Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Choisissez un didacticiel AWS Lambda d'intégration
<a name="getting-started-with-lambda-integration"></a>

 Pour créer une API avec des intégrations Lambda, vous pouvez utiliser l’intégration de proxy Lambda ou l’intégration Lambda autre que de proxy. 

Dans l’intégration de proxy Lambda, l’entrée de la fonction Lambda peut être exprimée sous la forme d’une combinaison d’en-têtes de demande, de variables de chemin d’accès, de paramètres de chaîne de requête, d’un corps et de données de configuration d’API. Vous n’avez qu’à choisir une fonction Lambda. API Gateway configure automatiquement la demande d’intégration et la réponse d’intégration. Une fois configurée, votre méthode d’API peut évoluer sans avoir à modifier les paramètres existants. Cette possibilité est due au fait que la fonction Lambda du backend analyse les données des demandes entrantes et répond au client.

Dans l’intégration Lambda autre que de proxy, vous devez vous assurer que les entrées de la fonction Lambda sont fournies en tant que charge utile de la demande d’intégration. Vous devez mapper toutes les données d’entrée que le client a fournies comme paramètres de demande au corps de la demande d’intégration appropriée. Vous pouvez également avoir besoin de traduire le corps de la demande fournie par le client en un format reconnu par la Fonction Lambda. 

Dans le cadre d’une intégration de proxy Lambda ou d’une intégration Lambda sans proxy, vous pouvez utiliser une fonction Lambda dans un compte différent de celui sur lequel vous avez créé votre API.

**Topics**
+ [Didacticiel : création d’une API REST avec une intégration de proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md)
+ [Didacticiel : création d’une API REST avec une intégration Lambda sans proxy](getting-started-lambda-non-proxy-integration.md)
+ [Didacticiel : création d’une API REST Gateway avec une intégration de proxy Lambda entre comptes](apigateway-cross-account-lambda-integrations.md)

# Didacticiel : création d’une API REST avec une intégration de proxy Lambda
<a name="api-gateway-create-api-as-simple-proxy-for-lambda"></a>

L’[intégration de proxy Lambda](set-up-lambda-proxy-integrations.md) est un type d’intégration d’API avec API Amazon Gateway léger et flexible qui permet d’intégrer une méthode d’API, ou une API complète, avec une fonction Lambda. La fonction Lambda peut être écrite dans [n’importe quelle langue prise en charge par Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). Puisqu’il s’agit d’une intégration de proxy, vous pouvez modifier la mise en œuvre de la fonction Lambda à tout moment, sans avoir à redéployer votre API.

Dans ce didacticiel, vous allez effectuer les opérations suivantes :
+ Créer une fonction Lambda « Hello, World\$1 » pour être le backend de l’API.
+ Créer et tester une API « Hello, World\$1 » avec intégration de proxy Lambda.

**Topics**
+ [Création d’une fonction Lambda « Hello, World\$1 »](#api-gateway-proxy-integration-create-lambda-backend)
+ [Création d’une API « Hello, World\$1 »](#api-gateway-create-api-as-simple-proxy-for-lambda-build)
+ [Déploiement et test de l’API](#api-gateway-create-api-as-simple-proxy-for-lambda-test)

## Création d’une fonction Lambda « Hello, World\$1 »
<a name="api-gateway-proxy-integration-create-lambda-backend"></a>

**Pour créer une fonction Lambda « Hello, World\$1 » dans la console Lambda**

1. [Connectez-vous à la console Lambda à l'adresse /lambda. https://console.aws.amazon.com](https://console.aws.amazon.com/lambda)

1. Dans la barre AWS de navigation, choisissez un [Région AWS](https://docs.aws.amazon.com/general/latest/gr/apigateway.html).
**Note**  
Notez la région où vous avez créé la fonction Lambda. Vous en aurez besoin lors de la création de l’API.

1. Choisissez **Fonctions** dans le panneau de navigation.

1. Choisissez **Créer une fonction**.

1. Choisissez **Créer à partir de zéro**.

1. Sous **Informations de base**, procédez comme suit :

   1. Sous **Nom de la fonction**, entrez **GetStartedLambdaProxyIntegration**.

   1. Pour **Exécution**, choisissez le dernier environnement d’exécution **Node.js** ou **Python** compatible.

   1. Pour **Architecture**, conservez le paramètre par défaut.

   1. Sous **Permissions** (Autorisations), développez **Change default execution role** (Modifier le rôle d’exécution par défaut). Dans la liste déroulante **Rôle d’exécution**, choisissez **Créer un nouveau rôle à partir de modèles de politique AWS **.

   1. Sous **Nom du rôle**, entrez **GetStartedLambdaBasicExecutionRole**.

   1. Laissez vide le champ **Modèles de politique**.

   1. Choisissez **Créer une fonction**.

1. Sous **Code de fonction**, dans l'éditeur de code en ligne, copy/paste le code suivant :

------
#### [ Node.js ]

   ```
   export const handler = async(event, context) => {
       console.log('Received event:', JSON.stringify(event, null, 2));
       var res ={
           "statusCode": 200,
           "headers": {
               "Content-Type": "*/*"
           }
       };
       var greeter = 'World';
       if (event.greeter && event.greeter!=="") {
           greeter =  event.greeter;
       } else if (event.body && event.body !== "") {
           var body = JSON.parse(event.body);
           if (body.greeter && body.greeter !== "") {
               greeter = body.greeter;
           }
       } else if (event.queryStringParameters && event.queryStringParameters.greeter && event.queryStringParameters.greeter !== "") {
           greeter = event.queryStringParameters.greeter;
       } else if (event.multiValueHeaders && event.multiValueHeaders.greeter && event.multiValueHeaders.greeter != "") {
           greeter = event.multiValueHeaders.greeter.join(" and ");
       } else if (event.headers && event.headers.greeter && event.headers.greeter != "") {
           greeter = event.headers.greeter;
       } 
       res.body = "Hello, " + greeter + "!";
       return res
   };
   ```

------
#### [ Python ]

   ```
   import json
   
   
   def lambda_handler(event, context):
       print(event)
   
       greeter = 'World'
   
       try:
           if (event['queryStringParameters']) and (event['queryStringParameters']['greeter']) and (
                   event['queryStringParameters']['greeter'] is not None):
               greeter = event['queryStringParameters']['greeter']
       except KeyError:
           print('No greeter')
   
       try:
           if (event['multiValueHeaders']) and (event['multiValueHeaders']['greeter']) and (
                   event['multiValueHeaders']['greeter'] is not None):
               greeter = " and ".join(event['multiValueHeaders']['greeter'])
       except KeyError:
           print('No greeter')
   
       try:
           if (event['headers']) and (event['headers']['greeter']) and (
                   event['headers']['greeter'] is not None):
               greeter = event['headers']['greeter']
       except KeyError:
           print('No greeter')
   
       if (event['body']) and (event['body'] is not None):
           body = json.loads(event['body'])
           try:
               if (body['greeter']) and (body['greeter'] is not None):
                   greeter = body['greeter']
           except KeyError:
               print('No greeter')
   
       res = {
           "statusCode": 200,
           "headers": {
               "Content-Type": "*/*"
           },
           "body": "Hello, " + greeter + "!"
       }
   
       return res
   ```

------

1. Choisissez **Deploy (Déployer)**.

## Création d’une API « Hello, World\$1 »
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-build"></a>

Maintenant, créez une API pour votre fonction Lambda « Hello, World \$1 » à l’aide de la console API Gateway.

**Pour créer une API « Hello, World\$1 »**

1. Connectez-vous à la console API Gateway à l'adresse [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)

1. Si vous utilisez API Gateway pour la première fois, vous voyez une page qui vous présente les fonctions du service. Sous **REST API (API REST)**, choisissez **Build (Création)**. Lorsque la fenêtre contextuelle **Create Example API (Créer API exemple)** s’affiche, cliquez sur **OK**.

   Si ce n’est pas la première fois que vous utilisez API Gateway, choisissez **Create API (Créer une API)**. Sous **REST API (API REST)**, choisissez **Build (Création)**.

1.  Sous **API name (Nom de l’API)**, saisissez **LambdaProxyAPI**.

1. (Facultatif) Sous **Description**, entrez une description.

1. Laissez **Type de point de terminaison d’API** défini sur **Régional**.

1. Pour le **type d'adresse IP**, sélectionnez **IPv4**.

1. Sélectionnez **Create API** (Créer une API).

Une fois que vous avez créé une API, vous créez une ressource. En règle générale, les ressources API sont organisées dans une arborescence des ressources selon la logique de l’application. Pour cet exemple, vous créez une ressource **/helloworld**. 

**Pour créer une ressource**

1. Choisissez **Créer une ressource**.

1. Maintenez **Ressource proxy** désactivée. 

1. Conservez **Chemin de la ressource** sous la forme `/`.

1. Sous **Resource Name (Nom de la ressource)**, entrez **helloworld**.

1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.

1. Choisissez **Créer une ressource**.

 Dans une intégration de proxy, la totalité de la demande est envoyée à la fonction Lambda du backend en l’état, via une méthode `ANY` fourre-tout qui représente n’importe quelle méthode HTTP. La méthode HTTP concrète est spécifiée par le client au moment de l’exécution. La méthode `ANY` vous permet d’utiliser une seule configuration de méthode d’API pour toutes les méthodes HTTP prises en charge, `DELETE`, `GET`, `HEAD`, `OPTIONS`, `PATCH`, `POST` et `PUT`.

**Pour créer une méthode `ANY`**

1. Sélectionnez la ressource **/helloworld**, puis choisissez **Créer une méthode**.

1. Pour **Type de méthode**, sélectionnez **ANY**.

1. Pour **Type d’intégration**, sélectionnez **Fonction Lambda**.

1. Activez **Intégration de proxy Lambda**.

1. Pour la **fonction Lambda**, sélectionnez l' Région AWS endroit où vous avez créé votre fonction Lambda, puis entrez le nom de la fonction.

1. Pour utiliser la valeur de délai d’expiration par défaut de 29 secondes, gardez **Délai d’expiration** activé. Pour définir un délai d’expiration personnalisé, choisissez **Délai d’expiration** et entrez une valeur de délai d’expiration comprise entre `50` et `29000` millisecondes.

1. Choisissez **Créer une méthode**.

## Déploiement et test de l’API
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test"></a>

**Pour déployer votre API**

1. Sélectionnez **Deploy API (Déployer une API)**.

1. Pour **Étape**, sélectionnez **Nouvelle étape**.

1. Sous **Stage name (Nom de l’étape)**, entrez **test**.

1. (Facultatif) Sous **Description**, entrez une description.

1. Choisissez **Déployer**.

1. Sous **Détails de l’étape**, choisissez l’icône de copie pour copier l’URL d’invocation de votre API.

### Utilisation du navigateur et de cURL pour tester une API avec l’intégration de proxy Lambda
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test-curl"></a>

Pour tester votre API, vous pouvez utiliser un navigateur ou [cURL](https://curl.se/).

Pour tester les demandes `GET` en utilisant uniquement les paramètres de chaîne de requête, vous pouvez saisir l’URL de la ressource `helloworld` de l’API dans la barre d’adresse d’un navigateur. 

Pour créer l’URL de la ressource `helloworld` de l’API, ajoutez la ressource `helloworld` et le paramètre de chaîne de requête `?greeter=John` à votre URL d’invocation. Votre URL doit ressembler à ce qui suit :

```
https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John
```

Pour les autres méthodes, vous devez utiliser les utilitaires de test plus avancés de l’API REST, tels que [POSTMAN](https://www.postman.com/) ou [cURL](https://curl.se/). Dans ce didacticiel, on utilise cURL. Dans les exemples de commande cURL ci-dessous, on suppose que cURL est installé sur votre ordinateur.

**Pour tester l’API déployée à l’aide de cURL :**

1. Ouvrez une fenêtre du terminal.

1. Copiez la commande cURL suivante et collez-la dans la fenêtre du terminal, et remplacez l’URL d’invocation par celle que vous avez copiée à l’étape précédente et ajoutez **/helloworld** à la fin de l’URL.
**Note**  
Si vous exécutez la commande sous Windows, utilisez plutôt cette syntaxe :  

   ```
   curl -v -X POST "https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld" -H "content-type: application/json" -d "{ \"greeter\": \"John\" }"
   ```

   1. Pour appeler l’API avec le paramètre de chaîne de requête de `?greeter=John` :

      ```
      curl -X GET 'https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John'
      ```

   1. Pour appeler l’API avec un paramètre d’en-tête de `greeter:John` :

      ```
      curl -X GET https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
        -H 'content-type: application/json' \
        -H 'greeter: John'
      ```

   1. Pour appeler l’API avec un corps `{"greeter":"John"}` :

      ```
      curl -X POST https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
        -H 'content-type: application/json' \
        -d '{ "greeter": "John" }'
      ```

   Dans tous les cas, la sortie est une réponse 200 avec le corps de réponse suivant :

   ```
   Hello, John!
   ```

# Didacticiel : création d’une API REST avec une intégration Lambda sans proxy
<a name="getting-started-lambda-non-proxy-integration"></a>

Dans cette présentation, nous utilisons la console API Gateway pour créer une API qui permet à un client d’appeler des fonctions Lambda via l’intégration Lambda autre que de proxy (également désignée sous le nom d’intégration personnalisée). Pour en savoir plus sur AWS Lambda et les fonctions Lambda, consultez le [Guide du développeur AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/). 

Pour faciliter l’apprentissage, nous avons choisi une fonction Lambda simple avec une configuration d’API minimale pour vous guider à travers les étapes de création d’une API Amazon API Gateway avec l’intégration personnalisée Lambda. Lorsque nécessaire, nous décrivons un aspect de la logique. Pour un exemple plus détaillé de l’intégration personnalisée Lambda, consultez [Tutoriel : Création d'une API REST de calculatrice avec deux intégrations AWS de services et une intégration Lambda sans proxy](integrating-api-with-aws-services-lambda.md). 

Avant de créer l’API, configurez le backend Lambda en créant une fonction Lambda dans AWS Lambda, comme décrit ci-après.

**Topics**
+ [Création d’une fonction Lambda pour l’intégration Lambda autre que de proxy](#getting-started-new-lambda)
+ [Création d’une API avec l’intégration Lambda autre que de proxy](#getting-started-new-api)
+ [Test de l’appel de la méthode d’API](#getting-started-new-get)
+ [Déploiement de l’API](#getting-started-deploy-api)
+ [Test de l’API dans une phase de déploiement](#getting-started-test)
+ [Nettoyage](#getting-started-clean-up)

## Création d’une fonction Lambda pour l’intégration Lambda autre que de proxy
<a name="getting-started-new-lambda"></a>

**Note**  
La création de fonctions Lambda peut entraîner des frais sur votre AWS compte.

 Au cours de cette étape, vous allez créer une fonction Lambda de type « Hello, World \$1 » pour l’intégration Lambda personnalisée. Tout au long de cette procédure, la fonction est appelée `GetStartedLambdaIntegration`.

 La mise en œuvre de cette fonction Lambda `GetStartedLambdaIntegration` est la suivante : 

------
#### [ Node.js ]

```
'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];            
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];

export const handler = async(event) => {
  console.log(event);
  // Parse the input for the name, city, time and day property values
  let name = event.name === null || event.name === undefined || event.name === "" ? 'you' : event.name;
  let city = event.city === undefined ? 'World' : event.city;
  let time = times.indexOf(event.time)<0 ? 'day' : event.time;
  let day = days.indexOf(event.day)<0 ? null : event.day;

  // Generate a greeting
  let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
  if (day) greeting += 'Happy ' + day + '!';
  
  // Log the greeting to CloudWatch
  console.log('Hello: ', greeting);
  
  // Return a greeting to the caller
  return {"greeting": greeting}
};
```

------
#### [ Python ]

```
import json

days = {
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}


def lambda_handler(event, context):
    print(event)
    # parse the input for the name, city, time, and day property values
    name = event.get("name") or 'you'
    city = event.get("city") or 'World'
    try:
        if event['time'] in times:
            time = event['time']
        else:
            time = 'day'
    except KeyError:
        time = 'day'
    try:
        if event['day'] in days:
            day = event['day']
        else:
            day = ''
    except KeyError:
        day = ''
    # Generate a greeting
    greeting = 'Good ' + time + ', ' + name + ' of ' + \
        city + '.' + ['', ' Happy ' + day + '!'][day != '']
    # Log the greeting to CloudWatch
    print(greeting)

    # Return a greeting to the caller
    return {"greeting": greeting}
```

------

Pour l’intégration personnalisée Lambda, API Gateway transmet les entrées à la fonction Lambda depuis le client en tant que corps de la demande d’intégration. L’objet `event` du gestionnaire de la fonction Lambda correspond à l’entrée. 

Notre fonction Lambda est simple. Elle analyse l’objet `event` en entrée par rapport aux propriétés `name`, `city`, `time` et `day`. Elle renvoie ensuite un message d’accueil, en tant qu’objet JSON `{"message":greeting}`, à l’appelant. Le message suit le modèle `"Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!"`. Il est supposé que l’entrée de la fonction Lambda est l’objet JSON suivant : 

```
{
  "city": "...",
  "time": "...",
  "day": "...",
  "name" : "..."
}
```

Pour plus d’informations, consultez le [Manuel du développeur AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html). 

En outre, la fonction enregistre son exécution sur Amazon CloudWatch en appelant`console.log(...)`. Cet aspect est précieux pour suivre les appels lors du débogage de la fonction. Pour permettre à la `GetStartedLambdaIntegration` fonction d'enregistrer l'appel, définissez un rôle IAM avec des politiques appropriées pour que la fonction Lambda crée CloudWatch les flux et ajoute des entrées de journal aux flux. La console Lambda vous guide tout au long de la création des rôles et politiques IAM requis.

Si vous configurez l’API sans utiliser la console API Gateway, par exemple en [important une API depuis un fichier OpenAPI](https://github.com/aws-samples/api-gateway-secure-pet-store/blob/master/src/main/resources/swagger.yaml#L39), vous devez créer explicitement, si nécessaire, et configurer une politique et un rôle d’appel pour qu’API Gateway puisse appeler les fonctions Lambda. Pour plus d’informations sur la configuration des rôles d’appel et d’exécution Lambda pour une API Amazon API Gateway, consultez [Contrôle de l’accès à une API REST avec des autorisations IAM](permissions.md). 

 Par rapport à `GetStartedLambdaProxyIntegration`, la fonction Lambda pour l’intégration de proxy Lambda, la fonction `GetStartedLambdaIntegration` Lambda pour l’intégration personnalisée Lambda prend uniquement les entrées du corps de la requête d’intégration d’API Amazon API Gateway. La fonction peut renvoyer une sortie sous forme d’un objet JSON, d’une chaîne, d’un nombre, d’une valeur booléenne ou même d’un blob binaire. La fonction Lambda de l’intégration de proxy Lambda, en revanche, peut accepter les entrées de toutes données de la demande, mais doit renvoyer en sortie un objet JSON particulier. La fonction `GetStartedLambdaIntegration` pour l’intégration personnalisée Lambda peut avoir comme entrées les paramètres de la demande d’API, à condition qu’API Gateway mappe les paramètres de la demande d’API au corps de demande d’intégration avant de transférer la demande du client au backend. Pour que cela se produise, le développeur de l’API doit créer un modèle de mappage et le configurer sur la méthode de l’API lors de la création de l’API. 

Maintenant, créez la fonction Lambda `GetStartedLambdaIntegration`. 

**Pour créer la fonction Lambda `GetStartedLambdaIntegration` pour l’intégration personnalisée Lambda**

1. Ouvrez la AWS Lambda console à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Effectuez l’une des actions suivantes :
   + Si la page de bienvenue s’affiche, choisissez **Get Started Now (Commencer maintenant)** puis **Create function (Créer une fonction)**.
   + Si la liste **Lambda > Functions (Fonctions)** apparaît, choisissez **Create function (Créer une fonction)**.

1. Choisissez **Créer à partir de zéro**. 

1. Dans le volet **Author from scratch (Créer à partir de zéro)**, procédez comme suit :

   1. Dans **Name (Nom)**, entrez **GetStartedLambdaIntegration** comme nom de la fonction Lambda.

   1. Pour **Exécution**, choisissez le dernier environnement d’exécution **Node.js** ou **Python** compatible.

   1. Pour **Architecture**, conservez le paramètre par défaut.

   1. Sous **Permissions** (Autorisations), développez **Change default execution role** (Modifier le rôle d’exécution par défaut). Dans la liste déroulante **Rôle d’exécution**, choisissez **Créer un nouveau rôle à partir de modèles de politique AWS **.

   1. Pour **Role name (Nom du rôle)**, indiquez le nom de votre rôle, par exemple **GetStartedLambdaIntegrationRole**.

   1. Pour **Policy templates (Modèles de politique)**, choisissez **Simple microservice permissions (Autorisations Microservice simples)**.

   1. Choisissez **Créer une fonction**.

1. Dans le volet **Configure function (Configurer la fonction)**, sous **Function code (Code de la fonction)**, suivez les étapes suivantes :

   1. Copiez le code de la fonction Lambda affiché au début de cette section et collez-le dans l’éditeur de code en ligne.

   1. Acceptez les choix par défaut pour tous les autres champs de cette section.

   1. Choisissez **Deploy (Déployer)**.

1. Pour tester la fonction nouvellement créée, cliquez sur l’onglet **Test**.

   1. Dans **Event name** (Nom de l’événement), saisissez **HelloWorldTest**. 

   1. Pour **JSON d’événement**, remplacez le code par défaut par le code suivant.

      ```
      {
        "name": "Jonny",
        "city": "Seattle",
        "time": "morning",
        "day": "Wednesday"
      }
      ```

   1.  Sélectionnez **Test** pour appeler la fonction. La section **Execution result: succeeded** s’affiche. Développez **Détails** pour voir la sortie suivante.

      ```
      {
          "greeting": "Good morning, Jonny of Seattle. Happy Wednesday!"
      }
      ```

      La sortie est également écrite dans CloudWatch Logs. 

 À titre d’exercice, vous pouvez utiliser la console IAM pour afficher le rôle IAM (`GetStartedLambdaIntegrationRole`) créé dans le cadre de la création de la fonction Lambda. Deux politiques en ligne sont attachées à ce rôle IAM. L’une stipule les autorisations les plus élémentaires pour l’exécution Lambda. Cela permet d'appeler toutes CloudWatch `CreateLogGroup` les CloudWatch ressources de votre compte dans la région où la fonction Lambda est créée. Cette politique permet également de créer les CloudWatch flux et de consigner les événements pour la fonction `GetStartedLambdaIntegration` Lambda. 

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:us-east-1:111111111111:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:us-east-1:111111111111:log-group:/aws/lambda/GetStartedLambdaIntegration:*"
            ]
        }
    ]
}
```

------

L'autre document de politique s'applique à l'appel d'un autre AWS service qui n'est pas utilisé dans cet exemple. Vous pouvez l’ignorer pour l’instant. 

 Associée au rôle IAM se trouve une entité de confiance, qui est `lambda.amazonaws.com`. Voici la relation d’approbation : 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

------

 La combinaison de cette relation de confiance et de la politique intégrée permet à la fonction Lambda d'appeler `console.log()` une fonction pour consigner les événements CloudWatch dans Logs. 

## Création d’une API avec l’intégration Lambda autre que de proxy
<a name="getting-started-new-api"></a>

 Avec la fonction Lambda (`GetStartedLambdaIntegration`) créée et testée, vous êtes prêt à exposer la fonction via une API Amazon API Gateway. À des fins d’illustration, nous exposons la fonction Lambda avec une méthode HTTP générique. Nous utilisons le corps de la demande, une variable de chemin d’URL, une chaîne de requête et un en-tête pour recevoir les données d’entrée requises du client. Nous activons le validateur de demande API Gateway pour l’API afin de garantir que toutes les données requises sont correctement définies et spécifiées. Nous configurons un modèle de mappage pour qu’API Gateway transforme les données de la demande fournie par le client au format valide comme requis par la fonction Lambda du backend.

**Pour créer une API avec une intégration Lambda autre que de proxy**

1. Connectez-vous à la console API Gateway à l'adresse [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)

1. Si vous utilisez API Gateway pour la première fois, vous voyez une page qui vous présente les fonctions du service. Sous **REST API (API REST)**, choisissez **Build (Création)**. Lorsque la fenêtre contextuelle **Create Example API (Créer API exemple)** s’affiche, cliquez sur **OK**.

   Si ce n’est pas la première fois que vous utilisez API Gateway, choisissez **Create API (Créer une API)**. Sous **REST API (API REST)**, choisissez **Build (Création)**.

1.  Sous **API name (Nom de l’API)**, saisissez **LambdaNonProxyAPI**.

1. (Facultatif) Sous **Description**, entrez une description.

1. Laissez **Type de point de terminaison d’API** défini sur **Régional**.

1. Pour le **type d'adresse IP**, sélectionnez **IPv4**.

1. Sélectionnez **Create API** (Créer une API).

Après avoir créé votre API, vous créez une ressource **/\$1city\$1**. Ceci est un exemple de ressource avec une variable de chemin qui accepte une entrée du client. Par la suite, vous mapperez cette variable de chemin avec l’entrée de la fonction Lambda à l’aide d’un modèle de mappage.

**Pour créer une ressource**

1. Choisissez **Créer une ressource**.

1. Maintenez **Ressource proxy** désactivée. 

1. Conservez **Chemin de la ressource** sous la forme `/`.

1. Sous **Resource Name (Nom de la ressource)**, entrez **\$1city\$1**.

1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.

1. Choisissez **Créer une ressource**.

Après avoir créé votre ressource **/\$1city\$1**, vous créez une méthode `ANY`. Le verbe HTTP `ANY` est un espace réservé pour une méthode HTTP valide qu’un client soumet au moment de l’exécution. Cet exemple montre que la méthode `ANY` peut être utilisée pour l’intégration personnalisée Lambda aussi bien que pour l’intégration de proxy Lambda.

**Pour créer une méthode `ANY`**

1. Sélectionnez la ressource **/\$1city\$1**, puis choisissez **Créer une méthode**.

1. Pour **Type de méthode**, sélectionnez **ANY**.

1. Pour **Type d’intégration**, sélectionnez **Fonction Lambda**.

1. Maintenez **Intégration proxy Lambda** désactivée.

1. Pour la **fonction Lambda**, sélectionnez l' Région AWS endroit où vous avez créé votre fonction Lambda, puis entrez le nom de la fonction.

1. Choisissez **Paramètres de requête de méthode**.

   À présent, vous allez activer un valideur de requête pour une variable de chemin d’URL, un paramètre de chaîne de requête et un en-tête afin de vous assurer que toutes les données requises sont définies. Dans cet exemple, vous créez un paramètre de chaîne de requête `time` et un en-tête `day`. 

1. Pour **Validateur de requête**, sélectionnez **Valider les paramètres de chaîne de requête et les en-têtes**.

1. Choisissez **Paramètres de chaîne de requête d’URL** et procédez comme suit : 

   1. Sélectionnez **Add query string** (Ajouter une chaîne de requêtes).

   1. Pour **Nom**, saisissez **time**.

   1. Activez **Obligatoire**.

   1. Maintenez **Mise en cache** désactivée. 

1. Choisissez **En-têtes de requête HTTP** et procédez comme suit : 

   1. Sélectionnez **Add header**.

   1. Pour **Nom**, saisissez **day**.

   1. Activez **Obligatoire**.

   1. Maintenez **Mise en cache** désactivée. 

1. Choisissez **Créer une méthode**.

Après avoir activé un validateur de requête, vous configurez la requête d’intégration pour la méthode `ANY` en ajoutant un modèle de mappage corporel pour transformer la requête entrante en une charge utile JSON, comme l’exige la fonction Lambda du backend. 

**Pour configurer la requête d’intégration**

1. Dans l’onglet **Requête d’intégration**, sous **Paramètres de requête d’intégration**, choisissez **Modifier**.

1. Pour **Transmission du corps de requête**, sélectionnez **Lorsqu’aucun modèle n’est défini (recommandé)**.

1. Choisissez **Modèles de mappage**.

1. Sélectionnez **Add mapping template**.

1. Pour **Type de contenu**, entrez **application/json**.

1. Pour **Corps du modèle**, entrez le code suivant :

   ```
   #set($inputRoot = $input.path('$'))
   {
     "city": "$input.params('city')",
     "time": "$input.params('time')",
     "day":  "$input.params('day')",
     "name": "$inputRoot.callerName"
   }
   ```

1. Choisissez **Enregistrer**.

## Test de l’appel de la méthode d’API
<a name="getting-started-new-get"></a>

 La console API Gateway fournit une installation de test qui vous permet de tester l’appel de l’API avant qu’elle ne soit déployée. Vous utilisez la fonctionnalité Test de la console pour tester l’API en soumettant la demande suivante : 

```
POST /Seattle?time=morning
day:Wednesday

{
    "callerName": "John"
}
```

 Dans cette demande de test, vous allez définir `ANY` sur `POST` et `{city}` sur `Seattle`, attribuer `Wednesday` comme valeur de l’en-tête `day` et attribuer `"John"` comme valeur de `callerName`. 

**Pour tester la méthode `ANY`**

1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.

1. Pour **Type de méthode**, sélectionnez `POST`.

1. Pour **Chemin**, sous **city**, entrez **Seattle**.

1. Pour **Chaînes de requête**, saisissez **time=morning**.

1. Pour **En-têtes**, saisissez **day:Wednesday**.

1. Pour **Corps de la requête**, saisissez **\$1 "callerName": "John" \$1**.

1. Sélectionnez **Test**.

Vérifiez que la charge utile de la réponse retournée se présente comme suit :

```
{
  "greeting": "Good morning, John of Seattle. Happy Wednesday!"
}
```

Vous pouvez également consulter les journaux pour examiner comment API Gateway traite la demande et la réponse.

```
Execution log for request test-request
Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations: { "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-tag=test-request, Authorization=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid, X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs++ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
  "city": "Seattle",
  "time": "morning",
  "day": "Wednesday",
  "name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200
```

Les journaux présentent la demande entrante avant le mappage et la demande d’intégration après le mappage. Lorsqu’un test échoue, les journaux sont utiles pour évaluer si l’entrée d’origine est correcte ou si le modèle de mappage fonctionne correctement. 

## Déploiement de l’API
<a name="getting-started-deploy-api"></a>

 L’appel du test est une simulation et possède ses limites. Par exemple, il contourne tout mécanisme d’autorisation activé sur l’API. Pour tester l’exécution de l’API en temps réel, vous devez d’abord déployer l’API. Pour déployer une API, vous créez une phase afin de créer un instantané de l’API à ce moment-là. Le nom de la phase définit également le chemin de base après le nom d’hôte par défaut de l’API. La ressource racine de l’API est ajoutée après le nom de la phase. Lorsque vous modifiez l’API, vous devez la redéployer vers une phase nouvelle ou existante pour que les modifications prennent effet. 

**Pour déployer l’API sur une phase**

1. Sélectionnez **Deploy API (Déployer une API)**.

1. Pour **Étape**, sélectionnez **Nouvelle étape**.

1. Sous **Stage name (Nom de l’étape)**, entrez **test**.
**Note**  
L’entrée doit être du texte codé en UTF-8 (par exemple, non localisé).

1. (Facultatif) Sous **Description**, entrez une description.

1. Choisissez **Déployer**.

Sous **Détails de l’étape**, choisissez l’icône de copie pour copier l’URL d’invocation de votre API. Le modèle général de l’URL de base de l’API est `https://api-id.region.amazonaws.com/stageName`. Par exemple, l’URL de base de l’API (`beags1mnid`) créée dans la région `us-west-2` et déployée sur la phase `test` est `https://beags1mnid.execute-api.us-west-2.amazonaws.com/test`.

## Test de l’API dans une phase de déploiement
<a name="getting-started-test"></a>

Il existe plusieurs façons de tester une API déployée. Pour les requêtes GET n’utilisant que les variables de chemin d’URL ou les paramètres de chaîne de requête, vous pouvez saisir l’URL de la ressource d’API dans un navigateur. Pour les autres méthodes, vous devez utiliser les utilitaires de test plus avancés de l’API REST, tels que [POSTMAN](https://www.postman.com/) ou [cURL](https://curl.se/).

**Pour tester l’API à l’aide de cURL**

1. Ouvrez une fenêtre de terminal sur votre ordinateur local connecté à Internet.

1. Pour tester `POST /Seattle?time=evening`:

   Copiez la commande cURL suivante et collez-la dans la fenêtre du terminal.

   ```
   curl -v -X POST \
     'https://beags1mnid.execute-api.us-west-2.amazonaws.com/test/Seattle?time=evening' \
     -H 'content-type: application/json' \
     -H 'day: Thursday' \
     -H 'x-amz-docs-region: us-west-2' \
     -d '{
   	"callerName": "John"
   }'
   ```

   Vous devriez obtenir une réponse positive avec la charge utile suivante :

   ```
   {"greeting":"Good evening, John of Seattle. Happy Thursday!"}
   ```

   Si vous modifiez `POST` en `PUT` dans la demande de cette méthode, vous obtenez la même réponse.

## Nettoyage
<a name="getting-started-clean-up"></a>

Si vous n’avez plus besoin des fonctions Lambda que vous avez créées pour cette procédure, vous pouvez maintenant les supprimer. Vous pouvez également supprimer les ressources IAM associées.

**Avertissement**  
Si vous avez l’intention d’effectuer les autres procédures de cette série, ne supprimez pas le rôle d’exécution Lambda, ni le rôle d’appel Lambda. Si vous supprimez une fonction Lambda sur laquelle vous APIs comptez, elle ne APIs fonctionnera plus. La suppression d’une fonction Lambda ne peut pas être annulée. Si vous souhaitez utiliser à nouveau cette fonction Lambda, vous devez la recréer.  
Si vous supprimez une ressource IAM sur laquelle repose une fonction Lambda, cette fonction Lambda ne fonctionnera plus, et APIs toutes celles qui s'appuient sur cette fonction ne fonctionneront plus. La suppression d'une ressource IAM ne peut pas être annulée. Si vous souhaitez utiliser à nouveau cette ressource IAM, vous devez la recréer. 

**Pour supprimer la fonction Lambda**

1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Dans la liste des fonctions, choisissez **GetStartedLambdaIntegration**, **Actions**, puis **Delete function (Supprimer la fonction)**. A l’invite, sélectionnez à nouveau **Delete**.

**Pour supprimer les ressources IAM associées**

1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Dans le volet **Details**, sélectionnez **Roles**.

1. Dans la liste des rôles, choisissez **GetStartedLambdaIntegrationRole**, **Role Actions (Actions du rôle)**, puis **Delete Role (Supprimer le rôle)**. Suivez les étapes de la console pour supprimer le rôle.

# Didacticiel : création d’une API REST Gateway avec une intégration de proxy Lambda entre comptes
<a name="apigateway-cross-account-lambda-integrations"></a>

Vous pouvez désormais utiliser une AWS Lambda fonction d'un autre AWS compte comme backend d'intégration d'API. Chaque compte peut se trouver dans n’importe quelle région où Amazon API Gateway est disponible. Cela facilite la gestion centralisée et le partage des fonctions du backend Lambda entre plusieurs. APIs

Dans cette section, nous montrons comment configurer l’intégration de proxy Lambda entre comptes à l’aide de la console Amazon API Gateway.

## Création d’une API pour l’intégration Lambda entre comptes d’API Gateway
<a name="apigateway-cross-account-lambda-integrations-create-api"></a>

**Pour créer une API**

1. Connectez-vous à la console API Gateway à l'adresse [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)

1. Si vous utilisez API Gateway pour la première fois, vous voyez une page qui vous présente les fonctions du service. Sous **REST API (API REST)**, choisissez **Build (Création)**. Lorsque la fenêtre contextuelle **Create Example API (Créer API exemple)** s’affiche, cliquez sur **OK**.

   Si ce n’est pas la première fois que vous utilisez API Gateway, choisissez **Create API (Créer une API)**. Sous **REST API (API REST)**, choisissez **Build (Création)**.

1.  Sous **API name (Nom de l’API)**, saisissez **CrossAccountLambdaAPI**.

1. (Facultatif) Sous **Description**, entrez une description.

1. Laissez **Type de point de terminaison d’API** défini sur **Régional**.

1. Pour le **type d'adresse IP**, sélectionnez **IPv4**.

1. Sélectionnez **Create API** (Créer une API).

## Création d’une fonction d’intégration Lambda dans un autre compte
<a name="apigateway-cross-account-lambda-integrations-create-lambda-function"></a>

Maintenant, vous allez créer une fonction Lambda dans un compte différent de celui dans lequel vous avez créé l’exemple d’API.

**Création d’une fonction Lambda dans un autre compte**

1. Connectez-vous à la console Lambda dans un compte différent de celui dans lequel vous avez créé votre API Amazon API Gateway.

1. Choisissez **Créer une fonction**.

1. Choisissez **Créer à partir de zéro**.

1. Sous **Author from scratch**, effectuez les étapes suivantes :

   1. Pour **Nom de la fonction**, entrez un nom.

   1. Dans la liste déroulante **Exécution**, choisissez un environnement d’exécution Node.js pris en charge.

   1. Pour **Architecture**, conservez le paramètre par défaut.

   1. Sous **Permissions (Autorisations)**, développez **Choose or create an execution role (Choisir ou créer un rôle d’exécution)**. Vous pouvez créer un rôle ou choisir un rôle existant.

   1. Sélectionnez **Create function** pour continuer.

1. Faites défiler l’écran vers le bas jusqu’au volet **Function code** (Code de fonction).

1. Copiez et collez l’implémentation de la fonction Node.js depuis [Didacticiel : création d’une API REST avec une intégration de proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).

1. Choisissez **Deploy (Déployer)**.

1. Notez l’ARN complet de votre fonction (dans le coin supérieur droit du volet de la fonction Lambda). Vous en aurez besoin lors de la création de votre intégration Lambda entre comptes.

## Configuration de l’intégration Lambda entre comptes
<a name="apigateway-cross-account-lambda-integrations-create-integration2"></a>

Une fois que vous disposez d’une fonction d’intégration Lambda dans un autre compte, vous pouvez utiliser la console API Gateway pour l’ajouter à votre API dans votre premier compte.

**Note**  
Si vous configurez un mécanisme d’autorisation inter-compte entre régions, le `sourceArn` qui est ajouté à la fonction cible doit utiliser la région de la fonction, pas la région de l’API.

Une fois que vous avez créé une API, vous créez une ressource. En règle générale, les ressources API sont organisées dans une arborescence des ressources selon la logique de l’application. Pour cet exemple, vous créez une ressource **/helloworld**. 

**Pour créer une ressource**

1. Choisissez **Créer une ressource**.

1. Maintenez **Ressource proxy** désactivée. 

1. Conservez **Chemin de la ressource** sous la forme `/`.

1. Sous **Resource Name (Nom de la ressource)**, entrez **helloworld**.

1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.

1. Choisissez **Créer une ressource**.

Après avoir créé une ressource, vous créez une méthode `GET`. Vous intégrez la méthode `GET` avec une fonction Lambda dans un autre compte. 

**Pour créer une méthode `GET`**

1. Sélectionnez la ressource **/helloworld**, puis choisissez **Créer une méthode**.

1. Pour **Type de méthode**, sélectionnez **GET**.

1. Pour **Type d’intégration**, sélectionnez **Fonction Lambda**.

1. Activez **Intégration de proxy Lambda**.

1. Pour la **fonction Lambda**, entrez l’ARN complet de votre fonction Lambda à l’étape 1. 

   Dans la console Lambda, vous trouverez l’ARN de votre fonction dans le coin supérieur droit de la fenêtre de la console.

1. Lorsque vous entrez l’ARN, une chaîne de commande `aws lambda add-permission` apparaît. Cette politique permet d’accorder à votre premier compte l’accès à la fonction Lambda de votre second compte. Copiez et collez la chaîne de `aws lambda add-permission` commande dans une AWS CLI fenêtre configurée pour votre deuxième compte.

1. Choisissez **Créer une méthode**.

Vous pouvez afficher la politique de mise à jour de votre fonction dans la console Lambda.

**(Facultatif) Pour consulter votre politique mise à jour**

1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Choisissez votre fonction Lambda.

1. Choisissez **Permissions**.

   Vous devriez voir une politique `Allow` avec une clause `Condition` dans laquelle l’`AWS:SourceArn` est l’ARN de la méthode `GET` de votre API.