Tu as lu du PHP. Maintenant, fais-le tourner.
À la leçon 1, tu as vu du PHP de tes yeux. Un echo, une balise <?php ?>, l'idée de la plomberie derrière les murs. Mais tu n'as fait que le lire. Le compilateur de ce cours est honnête : il te l'a dit, PHP ne peut pas tourner dans l'éditeur d'une page web.
Normal : PHP s'exécute sur un serveur, pas dans ton navigateur. Pour le faire tourner, il te faut un serveur. Et la bonne nouvelle, c'est que PHP en embarque un, tout petit, juste pour développer.
Cette leçon est le passage à l'acte. Tu vas installer PHP chez toi, écrire un vrai fichier, lancer une seule commande, et voir ta page s'afficher dans le navigateur. À la fin, tu pourras refaire tourner tous les exemples des leçons suivantes pour de vrai.
Installer PHP sur ta machine
La version stable de référence en 2026 est PHP 8.5 (sortie en novembre 2025). C'est elle qu'on installe. La méthode dépend de ton système.
Windows
Le plus simple est le gestionnaire de paquets Winget, livré avec Windows. Ouvre PowerShell et tape :
winget install PHP.PHP.8.5Tu peux aussi télécharger le ZIP officiel sur windows.php.net et l'extraire à la main, mais Winget gère le PATH pour toi.
macOS
macOS ne fournit plus PHP depuis Monterey. On passe par Homebrew, le gestionnaire de paquets du Mac :
brew install php@8.5Linux (Debian / Ubuntu)
Le gestionnaire apt fait le travail. Le paquet php-cli suffit pour ce cours (c'est PHP en ligne de commande, sans serveur web lourd) :
sudo apt update
sudo apt install php-cliVérifier que ça marche
Quelle que soit ta méthode, une seule commande prouve que PHP est installé et joignable. Ouvre un terminal et tape :
php --versionTu dois voir s'afficher quelque chose comme PHP 8.5.6 (cli). Si tu lis bien un numéro de version, PHP est prêt. Si tu lis « command not found », PHP n'est pas dans ton PATH : referme et rouvre le terminal, ou reprends l'étape d'installation.
Le numéro exact peu importe. Tu verras peut-être 8.5.4, 8.5.6 ou une autre fin de numéro : ce sont des correctifs de sécurité de la même version 8.5. Ce qui compte, c'est de lire 8.5 au début. Tout ce cours fonctionne pareil sur n'importe quelle version 8.x récente.
Ton premier fichier qui tourne
PHP est installé. Place au geste central de la leçon : faire vivre une page. On va créer un dossier, y mettre un fichier, et le servir.
Crée un dossier pour ton projet, par exemple mon-site. Dedans, crée un fichier nommé index.php avec ces deux lignes :
<?php
echo "Bonjour depuis mon serveur PHP !";Maintenant, ouvre un terminal dans ce dossier et lance LA commande de ce cours :
php -S localhost:8000C'est le serveur de développement intégré de PHP. Pas d'Apache à configurer, pas de Nginx, zéro fichier de config. PHP devient lui-même un petit serveur web, le temps que tu développes. Décortiquons la commande :
php: le programme que tu viens d'installer.-S(S majuscule) : « démarre le serveur intégré ».localhost:8000: l'adresse où il écoute.localhost, c'est ta propre machine ;8000, c'est le port (une sorte de numéro de porte).
Le terminal affiche alors une ligne du genre Development Server (http://localhost:8000) started et reste figé : c'est normal, il tourne. Ouvre ton navigateur sur http://localhost:8000. Ta phrase s'affiche. PHP a exécuté ton fichier et renvoyé le résultat. La plomberie de la leçon 1, tu viens de l'ouvrir.
Le réflexe à prendre maintenant : modifie, recharge. Change le texte du echo, sauvegarde, et recharge la page dans le navigateur. Le nouveau texte apparaît aussitôt. Pas besoin de redémarrer le serveur : à chaque requête, PHP relit ton fichier. C'est cette boucle écrire → recharger qui va rythmer tout le reste du cours.
Le port 8000 est déjà pris ? Si PHP refuse de démarrer en disant que l'adresse est déjà utilisée, c'est qu'un autre programme occupe le port 8000. Change juste de numéro : php -S localhost:8001, puis ouvre http://localhost:8001. N'importe quel port libre au-dessus de 1024 fait l'affaire.
Ce serveur s'arrête à ta machine. Le serveur intégré est génial pour développer, mais il n'est pas fait pour la production. Il gère une requête à la fois et n'a aucune des protections d'un vrai serveur. Personne sur internet ne peut le voir : il ne sert que sur localhost, chez toi. Mettre un vrai site en ligne demande un serveur de production (Nginx, Apache, ou une stack moderne). C'est tout le sujet du cours Déploiement, à découvrir plus tard.
Ton serveur tourne avec php -S localhost:8000. Tu modifies le texte du echo dans index.php et tu sauvegardes, sans toucher au terminal. Tu recharges la page. Que vois-tu ?
Voir la réponse
Le nouveau texte, tout de suite. Pas besoin de redémarrer le serveur. À chaque requête, PHP relit ton fichier sur le disque et le ré-exécute de zéro. C'est exactement pour ça que la boucle « modifie, recharge » est si rapide en développement. Le serveur ne garde rien en mémoire d'une page à l'autre : il repart du fichier à chaque fois.
Composer, en un coup d'œil
Pour ce cours, PHP seul suffit. Mais dans un vrai projet, tu entendras vite parler de Composer. Retiens juste l'idée pour l'instant : Composer est le npm de PHP, le gestionnaire de dépendances.
Quand tu veux ajouter une librairie, tu tapes composer require nom/librairie. Composer la télécharge dans un dossier vendor/ et génère un autoload : un seul require au début de ton code, et toutes tes librairies deviennent disponibles, sans les inclure une par une.
On en reparle plus tard. Composer, l'autoload et les namespaces sont enseignés à fond dans le cours PHP orienté objet, à la leçon sur les namespaces. Inutile de l'installer maintenant : pour tout ce cours, ton PHP fraîchement posé et php -S suffisent.
À toi : de l'installation à la page qui répond
Un terminal simulé, dans le dossier de ton premier site. Tu vas vérifier ta version de PHP, démarrer le serveur intégré, puis simuler une modification du fichier et constater que la page répond bien le bon HTML.
You've read PHP. Now make it run.
In lesson 1 you saw PHP with your own eyes. An echo, a <?php ?> tag, the idea of plumbing behind the walls. But you only read it. This course's compiler was honest: it told you, PHP can't run inside a web page's editor.
That's normal: PHP runs on a server, not in your browser. To run it, you need a server. And the good news is that PHP ships with one, tiny, just for development.
This lesson is where you take action. You'll install PHP on your machine, write a real file, run a single command, and watch your page show up in the browser. By the end, you'll be able to actually run every example from the next lessons for real.
Installing PHP on your machine
The 2026 stable reference is PHP 8.5 (released November 2025). That's the one we install. The method depends on your system.
Windows
The simplest route is Winget, the package manager that ships with Windows. Open PowerShell and type:
winget install PHP.PHP.8.5You can also download the official ZIP from windows.php.net and extract it by hand, but Winget handles the PATH for you.
macOS
macOS no longer ships PHP since Monterey. We use Homebrew, the Mac package manager:
brew install php@8.5Linux (Debian / Ubuntu)
The apt manager does the job. The php-cli package is enough for this course (that's command-line PHP, no heavy web server):
sudo apt update
sudo apt install php-cliCheck it works
Whatever your method, a single command proves PHP is installed and reachable. Open a terminal and type:
php --versionYou should see something like PHP 8.5.6 (cli). If you read a version number, PHP is ready. If you read "command not found", PHP isn't in your PATH: close and reopen the terminal, or redo the install step.
The exact number doesn't matter. You might see 8.5.4, 8.5.6 or another tail number: those are security patches of the same 8.5 release. What matters is reading 8.5 at the start. This whole course works the same on any recent 8.x version.
Your first file that runs
PHP is installed. Now the central move of the lesson: bringing a page to life. We'll create a folder, drop a file in it, and serve it.
Create a folder for your project, say my-site. Inside it, create a file named index.php with these two lines:
<?php
echo "Hello from my PHP server!";Now open a terminal in that folder and run THE command of this course:
php -S localhost:8000This is PHP's built-in development server. No Apache to configure, no Nginx, zero config files. PHP becomes a tiny web server itself, while you develop. Let's break the command down:
php— the program you just installed.-S(capital S) — "start the built-in server".localhost:8000— the address it listens on.localhostis your own machine;8000is the port (a kind of door number).
The terminal then prints a line like Development Server (http://localhost:8000) started and stays frozen: that's normal, it's running. Open your browser at http://localhost:8000. Your sentence shows up. PHP ran your file and sent back the result. The plumbing from lesson 1 — you just turned the tap on.
The reflex to build now: edit, reload. Change the echo text, save, and reload the page in the browser. The new text appears at once. No need to restart the server: on every request, PHP re-reads your file. This write → reload loop will set the rhythm for the rest of the course.
Port 8000 already taken? If PHP refuses to start, saying the address is already in use, another program is holding port 8000. Just change the number: php -S localhost:8001, then open http://localhost:8001. Any free port above 1024 will do.
This server stops at your machine. The built-in server is great for developing, but it's not made for production. It handles one request at a time and has none of a real server's protections. Nobody on the internet can see it: it only serves on localhost, on your machine. Putting a real site online needs a production server (Nginx, Apache, or a modern stack). That's the whole point of the Deployment course, to discover later.
Your server is running with php -S localhost:8000. You change the echo text in index.php and save, without touching the terminal. You reload the page. What do you see?
Show the answer
The new text, right away. No need to restart the server. On every request, PHP re-reads your file from disk and runs it again from scratch. That's exactly why the "edit, reload" loop is so fast in development. The server keeps nothing in memory between pages: it starts from the file every time.
Composer, at a glance
For this course, PHP alone is enough. But in a real project, you'll soon hear about Composer. Just keep the idea for now: Composer is PHP's npm, the dependency manager.
When you want to add a library, you type composer require name/library. Composer downloads it into a vendor/ folder and generates an autoload: a single require at the top of your code, and all your libraries become available, without including them one by one.
More on this later. Composer, autoloading and namespaces are taught in depth in the object-oriented PHP course, in the namespaces lesson. No need to install it now: for this whole course, your freshly installed PHP and php -S are enough.
Your turn: from install to a page that answers
A simulated terminal, in your first site's folder. You'll check your PHP version, start the built-in server, then simulate a file edit and confirm the page returns the right HTML.
🎯 Pratique
S'entraîner (clique pour ouvrir) :
💬 Ré-explique sans regarder
Explique à un débutant ce que fait php -S localhost:8000, et pourquoi on peut modifier le fichier sans redémarrer le serveur.
php -S localhost:8000 lance le serveur de développement intégré de PHP, sans aucune config. Il écoute sur ta machine (localhost), au port 8000. À chaque requête, il relit ton fichier sur le disque et le ré-exécute de zéro : c'est pour ça qu'une simple modification + un rechargement suffisent, pas besoin de redémarrer. Et il ne sert qu'en local, jamais en production.🧠 Rappel libre
Sans remonter : quelle commande prouve que PHP est installé, et que dois-tu lire dans sa sortie ?
php --version (ou php -v). Si PHP est installé et joignable, tu lis un numéro de version commençant par PHP 8.5. Si tu lis « command not found », PHP n'est pas dans ton PATH : referme et rouvre ton terminal, ou reprends l'installation.⚖️ Juge le code de l'IA
Ton petit site tourne en local avec php -S localhost:8000. Tu demandes à l'IA comment le mettre en ligne pour de vrai. Elle répond : « Facile ! Lance php -S 0.0.0.0:80 sur ton serveur, et tout le monde pourra y accéder. C'est prêt pour la production. » Tu acceptes, ou tu rejettes ?
php -S) n'est pas fait pour la production, c'est écrit noir sur blanc dans la doc PHP. Il gère une requête à la fois et n'a aucune des protections d'un vrai serveur. L'exposer sur internet avec 0.0.0.0 est un vrai risque. La bonne approche : un serveur de production (Nginx, Apache ou une stack moderne), tout le sujet du cours Déploiement. Règle d'or : php -S pour développer, jamais pour servir le monde.php -S localhost:8000 ?index.php et tu sauvegardes. Que faut-il faire pour voir le changement dans le navigateur ?php -S ne suffit-il pas, et que viserais-tu à la place ?PHP tourne chez toi : un fichier, une commande, une page qui répond. Maintenant que tu peux exécuter du code, donne-lui de la matière. Place aux variables et aux tableaux, la mémoire de tes scripts pour jongler avec plusieurs valeurs à la fois.
Leçon 3 : Variables et tableaux →