DEV Community: Muhammed Ashraf

Using AWS App Runner to build & host my website

Muhammed Ashraf — Thu, 08 Jan 2026 13:28:46 +0000

Overview

AWS provides a lot of different ways to deploy your application. based on whatever you are looking for, you will find a service for this. For example, if you are looking to deploy a classic application you have EC2 or a fully managed service you have Elastic Beanstalk. If you are looking to host containers, you have Amazon ECS, EKS or you can use for a fast and simple service like AWS App Runner

As per AWS documentation. AWS App Runner is very simple, fast service that helps you to deploy your application from either source code like GitHub or Image repo like ECR into a scalable and cost-effective service

Referring to cost. the service is very cost-effective since you will only pay for the actual traffic since App Runner provision resources based on your traffic (Lower Number of requests = Lower provisioned resources)

I was trying to explore AWS App Runner, So I deployed a website on AWS App Runner with other services such as S3, DynamoDB, ECR and Amazon SES for sending emails.

Architecture

Technology Stack

Runtime: Node.js
Framework: Express.js
Templating: EJS (Embedded JavaScript)
Frontend: Tailwind CSS (Styling), Alpine.js (Interactivity/State)
Database: AWS DynamoDB (NoSQL)
Storage: AWS S3 (Food Images)
Email: AWS SES (Order Notifications)
Hosting: AWS App Runner (Dockerized)

Directory Structure

Core files:

server.js: Entry Point. Configures Express, middleware and static files. Starts the server.
lib/aws-client.js: AWS Utility. Centralizes initialization of DynamoDB Client, S3 Client, and SES Client.

Route Handlers:

shop.js: Customer Facing. Handles public access to the menu, cart operations, and checkout.
admin.js: Admin Management. Protected routes for managing items, authentication, and stats.

Views:

index.ejs: Homepage. Renders the Menu (Hot/Frozen sections), Cart Drawer, and Hero section.
admin.ejs: Dashboard. Main Admin interface for Adding/Editing/Deleting items.
admin-stats.ejs: Analytics. Visual dashboard using Chart.js to show revenue and order trends.
login-ejs: Authentication. Admin login form.

Partials:

header.ejs: Navigation bar, Mobile Menu, Favicon, Libraries import (Tailwind, Alpine).
footer.ejs: Page footer, Closing tags.
product-card.ejs: Reusable component for rendering a single regular menu item.
cart-drawer.ejs: The sliding cart sidebar content

AWS Components

Compute: AWS App Runner

Role: Fully managed container application service.
Configuration: Autoscaling instances based on request load.
Source: Deploys the Docker image directly from Amazon ECR.

Database: Amazon DynamoDB

Role: Serverless NoSQL key-value database.
Tables:
MenuTable: Stores food items (itemId, name, price, description, category).
OrdersTable: Stores customer orders (orderId, customerDetails, items, total, status).

Storage: Amazon S3

Role: Object storage for uploaded food images.
Access: Images are uploaded via the Admin Panel. The application generates signed URLs or proxies them for secure display.

Container Registry: Amazon ECR

Role: Securely stores the Docker container images.
Workflow: docker push commands upload new versions of the app. App Runner detects these changes to update the live site.

Communications: Amazon SES
Role: Reliable email delivery service.

Snapshots from the website

So, AWS App Runner simplifies the deployments. You don't care about the deployment's steps You only focus on improving your code or monitor your website.

Using AWS CloudFront to enhance the performance, Security & Availability of your application

Muhammed Ashraf — Mon, 13 Oct 2025 11:21:21 +0000

Hosting a website that serves a lot of customers around the world then AWS CloudFront should be considered by you since it distributes your content of your website and store them at the nearest edge location to your clients.

This significantly improves performance and reduces loading times which enhances the customer's experience

In this article I will try to explain CloudFront features that can be used to enhance the overall experience of your website

We are going to discuss the below features

Origin Group and Multiple Origins
CloudFront Functions
Global Accelerator
CloudFront Security

But before we start, we will try to explain how does CloudFront work

Overview

They key architectural components of CloudFront are distribution, Edge locations or Point of Presence, Regional Edge Cache, Origin & Caching Behavior

Let's walkthrough them one by one

Distribution: this the primary resource you create, and it contains the configurations including origins, caching behavior and security settings.
Edge Locations: there can be considered as data centers where content is cached
Regional Edge Cache: this is larger caching layer located between edge locations & origin, they store less popular content for larger periods than smaller edge locations
Origin: This is the source of your content, It can be S3, ALB, NLB EC2 or On-permise server, you can find more information Origin Types
Cache Behavior: set of configuration rules you apply to specific URL patterns, for example routing, TTL or redirection

Referring to AWS official documents this is how architecture looks like

CloudFront has a lot of features that could help you to go beyond if you used them correctly, Let's discuss them one by one

Feature

Origin Group & Multiple Origin

As mentioned earlier, Origin is the source of your data, the OriginGroup feature allow you to add multiple origins to the same group (primary origin & secondary origin) in addition to a failover criteria you define, This means if you send a request to your primary region and origin responded with an error status code, request will be redirected to the secondary origin.

you can use muliple origin groups to server the contents based on their types,

for example: You can redirect the static content to Origin A while dynamic content to Origin B

Global Accelerator

It achieves low latency and high performance by utilizing AWS global network and avoid going to the public internet,

it works by providing a static IP address to your application and route the traffic through the optimal route & healthy endpoint

Use Cases

Routing to Multiple Origin

CloudFront Cache Behavior can be used to route traffic based on the path pattern as below:

This allows you to serve static & dynamic origin instead of having different architecture for both content type

Origin Failover Through Origin Groups

This feature helps you to achieve high availability by forwarding failed requests to another Origin.

Restrict Access Through Custom Headers

By adding Custom Header on CloudFront and modifying the requests, this will allow us to define a rule on the ALB that if the requests don't contain the Custom Header will be denied, any direct access will be blocked by the defined rules on the ALB

Closing Words

CloudFront is a powerful service if you are looking to distribute your application or website globally, it has many features that will help you to achieve high availability, security and reduce latency for the clients that reaching your application.

References

CloudFront Official Documents
ow UNiDAYS achieved AWS Region expansion in 3 weeks

Using Amazon Textract to analyze and extract text from Documents Part 1

Muhammed Ashraf — Sun, 14 Sep 2025 17:37:26 +0000

Amazon Textract is very powerful machine learning
service that used to analyze do documents and extract either text or handwriting from scanned documents.

It can be used to build different solutions for different use cases such as:

Financial Services
Health Care

In this article we walkthrough how to build a solution on that works on extracting texts from PDF, analyze them, then store them into DynamoDB for further analysis

We will use a mix of AWS services to build our solutions, below is a breakdown of these services and the use case of them

S3 Buckets: will be used to be our storage for raw & extracted JSON files
Lambda: will be used to invoke Amazon Textract through StartDocumentAnalysis & GetDocumentAnalysis APIs, store the JSON files into S3
SNS: used for async communication to invoke the Lambda to get the results and store them into the final bucket
Eventbridge: Used to trigger Lambda function once file is uploaded to S3
AWS Glue: it will used as batch job to iterate over the S3 bucket to convert the files and ingest the files into DynamoDB
DynamoDB: will be our storage for the extracted data

Sequence Flow

Functional Requirements

User should be able to upload PDF files to S3 bucket

Non-Functional Requirements

Solution must be high available
Solution should be reliable

Block Diagram

Our block diagram shows the components that will be used to build our solution

High Level Design

The high-level design shows the services used to build our solution, focusing on ingesting, analyzing & storing the results DynamoDB

We will breakdown our solution into different aspects

High availability:
- Storage: our storage services such as S3 & DynamoDB, offer high availability you can find all the details related for each service here S3 DynamoDB
- Lambda Function: Resilience in Lambda
- SNS: Resilience in SNS
- Amazon Textract: Resilience in Amazon Textract

Amazon Textract APIs

We will utilize StartDocumentAnalysis API and GetDocumentAnalysis API

for StartDocumentAnalysis API we have different types of features such as (Tables, Forms, Queries, Signature and layout) we will use Queries to extract specific data from the statements such as card number, client name, new charges etc.

and for GetDocumentAnaylsis API is recieving the results of StartDocumentAnalysis API in aschyronous mode, we will utlize SNS to decouple our Lambda functions.

below you can find a screenshots for the setup

we have two Lambda functions as below

the trigger_lambda_put will be used to be triggered once a file uploaded to the S3 and call the Amazon Textract API
and other function will be used to get the results and filtering out the required parameters

we have also two S3 buckets for the input and outputs files

SNS

the output will be as below

file name is textract job id .json, this can be modified through the lambda function code

the final output should be as below

since I have defined the card holder name as a filter parameter in the Lambda function code

In part two we will discuss more about AWS Glue JOB to process multiple files and store them into DynamoDB and we will cover the cost part for each component

Using AWS Comprehend to analyze customers' feedback

Muhammed Ashraf — Fri, 15 Aug 2025 16:11:17 +0000

Analyzing customer feedback for your product is recommended to enhance and fill the gaps for any business want to enhance their products and customer services

AWS provides several services that can used to achieve this, One of the services that can be used is Amazon Comprehend

Based on AWS documentation Amazon Comprehend "Amazon Comprehend uses natural language processing (NLP) to extract insights about the content of documents. It develops insights by recognizing the entities, key phrases, language, sentiments, and other common elements in a document. Use Amazon Comprehend to create new products based on understanding the structure of documents."

So, in this blog we will discuss how we are going to use Amazon Comprehend to analyze customer reviews

We will start with the functional & non-functional requirements then we will move to the core components and the setup of the solution

We made some assumptions that the application is already deployed on an EC2 instance and users will be able to write their review, the application is Inegrated with S3 and will generate a text file contains review

Functional Requirements

Analyze text documents which will be generated by application
Extract the reviews and categorize them either POSITIVE, NEGATIVE or MIXED based on sentiment score

Non-Functional requirements

Solution should be reliable

HLD

Core Components

EC2: It will host the application accessed by users.
S3: will host the review files generated by application which contains user's reviews
Lambda Function: It will be triggered by S3 event notification and will invoke Amazon Comprehend by using Detect_Sentiment API, it will also save the generated results to DynamoDB
DynamoDB: will store the final results either the review is POSITIVE, NEGATIVE or MIXED

Solution Setup

1- We have created an S3 bucket with a directory uploads which will host the generated review files

The bucket is created with the default configuration and for event notification you can create type of events is (POST, PUT)

2- We have created a table on DynamoDB with the below configuration:
Table Name: CustomerFeedbackAnalysis
Partition Key: FeedbackID

We kept rest of configuration as default but for sure you will configure them based on your requirements

3- We created a Lambda function with defaults configuration except for the Timeout since it's only 3 seconds and IAM Role since it should have permissions for the below:

AWSLambdaBasicExecutionRole (Basic Exection Role for Lambda)
AmazonS3ReadOnlyAccess (to read files from S3)
AmazonDynamoDBFullAccess (Write results to DynamoDB)
ComprehendReadOnly (Invoke Comprehend using Detect_Sentiment API)

Sequence Diagram

The flow should be as below

The results

I generated some random reviews and uploaded them to the S3, the final results stored in DynamoDB table as below:

References

Analyze content with Amazon Comprehend and Amazon SageMaker notebooks
Amazon Comprehend

Content Moderation Using AWS Rekognition

Muhammed Ashraf — Thu, 17 Jul 2025 10:57:02 +0000

Overview

Content moderation is considered very important for organizations, especially for social media, advertising, and education. Any organization requires special analysis for media.

The basic definition of content moderation is reviewing media and content to ensure it complies with the standards and guidelines set by the organization.

Achieving that manually will be very difficult, since you are going to review every content that is uploaded by a user, and it's even impossible if we are talking about a large user base platform.

In this article, we will discuss deploying a content moderation solution on AWS and how to utilize different AWS services to achieve this.

First, we will break down our core components.

Core Components

User
Content

Then we will have our high-level design. Keep in mind that you can have different architectures for this, and you are not only restricted to this.

Architecture

Core Services

S3 Bucket --> It will be our storage services which will be used to store our content.

S3 has a feature called S3 event notification, which allows S3 to trigger events in case of uploading, deleting, or replication events. You can find a list of types of events here and the destinations that can receive this notification.

Lambda Function --> it will be used to put messages contains object details to SQS whenever any object uploaded to S3 and another one will pull SQS messages and triggers Rekognition API to start the content moderation process.
SQS --> It will be utilized to decouple upload and moderation process from each other to avoid bursts and spikes
Rekognition --> The actual moderation process happens here since AWS Rekognition is an AI service that is used for an image/video analysis, the results will be stored in another bucket

Sequence Diagram

The below sequence shows how the flow should be

The user will upload content to an S3 bucket. In the real world, the S3 bucket is the storage for the front-end layer, which can be a mobile or web app. I just used S3 directly for simplicity and explanation.
An S3 event notification will be triggered once an object is uploaded, and the destination will be a Lambda function.
The Lambda function will send a message containing details about the uploaded object to the SQS for decoupling the architecture.
A moderator Lambda function will pull the message from SQS and trigger the Rekognition API (DetectModerationLabels). More info here related to label categories.
The results will be stored into another S3 bucket for better isolation.

Conclusion

For sure, content moderation is used across nearly all social media and advertising organizations, and it became easier with the help of AWS's different AI services. You don't need to have experts in AI or machine learning to deploy your own content moderator, just go through the AWS documentation.

Hope this article helps you, and please let me know if you have any comments.

AWS Migration Services Part1

Muhammed Ashraf — Tue, 17 Jun 2025 12:00:42 +0000

Overview

In this article we are going to discuss the different service related to discovery & migration data either from AWS to AWS or On-premises to AWS and when features, use case for each one of them.

There is a ton of services that can be used to migrate either for application or database such as the below services:

AWS Application Migration Services (AWS MGN)
AWS Database Migration Service (AWS DMS)
AWS Datasync
AWS Migration Hub
AWS Transfer Family
AWS Application Discovery
AWS Modernize Mainframe Application

Let's start with the application & databases then move to the data migration services:

Application & Database Migration Services

AWS MGN: it's a service that used to help companies to lift and shift their physical, virtual or cloud-servers with facing any compatibility or performance issues, it simplifies the moving process for large servers to AWS,

It eliminates compatibility issues by the below features:

Block-level replication: By replicating at the block level, MGN is largely agnostic to the applications, databases, and file systems running on the server. It is copying the underlying disk data, not interpreting the files.
Automated OS conversion: When a test or cutover instance is launched, MGN automatically handles the necessary conversions to make the server boot and run natively on AWS infrastructure.

While performance issues are handled by:

Minimal Source Impact: The replication agent is lightweight and operates in the background with throttled resource consumption.
Choosing the right instance size: In the MGN console, you can define Launch Settings for each source server. This allows you to choose the appropriate EC2 instance type
Optimized data transfer: While the data transfer happens over your network, the continuous replication model avoids the need for a massive, single data transfer that could saturate your connection during business hours.

You can choose AWS MGN when you are looking for rehosting migration and need to quickly move existing application.

you can find more technical details about how it works on the below links https://docs.aws.amazon.com/mgn/latest/ug/General-Questions-FAQ.html

AWS DMS: it's a common service that support a lot of sources DB and many destinations used to migrate databases either an AWS DB or external DB

there are a lot of features for the DMS such as the below features

Support of homogeneous & heterogeneous migrations: DMS supports migrating between the same database engines and between different database engines.
CDC: DMS can capture changes from the source database and apply them to the target in near real-time, minimizing downtime during the migration.
Schema Conversion: DMS works in conjunction with the AWS Schema Conversion Tool to convert the source database schema and code to a format compatible with the target database.
Serverless Option: A serverless feature automatically provisions and scales the migration resources, simplifying the process further.

the major use case for this service is migration of databases either from/to External/AWS

for more technical information about how it works and supported sources, destinations you can visit this link AWS DMS FAQs

AWS DataSync: It's a service that used to transfer & accelerate movements of large data between on-premises storage systems and AWS storage services.

So as defined above the main focus only of this service is moving data between storage systems and it has many features such as:

Accelerated data transfer: by using purpose-built protocol to transfer data up to 10 times faster than open-source tools.
Automated and Managed: It handles many of the tasks involved in data transfer, including scripting copy jobs, scheduling and monitoring transfers, validating data integrity, and optimizing network utilization.
Secure Transfers: Data is encrypted in transit and at rest, and the service integrates with AWS security features like IAM roles and VPC endpoints.
Broad Storage Support: It supports a wide range of storage systems, including Network File System (NFS), Server Message Block (SMB), and Amazon S3, Amazon EFS, and Amazon FSx.

You can use this service for migrating large datasets to AWS or archiving cold data from on-permises to cost effective AWS storage like AWS S3 Glacier, it can be used also in data replication to achieve business continuity.

AWS Migration Hub: it's a like center location that you can manage & track the progress of applications migrations across multiple AWS accounts and partner solutions

It has many features like:

Centralized Tracking: Monitor the status of migrations from various tools like AWS Application Migration Service, AWS Database Migration Service, and partner migration tools.
Application Discovery: Integrates with AWS Application Discovery Service to automatically gather information about your on-premises servers, including specifications, performance data, and network dependencies.
Strategy Recommendations: Provides recommendations on the best migration and modernization strategy for your applications.

So picking the right service based on your needs is mandatory, we can summarize the use case for each service as below:

looking for lift and shift solution then you can go for AWS MGN
Database migration and schema conversion then use AWS DMS
Replicating & moving data from on premises to AWS then the DataSync option is the one
Centrally manage and track the progress of migration you can use migration hub

Based on you migration strategy you can pick the right choice for you.

we will discuss more the remaining services in another article but for now I will drop references below for each service if you want to dig deep in each service

AWS DataSync
AWS MGN
AWS DMS
AWS Migration Hub

[Boost]

Muhammed Ashraf — Sun, 23 Feb 2025 10:27:45 +0000

How I built a simple Twitter-Like System on AWS with the help of Grok AI

Muhammed Ashraf ・ Feb 22

#ai #aws #cloud

How I built a simple Twitter-Like System on AWS with the help of Grok AI

Muhammed Ashraf — Sat, 22 Feb 2025 23:34:49 +0000

As the article title states, Grok AI wrote most of the code, as my expertise lies in solution architecture, So I'm writing this article to share my experience in how I used Grok AI to help me to apply my experience to build this system and enhance my hands-on experience.

I am not an expert coder, but I understand how large systems, such as social media websites, function.

Building an enterprise system requires experience in system integration and service selection within different architectures. AI can assist, but its effective use requires a strong understanding of how these systems work.

But don't worry, this article is written by me, not AI 😎😁

First, you need to list the functional requirements of your system,

Functional requirements are the core things your system should do. If we take a moment to think together about what functions a system like Twitter should have,
the first thing that comes to mind is that the user should be able to sign up for an account and log in using that account.

Also, users should be able to post and delete tweets, upload photo, love tweets, comments and retweets

I tried to cover some core features to just help you understand how we can make this happens and later on we may build on these new features

I will list the function requirements which covered by this system

User can sign up and login
User should be able to post tweets
User Should be able to delete his tweets
User should be able to love and comments on tweets

Non-functional requirments are define how system should behave

They are like

Elasticity
High availability
Scalability

These requirements should enhance the user experience

The second thing you should do is your capacity estimation. This will help you pick the right resources for your system to avoid any spikes or under/high utilization.

We will not cover this here since it's a very simple system. You can search the internet; there are a lot of resources covering this. I will drop some links below 😁 ✌

High level Design & Components

I picked AWS since this is my area i
Of expertise and used common services for building the system

Below is a breakdown of the services I used:

EC2 instance: To host our frontend code and act as a web server.
API Gateway: Built APIs used for signup, login and authorization, posting tweets, deleting tweets, liking tweets, and commenting. Each function has its own URL and Lambda function.
Lambda Functions: Contain the logic for the system functionality mentioned above.
DynamoDB: Contains Users and Tweets tables that store the data.

Sequence Diagrams

Signup Flow

Post Tweet Flow

Love Tweet

Love Tweet, Comment & Delete Tweet they are all the same in terms of getting tweet_id and perform the action

Some screenshots of the UI:

Code

Twitter-Like-App

And now for the interesting part, I uploaded a code on Github
feel free to use it and remember this is a very basic code, Further enhancements are coming 😁

Final Words

I know best practices are not applied here and many features are missing such as decoupling the components, caching service and following/followee system and the system looks dummy that cannot handle heavy workloads 😢🤦‍♀️, but it should give you a vision of how larger systems should work, and you can consider it a start.

And you can make magic happen If you know the way and how you can interact with AI.

I hope this article helped you to understand a little about how you can make use of AI tools and how you can build a system by help of these tools, I will try to work on this base version for further enhancement and features and I may create another article to include these enhancements.

Will be happy to see your comments and suggestions 😃

References

Twitter System design
Hello Interview Youtube Channel

Parsing & Loading Data from S3 to DynamoDB with Lambda Function

Muhammed Ashraf — Sun, 05 Jan 2025 14:40:57 +0000

Many scenarios require you to work with data formatted as JSON, and you want to extract and process the data then save it into table for future use

In this article we are going to discuss loading JSON formatted data from S3 bucket into DynamoDB table using Lambda function

Prerequisites

IAM user with permissions to upload objects to S3
Lambda Execution role with permissions to S3 & DynamoDB

Architecture & Components

The architecture below shows we are using 3 AWS services

S3 bucket
Lambda Function
DynamoDB Table

A brief description of services below as refreshment:

S3 Bucket: Object storage service with scalability, security & high-performance service will be used as our storage service for the data
Lambda Function: Serverless compute service which allows you to run your code without worrying about the infrastructure, easy to setup and support a lot of programming languages, we will utilize it to run our code and deploy our logic.
DynamoDB: Serverless NoSQL database used to store our data in tables, we will use it to store our processed data by the Lambda function

Flow

User will upload JSON file to S3 bucket through console or CLI which behind the scenes PutObject API
Object is Uploaded successfully, S3 Event will be triggered to invoke the lambda function to load & process the file
Lambda will process the data and load it into DynamoDB table

Implementation Steps

We will walk through the steps & configuration for deploying the above diagram

1- Create Lambda Function with below Configuration

Author from Scratch
Function Name: ParserDemo
Runtime: Python 3.1x

Leave the rest as default
After Lambda created, you will need to modify the timeout configuration & Execution role as below:

I wrote this python code to perform the logic

import json
import boto3

s3_client = boto3.client('s3')
dynamodb = boto3.resource('dynamodb')

def lambda_handler(event, context):



    bucket_name = event['Records'][0]['s3']['bucket']['name'] # Getting the bucket name from the event triggered by S3
    object_key = event['Records'][0]['s3']['object']['key'] # Getting the Key of the item when the data is uploaded to S3
    print(f"Bucket: {bucket_name}, Key: {object_key}")


    response = s3_client.get_object(
    Bucket=bucket_name,
    Key=object_key
)


    # We will convert the streamed data into bytes
    json_data = response['Body'].read()
    string_formatted = json_data.decode('UTF-8') #Converting data into string

    dict_format_data = json.loads(string_formatted) #Converting Data into Dictionary 


    # Inserting Data Into DynamoDB

    table = dynamodb.Table('DemoTable')
    if isinstance(dict_format_data, list): #check if the file contains single record
        for record in dict_format_data:
            table.put_item(Item=record)

    elif isinstance(dict_format_data, dict): # check if the file contains multiple records 
        table.put_item(Item=data)

    else:  
        raise ValueError("Not Supported Format") # Raise error if nothing matched

2- Create S3 bucket

BucketName: use a unique name

leave the rest of configuration as default

Add the created S3 bucket as a trigger to lambda function as below:

3- Create a Table in the DynamoDB with the below configuration

Table Name: DemoTable
Partition Key: UserId
Table Settings: Customized
Capacity Mode: Provisioned

To Save costs configure the provisioned capacity units for read/write with low value (1 or 2 units)

Now the setup is ready, you can test it by uploading a file to the S3, then you will find items created on the DynamoDB table with the records you have uploaded into the file.

CloudWatch Logs for Lambda Function

DynamoDB Items

I hope you found this interesting and please let me know if you have any comments.

References

S3 API
DynamoDB API
boto3 practice for AWS services

Using Stable Diffusion in AWS Bedrock to Generate Images

Muhammed Ashraf — Sun, 03 Nov 2024 14:50:22 +0000

No doubt that Generative AI is now being used by nearly everyone in the technology industry, it helps a lot of people daily with their work, life and almost everything,

Generative AI is type of AI that is used to generate contents such as texts, images and videos based on the data that the models trained on.

there are a lot of foundations models which they are already trained on data, these models are very powerful and trained on very big datasets, and they are available to use such as:

Chat GPT
Amazon Titan
Stable Diffusion
Claude
Llama

Amazon Bedrock is a managed service that offers these foundation model to be used or to you can use some AWS bedrock to train these models with your own data and use it with other AWS services to build your application.

In this article we will building an API that invoke AWS Bedrock to generate images using SDXL 1.0 model

We will use the below services

Lambda function which contain the logic and integrate with AWS Bedrock
API Gateway which exposes the Lambda function
AWS Bedrock with Stable Diffusion Model
S3 bucket to store the images

High Level Design

Steps

We will Create IAM role first for our lambda function with managed policy (S3FullAccess,BedrockFullAccess)

Go to IAM --> Select Roles --> Create Role and Select AWS Service and Lambda to be the use case --> Add the previous policies --> Lambda-execution-role-demo will be the name -->
Create

We will create Lambda function with python runtime *Go to Lambda --> Create Function *

Make sure to modify the Lambda timeout since it will be 3 seconds by default

Create S3 bucket with default configuration *Go to S3 Console --> Create Bucket --> Leave the default settings *

Make sure to enter a unique bucket name

This bucket will be used to store the generated images and will be used to generate a pre-signed URLs to have temporary access to these images

Subscribe to Amazon Bedrock Stable Diffusion model Go to Bedrock Console --> Base Models under Foundation Models --> Request model access

Search for SDXL you should able to see it, mark it and press next then Submit

I am already subscribed to this model, so the configuration screen is different

You will have access after few minutes, after than you are ready to go

Get the model ID since it will be used later in Lambda python code Go to Bedrock Console --> On the left select images under playground --> Select SDXL 1.0 and Press on the 3 dots

Select View API Request you will get a sample request to interact with this model as below

note down the model id stability.stable-diffusion-xl-v1

Code Breakdown

First you need to import the below packages

import json # for converting the payload into JSON
import boto3 # to interact with AWS services
import base64 # it will be used to encode the images 
import datetime # will be used to interact with date and time functions

To interact with AWS services you will need to define client for the services

below we are going to interact with bedrock and S3 so we will have two clients

bedrock_client = boto3.client('bedrock-runtime')
s3_client = boto3.client('s3')

Then you will get the input from prompt text from the API gateway

  input_text = event['prompt']
  print(input_text) # for troubleshooting

Now you will need to configure the parameter for invoking the Stable Diffusion model, You can find the full parameters here

I used the below

payload = {
        "text_prompts": [ #(Required) – An array of text prompts to use for generation. 
            {
                "text": input_text # The prompt that you want to pass to the model.
            }
        ],
        "height": 1024, # (Optional) Height of the image to generate
        "width": 1024, # (Optional) Width of the image to generate
        "cfg_scale": 7, # (Optional) Determines how much the final image portrays the prompt.
        "steps": 50, # (Optional) Generation step determines how many times the image is sampled
        "style_preset": "photographic" # A style preset that guides the image model towards a particular style
    }

# Now we are invoking the model 
    response = bedrock_client.invoke_model( 
        body=json.dumps(payload),
        contentType='application/json', # The MIME type of the input data in the request.
        accept='application/json', #The desired MIME type of the inference body in the response.
        modelId='stability.stable-diffusion-xl-v1' #model ID
    )

We will now work to extract the image from the response and we will use base64 to decode it

    response_byte=json.loads(response['body'].read()) # store the response bytes
    response_base64=response_byte['artifacts'][0]['base64'] #extract the artifacts into base 64
    resposne_image=base64.b64decode(response_base64) # decode the image
    image_name='images-'+ datetime.datetime.today().strftime('%Y-%M-%D-%H-%S') +'.jpg' # store the image name into date time format

Now we are going to put the generated image into S3 bucket and generate pre-signed URL

 s3_response=s3_client.put_object(
        Bucket='', #replace it with your bucket name
        Body=resposne_image,
        Key=image_name
    )

    generate_url=s3_client.generate_presigned_url('get_object', Params={'Bucket':'<add your bucket here>','Key':image_name}, ExpiresIn=3600)

 return {
        'statusCode': 200,
        'body':generate_url
    }

Now to let's move to API Gateway, we are going to create REST API with any related name you want

We will create a resource with get method

** Create Resource --> Create Method with GET**

Select your Lambda Function and make sure that the API gateway has permission to invoke the Lambda function

Make sure to modify the method request settings & URL query string parameters to be as below

The value here should be similar to the one in the code

Edit the mapping template in the integration request with the below values

Now you are ready to Deploy your API and test it

You should now receive a pre-signed returned to the API Gateway

The generated image should be something like this

Hope you like the demo 😊, Leave like to keep me motivated ❤

References

Rahul Trisal Udemy Course *Recommended *
SDXL Parameters
Boto3 Invoke Model

Integrating AWS Connect with Amazon Lex to understand voice input Part1

Muhammed Ashraf — Wed, 16 Oct 2024 09:25:05 +0000

In this series of articles, we are going to discuss the below:

How to create a flow on Amazon Connect.
How to integrate it with Amazon Lex.
Sending Contact Trace Records to S3 using Kinesis Firehose.

HLD

Overview

Amazon Connect is service used to help you build your own contact center it’s a managed service by AWS which allow you to build your flows to handle customers’ requests & issues without the need of taking care of the infrastructure, we have used Amazon Connect in the setup to provide a contact flow to handle a customer with two categories (VIP & Golden) with two different queues for each category of customers, the flow is handling internet new requests & internet issues.

Amazon Connect is integrated with Amazon Lex which is a service allows you to create chat bots to handle customers requests and issues with bot which will be used later in the contact flow to recognize customer requests.

Amazon Lex is also a managed service used to build conversational bots which can be integrated by other services such as Lambda function,

Amazon Lex will be invoked in the contact flow using Invoke Lex block and the Lex chat bot created to recognize two types of requests, new service requests & internet down problems.

Design Components

Flow

Implementation Steps

Through AWS Console you will have to create an Amazon Connect Instance

I have created the instance with the below configuration for simplicity

Note: The access URL should be unique

Remember the Administrator credentials since it will be used later

Set your telephony settings in order to allow instance can recieve and initiate calls

Then we will configure our storage for call related information (recording & transcripts)

Then we are going to connect with the administrator credentials to our instance through the Access URL

You will have the below Dashboard

We will create a very simple flow in this article, then we may explore creation of more flow in future

Go to flows on the left as below

Then create flow and name it as sample flow

On the left we have call flow blocks, they are the main components of our IVR flow, we will go into more detail regarding these blocks later.

The type of this flow is inbound flow, which means it will receive incoming calls from customers

We added two blocks related to the logging,

Set Logging Behavior: When logging is enabled, data for each block in your flow is sent to Amazon CloudWatch Logs.

Set recording and analytics behavior: This Specifies recording behavior and configure Contact Lens conversational analytics

then we will add these two blocks,

The play prompt will be configured to welcome the customer

The other block is to check hours of operation, This block helps you to define the working hours of your queue

We will then use the below three blocks

Get customer input block: will receive an input from the user through the dial pad and based on the value it will be routed to the related queue

Set working queue block is defining current working queue to transfer the call

we will go into details later for creating queues, but I have selected the already created Basic Queue

the final block is the actual transfer to queue, here where the customer connected to the actual agent, after the customer request is fulfilled, the call should be terminated

After adding the terminate block, now you are ready to claim a number for your flow, but before moving forward you will have to save and publish your flow

for error in each flow block you will have to play prompt that "we are not able to process your request now" for better user experience

now go the dashboard then phone numbers in channel to claim a number

the difference between DID and toll free in a brief that the DID can be dialed from anywhere around the world, while the toll free can be dialed only from the country that you are claiming the number for, more details here.

channel will be voice, and you can choose any country just for testing purposes I have selected DID & UK

then select the flow that you are going to link this number with

Now you are ready to go and test your flow, I have used skype to dial and test this flow, in part two we are going to go into more details regarding voice recognition with Amazon Lex

Automate Cleaning of Unused EIP Through Lambda Part1

Muhammed Ashraf — Wed, 02 Oct 2024 14:45:37 +0000

Overview

The cost on AWS is considered one of the important things that everyone should take care of. It will be a headache if you have many resources on your account and a lot of charges occur.

Sometimes, most of the charges are due to forgetting a running resource like an EC2 instance or forgetting to delete unused resources such as EBS or EIP.

EBS and EIP charge you if they are provisioned and created on your account, whether used or not.

Previously in this article, we discussed how to delete unattached EBS volumes to save you some costs. In this article, I will help you to delete unused EIPs and how to Automate this part in order to avoid charges for unnecessary EIPs.

High Level Design

Steps:

we will utilize EventBridge new feature which is schedule to trigger our Lambda function every 1 day

1- We will create a Lambda function default configuration as below with runtime python 3.12 and an execution role to VPC full access

This is my python code I wrote in order to release unused EIPs

import json
import boto3

def lambda_handler(event, context):
    ec2_resource = boto3.resource('ec2')

    elastic_ips_list = []
    for elastic_ips in ec2_resource.vpc_addresses.all():
        try:
            if elastic_ips.instance_id is None:
               elastic_ips_list.append(elastic_ips)
               print(f"Releasing the Unused Addresses \n")
               elastic_ips.release()
               print("IPs addresses released")
        except Exception as e:
            print(f"Error releasing IP Address {elastic_ip.public_ip}: {str(e)}")

    return {
        'body': json.dumps("The list of Unused Addresses is: " + str(elastic_ips_list))
    }

2- We will create EventBridge schedule with the below configurations in order to trigger our lambda function

After the EventBridge schedule configured it will be ready to invoke our lambda function with the rate configured, the Lambda function will list the EIPs and will check for the unassociated ones to delete them, in the next article we will configure our lambda function to send an email with the deleted EIPs through AWS SNS.

Closing Words

Monitoring your AWS cost is crucial to avoid any unnecessary charges, so always try to have checks on your resources to see what resources are unused in order to start deleting them. It's better to automate this task through a combination of EventBridge schedules and Lambda functions.