Använda Tanzu Service Registry
Kommentar
Basic-, Standard- och Enterprise-planerna kommer att vara inaktuella från och med mitten av mars 2025, med en 3-årig pensionsperiod. Vi rekommenderar att du övergår till Azure Container Apps. Mer information finns i meddelandet om azure Spring Apps-pensionering.
Standardförbrukningen och den dedikerade planen kommer att vara inaktuell från och med den 30 september 2024, med en fullständig avstängning efter sex månader. Vi rekommenderar att du övergår till Azure Container Apps. Mer information finns i Migrera Azure Spring Apps Standard-förbrukning och dedikerad plan till Azure Container Apps.
Den här artikeln gäller för: ❎ Basic/Standard ✅ Enterprise
Den här artikeln visar hur du använder VMware Tanzu Service Registry med Azure Spring Apps Enterprise-planen.
Tanzu Service Registry är en av de kommersiella VMware Tanzu-komponenterna. Den här komponenten hjälper dig att använda designmönstret för tjänstidentifiering för dina program.
Tjänstidentifiering är en av huvudidéerna i mikrotjänstarkitekturen. Utan tjänstidentifiering skulle du behöva handkonfigurera varje klient för en tjänst eller anta någon form av åtkomstkonvention. Den här processen kan vara svår och konfigurationerna och konventionerna kan vara spröda i produktionen. I stället kan du använda Tanzu Service Registry för att dynamiskt identifiera och anropa registrerade tjänster i ditt program.
Med Azure Spring Apps Enterprise-planen behöver du inte skapa eller starta tjänstregistret själv. Du kan använda Tanzu Service Registry genom att välja det när du skapar din Azure Spring Apps Enterprise-planinstans.
Förutsättningar
- En redan etablerad Azure Spring Apps Enterprise-planinstans med Tanzu Service Registry aktiverat. Mer information finns i Snabbstart: Skapa och distribuera appar till Azure Spring Apps med hjälp av Enterprise-planen.
- Azure Spring Apps Enterprise-plantillägget. Använd följande kommando för att ta bort tidigare versioner och installera det senaste Enterprise-plantillägget. Om du tidigare har installerat
spring-cloudtillägget avinstallerar du det för att undvika konfigurations- och versionsmatchningar.az extension add --upgrade --name spring az extension remove --name spring-cloud
Skapa program som använder Service Registry
I den här artikeln skapar du två tjänster och registrerar dem med Azure Spring Apps Service Registry. Efter registreringen kan en tjänst använda Service Registry för att identifiera och anropa den andra tjänsten. Följande diagram sammanfattar de steg som krävs:
De här stegen beskrivs mer detaljerat i följande avsnitt.
- Skapa tjänst A.
- Distribuera Service A till Azure Spring Apps och registrera den med Service Registry.
- Skapa service B och implementera den för att anropa Service A.
- Distribuera Service B och registrera den med Service Registry.
- Anropa tjänst A via service B.
Skapa miljövariabler
I den här artikeln används följande miljövariabler. Ange de här variablerna till de värden som du använde när du skapade din Azure Spring Apps Enterprise-planinstans.
| Olika | beskrivning |
|---|---|
| $RESOURCE_GROUP | Namn på resursgrupp. |
| $AZURE_SPRING_APPS_NAME | Azure Spring Apps-instansnamn. |
Skapa service A med Spring Boot
Gå till Spring Initializr för att skapa exempeltjänst A. Den här länken använder följande URL för att initiera inställningarna.
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
Följande skärmbild visar Spring Initializr med nödvändiga inställningar.
Välj sedan GENERERA för att hämta ett exempelprojekt för Spring Boot med följande katalogstruktur.
├── 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
Bekräfta konfigurationen av beroende bibliotek för Service Registry-klienten (Eureka-klienten)
Bekräfta sedan att den pom.xml filen för projektet innehåller följande beroende. Lägg till beroendet om det saknas.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
Implementera Service Registry-klienten
Lägg till en @EnableEurekaClient anteckning i filen SampleServiceAApplication.java för att konfigurera den som en Eureka-klient.
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);
}
}
Skapa en REST-slutpunkt för testning
Nu kan du registrera tjänsten till Service Registry, men du kan inte verifiera den förrän du implementerar en tjänstslutpunkt. Om du vill skapa RESTful-slutpunkter som externa tjänster kan anropa lägger du till en ServiceAEndpoint.java fil i projektet med följande kod.
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;
}
}
Skapa en Spring Boot-app
Nu när du har en enkel tjänst kompilerar och skapar du källkoden genom att köra följande kommando:
mvn clean package
Distribuera tjänst A och registrera med Service Registry
Det här avsnittet beskriver hur du distribuerar Service A till en Azure Spring Apps Enterprise-planinstans och registrerar den med Service Registry.
Skapa ett Azure Spring Apps-program
Skapa först ett program i Azure Spring Apps med hjälp av följande kommando:
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceA \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
Argumentet --assign-endpoint beviljar en offentlig IP-adress för validering och ger åtkomst från det externa nätverket.
Ansluta till tjänstregistret från appen
När du har skapat en tjänstinstans med Spring Boot och skapat ett program i Azure Spring Apps distribuerar du programmet och bekräftar åtgärden. Innan dess måste du dock binda programmet till tjänstregistret så att det kan hämta anslutningsinformation från registret.
Vanligtvis måste en Eureka-klient skriva följande inställningar för anslutningsinformation i konfigurationsfilen application.properties för ett Spring Boot-program så att du kan ansluta till servern:
eureka.client.service-url.defaultZone=http://eureka:8761/eureka/
Men om du skriver de här inställningarna direkt i ditt program måste du redigera om och återskapa projektet igen varje gång Service Registry-servern ändras. För att undvika detta gör Azure Spring Apps det möjligt för dina program att hämta anslutningsinformation från tjänstregistret genom att binda till det. När du har bindt programmet till Service Registry kan du hämta anslutningsinformationen för tjänstregistret (eureka.client.service-url.defaultZone) från Java-miljövariabeln. På så sätt kan du ansluta till tjänstregistret genom att läsa in innehållet i miljövariablerna när programmet startar.
I praktiken läggs följande miljövariabler till i variabeln JAVA_TOOL_OPTIONS :
-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Binda en tjänst till tjänstregistret
Använd följande kommando för att binda tjänsten till Azure Service Registry så att den kan ansluta till servern.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceA
Du kan också konfigurera programbindningarna från Azure Portal, enligt följande skärmbild:
Kommentar
De här ändringarna tar några minuter att sprida till alla program när tjänstens registerstatus ändras.
Om du ändrar bindnings-/avbindningsstatusen måste du starta om eller distribuera om programmet.
Nu kan du välja att binda programmet till tjänstregistret direkt när du skapar en ny app med hjälp av följande kommandon:
az spring app create \
--resource-group <resource-group> \
--service <service-name> \
--name <app-name> \
--bind-service-registry
Du kan också binda ditt program till tjänstregistret från Azure Portal, enligt följande skärmbild:
Distribuera ett program till Azure Spring Apps
Nu när du har bundit programmet distribuerar du Spring Boot-artefaktfilen Sample-Service-A-A-0.0.1-SNAPSHOT.jar till Azure Spring Apps. Använd följande kommando för att distribuera:
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"
Använd följande kommando för att se om distributionen lyckas.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Det här kommandot genererar utdata som liknar följande exempel.
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 -
Bekräfta att Service A-programmet körs
Utdata från föregående kommando innehåller den offentliga URL:en för tjänsten. Om du vill komma åt RESTful-slutpunkten lägger du /serviceA till url:en enligt följande kommando:
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/serviceA
Det här kommandot genererar följande utdata.
This is a result of Service A
Service A innehåller en RESTful-slutpunkt som visar en lista över miljövariabler. Få åtkomst till slutpunkten med /env för att se miljövariablerna, som du ser i följande kommando:
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/env
Det här kommandot genererar följande utdata.
"JAVA_TOOL_OPTIONS":"-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Som du ser eureka.client.service-url.defaultZone läggs till i JAVA_TOOL_OPTIONS. På så sätt kan programmet registrera tjänsten i tjänstregistret och göra den tillgänglig från andra tjänster.
Nu kan du registrera tjänsten i Service Registry (Eureka Server) i Azure Spring Apps. Andra tjänster kan nu komma åt tjänsten med hjälp av tjänstregistret.
Implementera en ny tjänst B som har åtkomst till Service A via Service Registry
Implementera Service B med Spring Boot
Gå till Spring Initializr för att skapa ett nytt projekt för Service B. Den här länken använder följande URL för att initiera inställningarna:
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
Välj sedan GENERERA för att hämta det nya projektet.
Implementera Service B som en tjänstregisterklient (Eureka-klient)
Precis som Service A lägger du till anteckningen @EnableEurekaClient i Service B för att konfigurera den som en Eureka-klient.
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);
}
}
Implementera tjänstslutpunkter i Service B
Implementera sedan en ny tjänstslutpunkt (/invoke-serviceA) som anropar Tjänst A. Lägg till en ServiceBEndpoint.java fil i projektet med följande kod.
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;
}
}
Det här exemplet används RestTemplate för enkelhetens skull. Slutpunkten returnerar svarssträngen med en annan sträng (INVOKE SERVICE A FROM SERVICE B: ") för att indikera att den anropades av Service B.
Det här exemplet implementerar också en annan slutpunkt (/list-all) för validering. Den här implementeringen säkerställer att tjänsten kommunicerar korrekt med tjänstregistret. Du kan anropa den här slutpunkten för att hämta listan över program som är registrerade i tjänstregistret.
I det här exemplet anropas Service A som http://servicea. Tjänstnamnet är det namn som du angav när du skapade Azure Spring Apps-programmet. (Till exempel: az spring app create --name ServiceA.) Programnamnet matchar tjänstnamnet som du registrerade i tjänstregistret, vilket gör det enklare att hantera tjänstnamnet.
Skapa tjänst B
Använd följande kommando för att skapa projektet.
mvn clean package
Distribuera Service B till Azure Spring Apps
Använd följande kommando för att skapa ett program i Azure Spring Apps för att distribuera Service B.
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceB \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
Använd sedan följande kommando för att binda programmet till tjänstregistret.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceB
Använd sedan följande kommando för att distribuera tjänsten.
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"
Använd sedan följande kommando för att kontrollera programmets status.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Om Service A och Service B distribueras korrekt genererar det här kommandot utdata som liknar följande exempel.
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 -
Anropa tjänst A från tjänst B
Utdata från föregående kommando innehåller den offentliga URL:en för tjänsten. Om du vill komma åt RESTful-slutpunkten lägger du /invoke-serviceA till url:en enligt följande kommando:
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/invoke-serviceA
Det här kommandot genererar följande utdata:
INVOKE SERVICE A FROM SERVICE B: This is a result of Service A
Hämta lite information från Service Registry
Slutligen får du åtkomst till /list-all slutpunkten och hämtar viss information från tjänstregistret. Följande kommando hämtar en lista över tjänster som är registrerade i tjänstregistret.
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/list-all
Det här kommandot genererar följande utdata.
["SERVICEA","EUREKA-SERVER","SERVICEB"]
På så sätt kan du få detaljerad information från programmet efter behov.
Aktivera/inaktivera Tjänstregister när tjänsten har skapats
Du kan aktivera och inaktivera Service Registry när tjänsten har skapats med hjälp av Azure Portal eller Azure CLI. Innan du inaktiverar Service Registry måste du avbinda alla dina appar från det.
Använd följande steg för att aktivera eller inaktivera Service Registry med hjälp av Azure Portal:
- Gå till tjänstresursen och välj sedan Tjänstregister.
- Välj Hantera.
- Välj eller avmarkera Aktivera tjänstregister och välj sedan Spara.
- Nu kan du visa tillståndet för Service Registry på sidan Service Registry .