Fermer

février 29, 2024

Tutoriel 4 – Microservices – Client Discovery, Client LoadBalancer et Client Feign. / Blogues

Tutoriel 4 – Microservices – Client Discovery, Client LoadBalancer et Client Feign. / Blogues


Lisez les autres blogs de cette série :

Dans l’environnement Eureka Server, 3 types de « Composant Client » sont possibles :

  1. Composant client de découverte (Héritage, pas de prise en charge de l’équilibrage de charge).
  2. Composant client Load Balancer (bon, effectuer l’équilibrage de charge).
  3. Composant client Feign (meilleur, prise en charge de toutes les approches et équilibrage de charge).

Client de découverte

Limites du composant client de type Discovery Client : –

  • Nous recevons une liste d’instances de microservices cibles, parmi lesquelles nous devons en sélectionner une manuellement. Cependant, nous souhaitons une instance du microservice cible (microservice producteur) qui ait un facteur de charge inférieur. [Load balancing is not feasible].
  • Ce composant client de base, souvent appelé composant de type client, est en grande partie un héritage. c’est-à-dire qu’il ne répond pas aux normes de l’industrie.
  • La collecte d’une instance dans la liste des instances relève de la seule responsabilité de l’application client, qui est un processus manuel. Ainsi, d’autres instances de la cible peuvent rester inactives.

Pour résoudre ces problèmes, utilisez le «LoadBalancerClient» tapez composant client.

Contrôleur de microservice producteur : –
package com.boot.versioning;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(name = "/billing/api")
public class BillingInfoController {
    
    public ResponseEntity<String> fetchBillingDetails(){
        
        // Returning dummy data.
        return new ResponseEntity<String>("Final billAmount = billAmount - discount (RS. 10000)",HttpStatus.OK);
    }

}
Client de microservice grand public : –
@Component
public class BillingServiceConsumerClient {
    
    private DiscoveryClient client;
    
    public String getBillingInfo() {
        
        //Get Billing-Service instance from Eureka Server
        List<ServiceInstance> listInstances = client.getInstances("Billing-Service");
        // Get single instance from list of instance (no load balancing)
        ServiceInstance instance = listInstance.get(0);
        // get details from Service Instance
        URI uri = instance.getUri();
        //prepare provider MS related url to consumer method
        String url = uri.toString()+"/billing/api/info";
        
        //create RestTemplate class obj to consume the provider service
        RestTemplate template = new RestTemplate();
        //consume the provider service
        ResponseEntity<String> response = template.getForEntity(url, String.class);
        //get responseContent from ResponseEntity object
        String responseContent = response.getBody();
        
        return responseContent;
    }

}

LoadBalancerClient

  • C’est un autre composant de type client. qui sélectionne l’instance ayant le facteur de charge le plus faible malgré le fait qu’il existe de nombreuses instances pour les microservices ciblés, c’est-à-dire que nous ne recevons jamais de liste d’instances même s’il existe plusieurs instances pour les microservices producteurs. Nous recevons toujours une instance du microservice producteur, qui a un faible facteur de charge.
  • Spring Cloud Netflix fournit une implémentation de l’interface « LoadBalancerClient » via la classe « RibbonLoadBalancerClient », qui peut être injectée dans l’application Consume à l’aide de la configuration automatique.
  • La méthode choisit (-) quel ID d’instance appelé sur le « LoadBalancerClient » L’objet apportera l’instance la moins chargée en facteur de charge du microservice cible.

Pour générer de nombreuses instances d’un microservice, exécutez l’application de microservice plusieurs fois avec différents numéros de port, car deux serveurs ou microservices sur le même ordinateur ne peuvent pas utiliser le même numéro de port, mais ils peuvent être partagés sur d’autres machines.

Exemple d’application utilisant le composant client de type LoadBalancerClient (communication intra microservice utilisant LoadBalancerClient)

1 : – Développer l’application Eureka Server.

2 : – Développer les microservices producteurs.

  • Étant donné que nous souhaitons exécuter le programme producteur plusieurs fois, il est préférable d’attribuer un nom unique à chaque instance, souvent « serviceID: ».
    • Créez un projet à l’aide des dépendances Spring Web et EurekaDiscoveryClient. (N’incluez pas les dépendances de l’outil de développement.)
    • Ajoutez @EnableEurekaClient en haut de la classe principale.
    • Ajoutez les entrées suivantes à application.properties :
#Port number
server.port = 9900
#Service ID
spring.application.name = Billing-Service
#Eureka Server publishing info
eureka.client.server-url.default-zone = http://localhost:8761/eureka
#Provide application name + random value as Instance ID
eureka.instance.instance-id = ${spring.application.name}:${random.value}

3 : – Créez un contrôleur de repos qui agit comme un microservice producteur.

//BillingInfoController.java (Client Component)
package com.perficient.rest;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/billing/api")
public class BillingInfoController {
    @Value("${server.port}")
     private  int port;
    @Value("${eureka.instance.instance-id}")
      private  String instanceid;
    
    @GetMapping("/info")
    public  ResponseEntity<String>  fetchBillingDetails(){
       return new ResponseEntity<String>(" Final BillAmt= BillAmt- discount (Rs.5000) :: using instance::-->"+instanceid+" @port::"+port,HttpStatus.OK);   
    }

}

4 : -Créez l’application grand public à l’aide de LoadBalancerClient.

  • Créez un projet avec les dépendances Spring Web et EurekaDiscoveryClient ; Le ruban apparaîtra directement (n’inclut pas les exigences relatives aux outils de développement).
  • Ajoutez @EnableEurekaClient en haut de la classe principale.

5 : – Créez un assistant avec l’injection de composant LoadBalancerClient.

//BillingServiceConsumerClient .java (Client App)
package com.perficient.client;

import java.net.URI;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

@Component
public class BillingServiceConsumerClient {
    @Autowired
    private  LoadBalancerClient client;
    
      public   String   getBillingInfo() {
          // Get Billing-Service  Instance from eureka server  based LoadFactor
          ServiceInstance instance=client.choose("Billing-Service");
           // get details from Serivce Instance
           URI uri=instance.getUri();
            //prepare  provider MS related url to cosume method 
          String url=uri.toString()+"/billing/api/info";
          
         //create RestTemplate class obj to cosume the provider  service
            RestTemplate template=new RestTemplate();
         //  consume the provider service
            ResponseEntity<String> response=template.getForEntity(url,String.class);
           // get response content from ResponseEntity object
            String responseContent=response.getBody();
          
            return responseContent;
          
      }

}

6 : – Créer le contrôleur de repos

//ShoppingSerivceOperationsController.java (RestController)
package com.perficient.rest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.nt.client.BillingServiceConsumerClient;

@RestController
@RequestMapping("/shopping/api")
public class ShoppingSerivceOperationsController {
     @Autowired
    private BillingServiceConsumerClient client;

     @GetMapping("/cart")
      public   ResponseEntity<String>  doShopping(){
          //use  Client Comp
          String  resultMsg=client.getBillingInfo();
          try {
              Thread.sleep(20000);
          }
          catch(Exception e) {
              e.printStackTrace();
          }
          return  new ResponseEntity<String>("Shopping the items(shirt,trouser) ::::"+resultMsg,HttpStatus.OK);
          
        
              
          
          
      }
      
}

7 : – Exécutez l’application dans l’ordre suivant.

  1. Exécutez l’application serveur Eureka.
  2. Exécutez l’application producteur plusieurs fois mais modifiez le numéro de port. [server.port value]
  3. Exécutez l’application consommateur.

Client d'équilibrage de charge

Limitation avec Discovery Client et Load Balancer Client.

  • Eureka Server leur permet de localiser et d’obtenir des instances de microservices de producteur ainsi que d’autres informations. Cependant, ils ne peuvent pas effectuer d’appels http pour communiquer avec les microservices souhaités ; pour cela, nous devons utiliser RestTemplate séparément.
  • Nous utilisons le codage en dur pour localiser et obtenir l’instance de microservice cible.

Feindre un client

  • Il est appelé client abstrait car nous fournissons simplement une interface avec une définition et une annotation de méthode. Cependant, la logique complète sera construite à l’aide de la classe proxy dynamique InMemory. [Proxy design Pattern].
  • Il s’agit d’un client combiné, ce qui signifie qu’il obtient l’instance de microservice cible d’Eureka Server tout en communiquant simultanément avec le microservice cible via des appels http générés sans avoir besoin de codage. (Le code complet sera créé par la classe proxy InMemory.)
  • Il utilise LoadBalancerClient en interne, ce qui signifie qu’il sélectionne l’instance de microservice cible dans une liste d’instances de service avec un facteur de charge inférieur.
  • Nous ne créons pas d’assistant RestController pour le consommateur RestController, mais plutôt une interface avec @FiegnClient(« ServiceId »), qui génère un objet de classe proxy dynamique InMemory qui sera injecté dans le consommateur RestController.
  • Lors de l’utilisation de FeignClient, nous devons inclure deux annotations spécifiques ainsi que les annotations ordinaires dans l’application grand public.
    • @EnableFeignClient au début de la classe principale, à côté de @EnableEurekaClient.
    • @FeignClient au début de l’interface indique qu’une classe proxy dynamique en mémoire sera produite à l’intérieur.

Règles du client Feign

La configuration Spring Cloud produit la classe Dynamic InMemory Proxy pour cette interface, qui implémente la fonction getBillingInfo() et inclut une logique pour utiliser LoadBalancerClient pour réduire le facteur de charge sur l’instance de microservice producteur, ainsi que pour utiliser RestTemplate pour accéder à la méthode du microservice producteur. via des requêtes http.

Exemple d’application : –

1 : – Créer un projet de serveur Eureka

2 : – Créer un projet en tant que microservice producteur

  • Dépendances – Spring Web, EurekaDiscoveryClient
  • Ajoutez @EnableEurekaClient en haut de la classe principale
  • Ajoutez le code suivant à l’application. propriétés
# MS Service Port number
server.port=9091

#MS  name (service name -Service Instance name)
spring.application.name=Billing-Service
# Generate  Instace id dynaically having  service name + random value
eureka.instance.instance-id=${spring.application.name}:${random.value}


#url  to register with Eureka server
eureka.client.service-url.default-zone=http://localhost:8761/eureka
  • Créer RestController ayant la méthode producteur
//BillingInfoController.java (Client Comp)
package com.perficient.rest;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/billing/api")
public class BillingInfoController {
    @Value("${server.port}")
     private  int port;
    @Value("${eureka.instance.instance-id}")
      private  String instanceid;
    
    @GetMapping("/info")
    public  ResponseEntity<String>  fetchBillingDetails(){
       return new ResponseEntity<String>(" Final BillAmt= BillAmt- discount (Rs.5000) :: using instance::-->"+instanceid+" @port::"+port,HttpStatus.OK);   
    }

}

3 : – Créer un projet de microservice grand public

  • Dépendances – Spring Web, EurekaDiscoveryClient, open feign
  • Ajoutez l’annotation @EnableEurekaClient, @EnableFeignClient en haut de la classe principale.
package com.perficient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class MsProj04ShoppingServiceConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(MsProj04ShoppingServiceConsumerApplication.class, args);
    }

}
  • Ajoutez les entrées suivantes sur application.properties
#  Server port  (acts MS port no)
server.port=7070

#MS name
spring.application.name=Shopping-Service

#url to register  with Eureka
eureka.client.service-url.default-zone=http://localhost:8761/eureka
  • Créez une interface qui prend en charge le code Feign Client en tant que classe proxy dynamique en mémoire.
// IBillingServiceConsumer.java
package com.perficient.client;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient("Billing-Service")
public interface IBillingServiceConsumerClient {

   @GetMapping("/billing/api/info")
   public  ResponseEntity<String>  fetchBillingInfo();
}
  • Créez un Consumer RestController et injectez un objet Proxy lié à FeignClient pour consommer le microservice de destination.
//ShoppingSerivceOperationsController.java (RestController)
package com.nt.rest;

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


import com.nt.client.IBillingServiceConsumerClient;

@RestController
@RequestMapping("/shopping/api")
public class ShoppingSerivceOperationsController {
     @Autowired
    private   IBillingServiceConsumerClient client;

     @GetMapping("/cart")
      public   ResponseEntity<String>  doShopping(){
         System.out.println("Proxy class name ::"+client.getClass()+" .... "+ Arrays.toString (client.getClass().getInterfaces()));
          //use  Client Comp
          String resultMsg=client.fetchBillingInfo().getBody();
        
          return  new ResponseEntity<String>("Shopping the items(shirt,trouser) :- "+resultMsg,HttpStatus.OK);
    
      }//method
      
}//class
  • Exécutez l’application dans l’ordre suivant.
  1. Exécutez l’application serveur Eureka.
  2. Exécutez l’application producteur plusieurs fois mais modifiez le numéro de port. [server.port value]
  3. Exécutez l’application consommateur.

Restez à l’écoute pour le prochain didacticiel, qui couvrira Config Server.



Le meilleur outil 2023 pour ta croissance Instagram !



Source link