AWS Builder Center

From Localhost to the Cloud: Deploying an AI-Powered Application on AWS

Learn how to deploy an AI-powered Flask application from localhost to AWS using Amazon EC2 and Amazon Bedrock. This guide covers local development, AI integration, IAM permissions, secure deployment, server setup, testing, monitoring, and common deployment issues. It explains how to move from a simple AI prototype to a cloud-hosted application while following practical security and deployment practices.

From Localhost to the Cloud: Deploying an AI-Powered Application on AWS

Build locally, connect generative AI with Amazon Bedrock, and deploy a Python application to Amazon EC2

Introduction

Building an AI application on a local machine is exciting. You install Python, create a virtual environment, connect your application to an AI model, and suddenly you have a working prototype.
But a prototype running on  localhost  is only the beginning.
The next challenge is making that application accessible through the internet, securely connecting it to cloud services, managing credentials correctly, and creating an environment that can be maintained as the application grows.
In this article, I will walk through the journey of taking a simple AI-powered Flask application from localhost to AWS.
The architecture uses:
  • Python + Flask for the web application
  • Amazon Bedrock for generative AI inference
  • Amazon EC2 to host the application
  • AWS IAM for permissions
  • Boto3 to communicate with AWS services
  • Security Groups to control network access
Amazon Bedrock provides access to foundation models through AWS APIs, while the Converse API provides a consistent interface for models that support conversational messages. AWS recommends using Converse when supported because it provides a unified interface across supported models.
The goal is simple:
Take an AI application from  localhost  to a publicly accessible AWS environment without hard-coding cloud credentials into the application.



1. The Problem: Localhost Is Not Production

During development, an application might look like this:
User
|
v
localhost:5000
|
v
Flask Application
|
v
AI Model
This works perfectly for development.
However, other users cannot access your application because  localhost  refers to your own machine.
A cloud deployment changes the architecture:
Internet
|
v
AWS EC2 Instance
|
v
Flask Application
|
v
Amazon Bedrock
|
v
Foundation Model
Now the application has a public cloud environment capable of serving requests remotely.



2. Why Amazon Bedrock?

One of the biggest challenges when building generative AI applications is managing the infrastructure around the model.
Instead of hosting a foundation model yourself, Amazon Bedrock provides managed access to foundation models through AWS APIs.
This means the application can focus on the user experience and application logic while AWS manages the underlying model infrastructure.
Amazon Bedrock supports multiple foundation models and provides APIs such as  Converse  and  Invoke . The Converse API is particularly useful for conversational applications because it provides a standardized interface across supported models.
For this project, the application will send a user prompt to Amazon Bedrock and return the generated response.



3. Application Architecture

The final architecture looks like this:
┌───────────────────┐
│ User │
│ Web Browser │
└─────────┬─────────┘
│
│ HTTP/HTTPS
▼
┌───────────────────┐
│ AWS EC2 │
│ │
│ Flask Web App │
└─────────┬─────────┘
│
│ Boto3
▼
┌───────────────────┐
│ Amazon Bedrock │
│ Runtime API │
└─────────┬─────────┘
│
▼
┌───────────────────┐
│ Foundation Model │
└───────────────────┘
The important point is that the Flask application does not directly host the AI model.
Instead:
  1. The user sends a request.
  1. Flask receives the request.
  1. Flask creates a prompt.
  1. Boto3 sends the request to Amazon Bedrock.
  1. Bedrock invokes the selected model.
  1. The generated response is returned.
  1. Flask sends the result back to the user.



4. Building the Application Locally

Before touching AWS, it is important to make the application work locally.
Create a project directory:
mkdir aws-ai-app
cd aws-ai-app
Create a Python virtual environment:
python -m venv venv
Activate it on Windows:
venv\Scripts\activate
On Linux or macOS:
source venv/bin/activate
Install the required packages:
pip install flask boto3
Create a file named:
app.py



5. Creating the Flask Application

The basic application can look like this:
from flask import Flask, request, jsonify
import boto3
import os
app = Flask(__name__)
AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
MODEL_ID = os.getenv("MODEL_ID", "amazon.nova-micro-v1:0")
bedrock = boto3.client(
"bedrock-runtime",
region_name=AWS_REGION
)
@app.route("/")
def home():
return "AI application is running!"
@app.route("/ask", methods=["POST"])
def ask():
data = request.get_json()
prompt = data.get("prompt")
if not prompt:
return jsonify({
"error": "Prompt is required"
}), 400
response = bedrock.converse(
modelId=MODEL_ID,
messages=[
{
"role": "user",
"content": [
{
"text": prompt
}
]
}
],
inferenceConfig={
"maxTokens": 512,
"temperature": 0.5
}
)
answer = response["output"]["message"]["content"][0]["text"]
return jsonify({
"response": answer
})
if __name__ == "__main__":
app.run(
host="0.0.0.0",
port=5000,
debug=True
)
The important part is the Bedrock call:
response = bedrock.converse(
modelId=MODEL_ID,
messages=[
{
"role": "user",
"content": [
{
"text": prompt
}
]
}
]
)
The AWS documentation provides Boto3 examples for using the Converse API and recommends it over  InvokeModel  when supported.



6. Don't Hard-Code AWS Credentials

One of the most important lessons when moving an application to AWS is:
Never put AWS access keys directly inside your source code.
Avoid code like:
boto3.client(
"bedrock-runtime",
aws_access_key_id="YOUR_KEY",
aws_secret_access_key="YOUR_SECRET"
)
If this code is pushed to GitHub, those credentials could potentially be exposed.
Instead, AWS applications should use an appropriate identity mechanism.
For an EC2-hosted application, an IAM role attached to the EC2 instance is a much better approach.
AWS IAM is designed to control which identities can access AWS resources, and AWS recommends applying the principle of least privilege so identities receive only the permissions they actually need.



7. Test the Application Locally

Start Flask:
python app.py
You should see something similar to:
Running on http://127.0.0.1:5000
Open the application in your browser:
http://localhost:5000
For the AI endpoint, a request can be sent to:
POST /ask
with:
{
"prompt": "Explain cloud computing in simple terms."
}
The application should return:
{
"response": "Cloud computing is..."
}
At this point, the AI application works locally.
Now comes the interesting part.



8. Moving the Application to AWS

The next step is to create a virtual server using Amazon EC2.
Amazon EC2 provides virtual servers in the AWS Cloud. AWS supports several ways to connect to Linux EC2 instances, including SSH and EC2 Instance Connect.
The high-level process is:
Create EC2 Instance
|
v
Configure Security Group
|
v
Connect to Instance
|
v
Install Python
|
v
Upload Application
|
v
Install Dependencies
|
v
Configure IAM Role
|
v
Run Flask Application



9. Creating the EC2 Instance

From the AWS Management Console:
  1. Open Amazon EC2.
  1. Choose Launch Instance.
  1. Select a Linux AMI such as Ubuntu.
  1. Choose an appropriate instance type.
  1. Configure the key pair or another supported connection method.
  1. Configure the network settings.
  1. Create the instance.
For a learning project, a small instance is generally sufficient for the web application itself.
The AI model is not running inside the EC2 instance. EC2 is hosting the Flask application while Amazon Bedrock handles model inference.



10. Configure the Security Group

A security group acts as a virtual firewall for EC2 instances.
It controls inbound and outbound traffic to the instance. AWS documentation describes security groups as stateful virtual firewalls that can control access such as SSH, HTTP, and HTTPS.
For example:
Type
Port
Purpose
SSH
22
Server administration
HTTP
80
Web traffic
HTTPS
443
Secure web traffic
For SSH, avoid allowing the entire internet when it is not necessary.
Instead of:
0.0.0.0/0
prefer restricting SSH access to your own IP address or an appropriate trusted network.
AWS also documents restricting SSH access to the public IP address of the connecting computer.



11. Connect to the EC2 Instance

After launching the instance, connect using SSH or EC2 Instance Connect.
For an SSH-based connection, the command will look similar to:
ssh -i my-key.pem ubuntu@YOUR_EC2_PUBLIC_IP
After connecting:
sudo apt update
Then install Python:
sudo apt install python3 python3-pip python3-venv -y
Verify:
python3 --version



12. Upload the Application

There are several ways to transfer your project to EC2.
For example, using Git:
git clone YOUR_GITHUB_REPOSITORY
Then:
cd aws-ai-app
Create the virtual environment:
python3 -m venv venv
Activate it:
source venv/bin/activate
Install dependencies:
pip install -r requirements.txt
A basic  requirements.txt  could contain:
Flask
boto3
gunicorn



13. Give EC2 Permission to Use Amazon Bedrock

This is one of the most important parts of the deployment.
Instead of storing AWS credentials on the server, create an IAM role for the EC2 instance.
The role should contain only the permissions required by the application.
For this example, the application needs permission to invoke the selected Bedrock model.
Conceptually:
EC2 Instance
|
v
IAM Role
|
v
Permission to invoke Bedrock
|
v
Amazon Bedrock
This approach avoids putting long-lived AWS credentials inside the application.
It also follows the least-privilege principle recommended by AWS IAM guidance.



14. Configure Environment Variables

Instead of hard-coding configuration values, use environment variables.
For example:
export AWS_REGION="us-east-1"
export MODEL_ID="your-supported-model-id"
Then the application reads them using:
AWS_REGION = os.getenv("AWS_REGION")
MODEL_ID = os.getenv("MODEL_ID")
This makes the application easier to move between development, testing, and production environments.
It also means changing the model does not require modifying the application source code.



15. Run the Application on EC2

For testing, Flask can be started with:
python3 app.py
The application listens on:
0.0.0.0:5000
You would then need to allow port  5000  in the security group for testing.
However, exposing the Flask development server directly to the public internet is not a good production architecture.
A better deployment uses a production WSGI server such as Gunicorn and typically places a reverse proxy such as Nginx in front of it.



16. Use Gunicorn

Install Gunicorn:
pip install gunicorn
Run:
gunicorn --bind 0.0.0.0:5000 app:app
The structure is:
Internet
|
v
Web Server / Reverse Proxy
|
v
Gunicorn
|
v
Flask
|
v
Amazon Bedrock
This provides a cleaner deployment structure than using Flask's development server.



17. Testing the Cloud Application

Once the EC2 instance is configured, test the application using its public address.
For example:
http://YOUR_EC2_PUBLIC_IP
Then send an AI request:
{
"prompt": "Give me three ideas for a beginner cloud project."
}
The request travels through the application and eventually reaches Amazon Bedrock.
The complete flow is:
Browser
|
| HTTP request
v
EC2
|
| Flask
v
Boto3
|
| AWS API request
v
Amazon Bedrock
|
| Model inference
v
AI response
|
v
Flask
|
v
Browser
And just like that, the application has moved from localhost to the cloud.



18. Improving the Architecture

The basic EC2 deployment is useful for learning, but a production application can be improved significantly.
A more complete architecture could look like:
Users
|
v
┌───────────────┐
│ Amazon Route 53│
└───────┬───────┘
|
v
┌───────────────┐
│ Load Balancer │
└───────┬───────┘
|
┌────────┴────────┐
v v
EC2 Instance EC2 Instance
| |
└────────┬────────┘
|
v
Amazon Bedrock
|
v
Foundation Model
Additional AWS services can be introduced depending on the application's requirements.
For example:
  • Amazon CloudWatch for monitoring and logs
  • Amazon S3 for object storage
  • Amazon DynamoDB for application data
  • Application Load Balancer for distributing traffic
  • AWS Certificate Manager for TLS certificates
  • Amazon Route 53 for DNS
  • AWS Secrets Manager for sensitive application secrets
The important principle is not to add AWS services simply because they exist.
Choose a service when it solves a real problem.



19. Security Considerations

Moving an application to the cloud introduces new security responsibilities.

19.1 Protect credentials

Never commit:
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
to GitHub.
Use IAM roles where possible.

19.2 Restrict IAM permissions

If the application only needs to invoke Bedrock, it should not receive broad administrator permissions.
The goal is:
Required permission
↓
Grant only that permission
rather than:
Give AdministratorAccess
↓
Hope nothing goes wrong

19.3 Restrict network access

Only expose the ports that are required.
For example:
SSH → restricted source
HTTP → application traffic
HTTPS → secure application traffic
Security groups are specifically designed to control inbound and outbound traffic at the EC2 instance level.

19.4 Use HTTPS

For a real application, HTTPS should be used instead of sending user traffic over plain HTTP.

19.5 Protect user input

AI applications should validate and sanitize incoming data.
Never assume that user input is safe.



20. Monitoring the Application

A deployment is not complete just because the application is reachable.
You also need to know:
  • Is the server running?
  • Are requests failing?
  • Is the AI service responding?
  • How long are requests taking?
  • Is the application consuming too many resources?
This is where monitoring becomes important.
A production architecture can use Amazon CloudWatch for application and infrastructure monitoring.
Useful metrics include:
Request count
Error rate
Response latency
CPU utilization
Memory utilization
AI invocation failures
Monitoring transforms deployment from:
"It works on my server."
into:
"I know how my application is behaving."



21. Common Problems During Deployment

Moving from localhost to AWS is rarely completely smooth.
Here are some common problems developers encounter.

Problem 1: The application works locally but not on EC2

Possible causes:
  • Security group configuration
  • Incorrect port
  • Application binding only to  127.0.0.1 
  • Process stopped
  • Firewall configuration
Make sure the application listens on:
host="0.0.0.0"
rather than only:
host="127.0.0.1"



Problem 2: Bedrock access is denied

A common cause is insufficient IAM permissions.
Check:
EC2
↓
IAM Role
↓
Bedrock permissions
Also verify that the selected model is available and enabled for the AWS Region/account configuration you are using.



Problem 3: Credentials work locally but fail on EC2

This often happens when credentials are configured locally but the EC2 instance has no appropriate IAM role.
The solution is not to copy your personal AWS access keys to the server.
Instead, configure an appropriate IAM role for the workload.



Problem 4: The AI application becomes slow

Possible causes include:
  • High model latency
  • Too many simultaneous requests
  • Large prompts
  • Large response sizes
  • Insufficient EC2 resources
This is where monitoring and performance testing become important.



22. What I Learned From the Deployment

The biggest lesson from moving an AI application from localhost to AWS is that deployment is not simply:
Upload code → Done
A cloud application requires several layers to work together:
Application
+
Compute
+
Identity
+
Networking
+
AI Service
+
Security
+
Monitoring
Each layer solves a different problem.
The application contains the business logic.
EC2 provides the compute environment.
IAM controls permissions.
Security Groups control network access.
Amazon Bedrock provides managed access to foundation models.
Monitoring helps understand what is happening after deployment.



23. From Prototype to Production

The EC2 deployment described here is an excellent starting point, but the architecture can evolve as the application grows.
A future version could introduce:
Frontend
|
v
Load Balancer
|
v
Auto Scaling EC2 / Containers
|
v
Application API
|
├───────────────┐
v v
Amazon Bedrock Database
|
v
Foundation Model
Eventually, the application could move toward containerized or serverless architectures depending on workload, scalability, and operational requirements.
The important thing is to evolve the architecture based on actual requirements rather than adding complexity prematurely.



24. Final Takeaways

Taking an AI application from localhost to AWS taught me that cloud development is as much about architecture and security as it is about writing code.
The journey can be summarized as:
Local Development
↓
Flask Application
↓
Amazon Bedrock Integration
↓
EC2 Deployment
↓
IAM Permissions
↓
Security Groups
↓
Production Web Server
↓
Monitoring
↓
Scalable Cloud Architecture
The most important lessons are:
  1. Build and test locally before deploying.
  1. Use managed AI services when they simplify infrastructure.
  1. Never hard-code AWS credentials.
  1. Use IAM roles and least-privilege permissions.
  1. Configure network access carefully.
  1. Use a production WSGI server instead of Flask's development server.
  1. Monitor the application after deployment.
  1. Add cloud services only when they solve a real problem.
What started as an application running on:
localhost:5000
can become a cloud-hosted AI application accessible from anywhere.
That transition—from writing code on a laptop to designing and operating a cloud workload—is one of the most valuable steps in learning modern application development.



Conclusion

Cloud development is not about replacing localhost.
It is about taking something that already works and giving it the infrastructure, security, scalability, and reliability needed to serve real users.
By combining Flask, Amazon EC2, AWS IAM, Boto3, and Amazon Bedrock, developers can build a practical path from an AI prototype to a cloud-hosted application.
The next step is not necessarily to use more AWS services.
The next step is to understand why each service exists, what problem it solves, and when it should be introduced.
That mindset is what turns a simple deployment into cloud engineering.



AWS Resources

Tags:  AWS   Amazon Bedrock   Amazon EC2   Generative AI   Python   Flask   Boto3   Cloud Computing   AI   AWS Builder 
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article