Déployer une application PHP à laide de Docker-compose

• Configurer notre environnement de travail
• Configuration du conteneur PHP
• Configuration du conteneur Nginx
• Configuration du conteneur MySQL
• Construire notre application
• Conclusion

Les applications PHP sont généralement composées d'un serveur Web, d'un système de base de données relationnelle et de l'interpréteur de langage lui-même. Dans ce didacticiel, nous exploiterons une pile d'applications PHP complète à l'aide de Docker. Il s'agit d'un tutoriel approfondi dans lequel nous allons construire et orchestrer des conteneurs pour Nginx (le serveur Web), MySQL (le système de base de données) et PHP.

Pour les besoins de ce tutoriel, nous allons écrire une application simple qui lit une liste de villes à partir d'une base de données et l'affiche sur une page Web, de cette façon, nous allons démontrer une application PHP basique mais fonctionnelle.

Ce guide suppose que Docker-CE est déjà installé et au moins une connaissance pratique minimale de Docker. Pour cette question, vous pouvez consulter les tutoriels suivants:

• Installation de Docker CE sur Ubuntu 16.04
• Installation de Docker CE sur CentOS 7
• Comment utiliser Docker: création de votre premier conteneur Docker

Configurer notre environnement de travail

Une application basée sur un docker réel sera généralement composée de plusieurs conteneurs. Leur gestion manuelle peut facilement devenir assez compliquée et encombrante. C'est là que le docker-compose entre en jeu. Il vous aide à gérer un certain nombre de conteneurs via un yamlfichier de configuration simple .

Installez docker-compose.

curl -L https://github.com/docker/compose/releases/download/1.19.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

Créez un dossier pour contenir tous les fichiers nécessaires de cet exemple, puis cddans celui-ci. Désormais, il s'agit de notre répertoire de travail et chaque commande sera exécutée dans ce dossier et chaque chemin sera référencé par rapport à lui. Ce dossier peut être référencé ultérieurement comme WORKING_DIR.

mkdir ~/docker
cd ~/docker

Créez maintenant trois autres dossiers.

mkdir php nginx app

Le phpdossier est l'endroit où nous allons construire notre image PHP personnalisée, le nginxdossier contiendra les fichiers nécessaires pour notre image nginx personnalisée et le appdossier est l'endroit où nous mettrons le code source et la configuration de notre exemple d'application.

Configuration du conteneur PHP

Dans cet exemple, nous allons utiliser php-fpmpour nous connecter au serveur Web Nginx. Nous utiliserons l'image de base PHP officielle. Cependant, nous devons également installer et activer certaines extensions pour pouvoir accéder à la base de données. Dans le phpdossier, créez un fichier nommé Dockerfileet mettez-y le contenu suivant.

FROM php:7.1-fpm-alpine3.4
RUN apk update --no-cache \
    && apk add --no-cache $PHPIZE_DEPS \
    && apk add --no-cache mysql-dev \
    && docker-php-ext-install pdo pdo_mysql

Notez que nous utilisons la version Alpine de l'image PHP officielle. Alpine est une très petite distribution ciblée vers les conteneurs en fournissant des empreintes beaucoup plus petites. Notez également l'utilisation de la commande docker-php-ext-install, l'image PHP officielle fournit cette commande pour faciliter le processus d'installation et de configuration des extensions PHP.

Maintenant, construisons cette image Docker en émettant ce qui suit (à l'intérieur de notre WORKING_DIR):

docker build -t vultr-php php/

Le docker-compose.ymldossier

Comme déjà mentionné, docker-composevous permet de gérer un certain nombre de conteneurs via un simple fichier de configuration. Ce fichier de configuration est généralement nommé docker-compose.yml. Créez ce fichier dans le appdossier.

touch app/docker-compose.yml

Maintenant, mettez le contenu suivant dans ce fichier.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app

Nous expliquerons cette syntaxe. Tout d'abord, notez la première ligne.

version: '2'

Ceci spécifie la version du docker-compose.ymlfichier de configuration utilisé. La ligne suivante spécifie les services, ou en d'autres termes, les conteneurs à approvisionner.

services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app

Notez que chaque service a une clé spécifique à l'intérieur du servicesbloc. Le nom spécifié ici sera utilisé pour référencer ce conteneur spécifique ultérieurement. Notez également qu'à l'intérieur de la phpconfiguration, nous définissons l'image utilisée pour exécuter le conteneur (c'est l'image que nous avons construite précédemment). Nous définissons également une cartographie des volumes.

volumes:
  - ./:/app

Cela indique docker-composede mapper le répertoire actuel ( ./) au /apprépertoire à l'intérieur du conteneur. La dernière ligne définit le /appdossier à l'intérieur du conteneur comme répertoire de travail, ce qui signifie que c'est le dossier à partir duquel toutes les futures commandes à l'intérieur d'un conteneur sont exécutées par défaut.

Nous pouvons désormais orchestrer nos conteneurs.

cd ~/docker/app
docker-compose up -d

Vous pouvez exécuter la commande suivante pour vous assurer que le conteneur PHP a été exécuté:

docker ps

Comment exécuter des commandes à l'intérieur des conteneurs

Toujours à l'intérieur du appdossier, nous pouvons exécuter n'importe quelle commande à l'intérieur d'un conteneur de service défini à l'aide de la docker-composecommande.

docker-compose exec [service] [command]

L' [service]espace réservé fait référence à la clé de service. Dans notre cas, c'était le cas php. Exécutons une commande à l'intérieur du conteneur pour vérifier notre version PHP.

docker-compose exec php php -v

Vous verrez la sortie suivante.

PHP 7.1.14 (cli) (built: Feb  7 2018 00:40:45) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.1.0, Copyright (c) 1998-2018 Zend Technologies

Configuration du conteneur Nginx

Tout comme le conteneur PHP, nous devons créer une image personnalisée pour le serveur Web. Mais dans ce cas, nous avons juste besoin de fournir une configuration pour notre virtual host. Assurez-vous que vous êtes dans notre WORKING_DIRet créez un Dockerfiledans le nginxdossier:

cd ~/docker
touch nginx/Dockerfile

Maintenant, mettez le contenu suivant dans ceci Dockerfile:

FROM nginx:1.13.8-alpine
COPY ./default.conf /etc/nginx/conf.d/default.conf

Nous utilisons l'image Nginx par défaut basée sur Alpine. Sur ce fichier Docker, nous copions simplement un fichier de configuration dans la configuration de notre application. Avant de créer cette image, créez un fichier de configuration.

touch nginx/default.conf

Remplissez-le maintenant avec ce contenu.

server {
    listen 80 default_server;
    listen [::]:80 default_server ipv6only=on;

    root /app;
    index index.php;

    #server_name server_domain_or_IP;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        try_files $uri /index.php =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

Notez qu'à la fastcgi_pass php:9000ligne, nous référençons le conteneur PHP par son nom dans le servicebloc du docker-compose.ymlfichier de configuration. Crée en interne docker-composeun réseau et attribue le nom du service comme nom d'hôte à chacun des services définis. Nous pouvons maintenant construire l'image Nginx.

docker build -t vultr-nginx nginx/

Mise à jour docker-compose.yml

Maintenant, mettez à jour le app/docker-compose.ymlfichier.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app
  web:
    image: vultr-nginx
    volumes:
      - ./:/app
    depends_on:
      - php
    ports:
      - 80:80

Nous avons seulement ajouté un nouveau service. La configuration est presque la même, à l'exception des éléments suivants.

depends_on:
  - php
ports:
  - 80:80

Une fois que le conteneur Nginx a besoin que le service PHP soit complètement initialisé, nous forçons cette exigence dans l' depends_onoption. La portsclé de configuration mappe un port d'hôte à un port de conteneur, ici nous mappons le port 80de l'hôte au port 80du conteneur.

Créez maintenant un fichier appelé index.phpà l'intérieur du appdossier et mettez-y les éléments suivants.

<?php phpinfo();

Assurez-vous que le port 80est accessible via votre pare-feu et exécutez ce qui suit.

cd ~/docker/app
docker-compose up -d

Encore une fois, vérifiez que le service est en place.

docker ps

Ouvrez un navigateur et accédez [vultr-instance-ip]. Vous pouvez trouver votre adresse IP d'instance Vultr en exécutant ce qui suit.

hostname -I

Vous verrez la page d'informations PHP.

Configuration du conteneur MySQL

L'image MySQL officielle vous permet de configurer le conteneur via de simples variables d'environnement. Cela peut être fait avec une environmentoption dans la définition du bloc de service. Mettez à jour le ~/docker/app/docker-compose.ymlfichier comme suit.

version: '2'
services:
  php:
    image: vultr-php
    volumes:
      - ./:/app
    working_dir: /app
  web:
    image: vultr-nginx
    volumes:
      - ./:/app
    depends_on:
      - php
    ports:
      - 80:80
  mysql:
    image: mysql:5.7.21
    volumes:
      - ./:/app
      - dbdata:/var/lib/mysql
    environment:
      - MYSQL_DATABASE=world
      - MYSQL_ROOT_PASSWORD=root
    working_dir: /app
volumes:
  dbdata:

Nous avons maintenant défini un nouveau service pour la base de données. Remarquez la ligne dbdata:/var/lib/mysql. Cela monte le chemin sur le conteneur /var/lib/mysqlsur un volume persistant géré par Docker, de cette façon les données de la base de données persistent après la suppression du conteneur. Ce volume doit être défini dans un bloc de niveau supérieur comme vous pouvez le voir à la fin du fichier.

Avant d'orchestrer notre nouvelle configuration, téléchargeons un exemple de base de données MySQL. La documentation officielle de MySQL fournit quelques exemples de bases de données. Nous utiliserons la base de données mondiale bien connue. Cette base de données fournit une liste des pays et des villes. Pour télécharger cet exemple, exécutez ce qui suit dans notre dossier d'application.

curl -L http://downloads.mysql.com/docs/world.sql.gz -o world.sql.gz
gunzip world.sql.gz

Permet maintenant d'orchestrer nos conteneurs.

docker-compose up -d

Comme vous l'avez peut-être déjà remarqué, la docker-compose upcommande démarre uniquement les conteneurs qui ne sont pas déjà démarrés. Il vérifie les différences entre votre docker-compose.ymlfichier et la configuration actuelle des conteneurs en cours d'exécution.

Une fois de plus, vérifiez que le conteneur MySQL a été démarré.

docker ps

Remplissez maintenant la base de données mondiale.

docker-compose exec -T mysql mysql -uroot -proot world < world.sql

Vous pouvez vérifier que la base de données a été remplie en sélectionnant les données directement dans la base de données. Accédez d'abord à l'invite MySQL dans le conteneur.

docker-compose exec mysql mysql -uroot -proot world

Dans l'invite MySQL, exécutez ce qui suit.

select * from city limit 10;

Vous verrez une liste de villes. Quittez maintenant l'invite MySQL.

mysql> exit

Construire notre application

Maintenant que tous les conteneurs nécessaires sont opérationnels, nous pouvons nous concentrer sur notre exemple d'application. Mettez à jour le app/index.phpfichier comme suit.

<?php

$pdo = new PDO('mysql:host=mysql;dbname=world;charset=utf8', 'root', 'root');

$stmt = $pdo->prepare("
    select city.Name, city.District, country.Name as Country, city.Population
    from city
    left join country on city.CountryCode = country.Code
    order by Population desc
    limit 10
");
$stmt->execute();
$cities = $stmt->fetchAll(PDO::FETCH_ASSOC);

?>

<!doctype html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Vultr Rocks!</title>
</head>
<body>
    <h2>Most Populous Cities In The World</h2>
    <table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Country</th>
            <th>District</th>
            <th>Population</th>
        </tr>
    </thead>
    <tbody>
        <?php foreach($cities as $city): ?>
            <tr>
                <td><?=$city['Name']?></td>
                <td><?=$city['Country']?></td>
                <td><?=$city['District']?></td>
                <td><?=number_format($city['Population'], 0)?></td>
            </tr>
        <?php endforeach ?>
    </tbody>
    </table>
</body>
</html>

Si vous accédez [vultr-instance-ip]à un navigateur Web, vous verrez une liste des villes les plus peuplées du monde. Félicitations, vous avez déployé une application PHP entièrement fonctionnelle à l'aide de docker.

Conclusion

Dans ce tutoriel, j'ai montré étape par étape comment configurer une application PHP pleinement fonctionnelle. Nous avons construit des images personnalisées pour PHP et Nginx, et configuré docker-compose pour orchestrer nos conteneurs. Bien qu'elle soit très basique et simple, cette configuration reflète un scénario réel.

Dans ce guide, nous avons construit et étiqueté nos images localement. Pour une configuration plus flexible, vous pouvez pousser ces images vers un registre Docker . Vous pouvez pousser vers le registre Docker officiel ou même configurer votre propre registre Docker. Dans tous les cas, cela vous permettra de construire vos images sur un hôte et de les utiliser sur un autre.

Pour une utilisation plus détaillée de docker-compose, vous devez vous référer à la documentation officielle .

En fonction des exigences de votre application et du framework PHP que vous utilisez, vous souhaiterez peut-être ajouter d'autres extensions. Cela peut facilement être fait en modifiant le Dockerfileutilisé pour construire notre image PHP personnalisée. Cependant, certaines extensions nécessitent des dépendances supplémentaires pour être installées dans le conteneur. Vous devez vous référer à la liste des extensions dans la documentation officielle PHP pour revoir les exigences de base de chaque extension.