Tutorial: crea un'API CRUD con Lambda e DynamoDB

In questo tutorial crei un'API serverless che crea, legge, aggiorna ed elimina voci da una tabella DynamoDB. DynamoDB è un servizio di database NoSQL interamente gestito che combina prestazioni elevate e prevedibili con una scalabilità continua. Questo tutorial richiede circa 30 minuti e può essere eseguito all'interno del piano gratuito di AWS.

Innanzitutto, si crea una tabella DynamoDB utilizzando la console DynamoDB. Quindi crei una funzione Lambda utilizzando la AWS Lambda console. Successivamente, è possibile creare un'API HTTP utilizzando la console API Gateway. Infine, si esegue il dell'API.

Quando si richiama l'API HTTP, API Gateway instrada la richiesta alla funzione Lambda. La funzione Lambda interagisce con DynamoDB e restituisce una risposta ad API Gateway. La console API Gateway restituisce quindi una risposta all'utente.

Per completare questo esercizio, sono necessari un AWS account e un AWS Identity and Access Management utente con accesso alla console. Per ulteriori informazioni, consulta Prerequisiti per iniziare a utilizzare API Gateway.

In questo tutorial utilizzerai AWS Management Console. Per un AWS SAM modello che crea questa API e tutte le risorse correlate, vedi template.yaml.

Fase 1: creazione di una tabella DynamoDB

Si utilizza una tabella DynamoDB per memorizzare i dati per l'API.

Ogni voce ha un ID univoco, che usiamo come chiave di partizione per la tabella.

Per creare una tabella DynamoDB

1. Apri la console DynamoDB all'indirizzo https://console.aws.amazon.com/dynamodb/.

2. Seleziona Create table (Crea tabella).

3. Nel campo Table name (Nome tabella) immetti http-crud-tutorial-items.

4. In Partition key (Chiave di partizione), inserisci id.

5. Scegliere Create table (Crea tabella).

Fase 2: creazione di una funzione Lambda

Crei una funzione Lambda per il back-end della tua API. Questa funzione Lambda crea, legge, aggiorna ed elimina voci da DynamoDB. La funzione utilizza gli eventi da API Gateway per determinare come interagire con DynamoDB. Per semplicità questo tutorial utilizza una singola funzione Lambda. Come best practice, dovresti creare funzioni separate per ogni route.

Per creare una funzione Lambda

1. Accedere alla console Lambda all'indirizzo https://console.aws.amazon.com/lambda/.

2. Selezionare Create function (Crea funzione).

3. Nel campo Function name (Nome funzione), immettere http-crud-tutorial-function.

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

5. In Permissions (Autorizzazioni) scegli Change default execution role (Cambia ruolo di esecuzione predefinito).

6. Seleziona Crea un nuovo ruolo dai modelli di AWS policy.

7. In Role name (Nome ruolo), immettere http-crud-tutorial-role.

8. In Policy templates (Modelli di policy) scegli Simple microservice permissions. Questa policy concede alla funzione Lambda l'autorizzazione per interagire con DynamoDB.

   Nota

   Per semplicità, questo tutorial utilizza una policy gestita. Come best practice, dovresti creare la tua policy IAM per concedere le autorizzazioni minime richieste.

9. Selezionare Create function (Crea funzione).

10. Apri la funzione Lambda nell'editor di codice della console e sostituisci il suo contenuto con il codice seguente. Scegli Deploy (Distribuisci) per aggiornare la funzione.

Node.js

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

const client = new DynamoDBClient({});

const dynamo = DynamoDBDocumentClient.from(client);

const tableName = "http-crud-tutorial-items";

export const handler = async (event, context) => {
  let body;
  let statusCode = 200;
  const headers = {
    "Content-Type": "application/json",
  };

  try {
    switch (event.routeKey) {
      case "DELETE /items/{id}":
        await dynamo.send(
          new DeleteCommand({
            TableName: tableName,
            Key: {
              id: event.pathParameters.id,
            },
          })
        );
        body = `Deleted item ${event.pathParameters.id}`;
        break;
      case "GET /items/{id}":
        body = await dynamo.send(
          new GetCommand({
            TableName: tableName,
            Key: {
              id: event.pathParameters.id,
            },
          })
        );
        body = body.Item;
        break;
      case "GET /items":
        body = await dynamo.send(
          new ScanCommand({ TableName: tableName })
        );
        body = body.Items;
        break;
      case "PUT /items":
        let requestJSON = JSON.parse(event.body);
        await dynamo.send(
          new PutCommand({
            TableName: tableName,
            Item: {
              id: requestJSON.id,
              price: requestJSON.price,
              name: requestJSON.name,
            },
          })
        );
        body = `Put item ${requestJSON.id}`;
        break;
      default:
        throw new Error(`Unsupported route: "${event.routeKey}"`);
    }
  } catch (err) {
    statusCode = 400;
    body = err.message;
  } finally {
    body = JSON.stringify(body);
  }

  return {
    statusCode,
    body,
    headers,
  };
};

Python

import json
import boto3
from decimal import Decimal

client = boto3.client('dynamodb')
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table('http-crud-tutorial-items')
tableName = 'http-crud-tutorial-items'


def lambda_handler(event, context):
    print(event)
    body = {}
    statusCode = 200
    headers = {
        "Content-Type": "application/json"
    }

    try:
        if event['routeKey'] == "DELETE /items/{id}":
            table.delete_item(
                Key={'id': event['pathParameters']['id']})
            body = 'Deleted item ' + event['pathParameters']['id']
        elif event['routeKey'] == "GET /items/{id}":
            body = table.get_item(
                Key={'id': event['pathParameters']['id']})
            body = body["Item"]
            responseBody = [
                {'price': float(body['price']), 'id': body['id'], 'name': body['name']}]
            body = responseBody
        elif event['routeKey'] == "GET /items":
            body = table.scan()
            body = body["Items"]
            print("ITEMS----")
            print(body)
            responseBody = []
            for items in body:
                responseItems = [
                    {'price': float(items['price']), 'id': items['id'], 'name': items['name']}]
                responseBody.append(responseItems)
            body = responseBody
        elif event['routeKey'] == "PUT /items":
            requestJSON = json.loads(event['body'])
            table.put_item(
                Item={
                    'id': requestJSON['id'],
                    'price': Decimal(str(requestJSON['price'])),
                    'name': requestJSON['name']
                })
            body = 'Put item ' + requestJSON['id']
    except KeyError:
        statusCode = 400
        body = 'Unsupported route: ' + event['routeKey']
    body = json.dumps(body)
    res = {
        "statusCode": statusCode,
        "headers": {
            "Content-Type": "application/json"
        },
        "body": body
    }
    return res

Fase 3: creazione un'API HTTP

L'API HTTP fornisce un endpoint HTTP per la funzione Lambda. In questa fase si crea un'API vuota. Nelle fasi seguenti si configurano route e integrazioni per connettere l'API e la funzione Lambda.

Per creare un'API HTTP

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

2. Scegli Create API (Crea API), quindi per API HTTP, scegli Build (Crea).

3. Per API name (Nome API), immettere http-crud-tutorial-api.

4. Seleziona Successivo.

5. Per Configura route, scegli Avanti per ignorare la creazione della route. È possibile creare route in un secondo momento.

6. Esamina la fase creata da API Gateway e quindi scegli Next (Avanti).

7. Seleziona Crea.

Fase 4: creazione di route

Le route inviano le richieste API in entrata alle risorse di back-end. Le route sono costituite da due parti: un metodo HTTP e un percorso della risorsa, ad esempi, GET /items. Per questa API di esempio, creiamo quattro route:

• GET /items/{id}

• GET /items

• PUT /items

• DELETE /items/{id}

Per creare route

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

2. Scegliere l'API.

3. Scegliere Percorsi.

4. Seleziona Crea.

5. Per Method (Metodo) seleziona GET.

6. Per il percorso, immetti /items/{id}. Il {id} alla fine del percorso è un parametro che API Gateway recupera dal percorso della richiesta quando essa viene effettuata da un client.

7. Seleziona Crea.

8. Ripeti le fasi da 4 a 7 per GET /items, DELETE /items/{id} e PUT /items.

Fase 5: creazione di un'integrazione

Si crea un'integrazione per connettere una route alle risorse di back-end. Per questa API di esempio, si crea un'integrazione Lambda che si utilizza per tutte le route.

Per creare un'integrazione

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

2. Scegliere l'API.

3. Scegli Integrations (Integrazioni).

4. Scegli Manage integrations (Gestisci integrazioni), quindi scegli Create (Crea).

5. Salta il passaggio Collega questa integrazione a una route. Lo completerai in una fase successiva.

6. Per Integration type (Tipo di integrazione), scegli Lambda Function (Funzione Lambda).

7. Per Lambda function (Funzione Lambda), immetti http-crud-tutorial-function.

8. Seleziona Crea.

Fase 6: collega la tua integrazione alle route

Per questa API di esempio, si utilizza la stessa integrazione Lambda per tutte le route. Dopo aver collegato l'integrazione a tutte le route dell'API, la funzione Lambda viene richiamata quando un client chiama una delle route.

Per collegare integrazioni alle route

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

2. Scegliere l'API.

3. Scegli Integrations (Integrazioni).

4. Scegli una route.

5. Nel campo Choose an existing integration (Scegli un'integrazione esistente), scegli http-crud-tutorial-function.

6. Scegli Collega integrazione.

7. Ripeti le fasi 4-6 per tutte le route.

Tutti i percorsi mostrano che è associata un' AWS Lambda integrazione.

Ora che hai un'API HTTP con route e integrazioni, puoi testare la tua API.

Fase 7: test dell'API

Per assicurarti che la tua API funzioni, usa curl.

Per ottenere l'URL per richiamare la tua API

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

2. Scegliere l'API.

3. Prendere nota del valore URL di chiamata per l'API. Viene visualizzato in Invoke URL (Richiama URL) nella pagina Details (Dettagli).

   

4. Copia l'URL di chiamata per l'API.

   L'URL completo è simile a https://abcdef123.execute-api.us-west-2.amazonaws.com.

Per creare o aggiornare una voce

• Utilizza il comando seguente per creare o aggiornare una voce. Il comando include un corpo della richiesta con l'ID, il prezzo e il nome della voce.

  curl -X "PUT" -H "Content-Type: application/json" -d "{\"id\": \"123\", \"price\": 12345, \"name\": \"myitem\"}" https://abcdef123.execute-api.us-west-2.amazonaws.com/items

Per ottenere tutte le voci

• Utilizza il seguente comando per elencare tutte le voci.

  curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items

Per ottenere una voce

• Utilizza il seguente comando per ottenere una voce in base al relativo ID.

  curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123

Per eliminare una voce

1. Utilizza il comando seguente per eliminare una voce.

   curl -X "DELETE" https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123

2. Ottieni tutte le voci per verificare che la voce sia stata eliminata.

   curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items

Fase 8: Pulizia

Per evitare costi non necessari, eliminare le risorse create nell'ambito di questo esercizio di nozioni di base. La procedura seguente elimina l'API HTTP, la funzione Lambda e le risorse associate.

Per eliminare una tabella DynamoDB

1. Apri la console DynamoDB all'indirizzo https://console.aws.amazon.com/dynamodb/.

2. Seleziona la tabella.

3. Seleziona Delete Table (Elimina tabella).

4. Conferma la scelta e seleziona Delete (Elimina).

Per eliminare un'API HTTP

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

2. Nella pagina API, selezionare un'API. Scegli Azioni, quindi Elimina.

3. Scegliere Delete (Elimina).

Per eliminare una funzione Lambda

1. Accedere alla console Lambda all'indirizzo https://console.aws.amazon.com/lambda/.

2. Nella pagina Funzioni, selezionare una funzione. Scegli Azioni, quindi Elimina.

3. Scegliere Delete (Elimina).

Per eliminare il gruppo di log di una funzione Lambda

1. Nella CloudWatch console Amazon, apri la pagina dei gruppi di log.

2. Nella pagina Log Groups (Gruppi di log), seleziona il gruppo di log della funzione (/aws/lambda/http-crud-tutorial-function). Scegliere Actions (Operazioni), quindi selezionare Delete log group (Elimina gruppo di log).

3. Scegliere Delete (Elimina).

Per eliminare il ruolo di esecuzione di una funzione Lambda

1. Nella AWS Identity and Access Management console, apri la pagina Ruoli.

2. Seleziona il ruolo della funzione, ad esempi, http-crud-tutorial-role.

3. Scegliere Delete role (Elimina ruolo).

4. Scegliere Yes, delete (Sì, elimina).

Passaggi successivi: automatizza con AWS SAM o AWS CloudFormation

È possibile automatizzare la creazione e la pulizia delle AWS risorse utilizzando o. AWS CloudFormation AWS SAM Per un esempio di modello AWS SAM per questo tutorial, consulta template.yaml.

Per esempio AWS CloudFormation modelli, vedi modelli di esempio AWS CloudFormation.