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

# Lavora con AWS i servizi nell'SDK per JavaScript
<a name="working-with-services"></a>

La AWS SDK per JavaScript versione v3 fornisce l'accesso ai servizi che supporta tramite una raccolta di classi client. Da queste classi client, si creano oggetti di interfaccia di servizio, comunemente chiamati *oggetti di servizio*. Ogni AWS servizio supportato include una o più classi di client che offrono funzionalità e risorse APIs di servizio di basso livello. Ad esempio, Amazon APIs DynamoDB è disponibile tramite la classe. `DynamoDB`

I servizi esposti tramite l'SDK JavaScript seguono lo schema di richiesta-risposta per lo scambio di messaggi con le applicazioni chiamanti. In questo schema, il codice che richiama un servizio invia una HTTP/HTTPS richiesta a un endpoint per il servizio. La richiesta contiene i parametri necessari per richiamare correttamente la funzionalità specifica chiamata. Il servizio richiamato genera una risposta che viene inviata nuovamente al richiedente. La risposta contiene dati se l'operazione ha avuto esito positivo o informazioni di errore se l'operazione non ha avuto esito positivo. 

L'invocazione AWS di un servizio include l'intero ciclo di vita della richiesta e della risposta di un'operazione su un oggetto di servizio, inclusi eventuali nuovi tentativi. Una richiesta contiene zero o più proprietà come parametri JSON. La risposta è incapsulata in un oggetto correlato all'operazione e viene restituita al richiedente tramite una delle diverse tecniche, ad esempio una funzione di callback o una promessa. JavaScript 

**Topics**
+ [Crea e richiama oggetti di servizio](creating-and-calling-service-objects.md)
+ [Chiama i servizi in modo asincrono](calling-services-asynchronously.md)
+ [Crea richieste ai clienti di servizio](the-request-object.md)
+ [Gestisci le risposte dei clienti di assistenza](the-response-object.md)
+ [Lavora con JSON](working-with-json.md)
+ [Registrazione delle chiamate AWS SDK per JavaScript](logging-sdk-calls.md)
+ [Usa endpoint AWS basati su account con DynamoDB](ddb-account-based-endpoints-v3.md)
+ [Protezione dell'integrità dei dati con i checksum di Amazon S3](s3-checksums.md)
+ [SDK per esempi di JavaScript codice](sdk-code-samples.md)

# Crea e richiama oggetti di servizio
<a name="creating-and-calling-service-objects"></a>

L' JavaScript API supporta la maggior parte dei AWS servizi disponibili. Ogni servizio dell' JavaScriptAPI fornisce a una classe client un `send` metodo da utilizzare per richiamare tutte le API supportate dal servizio. Per ulteriori informazioni sulle classi di servizio, le operazioni e i parametri nell' JavaScript API, consulta l'[API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/).

Quando si utilizza l'SDK in Node.js, si aggiunge il pacchetto SDK per ogni servizio necessario all'utilizzo dell'applicazione`import`, che fornisce supporto per tutti i servizi correnti. L'esempio seguente crea un oggetto di servizio Amazon S3 nella `us-west-1` regione.

```
// Import the Amazon S3 service client
import { S3Client } from "@aws-sdk/client-s3"; 
// Create an S3 client in the us-west-1 Region
const s3Client = new S3Client({
    region: "us-west-1"
});
```

## Specificare i parametri dell'oggetto di servizio
<a name="specifying-service-object-parameters"></a>

Quando chiami un metodo di un oggetto di servizio, trasferisci i parametri in JSON come richiesto dall'API. Ad esempio, in Amazon S3, per ottenere un oggetto per un bucket e una chiave specificati, passa i seguenti parametri al `GetObjectCommand` metodo da. `S3Client` Per ulteriori informazioni sul trasferimento di parametri JSON, consulta [Lavora con JSON](working-with-json.md).

```
s3Client.send(new GetObjectCommand({Bucket: 'bucketName', Key: 'keyName'}));
```

Per ulteriori informazioni sui parametri di Amazon S3, consulta [@aws -sdk/client-s3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-s3/) nell'API Reference.

## Usa @smithy /types per i client generati in TypeScript
<a name="smithy-types"></a>

Se lo stai utilizzando TypeScript, il `@smithy/types` pacchetto ti consente di manipolare le forme di input e output di un client.

### Scenario: rimozione `undefined` dalle strutture di input e output
<a name="remove-undefined-from-input"></a>

I membri delle forme generate vengono uniti alle forme `undefined` di input e `?` (facoltativo) alle forme di output. Per gli input, ciò rinvia la convalida al servizio. Per quanto riguarda gli output, ciò suggerisce vivamente di controllare in fase di esecuzione i dati di output.

Se desideri saltare questi passaggi, usa gli helper o digita`AssertiveClient`. `UncheckedClient` L'esempio seguente utilizza i type helper con il servizio Amazon S3.

```
import { S3 } from "@aws-sdk/client-s3";
import type { AssertiveClient, UncheckedClient } from "@smithy/types";

const s3a = new S3({}) as AssertiveClient<S3>;
const s3b = new S3({}) as UncheckedClient<S3>;

// AssertiveClient enforces required inputs are not undefined
// and required outputs are not undefined.
const get = await s3a.getObject({
  Bucket: "",
  // @ts-expect-error (undefined not assignable to string)
  Key: undefined,
});

// UncheckedClient makes output fields non-nullable.
// You should still perform type checks as you deem
// necessary, but the SDK will no longer prompt you
// with nullability errors.
const body = await (
  await s3b.getObject({
    Bucket: "",
    Key: "",
  })
).Body.transformToString();
```

Quando si utilizza la trasformazione su un client non aggregato con la `Command` sintassi, l'input non può essere convalidato perché passa attraverso un'altra classe, come mostrato nell'esempio seguente.

```
import { S3Client, ListBucketsCommand, GetObjectCommand, GetObjectCommandInput } from "@aws-sdk/client-s3";
import type { AssertiveClient, UncheckedClient, NoUndefined } from "@smithy/types";

const s3 = new S3Client({}) as UncheckedClient<S3Client>;

const list = await s3.send(
  new ListBucketsCommand({
    // command inputs are not validated by the type transform.
    // because this is a separate class.
  })
);

/**
 * Although less ergonomic, you can use the NoUndefined<T>
 * transform on the input type.
 */
const getObjectInput: NoUndefined<GetObjectCommandInput> = {
  Bucket: "undefined",
  // @ts-expect-error (undefined not assignable to string)
  Key: undefined,
  // optional params can still be undefined.
  SSECustomerAlgorithm: undefined,
};

const get = s3.send(new GetObjectCommand(getObjectInput));

// outputs are still transformed.
await get.Body.TransformToString();
```

### Scenario: restringimento dei tipi di blob del payload di output di un client generato da Smithy TypeScript
<a name="remove-undefined-from-input"></a>

Questo scenario è principalmente rilevante per le operazioni con sistemi di streaming, ad esempio all'interno di in v3. `S3Client` AWS SDK per JavaScript 

Poiché i tipi di payload blob dipendono dalla piattaforma, potresti voler indicare nell'applicazione che un client è in esecuzione in un ambiente specifico. Questo restringe i tipi di payload blob, come illustrato nell'esempio seguente.

```
import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
import type { NodeJsClient, SdkStream, StreamingBlobPayloadOutputTypes } from "@smithy/types";
import type { IncomingMessage } from "node:http";

// default client init.
const s3Default = new S3Client({});

// client init with type narrowing.
const s3NarrowType = new S3Client({}) as NodeJsClient<S3Client>;

// The default type of blob payloads is a wide union type including multiple possible
// request handlers.
const body1: StreamingBlobPayloadOutputTypes = (await s3Default.send(new GetObjectCommand({ Key: "", Bucket: "" })))
  .Body!;

// This is of the narrower type SdkStream<IncomingMessage> representing
// blob payload responses using specifically the node:http request handler.
const body2: SdkStream<IncomingMessage> = (await s3NarrowType.send(new GetObjectCommand({ Key: "", Bucket: "" })))
  .Body!;
```

# Chiama i servizi in modo asincrono
<a name="calling-services-asynchronously"></a>

Tutte le richieste effettuate attraverso l'SDK sono asincrone. Questo è importante da tenere a mente quando si scrivono gli script del browser. JavaScript l'esecuzione in un browser Web in genere ha un solo thread di esecuzione. Dopo aver effettuato una chiamata asincrona a un AWS servizio, lo script del browser continua a essere eseguito e durante il processo può provare a eseguire il codice che dipende da quel risultato asincrono prima che venga restituito.

L'esecuzione di chiamate asincrone a un AWS servizio include la gestione di tali chiamate in modo che il codice non tenti di utilizzare i dati prima che i dati siano disponibili. Gli argomenti di questa sezione spiegano la necessità di gestire le chiamate asincrone e illustrano diverse tecniche che è possibile utilizzare per gestirle.

Sebbene sia possibile utilizzare una qualsiasi di queste tecniche per gestire le chiamate asincrone, si consiglia di utilizzarla per tutto il nuovo codice. async/await 

async/await  
Si consiglia di utilizzare questa tecnica in quanto è il comportamento predefinito in V3.

promettere  
Usa questa tecnica nei browser che non supportano async/await.

richiamata  
Evita di usare i callback tranne in casi molto semplici. Tuttavia, potresti trovarlo utile per gli scenari di migrazione.

**Topics**
+ [Gestisci le chiamate asincrone](making-asynchronous-calls.md)
+ [Usa async/await](using-async-await.md)
+ [Usa le promesse JavaScript](using-promises.md)
+ [Usa una funzione di callback anonima](using-a-callback-function.md)

# Gestisci le chiamate asincrone
<a name="making-asynchronous-calls"></a>

Ad esempio, la home page di un sito Web di e-commerce consente l'accesso ai clienti registrati. Parte del vantaggio per i clienti che effettuano l'accesso è che, dopo l'accesso, il sito si adatta alle loro preferenze specifiche. Per fare in modo che ciò accada:

1. Il cliente deve accedere ed essere convalidato con le proprie credenziali di accesso.

1. Le preferenze del cliente vengono richieste da un database dei clienti.

1. Il database fornisce le preferenze del cliente che vengono utilizzate per personalizzare il sito prima che la pagina venga caricata.

Se queste attività vengono eseguite in modo sincrono, ognuna deve terminare prima venga avviata quella successiva. Il caricamento della pagina web non potrà essere completato finché le preferenze del cliente non torneranno dal database. Tuttavia, dopo che la query del database viene inviata al server, la ricezione dei dati del cliente può essere posticipata o può addirittura fallire a causa di colli di bottiglia della rete, traffico di database eccezionalmente elevato o connessione scadente dei dispositivi mobili.

Per evitare che il sito Web si blocchi in tali condizioni, chiama il database in modo asincrono. Dopo l'esecuzione della chiamata al database, inviando la tua richiesta asincrona, il tuo codice continua a essere eseguito come previsto. Se non gestisci correttamente la risposta di una chiamata asincrona, il tuo codice può tentare di utilizzare le informazioni che si aspetta dal database quando tali dati non sono ancora disponibili.

![\[Differenza tra esecuzione sincrona e asincrona.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/async-vs-sync.png)


# Usa async/await
<a name="using-async-await"></a>

Piuttosto che usare le promesse, dovresti considerare l'uso di async/await. Le funzioni asincrone sono più semplici e richiedono meno boilerplate rispetto all'uso delle promesse. Await può essere utilizzato solo in una funzione asincrona per attendere in modo asincrono un valore.

L'esempio seguente utilizza async/await per elencare tutte le tabelle Amazon DynamoDB in. ` us-west-2`

**Nota**  
Per eseguire questo esempio:  
Installa il client AWS SDK per JavaScript DynamoDB `npm install @aws-sdk/client-dynamodb` entrando nella riga di comando del tuo progetto.
Assicurati di aver configurato correttamente le tue AWS credenziali. Per ulteriori informazioni, consulta [Imposta le credenziali](setting-credentials.md). 

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
(async function () {
  const dbClient = new DynamoDBClient({ region: "us-west-2" });
  const command = new ListTablesCommand({});

  try {
    const results = await dbClient.send(command);
    console.log(results.TableNames.join('\n'));
  } catch (err) {
    console.error(err)
  }
})();
```

**Nota**  
 Non tutti i browser supportano async/await. Vedi [Funzioni asincrone](https://caniuse.com/#feat=async-functions) per un elenco di browser supportati. async/await 

# Usa le promesse JavaScript
<a name="using-promises"></a>

Utilizza il metodo AWS SDK per JavaScript v3 (`ListTablesCommand`) del client di servizio per effettuare la chiamata di servizio e gestire il flusso asincrono invece di utilizzare i callback. L'esempio seguente mostra come inserire i nomi delle tabelle Amazon DynamoDB. `us-west-2`

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
const dbClient = new DynamoDBClient({ region: 'us-west-2' });

dbClient.listtables(new ListTablesCommand({}))
  .then(response => {
    console.log(response.TableNames.join('\n'));
  })
  .catch((error) => {
    console.error(error);
  });
```

## Coordina più promesse
<a name="multiple-promises"></a>

In alcune situazioni, il tuo codice deve effettuare più chiamate asincrone che richiedono un intervento solo quando sono state restituite tutte correttamente. Se gestisci tali chiamate singole al metodo asincrono con le promesse, puoi creare una promessa aggiuntiva che utilizza il metodo `all`. 

Questo metodo soddisfa questa promessa universale se e quando le promesse che trasferisci al metodo vengono soddisfatte. Alla funzione di callback viene trasferito una matrice dei valori delle promesse trasferite al metodo `all`.

Nell'esempio seguente, una AWS Lambda funzione deve effettuare tre chiamate asincrone ad Amazon DynamoDB, ma può essere completata solo dopo aver soddisfatto le promesse per ogni chiamata.

```
const values = await Promise.all([firstPromise, secondPromise, thirdPromise]);

console.log("Value 0 is " + values[0].toString);
console.log("Value 1 is " + values[1].toString);
console.log("Value 2 is " + values[2].toString);

return values;
```

## Browser e Node.js supportano le promesse
<a name="browser-node-promise-support"></a>

Il supporto per JavaScript le promesse native (ECMAScript 2015) dipende dal JavaScript motore e dalla versione in cui viene eseguito il codice. Per determinare il supporto per le JavaScript promesse in ogni ambiente in cui il codice deve essere eseguito, consulta la [tabella di ECMAScript compatibilità](https://compat-table.github.io/compat-table/es6/) su GitHub.

# Usa una funzione di callback anonima
<a name="using-a-callback-function"></a>

Ogni metodo dell'oggetto di servizio può accettare una funzione di callback anonima come ultimo parametro. La firma di questa funzione di callback è la seguente.

```
function(error, data) {
    // callback handling code
};
```

Questa funzione di callback viene eseguita quando vengono restituiti una risposta corretta o i dati dell'errore. Se la chiamata al metodo va a buon fine, i contenuti della risposta sono disponibili per la funzione di callback nel parametro `data`. Se la chiamata non va a buon fine, i dettagli sull'errore vengono forniti nel parametro `error`.

In genere il codice all'interno della funzione di callback verifica un errore, che elabora nel caso venga restituito. Se non viene restituito un errore, il codice recupera i dati dalla risposta dal parametro `data`. Il formato di base della funzione di callback è simile al seguente esempio.

```
function(error, data) {
    if (error) {
        // error handling code
        console.log(error);
    } else {
        // data handling code
        console.log(data);
    }
};
```

Nell'esempio precedente, i dettagli dell'errore o dei dati restituiti vengono registrati nella console. Ecco un esempio che mostra una funzione di callback trasferita come parte della chiamata a un metodo su un oggetto di servizio.

```
ec2.describeInstances(function(error, data) {
  if (error) {
    console.log(error); // an error occurred
  } else {
    console.log(data); // request succeeded
  }
});
```

# Crea richieste ai clienti di servizio
<a name="the-request-object"></a>

Effettuare richieste ai clienti del AWS servizio è semplice. La versione 3 (V3) dell'SDK JavaScript consente di inviare richieste. 

**Nota**  
È inoltre possibile eseguire operazioni utilizzando i comandi della versione 2 (V2) quando si utilizza la versione 3 dell'SDK for. JavaScript Per ulteriori informazioni, consulta [Utilizzo dei comandi v2](migrating.md#using_v2_commands).

**Per inviare una richiesta:**

1. Inizializza un oggetto client con la configurazione desiderata, ad esempio una AWS regione specifica.

1. (Facoltativo) Crea un oggetto JSON di richiesta con i valori per la richiesta, ad esempio il nome di uno specifico bucket Amazon S3. Puoi esaminare i parametri della richiesta consultando l'argomento API Reference relativo all'interfaccia con il nome associato al metodo client. Ad esempio, se si utilizza il metodo *AbcCommand* client, l'interfaccia di richiesta è*AbcInput*.

1. Inizializza un comando di servizio, facoltativamente, con l'oggetto di richiesta come input.

1. Chiama `send` il client con l'oggetto comando come input.

Ad esempio, per elencare le tue tabelle Amazon DynamoDB, puoi farlo con `us-west-2` async/await.

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";

(async function () {
  const dbClient = new DynamoDBClient({ region: 'us-west-2' });
  const command = new ListTablesCommand({});

  try {
    const results = await dbClient.send(command);
    console.log(results.TableNames.join('\n'));
  } catch (err) {
    console.error(err);
  }
})();
```

# Gestisci le risposte dei clienti di assistenza
<a name="the-response-object"></a>

Dopo che un metodo client di servizio è stato chiamato, restituisce un'istanza dell'oggetto di risposta di un'interfaccia con il nome associato al metodo client. Ad esempio, se si utilizza il metodo * AbcCommand* client, l'oggetto di risposta è di tipo *AbcResponse* (interfaccia).

## Accedi ai dati restituiti nella risposta
<a name="response-data-property"></a>

L'oggetto di risposta contiene i dati, come proprietà, restituiti dalla richiesta di servizio.

Nel[Crea richieste ai clienti di servizio](the-request-object.md), il ` ListTablesCommand` comando ha restituito i nomi delle tabelle nella `TableNames` proprietà della risposta.

## Informazioni sugli errori di accesso
<a name="response-error-property"></a>

Se un comando fallisce, genera un'eccezione. Il seguente frammento di codice mostra un modo per gestire un'eccezione di servizio.

```
try {
  await client.send(someCommand);
} catch (e) {
  if (e.name === "InvalidSignatureException") {
    // Handle InvalidSignatureException
  } else if (e.name === "ResourceNotFoundException") {
    // Handle ResourceNotFoundException
  } else if (e.name === "FooServiceException") {
    // Handle all other server-side exceptions from Foo service
  } else {
    // Handle errors from SDK
  }
}
```

# Lavora con JSON
<a name="working-with-json"></a>

JSON è un formato per lo scambio di dati leggibile sia dall'uomo che dalla macchina. Sebbene il nome JSON sia l'acronimo di *JavaScript Object Notation*, il formato di JSON è indipendente da qualsiasi linguaggio di programmazione.

 AWS SDK per JavaScript Utilizza JSON per inviare dati agli oggetti di servizio quando effettua richieste e riceve dati dagli oggetti di servizio come JSON. Per ulteriori informazioni su JSON, consulta [json.org](https://json.org).

![\[Formato generale e parti di JSON.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/json-format.png)


JSON rappresenta i dati in due modi:
+ Come *oggetto*, che è una raccolta non ordinata di coppie nome-valore. Un oggetto viene definito all'interno di parentesi graffe sinistra (`{`) e destra (`}`). Ogni coppia nome-valore inizia con il nome, seguita dai due punti e dal valore. Le coppie nome-valore sono separate da virgole.
+ Come *matrice*, che è una raccolta ordinata di valori. Una matrice viene definita all'interno di parentesi quadre sinistra (`[`) e destra (`]`). Gli elementi nella matrice sono separati da virgole.

Ecco un esempio di un oggetto JSON che contiene una matrice di oggetti in cui gli oggetti rappresentano le carte in un gioco di carte. Ogni carta è definita da due coppie nome-valore, una che specifica un valore univoco per identificare quella carta e un'altra che specifica un URL che punta all'immagine della carta corrispondente.

```
var cards = [
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"}
];
```

## JSON come parametri dell'oggetto di servizio
<a name="json-as-parameters-passed"></a>

Ecco un esempio di JSON semplice utilizzato per definire i parametri di una chiamata a un oggetto di AWS Lambda servizio.

```
const params = {
   FunctionName : funcName,
   Payload : JSON.stringify(payload),
   LogType : LogType.Tail,
};
```

L'oggetto `params` è definito da tre coppie nome-valore, separate da virgole e racchiuse fra parentesi graffe sinistra e destra. Quando si forniscono i parametri a una chiamata al metodo dell'oggetto di servizio, i nomi vengono determinati dai nomi dei parametri per il metodo dell'oggetto di servizio che si intende chiamare. Quando si richiama una funzione Lambda`FunctionName`,`Payload`, ` LogType` e sono i parametri utilizzati per chiamare il metodo su un oggetto `invoke` del servizio Lambda.

Quando passate parametri a una chiamata al metodo dell'oggetto servizio, fornite l'oggetto JSON alla chiamata al metodo, come illustrato nel seguente esempio di richiamo di una funzione Lambda.

```
const invoke = async (funcName, payload) => {
  const client = new LambdaClient({});
  const command = new InvokeCommand({
    FunctionName: funcName,
    Payload: JSON.stringify(payload),
    LogType: LogType.Tail,
  });

  const { Payload, LogResult } = await client.send(command);
  const result = Buffer.from(Payload).toString();
  const logs = Buffer.from(LogResult, "base64").toString();
  return { logs, result };
};
```

# Registrazione delle chiamate AWS SDK per JavaScript
<a name="logging-sdk-calls"></a>

 AWS SDK per JavaScript È dotato di un logger integrato che consente di registrare le chiamate API effettuate con l'SDK per. JavaScript

Per attivare il logger e stampare le voci di registro nella console, configura il client di servizio utilizzando il parametro opzionale. `logger` L'esempio seguente abilita la registrazione del client ignorando gli output di trace e debug.

```
new S3Client({
  logger: {
    ...console,
    debug(...args) {},
    trace(...args) {},
  },
});
```

## Utilizzo del middleware per registrare le richieste
<a name="middleware-logger"></a>

 AWS SDK per JavaScript Utilizza uno stack middleware per controllare il ciclo di vita di una chiamata operativa. Ogni middleware dello stack chiama il middleware successivo dopo aver apportato modifiche all'oggetto della richiesta. Inoltre, ciò semplifica notevolmente i problemi di debug nello stack, poiché è possibile vedere esattamente quale middleware è stato chiamato a causare un errore. Ecco un esempio di registrazione delle richieste tramite middleware:

```
const client = new DynamoDB({ region: "us-west-2" });

client.middlewareStack.add(
  (next, context) => async (args) => {
    console.log("AWS SDK context", context.clientName, context.commandName);
    console.log("AWS SDK request input", args.input);
    const result = await next(args);
    console.log("AWS SDK request output:", result.output);
    return result;
  },
  {
    name: "MyMiddleware",
    step: "build",
    override: true,
  }
);

await client.listTables({});
```

Nell'esempio precedente, un middleware viene aggiunto allo stack middleware del client DynamoDB. Il primo argomento è una funzione che accetta`next`, il middleware successivo nello stack da chiamare e un oggetto che contiene alcune informazioni sull'`context`operazione chiamata. Restituisce una funzione che accetta`args`, un oggetto che contiene i parametri passati all'operazione e alla richiesta e restituisce il risultato della chiamata al middleware successivo con. `args`

# Usa endpoint AWS basati su account con DynamoDB
<a name="ddb-account-based-endpoints-v3"></a>

DynamoDB [AWS offre endpoint basati su account](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.SDKOverview.html#Programming.SDKs.endpoints) che possono migliorare le prestazioni utilizzando l'ID dell'account per semplificare AWS il routing delle richieste. 

Per sfruttare questa funzionalità, è necessario utilizzare la versione 3.656.0 o successiva della versione 3. AWS SDK per JavaScript Questa funzionalità degli endpoint basata sull'account è abilitata per impostazione predefinita in questa nuova versione.

Se desideri disattivare il routing basato sull'account, hai le seguenti opzioni:
+ Configurare un client di servizio DynamoDB con `accountIdEndpointMode` il parametro impostato su. `disabled`
+ Imposta la variabile `AWS_ACCOUNT_ID_ENDPOINT_MODE` di ambiente su. `disabled`
+ Aggiorna l'impostazione del file di AWS configurazione condiviso `account_id_endpoint_mode` su`disabled`.

Il seguente frammento è un esempio di come disabilitare il routing basato su account configurando un client di servizio DynamoDB:

```
const ddbClient = new DynamoDBClient({
  region: "us-west-2",
  accountIdEndpointMode: "disabled" // Disable account ID in the endpoint
});
```

[La AWS SDKs and Tools Reference Guide fornisce ulteriori informazioni sulle altre opzioni di configurazione.](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html)

# Protezione dell'integrità dei dati con i checksum di Amazon S3
<a name="s3-checksums"></a>

Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) offre la possibilità di specificare un checksum quando carichi un oggetto. Quando specifichi un checksum, questo viene memorizzato con l'oggetto e può essere convalidato quando l'oggetto viene scaricato.

I checksum forniscono un ulteriore livello di integrità dei dati durante il trasferimento dei file. Con i checksum, è possibile verificare la coerenza dei dati confermando che il file ricevuto corrisponde al file originale. [Per ulteriori informazioni sui checksum con Amazon S3, consulta la Guida per l'[utente di Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html), inclusi gli algoritmi supportati.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums)

Hai la flessibilità di scegliere l'algoritmo più adatto alle tue esigenze e lasciare che sia l'SDK a calcolare il checksum. In alternativa, puoi fornire un valore di checksum precalcolato utilizzando uno degli algoritmi supportati.

**Nota**  
A partire dalla versione 3.729.0 di AWS SDK per JavaScript, l'SDK fornisce protezioni di integrità predefinite calcolando automaticamente un checksum per i caricamenti. `CRC32` L'SDK calcola questo checksum se non fornisci un valore di checksum precalcolato o se non specifichi un algoritmo che l'SDK deve utilizzare per calcolare un checksum.  
[L'SDK fornisce anche impostazioni globali per la protezione dell'integrità dei dati che puoi impostare esternamente, come puoi leggere nella Guida di riferimento agli strumenti e agli strumenti.AWS SDKs ](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html)

## Caricamento di un oggetto
<a name="use-service-S3-checksum-upload"></a>

Carichi oggetti su Amazon S3 utilizzando il [PutObject](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectCommand/)comando di. `S3Client` Utilizza il `ChecksumAlgorithm` parametro del generatore per abilitare il calcolo del `PutObjectRequest` checksum e specificare l'algoritmo. Consulta gli [algoritmi di checksum supportati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums) per i valori validi.

Il seguente frammento di codice mostra una richiesta di caricamento di un oggetto con un checksum CRC-32. Quando l'SDK invia la richiesta, calcola il checksum CRC-32 e carica l'oggetto. Amazon S3 memorizza il checksum con l'oggetto.

```
import { ChecksumAlgorithm, S3 } from "@aws-sdk/client-s3";

const client = new S3();
const response = await client.putObject({
  Bucket: "my-bucket",
  Key: "my-key",
  Body: "Hello, world!",
  ChecksumAlgorithm: ChecksumAlgorithm.CRC32,
});
```

Se non fornisci un algoritmo di checksum con la richiesta, il comportamento del checksum varia a seconda della versione dell'SDK che usi, come mostrato nella tabella seguente.

**Comportamento del checksum quando non viene fornito alcun algoritmo di checksum**


| SDK per versione JavaScript  | Comportamento del checksum | 
| --- | --- | 
| Precedente alla 3.729.0 | L'SDK non calcola automaticamente un checksum basato su CRC e lo fornisce nella richiesta. | 
| 3.729.0 o versione successiva | L'SDK utilizza l'CRC32algoritmo per calcolare il checksum e lo fornisce nella richiesta. Amazon S3 convalida l'integrità del trasferimento calcolando il proprio CRC32 checksum e lo confronta con il checksum fornito dall'SDK. Se i checksum corrispondono, il checksum viene salvato con l'oggetto. | 

Se il checksum calcolato dall'SDK non corrisponde al checksum calcolato da Amazon S3 quando riceve la richiesta, viene restituito un errore.

### Utilizza un valore di checksum precalcolato
<a name="use-service-S3-checksum-upload-pre"></a>

Un valore di checksum precalcolato fornito con la richiesta disabilita il calcolo automatico da parte dell'SDK e utilizza invece il valore fornito.

L'esempio seguente mostra una richiesta con un checksum SHA-256 precalcolato.

```
import { S3 } from "@aws-sdk/client-s3";
import { createHash } from "node:crypto";

const client = new S3();

const Body = "Hello, world!";
const ChecksumSHA256 = await createHash("sha256").update(Body).digest("base64");

const response = await client.putObject({
  Bucket: "my-bucket",
  Key: "my-key",
  Body,
  ChecksumSHA256,
});
```

Se Amazon S3 determina che il valore del checksum non è corretto per l'algoritmo specificato, il servizio restituisce una risposta di errore.

### Caricamenti in più parti
<a name="use-service-S3-checksum-upload-multi"></a>

Puoi anche utilizzare i checksum con caricamenti in più parti. AWS SDK per JavaScript Possono utilizzare le opzioni della `Upload` libreria to from per utilizzare i checksum con `@aws-sdk/lib-storage` caricamenti in più parti.

```
import { ChecksumAlgorithm, S3 } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import { createReadStream } from "node:fs";

const client = new S3();
const filePath = "/path/to/file";
const Body = createReadStream(filePath);

const upload = new Upload({
  client,
  params: {
    Bucket: "my-bucket",
    Key: "my-key",
    Body,
    ChecksumAlgorithm: ChecksumAlgorithm.CRC32,
  },
});
await upload.done();
```

# SDK per esempi di JavaScript codice
<a name="sdk-code-samples"></a>

Gli argomenti di questa sezione contengono esempi di come utilizzare AWS SDK per JavaScript i APIs vari servizi per eseguire attività comuni.

Trovate il codice sorgente per questi e altri esempi nel [AWS Code Examples Repository su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples). Per proporre un nuovo esempio di codice che il team addetto alla AWS documentazione possa prendere in considerazione la produzione, crea una richiesta. Il team sta cercando di produrre esempi di codice che coprano scenari e casi d'uso più ampi rispetto ai semplici frammenti di codice che coprono solo le singole chiamate API. Per istruzioni, consultate la sezione *Codice di creazione* nelle [linee guida per i contributi su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md).

**Importante**  
Questi esempi utilizzano la sintassi di ECMAScript6 importazione/esportazione.   
Ciò richiede la versione 14.17 o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci utilizzare la sintassi CommonJS, consulta le linee guida [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md) per la conversione.

**Topics**
+ [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)
+ [AWS Elemental MediaConvert esempi](emc-examples.md)
+ [AWS Lambda esempi](lambda-examples.md)
+ [Esempi di Amazon Lex](lex-examples.md)
+ [Esempi di Amazon Polly](polly-examples.md)
+ [Esempi di Amazon Redshift](redshift-examples.md)
+ [Esempi di Amazon Simple Email Service](ses-examples.md)
+ [Esempi di servizi di notifica Amazon Simple](sns-examples.md)
+ [Esempi di Amazon Transcribe](Transcribe-examples.md)
+ [Configurazione di Node.js su un'istanza Amazon EC2](setting-up-node-on-ec2-instance.md)
+ [Richiamare Lambda con API Gateway](api-gateway-invoking-lambda-example.md)
+ [Creazione di eventi pianificati per eseguire AWS Lambda funzioni](scheduled-events-invoking-lambda-example.md)
+ [Creazione di un chatbot Amazon Lex](lex-bot-example.md)

# JavaScript ES6Sintassi /CommonJS
<a name="sdk-example-javascript-syntax"></a>

Gli esempi di AWS SDK per JavaScript codice sono scritti in ECMAScript 6 (). ES6 ES6 offre una nuova sintassi e nuove funzionalità per rendere il codice più moderno e leggibile e fare di più. 

ES6 richiede l'utilizzo della versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). Tuttavia, se preferisci, puoi convertire uno qualsiasi dei nostri esempi nella sintassi CommonJS utilizzando le seguenti linee guida:
+ Rimuovi `"type" : "module"` dall'ambiente `package.json` del tuo progetto.
+ Converti tutte le ES6 `import` istruzioni in istruzioni CommonJS`require`. Ad esempio, converti:

  ```
  import { CreateBucketCommand } from "@aws-sdk/client-s3";
  import { s3 } from "./libs/s3Client.js";
  ```

  Al suo equivalente CommonJS:

  ```
  const { CreateBucketCommand } = require("@aws-sdk/client-s3");
  const { s3 } = require("./libs/s3Client.js");
  ```
+ Converti tutte le ES6 `export` istruzioni in istruzioni CommonJS`module.exports`. Ad esempio, converti:

  ```
  export {s3}
  ```

  Al suo equivalente CommonJS:

  ```
  module.exports = {s3}
  ```

L'esempio seguente mostra l'esempio di codice per la creazione di un bucket Amazon S3 sia in CommonJS che in ES6 CommonJS.

------
#### [ ES6 ]

libs/s3Client.js

```
// Create service client module using ES6 syntax.
import { S3Client } from "@aws-sdk/client-s3";
// Set the AWS region
const REGION = "eu-west-1"; //e.g. "us-east-1"
// Create Amazon S3 service object.
const s3 = new S3Client({ region: REGION });
// Export 's3' constant.
export {s3};
```

s3\$1createbucket.js

```
// Get service clients module and commands using ES6 syntax.
 import { CreateBucketCommand } from "@aws-sdk/client-s3";
 import { s3 } from "./libs/s3Client.js";

// Get service clients module and commands using CommonJS syntax.
// const { CreateBucketCommand } = require("@aws-sdk/client-s3");
// const { s3 } = require("./libs/s3Client.js");

// Set the bucket parameters
const bucketParams = { Bucket: "BUCKET_NAME" };

// Create the Amazon S3 bucket.
const run = async () => {
  try {
    const data = await s3.send(new CreateBucketCommand(bucketParams));
    console.log("Success", data.Location);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------
#### [ CommonJS ]

libs/s3Client.js

```
// Create service client module using CommonJS syntax.
 const { S3Client } = require("@aws-sdk/client-s3");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
 // Create Amazon S3 service object.
const s3 = new S3Client({ region: REGION });
// Export 's3' constant.
 module.exports ={s3};
```

s3\$1createbucket.js

```
// Get service clients module and commands using CommonJS syntax.
const { CreateBucketCommand } = require("@aws-sdk/client-s3");
const { s3 } = require("./libs/s3Client.js");

// Set the bucket parameters
const bucketParams = { Bucket: "BUCKET_NAME" };

// Create the Amazon S3 bucket.
const run = async () => {
  try {
    const data = await s3.send(new CreateBucketCommand(bucketParams));
    console.log("Success", data.Location);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------

# AWS Elemental MediaConvert esempi
<a name="emc-examples"></a>

AWS Elemental MediaConvert è un servizio di transcodifica video basato su file con funzionalità di livello broadcast. Puoi usarlo per creare risorse per la trasmissione e la distribuzione video-on-demand (VOD) su Internet. Per ulteriori informazioni, consulta la [Guida per l'utente *AWS Elemental MediaConvert *](https://docs.aws.amazon.com/mediaconvert/latest/ug/).

L' JavaScript API for MediaConvert è esposta tramite la classe `MediaConvert` client. Per ulteriori informazioni, consulta [Class: MediaConvert](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/) nel riferimento API.

**Topics**
+ [Creazione e gestione di lavori di transcodifica in MediaConvert](emc-examples-jobs.md)
+ [Utilizzo dei modelli di lavoro in MediaConvert](emc-examples-templates.md)

# Creazione e gestione di lavori di transcodifica in MediaConvert
<a name="emc-examples-jobs"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come creare lavori di transcodifica in. MediaConvert
+ Come annullare un processo di transcodifica.
+ Come recuperare il file JSON per un processo di transcodifica completato.
+ Come recuperare un array JSON per un massimo di 20 processi creati più di recente.

## Lo scenario
<a name="emc-examples-jobs-scenario"></a>

In questo esempio, si utilizza un modulo Node.js per chiamare per MediaConvert creare e gestire lavori di transcodifica. A tale scopo, il codice utilizza l' JavaScript SDK utilizzando questi metodi della MediaConvert classe client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CancelJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CancelJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/GetJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/GetJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobsCommand/)

## Attività prerequisite
<a name="emc-examples-jobs-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/master/javascriptv3/example_code/mediaconvert/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 e configura bucket Amazon S3 che forniscono storage per i file di input e output dei job. Per i dettagli, consulta [Creare spazio di archiviazione per i file](https://docs.aws.amazon.com/mediaconvert/latest/ug/set-up-file-locations.html) nella Guida per l'*AWS Elemental MediaConvert utente*.
+ Carica il video di input nel bucket Amazon S3 che hai fornito per lo storage di input. *Per un elenco dei codec e contenitori di input video supportati, consulta Codec e contenitori di [input supportati nella Guida per l'utente.](https://docs.aws.amazon.com/mediaconvert/latest/ug/reference-codecs-containers-input.html)AWS Elemental MediaConvert *
+ Crea un ruolo IAM che dia MediaConvert accesso ai tuoi file di input e ai bucket Amazon S3 in cui sono archiviati i file di output. *Per i dettagli, consulta [Configurare le autorizzazioni IAM nella Guida](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) per l'AWS Elemental MediaConvert utente.*

**Importante**  
Questo esempio utilizza ECMAScript6 (ES6). Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .  
Tuttavia, se preferisci utilizzare la sintassi CommonJS, fai riferimento a. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Definizione di un semplice processo di transcodifica
<a name="emc-examples-jobs-spec"></a>

Crea un modulo Node.js con il nome del file `emc_createjob.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Crea il file JSON che definisce i parametri del processo di transcodifica.

Questi parametri sono dettagliati. È possibile utilizzare la [AWS Elemental MediaConvert console](https://console.aws.amazon.com/mediaconvert/) per generare i parametri del lavoro JSON scegliendo le impostazioni del processo nella console e quindi selezionando **Mostra lavoro JSON** nella parte inferiore della sezione **Job**. Questo esempio illustra il JSON per un processo semplice.

**Nota**  
Sostituisci *JOB\$1QUEUE\$1ARN* con la coda dei MediaConvert lavori, *IAM\$1ROLE\$1ARN* con l'Amazon Resource Name (ARN) del ruolo IAM*OUTPUT\$1BUCKET\$1NAME*, con il nome del bucket di destinazione, ad esempio "s3://OUTPUT\$1BUCKET\$1NAME/ «, *INPUT\$1BUCKET\$1AND\$1FILENAME* e con il bucket di input e il nome del file, ad esempio" s3://INPUT\$1BUCKET/FILE\$1NAME».

```
const params = {
  Queue: "JOB_QUEUE_ARN", //JOB_QUEUE_ARN
  UserMetadata: {
    Customer: "Amazon",
  },
  Role: "IAM_ROLE_ARN", //IAM_ROLE_ARN
  Settings: {
    OutputGroups: [
      {
        Name: "File Group",
        OutputGroupSettings: {
          Type: "FILE_GROUP_SETTINGS",
          FileGroupSettings: {
            Destination: "OUTPUT_BUCKET_NAME", //OUTPUT_BUCKET_NAME, e.g., "s3://BUCKET_NAME/"
          },
        },
        Outputs: [
          {
            VideoDescription: {
              ScalingBehavior: "DEFAULT",
              TimecodeInsertion: "DISABLED",
              AntiAlias: "ENABLED",
              Sharpness: 50,
              CodecSettings: {
                Codec: "H_264",
                H264Settings: {
                  InterlaceMode: "PROGRESSIVE",
                  NumberReferenceFrames: 3,
                  Syntax: "DEFAULT",
                  Softness: 0,
                  GopClosedCadence: 1,
                  GopSize: 90,
                  Slices: 1,
                  GopBReference: "DISABLED",
                  SlowPal: "DISABLED",
                  SpatialAdaptiveQuantization: "ENABLED",
                  TemporalAdaptiveQuantization: "ENABLED",
                  FlickerAdaptiveQuantization: "DISABLED",
                  EntropyEncoding: "CABAC",
                  Bitrate: 5000000,
                  FramerateControl: "SPECIFIED",
                  RateControlMode: "CBR",
                  CodecProfile: "MAIN",
                  Telecine: "NONE",
                  MinIInterval: 0,
                  AdaptiveQuantization: "HIGH",
                  CodecLevel: "AUTO",
                  FieldEncoding: "PAFF",
                  SceneChangeDetect: "ENABLED",
                  QualityTuningLevel: "SINGLE_PASS",
                  FramerateConversionAlgorithm: "DUPLICATE_DROP",
                  UnregisteredSeiTimecode: "DISABLED",
                  GopSizeUnits: "FRAMES",
                  ParControl: "SPECIFIED",
                  NumberBFramesBetweenReferenceFrames: 2,
                  RepeatPps: "DISABLED",
                  FramerateNumerator: 30,
                  FramerateDenominator: 1,
                  ParNumerator: 1,
                  ParDenominator: 1,
                },
              },
              AfdSignaling: "NONE",
              DropFrameTimecode: "ENABLED",
              RespondToAfd: "NONE",
              ColorMetadata: "INSERT",
            },
            AudioDescriptions: [
              {
                AudioTypeControl: "FOLLOW_INPUT",
                CodecSettings: {
                  Codec: "AAC",
                  AacSettings: {
                    AudioDescriptionBroadcasterMix: "NORMAL",
                    RateControlMode: "CBR",
                    CodecProfile: "LC",
                    CodingMode: "CODING_MODE_2_0",
                    RawFormat: "NONE",
                    SampleRate: 48000,
                    Specification: "MPEG4",
                    Bitrate: 64000,
                  },
                },
                LanguageCodeControl: "FOLLOW_INPUT",
                AudioSourceName: "Audio Selector 1",
              },
            ],
            ContainerSettings: {
              Container: "MP4",
              Mp4Settings: {
                CslgAtom: "INCLUDE",
                FreeSpaceBox: "EXCLUDE",
                MoovPlacement: "PROGRESSIVE_DOWNLOAD",
              },
            },
            NameModifier: "_1",
          },
        ],
      },
    ],
    AdAvailOffset: 0,
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
        FileInput: "INPUT_BUCKET_AND_FILENAME", //INPUT_BUCKET_AND_FILENAME, e.g., "s3://BUCKET_NAME/FILE_NAME"
      },
    ],
    TimecodeConfig: {
      Source: "EMBEDDED",
    },
  },
};
```

## Creazione di un processo di transcodifica
<a name="emc-examples-jobs-create"></a>

Dopo aver creato i parametri di lavoro JSON, chiamate il `run` metodo asincrono per richiamare un oggetto del servizio `MediaConvert` client, passando i parametri. L'ID del processo creato viene restituito nei `data` della risposta.

```
const run = async () => {
  try {
    const data = await emcClient.send(new CreateJobCommand(params));
    console.log("Job created!", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi.

```
node emc_createjob.js 
```

Questo codice di esempio completo è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_createjob.js).

## Annullamento di un processo di transcodifica
<a name="emc-examples-jobs-cancel"></a>

Crea un modulo Node.js con il nome del file `emc_canceljob.js`. Assicurati di configurare l'SDK come mostrato in precedenza, incluso il download dei client e dei pacchetti richiesti. Crea il file JSON che include l'ID del processo da annullare. Quindi chiamate il `CancelJobCommand` metodo creando una promessa per richiamare un oggetto `MediaConvert` del servizio client, passando i parametri. Gestisci la risposta restituita dal callback della promessa.

**Nota**  
Sostituisci *JOB\$1ID* con l'ID del lavoro da annullare.

```
// Import required AWS-SDK clients and commands for Node.js
import { CancelJobCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = { Id: "JOB_ID" }; //JOB_ID

const run = async () => {
  try {
    const data = await emcClient.send(new CancelJobCommand(params));
    console.log(`Job  ${params.Id} is canceled`);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node ec2_canceljob.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_canceljob.js).

## Elenco dei lavori di transcodifica recenti
<a name="emc-examples-jobs-listing"></a>

Crea un modulo Node.js con il nome del file `emc_listjobs.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea i parametri JSON, inclusi i valori per specificare se ordinare o `DESCENDING` ordinare l'elenco in `ASCENDING` base all'Amazon Resource Name (ARN) della coda dei lavori da controllare e lo stato dei lavori da includere. Quindi chiama il `ListJobsCommand` metodo creando una promessa per richiamare un oggetto `MediaConvert` del servizio client, passando i parametri. 

**Nota**  
Sostituisci *QUEUE\$1ARN* con l'Amazon Resource Name (ARN) della coda dei lavori da controllare e *STATUS* con lo stato della coda.

```
// Import required AWS-SDK clients and commands for Node.js
import { ListJobsCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = {
  MaxResults: 10,
  Order: "ASCENDING",
  Queue: "QUEUE_ARN",
  Status: "SUBMITTED", // e.g., "SUBMITTED"
};

const run = async () => {
  try {
    const data = await emcClient.send(new ListJobsCommand(params));
    console.log("Success. Jobs: ", data.Jobs);
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node emc_listjobs.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_listjobs.js).

# Utilizzo dei modelli di lavoro in MediaConvert
<a name="emc-examples-templates"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come creare modelli AWS Elemental MediaConvert di lavoro.
+ Come utilizzare un modello dei processi per creare un processo di transcodifica.
+ Come elencare tutti i modelli dei processi.
+ Come eliminare i modelli dei processi

## Lo scenario
<a name="emc-examples-templates-scenario"></a>

Il codice JSON richiesto per creare un processo di transcodifica in MediaConvert è dettagliato e contiene un gran numero di impostazioni. È possibile semplificare notevolmente la creazione del processo salvando le impostazioni corrette in un modello del processo che è possibile utilizzare per creare processi successivi. In questo esempio, si utilizza un modulo Node.js per chiamare per MediaConvert creare, utilizzare e gestire modelli di lavoro. A tale scopo, il codice utilizza l'SDK utilizzando questi metodi della classe MediaConvert client: JavaScript 
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/DeleteJobTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/DeleteJobTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobTemplatesCommand/)

## Attività prerequisite
<a name="emc-example-templates-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/master/javascriptv3/example_code/mediaconvert/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 un ruolo IAM che dia MediaConvert accesso ai tuoi file di input e ai bucket Amazon S3 in cui sono archiviati i file di output. *Per i dettagli, consulta [Configurare le autorizzazioni IAM nella Guida](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) per l'AWS Elemental MediaConvert utente.*

**Importante**  
Questi esempi utilizzano ECMAScript6 (ES6). Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .  
Tuttavia, se preferisci utilizzare la sintassi CommonJS, fai riferimento a. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Creazione di un modello di lavoro
<a name="emc-examples-templates-create"></a>

Crea un modulo Node.js con il nome del file `emc_create_jobtemplate.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Specifica il file JSON dei parametri per la creazione del modello. È possibile utilizzare la maggior parte dei parametri JSON da un processo di successo precedente per specificare i valori `Settings` nel modello. In questo esempio vengono utilizzate le impostazioni del processo contenute in [Creazione e gestione di lavori di transcodifica in MediaConvert](emc-examples-jobs.md).

Chiamate il `CreateJobTemplateCommand` metodo creando una promessa per richiamare un oggetto `MediaConvert` del servizio client, passando i parametri.

**Nota**  
Sostituisci *JOB\$1QUEUE\$1ARN* con l'Amazon Resource Name (ARN) della coda dei lavori da controllare e *BUCKET\$1NAME* con il nome del bucket Amazon S3 di destinazione, ad esempio "s3://BUCKET\$1NAME/». 

```
// Import required AWS-SDK clients and commands for Node.js
import { CreateJobTemplateCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  Category: "YouTube Jobs",
  Description: "Final production transcode",
  Name: "DemoTemplate",
  Queue: "JOB_QUEUE_ARN", //JOB_QUEUE_ARN
  Settings: {
    OutputGroups: [
      {
        Name: "File Group",
        OutputGroupSettings: {
          Type: "FILE_GROUP_SETTINGS",
          FileGroupSettings: {
            Destination: "BUCKET_NAME", // BUCKET_NAME e.g., "s3://BUCKET_NAME/"
          },
        },
        Outputs: [
          {
            VideoDescription: {
              ScalingBehavior: "DEFAULT",
              TimecodeInsertion: "DISABLED",
              AntiAlias: "ENABLED",
              Sharpness: 50,
              CodecSettings: {
                Codec: "H_264",
                H264Settings: {
                  InterlaceMode: "PROGRESSIVE",
                  NumberReferenceFrames: 3,
                  Syntax: "DEFAULT",
                  Softness: 0,
                  GopClosedCadence: 1,
                  GopSize: 90,
                  Slices: 1,
                  GopBReference: "DISABLED",
                  SlowPal: "DISABLED",
                  SpatialAdaptiveQuantization: "ENABLED",
                  TemporalAdaptiveQuantization: "ENABLED",
                  FlickerAdaptiveQuantization: "DISABLED",
                  EntropyEncoding: "CABAC",
                  Bitrate: 5000000,
                  FramerateControl: "SPECIFIED",
                  RateControlMode: "CBR",
                  CodecProfile: "MAIN",
                  Telecine: "NONE",
                  MinIInterval: 0,
                  AdaptiveQuantization: "HIGH",
                  CodecLevel: "AUTO",
                  FieldEncoding: "PAFF",
                  SceneChangeDetect: "ENABLED",
                  QualityTuningLevel: "SINGLE_PASS",
                  FramerateConversionAlgorithm: "DUPLICATE_DROP",
                  UnregisteredSeiTimecode: "DISABLED",
                  GopSizeUnits: "FRAMES",
                  ParControl: "SPECIFIED",
                  NumberBFramesBetweenReferenceFrames: 2,
                  RepeatPps: "DISABLED",
                  FramerateNumerator: 30,
                  FramerateDenominator: 1,
                  ParNumerator: 1,
                  ParDenominator: 1,
                },
              },
              AfdSignaling: "NONE",
              DropFrameTimecode: "ENABLED",
              RespondToAfd: "NONE",
              ColorMetadata: "INSERT",
            },
            AudioDescriptions: [
              {
                AudioTypeControl: "FOLLOW_INPUT",
                CodecSettings: {
                  Codec: "AAC",
                  AacSettings: {
                    AudioDescriptionBroadcasterMix: "NORMAL",
                    RateControlMode: "CBR",
                    CodecProfile: "LC",
                    CodingMode: "CODING_MODE_2_0",
                    RawFormat: "NONE",
                    SampleRate: 48000,
                    Specification: "MPEG4",
                    Bitrate: 64000,
                  },
                },
                LanguageCodeControl: "FOLLOW_INPUT",
                AudioSourceName: "Audio Selector 1",
              },
            ],
            ContainerSettings: {
              Container: "MP4",
              Mp4Settings: {
                CslgAtom: "INCLUDE",
                FreeSpaceBox: "EXCLUDE",
                MoovPlacement: "PROGRESSIVE_DOWNLOAD",
              },
            },
            NameModifier: "_1",
          },
        ],
      },
    ],
    AdAvailOffset: 0,
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
      },
    ],
    TimecodeConfig: {
      Source: "EMBEDDED",
    },
  },
};

const run = async () => {
  try {
    // Create a promise on a MediaConvert object
    const data = await emcClient.send(new CreateJobTemplateCommand(params));
    console.log("Success!", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node emc_create_jobtemplate.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_create_jobtemplate.js).

## Creazione di un processo di transcodifica da un modello di lavoro
<a name="emc-examples-templates-createjob"></a>

Crea un modulo Node.js con il nome del file `emc_template_createjob.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea il JSON dei parametri di creazione del processo, tra cui il nome del modello del processo e le `Settings` da utilizzare che sono specifiche per il processo. Quindi chiamate il `CreateJobsCommand` metodo creando una promessa per richiamare un oggetto `MediaConvert` del servizio client, passando i parametri. 

**Nota**  
Sostituisci *JOB\$1QUEUE\$1ARN* con l'Amazon Resource Name (ARN) della coda dei lavori per verificare, *KEY\$1PAIR\$1NAME* con, con, *TEMPLATE\$1NAME* con *ROLE\$1ARN* l'Amazon Resource Name (ARN) del ruolo e * INPUT\$1BUCKET\$1AND\$1FILENAME* con il bucket di input e il nome del file, ad esempio "s3://BUCKET\$1NAME/FILE\$1NAME».

```
// Import required AWS-SDK clients and commands for Node.js
import { CreateJobCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  Queue: "QUEUE_ARN", //QUEUE_ARN
  JobTemplate: "TEMPLATE_NAME", //TEMPLATE_NAME
  Role: "ROLE_ARN", //ROLE_ARN
  Settings: {
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
        FileInput: "INPUT_BUCKET_AND_FILENAME", //INPUT_BUCKET_AND_FILENAME, e.g., "s3://BUCKET_NAME/FILE_NAME"
      },
    ],
  },
};

const run = async () => {
  try {
    const data = await emcClient.send(new CreateJobCommand(params));
    console.log("Success! ", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node emc_template_createjob.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Elencare i modelli di lavoro
<a name="emc-examples-templates-listing"></a>

Crea un modulo Node.js con il nome del file `emc_listtemplates.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire i parametri della richiesta vuoti per il metodo `listTemplates` della classe del client `MediaConvert`. Includi valori per determinare i modelli da elencare (`NAME`, `CREATION DATE`, `SYSTEM`), il numero da elencare e il loro ordinamento. Per chiamare il `ListTemplatesCommand` metodo, create una promessa di richiamo di un oggetto MediaConvert del servizio client, passando i parametri. 

```
// Import required AWS-SDK clients and commands for Node.js
import { ListJobTemplatesCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  ListBy: "NAME",
  MaxResults: 10,
  Order: "ASCENDING",
};

const run = async () => {
  try {
    const data = await emcClient.send(new ListJobTemplatesCommand(params));
    console.log("Success ", data.JobTemplates);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi.

```
node emc_listtemplates.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Eliminazione di un modello di lavoro
<a name="emc-examples-templates-delete"></a>

Crea un modulo Node.js con il nome del file `emc_deletetemplate.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per inoltrare il nome del modello del processo da eliminare come parametri per il metodo `DeleteJobTemplateCommand` della classe client `MediaConvert`. Per chiamare il `DeleteJobTemplateCommand` metodo, create una promessa di richiamo di un oggetto MediaConvert del servizio client, passando i parametri. 

```
// Import required AWS-SDK clients and commands for Node.js
import { DeleteJobTemplateCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = { Name: "test" }; //TEMPLATE_NAME

const run = async () => {
  try {
    const data = await emcClient.send(new DeleteJobTemplateCommand(params));
    console.log(
      "Success, template deleted! Request ID:",
      data.$metadata.requestId,
    );
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi.

```
node emc_deletetemplate.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_deletetemplate.js).

# AWS Lambda esempi
<a name="lambda-examples"></a>

AWS Lambda è un servizio di elaborazione serverless che consente di eseguire codice senza effettuare il provisioning o la gestione di server, creare una logica di scalabilità del cluster che riconosca il carico di lavoro, mantenere integrazioni di eventi o gestire i runtime. 

L'API for è esposta tramite la classe client. JavaScript AWS Lambda [LambdaService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lambda/)

Ecco un elenco di esempi che dimostrano come creare e utilizzare le funzioni Lambda con la AWS SDK per JavaScript v3:
+ [Richiamare Lambda con API Gateway](api-gateway-invoking-lambda-example.md)
+ [Creazione di eventi pianificati per eseguire AWS Lambda funzioni](scheduled-events-invoking-lambda-example.md)

# Esempi di Amazon Lex
<a name="lex-examples"></a>

Amazon Lex è un AWS servizio per la creazione di interfacce conversazionali in applicazioni che utilizzano voce e testo. 

L' JavaScript API per Amazon Lex è esposta tramite la classe client [Lex Runtime Service](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lex-runtime-service/).
+ [Creazione di un chatbot Amazon Lex](lex-bot-example.md)

# Esempi di Amazon Polly
<a name="polly-examples"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Caricare l'audio registrato con Amazon Polly su Amazon S3

## Lo scenario
<a name="polly-example-synthesize-to-s3-scenario"></a>

In questo esempio, una serie di moduli Node.js viene utilizzata per caricare automaticamente l'audio registrato utilizzando Amazon Polly su Amazon S3 utilizzando questi metodi della classe client Amazon S3:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-polly/Class/StartSpeechSynthesisTaskCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-polly/Class/StartSpeechSynthesisTaskCommand/)

## Attività prerequisite
<a name="polly-example-synthesize-to-s3-prerequisites"></a>

Per configurare ed eseguire questo esempio, è necessario completare queste attività:
+ Configura un ambiente di progetto per eseguire JavaScript esempi di Node seguendo le istruzioni su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/s3/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 un ruolo utente Amazon Cognito AWS Identity and Access Management (IAM) non autenticato pollySynthesizeSpeech : permessi e un pool di identità Amazon Cognito a cui è associato il ruolo IAM. La [Crea le risorse utilizzando il AWS CloudFormation](#polly-example-synthesize-to-s3-create-resources) sezione seguente descrive come creare queste risorse.

**Nota**  
Questo esempio utilizza Amazon Cognito, ma se non utilizzi Amazon Cognito, l'utente deve avere AWS la seguente politica di autorizzazione IAM  

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": [
        "mobileanalytics:PutEvents",
        "cognito-sync:*"
      ],
      "Resource": "*",
      "Effect": "Allow"
    },
    {
      "Action": "polly:SynthesizeSpeech",
      "Resource": "*",
      "Effect": "Allow"
    }
  ]
}
```

## Crea le risorse utilizzando il AWS CloudFormation
<a name="polly-example-synthesize-to-s3-create-resources"></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:

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/polly/general-examples/src/setup.yaml) 
**Nota**  
Il CloudFormation modello è stato generato utilizzando quello AWS CDK [disponibile qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/javascript_example_code_polly_aws_service/). 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. Accedi alla console di CloudFormation gestione, scegli **Stack**, scegli il nome dello stack e scegli la scheda **Risorse** per visualizzare un elenco delle risorse create.  
![\[CloudFormation risorse\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/cfn_polly.png)

## Caricare l'audio registrato con Amazon Polly su Amazon S3
<a name="polly-example-synthesize-to-s3-example"></a>

Crea un modulo Node.js con il nome del file `polly_synthesize_to_s3.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Nel codice, inserisci il*REGION*, e il*BUCKET\$1NAME*. Per accedere ad Amazon Polly, crea un oggetto di servizio `Polly` client. Sostituisci *"IDENTITY\$1POOL\$1ID"* con la `IdentityPoolId` **pagina Sample** del pool di identità Amazon Cognito che hai creato per questo esempio. Questo viene passato anche a ciascun oggetto client.

Chiama il `StartSpeechSynthesisCommand` metodo dell'oggetto del servizio client Amazon Polly, sintetizza il messaggio vocale e caricalo nel bucket Amazon S3. 

```
import { StartSpeechSynthesisTaskCommand } from "@aws-sdk/client-polly";
import { pollyClient } from "./libs/pollyClient.js";

// Create the parameters
const params = {
  OutputFormat: "mp3",
  OutputS3BucketName: "videoanalyzerbucket",
  Text: "Hello David, How are you?",
  TextType: "text",
  VoiceId: "Joanna",
  SampleRate: "22050",
};

const run = async () => {
  try {
    await pollyClient.send(new StartSpeechSynthesisTaskCommand(params));
    console.log(`Success, audio file added to ${params.OutputS3BucketName}`);
  } catch (err) {
    console.log("Error putting object", err);
  }
};
run();
```

[Questo codice di esempio può essere trovato qui su. GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/polly/general-examples/src/polly_synthesize_to_s3.js)

# Esempi di Amazon Redshift
<a name="redshift-examples"></a>

Amazon Redshift è un servizio di data warehouse nel cloud in scala petabyte interamente gestito. Un data warehouse Amazon Redshift è costituito da un insieme di risorse di calcolo denominate *nodi*, strutturate in un gruppo denominato *cluster*. Ciascun cluster esegue un motore Amazon Redshift e contiene uno o più database.

![\[Relazione tra JavaScript ambienti, SDK e Amazon Redshift\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/code-samples-redshift.png)


L' JavaScript API per Amazon Redshift è esposta tramite la classe client [Amazon Redshift](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/Redshift/).

**Topics**
+ [Esempi di Amazon Redshift](redshift-examples-section.md)

# Esempi di Amazon Redshift
<a name="redshift-examples-section"></a>

In questo esempio, una serie di moduli Node.js vengono utilizzati per creare, modificare, descrivere i parametri e quindi eliminare i cluster Amazon Redshift utilizzando i seguenti metodi della `Redshift` classe client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/)

Per ulteriori informazioni sugli utenti di Amazon Redshift, consulta la guida introduttiva di [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html).

## Attività prerequisite
<a name="s3-example-configuring-buckets-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/redshift/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.

**Importante**  
Questi esempi mostrano come importare/esportare oggetti e comandi del servizio client utilizzando (). ECMAScript6 ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Creazione di un cluster Amazon Redshift
<a name="redshift-create-cluster"></a>

Questo esempio dimostra come creare un cluster Amazon Redshift utilizzando. AWS SDK per JavaScript Per ulteriori informazioni, consulta [CreateCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_CreateCluster).

**Importante**  
*Il cluster che stai per creare è attivo (e non è in esecuzione in una sandbox). Saranno addebitati i costi standard di utilizzo di Amazon Redshift relativi al cluster finché non viene eliminato. Se elimini il cluster nella stessa sessione in cui lo hai creato, i costi totali sono minimi.* 

Create una `libs` directory e create un modulo Node.js con il nome del file`redshiftClient.js`. Copia e incolla il codice seguente al suo interno, che crea l'oggetto client Amazon Redshift. *REGION*Sostituiscilo con la tua AWS regione.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Crea un modulo Node.js con il nome del file `redshift-create-cluster.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Create un oggetto parametrico, specificando il tipo di nodo da assegnare e le credenziali di accesso principali per l'istanza di database creata automaticamente nel cluster e infine il tipo di cluster.

**Nota**  
Sostituisci *CLUSTER\$1NAME* con il nome del cluster. Per *NODE\$1TYPE* specificare il tipo di nodo da fornire, ad esempio 'dc2.large', ad esempio. *MASTER\$1USERNAME*e *MASTER\$1USER\$1PASSWORD* sono le credenziali di accesso dell'utente principale dell'istanza DB nel cluster. Per*CLUSTER\$1TYPE*, inserisci il tipo di cluster. Se lo specificate`single-node`, non è necessario il `NumberOfNodes` parametro. I parametri rimanenti sono opzionali. 

```
// Import required AWS SDK clients and commands for Node.js
import { CreateClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME", // Required
  NodeType: "NODE_TYPE", //Required
  MasterUsername: "MASTER_USER_NAME", // Required - must be lowercase
  MasterUserPassword: "MASTER_USER_PASSWORD", // Required - must contain at least one uppercase letter, and one number
  ClusterType: "CLUSTER_TYPE", // Required
  IAMRoleARN: "IAM_ROLE_ARN", // Optional - the ARN of an IAM role with permissions your cluster needs to access other AWS services on your behalf, such as Amazon S3.
  ClusterSubnetGroupName: "CLUSTER_SUBNET_GROUPNAME", //Optional - the name of a cluster subnet group to be associated with this cluster. Defaults to 'default' if not specified.
  DBName: "DATABASE_NAME", // Optional - defaults to 'dev' if not specified
  Port: "PORT_NUMBER", // Optional - defaults to '5439' if not specified
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new CreateClusterCommand(params));
    console.log(
      `Cluster ${data.Cluster.ClusterIdentifier} successfully created`,
    );
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node redshift-create-cluster.js  
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-create-cluster.js). GitHub

## Modifica di un cluster Amazon Redshift
<a name="redshift-modify-cluster"></a>

Questo esempio mostra come modificare la password dell'utente principale di un cluster Amazon Redshift utilizzando. AWS SDK per JavaScript Per ulteriori informazioni su quali altre impostazioni puoi modificare, consulta [ModifyCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_ModifyCluster.html).

Create una `libs` directory e create un modulo Node.js con il nome del file`redshiftClient.js`. Copia e incolla il codice seguente al suo interno, che crea l'oggetto client Amazon Redshift. *REGION*Sostituiscilo con la tua AWS regione.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Crea un modulo Node.js con il nome del file `redshift-modify-cluster.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Specificate la AWS regione, il nome del cluster che desiderate modificare e la nuova password dell'utente principale.

**Nota**  
Sostituisci *CLUSTER\$1NAME* con il nome del cluster e *MASTER\$1USER\$1PASSWORD* con la nuova password dell'utente principale. 

```
// Import required AWS SDK clients and commands for Node.js
import { ModifyClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

// Set the parameters
const params = {
  ClusterIdentifier: "CLUSTER_NAME",
  MasterUserPassword: "NEW_MASTER_USER_PASSWORD",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new ModifyClusterCommand(params));
    console.log("Success was modified.", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node redshift-modify-cluster.js 
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-modify-cluster.js). GitHub

## Visualizzazione dei dettagli di un cluster Amazon Redshift
<a name="redshift-describe-cluster"></a>

Questo esempio mostra come visualizzare i dettagli di un cluster Amazon Redshift utilizzando il. AWS SDK per JavaScript Per ulteriori informazioni su optional, consulta [DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html).

Create una `libs` directory e create un modulo Node.js con il nome del file`redshiftClient.js`. Copia e incolla il codice seguente al suo interno, che crea l'oggetto client Amazon Redshift. *REGION*Sostituiscilo con la tua AWS regione.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Crea un modulo Node.js con il nome del file `redshift-describe-clusters.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Specificate la AWS regione, il nome del cluster che desiderate modificare e la nuova password dell'utente principale.

**Nota**  
Sostituisci *CLUSTER\$1NAME* con il nome del cluster. 

```
// Import required AWS SDK clients and commands for Node.js
import { DescribeClustersCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new DescribeClustersCommand(params));
    console.log("Success", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node redshift-describe-clusters.js 
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-describe-clusters.js). GitHub

## Eliminare un cluster Amazon Redshift
<a name="redshift-delete-cluster"></a>

Questo esempio mostra come visualizzare i dettagli di un cluster Amazon Redshift utilizzando il. AWS SDK per JavaScript Per ulteriori informazioni su quali altre impostazioni puoi modificare, consulta [DeleteCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DeleteCluster.html).

Create una `libs` directory e create un modulo Node.js con il nome del file`redshiftClient.js`. Copia e incolla il codice seguente al suo interno, che crea l'oggetto client Amazon Redshift. *REGION*Sostituiscilo con la tua AWS regione.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Crea un modulo Node.js con il nome del file`redshift-delete-clusters.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Specificate la AWS regione, il nome del cluster che desiderate modificare e la nuova password dell'utente principale. Specificare se si desidera salvare un'istantanea finale del cluster prima dell'eliminazione e, in tal caso, l'ID dell'istantanea.

**Nota**  
Sostituisci *CLUSTER\$1NAME* con il nome del cluster. Per il*SkipFinalClusterSnapshot*, specificare se creare un'istantanea finale del cluster prima di eliminarlo. Se specifichi 'false', specifica l'id dell'istantanea finale del cluster in. *CLUSTER\$1SNAPSHOT\$1ID* ****Puoi ottenere questo ID facendo clic sul collegamento nella colonna **Istantanee** per il cluster nella dashboard dei cluster e scorrendo verso il basso fino al riquadro Istantanee.**** Nota che lo stem non `rs:` fa parte dell'ID dell'istantanea.

```
// Import required AWS SDK clients and commands for Node.js
import { DeleteClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME",
  SkipFinalClusterSnapshot: false,
  FinalClusterSnapshotIdentifier: "CLUSTER_SNAPSHOT_ID",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new DeleteClusterCommand(params));
    console.log("Success, cluster deleted. ", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi.

```
node redshift-delete-cluster.js  
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-delete-cluster.js). GitHub

# Esempi di Amazon Simple Email Service
<a name="ses-examples"></a>

Amazon Simple Email Service (Amazon SES) Simple Email Service (Amazon SES) è un servizio di invio e-mail basato sul cloud progettato per aiutare i professionisti del marketing digitale e gli sviluppatori di applicazioni a inviare e-mail di marketing, notifiche e transazionali. Si tratta di un servizio affidabile, a costo ridotto per aziende di tutte le dimensioni che utilizzano la posta elettronica per mantenere il contatto con i clienti.

![\[Relazione tra JavaScript ambienti, SDK e Amazon SES\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)


L' JavaScript API per Amazon SES è esposta tramite la classe `SES` client. Per ulteriori informazioni sull'uso della classe client Amazon SES, consulta [Class: SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/) nell'API Reference.

**Topics**
+ [Gestione delle identità Amazon SES](ses-examples-managing-identities.md)
+ [Utilizzo dei modelli di e-mail in Amazon SES](ses-examples-creating-template.md)
+ [Invio di e-mail tramite Amazon SES](ses-examples-sending-email.md)

# Gestione delle identità Amazon SES
<a name="ses-examples-managing-identities"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come verificare gli indirizzi e-mail e i domini utilizzati con Amazon SES.
+ Come assegnare una policy AWS Identity and Access Management (IAM) alle identità Amazon SES.
+ Come elencare tutte le identità Amazon SES per il tuo AWS account.
+ Come eliminare le identità utilizzate con Amazon SES.

Un'*identità* Amazon SES è un indirizzo e-mail o un dominio che Amazon SES utilizza per inviare e-mail. Amazon SES richiede che verifichi le tue identità e-mail, confermando che le possiedi e impedendo ad altri di utilizzarle.

Per dettagli su come verificare indirizzi e-mail e domini in Amazon SES, consulta la sezione [Verifica degli indirizzi e-mail e dei domini in Amazon SES nella Amazon Simple](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) Email Service Developer Guide. Per informazioni sull'autorizzazione all'invio in Amazon SES, consulta [Panoramica dell'autorizzazione all'invio di Amazon SES](Amazon Simple Email Service Developer Guidesending-authorization-overview.html).

## Lo scenario
<a name="ses-examples-verifying-identities-scenario"></a>

In questo esempio, utilizzi una serie di moduli Node.js per verificare e gestire le identità di Amazon SES. I moduli Node.js utilizzano l'SDK per JavaScript verificare indirizzi e-mail e domini, utilizzando questi metodi della `SES` classe client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/)

## Attività prerequisite
<a name="ses-examples-verifying-identities-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/ses/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](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) nella Guida di riferimento *agli strumenti AWS SDKs e agli strumenti*.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Elencare le tue identità
<a name="ses-examples-listing-identities"></a>

In questo esempio, utilizza un modulo Node.js per elencare gli indirizzi e-mail e i domini da utilizzare con Amazon SES.

Crea una `libs` directory e crea un modulo Node.js con il nome `sesClient.js` del file. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_listidentities.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire `IdentityType` e altri parametri per il metodo `ListIdentitiesCommand` della classe client `SES`. Per chiamare il `ListIdentitiesCommand` metodo, richiama un oggetto di servizio Amazon SES, passando l'oggetto parameters. 

 Il `data` valore restituito contiene una matrice di identità di dominio come specificato dal `IdentityType` parametro.

**Nota**  
Sostituisci *IdentityType* con il tipo di identità, che può essere "EmailAddress" o «Dominio».

```
import { ListIdentitiesCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createListIdentitiesCommand = () =>
  new ListIdentitiesCommand({ IdentityType: "EmailAddress", MaxItems: 10 });

const run = async () => {
  const listIdentitiesCommand = createListIdentitiesCommand();

  try {
    return await sesClient.send(listIdentitiesCommand);
  } catch (err) {
    console.log("Failed to list identities.", err);
    return err;
  }
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node ses_listidentities.js 
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js).

## Verifica di un'identità indirizzo e-mail
<a name="ses-examples-verifying-email"></a>

In questo esempio, utilizza un modulo Node.js per verificare i mittenti di posta elettronica da utilizzare con Amazon SES.

Crea una `libs` directory e crea un modulo Node.js con il nome `sesClient.js` del file. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_verifyemailidentity.js`. Configura l'SDK come mostrato in precedenza, incluso il download dei client e dei pacchetti richiesti. 

Crea un oggetto per trasferire il parametro `EmailAddress` per il metodo `VerifyEmailIdentityCommand` della classe client `SES`. Per chiamare il `VerifyEmailIdentityCommand` metodo, richiama un oggetto del servizio client Amazon SES, passando i parametri. 

**Nota**  
Sostituiscilo *EMAIL\$1ADDRESS* con l'indirizzo e-mail, ad esempio name@example.com.

```
// Import required AWS SDK clients and commands for Node.js
import { VerifyEmailIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const EMAIL_ADDRESS = "name@example.com";

const createVerifyEmailIdentityCommand = (emailAddress) => {
  return new VerifyEmailIdentityCommand({ EmailAddress: emailAddress });
};

const run = async () => {
  const verifyEmailIdentityCommand =
    createVerifyEmailIdentityCommand(EMAIL_ADDRESS);
  try {
    return await sesClient.send(verifyEmailIdentityCommand);
  } catch (err) {
    console.log("Failed to verify email identity.", err);
    return err;
  }
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi. Il dominio viene aggiunto ad Amazon SES per essere verificato.

```
node ses_verifyemailidentity.js 
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js).

## Verifica dell'identità di un dominio
<a name="ses-examples-verifying-domains"></a>

In questo esempio, utilizza un modulo Node.js per verificare i domini e-mail da utilizzare con Amazon SES.

Crea una `libs` directory e crea un modulo Node.js con il nome `sesClient.js` del file. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_verifydomainidentity.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire il parametro `Domain` per il metodo `VerifyDomainIdentityCommand` della classe client `SES`. Per chiamare il `VerifyDomainIdentityCommand` metodo, richiama un oggetto del servizio client Amazon SES, passando l'oggetto parameters. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
Sostituisci *DOMAIN\$1NAME* con il nome di dominio.

```
import { VerifyDomainIdentityCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * You must have access to the domain's DNS settings to complete the
 * domain verification process.
 */
const DOMAIN_NAME = postfix(getUniqueName("Domain"), ".example.com");

const createVerifyDomainIdentityCommand = () => {
  return new VerifyDomainIdentityCommand({ Domain: DOMAIN_NAME });
};

const run = async () => {
  const VerifyDomainIdentityCommand = createVerifyDomainIdentityCommand();

  try {
    return await sesClient.send(VerifyDomainIdentityCommand);
  } catch (err) {
    console.log("Failed to verify domain.", err);
    return err;
  }
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi. Il dominio viene aggiunto ad Amazon SES per essere verificato.

```
node ses_verifydomainidentity.js  
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js).

## Eliminazione delle identità
<a name="ses-examples-deleting-identities"></a>

In questo esempio, utilizza un modulo Node.js per eliminare gli indirizzi e-mail o i domini utilizzati con Amazon SES.

Crea una `libs` directory e crea un modulo Node.js con il nome `sesClient.js` del file. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_deleteidentity.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire il parametro `Identity` per il metodo `DeleteIdentityCommand` della classe client `SES`. Per chiamare il `DeleteIdentityCommand` metodo, crea un oggetto del servizio client Amazon SES `request` per richiamare un oggetto del servizio client Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
Sostituisci *IDENTITY\$1EMAIL* con l'e-mail dell'identità da eliminare.

```
import { DeleteIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const IDENTITY_EMAIL = "fake@example.com";

const createDeleteIdentityCommand = (identityName) => {
  return new DeleteIdentityCommand({
    Identity: identityName,
  });
};

const run = async () => {
  const deleteIdentityCommand = createDeleteIdentityCommand(IDENTITY_EMAIL);

  try {
    return await sesClient.send(deleteIdentityCommand);
  } catch (err) {
    console.log("Failed to delete identity.", err);
    return err;
  }
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node ses_deleteidentity.js 
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js).

# Utilizzo dei modelli di e-mail in Amazon SES
<a name="ses-examples-creating-template"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come ottenere un elenco di tutti i tuoi modelli di email.
+ Come recuperare e aggiornare i modelli di email.
+ Come creare ed eliminare modelli di email.

Amazon SES consente di inviare messaggi e-mail personalizzati utilizzando modelli di e-mail. Per dettagli su come creare e utilizzare modelli di e-mail in Amazon SES, consulta [Invio di e-mail personalizzate utilizzando l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html) nella Amazon Simple Email Service Developer Guide.

## Lo scenario
<a name="ses-examples-creating-template-scenario"></a>

In questo esempio, utilizzi una serie di moduli Node.js per utilizzare i modelli di e-mail. I moduli Node.js utilizzano l'SDK per JavaScript creare e utilizzare modelli di posta elettronica utilizzando questi metodi della classe `SES` client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/)

## Attività prerequisite
<a name="ses-examples-creating-template-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/ses/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](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) nella Guida di riferimento *agli strumenti AWS SDKs e agli strumenti*.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Elencare i tuoi modelli di email
<a name="ses-examples-listing-templates"></a>

In questo esempio, utilizza un modulo Node.js per creare un modello di e-mail da utilizzare con Amazon SES. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file`sesClient.js`. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_listtemplates.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire i parametri per il metodo `ListTemplatesCommand` della classe client `SES`. Per chiamare il `ListTemplatesCommand` metodo, richiama un oggetto del servizio client Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

```
import { ListTemplatesCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createListTemplatesCommand = (maxItems) =>
  new ListTemplatesCommand({ MaxItems: maxItems });

const run = async () => {
  const listTemplatesCommand = createListTemplatesCommand(10);

  try {
    return await sesClient.send(listTemplatesCommand);
  } catch (err) {
    console.log("Failed to list templates.", err);
    return err;
  }
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi. Amazon SES restituisce l'elenco dei modelli.

```
node ses_listtemplates.js  
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js).

## Ottenere un modello di email
<a name="ses-examples-get-template"></a>

In questo esempio, utilizza un modulo Node.js per ottenere un modello di e-mail da utilizzare con Amazon SES.

Crea una `libs` directory e crea un modulo Node.js con il nome del file`sesClient.js`. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_gettemplate.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire il parametro `TemplateName` per il metodo `GetTemplateCommand` della classe client `SES`. Per chiamare il `GetTemplateCommand` metodo, richiama un oggetto del servizio client Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
Sostituisci *TEMPLATE\$1NAME* con il nome del modello da restituire.

```
import { GetTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");

const createGetTemplateCommand = (templateName) =>
  new GetTemplateCommand({ TemplateName: templateName });

const run = async () => {
  const getTemplateCommand = createGetTemplateCommand(TEMPLATE_NAME);

  try {
    return await sesClient.send(getTemplateCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi. Amazon SES restituisce i dettagli del modello.

```
node ses_gettemplate.js 
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js).

## Creazione di un modello di email
<a name="ses-examples-create-template"></a>

In questo esempio, utilizza un modulo Node.js per creare un modello di e-mail da utilizzare con Amazon SES. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file`sesClient.js`. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_createtemplate.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire i parametri per il metodo `CreateTemplateCommand` della classe client `SES`, inclusi `TemplateName`, `HtmlPart`, `SubjectPart` e `TextPart`. Per chiamare il `CreateTemplateCommand` metodo, richiama un oggetto del servizio client Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
*TEMPLATE\$1NAME*Sostituitelo con un nome per il nuovo modello, *HtmlPart* con il contenuto del messaggio di posta elettronica con tag HTML e *SubjectPart* con l'oggetto dell'e-mail.

```
import { CreateTemplateCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";

const TEMPLATE_NAME = getUniqueName("TestTemplateName");

const createCreateTemplateCommand = () => {
  return new CreateTemplateCommand({
    /**
     * The template feature in Amazon SES is based on the Handlebars template system.
     */
    Template: {
      /**
       * The name of an existing template in Amazon SES.
       */
      TemplateName: TEMPLATE_NAME,
      HtmlPart: `
        <h1>Hello, {{contact.firstName}}!</h1>
        <p>
        Did you know Amazon has a mascot named Peccy?
        </p>
      `,
      SubjectPart: "Amazon Tip",
    },
  });
};

const run = async () => {
  const createTemplateCommand = createCreateTemplateCommand();

  try {
    return await sesClient.send(createTemplateCommand);
  } catch (err) {
    console.log("Failed to create template.", err);
    return err;
  }
};
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi. Il modello viene aggiunto ad Amazon SES.

```
node ses_createtemplate.js  
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js).

## Aggiornamento di un modello di e-mail
<a name="ses-examples-update-template"></a>

In questo esempio, utilizza un modulo Node.js per creare un modello di e-mail da utilizzare con Amazon SES. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file`sesClient.js`. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_updatetemplate.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire i valori dei parametri `Template` che desideri aggiornare nel modello, con il parametro `TemplateName` richiesto trasferito al metodo `UpdateTemplateCommand` della classe client `SES`. Per chiamare il `UpdateTemplateCommand` metodo, richiama un oggetto di servizio Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
Sostituiscilo *TEMPLATE\$1NAME* con il nome del modello e *HTML\$1PART* con il contenuto del messaggio di posta elettronica con tag HTML.

```
import { UpdateTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");
const HTML_PART = "<h1>Hello, World!</h1>";

const createUpdateTemplateCommand = () => {
  return new UpdateTemplateCommand({
    Template: {
      TemplateName: TEMPLATE_NAME,
      HtmlPart: HTML_PART,
      SubjectPart: "Example",
      TextPart: "Updated template text.",
    },
  });
};

const run = async () => {
  const updateTemplateCommand = createUpdateTemplateCommand();

  try {
    return await sesClient.send(updateTemplateCommand);
  } catch (err) {
    console.log("Failed to update template.", err);
    return err;
  }
};
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi. Amazon SES restituisce i dettagli del modello.

```
node ses_updatetemplate.js 
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js).

## Eliminazione di un modello di e-mail
<a name="ses-examples-delete-template"></a>

In questo esempio, utilizza un modulo Node.js per creare un modello di e-mail da utilizzare con Amazon SES. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file`sesClient.js`. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_deletetemplate.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire il parametro `TemplateName` richiesto al metodo `DeleteTemplateCommand` della classe client `SES`. Per chiamare il `DeleteTemplateCommand` metodo, richiama un oggetto di servizio Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
Sostituisci *TEMPLATE\$1NAME* con il nome del modello da eliminare.

```
import { DeleteTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");

const createDeleteTemplateCommand = (templateName) =>
  new DeleteTemplateCommand({ TemplateName: templateName });

const run = async () => {
  const deleteTemplateCommand = createDeleteTemplateCommand(TEMPLATE_NAME);

  try {
    return await sesClient.send(deleteTemplateCommand);
  } catch (err) {
    console.log("Failed to delete template.", err);
    return err;
  }
};
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi. Amazon SES restituisce i dettagli del modello.

```
node ses_deletetemplate.js 
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js).

# Invio di e-mail tramite Amazon SES
<a name="ses-examples-sending-email"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come inviare un'e-mail di testo o in formato HTML.
+ Come inviare e-mail in base a un modello di e-mail.
+ Come inviare e-mail in blocco in base a un modello di e-mail.

L'API Amazon SES offre due modi diversi per inviare un'e-mail, a seconda del livello di controllo che desideri sulla composizione del messaggio e-mail: formattato e non elaborato. Per i dettagli, consulta [Invio di e-mail formattate utilizzando l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html) e [Invio di e-mail non elaborate utilizzando l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).

## Lo scenario
<a name="ses-examples-sending-email-scenario"></a>

In questo esempio, utilizzi una serie di moduli Node.js per inviare e-mail in diversi modi. I moduli Node.js utilizzano l'SDK per JavaScript creare e utilizzare modelli di posta elettronica utilizzando questi metodi della classe `SES` client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/)

## Attività prerequisite
<a name="ses-examples-sending-emails-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/ses/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](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) nella Guida di riferimento *agli strumenti AWS SDKs e agli strumenti*.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Requisiti per l'invio di messaggi e-mail
<a name="ses-examples-sending-msail-reqs"></a>

Amazon SES compone un messaggio e-mail e lo mette immediatamente in coda per l'invio. Per inviare e-mail utilizzando il metodo `SendEmailCommand`, il messaggio deve soddisfare i seguenti requisiti:
+ Devi inviare il messaggio da un dominio o da un indirizzo e-mail verificato. Se tenti di inviare e-mail utilizzando un dominio o un indirizzo non verificato, l'operazione genera un errore `"Email address not verified"`.
+ Se il tuo account si trova ancora nella sandbox di Amazon SES, puoi inviare messaggi solo a domini o indirizzi verificati oppure a indirizzi e-mail associati al simulatore di mailbox di Amazon SES. Per ulteriori informazioni, consulta la sezione [Verifica degli indirizzi e-mail e dei domini](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) nella Amazon Simple Email Service Developer Guide.
+ La dimensione totale del messaggio, inclusi gli allegati, deve essere inferiore a 10 MB.
+ Il messaggio deve includere almeno l'indirizzo e-mail di un destinatario. L'indirizzo del destinatario può essere un indirizzo "To:" ("A:"), "CC:" ("Cc:") o "BCC:" ("Ccn:"). Se l'indirizzo e-mail del destinatario non è valido (ovvero non è nel formato`UserName@[SubDomain.]Domain.TopLevelDomain`), l'intero messaggio viene rifiutato, anche se contiene altri destinatari validi.
+ Il messaggio non può includere più di 50 destinatari nei campi To:, CC: e BCC:. Se devi inviare un messaggio e-mail a un pubblico più ampio, puoi dividere l'elenco dei destinatari in gruppi di massimo 50 persone e quindi chiamare il metodo `sendEmail` più volte per inviare il messaggio a ciascun gruppo.

## Invio di un'e-mail
<a name="ses-examples-sendmail"></a>

In questo esempio, utilizza un modulo Node.js per inviare e-mail con Amazon SES. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file`sesClient.js`. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_sendemail.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Create un oggetto per passare i valori dei parametri che definiscono l'e-mail da inviare, inclusi gli indirizzi del mittente e del destinatario, l'oggetto e il corpo dell'e-mail in formato testo semplice e HTML, al `SendEmailCommand` metodo della classe `SES` client. Per chiamare il `SendEmailCommand` metodo, richiama un oggetto di servizio Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
Sostituisci *toAddress* con l'indirizzo a cui inviare l'e-mail e *fromAddress* con l'indirizzo e-mail da cui inviare l'e-mail.

```
import { SendEmailCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createSendEmailCommand = (toAddress, fromAddress) => {
  return new SendEmailCommand({
    Destination: {
      /* required */
      CcAddresses: [
        /* more items */
      ],
      ToAddresses: [
        toAddress,
        /* more To-email addresses */
      ],
    },
    Message: {
      /* required */
      Body: {
        /* required */
        Html: {
          Charset: "UTF-8",
          Data: "HTML_FORMAT_BODY",
        },
        Text: {
          Charset: "UTF-8",
          Data: "TEXT_FORMAT_BODY",
        },
      },
      Subject: {
        Charset: "UTF-8",
        Data: "EMAIL_SUBJECT",
      },
    },
    Source: fromAddress,
    ReplyToAddresses: [
      /* more items */
    ],
  });
};

const run = async () => {
  const sendEmailCommand = createSendEmailCommand(
    "recipient@example.com",
    "sender@example.com",
  );

  try {
    return await sesClient.send(sendEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi. L'e-mail viene messa in coda per l'invio da parte di Amazon SES.

```
node ses_sendemail.js 
```

Questo codice di esempio può essere [trovato qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js) su. GitHub 

## Invio di un'e-mail utilizzando un modello
<a name="ses-examples-sendtemplatedemail"></a>

In questo esempio, utilizza un modulo Node.js per inviare e-mail con Amazon SES. Crea un modulo Node.js con il nome del file `ses_sendtemplatedemail.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire i valori dei parametri che definiscono l'e-mail da inviare, inclusi gli indirizzi dei mittenti e dei destinatari, l'oggetto, il corpo dell'e-mail in testo normale e in formato HTML, al metodo `SendTemplatedEmailCommand` della classe client `SES`. Per chiamare il `SendTemplatedEmailCommand` metodo, richiama un oggetto del servizio client Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
Sostituisci *REGION* con la tua AWS regione, *USER* con il nome e l'indirizzo e-mail a cui inviare l'e-mail, *VERIFIED\$1EMAIL* con l'indirizzo e-mail da cui inviare l'e-mail e *TEMPLATE\$1NAME* con il nome del modello.

```
import { SendTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * Replace this with the name of an existing template.
 */
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");

/**
 * Replace these with existing verified emails.
 */
const VERIFIED_EMAIL = postfix(getUniqueName("Bilbo"), "@example.com");

const USER = { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL };

/**
 *
 * @param { { emailAddress: string, firstName: string } } user
 * @param { string } templateName - The name of an existing template in Amazon SES.
 * @returns { SendTemplatedEmailCommand }
 */
const createReminderEmailCommand = (user, templateName) => {
  return new SendTemplatedEmailCommand({
    /**
     * Here's an example of how a template would be replaced with user data:
     * Template: <h1>Hello {{contact.firstName}},</h1><p>Don't forget about the party gifts!</p>
     * Destination: <h1>Hello Bilbo,</h1><p>Don't forget about the party gifts!</p>
     */
    Destination: { ToAddresses: [user.emailAddress] },
    TemplateData: JSON.stringify({ contact: { firstName: user.firstName } }),
    Source: VERIFIED_EMAIL,
    Template: templateName,
  });
};

const run = async () => {
  const sendReminderEmailCommand = createReminderEmailCommand(
    USER,
    TEMPLATE_NAME,
  );
  try {
    return await sesClient.send(sendReminderEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi. L'e-mail viene messa in coda per l'invio da parte di Amazon SES.

```
node ses_sendtemplatedemail.js 
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js) su. GitHub

## Invio di e-mail in blocco utilizzando un modello
<a name="ses-examples-sendbulktemplatedemail"></a>

In questo esempio, utilizza un modulo Node.js per inviare e-mail con Amazon SES. 

Crea una `libs` directory e crea un modulo Node.js con il nome `sesClient.js` del file. Copia e incolla il codice seguente, che crea l'oggetto client Amazon SES. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Crea un modulo Node.js con il nome del file `ses_sendbulktemplatedemail.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. 

Create un oggetto per passare i valori dei parametri che definiscono l'e-mail da inviare, inclusi gli indirizzi del mittente e del destinatario, l'oggetto e il corpo dell'e-mail in formato testo semplice e HTML, al `SendBulkTemplatedEmailCommand` metodo della classe `SES` client. Per chiamare il `SendBulkTemplatedEmailCommand` metodo, richiama un oggetto di servizio Amazon SES, passando i parametri. 

**Nota**  
Questo esempio importa e utilizza i client del pacchetto AWS Service V3 richiesti, i comandi V3 e utilizza il `send` metodo secondo uno schema. async/await È possibile creare questo esempio utilizzando i comandi V2 invece apportando alcune modifiche minori. Per informazioni dettagliate, vedi [Utilizzo dei comandi v3](migrating.md#using_v3_commands).

**Nota**  
Sostituisci *USERS* con i nomi e gli indirizzi e-mail a cui inviare l'e-mail, *VERIFIED\$1EMAIL\$11* con l'indirizzo e-mail da cui inviare l'e-mail e *TEMPLATE\$1NAME* con il nome del modello.

```
import { SendBulkTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * Replace this with the name of an existing template.
 */
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");

/**
 * Replace these with existing verified emails.
 */
const VERIFIED_EMAIL_1 = postfix(getUniqueName("Bilbo"), "@example.com");
const VERIFIED_EMAIL_2 = postfix(getUniqueName("Frodo"), "@example.com");

const USERS = [
  { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL_1 },
  { firstName: "Frodo", emailAddress: VERIFIED_EMAIL_2 },
];

/**
 *
 * @param { { emailAddress: string, firstName: string }[] } users
 * @param { string } templateName the name of an existing template in SES
 * @returns { SendBulkTemplatedEmailCommand }
 */
const createBulkReminderEmailCommand = (users, templateName) => {
  return new SendBulkTemplatedEmailCommand({
    /**
     * Each 'Destination' uses a corresponding set of replacement data. We can map each user
     * to a 'Destination' and provide user specific replacement data to create personalized emails.
     *
     * Here's an example of how a template would be replaced with user data:
     * Template: <h1>Hello {{name}},</h1><p>Don't forget about the party gifts!</p>
     * Destination 1: <h1>Hello Bilbo,</h1><p>Don't forget about the party gifts!</p>
     * Destination 2: <h1>Hello Frodo,</h1><p>Don't forget about the party gifts!</p>
     */
    Destinations: users.map((user) => ({
      Destination: { ToAddresses: [user.emailAddress] },
      ReplacementTemplateData: JSON.stringify({ name: user.firstName }),
    })),
    DefaultTemplateData: JSON.stringify({ name: "Shireling" }),
    Source: VERIFIED_EMAIL_1,
    Template: templateName,
  });
};

const run = async () => {
  const sendBulkTemplateEmailCommand = createBulkReminderEmailCommand(
    USERS,
    TEMPLATE_NAME,
  );
  try {
    return await sesClient.send(sendBulkTemplateEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi. L'e-mail viene messa in coda per l'invio da parte di Amazon SES.

```
node ses_sendbulktemplatedemail.js
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js) su. GitHub 

# Esempi di servizi di notifica Amazon Simple
<a name="sns-examples"></a>

Amazon Simple Notification Service (Amazon SNS) è un servizio Web che coordina e gestisce la consegna o l'invio di messaggi a endpoint o client abbonati. 

In Amazon SNS, esistono due tipi di clienti, editori e abbonati, noti anche come produttori e consumatori. 

![\[Relazione tra JavaScript ambienti, SDK e Amazon SNS\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/code-samples-sns.png)


Gli editori comunicano in modo asincrono con i sottoscrittori producendo e inviando un messaggio a un argomento, che rappresenta un punto di accesso logico e un canale di comunicazione. Gli abbonati (server Web, indirizzi e-mail, code Amazon SQS AWS Lambda , funzioni) utilizzano o ricevono il messaggio o la notifica tramite uno dei protocolli supportati (Amazon SQS, HTTP/S, e-mail AWS Lambda, SMS) quando sono abbonati all'argomento. 

L' JavaScript API per Amazon SNS è esposta tramite la [classe:](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SNS/) SNS. 

**Topics**
+ [Gestione degli argomenti in Amazon SNS](sns-examples-managing-topics.md)
+ [Pubblicazione di messaggi in Amazon SNS](sns-examples-publishing-messages.md)
+ [Gestione degli abbonamenti in Amazon SNS](sns-examples-subscribing-unsubscribing-topics.md)
+ [Invio di messaggi SMS con Amazon SNS](sns-examples-sending-sms.md)

# Gestione degli argomenti in Amazon SNS
<a name="sns-examples-managing-topics"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come creare argomenti in Amazon SNS su cui pubblicare notifiche.
+ Come eliminare argomenti creati in Amazon SNS.
+ Come ottenere un elenco degli argomenti disponibili.
+ Come ottenere e impostare gli attributi di argomento.

## Lo scenario
<a name="sns-examples-managing-topics-scenario"></a>

In questo esempio, utilizzi una serie di moduli Node.js per creare, elencare ed eliminare argomenti di Amazon SNS e per gestire gli attributi degli argomenti. I moduli Node.js utilizzano l'SDK per JavaScript gestire gli argomenti utilizzando questi metodi della classe `SNS` client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/)

## Attività prerequisite
<a name="sns-examples-managing-topics-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/blob/main/javascriptv3/example_code/sns/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.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Creazione di un argomento
<a name="sns-examples-managing-topics-createtopic"></a>

In questo esempio, usa un modulo Node.js per creare un argomento Amazon SNS. 

Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `create-topic.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto per trasferire l'oggetto `Name` per il nuovo argomento al metodo `CreateTopicCommand` della classe client `SNS`. Per chiamare il `CreateTopicCommand` metodo, crea una funzione asincrona che richiama un oggetto di servizio Amazon SNS, passando l'oggetto parameters. Il `data` valore restituito contiene l'ARN dell'argomento.

**Nota**  
Sostituisci *TOPIC\$1NAME* con il nome dell'argomento.

```
import { CreateTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicName - The name of the topic to create.
 */
export const createTopic = async (topicName = "TOPIC_NAME") => {
  const response = await snsClient.send(
    new CreateTopicCommand({ Name: topicName }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '087b8ad2-4593-50c4-a496-d7e90b82cf3e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME'
  // }
  return response;
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node create-topic.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/create-topic.js).

## Elenco dei tuoi argomenti
<a name="sns-examples-managing-topics-listtopics"></a>

In questo esempio, usa un modulo Node.js per elencare tutti gli argomenti di Amazon SNS. 

Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `list-topics.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto vuoto da trasferire al metodo `ListTopicsCommand` della classe client `SNS`. Per chiamare il `ListTopicsCommand` metodo, crea una funzione asincrona che richiama un oggetto di servizio Amazon SNS, passando l'oggetto parameters. Il file `data` restituito contiene una matrice del tuo argomento Amazon Resource Names (ARNs).

```
import { ListTopicsCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const listTopics = async () => {
  const response = await snsClient.send(new ListTopicsCommand({}));
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '936bc5ad-83ca-53c2-b0b7-9891167b909e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Topics: [ { TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic' } ]
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node list-topics.js
```

Questo codice di esempio è disponibile [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-topics.js). GitHub

## Eliminazione di un argomento
<a name="sns-examples-managing-topics-deletetopic"></a>

In questo esempio, usa un modulo Node.js per eliminare un argomento di Amazon SNS. 

Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `delete-topic.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto contenente il parametro `TopicArn` dell'argomento da eliminare per passare al metodo `DeleteTopicCommand` della classe client `SNS`. Per chiamare il `DeleteTopicCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituisci *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) dell'argomento che stai eliminando.

```
import { DeleteTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic to delete.
 */
export const deleteTopic = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new DeleteTopicCommand({ TopicArn: topicArn }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'a10e2886-5a8f-5114-af36-75bd39498332',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node delete-topic.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/delete-topic.js).

## Recupero degli attributi di argomento
<a name="sns-examples-managing-topicsgettopicattributes"></a>

In questo esempio, usa un modulo Node.js per recuperare gli attributi di un argomento Amazon SNS.

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `get-topic-attributes.js`. Configura l'SDK come mostrato in precedenza.

Crea un oggetto contenente il parametro `TopicArn` di un argomento da eliminare per passare al metodo `GetTopicAttributesCommand` della classe client `SNS`. Per chiamare il `GetTopicAttributesCommand` metodo, è necessario richiamare un oggetto del servizio client Amazon SNS, passare l'oggetto parameters. 

**Nota**  
Sostituisci *TOPIC\$1ARN* con l'ARN dell'argomento.

```
import { GetTopicAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic to retrieve attributes for.
 */
export const getTopicAttributes = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new GetTopicAttributesCommand({
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '36b6a24e-5473-5d4e-ac32-ff72d9a73d94',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Attributes: {
  //     Policy: '{...}',
  //     Owner: 'xxxxxxxxxxxx',
  //     SubscriptionsPending: '1',
  //     TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic',
  //     TracingConfig: 'PassThrough',
  //     EffectiveDeliveryPolicy: '{"http":{"defaultHealthyRetryPolicy":{"minDelayTarget":20,"maxDelayTarget":20,"numRetries":3,"numMaxDelayRetries":0,"numNoDelayRetries":0,"numMinDelayRetries":0,"backoffFunction":"linear"},"disableSubscriptionOverrides":false,"defaultRequestPolicy":{"headerContentType":"text/plain; charset=UTF-8"}}}',
  //     SubscriptionsConfirmed: '0',
  //     DisplayName: '',
  //     SubscriptionsDeleted: '1'
  //   }
  // }
  return response;
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node get-topic-attributes.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-topic-attributes.js).

## Impostazione degli attributi di argomento
<a name="sns-examples-managing-topicssttopicattributes"></a>

In questo esempio, usa un modulo Node.js per impostare gli attributi mutabili di un argomento Amazon SNS. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `set-topic-attributes.js`. Configura l'SDK come mostrato in precedenza.

Crea un oggetto contenente i parametri per l'aggiornamento dell'attributo, inclusi il parametro `TopicArn` dell'argomento di cui desideri impostare gli attributi, il nome dell'attributo da impostare e il nuovo valore per l'attributo. È possibile impostare solo gli attributi `Policy`, `DisplayName` e `DeliveryPolicy`. Trasferisci i parametri al metodo `SetTopicAttributesCommand` della classe client `SNS`. Per chiamare il `SetTopicAttributesCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituisci *ATTRIBUTE\$1NAME* con il nome dell'attributo che stai impostando, *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) dell'argomento di cui desideri impostare gli attributi e *NEW\$1ATTRIBUTE\$1VALUE* con il nuovo valore per quell'attributo.

```
import { SetTopicAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const setTopicAttributes = async (
  topicArn = "TOPIC_ARN",
  attributeName = "DisplayName",
  attributeValue = "Test Topic",
) => {
  const response = await snsClient.send(
    new SetTopicAttributesCommand({
      AttributeName: attributeName,
      AttributeValue: attributeValue,
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'd1b08d0e-e9a4-54c3-b8b1-d03238d2b935',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node set-topic-attributes.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-topic-attributes.js).

# Pubblicazione di messaggi in Amazon SNS
<a name="sns-examples-publishing-messages"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come pubblicare messaggi su un argomento di Amazon SNS.

## Lo scenario
<a name="sns-examples-publishing-messages-scenario"></a>

In questo esempio, utilizzi una serie di moduli Node.js per pubblicare messaggi da Amazon SNS su endpoint, e-mail o numeri di telefono tematici. I moduli Node.js utilizzano l'SDK per JavaScript inviare messaggi utilizzando questo metodo della `SNS` classe client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)

## Attività prerequisite
<a name="sns-examples-publishing-messages-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/blob/main/javascriptv3/example_code/sns/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.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Pubblicazione di un messaggio in un argomento SNS
<a name="sns-examples-publishing-text-messages"></a>

In questo esempio, usa un modulo Node.js per pubblicare un messaggio su un argomento di Amazon SNS.

Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Crea un modulo Node.js con il nome del file `publish-topic.js`. Configura l'SDK come mostrato in precedenza.

Crea un oggetto contenente i parametri per la pubblicazione di un messaggio, incluso il testo del messaggio e l'Amazon Resource Name (ARN) di Amazon. SNStopic Per i dettagli sugli attributi SMS disponibili, consulta [Set SMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html#setSMSAttributes-property).

Passa i parametri al `PublishCommand` metodo della classe `SNS` client. Crea una funzione asincrona richiamando un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituisci *MESSAGE\$1TEXT* con il testo del messaggio e *TOPIC\$1ARN* con l'ARN dell'argomento SNS.

```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string | Record<string, any>} message - The message to send. Can be a plain string or an object
 *                                                 if you are using the `json` `MessageStructure`.
 * @param {string} topicArn - The ARN of the topic to which you would like to publish.
 */
export const publish = async (
  message = "Hello from SNS!",
  topicArn = "TOPIC_ARN",
) => {
  const response = await snsClient.send(
    new PublishCommand({
      Message: message,
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'e7f77526-e295-5325-9ee4-281a43ad1f05',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node publish-topic.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-topic.js).

# Gestione degli abbonamenti in Amazon SNS
<a name="sns-examples-subscribing-unsubscribing-topics"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come elencare tutti gli abbonamenti a un argomento di Amazon SNS.
+ Come sottoscrivere un indirizzo e-mail, un endpoint dell'applicazione o una AWS Lambda funzione a un argomento di Amazon SNS.
+ Come annullare l'iscrizione agli argomenti di Amazon SNS.

## Lo scenario
<a name="sns-examples-subscribing-unsubscribing-topics-scenario"></a>

In questo esempio, utilizzi una serie di moduli Node.js per pubblicare messaggi di notifica su argomenti di Amazon SNS. I moduli Node.js utilizzano l'SDK per JavaScript gestire gli argomenti utilizzando questi metodi della classe `SNS` client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/)

## Attività prerequisite
<a name="sns-examples-subscribing-unsubscribing-topics-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/blob/main/javascriptv3/example_code/sns/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.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Elenco di sottoscrizioni a un argomento
<a name="sns-examples-list-subscriptions-email"></a>

In questo esempio, usa un modulo Node.js per elencare tutte le sottoscrizioni a un argomento di Amazon SNS. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Crea un modulo Node.js con il nome del file `list-subscriptions-by-topic.js`. Configura l'SDK come mostrato in precedenza.

Crea un oggetto contenente il parametro `TopicArn` per l'argomento di cui si desideri elencare le sottoscrizioni. Trasferisci i parametri al metodo `ListSubscriptionsByTopicCommand` della classe client `SNS`. Per chiamare il `ListSubscriptionsByTopicCommand` metodo, crea una funzione asincrona che richiama un oggetto servizio client Amazon SNS e passa l'oggetto parameters. 

**Nota**  
Sostituisci *TOPIC\$1ARN* con Amazon Resource Name (ARN) per l'argomento di cui desideri elencare gli abbonamenti.

```
import { ListSubscriptionsByTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic for which you wish to list subscriptions.
 */
export const listSubscriptionsByTopic = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new ListSubscriptionsByTopicCommand({ TopicArn: topicArn }),
  );

  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '0934fedf-0c4b-572e-9ed2-a3e38fadb0c8',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Subscriptions: [
  //     {
  //       SubscriptionArn: 'PendingConfirmation',
  //       Owner: '901487484989',
  //       Protocol: 'email',
  //       Endpoint: 'corepyle@amazon.com',
  //       TopicArn: 'arn:aws:sns:us-east-1:901487484989:mytopic'
  //     }
  //   ]
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node list-subscriptions-by-topic.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-subscriptions-by-topic.js).

## Sottoscrizione di un indirizzo e-mail a un argomento
<a name="sns-examples-subscribing-email"></a>

In questo esempio, usa un modulo Node.js per iscrivere un indirizzo e-mail in modo che riceva messaggi e-mail SMTP da un argomento di Amazon SNS. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `subscribe-email.js`. Configura l'SDK come mostrato in precedenza.

Crea un oggetto contenente il parametro `Protocol` per specificare il protocollo `email`, il parametro `TopicArn` per l'argomento a cui effettuare la sottoscrizione e un indirizzo e-mail come `Endpoint` del messaggio. Trasferisci i parametri al metodo `SubscribeCommand` della classe client `SNS`. Puoi utilizzare il `subscribe` metodo per sottoscrivere diversi endpoint a un argomento Amazon SNS, a seconda dei valori utilizzati per i parametri passati, come mostreranno altri esempi in questo argomento.

Per chiamare il `SubscribeCommand` metodo, crea una funzione asincrona che richiama un oggetto servizio client Amazon SNS e passa l'oggetto parameters. 

**Nota**  
Sostituisci *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) per l'argomento e *EMAIL\$1ADDRESS* con l'indirizzo e-mail a cui iscriverti.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic for which you wish to confirm a subscription.
 * @param {string} emailAddress - The email address that is subscribed to the topic.
 */
export const subscribeEmail = async (
  topicArn = "TOPIC_ARN",
  emailAddress = "usern@me.com",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "email",
      TopicArn: topicArn,
      Endpoint: emailAddress,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node subscribe-email.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-email.js).

### Conferma delle sottoscrizioni
<a name="sns-confirm-subscription-email"></a>

In questo esempio, utilizzate un modulo Node.js per verificare l'intenzione del proprietario di un endpoint di ricevere e-mail convalidando il token inviato all'endpoint con una precedente azione di sottoscrizione.

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `confirm-subscription.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Definite i parametri, incluso `TOPIC_ARN` e`TOKEN`, e definite un valore di `TRUE` o `FALSE` per`AuthenticateOnUnsubscribe`.

Il token è un token di breve durata inviato al proprietario di un endpoint durante un'azione precedente`SUBSCRIBE`. Ad esempio, per un endpoint di posta elettronica, `TOKEN` si trova nell'URL dell'e-mail di conferma dell'iscrizione inviata al proprietario dell'e-mail. Ad esempio, `abc123` è il token nel seguente URL.

![\[Amazon Web Services Simple Notification Service subscription confirmation page.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/token.png)


Per chiamare il `ConfirmSubscriptionCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituisci *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) per l'argomento, *TOKEN* con il valore del token dell'URL inviato al proprietario dell'endpoint in un'`Subscribe`azione precedente e definisci*AuthenticateOnUnsubscribe*. con il valore o. `TRUE` `FALSE`

```
import { ConfirmSubscriptionCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} token - This token is sent the subscriber. Only subscribers
 *                         that are not AWS services (HTTP/S, email) need to be confirmed.
 * @param {string} topicArn - The ARN of the topic for which you wish to confirm a subscription.
 */
export const confirmSubscription = async (
  token = "TOKEN",
  topicArn = "TOPIC_ARN",
) => {
  const response = await snsClient.send(
    // A subscription only needs to be confirmed if the endpoint type is
    // HTTP/S, email, or in another AWS account.
    new ConfirmSubscriptionCommand({
      Token: token,
      TopicArn: topicArn,
      // If this is true, the subscriber cannot unsubscribe while unauthenticated.
      AuthenticateOnUnsubscribe: "false",
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '4bb5bce9-805a-5517-8333-e1d2cface90b',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node confirm-subscription.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/confirm-subscription.js).

## Sottoscrizione di un endpoint di applicazione a un argomento
<a name="sns-examples-subscribing-apps"></a>

In questo esempio, usa un modulo Node.js per sottoscrivere un endpoint di applicazione mobile in modo che riceva notifiche da un argomento di Amazon SNS. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `subscribe-app.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei moduli e dei pacchetti richiesti.

Crea un oggetto contenente il `Protocol` parametro `TopicArn` per specificare il `application` protocollo, l'argomento a cui sottoscrivere e l'Amazon Resource Name (ARN) di un endpoint di applicazione mobile per il parametro. `Endpoint` Trasferisci i parametri al metodo `SubscribeCommand` della classe client `SNS`.

Per chiamare il `SubscribeCommand` metodo, crea una funzione asincrona che richiama un oggetto di servizio Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituiscilo *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) per l'argomento e *MOBILE\$1ENDPOINT\$1ARN* con l'endpoint a cui ti stai abbonando all'argomento.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic the subscriber is subscribing to.
 * @param {string} endpoint - The Endpoint ARN of an application. This endpoint is created
 *                            when an application registers for notifications.
 */
export const subscribeApp = async (
  topicArn = "TOPIC_ARN",
  endpoint = "ENDPOINT",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "application",
      TopicArn: topicArn,
      Endpoint: endpoint,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node subscribe-app.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-app.js).

## Sottoscrizione di una funzione Lambda a un argomento
<a name="sns-examples-subscribing-lambda"></a>

In questo esempio, usa un modulo Node.js per sottoscrivere una AWS Lambda funzione in modo che riceva notifiche da un argomento di Amazon SNS. 

Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `subscribe-lambda.js`. Configura l'SDK come mostrato in precedenza.

Crea un oggetto contenente il `Protocol` parametro, specificando il `lambda` protocollo, l'`TopicArn`argomento a cui sottoscrivere e l'Amazon Resource Name (ARN) di AWS Lambda una funzione come `Endpoint` parametro. Trasferisci i parametri al metodo `SubscribeCommand` della classe client `SNS`.

Per chiamare il `SubscribeCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituisci *TOPIC\$1ARN* con Amazon Resource Name (ARN) per l'argomento e *LAMBDA\$1FUNCTION\$1ARN* con Amazon Resource Name (ARN) della funzione Lambda.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic the subscriber is subscribing to.
 * @param {string} endpoint - The Endpoint ARN of and AWS Lambda function.
 */
export const subscribeLambda = async (
  topicArn = "TOPIC_ARN",
  endpoint = "ENDPOINT",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "lambda",
      TopicArn: topicArn,
      Endpoint: endpoint,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node subscribe-lambda.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-lambda.js).

## Annullamento della sottoscrizione a un argomento
<a name="sns-examples-unsubscribing"></a>

In questo esempio, usa un modulo Node.js per annullare l'iscrizione a un argomento Amazon SNS.

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `unsubscribe.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.

Crea un oggetto contenente il `SubscriptionArn` parametro, specificando l'Amazon Resource Name (ARN) dell'abbonamento per annullare l'iscrizione. Trasferisci i parametri al metodo `UnsubscribeCommand` della classe client `SNS`.

Per chiamare il `UnsubscribeCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituisci *TOPIC\$1SUBSCRIPTION\$1ARN* con l'Amazon Resource Name (ARN) dell'abbonamento per annullare l'iscrizione.

```
import { UnsubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} subscriptionArn - The ARN of the subscription to cancel.
 */
const unsubscribe = async (
  subscriptionArn = "arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
) => {
  const response = await snsClient.send(
    new UnsubscribeCommand({
      SubscriptionArn: subscriptionArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '0178259a-9204-507c-b620-78a7570a44c6',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node unsubscribe.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/unsubscribe.js).

# Invio di messaggi SMS con Amazon SNS
<a name="sns-examples-sending-sms"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Questo esempio di codice di Node.js illustra:**
+ Come ottenere e impostare le preferenze di messaggistica SMS per Amazon SNS.
+ Come controllare un numero di telefono per verificare se è stata disattivata la ricezione di messaggi SMS.
+ Come ottenere un elenco di numeri di telefono per cui è stata disattivata la ricezione di messaggi SMS.
+ Come inviare un messaggio SMS.

## Lo scenario
<a name="sns-examples-sending-sms-scenario"></a>

Puoi utilizzare Amazon SNS; per inviare messaggi SMS a dispositivi abilitati. Puoi inviare un messaggio direttamente a un numero di telefono oppure inviarlo a più numeri contemporaneamente sottoscrivendo quei numeri a un argomento e inviando il messaggio all'argomento.

In questo esempio, utilizzi una serie di moduli Node.js per pubblicare messaggi di testo SMS da Amazon SNS a dispositivi abilitati agli SMS. I moduli Node.js utilizzano l'SDK per JavaScript pubblicare messaggi SMS utilizzando questi metodi della classe client: `SNS`
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)

## Attività prerequisite
<a name="sns-examples-sending-sms-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/blob/main/javascriptv3/example_code/sns/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.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Recupero degli attributi SMS
<a name="sending-sms-getattributes"></a>

Usa Amazon SNS per specificare le preferenze per la messaggistica SMS, ad esempio il modo in cui le consegne sono ottimizzate (in termini di costi o per una consegna affidabile), il limite di spesa mensile, il modo in cui vengono registrate le consegne dei messaggi e se abbonarsi ai report giornalieri sull'utilizzo degli SMS. Queste preferenze vengono recuperate e impostate come attributi SMS per Amazon SNS.

In questo esempio, usa un modulo Node.js per ottenere gli attributi SMS correnti in Amazon SNS.

Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Crea un modulo Node.js con il nome del file `get-sms-attributes.js`.

Configura l'SDK come mostrato in precedenza, incluso il download dei client e dei pacchetti richiesti. Crea un oggetto contenente i parametri per ottenere attributi SMS, inclusi i nomi dei singoli attributi da recuperare. Per i dettagli sugli attributi SMS disponibili, consulta [Set SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) in the Amazon Simple Notification Service API Reference.

Questo esempio recupera l'attributo `DefaultSMSType`, che controlla se i messaggi SMS vengono inviati come `Promotional` per ottimizzare il recapito dei messaggi e permettere di contenere i costi, oppure come `Transactional` per ottimizzare il recapito dei messaggi e ottenere la massima affidabilità. Trasferisci i parametri al metodo `SetTopicAttributesCommand` della classe client `SNS`. Per chiamare il `SetSMSAttributesCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituisci *ATTRIBUTE\$1NAME* con il nome dell'attributo.

```
import { GetSMSAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const getSmsAttributes = async () => {
  const response = await snsClient.send(
    // If you have not modified the account-level mobile settings of SNS,
    // the DefaultSMSType is undefined. For this example, it was set to
    // Transactional.
    new GetSMSAttributesCommand({ attributes: ["DefaultSMSType"] }),
  );

  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '67ad8386-4169-58f1-bdb9-debd281d48d5',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   attributes: { DefaultSMSType: 'Transactional' }
  // }
  return response;
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node get-sms-attributes.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-sms-attributes.js).

## Impostazione degli attributi SMS
<a name="sending-sms-setattributes"></a>

In questo esempio, usa un modulo Node.js per ottenere gli attributi SMS correnti in Amazon SNS.

Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Crea un modulo Node.js con il nome del file `set-sms-attribute-type.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Crea un oggetto contenente i parametri per impostare gli attributi SMS, inclusi i nomi dei singoli attributi da impostare e i valori da impostare per ciascuno di essi. Per i dettagli sugli attributi SMS disponibili, consulta [Set SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) in the Amazon Simple Notification Service API Reference.

Questo esempio imposta l'attributo `DefaultSMSType` su `Transactional`, ottimizzando il recapito dei messaggi per ottenere la massima affidabilità. Trasferisci i parametri al metodo `SetTopicAttributesCommand` della classe client `SNS`. Per chiamare il `SetSMSAttributesCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

```
import { SetSMSAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {"Transactional" | "Promotional"} defaultSmsType
 */
export const setSmsType = async (defaultSmsType = "Transactional") => {
  const response = await snsClient.send(
    new SetSMSAttributesCommand({
      attributes: {
        // Promotional – (Default) Noncritical messages, such as marketing messages.
        // Transactional – Critical messages that support customer transactions,
        // such as one-time passcodes for multi-factor authentication.
        DefaultSMSType: defaultSmsType,
      },
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '1885b977-2d7e-535e-8214-e44be727e265',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node set-sms-attribute-type.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-sms-attribute-type.js).

## Controllare se un numero di telefono è stato disattivato
<a name="sending-sms-checkifphonenumberisoptedout"></a>

In questo esempio, utilizza un modulo Node.js per controllare un numero di telefono per verificare se è stata disattivata la ricezione di messaggi SMS. 

Crea una `libs` directory e crea un modulo Node.js con il nome del file`snsClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `check-if-phone-number-is-opted-out.js`. Configura l'SDK come mostrato in precedenza. Crea un oggetto contenente il numero di telefono da controllare come parametro.

Questo esempio imposta il parametro `PhoneNumber` per specificare il numero di telefono da verificare. Trasferisci l'oggetto al metodo `CheckIfPhoneNumberIsOptedOutCommand` della classe client `SNS`: Per chiamare il `CheckIfPhoneNumberIsOptedOutCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

**Nota**  

Sostituisci con il numero *PHONE\$1NUMBER* di telefono.

```
import { CheckIfPhoneNumberIsOptedOutCommand } from "@aws-sdk/client-sns";

import { snsClient } from "../libs/snsClient.js";

export const checkIfPhoneNumberIsOptedOut = async (
  phoneNumber = "5555555555",
) => {
  const command = new CheckIfPhoneNumberIsOptedOutCommand({
    phoneNumber,
  });

  const response = await snsClient.send(command);
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '3341c28a-cdc8-5b39-a3ee-9fb0ee125732',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   isOptedOut: false
  // }
  return response;
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node check-if-phone-number-is-opted-out.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/check-if-phone-number-is-opted-out.js).

## Elenco di numeri di telefono disattivati
<a name="sending-sms-listphonenumbersoptedout"></a>

In questo esempio, utilizza un modulo Node.js per ottenere un elenco di numeri di telefono per cui è stata disattivata la ricezione di messaggi SMS.

Crea una `libs` directory e crea un modulo Node.js con il nome del file`snsClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `list-phone-numbers-opted-out.js`. Configura l'SDK come mostrato in precedenza. Crea un oggetto vuoto come parametro.

Trasferisci l'oggetto al metodo `ListPhoneNumbersOptedOutCommand` della classe client `SNS`: Per chiamare il `ListPhoneNumbersOptedOutCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters. 

```
import { ListPhoneNumbersOptedOutCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const listPhoneNumbersOptedOut = async () => {
  const response = await snsClient.send(
    new ListPhoneNumbersOptedOutCommand({}),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '44ff72fd-1037-5042-ad96-2fc16601df42',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   phoneNumbers: ['+15555550100']
  // }
  return response;
};
```

Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.

```
node list-phone-numbers-opted-out.js 
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-phone-numbers-opted-out.js).

## Pubblicazione di un messaggio SMS
<a name="sending-sms-publishsms"></a>

In questo esempio, utilizza un modulo Node.js per inviare un messaggio SMS a un numero di telefono.

Crea una `libs` directory e crea un modulo Node.js con il nome del file`snsClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Crea un modulo Node.js con il nome del file `publish-sms.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Crea un oggetto contenente i parametri `Message` e `PhoneNumber`.

Quando invii un SMS, ricorda di specificare il numero di telefono utilizzando il formato E.164. E.164 è uno standard per la struttura del numero di telefono utilizzato per le telecomunicazioni internazionali. I numeri di telefono che seguono questo formato possono avere un massimo di 15 cifre e sono preceduti dal segno più (\$1) e dal prefisso internazionale. Ad esempio, un numero di telefono statunitense in formato E.164 apparirebbe come \$11001. XXX5550100 

Questo esempio imposta il parametro `PhoneNumber` per specificare il numero di telefono a cui inviare il messaggio. Trasferisci l'oggetto al metodo `PublishCommand` della classe client `SNS`: Per chiamare il `PublishCommand` metodo, crea una funzione asincrona che richiama un oggetto di servizio Amazon SNS, passando l'oggetto parameters. 

**Nota**  
Sostituisci *TEXT\$1MESSAGE* con il messaggio di testo e *PHONE\$1NUMBER* con il numero di telefono.

```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string | Record<string, any>} message - The message to send. Can be a plain string or an object
 *                                                 if you are using the `json` `MessageStructure`.
 * @param {*} phoneNumber - The phone number to send the message to.
 */
export const publish = async (
  message = "Hello from SNS!",
  phoneNumber = "+15555555555",
) => {
  const response = await snsClient.send(
    new PublishCommand({
      Message: message,
      // One of PhoneNumber, TopicArn, or TargetArn must be specified.
      PhoneNumber: phoneNumber,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '7410094f-efc7-5f52-af03-54737569ab77',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node publish-sms.js
```

Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-sms.js).

# Esempi di Amazon Transcribe
<a name="Transcribe-examples"></a>

Amazon Transcribe consente agli sviluppatori di aggiungere facilmente funzionalità di sintesi vocale alle proprie applicazioni. 

![\[Relazione tra JavaScript ambienti, SDK e Amazon Transcribe\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/code-samples-transcribe.png)


L' JavaScript API per Amazon Transcribe è esposta tramite [TranscribeService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/Transcribe/)la classe client.

**Topics**
+ [Esempi di Amazon Transcribe](transcribe-examples-section.md)
+ [Amazon Transcribe: esempi medici](transcribe-medical-examples-section.md)

# Esempi di Amazon Transcribe
<a name="transcribe-examples-section"></a>

In questo esempio, una serie di moduli Node.js vengono utilizzati per creare, elencare ed eliminare lavori di trascrizione utilizzando i seguenti metodi della classe client: `TranscribeService`
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Per ulteriori informazioni sugli utenti di Amazon Transcribe, consulta la guida per sviluppatori di Amazon [Transcribe](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Attività prerequisite
<a name="transcribe-example-transcription-jobs"></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/blob/main/javascriptv3/example_code/transcribe/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.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Avvio di un lavoro in Amazon Transcribe
<a name="transcribe-start-transcription"></a>

Questo esempio dimostra come avviare un processo di trascrizione di Amazon Transcribe utilizzando il. AWS SDK per JavaScript Per ulteriori informazioni, consulta [StartTranscriptionJobCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/).

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `transcribeClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon Transcribe. Sostituiscilo *REGION* con la tua regione. AWS 

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crea un modulo Node.js con il nome del file `transcribe-create-job.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Create un oggetto parametrico, specificando i parametri richiesti. Avviate il lavoro utilizzando il `StartMedicalTranscriptionJobCommand` comando.

**Nota**  
Sostituisci *MEDICAL\$1JOB\$1NAME* con un nome per il lavoro di trascrizione. Per *OUTPUT\$1BUCKET\$1NAME* specificare il bucket Amazon S3 in cui salvare l'output. Per *JOB\$1TYPE* specificare tipi di lavoro. Per *SOURCE\$1LOCATION* specificare la posizione del file sorgente. Per *SOURCE\$1FILE\$1LOCATION* specificare la posizione del file multimediale di input.

```
// Import the required AWS SDK clients and commands for Node.js
import { StartTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  TranscriptionJobName: "JOB_NAME",
  LanguageCode: "LANGUAGE_CODE", // For example, 'en-US'
  MediaFormat: "SOURCE_FILE_FORMAT", // For example, 'wav'
  Media: {
    MediaFileUri: "SOURCE_LOCATION",
    // For example, "https://transcribe-demo.s3-REGION.amazonaws.com/hello_world.wav"
  },
  OutputBucketName: "OUTPUT_BUCKET_NAME",
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new StartTranscriptionJobCommand(params),
    );
    console.log("Success - put", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi.

```
node transcribe-create-job.js
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_job.js). GitHub

## Elenca le offerte di lavoro in Amazon Transcribe
<a name="transcribe-list-jobs"></a>

Questo esempio mostra come elencare i lavori di trascrizione di Amazon Transcribe utilizzando il. AWS SDK per JavaScript Per ulteriori informazioni su quali altre impostazioni puoi modificare, consulta. [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)

Create una `libs` directory e create un modulo Node.js con il nome del file`transcribeClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon Transcribe. Sostituiscilo *REGION* con la tua regione. AWS 

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crea un modulo Node.js con il nome del file `transcribe-list-jobs.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Create un oggetto parametrico con i parametri richiesti.

**Nota**  
Sostituisci *KEY\$1WORD* con una parola chiave che deve contenere il nome del lavoro restituito.

```
// Import the required AWS SDK clients and commands for Node.js

import { ListTranscriptionJobsCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  JobNameContains: "KEYWORD", // Not required. Returns only transcription
  // job names containing this string
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new ListTranscriptionJobsCommand(params),
    );
    console.log("Success", data.TranscriptionJobSummaries);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node transcribe-list-jobs.js
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_jobs.js). GitHub

## Eliminazione di un lavoro Amazon Transcribe
<a name="transcribe-delete-job"></a>

Questo esempio mostra come eliminare un processo di trascrizione di Amazon Transcribe utilizzando il. AWS SDK per JavaScript Per ulteriori informazioni su optional, consulta. [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Create una `libs` directory e create un modulo Node.js con il nome del file`transcribeClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon Transcribe. Sostituiscilo *REGION* con la tua regione. AWS 

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crea un modulo Node.js con il nome del file `transcribe-delete-job.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Specificate la AWS regione e il nome del lavoro che desiderate eliminare.

**Nota**  
Sostituisci *JOB\$1NAME* con il nome del lavoro da eliminare. 

```
// Import the required AWS SDK clients and commands for Node.js
import { DeleteTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  TranscriptionJobName: "JOB_NAME", // Required. For example, 'transciption_demo'
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new DeleteTranscriptionJobCommand(params),
    );
    console.log("Success - deleted");
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node transcribe-delete-job.js  
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_job.js). GitHub

# Amazon Transcribe: esempi medici
<a name="transcribe-medical-examples-section"></a>

In questo esempio, una serie di moduli Node.js vengono utilizzati per creare, elencare ed eliminare lavori di trascrizione medica utilizzando i seguenti metodi della classe client: `TranscribeService`
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Per ulteriori informazioni sugli utenti di Amazon Transcribe, consulta la guida per sviluppatori di Amazon [Transcribe](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Attività prerequisite
<a name="transcribe-example-transcription-medical-jobs"></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/blob/main/javascriptv3/example_code/transcribe/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.

**Importante**  
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6  
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Avvio di un lavoro di trascrizione medica con Amazon Transcribe
<a name="transcribe-start-medical-transcription"></a>

Questo esempio dimostra come avviare un processo di trascrizione medica di Amazon Transcribe utilizzando il. AWS SDK per JavaScript Per ulteriori informazioni, vedere [startMedicalTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/).

Crea una `libs` directory e crea un modulo Node.js con il nome del file`transcribeClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon Transcribe. Sostituiscilo *REGION* con la tua regione. AWS 

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crea un modulo Node.js con il nome del file `transcribe-create-medical-job.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Create un oggetto parametrico, specificando i parametri richiesti. Inizia il lavoro medico usando il `StartMedicalTranscriptionJobCommand` comando.

**Nota**  
Sostituiscilo *MEDICAL\$1JOB\$1NAME* con un nome per il lavoro di trascrizione medica. Per *OUTPUT\$1BUCKET\$1NAME* specificare il bucket Amazon S3 in cui salvare l'output. Per *JOB\$1TYPE* specificare tipi di lavoro. Per *SOURCE\$1LOCATION* specificare la posizione del file sorgente. Per *SOURCE\$1FILE\$1LOCATION* specificare la posizione del file multimediale di input.

```
// Import the required AWS SDK clients and commands for Node.js
import { StartMedicalTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  MedicalTranscriptionJobName: "MEDICAL_JOB_NAME", // Required
  OutputBucketName: "OUTPUT_BUCKET_NAME", // Required
  Specialty: "PRIMARYCARE", // Required. Possible values are 'PRIMARYCARE'
  Type: "JOB_TYPE", // Required. Possible values are 'CONVERSATION' and 'DICTATION'
  LanguageCode: "LANGUAGE_CODE", // For example, 'en-US'
  MediaFormat: "SOURCE_FILE_FORMAT", // For example, 'wav'
  Media: {
    MediaFileUri: "SOURCE_FILE_LOCATION",
    // The S3 object location of the input media file. The URI must be in the same region
    // as the API endpoint that you are calling.For example,
    // "https://transcribe-demo.s3-REGION.amazonaws.com/hello_world.wav"
  },
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new StartMedicalTranscriptionJobCommand(params),
    );
    console.log("Success - put", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettete quanto segue al prompt dei comandi.

```
node transcribe-create-medical-job.js
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_medical_job.js). GitHub

## Pubblicazione di offerte di lavoro nel settore medico in Amazon Transcribe
<a name="transcribe-list-medical-jobs"></a>

Questo esempio mostra come elencare i lavori di trascrizione di Amazon Transcribe utilizzando il. AWS SDK per JavaScript Per ulteriori informazioni, consulta [ListTranscriptionMedicalJobsCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListMedicalTranscriptionJobsCommand/).

Crea una `libs` directory e crea un modulo Node.js con il nome del file. `transcribeClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon Transcribe. Sostituiscilo *REGION* con la tua regione. AWS 

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crea un modulo Node.js con il nome del file `transcribe-list-medical-jobs.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Create un oggetto parametrico con i parametri richiesti ed elencate i lavori medici utilizzando il `ListMedicalTranscriptionJobsCommand` comando.

**Nota**  
Sostituisci *KEYWORD* con una parola chiave che deve contenere il nome dei lavori restituiti.

```
// Import the required AWS SDK clients and commands for Node.js

import { ListMedicalTranscriptionJobsCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  JobNameContains: "KEYWORD", // Returns only transcription job names containing this string
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new ListMedicalTranscriptionJobsCommand(params),
    );
    console.log("Success", data.MedicalTranscriptionJobName);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node transcribe-list-medical-jobs.js
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_medical_jobs.js). GitHub

## Eliminazione di un lavoro medico in Amazon Transcribe
<a name="transcribe-delete-medical-job"></a>

Questo esempio mostra come eliminare un processo di trascrizione di Amazon Transcribe utilizzando il. AWS SDK per JavaScript Per ulteriori informazioni su optional, consulta. [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteMedicalTranscriptionJobCommand/)

Create una `libs` directory e create un modulo Node.js con il nome del file`transcribeClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon Transcribe. Sostituiscilo *REGION* con la tua regione. AWS 

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Questo codice di esempio può essere trovato [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Crea un modulo Node.js con il nome del file `transcribe-delete-job.js`. Assicurati di configurare l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Create un oggetto parametrico con i parametri richiesti ed eliminate il lavoro medico utilizzando il `DeleteMedicalJobCommand` comando.

**Nota**  
Sostituisci *JOB\$1NAME* con il nome del lavoro da eliminare. 

```
// Import the required AWS SDK clients and commands for Node.js
import { DeleteMedicalTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  MedicalTranscriptionJobName: "MEDICAL_JOB_NAME", // For example, 'medical_transciption_demo'
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new DeleteMedicalTranscriptionJobCommand(params),
    );
    console.log("Success - deleted");
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.

```
node transcribe-delete-medical-job.js
```

Questo codice di esempio può essere trovato [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_medical_job.js). GitHub

# Configurazione di Node.js su un'istanza Amazon EC2
<a name="setting-up-node-on-ec2-instance"></a>

Uno scenario comune per l'utilizzo di Node.js con l'SDK per JavaScript consiste nel configurare ed eseguire un'applicazione Web Node.js su un'istanza Amazon Elastic Compute Cloud (Amazon EC2). In questo tutorial, creerai un'istanza Linux, ti connetterai a essa tramite SSH, quindi installerai Node.js per l'esecuzione su tale istanza. 

## Prerequisiti
<a name="setting-up-node-on-ec2-instance.prerequisites"></a>

Questo tutorial presuppone che tu abbia già avviato un'istanza Linux con un nome DNS pubblico raggiungibile da Internet e a cui puoi connetterti tramite SSH. Per ulteriori informazioni su come eseguire questa operazione, consulta [Fase 1: Avvio di un'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-launch-instance) nella *Guida utente Amazon EC2;.*

**Importante**  
Usa **Amazon Linux 2023** Amazon Machine Image (AMI) per lanciare una nuova istanza Amazon EC2.

È inoltre necessario aver configurato il gruppo di sicurezza per consentire le connessioni `SSH` (porta 22), ` HTTP` (porta 80) e `HTTPS` (porta 443). Per ulteriori informazioni su questi prerequisiti, consulta [Configurazione con Amazon EC2 nella Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html) EC2 *User Guide*.

## Procedura
<a name="setting-up-node-on-ec2-instance-procedure"></a>

La procedura seguente ti consente di installare Node.js su un'istanza Amazon Linux. Puoi utilizzare questo server per l'hosting di un'applicazione Web Node.js.

**Per configurare Node.js sulla tua istanza Linux**

1. Connettersi all'istanza Linux come `ec2-user` tramite SSH.

1. Installa node version manager (`nvm`) digitando quanto segue nella riga di comando.
**avvertimento**  
AWS non controlla il codice seguente. Prima di eseguirlo, assicurati di verificarne l'autenticità e l'integrità. Ulteriori informazioni su questo codice sono disponibili nel repository [nvm.](https://github.com/nvm-sh/nvm/blob/master/README.md) GitHub

   ```
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
   ```

   Useremo `nvm` per installare Node.js perché `nvm` può installare più versioni di Node.js e permetterti di passare da una all'altra.

1. Carica `nvm` digitando quanto segue nella riga di comando.

   ```
   source ~/.bashrc
   ```

1. Usa nvm per installare l'ultima versione LTS di Node.js digitando quanto segue nella riga di comando.

   ```
   nvm install --lts
   ```

   L'installazione di Node.js installa anche il Node Package Manager (`npm`) in modo da poter installare moduli aggiuntivi secondo necessità.

1. Verificare che Node.js sia installato e correttamente in esecuzione digitando quanto segue nella riga di comando.

   ```
   node -e "console.log('Running Node.js ' + process.version)"
   ```

   Viene visualizzato il seguente messaggio che mostra la versione di Node.js in esecuzione.

    `Running Node.js VERSION` 

**Nota**  
L'installazione del nodo si applica solo alla sessione corrente di Amazon EC2. Se si riavvia la sessione CLI, è necessario utilizzare nuovamente nvm per abilitare la versione del nodo installata. Se l'istanza viene terminata, devi installare nuovamente il nodo. L'alternativa è creare un'Amazon Machine Image (AMI) dell'istanza Amazon EC2 una volta ottenuta la configurazione che desideri mantenere, come descritto nel seguente argomento.

## Creazione di un'Amazon Machine Image (AMI)
<a name="setting-up-node-on-ec2-instance-create-image"></a>

Dopo aver installato Node.js su un'istanza Amazon EC2, puoi creare un'Amazon Machine Image (AMI) da quell'istanza. La creazione di un'AMI semplifica il provisioning di più istanze Amazon EC2 con la stessa installazione di Node.js. Per ulteriori informazioni sulla creazione di un'AMI da un'istanza esistente, consulta [Creazione di un'AMI Linux supportata da Amazon EBS nella Guida](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) per l'utente di *Amazon EC2*.

## Risorse correlate
<a name="setting-up-node-on-ec2-instance-related-resource"></a>

Per ulteriori informazioni sui comandi e sul software utilizzati in questo argomento, consulta le seguenti pagine Web:
+ Node version manager (`nvm`): vedere [nvm](https://github.com/creationix/nvm) repo on. GitHub
+ Node Package Manager (`npm`) —Vedi il sito web di [npm](https://www.npmjs.com).

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

# Creazione di eventi pianificati per eseguire AWS Lambda funzioni
<a name="scheduled-events-invoking-lambda-example"></a>

Puoi creare un evento pianificato che richiami una AWS Lambda funzione utilizzando un Amazon CloudWatch Event. È possibile configurare un CloudWatch evento per utilizzare un'espressione cron per pianificare quando viene richiamata una funzione Lambda. Ad esempio, puoi pianificare un CloudWatch evento per richiamare una funzione Lambda ogni giorno della settimana.

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 tutorial, 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 di questo tutorial richiede circa 20 minuti.

Questo tutorial 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 usare un'espressione cron per richiamare la funzione Lambda ogni giorno della settimana.

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 interrompere tutte le risorse dopo aver completato questo tutorial per assicurarti che non ti venga addebitato alcun costo.

**Per creare l'app:**

1. [Prerequisiti completi](#scheduled-events-invoking-lambda-provision-resources)

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

1. [Preparare lo script del browser](#scheduled-events-invoking-lambda-browser-script)

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

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

1. [Esegui l'app](#scheduled-events-invoking-lambda-run)

1. [Elimina le risorse](#scheduled-events-invoking-lambda-destroy)

## Attività prerequisite
<a name="scheduled-events-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.js 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/blob/main/javascriptv3/example_code/cross-services/lex-bot/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="scheduled-events-invoking-lambda-provision-resources"></a>

Questo tutorial richiede le seguenti risorse.
+ Una tabella Amazon DynamoDB **denominata Employee con una chiave **denominata**** Id e i campi mostrati nell'illustrazione precedente. Assicurati di inserire i dati corretti, incluso un telefono cellulare valido con cui 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 usando CloudFormation come descritto in questo tutorial.

### Crea le AWS risorse utilizzando CloudFormation
<a name="scheduled-events-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-scheduled-events/setup.yaml)
**Nota**  
Il CloudFormation modello è stato generato utilizzando quello AWS CDK [disponibile qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/lambda_using_scheduled_events). 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).

   Visualizza un elenco delle risorse nella console aprendo lo stack sulla CloudFormation dashboard e scegliendo la scheda **Risorse**. Ti servono per il tutorial. 

1. Quando lo stack viene creato, utilizzare il AWS SDK per JavaScript per popolare la tabella DynamoDB, come descritto in. [Compila la tabella DynamoDB](#scheduled-events-invoking-lambda-resources-create-table)

### Compila la tabella DynamoDB
<a name="scheduled-events-invoking-lambda-resources-create-table"></a>

Per popolare la tabella, crea prima una directory denominata`libs`, in essa crea un file denominato `dynamoClient.js` e incolla 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 DynamoDB 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-scheduled-events/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.
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-scheduled-events/src/helper-functions/populate-table.js).

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

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

Importa innanzitutto i moduli e i comandi richiesti AWS SDK per JavaScript (v3): `ScanCommand` DynamoDB `DynamoDBClient` e `SNSClient` il comando Amazon SNS. `PublishCommand` Sostituisci con la regione*REGION*. AWS Quindi calcola la data odierna e assegnala a un parametro. Quindi crea i parametri per `ScanCommand` .Replace *TABLE\$1NAME* con il nome della tabella che hai creato nella [Crea le risorse AWS](#scheduled-events-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](#scheduled-events-invoking-lambda-full).)

```
"use strict";
// Load the required clients and commands.
const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");

//Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"

// 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 the the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "TABLE_NAME",
};
```

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

Per prima cosa 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](#scheduled-events-invoking-lambda-full).)

```
exports.handler = async (event, context, callback) => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      const data = await snsclient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to check identify employees with work anniversary today.
    const data = await dbclient.send(new ScanCommand(params));
    data.Items.forEach(function (element, index, array) {
      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="scheduled-events-invoking-lambda-full"></a>

Questo argomento descrive come raggruppare i `mylambdafunction.js` 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](#scheduled-events-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 mylamdbafunction.js --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. `my-lambda-function.zip`

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

Ecco il codice completo dello script del browser per. `mylambdafunction.js`

```
"use strict";
// Load the required clients and commands.
const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");

//Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"

// 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 the the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "TABLE_NAME",
};

// Create the client service objects.
const dbclient = new DynamoDBClient({ region: REGION });
const snsclient = new SNSClient({ region: REGION });

exports.handler = async (event, context, callback) => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      const data = await snsclient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to check identify employees with work anniversary today.
    const data = await dbclient.send(new ScanCommand(params));
    data.Items.forEach(function (element, index, array) {
      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);
  }
};
```

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

Nella radice del progetto, crea un `lambda-function-setup.js` 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 *IAM\$1ROLE\$1ARN* con l'Amazon Resource Number (ARN) del ruolo IAM che hai creato nell'[Crea le risorse AWS](#scheduled-events-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");

// Instantiate an Lambda client service object.
const lambda = new LambdaClient({ region: REGION });

// 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 the each anniversary of their start-date.",
};

const run = async () => {
  try {
    const data = await lambda.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.js
```

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

## Configura CloudWatch per richiamare le funzioni Lambda
<a name="scheduled-events-invoking-lambda-run"></a>

 CloudWatch Per configurare l'invocazione delle funzioni Lambda:

1. Aprire la **pagina Functions (Funzioni)** nella console Lambda.

1. Scegli la funzione Lambda.

1. Under **Designer**, scegliere **Add trigger (Aggiungi trigger)**.

1. Imposta il tipo di trigger su **CloudWatch EventBridgeEvents/**.

1. Per Regola, scegli **Crea una nuova** regola.

1.  Inserisci il nome della regola e la descrizione della regola.

1. Per il tipo di regola, seleziona **Espressione di pianificazione**.

1. Nel campo **Schedule expression**, inserisci un'espressione cron. Ad esempio, **cron (0) 12? \$1 DAL LUNEDÌ AL VENERDÌ** (\$1).

1. Scegliere **Aggiungi**.
**Nota**  
Per ulteriori informazioni, consulta [Uso di Lambda con CloudWatch ](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html) gli eventi.

## Eliminare le risorse
<a name="scheduled-events-invoking-lambda-destroy"></a>

Complimenti\$1 Hai richiamato una funzione Lambda tramite eventi pianificati di CloudWatch Amazon utilizzando. 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](#scheduled-events-invoking-lambda-provision-resources)argomento di questo tutorial, come segue:

1. Apri la [CloudFormation console]( https://console.aws.amazon.com/cloudformation/home).

1. Nella pagina **Stacks**, seleziona lo stack.

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

# Creazione di un chatbot Amazon Lex
<a name="lex-bot-example"></a>

Puoi creare un chatbot Amazon Lex all'interno di un'applicazione Web per coinvolgere i visitatori del tuo sito Web. Un chatbot di Amazon Lex è una funzionalità che esegue conversazioni in chat online con gli utenti senza fornire un contatto diretto con una persona. Ad esempio, l'illustrazione seguente mostra un chatbot Amazon Lex che coinvolge un utente nella prenotazione di una camera d'albergo.

![\[Chatbot interface demonstrating a hotel booking conversation with user inputs and bot responses.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/lex_example/chatintro.png)


Il chatbot Amazon Lex creato in questo AWS tutorial è in grado di gestire più lingue. Ad esempio, un utente che parla francese può inserire testo in francese e ottenere una risposta in francese.

![\[Chatbot interface demonstrating Amazon Lex integration with French language support.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot2.png)


Allo stesso modo, un utente può comunicare con il chatbot di Amazon Lex in italiano.

![\[Chat interface showing Italian language exchange between user and Amazon Lex chatbot.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot3.png)


Questo AWS tutorial ti guida nella creazione di un chatbot Amazon Lex e nella sua integrazione in un'applicazione Web Node.js. La AWS SDK per JavaScript (v3) viene utilizzata per richiamare questi servizi: AWS 
+ Amazon Lex
+ Amazon Comprehend
+ Amazon Translate

**Costo di completamento:** i AWS servizi inclusi in questo documento sono inclusi nel piano [AWS gratuito](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc).

**Nota:** assicurati di interrompere tutte le risorse che crei durante la lettura di questo tutorial per assicurarti che non ti venga addebitato alcun costo.

**Per creare l'app:**

1. [Prerequisiti](#lex-bot-example-prerequisites)

1. [Effettuare il provisioning delle risorse](#lex-bot-provision-resources)

1. [Crea un chatbot Amazon Lex](#lex-bot-example-create-lex-bot)

1. [Crea il codice HTML](#lex-bot-example-html)

1. [Crea lo script del browser](#lex-bot-example-script)

1. [Fasi successive](#lex-bot-example-next-steps)

## Prerequisiti
<a name="lex-bot-example-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-scheduled-events/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.

**Importante**  
Questo esempio utilizza ECMAScript6 (). ES6 Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .  
Tuttavia, se preferisci utilizzare la sintassi CommonJS, fai riferimento a. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)

## Crea le risorse AWS
<a name="lex-bot-provision-resources"></a>

Questo tutorial richiede le seguenti risorse.
+ Un ruolo IAM non autenticato con autorizzazioni allegate per:
  + Amazon Comprehend
  + Amazon Translate
  + Amazon Lex

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

### Crea le AWS risorse utilizzando CloudFormation
<a name="lex-bot-example-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/lex-bot/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/lex_bot_example_iam_unauth_role). 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).

   Per visualizzare le risorse create, apri la console Amazon Lex, scegli lo stack e seleziona la scheda **Risorse**.

## Creazione di un bot Amazon Lex
<a name="lex-bot-example-create-lex-bot"></a>

**Importante**  
Usa la versione 1 della console Amazon Lex per creare il bot. Questo esempio non funziona con i bot creati utilizzando V2.

Il primo passaggio consiste nel creare un chatbot Amazon Lex utilizzando la console di gestione di Amazon Web Services. In questo esempio, viene utilizzato l'**BookTrip**esempio di Amazon Lex. Per ulteriori informazioni, consulta [Book Trip](https://docs.aws.amazon.com/lex/latest/dg/ex-book-trip.html).
+ Accedi alla console di gestione di Amazon Web Services e apri la console Amazon Lex su [Amazon Web Services Console](https://console.aws.amazon.com/lex/).
+ Nella pagina Bot, scegli **Crea**.
+ Scegli **BookTrip**blueprint (lascia il nome **BookTrip**predefinito del bot).  
![\[Interface for creating a chatbot, showing BookTrip sample with conversation flow and components.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/lex_example/pic2.png)
+ Inserisci le impostazioni predefinite e scegli **Crea** (la console mostra il **BookTrip**bot). Nella scheda Editor, esamina i dettagli degli intenti preconfigurati.
+ Esegui il test del bot nella finestra di prova. Inizia il test digitando *Voglio prenotare una* camera d'albergo.  
![\[Chat interface showing a hotel booking conversation with a bot asking for the city.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/lex_example/ChatBotTest.png)
+ Scegliete **Pubblica** e specificate un nome alias (questo valore vi servirà quando usate il AWS SDK per JavaScript).

**Nota**  
 Devi fare riferimento al **nome del bot** e all'**alias del bot** nel codice JavaScript .

## Crea il codice HTML
<a name="lex-bot-example-html"></a>

Crea un file denominato `index.html`. Copia e incolla il codice seguente in`index.html`. Questo codice HTML fa riferimento`main.js`. Questa è una versione in bundle di index.js, che include i AWS SDK per JavaScript moduli richiesti. Creerai questo file in[Crea il codice HTML](#lex-bot-example-html). `index.html`anche riferimenti`style.css`, che aggiungono gli stili. 

```
<!doctype html>
<head>
  <title>Amazon Lex - Sample Application (BookTrip)</title>
  <link type="text/css" rel="stylesheet" href="style.css" />
</head>

<body>
  <h1 id="title">Amazon Lex - BookTrip</h1>
  <p id="intro">
    This multiple language chatbot shows you how easy it is to incorporate
    <a
      href="https://aws.amazon.com/lex/"
      title="Amazon Lex (product)"
      target="_new"
      >Amazon Lex</a
    >
    into your web apps. Try it out.
  </p>
  <div id="conversation"></div>
  <input
    type="text"
    id="wisdom"
    size="80"
    value=""
    placeholder="J'ai besoin d'une chambre d'hôtel"
  />
  <br />
  <button onclick="createResponse()">Send Text</button>
  <script type="text/javascript" src="./main.js"></script>
</body>
```

Questo codice è disponibile anche [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk#running-a-cdk-app).

## Crea lo script del browser
<a name="lex-bot-example-script"></a>

Crea un file denominato `index.js`. Copia e incolla il codice seguente in`index.js`. Importa i AWS SDK per JavaScript moduli e i comandi richiesti. Crea clienti per Amazon Lex, Amazon Comprehend e Amazon Translate. Sostituisci *REGION* con AWS Region e *IDENTITY\$1POOL\$1ID* con l'ID del pool di identità che hai creato in. [Crea le risorse AWS](#lex-bot-provision-resources) Per recuperare l'ID del pool di identità, apri il pool di identità nella console Amazon Cognito, **scegli Modifica pool di identità** e **scegli Codice di esempio** nel menu laterale. L'ID del pool di identità viene visualizzato in rosso nella console.

Innanzitutto, crea una `libs` directory, crea gli oggetti client di servizio richiesti creando tre file`comprehendClient.js`,`lexClient.js`, e`translateClient.js`. Incolla il codice appropriato riportato di seguito in ciascuno di essi *REGION* e sostituiscilo con *IDENTITY\$1POOL\$1ID* in ogni file.

**Nota**  
Usa l'ID del pool di identità di Amazon Cognito in cui hai creato. [Crea le AWS risorse utilizzando CloudFormation](#lex-bot-example-resources-cli)

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { ComprehendClient } from "@aws-sdk/client-comprehend";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Comprehend service client object.
const comprehendClient = new ComprehendClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { comprehendClient };
```

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { LexRuntimeServiceClient } from "@aws-sdk/client-lex-runtime-service";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Lex service client object.
const lexClient = new LexRuntimeServiceClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { lexClient };
```

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { TranslateClient } from "@aws-sdk/client-translate";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Translate service client object.
const translateClient = new TranslateClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { translateClient };
```

Questo codice è disponibile [qui. GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/libs) .

Quindi, crea un `index.js` file e incolla il codice seguente al suo interno.

 Sostituisci *BOT\$1ALIAS* e rispettivamente *BOT\$1NAME* con l'alias e il nome del tuo bot Amazon Lex e *USER\$1ID* con un ID utente. La funzione `createResponse` asincrona esegue le seguenti operazioni:
+ Prende il testo immesso dall'utente nel browser e utilizza Amazon Comprehend per determinarne il codice della lingua.
+ Prende il codice della lingua e usa Amazon Translate per tradurre il testo in inglese.
+ Prende il testo tradotto e utilizza Amazon Lex per generare una risposta.
+ Pubblica la risposta nella pagina del browser.

```
import { DetectDominantLanguageCommand } from "@aws-sdk/client-comprehend";
import { TranslateTextCommand } from "@aws-sdk/client-translate";
import { PostTextCommand } from "@aws-sdk/client-lex-runtime-service";
import { lexClient } from "./libs/lexClient.js";
import { translateClient } from "./libs/translateClient.js";
import { comprehendClient } from "./libs/comprehendClient.js";

let g_text = "";
// Set the focus to the input box.
document.getElementById("wisdom").focus();

function showRequest() {
  const conversationDiv = document.getElementById("conversation");
  const requestPara = document.createElement("P");
  requestPara.className = "userRequest";
  requestPara.appendChild(document.createTextNode(g_text));
  conversationDiv.appendChild(requestPara);
  conversationDiv.scrollTop = conversationDiv.scrollHeight;
}

function showResponse(lexResponse) {
  const conversationDiv = document.getElementById("conversation");
  const responsePara = document.createElement("P");
  responsePara.className = "lexResponse";

  const lexTextResponse = lexResponse;

  responsePara.appendChild(document.createTextNode(lexTextResponse));
  responsePara.appendChild(document.createElement("br"));
  conversationDiv.appendChild(responsePara);
  conversationDiv.scrollTop = conversationDiv.scrollHeight;
}

function handletext(text) {
  g_text = text;
  const xhr = new XMLHttpRequest();
  xhr.addEventListener("load", loadNewItems, false);
  xhr.open("POST", "../text", true); // A Spring MVC controller
  xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded"); //necessary
  xhr.send(`text=${text}`);
}

function loadNewItems() {
  showRequest();

  // Re-enable input.
  const wisdomText = document.getElementById("wisdom");
  wisdomText.value = "";
  wisdomText.locked = false;
}

// Respond to user's input.
const createResponse = async () => {
  // Confirm there is text to submit.
  const wisdomText = document.getElementById("wisdom");
  if (wisdomText?.value && wisdomText.value.trim().length > 0) {
    // Disable input to show it is being sent.
    const wisdom = wisdomText.value.trim();
    wisdomText.value = "...";
    wisdomText.locked = true;
    handletext(wisdom);

    const comprehendParams = {
      Text: wisdom,
    };
    try {
      const data = await comprehendClient.send(
        new DetectDominantLanguageCommand(comprehendParams),
      );
      console.log(
        "Success. The language code is: ",
        data.Languages[0].LanguageCode,
      );
      const translateParams = {
        SourceLanguageCode: data.Languages[0].LanguageCode,
        TargetLanguageCode: "en", // For example, "en" for English.
        Text: wisdom,
      };
      try {
        const data = await translateClient.send(
          new TranslateTextCommand(translateParams),
        );
        console.log("Success. Translated text: ", data.TranslatedText);
        const lexParams = {
          botName: "BookTrip",
          botAlias: "mynewalias",
          inputText: data.TranslatedText,
          userId: "chatbot", // For example, 'chatbot-demo'.
        };
        try {
          const data = await lexClient.send(new PostTextCommand(lexParams));
          console.log("Success. Response is: ", data.message);
          const msg = data.message;
          showResponse(msg);
        } catch (err) {
          console.log("Error responding to message. ", err);
        }
      } catch (err) {
        console.log("Error translating text. ", err);
      }
    } catch (err) {
      console.log("Error identifying language. ", err);
    }
  }
};
// Make the function available to the browser.
window.createResponse = createResponse;
```

Questo codice è [disponibile qui GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/index.html) .

Ora usa webpack per raggruppare i AWS SDK per JavaScript moduli `index.js` and in un unico file,. `main.js`

1. Se non l'hai già fatto, segui questo esempio [Prerequisiti](#lex-bot-example-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: `main.js`

   ```
   webpack index.js --mode development --target web --devtool false -o main.js
   ```

## Fasi successive
<a name="lex-bot-example-next-steps"></a>

Complimenti\$1 Hai creato un'applicazione Node.js che utilizza Amazon Lex per creare un'esperienza utente interattiva. 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](#lex-bot-provision-resources)argomento di questo tutorial, come segue:

1. Apri la [CloudFormation console]( https://console.aws.amazon.com/cloudformation/home).

1. Nella pagina **Stacks**, seleziona lo stack.

1. Scegli **Elimina**.

[Per altri esempi AWS inter-service, consulta AWS SDK per JavaScript Esempi interservice.](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/tutorials.html)