⚠️ Traduction non officielle - Cette documentation est une traduction communautaire non officielle de Docker.

Utiliser des conteneurs pour le développement PHP

Table des matières

Prérequis

Terminez Conteneuriser une application PHP.

Aperçu

Dans cette section, vous apprendrez à mettre en place un environnement de développement pour votre application conteneurisée. Cela inclut :

  • L'ajout d'une base de données locale et la persistance des données
  • L'ajout de phpMyAdmin pour interagir avec la base de données
  • La configuration de Compose pour mettre à jour automatiquement vos services Compose en cours d'exécution au fur et à mesure que vous modifiez et enregistrez votre code
  • La création d'un conteneur de développement contenant les dépendances de développement

Ajouter une base de données locale et persister les données

Vous pouvez utiliser des conteneurs pour mettre en place des services locaux, comme une base de données. Pour ce faire pour l'application exemple, vous devrez effectuer les opérations suivantes :

  • Mettre à jour le Dockerfile pour installer les extensions permettant de se connecter à la base de données
  • Mettre à jour le fichier compose.yaml pour ajouter un service de base de données et un volume pour persister les données

Mettre à jour le Dockerfile pour installer les extensions

Pour installer les extensions PHP, vous devez mettre à jour le Dockerfile. Ouvrez votre Dockerfile dans un EDI ou un éditeur de texte, puis mettez à jour le contenu. Le Dockerfile suivant inclut une nouvelle ligne qui installe les extensions pdo et pdo_mysql. Tous les commentaires ont été supprimés.

# syntax=docker/dockerfile:1

FROM composer:lts as deps
WORKDIR /app
RUN --mount=type=bind,source=composer.json,target=composer.json \
    --mount=type=bind,source=composer.lock,target=composer.lock \
    --mount=type=cache,target=/tmp/cache \
    composer install --no-dev --no-interaction

FROM php:8.2-apache as final
RUN docker-php-ext-install pdo pdo_mysql
RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
COPY --from=deps app/vendor/ /var/www/html/vendor
COPY ./src /var/www/html
USER www-data

Pour plus de détails sur l'installation des extensions PHP, consultez l'Image Docker officielle pour PHP.

Mettre à jour le fichier compose.yaml pour ajouter une base de données et persister les données

Ouvrez le fichier compose.yaml dans un EDI ou un éditeur de texte. Vous remarquerez qu'il contient déjà des instructions commentées pour une base de données PostgreSQL et un volume. Pour cette application, vous utiliserez MariaDB. Pour plus de détails sur MariaDB, consultez l'Image Docker officielle de MariaDB.

Ouvrez le fichier src/database.php dans un EDI ou un éditeur de texte. Vous remarquerez qu'il lit les variables d'environnement pour se connecter à la base de données.

Dans le fichier compose.yaml, vous devrez mettre à jour ce qui suit :

  1. Décommentez et mettez à jour les instructions de la base de données pour MariaDB.
  2. Ajoutez un secret au service serveur pour passer le mot de passe de la base de données.
  3. Ajoutez les variables d'environnement de connexion à la base de données au service serveur.
  4. Décommentez les instructions de volume pour persister les données.

Voici le fichier compose.yaml mis à jour. Tous les commentaires ont été supprimés.

services:
  server:
    build:
      context: .
    ports:
      - 9000:80
    depends_on:
      db:
        condition: service_healthy
    secrets:
      - db-password
    environment:
      - PASSWORD_FILE_PATH=/run/secrets/db-password
      - DB_HOST=db
      - DB_NAME=example
      - DB_USER=root
  db:
    image: mariadb
    restart: always
    user: root
    secrets:
      - db-password
    volumes:
      - db-data:/var/lib/mysql
    environment:
      - MARIADB_ROOT_PASSWORD_FILE=/run/secrets/db-password
      - MARIADB_DATABASE=example
    expose:
      - 3306
    healthcheck:
      test:
        [
          "CMD",
          "/usr/local/bin/healthcheck.sh",
          "--su-mysql",
          "--connect",
          "--innodb_initialized",
        ]
      interval: 10s
      timeout: 5s
      retries: 5
volumes:
  db-data:
secrets:
  db-password:
    file: db/password.txt
Note

Pour en savoir plus sur les instructions du fichier Compose, consultez la référence du fichier Compose.

Avant d'exécuter l'application à l'aide de Compose, notez que ce fichier Compose utilise des secrets et spécifie un fichier password.txt pour contenir le mot de passe de la base de données. Vous devez créer ce fichier car il n'est pas inclus dans le dépôt source.

Dans le répertoire docker-php-sample, créez un nouveau répertoire nommé db et à l'intérieur de ce répertoire, créez un fichier nommé password.txt. Ouvrez password.txt dans un EDI ou un éditeur de texte et ajoutez le mot de passe suivant. Le mot de passe doit être sur une seule ligne, sans lignes supplémentaires dans le fichier.

example

Enregistrez et fermez le fichier password.txt.

Vous devriez maintenant avoir ce qui suit dans votre répertoire docker-php-sample.

├── docker-php-sample/
│ ├── .git/
│ ├── db/
│ │ └── password.txt
│ ├── src/
│ ├── tests/
│ ├── .dockerignore
│ ├── .gitignore
│ ├── compose.yaml
│ ├── composer.json
│ ├── composer.lock
│ ├── Dockerfile
│ ├── README.Docker.md
│ └── README.md

Exécutez la commande suivante pour démarrer votre application.

$ docker compose up --build

Ouvrez un navigateur et affichez l'application à l'adresse http://localhost:9000/database.php. Vous devriez voir une application web simple avec du texte et un compteur qui s'incrémente à chaque rafraîchissement.

Appuyez sur ctrl+c dans le terminal pour arrêter votre application.

Vérifier que les données persistent dans la base de données

Dans le terminal, exécutez docker compose rm pour supprimer vos conteneurs, puis exécutez docker compose up pour relancer votre application.

$ docker compose rm
$ docker compose up --build

Rafraîchissez http://localhost:9000/database.php dans votre navigateur et vérifiez que le décompte précédent existe toujours. Sans volume, les données de la base de données ne persisteraient pas après la suppression du conteneur.

Appuyez sur ctrl+c dans le terminal pour arrêter votre application.

Ajouter phpMyAdmin pour interagir avec la base de données

Vous pouvez facilement ajouter des services à votre pile d'applications en mettant à jour le fichier compose.yaml.

Mettez à jour votre compose.yaml pour ajouter un nouveau service pour phpMyAdmin. Pour plus de détails, consultez l'Image Docker officielle de phpMyAdmin. Voici le fichier compose.yaml mis à jour.

services:
  server:
    build:
      context: .
    ports:
      - 9000:80
    depends_on:
      db:
        condition: service_healthy
    secrets:
      - db-password
    environment:
      - PASSWORD_FILE_PATH=/run/secrets/db-password
      - DB_HOST=db
      - DB_NAME=example
      - DB_USER=root
  db:
    image: mariadb
    restart: always
    user: root
    secrets:
      - db-password
    volumes:
      - db-data:/var/lib/mysql
    environment:
      - MARIADB_ROOT_PASSWORD_FILE=/run/secrets/db-password
      - MARIADB_DATABASE=example
    expose:
      - 3306
    healthcheck:
      test:
        [
          "CMD",
          "/usr/local/bin/healthcheck.sh",
          "--su-mysql",
          "--connect",
          "--innodb_initialized",
        ]
      interval: 10s
      timeout: 5s
      retries: 5
  phpmyadmin:
    image: phpmyadmin
    ports:
      - 8080:80
    depends_on:
      - db
    environment:
      - PMA_HOST=db
volumes:
  db-data:
secrets:
  db-password:
    file: db/password.txt

Dans le terminal, exécutez docker compose up pour relancer votre application.

$ docker compose up --build

Open http://localhost:8080 in your browser to access phpMyAdmin. Log in using root as the username and example as the password. You can now interact with the database through phpMyAdmin.

Press ctrl+c in the terminal to stop your application.

Automatically update services

Use Compose Watch to automatically update your running Compose services as you edit and save your code. For more details about Compose Watch, see Use Compose Watch.

Open your compose.yaml file in an IDE or text editor and then add the Compose Watch instructions. The following is the updated compose.yaml file.

services:
  server:
    build:
      context: .
    ports:
      - 9000:80
    depends_on:
      db:
        condition: service_healthy
    secrets:
      - db-password
    environment:
      - PASSWORD_FILE_PATH=/run/secrets/db-password
      - DB_HOST=db
      - DB_NAME=example
      - DB_USER=root
    develop:
      watch:
        - action: sync
          path: ./src
          target: /var/www/html
  db:
    image: mariadb
    restart: always
    user: root
    secrets:
      - db-password
    volumes:
      - db-data:/var/lib/mysql
    environment:
      - MARIADB_ROOT_PASSWORD_FILE=/run/secrets/db-password
      - MARIADB_DATABASE=example
    expose:
      - 3306
    healthcheck:
      test:
        [
          "CMD",
          "/usr/local/bin/healthcheck.sh",
          "--su-mysql",
          "--connect",
          "--innodb_initialized",
        ]
      interval: 10s
      timeout: 5s
      retries: 5
  phpmyadmin:
    image: phpmyadmin
    ports:
      - 8080:80
    depends_on:
      - db
    environment:
      - PMA_HOST=db
volumes:
  db-data:
secrets:
  db-password:
    file: db/password.txt

Run the following command to run your application with Compose Watch.

$ docker compose watch

Open a browser and verify that the application is running at http://localhost:9000/hello.php.

Any changes to the application's source files on your local machine will now be immediately reflected in the running container.

Open hello.php in an IDE or text editor and update the string Hello, world! to Hello, Docker!.

Save the changes to hello.php and then wait a few seconds for the application to sync. Refresh http://localhost:9000/hello.php in your browser and verify that the updated text appears.

Press ctrl+c in the terminal to stop Compose Watch. Run docker compose down in the terminal to stop the application.

Create a development container

At this point, when you run your containerized application, Composer isn't installing the dev dependencies. While this small image is good for production, it lacks the tools and dependencies you may need when developing and it doesn't include the tests directory. You can use multi-stage builds to build stages for both development and production in the same Dockerfile. For more details, see Multi-stage builds.

In the Dockerfile, you'll need to update the following:

  1. Split the deps staged into two stages. One stage for production (prod-deps) and one stage (dev-deps) to install development dependencies.
  2. Create a common base stage.
  3. Create a new development stage for development.
  4. Update the final stage to copy dependencies from the new prod-deps stage.

The following is the Dockerfile before and after the changes.

FROM composer:lts as deps
WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --no-scripts
COPY . .
RUN composer dump-autoload --optimize --classmap-authoritative

FROM php:8.2-apache as final
WORKDIR /var/www/html
RUN rm -rf /var/www/html/*
COPY --from=deps /app/src /var/www/html

EXPOSE 80

Summary

In this section, you learned how to use multi-stage builds and Compose Watch to enhance your development experience. Multi-stage builds let you create different images for different environments from a single Dockerfile. And, Compose Watch lets you automatically update your services as you edit and save your code.

Related information:

Next steps

In the next section, you'll learn how to run tests with Docker Compose.

Exécuter des tests PHP dans un conteneur »