Stratégie d'authentification des microservices

J'ai du mal à choisir une stratégie d'authentification décente / sécurisée pour une architecture de microservices. Le seul article SO que j'ai trouvé sur le sujet est celui-ci: Single Sign-On dans Microservice Architecture

Mon idée ici est d'avoir dans chaque service (ex. Authentification, messagerie, notification, profil etc.) une référence unique à chaque utilisateur (assez logiquement alors le sien user_id) et la possibilité d'obtenir l'utilisateur actuel ids'il est connecté.

D'après mes recherches, je vois qu'il y a deux stratégies possibles:

1. Architecture partagée

Dans cette stratégie, l'application d'authentification est un service parmi d'autres. Mais chaque service doit être capable de faire la conversion session_id=> user_iddonc ça doit être très simple. C'est pourquoi j'ai pensé à Redis, qui stockerait la clé: valeur session_id:user_id.

2. Architecture du pare-feu

Dans cette stratégie, le stockage de session n'a pas vraiment d'importance, car il n'est géré que par l'application d'authentification. Ensuite, le user_idpeut être transmis à d'autres services. J'ai pensé à Rails + Devise (+ Redis ou mem-cached, ou cookie storage, etc.) mais il y a des tonnes de possibilités. La seule chose qui compte, c'est que Service X n'aura jamais besoin d'authentifier l'utilisateur.

Comment ces deux solutions se comparent-elles en termes de:

• Sécurité
• robustesse
• évolutivité
• facilité d'utilisation

Ou peut-être suggéreriez-vous une autre solution que je n'ai pas mentionnée ici?

J'aime mieux la solution n ° 1, mais je n'ai pas trouvé beaucoup d'implémentation par défaut qui me garantirait le fait que je vais dans la bonne direction.

J'espère que ma question ne sera pas close. Je ne sais pas vraiment où le demander.

Merci d'avance

D'après ce que je comprends, un bon moyen de le résoudre est d'utiliser le protocole OAuth 2 (vous pouvez trouver un peu plus d'informations à ce sujet sur http://oauth.net/2/ )

Lorsque votre utilisateur se connecte à votre application, il recevra un jeton et avec ce jeton, il pourra l'envoyer à d'autres services pour les identifier dans la demande.

Exemple de conception de microservices chaînés

Ressources:

• http://presos.dsyer.com/decks/microservice-security.html
• https://github.com/intridea/oauth2
• https://spring.io/guides/tutorials/spring-security-and-angular-js/

Réponse courte: utilisez l'authentification basée sur un jeton de type Oauth2.0, qui peut être utilisée dans tout type d'application comme une application Web ou une application mobile. La séquence des étapes impliquées pour une application Web serait alors de

1. s'authentifier auprès du fournisseur d'identité
2. conserver le jeton d'accès dans le cookie
3. accéder aux pages dans webapp
4. appeler les services

Le diagramme ci-dessous montre les composants qui seraient nécessaires. Une telle architecture séparant les API web et data donnera une bonne évolutivité, résilience et stabilité

Le modèle de passerelle API doit être utilisé pour implémenter cela à l'aide d'OpenID Connect. L'utilisateur sera authentifié par IDP et obtiendra le jeton JWT du serveur d'autorisation. Désormais, le système de passerelle API peut stocker ce jeton dans la base de données Redis et définir le cookie sur le navigateur. La passerelle API utilisera le cookie pour valider la demande de l'utilisateur et enverra le jeton aux microservices.

API Gateway agit comme un point d'entrée unique pour tous les types d'applications clientes telles que l'application cliente de script java publique, l'application Web traditionnelle, l'application mobile native et les applications clientes tierces dans l'architecture Microservice.

Vous pouvez trouver plus de détails à ce sujet sur http://proficientblog.com/microservices-security/

vous pouvez utiliser le serveur idenitty 4 à des fins d'authentification et d'autorisation

vous devez utiliser l' architecture de pare-feu, vous avez donc plus de contrôle sur la sécurité, la robustesse, l'évolutivité et la facilité d'utilisation