Comment créer une pile LAMP basée sur Docker à l'aide de Docker sur Ubuntu 20.04

La pile LAMP

LAMP est la pile logicielle sur laquelle fonctionnent probablement la majorité des sites Web. Linux représente la base de la pile et l'implémentation traditionnelle inclut Apache comme serveur Web, la base de données MySQL et PHP comme langage de programmation côté serveur. Il existe cependant de nombreuses variantes possibles :MariaDB, par exemple, est souvent utilisé à la place de MySQL, dont il est un fork, et d'autres langages de programmation, comme Python ou Perl peuvent être utilisés à la place de PHP. Dans cet article, nous verrons comment implémenter une pile LAMP de base à l'aide de docker et de l'utilitaire docker-compose.

Dans ce didacticiel, vous apprendrez :

Comment installer docker et docker-compose sur Ubuntu 20.04
Comment définir les services et les volumes à l'aide de docker-compose
Comment mapper les ports hôtes aux ports conteneurs dans le fichier de configuration docker-compose
Comment utiliser les montages liés et les volumes nommés
Comment créer un projet avec docker-compose

Comment créer une pile LAMP basée sur Docker à l'aide de Docker sur Ubuntu 20.04

Configuration logicielle requise et conventions utilisées

Configuration logicielle requise et conventions de ligne de commande Linux
Catégorie	Exigences, conventions ou version du logiciel utilisée
Système	Installation d'Ubuntu 20.04 ou mise à niveau d'Ubuntu vers 20.04 Focal Fossa
Logiciel	docker, docker-composer
Autre	Autorisations root pour créer des conteneurs Docker et lancer le service Docker
Conventions	# - nécessite que les commandes linux données soient exécutées avec les privilèges root soit directement en tant qu'utilisateur root, soit en utilisant `sudo` commande $ – nécessite que les commandes linux données soient exécutées en tant qu'utilisateur normal non privilégié

Installation des packages et démarrage du service Docker

Afin de créer une pile LAMP basée sur Docker sur Ubuntu 20.04 Focal Fossa, la première chose que nous devons faire est d'installer le logiciel dont nous avons besoin :docker lui-même et docker-compose , qui est un utilitaire qui nous permet d'organiser facilement des applications multi-conteneurs à l'aide de yaml fichiers de configuration. Les deux packages sont disponibles dans les dépôts officiels d'Ubuntu. Nous pouvons les installer via apt :
```
$ sudo apt install docker docker-compose
```
Une fois l'installation effectuée, nous devons démarrer le docker service et activez-le au démarrage. Nous pouvons effectuer les deux opérations avec une seule commande :
```
$ systemctl enable --now docker
```
Configuration du projet

La première étape de notre parcours consiste en la création du répertoire que nous utiliserons comme racine de notre projet. Pour les besoins de cet article, nous l'appellerons linuxconfig . Dans ce répertoire, nous allons en créer un autre, DocumentRoot , qui hébergera les fichiers de notre site Web. Nous pouvons créer les deux répertoires à la fois en utilisant le -p option du mkdir commande :
```
$ mkdir -p linuxconfig/DocumentRoot
```
Dans linuxconfig répertoire, nous définissons la configuration docker-compose pour notre projet dans un fichier yaml, qui par défaut devrait s'appeler docker-compose.yml . Il existe trois strophes principales que nous pouvons utiliser dans le fichier de configuration :services , volumes et réseaux .

Chaque section est utilisée pour configurer l'aspect correspondant d'un projet. Dans ce tutoriel, nous n'utiliserons que les deux premiers. Nous implémenterons les composants de la pile LAMP en tant que services dans leurs propres conteneurs séparés.

Les conteneurs créés avec docker-compose seront membres du même réseau et pourront donc se parler par défaut. Dans le réseau, chaque conteneur pourra référencer les autres par un hostname identique à leur nom, ou par le nom utilisé pour définir le service mis en œuvre par le conteneur.

Par défaut, les conteneurs seront nommés en utilisant le nom du répertoire contenant le fichier de configuration comme préfixe. Dans ce cas, par exemple, le conteneur utilisé pour un service appelé php-httpd , sera nommé linuxconfig_php-httpd_1 .
Définir le service php + httpd

Le premier service que nous définirons dans le fichier de configuration inclura PHP en tant que module de serveur Web Apache. Nous utiliserons l'une des images PHP officielles disponibles sur dockerhub comme base pour notre conteneur, en particulier celui avec le -apache suffixe, qui fournit la configuration que nous avons mentionnée ci-dessus. Commençons à écrire notre configuration :
```
version: '3.7'

services:
    php-httpd:
        image: php:7.3-apache
        ports:
            - 80:80
        volumes:
            - "./DocumentRoot:/var/www/html"
```
La première chose que nous avons spécifiée dans le fichier de configuration est version . Avec cette instruction, nous déclarons quelle version spécifique du fichier de composition nous allons utiliser. Au moment de la rédaction, version 3.7 est le dernier et le plus recommandé.

Après avoir déclaré la version du fichier de composition, nous avons commencé à écrire le service strophe; à l'intérieur de celui-ci nous définissons les services qui composeront notre pile LAMP. Nous avons appelé le premier service php-httpd . Le nom du service est complètement arbitraire, mais c'est toujours une bonne habitude d'en utiliser un qui a du sens dans le contexte du projet.

L'image L'instruction est utilisée pour spécifier sur quelle image le conteneur doit être basé, dans ce cas php:7.3-apache .

Les ports L'instruction est utilisée pour exposer les ports sur le conteneur et pour créer une carte entre les ports hôtes et les ports du conteneur. Une telle carte est définie en séparant les ports par un : . Sur le côté gauche, nous spécifions le port hôte et sur la droite, le port à l'intérieur du conteneur auquel il doit être mappé. Dans ce cas, nous avons mappé le port 80 sur l'hôte au port 80 sur le conteneur, puisqu'il s'agit du port par défaut utilisé par le serveur Web Apache.

La dernière instruction que nous avons utilisée est volumes :avec lui, nous pouvons spécifier un mappage entre un volume nommé ou un chemin (relatif ou absolu) sur le système hôte vers un chemin sur le conteneur, sur lequel il sera monté.

Dans notre configuration, le ./DocumentRoot hébergera les fichiers du site :il sera monté sur le /var/www/html répertoire à l'intérieur du conteneur, car ce dernier est la racine du document utilisée par l'Apache VirtualHost par défaut. Une telle configuration s'appelle un montage lié et est particulièrement utile pendant le développement car les modifications que nous apportons aux fichiers du projet sont immédiatement répercutées dans le conteneur. L'inconvénient de cette configuration est qu'elle établit une dépendance entre le conteneur et la structure de fichiers de la machine hôte, diminuant l'un des principaux avantages de l'utilisation de Docker :la portabilité.

Le répertoire à monter à l'intérieur du conteneur sera créé automatiquement s'il n'existe pas lorsque le docker-compose up la commande est lancée :dans ce cas, elle appartiendra à root sauf indication contraire.

À l'intérieur de DocumentRoot répertoire, nous pouvons maintenant créer un fichier d'index et essayer de construire notre projet pour vérifier que la configuration fonctionne :

$ echo "<?php phpinfo();" > DocumentRoot/index.php
$ sudo docker-compose up -d

Après avoir exécuté la commande, les images docker nécessaires seront téléchargées à partir de dockerhub et les conteneurs seront créés avec les paramètres que nous avons fournis et exécutés en arrière-plan (ils ne bloqueront pas le terminal), à cause du -d option que nous avons fournie au docker-compose commande. Avec le projet opérationnel, si nous naviguons vers localhost avec notre navigateur, nous devrions voir la page suivante :

La page phpinfo

Pour arrêter le projet, depuis le répertoire hébergeant le docker-compose.yml fichier, nous pouvons exécuter :

$ sudo docker-compose stop

Définir le service MariaDB

Une partie essentielle de la pile LAMP est la couche de base de données. Dans notre configuration, nous utiliserons MariaDB et son image docker officielle disponible sur dockerhub :

version: '3.7'

services:
    php-httpd:
        image: php:7.3-apache
        ports:
            - 80:80
        volumes:
            - "./DocumentRoot:/var/www/html"

    mariadb:
        image: mariadb:10.5.2
        volumes:
            - mariadb-volume:/var/lib/mysql
        environment:
            TZ: "Europe/Rome"
            MYSQL_ALLOW_EMPTY_PASSWORD: "no"
            MYSQL_ROOT_PASSWORD: "rootpwd"
            MYSQL_USER: 'testuser'
            MYSQL_PASSWORD: 'testpassword'
            MYSQL_DATABASE: 'testdb'

volumes:
    mariadb-volume:

À l'intérieur des services strophe, nous avons défini un autre service et l'appelons mariadb et avec l'image instruction que nous avons spécifiée, nous voulons utiliser le 10.5.2 version de l'image officielle.

Dans la définition de service précédente, nous utilisions un montage lié. Cette fois, à la place, nous avons utilisé un docker approprié volume nommé , à monter sur /var/lib/mysql à l'intérieur du conteneur (il s'agit du répertoire de données par défaut utilisé par MariaDB). Contrairement à un montage lié, les volumes nommés ne créent pas de dépendances du conteneur sur la structure du système de fichiers hôte. Entièrement gérés par Docker, ils constituent la méthode recommandée pour conserver des données qui, autrement, seraient perdues lors de la destruction des conteneurs.

Les volumes nommés peuvent être définis dans les volumes principaux strophe du fichier de configuration et peut être référencé à partir des volumes sous-section de chaque service défini. Dans ce cas, nous avons appelé notre volume mariadb-volume .

Dans une prochaine étape, nous avons défini la valeur de certaines variables d'environnement utilisé pour influencer le comportement du conteneur. Les variables d'environnement sont définies dans l'environment section d'une définition de service. Les variables que nous avons définies dans ce cas ont l'effet suivant :

Variable	Effet
TZ	Définir le fuseau horaire utilisé par le serveur MariaDB
MYSQL_ALLOW_EMPTY_PASSWORD	Activer ou désactiver l'utilisation d'un mot de passe vide pour l'utilisateur racine de la base de données
MYSQL_ROOT_PASSWORD	Ceci est une variable obligatoire et est utilisée pour définir le mot de passe de l'utilisateur racine de la base de données
MYSQL_DATABASE	Optionnellement utilisé pour spécifier le nom de la base de données à créer au démarrage de l'image
MYSQL_USER	Optionnellement utilisé pour spécifier le nom d'un utilisateur qui sera créé avec des permissions de superutilisateur pour la base de données spécifiée avec MYSQL_DATABASE
MYSQL_PASSWORD	Utilisé pour spécifier le mot de passe de l'utilisateur créé avec le nom fourni par MYSQL_USER

À ce stade, nous devrions avoir un serveur Web fonctionnel capable de fonctionner avec PHP et une base de données pour stocker nos données.

Bonus – phpMyAdmin

Notre pile LAMP de base devrait maintenant être complète. En bonus, nous voudrons peut-être ajouter phpMyAdmin à celui-ci, afin de piloter facilement notre base de données MariaDB depuis une interface web conviviale. Ajoutons la définition de service associée à notre configuration docker-compose :

version: '3.7'

services:
    php-httpd:
        image: php:7.3-apache
        ports:
            - 80:80
        volumes:
            - "./DocumentRoot:/var/www/html"

    mariadb:
        image: mariadb:10.5.2
        volumes:
            - mariadb-volume:/var/lib/mysql
        environment:
            TZ: "Europe/Rome"
            MYSQL_ALLOW_EMPTY_PASSWORD: "no"
            MYSQL_ROOT_PASSWORD: "rootpwd"
            MYSQL_USER: 'testuser'
            MYSQL_PASSWORD: 'testpassword'
            MYSQL_DATABASE: 'testdb'

    phpmyadmin:
        image: phpmyadmin/phpmyadmin
        links:
            - 'mariadb:db'
        ports:
            - 8081:80

volumes:
    mariadb-volume:

Nous avons nommé notre service phpmyadmin et configuré pour utiliser le phpmyadmin/phpmyadmin image de dockerhub. Nous avons également utilisé les links mot-clé pour la première fois ; à quoi ça sert? Comme nous le savons déjà, par défaut, et sans configuration particulière, tous les conteneurs créés dans la même configuration docker-compose peuvent communiquer entre eux. L'image phpMyAdmin est configurée pour référencer un conteneur de base de données en cours d'exécution par le db nom, nous devons donc créer un alias avec le même nom pour notre service mariadb. C'est exactement ce que links est utilisé pour :définir des alias supplémentaires pour atteindre un service à partir d'un autre.

Dans la définition de service, nous avons également mappé le port 8081 de notre machine hôte, au port 80 à l'intérieur du conteneur (le port 80 est déjà mappé sur le même port à l'intérieur du conteneur php-httpd). L'interface phpMyAdmin sera donc joignable au localhost:8081 adresse. Reconstruisons notre projet et vérifions-le :

$ sudo docker-compose up -d --build

La page de connexion PhpMyAdmin

Nous pouvons nous connecter avec les informations d'identification que nous avons définies pour notre service de base de données et vérifier que le testdb la base de données a été créée :

Page d'accueil de PhpMyAdmin

Utiliser une image personnalisée pour un service

Dans les exemples ci-dessus, nous avons toujours utilisé des images vanilla dans notre définition de services. Il existe des cas dans lesquels nous pouvons souhaiter utiliser des images docker personnalisées basées sur celles-ci. Par exemple, disons que nous voulons construire le service php-httpd, mais incluons une extension php supplémentaire :comment pouvons-nous le faire ? À la racine du projet, nous définissons un nouveau répertoire et, pour plus de commodité, nommez-le d'après le service :

$ mkdir php-httpd

Dans ce répertoire, nous créons un Dockerfile, utilisé pour étendre l'image de base, avec le contenu suivant :

FROM php:7.3-apache
LABEL maintainer="[email protected]"

RUN apt-get update && apt-get install -y libmcrypt-dev \
    && pecl install mcrypt-1.0.2 \
    && docker-php-ext-enable mcrypt

De retour dans notre docker-compose.yml fichier, on modifie la définition du php-httpd un service. Nous ne pouvons pas référencer l'image directement comme nous le faisions auparavant. Au lieu de cela, nous spécifions le répertoire contenant notre Dockerfile personnalisé comme contexte de construction :

version: '3.7'

services:
    php-httpd:
        build:
            context: ./php-httpd
        ports:
            - 80:80
        volumes:
            - "./DocumentRoot:/var/www/html"
[...]

Dans le build section nous définissons les configurations qui sont appliquées au moment de la construction. Dans ce cas, nous avons utilisé context pour référencer le répertoire contenant le Dockerfile :ledit répertoire est utilisé comme contexte de construction, et son contenu est envoyé au démon Docker lors de la construction du conteneur. Pour appliquer la modification, nous devons reconstruire le projet.

Au fait, pour en savoir plus sur les extensions supplémentaires dans l'image docker php, vous pouvez consulter la documentation officielle, et plus particulièrement les extensions PECL rubrique.

Conclusion

Dans ce tutoriel, nous avons vu comment créer une pile LAMP de base en utilisant la technologie des conteneurs avec Docker et docker-compose. Nous avons vu comment définir les différents services dans le fichier de configuration docker-compose.yml et comment configurer les montages liés, les volumes nommés et le mappage des ports du conteneur hôte. Nous avons également vu comment utiliser des images personnalisées. Vous pouvez consulter la référence docker-compose pour la liste détaillée des instructions pouvant être utilisées dans le fichier de configuration docker-compose.

Comment créer une pile LAMP basée sur Docker à l'aide de Docker sur Ubuntu 20.04

La pile LAMP

Configuration logicielle requise et conventions utilisées

Installation des packages et démarrage du service Docker

Configuration du projet

Définir le service php + httpd

Définir le service MariaDB

Bonus – phpMyAdmin

Utiliser une image personnalisée pour un service

Conclusion