GNU/Linux >> Tutoriels Linux >  >> Ubuntu

Dockerisation de la pile LEMP avec Docker-Compose sur Ubuntu

Docker Compose est un outil en ligne de commande pour définir et gérer des applications Docker multi-conteneurs. Compose est un script python, il peut être installé facilement avec la commande pip (pip est la commande pour installer le logiciel Python à partir du référentiel de packages python). Avec compose, nous pouvons exécuter plusieurs conteneurs Docker avec une seule commande. Il vous permet de créer un conteneur en tant que service, idéal pour votre environnement de développement, de test et de préproduction.

Dans ce tutoriel, je vais vous guider étape par étape pour utiliser docker-compose afin de créer un environnement LEMP Stack (LEMP =Linux - Nginx - MySQL - PHP). Nous exécuterons tous les composants dans différents conteneurs Docker, nous configurons un conteneur Nginx, un conteneur PHP, un conteneur PHPMyAdmin et un conteneur MySQL/MariaDB.

Prérequis

  • Serveur Ubuntu 16.04 -64 bits
  • Privilèges root

Étape 1 - Installer Docker

Dans cette étape, nous allons installer Docker. Docker est disponible dans le référentiel Ubuntu, mettez simplement à jour votre référentiel, puis installez-le.

Mettre à jour le référentiel Ubuntu et mettre à niveau :

sudo apt-get update
sudo apt-get upgrade

Installez le dernier Docker à partir du référentiel Ubuntu.

sudo apt-get install -y docker.io

Démarrez docker et activez-le au démarrage :

systemctl start docker
systemctl enable docker

Les services Docker sont en cours d'exécution.

Ensuite, vous pouvez essayer d'utiliser docker avec la commande ci-dessous pour le tester :

docker run hello-world

Bonjour tout le monde de docker.

Étape 2 - Installer Docker-Compose

Dans la première étape, nous avons déjà installé Docker. Nous allons maintenant installer docker-compose.

Nous avons besoin de python-pip pour l'installation de composition, installez python et python-pip avec apt :

sudo apt-get install -y python python-pip

Une fois l'installation terminée, installez docker-compose avec la commande pip.

pip install docker-compose

Vérifiez maintenant la version de docker-compose :

docker-compose --version

Docker-compose a été installé.

Étape 3 - Créer et configurer l'environnement Docker

Dans cette étape, nous allons construire notre environnement docker-compose. Nous allons utiliser un utilisateur non root, nous devons donc créer cet utilisateur maintenant.

Ajouter un nouvel utilisateur nommé 'hakase ' (choisissez ici votre propre nom d'utilisateur si vous le souhaitez) :

useradd -m -s /bin/bash hakase
passwd hakase

Ensuite, ajoutez le nouvel utilisateur au 'docker ' groupe et redémarrez docker.

usermod -a -G docker hakase
sudo systemctl restart docker

Maintenant l'utilisateur 'hakase ' peut utiliser docker sans sudo.

Ensuite, depuis l'utilisateur root, connectez-vous à l'utilisateur 'hakase' avec su.

su - hakase

Créez un nouveau répertoire pour l'environnement de composition.

mkdir lemp-compose/
cd lemp-compose/

Ceci est notre environnement docker-compose, tous les fichiers qui doivent être dans le conteneur Docker doivent être dans ce répertoire. Lorsque nous utilisons docker-compose, nous avons besoin d'un fichier .yml nommé 'docker-compose.yml '.

Dans le répertoire 'lemp-compose', créez de nouveaux répertoires et un fichier docker-compose.yml :

touch docker-compose.yml
mkdir -p {logs,nginx,public,db-data}
  • journaux :Répertoire des fichiers journaux Nginx.
  • nginx :contient la configuration Nginx comme l'hôte virtuel, etc.
  • public :répertoire pour les fichiers Web, index.html et le fichier d'informations PHP.
  • db-data  :Volume du répertoire de données MariaDB.

Créez les fichiers journaux error.log et access.log dans les 'logs ' répertoire.

touch logs/{error,access}.log

Créez un nouveau fichier de configuration d'hôte virtuel nginx dans le fichier 'nginx ' répertoire :

vim nginx/app.conf

Collez la configuration ci-dessous :

upstream php {
        server phpfpm:9000;
}
 
server {
 
        server_name 193.70.36.50;
 
        error_log "/opt/bitnami/nginx/logs/myapp-error.log";
        access_log  "/opt/bitnami/nginx/logs/myapp-access.log";
 
        root /myapps;
        index index.php index.html;
 
        location / {
 
                try_files $uri $uri/ /index.php?$args;
        }
 
        location ~ \.php$ {
 
                include fastcgi.conf;
                fastcgi_intercept_errors on;
                fastcgi_pass php;
        }
 
        location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
                expires max;
                log_not_found off;
        }
}

Enregistrez le fichier et quittez vim.

Créez un nouveau fichier index.html et un fichier d'informations PHP dans le 'public ' répertoire.

echo '<h1>LEMP Docker-Compose</h1><p><b>hakase-labs</b>' > public/index.html
echo '<?php phpinfo(); ?>' > public/info.php

Vous pouvez maintenant voir le répertoire d'environnement comme indiqué ci-dessous :

tree

Étape 4 - Configuration du fichier docker-compose.yml

À l'étape précédente, nous avons créé les répertoires et les fichiers nécessaires à nos conteneurs. Dans cette étape, nous voulons éditer le fichier 'docker-compose.yml '. Dans le fichier docker-compose.yml, nous définirons nos services pour la pile LEMP, les images de base pour chaque conteneur et les volumes docker.

Connectez-vous au 'hakase ' et modifiez le fichier docker-compose.yml fichier avec vim :

su - hakase
cd lemp-compose/
vim docker-compose.yml

- Définir les services Nginx

Collez la configuration nginx ci-dessous :

nginx:
    image: 'bitnami/nginx'
    ports:
        - '80:80'
    links:
        - phpfpm
    volumes:
        - ./logs/access.log:/opt/bitnami/nginx/logs/myapp-access.log
        - ./logs/error.log:/opt/bitnami/nginx/logs/myapp-error.log
        - ./nginx/app.conf:/bitnami/nginx/conf/vhosts/app.conf
        - ./public:/myapps

Dans cette configuration, nous avons déjà défini :

  • nginx :nom du service
  • image  :nous utilisons 'bitnami/nginx ' images docker
  • ports  :exposer le port de conteneur 80 au port hôte 80
  • liens :liens 'nginx ' conteneur de service en 'phpfpm ' conteneur
  • volumes :monte les répertoires locaux sur le conteneur. Montez le répertoire des fichiers journaux, montez la configuration de l'hôte virtuel Nginx et montez le répertoire racine Web.

- Définir les services PHP-fpm

Collez la configuration sous le bloc Nginx :

phpfpm:
    image: 'bitnami/php-fpm'
    ports:
        - '9000:9000'
    volumes:
        - ./public:/myapps

Nous avons défini ici :

  • phpfpm :définissez le nom du service.
  • image  :définissez l'image de base pour le service phpfpm avec 'bitnami/php-fpm 'image.
  • ports :Nous exécutons PHP-fpm avec le port TCP 9000 et exposer le port 9000 à l'hôte.
  • volumes :montez le répertoire racine Web 'public ' à 'mesapplications ' sur le conteneur.

- Définir le service MySQL

Dans le troisième bloc, collez la configuration ci-dessous pour le conteneur de service MariaDB :

mysql:
    image: 'mariadb'
    ports:
        - '3306:3306'
    volumes:
        - ./db-data:/var/lib/mysql
    environment:
        - MYSQL_ROOT_PASSWORD=hakase-labs123

Ici, vous pouvez voir que nous utilisons :

  • mysql :comme nom de service.
  • image  :le conteneur est basé sur 'mariadb ' images du menu fixe.
  • ports  :conteneur de service utilisant le port 3306 pour la connexion MySQL et exposez-le à l'hôte sur le port 3306 .
  • volumes :db-data répertoire mysql
  • environnement :définissez la variable d'environnement 'MYSQL_ROOT_PASSWORD ' pour le mot de passe mysql root des images docker, exécuté lors de la construction du conteneur.

- Configuration des services PHPMyAdmin

Le dernier bloc, collez la configuration ci-dessous :

phpmyadmin:
    image: 'phpmyadmin/phpmyadmin'
    restart: always
    ports:
       - '8080:80'
    links:
        - mysql:mysql
    environment:
        MYSQL_USERNAME: root
        MYSQL_ROOT_PASSWORD: hakase-labs123
        PMA_HOST: mysql

Nous utilisons une image docker 'phpmyadmin', mappant le port de conteneur 80 à 8080 sur l'hôte, liez le conteneur à mariadb conteneur, définissez le redémarrage toujours et définissez certaines variables d'environnement de l'image docker, y compris la valeur 'PMA_HOST '.

Enregistrez le fichier et quittez vim.

Vous pouvez voir un exemple complet sur github.

Étape 5 - Exécuter Docker-Compose

Nous sommes maintenant prêts à exécuter docker-compose. Remarque :lorsque vous souhaitez exécuter docker-compose, vous devez vous trouver dans le répertoire du projet docker-compose et vous assurer qu'il existe le fichier yml avec la configuration de composition.

Exécutez la commande ci-dessous pour lancer la pile LEMP :

docker-compose up -d

-d : en cours d'exécution en tant que démon ou arrière-plan

Vous verrez le résultat que les nouveaux conteneurs ont été créés, vérifiez-le avec la commande ci-dessous :

docker-compose ps

Nous avons maintenant quatre conteneurs exécutant Nginx, PHP-fpm, MariaDB et PHPMyAdmin.

Étape 6 - Tester

Vérification des ports utilisés par le docker-proxy sur l'hôte.

netstat -plntu

Nous pouvons voir le port 80 pour le conteneur Nginx, le port 3306 pour le conteneur MariaDB, le port 9000 pour le conteneur php-fpm et le port 8080 pour le conteneur PHPMyAdmin.

Accédez au port 80 à partir du navigateur Web et vous verrez notre fichier index.html.

http://adresseip-serveur/

Assurez-vous que PHP-fpm est en cours d'exécution, accédez-y depuis le navigateur Web.

http://adresseip-serveur/info.php

Accédez au conteneur MySQL dans le shell MySQL.

docker-compose exec mysql bash
mysql -u root -p
TYPE MYSQL PASSWORD: hakase-labs123

Créez maintenant une nouvelle base de données :

create database hakase_db;
exit

Le conteneur MariaDB mysql shell est accessible et nous avons créé une nouvelle base de données 'hakase_db '.

Ensuite, accédez à PHPMyAdmin sur le port 8080 :http://serverip-address:8080/.

Vous verrez la page de connexion PHPMyAdmin, tapez simplement le nom d'utilisateur 'root ' et le mot de passe est 'hakase-labs123 '.

Vous serez automatiquement connecté au conteneur mysql qui a été défini dans le PMA_HOST variable d'environnement.

Cliquez sur 'Aller ' et vous verrez le tableau de bord phpmyadmin qui est connecté au 'mysql ' conteneur.

Succès! La pile LEMP s'exécute dans une configuration docker-compose, composée de quatre conteneurs.

Référence

https://hub.docker.com/r/bitnami/nginx/

https://hub.docker.com/r/bitnami/php-fpm/

https://hub.docker.com/_/mariadb/

https://hub.docker.com/r/phpmyadmin/phpmyadmin/

https://docs.docker.com/compose/

https://github.com/yuzukiseo/hakase-labs/tree/master/lemp-compose


Ubuntu

  1. Installation de la pile LEMP sur Ubuntu 14.04

  2. Comment installer WordPress avec Docker sur Ubuntu

  3. Dockeriser Wordpress avec Nginx et PHP-FPM sur Ubuntu 16.04

  4. Comment installer WordPress avec une pile LEMP sur Ubuntu 18.04

  5. Comment installer Magento 2.4 avec la pile LEMP sur Ubuntu 20.04

Installez ProjectSend sur Ubuntu 20.04 avec Nginx (pile LEMP)

Installez NextCloud sur Ubuntu 18.04 avec Nginx (pile LEMP)

Installez NextCloud sur Ubuntu 20.04 avec Nginx (pile LEMP)

Comment installer Mailtrain sur Ubuntu 18.04 avec Docker

Installer Portainer avec Docker sur Ubuntu

Comment installer la pile LEMP avec PhpMyAdmin dans Ubuntu 20.04