Habilitar métricas GPU basadas en pods en Amazon CloudWatch
Habilitar métricas GPU en Amazon CloudWatch
En febrero de 2022, Amazon Web Services agregó soporte para métricas de GPU de NVIDIA en Amazon CloudWatch, lo que permite enviar métricas desde el agente de Amazon CloudWatch a Amazon CloudWatch y monitorear tu código para una utilización óptima de la GPU. Desde entonces, esta función se ha integrado en muchas de nuestras Amazon Machine Images (AMIs) administradas, como la Deep Learning AMI y la AWS ParallelCluster AMI. Para obtener métricas de utilización de GPU a nivel de instancia, puedes usar Packer o Amazon ImageBuilder para crear tu propia AMI personalizada y utilizarla en diversas ofertas de servicios administrados como AWS Batch, Amazon Elastic Container Service (Amazon ECS) o Amazon Elastic Kubernetes Service (Amazon EKS). Sin embargo, para muchas ofertas de servicios y cargas de trabajo basadas en contenedores, es ideal capturar métricas de utilización a nivel de contenedor, pod o espacio de nombres.
Esta publicación detalla cómo configurar métricas de GPU basadas en contenedores y proporciona un ejemplo de recopilación de estas métricas desde pods de EKS.
Descripción general de la solución
Para demostrar métricas de GPU basadas en contenedores, creamos un clúster de EKS con instancias g5.2xlarge; sin embargo, esto funcionará con cualquier familia de instancias aceleradas por NVIDIA compatible.
Implementamos el operador de GPU de NVIDIA para habilitar el uso de los recursos de GPU y el Exportador de DCGM de NVIDIA para habilitar la recopilación de métricas de GPU. Luego exploramos dos arquitecturas. La primera conecta las métricas del Exportador de DCGM de NVIDIA a CloudWatch a través de un agente de CloudWatch, como se muestra en el siguiente diagrama.
- Estudio explora el potencial de la TMS asistida por robots para la ...
- Colombia Británica dividida sobre la seguridad de los coches autónomos
- Alan Turing y el Poder del Pensamiento Negativo
La segunda arquitectura (ver el siguiente diagrama) conecta las métricas del Exportador de DCGM a Prometheus, luego utilizamos un panel de control de Grafana para visualizar esas métricas.
Requisitos previos
Para simplificar la reproducción de toda la pila desde esta publicación, utilizamos un contenedor que ya tiene todas las herramientas necesarias (aws cli, eksctl, helm, etc.) instaladas. Para clonar el proyecto del contenedor desde GitHub, necesitarás git. Para construir y ejecutar el contenedor, necesitarás Docker. Para implementar la arquitectura, necesitarás credenciales de AWS. Para habilitar el acceso a los servicios de Kubernetes mediante el reenvío de puertos, también necesitarás kubectl.
Estos requisitos previos se pueden instalar en tu máquina local, en una instancia EC2 con NICE DCV o en AWS Cloud9. En esta publicación, utilizaremos una instancia de Cloud9 c5.2xlarge con un volumen de almacenamiento local de 40GB. Al usar Cloud9, desactiva las credenciales temporales administradas por AWS visitando Cloud9->Preferences->AWS Settings, como se muestra en la captura de pantalla a continuación.
Construir y ejecutar el contenedor aws-do-eks
Abre una terminal en tu entorno preferido y ejecuta los siguientes comandos:
git clone https://github.com/aws-samples/aws-do-eks
cd aws-do-eks
./build.sh
./run.sh
./exec.shEl resultado es el siguiente:
root@e5ecb162812f:/eks#Ahora tienes una terminal en un entorno de contenedor que tiene todas las herramientas necesarias para completar las tareas a continuación. Nos referiremos a él como “shell aws-do-eks”. Ejecutarás los comandos en las secciones siguientes en esta shell, a menos que se indique específicamente lo contrario.
Crear un clúster de EKS con un grupo de nodos
Este grupo incluye una familia de instancias GPU de tu elección; en este ejemplo, usamos el tipo de instancia g5.2xlarge.
El proyecto aws-do-eks viene con una colección de configuraciones de clúster. Puedes establecer la configuración de clúster deseada con un solo cambio de configuración.
- En la terminal de contenedores, ejecuta
./env-config.shy luego estableceCONF=conf/eksctl/yaml/eks-gpu-g5.yaml - Para verificar la configuración del clúster, ejecuta
./eks-config.sh
Deberías ver el siguiente manifiesto de clúster:
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: do-eks-yaml-g5
version: "1.25"
region: us-east-1
availabilityZones:
- us-east-1a
- us-east-1b
- us-east-1c
- us-east-1d
managedNodeGroups:
- name: sys
instanceType: m5.xlarge
desiredCapacity: 1
iam:
withAddonPolicies:
autoScaler: true
cloudWatch: true
- name: g5
instanceType: g5.2xlarge
instancePrefix: g5-2xl
privateNetworking: true
efaEnabled: false
minSize: 0
desiredCapacity: 1
maxSize: 10
volumeSize: 80
iam:
withAddonPolicies:
cloudWatch: true
iam:
withOIDC: true- Para crear el clúster, ejecuta el siguiente comando en el contenedor
./eks-create.shLa salida es la siguiente:
root@e5ecb162812f:/eks# ./eks-create.sh
/eks/impl/eksctl/yaml /eks
./eks-create.sh
Lun May 22 20:50:59 UTC 2023
Creando clúster usando /eks/conf/eksctl/yaml/eks-gpu-g5.yaml ...
eksctl create cluster -f /eks/conf/eksctl/yaml/eks-gpu-g5.yaml
2023-05-22 20:50:59 [ℹ] versión eksctl 0.133.0
2023-05-22 20:50:59 [ℹ] usando región us-east-1
2023-05-22 20:50:59 [ℹ] subredes para us-east-1a - público:192.168.0.0/19 privado:192.168.128.0/19
2023-05-22 20:50:59 [ℹ] subredes para us-east-1b - público:192.168.32.0/19 privado:192.168.160.0/19
2023-05-22 20:50:59 [ℹ] subredes para us-east-1c - público:192.168.64.0/19 privado:192.168.192.0/19
2023-05-22 20:50:59 [ℹ] subredes para us-east-1d - público:192.168.96.0/19 privado:192.168.224.0/19
2023-05-22 20:50:59 [ℹ] el grupo de nodos "sys" usará "" [AmazonLinux2/1.25]
2023-05-22 20:50:59 [ℹ] el grupo de nodos "g5" usará "" [AmazonLinux2/1.25]
2023-05-22 20:50:59 [ℹ] usando la versión de Kubernetes 1.25
2023-05-22 20:50:59 [ℹ] creando clúster EKS "do-eks-yaml-g5" en la región "us-east-1- Para verificar que su clúster se ha creado correctamente, ejecute el siguiente comando
kubectl get nodes -L node.kubernetes.io/instance-type
La salida es similar a la siguiente:
NOMBRE ESTADO ROLES EDAD VERSIÓN TIPO_DE_INSTANCIA
ip-192-168-18-137.ec2.internal Listo <ninguno> 47m v1.25.9-eks-0a21954 m5.xlarge
ip-192-168-214-241.ec2.internal Listo <ninguno> 46m v1.25.9-eks-0a21954 g5.2xlarge
En este ejemplo, tenemos una instancia m5.xlarge y una instancia g5.2xlarge en nuestro clúster; por lo tanto, se muestran dos nodos en la salida anterior.
Durante el proceso de creación del clúster, se instalará el complemento del dispositivo NVIDIA. Deberá eliminarlo después de la creación del clúster porque utilizaremos el Operador de GPU NVIDIA en su lugar.
- Elimine el complemento con el siguiente comando
kubectl -n kube-system delete daemonset nvidia-device-plugin-daemonset
Obtenemos la siguiente salida:
daemonset.apps "nvidia-device-plugin-daemonset" eliminado
Instalar el repositorio de Helm de NVIDIA
Instale el repositorio de Helm de NVIDIA con el siguiente comando:
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia && helm repo update
Implementar el exportador DCGM con el Operador de GPU NVIDIA
Para implementar el exportador DCGM, siga los siguientes pasos:
- Prepare la configuración de métricas de GPU del exportador DCGM
curl https://raw.githubusercontent.com/NVIDIA/dcgm-exporter/main/etc/dcp-metrics-included.csv > dcgm-metrics.csv
Tiene la opción de editar el archivo dcgm-metrics.csv. Puede agregar o eliminar las métricas que necesite.
- Cree el espacio de nombres del operador de GPU y el ConfigMap del exportador DCGM
kubectl create namespace gpu-operator && /
kubectl create configmap metrics-config -n gpu-operator --from-file=dcgm-metrics.csv
La salida es la siguiente:
namespace/gpu-operator creado
configmap/metrics-config creado
- Aplique el operador de GPU al clúster de EKS
helm install --wait --generate-name -n gpu-operator --create-namespace nvidia/gpu-operator \
--set dcgmExporter.config.name=metrics-config \
--set dcgmExporter.env[0].name=DCGM_EXPORTER_COLLECTORS \
--set dcgmExporter.env[0].value=/etc/dcgm-exporter/dcgm-metrics.csv \
--set toolkit.enabled=false
La salida es la siguiente:
NOMBRE: gpu-operator-1684795140
ÚLTIMA IMPLEMENTACIÓN: Día Mes Fecha HH:mm:ss YYYY
ESPACIO DE NOMBRES: gpu-operator
ESTADO: implementado
REVISIÓN: 1
SUITE DE PRUEBAS: Ninguno
- Confirme que el pod del exportador DCGM se está ejecutando
kubectl -n gpu-operator get pods | grep dcgm
La salida es la siguiente:
nvidia-dcgm-exporter-lkmfr 1/1 Ejecutando 0 1m
Si inspecciona los registros, debería ver el mensaje “Starting webserver”:
kubectl -n gpu-operator logs -f $(kubectl -n gpu-operator get pods | grep dcgm | cut -d ' ' -f 1)
La salida es la siguiente:
Contenedor predeterminado "nvidia-dcgm-exporter" fuera de: nvidia-dcgm-exporter, toolkit-validation (init)
hora="2023-05-22T22:40:08Z" nivel=info mensaje="Starting dcgm-exporter"
hora="2023-05-22T22:40:08Z" nivel=info mensaje="DCGM inicializado correctamente!"
hora="2023-05-22T22:40:08Z" nivel=info mensaje="Recopilando métricas DCP"
hora="2023-05-22T22:40:08Z" nivel=info mensaje="No se especificaron datos de configmap, se utiliza el archivo de métricas /etc/dcgm-exporter/dcgm-metrics.csv por defecto"
hora="2023-05-22T22:40:08Z" nivel=info mensaje="Inicializando entidades del sistema de tipo: GPU"
hora="2023-05-22T22:40:09Z" nivel=info mensaje="Inicializando entidades del sistema de tipo: NvSwitch"
hora="2023-05-22T22:40:09Z" nivel=info mensaje="No se recopilan métricas de switch: no hay switches para monitorizar"
hora="2023-05-22T22:40:09Z" nivel=info mensaje="Inicializando entidades del sistema de tipo: NvLink"
hora="2023-05-22T22:40:09Z" nivel=info mensaje="No se recopilan métricas de enlace: no hay switches para monitorizar"
hora="2023-05-22T22:40:09Z" nivel=info mensaje="¡Recopilación de métricas de Kubernetes habilitada!"
hora="2023-05-22T22:40:09Z" nivel=info mensaje="Inicio del pipeline"
hora="2023-05-22T22:40:09Z" nivel=info mensaje="Starting webserver"
El Exportador de DCGM de NVIDIA expone un punto de conexión de métricas de Prometheus, que puede ser consumido por el agente CloudWatch. Para ver el punto de conexión, use el siguiente comando:
kubectl -n gpu-operator get services | grep dcgm
Obtenemos la siguiente salida:
nvidia-dcgm-exporter ClusterIP 10.100.183.207 <ninguno> 9400/TCP 10m
- Para generar alguna utilización de la GPU, implementamos un pod que ejecute el binario gpu-burn
kubectl apply -f https://raw.githubusercontent.com/aws-samples/aws-do-eks/main/Container-Root/eks/deployment/gpu-metrics/gpu-burn-deployment.yaml
La salida es la siguiente:
deployment.apps/gpu-burn creado
Esta implementación utiliza una sola GPU para producir un patrón continuo de utilización del 100% durante 20 segundos, seguido de una utilización del 0% durante 20 segundos.
- Para asegurarse de que el punto de conexión funciona, puede ejecutar un contenedor temporal que use curl para leer el contenido de
http://nvidia-dcgm-exporter:9400/metrics
kubectl -Configurar e implementar el agente CloudWatch
Para configurar e implementar el agente CloudWatch, siga los siguientes pasos:
- Descargue el archivo YAML y edítelo
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/k8s/1.3.15/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
El archivo contiene un configmap de cwagent y un configmap de prometheus. Para este post, editaremos ambos.
- Edite el archivo
prometheus-eks.yaml
Abra el archivo prometheus-eks.yaml en su editor favorito y reemplace la sección cwagentconfig.json con el siguiente contenido:
apiVersion: v1
data:
# cwagent json config
cwagentconfig.json: |
{
"logs": {
"metrics_collected": {
"prometheus": {
"prometheus_config_path": "/etc/prometheusconfig/prometheus.yaml",
"emf_processor": {
"metric_declaration": [
{
"source_labels": ["Service"],
"label_matcher": ".*dcgm.*",
"dimensions": [["Service","Namespace","ClusterName","job","pod"]],
"metric_selectors": [
"^DCGM_FI_DEV_GPU_UTIL$",
"^DCGM_FI_DEV_DEC_UTIL$",
"^DCGM_FI_DEV_ENC_UTIL$",
"^DCGM_FI_DEV_MEM_CLOCK$",
"^DCGM_FI_DEV_MEM_COPY_UTIL$",
"^DCGM_FI_DEV_POWER_USAGE$",
"^DCGM_FI_DEV_ROW_REMAP_FAILURE$",
"^DCGM_FI_DEV_SM_CLOCK$",
"^DCGM_FI_DEV_XID_ERRORS$",
"^DCGM_FI_PROF_DRAM_ACTIVE$",
"^DCGM_FI_PROF_GR_ENGINE_ACTIVE$",
"^DCGM_FI_PROF_PCIE_RX_BYTES$",
"^DCGM_FI_PROF_PCIE_TX_BYTES$",
"^DCGM_FI_PROF_PIPE_TENSOR_ACTIVE$"
]
}
]
}
}
},
"force_flush_interval": 5
}
}
- En la sección de configuración de
prometheus, agregue la siguiente definición de trabajo para el exportador DCGM
- job_name: 'kubernetes-pod-dcgm-exporter'
sample_limit: 10000
metrics_path: /api/v1/metrics/prometheus
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__meta_kubernetes_pod_container_name]
action: keep
regex: '^DCGM.*$'
- source_labels: [__address__]
action: replace
regex: ([^:]+)(?::\d+)?
replacement: ${1}:9400
target_label: __address__
- action: labelmap
regex: __meta_kubernetes_pod_label_(.+)
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- source_labels: [__meta_kubernetes_pod]
action: replace
target_label: pod
- action: replace
source_labels:
- __meta_kubernetes_pod_container_name
target_label: container_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_name
target_label: pod_controller_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_kind
target_label: pod_controller_kind
- action: replace
source_labels:
- __meta_kubernetes_pod_phase
target_label: pod_phase
- action: replace
source_labels:
- __meta_kubernetes_pod_node_name
target_label: NodeName
- Guarde el archivo y aplique la configuración
cwagent-dcgm a su clúster
kubectl apply -f ./prometheus-eks.yaml
Obtendremos la siguiente salida:
namespace/amazon-cloudwatch creado
configmap/prometheus-cwagentconfig creado
configmap/prometheus-config creado
serviceaccount/cwagent-prometheus creado
clusterrole.rbac.authorization.k8s.io/cwagent-prometheus-role creado
clusterrolebinding.rbac.authorization.k8s.io/cwagent-prometheus-role-binding creado
deployment.apps/cwagent-prometheus creado
- Confirma que el pod del agente CloudWatch está en ejecución
kubectl -n amazon-cloudwatch get pods
Obtenemos la siguiente salida:
NOMBRE LISTO ESTADO REINICIOS EDAD
cwagent-prometheus-7dfd69cc46-s4cx7 1/1 En ejecución 0 15m
Visualizar métricas en la consola de CloudWatch
Para visualizar las métricas en CloudWatch, completa los siguientes pasos:
- En la consola de CloudWatch, en el panel de navegación, selecciona Métricas
- En la sección Espacios de nombres personalizados, selecciona la nueva entrada para ContainerInsights/Prometheus
Para obtener más información sobre el espacio de nombres ContainerInsights/Prometheus, consulta la obtención de métricas adicionales de fuentes Prometheus e importar esas métricas.
- Desglosa los nombres de las métricas y selecciona
DCGM_FI_DEV_GPU_UTIL
- En la pestaña Métricas graficadas, establece Período en 5 segundos
- Establece el intervalo de actualización en 10 segundos
Verás las métricas recopiladas del exportador DCGM que visualizan el patrón gpu-burn encendido y apagado cada 20 segundos.
En la pestaña Explorar, puedes ver los datos, incluido el nombre del pod para cada métrica.
Los metadatos de la API de EKS se han combinado con los datos de métricas de DCGM, lo que resulta en las métricas de GPU basadas en pod proporcionadas.
Esto concluye el primer enfoque de exportar métricas DCGM a CloudWatch a través del agente CloudWatch.
En la siguiente sección, configuraremos la segunda arquitectura, que exporta las métricas DCGM a Prometheus y las visualizamos con Grafana.
Utilizar Prometheus y Grafana para visualizar métricas de GPU de DCGM
Completa los siguientes pasos:
- Agrega el gráfico de helm de la comunidad de Prometheus
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
Este gráfico implementa tanto Prometheus como Grafana. Necesitamos hacer algunas ediciones al gráfico antes de ejecutar el comando de instalación.
- Guarda los valores de configuración del gráfico en un archivo en
/tmp
helm inspect values prometheus-community/kube-prometheus-stack > /tmp/kube-prometheus-stack.values
- Edita el archivo de configuración del gráfico
Edita el archivo guardado (/tmp/kube-prometheus-stack.values) y establece la siguiente opción buscando el nombre de la configuración y estableciendo el valor:
prometheus.prometheusSpec.serviceMonitorSelectorNilUsesHelmValues=false
- Agregue el siguiente ConfigMap a la sección
additionalScrapeConfigs
additionalScrapeConfigs:
- job_name: gpu-metrics
scrape_interval: 1s
metrics_path: /metrics
scheme: http
kubernetes_sd_configs:
- role: endpoints
namespaces:
names:
- gpu-operator
relabel_configs:
- source_labels: [__meta_kubernetes_pod_node_name]
action: replace
target_label: kubernetes_node
- Implemente el stack de Prometheus con los valores actualizados
helm install prometheus-community/kube-prometheus-stack \
--create-namespace --namespace prometheus \
--generate-name \
--values /tmp/kube-prometheus-stack.values
Obtenemos la siguiente salida:
NOMBRE: kube-prometheus-stack-1684965548
ÚLTIMA IMPLEMENTACIÓN: Mié May 24 21:59:14 2023
ESPACIO DE NOMBRES: prometheus
ESTADO: implementado
REVISIÓN: 1
NOTAS:
kube-prometheus-stack ha sido instalado. Verifique su estado ejecutando:
kubectl --namespace prometheus get pods -l "release=kube-prometheus-stack-1684965548"
Visite https://github.com/prometheus-operator/kube-prometheus
para obtener instrucciones sobre cómo crear y configurar Alertmanager
y las instancias de Prometheus utilizando el Operador.
- Confirme que los pods de Prometheus están en ejecución
kubectl get pods -n prometheus
Obtenemos la siguiente salida:
NOMBRE LISTO ESTADO REINICIOS EDAD
alertmanager-kube-prometheus-stack-1684-alertmanager-0 2/2 En ejecución 0 6m55s
kube-prometheus-stack-1684-operator-6c87649878-j7v55 1/1 En ejecución 0 6m58s
kube-prometheus-stack-1684965548-grafana-dcd7b4c96-bzm8p 3/3 En ejecución 0 6m58s
kube-prometheus-stack-1684965548-kube-state-metrics-7d856dptlj5 1/1 En ejecución 0 6m58s
kube-prometheus-stack-1684965548-prometheus-node-exporter-2fbl5 1/1 En ejecución 0 6m58s
kube-prometheus-stack-1684965548-prometheus-node-exporter-m7zmv 1/1 En ejecución 0 6m58s
prometheus-kube-prometheus-stack-1684-prometheus-0 2/2 En ejecución 0 6m55s
Los pods de Prometheus y Grafana están en estado En ejecución.
A continuación, validaremos que las métricas de DCGM se estén enviando a Prometheus.
- Reenvíe los puertos de la interfaz de usuario de Prometheus
Existen diferentes formas de exponer la interfaz de usuario de Prometheus que se ejecuta en EKS a solicitudes que provienen fuera del clúster. Utilizaremos el reenvío de puertos de kubectl. Hasta ahora, hemos estado ejecutando comandos dentro del contenedor aws-do-eks. Para acceder al servicio de Prometheus que se ejecuta en el clúster, crearemos un túnel desde el host. Aquí, el contenedor aws-do-eks se ejecuta ejecutando el siguiente comando fuera del contenedor, en una nueva terminal en el host. Nos referiremos a esto como "shell de host".
kubectl -n prometheus port-forward svc/$(kubectl -n prometheus get svc | grep prometheus | grep -v alertmanager | grep -v operator | grep -v grafana | grep -v metrics | grep -v exporter | grep -v operated | cut -d ' ' -f 1) 8080:9090 &
Mientras el proceso de reenvío de puertos esté en ejecución, podremos acceder a la interfaz de usuario de Prometheus desde el host según se describe a continuación.
- Abra la interfaz de usuario de Prometheus
- Si está utilizando Cloud9, navegue hasta
Preview->Preview Running Application para abrir la interfaz de usuario de Prometheus en una pestaña dentro del Cloud9 IDE, luego haga clic en el icono 
en la esquina superior derecha de la pestaña para abrir en una nueva ventana.
- Si está en su host local o conectado a una instancia de EC2 a través de escritorio remoto, abra un navegador y visite la URL
http://localhost:8080.
- Ingrese
DCGM para ver las métricas de DCGM que están fluyendo hacia Prometheus
- Seleccione
DCGM_FI_DEV_GPU_UTIL, elija Ejecutar y luego vaya a la pestaña Gráfico para ver el patrón esperado de utilización de la GPU
- Detenga el proceso de redirección de puertos de Prometheus
Ejecute el siguiente comando en su shell de host:
kill -9 $(ps -aef | grep port-forward | grep -v grep | grep prometheus | awk '{print $2}')
Ahora podemos visualizar las métricas de DCGM a través del Panel de control de Grafana.
- Recupere la contraseña para iniciar sesión en la interfaz de usuario de Grafana
kubectl -n prometheus get secret $(kubectl -n prometheus get secrets | grep grafana | cut -d ' ' -f 1) -o jsonpath="{.data.admin-password}" | base64 --decode ; echo
- Redireccione los puertos del servicio Grafana
Ejecute el siguiente comando en su shell de host:
kubectl port-forward -n prometheus svc/$(kubectl -n prometheus get svc | grep grafana | cut -d ' ' -f 1) 8080:80 &
- Inicie sesión en la interfaz de usuario de Grafana
Acceda a la pantalla de inicio de sesión de la interfaz de usuario de Grafana de la misma manera que accedió a la interfaz de usuario de Prometheus anteriormente. Si está utilizando Cloud9, seleccione Preview->Preview Running Application, luego abra en una nueva ventana. Si está utilizando su host local o una instancia de EC2 con escritorio remoto, visite la URL http://localhost:8080. Inicie sesión con el nombre de usuario admin y la contraseña que recuperó anteriormente.
- En el panel de navegación, elija Tableros
- Elija Nuevo e Importar
Vamos a importar el panel de control predeterminado de DCGM en Grafana descrito en NVIDIA DCGM Exporter Dashboard.
- En el campo
importar a través de grafana.com, ingrese 12239 y elija Cargar
- Elija Prometheus como origen de datos
- Elija Importar
Verás un panel de control similar al que se muestra en la siguiente captura de pantalla.
Para demostrar que estas métricas son basadas en pods, vamos a modificar el panel de Utilización de GPU en este panel de control.
- Elige el panel y el menú de opciones (tres puntos)
- Expande la sección Opciones y edita el campo Leyenda
- Reemplaza el valor actual por
Pod {{pod}}, luego elige Guardar
Ahora la leyenda muestra el nombre del pod gpu-burn asociado con la utilización de GPU mostrada.
- Detén el reenvío de puertos del servicio de interfaz de usuario de Grafana
Ejecuta lo siguiente en tu terminal:
kill -9 $(ps -aef | grep port-forward | grep -v grep | grep prometheus | awk '{print $2}')
En esta publicación, demostramos el uso de Prometheus y Grafana de código abierto desplegados en el clúster de EKS. Si lo deseas, este despliegue se puede sustituir por Amazon Managed Service for Prometheus y Amazon Managed Grafana.
Limpieza
Para limpiar los recursos que has creado, ejecuta el siguiente script desde la terminal del contenedor aws-do-eks:
./eks-delete.sh
Conclusión
En esta publicación, utilizamos NVIDIA DCGM Exporter para recolectar métricas de GPU y visualizarlas con CloudWatch o Prometheus y Grafana. Te invitamos a utilizar las arquitecturas demostradas aquí para habilitar el monitoreo de la utilización de GPU con NVIDIA DCGM en tu propio entorno de AWS.
Recursos adicionales
- Instancias de GPU de Amazon EC2
- NVIDIA DCGM: Gestiona y monitorea las GPUs en entornos de clúster
- Repositorio de GitHub kube-prometheus-stack
