AWS SDK untuk JavaScript V2 telah mencapai end-of-support. Kami menyarankan Anda bermigrasi ke [AWS SDK untuk JavaScript v3](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/). Untuk detail dan informasi tambahan tentang cara bermigrasi, silakan lihat [pengumuman](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/) ini.
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Bekerja dengan Layanan di SDK untuk JavaScript
AWS SDK untuk JavaScript Menyediakan akses ke layanan yang didukungnya melalui kumpulan kelas klien. Dari kelas klien ini, Anda membuat objek antarmuka layanan, yang biasa disebut *objek layanan*. Setiap AWS layanan yang didukung memiliki satu atau lebih kelas klien yang menawarkan tingkat rendah APIs untuk menggunakan fitur dan sumber daya layanan. Misalnya, Amazon APIs DynamoDB tersedia melalui kelas. `AWS.DynamoDB`
Layanan yang diekspos melalui SDK untuk JavaScript mengikuti pola permintaan-respons untuk bertukar pesan dengan aplikasi panggilan. Dalam pola ini, kode yang memanggil layanan mengirimkan HTTP/HTTPS permintaan ke titik akhir untuk layanan. Permintaan berisi parameter yang diperlukan untuk berhasil memanggil fitur tertentu yang dipanggil. Layanan yang dipanggil menghasilkan respons yang dikirim kembali ke pemohon. Respons berisi data jika operasi berhasil atau informasi kesalahan jika operasi tidak berhasil.
![\[Pola layanan respon AWS permintaan.\]](http://docs.aws.amazon.com/id_id/sdk-for-javascript/v2/developer-guide/images/request-response.png)
Memanggil AWS layanan mencakup siklus hidup permintaan dan respons penuh operasi pada objek layanan, termasuk percobaan ulang apa pun yang dicoba. Permintaan dienkapsulasi dalam SDK oleh objek. `AWS.Request` Respons dienkapsulasi dalam SDK oleh `AWS.Response` objek, yang diberikan kepada pemohon melalui salah satu dari beberapa teknik, seperti fungsi panggilan balik atau janji. JavaScript
**Topics**
+ [Membuat dan Memanggil Objek Layanan](creating-and-calling-service-objects.md)
+ [AWS SDK untuk JavaScript Panggilan Pencatatan](logging-sdk-calls.md)
+ [Layanan Panggilan Secara Asinkron](calling-services-asynchronously.md)
+ [Menggunakan Response Object](the-response-object.md)
+ [Bekerja dengan JSON](working-with-json.md)
+ [Coba lagi strategi di v2 AWS SDK untuk JavaScript](retry-strategy.md)
# Membuat dan Memanggil Objek Layanan
JavaScript API mendukung sebagian besar AWS layanan yang tersedia. Setiap kelas layanan di JavaScript API menyediakan akses ke setiap panggilan API dalam layanannya. Untuk informasi selengkapnya tentang kelas layanan, operasi, dan parameter di JavaScript API, lihat [referensi API](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/index.html).
Saat menggunakan SDK di Node.js, Anda menambahkan paket SDK ke aplikasi Anda menggunakan`require`, yang menyediakan dukungan untuk semua layanan saat ini.
```
var AWS = require('aws-sdk');
```
Saat menggunakan SDK dengan browser JavaScript, Anda memuat paket SDK ke skrip browser menggunakan paket SDK yang dihosting AWS. Untuk memuat paket SDK, tambahkan `
```
[Untuk menemukan SDK\$1VERSION\$1NUMBER saat ini, lihat Referensi API untuk SDK untuk Panduan Referensi API. JavaScript AWS SDK untuk JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/)
Paket SDK yang di-host default menyediakan dukungan untuk subset dari layanan yang tersedia AWS . Untuk daftar layanan default dalam paket SDK yang dihosting untuk browser, lihat [Layanan yang Didukung](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/#Supported_Services) di Referensi API. Anda dapat menggunakan SDK dengan layanan lain jika pemeriksaan keamanan CORS dinonaktifkan. Dalam hal ini, Anda dapat membuat versi kustom SDK untuk menyertakan layanan tambahan yang Anda butuhkan. Untuk informasi selengkapnya tentang membuat versi kustom SDK, lihat[Membangun SDK untuk Browser](building-sdk-for-browsers.md).
## Membutuhkan Layanan Individu
Memerlukan SDK untuk JavaScript seperti yang ditunjukkan sebelumnya menyertakan seluruh SDK ke dalam kode Anda. Sebagai alternatif, Anda dapat memilih untuk hanya meminta layanan individual yang digunakan oleh kode Anda. Pertimbangkan kode berikut yang digunakan untuk membuat objek layanan Amazon S3.
```
// Import the AWS SDK
var AWS = require('aws-sdk');
// Set credentials and Region
// This can also be done directly on the service client
AWS.config.update({region: 'us-west-1', credentials: {YOUR_CREDENTIALS}});
var s3 = new AWS.S3({apiVersion: '2006-03-01'});
```
Pada contoh sebelumnya, `require` fungsi menentukan seluruh SDK. Jumlah kode untuk diangkut melalui jaringan serta overhead memori kode Anda akan jauh lebih kecil jika hanya bagian SDK yang Anda butuhkan untuk layanan Amazon S3 yang disertakan. Untuk memerlukan layanan individual, panggil `require` fungsi seperti yang ditunjukkan, termasuk konstruktor layanan dalam semua huruf kecil.
```
require('aws-sdk/clients/SERVICE');
```
Berikut adalah kode untuk membuat objek layanan Amazon S3 sebelumnya ketika hanya menyertakan bagian Amazon S3 dari SDK.
```
// Import the Amazon S3 service client
var S3 = require('aws-sdk/clients/s3');
// Set credentials and Region
var s3 = new S3({
apiVersion: '2006-03-01',
region: 'us-west-1',
credentials: {YOUR_CREDENTIALS}
});
```
Anda masih dapat mengakses AWS namespace global tanpa setiap layanan yang melekat padanya.
```
require('aws-sdk/global');
```
Ini adalah teknik yang berguna ketika menerapkan konfigurasi yang sama di beberapa layanan individual, misalnya untuk memberikan kredensyal yang sama untuk semua layanan. Membutuhkan layanan individual harus mengurangi waktu pemuatan dan konsumsi memori di Node.js. Ketika dilakukan bersama dengan alat bundling seperti Browserify atau webpack, memerlukan layanan individual menghasilkan SDK menjadi sebagian kecil dari ukuran penuh. Ini membantu dengan memori atau lingkungan terbatas ruang disk seperti perangkat IoT atau dalam fungsi Lambda.
## Membuat Objek Layanan
Untuk mengakses fitur layanan melalui JavaScript API, pertama-tama Anda membuat *objek layanan* yang digunakan untuk mengakses serangkaian fitur yang disediakan oleh kelas klien yang mendasarinya. Umumnya ada satu kelas klien yang disediakan untuk setiap layanan; Namun, beberapa layanan membagi akses ke fitur mereka di antara beberapa kelas klien.
Untuk menggunakan fitur, Anda harus membuat instance kelas yang menyediakan akses ke fitur tersebut. Contoh berikut menunjukkan membuat objek layanan untuk DynamoDB dari `AWS.DynamoDB` kelas klien.
```
var dynamodb = new AWS.DynamoDB({apiVersion: '2012-08-10'});
```
Secara default, objek layanan dikonfigurasi dengan pengaturan global yang juga digunakan untuk mengkonfigurasi SDK. Namun, Anda dapat mengonfigurasi objek layanan dengan data konfigurasi runtime yang spesifik untuk objek layanan tersebut. Data konfigurasi khusus layanan diterapkan setelah menerapkan pengaturan konfigurasi global.
Dalam contoh berikut, objek layanan Amazon EC2 dibuat dengan konfigurasi untuk Wilayah tertentu tetapi menggunakan konfigurasi global.
```
var ec2 = new AWS.EC2({region: 'us-west-2', apiVersion: '2014-10-01'});
```
Selain mendukung konfigurasi khusus layanan yang diterapkan ke objek layanan individual, Anda juga dapat menerapkan konfigurasi khusus layanan ke semua objek layanan yang baru dibuat dari kelas tertentu. Misalnya, untuk mengonfigurasi semua objek layanan yang dibuat dari kelas Amazon EC2 untuk menggunakan Wilayah AS Barat (Oregon) (`us-west-2`), tambahkan berikut ini ke objek konfigurasi `AWS.config` global.
```
AWS.config.ec2 = {region: 'us-west-2', apiVersion: '2016-04-01'};
```
## Mengunci Versi API dari Objek Layanan
Anda dapat mengunci objek layanan ke versi API tertentu dari layanan dengan menentukan `apiVersion` opsi saat membuat objek. Dalam contoh berikut, objek layanan DynamoDB dibuat yang dikunci ke versi API tertentu.
```
var dynamodb = new AWS.DynamoDB({apiVersion: '2011-12-05'});
```
Untuk informasi selengkapnya tentang mengunci versi API dari objek layanan, lihat[Mengunci Versi API](locking-api-versions.md).
## Menentukan Parameter Objek Layanan
Saat memanggil metode objek layanan, berikan parameter di JSON seperti yang dipersyaratkan oleh API. Misalnya, di Amazon S3, untuk mendapatkan objek untuk bucket dan kunci tertentu, teruskan parameter berikut ke metode. `getObject` Untuk informasi selengkapnya tentang meneruskan parameter JSON, lihat[Bekerja dengan JSON](working-with-json.md).
```
s3.getObject({Bucket: 'bucketName', Key: 'keyName'});
```
Untuk informasi selengkapnya tentang parameter Amazon S3, lihat [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html)di referensi API.
Selain itu, Anda dapat mengikat nilai ke parameter individual saat membuat objek layanan menggunakan `params` parameter. Nilai `params` parameter objek layanan adalah peta yang menentukan satu atau lebih nilai parameter yang ditentukan oleh objek layanan. Contoh berikut menunjukkan `Bucket` parameter objek layanan Amazon S3 yang terikat ke bucket bernama. `amzn-s3-demo-bucket`
```
var s3bucket = new AWS.S3({params: {Bucket: 'amzn-s3-demo-bucket'}, apiVersion: '2006-03-01' });
```
Dengan mengikat objek layanan ke bucket, objek `s3bucket` layanan memperlakukan nilai `amzn-s3-demo-bucket` parameter sebagai nilai default yang tidak lagi perlu ditentukan untuk operasi selanjutnya. Setiap nilai parameter terikat diabaikan saat menggunakan objek untuk operasi di mana nilai parameter tidak berlaku. Anda dapat mengganti parameter terikat ini saat melakukan panggilan pada objek layanan dengan menentukan nilai baru.
```
var s3bucket = new AWS.S3({ params: {Bucket: 'amzn-s3-demo-bucket'}, apiVersion: '2006-03-01' });
s3bucket.getObject({Key: 'keyName'});
// ...
s3bucket.getObject({Bucket: 'amzn-s3-demo-bucket3', Key: 'keyOtherName'});
```
Detail tentang parameter yang tersedia untuk setiap metode dapat ditemukan di referensi API.
# AWS SDK untuk JavaScript Panggilan Pencatatan
AWS SDK untuk JavaScript Ini diinstrumentasi dengan logger bawaan sehingga Anda dapat mencatat panggilan API yang Anda buat dengan SDK untuk. JavaScript
Untuk mengaktifkan logger dan mencetak entri log di konsol, tambahkan pernyataan berikut ke kode Anda.
```
AWS.config.logger = console;
```
Berikut adalah contoh dari output log.
```
[AWS s3 200 0.185s 0 retries] createMultipartUpload({ Bucket: 'amzn-s3-demo-logging-bucket', Key: 'issues_1704' })
```
## Menggunakan Logger Pihak Ketiga
Anda juga dapat menggunakan logger pihak ketiga, asalkan memiliki `log()` atau `write()` operasi untuk menulis ke file log atau server. Anda harus menginstal dan mengatur logger kustom Anda seperti yang diinstruksikan sebelum Anda dapat menggunakannya dengan SDK for. JavaScript
Salah satu logger yang dapat Anda gunakan di skrip browser atau di Node.js adalah logplease. Di Node.js, Anda dapat mengkonfigurasi logplease untuk menulis entri log ke file log. Anda juga dapat menggunakannya dengan webpack.
Saat menggunakan logger pihak ketiga, setel semua opsi sebelum menetapkan logger ke. `AWS.Config.logger` Misalnya, berikut ini menentukan file log eksternal dan menetapkan tingkat log untuk logplease
```
// Require AWS Node.js SDK
const AWS = require('aws-sdk')
// Require logplease
const logplease = require('logplease');
// Set external log file option
logplease.setLogfile('debug.log');
// Set log level
logplease.setLogLevel('DEBUG');
// Create logger
const logger = logplease.create('logger name');
// Assign logger to SDK
AWS.config.logger = logger;
```
Untuk informasi lebih lanjut tentang logplease, lihat [logplease Simple JavaScript Logger](https://github.com/haadcode/logplease) on. GitHub
# Layanan Panggilan Secara Asinkron
Semua permintaan yang dibuat melalui SDK bersifat asinkron. Ini penting untuk diingat saat menulis skrip browser. JavaScript berjalan di browser web biasanya hanya memiliki satu thread eksekusi. Setelah melakukan panggilan asinkron ke AWS layanan, skrip browser terus berjalan dan dalam proses dapat mencoba mengeksekusi kode yang bergantung pada hasil asinkron sebelum kembali.
Membuat panggilan asinkron ke AWS layanan termasuk mengelola panggilan tersebut sehingga kode Anda tidak mencoba menggunakan data sebelum data tersedia. Topik di bagian ini menjelaskan perlunya mengelola panggilan asinkron dan merinci berbagai teknik yang dapat Anda gunakan untuk mengelolanya.
**Topics**
+ [Mengelola Panggilan Asinkron](making-asynchronous-calls.md)
+ [Menggunakan Fungsi Callback Anonim](using-a-callback-function.md)
+ [Menggunakan Request Object Event Listener](using-a-response-event-handler.md)
+ [Menggunakan async/await](using-async-await.md)
+ [Menggunakan JavaScript Janji](using-promises.md)
# Mengelola Panggilan Asinkron
Misalnya, halaman beranda situs web e-commerce memungkinkan pelanggan yang kembali masuk. Bagian dari manfaat bagi pelanggan yang masuk adalah bahwa, setelah masuk, situs kemudian menyesuaikan diri dengan preferensi khusus mereka. Untuk membuat ini terjadi:
1. Pelanggan harus masuk dan divalidasi dengan kredensi masuk mereka.
1. Preferensi pelanggan diminta dari database pelanggan.
1. Basis data menyediakan preferensi pelanggan yang digunakan untuk menyesuaikan situs sebelum halaman dimuat.
Jika tugas-tugas ini dijalankan secara serempak, maka masing-masing harus selesai sebelum tugas berikutnya dapat dimulai. Halaman web tidak akan dapat menyelesaikan pemuatan sampai preferensi pelanggan kembali dari database. Namun, setelah kueri database dikirim ke server, penerimaan data pelanggan dapat ditunda atau bahkan gagal karena kemacetan jaringan, lalu lintas basis data yang sangat tinggi, atau koneksi perangkat seluler yang buruk.
Agar situs web tidak membeku dalam kondisi tersebut, hubungi database secara tidak sinkron. Setelah panggilan database dijalankan, mengirimkan permintaan asinkron Anda, kode Anda terus dijalankan seperti yang diharapkan. Jika Anda tidak mengelola respons panggilan asinkron dengan benar, kode Anda dapat mencoba menggunakan informasi yang diharapkan kembali dari database ketika data tersebut belum tersedia.
![\[Menampilkan perbedaan antara eksekusi sinkron dan asinkron.\]](http://docs.aws.amazon.com/id_id/sdk-for-javascript/v2/developer-guide/images/async-vs-sync.png)
# Menggunakan Fungsi Callback Anonim
Setiap metode objek layanan yang membuat `AWS.Request` objek dapat menerima fungsi callback anonim sebagai parameter terakhir. Tanda tangan dari fungsi callback ini adalah:
```
function(error, data) {
// callback handling code
}
```
Fungsi callback ini dijalankan ketika respon berhasil atau data kesalahan kembali. Jika pemanggilan metode berhasil, isi respons tersedia untuk fungsi callback dalam parameter. `data` Jika panggilan tidak berhasil, detail tentang kegagalan disediakan dalam `error` parameter.
Biasanya kode di dalam fungsi callback menguji kesalahan, yang diproses jika dikembalikan. Jika kesalahan tidak dikembalikan, kode kemudian mengambil data dalam respons dari `data` parameter. Bentuk dasar dari fungsi callback terlihat seperti contoh ini.
```
function(error, data) {
if (error) {
// error handling code
console.log(error);
} else {
// data handling code
console.log(data);
}
}
```
Pada contoh sebelumnya, detail kesalahan atau data yang dikembalikan dicatat ke konsol. Berikut adalah contoh yang menunjukkan fungsi callback diteruskan sebagai bagian dari memanggil metode pada objek layanan.
```
new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(function(error, data) {
if (error) {
console.log(error); // an error occurred
} else {
console.log(data); // request succeeded
}
});
```
## Mengakses Objek Permintaan dan Respons
Dalam fungsi callback, JavaScript kata kunci `this` mengacu pada `AWS.Response` objek yang mendasari untuk sebagian besar layanan. Dalam contoh berikut, `httpResponse` properti `AWS.Response` objek digunakan dalam fungsi callback untuk mencatat data respons mentah dan header untuk membantu debugging.
```
new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(function(error, data) {
if (error) {
console.log(error); // an error occurred
// Using this keyword to access AWS.Response object and properties
console.log("Response data and headers: " + JSON.stringify(this.httpResponse));
} else {
console.log(data); // request succeeded
}
});
```
Selain itu, karena `AWS.Response` objek memiliki `Request` properti yang berisi `AWS.Request` yang dikirim oleh panggilan metode asli, Anda juga dapat mengakses detail permintaan yang dibuat.
# Menggunakan Request Object Event Listener
Jika Anda tidak membuat dan meneruskan fungsi callback anonim sebagai parameter saat Anda memanggil metode objek layanan, panggilan metode menghasilkan `AWS.Request` objek yang harus dikirim secara manual menggunakan `send` metodenya.
Untuk memproses respons, Anda harus membuat event listener untuk `AWS.Request` objek untuk mendaftarkan fungsi callback untuk panggilan metode. Contoh berikut menunjukkan cara membuat `AWS.Request` objek untuk memanggil metode objek layanan dan pendengar acara untuk pengembalian yang berhasil.
```
// create the AWS.Request object
var request = new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances();
// register a callback event handler
request.on('success', function(response) {
// log the successful data response
console.log(response.data);
});
// send the request
request.send();
```
Setelah `send` metode pada `AWS.Request` objek dipanggil, event handler mengeksekusi ketika objek layanan menerima objek`AWS.Response`.
Untuk informasi selengkapnya tentang `AWS.Request` objek, lihat [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)di Referensi API. Untuk informasi selengkapnya tentang `AWS.Response` objek, lihat [Menggunakan Response Object](the-response-object.md) atau [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html)di Referensi API.
## Merantai Beberapa Panggilan Balik
Anda dapat mendaftarkan beberapa callback pada objek permintaan apa pun. Beberapa panggilan balik dapat didaftarkan untuk acara yang berbeda atau acara yang sama. Selain itu, Anda dapat menghubungkan callback seperti yang ditunjukkan pada contoh berikut.
```
request.
on('success', function(response) {
console.log("Success!");
}).
on('error', function(response) {
console.log("Error!");
}).
on('complete', function() {
console.log("Always!");
}).
send();
```
## Permintaan Acara Penyelesaian Objek
`AWS.Request`Objek memunculkan peristiwa penyelesaian ini berdasarkan respons dari setiap metode operasi layanan:
+ `success`
+ `error`
+ `complete`
Anda dapat mendaftarkan fungsi callback sebagai respons terhadap salah satu peristiwa ini. Untuk daftar lengkap semua peristiwa objek permintaan, lihat [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)di Referensi API.
### Acara Sukses
`success`Acara ini diangkat setelah respons yang berhasil diterima dari objek layanan. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('success', function(response) {
// event handler code
});
```
Respons menyediakan `data` properti yang berisi data respons serial dari layanan. Misalnya, panggilan berikut ke `listBuckets` metode objek layanan Amazon S3
```
s3.listBuckets.on('success', function(response) {
console.log(response.data);
}).send();
```
mengembalikan respon dan kemudian mencetak konten `data` properti berikut ke konsol.
```
{ Owner: { ID: '...', DisplayName: '...' },
Buckets:
[ { Name: 'someBucketName', CreationDate: someCreationDate },
{ Name: 'otherBucketName', CreationDate: otherCreationDate } ],
RequestId: '...' }
```
### Peristiwa kesalahan
`error`Acara ini dimunculkan pada respons kesalahan yang diterima dari objek layanan. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('error', function(error, response) {
// event handling code
});
```
Ketika `error` acara dinaikkan, nilai `data` properti respon adalah `null` dan `error` properti berisi data kesalahan. `error`Objek terkait diteruskan sebagai parameter pertama ke fungsi callback terdaftar. Misalnya, kode berikut:
```
s3.config.credentials.accessKeyId = 'invalid';
s3.listBuckets().on('error', function(error, response) {
console.log(error);
}).send();
```
mengembalikan kesalahan dan kemudian mencetak data kesalahan berikut ke konsol.
```
{ code: 'Forbidden', message: null }
```
### Acara Lengkap
`complete`Acara dimunculkan ketika panggilan objek layanan telah selesai, terlepas dari apakah panggilan tersebut menghasilkan keberhasilan atau kesalahan. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('complete', function(response) {
// event handler code
});
```
Gunakan callback `complete` acara untuk menangani pembersihan permintaan apa pun yang harus dijalankan terlepas dari keberhasilan atau kesalahan. Jika Anda menggunakan data respons di dalam callback untuk `complete` acara tersebut, periksa dulu `response.error` properti `response.data` atau sebelum mencoba mengakses salah satu, seperti yang ditunjukkan pada contoh berikut.
```
request.on('complete', function(response) {
if (response.error) {
// an error occurred, handle it
} else {
// we can use response.data here
}
}).send();
```
## Permintaan Objek Acara HTTP
`AWS.Request`Objek memunculkan peristiwa HTTP ini berdasarkan respons dari setiap metode operasi layanan:
+ `httpHeaders`
+ `httpData`
+ `httpUploadProgress`
+ `httpDownloadProgress`
+ `httpError`
+ `httpDone`
Anda dapat mendaftarkan fungsi callback sebagai respons terhadap salah satu peristiwa ini. Untuk daftar lengkap semua peristiwa objek permintaan, lihat [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)di Referensi API.
### Acara HttpHeaders
`httpHeaders`Acara ini dinaikkan ketika header dikirim oleh server jarak jauh. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpHeaders', function(statusCode, headers, response) {
// event handling code
});
```
`statusCode`Parameter untuk fungsi callback adalah kode status HTTP. `headers`Parameter berisi header respons.
### Acara HttpData
`httpData`Acara ini dinaikkan untuk mengalirkan paket data respons dari layanan. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpData', function(chunk, response) {
// event handling code
});
```
Acara ini biasanya digunakan untuk menerima respons besar dalam potongan saat memuat seluruh respons ke dalam memori tidak praktis. Acara ini memiliki `chunk` parameter tambahan yang berisi sebagian data aktual dari server.
Jika Anda mendaftarkan callback untuk `httpData` acara tersebut, `data` properti respons berisi seluruh keluaran serial untuk permintaan tersebut. Anda harus menghapus `httpData` pendengar default jika Anda tidak memiliki parsing tambahan dan overhead memori untuk penangan bawaan.
### httpUploadProgress dan httpDownloadProgress Peristiwa
`httpUploadProgress`Acara ini muncul ketika permintaan HTTP telah mengunggah lebih banyak data. Demikian pula, `httpDownloadProgress` acara dinaikkan ketika permintaan HTTP telah mengunduh lebih banyak data. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpUploadProgress', function(progress, response) {
// event handling code
})
.on('httpDownloadProgress', function(progress, response) {
// event handling code
});
```
`progress`Parameter ke fungsi callback berisi objek dengan byte yang dimuat dan total permintaan.
### Acara HttpError
`httpError`Acara dimunculkan ketika permintaan HTTP gagal. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpError', function(error, response) {
// event handling code
});
```
`error`Parameter ke fungsi callback berisi kesalahan yang dilemparkan.
### Acara HttpDone
`httpDone`Acara ini dinaikkan ketika server selesai mengirim data. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpDone', function(response) {
// event handling code
});
```
# Menggunakan async/await
Anda dapat menggunakan `async/await` pola dalam panggilan Anda ke file AWS SDK untuk JavaScript. Sebagian besar fungsi yang mengambil panggilan balik tidak mengembalikan janji. Karena Anda hanya menggunakan `await` fungsi yang mengembalikan janji, untuk menggunakan `async/await` pola Anda perlu menghubungkan `.promise()` metode ke akhir panggilan Anda, dan menghapus panggilan balik.
Contoh berikut digunakan async/await untuk mencantumkan semua tabel Amazon DynamoDB Anda di. `us-west-2`
```
var AWS = require("aws-sdk");
//Create an Amazon DynamoDB client service object.
dbClient = new AWS.DynamoDB({ region: "us-west-2" });
// Call DynamoDB to list existing tables
const run = async () => {
try {
const results = await dbClient.listTables({}).promise();
console.log(results.TableNames.join("\n"));
} catch (err) {
console.error(err);
}
};
run();
```
**catatan**
Tidak semua browser mendukung async/await. Lihat [Fungsi async](https://caniuse.com/#feat=async-functions) untuk daftar browser dengan async/await dukungan.
# Menggunakan JavaScript Janji
`AWS.Request.promise`Metode ini menyediakan cara untuk memanggil operasi layanan dan mengelola aliran asinkron alih-alih menggunakan callback. Dalam Node.js dan skrip browser, `AWS.Request` objek dikembalikan ketika operasi layanan dipanggil tanpa fungsi callback. Anda dapat memanggil `send` metode permintaan untuk melakukan panggilan layanan.
Namun, `AWS.Request.promise` segera mulai panggilan layanan dan mengembalikan janji yang dipenuhi dengan `data` properti respons atau ditolak dengan `error` properti respons.
```
var request = new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances();
// create the promise object
var promise = request.promise();
// handle promise's fulfilled/rejected states
promise.then(
function(data) {
/* process the data */
},
function(error) {
/* handle the error */
}
);
```
Contoh berikutnya mengembalikan janji yang dipenuhi dengan `data` objek, atau ditolak dengan `error` objek. Menggunakan janji, satu panggilan balik tidak bertanggung jawab untuk mendeteksi kesalahan. Sebagai gantinya, callback yang benar dipanggil berdasarkan keberhasilan atau kegagalan permintaan.
```
var s3 = new AWS.S3({apiVersion: '2006-03-01', region: 'us-west-2'});
var params = {
Bucket: 'bucket',
Key: 'example2.txt',
Body: 'Uploaded text using the promise-based method!'
};
var putObjectPromise = s3.putObject(params).promise();
putObjectPromise.then(function(data) {
console.log('Success');
}).catch(function(err) {
console.log(err);
});
```
## Koordinasi Beberapa Janji
Dalam beberapa situasi, kode Anda harus membuat beberapa panggilan asinkron yang memerlukan tindakan hanya jika semuanya berhasil dikembalikan. Jika Anda mengelola panggilan metode asinkron individual tersebut dengan janji, Anda dapat membuat janji tambahan yang menggunakan metode ini. `all` Metode ini memenuhi janji payung ini jika dan ketika berbagai janji yang Anda berikan ke metode terpenuhi. Fungsi callback dilewatkan sebuah array dari nilai-nilai dari janji-janji yang diteruskan ke `all` metode.
Dalam contoh berikut, AWS Lambda fungsi harus membuat tiga panggilan asinkron ke Amazon DynamoDB tetapi hanya dapat diselesaikan setelah janji untuk setiap panggilan terpenuhi.
```
Promise.all([firstPromise, secondPromise, thirdPromise]).then(function(values) {
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 the result to the caller of the Lambda function
callback(null, values);
});
```
## Browser dan Node.js Support for Promises
Support for native JavaScript promises (ECMAScript 2015) tergantung pada JavaScript mesin dan versi di mana kode Anda dijalankan. Untuk membantu menentukan dukungan untuk JavaScript janji di setiap lingkungan tempat kode Anda perlu dijalankan, lihat [Tabel ECMAScript Kompatibilitas](https://compat-table.github.io/compat-table/es6/) di. GitHub
## Menggunakan Implementasi Janji Lainnya
Selain implementasi janji asli pada tahun ECMAScript 2015, Anda juga dapat menggunakan pustaka janji pihak ketiga, termasuk:
+ [burung biru](http://bluebirdjs.com)
+ [RSVP](https://github.com/tildeio/rsvp.js/)
+ [Q](https://github.com/kriskowal/q)
Pustaka janji opsional ini dapat berguna jika Anda memerlukan kode Anda untuk berjalan di lingkungan yang tidak mendukung implementasi janji asli di ECMAScript 5 dan ECMAScript 2015.
Untuk menggunakan pustaka janji pihak ketiga, tetapkan dependensi janji pada SDK dengan memanggil `setPromisesDependency` metode objek konfigurasi global. Dalam skrip browser, pastikan untuk memuat pustaka janji pihak ketiga sebelum memuat SDK. Dalam contoh berikut, SDK dikonfigurasi untuk menggunakan implementasi di pustaka janji bluebird.
```
AWS.config.setPromisesDependency(require('bluebird'));
```
Untuk kembali menggunakan implementasi janji asli JavaScript mesin, panggil `setPromisesDependency` lagi, berikan nama `null` alih-alih perpustakaan.
# Menggunakan Response Object
Setelah metode objek layanan dipanggil, ia mengembalikan `AWS.Response` objek dengan meneruskannya ke fungsi callback Anda. Anda mengakses konten respons melalui properti `AWS.Response` objek. Ada dua properti `AWS.Response` objek yang Anda gunakan untuk mengakses isi respons:
+ `data`properti
+ `error`properti
Saat menggunakan mekanisme callback standar, kedua properti ini disediakan sebagai parameter pada fungsi callback anonim seperti yang ditunjukkan pada contoh berikut.
```
function(error, data) {
if (error) {
// error handling code
console.log(error);
} else {
// data handling code
console.log(data);
}
}
```
## Mengakses Data yang Dikembalikan di Objek Response
`data`Properti `AWS.Response` objek berisi data serial yang dikembalikan oleh permintaan layanan. Ketika permintaan berhasil, `data` properti berisi objek yang berisi peta ke data yang dikembalikan. `data`Properti bisa null jika terjadi kesalahan.
Berikut adalah contoh memanggil `getItem` metode tabel DynamoDB untuk mengambil nama file file gambar untuk digunakan sebagai bagian dari permainan.
```
// Initialize parameters needed to call DynamoDB
var slotParams = {
Key : {'slotPosition' : {N: '0'}},
TableName : 'slotWheels',
ProjectionExpression: 'imageFile'
};
// prepare request object for call to DynamoDB
var request = new AWS.DynamoDB({region: 'us-west-2', apiVersion: '2012-08-10'}).getItem(slotParams);
// log the name of the image file to load in the slot machine
request.on('success', function(response) {
// logs a value like "cherries.jpg" returned from DynamoDB
console.log(response.data.Item.imageFile.S);
});
// submit DynamoDB request
request.send();
```
Untuk contoh ini, tabel DynamoDB adalah pencarian gambar yang menunjukkan hasil tarikan mesin slot seperti yang ditentukan oleh parameter di. `slotParams`
Setelah panggilan berhasil dari `getItem` metode, `data` properti `AWS.Response` objek berisi `Item` objek dikembalikan oleh DynamoDB. Data yang dikembalikan diakses sesuai dengan `ProjectionExpression` parameter permintaan, yang dalam hal ini berarti `imageFile` anggota `Item` objek. Karena `imageFile` anggota memegang nilai string, Anda mengakses nama file dari gambar itu sendiri melalui nilai anggota `S` anak dari`imageFile`.
## Paging Melalui Data yang Dikembalikan
Terkadang konten `data` properti yang dikembalikan oleh permintaan layanan menjangkau beberapa halaman. Anda dapat mengakses halaman data berikutnya dengan memanggil `response.nextPage` metode. Metode ini mengirimkan permintaan baru. Respons dari permintaan dapat ditangkap baik dengan callback atau dengan sukses dan pendengar kesalahan.
Anda dapat memeriksa untuk melihat apakah data yang dikembalikan oleh permintaan layanan memiliki halaman data tambahan dengan memanggil `response.hasNextPage` metode. Metode ini mengembalikan boolean untuk menunjukkan apakah panggilan `response.nextPage` mengembalikan data tambahan.
```
s3.listObjects({Bucket: 'bucket'}).on('success', function handlePage(response) {
// do something with response.data
if (response.hasNextPage()) {
response.nextPage().on('success', handlePage).send();
}
}).send();
```
## Mengakses Informasi Kesalahan dari Objek Respons
`error`Properti `AWS.Response` objek berisi data kesalahan yang tersedia jika terjadi kesalahan layanan atau kesalahan transfer. Kesalahan yang dikembalikan mengambil formulir berikut.
```
{ code: 'SHORT_UNIQUE_ERROR_CODE', message: 'a descriptive error message' }
```
Dalam kasus kesalahan, nilai `data` properti adalah`null`. Jika Anda menangani peristiwa yang dapat berada dalam status kegagalan, selalu periksa apakah `error` properti telah disetel sebelum mencoba mengakses nilai `data` properti.
## Mengakses Objek Permintaan Asal
`request`Properti menyediakan akses ke `AWS.Request` objek yang berasal. Hal ini dapat berguna untuk merujuk ke `AWS.Request` objek asli untuk mengakses parameter asli yang dikirim. Dalam contoh berikut, `request` properti digunakan untuk mengakses `Key` parameter permintaan layanan asli.
```
s3.getObject({Bucket: 'bucket', Key: 'key'}).on('success', function(response) {
console.log("Key was", response.request.params.Key);
}).send();
```
# Bekerja dengan JSON
JSON adalah format untuk pertukaran data yang dapat dibaca manusia dan mesin. Sementara nama JSON adalah akronim dari *JavaScript Object Notation*, format JSON tidak tergantung pada bahasa pemrograman apa pun.
SDK untuk JavaScript menggunakan JSON untuk mengirim data ke objek layanan saat membuat permintaan dan menerima data dari objek layanan sebagai JSON. Untuk informasi lebih lanjut tentang JSON, lihat [json.org](https://json.org).
![\[Menampilkan format umum dan bagian dari JSON.\]](http://docs.aws.amazon.com/id_id/sdk-for-javascript/v2/developer-guide/images/json-format.png)
JSON mewakili data dalam dua cara:
+ *Objek*, yang merupakan kumpulan pasangan nilai nama yang tidak dipesan. Sebuah objek didefinisikan dalam kurung kurung kiri (`{`) dan kanan (`}`). Setiap pasangan nilai dimulai dengan nama, diikuti dengan titik dua, diikuti dengan nilai. Pasangan nama-nilai dipisahkan koma.
+ Sebuah *rangkaian*, yang merupakan kumpulan nilai yang dipesan. Array didefinisikan dalam tanda kurung kiri (`[`) dan kanan (`]`). Item dalam array dipisahkan koma.
Berikut adalah contoh objek JSON yang berisi array objek di mana objek mewakili kartu dalam permainan kartu. Setiap kartu didefinisikan oleh dua pasangan nama-nilai, satu yang menentukan nilai unik untuk mengidentifikasi kartu itu dan satu lagi yang menentukan URL yang menunjuk ke gambar kartu yang sesuai.
```
var cards = [{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"},
{"CardID":"defaultname", "Image":"defaulturl"}];
```
## JSON sebagai Parameter Objek Layanan
Berikut adalah contoh JSON sederhana yang digunakan untuk menentukan parameter panggilan ke objek layanan Lambda.
```
var pullParams = {
FunctionName : 'slotPull',
InvocationType : 'RequestResponse',
LogType : 'None'
};
```
`pullParams`Objek didefinisikan oleh tiga pasangan nama-nilai, dipisahkan oleh koma di dalam kurung kiri dan kanan. Saat memberikan parameter ke panggilan metode objek layanan, nama ditentukan oleh nama parameter untuk metode objek layanan yang Anda rencanakan untuk dipanggil. Saat menjalankan fungsi Lambda`FunctionName`,,`InvocationType`, `LogType` dan merupakan parameter yang digunakan untuk memanggil metode `invoke` pada objek layanan Lambda.
Saat meneruskan parameter ke panggilan metode objek layanan, berikan objek JSON ke panggilan metode, seperti yang ditunjukkan pada contoh berikut untuk menjalankan fungsi Lambda.
```
lambda = new AWS.Lambda({region: 'us-west-2', apiVersion: '2015-03-31'});
// create JSON object for service call parameters
var pullParams = {
FunctionName : 'slotPull',
InvocationType : 'RequestResponse',
LogType : 'None'
};
// invoke Lambda function, passing JSON object
lambda.invoke(pullParams, function(err, data) {
if (err) {
console.log(err);
} else {
console.log(data);
}
});
```
## Mengembalikan Data sebagai JSON
JSON menyediakan cara standar untuk meneruskan data antar bagian aplikasi yang perlu mengirim beberapa nilai secara bersamaan. Metode kelas klien di API biasanya mengembalikan JSON dalam `data` parameter yang diteruskan ke fungsi callback mereka. Misalnya, berikut adalah panggilan ke `getBucketCors` metode kelas klien Amazon S3.
```
// call S3 to retrieve CORS configuration for selected bucket
s3.getBucketCors(bucketParams, function(err, data) {
if (err) {
console.log(err);
} else if (data) {
console.log(JSON.stringify(data));
}
});
```
Nilai `data` adalah objek JSON, dalam contoh ini JSON yang menjelaskan konfigurasi CORS saat ini untuk bucket Amazon S3 yang ditentukan.
```
{
"CORSRules": [
{
"AllowedHeaders":["*"],
"AllowedMethods":["POST","GET","PUT","DELETE","HEAD"],
"AllowedOrigins":["*"],
"ExposeHeaders":[],
"MaxAgeSeconds":3000
}
]
}
```
# Coba lagi strategi di v2 AWS SDK untuk JavaScript
Banyak komponen di jaringan, seperti server DNS, sakelar, penyeimbang beban, dan lainnya dapat menghasilkan kesalahan di mana pun selama permintaan tertentu. Teknik biasa untuk menangani respons kesalahan ini dalam lingkungan jaringan adalah dengan menerapkan percobaan ulang dalam aplikasi klien. Teknik ini meningkatkan keandalan aplikasi dan mengurangi biaya operasional bagi pengembang. AWS SDKs menerapkan logika coba ulang otomatis untuk AWS permintaan Anda.
## Perilaku coba lagi berbasis backoff eksponensial
AWS SDK untuk JavaScript v2 mengimplementasikan logika coba lagi menggunakan [backoff eksponensial dengan jitter penuh](https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/#Jitter) untuk kontrol aliran yang lebih baik. Ide di balik backoff eksponensial adalah menggunakan waktu tunggu yang semakin lama antara percobaan ulang untuk respons kesalahan yang berurutan. Jitter (penundaan acak) digunakan untuk mencegah tabrakan berturut-turut.
### Menguji coba lagi penundaan di v2
Untuk menguji penundaan coba lagi di v2, kode di [node\$1 modules/aws-sdk/lib/event \$1listeners.js](https://github.com/aws/aws-sdk-js/blob/master/lib/event_listeners.js#L588) diperbarui ke `console.log` nilai yang ada dalam penundaan variabel sebagai berikut:
```
// delay < 0 is a signal from customBackoff to skip retries
if (willRetry && delay >= 0) {
resp.error = null;
console.log('retry delay: ' + delay);
setTimeout(done, delay);
} else {
done();
}
```
#### Coba lagi penundaan dengan konfigurasi default
Anda dapat menguji penundaan untuk operasi apa pun pada klien AWS SDK. Kami memanggil `listTables` operasi pada klien DynamoDB menggunakan kode berikut:
```
import AWS from "aws-sdk";
const region = "us-east-1";
const client = new AWS.DynamoDB({ region });
await client.listTables({}).promise();
```
Untuk menguji percobaan ulang, kami mensimulasikan `NetworkingError` dengan memutuskan koneksi internet dari perangkat yang menjalankan kode pengujian. Anda juga dapat mengatur proxy untuk mengembalikan Kesalahan kustom.
Saat menjalankan kode, Anda dapat melihat bahwa coba lagi penundaan menggunakan backoff eksponensial dengan jitter sebagai berikut:
```
retry delay: 7.39361151766359
retry delay: 9.0672860785882
retry delay: 134.89340825668168
retry delay: 398.53559817403965
retry delay: 523.8076165896343
retry delay: 1323.8789643058465
```
Karena coba lagi menggunakan jitter, Anda akan mendapatkan nilai yang berbeda dalam menjalankan kode contoh.
#### Coba lagi penundaan dengan basis kustom
AWS SDK untuk JavaScript V2 memungkinkan melewatkan jumlah basis khusus milidetik untuk digunakan dalam backoff eksponensial untuk percobaan ulang operasi. Defaultnya 100 ms untuk semua layanan kecuali DynamoDB, di mana defaultnya 50 ms.
Kami menguji coba ulang dengan basis khusus 1000 ms sebagai berikut:
```
...
const client = new AWS.DynamoDB({ region, retryDelayOptions: { base: 1000 } });
...
```
Kami mensimulasikan `NetworkingError` dengan memutuskan koneksi internet dari perangkat yang menjalankan kode pengujian. Anda dapat melihat bahwa nilai untuk penundaan coba lagi lebih tinggi dibandingkan dengan proses sebelumnya di mana defaultnya adalah 50 atau 100 ms.
```
retry delay: 356.2841549924913
retry delay: 1183.5216495444615
retry delay: 2266.997988094194
retry delay: 1244.6948354966453
retry delay: 4200.323030066383
```
Karena coba lagi menggunakan jitter, Anda akan mendapatkan nilai yang berbeda dalam menjalankan kode contoh.
#### Coba lagi penundaan dengan algoritma backoff khusus
AWS SDK untuk JavaScript V2 juga memungkinkan meneruskan fungsi backoff khusus yang menerima hitungan coba lagi dan kesalahan dan mengembalikan jumlah waktu untuk menunda dalam milidetik. Jika hasilnya adalah nilai negatif bukan nol, tidak ada upaya coba lagi yang akan dilakukan.
Kami menguji fungsi backoff khusus yang menggunakan backoff linier dengan nilai dasar 200 ms sebagai berikut:
```
...
const client = new AWS.DynamoDB({
region,
retryDelayOptions: { customBackoff: (count, error) => (count + 1) * 200 },
});
...
```
Kami mensimulasikan `NetworkingError` dengan memutuskan koneksi internet dari perangkat yang menjalankan kode pengujian. Anda dapat melihat bahwa nilai untuk penundaan coba lagi adalah kelipatan 200.
```
retry delay: 200
retry delay: 400
retry delay: 600
retry delay: 800
retry delay: 1000
```