cloud native monitoring app

Cloud-native-montoring-app

Déploiement d'une application construite avec Python à l'aide de Flask et Putil sur ECR et Kubernete

Ceci est une application de surveillance construite avec Python, et elle serait contaminée avec Docker et déployée sur EKS

Condition préalable

• Apprendre docker et comment conteneriser une application python
• Création de dockerfile
• Bâtiment dockingrimage
• Conteneur Docker en cours d'exécution
• Commandes Docker
• Créer le référentiel ECR à l'aide de Python Boto3 et poussant l'image Docker vers ECR
• Apprenez Kubernetes et créez un cluster EKS et des groupes de nœuds
• Créez des déploiements et services de Kubernetes à l'aide de Python!

Étape 1 - Installations de services sur votre poste de travail

• Installez AWS CLI, puis accédez à votre compte AWS et obtenez vos clés secrètes et configurez l'espace de travail aws configure
• Installez Python sur votre poste de travail et une extension Python dans VSCODE
• L'application utilise les bibliothèques psutil et Flask , Plotly, Boto3 . Installez-les à l'aide de PIP pip3 install -r requirements.txt
• Installer les dépendances PSUTIL pip3 install psutil et FLASK pip install flask
• Installez Python pour ECR SDK pip install boto3
• Installez Kubernetes, ajoutez les dépendances K8S Python Bibliothèque client pip install kubernetes L'extenstion de Kubernetes dans VScode
• Installez l'extension Docker dans VSCODE

Étape 2: exécutez l'application

Pour exécuter l'application, accédez au répertoire racine du projet et exécutez la commande suivante:

 $ python3 app.py

Cela démarrera le serveur FLASK sur localhost:5000 . Accédez à http: // localhost: 5000 / sur votre navigateur pour accéder à l'application.

Étape 3: Dockerisation de l'application Flask

• Créez un Dockerfile dans le répertoire racine du projet avec le contenu suivant:

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

• Créez l'image Docker, exécutez la commande suivante:

 $ docker build -t <image_name> .

• Exécutez le conteneur Docker, exécutez la commande suivante:

 $ docker run -p 5000:5000 <image_name>

Cela démarrera le serveur FLASK dans un conteneur Docker sur localhost:5000 . Accédez à http: // localhost: 5000 / sur votre navigateur pour accéder à l'application.

Étape 4 - Pousser l'image Docker vers ECR

• Créez un référentiel ECR à l'aide de Python dans un dossier ecr.py :
• Configurez le référentiel ECR dans votre espace de travail pour activer une poussée, vous trouverez le processus dans view push commands Console

 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 )

Puis exécutez ce python3 ecr.py

• Poussez l'image Docker vers ECR à l'aide des commandes push sur la console:

 $ docker push <ecr_repo_uri>:<tag>

Étape 5 - Création d'un cluster EKS et déploiement de l'application à l'aide de Python **

• Créer un cluster cloud-native-cluster EKS Cluster et ajouter un groupe de nœuds dans la console AWS

• Créez un nodes de groupe de nœuds dans le cluster EKS.

• Créer un déploiement et un service dans un dossier 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
)

Assurez-vous de modifier le nom de l'image sur la ligne 25 avec votre URL d'image.

Pour exécuter les commandes K8S pour le déploiement et le service au lieu d'ajouter le script Python kubectl apply -f deployment.yml vous créez kubectl apply -f service.yml deployment.yml and service.yml

• Configurez les eks AWS à votre espace de travail

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

• Une fois que vous exécutez ce fichier en exécutant le déploiement et le service «python3 eks.py» seront créés.
• Vérifiez en exécutant les commandes suivantes:

 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

Une fois votre pod en cours d'exécution, exécutez le port pour exposer le service

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

Frappez l'étoile!

Si vous prévoyez d'utiliser ce dépôt pour apprendre, veuillez frapper l'étoile. Merci!

Auteur par Harshhaa Reddy