Commencez avec l’accélérateur distribué pour le stockage cloud sur AKS (aperçu)

Ce démarrage rapide permet un accélérateur distribué pour le stockage cloud (DACS) via son extension gérée sur un cluster existant d’Azure Kubernetes Service (AKS), accorde un accès en lecture à un conteneur Azure Blob, et vérifie que les lectures répétées utilisent le cache. L’exemple de charge de travail utilise le package public dacs-client==0.1.0.

Important

L’accélérateur distribué pour le stockage cloud est disponible en version préliminaire. Les fonctionnalités en préversion sont fournies sans contrat de niveau de service et ne sont pas recommandées pour les charges de travail de production. Pour plus d’informations, consultez Conditions d'utilisation supplémentaires pour les versions préliminaires de Microsoft Azure.

Prerequisites

Avant de commencer, vous avez besoin des éléments suivants :

  • Un abonnement Azure.
  • Un cluster AKS existant qui répond aux exigences de support de la prévisualisation DACS.
  • Un pool de nœuds de cache Linux avec des disques de données NVMe locaux, comme la Standard_L*s_v3 famille VM.
  • Un compte stockage Azure et un conteneur Blob contenant des données de modèles représentatives.
  • Un shell Bash avec Azure CLI, kubectl et Docker ou un autre outil de génération d’images de conteneur. Exécutez les commandes de ce démarrage rapide dans la même session shell afin que les variables restent disponibles.
  • Permission d’installer des extensions AKS, d’administrer les ressources Kubernetes, de mettre à jour les étiquettes du pool de nœuds et d’attribuer le rôle d’accès aux données de stockage utilisé dans ce démarrage rapide.
  • Une image de charge de travail avec Python 3.8 ou plus récent, et glibc 2.35 ou plus récent. Ce démarrage rapide utilise python:3.12-slim-bookworm et le package PyPI dacs-client==0.1.0 sur des nœuds x64.

Distributed Accelerator for Cloud Storage n’utilise pas le pool de nœuds de cache comme stockage persistant. Stockage Blob Azure reste la source de vérité.

Prérequis de prise en charge de la version préliminaire de DACS

Requirement Prise en charge de la version préliminaire de DACS
Régions Azure Toutes les régions de cloud public Azure.
Versions de Kubernetes AKS Version 1.35 ou ultérieure.

Définir des variables

Remplacez les valeurs de placeholder, puis exécutez les commandes suivantes :

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

Vérifier l’extension en version préliminaire d’AKS

L’aperçu du DACS nécessite aks-preview une version 22.0.0b9 ou une version ultérieure. Installez ou mettez à jour l’extension ainsi que celles utilisées pour gérer et inspecter les DACS :

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

Vous n'avez pas besoin de connecter le cluster AKS à Azure Arc. Si vous avez déjà installé un contrôleur DACS manuellement, suivez Préparez-vous aux mises à jour avant de passer à l'extension gérée. Ne faites pas tourner deux contrôleurs DACS sur le même cluster.

Vérifier le pool de nœuds cache

Confirmez que le pool de nœuds sélectionné utilise Linux et une taille de VM avec des disques de données NVMe locaux :

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

Pour un accélérateur distribué pour le stockage cloud, utilisez un pool de nœuds de cache dédié ou confirmez que d’autres logiciels ne revendiquent pas ou ne formatent pas les mêmes disques NVMe locaux.

Étiquetez le pool de nœuds de cache au niveau du pool de nœuds afin que l’étiquette survive au remplacement des nœuds. Si le pool a déjà des étiquettes personnalisées, incluez-les dans la mise à jour pour les préserver :

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

Caution

L’activation du DACS installe un DaemonSet préalable qui découvre, formate et monte les disques NVMe locaux sur des nœuds de cache étiquetés. Étiquetez uniquement les nœuds dont les disques sont dédiés au cache.

Activez l’accélérateur distribué pour le stockage cloud

Activez le DACS en passant distributedAccelerator seul. La majuscule A est requise :

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

La commande installe l’extension distributedaccelerator gérée, le contrôleur DACS et le prérequis NVMe DaemonSet dans kube-system, ainsi que la définition de ressource personnalisée caches.storage.azure.com (CRD). Vous n’installez pas un chart de prérequis séparé et ne gérez pas vous-même la release Helm de l’extension. Créez une ressource de cache séparément comme montré plus loin.

Vérifier l’extension

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

Confirmez que le type d’extension est microsoft.distributedaccelerator et que l’état de provisionnement est Succeeded. La version serveur installée est rapportée par currentVersion; ne l’inférez pas à partir de la version du package client ou d’une balise image publique.

Enregistrez cette version pour dépannage, puis vérifiez le contrôleur et le CRD :

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

Poursuivez uniquement lorsque l’extension est à l’état Succeeded et que le contrôleur est prêt. En cas d’échec de l’installation ou des vérifications de disponibilité, consultez Résoudre les problèmes liés à l’accélérateur distribué pour le stockage cloud.

Provisionner le cache

Vérifier la préparation locale du NVMe

L’extension gérée prépare les disques NVMe locaux via son DaemonSet prérequis. Ne déployez pas de workload de configuration de disque en double et n’installez pas un autre chart de prérequis.

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

Confirmez que le DaemonSet possède un pod Prêt sur chaque nœud de cache identifié. Le point de montage est /var/lib/ssd/cacheserver et doit correspondre à la valeur spec.storage.hostPath.nodeCacheFolderPath de la ressource Cache. Si le DaemonSet est absent ou n’est pas prêt, arrêtez la procédure et vérifiez la version de l’extension ainsi que les événements des pods prérequis, au lieu d’installer un graphique distinct.

Créez un espace de noms dédié au cache et à la charge de travail de test :

kubectl create namespace "$CACHE_NAMESPACE"

Créer la ressource Cache

Créez la ressource Cache. L’exemple configure trois serveurs cache, avec un serveur par nœud NVMe étiqueté, et nécessite au moins trois nœuds éligibles. Ajustez le nombre de serveurs, la taille du cache, le processeur (CPU) et la mémoire en fonction de votre pool de nœuds.

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

Vérifier que le cache est prêt

Attendez la ressource Cache nommée plutôt que de sélectionner le premier cache dans le cluster :

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

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

Vérifiez que le nombre actuel de serveurs de cache correspond au nombre souhaité et que chaque pod de serveur de cache s’exécute sur un nœud NVMe.

Obtenez le nom d’hôte de découverte utilisé par les clients de workload :

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

echo $CACHE_DISCOVERY_URL

Accorder un accès à la lecture des données du modèle

Ce démarrage rapide utilise l’identité managée du kubelet AKS. Obtenez son ID d’objet et l’ID de ressource du compte de stockage :

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)

Attribuez le rôle de lecture disposant des privilèges minimaux requis au niveau du conteneur :

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"

Les attributions de rôles peuvent prendre plusieurs minutes à se propager. Pour utiliser l’identité de kubelet, définissez les trois variables d’identité managée indiquées dans la spécification du pod : AZURE_CLIENT_ID, MSI_ENDPOINT et une valeur non vide pour MSI_SECRET. Définir uniquement AZURE_CLIENT_ID n’est pas suffisant pour cette configuration client.

Ajouter le client à une image de charge de travail

Créez un fichier nommé Dockerfile dans votre répertoire de construction avec le contenu suivant. Le nom de la distribution est dacs-client, et l’espace de noms d’importation Python est py_dacs_client:

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

Générez l’image, puis envoyez-la vers un registre accessible à votre cluster AKS. Pour Azure Container Registry (ACR), connectez-vous avant de pousser et assurez-vous que l’identité kubelet dispose de l’autorisation de tirer des images. Si vous utilisez un registre configuré avec les autorisations RBAC du registre, attribuez le rôle AcrPull au niveau du registre. Pour un registre compatible ABAC, utilisez plutôt le rôle repository-reader approprié. Pour plus de détails, voir S’authentifier auprès d’Azure Container Registry à partir d’Azure Kubernetes Service.

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

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

Déploie un test en lecture seule

Choisissez un blob de modèle existant et définissez son chemin :

MODEL_BLOB=<path-to-model-blob>

Créez un pod de test. Le pod lit jusqu’à 4 Mio à partir de l’objet blob cinq fois, avec un intervalle d’une seconde entre les lectures, et vérifie que toutes les lectures restituent la même somme de contrôle SHA-256. Le remplissage du cache étant asynchrone, une deuxième lecture effectuée immédiatement après la première peut ne pas bénéficier du cache. Les intervalles permettent aux chargements en arrière-plan de se terminer. Utilisez les métriques du client et les compteurs du serveur pour confirmer les accès au cache, plutôt que de supposer qu'une lecture donnée bénéficie nécessairement du cache. Pour comparer les compteurs du serveur, capturez une valeur de référence avant de créer le pod, en suivant les instructions de la section Vérifier le chemin des requêtes DACS.

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"

Vérifiez le chemin de requête DACS

Une lecture réussie ou une seconde lecture plus rapide ne prouve pas que la requête a atteint le DACS, car le client peut revenir à Stockage Blob Azure. Définissez à la fois CACHE_DISCOVERY_URL et CACHE_SERVER_PORT. Si l’un d’eux manque, le client enregistre Cache not configured. Working in Remote Blob mode only.

Inspectez les journaux de pod pour les métriques cache_client_download_cache_hits d’arrêt client et cache_client_download_cache_misses. Un compteur d’accès au cache supérieur à zéro indique qu’une requête a été traitée à partir du cache. Les compteurs clients peuvent inclure des requêtes internes et ne correspondent pas nécessairement au nombre de lectures d’applications.

Comparez aussi les compteurs de requêtes du serveur cache avant et après le test. Vérifiez chaque pod cache-serveur car la requête peut être traitée par n’importe quel serveur, pas nécessairement par le premier pod. Pour inspecter un serveur :

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

Dans un autre terminal, récupérez les métriques et inspectez le compteur de requêtes :

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

Confirmez une augmentation des demandes de téléchargement avec request_type="Download" et status="Success", et non seulement la présence d’une série de compteurs, qui peut exister à zéro. Les valeurs des étiquettes sont sensibles à la casse. Arrêtez le transfert de port et répétez pour les autres pods de serveur cache si besoin. Corrélez les métriques d’accès au cache client avec les compteurs serveur et la télémétrie Azure Blob pour distinguer les accès réussis au cache, le trafic d’origine et le comportement de secours.

Pour la référence complète des métriques et de la configuration de collecte, voir Surveiller l’accélérateur distribué pour le stockage cloud.

Nettoyer l’environnement de test

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

Si vous n’avez plus besoin du cache, supprimez la ressource Cache pendant que le contrôleur tourne :

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

Supprimez l’espace de noms uniquement s’il était dédié à ce guide de démarrage rapide et ne contient aucune ressource à conserver :

kubectl delete namespace "$CACHE_NAMESPACE"

Après avoir supprimé toutes les ressources de cache et les charges de travail dépendantes, désactivez l’extension gérée :

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

Désactiver le DACS supprime son extension gérée, son contrôleur et son DaemonSet préalable mais conserve le CRD du cache. Ne supprimez pas séparément les prérequis gérés, ne désinstallez pas directement la version Helm de l’extension, ni ne supprimez manuellement le CRD. Ne supprimez aucune attribution de rôle ni aucune étiquette de pool de nœuds ajoutée uniquement pour ce guide de démarrage rapide avant d’avoir vérifié qu’aucune autre charge de travail n’en dépend.

Pour plus d’informations, voir Supprimer l’accélérateur distribué pour le stockage cloud.

Étapes suivantes