Tutorial: creazione di una REST API di calcolo con due integrazioni del servizio AWS e un'integrazione non proxy Lambda - Amazon API Gateway
Creazione di un ruolo IAM prevedibileCreazione di una funzione Lambda CalcTest della funzione Lambda CalcCreazione di un'API CalcIntegrazione 1: creazione di un metodo GET con parametri di query per chiamare la funzione LambdaIntegrazione 2: creazione di un metodo POST con un payload JSON per chiamare la funzione LambdaIntegrazione 3: creazione di un metodo GET con parametri di percorso per chiamare la funzione Lambda

Tutorial: creazione di una REST API di calcolo con due integrazioni del servizio AWS e un'integrazione non proxy Lambda

Tutorial: creazione di una REST API con un'integrazione non proxy Lambda utilizza esclusivamente l'integrazione Lambda Function. L'integrazione Lambda Function è un caso speciale del tipo di integrazione AWS Service in cui gran parte delle operazioni di configurazione dell'integrazione vengono eseguite automaticamente, ad esempio l'aggiunta automatica delle autorizzazioni basate su risorse necessarie per invocare la funzione Lambda. In questo caso, due integrazioni su tre utilizzano l'integrazione AWS Service. Questo tipo di integrazione offre un controllo maggiore, ma richiede l'esecuzione manuale di attività come la creazione e la definizione di un ruolo IAM contenente le autorizzazioni appropriate.

In questo tutorial verrà creata una funzione Lambda Calc che implementa operazioni aritmetiche di base, accettando e restituendo input e output in formato JSON. Verrà quindi creata un'API REST, che verrà integrata con la funzione Lambda nei modi seguenti:

  1. Esponendo un metodo GET nella risorsa /calc per richiamare la funzione Lambda, fornendo l'input sotto forma di parametri delle stringhe di query (integrazione AWS Service).

  2. Esponendo un metodo POST nella risorsa /calc per richiamare la funzione Lambda, fornendo l'input nel payload della richiesta del metodo (integrazione AWS Service).

  3. Esponendo un metodo GET nelle risorse /calc/{operand1}/{operand2}/{operator} nidificate per richiamare la funzione Lambda, fornendo l'input sotto forma di parametri di percorso (integrazione Lambda Function).

Oltre a provare questo tutorial, puoi esaminare il file di definizione OpenAPI per l'API Calc, che è possibile importare in API Gateway seguendo le istruzioni in Sviluppo di REST API utilizzando OpenAPI in Gateway API.

Argomenti

Creazione di un ruolo IAM prevedibile

Affinché l'API possa richiamare la funzione Lambda Calc, è necessario un ruolo IAM API Gateway prevedibile, ovvero un ruolo IAM con la relazione di trust seguente:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "apigateway.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

Il ruolo creato deve disporre dell'autorizzazione InvokeFunction di Lambda. In caso contrario, il chiamante dell'API riceverà una risposta 500 Internal Server Error. Per assegnare al ruolo questa autorizzazione, è necessario collegare al ruolo la policy IAM seguente:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "lambda:InvokeFunction",
            "Resource": "*"
        }
    ]
}

Ecco come procedere:

Creazione di un ruolo IAM API Gateway prevedibile

  1. Accedi alla console IAM.

  2. Scegliere Roles (Ruoli).

  3. Seleziona Create Role (Crea ruolo).

  4. In Select type of trusted entity (Seleziona tipo di entità attendibile), scegli AWS Service.

  5. In Choose the service that will use this role (Scegli il servizio che utilizzerà questo ruolo), seleziona Lambda.

  6. Scegli Next: Permissions (Successivo: Autorizzazioni).

  7. Selezionare Create Policy (Crea policy).

    Si aprirà una nuova finestra Create Policy (Crea policy) della console. Nella finestra procedi nel seguente modo:

    1. Nella scheda JSON, sostituisci la policy esistente con la seguente:

      
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "lambda:InvokeFunction",
            "Resource": "*"
        }
    ]
}

    2. Scegliere Review policy (Esamina policy).

    3. InReview Policy (Rivedi policy), effettua le operazioni seguenti:

      1. In Name (Nome), digita un nome, ad esempio lambda_execute.

      2. Selezionare Create Policy (Crea policy).

  8. Nella finestra Create Role (Crea ruolo) originaria della console, procedi nel seguente modo:

    1. In Attach permissions policies (Collega policy delle autorizzazioni), scegli la tua policy lambda_execute dall'elenco a discesa.

      Se la policy non è visualizzata nell'elenco, scegliere il pulsante di aggiornamento in alto. Non aggiornare la pagina del browser.

    2. Scegliere Next: Tags (Successivo: Tag).

    3. Scegli Next:Review (Successivo:Rivedi).

    4. Per Role name (Nome ruolo), digita un nome, ad esempio lambda_invoke_function_assume_apigw_role.

    5. Seleziona Create role (Crea ruolo).

  9. Seleziona il tuo lambda_invoke_function_assume_apigw_role nell'elenco dei ruoli.

  10. Seleziona la scheda Trust relationships (Relazioni di trust).

  11. Seleziona Edit trust relationship (Modifica relazione di trust).

  12. Sostituisci la policy esistente con la seguente:

    
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "lambda.amazonaws.com",
          "apigateway.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

  13. Selezionare Update Trust Policy (Aggiorna policy di trust).

  14. Prendi nota dell'ARN per il ruolo appena creato. Sarà necessario in seguito.

Creazione di una funzione Lambda Calc

Verrà quindi creata una funzione Lambda utilizzando la console Lambda.

  1. Nella console Lambda, scegliere Create function (Crea funzione).

  2. Scegli Author from Scratch (Crea da zero).

  3. In Name (Nome), immettere Calc.

  4. Per Runtime, scegli l'ultimo runtime supportato di Node.js o di Python.

  5. Utilizza le impostazioni predefinite per tutte le altre opzioni.

  6. Scegli Crea funzione.

  7. Copia la seguente funzione Lambda e incollala nel runtime preferito e nell'editor di codice nella console Lambda.

    Node.js
    export const handler = async function (event, context) {
  console.log("Received event:", JSON.stringify(event));

  if (
    event.a === undefined ||
    event.b === undefined ||
    event.op === undefined
  ) {
    return "400 Invalid Input";
  }

  const res = {};
  res.a = Number(event.a);
  res.b = Number(event.b);
  res.op = event.op;
  if (isNaN(event.a) || isNaN(event.b)) {
    return "400 Invalid Operand";
  }
  switch (event.op) {
    case "+":
    case "add":
      res.c = res.a + res.b;
      break;
    case "-":
    case "sub":
      res.c = res.a - res.b;
      break;
    case "*":
    case "mul":
      res.c = res.a * res.b;
      break;
    case "/":
    case "div":
      if (res.b == 0) {
        return "400 Divide by Zero";
      } else {
        res.c = res.a / res.b;
      }
      break;
    default:
      return "400 Invalid Operator";
  }

  return res;
};
    Python
    import json


def lambda_handler(event, context):
    print(event)

    try:
        (event['a']) and (event['b']) and (event['op'])
    except KeyError:
        return '400 Invalid Input'

    try:
        res = {
            "a": float(
                event['a']), "b": float(
                event['b']), "op": event['op']}
    except ValueError:
        return '400 Invalid Operand'

    if event['op'] == '+':
        res['c'] = res['a'] + res['b']
    elif event['op'] == '-':
        res['c'] = res['a'] - res['b']
    elif event['op'] == '*':
        res['c'] = res['a'] * res['b']
    elif event['op'] == '/':
        if res['b'] == 0:
            return '400 Divide by Zero'
        else:
            res['c'] = res['a'] / res['b']
    else:
        return '400 Invalid Operator'

    return res

  8. In Execution role (Ruolo di esecuzione) scegliere Choose an existing role (Scegli un ruolo esistente).

  9. Immettere l'ARN per il ruolo lambda_invoke_function_assume_apigw_role creato in precedenza.

  10. Selezionare Deploy (Distribuisci).

Questa funzione richiede due operandi (a e b) e un operatore (op) del parametro di input event. L'input è un oggetto JSON con il formato seguente: 


{
  "a": "Number" | "String",
  "b": "Number" | "String",
  "op": "String"
}

Questa funzione restituisce il risultato calcolato (c) e l'input. Per un input non valido, la funzione restituisce il valore null o la stringa "Invalid op" come risultato. L'output ha il formato JSON seguente: 


{
  "a": "Number",
  "b": "Number",
  "op": "String",
  "c": "Number" | "String"
}

Prima dell'integrazione con l'API nella fase successiva, è necessario testare la funzione nella console Lambda.

Test della funzione Lambda Calc

Di seguito viene descritto come testare la funzione Calc nella console Lambda:

  1. Seleziona la scheda Test.

  2. Come nome dell'evento di test, immettere calc2plus5.

  3. Sostituire la definizione dell'evento di test con quanto segue:

    {
  "a": "2",
  "b": "5",
  "op": "+"
}

  4. Scegli Save (Salva).

  5. Scegli Test (Esegui test).

  6. Espandere Execution result: succeeded (Risultato esecuzione: riuscita). Verrà visualizzato un codice analogo al seguente:

    {
  "a": 2,
  "b": 5,
  "op": "+",
  "c": 7
}

Creazione di un'API Calc

Nella procedura seguente viene illustrato come creare un'API per la funzione Lambda Calc appena creata. Nelle sezioni successive verranno aggiunti metodi e risorse.

Per creare un API

  1. Accedere alla console API Gateway all'indirizzo https://console.aws.amazon.com/apigateway.

  2. Se si utilizza API Gateway per la prima volta, verrà visualizzata una pagina che presenta le caratteristiche del servizio. In API REST, scegliere Crea. Quando appare il popup Create Example API (Crea API di esempio), scegliere OK.

    Se non è la prima volta che si utilizza API Gateway, scegliere Create API (Crea API). In API REST, scegliere Crea.

  3. Per API name (Nome API), immettere LambdaCalc.

  4. (Facoltativo) In Description (Descrizione), immettere una descrizione.

  5. Lasciare l'opzione Tipo di endpoint API impostata su Regionale.

  6. Seleziona Create API (Crea API).

Integrazione 1: creazione di un metodo GET con parametri di query per chiamare la funzione Lambda

Creando un metodo GET che passa i parametri delle stringhe di query alla funzione Lambda, si permette all'API di essere richiamata da un browser. Questo approccio può essere utile, soprattutto per le API che permettono l'accesso aperto.

Dopo l'API, è necessario creare una risorsa. In genere, le risorse API sono organizzate in una struttura di risorse in base alla logica dell'applicazione. In questa fase crei una risorsa /calc.

Per creare una risorsa /calc

  1. Scegli Crea risorsa.

  2. Mantieni l'opzione Risorsa proxy disattivata.

  3. Mantieni Percorso risorsa impostato su /.

  4. Per Resource Name (Nome risorsa) immetti calc.

  5. Mantieni CORS (Cross Origin Resource Sharing) disattivato.

  6. Scegli Crea risorsa.

Creando un metodo GET che passa i parametri delle stringhe di query alla funzione Lambda, si permette all'API di essere richiamata da un browser. Questo approccio può essere utile, soprattutto per le API che permettono l'accesso aperto.

Con questo metodo, Lambda richiede che venga usata la richiesta POST per richiamare qualsiasi funzione Lambda. Questo esempio mostra che il metodo HTTP in una richiesta del metodo di front-end può essere diverso dalla richiesta di integrazione nel back-end.

Creazione di un metodo GET

  1. Seleziona la risorsa /calc quindi scegli Crea metodo.

  2. Per Tipo di metodo seleziona GET.

  3. Per Tipo di integrazione seleziona Servizio AWS.

  4. Per Regione AWS seleziona la Regione AWS in cui hai creato la funzione Lambda.

  5. Per Servizio AWS seleziona Lambda.

  6. Lascia vuoto Sottodominio AWS.

  7. Per Metodo HTTP seleziona POST.

  8. In Tipo di operazione scegli Utilizza sostituzione percorso. Questa opzione permette di specificare l'ARN dell'operazione Invoke (Richiama) per eseguire la funzione Calc.

  9. Per Sostituzione percorso immetti 2015-03-31/functions/arn:aws:lambda:us-east-2:account-id:function:Calc/invocations. Per account-id immetti l'ID del tuo Account AWS. Per us-east-2 immetti la Regione AWS in cui hai creato la funzione Lambda.

  10. Per Ruolo di esecuzione immetti l'ARN del ruolo per lambda_invoke_function_assume_apigw_role.

  11. Non modificare le impostazioni di Cache delle credenziali e Timeout predefinito.

  12. Scegli Impostazioni della richiesta del metodo.

  13. Per Validatore richiesta seleziona Convalida parametri di stringa query e intestazioni.

    Questa impostazione restituisce un messaggio di errore se il client non specifica i parametri obbligatori.

  14. Scegli Parametri della stringa di query URL.

    A questo punto si configurano i parametri della stringa di query per il metodo GET sulla risorsa /calc in modo da poter ricevere l'input per conto della funzione Lambda di backend.

    Per creare i parametri della stringa di query, procedi come indicato di seguito:

    1. Scegliere Add query string (Aggiungi stringa di query).

    2. Per Nome, immetti operand1.

    3. Attiva Campo obbligatorio.

    4. Mantieni disattivata l'opzione Caching.

    Ripeti le stesse fasi e crea una stringa di query denominata operand2 e una stringa di query denominata operator.

  15. Scegli Crea metodo.

A questo punto crea un modello di mappatura per tradurre le stringhe di query fornite dal client in payload di richiesta di integrazione, come richiesto dalla funzione Calc. Questo modello mappa i tre parametri della stringa di query dichiarati in Richiesta metodo in valori di proprietà designati dell'oggetto JSON come input per la funzione Lambda di back-end. L'oggetto JSON trasformato verrà incluso come payload di richiesta di integrazione.

Per mappare i parametri di input alla richiesta di integrazione

  1. Nella scheda Richiesta di integrazione scegli Modifica in Impostazioni della richiesta di integrazione.

  2. Per Richiesta corpo passthrough scegli Quando non ci sono modelli definiti (consigliato).

  3. Scegli Modelli di mappatura.

  4. Scegliere Add mapping template (Aggiungi modello di mappatura).

  5. Per Tipo di contenuto inserisci application/json.

  6. Per Corpo del modello inserisci il seguente codice:

    {
    "a":  "$input.params('operand1')",
    "b":  "$input.params('operand2')", 
    "op": "$input.params('operator')"   
}

  7. Seleziona Salva.

È ora possibile testare il metodo GET per verificare che sia stato configurato correttamente per richiamare la funzione Lambda.

Test del metodo GET

  1. Seleziona la scheda Test. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.

  2. In Stringhe di query immetti operand1=2&operand2=3&operator=+.

  3. Scegli Test (Esegui test).

    I risultati dovrebbero essere simili a quanto segue:

    Creazione di un'API in API Gateway come un proxy Lambda

Integrazione 2: creazione di un metodo POST con un payload JSON per chiamare la funzione Lambda

Se si crea un metodo POST con un payload JSON per chiamare la funzione Lambda, si richiede al client di fornire l'input necessario alla funzione di back-end nel corpo della richiesta. Per garantire che il client carichi i dati di input corretti, verrà abilitata la convalida delle richieste nel payload.

Per creare un metodo POST con un payload JSON

  1. Seleziona la risorsa /calc quindi scegli Crea metodo.

  2. Per Tipo di metodo seleziona POST.

  3. Per Tipo di integrazione seleziona Servizio AWS.

  4. Per Regione AWS seleziona la Regione AWS in cui hai creato la funzione Lambda.

  5. Per Servizio AWS seleziona Lambda.

  6. Lascia vuoto Sottodominio AWS.

  7. Per Metodo HTTP seleziona POST.

  8. In Tipo di operazione scegli Utilizza sostituzione percorso. Questa opzione permette di specificare l'ARN dell'operazione Invoke (Richiama) per eseguire la funzione Calc.

  9. Per Sostituzione percorso immetti 2015-03-31/functions/arn:aws:lambda:us-east-2:account-id:function:Calc/invocations. Per account-id immetti l'ID del tuo Account AWS. Per us-east-2 immetti la Regione AWS in cui hai creato la funzione Lambda.

  10. Per Ruolo di esecuzione immetti l'ARN del ruolo per lambda_invoke_function_assume_apigw_role.

  11. Non modificare le impostazioni di Cache delle credenziali e Timeout predefinito.

  12. Scegli Crea metodo.

A questo punto crea un modello di input per descrivere la struttura dei dati di input e convalidare il corpo della richiesta in ingresso.

Per creare un modello di input

  1. Nel riquadro di navigazione principale seleziona Modelli.

  2. Scegli Crea modello.

  3. Per Nome, immetti input.

  4. Per Tipo di contenuto inserisci application/json.

    Se non viene trovato alcun tipo di contenuto corrispondente, la convalida della richiesta non viene eseguita. Per utilizzare lo stesso modello indipendentemente dal tipo di contenuti, inserisci $default.

  5. Per Schema modello immetti il seguente modello:

    {
    "type":"object",
    "properties":{
        "a":{"type":"number"},
        "b":{"type":"number"},
        "op":{"type":"string"}
    },
    "title":"input"
}

  6. Scegli Crea modello.

A questo punto crea un modello di output. Questo modello descrive la struttura di dati dell'output calcolato del back-end. Può essere usato per mappare i dati della risposta di integrazione a un modello diverso. Questo tutorial è basato sul comportamento di passthrough e non usa questo modello.

Per creare un modello di output

  1. Scegli Crea modello.

  2. Per Nome, immetti output.

  3. Per Tipo di contenuto inserisci application/json.

    Se non viene trovato alcun tipo di contenuto corrispondente, la convalida della richiesta non viene eseguita. Per utilizzare lo stesso modello indipendentemente dal tipo di contenuti, inserisci $default.

  4. Per Schema modello immetti il seguente modello:

    {
    "type":"object",
    "properties":{
        "c":{"type":"number"}
    },
    "title":"output"
}

  5. Scegli Crea modello.

A questo punto crea un modello di risultato. Questo modello descrive la struttura dei dati della risposta restituiti. Fa riferimento agli schemi di input e output definiti nell'API.

Per creare un modello di risultato

  1. Scegli Crea modello.

  2. Per Nome, immetti result.

  3. Per Tipo di contenuto inserisci application/json.

    Se non viene trovato alcun tipo di contenuto corrispondente, la convalida della richiesta non viene eseguita. Per utilizzare lo stesso modello indipendentemente dal tipo di contenuti, inserisci $default.

  4. Per Schema modello immetti il seguente modello con il restapi-id. Il restapi-id è indicato tra parentesi nella parte superiore della console nel seguente flusso: API Gateway > APIs > LambdaCalc (abc123).

    {
    "type":"object",
    "properties":{
        "input":{
            "$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/input"
        },
        "output":{
            "$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/output"
        }
    },
    "title":"result"
}

  5. Scegli Crea modello.

A questo punto configura la richiesta del metodo POST per abilitare la convalida della richiesta nel corpo della richiesta in ingresso.

Abilitazione della convalida della richiesta del metodo POST

  1. Nel pannello di navigazione scegli Risorse, quindi seleziona il metodo POST nella struttura di risorse.

  2. Nella scheda Richiesta metodo, in Impostazioni richiesta metodo, scegli Modifica.

  3. Per Validatore richiesta seleziona Convalida corpo.

  4. Scegli Corpo della richiesta, quindi seleziona Aggiungi modello.

  5. Per Tipo di contenuto inserisci application/json.

    Se non viene trovato alcun tipo di contenuto corrispondente, la convalida della richiesta non viene eseguita. Per utilizzare lo stesso modello indipendentemente dal tipo di contenuti, inserisci $default.

  6. Per Modello seleziona input.

  7. Seleziona Salva.

È ora possibile testare il metodo POST per verificare che sia stato configurato correttamente per richiamare la funzione Lambda.

Test del metodo POST

  1. Seleziona la scheda Test. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.

  2. Per Corpo della richiesta immetti il payload JSON seguente.

    
{
    "a": 1,
    "b": 2,
    "op": "+"
}

  3. Scegli Test (Esegui test).

    Verrà visualizzato l'output seguente:

    
{
  "a": 1,
  "b": 2,
  "op": "+",
  "c": 3
}

Integrazione 3: creazione di un metodo GET con parametri di percorso per chiamare la funzione Lambda

Verrà ora creato un metodo GET in una risorsa specificata da una sequenza di parametri di percorso per chiamare la funzione Lambda di back-end. I valori dei parametri di percorso specificano i dati di input per la funzione Lambda. Verrà usato un modello di mappatura per mappare i valori dei parametri di percorso in ingresso al payload di richiesta di integrazione necessario.

La struttura della risorsa API risultante sarà la seguente:

Creazione di un'API in API Gateway come un proxy Lambda
Per creare una risorsa /{operand1}/{operand2}/{operator}

  1. Scegli Crea risorsa.

  2. Per Percorso risorsa seleziona /calc.

  3. Per Resource Name (Nome risorsa) immetti {operand1}.

  4. Mantieni CORS (Cross Origin Resource Sharing) disattivato.

  5. Scegli Crea risorsa.

  6. Per Percorso risorsa seleziona /calc/{operand1}/.

  7. Per Resource Name (Nome risorsa) immetti {operand2}.

  8. Mantieni CORS (Cross Origin Resource Sharing) disattivato.

  9. Scegli Crea risorsa.

  10. Per Percorso risorsa seleziona /calc/{operand1}/{operand2}/.

  11. Per Resource Name (Nome risorsa) immetti {operator}.

  12. Mantieni CORS (Cross Origin Resource Sharing) disattivato.

  13. Scegli Crea risorsa.

Questa volta verrà utilizzata l'integrazione Lambda predefinita nella console Gateway API per configurare l'integrazione del metodo.

Per configurare l'integrazione di un metodo

  1. Seleziona la risorsa /{operand1}/{operand2}/{operator}, quindi scegli Crea metodo.

  2. Per Tipo di metodo seleziona GET.

  3. In Tipo di integrazione, seleziona Lambda.

  4. Mantieni l'opzione Integrazione proxy Lambda disattivata.

  5. Per Funzione Lambda seleziona la Regione AWS in cui hai creato la funzione Lambda e immetti Calc.

  6. Mantieni attivata l'opzione Timeout predefinito.

  7. Scegli Crea metodo.

A questo punto crea il modello per mappare i tre parametri del percorso URL, dichiarati quando è stata creata la risorsa /calc/{operand1}/{operand2}/{operator}, ai valori di proprietà designati nell'oggetto JSON. Poiché i percorsi URL devono essere codificati in formato URL, l'operatore di divisione deve essere specificato come %2F invece di /. Questo modello traduce %2F in '/' prima di passarlo alla funzione Lambda.

Per creare un modello di mappatura

  1. Nella scheda Richiesta di integrazione scegli Modifica in Impostazioni della richiesta di integrazione.

  2. Per Richiesta corpo passthrough scegli Quando non ci sono modelli definiti (consigliato).

  3. Scegli Modelli di mappatura.

  4. Per Tipo di contenuto inserisci application/json.

  5. Per Corpo del modello inserisci il seguente codice:

    {
   "a": "$input.params('operand1')",
   "b": "$input.params('operand2')",
   "op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
}

  6. Seleziona Salva.

A questo punto testa il metodo GET per verificare che sia stato configurato correttamente per richiamare la funzione Lambda e passare l'output originale con la risposta di integrazione senza mappatura.

Test del metodo GET

  1. Seleziona la scheda Test. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.

  2. Per Percorso procedi come segue:

    1. Per operand1 immetti 1.

    2. Per operand2 immetti 1.

    3. Per operator immetti +.

  3. Scegli Test (Esegui test).

  4. Il risultato deve essere simile al seguente:

    Test del metodo GET nella console Gateway API.

A questo punto modella la struttura di dati del payload di risposta del metodo dopo lo schema result.

Per impostazione predefinita, al corpo della risposta del metodo viene assegnato un modello vuoto. Di conseguenza, il corpo della risposta di integrazione viene passato senza mappatura. Tuttavia, quando generi un SDK per uno dei linguaggi fortemente tipizzati, ad esempio Java o Objective-C, gli utenti dell'SDK riceveranno un oggetto vuoto come risultato. Affinché sia il client REST che i client SDK ricevano il risultato desiderato, è necessario modellare i dati della risposta utilizzando uno schema predefinito. Verrà illustrato come definire un modello per il corpo della risposta del metodo e creare un modello di mappatura per convertire il corpo della risposta di integrazione nel corpo della risposta del metodo.

Per creare una risposta del metodo

  1. Nella scheda Risposta metodo scegli Modifica in Risposta 200.

  2. In Corpo della risposta scegli Aggiungi modello.

  3. Per Tipo di contenuto inserisci application/json.

  4. Per Modello seleziona risultato.

  5. Seleziona Salva.

L'impostazione del modello per il corpo della risposta del metodo assicura che i dati della risposta verranno trasmessi nell'oggetto result di un determinato SDK. Per fare in modo che i dati della risposta di integrazione siano mappati di conseguenza, è necessario un modello di mappatura.

Per creare un modello di mappatura

  1. Nella scheda Risposta di integrazione scegli Modifica in Predefinito - Risposta.

  2. Scegli Modelli di mappatura.

  3. Per Tipo di contenuto inserisci application/json.

  4. Per Corpo del modello inserisci il seguente codice:

    #set($inputRoot = $input.path('$'))
{
  "input" : {
    "a" : $inputRoot.a,
    "b" : $inputRoot.b,
    "op" : "$inputRoot.op"
  },
  "output" : {
    "c" : $inputRoot.c
  }
}

  5. Seleziona Salva.

Per testare il modello di mappatura

  1. Seleziona la scheda Test. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.

  2. Per Percorso procedi come segue:

    1. Per operand1 immetti 1.

    2. Per operand2 immetti 2.

    3. Per operator immetti +.

  3. Scegli Test (Esegui test).

  4. Il risultato sarà simile al seguente:

    {
  "input": {
    "a": 1,
    "b": 2,
    "op": "+"
  },
  "output": {
    "c": 3
  }
}

A questo punto puoi chiamare l'API solo tramite la funzionalità Test nella console Gateway API. Per rendere l'API disponibile per i client, è necessario distribuirla. Assicurarsi sempre di ridistribuire l'API ogni volta che si aggiunge, si modifica o si elemina una risorsa o un metodo, si aggiorna una mappatura dei dati o si aggiornano le impostazioni della fase. In caso contrario, le nuove funzionalità o gli aggiornamenti non saranno disponibili per i client dell'API, come indicato di seguito:

Per distribuire l'API

  1. Seleziona Deploy API (Distribuisci API).

  2. In Fase, seleziona Nuova fase.

  3. In Stage name (Nome fase) immettere Prod.

  4. (Facoltativo) In Description (Descrizione), immettere una descrizione.

  5. Seleziona Deploy (Implementa).

  6. (Facoltativo) In Dettagli fase puoi scegliere l'icona Copia per copiare l'URL di richiamata dell'API in Richiama URL. È possibile usare questo valore con strumenti come Postman e cURL per testare l'API.

Nota

Implementa nuovamente l'API ogni volta che aggiungi, modifichi o elemini una risorsa o un metodo e aggiorni una mappatura dei dati oppure le impostazioni della fase. In caso contrario, le nuove caratteristiche o gli aggiornamenti non saranno disponibili per i client dell'API.