# Tutorial: Creación de una API de REST como proxy de Amazon Kinesis
Esta página describe cómo crear y configurar una API de REST con una integración del tipo `AWS` para tener acceso a Kinesis.
**nota**
Para integrar la API de API Gateway con Kinesis, debe elegir una región en la que estén disponibles los servicios API Gateway y Kinesis. Para conocer la disponibilidad de las regiones, consulte [Puntos de conexión y cuotas de servicio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html).
A modo de ejemplo, crearemos una API de ejemplo para permitir que un cliente haga lo siguiente:
1. Listado de los flujos disponibles para el usuario en Kinesis
1. Creación, descripción o eliminación de un flujo especificado
1. Leer registros de datos o escribir registros de datos en un flujo especificado
Para realizar las tareas anteriores, la API expone métodos en diferentes recursos para invocar lo siguiente, respectivamente:
1. La acción `ListStreams` en Kinesis
1. La acción `CreateStream`, `DescribeStream` o `DeleteStream`
1. La acción `GetRecords` o `PutRecords` (incluida la acción `PutRecord`) en Kinesis
En concreto, crearemos la API mediante las operaciones siguientes:
+ Exponer un método HTTP GET en el recurso `/streams` de la API e integrar el método con la acción [ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html) de Kinesis para mostrar los flujos de la cuenta del intermediario.
+ Exponer un método HTTP POST en el recurso `/streams/{stream-name}` de la API e integrar el método con la acción [CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html) de Kinesis para crear un flujo con nombre en la cuenta del intermediario.
+ Exponer un método HTTP GET en el recurso `/streams/{stream-name}` de la API e integrar el método con la acción [DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html) de Kinesis para describir un flujo con nombre en la cuenta del intermediario.
+ Exponer un método HTTP DELETE en el recurso `/streams/{stream-name}` de la API e integrar el método con la acción [DeleteStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DeleteStream.html) de Kinesis para eliminar un flujo en la cuenta del intermediario.
+ Exponer un método PUT HTTP en el recurso `/streams/{stream-name}/record` de la API e integrar el método con la acción [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html) de Kinesis. Esto permite que el cliente añada un solo registro de datos al flujo con nombre.
+ Exponer un método PUT HTTP en el recurso `/streams/{stream-name}/records` de la API e integrar el método con la acción [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html) de Kinesis. Esto permite que el cliente añada una lista de registros de datos al flujo con nombre.
+ Exponer un método GET HTTP en el recurso `/streams/{stream-name}/records` de la API e integrar el método con la acción [GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html) de Kinesis. Esto permite que el cliente muestre registros de datos en el flujo con nombre, con un iterador de fragmento especificado. Un iterador de fragmento especifica la posición del fragmento desde la que se empiezan a leer los registros de datos de forma secuencial.
+ Exponer un método GET HTTP en el recurso `/streams/{stream-name}/sharditerator` de la API e integrar el método con la acción [GetShardIterator](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html) de Kinesis. Este método auxiliar debe proporcionarse en la acción `ListStreams` de Kinesis.
Puede aplicar las instrucciones que se presentan aquí a otras acciones de Kinesis. Para obtener la lista completa de las acciones de Kinesis, consulte [Referencia de API de Amazon Kinesis](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html).
En lugar de utilizar la consola de API Gateway para crear la API de ejemplo, puede importar la API de ejemplo en API Gateway mediante la [API de importación](https://docs.aws.amazon.com/apigateway/latest/api/API_ImportRestApi.html) de API Gateway. Para obtener información acerca de cómo utilizar Import API, consulte [Desarrollo de API de REST mediante OpenAPI en API Gateway](api-gateway-import-api.md).
## Creación de un rol y una política de IAM para que la API tenga acceso a Kinesis
Para que la API pueda invocar las acciones de Kinesis necesarias, debe tener las políticas de IAM adecuadas asociadas a un rol de IAM. En este paso, deberá crear un nuevo rol de IAM.
**Para crear el rol de ejecución del proxy de servicio de AWS**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Roles**.
1. Seleccione **Crear rol**.
1. Elija **Servicio de AWS** en **Seleccionar el tipo de entidad de confianza** y, a continuación, elija **API Gateway** y seleccione **Permite que API Gateway envíe registros a CloudWatch Logs**.
1. Seleccione **Siguiente** y de nuevo **Siguiente**.
1. En **Nombre de rol**, escriba **APIGatewayKinesisProxyPolicy** y luego elija **Crear rol**.
1. En la lista **Roles**, elija el rol que acaba de crear. Puede que tenga que desplazarse o usar la barra de búsqueda para encontrar el rol.
1. Para el rol seleccionado, seleccione la pestaña **Agregar permisos**.
1. Elija **Adjuntar políticas** en la lista desplegable.
1. En la barra de búsqueda, escriba **AmazonKinesisFullAccess** y, a continuación, elija **Añadir permisos**.
**nota**
Para simplificar el proceso, este tutorial utiliza una política administrada. Como práctica recomendada, se deben crear políticas de IAM propias para otorgar los permisos mínimos requeridos.
1. Anote el **ARN del rol** recién creado, ya que lo usará más adelante.
## Creación de una API como un proxy de Kinesis
Utilice los siguientes pasos para crear la API en la consola de API Gateway.
**Para crear una API como un proxy de servicio de AWS para Kinesis**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las características del servicio. En **REST API**, elija **Build (Compilación)**. Cuando aparezca el menú emergente **Create Example API (Crear API de ejemplo)**, elija **OK (Aceptar)**.
Si esta no es la primera vez que utiliza API Gateway, elija **Create API (Crear API)**. En **REST API**, elija **Build (Compilación)**.
1. Elija **New API (Nueva API)**.
1. En **API name (Nombre de la API)**, escriba **KinesisProxy**. Mantenga los valores predeterminados en todos los demás campos.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Seleccione **Create API (Crear API)**.
Una vez creada la API, la consola de API Gateway mostrará la página **Resources (Recursos)**, que contiene únicamente el recurso raíz de la API (`/`).
## Lista de flujos en Kinesis
Kinesis es compatible con la acción `ListStreams` con la siguiente llamada a la API de REST:
```
POST /?Action=ListStreams HTTP/1.1
Host: kinesis..
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.1
Authorization:
X-Amz-Date:
{
...
}
```
En la anterior solicitud de API de REST, la acción se especifica en el parámetro de consulta `Action`. También puede, en su lugar, especificar la acción en un encabezado `X-Amz-Target`:
```
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
{
...
}
```
En este tutorial usamos el parámetro de consulta para especificar la acción.
Para exponer una acción de Kinesis en la API, agregue un recurso `/streams` a la raíz de la API. A continuación, defina un método `GET` en el recurso e integre el método en la acción `ListStreams` de Kinesis.
En el siguiente procedimiento se describe cómo listar los flujos de Kinesis con la consola de API Gateway.
**Para listar los flujos de Kinesis con la consola de API Gateway**
1. Seleccione el recurso `/` y, a continuación, elija **Crear recurso**.
1. En **Nombre del recurso**, escriba **streams**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
1. Elija el recurso `/streams` y luego **Crear método**. A continuación, haga lo siguiente:
1. En **Tipo de método**, seleccione **GET**.
**nota**
El verbo HTTP de un método invocado por un cliente puede ser diferente del verbo HTTP de una integración requerida por el backend. Aquí elegimos `GET` porque mostrar los flujos es intuitivamente una operación READ.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
**nota**
Aquí elegimos `POST` porque Kinesis requiere que la acción `ListStreams` también se invoque.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **ListStreams**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. En la pestaña **Solicitud de integración**, en **Configuración de la solicitud de integración**, seleccione **Editar**.
1. En **Acceso directo de cuerpo de la solicitud**, elija **Cuando no haya plantillas definidas (recomendado)**.
1. Elija **Parámetros de encabezados de consulta de URL** y luego haga lo siguiente:
1. Seleccione **Añadir parámetros de encabezados de solicitud**.
1. En **Nombre**, escriba **Content-Type**.
1. En **Asignado desde**, introduzca **'application/x-amz-json-1.1'**.
Hemos utilizado un mapeo de parámetros de solicitud para definir el encabezado `Content-Type` en el valor estático `'application/x-amz-json-1.1'` para informar a Kinesis de que la entrada es de una versión específica de JSON.
1. Elija **Plantillas de mapeo** y, a continuación, elija **Agregar plantilla de mapeo** y haga lo siguiente:
1. En **Content-Type**, indique **application/json**.
1. En **Cuerpo de plantilla**, escriba **\$1\$1**.
1. Seleccione **Save**.
La solicitud [ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html#API_ListStreams_RequestSyntax) toma una carga con el siguiente formato JSON:
```
{
"ExclusiveStartStreamName": "string",
"Limit": number
}
```
Sin embargo, las propiedades son opcionales. Para utilizar los valores predeterminados, usamos aquí una carga JSON vacía.
1. Pruebe el método GET en el recurso **/streams** para invocar la acción `ListStreams` en Kinesis:
Elija la pestaña **Prueba**. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
Elija **Prueba** para probar su método.
Si ya ha creado dos flujos llamados "myStream" y "yourStream" en Kinesis, la prueba realizada correctamente devolverá una respuesta 200 OK que contiene la siguiente carga:
```
{
"HasMoreStreams": false,
"StreamNames": [
"myStream",
"yourStream"
]
}
```
## Creación, descripción y eliminación de un flujo en Kinesis
Crear, describir y eliminar un flujo en Kinesis implica realizar las siguientes solicitudes a la API de REST de Kinesis, respectivamente:
```
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"
}
```
Podemos crear la API para que acepte la entrada necesaria como una carga JSON de una solicitud de método y transmita la carga a la solicitud de integración. Sin embargo, para proporcionar más ejemplos de mapeo de datos entre solicitudes de método e integración y respuestas de método e integración, crearemos nuestra API de una forma ligeramente distinta.
Exponemos los métodos HTTP `GET`, `POST` y `Delete` HTTP en un recurso `Stream` al que se asignará un nombre. Utilizamos la variable de ruta `{stream-name}` como marcador de posición del recurso de flujo e integramos estos métodos de la API con las acciones `DescribeStream`, `CreateStream` y `DeleteStream` de Kinesis respectivamente. Exigimos que el cliente pase otros datos de entrada como encabezados, parámetros de consulta o la carga de una solicitud de método. Proporcionamos plantillas de asignación para transformar los datos en la carga de solicitud de integración necesaria.
**Para crear un recurso \$1stream-name\$1**
1. Elija el recurso **/streams** y, a continuación, elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. En **Ruta de recurso**, seleccione `/streams`.
1. En **Nombre del recurso**, escriba **\$1stream-name\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
**Para configurar y probar el método GET en un recurso de flujo**
1. Elija el recurso **/\$1stream-name\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **DescribeStream**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. En la sección **Solicitud de integración**, añada los siguientes **Parámetros de encabezados de solicitudes de URL**:
```
Content-Type: 'x-amz-json-1.1'
```
La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que el método `GET /streams`.
1. Añada la siguiente plantilla de mapeo de cuerpo para mapear los datos de la solicitud del método `GET /streams/{stream-name}` a la solicitud de integración `POST /?Action=DescribeStream`:
```
{
"StreamName": "$input.params('stream-name')"
}
```
Esta plantilla de mapeo genera la carga de la solicitud de integración necesaria para la acción `DescribeStream` de Kinesis a partir del valor del parámetro de ruta `stream-name` de la solicitud de método.
1. Para probar el método `GET /stream/{stream-name}` para invocar la acción `DescribeStream` en Kinesis, seleccione la pestaña **Prueba**.
1. En **Ruta**, en **stream-name**, introduzca el nombre de un flujo de Kinesis existente.
1. Seleccione **Probar**. Si la prueba tiene éxito, se devuelve la respuesta 200 OK con una carga similar a la siguiente:
```
{
"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"
}
}
```
Después de implementar la API, puede realizar una solicitud REST a este método de la API:
```
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
```
**Para configurar y probar el método POST en un recurso de flujo**
1. Elija el recurso **/\$1stream-name\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **POST**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **CreateStream**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. En la sección **Solicitud de integración**, añada los siguientes **Parámetros de encabezados de solicitudes de URL**:
```
Content-Type: 'x-amz-json-1.1'
```
La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que el método `GET /streams`.
1. Añada la siguiente plantilla de mapeo de cuerpo para mapear los datos de la solicitud del método `POST /streams/{stream-name}` a la solicitud de integración `POST /?Action=CreateStream`:
```
{
"ShardCount": #if($input.path('$.ShardCount') == '') 5 #else $input.path('$.ShardCount') #end,
"StreamName": "$input.params('stream-name')"
}
```
En la plantilla de mapeo anterior, definimos `ShardCount` en un valor fijo de 5 si el cliente no especifica un valor en la carga de la solicitud de método.
1. Para probar el método `POST /stream/{stream-name}` para invocar la acción `CreateStream` en Kinesis, seleccione la pestaña **Prueba**.
1. En **Ruta**, en **stream-name**, introduzca el nombre de un flujo de Kinesis nuevo.
1. Seleccione **Probar**. Si la prueba tiene éxito, se devuelve una respuesta 200 OK sin datos.
Después de implementar la API, también puede realizar una solicitud de API de REST al método POST en un recurso Stream para invocar la acción `CreateStream` en 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
}
```
**Configurar y probar el método DELETE en un recurso de flujo**
1. Elija el recurso **/\$1stream-name\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **DELETE**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **DeleteStream**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. En la sección **Solicitud de integración**, añada los siguientes **Parámetros de encabezados de solicitudes de URL**:
```
Content-Type: 'x-amz-json-1.1'
```
La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que el método `GET /streams`.
1. Añada la siguiente plantilla de mapeo de cuerpo para mapear los datos de la solicitud de método `DELETE /streams/{stream-name}` a la solicitud de integración de `POST /?Action=DeleteStream` correspondiente:
```
{
"StreamName": "$input.params('stream-name')"
}
```
Esta plantilla de mapeo genera la entrada necesaria de la `DELETE /streams/{stream-name}` acción desde el nombre de ruta URL proporcionada por el cliente: `stream-name`.
1. Para probar el método `DELETE /stream/{stream-name}` para invocar la acción `DeleteStream` en Kinesis, seleccione la pestaña **Prueba**.
1. En **Ruta**, en **stream-name**, introduzca el nombre de un flujo de Kinesis existente.
1. Seleccione **Probar**. Si la prueba tiene éxito, se devuelve una respuesta 200 OK sin datos.
Después de implementar la API, también puede realizar la siguiente solicitud API de REST al método DELETE en el recurso Stream para llamar a la acción `DeleteStream` en 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
{}
```
## Obtención de registros y adición de registros a un flujo de Kinesis
Después de crear un flujo en Kinesis, puede agregar registros de datos al flujo y leer los datos del flujo. Agregar registros de datos implica llamar a la acción [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html#API_PutRecords_Examples) o [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html#API_PutRecord_Examples) de Kinesis. La primera acción añade varios registros, mientras que la última añade un solo registro al flujo.
```
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"
}
```
o
```
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"
}
```
Aquí, `StreamName` identifica el flujo de destino para añadir registros. `StreamName`, `Data` y `PartitionKey` son datos de entrada necesarios. En nuestro ejemplo, usamos los valores predeterminados para todos los datos de entrada opcionales y no especificaremos de forma explícita los valores para ellos en la entrada de la solicitud del método.
Leer datos en Kinesis equivale a llamar a la acción [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
}
```
Aquí, el flujo de origen del que se obtienen los registros se especifica en el valor de `ShardIterator` necesario, tal y como se muestra en la siguiente acción de Kinesis para obtener un iterador de fragmento:
```
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"
}
```
Para las acciones `GetRecords` y `PutRecords`, exponemos los métodos `GET` y `PUT`, respectivamente, en un recurso `/records` que se añade a un recurso de flujo con nombre (`/{stream-name}`). Del mismo modo, exponemos la acción `PutRecord` como un método `PUT` en un recurso `/record`.
Como la acción `GetRecords` toma como entrada un valor de `ShardIterator`, que se obtiene llamando a la acción auxiliar `GetShardIterator`, exponemos un método auxiliar `GET` en un recurso `ShardIterator` (`/sharditerator`).
**Para crear los recursos /record, /records y /sharditerator**
1. Elija el recurso **/\$1stream-name\$1** y, a continuación, elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. En **Ruta de recurso**, seleccione `/{stream-name}`.
1. En **Nombre del recurso**, escriba **record**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
1. Repita los pasos anteriores para crear un recurso **/records** y un recurso **/sharditerator**. La API final debe ser similar a la siguiente:
![\[Creación del método Records:GET|PUT|PUT|GET para la API.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-kinesis-proxy-setup-streams-stream-record-method-new-console.png)
Los siguientes cuatro procedimientos describen cómo configurar cada uno de los métodos, cómo asignar datos desde las solicitudes de método a las solicitudes de integración y cómo probar los métodos.
**Para configurar y probar el método `PUT /streams/{stream-name}/record` para invocar a `PutRecord` en Kinesis**
1. Elija **/record** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **PUT**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **PutRecord**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. En la sección **Solicitud de integración**, añada los siguientes **Parámetros de encabezados de solicitudes de URL**:
```
Content-Type: 'x-amz-json-1.1'
```
La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que el método `GET /streams`.
1. Añada la siguiente plantilla de mapeo de cuerpo para mapear los datos de la solicitud de método `PUT /streams/{stream-name}/record` a la solicitud de integración de `POST /?Action=PutRecord` correspondiente:
```
{
"StreamName": "$input.params('stream-name')",
"Data": "$util.base64Encode($input.json('$.Data'))",
"PartitionKey": "$input.path('$.PartitionKey')"
}
```
En esta plantilla de asignación se asume que la carga del método de solicitud tiene el siguiente formato:
```
{
"Data": "some data",
"PartitionKey": "some key"
}
```
Estos datos se pueden modelar mediante el siguiente esquema JSON:
```
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PutRecord proxy single-record payload",
"type": "object",
"properties": {
"Data": { "type": "string" },
"PartitionKey": { "type": "string" }
}
}
```
Puede crear un modelo para incluir este esquema y utilizar el modelo para facilitar la generación de la plantilla de asignación. Sin embargo, puede generar una plantilla de asignación sin usar ningún modelo.
1. Para probar el método `PUT /streams/{stream-name}/record`, establezca la variable de ruta `stream-name` en el nombre de un flujo existente, introduzca la carga del formato necesario y, a continuación, envíe la solicitud de método. El resultado correcto es una respuesta `200 OK `con una carga con el formato siguiente:
```
{
"SequenceNumber": "49559409944537880850133345460169886593573102115167928386",
"ShardId": "shardId-000000000004"
}
```
**Para configurar y probar el método `PUT /streams/{stream-name}/records` para invocar a `PutRecords` en Kinesis**
1. Elija el recurso **/records** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **PUT**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **PutRecords**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. En la sección **Solicitud de integración**, añada los siguientes **Parámetros de encabezados de solicitudes de URL**:
```
Content-Type: 'x-amz-json-1.1'
```
La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que el método `GET /streams`.
1. Añada la siguiente plantilla de mapeo para mapear los datos de la solicitud del método `PUT /streams/{stream-name}/records` a la solicitud de integración de `POST /?Action=PutRecords` correspondiente:
```
{
"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
]
}
```
Esta plantilla de mapeo asume que el siguiente esquema JSON puede modelar la carga de la solicitud de método:
```
{
"$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" }
}
}
}
}
}
```
Puede crear un modelo para incluir este esquema y utilizar el modelo para facilitar la generación de la plantilla de asignación. Sin embargo, puede generar una plantilla de asignación sin usar ningún modelo.
En este tutorial, hemos usado dos formatos de carga ligeramente diferentes para ilustrar que un desarrollador de API puede optar por exponer el formato de datos de backend al cliente u ocultárselo. Un formato es para el método `PUT /streams/{stream-name}/records` (anterior). Otro formato se utiliza en el método `PUT /streams/{stream-name}/record` (en el procedimiento anterior). En un entorno de producción, debe mantener la coherencia de ambos formatos.
1.
Para probar el método `PUT /streams/{stream-name}/records`, establezca la variable de ruta `stream-name` en un flujo existente, introduzca la siguiente carga y envíe la solicitud del método.
```
{
"records": [
{
"data": "some data",
"partition-key": "some key"
},
{
"data": "some other data",
"partition-key": "some key"
}
]
}
```
El resultado correcto es una respuesta 200 OK con una carga similar a la siguiente:
```
{
"FailedRecordCount": 0,
"Records": [
{
"SequenceNumber": "49559409944537880850133345460167468741933742152373764162",
"ShardId": "shardId-000000000004"
},
{
"SequenceNumber": "49559409944537880850133345460168677667753356781548470338",
"ShardId": "shardId-000000000004"
}
]
}
```
**Para configurar y probar el método `GET /streams/{stream-name}/sharditerator` para invocar a `GetShardIterator` en Kinesis**
`GET /streams/{stream-name}/sharditerator` es un método auxiliar para adquirir un iterador de fragmento necesario antes de llamar al método `GET /streams/{stream-name}/records`.
1. Elija el recurso **/sharditerator** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **GetShardIterator**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Parámetros de cadenas de consulta de URL**.
La acción `GetShardIterator` requiere una entrada de un valor de ShardId. Para pasar un valor de `ShardId` proporcionado por el cliente, añadimos un parámetro de consulta `shard-id` a la solicitud del método, tal y como se muestra en el siguiente paso.
1. Elija **Añadir cadena de consulta**.
1. En **Nombre**, escriba **shard-id**.
1. Mantenga desactivados **Obligatorio** y **Almacenamiento en caché**.
1. Elija **Crear método**.
1. En la sección **Solicitud de integración**, añada la siguiente plantilla de mapeo para generar la entrada requerida (`ShardId` y `StreamName`) a la acción `GetShardIterator` a partir de los parámetros `shard-id` y `stream-name` de la solicitud de método. Además, la plantilla de mapeo también establece `ShardIteratorType` en `TRIM_HORIZON` como valor predeterminada.
```
{
"ShardId": "$input.params('shard-id')",
"ShardIteratorType": "TRIM_HORIZON",
"StreamName": "$input.params('stream-name')"
}
```
1. Con la opción **Test (Prueba)** de la consola de API Gateway, escriba un nombre de flujo existente como el valor de la variable `stream-name` de **Path (Ruta)**, establezca `shard-id` para **Query string (Cadena de consulta)** en un valor `ShardId` existente (por ejemplo, `shard-000000000004`) y elija **Test (Prueba)**.
La carga de la respuesta correcta es similar al siguiente resultado:
```
{
"ShardIterator": "AAAAAAAAAAFYVN3VlFy..."
}
```
Anote el valor de `ShardIterator`. Lo necesita para obtener los registros de un flujo.
**Para configurar y probar el método `GET /streams/{stream-name}/records` para invocar la acción `GetRecords` en Kinesis**
1. Elija el recurso **/records** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **GetRecords**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Encabezados de solicitud HTTP**.
La acción `GetRecords` requiere una entrada de un valor de `ShardIterator`. Para pasar un valor de `ShardIterator` proporcionado por el cliente, agregamos un parámetro de encabezado `Shard-Iterator` a la solicitud del método.
1. Elija **Agregar encabezado**.
1. En **Nombre**, escriba **Shard-Iterator**.
1. Mantenga desactivados **Obligatorio** y **Almacenamiento en caché**.
1. Elija **Crear método**.
1. En la sección **Solicitud de integración**, añada la siguiente plantilla de mapeo de cuerpo para mapear el valor del parámetro de encabezado `Shard-Iterator` al valor de la propiedad `ShardIterator` de la carga JSON para la acción `GetRecords` en Kinesis.
```
{
"ShardIterator": "$input.params('Shard-Iterator')"
}
```
1. Con la opción **Prueba** de la consola de API Gateway, escriba un nombre de flujo existente como el valor de la variable `stream-name` de **Ruta**, establezca el `Shard-Iterator` de **Encabezado** en el valor de `ShardIterator` obtenido de la serie de pruebas del método `GET /streams/{stream-name}/sharditerator` (arriba) y elija **Prueba**.
La carga de la respuesta correcta es similar al siguiente resultado:
```
{
"MillisBehindLatest": 0,
"NextShardIterator": "AAAAAAAAAAF...",
"Records": [ ... ]
}
```
# Definiciones de OpenAPI de la API de ejemplo como un proxy de Kinesis
A continuación se muestran las definiciones de OpenAPI de la API de ejemplo, utilizada en este tutorial, como un proxy de Kinesis.
------
#### [ 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"
}
}
}
}
}
}
}
}
```
------