Este artigo é compartilhado da comunidade Huawei Cloud " Guia rápido de desenvolvimento e uso para plug-ins de governança de serviços sob a estrutura Sermant " por Huawei Cloud Open Source.
Sermant é uma malha de serviço nativa da nuvem, sem agente, baseada na tecnologia de aprimoramento de bytecode Java. É não intrusiva, plugável e de alto desempenho. Através da estrutura principal do Sermant, plug-ins para vários fins de gerenciamento de serviços podem ser facilmente desenvolvidos, incluindo balanceamento de carga, controle de fluxo, roteamento de rótulos, transmissão transparente de rótulos, etc. Neste artigo, utilizamos um caso para explicar como desenvolver um plug-in que conta a duração da chamada com base no Sermant e utilizá-lo para implantação no ambiente de produção.
1. Desenvolvimento de plug-ins
Neste capítulo, demonstraremos completamente o processo de desenvolvimento de plug-ins de governança de serviço usando a estrutura Sermant do zero, com base no modelo de desenvolvimento de plug-in fornecido oficialmente pela Sermant.
A principal tarefa que este plug-in de modelo precisa implementar é interceptar e aprimorar o método de interface do controlador do aplicativo host e calcular o tempo de execução do método.
A seguir, vamos iniciar o caminho do código de desenvolvimento do plug-in!
Sermant fornece oficialmente código de modelo para desenvolvimento de plug-ins. Execute as seguintes instruções do Maven para extrair:
Arquétipo $ mvn: gerar -DarchetypeGroupId=com.huaweicloud.sermant -DarchetypeArtifactId=sermant-template-archetype -DarchetypeVersion=1.2.0 -DgroupId=com.huaweicloud.sermant -Dversion=1.2.0 -Dpackage=com.huaweicloud -DartifactId= primeiro plugin
Para etapas e detalhes específicos de implementação, consulte o site oficial da Sermant para criar o primeiro documento do plug-in . O código do modelo pré-projeta a estrutura do projeto e a configuração do arquivo pom para o desenvolvimento do plug-in, para que possamos nos concentrar melhor na implementação das funções do plug-in. O código mostrado abaixo foi desenvolvido com base neste modelo. Também fornecemos nosso código de exemplo desenvolvido na primeira demonstração de plug-in do Sermant -example.
1.1 Desenvolvimento do módulo principal do plug-in
O módulo principal do plug-in é a implementação principal do plug-in e os desenvolvedores precisam declarar a lógica aprimorada do plug-in neste módulo.
O módulo principal do plug-in precisa determinar quais classes do aplicativo host interceptar. Neste artigo, as classes interceptadas do aplicativo host são as seguintes:
pacote com.huaweicloud.template;
@RestController
classe pública Controlador {
@RequestMapping("digaOlá")
public void sayHello(String nome) lança InterruptedException {
System.out.println("olá " + nome);
Thread.sleep(5);
}
}
O módulo principal do plug-in precisa completar a lógica de aprimoramento que calcula a execução demorada do método sayHello, portanto, primeiro precisamos interceptar o método sayHello da classe Controller e, em seguida, realizar cálculos pré e pós-aprimoramento no método no interceptor.
Crie o pacote com.huawei.sermant.template no módulo template-plugin. As classes criadas nesta seção estão todas localizadas neste pacote.
1) Crie a classe TemplateDeclarer, que herda da classe com.huaweicloud.sermant.core.plugin.agent.declarer.AbstractPluginDeclarer.Você precisa substituir o método getClassMatcher e o método getInterceptDeclarers da classe pai. O nome da classe e o nome do método usado para declarar a interceptação aprimorada de bytecode e o interceptor correspondente. Os detalhes de implementação do código são os seguintes:
classe pública TemplateDeclarer estende AbstractPluginDeclarer {
@Sobrepor
public ClassMatcher getClassMatcher() {
// Corresponde às classes que precisam ser interceptadas. Existem vários métodos de correspondência. Aqui usamos o nome totalmente qualificado da classe para correspondência.
retornar ClassMatcher.nameEquals("com.huaweicloud.template.Controller");
}
@Sobrepor
public InterceptDeclarer[] getInterceptDeclarers(ClassLoader classLoader) {
// Retorna o array InterceptDeclarer. Cada InterceptDeclarer determina o método e o Interceptor que ele precisa interceptar.
retornar novo InterceptDeclarer[]{
// Corresponde aos métodos que precisam ser interceptados. Existem vários métodos de correspondência. Aqui, o nome do método é usado para correspondência.
InterceptDeclarer.build(MethodMatcher.nameEquals("sayHello"), novo TemplateInterceptor())
};
}
}
A classe ClassMatcher e a classe MethodMatcher possuem vários métodos correspondentes. Você pode verificar a documentação de aprimoramento de bytecode .
2) Crie a classe TemplateInterceptor, que precisa implementar a interface com.huaweicloud.sermant.core.plugin.agent.interceptor.Interceptor e reescrever os métodos antes, depois e onThrow da interface para obter pré-aprimoramento e pós- pontos de interceptação, respectivamente.Definir lógica de código de aprimoramento e tratamento de exceções. Os detalhes de implementação do código são os seguintes:
classe pública TemplateInterceptor implementa Interceptor {
string final estática privada START_TIME = "startTime";
@Sobrepor
public ExecuteContext antes (contexto ExecuteContext) {
context.setLocalFieldValue(START_TIME, System.currentTimeMillis());
System.out.println("A hora em que o método gravado começou a ser executado");
contexto de retorno;
}
@Sobrepor
public ExecuteContext after(contexto ExecuteContext) {
endTime longo = System.currentTimeMillis();
tempo decorrido longo = endTime - (longo) context.getLocalFieldValue(START_TIME);
System.out.println("Consumo de tempo do método: " + elapsedTime + "milissegundos");
contexto de retorno;
}
@Sobrepor
public ExecuteContext onThrow(contexto ExecuteContext) {
contexto de retorno;
}
}
Registramos o horário de início da execução do método interceptado no método before, calculamos o tempo de execução do método interceptado no método after e o imprimimos no console.
3) Adicione a configuração SPI da declaração aprimorada, adicione o diretório META-INF/services ao diretório de recursos em template/template-plugin no projeto e crie um nome nele chamado com.huaweicloud.sermant.core.plugin. arquivo SPI de agent.declarer .PluginDeclarer e adicione o nome da classe de declaração aprimorada de bytecode a ele:
com.huaweicloud.sermant.template.TemplateDeclarer
Neste ponto, o desenvolvimento da lógica do código do módulo principal do plug-in está concluído, implementamos a interceptação da classe alvo e aprimoramos os métodos da classe interceptada.
1.2 Embalagem e construção de plug-ins
Execute o comando maven no diretório de modelo para empacotar e construir o plug-in de modelo:
pacote limpo mvn
Após a conclusão da construção, o diretório agent/ será gerado. A estrutura de arquivo específica é a seguinte:
. ├── comum ├── arquivo de configuração do Sermant ├── núcleo ├── Deus ├── implementado ├──Application.jar aplicativo host, que pode ser substituído por seu próprio aplicativo desenvolvido ├── sermant-agent.jar Produto Sermant Agent, usado para montagem e uso por aplicativos host └── pluginPackage └── modelo ├── arquivo de configuração do plug-in config ├── módulo principal do plug-in └── módulo de serviço do plug-in de serviço
Agora que concluímos um plug-in simples que pode calcular o tempo gasto pelos métodos interceptados, começaremos a mostrar o efeito do plug-in.
2. Uso do Agente Sermant
2.1 Iniciar Agente Sermant
Sermant habilita o serviço de configuração dinâmica por padrão. Modifique o arquivo config.properties no diretório config para desligar o serviço de configuração dinâmica:
# Configurar switches de serviço dinamicamente agente.service.dynamic.config.enable=falso
Entre no diretório do produto agent/ construído no Capítulo 1.2 e inicie o Sermant Agent no modo pré-principal configurando a diretiva -javaagent para o serviço host:
java -javaagent:sermant-agent.jar -jar Application.jar
O console imprime a seguinte saída, indicando que o Sermant Agent foi iniciado com êxito no modo pré-principal.
[2023-1024T17:26:49.049] [INFO] Carregando a biblioteca de deuses no BootstrapClassLoader. [2023-10-24T17:26:49.153] [INFO] Construindo mapa de argumentos por argumentos do agente. [2023-10-24T17:26:49.161] [INFO] Carregando a biblioteca principal no SermantClassLoader. [2023-10-24T17:26:49.162] [INFO] Carregando agente sermant, o artefato é: padrão [2023-10-24T17:26:49.740] [INFO] Carregamento do sermant concluído, o artefato é: padrão
O Sermant Agent também pode realizar a montagem enquanto o aplicativo host está sendo executado por meio do método agentmain. Para obter mais detalhes sobre o uso do Sermant Agent, consulte o documento Sermant .
2.2 Verificação
O aplicativo host montou com sucesso o Agente Sermant. Nesta seção verificaremos se a lógica de aprimoramento do plug-in entra em vigor.
Execute o seguinte comando para iniciar uma solicitação get para o serviço de interface do aplicativo host:
curl http://127.0.0.1:8080/sayHello?name=lihua
A saída impressa pelo console do aplicativo host é a seguinte:
O horário em que a execução do método foi iniciada foi registrado olá lihua O método leva: 20 milissegundos ECHO: Muitas felicidades para você!
Pode-se observar que o Agente Sermant interceptou com sucesso as classes da aplicação host e executou a lógica aprimorada.
3. Funções avançadas do servo
3.1 Back-end do Servo
Sermant Backend inclui módulo back-end de processamento de dados Sermant e módulo de exibição de informações front-end, com o objetivo de fornecer recursos de observabilidade em tempo de execução para Sermant. Atualmente, inclui principalmente funções como informações de pulsação do Agente Sermant, recepção e exibição de eventos relatados e webhook push .
Sermant Backend funciona com Sermant Agent. O Sermant Agent é montado no aplicativo host. Como remetente de dados, ele pode enviar regularmente os dados de pulsação do Sermant Agent atual (nome do serviço, nome do host, ID da instância, número da versão, IP, carimbo de data/hora, informações de montagem do plug-in) e eventos dados (inicialização e parada do agente Sermant, início e parada do serviço principal, aprimoramento de bytecode, dados de log, etc.)
Backend é um componente não essencial. Os usuários podem implantá-lo sob demanda e obter o componente Backend baixando pacote de lançamento do Sermant-1.2.0. Descompacte o pacote de lançamento, entre no diretório sermant-agent/server/sermant e execute o seguinte comando para iniciar o Sermant Backend:
java -jar sermant-backend-1.2.0.jar
Acesse o endereço http://127.0.0.1:8900/ . Se você vir a página a seguir, significa que o Sermant Backend foi iniciado com sucesso;
O Agente Sermant precisa configurar os parâmetros do Agente ao usar o Backend. Modifique o arquivo config.properties no diretório agent (diretório de produto criado no Capítulo 1)/config.
Os itens de configuração precisam ser modificados como:
# Ative o interruptor de serviço de pulsação agente.service.heartbeat.enable=true # Ative o switch de serviço do gateway unificado agente.service.gateway.enable=true
Consulte a Seção 2.1 para iniciar o Agente Sermant. Você pode ver o Agente Sermant iniciado e as informações do plug-in do modelo montado na página front-end do backend:
Para obter mais detalhes sobre o backend, consulte o documento Sermant .
3.2 Função de registro
Os logs são um recurso indispensável no desenvolvimento de programas. Por meio dos logs, você pode descobrir rapidamente o status do programa quando ele está em execução e os problemas encontrados.
Os produtos JavaAgent são propensos a conflitos com classes de aplicativos host e conflitos de configuração de log ao usar classes de log. O sistema de log construído por Sermant resolve esse problema. O sistema de log Sermant é construído em JUL&logback, fornecendo uma configuração completa e flexível e uma ferramenta de log que evita conflitos de classe para o desenvolvimento de plug-ins. O sistema de log fornecido pelo Sermant pode ser completamente isolado dos microsserviços do host, desde a configuração até a execução. Além disso, combinado com o componente Sermant Backend, o sistema de log Sermant pode fornecer coleta e relatórios unificados de eventos anormais.
Agora precisamos registrar o tempo de execução do método interceptado no log. Esta seção demonstrará como usar o sistema de logging fornecido pelo Sermant.
3.2.1 Adicionar registro
Definimos uma constante estática privada LOGGER na classe TemplateInterceptor do módulo principal do plug-in, que é usada para construção de log nesta classe.
//Classe de log Sermant privado estático final Logger LOGGER = LoggerFactory.getLogger();
A seguir, usamos o log no método after desta classe para registrar o tempo de execução do método interceptado. O nível deste log é INFO.
LOGGER.info("Método demorado: " + elapsedTime);
O sistema de log Sermant pode registrar logs de vários níveis (TRACE, DEBUG, INFO, WARN, ERROR) para atingir diferentes níveis de monitoramento da operação do programa.
Para obter mais detalhes, consulte a documentação da função de log .
3.2.2 Demonstração de registros
Inicie o Sermant e chame a interface do aplicativo host de acordo com o método do Capítulo 2:
curl http://127.0.0.1:8080/sayHello?name=lihua
Vá para o diretório logs/sermant/core/app/xxxx-xx-xx para visualizar o log do Sermant. "xxxx-xx-xx" é a hora em que o log foi gravado. Você pode ver que o consumo de tempo do método foi registrado com sucesso no arquivo de log.
[INFO] [com.huaweicloud.sermant.template.TemplateInterceptor] [após:45] [http-nio-8080-exec-1] Tempo do método: 20
3.2.3 Relatórios de log anormais
Os logs de alerta e nível de erro coletados uniformemente pelo sistema de log Sermant podem ser carregados no Sermant Backend para observação. Imprimiremos manualmente o log de exceções e observaremos através do Backend.
Imprima um log em nível de aviso no método before da classe TemplateInterceptor do módulo principal do plug-in e imprima um log em nível de erro no método after:
LOGGER.warning("mensagem de aviso");
LOGGER.severe("mensagem de erro");
Modifique o arquivo config.properties no diretório config para ativar configurações relacionadas ao relatório de eventos:
#Mudança do sistema de eventos evento.enable=true # Interruptor de relatório de eventos de log de nível de aviso event.offerWarnLog=true # Chave de relatório de eventos de log de nível de erro event.offerErrorLog=true
Inicie o Sermant e chame a interface do aplicativo host de acordo com o método do Capítulo 2:
curl http://127.0.0.1:8080/sayHello?name=lihua
Vá para a página de front-end do Sermant Backend para ver as informações de exceção relatadas:
3.3 Configuração dinâmica
3.3.1 Adicionar configuração dinâmica
Sermant fornece funções de configuração dinâmica e atualmente suporta Zookeeper, Nacos e Kie como centros de configuração. A função de configuração dinâmica permite que Sermant execute operações de gerenciamento e monitoramento de configuração nas configurações emitidas pelo centro de configuração dinâmica para obter recursos de governança de serviço ricos e diversificados. Esta seção toma o Zookeeper como exemplo para demonstrar como usar o serviço de configuração dinâmica do Sermant para adicionar um switch para executar lógica aprimorada neste plug-in.
Primeiro, adicione um campo Map à classe TemplateInterceptor no módulo principal do plug-in para simular o estado do switch. ENABLE_KEY é o nome do switch e defina o estado padrão do switch como true:
private static final Map<String, Boolean> CONFIG_MAP = new HashMap<>();
private static final String ENABLE_KEY = "enable";
{
//O estado padrão do switch é verdadeiro
CONFIG_MAP.put(ENABLE_KEY, verdadeiro);
}
Em seguida, adicione opções no método before e after:
if (!CONFIG_MAP.get(ENABLE_KEY)) {
System.out.println("Não execute lógica aprimorada");
contexto de retorno;
}
Em seguida, precisamos modificar dinamicamente o status do switch, adicionar o campo de serviço de configuração dinâmica, obter a instância da classe de serviço de configuração dinâmica e registrar um ouvinte para monitorar as alterações do nó correspondente no Zookeeper:
// Obtém a instância da classe de serviço de configuração dinâmica
private final DynamicConfigService dynamicConfigService = ServiceManager.getService(DynamicConfigService.class);
// Obtenha o analisador yaml fornecido pela estrutura Sermant
conversor YamlConverter final privado = OperationManager.getOperation(YamlConverter.class);
{
dynamicConfigService.addConfigListener("template-config", "sermant/template-plugin",
novo DynamicConfigListener() {
@Sobrepor
processo público void (evento DynamicConfigEvent) {
// analisa o arquivo yaml no mapa
Opcional<Map<String, Object>> convertOptional = converter.convert(event.getContent(), Map.class);
if (convertOptional.isPresent()) {
//Modifica o status do switch
CONFIG_MAP.put(ENABLE_KEY, (booleano) convertOptional.get().get(ENABLE_KEY));
}
System.out.println("O item de configuração do plug-in foi alterado, o valor do item de configuração é: " + event.getContent());
}
});
}
Para usar a configuração dinâmica, é necessário ativar a chave do serviço de configuração dinâmica e modificar o arquivo config.properties no diretório config:
# Configurar switches de serviço dinamicamente agente.service.dynamic.config.enable=true
3.3.2 Demonstração de configuração dinâmica
Para habilitar o serviço de configuração dinâmica, você precisa iniciar o zookeeper localmente. Inicie o aplicativo host e monte o Agente Sermant e inicie uma chamada para o serviço de interface do aplicativo host:
curl http://127.0.0.1:8080/sayHello?name=lihua
Neste momento, a chave está ligada por padrão e a saída do console é a seguinte:
O horário em que a execução do método foi iniciada foi registrado olá lihua O método leva: 23 milissegundos
Comece a entregar a configuração dinâmica, crie o nó /sermant/template-plugin/template-config e defina o valor do nó como "enable: false":
criar /servo criar /sermant/template-plugin crie /sermant/template-plugin/template-config enable: falso
O console do aplicativo host imprime a seguinte saída:
O item de configuração do plug-in foi alterado e o valor do item de configuração é: enable: false
Faça outra chamada para o serviço de interface do aplicativo host:
curl http://127.0.0.1:8080/sayHello?name=lihua
Você pode ver que o console imprime o conteúdo de que a lógica aprimorada não foi executada, indicando que a configuração dinâmica foi entregue com sucesso:
A lógica de aprimoramento não é executada olá lihua A lógica de aprimoramento não é executada
A demonstração da configuração dinâmica termina aqui. Para obter mais detalhes sobre a configuração dinâmica, consulte o documento da função de configuração dinâmica .
4. Resumo deste capítulo
Este artigo apresenta o processo de desenvolvimento rápido de plug-ins de governança de serviço com base na estrutura Sermant e como usar o produto Sermant Agent. Pode-se descobrir que através dos recursos fornecidos pela estrutura subjacente do Sermant, podemos facilmente desenvolver plug-ins que atendam às nossas próprias necessidades.Ao mesmo tempo, combinados com o sistema de log do Sermant, configuração dinâmica e componentes de backend, podemos aprimorar as funções do plug-in de gerenciamento de serviços de maneira mais precisa e flexível. Sermant é uma grade de serviço sem agente baseada na tecnologia de aprimoramento de bytecode Java. Não é intrusiva, pode ser plugada e tem alto desempenho. Espero que este artigo seja útil para desenvolvedores que desejam usar os produtos Sermant!
Como uma estrutura de aprimoramento de bytecode com foco no campo de governança de serviços, a Sermant está comprometida em fornecer uma experiência de governança de serviços de alto desempenho, escalonável, fácil de acessar e rica em recursos, e cuidará do desempenho, funcionalidade e experiência em cada versão. , todos são bem-vindos para participar.
- Site oficial do Sermant: https://sermant.io
- Endereço do armazém GitHub: https://github.com/huaweicloud/Sermant
Clique para seguir e conhecer as novas tecnologias da Huawei Cloud o mais rápido possível~
Microsoft lança novo "Windows App" Xiaomi anuncia oficialmente que Xiaomi Vela é totalmente de código aberto e o kernel subjacente é NuttX Vite 5. Alibaba Cloud 11.12 é lançado oficialmente. A causa da falha é exposta: anomalia do serviço de chave de acesso (chave de acesso) . Relatório do GitHub: TypeScript substitui Java e se torna o terceiro mais popular. A operação milagrosa do operador de linguagem: desconectar a rede em segundo plano, desativar contas de banda larga, forçar os usuários a trocar modems ópticos ByteDance: usando IA para ajustar automaticamente os parâmetros do kernel do Linux Código aberto da Microsoft Terminal Chat Spring Framework 6.1 oficialmente GA OpenAI, ex-CEO e presidente Sam Altman e Greg Brockman juntam-se à Microsoft