Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan operasi batch DynamoDB di AWS AppSync
AWS AppSync mendukung penggunaan operasi batch Amazon DynamoDB di satu atau beberapa tabel dalam satu Wilayah. Operasi yang didukung adalah`BatchGetItem`,`BatchPutItem`, dan`BatchDeleteItem`. Dengan menggunakan fitur-fitur ini di AWS AppSync, Anda dapat melakukan tugas-tugas seperti:
+ Melewati daftar kunci dalam satu kueri dan mengembalikan hasil dari tabel
+ Membaca catatan dari satu atau beberapa tabel dalam satu kueri
+ Menulis catatan secara massal ke satu atau lebih tabel
+ Menulis atau menghapus catatan secara kondisional dalam beberapa tabel yang mungkin memiliki hubungan
Operasi Batch AWS AppSync memiliki dua perbedaan utama dari operasi non-batch:
+ Peran sumber data harus memiliki izin ke semua tabel yang akan diakses oleh resolver.
+ Spesifikasi tabel untuk resolver adalah bagian dari objek permintaan.
## Batch tabel tunggal
**Awas**
`BatchPutItem`dan `BatchDeleteItem` tidak didukung saat digunakan dengan deteksi dan resolusi konflik. Pengaturan ini harus dinonaktifkan untuk mencegah kemungkinan kesalahan.
Untuk memulai, mari buat GraphQL API baru. Di AWS AppSync konsol, pilih **Create API**, ** APIsGraphQL**, **dan** Design dari awal. **Beri nama API Anda`BatchTutorial API`, pilih **Berikutnya**, dan pada langkah **Tentukan sumber daya GraphQL**, pilih **Buat sumber daya GraphQL** nanti dan klik Berikutnya.** Tinjau detail Anda dan buat API. Pergi ke halaman **Skema** dan tempel skema berikut, perhatikan bahwa untuk kueri, kami akan meneruskan daftar: IDs
```
type Post {
id: ID!
title: String
}
input PostInput {
id: ID!
title: String
}
type Query {
batchGet(ids: [ID]): [Post]
}
type Mutation {
batchAdd(posts: [PostInput]): [Post]
batchDelete(ids: [ID]): [Post]
}
```
Simpan skema Anda dan pilih **Buat Sumber Daya** di bagian atas halaman. Pilih **Gunakan tipe yang ada** dan pilih `Post` jenisnya. Beri nama meja Anda`Posts`. **Pastikan **Primary Key** diatur ke`id`, batalkan pilihan **Automatically generate GraphQL** (Anda akan memberikan kode Anda sendiri), dan pilih Create.** Untuk memulai, AWS AppSync buat tabel DynamoDB baru dan sumber data yang terhubung ke tabel dengan peran yang sesuai. Namun, masih ada beberapa izin yang perlu Anda tambahkan ke peran tersebut. Buka halaman **Sumber data** dan pilih sumber data baru. Di bawah **Pilih peran yang ada**, Anda akan melihat bahwa peran dibuat secara otomatis untuk tabel. Perhatikan peran (akan terlihat seperti`appsync-ds-ddb-aaabbbcccddd-Posts`) dan kemudian pergi ke konsol IAM ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)). Di konsol IAM, pilih **Peran**, lalu pilih peran Anda dari tabel. Dalam peran Anda, di bawah **Kebijakan izin**, klik "`+`" di sebelah kebijakan (harus memiliki nama yang mirip dengan nama peran). Pilih **Edit** di bagian atas yang dapat dilipat saat kebijakan muncul. Anda perlu menambahkan izin batch ke kebijakan Anda, khususnya `dynamodb:BatchGetItem` dan`dynamodb:BatchWriteItem`. Ini akan terlihat seperti ini:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem",
"dynamodb:BatchGetItem"
],
"Resource": [
"arn:aws:dynamodb:us-east-1:111122223333:table/locationReadings",
"arn:aws:dynamodb:us-east-1:111122223333:table/locationReadings/*",
"arn:aws:dynamodb:us-east-1:111122223333:table/temperatureReadings",
"arn:aws:dynamodb:us-east-1:111122223333:table/temperatureReadings/*"
]
}
]
}
```
------
Pilih **Berikutnya**, lalu **Simpan perubahan**. Kebijakan Anda harus mengizinkan pemrosesan batch sekarang.
Kembali ke AWS AppSync konsol, buka halaman **Skema** dan pilih **Lampirkan** di sebelah `Mutation.batchAdd` bidang. Buat resolver Anda menggunakan `Posts` tabel sebagai sumber data. Di editor kode, ganti handler dengan cuplikan di bawah ini. Cuplikan ini secara otomatis mengambil setiap item dalam `input PostInput` tipe GraphQL dan membuat peta, yang diperlukan untuk operasi: `BatchPutItem`
```
import { util } from "@aws-appsync/utils";
export function request(ctx) {
return {
operation: "BatchPutItem",
tables: {
Posts: ctx.args.posts.map((post) => util.dynamodb.toMapValues(post)),
},
};
}
export function response(ctx) {
if (ctx.error) {
util.error(ctx.error.message, ctx.error.type);
}
return ctx.result.data.Posts;
}
```
Arahkan ke halaman **Kueri** AWS AppSync konsol dan jalankan `batchAdd` mutasi berikut:
```
mutation add {
batchAdd(posts:[{
id: 1 title: "Running in the Park"},{
id: 2 title: "Playing fetch"
}]){
id
title
}
}
```
Anda akan melihat hasil yang dicetak di layar; ini dapat divalidasi dengan meninjau konsol DynamoDB untuk memindai nilai yang ditulis ke tabel. `Posts`
Selanjutnya, ulangi proses melampirkan resolver tetapi untuk `Query.batchGet` bidang menggunakan `Posts` tabel sebagai sumber data. Ganti handler dengan kode di bawah ini. Ini secara otomatis mengambil setiap item dalam tipe `ids:[]` GraphQL dan membangun peta yang diperlukan untuk operasi: `BatchGetItem`
```
import { util } from "@aws-appsync/utils";
export function request(ctx) {
return {
operation: "BatchGetItem",
tables: {
Posts: {
keys: ctx.args.ids.map((id) => util.dynamodb.toMapValues({ id })),
consistentRead: true,
},
},
};
}
export function response(ctx) {
if (ctx.error) {
util.error(ctx.error.message, ctx.error.type);
}
return ctx.result.data.Posts;
}
```
Sekarang, kembali ke halaman **Queries** AWS AppSync konsol dan jalankan `batchGet` kueri berikut:
```
query get {
batchGet(ids:[1,2,3]){
id
title
}
}
```
Ini akan mengembalikan hasil untuk dua `id` nilai yang Anda tambahkan sebelumnya. Perhatikan bahwa `null` nilai dikembalikan untuk `id` dengan nilai`3`. Ini karena belum ada catatan di `Posts` tabel Anda dengan nilai itu. Perhatikan juga bahwa AWS AppSync mengembalikan hasil dalam urutan yang sama dengan kunci yang diteruskan ke kueri, yang merupakan fitur tambahan yang AWS AppSync berkinerja atas nama Anda. Jadi, jika Anda beralih ke`batchGet(ids:[1,3,2])`, Anda akan melihat bahwa pesanan berubah. Anda juga akan tahu mana yang `id` mengembalikan `null` nilai.
Terakhir, lampirkan satu resolver lagi ke `Mutation.batchDelete` bidang menggunakan `Posts` tabel sebagai sumber data. Ganti handler dengan kode di bawah ini. Ini secara otomatis mengambil setiap item dalam tipe `ids:[]` GraphQL dan membangun peta yang diperlukan untuk operasi: `BatchGetItem`
```
import { util } from "@aws-appsync/utils";
export function request(ctx) {
return {
operation: "BatchDeleteItem",
tables: {
Posts: ctx.args.ids.map((id) => util.dynamodb.toMapValues({ id })),
},
};
}
export function response(ctx) {
if (ctx.error) {
util.error(ctx.error.message, ctx.error.type);
}
return ctx.result.data.Posts;
}
```
Sekarang, kembali ke halaman **Queries** AWS AppSync konsol dan jalankan `batchDelete` mutasi berikut:
```
mutation delete {
batchDelete(ids:[1,2]){ id }
}
```
Catatan dengan `id` `1` dan sekarang `2` harus dihapus. Jika Anda menjalankan kembali `batchGet()` kueri dari sebelumnya, ini akan kembali`null`.
## Batch multi-tabel
**Awas**
`BatchPutItem`dan `BatchDeleteItem` tidak didukung saat digunakan dengan deteksi dan resolusi konflik. Pengaturan ini harus dinonaktifkan untuk mencegah kemungkinan kesalahan.
AWS AppSync juga memungkinkan Anda untuk melakukan operasi batch di seluruh tabel. Mari kita membangun aplikasi yang lebih kompleks. Bayangkan kita sedang membangun aplikasi kesehatan hewan peliharaan di mana sensor melaporkan lokasi dan suhu tubuh hewan peliharaan. Sensor bertenaga baterai dan mencoba terhubung ke jaringan setiap beberapa menit. Ketika sensor membuat koneksi, ia mengirimkan bacaannya ke AWS AppSync API kami. Pemicu kemudian menganalisis data sehingga dasbor dapat disajikan kepada pemilik hewan peliharaan. Mari kita fokus pada merepresentasikan interaksi antara sensor dan penyimpanan data backend.
Di AWS AppSync konsol, pilih **Create API**, ** APIsGraphQL**, **dan** Design dari awal. **Beri nama API Anda`MultiBatchTutorial API`, pilih **Berikutnya**, dan pada langkah **Tentukan sumber daya GraphQL**, pilih **Buat sumber daya GraphQL** nanti dan klik Berikutnya.** Tinjau detail Anda dan buat API. Buka halaman **Skema** dan tempel dan simpan skema berikut:
```
type Mutation {
# Register a batch of readings
recordReadings(tempReadings: [TemperatureReadingInput], locReadings: [LocationReadingInput]): RecordResult
# Delete a batch of readings
deleteReadings(tempReadings: [TemperatureReadingInput], locReadings: [LocationReadingInput]): RecordResult
}
type Query {
# Retrieve all possible readings recorded by a sensor at a specific time
getReadings(sensorId: ID!, timestamp: String!): [SensorReading]
}
type RecordResult {
temperatureReadings: [TemperatureReading]
locationReadings: [LocationReading]
}
interface SensorReading {
sensorId: ID!
timestamp: String!
}
# Sensor reading representing the sensor temperature (in Fahrenheit)
type TemperatureReading implements SensorReading {
sensorId: ID!
timestamp: String!
value: Float
}
# Sensor reading representing the sensor location (lat,long)
type LocationReading implements SensorReading {
sensorId: ID!
timestamp: String!
lat: Float
long: Float
}
input TemperatureReadingInput {
sensorId: ID!
timestamp: String
value: Float
}
input LocationReadingInput {
sensorId: ID!
timestamp: String
lat: Float
long: Float
}
```
Kita perlu membuat dua tabel DynamoDB:
+ `locationReadings`akan menyimpan pembacaan lokasi sensor.
+ `temperatureReadings`akan menyimpan pembacaan suhu sensor.
Kedua tabel akan berbagi struktur kunci primer yang sama: `sensorId (String)` sebagai kunci partisi dan `timestamp (String)` sebagai kunci sortir.
Pilih **Buat Sumber Daya** di bagian atas halaman. Pilih **Gunakan tipe yang ada** dan pilih `locationReadings` jenisnya. Beri nama meja Anda`locationReadings`. Pastikan **Primary Key** diatur ke `sensorId` dan tombol sortir ke`timestamp`. **Hapus pilihan **Secara otomatis menghasilkan** GraphQL (Anda akan memberikan kode Anda sendiri), dan pilih Buat.** Ulangi proses ini untuk `temperatureReadings` menggunakan `temperatureReadings` sebagai tipe dan nama tabel. Gunakan tombol yang sama seperti di atas.
Tabel baru Anda akan berisi peran yang dihasilkan secara otomatis. Masih ada beberapa izin yang perlu Anda tambahkan ke peran tersebut. Buka halaman **Sumber data** dan pilih`locationReadings`. Di bawah **Pilih peran yang ada**, Anda dapat melihat peran tersebut. Perhatikan peran (akan terlihat seperti`appsync-ds-ddb-aaabbbcccddd-locationReadings`) dan kemudian pergi ke konsol IAM ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)). Di konsol IAM, pilih **Peran**, lalu pilih peran Anda dari tabel. Dalam peran Anda, di bawah **Kebijakan izin**, klik "`+`" di sebelah kebijakan (harus memiliki nama yang mirip dengan nama peran). Pilih **Edit** di bagian atas yang dapat dilipat saat kebijakan muncul. Anda perlu menambahkan izin ke kebijakan ini. Ini akan terlihat seperti ini:
Pilih **Berikutnya**, lalu **Simpan perubahan**. Ulangi proses ini untuk sumber `temperatureReadings` data menggunakan cuplikan kebijakan yang sama di atas.
### BatchPutItem - Merekam pembacaan sensor
Sensor kami harus dapat mengirim bacaan mereka setelah mereka terhubung ke internet. `Mutation.recordReadings`Bidang GraphQL adalah API yang akan mereka gunakan untuk melakukannya. Kita perlu menambahkan resolver ke bidang ini.
Di halaman **Skema AWS AppSync ** konsol, pilih **Lampirkan** di sebelah `Mutation.recordReadings` bidang. Pada layar berikutnya, buat resolver Anda menggunakan `locationReadings` tabel sebagai sumber data.
Setelah membuat resolver Anda, ganti handler dengan kode berikut di editor. `BatchPutItem`Operasi ini memungkinkan kita untuk menentukan beberapa tabel:
```
import { util } from '@aws-appsync/utils'
export function request(ctx) {
const { locReadings, tempReadings } = ctx.args
const locationReadings = locReadings.map((loc) => util.dynamodb.toMapValues(loc))
const temperatureReadings = tempReadings.map((tmp) => util.dynamodb.toMapValues(tmp))
return {
operation: 'BatchPutItem',
tables: {
locationReadings,
temperatureReadings,
},
}
}
export function response(ctx) {
if (ctx.error) {
util.appendError(ctx.error.message, ctx.error.type)
}
return ctx.result.data
}
```
Dengan operasi batch, mungkin ada kesalahan dan hasil yang dikembalikan dari pemanggilan. Dalam hal ini, kami bebas melakukan beberapa penanganan kesalahan tambahan.
**catatan**
`utils.appendError()`Penggunaannya mirip dengan`util.error()`, dengan perbedaan utama bahwa itu tidak mengganggu evaluasi permintaan atau penangan respons. Sebaliknya, ini menandakan ada kesalahan dengan bidang tetapi memungkinkan penangan untuk dievaluasi dan akibatnya mengembalikan data kembali ke pemanggil. Kami menyarankan Anda menggunakan `utils.appendError()` ketika aplikasi Anda perlu mengembalikan sebagian hasil.
Simpan resolver dan navigasikan ke halaman **Kueri** di konsol. AWS AppSync Kami sekarang dapat mengirim beberapa pembacaan sensor.
Jalankan mutasi berikut:
```
mutation sendReadings {
recordReadings(
tempReadings: [
{sensorId: 1, value: 85.5, timestamp: "2018-02-01T17:21:05.000+08:00"},
{sensorId: 1, value: 85.7, timestamp: "2018-02-01T17:21:06.000+08:00"},
{sensorId: 1, value: 85.8, timestamp: "2018-02-01T17:21:07.000+08:00"},
{sensorId: 1, value: 84.2, timestamp: "2018-02-01T17:21:08.000+08:00"},
{sensorId: 1, value: 81.5, timestamp: "2018-02-01T17:21:09.000+08:00"}
]
locReadings: [
{sensorId: 1, lat: 47.615063, long: -122.333551, timestamp: "2018-02-01T17:21:05.000+08:00"},
{sensorId: 1, lat: 47.615163, long: -122.333552, timestamp: "2018-02-01T17:21:06.000+08:00"},
{sensorId: 1, lat: 47.615263, long: -122.333553, timestamp: "2018-02-01T17:21:07.000+08:00"},
{sensorId: 1, lat: 47.615363, long: -122.333554, timestamp: "2018-02-01T17:21:08.000+08:00"},
{sensorId: 1, lat: 47.615463, long: -122.333555, timestamp: "2018-02-01T17:21:09.000+08:00"}
]) {
locationReadings {
sensorId
timestamp
lat
long
}
temperatureReadings {
sensorId
timestamp
value
}
}
}
```
Kami mengirim sepuluh pembacaan sensor dalam satu mutasi dengan pembacaan dibagi menjadi dua tabel. Gunakan konsol DynamoDB untuk memvalidasi bahwa data muncul di tabel dan tabel. `locationReadings` `temperatureReadings`
### BatchDeleteItem - Menghapus pembacaan sensor
Demikian pula, kita juga harus dapat menghapus batch pembacaan sensor. Mari kita gunakan bidang `Mutation.deleteReadings` GraphQL untuk tujuan ini. Di halaman **Skema AWS AppSync ** konsol, pilih **Lampirkan** di sebelah `Mutation.deleteReadings` bidang. Pada layar berikutnya, buat resolver Anda menggunakan `locationReadings` tabel sebagai sumber data.
Setelah membuat resolver Anda, ganti handler di editor kode dengan cuplikan di bawah ini. Dalam resolver ini, kita menggunakan helper function mapper yang mengekstrak `sensorId` dan `timestamp` dari input yang disediakan.
```
import { util } from '@aws-appsync/utils'
export function request(ctx) {
const { locReadings, tempReadings } = ctx.args
const mapper = ({ sensorId, timestamp }) => util.dynamodb.toMapValues({ sensorId, timestamp })
return {
operation: 'BatchDeleteItem',
tables: {
locationReadings: locReadings.map(mapper),
temperatureReadings: tempReadings.map(mapper),
},
}
}
export function response(ctx) {
if (ctx.error) {
util.appendError(ctx.error.message, ctx.error.type)
}
return ctx.result.data
}
```
Simpan resolver dan navigasikan ke halaman **Kueri** di konsol. AWS AppSync Sekarang, mari kita hapus beberapa pembacaan sensor.
Jalankan mutasi berikut:
```
mutation deleteReadings {
# Let's delete the first two readings we recorded
deleteReadings(
tempReadings: [{sensorId: 1, timestamp: "2018-02-01T17:21:05.000+08:00"}]
locReadings: [{sensorId: 1, timestamp: "2018-02-01T17:21:05.000+08:00"}]) {
locationReadings {
sensorId
timestamp
lat
long
}
temperatureReadings {
sensorId
timestamp
value
}
}
}
```
**catatan**
Berlawanan dengan `DeleteItem` operasi, item yang dihapus sepenuhnya tidak dikembalikan dalam respons. Hanya kunci yang dilewati yang dikembalikan. Untuk mempelajari lebih lanjut, lihat [referensi fungsi BatchDeleteItem in JavaScript resolver untuk DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-batch-delete-item).
Validasi melalui konsol DynamoDB bahwa kedua pembacaan ini telah dihapus dari tabel dan. `locationReadings` `temperatureReadings`
### BatchGetItem - Ambil bacaan
Operasi umum lainnya untuk aplikasi kami adalah mengambil pembacaan untuk sensor pada titik waktu tertentu. Mari lampirkan resolver ke bidang GraphQL pada skema `Query.getReadings` kami. Di halaman **Skema AWS AppSync ** konsol, pilih **Lampirkan** di sebelah `Query.getReadings` bidang. Pada layar berikutnya, buat resolver Anda menggunakan `locationReadings` tabel sebagai sumber data.
Mari kita gunakan kode berikut:
```
import { util } from '@aws-appsync/utils'
export function request(ctx) {
const keys = [util.dynamodb.toMapValues(ctx.args)]
const consistentRead = true
return {
operation: 'BatchGetItem',
tables: {
locationReadings: { keys, consistentRead },
temperatureReadings: { keys, consistentRead },
},
}
}
export function response(ctx) {
if (ctx.error) {
util.appendError(ctx.error.message, ctx.error.type)
}
const { locationReadings: locs, temperatureReadings: temps } = ctx.result.data
return [
...locs.map((l) => ({ ...l, __typename: 'LocationReading' })),
...temps.map((t) => ({ ...t, __typename: 'TemperatureReading' })),
]
}
```
Simpan resolver dan navigasikan ke halaman **Kueri** di konsol. AWS AppSync Sekarang, mari kita ambil pembacaan sensor kita.
Jalankan kueri berikut:
```
query getReadingsForSensorAndTime {
# Let's retrieve the very first two readings
getReadings(sensorId: 1, timestamp: "2018-02-01T17:21:06.000+08:00") {
sensorId
timestamp
...on TemperatureReading {
value
}
...on LocationReading {
lat
long
}
}
}
```
Kami telah berhasil mendemonstrasikan penggunaan operasi batch DynamoDB menggunakan. AWS AppSync
## Penanganan kesalahan
Dalam AWS AppSync, operasi sumber data terkadang dapat mengembalikan hasil sebagian. Hasil sebagian adalah istilah yang akan kita gunakan untuk menunjukkan ketika output dari suatu operasi terdiri dari beberapa data dan kesalahan. Karena penanganan kesalahan secara inheren spesifik aplikasi, AWS AppSync memberi Anda kesempatan untuk menangani kesalahan dalam penangan respons. Kesalahan pemanggilan resolver, jika ada, tersedia dari konteks sebagai. `ctx.error` Kesalahan pemanggilan selalu menyertakan pesan dan tipe, dapat diakses sebagai properti `ctx.error.message` dan. `ctx.error.type` Dalam handler respon, Anda dapat menangani sebagian hasil dalam tiga cara:
1. Menelan kesalahan pemanggilan hanya dengan mengembalikan data.
1. Naikkan kesalahan (menggunakan`util.error(...)`) dengan menghentikan evaluasi handler, yang tidak akan mengembalikan data apa pun.
1. Tambahkan kesalahan (menggunakan`util.appendError(...)`) dan juga mengembalikan data.
Mari kita tunjukkan masing-masing dari tiga poin di atas dengan operasi batch DynamoDB.
### Operasi Batch DynamoDB
Dengan operasi batch DynamoDB, ada kemungkinan bahwa batch sebagian selesai. Artinya, ada kemungkinan bahwa beberapa item atau kunci yang diminta dibiarkan tidak diproses. Jika AWS AppSync tidak dapat menyelesaikan batch, item yang belum diproses dan kesalahan pemanggilan akan disetel pada konteksnya.
Kami akan menerapkan penanganan kesalahan menggunakan konfigurasi `Query.getReadings` bidang dari `BatchGetItem` operasi dari bagian sebelumnya dari tutorial ini. Kali ini, mari kita berpura-pura bahwa saat mengeksekusi `Query.getReadings` field, tabel DynamoDB `temperatureReadings` kehabisan throughput yang disediakan. DynamoDB mengangkat `ProvisionedThroughputExceededException` a selama upaya kedua AWS AppSync dengan memproses elemen yang tersisa dalam batch.
JSON berikut mewakili konteks serial setelah pemanggilan batch DynamoDB tetapi sebelum penangan respons dipanggil:
```
{
"arguments": {
"sensorId": "1",
"timestamp": "2018-02-01T17:21:05.000+08:00"
},
"source": null,
"result": {
"data": {
"temperatureReadings": [
null
],
"locationReadings": [
{
"lat": 47.615063,
"long": -122.333551,
"sensorId": "1",
"timestamp": "2018-02-01T17:21:05.000+08:00"
}
]
},
"unprocessedKeys": {
"temperatureReadings": [
{
"sensorId": "1",
"timestamp": "2018-02-01T17:21:05.000+08:00"
}
],
"locationReadings": []
}
},
"error": {
"type": "DynamoDB:ProvisionedThroughputExceededException",
"message": "You exceeded your maximum allowed provisioned throughput for a table or for one or more global secondary indexes. (...)"
},
"outErrors": []
}
```
Beberapa hal yang perlu diperhatikan pada konteksnya:
+ Kesalahan pemanggilan telah disetel pada konteks di `ctx.error` by AWS AppSync, dan jenis kesalahan telah disetel ke. `DynamoDB:ProvisionedThroughputExceededException`
+ Hasil dipetakan per tabel di bawah `ctx.result.data` meskipun ada kesalahan.
+ Kunci yang dibiarkan tidak diproses tersedia di`ctx.result.data.unprocessedKeys`. Di sini, AWS AppSync tidak dapat mengambil item dengan kunci (sensorid:1, stempel waktu: 2018-02-01T 17:21:05.000 \$1 08:00) karena throughput tabel yang tidak mencukupi.
**catatan**
Untuk`BatchPutItem`, itu`ctx.result.data.unprocessedItems`. Untuk`BatchDeleteItem`, itu`ctx.result.data.unprocessedKeys`.
Mari kita tangani kesalahan ini dengan tiga cara berbeda.
#### 1. Menelan kesalahan pemanggilan
Mengembalikan data tanpa menangani kesalahan pemanggilan secara efektif menelan kesalahan, membuat hasil untuk bidang GraphQL yang diberikan selalu berhasil.
Kode yang kami tulis sudah tidak asing lagi dan hanya berfokus pada data hasil.
**Penangan respons**
```
export function response(ctx) {
return ctx.result.data
}
```
**Tanggapan GraphQL**
```
{
"data": {
"getReadings": [
{
"sensorId": "1",
"timestamp": "2018-02-01T17:21:05.000+08:00",
"lat": 47.615063,
"long": -122.333551
},
{
"sensorId": "1",
"timestamp": "2018-02-01T17:21:05.000+08:00",
"value": 85.5
}
]
}
}
```
Tidak ada kesalahan yang akan ditambahkan ke respons kesalahan karena hanya data yang ditindaklanjuti.
#### 2. Memunculkan kesalahan untuk membatalkan eksekusi handler respons
Ketika kegagalan sebagian harus diperlakukan sebagai kegagalan total dari perspektif klien, Anda dapat membatalkan eksekusi handler respons untuk mencegah pengembalian data. Metode `util.error(...)` utilitas mencapai perilaku ini dengan tepat.
**Kode penangan respons**
```
export function response(ctx) {
if (ctx.error) {
util.error(ctx.error.message, ctx.error.type, null, ctx.result.data.unprocessedKeys);
}
return ctx.result.data;
}
```
**Tanggapan GraphQL**
```
{
"data": {
"getReadings": null
},
"errors": [
{
"path": [
"getReadings"
],
"data": null,
"errorType": "DynamoDB:ProvisionedThroughputExceededException",
"errorInfo": {
"temperatureReadings": [
{
"sensorId": "1",
"timestamp": "2018-02-01T17:21:05.000+08:00"
}
],
"locationReadings": []
},
"locations": [
{
"line": 58,
"column": 3
}
],
"message": "You exceeded your maximum allowed provisioned throughput for a table or for one or more global secondary indexes. (...)"
}
]
}
```
*Meskipun beberapa hasil mungkin telah dikembalikan dari operasi batch DynamoDB, kami memilih untuk memunculkan kesalahan sehingga bidang `getReadings` GraphQL adalah nol dan kesalahan telah ditambahkan ke blok kesalahan respons GraphQL.*
#### 3. Menambahkan kesalahan untuk mengembalikan data dan kesalahan
Dalam kasus tertentu, untuk memberikan pengalaman pengguna yang lebih baik, aplikasi dapat mengembalikan sebagian hasil dan memberi tahu klien mereka tentang item yang belum diproses. Klien dapat memutuskan untuk menerapkan coba lagi atau menerjemahkan kesalahan kembali ke pengguna akhir. Ini `util.appendError(...)` adalah metode utilitas yang memungkinkan perilaku ini dengan membiarkan perancang aplikasi menambahkan kesalahan pada konteks tanpa mengganggu evaluasi penangan respons. Setelah mengevaluasi penangan respons, AWS AppSync akan memproses kesalahan konteks apa pun dengan menambahkannya ke blok kesalahan respons GraphQL.
**Kode penangan respons**
```
export function response(ctx) {
if (ctx.error) {
util.appendError(ctx.error.message, ctx.error.type, null, ctx.result.data.unprocessedKeys);
}
return ctx.result.data;
}
```
Kami meneruskan kesalahan pemanggilan dan `unprocessedKeys` elemen di dalam blok kesalahan respons GraphQL. `getReadings`Bidang ini juga mengembalikan sebagian data dari `locationReadings` tabel seperti yang Anda lihat pada respons di bawah ini.
**Tanggapan GraphQL**
```
{
"data": {
"getReadings": [
null,
{
"sensorId": "1",
"timestamp": "2018-02-01T17:21:05.000+08:00",
"value": 85.5
}
]
},
"errors": [
{
"path": [
"getReadings"
],
"data": null,
"errorType": "DynamoDB:ProvisionedThroughputExceededException",
"errorInfo": {
"temperatureReadings": [
{
"sensorId": "1",
"timestamp": "2018-02-01T17:21:05.000+08:00"
}
],
"locationReadings": []
},
"locations": [
{
"line": 58,
"column": 3
}
],
"message": "You exceeded your maximum allowed provisioned throughput for a table or for one or more global secondary indexes. (...)"
}
]
}
```