Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Integrasi Lambda untuk REST APIs di API Gateway
Anda dapat mengintegrasikan metode API dengan fungsi Lambda menggunakan integrasi proxy Lambda atau integrasi Lambda non-proxy (kustom).
Dalam integrasi proxy Lambda, pengaturan yang diperlukan sederhana. Setel metode HTTP integrasi ke POST, URI endpoint integrasi ke ARN dari tindakan pemanggilan fungsi Lambda dari fungsi Lambda tertentu, dan berikan izin API Gateway untuk memanggil fungsi Lambda atas nama Anda.
Di integrasi non-proxy Lambda, selain langkah penyiapan integrasi proxy, Anda juga menentukan cara data permintaan masuk dipetakan ke permintaan integrasi dan bagaimana data respons integrasi yang dihasilkan dipetakan ke respons metode.
**Topics**
+ [Integrasi proxy Lambda di API Gateway](set-up-lambda-proxy-integrations.md)
+ [Siapkan integrasi kustom Lambda di API Gateway](set-up-lambda-custom-integrations.md)
+ [Siapkan pemanggilan asinkron dari fungsi Lambda backend](set-up-lambda-integration-async.md)
+ [Menangani kesalahan Lambda di API Gateway](handle-errors-in-lambda-integration.md)
# Integrasi proxy Lambda di API Gateway
Bagian berikut menunjukkan cara menggunakan integrasi proxy Lambda.
**Topics**
+ [Memahami integrasi proxy API Gateway Lambda](#api-gateway-create-api-as-simple-proxy)
+ [Support untuk header multi-nilai dan parameter string kueri](#apigateway-multivalue-headers-and-parameters)
+ [Format input fungsi Lambda untuk integrasi proxy](#api-gateway-simple-proxy-for-lambda-input-format)
+ [Format output dari fungsi Lambda untuk integrasi proxy](#api-gateway-simple-proxy-for-lambda-output-format)
+ [Siapkan integrasi proxy Lambda untuk API Gateway menggunakan AWS CLI](set-up-lambda-proxy-integration-using-cli.md)
+ [Siapkan sumber daya proxy dengan integrasi proxy Lambda dengan definisi OpenAPI](api-gateway-set-up-lambda-proxy-integration-on-proxy-resource.md)
## Memahami integrasi proxy API Gateway Lambda
Integrasi proxy Amazon API Gateway Lambda adalah mekanisme yang sederhana, kuat, dan gesit untuk membangun API dengan penyiapan metode API tunggal. Integrasi proxy Lambda memungkinkan klien untuk memanggil satu fungsi Lambda di backend. Fungsi ini mengakses banyak sumber daya atau fitur AWS layanan lain, termasuk memanggil fungsi Lambda lainnya.
Dalam integrasi proxy Lambda, ketika klien mengirimkan permintaan API, API Gateway meneruskan ke fungsi Lambda terintegrasi [objek peristiwa](#api-gateway-simple-proxy-for-lambda-input-format), kecuali urutan parameter permintaan tidak dipertahankan. [Data permintaan](#api-gateway-simple-proxy-for-lambda-input-format) ini mencakup header permintaan, parameter string kueri, variabel jalur URL, payload, dan data konfigurasi API. Data konfigurasi dapat mencakup nama tahap penyebaran saat ini, variabel tahap, identitas pengguna, atau konteks otorisasi (jika ada). Fungsi backend Lambda mem-parsing data permintaan yang masuk untuk menentukan respons yang dikembalikan. [Agar API Gateway meneruskan output Lambda sebagai respons API ke klien, fungsi Lambda harus mengembalikan hasilnya dalam format ini.](#api-gateway-simple-proxy-for-lambda-output-format)
Karena API Gateway tidak terlalu banyak campur tangan antara klien dan fungsi Lambda backend untuk integrasi proxy Lambda, klien dan fungsi Lambda terintegrasi dapat beradaptasi dengan perubahan satu sama lain tanpa merusak pengaturan integrasi API yang ada. Untuk mengaktifkan ini, klien harus mengikuti protokol aplikasi yang diberlakukan oleh fungsi Lambda backend.
Anda dapat menyiapkan integrasi proxy Lambda untuk metode API apa pun. Tetapi integrasi proxy Lambda lebih kuat ketika dikonfigurasi untuk metode API yang melibatkan sumber daya proxy generik. Sumber daya proxy generik dapat dilambangkan dengan variabel jalur template khusus, placeholder metode catch-all `{proxy+}``ANY`, atau keduanya. Klien dapat meneruskan input ke fungsi Lambda backend dalam permintaan masuk sebagai parameter permintaan atau muatan yang berlaku. Parameter permintaan termasuk header, variabel jalur URL, parameter string kueri, dan payload yang berlaku. Fungsi Lambda terintegrasi memverifikasi semua sumber input sebelum memproses permintaan dan menanggapi klien dengan pesan kesalahan yang berarti jika ada input yang diperlukan yang hilang.
Saat memanggil metode API yang terintegrasi dengan metode HTTP generik `ANY` dan sumber daya generik`{proxy+}`, klien mengirimkan permintaan dengan metode HTTP tertentu sebagai pengganti. `ANY` Klien juga menentukan jalur URL tertentu, bukan`{proxy+}`, dan menyertakan header yang diperlukan, parameter string kueri, atau payload yang berlaku.
Daftar berikut merangkum perilaku runtime dari berbagai metode API dengan integrasi proxy Lambda:
+ `ANY /{proxy+}`: Klien harus memilih metode HTTP tertentu, harus menetapkan hierarki jalur sumber daya tertentu, dan dapat mengatur header, parameter string kueri, dan muatan yang berlaku untuk meneruskan data sebagai input ke fungsi Lambda terintegrasi.
+ `ANY /res`: Klien harus memilih metode HTTP tertentu dan dapat mengatur header, parameter string kueri, dan payload yang berlaku untuk meneruskan data sebagai input ke fungsi Lambda terintegrasi.
+ `GET|POST|PUT|... /{proxy+}`: Klien dapat mengatur hierarki jalur sumber daya tertentu, header apa pun, parameter string kueri, dan muatan yang berlaku untuk meneruskan data sebagai input ke fungsi Lambda terintegrasi.
+ `GET|POST|PUT|... /res/{path}/...`: Klien harus memilih segmen jalur tertentu (untuk `{path}` variabel) dan dapat mengatur header permintaan, parameter string kueri, dan payload yang berlaku untuk meneruskan data input ke fungsi Lambda terintegrasi.
+ `GET|POST|PUT|... /res`: Klien dapat memilih header permintaan, parameter string kueri, dan payload yang berlaku untuk meneruskan data input ke fungsi Lambda terintegrasi.
Baik sumber daya proxy `{proxy+}` dan sumber daya kustom `{custom}` dinyatakan sebagai variabel jalur templat. Namun `{proxy+}` dapat merujuk ke sumber daya apa pun di sepanjang hierarki jalur, sementara `{custom}` mengacu pada segmen jalur tertentu saja. Misalnya, toko kelontong mungkin mengatur inventaris produk online-nya berdasarkan nama departemen, kategori produksi, dan jenis produk. Situs web toko kelontong kemudian dapat mewakili produk yang tersedia dengan variabel jalur template berikut dari sumber daya khusus:. `/{department}/{produce-category}/{product-type}` Misalnya, apel diwakili oleh `/produce/fruit/apple` dan wortel oleh`/produce/vegetables/carrot`. Ini juga dapat digunakan `/{proxy+}` untuk mewakili departemen apa pun, kategori produk apa pun, atau jenis produk apa pun yang dapat dicari pelanggan saat berbelanja di toko online. Misalnya, `/{proxy+}` dapat merujuk ke salah satu item berikut:
+ `/produce`
+ `/produce/fruit`
+ `/produce/vegetables/carrot`
Untuk memungkinkan pelanggan mencari produk apa pun yang tersedia, kategori produksinya, dan departemen toko terkait, Anda dapat mengekspos satu metode `GET /{proxy+}` dengan izin hanya-baca. Demikian pula, untuk memungkinkan supervisor memperbarui inventaris `produce` departemen, Anda dapat menyiapkan metode tunggal lain `PUT /produce/{proxy+}` dengan read/write izin. Untuk memungkinkan kasir memperbarui total sayuran yang sedang berjalan, Anda dapat mengatur `POST /produce/vegetables/{proxy+}` metode dengan read/write izin. Untuk membiarkan manajer toko melakukan tindakan apa pun yang mungkin pada produk apa pun yang tersedia, pengembang toko online dapat mengekspos `ANY /{proxy+}` metode dengan read/write izin. Dalam kasus apa pun, pada waktu berjalan, pelanggan atau karyawan harus memilih produk tertentu dari jenis tertentu di departemen yang dipilih, kategori produk tertentu di departemen yang dipilih, atau departemen tertentu.
Untuk informasi selengkapnya tentang menyiapkan integrasi proxy API Gateway, lihat[Siapkan integrasi proxy dengan sumber daya proxy](api-gateway-set-up-simple-proxy.md).
Integrasi proxy mengharuskan klien memiliki pengetahuan yang lebih rinci tentang persyaratan backend. Oleh karena itu, untuk memastikan kinerja aplikasi dan pengalaman pengguna yang optimal, pengembang backend harus berkomunikasi dengan jelas kepada pengembang klien persyaratan backend, dan memberikan mekanisme umpan balik kesalahan yang kuat ketika persyaratan tidak terpenuhi.
## Support untuk header multi-nilai dan parameter string kueri
API Gateway mendukung beberapa header dan parameter string kueri yang memiliki nama yang sama. Header multi-nilai serta header dan parameter nilai tunggal dapat digabungkan dalam permintaan dan tanggapan yang sama. Untuk informasi selengkapnya, lihat [Format input fungsi Lambda untuk integrasi proxy](#api-gateway-simple-proxy-for-lambda-input-format) dan [Format output dari fungsi Lambda untuk integrasi proxy](#api-gateway-simple-proxy-for-lambda-output-format).
## Format input fungsi Lambda untuk integrasi proxy
Dalam integrasi proxy Lambda, API Gateway memetakan seluruh permintaan klien ke `event` parameter input fungsi Lambda backend. Contoh berikut menunjukkan struktur peristiwa yang dikirimkan API Gateway ke integrasi proxy Lambda.
Dalam contoh ini, kami berasumsi bahwa pemanggilan ke API Gateway adalah sebagai berikut:
```
curl 'https://a1b2c3.execute-api.us-east-1.amazonaws.com/my/path?parameter1=value1¶meter2=value1¶meter2=value2¶meter3=value1,value2' -H 'header1: value1' -H 'header2: value1' -H 'header2: value2' -H 'header3: value1,value2'
```
Outputnya terlihat seperti berikut:
```
{
"resource": "/my/path",
"path": "/my/path",
"httpMethod": "GET",
"headers": {
"header1": "value1",
"header2": "value2",
"header3": "value1,value2"
},
"multiValueHeaders": {
"header1": ["value1"],
"header2": ["value1","value2"],
"header3": ["value1,value2"]
},
"queryStringParameters": {
"parameter1": "value1",
"parameter2": "value2",
"parameter3": "value1,value2"
},
"multiValueQueryStringParameters": {
"parameter1": ["value1"],
"parameter2": ["value1","value2"],
"parameter3": ["value1,value2"]
},
"requestContext": {
"accountId": "123456789012",
"apiId": "id",
"authorizer": {
"claims": null,
"scopes": null
},
"domainName": "id.execute-api.us-east-1.amazonaws.com",
"domainPrefix": "id",
"extendedRequestId": "request-id",
"httpMethod": "GET",
"identity": {
"accessKey": null,
"accountId": null,
"caller": null,
"cognitoAuthenticationProvider": null,
"cognitoAuthenticationType": null,
"cognitoIdentityId": null,
"cognitoIdentityPoolId": null,
"principalOrgId": null,
"sourceIp": "IP",
"user": null,
"userAgent": "user-agent",
"userArn": null,
"clientCert": {
"clientCertPem": "CERT_CONTENT",
"subjectDN": "www.example.com",
"issuerDN": "Example issuer",
"serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
"validity": {
"notBefore": "May 28 12:30:02 2019 GMT",
"notAfter": "Aug 5 09:36:04 2021 GMT"
}
}
},
"path": "/my/path",
"protocol": "HTTP/1.1",
"requestId": "id=",
"requestTime": "04/Mar/2020:19:15:17 +0000",
"requestTimeEpoch": 1583349317135,
"resourceId": null,
"resourcePath": "/my/path",
"stage": "$default"
},
"pathParameters": null,
"stageVariables": null,
"body": "Hello from Lambda!",
"isBase64Encoded": false
}
```
**catatan**
Dalam masukan:
`headers`Kuncinya hanya dapat berisi header nilai tunggal.
`multiValueHeaders`Kuncinya dapat berisi header multi-nilai serta header nilai tunggal.
Jika Anda menentukan nilai untuk keduanya `headers` dan`multiValueHeaders`, API Gateway menggabungkannya ke dalam satu daftar. Jika pasangan kunci-nilai yang sama ditentukan di keduanya, hanya nilai dari yang `multiValueHeaders` akan muncul dalam daftar gabungan.
Dalam input ke fungsi Lambda backend, `requestContext` objek adalah peta pasangan kunci-nilai. Di setiap pasangan, kuncinya adalah nama properti variabel [\$1context](api-gateway-mapping-template-reference.md#context-variable-reference), dan nilainya adalah nilai properti itu. API Gateway mungkin menambahkan kunci baru ke peta.
Bergantung pada fitur yang diaktifkan, `requestContext` peta dapat bervariasi dari API ke API. Misalnya, dalam contoh sebelumnya, tidak ada jenis otorisasi yang ditentukan, jadi tidak ada `$context.authorizer.*` atau `$context.identity.*` properti yang ada. Ketika jenis otorisasi ditentukan, ini menyebabkan API Gateway meneruskan informasi pengguna yang diotorisasi ke titik akhir integrasi dalam `requestContext.identity` objek sebagai berikut:
+ Ketika jenis otorisasi`AWS_IAM`, informasi pengguna yang berwenang mencakup `$context.identity.*` properti.
+ Ketika jenis otorisasi adalah `COGNITO_USER_POOLS` (Amazon Cognito Authorizer), informasi `$context.identity.cognito*` pengguna yang berwenang termasuk dan properti. `$context.authorizer.claims.*`
+ Ketika jenis otorisasi adalah `CUSTOM` (Lambda Authorizer), informasi pengguna yang berwenang `$context.authorizer.principalId` termasuk dan properti lain yang berlaku. `$context.authorizer.*`
## Format output dari fungsi Lambda untuk integrasi proxy
Dalam integrasi proxy Lambda, API Gateway memerlukan fungsi Lambda backend untuk mengembalikan output sesuai dengan format JSON berikut:
```
{
"isBase64Encoded": true|false,
"statusCode": httpStatusCode,
"headers": { "headerName": "headerValue", ... },
"multiValueHeaders": { "headerName": ["headerValue", "headerValue2", ...], ... },
"body": "..."
}
```
Dalam output:
+ `multiValueHeaders`Tombol `headers` dan dapat tidak ditentukan jika tidak ada header respons tambahan yang akan dikembalikan.
+ `headers`Kuncinya hanya dapat berisi header nilai tunggal.
+ `multiValueHeaders`Kuncinya dapat berisi header multi-nilai serta header nilai tunggal. Anda dapat menggunakan `multiValueHeaders` kunci untuk menentukan semua header tambahan Anda, termasuk yang bernilai tunggal.
+ Jika Anda menentukan nilai untuk keduanya `headers` dan`multiValueHeaders`, API Gateway menggabungkannya ke dalam satu daftar. Jika pasangan kunci-nilai yang sama ditentukan di keduanya, hanya nilai dari yang `multiValueHeaders` akan muncul dalam daftar gabungan.
Untuk mengaktifkan CORS untuk integrasi proxy Lambda, Anda harus `Access-Control-Allow-Origin:domain-name` menambahkan ke output. `headers` `domain-name`bisa `*` untuk nama domain apa pun. Output `body` disusun ke frontend sebagai payload respons metode. **Jika `body` adalah gumpalan biner, Anda dapat menyandikannya sebagai string yang dikodekan Base64 dengan mengatur `true` dan `isBase64Encoded` mengonfigurasi `*/*` sebagai Tipe Media Biner.** Jika tidak, Anda dapat mengaturnya ke `false` atau membiarkannya tidak ditentukan.
**catatan**
Untuk informasi selengkapnya tentang mengaktifkan dukungan biner, lihat[Mengaktifkan dukungan biner menggunakan konsol API Gateway](api-gateway-payload-encodings-configure-with-console.md). Untuk contoh fungsi Lambda, lihat. [Kembalikan media biner dari integrasi proxy Lambda di API Gateway](lambda-proxy-binary-media.md)
Jika output fungsi dari format yang berbeda, API Gateway mengembalikan respon `502 Bad Gateway` kesalahan.
Untuk mengembalikan respons dalam fungsi Lambda di Node.js, Anda dapat menggunakan perintah seperti berikut:
+ Untuk mengembalikan hasil yang sukses, hubungi`callback(null, {"statusCode": 200, "body": "results"})`.
+ Untuk melempar pengecualian, panggil`callback(new Error('internal server error'))`.
+ Untuk kesalahan sisi klien (jika, misalnya, parameter yang diperlukan tidak ada), Anda dapat memanggil `callback(null, {"statusCode": 400, "body": "Missing parameters of ..."})` untuk mengembalikan kesalahan tanpa melempar pengecualian.
Dalam `async` fungsi Lambda di Node.js, sintaks yang setara adalah:
+ Untuk mengembalikan hasil yang sukses, hubungi`return {"statusCode": 200, "body": "results"}`.
+ Untuk melempar pengecualian, panggil`throw new Error("internal server error")`.
+ Untuk kesalahan sisi klien (jika, misalnya, parameter yang diperlukan tidak ada), Anda dapat memanggil `return {"statusCode": 400, "body": "Missing parameters of ..."}` untuk mengembalikan kesalahan tanpa melempar pengecualian.
# Siapkan integrasi proxy Lambda untuk API Gateway menggunakan AWS CLI
Di bagian ini, kami menunjukkan cara menyiapkan API dengan integrasi proxy Lambda menggunakan. AWS CLI Untuk petunjuk mendetail tentang penggunaan konsol API Gateway guna mengonfigurasi sumber daya proxy dengan integrasi proxy Lambda, lihat. [Tutorial: Buat REST API dengan integrasi proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md)
Sebagai contoh, kami menggunakan contoh fungsi Lambda berikut sebagai backend API:
```
export const handler = async(event, context) => {
console.log('Received event:', JSON.stringify(event, null, 2));
var res ={
"statusCode": 200,
"headers": {
"Content-Type": "*/*"
}
};
var greeter = 'World';
if (event.greeter && event.greeter!=="") {
greeter = event.greeter;
} else if (event.body && event.body !== "") {
var body = JSON.parse(event.body);
if (body.greeter && body.greeter !== "") {
greeter = body.greeter;
}
} else if (event.queryStringParameters && event.queryStringParameters.greeter && event.queryStringParameters.greeter !== "") {
greeter = event.queryStringParameters.greeter;
} else if (event.multiValueHeaders && event.multiValueHeaders.greeter && event.multiValueHeaders.greeter != "") {
greeter = event.multiValueHeaders.greeter.join(" and ");
} else if (event.headers && event.headers.greeter && event.headers.greeter != "") {
greeter = event.headers.greeter;
}
res.body = "Hello, " + greeter + "!";
return res
};
```
Membandingkan ini dengan pengaturan integrasi kustom Lambda di[Siapkan integrasi kustom Lambda di API Gateway](set-up-lambda-custom-integrations.md), input ke fungsi Lambda ini dapat dinyatakan dalam parameter permintaan dan isi. Anda memiliki lebih banyak garis lintang untuk memungkinkan klien meneruskan data input yang sama. Di sini, klien dapat meneruskan nama penyambut sebagai parameter string kueri, header, atau properti tubuh. Fungsi ini juga dapat mendukung integrasi kustom Lambda. Penyiapan API lebih sederhana. Anda tidak mengonfigurasi respons metode atau respons integrasi sama sekali.
**Untuk mengatur integrasi proxy Lambda menggunakan AWS CLI**
1. Gunakan [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-rest-api.html)perintah berikut untuk membuat API:
```
aws apigateway create-rest-api --name 'HelloWorld (AWS CLI)'
```
Outputnya akan terlihat seperti berikut:
```
{
"name": "HelloWorldProxy (AWS CLI)",
"id": "te6si5ach7",
"rootResourceId" : "krznpq9xpg",
"createdDate": 1508461860
}
```
Anda menggunakan API `id` (`te6si5ach7`) dan `rootResourceId` (`krznpq9xpg`) di seluruh contoh ini.
1. [Gunakan perintah [create-resource](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-resource.html) berikut untuk membuat API Gateway Resource dari:](https://docs.aws.amazon.com/apigateway/latest/api/API_Resource.html) `/greeting`
```
aws apigateway create-resource \
--rest-api-id te6si5ach7 \
--parent-id krznpq9xpg \
--path-part {proxy+}
```
Outputnya akan terlihat seperti berikut:
```
{
"path": "/{proxy+}",
"pathPart": "{proxy+}",
"id": "2jf6xt",
"parentId": "krznpq9xpg"
}
```
Anda menggunakan `id` nilai `{proxy+}` sumber daya (`2jf6xt`) untuk membuat metode pada `/{proxy+}` sumber daya di langkah berikutnya.
1. Gunakan [put-metode](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html) berikut untuk membuat permintaan `ANY` metode: `ANY /{proxy+}`
```
aws apigateway put-method --rest-api-id te6si5ach7 \
--resource-id 2jf6xt \
--http-method ANY \
--authorization-type "NONE"
```
Outputnya akan terlihat seperti berikut:
```
{
"apiKeyRequired": false,
"httpMethod": "ANY",
"authorizationType": "NONE"
}
```
Metode API ini memungkinkan klien untuk menerima atau mengirim salam dari fungsi Lambda di backend.
1. Gunakan perintah [put-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html) berikut untuk mengatur integrasi `ANY /{proxy+}` metode dengan fungsi Lambda, bernama. `HelloWorld` Fungsi ini menanggapi permintaan dengan pesan`"Hello, {name}!"`, jika `greeter` parameter disediakan, atau`"Hello, World!"`, jika parameter string query tidak diatur.
```
aws apigateway put-integration \
--rest-api-id te6si5ach7 \
--resource-id 2jf6xt \
--http-method ANY \
--type AWS_PROXY \
--integration-http-method POST \
--uri arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:HelloWorld/invocations \
--credentials arn:aws:iam::123456789012:role/apigAwsProxyRole
```
**penting**
Untuk integrasi Lambda, Anda harus menggunakan metode HTTP `POST` untuk permintaan integrasi, sesuai dengan [spesifikasi tindakan layanan Lambda untuk pemanggilan](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) fungsi. Peran IAM `apigAwsProxyRole` harus memiliki kebijakan yang memungkinkan `apigateway` layanan untuk menjalankan fungsi Lambda. Untuk informasi selengkapnya tentang izin IAM, lihat. [Model izin API Gateway untuk menjalankan API](permissions.md#api-gateway-control-access-iam-permissions-model-for-calling-api)
Outputnya akan terlihat seperti berikut:
```
{
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:1234567890:function:HelloWorld/invocations",
"httpMethod": "POST",
"cacheNamespace": "vvom7n",
"credentials": "arn:aws:iam::1234567890:role/apigAwsProxyRole",
"type": "AWS_PROXY"
}
```
Alih-alih menyediakan peran IAM`credentials`, Anda dapat menggunakan perintah [add-permission untuk menambahkan izin berbasis](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) sumber daya. Inilah yang dilakukan konsol API Gateway.
1. Gunakan perintah [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-deployment.html) berikut untuk menyebarkan API ke sebuah panggung: `test`
```
aws apigateway create-deployment \
--rest-api-id te6si5ach7 \
--stage-name test
```
1. Uji API menggunakan perintah cURL berikut di terminal.
Memanggil API dengan parameter string kueri`?greeter=jane`:
```
curl -X GET 'https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/greeting?greeter=jane'
```
Memanggil API dengan parameter header`greeter:jane`:
```
curl -X GET https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/hi \
-H 'content-type: application/json' \
-H 'greeter: jane'
```
Memanggil API dengan badan`{"greeter":"jane"}`:
```
curl -X POST https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/hi \
-H 'content-type: application/json' \
-d '{ "greeter": "jane" }'
```
Dalam semua kasus, outputnya adalah respons 200 dengan badan respons berikut:
```
Hello, jane!
```
# Siapkan sumber daya proxy dengan integrasi proxy Lambda dengan definisi OpenAPI
Untuk menyiapkan sumber daya proxy dengan tipe integrasi proxy Lambda, buat sumber daya API dengan parameter jalur serakah (misalnya,`/parent/{proxy+}`) dan integrasikan sumber daya ini dengan backend fungsi Lambda (misalnya,) pada metode. `arn:aws:lambda:us-west-2:123456789012:function:SimpleLambda4ProxyResource` `ANY` Parameter jalur serakah harus berada di akhir jalur sumber daya API. Seperti sumber daya non-proxy, Anda dapat mengatur sumber daya proxy dengan menggunakan konsol API Gateway, mengimpor file definisi OpenAPI, atau memanggil API REST API Gateway API secara langsung.
File definisi API OpenAPI berikut menunjukkan contoh API dengan sumber daya proxy yang terintegrasi dengan fungsi Lambda bernama. `SimpleLambda4ProxyResource`
------
#### [ OpenAPI 3.0 ]
```
{
"openapi": "3.0.0",
"info": {
"version": "2016-09-12T17:50:37Z",
"title": "ProxyIntegrationWithLambda"
},
"paths": {
"/{proxy+}": {
"x-amazon-apigateway-any-method": {
"parameters": [
{
"name": "proxy",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {},
"x-amazon-apigateway-integration": {
"responses": {
"default": {
"statusCode": "200"
}
},
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:SimpleLambda4ProxyResource/invocations",
"passthroughBehavior": "when_no_match",
"httpMethod": "POST",
"cacheNamespace": "roq9wj",
"cacheKeyParameters": [
"method.request.path.proxy"
],
"type": "aws_proxy"
}
}
}
},
"servers": [
{
"url": "https://gy415nuibc.execute-api.us-east-1.amazonaws.com/{basePath}",
"variables": {
"basePath": {
"default": "/testStage"
}
}
}
]
}
```
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2016-09-12T17:50:37Z",
"title": "ProxyIntegrationWithLambda"
},
"host": "gy415nuibc.execute-api.us-east-1.amazonaws.com",
"basePath": "/testStage",
"schemes": [
"https"
],
"paths": {
"/{proxy+}": {
"x-amazon-apigateway-any-method": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "proxy",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {},
"x-amazon-apigateway-integration": {
"responses": {
"default": {
"statusCode": "200"
}
},
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:SimpleLambda4ProxyResource/invocations",
"passthroughBehavior": "when_no_match",
"httpMethod": "POST",
"cacheNamespace": "roq9wj",
"cacheKeyParameters": [
"method.request.path.proxy"
],
"type": "aws_proxy"
}
}
}
}
}
```
------
Dalam integrasi proxy Lambda, pada waktu berjalan, API Gateway memetakan permintaan masuk ke `event` parameter input fungsi Lambda. Input mencakup metode permintaan, jalur, header, parameter string kueri apa pun, payload apa pun, konteks terkait, dan variabel tahap yang ditentukan. Format input dijelaskan dalam[Format input fungsi Lambda untuk integrasi proxy](set-up-lambda-proxy-integrations.md#api-gateway-simple-proxy-for-lambda-input-format). Agar API Gateway berhasil memetakan output Lambda ke respons HTTP, fungsi Lambda harus menampilkan hasil dalam format yang dijelaskan dalam. [Format output dari fungsi Lambda untuk integrasi proxy](set-up-lambda-proxy-integrations.md#api-gateway-simple-proxy-for-lambda-output-format)
Dalam integrasi proxy Lambda dari sumber daya proxy melalui `ANY` metode, fungsi Lambda backend tunggal berfungsi sebagai event handler untuk semua permintaan melalui sumber daya proxy. Misalnya, untuk mencatat pola lalu lintas, Anda dapat meminta perangkat seluler mengirim informasi lokasi negara bagian, kota, jalan, dan bangunannya dengan mengirimkan permintaan `/state/city/street/house` di jalur URL untuk sumber daya proxy. Fungsi backend Lambda kemudian dapat mengurai jalur URL dan menyisipkan tupel lokasi ke dalam tabel DynamoDB.
# Siapkan integrasi kustom Lambda di API Gateway
Untuk menunjukkan cara mengatur integrasi kustom Lambda, atau non-proxy, kami membuat API Gateway API untuk mengekspos `GET /greeting?greeter={name}` metode untuk menjalankan fungsi Lambda. Gunakan salah satu contoh fungsi Lambda berikut untuk API Anda.
Gunakan salah satu contoh fungsi Lambda berikut:
------
#### [ Node.js ]
```
'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];
export const handler = async(event) => {
console.log(event);
// Parse the input for the name, city, time and day property values
let name = event.name === null || event.name === undefined || event.name === "" ? 'you' : event.name;
let city = event.city === undefined ? 'World' : event.city;
let time = times.indexOf(event.time)<0 ? 'day' : event.time;
let day = days.indexOf(event.day)<0 ? null : event.day;
// Generate a greeting
let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
if (day) greeting += 'Happy ' + day + '!';
// Log the greeting to CloudWatch
console.log('Hello: ', greeting);
// Return a greeting to the caller
return greeting;
};
```
------
#### [ Python ]
```
import json
def lambda_handler(event, context):
print(event)
res = {
"statusCode": 200,
"headers": {
"Content-Type": "*/*"
}
}
if event['greeter'] == "":
res['body'] = "Hello, World"
elif (event['greeter']):
res['body'] = "Hello, " + event['greeter'] + "!"
else:
raise Exception('Missing the required greeter parameter.')
return res
```
------
Fungsi merespons dengan pesan `"Hello, {name}!"` jika nilai `greeter` parameter adalah string yang tidak kosong. Ia mengembalikan pesan `"Hello, World!"` jika `greeter` nilai adalah string kosong. Fungsi mengembalikan pesan kesalahan `"Missing the required greeter parameter."` jika parameter penyambut tidak diatur dalam permintaan masuk. Kami menamai fungsinya`HelloWorld`.
Anda dapat membuatnya di konsol Lambda atau dengan menggunakan. AWS CLI Pada bagian ini, kami mereferensikan fungsi ini menggunakan ARN berikut:
```
arn:aws:lambda:us-east-1:123456789012:function:HelloWorld
```
Dengan fungsi Lambda diatur di backend, lanjutkan untuk mengatur API.
**Untuk mengatur integrasi kustom Lambda menggunakan AWS CLI**
1. Gunakan [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-rest-api.html)perintah berikut untuk membuat API:
```
aws apigateway create-rest-api --name 'HelloWorld (AWS CLI)'
```
Outputnya akan terlihat seperti berikut:
```
{
"name": "HelloWorld (AWS CLI)",
"id": "te6si5ach7",
"rootResourceId" : "krznpq9xpg",
"createdDate": 1508461860
}
```
Anda menggunakan API `id` (`te6si5ach7`) dan `rootResourceId` (`krznpq9xpg`) di seluruh contoh ini.
1. [Gunakan perintah [create-resource](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-resource.html) berikut untuk membuat API Gateway Resource dari:](https://docs.aws.amazon.com/apigateway/latest/api/API_Resource.html) `/greeting`
```
aws apigateway create-resource \
--rest-api-id te6si5ach7 \
--parent-id krznpq9xpg \
--path-part greeting
```
Outputnya akan terlihat seperti berikut:
```
{
"path": "/greeting",
"pathPart": "greeting",
"id": "2jf6xt",
"parentId": "krznpq9xpg"
}
```
Anda menggunakan `id` nilai `greeting` sumber daya (`2jf6xt`) untuk membuat metode pada `/greeting` sumber daya di langkah berikutnya.
1. Gunakan perintah [put-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html) berikut untuk membuat permintaan metode API dari: `GET /greeting?greeter={name}`
```
aws apigateway put-method --rest-api-id te6si5ach7 \
--resource-id 2jf6xt \
--http-method GET \
--authorization-type "NONE" \
--request-parameters method.request.querystring.greeter=false
```
Outputnya akan terlihat seperti berikut:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE",
"requestParameters": {
"method.request.querystring.greeter": false
}
}
```
Metode API ini memungkinkan klien untuk menerima salam dari fungsi Lambda di backend. `greeter`Parameternya opsional karena backend harus menangani penelepon anonim atau penelepon yang diidentifikasi sendiri.
1. Gunakan [put-method-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method-response.html)perintah berikut untuk mengatur `200 OK` respons terhadap permintaan metode`GET /greeting?greeter={name}`:
```
aws apigateway put-method-response \
--rest-api-id te6si5ach7 \
--resource-id 2jf6xt \
--http-method GET \
--status-code 200
```
1. Gunakan perintah [put-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html) berikut untuk mengatur integrasi `GET /greeting?greeter={name}` metode dengan fungsi Lambda, bernama. `HelloWorld` Fungsi menanggapi permintaan dengan pesan`"Hello, {name}!"`, jika `greeter` parameter disediakan, atau`"Hello, World!"`, jika parameter string query tidak diatur.
```
aws apigateway put-integration \
--rest-api-id te6si5ach7 \
--resource-id 2jf6xt \
--http-method GET \
--type AWS \
--integration-http-method POST \
--uri arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:HelloWorld/invocations \
--request-templates '{"application/json":"{\"greeter\":\"$input.params('greeter')\"}"}' \
--credentials arn:aws:iam::123456789012:role/apigAwsProxyRole
```
Template pemetaan yang disediakan di sini menerjemahkan parameter string `greeter` kueri ke `greeter` properti payload JSON. Ini diperlukan karena input ke fungsi Lambda harus diekspresikan dalam tubuh.
**penting**
Untuk integrasi Lambda, Anda harus menggunakan metode HTTP `POST` untuk permintaan integrasi, sesuai dengan [spesifikasi tindakan layanan Lambda untuk pemanggilan](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) fungsi. `uri`Parameternya adalah ARN dari tindakan pemanggilan fungsi.
Outputnya akan terlihat seperti berikut:
```
{
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:HelloWorld/invocations",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\"greeter\":\"$input.params('greeter')\"}"
},
"cacheNamespace": "krznpq9xpg",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"type": "AWS"
}
```
Peran IAM `apigAwsProxyRole` harus memiliki kebijakan yang memungkinkan `apigateway` layanan untuk menjalankan fungsi Lambda. Alih-alih menyediakan peran IAM`credentials`, Anda dapat memanggil perintah [add-permission untuk menambahkan izin berbasis](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) sumber daya. Beginilah cara konsol API Gateway menambahkan izin ini.
1. Gunakan [put-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration-response.html)perintah berikut untuk mengatur respons integrasi untuk meneruskan output fungsi Lambda ke klien sebagai respons `200 OK` metode:
```
aws apigateway put-integration-response \
--rest-api-id te6si5ach7 \
--resource-id 2jf6xt \
--http-method GET \
--status-code 200 \
--selection-pattern ""
```
Dengan mengatur pola pilihan ke string kosong, `200 OK` responsnya adalah default.
Outputnya akan terlihat seperti berikut:
```
{
"selectionPattern": "",
"statusCode": "200"
}
```
1. Gunakan perintah [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-deployment.html) berikut untuk menyebarkan API ke sebuah panggung: `test`
```
aws apigateway create-deployment \
--rest-api-id te6si5ach7 \
--stage-name test
```
1. Uji API menggunakan perintah cURL berikut di terminal:
```
curl -X GET 'https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/greeting?greeter=me' \
-H 'authorization: AWS4-HMAC-SHA256 Credential={access_key}/20171020/us-west-2/execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date, Signature=f327...5751'
```
# Siapkan pemanggilan asinkron dari fungsi Lambda backend
Dalam integrasi Lambda non-proxy (kustom), fungsi Lambda backend dipanggil secara sinkron secara default. Ini adalah perilaku yang diinginkan untuk sebagian besar operasi REST API. Beberapa aplikasi, bagaimanapun, memerlukan pekerjaan yang harus dilakukan secara asinkron (sebagai operasi batch atau operasi latensi panjang), biasanya oleh komponen backend terpisah. Dalam hal ini, fungsi Lambda backend dipanggil secara asinkron, dan metode REST API front-end tidak mengembalikan hasilnya.
[Anda dapat mengonfigurasi fungsi Lambda agar integrasi non-proxy Lambda dipanggil secara asinkron dengan menentukan sebagai jenis pemanggilan Lambda. `'Event'`](https://docs.aws.amazon.com/lambda/latest/dg/lambda-invocation.html) Ini dilakukan sebagai berikut:
## Konfigurasikan pemanggilan asinkron Lambda di konsol API Gateway
Agar semua pemanggilan menjadi asinkron:
+ Dalam **permintaan Integrasi**, tambahkan `X-Amz-Invocation-Type` header dengan nilai statis`'Event'`.
Bagi klien untuk memutuskan apakah pemanggilan asinkron atau sinkron:
1. Dalam **permintaan Metode**, tambahkan `InvocationType` header.
1. Dalam **permintaan Integrasi** tambahkan `X-Amz-Invocation-Type` header dengan ekspresi pemetaan. `method.request.header.InvocationType`
1. Klien dapat menyertakan `InvocationType: Event` header dalam permintaan API untuk pemanggilan asinkron atau untuk pemanggilan sinkron. `InvocationType: RequestResponse`
## Konfigurasikan pemanggilan asinkron Lambda menggunakan OpenAPI
Agar semua pemanggilan menjadi asinkron:
+ Tambahkan `X-Amz-Invocation-Type` header ke **x-amazon-apigateway-integration**bagian.
```
"x-amazon-apigateway-integration" : {
"type" : "aws",
"httpMethod" : "POST",
"uri" : "arn:aws:apigateway:us-east-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-2:123456789012:function:my-function/invocations",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.header.X-Amz-Invocation-Type" : "'Event'"
},
"passthroughBehavior" : "when_no_match",
"contentHandling" : "CONVERT_TO_TEXT"
}
```
Bagi klien untuk memutuskan apakah pemanggilan asinkron atau sinkron:
1. Tambahkan header berikut pada [OpenAPI Path Item](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#pathItemObject) Object.
```
"parameters" : [ {
"name" : "InvocationType",
"in" : "header",
"schema" : {
"type" : "string"
}
} ]
```
1. Tambahkan `X-Amz-Invocation-Type` header ke **x-amazon-apigateway-integration**bagian.
```
"x-amazon-apigateway-integration" : {
"type" : "aws",
"httpMethod" : "POST",
"uri" : "arn:aws:apigateway:us-east-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-2:123456789012:function:my-function/invocations",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.header.X-Amz-Invocation-Type" : "method.request.header.InvocationType"
},
"passthroughBehavior" : "when_no_match",
"contentHandling" : "CONVERT_TO_TEXT"
}
```
1. Klien dapat menyertakan `InvocationType: Event` header dalam permintaan API untuk pemanggilan asinkron atau untuk pemanggilan sinkron. `InvocationType: RequestResponse`
## Konfigurasikan pemanggilan asinkron Lambda menggunakan CloudFormation
CloudFormation Template berikut menunjukkan cara mengkonfigurasi `AWS::ApiGateway::Method` untuk pemanggilan asinkron.
Agar semua pemanggilan menjadi asinkron:
```
AsyncMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref AsyncResource
HttpMethod: GET
ApiKeyRequired: false
AuthorizationType: NONE
Integration:
Type: AWS
RequestParameters:
integration.request.header.X-Amz-Invocation-Type: "'Event'"
IntegrationResponses:
- StatusCode: '200'
IntegrationHttpMethod: POST
Uri: !Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${myfunction.Arn}$/invocations
MethodResponses:
- StatusCode: '200'
```
Bagi klien untuk memutuskan apakah pemanggilan asinkron atau sinkron:
```
AsyncMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref AsyncResource
HttpMethod: GET
ApiKeyRequired: false
AuthorizationType: NONE
RequestParameters:
method.request.header.InvocationType: false
Integration:
Type: AWS
RequestParameters:
integration.request.header.X-Amz-Invocation-Type: method.request.header.InvocationType
IntegrationResponses:
- StatusCode: '200'
IntegrationHttpMethod: POST
Uri: !Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${myfunction.Arn}$/invocations
MethodResponses:
- StatusCode: '200'
```
Klien dapat menyertakan `InvocationType: Event` header dalam permintaan API untuk pemanggilan asinkron atau untuk pemanggilan sinkron. `InvocationType: RequestResponse`
# Menangani kesalahan Lambda di API Gateway
Untuk integrasi kustom Lambda, Anda harus memetakan kesalahan yang dikembalikan oleh Lambda dalam respons integrasi terhadap respons kesalahan HTTP standar untuk klien Anda. Jika tidak, kesalahan Lambda dikembalikan sebagai `200 OK` respons secara default dan hasilnya tidak intuitif untuk pengguna API Anda.
Ada dua jenis kesalahan yang dapat dikembalikan Lambda: kesalahan standar dan kesalahan khusus. Di API Anda, Anda harus menangani ini secara berbeda.
Dengan integrasi proxy Lambda, Lambda diperlukan untuk mengembalikan output dari format berikut:
```
{
"isBase64Encoded" : "boolean",
"statusCode": "number",
"headers": { ... },
"body": "JSON string"
}
```
Dalam output ini, `statusCode` biasanya `4XX` untuk kesalahan klien dan `5XX` untuk kesalahan server. API Gateway menangani kesalahan ini dengan memetakan kesalahan Lambda ke respons kesalahan HTTP, sesuai dengan yang ditentukan. `statusCode` Agar API Gateway dapat meneruskan jenis kesalahan (misalnya,`InvalidParameterException`), sebagai bagian dari respons terhadap klien, fungsi Lambda harus menyertakan header (misalnya,`"X-Amzn-ErrorType":"InvalidParameterException"`) di `headers` properti.
**Topics**
+ [Menangani kesalahan Lambda standar di API Gateway](#handle-standard-errors-in-lambda-integration)
+ [Menangani kesalahan Lambda khusus di API Gateway](#handle-custom-errors-in-lambda-integration)
## Menangani kesalahan Lambda standar di API Gateway
AWS Lambda Kesalahan standar memiliki format berikut:
```
{
"errorMessage": "string",
"errorType": "string",
"stackTrace": [
"string",
...
]
}
```
Di sini, `errorMessage` adalah ekspresi string dari kesalahan. `errorType`Ini adalah kesalahan atau tipe pengecualian yang bergantung pada bahasa. `stackTrace`Ini adalah daftar ekspresi string yang menunjukkan jejak tumpukan yang mengarah ke terjadinya kesalahan.
Misalnya, perhatikan fungsi Lambda berikut JavaScript (Node.js).
```
export const handler = function(event, context, callback) {
callback(new Error("Malformed input ..."));
};
```
Fungsi ini mengembalikan kesalahan Lambda standar berikut, yang berisi `Malformed input ...` sebagai pesan kesalahan:
```
{
"errorMessage": "Malformed input ...",
"errorType": "Error",
"stackTrace": [
"export const handler (/var/task/index.js:3:14)"
]
}
```
Demikian pula, pertimbangkan fungsi Lambda Python berikut, yang memunculkan pesan kesalahan `Exception` yang sama. `Malformed input ...`
```
def lambda_handler(event, context):
raise Exception('Malformed input ...')
```
Fungsi ini mengembalikan kesalahan Lambda standar berikut:
```
{
"stackTrace": [
[
"/var/task/lambda_function.py",
3,
"lambda_handler",
"raise Exception('Malformed input ...')"
]
],
"errorType": "Exception",
"errorMessage": "Malformed input ..."
}
```
Perhatikan bahwa nilai `errorType` dan `stackTrace` properti bergantung pada bahasa. Kesalahan standar juga berlaku untuk objek kesalahan apa pun yang merupakan perpanjangan dari `Error` objek atau subkelas `Exception` kelas.
Untuk memetakan kesalahan Lambda standar ke respons metode, Anda harus terlebih dahulu memutuskan kode status HTTP untuk kesalahan Lambda yang diberikan. Anda kemudian menetapkan pola ekspresi reguler pada `[selectionPattern](https://docs.aws.amazon.com/apigateway/latest/api/API_IntegrationResponse.html#selectionPattern)` properti yang [IntegrationResponse](https://docs.aws.amazon.com/apigateway/latest/api/API_IntegrationResponse.html)terkait dengan kode status HTTP yang diberikan. Di konsol API Gateway, ini `selectionPattern` dilambangkan sebagai **regex kesalahan Lambda** di bagian **Respons Integrasi, di bawah setiap respons integrasi**.
**catatan**
API Gateway menggunakan regex gaya pola Java untuk pemetaan respons. Untuk informasi selengkapnya, lihat [Pola](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html) dalam Oracle dokumentasi.
Misalnya, gunakan yang berikut ini [put-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration-response.html)untuk menyiapkan `selectionPattern` ekspresi baru:
```
aws apigateway put-integration-response --rest-api-id z0vprf0mdh --resource-id x3o5ih --http-method GET --status-code 400 --selection-pattern "Malformed.*" --region us-west-2
```
Pastikan bahwa Anda juga mengatur kode kesalahan yang sesuai (`400`) pada [respon metode](api-gateway-method-settings-method-response.md#setup-method-response-status-code). Jika tidak, API Gateway akan menampilkan respons kesalahan konfigurasi yang tidak valid saat runtime.
**catatan**
Saat runtime, API Gateway mencocokkan kesalahan `errorMessage` Lambda dengan pola ekspresi reguler pada `selectionPattern` properti. Jika ada kecocokan, API Gateway mengembalikan kesalahan Lambda sebagai respons HTTP dari kode status HTTP yang sesuai. Jika tidak ada kecocokan, API Gateway mengembalikan kesalahan sebagai respons default atau melempar pengecualian konfigurasi yang tidak valid jika tidak ada respons default yang dikonfigurasi.
Menyetel `selectionPattern` nilai `.*` untuk respons yang diberikan berarti mengatur ulang respons ini sebagai respons default. Ini karena pola pemilihan seperti itu akan cocok dengan semua pesan kesalahan, termasuk null, yaitu, pesan kesalahan yang tidak ditentukan. Pemetaan yang dihasilkan mengesampingkan pemetaan default. Jika Anda menggunakan `.+` sebagai pola pemilihan untuk memfilter respons, itu mungkin tidak cocok dengan respons yang mengandung ketahuilah bahwa itu mungkin tidak cocok dengan respons yang berisi karakter baris baru ('`\n`).
Untuk memperbarui `selectionPattern` nilai yang ada menggunakan AWS CLI, panggil [update-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-integration-response.html)operasi untuk mengganti nilai `/selectionPattern` jalur dengan ekspresi regex yang ditentukan dari pola. `Malformed*`
Untuk mengatur `selectionPattern` ekspresi menggunakan konsol API Gateway, masukkan ekspresi di kotak teks **regex kesalahan Lambda** saat menyiapkan atau memperbarui respons integrasi kode status HTTP tertentu.
## Menangani kesalahan Lambda khusus di API Gateway
Alih-alih kesalahan standar yang dijelaskan di bagian sebelumnya, AWS Lambda memungkinkan Anda mengembalikan objek kesalahan kustom sebagai string JSON. Kesalahan dapat berupa objek JSON yang valid. Misalnya, fungsi Lambda berikut JavaScript (Node.js) mengembalikan kesalahan kustom:
```
export const handler = (event, context, callback) => {
...
// Error caught here:
var myErrorObj = {
errorType : "InternalServerError",
httpStatus : 500,
requestId : context.awsRequestId,
trace : {
"function": "abc()",
"line": 123,
"file": "abc.js"
}
}
callback(JSON.stringify(myErrorObj));
};
```
Anda harus mengubah `myErrorObj` objek menjadi string JSON sebelum memanggil `callback` untuk keluar dari fungsi. Jika tidak, `myErrorObj` dikembalikan sebagai string dari`"[object Object]"`. Saat metode API Anda terintegrasi dengan fungsi Lambda sebelumnya, API Gateway menerima respons integrasi dengan muatan berikut:
```
{
"errorMessage": "{\"errorType\":\"InternalServerError\",\"httpStatus\":500,\"requestId\":\"e5849002-39a0-11e7-a419-5bb5807c9fb2\",\"trace\":{\"function\":\"abc()\",\"line\":123,\"file\":\"abc.js\"}}"
}
```
Seperti halnya respons integrasi apa pun, Anda dapat melewati respons kesalahan ini apa adanya terhadap respons metode. Atau Anda dapat memiliki template pemetaan untuk mengubah payload menjadi format yang berbeda. Misalnya, pertimbangkan template pemetaan tubuh berikut untuk respons metode kode status`500`:
```
{
errorMessage: $input.path('$.errorMessage');
}
```
Template ini menerjemahkan badan respons integrasi yang berisi string JSON kesalahan kustom ke badan respons metode berikut. Badan respons metode ini berisi objek JSON kesalahan kustom:
```
{
"errorMessage" : {
errorType : "InternalServerError",
httpStatus : 500,
requestId : context.awsRequestId,
trace : {
"function": "abc()",
"line": 123,
"file": "abc.js"
}
}
};
```
Bergantung pada persyaratan API Anda, Anda mungkin perlu meneruskan beberapa atau semua properti kesalahan kustom sebagai parameter header respons metode. Anda dapat mencapai ini dengan menerapkan pemetaan kesalahan kustom dari badan respons integrasi ke header respons metode.
Misalnya, ekstensi OpenAPI berikut mendefinisikan pemetaan dari`errorMessage.errorType`,,, dan `errorMessage.trace` properti ke `errorMessage.httpStatus``errorMessage.trace.function`,,, dan `error_type` header `error_status``error_trace_function`, masing-masing. `error_trace`
```
"x-amazon-apigateway-integration": {
"responses": {
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.error_trace_function": "integration.response.body.errorMessage.trace.function",
"method.response.header.error_status": "integration.response.body.errorMessage.httpStatus",
"method.response.header.error_type": "integration.response.body.errorMessage.errorType",
"method.response.header.error_trace": "integration.response.body.errorMessage.trace"
},
...
}
}
}
```
Saat runtime, API Gateway melakukan deserialisasi `integration.response.body` parameter saat melakukan pemetaan header. Namun, deserialisasi ini hanya berlaku untuk body-to-header pemetaan untuk respons kesalahan khusus Lambda dan tidak berlaku untuk pemetaan yang menggunakan. body-to-body `$input.body` Dengan pemetaan custom-error-body-to -header ini, klien menerima header berikut sebagai bagian dari respons metode, asalkan,, `error_status` `error_trace``error_trace_function`, dan `error_type` header dideklarasikan dalam permintaan metode.
```
"error_status":"500",
"error_trace":"{\"function\":\"abc()\",\"line\":123,\"file\":\"abc.js\"}",
"error_trace_function":"abc()",
"error_type":"InternalServerError"
```
`errorMessage.trace`Properti badan respons integrasi adalah properti yang kompleks. Hal ini dipetakan ke `error_trace` header sebagai string JSON.