Leer en inglés

Compartir a través de


Integración de Azure HPC Cache con Azure Kubernetes Service (AKS)

Azure HPC Cache acelera el acceso a los datos para las tareas de informática de alto rendimiento (HPC). Mediante el almacenamiento en caché de archivos en Azure, Azure HPC Cache aporta la escalabilidad de la informática en la nube al flujo de trabajo existente. En este artículo se le muestra cómo integrar Azure HPC Cache con Azure Kubernetes Service (AKS).

Antes de empezar

  • El clúster de AKS debe estar en una región que admita Azure HPC Cache.

  • Necesita la versión 2.7 o posterior de la CLI de Azure. Ejecute az --version para encontrar la versión. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.

  • Registre la extensión hpc-cache en la suscripción de Azure. Para más información sobre el uso de HPC Cache con la CLI de Azure, consulte los Requisitos previos de la CLI para HPC Cache.

  • Requisitos previos para HPC Cache. Debe satisfacer lo siguiente para poder ejecutar una instancia de HPC Cache:

    • La memoria caché requiere una subred dedicada con al menos 64 direcciones IP disponibles.
    • La subred no debe hospedar otras máquinas virtuales o contenedores.
    • La subred debe ser accesible desde los nodos de AKS.
  • Si necesita ejecutar la aplicación como usuario sin acceso raíz, es posible que deba deshabilitar la squash raíz mediante el comando change owner (chown) para cambiar la propiedad del directorio a otro usuario. El usuario sin acceso raíz debe poseer un directorio para acceder al sistema de archivos. Para que el usuario sea propietario de un directorio, el usuario raíz debe asignar un directorio a ese usuario, pero si la instancia de HPC Cache está suprimiendo al usuario raíz, esta operación se deniega porque el usuario raíz (UID 0) se está asignando al usuario anónimo. Para obtener más información sobre las directivas de acceso de cliente y de supresión del usuario raíz, consulte directivas de acceso de HPC Cache.

Instalación de la extensión de la CLI de Azure hpc-cache

Importante

Las características en versión preliminar de AKS están disponibles como opción de participación y autoservicio. Las versiones preliminares se proporcionan "tal cual" y "como están disponibles", y están excluidas de los Acuerdos de nivel de servicio y garantía limitada. Las versiones preliminares de AKS reciben cobertura parcial del soporte al cliente en la medida de lo posible. Por lo tanto, estas características no están diseñadas para su uso en producción. Para más información, consulte los siguientes artículos de soporte:

Para instalar la extensión hpc-cache, ejecute el siguiente comando:

az extension add --name hpc-cache

Ejecute el siguiente comando para actualizar a la versión más reciente de la extensión publicada:

az extension update --name hpc-cache

Registro de la marca de características StorageCache

Registre el proveedor de recursos Microsoft.StorageCache mediante el comando az provider register.

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

Tarda unos minutos en que el estado muestre Registrado. Para comprobar el estado de registro se usa el comandoaz feature show:

az feature show --namespace "Microsoft.StorageCache"

Crear la instancia de Azure HPC Cache

  1. Obtenga el grupo de recursos del nodo mediante el comando az aks show con el parámetro de consulta --query nodeResourceGroup.

    az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
    

    El resultado debería ser similar al ejemplo siguiente:

    MC_myResourceGroup_myAKSCluster_eastus
    
  2. Cree una subred de HPC Cache dedicada mediante el comando az network vnet subnet create. En primer lugar, defina las variables de entorno para RESOURCE_GROUP, VNET_NAME, VNET_ID, y SUBNET_NAME. Copie la salida del paso anterior para RESOURCE_GROUP, y especifique un 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
    
  3. Cree una instancia de HPC Cache en el mismo grupo de recursos de nodo y región. En primer lugar, defina la variable de entorno SUBNET_ID.

    SUBNET_ID=$(az network vnet subnet show --resource-group $RESOURCE_GROUP --vnet-name $VNET_NAME --name $SUBNET_NAME --query "id" -o tsv)
    

    Cree HPC Cache mediante el comando az hpc-cache create. En el ejemplo siguiente se crea HPC Cache en la región Este de EE. UU. con un tipo de caché estándar de 2G denominado MyHpcCache. Especifique un valor para --location, --sku-namey --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 creación de HPC Cache puede tardar hasta 20 minutos.

Creación y configuración de Azure Storage

  1. Cree una cuenta de almacenamiento mediante el comando az storage account create. En primer lugar, defina la variable de entorno STORAGE_ACCOUNT_NAME.

    Importante

    Tendrá que seleccionar un nombre de cuenta de almacenamiento único. Reemplace uniquestorageaccount por el nombre especificado. Los nombres de las cuentas de almacenamiento deben tener entre 3 y 24 caracteres, y solo pueden incluir números y letras en minúscula.

    STORAGE_ACCOUNT_NAME=uniquestorageaccount
    

    En el ejemplo siguiente se crea una cuenta de almacenamiento en la región Este de EE. UU. con la SKU de Standard_LRS. Especifique un valor para --location y --sku.

    az storage account create \
      --name $STORAGE_ACCOUNT_NAME \
      --resource-group $RESOURCE_GROUP \
      --location eastus \
      --sku Standard_LRS
    
  2. Asigne el Rol colaborador de datos de Blob Storage en la suscripción mediante el comando az role assignment create. En primer lugar, defina las variables de entorno STORAGE_ACCOUNT_ID y 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
    
  3. Cree el contenedor de blobs en la cuenta de almacenamiento mediante el comando az storage container create. En primer lugar, defina la variable de entorno CONTAINER_NAME y reemplace el nombre del contenedor de blobs.

    CONTAINER_NAME=mystoragecontainer
    
    az storage container create --name $CONTAINER_NAME --account-name $STORAGE_ACCOUNT_NAME --auth-mode login
    
  4. Proporcione permisos a la cuenta de servicio de Azure HPC Cache para acceder a la cuenta de almacenamiento y al contenedor de blobs mediante los comandos az role assignment. En primer lugar, defina las variables de entorno HPC_CACHE_USER y 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
    
  5. Agregue el contenedor de blobs a la instancia de HPC Cache como destino de almacenamiento mediante el comando az hpc-cache blob-storage-target add. En el ejemplo siguiente se crea un contenedor de blobs denominado MyStorageTarget en HPC Cache MyHpcCache. Especifique un valor para --name, --cache-name, y --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"
    

Configuración del equilibrio de carga del cliente

  1. Cree una zona DNS privada de Azure para las direcciones IP orientadas al cliente mediante el comando az network private-dns zone create. En primer lugar, defina la variable de entorno PRIVATE_DNS_ZONE y especifique un nombre para la zona.

    PRIVATE_DNS_ZONE="myhpccache.local"
    
    az network private-dns zone create \
      --resource-group $RESOURCE_GROUP \
      --name $PRIVATE_DNS_ZONE
    
  2. Cree un vínculo DNS entre la zona de Azure DNS privado y la red virtual mediante el comando az network private-dns link vnet create. Reemplace el valor de --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
    
  3. Cree el nombre DNS round robin para las direcciones IP orientadas al cliente mediante el comando az network private-dns record-set a create. En primer lugar, defina las variables de entorno DNS_NAME, HPC_MOUNTS0, HPC_MOUNTS1, y HPC_MOUNTS2. Reemplace el valor de la propiedad 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
    

Creación de un volumen persistente

  1. Cree un archivo denominado pv-nfs.yaml para definir un volumen persistente y, a continuación, pegue el siguiente manifiesto. Reemplace los valores de la propiedad server y path.

    ---
    apiVersion: v1
    kind: PersistentVolume
    metadata:
      name: pv-nfs
    spec:
      capacity:
        storage: 10000Gi
      accessModes:
        - ReadWriteMany
      mountOptions:
        - vers=3
      nfs:
        server: server.myhpccache.local
        path: /
    
  2. Obtenga las credenciales del clúster de Kubernetes mediante el comando az aks get-credentials.

    az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
    
  3. Cree la notificación del volumen persistente con el comando kubectl apply.

    kubectl apply -f pv-nfs.yaml
    
  4. Compruebe que el estado del volumen persistente esté Disponible mediante el comando kubectl describe.

    kubectl describe pv pv-nfs
    

Creación de la notificación de volumen persistente

  1. Cree un archivo denominado pvc-nfs.yamlpara definir una notificación de volumen persistente y, a continuación, pegue el siguiente manifiesto.

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: pvc-nfs
    spec:
      accessModes:
        - ReadWriteMany
      storageClassName: ""
      resources:
        requests:
          storage: 100Gi
    
  2. Cree la notificación del volumen persistente con el comando kubectl apply.

    kubectl apply -f pvc-nfs.yaml
    
  3. Compruebe que el estado de la notificación de volumen persistente es Enlazado mediante el comando kubectl describe.

    kubectl describe pvc pvc-nfs
    

Montaje de la instancia de HPC Cache con un pod

  1. Cree un archivo denominado nginx-nfs.yaml para definir un pod que use la notificación de volumen persistente y, a continuación, pegue el siguiente manifiesto.

    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
    
  2. Cree el pod mediante el comando kubectl apply.

    kubectl apply -f nginx-nfs.yaml
    
  3. Compruebe que el pod está en ejecución mediante el comando kubectl describe.

    kubectl describe pod nginx-nfs
    
  4. Compruebe que el volumen está montado en el pod mediante el comando kubectl exec para conectarse al pod.

    kubectl exec -it nginx-nfs -- sh
    

    Para comprobar si el volumen está montado, ejecute df en su formato legible mediante la opción --human-readable (-h para abreviar).

    df -h
    

    En el ejemplo siguiente se parece a la salida devuelta desde el comando :

    Filesystem             Size  Used Avail Use% Mounted on
    ...
    server.myhpccache.local:/myfilepath 8.0E         0      8.0E   0% /mnt/azure/myfilepath
    ...
    

Pasos siguientes