Installer PHP 8.1 et configurer un environnement de développement local sur Ubuntu

Une version précédente de ce tutoriel a été écrite par alenaholligan.

Introduction

PHP est un langage de script côté serveur populaire et open-source, conçu pour le développement web, et alimente une part importante d'Internet, des blogs et sites de commerce électronique aux applications à grande échelle. À chaque nouvelle version, PHP offre une meilleure performance, une sécurité renforcée et des fonctionnalités de développement modernes pour aider les développeurs à créer des logiciels robustes et évolutifs.

PHP 8.1 est une version stable et à support long terme qui apporte des améliorations notables et de nouvelles fonctionnalités linguistiques tout en maintenant la fiabilité. Installer PHP 8.1 sur Ubuntu garantit que votre environnement de développement local est à jour, sécurisé et compatible avec des frameworks et plateformes largement utilisés comme WordPress, Laravel et les applications PHP personnalisées.

Ce tutoriel vous guide dans l'installation de PHP 8.1 sur Ubuntu, sa configuration avec Apache ou Nginx, la mise en place des extensions PHP essentielles et l'installation de Composer pour la gestion des dépendances. Vous apprendrez également à vérifier votre installation et à résoudre les problèmes courants.

Points clés

• Installation de PHP 8.1 sur Ubuntu 22.04 : Ubuntu 22.04 LTS inclut PHP 8.1 dans ses dépôts par défaut, vous permettant d’installer une version stable de PHP à support à long terme en utilisant apt sans PPA tiers. Cela garantit des mises à jour prévisibles, des correctifs de sécurité et la compatibilité avec les frameworks PHP modernes.

• Extensions PHP essentielles pour des projets réels : La plupart des applications PHP de niveau production dépendent d'extensions telles que mysql, curl, xml, mbstring, zip, gd et bcmath. Les installer dès le départ permet d'éviter les erreurs à l'exécution et garantit la compatibilité avec des frameworks tels que Laravel, Symfony et WordPress.

• Choisir Apache ou Nginx pour le développement PHP : Apache peut exécuter PHP directement en utilisant mod_php, tandis que Nginx nécessite PHP‑FPM pour gérer les requêtes. Les deux approches fonctionnent bien pour le développement local, mais PHP‑FPM reflète davantage les environnements de production modernes et gère mieux la charge.

• Composer comme fondement des flux de travail PHP modernes : Composer gère les dépendances d'un projet via composer.json et composer.lock, garantissant des constructions cohérentes sur différentes machines. Il est essentiel pour installer des frameworks, générer des chargeurs automatiques et maintenir des versions de dépendances fiables dans les projets PHP collaboratifs.

• Configurer PHP spécifiquement pour le développement : Les environnements de développement bénéficient d'un rapport d'erreurs détaillé, de limites de mémoire plus élevées et de durées d'exécution plus longues. Ajuster ces paramètres dans php.ini permet de détecter rapidement les bugs pendant le développement, mais ils doivent toujours être rétablis pour les déploiements en production.

• Le dépannage et la validation font partie de la configuration : Vérifier PHP avec php -v, contrôler les extensions chargées et consulter les journaux Apache, Nginx ou PHP-FPM sont des étapes cruciales. La plupart des problèmes de configuration proviennent d'extensions manquantes, de permissions ou de directives de serveur web mal configurées.

Prérequis

Pour terminer ce tutoriel, vous avez besoin de :

• Un ordinateur local ou un serveur virtuel exécutant Ubuntu (compatible avec Ubuntu 22.04 LTS et les versions ultérieures)
• Accès administratif (sudo) à la machine
• Une connexion Internet active
• Connaissance de base de la ligne de commande

Si vous configurez un nouveau serveur Ubuntu, consultez notre guide sur la configuration initiale d'un serveur avec Ubuntu.

Étape 1 — Configuration de PHP 8.1

Vous allez compléter votre installation et configuration via la ligne de commande, ce qui est une manière non graphique d'interagir avec votre ordinateur. C'est-à-dire qu'au lieu de cliquer sur des boutons, vous allez taper du texte et recevoir des retours de votre ordinateur également sous forme de texte.

La ligne de commande, également appelée shell ou terminal, peut vous aider à modifier et à automatiser de nombreuses tâches que vous effectuez sur un ordinateur au quotidien et constitue un outil essentiel pour les développeurs de logiciels. Il existe de nombreuses commandes de terminal à apprendre qui peuvent vous permettre de réaliser des actions plus puissantes. L'article Une introduction au terminal Linux peut vous aider à mieux vous familiariser avec le terminal.

Sur Ubuntu, vous pouvez trouver l'application Terminal en cliquant sur l'icône Ubuntu dans le coin supérieur gauche de votre écran et en tapant terminal dans la barre de recherche. Cliquez sur l'icône de l'application Terminal pour l'ouvrir. Vous pouvez également appuyer simultanément sur les touches CTRL, ALT et T de votre clavier pour ouvrir automatiquement l'application Terminal.

Exécutez les commandes suivantes pour mettre à jour votre liste de packages disponibles, puis installez PHP 8.1 :

sudo apt update

sudo apt install --no-install-recommends php8.1

L'option --no-install-recommends garantira que d'autres paquets comme le serveur web Apache ne soient pas installés.

Vérifiez les informations de votre version PHP avec la commande suivante :

php -v

Vous recevrez une sortie comme celle-ci :

PHP 8.1.2-1ubuntu2.22 (cli) (built: Jul 15 2025 12:11:22) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
    with Zend OPcache v8.1.2-1ubuntu2.22, Copyright (c), by Zend Technologies

Cette configuration a été testée sur Ubuntu 22.04 LTS en utilisant les paquets PHP 8.1 des dépôts officiels d'Ubuntu.

Installez les extensions PHP essentielles pour le développement web :

sudo apt install -y php8.1-cli php8.1-common php8.1-mysql php8.1-zip php8.1-gd php8.1-mbstring php8.1-curl php8.1-xml php8.1-bcmath

Cette commande installera les modules suivants :

• php8.1-cli - interpréteur de commandes, utile pour tester des scripts PHP depuis un terminal ou effectuer des tâches de script shell générales
• php8.1-common - documentation, exemples et modules courants pour PHP
• php8.1-mysql - pour travailler avec des bases de données MySQL
• php8.1-zip - pour travailler avec des fichiers compressés
• php8.1-gd - pour travailler avec des images
• php8.1-mbstring - utilisé pour gérer les chaînes non ASCII
• php8.1-curl - vous permet d'effectuer des requêtes HTTP en PHP
• php8.1-xml - pour travailler avec des données XML
• php8.1-bcmath - utilisé lors du travail avec des flottants de précision

Les fichiers de configuration PHP sont stockés dans /etc/php/8.1/. Le fichier de configuration principal est php.ini, qui peut se trouver dans différents répertoires selon votre configuration :

• Configuration CLI : /etc/php/8.1/cli/php.ini
• Configuration d'Apache : /etc/php/8.1/apache2/php.ini (si Apache est installé)
• Configuration de PHP-FPM : /etc/php/8.1/fpm/php.ini (si PHP-FPM est installé)

Vérifier les extensions installées :

php -m

Cela répertorie tous les modules PHP chargés. Si php -v affiche une version différente de celle attendue, vous pouvez avoir plusieurs versions de PHP installées. Utilisez php8.1 -v pour vérifier spécifiquement PHP 8.1.

Vous avez installé PHP et vérifié la version que vous utilisez. Vous avez également installé tous les modules PHP requis et avez pu lister les modules que vous avez chargés.

Étape 2 — Configuration de PHP avec Apache

Installez le module PHP d'Apache :

sudo apt install libapache2-mod-php8.1

Activez le module et redémarrez Apache :

sudo a2enmod php8.1
sudo systemctl restart apache2

Comprendre mod_php : Le module mod_php intègre PHP directement dans le processus d’Apache. Lorsqu’Apache reçoit une requête pour un fichier PHP, il le traite en interne à l’aide de l’interpréteur PHP intégré. Cela diffère de Nginx, qui nécessite un service PHP-FPM séparé. La commande a2enmod crée un lien symbolique dans /etc/apache2/mods-enabled/ pour activer le module.

Vérifiez qu'Apache traite correctement le PHP en créant un fichier de test dans le répertoire racine des documents d'Apache (généralement /var/www/html) :

echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

Visitez http://localhost/info.php dans votre navigateur. Vous devriez voir la page d’informations de configuration de PHP. Supprimez ce fichier après les tests pour des raisons de sécurité :

sudo rm /var/www/html/info.php

Résolution des problèmes Apache PHP

Si Apache ne démarre pas après l'installation de mod_php :

Vérifiez le journal des erreurs d’Apache :

sudo tail -20 /var/log/apache2/error.log

Les problèmes courants incluent :

• Modules PHP conflictuels : Si vous avez plusieurs versions de PHP, désactivez d'abord les autres modules PHP avec sudo a2dismod php7.4 (si présent)
• Erreurs de syntaxe dans la configuration d'Apache : Exécutez sudo apache2ctl configtest pour vérifier

Si vous visitez localhost et voyez « Ça fonctionne ! » mais que les fichiers PHP apparaissent en texte brut :

Cela signifie qu'Apache ne traite pas PHP. Vérifiez :

1. Vérifiez que le module est activé :

apache2ctl -M | grep php

1. Si rien n’apparaît, le module n’est pas chargé. Réactivez-le :

sudo a2enmod php8.1
sudo systemctl restart apache2

1. Vérifiez que votre fichier PHP a la bonne extension (.php) et contient du code PHP

Si vous recevez une erreur 403 Interdit :

Vérifiez les permissions du fichier :

sudo chown -R www-data:www-data /var/www/html
sudo chmod -R 755 /var/www/html

Configuration des hôtes virtuels Apache

Pour le développement local avec des domaines personnalisés, créez un hôte virtuel :

sudo nano /etc/apache2/sites-available/example.local.conf

Ajoutez cette configuration :

<VirtualHost *:80>
    ServerName example.local
    DocumentRoot /var/www/example.local
    <Directory /var/www/example.local>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

• ServerName : Le nom de domaine pour cet hôte virtuel
• DocumentRoot : Où vos fichiers PHP sont situés
• AllowOverride All : Permet aux fichiers .htaccess de remplacer les paramètres d’Apache (nécessaire pour des frameworks comme Laravel)
• Require all granted : Autorise l'accès au répertoire

Créez le répertoire, activez le site et redémarrez Apache :

sudo mkdir -p /var/www/example.local
sudo chown -R www-data:www-data /var/www/example.local
sudo a2ensite example.local.conf
sudo systemctl restart apache2

Ajoutez le domaine à votre fichier /etc/hosts pour un accès local :

echo "127.0.0.1 example.local" | sudo tee -a /etc/hosts

Choisir entre Apache et Nginx

Avant de configurer votre serveur web, réfléchissez à celui qui correspond le mieux à vos besoins :

Quand choisir Apache :

• Vous êtes familier avec Apache ou avez besoin d’une assistance pour .htaccess
• Configurer un environnement de développement simple
• Travailler avec des frameworks qui dépendent fortement de .htaccess (certains configurations de WordPress)
• Vous préférez une configuration initiale plus simple

Quand choisir Nginx :

• Vous avez besoin de meilleures performances sous forte charge
• Vous voulez refléter les environnements de production modernes
• Vous créez des applications qui évolueront
• Vous préférez une architecture plus moderne

Les deux fonctionnent tout aussi bien pour le développement local. Le choix dépend souvent des préférences personnelles ou de l'infrastructure existante.

Étape 3 — Configuration de PHP avec Nginx

Installer PHP-FPM (gestionnaire de processus FastCGI) :

sudo apt install php8.1-fpm

Démarrez et activez PHP-FPM :

sudo systemctl start php8.1-fpm
sudo systemctl enable php8.1-fpm

Comprendre PHP-FPM et FastCGI : Contrairement à mod_php d’Apache, Nginx ne traite pas le PHP directement. PHP-FPM (FastCGI Process Manager) fonctionne comme un service séparé avec lequel Nginx communique via le protocole FastCGI. FastCGI est un protocole binaire pour interfacer des programmes avec des serveurs web — il est plus rapide que le CGI traditionnel car il garde les processus actifs entre les requêtes.

Lorsque Nginx reçoit une requête pour un fichier PHP, il transmet la requête à PHP-FPM via un socket Unix (ou une connexion TCP). PHP-FPM traite le code PHP et renvoie le résultat à Nginx, qui l'envoie ensuite au client. Cette séparation permet à PHP-FPM de gérer son propre pool de processus, améliorant ainsi les performances et la gestion des ressources.

Configuration du bloc de serveur Nginx

Créer une configuration de bloc de serveur :

sudo nano /etc/nginx/sites-available/example.local

Ajoutez cette configuration :

server {
    listen 80;
    server_name example.local;
    root /var/www/example.local;
    index index.php index.html index.htm;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
    }

    location ~ /\.ht {
        deny all;
    }
}

Configuration expliquée :

• root : Répertoire où se trouvent vos fichiers PHP
• location ~ \.php$ : Correspond à toutes les requêtes se terminant par .php en utilisant une expression régulière
• include snippets/fastcgi-php.conf : Inclut la configuration FastCGI par défaut de Nginx (définit SCRIPT_FILENAME et d’autres variables requises)
• fastcgi_pass unix:/var/run/php/php8.1-fpm.sock : Le socket Unix sur lequel PHP-FPM écoute. C'est ainsi que Nginx communique avec PHP-FPM. Le chemin du socket est défini dans /etc/php/8.1/fpm/pool.d/www.conf

Activez le site et testez la configuration :

sudo mkdir -p /var/www/example.local
sudo chown -R www-data:www-data /var/www/example.local
sudo ln -s /etc/nginx/sites-available/example.local /etc/nginx/sites-enabled/
sudo nginx -t

Si le test est réussi, redémarrez Nginx :

sudo systemctl restart nginx

Ajoutez le domaine à /etc/hosts :

echo "127.0.0.1 example.local" | sudo tee -a /etc/hosts

Créez un fichier PHP de test :

echo "<?php phpinfo(); ?>" | sudo tee /var/www/example.local/info.php

Visitez http://example.local/info.php. Vous devriez voir la page de configuration de PHP. Supprimez le fichier de test après vérification :

sudo rm /var/www/example.local/info.php

Résolution des problèmes Nginx PHP

Si vous recevez l'erreur « 502 Bad Gateway » :

Cela signifie que Nginx ne peut pas communiquer avec PHP-FPM. Vérifiez :

1. Vérifiez que PHP-FPM est en cours d'exécution :

sudo systemctl status php8.1-fpm

1. Vérifiez que le chemin du socket est correct. L'emplacement du socket est défini dans /etc/php/8.1/fpm/pool.d/www.conf :

grep listen /etc/php/8.1/fpm/pool.d/www.conf

Vous devriez voir quelque chose comme listen=/run/php/php8.1-fpm.sock. Le chemin dans votre configuration Nginx doit correspondre exactement. Notez que /var/run est souvent un lien symbolique vers /run, donc les deux chemins fonctionnent.

1. Vérifiez les permissions du fichier socket :

ls -la /var/run/php/php8.1-fpm.sock

La socket doit être détenue par www-data ou par l'utilisateur sous lequel Nginx s'exécute. Si les permissions sont incorrectes :

sudo chown www-data:www-data /var/run/php/php8.1-fpm.sock

1. Vérifiez le journal des erreurs Nginx :

sudo tail -20 /var/log/nginx/error.log

Vous pourriez voir des erreurs comme :

connect() to unix:/var/run/php/php8.1-fpm.sock failed (2: No such file or directory)

Cela indique que le chemin de la socket est incorrect ou que PHP-FPM n’est pas en cours d’exécution.

Si les fichiers PHP se téléchargent au lieu de s'exécuter :

Cela signifie que Nginx ne transmet pas les fichiers PHP à PHP-FPM. Vérifiez :

• Le bloc location ~ \.php$ existe dans la configuration de votre serveur
• La directive fastcgi_pass pointe vers le bon socket
• Vous avez redémarré Nginx après avoir effectué des modifications

Si vous recevez des erreurs « Fichier introuvable » :

Vérifiez que snippets/fastcgi-php.conf existe :

ls -la /etc/nginx/snippets/fastcgi-php.conf

Ce fichier définit SCRIPT_FILENAME, ce qui indique à PHP-FPM quel fichier exécuter. Sans cela, PHP-FPM ne sait pas quel fichier traiter.

Étape 4 — Configuration de PHP pour le développement

Configurez PHP pour le développement en ajustant les paramètres de rapport d'erreurs, d'affichage et les limites de mémoire dans php.ini. Ces paramètres diffèrent des configurations de production.

PHP utilise des fichiers de configuration séparés pour l'utilisation en ligne de commande (CLI) et sur serveur web. Modifiez le fichier approprié :

Pour le CLI (lors de l'exécution de PHP depuis le terminal) :

sudo nano /etc/php/8.1/cli/php.ini

Pour le serveur web (Apache ou Nginx avec PHP-FPM) :

# For Apache
sudo nano /etc/php/8.1/apache2/php.ini

# For PHP-FPM (Nginx)
sudo nano /etc/php/8.1/fpm/php.ini

Paramètres essentiels de développement

Trouvez et mettez à jour ces paramètres dans votre fichier php.ini :

display_errors = On
display_startup_errors = On
error_reporting = E_ALL
log_errors = On
error_log = /var/log/php_errors.log
memory_limit = 256M
upload_max_filesize = 64M
post_max_size = 64M
max_execution_time = 300
date.timezone = America/New_York

Ce que fait chaque paramètre :

• display_errors=On : Affiche les erreurs PHP directement dans le navigateur (utile pour le débogage, dangereux en production)
• display_startup_errors=On : Affiche les erreurs qui se produisent lors du démarrage de PHP
• error_reporting=E_ALL : Signale tous les types d'erreurs (avertissements, notifications, etc.)
• log_errors=On : Écrit les erreurs dans un fichier journal
• error_log : Où PHP écrit les journaux d'erreurs
• memory_limit=256M : Mémoire maximale qu'un script peut utiliser (augmentez si vous obtenez des erreurs « mémoire épuisée »)
• upload_max_filesize=64M : Taille maximale des fichiers téléversés
• post_max_size=64M : Taille maximale pour les données POST (doit être supérieure à upload_max_filesize)
• max_execution_time=300 : Temps maximum pendant lequel un script peut s'exécuter (en secondes)
• date.timezone : Définit le fuseau horaire par défaut (utilisez votre fuseau horaire local : Asia/Kolkata, Europe/London, UTC, etc.)

Après avoir apporté des modifications, redémarrez votre serveur web :

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

Vérification de votre configuration

Vérifiez si vos modifications ont été prises en compte :

# For CLI
php -i | grep display_errors

# For web server (create a test file)
echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/test.php

Visitez le fichier de test dans votre navigateur et recherchez display_errors. Il devrait afficher On. Supprimez le fichier de test après vérification.

Si vos modifications n’apparaissent pas :

1. Assurez-vous d'avoir modifié le bon fichier php.ini (CLI ou serveur web)
2. Vérifiez les fautes de frappe dans les noms des paramètres (ils sont sensibles à la casse)
3. Redémarrez votre serveur web après avoir apporté des modifications
4. Certaines configurations peuvent être remplacées par .htaccess (Apache) ou php.ini dans le répertoire de votre projet

Vous pourriez commencer à utiliser PHP dès maintenant, mais vous voudrez probablement utiliser différentes bibliothèques pour créer des applications PHP rapidement. Avant de tester votre environnement PHP, configurez d'abord un gestionnaire de dépendances pour vos projets.

Étape 5 — Configurer Composer pour la gestion des dépendances (Optionnel)

Les bibliothèques sont des ensembles de code qui peuvent vous aider à résoudre des problèmes courants sans avoir à tout écrire vous-même. Puisqu'il existe de nombreuses bibliothèques disponibles, utiliser un gestionnaire de dépendances vous aidera à gérer plusieurs bibliothèques à mesure que vous gagnerez en expérience dans l'écriture de PHP.

Composer est un outil de gestion des dépendances en PHP. Il vous permet de déclarer les bibliothèques dont votre projet dépend et gère l'installation et la mise à jour de ces packages.

Bien que similaire, Composer n'est pas un gestionnaire de paquets au même sens que yum ou apt. Il gère des « paquets » ou des bibliothèques, mais il les gère au niveau de chaque projet, en les installant dans un répertoire (par exemple vendor) à l'intérieur de votre projet. Par défaut, il n'installe rien de manière globale. C'est donc un gestionnaire de dépendances. Il prend toutefois en charge un projet global pour plus de commodité via la commande global.

Cette idée n'est pas nouvelle, et Composer s'inspire fortement de npm de Node et de bundler de Ruby.

Supposons :

• Vous avez un projet qui dépend de plusieurs bibliothèques.
• Certaines de ces bibliothèques dépendent d'autres bibliothèques.

Compositeur :

• Vous permet de déclarer les bibliothèques dont vous dépendez.
• Détermine quelles versions de quels paquets peuvent et doivent être installées, et les installe en les téléchargeant dans votre projet.
• Vous permet de mettre à jour toutes vos dépendances en une seule commande.
• Vous permet de consulter le chapitre Utilisation de base pour plus de détails sur la déclaration des dépendances.

Téléchargez l'installateur de Composer :

curl -sS https://getcomposer.org/installer -o /tmp/composer-setup.php

Vérifiez l'intégrité de l'installateur en contrôlant son empreinte SHA-384. Obtenez la dernière empreinte :

HASH=$(curl -sS https://composer.github.io/installer.sig)

Vérifiez que le hachage correspond :

php -r "if (hash_file('SHA384', '/tmp/composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('/tmp/composer-setup.php'); } echo PHP_EOL;"

Vous devriez voir :

Installer verified

Si vous voyez Installateur corrompu, le téléchargement était incomplet ou a été altéré. Téléchargez à nouveau l'installateur et vérifiez le hachage. Si cela échoue encore, vérifiez votre connexion Internet ou essayez de télécharger depuis un autre réseau.

Installer Composer globalement :

sudo php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer

Vous recevrez un résultat similaire à ceci :

All settings correct for using Composer
Downloading...

Composer (version 2.3.5) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer

Testez votre installation :

composer

Vous recevrez une sortie comme suit :

   ______
  / ____/___  ____ ___  ____  ____  ________  _____
 / /   / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/
/ /___/ /_/ / / / / / / /_/ / /_/ (__  )  __/ /
\____/\____/_/ /_/ /_/ .___/\____/____/\___/_/
                    /_/
Composer version 2.3.5 2022-04-13 16:43:00

Usage:
  command [options] [arguments]

Options:
  -h, --help                     Display help for the given command. When no command is given display help for the list command
  -q, --quiet                    Do not output any message
  -V, --version                  Display this application version
      --ansi|--no-ansi           Force (or disable --no-ansi) ANSI output
  -n, --no-interaction           Do not ask any interactive question
      --profile                  Display timing and memory usage information
      --no-plugins               Whether to disable plugins.
      --no-scripts               Skips the execution of all scripts defined in composer.json file.
  -d, --working-dir=WORKING-DIR  If specified, use the given directory as working directory.
      --no-cache                 Prevent use of the cache
  -v|vv|vvv, --verbose           Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug
. . .

Cela vérifie que Composer a été installé avec succès sur votre système et est disponible à l'échelle du système.

Étape 6 — Utiliser Composer dans un projet PHP

Comme dernière étape, vous pouvez éventuellement initialiser votre projet avec composer init. Cela créera le fichier composer.json qui gérera les dépendances de votre projet. L'initialisation du projet vous permettra également de définir des détails sur le projet tels que l'auteur et la licence, et d'utiliser la fonctionnalité d'auto-chargement de Composer. Vous pouvez définir les dépendances dès maintenant ou les ajouter plus tard.

Créez un répertoire de projet et initialisez Composer :

cd ~
mkdir example-project
cd example-project
composer init

Exécuter cette commande démarrera l'assistant de configuration. Les informations que vous saisissez dans l'assistant peuvent être mises à jour ultérieurement, alors n'hésitez pas à laisser les valeurs par défaut et à simplement appuyer sur ENTER. Si vous n'êtes pas prêt à installer des dépendances, vous pouvez choisir no. Saisissez vos informations à chaque invite :

                                            
  Welcome to the Composer config generator  
                                            


This command will guide you through creating your composer.json config.

Package name (<vendor>/<name>) [sammy/example-project]:  sammy/project1
Description []:
Author [n to skip]: Sammy <sammy@linux-console.net>
Minimum Stability []: 
Package Type (e.g. library, project, metapackage, composer-plugin) []: project
License []: 

Define your dependencies.

Would you like to define your dependencies (require) interactively [yes]? no
Would you like to define your dev dependencies (require-dev) interactively [yes]? no

Add PSR-4 autoload mapping? Maps namespace "Sammy\Project1" to the entered relative path. [src/, n to skip]: n

{
    "name": "sammy/project1",
    "type": "project",
    "authors": [
        {
            "name": "Sammy",
            "email": "sammy@linux-console.net"
        }
    ],
    "require": {}
}

Do you confirm generation [yes]? yes

Avant de confirmer la génération, vous verrez un exemple du fichier composer.json que l'assistant va créer. Si tout semble correct, vous pouvez confirmer le choix par défaut oui. Si vous avez besoin de recommencer, choisissez non.

La première fois que vous définissez une dépendance, Composer créera un dossier vendor. Toutes les dépendances sont installées dans ce dossier vendor. Composer crée également un fichier composer.lock. Ce fichier spécifie la version exacte de chaque dépendance et sous-dépendance utilisée dans votre projet. Cela garantit que toute machine sur laquelle votre programme est exécuté utilisera exactement la même version de chaque package.

Maintenant que vous avez installé PHP et un moyen de gérer les dépendances de votre projet avec Composer, vous êtes prêt à tester votre environnement.

Étape 7 — Tester l'environnement PHP

Créez et exécutez un script PHP de base pour tester votre installation :

nano hello.php

Ajoutez le code PHP suivant :

<?php
echo 'Hello World!';
?>

Enregistrez et fermez le fichier (appuyez sur CTRL+X, puis Y, puis ENTRÉE). Exécutez le script :

php hello.php

Si le PHP est correctement exécuté, vous ne verrez que les caractères entre les guillemets :

Hello World!

PHP a traité le script avec succès, ce qui signifie que votre environnement PHP est correctement installé et que vous êtes prêt à continuer votre parcours de programmation.

Étape 8 — Configuration de projets PHP réels

Les frameworks PHP modernes comme Laravel, Symfony et WordPress nécessitent des extensions PHP spécifiques et Composer. Installez le framework en utilisant Composer ou l’installateur du framework, puis configurez votre serveur web pour qu’il pointe vers le répertoire public du projet.

Configurer Laravel

Installez Laravel en utilisant Composer :

composer create-project laravel/laravel my-laravel-app
cd my-laravel-app

Cette commande télécharge Laravel et toutes ses dépendances. Le processus peut prendre quelques minutes.

Laravel nécessite ces extensions PHP (installées à l'étape 1) :

• php8.1-mbstring - Gestion des chaînes multioctets
• php8.1-xml - Analyse XML
• php8.1-curl - requêtes HTTP
• php8.1-zip - Gestion des archives
• php8.1-bcmath - Mathématiques à précision arbitraire

Si Laravel indique « mbstring manquant » même si vous l'avez installé :

Cela signifie généralement que l'extension est installée mais non chargée. Vérifiez :

1. Vérifiez que l'extension est installée :

php -m | grep mbstring

1. S'il est manquant, installez-le :

sudo apt install php8.1-mbstring

1. S’il est installé mais n’apparaît pas, redémarrez votre serveur web :

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

1. Vérifiez quel fichier php.ini est utilisé. L'installateur de Laravel utilise PHP en ligne de commande, donc vérifiez :

php --ini

Assurez-vous que l'extension est activée dans le fichier php.ini de la CLI.

Vérification de l'installation de Laravel :

Une fois l'installation terminée, démarrez le serveur de développement de Laravel :

php artisan serve

Vous devriez voir :

INFO  Server running on [http://127.0.0.1:8000]

Visitez http://localhost:8000 dans votre navigateur. Vous devriez voir la page d'accueil de Laravel.

Pour les environnements proches de la production avec Apache ou Nginx :

Configurez votre serveur web pour qu'il pointe vers le répertoire public (et non vers la racine du projet). Le fichier public/index.php de Laravel est le point d'entrée pour toutes les requêtes.

Configurer WordPress

Téléchargez et extrayez WordPress :

cd /var/www
sudo wget https://wordpress.org/latest.tar.gz
sudo tar -xzf latest.tar.gz
sudo chown -R www-data:www-data /var/www/wordpress

WordPress nécessite une base de données MySQL ou MariaDB. Installez MySQL si nécessaire :

sudo apt install mysql-server
sudo mysql_secure_installation

Le script mysql_secure_installation vous invitera à :

• Définir un mot de passe root
• Supprimer les utilisateurs anonymes
• Interdire la connexion root à distance
• Supprimer la base de données de test
• Recharger les tables de privilèges

Créer une base de données et un utilisateur pour WordPress :

sudo mysql -u root -p

Dans l'invite MySQL :

CREATE DATABASE wordpress_db;
CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'secure_password';
GRANT ALL PRIVILEGES ON wordpress_db.* TO 'wpuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Remplacez secure_password par un mot de passe sécurisé. WordPress utilisera ces informations d'identification pour se connecter à la base de données.

Si WordPress ne peut pas se connecter à la base de données :

1. Vérifiez que MySQL fonctionne :

sudo systemctl status mysql

1. Tester la connexion à la base de données :

mysql -u wpuser -p wordpress_db

Si cela échoue, vérifiez :

• Le nom d'utilisateur et le mot de passe sont corrects
• La base de données existe : SHOW DATABASES;
• L'utilisateur dispose des permissions : SHOW GRANTS FOR 'wpuser'@'localhost';

1. Vérifiez que l'extension MySQL de PHP est installée :

php -m | grep mysql

Si elle est absente, installez-la :

sudo apt install php8.1-mysql
sudo systemctl restart apache2  # or php8.1-fpm for Nginx

Finalisation de l'installation de WordPress :

Configurez votre serveur web pour qu'il pointe vers /var/www/wordpress (voir l'étape 2 pour Apache ou l'étape 3 pour Nginx). Visitez le site dans votre navigateur. WordPress vous invitera à :

1. Sélectionnez votre langue
2. Entrez les identifiants de la base de données (utilisez la base de données, le nom d'utilisateur et le mot de passe que vous avez créés)
3. Terminer l'installation

Configurer Symfony

Installez Symfony en utilisant Composer :

composer create-project symfony/website-skeleton my-symfony-app
cd my-symfony-app

Symfony nécessite les mêmes extensions que Laravel. Démarrez le serveur de développement :

symfony server:start

Ou utilisez le serveur intégré de PHP :

php -S localhost:8000 -t public

Si l'installation de Symfony échoue à cause d'erreurs d'extension :

Vérifiez que toutes les extensions requises sont installées et chargées :

php -m | grep -E 'mbstring|xml|curl|zip|bcmath'

S'ils manquent, installez-les et redémarrez votre serveur web.

Étape 9 — Meilleures pratiques pour le développement local

Sécurisez votre environnement local, utilisez le contrôle de version, configurez correctement les permissions des fichiers et mettez en place des configurations spécifiques à l'environnement. Ces pratiques préviennent les problèmes de sécurité et facilitent le développement.

Considérations de sécurité

Même en développement local, suivez les meilleures pratiques de sécurité :

1. Désactiver les fonctions PHP dangereuses en production : Les fonctions comme exec(), system() et shell_exec() doivent être limitées dans les fichiers php.ini de production.

2. Utilisez des variables d'environnement : stockez les configurations sensibles dans des fichiers .env (ne les validez jamais dans le contrôle de version). Laravel et Symfony prennent cela en charge nativement.

3. Définir les permissions de fichiers appropriées : Les fichiers du serveur web doivent être lisibles par l'utilisateur du serveur web mais non modifiables :

sudo chown -R www-data:www-data /var/www/your-project
sudo find /var/www/your-project -type d -exec chmod 755 {} \;
sudo find /var/www/your-project -type f -exec chmod 644 {} \;

Pourquoi ces permissions sont importantes : Les répertoires doivent avoir 755 (lecture, écriture, exécution pour le propriétaire ; lecture et exécution pour les autres) afin que le serveur web puisse les parcourir. Les fichiers doivent avoir 644 (lecture et écriture pour le propriétaire ; lecture seule pour les autres) afin que le serveur web puisse les lire mais pas les modifier. Cela empêche les scripts malveillants de remplacer vos fichiers.

Intégration du contrôle de version

Utilisez toujours le contrôle de version pour vos projets PHP. Initialisez Git dans le répertoire de votre projet :

cd /var/www/your-project
git init

Créez un fichier .gitignore pour exclure les fichiers inutiles :

/vendor/
/node_modules/
.env
.DS_Store
*.log

Optimisation des performances

Pour de meilleures performances en développement local :

• Activer OPcache : OPcache est inclus avec PHP 8.1 et améliore les performances en mettant en cache le code PHP compilé.

• Utilisez l’optimisation de l’autoloader de Composer :

composer install --optimize-autoloader --no-dev

• Configurez les pools PHP-FPM pour une meilleure gestion des ressources si vous utilisez Nginx.

Étape 10 — Dépannage des problèmes courants

Les problèmes courants d'installation de PHP incluent des extensions manquantes, des permissions de fichiers incorrectes, des erreurs de configuration du serveur web et des conflits de version. La plupart des problèmes peuvent être résolus en vérifiant l'installation des extensions, en contrôlant les permissions des fichiers et en consultant les journaux du serveur web.

Extensions PHP non chargées

Si php -m n’affiche pas une extension que vous venez d’installer :

• Vérifiez qu’il est réellement installé :

dpkg -l | grep php8.1-extension_name

• Vérifiez si le fichier d'extension existe :

ls /usr/lib/php/*/extension_name.so

• Vérifiez qu'il est activé dans php.ini. Certaines extensions doivent être activées explicitement :

grep -i extension_name /etc/php/8.1/*/php.ini

• Redémarrez votre serveur web :

# For Apache
sudo systemctl restart apache2

# For PHP-FPM
sudo systemctl restart php8.1-fpm

• Vérifiez quel php.ini est utilisé :

php --ini

Assurez-vous de vérifier le bon fichier php.ini (CLI ou serveur web).

Si l’extension n’apparaît toujours pas :

• Certaines extensions nécessitent des bibliothèques système supplémentaires. Consultez la documentation de l’extension.
• Vérifiez que vous avez installé la bonne version (php8.1-extension, pas php8.0-extension)
• Vérifiez les versions de PHP conflictuelles qui pourraient interférer

Erreur interne du serveur 500

Une erreur 500 signifie que le serveur a rencontré une erreur mais ne peut pas afficher les détails. Vérifiez les journaux d'erreurs :

# Apache
sudo tail -20 /var/log/apache2/error.log

# Nginx
sudo tail -20 /var/log/nginx/error.log

# PHP-FPM
sudo tail -20 /var/log/php8.1-fpm.log

Causes et solutions courantes :

1. Permissions de fichier incorrectes : les fichiers PHP doivent être lisibles par l'utilisateur du serveur web

sudo chown -R www-data:www-data /var/www/your-project
sudo find /var/www/your-project -type f -exec chmod 644 {} \;
sudo find /var/www/your-project -type d -exec chmod 755 {} \;

1. Extensions PHP manquantes : Vérifiez le journal des erreurs pour des messages du type « Appel à une fonction indéfinie ». Installez l'extension manquante et redémarrez le serveur web.

2. Erreurs de syntaxe dans les fichiers PHP : Le journal des erreurs indiquera le fichier et le numéro de ligne. Problèmes courants :

   • Points-virgules manquants
   • Crochets ou guillemets non fermés
   • Utiliser des fonctions ou des classes non définies

3. Configuration incorrecte du serveur web :

   • Apache : Vérifier la configuration de l'hôte virtuel, le chargement des modules
   • Nginx : Vérifier le chemin du socket PHP-FPM, la configuration FastCGI

4. Limite de mémoire PHP dépassée : Augmentez memory_limit dans php.ini si vous voyez des erreurs « Mémoire autorisée épuisée »

Conflits de versions PHP

Si php -v affiche une version différente de celle attendue, cela signifie que vous avez plusieurs versions de PHP installées.

Vérifiez quelles versions sont installées :

dpkg -l | grep php | grep -E 'php[0-9]'

Utilisez explicitement la version correcte :

php8.1 -v
php8.1 -m

Mettez à jour votre serveur web pour utiliser PHP 8.1 :

Pour Apache, désactivez les autres modules PHP et activez PHP 8.1 :

sudo a2dismod php7.4 php8.0  # if they exist
sudo a2enmod php8.1
sudo systemctl restart apache2

Pour PHP-FPM, arrêtez les autres versions et démarrez PHP 8.1 :

sudo systemctl stop php7.4-fpm php8.0-fpm  # if they exist
sudo systemctl start php8.1-fpm
sudo systemctl enable php8.1-fpm

Définir PHP 8.1 comme version CLI par défaut :

sudo update-alternatives --set php /usr/bin/php8.1

Problèmes de mémoire du compositeur

Si Composer manque de mémoire, vous verrez une erreur comme :

Fatal error: Allowed memory size of 134217728 bytes exhausted

Réparez-le en exécutant Composer avec plus de mémoire :

php -d memory_limit=512M /usr/local/bin/composer install

Ou augmentez la limite de mémoire de PHP dans php.ini :

memory_limit = 512M

Si l'installation de Composer échoue en raison d'un problème de correspondance de hachage :

La vérification du hachage peut échouer si :

• L'installateur a été mis à jour depuis votre téléchargement (téléchargez-le à nouveau pour obtenir le dernier hash)
• Votre téléchargement est corrompu (essayez de le télécharger à nouveau)
• Vous êtes derrière un proxy qui modifie les fichiers (vérifiez vos paramètres réseau)

Problèmes de connexion à la base de données

Si votre application PHP ne peut pas se connecter à MySQL/MariaDB, vous pourriez voir des erreurs comme :

SQLSTATE[HY000] [2002] No such file or directory

ou

Access denied for user 'username'@'localhost'

Étapes de dépannage :

1. Vérifiez que le service de base de données est en cours d'exécution :

sudo systemctl status mysql

S'il ne fonctionne pas, démarrez-le :

sudo systemctl start mysql
sudo systemctl enable mysql

1. Vérifiez que l’extension MySQL de PHP est installée :

php -m | grep mysql

Si elle est absente, installez-la :

sudo apt install php8.1-mysql
sudo systemctl restart apache2  # or php8.1-fpm for Nginx

1. Vérifiez les identifiants et les autorisations de la base de données. Testez la connexion :

mysql -u username -p database_name

Si cela échoue, vérifiez :

• Le nom d'utilisateur et le mot de passe sont corrects
• La base de données existe : SHOW DATABASES;
• L'utilisateur a les permissions : SHOW GRANTS FOR 'username'@'localhost';

Le fichier PHP s'affiche en texte clair au lieu de s'exécuter

Si votre fichier PHP s'affiche en texte brut dans le navigateur :

1. Vérifiez l'extension du fichier : elle doit être .php, et non .txt ou .html

2. Vérifiez que PHP traite les fichiers :

   • Apache : Vérifiez que mod_php est activé : apache2ctl -M | grep php
   • Nginx : Vérifiez que PHP-FPM fonctionne et que le chemin du socket est correct

3. Vérifiez les permissions du fichier : le serveur web doit pouvoir lire le fichier

4. Vérifiez que le fichier contient du code PHP : Assurez-vous qu'il commence par <?php ou <?

5. Vérifier la configuration du serveur web :

   • Apache : le hôte virtuel pourrait ne pas être configuré correctement
   • Nginx : Le bloc location ~ \.php$ pourrait être manquant ou incorrect

Problèmes de téléversement de fichiers

Si les téléchargements de fichiers échouent, vous pourriez voir des erreurs telles que :

The uploaded file exceeds the upload_max_filesize directive

Vérifiez ces paramètres php.ini :

upload_max_filesize = 64M
post_max_size = 64M
max_execution_time = 300

Important : post_max_size doit être supérieur à upload_max_filesize. Si vous définissez upload_max_filesize=100M, définissez post_max_size=110M ou plus.

Si les téléchargements échouent toujours :

1. Vérifiez le journal des erreurs pour des messages d'erreur spécifiques
2. Vérifiez que le répertoire de téléchargement existe et est accessible en écriture :

sudo chmod 755 /path/to/upload/directory
sudo chown www-data:www-data /path/to/upload/directory

1. Vérifier l'espace disque : df -h
2. Vérifiez que le formulaire utilise enctype="multipart/form-data"

Redémarrez votre serveur web après avoir modifié le fichier php.ini.

FAQ

Comment installer PHP 8.1 sur Ubuntu ?

Installez PHP 8.1 en utilisant le gestionnaire de paquets d’Ubuntu : sudo apt update && sudo apt install php8.1. PHP 8.1 est disponible dans les dépôts par défaut d’Ubuntu, donc aucune source de paquets supplémentaire n’est nécessaire.

Quelles extensions PHP sont essentielles pour le développement ?

Les extensions essentielles incluent php8.1-cli, php8.1-mysql, php8.1-curl, php8.1-xml, php8.1-mbstring, php8.1-zip, php8.1-gd et php8.1-bcmath. Elles couvrent la connectivité à la base de données, les requêtes HTTP, le traitement des chaînes et le traitement d'images.

Comment configurer PHP avec Apache ou Nginx ?

Pour Apache, installez libapache2-mod-php8.1 et activez-le avec sudo a2enmod php8.1. Pour Nginx, installez php8.1-fpm et configurez Nginx pour transmettre les requêtes PHP au socket PHP-FPM en utilisant FastCGI.

Comment puis-je vérifier si PHP est installé correctement ?

Exécutez php -v pour vérifier la version de PHP. Créez un fichier de test avec <?php phpinfo(); ?> et accédez-y via votre serveur web pour voir des informations détaillées sur la configuration de PHP.

Puis-je exécuter Laravel ou WordPress en local avec cette configuration ?

Oui. Laravel nécessite Composer et les extensions PHP standard mentionnées ci-dessus. WordPress a besoin d'une base de données MySQL en plus de PHP. Les deux frameworks fonctionnent avec des configurations Apache ou Nginx.

Comment installer Composer pour les projets PHP ?

Téléchargez l'installateur de Composer, vérifiez son hash, et installez-le globalement : sudo php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer. Vérifiez avec composer --version.

Comment résoudre les problèmes d'extensions PHP manquantes ?

Vérifiez les extensions installées avec php -m. Installez les extensions manquantes en utilisant sudo apt install php8.1-nom_de_l_extension, puis redémarrez votre serveur web.

Comment configurer la gestion des erreurs PHP pour le développement ?

Modifiez php.ini et réglez display_errors=On, error_reporting=E_ALL et log_errors=On. N'oubliez pas de désactiver l'affichage des erreurs en environnement de production.

Quelle est la différence entre Apache et Nginx pour PHP ?

Apache utilise mod_php pour traiter PHP directement (PHP est intégré dans le processus d’Apache), tandis que Nginx nécessite PHP-FPM (FastCGI Process Manager) pour gérer les requêtes PHP (PHP s’exécute comme un service séparé). Voir la section « Choisir entre Apache et Nginx » ci-dessus pour un tableau comparatif détaillé. Les deux approches fonctionnent bien ; choisissez en fonction de vos besoins en matière de performance, de votre familiarité et de l’infrastructure existante.

Puis-je installer plusieurs versions de PHP sur le même système ?

Oui, en utilisant des outils comme phpenv ou phpbrew. Cependant, pour la plupart des scénarios de développement, une seule version de PHP est suffisante. Utilisez des gestionnaires de version lorsque vous devez tester des applications avec différentes versions de PHP.

Conclusion

Vous disposez désormais d’un environnement de développement PHP 8.1 entièrement configuré sur Ubuntu avec prise en charge des serveurs web Apache et Nginx. Votre configuration comprend les extensions PHP essentielles, Composer pour la gestion des dépendances, et une configuration appropriée pour le développement local.

Avant de commencer votre prochain projet, envisagez de configurer un environnement de développement intégré (IDE) comme VS Code avec des extensions PHP pour la coloration syntaxique, le débogage et le support IntelliSense.

Avec votre environnement prêt, vous pouvez explorer davantage le développement PHP :

• Apprenez les fondamentaux de PHP avec Comment travailler avec les chaînes en PHP
• Créer des API en utilisant Comment utiliser les API Web en PHP
• Comprendre les fonctions dans Comment utiliser les fonctions en PHP
• Configurer des bases de données avec Comment Installer et Utiliser PostgreSQL sur Ubuntu

Pour les déploiements en production, envisagez d'utiliser la plateforme d'applications Linux-Console.net pour déployer vos applications PHP directement depuis GitHub avec mise à l'échelle automatique et certificats SSL.

Merci d'apprendre avec la communauté Linux-Console.net.