[Panduan Referensi API AWS SDK untuk JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) menjelaskan secara rinci semua operasi API untuk AWS SDK untuk JavaScript versi 3 (V3). 

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Konfigurasikan SDK untuk JavaScript
<a name="configuring-the-jssdk"></a>

Sebelum Anda menggunakan SDK for JavaScript untuk memanggil layanan web menggunakan API, Anda harus mengonfigurasi SDK. Minimal, Anda harus mengkonfigurasi:
+  AWS Wilayah di mana Anda akan meminta layanan
+ Bagaimana kode Anda mengautentikasi dengan AWS

Selain pengaturan ini, Anda mungkin juga harus mengonfigurasi izin untuk AWS sumber daya Anda. Misalnya, Anda dapat membatasi akses ke bucket Amazon S3 atau membatasi tabel Amazon DynamoDB untuk akses hanya-baca.

[Panduan Referensi AWS SDKs and Tools](https://docs.aws.amazon.com/sdkref/latest/guide/) juga berisi pengaturan, fitur, dan konsep dasar lainnya yang umum di antara banyak. AWS SDKs 

Topik di bagian ini menjelaskan cara mengonfigurasi SDK JavaScript untuk Node.js dan JavaScript berjalan di browser web.

**Topics**
+ [Konfigurasi per layanan](global-config-object.md)
+ [Mengatur AWS Wilayah](setting-region.md)
+ [Tetapkan kredensialnya](setting-credentials.md)
+ [Pertimbangan Node.js](node-js-considerations.md)
+ [Pertimbangan Skrip Browser](browser-js-considerations.md)

# Konfigurasi per layanan
<a name="global-config-object"></a>

Anda dapat mengonfigurasi SDK dengan meneruskan informasi konfigurasi ke objek layanan.

Konfigurasi tingkat layanan memberikan kontrol yang signifikan atas layanan individual, memungkinkan Anda untuk memperbarui konfigurasi objek layanan individual ketika kebutuhan Anda bervariasi dari konfigurasi default.

**catatan**  
Dalam versi 2.x konfigurasi AWS SDK untuk JavaScript layanan dapat diteruskan ke konstruktor klien individu. Namun, konfigurasi ini pertama-tama akan digabungkan secara otomatis ke dalam salinan konfigurasi SDK global. `AWS.config`  
Selain itu, `AWS.config.update({/* params *})` hanya memanggil konfigurasi yang diperbarui untuk klien layanan yang dipakai setelah panggilan pembaruan dilakukan, bukan klien yang ada.  
Perilaku ini sering menjadi sumber kebingungan, dan membuatnya sulit untuk menambahkan konfigurasi ke objek global yang hanya memengaruhi sebagian klien layanan dengan cara yang kompatibel ke depan. Di versi 3, tidak ada lagi konfigurasi global yang dikelola oleh SDK. Konfigurasi harus diteruskan ke setiap klien layanan yang dipakai. Masih dimungkinkan untuk berbagi konfigurasi yang sama di beberapa klien tetapi konfigurasi itu tidak akan digabungkan secara otomatis dengan status global.

## Tetapkan konfigurasi per layanan
<a name="service-specific-configuration"></a>

Setiap layanan yang Anda gunakan dalam SDK untuk JavaScript diakses melalui objek layanan yang merupakan bagian dari API untuk layanan tersebut. Misalnya, untuk mengakses layanan Amazon S3, Anda membuat objek layanan Amazon S3. Anda dapat menentukan pengaturan konfigurasi yang spesifik untuk layanan sebagai bagian dari konstruktor untuk objek layanan tersebut. 

Misalnya, jika Anda perlu mengakses objek Amazon EC2 di beberapa AWS Wilayah, buat objek layanan Amazon EC2 untuk setiap Wilayah, lalu atur konfigurasi Wilayah dari setiap objek layanan yang sesuai.

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

# Mengatur AWS Wilayah
<a name="setting-region"></a>

 AWS Wilayah adalah kumpulan AWS sumber daya bernama di wilayah geografis yang sama. Contoh dari sebuah Wilayah adalah`us-east-1`, yang merupakan Wilayah AS Timur (Virginia N.). Anda menentukan Region saat membuat klien layanan di SDK JavaScript agar SDK mengakses layanan di Wilayah tersebut. Beberapa layanan hanya tersedia di Wilayah tertentu.

SDK for JavaScript tidak memilih Region secara default. Namun, Anda dapat mengatur AWS Wilayah menggunakan variabel lingkungan, atau `config` file konfigurasi bersama.

## Dalam konstruktor kelas klien
<a name="setting-region-constructor"></a>

Ketika Anda membuat instance objek layanan, Anda dapat menentukan AWS Region untuk sumber daya tersebut sebagai bagian dari konstruktor kelas klien, seperti yang ditunjukkan di sini.

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

## Gunakan variabel lingkungan
<a name="setting-region-environment-variable"></a>

Anda dapat mengatur Wilayah menggunakan variabel `AWS_REGION` lingkungan. Jika Anda mendefinisikan variabel ini, SDK untuk JavaScript membacanya dan menggunakannya.

## Gunakan file konfigurasi bersama
<a name="setting-region-config-file"></a>

Sama seperti file kredensial bersama yang memungkinkan Anda menyimpan kredensional untuk digunakan oleh SDK, Anda dapat menyimpan AWS Region dan pengaturan konfigurasi lainnya dalam file bersama yang diberi nama `config` untuk digunakan SDK. Jika variabel `AWS_SDK_LOAD_CONFIG` lingkungan disetel ke nilai kebenaran, SDK untuk JavaScript secara otomatis mencari `config` file saat dimuat. Di mana Anda menyimpan `config` file tergantung pada sistem operasi Anda:
+ Pengguna Linux, macOS, atau Unix - `~/.aws/config`
+ Pengguna Windows - `C:\Users\USER_NAME\.aws\config`

Jika Anda belum memiliki `config` file bersama, Anda dapat membuatnya di direktori yang ditunjuk. Dalam contoh berikut, `config` file menetapkan Region dan format output.

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

Untuk informasi selengkapnya tentang penggunaan bersama `config` dan `credentials` file, lihat [File konfigurasi dan kredensial bersama](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) di Panduan Referensi *Alat AWS SDKs dan Alat*.

## Urutan prioritas untuk pengaturan Wilayah
<a name="setting-region-order-of-precedence"></a>

Berikut ini adalah urutan prioritas untuk pengaturan Wilayah:

1. Jika Region diteruskan ke konstruktor kelas klien, Region itu digunakan.

1. Jika Region diatur dalam variabel lingkungan, Region yang digunakan.

1. Jika tidak, Wilayah yang ditentukan dalam file konfigurasi bersama akan digunakan.

# Tetapkan kredensialnya
<a name="setting-credentials"></a>

AWS menggunakan kredensi untuk mengidentifikasi siapa yang memanggil layanan dan apakah akses ke sumber daya yang diminta diizinkan. 

Baik berjalan di browser web atau di server Node.js, JavaScript kode Anda harus mendapatkan kredensi yang valid sebelum dapat mengakses layanan melalui API. Kredensial dapat diatur per layanan, dengan meneruskan kredensional langsung ke objek layanan.

Ada beberapa cara untuk mengatur kredensi yang berbeda antara Node.js dan JavaScript di browser web. Topik di bagian ini menjelaskan cara mengatur kredensional di Node.js atau browser web. Dalam setiap kasus, opsi disajikan dalam urutan yang disarankan.

## Praktik terbaik untuk kredensional
<a name="credentials-best-practices"></a>

Menetapkan kredensional dengan benar memastikan bahwa aplikasi atau skrip browser Anda dapat mengakses layanan dan sumber daya yang diperlukan sambil meminimalkan paparan terhadap masalah keamanan yang dapat memengaruhi aplikasi penting misi atau membahayakan data sensitif.

Prinsip penting untuk diterapkan saat menetapkan kredensional adalah selalu memberikan hak istimewa paling sedikit yang diperlukan untuk tugas Anda. Lebih aman untuk memberikan izin minimal pada sumber daya Anda dan menambahkan izin lebih lanjut sesuai kebutuhan, daripada memberikan izin yang melebihi hak istimewa paling sedikit dan, sebagai hasilnya, diminta untuk memperbaiki masalah keamanan yang mungkin Anda temukan nanti. Misalnya, kecuali Anda perlu membaca dan menulis sumber daya individual, seperti objek di bucket Amazon S3 atau tabel DynamoDB, setel izin tersebut hanya untuk dibaca.

Untuk informasi selengkapnya tentang pemberian hak istimewa paling sedikit, lihat bagian [Hibah hak istimewa terkecil](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) dari topik Praktik Terbaik di Panduan Pengguna *IAM*.

**Topics**
+ [Praktik terbaik untuk kredensional](#credentials-best-practices)
+ [Setel kredensial di Node.js](setting-credentials-node.md)
+ [Mengatur kredensi di browser web](setting-credentials-browser.md)

# Setel kredensial di Node.js
<a name="setting-credentials-node"></a>

Kami merekomendasikan bahwa pengguna baru yang mengembangkan secara lokal dan tidak diberikan metode otentikasi oleh majikan mereka untuk mengatur. AWS IAM Identity Center Untuk informasi selengkapnya, lihat [Otentikasi SDK dengan AWS](getting-your-credentials.md).

Ada beberapa cara di Node.js untuk memasok kredensialmu ke SDK. Beberapa di antaranya lebih aman dan yang lain memberikan kenyamanan yang lebih besar saat mengembangkan aplikasi. Saat mendapatkan kredensi di Node.js, berhati-hatilah untuk mengandalkan lebih dari satu sumber, seperti variabel lingkungan dan file JSON yang Anda muat. Anda dapat mengubah izin di mana kode Anda berjalan tanpa menyadari perubahan telah terjadi.

AWS SDK untuk JavaScript V3 menyediakan rantai penyedia kredensi default di Node.js, sehingga Anda tidak diharuskan untuk menyediakan penyedia kredensi secara eksplisit. [Rantai penyedia kredensi](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html#credentialProviderChain) default mencoba menyelesaikan kredensi dari berbagai sumber berbeda dalam prioritas tertentu, hingga kredensi dikembalikan dari salah satu sumber. [Anda dapat menemukan rantai penyedia kredensi untuk SDK untuk JavaScript V3 di sini.](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/#fromnodeproviderchain)

## Rantai penyedia kredensi
<a name="credchain"></a>

Semua SDKs memiliki serangkaian tempat (atau sumber) yang mereka periksa untuk mendapatkan kredensi yang valid untuk digunakan untuk membuat permintaan ke sebuah. Layanan AWS Setelah kredensi yang valid ditemukan, pencarian dihentikan. Pencarian sistematis ini disebut rantai penyedia kredensi default. 

Untuk setiap langkah dalam rantai, ada berbagai cara untuk mengatur nilai. Menetapkan nilai secara langsung dalam kode selalu diutamakan, diikuti dengan pengaturan sebagai variabel lingkungan, dan kemudian di file bersama AWS `config`. Untuk informasi selengkapnya, lihat [Prioritas pengaturan di Panduan Referensi](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#precedenceOfSettings) *Alat AWS SDKs dan Alat*. 

*Panduan Referensi AWS SDKs dan Alat* memiliki informasi tentang pengaturan konfigurasi SDK yang digunakan oleh semua AWS SDKs dan. AWS CLI Untuk mempelajari lebih lanjut tentang cara mengonfigurasi SDK melalui AWS `config` file bersama, lihat File [konfigurasi dan kredensial bersama](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html). Untuk mempelajari lebih lanjut tentang cara mengonfigurasi SDK melalui pengaturan variabel lingkungan, lihat [Dukungan variabel lingkungan](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html).

Untuk mengautentikasi dengan AWS, AWS SDK untuk JavaScript memeriksa penyedia kredensi dalam urutan yang tercantum dalam tabel berikut.

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

Jika Anda mengikuti pendekatan yang disarankan bagi pengguna baru untuk memulai, Anda menyiapkan AWS IAM Identity Center [Otentikasi SDK dengan AWS](getting-your-credentials.md) autentikasi selama topik Memulai. Metode otentikasi lainnya berguna untuk situasi yang berbeda. Untuk menghindari risiko keamanan, kami sarankan untuk selalu menggunakan kredensi jangka pendek. Untuk prosedur metode otentikasi lainnya, lihat [Otentikasi dan akses di Panduan](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) *Referensi Alat AWS SDKs dan Alat*.

Topik di bagian ini menjelaskan cara memuat kredensi ke dalam Node.js.

**Topics**
+ [Rantai penyedia kredensi](#credchain)
+ [Memuat kredensi di Node.js dari peran IAM untuk Amazon EC2](loading-node-credentials-iam.md)
+ [Memuat kredensi untuk fungsi Lambda Node.js](loading-node-credentials-lambda.md)

# Memuat kredensi di Node.js dari peran IAM untuk Amazon EC2
<a name="loading-node-credentials-iam"></a>

Jika Anda menjalankan aplikasi Node.js di instans Amazon EC2, Anda dapat memanfaatkan peran IAM untuk Amazon EC2 agar secara otomatis memberikan kredensi ke instans. Jika Anda mengonfigurasi instans Anda untuk menggunakan peran IAM, SDK secara otomatis memilih kredenal IAM untuk aplikasi Anda, sehingga tidak perlu menyediakan kredenal secara manual.

Untuk informasi selengkapnya tentang menambahkan peran IAM ke instans Amazon EC2, [lihat peran IAM untuk Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) EC2.

# Memuat kredensi untuk fungsi Lambda Node.js
<a name="loading-node-credentials-lambda"></a>

Saat Anda membuat AWS Lambda fungsi, Anda harus membuat peran IAM khusus yang memiliki izin untuk menjalankan fungsi tersebut. Peran ini disebut *peran eksekusi*. Saat menyiapkan fungsi Lambda, Anda harus menentukan peran IAM yang Anda buat sebagai peran eksekusi yang sesuai.

Peran eksekusi menyediakan fungsi Lambda dengan kredenal yang dibutuhkan untuk menjalankan dan memanggil layanan web lainnya. Akibatnya, Anda tidak perlu memberikan kredensi ke kode Node.js yang Anda tulis dalam fungsi Lambda.

*Untuk informasi selengkapnya tentang membuat peran eksekusi Lambda, lihat [Mengelola izin: Menggunakan peran IAM (peran eksekusi)](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role) di Panduan Pengembang.AWS Lambda *

# Mengatur kredensi di browser web
<a name="setting-credentials-browser"></a>

Ada beberapa cara untuk memasok kredensional Anda ke SDK dari skrip browser. Beberapa di antaranya lebih aman dan yang lain memberikan kenyamanan yang lebih besar saat mengembangkan skrip.

 Berikut adalah cara-cara Anda dapat memberikan kredensi Anda, dalam urutan rekomendasi:

1. Menggunakan Identitas Amazon Cognito untuk mengautentikasi pengguna dan menyediakan kredensional

1. Menggunakan identitas federasi web

**Awas**  
Kami tidak menyarankan hard coding AWS kredensional Anda dalam skrip Anda. Kredensi pengkodean keras menimbulkan risiko mengekspos ID kunci akses dan kunci akses rahasia Anda.

**Topics**
+ [Menggunakan Identitas Amazon Cognito untuk mengautentikasi pengguna](loading-browser-credentials-cognito.md)

# Menggunakan Identitas Amazon Cognito untuk mengautentikasi pengguna
<a name="loading-browser-credentials-cognito"></a>

Cara yang disarankan untuk mendapatkan AWS kredensi untuk skrip browser Anda adalah dengan menggunakan klien kredensi Identitas Amazon Cognito. `CognitoIdentityClient` Amazon Cognito memungkinkan otentikasi pengguna melalui penyedia identitas pihak ketiga.

Untuk menggunakan Identitas Amazon Cognito, Anda harus terlebih dahulu membuat kumpulan identitas di konsol Amazon Cognito. Kumpulan identitas mewakili grup identitas yang disediakan aplikasi Anda kepada pengguna Anda. Identitas yang diberikan kepada pengguna secara unik mengidentifikasi setiap akun pengguna. Identitas Amazon Cognito identitas bukan kredensial. Mereka ditukar dengan kredensional menggunakan dukungan federasi identitas web di AWS Security Token Service ().AWS STS

Amazon Cognito membantu Anda mengelola abstraksi identitas di beberapa penyedia identitas. Identitas yang dimuat kemudian ditukar dengan kredensi di. AWS STS

## Konfigurasikan objek kredensial Identitas Amazon Cognito
<a name="browser-cognito-configuration"></a>

Jika Anda belum membuatnya, buat kumpulan identitas untuk digunakan dengan skrip browser Anda di konsol Amazon [Cognito sebelum Anda mengonfigurasi klien Amazon Cognito](https://console.aws.amazon.com/cognito) Anda. Buat dan kaitkan peran IAM yang diautentikasi dan tidak diautentikasi untuk kumpulan identitas Anda. Untuk informasi selengkapnya, lihat [Tutorial: Membuat kumpulan identitas](https://docs.aws.amazon.com/cognito/latest/developerguide/tutorial-create-identity-pool.html) di Panduan *Pengembang Amazon Cognito*.

Pengguna yang tidak diautentikasi tidak memverifikasi identitasnya, membuat peran ini sesuai untuk pengguna tamu aplikasi Anda atau jika tidak masalah jika pengguna telah memverifikasi identitasnya. Pengguna yang diautentikasi masuk ke aplikasi Anda melalui penyedia identitas pihak ketiga yang memverifikasi identitas mereka. Pastikan Anda menjangkau izin sumber daya dengan tepat sehingga Anda tidak memberikan akses kepada mereka dari pengguna yang tidak terautentikasi.

Setelah Anda mengonfigurasi kumpulan identitas, gunakan `fromCognitoIdentityPool` metode dari `@aws-sdk/credential-providers` untuk mengambil kredensional dari kumpulan identitas. Dalam contoh berikut membuat klien Amazon S3, ganti *AWS\$1REGION* dengan wilayah dan *IDENTITY\$1POOL\$1ID* dengan ID kumpulan identitas.

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

Properti opsional `logins` adalah peta nama penyedia identitas untuk token identitas bagi penyedia tersebut. Bagaimana Anda bisa mendapatkan token dari penyedia identitas Anda tergantung pada penyedia yang Anda gunakan. Misalnya, jika Anda menggunakan kumpulan pengguna Amazon Cognito sebagai penyedia otentikasi, Anda dapat menggunakan metode yang mirip dengan yang di bawah ini.

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

## Mengalihkan Pengguna yang Tidak Diautentikasi ke Pengguna yang Diautentikasi
<a name="browser-switching-unauthenticated-users"></a>

Amazon Cognito mendukung pengguna yang diautentikasi dan tidak diautentikasi. Pengguna yang tidak diautentikasi menerima akses ke sumber daya Anda meskipun mereka tidak masuk dengan penyedia identitas Anda. Tingkat akses ini berguna untuk menampilkan konten kepada pengguna sebelum masuk. Setiap pengguna yang tidak diautentikasi memiliki identitas unik di Amazon Cognito meskipun mereka belum masuk dan diautentikasi secara individual.

### Pengguna Awalnya Tidak Diautentikasi
<a name="browser-initially-unauthenticated-user"></a>

Pengguna biasanya memulai dengan peran yang tidak diautentikasi, di mana Anda menetapkan properti kredensial objek konfigurasi Anda tanpa properti. `logins` Dalam hal ini, kredensi default Anda mungkin terlihat seperti berikut:

```
// Import the required AWS SDK untuk 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.
});
```

### Beralih ke Pengguna Terautentikasi
<a name="switch-to-authenticated"></a>

Ketika pengguna yang tidak diautentikasi masuk ke penyedia identitas dan Anda memiliki token, Anda dapat mengalihkan pengguna dari yang tidak diautentikasi ke otentikasi dengan memanggil fungsi khusus yang memperbarui objek kredensional dan menambahkan token. `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;
}
```

# Pertimbangan Node.js
<a name="node-js-considerations"></a>

Meskipun kode Node.js adalah JavaScript, menggunakan AWS SDK untuk JavaScript dalam Node.js dapat berbeda dari menggunakan SDK dalam skrip browser. Beberapa metode API bekerja di Node.js tetapi tidak dalam skrip browser, serta sebaliknya. Dan berhasil menggunakan beberapa APIs tergantung pada keakraban Anda dengan pola pengkodean Node.js umum, seperti mengimpor dan menggunakan modul Node.js lainnya seperti modul. `File System (fs)`

**catatan**  
AWS merekomendasikan menggunakan versi Active LTS dari Node.js untuk pengembangan.

## Gunakan modul Node.js bawaan
<a name="node-common-modules"></a>

Node.js menyediakan koleksi modul bawaan yang dapat Anda gunakan tanpa menginstalnya. Untuk menggunakan modul ini, buat objek dengan `require` metode untuk menentukan nama modul. Misalnya, untuk menyertakan modul HTTP bawaan, gunakan yang berikut ini.

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

Memanggil metode modul seolah-olah mereka adalah metode dari objek itu. Misalnya, berikut adalah kode yang membaca file 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
  }
});
```

Untuk daftar lengkap semua modul bawaan yang disediakan Node.js, lihat [dokumentasi Node.js](https://nodejs.org/api/modules.html) di situs web Node.js.

## Gunakan paket npm
<a name="node-npm-packages"></a>

Selain modul bawaan, Anda juga dapat menyertakan dan menggabungkan kode pihak ketiga dari`npm`, manajer paket Node.js. Ini adalah repositori paket Node.js open source dan antarmuka baris perintah untuk menginstal paket-paket tersebut. Untuk informasi selengkapnya `npm` dan daftar paket yang tersedia saat ini, lihat [ https://www.npmjs.com](https://www.npmjs.com). Anda juga dapat mempelajari tentang paket Node.js tambahan yang dapat Anda gunakan [di sini GitHub](https://github.com/sindresorhus/awesome-nodejs).

# Konfigurasikan MaxSockets di Node.js
<a name="node-configuring-maxsockets"></a>

Di Node.js, Anda dapat mengatur jumlah maksimum koneksi per asal. Jika ` maxSockets` diatur, klien HTTP tingkat rendah mengantri permintaan dan menetapkannya ke soket saat tersedia.

Ini memungkinkan Anda menetapkan batas atas pada jumlah permintaan bersamaan ke asal tertentu pada suatu waktu. Menurunkan nilai ini dapat mengurangi jumlah kesalahan pelambatan atau batas waktu yang diterima. Namun, itu juga dapat meningkatkan penggunaan memori karena permintaan antri sampai soket tersedia.

Contoh berikut menunjukkan bagaimana mengatur `maxSockets` untuk klien DynamoDB.

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

SDK untuk JavaScript menggunakan `maxSockets` nilai 50 jika Anda tidak memberikan nilai atau `Agent` objek. Jika Anda menyediakan `Agent` objek, `maxSockets` nilainya akan digunakan. Untuk informasi selengkapnya tentang pengaturan `maxSockets` di Node.js, lihat [dokumentasi Node.js](https://nodejs.org/dist/latest/docs/api/http.html#http_agent_maxsockets).

Pada v3.521.0 dari AWS SDK untuk JavaScript, Anda dapat menggunakan sintaks [singkatan](https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md#new-in-v35210) berikut untuk mengkonfigurasi. `requestHandler`

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

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

# Gunakan kembali koneksi dengan keep-alive di Node.js
<a name="node-reusing-connections"></a>

 HTTP/HTTPS Agen Node.js default membuat koneksi TCP baru untuk setiap permintaan baru. *Untuk menghindari biaya membangun koneksi baru, AWS SDK untuk JavaScript menggunakan kembali koneksi TCP secara default.*

Untuk operasi jangka pendek, seperti kueri Amazon DynamoDB, overhead latensi pengaturan koneksi TCP mungkin lebih besar daripada operasi itu sendiri. Selain itu, karena [enkripsi DynamoDB saat](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html) istirahat terintegrasi [AWS KMS](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/encryption.howitworks.html), Anda mungkin mengalami latensi dari database yang harus membuat kembali entri cache AWS KMS baru untuk setiap operasi. 

Jika Anda tidak ingin menggunakan kembali koneksi TCP, Anda dapat menonaktifkan penggunaan kembali koneksi ini hidup dengan `keepAlive` basis klien per layanan seperti yang ditunjukkan dalam contoh berikut untuk klien DynamoDB.

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

Jika `keepAlive` diaktifkan, Anda juga dapat mengatur penundaan awal untuk paket TCP Keep-Alive`keepAliveMsecs`, yang secara default adalah 1000 ms. Lihat [dokumentasi Node.js](https://nodejs.org/api/http.html#new-agentoptions) untuk detailnya.

# Konfigurasikan proxy untuk Node.js
<a name="node-configuring-proxies"></a>

Jika Anda tidak dapat terhubung langsung ke internet, SDK untuk JavaScript mendukung penggunaan proxy HTTP atau HTTPS melalui agen HTTP pihak ketiga.

Untuk menemukan agen HTTP pihak ketiga, cari “HTTP proxy” di [npm](https://www.npmjs.com/).

Untuk menginstal proxy agen HTTP pihak ketiga, masukkan yang berikut ini di prompt perintah, di mana *PROXY* nama `npm` paket. 

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

Untuk menggunakan proxy dalam aplikasi Anda, gunakan ` httpsAgent` properti `httpAgent` and, seperti yang ditunjukkan pada contoh berikut untuk klien DynamoDB. 

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

**catatan**  
`httpAgent`tidak sama dengan`httpsAgent`, dan karena sebagian besar panggilan dari klien akan ke`https`, keduanya harus disetel.

# Daftarkan bundel sertifikat di Node.js
<a name="node-registering-certs"></a>

Penyimpanan kepercayaan default untuk Node.js menyertakan sertifikat yang diperlukan untuk mengakses AWS layanan. Dalam beberapa kasus, mungkin lebih baik untuk menyertakan hanya satu set sertifikat tertentu.

Dalam contoh ini, sertifikat khusus pada disk digunakan untuk membuat ` https.Agent` yang menolak koneksi kecuali sertifikat yang ditunjuk disediakan. Yang baru dibuat kemudian `https.Agent` digunakan oleh klien 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
  })
});
```

# Pertimbangan Skrip Browser
<a name="browser-js-considerations"></a>

Topik berikut menjelaskan pertimbangan khusus untuk menggunakan skrip AWS SDK untuk JavaScript di browser.

**Topics**
+ [Membangun SDK untuk Browser](building-sdk-for-browsers.md)
+ [Cross-origin resource sharing (CORS)](cors.md)
+ [Bundel aplikasi dengan webpack](webpack.md)

# Membangun SDK untuk Browser
<a name="building-sdk-for-browsers"></a>

Tidak seperti SDK untuk JavaScript versi 2 (V2), V3 tidak disediakan sebagai JavaScript file dengan dukungan yang disertakan untuk serangkaian layanan default. Sebagai gantinya, V3 memungkinkan Anda untuk menggabungkan dan menyertakan di browser hanya SDK untuk JavaScript file yang Anda butuhkan, mengurangi overhead. Sebaiknya gunakan Webpack untuk menggabungkan SDK yang diperlukan untuk JavaScript file, dan paket pihak ketiga tambahan yang Anda butuhkan, ke dalam satu `Javascript` file, dan memuatnya ke dalam skrip browser menggunakan tag. `<script>` Untuk informasi selengkapnya tentang Webpack, lihat[Bundel aplikasi dengan webpack](webpack.md). 

Jika Anda bekerja dengan SDK di luar lingkungan yang memberlakukan CORS di browser Anda dan jika Anda ingin akses ke semua layanan yang disediakan oleh SDK for JavaScript, Anda dapat membuat salinan khusus SDK secara lokal dengan mengkloning repositori dan menjalankan alat build yang sama yang membangun versi default SDK yang dihosting. Bagian berikut menjelaskan langkah-langkah untuk membangun SDK dengan layanan tambahan dan versi API.

## Menggunakan SDK Builder untuk membangun SDK untuk JavaScript
<a name="using-the-sdk-builder"></a>

**catatan**  
Amazon Web Services versi 3 (V3) tidak lagi mendukung Browser Builder. Untuk meminimalkan penggunaan bandwidth aplikasi browser, kami sarankan Anda mengimpor modul bernama, dan bundel mereka untuk mengurangi ukuran. Untuk informasi selengkapnya tentang bundling, lihat[Bundel aplikasi dengan webpack](webpack.md).

# Cross-origin resource sharing (CORS)
<a name="cors"></a>

Berbagi sumber daya lintas asal, atau CORS, adalah fitur keamanan browser web modern. Ini memungkinkan browser web untuk menegosiasikan domain mana yang dapat membuat permintaan situs web atau layanan eksternal. 

CORS adalah pertimbangan penting ketika mengembangkan aplikasi browser dengan AWS SDK untuk JavaScript karena sebagian besar permintaan ke sumber daya dikirim ke domain eksternal, seperti titik akhir untuk layanan web. Jika JavaScript lingkungan Anda memberlakukan keamanan CORS, Anda harus mengonfigurasi CORS dengan layanan.

CORS menentukan apakah akan mengizinkan pembagian sumber daya dalam permintaan lintas asal berdasarkan hal berikut:
+ Domain spesifik yang membuat permintaan 
+ Jenis permintaan HTTP yang dibuat (GET, PUT, POST, DELETE dan sebagainya)

## Bagaimana CORS bekerja
<a name="how-cors-works"></a>

Dalam kasus yang paling sederhana, skrip browser Anda membuat permintaan GET untuk sumber daya dari server di domain lain. Bergantung pada konfigurasi CORS server tersebut, jika permintaan berasal dari domain yang berwenang untuk mengirimkan permintaan GET, server lintas asal merespons dengan mengembalikan sumber daya yang diminta.

Jika domain yang meminta atau jenis permintaan HTTP tidak diotorisasi, permintaan ditolak. Namun, CORS memungkinkan untuk melakukan pra-penerbangan permintaan sebelum benar-benar mengirimkannya. Dalam hal ini, permintaan preflight dibuat di mana operasi permintaan `OPTIONS` akses dikirim. Jika konfigurasi CORS server lintas asal memberikan akses ke domain yang meminta, server mengirimkan kembali respons preflight yang mencantumkan semua jenis permintaan HTTP yang dapat dibuat oleh domain permintaan pada sumber daya yang diminta.

![\[Alur proses untuk permintaan CORS\]](http://docs.aws.amazon.com/id_id/sdk-for-javascript/v3/developer-guide/images/cors-overview.png)


## Apakah konfigurasi CORS diperlukan?
<a name="the-need-for-cors-configuration"></a>

Bucket Amazon S3 memerlukan konfigurasi CORS sebelum Anda dapat melakukan operasi pada mereka. Di beberapa JavaScript lingkungan CORS mungkin tidak diberlakukan dan oleh karena itu mengonfigurasi CORS tidak diperlukan. Misalnya, jika Anda meng-host aplikasi dari bucket Amazon S3 dan mengakses sumber daya dari `*.s3.amazonaws.com` atau titik akhir tertentu lainnya, permintaan Anda tidak akan mengakses domain eksternal. Oleh karena itu, konfigurasi ini tidak memerlukan CORS. Dalam hal ini, CORS masih digunakan untuk layanan selain Amazon S3.

## Konfigurasikan CORS untuk bucket Amazon S3
<a name="configuring-cors-s3-bucket"></a>

Anda dapat mengonfigurasi bucket Amazon S3 untuk menggunakan CORS di konsol Amazon S3.

Jika Anda mengonfigurasi CORS di Konsol Manajemen Layanan AWS Web, Anda harus menggunakan JSON untuk membuat konfigurasi CORS. Konsol Manajemen Layanan AWS Web baru hanya mendukung konfigurasi JSON CORS. 

**penting**  
Di Konsol Manajemen Layanan AWS Web yang baru, konfigurasi CORS harus JSON.

1. Di Konsol Manajemen Layanan AWS Web, buka konsol Amazon S3, temukan bucket yang ingin Anda konfigurasi dan pilih kotak centang.

1. Di panel yang terbuka, pilih **Izin**.

1. Pada tab **Izin**, pilih **Konfigurasi CORS**.

1. **Masukkan konfigurasi CORS Anda di **CORS Configuration Editor**, lalu pilih Simpan.**

Konfigurasi CORS adalah file XMLyang berisi serangkaian aturan dalam file. `<CORSRule>` Konfigurasi dapat memiliki hingga 100 aturan. Aturan didefinisikan oleh salah satu tag berikut:
+ `<AllowedOrigin>`— Menentukan asal domain yang Anda izinkan untuk membuat permintaan lintas domain.
+ `<AllowedMethod>`— Menentukan jenis permintaan yang Anda izinkan (GET, PUT, POST, DELETE, HEAD) dalam permintaan lintas domain.
+ `<AllowedHeader>`— Menentukan header diperbolehkan dalam permintaan preflight.

Misalnya konfigurasi, lihat [Bagaimana cara mengonfigurasi CORS di bucket saya?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/cors.html#how-do-i-enable-cors) di *Panduan Pengguna Layanan Penyimpanan Sederhana Amazon*.

## Contoh konfigurasi CORS
<a name="cors-configuration-example"></a>

Contoh konfigurasi CORS berikut memungkinkan pengguna untuk melihat, menambah, menghapus, atau memperbarui objek di dalam bucket dari domain`example.org`. Namun, kami menyarankan Anda `<AllowedOrigin>` untuk menjangkau domain situs web Anda. Anda dapat menentukan `"*"` untuk mengizinkan asal apa pun.

**penting**  
Pada konsol S3 baru, konfigurasi CORS harus 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"]
    }
]
```

------

Konfigurasi ini tidak mengizinkan pengguna untuk melakukan tindakan pada bucket. Ini memungkinkan model keamanan browser untuk memungkinkan permintaan ke Amazon S3. Izin harus dikonfigurasi melalui izin bucket atau izin peran IAM.

Anda dapat menggunakan `ExposeHeader` untuk membiarkan SDK membaca header respons yang dikembalikan dari Amazon S3. Misalnya, membaca `ETag` header dari upload `PUT` atau multipart, Anda perlu menyertakan `ExposeHeader` tag dalam konfigurasi Anda, seperti yang ditunjukkan pada contoh sebelumnya. SDK hanya dapat mengakses header yang diekspos melalui konfigurasi CORS. Jika Anda mengatur metadata pada objek, nilai dikembalikan sebagai header dengan awalan`x-amz-meta-`, seperti`x-amz-meta-my-custom-header`, dan juga harus diekspos dengan cara yang sama.

# Bundel aplikasi dengan webpack
<a name="webpack"></a>

Penggunaan modul kode oleh aplikasi web dalam skrip browser atau Node.js menciptakan dependensi. Modul kode ini dapat memiliki dependensi sendiri, menghasilkan kumpulan modul yang saling berhubungan yang dibutuhkan aplikasi Anda untuk berfungsi. Untuk mengelola dependensi, Anda dapat menggunakan bundler modul seperti. `webpack`

`webpack`Modul bundler mem-parsing kode aplikasi Anda, mencari `import` atau `require` pernyataan, untuk membuat bundel yang berisi semua aset yang dibutuhkan aplikasi Anda. Ini agar aset dapat dengan mudah dilayani melalui halaman web. SDK for JavaScript dapat dimasukkan `webpack` sebagai salah satu dependensi untuk disertakan dalam bundel keluaran.

Untuk informasi selengkapnya`webpack`, lihat [bundler modul webpack](https://webpack.github.io/) aktif. GitHub

## Instal webpack
<a name="webpack-installing"></a>

Untuk menginstal bundler `webpack` modul, Anda harus menginstal npm, manajer paket Node.js terlebih dahulu. Ketik perintah berikut untuk menginstal `webpack` CLI dan JavaScript modul.

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

Untuk menggunakan `path` modul untuk bekerja dengan jalur file dan direktori, yang diinstal secara otomatis dengan webpack, Anda mungkin perlu menginstal `path-browserify` paket Node.js. 

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

## Konfigurasikan webpack
<a name="webpack-configuring"></a>

Secara default, Webpack mencari JavaScript file bernama `webpack.config.js` di direktori root proyek Anda. File ini menentukan opsi konfigurasi Anda. Berikut ini adalah contoh file `webpack.config.js` konfigurasi untuk WebPack versi 5.0.0 dan yang lebih baru.

**catatan**  
Persyaratan konfigurasi webpack bervariasi tergantung pada versi Webpack yang Anda instal. Untuk informasi selengkapnya, lihat [dokumentasi Webpack](https://webpack.js.org/configuration/). 

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

Dalam contoh ini, `browser.js` ditentukan sebagai *titik masuk*. *Titik masuk* adalah file yang `webpack` digunakan untuk mulai mencari modul yang diimpor. Nama file output ditentukan sebagai`bundle.js`. File output ini akan berisi semua aplikasi JavaScript yang perlu dijalankan. Jika kode yang ditentukan di titik masuk mengimpor atau memerlukan modul lain, seperti SDK for JavaScript, kode tersebut dibundel tanpa perlu menentukannya dalam konfigurasi.

## Jalankan webpack
<a name="webpack-running"></a>

Untuk membangun aplikasi yang akan digunakan`webpack`, tambahkan berikut ini ke `scripts` objek dalam `package.json` file Anda.

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

Berikut ini adalah contoh `package.json` file yang menunjukkan penambahan`webpack`.

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

Untuk membangun aplikasi Anda, masukkan perintah berikut.

```
npm run build
```

`webpack`Modul bundler kemudian menghasilkan JavaScript file yang Anda tentukan di direktori root proyek Anda.

## Gunakan bundel webpack
<a name="webpack-using-bundle"></a>

Untuk menggunakan bundel dalam skrip browser, Anda dapat menggabungkan bundel menggunakan `<script>` tag, seperti yang ditunjukkan pada contoh berikut.

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

## Bundel untuk Node.js
<a name="webpack-nodejs-bundles"></a>

Anda dapat menggunakan `webpack` untuk menghasilkan bundel yang berjalan di Node.js dengan menentukan `node` sebagai target dalam konfigurasi.

```
target: "node"
```

Ini berguna saat menjalankan aplikasi Node.js di lingkungan di mana ruang disk terbatas. Berikut adalah contoh `webpack.config.js` konfigurasi dengan Node.js ditentukan sebagai target output.

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