Usar o Tanzu Service Registry

Este artigo aplica-se a: ❎ Basic/Standard ✅ Enterprise

Este artigo mostra como usar o VMware Tanzu Service Registry com o plano Azure Spring Apps Enterprise.

O Tanzu Service Registry é um dos componentes comerciais do VMware Tanzu. Este componente ajuda você a aplicar o padrão de design de descoberta de serviço aos seus aplicativos.

A descoberta de serviços é uma das principais ideias da arquitetura de microsserviços. Sem a descoberta de serviços, você teria que configurar manualmente cada cliente de um serviço ou adotar alguma forma de convenção de acesso. Este processo pode ser difícil, e as configurações e convenções podem ser frágeis na produção. Em vez disso, você pode usar o Tanzu Service Registry para descobrir e invocar dinamicamente serviços registrados em seu aplicativo.

com o plano Azure Spring Apps Enterprise, você não precisa criar ou iniciar o Registro de Serviço por conta própria. Você pode usar o Registro de Serviço Tanzu selecionando-o ao criar sua instância do plano do Azure Spring Apps Enterprise.

Pré-requisitos

• Uma instância de plano do Azure Spring Apps Enterprise já provisionada com o Tanzu Service Registry habilitado. Para obter mais informações, consulte Guia de início rápido: criar e implantar aplicativos no Azure Spring Apps usando o plano Enterprise.
• A extensão do plano do Azure Spring Apps Enterprise. Use o comando a seguir para remover versões anteriores e instalar a extensão de plano Enterprise mais recente. Se você instalou spring-cloud a extensão anteriormente, desinstale-a para evitar incompatibilidades de configuração e versão.

  az extension add --upgrade --name spring
  az extension remove --name spring-cloud
  

Criar aplicativos que usam o Registro de Serviço

Neste artigo, você cria dois serviços e os registra no Registro de Serviço do Azure Spring Apps. Após o registro, um serviço poderá usar o Registro de Serviço para descobrir e invocar o outro serviço. O diagrama a seguir resume as etapas necessárias:

Essas etapas são descritas com mais detalhes nas seções a seguir.

1. Criar Serviço A.
2. Implante o Serviço A no Azure Spring Apps e registre-o no Registro de Serviço.
3. Crie o Serviço B e implemente-o para chamar o Serviço A.
4. Implante o Serviço B e registre-o no Registro de Serviço.
5. Invoque o Serviço A através do Serviço B.

Criar variáveis de ambiente

Este artigo usa as seguintes variáveis de ambiente. Defina essas variáveis para os valores usados quando você criou sua instância do plano do Azure Spring Apps Enterprise.

Criar o serviço A com o Spring Boot

Navegue até Spring Initializr para criar o Serviço A de exemplo. Este link usa a seguinte URL para inicializar as configurações.

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

A captura de tela a seguir mostra o Spring Initializr com as configurações necessárias.

Em seguida, selecione GERAR para obter um projeto de exemplo para o Spring Boot com a seguinte estrutura de diretórios.

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

Confirme a configuração de bibliotecas dependentes para o cliente do Service Registry (cliente Eureka)

Em seguida, confirme se o arquivo pom.xml para o projeto contém a seguinte dependência. Adicione a dependência se ela estiver faltando.

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

Implementar o cliente do Service Registry

Adicione uma @EnableEurekaClient anotação ao arquivo SampleServiceAApplication.java para configurá-lo como um cliente 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);
    }
}

Criar um ponto de extremidade REST para teste

Agora você pode registrar o serviço no Registro de Serviço, mas não pode verificá-lo até implementar um ponto de extremidade de serviço. Para criar pontos de extremidade RESTful que serviços externos podem chamar, adicione um arquivo ServiceAEndpoint.java ao seu projeto com o código a seguir.

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

Criar uma aplicação do Spring Boot

Agora que você tem um serviço simples, compile e construa o código-fonte executando o seguinte comando:

mvn clean package

Implantar o Serviço A e registrar-se no Registro de Serviço

Esta seção explica como implantar o Serviço A em uma instância do plano do Azure Spring Apps Enterprise e registrá-lo no Registro de Serviço.

Criar um aplicativo do Azure Spring Apps

Primeiro, crie um aplicativo no Azure Spring Apps usando o seguinte comando:

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

O --assign-endpoint argumento concede um IP público para validação e permite o acesso a partir da rede externa.

Conectar-se ao Registro de Serviço a partir do aplicativo

Depois de criar uma instância de serviço com o Spring Boot e criar um aplicativo no Azure Spring Apps, você implanta o aplicativo e confirma a operação. Antes disso, no entanto, você deve vincular seu aplicativo ao Registro de Serviço para que ele possa obter informações de conexão do Registro.

Normalmente, um cliente Eureka precisa escrever as seguintes configurações de informações de conexão no arquivo de configuração application.properties de um aplicativo Spring Boot para que você possa se conectar ao servidor:

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

No entanto, se você escrever essas configurações diretamente em seu aplicativo, precisará reeditar e reconstruir o projeto novamente sempre que o servidor do Registro de Serviço for alterado. Para evitar esse esforço, o Azure Spring Apps permite que seus aplicativos obtenham informações de conexão do registro de serviço vinculando-se a ele. Especificamente, depois de vincular o aplicativo ao Registro de Serviço, você pode obter as informações de conexão do Registro de serviço (eureka.client.service-url.defaultZone) da variável de ambiente Java. Dessa forma, você pode se conectar ao Registro de Serviço carregando o conteúdo das variáveis de ambiente quando o aplicativo é iniciado.

Na prática, as seguintes variáveis de ambiente são adicionadas à JAVA_TOOL_OPTIONS variável:

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

Vincular um serviço ao Registro de Serviço

Use o comando a seguir para vincular o serviço ao Registro de Serviço do Azure, permitindo que ele se conecte ao servidor.

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

Você também pode configurar as associações de aplicativo no portal do Azure, conforme mostrado na captura de tela a seguir:

Agora você pode optar por vincular seu aplicativo ao Registro de Serviço diretamente ao criar um novo aplicativo usando os seguintes comandos:

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

Você também pode vincular seu aplicativo ao Registro de Serviço no portal do Azure, conforme mostrado na captura de tela a seguir:

Implantar um aplicativo no Azure Spring Apps

Agora que você vinculou seu aplicativo, implante o arquivo de artefato Spring Boot Sample-Service-A-A-0.0.1-SNAPSHOT.jar no Azure Spring Apps. Para implantar, use o seguinte comando:

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"

Use o comando a seguir para ver se sua implantação foi bem-sucedida.

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

Este comando produz uma saída semelhante ao exemplo a seguir.

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                  -

Confirme se o aplicativo Service A está em execução

A saída do comando anterior inclui a URL pública do serviço. Para acessar o ponto de extremidade RESTful, acrescente /serviceA à URL, conforme mostrado no comando a seguir:

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

Este comando produz a seguinte saída.

This is a result of Service A

O serviço A inclui um ponto de extremidade RESTful que exibe uma lista de variáveis de ambiente. Acesse o ponto de extremidade com /env para ver as variáveis de ambiente, conforme mostrado no comando a seguir:

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

Este comando produz a seguinte saída.

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

Como você pode ver, eureka.client.service-url.defaultZone é adicionado ao JAVA_TOOL_OPTIONS. Desta forma, a aplicação pode registar o serviço no Registo de Serviços e disponibilizá-lo a partir de outros serviços.

Agora você pode registrar o serviço no Registro de Serviço (Eureka Server) no Azure Spring Apps. Outros serviços agora podem acessar o serviço usando o registro de serviço.

Implementar um novo Serviço B que aceda ao Serviço A através do Registo de Serviços

Implementar o Serviço B com o Spring Boot

Navegue até Spring Initializr para criar um novo projeto para o Serviço B. Este link usa a seguinte URL para inicializar as configurações:

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

Em seguida, selecione GERAR para obter o novo projeto.

Implementar o Serviço B como um cliente de Registo de Serviços (cliente Eureka)

Como o Serviço A, adicione a @EnableEurekaClient anotação ao Serviço B para configurá-lo como um cliente 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);
    }
}

Implementar pontos de extremidade de serviço no Serviço B

Em seguida, implemente um novo ponto de extremidade de serviço (/invoke-serviceA) que invoque o Serviço A. Adicione um arquivo ServiceBEndpoint.java ao seu projeto com o código a seguir.

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

Este exemplo usa RestTemplate para simplificar. O ponto de extremidade retorna a cadeia de caracteres de resposta com outra cadeia de caracteres (INVOKE SERVICE A FROM SERVICE B: ") para indicar que ela foi chamada pelo Serviço B.

Este exemplo também implementa outro ponto de extremidade (/list-all) para validação. Essa implementação garante que o serviço esteja se comunicando corretamente com o Registro de Serviço. Você pode chamar esse ponto de extremidade para obter a lista de aplicativos registrados no Registro de Serviço.

Este exemplo invoca o Serviço A como http://servicea. O nome do serviço é o nome que você especificou durante a criação do aplicativo Azure Spring Apps. (Por exemplo: az spring app create --name ServiceA.) O nome do aplicativo corresponde ao nome do serviço que você registrou no registro do serviço, facilitando o gerenciamento do nome do serviço.

Serviço de compilação B

Use o comando a seguir para criar seu projeto.

mvn clean package

Implantar o Serviço B no Azure Spring Apps

Use o comando a seguir para criar um aplicativo no Azure Spring Apps para implantar o Serviço B.

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

Em seguida, use o seguinte comando para vincular o aplicativo ao Registro de Serviço.

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

Em seguida, use o seguinte comando para implantar o serviço.

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"

Em seguida, use o seguinte comando para verificar o status do aplicativo.

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

Se o Serviço A e o Serviço B forem implantados corretamente, esse comando produzirá uma saída semelhante ao exemplo a seguir.

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                  -

Invoque o Serviço A do Serviço B

A saída do comando anterior inclui a URL pública do serviço. Para acessar o ponto de extremidade RESTful, acrescente /invoke-serviceA à URL, conforme mostrado no comando a seguir:

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

Este comando produz a seguinte saída:

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

Obter algumas informações do Registro de Serviço

Finalmente, acesse o /list-all ponto de extremidade e recupere algumas informações do Registro de Serviço. O comando a seguir recupera uma lista de serviços registrados no Registro de Serviço.

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

Este comando produz a seguinte saída.

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

Desta forma, você pode obter informações detalhadas do programa, conforme necessário.

Ativar/desativar o Registo de Serviço após a criação do serviço

Você pode habilitar e desabilitar o Registro de Serviço após a criação do serviço usando o portal do Azure ou a CLI do Azure. Antes de desativar o Registro de Serviço, é necessário desvincular todos os seus aplicativos dele.

az spring service-registry create \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-service-instance-name>

az spring service-registry delete \
    --resource-group <resource-group-name> \
    --service <Azure-Spring-Apps-service-instance-name>

Próximos passos

• Criar funções e permissões