Architecture des microservices - Guide rapide

Microservice est une méthodologie de développement d'applications basée sur les services. Dans cette méthodologie, les grandes applications seront divisées en plus petites unités de service indépendantes. Le microservice est le processus de mise en œuvre de l'architecture orientée services (SOA) en divisant l'ensemble de l'application en un ensemble de services interconnectés, où chaque service ne répond qu'à un seul besoin métier.

Le concept du micro

Dans une architecture orientée services, des progiciels entiers seront subdivisés en petites unités commerciales interconnectées. Chacune de ces petites unités commerciales communiquera entre elles en utilisant différents protocoles pour offrir une entreprise prospère au client. Maintenant, la question est de savoir en quoi l'architecture de microservice (MSA) diffère de SOA? En un mot, SOA est un modèle de conception et Microservice est une méthodologie de mise en œuvre pour implémenter SOA ou nous pouvons dire que Microservice est un type de SOA.

Voici quelques règles que nous devons garder à l'esprit lors du développement d'une application orientée Microservice.

Independent - Chaque microservice doit être déployable indépendamment.
Coupling - Tous les microservices doivent être faiblement couplés les uns aux autres de sorte que les changements dans l'un n'affectent pas l'autre.
Business Goal - Chaque unité de service de l'ensemble de l'application doit être la plus petite et capable de fournir un objectif commercial spécifique.

Prenons un exemple de portail d'achat en ligne pour comprendre le microservice en profondeur. Maintenant, divisons tout ce portail de commerce électronique en petites unités commerciales telles que la gestion des utilisateurs, la gestion des commandes, l'enregistrement, la gestion des paiements, la gestion des livraisons, etc. Une commande réussie doit passer par tous ces modules dans un délai spécifique Cadre. Voici l'image consolidée des différentes unités commerciales associées à un système de commerce électronique.

Chacun de ces modules métier doit avoir sa propre logique métier et ses propres parties prenantes. Ils communiquent avec d'autres logiciels tiers pour certains besoins spécifiques, ainsi qu'entre eux. Par exemple, la gestion des commandes peut communiquer avec la gestion des utilisateurs pour obtenir des informations sur les utilisateurs.

Maintenant, étant donné que vous exécutez un portail d'achat en ligne avec toutes ces unités commerciales mentionnées précédemment, vous avez besoin d'une application de niveau entreprise composée de différentes couches telles que front-end, back-end, base de données, etc. Si votre application n'est pas mise à l'échelle et complètement développé dans un seul fichier de guerre, il sera alors appelé comme une application monolithique typique. Selon IBM, une application monolithique typique doit posséder la structure de module suivante en interne où un seul point de terminaison ou application sera responsable de traiter toutes les demandes des utilisateurs.

Dans l'image ci-dessus, vous pouvez voir différents modules tels que Base de données pour stocker différents utilisateurs et données d'entreprise. Sur le front-end, nous avons différents appareils sur lesquels nous restituons généralement les données utilisateur ou commerciales à utiliser. Au milieu, nous avons un package qui peut être un fichier EAR ou WAR déployable qui accepte la demande de la fin des utilisateurs, le traite à l'aide des ressources et le restitue aux utilisateurs. Tout ira bien jusqu'à ce que les entreprises souhaitent des modifications dans l'exemple ci-dessus.

Considérez les scénarios suivants dans lesquels vous devez modifier votre application en fonction des besoins de l'entreprise.

L'unité commerciale a besoin de quelques modifications dans le module «Recherche». Ensuite, vous devez modifier l'ensemble du processus de recherche et redéployer votre application. Dans ce cas, vous redéployez vos autres unités sans aucun changement.

Maintenant encore, votre unité commerciale a besoin de quelques modifications dans le module «Vérifier» pour inclure l'option «portefeuille». Vous devez maintenant changer votre module «Check out» et le redéployer sur le serveur. Attention, vous redéployez les différents modules de vos progiciels, alors que nous n'y avons apporté aucune modification. Voici le concept d'architecture orientée services plus spécifique à l'architecture Microservice. Nous pouvons développer notre application monolithique de telle manière que chaque module du logiciel se comporte comme une unité indépendante, capable de gérer une seule tâche métier de manière indépendante.

Prenons l'exemple suivant.

Dans l'architecture ci-dessus, nous ne créons aucun fichier ear avec un service compact de bout en bout. Au lieu de cela, nous divisons différentes parties du logiciel en les exposant en tant que service. Toutes les parties du logiciel peuvent facilement communiquer entre elles en utilisant les services respectifs. C'est ainsi que le microservice joue un grand rôle dans les applications Web modernes.

Comparons notre exemple de panier dans la ligne de microservice. Nous pouvons décomposer notre panier dans les différents modules tels que «Recherche», «Filtre», «Paiement», «Panier», «Recommandation», etc. Si nous voulons créer un portail de panier d'achat, nous devons créer le modules mentionnés ci-dessus de manière à pouvoir se connecter les uns aux autres pour vous offrir une bonne expérience d'achat 24h / 24 et 7j / 7.

Avantages désavantages

Voici quelques points sur les avantages de l'utilisation de microservice au lieu d'utiliser une application monolithique.

Avantages

Small in size- Microservices est une implémentation du modèle de conception SOA. Il est recommandé de conserver votre service autant que vous le pouvez. Fondamentalement, un service ne doit pas effectuer plus d'une tâche commerciale, il sera donc évidemment de petite taille et facile à entretenir que toute autre application monolithique.
Focused- Comme mentionné précédemment, chaque microservice est conçu pour fournir une seule tâche métier. Lors de la conception d'un microservice, l'architecte doit se préoccuper du point focal du service, qui est son livrable. Par définition, un microservice doit être de nature full stack et doit s'engager à fournir une seule propriété commerciale.
Autonomous- Chaque microservice doit être une unité commerciale autonome de l'ensemble de l'application. Par conséquent, l'application devient plus faiblement couplée, ce qui contribue à réduire les coûts de maintenance.
Technology heterogeneity- Microservice prend en charge différentes technologies pour communiquer entre elles dans une seule unité commerciale, ce qui aide les développeurs à utiliser la bonne technologie au bon endroit. En mettant en œuvre un système hétérogène, on peut obtenir un maximum de sécurité, de rapidité et un système évolutif.
Resilience- La résilience est une propriété d'isolement d'une unité logicielle. Microservice suit un niveau élevé de résilience dans la méthodologie de construction, par conséquent, chaque fois qu'une unité tombe en panne, cela n'a pas d'impact sur l'ensemble de l'entreprise. La résilience est une autre propriété qui implémente un système hautement évolutif et moins couplé.
Ease of deployment- Comme l'application entière est sous-divisée en petits morceaux d'unités, chaque composant doit être de nature à pile complète. Tous peuvent être déployés dans n'importe quel environnement très facilement avec moins de complexité de temps contrairement aux autres applications monolithiques du même type.

Voici quelques points sur les inconvénients de l'architecture des microservices.

Désavantages

Distributed system- En raison de l'hétérogénéité technique, différentes technologies seront utilisées pour développer différentes parties d'un microservice. Un vaste ensemble de professionnels qualifiés est nécessaire pour prendre en charge ce grand logiciel distribué hétérogène. Par conséquent, la distribution et l'hétérogénéité constituent un inconvénient majeur de l'utilisation des microservices.
Cost - Le microservice est coûteux, car vous devez conserver un espace serveur différent pour différentes tâches métier.
Enterprise readiness- L'architecture des microservices peut être considérée comme un conglomérat de différentes technologies, car la technologie évolue de jour en jour. Par conséquent, il est assez difficile de rendre une entreprise d'application de microservices prête à être comparée au modèle de développement logiciel conventionnel.

Microservice sur SOA

Le tableau suivant répertorie certaines fonctionnalités de SOA et Microservice, soulignant l'importance de l'utilisation de microservice sur SOA.

Composant	SOA	Microservice
Design pattern	SOA est un paradigme de conception pour les logiciels informatiques, où les composants logiciels sont exposés au monde extérieur pour être utilisés sous la forme de services.	Micro Service fait partie de SOA. Il s'agit d'une implémentation spécialisée de SOA.
Dépendance	Les unités commerciales dépendent les unes des autres.	Toutes les unités commerciales sont indépendantes les unes des autres.
Taille	La taille du logiciel est plus grande que le logiciel conventionnel.	La taille du logiciel est petite.
La technologie	La pile technologique est inférieure à Microservice.	Le microservice est de nature hétérogène car des technologies exactes sont utilisées pour effectuer une tâche spécifique. Les microservices peuvent être considérés comme un conglomérat de nombreuses technologies.
Autonome et concentré	Les applications SOA sont conçues pour effectuer plusieurs tâches métier.	Les applications de microservices sont conçues pour effectuer une seule tâche métier.
La nature	De nature monolithique.	Pile complète dans la nature.
Déploiement	Le déploiement prend du temps.	Le déploiement est très simple. Par conséquent, cela prendra moins de temps.
Rentabilité	Plus rentable.	Moins rentable.
Évolutivité	Moins que les microservices.	Entièrement mis à l'échelle.
Exemple	Considérons une application de réservation CAB en ligne. Si nous voulons construire cette application en utilisant SOA, alors ses unités logicielles seront - GetPayments And DriverInformation and MappingDataAPI AuthenticateUsersAnd DriversAPI	Si la même application est construite à l'aide d'une architecture de microservice, ses API seront - SubmitPaymentsService GetDriverInfoService GetMappingDataService AuthenticateUserService AuthenticateDriverService

La mise à l'échelle est un processus de décomposition d'un logiciel en différentes unités. La mise à l'échelle définit également en termes d'évolutivité. L'évolutivité est la possibilité d'implémenter des fonctionnalités plus avancées de l'application. Il contribue à améliorer la sécurité, la durabilité et la maintenabilité de l'application. Nous avons trois types de procédures de mise à l'échelle qui sont suivies dans les industries. Vous trouverez ci-dessous les différentes méthodologies de mise à l'échelle ainsi que les exemples réels correspondants.

Mise à l'échelle de l'axe X

La mise à l'échelle de l'axe X est également appelée mise à l'échelle horizontale. Dans cette procédure, l'ensemble de la demande est subdivisé en différentes parties horizontales. Normalement, n'importe quelle application de serveur Web peut avoir ce type de mise à l'échelle. Considérez une architecture MVC normale qui suit la mise à l'échelle horizontale, comme illustré dans la figure suivante.

À titre d'exemple, nous pouvons considérer n'importe quelle application de servlet JSP. Dans cette application, le contrôleur contrôle chaque demande et génère une vue en communiquant avec le modèle chaque fois que nécessaire. Normalement, les applications monolithiques suivent cette méthode de mise à l'échelle. La mise à l'échelle de l'axe X est de nature très basique et prend beaucoup moins de temps. Dans cette méthodologie, un logiciel sera mis à l'échelle en fonction de ses différentes tâches dont l'unité est responsable. Par exemple, le contrôleur est responsable du contrôle de la demande entrante et sortante, la vue est chargée de représenter la fonctionnalité commerciale aux utilisateurs dans le navigateur, tandis que le modèle est responsable de stocker nos données et fonctionne comme base de données.

Mise à l'échelle de l'axe Y

La mise à l'échelle de l'axe Y est également appelée mise à l'échelle verticale qui inclut toute mise à l'échelle au niveau des ressources. Tout système DBaaS ou Hadoop peut être considéré comme mis à l'échelle sur l'axe Y. Dans ce type de mise à l'échelle, la demande des utilisateurs est redirigée et restreinte en implémentant une logique.

Prenons Facebook comme exemple. Facebook doit gérer 1,79 million d'utilisateurs par seconde; Par conséquent, contrôler le trafic est une énorme responsabilité des ingénieurs réseau de Facebook. Pour surmonter tout danger, ils suivent la mise à l'échelle de l'axe Y qui comprend l'exécution de plusieurs serveurs avec la même application en même temps. Désormais, afin de contrôler cet énorme niveau de trafic, Facebook redirige tout le trafic d'une région vers un serveur spécifique, comme le montre l'image. Ce transfert de trafic basé sur la région est appelé équilibrage de charge en langage architectural.

Cette méthode de décomposition des ressources en petites unités commerciales indépendantes est appelée mise à l'échelle de l'axe Y.

Mise à l'échelle de l'axe Z

La mise à l'échelle des axes X et Y est plus facile à comprendre. Cependant, une application peut également être mise à l'échelle au niveau de l'entreprise, ce qui est appelé mise à l'échelle de l'axe Z. Voici un exemple de mise à l'échelle d'une application de service de cabine dans les différents secteurs verticaux des unités commerciales.

Avantages de la mise à l'échelle

Cost - Une mise à l'échelle appropriée d'un logiciel réduira les coûts de maintenance.
Performance - En raison d'un couplage lâche, les performances d'un logiciel correctement dimensionné sont toujours meilleures que celles d'un logiciel non dimensionné.
Load distribution - En utilisant différentes technologies, nous pouvons facilement maintenir la charge de notre serveur.
Reuse - L'évolutivité d'un logiciel augmente également la convivialité du logiciel.

Microservice implémente SOA en interne. Dans un sens plus large, nous pouvons le considérer comme un sous-ensemble d'une application SOA.

Règle et flux de travail

Voici les principes à prendre en compte lors du développement d'un microservice.

High Cohesion- Tous les modèles commerciaux doivent être subdivisés dans la plus petite partie des affaires autant que possible. Chaque service doit être axé sur une seule tâche commerciale.
Independent - Tous les services doivent être de nature complète et indépendants les uns des autres.
Business Domain Centric - Le logiciel se modularise en fonction de l'unité commerciale et n'est pas basé sur les niveaux.
Automation- Le déploiement des tests sera automatisé. Essayez d'introduire une interaction humaine minimale.
Observable - Chaque service sera de nature complète et devra être déployable et observable indépendamment comme une application d'entreprise.

Gestion d'équipe

«Two Pizza Rule» est une sorte de règle qui limite le nombre de participants dans une équipe de développement de microservices. Selon cette règle, le nombre de membres de l'équipe d'une application doit être si petit qu'ils peuvent être nourris par deux pizzas. En général, le nombre ne doit pas être supérieur à 8. Comme le microservice est de nature full stack, l'équipe est également full stack par nature. Pour augmenter la productivité, nous devons constituer une équipe de 8 membres maximum avec toutes les compétences requises pour ce service.

La gestion des tâches

La tâche est un rôle important dans le cycle de vie du développement logiciel. Le développement d'une application à grande échelle peut être divisé en plusieurs petites unités de tâche. Considérons que nous devons développer une application telle que Facebook. Ensuite, la fonctionnalité «Connexion» peut être considérée comme une tâche de l'ensemble du processus de construction. Les progrès de chacune de ces tâches doivent être correctement surveillés par des professionnels hautement qualifiés. Agile est la structure de processus bien connue suivie dans les industries pour suivre une bonne gestion des tâches.

Jusqu'à présent, nous avons appris ce qu'est Microservice et quels en sont les besoins de base au-dessus de l'architecture MVC moderne. Dans ce chapitre, nous allons apprendre les différents éléments de cette architecture qui sont également importants pour un service.

Catégories de services

Par le nom de Microservice, nous supposons qu'il s'agira d'un service qui peut être consommé via des protocoles HTTP, mais nous devons savoir quel type de services peut être construit en utilisant cette architecture. Voici la liste des services qui peuvent être implémentés à l'aide de l'architecture Microservice.

Platform as a Service [PaaS]- Dans cette architecture orientée services, la plateforme est donnée comme un outil personnalisable en fonction des besoins métiers. Le PaaS joue un rôle important dans le développement d'applications mobiles. Le meilleur exemple de PaaS est le moteur Google App, où Google fournit différentes plates-formes utiles pour créer votre application. PaaS se développe à l'origine pour fournir une architecture ou une infrastructure intégrée aux développeurs. Il réduit la complexité de la programmation de niveau supérieur en un temps considérablement réduit. Voici un aperçu du PaaS fourni par Google.

Software as a Service [SaaS]- Le logiciel en tant que service est une entreprise de licence de logiciel, où le logiciel est hébergé de manière centralisée et concédé sous licence sur la base d'un abonnement. Le SaaS est accessible principalement via le navigateur et il s'agit d'un modèle d'architecture très courant dans de nombreux secteurs d'activité tels que la gestion des ressources humaines (HRM), la planification des ressources d'entreprise (ERP), la gestion de la relation client (CRM), etc. La capture d'écran suivante montre des exemples de différents SaaS fournis par Oracle.

Infrastructure as a Service [IaaS]- L'infrastructure joue un bon rôle dans les industries informatiques. En utilisant le cloud computing, certaines organisations fournissent une infrastructure virtuelle comme leurs services. L'IaaS est très utile pour apporter agilité, rentabilité, sécurité, performance, productivité, etc. dans le développement de logiciels. Amazon EC2 et Microsoft Azure sont les plus grands exemples d'IaaS. L'image suivante illustre un exemple d'AWS, où le centre de données est fourni en tant qu'IaaS.

Data as a Service [DaaS]- La technologie de l'information traite des données et certains des plus grands leaders de l'industrie estiment que les données seront le nouveau soutien de la société. DaaS est un type de service où les données sont partagées avec des conglomérats d'entreprises à des fins de recherche et d'analyse. DaaS apporte simplicité, agilité et sécurité dans la couche d'accès aux données. Voici un exemple d'Oracle Data cloud, auquel vous pouvez accéder ou sous licence pour vos propres besoins professionnels.

Back End as a Service [BaaS]- BaaS est également connu sous le nom de MBaaS, ce qui signifie back-end mobile en tant que service. Dans ce type de service, le backend de l'application sera fourni aux unités commerciales pour leurs propres entreprises. Toutes les notifications push, les services de réseaux sociaux relèvent de ce type de services. Facebook et Twitter sont des exemples de fournisseurs de services BaaS bien connus.

Sécurité

Lorsqu'il s'agit de traiter des tonnes de données clients, la sécurité joue un rôle important. Le problème de sécurité est associé à toutes sortes de services disponibles sur le marché. Quel que soit le cloud que vous utilisez - privé, public, hybride, etc., la sécurité doit être maintenue à tous les niveaux. L'ensemble du problème de sécurité peut être globalement subdivisé en les parties suivantes -

Security issue faced by service providers - Ce type de problème de sécurité est rencontré par les fournisseurs de services tels que Google, Amazon, etc. Pour assurer la protection de la sécurité, la vérification des antécédents du client est nécessaire en particulier de ceux qui ont un accès direct au cœur du cloud.
Security issue faced by consumers- Le cloud est économique, il est donc largement utilisé dans tous les secteurs. Certaines organisations stockent les détails de l'utilisateur dans des centres de données tiers et extraient les données chaque fois que nécessaire. Par conséquent, il est obligatoire de maintenir des niveaux de sécurité tels que les données privées d'un client ne doivent être visibles par aucun autre utilisateur.

Pour éviter les problèmes de sécurité mentionnés ci-dessus, voici quelques-uns des mécanismes défensifs utilisés par les organisations.

Deterrent Control - Connaissez votre menace potentielle pour réduire les cyberattaques.
Preventive Control - Maintenez une politique d'authentification de haut niveau pour accéder à votre cloud.
Detective Control - Surveillez vos utilisateurs et détectez tout risque potentiel.
Corrective Control - Travailler en étroite collaboration avec différentes équipes et résoudre les problèmes qui surviennent lors de la phase de contrôle des détectives.

La composition logicielle désigne la manière de créer votre produit logiciel. Fondamentalement, il s'agit d'un diagramme d'architecture logicielle de haut niveau dans lequel différents modules de votre logiciel communiqueront pour des objectifs commerciaux spécifiques. Dans ce chapitre, nous découvrirons les différents modèles de composition logicielle largement utilisés dans les organisations. Dans le microservice, nous divisons chaque fonction en un seul processus. Chacun de ces services sera indépendant et de nature complète.

La décomposition fonctionnelle joue un rôle important dans la création de vos microservices. Il offre agilité, flexibilité et évolutivité à votre application.

Modèle d'agrégateur

Le modèle d'agrégateur est le modèle Web le plus simple pouvant être implémenté lors du développement d'un microservice. Dans ce modèle de composition, un simple module Web agira comme un équilibreur de charge, ce qui signifie qu'il appellera différents services selon les besoins. Voici un diagramme illustrant une application Web de microservice simple avec une conception d'agrégateur. Comme le montre l'image suivante, «l'agrégateur» est chargé d'appeler les différents services un par un. Si nous devons appliquer une logique métier sur les résultats du service A, B et C, nous pouvons implémenter la logique métier dans l'agrégateur lui-même.

Un agrégateur peut à nouveau être exposé comme un autre service au monde extérieur, qui peut être consommé par d'autres en cas de besoin. Lors du développement du service Web de modèle d'agrégateur, nous devons garder à l'esprit que chacun de nos services A, B et C doit avoir ses propres couches de mise en cache et qu'il doit être de nature complète.

Modèle de proxy

Le modèle de microservice proxy est une variante du modèle d'agrégateur. Dans ce modèle, nous utiliserons le module proxy au lieu du module d'agrégation. Le service proxy peut appeler différents services individuellement.

Dans le modèle Proxy, nous pouvons créer un niveau de sécurité supplémentaire en fournissant une couche proxy de vidage. Cette couche agit de manière similaire à l'interface.

Motif enchaîné

Comme son nom l'indique, ce type de modèle de composition suivra la structure en chaîne. Ici, nous n'utiliserons rien entre les couches client et service. Au lieu de cela, nous autoriserons le client à communiquer directement avec les services et tous les services seront enchaînés de telle manière que la sortie d'un service sera l'entrée du service suivant. L'image suivante montre un microservice de modèle chaîné typique.

Un inconvénient majeur de cette architecture est que le client sera bloqué jusqu'à ce que l'ensemble du processus soit terminé. Ainsi, il est fortement recommandé de garder la longueur de la chaîne aussi courte que possible.

Modèle de microservice de branche

Le microservice de branche est la version étendue du modèle d'agrégateur et du modèle de chaîne. Dans ce modèle de conception, le client peut communiquer directement avec le service. En outre, un service peut communiquer avec plusieurs services à la fois. Voici la représentation schématique de Branch Microservice.

Le modèle de microservice de branche permet au développeur de configurer dynamiquement les appels de service. Tous les appels de service se produiront de manière simultanée, ce qui signifie que le service A peut appeler les services B et C simultanément.

Modèle de ressource partagée

Le modèle de ressources partagées est en fait un conglomérat de tous les types de modèles mentionnés précédemment. Dans ce modèle, le client ou l'équilibreur de charge communiquera directement avec chaque service chaque fois que nécessaire. Il s'agit du modèle de conception le plus efficace largement suivi dans la plupart des organisations. Voici une représentation schématique du modèle de conception de ressources partagées.

Dans ce chapitre, nous développerons une application basée sur CRUD avec une architecture SOA. Plus tard dans les chapitres suivants, nous décomposerons ce service en microservice et nous apprendrons la différence fondamentale entre l'architecture SOA et microservice.

Configuration et installation du système

Dans cette section, nous allons créer un exemple d'application CRUD, qui renverra un objet JSON en tant que réponse chaque fois que nous appelons notre service. Nous utiliserons le framework Jersey pour développer le même. Voici les étapes de configuration de votre environnement système local.

Développement d'une application CRUD

Step 1- Nous utiliserons NetBeans comme IDE de développement. Veuillez télécharger et installer la dernière version disponible sur le site officiel de NetBeanshttps://netbeans.org/downloads/.

Step 2- Ouvrez votre IDE NetBeans. Allez dans «Fichier -> Nouveau projet». La capture d'écran suivante apparaît. Choisissez «Maven» comme catégorie et sélectionnez «Projet d'ArchType» comme projet et cliquez sur Suivant.

Cela téléchargera tous les fichiers jar requis pour créer votre tout premier projet Maven et service Web RESTful.

Step 3- En appuyant sur le bouton Suivant à l'étape précédente, la capture d'écran suivante apparaît. Ici, vous devrez spécifier l'archétype Maven.

Dans la zone de recherche, recherchez «Jersey-archType-Webapp (2.16)» et cochez la case «Afficher les anciens».

Step 4- Une fois que vous avez sélectionné la même chose, vous serez redirigé vers l'écran suivant. Sélectionnez le pot préféré dans la liste et appuyez sur Suivant pour continuer.

Step 5- Dans cette étape, vous devez fournir le nom de votre projet et son identifiant de groupe ainsi que les détails du package. Après avoir fourni toutes ces informations, appuyez sur Terminer pour continuer.

Step 6- Vous avez terminé la configuration de votre espace de travail. Le répertoire du projet ressemblera à ce qui suit.

Consultez votre dossier «Dépendances» et vous constaterez que Maven a automatiquement téléchargé tous les fichiers jar requis pour ce projet.

Step 7- Votre espace de travail est configuré et vous pouvez commencer par le codage. Allez-y et créez quatre classes et packages comme indiqué dans la capture d'écran suivante. Vous pouvez constater que MyResource.java est déjà créé par Maven, car Maven est suffisamment intelligent pour détecter que vous allez créer votre propre service Web.

Step 8 - Une fois l'étape ci-dessus terminée, nous allons construire notre classe POJO qui est UserProfile.java comme suit.

package com.tutorialspoint.userprofile.Model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class UserProfile {
   private long ProId;
   private String FName;
   private String LName;
   private String Add;
   public UserProfile(){}
   
   public UserProfile(long Proid, String Fname, String Lname,String Add) {
      this.ProId = Proid;
      this.FName = Fname;
      this.LName = Lname;
      this.Add = Add;
   }
   public long getProId() {
      return ProId;
   }
   public void setProId(long ProId) {
      this.ProId = ProId;
   }
   public String getFName() {
      return FName;
   }
   public void setFName(String FName) {
      this.FName = FName;
   }
   public String getLName() {
      return LName;
   }
   public void setLName(String LName) {
      this.LName = LName;
   }
   public String getAdd() {
      return Add;
   }
   public void setAdd(String Add) {
      this.Add = Add;
   }
}

Step 9- Nous allons maintenant créer notre classe Database. Comme cela fait partie du matériel d'apprentissage, nous n'utiliserons aucune base de données comme base de données. Nous utiliserons une mémoire Java intégrée pour fonctionner comme mémoire temporaire. Comme vous pouvez le voir dans l'ensemble de code suivant, nous utiliserons MAP comme base de données. Toutes les opérations de service Web que nous effectuons, nous travaillerons sur cette MAP définie dans la classe.

package com.tutorialspoint.userprofile.DAO;

import com.tutorialspoint.userprofile.Model.UserProfile;

import java.util.HashMap;
import java.util.Map;

public class DatabaseClass {
   private static Map<Long,UserProfile> messages = new HashMap<Long,UserProfile>();
   public static Map<Long,UserProfile> getUsers() {
      return messages; 
      // Each time this method will return entire map as an instance of database
   }
}

Step 10- Construisons maintenant notre classe de service. Allez-y et copiez-collez l'ensemble de code suivant dans la classe «ProfileService.java». C'est la classe dans laquelle nous déclarerons toutes nos méthodes de service Web qui doivent être exposées pour le monde extérieur. Nous devons créer une référence de notre DatabaseClass afin que notre base de données temporaire soit accessible dans cette classe.

package com.tutorialspoint.userprofile.service;

import com.tutorialspoint.userprofile.DAO.DatabaseClass;
import com.tutorialspoint.userprofile.Model.UserProfile;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class ProfileService {
   private Map<Long,UserProfile> Userprofiles = DatabaseClass.getUsers();
   
   // Creating some predefine profile and populating the same in the map
   public ProfileService() {
      UserProfile m1 = new UserProfile(1L,"Tutorials1","Point1","TutorialsPoint.com");
      UserProfile m2 = new UserProfile(2L,"Tutorials2","Point2","TutorialsPoint.com2");
      UserProfile m3 = new UserProfile(3L,"Tutorials3","Point3","TutorialsPoint.com3");
      UserProfile m4 = new UserProfile(4L,"Tutorials4","Point4","TutorialsPoint.com4");
      
      Userprofiles.put(1L, m1);
      Userprofiles.put(2L, m2);
      Userprofiles.put(1L, m3);
      Userprofiles.put(2L, m4);
   }
   
   //Method to fetch all profile
   public List<UserProfile> getAllProfile() {
      List<UserProfile> list = new ArrayList<UserProfile>(Userprofiles.values());
      return list;
   }  // Method to fetch only one profile depending on the ID provided
   
   public UserProfile getProfile(long id) {
      return Userprofiles.get(id);
   }  //Method to add profile
   
   public UserProfile addProfile(UserProfile UserProfile) {
      UserProfile.setProId(Userprofiles.size()+1);
      Userprofiles.put(UserProfile.getProId(), UserProfile);
      return UserProfile;
   }  //method to update Profile

   public UserProfile UpdateProfile(UserProfile UserProfile) {
      if(UserProfile.getProId()<=0) { 
         return null;
      } else { 
         Userprofiles.put(UserProfile.getProId(), UserProfile);
         return UserProfile;
      }
   } //method to delete profile
   
   public void RemoveProfile(long Id) {
      Userprofiles.remove(Id);
   }
}

Step 11 - Dans cette étape, nous allons créer notre classe Resource qui sera liée à l'URL et le service correspondant sera appelé.

package com.tutorialspoint.userprofile.Resource;

import com.tutorialspoint.userprofile.Model.UserProfile;
import com.tutorialspoint.userprofile.service.ProfileService;

import java.util.List;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/Profile")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)

public class ProfileResource {
   ProfileService messageService = new ProfileService();
   
   @GET
   public List<UserProfile> getProfile() {
      return messageService.getAllProfile();
   }

   @GET
   @Path("/{ProID}")
   public UserProfile getProfile(@PathParam("ProID")long Id) {
      return messageService.getProfile(Id);
   }

   @POST
   public UserProfile addProfile(UserProfile profile) {
      return messageService.addProfile(profile);
   }

   @PUT
   @Path("/{proID}")
   public UserProfile UpdateProfile(@PathParam("proID")long Id,UserProfile UserProfile) {
      UserProfile.setProId(Id);
      return messageService.UpdateProfile(UserProfile);
   }
   
   @DELETE
   @Path("/{ProID}")
   public void deleteProfile(@PathParam("ProID")long Id) {
      messageService.RemoveProfile(Id);
   }
}

Step 12- Nettoyez le projet et exécutez-le. Si tout se passe bien, vous devriez obtenir la sortie suivante dans le navigateur, tout en accédanthttp://localhost:8080/UserProfile/webapi/Profile” URL.

Vous pouvez voir que différentes entrées sont remplies à l'aide d'une représentation XML.

Différentes méthodes peuvent être testées à l'aide de Postman en appliquant une URL de méthode appropriée.

@GET method - La capture d'écran suivante montre comment nous pouvons obtenir le résultat souhaité pour get request, qui renvoie tous les détails de l'utilisateur.

@POST- La requête suivante peut être utilisée pour tester notre méthode Post. Remarquez comment le proId a été généré automatiquement.

@PUT- Cette méthode mettra à jour les entrées. La capture d'écran suivante montre comment Jersey prend le proId de l'URL de la demande et met à jour la même réponse de profil utilisateur.

De la même manière, vous pouvez rechercher d'autres méthodes disponibles dans vos services Web.

Dans la section précédente, nous avons développé un service qui exposera la fonctionnalité CRUD. Désormais, chaque fois que nous essayons d'implémenter ce service dans notre application, nous devons créer un client de cette application et le joindre à notre application. Dans ce chapitre, nous allons apprendre à construire cette fonctionnalité en utilisant le concept de Microservice. Voici une représentation schématique de notre application créée à l'aide des étapes ci-dessus.

L'acteur doit être le point d'entrée de notre service. Dans ce cas, «ProfileResource.java» assume la responsabilité d'un acteur. Cette classe appellera différentes méthodes pour effectuer différentes opérations telles que l'ajout, la mise à jour et la suppression.

Décomposition de l'application CRUD

Selon le principe de base du microservice, nous n'avons besoin que d'une seule tâche métier pour chacun des modules, par conséquent un acteur ne doit pas être responsable des quatre fonctionnalités CRUD. Prenons l'exemple suivant, dans lequel nous avons introduit de nouveaux rôles de telle sorte qu'il sera conceptuellement clair pour vous que Microservice est une représentation architecturale de SOA.

«L'utilisateur principal» est l'utilisateur qui communique avec le «contrôleur d'application» pour répondre à ses besoins. Le «contrôleur d'application» est celui qui appelle simplement différents «gestionnaires de ressources» en fonction de la demande de l'utilisateur final. «Resource Manager» fait le travail qui doit être fait. Jetons un coup d'œil sur les différents rôles des différentes unités de l'application.

End User/Main Users - Demandes de certaines ressources à Application Controller.
Application - Reçoit la demande et la transmet à un gestionnaire de ressources spécifique.
Resource Manager - Effectue le travail réel de mise à jour, de suppression et d'ajout d'utilisateurs.

Voyez comment la responsabilité totale d'une classe est répartie entre différentes autres classes.

Dans ce chapitre, nous allons créer une application de microservice qui consommera différents services disponibles. Nous savons tous que le microservice n'est pas un moyen rentable de créer une application, car chaque service que nous construisons sera de nature complète. La création d'un microservice dans l'environnement local nécessiterait une configuration système haut de gamme, car vous devez disposer de quatre instances d'un serveur pour continuer à fonctionner de manière à pouvoir être consommé à un moment donné. Pour créer notre tout premier microservice, nous utiliserons certains des points de terminaison SOA disponibles et nous utiliserons la même chose dans notre application.

Configuration et installation du système

Avant d'aller plus loin dans la phase de construction, préparez votre système en conséquence. Vous auriez besoin de certains services Web publics. Vous pouvez facilement google pour cela. Si vous souhaitez utiliser le service Web SOAP, vous obtiendrez un fichier WSDL et à partir de là, vous devrez utiliser le service Web spécifique. Pour le service REST, vous n'aurez besoin que d'un seul lien pour consommer le même. Dans cet exemple, vous allez brouiller trois services Web différents «SOAP», «REST» et «personnalisé» dans une seule application.

Architecture d'application

Vous allez créer une application Java à l'aide du plan d'implémentation de microservice. Vous allez créer un service personnalisé et la sortie de ce service fonctionnera comme une entrée pour d'autres services.

Voici les étapes à suivre pour développer une application de microservice.

Step 1: Client creation for SOAP service- Il existe de nombreuses API Web gratuites pour apprendre un service Web. Pour les besoins de ce tutoriel, utilisez le service GeoIP de "http://www.webservicex.net/.”Le fichier WSDL est fourni dans le lien suivant sur leur site Web « webservicex.net. Pour générer le client à partir de ce fichier WSDL, il vous suffit d'exécuter la commande suivante dans votre terminal.

wsimport http://www.webservicex.net/geoipservice.asmx?WSDL

Cette commande générera tous les fichiers client requis dans un dossier nommé «SEI», qui porte le nom de l'interface du point de terminaison du service.

Step 2: Create your custom web service- Suivez le même processus mentionné à une étape précédente dans ce didacticiel et créez une API REST basée sur Maven nommée «CustomRest». Une fois terminé, vous trouverez une classe nommée «MyResource.java». Allez-y et mettez à jour cette classe en utilisant le code suivant.

package com.tutorialspoint.customrest;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("myresource")
public class MyResource {
   @GET
   @Produces(MediaType.TEXT_PLAIN)
   
   public String getIt() {
      return "IND|INDIA|27.7.65.215";
   }
}

Une fois que tout est terminé, lancez cette application sur le serveur. Vous devriez obtenir la sortie suivante dans le navigateur.

Il s'agit du serveur Web, qui renvoie un objet chaîne une fois qu'il est appelé. Il s'agit du service d'entrée qui fournit des entrées pouvant être utilisées par une autre application pour générer des enregistrements.

Step 3: Configure another Rest API- Dans cette étape, utilisez un autre service Web disponible sur services.groupkt.com. Cela renverra un objet JSON lorsqu'il est appelé.

Step 4: Create JAVA application - Créez une application Java normale en sélectionnant «Nouveau projet» -> «Projet JAVA» et appuyez sur Terminer comme indiqué dans la capture d'écran suivante.

Step 5: Add the SOAP client- À l'étape 1, vous avez créé le fichier client pour le service Web SOAP. Allez-y et ajoutez ces fichiers client à votre projet actuel. Une fois l'ajout réussi des fichiers client, le répertoire de votre application ressemblera à ce qui suit.

Step 6: Create your main app- Créez votre classe principale où vous utiliserez tous ces trois services Web. Cliquez avec le bouton droit sur le projet source et créez une nouvelle classe nommée «MicroServiceInAction.java». La tâche suivante consiste à appeler différents services Web à partir de cela.

Step 7: Call your custom web service - Pour cela, allez-y et ajoutez l'ensemble de codes suivant pour implémenter l'appel de votre propre service.

try {
   url = new URL("http://localhost:8080/CustomRest/webapi/myresource");
   conn = (HttpURLConnection) url.openConnection();
   conn.setRequestMethod("GET");
   conn.setRequestProperty("Accept", "application/json");
   
   if (conn.getResponseCode() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
   }
   
   BufferedReader br = new BufferedReader(new InputStreamReader(
      (conn.getInputStream())));
   while ((output = br.readLine()) != null) {
      inputToOtherService = output;
   }
   conn.disconnect();

} catch (MalformedURLException e) {
   e.printStackTrace();
} catch (IOException e) {
   e.printStackTrace();
}

Step 8: Consume SOAP Services- Vous avez généré votre fichier client mais vous ne savez pas quelle méthode doit être appelée dans tout ce package? Pour cela, vous devez vous référer à nouveau au WSDL, que vous avez utilisé pour générer vos fichiers client. Chaque fichier WSDL doit avoir une recherche de balise «wsdl: service» pour cette balise. Cela devrait être votre point d'entrée de ce service Web. Voici le point de terminaison de service de cette application.

Vous devez maintenant implémenter ce service dans votre application. Voici l'ensemble de code Java dont vous avez besoin pour implémenter votre service Web SOAP.

GeoIPService newGeoIPService = new GeoIPService();
GeoIPServiceSoap newGeoIPServiceSoap = newGeoIPService.getGeoIPServiceSoap();
GeoIP newGeoIP = newGeoIPServiceSoap.getGeoIP(Ipaddress);  
// Ipaddress is output of our own web service.

System.out.println("Country Name from SOAP Webserivce ---"+newGeoIP.getCountryName());

Step 9: Consume REST web service- Deux des services ont été consommés jusqu'à présent. Au cours de cette étape, un autre service Web REST avec une URL personnalisée sera utilisé à l'aide de votre service Web personnalisé. Utilisez l'ensemble de code suivant pour ce faire.

String url1="http://services.groupkt.com/country/get/iso3code/";//customizing the Url
url1 = url1.concat(countryCode);

try {
   URL url = new URL(url1);
   HttpURLConnection conn = (HttpURLConnection) url.openConnection();
   conn.setRequestMethod("GET");
   conn.setRequestProperty("Accept", "application/json");
   
   if (conn.getResponseCode() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
   }
   
   BufferedReader br = new BufferedReader(new InputStreamReader(
      (conn.getInputStream())));
   while ((output = br.readLine()) != null) {
      System.out.println(output);
   }
   conn.disconnect();

} catch (MalformedURLException e) {
   e.printStackTrace();
} catch (IOException e) {
   e.printStackTrace();
}

Step 10: Consume all services - Étant donné que votre service Web «CustomRest» est en cours d'exécution et que vous êtes connecté à Internet, si tout est terminé avec succès, ce qui suit devrait être votre classe principale consolidée.

package microserviceinaction;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.StringTokenizer;

import net.webservicex.GeoIP;
import net.webservicex.GeoIPService;
import net.webservicex.GeoIPServiceSoap;

public class MicroServiceInAction {
   static URL url;
   static HttpURLConnection conn;
   static String output;
   static String inputToOtherService;
   static String countryCode;
   static String ipAddress;
   static String CountryName;
   public static void main(String[] args) {
      //consuming of your own web service
      try {
         url = new URL("http://localhost:8080/CustomRest/webapi/myresource");
         conn = (HttpURLConnection) url.openConnection();
         conn.setRequestMethod("GET");
         conn.setRequestProperty("Accept", "application/json");
         
         if (conn.getResponseCode() != 200) {
            throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
         }
         
         BufferedReader br = new BufferedReader(new InputStreamReader(
            (conn.getInputStream())));
         while ((output = br.readLine()) != null) {
            inputToOtherService = output;
         }
         conn.disconnect();
      
      } catch (MalformedURLException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
      
      //Fetching IP address from the String and other information
      StringTokenizer st = new StringTokenizer(inputToOtherService);
      countryCode = st.nextToken("|");
      CountryName = st.nextToken("|");
      ipAddress = st.nextToken("|");
      
      // Call to SOAP web service with output of your web service--- 
      // getting the location of our given IP address
      String Ipaddress = ipAddress;
      GeoIPService newGeoIPService = new GeoIPService();
      GeoIPServiceSoap newGeoIPServiceSoap = newGeoIPService.getGeoIPServiceSoap();
      GeoIP newGeoIP = newGeoIPServiceSoap.getGeoIP(Ipaddress);
      System.out.println("Country Name from SOAP Webservice ---"+newGeoIP.getCountryName());
      
      // Call to REST API --to get all the details of our country
      String url1 = "http://services.groupkt.com/country/get/iso3code/"; //customizing the Url
      url1 = url1.concat(countryCode);
      
      try {
         URL url = new URL(url1);
         HttpURLConnection conn = (HttpURLConnection) url.openConnection();
         conn.setRequestMethod("GET");
         conn.setRequestProperty("Accept", "application/json");
			
         if (conn.getResponseCode() != 200) {
            throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
         }
      
         BufferedReader br = new BufferedReader(new InputStreamReader(
            (conn.getInputStream())));
         while ((output = br.readLine()) != null) {
            System.out.println(output);
         }
      
         conn.disconnect();
      } catch (MalformedURLException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Une fois que vous exécutez ce fichier, vous verrez la sortie suivante dans la console. Vous avez développé avec succès votre première application de microservice.