cloud native monitoring app

Aplicación de monitorización nativa de nubes

Implementar una aplicación construida con Python usando Flask y Psutil en ECR y Kubernete

Esta es una aplicación de monitoreo construida con Python, y se contanerizaría con Docker y se implementa en EKS

Requisitos previos

• Aprenda Docker y cómo contener una aplicación de Python
• Creación de Dockerfile
• Edificio Dockerimage
• Ejecutando el contenedor Docker
• Comandos de Docker
• Crear repositorio de ECR usando Python Boto3 y empujar la imagen de Docker a ECR
• Aprender kubernetes y crear clúster eks y nodegroups
• ¡Crea implementaciones y servicios de Kubernetes usando Python!

Paso 1 - Instalaciones de servicios en su estación de trabajo

• Instale AWS CLI, luego vaya a su cuenta de AWS y obtenga sus claves secretas y configure el espacio de trabajo aws configure
• Instale Python en su estación de trabajo y una extensión de Python en VScode
• La aplicación utiliza las bibliotecas psutil y Flask , Plotly, Boto3 . Instalarlos usando PIP pip3 install -r requirements.txt
• Instalar dependencias Psutil pip3 install psutil y Flask pip install flask
• Instale Python para ECR SDK pip install boto3
• Instale Kubernetes, agregue el K8S Python Dependencias Biblioteca de clientes pip install kubernetes la extensión de Kubernetes en VScode
• Instale la extensión Docker en VScode

Paso 2: ejecute la aplicación

Para ejecutar la aplicación, navegue al directorio raíz del proyecto y ejecute el siguiente comando:

 $ python3 app.py

Esto iniciará el servidor Flask en localhost:5000 . Navegue a http: // localhost: 5000/en su navegador para acceder a la aplicación.

Paso 3: Dockerizing de la aplicación Flask

• Cree un Dockerfile en el directorio raíz del proyecto con los siguientes contenidos:

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

• Construya la imagen Docker, ejecute el siguiente comando:

 $ docker build -t <image_name> .

• Ejecute el contenedor Docker, ejecute el siguiente comando:

 $ docker run -p 5000:5000 <image_name>

Esto iniciará el servidor Flask en un contenedor Docker en localhost:5000 . Navegue a http: // localhost: 5000/en su navegador para acceder a la aplicación.

Paso 4 - Empujar la imagen Docker a ECR

• Cree un repositorio ECR usando Python en una carpeta ecr.py :
• Configure el repositorio de ECR en su espacio de trabajo para habilitar un empuje, encontrará el proceso en la 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 )

Luego ejecute este python3 ecr.py

• Empuje la imagen Docker a ECR usando los comandos PUSH en la consola:

 $ docker push <ecr_repo_uri>:<tag>

Paso 5: crear un clúster EKS e implementar la aplicación usando Python **

• Cree un cloud-native-cluster eks y agregue el grupo de nodos en la consola AWS

• Cree un grupo de nodos nodes en el clúster EKS.

• Crear implementación y servicio en una carpeta 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
)

Asegúrese de editar el nombre de la imagen en la línea 25 con su URL de imagen.

Para ejecutar los comandos K8S para la implementación y el servicio en lugar de agregar el script de Python, crea deployment.yml and service.yml Use estos comandos kubectl apply -f deployment.yml y kubectl apply -f service.yml

• Configure los AWS EKS en su espacio de trabajo

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

• Una vez que ejecute este archivo ejecutando la implementación y el servicio "Python3 Eks.py".
• Compruebe ejecutando los siguientes comandos:

 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

Una vez que su vaina esté en funcionamiento, ejecute el puerto hacia adelante para exponer el servicio

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

¡Golpea la estrella!

Si planea usar este repositorio para aprender, presione la estrella. ¡Gracias!

Autor de Harshhaa Reddy