Configuration d'une API optimisée pour les périphériques à l'aide des commandes de l' AWS CLI

La configuration d'une API à l'aide de la commande AWS CLI nécessite d'utiliser les put-integration-response commandes create-rest-api get-resourcesput-method, create-resource ou put-method-responseput-integration,,, et. Les procédures suivantes montrent comment utiliser ces AWS CLI commandes pour créer l' PetStore API simple du type HTTP d'intégration.

Pour créer une PetStore API simple à l'aide de AWS CLI

Appelez la commande create-rest-api pour configurer l'API RestApi dans une région spécifique (us-west-2).


aws apigateway create-rest-api --name 'Simple PetStore (AWS CLI)' --region us-west-2

Voici la sortie de cette commande :


{
    "id": "vaz7da96z6", 
    "name": "Simple PetStore (AWS CLI)", 
    "createdDate": "2022-12-15T08:07:04-08:00",
    "apiKeySource": "HEADER",
    "endpointConfiguration": {
        "types": [
            "EDGE"
        ]
    },
    "disableExecuteApiEndpoint": false
}

Notez la valeur id renvoyée pour l'API RestApi nouvellement créée. Vous en aurez besoin pour configurer d'autres parties de l'API.

Appelez la commande get-resources pour récupérer l'identificateur de ressource racine de l'API RestApi.
```
aws apigateway get-resources --rest-api-id vaz7da96z6 --region us-west-2
```
Voici la sortie de cette commande :
```
{
    "items": [
        {
            "id": "begaltmsm8",
            "path": "/" 
        }
    ]
}
```
Notez la ressource racine Id. Vous en aurez besoin pour commencer la configuration l'arborescence des ressource de l'API et la configuration des méthodes et des intégrations.
Appelez la commande create-resource pour ajouter une ressource enfant (pets) sous la ressource racine (begaltmsm8) :
```
aws apigateway create-resource --rest-api-id vaz7da96z6 \
      --region us-west-2 \
      --parent-id begaltmsm8 \
      --path-part pets
```
Voici la sortie de cette commande :
```
{
    "id": "6sxz2j", 
    "parentId": "begaltmsm8",
    "pathPart": "pets",
    "path": "/pets"
}
```
Pour ajouter une ressource enfant sous la racine, spécifiez la ressource racine Id en tant que la valeur de la propriété parentId. De même, pour ajouter une ressource enfant sous la ressource pets, répétez l'étape précédente tout en remplaçant la valeur parent-id par l'pets de la ressource id 6sxz2j :
```
aws apigateway create-resource --rest-api-id vaz7da96z6 \
      --region us-west-2 \
      --parent-id 6sxz2j \
      --path-part '{petId}'
```
Pour faire d'une partie d'un chemin un paramètre de chemin, entourez-la d'accolades. Si elle aboutit, cette commande renvoie la réponse suivante :
```
{
    "id": "rjkmth",
    "parentId": "6sxz2j",
    "path": "/pets/{petId}", 
    "pathPart": "{petId}"
}
```
Maintenant que vous avez créé deux ressources : /pets (6sxz2j) et /pets/{petId} (rjkmth), vous pouvez continuer à configurer des méthodes basées sur celles-ci.
Appelez la commande put-method pour ajouter la méthode HTTP GET sur la ressource /pets. Cela crée une API Method de GET /pets avec accès ouvert, faisant référence à la ressource /pets par sa valeur d'ID 6sxz2j.
```
aws apigateway put-method --rest-api-id vaz7da96z6 \
       --resource-id 6sxz2j \
       --http-method GET \
       --authorization-type "NONE" \
       --region us-west-2
```
Voici un exemple de la sortie positive de cette commande :
```
{
    "httpMethod": "GET", 
    "authorizationType": "NONE",
    "apiKeyRequired": false
}
```
La méthode concerne l'accès ouvert, car authorization-type est défini sur NONE. Pour autoriser uniquement les utilisateurs authentifiés à appeler la méthode, vous pouvez utiliser des rôles et des stratégies IAM, un mécanisme d'autorisation Lambda (anciennement appelé mécanisme Custom Authorizer) ou un groupe d'utilisateurs Amazon Cognito. Pour de plus amples informations, veuillez consulter Contrôle et gestion de l'accès à une API REST dans API Gateway.

Pour activer l'accès en lecture à la ressource /pets/{petId} (rjkmth), ajoutez-y la méthode HTTP GET pour créer une API Method de GET /pets/{petId} comme suit.
```
aws apigateway put-method --rest-api-id vaz7da96z6 \
       --resource-id rjkmth --http-method GET \
       --authorization-type "NONE" \
       --region us-west-2 \
       --request-parameters method.request.path.petId=true
```
Voici un exemple de la sortie positive de cette commande :
```
{
    "httpMethod": "GET", 
    "authorizationType": "NONE", 
    "apiKeyRequired": false, 
    "requestParameters": {
        "method.request.path.petId": true
    }
}
```
Notez que le paramètre de chemin de demande de méthode de petId doit être spécifié en tant que paramètre de demande obligatoire pour que sa valeur définie de manière dynamique soit mappée à un paramètre de demande d'intégration correspondant et transmise au backend.
Appelez la commande put-method-response pour configurer la réponse 200 OK de la méthode GET /pets, en spécifiant la ressource /pets par sa valeur d'ID 6sxz2j.
```
aws apigateway put-method-response --rest-api-id vaz7da96z6 \ 
       --resource-id 6sxz2j --http-method GET \
       --status-code 200  --region us-west-2
```
Voici la sortie de cette commande :
```
{
    "statusCode": "200"
}
```
De même, pour configurer la réponse 200 OK de la méthode GET /pets/{petId}, procédez comme suit en spécifiant la ressource /pets/{petId} par sa valeur d'ID de ressource rjkmth :
```
aws apigateway put-method-response --rest-api-id vaz7da96z6 \
       --resource-id rjkmth --http-method GET \
       --status-code 200  --region us-west-2
```
Après avoir configuré une interface client simple pour l'API, vous pouvez passer à la configuration de l'intégration des méthodes d'API avec le serveur principal.

Appelez la commande put-integration pour configurer une Integration avec un point de terminaison HTTP spécifié pour la méthode GET /pets. La ressource /pets est identifiée par son ID de ressource 6sxz2j :


aws apigateway put-integration --rest-api-id vaz7da96z6 \
       --resource-id 6sxz2j --http-method GET --type HTTP \
       --integration-http-method GET \
       --uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets' \
       --region us-west-2

Voici la sortie de cette commande :


{
    "type": "HTTP",
    "httpMethod": "GET",
    "uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
    "connectionType": "INTERNET",
    "passthroughBehavior": "WHEN_NO_MATCH",
    "timeoutInMillis": 29000,
    "cacheNamespace": "6sxz2j",
    "cacheKeyParameters": []
}

Notez que l'uri d'intégration de http://petstore-demo-endpoint.execute-api.com/petstore/pets spécifie le point de terminaison d'intégration de la méthode GET /pets.

De même, vous créez une demande d'intégration pour la méthode GET /pets/{petId} comme suit :


aws apigateway put-integration \
        --rest-api-id vaz7da96z6 \ 
        --resource-id rjkmth \
        --http-method GET \
        --type HTTP \
        --integration-http-method GET \
        --uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}' \ 
        --request-parameters '{"integration.request.path.id":"method.request.path.petId"}' \
        --region us-west-2

Ici, le point de terminaison d'intégration, uri de http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}, utilise également un paramètre de chemin (id). Sa valeur est mappée à partir du paramètre de chemin de demande de méthode correspondant {petId}. Le mappage est défini dans le cadre des request-parameters. Si ce mappage n'est pas défini ici, le client reçoit une réponse d'erreur lorsqu'il essaie d'appeler la méthode.

Voici la sortie de cette commande :


{
    "type": "HTTP",
    "httpMethod": "GET",
    "uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
    "connectionType": "INTERNET",
    "requestParameters": {
        "integration.request.path.id": "method.request.path.petId"
    },
    "passthroughBehavior": "WHEN_NO_MATCH",
    "timeoutInMillis": 29000,
    "cacheNamespace": "rjkmth",
    "cacheKeyParameters": []
}

Appelez la commande put-integration-response pour créer une réponse IntegrationResponse de la méthode GET /pets intégrée à un backend HTTP.
```
aws apigateway put-integration-response --rest-api-id vaz7da96z6 \
       --resource-id 6sxz2j --http-method GET \
       --status-code 200 --selection-pattern ""  \
       --region us-west-2
```
Voici la sortie de cette commande :
```
{
    "statusCode": "200",
    "selectionPattern": "" 
}
```
De même, appelez la commande put-integration-response suivante pour créer une réponse IntegrationResponse de la méthode GET /pets/{petId} :
```
aws apigateway put-integration-response --rest-api-id vaz7da96z6 \
      --resource-id rjkmth --http-method GET 
      --status-code 200 --selection-pattern ""  
      --region us-west-2
```
Au cours des étapes précédentes, vous avez terminé de configurer une API simple qui permet à vos clients d'interroger les animaux de compagnie disponibles sur le PetStore site Web et de voir un animal individuel avec un identifiant spécifique. Pour le rendre appelable par votre client, vous devez déployer l'API.

Déployer l'API jusqu'à une étape stage, par exemple, en appelant create-deployment :


aws apigateway create-deployment --rest-api-id vaz7da96z6 \ 
       --region us-west-2 \
       --stage-name test \
       --stage-description 'Test stage' \
       --description 'First deployment'

Voici la sortie de cette commande :


{
    "id": "ab1c1d",
    "description": "First deployment",
    "createdDate": "2022-12-15T08:44:13-08:00"
}

Vous pouvez tester cette API en saisissant l'URL https://vaz7da96z6.execute-api.us-west-2.amazonaws.com/test/pets dans un navigateur, et en remplaçant vaz7da96z6 par l'identificateur de votre API. La sortie attendue devrait se présenter comme suit :


[
  {
    "id": 1,
    "type": "dog",
    "price": 249.99
  },
  {
    "id": 2,
    "type": "cat",
    "price": 124.99
  },
  {
    "id": 3,
    "type": "fish",
    "price": 0.99
  }
]

Pour tester la méthode GET /pets/{petId}, tapez https://vaz7da96z6.execute-api.us-west-2.amazonaws.com/test/pets/3 dans le navigateur. Vous devriez recevoir la réponse suivante :


{
  "id": 3,
  "type": "fish",
  "price": 0.99
}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Configuration d'une API à l'aide de la console API Gateway

Configuration d'une API optimisée pour les périphériques à l'aide du kit SDK AWS pour Node.js