Zainstaluj zarządzane rozszerzenie KubeRay w Azure Kubernetes Service (AKS) (wersja zapoznawcza)

Zarządzane rozszerzenie KubeRay dla Azure Kubernetes Service (AKS) jest dostępne w wersji zapoznawczej. Instaluje operator KubeRay i niestandardowe definicje zasobów Ray (CRD) w Twoim klastrze oraz zarządza nimi: RayCluster, RayJob, RayCronJob, i RayService.

W tym artykule pokazano, jak zainstalować, zweryfikować, zaktualizować i usunąć rozszerzenie przy użyciu Azure CLI. Wdrożysz również przykładowe obciążenie Ray, aby potwierdzić, że operator zarządza zasobami Ray zgodnie z oczekiwaniami.

Prerequisites

• Subskrypcja Azure i klaster usługi AKS, który uruchamia Kubernetes 1.34 lub nowszy i korzysta z tożsamości zarządzanej w obsługiwanym przez usługę AKS regionie publicznej chmury Azure. Jeśli nie masz klastra, zobacz Tworzenie klastra usługi AKS przy użyciu Azure CLI.
• Bieżąca wersja Azure CLI.
• k8s-extension Rozszerzenie Azure CLI w wersji 1.8.0 lub nowszej.
• kubectl zgodny z wersją Kubernetes Twojego klastra.
• Uprawnienia do rejestrowania dostawców zasobów platformy Azure, zarządzania rozszerzeniami klastra, pobierania poświadczeń klastra i inspekcji zasobów platformy Kubernetes.

Limitations

• Istniejące instalacje oprogramowania typu open source (OSS) KubeRay:Odinstaluj istniejącego własnego operatora KubeRay przed zainstalowaniem zarządzanego rozszerzenia KubeRay (microsoft.kuberay). Odrzucona instalacja nadal może zmienić schematy i własność Ray CRD, a usunięcie nieudanego rozszerzenia nie spowoduje cofnięcia tych zmian. Zachowaj CRD-y i zasoby obciążeń. Jeśli instalacja już się nie powiodła, przed ponowieniem próby postępuj zgodnie z wskazówkami dotyczącymi odzyskiwania.

Przygotowywanie środowiska

W poniższych przykładach użyto powłoki Bash. Ustaw subskrypcję i istniejące szczegóły klastra, a następnie zaloguj się:

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"

Sprawdź wersję klastra Kubernetes. Przed kontynuowaniem upewnij się, że zwrócona wersja to 1.34 lub nowsza:

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

Połącz się z klastrem:

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

Zainstaluj lub zaktualizuj rozszerzenie CLI i zarejestruj wymaganych dostawców zasobów:

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

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

Sprawdź zainstalowaną wersję rozszerzenia interfejsu wiersza polecenia:

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

Instalowanie rozszerzenia interfejsu wiersza polecenia zapewnia polecenia zarządzania; nie instaluje rozwiązania KubeRay w klastrze.

Odinstaluj istniejący operator OSS KubeRay

Pomiń ten krok, jeśli nie masz samodzielnie hostowanego operatora. W przeciwnym razie wykonaj kopię zapasową danych obciążeń i manifestów, wstrzymaj harmonogramy RayCronJob i poczekaj na zakończenie uruchomionych zadań przed usunięciem operatora.

W przypadku instalacji programu Helm znajdź nazwę wydania i przestrzeń nazw:

helm list --all-namespaces

Usuń tylko wydanie operatora i upewnij się, że jego wdrożenie zostało usunięte:

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"

Sprawdź, czy zachowana przestrzeń nazw pokazuje Active, a każdy zachowany element CRD *.ray.io pokazuje True w kolumnie ESTABLISHED:

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

Jeśli przestrzeń nazw jest zamykana lub Ray CRD nie został ustanowiony, rozwiąż problem przed włączeniem rozszerzenia.

W przypadku innych metod instalacji należy użyć właściwej dla nich procedury usuwania. Zachowaj zasoby CRD Ray i zasoby obciążeń; nie usuwaj ich przestrzeni nazw ani zasobów CRD.

Instalowanie zarządzanego rozszerzenia KubeRay

Wyświetl listę wersji rozszerzeń dostępnych dla klastra i gałęzi wydań 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

Upewnij się, że jest zwracana kompatybilna wersja. Jeśli nic nie zostanie zwrócone, zobacz Rozwiązywanie problemów z odnajdywaniem wersji rozszerzenia.

Utwórz rozszerzenie z włączonymi automatycznymi uaktualnieniami. Polecenie używa następujących wartości:

• --extension-type microsoft.kuberay instaluje zarządzane rozszerzenie KubeRay.
• --scope cluster instaluje rozszerzenie dla całego klastra.
• --release-namespace kuberay-system ustawia przestrzeń nazw wdrożenia kuberay-operator.
• --release-train "$RELEASE_TRAIN" wybiera gałąź wydawniczą preview.
• --auto-upgrade-minor-version true umożliwia automatyczne uaktualnianie. Nie określaj --version przy użyciu tego ustawienia.

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

Sprawdź instalację rozszerzenia

Sprawdź zainstalowaną wersję i stan aprowizacji:

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

Instalacja może potrwać do 15 minut. Zaczekaj, aż dane wyjściowe polecenia pokażą następujące wartości, a następnie sprawdź, czy wdrożenie operatora jest dostępne, a zasoby CRD Ray są zainstalowane:

• Parametr provisioningState ma wartość Succeeded.
• extensionState jest Available lub 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

Jeśli sprawdzanie aprowizacji lub gotowości nie powiedzie się, zobacz Rozwiązywanie problemów z zarządzanym rozszerzeniem KubeRay.

Uruchom przykładowe obciążenie Ray

Wdróż zasób tylko z procesorem CPU RayCluster i prześlij RayJob, aby potwierdzić, że operator KubeRay może zsynchronizować stan zasobów Ray i uruchomić rozproszone zadania. W przykładzie użyto jednego head poda i jednego worker poda.

Ustaw przykładowe nazwy zasobów i obraz Ray:

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"

Utwórz przestrzeń nazw i wdrożenie 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

Poczekaj, aż RayCluster zgłosi ready, a następnie upewnij się, że zasobniki głównego i roboczego są uruchomione:

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

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

Prześlij RayJob w trybie HTTP do istniejącego klastra. Zadanie uruchamia cztery zadania zdalne na workerze i wyświetla znacznik powodzenia po zweryfikowaniu wyników:

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

Poczekaj na pomyślne zakończenie zadania:

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

Przeczytaj dziennik sterownika Ray z poda nadrzędnego:

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'

Oczekiwane dane wyjściowe to:

KUBERAY_SAMPLE_OK [0, 1, 4, 9]

Te dane wyjściowe potwierdzają, że operator utworzył klaster Ray, przesłał zadanie i uruchomił zadania na workerze. Po zakończeniu usuń przykładowe zasoby:

kubectl delete namespace "$RAY_NAMESPACE"

Aktualizowanie zarządzanego rozszerzenia KubeRay

Użyj polecenia az k8s-extension extension-types list-versions-by-cluster w temacie Instalowanie zarządzanego rozszerzenia KubeRay, aby sprawdzić, które wersje są dostępne dla klastra.

W tej samej sesji powłoki lub po ponownym zdefiniowaniu RESOURCE_GROUP, CLUSTER_NAME, EXTENSION_NAME i RELEASE_TRAIN zgodnie z opisem w sekcji Przygotowywanie środowiska włącz automatyczne uaktualnienia dla istniejącego rozszerzenia:

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

Nie określaj --version , kiedy są włączone automatyczne uaktualnienia. Po aktualizacji powtórz kroki weryfikacji i potwierdź zainstalowaną wersję.

Odinstaluj zarządzane rozszerzenie KubeRay

Przed usunięciem zarządzanego rozszerzenia KubeRay upewnij się RESOURCE_GROUP, że wartości CLUSTER_NAME i EXTENSION_NAME są nadal ustawione zgodnie z opisem w temacie Przygotowywanie środowiska. Następnie przejrzyj istniejące zasoby Ray:

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

• Wstrzymaj zaplanowane zadania, pozwól na zakończenie uruchomionych zadań i zachowaj wymagane dane i manifesty.
• Jeśli chcesz usunąć zadania robocze Ray, usuń je, gdy operator jest nadal uruchomiony, aby mógł dokończyć czyszczenie.

Usuń wystąpienie rozszerzenia:

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

Upewnij się, że kuberay rozszerzenie nie jest już wyświetlane na liście rozszerzeń i że kuberay-operator wdrożenie zostało usunięte:

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

kubectl get deployments --namespace kuberay-system

Następne kroki

• Rozwiązywanie problemów z zarządzanym rozszerzeniem KubeRay w usłudze AKS.
• Uruchamianie obciążeń ray AI za pomocą usługi Kueue w usłudze AKS.