cloud native monitoring app

Monitoramento nativo da nuvem

Implantando um aplicativo construído com python usando o Flask e Psutil no ECR e Kubernete

Este é um aplicativo de monitoramento construído com Python e seria contornado com o Docker e implantado em EKS

Pré -requisitos

• Aprenda Docker e como contêiner um aplicativo Python
• Criando Dockerfile
• Building Dockerimage
• Contêiner em execução do Docker
• Comandos do docker
• Crie repositório de ECR usando Python BOTO3 e empurrando a imagem do Docker para o ECR
• Aprenda Kubernetes e crie cluster eks e nodegrupos
• Crie implantações e serviços Kubernetes usando o Python!

Etapa 1 - Instalações de serviços em sua estação de trabalho

• Instale a AWS CLI, depois vá para sua conta AWS e obtenha suas chaves secretas e configure o espaço de trabalho aws configure
• Instale o Python em sua estação de trabalho e uma extensão python no vscode
• O aplicativo usa as bibliotecas psutil e Flask , plotly, BOTO3 . Instale -os usando o PIP pip3 install -r requirements.txt
• Instale dependências Psutil pip3 install psutil e Flask pip install flask
• Instale o python para o ecr sdk pip install boto3
• Instale o Kubernetes, adicione a biblioteca de clientes do K8S Python dependências pip install kubernetes a extensão de Kubernetes no VSCODE
• Instale a extensão do Docker no vscode

Etapa 2: Execute o aplicativo

Para executar o aplicativo, navegue até o diretório raiz do projeto e execute o seguinte comando:

 $ python3 app.py

Isso iniciará o servidor Flask no localhost:5000 . Navegue para http: // localhost: 5000/no seu navegador para acessar o aplicativo.

Etapa 3: Dockerizando o aplicativo Flask

• Crie um Dockerfile no diretório raiz do projeto com o seguinte conteúdo:

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

• Construa a imagem do Docker, execute o seguinte comando:

 $ docker build -t <image_name> .

• Execute o contêiner do Docker, execute o seguinte comando:

 $ docker run -p 5000:5000 <image_name>

Isso iniciará o servidor Flask em um contêiner do Docker no localhost:5000 . Navegue para http: // localhost: 5000/no seu navegador para acessar o aplicativo.

Etapa 4 - empurrando a imagem do Docker para o ECR

• Crie um repositório de ECR usando o Python em uma pasta ecr.py :
• Configure o repositório ECR para o seu espaço de trabalho para permitir um empurrão, você encontrará o processo no console 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 )

Em seguida, execute este python3 ecr.py

• Empurre a imagem do Docker para o ECR usando os comandos push no console:

 $ docker push <ecr_repo_uri>:<tag>

Etapa 5 - Criando um cluster EKS e implantando o aplicativo usando Python **

• Crie um cluster cloud-native-cluster eks e adicione o Grupo de Nó no Console da AWS

• Crie um nodes do grupo de nós no cluster EKS.

• Crie implantação e serviço em uma pasta 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
)

Certifique -se de editar o nome da imagem na linha 25 com o URL da sua imagem.

Para executar os comandos K8S para implantação e serviço, em vez de adicionar o script python, você cria deployment.yml and service.yml use esses comandos kubectl apply -f deployment.yml e kubectl apply -f service.yml

• Configure o AWS EKS para o seu espaço de trabalho

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

• Depois de executar esse arquivo executando a implantação e o serviço Python3 Eks.py "será criado.
• Verifique a execução dos seguintes 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

Quando o seu pod estiver em funcionamento, execute a porta para expor o serviço

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

Bata a estrela!

Se você planeja usar este repositório para aprender, bata na estrela. Obrigado!

Autor de Harshhaa Reddy