cloud native monitoring app

Cloud-Native-Überwachung-App

Bereitstellung einer App, die mit Python mit Flask und Psutil auf ECR ​​und Kubernete erstellt wurde

Dies handelt

Voraussetzungen

• Lernen Sie Docker und wie Sie eine Python -Anwendung Containerieren
• Erstellen von Dockerfile
• Bauen von Dockerimage
• Laufen Docker -Container
• Docker -Befehle
• Erstellen Sie das ECR -Repository mit Python Boto3 und drücken Sie das Docker -Bild zu ECR
• Lernen Sie Kubernetes und erstellen Sie EKS -Cluster- und Knotengruppen
• Erstellen Sie Kubernetes -Bereitstellungen und -Dienste mit Python!

Schritt 1 - Installationen von Diensten auf Ihrer Workstation

• Installieren Sie die AWS CLI, gehen Sie zu Ihrem AWS -Konto und erhalten Sie Ihre geheimen Schlüssel und aws configure
• Installieren Sie Python auf Ihrer Workstation und eine Python -Erweiterung in VSCODE
• Die Anwendung verwendet die Boto3 -Bibliotheken von psutil und Flask , Plotly, Boto3 . Installieren Sie sie mit PIP pip3 install -r requirements.txt
• Installieren Sie Abhängigkeiten PSUTIL pip3 install psutil und Flask pip install flask
• Installieren Sie Python für ECR SDK pip install boto3
• Installieren Sie Kubernetes und fügen Sie die K8S -Python -Abhängigkeiten Client Library pip install kubernetes Die Erweiterung von Kubernetes in VSCODE
• Installieren Sie die Docker -Erweiterung in VSCODE

Schritt 2: Führen Sie die Anwendung aus

Um die Anwendung auszuführen, navigieren Sie zum Stammverzeichnis des Projekts und führen Sie den folgenden Befehl aus:

 $ python3 app.py

Dadurch wird der Flask -Server auf localhost:5000 gestartet. Navigieren Sie zu http: // localhost: 5000/in Ihrem Browser, um auf die Anwendung zuzugreifen.

Schritt 3: Dockieren der Flask -Anwendung

• Erstellen Sie eine Dockerfile im Stammverzeichnis des Projekts mit dem folgenden Inhalt:

 # 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"]

• Erstellen Sie das Docker -Bild und führen Sie den folgenden Befehl aus:

 $ docker build -t <image_name> .

• Führen Sie den Docker -Container aus und führen Sie den folgenden Befehl aus:

 $ docker run -p 5000:5000 <image_name>

Dadurch wird der Flask -Server in einem Docker -Container auf localhost:5000 gestartet. Navigieren Sie zu http: // localhost: 5000/in Ihrem Browser, um auf die Anwendung zuzugreifen.

Schritt 4 - Drücken Sie das Docker -Bild auf ECR

• Erstellen Sie ein ECR -Repository mit Python in einem Ordner ecr.py :
• Konfigurieren Sie das ECR -Repository in Ihrem Arbeitsbereich, um einen Push zu aktivieren. Sie finden den Vorgang in Konsolenansicht view push commands

 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 )

Dann führen Sie diesen python3 ecr.py aus

• Drücken Sie das Docker -Bild mit den Push -Befehlen auf der Konsole zu ECR:

 $ docker push <ecr_repo_uri>:<tag>

Schritt 5 - Erstellen eines EKS -Clusters und Bereitstellen der App mit Python **

• Erstellen Sie einen EKS-Cluster cloud-native-cluster und fügen Sie die Knotengruppe in die AWS-Konsole hinzu

• Erstellen Sie einen nodes im EKS -Cluster.

• Erstellen Sie Bereitstellung und Dienst in einem Ordner eks.py

 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 )]
                    )
                ]
            )
        )
    )
)

# This is an automation to run deployment and svc using python
# 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
)

Stellen Sie sicher, dass Sie den Namen des Bildes in Zeile 25 mit Ihrer Bild -URL bearbeiten.

So führen Sie die K8S -Befehle für Bereitstellung und Service aus kubectl apply -f service.yml anstatt das Python -Skript hinzuzufügen kubectl apply -f deployment.yml das Sie erstellen deployment.yml and service.yml

• Konfigurieren Sie die AWS -EKS in Ihrem Arbeitsbereich

 aws eks update-kubeconfig --name cloud-native-cluster

• Sobald Sie diese Datei ausgeführt haben, werden Bereitstellungs- und Dienst "python3 eks.py" erstellt.
• Überprüfen Sie, indem Sie die folgenden Befehle ausführen:

 kubectl get deployment -n default (check deployments)
kubectl get service -n default (check service)
kubectl get pods <name of pod> -n default (to check the pods)

# edit images created if u made errors
kubectl edit deployment my-flask-app -n default 

# this will pull down the editted image
kubectl get pod -n default -w

Sobald Ihr Pod in Betrieb ist, führen Sie den Port-Forward aus, um den Dienst freizulegen

 kubectl port-forward service/<service_name> 5000:5000

Schlagen Sie den Stern!

Wenn Sie vorhaben, dieses Repo zum Lernen zu verwenden, drücken Sie bitte den Stern. Danke!

Autor von Harshhaa Reddy