Spring Cloud Framework Apprentissage - Centre d'inscription Spring Cloud Eureka

1. Introduction à Eurêka

Eureka est un registre de services fourni par Netflix. Eureka implémente l'enregistrement et la découverte de services basés sur REST. Eureka est encapsulé dans Spring Cloud. Sur la base d'Eureka, certaines configurations sont optimisées et une interface visuelle est fournie, qui permet de visualiser facilement l'état d'enregistrement des services et l'état de fonctionnement du cluster de registre de services.

Euraka se compose de deux parties : serveur et client. Le serveur est le registre, qui est utilisé pour recevoir les enregistrements d'autres services ; le client est divisé en fournisseurs de services et consommateurs de services, et est un client Java. Comme indiqué ci-dessous:

2. Construction Eurêka

Eureka lui-même est développé en Java, et Spring Cloud utilise la technologie Spring Boot pour encapsuler Eureka. Il est très pratique d'utiliser Eureka dans Spring Cloud. Il vous suffit d'introduire des dépendances : spring-cloud-starter-netflix-eureka-server, et vous pouvez le démarrer comme un projet Spring Boot normal.

1. Créez un projet Spring Boot et ajoutez des dépendances Eureka.

2. Une fois le projet créé, ajoutez l'annotation @EnableEurekaServer à la classe de démarrage pour identifier le projet en tant que serveur Eureka.

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
    
    

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

3. Ajoutez les informations de configuration de base dans application.properties :

#当前服务的名字
spring.application.name=eureka
#端口号(Eureka后台管理端端口)
server.port=1111
#默认情况下，Eureka Server也是一个普通的微服务，所以当它还是注册中心时，就有两层身份：
#1.注册中心；2.普通服务。默认当前eureka server自动把自己注册到注册中心中，
# 通过eureka.client.register-with-eureka=false设置不注册
eureka.client.register-with-eureka=false
#表示是否从Eureka Server上获取注册信息
eureka.client.fetch-registry=false

4. Une fois la configuration terminée, vous pouvez démarrer le projet et visiter http://localhost:1111 dans le navigateur pour afficher la page de gestion d'arrière-plan Eureka.

3. Pôle Eurêka

Dans l'architecture Spring Cloud, s'il n'y a qu'un seul registre, si une panne se produit, l'ensemble de l'environnement de service sera indisponible, nous devons donc créer un cluster de registre Eureka pour obtenir l'équilibrage de charge et la tolérance aux pannes. Schéma de principe du diagramme d' architecture du cluster Eureka : Le

principe de construction du cluster Eureka est de s'enregistrer les uns avec les autres. Dans cette architecture de cluster, la synchronisation des données est effectuée entre les serveurs Eureka et tous les nœuds sont égaux sans distinction entre les nœuds maîtres et esclaves. Les nœuds s'enregistrent les uns avec les autres via le top serviceUrl pour former un cluster, améliorant ainsi la disponibilité des nœuds.

Dans un cluster de serveurs Eureka, si un seul nœud tombe en panne, le client Eureka basculera automatiquement vers le nouveau serveur Eureka. Chaque nœud de serveur Eureka synchronise les données les unes avec les autres. La méthode de connexion du serveur Eureka peut être une seule ligne, la méthode de connexion est a->b->c, et les données du nœud a seront également synchronisées avec c. Mais ce n'est pas recommandé. Lorsque nous configurons serviceUrl, vous pouvez spécifier plusieurs adresses d'enregistrement, c'est-à-dire que a peut s'enregistrer sur b ou c en même temps.

4. Architecture Eurêka

Eureka se compose de deux composants : Eureka Server et Eureka Client.

4.1 Serveur Eurêka

Eureka Server a principalement trois fonctions :

1. Enregistrement du service, tous les services sont enregistrés sur Eureka Server. Une fois que chaque nœud de microservice est démarré, il sera enregistré dans Eureka Server, de sorte que le registre de service dans Eureka Server stocke les informations de tous les nœuds de service disponibles, et les informations des nœuds de service peuvent être vues intuitivement dans l'interface.
2. Fournit un registre, qui est une liste de services enregistrés sur Eureka Server. Le client Eureka a besoin d'obtenir ce registre lors de l'appel du service. En général, ce registre sera mis en cache. Si le cache échoue, il obtiendra directement le dernier registre.
3. État de synchronisation, Eureka Client synchronise l'état actuel du registre avec Eureka Server via l'enregistrement, le rythme cardiaque et d'autres mécanismes.

4.2 Client Eurêka

Eureka Client est principalement utilisé pour simplifier l'interaction entre chaque service et Eureka Server. Le client Eureka extrait automatiquement les mises à jour et met en cache les informations dans le serveur Eureka, de sorte que même si tous les nœuds du serveur Eureka sont en panne, le client Eureka peut toujours obtenir le service qu'il souhaite appeler. (mais l'adresse peut être inexacte).

Eureka Client fournit les fonctions suivantes :

• enregistrement des services

Le fournisseur de services s'enregistre auprès du registre de services Eureka Server,Le soi-disant fournisseur de services n'est qu'une division commerciale, qui est essentiellement un client Eureka. Une fois qu'Eureka Client s'est enregistré auprès d'Eureka Server, il fournira ses propres informations de métadonnées, telles que l'adresse IP, le port, le nom, l'état d'exécution, etc.

• Renouvellement des services

Une fois le client Eureka enregistré auprès du serveur Eureka, == Par défaut, Eureka envoie un message de pulsation au serveur Eureka toutes les 30 secondes pour indiquer au serveur Eureka qu'il est toujours en cours d'exécution. == Si le serveur Eureka ne reçoit pas de message de renouvellement du client Eureka pendant 90 secondes, le serveur Eureka considérera le client Eureka comme étant hors ligne et le supprimera de la liste d'enregistrement du service.

Les fonctions liées au renouvellement de service ont deux propriétés connexes (il n'est généralement pas recommandé de les modifier) :

#服务续约时间，默认30s
eureka.instance.lease-renewal-interval-in-seconds=30
#未续约的服务失效时间，默认90s
eureka.instance.lease-expiration-duration-in-seconds=90

• service hors ligne

Lorsque le client Eureka se déconnecte, il envoie activement un message pour indiquer au serveur Eureka qu'il se déconnecte.

• Obtenir des informations sur le registre

Le client Eureka obtient les informations d'enregistrement du service à partir du serveur Eureka et les met en cache localement. Lorsque le client local doit appeler le service distant, il recherche l'adresse IP, le port et d'autres informations correspondant au service distant à partir des informations. Les informations d'enregistrement de service mises en cache sur le client Eureka seront mises à jour périodiquement (30 secondes). Si les informations de registre renvoyées par le serveur Eureka sont différentes des informations de registre mises en cache localement, le client Eureka les traitera automatiquement.
Deux propriétés sont concernées :

#是否获取注册表信息，默认为true
eureka.client.fetch-registry=true
#定期更新的时间间隔，默认为30秒
eureka.client.registry-fetch-interval-seconds=30

4.3 Autoprotection Eurêka

Par défaut, si Eureka Server ne reçoit pas la pulsation d'une instance de microservice dans un certain laps de temps (90 secondes par défaut), Eureka Server déconnecte l'instance de microservice. Cependant, lorsqu'une panne de partition réseau se produit, retarde, se fige et encombre, le microservice et le serveur Eureka ne peuvent pas communiquer normalement.Cependant, étant donné que le microservice est en réalité sain, l'instance du microservice ne doit pas être hors ligne pour le moment. Eureka résout ce problème grâce au "mode d'autoprotection" - lorsque le nœud du serveur Eureka perd trop de clients en peu de temps, Eureka entre en mode d'autoprotection et le serveur Eureka ne déconnecte pas immédiatement le service client Eureka.

5. Enregistrement des services

L'enregistrement de service consiste à enregistrer un microservice auprès d'Eureka Server, de sorte que lorsque d'autres services souhaitent appeler le service, ils n'ont qu'à interroger les informations du service auprès d'Eureka Server, puis terminer l'appel de service.

Pour créer un fournisseur de services, ajoutez simplement les deux dépendances suivantes à votre projet Spring Boot :

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

Configurez ensuite l'adresse d'enregistrement du projet dans application.properties, vous pouvez enregistrer le fournisseur de services Provider sur le serveur Eureka :

#服务名
spring.application.name=provider
#服务端口号
server.port=1113
#注册中心url地址
eureka.client.service-url.defaultZone=http://localhost:1111/eureka

Ensuite, démarrez d'abord le registre de services Eureka Server, puis démarrez le fournisseur de services une fois son démarrage terminé. Une fois les deux démarrages réussis, entrez dans le navigateur pour http://localhost:1111afficher les informations d'enregistrement dans le centre d'enregistrement de service actuel.

6. Consommation des services

Fournissez d'abord une interface dans le fournisseur de modules :

@RestController
public class HelloController {
    
    
  @Value("${server.port}")
  Integer port;

  @GetMapping("/hello")
  public String hello(){
    
    
    return "hello world port:"+port;
  }
}

Créez ensuite un module consommateur et ajoutez également les dépendances spring-boot-starter-web et spring-cloud-starter-netflix-eureka-client.

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

Une fois la création terminée, configurez les informations d'enregistrement dans application.properties

#服务名称
spring.application.name=consumer
#端口号
server.port=1114
#注册中心的url地址
eureka.client.service-url.defaultZone=http://localhost:1111/eureka

Ensuite, fournissez une interface, consommez l'interface fournie par le fournisseur de services, puis utilisez l'outil DiscoveryClient fourni par Eureka Client pour interroger les informations détaillées d'un service auprès d'Eureka Server en fonction du nom du service, et utilisez la classe d'outils RestTemplate pour lancer le demande.

@SpringBootApplication
public class ConsumerApplication {
    
    

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

  @Bean
  RestTemplate restTemplate(){
    
    
    return new RestTemplate();
  }
}

@RestController
public class HelloController {
    
    
  @Autowired
  DiscoveryClient discoveryClient;
  @Autowired
  RestTemplate restTemplate;

  @GetMapping("/hello2")
  public String hello2(){
    
    
    HttpURLConnection httpConnection=null;
    //如果是集群部署会有多个
    List<ServiceInstance> providerList = discoveryClient.getInstances("provider");
    ServiceInstance provider=providerList.get(0);
    String host = provider.getHost();
    int port=provider.getPort();
    StringBuffer providerUrl = new StringBuffer("http://").append(host)
                                                          .append(":")
                                                          .append(port)
                                                          .append("/hello");
    //通过RestTemplate实现服务的调用
    String result = restTemplate.getForObject(providerUrl.toString(), String.class);
    return result;
  }
}

Pour configurer la fonction d'équilibrage de charge de RestTemplate, vous devez ajouter l'annotation @LoadBalanced pour l'activer

@SpringBootApplication
public class ConsumerApplication {
    
    

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

  @Bean
  RestTemplate restTemplate(){
    
    
    return new RestTemplate();
  }
}
  @Bean
  @LoadBalanced
  RestTemplate balancedRestTemplate(){
    
    
    return new RestTemplate();
  }