Utilisation d'AWS DynamoDB dans une application Node.js

Points Essentiels à Retenir

• DynamoDB, une solution de base de données NoSQL d'AWS, excelle dans la gestion de vastes ensembles de données diversifiés tout en garantissant des performances, une durabilité et une fiabilité optimales.
• Pour intégrer DynamoDB dans un environnement Node.js, l'installation du package `client-dynamodb` à partir du `aws-sdk` et la configuration des informations d'identification sont nécessaires.
• DynamoDB offre une grande souplesse pour la création de tables, la manipulation de données (lecture, écriture, mise à jour, suppression) grâce aux méthodes et paramètres de son client, favorisant ainsi un développement applicatif efficace et évolutif.

Le développement moderne d'applications repose souvent sur l'alliance de langages de programmation performants et de systèmes de gestion de bases de données robustes.

Parmi les solutions proposées par Amazon Web Services (AWS), DynamoDB se distingue comme un outil révolutionnaire pour la gestion de données. Il permet de déployer rapidement une base de données capable de traiter d'importants volumes de données variées.

Qu'est-ce que DynamoDB ?

AWS met à disposition divers services de bases de données, tels qu'Amazon RDS pour les bases relationnelles ou DocumentDB pour les bases de documents comme MongoDB. DynamoDB se positionne comme une base NoSQL, stockant les données selon un modèle clé-valeur.

DynamoDB est conçu pour gérer de grands volumes de données sur une infrastructure distribuée, sans compromettre la performance, la durabilité ou la fiabilité. Sa flexibilité permet de stocker et d'interroger facilement des données, qu'elles soient structurées ou non.

DynamoDB peut être utilisé comme base de données pour différents types d'applications. Il est accessible directement via la console web AWS, par programmation avec AWS-CLI ou via des applications web en utilisant le AWS-SDK.

Premiers Pas avec DynamoDB et Node.js

Node.js offre un large choix d'outils pour le développement d'APIs backend. Lors de la création d'une API, le choix de la base de données est libre. Node.js facilite l'intégration avec des services externes, notamment des bases de données comme AWS DynamoDB.

Pour accéder à un service AWS depuis une application Node, le package client `aws-sdk` correspondant est nécessaire. Pour DynamoDB, il s'agit du package `client-dynamodb` sous `aws-sdk`.

Pour installer ce package, exécutez la commande suivante dans le répertoire de votre projet :

 npm install @aws-sdk/client-dynamodb

Après l'installation de `aws-sdk/client-dynamodb` dans votre projet Node.js, vous devez configurer la région de votre table DynamoDB avant toute interaction. Cette configuration se fait lors de l'initialisation du client DynamoDB.

Si vous avez déjà installé et utilisé AWS-CLI, vos informations d'identification AWS sont probablement déjà définies dans votre environnement, et le SDK les utilisera automatiquement.

Si ce n'est pas le cas, vous pouvez vous rendre dans le service Gestion de l'accès aux identités AWS (IAM) de votre console pour créer un nouvel utilisateur. Lors de la création, vous obtiendrez un identifiant de clé d'accès et une clé secrète, vos informations d'identification personnelles.

Ajoutez ces identifiants à votre environnement en utilisant les commandes suivantes, adaptées à votre système d'exploitation :

Sur Unix, Linux ou macOS :

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

Sur Windows (CMD) :

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

Sur Windows (PowerShell) :

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

Créez ensuite un nouveau fichier nommé `dynamodb.js` dans votre projet Node.js. Dans ce fichier, instanciez un nouveau client AWS DynamoDB avec le code ci-dessous :

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

C'est aussi simple que ça ! AWS assure que vos identifiants de sécurité ne soient pas exposés dans le code. Le code ci-dessus utilise la clé d'accès et la clé secrète définies dans votre environnement pour créer le client.

Le client ainsi créé permet d'effectuer diverses opérations telles que la création de tables, la lecture et l'écriture de données.

DynamoDB, comme les autres bases de données NoSQL, est sans schéma. Il est donc possible d'ajouter de nouveaux attributs (champs) à une table à tout moment. Lors de la création d'une table DynamoDB, il suffit de définir les attributs qui serviront de clés primaires.

Voici un exemple de code pour créer une table (Client) dans 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();
 

Le champ `AttributeDefinitions` définit les attributs clés de la table et leurs types. L'attribut `Email` est de type `S`, indiquant qu'il attend une chaîne de caractères. Les trois types d'attributs disponibles sont `S` (Chaîne), `N` (Nombre) et `B` (Binaire).

Le `KeySchema` définit les clés primaires qui permettent de rechercher et d'organiser rapidement les éléments. DynamoDB s'attend à ce que les attributs ajoutés lors de la création de la table soient des attributs clés. `Email` est donc la clé primaire ici. Il doit être ajouté au `KeySchema` avec un `KeyType` défini à `HASH`.

L'autre valeur disponible pour `KeyType` est `RANGE`, utilisée pour les clés de tri. Les clés de tri sont utiles dans les cas où plusieurs enregistrements partagent la même clé `HASH`. Elles permettent de regrouper les données selon un attribut supplémentaire, comme la date ou la couleur, qui devient alors une clé `RANGE`.

Le troisième paramètre essentiel est `ProvisionedThroughput`. Il définit le nombre de lectures et d'écritures autorisées par seconde sur la table.

L'exécution du code ci-dessus devrait générer un résultat similaire à :

Dans le tableau de bord de vos tables DynamoDB, vous verrez que la table est soit en cours de provisionnement, soit active.

Il est crucial d'adapter les valeurs de `ReadCapacityUnits` et `WriteCapacityUnits` aux besoins de votre application. Des valeurs inadéquates peuvent entraîner des problèmes de performance ou des coûts de facturation élevés.

Une fois que la table est active, il est possible d'y effectuer des opérations CRUD.

Voici quelques exemples de code illustrant comment écrire et lire des données dans la table Customer :

 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)
 

 const getAllCustomers = async () => {
    const params = {
        TableName: "Customer"
    }
    const customers = await client.scan(params)
    console.log(customers)
}
 

 const getCustomerByEmail = async (email) => {
    const params = {
        TableName: "Customer",
        Key: {
            Email: { "S": email } 
        }
    }
    const customer = await client.getItem(params)
    console.log(customer)
}
getCustomerByEmail("[email protected]")
 

  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)
 }
 

 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]")
 

Développement d'Applications Efficaces avec DynamoDB

Amazon Web Services est en constante évolution et propose une plateforme accessible pour fournir des solutions numériques efficaces et sécurisées. DynamoDB est un choix judicieux si vous recherchez une base de données facile à gérer, sans vous soucier de l'infrastructure ou de la sécurité.

Vous disposez maintenant de toutes les informations nécessaires pour démarrer avec DynamoDB dans Node.js. Vous pouvez choisir DynamoDB en toute confiance pour vos futures applications Node.js.