Accéder à une application web Docker : Guide complet

Introduction

Ce tutoriel vous guidera à travers le processus d'accès à une application web fonctionnant dans un conteneur Docker. Vous apprendrez les bases des conteneurs Docker, déploirez une application web simple et découvrirez comment y accéder depuis votre machine hôte. Ces connaissances sont essentielles pour le développement et le test d'applications web en utilisant Docker.

Comprendre Docker et exécuter un conteneur de test

Docker est une plateforme qui utilise la conteneurisation pour empaqueter les applications et leurs dépendances ensemble. Cela permet aux applications de s'exécuter de manière cohérente dans différents environnements.

Vérification de l'installation de Docker

Tout d'abord, vérifions si Docker est correctement installé sur votre système :

docker --version

Vous devriez voir une sortie similaire à celle-ci, indiquant la version de Docker :

Docker version 20.10.21, build baeda1f

Comprendre les images et les conteneurs Docker

Dans la terminologie Docker :

Une image Docker (Docker image) est un modèle contenant le code de l'application, les bibliothèques et les dépendances.
Un conteneur Docker (Docker container) est une instance en cours d'exécution d'une image.

Considérez une image Docker comme un plan et un conteneur Docker comme un bâtiment créé à partir de ce plan.

Exécution de votre premier conteneur Docker

Exécutons un conteneur simple pour vérifier que Docker fonctionne correctement :

docker run hello-world

Vous devriez voir une sortie comme celle-ci :

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.
...

Cela confirme que Docker fonctionne correctement sur votre système.

Commandes Docker de base

Voici quelques commandes Docker essentielles que vous devriez connaître :

Pour lister tous les conteneurs en cours d'exécution :

docker ps

Pour lister tous les conteneurs (y compris ceux arrêtés) :

docker ps -a

Pour lister toutes les images Docker sur votre système :

docker images

Essayez ces commandes et observez les sorties. Après avoir exécuté le conteneur hello-world, vous devriez le voir listé lorsque vous exécutez docker ps -a (mais pas dans docker ps car il se ferme immédiatement après avoir affiché le message).

Création d'une application web simple

Dans cette étape, nous allons créer une application web simple en utilisant Python et Flask que nous pourrons déployer dans un conteneur Docker.

Configuration des fichiers de l'application

Tout d'abord, créons un nouveau répertoire pour notre application web :

mkdir -p ~/project/my-web-app
cd ~/project/my-web-app

Maintenant, créons une application Flask simple. Créez un fichier appelé app.py en utilisant l'éditeur nano :

nano app.py

Ajoutez le code Python suivant au fichier :

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Appuyez sur Ctrl+O suivi de Entrée pour enregistrer le fichier, puis sur Ctrl+X pour quitter nano.

Ensuite, créez un fichier requirements.txt pour spécifier les dépendances de notre application :

nano requirements.txt

Ajoutez la ligne suivante au fichier :

flask==2.0.1

Appuyez sur Ctrl+O suivi de Entrée pour enregistrer le fichier, puis sur Ctrl+X pour quitter nano.

Création d'un Dockerfile

Maintenant, créons un Dockerfile pour définir comment notre application doit être conteneurisée :

nano Dockerfile

Ajoutez le contenu suivant au fichier :

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]

Ce Dockerfile fait ce qui suit :

Utilise une image Python 3.9 légère comme base
Définit le répertoire de travail sur /app
Copie le fichier requirements et installe les dépendances
Copie le code de l'application
Expose le port 5000 pour les connexions entrantes
Spécifie la commande à exécuter lorsque le conteneur démarre

Appuyez sur Ctrl+O suivi de Entrée pour enregistrer le fichier, puis sur Ctrl+X pour quitter nano.

Construction de l'image Docker

Maintenant, construisons une image Docker à partir de notre Dockerfile :

docker build -t my-flask-app .

L'option -t étiquette notre image avec le nom my-flask-app. Le . à la fin spécifie que le Dockerfile se trouve dans le répertoire courant.

Vous devriez voir une sortie similaire à celle-ci :

Sending build context to Docker daemon  x.xxxkB
Step 1/6 : FROM python:3.9-slim
 ---> xxxxxxxxxx
Step 2/6 : WORKDIR /app
 ---> Using cache
 ---> xxxxxxxxxx
...
Successfully built xxxxxxxxxx
Successfully tagged my-flask-app:latest

Maintenant, vérifiez que votre image a été créée :

docker images | grep my-flask-app

Vous devriez voir votre image nouvellement créée dans la liste.

Exécution de l'application web dans un conteneur Docker

Maintenant que nous avons construit notre image Docker, exécutons-la en tant que conteneur et accédons à l'application web.

Exécution du conteneur

Pour exécuter le conteneur et mapper le port afin que nous puissions accéder à l'application web, utilisez la commande suivante :

docker run -d -p 5000:5000 --name my-web-container my-flask-app

Cette commande fait ce qui suit :

-d : Exécute le conteneur en mode détaché (en arrière-plan)
-p 5000:5000 : Mappe le port 5000 du conteneur vers le port 5000 sur l'hôte
--name my-web-container : Attribue un nom au conteneur
my-flask-app : Spécifie l'image à utiliser

Vérification que le conteneur est en cours d'exécution

Vérifions que notre conteneur est en cours d'exécution :

docker ps

Vous devriez voir une sortie similaire à celle-ci :

CONTAINER ID   IMAGE          COMMAND           CREATED          STATUS          PORTS                    NAMES
xxxxxxxxxxxx   my-flask-app   "python app.py"   xx seconds ago   Up xx seconds   0.0.0.0:5000->5000/tcp   my-web-container

Accès à l'application web

Maintenant, vous pouvez accéder à l'application web de deux manières :

En utilisant curl depuis la ligne de commande :

curl http://localhost:5000

Vous devriez voir la réponse HTML :

<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>

En utilisant un navigateur web :
- Cliquez sur l'icône du navigateur web dans l'environnement de bureau
- Entrez http://localhost:5000 dans la barre d'adresse
- Vous devriez voir "Hello from Docker!" suivi du texte de description

Comprendre le mappage de ports

Lorsque nous exécutons un conteneur avec -p 5000:5000, nous créons un mappage entre :

Le port hôte (premier nombre) : 5000
Le port du conteneur (deuxième nombre) : 5000

Cela signifie que tout le trafic envoyé au port 5000 sur la machine hôte sera transféré vers le port 5000 à l'intérieur du conteneur.

Nous pourrions également utiliser des numéros de port différents. Par exemple, -p 8080:5000 mapperait le port hôte 8080 au port du conteneur 5000, vous permettant d'accéder à l'application à l'adresse http://localhost:8080.

Inspection des journaux du conteneur

Si vous avez besoin de voir les journaux du conteneur (ce qui peut être utile pour le débogage), utilisez :

docker logs my-web-container

Vous devriez voir les messages de démarrage de l'application Flask.

Arrêt et suppression du conteneur

Pour arrêter le conteneur, utilisez :

docker stop my-web-container

Pour supprimer le conteneur arrêté, utilisez :

docker rm my-web-container

Vous pouvez également arrêter et supprimer un conteneur en une seule commande :

docker rm -f my-web-container

Ceci est utile pendant le développement lorsque vous souhaitez reconstruire et réexécuter votre conteneur rapidement.

Gestion avancée des conteneurs Docker

Maintenant que vous avez exécuté avec succès votre application web dans un conteneur Docker, explorons quelques fonctionnalités et techniques supplémentaires pour la gestion des conteneurs Docker.

Exécution de plusieurs instances

Vous pouvez exécuter plusieurs instances de votre application web sur différents ports. Ceci est utile pour les tests ou pour exécuter différentes versions de votre application simultanément.

Tout d'abord, arrêtons et supprimons notre conteneur précédent :

docker rm -f my-web-container

Maintenant, exécutons deux instances de notre application web sur différents ports :

docker run -d -p 5000:5000 --name web-app-1 my-flask-app
docker run -d -p 5001:5000 --name web-app-2 my-flask-app

Vérifiez que les deux conteneurs sont en cours d'exécution :

docker ps

Vous devriez voir deux conteneurs en cours d'exécution :

CONTAINER ID   IMAGE          COMMAND           CREATED          STATUS          PORTS                    NAMES
xxxxxxxxxxxx   my-flask-app   "python app.py"   xx seconds ago   Up xx seconds   0.0.0.0:5001->5000/tcp   web-app-2
xxxxxxxxxxxx   my-flask-app   "python app.py"   xx seconds ago   Up xx seconds   0.0.0.0:5000->5000/tcp   web-app-1

Vous pouvez maintenant accéder à la même application sur deux ports différents :

Limites de ressources des conteneurs

Docker vous permet de définir des limites de ressources pour vos conteneurs. Ceci est utile pour empêcher un conteneur de consommer trop de ressources système.

Arrêtons et supprimons nos conteneurs précédents :

docker rm -f web-app-1 web-app-2

Maintenant, exécutons un conteneur avec des limites de mémoire et de CPU :

docker run -d -p 5000:5000 --name limited-container --memory=512m --cpus=0.5 my-flask-app

Cette commande crée un conteneur avec :

Un maximum de 512 Mo de mémoire
Un maximum de 0,5 cœur de CPU

Vérifiez que le conteneur est en cours d'exécution :

docker ps

Variables d'environnement des conteneurs

Les variables d'environnement sont un moyen courant de configurer les applications dans les conteneurs Docker. Modifions notre application Flask pour utiliser une variable d'environnement :

docker rm -f limited-container

Créez une nouvelle version du fichier app.py :

cd ~/project/my-web-app
nano app_env.py

Ajoutez le code suivant :

import os
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    app_name = os.environ.get('APP_NAME', 'Default App')
    return f"<h1>Hello from {app_name}!</h1><p>This is a simple web application running in a Docker container.</p>"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Appuyez sur Ctrl+O suivi de Entrée pour enregistrer le fichier, puis Ctrl+X pour quitter nano.

Créez un nouveau Dockerfile :

nano Dockerfile-env

Ajoutez le contenu suivant :

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app_env.py ./app.py
EXPOSE 5000
CMD ["python", "app.py"]

Appuyez sur Ctrl+O suivi de Entrée pour enregistrer le fichier, puis Ctrl+X pour quitter nano.

Construisez une nouvelle image :

docker build -t my-flask-app-env -f Dockerfile-env .

Maintenant, exécutez le conteneur avec une variable d'environnement :

docker run -d -p 5000:5000 --name env-container -e APP_NAME="Customized App" my-flask-app-env

Accédez à l'application web :

curl http://localhost:5000

Vous devriez voir :

<h1>Hello from Customized App!</h1><p>This is a simple web application running in a Docker container.</p>

Ceci démontre comment transmettre la configuration à vos applications conteneurisées en utilisant des variables d'environnement.

Résumé

Dans ce laboratoire, vous avez appris à accéder à une application web s'exécutant dans un conteneur Docker. Vous avez créé une simple application web Flask, l'avez conteneurisée à l'aide de Docker et y avez accédé depuis votre machine hôte en utilisant le mappage de ports.

Concepts clés couverts :

Compréhension des images et des conteneurs Docker
Création d'une simple application web avec Flask
Construction d'une image Docker avec un Dockerfile
Exécution et accès à une application web conteneurisée
Gestion des conteneurs Docker avec diverses commandes
Exécution de plusieurs instances de conteneurs sur différents ports
Définition de limites de ressources pour les conteneurs
Utilisation de variables d'environnement pour la configuration des conteneurs

Ces compétences fournissent une base solide pour travailler avec des applications conteneurisées et vous aideront à déployer et à tester efficacement des applications web à l'aide de Docker.

Comment accéder à une application web s'exécutant dans un conteneur Docker

Introduction

Comprendre Docker et exécuter un conteneur de test

Vérification de l'installation de Docker

Comprendre les images et les conteneurs Docker

Exécution de votre premier conteneur Docker

Commandes Docker de base

Création d'une application web simple

Configuration des fichiers de l'application

Création d'un Dockerfile

Construction de l'image Docker

Exécution de l'application web dans un conteneur Docker

Exécution du conteneur

Vérification que le conteneur est en cours d'exécution

Accès à l'application web

Comprendre le mappage de ports

Inspection des journaux du conteneur

Arrêt et suppression du conteneur

Gestion avancée des conteneurs Docker

Exécution de plusieurs instances

Limites de ressources des conteneurs

Variables d'environnement des conteneurs

Résumé