Integrare Cache HPC di Azure con il servizio Azure Kubernetes

Articolo
08/02/2024

Cache HPC di Azure accelera l'accesso ai dati per le attività High Performance Computing (HPC). Memorizzando nella cache i file di Azure, Cache HPC di Azure aggiunge la scalabilità del cloud computing al flusso di lavoro esistente. Questo articolo illustra come integrare Cache HPC di Azure con il servizio Azure Kubernetes.

Operazioni preliminari

Il cluster del servizio Azure Kubernetes deve trovarsi in un'area che supporta Cache HPC di Azure.
È necessaria l'interfaccia della riga di comando di Azure versione 2.7 o successiva. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.
Registrare l'estensione hpc-cache nella sottoscrizione di Azure. Per altre informazioni sull'uso di Cache HPC con l'interfaccia della riga di comando di Azure, vedere i prerequisiti dell'interfaccia della riga di comando di Cache HPC.
Esaminare i prerequisiti di Cache HPC. Prima di poter eseguire Cache HPC, è necessario soddisfare quanto segue:
- La cache richiede una subnet dedicata con almeno 64 indirizzi IP disponibili.
- La subnet non deve ospitare altre macchine virtuali o contenitori.
- La subnet deve essere accessibile dai nodi del servizio Azure Kubernetes.
Se è necessario eseguire l'applicazione come utente senza accesso radice, potrebbe essere necessario disabilitare lo squash radice usando il comando di modifica proprietario (chown) per modificare la titolarità della directory in un altro utente. L'utente senza accesso radice deve essere proprietario di una directory per accedere al file system. Affinché l'utente sia proprietario di una directory, l'utente radice deve creare una directory a tale utente, ma se Cache HPC è una radice squash, questa operazione viene negata perché l'utente radice (UID 0) viene mappato in utente anonimo. Per altre informazioni sullo squash di radice e sui criteri di accesso client, vedere Criteri di accesso alla Cache HPC.

Installare l'estensione `hpc-cache` dell'interfaccia della riga di comando di Azure.

Importante

Le funzionalità di anteprima del servizio Azure Kubernetes sono disponibili in modalità self-service e opzionale. Le anteprime vengono fornite "così come sono" e "come disponibili" e sono escluse dai contratti di servizio e dalla garanzia limitata. Le anteprime del servizio Azure Kubernetes sono parzialmente coperte dal supporto clienti con la massima diligenza possibile. Di conseguenza, queste funzionalità non sono destinate all'uso in produzione. Per altre informazioni, vedere gli articoli di supporto seguenti:

Per installare l'estensione hpc-cache, eseguire il comando seguente:

az extension add --name hpc-cache

Per eseguire l'aggiornamento alla versione più recente dell'estensione rilasciata eseguire il comando seguente:

az extension update --name hpc-cache

Registrare il flag di funzionalità StorageCache

Registrare il provider di risorse Microsoft.StorageCache usando il comando az provider register.

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

Sono necessari alcuni minuti per visualizzare lo stato Registered. Verificare lo stato della registrazione usando il comando az feature show:

az feature show --namespace "Microsoft.StorageCache"

Creare Cache HPC di Azure

Ottenere il gruppo di risorse del nodo usando il comando az aks show con il parametro di query --query nodeResourceGroup.
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
L'output dovrebbe essere simile all'esempio di output seguente:
```
MC_myResourceGroup_myAKSCluster_eastus
```

Creare una subnet di Cache HPC dedicata usando il comando az network vnet subnet create. Definire prima di tutto le variabili di ambiente per RESOURCE_GROUP, VNET_NAME, VNET_ID e SUBNET_NAME. Copiare l'output del passaggio precedente per RESOURCE_GROUP e specificare un valore per 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

Creare una Cache HPC nello stesso gruppo di risorse nodo e nella stessa area. Definire prima di tutto la variabile di ambiente SUBNET_ID.
```
SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
```
Creare Cache HPC usando il comando az hpc-cache create. L'esempio seguente crea Cache HPC nell'area Stati Uniti orientali con un tipo di cache 2G Standard denominato MyHpcCache. Specificare un valore per --location, --sku-name e --name.
```
az hpc-cache create \
  --resource-group $RESOURCE_GROUP \
  --cache-size-gb "3072" \
  --location eastus \
  --subnet $SUBNET_ID \
  --sku-name "Standard_2G" \
  --name MyHpcCache
```
Nota

La creazione di Cache HPC può richiedere fino a 20 minuti.

Creare e configurare Archiviazione di Azure

Creare un account di archiviazione usando il comando az storage account create. Definire prima di tutto la variabile di ambiente STORAGE_ACCOUNT_NAME.

Importante

È necessario selezionare un nome univoco dell'account di archiviazione. Sostituire uniquestorageaccount con il nome specificato. I nomi degli account di archiviazione devono avere una lunghezza compresa tra 3 e 24 caratteri e possono contenere solo numeri e lettere minuscole.
```
STORAGE_ACCOUNT_NAME=uniquestorageaccount
```
L'esempio seguente crea un account di archiviazione nell'area Stati Uniti orientali con lo SKU Standard_LRS. Specificare un valore per --location e --sku.
```
az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location eastus \
  --sku Standard_LRS
```

Assegnare il ruolo Collaboratore ai dati dei BLOB di archiviazione nella sottoscrizione usando il comando az role assignment create. Definire prima di tutto le variabili di ambiente STORAGE_ACCOUNT_ID e 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

Creare il contenitore BLOB all'interno dell'account di archiviazione usando il comando az storage container create. Prima di tutto, definire la variabile di ambiente CONTAINER_NAME e sostituire il nome per il contenitore BLOB.
```
CONTAINER_NAME=mystoragecontainer
```
```
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
```

Fornire le autorizzazioni all'account del servizio Cache HPC di Azure per accedere all'account di archiviazione e al contenitore BLOB usando i comandi az role assignment. Definire prima di tutto le variabili di ambiente HPC_CACHE_USER e 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

Aggiungere il contenitore BLOB a Cache HPC come destinazione di archiviazione usando il comando az hpc-cache blob-storage-target add. L'esempio seguente crea un contenitore BLOB denominato MyStorageTarget in Cache HPC MyHpcCache. Specificare un valore per --name, --cache-name e --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"
```

Configurare il bilanciamento del carico client

Creare una zona del DNS privato di Azure per gli indirizzi IP rivolti al client usando il comando az network private-dns zone create. Prima di tutto, definire la variabile di ambiente PRIVATE_DNS_ZONE e specificare un nome per la zona.
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
```
az network private-dns zone create \
  --resource-group $RESOURCE_GROUP \
  --name $PRIVATE_DNS_ZONE
```

Creare un collegamento DNS tra la zona del DNS privato di Azure e la rete virtuale usando il comando az network private-dns link vnet create. Sostituire il valore per --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

Creare il nome DNS round-robin per gli indirizzi IP rivolti al client usando il comando az network private-dns record-set a create. Definire prima di tutto le variabili di ambiente DNS_NAME, HPC_MOUNTS0,HPC_MOUNTS1 e HPC_MOUNTS2. Sostituire il valore per la proprietà 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

Creare un volume permanente

Creare un file denominato pv-nfs.yaml per definire un volume permanente e quindi incollarlo nel manifesto seguente. Sostituire i valori per la proprietà server e path.

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

Ottenere le credenziali per il cluster Kubernetes usando il comando az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Creare il volume permanente usando il comando kubectl apply.
```
kubectl apply -f pv-nfs.yaml
```
Verificare che lo stato del volume permanente sia Disponibile usando il comando kubectl describe.
```
kubectl describe pv pv-nfs
```

Creare l'attestazione di volume permanente

Creare un file denominato pvc-nfs.yaml per definire un'attestazione di volume permanente e quindi incollarlo nel manifesto seguente.

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

Creare l'attestazione di volume permanente usando il comando kubectl apply.
```
kubectl apply -f pvc-nfs.yaml
```
Verificare che lo stato dell’attestazione di volume permanente sia Associato usando il comando kubectl describe.
```
kubectl describe pvc pvc-nfs
```

Montare Cache HPC con un pod

Creare un file denominato nginx-nfs.yaml per definire un pod che usa l'attestazione di volume permanente e quindi incollarlo nel manifesto seguente.

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

Creare il pod usando il comando kubectl apply.
```
kubectl apply -f nginx-nfs.yaml
```
Verificare che il pod sia in esecuzione usando il comando kubectl describe.
```
kubectl describe pod nginx-nfs
```
Verificare che il volume sia montato nel pod usando il comando kubectl exec per connettersi al pod.
```
kubectl exec -it nginx-nfs -- sh
```
Per verificare se il volume è montato, eseguire df nel formato leggibile usando l'opzione --human-readable (-h in breve).
```
df -h
```
L'esempio seguente è simile all'output restituito dal comando:
```
Filesystem             Size  Used Avail Use% Mounted on
...
server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
...
```

Passaggi successivi

Per altre informazioni su Cache HPC di Azure, vedere Panoramica di Cache HPC.
Per altre informazioni sull'uso di NFS con il servizio Azure Kubernetes, vedere Creare e usare manualmente un volume server Linux NFS (Network File System) con il servizio Azure Kubernetes.

Condividi tramite

Integrare Cache HPC di Azure con il servizio Azure Kubernetes

Operazioni preliminari

Installare l'estensione `hpc-cache` dell'interfaccia della riga di comando di Azure.

Registrare il flag di funzionalità StorageCache

Creare Cache HPC di Azure

Creare e configurare Archiviazione di Azure

Configurare il bilanciamento del carico client

Creare un volume permanente

Creare l'attestazione di volume permanente

Montare Cache HPC con un pod

Passaggi successivi

Risorse aggiuntive

Condividi tramite

Integrare Cache HPC di Azure con il servizio Azure Kubernetes

Operazioni preliminari

Installare l'estensione hpc-cache dell'interfaccia della riga di comando di Azure.

Registrare il flag di funzionalità StorageCache

Creare Cache HPC di Azure

Creare e configurare Archiviazione di Azure

Configurare il bilanciamento del carico client

Creare un volume permanente

Creare l'attestazione di volume permanente

Montare Cache HPC con un pod

Passaggi successivi

Risorse aggiuntive

Installare l'estensione `hpc-cache` dell'interfaccia della riga di comando di Azure.