DEV Community: Vilsi Jain

Deploying a Flask Model on AWS: A Step-by-Step Guide

Vilsi Jain — Sat, 03 Jun 2023 09:23:33 +0000

Introduction:
In this I will be sharing how you can deploying machine learning models to your data-driven applications into scalable and production-ready solutions. In this will walk through the process of deploying a Flask model on AWS (Amazon Web Services), one of the most popular cloud platforms. By following these step-by-step instructions, you'll be able to leverage the power of AWS to make your Flask application accessible to users worldwide.

I have to deploy my machine learning model which converted into flask project to deploy and get API faced issues finding proper documentation So tried to get proper guidance with steps.

Table of Contents:

Prerequisites
Setting AWS Account
Creating an EC2 Instance
Configuring the EC2 Instance
Installing Dependencies
Building the Flask Application
Deploying the Flask Model
Testing and Deployed Application

1: Prerequisites
Make sure the following conditions are met before beginning the deployment process:

Basic understanding of Flask and AWS concepts
An AWS account with appropriate permissions to create and configure resources

2: Setting up an AWS Account
If you don't have an AWS account, visit the website and sign up for a new one. Follow the provided instructions to complete the registration process.

3: Creating an EC2 Instance

Open the AWS Management Console and log in.
Using the EC2 service, go there and select "Launch Instance."
Choose a suitable Amazon Machine Image (AMI) for your needs.
Based on the requirements of your application, select an instance type.
Set up the instance's specifics, such as how many instances there are, the network configuration, and storage.
Set security groups established to accept incoming traffic.
Review and launch the instance.

4: Configuring the EC2 Instance

Once the instance is launched, connect to it using SSH.
Install necessary packages and dependencies on the EC2 instance.
Set up your environment variables and configurations.

5: Installing Dependencies

Install the required dependencies such as Flask, scikit-learn, etc.
Set up a virtual environment for isolating dependencies.

6: Building the Flask Application

Create a Flask application.
Define routes and implement the necessary logic for your machine learning model.
Test the application locally to ensure it's functioning correctly.

7: Deploying the Flask Model

Copy your Flask application files to the EC2 instance.
Install the WSGI server (e.g., Gunicorn) to run the Flask application.
Configure the web server and application for production.

8: Testing the Deployed Application

Access the public IP or domain name associated with your EC2 instance.
Verify that the Flask application is up and running.
Test the endpoints and functionality to ensure they are working as expected.

Conclusion
Congratulations! You have successfully deployed your Flask model on AWS. By leveraging the power of AWS, you can now provide your machine learning application to users worldwide. Remember to monitor and maintain your application regularly to ensure its optimal performance and scalability.

In this tutorial, we have covered the essential steps to deploy a Flask model on AWS. However, keep in mind that this is just the beginning. As we go deeper into the world of cloud deployment, there are additional considerations such as load balancing, autoscaling, and security that you may need to explore based on your specific use case.

Deploying machine learning models on the cloud opens up endless possibilities for scaling and delivering your applications to a wider audience. Keep learning, experimenting, and leveraging the vast resources available to continuously enhance your deployment skills.

Follow - Vilsi jain
Linkedin - https://www.linkedin.com/in/vilsijain08/

AWS API Gateway with Terraform

Vilsi Jain — Thu, 20 Jan 2022 11:49:57 +0000

__Most of the projects start as a monolith and then, in time, comes the part where we start splitting it in the “microservices” we all love. With this change in architecture there will be a part of your code that will start to look like a router, where it receives some request from the outside world and proceeds to redirect it to whoever is responsible for answering it. The AWS API Gateway is here so, we can lift those concerns from your service. We can even add more cross-cutting concerns to it (like authentication or rate limiting). Having this approach will even help with the latency of your response as it will skip the step of interpreting code to know were it should go, because it’s doing it directly in the AWS API Gateway.
Enough chit-chat and let’s get some coding done, starting with the creation of the api entry:
resource “aws_api_gateway_rest_api” “api” { name = “api-gateway” description = “Proxy to handle requests to our API”
}
In here we are creating the REST API resource to where all the requests are going to hit. Next we will start to configure what we want this API to do:
`resource "aws_api_gateway_resource" "resource" {
rest_api_id = "${aws_api_gateway_rest_api.api.id}"
parent_id = "${aws_api_gateway_rest_api.api.root_resource_id}"
path_part = "{proxy+}"
}
resource "aws_api_gateway_method" "method" {
rest_api_id = "${aws_api_gateway_rest_api.api.id}"
resource_id = "${aws_api_gateway_resource.resource.id}"
http_method = "ANY"
authorization = "NONE"
request_parameters = {
"method.request.path.proxy" = true
}
}
resource "aws_api_gateway_integration" "integration" {
rest_api_id = "${aws_api_gateway_rest_api.api.id}"
resource_id = "${aws_api_gateway_resource.resource.id}"
http_method = "${aws_api_gateway_method.method.http_method}"
integration_http_method = "ANY"
type = "HTTP_PROXY"
uri = "http://your.domain.com/{proxy}"

request_parameters = {
"integration.request.path.proxy" = "method.request.path.proxy"
}
}`
Let’s do this in small steps so it’s clearer what is happening here.

Resource
This is where we’ll configure on what endpoint are we listening for requests. The path_part argument will contain a string that represents the endpoint path, as our case is a simple proxy, AWS provides a special handler to listen all the requests, the "{proxy+}". This handler can also be applied to a more specific path, i.e "users/{proxy+}" where it will listen to anything starting with users ( i.e users/1/posts , users/3/notes , etc). The other values presented in there are related to where will this resource be applied, the rest_api_id will have the id of what API we are mounting this resource and the parent_id has the id of the parent on where are mounting this. This last one can be mounted directly on the root api (as we have) or mounted in another resource making it a child resource that will be composed by both parent and child. So if you have the path_part defined as "active" in the child resource and it’s mounted in the users resource, the child resource will listen to a users/active endpoint.

Method

In the method resource is were we build the specification of the endpoint we are listening. The http_method argument will have the string with what HTTP method we’re interested, the "ANY" value is, again, a special handler where we’ll accept any HTTP method that comes our way. In the case we have in hands we won’t need any authorization done in our AWS API Gateway, and that’s why the value in authorization is "NONE" . The request_parameters argument, will state that we will have something in a proxy handler required for this method and that will passed to the integration resource (described next).This resource also has some arguments related to where it should be mounted, namely the rest_api_id that is the same as the one described in the Resource resource and the resource_id that represents to what resource it should be related to.
Integration

The integration resource is related to how are we going to react to the request that we just received, it could go from passing the request to a backend, run some lambda function or even doing nothing with it. Besides the arguments previously referenced ( rest_api_id and resource_id ), we have the http_method argument that will be the same as the method resource (that’s why we link both of them with the "${aws_api_gateway_method.method.http_method}" ), the integration_http_method argument represents the HTTP method that will be done from the integration to our backend (again the "ANY" value is a special one) and we have the type argument where we configure what type of integration this is. As for the uri argument it will contain the endpoint to where we are proxying to, and the request_paramenters argument will map what we need from the method resource to our request to the backend, in our case we are are replacing the {proxy} handler present in the uri argument with the path that comes after the domain of our API Gateway.
The way that all of this can be grouped together is that a method and a integration are wrapped around a resource, the method will be responsible on how can the API Gateway be reached and the integration will be responsible in interacting with the backend. Kinda like this:

AWS API gateway working 🎉 If we go to

https://api-gateway.execute-api.{region}.amazonaws.com (the {region} is the region where you’ll deploy the API, i.e eu-west-1) we’ll be communicating with our API Gateway.

Journey of Hackathon

Vilsi Jain — Sun, 18 Apr 2021 08:58:26 +0000

What is a hackathon?
Hackathon which makes ideas into real world problem solutions , which make you connect with like minded people it make you a good team leader , grow your skills and work with different partners.
I started my journey of hackathon in 1st year itself without knowing much, just made my team and started that time I am not a winner. I am a learner and then till now I take part in an 8+ hackathon and now I am a mentor in a hackathon.
Who can join — In mostly Hackathon is beginner friendly everyone can participate in that just you need to make a good team and develop technical skills or if you don’t have just give it and learn the working pattern.

Getting Started:
1)Find Your Hackathon best fits on you From what I observed I found that the best profile of hackers are people who:
They are highly competitive with a hunger to win
bored by “just talking about it” and have the passion to see real results
get energized by pressure deadlines
fueled by finding like-minded people to idea to and work with

2. First Decided to make a team of technical and good leader.

FORMING TEAM:
Team chemistry and makeup is one of the most important factors not only in winning, but also in making sure that you don’t burn out. To ensure that you have a chance, here are some tips:
Pitch your idea during the initial pitching session and get folks to buy-in on sharing your vision.
Join a team that already has a front-end engineer. This is a key role that I’ll describe in further detail below.
Have a team of friends or previous hackers to participate with. Knowing each member’s strengths and weaknesses beforehand gives you an advantage in preparation and execution.

3.Employ These Strategies to Be Part of the Best Team- Make good strategies and make everyone on your team give their points and if you have a good team you will always have a chance to make sure that you are in the right direction.

4.Understanding the Judges Panel is Key How to work- this is the best which help me to win understand the background of Judges what they want from you or in which field they are more proficient with this you will get idea that in which field you should focus more and pitch your idea.

5.Decide Your Approach your topic and according to your skills divide it- Yes, always problem or field is given or open to all in that situation

1)team member should meet and discuss the innovative idea 2)approach how to make it skills required 3)Divide the work on the skills of person.

6.It’s for good time Utilize it best Hackathons- typically last 24–48 hours, and the time will fly (especially if you want time for meals and sleep!).Get a general sense of who on your team will work on what, and approximately how long you expect it to take. Timebox tasks, noting when you will “just move on,” even if you can’t get things to work. Bugs can creep up anywhere — and a hackathon is no exception. Deciding in advance how much time you’ll allow for the different parts of your project, and when you’ll move on to a plan B, will help ensure that you have something to demo come pitch time.

7.Learn How to Effectively Validate Your Idea and present it- presentation is main to win means putting your ideas in front of judges is most important and you
It’s for good time Utilize it best Hackathons typically last 24–48 hours, and the time will fly (especially if you want time for meals and sleep!).Get a general sense of who on your team will work on what, and approximately how long you expect it to take. Time box tasks, noting when you will “just move on,” even if you can’t get things to work. Bugs can creep up anywhere — and a hackathon is no exception. Deciding in advance how much time you’ll allow for the different parts of your project, and when you’ll move on to a plan B, will help ensure that you have something to demo come pitch time.
Learn How to Effectively Validate Your Idea and present it presentation is main to win means putting your ideas in front of judges is most important and you

8.Always write your mistake which you done and work upon it-

This is the most important one “Learn from your mistake and try not to revise that in next”

My best experience of winning Hackathon from Incubatedind (https://www.incubateind.com/ ) ,Code-n-build ,CIS, Github and my MLH Hackathons,Zeta Hacks3.0 other Hackathon experience is also cool as we always learn from that
IncubatedInd make best experience of your Hackathon I think you once checkout.