

 La [AWS SDK per JavaScript V3 API Reference Guide](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) descrive in dettaglio tutte le operazioni API per la AWS SDK per JavaScript versione 3 (V3). 

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

# Richiamare Lambda con API Gateway
<a name="api-gateway-invoking-lambda-example"></a>

Puoi richiamare una funzione Lambda utilizzando Amazon API Gateway, AWS un servizio per la creazione, la pubblicazione, la manutenzione, il monitoraggio e la protezione di REST, WebSocket APIs HTTP e su larga scala. Gli sviluppatori di API possono creare APIs quell'accesso AWS o altri servizi Web, oltre ai dati archiviati nel cloud. AWS In qualità di sviluppatore di API Gateway, puoi creare applicazioni client APIs per utilizzarle nelle tue applicazioni client. Per ulteriori informazioni, consulta [Cos'è Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html). 

AWS Lambda è un servizio di elaborazione che consente di eseguire codice senza fornire o gestire server. È possibile creare funzioni Lambda in diversi linguaggi di programmazione. Per ulteriori informazioni su AWS Lambda, consulta [What is AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

In questo esempio, crei una funzione Lambda utilizzando l'API JavaScript Lambda runtime. Questo esempio richiama diversi AWS servizi per eseguire un caso d'uso specifico. Ad esempio, si supponga che un'organizzazione invii un messaggio di testo mobile ai propri dipendenti per congratularsi con loro in occasione del primo anniversario, come illustrato in questa illustrazione.

![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


Il completamento dell'esempio dovrebbe richiedere circa 20 minuti.

Questo esempio mostra come utilizzare la JavaScript logica per creare una soluzione che esegua questo caso d'uso. Ad esempio, imparerai a leggere un database per determinare quali dipendenti hanno raggiunto la data del primo anniversario, come elaborare i dati e inviare un messaggio di testo, il tutto utilizzando una funzione Lambda. Quindi imparerai come utilizzare API Gateway per richiamare questa AWS Lambda funzione utilizzando un endpoint Rest. Ad esempio, puoi richiamare la funzione Lambda utilizzando questo comando curl:

```
curl -XGET "https://xxxxqjko1o3.execute-api.us-east-1.amazonaws.com/cronstage/employee" 
```

Questo AWS tutorial utilizza una tabella Amazon DynamoDB denominata Employee che contiene questi campi.
+ **id**: la chiave primaria per la tabella.
+ **firstName: nome** del dipendente.
+ **telefono: numero** di telefono del dipendente.
+ **StartDate: data** di inizio del dipendente.

![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**Importante**  
Costo di completamento: i AWS servizi inclusi in questo documento sono inclusi nel piano AWS gratuito. Tuttavia, assicurati di terminare tutte le risorse dopo aver completato questo esempio per assicurarti che non ti venga addebitato alcun costo.

**Per creare l'app:**

1. [Prerequisiti completi](#api-gateway-invoking-lambda-provision-resources)

1. [Crea le risorse AWS](#api-gateway-invoking-lambda-provision-resources)

1. [Preparare lo script del browser](#api-gateway-invoking-lambda-browser-script)

1. [Crea e carica la funzione Lambda](#api-gateway-invoking-lambda-browser-script)

1. [Implementa la funzione Lambda](#api-gateway-invoking-lambda-deploy-function)

1. [Esegui l'app](#api-gateway-invoking-lambda-run)

1. [Elimina le risorse](#api-gateway-invoking-lambda-destroy)

## Attività prerequisite
<a name="api-gateway-invoking-lambda-prerequisites"></a>

Per configurare ed eseguire questo esempio, è necessario completare queste attività:
+ Configura l'ambiente di progetto per eseguire questi TypeScript esempi di Node e installa i moduli richiesti AWS SDK per JavaScript e di terze parti. Segui le istruzioni su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway/README.md).
+ Creazione di un file di configurazione condiviso con le credenziali utente. Per ulteriori informazioni sulla fornitura di un file di credenziali condiviso, consulta File di [configurazione e credenziali condivisi nella AWS SDKs and](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) *Tools* Reference Guide.

## Crea le risorse AWS
<a name="api-gateway-invoking-lambda-provision-resources"></a>

Questo tutorial richiede le seguenti risorse:
+ Una tabella Amazon DynamoDB `Employee` denominata con una chiave `Id` denominata e i campi mostrati nell'illustrazione precedente. Assicurati di inserire i dati corretti, incluso un telefono cellulare valido con cui desideri testare questo caso d'uso. Per ulteriori informazioni, consulta [Creare una tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Un ruolo IAM con autorizzazioni allegate per eseguire funzioni Lambda.
+ Un bucket Amazon S3 per ospitare la funzione Lambda.

Puoi creare queste risorse manualmente, ma ti consigliamo di effettuare il provisioning di queste risorse utilizzando il metodo CloudFormation descritto in questo tutorial.

### Crea le AWS risorse utilizzando CloudFormation
<a name="api-gateway-invoking-lambda-resources-cli"></a>

CloudFormation consente di creare e fornire implementazioni di AWS infrastrutture in modo prevedibile e ripetuto. [Per ulteriori informazioni in merito CloudFormation, consulta la Guida per l'utente.AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)

Per creare lo CloudFormation stack utilizzando: AWS CLI

1. Installa e configura le AWS CLI seguenti istruzioni contenute nella [Guida per l'AWS CLI utente](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. [Create un file denominato `setup.yaml` nella directory principale della cartella del progetto e copiatene il contenuto. GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/setup.yaml)
**Nota**  
Il CloudFormation modello è stato generato utilizzando quello AWS CDK [disponibile qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lambda_using_api_gateway). Per ulteriori informazioni su AWS CDK, consulta la [Guida per AWS Cloud Development Kit (AWS CDK) gli sviluppatori](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Esegui il comando seguente dalla riga di comando, sostituendolo *STACK\$1NAME* con un nome univoco per lo stack.
**Importante**  
Il nome dello stack deve essere univoco all'interno di una AWS regione e AWS di un account. È possibile specificare fino a 128 caratteri e sono consentiti numeri e trattini.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Per ulteriori informazioni sui parametri dei `create-stack` comandi, consultate la guida di [riferimento ai AWS CLI comandi e la Guida](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) per l'[CloudFormation utente](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. Successivamente, compila la tabella seguendo la procedura[Compilazione della tabella](#api-gateway-invoking-lambda-resources-create-table).

### Compilazione della tabella
<a name="api-gateway-invoking-lambda-resources-create-table"></a>

Per compilare la tabella, create innanzitutto una directory denominata`libs`, in essa create un file denominato `dynamoClient.js` e incollate il contenuto sottostante. 

```
const { DynamoDBClient } = require ( "@aws-sdk/client-dynamodb" );
// Set the AWS Region.
const REGION = "REGION"; // e.g. "us-east-1"
 // Create an Amazon Lambda service client object.
const dynamoClient = new DynamoDBClient({region:REGION});
module.exports = { dynamoClient };
```

 Questo codice è disponibile [qui su. GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/dynamoClient.js)

Quindi, crea un file denominato `populate-table.js` nella directory principale della cartella del tuo progetto e copia il contenuto [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) dentro. Per uno degli elementi, sostituisci il valore della `phone` proprietà con un numero di cellulare valido nel formato E.164 e il valore della `startDate` con la data odierna.

Esegui il comando seguente dalla riga di comando.

```
node populate-table.js
```

```
const { BatchWriteItemCommand } = require ( "aws-sdk/client-dynamodb" );
const {dynamoClient} = require ( "./libs/dynamoClient" );

// Set the parameters.
export const params = {
  RequestItems: {
    Employees: [
      {
        PutRequest: {
          Item: {
            id: { N: "1" },
            firstName: { S: "Bob" },
            phone: { N: "155555555555654" },
            startDate: { S: "2019-12-20" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "2" },
            firstName: { S: "Xing" },
            phone: { N: "155555555555653" },
            startDate: { S: "2019-12-17" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "55" },
            firstName: { S: "Harriette" },
            phone: { N: "155555555555652" },
            startDate: { S: "2019-12-19" },
          },
        },
      },
    ],
  },
};

export const run = async () => {
  try {
    const data = await dbclient.send(new BatchWriteItemCommand(params));
    console.log("Success", data);
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

 Questo codice è [disponibile qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js).

## Creazione della AWS Lambda funzione
<a name="api-gateway-invoking-lambda-browser-script"></a>

### Configurazione dell'SDK
<a name="api-gateway-invoking-lambda-configure-sdk"></a>

Nella `libs` directory, crea file denominati `snsClient.js` e `lambdaClient.js` incolla il contenuto seguente in questi file, rispettivamente. 

```
const { SNSClient } = require("@aws-sdk/client-sns");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon SNS service client object.
const snsClient = new SNSClient({ region: REGION });
module.exports = { snsClient };
```

 Sostituisci *REGION* con la AWS regione. Questo codice è [disponibile qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/snsClient.js).

```
const { LambdaClient } = require("@aws-sdk/client-lambda");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Lambda service client object.
const lambdaClient = new LambdaClient({ region: REGION });
module.exports = { lambdaClient };
```

Sostituisci *REGION* con la AWS regione. Questo codice è [disponibile qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/lambdaClient.js).

Innanzitutto, importa i moduli e i comandi richiesti AWS SDK per JavaScript (v3). Quindi calcola la data odierna e assegnala a un parametro. Terzo, crea i parametri per. `ScanCommand` Sostituitelo *TABLE\$1NAME* con il nome della tabella creata nella [Crea le risorse AWS](#api-gateway-invoking-lambda-provision-resources) sezione di questo esempio.

Il seguente frammento di codice mostra questa fase. (Per l'esempio completo, consulta [Raggruppamento della funzione Lambda](#api-gateway-invoking-lambda-full).)

```
const { ScanCommand } = require("@aws-sdk/client-dynamodb");
const { PublishCommand } = require("@aws-sdk/client-sns");
const { snsClient } = require("./libs/snsClient");
const { dynamoClient } = require("./libs/dynamoClient");

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = `${yyyy}-${mm}-${dd}`;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which are the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "Employees",
};
```

### Scansione della tabella DynamoDB
<a name="api-gateway-invoking-lambda-scan-table"></a>

Innanzitutto, crea una async/await funzione chiamata `sendText` a pubblicare un messaggio di testo utilizzando Amazon SNS`PublishCommand`. Quindi, aggiungi uno schema a `try` blocchi che analizza la tabella DynamoDB alla ricerca dei dipendenti che festeggiano oggi il loro anniversario di lavoro, quindi richiama `sendText` la funzione per inviare a questi dipendenti un messaggio di testo. Se si verifica un errore, viene richiamato il `catch` blocco.

Il seguente frammento di codice mostra questa fase. (Per l'esempio completo, consulta [Raggruppamento della funzione Lambda](#api-gateway-invoking-lambda-full).)

```
// Helper function to send message using Amazon SNS.
exports.handler = async () => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      await snsClient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to identify employees with work anniversary today.
    const data = await dynamoClient.send(new ScanCommand(params));
    for (const element of data.Items) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message: `Hi ${element.firstName.S}; congratulations on your work anniversary!`,
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    }
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};
```

### Raggruppamento della funzione Lambda
<a name="api-gateway-invoking-lambda-full"></a>

Questo argomento descrive come raggruppare i `mylambdafunction.ts` AWS SDK per JavaScript moduli richiesti per questo esempio in un file in bundle chiamato. `index.js` 

1. Se non l'hai già fatto, segui questo esempio [Attività prerequisite](#api-gateway-invoking-lambda-prerequisites) per installare webpack. 
**Nota**  
Per informazioni sul *webpack, consulta*. [Raggruppa le applicazioni con webpack](webpack.md)

1. Esegui quanto segue nella riga di comando per raggruppare il file di questo JavaScript esempio in un file chiamato: `<index.js>`

   ```
   webpack mylambdafunction.ts --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**Importante**  
Notate che l'output ha un nome`index.js`. Questo perché le funzioni Lambda devono avere un `index.js` gestore per funzionare.

1. Comprimi il file di output in bundle,`index.js`, in un file ZIP denominato. `mylambdafunction.zip`

1. Carica `mylambdafunction.zip` nel bucket Amazon S3 che hai creato nell'[Crea le risorse AWS](#api-gateway-invoking-lambda-provision-resources)argomento di questo tutorial. 

## Distribuire la funzione Lambda
<a name="api-gateway-invoking-lambda-deploy-function"></a>

Nella radice del progetto, crea un `lambda-function-setup.ts` file e incolla il contenuto seguente al suo interno.

Sostituisci *BUCKET\$1NAME* con il nome del bucket Amazon S3 in cui hai caricato la versione ZIP della tua funzione Lambda. Sostituisci *ZIP\$1FILE\$1NAME* con il nome o il nome la versione ZIP della tua funzione Lambda. Sostituisci *ROLE* con l'Amazon Resource Number (ARN) del ruolo IAM che hai creato nell'[Crea le risorse AWS](#api-gateway-invoking-lambda-provision-resources)argomento di questo tutorial. Sostituire *LAMBDA\$1FUNCTION\$1NAME* con un nome per la funzione Lambda.

```
// Load the required Lambda client and commands.
const {
  CreateFunctionCommand
} = require ( "@aws-sdk/client-lambda" );
const { lambdaClient} = require ( "./libs/lambdaClient.js );

// Set the parameters.
const params = {
  Code: {
    S3Bucket: "BUCKET_NAME", // BUCKET_NAME
    S3Key: "ZIP_FILE_NAME", // ZIP_FILE_NAME
  },
  FunctionName: "LAMBDA_FUNCTION_NAME",
  Handler: "index.handler",
  Role: "IAM_ROLE_ARN", // IAM_ROLE_ARN; e.g., arn:aws:iam::650138640062:role/v3-lambda-tutorial-lambda-role
  Runtime: "nodejs12.x",
  Description:
    "Scans a DynamoDB table of employee details and using Amazon Simple Notification Services (Amazon SNS) to " +
    "send employees an email on each anniversary of their start-date.",
};

const run = async () => {
  try {
    const data = await lambdaClient.send(new CreateFunctionCommand(params));
    console.log("Success", data); // successful response
  } catch (err) {
    console.log("Error", err); // an error occurred
  }
};
run();
```

Immettere quanto segue nella riga di comando per distribuire la funzione Lambda.

```
node lambda-function-setup.ts
```

Questo esempio di codice è disponibile [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/lambda-function-setup.js). GitHub

## Configurare API Gateway per richiamare la funzione Lambda
<a name="api-gateway-invoking-lambda-run"></a>

**Per creare l'app:**

1. [Crea la restante API](#api-gateway-invoking-lambda-run-create)

1. [Prova il metodo API Gateway](#api-gateway-invoking-lambda-run-test)

1. [Implementa il metodo API Gateway](#api-gateway-invoking-lambda-run-deploy)

### Crea la restante API
<a name="api-gateway-invoking-lambda-run-create"></a>

Puoi utilizzare la console API Gateway per creare un endpoint REST per la funzione Lambda. Una volta terminata, puoi richiamare la funzione Lambda utilizzando una chiamata restful.



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

1. In Rest API, scegli **Build**.

1. Seleziona **Nuova API**.  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/PicNewAPI.png)

1. Specificate **Employee** come nome dell'API e fornite una descrizione.  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picEmployeeAPI.png)

1. Seleziona **Create API** (Crea API).

1. Scegli **Risorse** nella sezione **Dipendenti**.  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picResources.png)

1. Nel campo del nome, specifica **i dipendenti**.

1. Selezionare **Create Resources (Crea risorse)**.

1. Dal menu a discesa **Azioni**, scegli **Crea risorse**.  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picCreateResources.png)

1. **Scegli **/employees**, seleziona **Crea metodo** dal menu **Azioni**, quindi seleziona **GET** dal menu a discesa sotto /employees.** Selezionare l'icona del segno di spunta.  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGet.png)

1. Scegliete la **funzione Lambda** e immettete **mylambdafunction** come nome della funzione Lambda. Scegli **Save** (Salva).

### Prova il metodo API Gateway
<a name="api-gateway-invoking-lambda-run-test"></a>

A questo punto del tutorial, puoi testare il metodo API Gateway che richiama la funzione Lambda **mylambdafunction**. Per testare il metodo, scegliete **Test**, come illustrato nella figura seguente.

![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picTest.png)


Una volta richiamata la funzione Lambda, è possibile visualizzare il file di registro per visualizzare un messaggio di successo.

### Implementa il metodo API Gateway
<a name="api-gateway-invoking-lambda-run-deploy"></a>

Una volta completato il test, puoi implementare il metodo dalla [console di Amazon API Gateway](https://console.aws.amazon.com/apigateway).

1. Scegli **Get**.  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGetDeploy.png)

1. Dal menu a discesa **Azioni**, seleziona **Deploy API.**  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1. **Compila il modulo **Deploy API** e scegli Deploy.**  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1.  Seleziona **Salva modifiche**.

1.  Scegli **Get** again e nota che l'URL cambia. Questo è l'URL di chiamata che puoi usare per richiamare la funzione Lambda.  
![\[DynamoDB tabella\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picURL2.png)

## Eliminare le risorse
<a name="api-gateway-invoking-lambda-destroy"></a>

Complimenti\$1 Hai richiamato una funzione Lambda tramite Amazon API Gateway utilizzando il. AWS SDK per JavaScript Come indicato all'inizio di questo tutorial, assicurati di terminare tutte le risorse che crei durante la lettura di questo tutorial per assicurarti che non ti vengano addebitati costi. Puoi farlo eliminando lo CloudFormation stack che hai creato nell'[Crea le risorse AWS](#api-gateway-invoking-lambda-provision-resources)argomento di questo tutorial, come segue:

1. Apri il file [CloudFormation nella console di AWS gestione]( https://console.aws.amazon.com/cloudformation/home).

1. Apri la pagina **Stacks** e seleziona lo stack.

1. Scegli **Delete** (Elimina).