Intégrer Azure HPC Cache à Azure Kubernetes Service (AKS)

Article
02/19/2024

Azure HPC Cache accélère l’accès à vos données pour les tâches de calcul haute performance. En mettant les fichiers en cache dans Azure, Azure HPC Cache apporte la scalabilité du cloud computing à votre workflow existant. Cet article vous montre comment intégrer Azure HPC Cache à Azure Kubernetes Service (AKS).

Avant de commencer

Le cluster AKS doit se trouver dans une région qui prend en charge Azure HPC Cache.
Vous avez besoin d’Azure CLI version 2.7 ou ultérieure. Exécutez az --version pour trouver la version. Si vous devez installer ou mettre à niveau, voir Installer Azure CLI.
Inscrivez l’extension hpc-cache dans votre abonnement Azure. Pour plus d’informations sur l’utilisation de HPC Cache avec Azure CLI, consultez les prérequis de l’interface cli HPC Cache.
Examinez les Prérequis pour Azure HPC Cache. Vous devez satisfaire les conditions suivantes avant de pouvoir exécuter un cache HPC :
- Le cache nécessite un sous-réseau dédié avec au moins 64 adresses IP disponibles.
- Ce sous-réseau ne doit pas héberger d’autres machines virtuelles ou conteneurs.
- Ce sous-réseau doit être accessible à partir des nœuds AKS.
Si vous devez exécuter votre application en tant qu’utilisateur sans accès racine, vous devrez peut-être désactiver la courge racine à l’aide de la commande modifier le propriétaire (chown) pour modifier la propriété du répertoire en un autre utilisateur. L’utilisateur sans accès racine doit posséder un répertoire pour accéder au système de fichiers. Pour que l’utilisateur soit propriétaire d’un répertoire, l’utilisateur racine doit diriger un annuaire vers cet utilisateur, mais si le cache HPC Cache est à l’origine du root squash, cette opération est refusée car l’utilisateur racine (UID 0) est mappé à l’utilisateur anonyme. Pour plus d’informations sur l’écrasement racine et les stratégies d’accès client, consultez Stratégies d’accès HPC Cache.

Installer l’extension Azure CLI `hpc-cache`

Important

Les fonctionnalités d’évaluation AKS sont disponibles en libre-service et font l’objet d’un abonnement. Les préversions sont fournies « en l’état » et « en fonction des disponibilités », et sont exclues des contrats de niveau de service et de la garantie limitée. Les préversions AKS sont, dans la mesure du possible, partiellement couvertes par le service clientèle. Telles quelles, ces fonctionnalités ne sont pas destinées à une utilisation en production. Pour plus d’informations, consultez les articles de support suivants :

Pour installer l’extension hpc-cache, exécutez la commande suivante :

az extension add --name hpc-cache

Exécutez la commande suivante pour effectuer la mise à jour vers la dernière version de l’extension publiée :

az extension update --name hpc-cache

Inscrire l’indicateur de fonctionnalité StorageCache

Réinscrivez le fournisseur de ressources Microsoft.StorageCache avec la commande az provider register.

az provider register --namespace Microsoft.StorageCache --wait

Quelques minutes sont nécessaires pour que l’état s’affiche Registered (Inscrit). Vérifiez l’état de l’inscription à l’aide de la commande az feature show :

az feature show --namespace "Microsoft.StorageCache"

Monter le cache Azure HPC Cache

Obtenez le nom du groupe de ressources à l’aide de la commande az aks show avec le paramètre --query nodeResourceGroup.
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :
```
MC_myResourceGroup_myAKSCluster_eastus
```

Créez un sous-réseau HPC Cache dédié à l’aide de la commande az network vnet subnet create. Définissez d’abord les variables d’environnement pour RESOURCE_GROUP, VNET_NAME, VNET_IDet SUBNET_NAME. Copiez la sortie de l’étape précédente pour RESOURCE_GROUPet spécifiez une valeur pour SUBNET_NAME.

RESOURCE_GROUP=MC_myResourceGroup_myAKSCluster_eastus
VNET_NAME=$(az network vnet list --resource-group $RESOURCE_GROUP --query [].name -o tsv)
VNET_ID=$(az network vnet show --resource-group $RESOURCE_GROUP --name $VNET_NAME --query "id" -o tsv)
SUBNET_NAME=MyHpcCacheSubnet

az network vnet subnet create \
    --resource-group $RESOURCE_GROUP \
    --vnet-name $VNET_NAME \
    --name $SUBNET_NAME \
    --address-prefixes 10.0.0.0/26

Créez un cache HPC dans le même groupe de ressources et la même région de nœud. Commencez par définir la variable d’environnement SUBNET_ID.
```
SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
```
Créez le cache HPC à l’aide de la commande az hpc-cache create. L’exemple suivant crée le cache HPC dans la région USA Est avec un type de cache 2G Standard nommé MyHpcCache. Spécifiez une valeur pour --location, --sku-nameet --name.
```
az hpc-cache create \
  --resource-group $RESOURCE_GROUP \
  --cache-size-gb "3072" \
  --location eastus \
  --subnet $SUBNET_ID \
  --sku-name "Standard_2G" \
  --name MyHpcCache
```
Remarque

La création du cache HPC peut prendre jusqu’à 20 minutes.

Créer et configurer le stockage Azure

Créer un compte de stockage à l’aide de la commande az storage account create. Commencez par définir la variable d’environnement STORAGE_ACCOUNT_NAME.

Important

Vous devez sélectionner un nom de compte de stockage unique. Remplacez uniquestorageaccount par votre nom spécifié. Un nom de compte de stockage doit comporter entre 3 et 24 caractères, et ne peut contenir que des chiffres et des lettres minuscules.
```
STORAGE_ACCOUNT_NAME=uniquestorageaccount
```
L’exemple suivant crée un compte de stockage dans la région USA Est avec la référence SKU Standard_LRS. Spécifiez une valeur pour --location et --sku.
```
az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location eastus \
  --sku Standard_LRS
```

Attribuez le rôle contributeur aux données blob de stockage sur votre abonnement à l’aide de la commande az role assignment create. Tout d’abord, définissez les variables d’environnement STORAGE_ACCOUNT_ID et AD_USER.

STORAGE_ACCOUNT_ID=$(az storage account show --name $STORAGE_ACCOUNT_NAME --query "id" -o tsv)
AD_USER=$(az ad signed-in-user show --query objectId -o tsv)

az role assignment create --role "Storage Blob Data Contributor" --assignee $AD_USER --scope $STORAGE_ACCOUNT_ID

Créez le conteneur Blob dans le compte de stockage avec la commande az storage container create. Tout d’abord, définissez la variable d’environnement CONTAINER_NAME et remplacez le nom du conteneur d’objets blob.
```
CONTAINER_NAME=mystoragecontainer
```
```
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
```

Fournissez des autorisations au compte de service Azure HPC Cache pour accéder à votre compte de stockage et conteneur d’objets blob à l’aide des commandes az role assignment. Tout d’abord, définissez les variables d’environnement HPC_CACHE_USER et HPC_CACHE_ID.

HPC_CACHE_USER="StorageCache Resource Provider"
HPC_CACHE_ID=$(az ad sp list --display-name "${HPC_CACHE_USER}" --query "[].objectId" -o tsv)

az role assignment create --role "Storage Account Contributor" --assignee $HPC_CACHE_ID --scope $STORAGE_ACCOUNT_ID
az role assignment create --role "Storage Blob Data Contributor" --assignee $HPC_CACHE_ID --scope $STORAGE_ACCOUNT_ID

Ajoutez le conteneur Blob à votre cache HPC Cache en tant que cible de stockage avec la commande az hpc-cache blob-storage-target add. L’exemple suivant crée un conteneur d’objets blob nommé MyStorageTarget au cache HPC MyHpcCache. Spécifiez une valeur pour --name, --cache-nameet --virtual-namespace-path.
```
az hpc-cache blob-storage-target add \
  --resource-group $RESOURCE_GROUP \
  --cache-name MyHpcCache \
  --name MyStorageTarget \
  --storage-account $STORAGE_ACCOUNT_ID \
  --container-name $CONTAINER_NAME \
  --virtual-namespace-path "/myfilepath"
```

Configurer l’équilibrage de la charge client

Créez une zone DNS privée Azure pour les adresses IP côté client à l’aide de la commande az network private-dns zone create . Commencez par définir la variable d’environnement PRIVATE_DNS_ZONE et spécifiez un nom pour la zone.
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
```
az network private-dns zone create \
  --resource-group $RESOURCE_GROUP \
  --name $PRIVATE_DNS_ZONE
```

Créez un lien DNS entre la zone Azure DNS privé et le réseau virtuel à l’aide de la commande az network private-dns link vnet create. Remplacez la valeur de --name.

az network private-dns link vnet create \
  --resource-group $RESOURCE_GROUP \
  --name MyDNSLink \
  --zone-name $PRIVATE_DNS_ZONE \
  --virtual-network $VNET_NAME \
  --registration-enabled true

Créez le nom DNS de tourniquet pour les adresses IP côté client à l’aide de la commande az network private-dns record-set a create. Tout d’abord, définissez les variables d’environnement DNS_NAME, HPC_MOUNTS0, HPC_MOUNTS1et HPC_MOUNTS2. Remplacez la valeur de la propriété DNS_NAME.

DNS_NAME="server"
HPC_MOUNTS0=$(az hpc-cache show --name "MyHpcCache" --resource-group $RESOURCE_GROUP --query "mountAddresses[0]" -o tsv | tr --delete '\r')
HPC_MOUNTS1=$(az hpc-cache show --name "MyHpcCache" --resource-group $RESOURCE_GROUP --query "mountAddresses[1]" -o tsv | tr --delete '\r')
HPC_MOUNTS2=$(az hpc-cache show --name "MyHpcCache" --resource-group $RESOURCE_GROUP --query "mountAddresses[2]" -o tsv | tr --delete '\r')

az network private-dns record-set a add-record -g $RESOURCE_GROUP -z $PRIVATE_DNS_ZONE -n $DNS_NAME -a $HPC_MOUNTS0

az network private-dns record-set a add-record -g $RESOURCE_GROUP -z $PRIVATE_DNS_ZONE -n $DNS_NAME -a $HPC_MOUNTS1

az network private-dns record-set a add-record -g $RESOURCE_GROUP -z $PRIVATE_DNS_ZONE -n $DNS_NAME -a $HPC_MOUNTS2

Créer un volume persistant

Créez un fichier nommé pv-nfs.yaml pour définir un volume persistant, puis collez le manifeste suivant. Remplacez les valeurs de la propriété server et path.

---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-nfs
spec:
  capacity:
    storage: 10000Gi
  accessModes:
    - ReadWriteMany
  mountOptions:
    - vers=3
  nfs:
    server: server.myhpccache.local
    path: /

Obtenez les informations d’identification de votre cluster Kubernetes à l’aide de la commande az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Créez le volume persistant à l’aide de la commande kubectl apply.
```
kubectl apply -f pv-nfs.yaml
```
Vérifiez que l’état du volume persistant est Disponible à l’aide de la commande kubectl describe.
```
kubectl describe pv pv-nfs
```

Créer la revendication de volume persistant

Créez un fichier nommé pvc-nfs.yamlpour définir une revendication de volume persistant , puis collez le manifeste suivant.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi

Créez la revendication de volume persistant avec la commande kubectl apply.
```
kubectl apply -f pvc-nfs.yaml
```
Vérifiez que l’état de la revendication de volume persistant est Bound (Lié) à l’aide de la commande kubectl describe.
```
kubectl describe pvc pvc-nfs
```

Monter le cache HPC Cache avec un pod

Créez un fichier nommé nginx-nfs.yaml pour définir un pod qui utilise la revendication de volume persistant, puis collez le manifeste suivant.

kind: Pod
apiVersion: v1
metadata:
  name: nginx-nfs
spec:
  containers:
 - image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
    name: nginx-nfs
    command:
    - "/bin/sh"
    - "-c"
    - while true; do echo $(date) >> /mnt/azure/myfilepath/outfile; sleep 1; done
    volumeMounts:
    - name: disk01
      mountPath: /mnt/azure
  volumes:
 - name: disk01
    persistentVolumeClaim:
      claimName: pvc-nfs

Créez le pod à l’aide de la commande kubectl apply.
```
kubectl apply -f nginx-nfs.yaml
```
Vérifiez que le pod est en cours d’exécution à l’aide de la commande kubectl describe.
```
kubectl describe pod nginx-nfs
```
Vérifiez que votre volume est monté dans le pod à l’aide de la commande kubectl exec pour vous connecter au pod.
```
kubectl exec -it nginx-nfs -- sh
```
Pour vérifier si le volume est monté, exécutez df dans son format lisible par l’utilisateur à l’aide de l’option --human-readable (-h pour un court terme).
```
df -h
```
L’exemple suivant ressemble à la sortie retournée par la commande :
```
Filesystem             Size  Used Avail Use% Mounted on
...
server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
...
```

Étapes suivantes

Pour plus d’informations sur Azure HPC cache, consultez Vue d’ensemble du cache HPC Cache.
Pour plus d’informations sur l’utilisation de NFS avec AKS, consultez Créer manuellement et utiliser un volume de serveur Linux NFS (Network File System) avec AKS.

Share via

Intégrer Azure HPC Cache à Azure Kubernetes Service (AKS)

Avant de commencer

Installer l’extension Azure CLI `hpc-cache`

Inscrire l’indicateur de fonctionnalité StorageCache

Monter le cache Azure HPC Cache

Créer et configurer le stockage Azure

Configurer l’équilibrage de la charge client

Créer un volume persistant

Créer la revendication de volume persistant

Monter le cache HPC Cache avec un pod

Étapes suivantes

Ressources supplémentaires

Share via

Intégrer Azure HPC Cache à Azure Kubernetes Service (AKS)

Avant de commencer

Installer l’extension Azure CLI hpc-cache

Inscrire l’indicateur de fonctionnalité StorageCache

Monter le cache Azure HPC Cache

Créer et configurer le stockage Azure

Configurer l’équilibrage de la charge client

Créer un volume persistant

Créer la revendication de volume persistant

Monter le cache HPC Cache avec un pod

Étapes suivantes

Ressources supplémentaires

Installer l’extension Azure CLI `hpc-cache`