https://github.com/iambotcoder/serverless-crud-api
A serverless CRUD API leveraging AWS Lambda, API Gateway, and DynamoDB for seamless and scalable database operations.
https://github.com/iambotcoder/serverless-crud-api
Last synced: 2 months ago
JSON representation
A serverless CRUD API leveraging AWS Lambda, API Gateway, and DynamoDB for seamless and scalable database operations.
- Host: GitHub
- URL: https://github.com/iambotcoder/serverless-crud-api
- Owner: iambotcoder
- Created: 2025-01-14T01:16:00.000Z (about 1 year ago)
- Default Branch: master
- Last Pushed: 2025-02-20T17:06:54.000Z (about 1 year ago)
- Last Synced: 2025-02-20T18:23:07.102Z (about 1 year ago)
- Homepage:
- Size: 29.3 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# 🌐 Lambda API Gateway Integration with DynamoDB 🚀
---
## 📖 Introduction
This project demonstrates the implementation of a serverless API using **AWS services** such as **API Gateway**, **Lambda**, and **DynamoDB**. It showcases how to build a backend system without managing servers, utilizing these components to handle HTTP requests, execute backend logic, and interact with a NoSQL database.
The key components of this project are:
- **API Gateway**: Acts as an HTTP interface for accessing Lambda functions. 🌐
- **AWS Lambda**: Runs backend logic for processing API requests. 🧑💻
- **DynamoDB**: Serves as the NoSQL database for storing and retrieving data. 📊
---
## 📑 Table of Contents
- [Overview](#overview)
- [Prerequisites](#Prerequisites) 🔑
- [Architecture Diagram](#architecture-diagram) 🏗️
- [Implementation Steps](#implementation-steps) 🔨
- [Step 1: Create IAM Policy and Role](#step-1-create-iam-policy-and-role) 🛠️
- [Step 2: Deploy the Lambda Function](#step-2-deploy-the-lambda-function) 🚀
- [Step 3: Configure API Gateway](#step-3-configure-api-gateway) ⚙️
- [Step 4: Test the Solution with Postman](#step-4-test-the-solution-with-postman) 🧪
- [Screenshots](#screenshots) 📸
- [Conclusion](#conclusion) ✅
---
## 🔑 Prerequisites
Before you start, ensure you have the following:
- An AWS account 🌍
- Basic knowledge of AWS services: Lambda, API Gateway, and DynamoDB 📚
- Installed tools: [Postman](https://www.postman.com/) 🔧
---
## 🏗️ Architecture Diagram
Provide a high-level architecture diagram of the project setup.
---
### 🛠️ Supported Operations
The API supports the following operations:
- **DynamoDB CRUD Operations**:
- `create`, `read`, `update`, `delete`, `list` 🔄
- **Testing Operations**:
- `echo` (returns the input as-is) 🔊
- `ping` (returns "pong") 🏓
---
### ⚙️ Steps to Implement
### 1️⃣ Setup: IAM Role Creation
- **Create an IAM Role (lambda-apigateway-role):**
1. Go to the AWS Management Console and navigate to the **IAM** service. 🛡️
2. Create a new policy with the following JSON 📝
3. Attach the following custom policy JSON to provide necessary permissions:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Stmt1428341300017",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:UpdateItem"
],
"Effect": "Allow",
"Resource": "*"
},
{
"Sid": "",
"Resource": "*",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Effect": "Allow"
}
]
}
```
4. Save the policy with the name **lambda-apigateway-policy**. 💾
5. Go to the Roles section in IAM and create a new role. 🎭
6. Attach the **lambda-apigateway-policy** to the role. 🔑
---
### 2️⃣ Create Lambda Function
- **Lambda Function (LambdaFunctionOverHttps):**
1. Go to the **AWS Lambda** console and click on **Create Function**. 🆕
2. Choose the following settings:
- **Author from scratch**: Yes. 📝
- **Runtime**: Python 3.13 or a newer supported version as the runtime. 🐍
- **Execution Role**: Use the previously created `lambda-apigateway-role`. 🎭
3. Use the following Python code snippet for the function:
```python
from __future__ import print_function
import boto3
import json
print('Loading function')
def lambda_handler(event, context):
operation = event['operation']
if 'tableName' in event:
dynamo = boto3.resource('dynamodb').Table(event['tableName'])
operations = {
'create': lambda x: dynamo.put_item(**x),
'read': lambda x: dynamo.get_item(**x),
'update': lambda x: dynamo.update_item(**x),
'delete': lambda x: dynamo.delete_item(**x),
'list': lambda x: dynamo.scan(**x),
'echo': lambda x: x,
'ping': lambda x: 'pong'
}
if operation in operations:
return operations[operation](event.get('payload'))
else:
raise ValueError('Unrecognized operation "{}"'.format(operation))
```
4. Save and deploy the function. 🚀
---
### 3️⃣ Test Lambda Function
- Test the Lambda function using the **echo** operation:
- Sample test event JSON:
```json
{
"operation": "echo",
"payload": {
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
}
```
- Expected output:
```json
{
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
```
---
### 4️⃣ Create DynamoDB Table
- **DynamoDB Table (lambda-apigateway):**
1. Go to the **DynamoDB** console and click on **Create Table**. 📊
2. Set the table name to `lambda-apigateway`. 🏷️
3. Define the **Primary Key**:
- Partition Key: `id` (String). 🔑
---
### 5️⃣ Create API Gateway
- **API Gateway Setup:**
1. Navigate to **API Gateway**, choose REST API and create a new API: 🎛️
- Name: `DynamoDBOperations`. 💬
2. Add a new resource:
- Resource Name: `DynamoDBManager`. 🗂️
3. Add a method to the resource:
- Method: `POST`. 📨
4. Integrate the POST method with the Lambda function:
- Select **Lambda Function** as the integration type. 🔗
- Specify the function name (`LambdaFunctionOverHttps`). 🖥️
---
### 6️⃣ Deploy API
- **Deploy the API:**
1. Go to the **Actions** menu and select **Deploy API**. 🏁
2. Create a new stage: `prod`. 🚀
3. Retrieve the **Invoke URL** for the deployed API. 🌐
---
## 🧪 Running the Solution with Postman
1. Open Postman and create a new request with the following configurations:
- HTTP Method: POST ✉️
- URL: `/DynamoDBManager` 🌍
2. Test different scenarios using the following payloads:
- **Create Operation** 💾
```json
{
"operation": "create",
"tableName": "lambda-apigateway",
"payload": {
"Item": {
"id": "123",
"value": "sample data"
}
}
}
```
- Outcome 🎉
- **Read Operation** 📚
```json
{
"operation": "read",
"tableName": "lambda-apigateway",
"payload": {
"Key": {
"id": "123"
}
}
}
```
- **Update Operation** ✏️
```json
{
"operation": "update",
"tableName": "lambda-apigateway",
"payload": {
"Key": {
"id": "56789ABCD"
},
"UpdateExpression": "set #num = :val1",
"ExpressionAttributeValues": {
":val1": 42
},
"ExpressionAttributeNames": {
"#num": "number"
},
"ReturnValues": "UPDATED_NEW"
}
}
```
- outcome ✅
- Delete Operation
```json
{
"operation": "delete",
"tableName": "lambda-apigateway",
"payload": {
"Key": {
"id": "56789ABCD"
}
}
}
```
- outcome 🏁
- Verify the results in the DynamoDB console. 📊
---
### Cleanup
- Delete the created resources to avoid unnecessary costs:
1. DynamoDB table.📅
2. Lambda function.🔌
3. API Gateway resources.🚫
---
### ✅ Conclusion
This guide demonstrates how to integrate AWS Lambda with API Gateway and DynamoDB to perform database operations in a serverless architecture. It provides a scalable and efficient approach to manage CRUD functionalities with minimal infrastructure management.
## 👨🏫 Instructor
This project was guided by **Rajdeep Saha**, who provided valuable mentorship throughout the process.