Docker Compose Starter Guide

L'auteur de l'article, dont nous publions la traduction aujourd'hui, dit qu'il est destiné aux développeurs qui souhaitent apprendre Docker Compose et vont créer leur première application client-serveur à l'aide de Docker. Le lecteur est censé connaître les bases de Docker. Si ce n'est pas le cas, vous pouvez consulter cette série de documents, cette publication, où les bases de Docker sont discutées avec les bases de Kubernetes, et cet 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 étudiant les bases de Docker, vous pourriez rencontrer la création d'applications simples qui fonctionnent de manière autonome, indépendamment, par exemple, des sources de données externes ou de certains services. En pratique, de telles applications sont rares. Les projets réels incluent généralement un ensemble complet d'applications collaboratives.

Comment savoir si vous devez utiliser Docker Compose lors du déploiement d'un projet? En fait - très simple. Si plusieurs services sont utilisés pour assurer le fonctionnement de ce projet, Docker Compose peut être utile. Par exemple, dans une situation où ils créent un site Web qui, pour authentifier les utilisateurs, doit se connecter à la base de données. Un projet similaire peut comprendre deux services - l'un qui fournit le site et l'autre qui est responsable de la maintenance de la base de données.

La technologie Docker Compose, si elle est décrite de manière simplifiée, permet, avec une seule commande, de lancer de nombreux services.

Différence entre Docker et Docker Compose

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

Docker Compose est utilisé pour gérer simultanément plusieurs conteneurs qui composent l'application. Cet outil offre les mêmes fonctionnalités que Docker, mais vous 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 vous 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 qui vous permettront d'utiliser Docker Compose.

Imaginez que vous êtes développeur d'un projet Web. Ce projet comprend deux sites Web. Le premier permet aux professionnels 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 puissance du serveur sur lequel il fonctionne n'est plus suffisante. En conséquence, vous décidez de transférer l'intégralité du projet sur une autre machine.

Malheureusement, vous n'avez pas utilisé quelque chose comme Docker Compose. Par conséquent, vous devrez transférer et reconfigurer les services un par un, en espérant que vous, dans le processus de ce travail, n'oublierez rien.

Si vous utilisez Docker Compose, le transfert de votre projet vers un nouveau serveur peut être résolu en exécutant plusieurs commandes. Afin de terminer le transfert du projet vers un nouvel emplacement, il vous suffit d'effectuer certains réglages 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 à l'aide de Docker Compose

Maintenant que vous savez pourquoi 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 à l'écran le texte qui y est stocké.

Veuillez noter que nous nous attendons à ce que vous possédiez les bases de Docker et que vous avez déjà installé la plate-forme Docker.

Mettons-nous au travail sur le projet.

▍1. Création de projet

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

• 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 du server . Il contiendra les fichiers nécessaires pour assurer le fonctionnement du serveur.
• client dossier. Voici les fichiers de l'application client.

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 du serveur, nous aborderons certaines choses de base concernant Docker.

2a. Création de fichiers

Accédez au dossier du server et créez-y les fichiers suivants:

• Fichier server.py . Il contiendra le code du serveur.
• Fichier index.html . Ce fichier contiendra un morceau de texte que l'application cliente devrait afficher.
• Fichier Dockerfile . Il s'agit d'un fichier Docker qui contiendra les instructions nécessaires pour créer un environnement de serveur.

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

 . ├── Dockerfile ├── index.html └── server.py 0 directories, 3 files 

2b. Modification d'un fichier Python.

Ajoutez le code suivant au fichier server.py :

 #!/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 simple serveur Web. Il donnera aux clients le fichier index.html , dont le contenu sera ensuite affiché sur la page Web.

2c. Édition de fichiers HTML

Ajoutez le texte suivant au fichier index.html :

 Docker-Compose is magic! 

Ce texte sera transmis au client.

2d. Modification du Dockerfile

Nous allons maintenant créer un Dockerfile simple, qui sera responsable de l'organisation du runtime pour le serveur Python. Nous utiliserons l' image officielle destinée à l'exécution de programmes écrits en Python comme base de l'image créée. 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/ 

Maintenant, travaillons sur le client.

▍3. Création de client

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

3a. Création de fichiers

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

• Le fichier client.py . Ce sera le code client.
• Fichier Dockerfile . Ce fichier joue le même rôle qu'un fichier similaire dans le dossier du serveur. À savoir, il contient des instructions décrivant la création d'un environnement pour exécuter du code client.

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

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

3b. Édition de fichier Python

Ajoutez le code suivant au fichier client.py :

 #!/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 depuis le serveur et les afficher à l'écran.

3c. Modification du Dockerfile

Comme dans le cas du serveur, nous créons un Dockerfile simple pour le client, chargé de créer l'environnement dans lequel l'application client Python fonctionnera. Voici le code Dockerfile client:

 #   ,     Dockerfile. FROM python:latest #  'client.py'   '/client/'. ADD client.py /client/ #      '/client/'. WORKDIR /client/ 

▍4. Docker compose

Comme vous l'avez peut-être remarqué, nous avons créé deux projets différents: le serveur et le client. Chacun d'eux a son propre Dockerfile . Jusqu'à présent, tout ce qui se passe ne va pas au-delà des bases de l'utilisation de Docker. Nous commençons maintenant avec Docker Compose. Pour ce faire, nous nous tournons vers le fichier docker-compose.yml situé dans le dossier racine du projet.

Veuillez noter qu'ici nous docker-compose.yml pas de considérer absolument toutes les commandes qui peuvent être utilisées dans docker-compose.yml . Notre objectif principal est de vous donner un exemple pratique qui vous donne une connaissance de base de Docker Compose.

Voici le code à mettre dans le 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. Montage du projet

Une fois que toutes les instructions nécessaires sont incluses dans docker-compose.yml , le projet doit être assemblé. Cette étape de notre travail ressemble à l'utilisation de la docker build , mais la commande correspondante est liée à plusieurs services:

 $ docker-compose build 

▍6. Lancement du projet

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

 $ docker-compose up 

Après avoir exécuté cette commande, le terminal doit afficher le texte téléchargé par le client depuis le serveur: Docker-Compose is magic! .

Comme déjà mentionné, le serveur utilise le port informatique 1234 pour répondre aux demandes des clients. Par conséquent, si vous allez sur le navigateur http: // localhost: 1234 / , une page avec le texte Docker-Compose is magic! sera affichée dedans Docker-Compose is magic! .

Commandes utiles

Examinons certaines des commandes que vous pourriez trouver utiles lorsque vous travaillez avec Docker Compose.

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

 $ docker-compose down 

Cette commande affiche les journaux de service:

 $ docker-compose logs -f [service name] 

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

À l'aide de cette commande, vous pouvez répertorier les conteneurs:

 $ docker-compose ps 

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

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

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

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

 $ docker-compose images 

Résumé

Nous avons examiné 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 son étude plus approfondie. Voici le référentiel avec le code du projet que nous avons examiné ici.

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