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à.
# Esempi di Amazon Simple Email Service
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
![\[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
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
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à
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
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
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à
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
![\[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
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
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
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
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
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: `
Hello, {{contact.firstName}}!
Did you know Amazon has a mascot named Peccy?
`,
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
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 = "Hello, World!
";
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
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
![\[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
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
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
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
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
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: Hello {{contact.firstName}},
Don't forget about the party gifts!
* Destination: Hello Bilbo,
Don't forget about the party gifts!
*/
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
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: Hello {{name}},
Don't forget about the party gifts!
* Destination 1: Hello Bilbo,
Don't forget about the party gifts!
* Destination 2: Hello Frodo,
Don't forget about the party gifts!
*/
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