Créer et exécuter un projet PHPixie sur macOS avec ServBay

PHPixie est un framework PHP léger et performant, conçu pour le développement rapide d'applications web. Il suit le modèle de conception HMVC (Hierarchical Model-View-Controller), offrant une structure de code épurée et une gestion efficace des traitements. PHPixie séduit de nombreux développeurs grâce à sa simplicité, sa flexibilité et ses excellentes performances.

Principales caractéristiques et avantages de PHPixie

Légèreté : Le noyau de PHPixie est particulièrement compact, n'incluant que les composants essentiels à l'application, ce qui assure un démarrage et une exécution rapides.
Hautes performances : Pensé pour l'efficacité, le framework gère les requêtes simultanées de façon optimale — idéal pour les applications exigeantes.
Facilité d’apprentissage : Grâce à une API claire et à une documentation complète, les développeurs apprennent à l'utiliser rapidement.
Grande flexibilité : Sa structure faiblement couplée permet de choisir et d’intégrer librement des bibliothèques ou composants tiers selon les besoins du projet.
Communauté active : Une communauté dynamique offre de nombreuses extensions tierces et des ressources de support riches.

PHPixie vous permet de créer efficacement des applications web à la fois performantes et fiables, du petit projet à la solution d'entreprise à grande échelle.

Créer et exécuter un projet PHPixie avec ServBay

Dans ce guide, nous vous montrons comment exploiter ServBay comme environnement de développement web local pour créer et lancer un projet PHPixie. Nous utiliserons l’environnement PHP et le gestionnaire de dépendances Composer intégrés à ServBay, ainsi que la fonctionnalité "Sites Web" pour configurer le serveur web. Quelques étapes simples suffiront pour accéder localement au projet et intégrer des bases de données/cache.

Prérequis

ServBay doit être installé et en cours d’exécution sur macOS. ServBay inclut PHP, Composer, divers systèmes de bases de données (MySQL, PostgreSQL, MongoDB, Redis, etc.) ainsi qu’un serveur web Caddy.
Savoir exécuter des commandes élémentaires en ligne de commande.

Créer un projet PHPixie

Chemin recommandé pour vos sites web

ServBay recommande de centraliser vos projets web locaux dans le dossier /Applications/ServBay/www, pour une gestion simplifiée et un contrôle optimal des autorisations d'accès.

Vérifier que Composer est installé : Composer est déjà préinstallé dans ServBay, inutile de l’ajouter manuellement. Ouvrez votre terminal et tapez composer --version pour confirmer sa présence.
Créer le dossier du projet : Dans le dossier racine suggéré par ServBay, créez un répertoire pour votre projet PHPixie et positionnez-vous dedans :
bash
```
cd /Applications/ServBay/www
mkdir servbay-phpixie-app
cd servbay-phpixie-app
```
1
2
3
Créer le projet PHPixie avec Composer : Dans le répertoire du projet, lancez la commande Composer pour récupérer l’exemple de projet PHPixie :
bash
```
composer create-project phpixie/project .
```
1
Composer téléchargera alors PHPixie et ses dépendances dans le dossier courant.

Configurer le serveur web

Utilisez la fonctionnalité Sites Web de ServBay pour configurer Caddy afin de pointer vers votre projet PHPixie.

Ouvrez l’interface de l’application ServBay.
Rendez-vous dans la liste Sites Web (Websites).
Cliquez sur Ajouter un nouveau site web.
Remplissez les informations de configuration :
- Nom : Par exemple Mon premier site PHPixie (il s’agit d’un identifiant interne à ServBay).
- Domaine : Par exemple servbay-phpixie-test.local (le nom de domaine local utilisé dans votre navigateur).
- Type de site web : Sélectionnez PHP.
- Version de PHP : Choisissez la version désirée, comme 8.3.
- Racine du site (Document Root) : Pointez vers le dossier web de votre projet : /Applications/ServBay/www/servbay-phpixie-app/web.
Pourquoi le dossier /web ?
Le fichier d’entrée de PHPixie est web/index.php. Pour la sécurité et par bonnes pratiques, la racine du serveur web doit pointer directement sur le dossier web et non sur la racine du projet. Cela évite l’accès par le web à des fichiers sensibles comme les configurations ou le dossier vendor.
Enregistrez la configuration. ServBay configurera automatiquement Caddy et mettra à jour le fichier hosts local (si nécessaire), pour que servbay-phpixie-test.local pointe sur votre instance ServBay.

Pour plus de détails, consultez Ajouter un premier site web.

Ajouter du code d’exemple

Ajoutons du code de démonstration au projet pour vérifier que tout fonctionne et illustrer l'intégration des bases de données et du cache.

Créer un contrôleur d’exemple : Ajoutez le fichier src/App/HTTP/Controller/Home.php. Créez le dossier si besoin.

php

<?php

namespace App\HTTP\Controller;

use PHPixie\HTTP\Request;
use PHPixie\Template;
use PHPixie\Database\Query; // Importation de la classe Query

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

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

    // Action pour la page d'accueil par défaut
    public function action_index(Request $request)
    {
        // Rendu du template assets/templates/app/home.php
        return $this->template->render('app:home');
    }

    // Action d’exemple Memcached
    public function action_memcached(Request $request)
    {
        $cache = $this->components->cache();
        $cache->set('key', 'Hello Memcached from ServBay!', 60); // Stocke les données, 60s de validité
        $value = $cache->get('key'); // Récupère les données
        return $this->response()->string($value); // Retourne une réponse texte
    }

    // Action d’exemple Redis
    public function action_redis(Request $request)
    {
        $redis = $this->components->redis();
        $redis->set('key', 'Hello Redis from ServBay!'); // Stocke les données
        $value = $redis->get('key'); // Récupère les données
        return $this->response()->string($value); // Retourne une réponse texte
    }

    // Action d’ajout d’utilisateur (MySQL/PostgreSQL)
    public function action_add_user(Request $request)
    {
        // Utilisation du composant DB pour obtenir le query builder
        $query = $this->components->database()->query();
        // Insertion d’un nouvel utilisateur dans la table 'users'
        $query->insert('users')->data([
            'name' => 'ServBay Demo User',
            'email' => 'demo-' . uniqid() . '@servbay.test', // Création d'un email unique
        ])->execute(); // Exécute l'insertion

        return $this->response()->string('Utilisateur ajouté avec succès.'); // Message de succès
    }

    // Action de récupération de la liste des utilisateurs (MySQL/PostgreSQL)
    public function action_list_users(Request $request)
    {
        // Utilisation du composant DB pour obtenir le query builder
        $query = $this->components->database()->query();
        // Sélection de tous les utilisateurs dans la table 'users'
        $users = $query->select('*')->from('users')->execute()->fetchAll(); // Exécute la requête

        return $this->response()->json($users); // Retourne la liste des utilisateurs en JSON
    }
}

Créer un template d’exemple : Ajoutez le fichier assets/templates/app/home.php. Créez le dossier si besoin.

php

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Bienvenue sur PHPixie avec 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>Bienvenue sur PHPixie avec ServBay</h1>
    <p>Cette page est générée dynamiquement par votre application PHPixie, exécutée sur ServBay.</p>

    <h2>Fonctionnalités de démonstration :</h2>
    <ul>
        <li><a href="/home/memcached">Tester Memcached</a></li>
        <li><a href="/home/redis">Tester Redis</a></li>
        <li><a href="/home/add_user">Ajouter un utilisateur à la base de données</a></li>
        <li><a href="/home/list_users">Lister les utilisateurs de la base de données</a></li>
    </ul>

    <p>Merci de vous assurer que les étapes de configuration des bases de données et du cache sont terminées.</p>

</body>
</html>

Accéder à votre site

Après avoir configuré le site ServBay et ajouté le code d’exemple, vous pouvez accéder au domaine configuré depuis votre navigateur :

Ouvrez un navigateur et visitez https://servbay-phpixie-test.local.
Vous devriez voir une page affichant "Bienvenue sur PHPixie avec ServBay", accompagnée de liens de démonstration.

En cas de problème d’accès, vérifiez que :

ServBay est bien lancé.
La configuration du site dans ServBay est correcte (domaine, type de site, racine du projet).
Le fichier hosts local résout correctement servbay-phpixie-test.local (géré automatiquement par ServBay la plupart du temps).
La version de PHP désirée est bien activée dans ServBay.

Exemple d'intégration base de données et cache

PHPixie intègre nativement plusieurs systèmes de base de données et solutions de cache. ServBay propose MySQL, PostgreSQL, Redis, Memcached, etc., que vous pouvez relier facilement à votre projet PHPixie.

Important : Avant toute opération sur la base de données, démarrez le service adapté (MySQL, PostgreSQL...) depuis ServBay et créez la base dédiée à votre projet (par exemple, servbay_phpixie_app). Utilisez les outils graphiques de gestion de base (Sequel Ace, Postico, TablePlus...) ou le client en ligne de commande. Par défaut, l'utilisateur est root et le mot de passe password (à ajuster selon vos paramètres ServBay).

Configurer la connexion à la base de données

Selon le moteur utilisé (MySQL ou PostgreSQL), éditez le fichier assets/config/database.php à la racine du projet. l’adresse ServBay par défaut est généralement 127.0.0.1.

Exemple pour MySQL (assets/config/database.php) :

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // La chaîne de connexion doit correspondre au moteur de base et à la config ServBay
        'connection' => 'mysql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Utilisateur par défaut ServBay
        'password'  => 'password', // Mot de passe par défaut (à adapter au besoin)
        'options'   => []
    ]
];

Exemple pour PostgreSQL (assets/config/database.php) :

php

<?php

return [
    'default' => [
        'driver'    => 'pdo',
        // La chaîne de connexion doit correspondre au moteur de base et à la config ServBay
        'connection' => 'pgsql:host=127.0.0.1;dbname=servbay_phpixie_app',
        'user'      => 'root', // Utilisateur par défaut ServBay
        'password'  => 'password', // Mot de passe par défaut (à adapter au besoin)
        'options'   => []
    ]
];

Créer les tables (migrations)

PHPixie fournit un outil en ligne de commande pour gérer les migrations de base (versionning du schéma SQL).

Ouvrez votre terminal : Placez-vous dans le dossier racine du projet :
bash
```
cd /Applications/ServBay/www/servbay-phpixie-app
```
1
Générez le fichier de migration : Utilisez l’outil CLI de PHPixie pour créer une migration destinée à la table users :
bash
```
php pixie generate:migration create_users_table
```
1
Un fichier PHP est créé dans assets/migrations avec un timestamp dans son nom.

Éditez le fichier de migration : Ouvrez le fichier généré (ex. YYYY_MM_DD_HHMMSS_create_users_table.php) et modifiez les méthodes up() et down() pour définir la table :

php

<?php

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

class CreateUsersTable extends Migration
{
    public function up()
    {
        // Création de la table 'users' via le schema builder
        $this->schema->create('users', function(Table $table) {
            $table->increments('id'); // Clé primaire auto-incrémentée
            $table->string('name'); // Colonne nom
            $table->string('email')->unique(); // Colonne email, unique
            $table->timestamps(); // colonnes created_at et updated_at
        });
    }

    public function down()
    {
        // Suppression de la table 'users'
        $this->schema->drop('users');
    }
}

Exécutez la migration : Depuis la racine du projet, lancez :
bash
```
php pixie migrate
```
1
Si tout fonctionne, vous verrez un message de migration réussie dans le terminal. Vérifiez avec vos outils de gestion que la table users a bien été créée dans la base de données servbay_phpixie_app.

Utilisation base de données relationnelle (MySQL/PostgreSQL)

Dans le contrôleur d’exemple src/App/HTTP/Controller/Home.php, les méthodes action_add_user et action_list_users montrent comment interagir avec MySQL ou PostgreSQL via le composant base de données de PHPixie.

Ajouter un utilisateur : Visitez https://servbay-phpixie-test.local/home/add_user pour insérer un utilisateur dans la table users.
Afficher les utilisateurs : Allez sur https://servbay-phpixie-test.local/home/list_users pour obtenir la liste des utilisateurs, au format JSON.

Configuration et utilisation de NoSQL (Memcached/Redis)

ServBay inclut Memcached et Redis, ainsi que les extensions PHP nécessaires. Il suffit de configurer PHPixie pour en bénéficier.

Configuration Memcached (assets/config/cache.php) :

Éditez ou créez le fichier assets/config/cache.php et ajoutez la configuration Memcached :

php

<?php

return [
    'default' => [
        'driver' => 'memcached',
        'servers' => [
            [
                'host'   => '127.0.0.1', // Adresse Memcached par défaut ServBay
                'port'   => 11211, // Port par défaut Memcached ServBay
                'weight' => 100,
            ],
        ],
    ],
];

Configuration Redis (assets/config/redis.php) :

Éditez ou créez le fichier assets/config/redis.php et ajoutez la configuration Redis :

php

<?php

return [
    'default' => [
        'hostname' => '127.0.0.1', // Adresse Redis par défaut ServBay
        'port'     => 6379, // Port par défaut Redis
        'timeout'  => 0,
        'database' => 0, // Index base Redis
    ],
];

Utilisation de Memcached/Redis :

Dans le contrôleur d’exemple src/App/HTTP/Controller/Home.php, les méthodes action_memcached et action_redis montrent comment exploiter le composant de cache de PHPixie (configurable pour Memcached ou Redis).

Tester Memcached : Rendez-vous sur https://servbay-phpixie-test.local/home/memcached pour écrire et lire une clé depuis Memcached.
Tester Redis : Visitez https://servbay-phpixie-test.local/home/redis pour faire de même avec Redis.

Veillez à ce que les services Memcached et Redis soient bien démarrés dans ServBay.

Conclusion

En suivant ce guide, vous avez créé, configuré et exécuté avec succès un projet PHPixie en environnement local macOS grâce à ServBay. Vous avez appris à utiliser Composer pour générer le projet, configurer un serveur web via la fonctionnalité Sites Web de ServBay, intégrer bases de données et caches, et vérifier leur fonctionnement.

ServBay simplifie grandement la mise en place d’un environnement PHP moderne afin de vous permettre de vous concentrer sur l'essentiel : le développement. Nous espérons que ce guide facilitera vos débuts avec PHPixie et ServBay pour vos futurs projets web !

Créer et exécuter un projet PHPixie sur macOS avec ServBay ​

Principales caractéristiques et avantages de PHPixie ​

Créer et exécuter un projet PHPixie avec ServBay ​

Prérequis ​

Créer un projet PHPixie ​

Configurer le serveur web ​

Ajouter du code d’exemple ​

Accéder à votre site ​

Exemple d'intégration base de données et cache ​

Configurer la connexion à la base de données ​

Créer les tables (migrations) ​

Utilisation base de données relationnelle (MySQL/PostgreSQL) ​

Configuration et utilisation de NoSQL (Memcached/Redis) ​

Conclusion ​