Integrace služby Azure HPC Cache se službou Azure Kubernetes Service (AKS)

Azure HPC Cache zrychluje přístup k datům pro úlohy vysokovýkonných výpočetních prostředí (HPC). Díky ukládání souborů do mezipaměti v Azure přináší Azure HPC Cache do vašich stávajících pracovních postupů škálovatelnost, jaká je možná u cloud computingu. V tomto článku se dozvíte, jak integrovat Azure HPC Cache se službou Azure Kubernetes Service (AKS).

Než začnete

Cluster AKS musí být v oblasti, která podporuje Azure HPC Cache.
Potřebujete Azure CLI verze 2.7 nebo novější. Verzi zjistíte spuštěním příkazu az --version. Pokud potřebujete instalovat nebo upgradovat, podívejte se na Install Azure CLI.
hpc-cache Zaregistrujte rozšíření ve svém předplatném Azure. Další informace o používání služby HPC Cache s Azure CLI najdete v požadavcích rozhraní příkazového řádku služby HPC Cache.
Projděte si požadavky služby HPC Cache. Před spuštěním služby HPC Cache musíte splnit následující skutečnosti:
- Mezipaměť vyžaduje vyhrazenou podsíť s alespoň 64 dostupnými IP adresami.
- Podsíť nesmí hostovat jiné virtuální počítače ani kontejnery.
- Podsíť musí být přístupná z uzlů AKS.
Pokud potřebujete aplikaci spustit jako uživatele bez kořenového přístupu, možná budete muset zakázat root squashing pomocí příkazu change owner (chown) a změnit vlastnictví adresáře na jiného uživatele. Uživatel bez kořenového přístupu musí vlastnit adresář pro přístup k systému souborů. Aby mohl uživatel být vlastníkem adresáře, musí administrátor systému použít příkaz "chown" k přiřazení adresáře tomuto uživateli. Pokud ale HPC Cache odstraňuje práva kořenového uživatele (squashing root), je tato operace zamítnuta, protože kořenový uživatel (UID 0) je namapován na anonymního uživatele. Další informace o kořenovém squashingu a zásadách přístupu klientů najdete v tématu Zásady přístupu ke službě HPC Cache.

`hpc-cache` Instalace rozšíření Azure CLI

Important

Funkce AKS ve verzi Preview jsou k dispozici na bázi samoobsluhy a dobrovolného přihlášení. Ukázky jsou poskytovány "jak jsou" a "podle aktuální dostupnosti" a jsou vyloučené ze smluv o úrovni služeb a omezené záruky. Předběžné verze AKS jsou částečně pokryty zákaznickou podporou podle možností. Proto tyto funkce nejsou určené pro produkční použití. Další informace najdete v následujících článcích podpory:

Pokud chcete nainstalovat rozšíření hpc-Cache, spusťte následující příkaz:

az extension add --name hpc-cache

Spuštěním následujícího příkazu aktualizujte nejnovější verzi vydaného rozšíření:

az extension update --name hpc-cache

Zaregistrujte příznak funkce StorageCache

Pomocí příkazu zaregistrujte poskytovatele prostředků az provider register.

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

Zobrazení stavu Zaregistrované trvá několik minut. Pomocí příkazu az feature show ověřte stav registrace:

az feature show --namespace "Microsoft.StorageCache"

Vytvoření služby Azure HPC Cache

Pomocí az aks show příkazu s --query nodeResourceGroup parametrem dotazu získejte skupinu prostředků uzlu.
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
Vaše výstupy by měly vypadat podobně jako následující příklad:
```
MC_myResourceGroup_myAKSCluster_eastus
```

Pomocí příkazu vytvořte vyhrazenou podsíť az network vnet subnet create služby HPC Cache. Nejprve definujte proměnné prostředí pro RESOURCE_GROUP, VNET_NAMEVNET_ID, a SUBNET_NAME. Zkopírujte výstup z předchozího kroku pro RESOURCE_GROUPa zadejte hodnotu pro 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

Vytvořte mezipaměť HPC Cache ve stejné skupině prostředků a oblasti uzlu. Nejprve definujte proměnnou SUBNET_IDprostředí .
```
SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
```
Pomocí příkazu vytvořte službu HPC Cache az hpc-cache create . Následující příklad vytvoří mezipaměť HPC Cache v oblasti USA – východ s typem mezipaměti Standard 2G s názvem MyHpcCache. Zadejte hodnotu pro --location, --sku-name a --name.
```
az hpc-cache create \
  --resource-group $RESOURCE_GROUP \
  --cache-size-gb "3072" \
  --location eastus \
  --subnet $SUBNET_ID \
  --sku-name "Standard_2G" \
  --name MyHpcCache
```
Note

Vytvoření služby HPC Cache může trvat až 20 minut.

Vytvoření a konfigurace úložiště Azure

Vytvořte účet úložiště pomocí příkazu az storage account create. Nejprve definujte proměnnou STORAGE_ACCOUNT_NAMEprostředí .

Important

Musíte vybrat jedinečný název účtu úložiště. Nahraďte uniquestorageaccount zadaným názvem. Názvy účtů úložiště musí mít délku 3 až 24 znaků a můžou obsahovat jenom číslice a malá písmena.
```
STORAGE_ACCOUNT_NAME=uniquestorageaccount
```
Následující příklad vytvoří účet úložiště v oblasti východ USA s SKU Standard_LRS. Zadejte hodnotu pro --location a --sku.
```
az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location eastus \
  --sku Standard_LRS
```

Pomocí příkazu přiřaďte roli Přispěvatel dat v objektu blob služby Storage ve vašem předplatném az role assignment create . Nejprve definujte proměnné STORAGE_ACCOUNT_ID prostředí a 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

Vytvořte kontejner objektů blob v účtu úložiště pomocí příkazu az storage container create. Nejprve definujte proměnnou CONTAINER_NAME prostředí a nahraďte název kontejneru objektů blob.
```
CONTAINER_NAME=mystoragecontainer
```
```
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
```

Poskytněte oprávnění účtu služby Azure HPC Cache pro přístup k vašemu účtu úložiště a kontejneru objektů Blob pomocí příkazů az role assignment. Nejprve definujte proměnné HPC_CACHE_USER prostředí a 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

Přidejte kontejner objektů blob do služby HPC Cache jako cíl úložiště pomocí az hpc-cache blob-storage-target add příkazu. Následující příklad vytvoří kontejner objektů blob MyStorageTarget do mezipaměti HPC Cache MyHpcCache. Zadejte hodnotu pro --name, --cache-name a --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"
```

Nastavení vyrovnávání zatížení klienta

Pomocí příkazu vytvořte zónu Azure Private DNS pro IP adresy az network private-dns zone create určené pro klienta. Nejprve definujte proměnnou PRIVATE_DNS_ZONE prostředí a zadejte název zóny.
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
```
az network private-dns zone create \
  --resource-group $RESOURCE_GROUP \
  --name $PRIVATE_DNS_ZONE
```

Pomocí příkazu vytvořte propojení DNS mezi zónou Azure Private DNS a virtuální az network private-dns link vnet create sítí. Nahraďte hodnotu parametru --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

Pomocí příkazu az network private-dns record-set a create vytvořte název DNS s kruhovým dotazováním pro IP adresy směřující ke klientovi. Nejprve definujte proměnné prostředí DNS_NAME, HPC_MOUNTS0, HPC_MOUNTS1 a HPC_MOUNTS2. Nahraďte hodnotu vlastnosti 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

Vytvořte trvalý svazek

Vytvořte soubor s názvem pv-nfs.yaml pro definování trvalého svazku a vložte ho do následujícího manifestu. Nahraďte hodnoty vlastnosti server a path.

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

Pomocí příkazu získejte přihlašovací údaje pro cluster az aks get-credentials Kubernetes.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Pomocí příkazu kubectl apply vytvořte trvalý svazek.
```
kubectl apply -f pv-nfs.yaml
```
Ověřte, že stav trvalého svazku je k dispozici pomocí příkazu kubectl describe.
```
kubectl describe pv pv-nfs
```

Vytvořte požadavek na trvalý svazek

Vytvořte soubor pojmenovaný pvc-nfs.yaml pro definici přetrvávajícího požadavku na svazek a vložte následující manifest.

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

Pomocí příkazu kubectl apply vytvořte požadavek na trvalý svazek.
```
kubectl apply -f pvc-nfs.yaml
```
Pomocí příkazu kubectl describe ověřte, že stav přetrvávající žádosti o svazek je Svázaný.
```
kubectl describe pvc pvc-nfs
```

Připojte HPC Cache pomocí podu

Vytvořte soubor s názvem nginx-nfs.yaml pro definování podu, který používá trvalou deklaraci identity svazku, a vložte následující manifest.

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

Vytvořte pod pomocí příkazu kubectl apply.
```
kubectl apply -f nginx-nfs.yaml
```
Ověřte, že je pod spuštěný pomocí příkazu kubectl describe.
```
kubectl describe pod nginx-nfs
```
Ověřte, že je svazek připojený k podu pomocí příkazu kubectl exec ke spuštění spojení s podem.
```
kubectl exec -it nginx-nfs -- sh
```
Pokud chcete zkontrolovat, jestli je svazek připojený, spusťte ho df ve formátu čitelném pro člověka s použitím možnosti --human-readable (-h).
```
df -h
```
Následující příklad připomíná výstup vrácený příkazem:
```
Filesystem             Size  Used Avail Use% Mounted on
...
server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
...
```

Další kroky

Další informace o službě Azure HPC Cache najdete v přehledu služby HPC Cache.
Další informace o použití systému souborů NFS s AKS najdete v tématu Ruční vytvoření a použití svazku systému souborů NFS (Network File System) s Linuxem s AKS.

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-11-04