Uso de Tanzu Service Registry

Este artículo se aplica a:❌ Básico o 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.

1. Cree el servicio A.
2. Implemente el servicio A en Azure Spring Apps y regístrelo con Service Registry.
3. Cree el servicio B e impleméntelo para llamar al servicio A.
4. Implemente el servicio B y regístrelo con el registro de servicios.
5. 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.

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:

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.

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>

Pasos siguientes

• Creación de roles y permisos