Le développement de services en Java, y compris les API REST, n’a pas toujours été facile ou productif jusqu’à ce que le printemps arrive et change le paysage. De nombreuses années se sont écoulées depuis et de nouveaux cadres ont vu le jour dans la communauté.

L’un de ces cadres était Micronaut. Il est développé par OCI, la même société derrière Grails, et son objectif est d’aider les développeurs à créer des microservices et des applications sans serveur.

Il y a aussi Quarkus, un autre framework qui a gagné en popularité au cours de la dernière année. Développé par RedHat, Quarkus promet un démarrage rapide et une utilisation moindre de la mémoire, deux problèmes courants lors du développement de services REST en Java.

Avec tous ces choix, il y a une question très importante à se poser: est-il facile de créer un service avec chacun de ces trois frameworks?

Dans ce tutoriel, vous allez créer une application REST sécurisée en utilisant Spring, Micronaut et Quarkus pour voir en quoi elles diffèrent les unes des autres et laquelle convient le mieux à vos besoins.

Table des matières

• Prérequis pour Votre API REST Java
  • Créer un Compte Okta pour la Gestion des Utilisateurs
  • Générer des Jetons à l’aide du Débogueur OpenID Connect
• Construire une API REST Java avec Micronaut
  • Développer Votre Service Java
• Construire une API REST Java avec Quarkus
• Construire une API REST Java avec API avec Spring Boot
• Réflexions finales sur les API REST Avec Java : Micronaut, Quarkus et Spring Boot

Si vous le souhaitez, vous pouvez regarder ce tutoriel sous forme de screencast. Prere

Prérequis pour Votre API REST Java

Ce tutoriel utilise Maven 3+. Assurez-vous qu’il est installé et disponible à l’utilisation avant de continuer. Vous pouvez certainement également utiliser Gradle, mais YMMV.

Vous allez créer des applications qui authentifient les requêtes en utilisant OAuth 2.0, sécurisées par une application Okta. Vous n’avez pas de compte Okta ? Ne vous inquiétez pas, il faut moins d’une minute pour en créer un nouveau. Non seulement cela, mais Okta prend en charge des normes telles que JWT, OAuth 2.0 et OIDC. Nous prenons en charge des frameworks bien connus tels que Java EE, Spring Boot et Spring Security. Zut, nous avons même un plugin Maven qui automatise tout pour vous.

Pas besoin de réinventer la roue !

Créez un compte Okta pour la gestion des utilisateurs

Ouvrez votre terminal et exécutez la commande suivante :

mvn com.okta:okta-maven-plugin:register

Il vous sera demandé de saisir les informations suivantes:

• Prénom
• Nom
• Email
• Société

Une fois que vous aurez répondu aux questions, vous recevrez un e-mail pour activer votre tout nouveau compte. Après avoir activé votre compte, exécutez la commande suivante :

mvn com.okta:okta-maven-plugin:spring-boot

Cette commande crée une application pour vous avec le flux de code d’authentification et l’URI de redirection de Spring Security pour Okta.

Pour mieux s’en souvenir, vous pouvez créer la même application manuellement:

• Accédez à la page d’accueil des développeurs d’Okta et connectez-vous à votre compte.
• Cliquez sur Applications >Ajouter une Application >Web > Suivant.

Vous verrez l’écran suivant:

Avant de continuer, effectuez les modifications suivantes dans l’application :

• URI de redirection de connexion:
  • http://localhost:8080/login/oauth2/code/okta
  • https://oidcdebugger.com/debug
• Type d’octroi autorisé
  • Code d’autorisation
  • Implicite (hybride)

Le type d’octroi implicite (avec ID et jeton d’accès autorisés cochée) est nécessaire pour récupérer un jeton d’accès dans votre navigateur.

Les champs non mentionnés ci-dessus peuvent conserver leurs valeurs par défaut.

Après l’avoir terminé, cliquez sur Terminé. Votre application est prête !

L’étape suivante consiste à apprendre à générer un jeton valide en l’utilisant.

Générer des jetons à l’aide du débogueur OpenID Connect

Okta vous permet de gérer vos utilisateurs dans le cloud à l’aide de ses API. Il vous permet également de sécuriser vos applications en utilisant OAuth 2.0 et OpenID Connect (alias OIDC). OAuth 2.0 fournit un mécanisme d’autorisation déléguée, ce qui signifie que vous n’avez pas à stocker les informations d’identification de l’utilisateur dans votre application. Au lieu de cela, vous pouvez le déléguer à un fournisseur OAuth 2.0 (Okta, dans ce cas). OIDC fournit une couche d’identité au-dessus d’OAuth 2.0 et c’est pourquoi des entreprises comme Okta sont appelées « fournisseurs d’identité”, ou IDP.

Vous avez enregistré votre application auprès d’Okta et pouvez désormais générer un jeton pour y accéder. L’un des URI de redirection de connexion que vous avez enregistrés est pour le site Web OpenID Connect.

Vos demandes seront validées à l’aide d’un jeton. Pour générer ce jeton, vous utiliserez le débogueur OpenID Connect. Ce site Web vous fournira un moyen facile de générer des informations d’identification pour les utilisateurs de votre application Okta.

Accédez au https://oidcdebugger.com et remplissez les informations suivantes:

• Autorisez l’URI: https://{yourOktaDomain}/oauth2/default/v1/authorize
• Redirigez l’URI: https://oidcdebugger.com/debug
• ID client: {yourOktaClientId}
• Portée: openid email profile
• État: dev
• Nonce: (conservez la valeur par défaut)
• Type de réponse: token

Vous pouvez trouver la valeur de {yourOktaDomain}dans le coin supérieur droit de la page d’accueil de votre compte:

Pour trouver votre identifiant client Okta, suivez les étapes ci-dessous:

• Allez dans Applications
• Sélectionnez Mon Application Web
• Cliquez sur Général

L’ID Client sera disponible dans la section Informations d’identification du client :

Après avoir rempli tous les champs, cliquez sur Envoyer la demande. Vous serez redirigé vers votre page de connexion Okta.

Une fois que vous vous êtes authentifié avec succès, vous serez à nouveau redirigé vers le débogueur OIDC, où vous pourrez voir le jeton généré:

Vous utiliserez ce jeton pour accéder en toute sécurité aux services que vous allez créer.

Maintenant que vous avez un compte Okta et que vous savez comment générer des jetons à l’aide de votre application Okta, commençons à comparer les frameworks!

Construire une API REST Java avec Micronaut

La première étape pour développer votre service Micronaut est de télécharger SDKMAN !. SDKMAN ! est un outil de gestion des versions parallèles de plusieurs SDK, que vous utiliserez pour installer le client Micronaut.

Vous pouvez télécharger SDKMAN! en exécutant la commande suivante:

curl -s https://get.sdkman.io | bash

Maintenant, vous pouvez installer Micronaut lui-même. Exécutez simplement la commande suivante dans le terminal :

sdk install micronaut

Une fois la commande terminée, vous aurez la dernière version de Micronaut disponible sur votre ordinateur.

Vous êtes prêt à commencer à développer l’application!

Développez votre service Java

Accédez au répertoire dans lequel vous souhaitez créer votre application et exécutez la commande suivante:

mn create-app com.okta.rest.app --build maven

Cette commande va créer un projet avec la structure de base d’un projet Micronaut. Micronaut utilise Gradle par défaut, mais comme vous utilisez --build maven, il utilisera Maven à la place.

L’étape suivante consiste à ajouter les bibliothèques de sécurité à l’intérieur du projet. Modifiez le fichier pom.xml et ajoutez les dépendances suivantes:

<dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security</artifactId></dependency><dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security-jwt</artifactId></dependency>

Ces dépendances activeront la sécurité – en particulier OAuth 2.0 avec JWT – dans votre projet. Maintenant que toutes les dépendances sont en place, vous pouvez commencer à créer votre point de terminaison.

Créez la classe suivante dans src/main/java/com/okta/rest/controller:

package com.okta.rest.controller;import io.micronaut.http.MediaType;import io.micronaut.http.annotation.Controller;import io.micronaut.http.annotation.Get;import io.micronaut.http.annotation.Produces;import io.micronaut.security.annotation.Secured;import io.micronaut.security.rules.SecurityRule;import java.security.Principal;@Controller("/hello")public class HelloController { @Get @Secured(SecurityRule.IS_AUTHENTICATED) @Produces(MediaType.TEXT_PLAIN) public String hello(Principal principal) { return "Hello, " + principal.getName() + "!"; }}

L’annotation @Controller indique au Micronaut que ce composant recevra des requêtes dans le /hello.

La classe n’a qu’une seule méthode, nommée hello(). L’annotation @Get montre que la méthode recevra des requêtes HTTP GET. Vous avez besoin de @Produces car le type de retour par défaut de Micronaut est un objet JSON. Puisque vous renvoyez du texte simple, vous devez définir explicitement ces informations dans la méthode.

La dernière annotation est @Secured. Il indique simplement à Micronaut que cette méthode n’est accessible qu’aux utilisateurs authentifiés.

Vous avez maintenant un contrôleur sécurisé, mais vous n’avez pas encore défini la configuration de sécurité. Configurons Micronaut pour qu’il se connecte à votre application Okta.

Renommez src/main/resources/application.yml en application.properties et ajoutez la configuration de sécurité suivante :

micronaut.security.enabled=truemicronaut.security.token.jwt.enabled=truemicronaut.security.token.jwt.signatures.jwks.okta.url=https://{yourOktaDomain}/oauth2/default/v1/keys

Remplacez {yourOktaDomain} avec la valeur de votre compte Okta.

La configuration ci-dessus active la sécurité en utilisant OAuth 2.0. Vous déclarez que votre client OAuth 2.0 provient d’Okta, en spécifiant l’émetteur de votre organisation Okta.

Vous activez également l’utilisation de jetons web JSON ou JWT. Puisque vous souhaitez lire les informations d’Okta, vous devez déclarer où vous pouvez trouver vos JWK (jeu de clés Web JSON) pour valider les signatures JWT.

Il est temps de tester votre service ! Démarrez votre application en exécutant la commande suivante :

./mvnw mn:run

Lorsque votre application s’exécute, exécutez la commande suivante :

curl -X GET -I http://localhost:8080/hello

La commande ci-dessus produira un résultat similaire à celui-ci :

HTTP/1.1 401 UnauthorizedDate: Tue, 8 Jan 2019 15:47:36 GMTtransfer-encoding: chunkedconnection: close

Comme vous pouvez le voir, la requête n’a pas été acceptée. Pour que cela fonctionne, vous devez transmettre le jeton d’accès OAuth 2.0 récupéré par le débogueur OIDC. Attribuez le jeton d’accès à une variable TOKEN dans votre shell.

TOKEN=eyJraWQiOiJxOE1QMjFNNHZCVmxOSkxGbFFWNlN...

Exécutez la commande ci-dessous:

curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hello

Maintenant, cela fonctionne comme prévu! Cette fois, vous recevez le message d’accueil en réponse :

Hello, [email protected]!

Vous pouvez voir que Micronaut nécessite très peu de code pour créer une API REST sécurisée. Si vous comptiez les lignes de code, vous constateriez que ~ 24% sont des dépendances en XML (8 lignes), le code Java ne contient que 22 lignes de code et la configuration de sécurité prend 3 lignes. La prise en charge intégrée d’OAuth 2.0 de Micronaut facilite l’intégration avec Okta et ils ont même un Guide pour Okta dans leur documentation.

Super! Voyons maintenant comment vous créez la même application à l’aide de Quarkus.

Construisez une API REST Java avec Quarkus

Pour développer votre application en utilisant Quarkus, il vous suffit d’installer Maven, aucune autre dépendance n’est requise.

Commençons à créer votre application! Accédez au répertoire dans lequel vous souhaitez le créer et exécutez la commande suivante :

mvn io.quarkus:quarkus-maven-plugin:1.8.1.Final:create \ -DprojectGroupId=com.okta.rest \ -DprojectArtifactId=quarkus \ -DclassName="com.okta.rest.quarkus.HelloResource" \ -Dpath="/hello" \ -Dextensions="jwt"

La commande ci-dessus crée un projet à l’aide du plugin Quarkus Maven. Il va créer une ressource nommée HelloResource, qui va recevoir des requêtes sur le chemin /hello. Vous ajoutez également l’extension JWT de Quarkus sur le projet.

Une fois que vous avez créé le projet, modifiez src/java/com/okta/rest/quarkus/HelloResource.java et ajoutez des informations utilisateur à la méthode hello():

package com.okta.rest.quarkus;import io.quarkus.security.Authenticated;import javax.ws.rs.GET;import javax.ws.rs.Path;import javax.ws.rs.Produces;import javax.ws.rs.core.Context;import javax.ws.rs.core.MediaType;import javax.ws.rs.core.SecurityContext;import java.security.Principal;@Path("/hello")public class HelloResource { @GET @Path("/") @Authenticated @Produces(MediaType.TEXT_PLAIN) public String hello(@Context SecurityContext context) { Principal userPrincipal = context.getUserPrincipal(); return "Hello, " + userPrincipal.getName() + "!"; }}

La classe ci-dessus se comportera de la même manière que celle que vous avez créée dans Micronaut. Il lit les informations de l’utilisateur en fonction du jeton généré dans la demande et renvoie un message d’accueil à l’utilisateur trouvé.

Vous n’avez toujours pas configuré Quarkus avec votre émetteur et vos clés d’Okta, alors faisons-le.

Modifiez src/main/resources/application.properties et ajoutez le code suivant:

mp.jwt.verify.publickey.location=https://{yourOktaDomain}/oauth2/default/v1/keysmp.jwt.verify.issuer=https://{yourOktaDomain}/oauth2/default

Terminé! La version Quarkus de votre application est prête à être testée. Allez dans votre dossier de projet et exécutez la commande suivante :

./mvnw compile quarkus:dev

La commande ci-dessus démarrera votre application.

La première étape consiste à vous assurer de recevoir un 401 - Unauthorized lorsque vous n’utilisez pas les informations d’identification correctes.

Exécutez la commande suivante dans le terminal :

curl -X GET -I http://localhost:8080/hello

Comme prévu, le résultat est une réponse HTTP 401:

HTTP/1.1 401 Unauthorizedwww-authenticate: Bearer {token}Content-Length: 0

Si vous exécutez cette même requête, y compris le jeton du débogueur OIDC, elle doit renvoyer le message d’accueil.

Exécutez la commande suivante:

curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hello

Cela a fonctionné comme un charme! Dans mon cas, le résultat était:

Hello, [email protected]!

Quarkus nécessite encore moins de lignes de code que Micronaut! Il génère une application avec des dépendances incluses, a 25 lignes de code Java et seulement 2 lignes de configuration. Oui, lines of code est une comparaison stupide, mais cela montre également comment ces frameworks nécessitent très peu de code pour développer des applications sécurisées.

Deux vers le bas, un pour aller! Maintenant que vous avez pu implémenter l’application sur Micronaut et Quarkus, terminons en créant la même application à l’aide de Spring Boot.

Construisez une API REST Java avec Spring Boot

Spring Boot n’a pas de prérequis pour commencer à créer votre application, alors commençons par créer le projet!

Ouvrez votre terminal et exécutez la commande suivante:

curl https://start.spring.io/starter.zip -d language=java \ -d bootVersion=2.3.4.RELEASE \ -d dependencies=web,okta \ -d packageName=com.okta.rest \ -d name=spring-boot \ -d type=maven-project \ -o spring-boot.zip

La commande ci-dessus créera un fichier spring-boot.zip avec une application de démarrage à ressort qui utilise Maven. Vous pouvez extraire le fichier dans un répertoire spring-boot en utilisant la commande ci-dessous.

unzip spring-boot.zip -d spring-boot

Maintenant, vous allez implémenter le contrôleur qui recevra les requêtes.

Créez un package com.okta.rest.controller et une classe HelloController:

package com.okta.rest.controller;import org.springframework.security.core.annotation.AuthenticationPrincipal;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import java.security.Principal;@RestControllerpublic class HelloController { @GetMapping("/hello") public String hello(@AuthenticationPrincipal Principal principal) { return "Hello, " + principal.getName() + "!"; }}

La configuration ici est très similaire aux autres frameworks. Vous annotez la classe avec @RestController pour informer Spring que vous recevrez des demandes sur la classe. @GetMapping recevra les requêtes HTTP GET sur le chemin /hello. Pour récupérer l’utilisateur authentifié, vous utilisez l’annotation @AuthenticationPrincipal.

Contrairement aux autres frameworks, vous n’avez pas besoin de spécifier que ce point de terminaison est authentifié car Spring contrôle déjà ces informations à partir de ses configurations.

La dernière étape consiste à ajouter les informations de l’émetteur, afin que le support OIDC de Spring Security puisse découvrir automatiquement les points de terminaison avec lesquels il doit communiquer.

Modifiez src/main/resources/applications.propertieset ajoutez la configuration suivante :

okta.oauth2.issuer=https://{yourOktaDomain}/oauth2/default

Testons-le ! Démarrez votre application Spring Boot à l’aide de Maven.

./mvnw spring-boot:run

Ensuite, ouvrez un terminal et exécutez la commande ci-dessous:

curl -X GET -I http://localhost:8080/hello

La réponse est une erreur HTTP 401, car vous n’avez pas inclus le jeton :

p>

HTTP/1.1 401Set-Cookie: JSESSIONID=316DCFD55C302A8D69EFD865411DFA77; Path=/; HttpOnlyWWW-Authenticate: BearerX-Content-Type-Options: nosniffX-XSS-Protection: 1; mode=blockCache-Control: no-cache, no-store, max-age=0, must-revalidatePragma: no-cacheExpires: 0X-Frame-Options: DENYContent-Length: 0Date: Thu, 09 Jan 2020 15:46:34 GMT

Testez-le à nouveau, en passant maintenant le jeton:

curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hello

Cela a fonctionné! Comme pour les autres services, le résultat de cette commande est le suivant :

Hello, [email protected]!

Spring Boot clocks dans au moins la quantité de code requise: 17 lignes de Java et seulement 1 ligne de configuration ! Le printemps a toujours été excellent pour faciliter la vie des développeurs, ce n’est donc pas une surprise.

C’est tout! Vous avez implémenté une API REST Java de base dans les trois frameworks !

Réflexions finales sur les API REST Avec Java : Micronaut, Quarkus et Spring Boot

Lorsqu’il s’agit de développer votre API REST, les trois frameworks ont bien fait le travail. Avec seulement un peu de code et une certaine configuration, vous avez pu développer une application sécurisée en utilisant Okta et OAuth 2.0.

Le printemps existe depuis de nombreuses années, il est très populaire et présente de nombreuses caractéristiques autour de son écosystème. Personnellement, je crois toujours que c’est la meilleure option disponible lors de la programmation en Java.

Micronaut et Quarkus gagnent en popularité et prennent de l’ampleur au sein de la communauté Java. Si vous rencontrez des problèmes de performances, ou peut-être si vous avez mal à un changement, vous pourriez essayer l’un d’eux et voir comment cela se passe.

La performance est le point de comparaison le plus souvent mis en évidence entre ces trois frameworks. Si vous recherchez un démarrage rapide dans un environnement sans serveur, ou la possibilité de créer des images natives avec GraalVM, Micronaut et Quarkus fonctionnera probablement bien pour vous. Juste pour le plaisir, les temps de démarrage de chacune de ces applications sont les suivants (basés sur la moyenne de trois tentatives):

• Micronaut: 474ms
• Quarkus: 1132ms
• Spring Boot: 1014ms

J’ai obtenu ces chiffres en exécutant les objectifs Maven de développement de chaque framework.

• Micronaut: ./mvnw mn:run
• Quarkus:./mvnw compile quarkus:dev
• Botte à ressort: ./mvnw spring-boot:run

Ces commandes ne sont pas optimisées pour la vitesse, j’ai donc empaqueté chaque application avec ./mvnw package et je les ai démarrées avec java -jar.

• Micronaut: 596ms
• Quarkus: 658ms
• Spring Boot: 1878ms

REMARQUE: Ces chiffres ont été calculés sur un MacBook Pro 2019 doté d’un processeur Intel Core i9 8 cœurs 2,4 GHz et de 64 Go de RAM. OpenJDK 15 a été utilisé sans paramètre JAVA_OPTS.

Si vous recherchez des temps de démarrage encore plus rapides, vous pouvez utiliser GraalVM. Plutôt que d’exécuter moi-même des tests de synchronisation, j’ai regardé la documentation de chaque projet.

• Micronaut : 12 ms selon la création de votre première application Micronaut Graal.
• Quarkus : 14ms selon Quarkus et GraalVM : Démarrage en Hibernation à Vitesse Supersonique, Taille Subatomique sur InfoQ. Les documents Quarkus ne répertorient pas d’heure de démarrage.
• Spring Boot : 44 ms selon la version 0.6.0 native de Spring Graal.

Au final, vous serez en mesure de développer de manière productive une application sécurisée, quel que soit le choix que vous ferez.

Vous voulez jeter un coup d’œil au code source ? Vous pouvez le trouver sur GitHub à l’exemple de comparaison okta-java-rest-api.

Voulez-vous en savoir plus sur Java, les API REST et les applications sécurisées ? Voici quelques autres articles de notre blog qui pourraient vous être utiles :

• Regardez GraalVM Transformer votre Java en Binaires
• Guide Java OAuth 2.0: Sécurisez votre Application en 5 Minutes
• Microservices Java avec Spring Boot et Spring Cloud
• Comment développer une application Quarkus avec Authentification Java et OIDC
• Authentification simple avec Spring Security

Pour d’autres articles comme celui-ci, suivez @oktadev sur Twitter. Nous publions également régulièrement des screencasts sur notre chaîne YouTube!

Journal des modifications :

• 23 septembre 2020 : Mise à niveau vers Micronaut 2.0.2, Quarkus 1.8.1 et Spring Boot 2.3.4. Voir les modifications de code dans l’exemple d’application sur GitHub. Les modifications apportées à cet article peuvent être consultées dans oktadeveloper / okta-blog #423.
• 21 mai 2020 : Ajout des temps de démarrage pour java -jar et fonctionnant avec GraalVM. Les modifications apportées à cet article peuvent être consultées dans oktadeveloper / okta-blog #304.
• 20 mai 2020 : Mise à niveau vers Micronaut 1.3.5, Quarkus 1.4.2 et Spring Boot 2.3.0. Voir les modifications de code dans l’exemple d’application sur GitHub. Les modifications apportées à cet article peuvent être consultées dans oktadeveloper / okta-blog #301.
• 30 janvier 2020: Mise à jour pour optimiser Micronaut en fonction des commentaires de l’équipe Micronaut. Les temps de démarrage ont également été recalculés sur la base d’une moyenne de trois tentatives. Voir les modifications de code dans l’exemple d’application sur GitHub. Les modifications apportées à cet article peuvent être consultées dans oktadeveloper / okta-blog #176.