การใช้ AWS DynamoDB ในแอปพลิเคชัน Node.js

ประเด็นที่สำคัญ

DynamoDB เป็นโซลูชันฐานข้อมูล NoSQL ที่แข็งแกร่งและมีประสิทธิภาพเป็นพิเศษจาก Amazon Web Services (AWS) ซึ่งสามารถจัดการข้อมูลที่หลากหลายในปริมาณมาก ในขณะเดียวกันก็รักษาระดับประสิทธิภาพ ความยืดหยุ่น และความเชื่อถือได้ให้เหมาะสมที่สุด

เพื่อเริ่มต้นการใช้งานบริการฐานข้อมูล NoSQL ของ Amazon หรือที่เรียกว่า DynamoDB ภายในสภาพแวดล้อม Node.js จำเป็นต้องรับโมดูลไคลเอ็นต์-dynamodb จาก AWS SDK และสร้างการตั้งค่าการรับรองความถูกต้องที่เหมาะสมสำหรับการเข้าถึงแพลตฟอร์ม

DynamoDB มอบแนวทางที่ตรงไปตรงมาในการสร้างตาราง จัดการข้อมูลผ่านการดำเนินการต่างๆ เช่น การเขียน การอ่าน การอัปเดต และการลบบันทึก ทั้งหมดนี้ใช้พารามิเตอร์ที่ผู้ใช้กำหนด คุณลักษณะนี้ส่งเสริมความสามารถในการปรับตัวและปรับขนาดในการออกแบบแอปพลิเคชัน ซึ่งช่วยเพิ่มประสิทธิภาพโดยรวม

การใช้ภาษาการเขียนโปรแกรมที่มีประสิทธิภาพมากมายร่วมกับฐานข้อมูลที่มีศักยภาพถือเป็นสิ่งสำคัญสำหรับส่วนสำคัญในการสร้างแอปพลิเคชันร่วมสมัย

Amazon Web Services มอบโซลูชันนวัตกรรมที่เรียกว่า DynamoDB ซึ่งมีศักยภาพในการเปลี่ยนแปลงการจัดการข้อมูลโดยทำให้สามารถสร้างฐานข้อมูลได้อย่างรวดเร็วซึ่งสามารถจัดการชุดข้อมูลจำนวนมากและหลากหลายได้อย่างมีประสิทธิภาพ

DynamoDB คืออะไร?

Amazon Web Services มอบโซลูชันที่หลากหลายที่ตอบสนองความต้องการฐานข้อมูลที่หลากหลาย รวมถึง Amazon Relational Database Service (RDS) สำหรับฐานข้อมูลเชิงสัมพันธ์แบบดั้งเดิม และ Amazon DocumentDB ซึ่งรองรับฐานข้อมูลเอกสารที่คล้ายกับ MongoDB นอกจากนี้ DynamoDB ยังเป็นตัวอย่างของฐานข้อมูลที่ไม่เกี่ยวข้องหรือฐานข้อมูล NoSQL ที่จัดเก็บข้อมูลโดยใช้ระบบจัดเก็บข้อมูลคีย์-ค่า

DynamoDB สามารถจัดการข้อมูลปริมาณมากที่กระจายไปทั่วเครือข่ายแบบกระจายได้อย่างมีประสิทธิภาพ ขณะเดียวกันก็รักษาประสิทธิภาพ ความทนทาน และความน่าเชื่อถือในระดับที่ยอดเยี่ยม ระบบนำเสนอกรอบการทำงานที่ปรับเปลี่ยนได้ซึ่งช่วยให้จัดเก็บและเรียกค้นข้อมูลทั้งที่มีโครงสร้างและไม่มีโครงสร้างได้ง่าย

DynamoDB เป็นโซลูชันฐานข้อมูลอเนกประสงค์ที่สามารถนำไปใช้ในหลายโดเมนได้ สามารถเข้าถึงได้ผ่านทั้ง AWS Management Console และ AWS Command Line Interface (CLI) รวมถึงการผสานรวมภายในเว็บแอปพลิเคชันที่ใช้ประโยชน์จาก AWS Software Development Kit (SDK)

เริ่มต้นใช้งาน DynamoDB ใน Node.js

Node.js นำเสนอตัวเลือกที่หลากหลายสำหรับการสร้าง Application Programming Interfaces (API) ของแบ็กเอนด์ และนำเสนอความยืดหยุ่นแก่ผู้ใช้ในการเลือกฐานข้อมูลที่ต้องการเพื่อบูรณาการภายในบริบทนี้ นอกจากนี้ Node.js ยังรองรับบริการภายนอกมากมาย เช่น DynamoDB ของ Amazon Web Services ทำให้นักพัฒนามีตัวเลือกมากมายเพื่อรองรับความต้องการเฉพาะของพวกเขา

หากต้องการใช้บริการ Amazon Web Services (AWS) ภายในแอปพลิเคชัน Node สิ่งที่จำเป็นต้องมีคือแพ็คเกจ SDK ไคลเอ็นต์ที่เหมาะสมสำหรับบริการนั้นๆ โดยเฉพาะ ตามตัวอย่าง ในการโต้ตอบกับ DynamoDB เราจะต้องได้รับและติดตั้งโมดูล client-dynamodb ซึ่งอยู่ภายใน aws-sdk

หากต้องการดำเนินการคำสั่งภายในไดเร็กทอรีโครงการที่ระบุ โปรดปฏิบัติตามขั้นตอนเหล่านี้:1. นำทางไปยังไดเร็กทอรีโปรเจ็กต์ที่ต้องการโดยใช้เทอร์มินัลหรือพรอมต์คำสั่ง2. พิมพ์คำสั่งที่เหมาะสมสำหรับการติดตั้งแพ็คเกจที่ต้องการแล้วกด Enter3. กระบวนการติดตั้งจะเริ่มขึ้น และเมื่อเสร็จสิ้นแล้ว คุณควรตรวจสอบว่าแพ็คเกจได้รับการติดตั้งสำเร็จแล้วโดยการตรวจสอบว่ามีอยู่ในระบบไฟล์ของโปรเจ็กต์

 npm install @aws-sdk/client-dynamodb

ในการใช้ตาราง DynamoDB ภายในโปรเจ็กต์ Node.js ของคุณโดยใช้แพ็คเกจ aws-sdk/client-dynamodb จำเป็นต้องระบุตำแหน่งทางภูมิศาสตร์ของตารางโดยการรวมภูมิภาคเข้ากับการตั้งค่าการกำหนดค่าของไคลเอ็นต์ก่อนที่จะมีการโต้ตอบใดๆ. การอัปเดตการกำหนดค่านี้ควรดำเนินการในระหว่างกระบวนการเริ่มต้นของไคลเอ็นต์ DynamoDB

หากคุณได้ติดตั้งและใช้ AWS CLI บนอุปกรณ์คอมพิวเตอร์ของคุณก่อนหน้านี้ มีความเป็นไปได้สูงที่คุณจะได้สร้างข้อมูลรับรอง AWS ภายในการตั้งค่าสภาพแวดล้อมของคุณแล้ว ในกรณีดังกล่าว ชุดพัฒนาซอฟต์แวร์ (SDK) ที่เกี่ยวข้องจะดึงค่าเหล่านี้จากสภาพแวดล้อมดังกล่าวได้อย่างราบรื่นโดยที่คุณไม่ต้องดำเนินการใดๆ เพิ่มเติม

หากคุณยังไม่ได้สร้างผู้ใช้ IAM ภายใน Amazon Web Services (AWS) Console คุณสามารถทำได้โดยไปที่บริการ AWS Identity and Access Management (IAM) เมื่อคุณสร้างบัญชีผู้ใช้ใหม่นี้แล้ว คุณจะได้รับตัวระบุคีย์การเข้าถึงเฉพาะและคีย์ลับที่เกี่ยวข้อง ซึ่งทำหน้าที่เป็นข้อมูลประจำตัวส่วนบุคคลของคุณสำหรับการเข้าถึงทรัพยากรต่างๆ ภายในระบบนิเวศของ AWS

เพื่อรวมคีย์การรับรองความถูกต้องเหล่านี้ลงในพื้นที่ทำงานของคุณ คุณสามารถดำเนินการตามคำแนะนำบรรทัดคำสั่งต่อไปนี้บนระบบปฏิบัติการของคุณ:

บน Unix, Linux หรือ macOS:

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

บน Windows (CMD):

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

บน Windows (PowerShell):

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

ในโปรเจ็กต์ Node.js ของคุณ ให้สร้างไฟล์ใหม่ชื่อ “dynamodb.js” ภายในไฟล์นี้ ให้ใช้บรรทัดโค้ดต่อไปนี้เพื่อเริ่มต้นอินสแตนซ์ของไคลเอนต์ Amazon Web Services (AWS) DynamoDB:

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

const region = "us-east-1" // your preferred region

const client = new DynamoDB({ region })

AWS ตรวจสอบให้แน่ใจว่าข้อมูลความปลอดภัยที่ละเอียดอ่อนได้รับการปกป้องอย่างเพียงพอโดยการป้องกันการเปิดเผยข้อมูลดังกล่าวภายในโค้ดเอง ด้วยเหตุนี้ เมื่อพยายามสร้างการเชื่อมต่อไคลเอ็นต์ดังที่แสดงไว้ก่อนหน้านี้ คีย์การเข้าถึงและคีย์ลับที่จำเป็นจะถูกดึงมาจากแหล่งสภาพแวดล้อม แทนที่จะฝังอยู่ภายในโค้ดโดยตรง

ไคลเอนต์ที่จัดตั้งขึ้นเมื่อเร็ว ๆ นี้อำนวยความสะดวกให้กับฟังก์ชันการทำงานมากมาย เช่น การสร้างตารางและการดำเนินการอินพุต/เอาท์พุตข้อมูล

DynamoDB ทำงานบนสถาปัตยกรรมที่ไม่มีสคีมา ซึ่งคล้ายกับฐานข้อมูล NoSQL อื่นๆ ซึ่งช่วยให้สามารถเพิ่มแอตทริบิวต์หรือช่องใหม่ลงในตารางที่มีอยู่ได้อย่างราบรื่นโดยไม่ทำให้เกิดค่าใช้จ่ายจำนวนมาก ด้วยเหตุนี้ เมื่อสร้างตาราง DynamoDB จึงจำเป็นต้องกำหนดคุณลักษณะเฉพาะที่จะทำหน้าที่เป็นคีย์หลักเพื่ออำนวยความสะดวกในการเรียกค้นและการจัดการข้อมูลที่มีประสิทธิภาพ

จริงๆ แล้ว ให้เราเจาะลึกตัวอย่างของโค้ดที่สร้างตารางใหม่ที่มีชื่อว่า"ลูกค้า"ภายในขอบเขตของบริการ DynamoDB ของ Amazon:

 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();

ฟิลด์ AttributeDefinitions ทำหน้าที่ระบุคุณลักษณะหลักของโครงสร้างของตารางโดยการกำหนดคุณลักษณะที่สำคัญพร้อมกับประเภทข้อมูลที่เกี่ยวข้อง ในกรณีนี้ คุณลักษณะ Email ถูกกำหนดให้เป็นประเภทข้อมูลแบบสตริงซึ่งแสดงด้วยตัวย่อ"S"ประเภทแอตทริบิวต์อื่นๆ ที่ใช้ได้ ได้แก่ ค่าตัวเลขที่แสดงด้วย"N"และข้อมูลไบนารีที่แสดงด้วย"B"

เพื่อให้สามารถดึงและจัดเรียงข้อมูลภายในตาราง DynamoDB ได้อย่างมีประสิทธิภาพ จำเป็นต้องสร้างสคีมาคีย์หลักที่กำหนดแอตทริบิวต์ตั้งแต่หนึ่งรายการขึ้นไปเป็นตัวระบุที่ไม่ซ้ำกันสำหรับแต่ละรายการ ในกรณีนี้ เนื่องจากเราได้กำหนดให้ “อีเมล” เป็นคีย์หลัก จึงควรรวมไว้ใน KeySchema ด้วยประเภทคีย์ที่ระบุเป็น “HASH” ซึ่งช่วยให้ DynamoDB สามารถระบุและค้นหาบันทึกเฉพาะตามที่อยู่อีเมลได้อย่างมีประสิทธิภาพ

อีกทางเลือกหนึ่งสำหรับแอตทริบิวต์ KeyType คือประเภทช่วง ซึ่งทำหน้าที่เป็นกลไกการเรียงลำดับเมื่อนำไปใช้กับค่าแฮชที่ไม่ซ้ำกันภายในตารางฐานข้อมูล ในสถานการณ์ที่บันทึกหลายรายการมีค่าแฮชที่เหมือนกัน การใช้คีย์ช่วงจะทำให้สามารถจัดกลุ่มบันทึกเหล่านี้ตามข้อมูลที่แตกต่างเพิ่มเติม เช่น วันที่หรือสี ด้วยการใช้วิธีการนี้ เราสามารถจัดระเบียบข้อมูลในลักษณะที่มีโครงสร้างมากขึ้นได้อย่างมีประสิทธิภาพ ในขณะเดียวกันก็หลีกเลี่ยงข้อขัดแย้งที่อาจเกิดขึ้นจากการใช้เพียงแฮชคีย์เท่านั้น

สิ่งสำคัญประการที่สามภายในโค้ดที่กล่าวมาข้างต้นเกี่ยวข้องกับ ProvisionedThroughput ซึ่งกำหนดอัตราการอ่านและเขียนที่อนุญาตสำหรับตาราง DynamoDB ที่ระบุเป็นต่อวินาที

เมื่อรันโค้ดที่กล่าวมาข้างต้น เราสามารถคาดหวังได้ว่าจะได้รับเอาต์พุตในรูปแบบ:

เมื่อนำทางไปยังแดชบอร์ดตาราง DynamoDB ภายในเว็บอินเทอร์เฟซของ AWS Management Console จะสังเกตได้ว่าตารางอยู่ระหว่างกระบวนการจัดเตรียมหรือสร้างขึ้นสำเร็จแล้ว และปัจจุบันแสดงสถานะเป็น"ใช้งานอยู่"หรือ"จัดเตรียมแล้ว"

เมื่อกำหนดค่าที่เหมาะสมสำหรับ ReadCapacityUnits และ WriteCapacityUnits การประเมินข้อกำหนดเฉพาะของแอปพลิเคชันของคุณอย่างรอบคอบเป็นสิ่งสำคัญ เพื่อหลีกเลี่ยงปัญหาด้านประสิทธิภาพที่อาจเกิดขึ้นหรือค่าบริการที่สูงเกินจริงในบัญชีของคุณ

เมื่อตารางถูกกำหนดให้เป็นแอ็คทีฟแล้ว คุณจะสามารถดำเนินการต่างๆ ที่เกี่ยวข้องกับการสร้าง อ่าน อัปเดต และลบข้อมูลภายในตารางดังกล่าวได้

ตัวอย่างที่ให้มาแสดงให้เห็นถึงกระบวนการในการเขียนและการดึงข้อมูลจาก

⭐ เพิ่มข้อมูลลงในตาราง ในการเขียนข้อมูลลงตาราง คุณต้องใช้เมธอด putItem ของไคลเอ็นต์ โค้ดด้านล่างจะเพิ่มลูกค้าใหม่ลงในตารางลูกค้าใน 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)

อ็อบเจ็กต์พารามิเตอร์ประกอบด้วย TableName ซึ่งเป็นตารางที่คุณกำลังเขียน และฟิลด์ Item ซึ่งมีข้อมูลที่คุณเพิ่มด้วยประเภทเฉพาะ สังเกตช่องใหม่ๆ ที่ไม่ได้อยู่ในตารางในตอนแรก นี่คือวิธีที่ DynamoDB ทำงานได้อย่างยืดหยุ่น คุณสามารถดูข้อมูลในฐานข้อมูลของคุณในคอนโซลได้ดังนี้:

⭐ อ่านข้อมูลจากตาราง DynamoDB ช่วยให้คุณอ่านข้อมูลได้หลายวิธี ฟังก์ชันการสแกนของ SDK€™ จะอ่านทั้งตาราง ในขณะที่ getItem จะอ่านเฉพาะข้อมูลที่ระบุเท่านั้น ตัวอย่างเช่น รหัสด้านล่างจะรับลูกค้าทั้งหมด:

 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 } // the type is always required
        }
    }

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

getCustomerByEmail("[email protected]")

⭐ อัพเดตข้อมูลในตาราง. หากต้องการอัปเดตข้อมูลที่มีอยู่ในตาราง ให้ใช้ฟังก์ชัน updateItem ของ SDK€™ รหัสต่อไปนี้สาธิตวิธีการอัพเดตเรกคอร์ดเฉพาะ:

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

คุณยังสามารถเลือกทำให้ฟังก์ชันของคุณเป็นแบบไดนามิกได้ด้วยการสร้างนิพจน์การอัปเดตจากข้อมูลที่อัปเดตของคุณ ความยืดหยุ่นของ DynamoDB€™ ช่วยให้คุณจัดการทุกการดำเนินการได้ตามความต้องการของคุณ

⭐ ลบข้อมูลจากตาราง หากต้องการลบบันทึกออกจาก DynamoDB คุณต้องมีฟังก์ชัน DeleteItem และคีย์ของบันทึกนั้นๆ นี่คือวิธีการนำไปใช้:

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

การสร้างแอปพลิเคชันที่มีประสิทธิภาพด้วย DynamoDB

Amazon Web Services ยังคงประสบความสำเร็จอย่างสูงและนำเสนอแพลตฟอร์มที่ใช้งานง่ายสำหรับการพัฒนาบริการดิจิทัลที่มีประสิทธิภาพและเชื่อถือได้ ในขณะเดียวกันก็รับประกันว่าจะมีมาตรการรักษาความปลอดภัยที่แข็งแกร่ง โซลูชัน DynamoDB นำเสนอตัวเองว่าเป็นตัวเลือกในอุดมคติสำหรับผู้ที่ต้องการประสบการณ์ฐานข้อมูลที่มีประสิทธิภาพซึ่งต้องการการจัดการโครงสร้างพื้นฐานพื้นฐานหรือโปรโตคอลการป้องกันเพียงเล็กน้อย

คุณได้รับความรู้และเครื่องมือที่จำเป็นในการเริ่มใช้ DynamoDB ภายในโปรเจ็กต์ Node.js ซึ่งช่วยให้คุณสามารถตัดสินใจอย่างมีข้อมูลเกี่ยวกับการนำไปใช้ในความพยายามในอนาคต