Lambda-Genehmiger Auth-Workflow Schritte zum Erstellen eines Lambda-Genehmigers Lambda-Genehmigerfunktion in der Lambda-Konsole erstellen

API Gateway-Lambda-Genehmiger verwenden

Ein Lambda-Genehmiger (früher bekannt als Kundenautorisierer) ist eine API Gateway-Funktion, die eine Lambda-Funktion verwendet, um den Zugriff auf Ihre API zu steuern.

Ein Lambda-Genehmiger ist hilfreich, wenn Sie ein benutzerdefiniertes Autorisierungsschema implementieren möchten, das eine Bearer-Token-Authentifizierungsstrategie, z. B. OAuth oder SAML, oder Anfrageparameter verwendet, um die Identität des Aufrufers zu bestimmen.

Wenn ein Client eine Anfrage an eine Ihrer API-Methoden stellt, ruft API Gateway Ihren Lambda-Genehmiger auf, der die Identität des Aufrufers als Eingabe entgegennimmt und eine IAM-Richtlinie als Ausgabe zurückgibt.

Es gibt zwei Arten von Lambda-Genehmigern:

Ein tokenbasierter Lambda-Genehmiger (auch als TOKEN-Genehmiger bezeichnet) erhält die Identität des Aufrufers in einem Bearer-Token, z. B. ein JSON-Web-Token (JWT) oder OAuth-Token. Ein Beispiel für eine Anwendung finden Sie unter Open Banking Brasilien – Autorisierungsbeispiele auf GitHub.
Ein anforderungsparameterbasierter Lambda-Genehmiger (auch als REQUEST-Genehmiger bezeichnet) erhält die Identität des Aufrufers in einer Kombination aus Headern, Abfragezeichenfolge-Parametern, stageVariables und $context-Variablen.

Für WebSocket APIs werden nur anforderungsparameterbasierte Genehmiger unterstützt.

Es ist möglich, eine - AWS Lambda Funktion aus einem - AWS Konto zu verwenden, das sich von dem unterscheidet, in dem Sie Ihre API erstellt haben. Weitere Informationen finden Sie unter Kontenübergreifenden Lambda-Genehmiger konfigurieren.

Beispiele für Lambda-Funktionen finden Sie unter aws-apigateway-lambda-authorizer-blueprints auf GitHub.

Themen

Lambda-Genehmiger Auth-Workflow

Das folgende Diagramm veranschaulicht den Autorisierungs-Workflow für Lambda-Genehmiger.

API Gateway-Lambda-Autorisierungs-Workflow

Der Client ruft eine Methode für eine API Gateway-API-Methode auf, wobei er ein Bearer-Token oder Anfrageparameter übergibt.
API Gateway prüft, ob ein Lambda-Genehmiger für die Methode konfiguriert ist. Ist dies der Fall, ruft API Gateway die Lambda-Funktion auf.
Die Lambda-Funktion authentifiziert den Aufrufer zum Beispiel so:
- Aufruf über einen OAuth-Anbieter, um ein OAuth-Zugriffs-Token zu erhalten
- Aufruf über einen SAML-Anbieter, um eine SAML-Zusicherung zu erhalten
- Generierung einer IAM-Richtlinie basierend auf den Werten der Anfrageparameter.
- Abrufen von Anmeldeinformationen aus einer Datenbank
Wenn der Aufruf erfolgreich ist, gewährt die Lambda-Funktion den Zugriff, indem sie ein Ausgabeobjekt zurückgibt, das mindestens eine IAM-Richtlinie und eine Prinzipal-ID enthält.
API Gateway wertet die Richtlinie aus.
- Wenn der Zugriff verweigert wird, gibt API Gateway einen geeigneten HTTP-Statuscode zurück, wie z. B. 403 ACCESS_DENIED.
- Wenn der Zugriff zulässig ist, ruft API Gateway die Methode auf. Wenn das Caching in den Genehmiger-Einstellungen aktiviert ist, speichert API Gateway die Richtlinie auch im Cache, sodass die Lambda-Autorisierungsfunktion nicht erneut aufgerufen werden muss.
Der Aufruf kann fehlschlagen, wenn die Lambda-Funktion eine 401 Unauthorized Antwort zurückgibt. Sie können die 401 Unauthorized Gateway-Antwort anpassen. Weitere Informationen hierzu finden Sie unter Gateway-Antworten in API Gateway.

Schritte zum Erstellen eines API Gateway-Lambda-Genehmigers

Um einen Lambda-Genehmiger zu erstellen, müssen Sie die folgenden Aufgaben durchführen:

Erstellen Sie die Lambda-Genehmigerfunktion in der Lambda-Konsole wie in API Gateway-Lambda-Genehmigerfunktion in der Lambda-Konsole erstellen beschrieben. Sie können eine der Vorlagenbeispiele als Startpunkt verwenden und die Eingabe und Ausgabe wie gewünscht anpassen.
Konfigurieren Sie die Lambda-Funktion als Genehmiger für API Gateway und konfigurieren Sie eine API-Methode, die sie vorschreibt, wie unter Lambda-Genehmiger über die API Gateway-Konsole konfigurieren beschrieben. Wenn Sie alternativ einen kontenübergreifenden Lambda-Genehmiger benötigen, lesen Sie Kontenübergreifenden Lambda-Genehmiger konfigurieren.

Anmerkung
Sie können einen -Genehmiger auch mithilfe der AWS CLI oder eines - AWS SDK konfigurieren.
Testen Sie Ihren Genehmiger mithilfe von Postman. Einzelheiten dazu finden Sie unter Aufruf einer API mit API Gateway-Lambda-Genehmigern.

API Gateway-Lambda-Genehmigerfunktion in der Lambda-Konsole erstellen

Bevor Sie einen Lambda-Genehmiger konfigurieren, müssen Sie zunächst die Lambda-Funktion erstellen, die die Logik zur Autorisierung und, falls erforderlich, zur Authentifizierung des Aufrufers implementiert. Die Lambda-Konsole stellt einen Python-Blueprint bereit, den Sie verwenden können, indem Sie Einen Blueprint verwenden und den api-gateway-authorizer-python Blueprint auswählen. Andernfalls möchten Sie einen der Blueprints im awslabs GitHub -Repository als Ausgangspunkt verwenden.

Für die Lambda-Beispiel-Genehmigerfunktionen in diesem Abschnitt, die keine anderen Dienste aufrufen, können Sie die integrierte verwenden AWSLambdaBasicExecutionRole. Wenn Sie die Lambda-Funktion für Ihren eigenen API Gateway-Lambda-Genehmiger erstellen, müssen Sie der Lambda-Funktion eine IAM-Ausführungsrolle zuweisen, wenn sie andere - AWS Services aufruft. Folgen Sie beim Erstellen einer Rolle den Anweisungen unter AWS Lambda -Ausführungsrolle.

Weitere Beispiele für Lambda-Funktionen finden Sie unter aws-apigateway-lambda-authorizer-blueprints auf GitHub. Eine Beispielanwendung finden Sie unter Open Banking Brasilien – Autorisierungsbeispiele auf GitHub.

BEISPIEL: Token-basierte Lambda-Genehmiger-Funktion erstellen

Um eine token-basierte Lambda-Genehmigerfunktion zu erstellen, geben Sie den folgenden Node.js-Code für die aktuelle Laufzeit in der Lambda-Konsole ein. Anschließend testen Sie den Genehmiger in der API-Gateway-Konsole.

So erstellen Sie die token-basierte Lambda-Genehmigerfunktion:

Wählen Sie in der Lambda-Konsole Create function (Funktion erstellen).
Wählen Sie Author from scratch aus.
Geben Sie einen Namen für die Funktion ein.
Wählen Sie für Laufzeit die neueste unterstützte Node.js- oder Python-Laufzeit aus.
Wählen Sie Create function (Funktion erstellen).

Kopieren Sie den folgenden Code und fügen Sie diesen in den Code-Editor ein.

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

Wählen Sie Deploy (Bereitstellen) aus.

Nachdem Sie Ihre Lambda-Funktion erstellt haben, erstellen und testen Sie einen token-basierten Lambda-Genehmiger in der API-Gateway-Konsole.

So erstellen Sie einen token-basierten Lambda-Genehmiger:

Erstellen Sie in der API Gateway-Konsole eine einfache API, falls Sie noch keine haben.
Wählen Sie Ihre API aus der API-Liste aus.
Wählen Sie Authorizers (Genehmiger) aus.
Wählen Sie Genehmiger erstellen aus.
Geben Sie unter Name des Genehmigers einen Namen ein.
Wählen Sie als Genehmiger-Typ Lambda aus.
Wählen Sie für Lambda-Funktion die aus, AWS-Region in der Sie Ihre Lambda-Genehmigerfunktion erstellt haben, und geben Sie dann den Funktionsnamen ein.
Lassen Sie das Feld Lambda-Aufrufrolle leer.
Wählen Sie für Lambda-Ereignisnutzlast die Option Token aus.
Geben Sie unter Token-Quelle authorizationToken ein.
Wählen Sie Genehmiger erstellen aus.

So testen Sie Ihren Genehmiger:

Wählen Sie den Namen des Genehmigers.
Geben unter Genehmiger testen für den Wert authorizationToken allow ein.
Wählen Sie Genehmiger testen aus.

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:

Bei einem Token-Wert von 'allow' gibt der Test der Genemigerfunktion 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/"
    }
  ]
}

Bei einem Token-Wert von 'deny' gibt der Test der 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 die Genehmigerfunktion eine 403 Forbidden-HTTP-Antwort zurück und die Methodenanforderung schlägt fehl.
Bei einem Token-Wert von 'unauthorized' oder bei einer leeren Zeichenfolge gibt der Test der 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.

Anmerkung

Im Produktions-Code kann die Authentifizierung des Benutzers erforderlich sein, bevor Sie Autorisierungen erteilen. Wenn dies der Fall ist, können Sie die Authentifizierungslogik auch in der Lambda-Funktion hinzufügen, indem Sie einen Authentifizierungsanbieter aufrufen. Befolgen Sie hierzu die Anleitungen in der Dokumentation für diesen Anbieter.

Zusätzlich zur Rückgabe einer IAM-Richtlinie muss die Lambda-Funktion des Genehmigers auch die Prinzipal-ID des Aufrufers zurückgeben. Es kann optional auch ein context-Objekt zurückgegeben werden, mit zusätzlichen Informationen, die dem Integrations-Backend übergeben werden können. Weitere Informationen finden Sie unter Ausgabe von einem Amazon API Gateway-Lambda-Genehmiger.

BEISPIEL: Anfragebasierten Lambda-Genehmigerfunktion erstellen

Um eine anfragebasierte Lambda-Genehmigerfunktion zu erstellen, geben Sie den folgenden Node.js-Code für die aktuelle Laufzeit in der Lambda-Konsole ein. Anschließend testen Sie den Genehmiger in der API-Gateway-Konsole.

Wählen Sie in der Lambda-Konsole Create function (Funktion erstellen).
Wählen Sie Author from scratch aus.
Geben Sie einen Namen für die Funktion ein.
Wählen Sie für Laufzeit die neueste unterstützte Node.js- oder Python-Laufzeit aus.
Wählen Sie Create function (Funktion erstellen).

Kopieren Sie den folgenden Code und fügen Sie diesen in den Code-Editor ein.

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["StageVal1"] == "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)

Wählen Sie Deploy (Bereitstellen) aus.

Nachdem Sie Ihre Lambda-Funktion erstellt haben, erstellen und testen Sie einen anfragebasierten Lambda-Genehmiger in der API-Gateway-Konsole.

So erstellen Sie einen anfragebasierten Lambda-Genehmiger:

Erstellen Sie in der API Gateway-Konsole eine einfache API, falls Sie noch keine haben.
Wählen Sie Ihre API aus der API-Liste aus.
Wählen Sie Authorizers (Genehmiger) aus.
Wählen Sie Genehmiger erstellen aus.
Geben Sie unter Name des Genehmigers einen Namen ein.
Wählen Sie als Genehmiger-Typ Lambda aus.
Wählen Sie für Lambda-Funktion die aus, AWS-Region in der Sie Ihre Lambda-Genehmigerfunktion erstellt haben, und geben Sie dann den Funktionsnamen ein.
Lassen Sie das Feld Lambda-Aufrufrolle leer.
Wählen Sie für Lambda-Ereignisnutzlast die Option Anfrage.
Geben Sie unter Identitätsquellen-Typ Folgendes ein:
1. Wählen Sie Header, geben Sie headerauth1 ein und wählen Sie dann Parameter hinzufügen aus.
2. Wählen Sie unter Identitätsquellen-Typ die Option Abfragezeichenfolge, geben Sie QueryString1 ein und wählen Sie dann Parameter hinzufügen aus.
3. Wählen Sie unter Identitätsquellen-Typ die Option Stufenvariable aus und geben Sie StageVar1 ein.
Wählen Sie Genehmiger erstellen aus.

So testen Sie Ihren Genehmiger:

Wählen Sie den Namen des Genehmigers.
Geben Sie unter Genehmiger testen Folgendes ein:
1. Wählen Sie Header, geben Sie headerValue1 ein und wählen Sie dann Parameter hinzufügen aus.
2. Wählen Sie unter Identitätsquellen-Typ die Option Abfragezeichenfolge, geben Sie queryValue1 ein und wählen Sie dann Parameter hinzufügen aus.
3. Wählen Sie unter Identitätsquellen-Typ die Option Stufenvariable aus und geben Sie stageValue1 ein.
Wählen Sie Genehmiger testen aus.

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 Genehmigerfunktion eine 401 Unauthorized-HTTP-Antwort zurück, und der Methodenaufruf schlägt fehl.

Anmerkung

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verwendung von Tags zur Zugriffssteuerung auf eine REST-API

Lambda-Genehmiger über die Konsole konfigurieren