Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial dan lokakarya Amazon API Gateway
Tutorial dan lokakarya berikut menyediakan latihan langsung untuk membantu Anda mempelajari API Gateway. Untuk memulai, kami sarankan Anda menyelesaikannya[Tutorial: Buat REST API dengan integrasi proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).
**Tutorial REST API**
+ [Pilih tutorial AWS Lambda integrasi](getting-started-with-lambda-integration.md)
+ [Tutorial: Buat REST API dengan mengimpor contoh](api-gateway-create-api-from-example.md)
+ [Pilih tutorial integrasi HTTP](getting-started-http-integrations.md)
+ [Tutorial: Buat REST API dengan integrasi pribadi](getting-started-with-private-integration.md)
+ [Tutorial: Buat REST API dengan AWS integrasi](getting-started-aws-proxy.md)
+ [Tutorial: Buat REST API kalkulator dengan dua integrasi AWS layanan dan satu integrasi non-proxy Lambda](integrating-api-with-aws-services-lambda.md)
+ [Tutorial: Buat REST API sebagai proxy Amazon S3](integrating-api-with-aws-services-s3.md)
+ [Tutorial: Buat REST API sebagai proxy Amazon Kinesis](integrating-api-with-aws-services-kinesis.md)
+ [Tutorial: Buat REST API menggunakan AWS SDKs atau AWS CLI](api-gateway-create-api-cli-sdk.md)
+ [Tutorial: Membuat REST API pribadi](private-api-tutorial.md)
**HTTP API tutorial**
+ [Tutorial: Buat API HTTP CRUD dengan Lambda dan DynamoDB](http-api-dynamo-db.md)
+ [Tutorial: Buat API HTTP dengan integrasi pribadi ke layanan Amazon ECS](http-api-private-integration.md)
**WebSocket API tutorial**
+ [Tutorial: Buat aplikasi WebSocket obrolan dengan WebSocket API, Lambda, dan DynamoDB](websocket-api-chat-app.md)
**Lokakarya**
+ [Membangun aplikasi web tanpa server](https://webapp.serverlessworkshops.io)
+ [CI/CD untuk aplikasi tanpa server](https://cicd.serverlessworkshops.io)
+ [Bengkel keamanan tanpa server](https://github.com/aws-samples/aws-serverless-security-workshop)
+ [Manajemen identitas tanpa server, otentikasi dan otorisasi](https://auth.serverlessworkshops.io)
+ [Lokakarya Amazon API Gateway](https://catalog.workshops.aws/apigateway/en-US)
# Tutorial API REST API Amazon API Gateway
Tutorial berikut menyediakan latihan langsung untuk membantu Anda mempelajari API Gateway REST. APIs
**Topics**
+ [Pilih tutorial AWS Lambda integrasi](getting-started-with-lambda-integration.md)
+ [Tutorial: Buat REST API dengan mengimpor contoh](api-gateway-create-api-from-example.md)
+ [Pilih tutorial integrasi HTTP](getting-started-http-integrations.md)
+ [Tutorial: Buat REST API dengan integrasi pribadi](getting-started-with-private-integration.md)
+ [Tutorial: Buat REST API dengan AWS integrasi](getting-started-aws-proxy.md)
+ [Tutorial: Buat REST API kalkulator dengan dua integrasi AWS layanan dan satu integrasi non-proxy Lambda](integrating-api-with-aws-services-lambda.md)
+ [Tutorial: Buat REST API sebagai proxy Amazon S3](integrating-api-with-aws-services-s3.md)
+ [Tutorial: Buat REST API sebagai proxy Amazon Kinesis](integrating-api-with-aws-services-kinesis.md)
+ [Tutorial: Buat REST API menggunakan AWS SDKs atau AWS CLI](api-gateway-create-api-cli-sdk.md)
+ [Tutorial: Membuat REST API pribadi](private-api-tutorial.md)
# Pilih tutorial AWS Lambda integrasi
Untuk membangun API dengan integrasi Lambda, Anda dapat menggunakan integrasi proxy Lambda atau integrasi non-proxy Lambda.
Dalam integrasi proxy Lambda, input ke fungsi Lambda dapat dinyatakan sebagai kombinasi header permintaan, variabel jalur, parameter string kueri, isi, dan data konfigurasi API. Anda hanya perlu memilih fungsi Lambda. API Gateway mengonfigurasi permintaan integrasi dan respons integrasi untuk Anda. Setelah disiapkan, metode API Anda dapat berkembang tanpa mengubah pengaturan yang ada. Ini dimungkinkan karena fungsi backend Lambda mem-parsing data permintaan yang masuk dan merespons klien.
Dalam integrasi non-proxy Lambda, Anda harus memastikan bahwa input ke fungsi Lambda disediakan sebagai payload permintaan integrasi. Anda harus memetakan data input apa pun yang diberikan klien sebagai parameter permintaan ke dalam badan permintaan integrasi yang tepat. Anda mungkin juga perlu menerjemahkan badan permintaan yang disediakan klien ke dalam format yang dikenali oleh fungsi Lambda.
Baik dalam proxy Lambda atau integrasi non-proxy Lambda, Anda dapat menggunakan fungsi Lambda di akun yang berbeda dari akun tempat Anda membuat API.
**Topics**
+ [Tutorial: Buat REST API dengan integrasi proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md)
+ [Tutorial: Buat REST API dengan integrasi non-proxy Lambda](getting-started-lambda-non-proxy-integration.md)
+ [Tutorial: Buat REST API dengan integrasi proxy Lambda lintas akun](apigateway-cross-account-lambda-integrations.md)
# Tutorial: Buat REST API dengan integrasi proxy Lambda
[Integrasi proxy Lambda adalah jenis integrasi](set-up-lambda-proxy-integrations.md) API Gateway API yang ringan dan fleksibel yang memungkinkan Anda mengintegrasikan metode API — atau seluruh API — dengan fungsi Lambda. Fungsi Lambda dapat ditulis dalam [bahasa apa pun yang didukung Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). Karena ini adalah integrasi proxy, Anda dapat mengubah implementasi fungsi Lambda kapan saja tanpa perlu menerapkan ulang API Anda.
Dalam tutorial ini, Anda akan melakukan hal-hal berikut:
+ Buat “Halo, Dunia\$1” Lambda berfungsi sebagai backend untuk API.
+ Buat dan uji “Halo, Dunia\$1” API dengan integrasi proxy Lambda.
**Topics**
+ [Buat “Halo, Dunia\$1” Fungsi Lambda](#api-gateway-proxy-integration-create-lambda-backend)
+ [Buat “Halo, Dunia\$1” API](#api-gateway-create-api-as-simple-proxy-for-lambda-build)
+ [Menerapkan dan menguji API](#api-gateway-create-api-as-simple-proxy-for-lambda-test)
## Buat “Halo, Dunia\$1” Fungsi Lambda
**Untuk membuat “Halo, Dunia\$1” Fungsi Lambda di konsol Lambda**
1. [Masuk ke konsol Lambda di https://console.aws.amazon.com /lambda.](https://console.aws.amazon.com/lambda)
1. Pada bilah AWS navigasi, pilih file [Wilayah AWS](https://docs.aws.amazon.com/general/latest/gr/apigateway.html).
**catatan**
Perhatikan wilayah tempat Anda membuat fungsi Lambda. Anda akan membutuhkannya saat membuat API.
1. Pilih **Fungsi** di panel navigasi.
1. Pilih **Buat fungsi**.
1. Pilih **Penulis dari scratch**.
1. Di bagian **Informasi dasar**, lakukan hal berikut:
1. Dalam **nama Fungsi**, masukkan**GetStartedLambdaProxyIntegration**.
1. Untuk **Runtime, pilih runtime** **Node.js** atau **Python** terbaru yang didukung.
1. Untuk **Arsitektur**, pertahankan pengaturan default.
1. (Opsional) Di bagian **Izin**, luaskan **Ubah peran eksekusi default**. Untuk daftar dropdown **peran eksekusi**, pilih **Buat peran baru dari templat AWS kebijakan**.
1. Dalam **nama Peran**, masukkan**GetStartedLambdaBasicExecutionRole**.
1. Biarkan bidang **Policy templates** kosong.
1. Pilih **Buat fungsi**.
1. Di bawah **Kode fungsi**, dalam editor kode inline, kode copy/paste berikut:
------
#### [ Node.js ]
```
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
};
```
------
#### [ Python ]
```
import json
def lambda_handler(event, context):
print(event)
greeter = 'World'
try:
if (event['queryStringParameters']) and (event['queryStringParameters']['greeter']) and (
event['queryStringParameters']['greeter'] is not None):
greeter = event['queryStringParameters']['greeter']
except KeyError:
print('No greeter')
try:
if (event['multiValueHeaders']) and (event['multiValueHeaders']['greeter']) and (
event['multiValueHeaders']['greeter'] is not None):
greeter = " and ".join(event['multiValueHeaders']['greeter'])
except KeyError:
print('No greeter')
try:
if (event['headers']) and (event['headers']['greeter']) and (
event['headers']['greeter'] is not None):
greeter = event['headers']['greeter']
except KeyError:
print('No greeter')
if (event['body']) and (event['body'] is not None):
body = json.loads(event['body'])
try:
if (body['greeter']) and (body['greeter'] is not None):
greeter = body['greeter']
except KeyError:
print('No greeter')
res = {
"statusCode": 200,
"headers": {
"Content-Type": "*/*"
},
"body": "Hello, " + greeter + "!"
}
return res
```
------
1. Pilih **Deploy**.
## Buat “Halo, Dunia\$1” API
Sekarang buat API untuk “Hello, World\$1” Lambda berfungsi dengan menggunakan konsol API Gateway.
**Untuk membuat “Halo, Dunia\$1” API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Jika ini adalah pertama kalinya Anda menggunakan API Gateway, Anda akan melihat halaman yang memperkenalkan Anda ke fitur layanan. Di bawah **REST API**, pilih **Build**. **Saat munculan **Create Example API** muncul, pilih OK.**
Jika ini bukan pertama kalinya Anda menggunakan API Gateway, pilih **Buat API**. Di bawah **REST API**, pilih **Build**.
1. Untuk **nama API**, masukkan**LambdaProxyAPI**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Tetap tetapkan **jenis endpoint API** ke **Regional**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Buat API**.
Setelah membuat API, Anda membuat sumber daya. Biasanya, sumber daya API diatur dalam pohon sumber daya sesuai dengan logika aplikasi. Untuk contoh ini, Anda membuat sumber daya **/helloworld**.
**Untuk membuat sumber daya**
1. Pilih **Buat sumber daya**.
1. Matikan **sumber daya Proxy**.
1. Pertahankan **jalur Sumber Daya** sebagai`/`.
1. Untuk **Nama sumber daya**, masukkan **helloworld**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
Dalam integrasi proxy, seluruh permintaan dikirim ke fungsi Lambda backend apa adanya, melalui metode catch-all `ANY` yang mewakili metode HTTP apa pun. Metode HTTP sebenarnya ditentukan oleh klien pada waktu berjalan. `ANY`Metode ini memungkinkan Anda untuk menggunakan penyiapan metode API tunggal untuk semua metode HTTP yang didukung:`DELETE`,`GET`,`HEAD`,`OPTIONS`,`PATCH`,`POST`, dan`PUT`.
**Untuk membuat `ANY` metode**
1. **Pilih sumber daya **/helloworld**, lalu pilih Create method.**
1. Untuk **jenis Metode**, pilih **APAPUN**.
1. Untuk **jenis Integrasi**, pilih fungsi **Lambda**.
1. Aktifkan **integrasi proxy Lambda**.
1. Untuk **fungsi Lambda**, pilih Wilayah AWS tempat Anda membuat fungsi Lambda Anda, lalu masukkan nama fungsi.
1. Untuk menggunakan nilai batas waktu default 29 detik, tetap aktifkan **batas waktu default**. Untuk menetapkan batas waktu kustom, pilih Batas **waktu default** dan masukkan nilai batas waktu antara `50` dan milidetik. `29000`
1. Pilih **metode Buat**.
## Menerapkan dan menguji API
**Untuk men-deploy API Anda**
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **New stage**.
1. Untuk **nama Panggung**, masukkan**test**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
1. Di bawah **Detail tahap**, pilih ikon salin untuk menyalin URL pemanggilan API Anda.
### Gunakan browser dan cURL untuk menguji API dengan integrasi proxy Lambda
Anda dapat menggunakan browser atau [cURL](https://curl.se/) untuk menguji API Anda.
Untuk menguji `GET` permintaan hanya menggunakan parameter string kueri, Anda dapat memasukkan URL untuk `helloworld` sumber daya API ke dalam bilah alamat browser.
Untuk membuat URL sumber daya API, tambahkan `helloworld` sumber daya `helloworld` dan parameter `?greeter=John` string kueri ke URL pemanggilan Anda. URL Anda akan terlihat seperti berikut ini.
```
https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John
```
Untuk metode lain, Anda harus menggunakan utilitas pengujian REST API yang lebih canggih, seperti [POSTMAN](https://www.postman.com/) atau [cURL](https://curl.se/). Tutorial ini menggunakan cURL. Contoh perintah cURL di bawah ini mengasumsikan bahwa cURL diinstal pada komputer Anda.
**Untuk menguji API yang Anda gunakan menggunakan cURL:**
1. Buka jendela terminal.
1. Salin perintah cURL berikut dan tempel ke jendela terminal, dan ganti URL pemanggilan dengan yang Anda salin di langkah sebelumnya dan tambahkan **/helloworld** ke akhir URL.
**catatan**
Jika Anda menjalankan perintah di Windows, gunakan sintaks ini sebagai gantinya:
```
curl -v -X POST "https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld" -H "content-type: application/json" -d "{ \"greeter\": \"John\" }"
```
1. Untuk memanggil API dengan parameter string kueri`?greeter=John`:
```
curl -X GET 'https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John'
```
1. Untuk memanggil API dengan parameter header`greeter:John`:
```
curl -X GET https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
-H 'content-type: application/json' \
-H 'greeter: John'
```
1. Untuk memanggil API dengan badan`{"greeter":"John"}`:
```
curl -X POST https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
-H 'content-type: application/json' \
-d '{ "greeter": "John" }'
```
Dalam semua kasus, outputnya adalah respons 200 dengan badan respons berikut:
```
Hello, John!
```
# Tutorial: Buat REST API dengan integrasi non-proxy Lambda
Dalam panduan ini, kami menggunakan konsol API Gateway untuk membangun API yang memungkinkan klien memanggil fungsi Lambda melalui integrasi non-proxy Lambda (juga dikenal sebagai integrasi khusus). Untuk informasi selengkapnya tentang AWS Lambda dan fungsi Lambda, lihat Panduan [AWS Lambda Pengembang](https://docs.aws.amazon.com/lambda/latest/dg/).
Untuk memfasilitasi pembelajaran, kami memilih fungsi Lambda sederhana dengan pengaturan API minimal untuk memandu Anda melalui langkah-langkah membangun API Gateway API dengan integrasi kustom Lambda. Bila perlu, kami menjelaskan beberapa logika. Untuk contoh lebih rinci tentang integrasi kustom Lambda, lihat. [Tutorial: Buat REST API kalkulator dengan dua integrasi AWS layanan dan satu integrasi non-proxy Lambda](integrating-api-with-aws-services-lambda.md)
Sebelum membuat API, siapkan backend Lambda dengan membuat fungsi Lambda di, dijelaskan selanjutnya. AWS Lambda
**Topics**
+ [Buat fungsi Lambda untuk integrasi non-proxy Lambda](#getting-started-new-lambda)
+ [Buat API dengan integrasi non-proxy Lambda](#getting-started-new-api)
+ [Uji pemanggilan metode API](#getting-started-new-get)
+ [Terapkan API](#getting-started-deploy-api)
+ [Uji API dalam tahap penerapan](#getting-started-test)
+ [Bersihkan](#getting-started-clean-up)
## Buat fungsi Lambda untuk integrasi non-proxy Lambda
**catatan**
Membuat fungsi Lambda dapat mengakibatkan biaya ke akun Anda AWS .
Pada langkah ini, Anda membuat “Halo, Dunia\$1” -seperti fungsi Lambda untuk integrasi kustom Lambda. Sepanjang panduan ini, fungsi ini disebut. `GetStartedLambdaIntegration`
Implementasi fungsi `GetStartedLambdaIntegration` Lambda ini adalah sebagai 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": greeting}
};
```
------
#### [ Python ]
```
import json
days = {
'Sunday',
'Monday',
'Tuesday',
'Wednesday',
'Thursday',
'Friday',
'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}
def lambda_handler(event, context):
print(event)
# parse the input for the name, city, time, and day property values
name = event.get("name") or 'you'
city = event.get("city") or 'World'
try:
if event['time'] in times:
time = event['time']
else:
time = 'day'
except KeyError:
time = 'day'
try:
if event['day'] in days:
day = event['day']
else:
day = ''
except KeyError:
day = ''
# Generate a greeting
greeting = 'Good ' + time + ', ' + name + ' of ' + \
city + '.' + ['', ' Happy ' + day + '!'][day != '']
# Log the greeting to CloudWatch
print(greeting)
# Return a greeting to the caller
return {"greeting": greeting}
```
------
Untuk integrasi kustom Lambda, API Gateway meneruskan input ke fungsi Lambda dari klien sebagai badan permintaan integrasi. `event`Objek dari fungsi handler Lambda adalah input.
Fungsi Lambda kami sederhana. Ini mem-parsing `event` objek input untuk`name`,, `city``time`, dan `day` properti. Kemudian mengembalikan salam, sebagai objek JSON dari`{"message":greeting}`, ke penelepon. Pesannya ada dalam `"Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!"` pola. Diasumsikan bahwa input ke fungsi Lambda adalah dari objek JSON berikut:
```
{
"city": "...",
"time": "...",
"day": "...",
"name" : "..."
}
```
Lihat informasi selengkapnya di [Panduan Developer AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).
Selain itu, fungsi mencatat eksekusinya ke Amazon CloudWatch dengan menelepon`console.log(...)`. Ini berguna untuk melacak panggilan saat men-debug fungsi. Untuk mengizinkan `GetStartedLambdaIntegration` fungsi mencatat panggilan, tetapkan peran IAM dengan kebijakan yang sesuai untuk fungsi Lambda untuk membuat CloudWatch aliran dan menambahkan entri log ke aliran. Konsol Lambda memandu Anda untuk membuat peran dan kebijakan IAM yang diperlukan.
Jika Anda menyiapkan API tanpa menggunakan konsol API Gateway, seperti saat [mengimpor API dari file OpenAPI](https://github.com/aws-samples/api-gateway-secure-pet-store/blob/master/src/main/resources/swagger.yaml#L39), Anda harus secara eksplisit membuat, jika perlu, dan menyiapkan peran dan kebijakan pemanggilan untuk API Gateway untuk menjalankan fungsi Lambda. Untuk informasi selengkapnya tentang cara menyiapkan peran pemanggilan dan eksekusi Lambda untuk API Gateway API, lihat. [Kontrol akses ke REST API dengan izin IAM](permissions.md)
Dibandingkan dengan`GetStartedLambdaProxyIntegration`, fungsi Lambda untuk integrasi proxy Lambda, fungsi Lambda untuk integrasi kustom `GetStartedLambdaIntegration` Lambda hanya mengambil masukan dari badan permintaan integrasi API Gateway API. Fungsi ini dapat mengembalikan output dari setiap objek JSON, string, angka, Boolean, atau bahkan blob biner. Fungsi Lambda untuk integrasi proxy Lambda, sebaliknya, dapat mengambil input dari data permintaan apa pun, tetapi harus mengembalikan output dari objek JSON tertentu. `GetStartedLambdaIntegration`Fungsi untuk integrasi kustom Lambda dapat memiliki parameter permintaan API sebagai input, asalkan API Gateway memetakan parameter permintaan API yang diperlukan ke badan permintaan integrasi sebelum meneruskan permintaan klien ke backend. Agar hal ini terjadi, pengembang API harus membuat template pemetaan dan mengonfigurasinya pada metode API saat membuat API.
Sekarang, buat fungsi `GetStartedLambdaIntegration` Lambda.
**Untuk membuat fungsi `GetStartedLambdaIntegration` Lambda untuk integrasi kustom Lambda**
1. Buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Lakukan salah satu tindakan berikut:
+ Jika halaman selamat datang muncul, pilih **Mulai Sekarang** dan kemudian pilih **Buat fungsi**.
+ Jika halaman daftar **Lambda > Fungsi** muncul, pilih **Buat** fungsi.
1. Pilih **Tulis dari awal**.
1. Di panel **Penulis dari awal**, lakukan hal berikut:
1. Untuk **Nama**, masukkan **GetStartedLambdaIntegration** sebagai nama fungsi Lambda.
1. Untuk **Runtime, pilih runtime** **Node.js** atau **Python** terbaru yang didukung.
1. Untuk **Arsitektur**, pertahankan pengaturan default.
1. (Opsional) Di bagian **Izin**, luaskan **Ubah peran eksekusi default**. Untuk daftar dropdown **peran eksekusi**, pilih **Buat peran baru dari templat AWS kebijakan**.
1. Untuk **nama Peran**, masukkan nama untuk peran Anda (misalnya,**GetStartedLambdaIntegrationRole**).
1. Untuk **templat Kebijakan**, pilih **Izin microservice sederhana**.
1. Pilih **Buat fungsi**.
1. Di panel **Configure function**, di bawah **Kode fungsi** lakukan hal berikut:
1. Salin kode fungsi Lambda yang tercantum di awal bagian ini dan tempel di editor kode sebaris.
1. Tinggalkan pilihan default untuk semua bidang lain di bagian ini.
1. Pilih **Deploy**.
1. Untuk menguji fungsi yang baru dibuat, pilih tab **Uji**.
1. Untuk **Nama peristiwa**, masukkan **HelloWorldTest**.
1. Untuk **Event JSON**, ganti kode default dengan yang berikut ini.
```
{
"name": "Jonny",
"city": "Seattle",
"time": "morning",
"day": "Wednesday"
}
```
1. Pilih **Uji** untuk menjalankan fungsi. **Hasil eksekusi: bagian berhasil** ditampilkan. Perluas **Detail** dan Anda melihat output berikut.
```
{
"greeting": "Good morning, Jonny of Seattle. Happy Wednesday!"
}
```
Outputnya juga ditulis ke CloudWatch Log.
Sebagai latihan sampingan, Anda dapat menggunakan konsol IAM untuk melihat peran IAM (`GetStartedLambdaIntegrationRole`) yang dibuat sebagai bagian dari pembuatan fungsi Lambda. Terlampir pada peran IAM ini adalah dua kebijakan inline. Satu menetapkan izin paling dasar untuk eksekusi Lambda. Ini memungkinkan memanggil CloudWatch sumber daya apa pun dari akun Anda di wilayah tempat fungsi Lambda dibuat. CloudWatch `CreateLogGroup` Kebijakan ini juga memungkinkan pembuatan CloudWatch stream dan peristiwa logging untuk fungsi `GetStartedLambdaIntegration` Lambda.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "logs:CreateLogGroup",
"Resource": "arn:aws:logs:us-east-1:111111111111:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111111111111:log-group:/aws/lambda/GetStartedLambdaIntegration:*"
]
}
]
}
```
------
Dokumen kebijakan lainnya berlaku untuk memanggil AWS layanan lain yang tidak digunakan dalam contoh ini. Anda dapat melewatkannya untuk saat ini.
Terkait dengan peran IAM adalah entitas tepercaya, yaitu`lambda.amazonaws.com`. Inilah hubungan kepercayaannya:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Kombinasi hubungan kepercayaan ini dan kebijakan sebaris memungkinkan fungsi Lambda memanggil fungsi untuk mencatat peristiwa ke `console.log()` Log. CloudWatch
## Buat API dengan integrasi non-proxy Lambda
Dengan fungsi Lambda (`GetStartedLambdaIntegration`) yang dibuat dan diuji, Anda siap mengekspos fungsi tersebut melalui API Gateway API. Untuk tujuan ilustrasi, kami mengekspos fungsi Lambda dengan metode HTTP generik. Kami menggunakan badan permintaan, variabel jalur URL, string kueri, dan header untuk menerima data input yang diperlukan dari klien. Kami mengaktifkan validator permintaan API Gateway untuk API untuk memastikan bahwa semua data yang diperlukan didefinisikan dan ditentukan dengan benar. Kami mengonfigurasi template pemetaan untuk API Gateway untuk mengubah data permintaan yang disediakan klien menjadi format yang valid seperti yang dipersyaratkan oleh fungsi Lambda backend.
**Untuk membuat API dengan integrasi non-proxy Lambda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Jika ini adalah pertama kalinya Anda menggunakan API Gateway, Anda akan melihat halaman yang memperkenalkan Anda ke fitur layanan. Di bawah **REST API**, pilih **Build**. **Saat munculan **Create Example API** muncul, pilih OK.**
Jika ini bukan pertama kalinya Anda menggunakan API Gateway, pilih **Buat API**. Di bawah **REST API**, pilih **Build**.
1. Untuk **nama API**, masukkan**LambdaNonProxyAPI**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Tetap tetapkan **jenis endpoint API** ke **Regional**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Buat API**.
Setelah membuat API Anda, Anda membuat sumber daya**/\$1city\$1**. Ini adalah contoh sumber daya dengan variabel jalur yang mengambil masukan dari klien. Kemudian, Anda memetakan variabel jalur ini ke input fungsi Lambda menggunakan template pemetaan.
**Untuk membuat sumber daya**
1. Pilih **Buat sumber daya**.
1. Matikan **sumber daya Proxy**.
1. Pertahankan **jalur Sumber Daya** sebagai`/`.
1. Untuk **Nama sumber daya**, masukkan **\$1city\$1**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
Setelah membuat sumber daya**/\$1city\$1** Anda, Anda membuat `ANY` metode. Kata kerja `ANY` HTTP adalah placeholder untuk metode HTTP yang valid yang klien kirimkan pada waktu berjalan. Contoh ini menunjukkan bahwa `ANY` metode dapat digunakan untuk integrasi kustom Lambda serta untuk integrasi proxy Lambda.
**Untuk membuat `ANY` metode**
1. Pilih sumber daya**/\$1city\$1**, lalu pilih **Create method**.
1. Untuk **jenis Metode**, pilih **APAPUN**.
1. Untuk **jenis Integrasi**, pilih fungsi **Lambda**.
1. Matikan **integrasi proxy Lambda**.
1. Untuk **fungsi Lambda**, pilih Wilayah AWS tempat Anda membuat fungsi Lambda Anda, lalu masukkan nama fungsi.
1. Pilih **Pengaturan permintaan Metode.**
Sekarang, Anda mengaktifkan validator permintaan untuk variabel jalur URL, parameter string kueri, dan header untuk memastikan bahwa semua data yang diperlukan ditentukan. Untuk contoh ini, Anda membuat parameter string `time` kueri dan `day` header.
1. Untuk **validator Permintaan**, pilih **Validasi parameter string kueri** dan header.
1. Pilih **parameter string kueri URL** dan lakukan hal berikut:
1. Pilih **Tambahkan string kueri**.
1. Untuk **Nama**, masukkan **time**.
1. Aktifkan **Diperlukan**.
1. Tetap **caching** dimatikan.
1. Pilih **header permintaan HTTP** dan lakukan hal berikut:
1. Pilih **Tambahkan header**.
1. Untuk **Nama**, masukkan **day**.
1. Aktifkan **Diperlukan**.
1. Tetap **caching** dimatikan.
1. Pilih **metode Buat**.
Setelah mengaktifkan validator permintaan, Anda mengonfigurasi permintaan integrasi untuk `ANY` metode dengan menambahkan templat pemetaan tubuh untuk mengubah permintaan yang masuk menjadi payload JSON, seperti yang dipersyaratkan oleh fungsi Lambda backend.
**Untuk mengkonfigurasi permintaan integrasi**
1. Pada tab **Permintaan integrasi**, di bawah **pengaturan permintaan Integrasi**, pilih **Edit**.
1. Untuk **Request body passthrough**, pilih **Bila tidak ada templat yang ditentukan (disarankan)**.
1. Pilih **Template pemetaan**.
1. Pilih **Tambahkan templat pemetaan**.
1. Untuk **jenis Konten**, masukkan**application/json**.
1. Untuk **badan Template**, masukkan kode berikut:
```
#set($inputRoot = $input.path('$'))
{
"city": "$input.params('city')",
"time": "$input.params('time')",
"day": "$input.params('day')",
"name": "$inputRoot.callerName"
}
```
1. Pilih **Simpan**.
## Uji pemanggilan metode API
Konsol API Gateway menyediakan fasilitas pengujian bagi Anda untuk menguji pemanggilan API sebelum diterapkan. Anda menggunakan fitur Uji konsol untuk menguji API dengan mengirimkan permintaan berikut:
```
POST /Seattle?time=morning
day:Wednesday
{
"callerName": "John"
}
```
Dalam permintaan pengujian ini, Anda akan mengatur `ANY` ke`POST`, mengatur `{city}` ke`Seattle`, menetapkan `Wednesday` sebagai nilai `day` header, dan menetapkan `"John"` sebagai nilai`callerName`.
**Untuk menguji `ANY` metode**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Untuk **jenis Metode**, pilih`POST`.
1. Untuk **Path**, di bawah **kota**, masuk**Seattle**.
1. Untuk **string Query**, masukkan**time=morning**.
1. Untuk **Header**, masukkan**day:Wednesday**.
1. Untuk **Badan Permintaan**, masukkan**\$1 "callerName": "John" \$1**.
1. Pilih **Uji**.
Verifikasi bahwa muatan respons yang dikembalikan adalah sebagai berikut:
```
{
"greeting": "Good morning, John of Seattle. Happy Wednesday!"
}
```
Anda juga dapat melihat log untuk memeriksa bagaimana API Gateway memproses permintaan dan respons.
```
Execution log for request test-request
Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations: { "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-tag=test-request, Authorization=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid, X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs++ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
"city": "Seattle",
"time": "morning",
"day": "Wednesday",
"name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200
```
Log menampilkan permintaan masuk sebelum pemetaan dan permintaan integrasi setelah pemetaan. Ketika pengujian gagal, log berguna untuk mengevaluasi apakah input asli benar atau template pemetaan berfungsi dengan benar.
## Terapkan API
Doa tes adalah simulasi dan memiliki keterbatasan. Misalnya, ia melewati mekanisme otorisasi apa pun yang diberlakukan pada API. Untuk menguji eksekusi API secara real time, Anda harus menerapkan API terlebih dahulu. Untuk menerapkan API, Anda membuat tahapan untuk membuat snapshot API pada saat itu. Nama stage juga mendefinisikan path dasar setelah nama host default API. Sumber daya root API ditambahkan setelah nama panggung. Saat memodifikasi API, Anda harus menerapkannya kembali ke tahap baru atau yang sudah ada sebelum perubahan diterapkan.
**Untuk menerapkan API ke panggung**
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **New stage**.
1. Untuk **nama Panggung**, masukkan**test**.
**catatan**
Input harus berupa teks yang dikodekan UTF-8 (yaitu, tidak terlokalisasi).
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
Di bawah **Detail tahap**, pilih ikon salin untuk menyalin URL pemanggilan API Anda. Pola umum URL dasar API adalah`https://api-id.region.amazonaws.com/stageName`. Misalnya, URL dasar API (`beags1mnid`) yang dibuat di `us-west-2` wilayah dan diterapkan ke `test` panggung adalah`https://beags1mnid.execute-api.us-west-2.amazonaws.com/test`.
## Uji API dalam tahap penerapan
Ada beberapa cara Anda dapat menguji API yang diterapkan. Untuk permintaan GET yang hanya menggunakan variabel jalur URL atau parameter string kueri, Anda dapat memasukkan URL sumber daya API di browser. Untuk metode lain, Anda harus menggunakan utilitas pengujian REST API yang lebih canggih, seperti [POSTMAN](https://www.postman.com/) atau [cURL](https://curl.se/).
**Untuk menguji API menggunakan cURL**
1. Buka jendela terminal di komputer lokal Anda yang terhubung ke internet.
1. Untuk menguji`POST /Seattle?time=evening`:
Salin perintah cURL berikut dan tempel ke jendela terminal.
```
curl -v -X POST \
'https://beags1mnid.execute-api.us-west-2.amazonaws.com/test/Seattle?time=evening' \
-H 'content-type: application/json' \
-H 'day: Thursday' \
-H 'x-amz-docs-region: us-west-2' \
-d '{
"callerName": "John"
}'
```
Anda harus mendapatkan respons yang sukses dengan muatan berikut:
```
{"greeting":"Good evening, John of Seattle. Happy Thursday!"}
```
Jika Anda `POST` mengubah `PUT` permintaan metode ini, Anda mendapatkan respons yang sama.
## Bersihkan
Jika Anda tidak lagi membutuhkan fungsi Lambda yang Anda buat untuk panduan ini, Anda dapat menghapusnya sekarang. Anda juga dapat menghapus sumber daya IAM yang menyertainya.
**Awas**
Jika Anda berencana untuk menyelesaikan penelusuran lain dalam seri ini, jangan hapus peran eksekusi Lambda atau peran pemanggilan Lambda. Jika Anda menghapus fungsi Lambda yang Anda APIs andalkan, fungsi tersebut tidak APIs akan berfungsi lagi. Menghapus fungsi Lambda tidak dapat dibatalkan. Jika Anda ingin menggunakan fungsi Lambda lagi, Anda harus membuat ulang fungsi tersebut.
Jika Anda menghapus sumber daya IAM yang bergantung pada fungsi Lambda, fungsi Lambda itu tidak akan berfungsi lagi, dan APIs semua yang bergantung pada fungsi itu tidak akan berfungsi lagi. Menghapus sumber daya IAM tidak dapat dibatalkan. Jika Anda ingin menggunakan sumber daya IAM lagi, Anda harus membuat ulang sumber daya.
**Untuk menghapus fungsi Lambda**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Dari daftar fungsi, pilih **GetStartedLambdaIntegration**, pilih **Tindakan**, lalu pilih **Hapus fungsi**. Saat diminta, pilih **Hapus** lagi.
**Untuk menghapus sumber daya IAM terkait**
1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Dari **Detail**, pilih **Peran**.
1. Dari daftar peran, pilih **GetStartedLambdaIntegrationRole**, pilih **Tindakan Peran**, lalu pilih **Hapus Peran**. Ikuti langkah-langkah di konsol untuk menghapus peran.
# Tutorial: Buat REST API dengan integrasi proxy Lambda lintas akun
Anda sekarang dapat menggunakan AWS Lambda fungsi dari AWS akun yang berbeda sebagai backend integrasi API Anda. Setiap akun dapat berada di wilayah mana pun di mana Amazon API Gateway tersedia. Ini membuatnya mudah untuk mengelola dan berbagi fungsi backend Lambda secara terpusat di beberapa. APIs
Di bagian ini, kami menunjukkan cara mengonfigurasi integrasi proxy Lambda lintas akun menggunakan konsol Amazon API Gateway.
## Buat API untuk integrasi Lambda lintas akun API Gateway
**Untuk membuat API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Jika ini adalah pertama kalinya Anda menggunakan API Gateway, Anda akan melihat halaman yang memperkenalkan Anda ke fitur layanan. Di bawah **REST API**, pilih **Build**. **Saat munculan **Create Example API** muncul, pilih OK.**
Jika ini bukan pertama kalinya Anda menggunakan API Gateway, pilih **Buat API**. Di bawah **REST API**, pilih **Build**.
1. Untuk **nama API**, masukkan**CrossAccountLambdaAPI**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Tetap tetapkan **jenis endpoint API** ke **Regional**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Buat API**.
## Buat fungsi integrasi Lambda di akun lain
Sekarang Anda akan membuat fungsi Lambda di akun yang berbeda dari yang Anda buat contoh API.
**Membuat fungsi Lambda di akun lain**
1. Masuk ke konsol Lambda di akun yang berbeda dari akun tempat Anda membuat API Gateway API.
1. Pilih **Buat fungsi**.
1. Pilih **Penulis dari scratch**.
1. Di bawah **Tulis dari awal**, lakukan langkah berikut:
1. Untuk **nama Fungsi**, masukkan nama.
1. Dari daftar drop-down **Runtime, pilih runtime** Node.js yang didukung.
1. Untuk **Arsitektur**, pertahankan pengaturan default.
1. Di bagian **Izin**, perluas **Pilih atau buat peran eksekusi**. Anda dapat membuat peran atau memilih peran yang ada.
1. Pilih **fungsi Buat** untuk melanjutkan.
1. Gulir ke bawah ke panel **kode Fungsi**.
1. Masukkan implementasi fungsi Node.js dari[Tutorial: Buat REST API dengan integrasi proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).
1. Pilih **Deploy**.
1. Perhatikan ARN lengkap untuk fungsi Anda (di sudut kanan atas panel fungsi Lambda). Anda akan membutuhkannya saat membuat integrasi Lambda lintas akun Anda.
## Konfigurasikan integrasi Lambda lintas akun
Setelah Anda memiliki fungsi integrasi Lambda di akun yang berbeda, Anda dapat menggunakan konsol API Gateway untuk menambahkannya ke API Anda di akun pertama Anda.
**catatan**
Jika Anda mengonfigurasi otorisasi lintas wilayah dan lintas akun, `sourceArn` yang ditambahkan ke fungsi target harus menggunakan wilayah fungsi, bukan wilayah API.
Setelah membuat API, Anda membuat sumber daya. Biasanya, sumber daya API diatur dalam pohon sumber daya sesuai dengan logika aplikasi. Untuk contoh ini, Anda membuat sumber daya **/helloworld**.
**Untuk membuat sumber daya**
1. Pilih **Buat sumber daya**.
1. Matikan **sumber daya Proxy**.
1. Pertahankan **jalur Sumber Daya** sebagai`/`.
1. Untuk **Nama sumber daya**, masukkan **helloworld**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
Setelah Anda membuat sumber daya, Anda membuat `GET` metode. Anda mengintegrasikan `GET` metode dengan fungsi Lambda di akun lain.
**Untuk membuat `GET` metode**
1. **Pilih sumber daya **/helloworld**, lalu pilih Create method.**
1. Untuk **tipe Metode**, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih fungsi **Lambda**.
1. Aktifkan **integrasi proxy Lambda**.
1. Untuk **fungsi Lambda**, masukkan ARN lengkap fungsi Lambda Anda dari Langkah 1.
Di konsol Lambda, Anda dapat menemukan ARN untuk fungsi Anda di sudut kanan atas jendela konsol.
1. Saat Anda memasukkan ARN, string `aws lambda add-permission` perintah akan muncul. Kebijakan ini memberikan akses akun pertama Anda ke fungsi Lambda akun kedua Anda. Salin dan tempel string `aws lambda add-permission` perintah ke AWS CLI jendela yang dikonfigurasi untuk akun kedua Anda.
1. Pilih **metode Buat**.
Anda dapat melihat kebijakan terbaru untuk fungsi Anda di konsol Lambda.
**(Opsional) Untuk melihat kebijakan Anda yang diperbarui**
1. Masuk ke Konsol Manajemen AWS dan buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Pilih fungsi Lambda Anda.
1. Pilih **Izin**.
Anda akan melihat `Allow` kebijakan dengan `Condition` klausa di mana dalam `AWS:SourceArn` adalah ARN untuk metode API `GET` Anda.
# Tutorial: Buat REST API dengan mengimpor contoh
Anda dapat menggunakan konsol Amazon API Gateway untuk membuat dan menguji REST API sederhana dengan integrasi HTTP untuk PetStore situs web. Definisi API telah dikonfigurasi sebelumnya sebagai file OpenAPI 2.0. Setelah memuat definisi API ke dalam API Gateway, Anda dapat menggunakan konsol API Gateway untuk memeriksa struktur dasar API atau cukup menerapkan dan menguji API.
PetStore Contoh API mendukung metode berikut bagi klien untuk mengakses situs backend HTTP dari. `http://petstore-demo-endpoint.execute-api.com/petstore/pets`
**catatan**
Tutorial ini menggunakan endpoint HTTP sebagai contoh. Saat Anda membuat sendiri APIs, kami sarankan Anda menggunakan titik akhir HTTPS untuk integrasi HTTP Anda.
+ `GET /`: untuk akses baca sumber daya root API yang tidak terintegrasi dengan titik akhir backend apa pun. API Gateway merespons dengan ikhtisar PetStore situs web. Ini adalah contoh dari jenis `MOCK` integrasi.
+ `GET /pets`: untuk akses baca ke sumber daya API yang terintegrasi dengan `/pets` sumber daya backend `/pets` bernama sama. Backend mengembalikan halaman hewan peliharaan yang tersedia di file. PetStore Ini adalah contoh dari jenis `HTTP` integrasi. URL dari titik akhir integrasi adalah`http://petstore-demo-endpoint.execute-api.com/petstore/pets`.
+ `POST /pets`: untuk akses tulis ke `/pets` sumber daya API yang terintegrasi dengan sumber daya backend`/petstore/pets`. Setelah menerima permintaan yang benar, backend menambahkan hewan peliharaan yang ditentukan ke PetStore dan mengembalikan hasilnya ke pemanggil. Integrasi juga`HTTP`.
+ `GET /pets/{petId}`: untuk akses baca ke hewan peliharaan yang diidentifikasi oleh `petId` nilai sebagaimana ditentukan sebagai variabel jalur dari URL permintaan masuk. Metode ini juga memiliki tipe `HTTP` integrasi. Backend mengembalikan hewan peliharaan tertentu yang ditemukan di file. PetStore URL titik akhir HTTP backend adalah`http://petstore-demo-endpoint.execute-api.com/petstore/pets/n`, di mana `n` bilangan bulat sebagai pengidentifikasi hewan peliharaan yang ditanyakan.
API mendukung akses CORS melalui `OPTIONS` metode jenis `MOCK` integrasi. API Gateway mengembalikan header yang diperlukan yang mendukung akses CORS.
Prosedur berikut memandu Anda melalui langkah-langkah untuk membuat dan menguji API dari contoh menggunakan API Gateway Console.
**Untuk mengimpor, membangun, dan menguji contoh API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Lakukan salah satu tindakan berikut:
+ Untuk membuat API pertama Anda, untuk **REST API**, pilih **Build**.
+ Jika Anda telah membuat API sebelumnya, pilih **Buat API**, lalu pilih **Build** for **REST API**.
1. Di bawah **Create REST API**, pilih **Example** API lalu pilih **Create API** untuk membuat contoh API.
![\[Contoh REST API di konsol API Gateway.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-new-console.png)
Anda dapat menggulir ke bawah definisi OpenAPI untuk detail contoh API ini sebelum memilih **Create** API.
1. Di panel navigasi utama, pilih **Resources**. API yang baru dibuat ditampilkan sebagai berikut:
![\[Contoh API setelah mengimpornya ke konsol API Gateway.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-result-new-console.png)
Panel **Resources** menunjukkan struktur API yang dibuat sebagai pohon node. Metode API yang didefinisikan pada setiap sumber daya adalah tepi pohon. Ketika sumber daya dipilih, semua metodenya tercantum dalam tabel **Metode** di sebelah kanan. Ditampilkan dengan setiap metode adalah jenis metode, jenis integrasi, jenis otorisasi, dan persyaratan kunci API.
1. Untuk melihat detail metode, untuk memodifikasi pengaturannya, atau untuk menguji pemanggilan metode, pilih nama metode dari daftar metode atau pohon sumber daya. Di sini, kami memilih `POST /pets` metode sebagai ilustrasi:
![\[Metode POST /pets untuk contoh API di konsol API Gateway.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-execution-new-console.png)
Panel **eksekusi Metode** yang dihasilkan menyajikan tampilan logis dari struktur dan perilaku metode yang dipilih (`POST /pets`).
**Permintaan Metode** **dan respons Metode** mewakili antarmuka API dengan frontend, dan **permintaan Integrasi** serta **respons Integrasi** mewakili antarmuka API dengan backend.
Klien menggunakan API untuk mengakses fitur backend melalui permintaan **Metode**. API Gateway menerjemahkan permintaan klien, jika perlu, ke dalam formulir yang dapat diterima oleh backend dalam **permintaan Integrasi sebelum meneruskan permintaan** masuk ke backend. Permintaan yang ditransformasikan dikenal sebagai permintaan integrasi. Demikian pula, backend mengembalikan respons ke API Gateway dalam respons **Integrasi**. API Gateway kemudian merutekan ke **Method Response** sebelum mengirimnya ke klien. Sekali lagi, jika perlu, API Gateway dapat memetakan data respons backend ke formulir yang diharapkan oleh klien.
Untuk `POST` metode pada sumber daya API, payload permintaan metode dapat diteruskan ke permintaan integrasi tanpa modifikasi, jika payload permintaan metode memiliki format yang sama dengan payload permintaan integrasi.
Permintaan `GET /` metode menggunakan tipe `MOCK` integrasi dan tidak terikat pada titik akhir backend nyata. **Respons Integrasi** yang sesuai diatur untuk mengembalikan halaman HTML statis. Ketika metode dipanggil, API Gateway hanya menerima permintaan dan segera mengembalikan respons integrasi yang dikonfigurasi ke klien melalui **respons Metode**. Anda dapat menggunakan integrasi tiruan untuk menguji API tanpa memerlukan titik akhir backend. Anda juga dapat menggunakannya untuk menyajikan respons lokal, yang dihasilkan dari template pemetaan badan respons.
Sebagai pengembang API, Anda mengontrol perilaku interaksi frontend API Anda dengan mengonfigurasi permintaan metode dan respons metode. Anda mengontrol perilaku interaksi backend API Anda dengan menyiapkan permintaan integrasi dan respons integrasi. Ini melibatkan pemetaan data antara metode dan integrasi yang sesuai. Untuk saat ini, kami fokus pada pengujian API untuk memberikan pengalaman end-to-end pengguna.
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Misalnya, untuk menguji `POST /pets` metode, masukkan **\$1"type": "dog","price": 249.99\$1** payload berikut ke dalam **badan Permintaan**, lalu pilih **Uji**.
![\[Uji metode POST di konsol API Gateway.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-test-new-console.png)
Input menentukan atribut hewan peliharaan yang ingin kita tambahkan ke daftar hewan peliharaan di situs PetStore web.
1. Hasil ditampilkan sebagai berikut:
![\[Hasil pengujian metode POST di konsol API Gateway.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-test-result-new-console.png)
Entri **Log** output menunjukkan perubahan status dari permintaan metode ke permintaan integrasi, dan dari respons integrasi ke respons metode. Ini dapat berguna untuk memecahkan masalah kesalahan pemetaan yang menyebabkan permintaan gagal. Dalam contoh ini, tidak ada pemetaan yang diterapkan: payload permintaan metode diteruskan melalui permintaan integrasi ke backend dan, demikian pula, respons backend diteruskan melalui respons integrasi ke respons metode.
Untuk menguji API menggunakan klien selain test-invoke-request fitur API Gateway, Anda harus terlebih dahulu menerapkan API ke tahap.
1. Untuk menerapkan API sampel, pilih **Deploy** API.
![\[Gunakan tombol deploy untuk men-deploy API Anda, sehingga pemanggil API dapat memanggil API Anda.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-deploy-api-new-console.png)
1. Untuk **Stage**, pilih **New stage**, dan kemudian enter**test**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
1. Di panel **Tahapan** yang dihasilkan, di bawah **Detail tahap**, **URL Invoke** menampilkan URL untuk memanggil permintaan metode API. `GET /`
![\[Setelah Anda membuat REST API, konsol akan menampilkan URL pemanggilan API Anda.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/getting-started-rest-invoke-url.png)
1. Pilih ikon salin untuk menyalin URL pemanggilan API Anda, lalu masukkan URL pemanggilan API Anda di browser web. Respons yang berhasil mengembalikan hasil, yang dihasilkan dari template pemetaan dalam respons integrasi.
1. Di panel navigasi **Tahapan**, perluas tahap **pengujian**, pilih **GET** on`/pets/{petId}`, lalu salin nilai **URL Invoke** dari. `https://api-id.execute-api.region.amazonaws.com/test/pets/{petId}` `{petId}`singkatan dari variabel jalur.
Rekatkan nilai **URL Invoke** (diperoleh pada langkah sebelumnya) ke bilah alamat browser, ganti `{petId}` dengan, misalnya`1`, dan tekan Enter untuk mengirimkan permintaan. Respons 200 OK harus kembali dengan muatan JSON berikut:
```
{
"id": 1,
"type": "dog",
"price": 249.99
}
```
Memanggil metode API seperti yang ditunjukkan dimungkinkan karena jenis **Otorisasi** disetel ke. `NONE` Jika `AWS_IAM` otorisasi digunakan, Anda akan menandatangani permintaan menggunakan protokol [Signature Version 4 (SigV4) atau Signature Version](https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html) [4a (Sigv4a](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html#how-sigv4a-works)). Untuk contoh permintaan seperti itu, lihat[Tutorial: Membuat REST API dengan integrasi non-proxy HTTP](api-gateway-create-api-step-by-step.md).
# Pilih tutorial integrasi HTTP
Untuk membangun API dengan integrasi HTTP, Anda dapat menggunakan integrasi proxy HTTP atau integrasi kustom HTTP.
Dalam integrasi proxy HTTP, Anda hanya perlu mengatur metode HTTP dan URI endpoint HTTP, sesuai dengan persyaratan backend. Kami menyarankan Anda menggunakan integrasi proxy HTTP, bila memungkinkan, untuk memanfaatkan pengaturan API yang disederhanakan.
Anda mungkin ingin menggunakan integrasi kustom HTTP jika Anda perlu mengubah data permintaan klien untuk backend atau mengubah data respons backend untuk klien.
**Topics**
+ [Tutorial: Membuat REST API dengan integrasi proxy HTTP](api-gateway-create-api-as-simple-proxy-for-http.md)
+ [Tutorial: Membuat REST API dengan integrasi non-proxy HTTP](api-gateway-create-api-step-by-step.md)
# Tutorial: Membuat REST API dengan integrasi proxy HTTP
Integrasi proxy HTTP adalah mekanisme sederhana, kuat, dan serbaguna untuk membangun API yang memungkinkan aplikasi web mengakses beberapa sumber daya atau fitur dari titik akhir HTTP terintegrasi, misalnya seluruh situs web, dengan pengaturan yang efisien dari satu metode API. Dalam integrasi proxy HTTP, API Gateway meneruskan permintaan metode yang dikirimkan klien ke backend. Data permintaan yang diteruskan mencakup header permintaan, parameter string kueri, variabel jalur URL, dan payload. Titik akhir HTTP backend atau server web mem-parsing data permintaan yang masuk untuk menentukan respons yang dikembalikan. Integrasi proxy HTTP membuat klien dan backend berinteraksi secara langsung tanpa intervensi dari API Gateway setelah metode API disiapkan, kecuali untuk masalah yang diketahui seperti karakter yang tidak didukung, yang tercantum di dalamnya. [Catatan penting Amazon API Gateway](api-gateway-known-issues.md)
Dengan sumber daya proxy yang mencakup semua`{proxy+}`, dan `ANY` kata kerja catch-all untuk metode HTTP, Anda dapat menggunakan integrasi proxy HTTP untuk membuat API dari satu metode API. Metode ini mengekspos seluruh rangkaian sumber daya HTTP yang dapat diakses publik dan operasi situs web. Ketika server web backend membuka lebih banyak sumber daya untuk akses publik, klien dapat menggunakan sumber daya baru ini dengan penyiapan API yang sama. Untuk mengaktifkan ini, pengembang situs web harus berkomunikasi dengan jelas kepada pengembang klien apa sumber daya baru dan operasi apa yang berlaku untuk masing-masing sumber daya tersebut.
Sebagai pengantar singkat, tutorial berikut menunjukkan integrasi proxy HTTP. Dalam tutorial, kita membuat API menggunakan konsol API Gateway untuk berintegrasi dengan PetStore situs web melalui sumber daya proxy generik`{proxy+}`, dan membuat placeholder metode HTTP dari. `ANY`
**Topics**
+ [Membuat API dengan integrasi proxy HTTP menggunakan konsol API Gateway](#api-gateway-create-api-as-simple-proxy-for-http-build)
+ [Uji API dengan integrasi proxy HTTP](#api-gateway-create-api-as-simple-proxy-for-http-test)
## Membuat API dengan integrasi proxy HTTP menggunakan konsol API Gateway
Prosedur berikut memandu Anda melalui langkah-langkah untuk membuat dan menguji API dengan sumber daya proxy untuk backend HTTP menggunakan konsol API Gateway. Backend HTTP adalah `PetStore` situs web (`http://petstore-demo-endpoint.execute-api.com/petstore/pets`) dari[Tutorial: Membuat REST API dengan integrasi non-proxy HTTP](api-gateway-create-api-step-by-step.md), di mana tangkapan layar digunakan sebagai alat bantu visual untuk mengilustrasikan elemen UI API Gateway. Jika Anda baru menggunakan konsol API Gateway untuk membuat API, Anda mungkin ingin mengikuti bagian itu terlebih dahulu.
**Untuk membuat API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Jika ini adalah pertama kalinya Anda menggunakan API Gateway, Anda akan melihat halaman yang memperkenalkan Anda ke fitur layanan. Di bawah **REST API**, pilih **Build**. **Saat munculan **Create Example API** muncul, pilih OK.**
Jika ini bukan pertama kalinya Anda menggunakan API Gateway, pilih **Buat API**. Di bawah **REST API**, pilih **Build**.
1. Untuk **nama API**, masukkan**HTTPProxyAPI**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Tetap tetapkan **jenis endpoint API** ke **Regional**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Buat API**.
Pada langkah ini, Anda membuat jalur sumber daya proxy dari`{proxy+}`. Ini adalah placeholder dari salah satu titik akhir backend di bawah. `http://petstore-demo-endpoint.execute-api.com/` Misalnya, bisa jadi`petstore`,`petstore/pets`, dan`petstore/pets/{petId}`. API Gateway membuat `ANY` metode saat Anda membuat `{proxy+}` sumber daya dan berfungsi sebagai placeholder untuk salah satu kata kerja HTTP yang didukung pada waktu berjalan.
**Untuk membuat sumber daya**/\$1proxy\$1**\$1**
1. Pilih API Anda.
1. Di panel navigasi utama, pilih **Resources**.
1. Pilih **Buat sumber daya**.
1. Aktifkan **sumber daya Proxy**.
1. Pertahankan **jalur Sumber Daya** sebagai`/`.
1. Untuk **Nama sumber daya**, masukkan **\$1proxy\$1\$1**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
![\[Buat sumber daya anak.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-simple-proxy-create-proxy-resource-new-console.png)
Pada langkah ini, Anda mengintegrasikan `ANY` metode dengan titik akhir HTTP backend, menggunakan integrasi proxy. Dalam integrasi proxy, API Gateway meneruskan permintaan metode yang dikirimkan klien ke backend tanpa intervensi dari API Gateway.
**Untuk membuat `ANY` metode**
1. Pilih sumber daya**/\$1proxy\$1\$1**.
1. Pilih metode **APAPUN**.
1. Di bawah simbol peringatan, pilih **Edit integrasi**. Anda tidak dapat menerapkan API yang memiliki metode tanpa integrasi.
1. Untuk **jenis Integrasi**, pilih **HTTP**.
1. Aktifkan **integrasi proxy HTTP**.
1. Untuk **metode HTTP**, pilih **APAPUN**.
1. Untuk **URL Endpoint**, masukkan**http://petstore-demo-endpoint.execute-api.com/\$1proxy\$1**.
1. Pilih **Simpan**.
## Uji API dengan integrasi proxy HTTP
Apakah permintaan klien tertentu berhasil tergantung pada hal berikut:
+ Jika backend telah membuat titik akhir backend yang sesuai tersedia dan, jika demikian, telah memberikan izin akses yang diperlukan.
+ Jika klien memberikan masukan yang benar.
Misalnya, PetStore API yang digunakan di sini tidak mengekspos `/petstore` sumber daya. Dengan demikian, Anda mendapatkan `404 Resource Not Found` respons yang berisi pesan kesalahan`Cannot GET /petstore`.
Selain itu, klien harus dapat menangani format output backend untuk mengurai hasil dengan benar. API Gateway tidak memediasi untuk memfasilitasi interaksi antara klien dan backend.
**Untuk menguji API yang terintegrasi dengan PetStore situs web menggunakan integrasi proxy HTTP melalui sumber daya proxy**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Untuk **jenis Metode**, pilih`GET`.
1. Untuk **Path**, di bawah **proxy**, masukkan**petstore/pets**.
1. Untuk **string Query**, masukkan**type=fish**.
1. Pilih **Uji**.
![\[Gunakan fitur uji untuk menguji metode.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-simple-proxy-petstore-call-proxy-resource-new-console.png)
Karena situs web backend mendukung `GET /petstore/pets?type=fish` permintaan, ia mengembalikan respons yang berhasil serupa dengan yang berikut ini:
```
[
{
"id": 1,
"type": "fish",
"price": 249.99
},
{
"id": 2,
"type": "fish",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]
```
Jika Anda mencoba menelepon`GET /petstore`, Anda mendapatkan `404` respons dengan pesan kesalahan`Cannot GET /petstore`. Ini karena backend tidak mendukung operasi yang ditentukan. Jika Anda menelepon`GET /petstore/pets/1`, Anda mendapatkan `200 OK` respons dengan muatan berikut, karena permintaan didukung oleh PetStore situs web.
```
{
"id": 1,
"type": "dog",
"price": 249.99
}
```
Anda juga dapat menggunakan browser untuk menguji API Anda. Terapkan API Anda dan kaitkan ke panggung untuk membuat URL Invoke API Anda.
**Untuk men-deploy API Anda**
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **New stage**.
1. Untuk **nama Panggung**, masukkan**test**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
Sekarang klien dapat menghubungi API Anda.
**Untuk menjalankan API Anda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Di panel navigasi utama, pilih **Stage**.
1. Di bawah **Detail tahap**, pilih ikon salin untuk menyalin URL pemanggilan API Anda.
Masukkan URL pemanggilan API Anda di browser web.
URL lengkap akan terlihat seperti`https://abcdef123.execute-api.us-east-2.amazonaws.com/test/petstore/pets?type=fish`.
Browser Anda mengirimkan `GET` permintaan ke API.
1. Hasilnya harus sama dengan yang dikembalikan saat Anda menggunakan **Test** di konsol API Gateway.
# Tutorial: Membuat REST API dengan integrasi non-proxy HTTP
Dalam tutorial ini, Anda membuat API dari awal menggunakan konsol Amazon API Gateway. Anda dapat menganggap konsol sebagai studio desain API dan menggunakannya untuk cakupan fitur API, bereksperimen dengan perilakunya, membangun API, dan menerapkan API Anda secara bertahap.
**Topics**
+ [Buat API dengan integrasi kustom HTTP](#api-gateway-create-resource-and-methods)
+ [(Opsional) Parameter permintaan peta](#api-gateway-create-resources-and-methods-next-steps)
## Buat API dengan integrasi kustom HTTP
Bagian ini memandu Anda melalui langkah-langkah untuk membuat sumber daya, mengekspos metode pada sumber daya, mengonfigurasi metode untuk mencapai perilaku API yang diinginkan, dan untuk menguji dan menerapkan API.
Pada langkah ini, Anda membuat API kosong. Dalam langkah-langkah berikut, Anda membuat sumber daya dan metode untuk menghubungkan API Anda ke `http://petstore-demo-endpoint.execute-api.com/petstore/pets` titik akhir, menggunakan integrasi HTTP non-proxy.
**Untuk membuat API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Jika ini adalah pertama kalinya Anda menggunakan API Gateway, Anda akan melihat halaman yang memperkenalkan Anda ke fitur layanan. Di bawah **REST API**, pilih **Build**. **Saat munculan **Create Example API** muncul, pilih OK.**
Jika ini bukan pertama kalinya Anda menggunakan API Gateway, pilih **Buat API**. Di bawah **REST API**, pilih **Build**.
1. Untuk **nama API**, masukkan**HTTPNonProxyAPI**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Tetap tetapkan **jenis endpoint API** ke **Regional**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Buat API**.
Pohon **Resources** menunjukkan sumber daya root (`/`) tanpa metode apa pun. Dalam latihan ini, kita akan membangun API dengan integrasi kustom HTTP dari PetStore situs web (http://petstore-demo-endpoint.execute-api. com/petstore/pets.) Untuk tujuan ilustrasi, kami akan membuat `/pets` sumber daya sebagai anak dari root dan mengekspos metode GET pada sumber daya ini bagi klien untuk mengambil daftar item Hewan Peliharaan yang tersedia dari situs web. PetStore
**Untuk membuat sumber daya /pets**
1. Pilih **Buat sumber daya**.
1. Matikan **sumber daya Proxy**.
1. Pertahankan **jalur Sumber Daya** sebagai`/`.
1. Untuk **Nama sumber daya**, masukkan **pets**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
Pada langkah ini, Anda membuat `GET` metode pada sumber daya **/pets**. `GET`Metode ini terintegrasi dengan situs `http://petstore-demo-endpoint.execute-api.com/petstore/pets` web. Opsi lain untuk metode API termasuk yang berikut:
+ **POST**, terutama digunakan untuk membuat sumber daya anak.
+ **PUT**, terutama digunakan untuk memperbarui sumber daya yang ada (dan, meskipun tidak disarankan, dapat digunakan untuk membuat sumber daya anak).
+ **DELETE**, digunakan untuk menghapus sumber daya.
+ **PATCH**, digunakan untuk memperbarui sumber daya.
+ **HEAD**, terutama digunakan dalam skenario pengujian. Ini sama dengan GET tetapi tidak mengembalikan representasi sumber daya.
+ **OPTIONS**, yang dapat digunakan oleh penelepon untuk mendapatkan informasi tentang opsi komunikasi yang tersedia untuk layanan target.
Untuk **metode HTTP** permintaan integrasi, Anda harus memilih salah satu yang didukung oleh backend. Untuk `HTTP` atau`Mock integration`, masuk akal bahwa permintaan metode dan permintaan integrasi menggunakan kata kerja HTTP yang sama. Untuk jenis integrasi lainnya, permintaan metode kemungkinan akan menggunakan kata kerja HTTP yang berbeda dari permintaan integrasi. Misalnya, untuk memanggil fungsi Lambda, permintaan integrasi harus digunakan `POST` untuk memanggil fungsi, sedangkan permintaan metode dapat menggunakan kata kerja HTTP apa pun tergantung pada logika fungsi Lambda.
**Untuk membuat `GET` metode pada sumber daya **/pets****
1. Pilih sumber daya **/pets**.
1. Pilih **metode Buat**.
1. Untuk **tipe Metode**, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **Integrasi HTTP**.
1. Matikan **integrasi proxy HTTP**.
1. Untuk **metode HTTP**, pilih **GET**.
1. Untuk **URL Endpoint**, masukkan**http://petstore-demo-endpoint.execute-api.com/petstore/pets**.
PetStore Situs web ini memungkinkan Anda untuk mengambil daftar `Pet` item berdasarkan jenis hewan peliharaan, seperti “Dog” atau “Cat”, pada halaman tertentu.
1. Untuk **penanganan Konten**, pilih **Passthrough**.
1. Pilih **parameter string kueri URL**.
Situs PetStore web menggunakan parameter string `type` dan `page` kueri untuk menerima input. Anda menambahkan parameter string kueri ke permintaan metode dan memetakannya ke dalam parameter string kueri yang sesuai dari permintaan integrasi.
1. Untuk menambahkan parameter string kueri, lakukan hal berikut:
1. Pilih **Tambahkan string kueri**.
1. Untuk **Nama**, masukkan **type**
1. Tetap **Diperlukan** dan **Caching** dimatikan.
Ulangi langkah sebelumnya untuk membuat string kueri tambahan dengan nama**page**.
1. Pilih **metode Buat**.
Klien sekarang dapat menyediakan jenis hewan peliharaan dan nomor halaman sebagai parameter string kueri saat mengirimkan permintaan. Parameter input ini harus dipetakan ke dalam parameter string kueri integrasi untuk meneruskan nilai input ke PetStore situs web kami di backend.
**Untuk memetakan parameter input ke permintaan Integrasi**
1. Pada tab **Permintaan integrasi**, di bawah **Pengaturan permintaan integrasi**, pilih **Edit**.
1. Pilih **parameter string kueri URL**, lalu lakukan hal berikut:
1. Pilih **Tambahkan parameter string kueri**.
1. Untuk **Nama**, masukkan **type**.
1. Untuk **Dipetakan dari**, masukkan **method.request.querystring.type**
1. Tetap **caching** dimatikan.
1. Pilih **Tambahkan parameter string kueri**.
1. Untuk **Nama**, masukkan **page**.
1. Untuk **Dipetakan dari**, masukkan **method.request.querystring.page**
1. Tetap **caching** dimatikan.
1. Pilih **Simpan**.
**Untuk menguji API**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Untuk **string Query**, masukkan**type=Dog&page=2**.
1. Pilih **Uji**.
Hasilnya mirip dengan yang berikut:
![\[Test-invoke GET pada hasil metode hewan peliharaan\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-create-api-step-by-step-test-invoke-get-on-pets-result-new-console.png)
Sekarang setelah pengujian berhasil, kami dapat menerapkan API untuk membuatnya tersedia untuk umum.
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **New stage**.
1. Untuk **nama Panggung**, masukkan**Prod**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
1. (Opsional) Di bawah **detail Tahap**, untuk **Invoke URL**, Anda dapat memilih ikon salin untuk menyalin URL pemanggilan API Anda. Anda dapat menggunakan ini dengan alat seperti [Postman](https://www.postman.com) dan [cURL](https://curl.se/) untuk menguji API Anda.
Jika Anda menggunakan SDK untuk membuat klien, Anda dapat memanggil metode yang diekspos oleh SDK untuk menandatangani permintaan. Untuk detail implementasi, lihat [AWS SDK](https://aws.amazon.com/developer/tools/) yang Anda pilih.
**catatan**
Saat perubahan dilakukan pada API Anda, Anda harus menerapkan ulang API agar fitur baru atau yang diperbarui tersedia sebelum menjalankan URL permintaan lagi.
## (Opsional) Parameter permintaan peta
### Parameter permintaan peta untuk API Gateway API
Tutorial ini menunjukkan cara membuat parameter jalur `{petId}` pada permintaan metode API untuk menentukan ID item, memetakannya ke parameter `{id}` jalur di URL permintaan integrasi, dan mengirim permintaan ke titik akhir HTTP.
**catatan**
Jika Anda memasukkan huruf yang salah, seperti huruf kecil, bukan huruf besar, ini akan menyebabkan kesalahan nanti dalam penelusuran.
#### Langkah 1: Buat sumber daya
Pada langkah ini, Anda membuat sumber daya dengan parameter jalur \$1PeTiD\$1.
**Untuk membuat sumber daya \$1PeTID\$1**
1. Pilih sumber daya **/pets**, lalu pilih **Create resource**.
1. Matikan **sumber daya Proxy**.
1. Untuk **jalur Sumber Daya**, pilih **/pets/**.
1. Untuk **Nama sumber daya**, masukkan **\$1petId\$1**.
Gunakan kurawal kurawal (`{ }`) di sekitar `petId` sehingga **/pets/ \$1PeTiD**\$1 ditampilkan.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
#### Langkah 2: Buat dan uji metode
Pada langkah ini, Anda membuat `GET` metode dengan parameter `{petId}` jalur.
**Untuk mengatur metode GET**
1. Pilih sumber daya**/\$1PeTiD\$1**, lalu pilih **Create** method.
1. Untuk **tipe Metode**, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **Integrasi HTTP**.
1. Matikan **integrasi proxy HTTP**.
1. Untuk **metode HTTP**, pilih **GET**.
1. Untuk **URL Endpoint**, masukkan **http://petstore-demo-endpoint.execute-api.com/petstore/pets/\$1id\$1**
1. Untuk **penanganan Konten**, pilih **Passthrough**.
1. Tetap aktifkan **batas waktu default**.
1. Pilih **metode Buat**.
Sekarang Anda memetakan parameter `{petId}` path yang baru saja Anda buat ke parameter `{id}` path di URL endpoint HTTP dari permintaan integrasi. URL titik akhir HTTP adalah**http://petstore-demo-endpoint.execute-api.com/petstore/pets/\$1id\$1**.
**Untuk memetakan parameter `{petId}` jalur**
1. Pada tab **Permintaan integrasi**, di bawah **Pengaturan permintaan integrasi**, pilih **Edit**.
1. Pilih **parameter jalur URL**.
1. API Gateway membuat parameter jalur untuk permintaan integrasi bernama **PeTiD**, namun parameter jalur ini tidak valid untuk URL titik akhir HTTP yang Anda tetapkan sebagai integrasi backend. Titik akhir HTTP digunakan `{id}` sebagai parameter jalur. Untuk **Nama**, hapus **PeTiD dan masukkan**. **id**
Ini memetakan parameter jalur permintaan metode `petId` ke parameter jalur permintaan integrasi`id`.
1. Pilih **Simpan**.
Sekarang Anda menguji metodenya.
**Untuk menguji metode**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Di bawah **Path** for **PeTiD, masukkan**. **4**
1. Pilih **Uji**.
Jika berhasil, **badan Response** menampilkan yang berikut ini:
```
{
"id": 4,
"type": "bird",
"price": 999.99
}
```
#### Langkah 3: Menyebarkan API
Pada langkah ini, Anda menerapkan API sehingga Anda dapat mulai memanggilnya di luar konsol API Gateway.
**Untuk menerapkan API**
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **Prod**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
#### Langkah 4: Uji API
Pada langkah ini, Anda pergi ke luar konsol API Gateway dan menggunakan API Anda untuk mengakses titik akhir HTTP.
1. Di panel navigasi utama, pilih **Stage**.
1. Di bawah **Detail tahap**, pilih ikon salin untuk menyalin URL pemanggilan API Anda.
Seharusnya terlihat seperti ini:
```
https://my-api-id.execute-api.region-id.amazonaws.com/prod
```
1. Masukkan URL ini di kotak alamat tab browser baru dan tambahkan `/pets/4` ke URL sebelum Anda mengirimkan permintaan Anda.
1. Browser akan mengembalikan yang berikut:
```
{
"id": 4,
"type": "bird",
"price": 999.99
}
```
#### Langkah selanjutnya
Anda dapat menyesuaikan API lebih lanjut dengan mengaktifkan validasi permintaan, mengubah data, atau membuat respons gateway khusus.
Untuk menjelajahi lebih banyak cara untuk menyesuaikan API Anda, lihat tutorial berikut:
+ Untuk informasi selengkapnya tentang validasi permintaan, lihat[Siapkan validasi permintaan dasar di API Gateway](api-gateway-request-validation-set-up.md).
+ Untuk informasi tentang cara mengubah payload permintaan dan respons, lihat[Tutorial: Memodifikasi permintaan integrasi dan respon untuk integrasi ke layanan AWS](set-up-data-transformations-in-api-gateway.md).
+ Untuk informasi tentang cara membuat respons gateway kustom, lihat,[Menyiapkan respons gateway untuk REST API menggunakan konsol API Gateway](set-up-gateway-response-using-the-console.md).
# Tutorial: Buat REST API dengan integrasi pribadi
Dalam tutorial ini, Anda membuat REST API yang terhubung ke layanan Amazon ECS yang berjalan di Amazon VPC. Klien di luar VPC Amazon Anda dapat menggunakan API untuk mengakses layanan Amazon ECS Anda.
Tutorial ini membutuhkan waktu sekitar satu jam untuk menyelesaikannya. Pertama, Anda menggunakan CloudFormation template untuk membuat Amazon VPC dan layanan Amazon ECS. Kemudian Anda menggunakan konsol API Gateway untuk membuat tautan VPC V2. Tautan VPC memungkinkan API Gateway untuk mengakses layanan Amazon ECS yang berjalan di VPC Amazon Anda. Selanjutnya, Anda membuat REST API yang menggunakan tautan VPC V2 untuk terhubung ke layanan Amazon ECS Anda. Terakhir, Anda menguji API Anda.
Saat Anda menjalankan REST API, API Gateway merutekan permintaan ke layanan Amazon ECS Anda melalui tautan VPC V2, lalu mengembalikan respons dari layanan.
**catatan**
Tutorial ini sebelumnya didukung untuk HTTP APIs, dan sekarang didukung untuk REST APIs menggunakan VPC link V2.
![\[Ikhtisar REST API yang Anda buat dalam tutorial ini.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/private-integration-rest.png)
Untuk menyelesaikan tutorial ini, Anda memerlukan AWS akun dan AWS Identity and Access Management pengguna dengan akses konsol. Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan API Gateway](setting-up.md).
**Topics**
+ [Langkah 1: Buat layanan Amazon ECS](#rest-api-private-integration-create-ecs-service)
+ [Langkah 2: Buat tautan VPC](#http-api-private-integration-vpc-link)
+ [Langkah 3: Buat REST API](#http-api-private-integration-create-api)
+ [Langkah 4: Uji API Anda](#rest-api-private-integration-test-api)
+ [Langkah 5: Menerapkan API Anda](#rest-api-private-integration-deploy-api)
+ [Langkah 6: Hubungi API Anda](#rest-api-private-integration-call)
+ [Langkah 7: Bersihkan](#rest-api-private-integration-cleanup)
## Langkah 1: Buat layanan Amazon ECS
Amazon ECS adalah layanan manajemen kontainer yang memudahkan untuk menjalankan, menghentikan, dan mengelola kontainer Docker di cluster. Dalam tutorial ini, Anda menjalankan cluster Anda pada infrastruktur tanpa server yang dikelola oleh Amazon ECS.
Unduh dan unzip [CloudFormation template ini](samples/rest-private-integration-tutorial.zip), yang membuat semua dependensi untuk layanan, termasuk VPC Amazon. Anda menggunakan template untuk membuat layanan Amazon ECS yang menggunakan Application Load Balancer.
**Untuk membuat CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih **Buat tumpukan** kemudian pilih **Dengan sumber daya baru (standar)**.
1. Untuk **Tentukan templat**, pilih **Unggah file templat**.
1. Pilih template yang Anda unduh.
1. Pilih **Berikutnya**.
1. Untuk **nama Stack**, masukkan **rest-api-private-integrations-tutorial** dan kemudian pilih **Berikutnya**.
1. Untuk **opsi Konfigurasi tumpukan**, pilih **Berikutnya**.
1. Untuk **Kemampuan**, akui bahwa CloudFormation dapat membuat sumber daya IAM di akun Anda.
1. Pilih **Berikutnya**, lalu pilih **Kirim**.
CloudFormation menyediakan layanan ECS, yang dapat memakan waktu beberapa menit. Ketika status CloudFormation tumpukan Anda adalah **CREATE\$1COMPLETE**, Anda siap untuk melanjutkan ke langkah berikutnya.
## Langkah 2: Buat tautan VPC
Tautan VPC memungkinkan API Gateway untuk mengakses sumber daya pribadi di VPC Amazon. Anda menggunakan tautan VPC untuk memungkinkan klien mengakses layanan Amazon ECS Anda melalui REST API Anda.
**Untuk membuat tautan VPC**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. **Pada panel navigasi utama, pilih tautan **VPC** dan kemudian pilih Buat.**
Anda mungkin perlu memilih ikon menu untuk membuka panel navigasi utama.
1. Untuk **Pilih versi tautan VPC, pilih tautan** VPC **V2**.
1. Untuk **Nama**, masukkan **private-integrations-tutorial**.
1. Untuk **VPC**, pilih VPC yang Anda buat di langkah 1. Nama harus dimulai dengan **RestApiStack**.
1. Untuk **Subnet**, pilih dua subnet pribadi di VPC Anda. Nama mereka diakhiri dengan `PrivateSubnet`
1. Untuk **grup Keamanan**, pilih ID Grup yang dimulai dengan `private-integrations-tutorial` dan memiliki deskripsi`RestApiStack/RestApiTutorialService/Service/SecurityGroup`.
1. Pilih **Buat**.
Setelah Anda membuat tautan VPC V2, API Gateway menyediakan Antarmuka Jaringan Elastis untuk mengakses VPC Anda. Prosesnya bisa memakan waktu beberapa menit. Sementara itu, Anda dapat membuat API Anda.
## Langkah 3: Buat REST API
REST API menyediakan titik akhir HTTP untuk layanan Amazon ECS Anda.
**Untuk membuat REST API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **Create API**, lalu untuk **REST API**, pilih **Build**.
1. Untuk **Nama**, masukkan **private-integration-api**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Buat API**.
Setelah membuat API, Anda membuat metode.
1. Pilih **metode Create**, dan kemudian lakukan hal berikut:
1. Untuk **jenis Metode**, pilih`GET`.
1. Untuk **jenis Integrasi**, pilih **tautan VPC**.
1. Aktifkan **integrasi proxy VPC**.
1. Untuk **metode HTTP**, pilih`GET`.
1. Untuk tautan **VPC, pilih tautan** VPC V2 yang Anda buat di langkah sebelumnya.
1. Untuk **target Integrasi**, masukkan penyeimbang beban yang Anda buat dengan CloudFormation template di Langkah 1. Namanya harus dimulai dengan **istirahat-**.
1. Untuk **URL Endpoint**, masukkan`http://private-integrations-tutorial.com`.
URL digunakan untuk mengatur `Host` header permintaan integrasi. Dalam hal ini, header host adalah**private-integrations-tutorial**.
1. Pilih **metode Buat**.
Dengan integrasi proxy, API siap untuk diuji.
## Langkah 4: Uji API Anda
Selanjutnya, Anda menguji pemanggilan metode API.
**Untuk menguji API Anda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Pilih **Tes**
Verifikasi bahwa respons API Anda adalah pesan selamat datang yang memberi tahu Anda bahwa aplikasi Anda berjalan di Amazon ECS.
## Langkah 5: Menerapkan API Anda
Selanjutnya, Anda menerapkan API Anda.
**Untuk men-deploy API Anda**
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **New stage**.
1. Untuk **nama Panggung**, masukkan**Prod**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
## Langkah 6: Hubungi API Anda
Setelah API Anda di-deploy, Anda dapat memanggilnya.
**Untuk memanggil API Anda**
1. Masukkan URL pemanggilan di browser web.
URL lengkap akan terlihat seperti`https://abcd123.execute-api.us-east-2.amazonaws.com/Prod`.
Browser Anda mengirimkan `GET` permintaan ke API.
1. Verifikasi bahwa respons API Anda adalah pesan selamat datang yang memberi tahu Anda bahwa aplikasi Anda berjalan di Amazon ECS.
Jika Anda melihat pesan selamat datang, Anda berhasil membuat layanan Amazon ECS yang berjalan di VPC Amazon, dan Anda menggunakan API REST API Gateway API dengan tautan VPC V2 untuk mengakses layanan Amazon ECS.
## Langkah 7: Bersihkan
Untuk mencegah biaya yang tidak perlu, hapus sumber daya yang Anda buat sebagai bagian dari tutorial ini. Langkah-langkah berikut menghapus tautan VPC V2, CloudFormation stack, dan REST API Anda.
**Untuk menghapus REST API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pada **APIs**halaman, pilih API. Pilih **Tindakan**, pilih **Hapus**, lalu konfirmasikan pilihan Anda.
**Untuk menghapus tautan VPC**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **tautan VPC**.
1. Pilih tautan VPC Anda, pilih **Hapus**, lalu konfirmasikan pilihan Anda.
**Untuk menghapus CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih CloudFormation tumpukan Anda.
1. Pilih **Hapus** dan kemudian konfirmasikan pilihan Anda.
# Tutorial: Buat REST API dengan AWS integrasi
Baik [Tutorial: Buat REST API dengan integrasi non-proxy Lambda](getting-started-lambda-non-proxy-integration.md) topik [Tutorial: Buat REST API dengan integrasi proxy Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md) maupun topik menjelaskan cara membuat API Gateway API untuk mengekspos fungsi Lambda terintegrasi. Selain itu, Anda dapat membuat API Gateway API untuk mengekspos AWS layanan lain, seperti Amazon SNS, Amazon S3, Amazon Kinesis, dan bahkan. AWS Lambda Hal ini dimungkinkan oleh `AWS` integrasi. Integrasi Lambda atau integrasi proxy Lambda adalah kasus khusus, di mana pemanggilan fungsi Lambda diekspos melalui API Gateway API.
Semua dukungan AWS layanan yang didedikasikan APIs untuk mengekspos fitur mereka. Namun, protokol aplikasi atau antarmuka pemrograman cenderung berbeda dari layanan ke layanan. API Gateway API dengan `AWS` integrasi memiliki keuntungan menyediakan protokol aplikasi yang konsisten bagi klien Anda untuk mengakses berbagai AWS layanan.
Dalam panduan ini, kami membuat API untuk mengekspos Amazon SNS. Untuk contoh lebih lanjut tentang mengintegrasikan API dengan AWS layanan lain, lihat[Tutorial dan lokakarya Amazon API Gateway](api-gateway-tutorials.md).
Berbeda dengan integrasi proxy Lambda, tidak ada integrasi proxy yang sesuai untuk layanan lain AWS . Oleh karena itu, metode API terintegrasi dengan satu AWS tindakan. Untuk fleksibilitas lebih, mirip dengan integrasi proxy, Anda dapat mengatur integrasi proxy Lambda. Fungsi Lambda kemudian mem-parsing dan memproses permintaan untuk tindakan lain. AWS
API Gateway tidak mencoba lagi saat titik akhir habis. Pemanggil API harus menerapkan logika coba lagi untuk menangani batas waktu titik akhir.
Panduan ini dibangun di atas instruksi dan konsep di. [Tutorial: Buat REST API dengan integrasi non-proxy Lambda](getting-started-lambda-non-proxy-integration.md) Jika Anda belum menyelesaikan panduan itu, kami sarankan Anda melakukannya terlebih dahulu.
**Topics**
+ [Prasyarat](#getting-started-aws-proxy-prerequisites)
+ [Langkah 1: Buat peran eksekusi proxy AWS layanan](#getting-started-aws-proxy-add-roles)
+ [Langkah 2: Buat sumber daya](#getting-started-aws-proxy-add-resources)
+ [Langkah 3: Buat metode GET](#getting-started-aws-proxy-add-methods)
+ [Langkah 4: Tentukan pengaturan metode dan uji metodenya](#getting-started-aws-proxy-set-methods)
+ [Langkah 5: Menerapkan API](#getting-started-aws-proxy-deploy)
+ [Langkah 6: Uji API](#getting-started-aws-proxy-test)
+ [Langkah 7: Bersihkan](#getting-started-aws-proxy-clean-up)
## Prasyarat
Sebelum memulai panduan ini, lakukan hal berikut:
1. Selesaikan langkah-langkah dalam [Siapkan untuk menggunakan API Gateway](setting-up.md).
1. Buat API baru bernama`MyDemoAPI`. Untuk informasi selengkapnya, lihat [Tutorial: Membuat REST API dengan integrasi non-proxy HTTP](api-gateway-create-api-step-by-step.md).
1. Terapkan API setidaknya sekali ke tahap bernama`test`. Untuk informasi selengkapnya, lihat [Menerapkan API](getting-started-lambda-non-proxy-integration.md#getting-started-deploy-api) di[Pilih tutorial AWS Lambda integrasi](getting-started-with-lambda-integration.md).
1. Selesaikan langkah-langkah lainnya[Pilih tutorial AWS Lambda integrasi](getting-started-with-lambda-integration.md).
1. Buat setidaknya satu topik di Amazon Simple Notification Service (Amazon SNS). Anda akan menggunakan API yang diterapkan untuk mendapatkan daftar topik di Amazon SNS yang terkait dengan AWS akun Anda. Untuk mempelajari cara membuat topik di Amazon SNS, lihat [Membuat](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html) Topik. (Anda tidak perlu menyalin topik ARN yang disebutkan di langkah 5.)
## Langkah 1: Buat peran eksekusi proxy AWS layanan
Untuk mengizinkan API menjalankan tindakan Amazon SNS, Anda harus memiliki kebijakan IAM yang sesuai yang dilampirkan ke peran IAM. Pada langkah ini, Anda membuat peran IAM baru.
**Untuk membuat peran eksekusi proxy AWS layanan**
1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Pilih **Peran**.
1. Pilih **Buat peran**.
1. Pilih **AWS layanan** di bawah **Pilih jenis entitas tepercaya**, lalu pilih **API Gateway** dan pilih **Izinkan API Gateway untuk mendorong CloudWatch log ke Log**.
1. Pilih **Berikutnya**, lalu pilih **Berikutnya**.
1. Untuk **nama Peran****APIGatewaySNSProxyPolicy**, masukkan, lalu pilih **Buat peran**.
1. Dalam daftar **Peran**, pilih peran yang baru saja Anda buat. Anda mungkin perlu menggulir atau menggunakan bilah pencarian untuk menemukan peran.
1. Untuk peran yang dipilih, pilih tab **Tambahkan izin**.
1. Pilih **Lampirkan kebijakan** dari daftar dropdown.
1. Di bilah pencarian, masukkan **AmazonSNSReadOnlyAccess** dan pilih **Tambahkan izin**.
**catatan**
Tutorial ini menggunakan kebijakan terkelola untuk kesederhanaan. Sebagai praktik terbaik, Anda harus membuat kebijakan IAM Anda sendiri untuk memberikan izin minimum yang diperlukan.
1. Perhatikan **ARN Peran** yang baru dibuat, Anda akan menggunakannya nanti.
## Langkah 2: Buat sumber daya
Pada langkah ini, Anda membuat sumber daya yang memungkinkan proxy AWS layanan berinteraksi dengan AWS layanan.
**Untuk membuat sumber daya**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih sumber daya root,**/**, yang diwakili oleh satu garis miring (**/**), lalu pilih **Buat sumber daya**.
1. Matikan **sumber daya Proxy**.
1. Pertahankan **jalur Sumber Daya** sebagai`/`.
1. Untuk **Nama sumber daya**, masukkan **mydemoawsproxy**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
## Langkah 3: Buat metode GET
Pada langkah ini, Anda membuat metode GET yang memungkinkan proxy AWS layanan berinteraksi dengan AWS layanan.
**Untuk membuat `GET` metode**
1. **Pilih sumber daya **/mydemoawsproxy**, lalu pilih Create method.**
1. Untuk jenis metode, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **Layanan AWS**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat topik Amazon SNS Anda.
1. Untuk **Layanan AWS**, pilih **Amazon SNS**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **GET**.
1. Untuk **jenis tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**ListTopics**.
1. Untuk **peran Eksekusi**, masukkan peran ARN untuk. **APIGatewaySNSProxyPolicy**
1. Pilih **metode Buat**.
## Langkah 4: Tentukan pengaturan metode dan uji metodenya
Anda sekarang dapat menguji `GET` metode Anda untuk memverifikasi bahwa metode tersebut telah diatur dengan benar untuk mencantumkan topik Amazon SNS Anda.
**Untuk menguji `GET` metode**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Pilih **Uji**.
Hasilnya menampilkan respon yang mirip dengan berikut ini:
```
{
"ListTopicsResponse": {
"ListTopicsResult": {
"NextToken": null,
"Topics": [
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-1"
},
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-2"
},
...
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-N"
}
]
},
"ResponseMetadata": {
"RequestId": "abc1de23-45fa-6789-b0c1-d2e345fa6b78"
}
}
}
```
## Langkah 5: Menerapkan API
Pada langkah ini, Anda menerapkan API sehingga Anda dapat memanggilnya dari luar konsol API Gateway.
**Untuk menerapkan API**
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **New stage**.
1. Untuk **nama Panggung**, masukkan**test**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
## Langkah 6: Uji API
Pada langkah ini, Anda pergi ke luar konsol API Gateway dan menggunakan proxy AWS layanan Anda untuk berinteraksi dengan layanan Amazon SNS.
1. Di panel navigasi utama, pilih **Stage**.
1. Di bawah **Detail tahap**, pilih ikon salin untuk menyalin URL pemanggilan API Anda.
Seharusnya terlihat seperti ini:
```
https://my-api-id.execute-api.region-id.amazonaws.com/test
```
1. Masukkan URL ke dalam kotak alamat tab browser baru.
1. Tambahkan `/mydemoawsproxy` sehingga URL terlihat seperti ini:
```
https://my-api-id.execute-api.region-id.amazonaws.com/test/mydemoawsproxy
```
Jelajahi URL. Informasi yang mirip dengan berikut ini harus ditampilkan:
```
{"ListTopicsResponse":{"ListTopicsResult":{"NextToken": null,"Topics":[{"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-1"},{"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-2"},...{"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-N}]},"ResponseMetadata":{"RequestId":"abc1de23-45fa-6789-b0c1-d2e345fa6b78}}}
```
## Langkah 7: Bersihkan
Anda dapat menghapus sumber daya IAM yang diperlukan proxy AWS layanan untuk bekerja.
**Awas**
Jika Anda menghapus sumber daya IAM yang diandalkan oleh proxy AWS layanan, proxy AWS layanan itu dan apa pun APIs yang mengandalkannya tidak akan berfungsi lagi. Menghapus sumber daya IAM tidak dapat dibatalkan. Jika Anda ingin menggunakan sumber daya IAM lagi, Anda harus membuatnya kembali.
**Untuk menghapus sumber daya IAM terkait**
1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Di area **Detail**, pilih **Peran**.
1. Pilih **APIGatewayAWSProxyExecRole**, lalu pilih **Tindakan Peran**, **Hapus Peran**. Saat diminta, pilih **Ya, Hapus**.
1. Di area **Detail**, pilih **Kebijakan**.
1. Pilih **APIGatewayAWSProxyExecPolicy**, lalu pilih **Tindakan Kebijakan**, **Hapus**. Saat diminta, pilih **Hapus**.
Anda telah mencapai akhir dari panduan ini. Untuk diskusi lebih rinci tentang membuat API sebagai proxy AWS layanan, lihat[Tutorial: Buat REST API sebagai proxy Amazon S3](integrating-api-with-aws-services-s3.md),[Tutorial: Buat REST API kalkulator dengan dua integrasi AWS layanan dan satu integrasi non-proxy Lambda](integrating-api-with-aws-services-lambda.md), atau[Tutorial: Buat REST API sebagai proxy Amazon Kinesis](integrating-api-with-aws-services-kinesis.md).
# Tutorial: Buat REST API kalkulator dengan dua integrasi AWS layanan dan satu integrasi non-proxy Lambda
[Tutorial: Buat REST API dengan integrasi non-proxy Lambda](getting-started-lambda-non-proxy-integration.md)Penggunaan `Lambda Function` integrasi secara eksklusif. `Lambda Function`integrasi adalah kasus khusus dari jenis `AWS Service` integrasi yang melakukan banyak pengaturan integrasi untuk Anda, seperti secara otomatis menambahkan izin berbasis sumber daya yang diperlukan untuk menjalankan fungsi Lambda. Di sini, dua dari tiga integrasi menggunakan `AWS Service` integrasi. Dalam jenis integrasi ini, Anda memiliki lebih banyak kontrol, tetapi Anda harus melakukan tugas secara manual seperti membuat dan menentukan peran IAM yang berisi izin yang sesuai.
Dalam tutorial ini, Anda akan membuat fungsi `Calc` Lambda yang mengimplementasikan operasi aritmatika dasar, menerima dan mengembalikan input dan output berformat JSON. Kemudian Anda akan membuat REST API dan mengintegrasikannya dengan fungsi Lambda dengan cara berikut:
1. Dengan mengekspos `GET` metode pada `/calc` sumber daya untuk menjalankan fungsi Lambda, memasok input sebagai parameter string kueri. (`AWS Service`integrasi)
1. Dengan mengekspos `POST` metode pada `/calc` sumber daya untuk menjalankan fungsi Lambda, memasok input dalam payload permintaan metode. (`AWS Service`integrasi)
1. Dengan mengekspos `/calc/{operand1}/{operand2}/{operator}` sumber daya `GET` bersarang untuk menjalankan fungsi Lambda, memasok input sebagai parameter jalur. (`Lambda Function`integrasi)
Selain mencoba tutorial ini, Anda mungkin ingin mempelajari [file definisi OpenAPI](api-as-lambda-proxy-export-swagger-with-extensions.md) untuk `Calc` API, yang dapat Anda impor ke API Gateway dengan mengikuti petunjuk di. [Kembangkan REST APIs menggunakan OpenAPI di API Gateway](api-gateway-import-api.md)
**Topics**
+ [Buat peran IAM yang dapat diasumsikan](#api-as-lambda-proxy-setup-iam-role-policies)
+ [Buat fungsi `Calc` Lambda](#api-as-lambda-proxy-create-lambda-function)
+ [Uji fungsi `Calc` Lambda](#api-as-lambda-proxy-test-lambda-function-)
+ [Buat `Calc` API](#api-as-lambda-proxy-create-api-resources)
+ [Integrasi 1: Buat `GET` metode dengan parameter kueri untuk memanggil fungsi Lambda](#api-as-lambda-proxy-expose-get-method-with-query-strings-to-call-lambda-function)
+ [Integrasi 2: Buat `POST` metode dengan payload JSON untuk memanggil fungsi Lambda](#api-as-lambda-proxy-expose-post-method-with-json-body-to-call-lambda-function)
+ [Integrasi 3: Buat `GET` metode dengan parameter jalur untuk memanggil fungsi Lambda](#api-as-lambda-proxy-expose-get-method-with-path-parameters-to-call-lambda-function)
+ [Definisi OpenAPI dari contoh API terintegrasi dengan fungsi Lambda](api-as-lambda-proxy-export-swagger-with-extensions.md)
## Buat peran IAM yang dapat diasumsikan
Agar API dapat menjalankan fungsi `Calc` Lambda, Anda harus memiliki peran IAM yang dapat diasumsikan API Gateway, yang merupakan peran IAM dengan hubungan tepercaya berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "apigateway.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Peran yang Anda buat harus memiliki izin Lambda [InvokeFunction](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html). Jika tidak, pemanggil API akan menerima `500 Internal Server Error` respons. Untuk memberikan izin ini kepada peran ini, Anda akan melampirkan kebijakan IAM berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}
```
------
Inilah cara untuk mencapai semua ini:
**Buat peran IAM yang dapat diasumsikan API Gateway**
1. Masuk ke konsol IAM.
1. Pilih **Peran**.
1. Pilih **Buat Peran**.
1. Di **Pilih jenis entitas tepercaya**, pilih **Layanan AWS **.
1. Di bawah **Pilih layanan yang akan menggunakan di peran ini**, pilih **Lambda**.
1. Pilih **Berikutnya: Izin**.
1. Pilih **Buat Kebijakan**.
Jendela konsol **Create Policy** baru akan terbuka. Di jendela itu, lakukan hal berikut:
1. Di tab **JSON**, ganti kebijakan yang ada dengan yang berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}
```
------
1. Pilih **Tinjau kebijakan**.
1. Di bawah **Kebijakan Peninjauan**, lakukan hal berikut:
1. Untuk **Nama**, ketik nama seperti **lambda\$1execute**.
1. Pilih **Buat Kebijakan**.
1. Di jendela konsol **Create Role** asli, lakukan hal berikut:
1. Di bawah **Lampirkan kebijakan izin**, pilih **lambda\$1execute** kebijakan Anda dari daftar tarik-turun.
Jika kebijakan tidak terlihat dalam daftar, pilih tombol refresh di bagian atas daftar. (Jangan me-refresh halaman browser\$1)
1. Pilih **Selanjutnya: Tag**.
1. Pilih **Selanjutnya: Tinjau**.
1. Untuk **nama Peran**, ketikkan nama seperti**lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. Pilih **Buat peran**.
1. Pilih **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** dari daftar peran Anda.
1. Pilih tab **Trust relationship**.
1. Pilih **Edit trust relationship** (Edit Hubungan Kepercayaan).
1. Ganti kebijakan yang ada dengan yang berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"lambda.amazonaws.com",
"apigateway.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Pilih **Perbarui Kebijakan Kepercayaan**.
1. Catat peran ARN untuk peran yang baru saja Anda buat. Anda akan membutuhkannya nanti.
## Buat fungsi `Calc` Lambda
Selanjutnya Anda akan membuat fungsi Lambda menggunakan konsol Lambda.
1. Di konsol Lambda, pilih **Buat** fungsi.
1. Pilih **Penulis dari Scratch**.
1. Untuk **Nama**, masukkan **Calc**.
1. Untuk **Runtime, pilih runtime** **Node.js** atau **Python** terbaru yang didukung.
1. Untuk semua opsi lain, gunakan pengaturan default.
1. Pilih **Buat fungsi**.
1. Salin fungsi Lambda berikut di runtime pilihan Anda dan tempelkan ke editor kode di konsol Lambda.
------
#### [ Node.js ]
```
export const handler = async function (event, context) {
console.log("Received event:", JSON.stringify(event));
if (
event.a === undefined ||
event.b === undefined ||
event.op === undefined
) {
return "400 Invalid Input";
}
const res = {};
res.a = Number(event.a);
res.b = Number(event.b);
res.op = event.op;
if (isNaN(event.a) || isNaN(event.b)) {
return "400 Invalid Operand";
}
switch (event.op) {
case "+":
case "add":
res.c = res.a + res.b;
break;
case "-":
case "sub":
res.c = res.a - res.b;
break;
case "*":
case "mul":
res.c = res.a * res.b;
break;
case "/":
case "div":
if (res.b == 0) {
return "400 Divide by Zero";
} else {
res.c = res.a / res.b;
}
break;
default:
return "400 Invalid Operator";
}
return res;
};
```
------
#### [ Python ]
```
import json
def lambda_handler(event, context):
print(event)
try:
(event['a']) and (event['b']) and (event['op'])
except KeyError:
return '400 Invalid Input'
try:
res = {
"a": float(
event['a']), "b": float(
event['b']), "op": event['op']}
except ValueError:
return '400 Invalid Operand'
if event['op'] == '+':
res['c'] = res['a'] + res['b']
elif event['op'] == '-':
res['c'] = res['a'] - res['b']
elif event['op'] == '*':
res['c'] = res['a'] * res['b']
elif event['op'] == '/':
if res['b'] == 0:
return '400 Divide by Zero'
else:
res['c'] = res['a'] / res['b']
else:
return '400 Invalid Operator'
return res
```
------
1. Di bawah Peran eksekusi, **pilih Pilih peran yang ada**.
1. Masukkan peran ARN untuk **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** peran yang Anda buat sebelumnya.
1. Pilih **Deploy**.
Fungsi ini membutuhkan dua operan (`a`dan`b`) dan operator (`op`) dari parameter `event` input. Input adalah objek JSON dari format berikut:
```
{
"a": "Number" | "String",
"b": "Number" | "String",
"op": "String"
}
```
Fungsi ini mengembalikan hasil yang dihitung (`c`) dan masukan. Untuk input yang tidak valid, fungsi mengembalikan nilai null atau string “Invalid op” sebagai hasilnya. Outputnya adalah format JSON berikut:
```
{
"a": "Number",
"b": "Number",
"op": "String",
"c": "Number" | "String"
}
```
Anda harus menguji fungsi di konsol Lambda sebelum mengintegrasikannya dengan API di langkah berikutnya.
## Uji fungsi `Calc` Lambda
Berikut cara menguji `Calc` fungsi Anda di konsol Lambda:
1. Pilih tab **Uji**.
1. Untuk nama acara pengujian, masukkan**calc2plus5**.
1. Ganti definisi acara pengujian dengan yang berikut:
```
{
"a": "2",
"b": "5",
"op": "+"
}
```
1. Pilih **Simpan**.
1. Pilih **Uji**.
1. Perluas **Hasil eksekusi: berhasil.** Anda akan melihat yang berikut ini:
```
{
"a": 2,
"b": 5,
"op": "+",
"c": 7
}
```
## Buat `Calc` API
Prosedur berikut menunjukkan cara membuat API untuk fungsi `Calc` Lambda yang baru saja Anda buat. Di bagian berikutnya, Anda akan menambahkan sumber daya dan metode ke dalamnya.
**Untuk membuat API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Jika ini adalah pertama kalinya Anda menggunakan API Gateway, Anda akan melihat halaman yang memperkenalkan Anda ke fitur layanan. Di bawah **REST API**, pilih **Build**. **Saat munculan **Create Example API** muncul, pilih OK.**
Jika ini bukan pertama kalinya Anda menggunakan API Gateway, pilih **Buat API**. Di bawah **REST API**, pilih **Build**.
1. Untuk **nama API**, masukkan**LambdaCalc**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Tetap tetapkan **jenis endpoint API** ke **Regional**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Buat API**.
## Integrasi 1: Buat `GET` metode dengan parameter kueri untuk memanggil fungsi Lambda
Dengan membuat `GET` metode yang meneruskan parameter string kueri ke fungsi Lambda, Anda mengaktifkan API untuk dipanggil dari browser. Pendekatan ini dapat berguna, terutama untuk APIs itu memungkinkan akses terbuka.
Setelah membuat API, Anda membuat sumber daya. Biasanya, sumber daya API diatur dalam pohon sumber daya sesuai dengan logika aplikasi. Untuk langkah ini, Anda membuat sumber daya **/calc**.
**Untuk membuat sumber daya **/calc****
1. Pilih **Buat sumber daya**.
1. Matikan **sumber daya Proxy**.
1. Pertahankan **jalur Sumber Daya** sebagai`/`.
1. Untuk **Nama sumber daya**, masukkan **calc**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
Dengan membuat `GET` metode yang meneruskan parameter string kueri ke fungsi Lambda, Anda mengaktifkan API untuk dipanggil dari browser. Pendekatan ini dapat berguna, terutama untuk APIs itu memungkinkan akses terbuka.
Dalam metode ini, Lambda mengharuskan `POST` permintaan digunakan untuk memanggil fungsi Lambda apa pun. Contoh ini menunjukkan bahwa metode HTTP dalam permintaan metode frontend dapat berbeda dari permintaan integrasi di backend.
**Untuk membuat `GET` metode**
1. Pilih sumber daya **/calc**, lalu pilih **Create** method.
1. Untuk **tipe Metode**, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **Layanan AWS**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat fungsi Lambda Anda.
1. Untuk **Layanan AWS**, pilih **Lambda**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Action**, pilih **Use path override**. Opsi ini memungkinkan kita untuk menentukan ARN dari tindakan [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) untuk menjalankan fungsi kita. `Calc`
1. Untuk **Path override**, masukkan**2015-03-31/functions/arn:aws:lambda:*us-east-2*:*account-id*:function:Calc/invocations**. Untuk** *account-id***, masukkan Akun AWS ID Anda. Untuk***us-east-2***, masukkan Wilayah AWS tempat Anda membuat fungsi Lambda Anda.
1. Untuk **peran Eksekusi**, masukkan peran ARN untuk. **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**
1. Jangan mengubah pengaturan **cache Credential** dan **batas waktu default**.
1. Pilih **Pengaturan permintaan Metode**.
1. Untuk **validator Permintaan**, pilih **Validasi parameter string kueri** dan header.
Pengaturan ini akan menyebabkan pesan kesalahan kembali jika klien tidak menentukan parameter yang diperlukan.
1. Pilih **parameter string kueri URL**.
Sekarang Anda mengatur parameter string kueri untuk metode **GET** pada sumber daya **/calc** sehingga dapat menerima input atas nama fungsi Lambda backend.
Untuk membuat parameter string kueri lakukan hal berikut:
1. Pilih **Tambahkan string kueri**.
1. Untuk **Nama**, masukkan **operand1**.
1. Aktifkan **Diperlukan**.
1. Tetap **caching** dimatikan.
Ulangi langkah yang sama dan buat string kueri bernama **operand2** dan string kueri bernama**operator**.
1. Pilih **metode Buat**.
Sekarang, Anda membuat template pemetaan untuk menerjemahkan string kueri yang disediakan klien ke payload permintaan integrasi seperti yang dipersyaratkan oleh fungsi. `Calc` Template ini memetakan tiga parameter string kueri yang dideklarasikan dalam **permintaan Metode** ke dalam nilai properti yang ditunjuk dari objek JSON sebagai masukan ke fungsi Lambda backend. Objek JSON yang diubah akan dimasukkan sebagai payload permintaan integrasi.
**Untuk memetakan parameter input ke permintaan integrasi**
1. Pada tab **Permintaan integrasi**, di bawah **Pengaturan permintaan integrasi**, pilih **Edit**.
1. Untuk **Request body passthrough**, pilih **Bila tidak ada templat yang ditentukan (disarankan)**.
1. Pilih **template Pemetaan**.
1. Pilih **Tambahkan templat pemetaan**.
1. Untuk **jenis Konten**, masukkan**application/json**.
1. Untuk **badan Template**, masukkan kode berikut:
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": "$input.params('operator')"
}
```
1. Pilih **Simpan**.
Anda sekarang dapat menguji `GET` metode Anda untuk memverifikasi bahwa itu telah diatur dengan benar untuk menjalankan fungsi Lambda.
**Untuk menguji `GET` metode**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Untuk **string Query**, masukkan**operand1=2&operand2=3&operator=\$1**.
1. Pilih **Uji**.
Hasilnya akan terlihat mirip dengan ini:
![\[Buat API di API Gateway sebagai proxy Lambda\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_new_console.png)
## Integrasi 2: Buat `POST` metode dengan payload JSON untuk memanggil fungsi Lambda
Dengan membuat `POST` metode dengan payload JSON untuk memanggil fungsi Lambda, Anda membuatnya sehingga klien harus memberikan input yang diperlukan ke fungsi backend di badan permintaan. Untuk memastikan bahwa klien mengunggah data input yang benar, Anda akan mengaktifkan validasi permintaan pada payload.
**Untuk membuat `POST` metode dengan payload JSON**
1. Pilih sumber daya **/calc**, lalu pilih **Create** method.
1. Untuk **jenis Metode**, pilih **POST**.
1. Untuk **jenis Integrasi**, pilih **Layanan AWS**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat fungsi Lambda Anda.
1. Untuk **Layanan AWS**, pilih **Lambda**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Action**, pilih **Use path override**. Opsi ini memungkinkan kita untuk menentukan ARN dari tindakan [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) untuk menjalankan fungsi kita. `Calc`
1. Untuk **Path override**, masukkan**2015-03-31/functions/arn:aws:lambda:*us-east-2*:*account-id*:function:Calc/invocations**. Untuk** *account-id***, masukkan Akun AWS ID Anda. Untuk***us-east-2***, masukkan Wilayah AWS tempat Anda membuat fungsi Lambda Anda.
1. Untuk **peran Eksekusi**, masukkan peran ARN untuk. **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**
1. Jangan mengubah pengaturan **cache Credential** dan **batas waktu default**.
1. Pilih **metode Buat**.
Sekarang Anda membuat model **input** untuk menggambarkan struktur data input dan memvalidasi badan permintaan yang masuk.
**Untuk membuat model input**
1. Di panel navigasi utama, pilih **Model**.
1. Pilih **Buat model**.
1. Untuk **Nama**, masukkan **input**.
1. Untuk **jenis Konten**, masukkan**application/json**.
Jika tidak ada jenis konten yang cocok ditemukan, validasi permintaan tidak dilakukan. Untuk menggunakan model yang sama terlepas dari jenis konten, masukkan**\$1default**.
1. Untuk **skema Model**, masukkan model berikut:
```
{
"type":"object",
"properties":{
"a":{"type":"number"},
"b":{"type":"number"},
"op":{"type":"string"}
},
"title":"input"
}
```
1. Pilih **Buat model**.
Anda sekarang membuat model **output**. Model ini menjelaskan struktur data dari output yang dihitung dari backend. Ini dapat digunakan untuk memetakan data respons integrasi ke model yang berbeda. Tutorial ini bergantung pada perilaku passthrough dan tidak menggunakan model ini.
**Untuk membuat model keluaran**
1. Pilih **Buat model**.
1. Untuk **Nama**, masukkan **output**.
1. Untuk **jenis Konten**, masukkan**application/json**.
Jika tidak ada jenis konten yang cocok ditemukan, validasi permintaan tidak dilakukan. Untuk menggunakan model yang sama terlepas dari jenis konten, masukkan**\$1default**.
1. Untuk **skema Model**, masukkan model berikut:
```
{
"type":"object",
"properties":{
"c":{"type":"number"}
},
"title":"output"
}
```
1. Pilih **Buat model**.
Anda sekarang membuat model **hasil**. Model ini menjelaskan struktur data dari data respons yang dikembalikan. Ini mereferensikan skema **input** dan **output** yang ditentukan dalam API Anda.
**Untuk membuat model hasil**
1. Pilih **Buat model**.
1. Untuk **Nama**, masukkan **result**.
1. Untuk **jenis Konten**, masukkan**application/json**.
Jika tidak ada jenis konten yang cocok ditemukan, validasi permintaan tidak dilakukan. Untuk menggunakan model yang sama terlepas dari jenis konten, masukkan**\$1default**.
1. Untuk **skema Model**, masukkan model berikut dengan skema Anda*restapi-id*. Anda *restapi-id* tercantum dalam tanda kurung di bagian atas konsol dalam alur berikut: `API Gateway > APIs > LambdaCalc (abc123).`
```
{
"type":"object",
"properties":{
"input":{
"$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/input"
},
"output":{
"$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/output"
}
},
"title":"result"
}
```
1. Pilih **Buat model**.
Anda sekarang mengonfigurasi permintaan metode metode POST Anda untuk mengaktifkan validasi permintaan pada badan permintaan yang masuk.
**Untuk mengaktifkan validasi permintaan pada metode POST**
1. Di panel navigasi utama, pilih **Sumber daya**, lalu pilih `POST` metode dari pohon sumber daya.
1. Pada tab **Permintaan metode**, di bawah **Pengaturan permintaan metode**, pilih **Edit**.
1. Untuk **validator Permintaan**, pilih **Validasi** isi.
1. Pilih **Request body**, lalu pilih **Add model**.
1. Untuk **jenis Konten**, masukkan**application/json**.
Jika tidak ada jenis konten yang cocok ditemukan, validasi permintaan tidak dilakukan. Untuk menggunakan model yang sama terlepas dari jenis konten, masukkan**\$1default**.
1. Untuk **Model**, pilih **input**.
1. Pilih **Simpan**.
Anda sekarang dapat menguji `POST` metode Anda untuk memverifikasi bahwa itu telah diatur dengan benar untuk menjalankan fungsi Lambda.
**Untuk menguji `POST` metode**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Untuk **badan Permintaan**, masukkan payload JSON berikut.
```
{
"a": 1,
"b": 2,
"op": "+"
}
```
1. Pilih **Uji**.
Anda akan melihat output berikut:
```
{
"a": 1,
"b": 2,
"op": "+",
"c": 3
}
```
## Integrasi 3: Buat `GET` metode dengan parameter jalur untuk memanggil fungsi Lambda
Sekarang Anda akan membuat `GET` metode pada sumber daya yang ditentukan oleh urutan parameter jalur untuk memanggil fungsi Lambda backend. Nilai parameter jalur menentukan data input ke fungsi Lambda. Anda akan menggunakan template pemetaan untuk memetakan nilai parameter jalur masuk ke payload permintaan integrasi yang diperlukan.
Struktur sumber daya API yang dihasilkan akan terlihat seperti ini:
![\[Buat API di API Gateway sebagai proxy Lambda\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_lambda_create_api_resources_new_console.png)
**Untuk membuat sumber daya**/\$1operand1\$1/\$1operand2\$1/\$1operator\$1****
1. Pilih **Buat sumber daya**.
1. Untuk **jalur Sumber Daya**, pilih`/calc`.
1. Untuk **Nama sumber daya**, masukkan **\$1operand1\$1**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
1. Untuk **jalur Sumber Daya**, pilih`/calc/{operand1}/`.
1. Untuk **Nama sumber daya**, masukkan **\$1operand2\$1**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
1. Untuk **jalur Sumber Daya**, pilih`/calc/{operand1}/{operand2}/`.
1. Untuk **Nama sumber daya**, masukkan **\$1operator\$1**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
Kali ini Anda akan menggunakan integrasi Lambda bawaan di konsol API Gateway untuk menyiapkan integrasi metode.
**Untuk mengatur integrasi metode**
1. **Pilih sumber daya**/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**, lalu pilih Create method.**
1. Untuk **tipe Metode**, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **Lambda**.
1. Matikan **integrasi proxy Lambda**.
1. Untuk **fungsi Lambda**, pilih Wilayah AWS tempat Anda membuat fungsi Lambda dan masukkan. **Calc**
1. Tetap **aktifkan batas waktu default**.
1. Pilih **metode Buat**.
Anda sekarang membuat template pemetaan untuk memetakan tiga parameter jalur URL, dideklarasikan ketika sumber daya **/calc/ \$1operand1\$1/\$1operand2\$1/\$1operator\$1** dibuat, ke dalam nilai properti yang ditunjuk di objek JSON. Karena jalur URL harus dikodekan URL, operator divisi harus ditentukan sebagai pengganti. `%2F` `/` Template ini menerjemahkan `%2F` ke dalam `'/'` sebelum meneruskannya ke fungsi Lambda.
**Untuk membuat template pemetaan**
1. Pada tab **Permintaan integrasi**, di bawah **Pengaturan permintaan integrasi**, pilih **Edit**.
1. Untuk **Request body passthrough**, pilih **Bila tidak ada templat yang ditentukan (disarankan)**.
1. Pilih **template Pemetaan**.
1. Untuk **jenis Konten**, masukkan**application/json**.
1. Untuk **badan Template**, masukkan kode berikut:
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
}
```
1. Pilih **Simpan**.
Anda sekarang dapat menguji `GET` metode Anda untuk memverifikasi bahwa itu telah diatur dengan benar untuk menjalankan fungsi Lambda dan meneruskan output asli melalui respons integrasi tanpa pemetaan.
**Untuk menguji `GET` metode**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Untuk **Path**, lakukan hal berikut:
1. Untuk **operand1, masukkan**. **1**
1. Untuk **operand2, masukkan**. **1**
1. Untuk **operator**, masukkan**\$1**.
1. Pilih **Uji**.
1. Hasilnya akan terlihat seperti ini:
![\[Uji metode GET di konsol API Gateway.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_path_parm_new_console.png)
Selanjutnya, Anda memodelkan struktur data payload respons metode setelah `result` skema.
Secara default, badan respons metode diberi model kosong. Ini akan menyebabkan badan respons integrasi dilewatkan tanpa pemetaan. Namun, ketika Anda membuat SDK untuk salah satu bahasa tipe kuat, seperti Java atau Objective-C, pengguna SDK Anda akan menerima objek kosong sebagai hasilnya. Untuk memastikan bahwa klien REST dan klien SDK menerima hasil yang diinginkan, Anda harus memodelkan data respons menggunakan skema yang telah ditentukan. Di sini Anda akan mendefinisikan model untuk badan respons metode dan untuk membuat template pemetaan untuk menerjemahkan badan respons integrasi ke dalam badan respons metode.
**Untuk membuat respons metode**
1. Pada tab **Respons Metode**, di bawah **Respons 200**, pilih **Edit**.
1. Di bawah **Badan respons**, pilih **Tambahkan model**.
1. Untuk **jenis Konten**, masukkan**application/json**.
1. Untuk **Model**, pilih **hasil**.
1. Pilih **Simpan**.
Menyetel model untuk badan respons metode memastikan bahwa data respons akan dilemparkan ke `result` objek SDK tertentu. Untuk memastikan bahwa data respons integrasi dipetakan sesuai, Anda memerlukan template pemetaan.
**Untuk membuat template pemetaan**
1. Pada tab **Respons integrasi**, di bawah **Default - Respons**, pilih **Edit**.
1. Pilih **template Pemetaan**.
1. Untuk **jenis Konten**, masukkan**application/json**.
1. Untuk **badan Template**, masukkan kode berikut:
```
#set($inputRoot = $input.path('$'))
{
"input" : {
"a" : $inputRoot.a,
"b" : $inputRoot.b,
"op" : "$inputRoot.op"
},
"output" : {
"c" : $inputRoot.c
}
}
```
1. Pilih **Simpan**.
**Untuk menguji template pemetaan**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Untuk **Path**, lakukan hal berikut:
1. Untuk **operand1, masukkan**. **1**
1. Untuk **operand2, masukkan**. **2**
1. Untuk **operator**, masukkan**\$1**.
1. Pilih **Uji**.
1. Hasilnya akan terlihat seperti berikut:
```
{
"input": {
"a": 1,
"b": 2,
"op": "+"
},
"output": {
"c": 3
}
}
```
Pada titik ini, Anda hanya dapat memanggil API menggunakan fitur **Uji** di konsol API Gateway. Untuk membuatnya tersedia bagi klien, Anda harus menerapkan API Anda. Selalu pastikan untuk menerapkan ulang API Anda setiap kali Anda menambahkan, memodifikasi, atau menghapus sumber daya atau metode, memperbarui pemetaan data, atau memperbarui pengaturan tahap. Jika tidak, fitur atau pembaruan baru tidak akan tersedia untuk klien API Anda. sebagai berikut:
**Untuk menerapkan API**
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **New stage**.
1. Untuk **nama Panggung**, masukkan**Prod**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
1. (Opsional) Di bawah **detail Tahap**, untuk **Invoke URL**, Anda dapat memilih ikon salin untuk menyalin URL pemanggilan API Anda. Anda dapat menggunakan ini dengan alat seperti [Postman](https://www.postman.com) dan [cURL](https://curl.se/) untuk menguji API Anda.
**catatan**
Selalu terapkan ulang API Anda setiap kali Anda menambahkan, memodifikasi, atau menghapus sumber daya atau metode, memperbarui pemetaan data, atau memperbarui pengaturan tahap. Jika tidak, fitur atau pembaruan baru tidak akan tersedia untuk klien API Anda.
# Definisi OpenAPI dari contoh API terintegrasi dengan fungsi Lambda
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2017-04-20T04:08:08Z",
"title": "LambdaCalc"
},
"host": "uojnr9hd57.execute-api.us-east-1.amazonaws.com",
"basePath": "/test",
"schemes": [
"https"
],
"paths": {
"/calc": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "query",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
},
"headers": {
"operand_1": {
"type": "string"
},
"operand_2": {
"type": "string"
},
"operator": {
"type": "string"
}
}
}
},
"x-amazon-apigateway-request-validator": "Validate query string parameters and headers",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.operator": "integration.response.body.op",
"method.response.header.operand_2": "integration.response.body.b",
"method.response.header.operand_1": "integration.response.body.a"
},
"responseTemplates": {
"application/json": "#set($res = $input.path('$'))\n{\n \"result\": \"$res.a, $res.b, $res.op => $res.c\",\n \"a\" : \"$res.a\",\n \"b\" : \"$res.b\",\n \"op\" : \"$res.op\",\n \"c\" : \"$res.c\"\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_match",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n \"b\": \"$input.params('operand2')\", \n \"op\": \"$input.params('operator')\" \n}"
},
"type": "aws"
}
},
"post": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"in": "body",
"name": "Input",
"required": true,
"schema": {
"$ref": "#/definitions/Input"
}
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-request-validator": "Validate body",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : $inputRoot.op,\n \"c\" : $inputRoot.c\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"type": "aws"
}
}
},
"/calc/{operand1}/{operand2}/{operator}": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"input\" : {\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : \"$inputRoot.op\"\n },\n \"output\" : {\n \"c\" : $inputRoot.c\n }\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n \"b\": \"$input.params('operand2')\",\n \"op\": #if($input.params('operator')=='%2F')\"/\"#{else}\"$input.params('operator')\"#end\n \n}"
},
"contentHandling": "CONVERT_TO_TEXT",
"type": "aws"
}
}
}
},
"definitions": {
"Input": {
"type": "object",
"required": [
"a",
"b",
"op"
],
"properties": {
"a": {
"type": "number"
},
"b": {
"type": "number"
},
"op": {
"type": "string",
"description": "binary op of ['+', 'add', '-', 'sub', '*', 'mul', '%2F', 'div']"
}
},
"title": "Input"
},
"Output": {
"type": "object",
"properties": {
"c": {
"type": "number"
}
},
"title": "Output"
},
"Result": {
"type": "object",
"properties": {
"input": {
"$ref": "#/definitions/Input"
},
"output": {
"$ref": "#/definitions/Output"
}
},
"title": "Result"
}
},
"x-amazon-apigateway-request-validators": {
"Validate body": {
"validateRequestParameters": false,
"validateRequestBody": true
},
"Validate query string parameters and headers": {
"validateRequestParameters": true,
"validateRequestBody": false
}
}
}
```
------
# Tutorial: Buat REST API sebagai proxy Amazon S3
Sebagai contoh untuk menampilkan menggunakan REST API di API Gateway ke proxy Amazon S3, bagian ini menjelaskan cara membuat dan mengonfigurasi REST API untuk mengekspos operasi Amazon S3 berikut:
+ Paparkan GET di sumber daya root API untuk [mencantumkan semua bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html) pemanggil.
+ Paparkan GET pada resource Folder untuk [melihat daftar semua objek di bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html).
+ Paparkan GET pada Folder/Item sumber daya untuk [melihat atau mengunduh objek dari bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html).
Anda mungkin ingin mengimpor API sampel sebagai proxy Amazon S3, seperti yang ditunjukkan pada. [Definisi OpenAPI dari API sampel sebagai proxy Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md) Sampel ini berisi metode yang lebih terbuka. Untuk petunjuk tentang cara mengimpor API menggunakan definisi OpenAPI, lihat. [Kembangkan REST APIs menggunakan OpenAPI di API Gateway](api-gateway-import-api.md)
**catatan**
Untuk mengintegrasikan API Gateway API Anda dengan Amazon S3, Anda harus memilih wilayah tempat layanan API Gateway dan Amazon S3 tersedia. Untuk ketersediaan wilayah, lihat [Titik Akhir dan Kuota Amazon API Gateway](https://docs.aws.amazon.com/general/latest/gr/apigateway.html).
**Topics**
+ [Siapkan izin IAM untuk API untuk menjalankan tindakan Amazon S3](#api-as-s3-proxy-iam-permissions)
+ [Buat sumber daya API untuk mewakili sumber daya Amazon S3](#api-as-s3-proxy-create-resources)
+ [Paparkan metode API untuk mencantumkan bucket Amazon S3 pemanggil](#api-root-get-as-s3-get-service)
+ [Mengekspos metode API untuk mengakses bucket Amazon S3](#api-folder-operations-as-s3-bucket-actions)
+ [Mengekspos metode API untuk mengakses objek Amazon S3 dalam bucket](#api-items-in-folder-as-s3-objects-in-bucket)
+ [Definisi OpenAPI dari API sampel sebagai proxy Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md)
+ [Panggil API menggunakan klien REST API](api-as-s3-proxy-test-using-postman.md)
## Siapkan izin IAM untuk API untuk menjalankan tindakan Amazon S3
Untuk mengizinkan API menjalankan tindakan Amazon S3, Anda harus memiliki kebijakan IAM yang sesuai yang dilampirkan ke peran IAM. Pada langkah ini, Anda membuat peran IAM baru.
**Untuk membuat peran eksekusi proxy AWS layanan**
1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Pilih **Peran**.
1. Pilih **Buat peran**.
1. Pilih **AWS layanan** di bawah **Pilih jenis entitas tepercaya**, lalu pilih **API Gateway** dan pilih **Izinkan API Gateway untuk mendorong CloudWatch log ke Log**.
1. Pilih **Berikutnya**, lalu pilih **Berikutnya**.
1. Untuk **nama Peran****APIGatewayS3ProxyPolicy**, masukkan, lalu pilih **Buat peran**.
1. Dalam daftar **Peran**, pilih peran yang baru saja Anda buat. Anda mungkin perlu menggulir atau menggunakan bilah pencarian untuk menemukan peran.
1. Untuk peran yang dipilih, pilih tab **Tambahkan izin**.
1. Pilih **Lampirkan kebijakan** dari daftar dropdown.
1. Di bilah pencarian, masukkan **AmazonS3FullAccess** dan pilih **Tambahkan izin**.
**catatan**
Tutorial ini menggunakan kebijakan terkelola untuk kesederhanaan. Sebagai praktik terbaik, Anda harus membuat kebijakan IAM Anda sendiri untuk memberikan izin minimum yang diperlukan.
1. Perhatikan **ARN Peran** yang baru dibuat, Anda akan menggunakannya nanti.
## Buat sumber daya API untuk mewakili sumber daya Amazon S3
Anda menggunakan sumber daya root (`/`) API sebagai wadah bucket Amazon S3 pemanggil yang diautentikasi. Anda juga membuat `Folder` dan `Item` sumber daya untuk mewakili bucket Amazon S3 tertentu dan objek Amazon S3 tertentu, masing-masing. Nama folder dan kunci objek akan ditentukan, dalam bentuk parameter jalur sebagai bagian dari URL permintaan, oleh pemanggil.
**catatan**
Saat mengakses objek yang kunci objeknya termasuk `/` atau karakter khusus lainnya, karakter harus dikodekan URL. Misalnya, `test/test.txt` harus dikodekan ke. `test%2Ftest.txt`
**Untuk membuat sumber daya API yang mengekspos fitur layanan Amazon S3**
1. **Saat Wilayah AWS Anda membuat bucket Amazon S3, buat API bernama myS3.** Sumber daya root API ini (**/**) mewakili layanan Amazon S3. Pada langkah ini, Anda membuat dua sumber daya tambahan**/\$1folder\$1** dan**/\$1item\$1**.
1. Pilih **Buat sumber daya**.
1. Matikan **sumber daya Proxy**.
1. Untuk **jalur Sumber Daya**, pilih`/`.
1. Untuk **Nama sumber daya**, masukkan **\$1folder\$1**.
1. Biarkan **CORS (Cross Origin Resource Sharing) tidak dicentang**.
1. Pilih **Buat sumber daya**.
1. Pilih sumber daya**/\$1folder\$1**, lalu pilih **Buat sumber daya**.
1. Gunakan langkah-langkah sebelumnya untuk membuat sumber daya turunan dari**/\$1folder\$1** bernama**\$1item\$1**.
API final Anda akan terlihat mirip dengan yang berikut ini:
![\[Buat API di API Gateway sebagai proxy Amazon S3\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_s3_create_api-resources_new_console.png)
## Paparkan metode API untuk mencantumkan bucket Amazon S3 pemanggil
Mendapatkan daftar bucket Amazon S3 dari penelepon melibatkan pemanggilan tindakan [GET Service di](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html) Amazon S3. Pada sumber daya root API, (**/**), buat metode GET. Konfigurasikan metode GET untuk diintegrasikan dengan Amazon S3, sebagai berikut.
**Untuk membuat dan menginisialisasi metode API `GET /`**
1. Pilih sumber daya**/**, lalu pilih **Create method**.
1. Untuk jenis metode, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **Layanan AWS**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat bucket Amazon S3.
1. Untuk **Layanan AWS**, pilih **Amazon Simple Storage Service**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **GET**.
1. Untuk **tipe Action**, pilih **Use path override**.
Dengan penggantian jalur, API Gateway meneruskan permintaan klien ke Amazon S3 sebagai permintaan gaya jalur API [Amazon S3 REST API yang sesuai, di mana sumber daya](https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAPI.html) Amazon S3 diekspresikan oleh jalur sumber daya pola. `s3-host-name/bucket/key` API Gateway menyetel `s3-host-name` dan meneruskan klien yang ditentukan `bucket` dan `key` dari klien ke Amazon S3.
1. Untuk **Path override**, masukkan**/**.
1. Untuk **peran Eksekusi**, masukkan peran ARN untuk. **APIGatewayS3ProxyPolicy**
1. Pilih **Pengaturan permintaan Metode**.
Anda menggunakan pengaturan permintaan metode untuk mengontrol siapa yang dapat memanggil metode API Anda ini.
1. Untuk **Otorisasi**, dari menu tarik-turun, pilih. `AWS_IAM`
![\[Mendeklarasikan jenis respons metode\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_s3_setup_method_request_authorization_new_console.png)
1. Pilih **metode Buat**.
Pengaturan ini mengintegrasikan `GET https://your-api-host/stage/` permintaan frontend dengan backend. `GET https://your-s3-host/`
**Agar API Anda mengembalikan respons dan pengecualian yang berhasil dengan benar ke penelepon, Anda mendeklarasikan respons 200, 400, dan 500 dalam respons Metode.** Anda menggunakan pemetaan default untuk 200 tanggapan sehingga tanggapan backend dari kode status yang tidak dideklarasikan di sini akan dikembalikan ke pemanggil sebagai 200 respons.
**Untuk mendeklarasikan tipe respons untuk metode `GET /`**
1. Pada tab **Respons Metode**, di bawah **Respons 200**, pilih **Edit**.
1. Pilih **Add header** dan lakukan hal berikut:
1. Untuk **nama Header**, masukkan**Content-Type**.
1. Pilih **Tambahkan header**.
Ulangi langkah-langkah ini untuk membuat **Timestamp** header dan **Content-Length** header.
1. Pilih **Simpan**.
1. Pada tab **Respons metode**, di bawah **Respons metode**, pilih **Buat respons**.
1. Untuk **kode status HTTP**, masukkan **400**.
Anda tidak menetapkan header apa pun untuk respons ini.
1. Pilih **Simpan**.
1. Ulangi langkah-langkah berikut untuk membuat respons 500.
Anda tidak menetapkan header apa pun untuk respons ini.
Karena respons integrasi yang berhasil dari Amazon S3 mengembalikan bucket list sebagai payload XHTML dan respons metode default dari API Gateway mengembalikan payload JSON, Anda harus memetakan nilai parameter header Content-Type backend ke counterpart frontend. Jika tidak, klien akan menerima `application/json` untuk tipe konten ketika badan respons sebenarnya adalah string XHTML. Prosedur berikut menunjukkan cara mengatur ini. Selain itu, Anda juga ingin menampilkan parameter header lainnya ke klien, seperti Tanggal dan Panjang Konten.
**Untuk mengatur pemetaan header respons untuk metode GET/**
1. Pada tab **Respons integrasi**, di bawah **Default - Respons**, pilih **Edit**.
1. Untuk header **Content-Length**, masukkan **integration.response.header.Content-Length** untuk nilai pemetaan.
1. Untuk header **Content-Type**, masukkan **integration.response.header.Content-Type** untuk nilai pemetaan.
1. Untuk header **Timestamp**, masukkan **integration.response.header.Date** untuk nilai pemetaan.
1. Pilih **Simpan**. Hasilnya akan terlihat mirip dengan yang berikut:
![\[Header respons integrasi peta ke header respons metode\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_s3_setup_integration_response_headers_new_console.png)
1. Pada tab **Respons Integrasi**, di bawah **Respons integrasi**, pilih **Buat respons**.
1. Untuk **regex status HTTP, masukkan**. **4\$1d\$12\$1** Ini memetakan semua kode status respons HTTP 4xx ke respons metode.
1. Untuk **kode status respons Metode**, pilih**400**.
1. Pilih **Buat**.
1. Ulangi langkah-langkah berikut untuk membuat respons integrasi untuk respons metode 500. Untuk **regex status HTTP, masukkan**. **5\$1d\$12\$1**
Sebagai praktik yang baik, Anda dapat menguji API yang telah Anda konfigurasikan sejauh ini.
**Untuk menguji `GET /` metode**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Pilih **Uji**. Hasilnya akan terlihat seperti gambar berikut:
![\[Uji akar API GET hasil bucket\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_s3_test_root_get_result_new_console.png)
## Mengekspos metode API untuk mengakses bucket Amazon S3
Untuk bekerja dengan bucket Amazon S3, Anda mengekspos `GET` metode pada resource/\$1folder\$1 untuk mencantumkan objek dalam bucket. Instruksi mirip dengan yang dijelaskan dalam[Paparkan metode API untuk mencantumkan bucket Amazon S3 pemanggil](#api-root-get-as-s3-get-service). Untuk metode lainnya, Anda dapat mengimpor contoh API di sini,[Definisi OpenAPI dari API sampel sebagai proxy Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md).
**Untuk mengekspos metode GET pada sumber daya folder**
1. Pilih sumber daya**/\$1folder\$1**, lalu pilih **Create method**.
1. Untuk jenis metode, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **Layanan AWS**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat bucket Amazon S3.
1. Untuk **Layanan AWS**, pilih **Amazon Simple Storage Service**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **GET**.
1. Untuk **tipe Action**, pilih **Use path override**.
1. Untuk **Path override**, masukkan**\$1bucket\$1**.
1. Untuk **peran Eksekusi**, masukkan peran ARN untuk. **APIGatewayS3ProxyPolicy**
1. Pilih **metode Buat**.
Anda mengatur parameter `{folder}` jalur di URL titik akhir Amazon S3. Anda perlu memetakan parameter `{folder}` jalur permintaan metode ke parameter `{bucket}` jalur permintaan integrasi.
**Untuk memetakan `{folder}` ke `{bucket}`**
1. Pada tab **Permintaan integrasi**, di bawah **Pengaturan permintaan integrasi**, pilih **Edit**.
1. Pilih **parameter jalur URL**, lalu pilih **Tambahkan parameter jalur**.
1. Untuk **Nama**, masukkan **bucket**.
1. Untuk **Dipetakan dari**, masukkan**method.request.path.folder**.
1. Pilih **Simpan**.
Sekarang, Anda menguji API Anda.
**Untuk menguji `/{folder} GET` metode.**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Di bawah **Path**, untuk **folder**, masukkan nama bucket Anda.
1. Pilih **Uji**.
Hasil tes akan berisi daftar objek di bucket Anda.
![\[Uji metode GET untuk membuat bucket Amazon S3.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_s3_test_api_folder_get_new_console.png)
## Mengekspos metode API untuk mengakses objek Amazon S3 dalam bucket
Amazon S3 mendukung tindakan GET, DELETE, HEAD, OPTIONS, POST, dan PUT untuk mengakses dan mengelola objek dalam bucket tertentu. Dalam tutorial ini, Anda mengekspos `GET` metode pada `{folder}/{item}` sumber daya untuk mendapatkan gambar dari ember. Untuk aplikasi `{folder}/{item}` sumber daya lainnya, lihat contoh API,[Definisi OpenAPI dari API sampel sebagai proxy Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md).
**Untuk mengekspos metode GET pada sumber daya item**
1. Pilih sumber daya**/\$1item\$1**, lalu pilih **Create method**.
1. Untuk jenis metode, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **Layanan AWS**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat bucket Amazon S3.
1. Untuk **Layanan AWS**, pilih **Amazon Simple Storage Service**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **GET**.
1. Untuk **tipe Action**, pilih **Use path override**.
1. Untuk **penggantian Path**, masukkan **\$1bucket\$1/\$1object\$1**.
1. Untuk **peran Eksekusi**, masukkan peran ARN untuk. **APIGatewayS3ProxyPolicy**
1. Pilih **metode Buat**.
Anda mengatur parameter `{folder}` dan `{item}` jalur di URL titik akhir Amazon S3. Anda perlu memetakan parameter jalur permintaan metode ke parameter jalur permintaan integrasi.
Dalam langkah ini, Anda melakukan hal berikut:
+ Petakan parameter `{folder}` jalur permintaan metode ke parameter `{bucket}` jalur permintaan integrasi.
+ Petakan parameter `{item}` jalur permintaan metode ke parameter `{object}` jalur permintaan integrasi.
**Untuk memetakan `{folder}` ke `{bucket}` dan `{item}` ke `{object}`**
1. Pada tab **Permintaan integrasi**, di bawah **Pengaturan permintaan integrasi**, pilih **Edit**.
1. Pilih **parameter jalur URL**.
1. Pilih **Tambahkan parameter jalur**.
1. Untuk **Nama**, masukkan **bucket**.
1. Untuk **Dipetakan dari**, masukkan**method.request.path.folder**.
1. Pilih **Tambahkan parameter jalur**.
1. Untuk **Nama**, masukkan **object**.
1. Untuk **Dipetakan dari**, masukkan**method.request.path.item**.
1. Pilih **Simpan**.
**Untuk menguji `/{folder}/{object} GET` metode.**
1. Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
1. Di bawah **Path**, untuk **folder**, masukkan nama bucket Anda.
1. Di bawah **Path**, untuk **item**, masukkan nama item.
1. Pilih **Uji**.
Badan respons akan berisi isi item.
![\[Uji metode GET untuk membuat bucket Amazon S3.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/aws_proxy_s3_test_api_item_get_new_console.png)
Permintaan mengembalikan teks biasa (“Hello world”) dengan benar sebagai konten file yang ditentukan (test.txt) di bucket Amazon S3 yang diberikan (amzn-s3-demo-bucket).
Untuk mengunduh atau mengunggah file biner, yang di API Gateway dianggap sebagai hal apa pun selain konten JSON yang dikodekan utf-8, diperlukan pengaturan API tambahan. Ini diuraikan sebagai berikut:
**Untuk mengunduh atau mengunggah file biner dari S3**
1. Daftarkan jenis media dari file yang terpengaruh ke API binaryMediaTypes. Anda dapat melakukan ini di konsol:
1. Pilih **pengaturan API** untuk API.
1. Di bawah **Jenis media biner**, pilih **Kelola jenis media**.
1. Pilih **Tambahkan jenis media biner**, lalu masukkan jenis media yang diperlukan, misalnya,`image/png`.
1. Pilih **Simpan perubahan** untuk menyimpan pengaturan.
1. Tambahkan header `Content-Type` (untuk diunggah) and/or `Accept` (untuk diunduh) ke permintaan metode untuk meminta klien menentukan jenis media biner yang diperlukan dan memetakannya ke permintaan integrasi.
1. Setel **Penanganan Konten** ke `Passthrough` dalam permintaan integrasi (untuk diunggah) dan dalam respons integrasi (untuk diunduh). Pastikan tidak ada template pemetaan yang ditentukan untuk jenis konten yang terpengaruh. Untuk informasi selengkapnya, lihat [Transformasi data untuk REST APIs di API Gateway](rest-api-data-transformations.md).
Batas ukuran muatan adalah 10 MB. Lihat [Kuota untuk mengonfigurasi dan menjalankan REST API di API Gateway](api-gateway-execution-service-limits-table.md).
Pastikan file di Amazon S3 memiliki jenis konten yang benar yang ditambahkan sebagai metadata file. Untuk konten media yang dapat disederhanakan, `Content-Disposition:inline` mungkin juga perlu ditambahkan ke metadata.
Untuk informasi selengkapnya tentang dukungan biner di API Gateway, lihat[Konversi jenis konten di API Gateway](api-gateway-payload-encodings-workflow.md).
# Definisi OpenAPI dari API sampel sebagai proxy Amazon S3
Definisi OpenAPI berikut menjelaskan API yang berfungsi sebagai proxy Amazon S3. API ini berisi lebih banyak operasi Amazon S3 daripada API yang Anda buat dalam tutorial. Metode berikut diekspos dalam definisi OpenAPI:
+ Paparkan GET di sumber daya root API untuk [mencantumkan semua bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html) pemanggil.
+ Paparkan GET pada resource Folder untuk [melihat daftar semua objek di bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html).
+ Paparkan PUT pada sumber daya Folder untuk [menambahkan bucket ke Amazon](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html) S3.
+ Paparkan DELETE pada resource Folder untuk [menghapus bucket dari Amazon](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucket.html) S3.
+ Paparkan GET pada Folder/Item sumber daya untuk [melihat atau mengunduh objek dari bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html).
+ Paparkan PUT pada Folder/Item sumber daya untuk [mengunggah objek ke bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html).
+ Paparkan HEAD pada Folder/Item sumber daya untuk [mendapatkan metadata objek di bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html).
+ Paparkan DELETE pada Folder/Item sumber daya untuk [menghapus objek dari bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObject.html).
Untuk petunjuk tentang cara mengimpor API menggunakan definisi OpenAPI, lihat. [Kembangkan REST APIs menggunakan OpenAPI di API Gateway](api-gateway-import-api.md)
Untuk petunjuk tentang cara membuat API serupa, lihat[Tutorial: Buat REST API sebagai proxy Amazon S3](integrating-api-with-aws-services-s3.md).
Untuk mempelajari cara menjalankan API ini menggunakan [Postman](https://www.postman.com/), yang mendukung otorisasi AWS IAM, lihat. [Panggil API menggunakan klien REST API](api-as-s3-proxy-test-using-postman.md)
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2016-10-13T23:04:43Z",
"title": "MyS3"
},
"host": "9gn28ca086.execute-api.{region}.amazonaws.com",
"basePath": "/S3",
"schemes": [
"https"
],
"paths": {
"/": {
"get": {
"produces": [
"application/json"
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Timestamp": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Content-Length": "integration.response.header.Content-Length",
"method.response.header.Timestamp": "integration.response.header.Date"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"uri": "arn:aws:apigateway:us-west-2:s3:path//",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
}
},
"/{folder}": {
"get": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Date": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Date": "integration.response.header.Date",
"method.response.header.Content-Length": "integration.response.header.content-length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
},
"put": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Content-Length": "integration.response.header.Content-Length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder",
"integration.request.header.Content-Type": "method.request.header.Content-Type"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",
"httpMethod": "PUT",
"type": "aws"
}
},
"delete": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Date": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Date": "integration.response.header.Date"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",
"httpMethod": "DELETE",
"type": "aws"
}
}
},
"/{folder}/{item}": {
"get": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"content-type": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.content-type": "integration.response.header.content-type",
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
},
"head": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Content-Length": "integration.response.header.Content-Length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "HEAD",
"type": "aws"
}
},
"put": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type",
"method.response.header.Content-Length": "integration.response.header.Content-Length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder",
"integration.request.header.Content-Type": "method.request.header.Content-Type"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "PUT",
"type": "aws"
}
},
"delete": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200"
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "DELETE",
"type": "aws"
}
}
}
},
"securityDefinitions": {
"sigv4": {
"type": "apiKey",
"name": "Authorization",
"in": "header",
"x-amazon-apigateway-authtype": "awsSigv4"
}
},
"definitions": {
"Empty": {
"type": "object",
"title": "Empty Schema"
}
}
}
```
------
#### [ OpenAPI 3.0 ]
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "MyS3",
"version" : "2016-10-13T23:04:43Z"
},
"servers" : [ {
"url" : "https://9gn28ca086.execute-api.{region}.amazonaws.com/{basePath}",
"variables" : {
"basePath" : {
"default" : "S3"
}
}
} ],
"paths" : {
"/{folder}" : {
"get" : {
"parameters" : [ {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Date" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Date" : "integration.response.header.Date",
"method.response.header.Content-Length" : "integration.response.header.content-length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"put" : {
"parameters" : [ {
"name" : "Content-Type",
"in" : "header",
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "PUT",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Content-Length" : "integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder",
"integration.request.header.Content-Type" : "method.request.header.Content-Type"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"delete" : {
"parameters" : [ {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Date" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "DELETE",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Date" : "integration.response.header.Date"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
},
"/{folder}/{item}" : {
"get" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"content-type" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.content-type" : "integration.response.header.content-type",
"method.response.header.Content-Type" : "integration.response.header.Content-Type"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"put" : {
"parameters" : [ {
"name" : "Content-Type",
"in" : "header",
"schema" : {
"type" : "string"
}
}, {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "PUT",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Content-Length" : "integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder",
"integration.request.header.Content-Type" : "method.request.header.Content-Type"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"delete" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "DELETE",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200"
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"head" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "HEAD",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Content-Length" : "integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
},
"/" : {
"get" : {
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Timestamp" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path//",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" : "integration.response.header.Content-Type",
"method.response.header.Content-Length" : "integration.response.header.Content-Length",
"method.response.header.Timestamp" : "integration.response.header.Date"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
}
},
"components" : {
"schemas" : {
"Empty" : {
"title" : "Empty Schema",
"type" : "object"
}
}
}
}
```
------
# Panggil API menggunakan klien REST API
Untuk memberikan end-to-end tutorial, kami sekarang menunjukkan cara memanggil API menggunakan [Postman](https://www.postman.com/), yang mendukung otorisasi AWS IAM.
**Untuk memanggil API proxy Amazon S3 kami menggunakan Postman**
1. Menerapkan atau menerapkan ulang API. Catat URL dasar API yang ditampilkan di sebelah **Invoke URL** di bagian atas **Stage Editor**.
1. Luncurkan Postman.
1. Pilih **Otorisasi** dan kemudian pilih`AWS Signature`. Masukkan ID Kunci Akses dan Kunci Akses Rahasia pengguna IAM Anda ke dalam bidang **AccessKey**dan **SecretKey**input, masing-masing. Masukkan Wilayah AWS ke mana API Anda digunakan di kotak teks **AWS Region**. Masukkan `execute-api` di kolom input **Nama Layanan**.
Anda dapat membuat sepasang kunci dari tab **Security Credentials** dari akun pengguna IAM Anda di IAM Management Console.
1. Untuk menambahkan bucket yang diberi nama `amzn-s3-demo-bucket` ke akun Amazon S3 Anda di wilayah ini`{region}`:
1. Pilih **PUT** dari daftar metode drop-down dan ketik URL metode (`https://api-id.execute-api.aws-region.amazonaws.com/stage/folder-name`
1. Tetapkan nilai `Content-Type` header sebagai`application/xml`. Anda mungkin perlu menghapus header yang ada sebelum menyetel jenis konten.
1. Pilih item menu **Body** dan ketik fragmen XHTML berikut sebagai badan permintaan:
```
{region}
```
1. Pilih **Kirim** untuk mengirimkan permintaan. Jika berhasil, Anda harus menerima `200 OK` respons dengan muatan kosong.
1. Untuk menambahkan file teks ke ember, ikuti petunjuk di atas. Jika Anda menentukan nama bucket **amzn-s3-demo-bucket** for `{folder}` dan nama file **Readme.txt** for `{item}` di URL dan memberikan string teks **Hello, World\$1** sebagai isi file (sehingga menjadikannya payload permintaan), permintaan menjadi
```
PUT /S3/amzn-s3-demo-bucket/Readme.txt HTTP/1.1
Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T062647Z
Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/execute-api/aws4_request, SignedHeaders=content-length;content-type;host;x-amz-date, Signature=ccadb877bdb0d395ca38cc47e18a0d76bb5eaf17007d11e40bf6fb63d28c705b
Cache-Control: no-cache
Postman-Token: 6135d315-9cc4-8af8-1757-90871d00847e
Hello, World!
```
Jika semuanya berjalan dengan baik, Anda harus menerima `200 OK` respons dengan muatan kosong.
1. Untuk mendapatkan konten `Readme.txt` file yang baru saja kita tambahkan ke `amzn-s3-demo-bucket` bucket, lakukan permintaan GET seperti berikut ini:
```
GET /S3/amzn-s3-demo-bucket/Readme.txt HTTP/1.1
Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T063759Z
Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date, Signature=ba09b72b585acf0e578e6ad02555c00e24b420b59025bc7bb8d3f7aed1471339
Cache-Control: no-cache
Postman-Token: d60fcb59-d335-52f7-0025-5bd96928098a
```
Jika berhasil, Anda harus menerima `200 OK` respons dengan string `Hello, World!` teks sebagai payload.
1. Untuk mencantumkan item di `amzn-s3-demo-bucket` bucket, kirimkan permintaan berikut:
```
GET /S3/amzn-s3-demo-bucket HTTP/1.1
Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T064324Z
Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date, Signature=4ac9bd4574a14e01568134fd16814534d9951649d3a22b3b0db9f1f5cd4dd0ac
Cache-Control: no-cache
Postman-Token: 9c43020a-966f-61e1-81af-4c49ad8d1392
```
Jika berhasil, Anda harus menerima `200 OK` respons dengan payload XHTML yang menampilkan satu item dalam bucket yang ditentukan, kecuali jika Anda menambahkan lebih banyak file ke bucket sebelum mengirimkan permintaan ini.
```
apig-demo-5
1000
false
Readme.txt
2016-10-15T06:26:48.000Z
"65a8e27d8879283831b664bd8b7f0ad4"
13
06e4b09e9d...603addd12ee
user-name
STANDARD
```
**catatan**
Untuk mengunggah atau mengunduh gambar, Anda perlu mengatur penanganan konten ke CONVERT\$1TO\$1BINARY.
# Tutorial: Buat REST API sebagai proxy Amazon Kinesis
Halaman ini menjelaskan cara membuat dan mengonfigurasi REST API dengan integrasi `AWS` tipe untuk mengakses Kinesis.
**catatan**
Untuk mengintegrasikan API Gateway API Anda dengan Kinesis, Anda harus memilih wilayah tempat layanan API Gateway dan Kinesis tersedia. Untuk ketersediaan wilayah, lihat [Titik Akhir Layanan dan Kuota](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html).
Untuk tujuan ilustrasi, kami membuat contoh API untuk memungkinkan klien melakukan hal berikut:
1. Daftar aliran yang tersedia pengguna di Kinesis
1. Membuat, mendeskripsikan, atau menghapus aliran tertentu
1. Membaca catatan data dari atau menulis catatan data ke dalam aliran yang ditentukan
Untuk menyelesaikan tugas-tugas sebelumnya, API mengekspos metode pada berbagai sumber daya untuk menjalankan yang berikut ini, masing-masing:
1. `ListStreams`Tindakan dalam Kinesis
1. , `CreateStream``DescribeStream`, atau `DeleteStream` tindakan
1. Tindakan `GetRecords` atau `PutRecords` (termasuk`PutRecord`) dalam Kinesis
Secara khusus, kami membangun API sebagai berikut:
+ Paparkan metode HTTP GET pada `/streams` sumber daya API dan integrasikan metode tersebut dengan [ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html)tindakan di Kinesis untuk mencantumkan aliran di akun pemanggil.
+ Paparkan metode HTTP POST pada `/streams/{stream-name}` sumber daya API dan integrasikan metode tersebut dengan [CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html)tindakan di Kinesis untuk membuat aliran bernama di akun pemanggil.
+ Paparkan metode HTTP GET pada `/streams/{stream-name}` sumber daya API dan integrasikan metode tersebut dengan [DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html)tindakan di Kinesis untuk mendeskripsikan aliran bernama di akun pemanggil.
+ Paparkan metode HTTP DELETE pada `/streams/{stream-name}` sumber daya API dan integrasikan metode tersebut dengan [DeleteStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DeleteStream.html)tindakan di Kinesis untuk menghapus aliran di akun pemanggil.
+ Paparkan metode HTTP PUT pada `/streams/{stream-name}/record` sumber daya API dan integrasikan metode dengan [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html)tindakan di Kinesis. Ini memungkinkan klien untuk menambahkan catatan data tunggal ke aliran bernama.
+ Paparkan metode HTTP PUT pada `/streams/{stream-name}/records` sumber daya API dan integrasikan metode dengan [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html)tindakan di Kinesis. Ini memungkinkan klien untuk menambahkan daftar catatan data ke aliran bernama.
+ Paparkan metode HTTP GET pada `/streams/{stream-name}/records` sumber daya API dan integrasikan metode dengan [GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html)tindakan di Kinesis. Hal ini memungkinkan klien untuk daftar catatan data dalam aliran bernama, dengan iterator shard tertentu. Sebuah iterator shard menentukan posisi shard dari mana untuk mulai membaca catatan data secara berurutan.
+ Paparkan metode HTTP GET pada `/streams/{stream-name}/sharditerator` sumber daya API dan integrasikan metode dengan [GetShardIterator](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html)tindakan di Kinesis. Metode pembantu ini harus diberikan pada `ListStreams` tindakan di Kinesis.
Anda dapat menerapkan instruksi yang disajikan di sini untuk tindakan Kinesis lainnya. Untuk daftar lengkap tindakan Kinesis, lihat Referensi API [Amazon Kinesis](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html).
Alih-alih menggunakan konsol API Gateway untuk membuat API sampel, Anda dapat mengimpor API sampel ke API Gateway menggunakan API Gateway [Import API](https://docs.aws.amazon.com/apigateway/latest/api/API_ImportRestApi.html). Untuk informasi tentang cara menggunakan API Impor, lihat[Kembangkan REST APIs menggunakan OpenAPI di API Gateway](api-gateway-import-api.md).
## Membuat peran dan kebijakan IAM untuk API untuk mengakses Kinesis
Untuk mengizinkan API menjalankan tindakan Kinesis, Anda harus memiliki kebijakan IAM yang sesuai yang dilampirkan ke peran IAM. Pada langkah ini, Anda membuat peran IAM baru.
**Untuk membuat peran eksekusi proxy AWS layanan**
1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Pilih **Peran**.
1. Pilih **Buat peran**.
1. Pilih **AWS layanan** di bawah **Pilih jenis entitas tepercaya**, lalu pilih **API Gateway** dan pilih **Izinkan API Gateway untuk mendorong CloudWatch log ke Log**.
1. Pilih **Berikutnya**, lalu pilih **Berikutnya**.
1. Untuk **nama Peran****APIGatewayKinesisProxyPolicy**, masukkan, lalu pilih **Buat peran**.
1. Dalam daftar **Peran**, pilih peran yang baru saja Anda buat. Anda mungkin perlu menggulir atau menggunakan bilah pencarian untuk menemukan peran.
1. Untuk peran yang dipilih, pilih tab **Tambahkan izin**.
1. Pilih **Lampirkan kebijakan** dari daftar dropdown.
1. Di bilah pencarian, masukkan **AmazonKinesisFullAccess** dan pilih **Tambahkan izin**.
**catatan**
Tutorial ini menggunakan kebijakan terkelola untuk kesederhanaan. Sebagai praktik terbaik, Anda harus membuat kebijakan IAM Anda sendiri untuk memberikan izin minimum yang diperlukan.
1. Perhatikan **ARN Peran** yang baru dibuat, Anda akan menggunakannya nanti.
## Buat API sebagai proxy Kinesis
Gunakan langkah-langkah berikut untuk membuat API di konsol API Gateway.
**Untuk membuat API sebagai proxy AWS layanan untuk Kinesis**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Jika ini adalah pertama kalinya Anda menggunakan API Gateway, Anda akan melihat halaman yang memperkenalkan Anda ke fitur layanan. Di bawah **REST API**, pilih **Build**. **Saat munculan **Create Example API** muncul, pilih OK.**
Jika ini bukan pertama kalinya Anda menggunakan API Gateway, pilih **Buat API**. Di bawah **REST API**, pilih **Build**.
1. Pilih **API Baru**.
1. Dalam **nama API**, masukkan**KinesisProxy**. Simpan nilai default untuk semua bidang lainnya.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Buat API**.
Setelah API dibuat, konsol API Gateway menampilkan halaman **Resources**, yang hanya berisi sumber daya root (`/`) API.
## Daftar aliran dalam Kinesis
Kinesis mendukung `ListStreams` tindakan dengan panggilan REST API berikut:
```
POST /?Action=ListStreams HTTP/1.1
Host: kinesis..
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.1
Authorization:
X-Amz-Date:
{
...
}
```
Dalam permintaan REST API di atas, tindakan ditentukan dalam parameter `Action` kueri. Atau, Anda dapat menentukan tindakan di `X-Amz-Target` header, sebagai gantinya:
```
POST / HTTP/1.1
Host: kinesis..
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.1
Authorization:
X-Amz-Date:
X-Amz-Target: Kinesis_20131202.ListStreams
{
...
}
```
Dalam tutorial ini, kita menggunakan parameter query untuk menentukan tindakan.
Untuk mengekspos tindakan Kinesis di API, tambahkan `/streams` resource ke root API. Kemudian atur `GET` metode pada sumber daya dan integrasikan metode dengan `ListStreams` aksi Kinesis.
Prosedur berikut menjelaskan cara membuat daftar aliran Kinesis menggunakan konsol API Gateway.
**Untuk membuat daftar aliran Kinesis dengan menggunakan konsol API Gateway**
1. Pilih `/` sumber daya, lalu pilih **Buat sumber daya**.
1. Untuk **Nama sumber daya**, masukkan **streams**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
1. Pilih `/streams` sumber daya, lalu pilih **Create method**, lalu lakukan hal berikut:
1. Untuk **tipe Metode**, pilih **GET**.
**catatan**
Kata kerja HTTP untuk metode yang dipanggil oleh klien mungkin berbeda dari kata kerja HTTP untuk integrasi yang diperlukan oleh backend. Kami memilih `GET` di sini, karena aliran daftar secara intuitif merupakan operasi BACA.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat aliran Kinesis Anda.
1. Untuk **Layanan AWS**, pilih **Kinesis**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
**catatan**
Kami memilih `POST` di sini karena Kinesis mengharuskan `ListStreams` tindakan dipanggil dengannya.
1. Untuk **tipe Tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**ListStreams**.
1. Untuk **peran Eksekusi**, masukkan ARN untuk peran eksekusi Anda.
1. Pertahankan default **Passthrough** untuk **Penanganan Konten**.
1. Pilih **metode Buat**.
1. Pada tab **Permintaan integrasi**, di bawah **Pengaturan permintaan integrasi**, pilih **Edit**.
1. Untuk **Request body passthrough**, pilih **Bila tidak ada templat yang ditentukan (disarankan)**.
1. Pilih **parameter header permintaan URL**, lalu lakukan hal berikut:
1. Pilih **Tambahkan parameter header permintaan**.
1. Untuk **Nama**, masukkan **Content-Type**.
1. Untuk **Dipetakan dari**, masukkan**'application/x-amz-json-1.1'**.
Kami menggunakan pemetaan parameter permintaan untuk mengatur `Content-Type` header ke nilai statis `'application/x-amz-json-1.1'` untuk menginformasikan Kinesis bahwa input adalah versi tertentu dari JSON.
1. Pilih **Mapping templates**, lalu pilih **Add mapping template**, dan lakukan hal berikut:
1. Untuk **Content-Type, masukkan**. **application/json**
1. Untuk **badan Template**, masukkan**\$1\$1**.
1. Pilih **Simpan**.
[ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html#API_ListStreams_RequestSyntax)Permintaan mengambil muatan dari format JSON berikut:
```
{
"ExclusiveStartStreamName": "string",
"Limit": number
}
```
Namun, propertinya opsional. Untuk menggunakan nilai default, kami memilih payload JSON kosong di sini.
1. Uji metode GET pada sumber daya **/streams** untuk menjalankan tindakan `ListStreams` di Kinesis:
Pilih tab **Uji**. Anda mungkin perlu memilih tombol panah kanan untuk menampilkan tab.
Pilih **Tes** untuk menguji metode Anda.
Jika Anda telah membuat dua aliran bernama “MyStream” dan “YourStream” di Kinesis, pengujian yang berhasil mengembalikan respons 200 OK yang berisi muatan berikut:
```
{
"HasMoreStreams": false,
"StreamNames": [
"myStream",
"yourStream"
]
}
```
## Buat, jelaskan, dan hapus aliran di Kinesis
Membuat, mendeskripsikan, dan menghapus aliran di Kinesis melibatkan pembuatan permintaan Kinesis REST API berikut, masing-masing:
```
POST /?Action=CreateStream HTTP/1.1
Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"ShardCount": number,
"StreamName": "string"
}
```
```
POST /?Action=DescribeStream HTTP/1.1
Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"StreamName": "string"
}
```
```
POST /?Action=DeleteStream HTTP/1.1
Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"StreamName":"string"
}
```
Kita dapat membangun API untuk menerima input yang diperlukan sebagai payload JSON dari permintaan metode dan meneruskan payload ke permintaan integrasi. Namun, untuk memberikan lebih banyak contoh pemetaan data antara permintaan metode dan integrasi, serta respons metode dan integrasi, kami membuat API kami agak berbeda.
Kami mengekspos`GET`,`POST`, dan metode `Delete` HTTP pada to-be-named `Stream` sumber daya. Kami menggunakan variabel `{stream-name}` jalur sebagai pengganti sumber daya aliran dan mengintegrasikan metode API ini dengan Kinesis,, dan tindakan `DescribeStream``CreateStream`, masing-masing. `DeleteStream` Kami mengharuskan klien meneruskan data input lain sebagai header, parameter kueri, atau muatan permintaan metode. Kami menyediakan template pemetaan untuk mengubah data ke payload permintaan integrasi yang diperlukan.
**Untuk membuat sumber daya \$1stream-name\$1**
1. Pilih sumber daya **/streams**, lalu pilih **Buat** sumber daya.
1. Matikan **sumber daya Proxy**.
1. Untuk **jalur Sumber Daya**, pilih`/streams`.
1. Untuk **Nama sumber daya**, masukkan **\$1stream-name\$1**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
**Untuk mengonfigurasi dan menguji metode GET pada sumber daya aliran**
1. Pilih sumber daya**/\$1stream-name\$1**, lalu pilih **Create** method.
1. Untuk **tipe Metode**, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat aliran Kinesis Anda.
1. Untuk **Layanan AWS**, pilih **Kinesis**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**DescribeStream**.
1. Untuk **peran Eksekusi**, masukkan ARN untuk peran eksekusi Anda.
1. Pertahankan default **Passthrough** untuk **Penanganan Konten**.
1. Pilih **metode Buat**.
1. Di bagian **Permintaan integrasi**, tambahkan **parameter header permintaan URL** berikut:
```
Content-Type: 'x-amz-json-1.1'
```
Tugas mengikuti prosedur yang sama untuk mengatur pemetaan parameter permintaan untuk `GET /streams` metode tersebut.
1. Tambahkan template pemetaan badan berikut untuk memetakan data dari permintaan `GET /streams/{stream-name}` metode ke permintaan `POST /?Action=DescribeStream` integrasi:
```
{
"StreamName": "$input.params('stream-name')"
}
```
Template pemetaan ini menghasilkan payload permintaan integrasi yang diperlukan untuk `DescribeStream` tindakan Kinesis dari nilai parameter jalur permintaan `stream-name` metode.
1. Untuk menguji `GET /stream/{stream-name}` metode untuk menjalankan `DescribeStream` tindakan di Kinesis, pilih tab Uji**.**
1. Untuk **Path**, di bawah **nama aliran**, masukkan nama aliran Kinesis yang ada.
1. Pilih **Uji**. Jika tes berhasil, respons 200 OK dikembalikan dengan muatan yang mirip dengan berikut ini:
```
{
"StreamDescription": {
"HasMoreShards": false,
"RetentionPeriodHours": 24,
"Shards": [
{
"HashKeyRange": {
"EndingHashKey": "68056473384187692692674921486353642290",
"StartingHashKey": "0"
},
"SequenceNumberRange": {
"StartingSequenceNumber": "49559266461454070523309915164834022007924120923395850242"
},
"ShardId": "shardId-000000000000"
},
...
{
"HashKeyRange": {
"EndingHashKey": "340282366920938463463374607431768211455",
"StartingHashKey": "272225893536750770770699685945414569164"
},
"SequenceNumberRange": {
"StartingSequenceNumber": "49559266461543273504104037657400164881014714369419771970"
},
"ShardId": "shardId-000000000004"
}
],
"StreamARN": "arn:aws:kinesis:us-east-1:12345678901:stream/myStream",
"StreamName": "myStream",
"StreamStatus": "ACTIVE"
}
}
```
Setelah menerapkan API, Anda dapat membuat permintaan REST terhadap metode API ini:
```
GET https://your-api-id.execute-api.region.amazonaws.com/stage/streams/myStream HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z
```
**Untuk mengkonfigurasi dan menguji metode POST pada sumber daya aliran**
1. Pilih sumber daya**/\$1stream-name\$1**, lalu pilih **Create** method.
1. Untuk **jenis Metode**, pilih **POST**.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat aliran Kinesis Anda.
1. Untuk **Layanan AWS**, pilih **Kinesis**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**CreateStream**.
1. Untuk **peran Eksekusi**, masukkan ARN untuk peran eksekusi Anda.
1. Pertahankan default **Passthrough** untuk **Penanganan Konten**.
1. Pilih **metode Buat**.
1. Di bagian **Permintaan integrasi**, tambahkan **parameter header permintaan URL** berikut:
```
Content-Type: 'x-amz-json-1.1'
```
Tugas mengikuti prosedur yang sama untuk mengatur pemetaan parameter permintaan untuk `GET /streams` metode tersebut.
1. Tambahkan template pemetaan badan berikut untuk memetakan data dari permintaan `POST /streams/{stream-name}` metode ke permintaan `POST /?Action=CreateStream` integrasi:
```
{
"ShardCount": #if($input.path('$.ShardCount') == '') 5 #else $input.path('$.ShardCount') #end,
"StreamName": "$input.params('stream-name')"
}
```
Dalam template pemetaan sebelumnya, kami menetapkan `ShardCount` ke nilai tetap 5 jika klien tidak menentukan nilai dalam payload permintaan metode.
1. Untuk menguji `POST /stream/{stream-name}` metode untuk menjalankan `CreateStream` tindakan di Kinesis, pilih tab Uji**.**
1. Untuk **Path**, di **bawah nama aliran**, masukkan nama aliran Kinesis baru.
1. Pilih **Uji**. Jika tes berhasil, respons 200 OK dikembalikan tanpa data.
Setelah menerapkan API, Anda juga dapat membuat permintaan REST API terhadap metode POST pada resource Stream untuk menjalankan `CreateStream` tindakan di Kinesis:
```
POST https://your-api-id.execute-api.region.amazonaws.com/stage/streams/yourStream HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z
{
"ShardCount": 5
}
```
**Konfigurasikan dan uji metode DELETE pada sumber daya aliran**
1. Pilih sumber daya**/\$1stream-name\$1**, lalu pilih **Create** method.
1. Untuk **jenis Metode**, pilih **DELETE**.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat aliran Kinesis Anda.
1. Untuk **Layanan AWS**, pilih **Kinesis**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**DeleteStream**.
1. Untuk **peran Eksekusi**, masukkan ARN untuk peran eksekusi Anda.
1. Pertahankan default **Passthrough** untuk **Penanganan Konten**.
1. Pilih **metode Buat**.
1. Di bagian **Permintaan integrasi**, tambahkan **parameter header permintaan URL** berikut:
```
Content-Type: 'x-amz-json-1.1'
```
Tugas mengikuti prosedur yang sama untuk mengatur pemetaan parameter permintaan untuk `GET /streams` metode tersebut.
1. Tambahkan template pemetaan badan berikut untuk memetakan data dari permintaan `DELETE /streams/{stream-name}` metode ke permintaan integrasi yang sesuai dari`POST /?Action=DeleteStream`:
```
{
"StreamName": "$input.params('stream-name')"
}
```
Template pemetaan ini menghasilkan input yang diperlukan untuk `DELETE /streams/{stream-name}` tindakan dari nama jalur URL yang disediakan klien. `stream-name`
1. Untuk menguji `DELETE /stream/{stream-name}` metode untuk menjalankan `DeleteStream` tindakan di Kinesis, pilih tab Uji**.**
1. Untuk **Path**, di bawah **nama aliran**, masukkan nama aliran Kinesis yang ada.
1. Pilih **Uji**. Jika tes berhasil, respons 200 OK dikembalikan tanpa data.
Setelah menerapkan API, Anda juga dapat membuat permintaan REST API berikut terhadap metode DELETE pada sumber daya Stream untuk memanggil `DeleteStream` tindakan di Kinesis:
```
DELETE https://your-api-id.execute-api.region.amazonaws.com/stage/streams/yourStream HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z
{}
```
## Dapatkan catatan dari dan tambahkan catatan ke aliran di Kinesis
Setelah Anda membuat aliran di Kinesis, Anda dapat menambahkan catatan data ke aliran dan membaca data dari aliran. Menambahkan catatan data melibatkan pemanggilan [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html#API_PutRecords_Examples)atau [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html#API_PutRecord_Examples)tindakan dalam Kinesis. Yang pertama menambahkan beberapa catatan sedangkan yang terakhir menambahkan satu catatan ke aliran.
```
POST /?Action=PutRecords HTTP/1.1
Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"Records": [
{
"Data": blob,
"ExplicitHashKey": "string",
"PartitionKey": "string"
}
],
"StreamName": "string"
}
```
atau
```
POST /?Action=PutRecord HTTP/1.1
Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"Data": blob,
"ExplicitHashKey": "string",
"PartitionKey": "string",
"SequenceNumberForOrdering": "string",
"StreamName": "string"
}
```
Di sini, `StreamName` mengidentifikasi aliran target untuk menambahkan catatan. `StreamName`,`Data`, dan `PartitionKey` diperlukan data input. Dalam contoh kita, kita menggunakan nilai default untuk semua data input opsional dan tidak akan secara eksplisit menentukan nilai untuk mereka dalam input ke permintaan metode.
Membaca data dalam Kinesis sama dengan memanggil tindakan: [GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html#API_GetRecords_Examples)
```
POST /?Action=GetRecords HTTP/1.1
Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"ShardIterator": "string",
"Limit": number
}
```
Di sini, aliran sumber dari mana kita mendapatkan catatan ditentukan dalam `ShardIterator` nilai yang diperlukan, seperti yang ditunjukkan dalam tindakan Kinesis berikut untuk mendapatkan iterator pecahan:
```
POST /?Action=GetShardIterator HTTP/1.1
Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes
{
"ShardId": "string",
"ShardIteratorType": "string",
"StartingSequenceNumber": "string",
"StreamName": "string"
}
```
Untuk `PutRecords` tindakan `GetRecords` dan, kami mengekspos `PUT` metode `GET` dan, masing-masing, pada `/records` sumber daya yang ditambahkan ke sumber daya aliran bernama ()`/{stream-name}`. Demikian pula, kami mengekspos `PutRecord` tindakan sebagai `PUT` metode pada `/record` sumber daya.
Karena `GetRecords` tindakan mengambil sebagai input `ShardIterator` nilai, yang diperoleh dengan memanggil aksi `GetShardIterator` helper, kami mengekspos metode `GET` helper pada `ShardIterator` resource (). `/sharditerator`
**Untuk membuat sumber daya /record, /records, dan /sharditerator**
1. Pilih sumber daya**/\$1stream-name\$1**, lalu pilih **Buat** sumber daya.
1. Matikan **sumber daya Proxy**.
1. Untuk **jalur Sumber Daya**, pilih`/{stream-name}`.
1. Untuk **Nama sumber daya**, masukkan **record**.
1. Tetap nonaktifkan **CORS (Cross Origin Resource Sharing)**.
1. Pilih **Buat sumber daya**.
1. Ulangi langkah sebelumnya untuk membuat sumber **/records** dan **/sharditerator**. API final akan terlihat seperti berikut:
![\[Buat metode Records:get|put|put|get untuk API.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/api-gateway-kinesis-proxy-setup-streams-stream-record-method-new-console.png)
Empat prosedur berikut menjelaskan cara mengatur masing-masing metode, cara memetakan data dari permintaan metode ke permintaan integrasi, dan cara menguji metode.
**Untuk mengatur dan menguji `PUT /streams/{stream-name}/record` metode yang akan dipanggil `PutRecord` di Kinesis:**
1. Pilih **/record**, lalu pilih **Create method**.
1. Untuk **jenis Metode**, pilih **PUT**.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat aliran Kinesis Anda.
1. Untuk **Layanan AWS**, pilih **Kinesis**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**PutRecord**.
1. Untuk **peran Eksekusi**, masukkan ARN untuk peran eksekusi Anda.
1. Pertahankan default **Passthrough** untuk **Penanganan Konten**.
1. Pilih **metode Buat**.
1. Di bagian **Permintaan integrasi**, tambahkan **parameter header permintaan URL** berikut:
```
Content-Type: 'x-amz-json-1.1'
```
Tugas mengikuti prosedur yang sama untuk mengatur pemetaan parameter permintaan untuk `GET /streams` metode tersebut.
1. Tambahkan template pemetaan badan berikut untuk memetakan data dari permintaan `PUT /streams/{stream-name}/record` metode ke permintaan integrasi yang sesuai dari`POST /?Action=PutRecord`:
```
{
"StreamName": "$input.params('stream-name')",
"Data": "$util.base64Encode($input.json('$.Data'))",
"PartitionKey": "$input.path('$.PartitionKey')"
}
```
Template pemetaan ini mengasumsikan bahwa payload permintaan metode adalah dari format berikut:
```
{
"Data": "some data",
"PartitionKey": "some key"
}
```
Data ini dapat dimodelkan dengan skema JSON berikut:
```
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PutRecord proxy single-record payload",
"type": "object",
"properties": {
"Data": { "type": "string" },
"PartitionKey": { "type": "string" }
}
}
```
Anda dapat membuat model untuk menyertakan skema ini dan menggunakan model untuk memfasilitasi pembuatan template pemetaan. Namun, Anda dapat membuat template pemetaan tanpa menggunakan model apa pun.
1. Untuk menguji `PUT /streams/{stream-name}/record` metode, atur variabel `stream-name` jalur ke nama aliran yang ada, berikan muatan format yang diperlukan, lalu kirimkan permintaan metode. Hasil yang berhasil adalah `200 OK ` respons dengan muatan format berikut:
```
{
"SequenceNumber": "49559409944537880850133345460169886593573102115167928386",
"ShardId": "shardId-000000000004"
}
```
**Untuk mengatur dan menguji `PUT /streams/{stream-name}/records` metode yang akan dipanggil `PutRecords` di Kinesis**
1. Pilih sumber daya **/records**, lalu pilih **Create method**.
1. Untuk **jenis Metode**, pilih **PUT**.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat aliran Kinesis Anda.
1. Untuk **Layanan AWS**, pilih **Kinesis**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**PutRecords**.
1. Untuk **peran Eksekusi**, masukkan ARN untuk peran eksekusi Anda.
1. Pertahankan default **Passthrough** untuk **Penanganan Konten**.
1. Pilih **metode Buat**.
1. Di bagian **Permintaan integrasi**, tambahkan **parameter header permintaan URL** berikut:
```
Content-Type: 'x-amz-json-1.1'
```
Tugas mengikuti prosedur yang sama untuk mengatur pemetaan parameter permintaan untuk `GET /streams` metode tersebut.
1. Tambahkan template pemetaan berikut untuk memetakan data dari permintaan `PUT /streams/{stream-name}/records` metode ke permintaan integrasi yang sesuai dari`POST /?Action=PutRecords`:
```
{
"StreamName": "$input.params('stream-name')",
"Records": [
#foreach($elem in $input.path('$.records'))
{
"Data": "$util.base64Encode($elem.data)",
"PartitionKey": "$elem.partition-key"
}#if($foreach.hasNext),#end
#end
]
}
```
Template pemetaan ini mengasumsikan bahwa payload permintaan metode dapat dimodelkan oleh skema JSON berikut:
```
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PutRecords proxy payload data",
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": { "type": "string" },
"partition-key": { "type": "string" }
}
}
}
}
}
```
Anda dapat membuat model untuk menyertakan skema ini dan menggunakan model untuk memfasilitasi pembuatan template pemetaan. Namun, Anda dapat membuat template pemetaan tanpa menggunakan model apa pun.
Dalam tutorial ini, kami menggunakan dua format payload yang sedikit berbeda untuk menggambarkan bahwa pengembang API dapat memilih untuk mengekspos format data backend ke klien atau menyembunyikannya dari klien. Satu format adalah untuk `PUT /streams/{stream-name}/records` metode (di atas). Format lain digunakan untuk `PUT /streams/{stream-name}/record` metode (dalam prosedur sebelumnya). Dalam lingkungan produksi, Anda harus menjaga kedua format tetap konsisten.
1.
Untuk menguji `PUT /streams/{stream-name}/records` metode, atur variabel `stream-name` jalur ke aliran yang ada, berikan payload berikut, dan kirimkan permintaan metode.
```
{
"records": [
{
"data": "some data",
"partition-key": "some key"
},
{
"data": "some other data",
"partition-key": "some key"
}
]
}
```
Hasil yang berhasil adalah respons 200 OK dengan muatan yang mirip dengan output berikut:
```
{
"FailedRecordCount": 0,
"Records": [
{
"SequenceNumber": "49559409944537880850133345460167468741933742152373764162",
"ShardId": "shardId-000000000004"
},
{
"SequenceNumber": "49559409944537880850133345460168677667753356781548470338",
"ShardId": "shardId-000000000004"
}
]
}
```
**Untuk mengatur dan menguji `GET /streams/{stream-name}/sharditerator` metode yang dipanggil `GetShardIterator` di Kinesis**
`GET /streams/{stream-name}/sharditerator`Metode ini adalah metode pembantu untuk memperoleh iterator shard yang diperlukan sebelum memanggil metode. `GET /streams/{stream-name}/records`
1. **Pilih sumber daya **/sharditerator**, lalu pilih Create method.**
1. Untuk **tipe Metode**, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat aliran Kinesis Anda.
1. Untuk **Layanan AWS**, pilih **Kinesis**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**GetShardIterator**.
1. Untuk **peran Eksekusi**, masukkan ARN untuk peran eksekusi Anda.
1. Pertahankan default **Passthrough** untuk **Penanganan Konten**.
1. Pilih **parameter string kueri URL**.
`GetShardIterator`Tindakan tersebut membutuhkan masukan dari suatu ShardId nilai. Untuk meneruskan `ShardId` nilai yang disediakan klien, kami menambahkan parameter `shard-id` kueri ke permintaan metode, seperti yang ditunjukkan pada langkah berikut.
1. Pilih **Tambahkan string kueri**.
1. Untuk **Nama**, masukkan **shard-id**.
1. Tetap **Diperlukan** dan **Caching** dimatikan.
1. Pilih **metode Buat**.
1. Di bagian **Permintaan integrasi**, tambahkan template pemetaan berikut untuk menghasilkan input yang diperlukan (`ShardId`dan`StreamName`) ke `GetShardIterator` tindakan dari `shard-id` dan `stream-name` parameter permintaan metode. Selain itu, template pemetaan juga ditetapkan `ShardIteratorType` `TRIM_HORIZON` sebagai default.
```
{
"ShardId": "$input.params('shard-id')",
"ShardIteratorType": "TRIM_HORIZON",
"StreamName": "$input.params('stream-name')"
}
```
1. Menggunakan opsi **Uji** di konsol API Gateway, masukkan nama aliran yang ada sebagai nilai variabel `stream-name` **Path**, atur **string `shard-id` Kueri** ke `ShardId` nilai yang ada (mis.,`shard-000000000004`), dan pilih **Uji**.
Muatan respons yang berhasil mirip dengan output berikut:
```
{
"ShardIterator": "AAAAAAAAAAFYVN3VlFy..."
}
```
Catat `ShardIterator` nilainya. Anda membutuhkannya untuk mendapatkan catatan dari aliran.
**Untuk mengkonfigurasi dan menguji `GET /streams/{stream-name}/records` metode untuk menjalankan `GetRecords` tindakan di Kinesis**
1. Pilih sumber daya **/records**, lalu pilih **Create method**.
1. Untuk **tipe Metode**, pilih **GET**.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **Wilayah AWS**, pilih Wilayah AWS tempat Anda membuat aliran Kinesis Anda.
1. Untuk **Layanan AWS**, pilih **Kinesis**.
1. Biarkan **AWS subdomain** kosong.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **tipe Tindakan**, pilih **Gunakan nama tindakan**.
1. Untuk **nama Action**, masukkan**GetRecords**.
1. Untuk **peran Eksekusi**, masukkan ARN untuk peran eksekusi Anda.
1. Pertahankan default **Passthrough** untuk **Penanganan Konten**.
1. Pilih **header permintaan HTTP**.
`GetRecords`Tindakan tersebut membutuhkan masukan dari suatu `ShardIterator` nilai. Untuk meneruskan `ShardIterator` nilai yang disediakan klien, kami menambahkan parameter `Shard-Iterator` header ke permintaan metode.
1. Pilih **Tambahkan header**.
1. Untuk **Nama**, masukkan **Shard-Iterator**.
1. Tetap **Diperlukan** dan **Caching** dimatikan.
1. Pilih **metode Buat**.
1. Di bagian **Permintaan integrasi**, tambahkan template pemetaan badan berikut untuk memetakan nilai parameter `Shard-Iterator` header ke nilai `ShardIterator` properti payload JSON untuk tindakan `GetRecords` di Kinesis.
```
{
"ShardIterator": "$input.params('Shard-Iterator')"
}
```
1. Menggunakan opsi **Uji** di konsol API Gateway, masukkan nama aliran yang ada sebagai nilai variabel `stream-name` **Path**, setel `Shard-Iterator` **Header** ke `ShardIterator` nilai yang diperoleh dari uji coba `GET /streams/{stream-name}/sharditerator` metode (di atas), dan pilih **Uji**.
Muatan respons yang berhasil mirip dengan output berikut:
```
{
"MillisBehindLatest": 0,
"NextShardIterator": "AAAAAAAAAAF...",
"Records": [ ... ]
}
```
# Definisi OpenAPI dari API sampel sebagai proxy Kinesis
Berikut ini adalah definisi OpenAPI untuk API sampel sebagai proxy Kinesis yang digunakan dalam tutorial ini.
------
#### [ OpenAPI 3.0 ]
```
{
"openapi": "3.0.0",
"info": {
"title": "KinesisProxy",
"version": "2016-03-31T18:25:32Z"
},
"paths": {
"/streams/{stream-name}/sharditerator": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
},
{
"name": "shard-id",
"in": "query",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetShardIterator",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardId\": \"$input.params('shard-id')\",\n \"ShardIteratorType\": \"TRIM_HORIZON\",\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/records": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
},
{
"name": "Shard-Iterator",
"in": "header",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardIterator\": \"$input.params('Shard-Iterator')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"put": {
"parameters": [
{
"name": "Content-Type",
"in": "header",
"schema": {
"type": "string"
}
},
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/PutRecordsMethodRequestPayload"
}
},
"application/x-amz-json-1.1": {
"schema": {
"$ref": "#/components/schemas/PutRecordsMethodRequestPayload"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"Records\": [\n {\n \"Data\": \"$util.base64Encode($elem.data)\",\n \"PartitionKey\": \"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}",
"application/x-amz-json-1.1": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"records\" : [\n {\n \"Data\" : \"$elem.data\",\n \"PartitionKey\" : \"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DescribeStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"post": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/CreateStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardCount\": 5,\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"delete": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
},
"400": {
"description": "400 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {}
},
"500": {
"description": "500 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DeleteStream",
"responses": {
"4\\d{2}": {
"statusCode": "400",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/record": {
"put": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecord",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"Data\": \"$util.base64Encode($input.json('$.Data'))\",\n \"PartitionKey\": \"$input.path('$.PartitionKey')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams": {
"get": {
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/ListStreams",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
}
},
"components": {
"schemas": {
"Empty": {
"type": "object"
},
"PutRecordsMethodRequestPayload": {
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": {
"type": "string"
},
"partition-key": {
"type": "string"
}
}
}
}
}
}
}
}
}
```
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2016-03-31T18:25:32Z",
"title": "KinesisProxy"
},
"basePath": "/test",
"schemes": [
"https"
],
"paths": {
"/streams": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/ListStreams",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DescribeStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"post": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/CreateStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardCount\": 5,\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"delete": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response",
"headers": {
"Content-Type": {
"type": "string"
}
}
},
"500": {
"description": "500 response",
"headers": {
"Content-Type": {
"type": "string"
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DeleteStream",
"responses": {
"4\\d{2}": {
"statusCode": "400",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500",
"responseParameters": {
"method.response.header.Content-Type": "integration.response.header.Content-Type"
}
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/record": {
"put": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecord",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"Data\": \"$util.base64Encode($input.json('$.Data'))\",\n \"PartitionKey\": \"$input.path('$.PartitionKey')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/records": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "Shard-Iterator",
"in": "header",
"required": false,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardIterator\": \"$input.params('Shard-Iterator')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"put": {
"consumes": [
"application/json",
"application/x-amz-json-1.1"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"in": "body",
"name": "PutRecordsMethodRequestPayload",
"required": true,
"schema": {
"$ref": "#/definitions/PutRecordsMethodRequestPayload"
}
},
{
"in": "body",
"name": "PutRecordsMethodRequestPayload",
"required": true,
"schema": {
"$ref": "#/definitions/PutRecordsMethodRequestPayload"
}
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"Records\": [\n {\n \"Data\": \"$util.base64Encode($elem.data)\",\n \"PartitionKey\": \"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}",
"application/x-amz-json-1.1": "{\n \"StreamName\": \"$input.params('stream-name')\",\n \"records\" : [\n {\n \"Data\" : \"$elem.data\",\n \"PartitionKey\" : \"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/sharditerator": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "shard-id",
"in": "query",
"required": false,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetShardIterator",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardId\": \"$input.params('shard-id')\",\n \"ShardIteratorType\": \"TRIM_HORIZON\",\n \"StreamName\": \"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
}
},
"definitions": {
"Empty": {
"type": "object"
},
"PutRecordsMethodRequestPayload": {
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": {
"type": "string"
},
"partition-key": {
"type": "string"
}
}
}
}
}
}
}
}
```
------
# Tutorial: Buat REST API menggunakan AWS SDKs atau AWS CLI
Gunakan tutorial berikut untuk membuat PetStore API yang mendukung `GET /pets` dan `GET /pets/{petId}` metode. Metode terintegrasi dengan titik akhir HTTP. Anda dapat mengikuti tutorial ini menggunakan AWS SDK for JavaScript, SDK for Python (Boto3), atau file. AWS CLI Anda menggunakan fungsi atau perintah berikut untuk menyiapkan API Anda:
------
#### [ JavaScript v3 ]
+ [ CreateRestApiCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateRestApiCommand/)
+ [ CreateResourceCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateResourceCommand/)
+ [ PutMethodCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutMethodCommand/)
+ [ PutMethodResponseCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutMethodResponseCommand/)
+ [ PutIntegrationCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutIntegrationCommand/)
+ [ PutIntegrationResponseCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutIntegrationResponseCommand/)
+ [ CreateDeploymentCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateDeploymentCommand/)
------
#### [ Python ]
+ [create\$1rest\$1api](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_rest_api.html)
+ [create\$1resource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_resource.html)
+ [put\$1metode](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_method.html)
+ [put\$1method\$1response](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_method_response.html)
+ [put\$1integrasi](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_integration.html)
+ [put\$1integration\$1response](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_integration_response.html)
+ [create\$1deployment](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_deployment.html)
------
#### [ AWS CLI ]
+ [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-rest-api.html)
+ [buat-sumber daya](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-resource.html)
+ [metode put-](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html)
+ [put-method-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method-response.html)
+ [put-integrasi](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html)
+ [put-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration-response.html)
+ [membuat-penyebaran](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-deployment.html)
------
Untuk informasi selengkapnya tentang AWS SDK untuk JavaScript v3, lihat Untuk [apa AWS SDK itu? JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/welcome.html) . Untuk informasi selengkapnya tentang SDK for Python (Boto3), lihat. [AWS SDK untuk Python (Boto3)](https://docs.aws.amazon.com/pythonsdk) Untuk informasi lebih lanjut tentang AWS CLI, lihat [Apa itu AWS CLI?](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) .
## Siapkan API yang dioptimalkan tepi PetStore
Dalam tutorial ini, contoh perintah menggunakan nilai placeholder untuk nilai IDs seperti ID API dan ID sumber daya. Saat Anda menyelesaikan tutorial, ganti nilai-nilai ini dengan milik Anda sendiri.
**Untuk menyiapkan API yang dioptimalkan tepi PetStore menggunakan AWS SDKs**
1. Gunakan contoh berikut untuk membuat `RestApi` entitas:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateRestApiCommand} from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateRestApiCommand({
name: "Simple PetStore (JavaScript v3 SDK)",
description: "Demo API created using the AWS SDK for JavaScript v3",
version: "0.00.001",
binaryMediaTypes: [
'*']
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.error(Couldn't create API:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan ID API Anda dan ID sumber daya root API Anda dalam output seperti berikut:
```
{
id: 'abc1234',
name: 'PetStore (JavaScript v3 SDK)',
description: 'Demo API created using the AWS SDK for node.js',
createdDate: 2017-09-05T19:32:35.000Z,
version: '0.00.001',
rootResourceId: 'efg567'
binaryMediaTypes: [ '*' ]
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_rest_api(
name='Simple PetStore (Python SDK)',
description='Demo API created using the AWS SDK for Python',
version='0.00.001',
binaryMediaTypes=[
'*'
]
)
except botocore.exceptions.ClientError as error:
logger.exception("Couldn't create REST API %s.", error)
raise
attribute=["id","name","description","createdDate","version","binaryMediaTypes","apiKeySource","endpointConfiguration","disableExecuteApiEndpoint","rootResourceId"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan ID API Anda dan ID sumber daya root API Anda dalam output seperti berikut:
```
{'id': 'abc1234', 'name': 'Simple PetStore (Python SDK)', 'description': 'Demo API created using the AWS SDK for Python', 'createdDate': datetime.datetime(2024, 4, 3, 14, 31, 39, tzinfo=tzlocal()), 'version': '0.00.001', 'binaryMediaTypes': ['*'], 'apiKeySource': 'HEADER', 'endpointConfiguration': {'types': ['EDGE']}, 'disableExecuteApiEndpoint': False, 'rootResourceId': 'efg567'}
```
------
#### [ AWS CLI ]
```
aws apigateway create-rest-api --name 'Simple PetStore (AWS CLI)' --region us-west-2
```
Berikut ini adalah output dari perintah ini:
```
{
"id": "abcd1234",
"name": "Simple PetStore (AWS CLI)",
"createdDate": "2022-12-15T08:07:04-08:00",
"apiKeySource": "HEADER",
"endpointConfiguration": {
"types": [
"EDGE"
]
},
"disableExecuteApiEndpoint": false,
"rootResourceId": "efg567"
}
```
------
API yang Anda buat memiliki ID API `abcd1234` dan ID sumber daya root dari`efg567`. Anda menggunakan nilai-nilai ini dalam pengaturan API Anda.
1. Selanjutnya, Anda menambahkan sumber daya anak di bawah root, Anda menentukan `RootResourceId` sebagai nilai `parentId` properti. Gunakan contoh berikut untuk membuat `/pets` sumber daya untuk API Anda:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateResourceCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateResourceCommand({
restApiId: 'abcd1234',
parentId: 'efg567',
pathPart: 'pets'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The '/pets' resource setup failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan informasi tentang sumber daya Anda dalam output seperti berikut:
```
{
"path": "/pets",
"pathPart": "pets",
"id": "aaa111",
"parentId": "efg567'"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_resource(
restApiId='abcd1234',
parentId='efg567',
pathPart='pets'
)
except botocore.exceptions.ClientError as error:
logger.exception("The '/pets' resource setup failed: %s.", error)
raise
attribute=["id","parentId", "pathPart", "path",]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan informasi tentang sumber daya Anda dalam output seperti berikut:
```
{'id': 'aaa111', 'parentId': 'efg567', 'pathPart': 'pets', 'path': '/pets'}
```
------
#### [ AWS CLI ]
```
aws apigateway create-resource --rest-api-id abcd1234 \
--region us-west-2 \
--parent-id efg567 \
--path-part pets
```
Berikut ini adalah output dari perintah ini:
```
{
"id": "aaa111",
"parentId": "efg567",
"pathPart": "pets",
"path": "/pets"
}
```
------
Sumber `/pets` daya yang Anda buat memiliki ID sumber daya`aaa111`. Anda menggunakan nilai ini dalam pengaturan API Anda.
1. Selanjutnya, Anda menambahkan sumber daya anak di bawah sumber `/pets` daya. Sumber daya ini, `/{petId}` memiliki parameter jalur `{petId}` untuk .To membuat bagian jalur sebagai parameter jalur, lampirkan dalam sepasang tanda kurung kurawal,. `{ }` Gunakan contoh berikut untuk membuat `/pets/{petId}` sumber daya untuk API Anda:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateResourceCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateResourceCommand({
restApiId: 'abcd1234',
parentId: 'aaa111',
pathPart: '{petId}'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The '/pets/{petId}' resource setup failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan informasi tentang sumber daya Anda dalam output seperti berikut:
```
{
"path": "/pets/{petId}",
"pathPart": "{petId}",
"id": "bbb222",
"parentId": "aaa111'"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_resource(
restApiId='abcd1234',
parentId='aaa111',
pathPart='{petId}'
)
except botocore.exceptions.ClientError as error:
logger.exception("The '/pets/{petId}' resource setup failed: %s.", error)
raise
attribute=["id","parentId", "pathPart", "path",]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan informasi tentang sumber daya Anda dalam output seperti berikut:
```
{'id': 'bbb222', 'parentId': 'aaa111', 'pathPart': '{petId}', 'path': '/pets/{petId}'}
```
------
#### [ AWS CLI ]
```
aws apigateway create-resource --rest-api-id abcd1234 \
--region us-west-2 \
--parent-id aaa111 \
--path-part '{petId}'
```
Berikut ini adalah output dari perintah ini:
```
{
"id": "bbb222",
"parentId": "aaa111",
"path": "/pets/{petId}",
"pathPart": "{petId}"
}
```
------
Sumber `/pets/{petId}` daya yang Anda buat memiliki ID sumber daya`bbb222`. Anda menggunakan nilai ini dalam pengaturan API Anda.
1. Dalam dua langkah berikut, Anda menambahkan metode HTTP ke sumber daya Anda. Dalam tutorial ini, Anda mengatur metode untuk memiliki akses terbuka dengan mengatur `authorization-type` to set ke`NONE`. Untuk mengizinkan hanya pengguna yang diautentikasi untuk memanggil metode, Anda dapat menggunakan peran dan kebijakan IAM, otorisasi Lambda (sebelumnya dikenal sebagai otorisasi khusus), atau kumpulan pengguna Amazon Cognito. Untuk informasi selengkapnya, lihat [Kontrol dan kelola akses ke REST APIs di API Gateway](apigateway-control-access-to-api.md).
Gunakan contoh berikut untuk menambahkan metode `GET` HTTP pada `/pets` sumber daya:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
authorizationType: 'NONE'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets' method setup failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan output berikut:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
authorizationType='NONE'
)
except botocore.exceptions.ClientError as error:
logger.exception("The 'GET /pets' method setup failed: %s", error)
raise
attribute=["httpMethod","authorizationType","apiKeyRequired"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan output berikut:
```
{'httpMethod': 'GET', 'authorizationType': 'NONE', 'apiKeyRequired': False}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method --rest-api-id abcd1234 \
--resource-id aaa111 \
--http-method GET \
--authorization-type "NONE" \
--region us-west-2
```
Berikut ini adalah output dari perintah ini:
```
{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": false
}
```
------
1. Gunakan contoh berikut untuk menambahkan metode `GET` HTTP pada `/pets/{petId}` sumber daya dan untuk mengatur `requestParameters` properti untuk meneruskan `petId` nilai yang disediakan klien ke backend:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
authorizationType: 'NONE'
requestParameters: {
"method.request.path.petId" : true
}
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets/{petId}' method setup failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan output berikut:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE",
"requestParameters": {
"method.request.path.petId": true
}
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
authorizationType='NONE',
requestParameters={
"method.request.path.petId": True
}
)
except botocore.exceptions.ClientError as error:
logger.exception("The 'GET /pets/{petId}' method setup failed: %s", error)
raise
attribute=["httpMethod","authorizationType","apiKeyRequired", "requestParameters" ]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan output berikut:
```
{'httpMethod': 'GET', 'authorizationType': 'NONE', 'apiKeyRequired': False, 'requestParameters': {'method.request.path.petId': True}}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET \
--authorization-type "NONE" \
--region us-west-2 \
--request-parameters method.request.path.petId=true
```
Berikut ini adalah output dari perintah ini:
```
{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": false,
"requestParameters": {
"method.request.path.petId": true
}
}
```
------
1. Gunakan contoh berikut untuk menambahkan respons metode 200 OK untuk `GET /pets` metode ini:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodResponseCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
statusCode: '200'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the 200 OK response for the 'GET /pets' method failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan output berikut:
```
{
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method_response(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
statusCode='200'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the 200 OK response for the 'GET /pets' method failed %s.", error)
raise
attribute=["statusCode"]
filtered_result ={key:result[key] for key in attribute}
logger.info(filtered_result)
```
Panggilan yang berhasil mengembalikan output berikut:
```
{'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method-response --rest-api-id abcd1234 \
--resource-id aaa111 --http-method GET \
--status-code 200 --region us-west-2
```
Berikut ini adalah output dari perintah ini:
```
{
"statusCode": "200"
}
```
------
1. Gunakan contoh berikut untuk menambahkan respons metode 200 OK untuk `GET /pets/{petId}` metode ini:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodResponseCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
statusCode: '200'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the 200 OK response for the 'GET /pets/{petId}' method failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan output berikut:
```
{
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method_response(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
statusCode='200'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the 200 OK response for the 'GET /pets/{petId}' method failed %s.", error)
raise
attribute=["statusCode"]
filtered_result ={key:result[key] for key in attribute}
logger.info(filtered_result)
```
Panggilan yang berhasil mengembalikan output berikut:
```
{'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method-response --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET \
--status-code 200 --region us-west-2
```
Berikut ini adalah output dari perintah ini:
```
{
"statusCode": "200"
}
```
------
1. Gunakan contoh berikut untuk mengkonfigurasi integrasi untuk `GET /pets` metode dengan titik akhir HTTP. Endpoint HTTP adalah`http://petstore-demo-endpoint.execute-api.com/petstore/pets`.
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
type: 'HTTP',
integrationHttpMethod: 'GET',
uri: 'http://petstore-demo-endpoint.execute-api.com/petstore/pets'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the integration of the 'GET /pets' method of the API failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan output berikut:
```
{
"httpMethod": "GET",
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"type": "HTTP",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"cacheNamespace": "ccc333"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
type='HTTP',
integrationHttpMethod='GET',
uri='http://petstore-demo-endpoint.execute-api.com/petstore/pets'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration of the 'GET /' method of the API failed %s.", error)
raise
attribute=["httpMethod","passthroughBehavior","cacheKeyParameters", "type", "uri", "cacheNamespace"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan output berikut:
```
{'httpMethod': 'GET', 'passthroughBehavior': 'WHEN_NO_MATCH', 'cacheKeyParameters': [], 'type': 'HTTP', 'uri': 'http://petstore-demo-endpoint.execute-api.com/petstore/pets', 'cacheNamespace': 'ccc333'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration --rest-api-id abcd1234 \
--resource-id aaa111 --http-method GET --type HTTP \
--integration-http-method GET \
--uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets' \
--region us-west-2
```
Berikut ini adalah output dari perintah ini:
```
{
"type": "HTTP",
"httpMethod": "GET",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"connectionType": "INTERNET",
"passthroughBehavior": "WHEN_NO_MATCH",
"timeoutInMillis": 29000,
"cacheNamespace": "6sxz2j",
"cacheKeyParameters": []
}
```
------
1. Gunakan contoh berikut untuk mengkonfigurasi integrasi untuk `GET /pets/{petId}` metode dengan titik akhir HTTP. Endpoint HTTP adalah`http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}`. Pada langkah ini, Anda memetakan parameter jalur `petId` ke parameter jalur titik akhir integrasi. `id`
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
type: 'HTTP',
integrationHttpMethod: 'GET',
uri: 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}'
requestParameters: {
"integration.request.path.id": "method.request.path.petId"
}
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the integration of the 'GET /pets/{petId}' method of the API failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan output berikut:
```
{
"httpMethod": "GET",
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"type": "HTTP",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"cacheNamespace": "ddd444",
"requestParameters": {
"integration.request.path.id": "method.request.path.petId"
}
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration(
restApiId='ieps9b05sf',
resourceId='t8zeb4',
httpMethod='GET',
type='HTTP',
integrationHttpMethod='GET',
uri='http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}',
requestParameters={
"integration.request.path.id": "method.request.path.petId"
}
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration of the 'GET /pets/{petId}' method of the API failed %s.", error)
raise
attribute=["httpMethod","passthroughBehavior","cacheKeyParameters", "type", "uri", "cacheNamespace", "requestParameters"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan output berikut:
```
{'httpMethod': 'GET', 'passthroughBehavior': 'WHEN_NO_MATCH', 'cacheKeyParameters': [], 'type': 'HTTP', 'uri': 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}', 'cacheNamespace': 'ddd444', 'requestParameters': {'integration.request.path.id': 'method.request.path.petId'}}}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET --type HTTP \
--integration-http-method GET \
--uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}' \
--request-parameters '{"integration.request.path.id":"method.request.path.petId"}' \
--region us-west-2
```
Berikut ini adalah output dari perintah ini:
```
{
"type": "HTTP",
"httpMethod": "GET",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"connectionType": "INTERNET",
"requestParameters": {
"integration.request.path.id": "method.request.path.petId"
},
"passthroughBehavior": "WHEN_NO_MATCH",
"timeoutInMillis": 29000,
"cacheNamespace": "rjkmth",
"cacheKeyParameters": []
}
```
------
1. Gunakan contoh berikut untuk menambahkan respons integrasi untuk `GET /pets` integrasi:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationResponseCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
statusCode: '200',
selectionPattern: ''
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets' method integration response setup failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan output berikut:
```
{
"selectionPattern": "",
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration_response(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
statusCode='200',
selectionPattern='',
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration response of the 'GET /pets' method of the API failed: %s", error)
raise
attribute=["selectionPattern","statusCode"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan output berikut:
```
{'selectionPattern': "", 'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration-response --rest-api-id abcd1234 \
--resource-id aaa111 --http-method GET \
--status-code 200 --selection-pattern "" \
--region us-west-2
```
Berikut ini adalah output dari perintah ini:
```
{
"statusCode": "200",
"selectionPattern": ""
}
```
------
1. Gunakan contoh berikut untuk menambahkan respons integrasi untuk `GET /pets/{petId}` integrasi:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationResponseCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
statusCode: '200',
selectionPattern: ''
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets/{petId}' method integration response setup failed:\n", err)
}
})();
```
Panggilan yang berhasil mengembalikan output berikut:
```
{
"selectionPattern": "",
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration_response(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
statusCode='200',
selectionPattern='',
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration response of the 'GET /pets/{petId}' method of the API failed: %s", error)
raise
attribute=["selectionPattern","statusCode"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Panggilan yang berhasil mengembalikan output berikut:
```
{'selectionPattern': "", 'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration-response --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET
--status-code 200 --selection-pattern ""
--region us-west-2
```
Berikut ini adalah output dari perintah ini:
```
{
"statusCode": "200",
"selectionPattern": ""
}
```
------
Setelah Anda membuat respons integrasi, API Anda dapat menanyakan hewan peliharaan yang tersedia di PetStore situs web dan untuk melihat hewan peliharaan individu dari pengenal tertentu. Sebelum API Anda dapat dipanggil oleh pelanggan Anda, Anda harus menerapkannya. Sebaiknya sebelum menerapkan API, Anda mengujinya.
1. Gunakan contoh berikut untuk menguji `GET /pets` metode:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new TestInvokeMethodCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
pathWithQueryString: '/',
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The test on 'GET /pets' method failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.test_invoke_method(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
pathWithQueryString='/',
)
except botocore.exceptions.ClientError as error:
logger.exception("Test invoke method on 'GET /pets' failed: %s", error)
raise
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway test-invoke-method --rest-api-id abcd1234 /
--resource-id aaa111 /
--http-method GET /
--path-with-query-string '/'
```
------
1. Gunakan contoh berikut untuk menguji `GET /pets/{petId}` metode dengan `petId` 3:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new TestInvokeMethodCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
pathWithQueryString: '/pets/3',
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The test on 'GET /pets/{petId}' method failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.test_invoke_method(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
pathWithQueryString='/pets/3',
)
except botocore.exceptions.ClientError as error:
logger.exception("Test invoke method on 'GET /pets/{petId}' failed: %s", error)
raise
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway test-invoke-method --rest-api-id abcd1234 /
--resource-id bbb222 /
--http-method GET /
--path-with-query-string '/pets/3'
```
------
Setelah berhasil menguji API, Anda dapat menerapkannya ke panggung.
1. Gunakan contoh berikut untuk menerapkan API Anda ke tahap bernama`test`. Saat Anda menerapkan API ke sebuah panggung, pemanggil API dapat memanggil API Anda.
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateDeploymentCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateDeploymentCommand({
restApiId: 'abcd1234',
stageName: 'test',
stageDescription: 'test deployment'
});
try {
const results = await apig.send(command)
console.log("Deploying API succeeded\n", results)
} catch (err) {
console.log("Deploying API failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_deployment(
restApiId='ieps9b05sf',
stageName='test',
stageDescription='my test stage',
)
except botocore.exceptions.ClientError as error:
logger.exception("Error deploying stage %s.", error)
raise
print('Deploying API succeeded')
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway create-deployment --rest-api-id abcd1234 \
--region us-west-2 \
--stage-name test \
--stage-description 'Test stage' \
--description 'First deployment'
```
Berikut ini adalah output dari perintah ini:
```
{
"id": "ab1c1d",
"description": "First deployment",
"createdDate": "2022-12-15T08:44:13-08:00"
}
```
------
API Anda sekarang dapat dipanggil oleh pelanggan. Anda dapat menguji API ini dengan memasukkan `https://abcd1234.execute-api.us-west-2.amazonaws.com/test/pets` URL di browser, dan menggantinya `abcd1234` dengan pengenal API Anda.
Untuk contoh selengkapnya tentang cara membuat atau memperbarui API menggunakan AWS SDKs atau menggunakan API AWS CLI, lihat [Tindakan untuk API Gateway menggunakan AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/api-gateway_code_examples_actions.html).
## Otomatiskan penyiapan API Anda
Alih-alih membuat API step-by-step, Anda dapat mengotomatiskan pembuatan dan pembersihan AWS sumber daya dengan menggunakan OpenAPI, CloudFormation, atau Terraform untuk membuat API Anda.
### Definisi OpenAPI 3.0
Anda dapat mengimpor definisi OpenAPI ke API Gateway. Untuk informasi selengkapnya, lihat [Kembangkan REST APIs menggunakan OpenAPI di API Gateway](api-gateway-import-api.md).
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "Simple PetStore (OpenAPI)",
"description" : "Demo API created using OpenAPI",
"version" : "2024-05-24T20:39:34Z"
},
"servers" : [ {
"url" : "{basePath}",
"variables" : {
"basePath" : {
"default" : "Prod"
}
}
} ],
"paths" : {
"/pets" : {
"get" : {
"responses" : {
"200" : {
"description" : "200 response",
"content" : { }
}
},
"x-amazon-apigateway-integration" : {
"type" : "http",
"httpMethod" : "GET",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"passthroughBehavior" : "when_no_match",
"timeoutInMillis" : 29000
}
}
},
"/pets/{petId}" : {
"get" : {
"parameters" : [ {
"name" : "petId",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"200" : {
"description" : "200 response",
"content" : { }
}
},
"x-amazon-apigateway-integration" : {
"type" : "http",
"httpMethod" : "GET",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.path.id" : "method.request.path.petId"
},
"passthroughBehavior" : "when_no_match",
"timeoutInMillis" : 29000
}
}
}
},
"components" : { }
}
```
### AWS CloudFormation Template
Untuk menerapkan CloudFormation template Anda, lihat [Membuat tumpukan di AWS CloudFormation konsol](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html).
```
AWSTemplateFormatVersion: 2010-09-09
Resources:
Api:
Type: 'AWS::ApiGateway::RestApi'
Properties:
Name: Simple PetStore (AWS CloudFormation)
PetsResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !GetAtt Api.RootResourceId
PathPart: 'pets'
PetIdResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !Ref PetsResource
PathPart: '{petId}'
PetsMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetsResource
HttpMethod: GET
AuthorizationType: NONE
Integration:
Type: HTTP
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/
IntegrationResponses:
- StatusCode: '200'
MethodResponses:
- StatusCode: '200'
PetIdMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetIdResource
HttpMethod: GET
AuthorizationType: NONE
RequestParameters:
method.request.path.petId: true
Integration:
Type: HTTP
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}
RequestParameters:
integration.request.path.id: method.request.path.petId
IntegrationResponses:
- StatusCode: '200'
MethodResponses:
- StatusCode: '200'
ApiDeployment:
Type: 'AWS::ApiGateway::Deployment'
DependsOn:
- PetsMethodGet
Properties:
RestApiId: !Ref Api
StageName: Prod
Outputs:
ApiRootUrl:
Description: Root Url of the API
Value: !Sub 'https://${Api}.execute-api.${AWS::Region}.amazonaws.com/Prod'
```
### Konfigurasi Terraform
[Untuk informasi lebih lanjut tentang Terraform, lihat Terraform.](https://developer.hashicorp.com/terraform/intro)
```
provider "aws" {
region = "us-east-1" # Update with your desired region
}
resource "aws_api_gateway_rest_api" "Api" {
name = "Simple PetStore (Terraform)"
description = "Demo API created using Terraform"
}
resource "aws_api_gateway_resource" "petsResource"{
rest_api_id = aws_api_gateway_rest_api.Api.id
parent_id = aws_api_gateway_rest_api.Api.root_resource_id
path_part = "pets"
}
resource "aws_api_gateway_resource" "petIdResource"{
rest_api_id = aws_api_gateway_rest_api.Api.id
parent_id = aws_api_gateway_resource.petsResource.id
path_part = "{petId}"
}
resource "aws_api_gateway_method" "petsMethodGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = "GET"
authorization = "NONE"
}
resource "aws_api_gateway_method_response" "petsMethodResponseGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
status_code ="200"
}
resource "aws_api_gateway_integration" "petsIntegration" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
type = "HTTP"
uri = "http://petstore-demo-endpoint.execute-api.com/petstore/pets"
integration_http_method = "GET"
depends_on = [aws_api_gateway_method.petsMethodGet]
}
resource "aws_api_gateway_integration_response" "petsIntegrationResponse" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
status_code = aws_api_gateway_method_response.petsMethodResponseGet.status_code
}
resource "aws_api_gateway_method" "petIdMethodGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = "GET"
authorization = "NONE"
request_parameters = {"method.request.path.petId" = true}
}
resource "aws_api_gateway_method_response" "petIdMethodResponseGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
status_code ="200"
}
resource "aws_api_gateway_integration" "petIdIntegration" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
type = "HTTP"
uri = "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}"
integration_http_method = "GET"
request_parameters = {"integration.request.path.id" = "method.request.path.petId"}
depends_on = [aws_api_gateway_method.petIdMethodGet]
}
resource "aws_api_gateway_integration_response" "petIdIntegrationResponse" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
status_code = aws_api_gateway_method_response.petIdMethodResponseGet.status_code
}
resource "aws_api_gateway_deployment" "Deployment" {
rest_api_id = aws_api_gateway_rest_api.Api.id
depends_on = [aws_api_gateway_integration.petsIntegration,aws_api_gateway_integration.petIdIntegration ]
}
resource "aws_api_gateway_stage" "Stage" {
stage_name = "Prod"
rest_api_id = aws_api_gateway_rest_api.Api.id
deployment_id = aws_api_gateway_deployment.Deployment.id
}
```
# Tutorial: Membuat REST API pribadi
Dalam tutorial ini, Anda membuat REST API pribadi. Klien dapat mengakses API hanya dari dalam VPC Amazon Anda. API diisolasi dari internet publik, yang merupakan persyaratan keamanan umum.
Tutorial ini memakan waktu sekitar 30 menit untuk menyelesaikannya. Pertama, Anda menggunakan CloudFormation template untuk membuat VPC Amazon, titik akhir VPC, AWS Lambda fungsi, dan meluncurkan instans Amazon EC2 yang akan Anda gunakan untuk menguji API Anda. Selanjutnya, Anda menggunakan Konsol Manajemen AWS untuk membuat API pribadi dan melampirkan kebijakan sumber daya yang memungkinkan akses hanya dari titik akhir VPC Anda. Terakhir, Anda menguji API Anda.
![\[Ikhtisar API pribadi yang Anda buat dalam tutorial ini.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/private-api-tutorial-diagram.png)
Untuk menyelesaikan tutorial ini, Anda memerlukan AWS akun dan AWS Identity and Access Management pengguna dengan akses konsol. Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan API Gateway](setting-up.md).
Dalam tutorial ini, Anda menggunakan Konsol Manajemen AWS. Untuk CloudFormation template yang membuat API ini dan semua resource terkait, lihat [template.yaml](samples/private-api-full-template.zip).
**Topics**
+ [Langkah 1: Buat dependensi](#private-api-tutorial-create-dependencies)
+ [Langkah 2: Buat API pribadi](#private-api-tutorial-create-api)
+ [Langkah 3: Buat metode dan integrasi](#private-api-tutorial-create-method)
+ [Langkah 4: Lampirkan kebijakan sumber daya](#private-api-tutorial-attach-resource-policy)
+ [Langkah 5: Menerapkan API Anda](#private-api-tutorial-deploy-api)
+ [Langkah 6: Verifikasi bahwa API Anda tidak dapat diakses publik](#private-api-tutorial-test-private-api)
+ [Langkah 7: Hubungkan ke instans di VPC Anda dan panggil API Anda](#private-api-tutorial-connect-to-instance)
+ [Langkah 8: Membersihkan](#private-api-tutorial-cleanup)
+ [Langkah selanjutnya: Otomatisasi dengan CloudFormation](#private-api-tutorial-next-steps)
## Langkah 1: Buat dependensi
Unduh dan unzip [CloudFormation template ini](samples/private-api-starter-template.zip). Anda menggunakan template untuk membuat semua dependensi untuk API pribadi Anda, termasuk VPC Amazon, titik akhir VPC, dan fungsi Lambda yang berfungsi sebagai backend API Anda. Anda membuat API pribadi nanti.
**Untuk membuat CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih **Buat tumpukan** kemudian pilih **Dengan sumber daya baru (standar)**.
1. Untuk **Tentukan templat**, pilih **Unggah file templat**.
1. Pilih template yang Anda unduh.
1. Pilih **Berikutnya**.
1. Untuk **nama Stack**, **private-api-tutorial** masukkan lalu pilih **Berikutnya**.
1. Untuk **opsi Konfigurasi tumpukan**, pilih **Berikutnya**.
1. Untuk **Kemampuan**, akui bahwa CloudFormation dapat membuat sumber daya IAM di akun Anda.
1. Pilih **Berikutnya**, lalu pilih **Kirim**.
CloudFormation menyediakan dependensi untuk API Anda, yang dapat memakan waktu beberapa menit. **Ketika status CloudFormation tumpukan Anda adalah **CREATE\$1COMPLETE**, pilih Output.** Perhatikan ID titik akhir VPC Anda. Anda membutuhkannya untuk langkah-langkah selanjutnya dalam tutorial ini.
## Langkah 2: Buat API pribadi
Anda membuat API pribadi untuk mengizinkan hanya klien dalam VPC Anda untuk mengaksesnya.
**Untuk membuat API pribadi**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **Create API**, lalu untuk **REST API**, pilih **Build**.
1. Untuk **nama API**, masukkan**private-api-tutorial**.
1. Untuk **jenis endpoint API**, pilih **Private**.
1. **Untuk **titik akhir VPC IDs, masukkan ID titik akhir** VPC dari Output tumpukan Anda.** CloudFormation
1. Untuk **jenis alamat IP**, pilih **Dualstack**.
1. Pilih **Buat API**.
## Langkah 3: Buat metode dan integrasi
Anda membuat `GET` metode dan integrasi Lambda untuk menangani `GET` permintaan ke API Anda. Saat klien memanggil API Anda, API Gateway mengirimkan permintaan ke fungsi Lambda yang Anda buat di Langkah 1, lalu mengembalikan respons ke klien.
**Untuk membuat metode dan integrasi**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **metode Buat**.
1. Untuk **jenis Metode** pilih`GET`.
1. Untuk **jenis Integrasi**, pilih fungsi **Lambda**.
1. Aktifkan **integrasi proxy Lambda**. Dengan integrasi proxy Lambda, API Gateway mengirimkan peristiwa ke Lambda dengan struktur yang ditentukan, dan mengubah respons dari fungsi Lambda Anda menjadi respons HTTP.
1. Untuk **fungsi Lambda**, pilih fungsi yang Anda buat dengan CloudFormation template di Langkah 1. Nama fungsi dimulai dengan**private-api-tutorial**.
1. Pilih **metode Buat**.
## Langkah 4: Lampirkan kebijakan sumber daya
Anda melampirkan [kebijakan sumber daya](apigateway-resource-policies.md) ke API Anda yang memungkinkan klien menjalankan API hanya melalui titik akhir VPC Anda. Untuk lebih membatasi akses ke API Anda, Anda juga dapat mengonfigurasi kebijakan titik akhir [VPC untuk titik akhir](apigateway-vpc-endpoint-policies.md) VPC Anda, tetapi itu tidak diperlukan untuk tutorial ini.
**Untuk melampirkan kebijakan sumber daya**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **Kebijakan sumber daya**, lalu pilih **Buat kebijakan**.
1. Masukkan kebijakan berikut. Ganti *vpceID* dengan ID titik akhir VPC Anda dari **Output** tumpukan Anda. CloudFormation
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": "execute-api:/*",
"Condition": {
"StringNotEquals": {
"aws:sourceVpce": "vpce-abcd1234"
}
}
},
{
"Effect": "Allow",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": "execute-api:/*"
}
]
}
```
------
1. Pilih **Simpan perubahan**.
## Langkah 5: Menerapkan API Anda
Selanjutnya, Anda menerapkan API Anda untuk membuatnya tersedia bagi klien di Amazon VPC Anda.
**Untuk menerapkan API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **Deploy API**.
1. Untuk **Stage**, pilih **New stage**.
1. Untuk **nama Panggung**, masukkan**test**.
1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi.
1. Pilih **Deploy**.
Sekarang Anda siap untuk menguji API Anda.
## Langkah 6: Verifikasi bahwa API Anda tidak dapat diakses publik
Gunakan `curl` untuk memverifikasi bahwa Anda tidak dapat menjalankan API dari luar VPC Amazon Anda.
**Untuk menguji API Anda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Di panel navigasi utama, pilih **Tahapan**, lalu pilih tahap **pengujian**.
1. Di bawah **Detail tahap**, pilih ikon salin untuk menyalin URL pemanggilan API Anda. URL terlihat seperti`https://abcdef123.execute-api.us-west-2.amazonaws.com/test`. Titik akhir VPC yang Anda buat di Langkah 1 memiliki DNS pribadi yang diaktifkan, sehingga Anda dapat menggunakan URL yang disediakan untuk menjalankan API Anda.
1. Gunakan curl untuk mencoba menjalankan API Anda dari luar VPC Anda.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/test
```
Curl menunjukkan bahwa titik akhir API Anda tidak dapat diselesaikan. Jika Anda mendapatkan respons yang berbeda, kembali ke Langkah 2, dan pastikan Anda memilih **Private** untuk jenis endpoint API Anda.
```
curl: (6) Could not resolve host: abcdef123.execute-api.us-west-2.amazonaws.com/test
```
Selanjutnya, Anda terhubung ke instans Amazon EC2 di VPC Anda untuk menjalankan API Anda.
## Langkah 7: Hubungkan ke instans di VPC Anda dan panggil API Anda
Selanjutnya, Anda menguji API Anda dari dalam VPC Amazon Anda. Untuk mengakses API pribadi, sambungkan ke instans Amazon EC2 di VPC, lalu gunakan curl untuk menjalankan API. Anda menggunakan Systems Manager Session Manager untuk menyambung ke instans Anda di browser.
**Untuk menguji API Anda**
1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Pilih **Instans**.
1. Pilih contoh bernama **private-api-tutorial**yang Anda buat dengan CloudFormation template di Langkah 1.
1. Pilih **Connect** dan kemudian pilih **Session Manager**.
1. Pilih **Connect** untuk meluncurkan sesi berbasis browser ke instans Anda.
1. Di sesi Session Manager Anda, gunakan curl untuk menjalankan API Anda. Anda dapat menjalankan API karena Anda menggunakan instance di VPC Amazon Anda.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/test
```
Verifikasi bahwa Anda mendapatkan respon`Hello from Lambda!`.
![\[Anda menggunakan Session Manager untuk memanggil API Anda dari dalam VPC Amazon Anda.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/private-api-tutorial-invoke.png)
Anda berhasil membuat API yang hanya dapat diakses dari dalam VPC Amazon Anda dan kemudian memverifikasi bahwa itu berfungsi.
## Langkah 8: Membersihkan
Untuk mencegah biaya yang tidak perlu, hapus sumber daya yang Anda buat sebagai bagian dari tutorial ini. Langkah-langkah berikut menghapus REST API dan CloudFormation tumpukan Anda.
**Untuk menghapus REST API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pada **APIs**halaman, pilih API. Pilih **tindakan API**, pilih **Hapus API**, lalu konfirmasikan pilihan Anda.
**Untuk menghapus CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih CloudFormation tumpukan Anda.
1. Pilih **Hapus** dan kemudian konfirmasikan pilihan Anda.
## Langkah selanjutnya: Otomatisasi dengan CloudFormation
Anda dapat mengotomatiskan pembuatan dan pembersihan semua AWS sumber daya yang terlibat dalam tutorial ini. Untuk contoh CloudFormation template lengkap, lihat [template.yaml](samples/private-api-full-template.zip).
# Tutorial API HTTP Amazon API Gateway
Tutorial berikut menyediakan latihan langsung untuk membantu Anda mempelajari tentang API Gateway HTTP. APIs
**Topics**
+ [Tutorial: Buat API HTTP CRUD dengan Lambda dan DynamoDB](http-api-dynamo-db.md)
+ [Tutorial: Buat API HTTP dengan integrasi pribadi ke layanan Amazon ECS](http-api-private-integration.md)
# Tutorial: Buat API HTTP CRUD dengan Lambda dan DynamoDB
Dalam tutorial ini, Anda membuat API tanpa server yang membuat, membaca, memperbarui, dan menghapus item dari tabel DynamoDB. DynamoDB adalah layanan basis data NoSQL terkelola penuh yang memberikan performa yang cepat dan dapat diprediksi dengan skalabilitas sempurna. Tutorial ini membutuhkan waktu sekitar 30 menit untuk menyelesaikannya, dan Anda dapat melakukannya dalam [Tingkat AWS Gratis](https://aws.amazon.com/free/).
Pertama, Anda membuat tabel [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) menggunakan konsol DynamoDB. Kemudian Anda membuat fungsi [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) menggunakan konsol. AWS Lambda Selanjutnya, Anda membuat API HTTP menggunakan konsol API Gateway. Terakhir, Anda menguji API Anda.
Saat Anda memanggil API HTTP, API Gateway merutekan permintaan ke fungsi Lambda Anda. Fungsi Lambda berinteraksi dengan DynamoDB, dan mengembalikan respons ke API Gateway. API Gateway kemudian mengembalikan respons kepada Anda.
![\[Ikhtisar HTTP API yang Anda buat dalam tutorial ini.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ddb-crud.png)
Untuk menyelesaikan latihan ini, Anda memerlukan AWS akun dan AWS Identity and Access Management pengguna dengan akses konsol. Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan API Gateway](setting-up.md).
Dalam tutorial ini, Anda menggunakan Konsol Manajemen AWS. Untuk AWS SAM template yang membuat API ini dan semua sumber daya terkait, lihat [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).
**Topics**
+ [Langkah 1: Buat tabel DynamoDB](#http-api-dynamo-db-create-table)
+ [Langkah 2: Buat fungsi Lambda](#http-api-dynamo-db-create-function)
+ [Langkah 3: Buat API HTTP](#http-api-dynamo-db-create-api)
+ [Langkah 4: Buat rute](#http-api-dynamo-db-create-routes)
+ [Langkah 5: Buat integrasi](#http-api-dynamo-db-create-integration)
+ [Langkah 6: Lampirkan integrasi Anda ke rute](#http-api-dynamo-db-attach-integrations)
+ [Langkah 7: Uji API Anda](#http-api-dynamo-db-invoke-api)
+ [Langkah 8: Membersihkan](#http-api-dynamo-db-cleanup)
+ [Langkah selanjutnya: Otomatiskan dengan AWS SAM atau CloudFormation](#http-api-dynamo-db-next-steps)
## Langkah 1: Buat tabel DynamoDB
Anda menggunakan tabel [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) untuk menyimpan data untuk API Anda.
Setiap item memiliki ID unik, yang kita gunakan sebagai [kunci partisi](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) untuk tabel.
**Untuk membuat tabel DynamoDB**
1. Buka konsol DynamoDB di. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Pilih **Buat tabel**.
1. Untuk **Nama tabel**, masukkan **http-crud-tutorial-items**.
1. Untuk **kunci Partisi**, masukkan**id**.
1. Pilih **Buat tabel**.
## Langkah 2: Buat fungsi Lambda
Anda membuat fungsi [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) untuk backend API Anda. Fungsi Lambda ini membuat, membaca, memperbarui, dan menghapus item dari DynamoDB. Fungsi ini menggunakan [peristiwa dari API Gateway](http-api-develop-integrations-lambda.md#http-api-develop-integrations-lambda.proxy-format) untuk menentukan cara berinteraksi dengan DynamoDB. Untuk kesederhanaan tutorial ini menggunakan fungsi Lambda tunggal. Sebagai praktik terbaik, Anda harus membuat fungsi terpisah untuk setiap rute. Untuk informasi lebih lanjut, lihat [Monolit Lambda](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith).
**Untuk membuat fungsi Lambda**
1. [Masuk ke konsol Lambda di https://console.aws.amazon.com /lambda.](https://console.aws.amazon.com/lambda)
1. Pilih **Buat fungsi**.
1. Untuk **Nama fungsi**, masukkan **http-crud-tutorial-function**.
1. Untuk **Runtime, pilih runtime** **Node.js** atau **Python** terbaru yang didukung.
1. Di bawah **Izin** pilih **Ubah peran eksekusi default**.
1. Pilih **Buat peran baru dari templat AWS kebijakan**.
1. Untuk **Nama peran**, masukkan **http-crud-tutorial-role**.
1. Untuk **templat Kebijakan**, pilih**Simple microservice permissions**. Kebijakan ini memberikan izin fungsi Lambda untuk berinteraksi dengan DynamoDB.
**catatan**
Tutorial ini menggunakan kebijakan terkelola untuk kesederhanaan. Sebagai praktik terbaik, Anda harus membuat kebijakan IAM Anda sendiri untuk memberikan izin minimum yang diperlukan.
1. Pilih **Buat fungsi**.
1. Buka fungsi Lambda di editor kode konsol, dan ganti isinya dengan kode berikut. Pilih **Deploy** untuk memperbarui fungsi Anda.
------
#### [ Node.js ]
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
DynamoDBDocumentClient,
ScanCommand,
PutCommand,
GetCommand,
DeleteCommand,
} from "@aws-sdk/lib-dynamodb";
const client = new DynamoDBClient({});
const dynamo = DynamoDBDocumentClient.from(client);
const tableName = "http-crud-tutorial-items";
export const handler = async (event, context) => {
let body;
let statusCode = 200;
const headers = {
"Content-Type": "application/json",
};
try {
switch (event.routeKey) {
case "DELETE /items/{id}":
await dynamo.send(
new DeleteCommand({
TableName: tableName,
Key: {
id: event.pathParameters.id,
},
})
);
body = `Deleted item ${event.pathParameters.id}`;
break;
case "GET /items/{id}":
body = await dynamo.send(
new GetCommand({
TableName: tableName,
Key: {
id: event.pathParameters.id,
},
})
);
body = body.Item;
break;
case "GET /items":
body = await dynamo.send(
new ScanCommand({ TableName: tableName })
);
body = body.Items;
break;
case "PUT /items":
let requestJSON = JSON.parse(event.body);
await dynamo.send(
new PutCommand({
TableName: tableName,
Item: {
id: requestJSON.id,
price: requestJSON.price,
name: requestJSON.name,
},
})
);
body = `Put item ${requestJSON.id}`;
break;
default:
throw new Error(`Unsupported route: "${event.routeKey}"`);
}
} catch (err) {
statusCode = 400;
body = err.message;
} finally {
body = JSON.stringify(body);
}
return {
statusCode,
body,
headers,
};
};
```
------
#### [ Python ]
```
import json
import boto3
from decimal import Decimal
client = boto3.client('dynamodb')
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table('http-crud-tutorial-items')
tableName = 'http-crud-tutorial-items'
def lambda_handler(event, context):
print(event)
body = {}
statusCode = 200
headers = {
"Content-Type": "application/json"
}
try:
if event['routeKey'] == "DELETE /items/{id}":
table.delete_item(
Key={'id': event['pathParameters']['id']})
body = 'Deleted item ' + event['pathParameters']['id']
elif event['routeKey'] == "GET /items/{id}":
body = table.get_item(
Key={'id': event['pathParameters']['id']})
body = body["Item"]
responseBody = [
{'price': float(body['price']), 'id': body['id'], 'name': body['name']}]
body = responseBody
elif event['routeKey'] == "GET /items":
body = table.scan()
body = body["Items"]
print("ITEMS----")
print(body)
responseBody = []
for items in body:
responseItems = [
{'price': float(items['price']), 'id': items['id'], 'name': items['name']}]
responseBody.append(responseItems)
body = responseBody
elif event['routeKey'] == "PUT /items":
requestJSON = json.loads(event['body'])
table.put_item(
Item={
'id': requestJSON['id'],
'price': Decimal(str(requestJSON['price'])),
'name': requestJSON['name']
})
body = 'Put item ' + requestJSON['id']
except KeyError:
statusCode = 400
body = 'Unsupported route: ' + event['routeKey']
body = json.dumps(body)
res = {
"statusCode": statusCode,
"headers": {
"Content-Type": "application/json"
},
"body": body
}
return res
```
------
## Langkah 3: Buat API HTTP
HTTP API menyediakan endpoint HTTP untuk fungsi Lambda Anda. Pada langkah ini, Anda membuat API kosong. Pada langkah-langkah berikut, Anda mengonfigurasi rute dan integrasi untuk menghubungkan API dan fungsi Lambda Anda.
**Untuk membuat API HTTP**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **Buat API**, lalu untuk **HTTP API**, pilih **Build**.
1. Untuk **nama API**, masukkan**http-crud-tutorial-api**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Berikutnya**.
1. Untuk **Konfigurasi rute**, pilih **Berikutnya** untuk melewati pembuatan rute. Anda membuat rute nanti.
1. Tinjau tahap yang dibuat API Gateway untuk Anda, lalu pilih **Berikutnya**.
1. Pilih **Buat**.
## Langkah 4: Buat rute
Rute adalah cara untuk mengirim permintaan API yang masuk ke sumber daya backend. Rute terdiri dari dua bagian: metode HTTP dan jalur sumber daya, misalnya,`GET /items`. Untuk contoh API ini, kita membuat empat rute:
+ `GET /items/{id}`
+ `GET /items`
+ `PUT /items`
+ `DELETE /items/{id}`
**Untuk membuat rute**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **Rute**.
1. Pilih **Buat**.
1. Untuk **Metode**, pilih**GET**.
1. Untuk jalan, masuk**/items/\$1id\$1**. `{id}`Di akhir jalur adalah parameter jalur yang diambil API Gateway dari jalur permintaan saat klien membuat permintaan.
1. Pilih **Buat**.
1. Ulangi langkah 4-7 untuk`GET /items`,`DELETE /items/{id}`, dan`PUT /items`.
![\[API Anda memiliki rute untukGET /items,GET /items/{id},DELETE /items/{id}, danPUT /items.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ddb-create-routes.png)
## Langkah 5: Buat integrasi
Anda membuat integrasi untuk menghubungkan rute ke sumber daya backend. Untuk API contoh ini, Anda membuat satu integrasi Lambda yang Anda gunakan untuk semua rute.
**Untuk membuat integrasi**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **Integrasi.**
1. Pilih **Kelola integrasi** dan kemudian pilih **Buat**.
1. Lewati **Lampirkan integrasi ini ke rute**. Anda menyelesaikannya di langkah selanjutnya.
1. Untuk **jenis Integrasi**, pilih fungsi **Lambda**.
1. Untuk **fungsi Lambda, masukkan**. **http-crud-tutorial-function**
1. Pilih **Buat**.
## Langkah 6: Lampirkan integrasi Anda ke rute
Untuk API contoh ini, Anda menggunakan integrasi Lambda yang sama untuk semua rute. Setelah Anda melampirkan integrasi ke semua rute API, fungsi Lambda Anda akan dipanggil saat klien memanggil salah satu rute Anda.
**Untuk melampirkan integrasi ke rute**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **Integrasi.**
1. Pilih rute.
1. Di bawah **Pilih integrasi yang ada**, pilih**http-crud-tutorial-function**.
1. Pilih **Lampirkan integrasi**.
1. Ulangi langkah 4-6 untuk semua rute.
Semua rute menunjukkan bahwa AWS Lambda integrasi terlampir.
![\[Konsol ditampilkan AWS Lambda di semua rute untuk menunjukkan bahwa integrasi Anda terpasang.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ddb-attach-integrations.png)
Sekarang Anda memiliki API HTTP dengan rute dan integrasi, Anda dapat menguji API Anda.
## Langkah 7: Uji API Anda
Untuk memastikan bahwa API Anda berfungsi, Anda menggunakan [curl](https://curl.se).
**Untuk mendapatkan URL untuk menjalankan API Anda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Perhatikan URL pemanggilan API Anda. Itu muncul di bawah **Memanggil URL** pada halaman **Detail**.
![\[Setelah membuat API, konsol akan menampilkan URL pemanggilan API Anda.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ddb-invoke-url.png)
1. Salin URL pemanggilan API Anda.
URL lengkapnya terlihat seperti`https://abcdef123.execute-api.us-west-2.amazonaws.com`.
**Untuk membuat atau memperbarui item**
+ Gunakan perintah berikut untuk membuat atau memperbarui item. Perintah tersebut mencakup badan permintaan dengan ID, harga, dan nama item.
```
curl -X "PUT" -H "Content-Type: application/json" -d "{\"id\": \"123\", \"price\": 12345, \"name\": \"myitem\"}" https://abcdef123.execute-api.us-west-2.amazonaws.com/items
```
**Untuk mendapatkan semua item**
+ Gunakan perintah berikut untuk daftar semua item.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items
```
**Untuk mendapatkan item**
+ Gunakan perintah berikut untuk mendapatkan item dengan ID-nya.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123
```
**Untuk menghapus item**
1. Gunakan perintah berikut untuk menghapus item.
```
curl -X "DELETE" https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123
```
1. Dapatkan semua item untuk memverifikasi bahwa item telah dihapus.
```
curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items
```
## Langkah 8: Membersihkan
Untuk mencegah biaya yang tidak perlu, hapus sumber daya yang Anda buat sebagai bagian dari latihan memulai ini. Langkah-langkah berikut menghapus API HTTP, fungsi Lambda, dan sumber daya terkait.
**Untuk menghapus tabel DynamoDB**
1. Buka konsol DynamoDB di. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)
1. Pilih meja Anda.
1. Pilih **Hapus tabel**.
1. Konfirmasikan pilihan Anda, dan pilih **Hapus**.
**Untuk menghapus API HTTP**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pada **APIs**halaman, pilih API. Pilih **Tindakan**, lalu pilih **Hapus**.
1. Pilih **Hapus**.
**Untuk menghapus fungsi Lambda**
1. [Masuk ke konsol Lambda di https://console.aws.amazon.com /lambda.](https://console.aws.amazon.com/lambda)
1. Pada halaman **Fungsi**, pilih fungsi. Pilih **Tindakan**, lalu pilih **Hapus**.
1. Pilih **Hapus**.
**Untuk menghapus grup log fungsi Lambda**
1. Di CloudWatch konsol Amazon, buka [halaman Grup log](https://console.aws.amazon.com/cloudwatch/home#logs:).
1. Pada halaman **Grup log**, pilih grup log fungsi (`/aws/lambda/http-crud-tutorial-function`). Pilih **Tindakan**, lalu pilih **Hapus grup log**.
1. Pilih **Hapus**.
**Untuk menghapus peran eksekusi fungsi Lambda**
1. Di AWS Identity and Access Management konsol, buka [halaman Peran](https://console.aws.amazon.com/iam/home?#/roles).
1. Pilih peran fungsi, misalnya,`http-crud-tutorial-role`.
1. Pilih **Hapus peran**.
1. Pilih **Ya, Hapus**.
## Langkah selanjutnya: Otomatiskan dengan AWS SAM atau CloudFormation
Anda dapat mengotomatiskan pembuatan dan pembersihan AWS sumber daya dengan menggunakan CloudFormation atau. AWS SAM Untuk contoh AWS SAM template untuk tutorial ini, lihat [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).
Misalnya CloudFormation template, lihat [contoh CloudFormation template](https://github.com/awsdocs/amazon-api-gateway-developer-guide/tree/main/cloudformation-templates).
# Tutorial: Buat API HTTP dengan integrasi pribadi ke layanan Amazon ECS
Dalam tutorial ini, Anda membuat API tanpa server yang terhubung ke layanan Amazon ECS yang berjalan di VPC Amazon. Klien di luar VPC Amazon Anda dapat menggunakan API untuk mengakses layanan Amazon ECS Anda.
Tutorial ini membutuhkan waktu sekitar satu jam untuk menyelesaikannya. Pertama, Anda menggunakan CloudFormation template untuk membuat Amazon VPC dan layanan Amazon ECS. Kemudian Anda menggunakan konsol API Gateway untuk membuat tautan VPC. Tautan VPC memungkinkan API Gateway untuk mengakses layanan Amazon ECS yang berjalan di VPC Amazon Anda. Selanjutnya, Anda membuat API HTTP yang menggunakan tautan VPC untuk terhubung ke layanan Amazon ECS Anda. Terakhir, Anda menguji API Anda.
Saat Anda menjalankan API HTTP, API Gateway merutekan permintaan ke layanan Amazon ECS Anda melalui tautan VPC Anda, lalu mengembalikan respons dari layanan.
![\[Ikhtisar HTTP API yang Anda buat dalam tutorial ini.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/private-integration.png)
Untuk menyelesaikan tutorial ini, Anda memerlukan AWS akun dan AWS Identity and Access Management pengguna dengan akses konsol. Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan API Gateway](setting-up.md).
Dalam tutorial ini, Anda menggunakan Konsol Manajemen AWS. Untuk CloudFormation template yang membuat API ini dan semua resource terkait, lihat [template.yaml](samples/private-integration-full-template.zip).
**Topics**
+ [Langkah 1: Buat layanan Amazon ECS](#http-api-private-integration-create-ecs-service)
+ [Langkah 2: Buat tautan VPC](#http-api-private-integration-vpc-link)
+ [Langkah 3: Buat API HTTP](#http-api-private-integration-create-api)
+ [Langkah 4: Buat rute](#http-api-private-integration-create-routes)
+ [Langkah 5: Buat integrasi](#http-api-private-integration-create-integration)
+ [Langkah 6: Uji API Anda](#http-api-private-integration-invoke-api)
+ [Langkah 7: Bersihkan](#http-api-private-integration-cleanup)
+ [Langkah selanjutnya: Otomatiskan dengan CloudFormation](#http-api-private-integration-next-steps)
## Langkah 1: Buat layanan Amazon ECS
Amazon ECS adalah layanan manajemen kontainer yang memudahkan untuk menjalankan, menghentikan, dan mengelola kontainer Docker di cluster. Dalam tutorial ini, Anda menjalankan cluster Anda pada infrastruktur tanpa server yang dikelola oleh Amazon ECS.
Unduh dan unzip [CloudFormation template ini](samples/private-integration-cfn.zip), yang membuat semua dependensi untuk layanan, termasuk VPC Amazon. Anda menggunakan template untuk membuat layanan Amazon ECS yang menggunakan Application Load Balancer.
**Untuk membuat CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih **Buat tumpukan** kemudian pilih **Dengan sumber daya baru (standar)**.
1. Untuk **Tentukan templat**, pilih **Unggah file templat**.
1. Pilih template yang Anda unduh.
1. Pilih **Berikutnya**.
1. Untuk **nama Stack**, masukkan **http-api-private-integrations-tutorial** dan kemudian pilih **Berikutnya**.
1. Untuk **opsi Konfigurasi tumpukan**, pilih **Berikutnya**.
1. Untuk **Kemampuan**, akui bahwa CloudFormation dapat membuat sumber daya IAM di akun Anda.
1. Pilih **Berikutnya**, lalu pilih **Kirim**.
CloudFormation menyediakan layanan ECS, yang dapat memakan waktu beberapa menit. Ketika status CloudFormation tumpukan Anda adalah **CREATE\$1COMPLETE**, Anda siap untuk melanjutkan ke langkah berikutnya.
## Langkah 2: Buat tautan VPC
Tautan VPC memungkinkan API Gateway untuk mengakses sumber daya pribadi di VPC Amazon. Anda menggunakan tautan VPC untuk memungkinkan klien mengakses layanan Amazon ECS Anda melalui HTTP API Anda.
**Untuk membuat tautan VPC**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. **Pada panel navigasi utama, pilih tautan **VPC** lalu pilih Buat.**
Anda mungkin perlu memilih ikon menu untuk membuka panel navigasi utama.
1. Untuk **Pilih versi tautan VPC, pilih tautan** **VPC** untuk HTTP. APIs
1. Untuk **Nama**, masukkan **private-integrations-tutorial**.
1. Untuk **VPC**, pilih VPC yang Anda buat di langkah 1. Nama harus dimulai dengan **PrivateIntegrationsStack**.
1. Untuk **Subnet**, pilih dua subnet pribadi di VPC Anda. Nama mereka diakhiri dengan`PrivateSubnet`.
1. Untuk **grup Keamanan**, pilih ID Grup yang dimulai dengan `private-integrations-tutorial` dan memiliki deskripsi`PrivateIntegrationsStack/PrivateIntegrationsTutorialService/Service/SecurityGroup`.
1. Pilih **Buat**.
Setelah Anda membuat tautan VPC, API Gateway menyediakan Antarmuka Jaringan Elastis untuk mengakses VPC Anda. Prosesnya bisa memakan waktu beberapa menit. Sementara itu, Anda dapat membuat API Anda.
## Langkah 3: Buat API HTTP
HTTP API menyediakan endpoint HTTP untuk layanan Amazon ECS Anda. Pada langkah ini, Anda membuat API kosong. Pada Langkah 4 dan 5, Anda mengonfigurasi rute dan integrasi untuk menghubungkan API dan layanan Amazon ECS Anda.
**Untuk membuat API HTTP**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **Buat API**, lalu untuk **HTTP API**, pilih **Build**.
1. Untuk **nama API**, masukkan**http-private-integrations-tutorial**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Pilih **Berikutnya**.
1. Untuk **Mengonfigurasi rute**, pilih **Berikutnya** untuk melewati pembuatan rute. Anda membuat rute nanti.
1. Tinjau tahap yang dibuat API Gateway untuk Anda. API Gateway membuat `$default` panggung dengan penerapan otomatis diaktifkan, yang merupakan pilihan terbaik untuk tutorial ini. Pilih **Berikutnya**.
1. Pilih **Buat**.
## Langkah 4: Buat rute
Rute adalah cara untuk mengirim permintaan API yang masuk ke sumber daya backend. Rute terdiri dari dua bagian: metode HTTP dan jalur sumber daya, misalnya,`GET /items`. Untuk contoh API ini, kita membuat satu rute.
**Untuk membuat rute**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **Rute**.
1. Pilih **Buat**.
1. Untuk **Metode**, pilih**ANY**.
1. Untuk jalan, masuk**/\$1proxy\$1\$1**. `{proxy+}`Di ujung jalan adalah variabel jalur serakah. API Gateway mengirimkan semua permintaan ke API Anda ke rute ini.
1. Pilih **Buat**.
## Langkah 5: Buat integrasi
Anda membuat integrasi untuk menghubungkan rute ke sumber daya backend.
**Untuk membuat integrasi**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **Integrasi.**
1. Pilih **Kelola integrasi** dan kemudian pilih **Buat**.
1. Untuk **Lampirkan integrasi ini ke rute**, pilih rute **ANY/\$1proxy\$1\$1** yang Anda buat sebelumnya.
1. Untuk **jenis Integrasi**, pilih **Sumber daya pribadi**.
1. Untuk **detail Integrasi**, pilih **Pilih secara manual**.
1. Untuk **layanan Target**, pilih **ALB/NLB**.
1. Untuk **Load balancer**, pilih load balancer yang Anda buat dengan CloudFormation template di Langkah 1. Namanya harus dimulai dengan **HTTP-Priva**.
1. Untuk **pendengar**, pilih**HTTP 80**.
1. Untuk tautan **VPC, pilih tautan** VPC yang Anda buat di Langkah 2. Seharusnya namanya`private-integrations-tutorial`.
1. Pilih **Buat**.
Untuk memverifikasi bahwa rute dan integrasi Anda telah diatur dengan benar, pilih **Lampirkan integrasi ke rute**. Konsol menunjukkan bahwa Anda memiliki `ANY /{proxy+}` rute dengan integrasi ke Load Balancer VPC.
![\[Konsol menunjukkan bahwa Anda memiliki /{proxy+} rute dengan integrasi ke Load Balancer di VPC.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/private-integration-tutorial-route.png)
Sekarang Anda siap untuk menguji API Anda.
## Langkah 6: Uji API Anda
Selanjutnya, Anda menguji API Anda untuk memastikan bahwa itu berfungsi. Untuk mempermudah, gunakan browser web untuk menjalankan API Anda.
**Untuk menguji API Anda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Perhatikan URL pemanggilan API Anda.
![\[Setelah membuat API, konsol akan menampilkan URL pemanggilan API Anda.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/getting-started-invoke-url.png)
1. Di browser web, buka URL pemanggilan API Anda.
URL lengkap akan terlihat seperti`https://abcdef123.execute-api.us-east-2.amazonaws.com`.
Browser Anda mengirimkan `GET` permintaan ke API.
1. Verifikasi bahwa respons API Anda adalah pesan selamat datang yang memberi tahu Anda bahwa aplikasi Anda berjalan di Amazon ECS.
Jika Anda melihat pesan selamat datang, Anda berhasil membuat layanan Amazon ECS yang berjalan di VPC Amazon, dan Anda menggunakan API API Gateway HTTP dengan tautan VPC untuk mengakses layanan Amazon ECS.
## Langkah 7: Bersihkan
Untuk mencegah biaya yang tidak perlu, hapus sumber daya yang Anda buat sebagai bagian dari tutorial ini. Langkah-langkah berikut menghapus tautan VPC, CloudFormation tumpukan, dan API HTTP Anda.
**Untuk menghapus API HTTP**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pada **APIs**halaman, pilih API. Pilih **Tindakan**, pilih **Hapus**, lalu konfirmasikan pilihan Anda.
**Untuk menghapus tautan VPC**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **tautan VPC**.
1. Pilih tautan VPC Anda, pilih **Hapus**, lalu konfirmasikan pilihan Anda.
**Untuk menghapus CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih CloudFormation tumpukan Anda.
1. Pilih **Hapus** dan kemudian konfirmasikan pilihan Anda.
## Langkah selanjutnya: Otomatiskan dengan CloudFormation
Anda dapat mengotomatiskan pembuatan dan pembersihan semua AWS sumber daya yang terlibat dalam tutorial ini. Untuk contoh CloudFormation template lengkap, lihat [template.yaml](samples/private-integration-full-template.zip).
# Tutorial API Amazon WebSocket API Gateway
Tutorial berikut menyediakan latihan langsung untuk membantu Anda mempelajari tentang API Gateway. WebSocket APIs
**Topics**
+ [Tutorial: Buat aplikasi WebSocket obrolan dengan WebSocket API, Lambda, dan DynamoDB](websocket-api-chat-app.md)
+ [Tutorial: Membuat WebSocket API dengan AWS integrasi](websocket-api-step-functions-tutorial.md)
# Tutorial: Buat aplikasi WebSocket obrolan dengan WebSocket API, Lambda, dan DynamoDB
Dalam tutorial ini, Anda akan membuat aplikasi obrolan tanpa server dengan WebSocket API. Dengan WebSocket API, Anda dapat mendukung komunikasi dua arah antar klien. Klien dapat menerima pesan tanpa harus melakukan polling untuk pembaruan.
Tutorial ini memakan waktu sekitar 30 menit untuk menyelesaikannya. Pertama, Anda akan menggunakan CloudFormation template untuk membuat fungsi Lambda yang akan menangani permintaan API, serta tabel DynamoDB yang menyimpan klien Anda. IDs Kemudian, Anda akan menggunakan konsol API Gateway untuk membuat WebSocket API yang terintegrasi dengan fungsi Lambda Anda. Terakhir, Anda akan menguji API Anda untuk memverifikasi bahwa pesan dikirim dan diterima.
![\[Ikhtisar arsitektur API yang Anda buat dalam tutorial ini.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ws-chat-app.png)
Untuk menyelesaikan tutorial ini, Anda memerlukan AWS akun dan AWS Identity and Access Management pengguna dengan akses konsol. Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan API Gateway](setting-up.md).
Anda juga `wscat` perlu terhubung ke API Anda. Untuk informasi selengkapnya, lihat [Gunakan `wscat` untuk terhubung ke WebSocket API dan mengirim pesan ke sana](apigateway-how-to-call-websocket-api-wscat.md).
**Topics**
+ [Langkah 1: Buat fungsi Lambda dan tabel DynamoDB](#websocket-api-chat-app-create-dependencies)
+ [Langkah 2: Buat WebSocket API](#websocket-api-chat-app-create-api)
+ [Langkah 3: Uji API Anda](#websocket-api-chat-app-invoke-api)
+ [Langkah 4: Membersihkan](#websocket-api-chat-app-cleanup)
+ [Langkah selanjutnya: Otomatisasi dengan CloudFormation](#websocket-api-chat-app-next-steps)
## Langkah 1: Buat fungsi Lambda dan tabel DynamoDB
Unduh dan unzip [template pembuatan aplikasi untuk CloudFormation](samples/ws-chat-app-starter.zip). Anda akan menggunakan template ini untuk membuat tabel Amazon DynamoDB untuk menyimpan klien aplikasi Anda. IDs Setiap klien yang terhubung memiliki ID unik yang akan kita gunakan sebagai kunci partisi tabel. Template ini juga menciptakan fungsi Lambda yang memperbarui koneksi klien Anda di DynamoDB dan menangani pengiriman pesan ke klien yang terhubung.
**Untuk membuat CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih **Buat tumpukan** kemudian pilih **Dengan sumber daya baru (standar)**.
1. Untuk **Tentukan templat**, pilih **Unggah file templat**.
1. Pilih template yang Anda unduh.
1. Pilih **Berikutnya**.
1. Untuk **nama Stack**, masukkan **websocket-api-chat-app-tutorial** dan kemudian pilih **Berikutnya**.
1. Untuk **opsi Konfigurasi tumpukan**, pilih **Berikutnya**.
1. Untuk **Kemampuan**, akui bahwa CloudFormation dapat membuat sumber daya IAM di akun Anda.
1. Pilih **Berikutnya**, lalu pilih **Kirim**.
CloudFormation ketentuan sumber daya yang ditentukan dalam template. Diperlukan beberapa menit untuk menyelesaikan penyediaan sumber daya Anda. Ketika status CloudFormation tumpukan Anda adalah **CREATE\$1COMPLETE**, Anda siap untuk melanjutkan ke langkah berikutnya.
## Langkah 2: Buat WebSocket API
Anda akan membuat WebSocket API untuk menangani koneksi klien dan merutekan permintaan ke fungsi Lambda yang Anda buat di Langkah 1.
**Untuk membuat WebSocket API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **Buat API**. Kemudian untuk **WebSocket API**, pilih **Build**.
1. Untuk **nama API**, masukkan**websocket-chat-app-tutorial**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Untuk **ekspresi pemilihan Rute**, masukkan**request.body.action**. Ekspresi pemilihan rute menentukan rute yang dipanggil API Gateway saat klien mengirim pesan.
1. Pilih **Berikutnya**.
1. **Untuk **rute Predefined**, pilih **Add \$1connect, Add \$1disconnect****, dan Add \$1default**.** Rute **\$1connect** dan **\$1disconnect** adalah rute khusus yang dipanggil API Gateway secara otomatis saat klien terhubung atau terputus dari API. API Gateway memanggil `$default` rute ketika tidak ada rute lain yang cocok dengan permintaan.
1. Untuk **rute Kustom**, pilih **Tambahkan rute khusus**. Untuk **kunci Rute**, masukkan**sendmessage**. Rute kustom ini menangani pesan yang dikirim ke klien yang terhubung.
1. Pilih **Berikutnya**.
1. Di bawah **Lampirkan integrasi**, untuk setiap rute dan **jenis Integrasi**, pilih Lambda.
Untuk **Lambda**, pilih fungsi Lambda yang sesuai yang Anda buat di Langkah CloudFormation 1. Setiap nama fungsi cocok dengan rute. Misalnya, untuk rute **\$1connect**, pilih fungsi bernama**websocket-chat-app-tutorial-ConnectHandler**.
1. Tinjau tahap yang dibuat API Gateway untuk Anda. Secara default, API Gateway membuat nama panggung `production` dan secara otomatis menerapkan API Anda ke tahap itu. Pilih **Berikutnya**.
1. Pilih **Buat dan terapkan**.
## Langkah 3: Uji API Anda
Selanjutnya, Anda akan menguji API Anda untuk memastikan bahwa itu berfungsi dengan benar. Gunakan `wscat` perintah untuk terhubung ke API.
**Untuk mendapatkan URL pemanggilan untuk API Anda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih API Anda.
1. Pilih **Tahapan**, lalu pilih **produksi**.
1. Perhatikan **WebSocket URL** API Anda. URL akan terlihat seperti `wss://abcdef123.execute-api.us-east-2.amazonaws.com/production`.
**Untuk terhubung ke API Anda**
1. Gunakan perintah berikut untuk terhubung ke API Anda. Saat Anda terhubung ke API, API Gateway memanggil `$connect` rute. Ketika rute ini dipanggil, ia memanggil fungsi Lambda yang menyimpan ID koneksi Anda di DynamoDB.
```
wscat -c wss://abcdef123.execute-api.us-west-2.amazonaws.com/production
```
```
Connected (press CTRL+C to quit)
```
1. Buka terminal baru dan jalankan **wscat** perintah lagi dengan parameter berikut.
```
wscat -c wss://abcdef123.execute-api.us-west-2.amazonaws.com/production
```
```
Connected (press CTRL+C to quit)
```
Ini memberi Anda dua klien terhubung yang dapat bertukar pesan.
**Untuk mengirim pesan**
+ API Gateway menentukan rute mana yang akan dipanggil berdasarkan ekspresi pemilihan rute API Anda. Ekspresi pemilihan rute API Anda adalah`$request.body.action`. Akibatnya, API Gateway memanggil `sendmessage` rute saat Anda mengirim pesan berikut:
```
{"action": "sendmessage", "message": "hello, everyone!"}
```
Fungsi Lambda yang terkait dengan rute yang dipanggil mengumpulkan klien dari DynamoDB. IDs Kemudian, fungsi tersebut memanggil API Gateway Management API dan mengirimkan pesan ke klien tersebut. Semua klien yang terhubung menerima pesan berikut:
```
< hello, everyone!
```
**Untuk memanggil rute \$1default API Anda**
+ API Gateway memanggil rute default API Anda saat klien mengirim pesan yang tidak cocok dengan rute yang Anda tentukan. Fungsi Lambda yang terkait dengan `$default` rute menggunakan API Gateway Management API untuk mengirim informasi klien tentang koneksi mereka.
```
test
```
```
Use the sendmessage route to send a message. Your info: {"ConnectedAt":"2022-01-25T18:50:04.673Z","Identity":{"SourceIp":"192.0.2.1","UserAgent":null},"LastActiveAt":"2022-01-25T18:50:07.642Z","connectionID":"Mg_ugfpqPHcCIVA="}
```
**Untuk memutuskan sambungan dari API Anda**
+ Tekan **CTRL\$1C** untuk memutuskan sambungan dari API Anda. Saat klien terputus dari API Anda, API Gateway akan memanggil rute API Anda. `$disconnect` Integrasi Lambda untuk `$disconnect` rute API Anda menghapus ID koneksi dari DynamoDB.
## Langkah 4: Membersihkan
Untuk mencegah biaya yang tidak perlu, hapus sumber daya yang Anda buat sebagai bagian dari tutorial ini. Langkah-langkah berikut menghapus CloudFormation tumpukan dan WebSocket API Anda.
**Untuk menghapus WebSocket API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pada **APIs**halaman, pilih `websocket-chat-app-tutorial` API Anda. Pilih **Tindakan**, pilih **Hapus**, lalu konfirmasikan pilihan Anda.
**Untuk menghapus CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih CloudFormation tumpukan Anda.
1. Pilih **Hapus** dan kemudian konfirmasikan pilihan Anda.
## Langkah selanjutnya: Otomatisasi dengan CloudFormation
Anda dapat mengotomatiskan pembuatan dan pembersihan semua sumber AWS daya yang terlibat dalam tutorial ini. Untuk CloudFormation template yang membuat API ini dan semua resource terkait, lihat [ws-chat-app.yaml.](samples/ws-chat-app.zip)
# Tutorial: Membuat WebSocket API dengan AWS integrasi
Dalam tutorial ini, Anda membuat aplikasi siaran tanpa server dengan WebSocket API. Klien dapat menerima pesan tanpa harus melakukan polling untuk pembaruan.
Tutorial ini menunjukkan cara menyiarkan pesan ke klien yang terhubung dan menyertakan contoh otorisasi Lambda, integrasi tiruan, dan integrasi non-proxy ke Step Functions.
![\[Ikhtisar arsitektur API yang Anda buat dalam tutorial ini.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ws-sfn-app.png)
Setelah membuat resource menggunakan CloudFormation template, Anda akan menggunakan konsol API Gateway untuk membuat WebSocket API yang terintegrasi dengan AWS resource Anda. Anda akan melampirkan otorisasi Lambda ke API Anda dan membuat integrasi AWS layanan dengan Step Functions untuk memulai eksekusi mesin status. Mesin status Step Functions akan memanggil fungsi Lambda yang mengirim pesan ke semua klien yang terhubung.
Setelah membangun API, Anda akan menguji koneksi ke API dan memverifikasi bahwa pesan dikirim dan diterima. Tutorial ini membutuhkan waktu sekitar 45 menit untuk menyelesaikannya.
**Topics**
+ [Prasyarat](#websocket-api-step-functions-prerequisites)
+ [Langkah 1: Buat sumber daya](#websocket-api-step-functions-create-dependencies)
+ [Langkah 2: Buat WebSocket API](#websocket-api-step-functions-create-api)
+ [Langkah 3: Buat Authorizer Lambda](#websocket-api-step-functions-create-authorizer)
+ [Langkah 4: Buat integrasi dua arah tiruan](#websocket-api-step-functions-create-mock-integration)
+ [Langkah 5: Buat integrasi non-proxy dengan Step Functions](#websocket-api-step-functions-create-step-function-integration)
+ [Langkah 6: Uji API Anda](#websocket-api-step-functions-test-api)
+ [Langkah 7: Bersihkan](#websocket-api-step-functions-cleanup)
+ [Langkah selanjutnya](#websocket-api-step-functions-next-steps)
## Prasyarat
Anda membutuhkan prasyarat berikut:
+ AWS Akun dan AWS Identity and Access Management pengguna dengan akses konsol. Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan API Gateway](setting-up.md).
+ `wscat`untuk terhubung ke API Anda. Untuk informasi selengkapnya, lihat [Gunakan `wscat` untuk terhubung ke WebSocket API dan mengirim pesan ke sana](apigateway-how-to-call-websocket-api-wscat.md).
Kami menyarankan Anda menyelesaikan tutorial aplikasi WebSocket obrolan sebelum memulai tutorial ini. Untuk menyelesaikan tutorial aplikasi WebSocket obrolan, lihat[Tutorial: Buat aplikasi WebSocket obrolan dengan WebSocket API, Lambda, dan DynamoDB](websocket-api-chat-app.md).
## Langkah 1: Buat sumber daya
Unduh dan unzip [template pembuatan aplikasi untuk CloudFormation](samples/ws-sfn-starter.zip). Anda akan menggunakan template ini untuk membuat yang berikut:
+ Fungsi Lambda yang menangani permintaan API dan mengotorisasi akses ke API Anda.
+ Tabel DynamoDB untuk menyimpan IDs klien dan identifikasi pengguna utama yang dikembalikan oleh otorisasi Lambda.
+ Mesin status Step Functions untuk mengirim pesan ke klien yang terhubung.
**Untuk membuat CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih **Buat tumpukan** kemudian pilih **Dengan sumber daya baru (standar)**.
1. Untuk **Tentukan templat**, pilih **Unggah file templat**.
1. Pilih template yang Anda unduh.
1. Pilih **Berikutnya**.
1. Untuk **nama Stack**, masukkan **websocket-step-functions-tutorial** dan kemudian pilih **Berikutnya**.
1. Untuk **opsi Konfigurasi tumpukan**, pilih **Berikutnya**.
1. Untuk **Kemampuan**, akui bahwa CloudFormation dapat membuat sumber daya IAM di akun Anda.
1. Pilih **Berikutnya**, lalu pilih **Kirim**.
CloudFormation ketentuan sumber daya yang ditentukan dalam template. Diperlukan beberapa menit untuk menyelesaikan penyediaan sumber daya Anda. Pilih tab **Output** untuk melihat sumber daya yang Anda buat dan mereka ARNs. Ketika status CloudFormation tumpukan Anda adalah **CREATE\$1COMPLETE**, Anda siap untuk melanjutkan ke langkah berikutnya.
## Langkah 2: Buat WebSocket API
Anda akan membuat WebSocket API untuk menangani koneksi klien dan merutekan permintaan ke sumber daya yang Anda buat di Langkah 1.
**Untuk membuat WebSocket API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **Buat API**. Kemudian untuk **WebSocket API**, pilih **Build**.
1. Untuk **nama API**, masukkan**websocket-step-functions-tutorial**.
1. Untuk **jenis alamat IP**, pilih **IPv4**.
1. Untuk **ekspresi pemilihan Rute**, masukkan**request.body.action**.
Ekspresi pemilihan rute menentukan rute yang dipanggil API Gateway saat klien mengirim pesan.
1. Pilih **Berikutnya**.
1. **Untuk **rute Predefined**, pilih **Add \$1connect, Add \$1disconnect**, **Add \$1default**.**
Rute **\$1connect** dan **\$1disconnect** adalah rute khusus yang dipanggil API Gateway secara otomatis saat klien terhubung atau terputus dari API. API Gateway memanggil rute **\$1default** ketika tidak ada rute lain yang cocok dengan permintaan. Anda akan membuat rute khusus untuk terhubung ke Step Functions setelah Anda membuat API Anda.
1. Pilih **Berikutnya**.
1. Untuk **Integrasi untuk \$1connect**, lakukan hal berikut:
1. Untuk **jenis Integrasi**, pilih **Lambda**.
1. Untuk fungsi **Lambda, pilih fungsi** Lambda **\$1connect** yang sesuai yang Anda buat CloudFormation di Langkah 1. Nama fungsi Lambda harus dimulai dengan. **websocket-step**
1. Untuk **Integrasi untuk \$1disconnect**, lakukan hal berikut:
1. Untuk **jenis Integrasi**, pilih **Lambda**.
1. Untuk fungsi **Lambda, pilih fungsi** Lambda **\$1disconnect** yang sesuai yang Anda buat di Langkah 1. CloudFormation Nama fungsi Lambda harus dimulai dengan. **websocket-step**
1. Untuk **Integrasi untuk \$1 default**, pilih **mock**.
Dalam integrasi tiruan, API Gateway mengelola respons rute tanpa backend integrasi.
1. Pilih **Berikutnya**.
1. Tinjau tahap yang dibuat API Gateway untuk Anda. Secara default, API Gateway membuat tahap bernama **production** dan secara otomatis menerapkan API Anda ke tahap itu. Pilih **Berikutnya**.
1. Pilih **Buat dan terapkan**.
## Langkah 3: Buat Authorizer Lambda
Untuk mengontrol akses ke WebSocket API Anda, Anda membuat otorisasi Lambda. CloudFormation Template membuat fungsi otorisasi Lambda untuk Anda. Anda dapat melihat fungsi Lambda di konsol Lambda. Nama harus dimulai dengan**websocket-step-functions-tutorial-AuthorizerHandler**. Fungsi Lambda ini menolak semua panggilan ke WebSocket API kecuali headernya. `Authorization` `Allow` Fungsi Lambda juga meneruskan `$context.authorizer.principalId` variabel ke API Anda, yang nantinya digunakan dalam tabel DynamoDB untuk mengidentifikasi pemanggil API.
Pada langkah ini, Anda mengonfigurasi rute **\$1connect** untuk menggunakan Lambda Authorizer.
**Untuk membuat otorisasi Lambda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Di panel navigasi utama, pilih **Authorizers**.
1. Pilih **Buat Authorizer**.
1. Untuk **nama Authorizer**, masukkan**LambdaAuthorizer**.
1. Untuk **Authorizer ARN**, masukkan nama otorisasi yang dibuat oleh template. CloudFormation Nama harus dimulai dengan**websocket-step-functions-tutorial-AuthorizerHandler**.
**catatan**
Kami menyarankan Anda untuk tidak menggunakan contoh otorisasi ini untuk produksi APIs Anda.
1. Untuk **tipe sumber Identity**, pilih **Header**. Untuk **Kunci**, masukkan **Authorization**.
1. Pilih **Buat Authorizer**.
Setelah Anda membuat authorizer Anda, Anda melampirkannya ke **\$1connect** rute API Anda.
**Untuk melampirkan otorisasi ke rute \$1connect**
1. Di panel navigasi utama, pilih **Rute**.
1. Pilih rute **\$1connect**.
1. Di bagian **Pengaturan permintaan rute**, pilih **Edit**.
1. Untuk **Otorisasi**, pilih menu tarik-turun, lalu pilih otorisasi permintaan Anda.
1. Pilih **Simpan perubahan**.
## Langkah 4: Buat integrasi dua arah tiruan
Selanjutnya, Anda membuat integrasi tiruan dua arah untuk rute **\$1default**. Integrasi tiruan memungkinkan Anda mengirim respons ke klien tanpa menggunakan backend. Saat Anda membuat integrasi untuk rute **\$1default**, Anda dapat menunjukkan kepada klien cara berinteraksi dengan API Anda.
Anda mengonfigurasi rute **\$1default** untuk menginformasikan klien agar menggunakan rute **sendmessage**.
**Untuk membuat integrasi tiruan**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih rute **\$1 default**, lalu pilih tab **Permintaan integrasi**.
1. Untuk **templat Permintaan**, pilih **Edit**.
1. Untuk **ekspresi pemilihan Template**, masukkan**200**, lalu pilih **Edit**.
1. Pada tab **Permintaan integrasi**, untuk **templat Permintaan**, pilih **Buat templat**.
1. Untuk **kunci Template**, masukkan**200**.
1. Untuk **menghasilkan template**, masukkan template pemetaan berikut:
```
{"statusCode": 200}
```
Pilih **Buat templat**.
Hasilnya akan terlihat seperti berikut ini:
![\[Konfigurasi permintaan integrasi untuk integrasi tiruan untuk rute $default.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ws-sfn-mock-integration-request.png)
1. Pada panel **rute \$1default**, pilih **Aktifkan komunikasi dua arah**.
1. Pilih tab **Integration response**, lalu pilih **Create Integration Response**.
1. Untuk **tombol Respons**, masukkan**\$1default**.
1. Untuk **ekspresi pemilihan Template**, masukkan**200**.
1. Pilih **Buat respons**.
1. Di bawah **Templat respons**, pilih **Buat templat**.
1. Untuk **kunci Template**, masukkan**200**.
1. Untuk **template Response**, masukkan template pemetaan berikut:
```
{"Use the sendmessage route to send a message. Connection ID: $context.connectionId"}
```
1. Pilih **Buat templat**.
Hasilnya akan terlihat seperti berikut ini:
![\[Konfigurasi respons integrasi untuk integrasi tiruan untuk rute $default.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ws-sfn-mock-integration-response.png)
## Langkah 5: Buat integrasi non-proxy dengan Step Functions
Selanjutnya, Anda membuat rute **sendmessage**. Klien dapat memanggil rute **sendmessage** untuk menyiarkan pesan ke semua klien yang terhubung. Rute **sendmessage** memiliki integrasi AWS layanan non-proxy dengan. AWS Step Functions Integrasi memanggil [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)perintah untuk mesin status Step Functions yang dibuat CloudFormation template untuk Anda.
**Untuk membuat integrasi non-proxy**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pilih **Buat rute**.
1. Untuk **kunci Rute**, masukkan**sendmessage**.
1. Untuk **jenis Integrasi**, pilih **AWS layanan**.
1. Untuk **AWS Wilayah**, masukkan Wilayah tempat Anda menerapkan CloudFormation template Anda.
1. Untuk **AWS layanan**, pilih **Step Functions**.
1. Untuk **metode HTTP**, pilih **POST**.
1. Untuk **nama Action**, masukkan**StartExecution**.
1. Untuk **peran Eksekusi**, masukkan peran eksekusi yang dibuat oleh CloudFormation template. Namanya seharusnya **WebsocketTutorialApiRole**.
1. Pilih **Buat rute**.
Selanjutnya, Anda membuat template pemetaan untuk mengirim parameter permintaan ke mesin status Step Functions.
**Untuk membuat template pemetaan**
1. Pilih rute **sendmessage**, lalu pilih tab **Permintaan integrasi**.
1. Di bagian **Permintaan template**, pilih **Edit**.
1. Untuk **ekspresi pemilihan Template**, masukkan**\$1\$1default**.
1. Pilih **Edit**.
1. Di bagian **Permintaan template**, pilih **Buat template**.
1. Untuk **kunci Template**, masukkan**\$1\$1default**.
1. Untuk **menghasilkan template**, masukkan template pemetaan berikut:
```
#set($domain = "$context.domainName")
#set($stage = "$context.stage")
#set($body = $input.json('$'))
#set($getMessage = $util.parseJson($body))
#set($mymessage = $getMessage.message)
{
"input": "{\"domain\": \"$domain\", \"stage\": \"$stage\", \"message\": \"$mymessage\"}",
"stateMachineArn": "arn:aws:states:us-east-2:123456789012:stateMachine:WebSocket-Tutorial-StateMachine"
}
```
Ganti *stateMachineArn* dengan ARN dari mesin negara yang dibuat oleh. CloudFormation
Template pemetaan melakukan hal berikut:
+ Menciptakan variabel `$domain` menggunakan variabel konteks`domainName`.
+ Menciptakan variabel `$stage` menggunakan variabel konteks`stage`.
`$stage`Variabel `$domain` dan diperlukan untuk membangun URL callback.
+ Mengambil pesan `sendmessage` JSON yang masuk, dan mengekstrak properti. `message`
+ Menciptakan input untuk mesin negara. Input adalah domain dan tahap WebSocket API dan pesan dari `sendmessage` rute.
1. Pilih **Buat templat**.
![\[konfigurasi rute sendmessage.\]](http://docs.aws.amazon.com/id_id/apigateway/latest/developerguide/images/ws-sfn-integration-request.png)
Anda dapat membuat integrasi non-proxy pada rute **\$1connect atau **\$1disconnect****, untuk langsung menambahkan atau menghapus ID koneksi dari tabel DynamoDB, tanpa menjalankan fungsi Lambda.
## Langkah 6: Uji API Anda
Selanjutnya, Anda akan menerapkan dan menguji API Anda untuk memastikannya berfungsi dengan benar. Anda akan menggunakan `wscat` perintah untuk terhubung ke API dan kemudian, Anda akan menggunakan perintah garis miring untuk mengirim bingkai ping untuk memeriksa koneksi ke WebSocket API.
**Untuk men-deploy API Anda**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Di panel navigasi utama, pilih **Rute**.
1. Pilih **Deploy API**.
1. Untuk **Panggung**, pilih **produksi**.
1. (Opsional) Untuk **deskripsi Deployment**, masukkan deskripsi.
1. Pilih **Deploy**.
Setelah menerapkan API, Anda dapat memanggilnya. Gunakan URL pemanggilan untuk memanggil API Anda.
**Untuk mendapatkan URL pemanggilan untuk API Anda**
1. Pilih API Anda.
1. Pilih **Tahapan**, lalu pilih **produksi**.
1. Perhatikan **WebSocket URL** API Anda. URL akan terlihat seperti `wss://abcdef123.execute-api.us-east-2.amazonaws.com/production`.
Sekarang setelah Anda memiliki URL pemanggilan, Anda dapat menguji koneksi ke WebSocket API Anda.
**Untuk menguji koneksi ke API**
1. Gunakan perintah berikut untuk terhubung ke API Anda. Pertama, Anda menguji koneksi dengan memanggil `/ping` jalur.
```
wscat -c wss://abcdef123.execute-api.us-east-2.amazonaws.com/production -H "Authorization: Allow" --slash -P
```
```
Connected (press CTRL+C to quit)
```
1. Masukkan perintah berikut untuk melakukan ping pada bingkai kontrol. Anda dapat menggunakan bingkai kontrol untuk tujuan keepalive dari sisi klien.
```
/ping
```
Hasilnya akan terlihat seperti berikut ini:
```
< Received pong (data: "")
```
Sekarang setelah Anda menguji koneksi, Anda dapat menguji apakah API Anda berfungsi dengan benar. Pada langkah ini, Anda membuka jendela terminal baru sehingga WebSocket API dapat mengirim pesan ke semua klien yang terhubung.
**Untuk menguji API Anda**
1. Buka terminal baru dan jalankan `wscat` perintah lagi dengan parameter berikut.
```
wscat -c wss://abcdef123.execute-api.us-east-2.amazonaws.com/production -H "Authorization: Allow"
```
```
Connected (press CTRL+C to quit)
```
1. API Gateway menentukan rute mana yang akan dipanggil berdasarkan ekspresi pemilihan permintaan rute API Anda. Ekspresi pemilihan rute API Anda adalah`$request.body.action`. Akibatnya, API Gateway memanggil `sendmessage` rute saat Anda mengirim pesan berikut:
```
{"action": "sendmessage", "message": "hello, from Step Functions!"}
```
Mesin status Step Functions yang terkait dengan rute memanggil fungsi Lambda dengan pesan dan URL callback. Fungsi Lambda memanggil API Gateway Management API dan mengirimkan pesan ke semua klien yang terhubung. Semua klien menerima pesan berikut:
```
< hello, from Step Functions!
```
Sekarang setelah Anda menguji WebSocket API Anda, Anda dapat memutuskan sambungan dari API Anda.
**Untuk memutuskan sambungan dari API**
+ Tekan `CTRL+C` untuk memutuskan sambungan dari API Anda.
Saat klien terputus dari API Anda, API Gateway akan memanggil rute **\$1disconnect** API Anda. Integrasi Lambda untuk rute **\$1disconnect** API Anda menghapus ID koneksi dari DynamoDB.
## Langkah 7: Bersihkan
Untuk mencegah biaya yang tidak perlu, hapus sumber daya yang Anda buat sebagai bagian dari tutorial ini. Langkah-langkah berikut menghapus CloudFormation tumpukan dan WebSocket API Anda.
**Untuk menghapus WebSocket API**
1. Masuk ke konsol API Gateway di [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Pada **APIs**halaman, pilih **websocket-api** Anda.
1. Pilih **Tindakan**, pilih **Hapus**, lalu konfirmasikan pilihan Anda.
**Untuk menghapus CloudFormation tumpukan**
1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Pilih CloudFormation tumpukan Anda.
1. Pilih **Hapus** dan kemudian konfirmasikan pilihan Anda.
## Langkah selanjutnya
Anda dapat mengotomatiskan pembuatan dan pembersihan semua sumber AWS daya yang terlibat dalam tutorial ini. Untuk contoh CloudFormation template yang mengotomatiskan tindakan ini untuk tutorial ini, lihat [ws-sfn.zip](samples/ws-sfn-complete.zip).