API Gateway-Lambda-Genehmiger verwenden - Amazon API Gateway

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

API Gateway-Lambda-Genehmiger verwenden

Verwenden Sie einen Lambda-Autorisierer (früher bekannt als benutzerdefinierter Autorisierer), um den Zugriff auf Ihre API zu kontrollieren. Wenn ein Client die Methode Ihrer API anfordert, ruft API Gateway Ihren Lambda-Authorizer auf. Der Lambda-Autorisierer verwendet die Identität des Aufrufers als Eingabe und gibt eine IAM-Richtlinie als Ausgabe zurück.

Verwenden Sie einen Lambda-Autorisierer, um ein benutzerdefiniertes Autorisierungsschema zu implementieren. Ihr Schema kann Anforderungsparameter verwenden, um die Identität des Aufrufers zu ermitteln, oder eine Bearer-Token-Authentifizierungsstrategie wie OAuth oder SAML verwenden. Erstellen Sie einen Lambda-Authorizer in der API Gateway REST API-Konsole, indem Sie das oder ein AWS CLI AWS SDK verwenden.

Autorisierungsworkflow für Lambda-Autorisierer

Das folgende Diagramm zeigt den Autorisierungsworkflow für einen Lambda-Autorisierer.

API Gateway-Lambda-Autorisierungs-Workflow
API Gateway-Lambda-Autorisierungs-Workflow
  1. Der Client ruft eine Methode auf einer API Gateway auf und übergibt dabei ein Bearer-Token oder Anforderungsparameter.

  2. API Gateway prüft, ob die Methodenanforderung mit einem Lambda-Authorizer konfiguriert ist. Ist dies der Fall, ruft API Gateway die Lambda-Funktion auf.

  3. Die Lambda-Funktion authentifiziert den Anrufer. Die Funktion kann sich auf folgende Weise authentifizieren:

    • Indem Sie einen OAuth-Anbieter anrufen, um ein OAuth-Zugriffstoken zu erhalten.

    • Indem Sie einen SAML-Anbieter anrufen, um eine SAML-Assertion zu erhalten.

    • Durch Generieren einer IAM-Richtlinie auf der Grundlage der Werte der Anforderungsparameter.

    • Durch das Abrufen von Anmeldeinformationen aus einer Datenbank.

  4. Die Lambda-Funktion gibt eine IAM-Richtlinie und eine Prinzipal-ID zurück. Wenn die Lambda-Funktion diese Informationen nicht zurückgibt, schlägt der Aufruf fehl.

  5. API Gateway bewertet die IAM-Richtlinie.

    • Wenn der Zugriff verweigert wird, gibt API Gateway einen geeigneten HTTP-Statuscode zurück, wie z. B. 403 ACCESS_DENIED.

    • Wenn der Zugriff erlaubt ist, ruft API Gateway die Methode auf.

      Wenn Sie das Autorisierungs-Caching aktivieren, speichert API Gateway die Richtlinie im Cache, sodass die Lambda-Autorisierungsfunktion nicht erneut aufgerufen wird.

Sie können die oder die Gateway-Antworten anpassen. 403 ACCESS_DENIED 401 UNAUTHORIZED Weitere Informationen hierzu finden Sie unter Gateway-Antworten für REST-APIs in API Gateway.

Auswahl eines Lambda-Autorisierungstyps

Es gibt zwei Arten von Lambda-Genehmigern:

Parameterbasierten Lambda-Authorizer (Authorizer) anfordern REQUEST

Ein REQUEST Autorisierer empfängt die Identität des Aufrufers in einer Kombination aus Headern, Abfragezeichenfolgenparametern und Variablen. stageVariables$context Sie können einen REQUEST Autorisierer verwenden, um detaillierte Richtlinien zu erstellen, die auf den Informationen aus mehreren Identitätsquellen basieren, z. B. den Variablen und den Kontextvariablen. $context.path $context.httpMethod

Wenn Sie das Autorisierungs-Caching für einen REQUEST Autorisierer aktivieren, überprüft API Gateway, ob alle angegebenen Identitätsquellen in der Anfrage vorhanden sind. Wenn eine angegebene Identitätsquelle fehlt, null oder leer ist, gibt API Gateway eine 401 Unauthorized HTTP-Antwort zurück, ohne die Lambda-Autorisierungsfunktion aufzurufen. Wenn mehrere Identitätsquellen definiert sind, werden sie alle verwendet, um den Cache-Schlüssel des Autorisierers abzuleiten, wobei die Reihenfolge beibehalten wird. Sie können einen detaillierten Cache-Schlüssel definieren, indem Sie mehrere Identitätsquellen verwenden.

Wenn Sie einen Teil des Cache-Schlüssels ändern und Ihre API erneut bereitstellen, verwirft der Autorisierer das zwischengespeicherte Richtliniendokument und generiert ein neues.

Wenn Sie das Autorisierungs-Caching für einen REQUEST Autorisierer deaktivieren, leitet API Gateway die Anfrage direkt an die Lambda-Funktion weiter.

Tokenbasierter Lambda-Autorisierer (Autorisierer) TOKEN

Ein TOKEN Autorisierer erhält die Identität des Aufrufers in einem Trägertoken, z. B. einem JSON Web Token (JWT) oder einem OAuth-Token.

Wenn Sie das Autorisierungs-Caching für einen TOKEN Authorizer aktivieren, wird der in der Token-Quelle angegebene Header-Name zum Cache-Schlüssel.

Darüber hinaus können Sie die Token-Validierung verwenden, um eine RegEx Anweisung einzugeben. API Gateway führt eine erste Validierung des Eingabe-Tokens anhand dieses Ausdrucks durch und ruft bei erfolgreicher Validierung die Lambda-Autorisierungsfunktion auf. Dies trägt dazu bei, die Anzahl der Aufrufe Ihrer API zu reduzieren.

Die IdentityValidationExpression Eigenschaft wird nur für TOKEN Autorisierer unterstützt. Weitere Informationen finden Sie unter x-amazon-apigateway-authorizer Objekt.

Anmerkung

Wir empfehlen, dass Sie einen REQUEST Autorisierer verwenden, um den Zugriff auf Ihre API zu kontrollieren. Sie können den Zugriff auf Ihre API auf der Grundlage mehrerer Identitätsquellen steuern, wenn Sie einen REQUEST Autorisierer verwenden, im Vergleich zu einer einzigen Identitätsquelle, wenn Sie einen TOKEN Autorisierer verwenden. Darüber hinaus können Sie Cache-Schlüssel mithilfe mehrerer Identitätsquellen für einen REQUEST Autorisierer trennen.

Beispiel für eine REQUEST Autorisierungs-Lambda-Funktion

Der folgende Beispielcode erstellt eine Lambda-Autorisierungsfunktion, die eine Anfrage zulässt, wenn der vom Client bereitgestellte HeaderAuth1 Header, der QueryString1 Abfrageparameter und die Stage-Variable StageVar1 alle den angegebenen Werten von headerValue1queryValue1, bzw. entsprechen. stageValue1

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. var authResponse = {}; var condition = {}; condition.IpAddress = {}; if (headers.HeaderAuth1 === "headerValue1" && queryStringParameters.QueryString1 === "queryValue1" && stageVariables.StageVar1 === "stageValue1") { callback(null, generateAllow('me', event.methodArn)); } else { callback("Unauthorized"); } } // 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. import json 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. authResponse = {} condition = {} condition['IpAddress'] = {} if (headers['HeaderAuth1'] == "headerValue1" and queryStringParameters['QueryString1'] == "queryValue1" and stageVariables['StageVar1'] == "stageValue1"): response = generateAllow('me', event['methodArn']) print('authorized') return json.loads(response) else: print('unauthorized') raise Exception('Unauthorized') # Return a 401 Unauthorized response return 'unauthorized' # 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 } authResponse_JSON = json.dumps(authResponse) return authResponse_JSON def generateAllow(principalId, resource): return generatePolicy(principalId, 'Allow', resource) def generateDeny(principalId, resource): return generatePolicy(principalId, 'Deny', resource)

In diesem Beispiel prüft die Lambda-Autorisierungsfunktion die Eingabeparameter und verhält sich wie folgt:

  • Wenn alle erforderlichen Parameterwerte mit den erwarteten Werten übereinstimmen, gibt die Genehmiger-Funktion eine 200 OK-HTTP-Antwort und eine IAM-Richtlinie zurück (wie nachfolgend gezeigt), und die Methodenanforderung wird erfolgreich ausgeführt:

    { "Version": "2012-10-17", "Statement": [ { "Action": "execute-api:Invoke", "Effect": "Allow", "Resource": "arn:aws:execute-api:us-east-1:123456789012:ivdtdhp7b5/ESTestInvoke-stage/GET/" } ] }
  • Andernfalls gibt die Autorisierungsfunktion eine 401 Unauthorized HTTP-Antwort zurück und die Methodenanforderung schlägt fehl.

Zusätzlich zur Rückgabe einer IAM-Richtlinie muss die Lambda-Funktion des Genehmigers auch die Prinzipal-ID des Aufrufers zurückgeben. Optional kann sie ein context Objekt zurückgeben, das zusätzliche Informationen enthält, die an das Integrations-Backend übergeben werden können. Weitere Informationen finden Sie unter Ausgabe von einem API Gateway Lambda Authorizer.

Im Produktionscode müssen Sie möglicherweise den Benutzer authentifizieren, bevor Sie die Autorisierung erteilen. Sie können der Lambda-Funktion Authentifizierungslogik hinzufügen, indem Sie einen Authentifizierungsanbieter aufrufen, wie in der Dokumentation für diesen Anbieter beschrieben.

Beispiel für eine TOKEN Autorisierungs-Lambda-Funktion

Der folgende Beispielcode erstellt eine TOKEN Lambda-Autorisierungsfunktion, die es einem Aufrufer ermöglicht, eine Methode aufzurufen, wenn der vom Client bereitgestellte Tokenwert lautet. allow Der Aufrufer darf die Anfrage nicht aufrufen, wenn der Tokenwert ist. deny Wenn der Tokenwert unauthorized oder eine leere Zeichenfolge ist, gibt die Autorisierungsfunktion eine Antwort zurück. 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

Wenn in diesem Beispiel die API eine Methodenanfrage empfängt, übergibt API Gateway das Quell-Token an diese Lambda-Genehmigerfunktion im Attribut event.authorizationToken. Die Lambda-Genehmigerfunktion liest das Token und verhält sich wie folgt:

  • Wenn der Token-Wert allow lautet, gibt die Genehmigerfunktion eine 200 OK-HTTP-Antwort und eine IAM-Richtlinie zurück (wie nachfolgend gezeigt), und die Methodenanforderung wird erfolgreich ausgeführt:

    { "Version": "2012-10-17", "Statement": [ { "Action": "execute-api:Invoke", "Effect": "Allow", "Resource": "arn:aws:execute-api:us-east-1:123456789012:ivdtdhp7b5/ESTestInvoke-stage/GET/" } ] }
  • Wenn der Token-Wert deny lautet, gibt die Genehmigerfunktion eine 200 OK-HTTP-Antwort und eine Deny-IAM-Richtlinie zurück (wie nachfolgend gezeigt), und die Methodenanforderung schlägt fehl:

    { "Version": "2012-10-17", "Statement": [ { "Action": "execute-api:Invoke", "Effect": "Deny", "Resource": "arn:aws:execute-api:us-east-1:123456789012:ivdtdhp7b5/ESTestInvoke-stage/GET/" } ] }
    Anmerkung

    Außerhalb der Testumgebung gibt API Gateway eine 403 Forbidden HTTP-Antwort zurück und die Methodenanforderung schlägt fehl.

  • Wenn der Token-Wert unauthorized lautet oder eine leere Zeichenfolge ist, gibt die Genehmigerfunktion eine 401 Unauthorized-HTTP-Antwort zurück, und der Methodenaufruf schlägt fehl.

  • Wenn das Token anders lautet, erhält der Client eine 500 Invalid token-Antwort, und der Methodenaufruf schlägt fehl.

Zusätzlich zur Rückgabe einer IAM-Richtlinie muss die Lambda-Funktion des Genehmigers auch die Prinzipal-ID des Aufrufers zurückgeben. Optional kann es ein context Objekt zurückgeben, das zusätzliche Informationen enthält, die an das Integrations-Backend übergeben werden können. Weitere Informationen finden Sie unter Ausgabe von einem API Gateway Lambda Authorizer.

Im Produktionscode müssen Sie möglicherweise den Benutzer authentifizieren, bevor Sie die Autorisierung erteilen. Sie können der Lambda-Funktion Authentifizierungslogik hinzufügen, indem Sie einen Authentifizierungsanbieter aufrufen, wie in der Dokumentation für diesen Anbieter beschrieben.

Zusätzliche Beispiele für Lambda-Autorisierungsfunktionen

Die folgende Liste enthält weitere Beispiele für Lambda-Autorisierungsfunktionen. Sie können eine Lambda-Funktion in demselben Konto oder in einem anderen Konto erstellen, von dem aus Sie Ihre API erstellt haben.

Für die vorherigen Lambda-Beispielfunktionen können Sie die integrierten Funktionen verwenden AWSLambdaBasicExecutionRole, da diese Funktionen keine anderen AWS Dienste aufrufen. Wenn Ihre Lambda-Funktion andere AWS Dienste aufruft, müssen Sie der Lambda-Funktion eine IAM-Ausführungsrolle zuweisen. Folgen Sie beim Erstellen einer Rolle den Anweisungen unter AWS Lambda -Ausführungsrolle.

Zusätzliche Beispiele für Lambda-Autorisierungsfunktionen