La conception d’un logiciel est une phase essentielle de son développement. L’approche de la conception peut affecter l’ensemble du projet et la façon dont vous gérez les différentes exigences.
Les développeurs ont souvent utilisé une architecture monolithique, regroupant tous les composants logiciels en un seul module. Toutefois, cette approche peut s’avérer inefficace, en particulier pour les applications de grande envergure.
Les microservices visent à remédier à ces limitations. Un microservice est une petite application modulaire qui exécute des fonctions spécifiques. Contrairement aux applications monolithiques, les microservices permettent un déploiement et une mise à l’échelle indépendants. Ils sont donc plus flexibles et plus faciles à maintenir.
L’architecture microservice
L’architecture microservice est une approche de conception logicielle qui décompose une grande application en services indépendants, chaque service étant conçu pour répondre à une exigence professionnelle spécifique.
Ces services s’exécutent sur des ressources dédiées, notamment des instances de base de données et une puissance de calcul distinctes. Contrairement aux systèmes monolithiques, les applications microservices sont faiblement couplées, ce qui permet une plus grande flexibilité.
Dans un système distribué, les nœuds de serveurs déploient et exécutent des applications de microservices en tant que processus distincts, communiquant entre eux à l’aide de protocoles de communication tels que HTTP ou via des courtiers de messages tels que RabbitMQ.
Cette approche architecturale permet essentiellement aux services de conserver leur indépendance les uns par rapport aux autres tout en fonctionnant efficacement au sein du système logiciel.
Dans ce tutoriel, nous vous guiderons dans l’implémentation d’un microservice utilisateur simple qui gère les données des utilisateurs en utilisant Flask et PostgreSQL.
Configurer une base de données PostgreSQL
Pour commencer, installez PostgreSQL. Si PostgreSQL n’est pas installé, vous pouvez trouver comment installer PostgreSQL sur Windows ou comment installer PostgreSQL sur macOS.
Vous pouvez également configurer une instance de base de données PostgreSQL distante.
Ce guide utilisera le niveau gratuit de Render pour configurer une base de données PostgreSQL. Suivez ces instructions pour démarrer une instance de base de données PostgreSQL sur Render :
- Rendez-vous sur le site web de Render, ouvrez un compte, et connectez-vous à votre compte tableau de bord page.
- Sur la page de votre tableau de bord, dans la liste des services affichés, sélectionnez le service PostgreSQL.
- Sur la page des paramètres de la base de données, remplissez les détails requis et assurez-vous de sélectionner l’option niveau gratuitet enfin cliquez sur Créer une base de données.
Vous pouvez trouver le code de ce projet dans ce dépôt GitHub.
Créer un microservice Flask
- Dans votre terminal, créez un nouveau répertoire et entrez-y :
mkdir flask-microservice
cd flask-microservice - Ensuite, installez virtualenvpour créer un environnement de développement virtuel isolé.
pip install virtualenv - Créez un environnement virtuel dans votre projet :
virtualenv venv - Enfin, activez l’environnement virtuel.
# Windows:
.\venv\Scripts\activate
# Unix or MacOS:
source venv/bin/activate
Installer les paquets nécessaires
- Créer un nouveau exigences.txt dans le répertoire racine et ajoutez ces paquets :
flask
psycopg2-binary
sqlalchemy - Ensuite, installez les paquets.
pip install -r requirements.txt
Créer un serveur Flask
Dans le répertoire racine, créez un nouveau fichier : service.pyet le code suivant :
- Effectuer les importations suivantes :
from flask import Flask, request, jsonify
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
import psycopg2 - Créer l’instance Flask et configurer la connexion à la base de données.
app = Flask(__name__)
engine = create_engine("postgresql+psycopg2://flask_service_fe0v_user:4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")Copier le fichier URL de la base de données externe sur la page des paramètres de la base de données de Render. Nous utiliserons la méthode SQLAlchemy create_engine et la méthode Psycopg2 pour configurer la connexion à la base de données. Veillez à mettre à jour et à remplacer l’URL de la base de données dans le code ci-dessus par l’URL de votre propre instance PostgreSQL qui correspond au format spécifié ci-dessus. Si le format de l’URL est incorrect, le code générera une erreur.
- Créer un modèle SQLAlchemy pour la base de données.
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(50))
Base.metadata.create_all(engine)
print("Table 'users' created successfully.")
Session = sessionmaker(engine)Le code définit un modèle de données pour la table des utilisateurs. Après avoir défini le modèle, il crée la table à l’aide de la fonction SQLAlchemy create_all qui prend la base de données objet du moteur de connexion comme paramètre. Enfin, il crée une instance de l’objet créateur de session utilisant le même objet moteur pour permettre les interactions avec la base de données.
- Enfin, définissez les routes API pour le microservice.
@app.route("/api/user", methods=["POST"])
def create_user():
data = request.get_json()
name = data["name"]
try:
session = Session()
new_user = User(name=name)
session.add(new_user)
session.commit()
return {"id": new_user.id, "name": new_user.name, "message": f"User {name} created."}, 201
except Exception as e:
print(f"The error '{e}' occurred.")
return {"error": "An error occurred while creating the user."}, 500
@app.route("/api/user", methods=["GET"])
def get_all_users():
try:
session = Session()
users = session.query(User).all()
if users:
result = []
for user in users:
result.append({"id": user.id, "name": user.name})
return jsonify(result)
else:
return jsonify({"error": f"Users not found."}), 404
except Exception as e:
print(f"The error '{e}' occurred.")
return {"error": "An error occurred while getting all users."}, 500
if __name__ == "__main__":
app.run(debug=True, host="0.0.0.0")
Tester le microservice
Le code ci-dessus démontre un microservice simple de données utilisateur qui ajoute et récupère des données à partir d’une base de données PostgreSQL. Idéalement, les microservices reflètent l’architecture de l’API REST puisqu’elle permet une approche flexible de la construction de services web – cette architecture correspond bien au modèle de conception des microservices.
Cependant, il est important de noter que les microservices peuvent utiliser d’autres types d’approches de conception et de protocoles de communication, en fonction des besoins spécifiques du système.
Pour tester le service, démarrez le serveur de développement et dirigez-vous vers Postman pour effectuer des requêtes HTTP vers les points d’extrémité définis.
flask --app service run
Dans Postman, faites une requête POST pour ajouter des données utilisateur.
Conteneuriser des microservices avec Docker
Docker regroupe les applications et leurs dépendances dans des conteneurs. Cette approche permet de rationaliser le développement, le déploiement et la gestion des microservices dans un environnement de production, car chaque service peut fonctionner de manière indépendante et communiquer avec d’autres services à l’aide du protocole de communication configuré.
Avant de commencer, vous devez d’abord installer Docker en suivant les étapes indiquées sur le site Web de Docker. Ensuite, construisez une image Docker à partir d’un fichier Docker qui contient les instructions nécessaires pour configurer les dépendances requises afin d’exécuter l’application dans un conteneur.
- Créez un fichier Docker dans le répertoire racine de votre dossier de projet et ajoutez ces instructions :
FROM python:3.9-alpine
WORKDIR /app
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "./service.py"] - Exécutez la commande ci-dessous pour construire l’image Docker.
docker build -t flask-microservice . - Enfin, lancez le conteneur Docker.
docker run -p 5000:5000 flask-microservice
Cela démarrera un conteneur Docker exécutant le microservice Flask et exposera le port 5000 du conteneur au port 8000 de la machine hôte, ce qui vous permettra d’effectuer des requêtes HTTP à partir de votre navigateur Web ou de Postman à l’aide de l’URL http://localhost:5000.
Adopter l’architecture microservice
L’architecture microservices est devenue une approche populaire pour le développement d’applications logicielles évolutives et robustes. En divisant l’application en petits services déployables indépendamment, l’architecture microservices facilite la maintenance et l’évolution du système.
Bien que cette architecture présente des avantages potentiels, elle ne convient pas à tous les cas d’utilisation. En tout état de cause, ce sont les exigences commerciales spécifiques du projet qui doivent influencer en premier lieu l’approche de conception adoptée.