Einrichten der GPU-Profilerstellung für Azure Kubernetes Service (AKS) (Vorschau)

GPU-basierte Workloads, z. B. KI-Ableitungsdienste, können arbeitsspeicherintensiv und schwierig zu optimieren sein, ohne dass die GPU-Aktivität sichtbar ist. Möglicherweise werden Fehler außerhalb des Arbeitsspeichers (Out-of-Memory, OOM), unerwartete Latenzspitzen oder steigender GPU-Speicherdruck angezeigt, herkömmliche Kubernetes-Metriken zeigen jedoch nicht an, wo der Code Arbeitsspeicher zuweist. GPU-Profiling hilft Ihnen dabei, die Funktionen zu identifizieren, die für die Nutzung des GPU-Speichers verantwortlich sind.

In diesem Artikel erfahren Sie, wie Sie einen eBPF-basierten GPU-Observability-Agent bereitstellen, Profile in Pyroscope speichern und GPU-Speicherzuordnungen in Grafana visualisieren.

Important

AKS-Preview-Funktionen stehen auf Selbstbedienungs- und Opt-in-Basis zur Verfügung. Vorschauversionen werden „im Istzustand“ und „wie verfügbar“ bereitgestellt und sind von den Service Level Agreements und der eingeschränkten Garantie ausgeschlossen. AKS-Vorschauversionen werden teilweise vom Kundensupport auf Grundlage der bestmöglichen Leistung abgedeckt. Daher sind diese Funktionen nicht für die Verwendung in der Produktion vorgesehen. Weitere Informationen finden Sie in den folgenden Supportartikeln:

Important

Open-Source-Software wird überall in AKS-Dokumenten und -Beispielen erwähnt. Software, die Sie bereitstellen, ist von AKS-Vereinbarungen zum Servicelevel, der eingeschränkten Garantie und dem Azure-Support ausgeschlossen. Wenn Sie Open-Source-Technologie zusammen mit AKS nutzen, nutzen Sie die Supportoptionen, die von den jeweiligen Communitys und Projektbetreuenden angeboten werden, um einen Plan zu entwickeln.

Microsoft übernimmt die Verantwortung für die Erstellung der Open-Source-Pakete, die wir auf AKS bereitstellen. Diese Verantwortung beinhaltet die vollständige Übernahme des Build-, Scan-, Signier-, Validierungs- und Hotfix-Prozesses sowie die Kontrolle über die Binärdateien in Container-Images. Weitere Informationen finden Sie unter Sicherheitsrisikomanagement für AKS und AKS-Supportabdeckung.

Voraussetzungen

  • Ein AKS-Cluster mit mindestens einem GPU-fähigen Knotenpool.
  • Azure CLI Version 2.72.0 oder höher. Führen Sie az --version aus, um Ihre Version zu überprüfen.
  • Die k8s-extension Azure CLI-Erweiterung. Führen Sie az extension add --name k8s-extension aus, um es zu installieren.
  • Helm Version 3.x oder höher. Führen Sie helm version aus, um Ihre Version zu überprüfen.
  • Azure Monitor, es sei denn, Sie verwenden Ihr eigenes Überwachungssetup.
  • Azure Managed Grafana, es sei denn, Sie verwenden Ihre eigene Grafana-Instanz.

Schritt 1: GPU-Profiling über die Erweiterung „Inspektor Gadget“ aktivieren

Inspektor Gadget ist ein open-source eBPF-basiertes Observability Framework für Kubernetes. Für das GPU-Profiling werden CUDA-Speicherzuweisungsaufrufe (Compute Unified Device Architecture) ohne Codeänderungen, Sidecars oder Pod-Neustarts verfolgt.

Aktivieren Sie das GPU-Profiling auf Ihrem AKS-Cluster:

Note

Bei diesem Befehl wird davon ausgegangen, dass Sie Azure Monitor auf Ihrem AKS-Cluster aktiviert haben. Wenn Sie Ihr eigenes Prometheus-Setup verwenden, entfernen Sie --configuration-settings azureMonitor.enabled=true. Weitere Informationen finden Sie in den häufig gestellten Fragen zur GPU-Profilerstellung.

az k8s-extension create \
  --extension-type microsoft.inspektorgadget \
  --subscription <your-subscription-id> \
  --resource-group <your-resource-group> \
  --cluster-name <your-cluster-name> \
  --cluster-type managedClusters \
  --release-train preview \
  --name inspektor-gadget \
  --configuration-settings gpuObservability.enabled=true \
  --configuration-settings azureMonitor.enabled=true

Vergewissern Sie sich, dass die Inspektor Gadget-Pods laufen:

kubectl get pods -n gadget -l k8s-app=gadget

Tip

Die GPU-Speicherprofilerstellung erfasst Speicherzuordnungsereignisse, sobald sie auftreten. Wenn Ihre Workload GPU-Speicher zuweist, bevor Sie die Profilerstellung aktivieren, erfasst der Profiler diese Ereignisse nicht. Aktivieren Sie bei Workloads wie vLLM, die den GPU-Speicher beim Start vorab reservieren, das Profiling, bevor Sie die Workload bereitstellen, oder starten Sie die Workload neu, um die anfänglichen Speicherzuweisungspfade zu erfassen.

Schritt 2: Aktivieren der Profilvisualisierung mit Pyroscope

Note

Wenn Sie über einen vorhandenen Grafana- und Pyroscope-Stapel in Ihrem Cluster verfügen, überspringen Sie diesen Schritt.

Pyroscope ist ein Open-Source-Projekt, das Leistungsprofile zur Speicheroptimierung und Zur Problembehandlung visualisiert und speichert.

Stellen Sie eine einzelne Pyroscope-Instanz auf Ihrem Cluster bereit:

helm install pyroscope -n gadget \
  oci://ghcr.io/grafana/helm-charts/pyroscope \
  --version 1.15.0 \
  --set pyroscope.image.repository=grafana/pyroscope \
  --set-string pyroscope.image.tag=1.15.0 \
  --set pyroscope.replicaCount=1 \
  --set pyroscope.structuredConfig.self_profiling.disable_push=true \
  --set pyroscope.structuredConfig.storage.backend=filesystem \
  --set pyroscope.service.type=LoadBalancer \
  --set pyroscope.service.port=4040 \
  --set-string pyroscope.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-internal"=true \
  --set-string pyroscope.service.annotations."service\.beta\.kubernetes\.io/azure-pls-create"=true \
  --set-string pyroscope.service.annotations."service\.beta\.kubernetes\.io/azure-pls-name"=pyroscope-pls \
  --set-string pyroscope.service.annotations."service\.beta\.kubernetes\.io/azure-pls-proxy-protocol"=false \
  --set-string pyroscope.service.annotations."service\.beta\.kubernetes\.io/azure-pls-visibility"='*' \
  --set alloy.enabled=false \
  --set minio.enabled=false

Überprüfen Sie, ob der Pyroscope-Pod läuft:

kubectl get pods -n gadget pyroscope-0

Note

Informationen zu einer hochverfügbaren Bereitstellung finden Sie in der Dokumentation zu den Pyroscope-Mikroservices.

Note

Dieser Befehl speichert Profile im lokalen Dateisystem, sodass Profilerstellungsdaten verloren gehen, wenn der Pod neu erstellt wird. Informationen dazu, wie Profile über Pod-Neustarts hinweg beibehalten werden, finden Sie im GPU-Profiling-FAQ.

Schritt 3: Verbinden von Pyroscope mit Azure Managed Grafana

Note

Wenn Sie Ihre eigene Grafana-Instanz verwenden, lesen Sie die häufig gestellten Fragen zur GPU-Profilerstellung.

Tip

Um Workload-Profile direkt in der Pyroscope-Benutzeroberfläche anzuzeigen, führen Sie kubectl port-forward -n gadget pyroscope-0 4040:4040 aus.

Verbinden Sie Pyroscope mit Azure Managed Grafana über Azure Private Link.

Legen Sie die Cluster- und Grafana-Umgebungsvariablen fest:

export RESOURCE_GROUP="<your-resource-group>"
export AKS_CLUSTER="<your-aks-cluster-name>"
export LOCATION="<your-aks-cluster-location>"
export GRAFANA_NAME="<your-azure-managed-grafana-name>"
export AKS_NODE_RG=$(az aks show \
  --resource-group "$RESOURCE_GROUP" \
  --name "$AKS_CLUSTER" \
  --query 'nodeResourceGroup' \
  --output tsv)

Tip

Wenn Sie keine Azure Managed Grafana-Instanz haben, führen Sie az grafana create --name "$GRAFANA_NAME" --resource-group "$RESOURCE_GROUP" --location "$LOCATION" --output none aus.

Legen Sie die Variablen der privaten Endpunktumgebung fest:

export PYROSCOPE_PLS="pyroscope-pls"
export PYROSCOPE_MPE="pyroscope-mpe"
export PYROSCOPE_PORT="4040"

Erstellen Sie den privaten Link:

Note

Das Erstellen des privaten Links kann einige Minuten dauern.

# Check the Azure Managed Grafana extension version.
ver=$(az extension show --name amg --query version --output tsv)
[[ "${ver%%.*}" -ge 3 ]] && MPE="managed-private-endpoint" || MPE="mpe"

# Wait until the Pyroscope private link service is available.
until az network private-link-service show \
  --name "$PYROSCOPE_PLS" \
  --resource-group "$AKS_NODE_RG" \
  --output none 2>/dev/null; do
  sleep 10
done

PYRO_PLS_ID=$(az network private-link-service show \
  --name "$PYROSCOPE_PLS" \
  --resource-group "$AKS_NODE_RG" \
  --query 'id' \
  --output tsv)

az grafana $MPE create \
  --workspace-name "$GRAFANA_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --name "$PYROSCOPE_MPE" \
  --private-link-resource-id "$PYRO_PLS_ID" \
  --location "$LOCATION" \
  --output none

sleep 30

PYRO_CONN=$(az network private-link-service show \
  --name "$PYROSCOPE_PLS" \
  --resource-group "$AKS_NODE_RG" \
  --query "privateEndpointConnections[?privateLinkServiceConnectionState.status=='Pending' && starts_with(name, 'grafana-${GRAFANA_NAME}')].name | [0]" \
  --output tsv)

az network private-link-service connection update \
  --name "$PYRO_CONN" \
  --service-name "$PYROSCOPE_PLS" \
  --resource-group "$AKS_NODE_RG" \
  --connection-status Approved \
  --output none

az grafana $MPE refresh \
  --workspace-name "$GRAFANA_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --output none

echo "Successfully created private link."

Erstellen Sie die Pyroscope-Datenquelle in Azure Managed Grafana:

ver=$(az extension show --name amg --query version --output tsv)
[[ "${ver%%.*}" -ge 3 ]] && MPE="managed-private-endpoint" || MPE="mpe"

PYRO_IP=$(az grafana $MPE show \
  --workspace-name "$GRAFANA_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --name "$PYROSCOPE_MPE" \
  --query 'privateLinkServicePrivateIP' \
  --output tsv)

export PYROSCOPE_URL="http://${PYRO_IP}:${PYROSCOPE_PORT}"

az grafana data-source create \
  --name "$GRAFANA_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --definition "{
    \"name\": \"local-pyroscope\",
    \"uid\": \"local-pyroscope\",
    \"type\": \"grafana-pyroscope-datasource\",
    \"access\": \"proxy\",
    \"url\": \"${PYROSCOPE_URL}\",
    \"jsonData\": { \"keepCookies\": [\"pyroscope_git_session\"] }
  }" \
  --output none

echo "Successfully created the local-pyroscope data source."

Stellen Sie sicher, dass die Datenquelle über eine gültige URL verfügt:

az grafana data-source show \
  --name "$GRAFANA_NAME" \
  --data-source local-pyroscope

Schritt 4: Verbinden Sie Grafana mit dem verwalteten Azure Monitor-Dienst für Prometheus

Note

Diese Schritte basieren auf Azure Monitor Managed Service für Prometheus mit Grafana verbinden. Stellen Sie sicher, dass die verwaltete Identität von Grafana über die Rolle "Überwachungsdatenleser" im Azure Monitor Arbeitsbereich verfügt, insbesondere, wenn sich der Arbeitsbereich in einer anderen Ressourcengruppe oder einem anderen Abonnement befindet.

Legen Sie die Azure Monitor Arbeitsbereichsumgebungsvariablen fest:

export AMP_NAME="<your-azure-monitor-workspace-name>"
export AMP_RESOURCE_GROUP="<your-azure-monitor-workspace-resource-group>"

Tip

Führen Sie az resource list --resource-type Microsoft.Monitor/accounts --resource-group "$AMP_RESOURCE_GROUP" --output table aus, um Azure Monitor-Arbeitsbereiche in der Ressourcengruppe aufzulisten. Um das Abonnement zu durchsuchen, lassen Sie --resource-group weg.

Erstellen Sie die Prometheus-Datenquelle:

AMP_ENDPOINT=$(az resource show \
  --resource-type Microsoft.Monitor/accounts \
  --name "$AMP_NAME" \
  --resource-group "$AMP_RESOURCE_GROUP" \
  --query properties.metrics.prometheusQueryEndpoint \
  --output tsv)

az grafana data-source create \
  --name "$GRAFANA_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --definition "{
    \"name\": \"$AMP_NAME\",
    \"type\": \"prometheus\",
    \"access\": \"proxy\",
    \"url\": \"$AMP_ENDPOINT\",
    \"jsonData\": {
      \"httpMethod\": \"POST\",
      \"azureCredentials\": { \"authType\": \"msi\" }
    }
  }"

Überprüfen Sie die Datenquelle:

az grafana data-source show \
  --name "$GRAFANA_NAME" \
  --data-source "$AMP_NAME"

Schritt 5: Einrichten von Dashboards in Grafana

Importieren Sie das GPU-Observability-Dashboard:

az grafana dashboard create \
  --name "$GRAFANA_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --definition "$(curl -sSL https://raw.githubusercontent.com/inspektor-gadget/grafana-dashboards/refs/heads/main/dashboards/gpu-observability/AdvancedGPUObservability.json)"

Abrufen der Dashboard-URL:

GRAFANA_URL=$(az grafana show \
  --name "$GRAFANA_NAME" \
  --resource-group "$RESOURCE_GROUP" \
  --query properties.endpoint \
  --output tsv)

echo "${GRAFANA_URL}/d/AdvancedGPUObservability"

Zur Interpretation der Profiling-Daten siehe GPU-Profiling-Flammendiagramme analysieren.

Bereinigen von Ressourcen

Entfernen Sie den GPU-Observability-Stack im Cluster:

helm uninstall pyroscope -n gadget
az k8s-extension delete \
  --name inspektor-gadget \
  --cluster-name <your-cluster-name> \
  --resource-group <your-resource-group> \
  --cluster-type managedClusters \
  --yes
kubectl delete namespace gadget

Lesen von Flammendiagrammen

Informationen zum Interpretieren von Profilerstellungsergebnissen und Identifizieren von GPU-Speicher-Hotspots finden Sie unter Analysieren von GPU-Profilerstellungsflammdiagrammen.

FAQ

Informationen zu benutzerdefinierten Prometheus- und Grafana-Integrationen und persistentem Pyroscope-Speicher finden Sie in den HÄUFIG gestellten Fragen zur GPU-Profilerstellung.

Nächste Schritte

  • Zuletzt aktualisiert um