🥇Guide du débutant pour Docker Compose

L'auteur de l'article, que nous publions aujourd'hui, dit qu'il est destiné aux développeurs qui souhaitent apprendre Docker Compose et sont sur le point de créer leur première application client-serveur à l'aide de Docker. Il est supposé que le lecteur de ce document connaît les bases de Docker. Si ce n'est pas le cas, vous pouvez consulter cette série de matériaux cette un article couvrant les bases de Docker ainsi que les bases de Kubernetes, et cette article pour les débutants.

Qu'est-ce que Docker Compose ?

Docker Compose est un outil inclus avec Docker. Il est conçu pour résoudre les problèmes liés au déploiement de projets.

En apprenant les bases de Docker, vous êtes peut-être tombé sur la création des applications les plus simples qui fonctionnent de manière autonome, ne dépendant pas, par exemple, de sources de données externes ou de certains services. En pratique, de telles applications sont rares. Les projets réels impliquent généralement tout un ensemble d'applications collaboratives.

Comment savoir si vous devez utiliser Docker Compose lors du déploiement d'un projet ? En fait, c'est très simple. Si vous utilisez plusieurs services pour exécuter ce projet, Docker Compose peut s'avérer utile. Par exemple, dans une situation où vous créez un site Web qui, pour effectuer l'authentification de l'utilisateur, doit se connecter à une base de données. Un tel projet peut consister en deux services - un qui assure le fonctionnement du site, et un qui est responsable du support de la base de données.

La technologie Docker Compose, si vous la décrivez de manière simplifiée, vous permet de démarrer de nombreux services avec une seule commande.

Différence entre Docker et Docker Compose

Docker est utilisé pour gérer les conteneurs individuels (services) qui composent une application.

Docker Compose est utilisé pour gérer plusieurs conteneurs faisant partie d'une application en même temps. Cet outil offre les mêmes fonctionnalités que Docker, mais permet de travailler avec des applications plus complexes.

Docker (conteneur unique) et Docker Compose (conteneurs multiples)

Cas d'utilisation typique de Docker Compose

Docker Compose est, entre de bonnes mains, un outil très puissant qui permet de déployer rapidement des applications aux architectures complexes. Nous allons maintenant nous intéresser à un exemple d'utilisation pratique de Docker Compose dont l'analyse vous permettra d'évaluer les bénéfices que vous apportera l'utilisation de Docker Compose.

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

Votre projet devient de plus en plus populaire, et il s'avère que la capacité du serveur sur lequel il fonctionne n'est plus suffisante. En conséquence, 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. Par conséquent, vous devrez migrer et reconfigurer les services un par un, en espérant que vous n'oublierez rien au cours de ce travail.

Si vous utilisez Docker Compose, la migration de votre projet vers un nouveau serveur est un problème qui peut être résolu en exécutant quelques commandes. Pour terminer le transfert du projet vers un nouvel emplacement, il vous suffit de définir certains paramètres et de télécharger une copie de sauvegarde de la base de données sur le nouveau serveur.

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 à l'aide de cet outil. À savoir, nous parlons du développement d'un petit site Web (serveur) en Python, qui peut produire un fichier avec un fragment de texte. Ce fichier est demandé au serveur par un programme (client), également écrit en Python. Après avoir reçu le fichier du serveur, le programme affiche le texte qui y est stocké à l'écran.

Veuillez noter que nous supposons que vous avez les bases de Docker et que vous avez déjà installé la plateforme Docker.

Commençons à travailler sur le projet.

▍1. Créer un projet

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

Dossier docker-compose.yml. Il s'agit d'un fichier Docker Compose qui contiendra les instructions nécessaires pour démarrer et configurer les services.
Dossier server. Il contiendra les fichiers nécessaires au fonctionnement du serveur.
Dossier client. C'est là que se trouveront les fichiers de l'application cliente.

Par conséquent, le contenu du dossier principal de votre projet devrait ressembler à ceci :

.
├── client/
├── docker-compose.yml
└── server/
2 directories, 1 file

▍2. Création de serveur

Ici, dans le processus de création d'un serveur, nous aborderons certaines choses de base concernant Docker.

2a. Création de fichiers

Aller au dossier server et créez-y les fichiers suivants :

Dossier server.py. Il contiendra le code du serveur.
Dossier index.html. Ce fichier contiendra un morceau de texte que l'application cliente doit afficher.
Dossier Dockerfile. Il s'agit du 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 directories, 3 files

2b. Modification d'un fichier Python.

Ajouter au 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 vous permet de créer un serveur Web simple. Il remettra aux clients un dossier index.html, dont le contenu sera ensuite affiché sur la page Web.

2c. Modification d'un fichier HTML

Pour déposer index.html ajouter le texte suivant :

Docker-Compose is magic!

Ce texte sera envoyé au client.

2d. Modification du Dockerfile

Nous allons maintenant créer un fichier simple Dockerfile, qui sera responsable de l'organisation de l'environnement d'exécution du serveur Python. Comme base de l'image créée, nous utiliserons de manière officielle, conçu pour exécuter des 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/

Passons maintenant au client.

▍3. Créer un client

Lors de la création du côté client de notre projet, nous rappellerons quelques bases de Docker en cours de route.

3a. Création de fichiers

Accédez à votre dossier de projet client et créez-y les fichiers suivants :

Dossier client.py. C'est là que se trouvera le code client.
Dossier Dockerfile. Ce fichier joue le même rôle qu'un fichier similaire dans le dossier du serveur. À savoir, il contient une instruction qui décrit comment créer un environnement pour l'exécution du code client.

Par conséquent, votre dossier client/ A ce stade, cela devrait ressembler à ceci :

.
├── client.py
└── Dockerfile
0 directories, 2 files

3b. Modification d'un fichier Python

Ajouter au 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 télécharger des données du serveur et les afficher à l'écran.

3c. Modification du Dockerfile

Comme dans le cas du serveur, nous créons pour le client un simple Dockerfile, responsable de la mise en forme de l'environnement dans lequel l'application cliente Python s'exécutera. Voici le code client Dockerfile:

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

FROM python:latest

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

ADD client.py /client/

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

WORKDIR /client/

▍4. Docker Composer

Comme vous pouvez le voir, nous avons créé deux projets différents : serveur et client. Chacun d'eux a son propre fichier Dockerfile. Jusqu'à présent, tout ce qui se passe ne va pas au-delà des bases du travail avec Docker. Nous allons maintenant travailler avec Docker Compose. Pour ce faire, reportez-vous au fichier docker-compose.ymlsitué dans le dossier racine du projet.

Veuillez noter qu'ici nous n'avons pas pour but de couvrir absolument toutes les commandes qui peuvent être utilisées dans docker-compose.yml. Notre objectif principal est de décomposer un exemple pratique qui vous donne une connaissance de base de Docker Compose.

Voici le code à mettre 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

Après dans docker-compose.yml toutes les instructions nécessaires ont été faites, le projet doit être assemblé. Cette étape de notre travail ressemble à l'utilisation de la commande docker build, mais la commande correspondante est liée à plusieurs services :

$ docker-compose build

▍6. Lancement du projet

Maintenant que le projet est construit, il est temps de l'exécuter. Cette étape de notre travail correspond à l'étape à laquelle, lorsque vous travaillez avec des conteneurs individuels, la commande est exécutée docker run:

$ docker-compose up

Après avoir exécuté cette commande, le texte chargé par le client depuis le serveur doit apparaître dans le terminal : Docker-Compose is magic!.

Comme déjà mentionné, le serveur utilise le port de l'ordinateur 1234 pour répondre aux demandes des clients. Par conséquent, si vous allez dans le navigateur à l'adresse http://localhost:1234/, il affichera une page avec du texte Docker-Compose is magic!.

Commandes utiles

Jetons un coup d'œil à certaines des commandes qui pourraient vous être utiles lorsque vous travaillez avec Docker Compose.

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

$ docker-compose down

Cette commande imprime les journaux de service :

$ docker-compose logs -f [service name]

Par exemple, dans notre projet, il peut être utilisé sous cette forme : $ docker-compose logs -f [service name].

Avec cette commande, vous pouvez afficher une liste de conteneurs :

$ docker-compose ps

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

$ docker-compose exec [service name] [command]

Par exemple, cela pourrait ressembler à ceci : docker-compose exec server ls.

Cette commande permet d'afficher une liste d'images :

$ docker-compose images

Les résultats de

Nous avons couvert les bases du travail avec la technologie Docker Compose, dont la connaissance vous permettra d'utiliser cette technologie et, si vous le souhaitez, de commencer à l'étudier plus en profondeur. Ici référentiel avec le code du projet, que nous avons considéré ici.

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

Source: habr.com

Guide de composition Docker pour les débutants