Generative Datenintelligenz

AI

Open-Source-Beobachtbarkeit für AWS Inferentia-Knoten innerhalb von Amazon EKS-Clustern | Amazon Web Services

Neuauflage von Plato
Neuauflage von Plato

Datum:

Views: 0

Jüngste Entwicklungen im maschinellen Lernen (ML) haben zu immer größeren Modellen geführt, die teilweise Hunderte Milliarden Parameter erfordern. Obwohl sie leistungsfähiger sind, erfordern Training und Inferenz auf diesen Modellen erhebliche Rechenressourcen. Trotz der Verfügbarkeit fortschrittlicher verteilter Trainingsbibliotheken sind für Trainings- und Inferenzaufgaben häufig Hunderte von Beschleunigern (GPUs oder speziell entwickelte ML-Chips wie z. B AWS-Training und AWS-Inferenz), und daher Dutzende oder Hunderte von Instanzen.

In solchen verteilten Umgebungen wird die Beobachtbarkeit sowohl der Instanzen als auch der ML-Chips zum Schlüssel für die Feinabstimmung der Modellleistung und die Kostenoptimierung. Mithilfe von Metriken können Teams das Workload-Verhalten verstehen, die Ressourcenzuteilung und -nutzung optimieren, Anomalien diagnostizieren und die Gesamteffizienz der Infrastruktur steigern. Für Datenwissenschaftler sind die Auslastung und Sättigung von ML-Chips auch für die Kapazitätsplanung relevant.

Dieser Beitrag führt Sie durch die Open-Source-Observability-Muster für AWS Inferentia, das Ihnen zeigt, wie Sie die Leistung von ML-Chips überwachen, die in einem verwendet werden Amazon Elastic Kubernetes-Service (Amazon EKS)-Cluster mit Datenebenenknoten basierend auf Amazon Elastic Compute-Cloud (Amazon EC2) Instanzen des Typs Info1 und Info2.

Das Muster ist Teil des AWS CDK Observability Accelerator, eine Reihe eigenwilliger Module, die Ihnen beim Festlegen der Beobachtbarkeit für Amazon EKS-Cluster helfen. Der AWS CDK Observability Accelerator ist nach Mustern organisiert, bei denen es sich um wiederverwendbare Einheiten für die Bereitstellung mehrerer Ressourcen handelt. Der Open-Source-Beobachtbarkeitssatz von Mustern instrumentiert die Beobachtbarkeit mit Von Amazon verwaltetes Grafana Dashboards, ein AWS-Distribution für OpenTelemetry Collector zum Sammeln von Metriken und Amazon Managed Service für Prometheus um sie zu speichern.

Lösungsüberblick

Das folgende Diagramm zeigt die Lösungsarchitektur.

Diese Lösung stellt einen Amazon EKS-Cluster mit einer Knotengruppe bereit, die Inf1-Instances enthält.

Der AMI-Typ der Knotengruppe ist AL2_x86_64_GPU, der das benutzt Amazon EKS optimiertes beschleunigtes Amazon Linux AMI. Zusätzlich zur standardmäßigen Amazon EKS-optimierten AMI-Konfiguration umfasst das beschleunigte AMI die NeuronX-Laufzeit.

Um über Kubernetes auf die ML-Chips zuzugreifen, stellt das Muster Folgendes bereit AWS-Neuron Geräte-Plugin.

Metriken werden Amazon Managed Service for Prometheus durch bereitgestellt neuron-monitor DaemonSet, das einen minimalen Container bereitstellt, mit dem Neuronen-Tools Eingerichtet. Konkret die neuron-monitor DaemonSet führt das aus neuron-monitor Befehl in die weitergeleitet neuron-monitor-prometheus.py Begleitskript (beide Befehle sind Teil des Containers):

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

Der Befehl verwendet die folgenden Komponenten:

  • neuron-monitor sammelt Metriken und Statistiken von den Neuron-Anwendungen, die auf dem System ausgeführt werden, und streamt die gesammelten Daten an stdout in JSON-Format
  • neuron-monitor-prometheus.py Ordnet die Telemetriedaten vom JSON-Format in ein Prometheus-kompatibles Format zu und macht sie verfügbar

Die Daten werden in Amazon Managed Grafana durch das entsprechende Dashboard visualisiert.

Der Rest des Setups zum Sammeln und Visualisieren von Metriken mit Amazon Managed Service for Prometheus und Amazon Managed Grafana ähnelt dem, das in anderen Open-Source-basierten Mustern verwendet wird, die im enthalten sind AWS Observability Accelerator for CDK GitHub-Repository.

Voraussetzungen:

Sie benötigen Folgendes, um die Schritte in diesem Beitrag auszuführen:

Richten Sie die Umgebung ein

Führen Sie die folgenden Schritte aus, um Ihre Umgebung einzurichten:

  1. Öffnen Sie ein Terminalfenster und führen Sie die folgenden Befehle aus:
export AWS_REGION=<YOUR AWS REGION>
export ACCOUNT_ID=$(aws sts get-caller-identity --query 'Account' --output text)

  1. Rufen Sie die Arbeitsbereichs-IDs aller vorhandenen Amazon Managed Grafana-Arbeitsbereiche ab:
aws grafana list-workspaces

Das Folgende ist unsere Beispielausgabe:

{
  "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. Weisen Sie die Werte zu id und endpoint auf die folgenden Umgebungsvariablen:
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 muss einschließen https://.

  1. Erstellen Sie einen Grafana-API-Schlüssel aus dem Amazon Managed Grafana-Arbeitsbereich:
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. Richten Sie ein Geheimnis ein AWS-Systemmanager:
aws ssm put-parameter --name "/cdk-accelerator/grafana-api-key" 
--type "SecureString" 
--value $AMG_API_KEY 
--region $AWS_REGION

Auf das Secret wird über das External Secrets-Add-on zugegriffen und es wird als natives Kubernetes-Secret im EKS-Cluster verfügbar gemacht.

Bootstrap der AWS CDK-Umgebung

Der erste Schritt bei jeder AWS CDK-Bereitstellung ist das Bootstrapping der Umgebung. Sie verwenden die cdk bootstrap Befehl in der AWS CDK-CLI, um die Umgebung (eine Kombination aus AWS-Konto und AWS-Region) mit Ressourcen vorzubereiten, die AWS CDK für die Durchführung von Bereitstellungen in dieser Umgebung benötigt. AWS CDK-Bootstrapping ist für jede Kombination aus Konto und Region erforderlich. Wenn Sie also bereits AWS CDK in einer Region gebootet haben, müssen Sie den Bootstrapping-Vorgang nicht wiederholen.

cdk bootstrap aws://$ACCOUNT_ID/$AWS_REGION

Stellen Sie die Lösung bereit

Führen Sie die folgenden Schritte aus, um die Lösung bereitzustellen:

  1. Klonen Sie die cdk-aws-observability-accelerator Repository und installieren Sie die Abhängigkeitspakete. Dieses Repository enthält in TypeScript geschriebenen AWS CDK v2-Code.
git clone https://github.com/aws-observability/cdk-aws-observability-accelerator.git
cd cdk-aws-observability-accelerator

Die tatsächlichen Einstellungen für die JSON-Dateien des Grafana-Dashboards werden voraussichtlich im AWS CDK-Kontext angegeben. Sie müssen aktualisieren context der cdk.json Datei, die sich im aktuellen Verzeichnis befindet. Der Standort des Dashboards wird durch angegeben fluxRepository.values.GRAFANA_NEURON_DASH_URL Parameter und neuronNodeGroup wird verwendet, um den Instanztyp, die Anzahl und festzulegen Amazon Elastic Block-Shop (Amazon EBS) Größe, die für die Knoten verwendet wird.

  1. Geben Sie den folgenden Ausschnitt ein cdk.json, Ersetzen 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
    }
  }

Sie können den Inf1-Instanztyp durch Inf2 ersetzen und die Größe nach Bedarf ändern. Um die Verfügbarkeit in Ihrer ausgewählten Region zu überprüfen, führen Sie den folgenden Befehl aus (ändern Values wie Sie es für richtig halten):

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

  1. Installieren Sie die Projektabhängigkeiten:
npm install

  1. Führen Sie die folgenden Befehle aus, um das Open-Source-Observability-Muster bereitzustellen:
make build
make pattern single-new-eks-inferentia-opensource-observability deploy

Validieren Sie die Lösung

Führen Sie die folgenden Schritte aus, um die Lösung zu validieren:

  1. Führen Sie die update-kubeconfig Befehl. Sie sollten den Befehl aus der Ausgabenachricht des vorherigen Befehls abrufen können:
aws eks update-kubeconfig --name single-new-eks-inferentia-opensource... --region <your region> --role-arn arn:aws:iam::xxxxxxxxx:role/single-new-eks-....

  1. Überprüfen Sie die von Ihnen erstellten Ressourcen:
kubectl get pods -A

Der folgende Screenshot zeigt unsere Beispielausgabe.

  1. Stellen Sie sicher, dass die neuron-device-plugin-daemonset DaemonSet läuft:
kubectl get ds neuron-device-plugin-daemonset --namespace kube-system

Das Folgende ist unsere erwartete Ausgabe:

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

  1. Bestätigen Sie, dass die neuron-monitor DaemonSet läuft:
kubectl get ds neuron-monitor --namespace kube-system

Das Folgende ist unsere erwartete Ausgabe:

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

  1. Um zu überprüfen, ob die Neuron-Geräte und -Kerne sichtbar sind, führen Sie Folgendes aus: neuron-ls und neuron-top Befehle beispielsweise von Ihrem Neuron-Monitor-Pod (den Namen des Pods können Sie der Ausgabe von entnehmen kubectl get pods -A):
kubectl exec -it {your neuron-monitor pod} -n kube-system -- /bin/bash -c "neuron-ls"

Der folgende Screenshot zeigt unsere erwartete Ausgabe.

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

Der folgende Screenshot zeigt unsere erwartete Ausgabe.

Visualisieren Sie Daten mit dem Grafana Neuron-Dashboard

Melden Sie sich bei Ihrem Amazon Managed Grafana-Arbeitsbereich an und navigieren Sie zu Armaturenbretter Panel. Sie sollten ein Dashboard mit dem Namen sehen Neuron / Monitor.

Um einige interessante Metriken im Grafana-Dashboard anzuzeigen, wenden wir das folgende Manifest an:

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

Dies ist ein Beispiel-Workload, der die kompiliert Torchvision ResNet50-Modell und führt wiederholte Inferenzen in einer Schleife aus, um Telemetriedaten zu generieren.

Um zu überprüfen, ob der Pod erfolgreich bereitgestellt wurde, führen Sie den folgenden Code aus:

kubectl get pods

Sie sollten einen Pod mit dem Namen sehen pytorch-inference-resnet50.

Nach ein paar Minuten Blick in die Neuron / Monitor Dashboard sollten Sie die gesammelten Metriken ähnlich den folgenden Screenshots sehen.

Grafana Operator und Flux arbeiten immer zusammen, um Ihre Dashboards mit Git zu synchronisieren. Wenn Sie Ihre Dashboards versehentlich löschen, werden sie automatisch neu bereitgestellt.

Aufräumen

Sie können den gesamten AWS CDK-Stack mit dem folgenden Befehl löschen:

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

Zusammenfassung

In diesem Beitrag haben wir Ihnen gezeigt, wie Sie mit Open-Source-Tools Beobachtbarkeit in einen EKS-Cluster mit einer Datenebene einführen, auf der EC2-Inf1-Instanzen ausgeführt werden. Wir begannen mit der Auswahl des Amazon EKS-optimierten beschleunigten AMI für die Datenebenenknoten, das die Neuron-Container-Laufzeit umfasst und Zugriff auf AWS Inferentia- und Trainium Neuron-Geräte bietet. Anschließend stellten wir das Neuron-Geräte-Plugin bereit, um die Neuron-Kerne und -Geräte Kubernetes zugänglich zu machen. Die eigentliche Erfassung und Zuordnung von Telemetriedaten in ein Prometheus-kompatibles Format wurde über erreicht neuron-monitor und neuron-monitor-prometheus.py. Die Metriken wurden von Amazon Managed Service für Prometheus bezogen und im Neuron-Dashboard von Amazon Managed Grafana angezeigt.

Wir empfehlen Ihnen, zusätzliche Beobachtbarkeitsmuster im zu untersuchen AWS Observability Accelerator für CDK GitHub-Repo. Weitere Informationen zu Neuron finden Sie im AWS Neuron-Dokumentation.

Über den Autor

Riccardo Freschi ist Senior Solutions Architect bei AWS und konzentriert sich auf die Modernisierung von Anwendungen. Er arbeitet eng mit Partnern und Kunden zusammen, um sie bei der Transformation ihrer IT-Landschaften auf ihrem Weg in die AWS Cloud zu unterstützen, indem er bestehende Anwendungen umgestaltet und neue erstellt.

spot_img

Neueste Intelligenz

spot_img

Copyright @ 2024 Plato Technologies Inc.