Usar o Registro de Serviço do Tanzu
Observação
Os planos Básico, Standard e Enterprise serão preteridos a partir de meados de março de 2025, com um período de desativação de 3 anos. Recomendamos a transição para os Aplicativos de Contêiner do Azure. Para mais informações, confira o anúncio de desativação dos Aplicativos Spring do Azure.
O plano consumo e dedicado Standard será preterido a partir de 30 de setembro de 2024, com um desligamento completo após seis meses. Recomendamos a transição para os Aplicativos de Contêiner do Azure. Para mais informações, confira Migrar o plano dedicado e consumo Standard dos Aplicativos Spring do Azure para os Aplicativos de Contêiner do Azure.
Este artigo se aplica a: ❎ 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-cloudanteriormente, 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.
- Crie o Serviço A.
- Implante o Serviço A nos Aplicativos Spring do Azure e registre-o no Registro do Serviço.
- Crie o Serviço B e implemente-o para chamar o Serviço A.
- Implante o Serviço B e registre-o no Registro do Serviço.
- 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.
| Variável | Descrição |
|---|---|
| $RESOURCE_GROUP | Nome do grupo de recursos. |
| $AZURE_SPRING_APPS_NAME | Nome da instância 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:
Observação
Essas alterações levarão alguns minutos para serem propagadas para todos os aplicativos quando o status do registro do serviço for alterado.
Se você alterar o status de associação/desassociação, precisará reiniciar ou reimplantar o aplicativo.
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.
Use as etapas a seguir para habilitar ou desabilitar o Registro de Serviços usando o portal do Azure:
- Navegue até o seu recurso de serviço e selecione o Registro de Serviço.
- Selecione Gerenciar.
- Selecione ou desmarque Habilitar o Registro de Serviçoe selecione Salvar.
- Agora você pode exibir o estado do Registro de Serviço na página do Registro de Serviço.