Configurar una API optimizada para bordes mediante comandos de AWS CLI

Para configurar una API mediante la AWS CLI, es necesario trabajar con los comandos create-rest-api, create-resource o get-resources, put-method, put-method-response, put-integration y put-integration-response. Los siguientes procedimientos muestran cómo trabajar con estos comandos de la AWS CLI para crear la API de PetStore del tipo de integración HTTP.

Para crear una API PetStore sencilla mediante la AWS CLI

Llame al comando create-rest-api para configurar la RestApi en una región concreta (us-west-2).


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

A continuación se muestra la salida de este comando:


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

Anote el id devuelto de la RestApi recién creada. Lo necesitará para configurar otras partes de la API.

Llame al comando get-resources para recuperar el identificador del recurso raíz de la RestApi.
```
aws apigateway get-resources --rest-api-id vaz7da96z6 --region us-west-2
```
A continuación se muestra la salida de este comando:
```
{
    "items": [
        {
            "id": "begaltmsm8",
            "path": "/" 
        }
    ]
}
```
Anote el del recurso raí Id. Lo necesitará para comenzar a establecer el árbol de recursos de la API y para configurar métodos e integraciones.
Llame al comando create-resource para asociar un recurso secundario (pets) bajo el recurso raíz (begaltmsm8):
```
aws apigateway create-resource --rest-api-id vaz7da96z6 \
      --region us-west-2 \
      --parent-id begaltmsm8 \
      --path-part pets
```
A continuación se muestra la salida de este comando:
```
{
    "id": "6sxz2j", 
    "parentId": "begaltmsm8",
    "pathPart": "pets",
    "path": "/pets"
}
```
Para asociar un recurso secundario bajo la raíz, se especifica el Id del recurso raíz como valor de la propiedad parentId. Del forma similar, para asociar un recurso secundario bajo el recurso pets, se repite el paso anterior y se sustituye el valor parent-id por el pets id del recurso de 6sxz2j:
```
aws apigateway create-resource --rest-api-id vaz7da96z6 \
      --region us-west-2 \
      --parent-id 6sxz2j \
      --path-part '{petId}'
```
Para hacer de una parte de la ruta un parámetro de ruta, sitúela entre llaves. Si se ejecuta correctamente, este comando devuelve la siguiente respuesta:
```
{
    "id": "rjkmth",
    "parentId": "6sxz2j",
    "path": "/pets/{petId}", 
    "pathPart": "{petId}"
}
```
Ahora que ha creado dos recursos, /pets (6sxz2j) y /pets/{petId} (rjkmth), puede continuar configurando métodos sobre ellos.
Llame al comando put-method para añadir el método HTTP GET en el recurso /pets. Esto crea un Method de API de GET /pets con acceso abierto, haciendo referencia al recurso /pets mediante su 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
```
Si se ejecuta correctamente, el resultado de este comando sería el siguiente:
```
{
    "httpMethod": "GET", 
    "authorizationType": "NONE",
    "apiKeyRequired": false
}
```
El método es de acceso abierto porque authorization-type está ajustado en NONE. Para permitir que solo puedan llamar al método los usuarios autenticados, puede utilizar políticas y roles de IAM, un autorizador de Lambda (que anteriormente se denominaba autorizador personalizado) o un grupo de usuarios de Amazon Cognito. Para obtener más información, consulte Control y administración del acceso a una API REST en API Gateway.

Para habilitar el acceso de lectura al recurso /pets/{petId} (rjkmth), añada el método HTTP GET para crear un Method de API de GET /pets/{petId} del siguiente modo.
```
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
```
Si se ejecuta correctamente, el resultado de este comando sería el siguiente:
```
{
    "httpMethod": "GET", 
    "authorizationType": "NONE", 
    "apiKeyRequired": false, 
    "requestParameters": {
        "method.request.path.petId": true
    }
}
```
Tenga en cuenta que el parámetro de ruta de solicitud de método de petId debe especificarse como un parámetro de solicitud necesario para que su valor establecido dinámicamente se asigne a un parámetro de solicitud de integración correspondiente y se transfiera al backend.
Llame al comando put-method-response para configurar la respuesta 200 OK del método GET /pets, especificando el recurso /pets mediante su 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
```
A continuación se muestra la salida de este comando:
```
{
    "statusCode": "200"
}
```
De forma similar, para establecer la respuesta 200 OK del método GET /pets/{petId}, realice lo siguiente, especificando el recurso /pets/{petId} mediante su 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
```
Tras configurar una interfaz de cliente sencilla para la API, puede continuar y configurar la integración de los métodos de la API con el backend.

Llame al comando put-integration para configurar una Integration con un punto de enlace HTTP especificado para el método GET /pets. El recurso /pets se identifica mediante su 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

A continuación se muestra la salida de este 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": []
}

Tenga en cuenta que el uri de integración de http://petstore-demo-endpoint.execute-api.com/petstore/pets especifica el punto de enlace de integración del método GET /pets.

De forma similar, se crea una solicitud de integración para el método GET /pets/{petId} del siguiente modo:


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

Aquí, el punto de enlace de integración, uri de http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}, también utiliza un parámetro de ruta (id). Su valor se asigna a partir del parámetro de ruta de solicitud de método correspondiente de {petId}. La asignación se define como parte de request-parameters. Si esta asignación no se define aquí, el cliente recibe una respuesta de error al intentar llamar al método.

A continuación se muestra la salida de este 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": []
}

Llame al comando put-integration-response para crear una entidad IntegrationResponse del método GET /pets integrada con 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
```
A continuación se muestra la salida de este comando:
```
{
    "statusCode": "200",
    "selectionPattern": "" 
}
```
Del forma similar, llame al siguiente comando put-integration-response para crear una IntegrationResponse del 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
```
Con los pasos anteriores, ha terminado la configuración de una API sencilla que permite a sus clientes consultar las mascotas disponibles en el sitio web de PetStore y ver una mascota concreta con un identificador especificado. Para que el cliente pueda llamar a la API, debe implementarla.

Implemente la API en una etapa stage llamando, por ejemplo, a create-deployment:


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

A continuación se muestra la salida de este comando:


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

Puede probar esta API escribiendo la URL https://vaz7da96z6.execute-api.us-west-2.amazonaws.com/test/pets en un navegador y sustituyendo vaz7da96z6 por el identificador de la API. La salida esperada debe ser la siguiente:


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

Para probar el método GET /pets/{petId}, escriba https://vaz7da96z6.execute-api.us-west-2.amazonaws.com/test/pets/3 en el navegador. Debería recibir la siguiente respuesta:


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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Configuración de una API con la consola de API Gateway

Configurar una API optimizada para bordes con el SDK de AWS para Node.js