La [Guía de referencia de la API de AWS SDK for JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) describe en detalle todas las operaciones de la API para la versión 3 (V3) de AWS SDK for JavaScript.
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Ejemplos de Amazon Simple Email Service
Amazon Simple Email Service (Amazon SES) es un servicio de envío de correos electrónicos con base en la nube y diseñado para ayudar a los responsables de marketing digital y a los desarrolladores de aplicaciones a enviar correos electrónicos de marketing, notificaciones y transacciones. Se trata de un servicio de confianza y rentable para negocios de todos los tamaños que usan el correo electrónico para mantenerse en contacto con sus clientes.
![\[Relación entre JavaScript los entornos, el SDK y Amazon SES\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)
La JavaScript API de Amazon SES se expone a través de la clase de `SES` cliente. Para obtener más información acerca de cómo usar la clase de cliente de Amazon SES, consulte [Clase: SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/) en la referencia de la API.
**Topics**
+ [Administración de identidades en Amazon SES](ses-examples-managing-identities.md)
+ [Trabajar con plantillas de correo electrónico en Amazon SES](ses-examples-creating-template.md)
+ [Envío de correo electrónico con Amazon SES](ses-examples-sending-email.md)
# Administración de identidades en Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Este ejemplo de código de Node.js muestra:**
+ Cómo verificar direcciones de correo electrónico y dominios que se usan con Amazon SES.
+ Cómo asignar una política AWS Identity and Access Management (IAM) a tus identidades de Amazon SES.
+ Cómo enumerar todas las identidades de Amazon SES de tu AWS cuenta.
+ Cómo eliminar identidades que se usan con Amazon SES.
En Amazon SES, una *identidad* es una dirección de correo electrónico o dominio que se utiliza para enviar correos electrónicos. Amazon SES requiere que verifique su dirección de correo electrónico o dominio para confirmar que es de su propiedad e impedir que otras personas los utilicen.
Para obtener información detallada acerca de cómo verificar direcciones de correo electrónico y dominios en Amazon SES, consulte [Verificación de direcciones de correo electrónico y dominios en Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) en la Guía para desarrolladores de Amazon Simple Email Service. Para obtener información acerca de cómo enviar autorizaciones en Amazon SES, consulte [Información general sobre el envío de autorizaciones en Amazon SES](Amazon Simple Email Service Developer Guidesending-authorization-overview.html).
## El escenario
En este ejemplo, va a utilizar una serie de módulos de Node.js para verificar y administrar identidades de Amazon SES. Los módulos de Node.js utilizan el SDK JavaScript para verificar las direcciones de correo electrónico y los dominios mediante los siguientes métodos de la clase `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/)
## Tareas previas necesarias
Para configurar y ejecutar este ejemplo, primero debe completar estas tareas:
+ Configure el entorno del proyecto para ejecutar estos TypeScript ejemplos de nodos e instale los módulos necesarios AWS SDK para JavaScript y de terceros. Siga las instrucciones de [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Cree un archivo de configuraciones compartidas con sus credenciales de usuario. Para obtener más información sobre cómo proporcionar un archivo de credenciales compartido, consulte [Archivos de configuración y credenciales compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.
**importante**
En estos ejemplos se muestra cómo hacer un import/export cliente para ejecutar comandos y objetos de servicio mediante ECMAScript6 (ES6).
Requiere la versión 13.x o superior de Node.js. Para descargar e instalar la versión más reciente de Node.js, consulte [Descargas de Node.js](https://nodejs.org/en/download).
Si prefiere utilizar la sintaxis CommonJS, consulte [Sintaxis ES6/commonJS de JavaScript](sdk-example-javascript-syntax.md).
## Mostrar sus identidades
En este ejemplo, utilice un módulo de Node.js para obtener una lista de direcciones de correo electrónico y dominios que se usarán con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_listidentities.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir el parámetro `IdentityType` y otros parámetros para el método `ListIdentitiesCommand` de la clase de cliente de Amazon SES. Para llamar al método `ListIdentitiesCommand`, invoque un objeto de servicio de Amazon SES transfiriendo el objeto de los parámetros.
Los `data` devueltos contienen una matriz de identidades de dominio tal y como especifica el parámetro `IdentityType`.
**nota**
*IdentityType*Sustitúyalo por el tipo de identidad, que puede ser 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;
}
};
```
Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.
```
node ses_listidentities.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js).
## Verificación de una identidad de dirección de correo electrónico
En este ejemplo, utilice un módulo de Node.js para comprobar los remitentes de direcciones de correo electrónico que se usarán con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_verifyemailidentity.js`. Configure el SDK como se mostró anteriormente, incluida la descarga de los clientes y paquetes necesarios.
Cree un objeto para transferir el parámetro `EmailAddress` para el método `VerifyEmailIdentityCommand` de la clase de cliente de Amazon SES. Para llamar al método `VerifyEmailIdentityCommand`, invoque un objeto de servicio de cliente de Amazon SES transfiriendo los parámetros.
**nota**
*EMAIL\$1ADDRESS*Sustitúyalo por la dirección de correo electrónico, 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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. El dominio se añade a Amazon SES para que se compruebe.
```
node ses_verifyemailidentity.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js).
## Verificación de una identidad de dominio
En este ejemplo, utilice un módulo de Node.js para comprobar los dominios de correo electrónico que se usarán con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_verifydomainidentity.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir el parámetro `Domain` para el método `VerifyDomainIdentityCommand` de la clase de cliente de Amazon SES. Para llamar al método `VerifyDomainIdentityCommand`, invoque un objeto de servicio de Amazon SES transfiriendo el objeto de los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*DOMAIN\$1NAME*Sustitúyalo por el nombre de 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;
}
};
```
Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. El dominio se añade a Amazon SES para que se compruebe.
```
node ses_verifydomainidentity.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js).
## Eliminación de identidades
En este ejemplo, utilice un módulo de Node.js para eliminar direcciones de correo electrónico o dominios que se usan con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_deleteidentity.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir el parámetro `Identity` para el método `DeleteIdentityCommand` de la clase de cliente de Amazon SES. Para llamar al método `DeleteIdentityCommand`, cree una `request` para invocar un objeto de servicio de cliente de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*IDENTITY\$1EMAIL*Sustitúyalo por el correo electrónico de la identidad que se va a eliminar.
```
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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.
```
node ses_deleteidentity.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js).
# Trabajar con plantillas de correo electrónico en Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Este ejemplo de código de Node.js muestra:**
+ Cómo obtener una lista de todas sus plantillas de correo electrónico.
+ Cómo recuperar y actualizar plantillas de correo electrónico.
+ Cómo crear y eliminar plantillas de correo electrónico.
Con Amazon SES, puede enviar mensajes de correo electrónico personalizados mediante plantillas de correo electrónico. Para obtener más información sobre cómo crear y usar plantillas de correo electrónico en Amazon SES, consulte [Envío de correos electrónicos personalizados utilizando la API de Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html) en la Guía para desarrolladores de Amazon Simple Email Service.
## El escenario
En este ejemplo, va a utilizar una serie de módulos de Node.js para trabajar con plantillas de correo electrónico. Los módulos de Node.js utilizan el SDK JavaScript para crear y utilizar plantillas de correo electrónico mediante los siguientes métodos de la clase `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/)
## Tareas previas necesarias
Para configurar y ejecutar este ejemplo, primero debe completar estas tareas:
+ Configure el entorno del proyecto para ejecutar estos TypeScript ejemplos de Node e instale los módulos necesarios AWS SDK para JavaScript y de terceros. Siga las instrucciones de [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Cree un archivo de configuraciones compartidas con sus credenciales de usuario. Para obtener más información sobre cómo proporcionar un archivo de credenciales compartido, consulte [Archivos de configuración y credenciales compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.
**importante**
En estos ejemplos se muestra cómo hacer un import/export cliente para ejecutar comandos y objetos de servicio mediante ECMAScript6 (ES6).
Requiere la versión 13.x o superior de Node.js. Para descargar e instalar la versión más reciente de Node.js, consulte [Descargas de Node.js](https://nodejs.org/en/download).
Si prefiere utilizar la sintaxis CommonJS, consulte [Sintaxis ES6/commonJS de JavaScript](sdk-example-javascript-syntax.md).
## Obtención de una lista de plantillas de correo electrónico
En este ejemplo, utilice un módulo de Node.js para crear una plantilla de correo electrónico que se usará con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_listtemplates.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir los parámetros para el método `ListTemplatesCommand` de la clase de cliente de Amazon SES. Para llamar al método `ListTemplatesCommand`, invoque un objeto de servicio de cliente de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de 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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. Amazon SES devuelve la lista de plantillas.
```
node ses_listtemplates.js
```
Este código de ejemplo se puede encontrar [aquí en. GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js)
## Obtención de una plantilla de correo electrónico
En este ejemplo, utilice un módulo de Node.js para obtener una plantilla de correo electrónico que se usará con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_gettemplate.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir el parámetro `TemplateName` para el método `GetTemplateCommand` de la clase de cliente de Amazon SES. Para llamar al método `GetTemplateCommand`, invoque un objeto de servicio de cliente de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*TEMPLATE\$1NAME*Sustitúyalo por el nombre de la plantilla que se va a devolver.
```
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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. Amazon SES devuelve los detalles de la plantilla.
```
node ses_gettemplate.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js).
## Creación de una plantilla de correo electrónico
En este ejemplo, utilice un módulo de Node.js para crear una plantilla de correo electrónico que se usará con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_createtemplate.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir los parámetros para el método `CreateTemplateCommand` de la clase de cliente de Amazon SES, incluidos `TemplateName`, `HtmlPart`, `SubjectPart` y `TextPart`. Para llamar al método `CreateTemplateCommand`, invoque un objeto de servicio de cliente de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*TEMPLATE\$1NAME*Sustitúyala por un nombre para la nueva plantilla, *HtmlPart* por el contenido del correo electrónico etiquetado en HTML y *SubjectPart* por el asunto del correo electrónico.
```
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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. La plantilla se añade a Amazon SES.
```
node ses_createtemplate.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js).
## Actualización de una plantilla de correo electrónico
En este ejemplo, utilice un módulo de Node.js para crear una plantilla de correo electrónico que se usará con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_updatetemplate.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir los valores de parámetro `Template` que desea actualizar en la plantilla, con el parámetro `TemplateName` obligatorio transferido al método `UpdateTemplateCommand` de la clase de cliente de Amazon SES. Para llamar al método `UpdateTemplateCommand`, invoque un objeto de servicio de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*TEMPLATE\$1NAME*Sustitúyalo por el nombre de la plantilla y *HTML\$1PART* por el contenido del correo electrónico etiquetado en 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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. Amazon SES devuelve los detalles de la plantilla.
```
node ses_updatetemplate.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js).
## Eliminación de una plantilla de correo electrónico
En este ejemplo, utilice un módulo de Node.js para crear una plantilla de correo electrónico que se usará con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_deletetemplate.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir el parámetro `TemplateName` obligatorio al método `DeleteTemplateCommand` de la clase de cliente de Amazon SES. Para llamar al método `DeleteTemplateCommand`, invoque un objeto de servicio de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*TEMPLATE\$1NAME*Sustitúyalo por el nombre de la plantilla que se va a eliminar.
```
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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. Amazon SES devuelve los detalles de la plantilla.
```
node ses_deletetemplate.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js).
# Envío de correo electrónico con Amazon SES
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Este ejemplo de código de Node.js muestra:**
+ Enviar un correo electrónico en HTML o de texto.
+ Enviar mensajes de correo electrónico basados en una plantilla de correo electrónico.
+ Enviar mensajes de correo electrónico masivos basados en una plantilla de correo electrónico.
La API de Amazon SES ofrece dos formas distintas de enviar los correos electrónicos, según el nivel de control que desee tener sobre la composición del mensaje de correo electrónico: con o sin formato. Para obtener información detallada, consulte [Envío de correo electrónico con formato utilizando la API de Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html) y [Envío de correo electrónico sin formato usando la API de Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).
## El escenario
En este ejemplo, va a utilizar una serie de módulos de Node.js para enviar correos electrónicos de distintas maneras. Los módulos de Node.js utilizan el SDK JavaScript para crear y utilizar plantillas de correo electrónico mediante los siguientes métodos de la clase `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/)
## Tareas previas necesarias
Para configurar y ejecutar este ejemplo, primero debe completar estas tareas:
+ Configure el entorno del proyecto para ejecutar estos TypeScript ejemplos de Node e instale los módulos necesarios AWS SDK para JavaScript y de terceros. Siga las instrucciones de [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Cree un archivo de configuraciones compartidas con sus credenciales de usuario. Para obtener más información sobre cómo proporcionar un archivo de credenciales compartido, consulte [Archivos de configuración y credenciales compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.
**importante**
En estos ejemplos se muestra cómo hacer un import/export cliente para ejecutar comandos y objetos de servicio mediante ECMAScript6 (ES6).
Requiere la versión 13.x o superior de Node.js. Para descargar e instalar la versión más reciente de Node.js, consulte [Descargas de Node.js](https://nodejs.org/en/download).
Si prefiere utilizar la sintaxis CommonJS, consulte [Sintaxis ES6/commonJS de JavaScript](sdk-example-javascript-syntax.md).
## Requisitos para enviar un mensaje de correo electrónico
Amazon SES crea un mensaje de correo electrónico e inmediatamente lo pone en la cola para su envío. Para enviar correo electrónico por medio del método `SendEmailCommand`, el mensaje debe cumplir los requisitos siguientes:
+ Tiene que enviar el mensaje desde un dominio o una dirección de correo electrónico que se haya verificado. Si intenta enviar un correo electrónico mediante una dirección o un dominio que no se haya verificado, la operación generará un error `"Email address not verified"`.
+ Si su cuenta está todavía en el entorno de pruebas de Amazon SES, solo podrá realizar envíos a direcciones o dominios verificados, o a direcciones de correo electrónico que estén asociadas al simulador de bandeja de correo de Amazon SES. Para obtener más información, consulte [Verificación de direcciones de correo electrónico y dominios](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) en la Guía para desarrolladores de Amazon Simple Email Service.
+ El tamaño total del mensaje, los archivos adjuntos incluidos, debe ser inferior a 10 MB.
+ El mensaje tiene que incluir al menos una dirección de correo electrónico de destinatario. La dirección del destinatario puede ser una dirección A:, una dirección CC: o una dirección CCO. Si la dirección de correo electrónico de un destinatario no es válida (es decir, no sigue el formato `UserName@[SubDomain.]Domain.TopLevelDomain`), se rechazará todo el mensaje, aunque este contenga otros destinatarios que sí son válidos.
+ El mensaje no puede incluir más de 50 destinatarios entre los campos A:, CC: y CCO: en total. Si necesita enviar un mensaje de correo electrónico a más destinatarios, puede dividir la lista de destinatarios en grupos de 50 o menos y luego llamar al método `sendEmail` varias veces para enviar el mensaje a cada grupo.
## Envío de un correo electrónico
En este ejemplo, utilice un módulo de Node.js para enviar un correo electrónico con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_sendemail.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir los valores de parámetros que definen el correo electrónico que se va a enviar, como las direcciones del remitente y el receptor, y el cuerpo del correo electrónico en formatos de texto y HTML, al método `SendEmailCommand` de la clase de cliente de Amazon SES. Para llamar al método `SendEmailCommand`, invoque un objeto de servicio de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*toAddress*Sustitúyalo por la dirección a la que se envía el correo electrónico y *fromAddress* por la dirección desde la que se envía el correo electrónico.
```
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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. El correo electrónico se pone en cola para que Amazon SES lo envíe.
```
node ses_sendemail.js
```
Este código de ejemplo se puede [encontrar aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js).
## Envío de un correo electrónico mediante una plantilla
En este ejemplo, utilice un módulo de Node.js para enviar un correo electrónico con Amazon SES. Cree un módulo de Node.js con el nombre de archivo `ses_sendtemplatedemail.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir los valores de parámetros que definen el correo electrónico que se va a enviar, como las direcciones del remitente y el receptor, el cuerpo del correo electrónico en formatos de texto y HTML, al método `SendTemplatedEmailCommand` de la clase de cliente de Amazon SES. Para llamar al método `SendTemplatedEmailCommand`, invoque un objeto de servicio de cliente de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la versión 3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*REGION*Sustitúyalo por tu AWS región, *USER* por el nombre y la dirección de correo electrónico a los que quieres enviar el correo electrónico, *VERIFIED\$1EMAIL* por la dirección desde la que se envía el correo electrónico y *TEMPLATE\$1NAME* por el nombre de la plantilla.
```
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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. El correo electrónico se pone en cola para que Amazon SES lo envíe.
```
node ses_sendtemplatedemail.js
```
Puedes encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js).
## Envío masivo de correos electrónicos mediante una plantilla
En este ejemplo, utilice un módulo de Node.js para enviar un correo electrónico con Amazon SES.
Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `sesClient.js`. Copie y pegue el siguiente código en él para crear el objeto de cliente de Amazon SES. *REGION*Reemplácelo por su AWS región.
```
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 };
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).
Cree un módulo de Node.js con el nombre de archivo `ses_sendbulktemplatedemail.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.
Cree un objeto para transferir los valores de parámetros que definen el correo electrónico que se va a enviar, como las direcciones del remitente y el receptor, y el cuerpo del correo electrónico en formatos de texto y HTML, al método `SendBulkTemplatedEmailCommand` de la clase de cliente de Amazon SES. Para llamar al método `SendBulkTemplatedEmailCommand`, invoque un objeto de servicio de Amazon SES transfiriendo los parámetros.
**nota**
En este ejemplo se importan y se utilizan los paquetes de clientes y comandos de la V3 necesarios del AWS Servicio V3, y se utiliza el `send` método siguiendo un async/await patrón. En su lugar, puede crear este ejemplo con los comandos de la V2 realizando algunos cambios menores. Para obtener más información, consulte [Uso de comandos de v3](migrating.md#using_v3_commands).
**nota**
*USERS*Sustitúyalo por los nombres y las direcciones de correo electrónico a las que se va a enviar el correo electrónico, *VERIFIED\$1EMAIL\$11* por la dirección de correo electrónico desde la que se envía el correo electrónico y *TEMPLATE\$1NAME* por el nombre de la plantilla.
```
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 ejecutar el ejemplo, escriba lo siguiente en la línea de comandos. El correo electrónico se pone en cola para que Amazon SES lo envíe.
```
node ses_sendbulktemplatedemail.js
```
Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js).