CRUD Operations Using AWS DynamoDB with Flask APIs and Boto3

Last Updated on January 1, 2024

Table of Contents

Introduction

In this tutorial, we will build a demo application together; learn about the Flask framework, Boto3 library, REST APIs, and AWS DynamoDB. If you are new at using AWS DynamoDB with Flask APIs and Boto3, don’t worry! We are here to help you learn through this tutorial.

Goal: Using AWS DynamoDB with Flask APIs and Boto3

Before knowing how to implement CRUD operations on DynamoDB using Flask APIs, let’s see the video and know what we will build.

Prerequisites

We assume that you have prior knowledge of the following:

Python3 Programming
pip
Flask
AWS and IAM

To get started with this tutorial, make sure you have the following as well:

DynamoDB local
Python
IDE

Technologies to use

We will be using the following technologies:

Flask
Boto3
DynamoDB

Let’s start the implementation of AWS DynamoDB with Flask APIs and Boto3. Here’s my system setup:

Ubuntu 20.04 OS
Python 3.8+
Postman

Installing Flask and Boto3 using pip

Install the packages to build REST APIs

Flask
Boto3

An efficient way: Create a requirements.txt file and list all the packages into it. You can also declare the versions of the packages wherever necessary.

Copy Text

flask==1.1.2
boto3==1.17.52

Use the above file to install all the listed packages with pip.

Copy Text

pip install -r requirements.txt

Create new directory

Create a new directory and navigate to it using the below commands

Copy Text

mkdir mydynamoDBflaskproject
cd mydynamoDBflaskproject

Set Up AWS Credentials

Create a new file named config.py

Copy Text

touch config.py

NOTE– it is advised to use a virtual environment and perform all the setup and installation inside it to avoid unnecessary pollution of the Operating System. However, it is not a mandatory process but a healthy practice.

Now, include your AWS credentials in a python file named config.py:

// config.py

Copy Text

AWS_ACCESS_KEY_ID = 'youraccessid'
AWS_SECRET_ACCESS_KEY = 'yoursecretaccesskey'
REGION_NAME = 'yourregionname'

AWS_ACCESS_KEY_ID: AWS access key associated with an IAM role or user.
AWS_SECRET_ACCESS_KEY: A secret key associated with the access key. This is essentially the “password” for the specified access key.
REGION_NAME: The default region when creating new connections.

Configuration Set Up for APIs

Create a new file named “controller.py.”

Copy Text

touch controller.py

NOTE– while executing these commands in the terminal, make sure you do it inside the virtual environment named “venv” we created earlier.

Open the file and paste the following code.

// controller.py

Copy Text

from boto3 import resource
import config

The resource package provides higher-level object-oriented service access. It provides better abstraction and makes your code easier to comprehend.

The config package will import all the AWS configurations that we set in the config.py file.

Now it’s time to configure settings for the Movie API

// controller.py

Copy Text

AWS_ACCESS_KEY_ID = config.AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY = config.AWS_SECRET_ACCESS_KEY
REGION_NAME = config.REGION_NAME
 
resource = resource(
   'dynamodb',
   aws_access_key_id     = AWS_ACCESS_KEY_ID,
   aws_secret_access_key = AWS_SECRET_ACCESS_KEY,
   region_name           = REGION_NAME
)

Create a Table using create_table()

As part of the next step, let’s create a function that would create a new table called create_table().

// controller.py

Copy Text

def create_table_movie():   
   table = resource.create_table(
       TableName = 'Movie', # Name of the table
       KeySchema = [
           {
               'AttributeName': 'id',
               'KeyType'      : 'HASH' #RANGE = sort key, HASH = partition key
           }
       ],
       AttributeDefinitions = [
           {
               'AttributeName': 'id', # Name of the attribute
               'AttributeType': 'N'   # N = Number (B= Binary, S = String)
           }
       ],
       ProvisionedThroughput={
           'ReadCapacityUnits'  : 10,
           'WriteCapacityUnits': 10
       }
   )
   return table

To access or modify the table’s entries, we have to get the table using the resource.

Copy Text

MovieTable = resource.Table('Movie')

Once done, let’s get started for CRUD operations using Flask APIs on DynamoDB.

Supercharge your projects with our elite AWS developers!
Elevate your business to new heights with cutting-edge solutions and unparalleled expertise. Let’s transform your vision into reality— hire AWS developers from us today for a journey of innovation and success!

CRUD Operations using AWS DynamoDB with Flask APIs and Boto3

CREATE

Now, let’s add a new entry in the Movie table.

Copy Text

def write_to_movie(id, title, director):
   response = MovieTable.put_item(
       Item = {
           'id'     : id,
           'title'  : title,
           'director' : director,
           'upvotes'  : 0
       }
   )
 return response

READ

Read an entry from the Movie table.

Copy Text

def read_from_movie(id):
   response = MovieTable.get_item(
       Key = {
           'id'     : id
       },
       AttributesToGet = [
           'title,’,’’ 'director'
   )
 return response

UPDATE

Update an entry in the Movie table using the ‘id’ attribute.

Copy Text

def update_in_movie(id, data:dict):
 
   response = MovieTable.update_item(
       Key = {
           'id': id
       },
       AttributeUpdates={
           'title': {
               'Value'  : data['title'],
               'Action' : 'PUT' 
           },
           'director': {
               'Value'  : data['director'],
               'Action' : 'PUT'
           }
       },
 
       ReturnValues = "UPDATED_NEW"  # returns the new updated values
   )
 
  return response

Update ‘upvotes’ property for an entry.

Copy Text

def upvote_a_movie(id):
 
   response = MovieTable.update_item(
       Key = {
           'id': id
       },
       AttributeUpdates = {
           'upvotes': {
               'Value'  : 1,
               'Action' : 'ADD'
           }
       },
 
       ReturnValues = "UPDATED_NEW"
   )
 
   response['Attributes']['upvotes'] = int(response['Attributes']['upvotes'])
 
 return response

DELETE

Delete an entry from the Movie collection.

Copy Text

def delete_from_movie(id):
 
   response = MovieTable.delete_item(
       Key = {
           'id': id
       }
   )
 
 return response

Let’s create a linear flask application with APIs to perform operations on the Movie collection we will create using our create_table_movie() function.

// app.py

Copy Text

import controller as dynamodb
 
 
@app.route('/')
def root_route():
   dynamodb.create_table_movie()
   return 'Table created'
 
@app.route('/movie', methods=['POST'])
def add_movie():
   data = request.get_json()
   response = dynamodb.write_to_movie(data['id'], data['title'], data['director'])   
   if (response['ResponseMetadata']['HTTPStatusCode'] == 200):
       return {
           'msg': 'Add Movie successful',
       }
   return { 
       'msg': 'error occurred',
       'response': response
   }
 
@app.route('/movie/', methods=['GET'])
def get_movie(id):
   response = dynamodb.read_from_movie(id)
   if (response['ResponseMetadata']['HTTPStatusCode'] == 200):
       if ('Item' in response):
           return { 'Item': response['Item'] }
       return { 'msg' : 'Item not found!' }
   return {
       'msg': 'error occurred',
       'response': response
   }
 
@app.route('/movie/', methods=['DELETE'])
def delete_movie(id):
   response = dynamodb.delete_from_movie(id)
   if (response['ResponseMetadata']['HTTPStatusCode'] == 200):
       return {
           'msg': 'Delete successful',
       }
   return { 
       'msg': 'error occurred',
       'response': response
   }
 
@app.route('/movie/', methods=['PUT'])
def update_movie(id):
 
   data = request.get_json()
   response = dynamodb.update_in_movie(id, data)
   if (response['ResponseMetadata']['HTTPStatusCode'] == 200):
       return {
           'msg'                : update successful',
           'response'           : response['ResponseMetadata'],
           'ModifiedAttributes' : response['Attributes']
       }
   return {
       'msg'      : ‘error occurred',
       'response' : response
   }  
 
@app.route('/upvote/movie/', methods=['POST'])
def upvote_movie(id):
   response = dynamodb.upvote_a_movieMovie(id)
   if (response['ResponseMetadata']['HTTPStatusCode'] == 200):
       return {
           'msg'      : 'Upvote successful',
           'response' : response['ResponseMetadata'],
           'Upvotes'    : response['Attributes']['upvotes']
       }
   return {
       'msg'      : ‘error occurred',
       'response' : response
  }

Now run the app.py file by using the following command inside the virtual environment

Copy Text

python app.py

The entire source code is available here: flask-dynamoDB-boto3-example. Feel free to clone the repository and play around with code.

Conclusion

I hope the tutorial for using AWS DynamoDB with Flask APIs and Boto3 was helpful, and you have developed your demo application as well. For more such tutorials, you can visit the Python tutorials page to explore basic and advanced knowledge.

In case you need any further guidance or a helping hand for your Python application without wasting a second, contact Bacancy and hire Python developer. We have dedicated and experienced python developers who have optimum problem-solving skills.

Python Tutorials

Build Your Agile Team

Hire Skilled Developer From Us

AWS Cost Optimization:Best Practices to Reduce Your AWS Bill By 30%

Expand Your Digital Horizons With Us

Expand Your Digital Horizons With Us

Start a new project or take an existing one to the next level. Get in touch to start small, scale-up, and go Agile.

[email protected]

Your Success Is Guaranteed !

We accelerate the release of digital product and guaranteed their success

We Use Slack, Jira & GitHub for Accurate Deployment and Effective Communication.

Media Coverage

edumanias

HOW REACT NATIVE IS EMPOWERING UBER EATS AND AIRBNB

Feb, 2022

makeanapp

7 Tips to Improve the Performance Of Your Flutter Web App & Desktop

Feb, 2022

Top 15 React Native Tools

Jan, 2022