Creazione di una policy di autorizzazione Creazione di un ruolo di esecuzione Creare la funzione evento Lambda Verificate la funzione dell'evento Creazione di una REST API utilizzando API Gateway Creazione di una risorsa sulla REST API Creazione di un metodo HTTP POST Creazione di una tabella DynamoDB Test dell'integrazione di Gateway API, Lambda e DynamoDB Distribuzione dell'API Usa curl per richiamare la tua funzione evento utilizzando le richieste HTTP Pulizia delle risorse (facoltativo)

Tutorial: uso di Lambda con Amazon API Gateway

In questo tutorial, crei un'API REST tramite la quale richiami una funzione evento Lambda utilizzando una richiesta HTTP. La tua Lambda Event Function esegue operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) su una tabella DynamoDB. Questa funzione viene fornita qui a scopo dimostrativo, ma imparerai a configurare un'API REST di API Gateway in grado di richiamare qualsiasi funzione di evento Lambda.

Servizi e risorse utilizzati in questo tutorial.

L'utilizzo di API Gateway offre agli utenti un endpoint HTTP sicuro per richiamare la funzione Lambda Event e può aiutare a gestire grandi volumi di chiamate alla funzione limitando il traffico e convalidando e autorizzando automaticamente le chiamate API. API Gateway fornisce anche controlli di sicurezza flessibili utilizzando AWS Identity and Access Management (IAM) e Amazon Cognito. Ciò è utile nei casi d'uso in cui è richiesta un'autorizzazione preventiva per le chiamate all'applicazione.

Suggerimento

Lambda offre due modi per invocare una funzione tramite un endpoint HTTP: API Gateway e URL della funzione Lambda. In caso di dubbi su quale sia il metodo migliore per il tuo caso d'uso, consulta Seleziona un metodo per richiamare la tua funzione evento Lambda utilizzando una richiesta HTTP.

Per completare questo tutorial, segui le seguenti fasi:

Crea e configura una funzione evento Lambda in Python o Node.js per eseguire operazioni su una tabella DynamoDB.
Crea un'API REST in API Gateway per connetterti alla tua funzione di eventi Lambda.
Crea una tabella DynamoDB e testala con la tua Lambda Event Function nella console.
Implementa la tua API e testa la configurazione completa usando curl in un terminale.

Completando queste fasi, imparerai a utilizzare API Gateway per creare un endpoint HTTP in grado di richiamare in modo sicuro una funzione evento Lambda su qualsiasi scala. Imparerai anche come implementare la tua API e come testarla nella console e inviando una richiesta HTTP utilizzando un terminale.

Creazione di una policy di autorizzazione

Prima di poter creare un ruolo di esecuzione per la tua funzione di eventi Lambda, devi prima creare una politica di autorizzazioni per concedere alla funzione il permesso di accedere alle risorse richieste. AWS Per questo tutorial, la policy consente a Lambda di eseguire operazioni CRUD su una tabella DynamoDB e scrivere su Amazon Logs. CloudWatch

Come creare la policy

Apri la pagina Policies (Policy) nella console IAM.
Scegli Crea policy.

Scegliere la scheda JSON e quindi incollare la seguente policy personalizzata nell'editor JSON.

Scegliere Next: Tags (Successivo: Tag).
Scegliere Next:Review (Successivo: Rivedi).
In Rivedi policy, per Nome della policy inserisci lambda-apigateway-policy.
Scegli Crea policy.

Creazione di un ruolo di esecuzione

Un ruolo di esecuzione è un ruolo AWS Identity and Access Management (IAM) che concede a una Lambda Event Function l'autorizzazione all' Servizi AWS accesso e alle risorse. Per consentire alla funzione di eseguire operazioni su una tabella DynamoDB, collega la policy di autorizzazione che hai creato nella fase precedente.

Creazione di un ruolo di esecuzione e collegamento di una policy di autorizzazione personalizzata

Aprire la pagina Roles (Ruoli) della console IAM.
Scegliere Crea ruolo.
Per il tipo di entità attendibile, scegli Servizio AWS , quindi per il caso d'uso seleziona Lambda.
Scegli Avanti.
Nella casella di ricerca delle policy, immettere lambda-apigateway-policy.
Nei risultati della ricerca, seleziona la policy creata (lambda-apigateway-policy), quindi scegli Next (Successivo).
In Role details (Dettagli del ruolo), per Role name (Nome del ruolo), specifica lambda-apigateway-role, quindi scegli Create role (Crea ruolo).

Creare la funzione evento Lambda

Apri la pagina Funzioni evento della console Lambda e scegli Crea funzione evento.
Scegli Crea da zero.
Nel campo Function name (Nome funzione), immettere LambdaFunctionOverHttps.
Per Runtime, scegli il runtime più recente Node.js o Python.
In Autorizzazioni espandere Modifica ruolo di esecuzione predefinito.
Scegli Utilizza un ruolo esistente, quindi seleziona il ruolo lambda-apigateway-role creato in precedenza.
Scegliete Crea funzione evento.

Nel riquadro Codice sorgente, sostituisci il codice predefinito con il seguente codice Node.js o con il codice Python.

Node.js

L'regionimpostazione deve corrispondere al Regione AWS luogo in cui si distribuisce la funzione e si crea la tabella DynamoDB.

Esempio index.mjs


import { DynamoDBDocumentClient, PutCommand, GetCommand, 
         UpdateCommand, DeleteCommand} from "@aws-sdk/lib-dynamodb";
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";

const ddbClient = new DynamoDBClient({ region: "us-east-2" });
const ddbDocClient = DynamoDBDocumentClient.from(ddbClient);

// Define the name of the DDB table to perform the CRUD operations on
const tablename = "lambda-apigateway";

/**
 * Provide an event that contains the following keys:
 *
 *   - operation: one of 'create,' 'read,' 'update,' 'delete,' or 'echo'
 *   - payload: a JSON object containing the parameters for the table item
 *     to perform the operation on
 */
export const handler = async (event, context) => {
   
     const operation = event.operation;
   
     if (operation == 'echo'){
          return(event.payload);
     }
     
    else { 
        event.payload.TableName = tablename;
        let response;
        
        switch (operation) {
          case 'create':
               response = await ddbDocClient.send(new PutCommand(event.payload));
               break;
          case 'read':
               response = await ddbDocClient.send(new GetCommand(event.payload));
               break;
          case 'update':
               response = ddbDocClient.send(new UpdateCommand(event.payload));
               break;
          case 'delete':
               response = ddbDocClient.send(new DeleteCommand(event.payload));
               break;
          default:
            response = 'Unknown operation: ${operation}';
          }
        console.log(response);
        return response;
    }
};

Python

Esempio lambda_function.py


import boto3

# Define the DynamoDB table that Lambda will connect to
table_name = "lambda-apigateway"

# Create the DynamoDB resource
dynamo = boto3.resource('dynamodb').Table(table_name)

# Define some functions to perform the CRUD operations
def create(payload):
    return dynamo.put_item(Item=payload['Item'])

def read(payload):
    return dynamo.get_item(Key=payload['Key'])

def update(payload):
    return dynamo.update_item(**{k: payload[k] for k in ['Key', 'UpdateExpression', 
    'ExpressionAttributeNames', 'ExpressionAttributeValues'] if k in payload})

def delete(payload):
    return dynamo.delete_item(Key=payload['Key'])

def echo(payload):
    return payload

operations = {
    'create': create,
    'read': read,
    'update': update,
    'delete': delete,
    'echo': echo,
}

def lambda_handler(event, context):
    '''Provide an event that contains the following keys:
      - operation: one of the operations in the operations dict below
      - payload: a JSON object containing parameters to pass to the 
        operation being performed
    '''
    
    operation = event['operation']
    payload = event['payload']
    
    if operation in operations:
        return operations[operation](payload)
        
    else:
        raise ValueError(f'Unrecognized operation "{operation}"')

Nota

In questo esempio, il nome della tabella DynamoDB è definito come variabile nel codice della funzione. In un'applicazione reale, la best practice consiste nell'inviare questo parametro come variabile d'ambiente ed evitare di codificare il nome della tabella. Per ulteriori informazioni, consulta Uso AWS Lambda delle variabili di ambiente.

Nella sezione DEPLOY, scegli Implementa per aggiornare il codice della tua funzione:

Verificate la funzione dell'evento

Prima di integrare la tua funzione con Gateway API, verifica di aver implementato correttamente la funzione. Utilizza la console Lambda per inviare un evento di test alla tua funzione.

Nella pagina della console Lambda della funzione, scegli la scheda Test.
Scorri alla sezione JSON dell'evento e sostituisci l’evento predefinito con il seguente. Questo evento corrisponde alla struttura prevista dalla Lambda Event Function.
```
{
    "operation": "echo",
    "payload": {
        "somekey1": "somevalue1",
        "somekey2": "somevalue2"
    }
}
```
Scegli Test (Esegui test).
In Esecuzione funzione: riuscita, espandi Dettagli. Dovrebbe essere visualizzata la seguente risposta:
```
{
  "somekey1": "somevalue1",
  "somekey2": "somevalue2"
}
```

Creazione di una REST API utilizzando API Gateway

In questo passaggio, crei l'API REST di API Gateway che utilizzi per richiamare la tua funzione di evento Lambda.

Per creare l'API

Apri la console API Gateway.
Seleziona Create API (Crea API).
Nella casella REST API, scegliere Build.
In Dettagli API, lasciare selezionata Nuova API e per Nome API, inserire DynamoDBOperations.
Seleziona Create API (Crea API).

Creazione di una risorsa sulla REST API

Per aggiungere un metodo HTTP all'API, è necessario prima creare una risorsa su cui quel metodo possa operare. Qui viene creata la risorsa per gestire la tabella DynamoDB.

Per creare la risorsa

Nella console API Gateway, nella pagina Risorse dell'API, scegliere Crea risorsa.
In Dettagli risorsa, per Nome risorsa, inserire DynamoDBManager.
Scegliere Create Resource (Crea risorsa).

Creazione di un metodo HTTP POST

In questa fase, viene creato un metodo (POST) per la risorsa DynamoDBManager. Colleghi questo POST metodo alla tua Lambda Event Function in modo che quando il metodo riceve una richiesta HTTP, API Gateway richiami la tua Lambda Event Function.

Nota

Ai fini di questo tutorial, viene utilizzato un metodo HTTP (POST) per richiamare una singola funzione evento Lambda che esegue tutte le operazioni sulla tabella DynamoDB. In un'applicazione reale, la best practice consiste nell'utilizzare una funzione evento Lambda e un metodo HTTP diversi per ogni operazione. Per ulteriori informazioni, consulta Il monolite Lambda in Serverless Land.

Creazione del metodo POST

Nella pagina Risorse dell'API, assicurarsi che la risorsa /DynamoDBManager sia evidenziata. Quindi, nel riquadro Metodi, scegliere Crea metodo.
Per Metodo HTTP scegliere POST.
Per Tipo di integrazione lasciare selezionato Funzione Lambda.
Per la funzione Lambda, scegliere nome della risorsa Amazon (ARN) per la funzione (LambdaFunctionOverHttps).
Scegli Crea metodo.

Creazione di una tabella DynamoDB

Crea una tabella DynamoDB vuota su cui la tua Lambda Event Function esegue le operazioni CRUD.

Creare la tabella DynamoDB

Aprire la pagina Tables (Tabelle) della console DynamoDB.
Scegliere Create table (Crea tabella).
In Table details (Dettagli tabella), effettuare le seguenti operazioni:
1. Nel campo Table name (Nome tabella) immetti lambda-apigateway.
2. Per Partition key (Chiave di partizione), immettere id e mantenere il tipo di dati impostato come String (Stringa).
In Table settings (Impostazioni tabella), mantieni le impostazioni predefinite.
Scegliere Create table (Crea tabella).

Test dell'integrazione di Gateway API, Lambda e DynamoDB

Ora sei pronto per testare l'integrazione del tuo metodo API Gateway con la tua Lambda Event Function e la tua tabella DynamoDB. Utilizzando la console di Gateway API, invii le richieste direttamente al metodo POST utilizzando la funzione di test della console. In questo passaggio, viene utilizzata prima un'operazione create per aggiungere un nuovo elemento alla tabella DynamoDB, quindi viene utilizzata un'operazione update per modificare l'elemento.

Test 1: creazione di un nuovo elemento nella tabella DynamoDB

Nella console di Gateway API, scegli l'API (DynamoDBOperations).
Scegli il metodo POST sotto la risorsa DynamoDBManager.
Seleziona la scheda Test. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
In Metodo di prova, lasciare vuote le stringhe di query e le intestazioni. Per Corpo della richiesta, incollare il file JSON seguente:
```
{
  "operation": "create",
  "payload": {
    "Item": {
      "id": "1234ABCD",
      "number": 5
    }
  }
}
```
Scegli Test (Esegui test).

I risultati visualizzati al termine del test devono mostrare lo stato 200. Questo codice di stato indica che l'operazione create è riuscita.

Come verifica, controlla che la tabella DynamoDB contenga il nuovo elemento.
Apri la pagina Tables (Tabelle) della console DynamoDB e scegli la tabella lambda-apigateway.
Scegli Explore table items (Esplora elementi della tabella). Nel riquadro Items returned (Elementi restituiti), dovresti vedere un elemento con l'id 1234ABCD e il numero 5. Esempio:

Test 2: aggiornamento dell'elemento nella tabella DynamoDB

Nella Console API Gateway, tornare alla scheda Test del metodo POST.

In Metodo di prova, lasciare vuote le stringhe di query e le intestazioni. Per Corpo della richiesta, incollare il file JSON seguente:


{
    "operation": "update",
    "payload": {
        "Key": {
            "id": "1234ABCD"
        },
        "UpdateExpression": "SET #num = :newNum",
        "ExpressionAttributeNames": {
            "#num": "number"
        },
        "ExpressionAttributeValues": {
            ":newNum": 10
        }
    }
}

Scegli Test (Esegui test).

I risultati visualizzati al termine del test devono mostrare lo stato 200. Questo codice di stato indica che l'operazione update è riuscita.

Per confermare, controlla che l'elemento nella tua tabella DynamoDB sia stato modificato.
Apri la pagina Tables (Tabelle) della console DynamoDB e scegli la tabella lambda-apigateway.
Scegli Explore table items (Esplora elementi della tabella). Nel riquadro Items returned (Elementi restituiti), dovresti vedere un elemento con l'id 1234ABCD e il numero 10.

Distribuzione dell'API

Per consentire al client di chiamare l'API, è necessario creare una implementazione e una fase associata. Una fase rappresenta un'istantanea dell'API, inclusi i suoi metodi e le sue integrazioni.

Per distribuire l'API

Apri la pagina APIs (API) della console Gateway API quindi scegli l'API DynamoDBOperations.
Nella pagina Risorse per la tua API, scegliere Distribuzione dell'API.
Per Fase, scegliere *Nuova fase* quindi per Nome fase specificare test.
Seleziona Implementa.
Nel riquadro Editor fase (Editor fasi) del test, copia l'URL di richiamo. Lo usi nel passaggio successivo per richiamare la tua funzione utilizzando una richiesta HTTP.

Usa curl per richiamare la tua funzione evento utilizzando le richieste HTTP

Ora puoi richiamare la tua Lambda Event Function inviando una richiesta HTTP alla tua API. In questo passaggio, si crea un nuovo elemento nella tabella DynamoDB e quindi si eseguono operazioni di lettura, aggiornamento ed eliminazione su quell'elemento.

Per creare un elemento nella tabella DynamoDB utilizzando curl

Apri un terminale o un prompt dei comandi sul computer locale ed esegui il comando curl seguente utilizzando l'URL di invocazione che hai copiato nel passaggio precedente. Questo comando utilizza le seguenti opzioni:
- -H: aggiunge un'intestazione personalizzata alla richiesta. Qui specifica il tipo di contenuto come JSON.
- -d: invia i dati nel corpo della richiesta. Per impostazione predefinita, questa opzione utilizza un metodo HTTP POST.
Linux/macOS
```
curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
-H "Content-Type: application/json" \
-d '{"operation": "create", "payload": {"Item": {"id": "5678EFGH", "number": 15}}}'
```
PowerShell
```
curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"create\", \"payload\": {\"Item\": {\"id\": \"5678EFGH\", \"number\": 15}}}'
```
Se l'operazione ha avuto esito positivo, dovrebbe essere restituita una risposta con un codice di stato HTTP di 200.
È inoltre possibile utilizzare la console DynamoDB per verificare che il nuovo elemento sia nella tabella effettuando le operazioni seguenti:
1. Apri la pagina Tables (Tabelle) della console DynamoDB e scegli la tabella lambda-apigateway.
2. Scegli Explore table items (Esplora elementi della tabella). Nel riquadro Items returned (Elementi restituiti), dovresti vedere un elemento con l'id 5678EFGH e il numero 15.

Per leggere l'elemento nella tabella DynamoDB utilizzando curl

Nel terminale o nel prompt dei comandi, esegui il comando curl seguente per leggere il valore dell'elemento appena creato. Utilizzo dei propri URL di richiamo

Dovresti vedere un output simile a uno dei seguenti a seconda che tu abbia scelto il codice della funzione Node.js o Python:

Per aggiornare l'elemento nella tabella DynamoDB utilizzando curl

Nel terminale o nel prompt dei comanti, esegui il comando curl seguente per aggiornare l'elemento appena creato modificando il valore number. Utilizzo dei propri URL di richiamo

Per verificare che il valore di number per l'elemento sia stato aggiornato, esegui un altro comando di lettura:

Per eliminare l'elemento nella tabella DynamoDB utilizzando curl

Nel terminale o nel prompt dei comandi, esegui il comando curl seguente per eliminare l'elemento appena creato. Utilizzo dei propri URL di richiamo

Verifica che l'operazione di eliminazione è andata a buon fine. Nel riquadro Elementi restituiti della pagina Esplora elementi della console DynamoDB, verifica che l'elemento con id 5678EFGH non sia più presente nella tabella.

Pulizia delle risorse (facoltativo)

Ora è possibile eliminare le risorse create per questo tutorial, a meno che non si voglia conservarle. Eliminando AWS le risorse che non utilizzi più, eviti addebiti inutili a tuo carico. Account AWS

Per eliminare la funzione evento Lambda

Apri la pagina Event Functions della console Lambda.
Seleziona la funzione di evento che hai creato.
Scegliere Operazioni, Elimina.
Inserisci confirm nel campo di immissione del testo, quindi scegli Elimina.

Come eliminare il ruolo di esecuzione

Aprire la pagina Ruoli della console IAM.
Selezionare il ruolo di esecuzione creato.
Scegliere Elimina.
Inserisci il nome del ruolo nel campo di immissione testo e seleziona Delete (Elimina).

Per eliminare l'API

Aprire la pagina API della console API Gateway.
Selezionare l'API creata.
Scegliere Actions (Operazioni), Delete (Elimina).
Scegliere Delete (Elimina).

Per eliminare la tabella DynamoDB

Aprire la pagina Tables (Tabelle) della console DynamoDB.
Selezionare la tabella creata.
Scegliere Delete (Elimina).
Immettere delete nella casella di testo.
Seleziona Delete Table (Elimina tabella).

Se riscontri errori durante l'invocazione della funzione tramite API Gateway, consultaGestione degli errori con un'API di API Gateway.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Gateway API

Errori