Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/anindyadas2001/aws_project_1
Resource Monitoring Application ( containerized using docker, and hosted / scalable using Kubernetes) AWS CLoud Project
https://github.com/anindyadas2001/aws_project_1
Last synced: about 6 hours ago
JSON representation
Resource Monitoring Application ( containerized using docker, and hosted / scalable using Kubernetes) AWS CLoud Project
- Host: GitHub
- URL: https://github.com/anindyadas2001/aws_project_1
- Owner: anindyadas2001
- Created: 2024-05-27T11:29:53.000Z (6 months ago)
- Default Branch: main
- Last Pushed: 2024-08-04T19:22:03.000Z (3 months ago)
- Last Synced: 2024-08-05T19:58:11.824Z (3 months ago)
- Language: HTML
- Homepage:
- Size: 319 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# **System Resource Monitoring Application (Cloud Native)**
1. Created Monitoring Application in Python using Flask
2. Containerized a Python application
- [x] Created Dockerfile
- [x] Built DockerImage
- [x] Ran Docker Container
3. Created ECR repository using Python Boto3 and pushing Docker Image to ECR
4. Created EKS cluster and Nodegroups
5. Create Kubernetes Deployments and Services using Python
## **Must Haves**
- [x] AWS Account.
- [x] Programmatic access and AWS configured with CLI.
- [x] Python3.
- [x] Docker and Kubectl .
- [x] IDE ( Vscode )
## **Syetem Design**
# Process
## **Part 1: Deploying the Flask application locally**
### **Step 1: Clone the code**
Clone the code from the repository:
```
git clone
```
### **Step 2: Install dependencies**
The application uses the **`psutil`** and **`Flask`, Plotly, boto3** libraries. Install them using pip:
```
pip3 install -r requirements.txt
```
### **Step 3: Run the application**
To run the application, navigate to the root directory of the project and execute the following command:
```
python3 app.py
```
This will start the Flask server on **`localhost:5000`**. Navigate to [http://localhost:5000/](http://localhost:5000/) on your browser to access the application.
## **Part 2: Dockerizing the Flask application**
### **Step 1: Create a Dockerfile**
Create a **`Dockerfile`** in the root directory of the project with the following contents:
```
# Use the official Python image as the base image
FROM python:3.9-slim-buster
# Set the working directory in the container
WORKDIR /app
# Copy the requirements file to the working directory
COPY requirements.txt .
RUN pip3 install --no-cache-dir -r requirements.txt
# Copy the application code to the working directory
COPY . .
# Set the environment variables for the Flask app
ENV FLASK_RUN_HOST=0.0.0.0
# Expose the port on which the Flask app will run
EXPOSE 5000
# Start the Flask app when the container is run
CMD ["flask", "run"]
```
### **Step 2: Build the Docker image**
To build the Docker image, execute the following command:
```
docker build -t .
```
### **Step 3: Run the Docker container**
To run the Docker container, execute the following command:
```
docker run -p 5000:5000
```
This will start the Flask server in a Docker container on **`localhost:5000`**. Navigate to [http://localhost:5000/](http://localhost:5000/) on your browser to access the application.
## **Part 3: Pushing the Docker image to ECR**
### **Step 1: Create an ECR repository**
Create an ECR repository using Python:
```
import boto3
# Create an ECR client
ecr_client = boto3.client('ecr')
# Create a new ECR repository
repository_name = 'my-ecr-repo'
response = ecr_client.create_repository(repositoryName=repository_name)
# Print the repository URI
repository_uri = response['repository']['repositoryUri']
print(repository_uri)
```
### **Step 2: Push the Docker image to ECR**
Push the Docker image to ECR using the push commands on the console:
```
docker push :
```
## **Part 4: Creating an EKS cluster and deploying the app using Python**
### **Step 1: Create an EKS cluster**
Create an EKS cluster and add node group
### **Step 2: Create a node group**
Create a node group in the EKS cluster.
### **Step 3: Create deployment and service**
```jsx
from kubernetes import client, config
# Load Kubernetes configuration
config.load_kube_config()
# Create a Kubernetes API client
api_client = client.ApiClient()
# Define the deployment
deployment = client.V1Deployment(
metadata=client.V1ObjectMeta(name="my-flask-app"),
spec=client.V1DeploymentSpec(
replicas=1,
selector=client.V1LabelSelector(
match_labels={"app": "my-flask-app"}
),
template=client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(
labels={"app": "my-flask-app"}
),
spec=client.V1PodSpec(
containers=[
client.V1Container(
name="my-flask-container",
image="568373317874.dkr.ecr.us-east-1.amazonaws.com/my-cloud-native-repo:latest",
ports=[client.V1ContainerPort(container_port=5000)]
)
]
)
)
)
)
# Create the deployment
api_instance = client.AppsV1Api(api_client)
api_instance.create_namespaced_deployment(
namespace="default",
body=deployment
)
# Define the service
service = client.V1Service(
metadata=client.V1ObjectMeta(name="my-flask-service"),
spec=client.V1ServiceSpec(
selector={"app": "my-flask-app"},
ports=[client.V1ServicePort(port=5000)]
)
)
# Create the service
api_instance = client.CoreV1Api(api_client)
api_instance.create_namespaced_service(
namespace="default",
body=service
)
```
make sure to edit the name of the image on line 25 with your image Uri.
- Once you run this file by running “python3 eks.py” deployment and service will be created.
- Check by running following commands:
```jsx
kubectl get deployment -n default (check deployments)
kubectl get service -n default (check service)
kubectl get pods -n default (to check the pods)
```
Once your pod is up and running, run the port-forward to expose the service
```bash
kubectl port-forward service/ 5000:5000
```