Usare il Registro di sistema del servizio Tanzu
Nota
I piani Basic, Standard ed Enterprise saranno deprecati a partire dalla metà di marzo 2025, con un periodo di ritiro di 3 anni. È consigliabile eseguire la transizione ad App Azure Container. Per altre informazioni, vedere l'annuncio di ritiro di Azure Spring Apps.
Il piano Standard a consumo e dedicato sarà deprecato a partire dal 30 settembre 2024, con un arresto completo dopo sei mesi. È consigliabile eseguire la transizione ad App Azure Container. Per altre informazioni, vedere Eseguire la migrazione del consumo di Azure Spring Apps Standard e del piano dedicato alle app Azure Container.
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.
- Creare il servizio A.
- Distribuire il servizio A in App Spring di Azure e registrarlo nel Registro di sistema dei servizi.
- Creare il servizio B e implementarlo per chiamare il servizio A.
- Distribuire il servizio B e registrarlo nel Registro di sistema dei servizi.
- 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.
| Variabile | Descrizione |
|---|---|
| $RESOURCE_GROUP | Nome del gruppo di risorse. |
| $AZURE_SPRING_APPS_NAME | Nome dell'istanza 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:
Nota
Queste modifiche richiederanno alcuni minuti per propagarsi a tutte le applicazioni quando lo stato del Registro di sistema del servizio cambia.
Se si modifica lo stato di associazione/annullamento dell'associazione, è necessario riavviare o ridistribuire l'applicazione.
È 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.
Usare la procedura seguente per abilitare o disabilitare il Registro di sistema dei servizi usando il portale di Azure:
- Passare alla risorsa del servizio e quindi selezionare Registro di sistema dei servizi.
- Seleziona Gestisci.
- Selezionare o deselezionare Abilita Registro di sistema del servizio e quindi selezionare Salva.
- È ora possibile visualizzare lo stato del Registro di sistema del servizio nella pagina Registro di sistema dei servizi.