Integrowanie usługi Azure HPC Cache z usługą Azure Kubernetes Service (AKS)

Usługa Azure HPC Cache przyspiesza dostęp do danych w celu wykonywania zadań obliczeń o wysokiej wydajności (HPC). Dzięki buforowaniu plików na platformie Azure usługa Azure HPC Cache zapewnia skalowalność przetwarzania w chmurze do istniejącego przepływu pracy. W tym artykule pokazano, jak zintegrować usługę Azure HPC Cache z usługą Azure Kubernetes Service (AKS).

Zanim rozpoczniesz

Klaster usługi AKS musi znajdować się w regionie obsługującym usługę Azure HPC Cache.
Potrzebujesz interfejsu wiersza polecenia platformy Azure w wersji 2.7 lub nowszej. Uruchom polecenie az --version, aby dowiedzieć się, jaka wersja jest używana. Jeśli konieczna będzie instalacja lub uaktualnienie, zobacz Instalowanie interfejsu wiersza polecenia platformy Azure.
Zarejestruj rozszerzenie w subskrypcji platformy hpc-cache Azure. Aby uzyskać więcej informacji na temat korzystania z usługi HPC Cache z interfejsem wiersza polecenia platformy Azure, zobacz wymagania wstępne interfejsu wiersza polecenia usługi HPC Cache.
Zapoznaj się z wymaganiami wstępnymi dotyczącymi usługi HPC Cache. Przed uruchomieniem pamięci podręcznej HPC Cache należy spełnić następujące wymagania:
- Pamięć podręczna wymaga dedykowanej podsieci z co najmniej 64 dostępnymi adresami IP.
- Podsieć nie może hostować innych maszyn wirtualnych ani kontenerów.
- Podsieć musi być dostępna z węzłów usługi AKS.
Jeśli musisz uruchomić aplikację jako użytkownik bez dostępu do katalogu głównego, może być konieczne wyłączenie funkcji squashing katalogu głównego przy użyciu polecenia właściciela zmiany (chown), aby zmienić własność katalogu na innego użytkownika. Użytkownik bez dostępu głównego musi być właścicielem katalogu, aby uzyskać dostęp do systemu plików. Aby użytkownik był właścicielem katalogu, użytkownik główny musi chown katalog do tego użytkownika, ale jeśli pamięć podręczna HPC Cache jest w stanie zmiażdżyć katalog główny, ta operacja zostanie odrzucona, ponieważ użytkownik główny (UID 0) jest mapowany na użytkownika anonimowego. Aby uzyskać więcej informacji na temat zasad zabezpieczeń katalogu głównego i zasad dostępu klienta, zobacz Zasady dostępu do pamięci podręcznej HPC Cache.

Instalowanie rozszerzenia interfejsu wiersza polecenia platformy `hpc-cache` Azure

Ważne

Funkcje usługi AKS w wersji zapoznawczej są dostępne na zasadzie samoobsługi. Wersje zapoznawcze są udostępniane w wersji "as is" i "jako dostępne" i są wykluczone z umów dotyczących poziomu usług i ograniczonej gwarancji. Wersje zapoznawcze usługi AKS są częściowo objęte pomocą techniczną dla klientów. W związku z tym te funkcje nie są przeznaczone do użytku produkcyjnego. Aby uzyskać więcej informacji, zobacz następujące artykuły pomocy technicznej:

Aby zainstalować rozszerzenie hpc-cache, uruchom następujące polecenie:

az extension add --name hpc-cache

Uruchom następujące polecenie, aby zaktualizować do najnowszej wersji wydanego rozszerzenia:

az extension update --name hpc-cache

Rejestrowanie flagi funkcji StorageCache

Zarejestruj dostawcę zasobów Microsoft.StorageCache przy użyciu az provider register polecenia .

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

Wyświetlenie stanu Zarejestrowane trwa kilka minut. Sprawdź stan rejestracji przy użyciu polecenia az feature show :

az feature show --namespace "Microsoft.StorageCache"

Tworzenie pamięci podręcznej Azure HPC Cache

Pobierz grupę zasobów węzła przy użyciu az aks show polecenia z parametrem --query nodeResourceGroup zapytania.
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:
```
MC_myResourceGroup_myAKSCluster_eastus
```

Utwórz dedykowaną podsieć usługi HPC Cache przy użyciu az network vnet subnet create polecenia . Najpierw zdefiniuj zmienne środowiskowe dla RESOURCE_GROUP, VNET_NAME, VNET_IDi SUBNET_NAME. Skopiuj dane wyjściowe z poprzedniego kroku dla RESOURCE_GROUPparametru i określ wartość parametru 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

Utwórz pamięć podręczną HPC Cache w tej samej grupie zasobów i regionie węzła. Najpierw zdefiniuj zmienną środowiskową SUBNET_ID.
```
SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
```
Utwórz pamięć podręczną HPC Cache przy użyciu az hpc-cache create polecenia . Poniższy przykład tworzy pamięć podręczną HPC Cache w regionie Wschodnie stany USA z typem pamięci podręcznej 2G w warstwie Standardowa o nazwie MyHpcCache. Określ wartość parametru --location, --sku-name i --name.
```
az hpc-cache create \
  --resource-group $RESOURCE_GROUP \
  --cache-size-gb "3072" \
  --location eastus \
  --subnet $SUBNET_ID \
  --sku-name "Standard_2G" \
  --name MyHpcCache
```
Uwaga

Tworzenie pamięci podręcznej HPC Cache może potrwać do 20 minut.

Tworzenie i konfigurowanie usługi Azure Storage

Utwórz konto magazynu przy użyciu az storage account create polecenia . Najpierw zdefiniuj zmienną środowiskową STORAGE_ACCOUNT_NAME.

Ważne

Musisz wybrać unikatową nazwę konta magazynu. Zastąp uniquestorageaccount element określoną nazwą. Nazwy kont magazynu muszą mieć długość od 3 do 24 znaków i mogą zawierać tylko cyfry i małe litery.
```
STORAGE_ACCOUNT_NAME=uniquestorageaccount
```
Poniższy przykład tworzy konto magazynu w regionie Wschodnie stany USA z Standard_LRS sku. Określ wartość parametru --location i --sku.
```
az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location eastus \
  --sku Standard_LRS
```

Przypisz rolę Współautor danych obiektu blob usługi Storage w subskrypcji przy użyciu az role assignment create polecenia . Najpierw zdefiniuj zmienne STORAGE_ACCOUNT_ID środowiskowe i 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

Utwórz kontener obiektów blob na koncie magazynu przy użyciu az storage container create polecenia . Najpierw zdefiniuj zmienną środowiskową CONTAINER_NAME i zastąp nazwę kontenera obiektów blob.
```
CONTAINER_NAME=mystoragecontainer
```
```
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
```

Podaj uprawnienia do konta usługi Azure HPC Cache w celu uzyskania dostępu do konta magazynu i kontenera obiektów blob przy użyciu az role assignment poleceń . Najpierw zdefiniuj zmienne HPC_CACHE_USER środowiskowe i 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

Dodaj kontener obiektów blob do pamięci podręcznej HPC Cache jako miejsce docelowe magazynu przy użyciu az hpc-cache blob-storage-target add polecenia . W poniższym przykładzie tworzony jest kontener obiektów blob o nazwie MyStorageTarget do pamięci podręcznej HPC Cache MyHpcCache. Określ wartość parametru --name, --cache-name i --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"
```

Konfigurowanie równoważenia obciążenia klienta

Utwórz strefę usługi Azure Prywatna strefa DNS dla adresów IP skierowanych do klienta przy użyciu az network private-dns zone create polecenia . Najpierw zdefiniuj zmienną środowiskową PRIVATE_DNS_ZONE i określ nazwę strefy.
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
```
az network private-dns zone create \
  --resource-group $RESOURCE_GROUP \
  --name $PRIVATE_DNS_ZONE
```

Utwórz link DNS między strefą Prywatna strefa DNS platformy Azure i siecią wirtualną az network private-dns link vnet create przy użyciu polecenia . Zastąp wartość --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

Utwórz nazwę DNS działania okrężnego dla adresów IP skierowanych do klienta przy użyciu az network private-dns record-set a create polecenia . Najpierw zdefiniuj zmienne DNS_NAMEśrodowiskowe , HPC_MOUNTS0, HPC_MOUNTS1i HPC_MOUNTS2. Zastąp wartość właściwości 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

Tworzenie woluminu trwałego

Utwórz plik o nazwie pv-nfs.yaml , aby zdefiniować wolumin trwały, a następnie wklej następujący manifest. Zastąp wartości właściwości server i path.

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

Pobierz poświadczenia klastra Kubernetes przy użyciu az aks get-credentials polecenia .
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Utwórz wolumin trwały przy użyciu kubectl apply polecenia .
```
kubectl apply -f pv-nfs.yaml
```
Sprawdź, czy stan woluminu trwałego jest dostępny przy użyciu kubectl describe polecenia .
```
kubectl describe pv pv-nfs
```

Tworzenie trwałego oświadczenia woluminu

Utwórz plik o nazwie pvc-nfs.yamlw celu zdefiniowania trwałego oświadczenia woluminu, a następnie wklej następujący manifest.

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

Utwórz oświadczenie trwałego woluminu kubectl apply przy użyciu polecenia .
```
kubectl apply -f pvc-nfs.yaml
```
Sprawdź, czy stan trwałego oświadczenia woluminu ma wartość Powiązana przy użyciu kubectl describe polecenia .
```
kubectl describe pvc pvc-nfs
```

Instalowanie pamięci podręcznej HPC Za pomocą zasobnika

Utwórz plik o nazwie nginx-nfs.yaml , aby zdefiniować zasobnik używający trwałego oświadczenia woluminu, a następnie wklej następujący 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

Utwórz zasobnik przy użyciu kubectl apply polecenia .
```
kubectl apply -f nginx-nfs.yaml
```
Sprawdź, czy zasobnik jest uruchomiony przy użyciu kubectl describe polecenia .
```
kubectl describe pod nginx-nfs
```
Sprawdź, czy wolumin jest zainstalowany w zasobniku przy użyciu kubectl exec polecenia , aby nawiązać połączenie z zasobnikiem.
```
kubectl exec -it nginx-nfs -- sh
```
Aby sprawdzić, czy wolumin jest zainstalowany, uruchom df polecenie w formacie czytelnym dla człowieka przy użyciu --human-readable opcji (-h w skrócie).
```
df -h
```
Poniższy przykład przypomina dane wyjściowe zwrócone z polecenia :
```
Filesystem             Size  Used Avail Use% Mounted on
...
server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
...
```

Następne kroki

Aby uzyskać więcej informacji na temat usługi Azure HPC Cache, zobacz Omówienie usługi HPC Cache.
Aby uzyskać więcej informacji na temat korzystania z systemu plików NFS z usługą AKS, zobacz Ręczne tworzenie i używanie woluminu sieciowego systemu plików (NFS) Linux Server z usługą AKS.

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2024-08-02