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**
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**