Integrera Azure HPC Cache med Azure Kubernetes Service (AKS)

Artikel
2024-11-01

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:

Azure CLI

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:

Azure CLI

az extension update --name hpc-cache

Registrera funktionsflaggan StorageCache

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

Azure CLI

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 :

Azure CLI

az feature show --namespace "Microsoft.StorageCache"

Skapa Azure HPC Cache

Hämta nodresursgruppen med kommandot az aks show med frågeparametern --query nodeResourceGroup .

Azure CLI
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
Dina utdata bör se ut ungefär som följande exempelutdata:

Output
```
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.

Azure CLI

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

Azure CLI

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.

Azure CLI
```
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.

Azure CLI
```
az hpc-cache create \
  --resource-group $RESOURCE_GROUP \
  --cache-size-gb "3072" \
  --location eastus \
  --subnet $SUBNET_ID \
  --sku-name "Standard_2G" \
  --name MyHpcCache
```
Anteckning

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.

Azure CLI
```
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.

Azure CLI
```
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.

Azure CLI

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)

Azure CLI

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.

Azure CLI
```
CONTAINER_NAME=mystoragecontainer
```
Azure CLI
```
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.

Azure CLI

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

Azure CLI

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.

Azure CLI
```
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.

Azure CLI
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
Azure CLI
```
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.

Azure CLI

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.

Azure CLI

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')

Azure CLI

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.

YAML

---
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 .

Azure CLI
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Skapa den beständiga volymen med kommandot kubectl apply .

Bash
```
kubectl apply -f pv-nfs.yaml
```
Kontrollera att statusen för den beständiga volymen är Tillgänglig med kommandot kubectl describe .

Bash
```
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.

YAML

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 .

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

Bash
```
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.

YAML

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 .

Bash
```
kubectl apply -f nginx-nfs.yaml
```
Kontrollera att podden körs med kommandot kubectl describe .

Bash
```
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.

Bash
```
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).

Bash
```
df -h
```
Följande exempel liknar utdata som returneras från kommandot:

Output
```
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.

Samarbeta med oss på GitHub

Källan för det här innehållet finns på GitHub, där du även kan skapa och granska ärenden och pull-begäranden. Se vår deltagarguide för mer information.

Feedback om Azure Kubernetes Service

Azure Kubernetes Service är ett öppen källkod projekt. Välj en länk för att ge feedback:

Öppna ett dokumentationsproblem Ge produktfeedback

Ytterligare resurser

Utbildning

Utbildningsväg

Köra HPC-program (databehandling med höga prestanda) på Azure - Training

Azure HPC är en specialbyggd molnfunktion för HPC & AI-arbetsbelastning, med hjälp av ledande processorer och HPC-klass InfiniBand-anslutning, för att leverera bästa programprestanda, skalbarhet och värde. Med Azure HPC kan användarna frigöra innovation, produktivitet och affärsflexialitet genom ett brett utbud av HPC- och AI-tekniker som kan allokeras dynamiskt när dina affärs- och tekniska behov ändras. Den här utbildningsvägen är en serie moduler som hjälper dig att komma igång med Azure HPC – du kan väl

Certifiering

Microsoft-certifierad: Specialitet för Azure för SAP-arbetsbelastningar - Certifications

Demonstrera planering, migrering och drift av en SAP-lösning på Microsoft Azure medan du använder Azure-resurser.

Händelser

Skapa intelligenta appar

17 mars 21 - 21 mars 10

Gå med i mötesserien för att skapa skalbara AI-lösningar baserat på verkliga användningsfall med andra utvecklare och experter.

Registrera dig nu

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`