Nozioni di base su AWS

Creazione di un'applicazione Web di base

Distribuzione di un'applicazione Web e maggiore interattività con un'API e un database

Modulo 4: Creazione di una tabella di dati

In questo modulo creerai una tabella DynamoDB e abiliterai la funzione Lambda per archiviare dati al suo interno.

Introduzione

In questo modulo andremo a creare una tabella per mantenere persistenti i dati utilizzando Amazon DynamoDB. DynamoDB è un servizio di database chiave-valore, pertanto non è necessario creare uno schema per i nostri dati. Offre prestazioni uniformi e scalabilità e non vi sono server da gestire durante il suo utilizzo.

Inoltre, utilizzeremo il servizio IAM (AWS Identity and Access Management) per fornire ai nostri servizi le autorizzazioni necessarie per interagire tra loro in modo sicuro. In particolare, consentiremo alla funzione Lambda creata nel Modulo 2 di scrivere nella tabella DynamoDB appena creata utilizzando una policy IAM. A tal fine, utilizzeremo l'SDK AWS (Python, JavaScript o Java) della nostra funzione Lambda.

Avrai modo di approfondire i seguenti aspetti

  • Creazione di una tabella DynamoDB con la Console di gestione AWS
  • Creazione di un ruolo e gestione delle autorizzazioni con IAM
  • Scrittura in una tabella DynamoDB con l'SDK AWS (Python, JavaScript o Java)

Concetti chiave

Persistenza dei dati: archiviazione di dati in modo da potervi accedere in futuro, indipendentemente dall'esecuzione del programma.

Database non relazionale: un database non relazionale non utilizza uno schema tabulare costituito da righe e colonne. Viene utilizzato invece un modello di storage ottimizzato per i requisiti specifici del tipo di dati che vengono archiviati.

Database chiave-valore: un database chiave-valore che immagazzina i dati come un insieme di coppie di chiave-valore dove una chiave rappresenta un identificatore univoco.

Chiave principale: il valore che identifica ciascuna parte dei dati in una tabella DynamoDB. Questo valore verrà utilizzato anche per partizionare la tabella per renderla scalabile.

Schema: l'organizzazione dei dati utilizzata come modello di creazione di un database.

SDK AWS: SDK sta per "Software Development Kit". Gli SDK AWS forniscono un set di strumenti, librerie, documentazione, codici di esempio, processi e guide che consentono agli sviluppatori di creare applicazioni software su piattaforme specifiche.

Policy IAM: un documento che definisce a quali risorse AWS ha accesso un'entità (ad esempio, servizio, utente, gruppo).

 Tempo richiesto per il completamento

10 minuti

 Servizi utilizzati

Implementazione

  • Creazione di una tabella DynamoDB
    1. Accedi alla Console di Amazon DynamoDB.
    2. Assicurati di prendere nota della regione in cui viene creata la funzione. Questa informazione è visibile all'inizio della pagina, accanto al nome dell'account.
    3. Fai clic sul pulsante blu "Crea tabella".
    4. Accanto al nome della tabella, digita HelloWorldDatabase.
    5. Nel campo "Chiave principale" digita ID.
    6. Fai clic sul pulsante blu "Crea".
    7. Copia l'"Amazon Resource Name (ARN)" dal pannello a destra (che sarà necessario successivamente in questo modulo).
  • Creazione e aggiunta della policy IAM nella funzione Lambda
    1. Ora che la tabella è pronta, andiamo a modificare la nostra funzione Lambda in modo da poter scrivere dati al suo interno. In una nuova finestra del browser, aprire la Console di AWS Lambda.
    2. Fai clic sulla funzione creata nel Modulo 2 (se hai seguito i nostri esempi, è denominata "HelloWorldFunction").
    3. Aggiungeremo autorizzazioni alla funzione in modo che possa utilizzare il servizio DynamoDB e a tal fine utilizzeremo AWS Identity and Access Management (IAM).
    4. Fai clic sulla scheda "Autorizzazioni".
    5. Nella casella "Ruolo di esecuzione" fai clic sul ruolo. Si aprirà una nuova scheda del browser.
    6. Fai clic su "Aggiungi policy integrata" a destra della casella "Policy autorizzazioni".
    7. Fai clic sulla scheda JSON.
    8. Incolla la policy seguente nell'area di testo, prestando attenzione nel sostituire l'ARN della tabella nel campo "Risorsa" alla riga 15:
    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": [
                "dynamodb:PutItem",
                "dynamodb:DeleteItem",
                "dynamodb:GetItem",
                "dynamodb:Scan",
                "dynamodb:Query",
                "dynamodb:UpdateItem"
            ],
            "Resource": "YOUR-TABLE-ARN"
        }
        ]
    }

    9. Questa policy consentirà alla funzione Lambda di leggere, modificare o eliminare voci, ma limitatamente nella tabella creata.

    10. Fai clic sul pulsante blu "Esamina policy".

    11. Accanto al nome digita HelloWorldDynamoPolicy.

    12. Fai clic sul pulsante blu "Crea policy".

    13. Adesso è possibile chiudere la scheda del browser e tornare alla scheda della funzione Lambda.


  • Modifica della funzione Lambda per scrivere nella tabella DynamoDB
    • Python
    • JavaScript
    • Java
    • Python
      1. Fai clic sulla scheda "Configurazione"
      2. Sostituisci il codice della funzione con quanto segue:
      # import the json utility package since we will be working with a JSON object
      import json
      # import the AWS SDK (for Python the package name is boto3)
      import boto3
      # import two packages to help us with dates and date formatting
      from time import gmtime, strftime
      
      # create a DynamoDB object using the AWS SDK
      dynamodb = boto3.resource('dynamodb')
      # use the DynamoDB object to select our table
      table = dynamodb.Table('HelloWorldDatabase')
      # store the current time in a human readable format in a variable
      now = strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())
      
      # define the handler function that the Lambda service will use as an entry point
      def lambda_handler(event, context):
      # extract values from the event object we got from the Lambda service and store in a variable
          name = event['firstName'] +' '+ event['lastName']
      # write name and time to the DynamoDB table using the object we instantiated and save response in a variable
          response = table.put_item(
              Item={
                  'ID': name,
                  'LatestGreetingTime':now
                  })
      # return a properly formatted JSON object
          return {
              'statusCode': 200,
              'body': json.dumps('Hello from Lambda, ' + name)
          }

      3. Fai clic sul pulsante arancione "Salva" a inizio pagina.

    • JavaScript
      1. Fai clic sulla scheda "Configurazione"
      2. Sostituisci il codice della funzione con quanto segue:
      // Include the AWS SDK module
      const AWS = require('aws-sdk');
      // Instantiate a DynamoDB document client with the SDK
      let dynamodb = new AWS.DynamoDB.DocumentClient();
      // Use built-in module to get current date & time
      let date = new Date();
      // Store date and time in human-readable format in a variable
      let now = date.toISOString();
      // Define handler function, the entry point to our code for the Lambda service
      // We receive the object that triggers the function as a parameter
      exports.handler = async (event) => {
          // Extract values from event and format as strings
          let name = JSON.stringify(`Hello from Lambda, ${event.firstName} ${event.lastName}`);
          // Create JSON object with parameters for DynamoDB and store in a variable
          let params = {
              TableName:'HelloWorldDatabase',
              Item: {
                  'ID': name,
                  'LatestGreetingTime': now
              }
          };
          // Using await, make sure object writes to DynamoDB table before continuing execution
          await dynamodb.put(params).promise();
          // Create a JSON object with our response and store it in a constant
          const response = {
              statusCode: 200,
              body: name
          };
          // Return the response constant
          return response;
      };

      3. Fai clic sul pulsante arancione "Salva" a inizio pagina.

    • Java
      1. Fai clic sulla scheda "Configurazione"
      2. Vai al "Codice funzione" e carica il seguente file JAR. (Ai fini di questo tutorial, salteremo la creazione del pacchetto di distribuzione).
      3. Aggiorna "Gestore" con com.example.app.SavePersonHandler::handleRequest.
      4. Fai clic sul pulsante arancione "Salva" a inizio pagina.
  • Verifica delle modifiche
    1. Fai clic sul pulsante bianco "Test".
    2. Dovresti visualizzare il messaggio "Risultato esecuzione: completata" su uno sfondo verde.
    3. In una nuova scheda del browser, apri la Console di DynamoDB.
    4. Fai clic su "Tabelle" nella barra di navigazione a sinistra.
    5. Fai clic sulla tabella HelloWorldDatabase, creata precedentemente nel modulo.
    6. Fai clic sulla scheda "Voci" a destra.
    7. Le voci corrispondenti all'evento di test dovrebbero essere visualizzate qui. Se hai seguito i nostri esempi, l'ID voce sarà "Ada Lovelace".
    8. Ogni volta che si esegue la funzione Lambda, la tabella DynamoDB viene aggiornata. Se si utilizza lo stesso nome, cambierà solo l'indicazione di data/ora.

Architettura dell'applicazione

Ora che il Modulo 4 è completato, diamo un'occhiata alla nostra attuale architettura:

Full Stack tutorial Module Four app arch

Abbiamo aggiunto due servizi nel modulo: DynamoDB (per lo storage) e IAM (per la gestione sicura delle autorizzazioni). Entrambi sono collegati alla nostra funzione Lambda, pertanto questa può scrivere nel nostro database. Nella fase finale, aggiungeremo il codice al nostro client per richiamare API Gateway.

Questo modulo è stato utile?

Grazie
Facci sapere cosa ti è piaciuto.
Spiacenti di non esserti stati d'aiuto
C'è qualcosa di obsoleto, ambiguo o approssimativo? Aiutaci a migliorare questo tutorial con il tuo feedback.

Maggiore interattività in un sito Web