Bonjour à tous, voici le troisième article de la série Quarkus !
Lors du développement de microservices Java, on pense souvent que и sont des API distinctes et indépendantes. Par défaut, les programmeurs ont tendance à utiliser les API auxquelles ils sont déjà habitués, car l'apprentissage de nouveaux frameworks et composants d'exécution prend beaucoup de temps. Aujourd'hui, nous allons essayer de simplifier le développement de certains populaires et vous montrer comment utiliser simultanément l'API Spring et de nouvelles fonctionnalités utiles .
De manière un peu plus détaillée, nous examinerons d'abord la portée et les détails de la façon dont Quarkus prend en charge les API Spring pour montrer aux développeurs Spring comment utiliser l'API MicroProfile dans leur travail quotidien. Nous aborderons ensuite les API MicroProfile, qui sont utiles aux développeurs Spring lors de la création de microservices.
Pourquoi Quarkus ? Premièrement, il s'agit de codage en direct, c'est-à-dire le rechargement automatique de toute modification apportée à l'API MicroProfile, à l'API Spring et aux autres API Java, qui s'effectue avec une seule commande : mvn quarkus:dev. Deuxièmement, considéré dans le service Person (qui compile les API Spring, MicroProfile et JPA en un binaire à l'aide de l'image native GraalVM) démarre en seulement 0.055 seconde et occupe environ 90 Mo de RAM (RSS) sur le point de terminaison de l'application RESTful. De plus, sa compilation elle-même s'effectue avec une seule commande : mvn package -Pnative.
Nous n'entrerons pas dans les détails de MicroProfile, sauf pour aider les développeurs Spring à comprendre comment ils peuvent utiliser les API Spring avec les API MicroProfile dans Quarkus.
Conteneurs et Kubernetes
Pour simplifier cet article, nous ne couvrirons ici que les aspects de haut niveau du support. , car il est important de comprendre. Quarkus se positionne comme une pile Java pour Kubernetes, elle est conçue pour minimiser la consommation de mémoire et le temps de démarrage des applications et services Java et, par conséquent, augmenter leur densité sur l'hôte et réduire les coûts globaux.
Quarkus aussi Ressources et offres Kubernetes pour le déploiement sur les plateformes Kubernetes et Red Hat OpenShift. De plus, Quarkus génère automatiquement les fichiers Dockerfile.jvm (empaquetage JVM) et Dockerfile.native (empaquetage binaire natif) nécessaires à la création de conteneurs.
Enfin, en se concentrant sur Kubernetes comme environnement de déploiement cible, Quarkus n'utilise pas de frameworks Java dans les cas où des fonctionnalités similaires sont implémentées au niveau de la plateforme Kubernetes elle-même. Le tableau 1 fournit une carte de la correspondance fonctionnelle entre Kubernetes et les frameworks Java typiques utilisés par les développeurs Spring.
Tableau 1. Carte de correspondance fonctionnelle entre les frameworks Java et Kubernetes.
fonctionnel
Botte de printemps traditionnelle
Kubernetes
Découverte de service
Eureka
DNS
configuration
Configuration cloud de printemps
Cartes/Secrets de configuration
L'équilibrage de charge
Ruban (côté client)
Service, Replication Controller (côté serveur)
Compiler et exécuter le code de l'exemple
Dans cet article, nous faisons référence à , où les API Spring et MicroProfile et même la même classe Java sont utilisées ensemble. Le code de cet exemple peut être compilé et exécuté à partir de la ligne de commande, voir le fichier README.md pour plus de détails.
API du framework Spring
Injection de dépendance
Quarkus prend en charge une gamme de et les API Spring Dependency Injection (Spring DI). Si vous travaillez avec MicroProfile, , alors vous connaissez déjà très bien le CDI. D'un autre côté, les développeurs Spring peuvent utiliser l'extension Quarkus pour l'API Spring DI pour assurer la compatibilité avec Spring DI. Des exemples d'utilisation des API Spring DI prises en charge sont donnés dans le tableau 2.
В Utilise à la fois CDI et Spring Dependency Injection. Pour plus d'informations et des exemples sur ce sujet, consultez le guide Quarkus intitulé .
Tableau 2. Exemples d'utilisation des API Spring DI prises en charge.
Fonctionnalités Spring DI prises en charge
Exemples
Injection de constructeur
public PersonSpringController(
PersonSpringRepository personRepository, // injected
PersonSpringMPService personService) { // injected
this.personRepository = personRepository;
this.personService = personService;
}
Injection sur le terrain
@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;
}
}
Cadre Web
Les utilisateurs de MicroProfile apprécieront le fait que Quarkus prenne en charge JAX-RS, MicroProfile Rest Client, JSON-P et JSON-B comme modèle de programmation Web principal. Les développeurs Spring seront satisfaits de la récente prise en charge par Quarkus de l'API Web Spring, en particulier des interfaces REST. Semblable à Spring DI, l'objectif principal de la prise en charge de Spring Web API est de permettre aux développeurs Spring d'utiliser les API Spring Web en conjonction avec les API MicroProfile. Des exemples d'utilisation des API Web Spring prises en charge sont fournis dans le tableau 3, et plus d'informations et d'exemples sur ce sujet peuvent être trouvés dans le didacticiel Quarkus intitulé .
Tableau 3. Exemples d'utilisation des API Web Spring prises en charge.
Fonctionnalités Web Spring prises en charge
Exemples
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
...
...
...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ReponseStatus
@ExceptionHandler
@RestControllerAdvice (partiel)
@GetMapping(path = "/greet/{id}",
produces = "text/plain")
public String greetPerson(
@PathVariable(name = "id") long id) {
...
...
...
}
JPA de données de printemps
Les utilisateurs de MicroProfile apprécieront également que Quarkus prend en charge JPA à l'aide de l'ORM Hibernate. Il y a également de bonnes nouvelles pour les développeurs Spring : Quarkus prend en charge les annotations et les types Spring Data JPA courants. Des exemples d'utilisation des API Spring Data JPA prises en charge sont donnés dans le tableau 4.
В Les API Spring Data JPA sont utilisées et plus d'informations sont disponibles dans le didacticiel Quarkus appelé .
Tableau 4. Exemples d'utilisation des API Spring Data JPA prises en charge.
Fonctionnalités JPA de données Spring prises en charge
Exemples
CrudRepository
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Dépôt
Référentiel Jpa
PaginationEtTriRéférentiel
public class PersonRepository extends
Repository {
Person save(Person entity);
Optional findById(Person entity);
}
Fragments de référentiel
public interface PersonRepository
extends JpaRepository,
PersonFragment {
...
}
Méthodes de requête dérivées
public interface PersonRepository extends CrudRepository {
List findByName(String name);
Person findByNameBySsn(String ssn);
Optional
findByNameBySsnIgnoreCase(String ssn);
Boolean existsBookByYearOfBirthBetween(
Integer start, Integer end);
}
Requêtes définies par l'utilisateur
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);
}
API MicroProfil
Tolérance aux pannes
Les constructions de tolérance aux pannes sont très importantes pour éviter les pannes en cascade et créer des architectures de microservices fiables. Les développeurs Spring utilisent des disjoncteurs pour la tolérance aux pannes depuis de nombreuses années. . Cependant, Hystrix n'a pas été mis à jour depuis longtemps, mais la tolérance aux pannes de MicroProfile se développe désormais activement et compte plusieurs années d'utilisation en production. Par conséquent, pour améliorer la fiabilité des services dans Quarkus, il est recommandé d'utiliser les API MicroProfile Fault Tolerance, dont des exemples sont utilisés dans le tableau 5. Pour plus d'informations à ce sujet, consultez le manuel Quarkus. .
Tableau 5. Exemples d'utilisation des API MicroProfile Fault Tolerance prises en charge.
Fonctionnalités de tolérance aux pannes MicroProfile
description
Exemples
@Asynchrone
Exécuter la logique dans un thread séparé
@Asynchronous
@Retry
public Future<String> getSalutation() {
...
return future;
}
@Cloison
Limiter le nombre de requêtes simultanées
@Bulkhead(5)
public void fiveConcurrent() {
makeRemoteCall(); //...
}
@Disjoncteur
Gestion intelligente des pannes et récupération après panne
@CircuitBreaker(delay=500 // milliseconds
failureRatio = .75,
requestVolumeThreshold = 20,
successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
@Retomber
Appel d'une logique alternative en cas d'échec
@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
public String fallback() {
return "hello";
}
Réessayer en cas d'échec de la demande
@Retry(maxRetries=3)
public String getSalutation() {
makeRemoteCall(); //...
}
Expiration du délai de contrôle des pannes
@Timeout(value = 500 ) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
makeRemoteCall(); //...
}
Vérification des services (Service Health)
Les plates-formes Kubernetes surveillent la santé des conteneurs à l'aide de services spéciaux. Pour permettre à la plate-forme sous-jacente de surveiller les services, les développeurs Spring utilisent généralement un HealthIndicator et un Spring Boot Actuator personnalisés. Dans Quarkus, cela peut être fait à l'aide de MicroProfile Health, qui effectue par défaut une vérification de l'activité, mais peut être configuré pour vérifier simultanément l'activité et l'état de préparation. Des exemples d'utilisation des API MicroProfile Health prises en charge sont fournis dans le tableau 6, et des informations supplémentaires sont fournies dans le manuel Quarkus. .
Tableau 6 : Exemples d'utilisation des API MicroProfile Health prises en charge.
Fonctionnalités de santé de MicroProfile
description
Exemples
@Liveness
La plateforme redémarre les applications conteneurisées défaillantes
Endpoint:
hôte : 8080/santé/en direct
@Liveness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(ready ? true:false)
.withData("mydata", data)
.build();
}
@Préparation
La plateforme n'enverra pas de trafic vers des applications conteneurisées si elle n'est pas prête
Endpoint:
hôte : 8080/santé/prêt
@Readiness
public class MyHC implements HealthCheck {
public HealthCheckResponse call() {
...
return HealthCheckResponse
.named("myHCProbe")
.status(live ? true:false)
.withData("mydata", data)
.build();
}
Métrique
Les applications fournissent des métriques à des fins opérationnelles (pour surveiller les SLA de performances) ou à des fins non opérationnelles (SLA commerciaux). Les développeurs Spring fournissent des métriques à l’aide de Spring Boot Actuator et Micrometer. À son tour, Quarkus utilise MicroProfile Metrics pour fournir des métriques de base (JVM et système d'exploitation), des métriques de fournisseur (Quarkus) et des métriques d'application. MicroProfile Metrics nécessite que l'implémentation prenne en charge les formats de sortie JSON et OpenMetrics (Prometheus). Des exemples d'utilisation de l'API MicroProfile Metrics sont donnés dans le tableau 7.
В Les métriques MicroProfile sont utilisées pour fournir des métriques d’application. Pour plus d'informations, consultez le manuel Quarkus .
Tableau 7. Exemples d'utilisation des API MicroProfile Metrics.
Fonctionnalités de métriques MicroProfile
description
Exemples
@Dénombré
Désigne un compteur compteur qui compte le nombre de fois qu'un objet annoté a été appelé
@Counted(name = "fallbackCounter",
displayName = "Fallback Counter",
description = "Fallback Counter")
public String salutationFallback() {
return fallbackSalutation;
}
@ConcurrentGauge
Désigne une jauge qui compte le nombre d'appels simultanés vers un objet annoté
@ConcurrentGuage(
name = "fallbackConcurrentGauge",
displayName="Fallback Concurrent",
description="Fallback Concurrent")
public String salutationFallback() {
return fallbackSalutation;
}
@Jauge
Désigne un capteur de jauge qui mesure la valeur d'un objet annoté
@Metered(name = "FallbackGauge",
displayName="Fallback Gauge",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
@Metré
Désigne un capteur de compteur qui surveille la fréquence d'appel d'un objet annoté
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Une annotation contenant des informations sur les métadonnées lorsqu'une demande est reçue pour saisir ou produire une métrique
@Metric
@Metered(name = "MeteredFallback",
displayName="Metered Fallback",
description="Fallback frequency")
public String salutationFallback() {
return fallbackSalutation;
}
Indique une minuterie qui suit la durée d'un objet annoté
@Timed(name = "TimedFallback",
displayName="Timed Fallback",
description="Fallback delay")
public String salutationFallback() {
return fallbackSalutation;
}
Points de terminaison des métriques
Métriques des applications :8080/métriques/application
Métriques de base :8080/métriques/base
Métriques du fournisseur :8080/métriques/fournisseur
Toutes les mesures :8080/métriques
Client de repos MicroProfile
Les microservices fournissent souvent des points de terminaison RESTful qui nécessitent l'utilisation des API client correspondantes. Pour utiliser les points de terminaison RESTful, les développeurs Spring utilisent généralement RestTemplate. Quarkus propose des API MicroProfile Rest Client pour résoudre ce problème, dont des exemples d'utilisation sont donnés dans le tableau 8.
В l'utilisation des points de terminaison RESTful se fait à l'aide du client MicroProfile Rest. Plus d'informations et d'exemples sur ce sujet peuvent être trouvés dans le manuel Quarkus. .
Tableau 8. Exemples d'utilisation des API MicroProfile Rest Client.
Fonctionnalités du client MicroProfile Rest
description
Exemples
@RegisterRestClient
Enregistre une interface Java typée en tant que client REST
@RegisterRestClient
@Path("/")
public interface MyRestClient {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getSalutation();
}
@RestClient
Marque l'implémentation d'une instance d'une interface client REST typée
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Invocation
Appelle un point de terminaison REST
System.out.println(
restClient.getSalutation());
mp-rest/url
Spécifie le point de terminaison REST
application.properties:
org.example.MyRestClient/mp-rest/url=
http://localhost:8081/myendpoint
Les résultats de
Dans ce blog, destiné principalement aux développeurs Spring, nous avons examiné rapidement comment utiliser les API Spring avec les API MicroProfile dans Quarkus pour développer des microservices Java, puis les compiler en code binaire natif qui économise des centaines de mégaoctets de RAM et se lance dans une question de millisecondes.
Comme vous l'avez déjà compris, plus d'informations sur la prise en charge des API Spring et MicroProfile, ainsi que de nombreuses autres informations utiles, peuvent être trouvées dans .
Source: habr.com