Freigeben über


Verwenden der Tanzu-Dienstregistrierung

Hinweis

Die Pläne Basic, Standard und Enterprise gelten ab Mitte März 2025 als veraltet und werden über einen Zeitraum von 3 Jahren eingestellt. Es wird empfohlen, auf Azure Container Apps umzustellen. Weitere Informationen finden Sie in der Ankündigung zur Einstellung von Azure Spring Apps.

Der Standardverbrauchs- und dedizierte Plan wird ab dem 30. September 2024 als veraltet gekennzeichnet und nach sechs Monaten vollständig eingestellt. Es wird empfohlen, auf Azure Container Apps umzustellen. Weitere Informationen finden Sie unter Migrieren vom Standardverbrauchs- und dedizierten Plan von Azure Spring Apps zu Azure Container Apps.

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:

Diagramm mit den Schritten zum Erstellen, Bereitstellen und Registrieren von Dienst A und Dienst B.

Diese Schritte werden in den folgenden Abschnitten ausführlicher beschrieben.

  1. Erstellen von Dienst A.
  2. Bereitstellen von Dienst A in Azure Spring Apps und Registrieren des Diensts bei der Dienstregistrierung.
  3. Erstellen von Dienst B und Implementieren, dass er Dienst A aufruft.
  4. Bereitstellen von Dienst B und Registrieren des Diensts bei der Dienstregistrierung.
  5. 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.

Screenshot der Seite „Spring Initializr“, auf der die erforderlichen Einstellungen angezeigt werden.

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:

Screenshot des Azure-Portals, auf dem die Seite „Dienstregistrierung“ mit hervorgehobener Dropdownliste „App-Bindung“ angezeigt wird.

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:

Screenshot: Seite „App erstellen“ im Azure-Portal mit hervorgehobenem Dropdownmenü „Bindung“

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:

  1. Navigieren Sie zu Ihrer Dienstressource und wählen Sie dann Dienstregistrierung aus.
  2. Wählen Sie Verwalten aus.
  3. Wählen Oder deaktivieren Sie die Option Dienstregistrierung aktivieren und wählen Sie dann Speichern aus.
  4. Sie können nun den Status der Dienstregistrierung auf der Seite Dienstregistrierung anzeigen.

Nächste Schritte