[AWS SDK for JavaScript V3 API リファレンスガイド](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/)では、 AWS SDK for JavaScript バージョン3 (V3) のすべての API オペレーションについて詳しく説明します。

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# SDK for JavaScript で AWS のサービスを操作する
<a name="working-with-services"></a>

 AWS SDK for JavaScript v3 は、クライアントクラスのコレクションを通じてサポートされるサービスへのアクセスを提供します。これらのクライアントクラスから、一般に*サービスオブジェクト*と呼ばれるサービスインターフェイスオブジェクトが作成されます。サポートされている各 AWS サービスには、サービスの機能とリソースを使用するための低レベル APIs を提供する 1 つ以上のクライアントクラスがあります。例えば、Amazon DynamoDB API は、`DynamoDB` クラスから利用できます。

SDK for JavaScript を通じて公開されるサービスは、リクエストレスポンスのパターンに従って、呼び出し元のアプリケーションとメッセージを交換します。このパターンでは、サービスを呼び出すコードが HTTP/HTTPS リクエストをそのサービスのエンドポイントに送信します。リクエストには、呼び出されている特定の機能を正常に呼び出すために必要なパラメータが含まれています。呼び出されたサービスは、リクエスタに返されるレスポンスを生成します。オペレーションが成功した場合、レスポンスにはデータが含まれています。オペレーションが失敗した場合は、エラー情報が含まれています。

 AWS サービスの呼び出しには、再試行を含む、サービスオブジェクトに対するオペレーションのリクエストとレスポンスのライフサイクル全体が含まれます。リクエストには、JSON パラメータとして 0 個以上のプロパティが含まれています。レスポンスは、操作に関連するオブジェクトによってカプセル化され、コールバック機能や JavaScript promise などのいくつかの手法の1つを通してリクエスタに返信されます。

**Topics**
+ [サービスオブジェクトを作成して呼び出す](creating-and-calling-service-objects.md)
+ [非同期的なサービスを呼び出す](calling-services-asynchronously.md)
+ [サービスクライアントのリクエストを作成する](the-request-object.md)
+ [サービスクライアントのレスポンスを処理する](the-response-object.md)
+ [JSON を使用する](working-with-json.md)
+ [AWS SDK for JavaScript 通話のログ記録](logging-sdk-calls.md)
+ [DynamoDB で AWS アカウントベースのエンドポイントを使用する](ddb-account-based-endpoints-v3.md)
+ [Amazon S3 チェックサムによるデータ整合性保護](s3-checksums.md)
+ [SDK for JavaScript のコードサンプル](sdk-code-samples.md)

# サービスオブジェクトを作成して呼び出す
<a name="creating-and-calling-service-objects"></a>

JavaScript API は、利用可能なほとんどの AWS サービスをサポートしています。JavaScript APIの各サービスは、サービスがサポートするすべてのAPIを呼び出すために使用する`send`メソッドをクライアントクラスに提供します。JavaScript API のサービスクラス、オペレーション、およびパラメータの詳細については、[[ API Reference ]](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/)を参照してください。

Node.jsでSDKを使用する場合は、`import`を使用して、必要な各サービスのSDKパッケージをアプリケーションに追加します。これにより、現在のすべてのサービスがサポートされます。次の例では、`us-west-1`地域に Amazon S3 サービスオブジェクトを作成します。

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

## サービスオブジェクトのパラメータを指定する
<a name="specifying-service-object-parameters"></a>

サービスオブジェクトのメソッドを呼び出す場合、API の必要に応じて JSON でパラメータを渡します。例えば、Amazon S3 では、指定されたバケットとキーのオブジェクトを取得するために、`S3Client` から `GetObjectCommand` メソッドに以下のパラメータを渡します。JSON パラメータを渡す詳細については、「[JSON を使用する](working-with-json.md)」を参照してください。

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

Amazon S3 パラメータの詳細については、API リファレンスの「[@aws-sdk/client-s3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-s3/)」を参照してください。

## TypeScript で生成されたクライアントに @smithy/types を使用する
<a name="smithy-types"></a>

TypeScript を使用している場合、`@smithy/types` パッケージを使用すると、クライアントの入出力シェイプを操作できます。

### シナリオ: 入力構造と出力構造から `undefined` を削除する
<a name="remove-undefined-from-input"></a>

生成されたシェイプのメンバーは、入力シェイプの場合は `undefined` とのユニオン型になり、出力シェイプの場合は `?` (オプション) になります。入力の場合、検証はサービス側で処理されます。出力の場合、実行時に出力データを検証することを強くお勧めします。

これらのステップをスキップする場合は、`AssertiveClient` または `UncheckedClient` の型ヘルパーを使用します。次の例では、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();
```

非集約クライアントで `Command` 構文を使用して変換を使用する場合、以下の例に示すように、入力は別のクラスを通過するため、検証できません。

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

### シナリオ: Smithy-TypeScript で生成されたクライアントの出力ペイロード BLOB タイプを絞り込む
<a name="remove-undefined-from-input"></a>

このシナリオは、 AWS SDK for JavaScript v3 の 内などのストリーミング本文を使用するオペレーション`S3Client`に主に関連します。

BLOB ペイロードタイプはプラットフォームに依存するため、クライアントが特定の環境で実行されていることをアプリケーションで指定することが必要な場合があります。これにより、次の例に示すように BLOB ペイロードタイプが絞り込まれます。

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

# 非同期的なサービスを呼び出す
<a name="calling-services-asynchronously"></a>

SDK を介して行われるリクエストはすべて非同期です。ブラウザスクリプトを作成するときに、この点に注意してください。通常、ウェブブラウザで実行されている JavaScript には、1 つの実行スレッドしかありません。 AWS サービスに対して非同期呼び出しを行った後、ブラウザスクリプトは実行を継続し、プロセスで、返される前にその非同期結果に依存するコードの実行を試みることができます。

 AWS サービスへの非同期呼び出しには、これらの呼び出しの管理が含まれます。これにより、コードはデータが利用可能になる前にデータを使用しようとしません。このセクションのトピックでは、非同期呼び出し管理の必要性を説明し、それらを管理するために使用できるさまざまな手法について詳しく説明します。

非同期呼び出しを管理するには、これらの方法のいずれかを使用できますが、すべての新しいコードに対して非同期/待機を使用することをお勧めします。

非同期/待機  
V3 のデフォルトの動作であるため、この手法を使用することをお勧めします。

promise  
非同期/待機 をサポートしないブラウザで、この手法を使用します。

コールバックします  
非常に単純な場合を除き、コールバックの使用は避けてください。ただし、移行シナリオでは役立つ場合があります。

**Topics**
+ [非同期呼び出しを管理する](making-asynchronous-calls.md)
+ [async/await を使用する](using-async-await.md)
+ [JavaScript Promises を使用する](using-promises.md)
+ [無名コールバック関数を使用する](using-a-callback-function.md)

# 非同期呼び出しを管理する
<a name="making-asynchronous-calls"></a>

たとえば、e コマースウェブサイトのホームページは、リピート顧客がサインインするようにします。サインインする顧客にとっての利点の 1 つは、サインイン後に、顧客の特定の好みに合わせてサイトがカスタマイズされることです。これを実現するには、以下のことが必要です。

1. 顧客はログインし、サインイン認証情報で認証を受ける必要があります。

1. 顧客の好みは顧客データベースからリクエストされます。

1. データベースは、ページがロードされる前に、サイトのカスタマイズに使用される顧客の好みを提供します。

これらのタスクが同期的に実行される場合、それぞれの処理が完了してからでなければ、次が開始できません。データベースから顧客選定が戻るまで、ウェブページはロードを終了することはできません。しかし、データベースクエリがサーバーに送信された後、ネットワークのボトルネック、異常に高いデータベーストラフィック、またはモバイルデバイスの接続不良のために、顧客データの受信が遅れたり、失敗することさえあります。

このような状況でウェブサイトがフリーズしないようにするため、データベースを非同期的に呼び出します。データベース呼び出しが実行され、非同期リクエストが送信された後も、コードは想定どおりに継続して実行されます。非同期呼び出しのレスポンスを適切に管理しないと、コードは、データベースから返されると想定される情報がまだ利用できないときに、そのデータを使用しようとする可能性があります。

![\[同期実行と非同期実行の違いを表示。\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/async-vs-sync.png)


# async/await を使用する
<a name="using-async-await"></a>

promise を使用するのではなく、async/await の使用を検討する必要があります。async 関数は、promise を使用するよりもシンプルで、使用する定型コードが少なくなります。await は、async 関数内でのみ使用して、値を非同期的に待機することができます。

次の例では、async/await を使用して、すべての Amazon DynamoDB テーブルを ` us-west-2` で一覧表示します。

**注記**  
この例を実行するには、  
プロジェクトのコマンドライン`npm install @aws-sdk/client-dynamodb`に を入力して、 AWS SDK for JavaScript DynamoDB クライアントをインストールします。
 AWS 認証情報が正しく設定されていることを確認します。詳細については、「[認証情報の設定](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)
  }
})();
```

**注記**  
 すべてのブラウザが async/await をサポートしているわけではありません。非同期/待機をサポートするブラウザのリストについては、[非同期関数](https://caniuse.com/#feat=async-functions)を参照してください。

# JavaScript Promises を使用する
<a name="using-promises"></a>

コールバックを使用する代わりに、サービスクライアントの AWS SDK for JavaScript v3 `ListTablesCommand` メソッド () を使用してサービス呼び出しを行い、非同期フローを管理します。次の例は、「Amazon DynamoDB」(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);
  });
```

## 複数の Promises を調整する
<a name="multiple-promises"></a>

状況によって、コードは複数の非同期呼び出しを行う必要があります。すべてが正常に返されたときのみ、これらの呼び出しに対する操作が必要です。これらの個々の非同期メソッド呼び出しを promises で管理する場合、`all` メソッドを使用する追加の promise を作成することができます。

このメソッドは、ユーザーがメソッドに渡す promise の配列が満たされた場合に、この包括的な promise を満たします。コールバック関数には、`all` メソッドに渡された promises の値の配列が渡されます。

次の例では、 AWS Lambda 関数は Amazon DynamoDB に対して 3 つの非同期呼び出しを行う必要がありますが、各呼び出しの promise が満たされた後にのみ完了できます。

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

## ブラウザおよび Node.js による Promises のサポート
<a name="browser-node-promise-support"></a>

ネイティブ JavaScript の promises (ECMAScript 2015) のサポートは、コードが実行される JavaScript エンジンとバージョンによって異なります。コードを実行する必要がある各環境における JavaScript Promise のサポートを確認するには、GitHub の「[ECMAScript 互換性の表](https://compat-table.github.io/compat-table/es6/)」を参照してください。

# 無名コールバック関数を使用する
<a name="using-a-callback-function"></a>

各サービスオブジェクトメソッドは、最後のパラメータとして無名コールバック機能を受け取ることができます。このコールバック機能の特性は次のとおりです。

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

このコールバック関数が実行されるのは、成功したレスポンスまたはエラーデータが返されたときです。メソッドの呼び出しに成功すると、レスポンスの内容は `data` パラメータでコールバック関数に利用可能になります。呼び出しが成功しない場合、エラーの詳細は `error` パラメータに記載されます。

通常、コールバック関数内のコードはエラーをテストし、エラーが返された場合はそれを処理します。エラーが返されない場合、コードは `data` パラメータからレスポンス内のデータを取得します。コールバック関数の基本的な形式は次の例のようになります。

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

前の例では、エラーまたは返されたデータの詳細がコンソールのログに記録されます。サービスオブジェクトのメソッド呼び出しの一部として渡されるコールバック関数の例を、次に示します。

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

# サービスクライアントのリクエストを作成する
<a name="the-request-object"></a>

 AWS サービスクライアントへのリクエストは簡単です。SDK for JavaScripのバージョン 3 (V3) では、リクエストの送信を行うことができます。

**注記**  
SDK for JavaScript の V3 を使用する場合は、バージョン 2 (V2)のコマンドを使用して操作を行うこともできます。詳細については、「[v2 コマンドの使用](migrating.md#using_v2_commands)」を参照してください。

**リクエストを送信するには**

1. クライアントオブジェクトを特定の AWS 地域など、希望する設定で初期化します。

1. (オプション) 特定の Amazon S3 バケットの名前など、リクエストの値を持つリクエストJSON オブジェクトを作成します。クライアントメソッドに関連付けられた名前を持つインターフェイスの API リファレンスのトピックを参照して、リクエストのパラメータを調べることができます。たとえば、*abcCommand*クライアントクライアントメソッドを使用した場合、リクエストインターフェイスは *ABCInput*となります。

1. オプションで、リクエストオブジェクトを入力としてサービスコマンドを初期化します。

1. コマンドオブジェクトを入力として、クライアントで`send`を呼び出します。

たとえば、Amazon DynamoDB テーブルを`us-west-2`で一覧表示するには、非同期/待機で実行できます。

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

# サービスクライアントのレスポンスを処理する
<a name="the-response-object"></a>

サービスクライアントメソッドが呼び出されると、クライアントメソッドに関連付けられた名前を持つインタフェースのレスポンスオブジェクトインスタンスを返信します。例えば、*AbcCommand* クライアントメソッドを使用した場合、レスポンスオブジェクトは *AbcResponse* (インタフェース) タイプになります。

## レスポンスで返されたデータにアクセスする
<a name="response-data-property"></a>

レスポンスオブジェクトには、サービスリクエストによって戻されたデータがプロパティとして含まれています。

[サービスクライアントのリクエストを作成する](the-request-object.md)では、` ListTablesCommand`コマンドがレスポンスの`TableNames`のプロパティのテーブル名を返しました。

## エラー情報にアクセスする
<a name="response-error-property"></a>

コマンドが失敗した場合、例外が発生します。次のコードスニペットは、サービス例外を処理する方法を示しています。

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

# JSON を使用する
<a name="working-with-json"></a>

JSON は、人間にも機械にも読み取り可能な、データ交換のためのフォーマットです。JSON という名前は、*[ JavaScript Object Notation ]*の頭字語ですが、JSON の形式はどのプログラミング言語にも依存しません。

は JSON AWS SDK for JavaScript を使用して、リクエストを行うときにサービスオブジェクトにデータを送信し、サービスオブジェクトからデータを JSON として受信します。JSON の詳細については、[json.org](https://json.org) を参照してください。

![\[JSON の一般的なフォーマットと一部を表示しています。\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/json-format.png)


JSON は 2 つの方法でデータを表します。
+ *[ object ]*としては、名前と値のペアの順不同のコレクションです。オブジェクトは左中括弧 (`{`) と右中括弧 (`}`) で囲んで定義します。それぞれの名前と値のペアは名前で始まり、続けてコロン、その後に値が続きます。名前と値のペアはカンマで区切ります。
+ *[ array ]*としては、値の順序付けられたコレクションです。配列は左角括弧 (`[`) と右角括弧 (`]`) で囲んで定義します。配列の項目はカンマで区切ります。

これは、オブジェクトの配列を含む JSON オブジェクトの例です。オブジェクトは、カードゲームのカードを表しています。各カードは 2 つの名前と値のペアで定義されます。1 つはそのカードを識別するための一意の値を指定し、もう 1 つは対応するカードイメージを指す URL を指定します。

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

## サービスオブジェクトパラメータとしての JSON
<a name="json-as-parameters-passed"></a>

これは、 AWS Lambda サービスオブジェクトへの呼び出しのパラメーターを定義するために使用される単純なJSONの例です。

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

`params` オブジェクトは、左右の中括弧内にコンマで区切られた、3 つの名前と値のペアによって定義されています。サービスオブジェクトメソッドの呼び出しにパラメータを指定する場合、呼び出す予定のサービスオブジェクトメソッドのパラメータ名によって名前が決まります。Lambda 関数を呼び出すとき、`FunctionName`、`Payload`、および ` LogType` は、Lambda サービスオブジェクトの `invoke` メソッドの呼び出しに使用されるパラメータです。

サービスオブジェクトのメソッド呼び出しにパラメータを渡すとき、次の Lambda 関数の呼び出しの例に示されているように、メソッド呼び出しに JSON オブジェクトを渡します。

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

# AWS SDK for JavaScript 通話のログ記録
<a name="logging-sdk-calls"></a>

 AWS SDK for JavaScript には組み込みロガーが実装されているため、SDK for JavaScript で行った API コールを記録できます。

ロガーを有効にしてコンソールにログエントリを出力するには、オプションの `logger` パラメータを使用してサービスクライアントを設定します。次の例では、トレース出力とデバッグ出力を無視しながらクライアントログ記録を有効にします。

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

## ミドルウェアを使用してリクエストをログに記録する
<a name="middleware-logger"></a>

 AWS SDK for JavaScript はミドルウェアスタックを使用して、オペレーション呼び出しのライフサイクルを制御します。スタック内の各ミドルウェアは、リクエストオブジェクトに変更を加えた後、次のミドルウェアを呼び出します。また、エラーに至るまでに呼び出されたミドルウェアを正確に確認できるため、スタック内の問題のデバッグがはるかに簡単になります。ミドルウェアを使用したリクエストのログ記録の例を次に示します。

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

上記の例では、ミドルウェアが DynamoDB クライアントのミドルウェアスタックに追加されています。最初の引数は関数で、スタック内で次に呼び出されるミドルウェアである `next` と、呼び出されるオペレーションに関する情報を含む `context` オブジェクトを受け取ります。この関数はさらに、オペレーションに渡されたパラメータとリクエストを含む `args` オブジェクトを受け取り、`args` を使って次のミドルウェアを呼び出した結果を返します。

# DynamoDB で AWS アカウントベースのエンドポイントを使用する
<a name="ddb-account-based-endpoints-v3"></a>

DynamoDB は[AWS 、アカウント ID を使用してリクエストのルーティングを合理化することで、パフォーマンスを向上させることができるアカウントベースのエンドポイント](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.SDKOverview.html#Programming.SDKs.endpoints)を提供します。 AWS 

この機能を利用するには、 AWS SDK for JavaScript バージョン 3 のバージョン 3.656.0 以降を使用する必要があります。このアカウントベースのエンドポイント機能は、この新しいバージョンではデフォルトで有効になっています。

アカウントベースのルーティングをオプトアウトする場合は、次のオプションがあります。
+ `accountIdEndpointMode` パラメータを `disabled` に設定して DynamoDB サービスクライアントを設定します。
+ `AWS_ACCOUNT_ID_ENDPOINT_MODE` 環境変数を `disabled` に設定します。
+ 共有 AWS 設定ファイル設定を `account_id_endpoint_mode`に更新します`disabled`。

次のスニペットは、DynamoDB サービスクライアントを設定してアカウントベースのルーティングを無効にする方法の例です。

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

 AWS SDKs およびツールリファレンスガイドには、[他の設定オプション](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html)に関する詳細が記載されています。

# Amazon S3 チェックサムによるデータ整合性保護
<a name="s3-checksums"></a>

Amazon Simple Storage Service (Amazon S3) では、オブジェクトをアップロードするときにチェックサムを指定できます。チェックサムを指定すると、そのチェックサムはオブジェクトとともに保存され、オブジェクトのダウンロード時に検証できます。

チェックサムは、ファイルを転送する際のデータの整合性をさらに強化します。チェックサムを使用すると、受信したファイルが元のファイルと一致することを確認することで、データ整合性を検証できます。Amazon S3 でのチェックサムの詳細については、[サポート対象アルゴリズム](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums)など、「[Amazon Simple Storage Service ユーザーガイド](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html)」を参照してください。

ニーズに最適なアルゴリズムを柔軟に選択して、SDK にチェックサムを計算させることができます。または、サポートされているアルゴリズムのいずれかを使用して、事前に計算された独自のチェックサム値を指定することもできます。

**注記**  
 AWS SDK for JavaScriptのバージョン 3.729.0 以降、SDK はアップロードの `CRC32` チェックサムを自動的に計算することで、デフォルトの整合性保護を提供します。事前計算されたチェックサム値を指定しない場合や、SDK がチェックサムの計算に使用するアルゴリズムを指定しない場合、SDK はこのチェックサムを計算します。  
SDK には、外部で設定できるデータ整合性保護のグローバル設定も用意されています。詳細については、「[AWS SDKs とツールリファレンスガイド](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html)」を参照してください。

## オブジェクトのアップロード
<a name="use-service-S3-checksum-upload"></a>

オブジェクトを Amazon S3 にアップロードするには、`S3Client` の [PutObject](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/command/PutObjectCommand/) コマンドを使用します。`PutObjectRequest` のビルダーの `ChecksumAlgorithm` パラメータを使用してチェックサム計算を有効にし、アルゴリズムを指定します。有効な値については、[サポートされているチェックサムアルゴリズム](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums)を参照してください。

次のコードスニペットは、CRC-32 チェックサムを含むオブジェクトをアップロードするリクエストを示しています。SDK はリクエストを送信すると、CRC-32 チェックサムを計算してオブジェクトをアップロードします。Amazon S3 はオブジェクトと共にチェックサムを保存します。

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

リクエストでチェックサムアルゴリズムを指定しない場合、チェックサムの動作は、次の表に示すように、使用する SDK のバージョンによって異なります。

**チェックサムアルゴリズムが指定されていない場合のチェックサムの動作**


| SDK for JavaScript のバージョン | チェックサムの動作 | 
| --- | --- | 
| 3.729.0 より前 | SDK は、CRC ベースのチェックサムを自動的に計算してリクエストに含めることはありません。 | 
| 3.729.0 以降 | SDK は、CRC32 アルゴリズムを使用してチェックサムを計算し、リクエストに含めます。Amazon S3 は、独自の CRC32 チェックサムを計算して転送の整合性を検証し、SDK が提供するチェックサムと比較します。チェックサムが一致した場合、チェックサムはオブジェクトとともに保存されます。 | 

SDK が計算するチェックサムが、Amazon S3 がリクエストを受信したときに計算するチェックサムと一致しない場合、エラーが返されます。

### 事前に計算されたチェックサム値を使用してください。
<a name="use-service-S3-checksum-upload-pre"></a>

リクエストで事前に計算されたチェックサム値を指定すると、SDK による自動計算が無効になり、代わりに提供された値が使用されます。

次の例は、事前に計算された SHA-256 チェックサムを含むリクエストを示しています。

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

Amazon S3 が、指定されたアルゴリズムのチェックサム値が正しくないと判断した場合、サービスはエラーレスポンスを返します。

### マルチパートアップロード
<a name="use-service-S3-checksum-upload-multi"></a>

チェックサムはマルチパートアップロードでも使用できます。 AWS SDK for JavaScript は、 から への`Upload`ライブラリオプション`@aws-sdk/lib-storage`を使用して、マルチパートアップロードでチェックサムを使用できます。

```
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 for JavaScript のコードサンプル
<a name="sdk-code-samples"></a>

このセクションのトピックには、さまざまな サービスの APIs AWS SDK for JavaScript で を使用して一般的なタスクを実行する方法の例が含まれています。

これらの例などのソースコードについては、[[AWS [ Code Examples Repository on GitHub ]](https://github.com/awsdocs/aws-doc-sdk-examples)で見つけてください。 AWS ドキュメントチームが作成を検討するための新しいコード例を提案するには、 リクエストを作成します。チームは、個々の API 呼び出しのみを対象とするシンプルなコードスニペットよりは、より広範なシナリオやユースケースを対象とするコード例を作成しようとしています。手順については、「[GitHub の投稿ガイドライン](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md)」の「*コードの作成*」セクションを参照してください。

**重要**  
これらの例では、ECMAScript6 のimport/export 構文を使用します。  
これには Node.js バージョン 14.17 以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、[Node.js ダウンロード](https://nodejs.org/en/download)を参照してください。
CommonJS 構文を使用する場合は[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md) for conversion guidelinesを参照してください。

**Topics**
+ [JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)
+ [AWS Elemental MediaConvert の例](emc-examples.md)
+ [AWS Lambda の例](lambda-examples.md)
+ [Amazon Lex での例](lex-examples.md)
+ [Amazon Pollyの例](polly-examples.md)
+ [Amazon Redshiftの例](redshift-examples.md)
+ [Amazon Simple Email Servicesの例](ses-examples.md)
+ [Amazon Simple Notification Service の例](sns-examples.md)
+ [Amazon Transcribeの例](Transcribe-examples.md)
+ [Amazon EC2 インスタンスでの Node.js を設定する](setting-up-node-on-ec2-instance.md)
+ [API Gateway を使用した Lambdaを呼び出し](api-gateway-invoking-lambda-example.md)
+ [AWS Lambda 関数を実行するためのスケジュールされたイベントの作成](scheduled-events-invoking-lambda-example.md)
+ [Amazon Lex chatbotを構築する](lex-bot-example.md)

# JavaScript ES6/CommonJS 構文
<a name="sdk-example-javascript-syntax"></a>

AWS SDK for JavaScript コード例は ECMAScript 6 (ES6) で記述されています。ES6 は、コードをよりモダンで読みやすくし、より多くのことをおこなうための新しい構文と新機能を提供します。

ES6 では Node.js バージョン 13.x 以降を使用する必要があります。Node.js の最新バージョンをダウンロードしてインストールするには、[Node.js downloads.](https://nodejs.org/en/download) を参照してください。ただし、必要に応じて、次のガイドラインを使用して CommonJS 構文に例を変換することができます。
+ プロジェクト環境の `package.json` から `"type" : "module"` を削除します。
+ すべての ES6 `import` ステートメントを CommonJS `require` ステートメントに変換してください。例えば、変換します、

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

  CommonJS に相当する:

  ```
  const { CreateBucketCommand } = require("@aws-sdk/client-s3");
  const { s3 } = require("./libs/s3Client.js");
  ```
+ すべての ES6 `export` ステートメントを CommonJS `module.exports` ステートメントに変換してください。例えば、変換します、

  ```
  export {s3}
  ```

  CommonJS に相当する:

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

次の例は、ES6 と CommonJS の両方で Amazon S3 バケットを作成するためのコード例を示しています。

------
#### [ 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 の例
<a name="emc-examples"></a>

AWS Elemental MediaConvert は、ブロードキャストグレードの機能を備えたファイルベースの動画変換サービスです。このサービスでは、インターネット全体に配信するブロードキャストおよびビデオオンデマンド (VOD) 用のアセットを作成できます。詳細については[https://docs.aws.amazon.com/mediaconvert/latest/ug/](https://docs.aws.amazon.com/mediaconvert/latest/ug/)を参照してください。

JavaScript API for MediaConvert は `MediaConvert` クライアントクラスを通じて公開されます。詳細については、API リファレンスの「[Class: MediaConvert](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/)」(クラス: MediaConvert)を参照してください。

**Topics**
+ [MediaConvert でのコード変換ジョブの作成と管理](emc-examples-jobs.md)
+ [MediaConvert でジョブテンプレートを使用](emc-examples-templates.md)

# MediaConvert でのコード変換ジョブの作成と管理
<a name="emc-examples-jobs"></a>

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

**この Node.js コード例は以下を示しています。**
+ MediaConvert でコード変換ジョブを作成する方法。
+ コード変換ジョブをキャンセルする方法。
+ 完了したコード変換ジョブの JSON を取得する方法。
+ 最近作成されたジョブの最大 20 個の JSON 配列を取得する方法。

## シナリオ
<a name="emc-examples-jobs-scenario"></a>

この例では、Node.js モジュールを使用して MediaConvert を呼び出し、コード変換ジョブを作成および管理します。コードは SDK for JavaScript を使用して、MediaConvert クライアントクラスのこれらのメソッドを使用してこれを取得します。
+ [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/)

## 前提条件タスク
<a name="emc-examples-jobs-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了します。
+ これらの Node TypeScriptの例を実行するようにプロジェクト環境を設定し、必要なAWS SDK for JavaScriptとサードパーティーのモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。
+ ジョブの入力ファイル用および出力ファイル用のストレージを提供する Amazon S3 バケットを作成して設定します。詳細については、「AWS Elemental MediaConvert ユーザーガイド」の「[ファイルのストレージを作成する](https://docs.aws.amazon.com/mediaconvert/latest/ug/set-up-file-locations.html)」を参照してください。**
+ 入力動画を、入力ストレージ用にプロビジョニングした Amazon S3 バケットにアップロードします。サポートされている入力動画のコーデックとコンテナの一覧については、「AWS Elemental MediaConvert ユーザーガイド」の「[サポートされる入力コーデックおよびコンテナ](https://docs.aws.amazon.com/mediaconvert/latest/ug/reference-codecs-containers-input.html)」を参照してください。**
+ MediaConvert に入力ファイルと、出力ファイルが保存されている Amazon S3 バケットへのアクセスを付与する IAM ロールを作成します。詳細については、「AWS Elemental MediaConvert ユーザーガイド」の「[IAM アクセス許可の設定](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html)」を参照してください。**

**重要**  
この例では、ECMAScript6 (ES6) を使用しています。これには Node.js バージョン 13.x 以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。  
ただし、CommonJS 構文を使用したい場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## シンプルなコード変換ジョブの定義
<a name="emc-examples-jobs-spec"></a>

`emc_createjob.js` というファイル名で Node.js モジュールを作成します。前に示したように、必要なクライアントとパッケージをインストールに含め、SDK が設定されていることを確認します。コード変換ジョブのパラメータを定義する JSON を作成します。

これらは非常に詳細なパラメータです。[AWS Elemental MediaConvert コンソール](https://console.aws.amazon.com/mediaconvert/)を使用して JSON ジョブのパラメータを生成できます。そのためには、コンソールでジョブ設定を選択し、**[ジョブ]** セクションの下部にある **[ジョブ JSON の表示]** を選択します。次の例は、シンプルなジョブの JSON を示しています。

**注記**  
*JOB\$1QUEUE\$1ARN* を MediaConvert ジョブキューに、*IAM\$1ROLE\$1ARN* を IAM ロールの Amazon リソースネーム (ARN) に、*OUTPUT\$1BUCKET\$1NAME* を宛先バケット名、例えば「s3://OUTPUT\$1BUCKET\$1NAME/」に、*INPUT\$1BUCKET\$1AND\$1FILENAME* を入力バケットとファイル名、例えば「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",
    },
  },
};
```

## コード変換ジョブの作成
<a name="emc-examples-jobs-create"></a>

ジョブパラメータJSONを作成した後、非同期`run`メソッドを呼び出して`MediaConvert`クライアントサービスオブジェクトを呼び出し、パラメータを渡します。作成されたジョブの ID がレスポンスの `data` で返されます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node emc_createjob.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_createjob.js)で見つけられます。

## コード変換ジョブのキャンセル
<a name="emc-examples-jobs-cancel"></a>

`emc_canceljob.js` というファイル名で Node.js モジュールを作成します。前述のように、必要なクライアントとパッケージのダウンロードに含めて、SDK が設定されていることを確認します。キャンセルするジョブの ID を含む JSON を作成します。次に、`MediaConvert`クライアントサービスオブジェクトを呼び出すための promise を作成して`CancelJobCommand`メソッドを呼び出し、パラメータを渡します。promise コールバックのレスポンスを処理します。

**注記**  
*JOB\$1ID*をキャンセルするジョブのID に置き換えます。　　　

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

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node ec2_canceljob.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_canceljob.js)で見つけられます。

## 最新のコード変換ジョブの一覧表示
<a name="emc-examples-jobs-listing"></a>

`emc_listjobs.js` というファイル名で Node.js モジュールを作成します。前に示したように、必要なクライアントとパッケージをインストールに含め、SDK が設定されていることを確認します。

リストを`ASCENDING`または`DESCENDING`の順序で並べ替えるかどうかを指定する値、チェックするジョブキューのAmazonリソース名（ARN）、および含めるジョブのステータスを含むパラメーターJSONを作成します。次に、`MediaConvert`クライアントサービスオブジェクトを呼び出すための promise を作成して`ListJobsCommand`メソッドを呼び出し、パラメータを渡します。

**注記**  
*QUEUE\$1ARN* をチェックするジョブキューの Amazon リソースネーム (ARN) に、*[STATUS]*（状態）をキューのステータスに置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node emc_listjobs.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_listjobs.js)で見つけられます。

# MediaConvert でジョブテンプレートを使用
<a name="emc-examples-templates"></a>

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

**この Node.js コード例は以下を示しています。**
+ AWS Elemental MediaConvert ジョブテンプレートを作成する方法。
+ コード変換ジョブを作成するためのジョブテンプレートを使用する方法。
+ すべてのジョブテンプレートを一覧表示する方法。
+ ジョブテンプレートを作成する方法。

## シナリオ
<a name="emc-examples-templates-scenario"></a>

MediaConvert でコード変換ジョブを作成するために必要な JSON は詳細で、多数の設定が含まれています。後続のジョブを作成するために使用できるジョブテンプレートに既知の正常な設定を保存することで、ジョブ作成を大幅に簡素化できます。この例では、Node.js モジュールを使用して MediaConvert を呼び出し、ジョブテンプレートを作成、使用、および管理します。コードは SDK for JavaScript を使用して、MediaConvert クライアントクラスのこれらのメソッドを使用してこれを実行します。
+ [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/)

## 前提条件タスク
<a name="emc-example-templates-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了します。
+ これらの Node TypeScriptの例を実行するようにプロジェクト環境を設定し、必要なAWS SDK for JavaScriptとサードパーティーのモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。
+ MediaConvert に入力ファイルと、出力ファイルが保存されている Amazon S3 バケットへのアクセスを付与する IAM ロールを作成します。詳細については、「AWS Elemental MediaConvert ユーザーガイド」の「[IAM アクセス許可の設定](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html)」を参照してください。**

**重要**  
これらの例では ECMAScript6 (ES6) を使用します。これには Node.js バージョン 13.x 以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。  
ただし、CommonJS 構文を使用したい場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## ジョブテンプレートの作成
<a name="emc-examples-templates-create"></a>

`emc_create_jobtemplate.js` というファイル名で Node.js モジュールを作成します。前に示したように、必要なクライアントとパッケージをインストールに含め、SDK が設定されていることを確認します。

テンプレート作成用の JSON パラメータを指定します。以前の成功したジョブの JSON パラメータの大部分を使用して、テンプレートの `Settings` 値を指定できます。この例では、[MediaConvert でのコード変換ジョブの作成と管理](emc-examples-jobs.md) のジョブ設定を使用します。

次に、`MediaConvert`クライアントサービスオブジェクトを呼び出すための promise を作成して`CreateJobTemplateCommand`メソッドを呼び出し、パラメータを渡します。

**注記**  
*JOB\$1QUEUE\$1ARN* をチェックするジョブキューの Amazon リソースネーム (ARN) に、*BUCKET\$1NAME* を宛先 Amazon S3 バケットの名前に置き換えます。たとえば、「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();
```

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node emc_create_jobtemplate.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_create_jobtemplate.js)で見つけられます。

## ジョブテンプレートからコード変換ジョブを作成します
<a name="emc-examples-templates-createjob"></a>

`emc_template_createjob.js` というファイル名で Node.js モジュールを作成します。前に示したように、必要なクライアントとパッケージをインストールに含め、SDK が設定されていることを確認します。

使用するジョブテンプレートの名前、使用する `Settings` など、作成するジョブに固有のジョブ作成パラメータ JSON を作成します。次に、`CreateJobsCommand`クライアントサービスオブジェクトを呼び出すための promise を作成して`MediaConvert`メソッドを呼び出し、パラメータを渡します。

**注記**  
*JOB\$1QUEUE\$1ARN* をチェックするジョブキューの Amazon リソースネーム (ARN) に、*KEY\$1PAIR\$1NAME* をキーペア名に、*TEMPLATE\$1NAME* をテンプレート名に、*ROLE\$1ARN* をロールの Amazon リソースネーム (ARN) に、*INPUT\$1BUCKET\$1AND\$1FILENAME* を入力バケットとファイル名、例えば「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();
```

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node emc_template_createjob.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js)で見つけられます。

## ジョブテンプレートの一覧表化
<a name="emc-examples-templates-listing"></a>

`emc_listtemplates.js` というファイル名で Node.js モジュールを作成します。前に示したように、必要なクライアントとパッケージをインストールに含め、SDK が設定されていることを確認します。

`listTemplates` クライアントクラスの `MediaConvert` メソッドで空のリクエストパラメータを渡すためのオブジェクトを作成します。一覧表示するテンプレート (`NAME`、`CREATION DATE`、`SYSTEM`)、一覧表示するテンプレートの数、およびそれらのソート順を決定するための値を含めます。`ListTemplatesCommand` メソッドを呼び出すには、MediaConvert クライアントサービスオブジェクトを呼び出すための promise を作成し、パラメータを渡します。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node emc_listtemplates.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js)で見つけられます。

## ジョブテンプレートの削除
<a name="emc-examples-templates-delete"></a>

`emc_deletetemplate.js` というファイル名で Node.js モジュールを作成します。前に示したように、必要なクライアントとパッケージをインストールに含め、SDK が設定されていることを確認します。

削除するジョブテンプレートの名前を `DeleteJobTemplateCommand` クライアントクラスの `MediaConvert` メソッドのパラメータとして渡すオブジェクトを作成します。`DeleteJobTemplateCommand` メソッドを呼び出すには、MediaConvert クライアントサービスオブジェクトを呼び出すための promise を作成し、パラメータを渡します。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node emc_deletetemplate.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_deletetemplate.js)で見つけられます。

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

AWS Lambdaはサーバーレスコンピューティングサービスであり、サーバーのプロビジョニングや管理、ワークロード対応のクラスタースケーリングロジックの作成、イベント統合の維持、ランタイムの管理を行わずにコードを実行できます。

AWS Lambda 向けJavaScript API は [LambdaService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lambda/) （Lambdaサービス）クライアントクラスを介して公開されます。

v3のAWS SDK for JavaScript Lambda関数を作成して使用する方法を示す例の一覧表を次に示します。
+ [API Gateway を使用した Lambdaを呼び出し](api-gateway-invoking-lambda-example.md)
+ [AWS Lambda 関数を実行するためのスケジュールされたイベントの作成](scheduled-events-invoking-lambda-example.md)

# Amazon Lex での例
<a name="lex-examples"></a>

Amazon Lex は、アプリケーションに音声とテキストによる会話型インターフェイスを構築するためのAWSサービスです。

JavaScript API for Amazon Lex は[Lex Runtime Service](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lex-runtime-service/)（Lexランタイムサービス）クライアントクラスを介して公開されます。
+ [Amazon Lex chatbotを構築する](lex-bot-example.md)

# Amazon Pollyの例
<a name="polly-examples"></a>

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

**この Node.js コード例は以下を示しています。**
+ Amazon Polly を使用して録音した音声をAmazon S3 にアップロードします

## シナリオ
<a name="polly-example-synthesize-to-s3-scenario"></a>

この例では、一連のNode.jsモジュールを使用して、AmazonS3クライアントクラスのこれらのメソッドを使用して「Amazon Polly」(Amazon Polly)を使用して録音されたオーディオをAmazonS3に自動的にアップロードします。
+ [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/)

## 前提条件タスク
<a name="polly-example-synthesize-to-s3-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/s3/README.md)の手順に従って、Node JavaScriptの例を実行するようにプロジェクト環境を設定します。
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「AWS SDK とツールのリファレンスガイド」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。
+  AWS Identity and Access Management (IAM) 認証されていない Amazon Cognito ユーザーロール polly:SynthesizeSpeech アクセス許可と、IAM ロールがアタッチされた Amazon Cognito ID プールを作成します。[を使用して AWS リソースを作成する CloudFormation](#polly-example-synthesize-to-s3-create-resources)のセクションでは、これらのリソースを作成する方法について以下のことを説明します。

**注記**  
この例では Amazon Cognito を使用していますが、Amazon Cognito を使用していない場合、 AWS ユーザーは次の IAM アクセス許可ポリシーを持っている必要があります  

****  

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

## を使用して AWS リソースを作成する CloudFormation
<a name="polly-example-synthesize-to-s3-create-resources"></a>

CloudFormation を使用すると、 AWS インフラストラクチャのデプロイを予測どおりに繰り返し作成およびプロビジョニングできます。詳細については CloudFormation、[AWS CloudFormation 「 ユーザーガイド](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)」を参照してください。

 CloudFormation スタックを作成するには:

1. [AWS CLI 「 ユーザーガイド](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) AWS CLI 」の手順に従って、 をインストールして設定します。

1. プロジェクトフォルダのルートディレクトリで、`setup.yaml` という名前のファイルを作成し、それに[この GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/polly/general-examples/src/setup.yaml) にコンテンツをコピーします。
**注記**  
 CloudFormation テンプレートは、 AWS CDK [GitHub にある ](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/javascript_example_code_polly_aws_service/)を使用して生成されました。の詳細については AWS CDK、 [AWS Cloud Development Kit (AWS CDK) デベロッパーガイド](https://docs.aws.amazon.com/cdk/latest/guide/)を参照してください。

1. コマンドラインから以下のコマンドを実行し、「*STACK\$1NAME*」をスタックの一意の名前に置き換えます。
**重要**  
スタック名は、 AWS リージョンと AWS アカウント内で一意である必要があります。最大 128 文字まで指定でき、数字とハイフンを使用できます。

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

   `create-stack` コマンドパラメータの詳細については、 [AWS CLI Command Reference guide](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) (コマンドリファレンスガイド）および「[CloudFormation ユーザーガイド](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html)」を参照してください。

1.  CloudFormation マネジメントコンソールに移動し、**スタック**を選択し、スタック名を選択し、**リソース**タブを選択して、作成されたリソースのリストを表示します。  
![\[CloudFormation リソース\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/cfn_polly.png)

## Amazon Polly を使用して録音した音声をAmazon S3 にアップロードします
<a name="polly-example-synthesize-to-s3-example"></a>

`polly_synthesize_to_s3.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。コードに、*REGION* 、および*BUCKET\$1NAME*を入力します。Amazon Pollyにアクセスするには、`Polly`のクライアントのサービスオブジェクトを作成します。*「IDENTITY\$1POOL\$1ID」*を、この例で作成したAmazon CognitoIDプールの**サンプルページ**から `IdentityPoolId`を置き換えます。これは、各クライアントオブジェクトにも渡されます。

Amazon Pollyクライアントサービスオブジェクトの`StartSpeechSynthesisCommand`メソッドを呼び出して音声メッセージを合成し、AmazonS3バケットにアップロードします。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/polly/general-examples/src/polly_synthesize_to_s3.js)にあります。

# Amazon Redshiftの例
<a name="redshift-examples"></a>

Amazon Redshift は、クラウド内でのフルマネージド型、ペタバイトスケールのデータウェアハウスサービスです。Amazon Redshift データウェアハウスは、*ノード*と呼ばれるコンピューティングリソースの集合で、*クラスター*と呼ばれるグループに編成されています。各クラスターは Amazon Redshift エンジンを実行し、1 つ以上のデータベースを含みます。

![\[JavaScript 環境、SDK、および Amazon Redshiftの関係\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/code-samples-redshift.png)


JavaScript API for Amazon Redshift は[Amazon Redshift](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/Redshift/) クライアントクラスを介して公開されます。

**Topics**
+ [Amazon Redshiftの例](redshift-examples-section.md)

# Amazon Redshiftの例
<a name="redshift-examples-section"></a>

この例では、一連の Node.js モジュールを使用して、パラメーターの作成、変更、記述をします。次の `Redshift`クライアントクラス方法を使ってAmazon Redshift クラスターを削除します。
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/)

Amazon Redshift ユーザーの詳細については、「[ Amazon Redshift getting started guide ](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html)　」を参照下さい。

## 前提条件タスク
<a name="s3-example-configuring-buckets-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript とサードパーティーのモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## Amazon Redshift クラスターを作成します。
<a name="redshift-create-cluster"></a>

この例ではAWS SDK for JavaScriptを使用して Amazon Redshift クラスターを作成する方法を示しています。詳細については、「[CreateCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_CreateCluster) 」を参照してください。

**重要**  
*ここで作成するクラスターはライブです (サンドボックスで実行されるわけではありません)。クラスターを削除するまで、そのクラスターについて Amazon Redshift 標準使用料が発生します。クラスターを作成したときと同じ設定のクラスターを削除すれば、課金される合計金額は最小限になります。*

`libs`ディレクトリを作成し、ファイル名`redshiftClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon Redshift クライアントオブジェクトを作成します。*REGION*（地域）を、AWS地域に置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js)で見つけられます。

`redshift-create-cluster.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。パラメータオブジェクトを作成し、プロビジョニングするノードタイプ、およびクラスターに自動的に作成されるデータベースインスタンスのマスターサインイン認証情報、最後にクラスタタイプを指定します。

**注記**  
*CLUSTER\$1NAME*をクラスターの名前に置換します。*[NODE\$1TYPE]*は、たとえば、'dc2.large' など、プロビジョニングするノードタイプを指定します。*MASTER\$1USERNAME* そして *MASTER\$1USER\$1PASSWORD* は、クラスターの DB インスタンスのマスターユーザーのサインイン認証情報です。*CLUSTER\$1TYPE*では、クラスターのタイプを入力します。`single-node`を指定した場合、 `NumberOfNodes`パラメータは必要ありません。残りのパラメータはオプションです。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-create-cluster.js)にあります。

## Amazon Redshift クラスターを変更する
<a name="redshift-modify-cluster"></a>

この例では、AWS SDK for JavaScriptを使用して Amazon Redshift クラスターのマスターユーザーパスワードを変更する方法を示します。その他の設定を変更できる詳細については、「[[ModifyCluster]](https://docs.aws.amazon.com/redshift/latest/APIReference/API_ModifyCluster.html)」を参照してください。

`libs`ディレクトリを作成し、ファイル名`redshiftClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon Redshift クライアントオブジェクトを作成します。*REGION*（地域）を、AWS地域に置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js)で見つけられます。

`redshift-modify-cluster.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。AWSリージョン、変更したいクラスターの名前、および新しいマスターユーザーパスワードを指定します。

**注記**  
*[CLUSTER\$1NAME]*をクラスターの名前、*[MASTER\$1USER\$1PASSWORD]*を新しいマスターユーザーパスワードに置換してください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-modify-cluster.js)にあります。

## Amazon Redshift クラスターの詳細を表示します
<a name="redshift-describe-cluster"></a>

この例では、AWS SDK for JavaScriptを使用してAmazon Redshift クラスターの詳細を表示する方法を示しています。オプションの詳細については、「[[DescribeClusters]](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html)」を参照してください。

`libs`ディレクトリを作成し、ファイル名`redshiftClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon Redshift クライアントオブジェクトを作成します。*REGION*（地域）を、AWS地域に置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js)で見つけられます。

`redshift-describe-clusters.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。AWSリージョン、変更したいクラスターの名前、および新しいマスターユーザーパスワードを指定します。

**注記**  
*CLUSTER\$1NAME*をクラスターの名前に置換します。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-describe-clusters.js)にあります。

## Amazon Redshift クラスターを削除します
<a name="redshift-delete-cluster"></a>

この例では、AWS SDK for JavaScriptを使用してAmazon Redshift クラスターの詳細を表示する方法を示しています。その他の設定を変更できる詳細については、「[DeleteCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DeleteCluster.html)」を参照してください。

`libs`ディレクトリを作成し、ファイル名`redshiftClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon Redshift クライアントオブジェクトを作成します。*REGION*（地域）を、AWS地域に置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js)で見つけられます。

`redshift-delete-clusters.js`というファイル名で Node.js モジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。AWSリージョン、変更したいクラスターの名前、および新しいマスターユーザーパスワードを指定します。削除前にクラスターの最終スナップショットを保存したい場合、そうする場合は、スナップショットのID を指定します。

**注記**  
*CLUSTER\$1NAME*をクラスターの名前に置換します。*[SkipFinalClusterSnapshot]*で、削除する前に、クラスターの最後のスナップショットを作成するかどうかを指定します。'false' を指定した場合は、*[CLUSTER\$1SNAPSHOT\$1ID]*で最後のクラスタースナップショットのidを指定します。このIDは、**[Clusters]**ダッシュボードのクラスターで **[Snapshots]**のクラスタ列にあるリンクをクリックして、そして**[Snapshots]**ペインまでスクロールします。`rs:`ステムはスナップショットID の一部でないことに注意してください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-delete-cluster.js)にあります。

# Amazon Simple Email Servicesの例
<a name="ses-examples"></a>

Amazon Simple Email Service (Amazon SES) は、デジタルマーケティング担当者やアプリケーションデベロッパーがマーケティング、通知、トランザクションに関する E メールを送信できるように設計された、クラウドベースの E メール送信サービスです。E メールを利用してお客様とのつながりを維持するあらゆる規模の企業を対象とした、コスト効率の高い信頼できるサービスです。

![\[JavaScript 環境、SDK、および Amazon SES の関係\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)


JavaScript API for Amazon SES は `SES` クライアントクラスを通じて公開されます。Amazon SES クライアントクラスの使用についての詳細は、API リファレンスの[Class: SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/)（クラス：SES)を参照してください。

**Topics**
+ [Amazon SES アイデンティティの管理](ses-examples-managing-identities.md)
+ [Amazon SESでのE メールテンプレートの操作](ses-examples-creating-template.md)
+ [Amazon SES を使用してEメールを送信します](ses-examples-sending-email.md)

# Amazon SES アイデンティティの管理
<a name="ses-examples-managing-identities"></a>

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

**この Node.js コード例は以下を示しています。**
+ Amazon SES で使用されている E メールアドレスとドメインを確認する方法。
+  AWS Identity and Access Management (IAM) ポリシーを Amazon SES ID に割り当てる方法。
+  AWS アカウントのすべての Amazon SES ID を一覧表示する方法。
+ Amazon SES で使用されているアイデンティティを削除する方法。

Amazon SES *アイデンティティ*は、Amazon SES が E メールの送信に使用する E メールアドレスまたはドメインです。Amazon SES では、E メールアイデンティティを検証して、それを所有していることを確認し、他のユーザーに使用されないようにする必要があります。

Amazon SES の E メールアドレスとドメインを確認する方法の詳細については、Amazon Simple Email Service デベロッパーガイドの[Amazon SESでのEメールアドレスとドメインの検証](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html)を参照してください。Amazon SES での送信認可の詳細については、[Amazon SES 送信認可の概要](Amazon Simple Email Service Developer Guidesending-authorization-overview.html)を参照してください。

## シナリオ
<a name="ses-examples-verifying-identities-scenario"></a>

この例では、一連の Node.js モジュールを使用して Amazon SES のアイデンティティを検証および管理します。Node.js モジュールは、`SES` クライアントクラスの次のメソッドを使用し、SDK for JavaScript を使用して E メールアドレスとドメインを検証します。
+ [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/)

## 前提条件タスク
<a name="ses-examples-verifying-identities-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## アイデンティティの一覧表示
<a name="ses-examples-listing-identities"></a>

この例では、Node.js モジュールを使用して Amazon SES で使用する E メールアドレスとドメインを一覧表示します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_listidentities.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`SES` クライアントクラスの `ListIdentitiesCommand` メソッドに `IdentityType` とその他のパラメータを渡すオブジェクトを作成します。`ListIdentitiesCommand`メソッドを呼び出すには、Amazon SES サービスオブジェクトを起動し、パラメータオブジェクトを渡します。

 返される`data`には、`IdentityType`パラメーターで指定されたドメインIDの配列が含まれます。

**注記**  
*IdentityType*を「EmailAddress」または「Domain」のIDタイプに置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node ses_listidentities.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js)で見つけられます。

## E メールアドレスアイデンティの検証
<a name="ses-examples-verifying-email"></a>

この例では、Node.js モジュールを使用して Amazon SES で使用する E メールの送信者を検証します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_verifyemailidentity.js`というファイル名で Node.js モジュールを作成します。前述のように、必要なクライアントとパッケージのダウンロードを含め、SDKを設定します。

`SES` クライアントクラスの `VerifyEmailIdentityCommand` メソッドに `EmailAddress` パラメータを渡すオブジェクトを作成します。`VerifyEmailIdentityCommand`メソッドを呼び出すには、Amazon SES クライアントサービスオブジェクトを起動し、パラメータを渡します。

**注記**  
*EMAIL\$1ADDRESS* を name@example.com などの E メールアドレスに置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。検証のためにドメインが Amazon SES に追加されます。

```
node ses_verifyemailidentity.js 
```

このサンプルコードは、[この GitHub に](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js)で見つけられます。

## ドメイン ID の検証
<a name="ses-examples-verifying-domains"></a>

この例では、Node.js モジュールを使用して Amazon SES で使用する E メールのドメインを検証します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_verifydomainidentity.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`SES` クライアントクラスの `VerifyDomainIdentityCommand` メソッドに `Domain` パラメータを渡すオブジェクトを作成します。`VerifyDomainIdentityCommand`メソッドを呼び出すには、Amazon SES クライアントサービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*DOMAIN\$1NAME* をドメイン名に置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。検証のためにドメインが Amazon SES に追加されます。

```
node ses_verifydomainidentity.js  
```

このサンプルコードは、[この GitHub に](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js)で見つけられます。

## アイデンティティの削除
<a name="ses-examples-deleting-identities"></a>

この例では、Node.js モジュールを使用して、Amazon SES で使用されている E メールアドレスまたはドメインを削除します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_deleteidentity.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`SES` クライアントクラスの `DeleteIdentityCommand` メソッドに `Identity` パラメータを渡すオブジェクトを作成します。`DeleteIdentityCommand` メソッドを呼び出すには、Amazon SES クライアントサービスオブジェクトを起動するための`request`を作成し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*IDENTITY\$1EMAIL* を削除対象の ID の E メールアドレスに置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node ses_deleteidentity.js 
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js)で見つけられます。

# Amazon SESでのE メールテンプレートの操作
<a name="ses-examples-creating-template"></a>

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

**この Node.js コード例は以下を示しています。**
+ すべてのEメールテンプレートの一覧表を取得する方法
+ E メールテンプレートを取得して更新する方法
+ E メールテンプレートを作成して削除する方法

Amazon SES では、Eメールテンプレートを使用してパーソナライズされたEメールメッセージを送信できます。Amazon SESでEメールテンプレートを作成および使用する方法の詳細については、Amazon シンプル Eメールサービス・ディベロッパーガイドの「[Amazon SES APIを使用したパーソナライズされたEメールの送信](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html)」を参照してください。

## シナリオ
<a name="ses-examples-creating-template-scenario"></a>

この例では、一連の Node.js モジュールを使用して E メールテンプレートを操作します。Node.js モジュールは SDK for JavaScript を使用し、`SES` クライアントクラスの次のメソッドを使用して E メールテンプレートを作成して使用します。
+ [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/)

## 前提条件タスク
<a name="ses-examples-creating-template-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## Eメールテンプレートの一覧表示
<a name="ses-examples-listing-templates"></a>

この例では、Node.js モジュールを使用して Amazon SES で使用する E メールテンプレートを作成します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_listtemplates.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`SES` クライアントクラスの `ListTemplatesCommand` メソッドのパラメータを渡すオブジェクトを作成します。`ListTemplatesCommand`メソッドを呼び出すには、Amazon SES クライアントサービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[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;
  }
};
```

この例を実行するには、コマンドプロンプトで以下を入力します。Amazon SES はテンプレートのリストを返します。

```
node ses_listtemplates.js  
```

このサンプルコードは、[この GitHub に](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js)で見つけられます。

## E メールテンプレートの取得
<a name="ses-examples-get-template"></a>

この例では、Node.js モジュールを使用して Amazon SES で使用する E メールテンプレートを取得します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_gettemplate.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`SES` クライアントクラスの `GetTemplateCommand` メソッドに `TemplateName` パラメータを渡すオブジェクトを作成します。`GetTemplateCommand`メソッドを呼び出すには、Amazon SES クライアントサービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*TEMPLATE\$1NAME*（テンプレート名)を返すテンプレートの名前に置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。Amazon SES はテンプレートの詳細を返します。

```
node ses_gettemplate.js 
```

このサンプルコードは、[この GitHub に](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js)で見つけられます。

## Eメールテンプレートの作成
<a name="ses-examples-create-template"></a>

この例では、Node.js モジュールを使用して Amazon SES で使用する E メールテンプレートを作成します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_createtemplate.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`TemplateName`、`HtmlPart`、`SubjectPart` および `TextPart` を含む、`SES` クライアントクラスの `CreateTemplateCommand` メソッドのパラメータを渡すオブジェクトを作成します。`CreateTemplateCommand`メソッドを呼び出すには、Amazon SES クライアントサービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*TEMPLATE\$1NAME* を新しいテンプレートの名前に、*HtmlPart* を E メールの HTML タグ付きコンテンツに、*SubjectPart* を E メールの件名に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。テンプレートが Amazon SES に追加されます。

```
node ses_createtemplate.js  
```

このサンプルコードは、[この GitHub に](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js)で見つけられます。

## E メールテンプレートの更新
<a name="ses-examples-update-template"></a>

この例では、Node.js モジュールを使用して Amazon SES で使用する E メールテンプレートを作成します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_updatetemplate.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

必要な `TemplateName` パラメータを `SES` クライアントクラスの `UpdateTemplateCommand` メソッドに渡して、テンプレートで更新する `Template` パラメータ値を渡すオブジェクトを作成します。`UpdateTemplateCommand`メソッドを呼び出すには、Amazon SES サービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*TEMPLATE\$1NAME* をテンプレートの名前に、*HTML\$1PART* を E メールの HTML タグ付きコンテンツに置き換えます。

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

const TEMPLATE_NAME = getUniqueName("TemplateName");
const HTML_PART = "<h1>Hello, World!</h1>";

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

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

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

この例を実行するには、コマンドプロンプトで以下を入力します。Amazon SES はテンプレートの詳細を返します。

```
node ses_updatetemplate.js 
```

このサンプルコードは、[この GitHub に](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js)で見つけられます。

## E メールテンプレートの削除
<a name="ses-examples-delete-template"></a>

この例では、Node.js モジュールを使用して Amazon SES で使用する E メールテンプレートを作成します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_deletetemplate.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

必要な `TemplateName` パラメータを `SES` クライアントクラスの `DeleteTemplateCommand` メソッドに渡すオブジェクトを作成します。`DeleteTemplateCommand`メソッドを呼び出すには、Amazon SES サービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*TEMPLATE\$1NAME* を削除するテンプレートの名前に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。Amazon SES はテンプレートの詳細を返します。

```
node ses_deletetemplate.js 
```

このサンプルコードは、[この GitHub に](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js)で見つけられます。

# Amazon SES を使用してEメールを送信します
<a name="ses-examples-sending-email"></a>

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

**この Node.js コード例は以下を示しています。**
+ テキストまたは HTML の E メールを送信します。
+ E メールテンプレートに基づいて E メールを送信します。
+ E メールテンプレートに基づいて一括 E メールを送信します。

Amazon SES API は、E メールメッセージの構成に対する制御の程度に応じて、フォーマット済みと raw の 2 つの異なる方法で E メールを送信できます。詳細については、[「Amazon SESAPIを使用したフォーマット済みEメールの送信」](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html)および[「AmazonSESAPIを使用した生のEメールの送信」](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html)を参照してください。

## シナリオ
<a name="ses-examples-sending-email-scenario"></a>

この例では、一連の Node.js モジュールを使用してさまざまな方法で E メールを送信します。Node.js モジュールは SDK for JavaScript を使用し、`SES` クライアントクラスの次のメソッドを使用して E メールテンプレートを作成して使用します。
+ [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/)

## 前提条件タスク
<a name="ses-examples-sending-emails-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## E メールメッセージの送信要件
<a name="ses-examples-sending-msail-reqs"></a>

Amazon SES は E メールメッセージを作成し、送信するメッセージをすぐにキューに入れます。`SendEmailCommand` メソッドを使用して E メールを送信するには、メッセージが以下の要件を満たしている必要があります。
+ 検証済みの E メールアドレスまたはドメインからメッセージを送信する必要があります。検証されていないアドレスまたはドメインを使用して E メールを送信しようとすると、`"Email address not verified"` エラーが発生します。
+ アカウントがまだ Amazon SES サンドボックスにある場合は、検証済みのアドレスまたはドメイン、または Amazon SES メールボックスシミュレーターに関連付けられた E メールアドレスにのみ送信できます。詳細については、Amazon Simple Email Service デベロッパーガイドの [[ Eメールアドレスとドメインの検証］](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html)を参照してください。
+ 添付ファイルを含むメッセージの合計サイズは 10 MB より小さくなければなりません。
+ メッセージには少なくとも 1 つの受信者の E メールアドレスを含める必要があります。受信者アドレスは、To: アドレス、CC: アドレス、または BCC: アドレスのいずれかです。受信者の E メールアドレスが無効な場合 (つまり、`UserName@[SubDomain.]Domain.TopLevelDomain` のフォーマットではない場合)、メッセージに他の有効な受信者が含まれていても、メッセージ全体が拒否されます。
+ メッセージには、To:、CC:、BCC: のフィールド全体で 50 人を超える受信者を含めることはできません。それ以上の数のユーザーに E メールメッセージを送信する必要がある場合は、受信者リストを 50 ユーザー以下のグループに分割し、`sendEmail` メソッドを数回呼び出して各グループにメッセージを送信することができます。

## E メールを送信する
<a name="ses-examples-sendmail"></a>

この例では、Node.js モジュールを使用して Amazon SES で E メールを送信します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_sendemail.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

送信者と受信者のアドレス、件名、プレーンテキストおよび HTML 形式のEメール本文などを含む、送信するEメールを定義するパラメータ値を `SES`クライアントクラスの`SendEmailCommand`メソッドに渡すオブジェクトを作成します。`SendEmailCommand`メソッドを呼び出すには、Amazon SES サービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*toAddress* をE メールの宛先の E メールアドレスに、*fromAddress* を E メールの送信元の E メールアドレスに置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。E メールは Amazon SES による送信のためにキューに登録されます。

```
node ses_sendemail.js 
```

このサンプルコードは、 [[ here on GitHub ]](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js)で見つけられます。

## テンプレートを使用した E メールを送信する
<a name="ses-examples-sendtemplatedemail"></a>

この例では、Node.js モジュールを使用して Amazon SES で E メールを送信します。`ses_sendtemplatedemail.js` というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

送信者と受信者のアドレス、件名、プレーンテキストおよび HTML 形式の E メール本文など、送信する E メールを定義するパラメータ値を `SES` クライアントクラスの `SendTemplatedEmailCommand` メソッドに渡すオブジェクトを作成します。`SendTemplatedEmailCommand`メソッドを呼び出すには、Amazon SES クライアントサービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*REGION* を AWS リージョンに、*USER* を E メールを送信する名前と E メールアドレスに、*VERIFIED\$1EMAIL* を E メールを送信する E メールアドレスに、*TEMPLATE\$1NAME* をテンプレートの名前に置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。E メールは Amazon SES による送信のためにキューに登録されます。

```
node ses_sendtemplatedemail.js 
```

このサンプルコードは、[この GitHub に](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js)で見つけられます。

## テンプレートを使用した一括Eメールを送信します
<a name="ses-examples-sendbulktemplatedemail"></a>

この例では、Node.js モジュールを使用して Amazon SES で E メールを送信します。

`libs`ディレクトリを作成し、ファイル名`sesClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SES クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js)で見つけられます。

`ses_sendbulktemplatedemail.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

送信者と受信者のアドレス、件名、プレーンテキストおよび HTML 形式のEメール本文などを含む、送信するEメールを定義するパラメータ値を `SES`クライアントクラスの`SendBulkTemplatedEmailCommand`メソッドに渡すオブジェクトを作成します。`SendBulkTemplatedEmailCommand`メソッドを呼び出すには、Amazon SES サービスオブジェクトを起動し、パラメータを渡します。

**注記**  
この例では、必要な AWS Service V3 パッケージクライアント、V3 コマンドをインポートして使用し、非同期/待機パターンで `send`メソッドを使用します。この例は、代わりに少し変更を加えてV2コマンドで作成できます。詳細については、「[v3 コマンドの使用](migrating.md#using_v3_commands)」を参照してください。

**注記**  
*USERS* を E メールの宛先のユーザー名と E メールアドレスに、*VERIFIED\$1EMAIL\$11* を E メールの送信元の E メールアドレスに、*TEMPLATE\$1NAME* をテンプレート名に置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。E メールは Amazon SES による送信のためにキューに登録されます。

```
node ses_sendbulktemplatedemail.js
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js)で見つけられます。

# Amazon Simple Notification Service の例
<a name="sns-examples"></a>

Amazon Simple Notification Service (Amazon SNS) は、サブスクライブしているエンドポイントまたはクライアントへのメッセージの配信または送信を調整して管理するウェブサービスです。

Amazon SNS には、発行者とサブスクライバーという 2 種類のクライアントが存在し、それぞれ生産者と消費者とも呼ばれます。

![\[JavaScript 環境、SDK、および Amazon SNS の関係\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/code-samples-sns.png)


発行者は、論理アクセスポイントおよび通信チャネルであるトピックにメッセージを作成して送信することで、受信者と非同期的に通信します。サブスクライバー (ウェブサーバー、E メールアドレス、Amazon SQS キュー、 AWS Lambda 関数) は、トピックにサブスクライブするときに、サポートされているプロトコル (Amazon SQS、HTTP/S、E メール、SMS AWS Lambda) のいずれかを介してメッセージまたは通知を消費または受信します。

Amazon SNS 用JavaScript API は[[ Class: SNS ]](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SNS/)を介して公開されます。

**Topics**
+ [Amazon SNS でのトピックの管理](sns-examples-managing-topics.md)
+ [Amazon SNS でのメッセージの公開](sns-examples-publishing-messages.md)
+ [Amazon SNS でのサブスクリプションの管理](sns-examples-subscribing-unsubscribing-topics.md)
+ [Amazon SNS の SMS メッセージの送信](sns-examples-sending-sms.md)

# Amazon SNS でのトピックの管理
<a name="sns-examples-managing-topics"></a>

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

**この Node.js コード例は以下を示しています。**
+ 通知を発行できる Amazon SNS でトピックを作成する方法。
+ Amazon SNS で作成されたトピックを削除する方法。
+ 利用可能なトピックの一覧を取得する方法。
+ トピック属性を取得および設定する方法。

## シナリオ
<a name="sns-examples-managing-topics-scenario"></a>

この例では、一連の Node.js モジュールを使用して Amazon SNS トピックを作成、一覧表示、および削除し、トピック属性を処理します。Node.js モジュールは、`SNS` クライアントクラスの以下のメソッドを使用してトピックを管理するために SDK for JavaScript を使用します。
+ [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/)

## 前提条件タスク
<a name="sns-examples-managing-topics-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## トピックの作成
<a name="sns-examples-managing-topics-createtopic"></a>

この例では、Node.js モジュールを使用して Amazon SNS トピックを作成します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`create-topic.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`SNS` クライアントクラスの `CreateTopicCommand` メソッドに新しいトピックの `Name` を渡すためのオブジェクトを作成します。`CreateTopicCommand`メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。返された`data`には、トピックの ARN が含まれています。

**注記**  
*TOPIC\$1NAME*は、SNS トピックの名前に置換してください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/create-topic.js)で見つけられます。

## トピックの一覧表示
<a name="sns-examples-managing-topics-listtopics"></a>

この例では、Node.js モジュールを使用してすべての Amazon SNS トピックを一覧表示します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`list-topics.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`SNS` クライアントクラスの `ListTopicsCommand` メソッドに渡す空のオブジェクトを作成します。`ListTopicsCommand`メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。返信された`data`には、トピックの Amazon リソースネーム (ARN)の配列が含まれています。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-topics.js)にあります。

## トピックの削除
<a name="sns-examples-managing-topics-deletetopic"></a>

この例では、Node.js モジュールを使用して Amazon SNS トピックを削除します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`delete-topic.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`SNS` クライアントクラスの `DeleteTopicCommand` メソッドに渡すために、削除するトピックの `TopicArn` を含むオブジェクトを作成します。`DeleteTopicCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
*[ TOPIC\$1ARN ]*を削除するトピックの Amazon リソースネーム (ARN)に置換してください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/delete-topic.js)で見つけられます。

## トピック属性の取得
<a name="sns-examples-managing-topicsgettopicattributes"></a>

この例では、Node.js モジュールを使用して Amazon SNS トピックの属性を取得します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`get-topic-attributes.js`というファイル名で Node.js モジュールを作成します。前に示したように SDK を設定します。

`SNS` クライアントクラスの `GetTopicAttributesCommand` メソッドに渡すために、削除するトピックの `TopicArn` を含むオブジェクトを作成します。`GetTopicAttributesCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
返された*[ TOPIC\$1ARN ]*をトピックのARN に置換してください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-topic-attributes.js)で見つけられます。

## トピック属性の設定
<a name="sns-examples-managing-topicssttopicattributes"></a>

この例では、Node.js モジュールを使用して Amazon SNS トピックの変更可能な属性を設定します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`set-topic-attributes.js`というファイル名で Node.js モジュールを作成します。前に示したように SDK を設定します。

属性を設定するトピックの `TopicArn`、設定する属性の名前、およびその属性の新しい値など、属性の更新のパラメータを含むオブジェクトを作成します。`Policy`、`DisplayName`、および `DeliveryPolicy` 属性のみ設定できます。`SNS` クライアントクラスの `SetTopicAttributesCommand` メソッドにパラメータを渡します。`SetTopicAttributesCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
*ATTRIBUTE\$1NAME* を設定している属性の名前で、*TOPIC\$1ARN* 設定したい属性のトピックの Amazon リソースネーム (ARN)で、 *NEW\$1ATTRIBUTE\$1VALUE* を属性の新しい値に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-topic-attributes.js)で見つけられます。

# Amazon SNS でのメッセージの公開
<a name="sns-examples-publishing-messages"></a>

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

**この Node.js コード例は以下を示しています。**
+ Amazon SNS トピックにメッセージを発行する方法。

## シナリオ
<a name="sns-examples-publishing-messages-scenario"></a>

この例では、一連の Node.js モジュールを使用して Amazon SNS からトピックのエンドポイント、E メール、または電話番号にメッセージを発行します。Node.js モジュールは SDK for JavaScript を使用して、`SNS` クライアントクラスのこのメソッドを使用してメッセージを送信します。
+ [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/)

## 前提条件タスク
<a name="sns-examples-publishing-messages-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## SNS トピックへのメッセージの発行
<a name="sns-examples-publishing-text-messages"></a>

この例では、Node.js モジュールを使用して Amazon SNS トピックにメッセージを発行します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

 `publish-topic.js`というファイル名で Node.js モジュールを作成します。前に示したように SDK を設定します。

メッセージテキストと Amazon SNSトピックの Amazon Resource Name(ARN)を含む、メッセージを発行するためのパラメータを含むオブジェクトを作成します。利用可能な SMS 属性の詳細については、「[SetSMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html#setSMSAttributes-property)」を参照してください。

パラメータを`PublishCommand`クライアントクラスの`SNS`メソッドに渡します。Amazon SNS クライアントサービスオブジェクトを起動する非同期関数を作成し、パラメータオブジェクトを渡します。

**注記**  
*MESSAGE\$1TEXT* をメッセージテキストで、*TOPIC\$1ARN*をSNS トピックのARNに置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-topic.js)で見つけられます。

# Amazon SNS でのサブスクリプションの管理
<a name="sns-examples-subscribing-unsubscribing-topics"></a>

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

**この Node.js コード例は以下を示しています。**
+ Amazon SNS トピックへのすべてのサブスクリプションを一覧表示する方法。
+ E メールアドレス、アプリケーションエンドポイント、または AWS Lambda 関数を Amazon SNS トピックにサブスクライブする方法。
+ Amazon SNS トピックのサブスクライブを解除する方法。

## シナリオ
<a name="sns-examples-subscribing-unsubscribing-topics-scenario"></a>

この例では、一連の Node.js モジュールを使用して通知メッセージを Amazon SNS トピックに発行します。Node.js モジュールは、`SNS` クライアントクラスの以下のメソッドを使用してトピックを管理するために SDK for JavaScript を使用します。
+ [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/)

## 前提条件タスク
<a name="sns-examples-subscribing-unsubscribing-topics-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## サブスクリプションのトピックへの一覧表示
<a name="sns-examples-list-subscriptions-email"></a>

この例では、Node.js モジュールを使用して Amazon SNS トピックへのすべてのサブスクリプションを一覧表示します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

 `list-subscriptions-by-topic.js`というファイル名で Node.js モジュールを作成します。前に示したように SDK を設定します。

サブスクリプションを一覧表示するトピックの `TopicArn` パラメータを含むオブジェクトを作成します。`SNS` クライアントクラスの `ListSubscriptionsByTopicCommand` メソッドにパラメータを渡します。`ListSubscriptionsByTopicCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能を作成し、パラメータオブジェクトを渡します。

**注記**  
*TOPIC\$1ARN* をサブスクリプションを一覧表示したいトピックのAmazon リソースネーム (ARN) に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-subscriptions-by-topic.js)で見つけられます。

## E メールアドレスのトピックへのサブスクライブ
<a name="sns-examples-subscribing-email"></a>

この例では、Node.js モジュールを使用して E メールアドレスをサブスクライブし、Amazon SNS トピックから SMTP E メールメッセージを受信するようにします。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`subscribe-email.js`というファイル名で Node.js モジュールを作成します。前に示したように SDK を設定します。

`email` プロトコル、サブスクライブするトピックの `TopicArn`、およびメッセージの `Endpoint` としての E メールアドレスを指定するための `Protocol` パラメータを含むオブジェクトを作成します。`SNS` クライアントクラスの `SubscribeCommand` メソッドにパラメータを渡します。このトピックの他の例が示すように、渡されたパラメータに使用される値に応じて、`subscribe` メソッドを使用して Amazon SNS トピックにいくつかの異なるエンドポイントをサブスクライブすることができます。

`SubscribeCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能を作成し、パラメータオブジェクトを渡します。

**注記**  
*TOPIC\$1ARN* をトピックの Amazon リソースネーム (ARN) に、*EMAIL\$1ADDRESS* をサブスクライブする E メールアドレスに置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-email.js)で見つけられます。

### サブスクリプションを確認する
<a name="sns-confirm-subscription-email"></a>

この例では、Node.jsモジュールを使用し、以前の Subscribe アクションでエンドポイントに送信したトークンを検証することによって、メッセージを受信するというエンドポイントの所有者の意思を確認します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`confirm-subscription.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

`TOPIC_ARN`と`TOKEN`を含むパラメータを定義し、`AuthenticateOnUnsubscribe`に対して`TRUE`または`FALSE`の値を定義します。

トークンは、以前の`SUBSCRIBE`アクションの期間にエンドポイントの所有者に送信される短期間のトークンです。たとえば、電子メールエンドポイントの場合、`TOKEN`は、E メールの所有者に送信されたサブスクリプションの確認メールのURLにあります。例えば、`abc123`は次のURLのトークンです。

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


`ConfirmSubscriptionCommand`メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
*TOPIC\$1ARN*をトピックの Amazon リソースネーム (ARN)に、*TOKEN*を以前の`Subscribe`アクションでエンドポイント所有者に送信されたURLのトークン値に置き換えてください。そして、定義*AuthenticateOnUnsubscribe*を`TRUE`か`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;
};
```

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/confirm-subscription.js)で見つけられます。

## アプリケーションエンドポイントのトピックへのサブスクライブ
<a name="sns-examples-subscribing-apps"></a>

この例では、Node.js モジュールを使用してモバイルアプリケーションのエンドポイントをサブスクライブし、Amazon SNS トピックから通知を受信するようにします。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`subscribe-app.js`というファイル名で Node.js モジュールを作成します。必要なモジュールとパッケージのインストールを含め、前述のようにSDKを設定します。

`application`プロトコルを指定する`Protocol`パラメータ、サブスクライブするトピックの`TopicArn`、そして`Endpoint`パラメータのモバイルアプリケーションエンドポイントのAmazon リソースネーム(ARN)を含むオフジェクトを作成します。`SNS` クライアントクラスの `SubscribeCommand` メソッドにパラメータを渡します。

`SubscribeCommand`メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
*TOPIC\$1ARN* をトピックのAmazon リソースネーム (ARN)に、 *MOBILE\$1ENDPOINT\$1ARN* をトピックスにサブスクライブしているエンドポイントに置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-app.js)で見つけられます。

## Lambda 関数のトピックへのサブスクライブ
<a name="sns-examples-subscribing-lambda"></a>

この例では、Node.js モジュールを使用して AWS Lambda 関数をサブスクライブし、Amazon SNS トピックから通知を受信します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`subscribe-lambda.js`というファイル名で Node.js モジュールを作成します。前に示したように SDK を設定します。

`Protocol` パラメータを含むオブジェクトを作成し、`lambda`プロトコル、サブスクライブするトピック`TopicArn`の 、および AWS Lambda 関数の Amazon リソースネーム (ARN) を `Endpoint`パラメータとして指定します。`SNS` クライアントクラスの `SubscribeCommand` メソッドにパラメータを渡します。

`SubscribeCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
*TOPIC\$1ARN* をトピックの Amazon リソースネーム(ARN)に、*RAMBDA\$1FUNCTION\$1ARN*をLambda 関数のAmazonリソースネーム(ARN)に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-lambda.js)で見つけられます。

## トピックからのサブスクリプションの解除
<a name="sns-examples-unsubscribing"></a>

この例では、Node.js モジュールを使用して Amazon SNS トピックのサブスクリプションを解除します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`unsubscribe.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。

サブスクリプションを解除するAmazon リソースネーム(ARN)を指定して、`SubscriptionArn` パラメータを含むオブジェクトを作成します。`SNS` クライアントクラスの `UnsubscribeCommand` メソッドにパラメータを渡します。

`UnsubscribeCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
*TOPIC\$1SUBSCRIPTION\$1ARN* をサブスクリプションを解除するAmazon リソースネーム(ARN)に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

```
node unsubscribe.js
```

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/unsubscribe.js)で見つけられます。

# Amazon SNS の SMS メッセージの送信
<a name="sns-examples-sending-sms"></a>

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

**この Node.js コード例は以下を示しています。**
+ Amazon SNS の SMS メッセージングの設定を取得および設定する方法。
+ 電話番号をチェックして SMS メッセージの受信をオプトアウトしたかどうかを確認する方法。
+ SMS メッセージの受信をオプトアウトした電話番号のリストを取得する方法。
+ SMS メッセージを送信する方法。

## シナリオ
<a name="sns-examples-sending-sms-scenario"></a>

Amazon SNS を使用して、SMS 対応デバイスにテキストメッセージ (SMS メッセージ) を送信できます。電話番号をトピックにサブスクライブし、トピックへメッセージを送信することにより、電話番号へメッセージを直接送信または、一度に複数の電話番号にメッセージを送信できます。

この例では、一連の Node.js モジュールを使用して、Amazon SNS から SMS 対応デバイスに SMS テキストメッセージを発行します。Node.js モジュールは SDK for JavaScript を使用し、`SNS` クライアントクラスの以下のメソッドを使用して SMS メッセージを発行します。
+ [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/)

## 前提条件タスク
<a name="sns-examples-sending-sms-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md)」の指示に従います。
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## SMS 属性の取得
<a name="sending-sms-getattributes"></a>

Amazon SNS を使用して、配信の最適化の方法 (コストに対してか、確実な配信に対してか)、毎月の使用量の上限、メッセージ配信がログに記録される方法、SMS の毎日の使用状況レポートをサブスクライブするかどうかなど、SMS メッセージのプリファレンスを指定します。これらのプリファレンスが取得され、Amazon SNS の SMS 属性として設定されます。

この例では、Node.js モジュールを使用して Amazon SNS の現在の SMS 属性を取得します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

 `get-sms-attributes.js`というファイル名で Node.js モジュールを作成します。

前述のように、必要なクライアントとパッケージのダウンロードを含め、SDKを設定します。取得する個々の属性の名前など、SMS 属性を取得するためのパラメータを含むオブジェクトを作成します。利用可能な SMS 属性の詳細については、Amazon Simple Notification Service API リファレンスの [SetSMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) を参照してください。

この例では、`DefaultSMSType` 属性を取得します。これは、SMS メッセージが `Promotional` (コストが最も低くなるようにメッセージ配信が最適化されます) として送信されるのか、`Transactional` (信頼性が最も高くなるようにメッセージ配信が最適化されます) として送信されるのかを制御します。`SNS` クライアントクラスの `SetTopicAttributesCommand` メソッドにパラメータを渡します。`SetSMSAttributesCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
*ATTRIBUTE\$1NAME*を属性の名前に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-sms-attributes.js)で見つけられます。

## SMS 属性の設定
<a name="sending-sms-setattributes"></a>

この例では、Node.js モジュールを使用して Amazon SNS の現在の SMS 属性を取得します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

 `set-sms-attribute-type.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。設定する個々の属性の名前とそれぞれに設定する値を含む、SMS 属性を設定するためのパラメータを含むオブジェクトを作成します。利用可能な SMS 属性の詳細については、Amazon Simple Notification Service API リファレンスの [SetSMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) を参照してください。

この例では、`DefaultSMSType` 属性を `Transactional` に設定します。これにより、信頼性が最も高くなるようにメッセージ配信が最適化されます。`SNS` クライアントクラスの `SetTopicAttributesCommand` メソッドにパラメータを渡します。`SetSMSAttributesCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-sms-attribute-type.js)で見つけられます。

## 電話番号がオプトアウトしているかどうかの確認
<a name="sending-sms-checkifphonenumberisoptedout"></a>

この例では、Node.js モジュールを使用して電話番号をチェックし、SMS メッセージの受信をオプトアウトしたかどうかを確認します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`check-if-phone-number-is-opted-out.js`というファイル名で Node.js モジュールを作成します。前に示したように SDK を設定します。パラメータとして確認する電話番号を含むオブジェクトを作成します。

この例では、確認する電話番号を指定するために `PhoneNumber` パラメータを設定します。`SNS` クライアントクラスの `CheckIfPhoneNumberIsOptedOutCommand` メソッドにオブジェクトを渡します。`CheckIfPhoneNumberIsOptedOutCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  

*PHONE\$1NUMBER* を電話番号に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/check-if-phone-number-is-opted-out.js)で見つけられます。

## オプトアウトした電話番号の一覧表示
<a name="sending-sms-listphonenumbersoptedout"></a>

この例では、Node.js モジュールを使用して、SMS メッセージの受信からオプトアウトされた電話番号のリストを取得します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`list-phone-numbers-opted-out.js`というファイル名で Node.js モジュールを作成します。前に示したように SDK を設定します。空のオブジェクトをパラメータとして作成します。

`SNS` クライアントクラスの `ListPhoneNumbersOptedOutCommand` メソッドにオブジェクトを渡します。`ListPhoneNumbersOptedOutCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-phone-numbers-opted-out.js)で見つけられます。

## SMS メッセージの発行
<a name="sending-sms-publishsms"></a>

この例では、Node.js モジュールを使用して SMS メッセージを電話番号に送信します。

`libs`ディレクトリを作成し、ファイル名`snsClient.js`でNode.js モジュールを作成します。以下のコードをコピーし、ペーストしてAmazon SNS クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js)で見つけられます。

`publish-sms.js`というファイル名で Node.js モジュールを作成します。必要なクライアントとパッケージのインストールを含め、前述のようにSDKを設定します。`Message` および `PhoneNumber` パラメータを含むオブジェクトを作成します。

SMS メッセージを送信するときは、E.164 形式を使用して電話番号を指定します。E.164 は、国際的な音声通信に使用される電話番号の構造の規格です。この形式に従う電話番号には最大 15 桁を設定でき、プラス記号 (\$1) および国コードのプレフィックスがついています。たとえば、E.164 形式の米国の電話番号は \$11001XXX5550100 として表示されます。

この例では、メッセージを送信するための電話番号を指定する `PhoneNumber` パラメータを設定します。`SNS` クライアントクラスの `PublishCommand` メソッドにオブジェクトを渡します。`PublishCommand` メソッドを呼び出すには、Amazon SNS サービスオブジェクトを起動する非同期機能 を作成し、パラメータオブジェクトを渡します。

**注記**  
*TEXT\$1MESSAGE*をテキストメッセージに、*PHONE\$1NUMBER*を電話番号に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-sms.js)で見つけられます。

# Amazon Transcribeの例
<a name="Transcribe-examples"></a>

Amazon Transcribe を使用すると、開発者はアプリケーションに音声認識機能を簡単に追加できます。

![\[JavaScript 環境、SDK、および Amazon Transcribeの関係\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/code-samples-transcribe.png)


「Amazon Transcribe」(Amazon Transcribe)のJavaScriptAPIは、[TranscribeService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/Transcribe/)クライアントクラスを介して公開されます。

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

# Amazon Transcribeの例
<a name="transcribe-examples-section"></a>

この例では、一連のNode.jsモジュールを使用して、`TranscribeService`クライアントクラスの次のメソッドを使用して文字起こしジョブを作成、一覧表示、および削除します。
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Amazon Transcribe ユーザーの詳細については、[Amazon Transcribe 開発者ガイド](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html)を参照してください。

## 前提条件タスク
<a name="transcribe-example-transcription-jobs"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)を参照してください。

## Amazon Transcribe ジョブを開始します
<a name="transcribe-start-transcription"></a>

この例は、 AWS SDK for JavaScriptを使用してAmazon音声文字変換ジョブを開始する方法を示しています。詳細については、[StartTranscriptionJobCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/)を参照してください。

`libs`ディレクトリを作成し、ファイル名`transcribeClient.js`でNode.js モジュールを作成します。以下のコードをコピーして、ペーストして、Amazon Transcribe クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js)で見つけられます。

`transcribe-create-job.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。必要なパラメータを指定してパラメータ オブジェクトを作成します。`StartMedicalTranscriptionJobCommand`コマンドを使用してジョブを開始します。

**注記**  
*MEDICAL\$1JOB\$1NAME*をトランスクリプションジョブの名前に置き換えてください。*OUTPUT\$1BUCKET\$1NAME*には、出力が保存されるAmazonS3バケットを指定します。*JOB\$1TYPE*には、ジョブのタイプを指定します。*SOURCE\$1LOCATION*には、ソースファイルの場所を指定します。*SOURCE\$1FILE\$1LOCATION*には、入力メディアファイルの場所を指定します。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_job.js)にあります。

## AmazonTranscribeジョブを一覧表示します
<a name="transcribe-list-jobs"></a>

この例は、 AWS SDK for JavaScriptを使用して「Amazon Transcribe」(Amazon Transcribe)文字起こしジョブを一覧表示する方法を示しています。変更できる他の設定の詳細については、[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/)を参照してください。

`libs`ディレクトリを作成し、ファイル名`transcribeClient.js`でNode.js モジュールを作成します。以下のコードをコピーして、ペーストして、Amazon Transcribe クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js)で見つけられます。

`transcribe-list-jobs.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。必要なパラメータを使用して パラメータオブジェクトを作成します。

**注記**  
*KEY\$1WORD*を、返されるジョブ名が含まれている必要のあるキーワードに置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_jobs.js)にあります。

## Amazon Transcribe ジョブを削除します
<a name="transcribe-delete-job"></a>

この例では、 AWS SDK for JavaScriptを使用してAmazon Transcribe文字起こしジョブを削除する方法を示します。オプションの詳細については、[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/)を参照してください。

`libs`ディレクトリを作成し、ファイル名`transcribeClient.js`でNode.js モジュールを作成します。以下のコードをコピーして、ペーストして、Amazon Transcribe クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js)で見つけられます。

`transcribe-delete-job.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。 AWS リージョンと、削除するジョブの名前を指定します。

**注記**  
*JOB\$1NAME*を削除するジョブの名前に置き換えてください。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

このサンプルコードは、[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_job.js)で公開されています。

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

この例では、一連のNode.jsモジュールを使用して、`TranscribeService`クライアントクラスの次のメソッドを使用して、医療文字起こしジョブを作成、一覧表示、および削除します。
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Amazon Transcribe ユーザーの詳細については、[Amazon Transcribe 開発者ガイド](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html)を参照してください。

## 前提条件タスク
<a name="transcribe-example-transcription-medical-jobs"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「*AWS SDK とツールのリファレンスガイド*」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
これらの例は、ECMAScript6 (ES6) を使用してクライアントサービスオブジェクトとコマンドをimport/export する方法を示します。  
これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。
CommonJS 構文を使用する場合は、[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)を参照してください。

## Amazon Transcribe のメディカル文字起こしジョブを開始します
<a name="transcribe-start-medical-transcription"></a>

この例では、 AWS SDK for JavaScriptを使用してAmazon Transcribe のメディカル文字起こしジョブをスタートする方法を示します。詳細については、 [startMedicalTranscriptionJob ](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/)を参照してください。

`libs`ディレクトリを作成し、ファイル名`transcribeClient.js`でNode.js モジュールを作成します。以下のコードをコピーして、ペーストして、Amazon Transcribe クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js)で見つけられます。

`transcribe-create-medical-job.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。必要なパラメータを指定してパラメータ オブジェクトを作成します。`StartMedicalTranscriptionJobCommand`コマンドを使用してメディカル ジョブをスタートします

**注記**  
*MEDICAL\$1JOB\$1NAME*をメディカル文字起こしジョブの名前に置き換えてください。*OUTPUT\$1BUCKET\$1NAME*には、出力が保存されるAmazonS3バケットを指定します。*JOB\$1TYPE*には、ジョブのタイプを指定します。*SOURCE\$1LOCATION*には、ソースファイルの場所を指定します。*SOURCE\$1FILE\$1LOCATION*には、入力メディアファイルの場所を指定します。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_medical_job.js)にあります。

## Amazon Transcribe メディカルジョブを一覧表示します
<a name="transcribe-list-medical-jobs"></a>

この例では、 AWS SDK for JavaScriptを使用して Amazon Transcribe Transcribeジョブを一覧表示する方法を示します。詳細については、[ListTranscriptionMedicalJobsCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListMedicalTranscriptionJobsCommand/)を参照してください。

`libs`ディレクトリを作成し、ファイル名`transcribeClient.js`でNode.js モジュールを作成します。以下のコードをコピーして、ペーストして、Amazon Transcribe クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js)で見つけられます。

`transcribe-list-medical-jobs.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。必要なパラメータを使用してパラメータオブジェクトを作成し、`ListMedicalTranscriptionJobsCommand` コマンドを使用してメディカルジョブを一覧表にします。

**注記**  
*KEYWORD*を、返されるジョブ名が含まれている必要のあるキーワードに置き換えます。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_medical_jobs.js)にあります。

## Amazon Transcribe メディカル ジョブを削除します
<a name="transcribe-delete-medical-job"></a>

この例では、 AWS SDK for JavaScriptを使用して Amazon Transcribe 文字起こしジョブを削除する方法を示します。オプションの詳細については、[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/)を参照してください。

`libs`ディレクトリを作成し、ファイル名`transcribeClient.js`でNode.js モジュールを作成します。以下のコードをコピーして、ペーストして、Amazon Transcribe クライアントオブジェクトを作成します。*REGION* を自分の AWS リージョンに置き換えます。

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

このサンプルコードは、[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js)で見つけられます。

`transcribe-delete-job.js`ファイル名を使用してNode.jsモジュールを作成します。前に示したように、必要なクライアントとパッケージのインストールを含むSDKが設定されていることを確認してください。必要なパラメータを使用してパラメータオブジェクトを作成し、`DeleteMedicalJobCommand`のコマンドを使用してメディカルジョブを削除します。

**注記**  
*JOB\$1NAME*を削除するジョブの名前に置換します。

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

この例を実行するには、コマンドプロンプトで以下を入力します。

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

 このサンプルコードは、[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_medical_job.js)にあります。

# Amazon EC2 インスタンスでの Node.js を設定する
<a name="setting-up-node-on-ec2-instance"></a>

SDK for JavaScript で Node.js を使用するには、通常、Amazon Elastic Compute Cloud (Amazon EC2) インスタンス上で Node.js ウェブアプリケーションをセットアップして実行します。このチュートリアルでは、Linux インスタンスを作成し、SSH を使用してインスタンスに接続してから、そのインスタンスで実行する Node.js をインストールします。

## 前提条件
<a name="setting-up-node-on-ec2-instance.prerequisites"></a>

このチュートリアルは、インターネットから到達可能で、SSHを使用して接続できるパブリックDNS名でLinuxインスタンスをすでに起動していることを前提としています。これを行う方法の詳細については、[Amazon EC2 ユーザーガイド](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-launch-instance)の「*ステップ 1: インスタンスを起動する*」を参照してください。

**重要**  
新しい Amazon EC2 インスタンスを起動するときは、**Amazon Linux 2023** 用の Amazon マシンイメージ (AMI) を使用します。

また、セキュリティグループを設定して、`SSH` (ポート 22)、` HTTP` (ポート 80)、`HTTPS` (ポート 443) 接続を有効にしている必要もあります。前提条件の詳細については、「*Amazon EC2 ユーザーガイド*」の「[Amazon EC2 を使用するようにセットアップする](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html)」を参照してください。

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

次の手順により、Amazon Linux インスタンスで Node.js をインストールすることができます。このサーバーを使用して Node.js ウェブアプリケーションをホストすることができます。

**Linux インスタンスで Node.js を設定するには**

1. SSH を使用して、Linux インスタンスに `ec2-user` として接続します。

1. コマンドラインで次のように入力して、ノードバージョンマネージャー(`nvm`)をインストールしてください。
**警告**  
AWS は、次のコードを制御しません。実行する前に、その信頼性と整合性を検証する必要があります。このコードの詳細については、[[ nvm ]](https://github.com/nvm-sh/nvm/blob/master/README.md) GitHub リポジトリで参照できます。

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

   `nvm`は Node.js の複数のバージョンをインストールすることができ、そして、それらの切り替えもできるため、`nvm`を使用して Node.js をインストールします。

1. コマンドラインで次のように入力し、`nvm` をロードします。

   ```
   source ~/.bashrc
   ```

1. コマンドラインで次のように入力し、nvm を使用して Node.js の最新の LTS バージョンをインストールします。

   ```
   nvm install --lts
   ```

   Node.js をインストールすると、Node Package Manager (`npm`) もインストールされるため、必要に応じて追加のモジュールをインストールできます。

1. コマンドラインで次のように入力して、Node.js が正しくインストールされ、実行されていることをテストします。

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

   これにより、実行中の Node.js のバージョンを示す次のメッセージが表示されます。

    `Running Node.js VERSION` 

**注記**  
ノードのインストールは、現在の Amazon EC2 セッションにのみ適用されます。CLI セッションを再開する場合は、nvm を再度使用して、インストールされているノードバージョンを有効にする必要があります。インスタンスが終了したら、ノードを再インストールする必要があります。別の方法として、次のトピックで説明するように、保持したい設定が完了したら Amazon EC2 インスタンスの Amazon マシンイメージ (AMI) を作成します。

## Amazon マシンイメージ（AMI）を作成します
<a name="setting-up-node-on-ec2-instance-create-image"></a>

Amazon EC2 インスタンスで Node.js をインストールしたら、そのインスタンスから Amazon マシンイメージ (AMI) を作成できます。AMI を作成することで、同じ Node.js のインストールで複数の Amazon EC2 インスタンスを簡単にプロビジョニングできます。既存のインスタンスから AMI を作成する方法の詳細については、「*Amazon EC2 ユーザーガイド*」の「[Amazon EBS-backed Linux AMI を作成する](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html)」を参照してください。

## 関連リソース
<a name="setting-up-node-on-ec2-instance-related-resource"></a>

このトピックで使用されているコマンドおよびソフトウェアの詳細については、次のウェブページを参照してください。
+ ノードバージョンマネージャー (`nvm`)- [[ nvm repo on GitHub ]](https://github.com/creationix/nvm)を参照してください。
+ ノードパッケージマネージャー (`npm`)-[[ npm website ]](https://www.npmjs.com)を参照してください。

# API Gateway を使用した Lambdaを呼び出し
<a name="api-gateway-invoking-lambda-example"></a>

Lambda 関数を呼び出すには、Amazon API Gateway を使用します。これは、REST、HTTP、WebSocket APIsに作成、公開、保守、モニタリング、保護するための AWS サービスです。API デベロッパーは、 AWS または他のウェブサービス、および AWS クラウドに保存されているデータにアクセスする APIs を作成できます。API Gateway デベロッパーとして、独自のクライアントアプリケーションで使用するためのAPIを作成できます。詳細については、[[ What is Amazon API Gateway ]](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html)( Amazon API Gatewayとは )を参照してください。

AWS Lambda は、サーバーのプロビジョニングや管理を行わずにコードを実行できるようにするコンピューティングサービスです。Lambda 関数は、さまざまなプログラミング言語で作成できます。詳細については AWS Lambda、[「 とは AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)」を参照してください。

この例では、Lambda JavaScript ランタイム API を使用して Lambda 関数を作成します。この例では、さまざまな AWS サービスを呼び出して、特定のユースケースを実行します。例えば、次の図に示すように、組織が 1 周年記念日に従業員を祝福するモバイルテキストメッセージを送信するとします。

![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


この例は完了までに約 20 分かかります。

この例では、JavaScript ロジックを使用して、このユースケースを実行するソリューションを作成する方法を示しています。例えば、データベースを読み取り、1 年記念日になった従業員を特定する方法、データを処理する方法、およびテキストメッセージを送信する方法について全てLambda 関数を使用して説明します。次に、API Gateway を使用して Rest エンドポイントを使用してこの AWS Lambda 関数を呼び出す方法について説明します。例えば、この curl コマンドを使用して Lambda 関数を呼び出すことができます。:

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

この AWS チュートリアルでは、これらのフィールドを含む Employee という名前の Amazon DynamoDB テーブルを使用します。
+ **id** - 表のプライマリキー。
+ **名前** - 従業員のファーストネーム。
+ **電話** - 従業員の電話番号。
+ **開始日** - 従業員の入社日。

![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**重要**  
完了コスト: このドキュメントに含まれる AWS サービスは、 AWS 無料利用枠に含まれています。ただし、この例を完了したら必ずすべてのリソースを終了して料金が発生しないようにしてください。

**アプリケーションを構築するには、**

1. [前提条件を満たします](#api-gateway-invoking-lambda-provision-resources)

1. [AWS リソースを作成する ](#api-gateway-invoking-lambda-provision-resources)

1. [ブラウザスクリプトを準備](#api-gateway-invoking-lambda-browser-script)

1. [Lambda 関数の作成とアップロード](#api-gateway-invoking-lambda-browser-script)

1. [Lambda 関数をデプロイします](#api-gateway-invoking-lambda-deploy-function)

1. [アプリを実行](#api-gateway-invoking-lambda-run)

1. [リソースを削除します](#api-gateway-invoking-lambda-destroy)

## 前提条件タスク
<a name="api-gateway-invoking-lambda-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「AWS SDK とツールのリファレンスガイド」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

## AWS リソースを作成する
<a name="api-gateway-invoking-lambda-provision-resources"></a>

このチュートリアルでは、以下のリソースが必要です。
+ `Id` という名前のキーと前の図に示されているフィールドを持つ `Employee` という Amazon DynamoDB テーブル。このユースケースでテストする有効な携帯番号を含め、正しいデータを入力してください。詳細については、[テーブルの作成](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html)を参照してください。
+ Lambda関数を実行するためのアクセス許可が付与されたIAMロール。
+ Lambda 関数をホストするAmazon S3 バケット。

これらのリソースは手動で作成できますが、このチュートリアルで説明されている CloudFormation ように、 を使用してこれらのリソースをプロビジョニングすることをお勧めします。

### を使用して AWS リソースを作成する CloudFormation
<a name="api-gateway-invoking-lambda-resources-cli"></a>

CloudFormation を使用すると、 AWS インフラストラクチャのデプロイを予測どおりに繰り返し作成およびプロビジョニングできます。詳細については CloudFormation、[AWS CloudFormation 「 ユーザーガイド](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)」を参照してください。

を使用して CloudFormation スタックを作成するには AWS CLI:

1. [AWS CLI 「 ユーザーガイド](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) AWS CLI 」の手順に従って、 をインストールして設定します。

1. プロジェクトフォルダのルートディレクトリで、`setup.yaml` という名前のファイルを作成し、それに[この GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/setup.yaml) にコンテンツをコピーします。
**注記**  
 CloudFormation テンプレートは、 AWS CDK [GitHub にある ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lambda_using_api_gateway)を使用して生成されました。の詳細については AWS CDK、 [AWS Cloud Development Kit (AWS CDK) デベロッパーガイド](https://docs.aws.amazon.com/cdk/latest/guide/)を参照してください。

1. コマンドラインから以下のコマンドを実行し、「*STACK\$1NAME*」をスタックの一意の名前に置き換えます。
**重要**  
スタック名は、 AWS リージョンと AWS アカウント内で一意である必要があります。最大 128 文字まで指定でき、数字とハイフンを使用できます。

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

   `create-stack` コマンドパラメータの詳細については、 [AWS CLI Command Reference guide](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) (コマンドリファレンスガイド）および「[CloudFormation ユーザーガイド](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html)」を参照してください。

1. 次に、[表に入力します](#api-gateway-invoking-lambda-resources-create-table) の手順に従ってテーブルに入力します。

### 表に入力します
<a name="api-gateway-invoking-lambda-resources-create-table"></a>

テーブルにデータを入力するには、まず `libs` という名前のディレクトリを作成し、そこに `dynamoClient.js` という名前のファイルを作成し、それに以下の内容を貼り付けます。

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

 このコードは[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/dynamoClient.js)で利用できます。

次に、`populate-table.js` というファイルをプロジェクトフォルダのルートディレクトリに作成し、[この 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) にコンテンツをコピーします。項目の1つについて、`phone` のプロパティの値をE.164形式の有効な携帯電話番号に置き換え、`startDate` の値を今日の日付に置き換えます。

コマンドラインから、以下のコマンドを実行します。

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

 このコードは[この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)で利用できます。

## AWS Lambda 関数の作成
<a name="api-gateway-invoking-lambda-browser-script"></a>

### SDK の設定
<a name="api-gateway-invoking-lambda-configure-sdk"></a>

`libs` のディレクトリで `snsClient.js` と `lambdaClient.js` という名前のファイルを作成し、これらのファイルに以下の内容をそれぞれ貼り付けます。

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

 *REGION* を AWS リージョンに置き換えます。このコードは[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/snsClient.js)で利用できます。

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

*REGION* を AWS リージョンに置き換えます。このコードは[このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/lambdaClient.js)で利用できます。

まず、必要な AWS SDK for JavaScript (v3) モジュールとコマンドをインポートします。次に、今日の日付を計算し、パラメータに割り当てます。3 番目に、`ScanCommand` のパラメータを作成します。*TABLE\$1NAME* を、この例の「[AWS リソースを作成する](#api-gateway-invoking-lambda-provision-resources)」セクションで作成したテーブルの名前に置き換えます。

以下のコードスニペットは、このステップを示しています (詳細な例については、[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",
};
```

### DynamoDB テーブルをスキャンします
<a name="api-gateway-invoking-lambda-scan-table"></a>

まず、Amazon SNS `PublishCommand` を使用してテキストメッセージを公開するために `sendText` と呼ばれる非同期/待機関数を作成します。次に、今日が勤務記念日である従業員の DynamoDB テーブルをスキャンし、`sendText` 関数を呼び出してこれらの従業員にテキストメッセージを送信する `try` ブロックパターンを追加します。エラーが発生した場合は、`catch` ブロックされます。

以下のコードスニペットは、このステップを示しています (詳細な例については、[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);
  }
};
```

### Lambda 関数をバンドルします
<a name="api-gateway-invoking-lambda-full"></a>

このトピックでは、 `mylambdafunction.ts`とこの例に必要な AWS SDK for JavaScript モジュールを というバンドルされたファイルにバンドルする方法について説明します`index.js`。

1. まだの場合は、この例の[前提条件タスク](#api-gateway-invoking-lambda-prerequisites)に従ってwebpackをインストールしてください。
**注記**  
*Webpack* の詳細については、「[Webpack でアプリケーションをバンドルする](webpack.md)」を参照してください。

1. コマンドラインで以下を実行して、この例の JavaScript を `<index.js>` というファイルにバンドルします。

   ```
   webpack mylambdafunction.ts --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**重要**  
出力の名前が`index.js`であることに注意してください。Lambda関数が機能するには`index.js`ハンドラーが必要です。

1. バンドルされた出力ファイル `index.js` を、`mylambdafunction.zip`という名前の ZIP ファイルに圧縮します。

1. このチュートリアルの[AWS リソースを作成する](#api-gateway-invoking-lambda-provision-resources)トピックで作成したAmazonS3バケットに`mylambdafunction.zip`をアップロードします。

## Lambda 関数をデプロイします
<a name="api-gateway-invoking-lambda-deploy-function"></a>

プロジェクトのルートで、`lambda-function-setup.ts` ファイルを作成し、それに以下の内容をペーストします。

*BUCKET\$1NAME* を Lambda 関数の ZIP バージョンをアップロードした Amazon S3 バケットの名前に置き換えます。*ZIP\$1FILE\$1NAME*を、Lambda関数のZIPバージョンの名前に置き換えます。*ROLE*をこのチュートリアルの[AWS リソースを作成する](#api-gateway-invoking-lambda-provision-resources)トピックで作成した IAM ロールのAmazonリソースナンバー (ARN)に置き換えます。*LAMBDA\$1FUNCTION\$1NAME*を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();
```

コマンドラインで次を入力して、Lambda 関数をデプロイします。

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

このコード例は[この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)で利用可能です。

## Lambda 関数を呼び出すために API Gatewayを設定します
<a name="api-gateway-invoking-lambda-run"></a>

**アプリを構築するには**

1. [rest API を作成する](#api-gateway-invoking-lambda-run-create)

1. [API Gateway メソッドをテストする](#api-gateway-invoking-lambda-run-test)

1. [API Gateway メソッドをデプロイする](#api-gateway-invoking-lambda-run-deploy)

### rest API を作成する
<a name="api-gateway-invoking-lambda-run-create"></a>

API Gateway コンソールを使用して、Lambda 関数のrestエンドポイントを作成できます。完了したら、restful 呼び出しを使用して Lambda 関数を呼び出すことができます。



1. [[ Amazon API Gateway console ]](https://console.aws.amazon.com/apigateway)( Amazon API Gateway コンソール )にサインインします。

1. REST APIで、** [ Build ]**（ 構築 ）を選択します。

1. **[ New API ]**（ 新規API )を選択します。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/PicNewAPI.png)

1. **[ Employee ]**をAPI 名として指定し、説明を入力します。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picEmployeeAPI.png)

1. **[API の作成]** を選択します。

1. **Employee**セクションの**[Resources]**を選択します。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picResources.png)

1. 名前フィールドの **employees**を指定します。

1. **[Create Resources]** (リソースの作成) を選択します。

1. **[ Actions ]** ( アクション )のドロップダウンから **[ Create Resource ]** ( リソースの作成 )を選択します。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picCreateResources.png)

1. **[ /employees ]**を選択し、**[Create Method]** から**[Actions]**を選択し、**[GET]**を**[/employees]**下のドロップダウンメニューから選択します。チェックマークアイコンを選択します。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGet.png)

1. **Lambda function**を選択し、Lambda 関数名として**mylambdafunction**と入力します。**[保存]** を選択します。

### API Gateway メソッドをテストする
<a name="api-gateway-invoking-lambda-run-test"></a>

チュートリアルのこの時点で、**mylambdafunction**のLambda 関数を呼び出す API Gateway メソッドをテストできます。メソッドをテストするには、次の図に示す**[ Test ]**を選びます。

![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picTest.png)


Lambda 関数が呼び出されると、ログファイルを表示して成功したメッセージを表示できます。

### API Gateway メソッドをデプロイする
<a name="api-gateway-invoking-lambda-run-deploy"></a>

テストが成功したら、 [Amazon API Gateway コンソール](https://console.aws.amazon.com/apigateway)から、メソッドをデプロイできます。

1. **[ GET ]**（ 取得する ）を選択します。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGetDeploy.png)

1. **[ Actions ]** （アクション）ドロップダウンから**[ Deploy API ]**( デプロイAPI ）を選択します。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1. **[ Deploy API ]**フォームに入力し、**[ Deploy ]**を選択します。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1.  **[Save changes]** (変更の保存) をクリックします。

1.  **Get**をもう一度選択し、URL が変更されることに注意します。これは、Lambda 関数の呼び出しに使用できるURLです。  
![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picURL2.png)

## リソースを削除します
<a name="api-gateway-invoking-lambda-destroy"></a>

お疲れ様でした。 AWS SDK for JavaScriptを使用してAmazon API Gateway を介しLambda 関数を呼び出します。このチュートリアルの冒頭で説明したように、このチュートリアルを進めたうえで、作成したすべてのリソースを終了して、料金が発生しないようにしてください。これを行うには、このチュートリアルの [AWS リソースを作成する](#api-gateway-invoking-lambda-provision-resources)トピックで作成した CloudFormation スタックを次のように削除します。

1. [CloudFormationAWS マネジメントコンソールで ]( https://console.aws.amazon.com/cloudformation/home)を開きます。

1. 「**スタック**」ページを開き、スタックを選択します。

1. **[Delete]** (削除) をクリックします。

# AWS Lambda 関数を実行するためのスケジュールされたイベントの作成
<a name="scheduled-events-invoking-lambda-example"></a>

Amazon CloudWatch イベントを使用して、 AWS Lambda 関数を呼び出すスケジュールされたイベントを作成できます。cron式を使用してLambda関数が呼び出されるタイミングをスケジュールするようにCloudWatchイベントを設定できます。例えば、CloudWatchイベントをスケジュールして、平日に毎日Lambda関数を呼び出すことができます。

AWS Lambda は、サーバーのプロビジョニングや管理を行わずにコードを実行できるようにするコンピューティングサービスです。Lambda 関数は、さまざまなプログラミング言語で作成できます。詳細については AWS Lambda、[「 とは AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)」を参照してください。

このチュートリアルでは、Lambda JavaScript ランタイム API を使用して Lambda 関数を作成します。この例では、さまざまな AWS サービスを呼び出して、特定のユースケースを実行します。例えば、次の図に示すように、組織が 1 周年記念日に従業員を祝福するモバイルテキストメッセージを送信するとします。

![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


このチュートリアルは完了までに約 20 分かかります。

このチュートリアルでは、JavaScript ロジックを使用して、このユースケースを実行するソリューションを作成する方法を示します。例えば、データベースを読み取り、1 年記念日に達した従業員を特定する方法、データを処理する方法、Lambda 関数を使用してテキストメッセージを送信する方法について説明します。次に、cron 式を使用して Lambda 関数を毎日平日に呼び出す方法を説明します。

この AWS チュートリアルでは、これらのフィールドを含む Employee という名前の Amazon DynamoDB テーブルを使用します。
+ **id** - 表のプライマリキー。
+ **名前** - 従業員のファーストネーム。
+ **電話** - 従業員の電話番号。
+ **開始日** - 従業員の入社日。

![\[DynamoDB テーブル\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**重要**  
完了コスト: このドキュメントに含まれる AWS サービスは、 AWS 無料利用枠に含まれています。ただし、このチュートリアルを完了した後は、必ずすべてのリソースを終了して料金が発生しないようにしてください。

**アプリケーションを構築するには、**

1. [前提条件を満たします](#scheduled-events-invoking-lambda-provision-resources)

1. [AWS リソースを作成する ](#scheduled-events-invoking-lambda-provision-resources)

1. [ブラウザスクリプトを準備](#scheduled-events-invoking-lambda-browser-script)

1. [Lambda 関数の作成とアップロード](#scheduled-events-invoking-lambda-browser-script)

1. [Lambda 関数をデプロイします](#scheduled-events-invoking-lambda-deploy-function)

1. [アプリを実行](#scheduled-events-invoking-lambda-run)

1. [リソースを削除します](#scheduled-events-invoking-lambda-destroy)

## 前提条件タスク
<a name="scheduled-events-invoking-lambda-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node.js TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「AWS SDK とツールのリファレンスガイド」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

## AWS リソースを作成する
<a name="scheduled-events-invoking-lambda-provision-resources"></a>

このチュートリアルでは、以下のリソースが必要です。
+ **Id**という名前のキーと前の図に示されているフィールドを持つ**Employee**という「Amazon Dyn[oDB」(Amazon DynamoDB)の表。このユースケースでテストする有効な携帯番号を含め、正しいデータを入力してください。詳細については、[テーブルの作成](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html)を参照してください。
+ Lambda関数を実行するためのアクセス許可が付与されたIAMロール。
+ Lambda 関数をホストするAmazon S3 バケット。

これらのリソースは手動で作成できますが、このチュートリアルで説明されている CloudFormation ように、 を使用してこれらのリソースをプロビジョニングすることをお勧めします。

### を使用して AWS リソースを作成する CloudFormation
<a name="scheduled-events-invoking-lambda-resources-cli"></a>

CloudFormation を使用すると、 AWS インフラストラクチャのデプロイを予測どおりに繰り返し作成およびプロビジョニングできます。詳細については CloudFormation、[AWS CloudFormation 「 ユーザーガイド](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)」を参照してください。

を使用して CloudFormation スタックを作成するには AWS CLI:

1. [AWS CLI 「 ユーザーガイド](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) AWS CLI 」の手順に従って、 をインストールして設定します。

1. プロジェクトフォルダのルートディレクトリで、`setup.yaml` という名前のファイルを作成し、それに[この GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/setup.yaml) にコンテンツをコピーします。
**注記**  
 CloudFormation テンプレートは、 AWS CDK [GitHub にある ](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/lambda_using_scheduled_events)を使用して生成されました。の詳細については AWS CDK、 [AWS Cloud Development Kit (AWS CDK) デベロッパーガイド](https://docs.aws.amazon.com/cdk/latest/guide/)を参照してください。

1. コマンドラインから以下のコマンドを実行し、「*STACK\$1NAME*」をスタックの一意の名前に置き換えます。
**重要**  
スタック名は、 AWS リージョンと AWS アカウント内で一意である必要があります。最大 128 文字まで指定でき、数字とハイフンを使用できます。

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

   `create-stack` コマンドパラメータの詳細については、 [AWS CLI Command Reference guide](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) (コマンドリファレンスガイド）および「[CloudFormation ユーザーガイド](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html)」を参照してください。

    CloudFormation ダッシュボードでスタックを開き、リソースタブを選択して、コンソールで**リソース**のリストを表示します。チュートリアルにはこれらが必要です。

1. スタックが作成されたら、 AWS SDK for JavaScript 「」で説明されているように、 を使用して DynamoDB テーブルにデータを入力します[DynamoDB 表にデータを入力します。](#scheduled-events-invoking-lambda-resources-create-table)。

### DynamoDB 表にデータを入力します。
<a name="scheduled-events-invoking-lambda-resources-create-table"></a>

テーブルにデータを入力するには、まず `libs` という名前のディレクトリを作成し、そこに `dynamoClient.js` という名前のファイルを作成し、それに以下の内容を貼り付けます。

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

 このコードは[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/libs/dynamoClient.js)で利用できます。

次に、`populate-table.js` というファイルをプロジェクトフォルダのルートディレクトリに作成し、[この 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) にコンテンツをコピーします。項目の1つについて、`phone` のプロパティの値をE.164形式の有効な携帯電話番号に置き換え、`startDate` の値を今日の日付に置き換えます。

コマンドラインから、以下のコマンドを実行します。

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

 このコードは[この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)で利用できます。

## AWS Lambda 関数の作成
<a name="scheduled-events-invoking-lambda-browser-script"></a>

### SDK の設定
<a name="scheduled-events-invoking-lambda-configure-sdk"></a>

まず、必要な AWS SDK for JavaScript (v3) モジュールとコマンドをインポートします。 `DynamoDBClient` と DynamoDB `ScanCommand`、、`SNSClient`および Amazon SNS `PublishCommand` コマンド。*REGION* を AWS リージョンに置き換えます。次に、今日の日付を計算し、パラメータに割り当てます。次に、`ScanCommand`パラメータを作成します。*TABLE\$1NAME*を、この例の[AWS リソースを作成する](#scheduled-events-invoking-lambda-provision-resources)セクションで作成したテーブルの名に置き換えます。

以下のコードスニペットは、このステップを示しています (詳細な例については、[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",
};
```

### DynamoDB テーブルをスキャンします
<a name="scheduled-events-invoking-lambda-scan-table"></a>

まず、Amazon SNS `PublishCommand` を使用してテキストメッセージを公開するために `sendText` と呼ばれる非同期/待機関数を作成します。次に、今日が勤務記念日である従業員の DynamoDB テーブルをスキャンし、`sendText` 関数を呼び出してこれらの従業員にテキストメッセージを送信する `try` ブロックパターンを追加します。エラーが発生した場合は、`catch` ブロックされます。

以下のコードスニペットは、このステップを示しています (詳細な例については、[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);
  }
};
```

### Lambda 関数をバンドルします
<a name="scheduled-events-invoking-lambda-full"></a>

このトピックでは、 `mylambdafunction.js`とこの例に必要な AWS SDK for JavaScript モジュールを というバンドルされたファイルにバンドルする方法について説明します`index.js`。

1. まだの場合は、この例の[前提条件タスク](#scheduled-events-invoking-lambda-prerequisites)に従ってwebpackをインストールしてください。
**注記**  
*Webpack* の詳細については、[Webpack でアプリケーションをバンドルする](webpack.md) を参照してください。

1. コマンドラインで以下を実行して、この例のJavaScriptを`<index.js>`というファイルにバンドルします。

   ```
   webpack mylamdbafunction.js --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**重要**  
出力の名前が`index.js`であることに注意してください。Lambda関数が機能するには`index.js`ハンドラーが必要です。

1. バンドルされた出力ファイル `index.js` を、`my-lambda-function.zip`という名前の ZIP ファイルに圧縮します。

1. このチュートリアルの[AWS リソースを作成する](#scheduled-events-invoking-lambda-provision-resources)トピックで作成したAmazonS3バケットに`mylambdafunction.zip`をアップロードします。

これは`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);
  }
};
```

## Lambda 関数をデプロイします
<a name="scheduled-events-invoking-lambda-deploy-function"></a>

プロジェクトのルートで、`lambda-function-setup.js` ファイルを作成し、それに以下の内容をペーストします。

*BUCKET\$1NAME* を Lambda 関数の ZIP バージョンをアップロードした Amazon S3 バケットの名前に置き換えます。*ZIP\$1FILE\$1NAME*（ZIPファイル名）を、Lambda関数のZIPバージョンの名前に置き換えます。*IAM\$1ROLE\$1ARN*を、このチュートリアルの[AWS リソースを作成する](#scheduled-events-invoking-lambda-provision-resources)のトピックで作成したIAMロールのAmazonリソース番号（ARN）に置き換えます。*LAMBDA\$1FUNCTION\$1NAME*（Lambdaファンクション名）を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();
```

コマンドラインで次を入力して、Lambda 関数をデプロイします。

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

このコード例は[この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)で利用可能です。

## Lambda 関数を呼び出す CloudWatch を設定します
<a name="scheduled-events-invoking-lambda-run"></a>

Lambda 関数を呼び出す CloudWatch を設定するには、

1. Lambda コンソールで **[Functions (関数)] ページ**を開きます。

1. Lambda 関数を選択します。

1. [**Designer**] で、[**Add trigger**] を選択します。

1. トリガーの種類を**CloudWatch Events/EventBridge**に設定します。

1. ルールで、 **Create a new rule**（新規ルールの作成）を選択します。

1.  ルール名とルールの説明を入力します。

1. ルールタイプで、 **Schedule expression**（スケジュール式）を選びます。

1. **Schedule expression**（スケジュール式）フィールドには、cron 式を入力します。例えば、**cron(0 12 ? \$1 MON-FRI \$1)**（cron (0 12? \$1 月-金 \$1)）。

1. **[Add]** (追加) を選択します。
**注記**  
詳細については、「 [Using Lambda with CloudWatch Events](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html)」（CloudWatch イベントでLambda を使用）を参照してください。

## リソースを削除します
<a name="scheduled-events-invoking-lambda-destroy"></a>

お疲れ様でした。 AWS SDK for JavaScriptを使用してAmazon CloudWatch スケジュールイベントを通じて Lambda 関数を呼び出します。このチュートリアルの冒頭で説明したように、このチュートリアルを進めたうえで、作成したすべてのリソースを終了して、料金が発生しないようにしてください。これを行うには、このチュートリアルの [AWS リソースを作成する](#scheduled-events-invoking-lambda-provision-resources)トピックで作成した CloudFormation スタックを次のように削除します。

1. [CloudFormation コンソール]( https://console.aws.amazon.com/cloudformation/home) を開きます。

1. 「**スタック**」ページで、スタックを選択します。

1. **[Delete]** (削除) をクリックします。

# Amazon Lex chatbotを構築する
<a name="lex-bot-example"></a>

ウェブアプリケーション内に Amazon Lex chatbotを作成して、ウェブサイトの訪問者に対応することができます。Amazon Lex chatbotは、人と直接連絡することなく、ユーザーとのオンラインチャットの会話を実行する機能です。例えば、次の図は、ホテルの部屋の予約についてユーザーに対応する Amazon Lex chatbotを示しています。

![\[Chatbot interface demonstrating a hotel booking conversation with user inputs and bot responses.\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/lex_example/chatintro.png)


この AWS チュートリアルで作成した Amazon Lex チャットボットは、複数の言語を処理できます。例えば、フランス語を話すユーザーは、フランス語のテキストを入力し、フランス語で応答を返すことができます。

![\[Chatbot interface demonstrating Amazon Lex integration with French language support.\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot2.png)


同様に、ユーザーはイタリア語でAmazon Lex chatbotで通信できます。

![\[Chat interface showing Italian language exchange between user and Amazon Lex chatbot.\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot3.png)


この AWS チュートリアルでは、Amazon Lex チャットボットを作成し、Node.js ウェブアプリケーションに統合する方法について説明します。 AWS SDK for JavaScript (v3) は、以下の AWS サービスを呼び出すために使用されます。
+ Amazon Lex
+ Amazon Comprehend
+ Amazon Translate

**完了コスト:** このドキュメントに含まれる AWS サービスは、 [AWS 無料利用枠](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc)に含まれています。

**注意:** このチュートリアルを進めるうえで作成したすべてのリソースを終了して、料金が発生しないようにしてください。

**アプリを構築するには**

1. [前提条件](#lex-bot-example-prerequisites)

1. [リソースのプロビジョニング](#lex-bot-provision-resources)

1. [Amazon Lex chatbotの作成する](#lex-bot-example-create-lex-bot)

1. [HTMLを作成する](#lex-bot-example-html)

1. [ブラウザスクリプトを作成](#lex-bot-example-script)

1. [次のステップ](#lex-bot-example-next-steps)

## 前提条件
<a name="lex-bot-example-prerequisites"></a>

この例をセットアップして実行するには、まず次のタスクを完了する必要があります。
+ これらの Node TypeScript の例を実行するようにプロジェクト環境を設定し、必要な AWS SDK for JavaScript モジュールとサードパーティーモジュールをインストールします。「[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/README.md)」の指示に従います。　
+ ユーザーの認証情報を使用して、共有設定ファイルを作成します。共有認証情報ファイルの提供の詳細については、「AWS SDK とツールのリファレンスガイド」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

**重要**  
この例では、ECMAScript6 (ES6) を使用しています。これには Node.js バージョン13.x以降が必要です。Node.js の最新バージョンをダウンロードしてインストールするには、「[Node.js ダウンロード](https://nodejs.org/en/download)」を参照してください。  
ただし、CommonJS 構文を使用したい場合は、「[JavaScript ES6/CommonJS 構文](sdk-example-javascript-syntax.md)」を参照してください。

## AWS リソースを作成する
<a name="lex-bot-provision-resources"></a>

このチュートリアルでは、以下のリソースが必要です。
+ 次の権限がアタッチされた非認証IAM ロールです。
  + Amazon Comprehend
  + Amazon Translate
  + Amazon Lex

このリソースは手動で作成できますが、このチュートリアルで説明されている AWS CloudFormation ように、 を使用してこれらのリソースをプロビジョニングすることをお勧めします。

### を使用して AWS リソースを作成する CloudFormation
<a name="lex-bot-example-resources-cli"></a>

CloudFormation を使用すると、 AWS インフラストラクチャのデプロイを予測どおりに繰り返し作成およびプロビジョニングできます。詳細については CloudFormation、[AWS CloudFormation 「 ユーザーガイド](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)」を参照してください。

を使用して CloudFormation スタックを作成するには AWS CLI:

1. [AWS CLI 「 ユーザーガイド](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) AWS CLI 」の手順に従って、 をインストールして設定します。

1. プロジェクトフォルダのルートディレクトリで、`setup.yaml` という名前のファイルを作成し、それに[この GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/setup.yaml) にコンテンツをコピーします。
**注記**  
 CloudFormation テンプレートは、 AWS CDK [GitHub にある ](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lex_bot_example_iam_unauth_role)を使用して生成されました。の詳細については AWS CDK、 [AWS Cloud Development Kit (AWS CDK) デベロッパーガイド](https://docs.aws.amazon.com/cdk/latest/guide/)を参照してください。

1. コマンドラインから以下のコマンドを実行し、「*STACK\$1NAME*」をスタックの一意の名前に置き換えます。
**重要**  
スタック名は、 AWS リージョンと AWS アカウント内で一意である必要があります。最大 128 文字まで指定でき、数字とハイフンを使用できます。

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

   `create-stack` コマンドパラメータの詳細については、 [AWS CLI Command Reference guide](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) (コマンドリファレンスガイド）および「[CloudFormation ユーザーガイド](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html)」を参照してください。

   作成されたリソースを表示するには、Amazon Lex コンソールを開き、スタックを選択し、**Resources** (リソース)タブを選びます。

## Amazon Lex botを作成します
<a name="lex-bot-example-create-lex-bot"></a>

**重要**  
Amazon Lex V1 コンソールを使用してボットを作成します。この例は V2 を使用して作成されたボットでは機能しません。

最初のステップは、Amazon Web Services マネジメントコンソールを使用して Amazon Lex chatbotを作成することです。この例では、Amazon Lex**BookTrip**の例が使用されます。詳細については「[Book Trip](https://docs.aws.amazon.com/lex/latest/dg/ex-book-trip.html) (出張の予約)」を参照してください。
+ Amazon Web Services マネジメントコンソールにサインインして、[Amazon Web Services Console](https://console.aws.amazon.com/lex/) (Amazon Web Services コンソール)のAmazon Lex コンソールを開きます。
+ Botsページで、**Create**（作成）を選択します。
+ **BookTrip**ブループリント (デフォルトのボット名は**BookTrip**のままにしておきます) を選択します。  
![\[Interface for creating a chatbot, showing BookTrip sample with conversation flow and components.\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/lex_example/pic2.png)
+ デフォルト設定を入力し、**作成**(コンソールは **BookTrip**ボットを表示します) を選択します。編集タブで、事前設定されているインテントの詳細を確認します。
+ テストウィンドウでボットをテストします。*ホテルの部屋を予約したい*と入力してテストを開始します。  
![\[Chat interface showing a hotel booking conversation with a bot asking for the city.\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/lex_example/ChatBotTest.png)
+ **発行**を選択し、エイリアス名を指定します ( を使用する場合はこの値が必要です AWS SDK for JavaScript)。

**注記**  
 JavaScript コードの **bot name** (ボット名) と **bot alias** (ボットエイリアス) を参照する必要があります。

## HTMLを作成する
<a name="lex-bot-example-html"></a>

`index.html` という名前のファイルを作成します。以下のコードをコピーして、`index.html`に貼り付けます。このHTMLは`main.js`を参照します。これは index.js のバンドルバージョンで、必要な AWS SDK for JavaScript モジュールが含まれています。このファイルは [HTMLを作成する](#lex-bot-example-html) で作成します。`index.html` はスタイルを追加する `style.css` も参照します。

```
<!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>
```

このコードも[このGitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk#running-a-cdk-app)で公開されています。

## ブラウザスクリプトを作成する
<a name="lex-bot-example-script"></a>

`index.js` という名前のファイルを作成します。以下のコードをコピーして、`index.js`に貼り付けます。必要な AWS SDK for JavaScript モジュールとコマンドをインポートします。Amazon Lex、Amazon Comprehend、およびAmazon Translate のクライアントを作成します。*REGION* を AWS Region に、*IDENTITY\$1POOL\$1ID* を で作成した ID プールの ID に置き換えます[AWS リソースを作成する](#lex-bot-provision-resources)。このアイデンティティプールのIDを取得するには、Amazon Cognito コンソールでアイデンティティプールを開き、**Edit identity pool** (アイデンティティプールの編集) を選択し、サイドメニューの**Sample code** (サンプルコード)を選択します。アイデンティティプールの IDはコンソールに赤いテキストで表示されます。

まず、`libs`ディレクトリを作成し、3つのファイル、`comprehendClient.js`、`lexClient.js`、`translateClient.js`を作成することで、必要なサービスクライアントオブジェクトを作成します。以下の適切なコードをそれぞれに貼り付け、*REGION* および *IDENTITY\$1POOL\$1ID* を各ファイルで置き換えます。

**注記**  
[を使用して AWS リソースを作成する CloudFormation](#lex-bot-example-resources-cli)で作成したAmazon CognitoアイデンティティプールのIDを使用します。

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

このコードは [このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/libs)で利用可能です。

次に、`index.js`ファイルを作成し、そこへ以下のコードを貼り付けます。

 *BOT\$1ALIAS*と*BOT\$1NAME*をAmazon Lex ボットのエイリアスと名前にそれぞれ置き換え、*USER\$1ID*をユーザー ID に置き換えます。`createResponse`非同期関数は以下を実行します。
+ ユーザーが入力したテキストをブラウザに取り込み、Amazon Comprehend を使用して言語コードを決定します。
+ 言語コードを取得し、Amazon Translate を使用してテキストを英語に翻訳します。
+ 翻訳されたテキストを取得し、Amazon Lex を使用してレスポンスを生成します。
+ レスポンスをブラウザページに投稿します。

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

このコードは [このGitHubに](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/index.html)で利用可能です。

ここで、webpack を使用して `index.js`および AWS SDK for JavaScript モジュールを 1 つのファイルにバンドルします`main.js`。

1. まだの場合は、この例の[前提条件](#lex-bot-example-prerequisites)に従ってwebpackをインストールしてください。
**注記**  
*Webpack* の詳細については、[Webpack でアプリケーションをバンドルする](webpack.md) を参照してください。

1. コマンドラインで以下を実行して、この例の JavaScriptを`main.js`というファイルにバンドルします。

   ```
   webpack index.js --mode development --target web --devtool false -o main.js
   ```

## 次の手順
<a name="lex-bot-example-next-steps"></a>

お疲れ様でした。Amazon Lex を使用してインタラクティブなユーザーエクスペリエンスを実現する Node.js アプリケーションが作成されました。このチュートリアルの冒頭で説明したように、チュートリアルを進めるうえで作成したすべてのリソースを終了して、料金が発生しないようにしてください。これを行うには、このチュートリアルの [AWS リソースを作成する](#lex-bot-provision-resources)トピックで作成した CloudFormation スタックを次のように削除します。

1. [CloudFormation コンソール]( https://console.aws.amazon.com/cloudformation/home) を開きます。

1. 「**スタック**」ページで、スタックを選択します。

1. **[削除]** を選択します。

 AWS クロスサービスの例については、[AWS SDK for JavaScript 「クロスサービスの例](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/tutorials.html)」を参照してください。