Verwenden der Tanzu-Dienstregistrierung
Hinweis
Azure Spring Apps ist der neue Name für den Azure Spring Cloud-Dienst. Obwohl der Dienst umbenannt wurde, wird der alte Name noch an einigen Stellen verwendet, solange wir Ressourcen wie Screenshots, Videos und Diagramme aktualisieren.
Dieser Artikel gilt für:❌ Basic/Standard ✔️ Enterprise
In diesem Artikel erfahren Sie, wie Sie die VMware Tanzu-Dienstregistrierung mit Azure Spring Apps Enterprise verwenden.
Die Tanzu-Dienstregistrierung ist eine der kommerziellen Tanzu-Komponenten von VMware. Diese Komponente hilft Ihnen, das Entwurfsmuster Dienstermittlung auf Ihre Anwendungen anzuwenden.
Die Dienstermittlung ist eins der wichtigsten Konzepte der Microservices-Architektur. Ohne Dienstermittlung müssten Sie jeden Client eines Diensts manuell konfigurieren oder eine Form der Zugriffskonvention einführen. Dieser Prozess kann schwierig sein, und die Konfigurationen und Konventionen können in der Produktion unhandlich sein. Stattdessen können Sie die Tanzu-Dienstregistrierung verwenden, um registrierte Dienste in Ihrer Anwendung dynamisch zu ermitteln und aufzurufen.
Mit Azure Spring Apps Enterprise müssen Sie die Dienstregistrierung nicht selbst erstellen oder starten. Sie können die Tanzu-Dienstregistrierung verwenden, indem Sie sie auswählen, wenn Sie Ihre Instanz von Azure Spring Apps Enterprise erstellen.
Voraussetzungen
- Eine bereits bereitgestellte Instanz von Azure Spring Apps Enterprise mit aktivierter Tanzu-Dienstregistrierung. Weitere Informationen finden Sie unter Schnellstart: Erstellen und Bereitstellen von Anwendungen in Azure Spring Apps mit dem Enterprise Plan.
- Die Erweiterung des Azure Spring Apps Enterprise-Plans. Verwenden Sie den folgenden Befehl, um frühere Versionen zu entfernen und die neueste Erweiterung des Enterprise-Plans zu installieren. Wenn Sie zuvor die
spring-cloud-Erweiterung installiert hatten, deinstallieren Sie diese Erweiterung, um Konfigurations- und Versionskonflikte zu vermeiden.az extension add --upgrade --name spring az extension remove --name spring-cloud
Erstellen von Anwendungen, die die Dienstregistrierung verwenden
In diesem Artikel erstellen Sie zwei Dienste und registrieren sie bei der Azure Spring Apps-Dienstregistrierung. Nach der Registrierung kann ein Dienst die Dienstregistrierung verwenden, um den anderen Dienst zu ermitteln und aufzurufen. Im folgenden Diagramm werden die erforderlichen Schritte zusammenfassend dargestellt:
Diese Schritte werden in den folgenden Abschnitten ausführlicher beschrieben.
- Erstellen von Dienst A.
- Bereitstellen von Dienst A in Azure Spring Apps und Registrieren des Diensts bei der Dienstregistrierung.
- Erstellen von Dienst B und Implementieren, dass er Dienst A aufruft.
- Bereitstellen von Dienst B und Registrieren des Diensts bei der Dienstregistrierung.
- Aufrufen von Dienst A durch Dienst B.
Erstellen von Umgebungsvariablen
In diesem Artikel werden die folgenden Umgebungsvariablen verwendet. Legen Sie diese Variablen auf die Werte fest, die Sie beim Erstellen Ihrer Instanz von Azure Spring Apps Enterprise verwendet haben.
| Variable | Beschreibung |
|---|---|
| $RESOURCE_GROUP | Ressourcengruppenname |
| $AZURE_SPRING_APPS_NAME | Name der Azure Spring Apps-Instanz. |
Erstellen von Dienst A mit Spring Boot
Navigieren Sie zu Spring Initializr, um den Beispieldienst A zu erstellen. Dieser Link verwendet die folgende URL, um die Einstellungen zu initialisieren.
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
Der folgende Screenshot zeigt Spring Initializr mit den erforderlichen Einstellungen.
Wählen Sie dann GENERIEREN aus, um ein Beispielprojekt für Spring Boot mit der folgenden Verzeichnisstruktur zu erhalten.
├── 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
Bestätigen Sie die Konfiguration abhängiger Bibliotheken für den Dienstregistrierungsclient (Eureka-Client)
Vergewissern Sie sich als Nächstes, dass die Datei pom.xml für das Projekt die folgende Abhängigkeit enthält. Fügen Sie die Abhängigkeit hinzu, falls sie fehlt.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
Implementieren des Dienstregistrierungsclients
Fügen Sie der Datei SampleServiceAApplication.java die Anmerkung @EnableEurekaClient hinzu, um sie als Eureka-Client zu konfigurieren.
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);
}
}
Erstellen eines REST-Endpunkts zum Testen
Sie können den Dienst jetzt bei der Dienstregistrierung registrieren, aber Sie können ihn erst überprüfen, wenn Sie einen Dienstendpunkt implementiert haben. Um RESTful-Endpunkte zu erstellen, die externe Dienste aufrufen können, fügen Sie ihrem Projekt mit dem folgenden Code eine ServiceAEndpoint.java-Datei hinzu.
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;
}
}
Erstellen einer Spring Boot-Anwendung
Nachdem Sie nun über einen einfachen Dienst verfügen, kompilieren und erstellen Sie den Quellcode, indem Sie den folgenden Befehl ausführen:
mvn clean package
Bereitstellen von Dienst A und Registrieren der Dienstregistrierung
In diesem Abschnitt wird erläutert, wie Sie Dienst A in der Azure Spring Apps Enterprise-Instanz bereitstellen und in der Dienstregistrierung registrieren.
Erstellen einer Azure Spring Apps-Anwendung
Erstellen Sie zunächst eine Anwendung in Azure Spring Apps mithilfe des folgenden Befehls:
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceA \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
Das Argument --assign-endpoint gewährt eine öffentliche IP-Adresse zur Überprüfung und ermöglicht den Zugriff über das externe Netzwerk.
Herstellen einer Verbindung mit der Dienstregistrierung aus der App
Nachdem Sie eine Dienstinstanz mit Spring Boot erstellt und eine Anwendung in Azure Spring Apps erstellt haben, stellen Sie die Anwendung bereit und bestätigen Sie den Vorgang. Davor müssen Sie Ihre Anwendung jedoch an die Dienstregistrierung binden, damit sie Verbindungsinformationen aus der Registrierung abrufen kann.
Normalerweise muss ein Eureka-Client die folgenden Verbindungsinformationseinstellungen in die Konfigurationsdatei application.properties einer Spring Boot-Anwendung schreiben, damit Sie eine Verbindung mit dem Server herstellen können:
eureka.client.service-url.defaultZone=http://eureka:8761/eureka/
Wenn Sie diese Einstellungen jedoch direkt in Ihrer Anwendung schreiben, müssen Sie das Projekt jedes Mal erneut bearbeiten und neu erstellen, wenn sich der Dienstregistrierungsserver ändert. Um diesen Aufwand zu vermeiden, ermöglicht Azure Spring Apps Ihren Anwendungen das Abrufen von Verbindungsinformationen aus der Dienstregistrierung, indem sie an sie gebunden werden. Insbesondere können Sie nach dem Binden der Anwendung an die Dienstregistrierung die Dienstregistrierungs-Verbindungsinformationen (eureka.client.service-url.defaultZone) aus der Java-Umgebungsvariable abrufen. Auf diese Weise können Sie eine Verbindung mit der Dienstregistrierung herstellen, indem Sie den Inhalt der Umgebungsvariablen laden, wenn die Anwendung gestartet wird.
In der Praxis werden die folgenden Umgebungsvariablen der Variablen JAVA_TOOL_OPTIONS hinzugefügt:
-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Binden eines Diensts an die Dienstregistrierung
Verwenden Sie den folgenden Befehl, um den Dienst an die Azure-Dienstregistrierung zu binden und ihm so das Herstellen einer Verbindung mit dem Server zu ermöglichen.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceA
Sie können die Anwendungsbindungen auch über das Azure-Portal einrichten, wie im folgenden Screenshot gezeigt:
Hinweis
Die Weitergabe dieser Änderungen an alle Anwendungen dauert einige Minuten, wenn sich der Dienstregistrierungsstatus ändert.
Wenn Sie den Bindungs-/Nichtbindungsstatus ändern, müssen Sie die Anwendung neu starten oder erneut bereitstellen.
Sie können ihre Anwendung jetzt direkt beim Erstellen einer neuen App mithilfe der folgenden Befehle an die Dienstregistrierung binden:
az spring app create \
--resource-group <resource-group> \
--service <service-name> \
--name <app-name> \
--bind-service-registry
Sie können Ihre Anwendung auch über das Azure-Portal an die Dienstregistrierung binden, wie im folgenden Screenshot gezeigt:
Bereitstellen einer Anwendung in Azure Spring Apps
Nachdem Sie Ihre Anwendung gebunden haben, stellen Sie die Spring Boot-Artefaktdatei Sample-Service-A-0.0.1-SNAPSHOT.jar in Azure Spring Apps bereit. Zum Bereitstellen verwenden Sie den folgenden Befehl:
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"
Verwenden Sie den folgenden Befehl, um festzustellen, ob Ihre Bereitstellung erfolgreich war.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Dieser Befehl erzeugt eine Ausgabe ähnlich wie im folgenden Beispiel.
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 -
Bestätigen, dass die „Dienst A“-Anwendung ausgeführt wird
Die Ausgabe des vorherigen Befehls enthält die öffentliche URL für den Dienst. Um auf den RESTful-Endpunkt zuzugreifen, fügen Sie der URL /serviceA an, wie im folgenden Befehl dargestellt:
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/serviceA
Dieser Befehl erzeugt die folgende Ausgabe.
This is a result of Service A
Dienst A umfasst einen RESTful-Endpunkt, der eine Liste mit Umgebungsvariablen anzeigt. Greifen Sie mit /env auf den Endpunkt zu, um die Umgebungsvariablen anzuzeigen, wie im folgenden Befehl dargestellt:
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/env
Dieser Befehl erzeugt die folgende Ausgabe.
"JAVA_TOOL_OPTIONS":"-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Wie Sie sehen können, wird eureka.client.service-url.defaultZone zu JAVA_TOOL_OPTIONS hinzugefügt. Auf diese Weise kann die Anwendung den Dienst in der Dienstregistrierung registrieren und ihn für andere Dienste verfügbar machen.
Sie können den Dienst jetzt bei der Dienstregistrierung (Eureka-Server) in Azure Spring Apps registrieren. Andere Dienste können jetzt über die Dienstregistrierung auf den Dienst zugreifen.
Implementieren eines neuen Dienst B, der über die Dienstregistrierung auf Dienst A zugreift
Implementieren von Dienst B mit Spring Boot
Navigieren Sie zu Spring Initializr, um ein neues Projekt für Dienst B zu erstellen. Dieser Link verwendet die folgende URL, um die Einstellungen zu initialisieren:
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
Wählen Sie dann GENERIEREN aus, um das neue Projekt zu erhalten.
Implementieren von Dienst B als Dienstregistrierungsclient (Eureka-Client)
Fügen Sie wie bei Dienst A die Anmerkung @EnableEurekaClient zu Dienst B hinzu, um ihn als Eureka-Client zu konfigurieren.
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);
}
}
Implementieren von Dienstendpunkten in Dienst B
Implementieren Sie als Nächstes einen neuen Dienstendpunkt (/invoke-serviceA), der Dienst A aufruft. Fügen Sie Ihrem Projekt eine ServiceBEndpoint.java-Datei mit dem folgenden Code hinzu.
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;
}
}
Der Einfachheit halber wird in diesem Beispiel RestTemplate verwendet. Der Endpunkt gibt die Antwortzeichenfolge mit einer anderen Zeichenfolge (INVOKE SERVICE A FROM SERVICE B: ") zurück, um anzuzeigen, dass sie von Dienst B aufgerufen wurde.
In diesem Beispiel wird auch ein anderer Endpunkt (/list-all) für die Überprüfung implementiert. Diese Implementierung stellt sicher, dass der Dienst ordnungsgemäß mit der Dienstregistrierung kommuniziert. Sie können diesen Endpunkt aufrufen, um die Liste der Anwendungen abzurufen, die in der Dienstregistrierung registriert sind.
In diesem Beispiel wird Dienst A als http://servicea aufgerufen. Der Dienstname ist der Name, den Sie während der Erstellung der Azure Spring Apps-Anwendung angegeben haben. (Beispiel: az spring app create --name ServiceA.) Der Anwendungsname stimmt mit dem Dienstnamen überein, den Sie bei der Dienstregistrierung registriert haben, was die Verwaltung des Dienstnamens vereinfacht.
Erstellen von Dienst B
Verwenden Sie den folgenden Befehl, um Ihr Projekt zu erstellen.
mvn clean package
Bereitstellen von Dienst B in Azure Spring Apps
Verwenden Sie den folgenden Befehl, um eine Anwendung in Azure Spring Apps zum Bereitstellen von Dienst B zu erstellen.
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceB \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
Verwenden Sie als Nächstes den folgenden Befehl, um die Anwendung an die Dienstregistrierung zu binden.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceB
Verwenden Sie dann den folgenden Befehl, um den Dienst bereitzustellen.
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"
Verwenden Sie als Nächstes den folgenden Befehl, um den Status der Anwendung zu überprüfen.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Wenn Dienst A und Dienst B ordnungsgemäß bereitgestellt werden, erzeugt dieser Befehl eine Ausgabe ähnlich wie im folgenden Beispiel.
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 -
Aufrufen von Dienst A aus Dienst B
Die Ausgabe des vorherigen Befehls enthält die öffentliche URL für den Dienst. Um auf den RESTful-Endpunkt zuzugreifen, fügen Sie der URL /invoke-serviceA an, wie im folgenden Befehl dargestellt:
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/invoke-serviceA
Dieser Befehl erstellt die folgende Ausgabe:
INVOKE SERVICE A FROM SERVICE B: This is a result of Service A
Abrufen von Informationen aus der Dienstregistrierung
Greifen Sie schließlich auf den /list-all-Endpunkt zu, und rufen Sie Informationen aus der Dienstregistrierung ab. Der folgende Befehl ruft eine Liste der Dienste ab, die in der Dienstregistrierung registriert sind.
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/list-all
Dieser Befehl erzeugt die folgende Ausgabe.
["SERVICEA","EUREKA-SERVER","SERVICEB"]
Auf diese Weise können Sie nach Bedarf detaillierte Informationen aus dem Programm abrufen.
Aktivieren/Deaktivieren der Dienstregistrierung nach der Diensterstellung
Sie können die Dienstregistrierung nach der Diensterstellung über das Azure-Portal oder die Azure CLI aktivieren und deaktivieren. Bevor Sie die Dienstregistrierung deaktivieren, müssen Sie alle Apps herauslösen.
Verwenden Sie die folgenden Schritte, um die Dienstregistrierung mithilfe des Azure-Portals zu aktivieren oder zu deaktivieren:
- Navigieren Sie zu Ihrer Dienstressource und wählen Sie dann Dienstregistrierung aus.
- Wählen Sie Verwalten aus.
- Wählen Oder deaktivieren Sie die Option Dienstregistrierung aktivieren und wählen Sie dann Speichern aus.
- Sie können nun den Status der Dienstregistrierung auf der Seite Dienstregistrierung anzeigen.