Configurar uma API otimizada para bordas usando comandos da AWS CLI

A configuração de uma API usando o AWS CLI exige trabalhar com os put-integration-response comandos create-resource ou create-rest-api get-resources put-method put-method-responseput-integration,,, e. Os procedimentos a seguir mostram como trabalhar com esses AWS CLI comandos para criar a PetStore API simples do tipo de HTTP integração.

Para criar uma PetStore API simples usando AWS CLI

Chame o comando create-rest-api para configurar a RestApi em uma região específica (us-west-2).


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

Veja a seguir a saída desse comando:


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

Anote o id retornado da RestApi recém-criada. Ele será necessário para a configuração de outras partes da API.

Chame o comando get-resources para recuperar o identificador de recurso raiz da RestApi.
```
aws apigateway get-resources --rest-api-id vaz7da96z6 --region us-west-2
```
Veja a seguir a saída desse comando:
```
{
    "items": [
        {
            "id": "begaltmsm8",
            "path": "/" 
        }
    ]
}
```
Anote o do recurso rai Id. Ele é necessário para iniciar a definição da árvore de recursos de API e configurar os métodos e as integrações.
Chame o comando create-resource para anexar um recurso filho (pets) sob o recurso raiz (begaltmsm8):
```
aws apigateway create-resource --rest-api-id vaz7da96z6 \
      --region us-west-2 \
      --parent-id begaltmsm8 \
      --path-part pets
```
Veja a seguir a saída desse comando:
```
{
    "id": "6sxz2j", 
    "parentId": "begaltmsm8",
    "pathPart": "pets",
    "path": "/pets"
}
```
Para anexar um recurso filho sob a raiz, especifique o Id do recurso raiz como o valor da propriedade parentId. Da mesma forma, para anexar um recurso filho sob o recurso pets, repita as etapas anteriores substituindo o valor parent-id pelo pets recurso id de 6sxz2j:
```
aws apigateway create-resource --rest-api-id vaz7da96z6 \
      --region us-west-2 \
      --parent-id 6sxz2j \
      --path-part '{petId}'
```
Para tornar uma parte do caminho um parâmetro de caminho, coloque-a entre chaves. Se houver êxito, o comando gerará a seguinte resposta:
```
{
    "id": "rjkmth",
    "parentId": "6sxz2j",
    "path": "/pets/{petId}", 
    "pathPart": "{petId}"
}
```
Agora que você criou dois recursos: /pets (6sxz2j) e /pets/{petId} (rjkmth), você pode configurar os métodos neles.
Chame o comando put-method para adicionar o método HTTP GET ao recurso /pets. Isso cria um Method de API de GET /pets com acesso aberto, fazendo referência ao recurso /pets por seu valor de ID de 6sxz2j.
```
aws apigateway put-method --rest-api-id vaz7da96z6 \
       --resource-id 6sxz2j \
       --http-method GET \
       --authorization-type "NONE" \
       --region us-west-2
```
Veja a seguir a saída bem-sucedida desse comando:
```
{
    "httpMethod": "GET", 
    "authorizationType": "NONE",
    "apiKeyRequired": false
}
```
O método é para acesso aberto porque authorization-type é definido como NONE. Para permitir que somente usuários autenticados chamem o método, você pode usar as funções e políticas do IAM, um autorizador do Lambda (anteriormente conhecido como autorizador personalizado) ou um grupo de usuários do Amazon Cognito. Para obter mais informações, consulte Controlar e gerenciar acesso a uma API REST no API Gateway.

Para ativar o acesso de leitura ao recurso /pets/{petId} (rjkmth), adicione o método HTTP GET para criar um Method de API de GET /pets/{petId} da seguinte forma.
```
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
```
Veja a seguir a saída bem-sucedida desse comando:
```
{
    "httpMethod": "GET", 
    "authorizationType": "NONE", 
    "apiKeyRequired": false, 
    "requestParameters": {
        "method.request.path.petId": true
    }
}
```
Observe que o parâmetro de caminho de solicitação de método de petId deve ser especificado como um parâmetro de solicitação obrigatório para seu valor definido dinamicamente ser mapeado para um parâmetro de solicitação de integração correspondente e transmitido para o backend.
Chame o comando put-method-response para configurar a resposta 200 OK do método GET /pets especificando o recurso /pets por seu valor de ID de 6sxz2j.
```
aws apigateway put-method-response --rest-api-id vaz7da96z6 \ 
       --resource-id 6sxz2j --http-method GET \
       --status-code 200  --region us-west-2
```
Veja a seguir a saída desse comando:
```
{
    "statusCode": "200"
}
```
De forma semelhante, para definir a resposta 200 OK do método GET /pets/{petId}, faça o seguinte, especificando o recurso /pets/{petId} por seu valor de ID de recurso de rjkmth:
```
aws apigateway put-method-response --rest-api-id vaz7da96z6 \
       --resource-id rjkmth --http-method GET \
       --status-code 200  --region us-west-2
```
Depois de definir uma interface de cliente simples para a API, você poderá configurar a integração dos métodos de API com o backend.

Chame o comando put-integration para configurar um Integration com um endpoint HTTP especificado para o método GET /pets. O recurso /pets é identificado por seu ID de recurso 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

Veja a seguir a saída desse comando:


{
    "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": []
}

Observe que o uri de integração de http://petstore-demo-endpoint.execute-api.com/petstore/pets especifica o endpoint de integração do método GET /pets.

Da mesma forma, veja a seguir como criar uma solicitação de integração para o método GET /pets/{petId}:


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

Aqui, o endpoint de integração, o uri de http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}, também usa um parâmetro de caminho (id). Seu valor é mapeado do parâmetro de caminho de solicitação de método correspondente de {petId}. O mapeamento é definido como parte do request-parameters. Se esse mapeamento não for definido aqui, o cliente receberá uma resposta de erro ao tentar chamar o método.

Veja a seguir a saída desse comando:


{
    "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": []
}

Chame o comando put-integration-response para criar um IntegrationResponse do método GET /pets integrado a um 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
```
Veja a seguir a saída desse comando:
```
{
    "statusCode": "200",
    "selectionPattern": "" 
}
```
Da mesma forma, chame o comando put-integration-response a seguir para criar uma IntegrationResponse do método 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
```
Com as etapas anteriores, você concluiu a configuração de uma API simples que permite que seus clientes consultem animais de estimação disponíveis no PetStore site e visualizem um animal de estimação individual com um identificador especificado. Para que ela possa ser chamada pelo seu cliente, você deve implantar a API.

Implante a API em um estágio stage, por exemplo, chamando create-deployment:


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

Veja a seguir a saída desse comando:


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

Você pode testar essa API digitando a URL https://vaz7da96z6.execute-api.us-west-2.amazonaws.com/test/pets em um navegador e substituindo vaz7da96z6 pelo identificador da sua API. A saída esperada deve ser a seguinte:


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

Para testar o método GET /pets/{petId}, digite https://vaz7da96z6.execute-api.us-west-2.amazonaws.com/test/pets/3 no navegador. Você deve receber a seguinte resposta:


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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Configurar uma API usando o console do API Gateway

Configurar uma API otimizada para bordas usando o AWS SDK para Node.js