Integrar o Cache HPC do Azure com o Serviço Kubernetes do Azure (AKS)

Artigo
11/01/2024

O Azure HPC Cache acelera o acesso aos dados para tarefas de computação de elevado desempenho (HPC). Ao colocar os ficheiros em cache no Azure, o Azure HPC Cache traz a escalabilidade da computação na cloud para o fluxo de trabalho existente. Este artigo mostra como integrar o Cache HPC do Azure ao Serviço Kubernetes do Azure (AKS).

Antes de começar

O cluster AKS deve estar em uma região que ofereça suporte ao Cache HPC do Azure.
Você precisa da CLI do Azure versão 2.7 ou posterior. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).
Registe a hpc-cache extensão na sua subscrição do Azure. Para obter mais informações sobre como usar o Cache HPC com a CLI do Azure, consulte os pré-requisitos da CLI do Cache HPC.
Analise os pré-requisitos do cache HPC. Você precisa satisfazer o seguinte antes de executar um cache HPC:
- O cache requer uma sub-rede dedicada com pelo menos 64 endereços IP disponíveis.
- A sub-rede não deve hospedar outras VMs ou contêineres.
- A sub-rede deve ser acessível a partir dos nós AKS.
Se você precisar executar seu aplicativo como um usuário sem acesso root, talvez seja necessário desabilitar o esmagamento de raiz usando o comando change owner (chown) para alterar a propriedade do diretório para outro usuário. O usuário sem acesso root precisa possuir um diretório para acessar o sistema de arquivos. Para que o usuário possua um diretório, o usuário raiz deve chown um diretório para esse usuário, mas se o cache HPC estiver esmagando root, essa operação será negada porque o usuário root (UID 0) está sendo mapeado para o usuário anônimo. Para obter mais informações sobre esmagamento raiz e políticas de acesso para cliente, consulte Políticas de acesso ao cache HPC.

Instalar a extensão da CLI do `hpc-cache` Azure

Importante

Os recursos de visualização do AKS estão disponíveis em uma base de autosserviço e opt-in. As visualizações prévias são fornecidas "como estão" e "conforme disponíveis" e são excluídas dos contratos de nível de serviço e da garantia limitada. As visualizações do AKS são parcialmente cobertas pelo suporte ao cliente com base no melhor esforço. Como tal, estas funcionalidades não se destinam a utilização em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

Para instalar a extensão hpc-cache, execute o seguinte comando:

az extension add --name hpc-cache

Execute o seguinte comando para atualizar para a versão mais recente da extensão lançada:

az extension update --name hpc-cache

Registrar o sinalizador do recurso StorageCache

Registre o provedor de recursos Microsoft.StorageCache usando o az provider register comando.

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

Leva alguns minutos para que o status mostre Registrado. Verifique o status do registro usando o comando az feature show :

az feature show --namespace "Microsoft.StorageCache"

Criar o cache HPC do Azure

Obtenha o grupo de recursos do nó usando o az aks show comando com o --query nodeResourceGroup parâmetro query.
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
Sua saída deve ser semelhante à saída de exemplo a seguir:
```
MC_myResourceGroup_myAKSCluster_eastus
```

Crie uma sub-rede dedicada de cache HPC usando o az network vnet subnet create comando. Primeiro, defina as variáveis de ambiente para RESOURCE_GROUP, VNET_NAME, VNET_ID, e SUBNET_NAME. Copie a saída da etapa anterior para RESOURCE_GROUP, e especifique um valor para 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

Crie um cache HPC no mesmo grupo de recursos de nó e região. Primeiro, defina a variável SUBNET_IDde ambiente .
```
SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
```
Crie o cache HPC usando o az hpc-cache create comando. O exemplo a seguir cria o cache HPC na região Leste dos EUA com um tipo de cache 2G padrão chamado MyHpcCache. Especifique um valor para --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

A criação do cache HPC pode levar até 20 minutos.

Criar e configurar o armazenamento do Azure

Crie uma conta de armazenamento usando o az storage account create comando. Primeiro, defina a variável STORAGE_ACCOUNT_NAMEde ambiente .

Importante

Você precisa selecionar um nome de conta de armazenamento exclusivo. Substitua uniquestorageaccount pelo nome especificado. Os nomes das contas de armazenamento devem ter entre 3 e 24 caracteres e podem conter apenas números e letras minúsculas.
```
STORAGE_ACCOUNT_NAME=uniquestorageaccount
```
O exemplo a seguir cria uma conta de armazenamento na região Leste dos EUA com o Standard_LRS SKU. Especifique um valor para --location e --sku.
```
az storage account create \
  --name $STORAGE_ACCOUNT_NAME \
  --resource-group $RESOURCE_GROUP \
  --location eastus \
  --sku Standard_LRS
```

Atribua a função de Colaborador de Dados de Blob de Armazenamento à sua assinatura usando o az role assignment create comando. Primeiro, defina as variáveis STORAGE_ACCOUNT_ID de ambiente 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

Crie o contêiner Blob dentro da conta de armazenamento usando o az storage container create comando. Primeiro, defina a variável CONTAINER_NAME de ambiente e substitua o nome do contêiner Blob.
```
CONTAINER_NAME=mystoragecontainer
```
```
az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
```

Forneça permissões à conta de serviço de Cache HPC do Azure para acessar sua conta de armazenamento e contêiner de Blob usando os az role assignment comandos. Primeiro, defina as variáveis HPC_CACHE_USER de ambiente 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

Adicione o contêiner de blob ao cache HPC como um destino de armazenamento usando o az hpc-cache blob-storage-target add comando. O exemplo a seguir cria um contêiner de blob chamado MyStorageTarget para o cache HPC MyHpcCache. Especifique um valor para --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"
```

Configurar o balanceamento de carga do cliente

Crie uma zona DNS Privada do Azure para os endereços IP voltados para o cliente usando o az network private-dns zone create comando. Primeiro, defina a variável PRIVATE_DNS_ZONE de ambiente e especifique um nome para a zona.
```
PRIVATE_DNS_ZONE="myhpccache.local"
```
```
az network private-dns zone create \
  --resource-group $RESOURCE_GROUP \
  --name $PRIVATE_DNS_ZONE
```

Crie um link DNS entre a Zona DNS Privada do Azure e a VNet usando o az network private-dns link vnet create comando. Substitua o valor por --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

Crie o nome DNS round-robin para os endereços IP voltados para o cliente usando o az network private-dns record-set a create comando. Primeiro, defina as variáveis DNS_NAMEde ambiente , HPC_MOUNTS0, HPC_MOUNTS1, e HPC_MOUNTS2. Substitua o valor da propriedade 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

Criar um volume persistente

Crie um arquivo nomeado pv-nfs.yaml para definir um volume persistente e, em seguida, cole no manifesto a seguir. Substitua os valores da propriedade 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: /

Obtenha as credenciais para seu cluster Kubernetes usando o az aks get-credentials comando.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Crie o volume persistente usando o kubectl apply comando.
```
kubectl apply -f pv-nfs.yaml
```
Verifique se o status do volume persistente está Disponível usando o kubectl describe comando.
```
kubectl describe pv pv-nfs
```

Criar a declaração de volume persistente

Crie um arquivo chamado pvc-nfs.yamlpara definir uma declaração de volume persistente e cole o manifesto a seguir.

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

Crie a declaração de volume persistente usando o kubectl apply comando.
```
kubectl apply -f pvc-nfs.yaml
```
Verifique se o status da declaração de volume persistente é Bound usando o kubectl describe comando.
```
kubectl describe pvc pvc-nfs
```

Monte o cache HPC com um pod

Crie um arquivo chamado nginx-nfs.yaml para definir um pod que usa a declaração de volume persistente e cole o manifesto a seguir.

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

Crie o pod usando o kubectl apply comando.
```
kubectl apply -f nginx-nfs.yaml
```
Verifique se o pod está em execução usando o kubectl describe comando.
```
kubectl describe pod nginx-nfs
```
Verifique se o volume está montado no pod usando o kubectl exec comando para se conectar ao pod.
```
kubectl exec -it nginx-nfs -- sh
```
Para verificar se o volume está montado, execute df em seu formato legível por humanos usando a --human-readable opção (-h para abreviar).
```
df -h
```
O exemplo a seguir é semelhante à saída retornada do comando:
```
Filesystem             Size  Used Avail Use% Mounted on
...
server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
...
```

Próximos passos

Para obter mais informações sobre o Cache HPC do Azure, consulte Visão geral do Cache HPC.
Para obter mais informações sobre como usar NFS com AKS, consulte Criar e usar manualmente um volume de servidor Linux NFS (Network File System) com AKS.

Partilhar via

Integrar o Cache HPC do Azure com o Serviço Kubernetes do Azure (AKS)

Antes de começar

Instalar a extensão da CLI do `hpc-cache` Azure

Registrar o sinalizador do recurso StorageCache

Criar o cache HPC do Azure

Criar e configurar o armazenamento do Azure

Configurar o balanceamento de carga do cliente

Criar um volume persistente

Criar a declaração de volume persistente

Monte o cache HPC com um pod

Próximos passos

Recursos adicionais

Partilhar via

Integrar o Cache HPC do Azure com o Serviço Kubernetes do Azure (AKS)

Antes de começar

Instalar a extensão da CLI do hpc-cache Azure

Registrar o sinalizador do recurso StorageCache

Criar o cache HPC do Azure

Criar e configurar o armazenamento do Azure

Configurar o balanceamento de carga do cliente

Criar um volume persistente

Criar a declaração de volume persistente

Monte o cache HPC com um pod

Próximos passos

Recursos adicionais

Instalar a extensão da CLI do `hpc-cache` Azure