Tutorial: Creación de una API de REST mediante AWS SDK o la AWS CLI

Configuración de una API de PetStore optimizada para sistemas perimetrales con AWS SDK

1. Utilice el siguiente ejemplo para crear una entidad RestApi:

   JavaScript v3

   import {APIGatewayClient, CreateRestApiCommand} from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new CreateRestApiCommand({
       name: "Simple PetStore (JavaScript v3 SDK)",
       description: "Demo API created using the AWS SDK for JavaScript v3",
       version: "0.00.001",
       binaryMediaTypes: [
       '*']
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.error(Couldn't create API:\n", err)
   }
   })();

   Una llamada correcta devuelve el ID de API y el ID de recurso raíz de la API en un resultado como el siguiente:

   {
     id: 'abc1234',
     name: 'PetStore (JavaScript v3 SDK)',
     description: 'Demo API created using the AWS SDK for node.js',
     createdDate: 2017-09-05T19:32:35.000Z,
     version: '0.00.001',
     rootResourceId: 'efg567'
     binaryMediaTypes: [ '*' ] 
   }

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.create_rest_api(
           name='Simple PetStore (Python SDK)',
           description='Demo API created using the AWS SDK for Python',
           version='0.00.001',
           binaryMediaTypes=[
               '*'
           ]
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("Couldn't create REST API %s.", error)
       raise
   attribute=["id","name","description","createdDate","version","binaryMediaTypes","apiKeySource","endpointConfiguration","disableExecuteApiEndpoint","rootResourceId"]
   filtered_result ={key:result[key] for key in attribute}
   print(filtered_result)

   Una llamada correcta devuelve el ID de API y el ID de recurso raíz de la API en un resultado como el siguiente:

   {'id': 'abc1234', 'name': 'Simple PetStore (Python SDK)', 'description': 'Demo API created using the AWS SDK for Python', 'createdDate': datetime.datetime(2024, 4, 3, 14, 31, 39, tzinfo=tzlocal()), 'version': '0.00.001', 'binaryMediaTypes': ['*'], 'apiKeySource': 'HEADER', 'endpointConfiguration': {'types': ['EDGE']}, 'disableExecuteApiEndpoint': False, 'rootResourceId': 'efg567'}

   AWS CLI

   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": "abcd1234", 
       "name": "Simple PetStore (AWS CLI)", 
       "createdDate": "2022-12-15T08:07:04-08:00",
       "apiKeySource": "HEADER",
       "endpointConfiguration": {
           "types": [
               "EDGE"
           ]
       },
       "disableExecuteApiEndpoint": false,
       "rootResourceId": "efg567"
   }

   La API que ha creado tiene el ID de API abcd1234 y el ID de recurso raíz efg567. Se utilizan estos valores en la configuración de la API.

2. A continuación, se agrega un recurso secundario en la raíz, se especifica RootResourceId como valor de la propiedad parentId. Use el siguiente ejemplo para crear un recurso de /pets para la API:

   JavaScript v3

   import {APIGatewayClient,  CreateResourceCommand } from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new CreateResourceCommand({
       restApiId: 'abcd1234',
       parentId: 'efg567',
       pathPart: 'pets'
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.log("The '/pets' resource setup failed:\n", err)
   }
   })();

   Una llamada correcta devuelve información sobre el recurso en un resultado como el siguiente:

   {
       "path": "/pets", 
       "pathPart": "pets", 
       "id": "aaa111", 
       "parentId": "efg567'"
   }

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.create_resource(
           restApiId='abcd1234',
           parentId='efg567',
           pathPart='pets'
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("The '/pets' resource setup failed: %s.", error)
       raise
   attribute=["id","parentId", "pathPart", "path",]
   filtered_result ={key:result[key] for key in attribute}
   print(filtered_result)

   Una llamada correcta devuelve información sobre el recurso en un resultado como el siguiente:

   {'id': 'aaa111', 'parentId': 'efg567', 'pathPart': 'pets', 'path': '/pets'}

   AWS CLI

   aws apigateway create-resource --rest-api-id abcd1234 \
     --region us-west-2 \
     --parent-id efg567 \
     --path-part pets

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

   {
       "id": "aaa111", 
       "parentId": "efg567",
       "pathPart": "pets",
       "path": "/pets"
   }

   El recurso /pets que ha creado tiene un ID de recurso de aaa111. Se utiliza este valor en la configuración de la API.

3. A continuación, agregue un recurso secundario en el recurso de /pets. Este recurso, /{petId} tiene un parámetro de ruta para {petId}. Para hacer una parte de la ruta, un parámetro de la ruta, sitúelo entre llaves, { }. Use el siguiente ejemplo para crear un recurso de /pets/{petId} para la API:

   JavaScript v3

   import {APIGatewayClient,  CreateResourceCommand } from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new CreateResourceCommand({
       restApiId: 'abcd1234',
       parentId: 'aaa111',
       pathPart: '{petId}'
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.log("The '/pets/{petId}' resource setup failed:\n", err)
   }
   })();

   Una llamada correcta devuelve información sobre el recurso en un resultado como el siguiente:

   {
       "path": "/pets/{petId}", 
       "pathPart": "{petId}", 
       "id": "bbb222", 
       "parentId": "aaa111'"
   }

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.create_resource(
           restApiId='abcd1234',
           parentId='aaa111',
           pathPart='{petId}'
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("The '/pets/{petId}' resource setup failed: %s.", error)
       raise
   attribute=["id","parentId", "pathPart", "path",]
   filtered_result ={key:result[key] for key in attribute}
   print(filtered_result)

   Una llamada correcta devuelve información sobre el recurso en un resultado como el siguiente:

   {'id': 'bbb222', 'parentId': 'aaa111', 'pathPart': '{petId}', 'path': '/pets/{petId}'}

   AWS CLI

   aws apigateway create-resource --rest-api-id abcd1234 \
     --region us-west-2 \
     --parent-id aaa111 \
     --path-part '{petId}'

   Si se ejecuta correctamente, este comando devuelve la siguiente respuesta:

   {
       "id": "bbb222",
       "parentId": "aaa111",
       "path": "/pets/{petId}", 
       "pathPart": "{petId}"
   }

   El recurso /pets/{petId} que ha creado tiene un ID de recurso de bbb222. Se utiliza este valor en la configuración de la API.

4. En los dos pasos siguientes, se agregan métodos HTTP a los recursos. En este tutorial, se establecen los métodos para que tengan acceso abierto configurando el authorization-type para establecer 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 las API de REST en API Gateway.

   En el siguiente ejemplo, se agrega el método HTTP GET al recurso /pets:

   JavaScript v3

   import {APIGatewayClient,  PutMethodCommand } from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new PutMethodCommand({
       restApiId: 'abcd1234',
       resourceId: 'aaa111',
       httpMethod: 'GET',
       authorizationType: 'NONE'
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.log("The 'GET /pets' method setup failed:\n", err)
   }
   })();

   Una llamada correcta devuelve el resultado siguiente:

   {
       "apiKeyRequired": false, 
       "httpMethod": "GET", 
       "authorizationType": "NONE"
   }

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.put_method(
           restApiId='abcd1234',
           resourceId='aaa111',
           httpMethod='GET',
           authorizationType='NONE'
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("The 'GET /pets' method setup failed: %s", error)
       raise
   attribute=["httpMethod","authorizationType","apiKeyRequired"]
   filtered_result ={key:result[key] for key in attribute}
   print(filtered_result)

   Una llamada correcta devuelve el resultado siguiente:

   {'httpMethod': 'GET', 'authorizationType': 'NONE', 'apiKeyRequired': False}

   AWS CLI

   aws apigateway put-method --rest-api-id abcd1234 \
     --resource-id aaa111 \
     --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
   }

5. En el siguiente ejemplo, se agrega el método HTTP GET al recurso /pets/{petId} y se establece la propiedad requestParameters para pasar el valor petId proporcionado por el cliente al backend:

   JavaScript v3

   import {APIGatewayClient,  PutMethodCommand } from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new PutMethodCommand({
       restApiId: 'abcd1234',
       resourceId: 'bbb222',
       httpMethod: 'GET',
       authorizationType: 'NONE'
       requestParameters: {
           "method.request.path.petId" : true
       }
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.log("The 'GET /pets/{petId}' method setup failed:\n", err)
   }
   })();

   Una llamada correcta devuelve el resultado siguiente:

   {
       "apiKeyRequired": false, 
       "httpMethod": "GET", 
       "authorizationType": "NONE",
       "requestParameters": {
          "method.request.path.petId": true
       }
   }

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.put_method(
           restApiId='abcd1234',
           resourceId='bbb222',
           httpMethod='GET',
           authorizationType='NONE',
           requestParameters={
               "method.request.path.petId": True
           }
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("The 'GET /pets/{petId}' method setup failed: %s", error)
       raise
   attribute=["httpMethod","authorizationType","apiKeyRequired", "requestParameters" ]
   filtered_result ={key:result[key] for key in attribute}
   print(filtered_result)

   Una llamada correcta devuelve el resultado siguiente:

   {'httpMethod': 'GET', 'authorizationType': 'NONE', 'apiKeyRequired': False, 'requestParameters': {'method.request.path.petId': True}}

   AWS CLI

   aws apigateway put-method --rest-api-id abcd1234 \
     --resource-id bbb222 --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
       }
   }

6. Use el siguiente ejemplo para agregar la respuesta del método 200 OK para el método GET /pets:

   JavaScript v3

   import {APIGatewayClient,  PutMethodResponseCommand } from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new PutMethodResponseCommand({
       restApiId: 'abcd1234',
       resourceId: 'aaa111',
       httpMethod: 'GET',
       statusCode: '200'
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.log("Set up the 200 OK response for the 'GET /pets' method failed:\n", err)
   }
   })();

   Una llamada correcta devuelve el resultado siguiente:

   {
       "statusCode": "200"
   }

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.put_method_response(
           restApiId='abcd1234',
           resourceId='aaa111',
           httpMethod='GET',
           statusCode='200'
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("Set up the 200 OK response for the 'GET /pets' method failed %s.", error)
       raise
   attribute=["statusCode"]
   filtered_result ={key:result[key] for key in attribute}
   logger.info(filtered_result)

   Una llamada correcta devuelve el resultado siguiente:

   {'statusCode': '200'}

   AWS CLI

   aws apigateway put-method-response --rest-api-id abcd1234 \ 
     --resource-id aaa111 --http-method GET \
     --status-code 200  --region us-west-2

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

   {
       "statusCode": "200"
   }

7. Use el siguiente ejemplo para agregar la respuesta del método 200 OK para el método GET /pets/{petId}:

   JavaScript v3

   import {APIGatewayClient,  PutMethodResponseCommand } from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new PutMethodResponseCommand({
       restApiId: 'abcd1234',
       resourceId: 'bbb222',
       httpMethod: 'GET',
       statusCode: '200'
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.log("Set up the 200 OK response for the 'GET /pets/{petId}' method failed:\n", err)
   }
   })();

   Una llamada correcta devuelve el resultado siguiente:

   {
       "statusCode": "200"
   }

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.put_method_response(
           restApiId='abcd1234',
           resourceId='bbb222',
           httpMethod='GET',
           statusCode='200'
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("Set up the 200 OK response for the 'GET /pets/{petId}' method failed %s.", error)
       raise
   attribute=["statusCode"]
   filtered_result ={key:result[key] for key in attribute}
   logger.info(filtered_result)

   Una llamada correcta devuelve el resultado siguiente:

   {'statusCode': '200'}

   AWS CLI

   aws apigateway put-method-response --rest-api-id abcd1234 \ 
     --resource-id bbb222 --http-method GET \
     --status-code 200  --region us-west-2

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

   {
       "statusCode": "200"
   }

8. En el siguiente ejemplo se configura una integración para el método GET /pets con un punto de conexión HTTP. El punto de conexión HTTPS es http://petstore-demo-endpoint.execute-api.com/petstore/pets.

   JavaScript v3

   import {APIGatewayClient,  PutIntegrationCommand } from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new PutIntegrationCommand({
       restApiId: 'abcd1234',
       resourceId: 'aaa111',
       httpMethod: 'GET',
       type: 'HTTP',
       integrationHttpMethod: 'GET',
       uri: 'http://petstore-demo-endpoint.execute-api.com/petstore/pets'
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.log("Set up the integration of the 'GET /pets' method of the API failed:\n", err)
   }
   })();

   Una llamada correcta devuelve el resultado siguiente:

   {
       "httpMethod": "GET", 
       "passthroughBehavior": "WHEN_NO_MATCH", 
       "cacheKeyParameters": [], 
       "type": "HTTP", 
       "uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets", 
       "cacheNamespace": "ccc333"
   }

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.put_integration(
           restApiId='abcd1234',
           resourceId='aaa111',
           httpMethod='GET',
           type='HTTP',
           integrationHttpMethod='GET',
           uri='http://petstore-demo-endpoint.execute-api.com/petstore/pets'
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("Set up the integration of the 'GET /' method of the API failed %s.", error)
       raise
   attribute=["httpMethod","passthroughBehavior","cacheKeyParameters", "type", "uri", "cacheNamespace"]
   filtered_result ={key:result[key] for key in attribute}
   print(filtered_result)

   Una llamada correcta devuelve el resultado siguiente:

   {'httpMethod': 'GET', 'passthroughBehavior': 'WHEN_NO_MATCH', 'cacheKeyParameters': [], 'type': 'HTTP', 'uri': 'http://petstore-demo-endpoint.execute-api.com/petstore/pets', 'cacheNamespace': 'ccc333'}

   AWS CLI

   aws apigateway put-integration --rest-api-id abcd1234 \
     --resource-id aaa111 --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": []
   }

9. En el siguiente ejemplo se configura una integración para el método GET /pets/{petId} con un punto de conexión HTTP. El punto de conexión HTTPS es http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}. En este paso, se mapea el parámetro de ruta petId al parámetro de ruta del punto de conexión id.

   JavaScript v3

   import {APIGatewayClient,  PutIntegrationCommand } from "@aws-sdk/client-api-gateway";
   (async function (){
   const apig = new APIGatewayClient({region:"us-east-1"});
   const command = new PutIntegrationCommand({
       restApiId: 'abcd1234',
       resourceId: 'bbb222',
       httpMethod: 'GET',
       type: 'HTTP',
       integrationHttpMethod: 'GET',
       uri: 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}'
       requestParameters: {
           "integration.request.path.id": "method.request.path.petId"
        }
   });
   try {
       const results = await apig.send(command)
       console.log(results)
   } catch (err) {
       console.log("Set up the integration of the 'GET /pets/{petId}' method of the API failed:\n", err)
   }
   })();

   Una llamada correcta devuelve el resultado siguiente:

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

   Python

   import botocore
   import boto3
   import logging
   
   logger = logging.getLogger()
   apig = boto3.client('apigateway')
   
   try:
       result = apig.put_integration(
           restApiId='ieps9b05sf',
           resourceId='t8zeb4',
           httpMethod='GET',
           type='HTTP',
           integrationHttpMethod='GET',
           uri='http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}',
           requestParameters={
               "integration.request.path.id": "method.request.path.petId"
           }
       )
   except botocore.exceptions.ClientError as error:
       logger.exception("Set up the integration of the 'GET /pets/{petId}' method of the API failed %s.", error)
       raise
   attribute=["httpMethod","passthroughBehavior","cacheKeyParameters", "type", "uri", "cacheNamespace", "requestParameters"]
   filtered_result ={key:result[key] for key in attribute}
   print(filtered_result)

   Una llamada correcta devuelve el resultado siguiente:

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

   AWS CLI

   aws apigateway put-integration --rest-api-id abcd1234 \
     --resource-id bbb222 --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

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

10. El siguiente ejemplo agrega la respuesta de integración para la integración de GET /pets:

    JavaScript v3

    import {APIGatewayClient,  PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway";
    (async function (){
    const apig = new APIGatewayClient({region:"us-east-1"});
    const command = new PutIntegrationResponseCommand({
        restApiId: 'abcd1234',
        resourceId: 'aaa111',
        httpMethod: 'GET',
        statusCode: '200',
        selectionPattern: ''
    });
    try {
        const results = await apig.send(command)
        console.log(results)
    } catch (err) {
        console.log("The 'GET /pets' method integration response setup failed:\n", err)
    }
    })();

    Una llamada correcta devuelve el resultado siguiente:

    {
        "selectionPattern": "", 
        "statusCode": "200"
    }

    Python

    import botocore
    import boto3
    import logging
    
    logger = logging.getLogger()
    apig = boto3.client('apigateway')
    
    try:
        result = apig.put_integration_response(
            restApiId='abcd1234',
            resourceId='aaa111',
            httpMethod='GET',
            statusCode='200',
            selectionPattern='',
        )
    except botocore.exceptions.ClientError as error:
        logger.exception("Set up the integration response of the 'GET /pets' method of the API failed: %s", error)
        raise
    attribute=["selectionPattern","statusCode"]
    filtered_result ={key:result[key] for key in attribute}
    print(filtered_result)

    Una llamada correcta devuelve el resultado siguiente:

    {'selectionPattern': "", 'statusCode': '200'}

    AWS CLI

    aws apigateway put-integration-response --rest-api-id abcd1234 \
      --resource-id aaa111 --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": "" 
    }

11. El siguiente ejemplo agrega la respuesta de integración para la integración de GET /pets/{petId}:

    JavaScript v3

    import {APIGatewayClient,  PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway";
    (async function (){
    const apig = new APIGatewayClient({region:"us-east-1"});
    const command = new PutIntegrationResponseCommand({
        restApiId: 'abcd1234',
        resourceId: 'bbb222',
        httpMethod: 'GET',
        statusCode: '200',
        selectionPattern: ''
    });
    try {
        const results = await apig.send(command)
        console.log(results)
    } catch (err) {
        console.log("The 'GET /pets/{petId}' method integration response setup failed:\n", err)
    }
    })();

    Una llamada correcta devuelve el resultado siguiente:

    {
        "selectionPattern": "", 
        "statusCode": "200"
    }

    Python

    import botocore
    import boto3
    import logging
    
    logger = logging.getLogger()
    apig = boto3.client('apigateway')
    
    try:
        result = apig.put_integration_response(
            restApiId='abcd1234',
            resourceId='bbb222',
            httpMethod='GET',
            statusCode='200',
            selectionPattern='',
        )
    except botocore.exceptions.ClientError as error:
        logger.exception("Set up the integration response of the 'GET /pets/{petId}' method of the API failed: %s", error)
        raise
    attribute=["selectionPattern","statusCode"]
    filtered_result ={key:result[key] for key in attribute}
    print(filtered_result)

    Una llamada correcta devuelve el resultado siguiente:

    {'selectionPattern': "", 'statusCode': '200'}

    AWS CLI

    aws apigateway put-integration-response --rest-api-id abcd1234 \
      --resource-id bbb222 --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": "" 
    }

    Después de crear la respuesta de integración, la API puede consultar las mascotas disponibles en el sitio web de PetStore y ver una mascota concreta de un identificador especificado. Antes de que los clientes puedan llamar a la API, debe implementarla. Le recomendamos que antes de implementar la API, la pruebe.

12. En el siguiente ejemplo, se prueba el método GET /pets:

    JavaScript v3

    import {APIGatewayClient,  TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway";
    (async function (){
    const apig = new APIGatewayClient({region:"us-east-1"});
    const command = new TestInvokeMethodCommand({
        restApiId: 'abcd1234',
        resourceId: 'aaa111',
        httpMethod: 'GET',
        pathWithQueryString: '/',
    });
    try {
        const results = await apig.send(command)
        console.log(results)
    } catch (err) {
        console.log("The test on 'GET /pets' method failed:\n", err)
    }
    })();

    Python

    import botocore
    import boto3
    import logging
    
    logger = logging.getLogger()
    apig = boto3.client('apigateway')
    
    try:
        result = apig.test_invoke_method(
            restApiId='abcd1234',
            resourceId='aaa111',
            httpMethod='GET',
            pathWithQueryString='/',
        )
    except botocore.exceptions.ClientError as error:
        logger.exception("Test invoke method on 'GET /pets' failed: %s", error)
        raise
    print(result)

    AWS CLI

    aws apigateway test-invoke-method --rest-api-id abcd1234 /
      --resource-id aaa111 /
      --http-method GET /
      --path-with-query-string '/'

13. En el siguiente ejemplo, se prueba el método GET /pets/{petId} con un petId de 3:

    JavaScript v3

    import {APIGatewayClient,  TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway";
    (async function (){
    const apig = new APIGatewayClient({region:"us-east-1"});
    const command = new TestInvokeMethodCommand({
        restApiId: 'abcd1234',
        resourceId: 'bbb222',
        httpMethod: 'GET',
        pathWithQueryString: '/pets/3',
    });
    try {
        const results = await apig.send(command)
        console.log(results)
    } catch (err) {
        console.log("The test on 'GET /pets/{petId}' method failed:\n", err)
    }
    })();

    Python

    import botocore
    import boto3
    import logging
    
    logger = logging.getLogger()
    apig = boto3.client('apigateway')
    
    try:
        result = apig.test_invoke_method(
            restApiId='abcd1234',
            resourceId='bbb222',
            httpMethod='GET',
            pathWithQueryString='/pets/3',
        )
    except botocore.exceptions.ClientError as error:
        logger.exception("Test invoke method on 'GET /pets/{petId}' failed: %s", error)
        raise
    print(result)

    AWS CLI

    aws apigateway test-invoke-method --rest-api-id abcd1234 /
      --resource-id bbb222 /
      --http-method GET /
      --path-with-query-string '/pets/3'

    Una vez que haya probado con éxito la API, puede implementarla en una etapa.

14. En el siguiente ejemplo se implementa la API en una etapa denominada test. Cuando se implementa la API en una etapa, los intermediarios de la API pueden invocar la API.

    JavaScript v3

    import {APIGatewayClient,  CreateDeploymentCommand } from "@aws-sdk/client-api-gateway";
    (async function (){
    const apig = new APIGatewayClient({region:"us-east-1"});
    const command = new CreateDeploymentCommand({
        restApiId: 'abcd1234',
        stageName: 'test',
        stageDescription: 'test deployment'
    });
    try {
        const results = await apig.send(command)
        console.log("Deploying API succeeded\n", results)
    } catch (err) {
        console.log("Deploying API failed:\n", err)
    }
    })();

    Python

    import botocore
    import boto3
    import logging
    
    logger = logging.getLogger()
    apig = boto3.client('apigateway')
    
    try:
        result = apig.create_deployment(
            restApiId='ieps9b05sf',
            stageName='test',
            stageDescription='my test stage',
        )
    except botocore.exceptions.ClientError as error:
        logger.exception("Error deploying stage  %s.", error)
        raise
    print('Deploying API succeeded')
    print(result)

    AWS CLI

    aws apigateway create-deployment --rest-api-id abcd1234 \ 
      --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"
    }

    Los clientes ahora pueden llamar a la API. Puede probar esta API ingresando la URL https://abcd1234.execute-api.us-west-2.amazonaws.com/test/pets en un navegador y sustituyendo abcd1234 por el identificador de la API.