Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation des mécanismes d’autorisation Lambda API Gateway
Utilisez un *mécanisme d’autorisation Lambda* (anciennement appelé *mécanisme d’autorisation personnalisée*) pour contrôler l’accès à votre API. Lorsqu’un client soumet une méthode sur votre API, API Gateway appelle votre mécanisme d’autorisation Lambda. Ce dernier prend l’identité de l’appelant en entrée et renvoie une politique IAM en sortie.
Utilisez un mécanisme d’autorisation Lambda pour implémenter un schéma d’autorisation personnalisée. Votre schéma peut utiliser des paramètres de demande pour déterminer l'identité de l'appelant ou utiliser une stratégie d'authentification par jeton porteur telle que SAML OAuth . Créez un autorisateur Lambda dans la console API REST API Gateway, à l'aide du ou d'un AWS CLI SDK. AWS
## Flux d’autorisation du mécanisme d’autorisation Lambda
Le schéma suivant illustre le flux d’autorisation d’un mécanisme d’autorisation Lambda.
**Flux de travail d'autorisation Lambda API Gateway**
1. Le client appelle une méthode sur une API API Gateway, en transmettant un jeton de porteur ou des paramètres de demande.
1. API Gateway vérifie si la demande de méthode est configurée avec un mécanisme d’autorisation Lambda. Si c’est le cas, API Gateway appelle la fonction Lambda.
1. La fonction Lambda authentifie l’appelant. La fonction peut procéder à l’authentification de différentes manières :
+ En appelant un OAuth fournisseur pour obtenir un jeton OAuth d'accès.
+ En appelant un fournisseur SAML pour obtenir une assertion SAML.
+ En générant une politique IAM basée sur les valeurs des paramètres de la demande.
+ En extrayant les informations d’identification d’une base de données.
1. La fonction Lambda renvoie une politique IAM et un identifiant principal. Si la fonction Lambda ne renvoie pas ces informations, l’appel échoue.
1. API Gateway évalue la politique IAM.
+ Si l’accès est refusé, API Gateway renvoie un code de statut HTTP approprié, par exemple `403 ACCESS_DENIED`.
+ Si l’accès est autorisé, API Gateway invoque la méthode.
Si vous activez la mise en cache des autorisations, API Gateway met en cache la politique afin que la fonction du mécanisme d’autorisation Lambda ne soit pas invoquée à nouveau. Assurez-vous que votre politique s’applique à toutes les ressources et méthodes de votre API.
Vous pouvez personnaliser la réponse de passerelle `403 ACCESS_DENIED` ou `401 UNAUTHORIZED`. Pour en savoir plus, veuillez consulter la section [Réponses de passerelle pour REST APIs dans API Gateway](api-gateway-gatewayResponse-definition.md).
## Choix d’un type de mécanisme d’autorisation Lambda
Il existe deux types de mécanismes d’autorisation Lambda :
**Mécanisme d’autorisation Lambda basé sur les paramètres de la demande (mécanisme d’autorisation `REQUEST`)**
Un mécanisme d’autorisation `REQUEST` reçoit l’identité de l’appelant dans une combinaison d’en-têtes, de paramètres de chaîne de requête, et de variables [`stageVariables`](api-gateway-mapping-template-reference.md#stagevariables-template-reference) et [`$context`](api-gateway-mapping-template-reference.md#context-variable-reference). Vous pouvez utiliser un mécanisme d’autorisation `REQUEST` pour créer des politiques précises basées sur les informations de plusieurs sources d’identité, telles que les variables contextuelles `$context.path` et `$context.httpMethod`.
Si vous activez la mise en cache des autorisations pour un mécanisme d’autorisation `REQUEST`, API Gateway vérifie que toutes les sources d’identité spécifiées sont présentes dans la demande. Si une source d’identité spécifiée est absente, nulle ou vide, API Gateway renvoie une réponse HTTP `401 Unauthorized` sans appeler la fonction du mécanisme d’autorisation Lambda. Lorsque plusieurs sources d’identité sont définies, elles sont toutes utilisées pour obtenir la clé de cache du mécanisme d’autorisation, en respectant l’ordre établi. Vous pouvez définir une clé de cache précise en utilisant plusieurs sources d’identité.
Si vous modifiez une partie de la clé de cache et redéployez votre API, le mécanisme d’autorisation ignore le document de politique mis en cache et en génère un nouveau.
Si vous désactivez la mise en cache des autorisations pour un mécanisme d’autorisation `REQUEST`, API Gateway transmet directement la demande à la fonction Lambda.
**Mécanisme d’autorisation Lambda par jeton (mécanisme d’autorisation `TOKEN`)**
Un `TOKEN` autorisateur reçoit l'identité de l'appelant dans un jeton porteur, tel qu'un jeton Web JSON (JWT) ou un jeton. OAuth
Si vous activez la mise en cache des autorisations pour un mécanisme d’autorisation `TOKEN`, le nom de l’en-tête spécifié dans la source du jeton devient la clé de cache.
En outre, vous pouvez utiliser la validation par jeton pour saisir une RegEx déclaration. API Gateway effectue la validation initiale du jeton d’entrée en fonction de cette expression et invoque la fonction du mécanisme d’autorisation Lambda quand la validation aboutit. Cela contribue à réduire le nombre d'appels à votre API.
La propriété `IdentityValidationExpression` est prise en charge pour les mécanismes d’autorisation `TOKEN` uniquement. Pour de plus amples informations, veuillez consulter [x-amazon-apigateway-authorizer objet](api-gateway-swagger-extensions-authorizer.md).
**Note**
Nous vous recommandons d’utiliser un mécanisme d’autorisation `REQUEST` pour contrôler l’accès à votre API. Vous pouvez contrôler l’accès à votre API sur la base de plusieurs sources d’identité lorsque vous utilisez un mécanisme d’autorisation `REQUEST`, alors qu’une seule source d’identité suffit lorsque vous utilisez un mécanisme d’autorisation `TOKEN`. En outre, vous pouvez séparer les clés de cache en utilisant plusieurs sources d’identité pour un mécanisme d’autorisation `REQUEST`.
## Exemple de fonction de mécanisme d’autorisation Lambda `REQUEST`
L’exemple de code suivant crée une fonction de mécanisme d’autorisation Lambda qui autorise une demande si l’en-tête `HeaderAuth1` fourni par le client, le paramètre de requête `QueryString1` et la variable d’étape `StageVar1` correspondent aux valeurs `headerValue1`, `queryValue1` et `stageValue1` spécifiées, respectivement.
------
#### [ Node.js ]
```
// A simple request-based authorizer example to demonstrate how to use request
// parameters to allow or deny a request. In this example, a request is
// authorized if the client-supplied HeaderAuth1 header, QueryString1
// query parameter, and stage variable of StageVar1 all match
// specified values of 'headerValue1', 'queryValue1', and 'stageValue1',
// respectively.
export const handler = function(event, context, callback) {
console.log('Received event:', JSON.stringify(event, null, 2));
// Retrieve request parameters from the Lambda function input:
var headers = event.headers;
var queryStringParameters = event.queryStringParameters;
var pathParameters = event.pathParameters;
var stageVariables = event.stageVariables;
// Parse the input for the parameter values
var tmp = event.methodArn.split(':');
var apiGatewayArnTmp = tmp[5].split('/');
var awsAccountId = tmp[4];
var region = tmp[3];
var restApiId = apiGatewayArnTmp[0];
var stage = apiGatewayArnTmp[1];
var method = apiGatewayArnTmp[2];
var resource = '/'; // root resource
if (apiGatewayArnTmp[3]) {
resource += apiGatewayArnTmp[3];
}
// Perform authorization to return the Allow policy for correct parameters and
// the 'Unauthorized' error, otherwise.
if (headers.HeaderAuth1 === "headerValue1"
&& queryStringParameters.QueryString1 === "queryValue1"
&& stageVariables.StageVar1 === "stageValue1") {
callback(null, generateAllow('me', event.methodArn));
} else {
callback(null, generateDeny('me', event.methodArn));
}
}
// Help function to generate an IAM policy
var generatePolicy = function(principalId, effect, resource) {
// Required output:
var authResponse = {};
authResponse.principalId = principalId;
if (effect && resource) {
var policyDocument = {};
policyDocument.Version = '2012-10-17'; // default version
policyDocument.Statement = [];
var statementOne = {};
statementOne.Action = 'execute-api:Invoke'; // default action
statementOne.Effect = effect;
statementOne.Resource = resource;
policyDocument.Statement[0] = statementOne;
authResponse.policyDocument = policyDocument;
}
// Optional output with custom properties of the String, Number or Boolean type.
authResponse.context = {
"stringKey": "stringval",
"numberKey": 123,
"booleanKey": true
};
return authResponse;
}
var generateAllow = function(principalId, resource) {
return generatePolicy(principalId, 'Allow', resource);
}
var generateDeny = function(principalId, resource) {
return generatePolicy(principalId, 'Deny', resource);
}
```
------
#### [ Python ]
```
# A simple request-based authorizer example to demonstrate how to use request
# parameters to allow or deny a request. In this example, a request is
# authorized if the client-supplied headerauth1 header, QueryString1
# query parameter, and stage variable of StageVar1 all match
# specified values of 'headerValue1', 'queryValue1', and 'stageValue1',
# respectively.
def lambda_handler(event, context):
print(event)
# Retrieve request parameters from the Lambda function input:
headers = event['headers']
queryStringParameters = event['queryStringParameters']
pathParameters = event['pathParameters']
stageVariables = event['stageVariables']
# Parse the input for the parameter values
tmp = event['methodArn'].split(':')
apiGatewayArnTmp = tmp[5].split('/')
awsAccountId = tmp[4]
region = tmp[3]
restApiId = apiGatewayArnTmp[0]
stage = apiGatewayArnTmp[1]
method = apiGatewayArnTmp[2]
resource = '/'
if (apiGatewayArnTmp[3]):
resource += apiGatewayArnTmp[3]
# Perform authorization to return the Allow policy for correct parameters
# and the 'Unauthorized' error, otherwise.
if (headers['HeaderAuth1'] == "headerValue1" and queryStringParameters['QueryString1'] == "queryValue1" and stageVariables['StageVar1'] == "stageValue1"):
response = generateAllow('me', event['methodArn'])
print('authorized')
return response
else:
print('unauthorized')
response = generateDeny('me', event['methodArn'])
return response
# Help function to generate IAM policy
def generatePolicy(principalId, effect, resource):
authResponse = {}
authResponse['principalId'] = principalId
if (effect and resource):
policyDocument = {}
policyDocument['Version'] = '2012-10-17'
policyDocument['Statement'] = []
statementOne = {}
statementOne['Action'] = 'execute-api:Invoke'
statementOne['Effect'] = effect
statementOne['Resource'] = resource
policyDocument['Statement'] = [statementOne]
authResponse['policyDocument'] = policyDocument
authResponse['context'] = {
"stringKey": "stringval",
"numberKey": 123,
"booleanKey": True
}
return authResponse
def generateAllow(principalId, resource):
return generatePolicy(principalId, 'Allow', resource)
def generateDeny(principalId, resource):
return generatePolicy(principalId, 'Deny', resource)
```
------
Dans cet exemple, la fonction du mécanisme d’autorisation Lambda vérifie les paramètres d’entrée et agit comme suit :
+ Si toutes les valeurs de paramètre obligatoires correspondent aux valeurs attendues, la fonction du mécanisme d’autorisation renvoie une réponse HTTP `200 OK` et une politique IAM qui ressemble à ce qui suit, et la demande de la méthode aboutit :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "execute-api:Invoke",
"Effect": "Allow",
"Resource": "arn:aws:execute-api:us-east-1:123456789012:ivdtdhp7b5/ESTestInvoke-stage/GET/"
}
]
}
```
------
+ Sinon, la fonction du mécanisme d’autorisation renvoie une réponse HTTP `401 Unauthorized` et la demande de méthode échoue.
En plus de renvoyer une stratégie IAM, la fonction du mécanisme d'autorisation Lambda doit également renvoyer l'identifiant principal de l'appelant. Elle peut éventuellement renvoyer un objet `context` qui inclut des informations supplémentaires transmissibles au backend d’intégration. Pour de plus amples informations, veuillez consulter [Sortie d’un mécanisme d’autorisation Lambda API Gateway](api-gateway-lambda-authorizer-output.md).
Dans le code de production, vous devrez peut-être authentifier l’utilisateur avant d’accorder l’autorisation. Vous pouvez ajouter une logique d’authentification dans la fonction Lambda en appelant un fournisseur d’authentification, comme indiqué dans la documentation de ce fournisseur.
## Exemple de fonction de mécanisme d’autorisation Lambda `TOKEN`
L’exemple de code suivant crée une fonction de mécanisme d’autorisation Lambda`TOKEN` qui permet à un appelant d’invoquer une méthode si la valeur du jeton fournie par le client est `allow`. L’appelant n’est pas autorisé à invoquer la demande si la valeur du jeton est `deny`. Si la valeur du jeton est `unauthorized` ou une chaîne vide, la fonction du mécanisme d’autorisation renvoie une réponse `401 UNAUTHORIZED`.
------
#### [ Node.js ]
```
// A simple token-based authorizer example to demonstrate how to use an authorization token
// to allow or deny a request. In this example, the caller named 'user' is allowed to invoke
// a request if the client-supplied token value is 'allow'. The caller is not allowed to invoke
// the request if the token value is 'deny'. If the token value is 'unauthorized' or an empty
// string, the authorizer function returns an HTTP 401 status code. For any other token value,
// the authorizer returns an HTTP 500 status code.
// Note that token values are case-sensitive.
export const handler = function(event, context, callback) {
var token = event.authorizationToken;
switch (token) {
case 'allow':
callback(null, generatePolicy('user', 'Allow', event.methodArn));
break;
case 'deny':
callback(null, generatePolicy('user', 'Deny', event.methodArn));
break;
case 'unauthorized':
callback("Unauthorized"); // Return a 401 Unauthorized response
break;
default:
callback("Error: Invalid token"); // Return a 500 Invalid token response
}
};
// Help function to generate an IAM policy
var generatePolicy = function(principalId, effect, resource) {
var authResponse = {};
authResponse.principalId = principalId;
if (effect && resource) {
var policyDocument = {};
policyDocument.Version = '2012-10-17';
policyDocument.Statement = [];
var statementOne = {};
statementOne.Action = 'execute-api:Invoke';
statementOne.Effect = effect;
statementOne.Resource = resource;
policyDocument.Statement[0] = statementOne;
authResponse.policyDocument = policyDocument;
}
// Optional output with custom properties of the String, Number or Boolean type.
authResponse.context = {
"stringKey": "stringval",
"numberKey": 123,
"booleanKey": true
};
return authResponse;
}
```
------
#### [ Python ]
```
# A simple token-based authorizer example to demonstrate how to use an authorization token
# to allow or deny a request. In this example, the caller named 'user' is allowed to invoke
# a request if the client-supplied token value is 'allow'. The caller is not allowed to invoke
# the request if the token value is 'deny'. If the token value is 'unauthorized' or an empty
# string, the authorizer function returns an HTTP 401 status code. For any other token value,
# the authorizer returns an HTTP 500 status code.
# Note that token values are case-sensitive.
import json
def lambda_handler(event, context):
token = event['authorizationToken']
if token == 'allow':
print('authorized')
response = generatePolicy('user', 'Allow', event['methodArn'])
elif token == 'deny':
print('unauthorized')
response = generatePolicy('user', 'Deny', event['methodArn'])
elif token == 'unauthorized':
print('unauthorized')
raise Exception('Unauthorized') # Return a 401 Unauthorized response
return 'unauthorized'
try:
return json.loads(response)
except BaseException:
print('unauthorized')
return 'unauthorized' # Return a 500 error
def generatePolicy(principalId, effect, resource):
authResponse = {}
authResponse['principalId'] = principalId
if (effect and resource):
policyDocument = {}
policyDocument['Version'] = '2012-10-17'
policyDocument['Statement'] = []
statementOne = {}
statementOne['Action'] = 'execute-api:Invoke'
statementOne['Effect'] = effect
statementOne['Resource'] = resource
policyDocument['Statement'] = [statementOne]
authResponse['policyDocument'] = policyDocument
authResponse['context'] = {
"stringKey": "stringval",
"numberKey": 123,
"booleanKey": True
}
authResponse_JSON = json.dumps(authResponse)
return authResponse_JSON
```
------
Dans cet exemple, lorsque l’API reçoit une demande de méthode, API Gateway transmet le jeton source à cette fonction du mécanisme d’autorisation Lambda dans l’attribut `event.authorizationToken`. La fonction du mécanisme d’autorisation Lambda lit le jeton et agit comme suit :
+ Si la valeur du jeton est `allow`, la fonction du mécanisme d’autorisation renvoie une réponse HTTP `200 OK` et une politique IAM qui ressemble à ce qui suit, et la demande de méthode aboutit :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "execute-api:Invoke",
"Effect": "Allow",
"Resource": "arn:aws:execute-api:us-east-1:123456789012:ivdtdhp7b5/ESTestInvoke-stage/GET/"
}
]
}
```
------
+ Si la valeur du jeton est `deny`, la fonction du mécanisme d’autorisation renvoie une réponse HTTP `200 OK` et une politique IAM `Deny` qui ressemble à ce qui suit, et la demande de méthode échoue :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "execute-api:Invoke",
"Effect": "Deny",
"Resource": "arn:aws:execute-api:us-east-1:123456789012:ivdtdhp7b5/ESTestInvoke-stage/GET/"
}
]
}
```
------
**Note**
En dehors de l’environnement de test, API Gateway renvoie une réponse HTTP `403 Forbidden` et la demande de méthode échoue.
+ Si la valeur du jeton est `unauthorized` ou une chaîne vide, la fonction du mécanisme d’autorisation renvoie une réponse HTTP `401 Unauthorized` et l’appel de la méthode échoue.
+ Si le jeton a n’importe quelle autre valeur, le client reçoit une réponse `500 Invalid token` et l’appel de la méthode échoue.
En plus de renvoyer une stratégie IAM, la fonction du mécanisme d'autorisation Lambda doit également renvoyer l'identifiant principal de l'appelant. Elle peut éventuellement renvoyer un objet `context` qui inclut des informations supplémentaires transmissibles au backend d’intégration. Pour de plus amples informations, veuillez consulter [Sortie d’un mécanisme d’autorisation Lambda API Gateway](api-gateway-lambda-authorizer-output.md).
Dans le code de production, vous devrez peut-être authentifier l’utilisateur avant d’accorder l’autorisation. Vous pouvez ajouter une logique d’authentification dans la fonction Lambda en appelant un fournisseur d’authentification, comme indiqué dans la documentation de ce fournisseur.
## Exemples supplémentaires de fonctions de mécanisme d’autorisation Lambda
La liste suivante présente d’autres exemples de fonctions de mécanisme d’autorisation Lambda. Vous pouvez créer une fonction Lambda dans le même compte, ou dans un autre compte, que celui dans lequel vous avez créé votre API.
Dans l'exemple précédent, vous pouvez utiliser les fonctions Lambda intégrées [AWSLambdaBasicExecutionRole](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html), car ces fonctions n'appellent aucun autre AWS service. Si votre fonction Lambda appelle d'autres AWS services, vous devez attribuer un rôle d'exécution IAM à la fonction Lambda. Pour créer le rôle, suivez les instructions dans [Rôle d’exécution AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html).
**Exemples supplémentaires de fonctions de mécanisme d’autorisation Lambda**
+ Pour un exemple d'application, voir [Open Banking Brésil - Exemples GitHub d'autorisation](https://github.com/aws-samples/openbanking-brazilian-auth-samples) sur.
+ Pour plus d'exemples de fonctions Lambda, voir [ aws-apigateway-lambda-authorizer-blueprints](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints) on. GitHub
+ Vous pouvez créer un mécanisme d’autorisation Lambda qui authentifie les utilisateurs à l’aide de groupes d’utilisateurs Amazon Cognito, et autorise les appelants sur la base d’un entrepôt de politiques à l’aide de Verified Permissions. Pour de plus amples informations, veuillez consulter [Contrôle de l’accès sur la base des attributs d’une identité avec Verified Permissions](apigateway-lambda-authorizer-verified-permissions.md).
+ La console Lambda fournit un plan Python, que vous pouvez utiliser en choisissant **Utiliser un plan puis en choisissant le plan**. **api-gateway-authorizer-python**