Integrera Azure HPC Cache med Azure Kubernetes Service (AKS)

Artikel
11/01/2024

Azure HPC Cache ger snabbare åtkomst till dina data för HPC-uppgifter (databehandling med höga prestanda). Azure HPC Cache cachelagrar filer i Azure så att du får samma skalbarhet som i molnet för dina befintliga arbetsflöden. Den här artikeln visar hur du integrerar Azure HPC Cache med Azure Kubernetes Service (AKS).

Innan du börjar

AKS-klustret måste finnas i en region som stöder Azure HPC Cache.
Du behöver Azure CLI version 2.7 eller senare. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.
hpc-cache Registrera tillägget i din Azure-prenumeration. Mer information om hur du använder HPC Cache med Azure CLI finns i förhandskraven för HPC Cache CLI.
Granska kraven för HPC Cache. Du måste uppfylla följande innan du kan köra en HPC Cache:
- Cachen kräver ett dedikerat undernät med minst 64 TILLGÄNGLIGA IP-adresser.
- Undernätet får inte vara värd för andra virtuella datorer eller containrar.
- Undernätet måste vara tillgängligt från AKS-noderna.
Om du behöver köra ditt program som en användare utan rotåtkomst kan du behöva inaktivera rot squashing med hjälp av kommandot ändra ägare (chown) för att ändra katalogägarskapet till en annan användare. Användaren utan rotåtkomst måste äga en katalog för att få åtkomst till filsystemet. För att användaren ska kunna äga en katalog måste rotanvändaren skicka en katalog till den användaren, men om HPC Cache krossar roten nekas den här åtgärden eftersom rotanvändaren (UID 0) mappas till den anonyma användaren. Mer information om rot squashing och klientåtkomstprinciper finns i HPC Cache-åtkomstprinciper.

Installera Azure CLI-tillägget `hpc-cache`

Viktigt!

AKS-förhandsversionsfunktioner är tillgängliga via självbetjäning och anmäl dig. Förhandsversioner tillhandahålls "som är" och "som tillgängliga", och de undantas från serviceavtalen och den begränsade garantin. AKS-förhandsversioner omfattas delvis av kundsupport på bästa sätt. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:

Kör följande kommando för att installera tillägget hpc-cache:

az extension add --name hpc-cache

Kör följande kommando för att uppdatera till den senaste versionen av tillägget som släpptes:

az extension update --name hpc-cache

Registrera funktionsflaggan StorageCache

Registrera resursprovidern Microsoft.StorageCache med hjälp av az provider register kommandot .

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

Det tar några minuter för statusen att visa Registrerad. Kontrollera registreringsstatusen med kommandot az feature show :

az feature show --namespace "Microsoft.StorageCache"

Skapa Azure HPC Cache

Hämta nodresursgruppen med kommandot az aks show med frågeparametern --query nodeResourceGroup .
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
Dina utdata bör se ut ungefär som följande exempelutdata:
```
MC_myResourceGroup_myAKSCluster_eastus
```

Skapa ett dedikerat HPC Cache-undernät med kommandot az network vnet subnet create . Definiera först miljövariablerna för RESOURCE_GROUP, VNET_NAME, VNET_IDoch SUBNET_NAME. Kopiera utdata från föregående steg för RESOURCE_GROUPoch ange ett värde för 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

Skapa en HPC Cache i samma nodresursgrupp och region. Definiera först miljövariabeln SUBNET_ID.
```
SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
```
Skapa HPC Cache med kommandot az hpc-cache create . I följande exempel skapas HPC Cache i regionen USA, östra med en Standard 2G-cachetyp med namnet MyHpcCache. Ange ett värde för --location, --sku-name och --name.
```
az hpc-cache create \
  --resource-group $RESOURCE_GROUP \
  --cache-size-gb "3072" \
  --location eastus \
  --subnet $SUBNET_ID \
  --sku-name "Standard_2G" \
  --name MyHpcCache
```
Kommentar

Det kan ta upp till 20 minuter att skapa HPC Cache.

Skapa och konfigurera Azure Storage

Skapa ett lagringskonto med kommandot az storage account create . Definiera först miljövariabeln STORAGE_ACCOUNT_NAME.

Viktigt!

Du måste välja ett unikt lagringskontonamn. Ersätt uniquestorageaccount med ditt angivna namn. Lagringskontonamn måste vara mellan 3 och 24 tecken långa och får endast innehålla siffror och gemener.
```
STORAGE_ACCOUNT_NAME=uniquestorageaccount
```
I följande exempel skapas ett lagringskonto i regionen USA, östra med Standard_LRS SKU. Ange ett värde för --location och --sku.
```
az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location eastus \
  --sku Standard_LRS
```

Tilldela rollen Storage Blob Data-deltagare för din prenumeration med hjälp av az role assignment create kommandot . Definiera först miljövariablerna STORAGE_ACCOUNT_ID och 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

Skapa blobcontainern i lagringskontot med kommandot az storage container create . Definiera först miljövariabeln CONTAINER_NAME och ersätt namnet på blobcontainern.
```
CONTAINER_NAME=mystoragecontainer
```
```
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
```

Ange behörigheter till Azure HPC Cache-tjänstkontot för åtkomst till ditt lagringskonto och blobcontainern med hjälp av az role assignment kommandona. Definiera först miljövariablerna HPC_CACHE_USER och 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

Lägg till blobcontainern i HPC Cache som ett lagringsmål med kommandot az hpc-cache blob-storage-target add . I följande exempel skapas en blobcontainer med namnet MyStorageTarget till HPC Cache MyHpcCache. Ange ett värde för --name, --cache-name och --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"
```

Konfigurera klientbelastningsutjämning

Skapa en Azure Privat DNS-zon för de klientriktade IP-adresserna med hjälp av az network private-dns zone create kommandot . Definiera först miljövariabeln PRIVATE_DNS_ZONE och ange ett namn för zonen.
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
```
az network private-dns zone create \
  --resource-group $RESOURCE_GROUP \
  --name $PRIVATE_DNS_ZONE
```

Skapa en DNS-länk mellan Azure Privat DNS Zone och det virtuella nätverket med hjälp av az network private-dns link vnet create kommandot . Ersätt värdet 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

Skapa dns-namnet för resursallokering för de klientriktade IP-adresserna med kommandot az network private-dns record-set a create . Definiera först miljövariablerna DNS_NAME, HPC_MOUNTS0, HPC_MOUNTS1och HPC_MOUNTS2. Ersätt värdet för egenskapen 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

Skapa en beständig volym

Skapa en fil med namnet pv-nfs.yaml för att definiera en beständig volym och klistra sedan in följande manifest. Ersätt värdena för egenskapen server och path.

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

Hämta autentiseringsuppgifterna för kubernetes-klustret med hjälp av az aks get-credentials kommandot .
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Skapa den beständiga volymen med kommandot kubectl apply .
```
kubectl apply -f pv-nfs.yaml
```
Kontrollera att statusen för den beständiga volymen är Tillgänglig med kommandot kubectl describe .
```
kubectl describe pv pv-nfs
```

Skapa det beständiga volymanspråket

Skapa en fil med namnet pvc-nfs.yamlför att definiera ett beständigt volymanspråk och klistra sedan in följande manifest.

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

Skapa det beständiga volymanspråket kubectl apply med kommandot .
```
kubectl apply -f pvc-nfs.yaml
```
Kontrollera att statusen för det beständiga volymanspråket är Bundet kubectl describe med kommandot .
```
kubectl describe pvc pvc-nfs
```

Montera HPC Cache med en podd

Skapa en fil med namnet nginx-nfs.yaml för att definiera en podd som använder det beständiga volymanspråket och klistra sedan in följande 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

Skapa podden med kommandot kubectl apply .
```
kubectl apply -f nginx-nfs.yaml
```
Kontrollera att podden körs med kommandot kubectl describe .
```
kubectl describe pod nginx-nfs
```
Kontrollera att volymen är monterad i podden med hjälp av kubectl exec kommandot för att ansluta till podden.
```
kubectl exec -it nginx-nfs -- sh
```
Om du vill kontrollera om volymen är monterad kör du df i det humanläsbara formatet med alternativet --human-readable (-h för kort).
```
df -h
```
Följande exempel liknar utdata som returneras från kommandot:
```
Filesystem             Size  Used Avail Use% Mounted on
...
server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
...
```

Nästa steg

Mer information om Azure HPC Cache finns i Översikt över HPC Cache.
Mer information om hur du använder NFS med AKS finns i Skapa och använda en Linux Server-volym (Network File System) manuellt med AKS.

Dela via

Integrera Azure HPC Cache med Azure Kubernetes Service (AKS)

Innan du börjar

Installera Azure CLI-tillägget `hpc-cache`

Registrera funktionsflaggan StorageCache

Skapa Azure HPC Cache

Skapa och konfigurera Azure Storage

Konfigurera klientbelastningsutjämning

Skapa en beständig volym

Skapa det beständiga volymanspråket

Montera HPC Cache med en podd

Nästa steg

Ytterligare resurser

Dela via

Integrera Azure HPC Cache med Azure Kubernetes Service (AKS)

Innan du börjar

Installera Azure CLI-tillägget hpc-cache

Registrera funktionsflaggan StorageCache

Skapa Azure HPC Cache

Skapa och konfigurera Azure Storage

Konfigurera klientbelastningsutjämning

Skapa en beständig volym

Skapa det beständiga volymanspråket

Montera HPC Cache med en podd

Nästa steg

Ytterligare resurser

Installera Azure CLI-tillägget `hpc-cache`