Créer et exécuter un projet ThinkPHP 8 avec ServBay
Ce guide vous accompagne pas à pas pour créer, configurer et exécuter rapidement un projet PHP basé sur le framework ThinkPHP 8 à l'aide de ServBay, un environnement local puissant de développement web. ServBay propose un environnement PHP pré-configuré, un serveur web (Caddy ou Nginx) ainsi que de multiples bases de données, simplifiant considérablement la mise en place d’un projet ThinkPHP en local.
Qu’est-ce que ThinkPHP ?
ThinkPHP est un framework PHP open-source, orienté objet, rapide et simple, initialement développé en Chine. Fidèle à une philosophie de simplicité et d'efficacité, il vise à fournir aux développeurs une boîte à outils pratique pour la création d'applications web modernes. Grâce à sa facilité d’utilisation, ses fonctionnalités riches (ORM puissant, routage flexible, moteur de templates intégré, gestion du cache, etc.) et le soutien d’une communauté active, ThinkPHP est largement adopté dans le secteur PHP en Chine.
Principales fonctionnalités et avantages de ThinkPHP
- Simplicité et efficacité : Un design épuré, une architecture claire, facile à comprendre et à maintenir et une productivité accrue.
- Fonctionnalités complètes : Intègre tous les composants courants du développement web, tels que l'architecture MVC, l'ORM, un moteur de templates, le cache, la gestion des sessions, l’authentification, la protection contre les CSRF, etc.
- ORM puissant : Fournit un mapping objet-relationnel très simple d’usage, facilitant les opérations sur les bases de données.
- Routage flexible : Supporte de multiples modes de définition des routes pour répondre à toutes les exigences en matière d’URL.
- Écosystème riche : Grand nombre de bibliothèques et plugins, ainsi qu'une vaste communauté de développeurs très active.
- Évolution continue : Mises à jour fréquentes pour rester en phase avec l’évolution de PHP et les tendances du web.
ThinkPHP répond aux besoins de développement web de toutes tailles, des petits projets jusqu’aux applications d'entreprise à grande échelle.
Déployer un projet ThinkPHP 8 avec ServBay
ServBay offre un environnement idéal pour le développement local d’un projet ThinkPHP 8, incluant :
- Plusieurs versions de PHP préinstallées avec les extensions courantes.
- Serveur web intégré (Caddy ou Nginx) facile à configurer.
- Services de bases de données intégrés : MySQL, PostgreSQL, MongoDB, Redis, Memcached, etc.
- Gestionnaire de dépendances Composer intégré.
Ce guide exploite ces atouts pour vous aider à mettre en place rapidement votre projet ThinkPHP 8.
Prérequis
Avant de commencer, assurez-vous d’avoir :
- Téléchargé et installé ServBay sur macOS.
- Démarré ServBay, avec la version de PHP nécessaire (ThinkPHP 8 requiert PHP 8.0 ou supérieur) ainsi que les services de base de données requis (MySQL, PostgreSQL, Redis, Memcached, etc.) actifs. Vérifiez et démarrez-les dans l’onglet « Packages » du tableau de bord ServBay.
Créer un projet ThinkPHP
Il est recommandé de stocker tous vos sites web locaux dans le dossier /Applications/ServBay/www pour une gestion optimale par ServBay.
Vérifier que Composer est installé
Composer est préinstallé avec ServBay : aucune action supplémentaire n’est donc nécessaire. Vérifiez-le dans le terminal ServBay avec la commande
composer --version.Créer un projet ThinkPHP avec Composer
Ouvrez le terminal macOS et exécutez les commandes suivantes dans le répertoire racine de vos sites ServBay :
bashcd /Applications/ServBay/www composer create-project topthink/think servbay-thinkphp-app1
2Ceci créera un nouveau dossier
servbay-thinkphp-appdans/Applications/ServBay/wwwet téléchargera l’ensemble du framework ThinkPHP 8 ainsi que ses dépendances.Entrer dans le dossier du projet
Une fois le projet créé, accédez à son dossier :
bashcd /Applications/ServBay/www/servbay-thinkphp-app1
Première configuration du projet
Une fois le projet en place, quelques configurations sont nécessaires.
Configurer les informations de connexion à la base de données
Les paramètres se trouvent généralement dans
config/database.php. Modifiez ce fichier selon la base de données que vous avez démarrée sous ServBay.Exemple de configuration pour le service MySQL par défaut de ServBay :
php<?php // config/database.php return [ // Configuration de la connexion utilisée par défaut 'default' => env('database.driver', 'mysql'), // Configurations de connexion pour chaque base 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 'database' => env('database.database', 'servbay_thinkphp_app'), // Préférez une base distincte par 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 local uniquement ! // Port 'hostport' => env('database.hostport', '3306'), // ... autres paramètres ... ], // ... autres connexions ... ], ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27Conseils importants :
- Modifiez la valeur de
databasepour indiquer le nom réel de la base que vous avez créée pour ce projet (par ex. via phpMyAdmin ou Adminer dans ServBay). - Le mot de passe par défaut de l’utilisateur
rootsous ServBay estpassword. N’utilisez jamais ce mot de passe en production ! Utilisez-le uniquement pour du développement local. Prévoyez des mots de passe forts et des utilisateurs aux droits restreints en production. - Si vous gérez des variables d'environnement via un fichier
.env, assurez-vous que ses valeurs prennent le dessus sur celles deconfig/database.php.
- Modifiez la valeur de
Configurer le serveur web
Le point d'entrée du framework ThinkPHP est public/index.php, ce qui nécessite l’utilisation de règles de réécriture d’URL spécifiques : ThinkPHP utilise des routes différentes des accès directs à des fichiers statiques. Utilisez donc la règle « ThinkPHP » dans le menu déroulant des règles Rewrite de ServBay, puis sauvegardez.
Pour plus de détails, voir la section Ajouter un premier site.
Ajouter un exemple de code
Pour vérifier votre configuration et tester le routage ThinkPHP, ajoutez une route et un contrôleur simples à votre projet.
Éditez /Applications/ServBay/www/servbay-thinkphp-app/route/app.php et ajoutez :
php
<?php
// route/app.php
use think\facade\Route;
// Définir la route servbay : accessible sur /servbay, exécute une fonction anonyme
Route::get('servbay', function () {
return 'Hello ServBay!';
});
// ... autres routes ...1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
Tester l'accès au site
Après cela, ouvrez votre navigateur et rendez-vous à l’URL locale configurée :
https://thinkphp.servbay.demo/servbay
Si tout est correct, vous verrez s’afficher Hello ServBay!. Cela confirme que votre projet ThinkPHP 8 tourne bien dans l’environnement ServBay, et que la configuration du serveur web et de PHP-FPM fonctionne.
Exemple de bases de données NoSQL
ServBay propose par défaut plusieurs bases NoSQL telles que Memcached et Redis. ThinkPHP offre une couche d’abstraction pour intégrer facilement ces services comme moteurs de cache.
Exemple Memcached
Installation de l’extension Memcached
L’extension Memcached est préinstallée dans ServBay. Assurez-vous que le service Memcached est démarré dans l’onglet « Packages ».
Configuration du cache Memcached
Modifiez
config/cache.phppour utiliser Memcached comme moteur de cache :php<?php // config/cache.php return [ // Pilote de cache par défaut 'default' => env('cache.driver', 'memcached'), // Connexions de cache 'stores' => [ 'memcached' => [ // Type de cache 'type' => 'memcached', // Liste des serveurs 'host' => '127.0.0.1', // Adresse par défaut de Memcached ServBay 'port' => 11211, // Port par défaut de Memcached ServBay 'persistent' => false, 'expire' => 0, 'timeout' => 0, 'prefix' => '', ], // ... autres caches ... ], ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23Utiliser Memcached dans le code
Utilisez la façade
Cachede ThinkPHP dans votre contrôleur ou route :php<?php use think\facade\Cache; use think\facade\Route; Route::get('/memcached-example', function () { // Définir une valeur en cache pour 600 secondes Cache::set('my_memcached_key', 'This value is from Memcached!', 600); // Récupérer la valeur du cache $value = Cache::get('my_memcached_key'); return 'Value from Memcached: ' . $value; });1
2
3
4
5
6
7
8
9
10
11
12
13Visitez
https://thinkphp.servbay.demo/memcached-examplepour tester.
Exemple Redis
Installation de l’extension Redis
Redis est également préinstallé avec ServBay. Vérifiez que le service Redis est actif dans l’onglet « Packages ».
Configuration du cache Redis
Modifiez
config/cache.phppour utiliser Redis :php<?php // config/cache.php return [ // Pilote de cache par défaut 'default' => env('cache.driver', 'redis'), // Connexions de cache 'stores' => [ 'redis' => [ // Type de cache 'type' => 'redis', // Adresse serveur 'host' => env('cache.host', '127.0.0.1'), // Adresse Redis par défaut ServBay // Port 'port' => env('cache.port', 6379), // Port Redis par défaut // Mot de passe (aucun par défaut ServBay) 'password' => env('cache.password', ''), // Pas de mot de passe par défaut 'select' => 0, 'timeout' => 0, 'expire' => 0, 'persistent' => false, 'prefix' => '', ], // ... autres caches ... ], ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27Remarque : La configuration par défaut de Redis dans ServBay ne prévoit pas de mot de passe. Si vous en avez défini un manuellement, renseignez le champ
passworden conséquence.Utiliser Redis dans le code
Utilisez la façade
Cachede ThinkPHP :php<?php use think\facade\Cache; use think\facade\Route; Route::get('/redis-example', function () { // Stocker en cache (permanent ou préciser la durée en 3ème paramètre) Cache::set('my_redis_key', 'Hello from Redis!'); // Récupérer la valeur $value = Cache::get('my_redis_key'); return 'Value from Redis: ' . $value; });1
2
3
4
5
6
7
8
9
10
11
12
13Testez à l’adresse
https://thinkphp.servbay.demo/redis-example.
Exemple avec base de données relationnelle
ServBay intègre MySQL et PostgreSQL et ThinkPHP offre un ORM puissant pour interagir facilement.
Utilisation de l’outil de migration de ThinkPHP
La gestion des migrations permet à toute l’équipe de suivre les évolutions de la structure de la base en toute simplicité.
Installation de l’extension de migration
Depuis le répertoire du projet, installez l’extension ThinkPHP adéquate via Composer :
bashcd /Applications/ServBay/www/servbay-thinkphp-app composer require topthink/think-migration1
2Générer un fichier de migration
Créez un nouveau fichier de migration, par exemple pour une table
users:bashphp think migrate:create CreateUserTable1Cela créera un fichier PHP dans
database/migrations(nommé avec un timestamp, ex :20231027100000_create_user_table.php).Éditer le fichier de migration
Dans le répertoire
database/migrations, ouvrez et éditez la méthodeup()du fichier nouvellement créé :php<?php // database/migrations/YYYYMMDDHHMMSS_create_user_table.php use think\migration\Migrator; use think\migration\db\Column; class CreateUserTable extends Migrator { /** * Méthode de migration réversible. * Consultez http://docs.phinx.org/en/latest/migrations.html#the-change-method */ public function change() { // Créer 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 sur email ->addTimestamps() // Ajoute les champs created_at et updated_at ->create(); // Création effective } // Vous pouvez aussi définir up() et down() séparément /* 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'); } */ }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41Lancer la migration dans ServBay
Dans le terminal, placez-vous dans le dossier du projet et exécutez :
bashphp think migrate:run1Si tout est correct, la table
usersest créée dans la base de données.
Exemple MySQL
Supposons que MySQL soit actif sous ServBay et la connexion MySQL configurée dans config/database.php (voir plus haut).
Configurer la connexion MySQL
Reportez-vous à l’exemple de configuration MySQL précédent et vérifiez que les informations sont correctes.
Insertion de données utilisateur dans le code
Utilisez la façade
Dbou le modèle ORM pour insérer des données :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' => 'demo@servbay.demo', // Email démo 'created_at' => date('Y-m-d H:i:s'), // Ajout manuel du timestamp si besoin 'updated_at' => date('Y-m-d H:i:s'), ]); return 'User added successfully!'; } catch (\Exception $e) { return 'Error adding user: ' . $e->getMessage(); } });1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17Accédez à
https://thinkphp.servbay.demo/mysql-add-userpour tester l’insertion.Lecture des données utilisateur
Pour récupérer les données utilisateur en JSON :
php<?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 });1
2
3
4
5
6
7
8Rendez-vous sur
https://thinkphp.servbay.demo/mysql-userspour afficher les utilisateurs.
Exemple PostgreSQL
Supposons que PostgreSQL soit actif dans ServBay, avec la connexion configurée.
Paramétrer la connexion PostgreSQL
Dans
config/database.php(adaptez si besoin) :php<?php // config/database.php (extrait) return [ // ... autres configurations ... 'connections' => [ // ... config MySQL ... 'pgsql' => [ // Type de base de données 'type' => 'pgsql', // Adresse serveur 'hostname' => env('database.hostname', '127.0.0.1'), // Nom base 'database' => env('database.database', 'servbay_thinkphp_app'), // Créez une base dédiée // Utilisateur 'username' => env('database.username', 'root'), // Mot de passe 'password' => env('database.password', 'password'), // Pour développement local uniquement ! // Port 'hostport' => env('database.hostport', '5432'), // Port par défaut PostgreSQL // ... autres options ... ], // ... autres connexions ... ], ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27Conseils importants :
- Comme pour MySQL, créez une base PostgreSQL dédiée pour ce projet.
- Mot de passe par défaut sous ServBay :
password, à utiliser exclusivement en local.
Ajouter un utilisateur dans le code
Insérez des données en spécifiant
pgsql:php<?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 démo // Les champs de timestamps peuvent nécessiter un ajout manuel '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(); } });1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18Testez sur
https://thinkphp.servbay.demo/pgsql-add-user.Récupérer les utilisateurs PostgreSQL
Pour lire les données côté PostgreSQL :
php<?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); });1
2
3
4
5
6
7
8Allez sur
https://thinkphp.servbay.demo/pgsql-userspour voir les résultats.
Conclusion
En suivant ce guide, vous avez appris à utiliser l’environnement local ServBay pour créer, configurer et exécuter un projet ThinkPHP 8, à démarrer un projet avec Composer, à configurer le serveur web Caddy pour les routes ThinkPHP, et à connecter votre application aux services MySQL, PostgreSQL, Memcached et Redis intégrés à ServBay.
Grâce à ServBay, la configuration d’environnements locaux pour des frameworks comme ThinkPHP devient un jeu d’enfant. Vous pouvez ainsi vous concentrer sur le développement métier de votre application, en tirant parti de tout l’écosystème et des fonctionnalités offertes par ServBay.