Tutorial: creare un'API REST con un'integrazione proxy Lambda

L'integrazione proxy Lambda è un tipo di integrazione API di API Gateway leggero e flessibile che permette di integrare un metodo API, o un'intera API, con una funzione Lambda. La funzione Lambda può essere scritta in qualsiasi linguaggio supportato da Lambda. Poiché si tratta di un'integrazione proxy, è possibile modificare l'implementazione della funzione Lambda in qualsiasi momento senza necessità di ridistribuire l'API.

In questo tutorial, esegui quanto indicato di seguito:

• Creazione di una funzione Lambda "Hello, World!" come back-end per l'API.

• Creazione e test di un'API "Hello World!" API con integrazione proxy Lambda.

Creazione di una funzione Lambda "Hello, World!" valida e completa

Per creare una funzione Lambda "Hello, World!" Funzione Lambda nella console Lambda

1. Accedere alla console Lambda all'indirizzo https://console.aws.amazon.com/lambda/.

2. Nella barra AWS di navigazione, scegli un Regione AWS.

   Nota

   Prendere nota della regione in cui si crea la funzione Lambda. Questa informazione sarà necessaria in fase di creazione dell'API.

3. Nel riquadro di navigazione scegliere Functions (Funzioni).

4. Selezionare Create function (Crea funzione).

5. Scegli Author from scratch (Crea da zero).

6. In Basic information (Informazioni di base) eseguire queste operazioni:

   1. In Function name (Nome funzione) immettere GetStartedLambdaProxyIntegration.

   2. Per Runtime, scegli l'ultimo runtime supportato di Node.js o di Python.

   3. In Autorizzazioni espandere Modifica ruolo di esecuzione predefinito. Nell'elenco a discesa Ruolo di esecuzione, scegli Crea nuovo ruolo dai modelli di policy AWS .

   4. In Role name (Nome ruolo) immettere GetStartedLambdaBasicExecutionRole.

   5. Lasciare il campo Policy templates (Modelli di policy) vuoto.

   6. Selezionare Create function (Crea funzione).

7. In Function code (Codice funzione), nell'editor di codice inline, copiare/incollare il codice seguente:

   Node.js

   export const handler = function(event, context, callback) {
       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 + "!";
       callback(null, 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

8. Selezionare Deploy (Distribuisci).

Creazione di una funzione Lambda "Hello, World!" API

Viene ora creata un'API per la funzione Lambda "Hello, World!" utilizzando la console API Gateway.

Per creare una funzione Lambda "Hello, World!" API

1. Accedere alla console API Gateway all'indirizzo https://console.aws.amazon.com/apigateway.

2. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In API REST, scegliere Crea. Quando appare il popup Create Example API (Crea API di esempio), scegliere OK.

   Se non è la prima volta che si utilizza API Gateway, scegliere Create API (Crea API). In API REST, scegliere Crea.

3. Per API name (Nome API), immettere LambdaProxyAPI.

4. (Facoltativo) In Description (Descrizione), immettere una descrizione.

5. Lasciare l'opzione Tipo di endpoint API impostata su Regionale.

6. Seleziona Create API (Crea API).

Dopo l'API, è necessario creare una risorsa. In genere, le risorse API sono organizzate in una struttura di risorse in base alla logica dell'applicazione. In questo esempio crei una risorsa /helloworld.

Per creare una risorsa

1. Seleziona la risorsa /, quindi scegli Crea risorsa.

2. Mantieni l'opzione Risorsa proxy disattivata.

3. Mantieni Percorso risorsa impostato su /.

4. Per Resource Name (Nome risorsa) immetti helloworld.

5. Mantieni CORS (Cross Origin Resource Sharing) disattivato.

6. Scegli Crea risorsa.

In un'integrazione proxy, l'intera richiesta viene inviata alla funzione Lambda di back-end così com'è, tramite un metodo ANY catch-all che rappresenta qualsiasi metodo HTTP. Il metodo HTTP effettivo viene specificato dal client in fase di runtime. Il metodo ANY consente di utilizzare la configurazione di un solo metodo API per tutti i metodi HTTP supportati: DELETE, GET, HEAD, OPTIONS, PATCH, POST e PUT.

Per creare un metodo ANY

1. Seleziona la risorsa /helloworld, quindi scegli Crea metodo.

2. Per Tipo di metodo seleziona ANY.

3. Per Tipo di integrazione seleziona Funzione Lambda.

4. Attiva l'opzione Integrazione proxy Lambda.

5. Per la funzione Lambda, seleziona il Regione AWS luogo in cui hai creato la funzione Lambda, quindi inserisci il nome della funzione.

6. Per utilizzare il valore di timeout predefinito di 29 secondi, mantieni attiva l'opzione Timeout predefinito. Per impostare un timeout personalizzato, scegli Timeout predefinito e immetti un valore di timeout compreso tra 50 e 29000 millisecondi.

7. Scegli Crea metodo.

Distribuzione e test dell'API

Per distribuire l'API

1. Seleziona Deploy API (Distribuisci API).

2. In Fase, seleziona Nuova fase.

3. In Stage name (Nome fase) immettere test.

4. (Facoltativo) In Description (Descrizione), immettere una descrizione.

5. Seleziona Deploy (Implementa).

6. In Dettagli fase, scegli l'icona Copia per copiare l'URL di richiamo dell'API.

Uso del browser e di cURL per testare un'API con integrazione proxy Lambda

Puoi utilizzare un browser oppure cURL per testare l'API.

Per testare GET le richieste utilizzando solo i parametri della stringa di query, puoi inserire l'URL della helloworld risorsa dell'API nella barra degli indirizzi del browser.

Per creare l'URL per la helloworld risorsa dell'API, aggiungi la risorsa helloworld e il parametro della stringa di query ?greeter=John all'URL di invoke. Il tuo URL dovrebbe avere il seguente aspetto.

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

Per gli altri metodi, occorre utilizzare utilità di test dell'API REST più avanzate, come POSTMAN o cURL. In questo tutorial viene usato cURL. Gli esempi di comando cURL seguenti presuppongono che cURL sia installato nel computer in uso.

Per testare l'API implementata tramite cURL:

1. Apri una finestra del terminale.

2. Copia il comando cURL seguente e incollalo nella finestra del terminale, quindi sostituisci l'URL di richiamata con quello copiato nella fase precedente e aggiungi /helloworld alla fine dell'URL.

   Nota

   Se si esegue il comando in Windows, utilizzare questa sintassi:

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

   1. Per chiamare l'API con il parametro della stringa di query ?greeter=John:

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

   2. Per chiamare l'API con un parametro di intestazione 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. Per chiamare l'API con un corpo {"greeter":"John"}:

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

   In tutti i casi, l'output è una risposta 200 con il corpo seguente:

   Hello, John!