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-Genehmiger* (ehemals *benutzerdefinierter Genehmiger*) für die Zugriffskontrolle zu Ihrer API. Wenn ein Client eine Anfrage an die Methode Ihrer API stellt, ruft API Gateway Ihren Lambda-Genehmiger auf. Der Lambda-Genehmiger verwendet die Identität des Aufrufers als Eingabe und gibt eine IAM-Richtlinie als Ausgabe zurück. Verwenden Sie einen Lambda-Genehmiger für die Implementierung eines benutzerdefinierten Genehmigungsschemas. Ihr Schema kann Anforderungsparameter verwenden, um die Identität des Anrufers zu ermitteln, oder eine Bearer-Token-Authentifizierungsstrategie wie SAML OAuth verwenden. Erstellen Sie einen Lambda-Authorizer in der API Gateway REST API-Konsole, indem Sie das oder ein AWS CLI AWS SDK verwenden. ## Genehmigungsworkflow für Lambda-Genehmiger Im folgenden Diagramm sehen Sie den Genehmigungsworkflow für Lambda-Genehmiger. ![\[API Gateway-Lambda-Autorisierungs-Workflow\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/custom-auth-workflow.png) **API Gateway-Lambda-Autorisierungs-Workflow** 1. Der Client ruft eine Methode für eine API-Gateway-API auf, wobei er ein Bearer-Token oder mehrere Anforderungsparameter übergibt. 1. API Gateway prüft, ob ein Lambda-Genehmiger für die Methodenanforderung konfiguriert ist. Ist dies der Fall, ruft API Gateway die Lambda-Funktion auf. 1. Die Lambda-Funktion authentifiziert den Aufrufer. Die Funktion kann sich wie folgt authentifizieren: + Indem Sie einen OAuth Anbieter anrufen, um ein OAuth Zugriffstoken zu erhalten. + Aufruf über einen SAML-Anbieter, um eine SAML-Zusicherung zu erhalten + Generierung einer IAM-Richtlinie basierend auf den Werten der Anforderungsparameter. + Abrufen von Anmeldeinformationen aus einer Datenbank 1. 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. 1. API Gateway wertet die IAM-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 gestattet wird, ruft API Gateway die Methode auf. Wenn Sie Genehmigungs-Caching aktivieren, speichert API Gateway die Richtlinie zwischen, sodass die Lambda-Genehmigungsfunktion nicht erneut aufgerufen wird. Stellen Sie sicher, dass Ihre Richtlinie für alle Ressourcen und Methoden Ihrer API gilt. Sie können die `403 ACCESS_DENIED` oder die `401 UNAUTHORIZED`-Gateway-Antworten anpassen. Weitere Informationen hierzu finden Sie unter [Gateway-Antworten für REST APIs in API Gateway](api-gateway-gatewayResponse-definition.md). ## Auswahl eines Lambda-Genehmigertyps Es gibt zwei Arten von Lambda-Genehmigern: **Parameterbasierten Lambda-Genehmiger anfordern (`REQUEST`-Genehmiger) anfordern** Ein `REQUEST`-Genehmiger empfängt die Identität des Aufrufers in einer Kombination aus Headern, Abfragezeichenfolgeparametern, [`stageVariables`](api-gateway-mapping-template-reference.md#stagevariables-template-reference) sowie [`$context`](api-gateway-mapping-template-reference.md#context-variable-reference)-Variablen. Sie können einen `REQUEST`-Genehmiger zur Erstellung detaillierte Richtlinien auf Basis von Informationen aus verschiedenen Identitätsquellen wie den `$context.path`- und `$context.httpMethod`-Kontextvariablen verwenden. Wenn Sie das Genehmigungs-Caching für einen `REQUEST`-Genehmiger aktivieren, überprüft API Gateway, ob alle angegebenen Identitätsquellen in der Anforderung vorhanden sind. Sollte eine angegebene Identifikationsquelle fehlen, Null oder leer sein, gibt API Gateway eine `401 Unauthorized`-HTTP-Antwort zurück, ohne die Lambda-Genehmigerfunktion aufzurufen. Wenn mehrere Identitätsquellen definiert sind, werden sie alle für die Ableitung des Cache-Schlüssel des Genehmigers verwendet. Sie können einen detaillierten Cache-Schlüssel durch eine Verwendung mehrerer Identitätsquellen definieren. Wenn Sie Teile des Cache-Schlüssels ändern und Ihre API erneut bereitstellen, verwirft der Genehmiger das im Cache befindliche Richtliniendokument und generiert ein neues Dokument. Wenn Sie das Genehmigungs-Caching für einen `REQUEST`-Genehmiger deaktivieren, leitet API Gateway die Anforderung direkt an die Lambda-Funktion weiter. **Token-basierter Lambda-Genehmiger (`TOKEN`-Genehmiger)** Ein `TOKEN` Autorisierer erhält die Identität des Aufrufers in einem Trägertoken, z. B. einem JSON Web Token (JWT) oder einem Token. OAuth Wenn Sie das Genehmigungs-Caching für einen `TOKEN`-Genehmiger 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 Anweisung einzugeben. RegEx API Gateway führt eine erste Überprüfung des Eingabe-Tokens für diesen Ausdruck durch und ruft nach erfolgreichen Validierung die Lambda-Genehmigerfunktion auf. Dies trägt dazu bei, die Anzahl der Aufrufe Ihrer API zu reduzieren. Die `IdentityValidationExpression`-Eigenschaft wird ausschließlich für `TOKEN`-Genehmiger unterstützt. Weitere Informationen finden Sie unter [x-amazon-apigateway-authorizer Objekt](api-gateway-swagger-extensions-authorizer.md). **Anmerkung** Wir empfehlen, dass Sie einen `REQUEST`-Genehmiger für die Zugriffskontrolle auf Ihre API verwenden. Sie können den Zugriff auf Ihre API auf Basis mehrerer Identitätsquellen steuern, wenn Sie einen `REQUEST`-Genehmiger verwenden, anstatt einer einzigen Identitätsquelle, wenn Sie einen `TOKEN`-Genehmiger verwenden. Außerdem können Sie unterschiedliche Cache-Schlüssel mithilfe mehrerer Identitätsquellen für einen `REQUEST`-Genehmiger separieren. ## Beispiel für eine Lambda-Funktion für `REQUEST`-Genehmiger Der folgende Beispielcode erstellt eine Lambda-Funktion für Genehmiger, die eine Anforderung zulässt, wenn der vom Client bereitgestellte `HeaderAuth1`-Header, der `QueryString1`-Abfrageparameter und die Stufenvariable `StageVar1` jeweils den angegebenen Werten von `headerValue1`, `queryValue1` und `stageValue1` entsprechen. ------ #### [ 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) ``` ------ 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: ------ #### [ 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/" } ] } ``` ------ + Andernfalls gibt die Genehmigerfunktion 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 auch ein `context`-Objekt mit zusätzlichen Informationen zurückgegeben werden, die dem Integrations-Backend übergeben werden können. Weitere Informationen finden Sie unter [Ausgabe von einem API-Gateway-Lambda-Genehmiger](api-gateway-lambda-authorizer-output.md). Im Produktions-Code kann eine Authentifizierung des Benutzers erforderlich sein, bevor eine Autorisierung erfolgt. Sie können die Authentifizierungslogik zu der Lambda-Funktion hinzufügen, indem Sie einen Authentifizierungsanbieter aufrufen. Befolgen Sie hierzu die Anleitungen in der Dokumentation des Anbieters. ## Beispiel für eine Lambda-Funktion für `TOKEN`-Genehmiger Der folgende Beispielcode erstellt eine `TOKEN` Lambda-Genehmigungsfunktion, die es einem Aufrufer erlaubt, eine Methode aufzurufen, wenn der vom Client bereitgestellte Tokenwert `allow` lautet. Der Aufrufer darf die Anforderung nicht aufrufen, wenn der Tokenwert `deny` ist. Wenn der Tokenwert `unauthorized` lautet oder eine leere Zeichenfolge ist, gibt die Genehmigerfunktion eine `401 UNAUTHORIZED`-Antwort zurück. ------ #### [ 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: ------ #### [ 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/" } ] } ``` ------ + 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: ------ #### [ 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/" } ] } ``` ------ **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 auch ein `context`-Objekt mit zusätzlichen Informationen zurückgegeben werden, die dem Integrations-Backend übergeben werden können. Weitere Informationen finden Sie unter [Ausgabe von einem API-Gateway-Lambda-Genehmiger](api-gateway-lambda-authorizer-output.md). Im Produktions-Code kann eine Authentifizierung des Benutzers erforderlich sein, bevor eine Autorisierung erfolgt. Sie können die Authentifizierungslogik zu der Lambda-Funktion hinzufügen, indem Sie einen Authentifizierungsanbieter aufrufen. Befolgen Sie hierzu die Anleitungen in der Dokumentation des Anbieters. ## Weitere Beispiele für Lambda-Genehmigerfunktionen Die folgende Liste enthält weitere Beispiele für Lambda-Genehmigerfunktionen. Sie können eine Lambda-Funktion in demselben oder in einem anderen Konto als dem Konto erstellen, in dem Sie Ihre API erstellt haben. Für die vorherigen Lambda-Beispielfunktionen können Sie die integrierten Funktionen verwenden [AWSLambdaBasicExecutionRole](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html), 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](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html). **Weitere Beispiele für Lambda-Genehmigerfunktionen** + Eine Beispielanwendung finden Sie unter [Open Banking Brasilien — Authorization Samples](https://github.com/aws-samples/openbanking-brazilian-auth-samples) on GitHub. + Weitere Lambda-Beispielfunktionen finden Sie unter [ aws-apigateway-lambda-authorizer-blueprints on](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints). GitHub + Sie können einen Lambda-Genehmiger erstellen, der Benutzer mithilfe von Amazon-Cognito-Benutzerpools authentifiziert und Aufrufer anhand eines Richtlinienspeichers mithilfe Verified Permissions autorisiert. Weitere Informationen finden Sie unter [Zugriffssteuerung anhand der Attribute einer Identität mit Verified Permissions](apigateway-lambda-authorizer-verified-permissions.md). + 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** # Einen API-Gateway-Lambda-Genehmiger konfigurieren Nachdem Sie eine Lambda-Funktion erstellt haben, konfigurieren Sie die Lambda-Funktion als Genehmiger für Ihre API. Anschließend konfigurieren Sie Ihre Methode, sodass sie Ihren Lambda-Genehmiger aufruft, um festzustellen, ob ein Aufrufer Ihre Methode aufrufen kann. Sie können eine Lambda-Funktion in demselben oder in einem anderen Konto als dem Konto erstellen, in dem Sie Ihre API erstellt haben. Sie können Ihren Lambda-Genehmiger mit in der API-Gateway-Konsole integrierten Tools oder mithilfe von [Postman](https://www.postman.com/) testen. Anleitungen zur Verwendung von Postman zum Testen Ihrer Lambda-Genehmigerfunktion finden Sie unter [Aufruf einer API mit einem API Gateway-Lambda-Genehmiger](call-api-with-api-gateway-lambda-authorization.md). ## Lambda-Genehmiger konfigurieren (Konsole) Im folgenden Verfahren sehen Sie, wie Sie einen Lambda-Genehmiger in der API-Gateway-REST-API-Konsole erstellen. Weitere Informationen zu den verschiedenen Lambda-Genehmigertypen finden Sie unter [Auswahl eines Lambda-Genehmigertyps](apigateway-use-lambda-authorizer.md#api-gateway-lambda-authorizer-choose). ------ #### [ REQUEST authorizer ] **So konfigurieren Sie einen `REQUEST`-Lambda-Genehmiger** 1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway). 1. Wählen Sie eine API und dann **Genehmiger** aus. 1. Wählen Sie **Genehmiger erstellen** aus. 1. Geben Sie unter **Name des Genehmigers** einen Namen für den Genehmiger ein. 1. Wählen Sie als **Genehmiger-Typ** **Lambda** aus. 1. Wählen Sie für **Lambda-Funktion** den Ort aus, AWS-Region an dem Sie Ihre Lambda-Autorisierungsfunktion erstellt haben, und geben Sie dann den Funktionsnamen ein. 1. Lassen Sie **Lambda-Aufrufrolle** leer, um der API-Gateway-REST-API-Konsole zu erlauben, eine ressourcenbasierte Richtlinie festzulegen. Die Richtlinie gewährt API Gateway Berechtigungen, die Lambda-Genehmigerfunktion aufzurufen. Alternativ können Sie den Namen einer IAM-Rolle eingeben, damit API Gateway die Lambda-Genehmigerfunktion aufrufen kann. Eine Beispielrolle finden Sie unter [Übernehmbare IAM-Rolle erstellen](integrating-api-with-aws-services-lambda.md#api-as-lambda-proxy-setup-iam-role-policies). 1. Wählen Sie für **Lambda-Ereignisnutzlast** die Option **Anfrage**. 1. Wählen Sie für **Identitätsquellen-Typ** einen Parametertyp aus. Die unterstützten Parametertypen sind `Header`, `Query string`, `Stage variable` und `Context`. Um weitere Identitätsquellen hinzuzufügen, wählen Sie **Parameter hinzufügen**. 1. Um die vom Genehmiger generierte Genehmigungsrichtlinie zwischenzuspeichern, lassen Sie **Genehmigungs-Caching** aktiviert. Wenn das Caching der Richtlinie aktiviert ist, können Sie den **TTL**-Wert ändern. Durch die Einstellung **TTL** = 0 wird das Richtlinien-Caching deaktiviert. Wenn Sie Caching aktivieren, muss Ihr Genehmiger eine Richtlinie zurückgeben, die auf alle Methoden einer API anwendbar sind. Verwenden Sie die Kontextvariablen `$context.path` und `$context.httpMethod`, um eine methodenspezifische Richtlinie durchzusetzen. 1. Wählen Sie **Autorisierer erstellen**. ------ #### [ TOKEN authorizer ] **So konfigurieren Sie einen `TOKEN`-Lambda-Genehmiger** 1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway). 1. Wählen Sie eine API und dann **Genehmiger** aus. 1. Wählen Sie **Genehmiger erstellen** aus. 1. Geben Sie unter **Name des Genehmigers** einen Namen für den Genehmiger ein. 1. Wählen Sie als **Genehmiger-Typ** **Lambda** aus. 1. Wählen Sie für **Lambda-Funktion** den Ort aus, AWS-Region an dem Sie Ihre Lambda-Autorisierungsfunktion erstellt haben, und geben Sie dann den Funktionsnamen ein. 1. Lassen Sie **Lambda-Aufrufrolle** leer, um der API-Gateway-REST-API-Konsole zu erlauben, eine ressourcenbasierte Richtlinie festzulegen. Die Richtlinie gewährt API Gateway Berechtigungen, die Lambda-Genehmigerfunktion aufzurufen. Alternativ können Sie den Namen einer IAM-Rolle eingeben, damit API Gateway die Lambda-Genehmigerfunktion aufrufen kann. Eine Beispielrolle finden Sie unter [Übernehmbare IAM-Rolle erstellen](integrating-api-with-aws-services-lambda.md#api-as-lambda-proxy-setup-iam-role-policies). 1. Wählen Sie für **Lambda-Ereignisnutzlast** die Option **Token** aus. 1. Geben Sie unter **Token-Quelle** den Header-Namen ein, der das Genehmigungstoken enthält. Der Aufrufer muss einen Header mit diesem Namen enthalten, um das Genehmigungs-Token an den Lambda-Genehmiger zu senden. 1. (Optional) Geben Sie für die **Token-Validierung** eine Anweisung ein. RegEx API Gateway führt eine erste Überprüfung des eingegebenen Token für diesen Ausdruck an und ruft nach der erfolgreichen Validierung den Genehmiger auf. 1. Um die vom Genehmiger generierte Genehmigungsrichtlinie zwischenzuspeichern, lassen Sie **Genehmigungs-Caching** aktiviert. Wenn das Richtlinien-Caching aktiviert ist, wird der unter **Token-Quelle** angegebene Header-Name zum Cache-Schlüssel. Wenn das Caching der Richtlinie aktiviert ist, können Sie den **TTL**-Wert ändern. Durch die Einstellung **TTL** = 0 wird das Richtlinien-Caching deaktiviert. Wenn Sie Caching aktivieren, muss Ihr Genehmiger eine Richtlinie zurückgeben, die auf alle Methoden einer API anwendbar sind. Sie können **Autorisierer-Caching** deaktivieren, wenn Sie eine methodenspezifische Richtlinie durchsetzen möchten. 1. Wählen Sie **Autorisierer erstellen**. ------ Nachdem Sie Ihren Lambda-Genehmiger erstellt haben, können Sie ihn testen. Im folgenden Verfahren sehen Sie, wie Sie Ihren Lambda-Genehmiger testen. ------ #### [ REQUEST authorizer ] **So testen Sie einen `REQUEST`-Lambda-Genehmiger** 1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway). 1. Wählen Sie den Namen Ihres Genehmigers aus. 1. Geben Sie unter **Genehmiger testen** einen Wert für Ihre Identitätsquelle ein. Wenn Sie [Beispiel für eine Lambda-Funktion für `REQUEST`-Genehmiger](apigateway-use-lambda-authorizer.md#api-gateway-lambda-authorizer-request-lambda-function-create) verwenden, gehen Sie wie folgt vor: 1. Wählen Sie **Header**, geben Sie **headerValue1** ein und wählen Sie dann **Parameter hinzufügen** aus. 1. Wählen Sie unter **Identitätsquellen-Typ** die Option **Abfragezeichenfolge**, geben Sie **queryValue1** ein und wählen Sie dann **Parameter hinzufügen** aus. 1. Wählen Sie unter **Identitätsquellen-Typ** die Option **Stufenvariable** aus und geben Sie **stageValue1** ein. Sie können die Kontextvariablen für den Testaufruf nicht ändern, aber Sie können die **API-Gateway-Genehmiger**-Testereignisvorlage für Ihre Lambda-Funktion bearbeiten. Anschließend können Sie Ihre Lambda-Genehmigerfunktion mit geänderten Kontextvariablen testen. Weitere Informationen finden Sie unter [Lambda-Funktionen in der Konsole testen](https://docs.aws.amazon.com/lambda/latest/dg/testing-functions.html) im *AWS Lambda -Entwicklerhandbuch*. 1. Wählen Sie **Genehmiger testen** aus. ------ #### [ TOKEN authorizer ] **So testen Sie einen `TOKEN`-Lambda-Genehmiger** 1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway). 1. Wählen Sie den Namen Ihres Genehmigers aus. 1. Geben Sie unter **Genehmiger testen** einen Wert für Ihr Token ein. Wenn Sie [Beispiel für eine Lambda-Funktion für `TOKEN`-Genehmiger](apigateway-use-lambda-authorizer.md#api-gateway-lambda-authorizer-token-lambda-function-create) verwenden, gehen Sie wie folgt vor: 1. Geben Sie unter **authorizationToken** **allow** ein. 1. Wählen Sie **Genehmiger testen** aus. Wenn Ihr Lambda-Genehmiger eine Anfrage in der Testumgebung erfolgreich abweist, wird eine `200 OK`-HTTP-Antwort zurückgegeben. Außerhalb der Testumgebung jedoch, gibt API Gateway eine `403 Forbidden`-HTTP-Antwort zurück und die Methodenanforderung schlägt fehl. ------ ## Lambda-Genehmiger konfigurieren (AWS CLI) Der Befehl [create-authorizer](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-authorizer.html) demonstriert den Vorgang der Erstellung eines Lambda-Genehmigers mithilfe der AWS CLI. ------ #### [ REQUEST authorizer ] Der folgende [create-authorizer](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-authorizer.html)-Befehl erstellt einen `REQUEST`-Genehmiger und verwendet den `Authorizer`-Header sowie die `accountId`-Kontextvariable als Identitätsquellen: ``` aws apigateway create-authorizer \ --rest-api-id 1234123412 \ --name 'First_Request_Custom_Authorizer' \ --type REQUEST \ --authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations' \ --identity-source 'method.request.header.Authorization,context.accountId' \ --authorizer-result-ttl-in-seconds 300 ``` ------ #### [ TOKEN authorizer ] Der folgende [create-authorizer](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-authorizer.html)-Befehl erstellt einen `TOKEN`-Genehmiger und verwendet den `Authorization`-Header als Identitätsquelle: ``` aws apigateway create-authorizer \ --rest-api-id 1234123412 \ --name 'First_Token_Custom_Authorizer' \ --type TOKEN \ --authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations' \ --identity-source 'method.request.header.Authorization' \ --authorizer-result-ttl-in-seconds 300 ``` ------ Nachdem Sie Ihren Lambda-Genehmiger erstellt haben, können Sie ihn testen. Der folgende [test-invoke-authorizer](https://docs.aws.amazon.com/cli/latest/reference/apigateway/test-invoke-authorizer.html)Befehl testet einen Lambda-Authorizer: ``` aws apigateway test-invoke-authorizer --rest-api-id 1234123412 \ --authorizer-id efg1234 \ --headers Authorization='Value' ``` ## Konfigurieren einer Methode für die Verwendung eines Lambda-Genehmigers (Konsole) Nachdem Sie Ihren Lambda-Genehmiger konfiguriert haben, müssen Sie ihn einer Methode für Ihre API hinzufügen. Wenn Ihr Genehmiger Autorisierungs-Caching verwendet, stellen Sie sicher, dass Sie die Richtlinie aktualisieren, um den Zugriff auf die zusätzliche Methode zu kontrollieren. **So konfigurieren Sie eine API-Methode für die Verwendung eines Lambda-Genehmigers:** 1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway). 1. Wählen Sie eine API aus. 1. Klicken Sie auf **Ressourcen** und wählen Sie dann eine neue oder bereits vorhandene Methode aus. 1. Wählen Sie auf der Registerkarte **Methodenanfrage** unter **Methodenanfrage-Einstellungen** die Option **Bearbeiten** aus. 1. Wählen Sie für **Genehmiger** aus dem Drop-down-Menü den Lambda-Genehmiger aus, den Sie gerade erstellt haben. 1. (Optional) Wenn Sie das Genehmigungstoken an das Backend übergeben möchten, wählen Sie **HTTP-Anforderungsheader** aus. Wählen Sie **Header hinzufügen** und fügen Sie dann den Namen des Genehmigungsheaders hinzu. Geben Sie unter **Name** den Header-Namen ein, der mit dem Namen der **Token-Quelle** übereinstimmt, den Sie beim Erstellen des Lambda-Genehmigers für die API angegeben haben. Dieser Schritt gilt nicht für `REQUEST`-Genehmiger. 1. Wählen Sie **Speichern**. 1. Wählen Sie **Deploy API** aus, um die API für eine Stufe bereitzustellen. Für einen `REQUEST`-Genehmiger mit Stufenvariablen müssen Sie auch die erforderlichen Stufenvariablen definieren und ihre Werte auf der Seite **Stufen** angeben. ## Konfigurieren einer Methode für die Verwendung eines Lambda-Genehmigers (AWS CLI) Nachdem Sie Ihren Lambda-Genehmiger konfiguriert haben, müssen Sie ihn einer Methode für Ihre API hinzufügen. Sie können eine neue Methode erstellen oder einen Patch-Vorgang verwenden, um einen Genehmiger an eine vorhandene Methode anzuhängen. Wenn Ihr Genehmiger Autorisierungs-Caching verwendet, stellen Sie sicher, dass Sie die Richtlinie aktualisieren, um den Zugriff auf die zusätzliche Methode zu kontrollieren. Der [put-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html)-Befehl erstellt eine neue Methode, die einen Lambda-Genehmiger verwendet: ``` aws apigateway put-method --rest-api-id 1234123412 \ --resource-id a1b2c3 \ --http-method PUT \ --authorization-type CUSTOM \ --authorizer-id efg1234 ``` Der [update-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-method.html)-Befehl aktualisiert eine vorhandene Methode, um einen Lambda-Genehmiger zu verwenden: ``` aws apigateway update-method \ --rest-api-id 1234123412 \ --resource-id a1b2c3 \ --http-method PUT \ --patch-operations op="replace",path="/authorizationType",value="CUSTOM" op="replace",path="/authorizerId",value="efg1234" ``` # Eingabe für einen API-Gateway-Lambda-Genehmiger Im folgenden Abschnitt wird das Format der Eingabe aus API Gateway an einen Lambda-Genehmiger erklärt. ## `TOKEN`-Eingabeformat Für einen Lambda-Genehmiger (ehemals als benutzerdefinierter Genehmiger bezeichnet) des Typs `TOKEN` müssen Sie einen benutzerdefinierten Header als **Token Source (Token-Quelle)** angeben, wenn Sie den Genehmiger für Ihre API konfigurieren. Der API-Client muss das erforderliche Autorisierungs-Token in diesem Header in der eingehenden Anforderung übergeben. Beim Empfang der eingehenden Methodenanfrage extrahiert API Gateway das Token aus dem benutzerdefinierten Header. Anschließend gibt es das Token als `authorizationToken`-Eigenschaft des `event`-Objekts der Lambda-Funktion zurück, zusätzlich zum Methode-ARN als `methodArn`-Eigenschaft: ``` { "type":"TOKEN", "authorizationToken":"{caller-supplied-token}",     "methodArn":"arn:aws:execute-api:{regionId}:{accountId}:{apiId}/{stage}/{httpVerb}/[{resource}/[{child-resources}]]" } ``` In diesem Beispiel gibt die `type`-Eigenschaft den Genehmigertyp an, wobei es sich um einen `TOKEN` Genehmiger handelt. Das `{caller-supplied-token}` stammt aus dem Autorisierungs-Header einer Client-Anforderung und kann eine beliebige Zeichenfolge sein. `methodArn` ist der ARN der eingehenden Methodenanfrage und wird von API Gateway entsprechend der Konfiguration des Lambda-Genehmigers aufgefüllt. ## `REQUEST`-Eingabeformat Für einen Lambda-Genehmiger vom Typ `REQUEST` übergibt API Gateway die Anfrageparameter als Teil des `event`-Objekts an die Lambda-Genehmigerfunktion. Die Anforderungsparameter umfassen Header, Pfad, Parameter für Abfragezeichenfolgen, Stufenvariablen und einige der Anforderungskontextvariablen. Der API-Aufrufer können die Pfadparameter, Header und Abfragezeichenfolgenparameter festlegen. Der API-Entwickler muss die Stage-Variablen während der API-Bereitstellung festlegen, und API Gateway stellt den Anfragekontext zur Laufzeit zur Verfügung. **Anmerkung** Pfadparameter können als Anfrageparameter an die Lambda-Genehmigerfunktion übergeben werden, aber sie können nicht als Identitätsquellen verwendet werden. Das folgende Beispiel zeigt eine Eingabe für einen `REQUEST` Genehmiger für eine API-Methode (`GET /request`) mit einer Proxy-Integration: ``` { "type": "REQUEST", "methodArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request", "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" } } ``` `requestContext` ist eine Zuordnung von Schlüssel-Wert-Paaren und entspricht der Variablen [\$1 Kontext](api-gateway-mapping-template-reference.md#context-variable-reference). Das Ergebnis hängt von der API ab. API Gateway kann der Zuordnung u. U. neue Schlüssel hinzufügen. Weitere Informationen über die Eingabe von Lambda-Funktionen bei der Lambda-Proxy-Integration finden Sie unter [Eingabeformat einer Lambda-Funktion für die Proxy-Integration](set-up-lambda-proxy-integrations.md#api-gateway-simple-proxy-for-lambda-input-format). # Ausgabe von einem API-Gateway-Lambda-Genehmiger Die Ausgabe einer Lambda-Genehmigerfunktion ist ein wörterbuchähnliches Objekt, das die Prinzipal-ID (`principalId`) und ein Richtliniendokument (`policyDocument`) mit einer Liste Richtlinienanweisungen umfassen muss. Die Ausgabe kann auch eine `context`-Zuweisung mit Schlüssel-Wert-Paaren umfassen. Wenn die API einen Nutzungsplan verwendet ([https://docs.aws.amazon.com/apigateway/latest/api/API_RestApi.html#apiKeySource](https://docs.aws.amazon.com/apigateway/latest/api/API_RestApi.html#apiKeySource) ist auf `AUTHORIZER` gesetzt), muss die Lambda-Genehmigerfunktion einen der API-Schlüssel des Nutzungsplans als `usageIdentifierKey`-Eigenschaftswert ausgeben. Hier ein Beispiel für diese Ausgabe. ------ #### [ JSON ] **** ``` {   "principalId": "yyyyyyyy", "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": { "stringKey": "value", "numberKey": "1", "booleanKey": "true" }, "usageIdentifierKey": "{api-key}" } ``` ------ Hier legt eine Richtlinienanweisung fest, ob dem API Gateway-Ausführungs-Service der Aufruf (`Action`) der angegebenen API-Methode (`Resource`) erlaubt oder verweigert wird (`Effect`). Je nach Ihrem Autorisierer müssen Sie möglicherweise den Zugriff auf mehrere Ressourcen kontrollieren. Sie können einen Platzhalter (`*`) verwenden, um einen Ressourcentyp (Methode) anzugeben. Weitere Informationen zum Festlegen von gültigen Richtlinien für das Aufrufen einer API finden Sie unter [Anweisungsreferenz für IAM-Richtlinien zur Ausführung der API in API Gateway](api-gateway-control-access-using-iam-policies-to-invoke-api.md#api-gateway-calling-api-permissions). Für Methoden-ARNs mit Autorisierung, z. B. `arn:aws:execute-api:{regionId}:{accountId}:{apiId}/{stage}/{httpVerb}/[{resource}/[{child-resources}]]` beträgt die maximale Länge 1 600 Bytes. Die Pfadparameterwerte, deren Größe zur Laufzeit ermittelt wird, können dazu führen, dass die Länge des ARN dieses Limit übersteigt. Wenn dies geschieht, empfängt der API-Client die Antwort `414 Request URI too long`. Darüber hinaus ist der Ressourcen-ARN, wie in der Richtlinienanweisungsausgabe des Genehmigers gezeigt, derzeit auf 512 Zeichen begrenzt. Aus diesem Grund können Sie die URI nicht mit einem längeren JWT-Token in einer Anforderungs-URI verwenden. Übergeben Sie das JWT-Token stattdessen sicher im Anforderungs-Header. Sie können auf den `principalId`-Wert in einer Mapping-Vorlage unter Verwendung der `$context.authorizer.principalId`-Variablen zugreifen. Dies ist nützlich, wenn Sie den Wert an das Backend übergeben möchten. Weitere Informationen finden Sie unter [Kontextvariablen für Datentransformationen](api-gateway-mapping-template-reference.md#context-variable-reference). Sie können auf den `stringKey`-, `numberKey`- oder `booleanKey`-Wert (z. B. `"value"`, `"1"` oder `"true"`) der `context`-Zuweisung in einer Mapping-Vorlage zugreifen, indem Sie `$context.authorizer.stringKey`, `$context.authorizer.numberKey` bzw. `$context.authorizer.booleanKey` aufrufen. Die zurückgegebenen Werte werden alle in Text umgewandelt. Beachten Sie, dass Sie kein JSON-Objekt oder -Array als gültigen Wert eines Schlüssels in der `context`-Zuweisung festlegen können. Sie können das `context`-Mapping verwenden, um im Cache abgelegte Anmeldeinformationen vom Genehmiger unter Verwendung einer Mapping-Vorlage für die Integrationsanfrage an das Backend zurückzugeben. Dies ermöglicht dem Backend, durch Nutzung der im Cache gespeicherten Anmeldeinformationen, um die Notwendigkeit für den Zugriff auf die geheimen Schlüssel zu reduzieren und die Autorisierungs-Token für jede Anforderung zu öffnen, eine verbesserte Benutzerumgebung bereitzustellen. Für die Lambda-Proxy-Integration übergibt API Gateway das `context`-Objekt von einem Lambda-Genehmiger direkt an die Backend-Lambda-Funktion als Teil der Eingabe `event`. Sie können die `context`-Schlüssel-/Wert-Paare in der Lambda-Funktion durch den Aufruf von `$event.requestContext.authorizer.key` abrufen. `{api-key}` steht für einen API-Schlüssel im Nutzungsplan der API-Stufe. Weitere Informationen finden Sie unter [Nutzungspläne und API-Schlüssel für REST APIs in API Gateway](api-gateway-api-usage-plans.md). Im Folgenden wird die Beispielausgabe aus dem Beispiel-Lambda-Genehmiger gezeigt. Die Beispielausgabe enthält eine Richtlinienanweisung zum Blockieren (`Deny`) von `GET` Methodenaufrufen für die `dev` Phase einer API (`ymy8tbxw7b`) eines AWS Accounts (). `123456789012` ------ #### [ JSON ] **** ``` { "principalId": "user", "policyDocument": { "Version":"2012-10-17", "Statement": [ { "Action": "execute-api:Invoke", "Effect": "Deny", "Resource": "arn:aws:execute-api:us-west-2:123456789012:ymy8tbxw7b/dev/GET/" } ] } } ``` ------ # Aufruf einer API mit einem API Gateway-Lambda-Genehmiger Nachdem Sie den Lambda-Genehmiger (früher als benutzerdefinierter Genehmiger bezeichnet) konfiguriert und die API bereitgestellt haben, sollten Sie die API mit aktiviertem Lambda-Genehmiger testen. Dazu benötigen Sie einen REST-Client, z. B. cURL oder [Postman](https://www.postman.com/). In den folgenden Beispielen verwenden wir Postman. **Anmerkung** **Beim Aufrufen einer autorisiererfähigen Methode protokolliert API Gateway den Aufruf nicht, CloudWatch wenn das erforderliche Token für den `TOKEN` Authorizer nicht gesetzt ist, Null ist oder durch den angegebenen Token-Validierungsausdruck ungültig gemacht wird.** Ebenso protokolliert API Gateway den Aufruf nicht, CloudWatch wenn eine der erforderlichen Identitätsquellen für den `REQUEST` Autorisierer nicht festgelegt, Null oder leer ist. Nachfolgend zeigen wir, wie Sie Postman verwenden, um mit einem Lambda-`TOKEN`-Genehmiger die API aufzurufen oder zu testen. Die Methode kann für das Aufrufen einer API mit einem Lambda-`REQUEST`-Genehmiger angewendet werden, wenn Sie den erforderlichen Parameter für Pfad, Header oder Abfragezeichenfolge explizit angeben. **Aufrufen einer API mit dem benutzerdefinierten `TOKEN` Genehmiger** 1. Öffnen Sie **Postman**, wählen Sie die **GET**-Methode aus und fügen Sie die **Invoke URL** der API im benachbarten URL-Feld ein. Fügen Sie den Lambda-Genehmiger-Token-Header hinzu und setzen Sie den Wert auf `allow`. Wählen Sie **Send (Senden)** aus. ![\[API mit Lambda-Genehmiger-Token "allow" aufrufen\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/custom-auth-call-api-with-allow-token.png) Die Antwort zeigt, dass der API Gateway-Lambda-Genehmiger die Antwort **200 OK** zurückgibt und den Aufruf erfolgreich für den Zugriff auf den mit der Methode integrierten HTTP-Endpunkt (http://httpbin.org/get) autorisiert. 1. Ändern Sie in Postman den Lambda-Autorisierungstoken-Header-Wert in `deny`. Wählen Sie **Send (Senden)** aus. ![\[API mit Lambda-Autorisierungs-Token "deny" aufrufen\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/custom-auth-call-api-with-deny-token.png) Die Antwort zeigt, dass der API Gateway-Lambda-Genehmiger die Antwort **403 Forbidden** zurückgibt, ohne den Aufruf zum Zugriff auf den HTTP-Endpunkt zu autorisieren. 1. Ändern Sie in Postman den Wert des Lambda-Autorisierungstoken-Headers in `unauthorized` und wählen Sie **Send (Senden)**. ![\[API mit Lambda-Autorisierungs-token "unauthorized" aufrufen\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/custom-auth-call-api-with-unauthorized-token.png) Die Antwort zeigt, dass API Gateway die Antwort **401 Unauthorized** zurückgibt, ohne den Aufruf zum Zugriff auf den HTTP-Endpunkt zu autorisieren. 1. Ändern Sie nun den Lambda-Genehmiger-Token-Header-Wert in `fail`. Wählen Sie **Send (Senden)** aus. ![\[API mit Lambda-Autorisierungs-Token "authorization fail" aufrufen\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/custom-auth-call-api-with-fail-token.png) Die Antwort zeigt, dass API Gateway die Antwort **500 Internal Server Error** zurückgibt, ohne den Aufruf zum Zugriff auf den HTTP-Endpunkt zu autorisieren. # Konfigurieren eines kontenübergreifenden API Gateway-Lambda-Genehmigers Sie können jetzt auch eine AWS Lambda Funktion aus einem anderen AWS Konto als API-Autorisierungsfunktion verwenden. Jedes Konto kann sich in jeder Region befinden, in der Amazon API Gateway verfügbar ist. Die Lambda-Autorisierungsfunktion kann Bearer-Token-Authentifizierungsstrategien wie OAuth SAML verwenden. Dies macht es einfach, eine zentrale Lambda-Autorisierungsfunktion zentral zu verwalten und über mehrere API Gateway gemeinsam zu nutzen. APIs In diesem Abschnitt zeigen wir, wie eine kontoübergreifende Lambda-Genehmigerfunktion mit der Amazon API Gateway-Konsole konfiguriert wird. Bei diesen Anweisungen wird davon ausgegangen, dass Sie bereits eine API-Gateway-API in einem AWS Konto und eine Lambda-Autorisierungsfunktion in einem anderen Konto haben. ## Kontoübergreifenden Lambda-Genehmiger mit der API Gateway-Konsole konfigurieren Melden Sie sich in der Amazon-API-Gateway-Konsole bei dem Konto an, in dem Ihre API enthalten ist, und gehen Sie wie folgt vor: 1. Wählen Sie Ihre API und dann im Hauptnavigationsbereich **Genehmiger**. 1. Wählen Sie **Genehmiger erstellen** aus. 1. Geben Sie unter **Name des Genehmigers** einen Namen für den Genehmiger ein. 1. Wählen Sie als **Genehmiger-Typ** **Lambda** aus. 1. Geben Sie für **Lambda-Funktion** den vollständigen ARN der Lambda-Genehmigerfunktion aus Ihrem zweiten Konto ein. **Anmerkung** Sie finden den ARN für Ihre Funktion in der Lambda-Konsole in der oberen rechten Ecke des Konsolenfensters. 1. Eine Warnung mit einer `aws lambda add-permission`-Befehlszeichenfolge wird angezeigt. Diese Richtlinie gewährt API Gateway die Berechtigung, die Genehmiger-Lambda-Funktion aufzurufen. Kopieren Sie den Befehl und speichern Sie ihn für später. Führen Sie den Befehl aus, nachdem Sie den Genehmiger erstellt haben. 1. Wählen Sie für **Lambda-Ereignisnutzlast** entweder **Token** für einen `TOKEN`-Genehmiger oder **Anfrage** für einen `REQUEST`-Genehmiger. 1. Abhängig von der Auswahl im vorherigen Schritt führen Sie einen der folgenden Schritte aus: 1. Gehen Sie für die Option **Token** wie folgt vor: + Geben Sie unter **Token-Quelle** den Header-Namen ein, der das Genehmigungstoken enthält. Der API-Client muss einen Header mit diesem Namen enthalten, um das Autorisierungs-Token an den Lambda-Genehmiger zu senden. + Geben Sie optional für die **Token-Validierung** eine Anweisung ein RegEx . API Gateway führt eine erste Überprüfung des eingegebenen Token für diesen Ausdruck an und ruft nach der erfolgreichen Validierung den Genehmiger auf. Dies trägt dazu bei, die Anzahl der Aufrufe Ihrer API zu reduzieren. + Um die vom Genehmiger generierte Genehmigungsrichtlinie zwischenzuspeichern, lassen Sie **Genehmigungs-Caching** aktiviert. Wenn ein Caching der Richtlinie aktiviert ist, können Sie den **TTL**-Wert ändern. Durch die Einstellung **TTL** = 0 wird das Richtlinien-Caching deaktiviert. Wenn das Richtlinien-Caching aktiviert ist, wird der unter **Token-Quelle** angegebene Header-Name zum Cache-Schlüssel. Wenn in der Anfrage mehrere Werte an diesen Header übergeben werden, werden alle Werte zum Cache-Schlüssel, wobei die Reihenfolge beibehalten wird. **Anmerkung** Die **TTL**-Standardwert ist 300 Sekunden. Der Höchstwert ist 3.600 Sekunden; dieses Limit kann nicht erhöht werden. 1. Für die Optionen **Request** machen Sie Folgendes: + Wählen Sie für **Identitätsquellen-Typ** einen Parametertyp aus. Die unterstützten Parametertypen sind `Header`, `Query string`, `Stage variable` und `Context`. Um weitere Identitätsquellen hinzuzufügen, wählen Sie **Parameter hinzufügen**. + Um die vom Genehmiger generierte Genehmigungsrichtlinie zwischenzuspeichern, lassen Sie **Genehmigungs-Caching** aktiviert. Wenn ein Caching der Richtlinie aktiviert ist, können Sie den **TTL**-Wert ändern. Durch die Einstellung **TTL** = 0 wird das Richtlinien-Caching deaktiviert. API Gateway verwendet die angegebenen Identitätsquellen als Cachingschlüssel für den Anfrageautorisierer. Wenn das Caching aktiviert ist, ruft API Gateway die Lambda-Funktion des Genehmigers erst auf, nachdem erfolgreich überprüft wurde, dass alle angegebenen Identitätsquellen zur Laufzeit vorhanden sind. Wenn eine angegebene Identitätsquelle fehlt, Null oder leer ist, gibt API Gateway eine `401 Unauthorized`-Antwort zurück, ohne die Lambda-Genehmigerfunktion aufzurufen. Wenn mehrere Identitätsquellen definiert sind, werden sie alle verwendet, um den Cache-Schlüssel des Genehmigers abzuleiten. Das Ändern von Teilen des Cache-Schlüssels bewirkt, dass der Genehmiger das im Cache befindliche Richtliniendokument verwirft und ein neues erstellt. Wenn in der Anfrage ein Header mit mehreren Werten übergeben wird, werden alle Werte Teil des Cache-Schlüssels, wobei die Reihenfolge beibehalten wird. + Wenn das Caching deaktiviert ist, ist es nicht erforderlich, eine Identitätsquelle anzugeben. **Anmerkung** Zum Aktivieren der Zwischenspeicherung muss der Genehmiger eine Richtlinie zurückgeben, die für alle Methoden einer API anwendbar ist. Um methodenspezifische Richtlinien durchzusetzen, können Sie **Genehmiger-Caching** deaktivieren. 1. Wählen Sie **Genehmiger erstellen** aus. 1. Fügen Sie die `aws lambda add-permission` Befehlszeichenfolge, die Sie in einem vorherigen Schritt kopiert haben, in ein AWS CLI Fenster ein, das für Ihr zweites Konto konfiguriert ist. Ersetzen Sie `AUTHORIZER_ID` durch die ID Ihres Genehmigers. Dadurch erhält Ihr erstes Konto Zugriff auf die Lambda-Genehmigerfunktion Ihres zweiten Kontos. # Zugriffssteuerung anhand der Attribute einer Identität mit Verified Permissions Mit Amazon Verified Permissions steuern Sie den Zugriff auf Ihre API-Gateway-API. Wenn Sie API Gateway mit Verified Permissions verwenden, wird ein Lambda-Genehmiger erstellt, der detaillierte Genehmigungsentscheidungen verwendet, um den Zugriff auf Ihre API zu steuern. Verified Permissions autorisiert Aufrufer nach einem Richtlinienspeicherschema, wobei die Cedar-Richtliniensprache verwendet wird, um detaillierte Berechtigungen für Anwendungsbenutzer zu definieren. Weitere Informationen finden Sie unter [Erstellen eines Richtlinienspeichers mit einer verbundenen API und einem Identitätsanbieter](https://docs.aws.amazon.com/verifiedpermissions/latest/userguide/getting-started-api-policy-store.html) im *Benutzerhandbuch zu Amazon Verified Permissions*. Verified Permissions unterstützt Amazon-Cognito-Benutzerpools oder OpenID-Connect-(OIDC)-Identitätsanbieter als Identitätsquellen. Verified Permissions setzt voraus, dass der Principal bereits identifiziert und authentifiziert wurde. Verifizierte Berechtigungen werden nur für regionales und Edge-optimiertes REST unterstützt. APIs ## Lambda-Genehmiger mit Verified Permissions erstellen Verified Permissions erstellt einen Lambda-Genehmiger, um festzustellen, ob ein Principal eine Aktion an Ihrer API ausführen darf. Sie erstellen die Cedar-Richtlinie, die Verified Permissions zur Ausführung seiner Autorisierungsaufgaben verwendet. Im Folgenden sehen Sie ein Beispiel für eine Cedar-Richtlinie, die den Zugriff auf den Aufruf einer API auf Basis des Amazon-Cognito-Benutzerpools `us-east-1_ABC1234` für die `developer`-Gruppe auf der `GET /users`-Ressource einer API erlaubt. Verified Permissions verifiziert die Gruppenmitgliedschaft, indem das Bearer-Token für die Identität des Anrufers analysiert wird. ``` permit( principal in MyAPI::UserGroup::"us-east-1_ABC1234|developer", action in [ MyAPI::Action::"get /users" ], resource ); ``` Optional kann Verified Permissions den Genehmiger an die Methoden Ihrer API anhängen. In Produktionsstufen Ihrer API empfehlen wir, Verified Permissions nicht zu erlauben, den Genehmiger für Sie anzuhängen. In der folgenden Liste sehen Sie, wie Sie Verified Permissions so konfigurieren, dass der Lambda-Genehmiger an die Methodenanforderung der Methoden Ihrer API angehängt oder nicht angehängt wird. **Genehmiger für Sie anhängen (AWS-Managementkonsole)** Wenn Sie in der Verified-Permissions-Konsole die Option **Richtlinienspeicher erstellen** auswählen, klicken Sie anschließend auf der Seite **App-Integration bereitstellen** auf **Jetzt**. **Genehmiger nicht für Sie anhängen (AWS-Managementkonsole)** Wenn Sie in der Verified-Permissions-Konsole die Option **Richtlinienspeicher erstellen** auswählen, klicken Sie anschließend auf der Seite **App-Integration bereitstellen** auf **Später**. Verified Permissions erstellt weiterhin einen Lambda-Genehmiger für Sie. Der Lambda-Genehmiger beginnt mit `AVPAuthorizerLambda-`. Weitere Anleitungen zum Anhängen Ihres Genehmigers an eine Methode finden Sie unter [Konfigurieren einer Methode für die Verwendung eines Lambda-Genehmigers (Konsole)](configure-api-gateway-lambda-authorization.md#configure-api-gateway-lambda-authorization-method-console). **Genehmiger für Sie anhängen (CloudFormation)** Stellen Sie in der von Verified Permissions generierten CloudFormation Vorlage im `Conditions` Abschnitt auf ein. `"Ref": "shouldAttachAuthorizer"` `true` **Genehmiger nicht für Sie anhängen (CloudFormation)** Stellen Sie in der von Verified Permissions generierten CloudFormation Vorlage im Abschnitt den Wert auf ein. `Conditions` `"Ref": "shouldAttachAuthorizer"` `false` Verified Permissions erstellt weiterhin einen Lambda-Genehmiger für Sie. Der Lambda-Genehmiger beginnt mit `AVPAuthorizerLambda-`. Weitere Anleitungen zum Anhängen Ihres Genehmigers an eine Methode finden Sie unter [Konfigurieren einer Methode für die Verwendung eines Lambda-Genehmigers (AWS CLI)](configure-api-gateway-lambda-authorization.md#configure-api-gateway-lambda-authorization-method-cli). ## Lambda-Genehmiger mit Verified Permissions aufrufen Sie können Ihren Lambda-Genehmiger aufrufen, indem Sie im `Authorization`-Header ein Identitäts- oder Zugriffstoken angeben. Weitere Informationen finden Sie unter [Aufruf einer API mit einem API Gateway-Lambda-Genehmiger](call-api-with-api-gateway-lambda-authorization.md). API Gateway speichert die Richtlinie, die Ihr Lambda-Genehmiger zurückgibt, 120 Sekunden lang im Cache. Sie können die TTL in der API-Gateway-Konsole oder mithilfe von AWS CLIändern.