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

Artigo
08/02/2024

O Azure HPC Cache acelera o acesso às tarefas HPC (computação de alto desempenho). Ao armazenar arquivos em cache no Azure, o Azure HPC Cache traz a escalabilidade da computação em nuvem para seu fluxo de trabalho existente. Este artigo mostra como integrar o Azure HPC Cache ao AKS (Serviço de Kubernetes do Azure).

Antes de começar

O cluster do AKS deve estar em uma região compatível com o Azure HPC Cache.
Você precisa da versão 2.7 ou posterior da CLI do Azure. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.
Registre a extensão hpc-cache em sua assinatura do Azure. Para obter mais informações sobre como usar o HPC Cache com a CLI do Azure, consulte os pré-requisitos da CLI do HPC Cache.
Consulte os pré-requisitos do HPC Cache. Você precisa satisfazer o seguinte antes de executar um HPC Cache:
- 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 do AKS.
Se você precisar executar o seu aplicativo como um usuário sem acesso raiz, talvez seja necessário desabilitar o squash de raiz usando o comando proprietário da alteração (chown) para alterar a propriedade do diretório para outro usuário. O usuário sem acesso raiz precisa ter um diretório para acessar o sistema de arquivos. Para que o usuário seja proprietário de um diretório, o usuário raiz deve fazer chown de um diretório para esse usuário, mas, se o HPC Cache estiver comprimindo a raiz, essa operação será negada porque o usuário raiz (UID 0) está sendo mapeado para o usuário anônimo. Para obter mais informações sobre as políticas de acesso do cliente e de compactação da raiz, consulte Políticas de acesso ao HPC Cache.

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

Importante

As versões prévias do recurso AKS estão disponíveis em uma base de autoatendimento e aceitação. As visualizações são fornecidas "como estão" e "conforme disponíveis" e estão excluídas dos acordos de nível de serviço e da garantia limitada. As versões prévias do AKS são parcialmente cobertas pelo suporte ao cliente em uma base de melhor esforço. Dessa forma, esses recursos não são destinados ao uso em produção. Para obter mais informações, consulte os seguintes artigos:

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 de recurso StorageCache

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

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

Demora alguns minutos para o status exibir Registrado. Verifique o status do registro usando o comando az feature show:

az feature show --namespace "Microsoft.StorageCache"

Crie o Azure HPC Cache

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

Crie uma sub-rede de HPC Cache dedicada usando o comando az network vnet subnet create. 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 HPC Cache na mesma região e grupo de recursos do nó. Primeiro defina a variável de 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)
```
Crie o HPC Cache usando o comando az hpc-cache create. O exemplo a seguir cria o HPC Cache na região Leste dos EUA com um tipo de cache Standard 2G 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
```
Observação

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

Criar e configurar o armazenamento do Azure

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

Importante

É necessário 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 SKU Standard_LRS. 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 do blob de armazenamento em sua assinatura usando o comando az role assignment create. Primeiro, defina as variáveis de 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

Crie o contêiner Blobs na conta de armazenamento usando o comando az storage container create. Primeiro, defina a variável de ambiente CONTAINER_NAME e substitua o nome do contêiner de 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 do Azure HPC Cache para acessar sua conta de armazenamento e o contêiner de blobs usando os comandos az role assignment. Primeiro, defina as variáveis de 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

Adicione o contêiner de blobs ao seu HPC Cache como um destino de armazenamento usando o comando az hpc-cache blob-storage-target add. O exemplo a seguir cria um contêiner de blob chamado MyStorageTarget para o HPC Cache 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 comando az network private-dns zone create. Primeiro defina a variável de ambiente PRIVATE_DNS_ZONE 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 de DNS entre a Zona de DNS Privada do Azure e a VNet usando o comando az network private-dns link vnet create. 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 comando az network private-dns record-set a create. Primeiro, defina as variáveis de ambiente DNS_NAME, 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 denominado pv-nfs.yaml para definir um volume persistente e cole o manifesto a seguir. Substitua os valores de server e path da propriedade.

---
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 do seu cluster do Kubernetes usando o comando az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Crie o volume persistente usando o comando kubectl apply.
```
kubectl apply -f pv-nfs.yaml
```
Verifique se o status do volume persistente está disponível usando o comando kubectl describe.
```
kubectl describe pv pv-nfs
```

Criar a declaração de volume persistente

Crie um arquivo denominado 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 do volume persistente usando o comando kubectl apply.
```
kubectl apply -f pvc-nfs.yaml
```
Verifique se o status da declaração de volume persistente está Associado usando o comando kubectl describe.
```
kubectl describe pvc pvc-nfs
```

Montar o HPC Cache com um pod

Crie um arquivo nomeado nginx-nfs.yaml para definir um pod que use 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 comando kubectl apply.
```
kubectl apply -f nginx-nfs.yaml
```
Verifique se o pod está em execução usando o comando kubectl describe.
```
kubectl describe pod nginx-nfs
```
Verifique se o volume está montado no pod usando o comando kubectl exec 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 opção --human-readable (-h para abreviar).
```
df -h
```
O exemplo a seguir se assemelha à 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óximas etapas

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

Compartilhar via

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

Antes de começar

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

Registrar o sinalizador de recurso StorageCache

Crie o Azure HPC Cache

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

Montar o HPC Cache com um pod

Próximas etapas

Recursos adicionais

Compartilhar via

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

Antes de começar

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

Registrar o sinalizador de recurso StorageCache

Crie o Azure HPC Cache

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

Montar o HPC Cache com um pod

Próximas etapas

Recursos adicionais

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