Le [guide de référence de l'API AWS SDK pour JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) décrit en détail toutes les opérations de l'API pour la AWS SDK pour JavaScript version 3 (V3). 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# SDK pour les exemples de JavaScript code
<a name="sdk-code-samples"></a>

Les rubriques de cette section contiennent des exemples d'utilisation AWS SDK pour JavaScript APIs de différents services pour effectuer des tâches courantes.

Trouvez le code source de ces exemples et d'autres dans le [référentiel d'exemples de AWS code sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples). Pour proposer un nouvel exemple de code que l'équipe de AWS documentation pourrait envisager de produire, créez une demande. L'équipe cherche à produire des exemples de code qui couvrent des scénarios et des cas d'utilisation plus larges, plutôt que de simples extraits de code qui couvrent uniquement les appels d'API individuels. Pour obtenir des instructions, consultez la section *Code de création* dans les [directives de contribution sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md).

**Important**  
Ces exemples utilisent la syntaxe d' ECMAScript6 import/export.   
Cela nécessite la version 14.17 ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez les directives [JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md) de conversion.

**Topics**
+ [

# JavaScript ES6Syntaxe /CommonJS
](sdk-example-javascript-syntax.md)
+ [

# AWS Elemental MediaConvert exemples
](emc-examples.md)
+ [

# AWS Lambda exemples
](lambda-examples.md)
+ [

# Exemples Amazon Lex
](lex-examples.md)
+ [

# Exemples d'Amazon Polly
](polly-examples.md)
+ [

# Exemples d'Amazon Redshift
](redshift-examples.md)
+ [

# Exemples d'Amazon Simple Email Service
](ses-examples.md)
+ [

# Exemples du service de notification Amazon Simple
](sns-examples.md)
+ [

# Exemples d'Amazon Transcribe
](Transcribe-examples.md)
+ [

# Configuration de Node.js sur une instance Amazon EC2
](setting-up-node-on-ec2-instance.md)
+ [

# Invoquer Lambda avec API Gateway
](api-gateway-invoking-lambda-example.md)
+ [

# Création d'événements planifiés pour exécuter AWS Lambda des fonctions
](scheduled-events-invoking-lambda-example.md)
+ [

# Création d’un chatbot Amazon Lex
](lex-bot-example.md)

# JavaScript ES6Syntaxe /CommonJS
<a name="sdk-example-javascript-syntax"></a>

Les exemples de AWS SDK pour JavaScript code sont écrits en ECMAScript 6 (ES6). ES6 apporte une nouvelle syntaxe et de nouvelles fonctionnalités pour rendre votre code plus moderne et lisible, et faire plus encore. 

ES6 nécessite que vous utilisiez Node.js version 13.x ou supérieure. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) Toutefois, si vous préférez, vous pouvez convertir n'importe lequel de nos exemples en syntaxe CommonJS en suivant les directives suivantes :
+ `"type" : "module"`Supprimez-le de `package.json` l'environnement de votre projet.
+ Convertissez toutes les ES6 `import` instructions en instructions CommonJS`require`. Par exemple, convertissez :

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

  À son équivalent CommonJS :

  ```
  const { CreateBucketCommand } = require("@aws-sdk/client-s3");
  const { s3 } = require("./libs/s3Client.js");
  ```
+ Convertissez toutes les ES6 `export` instructions en instructions CommonJS`module.exports`. Par exemple, convertissez :

  ```
  export {s3}
  ```

  À son équivalent CommonJS :

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

L'exemple suivant illustre l'exemple de code permettant de créer un compartiment Amazon S3 à la fois dans CommonJS ES6 et dans 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();
```

------

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

AWS Elemental MediaConvert est un service de transcodage vidéo basé sur des fichiers doté de fonctionnalités adaptées à la diffusion. Vous pouvez l'utiliser pour créer des ressources destinées à la diffusion et à la diffusion video-on-demand (VOD) sur Internet. Pour plus d’informations, consultez le [Guide de l’utilisateur *AWS Elemental MediaConvert *](https://docs.aws.amazon.com/mediaconvert/latest/ug/).

L' JavaScript API pour MediaConvert est exposée via la classe `MediaConvert` client. Pour plus d'informations, consultez [Class : MediaConvert](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/) dans la référence de l'API.

**Topics**
+ [

# Création et gestion de tâches de transcodage dans MediaConvert
](emc-examples-jobs.md)
+ [

# Utilisation de modèles de tâches dans MediaConvert
](emc-examples-templates.md)

# Création et gestion de tâches de transcodage dans MediaConvert
<a name="emc-examples-jobs"></a>

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

**Cet exemple de code Node.js présente :**
+ Comment créer des tâches de transcodage dans. MediaConvert
+ Procédure d'annulation d'une tâche de transcodage.
+ Procédure de récupération de l'objet JSON pour une tâche de transcodage terminée.
+ Procédure de récupération d'un tableau JSON pour jusqu'à 20 tâches créées en dernier.

## Le scénario
<a name="emc-examples-jobs-scenario"></a>

Dans cet exemple, vous utilisez un module Node.js à appeler pour MediaConvert créer et gérer des tâches de transcodage. Le code utilise le SDK pour ce JavaScript faire en utilisant les méthodes suivantes de la classe MediaConvert client :
+ [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/)

## Tâches préalables
<a name="emc-examples-jobs-prerequisites"></a>

Pour configurer et exécuter cet exemple, réalisez tout d'abord les tâches ci-après :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions indiquées sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.
+ Créez et configurez des compartiments Amazon S3 qui fournissent du stockage pour les fichiers d'entrée et de sortie des tâches. Pour plus de détails, voir [Création d'un espace de stockage pour les fichiers](https://docs.aws.amazon.com/mediaconvert/latest/ug/set-up-file-locations.html) dans le *Guide de AWS Elemental MediaConvert l'utilisateur*.
+ Téléchargez la vidéo d'entrée dans le compartiment Amazon S3 que vous avez configuré pour le stockage d'entrée. *Pour obtenir la liste des codecs et conteneurs vidéo d'entrée pris en charge, consultez la section Codecs et conteneurs [d'entrée pris en charge dans le guide de l'utilisateur](https://docs.aws.amazon.com/mediaconvert/latest/ug/reference-codecs-containers-input.html).AWS Elemental MediaConvert *
+ Créez un rôle IAM qui donne MediaConvert accès à vos fichiers d'entrée et aux compartiments Amazon S3 dans lesquels vos fichiers de sortie sont stockés. Pour plus de détails, consultez la section [Configurer les autorisations IAM](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) dans le *guide de l'AWS Elemental MediaConvert utilisateur*.

**Important**  
Cet exemple utilise ECMAScript6 (ES6). Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .  
Toutefois, si vous préférez utiliser la syntaxe CommonJS, veuillez vous référer à[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Définition d'une tâche de transcodage simple
<a name="emc-examples-jobs-spec"></a>

Créez un module Node.js nommé `emc_createjob.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez le code JSON qui définit les paramètres de tâche de transcodage.

Ces paramètres sont assez détaillés. Vous pouvez utiliser la [AWS Elemental MediaConvert console](https://console.aws.amazon.com/mediaconvert/) pour générer les paramètres de tâche JSON en choisissant vos paramètres de tâche dans la console, puis en choisissant **Afficher le JSON de la tâche** en bas de la section **Job**. Cet exemple illustre le code JSON pour une tâche simple.

**Note**  
*JOB\$1QUEUE\$1ARN*Remplacez-le par la file d'attente *IAM\$1ROLE\$1ARN* des MediaConvert tâches, par le nom de ressource Amazon (ARN) du rôle IAM, *OUTPUT\$1BUCKET\$1NAME* par le nom du compartiment de destination, par exemple, « s3://OUTPUT\$1BUCKET\$1NAME/ », et *INPUT\$1BUCKET\$1AND\$1FILENAME* par le compartiment d'entrée et le nom du fichier, par exemple, « 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",
    },
  },
};
```

## Création d'une tâche de transcodage
<a name="emc-examples-jobs-create"></a>

Après avoir créé les paramètres de tâche au format JSON, appelez la `run` méthode asynchrone pour appeler un objet de service `MediaConvert` client en transmettant les paramètres. L'ID de la tâche créée est renvoyé dans les données `data` de la réponse.

```
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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node emc_createjob.js 
```

Cet exemple de code complet se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_createjob.js).

## Annulation d'une tâche de transcodage
<a name="emc-examples-jobs-cancel"></a>

Créez un module Node.js nommé `emc_canceljob.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en téléchargeant les clients et les packages requis. Créez l'objet JSON qui inclut l'ID de la tâche à annuler. Appelez ensuite la `CancelJobCommand` méthode en créant une promesse pour invoquer un objet de service `MediaConvert` client, en transmettant les paramètres. Traitez la réponse dans le rappel de promesse.

**Note**  
Remplacez *JOB\$1ID* par l'ID de la tâche à annuler.

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node ec2_canceljob.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_canceljob.js).

## Liste des travaux de transcodage récents
<a name="emc-examples-jobs-listing"></a>

Créez un module Node.js nommé `emc_listjobs.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez les paramètres JSON, y compris des valeurs indiquant s'il faut trier la liste en `ASCENDING` fonction ou en `DESCENDING` ordre, de l'Amazon Resource Name (ARN) de la file d'attente de tâches à vérifier et du statut des tâches à inclure. Appelez ensuite la `ListJobsCommand` méthode en créant une promesse pour invoquer un objet de service `MediaConvert` client, en transmettant les paramètres. 

**Note**  
*QUEUE\$1ARN*Remplacez-le par le Amazon Resource Name (ARN) de la file d'attente de tâches à vérifier et *STATUS* par le statut de la file d'attente.

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node emc_listjobs.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_listjobs.js).

# Utilisation de modèles de tâches dans MediaConvert
<a name="emc-examples-templates"></a>

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

**Cet exemple de code Node.js présente :**
+ Comment créer des modèles de AWS Elemental MediaConvert tâches.
+ Procédure d'utilisation d'un modèle de tâche pour créer une tâche de transcodage.
+ Procédure permettant de répertorier tous vos modèles de tâche.
+ Procédure de suppression des modèles de tâche.

## Le scénario
<a name="emc-examples-templates-scenario"></a>

Le JSON requis pour créer une tâche de transcodage dans MediaConvert est détaillé et contient un grand nombre de paramètres. Vous pouvez simplifier considérablement la création des tâches en enregistrant les paramètres que vous savez appropriés dans un modèle de tâche, que vous utiliserez par la suite pour créer d'autres tâches. Dans cet exemple, vous utilisez un module Node.js à appeler MediaConvert pour créer, utiliser et gérer des modèles de tâches. Le code utilise le SDK pour ce JavaScript faire en utilisant les méthodes suivantes de la classe MediaConvert client :
+ [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/)

## Tâches préalables
<a name="emc-example-templates-prerequisites"></a>

Pour configurer et exécuter cet exemple, réalisez tout d'abord les tâches ci-après :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions indiquées sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.
+ Créez un rôle IAM qui donne MediaConvert accès à vos fichiers d'entrée et aux compartiments Amazon S3 dans lesquels vos fichiers de sortie sont stockés. Pour plus de détails, consultez la section [Configurer les autorisations IAM](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) dans le *guide de l'AWS Elemental MediaConvert utilisateur*.

**Important**  
Ces exemples utilisent ECMAScript6 (ES6). Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .  
Toutefois, si vous préférez utiliser la syntaxe CommonJS, veuillez vous référer à[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Création d'un modèle de tâche
<a name="emc-examples-templates-create"></a>

Créez un module Node.js nommé `emc_create_jobtemplate.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Spécifiez l'objet JSON des paramètres pour la création du modèle. Vous pouvez utiliser la plupart des paramètres JSON issus d'une tâche antérieure réussie afin de spécifier les valeurs `Settings` du modèle. Cet exemple utilise les paramètres de tâche de [Création et gestion de tâches de transcodage dans MediaConvert](emc-examples-jobs.md).

Appelez la `CreateJobTemplateCommand` méthode en créant une promesse pour appeler un objet de service `MediaConvert` client, en transmettant les paramètres.

**Note**  
Remplacez-le *JOB\$1QUEUE\$1ARN* par le nom de ressource Amazon (ARN) de la file d'attente des tâches à vérifier et *BUCKET\$1NAME* par le nom du compartiment Amazon S3 de destination, par exemple « 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node emc_create_jobtemplate.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_create_jobtemplate.js).

## Création d'une tâche de transcodage à partir d'un modèle de tâche
<a name="emc-examples-templates-createjob"></a>

Créez un module Node.js nommé `emc_template_createjob.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez l'objet JSON des paramètres de création de tâche, en incluant le nom du modèle de tâche à utiliser et les `Settings` à utiliser propres à la tâche que vous créez. Appelez ensuite la `CreateJobsCommand` méthode en créant une promesse pour invoquer un objet de service `MediaConvert` client, en transmettant les paramètres. 

**Note**  
*JOB\$1QUEUE\$1ARN*Remplacez-le par le nom de ressource Amazon (ARN) de la file d'attente de tâches pour vérifier, *KEY\$1PAIR\$1NAME* *TEMPLATE\$1NAME* avec, *ROLE\$1ARN* avec le nom de ressource Amazon (ARN) du rôle, ainsi * INPUT\$1BUCKET\$1AND\$1FILENAME* que par le compartiment d'entrée et le nom du fichier, par exemple, « 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node emc_template_createjob.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Répertorier vos modèles de tâches
<a name="emc-examples-templates-listing"></a>

Créez un module Node.js nommé `emc_listtemplates.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet afin de transmettre les paramètres de demande pour la méthode `listTemplates` de la classe client `MediaConvert`. Incluez les valeurs permettant de déterminer quels modèles répertorier (`NAME`, `CREATION DATE`, `SYSTEM`), combien de modèles répertorier et leur ordre de tri. Pour appeler la `ListTemplatesCommand` méthode, créez une promesse pour appeler un objet de service MediaConvert client en transmettant les paramètres. 

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node emc_listtemplates.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Supprimer un modèle de tâche
<a name="emc-examples-templates-delete"></a>

Créez un module Node.js nommé `emc_deletetemplate.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet qui permettra de transmettre le nom du modèle de tâche que vous souhaitez supprimer en tant que paramètres de la méthode `DeleteJobTemplateCommand` de la classe client `MediaConvert`. Pour appeler la `DeleteJobTemplateCommand` méthode, créez une promesse pour appeler un objet de service MediaConvert client en transmettant les paramètres. 

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node emc_deletetemplate.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_deletetemplate.js).

# AWS Lambda exemples
<a name="lambda-examples"></a>

AWS Lambda est un service de calcul sans serveur qui vous permet d'exécuter du code sans provisionner ni gérer de serveurs, créer une logique de dimensionnement des clusters adaptée à la charge de travail, gérer les intégrations d'événements ou gérer les temps d'exécution. 

L' JavaScript API pour AWS Lambda est exposée via la classe [LambdaService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lambda/)client.

Voici une liste d'exemples qui montrent comment créer et utiliser des fonctions Lambda avec la AWS SDK pour JavaScript version 3 :
+ [Invoquer Lambda avec API Gateway](api-gateway-invoking-lambda-example.md)
+ [Création d'événements planifiés pour exécuter AWS Lambda des fonctions](scheduled-events-invoking-lambda-example.md)

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

Amazon Lex est un AWS service permettant de créer des interfaces conversationnelles dans des applications utilisant la voix et le texte. 

L' JavaScript API d'Amazon Lex est exposée via la classe client [Lex Runtime Service](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lex-runtime-service/).
+ [Création d’un chatbot Amazon Lex](lex-bot-example.md)

# Exemples d'Amazon Polly
<a name="polly-examples"></a>

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

**Cet exemple de code Node.js présente :**
+ Importer du contenu audio enregistré à l'aide d'Amazon Polly vers Amazon S3

## Le scénario
<a name="polly-example-synthesize-to-s3-scenario"></a>

Dans cet exemple, une série de modules Node.js sont utilisés pour télécharger automatiquement le son enregistré à l'aide d'Amazon Polly vers Amazon S3 en utilisant les méthodes suivantes de la classe client 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/)

## Tâches préalables
<a name="polly-example-synthesize-to-s3-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez un environnement de projet pour exécuter JavaScript des exemples de nœuds en suivant les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/s3/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.
+ Créez une enquête de rôle d'utilisateur Amazon Cognito non authentifiée Gestion des identités et des accès AWS (IAM) : autorisations, SynthesizeSpeech et un pool d'identités Amazon Cognito auquel le rôle IAM est associé. La [Créez les AWS ressources à l'aide du CloudFormation](#polly-example-synthesize-to-s3-create-resources) section ci-dessous décrit comment créer ces ressources.

**Note**  
Cet exemple utilise Amazon Cognito, mais si vous n'utilisez pas Amazon Cognito, AWS votre utilisateur doit avoir la politique d'autorisation IAM suivante  

****  

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

## Créez les AWS ressources à l'aide du CloudFormation
<a name="polly-example-synthesize-to-s3-create-resources"></a>

CloudFormation vous permet de créer et de provisionner des déploiements AWS d'infrastructure de manière prévisible et répétée. Pour plus d'informations CloudFormation, consultez le [guide de AWS CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Pour créer la CloudFormation pile :

1. Installez et configurez en AWS CLI suivant les instructions du [guide de l'AWS CLI utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Créez un fichier nommé `setup.yaml` dans le répertoire racine du dossier de votre projet et [ GitHubcopiez-y le](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/polly/general-examples/src/setup.yaml) contenu. 
**Note**  
Le CloudFormation modèle a été généré à l'aide du modèle AWS CDK [disponible ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/javascript_example_code_polly_aws_service/). Pour plus d'informations à ce sujet AWS CDK, consultez le [guide du AWS Cloud Development Kit (AWS CDK) développeur](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Exécutez la commande suivante depuis la ligne de commande, en la *STACK\$1NAME* remplaçant par un nom unique pour la pile.
**Important**  
Le nom de la pile doit être unique au sein d'une AWS région et d'un AWS compte. Vous pouvez spécifier jusqu'à 128 caractères. Les chiffres et les tirets sont autorisés.

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

   Pour plus d'informations sur les paramètres de `create-stack` commande, consultez le [guide de référence des AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) et le [guide de CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. Accédez à la console CloudFormation de gestion, choisissez **Stacks**, choisissez le nom de la pile, puis cliquez sur l'onglet **Ressources** pour afficher la liste des ressources créées.  
![\[CloudFormation ressources\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/cfn_polly.png)

## Importer du contenu audio enregistré à l'aide d'Amazon Polly vers Amazon S3
<a name="polly-example-synthesize-to-s3-example"></a>

Créez un module Node.js nommé `polly_synthesize_to_s3.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Dans le code, entrez le*REGION*, et le*BUCKET\$1NAME*. Pour accéder à Amazon Polly, créez un objet de service `Polly` client. *"IDENTITY\$1POOL\$1ID"*Remplacez-le par `IdentityPoolId` celui de la **page d'exemple** du pool d'identités Amazon Cognito que vous avez créé pour cet exemple. Ceci est également transmis à chaque objet client.

Appelez la `StartSpeechSynthesisCommand` méthode de l'objet du service client Amazon Polly, synthétisez le message vocal et chargez-le dans le compartiment 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();
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/polly/general-examples/src/polly_synthesize_to_s3.js).

# Exemples d'Amazon Redshift
<a name="redshift-examples"></a>

Amazon Redshift est un service d’entrepôt des données entièrement géré dans le cloud. Un entrepôt des données Amazon Redshift est un ensemble de ressources informatiques appelées *nœuds*, qui sont organisées en un groupe appelé *cluster*. Chaque cluster exécute un moteur Amazon Redshift et contient une ou plusieurs bases de données.

![\[Relation entre JavaScript les environnements, le SDK et Amazon Redshift\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/code-samples-redshift.png)


L' JavaScript API d'Amazon Redshift est exposée via la classe client [Amazon Redshift](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/Redshift/).

**Topics**
+ [

# Exemples d'Amazon Redshift
](redshift-examples-section.md)

# Exemples d'Amazon Redshift
<a name="redshift-examples-section"></a>

Dans cet exemple, une série de modules Node.js sont utilisés pour créer, modifier, décrire les paramètres des clusters Amazon Redshift, puis les supprimer à l'aide des méthodes suivantes de la classe `Redshift` client :
+ [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/)

Pour plus d'informations sur les utilisateurs d'Amazon Redshift, consultez le guide de démarrage d'[Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html).

## Tâches préalables
<a name="s3-example-configuring-buckets-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions indiquées sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment importer/exporter des objets de service client et des commandes à l'aide de ECMAScript6 ()ES6.  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, voir [JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md)

## Création d'un cluster Amazon Redshift
<a name="redshift-create-cluster"></a>

Cet exemple montre comment créer un cluster Amazon Redshift à l'aide du. AWS SDK pour JavaScript Pour de plus amples informations, veuillez consulter [CreateCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_CreateCluster).

**Important**  
*Le cluster que vous êtes sur le point de créer est actif (et ne fonctionne pas dans un sandbox). Des frais d'utilisation sont perçus pour l'utilisation d'Amazon Redshift pour le cluster jusqu'à ce que vous le supprimiez. Si vous supprimez le cluster au cours de la même séance que lors de sa création, les frais totaux sont minimes.* 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`redshiftClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Redshift. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Créez un module Node.js nommé `redshift-create-cluster.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez un objet de paramètres, en spécifiant le type de nœud à provisionner, les informations d'identification de connexion principale pour l'instance de base de données créée automatiquement dans le cluster, et enfin le type de cluster.

**Note**  
Remplacez *CLUSTER\$1NAME* par le nom du cluster. Pour *NODE\$1TYPE* spécifier le type de nœud à provisionner, tel que « dc2.large », par exemple. *MASTER\$1USERNAME*et *MASTER\$1USER\$1PASSWORD* sont les informations d'identification de connexion de l'utilisateur principal de votre instance de base de données dans le cluster. Pour*CLUSTER\$1TYPE*, entrez le type de cluster. Si vous le spécifiez`single-node`, vous n'avez pas besoin du `NumberOfNodes` paramètre. Les autres paramètres sont facultatifs. 

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node redshift-create-cluster.js  
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-create-cluster.js).

## Modifier un cluster Amazon Redshift
<a name="redshift-modify-cluster"></a>

Cet exemple montre comment modifier le mot de passe utilisateur principal d'un cluster Amazon Redshift à l'aide du. AWS SDK pour JavaScript Pour plus d'informations sur les autres paramètres que vous pouvez modifier, consultez [ModifyCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_ModifyCluster.html).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`redshiftClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Redshift. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Créez un module Node.js nommé `redshift-modify-cluster.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Spécifiez la AWS région, le nom du cluster que vous souhaitez modifier et le nouveau mot de passe de l'utilisateur principal.

**Note**  
*CLUSTER\$1NAME*Remplacez-le par le nom du cluster et *MASTER\$1USER\$1PASSWORD* par le nouveau mot de passe de l'utilisateur principal. 

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node redshift-modify-cluster.js 
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-modify-cluster.js).

## Afficher les détails d'un cluster Amazon Redshift
<a name="redshift-describe-cluster"></a>

Cet exemple montre comment afficher les détails d'un cluster Amazon Redshift à l'aide du. AWS SDK pour JavaScript Pour plus d'informations sur les options facultatives, consultez [DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`redshiftClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Redshift. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Créez un module Node.js nommé `redshift-describe-clusters.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Spécifiez la AWS région, le nom du cluster que vous souhaitez modifier et le nouveau mot de passe de l'utilisateur principal.

**Note**  
Remplacez *CLUSTER\$1NAME* par le nom du cluster. 

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node redshift-describe-clusters.js 
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-describe-clusters.js).

## Supprimer un cluster Amazon Redshift
<a name="redshift-delete-cluster"></a>

Cet exemple montre comment afficher les détails d'un cluster Amazon Redshift à l'aide du. AWS SDK pour JavaScript Pour plus d'informations sur les autres paramètres que vous pouvez modifier, consultez [DeleteCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DeleteCluster.html).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`redshiftClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Redshift. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Créez un module Node.js avec le nom du fichier`redshift-delete-clusters.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Spécifiez la AWS région, le nom du cluster que vous souhaitez modifier et le nouveau mot de passe de l'utilisateur principal. Spécifiez ensuite si vous souhaitez enregistrer un instantané final du cluster avant de le supprimer et, dans l'affirmative, l'ID de l'instantané.

**Note**  
Remplacez *CLUSTER\$1NAME* par le nom du cluster. Pour le*SkipFinalClusterSnapshot*, spécifiez s'il faut créer un instantané final du cluster avant de le supprimer. Si vous spécifiez « faux », spécifiez l'identifiant du cliché final du cluster dans*CLUSTER\$1SNAPSHOT\$1ID*. **Vous pouvez obtenir cet identifiant en cliquant sur le lien dans la colonne **Snapshots** du cluster sur le tableau de bord des **clusters**, puis en faisant défiler la page vers le bas jusqu'au volet Snapshots.** Notez que le radical ne `rs:` fait pas partie de l'identifiant du cliché.

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node redshift-delete-cluster.js  
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-delete-cluster.js).

# Exemples d'Amazon Simple Email Service
<a name="ses-examples"></a>

Amazon Simple Email Service (Amazon SES) est un service d'envoi d'e-mails basé sur le cloud conçu pour aider les spécialistes du marketing numérique et les développeurs d'applications à envoyer des e-mails marketing, de notification et transactionnels. C'est un service fiable et rentable pour les entreprises de toutes tailles utilisant les e-mails pour rester en contact avec leurs clients.

![\[Relation entre JavaScript les environnements, le SDK et Amazon SES\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)


L' JavaScript API d'Amazon SES est exposée par le biais de la classe `SES` client. Pour plus d'informations sur l'utilisation de la classe client Amazon SES, consultez [Classe : SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/) dans le Guide de référence des API.

**Topics**
+ [

# Gestion des identités Amazon SES
](ses-examples-managing-identities.md)
+ [

# Utilisation de modèles d'e-mail dans Amazon SES
](ses-examples-creating-template.md)
+ [

# Envoi d'e-mails à l'aide d'Amazon SES
](ses-examples-sending-email.md)

# Gestion des identités Amazon SES
<a name="ses-examples-managing-identities"></a>

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

**Cet exemple de code Node.js présente :**
+ Comment vérifier les adresses e-mail et les domaines utilisés avec Amazon SES.
+ Comment attribuer une politique Gestion des identités et des accès AWS (IAM) à vos identités Amazon SES.
+ Comment répertorier toutes les identités Amazon SES associées à votre AWS compte.
+ Comment supprimer les identités utilisées avec Amazon SES

Une *identité* Amazon SES est une adresse e-mail ou un domaine qu'Amazon SES utilise pour envoyer des e-mails. Amazon SES vous demande de vérifier votre identité e-mail, de confirmer que vous en êtes le propriétaire et d'empêcher les autres de les utiliser.

Pour en savoir plus sur la façon de vérifier les adresses e-mail et les domaines dans Amazon SES, consultez la section [Vérification des adresses e-mail et des domaines dans Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) dans le manuel Amazon Simple Email Service Developer Guide. Pour plus d'informations sur l'autorisation d'envoi dans Amazon SES, consultez [Présentation de l'autorisation d'envoi Amazon SES](Amazon Simple Email Service Developer Guidesending-authorization-overview.html).

## Le scénario
<a name="ses-examples-verifying-identities-scenario"></a>

Dans cet exemple, vous utilisez une série de modules Node.js pour vérifier et gérer les identités Amazon SES. Les modules Node.js utilisent le SDK JavaScript pour vérifier les adresses e-mail et les domaines, en utilisant les méthodes suivantes de la classe `SES` client :
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/)

## Tâches préalables
<a name="ses-examples-verifying-identities-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Répertorier vos identités
<a name="ses-examples-listing-identities"></a>

Dans cet exemple, utilisez un module Node.js pour répertorier les adresses e-mail et les domaines à utiliser avec Amazon SES.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_listidentities.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre le paramètre `IdentityType` ainsi que les autres paramètres de la méthode `ListIdentitiesCommand` de la classe client `SES`. Pour appeler la `ListIdentitiesCommand` méthode, appelez un objet de service Amazon SES en transmettant l'objet de paramètres. 

 Le `data` résultat contient un tableau d'identités de domaine tel que spécifié par le `IdentityType` paramètre.

**Note**  
Remplacez *IdentityType* par le type d'identité, qui peut être EmailAddress « » ou « Domaine ».

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node ses_listidentities.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js).

## Vérification d'une identité d'adresse e-mail
<a name="ses-examples-verifying-email"></a>

Dans cet exemple, utilisez un module Node.js pour vérifier les expéditeurs d'e-mails à utiliser avec Amazon SES.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_verifyemailidentity.js`. Configurez le SDK comme indiqué précédemment, notamment en téléchargeant les clients et les packages requis. 

Créez un objet pour transmettre le paramètre `EmailAddress` ainsi que les autres paramètres de la méthode `VerifyEmailIdentityCommand` de la classe client `SES`. Pour appeler la `VerifyEmailIdentityCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres. 

**Note**  
Remplacez *EMAIL\$1ADDRESS* par l'adresse e-mail, telle que 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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Le domaine est ajouté à Amazon SES pour être vérifié.

```
node ses_verifyemailidentity.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js).

## Vérification de l'identité d'un domaine
<a name="ses-examples-verifying-domains"></a>

Dans cet exemple, utilisez un module Node.js pour vérifier les domaines de messagerie à utiliser avec Amazon SES.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_verifydomainidentity.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre le paramètre `Domain` ainsi que les autres paramètres de la méthode `VerifyDomainIdentityCommand` de la classe client `SES`. Pour appeler la `VerifyDomainIdentityCommand` méthode, appelez un objet du service client Amazon SES en transmettant l'objet de paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
Remplacez *DOMAIN\$1NAME* par le nom de domaine.

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Le domaine est ajouté à Amazon SES pour être vérifié.

```
node ses_verifydomainidentity.js  
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js).

## Supprimer des identités
<a name="ses-examples-deleting-identities"></a>

Dans cet exemple, utilisez un module Node.js pour supprimer les adresses e-mail ou les domaines utilisés avec Amazon SES.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_deleteidentity.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre le paramètre `Identity` ainsi que les autres paramètres de la méthode `DeleteIdentityCommand` de la classe client `SES`. Pour appeler la `DeleteIdentityCommand` méthode, créez un `request` pour appeler un objet de service client Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
Remplacez *IDENTITY\$1EMAIL* par l'e-mail de l'identité à supprimer.

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node ses_deleteidentity.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js).

# Utilisation de modèles d'e-mail dans Amazon SES
<a name="ses-examples-creating-template"></a>

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

**Cet exemple de code Node.js présente :**
+ Comment obtenir une liste de tous vos modèles d'e-mails.
+ Comment récupérer et mettre à jour des modèles d'e-mails.
+ Comment créer et supprimer des modèles d'e-mails.

Amazon SES vous permet d'envoyer des e-mails personnalisés à l'aide de modèles d'e-mail. Pour en savoir plus sur la création et l'utilisation de modèles d'e-mails dans Amazon SES, consultez la section [Envoi d'e-mails personnalisés à l'aide de l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html) dans le manuel Amazon Simple Email Service Developer Guide.

## Le scénario
<a name="ses-examples-creating-template-scenario"></a>

Dans cet exemple, vous utilisez une série de modules Node.js à utiliser avec des modèles d'e-mail. Les modules Node.js utilisent le SDK pour JavaScript créer et utiliser des modèles de courrier électronique en utilisant les méthodes suivantes de la classe `SES` client :
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/)

## Tâches préalables
<a name="ses-examples-creating-template-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Répertorier vos modèles d'e-mails
<a name="ses-examples-listing-templates"></a>

Dans cet exemple, utilisez un module Node.js pour créer un modèle d'e-mail à utiliser avec Amazon SES. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_listtemplates.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre les paramètres de la méthode `ListTemplatesCommand` de la classe client `SES`. Pour appeler la `ListTemplatesCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes 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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Amazon SES renvoie la liste des modèles.

```
node ses_listtemplates.js  
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js).

## Obtenir un modèle d'e-mail
<a name="ses-examples-get-template"></a>

Dans cet exemple, utilisez un module Node.js pour obtenir un modèle d'e-mail à utiliser avec Amazon SES.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_gettemplate.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre le paramètre `TemplateName` ainsi que les autres paramètres de la méthode `GetTemplateCommand` de la classe client `SES`. Pour appeler la `GetTemplateCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
Remplacez *TEMPLATE\$1NAME* par le nom du modèle à renvoyer.

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Amazon SES renvoie les détails du modèle.

```
node ses_gettemplate.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js).

## Création d'un modèle d'e-mail
<a name="ses-examples-create-template"></a>

Dans cet exemple, utilisez un module Node.js pour créer un modèle d'e-mail à utiliser avec Amazon SES. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_createtemplate.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre les paramètres de la méthode `CreateTemplateCommand` de la classe client `SES`, y compris `TemplateName`, `HtmlPart`, `SubjectPart` et `TextPart`. Pour appeler la `CreateTemplateCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
Remplacez-le *TEMPLATE\$1NAME* par le nom du nouveau modèle, *HtmlPart* par le contenu balisé HTML de l'e-mail et *SubjectPart* par l'objet de l'e-mail.

```
import { CreateTemplateCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";

const TEMPLATE_NAME = getUniqueName("TestTemplateName");

const createCreateTemplateCommand = () => {
  return new CreateTemplateCommand({
    /**
     * The template feature in Amazon SES is based on the Handlebars template system.
     */
    Template: {
      /**
       * The name of an existing template in Amazon SES.
       */
      TemplateName: TEMPLATE_NAME,
      HtmlPart: `
        <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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Le modèle est ajouté à Amazon SES.

```
node ses_createtemplate.js  
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js).

## Mise à jour d'un modèle d'e-mail
<a name="ses-examples-update-template"></a>

Dans cet exemple, utilisez un module Node.js pour créer un modèle d'e-mail à utiliser avec Amazon SES. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_updatetemplate.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre les valeurs de paramètre `Template` que vous souhaitez mettre à jour dans le modèle, avec le paramètre `TemplateName` obligatoire transmis à la méthode `UpdateTemplateCommand` de la classe client `SES`. Pour appeler la `UpdateTemplateCommand` méthode, appelez un objet de service Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
*TEMPLATE\$1NAME*Remplacez-le par le nom du modèle et *HTML\$1PART* par le contenu HTML balisé de l'e-mail.

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Amazon SES renvoie les détails du modèle.

```
node ses_updatetemplate.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js).

## Suppression d'un modèle d'e-mail
<a name="ses-examples-delete-template"></a>

Dans cet exemple, utilisez un module Node.js pour créer un modèle d'e-mail à utiliser avec Amazon SES. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_deletetemplate.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre le paramètre`TemplateName` obligatoire à la méthode `DeleteTemplateCommand` de la classe client `SES`. Pour appeler la `DeleteTemplateCommand` méthode, appelez un objet de service Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
Remplacez *TEMPLATE\$1NAME* par le nom du modèle à supprimer.

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. Amazon SES renvoie les détails du modèle.

```
node ses_deletetemplate.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js).

# Envoi d'e-mails à l'aide d'Amazon SES
<a name="ses-examples-sending-email"></a>

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

**Cet exemple de code Node.js présente :**
+ L'envoi d'un texte ou d'un e-mail au format HTML.
+ L'envoi d'e-mails basés sur un modèle d'e-mail.
+ L'envoi d'e-mails en bloc basés sur un modèle d'e-mail.

L'API Amazon SES vous permet d'envoyer un e-mail de deux manières différentes, en fonction du niveau de contrôle que vous souhaitez obtenir sur la composition du message : formaté et brut. Pour plus de détails, consultez [Envoi d'e-mails formatés à l'aide de l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html) et [Envoi d'e-mails bruts à l'aide de l'API Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).

## Le scénario
<a name="ses-examples-sending-email-scenario"></a>

Dans cet exemple, vous utilisez une série de modules Node.js pour envoyer un e-mail de plusieurs façons. Les modules Node.js utilisent le SDK pour JavaScript créer et utiliser des modèles de courrier électronique en utilisant les méthodes suivantes de la classe `SES` client :
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/)

## Tâches préalables
<a name="ses-examples-sending-emails-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Exigences relatives à l'envoi de messages électroniques
<a name="ses-examples-sending-msail-reqs"></a>

Amazon SES rédige un e-mail et le met immédiatement en file d'attente pour envoi. Pour envoyer un e-mail à l'aide de la méthode `SendEmailCommand`, votre message doit répondre aux exigences suivantes :
+ Vous devez envoyer le message à partir d'une adresse e-mail ou d'un domaine vérifié(e). Si vous essayez d'envoyer un e-mail à l'aide d'une adresse ou d'un domaine non vérifié(e), cela engendre une erreur `"Email address not verified"`.
+ Si votre compte est encore dans l'environnement de test (sandbox) Amazon SES, vous pouvez uniquement envoyer un e-mail à des adresses ou des domaines vérifiés, ou à des adresses e-mail associées au simulateur de boîte de réception Amazon SES. Pour plus d'informations, consultez la section [Vérification des adresses e-mail et des domaines](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) dans le manuel Amazon Simple Email Service Developer Guide.
+ La taille totale du message, pièces jointes comprises, doit être inférieure à 10 Mo.
+ Le message doit inclure au moins un destinataire. L'adresse e-mail du destinataire peut se trouver dans le champ À :, Cc : ou Cci :. Si l'adresse e-mail d'un destinataire n'est pas valide (c'est-à-dire qu'elle n'est pas au format`UserName@[SubDomain.]Domain.TopLevelDomain`), le message entier est rejeté, même s'il contient d'autres destinataires valides.
+ Le message ne peut pas inclure plus de 50 destinataires dans les champs To :, CC : et BCC :. Si vous avez besoin d'envoyer un e-mail à davantage de personnes, vous pouvez diviser votre liste de destinataires en groupes de 50 ou moins, puis appeler la méthode `sendEmail` plusieurs fois pour envoyer le message à chaque groupe.

## Envoi d'un e-mail
<a name="ses-examples-sendmail"></a>

Dans cet exemple, utilisez un module Node.js pour envoyer un e-mail avec Amazon SES. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_sendemail.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre les valeurs des paramètres qui définissent l'e-mail à envoyer, y compris les adresses de l'expéditeur et du destinataire, l'objet et le corps de l'e-mail au format texte brut et HTML, à la `SendEmailCommand` méthode de la classe `SES` client. Pour appeler la `SendEmailCommand` méthode, appelez un objet de service Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
Remplacez *toAddress* par l'adresse à laquelle envoyer l'e-mail et *fromAddress* par l'adresse e-mail à partir de laquelle l'e-mail doit être envoyé.

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. L'e-mail est mis en file d'attente pour être envoyé par Amazon SES.

```
node ses_sendemail.js 
```

Cet exemple de code se [trouve ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js). 

## Envoi d'un e-mail à l'aide d'un modèle
<a name="ses-examples-sendtemplatedemail"></a>

Dans cet exemple, utilisez un module Node.js pour envoyer un e-mail avec Amazon SES. Créez un module Node.js nommé `ses_sendtemplatedemail.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre les valeurs de paramètre qui définissent l'e-mail à envoyer, y compris l'expéditeur et le destinataire, l'objet, le corps du message en texte brut ou au format HTML, à la méthode `SendTemplatedEmailCommand` de la classe client `SES`. Pour appeler la `SendTemplatedEmailCommand` méthode, appelez un objet du service client Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
Remplacez *REGION* par votre AWS région, *USER* par le nom et l'adresse e-mail auxquels envoyer l'e-mail, *VERIFIED\$1EMAIL* par l'adresse e-mail à partir de laquelle envoyer l'e-mail et *TEMPLATE\$1NAME* par le nom du modèle.

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. L'e-mail est mis en file d'attente pour être envoyé par Amazon SES.

```
node ses_sendtemplatedemail.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js).

## Envoi d'e-mails en masse à l'aide d'un modèle
<a name="ses-examples-sendbulktemplatedemail"></a>

Dans cet exemple, utilisez un module Node.js pour envoyer un e-mail avec Amazon SES. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`sesClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SES. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Créez un module Node.js nommé `ses_sendbulktemplatedemail.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. 

Créez un objet pour transmettre les valeurs des paramètres qui définissent l'e-mail à envoyer, y compris les adresses de l'expéditeur et du destinataire, l'objet et le corps de l'e-mail au format texte brut et HTML, à la `SendBulkTemplatedEmailCommand` méthode de la classe `SES` client. Pour appeler la `SendBulkTemplatedEmailCommand` méthode, appelez un objet de service Amazon SES en transmettant les paramètres. 

**Note**  
Cet exemple importe et utilise les clients du package AWS Service V3 requis, les commandes V3, et utilise la `send` méthode selon un async/await modèle. Vous pouvez créer cet exemple à l'aide des commandes V2 en apportant quelques modifications mineures. Pour en savoir plus, consultez [Utilisation des commandes v3](migrating.md#using_v3_commands).

**Note**  
Remplacez-le *USERS* par les noms et adresses e-mail auxquels envoyer l'e-mail, *VERIFIED\$1EMAIL\$11* par l'adresse e-mail à partir de laquelle l'e-mail doit être envoyé et *TEMPLATE\$1NAME* par le nom du modèle.

```
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;
  }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande. L'e-mail est mis en file d'attente pour être envoyé par Amazon SES.

```
node ses_sendbulktemplatedemail.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js). 

# Exemples du service de notification Amazon Simple
<a name="sns-examples"></a>

Amazon Simple Notification Service (Amazon SNS) est un service Web qui coordonne et gère la livraison ou l'envoi de messages aux points de terminaison ou aux clients abonnés. 

Sur Amazon SNS, il existe deux types de clients, les éditeurs et les abonnés, également appelés producteurs et consommateurs. 

![\[Relation entre JavaScript les environnements, le SDK et Amazon SNS\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/code-samples-sns.png)


Les éditeurs communiquent de façon asynchrone avec les abonnés en produisant et en envoyant un message à une rubrique, qui est un point d'accès logique et un canal de communication. Les abonnés (serveurs Web, adresses e-mail, files d'attente Amazon SQS, AWS Lambda fonctions) consomment ou reçoivent le message ou la notification via l'un des protocoles pris en charge (Amazon SQS, HTTP/S, e-mail, SMS AWS Lambda) lorsqu'ils sont abonnés au sujet. 

L' JavaScript API d'Amazon SNS est exposée par le biais de la [classe :](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SNS/) SNS. 

**Topics**
+ [

# Gestion des rubriques dans Amazon SNS
](sns-examples-managing-topics.md)
+ [

# Publication de messages sur Amazon SNS
](sns-examples-publishing-messages.md)
+ [

# Gestion des abonnements sur Amazon SNS
](sns-examples-subscribing-unsubscribing-topics.md)
+ [

# Envoi de SMS avec Amazon SNS
](sns-examples-sending-sms.md)

# Gestion des rubriques dans Amazon SNS
<a name="sns-examples-managing-topics"></a>

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

**Cet exemple de code Node.js présente :**
+ Comment créer des rubriques dans Amazon SNS sur lesquelles vous pouvez publier des notifications.
+ Comment supprimer des sujets créés dans Amazon SNS.
+ Comment obtenir une liste des rubriques disponibles.
+ Comment obtenir et définir des attributs de rubrique.

## Scénario
<a name="sns-examples-managing-topics-scenario"></a>

Dans cet exemple, vous utilisez une série de modules Node.js pour créer, répertorier et supprimer des rubriques Amazon SNS, ainsi que pour gérer les attributs des rubriques. Les modules Node.js utilisent le SDK pour gérer les sujets JavaScript à l'aide des méthodes suivantes de la classe `SNS` client :
+ [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/)

## Tâches prérequises
<a name="sns-examples-managing-topics-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions indiquées sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Création d'une rubrique
<a name="sns-examples-managing-topics-createtopic"></a>

Dans cet exemple, utilisez un module Node.js pour créer une rubrique Amazon SNS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `create-topic.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet pour transmettre le paramètre`Name` de la nouvelle rubrique à la méthode `CreateTopicCommand` de la classe client `SNS`. Pour appeler la `CreateTopicCommand` méthode, créez une fonction asynchrone invoquant un objet de service Amazon SNS, en transmettant l'objet de paramètres. Le `data` résultat contient l'ARN du sujet.

**Note**  
Remplacez *TOPIC\$1NAME* par le nom du sujet.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node create-topic.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/create-topic.js).

## Liste de vos rubriques
<a name="sns-examples-managing-topics-listtopics"></a>

Dans cet exemple, utilisez un module Node.js pour répertorier toutes les rubriques Amazon SNS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `list-topics.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet vide à transmettre à la méthode `ListTopicsCommand` de la classe client `SNS`. Pour appeler la `ListTopicsCommand` méthode, créez une fonction asynchrone invoquant un objet de service Amazon SNS, en transmettant l'objet de paramètres. Le `data` fichier renvoyé contient un tableau de votre sujet 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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

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

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-topics.js).

## Suppression d'une rubrique
<a name="sns-examples-managing-topics-deletetopic"></a>

Dans cet exemple, utilisez un module Node.js pour supprimer une rubrique Amazon SNS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `delete-topic.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet contenant le paramètre `TopicArn` de la rubrique à supprimer pour le transmettre à la méthode `DeleteTopicCommand` de la classe client `SNS`. Pour appeler la `DeleteTopicCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
*TOPIC\$1ARN*Remplacez-le par le nom de ressource Amazon (ARN) du sujet que vous supprimez.

```
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
  //   }
  // }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node delete-topic.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/delete-topic.js).

## Récupération d'attributs de rubrique
<a name="sns-examples-managing-topicsgettopicattributes"></a>

Dans cet exemple, utilisez un module Node.js pour récupérer les attributs d'une rubrique Amazon SNS.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `get-topic-attributes.js`. Configurez le kit SDK comme illustré précédemment.

Créez un objet contenant le paramètre `TopicArn` d'une rubrique à supprimer pour le transmettre à la méthode `GetTopicAttributesCommand` de la classe client `SNS`. Pour appeler la `GetTopicAttributesCommand` méthode, appelez un objet du service client Amazon SNS et transmettez l'objet de paramètres. 

**Note**  
Remplacez *TOPIC\$1ARN* par l'ARN du sujet.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node get-topic-attributes.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-topic-attributes.js).

## Définition d'attributs de rubrique
<a name="sns-examples-managing-topicssttopicattributes"></a>

Dans cet exemple, utilisez un module Node.js pour définir les attributs modifiables d'une rubrique Amazon SNS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `set-topic-attributes.js`. Configurez le kit SDK comme illustré précédemment.

Créez un objet contenant les paramètres pour la mise à jour de l'attribut, y compris le paramètre `TopicArn` de la rubrique dont vous souhaitez définir les attributs, le nom de l'attribut à définir et la nouvelle valeur pour cet attribut. Vous ne pouvez définir que les attributs `Policy`, `DisplayName` et `DeliveryPolicy`. Transmettez les paramètres à la méthode `SetTopicAttributesCommand` de la classe client `SNS`. Pour appeler la `SetTopicAttributesCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
Remplacez-le *ATTRIBUTE\$1NAME* par le nom de l'attribut que vous définissez, *TOPIC\$1ARN* par le nom de ressource Amazon (ARN) du sujet dont vous souhaitez définir les attributs et *NEW\$1ATTRIBUTE\$1VALUE* par la nouvelle valeur de cet attribut.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node set-topic-attributes.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-topic-attributes.js).

# Publication de messages sur Amazon SNS
<a name="sns-examples-publishing-messages"></a>

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

**Cet exemple de code Node.js présente :**
+ Comment publier des messages sur une rubrique Amazon SNS.

## Scénario
<a name="sns-examples-publishing-messages-scenario"></a>

Dans cet exemple, vous utilisez une série de modules Node.js pour publier des messages depuis Amazon SNS vers des points de terminaison, des e-mails ou des numéros de téléphone thématiques. Les modules Node.js utilisent le SDK pour JavaScript envoyer des messages en utilisant cette méthode de la classe `SNS` client :
+ [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/)

## Tâches prérequises
<a name="sns-examples-publishing-messages-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions indiquées sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Publication d'un message dans une rubrique SNS
<a name="sns-examples-publishing-text-messages"></a>

Dans cet exemple, utilisez un module Node.js pour publier un message sur une rubrique Amazon SNS.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Créez un module Node.js nommé `publish-topic.js`. Configurez le kit SDK comme illustré précédemment.

Créez un objet contenant les paramètres de publication d'un message, y compris le texte du message et le nom de ressource Amazon (ARN) d'Amazon SNStopic. Pour plus de détails sur les attributs SMS disponibles, voir [Définir SMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html#setSMSAttributes-property).

Transmettez les paramètres à la `PublishCommand` méthode de la classe `SNS` cliente. Créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
*MESSAGE\$1TEXT*Remplacez-le par le texte du message et *TOPIC\$1ARN* par l'ARN de la rubrique 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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node publish-topic.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-topic.js).

# Gestion des abonnements sur Amazon SNS
<a name="sns-examples-subscribing-unsubscribing-topics"></a>

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

**Cet exemple de code Node.js présente :**
+ Comment répertorier tous les abonnements à une rubrique Amazon SNS.
+ Comment abonner une adresse e-mail, un point de terminaison d'application ou une AWS Lambda fonction à une rubrique Amazon SNS.
+ Comment se désabonner des rubriques Amazon SNS.

## Scénario
<a name="sns-examples-subscribing-unsubscribing-topics-scenario"></a>

Dans cet exemple, vous utilisez une série de modules Node.js pour publier des messages de notification dans les rubriques Amazon SNS. Les modules Node.js utilisent le SDK pour gérer les sujets JavaScript à l'aide des méthodes suivantes de la classe `SNS` client :
+ [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/)

## Tâches prérequises
<a name="sns-examples-subscribing-unsubscribing-topics-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions indiquées sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Liste des abonnements à une rubrique
<a name="sns-examples-list-subscriptions-email"></a>

Dans cet exemple, utilisez un module Node.js pour répertorier tous les abonnements à une rubrique Amazon SNS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Créez un module Node.js nommé `list-subscriptions-by-topic.js`. Configurez le kit SDK comme illustré précédemment.

Créez un objet contenant le paramètre `TopicArn` pour la rubrique dont vous souhaitez répertorier les abonnements. Transmettez les paramètres à la méthode `ListSubscriptionsByTopicCommand` de la classe client `SNS`. Pour appeler la `ListSubscriptionsByTopicCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS et transmettant l'objet de paramètres. 

**Note**  
*TOPIC\$1ARN*Remplacez-le par le Amazon Resource Name (ARN) du sujet dont vous souhaitez répertorier les abonnements.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

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

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-subscriptions-by-topic.js).

## Abonnement d'une adresse e-mail à une rubrique
<a name="sns-examples-subscribing-email"></a>

Dans cet exemple, utilisez un module Node.js pour abonner une adresse e-mail afin qu'elle reçoive des e-mails SMTP provenant d'une rubrique Amazon SNS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `subscribe-email.js`. Configurez le kit SDK comme illustré précédemment.

Créez un objet contenant le paramètre `Protocol` pour spécifier le protocole `email`, l'élément `TopicArn` pour la rubrique à laquelle s'abonner ainsi qu'une adresse e-mail comme message `Endpoint`. Transmettez les paramètres à la méthode `SubscribeCommand` de la classe client `SNS`. Vous pouvez utiliser `subscribe` cette méthode pour abonner plusieurs points de terminaison différents à une rubrique Amazon SNS, en fonction des valeurs utilisées pour les paramètres transmis, comme le montreront d'autres exemples présentés dans cette rubrique.

Pour appeler la `SubscribeCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS et transmettant l'objet de paramètres. 

**Note**  
*TOPIC\$1ARN*Remplacez-le par le Amazon Resource Name (ARN) du sujet et *EMAIL\$1ADDRESS* par l'adresse e-mail à laquelle vous souhaitez vous abonner.

```
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'
  // }
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node subscribe-email.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-email.js).

### Confirmation des abonnements
<a name="sns-confirm-subscription-email"></a>

Dans cet exemple, utilisez un module Node.js pour vérifier l'intention du propriétaire d'un terminal de recevoir des e-mails en validant le jeton envoyé au point de terminaison par une action d'abonnement précédente.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `confirm-subscription.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Définissez les paramètres, y compris le `TOPIC_ARN` et`TOKEN`, et définissez une valeur de `TRUE` ou `FALSE` pour`AuthenticateOnUnsubscribe`.

Le jeton est un jeton de courte durée envoyé au propriétaire d'un point de terminaison lors d'une `SUBSCRIBE` action précédente. Par exemple, pour un point de terminaison de messagerie, `TOKEN` cela se trouve dans l'URL de l'e-mail de confirmation d'abonnement envoyé au propriétaire de l'e-mail. Par exemple, le jeton `abc123` se trouve dans l'URL suivante.

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


Pour appeler la `ConfirmSubscriptionCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
*TOPIC\$1ARN*Remplacez-le par le Amazon Resource Name (ARN) du sujet, *TOKEN* par la valeur du jeton provenant de l'URL envoyée au propriétaire du point de terminaison lors d'une `Subscribe` action précédente, et définissez*AuthenticateOnUnsubscribe*. par la valeur `TRUE` ou`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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node confirm-subscription.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/confirm-subscription.js).

## Abonnement d'un point de terminaison d'application à une rubrique
<a name="sns-examples-subscribing-apps"></a>

Dans cet exemple, utilisez un module Node.js pour abonner un point de terminaison d'application mobile afin qu'il reçoive des notifications provenant d'une rubrique Amazon SNS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `subscribe-app.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les modules et packages requis.

Créez un objet contenant le `Protocol` paramètre `TopicArn` pour spécifier le `application` protocole, le sujet auquel vous souhaitez vous abonner et le nom de ressource Amazon (ARN) d'un point de terminaison d'application mobile pour le `Endpoint` paramètre. Transmettez les paramètres à la méthode `SubscribeCommand` de la classe client `SNS`.

Pour appeler la `SubscribeCommand` méthode, créez une fonction asynchrone invoquant un objet de service Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
Remplacez-le *TOPIC\$1ARN* par le Amazon Resource Name (ARN) du sujet et *MOBILE\$1ENDPOINT\$1ARN* par le point de terminaison auquel vous êtes abonné au sujet.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node subscribe-app.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-app.js).

## Abonnement d'une fonction Lambda à une rubrique
<a name="sns-examples-subscribing-lambda"></a>

Dans cet exemple, utilisez un module Node.js pour abonner une AWS Lambda fonction afin qu'elle reçoive des notifications d'une rubrique Amazon SNS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `subscribe-lambda.js`. Configurez le kit SDK comme illustré précédemment.

Créez un objet contenant le `Protocol` paramètre, en spécifiant le `lambda` protocole, le `TopicArn` sujet auquel vous souhaitez vous abonner et le nom de ressource Amazon (ARN) d'une AWS Lambda fonction en tant que `Endpoint` paramètre. Transmettez les paramètres à la méthode `SubscribeCommand` de la classe client `SNS`.

Pour appeler la `SubscribeCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
Remplacez-le *TOPIC\$1ARN* par le Amazon Resource Name (ARN) du sujet et *LAMBDA\$1FUNCTION\$1ARN* par le Amazon Resource Name (ARN) de la fonction 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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node subscribe-lambda.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-lambda.js).

## Désabonnement d'une rubrique
<a name="sns-examples-unsubscribing"></a>

Dans cet exemple, utilisez un module Node.js pour vous désabonner d'un abonnement à une rubrique Amazon SNS.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `unsubscribe.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis.

Créez un objet contenant le `SubscriptionArn` paramètre, en spécifiant le nom de ressource Amazon (ARN) de l'abonnement à désabonner. Transmettez les paramètres à la méthode `UnsubscribeCommand` de la classe client `SNS`.

Pour appeler la `UnsubscribeCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
*TOPIC\$1SUBSCRIPTION\$1ARN*Remplacez-le par le Amazon Resource Name (ARN) de l'abonnement pour vous désabonner.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node unsubscribe.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/unsubscribe.js).

# Envoi de SMS avec Amazon SNS
<a name="sns-examples-sending-sms"></a>

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

**Cet exemple de code Node.js présente :**
+ Comment obtenir et définir les préférences de messagerie SMS pour Amazon SNS.
+ Comment vérifier qu'un numéro de téléphone a désactivé la réception de SMS.
+ Comment récupérer une liste de numéros de téléphone ayant désactivé la réception de SMS.
+ Comment envoyer un SMS.

## Scénario
<a name="sns-examples-sending-sms-scenario"></a>

Vous pouvez utiliser pour envoyer des messages texte, ou des messages SMS, à des appareils compatibles SMS. Vous pouvez envoyer un message directement à un numéro de téléphone, ou vous pouvez envoyer un message à plusieurs numéros de téléphone simultanément en abonnant ces numéros de téléphone à une rubrique et en envoyant votre message à la rubrique.

Dans cet exemple, vous utilisez une série de modules Node.js pour publier des SMS depuis Amazon SNS vers des appareils compatibles SMS. Les modules Node.js utilisent le SDK JavaScript pour publier des messages SMS en utilisant les méthodes suivantes de la classe `SNS` client :
+ [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/)

## Tâches prérequises
<a name="sns-examples-sending-sms-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions indiquées sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, consultez[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Récupération d'attributs SMS
<a name="sending-sms-getattributes"></a>

Utilisez Amazon SNS pour définir vos préférences en matière de messagerie SMS, telles que la manière dont vos envois sont optimisés (en termes de coût ou de fiabilité), votre limite de dépenses mensuelles, la manière dont les envois de messages sont enregistrés et si vous souhaitez vous abonner aux rapports quotidiens d'utilisation des SMS. Ces préférences sont récupérées et définies sous forme d'attributs SMS pour Amazon SNS.

Dans cet exemple, utilisez un module Node.js pour obtenir les attributs SMS actuels dans Amazon SNS.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Créez un module Node.js nommé `get-sms-attributes.js`.

Configurez le SDK comme indiqué précédemment, notamment en téléchargeant les clients et les packages requis. Créez un objet contenant les paramètres pour récupérer les attributs SMS, y compris les noms des attributs individuels. Pour plus de détails sur les attributs SMS disponibles, consultez la section [Définir SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) dans le manuel Amazon Simple Notification Service API Reference.

Cet exemple récupère l'attribut `DefaultSMSType`, qui contrôle si les messages SMS sont envoyés en tant que `Promotional`, ce qui optimise la transmission des messages au plus bas coût ou en tant que `Transactional`, ce qui optimise la transmission des messages à une fiabilité optimale. Transmettez les paramètres à la méthode `SetTopicAttributesCommand` de la classe client `SNS`. Pour appeler la `SetSMSAttributesCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
Remplacez *ATTRIBUTE\$1NAME* par le nom de l'attribut.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node get-sms-attributes.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-sms-attributes.js).

## Définition d'attributs SMS
<a name="sending-sms-setattributes"></a>

Dans cet exemple, utilisez un module Node.js pour obtenir les attributs SMS actuels dans Amazon SNS.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Créez un module Node.js nommé `set-sms-attribute-type.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez un objet contenant les paramètres pour définir les attributs SMS, y compris les noms des attributs individuels et les valeurs de chacun d'entre eux. Pour plus de détails sur les attributs SMS disponibles, consultez la section [Définir SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) dans le manuel Amazon Simple Notification Service API Reference.

Cet exemple définit l’attribut `DefaultSMSType` sur `Transactional`, ce qui optimise la transmission de message à une fiabilité optimale. Transmettez les paramètres à la méthode `SetTopicAttributesCommand` de la classe client `SNS`. Pour appeler la `SetSMSAttributesCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

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

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-sms-attribute-type.js).

## Vérification d'un numéro de téléphone désactivé
<a name="sending-sms-checkifphonenumberisoptedout"></a>

Dans cet exemple, utilisez un module Node.js pour vérifier qu'un numéro de téléphone a désactivé la réception de SMS. 

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `check-if-phone-number-is-opted-out.js`. Configurez le kit SDK comme illustré précédemment. Créez un objet contenant le numéro de téléphone à vérifier en tant que paramètre.

Cet exemple définit le paramètre `PhoneNumber` pour spécifier le numéro de téléphone à vérifier. Transmettez l'objet à la méthode `CheckIfPhoneNumberIsOptedOutCommand` de la classe client `SNS`. Pour appeler la `CheckIfPhoneNumberIsOptedOutCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  

Remplacez *PHONE\$1NUMBER* par le numéro de téléphone.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node check-if-phone-number-is-opted-out.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/check-if-phone-number-is-opted-out.js).

## Liste des numéros de téléphone désactivés
<a name="sending-sms-listphonenumbersoptedout"></a>

Dans cet exemple, utilisez un module Node.js pour récupérer une liste des numéros de téléphone ayant désactivé la réception de SMS.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `list-phone-numbers-opted-out.js`. Configurez le kit SDK comme illustré précédemment. Créez un objet vide comme paramètre.

Transmettez l'objet à la méthode `ListPhoneNumbersOptedOutCommand` de la classe client `SNS`. Pour appeler la `ListPhoneNumbersOptedOutCommand` méthode, créez une fonction asynchrone invoquant un objet de service client Amazon SNS, en transmettant l'objet de paramètres. 

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node list-phone-numbers-opted-out.js 
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-phone-numbers-opted-out.js).

## Publication d'un SMS
<a name="sending-sms-publishsms"></a>

Dans cet exemple, utilisez un module Node.js pour envoyer un SMS à un numéro de téléphone.

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`snsClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon SNS. Remplacez *REGION* par votre AWS région.

```
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({});
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Créez un module Node.js nommé `publish-sms.js`. Configurez le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez un objet contenant les paramètres `Message` et `PhoneNumber`.

Lorsque vous envoyez un SMS, spécifiez le numéro de téléphone au format E.164. E.164 est une norme pour la structure des numéros de téléphone, qui est utilisée pour les télécommunications internationales. Les numéros qui respectent ce format peuvent comporter 15 chiffres au maximum et commencent par le caractère plus (\$1) et le code pays. Par exemple, un numéro de téléphone américain au format E.164 s'affichera sous la forme XXX5550100 \$11001. 

Cet exemple définit le paramètre `PhoneNumber` pour spécifier le numéro de téléphone qui envoie le message. Transmettez l'objet à la méthode `PublishCommand` de la classe client `SNS`. Pour appeler la `PublishCommand` méthode, créez une fonction asynchrone invoquant un objet de service Amazon SNS, en transmettant l'objet de paramètres. 

**Note**  
Remplacez *TEXT\$1MESSAGE* par le message texte et *PHONE\$1NUMBER* par le numéro de téléphone.

```
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;
};
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node publish-sms.js
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-sms.js).

# Exemples d'Amazon Transcribe
<a name="Transcribe-examples"></a>

Amazon Transcribe permet aux développeurs d'ajouter facilement des fonctionnalités de synthèse vocale à leurs applications. 

![\[Relation entre JavaScript les environnements, le SDK et Amazon Transcribe\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/code-samples-transcribe.png)


L' JavaScript API d'Amazon Transcribe est exposée par le biais de la classe [TranscribeService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/Transcribe/)client.

**Topics**
+ [

# Exemples d'Amazon Transcribe
](transcribe-examples-section.md)
+ [

# Exemples médicaux d'Amazon Transcribe
](transcribe-medical-examples-section.md)

# Exemples d'Amazon Transcribe
<a name="transcribe-examples-section"></a>

Dans cet exemple, une série de modules Node.js sont utilisés pour créer, répertorier et supprimer des tâches de transcription à l'aide des méthodes suivantes de la classe `TranscribeService` client :
+ [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/)

Pour plus d'informations sur les utilisateurs d'Amazon Transcribe, consultez le guide du développeur [Amazon Transcribe](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Tâches prérequises
<a name="transcribe-example-transcription-jobs"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, voir [JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md)

## Démarrage d'une tâche sur Amazon Transcribe
<a name="transcribe-start-transcription"></a>

Cet exemple montre comment démarrer une tâche de transcription Amazon Transcribe à l'aide du. AWS SDK pour JavaScript Pour de plus amples informations, veuillez consulter [StartTranscriptionJobCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`transcribeClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Transcribe. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Créez un module Node.js nommé `transcribe-create-job.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez un objet de paramètres en spécifiant les paramètres requis. Démarrez la tâche à l'aide de la `StartMedicalTranscriptionJobCommand` commande.

**Note**  
*MEDICAL\$1JOB\$1NAME*Remplacez-le par le nom de la tâche de transcription. Pour *OUTPUT\$1BUCKET\$1NAME* spécifier le compartiment Amazon S3 dans lequel la sortie est enregistrée. Pour *JOB\$1TYPE* spécifier les types de tâches. Pour *SOURCE\$1LOCATION* spécifier l'emplacement du fichier source. Pour *SOURCE\$1FILE\$1LOCATION* spécifier l'emplacement du fichier multimédia d'entrée.

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node transcribe-create-job.js
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_job.js).

## Répertorier les offres d'emploi d'Amazon Transcribe
<a name="transcribe-list-jobs"></a>

Cet exemple montre comment répertorier les tâches de transcription Amazon Transcribe à l'aide du. AWS SDK pour JavaScript Pour plus d'informations sur les autres paramètres que vous pouvez modifier, consultez [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/).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`transcribeClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Transcribe. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Créez un module Node.js nommé `transcribe-list-jobs.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez un objet de paramètres avec les paramètres requis.

**Note**  
*KEY\$1WORD*Remplacez-le par un mot clé que le nom des tâches renvoyées doit contenir.

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node transcribe-list-jobs.js
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_jobs.js).

## Supprimer une tâche Amazon Transcribe
<a name="transcribe-delete-job"></a>

Cet exemple montre comment supprimer une tâche de transcription Amazon Transcribe à l'aide du. AWS SDK pour JavaScript Pour plus d'informations sur les options facultatives, consultez [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/).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`transcribeClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Transcribe. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Créez un module Node.js nommé `transcribe-delete-job.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Spécifiez la AWS région et le nom de la tâche que vous souhaitez supprimer.

**Note**  
Remplacez *JOB\$1NAME* par le nom de la tâche à supprimer. 

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node transcribe-delete-job.js  
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_job.js).

# Exemples médicaux d'Amazon Transcribe
<a name="transcribe-medical-examples-section"></a>

Dans cet exemple, une série de modules Node.js sont utilisés pour créer, répertorier et supprimer des tâches de transcription médicale à l'aide des méthodes suivantes de la classe `TranscribeService` client :
+ [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/)

Pour plus d'informations sur les utilisateurs d'Amazon Transcribe, consultez le guide du développeur [Amazon Transcribe](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Tâches prérequises
<a name="transcribe-example-transcription-medical-jobs"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Ces exemples montrent comment utiliser des objets de service import/export client et des commandes en utilisant ECMAScript6 (ES6).  
Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .
Si vous préférez utiliser la syntaxe CommonJS, voir [JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md)

## Démarrage d'une tâche de transcription médicale sur Amazon Transcribe
<a name="transcribe-start-medical-transcription"></a>

Cet exemple montre comment démarrer une tâche de transcription médicale Amazon Transcribe à l'aide du. AWS SDK pour JavaScript Pour plus d'informations, consultez [startMedicalTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`transcribeClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Transcribe. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Créez un module Node.js nommé `transcribe-create-medical-job.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez un objet de paramètres en spécifiant les paramètres requis. Commencez le travail médical à l'aide de la `StartMedicalTranscriptionJobCommand` commande.

**Note**  
*MEDICAL\$1JOB\$1NAME*Remplacez-le par un nom pour le travail de transcription médicale. Pour *OUTPUT\$1BUCKET\$1NAME* spécifier le compartiment Amazon S3 dans lequel la sortie est enregistrée. Pour *JOB\$1TYPE* spécifier les types de tâches. Pour *SOURCE\$1LOCATION* spécifier l'emplacement du fichier source. Pour *SOURCE\$1FILE\$1LOCATION* spécifier l'emplacement du fichier multimédia d'entrée.

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node transcribe-create-medical-job.js
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_medical_job.js).

## Liste des offres d'emploi dans le secteur médical d'Amazon Transcribe
<a name="transcribe-list-medical-jobs"></a>

Cet exemple montre comment répertorier les tâches de transcription Amazon Transcribe à l'aide du. AWS SDK pour JavaScript Pour de plus amples informations, veuillez consulter [ListTranscriptionMedicalJobsCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListMedicalTranscriptionJobsCommand/).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`transcribeClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Transcribe. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Créez un module Node.js nommé `transcribe-list-medical-jobs.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez un objet de paramètres avec les paramètres requis et listez les tâches médicales à l'aide de la `ListMedicalTranscriptionJobsCommand` commande.

**Note**  
*KEYWORD*Remplacez-le par un mot clé que le nom des tâches renvoyées doit contenir.

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node transcribe-list-medical-jobs.js
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_medical_jobs.js).

## Supprimer un emploi médical sur Amazon Transcribe
<a name="transcribe-delete-medical-job"></a>

Cet exemple montre comment supprimer une tâche de transcription Amazon Transcribe à l'aide du. AWS SDK pour JavaScript Pour plus d'informations sur les options facultatives, consultez [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/).

Créez un `libs` répertoire et créez un module Node.js avec le nom du fichier`transcribeClient.js`. Copiez-collez le code ci-dessous pour créer l'objet client Amazon Transcribe. Remplacez *REGION* par votre AWS région.

```
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 };
```

Cet exemple de code se trouve [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Créez un module Node.js nommé `transcribe-delete-job.js`. Assurez-vous de configurer le SDK comme indiqué précédemment, notamment en installant les clients et les packages requis. Créez un objet de paramètres avec les paramètres requis et supprimez le travail médical à l'aide de la `DeleteMedicalJobCommand` commande.

**Note**  
Remplacez *JOB\$1NAME* par le nom de la tâche à supprimer. 

```
// 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();
```

Pour exécuter l'exemple, entrez ce qui suit à l'invite de commande.

```
node transcribe-delete-medical-job.js
```

Cet exemple de code se trouve [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_medical_job.js).

# Configuration de Node.js sur une instance Amazon EC2
<a name="setting-up-node-on-ec2-instance"></a>

Un scénario courant d'utilisation de Node.js avec le SDK pour JavaScript consiste à configurer et à exécuter une application Web Node.js sur une instance Amazon Elastic Compute Cloud (Amazon EC2). Dans ce didacticiel, vous allez créer une instance Linux, vous y connecter à l'aide de SSH et installer Node.js pour que ce dernier s'exécute dans cette instance. 

## Conditions préalables
<a name="setting-up-node-on-ec2-instance.prerequisites"></a>

Ce didacticiel part du principe que vous avez déjà lancé une instance Linux avec un nom DNS public accessible depuis Internet et à laquelle vous pouvez vous connecter via SSH. Pour plus d'informations, veuillez consulter [Étape 1 : Lancer une instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-launch-instance) dans le *Guide de l'utilisateur Amazon EC2*.

**Important**  
Utilisez l'**Amazon Machine Image (AMI) Amazon Linux 2023** lors du lancement d'une nouvelle instance Amazon EC2.

Vous devez aussi avoir configuré votre groupe de sécurité pour permettre les connexions `SSH` (port 22), ` HTTP` (port 80) et `HTTPS` (port 443). Pour plus d'informations sur ces prérequis, consultez la section [Configuration avec Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html) EC2 dans le guide de l'utilisateur *Amazon EC2*.

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

La procédure suivante vous aide à installer Node.js sur une instance Amazon Linux. Vous pouvez utiliser ce serveur pour héberger une application web Node.js.

**Pour configurez Node.js sur votre instance Linux**

1. Connectez-vous à votre instance Linux en tant que `ec2-user` à l'aide de SSH.

1. Installez le gestionnaire de version de nœud (`nvm`) en saisissant ce qui suit sur la ligne de commande.
**Avertissement**  
AWS ne contrôle pas le code suivant. Avant de l'exécuter, vérifiez son authenticité et son intégrité. Vous trouverez plus d'informations sur ce code dans le GitHub dépôt [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
   ```

   Nous allons l'utiliser `nvm` pour installer Node.js car il `nvm` peut installer plusieurs versions de Node.js et vous permettre de passer de l'une à l'autre.

1. Chargez `nvm` en saisissant ce qui suit sur la ligne de commande.

   ```
   source ~/.bashrc
   ```

1. Utilisez nvm pour installer la dernière version LTS de Node.js en tapant ce qui suit sur la ligne de commande.

   ```
   nvm install --lts
   ```

   L'installation de Node.js installe également le Node Package Manager (`npm`) afin que vous puissiez installer des modules supplémentaires selon vos besoins.

1. Testez l'installation et le fonctionnement de Node.js en saisissant ce qui suit dans la ligne de commande.

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

   Le message suivant affiche alors la version de Node.js qui est en cours d'exécution.

    `Running Node.js VERSION` 

**Note**  
L'installation du nœud s'applique uniquement à la session Amazon EC2 en cours. Si vous redémarrez votre session CLI, vous devez réutiliser nvm pour activer la version du nœud installé. Si l'instance est interrompue, vous devez réinstaller le nœud. L'alternative est de créer une Amazon Machine Image (AMI) de l'instance Amazon EC2 une fois que vous avez obtenu la configuration que vous souhaitez conserver, comme décrit dans la rubrique suivante.

## Création d'une image machine Amazon (AMI)
<a name="setting-up-node-on-ec2-instance-create-image"></a>

Après avoir installé Node.js sur une instance Amazon EC2, vous pouvez créer une Amazon Machine Image (AMI) à partir de cette instance. La création d'une AMI facilite le provisionnement de plusieurs instances Amazon EC2 avec la même installation Node.js. Pour plus d'informations sur la création d'une AMI à partir d'une instance existante, consultez la section [Création d'une AMI Linux basée sur Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) dans le guide de l'utilisateur *Amazon EC2*.

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

Pour plus d'informations sur les commandes et les logiciels utilisés dans cette rubrique, consultez les pages Web suivantes :
+ Gestionnaire de versions de nœuds (`nvm`) —Voir [nvm repo](https://github.com/creationix/nvm) on. GitHub
+ Node Package Manager (`npm`) —Voir le site Web de [npm.](https://www.npmjs.com)

# Invoquer Lambda avec API Gateway
<a name="api-gateway-invoking-lambda-example"></a>

Vous pouvez appeler une fonction Lambda à l'aide d'Amazon API Gateway, qui est un AWS service de création, de publication, de maintenance, de surveillance et de sécurisation des protocoles REST, HTTP et WebSocket APIs à grande échelle. Les développeurs d'API peuvent créer APIs cet accès AWS ou d'autres services Web, ainsi que des données stockées dans le AWS cloud. En tant que développeur d'API Gateway, vous pouvez créer des applications APIs pour les utiliser dans vos propres applications clientes. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ? 

AWS Lambda est un service de calcul qui vous permet d'exécuter du code sans provisionner ni gérer de serveurs. Vous pouvez créer des fonctions Lambda dans différents langages de programmation. Pour plus d'informations AWS Lambda, voir [Qu'est-ce que AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

Dans cet exemple, vous créez une fonction Lambda à l'aide de l'API d'exécution JavaScript Lambda. Cet exemple fait appel à différents AWS services pour réaliser un cas d'utilisation spécifique. Supposons, par exemple, qu'une organisation envoie un message texte mobile à ses employés pour les féliciter à la date du premier anniversaire, comme le montre cette illustration.

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


La réalisation de l'exemple devrait prendre environ 20 minutes.

Cet exemple montre comment utiliser la JavaScript logique pour créer une solution qui exécute ce cas d'utilisation. Par exemple, vous apprendrez à lire une base de données pour déterminer quels employés ont atteint le premier anniversaire, à traiter les données et à envoyer un message texte à l'aide d'une fonction Lambda. Vous apprendrez ensuite à utiliser API Gateway pour appeler cette AWS Lambda fonction à l'aide d'un point de terminaison Rest. Par exemple, vous pouvez appeler la fonction Lambda à l'aide de cette commande curl :

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

Ce AWS didacticiel utilise une table Amazon DynamoDB nommée Employee qui contient ces champs.
+ **id** - la clé primaire de la table.
+ **FirstName : prénom** de l'employé.
+ **téléphone - numéro** de téléphone de l'employé.
+ Date de **début : date** de début de l'employé.

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


**Important**  
Coût de réalisation : Les AWS services inclus dans ce document sont inclus dans le niveau AWS gratuit. Veillez toutefois à désactiver toutes les ressources une fois que vous aurez terminé cet exemple afin de ne pas être débité.

**Pour créer l'application, procédez comme suit :**

1. [Compléter les prérequis](#api-gateway-invoking-lambda-provision-resources)

1. [Créez les AWS ressources](#api-gateway-invoking-lambda-provision-resources)

1. [Préparez le script du navigateur](#api-gateway-invoking-lambda-browser-script)

1. [Création et téléchargement de la fonction Lambda](#api-gateway-invoking-lambda-browser-script)

1. [Déployer la fonction Lambda](#api-gateway-invoking-lambda-deploy-function)

1. [Exécutez l'application](#api-gateway-invoking-lambda-run)

1. [Supprimer les ressources](#api-gateway-invoking-lambda-destroy)

## Tâches préalables
<a name="api-gateway-invoking-lambda-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

## Créez les AWS ressources
<a name="api-gateway-invoking-lambda-provision-resources"></a>

Ce didacticiel nécessite les ressources suivantes :
+ Une table Amazon DynamoDB `Employee` nommée avec une clé `Id` nommée et les champs illustrés dans l'illustration précédente. Assurez-vous de saisir les données correctes, y compris un téléphone portable valide avec lequel vous souhaitez tester ce cas d'utilisation. Pour plus d'informations, consultez la section [Création d'une table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Rôle IAM associé à des autorisations permettant d'exécuter des fonctions Lambda.
+ Un compartiment Amazon S3 pour héberger la fonction Lambda.

Vous pouvez créer ces ressources manuellement, mais nous vous recommandons de les approvisionner à l'aide de la méthode CloudFormation décrite dans ce didacticiel.

### Créez les AWS ressources à l'aide de CloudFormation
<a name="api-gateway-invoking-lambda-resources-cli"></a>

CloudFormation vous permet de créer et de provisionner des déploiements AWS d'infrastructure de manière prévisible et répétée. Pour plus d'informations CloudFormation, consultez le [guide de AWS CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Pour créer la CloudFormation pile à l'aide de AWS CLI :

1. Installez et configurez en AWS CLI suivant les instructions du [guide de l'AWS CLI utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Créez un fichier nommé `setup.yaml` dans le répertoire racine du dossier de votre projet et [ GitHubcopiez-y le](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/setup.yaml) contenu.
**Note**  
Le CloudFormation modèle a été généré à l'aide du modèle AWS CDK [disponible ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lambda_using_api_gateway). Pour plus d'informations à ce sujet AWS CDK, consultez le [guide du AWS Cloud Development Kit (AWS CDK) développeur](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Exécutez la commande suivante depuis la ligne de commande, en la *STACK\$1NAME* remplaçant par un nom unique pour la pile.
**Important**  
Le nom de la pile doit être unique au sein d'une AWS région et d'un AWS compte. Vous pouvez spécifier jusqu'à 128 caractères. Les chiffres et les tirets sont autorisés.

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

   Pour plus d'informations sur les paramètres de `create-stack` commande, consultez le [guide de référence des AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) et le [guide de CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. Ensuite, renseignez le tableau en suivant la procédure[Remplissage du tableau](#api-gateway-invoking-lambda-resources-create-table).

### Remplissage du tableau
<a name="api-gateway-invoking-lambda-resources-create-table"></a>

Pour remplir le tableau, créez d'abord un répertoire nommé`libs`, puis créez un fichier nommé`dynamoClient.js`, puis collez-y le contenu ci-dessous. 

```
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 };
```

 Ce code est disponible [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/dynamoClient.js).

Créez ensuite un fichier nommé `populate-table.js` dans le répertoire racine du dossier de votre projet et [ GitHubcopiez-y le](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) contenu. Pour l'un des articles, remplacez la valeur de la `phone` propriété par un numéro de téléphone portable valide au format E.164, et la valeur `startDate` par la date du jour.

Exécutez la commande suivante depuis la ligne de commande.

```
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();
```

 Ce code est disponible [ici 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).

## Création de la AWS Lambda fonction
<a name="api-gateway-invoking-lambda-browser-script"></a>

### Configuration du kit SDK
<a name="api-gateway-invoking-lambda-configure-sdk"></a>

Dans le `libs` répertoire, créez des fichiers nommés `snsClient.js` et`lambdaClient.js`, puis collez le contenu ci-dessous dans ces fichiers, respectivement. 

```
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 };
```

 Remplacez *REGION* par la AWS région. Ce code est disponible [ici 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 };
```

Remplacez *REGION* par la AWS région. Ce code est disponible [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/lambdaClient.js).

Importez d'abord les modules et commandes requis AWS SDK pour JavaScript (v3). Calculez ensuite la date du jour et attribuez-la à un paramètre. Troisièmement, créez les paramètres pour`ScanCommand`. *TABLE\$1NAME*Remplacez-le par le nom de la table que vous avez créée dans la [Créez les AWS ressources](#api-gateway-invoking-lambda-provision-resources) section de cet exemple.

L'extrait de code suivant illustre cette étape. (Pour obtenir l'exemple complet, consultez [Regroupement de la fonction Lambda](#api-gateway-invoking-lambda-full).)

```
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",
};
```

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

Tout d'abord, créez une async/await fonction appelée `sendText` pour publier un message texte à l'aide d'Amazon SNS`PublishCommand`. Ajoutez ensuite un schéma de `try` blocs qui analyse la table DynamoDB à la recherche des employés à l'occasion de leur anniversaire de travail aujourd'hui, puis appelle `sendText` la fonction pour envoyer un message texte à ces employés. En cas d'erreur, le `catch` bloc est appelé.

L'extrait de code suivant illustre cette étape. (Pour obtenir l'exemple complet, consultez [Regroupement de la fonction Lambda](#api-gateway-invoking-lambda-full).)

```
// 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);
  }
};
```

### Regroupement de la fonction Lambda
<a name="api-gateway-invoking-lambda-full"></a>

Cette rubrique décrit comment regrouper `mylambdafunction.ts` les AWS SDK pour JavaScript modules requis pour cet exemple dans un fichier groupé appelé`index.js`. 

1. Si ce n'est pas déjà fait, suivez cet exemple [Tâches préalables](#api-gateway-invoking-lambda-prerequisites) pour installer le webpack. 
**Note**  
Pour plus d'informations sur *Webpack*, consultez[Regroupez des applications avec Webpack](webpack.md).

1. Exécutez ce qui suit dans la ligne de commande JavaScript pour regrouper les informations de cet exemple dans un fichier appelé `<index.js>` :

   ```
   webpack mylambdafunction.ts --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**Important**  
Notez que la sortie est nommée`index.js`. Cela est dû au fait que les fonctions Lambda doivent avoir un `index.js` gestionnaire pour fonctionner.

1. Compressez le fichier de sortie groupé`index.js`,, dans un fichier ZIP nommé`mylambdafunction.zip`.

1. `mylambdafunction.zip`Téléchargez-le dans le compartiment Amazon S3 que vous avez créé dans la [Créez les AWS ressources](#api-gateway-invoking-lambda-provision-resources) rubrique de ce didacticiel. 

## Déployez la fonction Lambda.
<a name="api-gateway-invoking-lambda-deploy-function"></a>

À la racine de votre projet, créez un `lambda-function-setup.ts` fichier et collez-y le contenu ci-dessous.

*BUCKET\$1NAME*Remplacez-le par le nom du compartiment Amazon S3 dans lequel vous avez chargé la version ZIP de votre fonction Lambda. Remplacez *ZIP\$1FILE\$1NAME* par le nom la version ZIP de votre fonction Lambda. *ROLE*Remplacez-le par le numéro de ressource Amazon (ARN) du rôle IAM que vous avez créé dans le [Créez les AWS ressources](#api-gateway-invoking-lambda-provision-resources) sujet de ce didacticiel. Remplacez *LAMBDA\$1FUNCTION\$1NAME* par le nom de la fonction 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();
```

Entrez ce qui suit sur la ligne de commande pour déployer la fonction Lambda.

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

Cet exemple de code est disponible [ici 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).

## Configurer API Gateway pour appeler la fonction Lambda
<a name="api-gateway-invoking-lambda-run"></a>

**Pour créer l'application, procédez comme suit :**

1. [Création de l'API Rest](#api-gateway-invoking-lambda-run-create)

1. [Testez la méthode API Gateway](#api-gateway-invoking-lambda-run-test)

1. [Déployer la méthode API Gateway](#api-gateway-invoking-lambda-run-deploy)

### Création de l'API Rest
<a name="api-gateway-invoking-lambda-run-create"></a>

Vous pouvez utiliser la console API Gateway pour créer un point de terminaison REST pour la fonction Lambda. Une fois cela fait, vous pouvez invoquer la fonction Lambda à l'aide d'un appel RESTful.



1. Connectez-vous à la [console Amazon API Gateway](https://console.aws.amazon.com/apigateway).

1. Sous Rest API, choisissez **Build**.

1. Sélectionnez **Nouvelle API**.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/PicNewAPI.png)

1. Spécifiez **Employee** comme nom d'API et fournissez une description.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picEmployeeAPI.png)

1. Sélectionnez **Create API** (Créer une API).

1. Choisissez **Ressources** dans la section **Employé**.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picResources.png)

1. Dans le champ du nom, spécifiez **les employés**.

1. Choisissez **Create Resources (Créer des ressources)**.

1. Dans le menu déroulant **Actions**, choisissez **Create Resources**.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picCreateResources.png)

1. Choisissez **/employees**, sélectionnez **Create Method** dans les **Actions**, puis sélectionnez **GET** dans le menu déroulant situé sous **/employees**. Choisissez l'icône représentant une coche.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGet.png)

1. Choisissez **fonction Lambda** et entrez **mylambdafunction comme nom de la fonction** Lambda. Choisissez **Enregistrer**.

### Testez la méthode API Gateway
<a name="api-gateway-invoking-lambda-run-test"></a>

À ce stade du didacticiel, vous pouvez tester la méthode API Gateway qui appelle la fonction **Lambda mylambdafunction**. Pour tester la méthode, choisissez **Test**, comme indiqué dans l'illustration suivante.

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


Une fois que la fonction Lambda est invoquée, vous pouvez consulter le fichier journal pour voir s'il s'agit d'un message de réussite.

### Déployer la méthode API Gateway
<a name="api-gateway-invoking-lambda-run-deploy"></a>

Une fois le test réussi, vous pouvez déployer la méthode depuis la [console Amazon API Gateway](https://console.aws.amazon.com/apigateway).

1. Choisissez **Get**.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGetDeploy.png)

1. Dans le menu déroulant **Actions**, sélectionnez **Déployer l'API**.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1. Remplissez le formulaire **Deploy API** et choisissez **Deploy**.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1.  Choisissez **Save Changes (Enregistrer les modifications)**.

1.  Choisissez à nouveau **Obtenir** et remarquez que l'URL change. Il s'agit de l'URL d'appel que vous pouvez utiliser pour appeler la fonction Lambda.  
![\[Tableau DynamoDB\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picURL2.png)

## Supprimer les ressources
<a name="api-gateway-invoking-lambda-destroy"></a>

Félicitations \$1 Vous avez invoqué une fonction Lambda via Amazon API Gateway à l'aide du. AWS SDK pour JavaScript Comme indiqué au début de ce didacticiel, veillez à désactiver toutes les ressources que vous créez pendant que vous suivez ce didacticiel pour vous assurer que vous n'êtes pas débité. Pour ce faire, supprimez la CloudFormation pile que vous avez créée dans la [Créez les AWS ressources](#api-gateway-invoking-lambda-provision-resources) rubrique de ce didacticiel, comme suit :

1. Ouvrez le [CloudFormation dans la console AWS de gestion]( https://console.aws.amazon.com/cloudformation/home).

1. Ouvrez la page **Stacks**, puis sélectionnez la pile.

1. Sélectionnez **Supprimer**.

# Création d'événements planifiés pour exécuter AWS Lambda des fonctions
<a name="scheduled-events-invoking-lambda-example"></a>

Vous pouvez créer un événement planifié qui invoque une AWS Lambda fonction à l'aide d'un CloudWatch événement Amazon. Vous pouvez configurer un CloudWatch événement pour utiliser une expression cron afin de planifier le moment où une fonction Lambda est invoquée. Par exemple, vous pouvez planifier un CloudWatch événement pour appeler une fonction Lambda tous les jours de la semaine.

AWS Lambda est un service de calcul qui vous permet d'exécuter du code sans provisionner ni gérer de serveurs. Vous pouvez créer des fonctions Lambda dans différents langages de programmation. Pour plus d'informations AWS Lambda, voir [Qu'est-ce que AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

Dans ce didacticiel, vous allez créer une fonction Lambda à l'aide de l'API d'exécution JavaScript Lambda. Cet exemple fait appel à différents AWS services pour réaliser un cas d'utilisation spécifique. Supposons, par exemple, qu'une organisation envoie un message texte mobile à ses employés pour les féliciter à la date du premier anniversaire, comme le montre cette illustration.

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


Le didacticiel devrait prendre environ 20 minutes.

Ce didacticiel explique comment utiliser la JavaScript logique pour créer une solution adaptée à ce cas d'utilisation. Par exemple, vous apprendrez à lire une base de données pour déterminer quels employés ont atteint le premier anniversaire, à traiter les données et à envoyer un message texte à l'aide d'une fonction Lambda. Vous apprendrez ensuite à utiliser une expression cron pour appeler la fonction Lambda tous les jours de la semaine.

Ce AWS didacticiel utilise une table Amazon DynamoDB nommée Employee qui contient ces champs.
+ **id** - la clé primaire de la table.
+ **FirstName : prénom** de l'employé.
+ **téléphone - numéro** de téléphone de l'employé.
+ Date de **début : date** de début de l'employé.

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


**Important**  
Coût de réalisation : Les AWS services inclus dans ce document sont inclus dans le niveau AWS gratuit. Cependant, veillez à désactiver toutes les ressources une fois que vous aurez terminé ce didacticiel pour vous assurer que vous n'êtes pas débité.

**Pour créer l'application, procédez comme suit :**

1. [Compléter les prérequis](#scheduled-events-invoking-lambda-provision-resources)

1. [Créez les AWS ressources](#scheduled-events-invoking-lambda-provision-resources)

1. [Préparez le script du navigateur](#scheduled-events-invoking-lambda-browser-script)

1. [Création et téléchargement de la fonction Lambda](#scheduled-events-invoking-lambda-browser-script)

1. [Déployer la fonction Lambda](#scheduled-events-invoking-lambda-deploy-function)

1. [Exécutez l'application](#scheduled-events-invoking-lambda-run)

1. [Supprimer les ressources](#scheduled-events-invoking-lambda-destroy)

## Tâches préalables
<a name="scheduled-events-invoking-lambda-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples Node.js et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

## Créez les AWS ressources
<a name="scheduled-events-invoking-lambda-provision-resources"></a>

Ce didacticiel nécessite les ressources suivantes.
+ Une table Amazon DynamoDB **nommée Employee avec une clé **nommée**** Id et les champs illustrés dans l'illustration précédente. Assurez-vous de saisir les données correctes, y compris un téléphone portable valide avec lequel vous souhaitez tester ce cas d'utilisation. Pour plus d'informations, consultez la section [Création d'une table](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Rôle IAM associé à des autorisations permettant d'exécuter des fonctions Lambda.
+ Un compartiment Amazon S3 pour héberger la fonction Lambda.

Vous pouvez créer ces ressources manuellement, mais nous vous recommandons de les approvisionner à l'aide de la méthode CloudFormation décrite dans ce didacticiel.

### Créez les AWS ressources à l'aide de CloudFormation
<a name="scheduled-events-invoking-lambda-resources-cli"></a>

CloudFormation vous permet de créer et de provisionner des déploiements AWS d'infrastructure de manière prévisible et répétée. Pour plus d'informations CloudFormation, consultez le [guide de AWS CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Pour créer la CloudFormation pile à l'aide de AWS CLI :

1. Installez et configurez en AWS CLI suivant les instructions du [guide de l'AWS CLI utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Créez un fichier nommé `setup.yaml` dans le répertoire racine du dossier de votre projet et [ GitHubcopiez-y le](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/setup.yaml) contenu.
**Note**  
Le CloudFormation modèle a été généré à l'aide du modèle AWS CDK [disponible ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/lambda_using_scheduled_events). Pour plus d'informations à ce sujet AWS CDK, consultez le [guide du AWS Cloud Development Kit (AWS CDK) développeur](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Exécutez la commande suivante depuis la ligne de commande, en la *STACK\$1NAME* remplaçant par un nom unique pour la pile.
**Important**  
Le nom de la pile doit être unique au sein d'une AWS région et d'un AWS compte. Vous pouvez spécifier jusqu'à 128 caractères. Les chiffres et les tirets sont autorisés.

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

   Pour plus d'informations sur les paramètres de `create-stack` commande, consultez le [guide de référence des AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) et le [guide de CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

   Consultez la liste des ressources dans la console en ouvrant la pile sur le CloudFormation tableau de bord et en choisissant l'onglet **Ressources**. Vous en avez besoin pour le didacticiel. 

1. Lorsque la pile est créée, utilisez le AWS SDK pour JavaScript pour remplir la table DynamoDB, comme décrit dans. [Renseignez la table DynamoDB](#scheduled-events-invoking-lambda-resources-create-table)

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

Pour remplir le tableau, créez d'abord un répertoire nommé`libs`, puis créez un fichier nommé`dynamoClient.js`, puis collez-y le contenu ci-dessous. 

```
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 };
```

 Ce code est disponible [ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/libs/dynamoClient.js).

Créez ensuite un fichier nommé `populate-table.js` dans le répertoire racine du dossier de votre projet et [ GitHubcopiez-y le](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) contenu. Pour l'un des articles, remplacez la valeur de la `phone` propriété par un numéro de téléphone portable valide au format E.164, et la valeur `startDate` par la date du jour.

Exécutez la commande suivante depuis la ligne de commande.

```
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();
```

 Ce code est disponible [ici 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).

## Création de la AWS Lambda fonction
<a name="scheduled-events-invoking-lambda-browser-script"></a>

### Configuration du kit SDK
<a name="scheduled-events-invoking-lambda-configure-sdk"></a>

Importez d'abord les modules et commandes AWS SDK pour JavaScript (v3) requis : `ScanCommand` DynamoDB `DynamoDBClient` et la commande Amazon `SNSClient` SNS. `PublishCommand` Remplacez *REGION* par la AWS région. Calculez ensuite la date du jour et attribuez-la à un paramètre. Créez ensuite les paramètres du `ScanCommand` fichier .Replace *TABLE\$1NAME* avec le nom de la table que vous avez créée dans la [Créez les AWS ressources](#scheduled-events-invoking-lambda-provision-resources) section de cet exemple.

L'extrait de code suivant illustre cette étape. (Pour obtenir l'exemple complet, consultez [Regroupement de la fonction Lambda](#scheduled-events-invoking-lambda-full).)

```
"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",
};
```

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

Créez d'abord une async/await fonction appelée `sendText` pour publier un message texte à l'aide d'Amazon SNS`PublishCommand`. Ajoutez ensuite un schéma de `try` blocs qui analyse la table DynamoDB à la recherche des employés à l'occasion de leur anniversaire de travail aujourd'hui, puis appelle `sendText` la fonction pour envoyer un message texte à ces employés. En cas d'erreur, le `catch` bloc est appelé.

L'extrait de code suivant illustre cette étape. (Pour obtenir l'exemple complet, consultez [Regroupement de la fonction Lambda](#scheduled-events-invoking-lambda-full).)

```
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);
  }
};
```

### Regroupement de la fonction Lambda
<a name="scheduled-events-invoking-lambda-full"></a>

Cette rubrique décrit comment regrouper `mylambdafunction.js` les AWS SDK pour JavaScript modules requis pour cet exemple dans un fichier groupé appelé`index.js`. 

1. Si ce n'est pas déjà fait, suivez cet exemple [Tâches préalables](#scheduled-events-invoking-lambda-prerequisites) pour installer le webpack. 
**Note**  
Pour plus d'informations sur *Webpack*, consultez[Regroupez des applications avec Webpack](webpack.md).

1. Exécutez la commande suivante dans la ligne de commande JavaScript pour regrouper les informations de cet exemple dans un fichier appelé `<index.js>` :

   ```
   webpack mylamdbafunction.js --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**Important**  
Notez que la sortie est nommée`index.js`. Cela est dû au fait que les fonctions Lambda doivent avoir un `index.js` gestionnaire pour fonctionner.

1. Compressez le fichier de sortie groupé`index.js`,, dans un fichier ZIP nommé`my-lambda-function.zip`.

1. `mylambdafunction.zip`Téléchargez-le dans le compartiment Amazon S3 que vous avez créé dans la [Créez les AWS ressources](#scheduled-events-invoking-lambda-provision-resources) rubrique de ce didacticiel. 

Voici le code de script de navigateur complet pour`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);
  }
};
```

## Déployez la fonction Lambda.
<a name="scheduled-events-invoking-lambda-deploy-function"></a>

À la racine de votre projet, créez un `lambda-function-setup.js` fichier et collez-y le contenu ci-dessous.

*BUCKET\$1NAME*Remplacez-le par le nom du compartiment Amazon S3 dans lequel vous avez chargé la version ZIP de votre fonction Lambda. Remplacez *ZIP\$1FILE\$1NAME* par le nom la version ZIP de votre fonction Lambda. *IAM\$1ROLE\$1ARN*Remplacez-le par le numéro de ressource Amazon (ARN) du rôle IAM que vous avez créé dans le [Créez les AWS ressources](#scheduled-events-invoking-lambda-provision-resources) sujet de ce didacticiel. Remplacez *LAMBDA\$1FUNCTION\$1NAME* par le nom de la fonction 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();
```

Entrez ce qui suit sur la ligne de commande pour déployer la fonction Lambda.

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

Cet exemple de code est disponible [ici 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).

## Configurer CloudWatch pour appeler les fonctions Lambda
<a name="scheduled-events-invoking-lambda-run"></a>

Pour configurer CloudWatch afin d'invoquer les fonctions Lambda, procédez comme suit :

1. Ouvrez la **page Functions (Fonctions)** sur la console Lambda.

1. Choisissez la fonction Lambda.

1. Sous **Designer (Concepteur)**, choisissez **Add trigger (Ajouter un déclencheur)**.

1. Définissez le type de déclencheur sur **CloudWatch Evénements/ EventBridge**.

1. Pour Règle, choisissez **Créer une nouvelle règle**.

1.  Renseignez le nom et la description de la règle.

1. Pour le type de règle, sélectionnez **Expression de planification**.

1. Dans le champ **Expression de planification**, entrez une expression cron. Par exemple, **cron (0) 12 ? \$1 DU LUNDI AU VENDREDI** (\$1).

1. Choisissez **Ajouter**.
**Note**  
Pour plus d'informations, consultez la section [Utilisation de Lambda avec des CloudWatch événements](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html).

## Supprimer les ressources
<a name="scheduled-events-invoking-lambda-destroy"></a>

Félicitations \$1 Vous avez invoqué une fonction Lambda par le biais d'événements CloudWatch planifiés par Amazon à l'aide du. AWS SDK pour JavaScript Comme indiqué au début de ce didacticiel, veillez à désactiver toutes les ressources que vous créez pendant que vous suivez ce didacticiel pour vous assurer que vous n'êtes pas débité. Pour ce faire, supprimez la CloudFormation pile que vous avez créée dans la [Créez les AWS ressources](#scheduled-events-invoking-lambda-provision-resources) rubrique de ce didacticiel, comme suit :

1. Ouvrez la [CloudFormation console]( https://console.aws.amazon.com/cloudformation/home).

1. Sur la page **Stacks**, sélectionnez la pile.

1. Sélectionnez **Supprimer**.

# Création d’un chatbot Amazon Lex
<a name="lex-bot-example"></a>

Vous pouvez créer un chatbot Amazon Lex au sein d'une application Web pour engager les visiteurs de votre site Web. Un chatbot Amazon Lex est une fonctionnalité qui permet de discuter en ligne avec les utilisateurs sans établir de contact direct avec une personne. Par exemple, l'illustration suivante montre un chatbot Amazon Lex qui invite un utilisateur à réserver une chambre d'hôtel.

![\[Chatbot interface demonstrating a hotel booking conversation with user inputs and bot responses.\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/lex_example/chatintro.png)


Le chatbot Amazon Lex créé dans ce AWS didacticiel est capable de gérer plusieurs langues. Par exemple, un utilisateur qui parle français peut saisir du texte en français et obtenir une réponse en français.

![\[Chatbot interface demonstrating Amazon Lex integration with French language support.\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot2.png)


De même, un utilisateur peut communiquer avec le chatbot Amazon Lex en italien.

![\[Chat interface showing Italian language exchange between user and Amazon Lex chatbot.\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot3.png)


Ce AWS didacticiel vous explique comment créer un chatbot Amazon Lex et comment l'intégrer dans une application Web Node.js. Le AWS SDK pour JavaScript (v3) est utilisé pour appeler les AWS services suivants :
+ Amazon Lex
+ Amazon Comprehend
+ Amazon Translate

**Coût de réalisation :** Les AWS services inclus dans ce document sont inclus dans le [niveau AWS gratuit](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc).

**Remarque :** veillez à désactiver toutes les ressources que vous créez pendant que vous suivez ce didacticiel pour vous assurer que vous n'êtes pas débité.

**Pour créer l'application, procédez comme suit :**

1. [Conditions préalables](#lex-bot-example-prerequisites)

1. [Allocation des ressources](#lex-bot-provision-resources)

1. [Création d'un chatbot Amazon Lex](#lex-bot-example-create-lex-bot)

1. [Créez le code HTML](#lex-bot-example-html)

1. [Créez le script du navigateur](#lex-bot-example-script)

1. [Étapes suivantes](#lex-bot-example-next-steps)

## Conditions préalables
<a name="lex-bot-example-prerequisites"></a>

Pour configurer et exécuter cet exemple, vous devez d'abord :
+ Configurez l'environnement du projet pour exécuter ces TypeScript exemples de nœuds et installez les modules requis AWS SDK pour JavaScript et tiers. Suivez les instructions figurant sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/README.md).
+ Créez un fichier de configurations partagé avec vos informations d'identification utilisateur. Pour plus d'informations sur la fourniture d'un fichier d'informations d'identification [partagé, consultez la section Fichiers de configuration et d'informations d'identification](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) partagés dans le *guide de référence AWS SDKs et Tools*.

**Important**  
Cet exemple utilise ECMAScript6 (ES6). Cela nécessite la version 13.x ou supérieure de Node.js. Pour télécharger et installer la dernière version de Node.js, consultez la section [Téléchargements de Node.js.](https://nodejs.org/en/download) .  
Toutefois, si vous préférez utiliser la syntaxe CommonJS, veuillez vous référer à[JavaScript ES6Syntaxe /CommonJS](sdk-example-javascript-syntax.md).

## Créez les AWS ressources
<a name="lex-bot-provision-resources"></a>

Ce didacticiel nécessite les ressources suivantes.
+ Un rôle IAM non authentifié avec des autorisations associées pour :
  + Amazon Comprehend
  + Amazon Translate
  + Amazon Lex

Vous pouvez créer ces ressources manuellement, mais nous vous recommandons de les approvisionner en suivant les AWS CloudFormation instructions de ce didacticiel.

### Créez les AWS ressources à l'aide de CloudFormation
<a name="lex-bot-example-resources-cli"></a>

CloudFormation vous permet de créer et de provisionner des déploiements AWS d'infrastructure de manière prévisible et répétée. Pour plus d'informations CloudFormation, consultez le [guide de AWS CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).

Pour créer la CloudFormation pile à l'aide de AWS CLI :

1. Installez et configurez en AWS CLI suivant les instructions du [guide de l'AWS CLI utilisateur](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Créez un fichier nommé `setup.yaml` dans le répertoire racine du dossier de votre projet et [ GitHubcopiez-y le](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/setup.yaml) contenu.
**Note**  
Le CloudFormation modèle a été généré à l'aide du modèle AWS CDK [disponible ici GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lex_bot_example_iam_unauth_role). Pour plus d'informations à ce sujet AWS CDK, consultez le [guide du AWS Cloud Development Kit (AWS CDK) développeur](https://docs.aws.amazon.com/cdk/latest/guide/).

1. Exécutez la commande suivante depuis la ligne de commande, en la *STACK\$1NAME* remplaçant par un nom unique pour la pile.
**Important**  
Le nom de la pile doit être unique au sein d'une AWS région et d'un AWS compte. Vous pouvez spécifier jusqu'à 128 caractères. Les chiffres et les tirets sont autorisés.

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

   Pour plus d'informations sur les paramètres de `create-stack` commande, consultez le [guide de référence des AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) et le [guide de CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

   Pour afficher les ressources créées, ouvrez la console Amazon Lex, choisissez la pile, puis sélectionnez l'onglet **Ressources**.

## Créer un bot Amazon Lex
<a name="lex-bot-example-create-lex-bot"></a>

**Important**  
Utilisez la version 1 de la console Amazon Lex pour créer le bot. Cet exemple ne fonctionne pas avec les robots créés à l'aide de la V2.

La première étape consiste à créer un chatbot Amazon Lex à l'aide de la console de gestion Amazon Web Services. Dans cet exemple, l'**BookTrip**exemple Amazon Lex est utilisé. Pour plus d'informations, voir [Book Trip](https://docs.aws.amazon.com/lex/latest/dg/ex-book-trip.html).
+ Connectez-vous à la console de gestion Amazon Web Services et ouvrez la console Amazon Lex sur la console [Amazon Web Services](https://console.aws.amazon.com/lex/).
+ Sur la page Bots, choisissez **Create**.
+ Choisissez **BookTrip**Blueprint (conservez le nom du bot par défaut **BookTrip**).  
![\[Interface for creating a chatbot, showing BookTrip sample with conversation flow and components.\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/lex_example/pic2.png)
+ Renseignez les paramètres par défaut et choisissez **Create** (la console affiche le **BookTrip**bot). Dans l'onglet Éditeur, passez en revue les détails des intentions préconfigurées.
+ Testez le bot dans la fenêtre de test. Commencez le test en tapant *Je souhaite réserver une chambre d'hôtel*.  
![\[Chat interface showing a hotel booking conversation with a bot asking for the city.\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/lex_example/ChatBotTest.png)
+ Choisissez **Publier** et spécifiez un nom d'alias (vous aurez besoin de cette valeur pour utiliser le AWS SDK pour JavaScript).

**Note**  
 Vous devez faire référence au **nom** et à l'**alias du bot** dans votre JavaScript code.

## Créez le code HTML
<a name="lex-bot-example-html"></a>

Créez un fichier nommé `index.html`. Copiez et collez le code ci-dessous dans`index.html`. Ce code HTML fait référence`main.js`. Il s'agit d'une version groupée de index.js, qui inclut les AWS SDK pour JavaScript modules requis. Vous allez créer ce fichier dans[Créez le code HTML](#lex-bot-example-html). `index.html`également des références`style.css`, ce qui ajoute les styles. 

```
<!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>
```

Ce code est également disponible [ici sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk#running-a-cdk-app).

## Créez le script du navigateur
<a name="lex-bot-example-script"></a>

Créez un fichier nommé `index.js`. Copiez et collez le code ci-dessous dans`index.js`. Importez les AWS SDK pour JavaScript modules et commandes requis. Créez des clients pour Amazon Lex, Amazon Comprehend et Amazon Translate. Remplacez *REGION* par AWS Region et *IDENTITY\$1POOL\$1ID* par l'ID du pool d'identités que vous avez créé dans le[Créez les AWS ressources](#lex-bot-provision-resources). Pour récupérer cet ID de pool d'identités, ouvrez le pool d'identités dans la console Amazon Cognito, choisissez **Modifier le pool d'identités**, puis choisissez **Exemple de code** dans le menu latéral. L'ID du pool d'identités est affiché en rouge dans la console.

Créez d'abord un `libs` répertoire et créez les objets clients de service requis en créant trois fichiers`comprehendClient.js`,`lexClient.js`, et`translateClient.js`. Collez le code approprié ci-dessous dans chacun d'eux, puis remplacez *REGION* et *IDENTITY\$1POOL\$1ID* dans chaque fichier.

**Note**  
Utilisez l'ID du pool d'identités Amazon Cognito dans lequel vous avez créé. [Créez les AWS ressources à l'aide de 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 };
```

Ce code est disponible [ici GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/libs) .

Créez ensuite un `index.js` fichier et collez-y le code ci-dessous.

 Remplacez *BOT\$1ALIAS* et *BOT\$1NAME* par l'alias et le nom de votre bot Amazon Lex, respectivement, et *USER\$1ID* par un identifiant utilisateur. La fonction `createResponse` asynchrone effectue les opérations suivantes :
+ Prend le texte saisi par l'utilisateur dans le navigateur et utilise Amazon Comprehend pour déterminer son code de langue.
+ Prend le code de langue et utilise Amazon Translate pour traduire le texte en anglais.
+ Prend le texte traduit et utilise Amazon Lex pour générer une réponse.
+ Publie la réponse sur la page du navigateur.

```
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;
```

Ce code est disponible [ici GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/index.html) .

Utilisez maintenant webpack pour regrouper les AWS SDK pour JavaScript modules `index.js` et dans un seul fichier,`main.js`.

1. Si ce n'est pas déjà fait, suivez cet exemple [Conditions préalables](#lex-bot-example-prerequisites) pour installer le webpack. 
**Note**  
Pour plus d'informations sur *Webpack*, consultez[Regroupez des applications avec Webpack](webpack.md).

1. Exécutez la commande suivante dans la ligne de commande JavaScript pour regrouper les informations de cet exemple dans un fichier appelé `main.js` :

   ```
   webpack index.js --mode development --target web --devtool false -o main.js
   ```

## Étapes suivantes
<a name="lex-bot-example-next-steps"></a>

Félicitations \$1 Vous avez créé une application Node.js qui utilise Amazon Lex pour créer une expérience utilisateur interactive. Comme indiqué au début de ce didacticiel, veillez à désactiver toutes les ressources que vous créez pendant que vous suivez ce didacticiel pour vous assurer que vous n'êtes pas débité. Pour ce faire, supprimez la CloudFormation pile que vous avez créée dans la [Créez les AWS ressources](#lex-bot-provision-resources) rubrique de ce didacticiel, comme suit :

1. Ouvrez la [CloudFormation console]( https://console.aws.amazon.com/cloudformation/home).

1. Sur la page **Stacks**, sélectionnez la pile.

1. Sélectionnez **Delete (Supprimer)**.

Pour d'autres exemples AWS interservices, consultez les exemples [AWS SDK pour JavaScript interservices.](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/tutorials.html)