O [Guia de referência da API do AWS SDK para JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) descreve em detalhes todas as operações da API para o AWS SDK para JavaScript versão 3 (V3).
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Exemplos do Amazon Simple Email Service
O Amazon Simple Email Service (Amazon SES) é um serviço de envio de e-mails baseado na nuvem criado para ajudar profissionais de marketing digital e desenvolvedores de aplicativos a enviar e-mails de marketing, notificações e mensagens transacionais. Ele é um serviço confiável e econômico para empresas de todos os tamanhos que usam e-mail para manter contato com seus clientes.
![\[Relação entre JavaScript ambientes, o SDK e o Amazon SES\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)
A JavaScript API do Amazon SES é exposta por meio da classe `SES` cliente. Para obter mais informações sobre como usar a classe de cliente do Amazon SES, consulte [Classe: SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/) na Referência da API.
**Topics**
+ [Gerenciamento de identidades do Amazon SES](ses-examples-managing-identities.md)
+ [Trabalhar com modelos de e-mail no Amazon SES](ses-examples-creating-template.md)
+ [Envio de e-mail usando o Amazon SES](ses-examples-sending-email.md)
# Gerenciamento de identidades do Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Este exemplo de código Node.js mostra:**
+ Como verificar endereços de e-mail e domínios usados com o Amazon SES.
+ Como atribuir uma política AWS Identity and Access Management (IAM) às suas identidades do Amazon SES.
+ Como listar todas as identidades do Amazon SES para sua AWS conta.
+ Como excluir identidades usadas com o Amazon SES.
Uma *identidade* do Amazon SES é um endereço de e-mail ou domínio que o Amazon SES usa para enviar e-mails. O Amazon SES requer que você verifique suas identidades de e-mail, confirmando que você é o proprietário delas e impedindo que outras pessoas as utilizem.
Para obter detalhes sobre como verificar endereços de e-mail e domínios no Amazon SES, consulte [Verificar endereços de e-mail e domínios no Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) no Guia do desenvolvedor do Amazon Simple Email Service. Para obter informações sobre autorização de envio no Amazon SES, consulte [Visão geral da autorização de envio do Amazon SES](Amazon Simple Email Service Developer Guidesending-authorization-overview.html).
## O cenário
Neste exemplo, você usa uma série de módulos do Node.js para verificar e gerenciar identidades do Amazon SES. Os módulos Node.js usam o SDK JavaScript para verificar endereços de e-mail e domínios, usando esses métodos da classe `SES` cliente:
+ [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/)
## Tarefas de pré-requisito
Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.
**Importante**
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).
## Listar suas identidades
Neste exemplo, use um módulo do Node.js para listar endereços de e-mail e domínios para usar com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_listidentities.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para passar o `IdentityType` e outros parâmetros para o método `ListIdentitiesCommand` da classe de cliente `SES`. Para chamar o método `ListIdentitiesCommand`, invoque um objeto de serviço do Amazon SES passando o objeto dos parâmetros.
O `data` retornado contém um array de identidades de domínio, conforme especificado pelo parâmetro `IdentityType`.
**nota**
*IdentityType*Substitua pelo tipo de identidade, que pode ser EmailAddress "" ou “Domínio”.
```
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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando.
```
node ses_listidentities.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js).
## Verificar a identidade de um endereço de e-mail
Neste exemplo, use um módulo do Node.js para verificar remetentes de e-mail para usar com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_verifyemailidentity.js`. Configure o SDK conforme mostrado anteriormente, incluindo o download dos clientes e pacotes necessários.
Crie um objeto para passar o parâmetro `EmailAddress` para o método `VerifyEmailIdentityCommand` da classe de cliente `SES`. Para chamar o método `VerifyEmailIdentityCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros.
**nota**
*EMAIL\$1ADDRESS*Substitua pelo endereço de e-mail, como 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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O domínio é adicionado ao Amazon SES a ser verificado.
```
node ses_verifyemailidentity.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js).
## Verificar uma identidade de domínio
Neste exemplo, use um módulo do Node.js para verificar domínios de e-mail a serem usados com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_verifydomainidentity.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para passar o parâmetro `Domain` para o método `VerifyDomainIdentityCommand` da classe de cliente `SES`. Para chamar o método `VerifyDomainIdentityCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando o objeto dos parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*DOMAIN\$1NAME*Substitua pelo nome do domínio.
```
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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O domínio é adicionado ao Amazon SES a ser verificado.
```
node ses_verifydomainidentity.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js).
## Excluir identidades
Neste exemplo, use um módulo do Node.js para excluir endereços de e-mail ou domínios usados com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_deleteidentity.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para passar o parâmetro `Identity` para o método `DeleteIdentityCommand` da classe de cliente `SES`. Para chamar o método `DeleteIdentityCommand`, crie uma `request` para invocar um objeto de serviço de cliente do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*IDENTITY\$1EMAIL*Substitua pelo e-mail da identidade a ser excluída.
```
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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando.
```
node ses_deleteidentity.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js).
# Trabalhar com modelos de e-mail no Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Este exemplo de código Node.js mostra:**
+ Como obter uma lista de todos os modelos de e-mail.
+ Como recuperar e atualizar os modelos de e-mail.
+ Como criar e excluir modelos de e-mail.
O Amazon SES permite que você envie mensagens de e-mail personalizadas usando modelos de e-mail. Para obter detalhes sobre como criar e usar modelos de e-mail no Amazon SES, consulte [Envio de e-mail personalizado usando a API do Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html) no Guia do desenvolvedor do Amazon Simple Email Service.
## O cenário
Neste exemplo, você usa uma série de módulos do Node.js para trabalhar com modelos de e-mail. Os módulos Node.js usam o SDK JavaScript para criar e usar modelos de e-mail usando esses métodos da classe `SES` cliente:
+ [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/)
## Tarefas de pré-requisito
Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.
**Importante**
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).
## Listar seus modelos de e-mail
Neste exemplo, use um módulo do Node.js para criar um modelo de e-mail a ser usado com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_listtemplates.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para passar os parâmetros para o método `ListTemplatesCommand` da classe de cliente `SES`. Para chamar o método `ListTemplatesCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da 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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O Amazon SES retorna a lista de modelos.
```
node ses_listtemplates.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js).
## Obter um modelo de e-mail
Neste exemplo, use um módulo do Node.js para obter um modelo de e-mail a ser usado com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_gettemplate.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para passar o parâmetro `TemplateName` para o método `GetTemplateCommand` da classe de cliente `SES`. Para chamar o método `GetTemplateCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*TEMPLATE\$1NAME*Substitua pelo nome do modelo a ser devolvido.
```
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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O Amazon SES retorna os detalhes do modelo.
```
node ses_gettemplate.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js).
## Criar um modelo de e-mail
Neste exemplo, use um módulo do Node.js para criar um modelo de e-mail a ser usado com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_createtemplate.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para passar os parâmetros do método `CreateTemplateCommand` da classe de cliente `SES`, incluindo `TemplateName`, `HtmlPart`, `SubjectPart` e `TextPart`. Para chamar o método `CreateTemplateCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*TEMPLATE\$1NAME*Substitua por um nome para o novo modelo, *HtmlPart* pelo conteúdo do e-mail marcado em HTML e *SubjectPart* pelo assunto do 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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O modelo é adicionado ao Amazon SES.
```
node ses_createtemplate.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js).
## Atualização de um modelo de e-mail
Neste exemplo, use um módulo do Node.js para criar um modelo de e-mail a ser usado com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_updatetemplate.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para passar os valores do parâmetro `Template` que você deseja atualizar no modelo, com o parâmetro `TemplateName` passado para o método `UpdateTemplateCommand` da classe de cliente `SES`. Para chamar o método `UpdateTemplateCommand`, invoque um objeto de serviço do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*TEMPLATE\$1NAME*Substitua pelo nome do modelo e *HTML\$1PART* pelo conteúdo do e-mail marcado em 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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O Amazon SES retorna os detalhes do modelo.
```
node ses_updatetemplate.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js).
## Exclusão de um modelo de e-mail
Neste exemplo, use um módulo do Node.js para criar um modelo de e-mail a ser usado com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_deletetemplate.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para passar o parâmetro `TemplateName` obrigatório para o método `DeleteTemplateCommand` da classe de cliente `SES`. Para chamar o método `DeleteTemplateCommand`, invoque um objeto de serviço do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*TEMPLATE\$1NAME*Substitua pelo nome do modelo a ser excluído.
```
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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O Amazon SES retorna os detalhes do modelo.
```
node ses_deletetemplate.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js).
# Envio de e-mail usando o Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Este exemplo de código Node.js mostra:**
+ Envie uma e-mail de texto ou HTML.
+ Envie e-mails usando um modelo de e-mail.
+ Envie e-mails em massa usando um modelo de e-mail.
A API do Amazon SES fornece duas maneiras diferentes para você enviar um e-mail, dependendo de quanto controle você deseja ter sobre a composição da mensagem de e-mail: formatada e bruta. Para obter detalhes, consulte [Enviar e-mail formatado usando a API do Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html) e [Enviar e-mail bruto usando a API do Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).
## O cenário
Neste exemplo, você usa uma série de módulos do Node.js para enviar e-mails de várias maneiras. Os módulos Node.js usam o SDK JavaScript para criar e usar modelos de e-mail usando esses métodos da classe `SES` cliente:
+ [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/)
## Tarefas de pré-requisito
Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Configure o ambiente do projeto para executar esses TypeScript exemplos de Node e instale os módulos necessários AWS SDK para JavaScript e de terceiros. Siga as instruções em [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Crie um arquivo de configurações compartilhado com as credenciais de usuário. Para obter mais informações sobre como fornecer um arquivo de credenciais compartilhado, consulte [Arquivos de configuração e credenciais compartilhados](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no Guia de referência de *ferramentas AWS SDKs e ferramentas*.
**Importante**
Esses exemplos demonstram como atender ao import/export cliente objetos e comandar usando ECMAScript6 (ES6).
Isso requer o Node.js versão 13.x ou superior. Para baixar e instalar a versão mais recente do Node.js, consulte [Downloads do Node.js](https://nodejs.org/en/download).
Se você preferir usar a sintaxe do CommonJS, consulte [Sintaxe ES6/CommonJS de JavaScript](sdk-example-javascript-syntax.md).
## Requisitos de envio de mensagens de e-mail
O Amazon SES compõe uma mensagem de e-mail e imediatamente a coloca na fila para envio. Para enviar e-mail usando o método `SendEmailCommand`, sua mensagem deve atender aos seguintes requisitos:
+ Você deve enviar a mensagem a partir de um domínio ou endereço de e-mail verificado. Se você tentar enviar um e-mail usando um domínio ou endereço não verificados, a operação resultará no erro `"Email address not verified"`.
+ Se sua conta ainda estiver na sandbox do Amazon SES, você só poderá enviar para endereços ou domínios verificados ou para endereços de e-mail associados simulador de caixa postal do Amazon SES. Para obter mais informações, consulte [Verificar endereços de e-mail e domínios](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) no Guia do desenvolvedor do Amazon Simple Email Service.
+ O tamanho total da mensagem, incluindo anexos, deve ser menor que 10 MB.
+ A mensagem deve incluir pelo menos um endereço de e-mail de destinatário. O endereço do destinatário pode ser um endereço Para:, um endereço CC: ou um endereço CCO:. Se o endereço de e-mail do destinatário for inválido (ou seja, não estiver no formato `UserName@[SubDomain.]Domain.TopLevelDomain`), a mensagem inteira será rejeitada, mesmo se a mensagem contiver outros destinatários válidos.
+ A mensagem não pode incluir mais de 50 destinatários nos campos Para:, CC: e CCO:. Se você precisar enviar uma mensagem de e-mail para um público maior, pode dividir a lista de destinatários em grupos de 50 ou menos e chamar o método `sendEmail` várias vezes para enviar a mensagem para cada grupo.
## Enviar um e-mail
Neste exemplo, use um módulo do Node.js para enviar e-mail com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_sendemail.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para transmitir os valores de parâmetro que definem o e-mail a ser enviado, incluindo endereços do remetente e do destinatário, assunto e corpo do e-mail em texto sem formatação e formato HTML, para o método `SendEmailCommand` da classe de cliente `SES`. Para chamar o método `SendEmailCommand`, invoque um objeto de serviço do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*toAddress*Substitua pelo endereço para o qual enviar o e-mail e *fromAddress* pelo endereço de e-mail do qual enviar o 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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O e-mail é colocado na fila para ser enviado pelo Amazon SES.
```
node ses_sendemail.js
```
Esse código de exemplo pode ser [encontrado aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js).
## Enviar um e-mail usando um modelo
Neste exemplo, use um módulo do Node.js para enviar e-mail com o Amazon SES. Crie um módulo do Node.js com o nome de arquivo `ses_sendtemplatedemail.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para transmitir os valores de parâmetro que definem o e-mail a ser enviado, incluindo endereços do remetente e do destinatário, assunto, corpo do e-mail em texto sem formatação e formato HTML, para o método `SendTemplatedEmailCommand` da classe de cliente `SES`. Para chamar o método `SendTemplatedEmailCommand`, invoque um objeto de serviço de cliente do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*REGION*Substitua pela sua AWS região, *USER* pelo nome e endereço de e-mail para o qual enviar o e-mail, *VERIFIED\$1EMAIL* pelo endereço de e-mail do qual enviar o e-mail e *TEMPLATE\$1NAME* pelo nome do modelo.
```
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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O e-mail é colocado na fila para ser enviado pelo Amazon SES.
```
node ses_sendtemplatedemail.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js).
## Enviar um e-mail em massa usando um modelo
Neste exemplo, use um módulo do Node.js para enviar e-mail com o Amazon SES.
Crie um diretório `libs` e um módulo do Node.js com o nome de arquivo `sesClient.js`. Copie e cole o código abaixo nele, o que cria o objeto de cliente do Amazon SES. *REGION*Substitua pela sua AWS região.
```
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 };
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Crie um módulo do Node.js com o nome de arquivo `ses_sendbulktemplatedemail.js`. Configure o SDK conforme mostrado anteriormente, incluindo a instalação dos clientes e pacotes necessários.
Crie um objeto para transmitir os valores de parâmetro que definem o e-mail a ser enviado, incluindo endereços do remetente e do destinatário, assunto e corpo do e-mail em texto sem formatação e formato HTML, para o método `SendBulkTemplatedEmailCommand` da classe de cliente `SES`. Para chamar o método `SendBulkTemplatedEmailCommand`, invoque um objeto de serviço do Amazon SES, passando os parâmetros.
**nota**
Este exemplo importa e usa os clientes do pacote AWS Service V3 necessários, os comandos V3 e usa o `send` método em um async/await padrão. Em vez disso, você pode criar esse exemplo usando comandos da V2 fazendo algumas pequenas alterações. Para obter detalhes, consulte [Usar comandos da v3](migrating.md#using_v3_commands).
**nota**
*USERS*Substitua pelos nomes e endereços de e-mail para os quais enviar o e-mail, *VERIFIED\$1EMAIL\$11* pelo endereço de e-mail do qual enviar o e-mail e *TEMPLATE\$1NAME* pelo nome do modelo.
```
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;
}
};
```
Para executar o exemplo, digite o seguinte no prompt de comando. O e-mail é colocado na fila para ser enviado pelo Amazon SES.
```
node ses_sendbulktemplatedemail.js
```
Esse código de exemplo pode ser encontrado [aqui em GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js).