Créer et exécuter un projet ThinkPHP 8 avec ServBay

Ce guide vous explique comment utiliser ServBay, un environnement de développement web local puissant, pour créer, configurer et exécuter rapidement un projet PHP basé sur le framework ThinkPHP 8. ServBay propose une configuration PHP prête à l’emploi, des serveurs web (Caddy ou Nginx) et plusieurs bases de données, facilitant grandement la mise en place de projets ThinkPHP en local.

Qu’est-ce que ThinkPHP ?

ThinkPHP est un framework PHP open-source rapide et orienté objet, originaire de Chine. Il suit des principes de développement clairs et efficaces, offrant aux développeurs un ensemble d’outils pratiques pour construire des applications web modernes. Grâce à sa simplicité d’utilisation, ses nombreuses fonctionnalités (ORM puissant, routage flexible, moteur de template intégré, support du cache, etc.) et à sa grande communauté active, ThinkPHP est largement utilisé dans le développement PHP en Chine.

Principales fonctionnalités et avantages de ThinkPHP

• Simplicité et efficacité : Conception du framework claire, structure du code limpide, facile à comprendre et à maintenir, favorisant une productivité élevée.
• Richesse fonctionnelle : Prise en charge native des composants essentiels du développement web : architecture MVC, ORM, moteur de template, gestion de cache, session, authentification, protection des formulaires et plus encore.
• ORM puissant : Fournit un mapping objet-relation performant et intuitif, simplifiant la manipulation des bases de données.
• Routage flexible : Prise en charge de multiples définitions de routes pour gérer des structures d’URL complexes.
• Écosystème riche : Bibliothèques et extensions abondantes et une large communauté d’utilisateurs, facilitant l’accès à de nombreuses ressources.
• Mises à jour continues : Évolution rapide des versions, en phase avec les dernières pratiques PHP et tendances du développement web.

ThinkPHP convient aussi bien au développement de petits projets qu’à des applications web d’entreprise de grande ampleur.

Installer un projet ThinkPHP 8 avec ServBay

ServBay offre un environnement idéal pour le développement local d’un projet ThinkPHP 8, notamment :

• Plusieurs versions de PHP préinstallées avec les extensions courantes.
• Serveur web intégré (Caddy ou Nginx), permettant une configuration simple de vos sites.
• Services de base de données intégrés (MySQL, PostgreSQL, MongoDB, Redis, Memcached).
• Gestionnaire de dépendances Composer intégré.

Ce tutoriel vous montre comment exploiter ces atouts pour installer facilement votre projet ThinkPHP 8.

Prérequis

Avant de commencer, assurez-vous d’avoir effectué les étapes suivantes :

1. Téléchargez et installez ServBay sur votre système macOS ou Windows.
2. ServBay doit être en fonctionnement, avec la version PHP requise par ThinkPHP 8 (PHP 8.0 ou supérieure) et les services de base de données (MySQL, PostgreSQL, Redis, Memcached, etc.) activés. Vérifiez et démarrez ces services dans l’onglet « Packages » du panneau de contrôle ServBay.

Création du projet ThinkPHP

ServBay recommande d’organiser vos fichiers locaux de site web dans le dossier /Applications/ServBay/www pour une gestion optimale.

1. Vérifier l’installation de Composer

   ServBay installe Composer automatiquement, vous n’avez donc pas à le faire manuellement. Vérifiez l’installation dans le terminal ServBay en lançant la commande composer --version.

2. Créer un projet ThinkPHP avec Composer

   Ouvrez votre terminal macOS et exécutez la commande ci-dessous dans le dossier racine des sites ServBay pour créer un nouveau projet ThinkPHP 8 :

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

   Ceci crée un dossier servbay-thinkphp-app dans /Applications/ServBay/www et télécharge les fichiers de base et dépendances de ThinkPHP 8.

3. Accéder au dossier du projet

   Une fois le projet créé, allez dans le dossier correspondant :

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

Configuration initiale du projet

Après la création du projet, quelques réglages de base sont nécessaires.

1. Configurer la connexion à la base de données

   La configuration de la base de données se fait généralement dans le fichier config/database.php. Modifiez-le suivant la base de données activée dans ServBay.

   Voici un exemple pour utiliser le service MySQL par défaut de ServBay :

   <?php
   // config/database.php
   
   return [
       // Configuration de connexion à la base de données par défaut
       'default'         => env('database.driver', 'mysql'),
   
       // Paramètres de connexion aux différentes bases de données
       'connections'     => [
           'mysql' => [
               // Type de base de données
               'type'     => 'mysql',
               // Adresse du serveur
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nom de la base de données
               'database' => env('database.database', 'servbay_thinkphp_app'), // Il est conseillé de créer une base séparée pour chaque projet
               // Nom d'utilisateur
               'username' => env('database.username', 'root'),
               // Mot de passe
               'password' => env('database.password', 'password'), // Mot de passe par défaut ServBay, usage strictement local !
               // Port
               'hostport' => env('database.hostport', '3306'),
               // ... autres paramètres ...
           ],
           // ... autres connexions de base de données ...
       ],
   ];

   Attention :

   • Modifiez la valeur de database pour indiquer le nom réel de votre base (vous pouvez la créer via phpMyAdmin ou Adminer, par exemple servbay_thinkphp_app).
   • Le mot de passe par défaut du compte root ServBay est password. Utilisez-le seulement en local, jamais en production ! En production, privilégiez un mot de passe fort et créez un utilisateur aux permissions minimales.
   • Si vous gérez les variables d’environnement via un fichier .env, assurez-vous qu’il override les valeurs par défaut du config/database.php.

Configurer le serveur web

Le point d’entrée du framework ThinkPHP est public/index.php, et le framework repose sur des règles de réécriture URL. Comme la gestion des routes diffère de l’accès direct aux fichiers statiques, vous devez utiliser les règles de réécriture intégrées à ServBay.

Sélectionnez l’option ThinkPHP dans le menu déroulant des règles de réécriture sur l’interface de configuration du site, puis enregistrez les modifications.

Pour des instructions détaillées de configuration du site ServBay, consultez Ajouter un premier site web.

Ajouter du code d’exemple

Pour tester la configuration du site et le routage basique de ThinkPHP, nous allons créer une route et un contrôleur simples.

Éditez le fichier /Applications/ServBay/www/servbay-thinkphp-app/route/app.php, et ajoutez ce code pour définir une route GET :

<?php
// route/app.php

use think\facade\Route;

// Définir la route servbay, déclenche l’exécution de la fonction anonyme lors d'un accès à /servbay
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... autres routes ...

Accéder au site

Après ces étapes, ouvrez votre navigateur et accédez au domaine local et à la route définie :

https://thinkphp.servbay.demo/servbay

Si tout est configuré correctement, vous verrez s’afficher Hello ServBay! dans le navigateur. Votre projet ThinkPHP 8 fonctionne avec ServBay, et la configuration du serveur web et de PHP-FPM est opérationnelle.

Exemple de bases de données NoSQL

ServBay inclut plusieurs bases NoSQL telles que Memcached et Redis. ThinkPHP offre une couche d’abstraction cache qui intègre facilement ces services comme moteurs de cache.

Exemple Memcached

1. Installer l’extension Memcached

   L’extension Memcached pour PHP est préinstallée avec ServBay. Vérifiez simplement que le service Memcached est démarré depuis l’onglet « Packages » du panneau ServBay.

2. Configurer le cache Memcached

   Modifiez le fichier config/cache.php pour utiliser Memcached comme driver de cache :

   <?php
   // config/cache.php
   
   return [
       // Driver de cache par défaut
       'default' => env('cache.driver', 'memcached'),
   
       // Configuration des connexions au cache
       'stores'  => [
           'memcached' => [
               // Type de cache
               'type'       => 'memcached',
               // Liste des serveurs
               'host'       => '127.0.0.1', // Adresse par défaut Memcached ServBay
               'port'       => 11211, // Port par défaut Memcached ServBay
               'persistent' => false,
               'expire'     => 0,
               'timeout'    => 0,
               'prefix'     => '',
           ],
           // ... autres configurations de cache ...
       ],
   ];

3. Utiliser Memcached dans le code

   Dans un contrôleur ou un callback de route, utilisez la façade Cache de ThinkPHP :

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/memcached-example', function () {
       // Définir une valeur dans le cache, expiration en 600 secondes
       Cache::set('my_memcached_key', 'This value is from Memcached!', 600);
   
       // Récupérer la valeur en cache
       $value = Cache::get('my_memcached_key');
   
       return 'Value from Memcached: ' . $value;
   });

   Accédez à https://thinkphp.servbay.demo/memcached-example pour tester.

Exemple Redis

1. Installer l’extension Redis

   L’extension Redis pour PHP est préinstallée avec ServBay. Vérifiez que le service Redis est lancé dans l’onglet « Packages ».

2. Configurer le cache Redis

   Modifiez config/cache.php pour utiliser Redis comme moteur de cache :

   <?php
   // config/cache.php
   
   return [
       // Driver de cache par défaut
       'default' => env('cache.driver', 'redis'),
   
       // Configuration des connexions au cache
       'stores'  => [
           'redis' => [
               // Type de cache
               'type'       => 'redis',
               // Adresse du serveur
               'host'       => env('cache.host', '127.0.0.1'), // Adresse par défaut Redis ServBay
               // Port
               'port'       => env('cache.port', 6379), // Port par défaut Redis ServBay
               // Mot de passe (aucun mot de passe par défaut)
               'password'   => env('cache.password', ''), // Aucun mot de passe par défaut
               'select'     => 0,
               'timeout'    => 0,
               'expire'     => 0,
               'persistent' => false,
               'prefix'     => '',
           ],
           // ... autres configurations de cache ...
       ],
   ];

   Note : Par défaut, Redis sur ServBay n’a pas de mot de passe. Si vous en avez défini un, ajustez le champ password en conséquence.

3. Utiliser Redis dans le code

   Dans un contrôleur ou un callback de route, utilisez la façade Cache de ThinkPHP :

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/redis-example', function () {
       // Définir une valeur en cache, permanente (ou indiquez une durée en troisième paramètre)
       Cache::set('my_redis_key', 'Hello from Redis!');
   
       // Récupérer la valeur en cache
       $value = Cache::get('my_redis_key');
   
       return 'Value from Redis: ' . $value;
   });

   Allez sur https://thinkphp.servbay.demo/redis-example pour tester.

Exemple de bases de données relationnelles

ServBay intègre des bases de données comme MySQL et PostgreSQL. L’ORM ThinkPHP permet une interaction intuitive avec ces moteurs.

Utiliser l’outil de migration ThinkPHP

Gérez les évolutions du schéma de la base avec l’outil de migration, facilitant la collaboration et la gestion de versions.

1. Installer l’extension de migration

   Installez l’extension via Composer, depuis la racine du projet :

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

2. Créer un fichier de migration

   Utilisez l’outil CLI ThinkPHP pour générer un fichier de migration, par exemple pour la table users :

   php think migrate:create CreateUserTable

   Un fichier PHP sera généré dans database/migrations (ex. 20231027100000_create_user_table.php).

3. Éditer le fichier de migration

   Dans le dossier database/migrations, éditez le fichier pour définir la structure de la table users :

   <?php
   // database/migrations/YYYYMMDDHHMMSS_create_user_table.php
   
   use think\migration\Migrator;
   use think\migration\db\Column;
   
   class CreateUserTable extends Migrator
   {
       /**
        * Change Method.
        *
        * Écrire ici vos migrations réversibles.
        *
        * Plus d’informations ici :
        * http://docs.phinx.org/en/latest/migrations.html#the-change-method
        *
        * Les commandes suivantes sont supportées :
        *
        * createTable
        * renameTable
        * addColumn
        * addCustomColumn
        * renameColumn
        * addIndex
        * addForeignKey
        * createDatabase
        * renameDatabase
        * dropTable
        * dropColumn
        * dropIndex
        * dropForeignKey
        */
       public function change()
       {
           // Crée la table 'users'
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nom de l’utilisateur'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Adresse email'])
                 ->addIndex(['email'], ['unique' => true]) // Index unique
                 ->addTimestamps() // Ajoute les champs created_at et updated_at
                 ->create(); // Crée la table
       }
   
       // Possible aussi de définir séparément up() et down()
       /*
       public function up()
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nom de l’utilisateur'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Adresse email'])
                 ->addIndex(['email'], ['unique' => true])
                 ->addTimestamps()
                 ->create();
       }
   
       public function down()
       {
           $this->dropTable('users');
       }
       */
   }

4. Exécuter la migration

   Depuis le terminal ServBay, dans la racine du projet, lancez la commande :

   php think migrate:run

   Si tout fonctionne, la table users sera créée dans la base.

Exemple MySQL

Après avoir configuré et démarré le service MySQL dans ServBay, référez-vous aux exemples précédents pour le fichier config/database.php.

1. Configurer la connexion MySQL

   Vérifiez que la configuration MySQL dans config/database.php est correcte comme dans la section “Configuration initiale du projet”.

2. Insérer un utilisateur via le code

   Utilisez la façade Db ou l’ORM pour créer des données. Exemple avec la façade 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 exemple
               'created_at' => date('Y-m-d H:i:s'), // Ajout du timestamp
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'User added successfully!';
       } catch (\Exception $e) {
           return 'Error adding user: ' . $e->getMessage();
       }
   });

   Visitez https://thinkphp.servbay.demo/mysql-add-user pour tester l’ajout.

3. Lire les utilisateurs via le code

   Utilisez la façade Db pour afficher les utilisateurs :

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/mysql-users', function () {
       $users = Db::table('users')->select(); // Récupère tous les utilisateurs
       return json($users); // Retourne le résultat au format JSON
   });

   Visitez https://thinkphp.servbay.demo/mysql-users pour voir la liste.

Exemple PostgreSQL

Après avoir lancé le service PostgreSQL dans ServBay, configurez la connexion dans config/database.php :

1. Configurer la connexion PostgreSQL

   Dans config/database.php, ajoutez une section PostgreSQL similaire à celle-ci :

   <?php
   // config/database.php (extrait)
   
   return [
       // ... autres configurations ...
   
       'connections'     => [
           // ... config MySQL ...
   
           'pgsql' => [
               // Type de base de données
               'type'     => 'pgsql',
               // Adresse du serveur
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nom de la base
               'database' => env('database.database', 'servbay_thinkphp_app'), // Créez une base dédiée si possible
               // Nom d'utilisateur
               'username' => env('database.username', 'root'),
               // Mot de passe
               'password' => env('database.password', 'password'), // Mot de passe par défaut, local uniquement !
               // Port
               'hostport' => env('database.hostport', '5432'), // Port PostgreSQL par défaut
               // ... autres paramètres ...
           ],
           // ... autres connexions ...
       ],
   ];

   Attention :

   • Comme avec MySQL, créez une base PostgreSQL dédiée pour le projet et précisez-la dans la configuration.
   • Le mot de passe par défaut est password pour l’utilisateur root. Usage strictement local.

2. Insérer un utilisateur via le code (PostgreSQL)

   Utilisez la façade Db en spécifiant la connexion pgsql :

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-add-user', function () {
       try {
           Db::connect('pgsql')->table('users')->insert([ // Connexion pgsql
               'name' => 'ServBay PgSQL User',
               'email' => 'pgsql-demo@servbay.demo', // Email exemple
               // Les timestamps peuvent être renseignés selon la définition et la version 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();
       }
   });

   Rendez-vous sur https://thinkphp.servbay.demo/pgsql-add-user pour tester l’ajout.

3. Lire les utilisateurs via le code (PostgreSQL)

   Utilisez la façade Db avec la connexion pgsql :

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-users', function () {
       $users = Db::connect('pgsql')->table('users')->select(); // Connexion pgsql
       return json($users); // Format JSON
   });

   Rendez-vous sur https://thinkphp.servbay.demo/pgsql-users pour voir les données.

Conclusion

En suivant ces étapes, vous avez réussi à créer, configurer et exécuter un projet ThinkPHP 8 dans l’environnement local ServBay. Vous avez utilisé Composer pour générer le projet, configuré le serveur web Caddy pour gérer les routes ThinkPHP et connecté divers services de bases de données tels que MySQL, PostgreSQL, Memcached et Redis.

ServBay simplifie radicalement la mise en place d’un environnement pour frameworks PHP comme ThinkPHP, vous permettant de vous concentrer sur le développement métier. Vous pouvez poursuivre l’implémentation de votre application ThinkPHP en tirant parti de l’écosystème ServBay et de toutes ses fonctionnalités.