Share via

Použití registru služby Tanzu

  • Článek

Poznámka:

Azure Spring Apps je nový název služby Azure Spring Cloud. Přestože má služba nový název, na některých místech uvidíte starý název, protože pracujeme na aktualizaci prostředků, jako jsou snímky obrazovky, videa a diagramy.

Tento článek se vztahuje na:❌ Basic/Standard ✔️ Enterprise

V tomto článku se dozvíte, jak používat registr služeb VMware Tanzu s plánem Azure Spring Apps Enterprise.

Tanzu Service Registry je jednou z komerčních komponent VMware Tanzu. Tato komponenta vám pomůže s použitím vzoru návrhu zjišťování služeb pro vaše aplikace.

Zjišťování služeb je jednou z hlavních myšlenek architektury mikroslužeb. Bez zjišťování služeb byste museli ručně nakonfigurovat každého klienta služby nebo přijmout nějakou formu konvence přístupu. Tento proces může být složitý a konfigurace a konvence můžou být v produkčním prostředí křehké. Místo toho můžete pomocí registru služby Tanzu dynamicky zjišťovat a volat registrované služby ve vaší aplikaci.

s plánem Azure Spring Apps Enterprise nemusíte vytvářet ani spouštět registr služeb sami. Registr služby Tanzu můžete použít tak, že ho vyberete při vytváření instance plánu Azure Spring Apps Enterprise.

Požadavky

  • Již zřízená instance plánu Azure Spring Apps Enterprise s povoleným registrem služby Tanzu Další informace najdete v tématu Rychlý start: Sestavování a nasazování aplikací do Azure Spring Apps pomocí plánu Enterprise.
  • Rozšíření plánu Azure Spring Apps Enterprise Pomocí následujícího příkazu odeberte předchozí verze a nainstalujte nejnovější rozšíření plánu Enterprise. Pokud jste rozšíření nainstalovali dříve spring-cloud , odinstalujte ho, abyste se vyhnuli neshodám konfigurace a verzí. 
    az extension add --upgrade --name spring
az extension remove --name spring-cloud

Vytváření aplikací, které používají registr služeb

V tomto článku vytvoříte dvě služby a zaregistrujete je ve službě Azure Spring Apps Service Registry. Po registraci bude jedna služba moci pomocí registru služby zjistit a vyvolat druhou službu. Následující diagram shrnuje požadované kroky:

Diagram znázorňující postup vytvoření, nasazení a registrace služby A a služby B

Tyto kroky jsou podrobněji popsány v následujících částech.

  1. Vytvoření služby A.
  2. Nasaďte službu A do Azure Spring Apps a zaregistrujte ji ve službě Service Registry.
  3. Vytvořte službu B a implementujte ji pro volání služby A.
  4. Nasaďte službu B a zaregistrujte ji ve službě Service Registry.
  5. Vyvolání služby A prostřednictvím služby B

Vytvoření proměnných prostředí

Tento článek používá následující proměnné prostředí. Nastavte tyto proměnné na hodnoty, které jste použili při vytváření instance plánu Azure Spring Apps Enterprise.

Proměnná Popis
$RESOURCE_GROUP Název skupiny prostředků.
$AZURE_SPRING_APPS_NAME Název instance Azure Spring Apps

Vytvoření služby A s využitím Spring Bootu

Přejděte na Spring Initializr a vytvořte ukázkovou službu A. Tento odkaz používá k inicializaci nastavení následující adresu URL.

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

Následující snímek obrazovky ukazuje Spring Initializr s požadovaným nastavením.

Snímek obrazovky se stránkou Spring Initializr, která zobrazuje požadovaná nastavení

Potom výběrem příkazu GENERATE získáte ukázkový projekt pro Spring Boot s následující adresářovou strukturou.

├── 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

Potvrďte konfiguraci závislých knihoven pro klienta registru služeb (klient Eureka).

Dále ověřte, že soubor pom.xml projektu obsahuje následující závislost. Přidejte závislost, pokud chybí.

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Implementace klienta registru služeb

@EnableEurekaClient Přidejte do souboru SampleServiceAApplication.java poznámku, abyste ji nakonfigurovali jako klienta 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);
    }
}

Vytvoření koncového bodu REST pro testování

Službu teď můžete zaregistrovat do služby Service Registry, ale nemůžete ji ověřit, dokud neimplementujete koncový bod služby. Pokud chcete vytvořit koncové body RESTful, které externí služby můžou volat, přidejte do projektu ServiceAEndpoint.java soubor s následujícím kódem.

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;
    }
}

Vytvoření aplikace Spring Boot

Teď, když máte jednoduchou službu, zkompilujte a sestavte zdrojový kód spuštěním následujícího příkazu:

mvn clean package

Nasazení služby A a registrace ve službě Service Registry

Tato část vysvětluje, jak nasadit službu A do instance plánu Azure Spring Apps Enterprise a zaregistrovat ji ve službě Service Registry.

Vytvoření aplikace Azure Spring Apps

Nejprve pomocí následujícího příkazu vytvořte aplikaci v Azure Spring Apps:

az spring app create \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME  \
    --name serviceA \
    --instance-count 1 \
    --memory 2Gi \
    --assign-endpoint

Argument --assign-endpoint uděluje veřejnou IP adresu pro ověření a umožňuje přístup z externí sítě.

Připojení do registru služby z aplikace

Po vytvoření instance služby pomocí Spring Bootu a vytvoření aplikace v Azure Spring Apps nasadíte aplikaci a potvrdíte operaci. Předtím však musíte vytvořit vazbu aplikace na registr služby, aby mohl získat informace o připojení z registru.

Klient Eureka obvykle musí do konfiguračního souboru application.properties aplikace Spring Boot zapsat následující nastavení informací o připojení, abyste se mohli připojit k serveru:

eureka.client.service-url.defaultZone=http://eureka:8761/eureka/

Pokud ale tato nastavení napíšete přímo ve své aplikaci, budete muset projekt znovu upravit a znovu sestavit při každé změně serveru registru služby. Aby se tomu zabránilo, azure Spring Apps umožňuje vašim aplikacím získat informace o připojení z registru služby tím, že k němu připojí vazbu. Konkrétně po vytvoření vazby aplikace do registru služeb můžete získat informace o připojení registru služby (eureka.client.service-url.defaultZone) z proměnné prostředí Java. Tímto způsobem se můžete připojit k registru služby načtením obsahu proměnných prostředí při spuštění aplikace.

V praxi se do JAVA_TOOL_OPTIONS proměnné přidají následující proměnné prostředí:

-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka

Vytvoření vazby služby k registru služby

Pomocí následujícího příkazu vytvořte vazbu služby ke službě Azure Service Registry a povolte připojení k serveru.

az spring service-registry bind \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --app serviceA

Vazby aplikací můžete také nastavit na webu Azure Portal, jak je znázorněno na následujícím snímku obrazovky:

Snímek obrazovky webu Azure Portal zobrazující stránku Registr služeb se zvýrazněným rozevíracím seznamem Vazby aplikace

Poznámka:

Tyto změny budou trvat několik minut, než se rozšíří do všech aplikací, když se změní stav registru služby.

Pokud změníte stav vazby nebo zrušení vazby, musíte aplikaci restartovat nebo znovu nasadit.

Při vytváření nové aplikace teď můžete vytvořit vazbu aplikace na registr služby přímo pomocí následujících příkazů:

az spring app create \ 
    --resource-group <resource-group> \ 
    --service <service-name> \ 
    --name <app-name> \ 
    --bind-service-registry

Aplikaci můžete také svázat s registrem služeb z webu Azure Portal, jak je znázorněno na následujícím snímku obrazovky:

Snímek obrazovky webu Azure Portal se zvýrazněnou stránkou Vytvořit aplikaci se zvýrazněným rozevíracím seznamem Bind

Nasazení aplikace do Azure Spring Apps

Teď, když jste aplikaci vázali, nasaďte soubor artefaktů Spring Boot Sample-Service-A-A-0.0.1-SNAPSHOT.jar do Azure Spring Apps. K nasazení použijte následující příkaz:

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"

Pomocí následujícího příkazu zjistíte, jestli nasazení proběhlo úspěšně.

az spring app list \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --output table

Tento příkaz vytvoří výstup podobný následujícímu příkladu.

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                  -

Ověřte, že je aplikace Service A spuštěná.

Výstup předchozího příkazu obsahuje veřejnou adresu URL služby. Pokud chcete získat přístup ke koncovému bodu RESTful, připojte /serviceA se k adrese URL, jak je znázorněno v následujícím příkazu:

curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/serviceA

Tento příkaz vytvoří následující výstup.

This is a result of Service A

Služba A obsahuje koncový bod RESTful, který zobrazuje seznam proměnných prostředí. Přejděte ke koncovému bodu /env a zobrazte proměnné prostředí, jak je znázorněno v následujícím příkazu:

curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/env

Tento příkaz vytvoří následující výstup.

"JAVA_TOOL_OPTIONS":"-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka

Jak vidíte, eureka.client.service-url.defaultZone je přidán do JAVA_TOOL_OPTIONS. Tímto způsobem může aplikace zaregistrovat službu do registru služeb a zpřístupnit ji z jiných služeb.

Službu teď můžete zaregistrovat do registru služeb (Eureka Server) v Azure Spring Apps. Jiné služby teď mají přístup ke službě pomocí registru služeb.

Implementace nové služby B, která přistupuje ke službě A prostřednictvím registru služeb

Implementace služby B s využitím Spring Bootu

Přejděte na Spring Initializr a vytvořte nový projekt pro service B. Tento odkaz používá k inicializaci nastavení následující adresu URL:

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

Pak vyberte GENEROVAT a získejte nový projekt.

Implementace služby B jako klienta registru služeb (klient Eureka)

Podobně jako service A přidejte poznámku @EnableEurekaClient do služby B a nakonfigurujte ji jako klienta 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);
    }
}

Implementace koncových bodů služby ve službě B

Dále implementujte nový koncový bod služby (/invoke-serviceA), který vyvolá službu A. Přidejte do projektu soubor ServiceBEndpoint.java s následujícím kódem.

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;
    }
}

Tento příklad se používá RestTemplate pro jednoduchost. Koncový bod vrátí řetězec odpovědi s jiným řetězcem (INVOKE SERVICE A FROM SERVICE B: "), který označuje, že byl volán službou B.

Tento příklad také implementuje další koncový bod (/list-all) pro ověření. Tato implementace zajišťuje, že služba správně komunikuje s registrem služeb. Tento koncový bod můžete volat, abyste získali seznam aplikací zaregistrovaných v registru služeb.

Tento příklad vyvolá službu A jako http://servicea. Název služby je název, který jste zadali při vytváření aplikace Azure Spring Apps. (Příklad: az spring app create --name ServiceA.) Název aplikace odpovídá názvu služby, který jste zaregistrovali v registru služby, což usnadňuje správu názvu služby.

Build Service B

K sestavení projektu použijte následující příkaz.

mvn clean package

Nasazení služby B do Azure Spring Apps

Pomocí následujícího příkazu vytvořte aplikaci v Azure Spring Apps pro nasazení služby B.

az spring app create \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --name serviceB \
    --instance-count 1 \
    --memory 2Gi \
    --assign-endpoint

Dále pomocí následujícího příkazu vytvořte vazbu aplikace na registr služby.

az spring service-registry bind \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --app serviceB

Dále pomocí následujícího příkazu službu nasaďte.

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"

Dále pomocí následujícího příkazu zkontrolujte stav aplikace.

az spring app list \
    --resource-group $RESOURCE_GROUP \
    --service $AZURE_SPRING_APPS_NAME \
    --output table

Pokud jsou služba A a služba B správně nasazeny, tento příkaz vytvoří výstup podobný následujícímu příkladu.

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                  -

Vyvolání služby A ze služby B

Výstup předchozího příkazu obsahuje veřejnou adresu URL služby. Pokud chcete získat přístup ke koncovému bodu RESTful, připojte /invoke-serviceA se k adrese URL, jak je znázorněno v následujícím příkazu:

curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/invoke-serviceA

Tento příkaz vytvoří následující výstup:

INVOKE SERVICE A FROM SERVICE B: This is a result of Service A

Získání informací z registru služeb

Nakonec přejděte ke koncovému /list-all bodu a načtěte některé informace z registru služby. Následující příkaz načte seznam služeb zaregistrovaných v registru služeb.

curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/list-all

Tento příkaz vytvoří následující výstup.

["SERVICEA","EUREKA-SERVER","SERVICEB"]

Tímto způsobem můžete získat podrobné informace z programu podle potřeby.

Povolení nebo zakázání registru služby po vytvoření služby

Registr služeb můžete povolit a zakázat po vytvoření služby pomocí webu Azure Portal nebo Azure CLI. Před zakázáním registru služeb musíte zrušit vazbu všech aplikací.

Pomocí následujících kroků povolte nebo zakažte registr služeb pomocí webu Azure Portal:

  1. Přejděte k prostředku služby a pak vyberte Registr služeb.
  2. Vyberte položku Spravovat.
  3. Vyberte nebo zrušte výběr registru služby a pak vyberte Uložit.
  4. Stav registru služby teď můžete zobrazit na stránce Registr služby.

Další kroky