Usar o Registro de Serviço do Tanzu

Este artigo se aplica a(o):❌ Básico/Standard ✔️ Enterprise

Este artigo mostra como usar o Registro de Serviço do Tanzu do VMware com o plano do Enterprise dos Aplicativos Spring do Azure.

O Registro de Serviço do Tanzu é um dos componentes comerciais do VMware Tanzu. Esse componente ajuda você a aplicar o padrão de design de Descoberta de serviços aos aplicativos.

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

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

Pré-requisitos

• Uma instância de plano do Enterprise dos Aplicativos Spring do Azure já provisionada com o Registro de Serviço do Tanzu habilitado. Para obter mais informações, consulte Início Rápido: criar e implantar aplicativos no Enterprise dos Aplicativos Spring do Azure usando o plano Enterprise.
• A extensão do plano Enterprise dos Aplicativos Spring do Azure. Use o comando a seguir para remover as versões anteriores e instalar a extensão do plano Enterprise mais recente. Se você instalou a extensão spring-cloud 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 usem o Registro do Serviço

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

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

1. Crie o Serviço A.
2. Implante o Serviço A nos Aplicativos Spring do Azure e registre-o no Registro do 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 do Serviço.
5. Invoque o Serviço A por meio do Serviço B.

Criar variáveis de ambiente

Este artigo usa as seguintes variáveis de ambiente. Defina essas variáveis com os valores que você usa ao criar sua instância do plano do Enterprise dos Aplicativos Spring do Azure.

Criar Serviço A com o Spring Boot

Navegue até Spring Initializr para criar um exemplo de Serviço A. Esse link usa a URL a seguir 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 do Spring Boot com a estrutura de diretório a seguir.

├── 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 Registro do Serviço (cliente Eureka)

Em seguida, confirme se o arquivo pom.xml do projeto contém a dependência a seguir. Adicione a dependência, se estiver ausente.

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

Implementar o cliente do Registro do Serviço

Adicione uma anotação @EnableEurekaClient 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 do Serviço, mas não pode verificá-lo antes da implementação de um ponto de extremidade de serviço. Para criar pontos de extremidade RESTful que os 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 um aplicativo Spring Boot

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

mvn clean package

Implantar o Serviço A e registrar no Registro do Serviço

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

Criar um aplicativo dos Aplicativos Spring do Azure

Primeiro, crie um aplicativo nos Aplicativos Spring do Azure 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 argumento --assign-endpoint concede um IP público para validação e permite o acesso da rede externa.

Conectar-se ao Registro do Serviço pelo aplicativo

Depois de você ter criado uma instância de serviço com o Spring Boot e criado um aplicativo nos Aplicativos Spring do Azure, implante o aplicativo e confirme a operação. Antes disso, no entanto, você deve associar seu aplicativo ao Registro do Serviço para que ele possa obter informações de conexão do registro.

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

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

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

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

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

Associar um serviço ao Registro do Serviço

Use o comando a seguir para associar o serviço ao Registro do 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 seguinte captura de tela:

Agora você pode optar por associar 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ços no portal do Azure, conforme mostrado na captura de tela a seguir:

Implantar um aplicativo nos Aplicativos Spring do Azure

Agora que você vinculou seu aplicativo, implante o arquivo de artefato do Spring Boot Sample-Service-A-A-0.0.1-SNAPSHOT.jar nos Aplicativos Spring do Azure. 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 a implantação foi bem-sucedida.

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

Esse comando produz uma saída semelhante ao seguinte exemplo.

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                  -

Confirmar se o aplicativo do Serviço 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 exibido no seguinte comando:

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

Esse comando gera 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 seguinte comando:

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

Esse comando gera 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. Dessa forma, o aplicativo pode registrar o serviço no Registro do Serviço e disponibilizá-lo de outros serviços.

Agora você pode registrar o serviço no Registro do Serviço (Servidor Eureka) nos Aplicativos Spring do Azure. Outros serviços agora podem acessar o serviço usando o registro do serviço.

Implementar um novo Serviço B que acessa o Serviço A pelo Registro do Serviço

Implementar o Serviço B com o Spring Boot

Navegue até Spring Initializr para criar um projeto para o Serviço B. Esse link usa a URL a seguir 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 do Registro do Serviço (cliente Eureka)

Assim como o Serviço A, adicione a anotação @EnableEurekaClient ao Serviço B para configurá-la 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 invoca 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 do Serviço. Você pode chamar esse ponto de extremidade para obter a lista de aplicativos registrados no Registro do Serviço.

Este exemplo invoca o Serviço A como http://servicea. O nome do serviço é o nome especificado durante a criação do aplicativo nos Aplicativos Spring do Azure. (Por exemplo: az spring app create --name ServiceA.) O nome do aplicativo corresponde ao nome do serviço registrada com o registro do serviço, facilitando o gerenciamento do nome do serviço.

Serviço de build B

Use o seguinte comando para compilar seu projeto.

mvn clean package

Implantar o Serviço B nos Aplicativos Spring do Azure

Use o seguinte comando para criar um aplicativo nos Aplicativos Spring do Azure 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 comando a seguir para associar o aplicativo ao Registro do 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 comando a seguir 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                  -

Invocar 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 exibido no seguinte comando:

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

Esse comando gera a seguinte saída:

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

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

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

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

Esse comando gera a seguinte saída.

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

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

Habilitar/desabilitar o Registro de Serviço depois de criar o serviço

Você pode ativar e desativar o Registro de Serviço depois de criar o serviço usando o portal do Azure ou a CLI do Azure. Antes de desativar o Registro de Serviço, você deve desvincular todos os seus aplicativos desse registro.

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óximas etapas

• Criar funções e permissões