Usare il Registro di sistema del servizio Tanzu

Questo articolo si applica a: ❎ Basic/Standard ✅ Enterprise

Questo articolo illustra come usare il Registro di sistema dei servizi VMware Tanzu con il piano Enterprise di Azure Spring Apps.

Tanzu Service Registry è uno dei componenti commerciali di VMware Tanzu. Questo componente consente di applicare il modello di progettazione di individuazione dei servizi alle applicazioni.

L'individuazione dei servizi è una delle idee principali dell'architettura dei microservizi. Senza l'individuazione dei servizi, è necessario configurare a mano ogni client di un servizio o adottare una forma di convenzione di accesso. Questo processo può essere difficile e le configurazioni e le convenzioni possono essere fragili nell'ambiente di produzione. È invece possibile usare il Registro di sistema del servizio Tanzu per individuare e richiamare dinamicamente i servizi registrati nell'applicazione.

con il piano Enterprise di Azure Spring Apps non è necessario creare o avviare manualmente il Registro di sistema dei servizi. È possibile usare il Registro di sistema del servizio Tanzu selezionandolo quando si crea l'istanza del piano Enterprise di Azure Spring Apps.

Prerequisiti

• Un'istanza del piano Enterprise di Azure Spring Apps già con Tanzu Service Registry abilitata. Per altre informazioni, vedere Avvio rapido: Creare e distribuire app in Azure Spring Apps usando il piano Enterprise.
• Estensione del piano Enterprise di Azure Spring Apps. Usare il comando seguente per rimuovere le versioni precedenti e installare l'estensione del piano Enterprise più recente. Se l'estensione spring-cloud è stata installata in precedenza, disinstallarla per evitare la mancata corrispondenza della configurazione e della versione.

  az extension add --upgrade --name spring
  az extension remove --name spring-cloud
  

Creare applicazioni che usano il Registro di sistema dei servizi

In questo articolo vengono creati due servizi e registrati nel Registro di sistema del servizio Azure Spring Apps. Dopo la registrazione, un servizio sarà in grado di usare il Registro di sistema dei servizi per individuare e richiamare l'altro servizio. Il diagramma seguente riepiloga i passaggi necessari:

Questi passaggi vengono descritti in modo più dettagliato nelle sezioni seguenti.

1. Creare il servizio A.
2. Distribuire il servizio A in App Spring di Azure e registrarlo nel Registro di sistema dei servizi.
3. Creare il servizio B e implementarlo per chiamare il servizio A.
4. Distribuire il servizio B e registrarlo nel Registro di sistema dei servizi.
5. Richiamare il servizio A tramite il servizio B.

Creare variabili di ambiente

Questo articolo usa le variabili di ambiente seguenti. Impostare queste variabili sui valori usati quando è stata creata l'istanza del piano Enterprise di Azure Spring Apps.

Creare un servizio A con Spring Boot

Passare a Spring Initializr per creare il servizio A di esempio. Questo collegamento usa l'URL seguente per inizializzare le impostazioni.

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

Lo screenshot seguente mostra Spring Initializr con le impostazioni necessarie.

Selezionare quindi GENERA per ottenere un progetto di esempio per Spring Boot con la struttura di directory seguente.

├── 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

Verificare la configurazione delle librerie dipendenti per il client del Registro di sistema dei servizi (client Eureka)

Verificare quindi che il file di pom.xml per il progetto contenga la dipendenza seguente. Aggiungere la dipendenza, se mancante.

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

Implementare il client del Registro di sistema dei servizi

Aggiungere un'annotazione @EnableEurekaClient al file SampleServiceAApplication.java per configurarla come 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);
    }
}

Creare un endpoint REST per il test

È ora possibile registrare il servizio nel Registro di sistema dei servizi, ma non è possibile verificarlo fino a quando non si implementa un endpoint di servizio. Per creare endpoint RESTful che i servizi esterni possono chiamare, aggiungere un file ServiceAEndpoint.java al progetto con il codice seguente.

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;
    }
}

Creare un'applicazione Spring Boot

Ora che si dispone di un servizio semplice, compilare e compilare il codice sorgente eseguendo il comando seguente:

mvn clean package

Distribuire il servizio A e registrarsi con registro dei servizi

Questa sezione illustra come distribuire il servizio A in un'istanza del piano Enterprise di Azure Spring Apps e registrarla nel Registro di sistema dei servizi.

Creare un'applicazione Azure Spring Apps

Creare prima di tutto un'applicazione in Azure Spring Apps usando il comando seguente:

az spring app create \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME  \
    --name serviceA \
    --instance-count 1 \
    --memory 2Gi \
    --assign-endpoint

L'argomento --assign-endpoint concede un indirizzo IP pubblico per la convalida e abilita l'accesso dalla rete esterna.

Connettersi al Registro di sistema del servizio dall'app

Dopo aver creato un'istanza del servizio con Spring Boot e aver creato un'applicazione in Azure Spring Apps, distribuire l'applicazione e confermare l'operazione. Prima di questo, tuttavia, è necessario associare l'applicazione al Registro di sistema dei servizi in modo che possa ottenere informazioni di connessione dal Registro di sistema.

In genere, un client Eureka deve scrivere le seguenti impostazioni di informazioni di connessione nel file di configurazione application.properties di un'applicazione Spring Boot in modo che sia possibile connettersi al server:

eureka.client.service-url.defaultZone=http://eureka:8761/eureka/

Tuttavia, se si scrivono queste impostazioni direttamente nell'applicazione, è necessario modificare e ricompilare nuovamente il progetto ogni volta che il server del Registro di sistema del servizio cambia. Per evitare questo sforzo, Azure Spring Apps consente alle applicazioni di ottenere informazioni di connessione dal Registro di sistema del servizio tramite l'associazione. In particolare, dopo l'associazione dell'applicazione al Registro di sistema dei servizi, è possibile ottenere le informazioni di connessione del Registro di sistema del servizio (eureka.client.service-url.defaultZone) dalla variabile di ambiente Java. In questo modo, è possibile connettersi al Registro di sistema del servizio caricando il contenuto delle variabili di ambiente all'avvio dell'applicazione.

In pratica, alla variabile vengono aggiunte JAVA_TOOL_OPTIONS le variabili di ambiente seguenti:

-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka

Associare un servizio al Registro di sistema dei servizi

Usare il comando seguente per associare il servizio a Registro servizi di Azure, abilitandolo per la connessione al server.

az spring service-registry bind \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --app serviceA

È anche possibile configurare le associazioni dell'applicazione dal portale di Azure, come illustrato nello screenshot seguente:

È ora possibile scegliere di associare l'applicazione direttamente al Registro di sistema del servizio quando si crea una nuova app usando i comandi seguenti:

az spring app create \
    --resource-group <resource-group> \
    --service <service-name> \
    --name <app-name> \
    --bind-service-registry

È anche possibile associare l'applicazione al Registro di sistema dei servizi dal portale di Azure, come illustrato nello screenshot seguente:

Distribuire un'applicazione in Azure Spring Apps

Dopo aver associato l'applicazione, distribuire il file dell'artefatto Spring Boot Sample-Service-A-A-0.0.1-SNAPSHOT.jar ad Azure Spring Apps. Per eseguire la distribuzione, usare il comando seguente:

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"

Usare il comando seguente per verificare se la distribuzione ha esito positivo.

az spring app list \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --output table

Questo comando genera un output simile all'esempio seguente.

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                  -

Verificare che l'applicazione Service A sia in esecuzione

L'output del comando precedente include l'URL pubblico per il servizio. Per accedere all'endpoint RESTful, aggiungere /serviceA all'URL, come illustrato nel comando seguente:

curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/serviceA

Questo comando genera l'output seguente.

This is a result of Service A

Il servizio A include un endpoint RESTful che visualizza un elenco di variabili di ambiente. Accedere all'endpoint con /env per visualizzare le variabili di ambiente, come illustrato nel comando seguente:

curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/env

Questo comando genera l'output seguente.

"JAVA_TOOL_OPTIONS":"-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka

Come si può notare, eureka.client.service-url.defaultZone viene aggiunto a JAVA_TOOL_OPTIONS. In questo modo, l'applicazione può registrare il servizio nel Registro di sistema dei servizi e renderlo disponibile da altri servizi.

È ora possibile registrare il servizio nel Registro di sistema dei servizi (server Eureka) in Azure Spring Apps. Altri servizi possono ora accedere al servizio usando il Registro di sistema del servizio.

Implementare un nuovo servizio B che accede al servizio A tramite il Registro di sistema del servizio

Implementare il servizio B con Spring Boot

Passare a Spring Initializr per creare un nuovo progetto per il servizio B. Questo collegamento usa l'URL seguente per inizializzare le impostazioni:

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

Selezionare quindi GENERA per ottenere il nuovo progetto.

Implementare il servizio B come client del Registro di sistema dei servizi (client Eureka)

Come il servizio A, aggiungere l'annotazione @EnableEurekaClient al servizio B per configurarla come 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);
    }
}

Implementare gli endpoint di servizio nel servizio B

Implementare quindi un nuovo endpoint di servizio (/invoke-serviceA) che richiama il servizio A. Aggiungere un file ServiceBEndpoint.java al progetto con il codice seguente.

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;
    }
}

Questo esempio usa RestTemplate per semplicità. L'endpoint restituisce la stringa di risposta con un'altra stringa (INVOKE SERVICE A FROM SERVICE B: ") per indicare che è stata chiamata dal servizio B.

Questo esempio implementa anche un altro endpoint (/list-all) per la convalida. Questa implementazione garantisce che il servizio comunichi correttamente con il Registro di sistema dei servizi. È possibile chiamare questo endpoint per ottenere l'elenco delle applicazioni registrate nel Registro di sistema dei servizi.

In questo esempio viene richiamato il servizio A come http://servicea. Il nome del servizio è il nome specificato durante la creazione dell'applicazione Azure Spring Apps. (Ad esempio: az spring app create --name ServiceA.) Il nome dell'applicazione corrisponde al nome del servizio registrato con il Registro di sistema del servizio, semplificando la gestione del nome del servizio.

Servizio di compilazione B

Usare il comando seguente per compilare il progetto.

mvn clean package

Distribuire il servizio B in App Spring di Azure

Usare il comando seguente per creare un'applicazione in Azure Spring Apps per distribuire il servizio B.

az spring app create \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --name serviceB \
    --instance-count 1 \
    --memory 2Gi \
    --assign-endpoint

Usare quindi il comando seguente per associare l'applicazione al Registro di sistema del servizio.

az spring service-registry bind \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --app serviceB

Usare quindi il comando seguente per distribuire il servizio.

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"

Usare quindi il comando seguente per controllare lo stato dell'applicazione.

az spring app list \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --output table

Se il servizio A e il servizio B vengono distribuiti correttamente, questo comando genera un output simile all'esempio seguente.

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                  -

Richiamare il servizio A dal servizio B

L'output del comando precedente include l'URL pubblico per il servizio. Per accedere all'endpoint RESTful, aggiungere /invoke-serviceA all'URL, come illustrato nel comando seguente:

curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/invoke-serviceA

Questo comando produce l'output seguente:

INVOKE SERVICE A FROM SERVICE B: This is a result of Service A

Ottenere alcune informazioni dal Registro di sistema dei servizi

Infine, accedere all'endpoint /list-all e recuperare alcune informazioni dal Registro di sistema del servizio. Il comando seguente recupera un elenco di servizi registrati nel Registro di sistema dei servizi.

curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/list-all

Questo comando genera l'output seguente.

["SERVICEA","EUREKA-SERVER","SERVICEB"]

In questo modo, è possibile ottenere informazioni dettagliate dal programma in base alle esigenze.

Abilitare/disabilitare il Registro di sistema del servizio dopo la creazione del servizio

È possibile abilitare e disabilitare registro dei servizi dopo la creazione del servizio usando il portale di Azure o l'interfaccia della riga di comando di Azure. Prima di disabilitare il Registro di sistema del servizio, è necessario annullare l'associazione di tutte le app.

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>

Passaggi successivi

• Creare ruoli e autorizzazioni