AKS'te bulut depolama için dağıtılmış hızlandırıcıyı kullanmaya başlayın (önizleme)

Bu hızlı başlatma, mevcut Azure Kubernetes Service (AKS) kümesinde yönetilen uzantısı aracılığıyla bulut depolama için dağıtılmış hızlandırıcı (DACS) etkinleştirir, Azure Blob konteynerine okuma erişimi tanır ve tekrarlanan okumaların önbelleği kullandığını doğrular. İş yükü örneği public dacs-client==0.1.0 paketi kullanır.

Important

Bulut depolama için dağıtık hızlandırıcı önizleme aşamasında. Önizleme özellikleri hizmet düzeyi sözleşmesi olmadan sağlanır ve üretim iş yükleri için önerilmez. Daha fazla bilgi için bkz. Microsoft Azure Önizlemeleri için Ek Kullanım Koşulları.

Prerequisites

Başlamadan önce şunları yapmanız gerekir:

• Azure aboneliği.
• DACS önizleme destek gereksinimlerini karşılayan mevcut bir AKS kümesi.
• VM ailesi gibi yerel NVMe veri disklerine Standard_L*s_v3 sahip bir Linux önbellek düğüm havuzu.
• Temsilci model verilerini içeren Azure Depolama hesabı ve Blob konteyneri.
• Azure CLI'lı bir Bash shell, kubectl, ve Docker ya da başka bir konteyner-imajı oluşturma aracı. Bu hızlı başlatmadaki komutları aynı shell oturumunda çalıştırın ki değişkenler kullanılabilir kalsın.
• AKS uzantılarını yükleme, Kubernetes kaynaklarını yönetme, düğüm havuzu etiketlerini güncelleme ve bu hızlı başlatmada kullanılan depolama veri erişim rolünü atama izni.
• Python 3.8 veya daha yeni ve glibc 2.35 veya daha yeni bir iş yükü imajı. Bu hızlı başlatma x64 düğümlerinde PyPI paketini dacs-client==0.1.0 kullanıyorpython:3.12-slim-bookworm.

Bulut depolama için dağıtık hızlandırıcı, önbellek düğüm havuzunu kalıcı depolama olarak kullanmaz. Azure Blob Depolama gerçeğin kaynağı olarak kalıyor.

DACS önizleme destek gereksinimleri

Requirement	DACS önizleme desteği
Azure bölgeleri	Tüm Azure genel bulut bölgeleri.
AKS Kubernetes versiyonları	1.35 veya daha sonra.

Değişkenleri ayarla

Yer tutucu değerleri değiştirin ve ardından aşağıdaki komutları çalıştırın:

SUBSCRIPTION_ID=<subscription-id>
RESOURCE_GROUP=<resource-group>
CLUSTER_NAME=<aks-cluster-name>
CACHE_NODE_POOL=<nvme-node-pool>
STORAGE_ACCOUNT=<storage-account-name>
STORAGE_CONTAINER=<blob-container-name>
CACHE_NAMESPACE=dacs-cache-system
CACHE_NAME=cache-sample

az account set --subscription $SUBSCRIPTION_ID
az aks get-credentials \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME

AKS önizleme uzatmasını sağlamak

DACS önizleme için 22.0.0b9 sürüm aks-preview veya daha yenisi gereklidir. Uzantıyı ve DACS'i yönetmek ve incelemek için kullanılan uzantıları kurun veya yükseltin:

az extension add --name aks-preview --upgrade --yes
az extension show --name aks-preview --query version --output tsv
az extension add --name connectedk8s --upgrade --yes
az extension add --name k8s-extension --upgrade --yes

AKS kümesini Azure Arc'e bağlamanız gerekmez. Zaten bir DACS denetleyicisini el ile yüklediyseniz, yönetilen uzantıya geçmeden önce Yükseltmelere hazırlanma bölümündeki adımları izleyin. Aynı kümede iki DACS kontrolcüsü çalıştırmayın.

Önbellek düğüm havuzunu doğrulayın

Seçilen düğüm havuzunun Linux ve yerel NVMe veri diskleriyle VM boyutu kullandığını doğrulayın:

az aks nodepool show \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name $CACHE_NODE_POOL \
  --query '{osType:osType,vmSize:vmSize,count:count,powerState:powerState.code}' \
  --output table

Bulut depolama için dağıtık hızlandırıcıda, özel bir önbellek düğüm havuzu kullanın veya diğer yazılımların aynı yerel NVMe diskleri kullanmadığını ya da biçimlendirmediğini doğrulayın.

Etiketin düğümün değiştirilmesinden sonra da kalıcı olması için önbellek düğüm havuzunu düğüm havuzu düzeyinde etiketleyin. Havuzda zaten özel etiketler varsa, bunları korumak için güncellemeye dahil edin:

az aks nodepool update \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name $CACHE_NODE_POOL \
  --labels dacs.azure.com/processing-unit=cpu

Caution

DACS'in etkinleştirilmesi, yerel NVMe diskleri bulan, biçimlendiren ve etiketli önbellek düğümlerinde bağlayan bir önkoşul DaemonSet’i kurar. Sadece önbelleğe ayrılmış disklere sahip düğümleri etiketleyin.

Bulut depolama için dağıtık hızlandırıcıyı etkinleştirin

distributedAccelerator öğesini tek başına geçirerek DACS'i etkinleştirin. Büyük harf A gereklidir:

az aks update \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --enable-azure-container-storage distributedAccelerator

Komut, distributedaccelerator yönetilen uzantıyı, DACS denetleyicisini ve kube-system içinde NVMe ön koşulu DaemonSet'ini ve caches.storage.azure.com özel kaynak tanımını (CRD) yükler. Ayrı bir prerequisite chart yüklemez veya uzantının Helm release’ini kendiniz yönetmezsiniz. Daha sonra gösterildiği gibi ayrı bir Önbellek kaynağı oluşturun.

Uzantıyı doğrulama

az k8s-extension show \
  --cluster-type managedClusters \
  --cluster-name $CLUSTER_NAME \
  --resource-group $RESOURCE_GROUP \
  --name distributedaccelerator \
  --query '{extensionType:extensionType,provisioningState:provisioningState,currentVersion:currentVersion,releaseTrain:releaseTrain}' \
  --output table

Uzantı türünün microsoft.distributedaccelerator ve sağlama durumunun Succeeded olduğunu doğrulayın. Kurulu sunucu sürümü currentVersion tarafından bildirilir; bunu istemci paket sürümünden veya kamuya açık bir görüntü etiketinden çıkarmayın.

Bu sürümü sorun giderme için kaydedin, sonra kontrolcü ve CRD'yi doğrulayın:

DACS_VERSION=$(az k8s-extension show \
  --cluster-type managedClusters \
  --cluster-name $CLUSTER_NAME \
  --resource-group $RESOURCE_GROUP \
  --name distributedaccelerator \
  --query currentVersion --output tsv)

echo "$DACS_VERSION"
kubectl rollout status deployment/dacs-manager --namespace kube-system --timeout=5m
kubectl get crd caches.storage.azure.com

Sadece uzantı Succeeded durumundayken ve kontrolcü hazır olduktan sonra devam edin. Kurulum veya hazırlık kontrolleri başarısız olursa, Troubleshoot distributed accelerator for cloud storage sayfasına bakınız.

Önbelleği sağlayın

Yerel NVMe hazırlığını doğrulayın

Yönetilen uzantı, yerel NVMe disklerini önkoşul DaemonSet'i aracılığıyla hazırlar. Tekrarlayan bir disk kurulumu iş yükü dağıtmayın veya başka bir önkoşul chart’ı yüklemeyin.

kubectl rollout status daemonset/dacs-prereq \
  --namespace kube-system --timeout=10m

kubectl get daemonset dacs-prereq --namespace kube-system
kubectl get pods --namespace kube-system --selector app.kubernetes.io/name=dacs-prereq --output wide

DaemonSet'in her etiketlenmiş önbellek düğümünde bir Ready podu olduğunu doğrulayın. Bağlama noktası /var/lib/ssd/cacheserver'dır ve Cache kaynağının spec.storage.hostPath.nodeCacheFolderPath değeriyle eşleşmelidir. DaemonSet eksikse veya hazır değilse, ayrı bir chart yüklemek yerine durun ve uzantı sürümünü ve ön koşul pod olaylarını kontrol edin.

Önbellek için özel bir isim alanı oluşturun ve iş yükünü test edin:

kubectl create namespace "$CACHE_NAMESPACE"

Önbellek kaynağını oluştur

Önbellek kaynağını oluşturun. Örnek, her etiketli NVMe düğümü için bir sunucu olan üç önbellek sunucusunu yapılandırır ve en az üç uygun düğüm gerektirir. Sunucu sayısını, önbellek boyutunu, CPU'yu ve belleği düğüm havuzunuza göre ayarlayın.

cat <<EOF | kubectl apply -f -
apiVersion: storage.azure.com/v1
kind: Cache
metadata:
  name: $CACHE_NAME
  namespace: $CACHE_NAMESPACE
spec:
  scaling:
    static:
      numServers: 3
  serverSizeInGB: 1000
  serverThreads: 80
  cpuLimit: 4
  memoryLimitMB: 32000
  port: 9065
  metricsPort: 9096
  nodeSelectorKey: dacs.azure.com/processing-unit
  nodeSelectorValue: cpu
  storage:
    hostPath:
      nodeCacheFolderPath: /var/lib/ssd/cacheserver
EOF

Önbellek hazırlığını doğrulayın

Kümedeki ilk önbelleği seçmek yerine adlandırılmış Önbellek kaynağını bekleyin:

kubectl wait \
  --namespace $CACHE_NAMESPACE \
  --for=condition=Ready \
  cache/$CACHE_NAME \
  --timeout=10m

kubectl get cache,pods \
  --namespace $CACHE_NAMESPACE \
  --output wide

Mevcut ve istenen önbellek sunucusu sayılarının eşleşip eşleşmediğini ve her önbellek sunucusu podunun bir NVMe düğümünde çalıştığını doğrulayın.

İş yükü istemcilerinin kullandığı keşif ana bilgisayar adını alın:

CACHE_DISCOVERY_URL=$(kubectl get cache $CACHE_NAME \
  --namespace $CACHE_NAMESPACE \
  -o jsonpath='{.status.discoveryURL}')

echo $CACHE_DISCOVERY_URL

Model verilerine okuma erişimi verin

Bu hızlı başlangıç, AKS'in kubelet yönetilen kimliğini kullanır. Nesne ID'sini ve depolama hesabı kaynak kimliğini alın:

KUBELET_OBJECT_ID=$(az aks show \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --query identityProfile.kubeletidentity.objectId \
  --output tsv)

KUBELET_CLIENT_ID=$(az aks show \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --query identityProfile.kubeletidentity.clientId \
  --output tsv)

STORAGE_ID=$(az storage account show \
  --resource-group $RESOURCE_GROUP \
  --name $STORAGE_ACCOUNT \
  --query id \
  --output tsv)

Konteyner kapsamında en az ayrıcalıklı okuma rolünü atayın:

az role assignment create \
  --assignee-object-id $KUBELET_OBJECT_ID \
  --assignee-principal-type ServicePrincipal \
  --role "Storage Blob Data Reader" \
  --scope "$STORAGE_ID/blobServices/default/containers/$STORAGE_CONTAINER"

Rol atamalarının yayılması birkaç dakika sürebilir. Kubelet kimliğini kullanmak için, pod spesifikasyonunda gösterilen üç yönetilen kimlik değişkeninin tamamını ayarlayın: AZURE_CLIENT_ID, MSI_ENDPOINT ve boş olmayan MSI_SECRET. Bu istemci yapılandırması için yalnızca AZURE_CLIENT_ID ayarlamak yeterli değildir.

İstemciyi iş yükü imajına ekleyin

Aşağıdaki içerikle build dizininizde Dockerfile adlı bir dosya oluşturun. Dağıtım adı dacs-client'dır ve Python içe aktarma isim alanı py_dacs_client'dir:

FROM python:3.12-slim-bookworm
RUN python3 -m pip install --no-cache-dir "dacs-client==0.1.0"

İmajı oluşturun ve AKS kümenizin çekebileceği bir kayıt deposuna gönderin. Azure Container Registry (ACR) için, görüntüyü göndermeden önce giriş yapın ve kubelet kimliğinin imaj çekme erişimine sahip olduğundan emin olun. RBAC Kayıt Defteri İzinleri kullanan bir kayıt defteri için, kayıt defteri kapsamında AcrPull verin. ABAC özellikli bir kayıt deposu için, bunun yerine uygun depo okuyucusu rolünü kullanın. Detaylar için bkz. Azure Kubernetes Service'ten Azure Container Registry ile kimlik doğrulaması yapma.

WORKLOAD_IMAGE=<registry-name>.azurecr.io/dacs-test:0.1.0

docker build \
  --tag $WORKLOAD_IMAGE .
docker push $WORKLOAD_IMAGE

Salt okunur bir test oluştur

Mevcut bir model blob'unu seçin ve yolunu belirleyin:

MODEL_BLOB=<path-to-model-blob>

Bir test podu oluşturun. Pod, okumalar arasında bir saniyelik aralıkla blob'dan beş kez 4 MiB'ye kadar veri okur ve tüm okumaların aynı SHA-256 sağlama toplamını döndürdüğünü doğrular. Önbellek popülasyonu eşzamansızdır, bu yüzden hemen yapılan ikinci bir okuma önbelleği kaçırabilir. Bu aralıklar, arka plan yüklemelerinin tamamlanması için zaman tanır; belirli bir okumanın vuruş olduğunu varsaymak yerine önbellek vuruşlarını doğrulamak için istemci metriklerini ve sunucu sayaçlarını kullanın. Sunucu sayaçlarını karşılaştırmak için, pod oluşturmadan önce DACS istek yolunu doğrulama bölümünü izleyerek bir temel değer kaydedin.

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: dacs-test
  namespace: $CACHE_NAMESPACE
spec:
  restartPolicy: Never
  containers:
    - name: test
      image: $WORKLOAD_IMAGE
      env:
        - name: CACHE_DISCOVERY_URL
          value: "$CACHE_DISCOVERY_URL"
        - name: CACHE_SERVER_PORT
          value: "9065"
        - name: DACS_CPU_CORES
          value: "2"
        - name: DACS_MEMORY_MB
          value: "512"
        - name: AZURE_CLIENT_ID
          value: "$KUBELET_CLIENT_ID"
        - name: MSI_ENDPOINT
          value: "http://169.254.169.254/metadata/identity/oauth2/token"
        - name: MSI_SECRET
          value: "required-nonempty-value"
        - name: MODEL_PATH
          value: "az://$STORAGE_ACCOUNT.blob.core.windows.net/$STORAGE_CONTAINER/$MODEL_BLOB"
      command: ["python3", "-c"]
      resources:
        requests:
          cpu: "1"
          memory: 512Mi
        limits:
          cpu: "2"
          memory: 1Gi
      args:
        - |
          import asyncio
          import ctypes
          import hashlib
          import os
          import time

          from py_dacs_client.dacs_client import DACSCacheClient
          from py_dacs_client.dacs_utils import BoundedBufferManager

          async def main():
              path = os.environ["MODEL_PATH"]
              client = DACSCacheClient()
              buffers = BoundedBufferManager(max_memory_limit=64 * 1024 * 1024)
              try:
                  size = min(await client.get_file_size(path), 4 * 1024 * 1024)
                  if size == 0:
                      raise ValueError("Choose a nonempty model blob")
                  first_digest = None
                  for attempt in range(1, 6):
                      start = time.perf_counter()
                      buffer = await buffers.acquire_buffer(size)
                      try:
                          count = await client.read_blob(path, buffer, size, 0)
                          if count != size:
                              raise RuntimeError(f"Expected {size} bytes, received {count}")
                          digest = hashlib.sha256(ctypes.string_at(buffer, count)).hexdigest()
                          if first_digest is not None and digest != first_digest:
                              raise RuntimeError("Repeated reads returned different data")
                          first_digest = digest
                      finally:
                          await buffers.release_buffer(buffer)
                      elapsed = time.perf_counter() - start
                      print(f"read {attempt}: {count} bytes in {elapsed:.3f}s; sha256={digest}")
                      if attempt < 5:
                          await asyncio.sleep(1)
              finally:
                  await client.shutdown()

          asyncio.run(main())
EOF

kubectl wait \
  --namespace "$CACHE_NAMESPACE" \
  --for=jsonpath='{.status.phase}'=Succeeded \
  pod/dacs-test \
  --timeout=5m

kubectl logs dacs-test --namespace "$CACHE_NAMESPACE"

DACS istek yolunu doğrulayın

Başarılı bir okuma veya daha hızlı bir ikinci okuma tek başına isteğin DACS'e ulaştığının kanıtı değildir çünkü istemci Azure Blob Depolama'a geri dönebilir. Hem CACHE_DISCOVERY_URL hem de CACHE_SERVER_PORT ayarlayın. Herhangi biri eksikse, istemci Cache not configured. Working in Remote Blob mode only. günlüğe kaydeder

İstemci kapatma metrikleri cache_client_download_cache_hits ve cache_client_download_cache_misses için pod kayıtlarını inceleyin. Sıfır olmayan önbellek isabet sayısı, isteğin önbellekten karşılandığını gösterir. İstemci sayaçları dahili istekler içerebilir ve uygulama okuma sayısına eşit olmayabilir.

Ayrıca, testi çalıştırmadan önce ve sonra önbellek sunucusu istek sayaçlarını karşılaştırın. Her önbellek sunucusu podunu kontrol edin çünkü istek herhangi bir sunucu tarafından işlenebilir, mutlaka ilk pod değil. Bir sunucuyu incelemek için:

CACHE_POD=$(kubectl get pods \
  --namespace $CACHE_NAMESPACE \
  --selector app=cacheserver \
  -o jsonpath='{.items[0].metadata.name}')

kubectl port-forward \
  --namespace $CACHE_NAMESPACE \
  pod/$CACHE_POD 9096:9096

Başka bir terminalde metrikleri alın ve istek sayacı inceleyin:

curl --fail --silent --show-error http://localhost:9096/metrics > dacs-metrics.txt
grep '^cache_server_request_counter' dacs-metrics.txt

Yalnızca sıfır değerinde bulunabilen bir sayaç serisinin varlığını değil, request_type="Download" ve status="Success" ile indirme isteklerindeki artışı doğrulayın. Etiket değerleri büyük/küçük harfe duyarlıdır. Port yönlendirmesini durdurun ve gerektiğinde diğer önbellek sunucusu podları için tekrar yapın. İstemci önbellek vuruşu metriklerini sunucu sayaçları ve Azure Blob telemetrisiyle ilişkilendirerek önbellek hitlerini, kaynak trafiğini ve geri dönüş davranışını ayırt edin.

Tam metrik referans ve scrape yapılandırması için bkz. Bulut depolama için dağıtılmış hızlandırıcıyı izlemek.

Testi temizle

kubectl delete pod dacs-test --namespace "$CACHE_NAMESPACE"

Artık önbelleğe ihtiyacınız yoksa, kontrolcü çalışırken önbellek kaynağını silin:

kubectl delete cache "$CACHE_NAME" --namespace "$CACHE_NAMESPACE" --wait=true
kubectl get cache -A

Namespace'i sadece bu hızlı başlatmaya ayrılmışsa ve saklamanız gereken kaynak içermiyorsa silin:

kubectl delete namespace "$CACHE_NAMESPACE"

Tüm önbellek kaynakları ve bağımlı iş yükleri kaldırıldıktan sonra, yönetilen uzantıyı devre dışı bırakın:

az aks update \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --disable-azure-container-storage distributedAccelerator

DACS'in devre dışı bırakılması, yönetilen uzantı, denetleyici ve ön koşul DaemonSet'i kaldırır ancak Cache CRD'sini korur. Yönetilen ön koşulları ayrı ayrı silmeyin, uzantının Helm release’ini doğrudan kaldırın veya CRD'yi manuel olarak silmeyin. Sadece bu hızlı başlangıç için eklenen herhangi bir rol ataması veya düğüm havuzu etiketini, başka hiçbir iş yükünün buna ihtiyaç duymadığını doğruladıktan sonra kaldırın.

Daha fazla bilgi için, bulut depolama için dağıtık hızlandırıcıyı kaldır bölümünü inceleyebilirsiniz.

Sonraki Adımlar

• BlobFuse2 ile bulut depolama için dağıtık hızlandırıcı kullanın.
• Python istemcisiyle bulut depolama için dağıtık hızlandırıcı kullanın.
• Bulut depolama için dağıtık hızlandırmayı yönetin.
• Bulut depolama için dağıtık hızlandırıcıyı izleme.
• Bulut depolama için dağıtık hızlandırıcı sorunlarını giderin.