Concevoir une application basée sur des microservices

Découvrir les meilleures pratiques pour la conception de microservices

En suivant certaines bonnes pratiques lors de la conception de microservices, vous pouvez vous assurer que votre application est facile à faire évoluer, à déployer et à maintenir. Notez que les meilleures pratiques abordées ici ne sont pas toutes pertinentes pour votre application.

Chaque microservice doit implémenter une seule partie des fonctionnalités de l'application. Les équipes de développement doivent définir les limites et les responsabilités de chaque microservice. Une approche consiste à définir un microservice pour chaque tâche fréquemment demandée dans l'application. Une autre approche consiste à diviser les fonctionnalités par tâches métier, puis à définir un microservice pour chaque domaine.

Tenez compte des exigences suivantes dans votre conception :

Microservices réactifs : les microservices doivent renvoyer une réponse aux clients demandeurs, même en cas d'échec du service.
Compatibilité ascendante : lorsque vous ajoutez ou mettez à jour la fonctionnalité d'un microservice, les modifications apportées aux paramètres et méthodes d'API ne doivent pas affecter les clients. L'API REST doit rester rétrocompatible.
Communication flexible : chaque microservice peut indiquer le protocole à utiliser pour la communication entre les clients et la passerelle d'API, ainsi que pour la communication entre les microservices.
Idempotency : si un client appelle un microservice plusieurs fois, il doit produire le même résultat.
Opération efficace : la conception doit faciliter la surveillance et le dépannage. Un système de journalisation est couramment utilisé pour implémenter cette exigence.

Comprendre les 12 modèles de réussite des microservices

Les microservices sont difficiles à implémenter, et ces 12 modèles facilitent l'exploitation de l'agilité et de la simplicité d'une architecture de services en miroir à l'aide d'une plate-forme de base de données convergée avec des conteneurs et Kubernetes.

Contextes limités : concevez-le à l'avance ou décomposez les monolithes en microservices à l'aide d'une fonction de conseil de refactorisation des données.
Couplage à faible coût : dissociez les données en isolant le schéma vers le microservice et en utilisant un maillage d'événements fiable.
CI/CD pour les microservices : une base de données colocative en fait un ajustement naturel pour les microservices. Ajoutez une base de données pluggable à déployer et à créer indépendamment. Une application (avec Jenkins) et un schéma (Liquibase, Flyway et EBR dans la base de données) sont également de bons choix.
Sécurité pour les microservices : sécurisez chaque adresse de la passerelle d'API à l'équilibreur de charge, au maillage d'événements et à la base de données.
Observabilité unifiée pour les microservices : mesures, journaux et traces dans un seul tableau de bord pour le réglage et l'autoréparation.
Boîte d'envoi transactionnelle : envoi d'un message et d'une opération de manipulation de données dans une transaction locale unique.
Maillage d'événements fiable : maillage d'événements pour tous les événements avec messagerie transactionnelle haut débit, publication et sous-traitance, avec transformations d'événements et routage d'événements.
Agrégation d'événements : les événements sont éphémères et notifient ou déclenchent une action en temps réel. Après quoi ils sont agrégés dans la base de données, la base de données est le sujet compacté ultime.
Ségrégation des responsabilités de requête de commande (CQRS) : lorsque des copies opérationnelles et analytiques des données sont disponibles pour les microservices.
Sagas : transactions entre microservices, avec prise en charge du maillage d'événements et de la journalisation séquentielle dans la base de données.
Programmation multi-langage : prise en charge des microservices et des formats de message dans divers langages, en utilisant JSON comme charge utile.
Back-end en tant que service (BaaS) : infrastructure de microservices adaptée aux déploiements de test, de développement et de production (petit à moyen) sur n'importe quel déploiement cloud ou sur site, pour les applications Spring Boot.

Commencer par un modèle de contexte limité

Le modèle recommandé pour implémenter la persistance pour un microservice consiste à utiliser une seule base de données pluggable dans une base de données Conteneur. Pour chaque microservice, gardez les données persistantes privées et créez la base de données pluggable dans le cadre de l'implémentation du microservice.

Dans ce modèle, les données persistantes privées sont accessibles uniquement via l'API de microservice.

L'illustration suivante présente la conception de persistance pour les microservices.

Description de l'image microservices_persistence.png

Les variantes suivantes de cette implémentation de microservices s'appliquent aux bases de données convergées :

Tables privées : Chaque service possède un ensemble de tables ou de documents.
Schéma : chaque service possède un schéma de base de données privé ou une collection.
Base de données : chaque service possède une base de données pluggable au sein d'une base de données Conteneur, comme illustré dans l'illustration.

Un anti-modèle de persistance pour vos microservices consiste à partager un schéma de base de données entre plusieurs microservices. Vous pouvez implémenter des transactions atomiques, cohérentes, isolées et durables pour assurer la cohérence des données. Un avantage avec cet anti-modèle est qu'il utilise une base de données simple. Les inconvénients sont que les microservices peuvent interférer les uns avec les autres lors de l'accès à la base de données et que les cycles de développement peuvent ralentir car les développeurs de différents microservices doivent coordonner les modifications de schéma, ce qui augmente également les dépendances entre services.

Vos microservices peuvent se connecter à une instance Oracle Database exécutée sur Oracle Cloud Infrastructure. La base de données colocative Oracle prend en charge plusieurs bases de données pluggables au sein d'un conteneur. Il s'agit du meilleur choix pour la couche de persistance des microservices, pour l'isolement contextuel limité des données, la sécurité et la haute disponibilité. Dans de nombreux cas, moins de bases de données pluggables peuvent être utilisées avec l'isolement au niveau du schéma.

Comprendre la valeur du déploiement de microservices dans des conteneurs

Une fois le microservice créé, vous devez le mettre en conteneur. Un microservice exécuté dans son propre conteneur n'affecte pas les microservices déployés dans les autres conteneurs.

Un conteneur est une unité logicielle normalisée, utilisée pour développer, expédier et déployer des applications.

Les conteneurs sont gérés à l'aide d'un moteur de conteneur, tel que Docker. Le moteur de conteneur fournit les outils nécessaires pour regrouper toutes les dépendances d'application en tant que conteneur.

Vous pouvez utiliser le moteur Docker pour créer, déployer et exécuter vos applications de microservices dans des conteneurs. Les microservices exécutés dans des conteneurs Docker présentent les caractéristiques suivantes :

Standard : les microservices sont portables. Ils peuvent courir n'importe où.
Léger : Docker partage le noyau du système d'exploitation, ne nécessite pas de système d'exploitation pour chaque instance et s'exécute en tant que processus léger.
Sécurisé : chaque conteneur s'exécute en tant que processus isolé. Les microservices sont donc sécurisés.

Le processus de mise en conteneur d'un microservice consiste à créer un fichier Dockerfile, à créer et à créer une image de conteneur qui inclut ses dépendances et la configuration de l'environnement, à déployer l'image vers un moteur Docker et à télécharger l'image vers un registre de conteneur pour stockage et extraction.

Description de l'image docker_container_process.png

En savoir plus sur l'orchestration de microservices à l'aide de Kubernetes

Les microservices qui s'exécutent dans des conteneurs doivent pouvoir interagir et s'intégrer pour fournir les fonctionnalités d'application requises. Cette intégration peut être réalisée via l'orchestration de conteneurs.

L'orchestration de conteneurs vous permet de démarrer, d'arrêter et de regrouper des conteneurs dans des clusters. Il permet également une haute disponibilité et une mise à l'échelle. Kubernetes est l'une des plates-formes d'orchestration de conteneurs que vous pouvez utiliser pour gérer les conteneurs.

Une fois que vous avez mis en conteneur vos microservices, vous pouvez les déployer vers Oracle Cloud Infrastructure Container Engine for Kubernetes.

Avant de déployer votre application de microservices en conteneur vers le cloud, vous devez la déployer et la tester dans un moteur Kubernetes local, comme suit :

Créez votre application de microservices.
Créez des images Docker pour mettre en conteneur vos microservices.
Exécutez vos microservices dans votre moteur Docker local.
propager les images de conteneur vers un registre de conteneur,
Déployez et exécutez vos microservices dans un moteur Kubernetes local, tel que Minikube.

Après avoir testé l'application dans un moteur Kubernetes local, déployez-la vers Oracle Cloud Infrastructure Container Engine for Kubernetes comme suit :

Créer un cluster.
Télécharger le fichier kubeconfig
Installez l'outil kubectl sur un périphérique local.
Préparez le fichier deployment.yaml.
Déployez le microservice sur le cluster.
Testez le microservice.

Le diagramme suivant présente le processus de déploiement d'une application de microservices en conteneur vers Oracle Cloud Infrastructure Container Engine for Kubernetes.

Description de l'image oke_deployment_process.png

En savoir plus sur Oracle Backend for Spring Boot and Microservices

Spring Boot est le cadre le plus populaire pour la création de microservices en Java. L'un des 12 modèles de réussite du déploiement réussi de l'architecture de microservices est le modèle Backend en tant que service (BaaS). Oracle BaaS est disponible sur OCI Marketplace pour un déploiement à l'aide de Terraform et d'Ansible en 30 minutes. Oracle BaaS fournit un ensemble de services de plate-forme requis pour déployer et exploiter des microservices, et font partie intégrante de l'environnement Spring Boot. Les détails de la plate-forme Oracle Backend for Spring Boot and Microservices sont illustrés dans le diagramme ci-dessous.

Voici la description d'oracle-backend-spring-boot-microservices.png

Description de l'illustration oracle-backend-spring-boot-microservices.png