Integrieren von Azure HPC Cache in Azure Kubernetes Service (AKS)

Artikel
08/02/2024

Azure HPC Cache beschleunigt den Zugriff auf Ihre Daten für High Performance Computing-Aufgaben (HPC). Aufgrund der Zwischenspeicherung von Dateien in Azure ermöglicht Azure HPC Cache für Ihren vorhandenen Workflow die Skalierbarkeit des Cloud Computing. Dieser Artikel zeigt Ihnen, wie Sie Azure HPC Cache in Azure Kubernetes Service (AKS) integrieren.

Voraussetzungen

Ihr AKS-Cluster muss sich in einer Region befinden, die Azure HPC Cache unterstützt.
Sie benötigen Azure CLI, Version 2.7 oder höher. Führen Sie az --version aus, um die Version zu ermitteln. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI.
Registrieren Sie die hpc-cache-Erweiterung in Ihrem Azure-Abonnement. Weitere Informationen zur Verwendung von HPC Cache mit der Azure CLI finden Sie in den Voraussetzungen für die Einrichtung der CLI für HPC Cache.
Lesen Sie die Voraussetzungen für HPC Cache. Folgende Bedingungen müssen erfüllt sein, bevor Sie eine HPC Cache-Instanz ausführen können:
- Der Cache erfordert ein dediziertes Subnetz mit mindestens 64 verfügbaren IP-Adressen.
- Das Subnetz darf keine anderen VMs oder Container hosten.
- Auf das Subnetz muss über die AKS-Knoten zugegriffen werden können.
Wenn Sie Ihre Anwendung als Benutzer ohne Stammzugriff ausführen müssen, müssen Sie ggf. das Root Squashing deaktivieren, indem Sie den Befehl „Besitzer ändern“ (chown) verwenden, um das Eigentum am Verzeichnis an einen anderen Benutzer zu übertragen. Der Benutzer ohne Stammzugriff muss ein Verzeichnis besitzen, um auf das Dateisystem zugreifen zu können. Damit der Benutzer ein Verzeichnis besitzen kann, muss der Root-Benutzer diesen Benutzer zum Besitzer des Verzeichnisses machen. Wenn der HPC Cache jedoch Root-Squashing einsetzt, wird dieser Vorgang verweigert, da der Root-Benutzer (UID 0) dem anonymen Benutzer zugeordnet wird. Weitere Informationen zum Root-Squashing und zu Clientzugriffsrichtlinien finden Sie unter HPC Cache-Zugriffsrichtlinien.

Installieren der Azure CLI-Erweiterung `hpc-cache`

Wichtig

AKS-Previewfunktionen stehen gemäß dem Self-Service- und Aktivierungsprinzip zur Verfügung. Vorschauversionen werden „wie besehen“ und „wie verfügbar“ bereitgestellt und sind von Service Level Agreements und der Herstellergarantie ausgeschlossen. AKS-Vorschauversionen werden teilweise vom Kundensupport auf Grundlage der bestmöglichen Leistung abgedeckt. Daher sind diese Funktionen nicht für die Verwendung in der Produktion vorgesehen. Weitere Informationen finden Sie in den folgenden Supportartikeln:

Führen Sie den folgenden Befehl aus, um die Erweiterung „hpc-cache“ zu installieren:

az extension add --name hpc-cache

Führen Sie den folgenden Befehl aus, um ein Update auf die neueste veröffentlichte Version der Erweiterung durchzuführen:

az extension update --name hpc-cache

Registrieren des StorageCache-Feature-Flags

Registrieren Sie den Ressourcenanbieter Microsoft.StorageCache mit dem Befehl az provider register.

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

Es dauert einige Minuten, bis der Status Registered (Registriert) angezeigt wird. Überprüfen Sie den Registrierungsstatus mithilfe des Befehls az feature show:

az feature show --namespace "Microsoft.StorageCache"

Erstellen der Azure HPC Cache-Instanz

Rufen Sie die Knotenressourcengruppe mithilfe des Befehls az aks show mit dem Abfrageparameter --query nodeResourceGroup ab.
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:
```
MC_myResourceGroup_myAKSCluster_eastus
```

Erstellen Sie ein dediziertes HPC Cache-Subnetz mit dem Befehl az network vnet subnet create. Definieren Sie zunächst die Umgebungsvariablen für RESOURCE_GROUP, VNET_NAME, VNET_ID und SUBNET_NAME. Kopieren Sie die Ausgabe aus dem vorherigen Schritt für RESOURCE_GROUP, und geben Sie einen Wert für SUBNET_NAME an.

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

Erstellen Sie eine HPC Cache-Instanz in derselben Knotenressourcengruppe und -region. Definieren Sie zunächst die Umgebungsvariable SUBNET_ID.
```
SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
```
Erstellen Sie den HPC Cache mit dem Befehl az hpc-cache create. Im folgenden Beispiel wird der HPC Cache in der Region USA, Osten mit einem Standard 2G-Cache-Typ namens MyHpcCache erstellt. Geben Sie einen Wert für --location, --sku-nameund --name an.
```
az hpc-cache create \
  --resource-group $RESOURCE_GROUP \
  --cache-size-gb "3072" \
  --location eastus \
  --subnet $SUBNET_ID \
  --sku-name "Standard_2G" \
  --name MyHpcCache
```
Hinweis

Das Erstellen des HPC Cache kann bis zu 20 Minuten dauern.

Erstellen und Konfigurieren von Azure Storage

Erstellen Sie ein Speicherkonto mit dem Befehl az storage account create. Definieren Sie zunächst die Umgebungsvariable STORAGE_ACCOUNT_NAME.

Wichtig

Sie müssen einen eindeutigen Speicherkontonamen auswählen. Ersetzen Sie uniquestorageaccount durch den angegebenen Namen. Speicherkontonamen müssen zwischen 3 und 24 Zeichen lang sein und dürfen nur Ziffern und Kleinbuchstaben enthalten.
```
STORAGE_ACCOUNT_NAME=uniquestorageaccount
```
Im folgenden Beispiel wird ein Speicherkonto in der Region USA, Osten mit der SKU „Standard_LRS“ erstellt. Geben Sie einen Wert für --location und --sku an.
```
az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location eastus \
  --sku Standard_LRS
```

Weisen Sie Ihrem Abonnement mithilfe des Befehls az role assignment create die Rolle Mitwirkender an Speicherblobdaten zu. Definieren Sie zunächst die Umgebungsvariablen STORAGE_ACCOUNT_ID und 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

Erstellen Sie mit dem Befehl az storage container create den Blobcontainer im Speicherkonto. Definieren Sie zunächst die Umgebungsvariable CONTAINER_NAME und ersetzen Sie den Namen für den Blobcontainer.
```
CONTAINER_NAME=mystoragecontainer
```
```
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
```

Erteilen Sie dem Azure HPC Cache-Dienstkonto mit den az role assignment-Befehlen die Berechtigungen, auf Ihr Speicherkonto und Ihren Blobcontainer zuzugreifen. Definieren Sie zunächst die Umgebungsvariablen HPC_CACHE_USER und 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

Fügen Sie den Blobcontainer mit dem Befehl az hpc-cache blob-storage-target add HPC Cache als Speicherziel hinzu. Im folgenden Beispiel wird ein Blobcontainer namens MyStorageTarget für den HPC Cache MyHpcCache erstellt. Geben Sie einen Wert für --name, --cache-nameund --virtual-namespace-path- an.
```
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"
```

Einrichten des Clientlastenausgleichs

Erstellen Sie mit dem Befehl az network private-dns zone create eine private Azure DNS-Zone für die clientseitigen IP-Adressen. Definieren Sie zunächst die Umgebungsvariable PRIVATE_DNS_ZONE und legen Sie einen Namen für die Zone fest.
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
```
az network private-dns zone create \
  --resource-group $RESOURCE_GROUP \
  --name $PRIVATE_DNS_ZONE
```

Erstellen Sie mit dem Befehl az network private-dns link vnet create eine DNS-Verknüpfung zwischen der privaten Azure-DNS-Zone und dem VNet. Ersetzen Sie den Wert für --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

Erstellen Sie mit dem Befehl az network private-dns record-set a create den Roundrobin-DNS-Namen für die clientseitigen IP-Adressen. Definieren Sie zunächst die Umgebungsvariablen DNS_NAME, HPC_MOUNTS0, HPC_MOUNTS1 und HPC_MOUNTS2. Ersetzen Sie den Wert der Eigenschaft 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

Erstellen eines persistenten Volumes

Erstellen Sie eine Datei mit dem Namen pv-nfs.yaml, um ein persistentes Volume zu definieren, und fügen Sie dann das folgende Manifest ein. Ersetzen Sie die Werte für die Eigenschaften server und path.

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

Rufen Sie mit dem Befehl az aks get-credentials die Anmeldeinformationen für den Kubernetes-Cluster ab.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Erstellen Sie mit dem Befehl kubectl apply das persistente Volume.
```
kubectl apply -f pv-nfs.yaml
```
Überprüfen Sie mithilfe des Befehls kubectl describe, ob der Status des persistenten Volumes Verfügbar ist.
```
kubectl describe pv pv-nfs
```

Erstellen des Anspruchs auf persistente Volumes

Erstellen Sie eine Datei mit dem Namen pvc-nfs.yaml, um einen persistenten Volumeanspruch zu definieren, und fügen Sie dann das folgende Manifest ein.

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

Erstellen Sie den Anspruch auf ein persistentes Volume mit dem Befehl kubectl apply.
```
kubectl apply -f pvc-nfs.yaml
```
Überprüfen Sie mithilfe des Befehls kubectl describe, ob der Status des Anspruchs auf ein persistentes Volume Gebunden lautet.
```
kubectl describe pvc pvc-nfs
```

Einbinden des HPC Cache mit einem Pod

Erstellen Sie eine Datei mit dem Namen nginx-nfs.yaml, um einen Pod zu definieren, der den persistenten Volumeanspruch verwendet, und fügen Sie dann das folgende Manifest ein.

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

Erstellen Sie den Pod mit dem Befehl kubectl apply.
```
kubectl apply -f nginx-nfs.yaml
```
Überprüfen Sie mit dem Befehl kubectl describe, ob der Pod ausgeführt wird.
```
kubectl describe pod nginx-nfs
```
Stellen Sie sicher, dass Ihr Volume in den Pod eingebunden wurde, indem Sie den Befehl kubectl exec verwenden, um eine Verbindung mit dem Pod herzustellen.
```
kubectl exec -it nginx-nfs -- sh
```
Führen Sie mithilfe der Option --human-readable (-h für kurz) df im lesbaren Format aus, um zu überprüfen, ob das Volume eingebunden wurde.
```
df -h
```
Das folgende Beispiel ähnelt der vom Befehl zurückgegebenen Ausgabe:
```
Filesystem             Size  Used Avail Use% Mounted on
...
server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
...
```

Nächste Schritte

Weitere Informationen zu Azure HPC Cache finden Sie unter Was ist Azure HPC Cache?
Weitere Informationen zur Verwendung von NFS mit AKS finden Sie unter Manuelles Erstellen und Verwenden eines Linux-NFS-Servers (Network File System) mit Azure Kubernetes Service (AKS).

Freigeben über

Integrieren von Azure HPC Cache in Azure Kubernetes Service (AKS)

Voraussetzungen

Installieren der Azure CLI-Erweiterung `hpc-cache`

Registrieren des StorageCache-Feature-Flags

Erstellen der Azure HPC Cache-Instanz

Erstellen und Konfigurieren von Azure Storage

Einrichten des Clientlastenausgleichs

Erstellen eines persistenten Volumes

Erstellen des Anspruchs auf persistente Volumes

Einbinden des HPC Cache mit einem Pod

Nächste Schritte

Zusätzliche Ressourcen

Freigeben über

Integrieren von Azure HPC Cache in Azure Kubernetes Service (AKS)

Voraussetzungen

Installieren der Azure CLI-Erweiterung hpc-cache

Registrieren des StorageCache-Feature-Flags

Erstellen der Azure HPC Cache-Instanz

Erstellen und Konfigurieren von Azure Storage

Einrichten des Clientlastenausgleichs

Erstellen eines persistenten Volumes

Erstellen des Anspruchs auf persistente Volumes

Einbinden des HPC Cache mit einem Pod

Nächste Schritte

Zusätzliche Ressourcen

Installieren der Azure CLI-Erweiterung `hpc-cache`