Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Tutorial: creazione di una REST API con un'integrazione proxy Lambda
<a name="api-gateway-create-api-as-simple-proxy-for-lambda"></a>

L'[integrazione proxy Lambda](set-up-lambda-proxy-integrations.md) è 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](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). 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\$1" come back-end per l'API.
+ Creazione e test di un'API "Hello World\$1" API con integrazione proxy Lambda.

**Topics**
+ [Creazione di una funzione Lambda "Hello, World\$1" valida e completa](#api-gateway-proxy-integration-create-lambda-backend)
+ [Creazione di una funzione Lambda "Hello, World\$1" API](#api-gateway-create-api-as-simple-proxy-for-lambda-build)
+ [Distribuzione e test dell'API](#api-gateway-create-api-as-simple-proxy-for-lambda-test)

## Creazione di una funzione Lambda "Hello, World\$1" valida e completa
<a name="api-gateway-proxy-integration-create-lambda-backend"></a>

**Per creare una funzione Lambda "Hello, World\$1" Funzione Lambda nella console Lambda**

1. [Accedi alla console Lambda all'indirizzo https://console.aws.amazon.com /lambda.](https://console.aws.amazon.com/lambda)

1. Nella barra di AWS navigazione, scegli un. [Regione AWS](https://docs.aws.amazon.com/general/latest/gr/apigateway.html)
**Nota**  
Prendere nota della regione in cui si crea la funzione Lambda. Questa informazione sarà necessaria in fase di creazione dell'API.

1. Nel riquadro di navigazione scegliere **Functions (Funzioni)**.

1. Selezionare **Create function (Crea funzione)**.

1. Scegli **Author from scratch** (Crea da zero).

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

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

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

   1. Mantieni l'impostazione predefinita per **Architettura**.

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

   1. In **Role name (Nome ruolo)** immettere **GetStartedLambdaBasicExecutionRole**.

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

   1. Selezionare **Create function (Crea funzione)**.

1. In **Codice funzione**, nell'editor di codice in linea, copy/paste il codice seguente:

------
#### [ 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. Selezionare **Deploy (Distribuisci)**.

## Creazione di una funzione Lambda "Hello, World\$1" API
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-build"></a>

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

**Per creare una funzione Lambda "Hello, World\$1" "Hello, World\$1"**

1. Accedi alla console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)

1. 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**.

1.  Per **API name (Nome API)**, immettere **LambdaProxyAPI**.

1. (Facoltativo) In **Descrizione**, immetti una descrizione.

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

1. Per il tipo di **indirizzo IP**, selezionare. **IPv4**

1. 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**. 

**Come creare una risorsa**

1. Scegli **Crea risorsa**.

1. Mantieni l'opzione **Risorsa proxy** disattivata. 

1. Mantieni **Percorso risorsa** impostato su `/`.

1. Per **Resource Name (Nome risorsa)** immetti **helloworld**.

1. Mantieni **CORS (Cross Origin Resource Sharing)** disattivato.

1. 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**.

1. Per **Tipo di metodo** seleziona **ANY**.

1. Per **Tipo di integrazione** seleziona **Funzione Lambda**.

1. Attiva l'opzione **Integrazione proxy Lambda**.

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

1. 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.

1. Scegli **Crea metodo**.

## Distribuzione e test dell'API
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test"></a>

**Per distribuire l'API**

1. Seleziona **Deploy API (Distribuisci API)**.

1. In **Fase**, seleziona **Nuova fase**.

1. In **Stage name (Nome fase)** immettere **test**.

1. (Facoltativo) In **Descrizione**, immetti una descrizione.

1. Seleziona **Implementa**.

1. 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
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test-curl"></a>

Puoi utilizzare un browser oppure [cURL](https://curl.se/) per testare l'API.

Per testare le richieste `GET` utilizzando solo parametri della stringa di query, è possibile immettere l'URL per la risorsa `helloworld` dell'API nella barra degli indirizzi di un browser. 

Per creare l'URL per la risorsa `helloworld` dell'API, aggiungi la risorsa `helloworld` e il parametro della stringa di query `?greeter=John` all'URL di invocazione. L'URL sarà simile al seguente.

```
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](https://www.postman.com/) o [cURL](https://curl.se/). 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.

1. 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'
      ```

   1. 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'
      ```

   1. 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!
   ```