arrière-plan
Les amis qui se sont transformés des applications monolithiques traditionnelles à Spring Cloud me demandent, comment gérer les autorisations de microservice sous Spring Cloud ? Comment concevoir plus raisonnablement? Dans un grand point de vue, il est appelé les autorisations de service, qui sont divisées en trois parties:用户认证,用户权限et服务校验.
Authentification des utilisateurs
Les applications monolithiques traditionnelles peuvent être habituées à l'existence de sessions. Après les microservices de Spring Cloud, les séances peuvent être résolues par des sessions distribuées, mais ce ne sont pas la meilleure stratégie après tout. Certaines personnes ont commencé à mettre en œuvre Spring Cloud Security combinée à OAuth2 , qui est bien connue pour son OAuth2. Plus tard, afin d'optimiser les problèmes de stockage des Access Token dans OAuth 2 et d'améliorer la disponibilité et l'évolutivité des services back-end, il existe une meilleure méthode de vérification des jetons JWT (jeton Web JSON). Une chose à souligner ici est que OAuth2 et JWT ne sont pas du tout comparables, ce sont deux choses complètement différentes.
OAuth2是一种授权框架, tandis que JWT est un protocole d'authentification
Framework d'authentification OAuth2 OAuth2 contient quatre rôles:
OAuth2 contient 4 modes d'autorisation
Parmi eux, le processus d'opération d'OAuth2 est illustré dans la figure ci-dessous, extrait de RFC 6749:
+ -------- + + ------------------------ + | | - (a) - Demande d'autorisation -> | Ressource || | | | | Propriétaire || | <- (b) - Grant d'autorisation --- | || | + ------------------------ + | || | + ------------------- + | | - (c) - Grant d'autorisation -> | Autorisation || Client | | | Serveur || |<-(D)--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----->| Ressource || | | Server || <- (f) --- Ressource protégé --- | | + -------- + + ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Dans Spring Cloud OAuth2, toutes les demandes d'accès aux ressources de microservice transportent des jetons dans l'en-tête HTTP. Le service accessible demandera ensuite au serveur d'autorisation pour vérifier la validité du jeton. De cette façon, nous avons besoin两次或者更多次demandes. Toutes les vérifications de validité des jetons incombent au serveur d'autorisation, qui est devenu un très gros goulot d'étranglement pour l'expansion horizontale de notre système.
Protocole de certification JWT
授权服务器sérialise les informations de l'utilisateur et la portée de l'autorisation et met une chaîne JSON, puis utilise Base64 pour le coder, et signe enfin la chaîne avec une clé privée dans le serveur d'autorisation pour obtenir un JSON Web Token .
En supposant que tous les autres serveurs de ressources détiendront une clé publique RSA. Lorsque le serveur de ressources reçoit la demande d'avoir un jeton dans l'en-tête HTTP, le serveur de ressources peut obtenir le jeton et vérifier s'il utilise la signature de clé privée correcte (s'il a été signé par le serveur autorisé, c'est-à-dire la vérification de la signature). Après avoir réussi la vérification, les informations de vérification valides contenues dans ToEKN seront obtenues après désérialisation.
Parmi eux, le principal organigramme de l'opération est le suivant:
+ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Grâce à la méthode ci-dessus, nous pouvons bien compléter l'authentification de l'utilisateur basé sur le service.
Autorisation des utilisateurs
Tout le monde aime shiro pour le blocage d'autorisation des applications traditionnelles à corps à corps, et c'est assez facile à utiliser. Mais une fois divisés, les autorisations commencent à être dispersées à travers les différentes API. shiro fonctionne-t-il toujours? Dans le projet, je n'ai pas utilisé shiro . Une fois les extrémités avant et arrière séparées, l'interaction est un jeton, les services backend sont apatrides, les boutons frontaux sont des ressources et où pouvons-nous gérer les autorisations?
Résumé et conception
Avant d'introduire une conception de noyau flexible, permettez-moi de vous présenter un concept de prévisualisation: RBAC (contrôle d'accès basé sur les rôles, contrôle d'accès basé sur les rôles), ce qui signifie que les utilisateurs s'associent aux autorisations via des rôles. Autrement dit, un utilisateur a plusieurs rôles et chaque rôle a plusieurs autorisations.
Le RBAC est en fait un modèle analytique, principalement divisé en: modèle de base RBAC0 (RBAC de base), modèle hiérarchique de rôle RBAC1 (RBAC hiérarchal), modèle de restriction de rôle RBAC2 (contrainte RBAC) et modèle unifié RBAC3 (combine RBAC).
Noyau UML
Ceci est le diagramme de relations RBAC abstrait de l'auteur après plusieurs scénarios commerciaux
Description de la classe
Groupe
Un groupe ou un groupe, une collection avec un certain nombre d'autorisations, peut également être un porteur d'autorisations.
子类: utilisateur (utilisateur), rôle (rôle), position (post), unité (département). Grâce à la composition spécifique de l'utilisateur, des groupes ou des groupes de scénarios commerciaux différents sont formés et les autorisations des utilisateurs sont obtenues par autorisation de la classe parent du groupe ou du groupe.
Autorisation
Les autorisations, l'intégration avec un certain nombre de ressources, peuvent également être le transporteur de ressources.
Ressources
Il existe des ressources sous autorisation, et les sources de ressources incluent: menu (menu), bouton (autorisation d'action), éléments de page (bouton, onglet, etc.), autorisations de données, etc.
Programme
Les programmes, le transporteur de rendu pour les contrôles d'autorisation connexes, peuvent être montés dans plusieurs menus.
Composition de base des programmes Web communs
La relation entre le modèle et les microservices
Si toutes les interfaces API après le service Spring Cloud sont définies comme Resources ci-dessus, nous pouvons voir une telle situation.
Par exemple, si un utilisateur ajoute, supprime, modifie et vérifie, notre page le fera.
| Éléments de page | Codage des ressources | URI de ressources | Méthode de demande de ressources |
|---|---|---|---|
| Requête | user_btn_get | / api / user / {id} | OBTENIR |
| Augmenter | user_btn_add | / API / Utilisateur | POSTE |
| modifier | user_btn_edit | / api / user / {id} | METTRE |
| supprimer | user_btn_del | / api / user / {id} | SUPPRIMER |
Après avoir abstraction dans la relation de cartographie ci-dessus, nos ressources avant et arrière sont référencées, ce qui nous permet d'autoriser plus facilement les autorisations du groupe d'utilisateurs. Par exemple, j'accorde une autorisation de l'utilisateur à ajouter et à supprimer. Dans前端nous devons seulement vérifier si le资源编码existe ou non pour contrôler l'affichage et la cachette des boutons, tandis que dans后端, nous n'avons qu'à intercepter uniformément et à déterminer si l'utilisateur a URI et请求方式correspondante.
Quant à savoir si l'interception d'autorisation unifiée est placée sur la passerelle Zuul ou sur l'intercepteur du service backend spécifique (filtre, Intececeptor), il peut être facilement mis en œuvre. Non limité à l'invasivité du code. L'organigramme de placer Zuul est le suivant:
Si l'interception unifiée des autorisations est placée sur Zuul , il y aura un problème, c'est-à-dire si le service back-end est sécurisé et que le service ne doit être appelé que via le centre d'enregistrement. Cela implique le troisième module derrière, l'authentification entre les services.
Authentification entre les services
Parce que nous savons tous que les services sont directement appelés procédures distantes après avoir trouvé le client via le centre d'enregistrement. Nous devons protéger chaque service et interface sensible en production. Le processus du sujet est le suivant:
La méthode d'implémentation de l'auteur est basée sur FeignClient Inteceprot de Spring Cloud (applique automatiquement pour le jeton de service, passer le contexte actuel) et Mvc Inteceptor (vérification du jeton de service, mettez à jour le contexte actuel) pour protéger davantage la sécurité du service.
Après avoir combiné les caractéristiques de Spring Cloud, le graphique de flux global est le suivant:
Point d'optimisation
Bien que la sécurité de l'interface API soit assurée par la vérification de la légalité utilisateur susmentionnée, l'interception d'autorisation de l'utilisateur et l'authentification entre les services, Http访问频率est relativement élevée. Lorsque le nombre de demandes augmente, le problème de慢sera particulièrement évident. Certaines stratégies d'optimisation peuvent être prises en compte, telles que le cache d'autorisation de l'utilisateur, la distribution et le stockage mixte des informations d'autorisation de service, et un actualisation régulière des jetons d'authentification de service.
Conclusion
Ce qui précède est mon idée générale dans le projet. Les amis intéressés peuvent apprendre de mon projet open source. Bienvenue à Star:
- Gitchina: https://gitee.com/minull/ace-security (JWT, autorisation utilisateur)
- github: https://github.com/wxiaoqi/ace-security
- Gitchina: http://git.oschina.net/geek_qi/ace-gate (Authentification du service)
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.