Boto3 (Python) client vs resource in DynamoDB - Visual Side-by-Side Comparison

Concept Flow - Boto3 (Python) client vs resource

Start

↓

Choose Boto3 Interface

↓

Client: Low-level API

↓

Call service methods

↓

Receive raw response

↓

Resource: High-level API

↓

Use Python objects

↓

Call methods on objects

↓

Simplified interaction

↓

End

You start by choosing between client or resource interface. Client calls low-level service methods and returns raw data. Resource provides Python objects with easy methods for simpler use.

Execution Sample

DynamoDB

import boto3
client = boto3.client('dynamodb')
resource = boto3.resource('dynamodb')
table_client = client.get_item(TableName='MyTable', Key={'Id': {'S': '123'}})
table_resource = resource.Table('MyTable')
item = table_resource.get_item(Key={'Id': '123'})

This code shows how to get an item from DynamoDB using both client and resource interfaces.

Execution Table

Step	Action	Interface	Input	Output
1	Create client	client	service='dynamodb'	client object created
2	Create resource	resource	service='dynamodb'	resource object created
3	Call get_item	client	TableName='MyTable', Key={'Id': {'S': '123'}}	Raw response dict with item data
4	Access Table object	resource	Table('MyTable')	Table resource object
5	Call get_item	resource	Key={'Id': '123'}	Response dict with item data
6	Extract item	resource	response['Item']	Python dict with item attributes
7	End	-	-	-

💡 All steps complete, showing difference in method calls and outputs between client and resource.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
client	None	client object	client object	client object	client object	client object	client object	client object
resource	None	None	resource object	resource object	resource object	resource object	resource object	resource object
table_client	None	None	None	raw response dict	raw response dict	raw response dict	raw response dict	raw response dict
table_resource	None	None	None	None	Table resource object	Table resource object	Table resource object	Table resource object
item	None	None	None	None	None	response dict	Python dict	Python dict

Key Moments - 2 Insights

Why does the client get_item require the key value wrapped in {'S': '123'} but resource does not?

The client interface uses low-level API requiring explicit data types like {'S': '123'} for strings, as shown in step 3. The resource interface abstracts this, letting you pass plain Python types, as in step 5.

Why is the output from client get_item called 'raw response'?

Because client returns the full low-level response dictionary directly from AWS, including metadata and typed attributes (step 3). Resource simplifies this to Python dicts with attribute values (step 6).

Visual Quiz - 3 Questions

Look at the execution table, what type of object is 'resource' after step 2?

A A low-level client object

B A high-level resource object

C A raw response dictionary

D A Python dict with item data

💡 Hint

Check the output column at step 2 in the execution_table.

At which step does the client interface return the raw response dict?

A Step 3

B Step 1

C Step 5

D Step 6

💡 Hint

Look at the output column for step 3 in the execution_table.

If you want simpler Python objects to work with DynamoDB items, which interface should you use?

A Client interface

B Both are equally simple

C Resource interface

D Neither, use raw HTTP calls

💡 Hint

Refer to the concept_flow and the difference in outputs in execution_table steps 5 and 6.

Concept Snapshot

Boto3 client is low-level, needs explicit data types and returns raw AWS responses.
Boto3 resource is high-level, uses Python objects and simplifies data handling.
Use client for full control, resource for easier coding.
Client methods require detailed parameters; resource methods accept Python types.
Resource wraps tables and items as objects with methods.
Choose based on your comfort and needs.

Full Transcript

This visual execution compares Boto3 client and resource interfaces for DynamoDB in Python. First, we create both client and resource objects. The client calls get_item with explicit typed keys and returns a raw response dictionary. The resource accesses a Table object and calls get_item with plain Python keys, returning a simplified Python dictionary. Variables track these objects and responses step-by-step. Key moments clarify why client needs typed keys and why resource is easier to use. The quiz tests understanding of object types, response steps, and interface choice. The snapshot summarizes the main differences and usage tips.

Practice

1. What is the main difference between Boto3 client and resource when working with DynamoDB?

easy

A. client is deprecated, resource is the new standard.

B. client is only for S3, resource is only for DynamoDB.

C. client is low-level and matches AWS API calls exactly, while resource is higher-level and easier to use.

D. client automatically manages retries, resource does not.

Solution

1. Step 1: Understand the roles of client and resource

   The client provides direct access to AWS service APIs with low-level calls, matching the exact API structure.

2. Step 2: Compare with resource abstraction

   The resource offers a higher-level, object-oriented interface that simplifies interactions with AWS services like DynamoDB.

3. Final Answer:

   client is low-level and matches AWS API calls exactly, while resource is higher-level and easier to use. -> Option C

4. Quick Check:

   client = low-level, resource = high-level [OK]

Hint: Client = low-level API, resource = easier Python objects [OK]

Common Mistakes:

• Thinking client is deprecated
• Confusing client and resource usage scope
• Assuming resource has full API coverage

2. Which of the following is the correct way to create a DynamoDB resource using Boto3 in Python?

easy

A. dynamodb = boto3.client('dynamodb')

B. dynamodb = boto3.resource('dynamodb')

C. dynamodb = boto3.connect('dynamodb')

D. dynamodb = boto3.session('dynamodb')

Solution

1. Step 1: Recall Boto3 resource creation syntax

   To create a resource, use boto3.resource('service_name'). For DynamoDB, it is boto3.resource('dynamodb').

2. Step 2: Identify incorrect options

   boto3.client('dynamodb') creates a client, not a resource. connect and session are not valid Boto3 methods for this purpose.

3. Final Answer:

   dynamodb = boto3.resource('dynamodb') -> Option B

4. Quick Check:

   Resource creation uses boto3.resource('service') [OK]

Hint: Use boto3.resource('dynamodb') for resource creation [OK]

Common Mistakes:

• Using boto3.client instead of boto3.resource
• Trying to use boto3.connect which doesn't exist
• Confusing session with resource creation

3. Given the following code snippet using Boto3 resource:

import boto3
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Users')
response = table.get_item(Key={'UserId': '123'})
print(response['Item']['Name'])

What will this code print if the item exists with Name 'Alice'?

medium

A. 123

B. None

C. KeyError

D. Alice

Solution

1. Step 1: Understand the get_item call on resource Table

   The get_item method returns a dictionary with an 'Item' key containing the requested item if it exists.

2. Step 2: Access the 'Name' attribute from the returned item

   The code prints response['Item']['Name'], which will be 'Alice' if the item exists with that attribute.

3. Final Answer:

   Alice -> Option D

4. Quick Check:

   response['Item']['Name'] = Alice [OK]

Hint: get_item returns dict with 'Item' key holding data [OK]

Common Mistakes:

• Assuming response is just the item dict
• Forgetting to check 'Item' key
• Confusing client and resource response formats

4. What is wrong with this Boto3 client code snippet for DynamoDB?

import boto3
client = boto3.client('dynamodb')
response = client.get_item(TableName='Users', Key={'UserId': '123'})
print(response['Item'])

medium

A. The Key value should be a dict with attribute type, e.g., {'UserId': {'S': '123'}}

B. TableName should be lowercase 'users'

C. client.get_item does not exist, use resource instead

D. print statement should be print(response.Item)

Solution

1. Step 1: Check the Key format for client get_item

   When using the low-level client, the Key must specify attribute types, e.g., {'UserId': {'S': '123'}}.

2. Step 2: Identify other issues

   TableName is case-sensitive and usually capitalized as in the table creation. The method get_item exists on client. The print syntax is correct for a dict.

3. Final Answer:

   The Key value should be a dict with attribute type, e.g., {'UserId': {'S': '123'}} -> Option A

4. Quick Check:

   Client Key needs attribute type dict [OK]

Hint: Client Key needs attribute type dict like {'S': 'value'} [OK]

Common Mistakes:

• Using simple dict for Key with client
• Assuming client and resource Key formats are same
• Ignoring case sensitivity of TableName

5. You want to update an item attribute in DynamoDB using Boto3. Which approach correctly uses the resource and client to update the attribute 'Age' to 30 for UserId '123'?

hard

A. Resource: table.update_item(Key={'UserId': '123'}, UpdateExpression='SET Age = :val', ExpressionAttributeValues={':val': 30})
Client: client.update_item(TableName='Users', Key={'UserId': {'S': '123'}}, UpdateExpression='SET Age = :val', ExpressionAttributeValues={':val': {'N': '30'}})

B. Resource: table.update_item(Key={'UserId': {'S': '123'}}, UpdateExpression='SET Age = :val', ExpressionAttributeValues={':val': {'N': '30'}})
Client: client.update_item(TableName='Users', Key={'UserId': '123'}, UpdateExpression='SET Age = :val', ExpressionAttributeValues={':val': 30})

C. Resource: table.put_item(Item={'UserId': '123', 'Age': 30})
Client: client.put_item(TableName='Users', Item={'UserId': {'S': '123'}, 'Age': {'N': '30'}})

D. Resource: table.update_item(Key={'UserId': '123'}, UpdateExpression='ADD Age :val', ExpressionAttributeValues={':val': 30})
Client: client.update_item(TableName='Users', Key={'UserId': {'S': '123'}}, UpdateExpression='ADD Age :val', ExpressionAttributeValues={':val': {'N': '30'}})

Solution

1. Step 1: Understand resource update_item usage

   Resource expects simple Python types for Key and ExpressionAttributeValues, so {'UserId': '123'} and {':val': 30} are correct.

2. Step 2: Understand client update_item usage

   Client requires attribute types in Key and ExpressionAttributeValues, so {'UserId': {'S': '123'}} and {':val': {'N': '30'}} are needed.

3. Step 3: Confirm UpdateExpression syntax

   Using SET Age = :val is correct for updating an attribute value.

4. Final Answer:

   Resource and client update_item calls with correct Key and ExpressionAttributeValues formats as in option A -> Option A

5. Quick Check:

   Resource uses plain types, client uses typed dicts [OK]

Hint: Resource uses plain dicts; client needs typed attribute dicts [OK]

Common Mistakes:

• Mixing client and resource Key formats
• Using ADD instead of SET for update
• Passing raw values in client ExpressionAttributeValues