Configuration d'intégrations personnalisées Lambda dans API Gateway

Pour vous montrer comment configurer l'intégration personnalisée Lambda, nous créons une API API Gateway pour exposer la méthode GET /greeting?greeter={name} pour appeler une fonction Lambda. Utilisez l’un des exemples de fonctions Lambda suivants pour votre API.

Utilisez l’un des exemples de fonctions Lambda suivants :

Node.js

export const handler = function(event, context, callback) {
    var res ={
        "statusCode": 200,
        "headers": {
            "Content-Type": "*/*"
        }
    };
    if (event.greeter==null) {
        callback(new Error('Missing the required greeter parameter.'));
    } else if (event.greeter === "") {
        res.body = "Hello, World";
        callback(null, res);
    } else {
        res.body = "Hello, " + event.greeter +"!";
        callback(null, res);
    }
};

Python

import json


def lambda_handler(event, context):
    print(event)
    res = {
        "statusCode": 200,
        "headers": {
            "Content-Type": "*/*"
        }
    }

    if event['greeter'] == "":
        res['body'] = "Hello, World"
    elif (event['greeter']):
        res['body'] = "Hello, " + event['greeter'] + "!"
    else:
        raise Exception('Missing the required greeter parameter.')

    return res

La fonction répond avec un message "Hello, {name}!" si la valeur du paramètre greeter est une chaîne non vide. Elle renvoie un message "Hello, World!" si la valeur greeter est une chaîne vide. La fonction renvoie un message d'erreur "Missing the required greeter parameter." si le paramètre d'hôte n'est pas défini dans la demande entrante. Nous nommons la fonction HelloWorld.

Vous pouvez la créer dans la console Lambda ou à l'aide de la AWS CLI. Dans cette section, nous faisons référence à cette fonction avec l'ARN suivant :

arn:aws:lambda:us-east-1:123456789012:function:HelloWorld

Avec la fonction Lambda définie dans le backend, commencez à configurer l'API.

Pour configurer l'intégration personnalisée Lambda à l'aide du AWS CLI

1. Appelez la commande create-rest-api pour créer une API :

   aws apigateway create-rest-api --name 'HelloWorld (AWS CLI)' --region us-west-2

   Notez la valeur d'id (te6si5ach7) de l'API résultante dans la réponse :

   {
       "name": "HelloWorld (AWS CLI)", 
       "id": "te6si5ach7", 
       "createdDate": 1508461860
   }

   Vous avez besoin de l'id d'API tout au long de cette section.

2. Appelez la commande get-resources pour obtenir l'id de la ressource racine :

   aws apigateway get-resources --rest-api-id te6si5ach7 --region us-west-2

   La réponse positive est la suivante :

   {
       "items": [
           {
               "path": "/", 
               "id": "krznpq9xpg"
           }
       ]
   }

   Notez la valeur d'id de la ressource racine (krznpq9xpg). Vous en aurez besoin à l'étape suivante et ultérieurement.

3. Appelez create-resource pour créer une ressource API Gateway /greeting :

   aws apigateway create-resource --rest-api-id te6si5ach7 \
         --region us-west-2 \
         --parent-id krznpq9xpg \
         --path-part greeting

   La réponse positive est semblable à ce qui suit :

   {
       "path": "/greeting", 
       "pathPart": "greeting", 
       "id": "2jf6xt", 
       "parentId": "krznpq9xpg"
   }

   Notez la valeur d'id (2jf6xt) de la ressource greeting résultante. Vous en avez besoin pour créer une méthode dans la ressource /greeting à l'étape suivante.

4. Appelez put-method pour créer une demande de méthode d'API GET /greeting?greeter={name} :

   aws apigateway put-method --rest-api-id te6si5ach7 \
          --region us-west-2 \
          --resource-id 2jf6xt \
          --http-method GET \
          --authorization-type "NONE" \
          --request-parameters method.request.querystring.greeter=false

   La réponse positive est semblable à ce qui suit :

   {
       "apiKeyRequired": false, 
       "httpMethod": "GET", 
       "authorizationType": "NONE", 
       "requestParameters": {
           "method.request.querystring.greeter": false
       }
   }

   Cette méthode d'API permet au client de recevoir des salutations de la fonction Lambda au backend. Le paramètre greeter est facultatif, car le backend doit gérer soit un appelant anonyme, soit un appelant auto-identifié.

5. Appelez put-method-response pour configurer la réponse 200 OK à la demande de méthode GET /greeting?greeter={name} :

   aws apigateway put-method-response \
           --region us-west-2 \
           --rest-api-id te6si5ach7 \ 
           --resource-id 2jf6xt \
           --http-method GET \
           --status-code 200

6. Appelez put-integration pour configurer l'intégration de la méthode GET /greeting?greeter={name} avec une fonction Lambda nommée HelloWorld. La fonction répond à la demande par un message "Hello, {name}!" si le paramètre greeter est précisé, ou "Hello, World!" si le paramètre de chaîne de demande n'est pas défini.

   aws apigateway put-integration \
           --region us-west-2 \
           --rest-api-id te6si5ach7 \
           --resource-id 2jf6xt \
           --http-method GET \
           --type AWS \
           --integration-http-method POST \
           --uri arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:HelloWorld/invocations \
           --request-templates '{"application/json":"{\"greeter\":\"$input.params('greeter')\"}"}' \
           --credentials arn:aws:iam::123456789012:role/apigAwsProxyRole

   Le modèle de mappage fourni ici convertit le paramètre de chaîne de demande greeter en propriété greeter de la charge utile JSON. Ceci est nécessaire parce que l'entrée d'une fonction Lambda doit être exprimée dans le corps.

   Important

   Pour les intégrations Lambda, vous devez utiliser la méthode HTTP POST pour la demande d'intégration, conformément à la spécification de l'action de service Lambda pour les appels de fonction. Le paramètre uri est l'ARN de l'action d'appel de fonction.

   La sortie est similaire à ce qui suit :

   {
       "passthroughBehavior": "WHEN_NO_MATCH", 
       "cacheKeyParameters": [], 
       "uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:HelloWorld/invocations", 
       "httpMethod": "POST", 
       "requestTemplates": {
           "application/json": "{\"greeter\":\"$input.params('greeter')\"}"
       }, 
       "cacheNamespace": "krznpq9xpg", 
       "credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole", 
       "type": "AWS"
   }

   Le rôle IAM apigAwsProxyRole doit avoir des stratégies qui permettent au service apigateway d'appeler des fonctions Lambda. Plutôt que de préciser un rôle IAM pour credentials, vous pouvez appeler la commande add-permission pour ajouter des autorisations basées sur les ressources. C'est ainsi que la console API Gateway ajoute ces autorisations.

7. Appelez put-integration-response pour configurer la réponse d'intégration afin de transmettre la sortie de la fonction Lambda au client comme réponse de méthode 200 OK.

    aws apigateway put-integration-response \
           --region us-west-2 \
           --rest-api-id te6si5ach7 \
           --resource-id 2jf6xt \
           --http-method GET \
           --status-code 200 \
           --selection-pattern ""  
           

   En définissant le modèle de sélection sur une chaîne vide, la réponse 200 OK est la valeur par défaut.

   La réponse positive doit être semblable à ce qui suit :

    {
       "selectionPattern": "", 
       "statusCode": "200"
   }

8. Appelez create-deployment pour déployer l'API dans une étape de test :

   aws apigateway create-deployment --rest-api-id te6si5ach7 --stage-name test --region us-west-2 

9. Testez l'API à l'aide de la commande cURL suivante dans un terminal :

   curl -X GET 'https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/greeting?greeter=me' \
     -H 'authorization: AWS4-HMAC-SHA256 Credential={access_key}/20171020/us-west-2/execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date, Signature=f327...5751'