Azure HPC Cache integreren met Azure Kubernetes Service (AKS)

Met Azure HPC Cache wordt de toegang tot uw gegevens versneld voor HPC-taken (High Performance Computing). Door bestanden in cache op te slaan in Azure, brengt Azure HPC Cache de schaalbaarheid van cloud-computing naar uw bestaande werkstroom. In dit artikel leest u hoe u Azure HPC Cache integreert met Azure Kubernetes Service (AKS).

Voordat u begint

Een AKS-cluster moet zich in een regio bevinden die Ondersteuning biedt voor Azure HPC Cache.
U hebt Azure CLI versie 2.7 of hoger nodig. Voer az --version uit om de versie te bekijken. Als u Azure CLI 2.0 wilt installeren of upgraden, raadpleegt u Azure CLI 2.0 installeren.
Registreer de hpc-cache extensie in uw Azure-abonnement. Zie de vereisten voor HPC Cache CLI voor meer informatie over het gebruik van HPC Cache Met Azure CLI.
Controleer de vereisten voor HPC Cache. U moet aan het volgende voldoen voordat u een HPC-cache kunt uitvoeren:
- De cache vereist een toegewezen subnet met ten minste 64 IP-adressen die beschikbaar zijn.
- Het subnet mag geen andere VM's of containers hosten.
- Het subnet moet toegankelijk zijn vanaf de AKS-knooppunten.
Als u uw toepassing moet uitvoeren als gebruiker zonder hoofdtoegang, moet u mogelijk root-squashing uitschakelen met behulp van de opdracht eigenaar van de wijziging (chown) om het eigendom van de directory te wijzigen in een andere gebruiker. De gebruiker zonder hoofdtoegang moet eigenaar zijn van een map om toegang te krijgen tot het bestandssysteem. Als de gebruiker eigenaar is van een map, moet de hoofdgebruiker een map aan die gebruiker toewijzen, maar als de HPC-cache de hoofdmap verplettert, wordt deze bewerking geweigerd omdat de hoofdgebruiker (UID 0) wordt toegewezen aan de anonieme gebruiker. Zie HPC Cache-toegangsbeleid voor meer informatie over root-squashing- en clienttoegangsbeleid.

`hpc-cache` De Azure CLI-extensie installeren

Belangrijk

AKS preview-functies zijn beschikbaar op selfservice, opt-in basis. Previews worden geleverd 'zoals is' en 'als beschikbaar' en ze worden uitgesloten van de serviceovereenkomsten en beperkte garantie. AKS-previews worden gedeeltelijk gedekt door klantondersteuning op basis van best effort. Daarom zijn deze functies niet bedoeld voor productiegebruik. Zie de volgende ondersteuningsartikelen voor meer informatie:

Voer de volgende opdracht uit om de hpc-cache-extensie te installeren:

az extension add --name hpc-cache

Voer de volgende opdracht uit om bij te werken naar de nieuwste versie van de extensie die is uitgebracht:

az extension update --name hpc-cache

De functievlag StorageCache registreren

Registreer de resourceprovider Microsoft.StorageCache met behulp van de az provider register opdracht.

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

Het duurt enkele minuten voordat de status Geregistreerd wordt weergegeven. Controleer de registratiestatus met behulp van de opdracht az feature show :

az feature show --namespace "Microsoft.StorageCache"

De Azure HPC Cache maken

Haal de knooppuntresourcegroep op met behulp van de az aks show opdracht met de --query nodeResourceGroup queryparameter.
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:
```
MC_myResourceGroup_myAKSCluster_eastus
```

Maak een toegewezen HPC Cache-subnet met behulp van de az network vnet subnet create opdracht. Definieer eerst de omgevingsvariabelen voor RESOURCE_GROUP, VNET_NAMEen VNET_IDSUBNET_NAME. Kopieer de uitvoer van de vorige stap en RESOURCE_GROUPgeef een waarde op voor 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

Maak een HPC-cache in dezelfde knooppuntresourcegroep en -regio. Definieer eerst de omgevingsvariabele SUBNET_ID.
```
SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
```
Maak de HPC Cache met behulp van de az hpc-cache create opdracht. In het volgende voorbeeld wordt de HPC-cache gemaakt in de regio VS - oost met een standaard 2G-cachetype met de naam MyHpcCache. Geef een waarde op voor --location, --sku-name en --name.
```
az hpc-cache create \
  --resource-group $RESOURCE_GROUP \
  --cache-size-gb "3072" \
  --location eastus \
  --subnet $SUBNET_ID \
  --sku-name "Standard_2G" \
  --name MyHpcCache
```
Notitie

Het maken van de HPC-cache kan tot 20 minuten duren.

Azure Storage maken en configureren

Maak een opslagaccount met behulp van de az storage account create opdracht. Definieer eerst de omgevingsvariabele STORAGE_ACCOUNT_NAME.

Belangrijk

U moet een unieke naam voor het opslagaccount selecteren. Vervang door uniquestorageaccount de opgegeven naam. Namen van opslagaccounts moeten tussen de 3 en 24 tekens lang zijn en mogen alleen cijfers en kleine letters bevatten.
```
STORAGE_ACCOUNT_NAME=uniquestorageaccount
```
In het volgende voorbeeld wordt een opslagaccount gemaakt in de regio VS - oost met de Standard_LRS SKU. Geef een waarde op voor --location en --sku.
```
az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location eastus \
  --sku Standard_LRS
```

Wijs de rol Inzender voor opslagblobgegevens toe aan uw abonnement met behulp van de az role assignment create opdracht. Definieer eerst de omgevingsvariabelen STORAGE_ACCOUNT_ID en 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

Maak de Blob-container in het opslagaccount met behulp van de az storage container create opdracht. Definieer eerst de omgevingsvariabele CONTAINER_NAME en vervang de naam voor de Blob-container.
```
CONTAINER_NAME=mystoragecontainer
```
```
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
```

Geef machtigingen op voor het Azure HPC Cache-serviceaccount voor toegang tot uw opslagaccount en Blob-container met behulp van de az role assignment opdrachten. Definieer eerst de omgevingsvariabelen HPC_CACHE_USER en 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

Voeg de blobcontainer toe aan uw HPC Cache als opslagdoel met behulp van de az hpc-cache blob-storage-target add opdracht. In het volgende voorbeeld wordt een blobcontainer met de naam MyStorageTarget gemaakt naar de HPC Cache MyHpcCache. Geef een waarde op voor --name, --cache-name en --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"
```

Clienttaakverdeling instellen

Maak een Azure Privé-DNS-zone voor de clientgerichte IP-adressen met behulp van de az network private-dns zone create opdracht. Definieer eerst de omgevingsvariabele PRIVATE_DNS_ZONE en geef een naam op voor de zone.
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
```
az network private-dns zone create \
  --resource-group $RESOURCE_GROUP \
  --name $PRIVATE_DNS_ZONE
```

Maak een DNS-koppeling tussen de Azure Privé-DNS-zone en het VNet met behulp van de az network private-dns link vnet create opdracht. Vervang de waarde voor --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

Maak de round robin DNS-naam voor de clientgerichte IP-adressen met behulp van de az network private-dns record-set a create opdracht. Definieer eerst de omgevingsvariabelen DNS_NAME, HPC_MOUNTS0, en HPC_MOUNTS1HPC_MOUNTS2. Vervang de waarde voor de eigenschap 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

Een permanent volume maken

Maak een bestand met de naam pv-nfs.yaml om een permanent volume te definiëren en plak het volgende manifest. Vervang de waarden voor de eigenschap server en path.

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

Haal de referenties voor uw Kubernetes-cluster op met behulp van de az aks get-credentials opdracht.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Maak het permanente volume met behulp van de kubectl apply opdracht.
```
kubectl apply -f pv-nfs.yaml
```
Controleer of de status van het permanente volume beschikbaar is met behulp van de kubectl describe opdracht.
```
kubectl describe pv pv-nfs
```

De permanente volumeclaim maken

Maak een bestand met de naam pvc-nfs.yamlom een permanente volumeclaim te definiëren en plak het volgende manifest.

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

Maak de permanente volumeclaim met behulp van de kubectl apply opdracht.
```
kubectl apply -f pvc-nfs.yaml
```
Controleer of de status van de permanente volumeclaim afhankelijk is met behulp van de kubectl describe opdracht.
```
kubectl describe pvc pvc-nfs
```

De HPC-cache koppelen aan een pod

Maak een bestand met de naam nginx-nfs.yaml om een pod te definiëren die gebruikmaakt van de permanente volumeclaim en plak vervolgens het volgende 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

Maak de pod met behulp van de kubectl apply opdracht.
```
kubectl apply -f nginx-nfs.yaml
```
Controleer of de pod wordt uitgevoerd met behulp van de kubectl describe opdracht.
```
kubectl describe pod nginx-nfs
```
Controleer of uw volume is gekoppeld in de pod met behulp van de kubectl exec opdracht om verbinding te maken met de pod.
```
kubectl exec -it nginx-nfs -- sh
```
Als u wilt controleren of het volume is gekoppeld, voert df u de door mensen leesbare indeling uit met behulp van de --human-readable optie (-h kortom).
```
df -h
```
Het volgende voorbeeld lijkt op uitvoer die wordt geretourneerd door de opdracht:
```
Filesystem             Size  Used Avail Use% Mounted on
...
server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
...
```

Volgende stappen

Zie het overzicht van HPC Cache voor meer informatie over Azure HPC Cache.
Zie Voor meer informatie over het gebruik van NFS met AKS handmatig een Network File System (NFS) Linux Server-volume maken en gebruiken met AKS.

Feedback

Is deze pagina nuttig?

Last updated on 2024-11-01