Créer et exécuter un projet Zend Framework (Laminas) avec ServBay

Vue d'ensemble

Zend Framework (désormais partie du Laminas Project) est un puissant framework PHP open source offrant une large gamme de composants orientés objet pour concevoir des applications et services web modernes. Il est reconnu pour sa flexibilité, son approche modulaire et ses hautes performances ; il s'agit d'un excellent choix pour des projets allant du simple site vitrine aux applications d'entreprise complexes.

ServBay est un environnement de développement web local spécialement conçu pour macOS, intégrant PHP, différents serveurs web (Caddy, Nginx), de nombreuses bases de données (MySQL, PostgreSQL, MongoDB), des outils de cache (Redis, Memcached) et bien d'autres utilitaires pour développeurs. Avec ServBay, configurer et gérer ces outils devient simple et intuitif, ce qui facilite considérablement l'installation et l'exécution de tout projet PHP localement.

Ce guide vous accompagne à travers la création, la configuration et l’exécution d’un projet Zend Framework (Laminas) sous ServBay, avec l’intégration pratique des bases de données et systèmes de cache proposés.

Prérequis

Avant de commencer, assurez-vous d'avoir réalisé les étapes suivantes :

Installation de ServBay : Vous avez installé et démarré ServBay sur votre système macOS. Si ce n'est pas déjà fait, rendez-vous sur le site officiel ServBay pour obtenir toutes les instructions.
Composants ServBay : Vérifiez que ServBay inclut et fait tourner les outils nécessaires :
- Au moins une version de PHP (PHP 8.x ou plus est recommandé, car les versions modernes de Zend Framework / Laminas le requièrent généralement).
- Un serveur web (Caddy ou Nginx).
- Composer (généralement inclus dans ServBay).
- Les services de base de données (par exemple MySQL, PostgreSQL) et de cache (comme Memcached, Redis) que vous souhaitez utiliser. Ceux-ci sont facilement activables via le panneau de contrôle ServBay.

Création du projet Zend Framework

ServBay recommande de regrouper vos projets web dans le dossier /Applications/ServBay/www, ce qui permet une gestion et une configuration automatique optimales.

Accéder au dossier racine du projet
Ouvrez l’application Terminal et placez-vous dans le dossier recommandé :
bash
```
cd /Applications/ServBay/www
```
1
Créer le projet avec Composer
ServBay est livré avec Composer préinstallé. Lancez la commande suivante pour créer un projet Zend Framework (Laminas skeleton application) dans un sous-dossier nommé servbay-zend-app :
bash
```
composer create-project laminas/laminas-skeleton-application servbay-zend-app
```
1
Cette commande télécharge l’application squelette Zend Framework (Laminas) ainsi que toutes ses dépendances dans le dossier servbay-zend-app.
Entrer dans le dossier du projet
Accédez au dossier créé :
bash
```
cd servbay-zend-app
```
1

Configuration du serveur web

Pour accéder à votre projet Zend Framework depuis un navigateur, une configuration de site web dans ServBay est requise.

Ouvrir le panneau de contrôle ServBay : Lancez l’application ServBay.
Accéder aux paramètres du site : Rendez-vous dans l’onglet Sites Web (Websites).
Ajouter un nouveau site : Cliquez sur le bouton + en bas à gauche pour ajouter une nouvelle configuration.
Renseigner les informations du site :
- Nom (Name) : Donnez un nom facilement identifiable, par exemple My Zend Dev Site.
- Domaine (Domain) : Entrez le domaine que vous souhaitez utiliser pour accéder au projet dans le navigateur ; pour éviter tout conflit avec les domaines réels, privilégiez une extension comme .local ou .test (par exemple servbay-zend-test.local). ServBay configurer automatiquement la résolution DNS pour ce domaine.
- Type de site (Website Type) : Choisissez PHP.
- Version de PHP (PHP Version) : Sélectionnez la version de PHP pour ce site (ex. 8.3). Assurez-vous que cette version est bien installée et active dans ServBay.
- Racine du site (Document Root) : Ce dossier doit pointer vers le dossier public de votre projet, où se trouve le fichier d’entrée index.php : /Applications/ServBay/www/servbay-zend-app/public.
Sauvegarder et redémarrer : Cliquez sur Sauvegarder (Save). ServBay vous proposera d’appliquer la modification et rechargera la configuration, activant ainsi votre nouveau site.

Pour les étapes détaillées, consultez la documentation ServBay, section Ajouter le premier site.

Exemple "Hello ServBay !" basique

Modifions le code du projet pour qu'il affiche "Hello ServBay !" à la racine (URL /).

Configurer la route et le contrôleur (module.config.php)

Modifiez le fichier module/Application/config/module.config.php à la racine de votre projet. Assurez-vous que la configuration de base pour la route et le contrôleur ressemble à :

php

<?php

declare(strict_types=1);

namespace Application;

use Laminas\Router\Http\Literal;
use Laminas\Router\Http\Segment;
use Laminas\ServiceManager\Factory\InvokableFactory;

return [
    'router' => [
        'routes' => [
            'home' => [
                'type'    => Literal::class,
                'options' => [
                    'route'    => '/',
                    'defaults' => [
                        'controller' => Controller\IndexController::class,
                        'action'     => 'index',
                    ],
                ],
            ],
            // ... autres routes
        ],
    ],
    'controllers' => [
        'factories' => [
            Controller\IndexController::class => InvokableFactory::class,
        ],
    ],
    'view_manager' => [
        'display_not_found_reason' => true,
        'display_exceptions'       => true,
        'doctype'                  => 'HTML5',
        'not_found_template'       => 'error/404',
        'exception_template'       => 'error/index',
        'template_map' => [
            'layout/layout'           => __DIR__ . '/../view/layout/layout.phtml',
            'application/index/index' => __DIR__ . '/../view/application/index/index.phtml',
            'error/404'               => __DIR__ . '/../view/error/404.phtml',
            'error/index'             => __DIR__ . '/../view/error/index.phtml',
        ],
        'template_path_stack' => [
            __DIR__ . '/../view',
        ],
    ],
    // ... autres paramètres
];

Remarque : Ce code représente la partie nécessaire du fichier module.config.php. Veillez à fusionner cette configuration avec celle déjà existante dans le fichier – la route 'home' et la définition du contrôleur doivent être présentes.

Créer/modifier le contrôleur (IndexController.php)

Modifiez ou créez le fichier module/Application/src/Controller/IndexController.php. Le but : que la méthode indexAction retourne une ViewModel contenant le message à afficher :

php

<?php

declare(strict_types=1);

namespace Application\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;

class IndexController extends AbstractActionController
{
    /**
     * Action par défaut pour afficher la page d'accueil.
     */
    public function indexAction()
    {
        // Retourne un ViewModel et transmet la variable 'message' à la vue
        return new ViewModel([
            'message' => 'Hello ServBay!',
        ]);
    }

    // ... autres actions
}

Créer/modifier la vue (index.phtml)
Modifiez ou créez le fichier module/Application/view/application/index/index.phtml. Cette vue affiche la variable transmise :
php
```
<h1><?php echo $this->message; ?></h1>
```
1
Ici, le helper de vue $this->message permet d’accéder à la variable disponible côté contrôleur.

Accéder au site

Ouvrez votre navigateur et tapez le domaine que vous avez configuré, par exemple https://servbay-zend-test.local.

Si tout est correctement configuré, la page affichera Hello ServBay! – signe que votre projet Zend Framework tourne localement dans ServBay.

Intégrer base de données & cache : exemples pratiques

ServBay propose plusieurs services de base de données et de cache. Voici comment connecter et utiliser Memcached, Redis, MySQL ou PostgreSQL au sein de votre application Zend Framework.

À noter : Ces exemples sont indépendants, à adapter à vos besoins réels. Typiquement, vous sélectionnerez un type de base de données et un ou plusieurs systèmes de cache, que vous gérerez via l'injection de dépendances. Assurez-vous d’avoir lancé chaque service concerné (MySQL, PostgreSQL, Memcached, Redis) dans ServBay.

Exemple de manipulation de base de données – Création de table

Démontrons comment manipuler la base avec le composant Laminas DB, incluant la création d’une table simple. Ce code illustre l’exécution manuelle de l’opération, sans utiliser l’outil complet Laminas Migrations.

Installer Laminas DB
Dans la racine de votre projet, installez le composant Laminas DB via Composer :
bash
```
composer require laminas/laminas-db
```
1
Créer la base de données manuellement
Avant d’exécuter l’exemple, créez à la main une base servbay_zend_app via les outils de gestion proposés par ServBay (phpMyAdmin, pgAdmin, MongoDB Compass, etc.). Le nom d’utilisateur MySQL/MariaDB par défaut est root, le mot de passe par défaut est password. Pour PostgreSQL : root / password aussi.

Définir et exécuter le script de création de table

Créez un fichier PHP (ex. create_users_table.php) et ajoutez le code suivant pour créer une table users :

php

<?php
// create_users_table.php
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Sql\Sql;

// Supposons que vous utilisez MySQL ou MariaDB
$adapter = new Adapter([
    'driver' => 'Pdo_Mysql', // ou 'Pdo_Pgsql'
    'database' => 'servbay_zend_app',
    'username' => 'root',
    'password' => 'password', // Mot de passe par défaut ServBay
    'hostname' => '127.0.0.1',
    // 'port' => 3306, // port MySQL
    // 'port' => 5432, // port PostgreSQL
]);

$sql = new Sql($adapter);

// Définir une requête pour créer la table users
$create = $sql->createTable('users')
              ->addColumn(new \Laminas\Db\Sql\Ddl\Column\Integer('id', false, null, ['AUTO_INCREMENT' => true]))
              ->addColumn(new \Laminas\Db\Sql\Ddl\Column\Varchar('name', 255))
              ->addColumn(new \Laminas\Db\Sql\Ddl\Column\Varchar('email', 255, ['UNIQUE' => true]))
              ->addConstraint(new \Laminas\Db\Sql\Ddl\Constraint\PrimaryKey('id'));

echo "Exécution SQL :\n";
echo $sql->buildSqlString($create, $adapter->getPlatform()) . "\n";

try {
    // Exécuter la requête
    $adapter->query(
        $sql->buildSqlString($create, $adapter->getPlatform()),
        Adapter::QUERY_MODE_EXECUTE
    );
    echo "Table 'users' créée avec succès.\n";
} catch (\Exception $e) {
    echo "Erreur lors de la création de la table : " . $e->getMessage() . "\n";
}

Remarque : Ceci est un script d'exemple à lancer manuellement. Dans la vraie vie, privilégiez plutôt l’outil Laminas Migrations pour gérer les versions du schéma.

Exécutez ce script via le terminal (en étant dans le dossier approprié) :

bash

php create_users_table.php

Exemple d'intégration MySQL

Exemple de connexion et de requête MySQL depuis un contrôleur Zend Framework.

Configurer la connexion à la base

Éditez le fichier config/autoload/global.php pour renseigner les informations de connexion MySQL :

php

<?php
// config/autoload/global.php
return [
    'db' => [
        'driver' => 'Pdo_Mysql',
        'database' => 'servbay_zend_app', // la base doit exister
        'username' => 'root', // utilisateur par défaut ServBay
        'password' => 'password', // mot de passe par défaut
        'hostname' => '127.0.0.1',
        'port' => 3306,
        'charset' => 'utf8mb4',
    ],
    // ... autres paramètres
];

Définir la factory pour le contrôleur (module.config.php)

Pour injecter Laminas\Db\Adapter\Adapter dans un contrôleur, définissez une factory pour IndexController dans module/Application/config/module.config.php :

php

<?php
// module/Application/config/module.config.php
namespace Application;

use Laminas\ServiceManager\Factory\InvokableFactory; // garder si utilisé ailleurs
use Laminas\Db\Adapter\AdapterInterface; // à ajouter

return [
    // ... autres paramètres
    'controllers' => [
        'factories' => [
            Controller\IndexController::class => function($container) {
                // Récupérer l'adaptateur DB depuis le Service Manager
                $adapter = $container->get(AdapterInterface::class);
                // Création du contrôleur, injection de l'adaptateur
                return new Controller\IndexController($adapter);
            },
            // Ajouter d'autres factories si nécessaire
        ],
    ],
    'service_manager' => [
        'aliases' => [
            // Lier Laminas\Db\Adapter\AdapterInterface à l'Adapter concret
            AdapterInterface::class => 'Laminas\Db\Adapter\Adapter',
        ],
        'factories' => [
            // Factory pour Laminas\Db\Adapter\Adapter
            'Laminas\Db\Adapter\Adapter' => \Laminas\Db\Adapter\AdapterServiceFactory::class,
        ],
    ],
    // ... autres paramètres
];

Note : Merge ces morceaux à la configuration existante – surtout la clé service_manager avec l’alias et la factory.

Configurer les routes (module.config.php)

Ajoutez de nouvelles routes pour les exemples MySQL :

php

<?php
// module/Application/config/module.config.php
namespace Application;

use Laminas\Router\Http\Literal;
// ... autres use

return [
    'router' => [
        'routes' => [
            // ... routes existantes
            'mysql-add' => [
                'type'    => Literal::class,
                'options' => [
                    'route'    => '/mysql-add',
                    'defaults' => [
                        'controller' => Controller\IndexController::class,
                        'action'     => 'mysqlAdd',
                    ],
                ],
            ],
            'mysql' => [
                'type'    => Literal::class,
                'options' => [
                    'route'    => '/mysql',
                    'defaults' => [
                        'controller' => Controller\IndexController::class,
                        'action'     => 'mysql',
                    ],
                ],
            ],
        ],
    ],
    // ... autres paramètres
];

Ajouter les méthodes au contrôleur (IndexController.php)

Modifiez module/Application/src/Controller/IndexController.php pour ajouter le constructeur et les méthodes d’action :

php

<?php

declare(strict_types=1);

namespace Application\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;
use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Db\Sql\Sql;

class IndexController extends AbstractActionController
{
    private $adapter;

    public function __construct(AdapterInterface $adapter)
    {
        $this->adapter = $adapter;
    }

    /**
     * Page d’accueil.
     */
    public function indexAction()
    {
        return new ViewModel([
            'message' => 'Hello ServBay!',
        ]);
    }

    /**
     * Ajouter un utilisateur en MySQL.
     */
    public function mysqlAddAction()
    {
        $sql = new Sql($this->adapter);
        $insert = $sql->insert('users')
                      ->values([
                          'name' => 'ServBay Demo User',
                          'email' => 'demo-mysql@servbay.test',
                      ]);

        $statement = $sql->prepareStatementForSqlObject($insert);
        $result = $statement->execute();

        $message = $result->getAffectedRows() > 0 ? 'Utilisateur MySQL ajouté avec succès.' : 'Échec de l’ajout de l’utilisateur MySQL.';

        return new ViewModel([
            'message' => $message,
        ]);
    }

    /**
     * Retourner tous les utilisateurs de la table users via MySQL.
     */
    public function mysqlAction()
    {
        $sql = new Sql($this->adapter);
        $select = $sql->select('users');

        $statement = $sql->prepareStatementForSqlObject($select);
        $result = $statement->execute();

        $users = [];
        foreach ($result as $row) {
            $users[] = $row;
        }

        return new ViewModel([
            'users' => json_encode($users, JSON_PRETTY_PRINT),
        ]);
    }

    // ... autres actions
}

Ajoutez ces méthodes/constructeur à la classe.

Créer les vues
module/Application/view/application/index/mysql-add.phtml :
php
```
<h1><?php echo $this->message; ?></h1>
```
1
module/Application/view/application/index/mysql.phtml :
php
```
<h1>Utilisateurs MySQL</h1>
<pre><?php echo $this->users; ?></pre>
```
1
2
Tester l'exemple MySQL
Vérifiez que MySQL tourne dans ServBay. Visitez https://servbay-zend-test.local/mysql-add pour ajouter un utilisateur (message de succès affiché), puis https://servbay-zend-test.local/mysql pour voir la liste (au format JSON).

Exemple d'intégration PostgreSQL

Intégration d'une base PostgreSQL dans Zend Framework.

Configurer la connexion PostgreSQL

Dans config/autoload/global.php (modifiez la clé 'db' pour PostgreSQL) :

php

<?php
// config/autoload/global.php
return [
    'db' => [
        'driver' => 'Pdo_Pgsql',
        'database' => 'servbay_zend_app',
        'username' => 'root',
        'password' => 'password',
        'hostname' => '127.0.0.1',
        'port' => 5432,
    ],
    // ... autres paramètres
];

Remarque : Pour utiliser MySQL et PostgreSQL simultanément, il faudra adapter la configuration ou bien gérer le multi-adaptateur.

Vérifier la factory du contrôleur
Comme pour MySQL, assurez-vous que la configuration de la factory injecte bien l'adaptateur désiré.

Ajouter les routes (module.config.php)

Ajoutez les routes PostgreSQL :

php

<?php
// module/Application/config/module.config.php
namespace Application;

use Laminas\Router\Http\Literal;

return [
    'router' => [
        'routes' => [
            // ... routes existantes
            'pgsql-add' => [
                'type'    => Literal::class,
                'options' => [
                    'route'    => '/pgsql-add',
                    'defaults' => [
                        'controller' => Controller\IndexController::class,
                        'action'     => 'pgsqlAdd',
                    ],
                ],
            ],
            'pgsql' => [
                'type'    => Literal::class,
                'options' => [
                    'route'    => '/pgsql',
                    'defaults' => [
                        'controller' => Controller\IndexController::class,
                        'action'     => 'pgsql',
                    ],
                ],
            ],
        ],
    ],
    // ... autres paramètres
];

Ajouter les méthodes au contrôleur

Dans module/Application/src/Controller/IndexController.php ajoutez :

php

<?php

declare(strict_types=1);

namespace Application\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;
use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Db\Sql\Sql;

class IndexController extends AbstractActionController
{
    private $adapter;

    public function __construct(AdapterInterface $adapter)
    {
        $this->adapter = $adapter;
    }

    // ... autres méthodes
    
    /**
     * Ajouter un utilisateur en PostgreSQL.
     */
    public function pgsqlAddAction()
    {
        $sql = new Sql($this->adapter);
        $insert = $sql->insert('users')
                      ->values([
                          'name' => 'ServBay Demo User',
                          'email' => 'demo-pgsql@servbay.test',
                      ]);

        $statement = $sql->prepareStatementForSqlObject($insert);
        $result = $statement->execute();

        $message = $result->getAffectedRows() > 0 ? 'Utilisateur PostgreSQL ajouté avec succès.' : 'Échec de l’ajout de l’utilisateur PostgreSQL.';

        return new ViewModel([
            'message' => $message,
        ]);
    }

    /**
     * Retourner tous les utilisateurs (PostgreSQL).
     */
    public function pgsqlAction()
    {
        $sql = new Sql($this->adapter);
        $select = $sql->select('users');

        $statement = $sql->prepareStatementForSqlObject($select);
        $result = $statement->execute();

        $users = [];
        foreach ($result as $row) {
            $users[] = $row;
        }

        return new ViewModel([
            'users' => json_encode($users, JSON_PRETTY_PRINT),
        ]);
    }
}

Créer les vues
module/Application/view/application/index/pgsql-add.phtml :
php
```
<h1><?php echo $this->message; ?></h1>
```
1
module/Application/view/application/index/pgsql.phtml :
php
```
<h1>Utilisateurs PostgreSQL</h1>
<pre><?php echo $this->users; ?></pre>
```
1
2
Tester PostgreSQL
Vérifiez que PostgreSQL fonctionne dans ServBay. Visitez https://servbay-zend-test.local/pgsql-add pour insérer un utilisateur, puis https://servbay-zend-test.local/pgsql pour lister.

Exemple d'intégration Memcached

Utilisation de Memcached pour le cache depuis un contrôleur Zend Framework.

Installer l’adaptateur Memcached

Modifiez votre composer.json ainsi :

json

// composer.json
{
    "require": {
        "laminas/laminas-skeleton-application": "^1.0",
        "laminas/laminas-cache-storage-adapter-memcached": "^2.0"
    }
}

Puis mettez à jour :

bash

composer update

L’extension PHP memcached est déjà présente dans ServBay.

Ajouter la route Memcached (module.config.php)

Ajoutez une route :

php

<?php
namespace Application;

use Laminas\Router\Http\Literal;

return [
    'router' => [
        'routes' => [
            // ... autres routes
            'memcached' => [
                'type'    => Literal::class,
                'options' => [
                    'route'    => '/memcached',
                    'defaults' => [
                        'controller' => Controller\IndexController::class,
                        'action'     => 'memcached',
                    ],
                ],
            ],
        ],
    ],
    // ... autres paramètres
];

Ajouter la méthode au contrôleur

Dans module/Application/src/Controller/IndexController.php :

php

<?php

declare(strict_types=1);

namespace Application\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;
use Laminas\Cache\StorageFactory;
use Laminas\Cache\Storage\StorageInterface;

class IndexController extends AbstractActionController
{
    // ... constructeur & autres méthodes

    /**
     * Démonstration Memcached.
     */
    public function memcachedAction()
    {
        // ServBay : Memcached sur 127.0.0.1:11211
        $cache = StorageFactory::factory([
            'adapter' => [
                'name'    => 'memcached',
                'options' => [
                    'servers' => [
                        ['127.0.0.1', 11211],
                    ],
                    'ttl' => 300,
                ],
            ],
            'plugins' => [
                'serializer',
                'exception_handler' => ['throw_exceptions' => false],
            ],
        ]);

        $cacheKey = 'my_memcached_data';
        $cachedData = $cache->getItem($cacheKey, $success);

        if (!$success) {
            $cachedData = 'Hello Memcached! (Donnée source, mise en cache le ' . date('Y-m-d H:i:s') . ')';
            $cache->setItem($cacheKey, $cachedData);
            $cachedData .= ' - CACHE MISS';
        } else {
            $cachedData .= ' - CACHE HIT';
        }

        return new ViewModel([
            'message' => $cachedData,
        ]);
    }
}

Créer la vue
module/Application/view/application/index/memcached.phtml :
php
```
<h1>Exemple Memcached</h1>
<p><?php echo $this->message; ?></p>
```
1
2
Tester Memcached
Vérifiez que le service Memcached est actif. Visitez https://servbay-zend-test.local/memcached — le premier chargement devra afficher "CACHE MISS", puis "CACHE HIT" lors des chargements suivants pendant la durée de vie du cache.

Exemple d'intégration Redis

Utiliser Redis comme cache ou stockage simple dans un contrôleur Zend Framework.

Installer l’adaptateur Redis

Modifiez votre composer.json ainsi :

json

// composer.json
{
    "require": {
        "laminas/laminas-skeleton-application": "^1.0",
        "laminas/laminas-cache-storage-adapter-redis": "^2.0",
        "ext-redis": "*"
    }
}

Puis lancez :

bash

composer update

L’extension PHP redis est déjà incluse dans ServBay.

Ajouter une route Redis (module.config.php)

Ajoutez une route à la configuration :

php

<?php
namespace Application;

use Laminas\Router\Http\Literal;

return [
    'router' => [
        'routes' => [
            // ... autres routes
            'redis' => [
                'type'    => Literal::class,
                'options' => [
                    'route'    => '/redis',
                    'defaults' => [
                        'controller' => Controller\IndexController::class,
                        'action'     => 'redis',
                    ],
                ],
            ],
        ],
    ],
    // ... autres paramètres
];

Ajouter la méthode au contrôleur

Dans module/Application/src/Controller/IndexController.php :

php

<?php

declare(strict_types=1);

namespace Application\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;
use Laminas\Cache\StorageFactory;
use Laminas\Cache\Storage\StorageInterface;

class IndexController extends AbstractActionController
{
    // ... constructeur & autres méthodes

    /**
     * Démonstration Redis.
     */
    public function redisAction()
    {
        // ServBay : Redis sur 127.0.0.1:6379
        $cache = StorageFactory::factory([
            'adapter' => [
                'name'    => 'redis',
                'options' => [
                    'server' => [
                        'host' => '127.0.0.1',
                        'port' => 6379,
                        // 'database' => 0,
                        // 'password' => null,
                    ],
                    'ttl' => 300,
                ],
            ],
             'plugins' => [
                'serializer',
                'exception_handler' => ['throw_exceptions' => false],
            ],
        ]);
        $cacheKey = 'my_redis_data';
        $cachedData = $cache->getItem($cacheKey, $success);

        if (!$success) {
            $cachedData = 'Hello Redis! (Donnée source, mise en cache le ' . date('Y-m-d H:i:s') . ')';
            $cache->setItem($cacheKey, $cachedData);
            $cachedData .= ' - CACHE MISS';
        } else {
            $cachedData .= ' - CACHE HIT';
        }

        return new ViewModel([
            'message' => $cachedData,
        ]);
    }
}

Créer la vue
module/Application/view/application/index/redis.phtml :
php
```
<h1>Exemple Redis</h1>
<p><?php echo $this->message; ?></p>
```
1
2
Tester Redis
Vérifiez que Redis fonctionne dans ServBay. Visitez https://servbay-zend-test.local/redis — le premier accès affichera "CACHE MISS", puis "CACHE HIT" si consulté à nouveau avant expiration du cache.

Conclusion

En suivant ce guide, vous avez installé, configuré et exécuté avec succès un projet Zend Framework (Laminas) dans l'environnement local ServBay. Vous savez maintenant comment configurer la fonctionnalité de site de ServBay pour faire pointer le serveur web vers le dossier public de votre projet, et comment intégrer et exploiter les bases de données (MySQL, PostgreSQL) et systèmes de cache (Memcached, Redis) proposés par ServBay.

Grâce à ServBay, la gestion de votre environnement de développement local devient simple ; vous pouvez vous concentrer sur le code et vos fonctionnalités métier. Avec sa vaste sélection de packages et ses configurations flexibles, ServBay vous permet de reproduire aisément un environnement de production en local, boostant ainsi votre productivité de développeur.

Créer et exécuter un projet Zend Framework (Laminas) avec ServBay ​

Vue d'ensemble ​

Prérequis ​

Création du projet Zend Framework ​

Configuration du serveur web ​

Exemple "Hello ServBay !" basique ​

Accéder au site ​

Intégrer base de données & cache : exemples pratiques ​

Exemple de manipulation de base de données – Création de table ​

Exemple d'intégration MySQL ​

Exemple d'intégration PostgreSQL ​

Exemple d'intégration Memcached ​

Exemple d'intégration Redis ​

Conclusion ​

Créer et exécuter un projet Zend Framework (Laminas) avec ServBay

Vue d'ensemble

Prérequis

Création du projet Zend Framework

Configuration du serveur web

Exemple "Hello ServBay !" basique

Accéder au site

Intégrer base de données & cache : exemples pratiques

Exemple de manipulation de base de données – Création de table

Exemple d'intégration MySQL

Exemple d'intégration PostgreSQL

Exemple d'intégration Memcached

Exemple d'intégration Redis

Conclusion