Olá a todos, aqui está o terceiro post da série Quarkus!
Ao desenvolver microsserviços Java, muitas vezes acredita-se que и são APIs separadas e independentes. Por padrão, os programadores tendem a usar as APIs com as quais já estão acostumados, pois aprender novas estruturas e componentes de tempo de execução leva muito tempo. Hoje tentaremos simplificar o desenvolvimento de alguns populares e mostrar como usar simultaneamente a API Spring e novos recursos úteis .
Com um pouco mais de detalhes, primeiro veremos o escopo e os detalhes de como o Quarkus suporta APIs Spring para mostrar aos desenvolvedores Spring como usar a API MicroProfile em seu trabalho diário. Em seguida, abordaremos as APIs MicroProfile, que são úteis para desenvolvedores Spring ao criar microsserviços.
Por que Quarkus? Em primeiro lugar, trata-se de live coding, ou seja, recarregamento automático de quaisquer alterações na API MicroProfile, API Spring e outras APIs Java, que é realizado com apenas um comando: mvn quarkus:dev. Em segundo lugar, considerado em o serviço Person (que compila APIs Spring, MicroProfile e JPA em um binário usando a imagem nativa do GraalVM) começa em apenas 0.055 segundos e ocupa cerca de 90 MB de RAM (RSS) no endpoint do aplicativo RESTful. Além disso, sua compilação em si é realizada com apenas um comando: mvn package -Pnative.
Não entraremos em detalhes sobre o MicroProfile, a não ser para ajudar os desenvolvedores Spring a entender como eles podem usar APIs Spring com APIs MicroProfile no Quarkus.
Contêineres e Kubernetes
Para manter este artigo simples, abordaremos apenas os aspectos de suporte de alto nível aqui. , porque é importante entender. O Quarkus está posicionado como uma pilha Java para Kubernetes, projetado para minimizar o consumo de memória e o tempo de inicialização de aplicativos e serviços Java e, como resultado, aumentar sua densidade no host e reduzir custos gerais.
Quarkus também Recursos e ofertas do Kubernetes para implantação nas plataformas Kubernetes e Red Hat OpenShift. Além disso, o Quarkus gera automaticamente os arquivos Dockerfile.jvm (empacotamento JVM) e Dockerfile.native (empacotamento binário nativo) necessários para criar contêineres.
Por fim, ao focar no Kubernetes como ambiente de implantação de destino, o Quarkus não usa estruturas Java nos casos em que funcionalidades semelhantes são implementadas no nível da própria plataforma Kubernetes. A Tabela 1 fornece um mapa da correspondência funcional entre Kubernetes e estruturas Java típicas usadas por desenvolvedores Spring.
Tabela 1. Mapa de correspondência funcional entre frameworks Java e Kubernetes.
funcional
Bota Primavera Tradicional
Kubernetes
Descoberta de serviço
Eureka
DNS
Configuração
Configuração do Spring Cloud
Configurar mapas/segredos
Balanceamento de carga
Faixa de opções (lado do cliente)
Serviço, controlador de replicação (lado do servidor)
Compilando e executando o código do exemplo
Neste artigo nos referimos a , onde as APIs Spring e MicroProfile e até mesmo a mesma classe Java são usadas juntas. O código neste exemplo pode ser compilado e executado a partir da linha de comando; consulte o arquivo README.md para obter detalhes.
APIs do Spring Framework
Injeção de dependência
Quarkus suporta uma variedade de e APIs de injeção de dependência Spring (Spring DI). Se você estiver trabalhando com MicroProfile, , então você já está familiarizado com o CDI. Por outro lado, os desenvolvedores do Spring podem usar a API Quarkus Extension for Spring DI para obter compatibilidade com o Spring DI. Exemplos de uso das APIs Spring DI suportadas são fornecidos na Tabela 2.
В Usa CDI e injeção de dependência Spring. Para mais informações e exemplos sobre este tópico, consulte o guia do Quarkus chamado .
Tabela 2. Exemplos de uso das APIs Spring DI suportadas.
Recursos suportados do Spring DI
Примеры
Injeção de construtor
public PersonSpringController(
PersonSpringRepository personRepository, // injected
PersonSpringMPService personService) { // injected
this.personRepository = personRepository;
this.personService = personService;
}
Injeção de Campo
@Autowired
@RestClient
SalutationRestClient salutationRestClient;
@Value("${fallbackSalutation}")
String fallbackSalutation;
@Configuração
@Configuration
public class AppConfiguration {
@Bean(name = "capitalizeFunction")
public StringFunction capitalizer() {
return String::toUpperCase;
}
}
@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
@Override
public String apply(String s) {
return s;
}
}
@Service
public class MessageProducer {
@Value("${greeting.message}")
String message;
public String getPrefix() {
return message;
}
}
Estrutura da web
Os usuários do MicroProfile vão adorar o fato de o Quarkus oferecer suporte a JAX-RS, MicroProfile Rest Client, JSON-P e JSON-B como o principal modelo de programação da web. Os desenvolvedores Spring ficarão satisfeitos com o suporte recente do Quarkus para a API Spring Web, em particular interfaces REST. Semelhante ao Spring DI, o objetivo principal do suporte ao Spring Web API é permitir que os desenvolvedores do Spring usem Spring Web APIs em conjunto com APIs MicroProfile. Exemplos de como usar as APIs Spring Web suportadas são fornecidos na Tabela 3, e mais informações e exemplos sobre este tópico podem ser encontrados no tutorial do Quarkus chamado .
Tabela 3. Exemplos de uso das APIs Web Spring suportadas.
Recursos suportados do Spring Web
Примеры
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
...
...
...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrizVariável
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (parcial)
@GetMapping(path = "/greet/{id}",
produces = "text/plain")
public String greetPerson(
@PathVariable(name = "id") long id) {
...
...
...
}
Spring Data JPA
Os usuários do MicroProfile também apreciarão que o Quarkus suporta JPA usando o Hibernate ORM. Também há boas notícias para os desenvolvedores do Spring: o Quarkus suporta anotações e tipos comuns do Spring Data JPA. Exemplos de uso das APIs Spring Data JPA suportadas são fornecidos na Tabela 4.
В APIs Spring Data JPA são usadas e mais informações estão disponíveis no tutorial do Quarkus chamado .
Tabela 4. Exemplos de uso de APIs Spring Data JPA suportadas.
Recursos suportados do Spring Data JPA
Примеры
CrudRepositoryName
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Repositório
JpaRepositoryName
Repositório de paginação e classificação
public class PersonRepository extends
Repository {
Person save(Person entity);
Optional findById(Person entity);
}
Fragmentos de repositório
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Métodos de consulta derivados
public interface PersonRepository extends CrudRepository {
List findByName(String name);
Person findByNameBySsn(String ssn);
Optional
findByNameBySsnIgnoreCase(String ssn);
Boolean existsBookByYearOfBirthBetween(
Integer start, Integer end);
}
Consultas definidas pelo usuário
public interface MovieRepository
extends CrudRepository {
Movie findFirstByOrderByDurationDesc();
@Query("select m from Movie m where m.rating = ?1")
Iterator findByRating(String rating);
@Query("from Movie where title = ?1")
Movie findByTitle(String title);
}
APIs MicroProfile
Tolerância ao erro
As construções de tolerância a falhas são muito importantes para evitar falhas em cascata e criar arquiteturas de microsserviços confiáveis. Os desenvolvedores do Spring têm usado disjuntores para tolerância a falhas há muitos anos. . No entanto, o Hystrix não é atualizado há muito tempo, mas o Fault Tolerance do MicroProfile está agora em desenvolvimento ativo e tem vários anos de uso em produção. Portanto, para melhorar a confiabilidade dos serviços no Quarkus, recomenda-se a utilização das APIs MicroProfile Fault Tolerance, cujos exemplos são utilizados na Tabela 5. Para mais informações sobre isso, consulte o manual do Quarkus .
Tabela 5. Exemplos de uso de APIs MicroProfile Fault Tolerance suportadas.
Recursos de tolerância a falhas do MicroProfile
descrição
Примеры
@Assíncrono
Executando lógica em um thread separado
@Asynchronous
@Retry
public Future<String> getSalutation() {
...
return future;
}
@Antepara
Limite o número de solicitações simultâneas
@Bulkhead(5)
public void fiveConcurrent() {
makeRemoteCall(); //...
}
@Disjuntor
Tratamento inteligente de falhas e recuperação de falhas
@CircuitBreaker(delay=500 // milliseconds
failureRatio = .75,
requestVolumeThreshold = 20,
successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
@Cair pra trás
Chamando lógica alternativa em caso de falha
@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
public String fallback() {
return "hello";
}
Tentar novamente mediante falha na solicitação
@Retry(maxRetries=3)
public String getSalutation() {
makeRemoteCall(); //...
}
Tempo limite de controle de falha
@Timeout(value = 500 ) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
Verificando serviços (Saúde do Serviço)
As plataformas Kubernetes monitoram a integridade dos contêineres usando serviços especiais. Para permitir que a plataforma subjacente monitore serviços, os desenvolvedores do Spring normalmente usam um HealthIndicator e um Spring Boot Actuator personalizados. No Quarkus, isso pode ser feito usando o MicroProfile Health, que por padrão realiza uma verificação de atividade, mas pode ser configurado para verificar simultaneamente a atividade e a prontidão. Exemplos de como usar as APIs MicroProfile Health suportadas são fornecidos na Tabela 6, e informações adicionais são fornecidas no manual do Quarkus .
Tabela 6: Exemplos de uso de APIs MicroProfile Health suportadas.
Recursos de saúde do MicroProfile
descrição
Примеры
@Liveness
A plataforma reinicia aplicativos em contêineres com falha
Endpoint:
anfitrião: 8080/saúde/ao vivo
@Liveness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(ready ? true:false)
.withData("mydata", data)
.build();
}
@Prontidão
A plataforma não enviará tráfego para aplicações em contêineres se não estiver pronta
Endpoint:
anfitrião:8080/saúde/pronto
@Readiness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(live ? true:false)
.withData("mydata", data)
.build();
}
Métricas
Os aplicativos fornecem métricas para fins operacionais (para monitorar SLAs de desempenho) ou para fins não operacionais (SLAs de negócios). Os desenvolvedores Spring fornecem métricas usando Spring Boot Actuator e Micrometer. Por sua vez, o Quarkus usa MicroProfile Metrics para fornecer métricas de linha de base (JVM e sistema operacional), métricas de fornecedores (Quarkus) e métricas de aplicativos. O MicroProfile Metrics requer que a implementação suporte formatos de saída JSON e OpenMetrics (Prometheus). Exemplos de uso da API MicroProfile Metrics são fornecidos na Tabela 7.
В As métricas do MicroProfile são usadas para fornecer métricas de aplicativos. Para mais informações, consulte o manual do Quarkus .
Tabela 7. Exemplos de uso de APIs de métricas do MicroProfile.
Recursos de métricas do MicroProfile
descrição
Примеры
@Contado
Denota um contador contador que conta o número de vezes que um objeto anotado foi chamado
@Counted(name = "fallbackCounter",
displayName = "Fallback Counter",
description = "Fallback Counter")
public String salutationFallback() {
return fallbackSalutation;
}
@ConcurrentGauge
Denota um medidor que conta o número de chamadas simultâneas para um objeto anotado
@ConcurrentGuage(
name = "fallbackConcurrentGauge",
displayName="Fallback Concurrent",
description="Fallback Concurrent")
public String salutationFallback() {
return fallbackSalutation;
}
@Medidor
Denota um sensor de medidor que mede o valor de um objeto anotado
@Metered(name = "FallbackGauge",
displayName="Fallback Gauge",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
@Medido
Denota um sensor de medidor que monitora a frequência de chamada de um objeto anotado
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Uma anotação contendo informações sobre metadados quando uma solicitação é recebida para inserir ou produzir uma métrica
@Metric
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Indica um temporizador que rastreia a duração de um objeto anotado
@Timed(name = "TimedFallback",
displayName="Timed Fallback",
description="Fallback delay")
public String salutationFallback() {
return fallbackSalutation;
}
Pontos finais de métricas
Métricas de aplicação :8080/métricas/aplicação
Métricas básicas :8080/métricas/base
Métricas do fornecedor :8080/métricas/fornecedor
Todas as métricas :8080/métricas
Cliente Rest do MicroProfile
Os microsserviços geralmente fornecem endpoints RESTful que exigem APIs de cliente correspondentes para funcionar. Para usar endpoints RESTful, os desenvolvedores Spring normalmente usam RestTemplate. Quarkus oferece APIs MicroProfile Rest Client para resolver esse problema, cujos exemplos de uso são fornecidos na Tabela 8.
В o uso de endpoints RESTful é feito usando o MicroProfile Rest Client. Mais informações e exemplos sobre este tópico podem ser encontrados no manual do Quarkus .
Tabela 8. Exemplos de uso de APIs do MicroProfile Rest Client.
Recursos do cliente MicroProfile Rest
descrição
Примеры
@RegisterRestClient
Registra uma interface Java digitada como um cliente REST
@RegisterRestClient
@Path("/")
public interface MyRestClient {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getSalutation();
}
@RestClient
Marca a implementação de uma instância de uma interface de cliente REST digitada
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Invocação
Chama um endpoint REST
System.out.println(
restClient.getSalutation());
mp-rest/url
Especifica o ponto final REST
application.properties:
org.example.MyRestClient/mp-rest/url=
http://localhost:8081/myendpoint
Resultados de
Neste blog, voltado principalmente para desenvolvedores Spring, demos uma rápida olhada em como usar as APIs Spring com as APIs MicroProfile no Quarkus para desenvolver microsserviços Java e depois compilá-los em código binário nativo que economiza centenas de megabytes de RAM e inicia em questão de milissegundos.
Como você já entendeu, mais informações sobre o suporte às APIs Spring e MicroProfile, bem como muitas outras informações úteis, podem ser encontradas em .
Fonte: habr.com