Module 1Découvrir le framework PHP Laravel
Chapitre 2 sur 17
Préparer l'environnement de Laravel
Installation (Herd, php.new), création du projet, architecture, fichier .env, Artisan, lancement et débogage.
- ≈ 190 min
- 8 leçons
- 1 vidéo
- 4 exercices
Module 1Découvrir le framework PHP Laravel
Chapitre 2 sur 17
Installation (Herd, php.new), création du projet, architecture, fichier .env, Artisan, lancement et débogage.
Objectifs
Avec ce chapitre, tu sauras…
.env et passer de SQLite à MySQL ;Leçon 1
Pour développer avec Laravel, il te faut :
| Outil | Rôle | Vérification |
|---|---|---|
| PHP 8.3 ou plus | exécuter Laravel | php -v |
| Composer 2 | installer Laravel et ses dépendances | composer -V |
| Node.js et npm | compiler le CSS et le JavaScript avec Vite | node -v et npm -v |
| une base de données | SQLite (par défaut, rien à installer), MySQL ou MariaDB | |
| un éditeur | VS Code avec l'extension officielle Laravel, ou PhpStorm | |
| un navigateur récent | Chrome, Firefox, Edge, Safari, avec les outils de développement (F12) | |
| Git | versionner le projet (module M110) | git --version |
Leçon 2
| Question | Réponse pour ce cours |
|---|---|
| kit de démarrage (starter kit) | None (aucun) pour apprendre ; un kit (React, Vue, Svelte, Livewire) ajoute une authentification complète (chapitre 12) |
| framework de test | Pest ou PHPUnit (les deux fonctionnent ; ce cours montre PHPUnit, la syntaxe historique) |
| base de données | SQLite pour commencer |
lancer npm install et npm run build | oui |
Leçon 3
| Dossier | À retenir |
|---|---|
app/ | ton code : Http/Controllers, Models, Providers. D'autres dossiers apparaissent quand tu les génères avec Artisan : Http/Middleware, Http/Requests, Policies, Mail, Console/Commands… |
bootstrap/app.php | depuis Laravel 11, c'est là qu'on déclare les fichiers de routes, les middlewares et la gestion des exceptions |
config/ | un fichier par domaine ; chaque option est commentée ; les valeurs secrètes viennent du .env |
database/ | migrations, fabriques (factories) et seeders (chapitre 10) |
Leçon 4
| Commande | Effet |
|---|---|
php artisan list | liste toutes les commandes |
php artisan help migrate | affiche l'aide d'une commande (on peut aussi écrire php artisan migrate --help) |
php artisan --version | affiche la version de Laravel (Laravel Framework 13.x.x) |
php artisan about | résumé de l'application : versions, environnement, pilotes, cache |
Leçon 5
| Commande | Quand l'utiliser |
|---|---|
php artisan serve | lancer seulement le serveur PHP |
npm run dev | lancer Vite en mode développement (le CSS se recharge à chaque modification) |
npm run build | compiler le CSS et le JS pour la production (dans public/build) |
composer run dev | les deux à la fois, plus la file d'attente et le journal |
Leçon 6
Leçon 7
| Outil | Usage |
|---|---|
| la page d'erreur | avec APP_DEBUG=true, une erreur affiche une page détaillée : message, fichier, ligne, pile d'appels |
dd($variable) | dump and die : affiche le contenu d'une variable puis arrête le script |
dump($variable) | affiche le contenu sans arrêter le script |
logger('message', $donnees) | écrit dans storage/logs/laravel.log |
php artisan pail |
Leçon 8
Vidéo · À regarder
EN30 Days to Learn Laravel - Complete 8 Hour Course
Laracasts (Jeffrey Way) · YouTube
1Le seul dossier qui doit être accessible depuis le web est…
2Depuis Laravel 11, les middlewares se configurent dans…
3Par défaut, un projet Laravel 13 utilise la base…
4APP_DEBUG doit valoir en production…
5La commande qui affiche la version de Laravel est…
6Après un git clone, la commande qui recrée vendor/ est…
7Le fichier routes/api.php est créé par…
8La fonction qui affiche une variable puis arrête le script est…
L'essentiel du chapitre
laravel new kitab ou composer create-project laravel/laravel kitab (.env, APP_KEY, base SQLite et migrations créés automatiquement).app/ (Http/Controllers, Models, Providers), bootstrap/app.php (routes, middlewares, exceptions), config/, database/, public/ (seul dossier exposé, index.php), resources/views, routes/web.php et console.php, storage/, tests/, vendor/..env : configuration et secrets, jamais versionné ; APP_DEBUG=false en production ; lire avec config().list, --version, about, serve, make:*, route:list, migrate, migrate:rollback, tinker, optimize:clear, storage:link, test.php artisan serve → http://localhost:8000 ; composer run dev (serveur + Vite + file + journal). Après un clone : composer install, .env, key:generate, migrate.public/index.php → bootstrap/app.php → middlewares globaux → routeur → middlewares de route → contrôleur → réponse. Déboguer : page d'erreur, dd(), dump(), logger(), laravel.log, pail, tinker.Créer le projet dans le bon dossier
public/ | le seul dossier que le serveur web doit exposer : index.php, les images, le CSS et le JS compilés (public/build) |
resources/ | les vues Blade et les fichiers non compilés (CSS, JS) |
routes/ | deux fichiers par défaut : web.php et console.php |
storage/ | app/ (fichiers de l'application ; app/public pour les fichiers publics, app/private pour les autres), framework/ (vues compilées, cache, sessions), logs/ (le journal laravel.log) |
tests/ | Feature/ (tests d'une requête complète) et Unit/ (tests d'une classe isolée) ; chaque classe se termine par Test |
| Variable | Rôle |
|---|---|
APP_ENV | l'environnement : local, testing, production |
APP_KEY | la clé de chiffrement (cookies, sessions, Crypt) ; générée par php artisan key:generate ; ne jamais la partager |
APP_DEBUG | true en local (page d'erreur détaillée) ; false en production (sinon les erreurs affichent ton code et tes secrets) |
APP_URL | l'adresse du site, utilisée pour générer les URL complètes |
DB_* | la connexion à la base de données |
php artisan serve | lance le serveur de développement sur http://127.0.0.1:8000 |
php artisan make:controller LivreController | crée un contrôleur |
php artisan make:model Livre -m | crée un modèle et sa migration |
php artisan route:list | liste les routes |
php artisan migrate | exécute les migrations en attente |
php artisan migrate:rollback | annule le dernier lot de migrations |
php artisan tinker | console PHP interactive dans l'application |
php artisan config:clear | vide le cache de configuration |
php artisan optimize / optimize:clear | met en cache (ou vide) configuration, routes, vues et événements |
php artisan storage:link | crée le lien public/storage vers storage/app/public |
php artisan test | lance les tests |
affiche le journal en direct dans le terminal (lancé aussi par composer run dev) |
php artisan tinker | tester une expression dans l'application |
php artisan route:list | vérifier qu'une route existe, son nom, son contrôleur |
PHP doit avoir les extensions demandées par Laravel : Ctype, cURL, DOM, Fileinfo, Filter, Hash, Mbstring, OpenSSL, PCRE, PDO, Session, Tokenizer et XML, plus le pilote de ta base (pdo_sqlite, pdo_mysql). La commande php -m affiche les extensions actives.
La dernière version de XAMPP (8.2.12, novembre 2023) contient PHP 8.2. Laravel 13 exige PHP 8.3. Avec le PHP de XAMPP, laravel new ou composer create-project installe une ancienne version de Laravel, ou échoue. La solution : installer PHP avec Herd ou php.new (ci-dessous), et garder XAMPP seulement pour son serveur MySQL et phpMyAdmin. Vérifie toujours avec php -v quel PHP répond dans ton terminal.
Méthode 1 (recommandée) : Laravel Herd
Laravel Herd (herd.laravel.com, gratuit, Windows et macOS) installe d'un coup PHP, Nginx, Composer, l'installeur laravel, Node.js et npm. Il crée un dossier « parqué » (%USERPROFILE%\Herd sous Windows, ~/Herd sous macOS) : tout projet placé dedans est servi automatiquement à l'adresse http://nom-du-dossier.test, sans lancer de serveur.
cd ~\Herd
laravel new kitab
cd kitab
herd open # ouvre http://kitab.test dans le navigateurHerd permet aussi de changer de version de PHP en un clic. Pour une base MySQL, garde celle de XAMPP (ou utilise DBngin, gratuit).
Méthode 2 : php.new
Le site php.new fournit une commande qui installe PHP, Composer et l'installeur Laravel. Sous Windows, dans un PowerShell lancé en administrateur :
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://php.new/install/windows/8.5'))Sous macOS ou Linux : /bin/bash -c "$(curl -fsSL https://php.new/install/linux/8.5)" (remplace linux par mac sur macOS). Redémarre le terminal ensuite.
Méthode 3 : installation manuelle (la méthode du résumé)
windows.php.net/download (version Thread Safe, x64), dézipper dans C:\php et ajouter ce dossier à la variable d'environnement Path.php.ini-development en php.ini, puis activer les extensions en retirant le point-virgule devant chaque ligne :extension=curl
extension=fileinfo
extension=mbstring
extension=openssl
extension=pdo_mysql
extension=pdo_sqlite
extension=sqlite3
extension=zipComposer-Setup.exe (getcomposer.org/download) : vérifier que le chemin proposé vers PHP est bien C:\php\php.exe.composer global require laravel/installer.Le résumé demande d'installer « la version 7.3 ou plus » de PHP : c'est la version de Laravel 8. Il écrit les extensions sous la forme ;extension=php_mbstring.dll : depuis PHP 7.2, on écrit simplement extension=mbstring. Enfin, il conseille composer install --ignore-platform-reqs en cas d'erreur : cette option masque le vrai problème (une extension manquante ou un PHP trop ancien) et l'application plante plus tard. Lis le message de Composer et corrige ton installation de PHP.
Avec l'installeur Laravel
laravel new kitabL'installeur pose quelques questions, auxquelles on répond avec les flèches du clavier :
Avec Composer
composer create-project laravel/laravel kitabCette commande télécharge la dernière version stable de Laravel compatible avec ton PHP. Dans les deux cas, Laravel copie .env.example en .env, génère la clé de l'application (APP_KEY), crée le fichier de base database/database.sqlite et lance les premières migrations (les tables users, sessions, cache, jobs…).
kitab/
├── app/ le code de l'application
│ ├── Http/
│ │ └── Controllers/ les contrôleurs (Controller.php : classe de base, vide)
│ ├── Models/ les modèles Eloquent (User.php)
│ └── Providers/ les fournisseurs de services (AppServiceProvider.php)
├── bootstrap/
│ ├── app.php la configuration de l'application : routes, middlewares, exceptions
│ └── cache/ fichiers générés pour la performance
├── config/ les fichiers de configuration (app.php, database.php, auth.php…)
├── database/
│ ├── factories/ les fabriques de fausses données (UserFactory.php)
│ ├── migrations/ l'historique de la structure de la base
│ ├── seeders/ le remplissage initial (DatabaseSeeder.php)
│ └── database.sqlite la base SQLite
├── public/ le SEUL dossier accessible depuis le web
│ └── index.php le point d'entrée de toutes les requêtes
├── resources/
│ ├── css/app.css le CSS source
│ ├── js/app.js le JavaScript source
│ └── views/ les vues Blade (welcome.blade.php)
├── routes/
│ ├── web.php les routes du site
│ └── console.php les commandes Artisan personnalisées et tâches planifiées
├── storage/ logs, vues compilées, sessions, cache, fichiers envoyés
├── tests/ les tests automatisés (Feature/ et Unit/)
├── vendor/ les dépendances installées par Composer (non versionné)
├── .env la configuration locale (secrets ; non versionné)
├── .env.example le modèle de .env (versionné, sans secret)
├── artisan le script de la ligne de commande Artisan
├── composer.json les dépendances PHP
├── package.json les dépendances JavaScript
├── phpunit.xml la configuration des tests
└── vite.config.js la configuration de ViteArtisan est l'interface en ligne de commande de Laravel. Elle s'utilise depuis la racine du projet avec php artisan <commande>. Elle sert à générer du code (contrôleurs, modèles, migrations…), à gérer l'application (base de données, cache, routes) et à lancer des outils (serveur de développement, console interactive).
cd kitab
php artisan serve
# INFO Server running on [http://127.0.0.1:8000].Ouvre http://localhost:8000 : la page d'accueil de Laravel s'affiche. Ctrl + C arrête le serveur.
Pour travailler avec le CSS et le JavaScript compilés par Vite, Laravel fournit un script qui lance tout en même temps (serveur PHP, file d'attente, journal en direct et serveur Vite) :
npm install
composer run devL'adresse du résumé, « http://localhost/:8000 », est fausse : le port se place directement après le nom d'hôte, sans barre oblique : http://localhost:8000. La commande php artisan key:generate n'est utile que si la clé manque (après un git clone, par exemple) : à la création du projet, elle est déjà générée.
Après un git clone : remettre un projet en marche
git clone https://gitlab.com/equipe/kitab.git
cd kitab
composer install # recrée vendor/
cp .env.example .env # sous Windows (cmd) : copy .env.example .env
php artisan key:generate # génère APP_KEY
php artisan migrate # crée les tables
npm install && npm run build
php artisan serve@startuml
start
:Le navigateur demande **GET /livres**;
:Le serveur web transmet la requête à **public/index.php**;
:**bootstrap/app.php** crée l'application\n(configuration, fournisseurs de services);
:Le noyau HTTP fait traverser les **middlewares globaux**;
:Le **routeur** cherche la route qui correspond à GET /livres;
if (route trouvée ?) then (oui)
:Middlewares de la route\n(groupe **web** : session, CSRF…);
:Le **contrôleur** (ou la closure) s'exécute\net renvoie une réponse;
else (non)
:Réponse **404 Not Found**;
endif
:La réponse retraverse les middlewares;
:Le navigateur reçoit la **réponse HTTP**;
stop
@endumlRetiens trois idées : toutes les requêtes passent par public/index.php ; les middlewares forment des couches que la requête traverse à l'aller et au retour ; c'est le routeur qui choisit le code à exécuter.
Vite, npm run dev et npm run build : compiler le CSS et le JavaScript d'un projet Laravel.
(1) Installe l'environnement (Herd ou php.new) et vérifie les versions de PHP, Composer et Node. (2) Crée le projet kitab sans kit de démarrage. (3) Dans le .env, mets APP_NAME=Kitab et APP_LOCALE=fr. (4) Remplace le contenu de la route / de routes/web.php pour qu'elle renvoie le texte « Bienvenue sur Kitab ». (5) Lance le projet et vérifie dans le navigateur. (6) Crée le dépôt Git, vérifie que .env et vendor/ ne sont pas suivis, et fais le premier commit. (7) Lance php artisan about et relève la version de Laravel et de PHP.
Indique le dossier ou le fichier de chacun : (1) le contrôleur LivreController ; (2) la vue de la page d'accueil ; (3) le mot de passe de la base de données ; (4) le fichier de journal des erreurs ; (5) la migration qui crée la table users ; (6) l'image logo.png affichée sur toutes les pages ; (7) le modèle User ; (8) la déclaration d'un middleware global ; (9) les couvertures de livres envoyées par les libraires et visibles par tous.
Avec Herd, crée le projet dans le dossier parqué Herd. Sans Herd, crée-le où tu veux (par exemple C:\dev) et lance-le avec php artisan serve. Il n'est plus nécessaire de le mettre dans htdocs ou www : Laravel ne doit jamais être servi depuis un sous-dossier du serveur web, car cela pourrait exposer des fichiers sensibles comme .env.
Le résumé décrit la structure de Laravel 9. Depuis Laravel 11 : app/Http/Kernel.php et app/Http/Middleware n'existent plus par défaut (les middlewares se configurent dans bootstrap/app.php) ; le RouteServiceProvider a disparu ; le dossier routes/ contient deux fichiers et non quatre : api.php s'ajoute avec php artisan install:api et channels.php avec php artisan install:broadcasting. Le dossier lang/ (traductions) n'existe plus par défaut : php artisan lang:publish le crée à la racine du projet. Le résumé affirme aussi que dans les versions récentes ce dossier « se trouve dans le dossier public » : c'est faux, il n'a jamais été dans public/ (avant Laravel 9, il était dans resources/lang).
Le fichier bootstrap/app.php
<?php
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
return Application::configure(basePath: dirname(__DIR__))
->withRouting(
web: __DIR__.'/../routes/web.php',
commands: __DIR__.'/../routes/console.php',
health: '/up',
)
->withMiddleware(function (Middleware $middleware): void {
//
})
->withExceptions(function (Exceptions $exceptions): void {
//
})->create();Trois blocs à retenir : withRouting (quels fichiers de routes charger ; health: '/up' crée une route de surveillance qui répond si l'application fonctionne), withMiddleware (chapitre 4) et withExceptions (personnaliser la gestion des erreurs).
Le fichier composer.json
{
"name": "laravel/laravel",
"type": "project",
"require": {
"php": "^8.3",
"laravel/framework": "^13.0"
},
"autoload": {
"psr-4": {
"App\\": "app/",
"Database\\Factories\\": "database/factories/",
"Database\\Seeders\\": "database/seeders/"
}
}
}La section autoload applique la norme PSR-4 : l'espace de noms App\ correspond au dossier app/. C'est pourquoi la classe App\Models\Livre doit se trouver dans app/Models/Livre.php, avec la même casse.
Le fichier .env : la configuration de l'environnement
APP_NAME=Kitab
APP_ENV=local
APP_KEY=base64:Q3V0ZS1rZXktZ2VuZXJhdGVkLWJ5LWFydGlzYW4tZm9yLWtpdGFi
APP_DEBUG=true
APP_URL=http://localhost:8000
APP_LOCALE=fr
DB_CONNECTION=sqlite
# DB_HOST=127.0.0.1
# DB_PORT=3306
# DB_DATABASE=laravel
# DB_USERNAME=root
# DB_PASSWORD=
SESSION_DRIVER=database
CACHE_STORE=database
QUEUE_CONNECTION=database.env contient les mots de passe et la clé de l'application : il est listé dans .gitignore. On versionne .env.example, sans secrets, pour montrer aux autres développeurs quelles variables remplir. Dans le code, on lit la configuration avec config('app.name'), jamais avec env() en dehors des fichiers de config/ : en production, la configuration est mise en cache et env() renverrait null.
Passer de SQLite à MySQL
kitab avec l'interclassement utf8mb4_unicode_ci..env :DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=kitab
DB_USERNAME=root
DB_PASSWORD=php artisan migrate.Après une modification du .env, si l'application semble ignorer la nouvelle valeur, vide le cache de configuration : php artisan config:clear.
Plusieurs commandes du résumé sont mal écrites : php artisan -version (il faut deux tirets : --version), artisan route:list (il manque php), php artisan migrate : rollback (pas d'espace : migrate:rollback).
Toutes les commandes make: suivent le même principe : php artisan make:<type> <Nom>. Les plus utilisées : make:controller, make:model, make:migration, make:seeder, make:factory, make:middleware, make:request, make:policy, make:component, make:command, make:test.
Tinker : la console interactive
$ php artisan tinker
> 2 * 21
= 42
> config('app.name')
= "Kitab"
> App\Models\User::count()
= 0
> now()->addDays(3)->format('d/m/Y')
= "05/11/2026"
> exitTinker exécute du PHP dans l'application : idéal pour tester une requête Eloquent ou une fonction sans créer de page.
<?php
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
Route::get('/debug', function (Request $request) {
$donnees = ['page' => $request->query('page', 1), 'ip' => $request->ip()];
dd($donnees); // affiche le tableau et arrête tout
return 'jamais affiché';
});Lis d'abord la première ligne (le type d'erreur et le message), puis cherche dans la pile la première ligne qui pointe vers ton code (app/, routes/, resources/views/) et non vers vendor/. Les erreurs les plus fréquentes au début : Class "App\Models\Livre" not found (faute de frappe dans le nom ou le use), Route [livres.show] not defined (nom de route), SQLSTATE[HY000] [1049] Unknown database (base absente ou .env faux), 419 Page Expired (jeton CSRF manquant, chapitre 5).
Le projet Kitab doit utiliser la base MySQL kitab_db du serveur XAMPP (utilisateur kitab, mot de passe K1tab!2026, port 3306). (1) Écris les lignes du .env. (2) Donne la commande qui crée les tables. (3) Après tes modifications, Laravel affiche toujours Unknown database 'laravel'. Donne deux causes possibles et la commande qui règle la plus courante.
Donne la commande pour : (1) lister les routes ; (2) créer un contrôleur CatalogueController ; (3) créer le modèle Auteur avec sa migration ; (4) annuler la dernière migration ; (5) ouvrir une console pour tester App\Models\User::count() ; (6) rendre accessibles depuis le web les fichiers de storage/app/public ; (7) vider tous les caches ; (8) lancer les tests.