Använda AWS DynamoDB i en Node.js-applikation

Viktiga takeaways

  • DynamoDB är en kraftfull NoSQL-databas som erbjuds av AWS som kan hantera stora mängder olika data utan att kompromissa med prestanda, hållbarhet eller tillförlitlighet.
  • För att komma igång med DynamoDB i Node.js måste du installera client-dynamodb-paketet från aws-sdk och konfigurera dina referenser.
  • DynamoDB låter dig enkelt skapa tabeller, skriva och läsa data, uppdatera poster och ta bort poster med hjälp av klientens metoder och parametrar. Det erbjuder flexibilitet och skalbarhet för effektiv applikationsutveckling.

En stor del av modern apputveckling behöver en blandning av robusta programmeringsspråk och kraftfulla databaser.

En av lösningarna som Amazon Web Services (AWS) erbjuder är DynamoDB, ett verktyg som kan revolutionera din datahantering. Med den kan du snabbt tillhandahålla en databas för att hantera stora mängder olika data.

Vad är DynamoDB?

AWS erbjuder tjänster för olika databasbehov, som Amazon RDS för relationsdatabaser och DocumentDB för dokumentdatabaser som MongoDB. DynamoDB är en NoSQL-databas för att lagra data i ett nyckel-värdeformat.

DynamoDB kan hantera stora mängder data över distribuerad infrastruktur utan att kompromissa med prestanda, hållbarhet eller tillförlitlighet. Den erbjuder en flexibel modell som låter dig enkelt lagra och fråga data, oavsett om den är strukturerad eller ostrukturerad.

Du kan använda DynamoDB som databas för olika typer av applikationer. Du kan komma åt den direkt från AWS webbkonsol och programmatiskt via AWS-CLI, eller från webbapplikationer som använder AWS-SDK.

Komma igång med DynamoDB i Node.js

Det finns många verktyg för att bygga backend-API:er i Node.js och du är fri att välja databasen för ditt API när du arbetar med något av dessa verktyg. Node.js ger brett stöd för externa tjänster inklusive databaser som AWS DynamoDB.

Allt du behöver för att komma åt en AWS-tjänst från din Node-app är klientpaketet aws-sdk för den tjänsten. Till exempel, för att komma åt DynamoDB, måste du installera klient-dynamodb-paketet under aws-sdk.

Kör det här kommandot i din projektkatalog för att installera paketet:

 npm install @aws-sdk/client-dynamodb

Efter att ha installerat aws-sdk/client-dynamodb i ditt Node.js-projekt måste du lägga till regionen för din DynamoDB-tabell till konfigurationen innan du interagerar med den. Du kommer att göra detta när du initierar DynamoDB-klienten.

Om du har installerat och använt AWS-CLI på din dator tidigare, har du förmodligen redan AWS-referenser inställda i din miljö, och SDK:n kommer automatiskt att hämta dina värden från miljön.

Men om du inte har det kan du gå till AWS Identity Access Management (IAM) tjänsten i din konsol och skapa en ny användare. Efter att ha skapat användaren kan du få ett åtkomstnyckel-ID och en hemlig nyckel, som är dina personliga referenser.

Lägg till dessa referenser till din miljö genom att köra följande terminalkommandon för din plattform:

På Unix, Linux eller macOS:

 export AWS_ACCESS_KEY_ID='your access key ID'
export AWS_SECRET_ACCESS_KEY='you secret access key'

På Windows (CMD):

 set AWS_ACCESS_KEY_ID='your access key ID'
set AWS_SECRET_ACCESS_KEY='you secret access key'

På Windows (PowerShell):

 $env:AWS_ACCESS_KEY_ID='your access key ID'
$env:AWS_SECRET_ACCESS_KEY='you secret access key'

Sedan, tillbaka i ditt Node.js-projekt, skapa en ny fil och namnge den dynamodb.js. I den här filen instansierar du en ny AWS DynamoDB-klient med följande kod:

 const { DynamoDB } = require('@aws-sdk/client-dynamodb')

const region = "us-east-1"

const client = new DynamoDB({ region })

Ganska enkelt! AWS ser till att du inte exponerar någon av dina säkerhetsuppgifter i din kod, så medan koden ovan försöker skapa klienten läser den först åtkomstnyckeln och den hemliga nyckeln från din miljö.

Den nyskapade klienten gör att du kan utföra olika operationer, som att skapa tabeller och läsa och skriva data.

DynamoDB är schemalöst precis som andra NoSQL-databaser, så du kan alltid lägga till nya attribut (fält) till en tabell när som helst. Det är därför du bara behöver lägga till attribut som fungerar som primärnycklar till en DynamoDB-tabell när du skapar den.

Kolla in följande kod som skapar en ny tabell (kund) i DynamoDB:

 const createCustomerTable = async () => {
    const params = {
        TableName: "Customer",
        AttributeDefinitions: [
            {
                AttributeName: "Email",
                AttributeType: "S"
            },
        ],
        KeySchema: [
            {
                AttributeName: "Email",
                KeyType: "HASH"
            }
        ],
        ProvisionedThroughput: {
            ReadCapacityUnits: 5,
            WriteCapacityUnits: 5
        }
    };

    client.createTable(params, (err, data) => {
        if (err) {
           console.log(err);
        } else {
            console.log(data);
        }
    });
}

createCustomerTable();

Fältet AttributeDefinitions är där du definierar tabellens nyckelattribut och deras typer. E-postattributet här har typ S vilket betyder att fältet förväntar sig en sträng som värde. De tre tillgängliga attributtyperna är S, N och B (String, Number och Binary).

Du behöver KeySchema för att definiera primärnycklar som hjälper till att hitta och organisera objekt snabbt. DynamoDB förväntar sig att attributen du lägger till när du skapar tabellen är nyckelattribut, så e-post är den primära nyckeln här. Du måste lägga till det i KeySchema och ange dess KeyType (HASH).

Det andra tillgängliga KeyType-värdet är RANGE som används för sorteringsnycklar. Sorteringsnycklar är användbara i de fall där du kan ha data med samma HASH-nycklar i en tabell, och du vill gruppera dem efter extra data som datum eller färg, kan du göra extra data till en RANGE-nyckel.

Den tredje viktiga parametern i ovanstående kod är ProvisionedThroughput. Det är här du definierar antalet läsningar och skrivningar du vill att DynamoDb ska tillåta på bordet per sekund.

När du kör koden ovan bör du få utdata som ser ut så här:

Om du kontrollerar din DynamoDB-tabellinstrumentpanel i webbkonsolen ser du att tabellen antingen fortfarande tillhandahålls eller har statusen aktiv redan.

Tänk alltid på dina applikationsbehov när du anger ReadCapacityUnits och WriteCapacityUnits eftersom ett olämpligt värde kan leda till prestandaproblem eller höga faktureringskostnader på ditt konto.

När du är säker på att bordet redan är aktivt kan du utföra CRUD-operationer på det.

Följande är några kodexempel som visar hur du skriver och läser data från kundtabellen.

  • Lägg till data i tabellen. För att skriva data till en tabell behöver du klientens putItem-metod. Koden nedan lägger till en ny kund i Kundtabellen i DynamoDB.
     const createCustomer = async (customer) => {
        const params = {
            TableName: "Customer",
            Item: customer
        }

        client.putItem(params, (err, data) => {
            if (err) {
               console.error(err)
            } else {
                console.log(data)
            }
        })
    }

    const customerData = {
        Name: { "S": "Timilehin O." },
        Email: { "S": "[email protected]" },
        Age: { "N": "18"},
        Country: { "S": "Nigeria" }
    }

    createCustomer(customerData)

    Params-objektet innehåller TableName som är tabellen du skriver till och fältet Item som innehåller data du lägger till med deras specifika typer. Lägg märke till de nya fälten som inte fanns i tabellen från början, så här fungerar DynamoDB flexibelt. Du kan se data i din databas i din konsol så här:

  • Läs data från tabellen. DynamoDB låter dig läsa data på olika sätt. SDK:ns skanningsfunktion läser hela tabellen, medan getItem endast läser specifika data. Till exempel får koden nedan alla kunder:
     const getAllCustomers = async () => {
        const params = {
            TableName: "Customer"
        }

        const customers = await client.scan(params)
        console.log(customers)
    }

    Medan följande kod får användaren av e-postvärdet:

     const getCustomerByEmail = async (email) => {
        const params = {
            TableName: "Customer",
            Key: {
                Email: { "S": email }
            }
        }

        const customer = await client.getItem(params)
        console.log(customer)
    }

    getCustomerByEmail("[email protected]")

  • Uppdatera data i tabellen. För att uppdatera befintliga data i en tabell, använd SDK:s updateItem-funktion. Följande kod visar hur man uppdaterar en specifik post:
      const updateCustomerLocation = async (email, age) => {
         const params = {
             TableName: "Customer",
             Key: {
                 Email: { "S": email }
             },
             UpdateExpression: "SET Age = :newAge",
             ExpressionAttributeValues: {
                 ':newAge': { "N": age }
             },
             ReturnValues: "ALL_NEW"
         }

         const updatedCustomer = await client.updateItem(params)
         console.log(updatedCustomer.Attributes)
     }

    Du kan också välja att göra din funktion dynamisk genom att bygga uppdateringsuttryck från dina uppdateringsdata. DynamoDB:s flexibilitet gör att du kan hantera varje operation enligt dina behov.

  • Ta bort data från tabellen. För att radera en post från DynamoDB behöver du deleteItem-funktionen och nyckeln för den specifika posten. Så här implementerar du det:
     const deleteCustomer = async (email) => {
        const params = {
            TableName: "Customer",
            Key: {
                Email: { "S": email }
            }
        }

        client.deleteItem(params, (err, data) => {
            if (err) {
               console.error(err)
            } else {
                console.log("Customer deleted successfully")
            }
        })
    }

    deleteCustomer("[email protected]")

  • Bygga effektiva applikationer med DynamoDB

    Amazon Web Services fortsätter att frodas. Det ger en tillgänglig plattform som du kan använda för att leverera effektiva, säkra digitala lösningar. DynamoDB är det perfekta valet om du letar efter en databas för att komma igång utan att oroa dig för infrastruktur eller säkerhet.

    Du är nu utrustad med allt du behöver för att komma igång med DynamoDB i Node.js, och du kan med säkerhet välja DynamoDB för din nästa Node.js-applikation.