Utiliser Tanzu Service Registry

Article
02/20/2024

Remarque

Azure Spring Apps est le nouveau nom du service Azure Spring Cloud. Bien que le service ait un nouveau nom, vous verrez l’ancien nom à divers endroits pendant un certain temps, car nous travaillons à mettre à jour les ressources telles que les captures d’écran, les vidéos et les diagrammes.

Cet article s’applique à :❌ De base/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 :

Diagramme illustrant la procédure de création, de déploiement et d’inscription d’un Service A et d’un Service B.

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.

Capture d’écran de la page Spring Initializr montrant 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 :

Capture d’écran du Portail Azure montrant la page Registre de service avec la liste déroulante de liaison d’application mise en surbrillance.

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 :

Capture d’écran du Portail Azure montrant la page Créer une application avec mise en évidence de la liste déroulante Liaison.

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.

Azure portal
Azure CLI

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.

Utilisez les commandes Azure CLI suivantes pour activer ou désactiver Service Registry :

az spring service-registry create \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-service-instance-name>

az spring service-registry delete \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-service-instance-name>

Étapes suivantes

Créer des rôles et des autorisations

Utiliser Tanzu Service Registry

Prérequis

Créer des applications qui utilisent Service Registry

Créer des variables d’environnement

Créer le Service A avec Spring Boot

Confirmer la configuration des bibliothèques dépendantes pour le client Service Registry (client Eureka)

Implémenter le client Service Registry

Créer un point de terminaison REST à des fins de test

Créer une application Spring Boot

Déployer le Service A et l’inscrire auprès de Service Registry

Créer une application Azure Spring Apps

Se connecter à Service Registry à partir de l’application

Lier un service à Service Registry

Déployer une application dans Azure Spring Apps

Vérifier que l’application Service A est en cours d’exécution

Implémenter un nouveau Service B qui accède au Service A via Service Registry

Implémenter le Service B avec Spring Boot

Implémenter le Service B en tant que client de Service Registry (client Eureka)

Implémenter des points de terminaison de service dans le Service B

Générer le Service B

Déployer le Service B sur Azure Spring Apps

Appeler le Service A à partir du Service B

Obtenir des informations à partir de Service Registry

Activer/désactiver Service Registry après la création du service

Étapes suivantes

Ressources supplémentaires