Inicio rápido: Creación de un clúster de Azure Kubernetes Service (AKS) basado en GPU linux mediante CLI de Azure

Azure Kubernetes Service (AKS) es un servicio de Kubernetes administrado que puede usar para implementar y administrar clústeres rápidamente. En este inicio rápido, aprenderá a:

  • Implemente un clúster de AKS mediante CLI de Azure.
  • Agregue un grupo de nodos de GPU basado en Linux con nodos de GPU administrados habilitados.
  • Compruebe que AKS instaló y configuró la pila de software de la GPU para la planificación.

Los nodos de GPU totalmente administrados son una característica en versión preliminar. Al habilitar nodos de GPU administrados, AKS instala y administra el controlador de GPU nvidia, el complemento de dispositivos NVIDIA Kubernetes, el exportador de métricas de Data Center GPU Manager (DCGM) y los componentes de supervisión de estado de GPU para el grupo de nodos de GPU. Los nodos de GPU administrados también integran métricas de GPU en tiempo real para su ingesta en Azure Managed Prometheus y el servicio administrado para Prometheus de Azure Monitor. Para más información, consulte Creación de un grupo de nodos de GPU totalmente administrado en Azure Kubernetes Service (AKS) (versión preliminar) y observabilidad de GPU en Azure Kubernetes Service (AKS).

Note

En este artículo se incluyen los pasos para implementar un clúster solo con fines de evaluación. Antes de implementar un clúster listo para producción, familiarícese con la arquitectura de referencia de línea base para considerar cómo se alinea con sus requisitos empresariales.

Importante

Las características en versión preliminar de AKS están disponibles en modalidad de autoservicio y previa suscripción. Las versiones preliminares se proporcionan "tal cual" y "como están disponibles", y están excluidas de los Acuerdos de nivel de servicio y la garantía limitada. Las versiones preliminares de AKS cuentan con soporte parcial por parte del servicio al cliente en la medida de lo posible. Por lo tanto, estas características no están diseñadas para su uso en producción. Para más información, consulte los siguientes artículos de soporte:

Antes de empezar

En esta guía rápida se presupone un conocimiento básico de los conceptos de Kubernetes. Para más información, consulte Conceptos básicos de Kubernetes de Azure Kubernetes Service (AKS).

  • Si no tiene una cuenta de Azure, cree una cuenta gratuita antes de comenzar.

Instalación de la extensión aks-preview de la CLI

Instale la extensión de la aks-preview CLI mediante el comando az extension add .

az extension add --name aks-preview

Actualice la extensión para asegurarse de que tiene la versión más reciente mediante el comando az extension update .

az extension update --name aks-preview

Registro de la característica de vista previa

Registre el indicador de características ManagedGPUExperiencePreview en su suscripción con el comando az feature register.

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

Tarda unos minutos en que el estado muestre Registrado. Para comprobar el estado de registro se usa el comandoaz feature show.

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

Cuando el estado muestre Registrado, actualice el registro del Microsoft.ContainerService proveedor de recursos mediante el comando az provider register .

az provider register --namespace Microsoft.ContainerService

Definición de variables de entorno

Defina las siguientes variables de entorno para usarlas en este inicio rápido.

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 almacena una cadena aleatoria de 10 dígitos. Los valores de las variables RESOURCE_GROUP y CLUSTER_NAME se concatenan con el valor RANDOM_STRING para crear nombres únicos. La GPU_NP variable almacena el nombre del grupo de nodos de GPU administrado. La GPU_VM_SIZE variable almacena el tamaño de máquina virtual habilitado para GPU para el grupo de nodos. La LOCATION variable tiene el valor westus. Puede usar estos valores de variable o crear sus propios. Use el echo comando para ver valores de variable como echo $RANDOM_STRING.

Creación de un grupo de recursos

Un grupo de recursos Azure es un grupo lógico para implementar y administrar recursos Azure. Al crear un grupo de recursos, especifique una ubicación. Esta ubicación es donde se almacenan los metadatos del grupo de recursos y dónde se ejecutan los recursos en Azure si no especifica otra región durante la creación de recursos.

Use el comando az group create para crear un grupo de recursos.

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

En el ejemplo siguiente se muestra el resultado.

{
  "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"
}

Creación de un clúster de AKS

Use el comando az aks create para crear un clúster de AKS. En el ejemplo siguiente se crea un clúster con un nodo del sistema y se habilita una identidad administrada asignada por el sistema.

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

Al crear un nuevo clúster, AKS crea automáticamente un segundo grupo de recursos para almacenar los recursos de AKS. Para más información, consulte ¿Por qué se crean dos grupos de recursos con AKS?

El clúster de este ejemplo especifica un recuento de nodos de uno para ahorrar tiempo y recursos. En un entorno de producción, use un recuento de nodos de tres o más nodos. El az aks create comando tiene como valor predeterminado tres nodos si no especifica un recuento de nodos.

Adición de un grupo de nodos de GPU administrado

Agregue un grupo de nodos de GPU administrados basado en Linux al clúster mediante el comando az aks nodepool add . El --enable-managed-gpu=true parámetro configura AKS para instalar y administrar el controlador de GPU nvidia, el complemento de dispositivos NVIDIA Kubernetes, el exportador de métricas DCGM y los componentes de supervisión del estado de GPU en el grupo de nodos.

En el ejemplo siguiente se agrega un grupo de nodos de GPU administrado mediante el sistema operativo Ubuntu Linux predeterminado.

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

El --node-taints sku=gpu:NoSchedule parámetro mantiene las cargas de trabajo que no son de GPU fuera del grupo de nodos de GPU a menos que las cargas de trabajo incluyan una tolerancia coincidente.

Después de crear el grupo de nodos, use el comando az aks nodepool show para confirmar que el perfil de GPU administrado está habilitado.

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}"

La salida debe incluir los valores siguientes.

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

Conectarse al clúster

Para administrar un clúster de Kubernetes, use kubectl, el cliente de línea de comandos de Kubernetes. Si usa Azure Cloud Shell, kubectl ya está instalado. Para instalar kubectl localmente, use el comando az aks install-cli.

  1. Configure kubectl para conectarse al clúster de Kubernetes mediante el comando az aks get-credentials . Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.

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

  2. Compruebe la conexión al clúster mediante el comando kubectl get . Este comando devuelve una lista de los nodos del clúster y muestra el grupo de nodos para cada nodo.

    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. Compruebe que Kubernetes puede programar cargas de trabajo de GPU en el grupo de nodos de GPU administrado.

    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 salida muestra el recuento de GPU allocatable para cada nodo del grupo de nodos de GPU administrado.

    aks-gpunp-123456789-vmss000000  1

Habilitación de la recopilación de métricas de GPU

Los grupos de nodos de GPU administrados incluyen el exportador de métricas DCGM. Para ingerir las métricas de GPU en Azure Managed Prometheus, primero habilite el servicio administrado de Azure Monitor para Prometheus en su clúster de AKS. A continuación, cree un ConfigMap que habilite el perfil de extracción dcgmexporter en el agente de 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

Después de aplicar este ConfigMap, todos los grupos de nodos con GPU de NVIDIA, tanto existentes como nuevos, en el clúster se recopilan automáticamente. Para ver las métricas de GPU en Azure Managed Grafana, consulte Observabilidad de GPU en Azure Kubernetes Service (AKS).

Implementación de la aplicación

Implemente una carga de trabajo de GPU para confirmar que el grupo de nodos de GPU administrado puede ejecutar aplicaciones reales. En este ejemplo se ejecuta Ollama, que sirve un pequeño modelo de lenguaje grande de código abierto (Llama 3.2 1B) a través de una API compatible con OpenAI. Ollama se basa en llama.cpp, que admite la GPU NVIDIA T4 en el Standard_NC4as_T4_v3 grupo de nodos que usa esta guía de inicio rápido.

El siguiente manifiesto crea un Deployment y un Service. El Deployment solicita una GPU (nvidia.com/gpu: 1), incluye una tolerancia para la marca sku=gpu:NoSchedule y usa un selector de nodos para seleccionar el grupo de nodos de GPU administrado. Cuando se inicia el contenedor, se inicia el servidor de Ollama y se descarga el modelo llama3.2:1b para que el pod esté listo para procesar solicitudes.

Implemente la aplicación mediante el comando siguiente.

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

Este manifiesto tiene como destino el grupo de gpunp nodos. Si usó un valor diferente para la GPU_NP variable, actualice el valor del kubernetes.azure.com/agentpool selector de nodos para que coincida antes de aplicar el manifiesto.

Confirme que la implementación está lista mediante el comando kubectl rollout status . La descarga del modelo inicial puede tardar unos minutos.

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

Compruebe que el pod se ejecuta en el grupo de nodos de GPU administrado mediante el comando kubectl get .

kubectl get pods -l app=ollama -o wide

La salida debe mostrar el pod en ejecución en un nodo del grupo de nodos gpunp.

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>

Prueba de la aplicación

Reenvíe un puerto local a Service mediante el comando kubectl port-forward . Mantenga este comando en ejecución y abra un segundo terminal para los pasos restantes.

kubectl port-forward svc/ollama 11434:11434

En el segundo terminal, envíe un prompt al modelo mediante el endpoint de finalizaciones de chat compatible con 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?"}]
  }'

El modelo devuelve una respuesta JSON que contiene una respuesta generada, que confirma que la carga de trabajo atiende la inferencia desde el grupo de nodos de GPU administrado.

Confirme que el modelo se carga en la GPU mediante el ollama ps comando . La PROCESSOR columna muestra 100% GPU cuándo se ejecuta el modelo en el 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

También puede ver la GPU directamente desde dentro del pod mediante el nvidia-smi comando .

kubectl exec deploy/ollama -- nvidia-smi

Cuando termine de probar, detenga el kubectl port-forward proceso seleccionando Ctrl+C en su terminal. La aplicación se quita al eliminar el clúster en el paso siguiente.

Eliminación del clúster

Si no planea realizar el tutorial de AKS, limpie los recursos innecesarios para evitar los cargos de facturación de Azure. Puede quitar el grupo de recursos, el servicio de contenedor y todos los recursos relacionados mediante el comando az group delete .

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

Ha creado el clúster de AKS con una identidad administrada asignada por el sistema, que es la opción de identidad predeterminada que se usa en este inicio rápido. La plataforma administra esta identidad para que no tenga que quitarla manualmente.

Pasos siguientes

En este inicio rápido, ha implementado un clúster de Kubernetes y, a continuación, ha agregado un grupo de nodos de GPU administrados basado en Linux. Para más información sobre los nodos de GPU administrados y las métricas de GPU, consulte los siguientes artículos:

Para más información sobre AKS y realizar un ejemplo completo de código a implementación, continúe con el tutorial del clúster de Kubernetes.

Tutorial de AKS

  • Last updated on