Contrôlez l'accès à l'HTTPAPIsaide des AWS Lambda autorisateurs - APIPasserelle Amazon
Version du format de charge utileFormat de réponse du mécanisme d'autorisation LambdaExemple de fonctions d'autorisation LambdaSources d'identitéMise en cache des réponses du mécanisme d'autorisationCréation d'un mécanisme d'autorisation LambdaDépannage des autorisations Lambda

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.

Contrôlez l'accès à l'HTTPAPIsaide des AWS Lambda autorisateurs

Vous utilisez un autorisateur Lambda pour utiliser une fonction Lambda afin de contrôler l'accès à votre. HTTP API Ensuite, lorsqu'un client vous appelleAPI, API Gateway invoque votre fonction Lambda. APIGateway utilise la réponse de votre fonction Lambda pour déterminer si le client peut accéder à votre. API

Version du format de charge utile

La version du format de charge utile de l'autorisateur spécifie le format des données que API Gateway envoie à un autorisateur Lambda et la manière dont API Gateway interprète la réponse de Lambda. Si vous ne spécifiez pas de version de format de charge utile, la dernière version est AWS Management Console utilisée par défaut. Si vous créez un autorisateur Lambda en utilisant le AWS CLI, ou un AWS CloudFormation SDK, vous devez spécifier un. authorizerPayloadFormatVersion Les valeurs prises en charge sont 1.0 et 2.0.

Si vous avez besoin d'une compatibilité avec RESTAPIs, utilisez la version1.0.

Les exemples suivants montrent la structure de chaque version de format de charge utile.

2.0
{
  "version": "2.0",
  "type": "REQUEST",
  "routeArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request",
  "identitySource": ["user1", "123"],
  "routeKey": "$default",
  "rawPath": "/my/path",
  "rawQueryString": "parameter1=value1&parameter1=value2&parameter2=value",
  "cookies": ["cookie1", "cookie2"],
  "headers": {
    "header1": "value1",
    "header2": "value2"
  },
  "queryStringParameters": {
    "parameter1": "value1,value2",
    "parameter2": "value"
  },
  "requestContext": {
    "accountId": "123456789012",
    "apiId": "api-id",
    "authentication": {
      "clientCert": {
        "clientCertPem": "CERT_CONTENT",
        "subjectDN": "www.example.com",
        "issuerDN": "Example issuer",
        "serialNumber": "1",
        "validity": {
          "notBefore": "May 28 12:30:02 2019 GMT",
          "notAfter": "Aug  5 09:36:04 2021 GMT"
        }
      }
    },
    "domainName": "id.execute-api.us-east-1.amazonaws.com",
    "domainPrefix": "id",
    "http": {
      "method": "POST",
      "path": "/my/path",
      "protocol": "HTTP/1.1",
      "sourceIp": "IP",
      "userAgent": "agent"
    },
    "requestId": "id",
    "routeKey": "$default",
    "stage": "$default",
    "time": "12/Mar/2020:19:03:58 +0000",
    "timeEpoch": 1583348638390
  },
  "pathParameters": { "parameter1": "value1" },
  "stageVariables": { "stageVariable1": "value1", "stageVariable2": "value2" }
}
1.0
{
  "version": "1.0",
  "type": "REQUEST",
  "methodArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request",
  "identitySource": "user1,123",
  "authorizationToken": "user1,123",
  "resource": "/request",
  "path": "/request",
  "httpMethod": "GET",
  "headers": {
    "X-AMZ-Date": "20170718T062915Z",
    "Accept": "*/*",
    "HeaderAuth1": "headerValue1",
    "CloudFront-Viewer-Country": "US",
    "CloudFront-Forwarded-Proto": "https",
    "CloudFront-Is-Tablet-Viewer": "false",
    "CloudFront-Is-Mobile-Viewer": "false",
    "User-Agent": "..."
  },
  "queryStringParameters": {
    "QueryString1": "queryValue1"
  },
  "pathParameters": {},
  "stageVariables": {
    "StageVar1": "stageValue1"
  },
  "requestContext": {
    "path": "/request",
    "accountId": "123456789012",
    "resourceId": "05c7jb",
    "stage": "test",
    "requestId": "...",
    "identity": {
      "apiKey": "...",
      "sourceIp": "...",
      "clientCert": {
        "clientCertPem": "CERT_CONTENT",
        "subjectDN": "www.example.com",
        "issuerDN": "Example issuer",
        "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
        "validity": {
          "notBefore": "May 28 12:30:02 2019 GMT",
          "notAfter": "Aug  5 09:36:04 2021 GMT"
        }
      }
    },
    "resourcePath": "/request",
    "httpMethod": "GET",
    "apiId": "abcdef123"
  }
}

Format de réponse du mécanisme d'autorisation Lambda

La version du format de charge utile détermine également la structure de la réponse que vous devez renvoyer à partir de votre fonction Lambda.

Réponse de la fonction Lambda pour le format 1.0

Si vous choisissez la version du 1.0 format, les autorisateurs Lambda doivent renvoyer une IAM politique qui autorise ou refuse l'accès à votre itinéraire. API Vous pouvez utiliser la syntaxe IAM de stratégie standard dans la stratégie. Pour obtenir des exemples de stratégies IAM, consultez Contrôler l'accès pour invoquer un API. Vous pouvez transmettre des propriétés de contexte aux intégrations Lambda ou accéder aux journaux avec $context.authorizer.property. L'objet context est facultatif et claims est un espace réservé qui ne peut être utilisé comme objet contextuel. Pour en savoir plus, consultez la section Personnaliser les journaux HTTP API d'accès.

{
  "principalId": "abcdef", // The principal user identification associated with the token sent by the client.
  "policyDocument": {
    "Version": "2012-10-17",
    "Statement": [
      {
        "Action": "execute-api:Invoke",
        "Effect": "Allow|Deny",
        "Resource": "arn:aws:execute-api:{regionId}:{accountId}:{apiId}/{stage}/{httpVerb}/[{resource}/[{child-resources}]]"
      }
    ]
  },
  "context": {
    "exampleKey": "exampleValue"
  }
}

Réponse de la fonction Lambda pour le format 2.0

Si vous choisissez la version du 2.0 format, vous pouvez renvoyer une valeur booléenne ou une IAM politique qui utilise la syntaxe de stratégie standard IAM de votre fonction Lambda. Pour renvoyer une valeur booléenne, activez des réponses simples pour le mécanisme d'autorisation. Les exemples suivants montrent le format que vous devez coder pour retourner votre fonction Lambda. L'objet context est facultatif. Vous pouvez transmettre des propriétés de contexte aux intégrations Lambda ou accéder aux journaux avec $context.authorizer.property. Pour en savoir plus, consultez la section Personnaliser les journaux HTTP API d'accès.

Simple response
{
  "isAuthorized": true/false,
  "context": {
    "exampleKey": "exampleValue"
  }
}
IAM policy
{
  "principalId": "abcdef", // The principal user identification associated with the token sent by the client.
  "policyDocument": {
    "Version": "2012-10-17",
    "Statement": [
      {
        "Action": "execute-api:Invoke",
        "Effect": "Allow|Deny",
        "Resource": "arn:aws:execute-api:{regionId}:{accountId}:{apiId}/{stage}/{httpVerb}/[{resource}/[{child-resources}]]"
      }
    ]
  },
  "context": {
    "exampleKey": "exampleValue"
  }
}

Exemple de fonctions d'autorisation Lambda

Les exemples de fonction Lambda Node.js suivants illustrent les formats de réponse requis que vous devez renvoyer à partir de votre fonction Lambda pour la version du format de charge utile 2.0.

Simple response - Node.js
export const handler = async(event) => {
    let response = {
        "isAuthorized": false,
        "context": {
            "stringKey": "value",
            "numberKey": 1,
            "booleanKey": true,
            "arrayKey": ["value1", "value2"],
            "mapKey": {"value1": "value2"}
        }
    };
    
    if (event.headers.authorization === "secretToken") {
        console.log("allowed");
        response = {
            "isAuthorized": true,
            "context": {
                "stringKey": "value",
                "numberKey": 1,
                "booleanKey": true,
                "arrayKey": ["value1", "value2"],
                "mapKey": {"value1": "value2"}
            }
        };
    }

    return response;

};
Simple response - Python
import json


def lambda_handler(event, context):
    response = {
        "isAuthorized": False,
        "context": {
            "stringKey": "value",
            "numberKey": 1,
            "booleanKey": True,
            "arrayKey": ["value1", "value2"],
            "mapKey": {"value1": "value2"}
        }
    }

    try:
        if (event["headers"]["authorization"] == "secretToken"):
            response = {
                "isAuthorized": True,
                "context": {
                    "stringKey": "value",
                    "numberKey": 1,
                    "booleanKey": True,
                    "arrayKey": ["value1", "value2"],
                    "mapKey": {"value1": "value2"}
                }
            }
            print('allowed')
            return response
        else:
            print('denied')
            return response
    except BaseException:
        print('denied')
        return response
IAM policy - Node.js
export const handler = async(event) => {
  if (event.headers.authorization == "secretToken") {
    console.log("allowed");
    return {
      "principalId": "abcdef", // The principal user identification associated with the token sent by the client.
      "policyDocument": {
        "Version": "2012-10-17",
        "Statement": [{
          "Action": "execute-api:Invoke",
          "Effect": "Allow",
          "Resource": event.routeArn
        }]
      },
      "context": {
        "stringKey": "value",
        "numberKey": 1,
        "booleanKey": true,
        "arrayKey": ["value1", "value2"],
        "mapKey": { "value1": "value2" }
      }
    };
  }
  else {
    console.log("denied");
    return {
      "principalId": "abcdef", // The principal user identification associated with the token sent by the client.
      "policyDocument": {
        "Version": "2012-10-17",
        "Statement": [{
          "Action": "execute-api:Invoke",
          "Effect": "Deny",
          "Resource": event.routeArn
        }]
      },
      "context": {
        "stringKey": "value",
        "numberKey": 1,
        "booleanKey": true,
        "arrayKey": ["value1", "value2"],
        "mapKey": { "value1": "value2" }
      }
    };
  }
};
IAM policy - Python
import json


def lambda_handler(event, context):
    response = {
        # The principal user identification associated with the token sent by
        # the client.
        "principalId": "abcdef",
        "policyDocument": {
            "Version": "2012-10-17",
            "Statement": [{
                "Action": "execute-api:Invoke",
                "Effect": "Deny",
                "Resource": event["routeArn"]
            }]
        },
        "context": {
            "stringKey": "value",
            "numberKey": 1,
            "booleanKey": True,
            "arrayKey": ["value1", "value2"],
            "mapKey": {"value1": "value2"}
        }
    }

    try:
        if (event["headers"]["authorization"] == "secretToken"):
            response = {
                # The principal user identification associated with the token
                # sent by the client.
                "principalId": "abcdef",
                "policyDocument": {
                    "Version": "2012-10-17",
                    "Statement": [{
                        "Action": "execute-api:Invoke",
                        "Effect": "Allow",
                        "Resource": event["routeArn"]
                    }]
                },
                "context": {
                    "stringKey": "value",
                    "numberKey": 1,
                    "booleanKey": True,
                    "arrayKey": ["value1", "value2"],
                    "mapKey": {"value1": "value2"}
                }
            }
            print('allowed')
            return response
        else:
            print('denied')
            return response
    except BaseException:
        print('denied')
        return response

Sources d'identité

Si vous le souhaitez, vous pouvez spécifier des sources d'identité pour un mécanisme d'autorisation Lambda. Les sources d'identité spécifient l'emplacement des données requises pour autoriser une demande. Par exemple, vous pouvez spécifier des valeurs d'en-tête ou de chaîne de requête en tant que sources d'identité. Si vous spécifiez des sources d'identité, les clients doivent les inclure dans la demande. Si la demande du client n'inclut pas les sources d'identité, API Gateway n'invoque pas votre autorisateur Lambda et le client reçoit un message d'erreur. 401

Le tableau suivant décrit les sources d'identité prises en charge pour un autorisateur Lambda.

Type

Exemple

Remarques
Valeur d'en-tête $request.header.name Les noms d'en-tête ne sont pas sensibles à la casse.
Valeur de chaîne de requête $request.querystring.name Les noms de chaîne de requête sont sensibles à la casse.
Variable de contexte $contexte.variableName Valeur d'une variable de contexte prise en charge.
Variable d'étape $stageVariables.variableName Valeur d'une variable d'étape.

Mise en cache des réponses du mécanisme d'autorisation

Vous pouvez activer la mise en cache pour un autorisateur Lambda en spécifiant un. authorizerResultTtlInSeconds Lorsque la mise en cache est activée pour un autorisateur, API Gateway utilise les sources d'identité de l'autorisateur comme clé de cache. Si un client spécifie les mêmes paramètres dans les sources d'identité configuréesTTL, API Gateway utilise le résultat de l'autorisateur mis en cache au lieu d'appeler votre fonction Lambda.

Pour activer la mise en cache, votre mécanisme d'autorisation doit avoir au moins une source d'identité.

Si vous activez les réponses simples pour un autorisateur, la réponse de l'autorisateur autorise ou refuse complètement toutes les API demandes correspondant aux valeurs de source d'identité mises en cache. Pour des autorisations plus détaillées, désactivez les réponses simples et renvoyez une IAM politique.

Par défaut, API Gateway utilise la réponse d'autorisation mise en cache pour toutes les routes d'un utilisateur utilisant API l'autorisateur. Pour mettre en cache les réponses par route, ajoutez $context.routeKey aux sources d'identité de votre mécanisme d'autorisation.

Création d'un mécanisme d'autorisation Lambda

Lorsque vous créez un autorisateur Lambda, vous spécifiez la fonction Lambda que Gateway doit utiliser. API Vous devez autoriser API Gateway à invoquer la fonction Lambda en utilisant soit la politique de ressources de la fonction, soit un IAM rôle. Dans cet exemple, nous mettons à jour la politique de ressources de la fonction afin qu'elle autorise API Gateway à invoquer notre fonction Lambda.

aws apigatewayv2 create-authorizer \
    --api-id abcdef123 \
    --authorizer-type REQUEST \
    --identity-source '$request.header.Authorization' \
    --name lambda-authorizer \ 
    --authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:my-function/invocations' \
    --authorizer-payload-format-version '2.0' \
    --enable-simple-responses

La commande suivante autorise API Gateway à appeler votre fonction Lambda. Si API Gateway n'est pas autorisé à appeler votre fonction, les clients reçoivent un500 Internal Server Error.

aws lambda add-permission \
    --function-name my-authorizer-function \
    --statement-id apigateway-invoke-permissions-abc123 \ 
    --action lambda:InvokeFunction \
    --principal apigateway.amazonaws.com \
    --source-arn "arn:aws:execute-api:us-west-2:123456789012:api-id/authorizers/authorizer-id"

Après avoir créé un autorisateur et accordé à API Gateway l'autorisation de l'invoquer, mettez à jour votre itinéraire pour utiliser l'autorisateur.

aws apigatewayv2 update-route \
    --api-id abcdef123 \
    --route-id acd123 \
    --authorization-type CUSTOM \
    --authorizer-id def123

Dépannage des autorisations Lambda

Si API Gateway ne peut pas appeler votre autorisateur Lambda, ou si votre autorisateur Lambda renvoie une réponse dans un format non valide, les clients reçoivent un. 500 Internal Server Error

Pour résoudre les erreurs, activez la journalisation des accès pour votre API scène. Incluez la variable de journalisation $context.authorizer.error dans votre format de journal.

Si les journaux indiquent que API Gateway n'est pas autorisé à appeler votre fonction, mettez à jour la politique de ressources de votre fonction ou fournissez un IAM rôle pour autoriser API Gateway à invoquer votre autorisateur.

Si les journaux indiquent que votre fonction Lambda renvoie une réponse non valide, vérifiez qu'elle renvoie une réponse dans le format requis.