Observabilidad de código abierto para nodos de AWS Inferentia dentro de clústeres de Amazon EKS

[ad_1]

Los avances recientes en el aprendizaje automático (ML) han dado lugar a modelos cada vez más grandes, que a veces requieren cientos de miles de millones de parámetros. Aunque son más potentes, el entrenamiento y la inferencia sobre estos modelos requieren importantes recursos computacionales. A pesar de la disponibilidad de bibliotecas de capacitación distribuidas avanzadas, las tareas de capacitación e inferencia a menudo requieren cientos de aceleradores (GPU o chips de aprendizaje automático especialmente diseñados, como AWS Trainium y AWS Inferentia) y, por lo tanto, decenas o cientos de instancias.

En dichos entornos distribuidos, la observabilidad tanto de las instancias como de los chips ML se vuelve clave para ajustar el rendimiento del modelo y optimizar los costos. Al utilizar métricas, los equipos pueden comprender el comportamiento de las cargas de trabajo, optimizar la asignación y utilización de recursos, diagnosticar anomalías y aumentar la eficiencia general de la infraestructura. Para los científicos de datos, la utilización y saturación de los chips ML también son relevantes para la planificación de la capacidad.

Esta publicación lo guía a través del patrón de observabilidad de código abierto para AWS Inferentia y le muestra cómo monitorear el rendimiento de los chips de aprendizaje automático utilizados en un clúster de Amazon Elastic Kubernetes Service (Amazon EKS) con nodos de nivel de datos que se ejecutan en Amazon Elastic Compute Cloud (Amazon EC2). ) instancias de tipo Inf1 e Inf2.

El patrón es parte del Acelerador de observabilidad de AWS CDK, un conjunto de módulos personalizados que puede utilizar para establecer la observabilidad de los clústeres de Amazon EKS. El Acelerador de observabilidad de AWS CDK está organizado en torno a patrones, que son unidades reutilizables para implementar múltiples recursos. El conjunto de patrones de observabilidad de código abierto instrumenta la observabilidad con paneles de control de Amazon Managed Grafana, un recopilador de AWS Distro para OpenTelemetry para recopilar métricas y Amazon Managed Service para Prometheus para almacenarlas.

Descripción general de la solución

El siguiente diagrama ilustra la arquitectura de la solución.

Esta solución implementa un clúster de Amazon EKS con un grupo de nodos que contiene instancias Inf1.

El tipo de AMI del grupo de nodos es AL2_x86_64_GPU, que utiliza la AMI acelerada de Amazon Linux optimizada para Amazon EKS. Además de la configuración de AMI estándar optimizada para Amazon EKS, la AMI acelerada incluye el tiempo de ejecución de NeuronX.

Para acceder a los chips ML a través de Kubernetes, el patrón proporciona el complemento del dispositivo AWS Neuron.

Las métricas las proporciona Amazon Managed Service para Prometheus. neuron-monitor DaemonSet, que proporciona un contenedor mínimo con herramientas Neuron instaladas. Específicamente que neuron-monitor DaemonSet hace esto neuron-monitor Comando reenviado al neuron-monitor-prometheus.py Script complementario (ambos comandos son parte del contenedor):

neuron-monitor | neuron-monitor-prometheus.py --port <port>

El comando utiliza los siguientes componentes:

  • neuron-monitor recopila métricas y estadísticas de las aplicaciones Neuron que se ejecutan en el sistema y transmite los datos recopilados a la salida estándar en formato JSON
  • neuron-monitor-prometheus.py Asigna y expone los datos de telemetría del formato JSON a un formato compatible con Prometheus.

Los datos se visualizan en Amazon Managed Grafana a través del panel correspondiente.

El resto de la configuración para recopilar y visualizar métricas con Amazon Managed Service for Prometheus y Amazon Managed Grafana es similar a la utilizada en otros patrones basados ​​en código abierto incluidos en el AWS Observability Accelerator for CDK Repositorio de GitHub.

requisitos

Necesitará lo siguiente para seguir los pasos de esta publicación:

Configurar el entorno

Complete los siguientes pasos para configurar su entorno:

  1. Abra una ventana de terminal y ejecute los siguientes comandos:
export AWS_REGION=<YOUR AWS REGION>
export ACCOUNT_ID=$(aws sts get-caller-identity --query 'Account' --output text)

  1. Recupere los ID de los espacios de trabajo de todos los espacios de trabajo de Amazon Managed Grafana existentes:
aws grafana list-workspaces

El siguiente es nuestro resultado de muestra:

{
  "workspaces": [
    {
      "authentication": {
        "providers": [
          "AWS_SSO"
        ]
      },
      "created": "2023-06-07T12:23:56.625000-04:00",
      "description": "accelerator-workspace",
      "endpoint": "g-XYZ.grafana-workspace.us-east-2.amazonaws.com",
      "grafanaVersion": "9.4",
      "id": "g-XYZ",
      "modified": "2023-06-07T12:30:09.892000-04:00",
      "name": "accelerator-workspace",
      "notificationDestinations": [
        "SNS"
      ],
      "status": "ACTIVE",
      "tags": {}
    }
  ]
}

  1. asignar los valores id Y endpoint a las siguientes variables de entorno:
export COA_AMG_WORKSPACE_ID="<<YOUR-WORKSPACE-ID, similar to the above g-XYZ, without quotation marks>>"
export COA_AMG_ENDPOINT_URL="<<https://YOUR-WORKSPACE-URL, including protocol (i.e. https://), without quotation marks, similar to the above https://g-XYZ.grafana-workspace.us-east-2.amazonaws.com>>"

COA_AMG_ENDPOINT_URL debe incluir https://.

  1. Cree una clave API de Grafana desde el espacio de trabajo de Amazon Managed Grafana:
export AMG_API_KEY=$(aws grafana create-workspace-api-key \
--key-name "grafana-operator-key" \
--key-role "ADMIN" \
--seconds-to-live 432000 \
--workspace-id $COA_AMG_WORKSPACE_ID \
--query key \
--output text)

  1. Configure un secreto en AWS Systems Manager:
aws ssm put-parameter --name "/cdk-accelerator/grafana-api-key" \
--type "SecureString" \
--value $AMG_API_KEY \
--region $AWS_REGION

Se accede al secreto a través del complemento Secretos externos y se expone como un secreto nativo de Kubernetes en el clúster EKS.

Arranque el entorno AWS CDK

El primer paso en cualquier implementación de AWS CDK es iniciar el entorno. ellos usan el cdk bootstrap Comando en la CLI de AWS CDK para preparar el entorno (una combinación de cuenta de AWS y región de AWS) con los recursos que AWS CDK necesita para realizar implementaciones en ese entorno. Se requiere el arranque de AWS CDK para cualquier combinación de cuenta y región. Por lo tanto, si ya inició AWS CDK en una región, no necesita repetir el proceso de arranque.

cdk bootstrap aws://$ACCOUNT_ID/$AWS_REGION

Proporcionar la solución

Complete los siguientes pasos para implementar la solución:

  1. Clone el repositorio cdk-aws-observability-accelerator e instale los paquetes de dependencia. Este repositorio contiene código AWS CDK v2 escrito en TypeScript.
git clone https://github.com/aws-observability/cdk-aws-observability-accelerator.git
cd cdk-aws-observability-accelerator

Se espera que la configuración real de los archivos JSON del panel de Grafana se especifique en el contexto de AWS CDK. Necesitas actualizar context en el cdk.json Archivo ubicado en el directorio actual. La ubicación del tablero se indica mediante fluxRepository.values.GRAFANA_NEURON_DASH_URL Parámetros y neuronNodeGroup se utiliza para configurar el tipo, el número y el tamaño de instancia de Amazon Elastic Block Store (Amazon EBS) utilizados para los nodos.

  1. Ingrese el siguiente fragmento cdk.jsonsustituto context:
"context": {
    "fluxRepository": {
      "name": "grafana-dashboards",
      "namespace": "grafana-operator",
      "repository": {
        "repoUrl": "https://github.com/aws-observability/aws-observability-accelerator",
        "name": "grafana-dashboards",
        "targetRevision": "main",
        "path": "./artifacts/grafana-operator-manifests/eks/infrastructure"
      },
      "values": {
        "GRAFANA_CLUSTER_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/cluster.json",
        "GRAFANA_KUBELET_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/kubelet.json",
        "GRAFANA_NSWRKLDS_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/namespace-workloads.json",
        "GRAFANA_NODEEXP_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/nodeexporter-nodes.json",
        "GRAFANA_NODES_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/nodes.json",
        "GRAFANA_WORKLOADS_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/infrastructure/workloads.json",
        "GRAFANA_NEURON_DASH_URL" : "https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/grafana-dashboards/eks/neuron/neuron-monitor.json"
      },
      "kustomizations": [
        {
          "kustomizationPath": "./artifacts/grafana-operator-manifests/eks/infrastructure"
        },
        {
          "kustomizationPath": "./artifacts/grafana-operator-manifests/eks/neuron"
        }
      ]
    },
     "neuronNodeGroup": {
      "instanceClass": "inf1",
      "instanceSize": "2xlarge",
      "desiredSize": 1, 
      "minSize": 1, 
      "maxSize": 3,
      "ebsSize": 512
    }
  }

Puede reemplazar el tipo de instancia Inf1 con Inf2 y cambiar su tamaño según sea necesario. Para verificar la disponibilidad en la región seleccionada, ejecute el siguiente comando (cambiar Values como veas conveniente):

aws ec2 describe-instance-type-offerings \
--filters Name=instance-type,Values="inf1*" \
--query "InstanceTypeOfferings[].InstanceType" \
--region $AWS_REGION

  1. Instale las dependencias del proyecto:
  1. Ejecute los siguientes comandos para implementar el patrón de observabilidad de código abierto:
make build
make pattern single-new-eks-inferentia-opensource-observability deploy

Validar la solución

Complete los siguientes pasos para validar la solución:

  1. Ejecuta esto update-kubeconfig Dominio. Debería poder obtener el comando del mensaje de salida del comando anterior:
aws eks update-kubeconfig --name single-new-eks-inferentia-opensource... --region <your region> --role-arn arn:aws:iam::xxxxxxxxx:role/single-new-eks-....

  1. Revise los recursos que creó:

La siguiente captura de pantalla muestra nuestro resultado de ejemplo.

  1. Asegúrate de eso neuron-device-plugin-daemonset DaemonSet se está ejecutando:
kubectl get ds neuron-device-plugin-daemonset --namespace kube-system

El siguiente es nuestro resultado esperado:

NAME                             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
neuron-device-plugin-daemonset   1         1         1       1            1           <none>          2h

  1. Confirme que el neuron-monitor DaemonSet se está ejecutando:
kubectl get ds neuron-monitor --namespace kube-system

El siguiente es nuestro resultado esperado:

NAME             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
neuron-monitor   1         1         1       1            1           <none>          2h

  1. Para verificar que los dispositivos y núcleos de Neuron estén visibles, ejecute: neuron-ls Y neuron-top Por ejemplo, los comandos de su módulo Neuron Monitor (puede ver el nombre del módulo en la salida de kubectl get pods -A):
kubectl exec -it {your neuron-monitor pod} -n kube-system -- /bin/bash -c "neuron-ls"

La siguiente captura de pantalla muestra nuestro resultado esperado.

kubectl exec -it {your neuron-monitor pod} -n kube-system -- /bin/bash -c "neuron-top"

La siguiente captura de pantalla muestra nuestro resultado esperado.

Visualice datos con el panel de Grafana Neuron

Inicie sesión en su espacio de trabajo de Amazon Managed Grafana y navegue hasta Paneles de control panel. Deberías ver un panel llamado Neurona/Monitor.

Para mostrar algunas métricas interesantes en el panel de Grafana, aplicamos el siguiente manifiesto:

curl https://raw.githubusercontent.com/aws-observability/aws-observability-accelerator/main/artifacts/k8s-deployment-manifest-templates/neuron/pytorch-inference-resnet50.yml | kubectl apply -f -

Esta es una carga de trabajo de muestra que compila el modelo Torchvision ResNet50 y ejecuta inferencias repetidas en un bucle para generar datos de telemetría.

Para verificar que el pod se implementó correctamente, ejecute el siguiente código:

Deberías ver un pod llamado pytorch-inference-resnet50.

Después de unos minutos lo miré. Neurona/Monitor Panel de control, debería ver las métricas recopiladas similares a las capturas de pantalla a continuación.

Grafana Operador y Flux siempre trabajan juntos para sincronizar sus paneles con Git. Si elimina accidentalmente sus paneles, se volverán a implementar automáticamente.

Limpiar

Puede eliminar toda la pila de AWS CDK utilizando el siguiente comando:

make pattern single-new-eks-inferentia-opensource-observability destroy

Diploma

En esta publicación, le mostramos cómo introducir la observabilidad en un clúster EKS con un nivel de datos que ejecuta instancias EC2-Inf1 utilizando herramientas de código abierto. Comenzamos seleccionando la AMI acelerada optimizada para Amazon EKS para los nodos de la capa de datos, que incluye el tiempo de ejecución del contenedor Neuron y proporciona acceso a los dispositivos AWS Inferentia y Trainium Neuron. Luego implementamos el complemento Neuron Device para exponer los núcleos y dispositivos de Neuron a Kubernetes. La captura real y el mapeo de datos de telemetría en un formato compatible con Prometheus se logró a través de neuron-monitor Y neuron-monitor-prometheus.py. Las métricas se obtuvieron de Amazon Managed Service for Prometheus y se muestran en el panel de Amazon Managed Grafana Neuron.

Le recomendamos que explore patrones de observabilidad adicionales en el repositorio de GitHub de AWS Observability Accelerator para CDK. Para obtener más información sobre Neuron, consulte la documentación de AWS Neuron.

Sobre el Autor

Ricardo Freschi es arquitecto senior de soluciones en AWS y se centra en la modernización de aplicaciones. Trabaja en estrecha colaboración con socios y clientes para ayudarlos a transformar sus entornos de TI en el camino hacia la nube de AWS mediante el rediseño de aplicaciones existentes y la creación de otras nuevas.

[ad_2]

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *


Subir