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.

# SDK para ejemplos JavaScript de código
<a name="sdk-code-samples"></a>

Los temas de esta sección contienen ejemplos de cómo utilizar AWS SDK para JavaScript los APIs distintos servicios para llevar a cabo tareas comunes.

Encuentre el código fuente de estos ejemplos y otros en el [repositorio de ejemplos de AWS código en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples). Para proponer un nuevo ejemplo de código para que el equipo de AWS documentación considere producirlo, crea una solicitud. El equipo está buscando crear ejemplos de código que abarquen situaciones y casos de uso más amplios, en comparación con fragmentos de código sencillos que tratan solo llamadas a la API individuales. Para obtener instrucciones, consulte la sección sobre *creación de código* en las [directrices de contribución sobre GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md).

**importante**  
En estos ejemplos se utiliza la sintaxis de ECMAScript6 importación y exportación.   
Esto requiere la versión 14.17 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 las pautas de conversión [Sintaxis ES6/commonJS de JavaScript](sdk-example-javascript-syntax.md).

**Topics**
+ [Sintaxis ES6/commonJS de JavaScript](sdk-example-javascript-syntax.md)
+ [Ejemplos de AWS Elemental MediaConvert](emc-examples.md)
+ [Ejemplos de Lambda](lambda-examples.md)
+ [Ejemplos de Amazon Lex](lex-examples.md)
+ [Ejemplos de Amazon Polly](polly-examples.md)
+ [Ejemplos de Amazon Redshift](redshift-examples.md)
+ [Ejemplos de Amazon Simple Email Service](ses-examples.md)
+ [Ejemplos de Amazon Simple Notification Service](sns-examples.md)
+ [Ejemplos de Amazon Transcribe](Transcribe-examples.md)
+ [Configuración de Node.js en una instancia de Amazon EC2](setting-up-node-on-ec2-instance.md)
+ [Invocación de Lambda con API Gateway](api-gateway-invoking-lambda-example.md)
+ [Crear eventos programados para ejecutar AWS Lambda funciones](scheduled-events-invoking-lambda-example.md)
+ [Creación de un chatbot de Amazon Lex](lex-bot-example.md)

# Sintaxis ES6/commonJS de JavaScript
<a name="sdk-example-javascript-syntax"></a>

Los ejemplos de código de AWS SDK for JavaScript están escritos en ECMAScript 6 (ES6). ES6 incorpora una nueva sintaxis y nuevas funciones para que su código sea más moderno y legible, y haga más cosas. 

ES6 requiere que utilice 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) No obstante, si lo prefiere, puede convertir cualquiera de nuestros ejemplos a la sintaxis CommonJS. Para ello, siga las instrucciones que se indican a continuación:
+ Elimine module de package.json del entorno de su proyecto.
+ Convierta todas las declaraciones `import` de ES6 en declaraciones `require` de CommonJS. Por ejemplo, convierta:

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

  A su equivalente en CommonJS:

  ```
  const { CreateBucketCommand } = require("@aws-sdk/client-s3");
  const { s3 } = require("./libs/s3Client.js");
  ```
+ Convierta todas las declaraciones `export` de ES6 en declaraciones `module.exports` de CommonJS. Por ejemplo, convierta:

  ```
  export {s3}
  ```

  A su equivalente en CommonJS:

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

El siguiente ejemplo muestra el ejemplo de código para crear un bucket de Amazon S3 tanto en ES6 como en CommonJS.

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

libs/s3Client.js

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

s3\$1createbucket.js

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

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

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

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

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

libs/s3Client.js

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

s3\$1createbucket.js

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

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

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

------

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

AWS Elemental MediaConvert es un servicio de transcodificación de vídeo basado en archivos con características apropiadas para los medios de difusión. Puede utilizarlo para crear recursos para su difusión y para la entrega de vídeo bajo demanda (VOD) a través de Internet. Para obtener más información, consulte la [Guía del usuario de *AWS Elemental MediaConvert*](https://docs.aws.amazon.com/mediaconvert/latest/ug/).

La API de JavaScript para MediaConvert se expone a través de la clase de cliente de `MediaConvert`. Para obtener más información, consulte [Clase: MediaConvert](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/) en la referencia de la API.

**Topics**
+ [Creación y administración de trabajos de transcodificación en MediaConvert](emc-examples-jobs.md)
+ [Uso de plantillas de trabajo en MediaConvert](emc-examples-templates.md)

# Creación y administración de trabajos de transcodificación en MediaConvert
<a name="emc-examples-jobs"></a>

![\[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 crear trabajos de transcodificación en MediaConvert.
+ Cómo cancelar un trabajo de transcodificación.
+ Cómo recuperar el JSON de un trabajo de transcodificación finalizado.
+ Cómo recuperar una matriz JSON para un máximo de 20 de los últimos trabajos creados.

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

En este ejemplo, se utiliza un módulo de Node.js para llamar a MediaConvert para crear y administrar trabajos de transcodificación. El código usa el SDK de JavaScript para realizar esta operación mediante los métodos de la clase de cliente de MediaConvert siguientes:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CancelJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CancelJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/GetJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/GetJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobsCommand/)

## Tareas previas necesarias
<a name="emc-examples-jobs-prerequisites"></a>

Para configurar y ejecutar este ejemplo, primero debe completar las tareas siguientes:
+ Configure el entorno del proyecto para ejecutar estos ejemplos de Node TypeScript e instale los módulos de AWS SDK for JavaScript y de terceros necesarios. Siga las instrucciones en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md).
+ Cree un archivo de configuraciones compartidas con sus credenciales de usuario. Para obtener más información sobre 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 las herramientas y los SDK de AWS*.
+ Crear y configurar buckets de Amazon S3 que proporcionan almacenamiento para archivos de entrada de trabajo y archivos de salida. Para obtener información detallada, consulte [Crear almacenamiento para archivos](https://docs.aws.amazon.com/mediaconvert/latest/ug/set-up-file-locations.html) en la *Guía del usuario de AWS Elemental MediaConvert*.
+ Cargar el vídeo de entrada en el bucket de Amazon S3 que ha aprovisionado para el almacenamiento de entrada. Para obtener una lista de los códecs y contenedores compatibles con la entrada de vídeo, consulte [Códecs y contenedores de entrada compatibles](https://docs.aws.amazon.com/mediaconvert/latest/ug/reference-codecs-containers-input.html) en la *Guía del usuario de AWS Elemental MediaConvert*.
+ Cree un rol de IAM que conceda a MediaConvert acceso a los archivos de entrada y a los buckets de Amazon S3 donde se almacenan los archivos de salida. Para obtener más información, consulte [Configurar los permisos de IAM](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) en la *Guía del usuario de AWS Elemental MediaConvert*.

**importante**  
Este ejemplo usa 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).  
No obstante, si prefiere utilizar la sintaxis CommonJS, consulte [Sintaxis ES6/commonJS de JavaScript](sdk-example-javascript-syntax.md).

## Definición de un trabajo de transcodificación sencillo
<a name="emc-examples-jobs-spec"></a>

Cree un módulo de Node.js con el nombre de archivo `emc_createjob.js`. Asegúrese de configurar el SDK como se ha mostrado anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree el JSON que define los parámetros del trabajo de transcodificación.

Estos parámetros son bastante detallados. Puede utilizar la [consola de AWS Elemental MediaConvert](https://console.aws.amazon.com/mediaconvert/) para generar los parámetros JSON del trabajo seleccionando la configuración del trabajo en la consola y, a continuación, seleccionando **Mostrar JSON del trabajo** en la parte inferior de la sección **Trabajo**. En este ejemplo, se muestra el JSON de un trabajo sencillo.

**nota**  
Sustituya *JOB\$1QUEUE\$1ARN* por la cola de trabajos de MediaConvert, *IAM\$1ROLE\$1ARN* por el Nombre de recurso de Amazon (ARN) del rol de IAM, *OUTPUT\$1BUCKET\$1NAME* por el nombre del bucket de destino (por ejemplo, “s3://OUTPUT\$1BUCKET\$1NAME/”) y *INPUT\$1BUCKET\$1AND\$1FILENAME* por el bucket de entrada y el nombre de archivo (por ejemplo, “s3://INPUT\$1BUCKET/FILE\$1NAME”).

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

## Creación de un trabajo de transcodificación
<a name="emc-examples-jobs-create"></a>

Después de crear el JSON de los parámetros del trabajo, llame al método `run` asincrónico para que invoque un objeto de servicio de cliente de `MediaConvert` mediante la transferencia de los parámetros. El ID del trabajo creado se devuelve en la respuesta `data`.

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node emc_createjob.js 
```

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_createjob.js).

## Cancelación de un trabajo de transcodificación
<a name="emc-examples-jobs-cancel"></a>

Cree un módulo de Node.js con el nombre de archivo `emc_canceljob.js`. Asegúrese de configurar el SDK como se ha mostrado anteriormente, incluida la descarga de los clientes y paquetes necesarios. Cree el JSON que incluye el ID del trabajo que desea cancelar. Luego llame al método `CancelJobCommand` creando una promesa para invocar un objeto de servicio de cliente de `MediaConvert` mediante la transferencia de los parámetros. Gestione la respuesta en la devolución de llamada de la promesa.

**nota**  
Sustituya *JOB\$1ID* por el ID del trabajo que desea cancelar.

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node ec2_canceljob.js 
```

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_canceljob.js).

## Listado de los trabajos de transcodificación recientes
<a name="emc-examples-jobs-listing"></a>

Cree un módulo de Node.js con el nombre de archivo `emc_listjobs.js`. Asegúrese de configurar el SDK como se ha mostrado anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Cree el JSON de los parámetros, incluidos los valores que especificarán si se debe ordenar la lista en orden `ASCENDING` o `DESCENDING`, el Nombre de recurso de Amazon (ARN) de la cola de trabajos que se va comprobar y el estado de los trabajos que se deben incluir. Luego llame al método `ListJobsCommand` creando una promesa para invocar un objeto de servicio de cliente de `MediaConvert` mediante la transferencia de los parámetros. 

**nota**  
Sustituya *QUEUE\$1ARN* por el Nombre de recurso de Amazon (ARN) de la cola de trabajos que va a comprobar y *STATUS* por el estado de la cola.

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node emc_listjobs.js 
```

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_listjobs.js).

# Uso de plantillas de trabajo en MediaConvert
<a name="emc-examples-templates"></a>

![\[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 crear plantillas de trabajos de AWS Elemental MediaConvert.
+ Cómo utilizar una plantilla de trabajo para crear un trabajo de transcodificación.
+ Cómo generar una lista de todas sus plantillas de trabajo.
+ Cómo eliminar plantillas de trabajos.

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

El JSON necesario para crear un trabajo de transcodificación en MediaConvert es detallado, ya que contiene un gran número de opciones de configuración. Puede simplificar en gran medida la creación del trabajo guardando la configuración de funcionalidad comprobada en una plantilla de trabajo que pueda utilizar para crear trabajos posteriores. En este ejemplo, se utiliza un módulo de Node.js para llamar a MediaConvert para crear, utilizar y administrar plantillas de trabajos. El código usa el SDK de JavaScript para realizar esta operación mediante los métodos de la clase de cliente de MediaConvert siguientes:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/DeleteJobTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/DeleteJobTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobTemplatesCommand/)

## Tareas previas necesarias
<a name="emc-example-templates-prerequisites"></a>

Para configurar y ejecutar este ejemplo, primero debe completar las tareas siguientes:
+ Configure el entorno del proyecto para ejecutar estos ejemplos de Node TypeScript e instale los módulos de AWS SDK for JavaScript y de terceros necesarios. Siga las instrucciones en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md).
+ Cree un archivo de configuraciones compartidas con sus credenciales de usuario. Para obtener más información sobre 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 las herramientas y los SDK de AWS*.
+ Cree un rol de IAM que conceda a MediaConvert acceso a los archivos de entrada y a los buckets de Amazon S3 donde se almacenan los archivos de salida. Para obtener más información, consulte [Configurar los permisos de IAM](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) en la *Guía del usuario de AWS Elemental MediaConvert*.

**importante**  
En estos ejemplos se utiliza 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).  
No obstante, si prefiere utilizar la sintaxis CommonJS, consulte [Sintaxis ES6/commonJS de JavaScript](sdk-example-javascript-syntax.md).

## Creación de una plantilla de trabajo
<a name="emc-examples-templates-create"></a>

Cree un módulo de Node.js con el nombre de archivo `emc_create_jobtemplate.js`. Asegúrese de configurar el SDK como se ha mostrado anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Especifique los parámetros JSON para la creación de plantillas. Puede utilizar la mayoría de los parámetros JSON de un trabajo anterior realizado correctamente para especificar los valores de `Settings` en la plantilla. En este ejemplo se utiliza la configuración de trabajo de [Creación y administración de trabajos de transcodificación en MediaConvert](emc-examples-jobs.md).

Llame al método `CreateJobTemplateCommand` creando una promesa para invocar un objeto de servicio de cliente de `MediaConvert` mediante la transferencia de los parámetros.

**nota**  
Sustituya *JOB\$1QUEUE\$1ARN* por el nombre de recurso de Amazon (ARN) de la cola de trabajos que desea comprobar y *BUCKET\$1NAME* por el nombre del bucket de Amazon S3 de destino (por ejemplo, “s3://BUCKET\$1NAME/”). 

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node emc_create_jobtemplate.js 
```

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_create_jobtemplate.js).

## Creación de un trabajo de transcodificación a partir de una plantilla de trabajo
<a name="emc-examples-templates-createjob"></a>

Cree un módulo de Node.js con el nombre de archivo `emc_template_createjob.js`. Asegúrese de configurar el SDK como se ha mostrado anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Cree los parámetros JSON de creación del trabajo, como el nombre de la plantilla de trabajo que desea utilizar y el método `Settings` que se utilizará, que son específicos del trabajo que está creando. Luego llame al método `CreateJobsCommand` creando una promesa para invocar un objeto de servicio de cliente de `MediaConvert` mediante la transferencia de los parámetros. 

**nota**  
Sustituya *JOB\$1QUEUE\$1ARN* por el Nombre de recurso de Amazon (ARN) de la cola de trabajos que desea comprobar, *KEY\$1PAIR\$1NAME* por, *TEMPLATE\$1NAME* por, *ROLE\$1ARN* por el Nombre de recurso de Amazon (ARN) del rol y *INPUT\$1BUCKET\$1AND\$1FILENAME* por el bucket de entrada y el nombre del archivo (por ejemplo, “s3://BUCKET\$1NAME/FILE\$1NAME”).

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node emc_template_createjob.js 
```

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Generación de una lista de sus plantillas de trabajo
<a name="emc-examples-templates-listing"></a>

Cree un módulo de Node.js con el nombre de archivo `emc_listtemplates.js`. Asegúrese de configurar el SDK como se ha mostrado anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Cree un objeto para pasar los parámetros de solicitud vacíos para el método `listTemplates` de la clase de cliente `MediaConvert`. Incluya valores para determinar qué plantillas incluirá en la lista (`NAME`, `CREATION DATE`, `SYSTEM`), la cantidad que se incluirán en la lista y su orden de clasificación. Para llamar al método `ListTemplatesCommand`, cree una promesa para invocar un objeto de servicio de cliente de MediaConvert mediante la transferencia de los parámetros. 

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node emc_listtemplates.js 
```

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Eliminación de una plantilla de trabajo
<a name="emc-examples-templates-delete"></a>

Cree un módulo de Node.js con el nombre de archivo `emc_deletetemplate.js`. Asegúrese de configurar el SDK como se ha mostrado anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Cree un objeto para transferir el nombre de la plantilla de trabajo que desea eliminar como parámetros para el método `DeleteJobTemplateCommand` de la clase de cliente `MediaConvert`. Para llamar al método `DeleteJobTemplateCommand`, cree una promesa para invocar un objeto de servicio de cliente de MediaConvert mediante la transferencia de los parámetros. 

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node emc_deletetemplate.js 
```

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_deletetemplate.js).

# Ejemplos de Lambda
<a name="lambda-examples"></a>

Lambda es un servicio de computación sin servidor que le permite ejecutar código sin aprovisionar ni administrar servidores, crear una lógica de escalado de clústeres compatible con las cargas de trabajo, mantener integraciones de eventos ni administrar tiempos de ejecución. 

La API de JavaScript para Lambda se expone a través de la clase de cliente de [LambdaService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lambda/).

A continuación se muestra una lista de ejemplos que muestran cómo crear y usar funciones de Lambda con la v3 de AWS SDK for JavaScript:
+ [Invocación de Lambda con API Gateway](api-gateway-invoking-lambda-example.md)
+ [Crear eventos programados para ejecutar AWS Lambda funciones](scheduled-events-invoking-lambda-example.md)

# Ejemplos de Amazon Lex
<a name="lex-examples"></a>

Amazon Lex es un servicio de AWS para crear interfaces de conversación en aplicaciones utilizando voz y texto. 

La API de JavaScript para Amazon Lex se expone a través de la clase de cliente [Lex Runtime Service](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lex-runtime-service/).
+ [Creación de un chatbot de Amazon Lex](lex-bot-example.md)

# Ejemplos de Amazon Polly
<a name="polly-examples"></a>

![\[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:**
+ Cargue el audio grabado con Amazon Polly a Amazon S3

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

En este ejemplo, se utilizan una serie de módulos de Node.js para cargar automáticamente el audio grabado con Amazon Polly a Amazon S3 mediante estos métodos de la clase de cliente de Amazon S3:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-polly/Class/StartSpeechSynthesisTaskCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-polly/Class/StartSpeechSynthesisTaskCommand/)

## Tareas previas necesarias
<a name="polly-example-synthesize-to-s3-prerequisites"></a>

Para configurar y ejecutar este ejemplo, primero debe completar estas tareas:
+ Configure un entorno de proyecto para ejecutar JavaScript ejemplos de Node siguiendo las instrucciones de [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/s3/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 los [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 AWS SDKs and Tools*.
+ Cree una encuesta de roles de usuario de Amazon Cognito AWS Identity and Access Management (IAM) no autenticada: permisos SynthesizeSpeech y un grupo de identidades de Amazon Cognito con la función de IAM asociada. En la siguiente sección [Cree los recursos mediante el AWS CloudFormation](#polly-example-synthesize-to-s3-create-resources), se describe cómo crear estos recursos.

**nota**  
En este ejemplo se utiliza Amazon Cognito, pero si no utiliza Amazon Cognito, el usuario debe cumplir con la siguiente política de AWS permisos de IAM.  

****  

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

## Cree los recursos mediante el AWS CloudFormation
<a name="polly-example-synthesize-to-s3-create-resources"></a>

CloudFormation le permite crear y aprovisionar despliegues de AWS infraestructura de forma predecible y repetitiva. Para obtener más información al respecto CloudFormation, consulte la Guía del [AWS CloudFormation usuario](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Para crear la CloudFormation pila:

1. Instale y configure las AWS CLI siguientes instrucciones de la [Guía del AWS CLI usuario](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Cree un archivo con un nombre `setup.yaml` en el directorio raíz de la carpeta de su proyecto y copie [el contenido GitHub en](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/polly/general-examples/src/setup.yaml) él. 
**nota**  
La CloudFormation plantilla se generó utilizando lo que AWS CDK está [disponible aquí GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/javascript_example_code_polly_aws_service/). Para obtener más información sobre AWS CDK, consulte la [Guía para AWS Cloud Development Kit (AWS CDK) desarrolladores](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Ejecute el siguiente comando desde la línea de comandos y *STACK\$1NAME* sustitúyalo por un nombre único para la pila.
**importante**  
El nombre de la pila debe ser único en una AWS región y una AWS cuenta. El nombre puede tener una longitud de hasta 128 caracteres, y se permiten números y guiones.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Para obtener más información sobre los parámetros de los comandos `create-stack`, consulte la [Guía de referencia de comandos de AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) y la [Guía del usuario de AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. Ve a la consola CloudFormation de administración, selecciona **Pilas**, elige el nombre de la pila y selecciona la pestaña **Recursos** para ver una lista de los recursos creados.  
![\[CloudFormation recursos\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/cfn_polly.png)

## Cargue el audio grabado con Amazon Polly a Amazon S3
<a name="polly-example-synthesize-to-s3-example"></a>

Cree un módulo de Node.js con el nombre de archivo `polly_synthesize_to_s3.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. En el código, introduzca el*REGION*, y el*BUCKET\$1NAME*. Para acceder a Amazon Polly, cree un objeto de servicio al cliente de `Polly`. *"IDENTITY\$1POOL\$1ID"*`IdentityPoolId`Sustitúyala por la de la **página de muestra** del grupo de identidades de Amazon Cognito que creaste para este ejemplo. Esto también se transfiere a cada objeto de cliente.

Llame al método `StartSpeechSynthesisCommand` del objeto de servicio al cliente de Amazon Polly, sintetice el mensaje de voz y cárguelo en el bucket de Amazon S3. 

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

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

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

Puede encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/polly/general-examples/src/polly_synthesize_to_s3.js).

# Ejemplos de Amazon Redshift
<a name="redshift-examples"></a>

Amazon Redshift es un servicio de almacenamiento de datos administrado de varios petabytes en la nube. Un almacenamiento de datos de Amazon Redshift es una colección de recursos informáticos denominados *nodos* que se organizan en un grupo llamado *clúster*. Cada clúster ejecuta un motor Amazon Redshift y contiene una o más bases de datos.

![\[Relación entre entornos de JavaScript, el SDK y Amazon Redshift\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/code-samples-redshift.png)


La API de JavaScript para Amazon Redshift se expone a través de la clase de cliente de [Amazon Redshift](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/Redshift/).

**Topics**
+ [Ejemplos de Amazon Redshift](redshift-examples-section.md)

# Ejemplos de Amazon Redshift
<a name="redshift-examples-section"></a>

En este ejemplo, se utilizan una serie de módulos de Node.js para crear, modificar, describir los parámetros y, a continuación, eliminar clústeres de Amazon Redshift mediante los siguientes métodos de la clase de cliente de `Redshift`:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/)

Para obtener más información sobre los usuarios de Amazon Redshift, consulte la [Guía de introducción de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html).

## Tareas previas necesarias
<a name="s3-example-configuring-buckets-prerequisites"></a>

Para configurar y ejecutar este ejemplo, primero debe completar estas tareas:
+ Configure el entorno del proyecto para ejecutar estos ejemplos de Node TypeScript e instale los módulos necesarios de AWS SDK for JavaScript y de terceros. Siga las instrucciones en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift/README.md).
+ Cree un archivo de configuraciones compartidas con sus credenciales de usuario. Para obtener más información sobre 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 las herramientas y los SDK de AWS*.

**importante**  
Estos ejemplos muestran cómo importar/exportar comandos y objetos del servicio de cliente 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)

## Crea un clúster de Amazon Redshift.
<a name="redshift-create-cluster"></a>

En este ejemplo, se muestra cómo crear un clúster de Amazon Redshift con AWS SDK for JavaScript. Para obtener más información, consulte [CreateCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_CreateCluster).

**importante**  
*El clúster que está a punto de lanzar se ejecutará en un entorno real (no en un entorno aislado). Debe pagar las tarifas de uso estándar de Amazon Redshift por el clúster hasta que lo elimine. Si elimina el clúster en la misma sesión en que lo creó, los cargos totales son mínimos.* 

Cree un directorio `libs` y cree un módulo Node.js con el nombre de archivo `redshiftClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon Redshift. Sustituya *REGION* por su región de AWS.

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Cree un módulo de Node.js con el nombre de archivo `redshift-create-cluster.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree un objeto de parámetros, especificando el tipo de nodo que se va a aprovisionar y las credenciales maestras de inicio de sesión de la instancia de base de datos creada automáticamente en el clúster y, por último, el tipo de clúster.

**nota**  
Sustituya *CLUSTER\$1NAME* por el nombre de su clúster. En *NODE\$1TYPE*, especifique el tipo de nodo que se va a aprovisionar, como “dc2.large”, por ejemplo. *MASTER\$1USERNAME* y *MASTER\$1USER\$1PASSWORD* son las credenciales de inicio de sesión del usuario maestro de la instancia de base de datos en el clúster. En *CLUSTER\$1TYPE*, introduzca el tipo de clúster. Si especifica `single-node`, no necesitará el parámetro `NumberOfNodes`. El resto de los parámetros son opcionales. 

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node redshift-create-cluster.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/redshift/src/redshift-create-cluster.js).

## Modificación de un clúster de Amazon Redshift
<a name="redshift-modify-cluster"></a>

En este ejemplo se muestra cómo modificar la contraseña de usuario maestro de un clúster de Amazon Redshift usando AWS SDK for JavaScript. Para obtener más información sobre qué otra configuración puede modificar, consulte [ModifyCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_ModifyCluster.html).

Cree un directorio `libs` y cree un módulo Node.js con el nombre de archivo `redshiftClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon Redshift. Sustituya *REGION* por su región de AWS.

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Cree un módulo de Node.js con el nombre de archivo `redshift-modify-cluster.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Especifique la región de AWS, el nombre del clúster que desea modificar y la nueva contraseña de usuario maestro.

**nota**  
Sustituya *CLUSTER\$1NAME* por el nombre del clúster y *MASTER\$1USER\$1PASSWORD* por la nueva contraseña de usuario maestro. 

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node redshift-modify-cluster.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/redshift/src/redshift-modify-cluster.js).

## Visualización de los detalles de un clúster de Amazon Redshift
<a name="redshift-describe-cluster"></a>

En este ejemplo, se muestra cómo consultar los detalles de un clúster de Amazon Redshift con AWS SDK for JavaScript. Para obtener más información sobre lo opcional, consulte [DescribecLusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html).

Cree un directorio `libs` y cree un módulo Node.js con el nombre de archivo `redshiftClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon Redshift. Sustituya *REGION* por su región de AWS.

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Cree un módulo de Node.js con el nombre de archivo `redshift-describe-clusters.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Especifique la región de AWS, el nombre del clúster que desea modificar y la nueva contraseña de usuario maestro.

**nota**  
Sustituya *CLUSTER\$1NAME* por el nombre de su clúster. 

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node redshift-describe-clusters.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/redshift/src/redshift-describe-clusters.js).

## Eliminar un clúster de Amazon Redshift
<a name="redshift-delete-cluster"></a>

En este ejemplo, se muestra cómo consultar los detalles de un clúster de Amazon Redshift con AWS SDK for JavaScript. Para obtener más información sobre qué otra configuración puede modificar, consulte [DeleteCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DeleteCluster.html).

Cree un directorio `libs` y cree un módulo Node.js con el nombre de archivo `redshiftClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon Redshift. Sustituya *REGION* por su región de AWS.

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Cree un módulo de Node.js con el nombre de archivo `redshift-delete-clusters.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Especifique la región de AWS, el nombre del clúster que desea modificar y la nueva contraseña de usuario maestro. Especifique si desea guardar una instantánea final del clúster antes de eliminarlo y, de ser así, el ID de la instantánea.

**nota**  
Sustituya *CLUSTER\$1NAME* por el nombre de su clúster. Para *SkipFinalClusterSnapshot*, especifique si desea crear una instantánea final del clúster antes de eliminarlo. Si especifica “false”, especifique el ID de la instantánea final del clúster en *CLUSTER\$1SNAPSHOT\$1ID*. Puede obtener este ID haciendo clic en el enlace de la columna **Instantáneas** del clúster en el panel de control **Clústeres** y desplazándose hacia abajo hasta el panel **Instantáneas**. Tenga en cuenta que la raíz `rs:` no forma parte del ID de la instantánea.

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node redshift-delete-cluster.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/redshift/src/redshift-delete-cluster.js).

# Ejemplos de Amazon Simple Email Service
<a name="ses-examples"></a>

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
<a name="ses-examples-managing-identities"></a>

![\[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
<a name="ses-examples-verifying-identities-scenario"></a>

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
<a name="ses-examples-verifying-identities-prerequisites"></a>

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
<a name="ses-examples-listing-identities"></a>

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
<a name="ses-examples-verifying-email"></a>

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
<a name="ses-examples-verifying-domains"></a>

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
<a name="ses-examples-deleting-identities"></a>

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
<a name="ses-examples-creating-template"></a>

![\[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
<a name="ses-examples-creating-template-scenario"></a>

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
<a name="ses-examples-creating-template-prerequisites"></a>

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
<a name="ses-examples-listing-templates"></a>

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
<a name="ses-examples-get-template"></a>

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
<a name="ses-examples-create-template"></a>

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: `
        <h1>Hello, {{contact.firstName}}!</h1>
        <p>
        Did you know Amazon has a mascot named Peccy?
        </p>
      `,
      SubjectPart: "Amazon Tip",
    },
  });
};

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

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

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
<a name="ses-examples-update-template"></a>

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 = "<h1>Hello, World!</h1>";

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

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

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

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
<a name="ses-examples-delete-template"></a>

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
<a name="ses-examples-sending-email"></a>

![\[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
<a name="ses-examples-sending-email-scenario"></a>

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
<a name="ses-examples-sending-emails-prerequisites"></a>

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
<a name="ses-examples-sending-msail-reqs"></a>

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
<a name="ses-examples-sendmail"></a>

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
<a name="ses-examples-sendtemplatedemail"></a>

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: <h1>Hello {{contact.firstName}},</h1><p>Don't forget about the party gifts!</p>
     * Destination: <h1>Hello Bilbo,</h1><p>Don't forget about the party gifts!</p>
     */
    Destination: { ToAddresses: [user.emailAddress] },
    TemplateData: JSON.stringify({ contact: { firstName: user.firstName } }),
    Source: VERIFIED_EMAIL,
    Template: templateName,
  });
};

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

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
<a name="ses-examples-sendbulktemplatedemail"></a>

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: <h1>Hello {{name}},</h1><p>Don't forget about the party gifts!</p>
     * Destination 1: <h1>Hello Bilbo,</h1><p>Don't forget about the party gifts!</p>
     * Destination 2: <h1>Hello Frodo,</h1><p>Don't forget about the party gifts!</p>
     */
    Destinations: users.map((user) => ({
      Destination: { ToAddresses: [user.emailAddress] },
      ReplacementTemplateData: JSON.stringify({ name: user.firstName }),
    })),
    DefaultTemplateData: JSON.stringify({ name: "Shireling" }),
    Source: VERIFIED_EMAIL_1,
    Template: templateName,
  });
};

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

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

# Ejemplos de Amazon Simple Notification Service
<a name="sns-examples"></a>

Amazon Simple Notification Service (Amazon SNS) es un servicio web que coordina y gestiona la entrega o el envío de mensajes a los puntos de conexión o clientes suscritos. 

En Amazon SNS, existen dos tipos de clientes, publicadores y suscriptores, también conocidos como productores y consumidores. 

![\[Relación entre JavaScript los entornos, el SDK y Amazon SNS\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/code-samples-sns.png)


Los publicadores se comunican de forma asíncrona con los suscriptores generando y enviando un mensaje a un tema, que es un punto de acceso lógico y un canal de comunicación. Los suscriptores (servidores web, direcciones de correo electrónico, colas de Amazon SQS, AWS Lambda funciones) consumen o reciben el mensaje o la notificación a través de uno de los protocolos compatibles (Amazon SQS, HTTP/S, correo electrónico, SMS AWS Lambda) cuando se suscriben al tema. 

La JavaScript API de Amazon SNS se expone en la [clase:](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SNS/) SNS. 

**Topics**
+ [Administración de temas en Amazon SNS](sns-examples-managing-topics.md)
+ [Publicación de mensajes en Amazon SNS](sns-examples-publishing-messages.md)
+ [Administración de suscripciones en Amazon SNS](sns-examples-subscribing-unsubscribing-topics.md)
+ [Envío de mensajes SMS con Amazon SNS](sns-examples-sending-sms.md)

# Administración de temas en Amazon SNS
<a name="sns-examples-managing-topics"></a>

![\[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 crear temas en Amazon SNS en los que pueda publicar notificaciones.
+ Cómo eliminar temas creados en Amazon SNS.
+ Cómo obtener una lista de los temas disponibles.
+ Cómo obtener y establecer atributos de temas.

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

En este ejemplo, va a utilizar una serie de módulos de Node.js para crear, enumerar y eliminar temas de Amazon SNS y para gestionar atributos de los temas. Los módulos de Node.js utilizan el SDK JavaScript para administrar los temas mediante los siguientes métodos de la clase `SNS` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/)

## Tareas previas necesarias
<a name="sns-examples-managing-topics-prerequisites"></a>

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 que figuran en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/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).

## Creación de un tema
<a name="sns-examples-managing-topics-createtopic"></a>

En este ejemplo, utilice un módulo de Node.js para crear un tema de Amazon SNS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Reemplácelo por su AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `create-topic.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Cree un objeto para transferir el `Name` del nuevo tema al método `CreateTopicCommand` de la clase de cliente de Amazon SNS. Para llamar al método `CreateTopicCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. Los `data` devueltos contienen el ARN del tema.

**nota**  
*TOPIC\$1NAME*Sustitúyalo por el nombre del tema.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node create-topic.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/sns/actions/create-topic.js).

## Enumeración de los temas de
<a name="sns-examples-managing-topics-listtopics"></a>

En este ejemplo, utilice un módulo de Node.js para generar una lista de todos los temas de Amazon SNS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `list-topics.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Cree un objeto vacío para transferirlo al método `ListTopicsCommand` de la clase de cliente de Amazon SNS. Para llamar al método `ListTopicsCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. La información `data` devuelta contiene una matriz de su tema Amazon Resource Names (ARNs).

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

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

Este código de muestra se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-topics.js).

## Eliminación de un tema
<a name="sns-examples-managing-topics-deletetopic"></a>

En este ejemplo, utilice un módulo de Node.js para eliminar un tema de Amazon SNS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `delete-topic.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Cree un objeto que contenga el `TopicArn` del tema que se va a eliminar para transferirlo al método `DeleteTopicCommand` de la clase de cliente Amazon SNS. Para llamar al método `DeleteTopicCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  
*TOPIC\$1ARN*Sustitúyalo por el nombre de recurso de Amazon (ARN) del tema que vaya a eliminar.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node delete-topic.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/sns/actions/delete-topic.js).

## Obtención de atributos de temas
<a name="sns-examples-managing-topicsgettopicattributes"></a>

En este ejemplo, utilice un módulo de Node.js para recuperar atributos de un tema de Amazon SNS.

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `get-topic-attributes.js`. Configure el SDK como le hemos mostrado anteriormente.

Cree un objeto que contenga el `TopicArn` de un tema que se vaya a eliminar para transferirlo al método `GetTopicAttributesCommand` de la clase de cliente de Amazon SNS. Para llamar al método `GetTopicAttributesCommand`, invoque un objeto de servicio de cliente de Amazon SNS, mediante el traspaso del objeto de parámetros. 

**nota**  
*TOPIC\$1ARN*Sustitúyalo por el ARN del tema.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node get-topic-attributes.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/sns/actions/get-topic-attributes.js).

## Configuración de los atributos de un tema
<a name="sns-examples-managing-topicssttopicattributes"></a>

En este ejemplo, utilice un módulo de Node.js para establecer los atributos mutables de un tema de Amazon SNS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `set-topic-attributes.js`. Configure el SDK como le hemos mostrado anteriormente.

Cree un objeto que contenga los parámetros para realizar la actualización del atributo, como el `TopicArn` del tema cuyos atributos desea establecer, el nombre del atributo que se va a establecer y el nuevo valor para dicho atributo. Solo puede establecer los atributos `Policy`, `DisplayName` y `DeliveryPolicy`. Transfiera los parámetros al método `SetTopicAttributesCommand` de la clase de cliente de Amazon SNS. Para llamar al método `SetTopicAttributesCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  
*ATTRIBUTE\$1NAME*Sustitúyalo por el nombre del atributo que estás *TOPIC\$1ARN* configurando, por el nombre del recurso de Amazon (ARN) del tema cuyos atributos quieres establecer y *NEW\$1ATTRIBUTE\$1VALUE* por el nuevo valor de ese atributo.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node set-topic-attributes.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/sns/actions/set-topic-attributes.js).

# Publicación de mensajes en Amazon SNS
<a name="sns-examples-publishing-messages"></a>

![\[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 publicar mensajes en un tema de Amazon SNS.

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

En este ejemplo va a utilizar una serie de módulos de Node.js para publicar mensajes de Amazon SNS en puntos de conexión de temas, correos electrónicos o números de teléfono. Los módulos de Node.js utilizan el SDK JavaScript para enviar mensajes mediante este método de la clase `SNS` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)

## Tareas previas necesarias
<a name="sns-examples-publishing-messages-prerequisites"></a>

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 que figuran en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/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).

## Publicación de un mensaje en un tema de SNS
<a name="sns-examples-publishing-text-messages"></a>

En este ejemplo, utilice un módulo de Node.js para publicar un mensaje en un tema de Amazon SNS.

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Reemplácelo por su AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Cree un módulo de Node.js con el nombre de archivo `publish-topic.js`. Configure el SDK como le hemos mostrado anteriormente.

Cree un objeto que contenga los parámetros para publicar un mensaje, incluidos el texto del mensaje y el nombre de recurso de Amazon (ARN) de Amazon. SNStopic Para obtener más información sobre los atributos de SMS disponibles, consulte [Set SMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html#setSMSAttributes-property).

Pase los parámetros al método `PublishCommand` de la clase de cliente de Amazon SNS. Cree una función asíncrona que invoque un objeto de servicio de cliente de Amazon SNS, mediante el traspaso del objeto de parámetros. 

**nota**  
*MESSAGE\$1TEXT*Sustitúyalo por el texto del mensaje y *TOPIC\$1ARN* por el ARN del tema SNS.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node publish-topic.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/sns/actions/publish-topic.js)

# Administración de suscripciones en Amazon SNS
<a name="sns-examples-subscribing-unsubscribing-topics"></a>

![\[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 mostrar una lista de todas las suscripciones en un tema de Amazon SNS.
+ Cómo suscribir una dirección de correo electrónico, un punto de conexión de una aplicación o una función de Lambda a un tema de Amazon SNS.
+ Cómo cancelar una suscripción a temas de Amazon SNS.

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

En este ejemplo, va a utilizar una serie de módulos de Node.js para publicar mensajes de notificación en temas de Amazon SNS. Los módulos de Node.js utilizan el SDK JavaScript para gestionar los temas mediante los siguientes métodos de la clase `SNS` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/)

## Tareas previas necesarias
<a name="sns-examples-subscribing-unsubscribing-topics-prerequisites"></a>

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 que figuran en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/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).

## Generación de una lista de suscripciones a un tema
<a name="sns-examples-list-subscriptions-email"></a>

En este ejemplo, utilice un módulo de Node.js para generar una lista de todas las suscripciones a un tema de Amazon SNS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Reemplácelo por su AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Cree un módulo de Node.js con el nombre de archivo `list-subscriptions-by-topic.js`. Configure el SDK como le hemos mostrado anteriormente.

Cree un objeto que contenga el parámetro `TopicArn` para el tema cuyas suscripciones desee incluir en la lista. Transfiera los parámetros al método `ListSubscriptionsByTopicCommand` de la clase de cliente de Amazon SNS. Para llamar al método `ListSubscriptionsByTopicCommand`, cree una función asíncrona que invoque un objeto de servicio de cliente de Amazon SNS y transfiera el objeto de los parámetros. 

**nota**  
*TOPIC\$1ARN*Sustitúyalo por el nombre de recurso de Amazon (ARN) del tema cuyas suscripciones quieras incluir en la lista.

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

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

Puedes encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-subscriptions-by-topic.js).

## Suscripción de una dirección de correo electrónico a un tema
<a name="sns-examples-subscribing-email"></a>

En este ejemplo, va a utilizar un módulo de Node.js para suscribir una dirección de correo electrónico para que reciba mensajes de correo electrónico SMTP de un tema de Amazon SNS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `subscribe-email.js`. Configure el SDK como le hemos mostrado anteriormente.

Cree un objeto que contenga el parámetro `Protocol` para especificar el protocolo de `email`, el `TopicArn` del tema al que se suscribirá y una dirección de correo electrónico como el mensaje `Endpoint`. Transfiera los parámetros al método `SubscribeCommand` de la clase de cliente de Amazon SNS. Puede utilizar el método `subscribe` para suscribir varios puntos de conexión diferentes a un tema de Amazon SNS, en función de los valores que se utilicen para los parámetros que se transfieran, tal y como se verá en otros ejemplos de este tema.

Para llamar al método `SubscribeCommand`, cree una función asíncrona que invoque un objeto de servicio de cliente de Amazon SNS y transfiera el objeto de los parámetros. 

**nota**  
*TOPIC\$1ARN*Sustitúyalo por el nombre del recurso de Amazon (ARN) del tema y por la dirección de correo electrónico *EMAIL\$1ADDRESS* a la que deseas suscribirte.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node subscribe-email.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/sns/actions/subscribe-email.js).

### Confirmar suscripciones
<a name="sns-confirm-subscription-email"></a>

En este ejemplo, use un módulo de Node.js para verificar la intención del propietario de un punto de conexión de recibir mensajes validando el token enviado al punto de conexión por una acción de suscripción previa. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `confirm-subscription.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Defina los parámetros, incluidos `TOPIC_ARN` y `TOKEN`, y defina un valor de `TRUE` o `FALSE` para `AuthenticateOnUnsubscribe`.

El token es un token de corta duración que se envía al propietario de un punto de conexión durante una acción `SUBSCRIBE` anterior. Por ejemplo, en el caso de un punto de conexión de correo electrónico, el `TOKEN` está en la URL del correo electrónico de confirmación de suscripción enviado al propietario del correo electrónico. Por ejemplo, `abc123` es el token en la siguiente URL:

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


Para llamar al método `ConfirmSubscriptionCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  
*TOPIC\$1ARN*Sustitúyalo por el nombre del recurso de Amazon (ARN) del tema, *TOKEN* por el valor del token de la URL enviada al propietario del punto final en una `Subscribe` acción anterior, y defina*AuthenticateOnUnsubscribe*. por un valor de `TRUE` o. `FALSE`

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node confirm-subscription.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/sns/actions/confirm-subscription.js).

## Suscripción de un punto de conexión de aplicación a un tema
<a name="sns-examples-subscribing-apps"></a>

En este ejemplo, va a utilizar un módulo de Node.js para suscribir un punto de conexión de una aplicación móvil para que reciba notificaciones de un tema de Amazon SNS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `subscribe-app.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los módulos y paquetes necesarios.

Cree un objeto que contenga el parámetro `Protocol` para especificar el protocolo de la `application`, el `TopicArn` del tema al que va a suscribirse y el Nombre de recurso de Amazon (ARN) del punto de conexión de la aplicación móvil para el parámetro `Endpoint`. Transfiera los parámetros al método `SubscribeCommand` de la clase de cliente de Amazon SNS.

Para llamar al método `SubscribeCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  
*TOPIC\$1ARN*Sustitúyalo por el nombre del recurso de Amazon (ARN) del tema y *MOBILE\$1ENDPOINT\$1ARN* por el punto final al que te estás suscribiendo al tema.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node subscribe-app.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/sns/actions/subscribe-app.js)

## Suscripción de una función de Lambda a un tema
<a name="sns-examples-subscribing-lambda"></a>

En este ejemplo, utilice un módulo Node.js para suscribir una AWS Lambda función de forma que reciba notificaciones de un tema de Amazon SNS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por su AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `subscribe-lambda.js`. Configure el SDK como le hemos mostrado anteriormente.

Cree un objeto que contenga el `Protocol` parámetro, especificando el `lambda` protocolo, el `TopicArn` tema al que se va a suscribir y el nombre de recurso de Amazon (ARN) de una AWS Lambda función como parámetro. `Endpoint` Transfiera los parámetros al método `SubscribeCommand` de la clase de cliente de Amazon SNS.

Para llamar al método `SubscribeCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  
*TOPIC\$1ARN*Sustitúyalo por el nombre de recurso de Amazon (ARN) del tema y *LAMBDA\$1FUNCTION\$1ARN* por el nombre de recurso de Amazon (ARN) de la función Lambda.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node subscribe-lambda.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/sns/actions/subscribe-lambda.js)

## Cancelación de la suscripción a un tema
<a name="sns-examples-unsubscribing"></a>

En este ejemplo, utilice un módulo de Node.js para cancelar la suscripción a un tema de Amazon SNS.

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `unsubscribe.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios.

Cree un objeto que contenga el parámetro `SubscriptionArn` que especifique el Nombre de recurso de Amazon (ARN) de la suscripción que desea cancelar. Transfiera los parámetros al método `UnsubscribeCommand` de la clase de cliente de Amazon SNS.

Para llamar al método `UnsubscribeCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  
*TOPIC\$1SUBSCRIPTION\$1ARN*Sustitúyalo por el nombre de recurso de Amazon (ARN) de la suscripción para cancelar la suscripción.

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node unsubscribe.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/sns/actions/unsubscribe.js).

# Envío de mensajes SMS con Amazon SNS
<a name="sns-examples-sending-sms"></a>

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

**Este ejemplo de código de Node.js muestra:**
+ Cómo obtener y establecer las preferencias de mensajería de SMS para Amazon SNS.
+ Cómo comprobar un número de teléfono para ver si se ha desactivado la opción de recepción de mensajes SMS.
+ Cómo obtener una lista de números de teléfono con la opción de recepción de mensajes SMS desactivada
+ Cómo enviar un mensaje SMS.

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

Puede utilizar Amazon SNS para enviar mensajes de texto o mensajes SMS a dispositivos habilitados para recibir SMS. Dispone de la capacidad de enviar un mensaje directamente a un número de teléfono o de enviar un mensaje a varios números de teléfono a la vez suscribiendo dichos números de teléfono a un tema y enviando el mensaje al tema.

En este ejemplo, va a utilizar una serie de módulos de Node.js para publicar mensajes de texto SMS de Amazon SNS a dispositivos habilitados para SMS. Los módulos de Node.js utilizan el SDK JavaScript para publicar mensajes SMS mediante los siguientes métodos de la clase `SNS` cliente:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)

## Tareas previas necesarias
<a name="sns-examples-sending-sms-prerequisites"></a>

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 que figuran en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/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 atributos de SMS
<a name="sending-sms-getattributes"></a>

Utilice Amazon SNS para especificar las preferencias de mensajería SMS, como la forma en que se optimizan sus envíos (por coste o por fiabilidad de la entrega), su límite de gasto mensual, cómo se registran los envíos de mensajes y si desea suscribirse a informes de uso de SMS diarios. Estas preferencias se recuperan y se establecen como atributos SMS para Amazon SNS.

En este ejemplo, va a utilizar un módulo de Node.js para obtener los atributos de SMS actuales en Amazon SNS.

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Reemplácelo por su AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Cree un módulo de Node.js con el nombre de archivo `get-sms-attributes.js`.

Configure el SDK como se mostró anteriormente, incluida la descarga de los clientes y paquetes necesarios. Cree un objeto que contenga los parámetros para obtener atributos de SMS, como los nombres de los atributos individuales que desea obtener. Para obtener más información sobre los atributos de SMS disponibles, consulte [Establecer SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) en la referencia de la API de Amazon Simple Notification Service.

Este ejemplo obtiene el atributo `DefaultSMSType` que controla si se envían mensajes SMS como `Promotional`, que optimiza la entrega de mensajes para conseguir el costo más bajo, o como `Transactional`, que optimiza el envío de mensajes para conseguir la máxima fiabilidad. Transfiera los parámetros al método `SetTopicAttributesCommand` de la clase de cliente de Amazon SNS. Para llamar al método `SetSMSAttributesCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  
*ATTRIBUTE\$1NAME*Sustitúyalo por el nombre del atributo.

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

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node get-sms-attributes.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/sns/actions/get-sms-attributes.js).

## Configuración de atributos de SMS
<a name="sending-sms-setattributes"></a>

En este ejemplo, va a utilizar un módulo de Node.js para obtener los atributos de SMS actuales en Amazon SNS.

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Cree un módulo de Node.js con el nombre de archivo `set-sms-attribute-type.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree un objeto que contenga los parámetros para establecer atributos de SMS, como los nombres de los atributos individuales que desea establecer y los valores que se establecerán para cada uno de ellos. Para obtener más información sobre los atributos de SMS disponibles, consulte [Establecer SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) en la referencia de la API de Amazon Simple Notification Service.

Este ejemplo establece el atributo `DefaultSMSType` en `Transactional`, que optimiza el envío de mensajes para conseguir la máxima fiabilidad. Transfiera los parámetros al método `SetTopicAttributesCommand` de la clase de cliente de Amazon SNS. Para llamar al método `SetSMSAttributesCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

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

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

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

Puede encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-sms-attribute-type.js).

## Comprobación de si se ha desactivado un número de teléfono
<a name="sending-sms-checkifphonenumberisoptedout"></a>

En este ejemplo, va a utilizar un módulo de Node.js para comprobar si un número de teléfono tiene desactivada la opción de recibir mensajes SMS. 

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `check-if-phone-number-is-opted-out.js`. Configure el SDK como le hemos mostrado anteriormente. Cree un objeto que contenga el número de teléfono que se desea comprobar como parámetro.

Este ejemplo establece el parámetro `PhoneNumber` para especificar el número de teléfono que se va a comprobar. Transfiera el objeto al método `CheckIfPhoneNumberIsOptedOutCommand` de la clase de cliente de Amazon SNS. Para llamar al método `CheckIfPhoneNumberIsOptedOutCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  

*PHONE\$1NUMBER*Sustitúyalo por el número de teléfono.

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

import { snsClient } from "../libs/snsClient.js";

export const checkIfPhoneNumberIsOptedOut = async (
  phoneNumber = "5555555555",
) => {
  const command = new CheckIfPhoneNumberIsOptedOutCommand({
    phoneNumber,
  });

  const response = await snsClient.send(command);
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '3341c28a-cdc8-5b39-a3ee-9fb0ee125732',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   isOptedOut: false
  // }
  return response;
};
```

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node check-if-phone-number-is-opted-out.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/sns/actions/check-if-phone-number-is-opted-out.js).

## Generación de una lista de los números de teléfono desactivados
<a name="sending-sms-listphonenumbersoptedout"></a>

En este ejemplo, va a utilizar un módulo de Node.js para obtener una lista de números de teléfono que tienen desactivada la opción de recibir mensajes SMS.

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `list-phone-numbers-opted-out.js`. Configure el SDK como le hemos mostrado anteriormente. Cree un objeto vacío como parámetro.

Transfiera el objeto al método `ListPhoneNumbersOptedOutCommand` de la clase de cliente de Amazon SNS. Para llamar al método `ListPhoneNumbersOptedOutCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

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

export const listPhoneNumbersOptedOut = async () => {
  const response = await snsClient.send(
    new ListPhoneNumbersOptedOutCommand({}),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '44ff72fd-1037-5042-ad96-2fc16601df42',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   phoneNumbers: ['+15555550100']
  // }
  return response;
};
```

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node list-phone-numbers-opted-out.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/sns/actions/list-phone-numbers-opted-out.js).

## Publicación de un mensaje SMS
<a name="sending-sms-publishsms"></a>

En este ejemplo, utilice un módulo de Node.js para enviar un mensaje SMS a un número de teléfono.

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `snsClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente de Amazon SNS. *REGION*Sustitúyalo por tu AWS región.

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

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

Este código de ejemplo se puede encontrar [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Cree un módulo de Node.js con el nombre de archivo `publish-sms.js`. Configure el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree un objeto que contenga los parámetros `Message` y `PhoneNumber`.

Cuando envíe un mensaje SMS, especifique el número de teléfono usando la formato E.164. E.164 es un estándar de estructura de número de teléfono utilizado para las telecomunicaciones internacionales. Los números que aplican este formato pueden tener un máximo de 15 dígitos y van prefijados con el carácter (\$1) y el código de país. Por ejemplo, un número de teléfono de EE. UU. en formato E.164 aparecería como XXX5550100 \$11001. 

En este ejemplo se establece el parámetro `PhoneNumber` para especificar el número de teléfono al que se enviará el mensaje. Transfiera el objeto al método `PublishCommand` de la clase de cliente de Amazon SNS. Para llamar al método `PublishCommand`, cree una función asincrónica para invocar un objeto de servicio de Amazon SNS mediante el traspaso del objeto de parámetros. 

**nota**  
*TEXT\$1MESSAGE*Sustitúyalo por el mensaje de texto y *PHONE\$1NUMBER* por el número de teléfono.

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

/**
 * @param {string | Record<string, any>} message - The message to send. Can be a plain string or an object
 *                                                 if you are using the `json` `MessageStructure`.
 * @param {*} phoneNumber - The phone number to send the message to.
 */
export const publish = async (
  message = "Hello from SNS!",
  phoneNumber = "+15555555555",
) => {
  const response = await snsClient.send(
    new PublishCommand({
      Message: message,
      // One of PhoneNumber, TopicArn, or TargetArn must be specified.
      PhoneNumber: phoneNumber,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '7410094f-efc7-5f52-af03-54737569ab77',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node publish-sms.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/sns/actions/publish-sms.js).

# Ejemplos de Amazon Transcribe
<a name="Transcribe-examples"></a>

Amazon Transcribe permite a los desarrolladores añadir fácilmente a sus aplicaciones capacidades de conversión de voz a texto en tiempo real. 

![\[Relación entre JavaScript los entornos, el SDK y Amazon Transcribe\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/code-samples-transcribe.png)


La JavaScript API de Amazon Transcribe se expone a través de la clase de [TranscribeService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/Transcribe/)cliente.

**Topics**
+ [Ejemplos de Amazon Transcribe](transcribe-examples-section.md)
+ [Ejemplos de Amazon Transcribe Medical](transcribe-medical-examples-section.md)

# Ejemplos de Amazon Transcribe
<a name="transcribe-examples-section"></a>

En este ejemplo, se utilizan una serie de módulos de Node.js para crear, enumerar y eliminar trabajos de transcripción mediante los siguientes métodos de la clase de cliente de `TranscribeService`:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Para obtener más información acerca de los usuarios de Amazon Transcribe, consulte la [Guía para desarrolladores de Amazon Transcribe](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Tareas previas necesarias
<a name="transcribe-example-transcription-jobs"></a>

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/blob/main/javascriptv3/example_code/transcribe/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)

## Cómo iniciar un trabajo de Amazon Transcribe
<a name="transcribe-start-transcription"></a>

En este ejemplo se muestra cómo iniciar un trabajo de transcripción de Amazon Transcribe con AWS SDK for JavaScript. Para obtener más información, consulte [StartTranscriptionJobCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/).

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `transcribeClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente Amazon Transcribe. *REGION*Reemplácelo por su AWS región.

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Puedes encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Cree un módulo de Node.js con el nombre de archivo `transcribe-create-job.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree un objeto de parámetros especificando los parámetros necesarios. Inicie el trabajo mediante el comando `StartMedicalTranscriptionJobCommand`.

**nota**  
*MEDICAL\$1JOB\$1NAME*Sustitúyalo por un nombre para el trabajo de transcripción. Para *OUTPUT\$1BUCKET\$1NAME* especificar el bucket de Amazon S3 en el que se guarda la salida. Para *JOB\$1TYPE* especificar los tipos de trabajo. Para *SOURCE\$1LOCATION* especificar la ubicación del archivo fuente. Para *SOURCE\$1FILE\$1LOCATION* especificar la ubicación del archivo multimedia de entrada.

```
// Import the required AWS SDK clients and commands for Node.js
import { StartTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  TranscriptionJobName: "JOB_NAME",
  LanguageCode: "LANGUAGE_CODE", // For example, 'en-US'
  MediaFormat: "SOURCE_FILE_FORMAT", // For example, 'wav'
  Media: {
    MediaFileUri: "SOURCE_LOCATION",
    // For example, "https://transcribe-demo.s3-REGION.amazonaws.com/hello_world.wav"
  },
  OutputBucketName: "OUTPUT_BUCKET_NAME",
};

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node transcribe-create-job.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/transcribe/src/transcribe_create_job.js).

## Obtener una lista de trabajos de Amazon Transcribe
<a name="transcribe-list-jobs"></a>

Este ejemplo muestra cómo obtener una lista de los trabajos de transcripción de Amazon Transcribe utilizando AWS SDK for JavaScript. Para obtener más información sobre qué otra configuración puede modificar, consulte [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/).

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `transcribeClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente Amazon Transcribe. *REGION*Reemplácelo por su AWS región.

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Puedes encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Cree un módulo de Node.js con el nombre de archivo `transcribe-list-jobs.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree un objeto de parámetros con los parámetros requeridos.

**nota**  
*KEY\$1WORD*Sustitúyalo por una palabra clave que deba contener el nombre de los trabajos devueltos.

```
// Import the required AWS SDK clients and commands for Node.js

import { ListTranscriptionJobsCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  JobNameContains: "KEYWORD", // Not required. Returns only transcription
  // job names containing this string
};

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node transcribe-list-jobs.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/transcribe/src/transcribe_list_jobs.js).

## Eliminar un trabajo de Amazon Transcribe
<a name="transcribe-delete-job"></a>

En este ejemplo, se muestra cómo eliminar un trabajo de transcripción de Amazon Transcribe utilizando AWS SDK for JavaScript. Para obtener más información sobre los elementos opcionales, consulte [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/).

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `transcribeClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente Amazon Transcribe. *REGION*Reemplácelo por su AWS región.

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

Puedes encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Cree un módulo de Node.js con el nombre de archivo `transcribe-delete-job.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Especifique la AWS región y el nombre del trabajo que desea eliminar.

**nota**  
*JOB\$1NAME*Sustitúyalo por el nombre del trabajo que se va a eliminar. 

```
// Import the required AWS SDK clients and commands for Node.js
import { DeleteTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  TranscriptionJobName: "JOB_NAME", // Required. For example, 'transciption_demo'
};

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node transcribe-delete-job.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/transcribe/src/transcribe_delete_job.js).

# Ejemplos de Amazon Transcribe Medical
<a name="transcribe-medical-examples-section"></a>

En este ejemplo, se utilizan una serie de módulos de Node.js para crear, enumerar y eliminar trabajos de transcripción médica mediante los siguientes métodos de la clase de cliente de `TranscribeService`:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Para obtener más información acerca de los usuarios de Amazon Transcribe, consulte la [Guía para desarrolladores de Amazon Transcribe](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Tareas previas necesarias
<a name="transcribe-example-transcription-medical-jobs"></a>

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/blob/main/javascriptv3/example_code/transcribe/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)

## Cómo iniciar un trabajo de transcripción de Amazon Transcribe Medical
<a name="transcribe-start-medical-transcription"></a>

En este ejemplo se muestra cómo iniciar un trabajo de transcripción de Amazon Transcribe Medical utilizando AWS SDK for JavaScript. Para obtener más información, consulte [startMedicalTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/).

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `transcribeClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente Amazon Transcribe. *REGION*Reemplácelo por su AWS región.

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

Puedes encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Cree un módulo de Node.js con el nombre de archivo `transcribe-create-medical-job.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree un objeto de parámetros especificando los parámetros necesarios. Inicie el trabajo médico con el comando `StartMedicalTranscriptionJobCommand`.

**nota**  
*MEDICAL\$1JOB\$1NAME*Sustitúyalo por un nombre para el trabajo de transcripción médica. Para *OUTPUT\$1BUCKET\$1NAME* especificar el bucket de Amazon S3 en el que se guarda la salida. Para *JOB\$1TYPE* especificar los tipos de trabajo. Para *SOURCE\$1LOCATION* especificar la ubicación del archivo fuente. Para *SOURCE\$1FILE\$1LOCATION* especificar la ubicación del archivo multimedia de entrada.

```
// Import the required AWS SDK clients and commands for Node.js
import { StartMedicalTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  MedicalTranscriptionJobName: "MEDICAL_JOB_NAME", // Required
  OutputBucketName: "OUTPUT_BUCKET_NAME", // Required
  Specialty: "PRIMARYCARE", // Required. Possible values are 'PRIMARYCARE'
  Type: "JOB_TYPE", // Required. Possible values are 'CONVERSATION' and 'DICTATION'
  LanguageCode: "LANGUAGE_CODE", // For example, 'en-US'
  MediaFormat: "SOURCE_FILE_FORMAT", // For example, 'wav'
  Media: {
    MediaFileUri: "SOURCE_FILE_LOCATION",
    // The S3 object location of the input media file. The URI must be in the same region
    // as the API endpoint that you are calling.For example,
    // "https://transcribe-demo.s3-REGION.amazonaws.com/hello_world.wav"
  },
};

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node transcribe-create-medical-job.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/transcribe/src/transcribe_create_medical_job.js).

## Obtener una lista de trabajos de Amazon Transcribe Medical
<a name="transcribe-list-medical-jobs"></a>

En este ejemplo, se muestra cómo obtener una lista de los trabajos de transcripción de Amazon Transcribe utilizando AWS SDK for JavaScript. Para obtener más información, consulte [ListTranscriptionMedicalJobsCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListMedicalTranscriptionJobsCommand/).

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `transcribeClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente Amazon Transcribe. *REGION*Reemplácelo por su AWS región.

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Puedes encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Cree un módulo de Node.js con el nombre de archivo `transcribe-list-medical-jobs.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree un objeto de parámetros con los parámetros necesarios y obtenga una lista de los trabajos médicos utilizando el comando `ListMedicalTranscriptionJobsCommand`.

**nota**  
*KEYWORD*Sustitúyalo por una palabra clave que deba contener el nombre de los trabajos devueltos.

```
// Import the required AWS SDK clients and commands for Node.js

import { ListMedicalTranscriptionJobsCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  JobNameContains: "KEYWORD", // Returns only transcription job names containing this string
};

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node transcribe-list-medical-jobs.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/transcribe/src/transcribe_list_medical_jobs.js).

## Eliminar un trabajo de Amazon Transcribe Medical
<a name="transcribe-delete-medical-job"></a>

En este ejemplo, se muestra cómo eliminar un trabajo de transcripción de Amazon Transcribe utilizando AWS SDK for JavaScript. Para obtener más información sobre los elementos opcionales, consulte [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteMedicalTranscriptionJobCommand/).

Cree un directorio `libs` y un módulo Node.js con el nombre de archivo `transcribeClient.js`. Copie y pegue el siguiente código en él, para crear el objeto de cliente Amazon Transcribe. *REGION*Reemplácelo por su AWS región.

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

Puedes encontrar este código de ejemplo [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Cree un módulo de Node.js con el nombre de archivo `transcribe-delete-job.js`. Asegúrese de configurar el SDK como se mostró anteriormente, incluida la instalación de los clientes y paquetes necesarios. Cree un objeto de parámetros con los parámetros necesarios y elimine el trabajo médico utilizando el comando `DeleteMedicalJobCommand`.

**nota**  
*JOB\$1NAME*Sustitúyalo por el nombre del trabajo que se va a eliminar. 

```
// Import the required AWS SDK clients and commands for Node.js
import { DeleteMedicalTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  MedicalTranscriptionJobName: "MEDICAL_JOB_NAME", // For example, 'medical_transciption_demo'
};

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

Para ejecutar el ejemplo, escriba lo siguiente en la línea de comandos.

```
node transcribe-delete-medical-job.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/transcribe/src/transcribe_delete_medical_job.js).

# Configuración de Node.js en una instancia de Amazon EC2
<a name="setting-up-node-on-ec2-instance"></a>

Un escenario habitual para usar Node.js con el SDK JavaScript es configurar y ejecutar una aplicación web Node.js en una instancia de Amazon Elastic Compute Cloud (Amazon EC2). En este tutorial, creará una instancia Linux, se conectará a ella mediante SSH y, a continuación, instalará Node.js para ejecutarse en dicha instancia. 

## Requisitos previos
<a name="setting-up-node-on-ec2-instance.prerequisites"></a>

En este tutorial se presupone que ya ha lanzado una instancia Linux con un nombre de DNS público al que se puede tener acceso desde Internet y al que se puede conectar a través de SSH. Para obtener más información, consulte [Paso 1: Lanzamiento de una instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-launch-instance) en la *Guía del usuario de Amazon EC2*.

**importante**  
Utilice Imagen de máquina de Amazon (AMI) de **Amazon Linux 2023** al ejecutar una nueva instancia de Amazon EC2.

También debe haber configurado el grupo de seguridad para que permita las conexiones `SSH` (puerto 22), ` HTTP` (puerto 80) y `HTTPS` (puerto 443). Para obtener más información sobre estos requisitos previos, consulte [Configuración con Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html) en la *Guía del usuario de Amazon EC2*.

## Procedimiento
<a name="setting-up-node-on-ec2-instance-procedure"></a>

El siguiente procedimiento le será útil para instalar Node.js en una instancia Amazon Linux. Puede utilizar este servidor para alojar una aplicación web de Node.js.

**Para configurar Node.js en su instancia Linux**

1. Conecte su instancia Linux como `ec2-user` mediante SSH.

1. Instale el administrador de versiones de nodos (`nvm`) escribiendo lo siguiente en la línea de comandos.
**aviso**  
AWS no controla el siguiente código. Antes de ejecutarlo, asegúrese de comprobar su autenticidad e integridad. Puede encontrar más información sobre este código en el GitHub repositorio [nvm](https://github.com/nvm-sh/nvm/blob/master/README.md).

   ```
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
   ```

   Utilizaremos `nvm` para instalar Node.js, ya que `nvm` puede instalar varias versiones de Node.js y permitirle alternar entre ellas.

1. Cargue `nvm` escribiendo lo siguiente en la línea de comandos.

   ```
   source ~/.bashrc
   ```

1. Utilice nvm para instalar la última versión de LTS escribiendo lo siguiente en la línea de comandos.

   ```
   nvm install --lts
   ```

   Si instala Node.js también instalará el administrador de paquetes de nodos (`npm`) para poder instalar módulos adicionales según sea necesario.

1. Compruebe que Node.js esté instalado y ejecutándose correctamente, escribiendo lo siguiente en la línea de comandos.

   ```
   node -e "console.log('Running Node.js ' + process.version)"
   ```

   Esto presenta el siguiente mensaje que muestra la versión de Node.js que se está ejecutando.

    `Running Node.js VERSION` 

**nota**  
La instalación del nodo solo se aplica a la sesión actual de Amazon EC2. Si reinicia la sesión de CLI, debe volver a usar nvm para habilitar la versión de nodo instalada. Si la instancia finaliza, debe volver a instalar el nodo. La alternativa es crear una imagen de máquina de Amazon (AMI) de la instancia de Amazon EC2 una vez que tenga la configuración que desea conservar, como se describe en el siguiente tema.

## Creación de una Imagen de máquina de Amazon (AMI)
<a name="setting-up-node-on-ec2-instance-create-image"></a>

Después de instalar Node.js en una instancia de Amazon EC2, puede crear una imagen de máquina de Amazon (AMI) a partir de dicha instancia. Si crea una AMI le será más fácil aprovisionar varias instancias de Amazon EC2 con la misma instalación de Node.js. Para obtener información acerca de cómo crear una AMI a partir de una instancia existente, consulte [Creación de una AMI de Linux con el respaldo de Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) en la *Guía del usuario de Amazon EC2*.

## Recursos relacionados
<a name="setting-up-node-on-ec2-instance-related-resource"></a>

Para obtener más información acerca de los comandos y el software que se utilizan en este tema, visite las siguientes páginas web:
+ Administrador de versiones de nodo (`nvm`): consulte el repositorio de [nvm en](https://github.com/creationix/nvm). GitHub
+ Administrador de paquetes de nodos (`npm`): consulte el [sitio web de npm](https://www.npmjs.com).

# Invocación de Lambda con API Gateway
<a name="api-gateway-invoking-lambda-example"></a>

Puede invocar una función Lambda mediante Amazon API Gateway, que es AWS un servicio para crear, publicar, mantener, supervisar y proteger REST, WebSocket APIs HTTP y a escala. Los desarrolladores de API pueden crear APIs ese acceso AWS u otros servicios web, así como los datos almacenados en la AWS nube. Como desarrollador de API Gateway, puede crear APIs para usarlas en sus propias aplicaciones cliente. Para obtener más información, consulte [Qué es Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) 

AWS Lambda es un servicio informático que le permite ejecutar código sin aprovisionar ni administrar servidores. Puede crear funciones de Lambda en varios lenguajes de programación. Para obtener más información al respecto AWS Lambda, consulte [Qué es AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

En este ejemplo, se crea una función de Lambda mediante la API de tiempo de ejecución de JavaScript Lambda. En este ejemplo, se invocan diferentes AWS servicios para realizar un caso de uso específico. Por ejemplo, supongamos que una organización envía un mensaje de texto al móvil a sus empleados para felicitarles por su primer aniversario, como se muestra en esta ilustración.

![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


Completar el ejemplo debería tomarle aproximadamente 20 minutos.

En este ejemplo, se muestra cómo utilizar JavaScript la lógica para crear una solución que ejecute este caso de uso. Por ejemplo, aprenderá a leer una base de datos para determinar qué empleados han cumplido un año, cómo procesar los datos y cómo enviar un mensaje de texto, todo ello mediante una función de Lambda. A continuación, aprenderá a usar API Gateway para invocar esta AWS Lambda función mediante un punto final de REST. Por ejemplo, puede invocar la función de Lambda con este comando de curl:

```
curl -XGET "https://xxxxqjko1o3.execute-api.us-east-1.amazonaws.com/cronstage/employee" 
```

En este AWS tutorial se utiliza una tabla de Amazon DynamoDB denominada Employee que contiene estos campos.
+ **id**: la clave principal de la tabla.
+ **firstName**: nombre del empleado.
+ **phone**: número de teléfono del empleado.
+ **startDate**: fecha de inicio del empleado.

![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**importante**  
Costo de finalización: los AWS servicios incluidos en este documento están incluidos en la capa AWS gratuita. Sin embargo, asegúrese de cancelar todos los recursos una vez que haya completado este ejemplo para que no se le cobre nada.

**Para crear la aplicación:**

1. [Completar los requisitos previos ](#api-gateway-invoking-lambda-provision-resources)

1. [Cree los AWS recursos](#api-gateway-invoking-lambda-provision-resources)

1. [Preparar el script del navegador ](#api-gateway-invoking-lambda-browser-script)

1. [Crear y cargar una función de Lambda](#api-gateway-invoking-lambda-browser-script)

1. [Implemente la función de Lambda ](#api-gateway-invoking-lambda-deploy-function)

1. [Ejecutar la aplicación](#api-gateway-invoking-lambda-run)

1. [Eliminar los recursos](#api-gateway-invoking-lambda-destroy) 

## Tareas previas necesarias
<a name="api-gateway-invoking-lambda-prerequisites"></a>

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 que figuran en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway/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*.

## Cree los AWS recursos
<a name="api-gateway-invoking-lambda-provision-resources"></a>

Este tutorial requiere los siguientes recursos:
+ Una tabla de Amazon DynamoDB llamada `Employee` con una clave llamada `Id` y los campos que se muestran en la ilustración anterior. Asegúrese de introducir los datos correctos, incluido un teléfono móvil válido con el que quiera probar este caso de uso. Para obtener más información, consulte [Crear una tabla](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Un rol de IAM con permisos adjuntos para ejecutar funciones de Lambda.
+ Un bucket de Amazon S3 para alojar la función de Lambda.

Puede crear estos recursos manualmente, pero le recomendamos que los aprovisione utilizando los métodos CloudFormation descritos en este tutorial.

### Cree los AWS recursos mediante CloudFormation
<a name="api-gateway-invoking-lambda-resources-cli"></a>

CloudFormation le permite crear y aprovisionar despliegues de AWS infraestructura de forma predecible y repetitiva. Para obtener más información al respecto CloudFormation, consulte la Guía del [AWS CloudFormation usuario](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Para crear la CloudFormation pila con AWS CLI:

1. Instale y configure las AWS CLI siguientes instrucciones de la [Guía del AWS CLI usuario](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Cree un archivo con un nombre `setup.yaml` en el directorio raíz de la carpeta de su proyecto y copie [el contenido GitHub en](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/setup.yaml) él.
**nota**  
La CloudFormation plantilla se generó utilizando lo que AWS CDK está [disponible aquí GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lambda_using_api_gateway). Para obtener más información sobre el AWS CDK, consulte la [Guía para AWS Cloud Development Kit (AWS CDK) desarrolladores](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Ejecute el siguiente comando desde la línea de comandos y *STACK\$1NAME* sustitúyalo por un nombre único para la pila.
**importante**  
El nombre de la pila debe ser único en una AWS región y una AWS cuenta. El nombre puede tener una longitud de hasta 128 caracteres, y se permiten números y guiones.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Para obtener más información sobre los parámetros del comando `create-stack`, consulte la [guía de referencia de comandos de AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) y la [Guía del usuario de AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. A continuación, complete la tabla siguiendo el procedimiento [Rellenar la tabla](#api-gateway-invoking-lambda-resources-create-table).

### Rellenar la tabla
<a name="api-gateway-invoking-lambda-resources-create-table"></a>

Para rellenar la tabla, primero cree un directorio con el nombre `libs` y, dentro de él, cree un archivo con el nombre `dynamoClient.js` y pegue en él el contenido que aparece a continuación. 

```
const { DynamoDBClient } = require ( "@aws-sdk/client-dynamodb" );
// Set the AWS Region.
const REGION = "REGION"; // e.g. "us-east-1"
 // Create an Amazon Lambda service client object.
const dynamoClient = new DynamoDBClient({region:REGION});
module.exports = { dynamoClient };
```

 Este código está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/dynamoClient.js).

A continuación, cree un archivo con un nombre `populate-table.js` en el directorio raíz de la carpeta de su proyecto y copie el contenido [aquí GitHub en](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) él. Para uno de los elementos, sustituya el valor de la propiedad `phone` por un número de teléfono móvil válido con el formato E.164, y el valor de `startDate` por la fecha de hoy.

Desde la línea de comandos, ejecute el comando siguiente:

```
node populate-table.js
```

```
const { BatchWriteItemCommand } = require ( "aws-sdk/client-dynamodb" );
const {dynamoClient} = require ( "./libs/dynamoClient" );

// Set the parameters.
export const params = {
  RequestItems: {
    Employees: [
      {
        PutRequest: {
          Item: {
            id: { N: "1" },
            firstName: { S: "Bob" },
            phone: { N: "155555555555654" },
            startDate: { S: "2019-12-20" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "2" },
            firstName: { S: "Xing" },
            phone: { N: "155555555555653" },
            startDate: { S: "2019-12-17" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "55" },
            firstName: { S: "Harriette" },
            phone: { N: "155555555555652" },
            startDate: { S: "2019-12-19" },
          },
        },
      },
    ],
  },
};

export const run = async () => {
  try {
    const data = await dbclient.send(new BatchWriteItemCommand(params));
    console.log("Success", data);
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

 Este código está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js).

## Creando la AWS Lambda función
<a name="api-gateway-invoking-lambda-browser-script"></a>

### Configuración del SDK
<a name="api-gateway-invoking-lambda-configure-sdk"></a>

En el directorio `libs`, cree archivos con los nombres `snsClient.js` y `lambdaClient.js`, y pegue el contenido que aparece a continuación en estos archivos, respectivamente. 

```
const { SNSClient } = require("@aws-sdk/client-sns");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon SNS service client object.
const snsClient = new SNSClient({ region: REGION });
module.exports = { snsClient };
```

 *REGION*Sustitúyala por la AWS región. Este código está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/snsClient.js).

```
const { LambdaClient } = require("@aws-sdk/client-lambda");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Lambda service client object.
const lambdaClient = new LambdaClient({ region: REGION });
module.exports = { lambdaClient };
```

*REGION*Sustitúyalo por la AWS región. Este código está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/lambdaClient.js).

En primer lugar, importe los módulos y comandos necesarios AWS SDK para JavaScript (v3). A continuación, calcule la fecha de hoy y asígnela a un parámetro. En tercer lugar, cree los parámetros para `ScanCommand`. *TABLE\$1NAME*Sustitúyala por el nombre de la tabla que creaste en la [Cree los AWS recursos](#api-gateway-invoking-lambda-provision-resources) sección de este ejemplo.

El siguiente fragmento de código muestra este paso. (Consulte [Agrupación de la función de Lambda](#api-gateway-invoking-lambda-full) para ver el ejemplo completo).

```
const { ScanCommand } = require("@aws-sdk/client-dynamodb");
const { PublishCommand } = require("@aws-sdk/client-sns");
const { snsClient } = require("./libs/snsClient");
const { dynamoClient } = require("./libs/dynamoClient");

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = `${yyyy}-${mm}-${dd}`;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which are the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "Employees",
};
```

### Escaneo de la tabla de DynamoDB
<a name="api-gateway-invoking-lambda-scan-table"></a>

En primer lugar, cree una async/await función llamada `sendText` para publicar un mensaje de texto mediante Amazon SNS`PublishCommand`. A continuación, añada un patrón de bloques `try` que escanee la tabla de DynamoDB en busca de empleados cuyo aniversario laboral sea hoy y, a continuación, llame a la función `sendText` para que envíe un mensaje de texto a estos empleados. Si se produce un error, se llama al bloque `catch`.

El siguiente fragmento de código muestra este paso. (Consulte [Agrupación de la función de Lambda](#api-gateway-invoking-lambda-full) para ver el ejemplo completo).

```
// Helper function to send message using Amazon SNS.
exports.handler = async () => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      await snsClient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to identify employees with work anniversary today.
    const data = await dynamoClient.send(new ScanCommand(params));
    for (const element of data.Items) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message: `Hi ${element.firstName.S}; congratulations on your work anniversary!`,
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    }
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};
```

### Agrupación de la función de Lambda
<a name="api-gateway-invoking-lambda-full"></a>

En este tema se describe cómo agrupar los módulos `mylambdafunction.ts` y los AWS SDK para JavaScript módulos necesarios para este ejemplo en un archivo empaquetado llamado. `index.js` 

1. Si aún no lo ha hecho, siga el [Tareas previas necesarias](#api-gateway-invoking-lambda-prerequisites) para este ejemplo para instalar el paquete web. 
**nota**  
Para obtener información sobre el *paquete web*, consulte [Agrupación de aplicaciones con Webpack](webpack.md).

1. Ejecute lo siguiente en la línea de comandos para agrupar los JavaScript de este ejemplo en un archivo llamado`<index.js>`:

   ```
   webpack mylambdafunction.ts --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**importante**  
Observe que la salida tiene el nombre `index.js`. Esto se debe a que las funciones de Lambda tienen que tener un controlador `index.js` para funcionar.

1. Comprima el archivo de salida empaquetado, `index.js`, en un archivo ZIP denominado `mylambdafunction.zip`.

1. Suba `mylambdafunction.zip` al bucket de Amazon S3 que creó en el tema de [Cree los AWS recursos](#api-gateway-invoking-lambda-provision-resources) de este tutorial. 

## Implemente la función de Lambda
<a name="api-gateway-invoking-lambda-deploy-function"></a>

En la raíz del proyecto, cree un archivo `lambda-function-setup.ts` y pegue en él el contenido siguiente.

*BUCKET\$1NAME*Sustitúyalo por el nombre del bucket de Amazon S3 en el que cargó la versión ZIP de la función Lambda. *ZIP\$1FILE\$1NAME*Sustituya la versión ZIP de la función Lambda por el nombre del nombre. *ROLE*Sustitúyalo por el número de recurso de Amazon (ARN) del rol de IAM que creaste en el [Cree los AWS recursos](#api-gateway-invoking-lambda-provision-resources) tema de este tutorial. *LAMBDA\$1FUNCTION\$1NAME*Sustitúyala por un nombre para la función Lambda.

```
// Load the required Lambda client and commands.
const {
  CreateFunctionCommand
} = require ( "@aws-sdk/client-lambda" );
const { lambdaClient} = require ( "./libs/lambdaClient.js );

// Set the parameters.
const params = {
  Code: {
    S3Bucket: "BUCKET_NAME", // BUCKET_NAME
    S3Key: "ZIP_FILE_NAME", // ZIP_FILE_NAME
  },
  FunctionName: "LAMBDA_FUNCTION_NAME",
  Handler: "index.handler",
  Role: "IAM_ROLE_ARN", // IAM_ROLE_ARN; e.g., arn:aws:iam::650138640062:role/v3-lambda-tutorial-lambda-role
  Runtime: "nodejs12.x",
  Description:
    "Scans a DynamoDB table of employee details and using Amazon Simple Notification Services (Amazon SNS) to " +
    "send employees an email on each anniversary of their start-date.",
};

const run = async () => {
  try {
    const data = await lambdaClient.send(new CreateFunctionCommand(params));
    console.log("Success", data); // successful response
  } catch (err) {
    console.log("Error", err); // an error occurred
  }
};
run();
```

Introduzca lo siguiente en la línea de comandos para implementar la función de Lambda.

```
node lambda-function-setup.ts
```

Este ejemplo de código está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/lambda-function-setup.js).

## Configuración de API Gateway para invocar la función de Lambda
<a name="api-gateway-invoking-lambda-run"></a>

**Para crear la aplicación:**

1. [Cree la API de REST](#api-gateway-invoking-lambda-run-create)

1. [Probar el método de API Gateway](#api-gateway-invoking-lambda-run-test)

1. [Implementar el método de API Gateway](#api-gateway-invoking-lambda-run-deploy)

### Cree la API de REST
<a name="api-gateway-invoking-lambda-run-create"></a>

Puede utilizar la consola API Gateway para crear un punto de conexión para la función de Lambda. Una vez hecho esto, podrá invocar la función de Lambda mediante una llamada restful.



1. Inicie sesión en la [consola Amazon API Gateway](https://console.aws.amazon.com/apigateway).

1. En la API de REST, seleccione **Compilación**.

1. Seleccione **Nueva API**.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/PicNewAPI.png)

1. Especifique **Empleado** como nombre de la API y proporcione una descripción.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picEmployeeAPI.png)

1. Seleccione **Crear API**.

1. Seleccione **Recursos** en la sección **Empleado**.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picResources.png)

1. En el campo de nombre, especifique los **empleados**.

1. Elija **Create Resources (Crear recursos)**.

1. En el menú desplegable **Acciones**, elija **Crear recursos**.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picCreateResources.png)

1. Elija **/empleados**, seleccione **Crear método** en las **Acciones** y, a continuación, seleccione **OBTENER** en el menú desplegable situado debajo de **/empleados**. Elija el icono de marca de verificación.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGet.png)

1. Elija la **función de Lambda** e introduzca **mylambdafunction** como nombre de la función de Lambda. Seleccione **Guardar**.

### Probar el método de API Gateway
<a name="api-gateway-invoking-lambda-run-test"></a>

En este punto del tutorial, puede probar el método de API Gateway que invoca la función de Lambda **mylambdafunction**. Para probar el método, elija **Probar**, como se muestra en la siguiente ilustración.

![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picTest.png)


Una vez que se invoca la función de Lambda, puede ver el archivo de registro para ver un mensaje correcto.

### Implementar el método de API Gateway
<a name="api-gateway-invoking-lambda-run-deploy"></a>

Una vez que la prueba se haya realizado correctamente, podrá implementar el método desde la [consola Amazon API Gateway](https://console.aws.amazon.com/apigateway).

1. Elija **Obtener**.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGetDeploy.png)

1. En el menú desplegable **Acciones**, elija **Implementar API**.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1. Rellene el formulario de **Implementar API** y seleccione **Implementar**.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1.  Elija **Save changes (Guardar cambios)**.

1.  Seleccione **Obtener** de nuevo y observe que la URL cambia. Esta es la URL de invocación que puede utilizar para invocar la función de Lambda.  
![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picURL2.png)

## Elimine los recursos
<a name="api-gateway-invoking-lambda-destroy"></a>

¡Enhorabuena\$1 Ha invocado una función de Lambda a través de Amazon API Gateway usando AWS SDK for JavaScript. Como se indicó al principio de este tutorial, asegúrese de cancelar todos los recursos que cree mientras realiza este tutorial para asegurarse de que no se le cobre nada. Para ello, puedes eliminar la CloudFormation pila que creaste en el [Cree los AWS recursos](#api-gateway-invoking-lambda-provision-resources) tema de este tutorial, de la siguiente manera:

1. Abra la [CloudFormation en la consola AWS de administración]( https://console.aws.amazon.com/cloudformation/home).

1. Abra la página **Pilas** y seleccione la pila.

1. Elija **Eliminar**.

# Crear eventos programados para ejecutar AWS Lambda funciones
<a name="scheduled-events-invoking-lambda-example"></a>

Puedes crear un evento programado que invoque una AWS Lambda función mediante un Amazon CloudWatch Event. Puede configurar un CloudWatch evento para que utilice una expresión cron para programar cuándo se invoca una función Lambda. Por ejemplo, puede programar un CloudWatch evento para que invoque una función Lambda todos los días de la semana.

AWS Lambda es un servicio informático que le permite ejecutar código sin aprovisionar ni administrar servidores. Puede crear funciones de Lambda en varios lenguajes de programación. Para obtener más información AWS Lambda, consulte [Qué es AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

En este tutorial, creará una función de Lambda mediante la API de tiempo de ejecución de JavaScript Lambda. En este ejemplo, se invocan diferentes AWS servicios para realizar un caso de uso específico. Por ejemplo, supongamos que una organización envía un mensaje de texto al móvil a sus empleados para felicitarles por su primer aniversario, como se muestra en esta ilustración.

![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


Completar el tutorial debería tomarle aproximadamente 20 minutos.

En este tutorial, se muestra cómo usar JavaScript la lógica para crear una solución que ejecute este caso de uso. Por ejemplo, aprenderá a leer una base de datos para determinar qué empleados han cumplido un año, cómo procesar los datos y cómo enviar un mensaje de texto, todo ello mediante una función de Lambda. A continuación, aprenderá a utilizar una expresión cron para invocar la función de Lambda todos los días de la semana.

En este AWS tutorial se utiliza una tabla de Amazon DynamoDB denominada Employee que contiene estos campos.
+ **id**: la clave principal de la tabla.
+ **firstName**: nombre del empleado.
+ **phone**: número de teléfono del empleado.
+ **startDate**: fecha de inicio del empleado.

![\[Tabla de DynamoDB\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**importante**  
Costo de finalización: los AWS servicios incluidos en este documento están incluidos en la capa AWS gratuita. Sin embargo, asegúrese de cancelar todos los recursos después de haber completado este tutorial para asegurarse de que no se le cobre nada.

**Para crear la app:**

1. [Completar los requisitos previos ](#scheduled-events-invoking-lambda-provision-resources)

1. [Cree los AWS recursos](#scheduled-events-invoking-lambda-provision-resources)

1. [Preparar el script del navegador ](#scheduled-events-invoking-lambda-browser-script)

1. [Crear y cargar una función de Lambda](#scheduled-events-invoking-lambda-browser-script)

1. [Implemente la función de Lambda ](#scheduled-events-invoking-lambda-deploy-function)

1. [Ejecutar la aplicación](#scheduled-events-invoking-lambda-run)

1. [Eliminar los recursos](#scheduled-events-invoking-lambda-destroy) 

## Tareas previas necesarias
<a name="scheduled-events-invoking-lambda-prerequisites"></a>

Para configurar y ejecutar este ejemplo, primero debe completar estas tareas:
+ Configure el entorno del proyecto para ejecutar estos TypeScript ejemplos de Node.js 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/blob/main/javascriptv3/example_code/cross-services/lex-bot/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*.

## Cree los AWS recursos
<a name="scheduled-events-invoking-lambda-provision-resources"></a>

Este tutorial requiere los siguientes recursos.
+ Una tabla de Amazon DynamoDB llamada **Empleado** con una clave llamada **Id** y los campos que se muestran en la ilustración anterior. Asegúrese de introducir los datos correctos, incluido un teléfono móvil válido con el que quiera probar este caso de uso. Para obtener más información, consulte [Crear una tabla](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Un rol de IAM con permisos adjuntos para ejecutar funciones de Lambda.
+ Un bucket de Amazon S3 para alojar la función de Lambda.

Puede crear estos recursos manualmente, pero le recomendamos que los aprovisione utilizando los métodos CloudFormation descritos en este tutorial.

### Cree los AWS recursos mediante CloudFormation
<a name="scheduled-events-invoking-lambda-resources-cli"></a>

CloudFormation le permite crear y aprovisionar despliegues de AWS infraestructura de forma predecible y repetitiva. Para obtener más información al respecto CloudFormation, consulte la Guía del [AWS CloudFormation usuario](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Para crear la CloudFormation pila con AWS CLI:

1. Instale y configure las AWS CLI siguientes instrucciones de la [Guía del AWS CLI usuario](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Cree un archivo con un nombre `setup.yaml` en el directorio raíz de la carpeta de su proyecto y copie [el contenido GitHub en](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/setup.yaml) él.
**nota**  
La CloudFormation plantilla se generó utilizando lo que AWS CDK está [disponible aquí GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/lambda_using_scheduled_events). Para obtener más información sobre el AWS CDK, consulte la [Guía para AWS Cloud Development Kit (AWS CDK) desarrolladores](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Ejecute el siguiente comando desde la línea de comandos y *STACK\$1NAME* sustitúyalo por un nombre único para la pila.
**importante**  
El nombre de la pila debe ser único en una AWS región y una AWS cuenta. El nombre puede tener una longitud de hasta 128 caracteres, y se permiten números y guiones.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Para obtener más información sobre los parámetros de los comandos `create-stack`, consulte la [Guía de referencia de comandos de AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) y la [Guía del usuario de AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

   Para ver una lista de los recursos en la consola, abre la pila en el CloudFormation panel de control y selecciona la pestaña **Recursos**. Los necesitará para el tutorial. 

1. Cuando se cree la pila, utilícela AWS SDK para JavaScript para rellenar la tabla de DynamoDB, tal y como se describe en. [Rellenar la tabla de DynamoDB](#scheduled-events-invoking-lambda-resources-create-table)

### Rellenar la tabla de DynamoDB
<a name="scheduled-events-invoking-lambda-resources-create-table"></a>

Para rellenar la tabla, primero cree un directorio con el nombre `libs` y, dentro de él, cree un archivo con el nombre `dynamoClient.js` y pegue en él el contenido siguiente. 

```
const { DynamoDBClient } = require( "@aws-sdk/client-dynamodb" );
// Set the AWS Region.
const REGION = "REGION"; // e.g. "us-east-1"
// Create an Amazon DynamoDB service client object.
const dynamoClient = new DynamoDBClient({region:REGION});
module.exports = { dynamoClient };
```

 [Este código está disponible aquí en. GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/libs/dynamoClient.js)

A continuación, cree un archivo con un nombre `populate-table.js` en el directorio raíz de la carpeta de su proyecto y copie el contenido [aquí GitHub en](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) él. Para uno de los elementos, sustituya el valor de la propiedad `phone` por un número de teléfono móvil válido con el formato E.164, y el valor de `startDate` por la fecha de hoy.

Desde la línea de comandos, ejecute el comando siguiente:

```
node populate-table.js
```

```
const {
BatchWriteItemCommand } = require( "aws-sdk/client-dynamodb" );
const {dynamoClient} = require(  "./libs/dynamoClient" );
// Set the parameters.
const params = {
  RequestItems: {
    Employees: [
      {
        PutRequest: {
          Item: {
            id: { N: "1" },
            firstName: { S: "Bob" },
            phone: { N: "155555555555654" },
            startDate: { S: "2019-12-20" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "2" },
            firstName: { S: "Xing" },
            phone: { N: "155555555555653" },
            startDate: { S: "2019-12-17" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "55" },
            firstName: { S: "Harriette" },
            phone: { N: "155555555555652" },
            startDate: { S: "2019-12-19" },
          },
        },
      },
    ],
  },
};

export const run = async () => {
  try {
    const data = await dbclient.send(new BatchWriteItemCommand(params));
    console.log("Success", data);
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

 Este código está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/helper-functions/populate-table.js).

## Creando la AWS Lambda función
<a name="scheduled-events-invoking-lambda-browser-script"></a>

### Configuración del SDK
<a name="scheduled-events-invoking-lambda-configure-sdk"></a>

En primer lugar, importe los módulos y comandos necesarios AWS SDK para JavaScript (v3): `ScanCommand` DynamoDB `DynamoDBClient` y `SNSClient` el comando Amazon SNS. `PublishCommand` Sustitúyalo por *REGION* la región. AWS A continuación, calcule la fecha de hoy y asígnela a un parámetro. A continuación, cree los parámetros del `ScanCommand` archivo .Replace *TABLE\$1NAME* por el nombre de la tabla que creó en la [Cree los AWS recursos](#scheduled-events-invoking-lambda-provision-resources) sección de este ejemplo.

El siguiente fragmento de código muestra este paso. (Consulte [Agrupación de la función de Lambda](#scheduled-events-invoking-lambda-full) para ver el ejemplo completo).

```
"use strict";
// Load the required clients and commands.
const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");

//Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = yyyy + "-" + mm + "-" + dd;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which the the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "TABLE_NAME",
};
```

### Escaneo de la tabla de DynamoDB
<a name="scheduled-events-invoking-lambda-scan-table"></a>

Primero cree una async/await función llamada `sendText` publicar un mensaje de texto utilizando Amazon SNS`PublishCommand`. A continuación, añada un patrón de bloques `try` que escanee la tabla de DynamoDB en busca de empleados cuyo aniversario laboral sea hoy y, a continuación, llame a la función `sendText` para que envíe un mensaje de texto a estos empleados. Si se produce un error, se llama al bloque `catch`.

El siguiente fragmento de código muestra este paso. (Consulte [Agrupación de la función de Lambda](#scheduled-events-invoking-lambda-full) para ver el ejemplo completo).

```
exports.handler = async (event, context, callback) => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      const data = await snsclient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to check identify employees with work anniversary today.
    const data = await dbclient.send(new ScanCommand(params));
    data.Items.forEach(function (element, index, array) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message:
          "Hi " +
          element.firstName.S +
          "; congratulations on your work anniversary!",
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    });
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};
```

### Agrupación de la función de Lambda
<a name="scheduled-events-invoking-lambda-full"></a>

En este tema se describe cómo agrupar los módulos `mylambdafunction.js` y los AWS SDK para JavaScript módulos necesarios para este ejemplo en un archivo empaquetado llamado. `index.js` 

1. Si aún no lo ha hecho, siga [Tareas previas necesarias](#scheduled-events-invoking-lambda-prerequisites) para este ejemplo para instalar Webpack. 
**nota**  
Para obtener más información sobre *Webpack*, consulte [Agrupación de aplicaciones con Webpack](webpack.md).

1. Ejecute lo siguiente en la línea de comandos para agrupar el objeto de este JavaScript ejemplo en un archivo llamado`<index.js>`:

   ```
   webpack mylamdbafunction.js --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**importante**  
Observe que la salida tiene el nombre `index.js`. Esto se debe a que las funciones de Lambda tienen que tener un controlador `index.js` para funcionar.

1. Comprima el archivo de salida empaquetado, `index.js`, en un archivo ZIP denominado `my-lambda-function.zip`.

1. Suba `mylambdafunction.zip` al bucket de Amazon S3 que creó en el tema [Cree los AWS recursos](#scheduled-events-invoking-lambda-provision-resources) de este tutorial. 

Este es el código completo del script del navegador para `mylambdafunction.js`.

```
"use strict";
// Load the required clients and commands.
const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");

//Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = yyyy + "-" + mm + "-" + dd;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which the the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "TABLE_NAME",
};

// Create the client service objects.
const dbclient = new DynamoDBClient({ region: REGION });
const snsclient = new SNSClient({ region: REGION });

exports.handler = async (event, context, callback) => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      const data = await snsclient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to check identify employees with work anniversary today.
    const data = await dbclient.send(new ScanCommand(params));
    data.Items.forEach(function (element, index, array) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message:
          "Hi " +
          element.firstName.S +
          "; congratulations on your work anniversary!",
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    });
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};
```

## Implementar la función de Lambda
<a name="scheduled-events-invoking-lambda-deploy-function"></a>

En la raíz del proyecto, cree un archivo `lambda-function-setup.js` y pegue en él el contenido siguiente.

*BUCKET\$1NAME*Sustitúyalo por el nombre del bucket de Amazon S3 en el que cargó la versión ZIP de la función Lambda. *ZIP\$1FILE\$1NAME*Sustituya la versión ZIP de la función Lambda por el nombre del nombre. *IAM\$1ROLE\$1ARN*Sustitúyalo por el número de recurso de Amazon (ARN) del rol de IAM que creaste en el [Cree los AWS recursos](#scheduled-events-invoking-lambda-provision-resources) tema de este tutorial. *LAMBDA\$1FUNCTION\$1NAME*Sustitúyala por un nombre para la función Lambda.

```
// Load the required Lambda client and commands.
const {
   CreateFunctionCommand,
} = require("@aws-sdk/client-lambda");
const {
   lambdaClient
} = require("..libs/lambdaClient.js");

// Instantiate an Lambda client service object.
const lambda = new LambdaClient({ region: REGION });

// Set the parameters.
const params = {
  Code: {
    S3Bucket: "BUCKET_NAME", // BUCKET_NAME
    S3Key: "ZIP_FILE_NAME", // ZIP_FILE_NAME
  },
  FunctionName: "LAMBDA_FUNCTION_NAME",
  Handler: "index.handler",
  Role: "IAM_ROLE_ARN", // IAM_ROLE_ARN; e.g., arn:aws:iam::650138640062:role/v3-lambda-tutorial-lambda-role
  Runtime: "nodejs12.x",
  Description:
    "Scans a DynamoDB table of employee details and using Amazon Simple Notification Services (Amazon SNS) to " +
    "send employees an email the each anniversary of their start-date.",
};

const run = async () => {
  try {
    const data = await lambda.send(new CreateFunctionCommand(params));
    console.log("Success", data); // successful response
  } catch (err) {
    console.log("Error", err); // an error occurred
  }
};
run();
```

Introduzca lo siguiente en la línea de comandos para implementar la función de Lambda.

```
node lambda-function-setup.js
```

Este ejemplo de código está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/helper-functions/lambda-function-setup.js).

## Configurar CloudWatch para invocar las funciones Lambda
<a name="scheduled-events-invoking-lambda-run"></a>

 CloudWatch Para configurar la invocación de las funciones Lambda:

1. Abra la página de **Funciones** en la consola de Lambda.

1. Elija la función de Lambda.

1. En **Diseñador**, elija **Añadir disparador**.

1. **Establezca el tipo de disparador en Events/CloudWatch . EventBridge**

1. En Regla, seleccione **Crear una nueva regla**.

1.  Rellene el nombre y la descripción de la regla.

1. Para el tipo de regla, seleccione **Expresión de programación**.

1. En el campo **Expresión de programación**, introduzca una expresión cron. Por ejemplo, **cron(0 12 ? \$1 MON-FRI \$1)**.

1. Elija **Añadir**.
**nota**  
Para obtener más información, consulte [Uso de Lambda con CloudWatch eventos](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html).

## Elimine los recursos
<a name="scheduled-events-invoking-lambda-destroy"></a>

¡Enhorabuena\$1 Ha invocado una función Lambda a través de eventos CloudWatch programados de Amazon mediante. AWS SDK para JavaScript Como se indicó al principio de este tutorial, asegúrese de cancelar todos los recursos que cree mientras realiza este tutorial para asegurarse de que no se le cobre nada. Para ello, puede eliminar la CloudFormation pila que creó en el [Cree los AWS recursos](#scheduled-events-invoking-lambda-provision-resources) tema de este tutorial, de la siguiente manera:

1. Abra la [consola de AWS CloudFormation]( https://console.aws.amazon.com/cloudformation/home).

1. En la página **Pilas**, seleccione la pila.

1. Elija **Eliminar**.

# Creación de un chatbot de Amazon Lex
<a name="lex-bot-example"></a>

Puede crear un chatbot de Amazon Lex dentro de una aplicación web para atraer a los visitantes de su sitio web. Un chatbot de Amazon Lex es una funcionalidad que realiza conversaciones de chat en línea con los usuarios sin proporcionar contacto directo con una persona. Por ejemplo, en la siguiente ilustración se muestra un chatbot de Amazon Lex que interactúa con un usuario para que reserve una habitación de hotel.

![\[Chatbot interface demonstrating a hotel booking conversation with user inputs and bot responses.\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/lex_example/chatintro.png)


El chatbot Amazon Lex creado en este AWS tutorial puede manejar varios idiomas. Por ejemplo, un usuario que habla francés puede introducir texto en francés y obtener una respuesta en francés.

![\[Chatbot interface demonstrating Amazon Lex integration with French language support.\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot2.png)


Del mismo modo, un usuario puede comunicarse con el chatbot de Amazon Lex en italiano.

![\[Chat interface showing Italian language exchange between user and Amazon Lex chatbot.\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot3.png)


Este AWS tutorial le guía a través de la creación de un chatbot de Amazon Lex y su integración en una aplicación web de Node.js. El AWS SDK para JavaScript (v3) se utiliza para invocar estos servicios: AWS 
+ Amazon Lex
+ Amazon Comprehend
+ Amazon Translate

**Costo de finalización:** los AWS servicios incluidos en este documento están incluidos en la capa [AWS gratuita](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc).

**Nota:** Recuerde cancelar todos los recursos que cree mientras sigue este tutorial para asegurarse de que no se le cobre nada.

**Para crear la app:**

1. [Requisitos previos](#lex-bot-example-prerequisites)

1. [Aprovisionar recursos](#lex-bot-provision-resources)

1. [Cree el chatbot de Amazon Lex](#lex-bot-example-create-lex-bot)

1. [Cree el HTML](#lex-bot-example-html)

1. [Cree el script del navegador](#lex-bot-example-script)

1. [Pasos siguientes](#lex-bot-example-next-steps)

## Requisitos previos
<a name="lex-bot-example-prerequisites"></a>

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/cross-services/lambda-scheduled-events/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 este ejemplo se usa 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).  
No obstante, si prefiere utilizar la sintaxis CommonJS, consulte [Sintaxis ES6/commonJS de JavaScript](sdk-example-javascript-syntax.md).

## Crea los AWS recursos
<a name="lex-bot-provision-resources"></a>

Este tutorial requiere los siguientes recursos.
+ Un rol de IAM no autenticado con permisos adjuntos para:
  + Amazon Comprehend
  + Amazon Translate
  + Amazon Lex

Puede crear estos recursos manualmente, pero le recomendamos que los aprovisione tal y AWS CloudFormation como se describe en este tutorial.

### Cree los AWS recursos mediante CloudFormation
<a name="lex-bot-example-resources-cli"></a>

CloudFormation le permite crear y aprovisionar despliegues de AWS infraestructura de forma predecible y repetitiva. Para obtener más información al respecto CloudFormation, consulte la Guía del [AWS CloudFormation usuario](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Para crear la CloudFormation pila con AWS CLI:

1. Instale y configure las AWS CLI siguientes instrucciones de la [Guía del AWS CLI usuario](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Cree un archivo con un nombre `setup.yaml` en el directorio raíz de la carpeta de su proyecto y copie [el contenido GitHub en](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/setup.yaml) él.
**nota**  
La CloudFormation plantilla se generó utilizando lo que AWS CDK está [disponible aquí GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lex_bot_example_iam_unauth_role). Para obtener más información sobre el AWS CDK, consulte la [Guía para AWS Cloud Development Kit (AWS CDK) desarrolladores](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Ejecute el siguiente comando desde la línea de comandos y *STACK\$1NAME* sustitúyalo por un nombre único para la pila.
**importante**  
El nombre de la pila debe ser único en una AWS región y una AWS cuenta. El nombre puede tener una longitud de hasta 128 caracteres, y se permiten números y guiones.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Para obtener más información sobre los parámetros de los comandos `create-stack`, consulte la [Guía de referencia de comandos AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) y la [Guía del usuario de AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

   Para ver los recursos creados, abra la consola Amazon Lex, elija la pila y seleccione la pestaña **Recursos**.

## Crear un bot de Amazon Lex
<a name="lex-bot-example-create-lex-bot"></a>

**importante**  
Utilice la versión 1 de la consola Amazon Lex para crear el bot. Este ejemplo no funciona con los bots creados con la V2.

El primer paso es crear un chatbot de Amazon Lex mediante la consola de administración de Amazon Web Services. En este ejemplo, se utiliza el **BookTrip**ejemplo de Amazon Lex. Para obtener más información, consulte [Book Trip](https://docs.aws.amazon.com/lex/latest/dg/ex-book-trip.html).
+ Inicie sesión en la consola de administración de Amazon Web Services y abra la consola Amazon Lex en la [consola de Amazon Web Services](https://console.aws.amazon.com/lex/).
+ En la página Bots, elija **Crear**.
+ Elija el **BookTrip**plano (deje el nombre del bot predeterminado **BookTrip**).  
![\[Interface for creating a chatbot, showing BookTrip sample with conversation flow and components.\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/lex_example/pic2.png)
+ Rellena la configuración predeterminada y selecciona **Crear** (la consola muestra el **BookTrip**bot). En la pestaña Editor, revise los detalles de la intención preconfigurada ().
+ Pruebe el bot en la ventana de pruebas. Comience la prueba escribiendo *Quiero reservar una habitación de hotel*.  
![\[Chat interface showing a hotel booking conversation with a bot asking for the city.\]](http://docs.aws.amazon.com/es_es/sdk-for-javascript/v3/developer-guide/images/lex_example/ChatBotTest.png)
+ Elija **Publicar** y especifique un nombre de alias (necesitará este valor cuando utilice AWS SDK para JavaScript).

**nota**  
 Debes hacer referencia al **nombre** y al **alias del bot** en tu JavaScript código.

## Creación del HTML
<a name="lex-bot-example-html"></a>

Cree un archivo denominado `index.html`. Copie y pegue el siguiente código en `index.html`. Este HTML hace referencia a `main.js`. Se trata de una versión integrada de index.js, que incluye los AWS SDK para JavaScript módulos necesarios. Creará este archivo en [Creación del HTML](#lex-bot-example-html). `index.html` también hace referencia a `style.css`, que añade los estilos. 

```
<!doctype html>
<head>
  <title>Amazon Lex - Sample Application (BookTrip)</title>
  <link type="text/css" rel="stylesheet" href="style.css" />
</head>

<body>
  <h1 id="title">Amazon Lex - BookTrip</h1>
  <p id="intro">
    This multiple language chatbot shows you how easy it is to incorporate
    <a
      href="https://aws.amazon.com/lex/"
      title="Amazon Lex (product)"
      target="_new"
      >Amazon Lex</a
    >
    into your web apps. Try it out.
  </p>
  <div id="conversation"></div>
  <input
    type="text"
    id="wisdom"
    size="80"
    value=""
    placeholder="J'ai besoin d'une chambre d'hôtel"
  />
  <br />
  <button onclick="createResponse()">Send Text</button>
  <script type="text/javascript" src="./main.js"></script>
</body>
```

Este código también está disponible [aquí en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk#running-a-cdk-app).

## Crear el script del navegador
<a name="lex-bot-example-script"></a>

Cree un archivo denominado `index.js`. Copie y pegue el siguiente código `index.js` Importe los AWS SDK para JavaScript módulos y comandos necesarios. Cree clientes para Amazon Lex, Amazon Comprehend y Amazon Translate. *REGION*Sustitúyalos por AWS Región y *IDENTITY\$1POOL\$1ID* por el ID del grupo de identidades que creaste en[Crea los AWS recursos](#lex-bot-provision-resources). Para recuperar este ID del grupo de identidades, abra el grupo de identidades en la consola Amazon Cognito, seleccione **Editar grupo de identidades** y elija **Código de muestra** en el menú lateral. Anote el ID del grupo de identidades que se muestra en rojo en la consola.

En primer lugar, cree un directorio `libs` y cree los objetos de cliente de servicio necesarios mediante la creación de tres archivos, `comprehendClient.js`, `lexClient.js` y `translateClient.js`. Pegue el código correspondiente que aparece a continuación en cada uno de ellos *REGION* y reemplace y *IDENTITY\$1POOL\$1ID* en cada archivo.

**nota**  
Utilice el ID del grupo de identidades de Amazon Cognito que creó en [Cree los AWS recursos mediante CloudFormation](#lex-bot-example-resources-cli).

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { ComprehendClient } from "@aws-sdk/client-comprehend";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Comprehend service client object.
const comprehendClient = new ComprehendClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { comprehendClient };
```

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { LexRuntimeServiceClient } from "@aws-sdk/client-lex-runtime-service";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Lex service client object.
const lexClient = new LexRuntimeServiceClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { lexClient };
```

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { TranslateClient } from "@aws-sdk/client-translate";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Translate service client object.
const translateClient = new TranslateClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { translateClient };
```

Este código está disponible [aquí en GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/libs) .

A continuación, cree un archivo `index.js` y pegue en él el siguiente código.

 Sustituya *BOT\$1ALIAS* y *BOT\$1NAME* por el alias y el nombre de su bot de Amazon Lex, respectivamente, y *USER\$1ID* por un seudónimo. La función asíncrona de `createResponse` hace lo siguiente:
+ Toma el texto introducido por el usuario en el navegador y utiliza Amazon Comprehend para determinar el código de su idioma.
+ Toma el código del idioma y utiliza Amazon Translate para traducir el texto al inglés.
+ Toma el texto traducido y utiliza Amazon Lex para generar una respuesta.
+ Publica la respuesta en la página del navegador.

```
import { DetectDominantLanguageCommand } from "@aws-sdk/client-comprehend";
import { TranslateTextCommand } from "@aws-sdk/client-translate";
import { PostTextCommand } from "@aws-sdk/client-lex-runtime-service";
import { lexClient } from "./libs/lexClient.js";
import { translateClient } from "./libs/translateClient.js";
import { comprehendClient } from "./libs/comprehendClient.js";

let g_text = "";
// Set the focus to the input box.
document.getElementById("wisdom").focus();

function showRequest() {
  const conversationDiv = document.getElementById("conversation");
  const requestPara = document.createElement("P");
  requestPara.className = "userRequest";
  requestPara.appendChild(document.createTextNode(g_text));
  conversationDiv.appendChild(requestPara);
  conversationDiv.scrollTop = conversationDiv.scrollHeight;
}

function showResponse(lexResponse) {
  const conversationDiv = document.getElementById("conversation");
  const responsePara = document.createElement("P");
  responsePara.className = "lexResponse";

  const lexTextResponse = lexResponse;

  responsePara.appendChild(document.createTextNode(lexTextResponse));
  responsePara.appendChild(document.createElement("br"));
  conversationDiv.appendChild(responsePara);
  conversationDiv.scrollTop = conversationDiv.scrollHeight;
}

function handletext(text) {
  g_text = text;
  const xhr = new XMLHttpRequest();
  xhr.addEventListener("load", loadNewItems, false);
  xhr.open("POST", "../text", true); // A Spring MVC controller
  xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded"); //necessary
  xhr.send(`text=${text}`);
}

function loadNewItems() {
  showRequest();

  // Re-enable input.
  const wisdomText = document.getElementById("wisdom");
  wisdomText.value = "";
  wisdomText.locked = false;
}

// Respond to user's input.
const createResponse = async () => {
  // Confirm there is text to submit.
  const wisdomText = document.getElementById("wisdom");
  if (wisdomText?.value && wisdomText.value.trim().length > 0) {
    // Disable input to show it is being sent.
    const wisdom = wisdomText.value.trim();
    wisdomText.value = "...";
    wisdomText.locked = true;
    handletext(wisdom);

    const comprehendParams = {
      Text: wisdom,
    };
    try {
      const data = await comprehendClient.send(
        new DetectDominantLanguageCommand(comprehendParams),
      );
      console.log(
        "Success. The language code is: ",
        data.Languages[0].LanguageCode,
      );
      const translateParams = {
        SourceLanguageCode: data.Languages[0].LanguageCode,
        TargetLanguageCode: "en", // For example, "en" for English.
        Text: wisdom,
      };
      try {
        const data = await translateClient.send(
          new TranslateTextCommand(translateParams),
        );
        console.log("Success. Translated text: ", data.TranslatedText);
        const lexParams = {
          botName: "BookTrip",
          botAlias: "mynewalias",
          inputText: data.TranslatedText,
          userId: "chatbot", // For example, 'chatbot-demo'.
        };
        try {
          const data = await lexClient.send(new PostTextCommand(lexParams));
          console.log("Success. Response is: ", data.message);
          const msg = data.message;
          showResponse(msg);
        } catch (err) {
          console.log("Error responding to message. ", err);
        }
      } catch (err) {
        console.log("Error translating text. ", err);
      }
    } catch (err) {
      console.log("Error identifying language. ", err);
    }
  }
};
// Make the function available to the browser.
window.createResponse = createResponse;
```

Este código está disponible [aquí en GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/index.html) .

Ahora use webpack para agrupar los AWS SDK para JavaScript módulos `index.js` y en un solo archivo,`main.js`.

1. Si aún no lo ha hecho, siga [Requisitos previos](#lex-bot-example-prerequisites) para este ejemplo para instalar Webpack. 
**nota**  
Para obtener más información sobre *Webpack*, consulte [Agrupación de aplicaciones con Webpack](webpack.md).

1. Ejecute lo siguiente en la línea de comandos JavaScript para agrupar este ejemplo en un archivo llamado`main.js`:

   ```
   webpack index.js --mode development --target web --devtool false -o main.js
   ```

## Siguientes pasos
<a name="lex-bot-example-next-steps"></a>

¡Enhorabuena\$1 Ha creado una aplicación Node.js que utiliza Amazon Lex para crear una experiencia de usuario interactiva. Como se indicó al principio de este tutorial, asegúrese de cancelar todos los recursos que cree mientras realiza este tutorial para asegurarse de que no se le cobre nada. Para ello, puede eliminar la CloudFormation pila que creó en el [Crea los AWS recursos](#lex-bot-provision-resources) tema de este tutorial, de la siguiente manera:

1. Abra la [consola de AWS CloudFormation]( https://console.aws.amazon.com/cloudformation/home).

1. En la página **Pilas**, seleccione la pila.

1. Elija **Eliminar**.

Para obtener más ejemplos de AWS servicios cruzados, consulte ejemplos de [AWS SDK para JavaScript servicios cruzados.](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/tutorials.html)