LE ZÉRO DU DOCKER-COMPOSE AVEC FLASK ET REDIS

Photo by Dominik Lückmann on Unsplash

Cet article n’est pas parfait, il contiendrait des fautes d’ortographe et erreurs dans les codes, priez de me contacter pour la correction.

Que sont les conteneurs ?

Tout comme dans le domaine des transports, les conteneurs informatiques stockent des objets pour les transporter. Ils permettent d’expédier des applications et leurs dépendances sur de multiples systèmes d’exploitation, quels qu’ils soient. Ils garantissent que leur contenu est identique au départ et à l’arrivée, et qu’il est sécurisé, grâce à leur mise en isolation.

À quoi servent-ils ?

Ils servent à minimiser la complexité liée à la configuration et à l’administration applicatives, à accélérer les cycles de développement et de production applicatifs, et, grâce à leur flexibilité et à leur portabilité, ils constituent l’une des briques qui permettent de faire de l’« infrastructure as a service », c’est-à-dire d’automatiser les infrastructures IT.

Comment fonctionne la conteneurisation ?

La conteneurisation est une méthode qui permet de virtualiser, dans un conteneur, les ressources matérielles ‒ systèmes de fichiers, réseau, processeur, mémoire vive, etc. ‒ nécessaires à l’exécution d’une application. Dans cet espace sont aussi stockées toutes les dépendances des applications : fichiers, bibliothèques, etc. Pour déplacer les applications virtuelles d’un système d’exploitation à un autre, le conteneur se connecte à leur noyau (kernel), ce qui permet aux différents composants matériels et logiciels de communiquer entre eux.

Docker Engine est une technologie de conteneurisation open source permettant de créer et de conteneuriser vos applications (comme une machine virtuelle, vmware ou le vitualbox où vous installez l’OS et autres services). Docker Engine agit comme une application client-serveur avec:

  • Un serveur avec un processus daemon dockerd.
  • Les APIs qui spécifient les interfaces que les programmes peuvent utiliser pour parler et instruire le daemon Docker.
  • Un CLI docker.

Dans cet article, vous allez créer une application Web Python simple exécutée sur Docker-Compose. L’application utilise le framework Flask et gère un compteur d’accès dans Redis. Bien que l’exemple utilise Python, les concepts présentés ici doivent être compréhensibles même si vous ne le connaissez pas.

Prérequis

Assurez-vous que vous avez déjà installé Docker Engine et Docker Compose . Vous n’avez pas besoin d’installer Python ou Redis, car les deux sont fournis par les images Docker.

Étape 1: Configuration

Définissez les dépendances de l’application.

  1. Créez un répertoire pour le projet:
$ mkdir composetest
$ cd composetest

2. Créez un fichier appelé app.pydans le répertoire de votre projet et collez-le dans:

import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
retries = 5
while True:
try:
return cache.incr('hits')
except redis.exceptions.ConnectionError as exc:
if retries == 0:
raise exc
retries -= 1
time.sleep(0.5)

@app.route('/')
def hello():
count = get_hit_count()
return 'Hello World! I have been seen {} times.\n'.format(count)

Dans cet exemple, redisest le nom de l’hôte du conteneur redis sur le réseau de l'application. Nous utilisons le port 6379par défaut pour Redis.

Notez la façon dont la get_hit_countfonction est écrite. Cette boucle de relance de base nous permet de tenter notre demande plusieurs fois si le service redis n'est pas disponible. Ceci est utile au démarrage lorsque l'application est en ligne, mais rend également notre application plus résiliente si le service Redis doit être redémarré à tout moment pendant la durée de vie de l'application. Dans un cluster, cela permet également de gérer les baisses de connexion momentanées entre les nœuds.

3. Créez un autre fichier appelé requirements.txtdans le répertoire de votre projet et collez ceci:

flask
redis

Étape 2: Créez un Dockerfile

Dans cette étape, vous écrivez un Dockerfile qui crée une image Docker. L’image contient toutes les dépendances requises par l’application Python, y compris Python lui-même.

Dans le répertoire de votre projet, créez un fichier nommé Dockerfileet collez ce qui suit:

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]

Cela indique à Docker de:

  • Créer une image en commençant par l’image Python 3.7.
  • Définir le répertoire de travail sur /code.
  • Définir les variables d’environnement utilisées par la flaskcommande.
  • Installer gcc et d’autres dépendances
  • Copier requirements.txtet installer les dépendances Python.
  • Ajouter des métadonnées à l’image pour décrire que le conteneur écoute sur le port 5000
  • Copier le répertoire actuel .du projet dans le répertoire courant de l’image . .
  • Définir la commande par défaut du conteneur flask run.

Pour plus d’informations sur Dockerfile, consultez le guide de l’utilisateur Docker et la référence Dockerfile .

Étape 3: définir les services dans un fichier docker-compose

Créez un fichier appelé docker-compose.ymldans le répertoire de votre projet et collez ce qui suit:

version: "3.8"
services:
web:
build: .
ports:
- "5000:5000"
redis:
image: "redis:alpine"

Ce fichier Compose définit deux services: webet redis.

Service Web

Le webservice utilise une image créée à partir de Dockerfiledans le répertoire actuel. Il se lie alors le conteneur et la machine hôte au port exposé, 5000. Ce service utilise le port 5000 par défaut pour le serveur Web Flask.

Service Redis

Le service redis utilise une image Redis publique extraite du registre Docker Hub.

Étape 4: Créez et exécutez votre application avec Compose

  1. Depuis votre répertoire de projet, ouvrez le terminal et démarrez votre application en exécutant
$ docker-compose up

Creating network "composetest_default" with the default driver
Creating composetest_web_1 ...
Creating composetest_redis_1 ...
Creating composetest_web_1
Creating composetest_redis_1 ... done
Attaching to composetest_web_1, composetest_redis_1
web_1 | * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
redis_1 | 1:C 17 Aug 22:11:10.480 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
redis_1 | 1:C 17 Aug 22:11:10.480 # Redis version=4.0.1, bits=64, commit=00000000, modified=0, pid=1, just started
redis_1 | 1:C 17 Aug 22:11:10.480 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
web_1 | * Restarting with stat
redis_1 | 1:M 17 Aug 22:11:10.483 * Running mode=standalone, port=6379.
redis_1 | 1:M 17 Aug 22:11:10.483 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
web_1 | * Debugger is active!
redis_1 | 1:M 17 Aug 22:11:10.483 # Server initialized
redis_1 | 1:M 17 Aug 22:11:10.483 # WARNING you have Transparent Huge Pages (THP) support enabled in your kernel. This will create latency and memory usage issues with Redis. To fix this issue run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your /etc/rc.local in order to retain the setting after a reboot. Redis must be restarted after THP is disabled.
web_1 | * Debugger PIN: 330-787-903
redis_1 | 1:M 17 Aug 22:11:10.483 * Ready to accept connections

2. Compose extrait une image Redis, crée une image pour votre code et démarre les services que vous avez définis. Dans ce cas, le code est copié statiquement dans l’image au moment de la génération.

Entrez http: // localhost: 5000 / dans un navigateur pour voir l’application en cours d’exécution. Si vous utilisez Docker de manière native sur Linux, Docker Desktop pour Mac ou Docker Desktop pour Windows, l’application Web devrait maintenant être à l’écoute sur le port 5000 sur votre hôte de démon Docker. Pointez votre navigateur Web sur http: // localhost: 5000 pour trouver le Hello Worldmessage. Si cela ne résout pas le problème, vous pouvez également essayer http://127.0.0.1:5000. Si vous utilisez Docker Machine sur un Mac ou Windows, utilisez docker-machine ip MACHINE_VMpour obtenir l'adresse IP de votre hôte Docker. Ensuite, ouvrez http://MACHINE_VM_IP:5000dans un navigateur. Vous devriez voir un message dans votre navigateur disant:

Hello World! I have been seen 1 times.

3. Actualiser la page.

Le nombre doit augmenter.

Hello World! I have been seen 2 times.

4. Basculez vers une autre fenêtre de terminal et tapez docker image lspour lister les images locales. La liste des images à ce stade doit renvoyer rediset web.

$ docker image ls

REPOSITORY TAG IMAGE ID CREATED SIZE
composetest_web latest e2c21aa48cc1 4 minutes ago 93.8MB
python 3.4-alpine 84e6077c7ab6 7 days ago 82.5MB
redis alpine 9d8fa9aa0e5b 3 weeks ago 27.5MB

Vous pouvez inspecter les images avec docker inspect <tag or id>.

5. Arrêtez l’application, soit en exécutant à docker-compose down partir du répertoire de votre projet dans le deuxième terminal, soit en appuyant sur CTRL + C dans le terminal d'origine où vous avez démarré l'application.

Étape 5: Modifiez le fichier de composition pour ajouter un point de montage

Modifiez docker-compose.ymldans votre répertoire de projet pour ajouter un point de montage pour le webservice, au cas où vous redémarrer le service les contenus ne seront pas perdus:

version: "3.8"
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/code
environment:
FLASK_ENV: development
redis:
image: "redis:alpine"

Les volumesclé monte le répertoire du projet (répertoire courant) sur l'hôte à l’intérieur du conteneur, vous permettant de modifier le code à la volée, sans avoir à reconstruire l'image. environmentdéfinit la variable d'environnement, qui indique flask runde s'exécuter en mode développement et de recharger le code en cas de modification. Ce mode ne doit être utilisé qu'en développement.

Étape 6: et exécutez l’application avec Compose

À partir du répertoire de votre projet, tapez docker-compose uppour créer l'application avec le fichier Compose mis à jour et exécutez-le.

$ docker-compose upCreating network "composetest_default" with the default driver
Creating composetest_web_1 ...
Creating composetest_redis_1 ...
Creating composetest_web_1
Creating composetest_redis_1 ... done
Attaching to composetest_web_1, composetest_redis_1
web_1 | * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
...

Vérifiez à nouveau le Hello Worldmessage dans un navigateur Web et actualisez-le pour voir l'incrémentation du nombre.

Étape 7: Mettez à jour l’application

Étant donné que le code de l’application est maintenant monté dans le conteneur à l’aide d’un volume, vous pouvez apporter des modifications à son code et voir les modifications instantanément, sans avoir à reconstruire l’image.

Modifiez le message d’accueil app.pyet enregistrez-le. Par exemple, modifiez le Hello World! message en Hello from Docker!:

return 'Hello from Docker! I have been seen {} times.\n'.format(count)

Actualisez l’application dans votre navigateur. Le message d’accueil doit être mis à jour et le compteur doit toujours être incrémenté.

Étape 8: Expérimentez avec d’autres commandes

Si vous souhaitez exécuter vos services en arrière-plan, vous pouvez passer l’ indicateur -d(pour le mode «détaché») docker-compose upet utiliser docker-compose pspour voir ce qui est en cours d'exécution:

$ docker-compose up -dStarting composetest_redis_1...
Starting composetest_web_1...
$ docker-compose psName Command State Ports
-------------------------------------------------------------------
composetest_redis_1 /usr/local/bin/run Up
composetest_web_1 /bin/sh -c python app.py Up 5000->5000/tcp

Si vous avez lancé Compose avec docker-compose up -d, arrêtez vos services une fois que vous en avez terminé:

$ docker-compose stop

Vous pouvez tout abattre, en supprimant entièrement les conteneurs, avec la commande down. Passez --volumespour supprimer également le volume de données utilisé par le conteneur Redis:

$ docker-compose down --volumes

À ce stade, vous avez vu les bases du fonctionnement de docker et docker-compose.

Cet article n’est pas parfait, il contiendrait des fautes d’ortographes et erreur dans les codes, priez de me contacter pour la correction.

Liens:
https://docs.docker.com/
https://hellofuture.orange.com/fr/comment-la-conteneurisation-informatique-accelere-le-developpement-des-applications/

Tech nerd. South Korea

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store