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

# Tutorial: Buat REST API sebagai proxy Amazon Kinesis
<a name="integrating-api-with-aws-services-kinesis"></a>

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
<a name="integrate-with-kinesis-create-iam-role-and-policy"></a>

 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
<a name="api-gateway-create-api-as-kinesis-proxy"></a>

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
<a name="api-gateway-list-kinesis-streams"></a>

 Kinesis mendukung `ListStreams` tindakan dengan panggilan REST API berikut: 

```
POST /?Action=ListStreams HTTP/1.1
Host: kinesis.<region>.<domain>
Content-Length: <PayloadSizeBytes>
User-Agent: <UserAgentString>
Content-Type: application/x-amz-json-1.1
Authorization: <AuthParams>
X-Amz-Date: <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.<region>.<domain>
Content-Length: <PayloadSizeBytes>
User-Agent: <UserAgentString>
Content-Type: application/x-amz-json-1.1
Authorization: <AuthParams>
X-Amz-Date: <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
<a name="api-gateway-create-describe-delete-stream"></a>

 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
<a name="api-gateway-get-and-add-records-to-stream"></a>

 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
<a name="api-as-kinesis-proxy-export-swagger-with-extensions"></a>

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

------