Installera det hanterade KubeRay-tillägget på Azure Kubernetes Service (AKS) (förhandsversion)

Det hanterade KubeRay-tillägget för Azure Kubernetes Service (AKS) finns i förhandsversionen. Den installerar och hanterar KubeRay-operatorn och ray-anpassade resursdefinitioner (CRD) i klustret: RayCluster, RayJob, RayCronJoboch RayService.

Den här artikeln visar hur du installerar, verifierar, uppdaterar och tar bort tillägget med hjälp av Azure CLI. Du distribuerar också en Ray-exempelarbetsbelastning för att bekräfta att operatorn hanterar Ray-resurser som förväntat.

Prerequisites

• En Azure-prenumeration och ett AKS-kluster som kör Kubernetes 1.34 eller senare och använder hanterad identitet i en AKS-stödd Azure offentlig molnregion. Om du inte har något kluster kan du läsa Skapa ett AKS-kluster med hjälp av Azure CLI.
• En aktuell version av Azure CLI.
• Azure CLI-tillägget k8s-extension version 1.8.0 eller senare krävs.
• kubectl kompatibel med klustrets Kubernetes-version.
• Behörigheter för att registrera Azure resursprovidrar, hantera klustertillägg, hämta klusterautentiseringsuppgifter och inspektera Kubernetes-resurser.

Limitations

• Befintliga INSTALLATIONer av programvara med öppen källkod (OSS) KubeRay:Avinstallera alla befintliga självvärdbaserade KubeRay-operator innan du installerar det hanterade KubeRay-tillägget (microsoft.kuberay). En avvisad installation kan fortfarande ändra Ray CRD-scheman och ägarskap, och att ta bort det misslyckade tillägget ångrar inte dessa ändringar. Bevara CRD:er och arbetslastresurser. Om en installation redan har misslyckats följer du vägledningen för återställning innan du försöker igen.

Förbered din miljö

I följande exempel används Bash. Ange din prenumeration och befintlig klusterinformation och logga sedan in:

SUBSCRIPTION_ID="<subscription-id>"
RESOURCE_GROUP="<existing-resource-group>"
CLUSTER_NAME="<existing-aks-cluster>"
EXTENSION_NAME="kuberay"
RELEASE_TRAIN="preview"

az login
az account set --subscription "$SUBSCRIPTION_ID"

Kontrollera klustrets Kubernetes-version. Bekräfta att den returnerade versionen är 1.34 eller senare innan du fortsätter:

az aks show \
  --resource-group "$RESOURCE_GROUP" \
  --name "$CLUSTER_NAME" \
  --query kubernetesVersion \
  --output tsv

Anslut till klustret:

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

Installera eller uppdatera CLI-tillägget och registrera nödvändiga resursprovidrar:

az extension add --name k8s-extension --upgrade

az provider register --namespace Microsoft.ContainerService --wait
az provider register --namespace Microsoft.KubernetesConfiguration --wait

Kontrollera den installerade VERSIONEN av CLI-tillägget:

az extension show --name k8s-extension --query version --output tsv

Installation av CLI-tillägget tillhandahåller hanteringskommandon. Det installerar inte KubeRay i klustret.

Avinstallera en befintlig OSS KubeRay-operator

Hoppa över det här steget om du inte har en självhostad operator. Annars säkerhetskopierar du arbetsbelastningsdata och manifest, pausar RayCronJob scheman och väntar på att jobben ska slutföras innan operatorn tas bort.

För en Helm-installation letar du reda på versionsnamn och namnområdet:

helm list --all-namespaces

Ta bara bort operatorutgåvan och bekräfta att distributionen är borta:

OSS_RELEASE_NAME="<existing-kuberay-release-name>"
OSS_RELEASE_NAMESPACE="<existing-kuberay-release-namespace>"

helm uninstall "$OSS_RELEASE_NAME" --namespace "$OSS_RELEASE_NAMESPACE"
kubectl get deployments --namespace "$OSS_RELEASE_NAMESPACE"

Kontrollera att det behållna namnområdet visar Active och att varje behållen *.ray.io CRD visar ESTABLISHED i kolumnen True:

kubectl get namespace "$OSS_RELEASE_NAMESPACE"
kubectl get crds \
  --output='custom-columns=NAME:.metadata.name,ESTABLISHED:.status.conditions[?(@.type=="Established")].status'

Om namnrymden avslutas eller om en Ray CRD inte har upprättats löser du problemet innan du aktiverar tillägget.

Använd deras procedur för att ta bort operatorn för andra installationsmetoder. Bevara Ray CRD och workload-resurser; ta inte bort deras namnområden eller CRD:er.

Installera det hanterade KubeRay-tillägget

Lista de tilläggsversioner som är tillgängliga för klustret och releasegrenen preview:

az k8s-extension extension-types list-versions-by-cluster \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$CLUSTER_NAME" \
  --cluster-type managedClusters \
  --extension-type microsoft.kuberay \
  --release-train "$RELEASE_TRAIN" \
  --output table

Bekräfta att en kompatibel version returneras. Om ingen returneras kan du läsa Felsöka versionsidentifiering av tillägg.

Skapa tillägget med automatiska uppgraderingar aktiverade. Kommandot använder följande värden:

• --extension-type microsoft.kuberay installerar det hanterade KubeRay-tillägget.
• --scope cluster installerar tillägget för hela klustret.
• --release-namespace kuberay-system anger namnområdet för kuberay-operator-driftsättningen.
• --release-train "$RELEASE_TRAIN" väljer preview release train.
• --auto-upgrade-minor-version true möjliggör automatiska uppgraderingar. Ange --version inte med den här inställningen.

az k8s-extension create \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$CLUSTER_NAME" \
  --cluster-type managedClusters \
  --name "$EXTENSION_NAME" \
  --extension-type microsoft.kuberay \
  --scope cluster \
  --release-namespace kuberay-system \
  --release-train "$RELEASE_TRAIN" \
  --auto-upgrade-minor-version true

Verifiera tilläggsinstallationen

Kontrollera den installerade versionen och etableringstillståndet:

az k8s-extension show \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$CLUSTER_NAME" \
  --cluster-type managedClusters \
  --name "$EXTENSION_NAME" \
  --query "{name:name,version:currentVersion,provisioningState:provisioningState,extensionState:extensionState}" \
  --output table

Installationen kan ta upp till 15 minuter. Vänta tills kommandoutdata visar följande värden och kontrollera sedan att operator-distributionen är tillgänglig och att Ray CRD:erna är installerade:

• provisioningState är Succeeded.
• extensionState är Available eller Ready.

kubectl wait \
  --for=condition=Available \
  deployment/kuberay-operator \
  --namespace kuberay-system \
  --timeout=5m

kubectl get crds \
  rayclusters.ray.io \
  raycronjobs.ray.io \
  rayjobs.ray.io \
  rayservices.ray.io \
  --output name

Om etablerings- eller beredskapskontroller misslyckas kan du läsa Felsöka det hanterade KubeRay-tillägget.

Kör en Ray-exempelarbetsbelastning

Distribuera enbart CPU RayJob och skicka in en RayCluster för att bekräfta att KubeRay-operatorn kan stämma av Ray-resurser och köra distribuerade uppgifter. Exemplet använder en head pod och en worker pod.

Ange exempelresursnamnen och Ray-bilden:

RAY_NAMESPACE="kuberay-sample"
RAY_CLUSTER_NAME="sample-raycluster"
RAY_JOB_NAME="sample-rayjob"
RAY_VERSION="2.58.0"
RAY_IMAGE="mcr.microsoft.com/aks/ai-runtime/ray@sha256:e9a329eef15e5a13d50c3186c2b8036cd3728c6e218da860de23e8494b99ddd3"

Skapa ett namnområde och driftsätt RayCluster:

kubectl create namespace "$RAY_NAMESPACE"

kubectl apply -f - <<YAML
apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: ${RAY_CLUSTER_NAME}
  namespace: ${RAY_NAMESPACE}
spec:
  rayVersion: "${RAY_VERSION}"
  headGroupSpec:
    rayStartParams:
      num-cpus: "0"
      dashboard-host: "0.0.0.0"
    template:
      spec:
        containers:
        - name: ray-head
          image: ${RAY_IMAGE}
          resources:
            requests:
              cpu: 500m
              memory: 2Gi
            limits:
              cpu: "1"
              memory: 4Gi
  workerGroupSpecs:
  - groupName: cpu-workers
    replicas: 1
    minReplicas: 1
    maxReplicas: 1
    rayStartParams:
      num-cpus: "1"
    template:
      spec:
        containers:
        - name: ray-worker
          image: ${RAY_IMAGE}
          resources:
            requests:
              cpu: 500m
              memory: 1Gi
            limits:
              cpu: "1"
              memory: 2Gi
YAML

Vänta tills RayCluster rapporterar ready, och bekräfta sedan att huvud- och arbetspoddarna körs:

kubectl wait \
  --for=jsonpath='{.status.state}'=ready \
  raycluster/"$RAY_CLUSTER_NAME" \
  --namespace "$RAY_NAMESPACE" \
  --timeout=10m

kubectl get raycluster,pods --namespace "$RAY_NAMESPACE"

Skicka en HTTP-begäran RayJob till det befintliga klustret. Jobbet kör fyra fjärruppgifter på workern och skriver ut en lyckad markör när resultatet har verifierats:

kubectl apply -f - <<YAML
apiVersion: ray.io/v1
kind: RayJob
metadata:
  name: ${RAY_JOB_NAME}
  namespace: ${RAY_NAMESPACE}
spec:
  jobId: ${RAY_JOB_NAME}
  submissionMode: HTTPMode
  clusterSelector:
    ray.io/cluster: ${RAY_CLUSTER_NAME}
  entrypoint: >-
    python3 -c "import ray; ray.init(address='auto'); square=ray.remote(lambda x: x*x);
    values=ray.get([square.remote(i) for i in range(4)]);
    assert values == [0, 1, 4, 9], values;
    print('KUBERAY_SAMPLE_OK', values, flush=True)"
  shutdownAfterJobFinishes: false
YAML

Vänta tills jobbet har slutförts:

kubectl wait \
  --for=jsonpath='{.status.jobStatus}'=SUCCEEDED \
  rayjob/"$RAY_JOB_NAME" \
  --namespace "$RAY_NAMESPACE" \
  --timeout=10m

Läs Ray-driverloggen från huvudpodden:

HEAD_POD="$(kubectl get pods \
  --namespace "$RAY_NAMESPACE" \
  --selector="ray.io/cluster=$RAY_CLUSTER_NAME,ray.io/node-type=head" \
  --output jsonpath='{.items[0].metadata.name}')"

kubectl exec \
  --namespace "$RAY_NAMESPACE" \
  "$HEAD_POD" \
  --container ray-head \
  -- sh -c 'grep -h "KUBERAY_SAMPLE_OK" /tmp/ray/session_latest/logs/job-driver-*.log'

Förväntade utdata är:

KUBERAY_SAMPLE_OK [0, 1, 4, 9]

Det här utdata bekräftar att operatorn skapade Ray-klustret, skickade jobbet och körde uppgifter på arbetaren. Ta bort exempelresurserna när du är klar:

kubectl delete namespace "$RAY_NAMESPACE"

Uppdatera det hanterade KubeRay-tillägget

Använd az k8s-extension extension-types list-versions-by-cluster kommandot i Installera det hanterade KubeRay-tillägget för att kontrollera vilka versioner som är tillgängliga för klustret.

I samma skalsession, eller efter att du omdefinierat RESOURCE_GROUP, CLUSTER_NAME, EXTENSION_NAME och RELEASE_TRAIN enligt beskrivningen i Förbered din miljö, aktiverar du automatiska uppgraderingar för ett befintligt tillägg:

az k8s-extension update \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$CLUSTER_NAME" \
  --cluster-type managedClusters \
  --name "$EXTENSION_NAME" \
  --release-train "$RELEASE_TRAIN" \
  --auto-upgrade-minor-version true \
  --yes

Ange --version inte när automatiska uppgraderingar är aktiverade. Efter uppdateringen upprepa verifieringsstegen och bekräfta den installerade versionen.

Avinstallera det hanterade KubeRay-tillägget

Innan du tar bort det hanterade KubeRay-tillägget kontrollerar du att RESOURCE_GROUP, CLUSTER_NAME och EXTENSION_NAME fortfarande är inställda enligt beskrivningen i Förbered din miljö. Granska sedan befintliga Ray-resurser:

kubectl get rayclusters,raycronjobs,rayjobs,rayservices --all-namespaces

• Pausa schemalagda jobb, låt jobb som körs slutföras och bevara nödvändiga data och manifest.
• Om du vill ta bort Ray-arbetsbelastningar tar du bort dem medan operatorn fortfarande körs så att den kan slutföra rensningen.

Ta bort tilläggsinstansen:

az k8s-extension delete \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$CLUSTER_NAME" \
  --cluster-type managedClusters \
  --name "$EXTENSION_NAME" \
  --yes

Bekräfta att kuberay tillägget inte längre visas i tilläggslistan och att distributionen kuberay-operator tas bort:

az k8s-extension list \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$CLUSTER_NAME" \
  --cluster-type managedClusters \
  --output table

kubectl get deployments --namespace kuberay-system

Nästa steg

• Felsöka det hanterade KubeRay-tillägget på AKS.
• Kör Ray AI-arbetsbelastningar med Kueue på AKS.