Tutorial: Creare un'integrazione non proxy REST API con Lambda

In questa procedura dettagliata, utilizziamo la console API Gateway per creare una console API che consenta a un client di richiamare le funzioni Lambda tramite l'integrazione non proxy Lambda (nota anche come integrazione personalizzata). Per ulteriori informazioni su AWS Lambda e sulle funzioni Lambda, consulta la Guida per gli sviluppatori di AWS Lambda.

Per facilitare l'apprendimento, abbiamo scelto una semplice funzione Lambda con una API configurazione minima per guidarti attraverso i passaggi della creazione di un API gateway API con l'integrazione personalizzata Lambda. Laddove necessario, descriveremo la logica. Per un esempio più dettagliato dell'integrazione personalizzata Lambda, consulta Tutorial: crea una calcolatrice REST API con due integrazioni di AWS servizi e un'integrazione non proxy Lambda.

Prima di creare ilAPI, configura il backend Lambda creando una funzione Lambda in, descritta di seguito. AWS Lambda

Creazione di una funzione Lambda per l'integrazione non proxy Lambda

Nota

La creazione di funzioni Lambda può comportare addebiti sul tuo AWS account.

In questa fase, viene creata una funzione Lambda "Hello, World!" per l'integrazione Lambda personalizzata. In tutta la procedura guidata la funzione è denominata GetStartedLambdaIntegration.

L'implementazione di questa funzione Lambda GetStartedLambdaIntegration è la seguente:

Node.js

'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];            
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];

console.log('Loading function');

export const handler = function(event, context, callback) {
  // Parse the input for the name, city, time and day property values
  let name = event.name === undefined ? 'you' : event.name;
  let city = event.city === undefined ? 'World' : event.city;
  let time = times.indexOf(event.time)<0 ? 'day' : event.time;
  let day = days.indexOf(event.day)<0 ? null : event.day;

  // Generate a greeting
  let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
  if (day) greeting += 'Happy ' + day + '!';
  
  // Log the greeting to CloudWatch
  console.log('Hello: ', greeting);
  
  // Return a greeting to the caller
  callback(null, {
      "greeting": greeting
  }); 
};

Python

import json

days = {
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}


def lambda_handler(event, context):
    print(event)
    # parse the input for the name, city, time, and day property values
    try:
        if event['name']:
            name = event['name']
    except KeyError:
        name = 'you'
    try:
        if event['city']:
            city = event['city']
    except KeyError:
        city = 'World'
    try:
        if event['time'] in times:
            time = event['time']
        else:
            time = 'day'
    except KeyError:
        time = 'day'
    try:
        if event['day'] in days:
            day = event['day']
        else:
            day = ''
    except KeyError:
        day = ''
    # Generate a greeting
    greeting = 'Good ' + time + ', ' + name + ' of ' + \
        city + '.' + ['', ' Happy ' + day + '!'][day != '']
    # Log the greeting to CloudWatch
    print(greeting)

    # Return a greeting to the caller
    return {"greeting": greeting}

Per l'integrazione personalizzata Lambda, API Gateway passa l'input alla funzione Lambda dal client come corpo della richiesta di integrazione. L'oggetto event del gestore della funzione Lambda è l'input.

La nostra funzione Lambda è semplice. Analizza l'oggetto event di input per le proprietà name, city, time e day. Quindi restituisce un messaggio di saluto, come JSON oggetto di{"message":greeting}, al chiamante. Il messaggio è nel modello "Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!". Si presume che l'input della funzione Lambda provenga dal seguente oggetto: JSON

{
  "city": "...",
  "time": "...",
  "day": "...",
  "name" : "..."
}

Per ulteriori informazioni, consulta la Guida per gli sviluppatori di AWS Lambda.

Inoltre, la funzione registra la sua esecuzione su Amazon CloudWatch console.log(...) chiamando. Questo risulta utile per tracciare le chiamate durante il debug della funzione. Per consentire alla GetStartedLambdaIntegration funzione di registrare la chiamata, imposta un IAM ruolo con politiche appropriate per la funzione Lambda per creare gli CloudWatch stream e aggiungere voci di registro agli stream. La console Lambda ti guida nella creazione dei IAM ruoli e delle policy richiesti.

Se si configura API senza utilizzare la console API Gateway, ad esempio quando si importa un file API da un API file Open, è necessario creare e impostare in modo esplicito, se necessario, un ruolo e una politica di chiamata per API Gateway per richiamare le funzioni Lambda. Per ulteriori informazioni su come configurare i ruoli di chiamata ed esecuzione Lambda per un API gateway, vedere. API Controlla l'accesso a un REST API con IAM autorizzazioni

Rispetto alla GetStartedLambdaProxyIntegration funzione Lambda per l'integrazione del proxy Lambda, la funzione Lambda per l'integrazione personalizzata GetStartedLambdaIntegration Lambda riceve solo input dal corpo della richiesta di integrazione del Gateway. API API La funzione può restituire l'output di qualsiasi JSON oggetto, una stringa, un numero, un blob booleano o anche un blob binario. La funzione Lambda per l'integrazione del proxy Lambda, al contrario, può ricevere l'input da qualsiasi dato di richiesta, ma deve restituire l'output di un particolare oggetto. JSON La GetStartedLambdaIntegration funzione per l'integrazione personalizzata Lambda può avere i parametri di API richiesta come input, a condizione che API Gateway mappi i parametri di API richiesta richiesti al corpo della richiesta di integrazione prima di inoltrare la richiesta del client al backend. A tal fine, lo API sviluppatore deve creare un modello di mappatura e configurarlo sul metodo utilizzato durante la API creazione di. API

Viene ora creata la funzione Lambda GetStartedLambdaIntegration.

Per creare la funzione Lambda GetStartedLambdaIntegration per l'integrazione personalizzata Lambda

1. Apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

2. Esegui una di queste operazioni:

   • Se viene visualizzata la pagina di benvenuto, scegliere Get Started Now (Inizia subito), quindi Create a function (Crea una funzione).

   • Se viene visualizzata la pagina di elenco Lambda > Funzioni, scegliere Create a function (Crea una funzione).

3. Scegli Author from scratch (Crea da zero).

4. Nel riquadro Author from scratch (Crea da zero) procedere nel seguente modo:

   1. In Nome (Name), immettere GetStartedLambdaIntegration come nome della funzione Lambda.

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

   3. Per Architecture, mantieni l'impostazione predefinita.

   4. In Autorizzazioni espandere Modifica ruolo di esecuzione predefinito. Nell'elenco a discesa Ruolo di esecuzione, scegli Crea nuovo ruolo dai modelli di policy AWS .

   5. Per Role name (Nome ruolo), digitare un nome per il ruolo, ad esempio GetStartedLambdaIntegrationRole.

   6. Per Modelli di policy, scegliere Autorizzazioni microservizi semplici.

   7. Selezionare Create function (Crea funzione).

5. Nel riquadro Configure function (Configura funzione) effettua quanto segue in Function code (Codice funzione):

   1. Copiare il codice di funzione Lambda elencato all'inizio di questa sezione e incollarlo nell'editor di codice inline.

   2. Lascia i valori predefiniti negli altri campi di questa sezione.

   3. Selezionare Deploy (Distribuisci).

6. Per testare la funzione appena creata, scegli la scheda Test.

   1. Per Event name (Nome evento) immettere HelloWorldTest.

   2. Per Event JSON, sostituisci il codice predefinito con il seguente.

      {
        "name": "Jonny",
        "city": "Seattle",
        "time": "morning",
        "day": "Wednesday"
      }

   3. Scegliere Test (Testa) per invocare la funzione. Viene visualizzata la sezione Execution result: succeeded (Risultato esecuzione: riuscito). Espandi Dettaglio. Verrà visualizzato l'output seguente.

      {
          "greeting": "Good morning, Jonny of Seattle. Happy Wednesday!"
      }

      L'output viene anche scritto in CloudWatch Logs.

Come esercizio collaterale, puoi usare la IAM console per visualizzare il IAM ruolo (GetStartedLambdaIntegrationRole) creato come parte della creazione della funzione Lambda. A questo IAM ruolo sono associate due politiche in linea. Una stipula le autorizzazioni di base per l'esecuzione Lambda Consente di richiamare qualsiasi CloudWatch risorsa del tuo account nella regione in cui viene creata la funzione Lambda. CloudWatch CreateLogGroup Questa politica consente inoltre di creare CloudWatch flussi e registrare gli eventi per la funzione LambdaGetStartedLambdaIntegration.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:region:account-id:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:region:account-id:log-group:/aws/lambda/GetStartedLambdaIntegration:*"
            ]
        }
    ]
}

L'altro documento di policy si applica all'invocazione di un altro AWS servizio che non viene utilizzato in questo esempio. Puoi ignorarlo in questa fase.

Al IAM ruolo è associata un'entità attendibile, che èlambda.amazonaws.com. La relazione di fiducia è la seguente:

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

La combinazione di questa relazione di fiducia e della politica in linea consente alla funzione Lambda di richiamare console.log() una funzione per registrare gli eventi nei registri. CloudWatch

Crea un'integrazione API senza proxy con Lambda

Con la funzione Lambda (GetStartedLambdaIntegration) creata e testata, sei pronto per esporre la funzione tramite un gateway. API API A scopo illustrativo, esponiamo la funzione Lambda con un metodo generico. HTTP Utilizziamo il corpo della richiesta, una variabile di URL percorso, una stringa di query e un'intestazione per ricevere i dati di input richiesti dal client. Attiviamo il validatore di richieste API Gateway API per garantire che tutti i dati richiesti siano definiti e specificati correttamente. Configuriamo un modello di mappatura per API Gateway per trasformare i dati di richiesta forniti dal client nel formato valido richiesto dalla funzione Lambda di backend.

Per creare un file API con un'integrazione non proxy Lambda

1. Accedi 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, inserisciLambdaNonProxyAPI.

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

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

6. Scegli Crea API.

Dopo aver creato la tuaAPI, crei una risorsa/{city}. Questo è l'esempio di una risorsa con una variabile di percorso che riceve un input dal client. Più avanti mapperai questa variabile nell'input della funzione Lambda utilizzando un modello di mappatura.

Per creare una risorsa

1. Scegli Crea risorsa.

2. Mantieni l'opzione Risorsa proxy disattivata.

3. Mantieni Percorso risorsa impostato su /.

4. Per Resource Name (Nome risorsa) immetti {city}.

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

6. Scegli Crea risorsa.

Dopo la risorsa /{city}, è necessario creare un metodo ANY. Il ANY HTTP verbo è un segnaposto per un HTTP metodo valido che un client invia in fase di esecuzione. Questo esempio mostra che il metodo ANY può essere utilizzato sia per l'integrazione Lambda personalizzata sia per quella proxy.

Per creare un metodo ANY

1. Seleziona la risorsa /{city}, quindi scegli Crea metodo.

2. In Tipo di metodo, seleziona ANY.

3. Per Tipo di integrazione seleziona Funzione 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, quindi inserisci il nome della funzione.

6. Scegli le impostazioni di richiesta del metodo.

   Ora, attivi un validatore di richiesta per una variabile di URL percorso, un parametro della stringa di query e un'intestazione per garantire che tutti i dati richiesti siano definiti. Per questo esempio, crea un parametro della stringa di query time e un'intestazione day.

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

8. Scegliete i parametri della stringa di URL query ed effettuate le seguenti operazioni:

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

   2. Per Nome, immetti time.

   3. Attiva Campo obbligatorio.

   4. Mantieni disattivata l'opzione Caching.

9. Scegliete le intestazioni della HTTP richiesta ed effettuate le seguenti operazioni:

   1. Seleziona Add header (Aggiungi intestazione).

   2. Per Nome, immetti day.

   3. Attiva Campo obbligatorio.

   4. Mantieni disattivata l'opzione Caching.

10. Scegli Crea metodo.

Dopo aver attivato un validatore di richieste, configuri la richiesta di integrazione per il ANY metodo aggiungendo un modello di body mapping per trasformare la richiesta in entrata in un JSON payload, come richiesto dalla funzione Lambda di backend.

Per configurare la richiesta di integrazione

1. Nella scheda Richiesta di integrazione, nelle impostazioni della richiesta di integrazione, scegli Modifica.

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:

   #set($inputRoot = $input.path('$'))
   {
     "city": "$input.params('city')",
     "time": "$input.params('time')",
     "day":  "$input.params('day')",
     "name": "$inputRoot.callerName"
   }

7. Seleziona Salva.

Prova a richiamare il metodo API

La console API Gateway fornisce una struttura di test che consente di eseguire il test di invocazione API prima della distribuzione. È possibile utilizzare la funzionalità Test della console per eseguire il test API inviando la seguente richiesta:

POST /Seattle?time=morning
day:Wednesday

{
    "callerName": "John"
}

In questa richiesta di test imposterai ANY su POST e {city} su Seattle e assegnerai Wednesday come valore di intestazione di day e "John" come valore di callerName.

Test del metodo ANY

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

2. In Tipo di metodo, seleziona POST.

3. In Percorso immetti Seattle per city.

4. In Stringhe di query immetti time=morning.

5. In Intestazioni immetti day:Wednesday.

6. In Corpo della richiesta immetti { "callerName": "John" }.

7. Scegli Test (Esegui test).

Verifica che il payload della risposta restituita sia come segue:

{
  "greeting": "Good morning, John of Seattle. Happy Wednesday!"
}

È inoltre possibile visualizzare i log per esaminare come API Gateway elabora la richiesta e la risposta.

Execution log for request test-request
Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations: { "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-tag=test-request, Authorization=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid, X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs++ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
  "city": "Seattle",
  "time": "morning",
  "day": "Wednesday",
  "name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200

I log mostrano la richiesta in ingresso prima della mappatura e la richiesta di integrazione dopo la mappatura. I log risultano utili per valutare, in caso di esito negativo di un test, se l'input originale è corretto o il modello di mappatura funziona correttamente.

Implementa il API

La chiamata di test è una simulazione e presenta alcune limitazioni. Ad esempio, ignora qualsiasi meccanismo di autorizzazione attivato su. API Per testare l'APIesecuzione in tempo reale, è necessario implementare il primo. API Per distribuire unAPI, è necessario creare una fase in cui creare un'istantanea del API momento. Il nome dello stage definisce anche il percorso di base dopo il nome API host predefinito. La API risorsa root viene aggiunta dopo il nome dello stage. Quando si modifica laAPI, è necessario ridistribuirla in una fase nuova o esistente prima che le modifiche abbiano effetto.

Per distribuirlo su uno stadio API

1. Scegliere Deploy (Implementa)API.

2. In Fase, seleziona Nuova fase.

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

   Nota

   L'input deve essere testo codificato a UTF -8 (cioè non localizzato).

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

5. Seleziona Deploy (Implementa).

In Dettagli dello stage, scegli l'icona di copia per copiare la tua API chiamata. URL Lo schema generale della base API URL èhttps://api-id.region.amazonaws.com/stageName. Ad esempio, la base URL di API (beags1mnid) creata nella us-west-2 regione e distribuita sullo test stage èhttps://beags1mnid.execute-api.us-west-2.amazonaws.com/test.

Testatela API in una fase di distribuzione

Esistono diversi modi per testare una distribuzioneAPI. Per GET le richieste che utilizzano solo variabili di URL percorso o parametri della stringa di query, è possibile inserire la API risorsa URL in un browser. Per altri metodi, è necessario utilizzare utilità di REST API test più avanzate, come POSTMANo c URL.

Per testare l'APIuso di c URL

1. Apri una finestra terminale sul tuo computer locale connesso a Internet.

2. Per testare POST /Seattle?time=evening:

   Copia il seguente URL comando c e incollalo nella finestra del terminale.

   curl -v -X POST \
     'https://beags1mnid.execute-api.us-west-2.amazonaws.com/test/Seattle?time=evening' \
     -H 'content-type: application/json' \
     -H 'day: Thursday' \
     -H 'x-amz-docs-region: us-west-2' \
     -d '{
   	"callerName": "John"
   }'

   Dovresti visualizzare una risposta di operazione riuscita con il payload seguente:

   {"greeting":"Good evening, John of Seattle. Happy Thursday!"}

   Se modifichi POST in PUT in questa richiesta di metodo, otterrai la stessa risposta.

Elimini

Se non hai più bisogno delle funzioni Lambda create per questa procedura dettagliata, puoi eliminarle in questa fase. Puoi anche eliminare le IAM risorse di accompagnamento.

avvertimento

Se intendi completare le altre procedure guidate di questa serie, non eliminare il ruolo di esecuzione o di invocazione Lambda. Se elimini una funzione Lambda su APIs cui fai affidamento, quella non APIs funzionerà più. L'eliminazione di una funzione Lambda non può essere annullata. Se desideri utilizzare di nuovo la funzione Lambda, dovrai ricrearla.

Se elimini una IAM risorsa su cui si basa una funzione Lambda, quella funzione Lambda non funzionerà più e tutte le risorse APIs che si basano su quella funzione non funzioneranno più. L'eliminazione di una IAM risorsa non può essere annullata. Se si desidera utilizzare nuovamente la IAM risorsa, è necessario ricrearla.

Per eliminare la funzione Lambda

1. Accedi a AWS Management Console e apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

2. Dall'elenco delle funzioni, scegli GetStartedLambdaIntegration, scegli Azioni, quindi scegli Elimina funzione. Quando viene richiesto, scegliere nuovamente Delete (Elimina).

Per eliminare le risorse IAM associate

1. Apri la IAM console all'indirizzo https://console.aws.amazon.com/iam/.

2. In Details (Dettagli) scegliere Roles (Ruoli).

3. Dall'elenco dei ruoli, scegli GetStartedLambdaIntegrationRole, scegli Azioni di ruolo, quindi scegli Elimina ruolo. Segui i passaggi indicati nella console per eliminare il ruolo.