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

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

# SDK for JavaScript の設定
<a name="configuring-the-jssdk"></a>

SDK for JavaScript を使用して、API を使用するウェブサービスを呼び出す前に、SDK を設定する必要があります。少なくとも、以下を設定する必要があります。
+ サービスをリクエストする AWS リージョン
+ コードが で認証される方法 AWS

これらの設定に加えて、 AWS リソースへの許可も設定する必要があります。例えば、Amazon S3 バケットへのアクセスを制限したり、Amazon DynamoDB テーブルを読み取り専用アクセスに制限したりできます。

[AWS SDKs およびツールリファレンスガイド](https://docs.aws.amazon.com/sdkref/latest/guide/)には、多くの AWS SDKs で一般的な設定、機能、その他の基本的な概念も含まれています。

このセクションのトピックでは、Webブラウザーで実行されるNode.jsおよびJavaScript用のSDK for JavaScriptを設定する方法について説明します。

**Topics**
+ [サービスごとの設定](global-config-object.md)
+ [AWS リージョンを設定する](setting-region.md)
+ [認証情報の設定](setting-credentials.md)
+ [Node.js の考慮事項](node-js-considerations.md)
+ [ブラウザスクリプトの考慮事項](browser-js-considerations.md)

# サービスごとの設定
<a name="global-config-object"></a>

SDK を設定するには、設定情報をサービスオブジェクトに渡します。

サービスレベルの構成では、個々のサービスを大幅に制御し、ニーズがデフォルトの設定と異なる場合に、個々のサービスオブジェクト設定の更新を有効にします。

**注記**  
バージョン 2.x では、 AWS SDK for JavaScript サービス設定を個々のクライアントコンストラクタに渡すことができます。ただし、これらの設定は、まずグローバル SDK 設定 `AWS.config`のコピーに自動的にマージされます。  
また、既存のクライアントではなく、更新呼び出しが行われた後にインスタンス化されたサービスクライアントの`AWS.config.update({/* params *})`更新された設定のみを呼び出します。  
この動作は頻繁な混乱の原因であり、フォワード互換の方法でサービスクライアントのサブセットにのみ影響する設定をグローバルオブジェクトに追加することを困難にしました。バージョン3では、SDKによって管理されるグローバル設定はなくなりました。設定は、インスタンス化された各サービスクライアントに渡す必要があります。同じ設定を複数のクライアント間で共有することは可能ですが、その設定はグローバルステートに自動的にマージされません。

## サービスごとの構成の設定
<a name="service-specific-configuration"></a>

SDK for JavaScript で使用する各サービスには、そのサービスの API の一部であるサービスオブジェクトを介してアクセスします。例えば、Amazon S3 サービスにアクセスするには、Amazon S3 サービスオブジェクトを作成します。そのサービスオブジェクトのコンストラクタの一部として、サービスに固有の設定を指定できます。

たとえば、複数の AWS リージョンで Amazon EC2 オブジェクトにアクセスする必要がある場合は、リージョンごとに Amazon EC2 サービスオブジェクトを作成し、それに応じて各サービスオブジェクトのリージョン設定を設定します。

```
var ec2_regionA = new EC2({region: 'ap-southeast-2', maxAttempts: 15});
var ec2_regionB = new EC2({region: 'us-west-2', maxAttempts: 15});
```

# AWS リージョンを設定する
<a name="setting-region"></a>

 AWS リージョンは、同じ地理的領域にある AWS リソースの名前付きセットです。リージョンの例は `us-east-1` です。これは、米国東部 (バージニア北部) リージョンです。SDK がその地域内のサービスにアクセスするように、SDK for JavaScript でサービスクライアントを作成するときに地域を指定します。 の一部のサービスは、特定のリージョンでのみ利用可能です。

SDK for JavaScript は、デフォルトではリージョンを選択しません。ただし、環境変数または共有設定`config`ファイルを使用して AWS リージョンを設定できます。

## クライアントクラスコンストラクタ内
<a name="setting-region-constructor"></a>

サービスオブジェクトをインスタンス化するときは、次に示すように、クライアントクラスコンストラクタの一部としてそのリソースの AWS リージョンを指定できます。

```
const s3Client = new S3.S3Client({region: 'us-west-2'});
```

## 環境変数の使用
<a name="setting-region-environment-variable"></a>

`AWS_REGION` 環境変数を設定して、リージョンを設定できます。この変数を定義すると、SDK for JavaScript がそれを読み込み、使用します。

## 共有 Config ファイルの使用
<a name="setting-region-config-file"></a>

共有認証情報ファイルで SDK で使用する認証情報を保存できるのと同様に、 AWS リージョンやその他の設定は、SDK `config` が使用する という名前の共有ファイルに保持できます。`AWS_SDK_LOAD_CONFIG` 環境変数が真の値に設定されている場合、SDK for JavaScript はロード時に`config`ファイルを自動的に検索します。`config` ファイルを保存する場所はオペレーティングシステムによって異なります。
+ Linux、macOS、またはUnix ユーザー－`~/.aws/config`
+ Windows ユーザー－`C:\Users\USER_NAME\.aws\config`

共有 `config` ファイルがまだない場合は、指定されたディレクトリに 1 つ作成することができます。次の例では、`config` ファイルはリージョンと出力形式の両方を設定します。

```
[default]
   region=us-west-2
   output=json
```

共有された `config` および `credentials` ファイルの使用についての詳細は、「AWS SDK とツールのリファレンスガイド」の「[共有設定ファイルおよび認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。

## 地域設定の優先順位
<a name="setting-region-order-of-precedence"></a>

地域設定の優先順位は以下の通りです。

1. リージョンがクライアントクラスコンストラクタに渡された場合、そのリージョンが使用されます。

1. 環境変数に地域が設定されている場合は、その地域が使用されます。

1. それ以外の場合は、共有 config ファイルで定義された地域が使用されます。

# 認証情報の設定
<a name="setting-credentials"></a>

AWS は認証情報を使用して、サービスを呼び出すユーザーと、リクエストされたリソースへのアクセスが許可されているかどうかを識別します。

ウェブブラウザでも、Node.js サーバーでも、JavaScript コードは API を介してサービスにアクセスする前に有効な認証情報を取得する必要があります。認証情報は、認証情報をサービスオブジェクトに直接渡してサービスごとに設定することができます。　　　　

ウェブブラウザで Node.js と JavaScript の間で異なる認証情報を設定する方法はいくつかあります。このセクションのトピックでは、Node.js またはウェブブラウザで認証情報を設定する方法について説明します。いずれの場合も、オプションは推奨順に表示されています。

## 認証情報のベストプラクティス
<a name="credentials-best-practices"></a>

認証情報を正しく設定することで、ミッションクリティカルなアプリケーションに影響を与えたり重要なデータを侵害する可能性があるセキュリティ問題への露出を最小限に抑えながら、アプリケーションまたはブラウザスクリプトが必要なサービスおよびリソースにアクセスできるようにします。

認証情報を設定するときに適用する重要な原則は、常に自分のタスクに必要な最小限の権限を付与することです。最小限のアクセス許可を超えるアクセス許可を提供し、その結果、セキュリティ問題が後で発見されてそれを修正するよりも、リソースに対する最小限のアクセス許可を提供し、必要に応じてさらにアクセス許可を追加する方が安全です。例えば、Amazon S3 バケット内のオブジェクトや DynamoDB テーブル内のオブジェクトなど、個々のリソースを読み書きする必要がある場合を除き、これらのアクセス許可を読み取り専用に設定します。

最小特権の付与の詳細については、「IAM ユーザーガイド」のベストプラクティストピックの「[最小特権を付与](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege)」を参照してください。

**Topics**
+ [認証情報のベストプラクティス](#credentials-best-practices)
+ [Node.js で認証情報を設定する](setting-credentials-node.md)
+ [ウェブブラウザの認証情報を設定する](setting-credentials-browser.md)

# Node.js で認証情報を設定する
<a name="setting-credentials-node"></a>

ローカルで開発中で、雇用主がセットアップするための認証方法を与えられていない新しいユーザーをお勧めします AWS IAM アイデンティティセンター。詳細については、「[を使用した SDK 認証 AWS](getting-your-credentials.md)」を参照してください。

Node.js では、SDK に認証情報を提供する方法がいくつかあります。これらの中には、より安全なものもあれば、アプリケーションの開発中により便利に使えるものもあります。Node.js で認証情報を取得する場合は、環境変数やロードした JSON ファイルなど、1つ以上のソースに依存するように注意してください。変更が行われたことに気付かずに、コードの実行に使用されるアクセス許可を変更してしまう可能性があります。

AWS SDK for JavaScript V3 は Node.js でデフォルトの認証情報プロバイダーチェーンを提供するため、認証情報プロバイダーを明示的に指定する必要はありません。デフォルトの[認証情報プロバイダーチェーン](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain)は、認証情報が 1 つのソースから返されるまで指定された優先順位で、さまざまな異なるソースからの認証情報を解決しようとします。SDK for JavaScript V3 の認証情報プロバイダーチェーンについては、[こちら](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/#fromnodeproviderchain)を参照してください。

## 認証情報プロバイダーチェーン
<a name="credchain"></a>

すべての SDK には、 AWS のサービスに対するリクエストに使用する有効な認証情報を取得するためにチェックする一連の場所 (またはソース) があります。有効な認証情報が見つかると、検索は停止されます。この体系的な検索は、デフォルトの認証情報プロバイダーチェーンと呼ばれます。

チェーンのステップごとに、値を設定するさまざまな方法があります。コード内で直接値を設定することが常に優先され、その後に環境変数として を設定し、共有ファイルで を設定します AWS `config`。詳細については、『*AWS SDK とツールのリファレンスガイド*』の「[設定の優先順位](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#precedenceOfSettings)」を参照してください。

*AWS SDKsおよびツールリファレンスガイドには、*すべての SDK および で使用される AWS SDKs設定に関する情報が記載されています AWS CLI。共有 AWS `config`ファイルを使用して SDK を設定する方法の詳細については、[「共有設定ファイルと認証情報ファイル](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html)」を参照してください。環境変数を設定して SDK を設定する方法の詳細については、「[環境変数のサポート](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html)」を参照してください。

で認証するために AWS、 は認証情報プロバイダーを次の表に示す順序で AWS SDK for JavaScript 確認します。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html)

新規ユーザーに推奨されるアプローチに従って開始した場合は、「使用開始」のトピックの [を使用した SDK 認証 AWS](getting-your-credentials.md) 中に AWS IAM アイデンティティセンター 認証を設定します。その他の認証方法もさまざまな状況で役に立ちます。セキュリティリスクを避けるため、常に短期の認証情報を使用することをお勧めします。その他の認証方法については、「AWS SDK とツールのリファレンスガイド」の「[認証とアクセス](https://docs.aws.amazon.com/sdkref/latest/guide/access.html)」を参照してください。

このセクションのトピックでは、認証情報を Node.js にロードする方法について説明します。

**Topics**
+ [認証情報プロバイダーチェーン](#credchain)
+ [Amazon EC2 の IAM ロールから認証情報を Node.js にロードする](loading-node-credentials-iam.md)
+ [Node.js Lambda 関数の認証情報をロードする](loading-node-credentials-lambda.md)

# Amazon EC2 の IAM ロールから認証情報を Node.js にロードする
<a name="loading-node-credentials-iam"></a>

Amazon EC2 インスタンスで Node.js アプリケーションを実行する場合、Amazon EC2 の IAM ロールを活用して自動的に認証情報をインスタンスに提供できます。IAM ロールを使用するようにインスタンスを設定する場合、SDK はアプリケーションの IAM 認証情報を自動的に選択するため、手動で認証情報を提供する必要がなくなります。

Amazon EC2 インスタンスへの IAM ロールの追加の詳細については、 [IAM roles for Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)（Amazon EC2 の IAM ロール）を参照してください。

# Node.js Lambda 関数の認証情報をロードする
<a name="loading-node-credentials-lambda"></a>

 AWS Lambda 関数を作成するときは、関数を実行するアクセス許可を持つ特別な IAM ロールを作成する必要があります。このロールは、*実行ロール*と呼ばれます。Lambda 関数を設定するときは、作成した IAM ロールを対応する実行ロールとして指定する必要があります。

実行ロールは、実行と他のウェブサービスを呼び出すために必要な認証情報を Lambda 関数に提供します。その結果、Lambda 関数内で記述した Node.js コードに認証情報を提供する必要はありません。

Lambda 実行ロール作成の詳細については、*AWS Lambda Developer Guide*（ デベロッパーガイド）の[Manage permissions: Using an IAM role (execution role)](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role)（許可の管理: IAM ロール (実行ロール)の使用）を参照してください。

# ウェブブラウザの認証情報を設定する
<a name="setting-credentials-browser"></a>

ブラウザスクリプトから SDK に認証情報を提供する方法はいくつかあります。これらの中には、より安全なものもあれば、スクリプトの開発中により便利に使えるものもあります。

 推薦順で認証情報を提供できる方法は次のとおりです。

1. Amazon Cognito アイデンティティを使用してユーザーを認証し、認証情報を提供する

1. ウェブフェデレーテッド ID を使用する

**警告**  
スクリプトに AWS 認証情報をハードコーディングすることはお勧めしません。認証情報をハードコーディングすると、アクセスキー ID とシークレットアクセスキーが公開される危険があります。

**Topics**
+ [Amazon Cognito アイデンティティを使用してユーザー認証をする](loading-browser-credentials-cognito.md)

# Amazon Cognito アイデンティティを使用してユーザー認証をする
<a name="loading-browser-credentials-cognito"></a>

ブラウザスクリプトのAWS 認証情報を入手する推薦方法は、Amazon Cognito アイデンティティ認証情報クライアント`CognitoIdentityClient` を使います。Amazon Cognito では、サードパーティのアイデンティティプロバイダーによるユーザーの認証が可能です。

Amazon Cognito アイデンティティを使用するには、最初に Amazon Cognito コンソールでアイデンティティプールを作成する必要があります。ID プールは、アプリケーションがユーザーに提供する ID のグループを表します。ユーザーに与えられたアイデンティティは、各ユーザーアカウントを一意に識別します。Amazon Cognito ID は認証情報ではありません。これらは AWS Security Token Service (AWS STS) のウェブ ID フェデレーションサポートを使用して認証情報と交換されます。

Amazon Cognito は、複数のアイデンティティプロバイダーにわたるアイデンティティの抽象化を管理するのに役立ちます。ロードされた ID は AWS STS の認証情報と交換されます。

## Amazon Cognito アイデンティティ認証情報オブジェクトを設定する
<a name="browser-cognito-configuration"></a>

まだ作成していない場合は、Amazon Cognito クライアントを設定する前に [Amazon Cognito console](https://console.aws.amazon.com/cognito)（Amazon Cognito コンソール）でブラウザスクリプトによりアイデンティティプールを作成してください。アイデンティティプール用の認証済み IAM ロールと未認証 IAM ロールの両方を作成して関連付けます。詳細については、「Amazon Cognito デベロッパーガイド」の「[チュートリアル: ID プールの作成](https://docs.aws.amazon.com/cognito/latest/developerguide/tutorial-create-identity-pool.html)」を参照してください。

認証されていないユーザーは アイデンティティが検証されないため、このロールはアプリケーションのゲストユーザーに適切です。または、ユーザーのアイデンティティが検証されているかどうかが重要ではない場合に適切です。認証されているユーザーは、自分の ID を確認するサードパーティーの ID プロバイダーを介してアプリケーションにログインします。リソースの許可の範囲を適切に設定し、認証されていないユーザーからのアクセスを許可しないようにします。

アイデンティティプールを設定したら、`@aws-sdk/credential-providers` から `fromCognitoIdentityPool` のメソッドを使用して、アイデンティティプールから認証情報を取得します。Amazon S3 クライアントを作成する次の例では、*AWS\$1REGION* をリージョンに、*IDENTITY\$1POOL\$1ID* をアイデンティティプール ID に置き換えます。

```
// Import required AWS SDK clients and command for Node.js
import {S3Client} from "@aws-sdk/client-s3";
import {fromCognitoIdentityPool} from "@aws-sdk/credential-providers";

const REGION = AWS_REGION;

const s3Client = new S3Client({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    clientConfig: { region: REGION }, // Configure the underlying CognitoIdentityClient.
    identityPoolId: 'IDENTITY_POOL_ID',
    logins: {
            // Optional tokens, used for authenticated login.
        },
  })
});
```

オプションの `logins` プロパティは、ID プロバイダー名の ID トークンへのマッピングです。ID プロバイダーからのトークンの取得方法は、使用するプロバイダーによって異なります。たとえば、Amazon Cognito ユーザープールを認証プロバイダーとして使用している場合は、以下のような方法を同様に使用できます。

```
// Get the Amazon Cognito ID token for the user. 'getToken()' below.
let idToken = getToken();
let COGNITO_ID = "COGNITO_ID"; // 'COGNITO_ID' has the format 'cognito-idp.REGION.amazonaws.com/COGNITO_USER_POOL_ID'
let loginData = {
  [COGNITO_ID]: idToken,
};
const s3Client = new S3Client({
    region: REGION,
    credentials: fromCognitoIdentityPool({
    clientConfig: { region: REGION }, // Configure the underlying CognitoIdentityClient.
    identityPoolId: 'IDENTITY_POOL_ID',
    logins: loginData
  })
});

// Strips the token ID from the URL after authentication.
window.getToken = function () {
  var idtoken = window.location.href;
  var idtoken1 = idtoken.split("=")[1];
  var idtoken2 = idtoken1.split("&")[0];
  var idtoken3 = idtoken2.split("&")[0];
  return idtoken3;
};
```

## 認証されていないユーザーから認証されたユーザーに切り替える
<a name="browser-switching-unauthenticated-users"></a>

Amazon Cognito は、認証されたユーザーと認証されていないユーザーの両方をサポートします。認証されていないユーザーは、ID プロバイダーのいずれにもログインしていない場合でも、リソースにアクセスできます。このレベルのアクセスは、ログインする前にユーザーにコンテンツを表示するのに便利です。認証されていない各ユーザーは、個別にログインして認証していない場合でも Amazon Cognito で一意のアイデンティティを持ちます。

### 認証されていないユーザーとしての開始
<a name="browser-initially-unauthenticated-user"></a>

ユーザーは通常、認証されていないロールから開始します。このロールでは、`logins` プロパティを使用しないで設定オブジェクトの認証情報プロパティを設定します。この場合、デフォルト認証情報は次のようになります。

```
// Import the required AWS SDK for JavaScript v3 modules.                   
import {fromCognitoIdentityPool} from "@aws-sdk/credential-providers";
// Set the default credentials.
const creds = fromCognitoIdentityPool({
  identityPoolId: 'IDENTITY_POOL_ID',
  clientConfig: { region: REGION } // Configure the underlying CognitoIdentityClient.
});
```

### 認証されたユーザーへの切り替え
<a name="switch-to-authenticated"></a>

認証されていないユーザーが アイデンティティプロバイダーにログインしたときに、トークンがあれば、カスタム関数を呼び出して認証情報オブジェクトを更新し `logins` トークンを追加することで、認証されていないユーザーを認証されたユーザーに切り替えることができます。

```
// Called when an identity provider has a token for a logged in user
function userLoggedIn(providerName, token) {
  creds.params.Logins = creds.params.logins || {};
  creds.params.Logins[providerName] = token;
                    
  // Expire credentials to refresh them on the next request
  creds.expired = true;
}
```

# Node.js の考慮事項
<a name="node-js-considerations"></a>

Node.js コードは JavaScript ですが、Node.js AWS SDK for JavaScript での の使用は、ブラウザスクリプトでの SDK の使用とは異なる場合があります。一部の API メソッドは Node.js で動作しますが、ブラウザスクリプトでは動作しません。また、その逆も生じます。また、一部の API をうまく使用するには、`File System (fs)` モジュールなどの他の Node.js モジュールをインポートして使用するなど、一般的な Node.js コーディングパターンに精通している必要があります。

**注記**  
AWS では、開発にアクティブ LTS バージョンの Node.js を使用することをお勧めします。

## 組み込み Node.js モジュールの使用
<a name="node-common-modules"></a>

Node.js では、インストールしなくても使用できる一連の組み込みモジュールを提供します。これらのモジュールを使用するには、モジュール名を指定するために `require` メソッドを使ってオブジェクトを作成します。たとえば、組み込みの HTTP モジュールを含めるには、次のようにします。

```
import http from 'http';
```

モジュールのメソッドを、そのオブジェクトのメソッドであるかのように呼び出します。たとえば、次に示すのは HTML ファイルを読み込むコードです。

```
// include File System module
import fs from "fs"; 
// Invoke readFile method 
fs.readFile('index.html', function(err, data) {
  if (err) {
    throw err;
  } else {
    // Successful file read
  }
});
```

Node.js が提供するすべての組み込みモジュールの完全なリストについては、Node.js ウェブサイトの「[Node.js のドキュメント](https://nodejs.org/api/modules.html)」を参照してください。

## npm パッケージの使用
<a name="node-npm-packages"></a>

組み込みのモジュールに加えて、Node.js パッケージマネージャーの`npm`から、サードパーティーコードを含めたり、組み込んだりすることもできます。これは、オープンソースの Node.js パッケージとそれらのパッケージをインストールするためのコマンドラインインターフェイスのリポジトリです。`npm` の詳細と現在利用可能なパッケージのリストについては、[https://www.npmjs.com](https://www.npmjs.com) を参照してください。使用できる追加の Node.js パッケージについて、[GitHub のこちら](https://github.com/sindresorhus/awesome-nodejs)で学ぶこともできます。

# Node.js で maxSockets を設定する
<a name="node-configuring-maxsockets"></a>

Node.js では、オリジンあたりの最大接続数を設定できます。` maxSockets` が設定されている場合、低レベルの HTTP クライアントはリクエストをキューに入れ、利用可能になったときに、ソケットに割り当てます。

これにより、一度に特定のオリジンへの同時リクエスト数の上限を設定できます。この値を小さくすると、受信したスロットリングエラーまたはタイムアウトエラーの数を減らすことができます。ただし、ソケットが使用可能になるまでリクエストがキューに入れられるため、メモリ使用量も増加する可能性があります。

次の例は、DynamoDB クライアント用に`maxSockets`を設定する方法を示しています。

```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { NodeHttpHandler } from "@smithy/node-http-handler";
import https from "https";    
let agent = new https.Agent({
  maxSockets: 25
});

let dynamodbClient = new DynamoDBClient({
  requestHandler: new NodeHttpHandler({
    requestTimeout: 3_000,
    httpsAgent: agent
  });
});
```

値または `Agent` オブジェクトを指定しない場合、SDK for JavaScript は `maxSockets` の値として 50 を使用します。`Agent` オブジェクトを指定すると、その `maxSockets` 値が使用されます。Node.js で `maxSockets` を設定する方法の詳細については、[Node.js のオンラインドキュメント](https://nodejs.org/dist/latest/docs/api/http.html#http_agent_maxsockets)を参照してください。

の v3.521.0 以降では AWS SDK for JavaScript、次の[短縮構文](https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md#new-in-v35210)を使用して を設定できます`requestHandler`。

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

const client = new DynamoDBClient({
  requestHandler: {
    requestTimeout: 3_000,
    httpsAgent: { maxSockets: 25 },
  },
});
```

# Node.js で Keep-alive を使用して接続を再利用する
<a name="node-reusing-connections"></a>

デフォルトの Node.js HTTP/HTTPS エージェントは新しいリクエストがあるたびに新しい TCP 接続を作成します。新しい接続を確立するコストを回避するために、 は*デフォルトで* TCP 接続を AWS SDK for JavaScript 再利用します。

Amazon DynamoDB クエリなどの短期間のオペレーションでは、TCP 接続を設定する際のレイテンシーのオーバーヘッドが、オペレーション自体よりも大きくなる可能性があります。さらに、保管時の DynamoDB 暗号化は と統合されているため[AWS KMS](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html)、データベースからのレイテンシーがオペレーションごとに新しい AWS KMS キャッシュエントリを再確立しなければならない場合があります。 [https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html)

TCP 接続を再利用しない場合は、DynamoDB クライアントの次の例に示すように、サービスクライアントごとに `keepAlive` でこれらの接続の再利用を無効にすることもできます。

```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { NodeHttpHandler } from "@smithy/node-http-handler";
import { Agent } from "https";

const dynamodbClient = new DynamoDBClient({
    requestHandler: new NodeHttpHandler({
        httpsAgent: new Agent({ keepAlive: false })
    })
});
```

`keepAlive`が有効になっている場合、TCPキープアライブパケットの初期遅延を`keepAliveMsecs`に設定することもできます。これは、デフォルトでは1000ミリ秒(ms)です。詳細については、[Node.js のドキュメント](https://nodejs.org/api/http.html#new-agentoptions)を参照してください。

# Node.js 用のプロキシの設定
<a name="node-configuring-proxies"></a>

インターネットに直接接続できない場合、SDK for JavaScript は サードパーティーの HTTP エージェントを介した HTTP または HTTPS プロキシの使用をサポートします。

サードパーティーの HTTP エージェントを検索するには、[npm](https://www.npmjs.com/)で「HTTP プロキシ」を検索します。

サードパーティーの HTTP エージェントプロキシをインストールするには、コマンドプロンプトで次のように入力します。ここでは*PROXY*（プロキシ）は`npm`パッケージの名前です。

```
npm install PROXY --save
```

アプリケーションでプロキシを使用するには、DynamoDBクライアントの次の例に示すように、`httpAgent`と ` httpsAgent`プロパティを使用します。

```
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { NodeHttpHandler } from "@smithy/node-http-handler";
import { HttpsProxyAgent } from "hpagent";
const agent = new HttpsProxyAgent({ proxy: "http://internal.proxy.com" });
const dynamodbClient = new DynamoDBClient({
    requestHandler: new NodeHttpHandler({
        httpAgent: agent,
        httpsAgent: agent
    }),
});
```

**注記**  
`httpAgent`は`httpsAgent`と同じではなく、クライアントからのほとんどの呼び出しは `https` になるため、両方を設定する必要があります。

# Node.js で証明書バンドルを登録する
<a name="node-registering-certs"></a>

Node.js のデフォルトの信頼ストアには、 AWS のサービスへのアクセスに必要な証明書が含まれています 場合によっては、特定の証明書セットのみを含めることが望ましい場合があります。

この例では、指定された証明書が提供されない限り、接続を拒否する ` https.Agent` を作成するためにディスク上の特定の証明書が使用されます。新しく作成された`https.Agent`は、その次に、DynamoDB クライアントによって使用されます。

```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { NodeHttpHandler } from "@smithy/node-http-handler";
import { Agent } from "https";
import { readFileSync } from "fs";
const certs = [readFileSync("/path/to/cert.pem")];
const agent = new Agent({
  rejectUnauthorized: true,
  ca: certs
});
const dynamodbClient = new DynamoDBClient({
  requestHandler: new NodeHttpHandler({
    httpAgent: agent,
    httpsAgent: agent
  })
});
```

# ブラウザスクリプトの考慮事項
<a name="browser-js-considerations"></a>

以下のトピックでは、ブラウザスクリプト AWS SDK for JavaScript で を使用するための特別な考慮事項について説明します。

**Topics**
+ [ブラウザ用 SDK の構築](building-sdk-for-browsers.md)
+ [Cross-Origin Resource Sharing (CORS)](cors.md)
+ [Webpack でアプリケーションをバンドルする](webpack.md)

# ブラウザ用 SDK の構築
<a name="building-sdk-for-browsers"></a>

SDK for JavaScriptバージョン2 (V2)とは異なり 、V3はサービスのデフォルトセットを含んでサポートする JavaScript ファイルとして提供されていません。代わりに V3 は、必要な SDK for JavaScript ファイルのみをバンドルしてブラウザに含め、オーバーヘッドの削減を有効にします。Webpack を使用して、必要な SDK for Java Script ファイルと、必要な追加のサードパーティパッケージを `Javascript`ファイルにまとめ、 `<script>`タグを使用してブラウザスクリプトにロードします。Webpackの詳細については、「[Webpack でアプリケーションをバンドルする](webpack.md)」を参照してください。

ブラウザで CORS を強制する環境の外側で SDK を使用し、SDK for JavaScript によって提供されるすべてのサービスにアクセスする場合は、リポジトリを複製し、SDK のデフォルトのホストバージョンをビルドするのと同じビルドツールを実行することで、SDK のカスタムコピーをローカルにビルドできます。次のセクションでは、追加のサービスと API バージョンを使用して SDK を構築するステップについて説明します。

## SDK Builder を使用した SDK for JavaScript の構築
<a name="using-the-sdk-builder"></a>

**注記**  
Amazon Web Services バージョン 3 (V3) はブラウザビルダーをサポートは終了しました。ブラウザアプリケーションの帯域幅の使用量を最小限に抑えるために、名前付きモジュールをインポートし、それらをバンドルしてサイズを小さくすることをお勧めします。バンドルの詳細については、「[Webpack でアプリケーションをバンドルする](webpack.md)」を参照してください。

# Cross-Origin Resource Sharing (CORS)
<a name="cors"></a>

Cross-Origin Resource Sharing (CORS) は、最新ウェブブラウザのセキュリティ機能です。これにより、ウェブブラウザはどのドメインが外部のウェブサイトまたはサービスのリクエストを行うことができるかをネゴシエートできます。

AWS SDK for JavaScript を使用してブラウザアプリケーションを開発する場合、CORS は重要な考慮事項です。リソースへのリクエストのほとんどは、ウェブサービスのエンドポイントなどの外部ドメインに送信されるためです。JavaScript 環境で CORS セキュリティが適用される場合は、そのサービスで CORS を設定する必要があります。

CORS は、クロスオリジンリクエストでリソースの共有を許可するかどうかを、以下に基づいて決定します。
+ リクエストを行う特定のドメイン 
+ 行われている HTTP リクエストのタイプ (GET、PUT、POST、DELETE など)

## CORS の仕組みは
<a name="how-cors-works"></a>

最も簡単なケースとして、ブラウザスクリプトは他のドメインのサーバーからリソースの GET リクエストを行います。そのサーバーの CORS 設定に応じて、リクエストが GET リクエストの送信を許可されているドメインからのものである場合、クロスオリジンサーバーはリクエストされたリソースを返すことによって応答します。

リクエスト元のドメインまたは HTTP リクエストの種類のいずれかが承認されていない場合、リクエストは拒否されます。ただし、CORS では、実際に送信する前にリクエストをプリフライトすることができます。この場合、`OPTIONS` アクセスリクエストオペレーションが送信されるプリフライトリクエストが行われます。クロスオリジンサーバーの CORS 設定がリクエスト元ドメインへのアクセスを許可する場合、サーバーはリクエスト元ドメインがリクエストされたリソースに対して行うことができるすべての HTTP リクエストタイプをリストしたプリフライト応答を返送します。

![\[CORS リクエストのプロセスの流れ\]](http://docs.aws.amazon.com/ja_jp/sdk-for-javascript/v3/developer-guide/images/cors-overview.png)


## CORS の設定が必要ですか
<a name="the-need-for-cors-configuration"></a>

Amazon S3 バケットを操作する前に、CORS の設定が必要です。一部のJavaScript環境では、CORSが適用されない場合があるため、CORSを設定する必要はありません。例えば、Amazon S3 バケットからアプリケーションをホストし、 `*.s3.amazonaws.com` またはその他の特定のエンドポイントからリソースにアクセスする場合、リクエストは外部ドメインにアクセスしません。したがって、この CORS 設定は必要ありません。この場合、CORS は Amazon S3 以外のサービスに使用されます。

## Amazon S3 バケット用の CORS の設定
<a name="configuring-cors-s3-bucket"></a>

AmazonS3 コンソールで CORS を使用するように AmazonS3 バケットを設定できます。

AWS ウエブサービスマネジメントコンソールで CORS を設定する場合は、JSON を使用して CORS 設定を作成する必要があります。新しいAWS ウエブサービスマネジメントコンソールは、JSON CORS 設定のみがサポートされます。

**重要**  
新しい AWS ウェブサービスマネジメントコンソールでは、CORS 設定は JSON にする必要があります。

1. AWS ウェブサービスマネジメントコンソールでは、Amazon S3 コンソールを開き、設定したいバケットを見つけ、そのチェックボックスを選択します。

1. 開いたペインで、**Permissions**（許可）を選択します。

1. **Permissions**（許可）タブで、**CORS Configuration**（CORS 設定）を選択します。

1. **CORS Configuration Editor**（CORS 設定エディタ）でCORS設定を入力して、**Save**（保存）を選択します。

CORS 設定は、`<CORSRule>` の一連のルールを含む XML ファイルです。設定は最大で 100 個のルールを持つことができます。ルールは次のいずれかのタグによって定義されます。
+ `<AllowedOrigin>` ―クロスドメインリクエストを許可するドメインオリジンを指定します。
+ `<AllowedMethod>` ―クロスドメインリクエストで許可するリクエストの種類 (GET、PUT、POST、DELETE、HEAD) を指定します。
+ `<AllowedHeader>` ―プリフライトリクエストで許可されるヘッダーを指定します。

設定例については、*Amazon Simple Storage Service User Guide*（Amazon Simple ストレージサービスユーザーガイド）の「 [How do I configure CORS on my bucket?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/cors.html#how-do-i-enable-cors) 」（バケットで CORS を設定する方法）を参照してください。

## CORS 設定例
<a name="cors-configuration-example"></a>

次の CORS 設定例では、ユーザーはドメイン`example.org`からバケット内のオブジェクトを表示、追加、削除、または更新することができます。ただし、ウェブサイトのドメインに`<AllowedOrigin>`を追加することの検討をお勧めします。オリジンを許可するように `"*"` を指定できます。

**重要**  
新しい S3 コンソールでは、CORS 設定は JSON である必要があります。

------
#### [ XML ]

```
<?xml version="1.0" encoding="UTF-8"?>
<CORSConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
  <CORSRule>
    <AllowedOrigin>https://example.org</AllowedOrigin>
    <AllowedMethod>HEAD</AllowedMethod>
    <AllowedMethod>GET</AllowedMethod>
    <AllowedMethod>PUT</AllowedMethod>
    <AllowedMethod>POST</AllowedMethod>
    <AllowedMethod>DELETE</AllowedMethod>
    <AllowedHeader>*</AllowedHeader>
    <ExposeHeader>ETag</ExposeHeader>
    <ExposeHeader>x-amz-meta-custom-header</ExposeHeader>
  </CORSRule>
</CORSConfiguration>
```

------
#### [ JSON ]

```
[
    {
        "AllowedHeaders": [
            "*"
        ],
        "AllowedMethods": [
            "HEAD",
            "GET",
            "PUT",
            "POST",
            "DELETE"
        ],
        "AllowedOrigins": [
            "https://www.example.org"
        ],
        "ExposeHeaders": [
             "ETag",
             "x-amz-meta-custom-header"]
    }
]
```

------

この設定では、ユーザーがバケットに対してアクションを実行することは許可されません。ブラウザのセキュリティモデルで Amazon S3 へのリクエストを許可できます。許可はバケット権限または IAM ロール権限を介して設定する必要があります。

`ExposeHeader` を使用して、SDK に Amazon S3 から返されたレスポンスヘッダーを読み込ませることができます。例えば、`PUT`またはマルチパートアップロードから`ETag`ヘッダーを読み取る場合、前の例に示すように、設定に`ExposeHeader`タグを含める必要があります。SDK は、CORS 設定によって公開されているヘッダーにのみアクセスできます。オブジェクトにメタデータを設定すると、値は `x-amz-meta-` のように、プレフィックス `x-amz-meta-my-custom-header` を持つヘッダーとして返され、同じ方法で公開されている必要があります。

# Webpack でアプリケーションをバンドルする
<a name="webpack"></a>

ブラウザスクリプトまたはNode.jsでWebアプリケーションでコードモジュールを使用すると、依存関係が作成されます。これらのコードモジュールは独自の依存関係を持つことができ、結果として、アプリケーションが機能するために必要な、相互接続されたモジュールの集まりができます。依存関係を管理するには、`webpack`などのモジュールバンドラーを使用できます。

`webpack`モジュールバンドラーはアプリケーションコードを解析して、`import` または `require` ステートメントを検索し、アプリケーションに必要なすべてのアセットを含むバンドルを作成します。これは、アセットを Web ページを介して簡単に提供できるようにするためです。SDK for JavaScript は、出力バンドルに含める依存関係の1つとして`webpack` に含めることができます。

`webpack`の詳細については、GitHub の [webpack module bundler](https://webpack.github.io/)（Webpack モジュールバンドラー）を参照してください。

## Webpackをインストールします
<a name="webpack-installing"></a>

`webpack`モジュールバンドラーをインストールするには、まず npm (Node.js パッケージマネージャー) をインストールする必要があります。`webpack`CLI およびJavaScriptモジュールをインストールするには、次のコマンドを入力します。

```
npm install --save-dev webpack
```

ファイルとディレクトリパスを操作するためのモジュール`path`を使用するには、Webpack で自動的にインストールされる場合は、Node.js `path-browserify`パッケージをインストールする必要があります。

```
npm install --save-dev path-browserify
```

## Webpack を設定する
<a name="webpack-configuring"></a>

デフォルトで、webpack はプロジェクトのルートディレクトリにある`webpack.config.js`という名前のJavaScript ファイルを検索します。このファイルは、設定オプションを指定します。WebPackバージョン 5.0.0とそれ 以降の `webpack.config.js` 設定ファイルの例を次に示します。

**注記**  
Webpackの設定要件は、インストールする Webpack のバージョンによって異なります。詳細については、[Webpack documentation](https://webpack.js.org/configuration/)（Webpack ドキュメント）を参照してください。

```
// Import path for resolving file paths
var path = require("path");
module.exports = {
  // Specify the entry point for our app.
  entry: [path.join(__dirname, "browser.js")],
  // Specify the output file containing our bundled code.
  output: {
    path: __dirname,
    filename: 'bundle.js'
  },
   // Enable WebPack to use the 'path' package.
   resolve:{
  fallback: { path: require.resolve("path-browserify")}
  }
  /**
  * In Webpack version v2.0.0 and earlier, you must tell 
  * webpack how to use "json-loader" to load 'json' files.
  * To do this Enter 'npm --save-dev install json-loader' at the 
  * command line to install the "json-loader' package, and include the 
  * following entry in your webpack.config.js.
  * module: {
    rules: [{test: /\.json$/, use: use: "json-loader"}]
  }
  **/
};
```

この例では、 *entry point*（エントリポイント）として`browser.js` が指定されます。*entry point*（エントリポイント）は、インポートされたモジュールの検索を開始するために使用するファイル`webpack`です。出力のファイル名は `bundle.js` として指定されます。この出力ファイルには、アプリケーションの実行に必要なすべての JavaScript が含まれています。エントリーポイントで指定されたコードが SDK for JavaScript などの他のモジュールをインポートまたは必要とする場合、そのコードは設定で指定しなくてもバンドルされます。

## Webpack を実行する
<a name="webpack-running"></a>

アプリケーションが`webpack`を使用するように設定するには、`package.json`ファイル内の`scripts`オブジェクトに以下を追加します。

```
"build": "webpack"
```

以下は、`webpack`の追加を示す`package.json`ファイルの例です。

```
{
  "name": "aws-webpack",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "webpack"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@aws-sdk/client-iam": "^3.32.0",
    "@aws-sdk/client-s3": "^3.32.0"
  },
  "devDependencies": {
    "webpack": "^5.0.0"
  }
}
```

アプリケーションを構築するには、次のコマンドを入力します。

```
npm run build
```

そして、`webpack`モジュールバンドラーは、プロジェクトのルートディレクトリで指定した JavaScript ファイルを生成します。

## Webpack バンドルを使用する
<a name="webpack-using-bundle"></a>

ブラウザスクリプトでバンドルを使用するには、次の例で示すように `<script>` タグを使用してバンドルを組み込むことができます。

```
<!DOCTYPE html>
<html>
    <head>
        <title>Amazon SDK with webpack</title>
    </head> 
    <body>
        <div id="list"></div>
        <script src="bundle.js"></script>
    </body>
</html>
```

## Node.js 用のバンドル
<a name="webpack-nodejs-bundles"></a>

設定でターゲットとして`node`を指定することにより、Node.jsで実行されるバンドルを生成するために`webpack`を使用できます。

```
target: "node"
```

これは、ディスク容量に制限がある環境で Node.js アプリケーションを実行するときに役立ちます。出力ターゲットとして指定された Node.js を使用した `webpack.config.js` 設定の例を次に示します。

```
// Import path for resolving file paths
var path = require("path");
module.exports = {
  // Specify the entry point for our app.
  entry: [path.join(__dirname, "browser.js")],
  // Specify the output file containing our bundled code.
  output: {
    path: __dirname,
    filename: 'bundle.js'
  },
  // Let webpack know to generate a Node.js bundle.
  target: "node",
   // Enable WebPack to use the 'path' package.
   resolve:{
  fallback: { path: require.resolve("path-browserify")}
   /**
   * In Webpack version v2.0.0 and earlier, you must tell 
   * webpack how to use "json-loader" to load 'json' files.
   * To do this Enter 'npm --save-dev install json-loader' at the 
   * command line to install the "json-loader' package, and include the 
   * following entry in your webpack.config.js.
   module: {
    rules: [{test: /\.json$/, use: use: "json-loader"}]
  }
  **/
};
```