Serverless AWS Lambda Development · Aula

Integração com o DynamoDB

Conecte funções Lambda ao Amazon DynamoDB, um banco de dados NoSQL totalmente gerenciado, para armazenamento e recuperação de dados escaláveis e de alto desempenho em aplicativos sem servidor.

Integração com o DynamoDB é uma aula grátis de Serverless AWS Lambda Development no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Serverless AWS Lambda Development, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Serverless AWS Lambda Development inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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!

Perguntas Frequentes

A aula “Integração com o DynamoDB” é grátis?

Sim — o texto completo de “Integração com o DynamoDB” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Serverless AWS Lambda Development, atualize para CoddyKit PRO. O curso de Serverless AWS Lambda Development inclui 4 aulas no total.

O que vou aprender em “Integração com o DynamoDB”?

Conecte funções Lambda ao Amazon DynamoDB, um banco de dados NoSQL totalmente gerenciado, para armazenamento e recuperação de dados escaláveis e de alto desempenho em aplicativos sem servidor. Você pratica Serverless AWS Lambda Development com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Serverless AWS Lambda Development?

Nenhuma experiência prévia é necessária. Serverless AWS Lambda Development no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Integração com o DynamoDB”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Serverless AWS Lambda Development?

Sim. Cada aula de Serverless AWS Lambda Development inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Integração com o DynamoDB
S3 para armazenamento de arquivos e eventos
Escolhendo o armazenamento de dados adequado
Armazenamento em Cache com Amazon ElastiCache e DAX

← Voltar para Serverless AWS Lambda Development