Soit votre tâche est petite, soit vous pouvez la décomposer en tâches plus petites. Et une petite tâche convient parfaitement à un microservice.

La conception logicielle est une phase essentielle du développement logiciel. L'approche de 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 dans un seul module. Cependant, cette approche peut s'avérer inefficace, en particulier pour les applications plus importantes.

Les microservices visent à répondre à 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. En conséquence, ils sont plus flexibles et plus faciles à entretenir.

L'architecture des microservices

L'architecture de 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 à un besoin métier spécifique.

Ces services s'exécutent sur des ressources dédiées, y compris des instances de base de données et une puissance de calcul distinctes. Contrairement aux systèmes monolithiques, les applications de microservices sont faiblement couplées, ce qui permet une plus grande flexibilité.

Dans un système distribué, les nœuds de serveur déploient et exécutent des applications de microservice séparément processus—communiquer entre eux à l'aide de protocoles de communication tels que HTTP ou via des courtiers de messages comme RabbitMQ.

Essentiellement, cette approche architecturale permet 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 didacticiel, nous vous guiderons dans la mise en œuvre d'un microservice utilisateur simple qui gère les données utilisateur à l'aide de Flask et PostgreSQL.

Configurer une base de données PostgreSQL

Pour commencer, installez PostgreSQL. Si vous n'avez pas installé PostgreSQL, vous pouvez découvrir comment installer PostgreSQL sur Windows ou comment installer PostgreSQL sur macOS.

Alternativement, vous pouvez configurer un base de données PostgreSQL distante exemple.

Ce guide utilisera le niveau gratuit de Render pour configurer une base de données PostgreSQL. Suivez ces instructions pour lancer une instance de base de données PostgreSQL sur Render :

  1. Dirigez-vous vers Site Web de Render, ouvrez un compte et connectez-vous à votre tableau de bord page.
  2. Sur votre page de tableau de bord, dans la liste des services affichés, sélectionnez le service PostgreSQL.
  3. Sur la page des paramètres de la base de données, remplissez les détails requis et assurez-vous de sélectionner le niveau gratuit, et enfin cliquez Créer une base de données.

Vous pouvez trouver le code de ce projet dans ce Référentiel GitHub.

Créer un microservice Flask

  1. Dans votre terminal, créez un nouveau répertoire et changez-le :
    mkdir flacon-microservice
    cd fiole-microservice
  2. Ensuite, installez environnement virtuel, pour créer un environnement de développement virtuel isolé.
    pip installer virtualenv
  3. Créez un environnement virtuel dans votre projet :
    virtualenv venv
  4. Enfin, activez l'environnement virtuel.
    # Les fenêtres: 
    .\venv\Scripts\activate
    # Unix ou MacOS: 
    source venv/bin/activer

Installer les packages requis

  1. Créer un nouveau exigences.txt fichier dans le répertoire racine et ajoutez ces packages :
    ballon
    psycopg2-binaire
    sqlalchimie
  2. Ensuite, installez les packages.
    pip install -r exigences.txt

Créer un serveur Flask

Dans le répertoire racine, créez un nouveau fichier: service.py, et le code suivant :

  1. Effectuez les importations suivantes :
    depuis ballon importer Flacon, requête, jsonify
    depuis sqlalchimie importer create_engine, Colonne, Entier, Chaîne
    depuis sqlalchemy.orm importer créateur de session
    depuis sqlalchemy.ext.déclaratif importer base_déclarative
    importer psycopg2
  2. Créez l'instance Flask et configurez la connexion à la base de données.
    app = flacon (__nom__)
    moteur = créer_moteur("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Copiez le URL de la base de données externe sur la page des paramètres de base de données de Render. Nous utiliserons le SQLAlchemy create_engine méthode et Psychopg2 pour configurer la connexion à la base de données. Assurez-vous de mettre à jour et de 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ère une erreur.
  3. Créez un modèle SQLAlchemy pour la base de données.
    Base = base_déclarative()
    classeUtilisateur(Base):
     __tablename__ = 'utilisateurs'
     id = Colonne (Entier, primary_key=Vrai)
     nom = Colonne (Chaîne(50))
    Base.metadata.create_all (moteur)
    imprimer("La table 'utilisateurs' a été créée avec succès.")
    Session = sessionmaker (moteur)
    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 SQLAlchemy create_all méthode qui prend la base de données objet moteur de connexion comme paramètre. Enfin, il crée une instance de créateur de session en utilisant le même objet moteur pour activer les interactions avec la base de données.
  4. Enfin, définissez les routes d'API pour le microservice.
    @app.route("/api/user", methodes=["POST"])
    définitivementCréer un utilisateur():
     données = request.get_json()
     nom = données["nom"]
    essayer:
     séance = séance()
     new_user = Utilisateur (nom=nom)
     session.add (nouvel_utilisateur)
     session.commit()
    retour {"identifiant": new_user.id, "nom": nouveau nom d'utilisateur, "message": f"Utilisateur {nom} créé."}, 201
    sauf Exception comme e :
     imprimer(f"L'erreur '{e}' s'est produit.")
    retour {"erreur": "Une erreur s'est produite lors de la création de l'utilisateur."}, 500
    @app.route("/api/user", methodes=["GET"])
    définitivementget_all_users():
    essayer:
     séance = séance()
     utilisateurs = session.query (Utilisateur).all()
    si utilisateurs:
     résultat = []
    pour utilisateur dans utilisateurs:
     résultat.append({"identifiant": ID de l'utilisateur, "nom": nom d'utilisateur})
    retour jsonifier (résultat)
    autre:
    retour jsonifier({"erreur": f"Utilisateurs introuvables."}), 404
    sauf Exception comme e :
     imprimer(f"L'erreur '{e}' s'est produit.")
    retour {"erreur": "Une erreur s'est produite lors de l'obtention de tous les utilisateurs."}, 500
    si __nom__ == "__principal__":
     app.run (débogage=Vrai, hôte="0.0.0.0")

Testez le microservice

Le code ci-dessus illustre un microservice de données utilisateur simple qui ajoute et récupère des données à partir d'une base de données PostgreSQL. Idéalement, les microservices reflètent le Architecture d'API REST puisqu'elle permet une approche flexible de la création de services Web, cette architecture s'intègre bien au modèle de conception des microservices.

Cependant, il est important de noter que les microservices peuvent également 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, lancez le serveur de développement et dirigez-vous vers Postman pour envoyer des requêtes HTTP aux points de terminaison définis.

flacon --exécution du service d'application

Dans Postman, effectuez une requête POST pour ajouter des données utilisateur.

Conteneuriser les microservices avec Docker

Docker regroupe les applications et leurs dépendances dans des conteneurs. Cette approche rationalise le développement, le déploiement et la gestion des microservices dans un environnement de production puisque chaque service peut fonctionner indépendamment et communiquer avec d'autres services en utilisant la communication configurée protocole.

Avant de commencer, vous devez d'abord installer Docker en suivant les étapes sur le Site Web Docker. Ensuite, créez une image Docker à partir d'un Dockerfile qui contient les instructions nécessaires pour configurer les dépendances requises pour exécuter l'application dans un conteneur.

  1. Créez un Dockerfile dans le répertoire racine de votre dossier de projet et ajoutez ces instructions :
    DEPUIS python:3.9-alpin
    RÉP TRAVAIL /app
    COPIE exigences.txt ./
    COURIR pip install -r exigences.txt
    COPIE. .
    EXPOSER5000
    CMD ["python", "./service.py"]
  2. Exécutez la commande ci-dessous pour créer l'image Docker.
     docker build -t flacon-microservice .
  3. Enfin, exécutez le conteneur Docker.
    docker run -p 5000:5000 flacon-microservice

Cela démarrera un conteneur Docker exécutant le microservice Flask et exposera le port 5000 sur le conteneur à port 8000 sur la machine hôte, vous permettant de faire des requêtes HTTP depuis votre navigateur Web ou Postman en utilisant le URL http://localhost: 5000.

Adopter l'architecture des microservices

L'architecture de microservices est devenue une approche populaire pour développer des applications logicielles évolutives et robustes. En divisant l'application en petits services déployables indépendamment, l'architecture des microservices facilite la maintenance et la mise à l'échelle du système.

Bien que cette architecture présente des avantages potentiels, elle ne convient pas à tous les cas d'utilisation. Dans tous les cas, les exigences commerciales spécifiques du projet doivent principalement influencer l'approche de conception adoptée.