Configurer les intégrations personnalisées Lambda dans Gateway API

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

Utilisez l’un des exemples de fonctions Lambda suivants :

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 référençons cette fonction en utilisant les éléments suivants ARN :


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

Une fois la fonction Lambda définie dans le backend, procédez à la configuration du. API

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

Appelez la create-rest-api commande pour créer un API :


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

Notez la id valeur (te6si5ach7) API du résultat dans la réponse :


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

Vous en avez besoin API id tout au long de cette section.

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.
Appelez create-resource pour créer une ressource de API passerelle de /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.

Appelez put-method pour créer une demande de API méthode de 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 API méthode permet au client de recevoir un message d'accueil de la part de la fonction Lambda au niveau du backend. Le paramètre greeter est facultatif, car le backend doit gérer soit un appelant anonyme, soit un appelant auto-identifié.

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

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 traduit le paramètre de chaîne de greeter requête en greeter propriété de la JSON charge utile. 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 HTTP méthode de POST pour la demande d'intégration, conformément à la spécification de l'action de service Lambda pour les invocations de fonctions. Le uri paramètre est celui ARN de l'action invoquant la 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 IAM rôle de apigAwsProxyRole doit disposer de politiques permettant au apigateway service d'invoquer des fonctions Lambda. Au lieu de fournir un IAM rôle pourcredentials, 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.
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"
}
```

Appelez create-deployment pour déployer le API sur une test scène :


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

Testez le API à l'aide de la URL commande c 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'

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Configuration d'une ressource proxy avec intégration de proxy Lambda avec une définition ouverte API

Configuration d'un appel asynchrone de la fonction Lambda du backend

Configurer les intégrations personnalisées Lambda dans Gateway API

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

Important