🥇Guide de Docker Compose pour les débutants

L'auteur de l'article dont nous publions aujourd'hui la traduction affirme qu'il s'adresse aux développeurs souhaitant apprendre Docker Compose et qui cherchent à créer leur première application client-serveur en utilisant Docker. Il est supposé que le lecteur de ce matériel est familier avec les bases de Docker. Si ce n'est pas le cas, vous pouvez consulter cet une série de matériel, à cet une publication où les bases de Docker sont traitées avec celles de Kubernetes, et à cet un article pour débutants.

Qu'est-ce que Docker Compose ?

Docker Compose est un outil qui fait partie de Docker. Il est conçu pour résoudre des problèmes liés au déploiement de projets.

En apprenant les bases de Docker, vous avez peut-être rencontré la création d'applications simples, fonctionnant de manière autonome, ne dépendant par exemple pas de sources de données externes ou de certains services. En pratique, de telles applications sont rares. Les projets réels comprennent généralement un ensemble d'applications fonctionnant ensemble.

Comment savoir si vous devez utiliser Docker Compose lors du déploiement d'un projet ? En fait, c'est très simple. Si le fonctionnement de ce projet nécessite plusieurs services, Docker Compose peut vous être utile. Par exemple, dans le cas où l'on crée un site web qui, pour authentifier les utilisateurs, a besoin de se connecter à une base de données. Un tel projet peut comprendre deux services : celui qui assure le fonctionnement du site et celui qui s'occupe de la base de données.

La technologie Docker Compose, si l'on doit la décrire simplement, permet, avec une seule commande, de lancer plusieurs services.

La différence entre Docker et Docker Compose

Docker est utilisé pour gérer des conteneurs individuels (services) qui composent l'application.

Docker Compose est utilisé pour gérer simultanément plusieurs conteneurs faisant partie de l'application. Cet outil offre les mêmes possibilités que Docker, mais permet de travailler avec des applications plus complexes.

Docker (conteneur individuel) et Docker Compose (plusieurs conteneurs)

Un scénario typique d'utilisation de Docker Compose

Docker Compose est, entre de bonnes mains, un outil extrêmement puissant qui permet de déployer rapidement des applications avec une architecture complexe. Nous allons maintenant examiner un exemple d'utilisation pratique de Docker Compose, dont l'analyse vous permettra d'évaluer les avantages que vous en tirerez.

Imaginez que vous êtes un développeur d'un projet web. Ce projet comprend deux sites web. Le premier permet aux entrepreneurs de créer, en quelques clics, des boutiques en ligne. Le second est axé sur le support client. Ces deux sites interagissent avec la même base de données.

Votre projet devient de plus en plus populaire, et vous constatez que les ressources du serveur sur lequel il fonctionne ne suffisent plus. Par conséquent, vous décidez de transférer l'ensemble du projet sur une autre machine.

Malheureusement, vous n'avez pas utilisé quelque chose comme Docker Compose. Vous devrez donc transférer et reconfigurer les services un par un, espérant que vous n'oublierez rien en cours de route.

En revanche, si vous utilisez Docker Compose, le transfert de votre projet vers un nouveau serveur se résume à exécuter quelques commandes. Pour compléter le transfert du projet, il vous suffit de faire quelques réglages et de charger sur le nouveau serveur une sauvegarde de votre base de données.

Développement d'une application client-serveur avec Docker Compose

Maintenant que vous savez à quoi nous allons utiliser Docker Compose, il est temps de créer votre première application client-serveur avec cet outil. Il s'agit concrètement de développer un petit site web (serveur) en Python, capable de renvoyer un fichier contenant un extrait de texte. Ce fichier est demandé par un programme (client), également écrit en Python. Après avoir reçu le fichier du serveur, le programme affiche le texte qu'il contient à l'écran.

Veuillez noter que nous partons du principe que vous maîtrisez les bases de Docker et que la plateforme Docker est déjà installée chez vous.

Commençons à travailler sur le projet.

▍1. Création du projet

Pour construire votre première application client-serveur, je vous propose de commencer par créer le dossier du projet. Il doit contenir les fichiers et dossiers suivants :

Le fichier docker-compose.ymlCeci est un fichier Docker Compose, qui contiendra les instructions nécessaires au démarrage et à la configuration des services.
Dossier serveurIl contiendra les fichiers nécessaires au bon fonctionnement du serveur.
Dossier clientIci se trouveront les fichiers de l'application cliente.

Ainsi, le contenu du dossier principal de votre projet devrait ressembler à ceci :

.
├── client/
├── docker-compose.yml
└── server/
2 dossiers, 1 fichier

▍2. Création du serveur

Ici, lors de la création du serveur, nous aborderons quelques notions de base concernant Docker.

2a. Création des fichiers

et démarrez l'application avec la commande suivante : serveur et créez-y les fichiers suivants :

Le fichier server.pyCe fichier contiendra le code du serveur.
Le fichier index.htmlDans ce fichier se trouvera un extrait de texte que l'application cliente devra afficher.
Le fichier DockerfileCeci est un fichier Docker, qui contiendra les instructions nécessaires à la création de l'environnement du serveur.

Voici à quoi devrait ressembler le contenu de votre dossier server/:

.
├── Dockerfile
├── index.html
└── server.py
0 dossiers, 3 fichiers

2b. Modification du fichier Python.

Ajoutons dans le fichier server.py le code suivant :

#!/usr/bin/env python3

# Импорт системных библиотек python.
# Эти библиотеки будут использоваться для создания веб-сервера.
# Вам не нужно устанавливать что-то особенное, эти библиотеки устанавливаются вместе с Python.

import http.server
import socketserver

# Эта переменная нужна для обработки запросов клиента к серверу.

handler = http.server.SimpleHTTPRequestHandler

# Тут мы указываем, что сервер мы хотим запустить на порте 1234. 
# Постарайтесь запомнить эти сведения, так как они нам очень пригодятся в дальнейшем, при работе с docker-compose.

with socketserver.TCPServer(("", 1234), handler) as httpd:

    # Благодаря этой команде сервер будет выполняться постоянно, ожидая запросов от клиента.

   httpd.serve_forever()

Ce code permet de créer un serveur web simple. Il servira aux clients le fichier index.html, dont le contenu sera plus tard affiché sur la page web.

2c. Modification du fichier HTML

Dans le fichier index.html ajoutons le texte suivant :

Docker-Compose, c'est magique !

Ce texte sera transmis au client.

2d. Modification du fichier Dockerfile

Nous allons maintenant créer un fichier simple Dockerfile, qui sera responsable de l'organisation de l'environnement d'exécution pour le serveur Python. Nous utiliserons comme image de base l'image officielle, destinée à l'exécution de programmes écrits en Python. Voici le contenu du Dockerfile :

# На всякий случай напоминаю, что Dockerfile всегда должен начинаться с импорта базового образа.
# Для этого используется ключевое слово 'FROM'.
# Здесь нам нужно импортировать образ python (с DockerHub).
# В результате мы, в качестве имени образа, указываем 'python', а в качестве версии - 'latest'.

FROM python:latest

# Для того чтобы запустить в контейнере код, написанный на Python, нам нужно импортировать файлы 'server.py' и 'index.html'.
# Для того чтобы это сделать, мы используем ключевое слово 'ADD'.
# Первый параметр, 'server.py', представляет собой имя файла, хранящегося на компьютере.
# Второй параметр, '/server/', это путь, по которому нужно разместить указанный файл в образе.
# Здесь мы помещаем файл в папку образа '/server/'.

ADD server.py /server/
ADD index.html /server/

# Здесь мы воспользуемся командой 'WORKDIR', возможно, новой для вас.
# Она позволяет изменить рабочую директорию образа.
# В качестве такой директории, в которой будут выполняться все команды, мы устанавливаем '/server/'.

WORKDIR /server/

Nous allons maintenant travailler sur le client.

▍3. Création du client

En créant la partie client de notre projet, nous nous rappellerons certaines bases de Docker.

3a. Création des fichiers

Allez dans le dossier de votre projet client et créez-y les fichiers suivants :

Le fichier client.py. Ici se trouvera le code du client.
Le fichier DockerfileCe fichier joue le même rôle que le fichier correspondant dans le dossier du serveur, à savoir qu'il contient l'instruction décrivant la création de l'environnement pour le code client.

Le contenu de votre dossier client/ à ce stade du travail devrait ressembler à ceci :

.
├── client.py
└── Dockerfile
0 dossiers, 2 fichiers

3b. Modification du fichier Python

Ajoutons dans le fichier client.py le code suivant :

#!/usr/bin/env python3

# Импортируем системную библиотеку Python.
# Она используется для загрузки файла 'index.html' с сервера.
# Ничего особенного устанавливать не нужно, эта библиотека устанавливается вместе с Python.

import urllib.request

# Эта переменная содержит запрос к 'http://localhost:1234/'.
# Возможно, сейчас вы задаётесь вопросом о том, что такое 'http://localhost:1234'.
# localhost указывает на то, что программа работает с локальным сервером.
# 1234 - это номер порта, который вам предлагалось запомнить при настройке серверного кода.

fp = urllib.request.urlopen("http://localhost:1234/")

# 'encodedContent' соответствует закодированному ответу сервера ('index.html').
# 'decodedContent' соответствует раскодированному ответу сервера (тут будет то, что мы хотим вывести на экран).

encodedContent = fp.read()
decodedContent = encodedContent.decode("utf8")

# Выводим содержимое файла, полученного с сервера ('index.html').

print(decodedContent)

# Закрываем соединение с сервером.

fp.close()

Grâce à ce code, l'application cliente peut récupérer des données depuis le serveur et les afficher à l'écran.

3c. Modification du fichier Dockerfile

Tout comme pour le serveur, nous créons pour le client un simple Dockerfile, responsable de la création de l'environnement dans lequel fonctionnera l'application Python du client. Voici le code du client Dockerfile:

# То же самое, что и в серверном Dockerfile.

FROM python:latest

# Импортируем 'client.py' в папку '/client/'.

ADD client.py /client/

# Устанавливаем в качестве рабочей директории '/client/'.

WORKDIR /client/

▍4. Docker Compose

Comme vous l'avez remarqué, nous avons créé deux projets différents : le serveur et le client. Chacun d'eux a son propre fichier Dockerfile. Jusqu'à présent, tout ce qui se passe reste dans le cadre des bases de Docker. Maintenant, nous allons commencer à travailler avec Docker Compose. Pour cela, nous allons nous référer au fichier docker-compose.yml, situé dans le dossier racine du projet.

Notez que nous ne visons pas à examiner toutes les commandes pouvant être utilisées dans docker-compose.yml. Notre objectif principal est d'analyser un exemple pratique, vous fournissant des connaissances de base sur Docker Compose.

Voici le code à placer dans le fichier docker-compose.yml:

# Файл docker-compose должен начинаться с тега версии.
# Мы используем "3" так как это - самая свежая версия на момент написания этого кода.

version: "3"

# Следует учитывать, что docker-composes работает с сервисами.
# 1 сервис = 1 контейнер.
# Сервисом может быть клиент, сервер, сервер баз данных...
# Раздел, в котором будут описаны сервисы, начинается с 'services'.

services:

  # Как уже было сказано, мы собираемся создать клиентское и серверное приложения.
  # Это означает, что нам нужно два сервиса.
  # Первый сервис (контейнер): сервер.
  # Назвать его можно так, как нужно разработчику.
  # Понятное название сервиса помогает определить его роль.
  # Здесь мы, для именования соответствующего сервиса, используем ключевое слово 'server'.

  server:
 
    # Ключевое слово "build" позволяет задать
    # путь к файлу Dockerfile, который нужно использовать для создания образа,
    # который позволит запустить сервис.
    # Здесь 'server/' соответствует пути к папке сервера,
    # которая содержит соответствующий Dockerfile.

    build: server/

    # Команда, которую нужно запустить после создания образа.
    # Следующая команда означает запуск "python ./server.py".

    command: python ./server.py

    # Вспомните о том, что в качестве порта в 'server/server.py' указан порт 1234.
    # Если мы хотим обратиться к серверу с нашего компьютера (находясь за пределами контейнера),
    # мы должны организовать перенаправление этого порта на порт компьютера.
    # Сделать это нам поможет ключевое слово 'ports'.
    # При его использовании применяется следующая конструкция: [порт компьютера]:[порт контейнера]
    # В нашем случае нужно использовать порт компьютера 1234 и организовать его связь с портом
    # 1234 контейнера (так как именно на этот порт сервер 
    # ожидает поступления запросов).

    ports:
      - 1234:1234

  # Второй сервис (контейнер): клиент.
  # Этот сервис назван 'client'.

  client:
    # Здесь 'client/ соответствует пути к папке, которая содержит
    # файл Dockerfile для клиентской части системы.

    build: client/

    # Команда, которую нужно запустить после создания образа.
    # Следующая команда означает запуск "python ./client.py".
 
    command: python ./client.py

    # Ключевое слово 'network_mode' используется для описания типа сети.
    # Тут мы указываем то, что контейнер может обращаться к 'localhost' компьютера.

    network_mode: host

    # Ключевое слово 'depends_on' позволяет указывать, должен ли сервис,
    # прежде чем запуститься, ждать, когда будут готовы к работе другие сервисы.
    # Нам нужно, чтобы сервис 'client' дождался бы готовности к работе сервиса 'server'.
 
    depends_on:
      - server

▍5. Construction du projet

Une fois que toutes les instructions nécessaires ont été ajoutées à docker-compose.yml , le projet doit être construit. Cette étape de notre travail ressemble à l'utilisation de la commande docker build, mais la commande correspondante concerne plusieurs services :

$ docker-compose build

▍6. Lancement du projet

Maintenant que le projet est construit, il est temps de le lancer. Cette étape de notre travail correspond à celle dans laquelle, lors de l'utilisation de conteneurs séparés, la commande exécutée est docker run:

$ docker-compose up

Après avoir exécuté cette commande, le texte téléchargé par le client depuis le serveur doit apparaître dans le terminal : Docker-Compose, c'est magique !.

Comme déjà mentionné, le serveur utilise le port de l'ordinateur 1234 pour traiter les requêtes du client. Par conséquent, si vous accédez dans le navigateur à l'adresse http://localhost:1234/, une page avec le texte sera affichée Docker-Compose, c'est magique !.

Commandes utiles

Examinons quelques commandes qui pourraient vous être utiles lors de l'utilisation de Docker Compose.

Cette commande permet d'arrêter et de supprimer les conteneurs et autres ressources créées par la commande docker-compose up:

$ docker-compose down

Cette commande affiche les journaux des services :

$ docker-compose logs -f [nom du service]

Par exemple, dans notre projet, elle peut être utilisée de la manière suivante : $ docker-compose logs -f [nom du service].

Avec cette commande, vous pouvez afficher la liste des conteneurs :

$ docker-compose ps

Cette commande permet d'exécuter une commande dans un conteneur en cours d'exécution :

$ docker-compose exec [nom du service] [commande]

Par exemple, elle peut ressembler à ceci : docker-compose exec server ls.

Cette commande permet d'afficher la liste des images :

$ docker-compose images

Résultats

Nous avons examiné les bases de l'utilisation de la technologie Docker Compose, dont la connaissance vous permettra d'utiliser cette technologie et, si vous le souhaitez, de commencer à l'approfondir. Voici le dépôt contenant le code du projet que nous avons abordé ici.

Chers lecteurs ! Utilisez-vous Docker Compose dans vos projets ?

Source : habr.com

Guide Docker Compose pour les débutants