Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Didacticiel : création d’une API REST en tant que proxy Amazon Kinesis
Cette page explique comment créer et configurer une API REST avec une intégration du type `AWS` pour accéder à Kinesis.
**Note**
Pour intégrer votre API API Gateway avec Kinesis, vous devez choisir une région où les services API Gateway et Kinesis sont disponibles. Pour connaître la disponibilité dans les régions, consultez [Points de terminaison de service et quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html).
À titre d’illustration, nous allons créer un exemple d’API pour permettre à un client d’effectuer les tâches suivantes :
1. Affichage de la liste des flux disponibles de l’utilisateur dans Kinesis
1. Création, description ou suppression d’un flux spécifique
1. Lecture ou écriture des enregistrements de données du flux spécifié
Pour effectuer les tâches précédentes, l’API expose les méthodes sur diverses ressources pour appeler les actions suivantes, respectivement :
1. L’action `ListStreams` dans Kinesis
1. L’action `CreateStream`, `DescribeStream` ou `DeleteStream`
1. L’action `GetRecords` ou `PutRecords` (y compris `PutRecord`) dans Kinesis
Plus précisément, nous allons concevoir l’API comme suit :
+ Exposez une méthode HTTP GET sur la `/streams` ressource de l'API et intégrez-la à l'[ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html)action dans Kinesis pour répertorier les flux du compte de l'appelant.
+ Exposez une méthode HTTP POST sur la `/streams/{stream-name}` ressource de l'API et intégrez-la à l'[CreateStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html)action dans Kinesis pour créer un flux nommé dans le compte de l'appelant.
+ Exposez une méthode HTTP GET sur la `/streams/{stream-name}` ressource de l'API et intégrez-la à l'[DescribeStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html)action dans Kinesis pour décrire un flux nommé dans le compte de l'appelant.
+ Exposez une méthode HTTP DELETE sur la `/streams/{stream-name}` ressource de l'API et intégrez-la à l'[DeleteStream](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DeleteStream.html)action dans Kinesis pour supprimer un flux dans le compte de l'appelant.
+ Exposez une méthode HTTP PUT sur la `/streams/{stream-name}/record` ressource de l'API et intégrez-la à l'[PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html)action dans Kinesis. Cela permet au client d’ajouter un enregistrement de données unique au flux nommé.
+ Exposez une méthode HTTP PUT sur la `/streams/{stream-name}/records` ressource de l'API et intégrez-la à l'[PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html)action dans Kinesis. Cela permet au client d’ajouter une liste d’enregistrements de données au flux nommé.
+ Exposez une méthode HTTP GET sur la `/streams/{stream-name}/records` ressource de l'API et intégrez-la à l'[GetRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html)action dans Kinesis. Cela permet au client d’afficher la liste des enregistrements de données du flux nommé, avec un itérateur de partition spécifique. Un itérateur de partition spécifie la position de la partition à partir de laquelle la lecture séquentielle des enregistrements de données doit commencer.
+ Exposez une méthode HTTP GET sur la `/streams/{stream-name}/sharditerator` ressource de l'API et intégrez-la à l'[GetShardIterator](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html)action dans Kinesis. Cette méthode d’assistance doit être fournie à l’action `ListStreams` dans Kinesis.
Vous pouvez appliquer les instructions présentées ici aux autres actions Kinesis. Pour obtenir la liste complète des actions Kinesis, consultez la [Référence d’API Amazon Kinesis](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html).
Au lieu d’utiliser la console API Gateway pour créer l’exemple d’API, vous pouvez importer l’exemple d’API dans API Gateway à l’aide de l’[API d’importation](https://docs.aws.amazon.com/apigateway/latest/api/API_ImportRestApi.html) d’API Gateway. Pour plus d’informations sur l’utilisation de la fonction d’importation d’API, consultez [Développez REST APIs à l'aide d'OpenAPI dans API Gateway](api-gateway-import-api.md).
## Création d’un rôle et d’une politique IAM pour permettre à l’API d’accéder à Kinesis
Pour autoriser l’API à invoquer des actions Kinesis, vous devez avoir attaché les politiques IAM appropriées à un rôle IAM. Au cours de cette étape, vous allez créer un rôle IAM.
**Pour créer le rôle d'exécution du proxy de AWS service**
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.
1. Sélectionnez **Roles**.
1. Choisissez **Créer un rôle**.
1. Choisissez le **AWS service** sous **Sélectionner le type d'entité de confiance**, puis sélectionnez **API Gateway** et sélectionnez **Allows API Gateway to push CloudWatch logs vers Logs**.
1. Choisissez **Suivant**, puis **Suivant**.
1. Pour **Nom du rôle**, saisissez **APIGatewayKinesisProxyPolicy**, puis choisissez **Créer un rôle**.
1. Dans la liste **Roles**, choisissez le rôle que vous venez de créer. Vous devrez peut-être faire défiler la page ou utiliser la barre de recherche pour rechercher le rôle.
1. Pour le rôle sélectionné, sélectionnez l’onglet **Ajouter des autorisations**.
1. Choisissez **Attacher des politiques** dans la liste déroulante.
1. Dans la barre de recherche, saisissez **AmazonKinesisFullAccess** et choisissez **Ajouter des autorisations**.
**Note**
Ce didacticiel utilise une politique gérée pour plus de simplicité. Il est recommandé de créer votre propre politique IAM afin d’accorder les autorisations minimales requises.
1. Notez l’**ARN du rôle** nouvellement créé. Vous l’utiliserez ultérieurement.
## Création d’une API en tant que proxy Kinesis
Procédez comme suit pour créer l’API dans la console API Gateway.
**Pour créer une API en tant que proxy AWS de service pour Kinesis**
1. Connectez-vous à la console API Gateway à l'adresse [https://console.aws.amazon.com/apigateway.](https://console.aws.amazon.com/apigateway)
1. Si vous utilisez API Gateway pour la première fois, vous voyez une page qui vous présente les fonctions du service. Sous **REST API (API REST)**, choisissez **Build (Création)**. Lorsque la fenêtre contextuelle **Create Example API (Créer API exemple)** s’affiche, cliquez sur **OK**.
Si ce n’est pas la première fois que vous utilisez API Gateway, choisissez **Create API (Créer une API)**. Sous **REST API (API REST)**, choisissez **Build (Création)**.
1. Choisissez **New API (Nouvelle API)**.
1. Sous **API name (Nom de l’API)**, saisissez **KinesisProxy**. Conservez les valeurs par défaut pour tous les autres champs.
1. (Facultatif) Sous **Description**, entrez une description.
1. Pour le **type d'adresse IP**, sélectionnez **IPv4**.
1. Sélectionnez **Create API (Créer une API)**.
Une fois l’API créée, la console API Gateway affiche la page **Resources**, qui contient uniquement la ressource racine (`/`) de cette API.
## Liste des flux dans Kinesis
Kinesis prend en charge l’action `ListStreams` avec l’appel API REST suivant :
```
POST /?Action=ListStreams HTTP/1.1
Host: kinesis..
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.1
Authorization:
X-Amz-Date:
{
...
}
```
Dans la demande API REST ci-dessus, l’action est spécifiée dans le paramètre de requête `Action`. Vous pouvez également spécifier l’action dans l’en-tête `X-Amz-Target`, plutôt que :
```
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
{
...
}
```
Dans ce didacticiel, nous utilisons le paramètre de requête pour spécifier l’action.
Pour exposer une action Kinesis dans l’API, ajoutez une ressource `/streams` à la racine de l’API. Ensuite, définissez une méthode `GET` sur la ressource et intégrez-la avec l’action `ListStreams` de Kinesis.
La procédure suivante décrit comment répertorier les flux Kinesis à l’aide de la console API Gateway.
**Pour répertorier les flux Kinesis à l’aide de la console API Gateway**
1. Sélectionnez la ressource `/`, puis choisissez **Créer une ressource**.
1. Sous **Resource Name (Nom de la ressource)**, entrez **streams**.
1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.
1. Choisissez **Créer une ressource**.
1. Choisissez la ressource `/streams`, puis choisissez **Créer une méthode** et procédez comme suit :
1. Pour **Type de méthode**, sélectionnez **GET**.
**Note**
Le verbe HTTP pour une méthode appelée par un client peut différer du verbe HTTP pour une intégration requise par le serveur principal. Nous sélectionnons `GET` dans ce cas, car l’affichage de la liste des flux est intuitivement une opération READ.
1. Pour **Type d’intégration**, sélectionnez **Service AWS **.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre flux Kinesis.
1. Pour **Service AWS**, sélectionnez **Kinesis**.
1. Laissez **Sous-domaine AWS ** vide.
1. Dans le champ **HTTP Method**, sélectionnez **POST**.
**Note**
Nous avons choisi `POST` dans ce cas, car Kinesis exige que l’action `ListStreams` soit appelée avec lui.
1. Pour **Type d’action**, choisissez **Utiliser un nom d’action**.
1. Pour **Nom de l’action**, saisissez **ListStreams**.
1. Pour **Rôle d’exécution**, saisissez l’ARN de votre rôle d’exécution.
1. Conservez la valeur par défaut de **Transmettre** pour **Gestion de contenu**.
1. Choisissez **Créer une méthode**.
1. Dans l’onglet **Requête d’intégration**, sous **Paramètres de requête d’intégration**, choisissez **Modifier**.
1. Pour **Transmission du corps de requête**, sélectionnez **Lorsqu’aucun modèle n’est défini (recommandé)**.
1. Choisissez **Paramètres des en-têtes de requête d’URL** et procédez comme suit :
1. Choisissez le **paramètre Ajouter des en-têtes de requête**.
1. Pour **Nom**, saisissez **Content-Type**.
1. Pour **Mappage à partir de**, entrez **'application/x-amz-json-1.1'**.
Nous avons utilisé un mappage de paramètre de requête pour définir l’en-tête `Content-Type` sur la valeur statique de `'application/x-amz-json-1.1'` afin d’informer Kinesis que l’entrée est une version spécifique de JSON.
1. Choisissez **Modèles de mappage**, puis choisissez **Ajouter un modèle de mappage**, puis procédez comme suit :
1. Pour **Type de contenu**, saisissez **application/json**.
1. Pour **Corps du modèle**, saisissez **\$1\$1**.
1. Choisissez **Enregistrer**.
La [ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html#API_ListStreams_RequestSyntax)demande prend une charge utile au format JSON suivant :
```
{
"ExclusiveStartStreamName": "string",
"Limit": number
}
```
Cependant, les propriétés sont facultatives. Pour utiliser les valeurs par défaut, nous avons choisi une charge utile JSON vide dans ce cas.
1. Testez la méthode GET sur la ressource **/streams** pour invoquer l’action `ListStreams` dans Kinesis :
Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet.
Choisissez **Tester** pour tester votre méthode.
Si vous avez déjà créé deux flux nommés « myStream » et « yourStream » dans Kinesis, le test réussi renvoie une réponse 200 OK contenant la charge utile suivante :
```
{
"HasMoreStreams": false,
"StreamNames": [
"myStream",
"yourStream"
]
}
```
## Création, description et suppression d’un flux dans Kinesis
La création, la description et la suppression d’un flux dans Kinesis impliquent respectivement d’effectuer les demandes d’API REST Kinesis suivantes :
```
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"
}
```
Nous pouvons créer l’API pour qu’elle accepte l’entrée requises en tant que charge utile JSON de la demande de méthode et la transmette via la demande d’intégration. Cependant, pour fournir davantage d’exemples de mappage de données entre les demandes de méthode et d’intégration, et entre les réponses de méthode et d’intégration, nous allons créer notre API légèrement différemment.
Nous exposons les méthodes `GET``POST`,, et `Delete` HTTP sur une to-be-named `Stream` ressource. Nous utilisons la variable de chemin `{stream-name}` comme espace réservé de la ressource de flux et intégrons respectivement ces méthodes d’API avec les actions `DescribeStream`, `CreateStream` et `DeleteStream` de Kinesis, respectivement. Nous exigeons que le client transmette les autres données d’entrée, telles que les en-têtes, les paramètres de requête ou la charge utile d’une demande de méthode. Nous fournissons des modèles de mappage pour transformer ces données en charge utile de la demande d’intégration requise.
**Pour créer la ressource \$1stream-name\$1**
1. Sélectionnez la ressource **/streams**, puis choisissez **Créer une ressource**.
1. Maintenez **Ressource proxy** désactivée.
1. Pour **Chemin de ressource**, sélectionnez `/streams`.
1. Sous **Resource Name (Nom de la ressource)**, entrez **\$1stream-name\$1**.
1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.
1. Choisissez **Créer une ressource**.
**Pour configurer et tester la méthode GET sur une ressource de flux**
1. Sélectionnez la ressource **/\$1stream-name\$1**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **GET**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS **.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre flux Kinesis.
1. Pour **Service AWS**, sélectionnez **Kinesis**.
1. Laissez **Sous-domaine AWS ** vide.
1. Dans le champ **HTTP Method**, sélectionnez **POST**.
1. Pour **Type d’action**, choisissez **Utiliser un nom d’action**.
1. Pour **Nom de l’action**, saisissez **DescribeStream**.
1. Pour **Rôle d’exécution**, saisissez l’ARN de votre rôle d’exécution.
1. Conservez la valeur par défaut de **Transmettre** pour **Gestion de contenu**.
1. Choisissez **Créer une méthode**.
1. Dans la section **Requête d’intégration**, ajoutez les **Paramètres d’en-tête de requête d’URL** suivants :
```
Content-Type: 'x-amz-json-1.1'
```
La tâche suit la même procédure pour configurer le mappage de paramètre de demande pour la méthode `GET /streams`.
1. Ajoutez le modèle de mappage de corps suivant pour mapper des données à partir de la demande de méthode `GET /streams/{stream-name}` à la demande d’intégration `POST /?Action=DescribeStream` :
```
{
"StreamName": "$input.params('stream-name')"
}
```
Ce modèle de mappage génère la charge utile de demande d’intégration requise pour l’action `DescribeStream` de Kinesis à partir de la valeur du paramètre de chemin `stream-name` de la demande de méthode.
1. Pour tester la méthode `GET /stream/{stream-name}` permettant d’invoquer l’action `DescribeStream` dans Kinesis, cliquez sur l’onglet **Tester**.
1. Pour **Chemin**, sous **nom du flux**, entrez le nom d’un flux Kinesis existant.
1. Sélectionnez **Tester)**. Si le test aboutit, une réponse 200 OK est renvoyée avec une charge utile similaire à celle qui suit :
```
{
"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"
}
}
```
Après avoir déployé l’API, vous pouvez exécuter une demande REST sur cette méthode d’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
```
**Pour configurer et tester la méthode POST sur une ressource de flux**
1. Sélectionnez la ressource **/\$1stream-name\$1**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **POST**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS **.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre flux Kinesis.
1. Pour **Service AWS**, sélectionnez **Kinesis**.
1. Laissez **Sous-domaine AWS ** vide.
1. Dans le champ **HTTP Method**, sélectionnez **POST**.
1. Pour **Type d’action**, choisissez **Utiliser un nom d’action**.
1. Pour **Nom de l’action**, saisissez **CreateStream**.
1. Pour **Rôle d’exécution**, saisissez l’ARN de votre rôle d’exécution.
1. Conservez la valeur par défaut de **Transmettre** pour **Gestion de contenu**.
1. Choisissez **Créer une méthode**.
1. Dans la section **Requête d’intégration**, ajoutez les **Paramètres d’en-tête de requête d’URL** suivants :
```
Content-Type: 'x-amz-json-1.1'
```
La tâche suit la même procédure pour configurer le mappage de paramètre de demande pour la méthode `GET /streams`.
1. Ajoutez le modèle de mappage de corps suivant pour mapper des données à partir de la demande de méthode `POST /streams/{stream-name}` à la demande d’intégration `POST /?Action=CreateStream` :
```
{
"ShardCount": #if($input.path('$.ShardCount') == '') 5 #else $input.path('$.ShardCount') #end,
"StreamName": "$input.params('stream-name')"
}
```
Dans le modèle de mappage précédent, nous configurons `ShardCount` sur une valeur fixe de 5, si le client ne spécifie aucune valeur dans la charge utile de la demande de méthode.
1. Pour tester la méthode `POST /stream/{stream-name}` permettant d’invoquer l’action `CreateStream` dans Kinesis, cliquez sur l’onglet **Tester**.
1. Pour **Chemin**, sous **nom du flux**, entrez le nom d’un nouveau flux Kinesis.
1. Sélectionnez **Tester)**. Si le test aboutit, une réponse 200 OK est renvoyée sans aucune donnée.
Après avoir déployé l’API, vous pouvez également exécuter une demande d’API REST avec la méthode POST sur une ressource de flux pour appeler l’action `CreateStream` dans 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
}
```
**Configuration et test de la méthode DELETE sur une ressource de flux**
1. Sélectionnez la ressource **/\$1stream-name\$1**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **DELETE**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS **.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre flux Kinesis.
1. Pour **Service AWS**, sélectionnez **Kinesis**.
1. Laissez **Sous-domaine AWS ** vide.
1. Dans le champ **HTTP Method**, sélectionnez **POST**.
1. Pour **Type d’action**, choisissez **Utiliser un nom d’action**.
1. Pour **Nom de l’action**, saisissez **DeleteStream**.
1. Pour **Rôle d’exécution**, saisissez l’ARN de votre rôle d’exécution.
1. Conservez la valeur par défaut de **Transmettre** pour **Gestion de contenu**.
1. Choisissez **Créer une méthode**.
1. Dans la section **Requête d’intégration**, ajoutez les **Paramètres d’en-tête de requête d’URL** suivants :
```
Content-Type: 'x-amz-json-1.1'
```
La tâche suit la même procédure pour configurer le mappage de paramètre de demande pour la méthode `GET /streams`.
1. Ajoutez le modèle de mappage de corps suivant pour mapper des données à partir de la demande de méthode `DELETE /streams/{stream-name}` à la demande d’intégration correspondante de `POST /?Action=DeleteStream` :
```
{
"StreamName": "$input.params('stream-name')"
}
```
Ce modèle de mappage génère l’entrée requise pour l’action `DELETE /streams/{stream-name}` à partir du nom du chemin de l’URL fourni par le client de `stream-name`.
1. Pour tester la méthode `DELETE /stream/{stream-name}` permettant d’invoquer l’action `DeleteStream` dans Kinesis, cliquez sur l’onglet **Tester**.
1. Pour **Chemin**, sous **nom du flux**, entrez le nom d’un flux Kinesis existant.
1. Sélectionnez **Tester)**. Si le test aboutit, une réponse 200 OK est renvoyée sans aucune donnée.
Après avoir déployé l’API, vous pouvez également exécuter la demande d’API REST suivante avec la méthode DELETE sur la ressource de flux pour appeler l’action `DeleteStream` dans 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
{}
```
## Obtention d’enregistrements d’un flux et ajout d’enregistrements à un flux dans Kinesis
Après avoir créé un flux dans Kinesis, vous pouvez ajouter des enregistrements de données à ce flux et lire les données du flux. L'ajout d'enregistrements de données implique d'appeler l'[PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html#API_PutRecord_Examples)action [PutRecords](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html#API_PutRecords_Examples)ou dans Kinesis. La première ajoute plusieurs enregistrements, tandis que la seconde ajoute un seul enregistrement au flux.
```
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"
}
```
ou
```
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"
}
```
Ici, `StreamName` identifie le flux cible pour ajouter des enregistrements. `StreamName`, `Data`, et `PartitionKey` sont des données d’entrée requises. Dans notre exemple, nous utilisons les valeurs par défaut de toutes les données d’entrée facultatives et nous ne spécifierons pas explicitement leurs valeurs dans les données d’entrée de la demande de méthode.
Lire des données dans Kinesis revient à lancer l'action suivante : [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
}
```
Ici, le flux source à partir duquel nous obtenons les enregistrements est spécifié dans la valeur requise `ShardIterator`, comme indiqué dans l’action Kinesis suivante pour obtenir un itérateur de partition :
```
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"
}
```
Pour les actions `GetRecords` et `PutRecords`, nous exposons respectivement les méthodes `GET` et `PUT` sur une ressource `/records` qui est ajoutée à une ressource de flux nommé (`/{stream-name}`). De même, nous exposons l’action `PutRecord` en tant que méthode `PUT` sur une ressource `/record`.
Étant donné que l’action `GetRecords` utilise comme données d’entrée une valeur `ShardIterator`, qui est obtenue en appelant l’action d’assistance `GetShardIterator`, nous exposons une méthode d’assistance `GET` sur une ressource `ShardIterator` (`/sharditerator`).
**Pour créer les ressources /record, /records et /sharditerator**
1. Sélectionnez la ressource **/\$1stream-name\$1**, puis choisissez **Créer une ressource**.
1. Maintenez **Ressource proxy** désactivée.
1. Pour **Chemin de ressource**, sélectionnez `/{stream-name}`.
1. Sous **Resource Name (Nom de la ressource)**, entrez **record**.
1. Maintenez **CORS (Partage des ressources entre origines multiples)** désactivé.
1. Choisissez **Créer une ressource**.
1. Répétez les étapes précédentes pour créer une ressource **/records** et une ressource **/sharditerator**. L’API finale doit ressembler à ce qui suit :
![\[Création de méthodes Records:GET|PUT|PUT|GET pour l’API\]](http://docs.aws.amazon.com/fr_fr/apigateway/latest/developerguide/images/api-gateway-kinesis-proxy-setup-streams-stream-record-method-new-console.png)
Les quatre procédures suivantes expliquent comment configurer chacune des méthodes, comment mapper les données des demandes de méthode aux demandes d’intégration et comment tester les méthodes.
**Pour configurer et tester la méthode `PUT /streams/{stream-name}/record` de façon à ce qu’elle appelle `PutRecord` dans Kinesis**
1. Sélectionnez **/record**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **PUT**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS **.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre flux Kinesis.
1. Pour **Service AWS**, sélectionnez **Kinesis**.
1. Laissez **Sous-domaine AWS ** vide.
1. Dans le champ **HTTP Method**, sélectionnez **POST**.
1. Pour **Type d’action**, choisissez **Utiliser un nom d’action**.
1. Pour **Nom de l’action**, saisissez **PutRecord**.
1. Pour **Rôle d’exécution**, saisissez l’ARN de votre rôle d’exécution.
1. Conservez la valeur par défaut de **Transmettre** pour **Gestion de contenu**.
1. Choisissez **Créer une méthode**.
1. Dans la section **Requête d’intégration**, ajoutez les **Paramètres d’en-tête de requête d’URL** suivants :
```
Content-Type: 'x-amz-json-1.1'
```
La tâche suit la même procédure pour configurer le mappage de paramètre de demande pour la méthode `GET /streams`.
1. Ajoutez le modèle de mappage de corps suivant pour mapper des données à partir de la demande de méthode `PUT /streams/{stream-name}/record` à la demande d’intégration correspondante de `POST /?Action=PutRecord` :
```
{
"StreamName": "$input.params('stream-name')",
"Data": "$util.base64Encode($input.json('$.Data'))",
"PartitionKey": "$input.path('$.PartitionKey')"
}
```
Ce modèle de mappage suppose que la charge utile de la demande de méthode est au format suivant :
```
{
"Data": "some data",
"PartitionKey": "some key"
}
```
Ces données peuvent être modélisées par le schéma JSON suivant :
```
{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PutRecord proxy single-record payload",
"type": "object",
"properties": {
"Data": { "type": "string" },
"PartitionKey": { "type": "string" }
}
}
```
Vous pouvez créer un modèle pour inclure ce schéma et utiliser ce modèle pour faciliter la génération du modèle de mappage. Cependant, vous pouvez également générer un modèle de mappage sans utiliser aucun modèle.
1. Pour tester la méthode `PUT /streams/{stream-name}/record`, définissez la variable de chemin `stream-name` sur le nom d’un flux existant, fournissez une charge utile au format requis, puis envoyez la demande de méthode. Si le test aboutit, le résultat est une réponse `200 OK ` avec une charge utile au format suivant :
```
{
"SequenceNumber": "49559409944537880850133345460169886593573102115167928386",
"ShardId": "shardId-000000000004"
}
```
**Pour configurer et tester la méthode `PUT /streams/{stream-name}/records` de façon à ce qu’elle appelle `PutRecords` dans Kinesis**
1. Sélectionnez **/records**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **PUT**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS **.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre flux Kinesis.
1. Pour **Service AWS**, sélectionnez **Kinesis**.
1. Laissez **Sous-domaine AWS ** vide.
1. Dans le champ **HTTP Method**, sélectionnez **POST**.
1. Pour **Type d’action**, choisissez **Utiliser un nom d’action**.
1. Pour **Nom de l’action**, saisissez **PutRecords**.
1. Pour **Rôle d’exécution**, saisissez l’ARN de votre rôle d’exécution.
1. Conservez la valeur par défaut de **Transmettre** pour **Gestion de contenu**.
1. Choisissez **Créer une méthode**.
1. Dans la section **Requête d’intégration**, ajoutez les **Paramètres d’en-tête de requête d’URL** suivants :
```
Content-Type: 'x-amz-json-1.1'
```
La tâche suit la même procédure pour configurer le mappage de paramètre de demande pour la méthode `GET /streams`.
1. Ajoutez le modèle de mappage de corps suivant pour mapper des données à partir de la requête de méthode `PUT /streams/{stream-name}/records` à la requête d’intégration correspondante de `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
]
}
```
Ce modèle de mappage suppose que la charge utile de la demande de méthode puisse être modélisée par le schéma JSON suivant :
```
{
"$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" }
}
}
}
}
}
```
Vous pouvez créer un modèle pour inclure ce schéma et utiliser ce modèle pour faciliter la génération du modèle de mappage. Cependant, vous pouvez également générer un modèle de mappage sans utiliser aucun modèle.
Dans ce didacticiel, nous avons utilisé deux formats de charge utile légèrement différents pour illustrer qu’un développeur d’API peut choisir d’exposer le format de données principal au client ou de lui cacher. Un format concerne la méthode `PUT /streams/{stream-name}/records` (ci-dessus). Un autre format est utilisé pour la méthode `PUT /streams/{stream-name}/record` (dans la procédure précédente). Dans un environnement de production, vous devez maintenir la cohérence des deux formats.
1.
Pour tester la méthode `PUT /streams/{stream-name}/records`, définissez la variable de chemin `stream-name` sur un flux existant, fournissez la charge utile suivante, puis envoyez la demande de méthode.
```
{
"records": [
{
"data": "some data",
"partition-key": "some key"
},
{
"data": "some other data",
"partition-key": "some key"
}
]
}
```
Si le test aboutit, le résultat est une réponse 200 OK avec une charge utile semblable à la sortie suivante :
```
{
"FailedRecordCount": 0,
"Records": [
{
"SequenceNumber": "49559409944537880850133345460167468741933742152373764162",
"ShardId": "shardId-000000000004"
},
{
"SequenceNumber": "49559409944537880850133345460168677667753356781548470338",
"ShardId": "shardId-000000000004"
}
]
}
```
**Pour configurer et tester la méthode `GET /streams/{stream-name}/sharditerator`, appelez `GetShardIterator` dans Kinesis**
La méthode `GET /streams/{stream-name}/sharditerator` est une méthode d’assistance permettant d’acquérir un itérateur de partition requis avant d’appeler la méthode `GET /streams/{stream-name}/records`.
1. Sélectionnez la ressource **/sharditerator**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **GET**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS **.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre flux Kinesis.
1. Pour **Service AWS**, sélectionnez **Kinesis**.
1. Laissez **Sous-domaine AWS ** vide.
1. Dans le champ **HTTP Method**, sélectionnez **POST**.
1. Pour **Type d’action**, choisissez **Utiliser un nom d’action**.
1. Pour **Nom de l’action**, saisissez **GetShardIterator**.
1. Pour **Rôle d’exécution**, saisissez l’ARN de votre rôle d’exécution.
1. Conservez la valeur par défaut de **Transmettre** pour **Gestion de contenu**.
1. Choisissez **Paramètres de chaîne de requête d’URL**.
L’action `GetShardIterator` nécessite une valeur ShardId en entrée. Pour transmettre une valeur `ShardId` fournie par le client, nous ajoutons un paramètre de requête `shard-id` à la requête de méthode, comme indiqué dans l’étape suivante.
1. Sélectionnez **Add query string** (Ajouter une chaîne de requêtes).
1. Pour **Nom**, saisissez **shard-id**.
1. Gardez **Obligatoire** et **Mise en cache** désactivés.
1. Choisissez **Créer une méthode**.
1. Dans la section **Requête d’intégration**, ajoutez le modèle de mappage pour générer l’entrée requise (`ShardId` et `StreamName`) pour l’action `GetShardIterator` à partir des paramètres `shard-id` et `stream-name` de la requête de méthode. En outre, le modèle de mappage définit également `ShardIteratorType` à `TRIM_HORIZON` en tant que valeur par défaut.
```
{
"ShardId": "$input.params('shard-id')",
"ShardIteratorType": "TRIM_HORIZON",
"StreamName": "$input.params('stream-name')"
}
```
1. À l’aide de l’option **Test** de la console API Gateway, entrez un nom de flux existant en tant que valeur de variable `stream-name` **Path (Chemin)**, définissez la `shard-id` **chaîne de requête** sur une valeur `ShardId` existante (par exemple, `shard-000000000004`) et choisissez **Test**.
Si le test aboutit, la charge utile de la réponse est similaire à la sortie suivante :
```
{
"ShardIterator": "AAAAAAAAAAFYVN3VlFy..."
}
```
Notez la valeur `ShardIterator`. Vous en avez besoin pour obtenir les enregistrements d’un flux.
**Pour configurer et tester la méthode `GET /streams/{stream-name}/records` pour appeler l’action `GetRecords` dans Kinesis**
1. Sélectionnez **/records**, puis choisissez **Créer une méthode**.
1. Pour **Type de méthode**, sélectionnez **GET**.
1. Pour **Type d’intégration**, sélectionnez **Service AWS **.
1. Pour **Région AWS**, sélectionnez l' Région AWS endroit où vous avez créé votre flux Kinesis.
1. Pour **Service AWS**, sélectionnez **Kinesis**.
1. Laissez **Sous-domaine AWS ** vide.
1. Dans le champ **HTTP Method**, sélectionnez **POST**.
1. Pour **Type d’action**, choisissez **Utiliser un nom d’action**.
1. Pour **Nom de l’action**, saisissez **GetRecords**.
1. Pour **Rôle d’exécution**, saisissez l’ARN de votre rôle d’exécution.
1. Conservez la valeur par défaut de **Transmettre** pour **Gestion de contenu**.
1. Développez **En-têtes de demande HTTP**.
L’action `GetRecords` nécessite une valeur `ShardIterator` en entrée. Pour transmettre une valeur `ShardIterator` fournie par le client, nous ajoutons un paramètre d’en-tête `Shard-Iterator` à la demande de méthode.
1. Sélectionnez **Add header**.
1. Pour **Nom**, saisissez **Shard-Iterator**.
1. Gardez **Obligatoire** et **Mise en cache** désactivés.
1. Choisissez **Créer une méthode**.
1. Dans la section **Requête d’intégration**, ajoutez le modèle de mappage suivant pour mapper la valeur du paramètre d’en-tête `Shard-Iterator` à la valeur de propriété `ShardIterator` de la charge utile JSON pour l’action `GetRecords` dans Kinesis.
```
{
"ShardIterator": "$input.params('Shard-Iterator')"
}
```
1. À l’aide de l’option **Tester** dans la console API Gateway, saisissez un nom de flux existant comme valeur de variable `stream-name` **Chemin**, définissez l’**en-tête** `Shard-Iterator` sur la valeur `ShardIterator` obtenue à partir de l’exécution de test de la méthode `GET /streams/{stream-name}/sharditerator` (ci-dessus) et choisissez **Tester**.
Si le test aboutit, la charge utile de la réponse est similaire à la sortie suivante :
```
{
"MillisBehindLatest": 0,
"NextShardIterator": "AAAAAAAAAAF...",
"Records": [ ... ]
}
```
# Définitions OpenAPI d’un exemple d’API en tant que proxy Kinesis
Vous trouverez ci-après des définitions OpenAPI pour l’exemple d’API en tant que proxy Kinesis utilisé dans ce didacticiel.
------
#### [ 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"
}
}
}
}
}
}
}
}
```
------