Olá a todos, e aqui está o terceiro post da série sobre Quarkus!
Ao desenvolver microsserviços Java, muitas vezes considera-se que e é um conjunto de APIs distintas e independentes. Por padrão, os programadores tendem a usar as APIs às quais já estão acostumados, pois estudar novas estruturas e componentes de tempo de execução leva tempo. Hoje, vamos tentar simplificar a aprendizagem de algumas APIs populares do e mostrar como utilizar simultaneamente as APIs do Spring e novas funcionalidades úteis. .
Se formos um pouco mais detalhados, primeiro examinaremos o escopo e os detalhes de como o Quarkus suporta interfaces de API do Spring, para mostrar aos desenvolvedores Spring como aplicar a API MicroProfile em seu trabalho cotidiano. Em seguida, falaremos sobre a API MicroProfile que será útil para desenvolvedores Spring na criação de microsserviços.
Por que Quarkus? Primeiro, porque oferece codificação ao vivo (live coding), ou seja, a reinicialização automática de quaisquer mudanças nas APIs MicroProfile, APIs Spring e outras APIs Java, que é realizada com um único comando: mvn quarkus:dev. Em segundo lugar, o serviço Person (que é compilado a partir das interfaces de API do Spring, MicroProfile e JPA em um arquivo binário usando a imagem nativa do GraalVM) pode ser iniciado em apenas 0,055 segundos e ocupa cerca de 90 MB na memória RAM (RSS) no endpoint da aplicação RESTful. E a própria compilação é feita com um único comando: mvn package -Pnative. Containers e Kubernetes
Para não sobrecarregar este artigo, vamos abordar apenas os aspectos de alto nível de suporte
, pois é importante entender. O Quarkus é posicionado como uma pilha Java para Kubernetes, projetado para minimizar o consumo de memória e o tempo de inicialização de aplicações e serviços Java, e, como resultado, aumentar a densidade de implantação no host e reduzir os custos globais.
O Quarkus também oferece geração automática
de recursos Kubernetes e fornece para implantação em plataformas Kubernetes e Red Hat OpenShift. Além disso, o Quarkus gera automaticamente os arquivos Dockerfile.jvm (empacotamento JVM) e Dockerfile.native (empacotamento de binário nativo), necessários para criar containers. para implantação em plataformas Kubernetes e Red Hat OpenShift. Além disso, Quarkus gera automaticamente arquivos Dockerfile.jvm (empacotamento JVM) e Dockerfile.native (empacotamento de binário nativo), necessários para a criação de containers.
E finalmente, ao considerar o Kubernetes como um ambiente de implantação, o Quarkus não utiliza frameworks Java quando uma funcionalidade semelhante é implementada no próprio nível da plataforma Kubernetes. A Tabela 1 apresenta um mapa de correspondência funcional entre Kubernetes e os frameworks Java típicos usados pelos desenvolvedores Spring.
Tabela 1. Mapa de correspondência entre frameworks Java e Kubernetes.
Funcionalidade
Spring Boot Tradicional
Kubernetes
Descoberta de serviço
Eureka
DNS
Configuração
Spring Cloud Config
Config Maps / Secrets
Balanceamento de carga
Ribbon (do lado do cliente)
Service, Replication Controller (do lado do servidor)
Compilação e execução do código do exemplo
Neste artigo, referimo-nos a , onde APIs Spring e MicroProfile são utilizadas em conjunto, e até mesmo a mesma classe Java. O código deste exemplo pode ser compilado e executado a partir da linha de comando; para mais detalhes, consulte o arquivo README.md.
APIs do Spring Framework
Dependency Injection
O Quarkus suporta uma série de e APIs de Injeção de Dependência do Spring (Spring DI). Se você trabalha com MicroProfile, , você já está familiarizado com CDI. Por outro lado, os desenvolvedores Spring podem usar a Quarkus Extension para a API Spring DI para garantir compatibilidade com Spring DI. Exemplos de uso das APIs Spring DI suportadas estão na Tabela 2.
Em utiliza tanto CDI quanto Injeção de Dependência do Spring. Para mais informações e exemplos sobre este assunto, você pode encontrar no guia do Quarkus, chamado .
Tabela 2. Exemplos de uso das APIs Spring DI suportadas.
Funcionalidades suportadas do Spring DI
Exemplos
Injeção de Constructor
public PersonSpringController(
PersonSpringRepository personRepository, // injetado
PersonSpringMPService personService) { // injetado
this.personRepository = personRepository;
this.personService = personService;
}
Injeção de Campo
@Autowired
@RestClient
SalutationRestClient salutationRestClient;
@Value("${fallbackSalutation}")
String fallbackSalutation;
@Configuration
@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;
}
}
Framework Web
Os usuários do MicroProfile irão apreciar que o Quarkus suporta JAX-RS, MicroProfile Rest Client, JSON-P e JSON-B como a principal modelo de programação web. Os desenvolvedores do Spring ficarão agradavelmente surpresos com o suporte recentemente adicionado ao Spring Web API no Quarkus, especialmente pelas interfaces que gerenciam REST. Assim como no DI do Spring, o principal objetivo do suporte ao Spring Web API é permitir que os desenvolvedores do Spring utilizem as interfaces do Spring Web juntamente com as interfaces do MicroProfile. Exemplos do uso das APIs do Spring Web suportadas são apresentados na tabela 3, e informações adicionais e exemplos sobre o tema podem ser encontrados no guia Quarkus intitulado .
Tabela 3. Exemplos de uso das interfaces API do Spring Web suportadas.
Funcionalidades suportadas do Spring Web
Exemplos
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
...
...
...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@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 ficarão satisfeitos com o suporte do Quarkus para JPA usando Hibernate ORM. Há boas notícias também para os desenvolvedores do Spring: o Quarkus suporta as anotações e tipos comuns do Spring Data JPA. Exemplos do uso das APIs do Spring Data JPA suportadas são apresentados na tabela 4.
Em são utilizadas as interfaces API do Spring Data JPA, e informações adicionais estão disponíveis no guia Quarkus intitulado .
Tabela 4. Exemplos de uso das interfaces API do Spring Data JPA suportadas.
Funcionalidades suportadas do Spring Data JPA
Exemplos
CrudRepository
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Repository
JpaRepository
PagingAndSortingRepository
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);
}
Interfaces API do MicroProfile
Tolerância a Falhas
As estruturas de Tolerância a Falhas são muito importantes para prevenir falhas em cascata e criar arquiteturas de microsserviços confiáveis. Os desenvolvedores Spring já usam há anos circuit breakers para garantir a resiliência. . No entanto, o Hystrix não é atualizado há muito tempo, enquanto a Tolerância a Falhas do MicroProfile está sendo ativamente desenvolvida e já possui anos de uso em produção. Portanto, para aumentar a confiabilidade dos serviços no Quarkus, é recomendado aplicar as interfaces API do MicroProfile Fault Tolerance, cujos exemplos de uso estão na tabela 5. Informações adicionais sobre isso podem ser encontradas no guia do Quarkus. .
Tabela 5. Exemplos de uso das interfaces de API suportadas pelo MicroProfile Fault Tolerance.
Funções do MicroProfile Fault Tolerance
Descrição
Exemplos
@Asynchronous
Execução de lógica em uma thread separada
@Asynchronous
@Retry
public Future getSalutation() {
...
return future;
}
@Bulkhead
Limitação do número de solicitações simultâneas
@Bulkhead(5)
public void fiveConcurrent() {
makeRemoteCall(); //...
}
@CircuitBreaker
Tratamento inteligente de falhas e recuperação de falhas
@CircuitBreaker(delay=500 // milissegundos
failureRatio = .75,
requestVolumeThreshold = 20,
successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
@Fallback
Chamada de lógica alternativa em caso de falha
@Timeout(500) // milissegundos
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
public String fallback() {
return "olá";
}
Repetição em caso de falha na solicitação
@Retry(maxRetries=3)
public String getSalutation() {
makeRemoteCall(); //...
}
Tempo limite de espera em caso de falha
@Timeout(value = 500) // milissegundos
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
Verificação de Serviços (Service Health)
As plataformas Kubernetes monitoram a integridade dos contêineres por meio de serviços especiais. Para que a plataforma subjacente possa monitorar os serviços, os desenvolvedores Spring geralmente usam HealthIndicator configuráveis e o Spring Boot Actuator. No Quarkus, isso pode ser feito com o MicroProfile Health, que por padrão realiza verificações de prontidão (liveness check), mas pode ser configurado para verificar simultaneamente a prontidão e a disponibilidade (readiness). Os exemplos de uso das APIs suportadas pelo MicroProfile Health estão na tabela 6, e mais informações estão disponíveis no guia do Quarkus. .
Tabela 6. Exemplos de uso das interfaces de API suportadas pelo MicroProfile Health.
Funções do MicroProfile Health
Descrição
Exemplos
@Liveness
A plataforma realiza a reinicialização de aplicativos containerizados defeituosos.
Endpoint:
host:8080/health/live
@Liveness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(ready ? true:false)
.withData("mydata", data)
.build();
}
@Readiness
A plataforma não enviará tráfego para o aplicativo contêinerizado caso esteja indisponível.
Endpoint:
host:8080/health/ready
@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 monitoramento de SLA de desempenho) ou não operacionais (indicadores SLA de negócios). Desenvolvedores Spring fornecem métricas através do Spring Boot Actuator e Micrometer. Por sua vez, o Quarkus utiliza MicroProfile Metrics para fornecer métricas básicas (JVM e sistema operacional), métricas de fornecedor (Quarkus) e métricas de aplicativos. MicroProfile Metrics requer que a implementação suporte formatos de saída JSON e OpenMetrics (Prometheus). Exemplos de uso da API MicroProfile Metrics estão na Tabela 7.
Em MicroProfile Metrics é utilizado para fornecer métricas de aplicativo. Mais informações podem ser encontradas no guia Quarkus. .
Tabela 7. Exemplos de uso das APIs MicroProfile Metrics.
Funções do MicroProfile Metrics
Descrição
Exemplos
@Counted
Indica um contador que contabiliza o número de chamadas para o objeto anotado.
@Counted(name = "fallbackCounter",
displayName = "Contador de Fallback",
description = "Contador de Fallback")
public String salutationFallback() {
return fallbackSalutation;
}
@ConcurrentGauge
Indica um sensor que conta o número de chamadas simultâneas para o objeto anotado.
@ConcurrentGuage(
name = "fallbackConcurrentGauge",
displayName="Concurrent Fallback",
description="Concurrent Fallback")
public String salutationFallback() {
return fallbackSalutation;
}
@Gauge
Indica um sensor que mede o valor do objeto anotado.
@Metered(name = "FallbackGauge",
displayName="Medidor de Fallback",
description="Frequência de fallback")
public String salutationFallback() {
return fallbackSalutation;
}
@Metered
Indica um medidor que monitora a frequência de chamadas para o objeto anotado.
@Metered(name = "MeteredFallback",
displayName="Medidor de Fallback",
description="Frequência de fallback")
public String salutationFallback() {
return fallbackSalutation;
}
Anotação que contém informações sobre os metadados ao receber uma solicitação para registrar ou gerar métricas.
@Metric
@Metered(name = "MeteredFallback",
displayName="Medidor de Fallback",
description="Frequência de fallback")
public String salutationFallback() {
return fallbackSalutation;
}
Indica um temporizador que monitora a duração do objeto anotado.
@Timed(name = "TimedFallback",
displayName="Fallback Temporizado",
description="Atraso do fallback")
public String salutationFallback() {
return fallbackSalutation;
}
Pontos finais de métricas
Métricas de aplicações :8080/metrics/application
Métricas básicas :8080/metrics/base
Métricas do fornecedor :8080/metrics/vendor
Todas as métricas :8080/metrics
Cliente REST MicroProfile
Microserviços frequentemente expõem pontos finais RESTful, que requerem APIs de cliente apropriadas para interação. Para utilizar os pontos finais RESTful, os desenvolvedores Spring geralmente usam RestTemplate. Entretanto, o Quarkus oferece interfaces de API do MicroProfile Rest Client para resolver essa tarefa, com exemplos de uso apresentados na tabela 8.
Em A utilização de pontos finais RESTful é realizada através do MicroProfile Rest Client. Informações adicionais e exemplos sobre isso podem ser encontrados no guia Quarkus. .
Tabela 8. Exemplos de uso das interfaces de API MicroProfile Rest Client.
Funcionalidades do MicroProfile Rest Client
Descrição
Exemplos
@RegisterRestClient
Registra uma interface Java tipada como cliente REST
@RegisterRestClient
@Path("/")
public interface MyRestClient {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getSalutation();
}
@RestClient
Marca a injeção de uma instância da interface tipada do cliente REST
@Autowired // ou @Inject
@RestClient
MyRestClient restClient;
Invocação
Invoca um ponto final REST
System.out.println(
restClient.getSalutation());
mp-rest/url
Define um ponto final REST
application.properties:
org.example.MyRestClient/mp-rest/url=
http://localhost:8081/myendpoint
Resultados
Neste blog, que será especialmente útil para desenvolvedores Spring, discutimos brevemente como usar as APIs do Spring juntamente com as APIs do MicroProfile no Quarkus para desenvolver microserviços Java e depois compilá-los em código binário nativo, economizando centenas de megabytes de memória e iniciando em milissegundos.
Como você já percebeu, mais informações sobre o suporte às APIs do Spring e MicroProfile, assim como muitos outros detalhes úteis, podem ser encontradas nos .
Fonte: habr.com
