---
contentId: 61204f3d-47bc-4832-a217-8c00b11ab6e1
part: 1
title: "Configurer la structure et les bases d'un projet Laravel"
description: Découvrez comment configurer un projet Laravel et comprendre sa structure pour commencer le développement sur des bases solides.
date: 2025-02-25
seriesSlug: empower-and-dynamize-our-vitepress-blog-with-a-laravel-api
---

Bienvenue dans la partie Laravel de cette série ! 👋

Dans la série précédente, nous avons configuré un blog VitePress avec la [Créer un Blog Complet avec VitePress et Vue.js de Zéro](/fr/series/create-a-blog-with-vitepress-and-vue-js-from-scratch). Nous sommes maintenant prêts à construire l'API Laravel qui alimentera ses fonctionnalités interactives. Vous n'avez pas besoin d'avoir lu cette série, mais elle fournit un contexte utile pour la suite.

Dans ce premier article, nous allons créer le projet Laravel, explorer sa structure et identifier l'emplacement du code que nous écrirons tout au long de la série. À la fin, vous devriez pouvoir vous repérer facilement dans l'application.

## Configurer le projet



> [!NOTE]
> Cet article ne traite pas de l'installation de Laravel. Pour cela, consultez [la documentation officielle](https://laravel.com/docs/12.x/installation).



L'un des points forts de Laravel est son interface en ligne de commande, qui permet de créer rapidement un nouveau projet. Exécutez la commande suivante :

```bash [terminal]
laravel new mimram --pest # Mimram est le nom du projet
```



> [!NOTE]
> Depuis Laravel 12, la commande `laravel new` ne demande plus quel framework de test utiliser. L'option `--pest` configure automatiquement Pest.



La configuration devrait ressembler à ceci :



> [!NOTE]
> Pour cet article, j'utilise la version 12.x de Laravel.



```txt [Exemple]
   _                               _
  | |                             | |
  | |     __ _ _ __ __ ___   _____| |
  | |    / _` |  __/ _` \ \ / / _ \ |
  | |___| (_| | | | (_| |\ V /  __/ |
  |______\__,_|_|  \__,_| \_/ \___|_|

 ┌ Which starter kit would you like to install? ────────────────┐
 │ › ● None                                                     │
 │   ○ React                                                    │
 │   ○ Vue                                                      │
 │   ○ Livewire                                                 │
 └──────────────────────────────────────────────────────────────┘
```

Comme nous avons déjà un front-end, sélectionnez l'option `None`.

La commande vous demandera ensuite quelle base de données l'application doit utiliser.

```txt [Exemple]
 ┌ Which database will your application use? ───────────────────┐
 │ › ● SQLite                                                   │
 │   ○ MySQL                                                    │
 │   ○ MariaDB                                                  │
 │   ○ PostgreSQL                                               │
 │   ○ SQL Server (Missing PDO extension)                       │
 └──────────────────────────────────────────────────────────────┘
```

Pour ce projet, choisissez SQLite.

SQLite est une bibliothèque C qui stocke les données dans un seul fichier sur le disque, ce qui la rend portable et simple à maintenir. Elle ne convient pas à tous les cas d'usage, mais c'est un excellent choix pour un blog simple qui ne connaîtra pas un trafic important.



> [!NOTE]
> Pour en savoir plus sur SQLite, je vous recommande [High Performance SQLite](https://highperformancesqlite.com/) d'[Aaron Francis](https://x.com/aarondfrancis). C'est une excellente série pour maîtriser SQLite.



Enfin, répondez oui lorsque la commande vous demande si vous souhaitez installer les dépendances JavaScript et compiler les ressources.

Parfait ! Nous avons maintenant un projet Laravel vierge dans lequel construire notre API.

## Structure du projet

Voici la structure du projet avec laquelle nous allons travailler :

```text [Structure du projet Laravel]
├── app
│   ├── Http/
│   ├── Models/
│   └── Providers/
├── bootstrap
│   ├── app.php
│   └── cache/
├── config
│   ├── app.php
│   ├── database.php
│   └── mail.php
├── database
│   ├── migrations/
│   ├── factories/
│   └── seeders/
├── public
│   ├── index.php
│   ├── css/
│   └── js/
├── resources
│   ├── views/
│   ├── css/
│   └── js/
├── routes
│   ├── web.php
│   └── api.php
├── storage
│   ├── app/
│   ├── framework/
│   └── logs/
├── tests
│   ├── Feature/
│   └── Unit/
└── vendor
```

Examinons les différents dossiers et fichiers.

### `app`

Le dossier `app` contient le code principal de l'application, notamment les contrôleurs, les modèles et les services. C'est le cœur du projet et l'endroit où vous passerez le plus de temps à coder.

### `bootstrap`

Le dossier `bootstrap` contient les fichiers qui initialisent l'application. Il comprend `app.php`, qui crée et configure l'application.

Le dossier contient également le fichier `providers.php`, qui charge les fournisseurs de services. Un fournisseur de services enregistre des services, des routes et des extensions Laravel comme les macros et les helpers. Chaque package Laravel possède un fournisseur de services comme point d'entrée, et les fournisseurs de votre application se trouvent dans `app/Providers`.

### `config`

Le dossier `config` contient tous les fichiers de configuration. Vous y trouverez les paramètres de la base de données, du mail, du cache et bien d'autres choses.

### `database`

Le dossier `database` contient les migrations de base de données, les factories de modèles et les seeders. Les migrations versionnent le schéma de la base de données. Les factories de modèles génèrent facilement des données de test, tandis que les seeders remplissent la base de données, souvent à l'aide de ces factories.

Les factories de modèles sont liées aux modèles situés dans le dossier `app/Models`.

### `node_modules`

Le dossier `node_modules` contient les dépendances JavaScript installées par npm, pnpm ou yarn. Il est généré automatiquement et ne doit pas être ajouté au contrôle de version.

### `public`

Le dossier `public` contient le contrôleur frontal et les ressources publiques comme les fichiers JavaScript, CSS et les images. C'est le répertoire servi par le serveur web. Le fichier `index.php` est le point d'entrée de l'application et redirige les requêtes entrantes vers Laravel.

### `resources`

Le dossier `resources` contient les fichiers de vue et les ressources brutes comme les fichiers CSS et JavaScript. Dans Laravel, les vues sont des fichiers PHP appelés templates Blade. Blade fournit une syntaxe élégante pour le code PHP et les directives comme `@if` et `@foreach`.

Les ressources brutes sont compilées par Vite et stockées dans le dossier `public/build`.

### `routes`

Le dossier `routes` contient les routes de l'application. Il comprend les routes web, les routes API et les routes de console. Chaque fichier gère un type de route précis : `web.php` gère les routes accessibles depuis un navigateur, tandis que `api.php` gère les routes d'API.

### `storage`

Le dossier `storage` contient les templates Blade compilés, les sessions stockées dans des fichiers, les caches, les logs et d'autres fichiers générés par le framework. Il est organisé ainsi :

1. `app` : Fichiers générés par l'application.
2. `framework` : Fichiers générés par le framework.
3. `logs` : Fichiers de log de l'application.

Consultez le fichier `laravel.log` dans `storage/logs` pour trouver les logs d'erreur et les traces d'exécution.

### `tests`

Le dossier `tests` contient les tests automatisés. Laravel inclut Pest, un framework de test construit sur PHPUnit, pour écrire des tests unitaires et fonctionnels. Les tests vérifient que l'application se comporte comme prévu et aident à éviter les régressions.

Tout au long de cette série, nous écrirons des tests pour notre application afin de montrer à quel point Laravel facilite leur rédaction.

### `vendor`

Le dossier `vendor` contient toutes les dépendances PHP, générées automatiquement par Composer. Il joue pour PHP un rôle comparable à celui de `node_modules` pour JavaScript.

### Fichiers à la racine

Voici la liste des fichiers à la racine du projet :

### `.editorconfig`

Le fichier `.editorconfig` aide à maintenir un style de code cohérent entre plusieurs développeurs, éditeurs et IDE. Il définit notamment l'indentation, les fins de ligne et l'encodage des caractères.

### `.env`

Le fichier `.env` contient les valeurs de configuration propres à l'environnement. Il permet de configurer l'application sans modifier son code et peut contenir des informations sensibles comme des identifiants de base de données ou des clés d'API.

### `.env.example`

Le fichier `.env.example` sert de modèle pour `.env` et fournit les valeurs nécessaires à la création d'une configuration locale. Il doit être commité afin que les autres développeurs sachent quelles variables sont disponibles.

### `.gitattributes`

Le fichier `.gitattributes` définit des attributs pour les chemins du dépôt. Il contrôle notamment la gestion des fins de ligne, les stratégies de fusion et d'autres comportements de Git pour certains fichiers ou répertoires.

### `.gitignore`

Le fichier `.gitignore` indique à Git quels fichiers et répertoires ignorer, afin d'éviter de commiter des données sensibles ou des fichiers inutiles.

### `README.md`

Le fichier `README.md` présente le projet, sa configuration, son utilisation et d'autres informations essentielles. C'est souvent la première référence pour les nouveaux développeurs.

### `artisan`

Le fichier `artisan` est l'interface en ligne de commande de Laravel. Il fournit des commandes pour développer l'application, exécuter les migrations, générer du code et lancer les tests.

### `composer.json`

Le fichier `composer.json` est le fichier de configuration de Composer. Il liste les dépendances PHP et les métadonnées du projet, comme son nom et sa description.

Ce fichier contient une clé `scripts` pour exécuter des commandes `composer run`. Par exemple, `composer run test` exécute les tests de l'application. Parmi ces scripts, le script `dev` lance les processus nécessaires au développement :

```bash [composer.json]
npx concurrently -c \"#93c5fd,#c4b5fd,#fb7185,#fdba74\" \"php artisan serve\" \"php artisan queue:listen --tries=1\" \"php artisan pail --timeout=0\" \"npm run dev\" --names=server,queue,logs,vite
```

Laravel ne se limite pas à un seul processus pendant le développement. Le serveur web traite les requêtes, le serveur Vite sert les ressources, et les processus de queue et de logs s'occupent de leurs tâches respectives.

La commande `composer run dev` lance ces processus en parallèle grâce au package npm `concurrently`.

### `composer.lock`

Le fichier `composer.lock`, généré par Composer, verrouille les dépendances sur des versions précises et rend les installations reproductibles. Commitez-le dans le contrôle de version.

### `phpunit.xml`

Le fichier `phpunit.xml` configure PHPUnit, notamment ses suites de tests, son fichier de bootstrap et ses options d'environnement.

### `vite.config.js`

Le fichier `vite.config.js` configure Vite, l'outil de build front-end de Laravel, notamment les points d'entrée JavaScript et CSS.

### `package.json`

Le fichier `package.json` est le fichier de configuration de npm. Il liste les dépendances JavaScript et les scripts utilisés par le projet.

### `package-lock.json`

Le fichier `package-lock.json`, généré par npm, verrouille les dépendances JavaScript sur des versions précises. Commitez-le dans le contrôle de version lorsque vous utilisez npm.

## Derniers mots

Cette première étape pose les fondations du reste de la série. Vous savez maintenant où Laravel place le code de l'application, la configuration, les fichiers de base de données, les routes et les tests. Au fil de l'ajout des fonctionnalités, ces dossiers vous deviendront familiers.

Ensuite, nous rendrons ces fondations plus faciles à maintenir en configurant le formatage, la refactorisation automatique, l'analyse statique et les tests.
