Descriptografando JavaChassis3: suporte fácil de estender para vários centros de registro

Este artigo foi compartilhado pela Huawei Cloud Community " JavaChassis3 Technology Decryption: Easy-to-Expand Multiple Registration Center Support " por liubao68.

As primeiras versões do Java Chassis contavam com o Service Center e proporcionavam muita competitividade diferenciada:

Encaminhamento de nível de interface. Os metadados de cada versão do microsserviço são gerenciados através do registro, principalmente os dados do contrato. Combinados com dados de contrato, podem ser alcançados recursos de roteamento em nível de versão. Por exemplo, um microsserviço tem duas versões: v1 e v2. A versão v1 possui interfaces op1 e op2, e a versão v2 possui interfaces op1, op2 e op3. Em um cenário de escala de cinza, o Java Chassis pode encaminhar automaticamente o acesso do op3 para a versão v2. O acesso de op1 e op2 é balanceado em carga nas versões v1 e v2.
Seleção de instância baseada na regra de versão. O cliente pode configurar a regra de versão, como última, 2.0+, etc. Desta forma, o cliente pode filtrar a versão da instância com base na situação real.

O Java Chassis depende muito do Service Center, o que traz alguns gargalos ao desenvolvimento do produto. A promoção ecológica do Java Chassis depende da promoção ecológica do Service Center, o que não favorece o uso do Java Chassis por mais usuários. Com o desenvolvimento da nuvem, mais e mais clientes também esperam um conjunto de códigos que possam ser executados em diferentes ambientes de nuvem.Alguns provedores de nuvem não fornecem um ambiente operacional de Centro de Serviços, então os usuários terão preocupações ao escolher o Java Chassis.

Com base nas razões acima, o Java Chassis simplifica as dependências da descoberta de registro, define uma interface simples e fácil de implementar e fornece implementação com base nela, e outras implementações serão fornecidas no futuro . Java Chassis adota uma série de novos padrões de design para garantir que a confiabilidade do próprio aplicativo não seja reduzida sem reduzir a dependência funcional do centro de registro. Nacos zookeeper

Alternativas para encaminhamento em nível de interface

Contando com o Service Center, o Java Chassis fornece encaminhamento em nível de interface. Uma das primeiras mudanças no Java Chassis 3 é a remoção do suporte para encaminhamento em nível de interface. Desta forma, a complexidade da dependência do centro de registo pode ser reduzida em pelo menos 70%. No entanto, as cenas em tons de cinza ainda são importantes para muitas empresas. Java Chassis 3 usa publicação em tons de cinza para resolver esse problema. A vantagem de usar a publicação em escala de cinza é que você não precisa depender do centro de registro para fornecer recursos de gerenciamento de metadados de versão e só precisa que cada instância tenha informações simples de metadados, como números de versão.

servicecomb: 
  # habilitar roteador para serviço de borda 
  roteador: 
    tipo: roteador 
  routeRule: 
    business: | 
      - precedência: 2 
        correspondências: 
          apiPath: 
            prefixo: "/business/v2" 
        rota: 
          - peso: 100 
            tags: 
              versão: 2.0.0 
      - precedência: 1 
        correspondência: 
          apiPath: 
            prefixo: "/business/v1/dec" 
        rota: 
          - peso: 50 
            tags: 
              versão: 1.1.0 
          - peso: 50 
            tags: 
              versão: 2.0.0

Interface de descoberta de registro e sua implementação

Java Chassis 3 fornece novo suporte à descoberta de registro usando apenas interfaces. O Java Chassis chamará a instância de consulta. Se as instâncias subsequentes mudarem, a implementação do centro de registro notificará o Java Chassis. Discovery findServiceInstances InstanceChangedListener

/** 
 * Esta é a interface principal de descoberta de serviço. <br/> 
 */ 
public interface Discovery<D estende DiscoveryInstance> estende SPIEnabled, SPIOrder, LifeCycle { 
  interface InstanceChangedListener<D estende DiscoveryInstance> { 
    /** 
     * Chamado pelas implementações de descoberta quando a lista de instâncias é alterada. 
     * @param RegistryName Nome da implementação de descoberta de chamada 
     * @param application Aplicativo de microsserviço 
     * @param serviceName Nome do microsserviço 
     * @param updatedInstances As instâncias atualizadas mais recentemente. 
     */ 
    void onInstanceChanged(String RegistryName, String application, String serviceName, List<D> atualizadoInstances); 
  } 

  String nome(); 

  /** 
   * Se esta implementação estiver habilitada para este microsserviço. 
   */ 
  boolean habilitado(String aplicativo, String serviceName); 

  /** 
   * Encontre todas as instâncias. 
   * 
   * Ciclo de vida: Este método é chamado a qualquer momento após <code>executar</code>. 
   * 
   * @param application application 
   * @param serviceName nome do microsserviço 
   * @return todas as instâncias correspondem aos critérios. 
   */ 
  List<D> findServiceInstances(String aplicativo, String serviceName); 

  /** 
   * O Discovery pode chamar InstanceChangedListener quando a instância é alterada. 
   */ 
  void setInstanceChangedListener(InstanceChangedListener<D> instanceChangedListener); 
}

Java Chassis 3 gerencia o registro. O processo de registro é dividido em , e um ciclo de vida simples. Você pode preparar os dados de registro e executar o registro. Ele será executado quando o registro falhar ou o sistema parar. Registration initrundestroy init run destroy

/** 
 * Esta é a interface principal de registro do serviço. <br/> 
 */ 
interface pública Registro<R estende RegistrationInstance> estende SPIEnabled, SPIOrder, LifeCycle { 
  String name(); 

  /** 
   * get MicroserviceInstance </br> 
   * 
   * Ciclo de vida: Este método é chamado a qualquer momento após <code>executar</code>. 
   */ 
  R getMicroserviceInstance(); 

  /** 
   * atualizar status da MicroserviceInstance </br> 
   * 
   * Ciclo de vida: Este método é chamado a qualquer momento após <code>executar</code>. 
   */ 
  boolean updateMicroserviceInstanceStatus(status MicroserviceInstanceStatus); 

  /** 
   * adicionando esquemas ao microserviço </br> 
   * 
   * Ciclo de vida:Este método é chamado depois de <code>init</code> e antes de <code>run</code>. 
   */ 
  void addSchema(String esquemaId, String conteúdo); 

  /** 
   * adicionando endpoints ao MicroserviceInstance </br> 
   * 
   * Ciclo de vida:Este método é chamado depois de <code>init</code> e antes de <code>run</code>. 
   */ 
  void addEndpoint(String ponto final); 

  /** 
   * adicionando propriedade a MicroserviceInstance </br> 
   * 
   * Ciclo de vida:Este método é chamado depois de <code>init</code> e antes de <code>run</code>. 
   */ 
  void addProperty(chave String, valor String); 
}

Registrar combinações descobertas

Java Chassis 3 pode implementar de forma independente múltiplas somas para registrar-se em vários centros de registro e descobrir instâncias de vários centros de registro. Cada instância é identificada exclusivamente por seu ID de instância. Se os IDs das instâncias forem iguais, serão considerados como sendo a mesma instância; se forem diferentes, serão considerados como sendo instâncias diferentes. Conforme mencionado no artigo, o Java Chassis exige que cada registro de instância (novo processo) gere um ID de instância exclusivo para resolver o problema de falsas instâncias offline causadas pelo isolamento da partição de registro. e ambos contêm informações básicas definidas pelo Java Chassis. Discovery Registration Java Chassis 3技术解密：注册中心分区隔离 Discovery Registration

/** 
 * Informações padrão usadas para registro e descoberta de instâncias de microsserviço. 
 */ 
public interface MicroserviceInstance { 
  /** 
   * Environment(Required): Usado para separação lógica da instância de microsserviço. Apenas 
   * instâncias de microsserviço com o mesmo ambiente podem descobrir umas às outras. 
   */ 
  String getEnvironment(); 

  /** 
   * Application(Required): Usado para separação lógica da instância de microsserviço. Apenas 
   * instâncias de microsserviço com o mesmo aplicativo podem se descobrir. 
   */ 
  String getApplication(); 

  /** 
   * Nome do serviço (obrigatório): identificador exclusivo do microsserviço. 
   */ 
  String getNomeServiço(); 

  /** 
   * Alias do nome do serviço (opcional): identificador exclusivo para microsserviço. 
   * Este alias é usado pela implementação do registro para suportar a renomeação 
   * de um microsserviço, por exemplo, consumidores antigos que usam o nome de serviço antigo podem 
   * encontrar um serviço de microsserviço renomeado. 
   */ 
  String getAlias(); 

  /** 
   * Versão do Serviço(Obrigatório): versão deste microsserviço. 
   */ 
  String getVersão(); 

  /** 
   * Informações do data center (opcional). 
   */ 
  DataCenterInfo getDataCenterInfo(); 

  /** 
   * Descrição do Serviço(Opcional) 
   */ 
  String getDescription(); 

  /** 
   * Propriedades do serviço (opcional) 
   */ 
  Map<String, String> getProperties(); 

  /** 
   * Esquemas de serviço (opcional): informações da API aberta. 
   */ 
  Map<String, String> getSchemas(); 

  /** 
   * Terminais de serviço (opcional). 
   */ 
  List<String> getEndpoints(); 

  /** 
   * ID da instância de microsserviço (obrigatório). Este ID pode ser gerado quando a instância do microsserviço está sendo iniciada 
   * ou atribuído pela implementação do registro. 
   * 
   * Quando a instância do microsserviço for reiniciada, esse ID deverá ser alterado. 
   */ 
  String getInstanceId(); 

  /** 
   * ID do serviço de microsserviço (opcional). Isto é usado para centro de serviço, outras implementações podem não 
   * suportar ID de serviço. 
   */ 
  string padrão getServiceId() { 
    return ""; 
  } 
}

Ao implementar a descoberta de registros, é necessário garantir que as informações básicas definidas pela interface possam ser cadastradas na central de registros, e essas informações possam ser obtidas na consulta às instâncias.

História de cliente: Não colocar todos os ovos na mesma cesta é uma consideração muito importante na seleção de tecnologia. A abertura e a substituibilidade das soluções e a substituibilidade dos serviços em nuvem são questões que preocupam muitos clientes. Para uma estrutura de tecnologia de código aberto, embora a versão inicial do Java Chassis tenha sido projetada para suportar diferentes extensões do centro de registro, era muito difícil de implementar e inconscientemente tornava inviável para os clientes usarem outros centros de registro para substituir o centro de serviço. Fornece uma implementação de descoberta de registro mais simplificada, o que reduz um pequeno número de recursos competitivos, mas reduz bastante as preocupações de seleção dos clientes.

Clique para seguir e conhecer as novas tecnologias da Huawei Cloud o mais rápido possível~