Platone Data Intelligence.
Ricerca verticale e intelligenza artificiale.

AI

Osservabilità open source per i nodi AWS Inferentia all'interno dei cluster Amazon EKS | Servizi Web di Amazon

Ripubblicato da Platone
Ripubblicato da Platone

Data:

Visualizzazioni: 0

I recenti sviluppi nell’apprendimento automatico (ML) hanno portato a modelli sempre più grandi, alcuni dei quali richiedono centinaia di miliardi di parametri. Sebbene siano più potenti, l’addestramento e l’inferenza su tali modelli richiedono risorse computazionali significative. Nonostante la disponibilità di librerie di formazione distribuite avanzate, è normale che i lavori di formazione e inferenza necessitino di centinaia di acceleratori (GPU o chip ML appositamente realizzati come AWSTrainium ed AWS Inferenza), e quindi decine o centinaia di casi.

In tali ambienti distribuiti, l'osservabilità di entrambe le istanze e dei chip ML diventa fondamentale per la messa a punto delle prestazioni del modello e l'ottimizzazione dei costi. Le metriche consentono ai team di comprendere il comportamento del carico di lavoro e ottimizzare l'allocazione e l'utilizzo delle risorse, diagnosticare anomalie e aumentare l'efficienza complessiva dell'infrastruttura. Per i data scientist, l’utilizzo e la saturazione dei chip ML sono rilevanti anche per la pianificazione della capacità.

Questo post ti guida attraverso Modello di osservabilità open source per AWS Inferentia, che mostra come monitorare le prestazioni dei chip ML, utilizzati in un Servizio Amazon Elastic Kubernetes (Amazon EKS), con nodi del piano dati basati su Cloud di calcolo elastico di Amazon (Amazon EC2) istanze di tipo INF1 ed INF2.

Il modello fa parte del Acceleratore di osservabilità di AWS CDK, una serie di moduli basati su opinioni che ti aiutano a impostare l'osservabilità per i cluster Amazon EKS. AWS CDK Observability Accelerator è organizzato attorno a modelli, che sono unità riutilizzabili per la distribuzione di più risorse. L'insieme di modelli di osservabilità open source con cui è possibile osservare gli strumenti Grafana gestita da Amazon cruscotti, un Distribuzione AWS per OpenTelemetry collector per raccogliere metriche e Servizio gestito da Amazon per Prometheus per conservarli.

Panoramica della soluzione

Il diagramma seguente illustra l'architettura della soluzione.

Questa soluzione distribuisce un cluster Amazon EKS con un gruppo di nodi che include istanze Inf1.

Il tipo AMI del gruppo di nodi è AL2_x86_64_GPU, che utilizza il AMI Amazon Linux accelerata ottimizzata per Amazon EKS. Oltre alla configurazione AMI standard ottimizzata per Amazon EKS, l'AMI accelerata include Tempo di esecuzione di NeuronX.

Per accedere ai chip ML da Kubernetes, il modello distribuisce il file Neurone AWS plug-in del dispositivo.

I parametri vengono esposti ad Amazon Managed Service per Prometheus da neuron-monitor DaemonSet, che distribuisce un contenitore minimo, con il file Strumenti neuronali installato. Nello specifico, il neuron-monitor DaemonSet esegue il file neuron-monitor comando convogliato nel file neuron-monitor-prometheus.py script complementare (entrambi i comandi fanno parte del contenitore):

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

Il comando utilizza i seguenti componenti:

  • neuron-monitor raccoglie parametri e statistiche dalle applicazioni Neuron in esecuzione sul sistema e trasmette i dati raccolti a stdout in Formato JSON
  • neuron-monitor-prometheus.py mappa ed espone i dati di telemetria dal formato JSON al formato compatibile con Prometheus

I dati vengono visualizzati in Amazon Managed Grafana tramite la dashboard corrispondente.

Il resto della configurazione per raccogliere e visualizzare i parametri con Amazon Managed Service for Prometheus e Amazon Managed Grafana è simile a quello utilizzato in altri modelli basati su open source, inclusi nel AWS Observability Accelerator for CDK Archivio GitHub.

Prerequisiti

Per completare i passaggi descritti in questo post è necessario quanto segue:

Crea l'ambiente

Completa i seguenti passaggi per configurare il tuo ambiente:

  1. Apri una finestra di terminale ed esegui i seguenti comandi:
export AWS_REGION=<YOUR AWS REGION>
export ACCOUNT_ID=$(aws sts get-caller-identity --query 'Account' --output text)

  1. Recupera gli ID dello spazio di lavoro di qualsiasi spazio di lavoro Amazon Managed Grafana esistente:
aws grafana list-workspaces

Quello che segue è il nostro output di esempio:

{
  "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. Assegnare i valori di id ed endpoint alle seguenti variabili d'ambiente:
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 deve includere https://.

  1. Crea una chiave API Grafana dall'area di lavoro 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. Imposta un segreto in Gestore di sistemi AWS:
aws ssm put-parameter --name "/cdk-accelerator/grafana-api-key" 
--type "SecureString" 
--value $AMG_API_KEY 
--region $AWS_REGION

Al segreto si accederà dal componente aggiuntivo External Secrets e verrà reso disponibile come segreto Kubernetes nativo nel cluster EKS.

Avvia l'ambiente AWS CDK

Il primo passaggio per qualsiasi distribuzione AWS CDK è il bootstrap dell'ambiente. Usi il cdk bootstrap comando nell'AWS CDK CLI per preparare l'ambiente (una combinazione di account AWS e regione AWS) con le risorse richieste da AWS CDK per eseguire distribuzioni in tale ambiente. Il bootstrap di AWS CDK è necessario per ogni combinazione di account e regione, quindi se hai già avviato AWS CDK in una regione, non è necessario ripetere il processo di bootstrap.

cdk bootstrap aws://$ACCOUNT_ID/$AWS_REGION

Distribuisci la soluzione

Completare i seguenti passaggi per distribuire la soluzione:

  1. Clona il file cdk-aws-osservabilità-acceleratore repository e installare i pacchetti delle dipendenze. Questo repository contiene codice AWS CDK v2 scritto in TypeScript.
git clone https://github.com/aws-observability/cdk-aws-observability-accelerator.git
cd cdk-aws-observability-accelerator

Si prevede che le impostazioni effettive per i file JSON del dashboard Grafana siano specificate nel contesto AWS CDK. È necessario aggiornare context nel cdk.json file, situato nella directory corrente. La posizione del dashboard è specificata da fluxRepository.values.GRAFANA_NEURON_DASH_URL parametro, e neuronNodeGroup viene utilizzato per impostare il tipo di istanza, il numero e Negozio di blocchi elastici di Amazon (Amazon EBS) utilizzata per i nodi.

  1. Inserisci il seguente snippet in cdk.json, sostituendo 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
    }
  }

Puoi sostituire il tipo di istanza Inf1 con Inf2 e modificare le dimensioni secondo necessità. Per verificare la disponibilità nella regione selezionata, esegui il comando seguente (amend Values come meglio credi):

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

  1. Installa le dipendenze del progetto:
npm install

  1. Esegui i seguenti comandi per distribuire il modello di osservabilità open source:
make build
make pattern single-new-eks-inferentia-opensource-observability deploy

Convalida la soluzione

Completare i seguenti passaggi per convalidare la soluzione:

  1. Corri il update-kubeconfig comando. Dovresti essere in grado di ottenere il comando dal messaggio di output del comando precedente:
aws eks update-kubeconfig --name single-new-eks-inferentia-opensource... --region <your region> --role-arn arn:aws:iam::xxxxxxxxx:role/single-new-eks-....

  1. Verifica le risorse che hai creato:
kubectl get pods -A

Lo screenshot seguente mostra il nostro output di esempio.

  1. Assicurarsi che la neuron-device-plugin-daemonset DaemonSet è in esecuzione:
kubectl get ds neuron-device-plugin-daemonset --namespace kube-system

Quello che segue è il nostro output atteso:

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

  1. Conferma che il neuron-monitor DaemonSet è in esecuzione:
kubectl get ds neuron-monitor --namespace kube-system

Quello che segue è il nostro output atteso:

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

  1. Per verificare che i dispositivi e i core Neuron siano visibili, eseguire il file neuron-ls ed neuron-top comandi provenienti, ad esempio, dal pod del monitor neuronale (puoi ottenere il nome del pod dall'output di kubectl get pods -A):
kubectl exec -it {your neuron-monitor pod} -n kube-system -- /bin/bash -c "neuron-ls"

Lo screenshot seguente mostra l'output previsto.

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

Lo screenshot seguente mostra l'output previsto.

Visualizza i dati utilizzando la dashboard di Grafana Neuron

Accedi al tuo spazio di lavoro Amazon Managed Grafana e vai al file Cruscotti pannello. Dovresti vedere una dashboard denominata Neurone/Monitor.

Per vedere alcune metriche interessanti sulla dashboard di Grafana, applichiamo il seguente manifest:

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

Questo è un carico di lavoro di esempio che compila il file modello torchvision ResNet50 ed esegue l'inferenza ripetitiva in un ciclo per generare dati di telemetria.

Per verificare che il pod sia stato distribuito correttamente, esegui il codice seguente:

kubectl get pods

Dovresti vedere un pod con nome pytorch-inference-resnet50.

Dopo alcuni minuti, esaminando il Neurone/Monitor dashboard, dovresti vedere i parametri raccolti simili ai seguenti screenshot.

Grafana Operator e Flux lavorano sempre insieme per sincronizzare le tue dashboard con Git. Se elimini le tue dashboard per sbaglio, verrà effettuato nuovamente il provisioning automaticamente.

ripulire

Puoi eliminare l'intero stack AWS CDK con il comando seguente:

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

Conclusione

In questo post, ti abbiamo mostrato come introdurre l'osservabilità, con strumenti open source, in un cluster EKS dotato di un piano dati che esegue istanze EC2 Inf1. Abbiamo iniziato selezionando l'AMI accelerata ottimizzata per Amazon EKS per i nodi del piano dati, che include il runtime del container Neuron, fornendo l'accesso ai dispositivi AWS Inferentia e Trainium Neuron. Quindi, per esporre i core e i dispositivi Neuron a Kubernetes, abbiamo distribuito il plug-in del dispositivo Neuron. L'effettiva raccolta e mappatura dei dati di telemetria in un formato compatibile con Prometheus è stata ottenuta tramite neuron-monitor ed neuron-monitor-prometheus.py. I parametri sono stati ottenuti da Amazon Managed Service per Prometheus e visualizzati nel dashboard Neuron di Amazon Managed Grafana.

Ti consigliamo di esplorare ulteriori modelli di osservabilità nel file AWS Observability Accelerator per CDK Deposito GitHub. Per saperne di più su Neuron, fare riferimento a Documentazione di AWS Neuron.

L'autore

Riccardo Freschi è Sr. Solutions Architect presso AWS, specializzato nella modernizzazione delle applicazioni. Lavora a stretto contatto con partner e clienti per aiutarli a trasformare i loro ambienti IT nel loro percorso verso il cloud AWS effettuando il refactoring delle applicazioni esistenti e creandone di nuove.

spot_img

L'ultima intelligenza

spot_img

Copyright @ 2024 Plato Technologies Inc.

Parla con noi

Ciao! Come posso aiutarla?