Comment ça marche Ajouter ABAC Considérations

Magasins de politiques liés à l'API

Lorsque vous créez un nouveau magasin de politiques dans la console Amazon Verified Permissions, vous pouvez choisir l'option Configurer avec API Gateway et une source d'identité. Avec cette option, vous créez un magasin de politiques lié à une API, un modèle d'autorisation pour les applications qui s'authentifient auprès des groupes d'utilisateurs Amazon Cognito ou auprès d'un fournisseur d'identité OIDC (IdP) et obtiennent des données à partir des API Amazon API Gateway. Consultez Créez un magasin de politiques avec une API et un fournisseur d'identité connectés pour démarrer.

Rubriques

Comment les autorisations vérifiées autorisent-elles les demandes d'API
Ajout d'un contrôle d'accès basé sur les attributs (ABAC)
Considérations relatives aux magasins de politiques liés aux API
Résolution des problèmes liés aux magasins de politiques liés à l'API

Important

Les magasins de politiques que vous créez à l'aide de l'option Set up with API Gateway et d'une source d'identité dans la console Verified Permissions ne sont pas destinés à un déploiement immédiat en production. Avec votre magasin de politiques initial, finalisez votre modèle d'autorisation et exportez les ressources du magasin de politiques vers CloudFormation. Déployez les autorisations vérifiées en production de manière programmatique avec le AWS Cloud Development Kit (CDK). Pour plus d’informations, consultez Passage à la production avec AWS CloudFormation.

Dans un magasin de politiques lié à une API et à une source d'identité, votre application présente un jeton de pool d'utilisateurs dans un en-tête d'autorisation lorsqu'elle envoie une demande à l'API. La source d'identité de votre magasin de politiques fournit une validation par jeton pour les autorisations vérifiées. Le jeton forme principal les demandes d'autorisation internes avec l'IsAuthorizedWithTokenAPI. Verified Permissions élabore des politiques relatives à l'appartenance à un groupe d'utilisateurs, comme indiqué dans une réclamation de groupe sous forme de jetons d'identité (ID) et d'accès, par exemple cognito:groups pour les groupes d'utilisateurs. Votre API traite le jeton de votre application dans un autorisateur Lambda et le soumet à Verified Permissions pour une décision d'autorisation. Lorsque votre API reçoit la décision d'autorisation de la part de l'autorisateur Lambda, elle transmet la demande à votre source de données ou refuse la demande.

Composants de la source d'identité et de l'autorisation API Gateway avec autorisations vérifiées

Un groupe d'utilisateurs Amazon Cognito ou un IdP OIDC qui authentifie et regroupe les utilisateurs. Les jetons des utilisateurs renseignent l'appartenance au groupe et le principal ou le contexte que Verified Permissions évalue dans votre magasin de politiques.
Une API REST API Gateway. Les autorisations vérifiées définissent les actions à partir des chemins d'API et des méthodes d'API, par exempleMyAPI::Action::get /photo.
Une fonction Lambda et un autorisateur Lambda pour votre API. La fonction Lambda reçoit les jetons porteurs de votre groupe d'utilisateurs, demande l'autorisation à Verified Permissions et renvoie une décision à API Gateway. Le flux de travail Set up with Cognito and API Gateway crée automatiquement cet autorisateur Lambda pour vous.
Un magasin de politiques d'autorisations vérifiées. La source d'identité du Policy Store est votre groupe d'utilisateurs. Le schéma du magasin de politiques reflète la configuration de votre API, et les politiques lient les groupes d'utilisateurs aux actions d'API autorisées.
Une application qui authentifie les utilisateurs auprès de votre IdP et ajoute des jetons aux demandes d'API.

Comment les autorisations vérifiées autorisent-elles les demandes d'API

Lorsque vous créez un nouveau magasin de politiques et que vous sélectionnez l'option Configurer avec Cognito et API Gateway, Verified Permissions crée le schéma et les politiques du magasin de politiques. Le schéma et les politiques reflètent les actions de l'API et les groupes d'utilisateurs que vous souhaitez autoriser à effectuer ces actions. Verified Permissions crée également la fonction Lambda et l'autorisateur. Vous devez configurer le nouvel autorisateur sur une méthode de votre API.

Schéma qui montre le flux d'une demande d'autorisation avec Amazon API Gateway, Amazon Cognito et Amazon Verified Permissions.

Votre utilisateur se connecte à votre application via Amazon Cognito ou un autre IdP OIDC. L'IdP émet des identifiants et des jetons d'accès contenant les informations de l'utilisateur.
Votre application stocke les JWT. Pour plus d'informations, consultez la section Utilisation de jetons avec des groupes d'utilisateurs dans le manuel Amazon Cognito Developer Guide.
Votre utilisateur demande des données que votre application doit récupérer à partir d'une API externe.
Votre application demande des données à une API REST dans API Gateway. Il ajoute un identifiant ou un jeton d'accès en tant qu'en-tête de demande.
Si votre API dispose d'un cache pour la décision d'autorisation, elle renvoie la réponse précédente. Si la mise en cache est désactivée ou si l'API n'a pas de cache actuel, API Gateway transmet les paramètres de la demande à un autorisateur Lambda basé sur des jetons.
La fonction Lambda envoie une demande d'autorisation à un magasin de politiques d'autorisations vérifiées avec l'IsAuthorizedWithTokenAPI. La fonction Lambda transmet les éléments d'une décision d'autorisation :
1. Le jeton de l'utilisateur en tant que principal.
2. La méthode API combinée au chemin de l'API, par exempleGetPhoto, en tant qu'action.
3. Le terme Application en tant que ressource.
Les autorisations vérifiées valident le jeton. Pour plus d'informations sur la manière dont les jetons Amazon Cognito sont validés, consultez la section Autorisation avec autorisations vérifiées par Amazon dans le guide du développeur Amazon Cognito.
Verified Permissions évalue la demande d'autorisation par rapport aux politiques de votre magasin de politiques et renvoie une décision d'autorisation.
L'autorisateur Lambda renvoie une Deny réponse Allow OR à API Gateway.
L'API renvoie des données ou une ACCESS_DENIED réponse à votre application. Votre application traite et affiche les résultats de la demande d'API.

Ajout d'un contrôle d'accès basé sur les attributs (ABAC)

Une session d'authentification typique avec un IdP renvoie un identifiant et des jetons d'accès. Vous pouvez transmettre l'un ou l'autre de ces types de jetons en tant que jeton porteur dans les demandes d'application adressées à votre API. En fonction de vos choix lors de la création de votre magasin de politiques, Verified Permissions attend l'un des deux types de jetons. Les deux types contiennent des informations sur l'appartenance au groupe de l'utilisateur. Pour plus d'informations sur les types de jetons dans Amazon Cognito, consultez la section Utilisation de jetons avec des groupes d'utilisateurs dans le manuel Amazon Cognito Developer Guide.

Après avoir créé un magasin de politiques, vous pouvez ajouter et étendre des politiques. Par exemple, vous pouvez ajouter de nouveaux groupes à vos politiques au fur et à mesure que vous les ajoutez à votre groupe d'utilisateurs. Étant donné que votre magasin de politiques connaît déjà la manière dont votre groupe d'utilisateurs présente les groupes sous forme de jetons, vous pouvez autoriser un ensemble d'actions pour tout nouveau groupe doté d'une nouvelle politique.

Vous souhaiterez peut-être également étendre le modèle d'évaluation des politiques basé sur les groupes à un modèle plus précis basé sur les propriétés des utilisateurs. Les jetons du pool d'utilisateurs contiennent des informations supplémentaires sur les utilisateurs qui peuvent contribuer aux décisions d'autorisation.

Jetons d'identification: Les jetons d'identification représentent les attributs d'un utilisateur et offrent le plus haut niveau de contrôle d'accès précis. Pour évaluer les adresses e-mail, les numéros de téléphone ou les attributs personnalisés tels que le service et le responsable, évaluez le jeton d'identification.
Jetons d'accès: Les jetons d'accès représentent les autorisations d'un utilisateur avec les étendues OAuth 2.0. Pour ajouter une couche d'autorisation ou pour configurer des demandes de ressources supplémentaires, évaluez le jeton d'accès. Par exemple, vous pouvez vérifier qu'un utilisateur appartient aux groupes appropriés et qu'il possède un champ d'application tel PetStore.read que celui qui autorise généralement l'accès à l'API. Les groupes d'utilisateurs peuvent ajouter des étendues personnalisées aux jetons grâce aux serveurs de ressources et à la personnalisation des jetons lors de l'exécution.

Voir par Utilisation des sources d'identité dans les schémas et les politiques exemple les politiques qui traitent les demandes sous forme de jetons d'identification et d'accès.

Considérations relatives aux magasins de politiques liés aux API

Lorsque vous créez un magasin de politiques lié à une API dans la console Verified Permissions, vous créez un test pour un éventuel déploiement en production. Avant de passer à la production, établissez une configuration fixe pour votre API et votre groupe d'utilisateurs. Tenez compte des facteurs suivants :

API Gateway met en cache les réponses

Dans les magasins de politiques liés à l'API, Verified Permissions crée un autorisateur Lambda avec un TTL de mise en cache d'autorisation de 120 secondes. Vous pouvez ajuster cette valeur ou désactiver la mise en cache dans votre autorisateur. Dans un autorisateur dont la mise en cache est activée, votre autorisateur renvoie la même réponse à chaque fois jusqu'à l'expiration du TTL. Cela peut prolonger la durée de vie effective des jetons du pool d'utilisateurs d'une durée égale au TTL de mise en cache de l'étape demandée.

Les groupes Amazon Cognito peuvent être réutilisés

Amazon Verified Permissions détermine l'appartenance à un groupe pour les utilisateurs du groupe d'utilisateurs à partir de la cognito:groups réclamation contenue dans l'identifiant ou le jeton d'accès d'un utilisateur. La valeur de cette réclamation est un tableau des noms conviviaux des groupes d'utilisateurs auxquels appartient l'utilisateur. Vous ne pouvez pas associer des groupes de groupes d'utilisateurs à un identifiant unique.

Les groupes de groupes d'utilisateurs que vous supprimez et recréez sous le même nom sont présents dans votre magasin de politiques en tant que même groupe. Lorsque vous supprimez un groupe d'un groupe d'utilisateurs, supprimez toutes les références au groupe de votre magasin de politiques.

L'espace de noms et le schéma dérivés de l'API sont point-in-time

Verified Permissions capture votre API à un moment donné : il interroge votre API uniquement lorsque vous créez votre magasin de politiques. Lorsque le schéma ou le nom de votre API change, vous devez mettre à jour votre magasin de politiques et votre autorisateur Lambda, ou créer un nouveau magasin de politiques lié à l'API. Verified Permissions dérive l'espace de noms du magasin de politiques à partir du nom de votre API.

La fonction Lambda n'a pas de configuration VPC

La fonction Lambda créée par Verified Permissions pour votre autorisateur d'API n'est pas connectée à un VPC. Par défaut. Les API dont l'accès au réseau est limité aux VPC privés ne peuvent pas communiquer avec la fonction Lambda qui autorise les demandes d'accès avec des autorisations vérifiées.

Verified Permissions déploie les ressources d'autorisation dans CloudFormation

Pour créer un magasin de politiques lié à une API, vous devez connecter un AWS principal hautement privilégié à la console Verified Permissions. Cet utilisateur déploie une AWS CloudFormation pile qui crée des ressources entre plusieurs AWS services. Ce principal doit être autorisé à ajouter et à modifier des ressources dans Verified Permissions IAM, Lambda et API Gateway. Il est recommandé de ne pas partager ces informations d'identification avec les autres administrateurs de votre organisation.

Consultez Passage à la production avec AWS CloudFormation pour un aperçu des ressources créées par Verified Permissions.

Passage à la production avec AWS CloudFormation

Les magasins de politiques liés aux API permettent de créer rapidement un modèle d'autorisation pour une API API Gateway. Ils sont conçus pour servir d'environnement de test pour le composant d'autorisation de votre application. Après avoir créé votre magasin de politiques de test, passez du temps à affiner les politiques, le schéma et l'autorisateur Lambda.

Vous pouvez ajuster l'architecture de votre API, ce qui nécessite des ajustements équivalents au schéma et aux politiques de votre magasin de politiques. Les magasins de politiques liés à l'API ne mettent pas automatiquement à jour leur schéma à partir de l'architecture d'API. Les autorisations vérifiées interrogent uniquement l'API au moment de la création d'un magasin de politiques. Si votre API change suffisamment, vous devrez peut-être répéter le processus avec un nouveau magasin de politiques.

Lorsque votre application et votre modèle d'autorisation sont prêts à être déployés en production, intégrez le magasin de politiques lié à l'API que vous avez développé à vos processus d'automatisation. Il est recommandé d'exporter le schéma et les politiques du magasin de politiques dans un AWS CloudFormation modèle que vous pouvez déployer sur d'autres Comptes AWS et Régions AWS.

Les résultats du processus de magasin de politiques lié à l'API sont un magasin de politiques initial et un autorisateur Lambda. L'autorisateur Lambda dispose de plusieurs ressources dépendantes. Verified Permissions déploie ces ressources dans une pile générée automatiquement CloudFormation . Pour effectuer un déploiement en production, vous devez collecter les ressources du magasin de politiques et de l'autorisateur Lambda dans un modèle. Un magasin de politiques lié à une API est composé des ressources suivantes :

AWS::VerifiedPermissions::PolicyStore: Copiez votre schéma dans l'SchemaDefinitionobjet. Escapez " les personnages en tant que\".
AWS::VerifiedPermissions::IdentitySource: Copiez les valeurs à partir de la sortie GetIdentitySource de votre magasin de politiques de test et modifiez-les si nécessaire.
Une ou plusieurs des options AWS::VerifiedPermissions::Policysuivantes : Copiez votre déclaration de politique dans l'Definitionobjet. Escapez " les personnages en tant que\".
AWS: :Lambda : :Function, AWS: : : :Role,IAM : : :Policy ,AWS :IAM : : :Authorizer ,AWS ApiGateway AWS::Lambda::Permission: Copiez le modèle depuis l'onglet Modèle de la pile que Verified Permissions a déployée lorsque vous avez créé votre magasin de politiques.

Le modèle suivant est un exemple de magasin de politiques. Vous pouvez ajouter les ressources de l'autorisateur Lambda de votre pile existante à ce modèle.


{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Resources": {
        "MyExamplePolicyStore": {
            "Type": "AWS::VerifiedPermissions::PolicyStore",
            "Properties": {
                "ValidationSettings": {
                    "Mode": "STRICT"
                },
                "Description": "ApiGateway: PetStore/test",
                "Schema": {
                    "CedarJson": "{\"PetStore\":{\"actions\":{\"get /pets\":{\"appliesTo\":{\"principalTypes\":[\"User\"],\"resourceTypes\":[\"Application\"],\"context\":{\"type\":\"Record\",\"attributes\":{}}}},\"get /\":{\"appliesTo\":{\"principalTypes\":[\"User\"],\"resourceTypes\":[\"Application\"],\"context\":{\"type\":\"Record\",\"attributes\":{}}}},\"get /pets/{petId}\":{\"appliesTo\":{\"context\":{\"type\":\"Record\",\"attributes\":{}},\"resourceTypes\":[\"Application\"],\"principalTypes\":[\"User\"]}},\"post /pets\":{\"appliesTo\":{\"principalTypes\":[\"User\"],\"resourceTypes\":[\"Application\"],\"context\":{\"type\":\"Record\",\"attributes\":{}}}}},\"entityTypes\":{\"Application\":{\"shape\":{\"type\":\"Record\",\"attributes\":{}}},\"User\":{\"memberOfTypes\":[\"UserGroup\"],\"shape\":{\"attributes\":{},\"type\":\"Record\"}},\"UserGroup\":{\"shape\":{\"type\":\"Record\",\"attributes\":{}}}}}}"
                }
            }
        },
        "MyExamplePolicy": {
            "Type": "AWS::VerifiedPermissions::Policy",
            "Properties": {
                "Definition": {
                    "Static": {
                        "Description": "Policy defining permissions for testgroup cognito group",
                        "Statement": "permit(\nprincipal in PetStore::UserGroup::\"us-east-1_EXAMPLE|testgroup\",\naction in [\n  PetStore::Action::\"get /\",\n  PetStore::Action::\"post /pets\",\n  PetStore::Action::\"get /pets\",\n  PetStore::Action::\"get /pets/{petId}\"\n],\nresource);"
                    }
                },
                "PolicyStoreId": {
                    "Ref": "MyExamplePolicyStore"
                }
            },
            "DependsOn": [
                "MyExamplePolicyStore"
            ]
        },
        "MyExampleIdentitySource": {
            "Type": "AWS::VerifiedPermissions::IdentitySource",
            "Properties": {
                "Configuration": {
                    "CognitoUserPoolConfiguration": {
                        "ClientIds": [
                            "1example23456789"
                        ],
                        "GroupConfiguration": {
                            "GroupEntityType": "PetStore::UserGroup"
                        },
                        "UserPoolArn": "arn:aws:cognito-idp:us-east-1:123456789012:userpool/us-east-1_EXAMPLE"
                    }
                },
                "PolicyStoreId": {
                    "Ref": "MyExamplePolicyStore"
                },
                "PrincipalEntityType": "PetStore::User"
            },
            "DependsOn": [
                "MyExamplePolicyStore"
            ]
        }
    }
}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Création de magasins de politiques

Résolution des problèmes