Uso de Tanzu Service Registry
Nota:
Los planes de Básico, Estándar y Enterprise quedarán en desuso a partir de mediados de marzo de 2025, con un período de retiro de 3 años. Se recomienda realizar la transición a Azure Container Apps. Para más información, consulte el anuncio de retirada de Azure Spring Apps.
El plan de consumo estándar y dedicado quedará obsoleto a partir del 30 de septiembre de 2024, con un cierre completo al cabo de seis meses. Se recomienda realizar la transición a Azure Container Apps. Para obtener más información, consulte Migrar el plan de consumo y dedicado Azure Spring Apps Standard a Azure Container Apps.
Este artículo se aplica a: ❎ Básico/Estándar ✅ Enterprise
En este artículo se muestra cómo usar el Registro de servicios de VMware Tanzu con el plan Enterprise de Azure Spring Apps.
Tanzu Service Registry es uno de los componentes comerciales de VMware Tanzu. Este componente le ayuda a aplicar el patrón de diseño de detección de servicios a las aplicaciones.
La detección de servicios es una de las ideas principales de la arquitectura de microservicios. Sin la detección de servicios, tendría que configurar manualmente cada cliente de un servicio o adoptar alguna forma de convención de acceso. Este proceso puede ser difícil y las configuraciones y convenciones pueden ser frágiles en la producción. En su lugar, puede usar el Registro de servicio de Tanzu para detectar e invocar dinámicamente los servicios registrados en la aplicación.
Con el plan Enterprise de Azure Spring Apps, no es necesario que cree ni inicie el Registro de servicios por su cuenta. Puede usar el Registro de servicios de Tanzu seleccionándolo al crear la instancia de plan Enterprise de Azure Spring Apps.
Requisitos previos
- Una instancia del plan Enterprise de Azure Spring Apps ya aprovisionada con el Registro de servicios de Tanzu habilitado. Para más información, consulte Inicio rápido: Compilación e implementación de aplicaciones en Azure Spring Apps con el plan Enterprise.
- La extensión del plan Enterprise de Azure Spring Apps. Use el siguiente comando para eliminar las versiones anteriores e instalar la extensión del plan Enterprise más reciente. Si ya ha instalado la extensión
spring-cloud, desinstálela para evitar errores de coincidencia de la configuración y la versión.az extension add --upgrade --name spring az extension remove --name spring-cloud
Creación de aplicaciones que usan Service Registry
En este artículo, creará dos servicios y los registrará en el Registro de servicios de Azure Spring Apps. Después del registro, un servicio podrá usar el Registro de servicios para detectar e invocar el otro servicio. En el siguiente diagrama, se resumen los pasos requeridos:
En las secciones siguientes se describen estos pasos de forma más detallada.
- Cree el servicio A.
- Implemente el servicio A en Azure Spring Apps y regístrelo con Service Registry.
- Cree el servicio B e impleméntelo para llamar al servicio A.
- Implemente el servicio B y regístrelo con el registro de servicios.
- Invoque el servicio A mediante el servicio B.
Creación de variables de entorno
En este artículo se usan las siguientes variables de entorno. Establezca estas variables en los valores que usó al crear la instancia del plan Enterprise de Azure Spring Apps.
| Variable | Descripción |
|---|---|
| $RESOURCE_GROUP | Nombre del grupo de recursos. |
| $AZURE_SPRING_APPS_NAME | Nombre de instancia de Azure Spring Apps. |
Creación de un servicio A con Spring Boot
Vaya a Spring Initializr para crear el servicio A de muestra. Este vínculo usa la siguiente dirección URL para inicializar la configuración.
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
En la captura de pantalla siguiente se muestra Spring Initializr con la configuración necesaria.
A continuación, seleccione GENERAR para obtener un proyecto de ejemplo para Spring Boot con la siguiente estructura de directorios.
├── 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
Confirmar la configuración de bibliotecas dependientes para el cliente del Registro de servicio (cliente Eureka)
A continuación, confirme que el archivo pom.xml para el proyecto contiene la dependencia siguiente. Agregue la dependencia si falta.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
Implementación del cliente del registro de servicios
Agregue una anotación @EnableEurekaClient al archivo SampleServiceAApplication.java para configurarlo como 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);
}
}
Creación de un punto de conexión REST para pruebas
Ahora puede registrar el servicio en el Registro de servicios, pero no puede comprobarlo hasta que implemente un punto de conexión de servicio. Para crear puntos de conexión RESTful a los que puedan llamar los servicios externos, agregue un archivo ServiceAEndpoint.java al proyecto con el siguiente código.
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;
}
}
Creación de una aplicación de Spring Boot
Ahora que tiene un servicio sencillo, compile y construya el código fuente ejecutando el siguiente comando:
mvn clean package
Implementación del servicio A y registro en el registro de servicios
En esta sección se explica cómo implementar el servicio A en una instancia del plan Enterprise de Azure Spring Apps y registrarla en el Registro de servicios.
Creación de una aplicación de Azure Spring Apps
En primer lugar, cree una aplicación en Azure Spring Apps mediante el siguiente comando:
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceA \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
El argumento --assign-endpoint concede una dirección IP pública para la validación y habilita el acceso desde la red externa.
Conexión al Registro de servicios desde la aplicación
Después de crear una instancia de servicio con Spring Boot y crear una aplicación en Azure Spring Apps, implemente la aplicación y confirme la operación. Sin embargo, antes deberá enlazar la aplicación al Registro de servicios para que pueda obtener información de conexión del registro.
Normalmente, un cliente de Eureka debe escribir las siguientes opciones de información de conexión en el archivo de configuración application.properties de una aplicación de Spring Boot para que pueda conectarse al servidor:
eureka.client.service-url.defaultZone=http://eureka:8761/eureka/
Sin embargo, si escribe esta configuración directamente en la aplicación, debe volver a editar y volver a generar el proyecto cada vez que cambie el servidor del Registro de servicios. Para evitar este esfuerzo, Azure Spring Apps permite a las aplicaciones obtener información de conexión del registro de servicio enlazando a ella. En concreto, después de enlazar la aplicación al Registro de servicio, puede obtener la información de conexión del Registro de servicio (eureka.client.service-url.defaultZone) desde la variable de entorno de Java. De este modo, puede conectarse al Registro de servicios cargando el contenido de las variables de entorno cuando se inicie la aplicación.
En la práctica, se agregan las siguientes variables de entorno a la variable JAVA_TOOL_OPTIONS:
-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Enlace de un servicio al registro de servicios
Use el siguiente comando para enlazar el servicio a Azure Service Registry, que le permitirá conectarse al servidor.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceA
También puede configurar los enlaces de aplicación desde el Azure Portal, como se muestra en la captura de pantalla siguiente:
Nota:
Estos cambios tardarán unos minutos en extenderse a todas las aplicaciones cuando cambie el estado del registro del servicio.
Si cambia el estado de enlace o desenlace, debe reiniciar o volver a implementar la aplicación.
Ahora puede optar por enlazar la aplicación al Registro de servicios directamente al crear una aplicación mediante los siguientes comandos:
az spring app create \
--resource-group <resource-group> \
--service <service-name> \
--name <app-name> \
--bind-service-registry
También puede enlazar la aplicación al Registro de servicios desde Azure Portal, como se muestra en la captura de pantalla siguiente:
Implementación de una aplicación en Azure Spring Apps
Ahora que ha enlazado la aplicación, implemente el archivo de artefactos de Spring Boot Sample-Service-A-0.0.1-SNAPSHOT.jar en Azure Spring Apps. Para realizar la implementación, use el siguiente 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 el siguiente comando para ver si la implementación se ha realizado correctamente.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Esto genera una salida similar a la del siguiente ejemplo.
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 -
Confirmación de que la aplicación de servicio A se está ejecutando
La salida del comando anterior incluye la dirección URL pública del servicio. Para acceder al punto de conexión RESTful, anexe /serviceA a la dirección URL, como se muestra en el siguiente comando:
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/serviceA
Este comando genera el siguiente resultado.
This is a result of Service A
El servicio A incluye un punto de conexión RESTful que muestra una lista de variables de entorno. Acceda al punto de conexión con /env para ver las variables de entorno, como se muestra en el siguiente comando:
curl https://$AZURE_SPRING_APPS_NAME-servicea.azuremicroservices.io/env
Este comando genera el siguiente resultado.
"JAVA_TOOL_OPTIONS":"-Deureka.client.service-url.defaultZone=https://$AZURE_SPRING_APPS_NAME.svc.azuremicroservices.io/eureka/default/eureka
Como puede ver, eureka.client.service-url.defaultZone se agrega a JAVA_TOOL_OPTIONS. De este modo, la aplicación puede registrar el servicio en el Registro de servicios y hacer que esté disponible desde otros servicios.
Ahora puede registrar el servicio en el Registro de servicios (servidor Eureka) en Azure Spring Apps. Otros servicios ahora pueden acceder al servicio mediante el Registro de servicios.
Implementación de un nuevo servicio B que acceda al servicio A mediante el Registro de servicios
Implementación del servicio B con Spring Boot
Vaya a Spring Initializr para crear un nuevo proyecto para el servicio B. Este vínculo usa la siguiente dirección URL para inicializar la configuración:
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
A continuación, seleccione GENERAR para obtener el nuevo proyecto.
Implementación del servicio B como cliente del Registro de servicios (cliente Eureka)
Al igual que en el servicio A, agregue la anotación @EnableEurekaClient al servicio B para configurarla como un 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);
}
}
Implementación de puntos de conexión de servicio en el servicio B
A continuación, implemente un nuevo punto de conexión de servicio (/invoke-serviceA) que invoque el servicio A. Agregue un archivo ServiceBEndpoint.java al proyecto con el código siguiente.
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 ejemplo usa RestTemplate para mayor sencillez. El punto de conexión devuelve la cadena de respuesta con otra cadena (INVOKE SERVICE A FROM SERVICE B: ") para indicar que el servicio B lo ha llamado.
En este ejemplo también se implementa otro punto de conexión (/list-all) para la validación. Esta implementación garantiza que el servicio se comunique correctamente con el registro de servicios. Puede llamar a este punto de conexión para obtener la lista de aplicaciones registradas en el registro de servicios.
En este ejemplo se invoca el servicio A como http://servicea. El nombre del servicio es el nombre que especificó durante la creación de la aplicación de Azure Spring Apps (por ejemplo: az spring app create --name ServiceA). El nombre de la aplicación coincide con el nombre de servicio que registró con el registro de servicio, lo que facilita la administración del nombre del servicio.
Servicio de compilación B
Use el siguiente comando para compilar su proyecto.
mvn clean package
Implementación del servicio B en Azure Spring Apps
Use el siguiente comando para crear una aplicación en Azure Spring Apps para implementar el servicio B.
az spring app create \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--name serviceB \
--instance-count 1 \
--memory 2Gi \
--assign-endpoint
Después, use el siguiente comando para enlazar la aplicación al Registro de servicios.
az spring service-registry bind \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--app serviceB
A continuación, use el siguiente comando para implementar el servicio.
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"
Tras esto, use el siguiente comando para comprobar el estado de la aplicación.
az spring app list \
--resource-group $RESOURCE_GROUP \
--service $AZURE_SPRING_APPS_NAME \
--output table
Si el servicio A y el servicio B se implementan correctamente, este comando genera una salida similar al ejemplo siguiente.
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 el servicio A desde el servicio B
La salida del comando anterior incluye la dirección URL pública del servicio. Para acceder al punto de conexión RESTful, anexe /invoke-serviceA a la dirección URL, como se muestra en el siguiente comando:
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/invoke-serviceA
Este comando genera el siguiente resultado:
INVOKE SERVICE A FROM SERVICE B: This is a result of Service A
Obtención de información de Service Registry
Por último, acceda al punto de conexión /list-all y recupere información del registro de servicios. El siguiente comando recupera una lista de servicios registrados en el Registro de servicios.
curl https://$AZURE_SPRING_APPS_NAME-serviceb.azuremicroservices.io/list-all
Este comando genera el siguiente resultado.
["SERVICEA","EUREKA-SERVER","SERVICEB"]
De este modo, podrá obtener información detallada del programa según sea necesario.
Habilitar o deshabilitar el Registro de servicios después de la creación del servicio
Puede habilitar y deshabilitar el Registro de servicios después de la creación del servicio mediante Azure Portal o la CLI de Azure. Antes de deshabilitar el Registro de servicios, es necesario que desenlace todas las aplicaciones de ella.
Siga estos pasos para habilitar o deshabilitar el Registro de servicios mediante Azure Portal:
- Vaya al recurso de servicio y, a continuación, seleccione Registro de servicios.
- Seleccione Administrar.
- Seleccione o anule la selección del Habilitar Registro de servicios y, a continuación, seleccione Guardar.
- Ahora puede ver el estado del Registro de servicios en la página Registro de servicios.