Utiliser Tanzu Service Registry
Remarque
Les plans Essentiel, Standard et Entreprise seront déconseillés à compter de la mi-mars 2025, avec une période de mise hors service de 3 ans. Nous vous recommandons de passer à Azure Container Apps. Pour plus d’informations, consultez l’annonce de mise hors service d’Azure Spring Apps.
Le plan de consommation standard et dédiée sera déconseillé à compter du 30 septembre 2024, avec un arrêt complet après six mois. Nous vous recommandons de passer à Azure Container Apps. Pour plus d’informations, consultez Migrer le plan de consommation standard et dédiée Azure Spring Apps vers Azure Container Apps.
Cet article s’applique à : ❎ Essentiel/Standard ✅ Entreprise
Cet article explique comment utiliser VMware Tanzu Service Registry avec le plan Azure Spring Apps niveau Enterprise.
Tanzu Service Registry est l’un des composants commerciaux de VMware Tanzu. Ce composant vous aide à appliquer le modèle de conception de détection de services à vos applications.
La détection de services est l'une des principales idées de l'architecture des microservices. Sans détection de services, vous devrez configurer manuellement chaque client d’un service ou adopter une certaine forme de convention d’accès. Ce processus peut être fastidieux, et les configurations et conventions peuvent se révéler fragiles en termes de production. Au lieu de cela, vous pouvez utiliser Tanzu Service Registry pour détecter et appeler dynamiquement des services inscrits dans votre application.
Avec le plan Azure Spring Apps niveau Enterprise, vous n’avez pas besoin de créer ou de démarrer Service Registry vous-même. Vous pouvez utiliser Tanzu Service Registry en le sélectionnant lorsque vous créez votre instance de plan Azure Spring Apps niveau Entreprise.
Prérequis
- Une instance de plan Azure Spring Apps niveau Enterprise déjà provisionnée et dans laquelle Tanzu Service Registry est activé. Pour plus d’informations, consultez Démarrage rapide : Générer et déployer des applications sur Azure Spring Apps à l’aide du plan Enterprise.
- L’extension de plan Enterprise d’Azure Spring Apps. Utilisez la commande suivante pour supprimer les versions précédentes et installer l’extension de plan Enterprise la plus récente. Si vous avez déjà installé l’extension
spring-cloud, désinstallez-la pour éviter les incompatibilités de configuration et de version.az extension add --upgrade --name spring az extension remove --name spring-cloud
Créer des applications qui utilisent Service Registry
Dans cet article, vous allez créer deux services et les inscrire auprès d’Azure Spring Apps Service Registry. Après inscription, un service peut utiliser Service Registry pour détecter et appeler un autre service. Le diagramme suivant résume la procédure :
Ces étapes sont décrites de manière plus détaillée dans les sections suivantes.
- Créez le service A.
- Déployez le service A sur Azure Spring Apps et inscrivez-le auprès de Service Registry.
- Créez le service B et implémentez-le pour appeler le Service A.
- Déployez le Service B et inscrivez-le auprès de Service Registry.
- Appelez le Service A via le Service B.
Créer des variables d’environnement
Cet article utilise les variables d’environnement suivantes. Définissez ces variables sur les valeurs que vous avez utilisées lors de la création de votre instance de plan Azure Spring Apps niveau Entreprise.
| Variable | Description |
|---|---|
| $RESOURCE_GROUP | Nom du groupe de ressources. |
| $AZURE_SPRING_APPS_NAME | Nom de l’instance Azure Spring Apps. |
Créer le Service A avec Spring Boot
Accédez à Spring Initializr pour créer un exemple de Service A. Ce lien utilise l’URL suivante pour initialiser les paramètres.
https://start.spring.io/#!type=maven-project&language=java&packaging=jar&groupId=com.example&artifactId=Sample%20Service%20A&name=Sample%20Service%20A&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.Sample%20Service%20A&dependencies=web,cloud-eureka
La capture d’écran suivante montre Spring Initializr avec les paramètres requis.
Sélectionnez ensuite GENERATE pour obtenir un exemple de projet pour Spring Boot avec la structure de répertoire suivante.
├── HELP.md
├── mvnw
├── mvnw.cmd
├── pom.xml
└── src
├── main
│ ├── java
│ │ └── com
│ │ └── example
│ │ └── Sample
│ │ └── Service
│ │ └── A
│ │ └── SampleServiceAApplication.java
│ └── resources
│ ├── application.properties
│ ├── static
│ └── templates
└── test
└── java
└── com
└── example
└── Sample
└── Service
└── A
└── SampleServiceAApplicationTests.java
Confirmer la configuration des bibliothèques dépendantes pour le client Service Registry (client Eureka)
Vérifiez ensuite que le fichier pom.xml du projet contient la dépendance suivante. Si elle est manquante, ajoutez cette dépendance.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
Implémenter le client Service Registry
Ajoutez une @EnableEurekaClient annotation au fichier SampleServiceAApplication.java pour le configurer en tant que client Eureka.
package com.example.Sample.Service.A;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
@SpringBootApplication
@EnableEurekaClient
public class SampleServiceAApplication {
public static void main(String[] args) {
SpringApplication.run(SampleServiceAApplication.class, args);
}
}
Créer un point de terminaison REST à des fins de test
Vous pouvez maintenant inscrire le service dans Service Registry, mais il vous est impossible de le vérifier tant que vous n’avez pas implémenté un point de terminaison de service. Pour créer des points de terminaison RESTful que les services externes peuvent appeler, ajoutez un fichier ServiceAEndpoint.java à votre projet à l’aide du le code suivant.
package com.example.Sample.Service.A;
import java.util.Map;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class ServiceAEndpoint {
@GetMapping("/serviceA")
public String getServiceA(){
return "This is a result of Service A";
}
@GetMapping("/env")
public Map<String, String> getEnv(){
Map<String, String> env = System.getenv();
return env;
}
}
Créer une application Spring Boot
Maintenant que vous disposez d’un service simple, compilez et générez le code source en exécutant la commande suivante :
mvn clean package
Déployer le Service A et l’inscrire auprès de Service Registry
Cette section explique comment déployer Service A sur une instance de plan Azure Spring Apps niveau Enterprise et l’inscrire auprès de Service Registry.
Créer une application Azure Spring Apps
Commencez par créer une application dans Azure Spring Apps à l’aide de la commande suivante :
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceA \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
L’argument --assign-endpoint octroie une adresse IP publique à des fins de validation et active l’accès à partir du réseau externe.
Se connecter à Service Registry à partir de l’application
Après avoir créé une instance de service avec Spring Boot et créé une application dans Azure Spring Apps, vous déployez l’application et confirmez l’opération. Avant cela, cependant, vous devez lier votre application à Service Registry pour lui permettre d’obtenir des informations de connexion à partir du registre.
En règle générale, un client Eureka doit écrire les paramètres d’informations de connexion suivants dans le fichier de configuration application.properties d’une application Spring Boot afin de pouvoir vous connecter au serveur :
eureka.client.service-url.defaultZone=http://eureka:8761/eureka/
Toutefois, si vous écrivez ces paramètres directement dans votre application, vous devez recréer et régénérer le projet chaque fois que le serveur Service Registry change. Pour éviter cet effort, Azure Spring Apps permet à vos applications d’obtenir des informations de connexion à partir de Service Registry en le liant. Plus précisément, après avoir lié l’application à Service Registry, vous pouvez obtenir les informations de connexion de Service Registry (eureka.client.service-url.defaultZone) à partir de la variable d’environnement Java. Ainsi, vous pouvez vous connecter à Service Registry en chargeant le contenu des variables d’environnement au démarrage de l’application.
Dans la pratique, les variables d’environnement suivantes sont ajoutées à la variable JAVA_TOOL_OPTIONS :
-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Lier un service à Service Registry
Utilisez la commande suivante pour lier le service à Azure Service Registry afin de lui permettre de se connecter au serveur.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceA
Vous pouvez également configurer les liaisons d’application à partir du portail Azure, comme illustré dans la capture d’écran suivante :
Remarque
Ces modifications prennent quelques minutes pour se propager à toutes les applications lorsque l’état de Service Registry change.
Si vous modifiez l’état de liaison/de dissociation, vous devez redémarrer ou redéployer l’application.
Vous pouvez maintenant choisir de lier votre application à Service Registry directement lors de la création d’une application à l’aide des commandes suivantes :
az spring app create \
--resource-group <resource-group> \
--service <service-name> \
--name <app-name> \
--bind-service-registry
Vous pouvez également lier votre application à Service Registry à partir du portail Azure, comme illustré dans la capture d’écran suivante :
Déployer une application dans Azure Spring Apps
Maintenant que vous avez lié votre application, vous allez déployer le fichier d’artefact Spring Boot Sample-Service-A-A-0.0.1-SNAPSHOT.jar à Azure Spring Apps. Pour ce faire, utilisez la commande suivante :
az spring app deploy \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceA \
--artifact-path ./target/Sample-Service-A-0.0.1-SNAPSHOT.jar \
--jvm-options="-Xms1024m -Xmx1024m"
Utilisez la commande suivante pour voir si votre déploiement a réussi.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Cette commande produit une sortie semblable à celle de l’exemple suivant :
Name Location ResourceGroup Public Url Production Deployment Provisioning State CPU Memory Running Instance Registered Instance Persistent Storage Bind Service Registry Bind Application Configuration Service
------------------------ ------------- ---------------------- ------------------------------------------------------------------- ----------------------- -------------------- ----- -------- ------------------ --------------------- -------------------- ----------------------- ----------------------------------------
servicea southeastasia $RESOURCE_GROUP https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io default Succeeded 1 2Gi 1/1 N/A - default -
Vérifier que l’application Service A est en cours d’exécution
La sortie de la commande précédente inclut l’URL publique du service. Pour accéder au point de terminaison RESTful, ajoutez /serviceA à l’URL, comme indiqué dans la commande suivante :
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/serviceA
Cette commande génère la sortie suivante :
This is a result of Service A
Le Service A inclut un point de terminaison RESTful qui affiche une liste de variables d’environnement. Accédez au point de terminaison avec /env pour voir les variables d’environnement, comme indiqué dans la commande suivante :
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/env
Cette commande génère la sortie suivante :
"JAVA_TOOL_OPTIONS":"-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Comme vous pouvez le voir, eureka.client.service-url.defaultZone est ajouté à JAVA_TOOL_OPTIONS. Ainsi, l’application peut inscrire le service auprès de Service Registry et le rendre disponible à partir d’autres services.
Vous pouvez maintenant inscrire le service auprès de Service Registry (Eureka Server) dans Azure Spring Apps. D’autres services peuvent désormais accéder au service à l’aide de Service Registry.
Implémenter un nouveau Service B qui accède au Service A via Service Registry
Implémenter le Service B avec Spring Boot
Accédez à Spring Initializr pour créer un projet pour le Service B. Ce lien utilise l’URL suivante pour initialiser les paramètres :
https://start.spring.io/#!type=maven-project&language=java&packaging=jar&groupId=com.example&artifactId=Sample%20Service%20B&name=Sample%20Service%20B&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.Sample%20Service%20B&dependencies=web,cloud-eureka
Sélectionnez ensuite GENERATE pour obtenir le nouveau projet.
Implémenter le Service B en tant que client de Service Registry (client Eureka)
Comme pour le Service A, ajoutez l’annotation @EnableEurekaClient au Service B pour le configurer en tant que client Eureka.
package com.example.Sample.Service.B;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
@SpringBootApplication
@EnableEurekaClient
public class SampleServiceBApplication {
public static void main(String[] args) {
SpringApplication.run(SampleServiceBApplication.class, args);
}
}
Implémenter des points de terminaison de service dans le Service B
Implémentez ensuite un nouveau point de terminaison de service (/invoke-serviceA) qui appelle le Service A. Ajoutez un fichier ServiceBEndpoint.java à votre projet avec le code suivant.
package com.example.Sample.Service.B;
import java.util.List;
import java.util.stream.Collectors;
import com.netflix.discovery.EurekaClient;
import com.netflix.discovery.shared.Application;
import com.netflix.discovery.shared.Applications;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
@RestController
public class ServiceBEndpoint {
@Autowired
private EurekaClient discoveryClient;
@GetMapping(value = "/invoke-serviceA")
public String invokeServiceA()
{
RestTemplate restTemplate = new RestTemplate();
String response = restTemplate.getForObject("http://servicea/serviceA",String.class);
return "INVOKE SERVICE A FROM SERVICE B: " + response;
}
@GetMapping(value = "/list-all")
public List<String> listsAllServices() {
Applications applications = discoveryClient.getApplications();
List<Application> registeredApplications = applications.getRegisteredApplications();
List<String> appNames = registeredApplications.stream().map(app -> app.getName()).collect(Collectors.toList());
return appNames;
}
}
Pour plus de simplicité, cet exemple utilise RestTemplate. Le point de terminaison retourne la chaîne de réponse avec une autre chaîne (INVOKE SERVICE A FROM SERVICE B: ") pour indiquer qu’il a été appelé par Service B.
Cet exemple implémente également un autre point de terminaison (/list-all) à des fins de validation. Cette implémentation permet au service de communiquer correctement avec Service Registry. Vous pouvez appeler ce point de terminaison pour obtenir la liste des applications inscrites dans Service Registry.
Cet exemple appelle le Service A en tant que http://servicea. Le nom du service correspond au nom que vous avez indiqué lors de la création de l’application Azure Spring Apps. (Par exemple : az spring app create --name ServiceA.) Le nom de l’application correspond au nom de service que vous avez inscrit auprès de Service Registry, ce qui facilite la gestion du nom de service.
Générer le Service B
Utilisez la commande suivante pour générer votre projet.
mvn clean package
Déployer le Service B sur Azure Spring Apps
Utilisez la commande suivante pour créer une application dans Azure Spring Apps afin de déployer le Service B.
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceB \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
Utilisez ensuite la commande suivante pour lier l’application à Service Registry.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceB
Utilisez ensuite la commande suivante pour déployer le service.
az spring app deploy \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceB \
--artifact-path ./target/Sample-Service-B-0.0.1-SNAPSHOT.jar \
--jvm-options="-Xms1024m -Xmx1024m"
Utilisez ensuite la commande suivante pour vérifier l’état de l’application :
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Si le Service A et le Service B sont correctement déployés, cette commande génère une sortie similaire à l’exemple suivant.
Name Location ResourceGroup Public Url Production Deployment Provisioning State CPU Memory Running Instance Registered Instance Persistent Storage Bind Service Registry Bind Application Configuration Service
-------- ------------- ---------------------- --------------------------------------------------------------- ----------------------- -------------------- ----- -------- ------------------ --------------------- -------------------- ----------------------- ----------------------------------------
servicea southeastasia SpringCloud-Enterprise https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io default Succeeded 1 2Gi 1/1 1/1 - default -
serviceb southeastasia SpringCloud-Enterprise https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io default Succeeded 1 2Gi 1/1 1/1 - default -
Appeler le Service A à partir du Service B
La sortie de la commande précédente inclut l’URL publique du service. Pour accéder au point de terminaison RESTful, ajoutez /invoke-serviceA à l’URL, comme indiqué dans la commande suivante :
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/invoke-serviceA
Cette commande génère la sortie suivante :
INVOKE SERVICE A FROM SERVICE B: This is a result of Service A
Obtenir des informations à partir de Service Registry
Enfin, accédez au point de terminaison /list-all et récupérez des informations à partir de Service Registry. La commande suivante récupère une liste de services inscrits dans Service Registry.
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/list-all
Cette commande génère la sortie suivante :
["SERVICEA","EUREKA-SERVER","SERVICEB"]
Vous pouvez ainsi obtenir des informations détaillées du programme, si besoin.
Activer/désactiver Service Registry après la création du service
Vous pouvez activer et désactiver Service Registry après la création du service à l’aide du portail Azure ou d’Azure CLI. Avant de désactiver Service Registry, vous devez dissocier toutes vos applications.
Pour activer ou désactiver Service Registry à l’aide du portail Azure, procédez comme suit :
- Accédez à votre ressource de service, puis sélectionnez Service Registry.
- Sélectionnez Gérer.
- Sélectionnez ou désélectionnez l’option Enable Service Registry (Activer Service Registry), puis sélectionnez Enregistrer.
- Vous pouvez maintenant afficher l’état de Service Registry dans la page Service Registry.