Créer et exécuter un projet CodeIgniter

Qu'est-ce que CodeIgniter ?

CodeIgniter est un framework PHP léger et performant pour le développement d’applications web. Il suit le modèle d’architecture Model-View-Controller (MVC), et est conçu pour aider les développeurs à créer rapidement des applications web riches en fonctionnalités. CodeIgniter est apprécié pour sa structure épurée, ses excellentes performances et sa facilité d’apprentissage, faisant de lui un choix privilégié chez de nombreux développeurs PHP.

Principales caractéristiques et avantages de CodeIgniter

Noyau léger : Le système central de CodeIgniter est très compact, n’incluant que les composants essentiels à l’exécution, ce qui garantit une vitesse de chargement élevée.
Excellentes performances : Le framework est conçu pour l’efficacité et peut gérer un nombre élevé de requêtes simultanées avec de très bonnes performances applicatives.
Prise en main facile : Une documentation claire et des API intuitives facilitent l’apprentissage et permettent une montée en compétence rapide.
Grande flexibilité : Les développeurs peuvent choisir et intégrer librement des bibliothèques tierces selon les besoins du projet, permettant extensions et personnalisations aisées.
Communauté active : Une grande communauté dynamique offre de nombreuses ressources et un bon support.

CodeIgniter convient aussi bien aux petits projets qu’aux applications d’entreprise de grande envergure, aidant les développeurs à réaliser des solutions web fiables et qualitatives.

Installer un environnement de développement CodeIgniter avec ServBay

ServBay est un outil d’environnement de développement web local conçu pour macOS, intégrant PHP, des bases de données (MySQL, PostgreSQL, MongoDB), des solutions de cache (Redis, Memcached), des serveurs web (Caddy, Nginx, Apache), ainsi qu’une interface de gestion conviviale. Avec ServBay, il devient simple de configurer et de gérer l’environnement nécessaire à CodeIgniter.

Ce guide vous expliquera comment utiliser l’environnement PHP et la fonctionnalité Sites de ServBay pour créer, configurer et exécuter un projet CodeIgniter, et illustrera l’intégration de divers systèmes de base de données et de cache.

Prérequis

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

ServBay est bien installé et fonctionne sur votre macOS.
La version de PHP que vous souhaitez utiliser (ex : PHP 8.3) est activée dans ServBay.
Les paquets de base de données et de cache requis (ex : MySQL, PostgreSQL, Redis, Memcached) sont activés dans ServBay.

Création d’un projet CodeIgniter

ServBay recommande de centraliser vos sites web dans le dossier /Applications/ServBay/www, ce qui facilite la gestion des sites locaux par ServBay.

Installer Composer
Composer est déjà inclus avec ServBay, il n’est donc généralement pas nécessaire de l’installer séparément. Vous pouvez utiliser la commande composer directement dans le terminal.
Accéder au répertoire racine des sites
Ouvrez le terminal et placez-vous dans le répertoire racine recommandé :
bash
```
cd /Applications/ServBay/www
```
1
Créer un projet CodeIgniter
Utilisez Composer pour créer un nouveau projet CodeIgniter 4. Nommez le dossier du projet servbay-codeigniter-app :
bash
```
composer create-project codeigniter4/appstarter servbay-codeigniter-app
```
1
Composer téléchargera l’application squelette CodeIgniter et ses dépendances dans le dossier servbay-codeigniter-app.
Accéder au dossier du projet
Entrez dans le répertoire de votre nouveau projet :
bash
```
cd /Applications/ServBay/www/servbay-codeigniter-app
```
1

Configuration initiale

Configurer la connexion à la base de données

La configuration des bases de données de CodeIgniter se trouve dans le fichier app/Config/Database.php. Avant toute utilisation de la base, vous devez définir les informations de connexion dans ce fichier.

D’abord, si vous prévoyez d’utiliser une base de données, créez dans ServBay (via un outil comme Adminer ou phpMyAdmin, accessibles via l’interface ServBay) une base nommée servbay_codeigniter_app.

Ensuite, éditez le fichier app/Config/Database.php, localisez le tableau $default et remplissez les informations de connexion selon le type de base activé (ex : MySQL ou PostgreSQL). Par défaut, le nom d’utilisateur et le mot de passe ServBay sont souvent root et password.

Voici un exemple de configuration MySQL :

php

public $default = [
    'DSN'      => '',
    'hostname' => '127.0.0.1', // La base de données ServBay écoute généralement sur 127.0.0.1
    'username' => 'root',     // Nom d'utilisateur par défaut de ServBay
    'password' => 'password', // Mot de passe par défaut de ServBay
    'database' => 'servbay_codeigniter_app', // Nom de votre base de données
    'DBDriver' => 'MySQLi',   // Selon le type de base, MySQL utilise MySQLi ou PDO
    'DBPrefix' => '',
    'pConnect' => false,
    'DBDebug'  => (ENVIRONMENT !== 'production'),
    'charset'  => 'utf8mb4',
    'DBCollat' => 'utf8mb4_general_ci',
    'swapPre'  => '',
    'encrypt'  => false,
    'compress' => false,
    'strictOn' => false,
    'failover' => [],
    'port'     => 3306,       // Port par défaut MySQL
];

Pour PostgreSQL, définissez DBDriver sur 'Postgre', le port sur 5432, et adaptez éventuellement le charset.

Configurer le cache (Memcached/Redis)

Si vous souhaitez utiliser Memcached ou Redis comme cache, configurez-les dans le fichier app/Config/Cache.php.

Modifiez app/Config/Cache.php et trouvez la section correspondante. Par défaut, Memcached de ServBay écoute sur 11211 et Redis sur 6379, sans mot de passe.

Exemple de configuration Memcached :

php

public $memcached = [
    'host'   => '127.0.0.1', // Memcached de ServBay écoute généralement sur 127.0.0.1
    'port'   => 11211,      // Port par défaut Memcached
    'weight' => 1,
];

Exemple de configuration Redis :

php

public string $handler = 'redis'; // Définit le gestionnaire de cache par défaut sur redis

public $default = [ // La configuration Redis se fait généralement dans ce tableau
    'host'     => '127.0.0.1', // Redis de ServBay écoute sur 127.0.0.1
    'password' => null,       // Par défaut, pas de mot de passe
    'port'     => 6379,       // Port par défaut Redis
    'timeout'  => 0,
    'database' => 0,
];

Veillez à configurer uniquement les sections correspondant aux paquets de cache activés.

Configuration du serveur web (paramètres site ServBay)

Utilisez la fonction Sites de ServBay pour configurer le serveur web afin de pointer vers votre projet CodeIgniter.

Ouvrez l’interface de l’application ServBay.
Allez à l’onglet Sites (Websites).
Cliquez sur le bouton + en bas à gauche pour ajouter un nouveau site.
Remplissez les informations du site :
- Nom (Name) : Saisissez un nom descriptif, par exemple My First CodeIgniter Dev Site.
- Domaine (Domain) : Entrez le domaine que vous souhaitez utiliser localement, par ex. servbay-codeigniter-test.local. ServBay résoudra automatiquement les domaines .local en localhost.
- Type de site (Site Type) : Sélectionnez PHP.
- Version de PHP (PHP Version) : Choisissez la version désirée, ex. 8.3.
- Racine du site (Document Root) : C'est crucial. Le fichier d’entrée de CodeIgniter (index.php) se trouve dans le dossier public à la racine du projet. La racine du site doit donc être définie sur le dossier public de votre projet : /Applications/ServBay/www/servbay-codeigniter-app/public.
Cliquez sur Ajouter (Add) pour sauvegarder.
ServBay vous demandera peut-être de valider les modifications, acceptez.

Pour des étapes détaillées, consultez Ajouter son premier site.

Ajouter du code exemple

Pour vérifier le bon fonctionnement du projet et tester la connexion à la base de données et au cache, modifiez le contrôleur Home fourni par défaut par CodeIgniter pour y ajouter quelques méthodes d’exemple.

Éditez app/Controllers/Home.php et remplacez son contenu par :

php

<?php

namespace App\Controllers;

use CodeIgniter\Controller;
use CodeIgniter\Database\Exceptions\DatabaseException; // Importation des exceptions de base de données
use CodeIgniter\Cache\Exceptions\CacheException; // Importation des exceptions de cache

class Home extends Controller
{
    /**
     * Méthode d'accueil par défaut
     */
    public function index(): string
    {
        // Retourne un message de bienvenue simple
        return '<h1>Hello ServBay and CodeIgniter!</h1><p>Votre projet CodeIgniter fonctionne sur ServBay.</p>';
    }

    /**
     * Exemple Memcached
     */
    public function memcached(): string
    {
        try {
            $cache = \Config\Services::cache();

            // Tente d’écrire dans le cache
            $success = $cache->save('servbay_memcached_key', 'Hello Memcached from CodeIgniter!', 60); // Cache 60 secondes

            if (!$success) {
                 return 'Erreur : Impossible d\'enregistrer les données dans Memcached. Vérifiez le service et la configuration Memcached.';
            }

            // Tente de lire depuis le cache
            $value = $cache->get('servbay_memcached_key');

            if ($value === null) {
                return 'Erreur : Impossible de lire les données depuis Memcached. Le cache a peut-être expiré ou le service est indisponible.';
            }

            return 'Test Memcached réussi : ' . $value;

        } catch (CacheException $e) {
            // Capture des exceptions liées au cache
            return 'Erreur de cache : ' . $e->getMessage() . '. Vérifiez que le service Memcached fonctionne et que la configuration est correcte.';
        } catch (\Exception $e) {
            // Capture d'autres exceptions potentielles
            return 'Une erreur inattendue est survenue : ' . $e->getMessage();
        }
    }

    /**
     * Exemple Redis
     */
    public function redis(): string
    {
        try {
            $cache = \Config\Services::cache();

            // Tente d’écrire dans le cache
            $success = $cache->save('servbay_redis_key', 'Hello Redis from CodeIgniter!', 60); // Cache 60 secondes

             if (!$success) {
                 return 'Erreur : Impossible d\'enregistrer les données dans Redis. Vérifiez le service et la configuration Redis.';
            }

            // Tente de lire depuis le cache
            $value = $cache->get('servbay_redis_key');

             if ($value === null) {
                return 'Erreur : Impossible de lire les données depuis Redis. Le cache a peut-être expiré ou le service est indisponible.';
            }

            return 'Test Redis réussi : ' . $value;

        } catch (CacheException $e) {
             // Capture des exceptions liées au cache
            return 'Erreur de cache : ' . $e->getMessage() . '. Vérifiez que le service Redis fonctionne et que la configuration est correcte.';
        } catch (\Exception $e) {
            // Capture d'autres exceptions potentielles
            return 'Une erreur inattendue est survenue : ' . $e->getMessage();
        }
    }

    /**
     * Insérer un utilisateur dans la base de données (MySQL/PostgreSQL)
     */
    public function addUser(): string
    {
        try {
            $db = \Config\Database::connect();

            // Vérifier si la table 'users' existe (précaution simple)
            if (!$db->tableExists('users')) {
                 return 'Erreur : la table "users" n\'existe pas. Veuillez d\'abord exécuter la migration de la base de données.';
            }

            // Insertion des données
            $data = [
                'name' => 'ServBay Demo User',
                'email' => 'user_' . time() . '@servbay.demo', // Générer un email unique avec time()
            ];

            $db->table('users')->insert($data);

            // Vérification de l'insertion (optionnel, insert() retourne généralement true)
            // if ($db->affectedRows() > 0) {
                 return 'Utilisateur ajouté avec succès : ' . $data['email'];
            // } else {
            //      return 'Erreur : Échec de l\'ajout de l\'utilisateur.';
            // }

        } catch (DatabaseException $e) {
            // Capture des exceptions liées à la base de données
            return 'Erreur base de données : ' . $e->getMessage() . '. Vérifiez la connexion et la structure de la table.';
        } catch (\Exception $e) {
             // Capture d'autres exceptions potentielles
            return 'Une erreur inattendue est survenue : ' . $e->getMessage();
        }
    }

    /**
     * Lire les utilisateurs depuis la base de données (MySQL/PostgreSQL)
     */
    public function listUsers(): string
    {
         try {
            $db = \Config\Database::connect();

             // Vérifier si la table 'users' existe
            if (!$db->tableExists('users')) {
                 return 'Erreur : la table "users" n\'existe pas. Veuillez d\'abord exécuter la migration de la base de données.';
            }

            // Requête pour tous les utilisateurs
            $users = $db->table('users')->get()->getResult();

            if (empty($users)) {
                return 'Aucun utilisateur trouvé dans la base de données.';
            }

            // Retourner la liste au format JSON
            return json_encode($users);

        } catch (DatabaseException $e) {
             // Capture des exceptions liées à la base de données
            return 'Erreur base de données : ' . $e->getMessage() . '. Vérifiez la connexion et la structure de la table.';
        } catch (\Exception $e) {
            // Capture d'autres exceptions potentielles
            return 'Une erreur inattendue est survenue : ' . $e->getMessage();
        }
    }
}

Ce contrôleur mis à jour fournit des messages plus explicites et inclut une gestion de base des erreurs pour un meilleur diagnostic.

Configurer les routes

Pour accéder via URL aux méthodes d’exemple ajoutées dans le contrôleur Home, vous devez déclarer les règles dans le fichier de routes de CodeIgniter.

Éditez app/Config/Routes.php. Repérez la partie qui définit $routes et ajoutez les lignes suivantes :

php

// ... autres règles de routage ...

// Route pour l’exemple Memcached
$routes->get('/memcached', 'Home::memcached');

// Route pour l’exemple Redis
$routes->get('/redis', 'Home::redis');

// Routes exemples base de données
$routes->get('/add-user', 'Home::addUser');
$routes->get('/list-users', 'Home::listUsers');

// ... autres règles de routage ...

Veillez à ajouter ces routes sans écraser les règles existantes.

Accéder au site web

Votre projet CodeIgniter est désormais opérationnel sur ServBay. Ouvrez votre navigateur web et accédez au domaine configuré :

Page d’accueil : https://servbay-codeigniter-test.local Vous devriez voir le message Hello ServBay and CodeIgniter!, signe que le projet tourne correctement via le serveur ServBay.
Exemple Memcached : https://servbay-codeigniter-test.local/memcached Si Memcached est opérationnel et bien configuré, vous verrez un message comme Test Memcached réussi : Hello Memcached from CodeIgniter!.
Exemple Redis : https://servbay-codeigniter-test.local/redis Si Redis fonctionne, vous verrez un message comme Test Redis réussi : Hello Redis from CodeIgniter!.

Exemple de manipulation de bases de données (MySQL/PostgreSQL)

Avant d’utiliser les exemples en base de données, vous devez lancer la migration CodeIgniter pour créer la table users.

Créer la structure de la base (effectuer la migration)

Ouvrez le terminal et placez-vous dans le dossier du projet :
bash
```
cd /Applications/ServBay/www/servbay-codeigniter-app
```
1
Générer un fichier de migration : Utilisez l’outil CLI de CodeIgniter pour créer le fichier de migration de la table users :
bash
```
php spark make:migration create_users_table
```
1
Cela crée un nouveau fichier PHP dans app/Database/Migrations.

Éditez le fichier de migration : Ouvrez le fichier généré (nom du type YYYY-MM-DD-HHMMSS_CreateUsersTable.php) et modifiez la méthode up() pour définir la structure. Notez que la gestion des timestamps par défaut diffère entre MySQL et PostgreSQL (CURRENT_TIMESTAMP vs NOW()); la classe RawSql de CodeIgniter peut aider. Exemple :

php

<?php

namespace App\Database\Migrations;

use CodeIgniter\Database\Migration;
use CodeIgniter\Database\RawSql; // Veillez à importer RawSql

class CreateUsersTable extends Migration
{
    public function up()
    {
        $this->forge->addField([
            'id'          => [
                'type'           => 'INT',
                'constraint'     => 5,
                'unsigned'       => true,
                'auto_increment' => true,
            ],
            'name'       => [
                'type'       => 'VARCHAR',
                'constraint' => '100',
            ],
            'email'      => [
                'type'       => 'VARCHAR',
                'constraint' => '100',
                'unique'     => true, // Unicité de l’email
            ],
            'created_at' => [
                'type'    => 'TIMESTAMP',
                // Choix dynamique de la valeur par défaut suivant le SGBD
                // MySQL : 'default' => new RawSql('CURRENT_TIMESTAMP'),
                // PostgreSQL : 'default' => new RawSql('NOW()'),
                'default' => new RawSql($this->db->getPlatform() === 'MySQLi' ? 'CURRENT_TIMESTAMP' : 'NOW()'),
            ],
            'updated_at' => [
                'type'    => 'TIMESTAMP',
                // MySQL : 'default' => new RawSql('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'),
                // PostgreSQL : 'default' => new RawSql('NOW()'),
                'default' => new RawSql($this->db->getPlatform() === 'MySQLi' ? 'CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP' : 'NOW()'),
            ],
        ]);
        $this->forge->addKey('id', true); // id comme clé primaire
        $this->forge->createTable('users'); // Création de la table
    }

    public function down()
    {
        // Rollback de la migration : suppression de la table
        $this->forge->dropTable('users');
    }
}

Remarque : Cet exemple adopte une logique simple pour choisir dynamiquement la syntaxe des timestamps selon la base. En production, il peut être préférable de concevoir une stratégie de migration plus robuste, voire d’avoir des migrations dédiées par SGBD.

Lancer la migration : Exécutez la commande suivante pour créer la table users :
bash
```
php spark migrate
```
1
Si tout fonctionne, un message de succès s’affiche. Vous pouvez aussi vérifier la création de la table users dans la base servbay_codeigniter_app via Adminer.

Utiliser les exemples de base de données

Assurez-vous d’avoir correctement configuré la connexion dans app/Config/Database.php et d’avoir appliqué la migration.

Ajouter un utilisateur : Rendez-vous sur https://servbay-codeigniter-test.local/add-user À chaque visite de cette URL, un nouvel utilisateur sera inséré dans la table users. Un message du type Utilisateur ajouté avec succès : [email protected] doit s’afficher.
Lister les utilisateurs : Rendez-vous sur https://servbay-codeigniter-test.local/list-users Cette URL affiche en JSON tous les utilisateurs présents dans la table.

Conclusion

En suivant ces étapes, vous avez su créer, configurer et exécuter un projet CodeIgniter sur macOS dans l’environnement ServBay. Vous avez appris à utiliser Composer pour initialiser le projet, à configurer les Sites ServBay sur le bon dossier, à régler la connexion aux bases de données et au cache dans CodeIgniter, et à valider l’intégration via des exemples simples. ServBay facilite la configuration et la gestion de vos environnements locaux afin que vous puissiez vous concentrer sur le développement de votre application CodeIgniter.

Créer et exécuter un projet CodeIgniter ​

Qu'est-ce que CodeIgniter ? ​

Principales caractéristiques et avantages de CodeIgniter ​

Installer un environnement de développement CodeIgniter avec ServBay ​

Prérequis ​

Création d’un projet CodeIgniter ​

Configuration initiale ​

Configurer la connexion à la base de données ​

Configurer le cache (Memcached/Redis) ​

Configuration du serveur web (paramètres site ServBay) ​

Ajouter du code exemple ​

Configurer les routes ​

Accéder au site web ​

Exemple de manipulation de bases de données (MySQL/PostgreSQL) ​

Créer la structure de la base (effectuer la migration) ​

Utiliser les exemples de base de données ​

Conclusion ​