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.

# Utilisez les AWS services du SDK pour JavaScript
<a name="working-with-services"></a>

La AWS SDK pour JavaScript v3 donne accès aux services qu'elle prend en charge par le biais d'un ensemble de classes de clients. À partir de ces classes client, vous créez des objets d'interface de service, couramment appelés *objets de service*. Chaque AWS service pris en charge possède une ou plusieurs classes de clients qui offrent un faible niveau d'utilisation APIs des fonctionnalités et des ressources du service. Par exemple, Amazon APIs DynamoDB est disponible via la classe. `DynamoDB`

Les services exposés via le SDK JavaScript suivent le modèle demande-réponse pour échanger des messages avec les applications d'appel. Dans ce modèle, le code invoquant un service soumet une HTTP/HTTPS demande à un point de terminaison pour le service. La demande contient les paramètres nécessaires pour appeler avec succès la fonction spécifique appelée. Le service qui est appelé génère une réponse qui est renvoyée au demandeur. La réponse contient des données si l'opération a abouti ou les informations relatives à l'erreur si l'opération n'a pas abouti. 

L'appel d'un AWS service inclut le cycle de vie complet des demandes et des réponses d'une opération sur un objet de service, y compris les tentatives de nouvelle tentative. Une requête contient zéro ou plusieurs propriétés sous forme de paramètres JSON. La réponse est encapsulée dans un objet lié à l'opération et est renvoyée au demandeur via l'une des nombreuses techniques, telles qu'une fonction de rappel ou une promesse. JavaScript 

**Topics**
+ [Création et appel d'objets de service](creating-and-calling-service-objects.md)
+ [Appeler les services de manière asynchrone](calling-services-asynchronously.md)
+ [Création de demandes de service pour les clients](the-request-object.md)
+ [Gérer les réponses des clients du service](the-response-object.md)
+ [Travailler avec JSON](working-with-json.md)
+ [Enregistrement AWS SDK pour JavaScript des appels](logging-sdk-calls.md)
+ [Utiliser des points de terminaison AWS basés sur un compte avec DynamoDB](ddb-account-based-endpoints-v3.md)
+ [Protection de l'intégrité des données avec les checksums d'Amazon S3](s3-checksums.md)
+ [SDK pour les exemples de JavaScript code](sdk-code-samples.md)

# Création et appel d'objets de service
<a name="creating-and-calling-service-objects"></a>

L' JavaScript API prend en charge la plupart AWS des services disponibles. Chaque service de l' JavaScriptAPI fournit à une classe client une `send` méthode que vous pouvez utiliser pour appeler toutes les API prises en charge par le service. Pour plus d'informations sur les classes de service, les opérations et les paramètres de l' JavaScript API, consultez la [référence de l'API](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/).

Lorsque vous utilisez le SDK dans Node.js, vous ajoutez le package SDK pour chaque service dont vous avez besoin à l'application que vous utilisez`import`, qui prend en charge tous les services actuels. L'exemple suivant crée un objet de service Amazon S3 dans la `us-west-1` région.

```
// Import the Amazon S3 service client
import { S3Client } from "@aws-sdk/client-s3"; 
// Create an S3 client in the us-west-1 Region
const s3Client = new S3Client({
    region: "us-west-1"
});
```

## Spécifier les paramètres de l'objet de service
<a name="specifying-service-object-parameters"></a>

Lorsque vous appelez une méthode d'un objet de service, transmettez des paramètres au format JSON, comme requis par l'API. Par exemple, dans Amazon S3, pour obtenir un objet pour un compartiment et une clé spécifiques, transmettez les paramètres suivants à la `GetObjectCommand` méthode à partir du`S3Client`. Pour plus d'informations sur la transmission de paramètres JSON, consultez [Travailler avec JSON](working-with-json.md).

```
s3Client.send(new GetObjectCommand({Bucket: 'bucketName', Key: 'keyName'}));
```

Pour plus d'informations sur les paramètres Amazon S3, consultez [@aws -sdk/client-s3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-s3/) dans le guide de référence des API.

## Utilisez @smithy /types pour les clients générés dans TypeScript
<a name="smithy-types"></a>

Si vous l'utilisez TypeScript, le `@smithy/types` package vous permet de manipuler les formes d'entrée et de sortie d'un client.

### Scénario : supprimer `undefined` des structures d'entrée et de sortie
<a name="remove-undefined-from-input"></a>

Les membres des formes générées sont unifiés `undefined` pour les formes d'entrée et sont `?` (facultatifs) pour les formes de sortie. Pour les entrées, cela reporte la validation au service. Pour les sorties, cela suggère fortement que vous devriez vérifier les données de sortie au moment de l'exécution.

Si vous souhaitez ignorer ces étapes, utilisez les aides `AssertiveClient` ou `UncheckedClient` tapez. L'exemple suivant utilise les assistants de type avec le service Amazon S3.

```
import { S3 } from "@aws-sdk/client-s3";
import type { AssertiveClient, UncheckedClient } from "@smithy/types";

const s3a = new S3({}) as AssertiveClient<S3>;
const s3b = new S3({}) as UncheckedClient<S3>;

// AssertiveClient enforces required inputs are not undefined
// and required outputs are not undefined.
const get = await s3a.getObject({
  Bucket: "",
  // @ts-expect-error (undefined not assignable to string)
  Key: undefined,
});

// UncheckedClient makes output fields non-nullable.
// You should still perform type checks as you deem
// necessary, but the SDK will no longer prompt you
// with nullability errors.
const body = await (
  await s3b.getObject({
    Bucket: "",
    Key: "",
  })
).Body.transformToString();
```

Lorsque vous utilisez la transformation sur un client non agrégé avec la `Command` syntaxe, l'entrée ne peut pas être validée car elle passe par une autre classe, comme indiqué dans l'exemple ci-dessous.

```
import { S3Client, ListBucketsCommand, GetObjectCommand, GetObjectCommandInput } from "@aws-sdk/client-s3";
import type { AssertiveClient, UncheckedClient, NoUndefined } from "@smithy/types";

const s3 = new S3Client({}) as UncheckedClient<S3Client>;

const list = await s3.send(
  new ListBucketsCommand({
    // command inputs are not validated by the type transform.
    // because this is a separate class.
  })
);

/**
 * Although less ergonomic, you can use the NoUndefined<T>
 * transform on the input type.
 */
const getObjectInput: NoUndefined<GetObjectCommandInput> = {
  Bucket: "undefined",
  // @ts-expect-error (undefined not assignable to string)
  Key: undefined,
  // optional params can still be undefined.
  SSECustomerAlgorithm: undefined,
};

const get = s3.send(new GetObjectCommand(getObjectInput));

// outputs are still transformed.
await get.Body.TransformToString();
```

### Scénario : réduction des types de blob de charge utile de sortie d'un client TypeScript généré par Smithy
<a name="remove-undefined-from-input"></a>

Ce scénario est principalement pertinent pour les opérations avec des organismes de streaming, comme `S3Client` dans la AWS SDK pour JavaScript v3.

Étant donné que les types de charge utile blob dépendent de la plate-forme, vous souhaiterez peut-être indiquer dans votre application qu'un client s'exécute dans un environnement spécifique. Cela permet de réduire les types de charge utile blob, comme indiqué dans l'exemple suivant.

```
import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
import type { NodeJsClient, SdkStream, StreamingBlobPayloadOutputTypes } from "@smithy/types";
import type { IncomingMessage } from "node:http";

// default client init.
const s3Default = new S3Client({});

// client init with type narrowing.
const s3NarrowType = new S3Client({}) as NodeJsClient<S3Client>;

// The default type of blob payloads is a wide union type including multiple possible
// request handlers.
const body1: StreamingBlobPayloadOutputTypes = (await s3Default.send(new GetObjectCommand({ Key: "", Bucket: "" })))
  .Body!;

// This is of the narrower type SdkStream<IncomingMessage> representing
// blob payload responses using specifically the node:http request handler.
const body2: SdkStream<IncomingMessage> = (await s3NarrowType.send(new GetObjectCommand({ Key: "", Bucket: "" })))
  .Body!;
```

# Appeler les services de manière asynchrone
<a name="calling-services-asynchronously"></a>

Toutes les demandes effectuées via le kit SDK sont asynchrones. Il est important de garder cela à l'esprit lorsque vous écrivez des scripts de navigateur. JavaScript l'exécution dans un navigateur Web ne comporte généralement qu'un seul thread d'exécution. Après avoir effectué un appel asynchrone à un AWS service, le script du navigateur continue de s'exécuter et peut ainsi essayer d'exécuter du code qui dépend de ce résultat asynchrone avant qu'il ne soit renvoyé.

Les appels asynchrones à un AWS service incluent la gestion de ces appels afin que votre code n'essaie pas d'utiliser des données avant qu'elles ne soient disponibles. Les rubriques de cette section expliquent pourquoi il est nécessaire de gérer les appels asynchrones et détaillent les différentes techniques de gestion disponibles.

Bien que vous puissiez utiliser n'importe laquelle de ces techniques pour gérer les appels asynchrones, nous vous recommandons de l'utiliser async/await pour tout nouveau code.

async/wait  
Nous vous recommandons d'utiliser cette technique car il s'agit du comportement par défaut dans la version 3.

promettre  
Utilisez cette technique dans les navigateurs qui ne prennent pas en charge le mode async/await.

rappel  
Évitez d'utiliser des rappels, sauf dans des cas très simples. Toutefois, cela peut vous être utile pour les scénarios de migration.

**Topics**
+ [Gérer les appels asynchrones](making-asynchronous-calls.md)
+ [Utiliser async/await](using-async-await.md)
+ [JavaScript Promesses d'utilisation](using-promises.md)
+ [Utiliser une fonction de rappel anonyme](using-a-callback-function.md)

# Gérer les appels asynchrones
<a name="making-asynchronous-calls"></a>

Par exemple, la page d'accueil d'un site e-commerce autorise le renvoi de la connexion des utilisateurs. Pour les clients qui se connectent, cela présente notamment l'avantage, après connexion, de disposer d'une personnalisation en fonction de leurs préférences. Pour cela :

1. Le client doit se connecter et être validé avec ses identifiants de connexion.

1. La demande des préférences du client est faite auprès d'une base de données client.

1. La base de données fournit les préférences du client qui sont utilisées pour personnaliser le site avant le chargement de la page.

Si ces tâches s'exécutent de façon synchrone, chaque tâche doit se terminer avant le démarrage de la suivante. Le chargement de la page Web ne pourra pas être terminé tant que les préférences du client ne seront pas renvoyées de la base de données. Cependant, une fois que la requête de base de données est envoyée au serveur, la réception des données client peut être retardée ou même échouer en raison d'un goulot d'étranglement, d'un trafic de base de données exceptionnellement dense ou d'une mauvaise connexion d'un appareil mobile.

Pour éviter que le site Web ne se bloque dans ces conditions, appelez la base de données de manière asynchrone. Après l'exécution de l'appel de base de données, si vous envoyez une demande asynchrone, votre code continue de s'exécuter comme prévu. Si vous ne gérez pas correctement la réponse d'un appel asynchrone, votre code peut tenter d'utiliser les informations attendues de la base de données alors que ces données ne sont pas encore disponibles.

![\[Différence entre une exécution synchrone et une exécution asynchrone.\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/async-vs-sync.png)


# Utiliser async/await
<a name="using-async-await"></a>

Plutôt que d'utiliser des promesses, vous devriez envisager d'utiliser async/await. Les fonctions asynchrones sont plus simples à utiliser que les promesses. Await ne peut être utilisé que dans une fonction asynchrone pour attendre une valeur de manière asynchrone.

L'exemple suivant permet async/await de répertorier toutes vos tables Amazon DynamoDB dans. ` us-west-2`

**Note**  
Pour exécuter cet exemple :  
Installez le client AWS SDK pour JavaScript DynamoDB en `npm install @aws-sdk/client-dynamodb` entrant dans la ligne de commande de votre projet.
Assurez-vous d'avoir correctement configuré vos AWS informations d'identification. Pour de plus amples informations, veuillez consulter [Définir les informations d'identification](setting-credentials.md). 

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
(async function () {
  const dbClient = new DynamoDBClient({ region: "us-west-2" });
  const command = new ListTablesCommand({});

  try {
    const results = await dbClient.send(command);
    console.log(results.TableNames.join('\n'));
  } catch (err) {
    console.error(err)
  }
})();
```

**Note**  
 Tous les navigateurs ne prennent pas en charge le mode async/await. Consultez la section [Fonctions asynchrones](https://caniuse.com/#feat=async-functions) pour obtenir la liste des navigateurs async/await compatibles. 

# JavaScript Promesses d'utilisation
<a name="using-promises"></a>

Utilisez la méthode AWS SDK pour JavaScript v3 (`ListTablesCommand`) du client de service pour effectuer l'appel de service et gérer le flux asynchrone au lieu d'utiliser des rappels. L'exemple suivant montre comment obtenir les noms de vos tables Amazon DynamoDB. `us-west-2`

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
const dbClient = new DynamoDBClient({ region: 'us-west-2' });

dbClient.listtables(new ListTablesCommand({}))
  .then(response => {
    console.log(response.TableNames.join('\n'));
  })
  .catch((error) => {
    console.error(error);
  });
```

## Coordonner plusieurs promesses
<a name="multiple-promises"></a>

Dans certains cas, votre code doit effectuer plusieurs appels asynchrones qui nécessitent une action uniquement lorsqu'ils sont tous renvoyés avec succès. Si vous gérez ces appels de méthode asynchrone individuels avec des promesses, vous pouvez créer une autre promesse qui utilise la méthode `all`. 

Cette méthode exécute cette promesse générique si et quand la série de promesses que vous transmettez dans la méthode est exécutée. La fonction de rappel reçoit une série des valeurs des promesses transmises à la méthode `all`.

Dans l'exemple suivant, une AWS Lambda fonction doit effectuer trois appels asynchrones à Amazon DynamoDB, mais elle ne peut se terminer que lorsque les promesses pour chaque appel ont été remplies.

```
const values = await Promise.all([firstPromise, secondPromise, thirdPromise]);

console.log("Value 0 is " + values[0].toString);
console.log("Value 1 is " + values[1].toString);
console.log("Value 2 is " + values[2].toString);

return values;
```

## Support du navigateur et de Node.js pour les promesses
<a name="browser-node-promise-support"></a>

Support pour les JavaScript promesses natives (ECMAScript 2015) dépend du JavaScript moteur et de la version dans lesquels votre code s'exécute. Pour déterminer la prise en charge des JavaScript promesses dans chaque environnement dans lequel votre code doit être exécuté, consultez le [tableau de ECMAScript compatibilité](https://compat-table.github.io/compat-table/es6/) sur GitHub.

# Utiliser une fonction de rappel anonyme
<a name="using-a-callback-function"></a>

Chaque méthode d'objet de service peut accepter une fonction de rappel anonyme comme dernier paramètre. La signature de cette fonction de rappel est la suivante.

```
function(error, data) {
    // callback handling code
};
```

Cette fonction de rappel est exécutée lorsqu'une réponse positive ou des données d'erreur sont renvoyées. Si l'appel de méthode aboutit, le contenu de la réponse est disponible pour la fonction de rappel dans le paramètre `data`. Si l'appel n'aboutit pas, les détails relatifs à l'échec sont disponibles dans le paramètre `error`.

En général, le code à l'intérieur de la fonction de rappel effectue un test afin d'identifier une éventuelle erreur. Si une erreur est renvoyée, elle est traitée par le code. Si aucune erreur n'est renvoyée, le code récupère les données dans la réponse du paramètre `data`. La forme de base de la fonction de rappel ressemble à cet exemple.

```
function(error, data) {
    if (error) {
        // error handling code
        console.log(error);
    } else {
        // data handling code
        console.log(data);
    }
};
```

Dans l'exemple précédent, les détails de l'erreur ou ceux des données renvoyées sont consignés dans la console. Voici un exemple illustrant une fonction de rappel transmise dans le cadre de l'appel d'une méthode sur un objet de service.

```
ec2.describeInstances(function(error, data) {
  if (error) {
    console.log(error); // an error occurred
  } else {
    console.log(data); // request succeeded
  }
});
```

# Création de demandes de service pour les clients
<a name="the-request-object"></a>

Il est simple de faire des demandes aux clients de AWS service. La version 3 (V3) du SDK pour vous JavaScript permet d'envoyer des demandes. 

**Note**  
Vous pouvez également effectuer des opérations à l'aide des commandes de la version 2 (V2) lorsque vous utilisez la version 3 du SDK pour. JavaScript Pour de plus amples informations, veuillez consulter [Utilisation des commandes v2](migrating.md#using_v2_commands).

**Pour envoyer une demande :**

1. Initialisez un objet client avec la configuration souhaitée, telle qu'une AWS région spécifique.

1. (Facultatif) Créez un objet JSON de demande avec les valeurs de la demande, telles que le nom d'un compartiment Amazon S3 spécifique. Vous pouvez examiner les paramètres de la demande en consultant la rubrique de référence de l'API relative à l'interface dont le nom est associé à la méthode client. Par exemple, si vous utilisez la méthode *AbcCommand* client, l'interface de demande est*AbcInput*.

1. Initialisez une commande de service, éventuellement, avec l'objet de demande en entrée.

1. Appelez `send` le client avec l'objet de commande en entrée.

Par exemple, pour répertorier vos tables Amazon DynamoDB, vous pouvez `us-west-2` le faire avec async/await.

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";

(async function () {
  const dbClient = new DynamoDBClient({ region: 'us-west-2' });
  const command = new ListTablesCommand({});

  try {
    const results = await dbClient.send(command);
    console.log(results.TableNames.join('\n'));
  } catch (err) {
    console.error(err);
  }
})();
```

# Gérer les réponses des clients du service
<a name="the-response-object"></a>

Une fois qu'une méthode client de service a été appelée, elle renvoie une instance d'objet de réponse d'une interface dont le nom est associé à la méthode client. Par exemple, si vous utilisez la méthode * AbcCommand* client, l'objet de réponse est de type *AbcResponse* (interface).

## Données d'accès renvoyées dans la réponse
<a name="response-data-property"></a>

L'objet de réponse contient les données, sous forme de propriétés, renvoyées par la demande de service.

Dans[Création de demandes de service pour les clients](the-request-object.md), la ` ListTablesCommand` commande a renvoyé les noms des tables dans la `TableNames` propriété de la réponse.

## Informations sur les erreurs d'accès
<a name="response-error-property"></a>

Si une commande échoue, elle lance une exception. L'extrait de code suivant montre comment gérer une exception de service.

```
try {
  await client.send(someCommand);
} catch (e) {
  if (e.name === "InvalidSignatureException") {
    // Handle InvalidSignatureException
  } else if (e.name === "ResourceNotFoundException") {
    // Handle ResourceNotFoundException
  } else if (e.name === "FooServiceException") {
    // Handle all other server-side exceptions from Foo service
  } else {
    // Handle errors from SDK
  }
}
```

# Travailler avec JSON
<a name="working-with-json"></a>

Le format JSON est un format d'échange de données à la fois lisible par l'homme et lisible par machine. Bien que le nom JSON soit l'acronyme de *JavaScript Object Notation*, le format JSON est indépendant de tout langage de programmation.

Il AWS SDK pour JavaScript utilise le JSON pour envoyer des données aux objets de service lorsqu'il fait des demandes et reçoit les données des objets de service au format JSON. Pour plus d'informations sur le format JSON, consultez [json.org](https://json.org).

![\[Format général et éléments JSON.\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/json-format.png)


JSON représente les données de deux manières :
+ En tant qu'*objet*, qui est une collection non ordonnée de paires nom-valeur. Un objet est défini entre des accolades gauche (`{`) et droite (`}`). Chaque paire nom-valeur commence par le nom, suivi de deux points, suivi de la valeur. Les paires nom-valeur sont séparées par des virgules.
+ En tant que *tableau*, qui est une collection ordonnée de valeurs. Une série est définie entre crochets gauche (`[`) et droit (`]`). Les éléments de la série sont séparés par des virgules.

Voici un exemple d'un objet JSON contenant une série d'objets dans laquelle les objets représentent des cartes d'un jeu. Chaque carte est définie par deux paires nom-valeur. L'une spécifie une valeur unique qui identifie cette carte et l'une autre spécifie une URL qui pointe vers l'image de la carte correspondante.

```
var cards = [
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"},
  {"CardID":"defaultname", "Image":"defaulturl"}
];
```

## JSON en tant que paramètres d'objet de service
<a name="json-as-parameters-passed"></a>

Voici un exemple de JSON simple utilisé pour définir les paramètres d'un appel à un objet AWS Lambda de service.

```
const params = {
   FunctionName : funcName,
   Payload : JSON.stringify(payload),
   LogType : LogType.Tail,
};
```

L'objet `params` est défini par trois paires nom-valeur, séparées par des virgules et entourées d'accolades gauche et droite. Lorsque vous fournissez des paramètres à un appel de méthode d'objet de service, les noms sont déterminés par les noms de paramètres pour la méthode d'objet de service que vous prévoyez d'appeler. Lors de l'appel d'une fonction Lambda`FunctionName`,,`Payload`, ` LogType` et sont les paramètres utilisés pour appeler la méthode sur un `invoke` objet de service Lambda.

Lorsque vous transmettez des paramètres à un appel de méthode d'objet de service, fournissez l'objet JSON à l'appel de méthode, comme illustré dans l'exemple suivant d'appel d'une fonction Lambda.

```
const invoke = async (funcName, payload) => {
  const client = new LambdaClient({});
  const command = new InvokeCommand({
    FunctionName: funcName,
    Payload: JSON.stringify(payload),
    LogType: LogType.Tail,
  });

  const { Payload, LogResult } = await client.send(command);
  const result = Buffer.from(Payload).toString();
  const logs = Buffer.from(LogResult, "base64").toString();
  return { logs, result };
};
```

# Enregistrement AWS SDK pour JavaScript des appels
<a name="logging-sdk-calls"></a>

 AWS SDK pour JavaScript Il est équipé d'un enregistreur intégré qui vous permet de consigner les appels d'API que vous effectuez avec le SDK pour. JavaScript

Pour activer l'enregistreur et imprimer les entrées du journal dans la console, configurez le client de service à l'aide du `logger` paramètre facultatif. L'exemple ci-dessous active la journalisation du client tout en ignorant les résultats de trace et de débogage.

```
new S3Client({
  logger: {
    ...console,
    debug(...args) {},
    trace(...args) {},
  },
});
```

## Utilisation d'un intergiciel pour enregistrer les demandes
<a name="middleware-logger"></a>

Il AWS SDK pour JavaScript utilise une pile intergicielle pour contrôler le cycle de vie d'un appel d'opération. Chaque intergiciel de la pile appelle le middleware suivant après avoir apporté des modifications à l'objet de la requête. Cela facilite également le débogage des problèmes dans la pile, car vous pouvez voir exactement quel intergiciel a été appelé à l'origine d'une erreur. Voici un exemple de journalisation des demandes à l'aide d'un intergiciel :

```
const client = new DynamoDB({ region: "us-west-2" });

client.middlewareStack.add(
  (next, context) => async (args) => {
    console.log("AWS SDK context", context.clientName, context.commandName);
    console.log("AWS SDK request input", args.input);
    const result = await next(args);
    console.log("AWS SDK request output:", result.output);
    return result;
  },
  {
    name: "MyMiddleware",
    step: "build",
    override: true,
  }
);

await client.listTables({});
```

Dans l'exemple ci-dessus, un intergiciel est ajouté à la pile d'intergiciels du client DynamoDB. Le premier argument est une fonction qui accepte`next`, le prochain intergiciel de la pile à appeler et `context` un objet contenant des informations sur l'opération appelée. Il renvoie une fonction qui accepte`args`, un objet contenant les paramètres transmis à l'opération et à la demande, et il renvoie le résultat de l'appel du prochain intergiciel avec. `args`

# Utiliser des points de terminaison AWS basés sur un compte avec DynamoDB
<a name="ddb-account-based-endpoints-v3"></a>

DynamoDB [AWS propose des points de terminaison basés sur des comptes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.SDKOverview.html#Programming.SDKs.endpoints) qui peuvent améliorer les performances en utilisant AWS votre identifiant de compte pour rationaliser le routage des demandes. 

Pour tirer parti de cette fonctionnalité, vous devez utiliser la version 3.656.0 ou supérieure de la AWS SDK pour JavaScript version 3. Cette fonctionnalité de point de terminaison basée sur un compte est activée par défaut dans cette nouvelle version.

Si vous souhaitez désactiver le routage basé sur le compte, vous disposez des options suivantes :
+ Configurez un client de service DynamoDB avec `accountIdEndpointMode` le paramètre défini sur. `disabled`
+ Définissez la variable d'environnement `AWS_ACCOUNT_ID_ENDPOINT_MODE` sur`disabled`.
+ Mettez à jour le paramètre du fichier de AWS configuration partagé `account_id_endpoint_mode` sur`disabled`.

L'extrait suivant illustre comment désactiver le routage basé sur un compte en configurant un client de service DynamoDB :

```
const ddbClient = new DynamoDBClient({
  region: "us-west-2",
  accountIdEndpointMode: "disabled" // Disable account ID in the endpoint
});
```

Le guide de référence AWS SDKs and Tools fournit plus d'informations sur les [autres options de configuration](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html).

# Protection de l'intégrité des données avec les checksums d'Amazon S3
<a name="s3-checksums"></a>

Amazon Simple Storage Service (Amazon S3) permet de spécifier une somme de contrôle lorsque vous chargez un objet. Lorsque vous spécifiez une somme de contrôle, elle est stockée avec l'objet et peut être validée lors du téléchargement de l'objet.

Les checksums fournissent une couche supplémentaire d'intégrité des données lorsque vous transférez des fichiers. Avec les checksums, vous pouvez vérifier la cohérence des données en confirmant que le fichier reçu correspond au fichier d'origine. Pour plus d'informations sur les checksums avec Amazon S3, consultez le [guide de l'utilisateur d'Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html), y compris les [algorithmes pris en charge](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums).

Vous avez la possibilité de choisir l'algorithme qui répond le mieux à vos besoins et de laisser le SDK calculer le checksum. Vous pouvez également fournir une valeur de somme de contrôle précalculée à l'aide de l'un des algorithmes pris en charge.

**Note**  
À partir de la version 3.729.0 du AWS SDK pour JavaScript, le SDK fournit des protections d'intégrité par défaut en calculant automatiquement une `CRC32` somme de contrôle pour les téléchargements. Le SDK calcule cette somme de contrôle si vous ne fournissez pas de valeur de somme de contrôle précalculée ou si vous ne spécifiez pas d'algorithme que le SDK doit utiliser pour calculer une somme de contrôle.  
Le SDK fournit également des paramètres globaux pour les protections de l'intégrité des données que vous pouvez définir en externe, que vous pouvez consulter dans le [Guide de référence AWS SDKs et sur les outils](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html).

## Charger un objet
<a name="use-service-S3-checksum-upload"></a>

Vous chargez des objets sur Amazon S3 à l'aide de la [PutObject](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectCommand/)commande du`S3Client`. Utilisez le `ChecksumAlgorithm` paramètre du générateur pour activer le calcul `PutObjectRequest` de la somme de contrôle et spécifier l'algorithme. Consultez les [algorithmes de somme de contrôle pris en charge](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums) pour connaître les valeurs valides.

L'extrait de code suivant montre une demande de téléchargement d'un objet avec une somme de contrôle CRC-32. Lorsque le SDK envoie la demande, il calcule le checksum CRC-32 et télécharge l'objet. Amazon S3 stocke le checksum avec l'objet.

```
import { ChecksumAlgorithm, S3 } from "@aws-sdk/client-s3";

const client = new S3();
const response = await client.putObject({
  Bucket: "my-bucket",
  Key: "my-key",
  Body: "Hello, world!",
  ChecksumAlgorithm: ChecksumAlgorithm.CRC32,
});
```

Si vous ne fournissez pas d'algorithme de somme de contrôle avec la demande, le comportement de somme de contrôle varie en fonction de la version du SDK que vous utilisez, comme indiqué dans le tableau suivant.

**Comportement de somme de contrôle lorsqu'aucun algorithme de somme de contrôle n'est fourni**


| SDK pour la version JavaScript  | Comportement de Checksum | 
| --- | --- | 
| Antérieur à 3.729.0 | Le SDK ne calcule pas automatiquement une somme de contrôle basée sur le CRC et ne la fournit pas dans la demande. | 
| 3.729.0 ou version ultérieure | Le SDK utilise l'CRC32algorithme pour calculer le checksum et le fournit dans la demande. Amazon S3 valide l'intégrité du transfert en calculant sa propre somme de CRC32 contrôle et en la comparant à la somme de contrôle fournie par le SDK. Si les sommes de contrôle correspondent, la somme de contrôle est enregistrée avec l'objet. | 

Si la somme de contrôle calculée par le SDK ne correspond pas à la somme de contrôle calculée par Amazon S3 lorsqu'il reçoit la demande, une erreur est renvoyée.

### Utiliser une valeur de somme de contrôle précalculée
<a name="use-service-S3-checksum-upload-pre"></a>

Une valeur de somme de contrôle précalculée fournie avec la demande désactive le calcul automatique par le SDK et utilise la valeur fournie à la place.

L'exemple suivant montre une demande avec une somme de contrôle SHA-256 précalculée.

```
import { S3 } from "@aws-sdk/client-s3";
import { createHash } from "node:crypto";

const client = new S3();

const Body = "Hello, world!";
const ChecksumSHA256 = await createHash("sha256").update(Body).digest("base64");

const response = await client.putObject({
  Bucket: "my-bucket",
  Key: "my-key",
  Body,
  ChecksumSHA256,
});
```

Si Amazon S3 détermine que la valeur de la somme de contrôle est incorrecte pour l'algorithme spécifié, le service renvoie une réponse d'erreur.

### Chargements partitionnés
<a name="use-service-S3-checksum-upload-multi"></a>

Vous pouvez également utiliser des checksums pour les téléchargements partitionnés. Ils AWS SDK pour JavaScript peuvent utiliser les options de la `Upload` bibliothèque pour former et `@aws-sdk/lib-storage` utiliser des checksums avec des téléchargements partitionnés.

```
import { ChecksumAlgorithm, S3 } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import { createReadStream } from "node:fs";

const client = new S3();
const filePath = "/path/to/file";
const Body = createReadStream(filePath);

const upload = new Upload({
  client,
  params: {
    Bucket: "my-bucket",
    Key: "my-key",
    Body,
    ChecksumAlgorithm: ChecksumAlgorithm.CRC32,
  },
});
await upload.done();
```

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