Implement service registration and discovery - Enterprise Distributed Application Service

Enterprise Distributed Application Service (EDAS) propose la version en disponibilité générale (GA) du registre Nacos. Les applications Spring Cloud basées sur Nacos peuvent se connecter à ce registre partagé sans modification du code : déployez-les sur EDAS et la plateforme gère automatiquement la connectivité au registre.

Ce tutoriel vous guide dans la création de deux microservices Spring Cloud — un fournisseur de services et un consommateur de services — qui s'enregistrent auprès de Nacos pour la découverte de services. À l'issue de ce processus, vous disposerez des éléments suivants :

Un serveur Nacos local fonctionnant en mode autonome.
Un fournisseur de services enregistré auprès de Nacos et exposant un endpoint REST.
Un consommateur de services découvrant le fournisseur via RestTemplate et FeignClient.
Une découverte de services de bout en bout vérifiée localement.

Après la validation locale, déployez les deux applications sur EDAS. Consultez Déployer des applications sur des instances ECS ou Déployer des applications sur des clusters Kubernetes.

Remarque

EDAS prend en charge plusieurs registres, notamment Nacos, Eureka, ZooKeeper et Consul (gérés par vos soins ou via Microservice Engine (MSE)). Quel que soit le registre utilisé, EDAS fournit des fonctionnalités de gestion des applications, de gouvernance des microservices et de PaaS cloud-native après le déploiement.

Prérequis

Avant de commencer, assurez-vous d'avoir :

Maven installé et les variables d'environnement configurées
La dernière version de Nacos Server téléchargée et extraite

Démarrer Nacos Server

Accédez au répertoire nacos/bin.
Démarrez Nacos Server en mode autonome :
- Linux, UNIX ou macOS :
```
sudo sh startup.sh -m standalone
```
- Windows : double-cliquez sur startup.cmd.
Ouvrez http://127.0.0.1:8848/nacos dans votre navigateur pour vérifier que Nacos Server est en cours d'exécution. Le nom d'utilisateur et le mot de passe par défaut sont tous deux nacos.

Facultatif :

Lorsque vous développez des applications localement, vous pouvez utiliser le plug-in Alibaba Cloud Toolkit pour activer les appels mutuels entre les applications locales et les applications déployées dans EDAS, ce que l'on appelle l'interconnexion local-to-cloud. Ainsi, vous n'avez pas besoin de configurer un VPN et vous améliorez l'efficacité du développement. Pour plus d'informations, consultez Présentation de l'interconnexion local-to-cloud.

Structure du projet

Ce tutoriel crée deux projets Maven indépendants :

nacos-service-provider/
├── pom.xml
└── src/main/
    ├── java/com/aliware/edas/
    │   ├── ProviderApplication.java
    │   └── EchoController.java
    └── resources/
        └── application.properties

nacos-service-consumer/
├── pom.xml
└── src/main/
    ├── java/com/aliware/edas/
    │   ├── ConsumerApplication.java
    │   ├── EchoService.java
    │   └── TestController.java
    └── resources/
        └── application.properties

Téléchargez les projets de démonstration complets : service-provider | service-consumer.

Créer le fournisseur de services

Étape 1 : Configurer le projet Maven

Créez un projet Maven nommé nacos-service-provider et ajoutez les dépendances suivantes au fichier pom.xml. Cet exemple utilise Spring Boot 2.1.4.RELEASE et Spring Cloud Greenwich.SR1 :

Développer pour afficher le code

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    <relativePath/>
</parent>

<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Greenwich.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

La version de Spring Cloud Alibaba doit correspondre à votre version de Spring Cloud :

Version de Spring Cloud	Version de Spring Cloud Alibaba
Greenwich	2.1.1.RELEASE
Finchley	2.0.1.RELEASE
Edgware	1.5.1.RELEASE

Remarque

Spring Cloud Edgware a atteint sa fin de vie. N'utilisez pas Edgware pour de nouveaux projets.

Étape 2 : Créer la classe d'application

Dans src/main/java, créez le package com.aliware.edas, puis ajoutez ProviderApplication.java :

package com.aliware.edas;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient  // Enables service registration and discovery
public class ProviderApplication {

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

Étape 3 : Ajouter un contrôleur REST

Dans le même package, créez EchoController.java pour exposer un endpoint /echo/{string} :

package com.aliware.edas;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EchoController {
    @RequestMapping(value = "/echo/{string}", method = RequestMethod.GET)
    public String echo(@PathVariable String string) {
        return string;
    }
}

Étape 4 : Configurer l'adresse du registre

Dans src/main/resources, créez application.properties :

spring.application.name=service-provider
server.port=18081
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848

Remplacez 127.0.0.1 par l'adresse IP de votre Nacos Server s'il s'exécute sur une machine différente. Pour d'autres options de configuration, consultez Référence de configuration.

Étape 5 : Vérifier l'enregistrement

Exécutez la méthode main de ProviderApplication pour démarrer le service.
Ouvrez la console Nacos à l'adresse http://127.0.0.1:8848/nacos (nom d'utilisateur/mot de passe : nacos/nacos).
Accédez à Service Management > Services. service-provider apparaît dans la liste des services. Cliquez sur Details pour afficher les détails de l'enregistrement, tels que l'IP et le port de l'instance.

Créer le consommateur de services

Le consommateur illustre deux approches pour appeler le fournisseur : RestTemplate avec équilibrage de charge côté client, et FeignClient en tant que client HTTP déclaratif.

Étape 1 : Configurer le projet Maven

Créez un projet Maven nommé nacos-service-consumer et ajoutez les dépendances suivantes au fichier pom.xml :

Développer pour afficher le code

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    <relativePath/>
</parent>

<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Greenwich.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Étape 2 : Définir l'interface client Feign

Dans src/main/java, créez le package com.aliware.edas, puis ajoutez EchoService.java :

package com.aliware.edas;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@FeignClient(name = "service-provider")  // Refers to the provider's registered service name
public interface EchoService {
    @RequestMapping(value = "/echo/{str}", method = RequestMethod.GET)
    String echo(@PathVariable("str") String str);
}

Étape 3 : Créer la classe d'application

Dans le même package, créez ConsumerApplication.java :

package com.aliware.edas;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient   // Enables service registration and discovery
@EnableFeignClients      // Activates FeignClient scanning
public class ConsumerApplication {

    @LoadBalanced  // Integrates RestTemplate with service discovery for client-side load balancing
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

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

Résumé des annotations :

@EnableDiscoveryClient — enregistre cette application auprès de Nacos.
@EnableFeignClients — analyse les interfaces @FeignClient et crée des beans proxy.
@LoadBalanced — permet à RestTemplate de résoudre les noms de service (tels que service-provider) via le registre plutôt que par DNS.

Étape 4 : Ajouter un contrôleur de test

Dans le même package, créez TestController.java avec deux endpoints qui appellent le fournisseur en utilisant différentes approches :

package com.aliware.edas;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class TestController {

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private EchoService echoService;

    // Uses RestTemplate with service discovery to call the provider
    @RequestMapping(value = "/echo-rest/{str}", method = RequestMethod.GET)
    public String rest(@PathVariable String str) {
        return restTemplate.getForObject("http://service-provider/echo/" + str,
                String.class);
    }

    // Uses FeignClient to call the provider
    @RequestMapping(value = "/echo-feign/{str}", method = RequestMethod.GET)
    public String feign(@PathVariable String str) {
        return echoService.echo(str);
    }
}

Étape 5 : Configurer l'adresse du registre

Dans src/main/resources, créez application.properties :

spring.application.name=service-consumer
server.port=18082
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848

Remplacez 127.0.0.1 par l'adresse IP de votre Nacos Server s'il s'exécute sur une machine différente.

Étape 6 : Vérifier l'enregistrement

Exécutez la méthode main de ConsumerApplication pour démarrer le service.
Ouvrez la console Nacos à l'adresse http://127.0.0.1:8848/nacos.
Accédez à Service Management > Services. service-consumer apparaît dans la liste des services aux côtés de service-provider.

Tester la découverte de services localement

Les deux applications étant en cours d'exécution, testez la découverte de services de bout en bout. Le consommateur résout le nom de service service-provider via Nacos et transfère chaque requête au fournisseur.

Linux, UNIX ou macOS :

# Test with RestTemplate
curl http://127.0.0.1:18082/echo-rest/rest-rest

# Test with FeignClient
curl http://127.0.0.1:18082/echo-feign/feign-rest

Windows : Ouvrez les URL suivantes dans votre navigateur :

http://127.0.0.1:18082/echo-rest/rest-rest
http://127.0.0.1:18082/echo-feign/feign-rest

Sortie attendue :

Endpoint	Réponse attendue
`/echo-rest/rest-rest`	`rest-rest`
`/echo-feign/feign-rest`	`feign-rest`

Si les deux endpoints renvoient la valeur du paramètre de chemin, l'enregistrement et la découverte de services fonctionnent correctement.

Déployer sur EDAS

Après la validation locale, déployez les deux applications sur EDAS. EDAS fournit un registre Nacos managé, de sorte que vos applications s'y connectent automatiquement sans modification du code.

Pour les instructions de déploiement, consultez :

Référence de configuration

Nacos Discovery prend en charge les propriétés de configuration suivantes dans application.properties :

Élément de configuration	Clé	Valeur par défaut	Description
Adresse du serveur	`spring.cloud.nacos.discovery.server-addr`	Aucune	Adresse IP et port du serveur Nacos
Nom du service	`spring.cloud.nacos.discovery.service`	`${spring.application.name}`	Nom utilisé pour enregistrer le service
Nom de l'interface réseau	`spring.cloud.nacos.discovery.network-interface`	Aucune	Interface réseau dont l'adresse IP est enregistrée. Par défaut, la première interface NIC si non spécifié
Adresse IP enregistrée	`spring.cloud.nacos.discovery.ip`	Aucune	Remplace l'IP détectée automatiquement. Priorité la plus élevée
Port enregistré	`spring.cloud.nacos.discovery.port`	-1	Détecté automatiquement par défaut
Namespace	`spring.cloud.nacos.discovery.namespace`	Aucune	Isole les services entre les environnements (par exemple, dev, staging, production)
Métadonnées	`spring.cloud.nacos.discovery.metadata`	Aucune	Paires clé-valeur personnalisées associées à l'instance de service. Configurées au format Map
Cluster	`spring.cloud.nacos.discovery.cluster-name`	DEFAULT	Nom du cluster Nacos
Endpoint	`spring.cloud.nacos.discovery.endpoint`	UTF-8	Nom de domaine pour la résolution dynamique de l'adresse du serveur. Non requis lors du déploiement sur EDAS
Intégration Ribbon	`ribbon.nacos.enabled`	true	Active l'équilibrage de charge basé sur Ribbon avec Nacos. À modifier uniquement si nécessaire

Pour la référence complète, consultez Nacos Discovery sur GitHub.