0Pricing
Serverless AWS Lambda Development · Pelajaran

Mengintegrasikan DynamoDB

Hubungkan fungsi Lambda ke Amazon DynamoDB, basis data NoSQL yang dikelola sepenuhnya, untuk penyimpanan dan pengambilan data berperforma tinggi serta mudah diskalakan dalam aplikasi tanpa server.

Mengintegrasikan DynamoDB adalah pelajaran Serverless AWS Lambda Development gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Serverless AWS Lambda Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Serverless AWS Lambda Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Lambda Meets DynamoDB

Welcome! In this lesson, we'll connect the power of serverless AWS Lambda with Amazon DynamoDB, a super-fast and flexible NoSQL database.

This combination is perfect for building scalable, high-performance applications without managing servers or database infrastructure.

DynamoDB: NoSQL in a Nutshell

Amazon DynamoDB is a fully managed, serverless NoSQL database. Unlike traditional SQL databases, it uses a key-value and document data model.

  • Tables: Similar to SQL tables, but hold items.
  • Items: Like rows in SQL, but can have different attributes.
  • Attributes: Like columns, but flexible (no fixed schema).
  • Primary Key: Uniquely identifies each item. Can be a simple Partition Key or a composite Partition Key + Sort Key.

Setting Up Your DynamoDB Table

Before Lambda can interact with DynamoDB, you need a table. You can create one easily in the AWS Management Console.

When creating, you'll define a Primary Key. For example, an id attribute as a Partition Key is common for simple lookups.

Giving Lambda DynamoDB Access

For your Lambda function to talk to DynamoDB, it needs permission. This is managed via an IAM Role attached to your Lambda function.

You'll need to grant policies like dynamodb:PutItem, dynamodb:GetItem, etc., to specific tables for secure, granular access. For simplicity in learning, AmazonDynamoDBFullAccess might be used initially, but always prefer least privilege in production.

Writing Data: The PutItem Op

The PutItem operation is used to add a new item to a table or replace an existing item if an item with the same primary key already exists.

Try running this example to see how to add an item. We're using a mock AWS SDK for local execution.

// MOCK AWS SDK for local runnable example
const mockDynamoDB = {
  DocumentClient: function() {
    return {
      put: (params) => ({
        promise: () => {
          console.log("MOCK: Put item to table '" + params.TableName + "':", params.Item);
          return Promise.resolve({ success: true, item: params.Item });
        }
      })
    };
  }
};

// Simulate the Lambda handler function
async function handler(event) {
  const ddb = new mockDynamoDB.DocumentClient();

  const params = {
    TableName: "MyUsersTable", // Replace with your table name
    Item: {
      id: event.userId,
      name: event.userName,
      email: event.userEmail
    }
  };

  try {
    const data = await ddb.put(params).promise();
    console.log("Operation successful (mock):", data);
    return { statusCode: 200, body: JSON.stringify(data) };
  } catch (err) {
    console.error("Operation failed (mock):", err);
    return { statusCode: 500, body: JSON.stringify(err) };
  }
}

// Entry point for CoddyKit's runnable environment
async function main() {
  console.log("Running simulated PutItem operation...");
  const testEvent = {
    userId: "user123",
    userName: "Alice",
    userEmail: "alice@example.com"
  };
  await handler(testEvent);
}

main();

Understanding the PutItem Code

In the example, we're using DynamoDB.DocumentClient() to simplify interactions with DynamoDB, as it handles data types automatically.

  • TableName: The name of your DynamoDB table.
  • Item: A JavaScript object representing the data you want to store. Each key-value pair is an attribute.
  • promise(): Used to handle the asynchronous nature of AWS SDK calls.

Reading Data: The GetItem Op

To retrieve a single item from your table, you use the GetItem operation. You must provide the full Primary Key of the item you want to fetch.

Run this code to see how to get an item back.

// MOCK AWS SDK for local runnable example
const mockDynamoDB = {
  DocumentClient: function() {
    return {
      get: (params) => ({
        promise: () => {
          console.log("MOCK: Get item from table '" + params.TableName + "' with Key:", params.Key);
          // Simulate finding an item with id 'user123'
          if (params.Key.id === "user123") {
            return Promise.resolve({ Item: { id: "user123", name: "Alice", email: "alice@example.com" } });
          }
          return Promise.resolve({ Item: null }); // Item not found
        }
      })
    };
  }
};

// Simulate the Lambda handler function
async function handler(event) {
  const ddb = new mockDynamoDB.DocumentClient();

  const params = {
    TableName: "MyUsersTable", // Replace with your table name
    Key: {
      id: event.userId // The primary key to retrieve
    }
  };

  try {
    const data = await ddb.get(params).promise();
    console.log("Retrieved item (mock):", data.Item);
    return { statusCode: 200, body: JSON.stringify(data.Item) };
  } catch (err) {
    console.error("Operation failed (mock):", err);
    return { statusCode: 500, body: JSON.stringify(err) };
  }
}

// Entry point for CoddyKit's runnable environment
async function main() {
  console.log("Running simulated GetItem operation...");
  const testEvent = {
    userId: "user123" // ID of the item to retrieve
  };
  await handler(testEvent);
}

main();

Updating Data: The UpdateItem Op

The UpdateItem operation modifies existing attributes of an item or adds new attributes if they don't exist. It's more efficient than reading, modifying, and then putting the whole item back.

This example updates the email for an existing user.

// MOCK AWS SDK for local runnable example
const mockDynamoDB = {
  DocumentClient: function() {
    return {
      update: (params) => ({
        promise: () => {
          console.log("MOCK: Update item in table '" + params.TableName + "' with Key:", params.Key);
          console.log("MOCK: Update Expression:", params.UpdateExpression, "Values:", params.ExpressionAttributeValues);
          return Promise.resolve({ Attributes: { id: params.Key.id, email: "updated@example.com" } });
        }
      })
    };
  }
};

// Simulate the Lambda handler function
async function handler(event) {
  const ddb = new mockDynamoDB.DocumentClient();

  const params = {
    TableName: "MyUsersTable", // Replace with your table name
    Key: {
      id: event.userId // Primary key of the item to update
    },
    UpdateExpression: "set email = :e",
    ExpressionAttributeValues: {
      ":e": event.newEmail
    },
    ReturnValues: "UPDATED_NEW" // Return the new values of updated attributes
  };

  try {
    const data = await ddb.update(params).promise();
    console.log("Updated item (mock):", data.Attributes);
    return { statusCode: 200, body: JSON.stringify(data.Attributes) };
  } catch (err) {
    console.error("Operation failed (mock):", err);
    return { statusCode: 500, body: JSON.stringify(err) };
  }
}

// Entry point for CoddyKit's runnable environment
async function main() {
  console.log("Running simulated UpdateItem operation...");
  const testEvent = {
    userId: "user123",
    newEmail: "alice.new@example.com"
  };
  await handler(testEvent);
}

main();

Deleting Data: The DeleteItem Op

When you no longer need an item, you can remove it using the DeleteItem operation. Just like GetItem, you must specify the full primary key of the item to delete.

Be careful with deletions, as they are permanent!

// MOCK AWS SDK for local runnable example
const mockDynamoDB = {
  DocumentClient: function() {
    return {
      delete: (params) => ({
        promise: () => {
          console.log("MOCK: Delete item from table '" + params.TableName + "' with Key:", params.Key);
          return Promise.resolve({ success: true });
        }
      })
    };
  }
};

// Simulate the Lambda handler function
async function handler(event) {
  const ddb = new mockDynamoDB.DocumentClient();

  const params = {
    TableName: "MyUsersTable", // Replace with your table name
    Key: {
      id: event.userId // Primary key of the item to delete
    }
  };

  try {
    const data = await ddb.delete(params).promise();
    console.log("Item deleted successfully (mock).");
    return { statusCode: 200, body: JSON.stringify(data) };
  } catch (err) {
    console.error("Operation failed (mock):", err);
    return { statusCode: 500, body: JSON.stringify(err) };
  }
}

// Entry point for CoddyKit's runnable environment
async function main() {
  console.log("Running simulated DeleteItem operation...");
  const testEvent = {
    userId: "user123" // ID of the item to delete
  };
  await handler(testEvent);
}

main();

Quick Check: DynamoDB Actions

You've learned about basic DynamoDB operations. Let's test your understanding!

Recap: Lambda + DynamoDB

Great job! You've learned how to integrate AWS Lambda with Amazon DynamoDB for powerful serverless applications.

  • DynamoDB provides a scalable NoSQL database.
  • Lambda functions need IAM permissions to interact with DynamoDB tables.
  • You can perform common operations like PutItem (create/replace), GetItem (read), UpdateItem (modify), and DeleteItem (remove).

This integration is fundamental for building dynamic, event-driven serverless backends!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengintegrasikan DynamoDB” gratis?

Ya — teks lengkap “Mengintegrasikan DynamoDB” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Serverless AWS Lambda Development, upgrade ke CoddyKit PRO. Kursus Serverless AWS Lambda Development mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengintegrasikan DynamoDB”?

Hubungkan fungsi Lambda ke Amazon DynamoDB, basis data NoSQL yang dikelola sepenuhnya, untuk penyimpanan dan pengambilan data berperforma tinggi serta mudah diskalakan dalam aplikasi tanpa server. Kamu berlatih Serverless AWS Lambda Development dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Serverless AWS Lambda Development?

Tidak diperlukan pengalaman sebelumnya. Serverless AWS Lambda Development di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Mengintegrasikan DynamoDB” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Serverless AWS Lambda Development ini?

Ya. Setiap pelajaran Serverless AWS Lambda Development menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Mengintegrasikan DynamoDB
  2. S3 untuk Penyimpanan File dan Peristiwa
  3. Memilih Penyimpanan Data yang Tepat
  4. Penyimpanan Cache dengan Amazon ElastiCache dan DAX
← Kembali ke Serverless AWS Lambda Development