En premier lieu, pour tirer le meilleur parti de ce guide, assurez-vous de disposer des éléments suivants :

• Java JDK 17+ : le coeur de notre environnement de développement
• Spring Boot 3.1.0.RELEASE ou ultérieur : le framework choisi pour notre application
• Maven 3.6+ : pour la gestion et la construction du projet
• Keycloak 12.0.4 ou ultérieur : notre système d’authentification centralisé
• Postman : outil indispensable pour tester nos endpoints sécurisés

Commencez par installer le Java JDK 17, disponible sur le site officiel d’Oracle ou via une distribution OpenJDK. Vérifiez l’installation en exécutant :

java -version

Ensuite, téléchargez IntelliJ IDEA depuis le site officiel et installez-le. Il s’agit de l’environnement de développement intégré (IDE) choisit. La version Community gratuite sera parfaitement adaptée à nos besoins.

Nous utiliserons Spring Initializr pour générer le squelette de notre application Spring Boot 3. Pour ce faire, accédez à start.spring.io, sélectionnez Java 17 comme version de Java, et Spring Boot 3.x.x comme version de Spring Boot. Ajoutez les dépendances pour Spring Web, Spring Security, et OAuth2 Client.

Avec Spring Initializr, configurez votre projet avec Maven, Java, la version Spring Boot adéquate et les dépendances nécessaires mentionnées précédemment.

•  Project : Maven Project
• Language : Java
• Spring Boot : 3.x.x
• Packaging : Jar
• Java : 17
• Dependencies : Spring Web, Spring Security, OAuth2 Client

Téléchargez et décompressez le projet dans votre espace de travail.

Lancez ensuite IntelliJ IDEA et sélectionnez “Open”. Naviguez jusqu’au répertoire du projet extrait et ouvrez-le.

Assurez-vous que votre pom.xml spécifie Java 17 comme version du compilateur. Pour cela, ajoutez ou modifiez la section properties comme suit :

<properties>

<java.version>17</java.version>

</properties>

Spring Boot 3 a introduit quelques changements et améliorations. C’est pourquoi nous vous conseillons de consulter la documentation officielle pour les ajustements spécifiques qui pourraient être nécessaires pour votre application.

Avant de commencer à implémenter le code de notre projet, il est essentiel de suivre les instructions détaillées fournies dans la première partie de notre guide. Cette phase préliminaire inclut la configuration approfondie de Keycloak. Il s’agit d’une étape fondamentale pour assurer la sécurité de votre application Spring Boot.
Vous pouvez accéder à ces directives détaillées dans le deuxième article de notre série, disponible via ce lien : Configurer Keycloak pour Spring Boot. Notons qu’il est crucial de réaliser ces configurations avant de poursuivre.

Une fois Keycloak configuré, vous devrez ensuite ajouter les dépendances nécessaires à votre projet Spring Boot et configurer Spring Security pour exploiter OAuth2 et OpenID Connect, conformément aux étapes décrites précédemment.

Spring Security facilite l’intégration d’OAuth2 et OpenID Connect. Ce qui permet de sécuriser les applications Spring Boot avec peu d’effort. Voici comment configurer Spring Security pour utiliser Keycloak :

Tout d’abord, dans votre application Spring Boot, ajoutez les dépendances nécessaires pour Spring Security et le support OAuth2 dans votre fichier pom.xml.

À ce stade, IntelliJ devrait automatiquement reconnaître le projet comme un projet Maven et télécharger les dépendances requises.

La configuration précise de Keycloak dans application.yml est fondamentale pour sécuriser votre application Spring Boot avec des mécanismes d’authentification modernes et robustes. Cela facilite la gestion de l’authentification et de l’autorisation tout en assurant la sécurité et la flexibilité de votre application.

Cette section vise à spécifier les détails relatifs à l’application cliente que vous avez enregistrée dans Keycloak. Chaque application qui souhaite utiliser Keycloak pour l’authentification doit être enregistrée comme client dans Keycloak.

• client-id : identifiant unique de votre client/application dans Keycloak. Il permet à Keycloak de reconnaître les demandes provenant de votre application.
• authorization-grant-type : type d’autorisation utilisé pour l’authentification. authorization_code est un flux sécurisé adapté aux applications client-serveur où le code est échangé contre un token.
• scope : portée des autorisations demandées. openid est essentiel pour utiliser OpenID Connect et obtenir l’identité de l’utilisateur.

#client registration configuration
spring.security.oauth2.client.registration.keycloak.client-id=springboot-openid-client-app
spring.security.oauth2.client.registration.keycloak.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.keycloak.scope=openid

Ici, vous définissez la configuration de votre fournisseur OpenID Connect (OIDC), en l’occurrence Keycloak. Cette configuration permet à Spring Security de savoir où et comment communiquer avec Keycloak.

• issuer-uri : URI de l’émetteur de token de Keycloak. Cela informe Spring Security où envoyer les requêtes d’authentification et de validation de token.
• user-name-attribute : attribut utilisé pour identifier le nom d’utilisateur.
• preferred_username : attribut standard dans les tokens OpenID Connect qui contient le nom d’utilisateur.

#OIDC provider configuration:
spring.security.oauth2.client.provider.keycloak.issuer-uri=http://localhost:8180/auth/realms/Keycloak_SpringBoot
spring.security.oauth2.client.provider.keycloak.user-name-attribute=preferred_username

Pour sécuriser votre API, vous devez valider les JWT tokens envoyés par les clients. Cette configuration indique à Spring Security comment et où valider ces tokens.

• issuer-uri : l’URI de l’émetteur de token est également utilisé pour la validation des JWT tokens contre le serveur Keycloak. Cela permet de garantir que les tokens ont été émis par votre serveur d’authentification Keycloak et sont valides.

#validating JWT token against our Keycloak server
spring.security.oauth2.resourceserver.jwt.issuer-uri=http://localhost:8180/auth/realms/Keycloak_SpringBoot

• Sécurité : ces configurations garantissent que seule l’authentification et les tokens valides émis par votre serveur Keycloak peuvent accéder aux ressources sécurisées de votre application.
• Flexibilité : en définissant ces paramètres dans application.yml, vous centralisez la configuration de sécurité. Par conséquent, cela rend votre application facile à ajuster ou à déployer dans différents environnements (par exemple, développement, test, production), sans avoir à modifier le code.
• Conformité : utiliser OpenID Connect avec Keycloak de cette manière s’assure que votre application est conforme aux standards modernes d’authentification et d’autorisation. Cela permet notamment d’offrir une expérience utilisateur sécurisée et cohérente.

Keycloak, en tant que solution d’Identity and Access Management (IAM), fournit une plateforme puissante pour mettre en œuvre ces protocoles. Dans ce contexte, Spring Security, grâce à sa flexibilité et à sa puissante abstraction, se révèle être un excellent choix pour intégrer OAuth2/OpenID Connect dans les applications Spring Boot.

Pour réussir cette intégration, il est essentiel de comprendre comment configurer Spring Security pour travailler avec Keycloak, en utilisant OAuth2 et OpenID Connect pour l’authentification et l’autorisation. Cette configuration est cruciale pour sécuriser les applications Spring Boot. Cela protègera ainsi les ressources et les données sensibles. La classe SecurityConfig, qui est au cœur de cette configuration, définit la manière dont les requêtes sont sécurisées, comment les utilisateurs sont authentifiés et autorisés, et comment les sessions sont gérées.

Voici un exemple de classe de Configuration :

Il est important de noter que la compréhension détaillée de cette classe de configuration et de ses composants joue un rôle central dans l’efficacité de la sécurité de l’application. Elle implique non seulement la configuration des endpoints sécurisés et la gestion des rôles d’utilisateurs mais aussi l’intégration fluide avec Keycloak comme provider d’identité.

Ainsi, en explorant la classe SecurityConfig, nous plongeons dans les mécanismes qui sous-tendent l’authentification et l’autorisation dans les applications modernes sécurisées avec Spring Boot, Spring Security, OAuth2, et Keycloak.

À ce titre, voici une explication détaillée de cette classe de configuration :

• @Configuration & @EnableWebSecurity : ces annotations indiquent à Spring Boot que cette classe configure les aspects de sécurité de l’application.
• @EnableWebSecurity : active la sécurité web de Spring Security.
• SessionRegistry & SessionAuthenticationStrategy : ces beans gèrent les sessions d’utilisateur. Cela permet un contrôle fin sur les sessions actives et la stratégie d’authentification de session, essentiel pour la gestion des sessions dans les applications web.
• HttpSessionEventPublisher : ce bean permet à Spring Security de publier des événements de session HTTP pour être utilisés dans la gestion des sessions.
• SecurityFilterChain : c’est le cœur de la configuration de sécurité. Il définit les règles pour sécuriser les endpoints.

Pour aller plus loin, voici les points clés de cette configuration :

• Autorisation des requêtes : définit les règles d’accès aux différents endpoints de l’application. Par exemple, /api/public* est accessible sans authentification, tandis que /customers* nécessite que l’utilisateur ait le rôle user.
• OAuth2 Resource Server : configure l’application pour agir comme un serveur de ressources OAuth2, validant les JWT tokens pour les requêtes entrantes.
• OAuth2 Login : Ccnfigure le support pour le login OAuth2. Cela permet l’authentification des utilisateurs via OAuth2/OpenID Connect.
• GrantedAuthoritiesMapper : ce bean adapte les autorités (rôles) d’un utilisateur à partir des claims du token JWT ou des attributs utilisateur obtenus d’OIDC/OAuth2 provider. Cela permet une granularité fine dans l’attribution des rôles basée sur les informations contenues dans le token ou les attributs utilisateur.

La méthode userAuthoritiesMapperForKeycloak est particulièrement intéressante. Elle montre comment transformer les claims d’un token ou les attributs d’utilisateur en autorités Spring Security :

• Extraction des rôles : elle extrait les rôles à partir des claims spécifiques (REALM_ACCESS_CLAIM et GROUPS) présents dans les tokens JWT ou les attributs d’utilisateur.
• Création des GrantedAuthority : pour chaque rôle extrait, elle crée un objet SimpleGrantedAuthority. Il est ensuite utilisé par Spring Security pour prendre des décisions d’autorisation.

Cette configuration illustre la puissance et la flexibilité de Spring Security dans la gestion de l’authentification et de l’autorisation dans les applications modernes. En utilisant OAuth2 et OpenID Connect avec Keycloak, vous pouvez sécuriser efficacement vos applications tout en offrant une expérience utilisateur transparente et sécurisée. Cependant attention, la configuration requiert une attention minutieuse aux détails car elle définit les fondements de la sécurité de votre application.

La création de points de terminaison pour tester l’authentification est également une étape essentielle. En définissant des points de terminaison publics et privés, vous pouvez non seulement vérifier la configuration de votre sécurité mais aussi illustrer comment gérer différentes catégories d’accès au sein de votre application. Ainsi, créez des points de terminaison dans votre application pour tester l’authentification :

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

Ici, les endpoints /api/messages/public et /api/messages/private illustrent comment gérer l’accès basé sur l’authentification de l’utilisateur. Le premier est accessible sans authentification, tandis que le second nécessite que l’utilisateur soit authentifié.

L’écriture de tests unitaires pour les points de terminaison d’une application Spring Boot sécurisée avec OAuth2 et Keycloak assure la qualité et la sécurité de votre code. Les tests unitaires vous permettent de vérifier que votre logique d’authentification fonctionne comme prévu avant de déployer votre application en production.
Ici, examinons comment enrichir et expliquer plus en détail la section de tests unitaires pour le HelloController.

• Mocking des Services Externes : plutôt que d’utiliser un RestTemplate pour obtenir un vrai token d’accès de Keycloak, nous pouvons mocker cette partie pour rendre nos tests plus isolés et moins dépendants de l’infrastructure externe.
• @WebMvcTest : cette annotation est utilisée pour un test de contrôleur MVC. Elle charge uniquement les composants MVC pertinents et est donc plus légère que @SpringBootTest.
• @MockBean : bien que non utilisée directement dans cet exemple simplifié, elle est indispensable lorsque vous testez des contrôleurs qui dépendent de services ou de composants Spring injectés.
• @WithMockUser : cette annotation permet de simuler facilement une situation où un utilisateur est authentifié. Elle est utile pour tester les routes sécurisées sans nécessiter un token d’accès réel.

Dès lors, en développant et en enrichissant vos tests unitaires de cette manière, vous vous assurez non seulement que les points de terminaison répondent correctement, mais aussi que votre application respecte les contraintes de sécurité attendues.

L’un des atouts majeurs de Postman réside dans sa capacité à partager des collections entre équipes et à contribuer à la documentation d’API de manière collaborative. Pour bénéficier de cette facilité, commençons par l’installation de Postman et l’importation d’une collection d’API depuis un dépôt GitHub.

1. Téléchargement : dans un premier temps, rendez-vous sur le site officiel de Postman. Ensuite, téléchargez la version appropriée pour votre système d’exploitation.
2. Installation : ouvrez le fichier téléchargé et suivez les instructions pour installer Postman sur votre ordinateur.
3. Ouverture de Postman : une fois l’installation terminée, lancez Postman.

• Téléchargement de la collection : recherchez le fichier .json de la collection dans le dossier ressources. Cliquez ensuite sur le fichier et utilisez l’option ‘Download’ pour le sauvegarder localement.
• Importation dans Postman : ouvrez Postman, cliquez sur le bouton ‘Import’ situé en haut à gauche, puis sélectionnez le fichier .json que vous venez de télécharger.
• Confirmation : enfin, une fois le fichier sélectionné, Postman affichera les détails de la collection. Confirmez l’importation pour ajouter la collection à votre espace de travail Postman.

Vous pouvez modifier les paramètres des requêtes depuis l’onglet des variables d’environnement.

Dans la capture d’écran ci-dessus, nous voyons que l’interface de Postman affiche un ensemble de variables d’environnement. Ces variables sont cruciales pour la gestion des informations de configuration qui ne doivent pas être codées en dur dans les requêtes elles-mêmes, comme les URLs de serveur, les identifiants clients, et surtout les tokens d’authentification.

Pour s’assurer que Postman utilise ces variables lors de l’exécution des requêtes, il est impératif de sélectionner l’environnement approprié. Dans votre cas, il semblerait que l’environnement se nomme “OAuth2”, comme on peut le voir dans la capture d’écran ci-dessous, en haut à droite de la fenêtre de Postman. Sachez qu’en cliquant à cet endroit, vous pouvez choisir l’environnement “OAuth2” parmi ceux disponibles.

Une fois l’environnement sélectionné, Postman remplacera automatiquement les variables d’environnement par leurs valeurs actuelles dans toutes les requêtes exécutées. Ce processus permet de s’assurer que les valeurs sensibles, telles que les tokens, sont gérées de manière sécurisée et que votre collection peut être utilisée de manière flexible dans différents contextes ou stages de développement sans avoir besoin de modifier chaque requête individuellement.

Par conséquent, grâce à ces étapes simples, nous avons non seulement installé un outil essentiel pour le développement d’API, mais nous avons également mis en place un moyen rapide de commencer à interagir avec Keycloak. Cela simplifie grandement les tests et le développement pour la suite.

Dans cette section, nous allons créer une nouvelle collection Postman pour tester les requêtes d’authentification. Ensuite, nous configurerons une requête afin d’obtenir un token d’accès depuis Keycloak et utiliser ce token pour accéder au point de terminaison sécurisé. Pour tester l’authentification et l’autorisation dans votre application Spring Boot utilisant Keycloak, suivez les étapes qui suivront dans Postman.

• URL : http://localhost:8080/auth/realms/{realm-name}/protocol/openid-connect/token
• Méthode : POST
• Body : x-www-form-urlencoded
• Paramètres :
  client_id : votre_client_id (Exemple: monapp-springboot)
  client_secret : votre_client_secret
  grant_type : password
  username : votre_nom_utilisateur
  password : votre_mot_de_passe
  scope : openid

Tout d’abord, envoyez la requête et vous recevrez un JSON contenant, entre autres, votre token d’accès (access_token).

Exemple de réponse pour le token d’accès :

{
« access_token »: « eyJhbGciOiJIUzI1NiIsInR… »,
« expires_in »: 300,
 « refresh_expires_in »: 1800,
« token_type »: « bearer »,
 …
}

Nous pouvons maintenant tester l’appel de l’endpoints ‘userInfo’ pour récupérer les informations de l’utilisateur après son authentification avec Keycloak :

Vous pouvez dorénavant accéder à un point de terminaison sécurisé de votre application.

• URL : http://localhost:8081/api/public
• Méthode : GET

Utilisez le token obtenu pour accéder au point de terminaison sécurisé en ajoutant le token d’accès comme Bearer Token dans l’en-tête de la requête.

• URL : http://localhost:8081/api/private
• Méthode : GET
• Headers :
• Authorization : Bearer eyJhbGciOiJIUzI1NiIsInR…

À ce stade, si tout est configuré correctement, vous devriez pouvoir accéder au contenu sécurisé. Si vous n’avez pas les bonnes autorisations ou si le token est invalide, vous recevrez une erreur 401 ou 403.

Exemple de réponse pour un accès autorisé :

{
« message »: « Contenu Privé »
}

Pour tester un projet qui utilise des conteneurs Docker, comme dans le cas d’un serveur d’authentification Keycloak, il est important de suivre une série d’étapes méthodiques pour assurer que chaque partie du système fonctionne correctement. Voici comment vous pourriez procéder pour démarrer et tester le projet :

Ouvrez d’abord Docker Desktop pour visualiser et gérer vos conteneurs. Cela vous permet de contrôler l’état de chaque conteneur, comme illustré dans la capture d’écran ci-desous.

• Ouvrir le fichier docker-compose.yml : ici, assurez-vous que le fichier docker-compose.yml contient les services correctement définis pour Keycloak. Assurez-vous également que toutes les configurations nécessaires sont présentes. Il s’agit notamment des ports, des volumes, des variables d’environnement et des dépendances de service.
• Utiliser l’IDE : comme la capture d’écran ci-dessous le suggère, vous utilisez un IDE qui prend en charge Docker. Ainsi, vous pouvez simplement faire un clic droit sur le fichier docker-compose.yml et sélectionner « Run ‘docker-compose up' » pour démarrer le service Keycloak

• Utilisation de la ligne de commande : néanmoins, si vous préférez utiliser la ligne de commande, ouvrez un terminal, naviguez vers le répertoire contenant votre fichier docker-compose.yml et exécutez :

docker-compose up -d

L’option -d lance les conteneurs en mode détaché, ce qui permet à votre terminal de rester libre pour d’autres commandes.

• Vérifier les Logs : après avoir démarré Keycloak, vérifiez les logs pour s’assurer qu’il n’y a pas d’erreurs au démarrage. Vous pouvez utiliser Docker Desktop ou la commande suivante :

docker-compose logs keycloak

• Tester l’interface web : pour ce faire, ouvrez un navigateur et accédez à l’interface d’administration de Keycloak afin de confirmer qu’elle fonctionne correctement. L’URL par défaut est souvent http://localhost:8180/auth (ou le port que vous avez spécifié dans docker-compose.yml).

Si ces étapes ont été suivis correctement, vous devriez donc avoir une instance de Keycloak en cours d’exécution, prête à être intégrée et utilisée par votre application Spring Boot pour l’authentification et l’autorisation.

Cela garantit que le build de votre application est propre et prêt pour le déploiement ou les tests ultérieurs.

Voici comment procéder :

• Ouvrez votre IDE : assurez-vous d’abord que votre environnement de développement intégré (IDE), comme IntelliJ IDEA, est ouvert et que votre projet est correctement chargé.
• Vérification du fichier pom.xml : vérifiez que votre fichier pom.xml est configuré correctement. Toutes les dépendances nécessaires doivent être déclarées avec les versions appropriées.
• Utilisez la fonctionnalité Maven intégrée de l’IDE : comme indiqué sur l’image ci-dessous, votre IDE possède un outil intégré pour exécuter les commandes Maven. Cliquez sur l’icône Maven à droite ou accédez au menu “View” > “Tool Windows” > “Maven”.
• Sélectionnez l’option ‘clean install’ : dans la fenêtre Maven, dépliez les options sous le nom de votre projet, naviguez vers “Lifecycle” et sélectionnez à la fois “clean” et “install”.
• Exécutez le build : ensuite, cliquez sur le bouton d’exécution (généralement représenté par une flèche verte ou le texte ‘Run’) pour démarrer le processus de “clean install”. L’option “clean” effacera votre dossier target pour s’assurer qu’il n’y a pas de résidus d’anciens builds. L’option « install » compilera votre code, exécutera les tests et installera le package dans votre repository local.
• Console de l’IDE : suivez le processus de build dans la console de votre IDE. Tout message d’erreur ou d’avertissement s’affichera ici. Cela permet de résoudre rapidement les problèmes.
• Résultat du Build : à la fin du processus de build, vérifiez que le message “BUILD SUCCESS” s’affiche. Il indique que le processus s’est terminé avec succès.

Ainsi, en suivant ces étapes, vous assurerez que votre projet Spring Boot est proprement compilé, testé et prêt pour les prochaines étapes.

Par ailleurs, le processus de test de notre projet Spring Boot implique l’exécution de la classe de test pour s’assurer que le code répond correctement aux attentes et aux spécifications. Voici comment vous pouvez procéder pour exécuter le test unitaire :

1. Dans votre IDE, localisez la classe de test que vous souhaitez exécuter. Dans cet exemple, il s’agit de HelloControllerTest.
2. Assurez-vous que les méthodes de test couvrent les scénarios que vous souhaitez valider. Vous devriez avoir des méthodes de test distinctes pour chaque point de terminaison et comportement attendu.
3. Faites un clic droit sur le nom de la classe de test ou sur un test individuel et choisissez ‘Run’ pour démarrer l’exécution des tests. Vous pouvez également utiliser le raccourci, généralement indiqué à côté de l’option ‘Run’.

Notez qu’en suivant ces étapes pour exécuter et valider les classes de test dans votre projet Spring Boot, vous renforcez la confiance dans la qualité et la fiabilité de votre application.

Avant de démarrer l’application, assurez-vous que tous les fichiers de configuration, tels que application.properties ou application.yml et logback.xml, sont correctement configurés. Dans l’IDE, vous pouvez ensuite démarrer l’application en cliquant sur le bouton vert ‘Run’ associé à la configuration de votre application Spring Boot. Il est souvent situé dans la barre d’outils supérieure ou à côté de la configuration dans le menu déroulant. Enfin, assurez-vous que la configuration de démarrage (Run Configuration) sélectionnée correspond à votre application Spring Boot. Si nécessaire, ajustez la configuration via “Edit Configurations” pour spécifier des paramètres tels que les profils Spring actifs ou des variables d’environnement.

Ici, observez bien la console de l’IDE pour le feedback en temps réel pendant que l’application démarre. Vous verrez des logs informatifs, des avertissements, ou des erreurs qui pourraient survenir. Les logs générés par logback, sont essentiels pour comprendre le comportement de votre application. Recherchez des messages indiquant que l’application a démarré avec succès, comme « Started [ApplicationName] in X seconds ».

Pour tester l’accès aux différents écrans, nous allons vérifier que les points de terminaison publics sont accessibles comme prévu et affichent le contenu approprié.

Lancez votre navigateur et dirigez-vous vers http://localhost:8081/api/public. Cette URL correspond à l’endpoint public exposé par votre contrôleur.
Une fois la page chargée, vous devriez voir le texte “Contenu Public”, ce qui indique que l’endpoint est accessible sans authentification.

En revanche, l’accès à l’url localhost:8081/api/private nécessite une authentification. L’accès sécurisé à l’endpoint privé est un élément clé pour garantir que seuls les utilisateurs authentifiés peuvent voir le contenu sensible. Entrez donc l’URL http://localhost:8081/api/private dans votre navigateur. Puisque cet endpoint nécessite une authentification, vous serez redirigé vers la page de connexion Keycloak (voir capture d’écran ci-dessous).

Dans les champs prévus à cet effet, saisissez le nom d’utilisateur et le mot de passe que vous avez définis lors de la configuration de Keycloak.

• Username : my-user
• Password : my-password

Saisissez ensuite vos identifiants de connexion dans Keycloak. Si les informations d’identification sont correctes, vous serez redirigé vers l’endpoint privé.
Une fois redirigé vers l’endpoint privé, vérifiez que le contenu privé est affiché comme prévu, ce qui confirme que la procédure d’authentification fonctionne correctement :

En cas d’échec de l’authentification, des messages d’erreur clairs devraient s’afficher pour guider l’utilisateur.

En conclusion, ce guide pratique présente les étapes clés pour sécuriser une application Spring Boot en utilisant OAuth2 et OpenID Connect avec Keycloak et Spring Security. À travers ce processus, vous avez notamment pu saisir l’importance de l’authentification et de la gestion des sessions dans le développement d’applications web modernes. Les classes de configuration de sécurité de Spring Boot offrent une fondation solide pour protéger vos ressources et les données sensibles, tout en offrant une expérience utilisateur transparente et sécurisée.

Nous avons également montré comment :

• Configurer un environnement de développement, intégrer Keycloak avec Spring Security et créer des points de terminaison sécurisés pour gérer l’accès public et privé.
• Ajouter des tests unitaires.
• Créer une collection Postman pour tester les requêtes d’authentification ont renforcé la solidité de votre application.
• Vous disposez maintenant d’un cadre robuste pour implémenter l’authentification avancée dans vos projets futurs, ce qui est essentiel dans l’écosystème actuel du développement de logiciels.

Ce guide n’est qu’une base dans la pratique de sécuriser des applications avec des méthodes d’authentification de pointe. En effet, au fur et à mesure que la technologie évolue, il important de continuer d’apprendre, d’expérimenter et d’intégrer de nouvelles pratiques de sécurité.

Pour rappel, le code source complet de cet exemple ainsi que la collection Postman sont disponibles sur GitHub. N’hésitez pas à cloner le projet et à l’explorer pour mieux comprendre le fonctionnement de l’authentification avec Spring Boot, OAuth2, et Keycloak.

• Documentation officielle de Spring Boot : Spring Boot
• Documentation officielle de Keycloak : Keycloak
• Documentation officielle de Java 17 : Oracle