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