Descifrando JavaChassis3: soporte fácil de ampliar para múltiples centros de registro

Este artículo es compartido por liubao68 de la comunidad de nube de Huawei " Descifrado de tecnología JavaChassis3: soporte de centro de registro múltiple fácil de expandir ".

Las primeras versiones de Java Chassis se basaban en Service Center y proporcionaban mucha competitividad diferenciada:

Reenvío a nivel de interfaz. A través del registro se gestionan los metadatos de cada versión del microservicio, especialmente los datos del contrato. Combinado con los datos del contrato, se pueden lograr capacidades de enrutamiento a nivel de versión. Por ejemplo, un microservicio tiene dos versiones: v1 y v2. La versión v1 tiene las interfaces op1 y op2, y la versión v2 tiene las interfaces op1, op2 y op3. En un escenario en escala de grises, Java Chassis puede reenviar automáticamente el acceso de op3 a la versión v2. El acceso de op1 y op2 tiene carga equilibrada en las versiones v1 y v2.
Selección de instancia basada en la regla de versión. El cliente puede configurar la versión de la regla, como la última, 2.0+, etc. De esta forma, el cliente puede filtrar la versión de la instancia según la situación real.

Java Chassis depende demasiado del Centro de servicio, lo que genera algunos cuellos de botella en el desarrollo de productos. La promoción ecológica de Java Chassis se basa en la promoción ecológica del Centro de servicio, que no favorece que más usuarios utilicen Java Chassis. Con el desarrollo de la nube, cada vez más clientes también esperan un conjunto de códigos que puedan ejecutarse en diferentes entornos de nube. Algunos proveedores de nube no proporcionan un entorno operativo de centro de servicio, por lo que los usuarios tendrán dudas al elegir Java Chassis.

Según las razones anteriores, Java Chassis simplifica las dependencias del descubrimiento de registros, define una interfaz simple y fácil de implementar y proporciona una implementación basada en ella, y se proporcionarán otras implementaciones en el futuro . Java Chassis adopta una serie de nuevos patrones de diseño para garantizar que la confiabilidad de la aplicación en sí no se reduzca sin reducir la dependencia funcional del centro de registro. Nacos zookeeper

Alternativas al reenvío a nivel de interfaz

Basándose en Service Center, Java Chassis proporciona reenvío a nivel de interfaz. Uno de los primeros cambios en Java Chassis 3 es la eliminación del soporte para el reenvío a nivel de interfaz. De esta forma, la complejidad de la dependencia del centro de registro se puede reducir al menos en un 70%. Sin embargo, las escenas en escala de grises siguen siendo importantes para muchas empresas. Java Chassis 3 utiliza la publicación en escala de grises para resolver este problema. La ventaja de utilizar la publicación en escala de grises es que no necesita depender del centro de registro para proporcionar capacidades de administración de metadatos de versión y solo necesita que cada instancia tenga información de metadatos simple, como números de versión.

servicecomb: 
  # habilitar enrutador para servicio perimetral 
  enrutador: 
    tipo: enrutador 
  regla de ruta: 
    negocio: | 
      - precedencia: 2 
        coincidencias: 
          apiPath: 
            prefijo: "/business/v2" 
        ruta: 
          - peso: 100 
            etiquetas: 
              versión: 2.0.0 
      - precedencia: 1 
        coincidencia: 
          apiPath: 
            prefijo: "/business/v1/dec" 
        ruta: 
          - peso: 50 
            etiquetas: 
              versión: 1.1.0 
          - peso: 50 
            etiquetas: 
              versión: 2.0.0

Interfaz de descubrimiento de registros y su implementación.

Java Chassis 3 proporciona soporte para el descubrimiento de nuevos registros utilizando únicamente interfaces. Java Chassis llamará a la instancia de consulta. Si las instancias posteriores cambian, la implementación del centro de registro notificará a Java Chassis. Discovery findServiceInstances InstanceChangedListener

/** 
 * Esta es la interfaz principal de descubrimiento de servicios. <br/> 
 */ 
public interface Discovery<D extends DiscoveryInstance> extends SPIEnabled, SPIOrder, LifeCycle { 
  interface InstanceChangedListener<D extends DiscoveryInstance> { 
    /** 
     * Llamado por Discovery Implementations cuando cambió la lista de instancias. 
     * @param registroName Nombre de la implementación de descubrimiento de llamadas 
     * @param aplicación Aplicación de microservicio 
     * @param serviceName Nombre del microservicio 
     * @param selectedInstances Las últimas instancias actualizadas. 
     */ 
    void onInstanceChanged(String registroName, String aplicación, String serviceName, Lista<D> Instancias actualizadas); 
  } 

  Nombre de cadena(); 

  /** 
   * Si esta implementación está habilitada para este microservicio. 
   */ 
  booleano habilitado (aplicación de cadena, nombre de servicio de cadena); 

  /** 
   * Encuentra todas las instancias. 
   * 
   * Ciclo de vida: este método se llama en cualquier momento después de <code>ejecutar</code>. 
   * 
   * @param aplicación aplicación 
   * @param serviceName nombre del microservicio 
   * @return todas las instancias coinciden con los criterios. 
   */ 
  Lista<D> findServiceInstances(Aplicación de cadena, Nombre de servicio de cadena); 

  /** 
   * Discovery puede llamar a InstanceChangedListener cuando se cambia la instancia. 
   */ 
  void setInstanceChangedListener(InstanceChangedListener<D> instanciaChangedListener); 
}

Java Chassis 3 gestiona el registro. El proceso de registro se divide en , y un ciclo de vida simple. Puede preparar los datos de registro y ejecutar el registro. Se ejecutará cuando el registro falle o el sistema se detenga. Registration initrundestroy init run destroy

/** 
 * Esta es la interfaz de registro del servicio principal. <br/> 
 */ 
registro de interfaz pública<R extiende la instancia de registro> extiende SPIEnabled, SPIOrder, LifeCycle { 
  String name(); 

  /** 
   * get MicroserviceInstance </br> 
   * 
   * Ciclo de vida: este método se llama en cualquier momento después de <code>ejecutar</code>. 
   */ 
  R getMicroserviceInstance(); 

  /** 
   * actualizar el estado de MicroserviceInstance </br> 
   * 
   * Ciclo de vida: este método se llama en cualquier momento después de <code>ejecutar</code>. 
   */ 
  boolean updateMicroserviceInstanceStatus(estado de MicroserviceInstanceStatus); 

  /** 
   * agregar esquemas al microservicio </br> 
   * 
   * Ciclo de vida: este método se llama después de <code>init</code> y antes de <code>run</code>. 
   */ 
  void addSchema(String esquemaId, contenido de cadena); 

  /** 
   * agregar puntos finales a MicroserviceInstance </br> 
   * 
   * Ciclo de vida: este método se llama después de <code>init</code> y antes de <code>run</code>. 
   */ 
  void addEndpoint(Punto final de cadena); 

  /** 
   * agregar propiedad a MicroserviceInstance </br> 
   * 
   * Ciclo de vida: este método se llama después de <code>init</code> y antes de <code>run</code>. 
   */ 
  void addProperty(Clave de cadena, Valor de cadena); 
}

Registrar combinaciones descubiertas

Java Chassis 3 puede implementar de forma independiente múltiples sumas para registrarse en múltiples centros de registro y descubrir instancias de múltiples centros de registro. Cada instancia se identifica de forma única por su ID de instancia. Si los ID de instancia son iguales, se considerarán la misma instancia; si son diferentes, se considerarán instancias diferentes. Como se menciona en el artículo, Java Chassis requiere que cada registro de instancia (nuevo proceso) genere una ID de instancia única para resolver el problema de instancias falsas fuera de línea causadas por el aislamiento de la partición de registro. y ambos contienen información básica definida por Java Chassis. Discovery Registration Java Chassis 3技术解密：注册中心分区隔离 Discovery Registration

/** 
 * Información estándar utilizada para el registro y descubrimiento de instancias de microservicio. 
 */ 
public interface MicroserviceInstance { 
  /** 
   * Entorno (obligatorio): se utiliza para la separación lógica de la instancia de microservicio. Solo 
   * instancias de microservicio con el mismo entorno pueden descubrirse entre sí. 
   */ 
  Cadena getEnvironment(); 

  /** 
   * Aplicación (obligatoria): se utiliza para la separación lógica de la instancia de microservicio. Solo 
   * la instancia de microservicio con la misma aplicación puede descubrirse entre sí. 
   */ 
  Cadena getApplication(); 

  /** 
   * Nombre del servicio (obligatorio): identificador único del microservicio. 
   */ 
  String getServiceName(); 

  /** 
   * Alias del nombre del servicio (opcional): identificador único del microservicio. 
   * Este alias lo utiliza la implementación del registro para admitir el cambio de nombre 
   * de un microservicio, por ejemplo, los consumidores antiguos que usan el nombre de servicio antiguo pueden 
   * encontrar un servicio de microservicio renombrado. 
   */ 
  Cadena getAlias(); 

  /** 
   * Versión del servicio (Obligatorio): versión de este microservicio. 
   */ 
  Cadena getVersion(); 

  /** 
   * Información del centro de datos (opcional). 
   */ 
  DataCenterInfo getDataCenterInfo(); 

  /** 
   * Descripción del servicio (Opcional) 
   */ 
  String getDescription(); 

  /** 
   * Propiedades del servicio (Opcional) 
   */ 
  Map<String, String> getProperties(); 

  /** 
   * Esquemas de servicio (opcional): información de API abierta. 
   */ 
  Mapa<Cadena, Cadena> getSchemas(); 

  /** 
   * Puntos finales del servicio (opcional). 
   */ 
  Lista<Cadena> getEndpoints(); 

  /** 
   * ID de instancia de microservicio (obligatorio). Esta identificación se puede generar cuando se inicia la instancia de microservicio 
   * o se puede asignar mediante la implementación del registro. 
   * 
   * Cuando se reinicia la instancia de microservicio, esta identificación debe cambiarse. 
   */ 
  Cadena getInstanceId(); 

  /** 
   * ID del servicio de microservicio (opcional). Esto se utiliza para el centro de servicio; es posible que otras implementaciones no 
   * admitan la identificación del servicio. 
   */ 
  default String getServiceId() { 
    return ""; 
  } 
}

Al implementar el descubrimiento de registros, es necesario garantizar que la información básica definida por la interfaz se pueda registrar en el centro de registro y que esta información se pueda obtener al consultar instancias.

Historia de un cliente: No poner todos los huevos en la misma canasta es una consideración muy importante en la selección de tecnología. La apertura y la sustituibilidad de las soluciones y la sustituibilidad de los servicios en la nube son cuestiones que preocupan a muchos clientes. Para un marco de tecnología de código abierto, aunque la primera versión de Java Chassis fue diseñada para admitir diferentes extensiones del centro de registro, fue muy difícil de implementar e inconscientemente hizo inviable que los clientes usaran otros centros de registro para reemplazar el centro de servicio. Proporciona una implementación de descubrimiento de registros más simplificada, lo que reduce una pequeña cantidad de características competitivas, pero reduce en gran medida las preocupaciones de selección de los clientes.

Haga clic para seguir y conocer las nuevas tecnologías de Huawei Cloud lo antes posible ~