Tutorial: crea un'API REST utilizzando AWS SDKs o AWS CLI

Per configurare un'API ottimizzata per i bordi utilizzando PetStore AWS SDKs

1. Utilizza il seguente esempio per creare un'entità 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 chiamata riuscita restituisce l'ID API e l'ID risorsa root dell'API in un output simile al seguente:

   {
     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 chiamata riuscita restituisce l'ID API e l'ID risorsa root dell'API in un output simile al seguente:

   {'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

   L'output di questo comando è il seguente:

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

   L'API creata ha un ID API che corrisponde a abcd1234 e un ID risorsa root che corrisponde a efg567. Questi valori vengono utilizzati nella configurazione dell'API.

2. Quindi, viene aggiunta una risorsa figlio sotto la risorsa root e specificato il valore RootResourceId come valore della proprietà parentId. Usa l'esempio seguente per creare una /pets risorsa per la tua 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 chiamata riuscita restituisce informazioni sulla risorsa in un output simile al seguente:

   {
       "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 chiamata riuscita restituisce informazioni sulla risorsa in un output simile al seguente:

   {'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

   L'output di questo comando è il seguente:

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

   La risorsa /pets creata ha un ID risorsa che corrisponde a aaa111. Questo valore viene utilizzato nella configurazione dell'API.

3. Quindi, viene aggiunta una risorsa figlio sotto la risorsa /pets. Questa risorsa /{petId} ha un parametro di percorso per {petId}. Per fare di una parte di percorso un parametro di percorso, racchiudila tra parentesi graffe, { }. Usa l'esempio seguente per creare una /pets/{petId} risorsa per la tua 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 chiamata riuscita restituisce informazioni sulla risorsa in un output simile al seguente:

   {
       "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 chiamata riuscita restituisce informazioni sulla risorsa in un output simile al seguente:

   {'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}'

   L'output di questo comando è il seguente:

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

   La risorsa /pets/{petId} creata ha un ID risorsa che corrisponde a bbb222. Questo valore viene utilizzato nella configurazione dell'API.

4. Nei due passaggi seguenti, vengono aggiunti metodi HTTP alle risorse. In questo tutorial, vengono impostati i metodi per avere accesso aperto impostando authorization-type su NONE. Per consentire solo agli utenti autenticati di chiamare il metodo, puoi utilizzare i ruoli e le policy IAM, un'autorizzazione Lambda (nota in precedenza come autorizzazioni ad hoc) o un pool di utenti di Amazon Cognito. Per ulteriori informazioni, consulta Controllo e gestione degli accessi alle REST API in Gateway API.

   Utilizzate l'esempio seguente per aggiungere il metodo GET HTTP alla /pets risorsa:

   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)
   }
   })();

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {
       "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)

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {'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

   L'output di questo comando è il seguente:

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

5. Utilizzate l'esempio seguente per aggiungere il metodo GET HTTP sulla /pets/{petId} risorsa e impostare la requestParameters proprietà per passare il petId valore fornito dal client 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)
   }
   })();

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {
       "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)

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {'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

   L'output di questo comando è il seguente:

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

6. Utilizza l'esempio seguente per aggiungere la risposta del metodo 200 OK per il metodo 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)
   }
   })();

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {
       "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)

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {'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

   L'output di questo comando è il seguente:

   {
       "statusCode": "200"
   }

7. Utilizza l'esempio seguente per aggiungere la risposta del metodo 200 OK per il metodo 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)
   }
   })();

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {
       "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)

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {'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

   L'output di questo comando è il seguente:

   {
       "statusCode": "200"
   }

8. Utilizzate l'esempio seguente per configurare un'integrazione per il GET /pets metodo con un endpoint HTTP. L'endpoint HTTP è 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)
   }
   })();

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {
       "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)

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {'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

   L'output di questo comando è il seguente:

   {
       "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. Utilizzate l'esempio seguente per configurare un'integrazione per il GET /pets/{petId} metodo con un endpoint HTTP. L'endpoint HTTP è http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}. In questa fase viene mappato il parametro di percorso petId al parametro di percorso dell'endpoint di integrazione 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)
   }
   })();

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {
       "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)

   In caso di esito positivo, la chiamata restituisce il seguente output:

   {'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

   L'output di questo comando è il seguente:

   {
       "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. Utilizzate l'esempio seguente per aggiungere la risposta di integrazione per l'GET /petsintegrazione:

    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)
    }
    })();

    In caso di esito positivo, la chiamata restituisce il seguente output:

    {
        "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)

    In caso di esito positivo, la chiamata restituisce il seguente output:

    {'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

    L'output di questo comando è il seguente:

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

11. Usa l'esempio seguente per aggiungere la risposta di integrazione per l'GET /pets/{petId}integrazione:

    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)
    }
    })();

    In caso di esito positivo, la chiamata restituisce il seguente output:

    {
        "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)

    In caso di esito positivo, la chiamata restituisce il seguente output:

    {'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

    L'output di questo comando è il seguente:

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

    Dopo aver creato la risposta di integrazione, l'API può interrogare gli animali domestici disponibili sul PetStore sito Web e visualizzare un singolo animale domestico con un identificatore specificato. Affinché l'API possa essere chiamata dai clienti, devi implementarla. Ti consigliamo di testare l'API prima di implementarla.

12. Utilizzate l'esempio seguente per testare il GET /pets metodo:

    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. Utilizzate l'esempio seguente per testare il GET /pets/{petId} metodo con un punteggio petId di 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'

    Dopo aver testato l'API correttamente, puoi implementarla in una fase.

14. Utilizzate l'esempio seguente per distribuire l'API in una fase denominatatest. Quando implementi l'API in una fase, i chiamanti dell'API possono invocare l'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'

    L'output di questo comando è il seguente:

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

    L'API può ora essere chiamata dai clienti. Puoi testare l'API inserendo l'URL https://abcd1234.execute-api.us-west-2.amazonaws.com/test/pets in un browser e sostituendo abcd1234 con l'identificativo dell'API.