Démarrage rapide : Créer un cluster Azure Kubernetes Service (AKS) basé sur GPU linux à l’aide de Azure CLI

Azure Kubernetes Service (AKS) est un service Kubernetes géré que vous pouvez utiliser pour déployer et gérer rapidement des clusters. Dans ce guide de démarrage rapide, vous allez apprendre à :

  • Déployez un cluster AKS à l’aide de Azure CLI.
  • Ajoutez un pool de nœuds GPU Linux avec des nœuds GPU managés activés.
  • Vérifiez que AKS a installé et configuré la pile logicielle GPU pour la planification.

Les nœuds GPU complètement managés sont une fonctionnalité en préversion. Lorsque vous activez des nœuds GPU managés, AKS installe et gère le pilote GPU NVIDIA, le plug-in d’appareil NVIDIA Kubernetes, l’exportateur de métriques DCGM (Data Center GPU Manager) et les composants de surveillance de l’intégrité GPU pour le pool de nœuds GPU. Les nœuds GPU managés intègrent également des métriques GPU en temps réel pour l’ingestion dans Azure Prometheus managé et Azure Monitor service managé pour Prometheus. Pour plus d’informations, consultez Créer un pool de nœuds GPU entièrement managé sur Azure Kubernetes Service (AKS) (préversion) et l’observabilité GPU dans Azure Kubernetes Service (AKS).

Note

Cet article inclut uniquement les étapes de déploiement d’un cluster à des fins d’évaluation. Avant de déployer un cluster prêt pour la production, familiarisez-vous avec l’architecture de référence de base pour prendre en compte la façon dont elle s’aligne sur vos besoins métier.

Important

Les fonctionnalités d’évaluation AKS sont disponibles en libre-service et font l’objet d’un abonnement. Les versions préliminaires sont fournies « en l’état » et « selon leur disponibilité » et ne sont pas couvertes par les accords de niveau de service ni par la garantie limitée. Les versions préliminaires d’AKS sont partiellement couvertes par le support client, dans la limite du raisonnable. Par conséquent, ces fonctionnalités ne sont pas destinées à une utilisation en production. Pour plus d’informations, consultez les articles de support suivants :

Avant de commencer

Ce guide de démarrage rapide suppose une compréhension élémentaire des concepts liés à Kubernetes. Pour plus d’informations, consultez Concepts de base de Kubernetes pour AKS (Azure Kubernetes Service).

  • Si vous n’avez pas de compte Azure, créez un compte gratuit avant de commencer.

Installez l’extension CLI aks-preview

Installez l’extension aks-preview CLI à l’aide de la commande az extension add .

az extension add --name aks-preview

Mettez à jour l’extension pour vous assurer que vous disposez de la dernière version à l’aide de la commande az extension update .

az extension update --name aks-preview

Inscrire la fonctionnalité d’aperçu

Inscrivez l’indicateur ManagedGPUExperiencePreview de fonctionnalité dans votre abonnement à l’aide de la commande az feature register .

az feature register --namespace Microsoft.ContainerService --name ManagedGPUExperiencePreview

Quelques minutes sont nécessaires pour que l’état s’affiche Registered (Inscrit). Vérifiez l’état de l’inscription à l’aide de la commande az feature show.

az feature show --namespace Microsoft.ContainerService --name ManagedGPUExperiencePreview --query properties.state

Lorsque l’état indique Inscrit, actualisez l’inscription du Microsoft.ContainerService fournisseur de ressources à l’aide de la commande az provider register .

az provider register --namespace Microsoft.ContainerService

Définir des variables d’environnement

Définissez les variables d’environnement suivantes à utiliser tout au long de ce guide de démarrage rapide.

export RANDOM_STRING=$(printf '%05d%05d' "$RANDOM" "$RANDOM")
export RESOURCE_GROUP="myAKSResourceGroup$RANDOM_STRING"
export CLUSTER_NAME="myAKSCluster$RANDOM_STRING"
export GPU_NP="gpunp"
export GPU_VM_SIZE="Standard_NC4as_T4_v3"
export LOCATION="westus"

La RANDOM_STRING variable stocke une chaîne à 10 chiffres aléatoire. Les valeurs des variables RESOURCE_GROUP et CLUSTER_NAME sont concaténées avec la valeur RANDOM_STRING pour créer des noms uniques. La GPU_NP variable stocke le nom du pool de nœuds GPU managé. La GPU_VM_SIZE variable stocke la taille de machine virtuelle compatible GPU pour le pool de nœuds. La LOCATION variable a la valeur westus. Vous pouvez utiliser ces valeurs de variable ou créer vos propres valeurs. Utilisez la echo commande pour afficher les valeurs de variable comme echo $RANDOM_STRING.

Créer un groupe de ressources

Un groupe de ressources Azure est un groupe logique permettant de déployer et de gérer des ressources Azure. Lorsque vous créez un groupe de ressources, spécifiez un emplacement. Cet emplacement est l'emplacement où les métadonnées du groupe de ressources sont stockées et où vos ressources s'exécutent dans Azure si vous ne spécifiez pas une autre région lors de la création de la ressource.

Utilisez la commande az group create pour créer un groupe de ressources.

az group create --name $RESOURCE_GROUP --location $LOCATION

L’exemple suivant montre le résultat.

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/myAKSResourceGroup<randomStringValue>",
  "location": "westus",
  "managedBy": null,
  "name": "myAKSResourceGroup<randomStringValue>",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Créer un cluster AKS

Utilisez la commande az aks create pour créer un cluster AKS. L’exemple suivant crée un cluster avec un nœud système et active une identité managée affectée par le système.

az aks create \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --node-count 1 \
  --generate-ssh-keys

Lors de la création d’un nouveau cluster, un deuxième groupe de ressources est automatiquement créé par AKS pour stocker les ressources AKS. Pour plus d’informations, consultez Pourquoi deux groupes de ressources sont-ils créés avec AKS ?

Le cluster de cet exemple spécifie un nombre de nœuds d’un pour gagner du temps et des ressources. Dans un environnement de production, utilisez un nombre de nœuds de trois ou plusieurs nœuds. La az aks create commande est par défaut de trois nœuds si vous ne spécifiez pas de nombre de nœuds.

Ajouter un pool de nœuds GPU managé

Ajoutez un pool de nœuds GPU managé linux à votre cluster à l’aide de la commande az aks nodepool add . Le --enable-managed-gpu=true paramètre configure AKS pour installer et gérer le pilote GPU NVIDIA, le plug-in d’appareil NVIDIA Kubernetes, l’exportateur de métriques DCGM et les composants de surveillance de l’intégrité GPU sur le pool de nœuds.

L’exemple suivant ajoute un pool de nœuds GPU managé à l’aide du système d’exploitation Ubuntu Linux par défaut.

az aks nodepool add \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name $GPU_NP \
  --node-count 1 \
  --node-vm-size $GPU_VM_SIZE \
  --node-taints sku=gpu:NoSchedule \
  --enable-managed-gpu=true

Le --node-taints sku=gpu:NoSchedule paramètre conserve les charges de travail non GPU hors du pool de nœuds GPU, sauf si les charges de travail incluent une tolérance correspondante.

Après avoir créé le pool de nœuds, utilisez la commande az aks nodepool show pour vérifier que le profil GPU managé est activé.

az aks nodepool show \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name $GPU_NP \
  --query "{Name:name, Mode:mode, VmSize:vmSize, Taints:nodeTaints, GpuProfile:gpuProfile}"

Votre sortie doit inclure les valeurs suivantes.

{
  "GpuProfile": {
    "driver": "Install",
    "driverType": "",
    "nvidia": {
      "managementMode": "Managed",
      "migStrategy": null
    }
  },
  "Mode": "User",
  "Name": "gpunp",
  "Taints": [
    "sku=gpu:NoSchedule"
  ],
  "VmSize": "Standard_NC4as_T4_v3"
}

Se connecter au cluster

Pour gérer un cluster Kubernetes, utilisez kubectl, le client de ligne de commande Kubernetes. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé. Pour installer kubectl en local, utilisez la commande az aks install-cli.

  1. Configurez kubectl pour vous connecter à votre cluster Kubernetes à l’aide de la commande az aks get-credentials . Cette commande télécharge les informations d’identification et configure l’interface CLI Kubernetes pour les utiliser.

    az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME

  2. Vérifiez la connexion à votre cluster à l’aide de la commande kubectl get . Cette commande retourne une liste des nœuds de cluster et affiche le pool de nœuds pour chaque nœud.

    kubectl get nodes -L kubernetes.azure.com/agentpool,kubernetes.azure.com/mode

    NAME                                STATUS   ROLES    AGE     VERSION   AGENTPOOL   MODE
aks-nodepool1-123456789-vmss000000  Ready    <none>   20m     v1.34.4   nodepool1   system
aks-gpunp-123456789-vmss000000      Ready    <none>   5m36s   v1.34.4   gpunp       user

  3. Vérifiez que Kubernetes peut planifier des charges de travail GPU sur le pool de nœuds GPU managé.

    kubectl get nodes -l kubernetes.azure.com/agentpool=$GPU_NP -o=jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.allocatable.nvidia\.com/gpu}{"\n"}{end}'

    La sortie affiche le nombre de GPU allocatables pour chaque nœud du pool de nœuds GPU managé.

    aks-gpunp-123456789-vmss000000  1

Activer la collecte de métriques GPU

Les pools de nœuds GPU managés incluent l’exportateur de métriques DCGM. Pour ingérer les métriques GPU dans Azure Prometheus géré, activez d’abord Azure Monitor service managé pour Prometheus sur votre cluster AKS. Ensuite, créez une ConfigMap qui active le profil de récupération dcgmexporter dans l’agent Azure Monitor.

cat <<EOF | kubectl create -f -
kind: ConfigMap
apiVersion: v1
data:
  schema-version:
    v1
  config-version:
    ver1
  default-scrape-settings-enabled: |-
    dcgmexporter = true
metadata:
  name: ama-metrics-settings-configmap
  namespace: kube-system
EOF

Après avoir appliqué ce ConfigMap, tous les pools de nœuds GPU NVIDIA existants et nouveaux sur le cluster sont automatiquement supprimés. Pour afficher les métriques GPU dans Azure Managed Grafana, consultez l’observabilité gpu dans Azure Kubernetes Service (AKS).

Déployer l’application

Déployez une charge de travail GPU pour vérifier que le pool de nœuds GPU managé peut exécuter des applications réelles. Cet exemple exécute Ollama, qui sert un petit modèle de langage grand source open source (Llama 3.2 1B) via une API compatible OpenAI. Ollama est basé sur llama.cpp, qui prend en charge le GPU NVIDIA T4 dans le groupe de nœuds Standard_NC4as_T4_v3 utilisé par ce guide de démarrage rapide.

Le manifeste suivant crée un Deployment et un Service. Le Deployment demande un GPU (nvidia.com/gpu: 1), inclut une tolérance pour le taint sku=gpu:NoSchedule et utilise un sélecteur de nœuds pour cibler le pool de nœuds GPU géré. Au démarrage du conteneur, il lance le serveur Ollama et extrait le llama3.2:1b modèle afin que le pod soit prêt à traiter les demandes.

Déployez l’application à l’aide de la commande suivante.

cat <<'EOF' | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama
  labels:
    app: ollama
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama
  template:
    metadata:
      labels:
        app: ollama
    spec:
      # Schedule onto the managed GPU node pool created in this quickstart.
      nodeSelector:
        kubernetes.azure.com/agentpool: gpunp
      # Tolerate the GPU node pool taint (sku=gpu:NoSchedule).
      tolerations:
        - key: "sku"
          operator: "Equal"
          value: "gpu"
          effect: "NoSchedule"
      containers:
        - name: ollama
          image: ollama/ollama:0.30.10
          ports:
            - name: http
              containerPort: 11434
          env:
            # Listen on all interfaces so the Service and kubelet probes can reach it.
            - name: OLLAMA_HOST
              value: "0.0.0.0:11434"
            # Model to pull and serve on startup. Fits comfortably on a 16-GB T4.
            - name: MODEL
              value: "llama3.2:1b"
          # Start the server, wait until it's ready, and then pull the model so the
          # pod is self-contained (no manual "ollama pull" step required).
          command: ["/bin/sh", "-c"]
          args:
            - |
              ollama serve &
              pid=$!
              echo "Waiting for the Ollama server to be ready..."
              until ollama list >/dev/null 2>&1; do sleep 2; done
              echo "Server ready. Pulling model: $MODEL"
              ollama pull "$MODEL" || echo "WARN: pull failed; run 'kubectl exec deploy/ollama -- ollama pull $MODEL' manually"
              echo "Model $MODEL is ready to serve."
              wait $pid
          resources:
            requests:
              cpu: "1"
              memory: 4Gi
            limits:
              cpu: "4"
              memory: 16Gi
              nvidia.com/gpu: 1
          startupProbe:
            httpGet:
              path: /api/tags
              port: http
            periodSeconds: 5
            failureThreshold: 60
          readinessProbe:
            httpGet:
              path: /api/tags
              port: http
            periodSeconds: 10
          livenessProbe:
            httpGet:
              path: /
              port: http
            periodSeconds: 20
          volumeMounts:
            - name: ollama-data
              mountPath: /root/.ollama
      volumes:
        - name: ollama-data
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: ollama
  labels:
    app: ollama
spec:
  type: ClusterIP
  selector:
    app: ollama
  ports:
    - name: http
      port: 11434
      targetPort: http
EOF

Note

Ce manifeste cible le pool de gpunp nœuds. Si vous avez utilisé une autre valeur pour la GPU_NP variable, mettez à jour la kubernetes.azure.com/agentpool valeur du sélecteur de nœud pour qu’elle corresponde avant d’appliquer le manifeste.

Vérifiez que le déploiement est prêt à l’aide de la commande d’état de déploiement kubectl . Le téléchargement initial du modèle peut prendre quelques minutes.

kubectl rollout status deployment/ollama --timeout=600s

Vérifiez que le pod s’exécute sur le pool de nœuds GPU géré à l’aide de la commande kubectl get .

kubectl get pods -l app=ollama -o wide

Votre sortie doit afficher le pod s’exécutant sur un nœud dans le pool de gpunp nœuds.

NAME                      READY   STATUS    RESTARTS   AGE   IP            NODE                            NOMINATED NODE   READINESS GATES
ollama-5b8f6c9d4f-2xq7p   1/1     Running   0          5m    10.244.1.10   aks-gpunp-12345678-vmss000000   <none>           <none>

Tester l’application

Transférez un port local vers le Service à l’aide de la commande kubectl port-forward. Conservez cette commande en cours d’exécution et ouvrez un deuxième terminal pour les étapes restantes.

kubectl port-forward svc/ollama 11434:11434

Dans le deuxième terminal, envoyez une requête au modèle en utilisant le point de terminaison des complétions de chat compatible avec OpenAI.

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:1b",
    "messages": [{"role": "user", "content": "In one sentence, what is Azure Kubernetes Service?"}]
  }'

Le modèle retourne une réponse JSON qui contient une réponse générée, ce qui confirme que la charge de travail sert l’inférence à partir du pool de nœuds GPU managé.

Vérifiez que le modèle est chargé sur le GPU à l’aide de la ollama ps commande. La PROCESSOR colonne indique 100% GPU quand le modèle s’exécute sur le T4.

kubectl exec deploy/ollama -- ollama ps

NAME          ID              SIZE      PROCESSOR    CONTEXT   UNTIL
llama3.2:1b   baf6a787fdff    1.5 GB    100% GPU     4096      4 minutes from now

Vous pouvez également afficher le GPU directement à partir de l’intérieur du pod à l’aide de la nvidia-smi commande.

kubectl exec deploy/ollama -- nvidia-smi

Lorsque vous avez terminé le test, arrêtez le kubectl port-forward processus en sélectionnant Ctrl+C dans son terminal. L’application est supprimée lorsque vous supprimez le cluster à l’étape suivante.

Supprimer le cluster

Si vous n’envisagez pas de suivre le didacticiel AKS, supprimez les ressources superflues afin d’éviter toute facturation Azure. Vous pouvez supprimer le groupe de ressources, le service de conteneur et toutes les ressources associées à l’aide de la commande az group delete .

az group delete --name $RESOURCE_GROUP --no-wait --yes

Vous avez créé le cluster AKS avec une identité managée affectée par le système, qui est l’option d’identité par défaut utilisée dans ce guide de démarrage rapide. La plateforme gère cette identité afin que vous n’ayez pas besoin de la supprimer manuellement.

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez déployé un cluster Kubernetes, puis ajouté un pool de nœuds GPU managé linux. Pour plus d’informations sur les nœuds GPU managés et les métriques GPU, consultez les articles suivants :

Pour en savoir plus sur AKS et effectuer un exemple complet de code à déploiement, passez au didacticiel sur le cluster Kubernetes.

Tutoriel AKS

  • Last updated on