https://github.com/shohail-dev/cloud-native-resource-monitoring
A web application using Flask to collect and display real-time infrastructure health metrics of the CPU & memory . Also containerized the application with Docker for efficient scaling and deployed it on an Amazon EKS cluster using Kubernetes for management across multiple instances.
https://github.com/shohail-dev/cloud-native-resource-monitoring
amazon-web-services docker eks-cluster flask k8s-cluster kubernetes python3
Last synced: 7 months ago
JSON representation
A web application using Flask to collect and display real-time infrastructure health metrics of the CPU & memory . Also containerized the application with Docker for efficient scaling and deployed it on an Amazon EKS cluster using Kubernetes for management across multiple instances.
- Host: GitHub
- URL: https://github.com/shohail-dev/cloud-native-resource-monitoring
- Owner: shohail-DeV
- Created: 2024-06-25T07:46:09.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2024-06-26T15:23:12.000Z (over 1 year ago)
- Last Synced: 2025-01-07T20:12:43.389Z (9 months ago)
- Topics: amazon-web-services, docker, eks-cluster, flask, k8s-cluster, kubernetes, python3
- Language: HTML
- Homepage:
- Size: 4.88 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# **Cloud Native Resource Monitoring Python App on K8s!**
## Skillst Acquired in:
1. Running a Python App locally .
2. Docker and containerization of a Python application .
- Creating Dockerfile
- Building DockerImage
- Running Docker Container
- Docker Commands
3. Creation of ECR repository using Python Boto3 and pushing Docker Image to ECR .
4. Kubernetes and development of EKS cluster and nodegroups .
5. Kubernetes deployments and services using Python .
## **1: Creating a Python Flask application**
## **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
```