Une introduction à Spring Cloud Security

1. Vue d'ensemble

Le module Spring Cloud Security fournit des fonctionnalités liées à la sécurité basée sur les jetons dans les applications Spring Boot.

Plus précisément, cela facilite l'authentification unique basée sur OAuth2 - avec la prise en charge du relais de jetons entre les serveurs de ressources, ainsi que la configuration de l'authentification en aval à l'aide d'un proxy Zuul intégré.

Dans cet article rapide, nous verrons comment nous pouvons configurer ces fonctionnalités à l'aide d'une application client Spring Boot, d'un serveur d'autorisation et d'une API REST fonctionnant comme un serveur de ressources.

Notez que pour cet exemple, nous n'avons qu'une seule application cliente qui utilise SSO pour démontrer les fonctionnalités de sécurité du cloud - mais dans un scénario typique, nous aurions au moins deux applications clientes pour justifier la nécessité d'une authentification unique.

2. Démarrage rapide d'une application de sécurité cloud

Commençons par configurer SSO dans une application Spring Boot.

Tout d'abord, nous devons ajouter la dépendance spring-cloud-starter-oauth2 :

 org.springframework.cloud spring-cloud-starter-oauth2 2.2.2.RELEASE 

Cela entraînera également la dépendance spring-cloud-starter-security .

Nous pouvons configurer n'importe quel site social en tant que serveur d'authentification pour notre site ou nous pouvons utiliser notre propre serveur. Dans notre cas, nous avons choisi cette dernière option et configuré une application qui agit comme un serveur d'autorisation - qui est déployée localement sur // localhost: 7070 / authserver.

Notre serveur d'autorisation utilise des jetons JWT.

De plus, pour qu'un client puisse récupérer les informations d'identification d'un utilisateur, nous devons configurer notre serveur de ressources, fonctionnant sur le port 9000, avec un point de terminaison qui peut servir ces informations d'identification.

Ici, nous avons configuré un point de terminaison / user qui est disponible sur // localhost: 9000 / user.

Pour plus de détails sur la configuration d'un serveur d'autorisation et d'un serveur de ressources, consultez notre article précédent ici.

Nous pouvons maintenant ajouter l'annotation dans une classe de configuration dans notre application client:

@Configuration @EnableOAuth2Sso public class SiteSecurityConfigurer extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { // ... } }

Toutes les demandes nécessitant une authentification seront redirigées vers le serveur d'autorisation. Pour que cela fonctionne, nous devons également définir les propriétés du serveur:

security: oauth2: client: accessTokenUri: //localhost:7070/authserver/oauth/token userAuthorizationUri: //localhost:7070/authserver/oauth/authorize clientId: authserver clientSecret: passwordforauthserver resource: userInfoUri: //localhost:9000/user

Notez que nous avons besoin d'avoir spring-boot-starter-security dans notre chemin de classe pour que la configuration ci-dessus fonctionne.

3. Relayage des jetons d'accès

Lors du relais d'un jeton, un client OAuth2 transmet le jeton OAuth2 qu'il a reçu à une demande de ressource sortante.

Depuis que nous avons déclaré l' annotation @ EnableOauth2Sso , Spring Boot ajoute un bean OAuth2ClientContext dans la portée de la requête. Sur cette base, nous pouvons créer notre propre OAuth2RestTemplate dans notre application cliente:

@Bean public OAuth2RestOperations restOperations( OAuth2ProtectedResourceDetails resource, OAuth2ClientContext context) { return new OAuth2RestTemplate(resource, context); }

Une fois que nous avons configuré le bean , le contexte transmettra le jeton d'accès aux services demandés et actualisera également le jeton s'il expire.

4. Relais d'un jeton OAuth à l'aide du RestTemplate

Nous avons précédemment défini un bean restOperations de type OAuth2RestTemplate dans notre application Client. Par conséquent, nous pouvons utiliser la méthode getForObject () de OAuth2RestTemplate pour envoyer une requête avec les jetons nécessaires à un serveur de ressources protégé depuis notre client.

Tout d'abord, définissons un point de terminaison qui nécessite une authentification dans notre serveur de ressources:

@GetMapping("/person") @PreAuthorize("hasAnyRole('ADMIN', 'USER')") public @ResponseBody Person personInfo(){ return new Person("abir", "Dhaka", "Bangladesh", 29, "Male"); } 

Il s'agit d'un simple point de terminaison REST qui renvoie une représentation JSON d'un objet Person .

Maintenant, nous pouvons envoyer une requête depuis l'application cliente en utilisant la méthode getForObject () qui relaiera le jeton au serveur de ressources :

@Autowired private RestOperations restOperations; @GetMapping("/personInfo") public ModelAndView person() { ModelAndView mav = new ModelAndView("personinfo"); String personResourceUrl = "//localhost:9000/person"; mav.addObject("person", restOperations.getForObject(personResourceUrl, String.class)); return mav; }

5. Configuration de Zuul pour Token Relay

Si nous souhaitons relayer un jeton en aval vers les services proxy, nous pouvons utiliser Spring Cloud Zuul Embedded Reverse Proxy.

Tout d'abord, nous devons ajouter la dépendance Maven pour travailler avec Zuul:

 org.springframework.cloud spring-cloud-starter-netflix-zuul 

Ensuite, nous devons ajouter l' annotation @ EnableZuulProxy à notre classe de configuration dans l'application client:

@Configuration @EnableOAuth2Sso @EnableZuulProxy public class SiteSecurityConfigurer extends WebSecurityConfigurerAdapter { //... }

Il ne reste plus qu'à ajouter les propriétés de configuration de Zuul à notre fichier application.yml :

zuul: sensitiveHeaders: Cookie,Set-Cookie routes: resource: path: /api/** url: //localhost:9000 user: path: /user/** url: //localhost:9000/user

Toute demande arrivant au point de terminaison / api de l'application client sera redirigée vers l'URL du serveur de ressources. Nous devons également fournir l'URL du point de terminaison des informations d'identification de l'utilisateur.

6. Conclusion

Dans cet article rapide, nous avons exploré comment utiliser Spring Cloud Security avec OAuth2 et Zuul pour configurer des serveurs d'autorisation et de ressources sécurisés, ainsi que comment relayer les jetons OAuth2 entre les serveurs à l'aide de Oauth2RestTemplate et du proxy Zuul intégré.

Comme toujours, le code est disponible sur sur GitHub.