DynamoDB i Node.js: Bygg skalerbare apper enkelt!

0 Shares

Viktige punkter å huske

DynamoDB er en robust NoSQL-database fra AWS, designet for å håndtere store datamengder med høy ytelse, stabilitet og pålitelighet.
For å integrere DynamoDB i Node.js, kreves installasjon av klientpakken `@aws-sdk/client-dynamodb` fra AWS SDK, samt konfigurering av dine autentiseringsdetaljer.
Gjennom klientens metoder og parametere, tilbyr DynamoDB en enkel måte å opprette tabeller, skrive og hente data, samt oppdatere og slette elementer. Dette gir fleksibilitet og skalerbarhet for effektiv applikasjonsutvikling.

Moderne applikasjonsutvikling krever en kombinasjon av sterke programmeringsspråk og effektive databaser.

Amazon Web Services (AWS) tilbyr DynamoDB som en løsning som kan transformere databehandlingen. Med dette verktøyet kan du raskt sette opp en database for å håndtere store og varierte datamengder.

Hva er DynamoDB?

AWS tilbyr en rekke databasetjenester, som Amazon RDS for relasjonsdatabaser og DocumentDB for dokumentdatabaser som MongoDB. DynamoDB skiller seg ut som en NoSQL-database som lagrer data i et nøkkel-verdi-format.

DynamoDB er bygget for å håndtere enorme mengder data over distribuerte systemer, uten å kompromittere ytelse, holdbarhet eller pålitelighet. Databasen gir en fleksibel modell som gjør det enkelt å lagre og søke etter data, uavhengig av om de er strukturerte eller ustrukturerte.

DynamoDB er velegnet for en rekke applikasjoner. Du kan aksessere databasen direkte via AWS webkonsoll, programmatisk gjennom AWS CLI, eller via webapplikasjoner ved hjelp av AWS SDK.

Kom i gang med DynamoDB i Node.js

Det finnes mange alternativer for å utvikle backend-API-er i Node.js, og valget av database er fleksibelt. Node.js har god støtte for eksterne tjenester, inkludert databaser som AWS DynamoDB.

For å aksessere en AWS-tjeneste fra en Node.js-applikasjon, trenger du den relevante klientpakken fra AWS SDK. For å koble til DynamoDB, må du installere klientpakken `@aws-sdk/client-dynamodb`.

Kjør følgende kommando i prosjektmappen for å installere pakken:

npm install @aws-sdk/client-dynamodb

Etter installasjon av `@aws-sdk/client-dynamodb`, må du konfigurere regionen for din DynamoDB-tabell. Dette gjøres ved initialisering av DynamoDB-klienten.

Hvis du har installert og brukt AWS CLI tidligere, har du sannsynligvis allerede definert AWS-autentiseringsdetaljer i systemmiljøet ditt. SDK vil da hente disse automatisk.

Dersom dette ikke er tilfelle, kan du opprette en ny bruker via AWS Identity Access Management (IAM). Etter at brukeren er opprettet, får du en tilgangsnøkkel-ID og en hemmelig nøkkel, som er dine personlige autentiseringsdetaljer.

Legg til disse detaljene i miljøet ditt med disse kommandoene:

For Unix, Linux eller macOS:

 export AWS_ACCESS_KEY_ID='din tilgangsnøkkel-ID'
export AWS_SECRET_ACCESS_KEY='din hemmelige nøkkel'

For Windows (CMD):

 set AWS_ACCESS_KEY_ID='din tilgangsnøkkel-ID'
set AWS_SECRET_ACCESS_KEY='din hemmelige nøkkel'

For Windows (PowerShell):

 $env:AWS_ACCESS_KEY_ID='din tilgangsnøkkel-ID'
$env:AWS_SECRET_ACCESS_KEY='din hemmelige nøkkel'

Gå tilbake til ditt Node.js-prosjekt, opprett en ny fil og kall den for eksempel `dynamodb.js`. I denne filen, instansier en ny AWS DynamoDB-klient med følgende kode:

const { DynamoDB } = require('@aws-sdk/client-dynamodb')
const region = "us-east-1"
const client = new DynamoDB({ region })

Lett som en plett! AWS sikrer at du ikke eksponerer sikkerhetsinformasjonen i koden din, ettersom den henter tilgangsnøkkel og hemmelig nøkkel fra systemmiljøet.

Den nye klienten lar deg utføre ulike handlinger, som å lage tabeller, lese og skrive data.

I likhet med andre NoSQL-databaser, er DynamoDB uten skjema. Du kan når som helst legge til nye attributter (felter) i en tabell. Derfor trenger du kun å definere attributtene som skal fungere som primærnøkler når du oppretter en tabell.

Følgende kode viser hvordan du oppretter en ny tabell (customer) 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();

Feltet `AttributeDefinitions` definerer nøkkelattributtene og deres datatyper. Attributtet `Email` har typen `S`, som indikerer at det forventes en streng som verdi. De tre tilgjengelige attributtypene er `S` (streng), `N` (tall) og `B` (binær).

Du trenger `KeySchema` for å definere primærnøkler som gjør det raskt å finne og organisere elementer. DynamoDB forventer at attributtene du legger til når du oppretter tabellen er nøkkelattributter, så `Email` er primærnøkkelen her. Du må inkludere den i `KeySchema` og angi `KeyType` som `HASH`.

Den andre tilgjengelige `KeyType` verdien er `RANGE`, som brukes til sorteringsnøkler. Sorteringsnøkler er nyttige hvis du har data med like `HASH`-nøkler i en tabell, og ønsker å gruppere dem etter ekstra data som dato eller farge. Du kan da gjøre de ekstra dataene til en `RANGE`-nøkkel.

Den tredje viktige parameteren i koden er `ProvisionedThroughput`. Her definerer du antall lese- og skriveoperasjoner du ønsker å tillate per sekund.

Når du kjører koden, skal du få et utdata som ligner på:

Om du sjekker DynamoDB-tabelloversikten i webkonsollen, vil tabellen enten være i ferd med å bli klargjort eller ha status som aktiv.

Vurder alltid applikasjonens behov når du angir `ReadCapacityUnits` og `WriteCapacityUnits`. Feil verdier kan føre til ytelsesproblemer eller høye kostnader.

Når du har bekreftet at tabellen er aktiv, kan du utføre CRUD-operasjoner.

Her er noen kodeeksempler som viser hvordan du skriver og leser data fra `Customer`-tabellen:

Legge til data i tabellen. For å skrive data bruker du klientens `putItem`-metode. Koden under legger til en ny kunde i `Customer`-tabellen:

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 inneholder `TableName`, som er tabellen du skriver til, og `Item`-feltet som inneholder dataene du legger til med deres spesifikke typer. Legg merke til at nye felter er lagt til som ikke var i tabellen originalt, dette er et eksempel på DynamoDBs fleksibilitet. Du kan se dataene i databasen slik:

Lese data fra tabellen. DynamoDB lar deg lese data på flere måter. SDK sin `scan`-funksjon leser hele tabellen, mens `getItem` kun leser spesifikke data. Koden under henter alle kunder:

const getAllCustomers = async () => {
    const params = {
        TableName: "Customer"
    }

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

Mens koden under henter brukeren basert på e-postadressen:

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

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

getCustomerByEmail("[email protected]")

Oppdatere data i tabellen. For å oppdatere data, brukes SDK-funksjonen `updateItem`. Koden under viser hvordan du oppdaterer et spesifikt element:

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 også gjøre funksjonen dynamisk ved å bygge opp oppdateringsuttrykket fra dataene dine. DynamoDB sin fleksibilitet lar deg håndtere operasjoner etter behov.

Slette data fra tabellen. For å slette et element, bruk `deleteItem`-funksjonen og nøkkelen til elementet. Slik implementeres 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("Kunde slettet")
        }
    })
}

deleteCustomer("[email protected]")

Bygge effektive applikasjoner med DynamoDB

Amazon Web Services fortsetter å vokse. De tilbyr en tilgjengelig plattform for å levere effektive og sikre digitale løsninger. DynamoDB er et utmerket valg hvis du trenger en database som ikke krever bekymringer for infrastruktur eller sikkerhet.

Du har nå det grunnleggende for å begynne å bruke DynamoDB i Node.js. Du kan trygt velge DynamoDB for din neste Node.js-applikasjon.