Controlla l'accesso HTTP APIs con gli AWS Lambda autorizzatori - Amazon API Gateway
Tipo di formato payloadFormato della risposta dell'autorizzazioneEsempio di funzioni di autorizzazione LambdaOrigini di identitàCaching delle risposte delle autorizzazioniCreare un'autorizzazione LambdaRisoluzione dei problemi relativi alle autorizzazioni Lambda

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Controlla l'accesso HTTP APIs con gli AWS Lambda autorizzatori

Utilizzi un autorizzatore Lambda per utilizzare una funzione Lambda per controllare l'accesso al tuo. HTTP API Quindi, quando un client chiama la tuaAPI, API Gateway richiama la tua funzione Lambda. APIGateway utilizza la risposta della tua funzione Lambda per determinare se il client può accedere alla tua. API

Tipo di formato payload

La versione del formato del payload dell'autorizzazione specifica il formato dei dati che API Gateway invia a un sistema di autorizzazione Lambda e il modo in cui Gateway API interpreta la risposta di Lambda. Se non si specifica una versione del formato di payload, utilizza la versione più recente per impostazione predefinita. AWS Management Console Se crei un autorizzatore Lambda utilizzando AWS CLI, o an AWS CloudFormation SDK, devi specificare un. authorizerPayloadFormatVersion I valori supportati sono 1.0 e 2.0.

Se hai bisogno di compatibilità con RESTAPIs, usa la versione. 1.0

Gli esempi seguenti mostrano la struttura di ogni tipo di formato payload.

2.0
{
  "version": "2.0",
  "type": "REQUEST",
  "routeArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request",
  "identitySource": ["user1", "123"],
  "routeKey": "$default",
  "rawPath": "/my/path",
  "rawQueryString": "parameter1=value1&parameter1=value2&parameter2=value",
  "cookies": ["cookie1", "cookie2"],
  "headers": {
    "header1": "value1",
    "header2": "value2"
  },
  "queryStringParameters": {
    "parameter1": "value1,value2",
    "parameter2": "value"
  },
  "requestContext": {
    "accountId": "123456789012",
    "apiId": "api-id",
    "authentication": {
      "clientCert": {
        "clientCertPem": "CERT_CONTENT",
        "subjectDN": "www.example.com",
        "issuerDN": "Example issuer",
        "serialNumber": "1",
        "validity": {
          "notBefore": "May 28 12:30:02 2019 GMT",
          "notAfter": "Aug  5 09:36:04 2021 GMT"
        }
      }
    },
    "domainName": "id.execute-api.us-east-1.amazonaws.com",
    "domainPrefix": "id",
    "http": {
      "method": "POST",
      "path": "/my/path",
      "protocol": "HTTP/1.1",
      "sourceIp": "IP",
      "userAgent": "agent"
    },
    "requestId": "id",
    "routeKey": "$default",
    "stage": "$default",
    "time": "12/Mar/2020:19:03:58 +0000",
    "timeEpoch": 1583348638390
  },
  "pathParameters": { "parameter1": "value1" },
  "stageVariables": { "stageVariable1": "value1", "stageVariable2": "value2" }
}
1.0
{
  "version": "1.0",
  "type": "REQUEST",
  "methodArn": "arn:aws:execute-api:us-east-1:123456789012:abcdef123/test/GET/request",
  "identitySource": "user1,123",
  "authorizationToken": "user1,123",
  "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"
  }
}

Formato della risposta dell'autorizzazione

Il tipo di formato del payload determina anche la struttura della risposta che deve essere restituita dalla funzione Lambda.

Risposta della funzione Lambda per il formato 1.0

Se scegli la versione del 1.0 formato, gli autorizzatori Lambda devono restituire una IAM politica che consenta o neghi l'accesso al percorso. API È possibile utilizzare la sintassi standard IAM della policy nella policy. Per esempi di policy IAM, consulta Controlla l'accesso per invocare un API. È possibile passare le proprietà del contesto alle integrazioni Lambda o ai log di accesso utilizzando $context.authorizer.property. L'oggetto context è facoltativo e claims è un segnaposto riservato che non può essere utilizzato come oggetto contesto. Per ulteriori informazioni, consulta Personalizzazione dei registri di HTTP API accesso.

{
  "principalId": "abcdef", // The principal user identification associated with the token sent by the client.
  "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": {
    "exampleKey": "exampleValue"
  }
}

Risposta della funzione Lambda per il formato 2.0

Se scegli la versione del 2.0 formato, puoi restituire un valore booleano o un IAM criterio che utilizza la sintassi standard dei IAM criteri dalla tua funzione Lambda. Per restituire un valore booleano, abilitare risposte semplici per l'autorizzazione. Negli esempi seguenti viene illustrato il formato in cui è necessario codificare il risultato restituito dalla funzione Lambda. L'oggetto context è facoltativo. È possibile passare le proprietà del contesto alle integrazioni Lambda o ai log di accesso utilizzando $context.authorizer.property. Per ulteriori informazioni, consulta Personalizzazione dei registri di HTTP API accesso.

Simple response
{
  "isAuthorized": true/false,
  "context": {
    "exampleKey": "exampleValue"
  }
}
IAM policy
{
  "principalId": "abcdef", // The principal user identification associated with the token sent by the client.
  "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": {
    "exampleKey": "exampleValue"
  }
}

Esempio di funzioni di autorizzazione Lambda

Le seguenti funzioni Lambda Node.js di esempio illustrano i formati di risposta richiesti che è necessario restituire dalla funzione Lambda per il tipo di formato del payload 2.0.

Simple response - Node.js
export const handler = async(event) => {
    let response = {
        "isAuthorized": false,
        "context": {
            "stringKey": "value",
            "numberKey": 1,
            "booleanKey": true,
            "arrayKey": ["value1", "value2"],
            "mapKey": {"value1": "value2"}
        }
    };
    
    if (event.headers.authorization === "secretToken") {
        console.log("allowed");
        response = {
            "isAuthorized": true,
            "context": {
                "stringKey": "value",
                "numberKey": 1,
                "booleanKey": true,
                "arrayKey": ["value1", "value2"],
                "mapKey": {"value1": "value2"}
            }
        };
    }

    return response;

};
Simple response - Python
import json


def lambda_handler(event, context):
    response = {
        "isAuthorized": False,
        "context": {
            "stringKey": "value",
            "numberKey": 1,
            "booleanKey": True,
            "arrayKey": ["value1", "value2"],
            "mapKey": {"value1": "value2"}
        }
    }

    try:
        if (event["headers"]["authorization"] == "secretToken"):
            response = {
                "isAuthorized": True,
                "context": {
                    "stringKey": "value",
                    "numberKey": 1,
                    "booleanKey": True,
                    "arrayKey": ["value1", "value2"],
                    "mapKey": {"value1": "value2"}
                }
            }
            print('allowed')
            return response
        else:
            print('denied')
            return response
    except BaseException:
        print('denied')
        return response
IAM policy - Node.js
export const handler = async(event) => {
  if (event.headers.authorization == "secretToken") {
    console.log("allowed");
    return {
      "principalId": "abcdef", // The principal user identification associated with the token sent by the client.
      "policyDocument": {
        "Version": "2012-10-17",
        "Statement": [{
          "Action": "execute-api:Invoke",
          "Effect": "Allow",
          "Resource": event.routeArn
        }]
      },
      "context": {
        "stringKey": "value",
        "numberKey": 1,
        "booleanKey": true,
        "arrayKey": ["value1", "value2"],
        "mapKey": { "value1": "value2" }
      }
    };
  }
  else {
    console.log("denied");
    return {
      "principalId": "abcdef", // The principal user identification associated with the token sent by the client.
      "policyDocument": {
        "Version": "2012-10-17",
        "Statement": [{
          "Action": "execute-api:Invoke",
          "Effect": "Deny",
          "Resource": event.routeArn
        }]
      },
      "context": {
        "stringKey": "value",
        "numberKey": 1,
        "booleanKey": true,
        "arrayKey": ["value1", "value2"],
        "mapKey": { "value1": "value2" }
      }
    };
  }
};
IAM policy - Python
import json


def lambda_handler(event, context):
    response = {
        # The principal user identification associated with the token sent by
        # the client.
        "principalId": "abcdef",
        "policyDocument": {
            "Version": "2012-10-17",
            "Statement": [{
                "Action": "execute-api:Invoke",
                "Effect": "Deny",
                "Resource": event["routeArn"]
            }]
        },
        "context": {
            "stringKey": "value",
            "numberKey": 1,
            "booleanKey": True,
            "arrayKey": ["value1", "value2"],
            "mapKey": {"value1": "value2"}
        }
    }

    try:
        if (event["headers"]["authorization"] == "secretToken"):
            response = {
                # The principal user identification associated with the token
                # sent by the client.
                "principalId": "abcdef",
                "policyDocument": {
                    "Version": "2012-10-17",
                    "Statement": [{
                        "Action": "execute-api:Invoke",
                        "Effect": "Allow",
                        "Resource": event["routeArn"]
                    }]
                },
                "context": {
                    "stringKey": "value",
                    "numberKey": 1,
                    "booleanKey": True,
                    "arrayKey": ["value1", "value2"],
                    "mapKey": {"value1": "value2"}
                }
            }
            print('allowed')
            return response
        else:
            print('denied')
            return response
    except BaseException:
        print('denied')
        return response

Origini di identità

È facoltativamente possibile specificare le origini di identità per un'autorizzazione Lambda. Le origini di identità specificano la posizione dei dati necessari per autorizzare una richiesta. Ad esempio, è possibile specificare i valori di intestazione o di stringa di query come origini di identità. Se si specificano le origini di identità, i client devono includerle nella richiesta. Se la richiesta del client non include le fonti di identità, API Gateway non richiama l'autorizzatore Lambda e il client riceve un errore. 401

La tabella seguente descrive le fonti di identità supportate per un autorizzatore Lambda.

Type

Esempio

Note
Valore intestazione $request.header.name I nomi delle intestazioni non fanno distinzione tra maiuscole e minuscole.
Valore della stringa di query $ request.querystring.name I nomi delle stringhe di query fanno distinzione tra maiuscole e minuscole.
Variabile di contesto $ contesto.variableName Valore di una variabile di contesto supportata.
Variabile di fase $stageVariables.variableName Il valore di una variabile di fase.

Caching delle risposte delle autorizzazioni

Puoi abilitare la memorizzazione nella cache per un autorizzatore Lambda specificando un. authorizerResultTtlInSeconds Quando la memorizzazione nella cache è abilitata per un autorizzatore, API Gateway utilizza le fonti di identità dell'autorizzatore come chiave della cache. Se un client specifica gli stessi parametri nelle fonti di identità all'interno del file configuratoTTL, API Gateway utilizza il risultato dell'autorizzazione memorizzato nella cache, anziché richiamare la funzione Lambda.

Per abilitare il caching, l'autorizzazione deve disporre di almeno un'origine di identità.

Se abiliti le risposte semplici per un autorizzatore, la risposta dell'autorizzatore consente o nega completamente tutte le API richieste che corrispondono ai valori di origine dell'identità memorizzati nella cache. Per autorizzazioni più granulari, disabilita le risposte semplici e restituisci una policy. IAM

Per impostazione predefinita, API Gateway utilizza la risposta dell'autorizzatore memorizzata nella cache per tutte le rotte di un utente API che utilizza l'autorizzatore. Per inserire nella cache le risposte per l'instradamento, aggiungere $context.routeKey alle origini di identità dell'autorizzazione.

Creare un'autorizzazione Lambda

Quando si crea un autorizzatore Lambda, si specifica la funzione Lambda da utilizzare per Gateway. API È necessario concedere a API Gateway l'autorizzazione a richiamare la funzione Lambda utilizzando la politica delle risorse della funzione o IAM un ruolo. Per questo esempio, aggiorniamo la politica delle risorse per la funzione in modo che conceda a API Gateway l'autorizzazione a richiamare la nostra funzione Lambda.

aws apigatewayv2 create-authorizer \
    --api-id abcdef123 \
    --authorizer-type REQUEST \
    --identity-source '$request.header.Authorization' \
    --name lambda-authorizer \ 
    --authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:my-function/invocations' \
    --authorizer-payload-format-version '2.0' \
    --enable-simple-responses

Il comando seguente concede a API Gateway l'autorizzazione a richiamare la funzione Lambda. Se API Gateway non dispone dell'autorizzazione per richiamare la funzione, i client ricevono un. 500 Internal Server Error

aws lambda add-permission \
    --function-name my-authorizer-function \
    --statement-id apigateway-invoke-permissions-abc123 \ 
    --action lambda:InvokeFunction \
    --principal apigateway.amazonaws.com \
    --source-arn "arn:aws:execute-api:us-west-2:123456789012:api-id/authorizers/authorizer-id"

Dopo aver creato un autorizzatore e concesso a API Gateway l'autorizzazione a richiamarlo, aggiorna il percorso per utilizzare l'autorizzatore.

aws apigatewayv2 update-route \
    --api-id abcdef123 \
    --route-id acd123 \
    --authorization-type CUSTOM \
    --authorizer-id def123

Risoluzione dei problemi relativi alle autorizzazioni Lambda

Se API Gateway non può richiamare l'autorizzatore Lambda o l'autorizzatore Lambda restituisce una risposta in un formato non valido, i client ricevono un. 500 Internal Server Error

Per risolvere gli errori, abilita la registrazione degli accessi per lo stage. API Includere la variabile di registrazione $context.authorizer.error nel formato di log.

Se i log indicano che API Gateway non è autorizzato a richiamare la tua funzione, aggiorna la politica delle risorse della funzione o fornisci un IAM ruolo per concedere a API Gateway l'autorizzazione a richiamare l'autorizzazione.

Se i log indicano che la funzione Lambda restituisce una risposta non valida, verificare che la funzione Lambda restituisca una risposta nel formato richiesto.