Tutorial: crea una calcolatrice REST API con due integrazioni di AWS servizi e un'integrazione non proxy Lambda - Amazon API Gateway
Creazione di un ruolo IAM assumibileCreazione di una funzione Lambda CalcTest della funzione Lambda CalcCrea un Calc APIIntegrazione 1: creazione di un metodo GET con parametri di query per chiamare la funzione LambdaIntegrazione 2: creazione di un POST metodo con un JSON payload per chiamare la funzione LambdaIntegrazione 3: creazione di un metodo GET con parametri di percorso per chiamare la funzione Lambda

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Tutorial: crea una calcolatrice REST API con due integrazioni di AWS servizi e un'integrazione non proxy Lambda

Tutorial: Creare un'integrazione non proxy REST API con LambdaUtilizza esclusivamente Lambda Function l'integrazione. Lambda Functionl'integrazione è un caso speciale del tipo di AWS Service integrazione che esegue al posto tuo gran parte della configurazione dell'integrazione, ad esempio l'aggiunta automatica delle autorizzazioni basate sulle risorse richieste per richiamare la funzione Lambda. In questo caso, due integrazioni su tre utilizzano l'integrazione AWS Service. In questo tipo di integrazione, hai un maggiore controllo, ma dovrai eseguire manualmente attività come creare e specificare un ruolo contenente le autorizzazioni appropriate. IAM

In questo tutorial, creerai una funzione Calc Lambda che implementa operazioni aritmetiche di base, accettando e restituendo input e output formattati. JSON Quindi creerai una funzione REST API e la integrerai con la funzione Lambda nei seguenti modi:

  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, potresti voler studiare il file di API definizione aperto per CalcAPI, che puoi importare in API Gateway seguendo le istruzioni riportate inSviluppa REST APIs utilizzando Open API in API Gateway.

Argomenti

Creazione di un ruolo IAM assumibile

Per poter API richiamare la funzione Calc Lambda, è necessario disporre di un ruolo Gateway IAM assumibile, ovvero API IAM un ruolo con la seguente relazione di fiducia:

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

Il ruolo che crei dovrà avere l'autorizzazione Lambda InvokeFunction. In caso contrario, il API chiamante riceverà una 500 Internal Server Error risposta. Per concedere al ruolo questa autorizzazione, allegherai la seguente IAM politica:

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

Ecco come procedere:

Crea un ruolo assumibile in API IAM Gateway

  1. Accedi alla console di 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 JSONscheda, sostituisci la politica 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 del ruolo ARN per il ruolo che hai 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. Per tutte le altre opzioni, usa l'impostazione predefinita.

  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. Inserisci il ruolo ARN per il lambda_invoke_function_assume_apigw_role ruolo che hai 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 JSON oggetto del seguente formato: 


{
  "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 seguente JSON formato: 


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

Dovresti testare la funzione nella console Lambda prima di integrarla con la API nel passaggio successivo.

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
}

Crea un Calc API

La procedura seguente mostra come creare una API per la funzione Calc Lambda 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 è la prima volta che utilizzi API Gateway, viene visualizzata una pagina che presenta le funzionalità del servizio. In RESTAPI, scegli Costruisci. Quando viene visualizzato il API popup Crea esempio, scegli OK.

    Se non è la prima volta che usi API Gateway, scegli Crea API. In RESTAPI, scegli Build.

  3. Per APInome, inserisciLambdaCalc.

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

  5. Mantieni il tipo di API endpoint impostato su Regionale.

  6. Scegli Crea API.

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

Creando un GET metodo che passa i parametri della stringa di query alla funzione Lambda, si abilita la API loro invocazione da un browser. Questo approccio può essere utile, soprattutto perché consente APIs l'accesso aperto.

Dopo aver creato unAPI, crei una risorsa. In genere, API le risorse sono organizzate in un albero 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 GET metodo che passa i parametri della stringa di query alla funzione Lambda, si abilita la API loro invocazione da un browser. Questo approccio può essere utile, soprattutto perché consente APIs l'accesso aperto.

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

Creazione di un metodo GET

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

  2. In Tipo di metodo, seleziona GET.

  3. Per Tipo di integrazione seleziona Servizio AWS.

  4. Per Regione AWS, seleziona il Regione AWS luogo in cui hai creato la tua funzione Lambda.

  5. Per Servizio AWS seleziona Lambda.

  6. Lascia vuoto Sottodominio AWS .

  7. Per HTTPmetodo, seleziona POST.

  8. In Tipo di operazione scegli Utilizza sostituzione percorso. Questa opzione ci consente ARN di specificare l'azione Invoke per eseguire la nostra Calc funzione.

  9. Per Sostituzione percorso immetti 2015-03-31/functions/arn:aws:lambda:us-east-2:account-id:function:Calc/invocations. Per account-id, inserisci il tuo Account AWS ID. Perus-east-2, inserisci Regione AWS dove hai creato la tua funzione Lambda.

  10. Per Ruolo di esecuzione, inserisci il ruolo ARN perlambda_invoke_function_assume_apigw_role.

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

  12. Scegliete le impostazioni di 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 i parametri URL della stringa di query.

    Ora impostate i parametri della stringa di query per il GETmetodo sulla risorsa /calc in modo che possa ricevere input per conto della funzione Lambda di backend.

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

    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 nella richiesta del metodo nei valori delle proprietà designati dell'JSONoggetto come input per la funzione Lambda di backend. L'JSONoggetto trasformato verrà incluso come payload della 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:

    Creare un API in API Gateway come proxy Lambda

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

Creando un POST metodo con un JSON payload per chiamare la funzione Lambda, si fa in modo che il client debba fornire l'input necessario alla funzione di backend 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 POST metodo con un payload JSON

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

  2. In Tipo di metodo, seleziona POST.

  3. Per Tipo di integrazione seleziona Servizio AWS.

  4. Per Regione AWS, seleziona il Regione AWS luogo in cui hai creato la tua funzione Lambda.

  5. Per Servizio AWS seleziona Lambda.

  6. Lascia vuoto Sottodominio AWS .

  7. Per HTTPmetodo, seleziona POST.

  8. In Tipo di operazione scegli Utilizza sostituzione percorso. Questa opzione ci consente ARN di specificare l'azione Invoke per eseguire la nostra Calc funzione.

  9. Per Sostituzione percorso immetti 2015-03-31/functions/arn:aws:lambda:us-east-2:account-id:function:Calc/invocations. Per account-id, inserisci il tuo Account AWS ID. Perus-east-2, inserisci Regione AWS dove hai creato la tua funzione Lambda.

  10. Per Ruolo di esecuzione, inserisci il ruolo ARN perlambda_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 sia agli schemi di input che di output definiti nel tuoAPI.

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 lo schema del modello, inserisci il seguente modello con il tuo restapi-id. Tuo restapi-id è elencato 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.

Ora configuri la richiesta del POST metodo per abilitare la convalida della richiesta nel corpo della richiesta in entrata.

Per abilitare la convalida della richiesta sul 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 Request body, inserisci il seguente JSON payload.

    
{
    "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 API delle risorse risultante sarà simile alla seguente:

Creare un API in API Gateway come 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. Keep 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 utilizzerai l'integrazione Lambda integrata nella console API Gateway 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. In Tipo di metodo, seleziona GET.

  3. In Tipo di integrazione, seleziona Lambda.

  4. Mantieni l'opzione Integrazione proxy Lambda disattivata.

  5. Per la funzione Lambda, seleziona il Regione AWS luogo in cui hai creato la funzione Lambda e inserisci. Calc

  6. Mantieni attivata l'opzione Timeout predefinito.

  7. Scegli Crea metodo.

Ora crei un modello di mappatura per mappare i tre parametri del URL percorso, dichiarati quando è stata creata la risorsa /calc/ {operand1}/{operand2}/{operator}, nei valori di proprietà designati nell'oggetto. JSON Poiché URL i percorsi devono essere URL codificati, l'operatore di divisione deve essere specificato come anziché. %2F / 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:

    Prova il GET metodo nella console API Gateway.

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 si genera un file SDK per uno dei linguaggi di tipo forte, ad esempio Java o Objective-C, SDK gli utenti riceveranno come risultato un oggetto vuoto. Per garantire che sia il REST client che i SDK client ricevano il risultato desiderato, è necessario modellare i dati di 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 garantisce che i dati di risposta vengano inseriti nell'resultoggetto di un determinato SDK metodo. 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, è possibile chiamarli solo API utilizzando la funzione Test nella console API Gateway. Per renderla disponibile ai clienti, dovrai implementare il tuoAPI. Assicurati sempre di ridistribuire il tuo API ogni volta che aggiungi, modifichi o elimini una risorsa o un metodo, aggiorni una mappatura dei dati o aggiorni le impostazioni della fase. In caso contrario, le nuove funzionalità o gli aggiornamenti non saranno disponibili per i clienti diAPI... come segue:

Per distribuire API

  1. Scegliere Deploy (Implementa)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) Nella sezione Dettagli dello stage, per Invoke URL, puoi scegliere l'icona di copia per copiare API la tua chiamataURL. Puoi usarla con strumenti come Postman e c URL per testare il tuo. API

Nota

Ridistribuisci sempre il tuo API ogni volta che aggiungi, modifichi o elimini una risorsa o un metodo, aggiorni una mappatura dei dati o aggiorni le impostazioni dello stage. In caso contrario, le nuove funzionalità o gli aggiornamenti non saranno disponibili per i tuoi clienti. API