Tanzu-serviceregister gebruiken
Notitie
De Basic-, Standard- en Enterprise-abonnementen worden afgeschaft vanaf medio maart 2025, met een pensioenperiode van 3 jaar. We raden u aan om over te stappen naar Azure Container Apps. Zie de aankondiging over buitengebruikstelling van Azure Spring Apps voor meer informatie.
Het standaardverbruik en het speciale abonnement worden vanaf 30 september 2024 afgeschaft, met een volledige afsluiting na zes maanden. We raden u aan om over te stappen naar Azure Container Apps. Zie Azure Spring Apps Standard-verbruik en toegewezen abonnement migreren naar Azure Container Apps voor meer informatie.
Dit artikel is van toepassing op:❌ Basic/Standard ✔️ Enterprise
In dit artikel leest u hoe u VMware Tanzu Service Registry gebruikt met het Azure Spring Apps Enterprise-abonnement.
Tanzu Service Registry is een van de commerciële VMware Tanzu-onderdelen. Met dit onderdeel kunt u het ontwerppatroon voor servicedetectie toepassen op uw toepassingen.
Servicedetectie is een van de belangrijkste ideeën van de microservicesarchitectuur. Zonder servicedetectie moet u elke client van een service handmatig configureren of een vorm van toegangsconventie aannemen. Dit proces kan moeilijk zijn en de configuraties en conventies kunnen in productie broos zijn. In plaats daarvan kunt u het Tanzu-serviceregister gebruiken om geregistreerde services in uw toepassing dynamisch te detecteren en aan te roepen.
met het Azure Spring Apps Enterprise-abonnement hoeft u het serviceregister niet zelf te maken of te starten. U kunt het Tanzu-serviceregister gebruiken door het te selecteren wanneer u uw Azure Spring Apps Enterprise-abonnementexemplaren maakt.
Vereisten
- Een al ingericht Azure Spring Apps Enterprise-planexemplaren waarvoor Tanzu Service Registry is ingeschakeld. Zie quickstart: Apps bouwen en implementeren in Azure Spring Apps met behulp van het Enterprise-abonnement voor meer informatie.
- De Azure Spring Apps Enterprise-abonnementsextensie. Gebruik de volgende opdracht om eerdere versies te verwijderen en de nieuwste Enterprise-abonnementsextensie te installeren. Als u de extensie eerder hebt geïnstalleerd, verwijdert u deze
spring-cloudom te voorkomen dat de configuratie en versie niet overeenkomen.az extension add --upgrade --name spring az extension remove --name spring-cloud
Toepassingen maken die gebruikmaken van Service Registry
In dit artikel maakt u twee services en registreert u deze bij Azure Spring Apps Service Registry. Na de registratie kan de ene service serviceregister gebruiken om de andere service te detecteren en aan te roepen. In het volgende diagram ziet u een overzicht van de vereiste stappen:
Deze stappen worden uitgebreid beschreven in de volgende secties.
- Service A maken.
- Implementeer Service A in Azure Spring Apps en registreer deze bij Service Registry.
- Maak Service B en implementeer deze om Service A aan te roepen.
- Implementeer Service B en registreer deze bij Service Registry.
- Service A aanroepen via service B.
Omgevingsvariabelen maken
In dit artikel worden de volgende omgevingsvariabelen gebruikt. Stel deze variabelen in op de waarden die u hebt gebruikt bij het maken van uw Azure Spring Apps Enterprise-planexemplaren.
| Variabele | Beschrijving |
|---|---|
| $RESOURCE_GROUP | Naam van de resourcegroep. |
| $AZURE_SPRING_APPS_NAME | De naam van het Azure Spring Apps-exemplaar. |
Service A maken met Spring Boot
Navigeer naar Spring Initializr om voorbeeldservice A te maken. Deze koppeling gebruikt de volgende URL om de instellingen te initialiseren.
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
In de volgende schermopname ziet u Spring Initializr met de vereiste instellingen.
Selecteer vervolgens GENERATE om een voorbeeldproject voor Spring Boot op te halen met de volgende mapstructuur.
├── 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
De configuratie van afhankelijke bibliotheken voor de Service Registry-client (Eureka-client) bevestigen
Controleer vervolgens of het pom.xml-bestand voor het project de volgende afhankelijkheid bevat. Voeg de afhankelijkheid toe als deze ontbreekt.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
De Service Registry-client implementeren
Voeg een @EnableEurekaClient aantekening toe aan het SampleServiceAApplication.java-bestand om het te configureren als een Eureka-client.
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);
}
}
Een REST-eindpunt maken voor testen
U kunt de service nu registreren bij serviceregister, maar u kunt deze pas verifiëren als u een service-eindpunt implementeert. Als u RESTful-eindpunten wilt maken die externe services kunnen aanroepen, voegt u een ServiceAEndpoint.java-bestand toe aan uw project met de volgende code.
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;
}
}
Een Spring Boot-toepassing bouwen
Nu u een eenvoudige service hebt, compileert en bouwt u de broncode door de volgende opdracht uit te voeren:
mvn clean package
Service A implementeren en registreren bij serviceregister
In deze sectie wordt uitgelegd hoe u Service A implementeert in een Exemplaar van een Azure Spring Apps Enterprise-abonnement en hoe u deze registreert bij Service Registry.
Een Azure Spring Apps-toepassing maken
Maak eerst een toepassing in Azure Spring Apps met behulp van de volgende opdracht:
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceA \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
Het --assign-endpoint argument verleent een openbaar IP-adres voor validatie en maakt toegang mogelijk vanuit het externe netwerk.
Verbinding maken met het serviceregister vanuit de app
Nadat u een service-exemplaar hebt gemaakt met Spring Boot en een toepassing hebt gemaakt in Azure Spring Apps, implementeert u de toepassing en bevestigt u de bewerking. Daarvoor moet u uw toepassing echter binden aan het serviceregister, zodat deze verbindingsgegevens uit het register kan ophalen.
Normaal gesproken moet een Eureka-client de volgende verbindingsgegevensinstellingen schrijven in het configuratiebestand application.properties van een Spring Boot-toepassing, zodat u verbinding kunt maken met de server:
eureka.client.service-url.defaultZone=http://eureka:8761/eureka/
Als u deze instellingen echter rechtstreeks in uw toepassing schrijft, moet u het project opnieuw bewerken en opnieuw opbouwen telkens wanneer de serviceregisterserver wordt gewijzigd. Om dit te voorkomen, stelt Azure Spring Apps uw toepassingen in staat om verbindingsgegevens op te halen uit het serviceregister door er verbinding mee te maken. Nadat u de toepassing hebt gekoppeld aan het serviceregister, kunt u de verbindingsgegevens van het serviceregister (eureka.client.service-url.defaultZone) ophalen uit de Java-omgevingsvariabele. Op deze manier kunt u verbinding maken met het serviceregister door de inhoud van de omgevingsvariabelen te laden wanneer de toepassing wordt gestart.
In de praktijk worden de volgende omgevingsvariabelen toegevoegd aan de JAVA_TOOL_OPTIONS variabele:
-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Een service binden aan het serviceregister
Gebruik de volgende opdracht om de service te verbinden met Azure Service Registry, zodat deze verbinding kan maken met de server.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceA
U kunt de toepassingsbindingen ook instellen vanuit Azure Portal, zoals wordt weergegeven in de volgende schermopname:
Notitie
Het duurt enkele minuten voordat deze wijzigingen worden doorgegeven aan alle toepassingen wanneer de status van het serviceregister wordt gewijzigd.
Als u de bindingsstatus wijzigt, moet u de toepassing opnieuw starten of opnieuw implementeren.
U kunt er nu voor kiezen om uw toepassing rechtstreeks aan het serviceregister te binden wanneer u een nieuwe app maakt met behulp van de volgende opdrachten:
az spring app create \
--resource-group <resource-group> \
--service <service-name> \
--name <app-name> \
--bind-service-registry
U kunt uw toepassing ook verbinden met het serviceregister vanuit Azure Portal, zoals wordt weergegeven in de volgende schermopname:
Een toepassing implementeren in Azure Spring Apps
Nu u uw toepassing hebt gebonden, implementeert u het Spring Boot-artefactbestand Sample-Service-A-A-0.0.1-SNAPSHOT.jar in Azure Spring Apps. Gebruik de volgende opdracht om te implementeren:
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"
Gebruik de volgende opdracht om te zien of uw implementatie is geslaagd.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Met deze opdracht wordt uitvoer geproduceerd die vergelijkbaar is met het volgende voorbeeld.
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 -
Controleer of de Service A-toepassing wordt uitgevoerd
De uitvoer van de vorige opdracht bevat de openbare URL voor de service. Als u toegang wilt krijgen tot het RESTful-eindpunt, voegt u deze toe aan /serviceA de URL, zoals wordt weergegeven in de volgende opdracht:
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/serviceA
Met deze opdracht wordt de volgende uitvoer gegenereerd.
This is a result of Service A
Service A bevat een RESTful-eindpunt dat een lijst met omgevingsvariabelen weergeeft. Open het eindpunt met /env de omgevingsvariabelen, zoals wordt weergegeven in de volgende opdracht:
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/env
Met deze opdracht wordt de volgende uitvoer gegenereerd.
"JAVA_TOOL_OPTIONS":"-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Zoals u kunt zien, eureka.client.service-url.defaultZone wordt toegevoegd aan JAVA_TOOL_OPTIONS. Op deze manier kan de toepassing de service registreren bij het serviceregister en deze beschikbaar maken vanuit andere services.
U kunt de service nu registreren bij het ServiceRegister (Eureka Server) in Azure Spring Apps. Andere services hebben nu toegang tot de service met behulp van het serviceregister.
Een nieuwe service B implementeren die service A opent via serviceregister
Service B implementeren met Spring Boot
Navigeer naar Spring Initializr om een nieuw project voor Service B te maken. Deze koppeling gebruikt de volgende URL om de instellingen te initialiseren:
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
Selecteer vervolgens GENERATE om het nieuwe project op te halen.
Service B implementeren als een Service Registry-client (Eureka-client)
Voeg net als Service A de @EnableEurekaClient aantekening toe aan Service B om deze te configureren als een Eureka-client.
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);
}
}
Service-eindpunten implementeren in Service B
Implementeer vervolgens een nieuw service-eindpunt (/invoke-serviceA) dat Service A aanroept. Voeg een ServiceBEndpoint.java-bestand toe aan uw project met de volgende code.
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;
}
}
In dit voorbeeld wordt RestTemplate gebruikgemaakt van eenvoud. Het eindpunt retourneert de antwoordtekenreeks met een andere tekenreeks (INVOKE SERVICE A FROM SERVICE B: ") om aan te geven dat deze is aangeroepen door Service B.
In dit voorbeeld wordt ook een ander eindpunt (/list-all) geïmplementeerd voor validatie. Deze implementatie zorgt ervoor dat de service correct communiceert met het serviceregister. U kunt dit eindpunt aanroepen om de lijst met toepassingen op te halen die zijn geregistreerd in het serviceregister.
In dit voorbeeld wordt Service A aangeroepen als http://servicea. De servicenaam is de naam die u hebt opgegeven tijdens het maken van de Azure Spring Apps-toepassing. (Bijvoorbeeld: az spring app create --name ServiceA.) De naam van de toepassing komt overeen met de servicenaam die u hebt geregistreerd bij het serviceregister, zodat u de servicenaam gemakkelijker kunt beheren.
Build Service B
Gebruik de volgende opdracht om uw project te bouwen.
mvn clean package
Service B implementeren in Azure Spring Apps
Gebruik de volgende opdracht om een toepassing te maken in Azure Spring Apps om Service B te implementeren.
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceB \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
Gebruik vervolgens de volgende opdracht om de toepassing te binden aan het serviceregister.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceB
Gebruik vervolgens de volgende opdracht om de service te implementeren.
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"
Gebruik vervolgens de volgende opdracht om de status van de toepassing te controleren.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Als Service A en Service B correct zijn geïmplementeerd, produceert deze opdracht uitvoer die vergelijkbaar is met het volgende voorbeeld.
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 -
Service A aanroepen vanuit service B
De uitvoer van de vorige opdracht bevat de openbare URL voor de service. Als u toegang wilt krijgen tot het RESTful-eindpunt, voegt u deze toe aan /invoke-serviceA de URL, zoals wordt weergegeven in de volgende opdracht:
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/invoke-serviceA
Met deze opdracht wordt de volgende uitvoer gegenereerd:
INVOKE SERVICE A FROM SERVICE B: This is a result of Service A
Informatie ophalen uit het serviceregister
Tot slot opent u het /list-all eindpunt en haalt u enkele gegevens op uit het serviceregister. Met de volgende opdracht wordt een lijst opgehaald met services die zijn geregistreerd in het serviceregister.
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/list-all
Met deze opdracht wordt de volgende uitvoer gegenereerd.
["SERVICEA","EUREKA-SERVER","SERVICEB"]
Op deze manier kunt u zo nodig gedetailleerde informatie van het programma verkrijgen.
Serviceregister in- of uitschakelen na het maken van de service
U kunt Service Registry in- en uitschakelen na het maken van de service met behulp van Azure Portal of Azure CLI. Voordat u serviceregister uitschakelt, moet u al uw apps ervan losmaken.
Gebruik de volgende stappen om Service Registry in of uit te schakelen met behulp van Azure Portal:
- Navigeer naar uw serviceresource en selecteer vervolgens Serviceregister.
- Selecteer Beheren.
- Selecteer of hef de selectie van het serviceregister in of uit en selecteer opslaan.
- U kunt nu de status van het serviceregister bekijken op de pagina Serviceregister .