Création d’une fonction Lambda « Hello, World! »Création d’une API « Hello, World! »Déploiement et test de l’API

Didacticiel : création d’une API REST avec une intégration de proxy Lambda

L’intégration de proxy Lambda 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. 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! » pour être le backend de l’API.
Créer et tester une API « Hello, World! » avec intégration de proxy Lambda.

Rubriques

Création d’une fonction Lambda « Hello, World! »
Création d’une API « Hello, World! »
Déploiement et test de l’API

Création d’une fonction Lambda « Hello, World! »

Pour créer une fonction Lambda « Hello, World! » dans la console Lambda

Connectez-vous à la console Lambda à l'adresse /lambda. https://console.aws.amazon.com
Dans la barre AWS de navigation, choisissez un Région AWS.

Note
Notez la région où vous avez créé la fonction Lambda. Vous en aurez besoin lors de la création de l’API.
Choisissez Fonctions dans le panneau de navigation.
Choisissez Créer une fonction.
Choisissez Créer à partir de zéro.
Sous Informations de base, procédez comme suit :
1. Sous Nom de la fonction, entrez GetStartedLambdaProxyIntegration.
2. Pour Exécution, choisissez le dernier environnement d’exécution Node.js ou Python compatible.
3. Pour Architecture, conservez le paramètre par défaut.
4. 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 .
5. Sous Nom du rôle, entrez GetStartedLambdaBasicExecutionRole.
6. Laissez vide le champ Modèles de politique.
7. Choisissez Créer une fonction.

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

Choisissez Deploy (Déployer).

Création d’une API « Hello, World! »

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

Pour créer une API « Hello, World! »

Connectez-vous à la console API Gateway à l'adresse https://console.aws.amazon.com/apigateway.
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).
Sous API name (Nom de l’API), saisissez LambdaProxyAPI.
(Facultatif) Sous Description, entrez une description.
Laissez Type de point de terminaison d’API défini sur Régional.
Pour le type d'adresse IP, sélectionnez IPv4.
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

Choisissez Créer une ressource.
Maintenez Ressource proxy désactivée.
Conservez Chemin de la ressource sous la forme /.
Sous Resource Name (Nom de la ressource), entrez helloworld.
Maintenez CORS (Partage des ressources entre origines multiples) désactivé.
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`

Sélectionnez la ressource /helloworld, puis choisissez Créer une méthode.
Pour Type de méthode, sélectionnez ANY.
Pour Type d’intégration, sélectionnez Fonction Lambda.
Activez Intégration de proxy Lambda.
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.
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.
Choisissez Créer une méthode.

Déploiement et test de l’API

Pour déployer votre API

Sélectionnez Deploy API (Déployer une API).
Pour Étape, sélectionnez Nouvelle étape.
Sous Stage name (Nom de l’étape), entrez test.
(Facultatif) Sous Description, entrez une description.
Choisissez Déployer.
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

Pour tester votre API, vous pouvez utiliser un navigateur ou cURL.

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 ou cURL. 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 :

Ouvrez une fenêtre du terminal.
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'
```
2. 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'
```
3. 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!
```

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

Choix d’un didacticiel d’intégration Lambda

Didacticiel : création d’une API REST avec une intégration Lambda sans proxy