• Cloud

Réseau Docker Simplifié : Connectez Vos Conteneurs Comme un Pro !

  • 2 min read

Dans le paysage actuel du développement logiciel, la conteneurisation est devenue une pratique essentielle, offrant des environnements cohérents pour le développement, les tests et le déploiement.

Docker, une plateforme de conteneurisation de premier plan, permet aux développeurs d’emballer des applications et leurs dépendances dans des conteneurs, garantissant une opération cohérente à travers différents environnements. Docker Compose simplifie davantage ce processus en permettant de définir et gérer des applications Docker multi-conteneurs.

Dans cet article, nous allons parcourir la configuration d’un fichier Docker Compose pour deux applications interconnectées. Ces applications, construites avec Flask (un micro-framework web pour Python), pourront s’appeler mutuellement via HTTP. À la fin de ce guide, vous aurez une configuration multi-conteneurs opérationnelle où les applications interagissent sans problème.

Prérequis

    • Docker installé sur votre machine

    • Docker Compose installé sur votre machine

    • Compréhension de base de Docker et Docker Compose

    • Connaissances en Python et Flask

Structure du Projet

Voici la structure de notre projet :

Étapes de Configuration

  1. Définir les Applications Flask
    Nous allons créer deux applications Flask simples qui s’exécuteront sur des ports différents et pourront s’appeler mutuellement.


app1/app.py

				
					from flask import Flask, request
import requests

app = Flask(__name__)

@app.route('/')
def home():
    return "Bonjour depuis App1 !"

@app.route('/call_app2')
def call_app2():
    response = requests.get('http://app2:5001/')
    return f"App1 appelle App2 : {response.text}"

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

app2/app.py

				
					from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Bonjour depuis App2 !"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5001)
  1. Créer les Fichiers de Dépendances
    Les deux applications utiliseront Flask et requests, donc nous listerons ces dépendances dans requirements.txt pour chaque application.

 

app1/requirements.txt et app2/requirements.txt

				
					flask requests
  1. Créer les Dockerfiles
    Chaque application aura son Dockerfile pour construire l’image de conteneur.

app1/Dockerfile

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

FROM python:3.9-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir -r requirements.txt
EXPOSE 5001
CMD ["python", "app.py"]
  1. Définir la Configuration Docker Compose
    Nous utiliserons Docker Compose pour définir et gérer notre application multi-conteneurs.

docker-compose.yml

				
					version: '3.8'

services:
  app1:
    build:
      context: ./app1
    ports:
      - "5002:5000"
    networks:
      - app-network

  app2:
    build:
      context: ./app2
    ports:
      - "5003:5001"
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

Dans cette configuration :

  • app1 est construit depuis le répertoire ./app1 et expose le port 5000 dans le conteneur, mappé au port 5002 sur l’hôte.
  • app2 est construit depuis le répertoire ./app2 et expose le port 5001 dans le conteneur, mappé au port 5003 sur l’hôte.
  • Les deux services sont connectés via le réseau app-network, leur permettant de communiquer en interne avec leurs noms de service respectifs (app1 et app2).
  1. Construire et Exécuter les Conteneurs
    Naviguez jusqu’au répertoire racine du projet et exécutez la commande suivante pour construire et démarrer les conteneurs :
docker-compose up --build
  1. Tester la Configuration
    Une fois les conteneurs en cours d’exécution, vous pouvez tester l’inter-communication :
  • Accédez à app1 sur http://localhost:5002. Vous devriez voir le message : Bonjour depuis App1 !.
  • Accédez au point de terminaison de app1 qui appelle app2 à http://localhost:5002/call_app2. Vous devriez voir le message : App1 appelle App2 : Bonjour depuis App2 !.

Conclusion

Dans cet article, nous avons configuré une application multi-conteneurs en utilisant Docker Compose. Nous avons défini deux applications Flask, les avons conteneurisées avec Docker, et utilisé Docker Compose pour gérer leur déploiement et leur inter-communication. Cette approche simplifie non seulement le processus de développement mais assure également la cohérence entre différents environnements, rendant vos applications plus fiables et plus faciles à gérer.

La conteneurisation avec Docker et Docker Compose est un moyen puissant de rationaliser votre flux de travail, en particulier lorsqu’il s’agit de services interconnectés. En suivant les étapes ci-dessus, vous pouvez facilement configurer et gérer vos propres applications multi-conteneurs.

Articles Connexes