DynamoDB CRUD Operations

Welcome to the next step in your AWS development journey! So far, you have learned the boto3 Universal Pattern for connecting to AWS services and how to work with S3 for cloud file storage. In this lesson, we will focus on DynamoDB, Amazon’s managed NoSQL database service.

DynamoDB is designed for fast and flexible data storage and retrieval. It is often used for applications that need to handle large amounts of data with low latency, such as user profiles, session data, or product catalogs. By the end of this lesson, you will know how to create a DynamoDB table and perform the four basic operations: Create, Read, Update, and Delete (CRUD).

This lesson will build on your experience with the boto3 library in Python but will focus only on what you need to get started with DynamoDB. Let’s get started!

Before we dive into DynamoDB, let’s quickly remind ourselves how we use boto3 to connect to AWS services in Python. You have already used boto3 to work with S3, and the process is very similar for DynamoDB.

To use boto3, you typically import the library and create a resource or client for the AWS service you want to use. For example, to work with S3, you wrote:

import boto3

s3 = boto3.resource('s3')

For DynamoDB, you will use:

import boto3

dynamodb = boto3.resource('dynamodb')

This line creates a DynamoDB resource object, which you will use to interact with your tables. On CodeSignal, boto3 is already installed, so you do not need to worry about setup here, but remember how to do this for your own environment.

Let’s start by creating a DynamoDB table. In DynamoDB, a table is where your data is stored. Each table needs a name and a primary key. The primary key uniquely identifies each item in the table.

Here’s how you can create a table named Users_<random> with a primary key called user_id:

import uuid
import boto3

dynamodb = boto3.resource('dynamodb')
TABLE_NAME = f"Users_{uuid.uuid4().hex[:8]}"

table = dynamodb.create_table(
    TableName=TABLE_NAME,
    KeySchema=[{"AttributeName": "user_id", "KeyType": "HASH"}],
    AttributeDefinitions=[{"AttributeName": "user_id", "AttributeType": "S"}],
    BillingMode='PAY_PER_REQUEST'
)

Let’s break this down:

• TableName=TABLE_NAME sets the name of the table. Here, we use a random suffix to avoid name conflicts.
• KeySchema defines the primary key. In this case, user_id is the only key, and it is a "HASH" key (the partition key).
• AttributeDefinitions tells DynamoDB that user_id is a string ("S").
• BillingMode='PAY_PER_REQUEST' means you pay only for what you use, which is good for learning and small projects.

After creating the table, you need to wait until it is ready to use. Here’s a helper function to do that:

import time

def wait_active(name):
    client = boto3.client('dynamodb')
    for _ in range(30):
        if client.describe_table(TableName=name)["Table"]["TableStatus"] == "ACTIVE":
            return
        time.sleep(2)
    raise TimeoutError("Table not active in time")

You call this function after creating the table:

wait_active(TABLE_NAME)
print("Table created:", TABLE_NAME)

Sample Output:

Table created: Users_1a2b3c4d

Now that you have a table, let’s go through the four basic operations: Create, Read, Update, and Delete.

To add a new item (a row) to your table, use the put_item method:

table.put_item(Item={"user_id": "u-123", "name": "Ada", "email": "ada@example.com"})

This adds a user with ID u-123, name Ada, and email ada@example.com to the table.

To get an item by its primary key, use get_item:

response = table.get_item(Key={"user_id": "u-123"})
print("Read:", response.get("Item"))

Sample Output:

Read: {'user_id': 'u-123', 'name': 'Ada', 'email': 'ada@example.com'}

To update an item, use update_item. For example, to change the email address:

updated = table.update_item(
    Key={"user_id": "u-123"},
    UpdateExpression="SET email = :e",
    ExpressionAttributeValues={":e": "ada.lovelace@example.com"},
    ReturnValues="ALL_NEW"
)
print("Updated:", updated["Attributes"])

• UpdateExpression tells DynamoDB what to change.
• ExpressionAttributeValues provides the new value.
• ReturnValues="ALL_NEW" returns the updated item.

Sample Output:

Updated: {'user_id': 'u-123', 'name': 'Ada', 'email': 'ada.lovelace@example.com'}

To delete an item, use delete_item:

table.delete_item(Key={"user_id": "u-123"})
print("Deleted user u-123")

Sample Output:

Deleted user u-123

It’s important to clean up resources you no longer need. To delete the table:

table.delete()
print("Dropped table:", TABLE_NAME)

Sample Output:

Dropped table: Users_1a2b3c4d

Deleting unused tables helps you avoid unnecessary costs and keeps your AWS account tidy.

In this lesson, you learned how to create a DynamoDB table and perform the four basic CRUD operations using Python and boto3:

• Creating a table with a primary key
• Adding, reading, updating, and deleting items
• Cleaning up by deleting the table

You saw step-by-step code examples and learned what each part does. In the next practice exercises, you will get hands-on experience with these operations. Remember to pay attention to table names and primary keys, and always clean up your resources when you are done. Good luck, and enjoy working with DynamoDB!