Serverless AWS Lambda Development · Lekcja

Integracja z DynamoDB

Połącz funkcje Lambda z Amazon DynamoDB, w pełni zarządzaną bazą NoSQL, aby zapewnić wysokowydajne i skalowalne przechowywanie oraz pobieranie danych w aplikacjach serverless.

Integracja z DynamoDB to bezpłatna lekcja Serverless AWS Lambda Development na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Serverless AWS Lambda Development, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Serverless AWS Lambda Development zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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!

Często zadawane pytania

Czy lekcja „Integracja z DynamoDB” jest bezpłatna?

Tak — pełny tekst „Integracja z DynamoDB” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Serverless AWS Lambda Development, przejdź na CoddyKit PRO. Kurs Serverless AWS Lambda Development zawiera 4 lekcji w sumie.

Co nauczysz się w „Integracja z DynamoDB”?

Połącz funkcje Lambda z Amazon DynamoDB, w pełni zarządzaną bazą NoSQL, aby zapewnić wysokowydajne i skalowalne przechowywanie oraz pobieranie danych w aplikacjach serverless. Ćwiczysz Serverless AWS Lambda Development z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Serverless AWS Lambda Development?

Nie wymagamy żadnego doświadczenia. Serverless AWS Lambda Development w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Integracja z DynamoDB”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Serverless AWS Lambda Development?

Tak. Każda lekcja Serverless AWS Lambda Development zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Integracja z DynamoDB
S3 do przechowywania plików i obsługi zdarzeń
Wybór odpowiedniego magazynu danych
Buforowanie za pomocą Amazon ElastiCache i DAX

← Powrót do Serverless AWS Lambda Development