DEV Community: Antai Okon-Otoyo

Serverless Deployment of a Simple Item Manager

Antai Okon-Otoyo — Thu, 21 Aug 2025 06:13:09 +0000

Overview

This project provides a guide on how to deploy a simple item manager using a serverless architecture.

At the heart of serverless computing with AWS sits the AWS Lambda, which allows you to forget about server or infrastructure management and provisioning.

AWS Lambda is a service that lets you run code without having to manage servers. So in a nutshell, AWS handles your compute processes while you provide the code.

In our project, we are going to make use of the following AWS services to deploy our simple item manager application:

AWS Lambda
Amazon API Gateway
Amazon DynamoDB
AWS Amplify

Architecture Diagram

Project Steps

1. Setting up the Lambda Function

On the AWS Management Console, you search for Lambda and then choose "Create Function"

Deploy your code in the editor provided.

2. Setting up DynamoDB Table for CRUD Operations

On the AWS Management Console, you search for DynamoDB and then choose "Create Table"

The partition key in Amazon DynamoDB is similar to a primary key in relational databases, but not exactly the same.
Every DynamoDB table must have a partition key, and it is used to determine the physical storage partition where the item will live (hence the name).
Also, please note that if the sort key is not defined, then the primary key must be unique.

Now that the DynamoDB table has been created successfully, we need to go back to the Lambda function and grant the Lambda execution role access to DynamoDB to allow the function to perform CRUD operations.

Under the Configuration tab of the Lambda function, navigate to Permissions and click on the execution role, which will redirect you to the IAM role to grant the necessary permissions.

On the IAM role, search for DynamoDB and select the AmazonDynamoDBFullAccess permission. Then, click "Add permissions".

In a production environment, it is important to ensure the principle of least privilege is applied when granting the necessary permissions. This would mean attaching an inline policy and granting only the permissions required by Lambda for your application.

We will also need to set an environment variable to enable our Lambda function to recognise our DynamoDB table.

3. Setting up API Gateway for Lambda Function

On the AWS Management Console, you search for and select API Gateway and then choose "Create an API".

We will need to choose an API type, and for the sake of this project, we are going to be using the REST API type

Create Resource paths and their respective HTTP methods that would be processed through them.

Enable CORS

After setting the API resources, we now have to deploy the API and get our API Invoke URL, which we can test with and use for invoking our lambda function.

Test the API to ensure the API is working as expected.

4. Setting up AWS Amplify to host our Frontend.

AWS Amplify is a set of tools and services provided by AWS that is designed to help developers build, deploy, and manage full-stack web and mobile applications quickly and easily.
We are going to use it in this project to quickly and easily host or deploy our item manager application.

Before setting up AWS Amplify, ensure the api.ts file in the services folder of your source code is updated with your API Invoke URL received after setting up and deploying your API.

On the AWS Management Console, you search for and select Amplify and then choose "Deploy an App"

If you've not used Amplify before, it would require you to integrate with your repository for deployment.

Please note that the frontend code has already been pushed to the GitHub repository and the API Invoke URL has been included in the necessary file as a variable to be called when performing crud operations.

Review the deployment before saving and deploying the code.

After saving and deploying, we can confirm that the application is working as expected, as seen in the screenshot below.

Challenges

Lambda Function Configuration Issues

My initial API tests returned a 502 Bad Gateway error, pointing to an issue within the Lambda function's execution. A quick review of the function's configuration revealed the problem:
I had omitted a critical environment variable required for the function to resolve the correct DynamoDB table. This experience highlighted the importance of thorough environment variable management as a key step in the deployment and testing lifecycle.

Bonus Step - Terraform Migration

After a successful deployment, I decided to experiment with Infrastructure as Code (IaC). I used Terraform to import the existing cloud resources into my Terraform state file, allowing me to manage future updates and changes through IaC.

If you would like to do the same, you can follow these steps:

Create empty resource blocks for the resources you are trying to import.

I ran these commands (among others) to import the resources from AWS. Do the same regarding the resources being imported. The number of import statements you run is determined by the number of resources you are importing. The Terraform documentation is great and will guide you accordingly.

$ terraform import aws_dynamodb_table.items-table ItemsTable

$ terraform import aws_lambda_function.items-function ItemFunction

$ terraform import aws_api_gateway_rest_api.ItemsAPI 9lwgudjgw4

$ terraform import aws_amplify_app.items-app d313k4wcghvl6q

Run terraform show to give you details of the resources imported so you can update your empty resource blocks as well.
Run terraform plan to ensure that your configuration is fine and no extra resources are being added.
Run terraform apply to ensure that your configuration is fine and your infrastructure is successfully and finally synced to your state file.
You can now check and confirm that there are no issues with your application and resources.

Project source code can be found on my GitHub repo here

Deploying a Static Website on S3 with Terraform

Antai Okon-Otoyo — Fri, 27 Jun 2025 21:10:06 +0000

Overview

This project provides a guide on how to deploy a static website on S3 using Terraform. With Terraform, we would create an S3 bucket and make it public, along with a page for error handling.

Why Terraform?

Terraform has proven itself to be a very useful IaC tool in the Cloud and DevOps Engineering ecosystem.

The key advantage of using Terraform is that it allows for infrastructure to be managed as code, enabling automation, reusability, and collaboration across different cloud providers and environments. It simplifies the process of provisioning, managing, and updating infrastructure, making it faster and more efficient.

Project Pre-requisites

An active AWS account.
Terraform Installation Completed.

Project Steps

s3-portfolio-website/
├── index.html
├── error.html
├── terraform/
│   ├── provider.tf
│   ├── main.tf
│   ├── outputs.tf
│   └── variables.tf
└── profile.jpg  <-- Add your image here

Set Up Provider on Terraform

The first thing we would do is set up our provider. You can run terraform init after that to download the provider plugin and initialize the backend for state management.

# provider.tf

terraform {
  required_providers {
    aws = {
      source = "hashicorp/aws"
      version = "6.0.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

Set Up S3 Bucket with Terraform

The resource block below creates a bucket with bucket as a required field specifying the name of the bucket being created.

#main.tf

resource "aws_s3_bucket" "sitebucket" {
  bucket = var.bucketname
}

The variables.tf file is used to define your variables instead of hard-coding them in the main.tf file. This is best practice.

#variables.tf

variable "bucketname" {
  default = "<your-bucket-name>"
}

Set Up Bucket Ownership

This is to set ownership of the bucket and ensure no one else can claim ownership.

#main.tf

resource "aws_s3_bucket_ownership_controls" "objectOwner" {
  bucket = aws_s3_bucket.sitebucket.id

  rule {
    object_ownership = "BucketOwnerPreferred"
  }
}

Make S3 Bucket Publicly Accessible

By default, AWS S3 buckets are private and restricted for public access, which follows AWS security's principle of Least Privilege. This is best practice as it minimizes the potential attack surface and reduces the risk of unauthorized access or data breaches.

However, to host the site through S3 and allow our website and images to be publicly accessible, we need to make the bucket public using the resource block below.

#main.tf

resource "aws_s3_bucket_public_access_block" "public" {
  bucket = aws_s3_bucket.sitebucket.id

  block_public_acls       = false
  block_public_policy     = false
  ignore_public_acls      = false
  restrict_public_buckets = false
}

resource "aws_s3_bucket_acl" "bucketacl" {
  depends_on = [
    aws_s3_bucket_ownership_controls.objectOwner,
    aws_s3_bucket_public_access_block.public,
  ]

  bucket = aws_s3_bucket.sitebucket.id
  acl    = "public-read"
}

Set Up Site Files and Objects

This will upload your site files and images from your local environment to your S3 Bucket.

#main.tf

resource "aws_s3_object" "index" {
  bucket       = aws_s3_bucket.sitebucket.id
  key          = "index.html"
  source       = "../index.html"
  acl          = "public-read"
  content_type = "text/html"

  depends_on = [ aws_s3_bucket_acl.bucketacl ]

}

resource "aws_s3_object" "error" {
  bucket       = aws_s3_bucket.sitebucket.id
  key          = "error.html"
  source       = "../index.html"
  acl          = "public-read"
  content_type = "text/html"

  depends_on = [ aws_s3_bucket_acl.bucketacl ]

}

resource "aws_s3_object" "profilepic" {
  bucket = aws_s3_bucket.sitebucket.id
  key    = "linkedin-profile-pic.jpeg"
  source = "../linkedin-profile-pic.jpeg"
  acl    = "public-read"

  depends_on = [ aws_s3_bucket_acl.bucketacl ]
}

Enable Static Website Hosting on S3

This resource block will help set up our website on S3, specifying the index and error files.

#main.tf

resource "aws_s3_bucket_website_configuration" "website" {
  bucket = aws_s3_bucket.sitebucket.id

  index_document {
    suffix = "index.html"
  }

  error_document {
    key = "error.html"
  }

  depends_on = [ aws_s3_bucket_acl.bucketacl ]

}

Note: The depends_on attribute is to let your code know the order in which you want your resource blocks created. In other words, it tells you the dependencies for your resource block, which means for the resource block above, the bucketacl resource must be created first before the website resource.

I created an outputs.tf file to return the value of my website endpoint on my terminal, as against getting it from the AWS console directly.

#outputs.tf

output "website_endpoint" {
  value = aws_s3_bucket.sitebucket.website_endpoint
}

We are now done with building the resource blocks. The next steps are to run the following commands to help us create the infrastructure in our AWS environment:

Command	Description
`terraform fmt`	Automatically formats your configuration files into a standard format that adheres to a predefined set of rules of indentation, spacing, and alignment across your terraform code, making it more readable and maintainable
`terraform validate`	Checks the Syntax and structure of your Terraform configuration files without deploying any resources.
`terraform plan`	Creates a plan consisting of the set of changes that will make your resources match your configuration
`terraform apply -auto-approve`	Executes the actions proposed in a Terraform plan to create, update, or destroy infrastructure. The `-auto-approve` option is to automatically approve, as `terraform apply` will always ask for confirmation of approval when it runs

After the commands have been run, your website should be up with the endpoint made available to you on your terminal for confirmation.

Note: If you come across this error: Error: uploading object to S3 bucket : AccessControlListNotSupported: The bucket does not allow ACLs status code: 400, Ensure you use the depends_on attribute to ensure that your bucket ACL is configured first for public-read before the files are uploaded.

On a final note, you can always refer to the Terraform Documentation to assist you build your infrastructure.

Deploying a Number Classification API on AWS Lambda + API Gateway using Zappa

Antai Okon-Otoyo — Mon, 10 Feb 2025 14:54:46 +0000

Overview

This project is a Flask-based API that provides interesting mathematical properties of a given number. It determines whether a number is prime, perfect, or an Armstrong number, and also provides its digit sum and a fun fact.

Zappa makes it super easy to build and deploy serverless, event-driven python applications(including, but not limited to, WSGI web apps) on AWS Lambda + API Gateway. Find more info about Zappa here.

Note that you would need an AWS CLI user setup with necessary permissions to lambda and api gateway.

Features

Determines if a number is prime, perfect, or an Armstrong number.
Computes the sum of digits.
Returns a fun fact about the number.
Supports CORS for cross-origin access.
Returns responses in JSON format.

Setup Necessary Tools and Dependencies.

First of all, Ensure you have python installed. You can go through the python documentation to assist you.

Install Flask and Zappa.

pip install flask flask-cors zappa

Setup your API on app.py in your local environment

from flask import Flask, request, jsonify
from flask_cors import CORS
import requests
import math

app = Flask(__name__)
CORS(app)

def is_prime(num):
    if num <= 1 or num % 1 != 0:
        return False
    num = int(num)
    for i in range(2, int(math.sqrt(num)) + 1):
        if num % i == 0:
            return False
    return True

def is_armstrong(num):
    if num % 1 != 0:  # Only whole numbers can be Armstrong numbers
        return False
    num = abs(int(num))
    digits = [int(digit) for digit in str(num)]
    power = len(digits)
    return sum(digit ** power for digit in digits) == num

def get_fun_fact(num):
    url = f"http://numbersapi.com/{num}/math"
    response = requests.get(url)
    return response.text if response.status_code == 200 else "No fun fact found"

@app.route('/api/classify-number', methods=['GET'])
def classify_number():
    number = request.args.get('number')

    try:
        number = float(number)
    except (ValueError, TypeError):
        return jsonify({"number": number, "error": "true"}), 400

    armstrong = is_armstrong(number)
    prime = is_prime(number)
    even = number % 2 == 0
    digit_sum = sum(map(int, str(abs(int(number)))))
    fun_fact = get_fun_fact(int(number))

    properties = []
    if armstrong:
        properties.append("armstrong")
    properties.append("even" if even else "odd")

    return jsonify({
        "number": number,
        "is_prime": prime,
        "is_perfect": False,  # No perfect number check required
        "properties": properties,
        "digit_sum": digit_sum,
        "fun_fact": fun_fact
    })

if __name__ == "__main__":
    app.run()

Test your API Locally

http://127.0.0.1:5000/api/classify-number?number=-100.5

Deploy API with Zappa on AWS Lambda using API Gateway

Initialize Zappa

zappa init

Follow the prompts to configure deployment settings.

Deploy your Flask app to AWS Lambda using the code below:

zappa deploy dev

This would take a while. After deployment, a link will be shared to access your API.

If you make update to your function, you can always update lambda using the code below

zappa update dev

Zappa will automatically set up a regularly occurring execution of your application to keep the Lambda function warm. This helps optimize speed and produces fast response time.

You can confirm the creation of the AWS Lambda function and API Gateway on your AWS Console and also make changes there.

Setting Up Nginx on an Amazon EC2 Instance

Antai Okon-Otoyo — Fri, 31 Jan 2025 23:33:47 +0000

INTRODUCTION

This document provides a step-by-step guide on how to install and configure the NGINX web server on an Amazon EC2 Instance running on Ubuntu. At the end of this guide, we should have a functional nginx web server set up that serves a custom webpage, demonstrating foundational cloud infrastructure management and web server configuration skills.

STEP 0 - Prepping AWS

We need to set up an EC2 instance. You do that by using the search bar to search for EC2 and clicking on Launch Instance. Then follow the steps below:

Select a free tier Ubuntu image as the AMI (Amazon Machine Image).
Select the Instance type next, I used free tier eligible t2.micro to eliminate cost.
Create security key pair for secure connection to your instance (ensure to keep your .pem file very safe).
Ensure you create a security group to allow SSH connection to your instance using your .pem file.
You can use default settings to configure instance details.
Launch Instance.

Ensure your status check shows "2/2 checks passed" as seen in the screenshot below:

Connect to AWS EC2 Instance using code below (for SSH Client):

chmod 400 "nginx-web.pem" (for MacOS Users only)

ssh -i "nginx-web.pem" ubuntu@ec2-44-243-195-121.us-west-2.compute.amazonaws.com

Note: nginx-web.pem should be replaced with the name of your .pem file. AWS would also assist you with commands to run as seen below:

STEP 1 - Update Package AND Install NGINX

Run the command below to update the list of packages in package manager.

sudo apt update

Run the command below to install nginx (option -y is to automatically say yes to the permission requested during installation)

sudo apt install nginx -y

After installing the nginx service, you use the command below to start the nginx service.

sudo systemctl start nginx

The enable command below is to add nginx as part of the system services and ensure that whenever you restart your instance, the nginx service is restarted along side.

sudo systemctl enable nginx

Check the status of your nginx status to ensure it is active with below

sudo systemctl status nginx

STEP 2 - Create Your HTML File

First, we will navigate to the var directory which is the root path for your HTML files.

cd /var/www/html

Then create and write to your html file using vim with command below.

sudo vim index.html

You press "I" on your keyboard to change into insert mode and insert your code.

Press the esc key to leave insert mode and :wq to write/save and quit.

Now that your index.html file is created, restart nginx for the changes to take effect.

sudo systemctl restart nginx

STEP 3 - Update Security Group FOR EC2 Instance

Under the Security tab of the EC2 Instance, Click on the security group.

Edit inbound rules and add rule to allow port 80 to enable us access the HTML page over the internet.

You can now open your web browser and verify via the public IP as seen in the screenshot below.

Access the html page through your web browser.

http://your-server-ip

Project Completed.

References

-DevOps Engineers
-Cloud Engineers