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

# Scegli un tutorial di integrazione AWS Lambda
<a name="getting-started-with-lambda-integration"></a>

 Per creare un'API tramite integrazioni Lambda, puoi usare l'integrazione proxy Lambda o l'integrazione non proxy Lambda. 

Nell'integrazione proxy Lambda, l'input nella funzione Lambda può essere espresso con qualsiasi combinazione di intestazioni di richiesta, variabili di percorso, parametri di stringa di query, corpo e dati di configurazione dell'API. È necessario solo che tu scelga una funzione Lambda. API Gateway configura automaticamente la richiesta e la risposta di integrazione. Una volta configurate, il metodo API può evolvere senza modificare le impostazioni esistenti. Ciò è possibile in quanto la funzione Lambda backend analizza i dati della richiesta in entrata e risponde al client.

Con l'integrazione non proxy Lambda, devi accertarti che l'input della funzione Lambda venga fornito come payload della richiesta di integrazione. È necessario mappare i dati di input forniti dal client come parametri di richiesta nel corpo della richiesta di integrazione appropriato. Potrebbe anche essere necessario convertire il corpo della richiesta fornito dal client in un formato riconosciuto dalla funzione Lambda. 

In un proxy Lambda o in un'integrazione non proxy Lambda, è possibile utilizzare una funzione Lambda in un account diverso da quello in cui è stata creata l'API.

**Topics**
+ [Tutorial: creazione di una REST API con un'integrazione proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md)
+ [Tutorial: creazione di una REST API con un'integrazione non proxy Lambda](getting-started-lambda-non-proxy-integration.md)
+ [Tutorial: creazione di una REST API con un'integrazione proxy Lambda multi-account](apigateway-cross-account-lambda-integrations.md)

# 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!
   ```

# Tutorial: creazione di una REST API con un'integrazione non proxy Lambda
<a name="getting-started-lambda-non-proxy-integration"></a>

In questa procedura guidata viene utilizzata la console API Gateway per creare un'API che permette a un client di chiamare le funzioni Lambda tramite l'integrazione non proxy Lambda (detta anche integrazione personalizzata). Per ulteriori informazioni su AWS Lambda e sulle funzioni Lambda, consulta la [Guida per gli sviluppatori di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/). 

Per semplificare l'apprendimento, scegliamo una funzione Lambda semplice con una configurazione API minima per illustrare le fasi di creazione di un'API di API Gateway con l'integrazione personalizzata Lambda. Laddove necessario, descriveremo la logica. Per un esempio più dettagliato dell'integrazione personalizzata Lambda, consulta [Tutorial: crea un'API REST per calcolatrice con due integrazioni AWS di servizi e un'integrazione non proxy Lambda](integrating-api-with-aws-services-lambda.md). 

Prima di creare l'API, configura il back-end Lambda creando una funzione Lambda in AWS Lambda, come descritto di seguito.

**Topics**
+ [Creazione di una funzione Lambda per l'integrazione non proxy Lambda](#getting-started-new-lambda)
+ [Creazione di un'API con l'integrazione non proxy Lambda](#getting-started-new-api)
+ [Test della chiamata del metodo API](#getting-started-new-get)
+ [Distribuzione dell'API](#getting-started-deploy-api)
+ [Test dell'API in una fase di distribuzione](#getting-started-test)
+ [Elimini](#getting-started-clean-up)

## Creazione di una funzione Lambda per l'integrazione non proxy Lambda
<a name="getting-started-new-lambda"></a>

**Nota**  
La creazione di funzioni Lambda può comportare addebiti sul tuo AWS account.

 In questa fase, viene creata una funzione Lambda "Hello, World\$1" per l'integrazione Lambda personalizzata. In tutta la procedura guidata la funzione è denominata `GetStartedLambdaIntegration`.

 L'implementazione di questa funzione Lambda `GetStartedLambdaIntegration` è la seguente: 

------
#### [ 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}
```

------

Per l'integrazione Lambda personalizzata, API Gateway passa l'input alla funzione Lambda dal client come corpo della richiesta di integrazione. L'oggetto `event` del gestore della funzione Lambda è l'input. 

La nostra funzione Lambda è semplice. Analizza l'oggetto `event` di input per le proprietà `name`, `city`, `time` e `day`. Quindi restituisce un saluto, come un oggetto JSON di `{"message":greeting}`, all'intermediario. Il messaggio è nel modello `"Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!"`. Si presume che l'input per la funzione Lambda sia dell'oggetto JSON seguente: 

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

Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html). 

Inoltre, la funzione registra la sua esecuzione su Amazon CloudWatch `console.log(...)` chiamando. Questo risulta utile per tracciare le chiamate durante il debug della funzione. Per consentire alla `GetStartedLambdaIntegration` funzione di registrare la chiamata, imposta un ruolo IAM con politiche appropriate per la funzione Lambda per creare gli CloudWatch stream e aggiungere voci di registro agli stream. La console Lambda permette di creare le policy e i ruoli IAM necessari.

Se configuri l'API senza usare la console API Gateway, come nel caso in cui si esegue l'[importazione di un'API da un file OpenAPI](https://github.com/aws-samples/api-gateway-secure-pet-store/blob/master/src/main/resources/swagger.yaml#L39), dovrai creare esplicitamente, se necessario, e configurare una policy e un ruolo di invocazione affinché API Gateway possa invocare le funzioni Lambda. Per ulteriori informazioni su come configurare i ruoli di esecuzione e di invocazione Lambda per un'API di API Gateway, consulta [Controllo degli accessi a una REST API con le autorizzazioni IAM](permissions.md). 

 A differenza di `GetStartedLambdaProxyIntegration`, la funzione Lambda per l'integrazione proxy Lambda, la funzione Lambda `GetStartedLambdaIntegration` per l'integrazione personalizzata Lambda riceve l'input solo dal corpo della richiesta di integrazione API di API Gateway. La funzione può restituire un output di qualsiasi oggetto JSON, una stringa, un numero, un valore booleano o un BLOB binario. La funzione Lambda per l'integrazione proxy Lambda, al contrario, può ricevere l'input da tutti i dati di richiesta ma deve restituire un output di un oggetto JSON specifico. La funzione `GetStartedLambdaIntegration` per l'integrazione personalizzata Lambda può ricevere come input i parametri di richiesta API, a condizione che API Gateway mappi i parametri di richiesta API necessari al corpo della richiesta di integrazione prima di inoltrare la richiesta client al back-end. Perché ciò accada, lo sviluppatore dell'API deve creare un modello di mappatura e configurarlo nel metodo API durante la creazione dell'API. 

Viene ora creata la funzione Lambda `GetStartedLambdaIntegration`. 

**Per creare la funzione Lambda `GetStartedLambdaIntegration` per l'integrazione personalizzata Lambda**

1. Apri la console all' AWS Lambda indirizzo. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)

1. Esegui una delle seguenti operazioni:
   + Se viene visualizzata la pagina di benvenuto, scegliere **Get Started Now (Inizia subito)**, quindi **Create a function (Crea una funzione)**.
   + Se viene visualizzata la pagina di elenco **Lambda > Funzioni**, scegliere **Create a function (Crea una funzione)**.

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

1. Nel riquadro **Author from scratch (Crea da zero)** procedere nel seguente modo:

   1. In **Nome (Name)**, immettere **GetStartedLambdaIntegration** come nome della funzione Lambda.

   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. Per **Role name (Nome ruolo)**, digitare un nome per il ruolo, ad esempio **GetStartedLambdaIntegrationRole**.

   1. Per **Modelli di policy**, scegliere **Autorizzazioni microservizi semplici**.

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

1. Nel riquadro **Configure function (Configura funzione)** effettua quanto segue in **Function code (Codice funzione)**:

   1. Copiare il codice di funzione Lambda elencato all'inizio di questa sezione e incollarlo nell'editor di codice inline.

   1. Lascia i valori predefiniti negli altri campi di questa sezione.

   1. Selezionare **Deploy (Distribuisci)**.

1. Per testare la funzione appena creata, scegli la scheda **Test**.

   1. Per **Event name (Nome evento)** immettere **HelloWorldTest**. 

   1. Per **JSON dell'evento**, sostituisci il codice predefinito con il seguente.

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

   1.  Scegliere **Test (Testa)** per invocare la funzione. Viene visualizzata la sezione **Execution result: succeeded (Risultato esecuzione: riuscito)**. Espandi **Dettaglio**. Verrà visualizzato l'output seguente.

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

      L'output viene anche scritto in CloudWatch Logs. 

 Come esercizio complementare, puoi usare la console IAM per visualizzare il ruolo IAM (`GetStartedLambdaIntegrationRole`) creato insieme alla funzione Lambda. A questo ruolo IAM sono collegate due policy inline. Una stipula le autorizzazioni di base per l'esecuzione Lambda Consente di richiamare qualsiasi CloudWatch risorsa del tuo account nella regione in cui viene creata la funzione Lambda. CloudWatch `CreateLogGroup` Questa politica consente inoltre di creare CloudWatch flussi e registrare gli eventi per la funzione Lambda`GetStartedLambdaIntegration`. 

------
#### [ 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'altro documento di policy si applica all'invocazione di un altro AWS servizio che non viene utilizzato in questo esempio. Puoi ignorarlo in questa fase. 

 Al ruolo IAM è associata un'entità attendibile, ovvero `lambda.amazonaws.com`. La relazione di fiducia è la seguente: 

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

****  

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

------

 La combinazione di questa relazione di fiducia e della politica in linea consente alla funzione Lambda di richiamare `console.log()` una funzione per registrare gli eventi nei registri. CloudWatch 

## Creazione di un'API con l'integrazione non proxy Lambda
<a name="getting-started-new-api"></a>

 Con la funzione Lambda (`GetStartedLambdaIntegration`) creata e testata, è possibile esporre la funzione mediante un'API di API Gateway. A scopo illustrativo, viene esposta la funzione Lambda con un metodo HTTP generico. Vengono utilizzati il corpo della richiesta, una variabile di percorso URL, una stringa di query e un'intestazione per ricevere i dati di input necessari dal client. Attiviamo il validatore di richieste API Gateway per l'API per garantire che tutti i dati necessari vengano definiti e specificati in modo appropriato. Configuriamo un modello di mappatura per API Gateway per trasformare i dati della richiesta forniti dal client nel formato valido, come richiesto dalla funzione Lambda di back-end.

**Per creare un'API con un'integrazione non proxy Lambda**

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

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 **/\$1city\$1**. Questo è l'esempio di una risorsa con una variabile di percorso che riceve un input dal client. Più avanti mapperai questa variabile nell'input della funzione Lambda utilizzando un modello di mappatura.

**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 **\$1city\$1**.

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

1. Scegli **Crea risorsa**.

Dopo la risorsa **/\$1city\$1**, è necessario creare un metodo `ANY`. Il metodo HTTP `ANY` funge da segnaposto per un metodo HTTP valido inviato da un client al runtime. Questo esempio mostra che il metodo `ANY` può essere utilizzato sia per l'integrazione Lambda personalizzata sia per quella proxy.

**Per creare un metodo `ANY`**

1. Seleziona la risorsa **/\$1city\$1**, quindi scegli **Crea metodo**.

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

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

1. Mantieni l'opzione **Integrazione proxy Lambda** disattivata.

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

1. Scegli **Impostazioni della richiesta del metodo.**

   Ora, attivare un validatore richiesta per una variabile di percorso URL, un parametro di stringa di query e un'intestazione per assicurarsi che tutti i dati necessari siano definiti. Per questo esempio, crea un parametro della stringa di query `time` e un'intestazione `day`. 

1. Per **Validatore richiesta** seleziona **Convalida parametri di stringa query e intestazioni**.

1. Scegli **Parametri della stringa di query URL** ed effettua le seguenti operazioni: 

   1. Scegliere **Add query string (Aggiungi stringa di query)**.

   1. In **Nome**, inserisci **time**.

   1. Attiva **Campo obbligatorio**.

   1. Mantieni disattivata l'opzione **Caching**. 

1. Scegli **Intestazioni di richiesta HTTP** e procedi come segue: 

   1. Seleziona **Add header (Aggiungi intestazione)**.

   1. In **Nome**, inserisci **day**.

   1. Attiva **Campo obbligatorio**.

   1. Mantieni disattivata l'opzione **Caching**. 

1. Scegli **Crea metodo**.

Dopo aver attivato un validatore della richiesta, configura la richiesta di integrazione per il metodo `ANY` aggiungendo un modello di mappatura del corpo per trasformare la richiesta in ingresso in un payload JSON, come richiesto dalla funzione Lambda di back-end. 

**Per configurare la richiesta di integrazione**

1. Nella scheda **Richiesta di integrazione** scegli **Modifica** in **Impostazioni della richiesta di integrazione**.

1. Per **Richiesta corpo passthrough** scegli **Quando non ci sono modelli definiti (consigliato)**.

1. Scegli **Modelli di mappatura**.

1. Scegliere **Add mapping template (Aggiungi modello di mappatura)**.

1. Per **Tipo di contenuto** inserisci **application/json**.

1. Per **Corpo del modello** inserisci il seguente codice:

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

1. Scegli **Save** (Salva).

## Test della chiamata del metodo API
<a name="getting-started-new-get"></a>

 La console API Gateway offre l'opportunità di testare la chiamata dell'API prima della distribuzione. La caratteristica Test della console consente di testare l'API inviando la richiesta seguente: 

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

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

 In questa richiesta di test imposterai `ANY` su `POST` e `{city}` su `Seattle` e assegnerai `Wednesday` come valore di intestazione di `day` e `"John"` come valore di `callerName`. 

**Test del metodo `ANY`**

1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.

1. In **Tipo di metodo**, seleziona `POST`.

1. In **Percorso** immetti **Seattle** per **city**.

1. In **Stringhe di query** immetti **time=morning**.

1. In **Intestazioni** immetti **day:Wednesday**.

1. In **Corpo della richiesta** immetti **\$1 "callerName": "John" \$1**.

1. Scegli **Test (Esegui test)**.

Verifica che il payload della risposta restituita sia come segue:

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

Puoi anche visualizzare i log per analizzare il modo in cui API Gateway elabora la richiesta e la risposta.

```
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
```

I log mostrano la richiesta in ingresso prima della mappatura e la richiesta di integrazione dopo la mappatura. I log risultano utili per valutare, in caso di esito negativo di un test, se l'input originale è corretto o il modello di mappatura funziona correttamente. 

## Distribuzione dell'API
<a name="getting-started-deploy-api"></a>

 La chiamata di test è una simulazione e presenta alcune limitazioni. Ad esempio ignora qualsiasi sistema di autorizzazione attuato per l'API. Per testare l'esecuzione dell'API in tempo reale, è necessario prima distribuire l'API. Per distribuire un'API, crea una fase per creare una snapshot dell'API in quel momento. Il nome della fase definisce inoltre il percorso di base in base al nome host predefinito dell'API. La risorsa radice dell'API viene aggiunta dopo il nome della fase. Quando modifichi l'API, devi ridistribuirla in una fase nuova o esistente per rendere effettive le modifiche. 

**Per distribuire l'API in una fase**

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

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

1. In **Stage name (Nome fase)** immettere **test**.
**Nota**  
L'input deve essere un testo con codifica UTF-8, ovvero non localizzato.

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

1. Seleziona **Implementa**.

In **Dettagli fase**, scegli l'icona Copia per copiare l'URL di richiamo dell'API. Il modello generale dell'URL di base dell'API è `https://api-id.region.amazonaws.com/stageName`. Ad esempio, l'URL di base dell'API (`beags1mnid`) creato nella regione `us-west-2` e distribuito nella fase `test` è `https://beags1mnid.execute-api.us-west-2.amazonaws.com/test`.

## Test dell'API in una fase di distribuzione
<a name="getting-started-test"></a>

Sono disponibili diversi modi per testare un'API distribuita. Per le richieste GET che utilizzano solo variabili di percorso URL o parametri di stringa di query, puoi immettere l'URL di risorsa dell'API nel browser. 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/).

**Per testare l'API tramite cURL**

1. Apri una finestra terminale sul tuo computer locale connesso a Internet.

1. Per testare `POST /Seattle?time=evening`:

   Copia il comando cURL seguente e incollalo nella finestra terminale.

   ```
   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"
   }'
   ```

   Dovresti visualizzare una risposta di operazione riuscita con il payload seguente:

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

   Se modifichi `POST` in `PUT` in questa richiesta di metodo, otterrai la stessa risposta.

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

Se non hai più bisogno delle funzioni Lambda create per questa procedura dettagliata, puoi eliminarle in questa fase. Puoi anche eliminare le risorse IAM associate.

**avvertimento**  
Se intendi completare le altre procedure guidate di questa serie, non eliminare il ruolo di esecuzione o di invocazione Lambda. Se elimini una funzione Lambda su APIs cui fai affidamento, quella non APIs funzionerà più. L'eliminazione di una funzione Lambda non può essere annullata. Se desideri utilizzare di nuovo la funzione Lambda, dovrai ricrearla.  
Se elimini una risorsa IAM su cui si basa una funzione Lambda, quella funzione Lambda non funzionerà più e tutte le risorse APIs che si basano su quella funzione non funzioneranno più. L'eliminazione di una risorsa IAM non può essere annullata. Se desideri utilizzare di nuovo la risorsa IAM, dovrai ricrearla. 

**Per eliminare la funzione Lambda**

1. Accedi a Console di gestione AWS e apri la console all' AWS Lambda indirizzo. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)

1. Nell'elenco delle funzioni scegliere **GetStartedLambdaIntegration**, **Actions (Operazioni)**, quindi **Delete function (Elimina funzione)**. Quando viene richiesto, scegliere nuovamente **Delete (Elimina)**.

**Per eliminare le risorse IAM associate**

1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. In **Details (Dettagli)** scegliere **Roles (Ruoli)**.

1. Nell'elenco dei ruoli scegliere **GetStartedLambdaIntegrationRole**, **Role Actions (Operazioni ruolo)**, quindi **Delete role (Elimina ruolo)**. Per eliminare il ruolo utilizzando la console, attieniti alla procedura seguente.

# Tutorial: creazione di una REST API con un'integrazione proxy Lambda multi-account
<a name="apigateway-cross-account-lambda-integrations"></a>

Ora puoi utilizzare una AWS Lambda funzione di un altro AWS account come backend di integrazione delle API. Ogni account può trovarsi in qualsiasi regione in cui è disponibile Amazon API Gateway. Ciò semplifica la gestione e la condivisione centralizzata delle funzioni di backend Lambda tra più utenti. APIs

In questa sezione, viene illustrato come configurare l'integrazione proxy Lambda tra più account utilizzando la console Amazon API Gateway.

## Creazione di un'API per l'integrazione Lambda tra più account API Gateway
<a name="apigateway-cross-account-lambda-integrations-create-api"></a>

**Come creare un’API**

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

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

## Creazione di una funzione di integrazione Lambda in un altro account
<a name="apigateway-cross-account-lambda-integrations-create-lambda-function"></a>

Viene ora creata una funzione Lambda in un account diverso da quello in cui hai creato l'API di esempio.

**Creazione di una funzione Lambda in un altro account**

1. Accedere alla console Lambda in un account diverso da quello in cui è stata creata l'API di API Gateway.

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

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

1. In **Author from scratch (Crea da zero)**, effettuare le seguenti operazioni:

   1. Per **Function name (Nome funzione)** immettere un nome.

   1. Dall'elenco a discesa **Runtime**, scegliere un runtime Node.js supportato.

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

   1. In **Autorizzazioni**, espandere **Scegli o crea un ruolo di esecuzione**. È possibile creare un ruolo o scegliere un ruolo esistente.

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

1. Scorrere verso il basso fino al riquadro **Function code (Codice funzione)**.

1. Immetti l'implementazione della funzione Node.js da [Tutorial: creazione di una REST API con un'integrazione proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).

1. Selezionare **Deploy (Distribuisci)**.

1. Prendere nota dell'ARN completo della funzione (nell'angolo in alto a destra del riquadro della funzione Lambda), in quanto sarà necessario per la creazione dell'integrazione Lambda tra più account.

## Configurazione dell'integrazione Lambda tra più account
<a name="apigateway-cross-account-lambda-integrations-create-integration2"></a>

Dopo la creazione di una funzione di integrazione Lambda in un altro account, puoi utilizzare la console API Gateway per aggiungerla all'API nel tuo primo account.

**Nota**  
Se si sta configurando una regione, un provider di autorizzazioni tra più account, `sourceArn` che viene aggiunto alla funzione di destinazione deve utilizzare la regione della funzione, non la regione dell'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**.

Dopo la risorsa, è necessario creare un metodo `GET`. Integra il metodo `GET` con una funzione Lambda in un altro account. 

**Creazione di un metodo `GET`**

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

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

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

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

1. Per **Funzione Lambda** immetti l'ARN completo della funzione Lambda dalla fase 1. 

   Nella console Lambda, puoi trovare l'ARN della funzione nell'angolo in alto a destra.

1. Quando immetti l'ARN, viene visualizzata una stringa di comando `aws lambda add-permission`. Questa policy fornisce al tuo primo account l'accesso alla funzione Lambda del secondo account. Copia e incolla la stringa di `aws lambda add-permission` comando in una AWS CLI finestra configurata per il secondo account.

1. Scegli **Crea metodo**.

Puoi visualizzare la policy aggiornata per la funzione nella console Lambda.

**(Facoltativo) Per visualizzare la policy aggiornata**

1. Accedi a Console di gestione AWS e apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Seleziona la funzione Lambda.

1. Seleziona **Autorizzazioni**.

   Viene visualizzata una policy `Allow` con una clausola `Condition` in cui `AWS:SourceArn` è l'ARN per il metodo `GET` dell'API.