avant-propos

Dans un système distribué, le registre de services joue un rôle important et est un membre indispensable de la découverte de services et de l'équilibrage de charge client. En plus des fonctions de base du centre d'enregistrement, sa stabilité, sa disponibilité et sa robustesse ont un grand impact sur le bon fonctionnement de l'ensemble du système distribué.

Qu'est-ce qu'un registre de services

Dans les petites applications monolithiques précédentes, les appels entre les composants devaient uniquement être effectués via des interfaces avec des contraintes de spécification. Cependant, dans l'architecture des microservices, la grande application d'origine est généralement divisée en services relativement indépendants qui fournissent des fonctions spécifiques en fonction de l'entreprise. Chaque microservice peut être étendu de manière dynamique via le clustering ou d'autres méthodes. Chaque adresse réseau des instances de microservice peut changer de manière dynamique. Dans l'architecture de microservice, la portée du service est grande et le nombre est important, il est donc nécessaire d'établir un composant décentralisé pour enregistrer et gérer les informations de chaque instance de microservice, et en même temps fournir la possibilité de permettre à chaque instance de microservice de découvrir l'autre, afin d'atteindre Le résultat de s'appeler.

Par conséquent, on peut considérer que l'enregistrement et la découverte du service comprennent deux parties, l'une est le côté serveur et l'autre est le client. Le côté serveur est un composant commun, qui fournit la fonction d'enregistrement et de découverte de service pour le côté client, conserve les informations pertinentes du côté client enregistrées sur lui-même et fournit une interface pour que le côté client obtienne des informations sur d'autres services dans le Registre, apporter des modifications dynamiques Le client peut effectuer des appels entre les services lorsque l'adresse du service est stable. Le client enregistre ses propres informations de service sur le serveur d'une certaine manière et maintient la cohérence de ses propres informations dans la plage normale, de sorte que d'autres services puissent se trouver facilement. En même temps, il peut obtenir d'autres informations de service qu'il dépend de l'appel de service via le serveur.

Donc, en résumé, le registre des services fait référence à la proposition d'un service unique dans l'ensemble de l'architecture du microservice. Ce service ne complète aucune des fonctions commerciales du système, mais n'est utilisé que pour terminer l'enregistrement du service et la découverte du service de l'ensemble du système de microservice, comme ainsi que l'état de santé du service Fonctions de surveillance et de gestion.

Les fonctions du registre des services peuvent être résumées comme suit :

1. Stockez toutes les informations de microservice, telles que le nom du microservice, l'adresse IP, le port, etc.

2. Lorsque vous effectuez des appels de service, utilisez la découverte de service pour interroger la liste des microservices et des adresses réseau disponibles pour les appels de service ;

3. Effectuez une détection de pulsation sur tous les microservices. Si certaines instances s'avèrent inaccessibles pendant une longue période, les instances seront supprimées du registre de service.

Les composants communs d'enregistrement et de découverte du service incluent : eureka de netflix, zookeeper (pour zk, veuillez vous référer à l'article précédent : tutoriel zookeeper : démarrage ), consul et nacos d'Ali (en tant que nacos en tant que centre d'enregistrement, veuillez vous référer à l'article précédent : SpringCloud : Construire le service Nacos et la découverte de services )

Qu'est-ce qu'Eureka

Eureka vient du grec ancien, ce qui signifie "Je l'ai trouvé ! Je l'ai trouvé !" Selon la légende, Archimède a découvert le principe de la flottabilité en prenant un bain. Il était si heureux qu'il n'a pas eu le temps d'enfiler son pantalon et a couru dans la rue et a crié: "Eureka (je l'ai trouvé)!" . Dans Netflix, Eureka est un composant de service de base pour l'enregistrement et la découverte de services de style REST, principalement pour l'équilibrage de charge et le basculement des services de niveau intermédiaire dans AWS. Eureka se compose de deux parties, l'une est Eureka Server, qui fournit des fonctions d'enregistrement et de découverte de services ; l'autre est un client Java, appelé Eureka Client, qui doit faciliter l'interaction avec le serveur, et Eureka Client enregistrera régulièrement son propre information Accédez à Eureka Server et découvrez d'autres services de Server. Il existe un équilibreur de charge intégré dans le client pour l'équilibrage de charge de base à répétition alternée.

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

L'article d'aujourd'hui apprend principalement à développer un serveur eureka en tant que registre de services.

Développement pratique

La structure de mon projet est la suivante :

Vous devez d'abord créer un projet springcloud. J'ai créé ici un projet d'agrégation maven en tant que projet parent pour un apprentissage ultérieur. Le projet parent est principalement utilisé pour la gestion des dépendances et le contrôle des versions. Vous devez donc ajouter des dépendances liées au projet au projet parent. Le fichier pom complet est le suivant :

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jiangxia</groupId>
    <artifactId>springcloud_parent</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springcloud01_eureka_server</module>
    </modules>

    <!--继承springboot的父项目-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
    </parent>
    <!--父项目不写代码，只维护依赖和版本-->
    <!--自定义properties属性-->
    <properties>
        <!--具体的springcloud版本-->
        <spring.cloud-version>Hoxton.SR6</spring.cloud-version>
    </properties>

    <!--维护版本-->
    <dependencyManagement>
        <dependencies>
            <!--维护springcloud版本依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud-version}</version>
                <!--父项目类型都是pom类型-->
                <type>pom</type>
                <!--当前项目也要导入一个父项目-->
                <scope>import</scope>
            </dependency>
        </dependencies>

    </dependencyManagement>
</project>

Créez ensuite un sous-projet springcloud01_eureka_server, qui est le projet qui utilise eureka-server pour le centre d'enregistrement de service ici. Étant donné que le sous-projet hérite des dépendances du projet parent, il vous suffit d'ajouter les dépendances suivantes au fichier pom du sous-projet :

 <dependencies>
        <!--引入springbootweb依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--引入eurekaserver依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

Ensuite, vous devez ajouter une classe de démarrage d'entrée. En plus d'utiliser l'annotation @springbootapplication, vous devez également ajouter l'annotation @enableEurekaServer pour indiquer que le projet actuel est un registre de services.

/**
 * @author jiangxia
 * @date 2022年05月18日 21:02
 */
@SpringBootApplication
//开启eurekaserver注解：表示当前应用是一个服务注册中心
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class,args);
    }
}

La dernière étape consiste à effectuer une configuration dans le fichier de configuration. Dans le fichier application.properties, vous pouvez configurer le port de service, le nom du service, l'adresse du centre d'enregistrement et d'autres configurations, comme suit :

#eureka默认端口就是8761，这里和默认保持一致
server.port=8761
#指定服务名称，唯一标识，服务名不能出现下划线，如果不指定名称，显示的就是unknown
spring.application.name=eurekaserver
#指定服务注册中心的地址，暴露服务地址
eureka.client.service-url.defaultZone=http://localhost:8761/eureka
# 关闭eureka立即注册,默认事true
eureka.client.fetch-registry=false
#让当前应用仅仅是服务注册中心，即开启不自己注册自己，默认是true
eureka.client.register-with-eureka=false

Jusqu'à présent, le centre d'enregistrement du service de développement de serveur eureka a été développé. Projet de démarrage :

Tapez dans la barre d'adresse :

http://localhost:8761/

Vous pouvez voir l'interface de gestion du serveur eureka :

On peut constater qu'il n'y a pas d'application ici, car aucune application n'a encore été enregistrée. Ce qui précède a une configuration :

# 关闭eureka立即注册,默认是true
eureka.client.fetch-registry=false
#让当前应用仅仅是服务注册中心，即开启不自己注册自己，默认是true
eureka.client.register-with-eureka=false

Si la configuration ci-dessus est définie sur true ou non définie (la valeur par défaut est true). Ensuite, le serveur eureka s'enregistrera dans le centre d'enregistrement lorsqu'il démarrera, comme suit :

Et pendant le processus de démarrage ci-dessus, un message d'erreur s'affiche sur la console :

En effet, eureka comprend deux composants, serveur et client. Lorsque le composant serveur eureka est introduit dans le projet, le client eureka sera introduit dans le projet en même temps. Par conséquent, il démarrera lui-même en tant que centre de service au démarrage, et en même temps Enregistrez-vous en tant que client dans le centre d'enregistrement, et nous avons commenté les deux configurations dans le fichier de configuration, donc la valeur par défaut est de s'enregistrer immédiatement au démarrage (la même chose est vraie si la configuration précédente est définie sur true), mais le service n'est pas encore prêt pour l'enregistrement Terminé, alors signalez une erreur ! Définissez donc les deux configurations ci-dessus sur false.

Résumer

Ce qui précède est l'utilisation du serveur eureka pour le développement du centre d'enregistrement de service. Les principales étapes consistent à créer le projet springcloud correspondant, puis à importer les dépendances liées au serveur springcloud et eureka, et enfin à configurer le serveur eureka dans le fichier de configuration, et utilisez l'annotation @EnableEurekaServer sur la classe d'entrée pour démarrer le service Enregistrez simplement le centre.

Les articles suivants continueront le développement du client eureka.

Spring Cloud Series : Composants d'enregistrement et de découverte de service - Eureka (on)

avant-propos

Qu'est-ce qu'un registre de services

Qu'est-ce qu'Eureka

Développement pratique

Résumer

suggestion connexe

Je suppose que tu aimes