Autorisierungsworkflow für Lambda-Autorisierer Auswahl eines Lambda-Autorisierungstyps Beispiel für eine REQUEST Autorisierungs-Lambda-Funktion Beispiel für eine TOKEN Autorisierungs-Lambda-Funktion Zusätzliche Beispiele für Lambda-Authorizer-Funktionen

Verwenden Sie API Gateway Lambda-Autorisierer

Verwenden Sie einen Lambda-Autorisierer (früher bekannt als benutzerdefinierter Autorisierer), um den Zugriff auf Ihren zu kontrollieren. API Wenn ein Client eine Anfrage an Ihre API Methode stellt, 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 oder verwenden. OAuth SAML Erstellen Sie einen Lambda-Autorisierer in der API REST API Gateway-Konsole mit dem AWS CLI, oder einem. AWS SDK

Autorisierungsworkflow für Lambda-Autorisierer

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

APIWorkflow zur Gateway-Lambda-Autorisierung

Der Client ruft eine Methode auf einem API Gateway auf und übergibt API dabei ein Bearer-Token oder Anforderungsparameter.
APIGateway prüft, ob die Methodenanforderung mit einem Lambda-Authorizer konfiguriert ist. Ist dies der Fall, ruft API Gateway die Lambda-Funktion auf.
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 Bestätigung zu erhalten.
- Durch Generieren einer IAM Richtlinie auf der Grundlage der Werte der Anforderungsparameter.
- Durch das Abrufen von Anmeldeinformationen aus einer Datenbank.
Die Lambda-Funktion gibt eine IAM Richtlinie und einen Prinzipalbezeichner zurück. Wenn die Lambda-Funktion diese Informationen nicht zurückgibt, schlägt der Aufruf fehl.
APIGateway bewertet die IAM Richtlinie.
- Wenn der Zugriff verweigert wird, gibt API Gateway einen geeigneten HTTP Statuscode zurück, 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 Ihren 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 empfängt die Identität des Aufrufers in einem Trägertoken, z. B. einem Web-Token () oder einem JSON Token. JWT OAuth

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. APIGateway 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 Anrufe an Ihre zu reduzieren. API

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

Anmerkung

Wir empfehlen Ihnen, einen REQUEST Autorisierer zu verwenden, um den Zugriff auf Ihre zu kontrollieren. API Sie können den Zugriff auf Ihre Datenbank API anhand 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.

     
    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.

    if (headers['HeaderAuth1'] == "headerValue1" and queryStringParameters['QueryString1'] == "queryValue1" and stageVariables['StageVar1'] == "stageValue1"):
        response = generateAllow('me', event['methodArn'])
        print('authorized')
        return response
    else:
        print('unauthorized')
        raise Exception('Unauthorized') # Return a 401 Unauthorized 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)

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

Wenn alle erforderlichen Parameterwerte den erwarteten Werten entsprechen, gibt die Autorisierungsfunktion eine 200 OK HTTP Antwort und eine IAM Richtlinie zurück, die wie folgt aussehen, und die Methodenanforderung ist erfolgreich:


{
  "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.

Die Lambda-Autorisierungsfunktion muss nicht nur eine IAM Richtlinie zurückgeben, sondern 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 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

In diesem Beispiel übergibt API Gateway, wenn API er eine Methodenanforderung empfängt, das Quell-Token an diese Lambda-Autorisierungsfunktion im event.authorizationToken Attribut. Die Lambda-Genehmigerfunktion liest das Token und verhält sich wie folgt:

Wenn der Token-Wert istallow, gibt die Autorisierungsfunktion eine 200 OK HTTP Antwort und eine IAM Richtlinie zurück, die wie folgt aussehen, und die Methodenanforderung ist erfolgreich:


{
  "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 Tokenwert istdeny, gibt die Autorisierungsfunktion eine 200 OK HTTP Antwort und eine Deny IAM Richtlinie zurück, die wie folgt aussehen, 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 Tokenwert unauthorized oder eine leere Zeichenfolge ist, gibt die Autorisierungsfunktion 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ätzliche Beispiele für Lambda-Authorizer-Funktionen

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-Authorizer-Funktionen

Eine Beispielanwendung finden Sie unter Open Banking Brazil — Authorization Samples on. GitHub
Weitere Lambda-Beispielfunktionen finden Sie unter aws-apigateway-lambda-authorizer-blueprints on. GitHub
Sie können einen Lambda-Autorisierer erstellen, der Benutzer mithilfe von Amazon Cognito Cognito-Benutzerpools authentifiziert und Anrufer anhand eines Richtlinienspeichers mithilfe verifizierter Berechtigungen autorisiert. Weitere Informationen finden Sie unter Steuern Sie den Zugriff anhand der Attribute einer Identität mit verifizierten Berechtigungen.
Die Lambda-Konsole stellt einen Python-Blueprint bereit, den Sie verwenden können, indem Sie Blueprint verwenden und dann Blueprint auswählen. api-gateway-authorizer-python

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

Einen Lambda-Autorisierer konfigurieren