Aprovisionamiento de volúmenes NFS de Azure NetApp Files para Azure Kubernetes Service

Artículo
08/02/2024

Después de configurar Azure NetApp Files para Azure Kubernetes Service, puede aprovisionar volúmenes de Azure NetApp Files para Azure Kubernetes Service.

Azure NetApp Files admite volúmenes que usen NFS (NFSv3 o NFSv4.1), SMB o el protocolo dual (NFSv3 y SMB, o NFSv4.1 y SMB).

En este artículo se describen los detalles del aprovisionamiento de volúmenes NFS de forma estática o dinámica.
Para obtener información sobre el aprovisionamiento de volúmenes SMB de forma estática o dinámica, consulte Aprovisionamiento de volúmenes SMB de Azure NetApp Files para Azure Kubernetes Service.
Para obtener información sobre el aprovisionamiento de volúmenes de protocolo dual de forma estática, consulte Aprovisionamiento de volúmenes de protocolo dual de Azure NetApp Files para Azure Kubernetes Service

Configuración estática para aplicaciones que usan volúmenes NFS

En esta sección se describe cómo crear un volumen NFS en Azure NetApp Files y exponer el volumen estáticamente a Kubernetes. También se describe cómo usar el volumen con una aplicación contenedorizada.

Creación de un volumen NFS

Definición de algunas variables para su uso posterior. Reemplace myresourcegroup, mylocation, myaccountname, mypool1, premium, myfilepath, myvolsize, myvolname, vnetid y anfSubnetID por un valor adecuado de su cuenta y entorno. La ruta de acceso de archivo debe ser única dentro de todas las cuentas de ANF.

RESOURCE_GROUP="myresourcegroup"
LOCATION="mylocation"
ANF_ACCOUNT_NAME="myaccountname"
POOL_NAME="mypool1"
SERVICE_LEVEL="premium" # Valid values are Standard, Premium, and Ultra
UNIQUE_FILE_PATH="myfilepath"
VOLUME_SIZE_GIB="myvolsize"
VOLUME_NAME="myvolname"
VNET_ID="vnetId"
SUBNET_ID="anfSubnetId"

Cree un volumen mediante el comando az netappfiles volume create. Para más información, consulte Creación de un volumen de NFS para Azure NetApp Files.

az netappfiles volume create \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --account-name $ANF_ACCOUNT_NAME \
    --pool-name $POOL_NAME \
    --name "$VOLUME_NAME" \
    --service-level $SERVICE_LEVEL \
    --vnet $VNET_ID \
    --subnet $SUBNET_ID \
    --usage-threshold $VOLUME_SIZE_GIB \
    --file-path $UNIQUE_FILE_PATH \
    --protocol-types NFSv3

Creación del volumen persistente

Enumere los detalles de su volumen mediante el comando az netappfiles volume show. Reemplace las variables por los valores adecuados de la cuenta y el entorno de Azure NetApp Files si no se define en un paso anterior.

az netappfiles volume show \
    --resource-group $RESOURCE_GROUP \
    --account-name $ANF_ACCOUNT_NAME \
    --pool-name $POOL_NAME \
    --volume-name "$VOLUME_NAME -o JSON

La siguiente salida es un ejemplo del comando anterior ejecutado con valores reales.

{
  ...
  "creationToken": "myfilepath2",
  ...
  "mountTargets": [
    {
      ...
      "ipAddress": "10.0.0.4",
      ...
    }
  ],
  ...
}

Cree un archivo denominado pv-nfs.yaml y cópielo en el siguiente código YAML. Asegúrese de que el servidor coincide con la dirección IP de salida del paso 1, y de que la ruta de acceso coincide con la salida anterior de creationToken. La capacidad también debe coincidir con el tamaño del volumen del paso anterior.
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-nfs
spec:
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  mountOptions:
    - vers=3
  nfs:
    server: 10.0.0.4
    path: /myfilepath2
```
Cree el volumen persistente con el comando kubectl apply:
```
kubectl apply -f pv-nfs.yaml
```
Compruebe que el estado del volumen persistente esté Disponible mediante el comando kubectl describe:
```
kubectl describe pv pv-nfs
```

Creación de una notificación de volumen persistente

Cree un archivo denominado pvc-nfs.yaml y cópielo en el siguiente código YAML. Este manifiesto crea un PVC denominado pvc-nfs para un almacenamiento de 100Gi y el modo de acceso ReadWriteMany, que coincide con el PV que creó.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi
```
Cree la notificación del volumen persistente con el comando kubectl apply:
```
kubectl apply -f pvc-nfs.yaml
```
Compruebe que el Estado de la notificación de volumen persistente es Enlazado mediante el comando kubectl describe:
```
kubectl describe pvc pvc-nfs
```

Montaje con un pod

Cree un archivo denominado nginx-nfs.yaml y cópielo en el siguiente código YAML. Este manifiesto define un pod nginx que usa la notificación de volumen persistente.

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/outfile; sleep 1; done
    volumeMounts:
    - name: disk01
      mountPath: /mnt/azure
  volumes:
  - name: disk01
    persistentVolumeClaim:
      claimName: pvc-nfs

Cree el pod mediante el comando kubectl apply:
```
kubectl apply -f nginx-nfs.yaml
```
Compruebe que el pod está En ejecución mediante el comando kubectl describe:
```
kubectl describe pod nginx-nfs
```

Compruebe que su volumen se ha montado en el pod mediante kubectl exec para conectarse a pod y, luego, df -h para comprobar que el volumen está montado.

kubectl exec -it nginx-nfs -- sh

/ # df -h
Filesystem             Size  Used Avail Use% Mounted on
...
10.0.0.4:/myfilepath2  100T  384K  100T   1% /mnt/azure
...

Configuración dinámica para aplicaciones que usan volúmenes NFS

Astra Trident se puede usar para aprovisionar dinámicamente archivos NFS o SMB en Azure NetApp Files. Los volúmenes SMB aprovisionados dinámicamente solo se admiten con nodos de trabajo de Windows.

En esta sección se describe cómo usar Astra Trident para crear dinámicamente un volumen NFS en Azure NetApp Files y montarlo automáticamente en una aplicación contenedorizada.

Instalación de Astra Trident

Para aprovisionar volúmenes NFS de forma dinámica, debe instalar Astra Trident. Astra Trident es el aprovisionador de almacenamiento dinámico de NetApp que está diseñado para Kubernetes. Simplifique el consumo de almacenamiento para aplicaciones de Kubernetes mediante el controlador Container Storage Interface (CSI) estándar del sector de Astra Trident. Astra Trident se implementa en clústeres de Kubernetes como pods y proporciona servicios de orquestación de almacenamiento dinámico para las cargas de trabajo de Kubernetes.

Trident se puede instalar mediante el operador Trident (manualmente o con Helm) o tridentctl. Para más información sobre estos métodos de instalación y cómo funcionan, consulte la Guía de instalación de Astra Trident.

Instalación de Astra Trident mediante Helm

Helm debe estar instalado en la estación de trabajo para instalar Astra Trident mediante este método. Para conocer otros métodos de instalación de Astra Trident, consulte la Guía de instalación de Astra Trident.

Para instalar Astra Trident mediante Helm para un clúster con solo nodos de trabajo de Linux, ejecute los siguientes comandos:

helm repo add netapp-trident https://netapp.github.io/trident-helm-chart   
helm install trident netapp-trident/trident-operator --version 23.04.0  --create-namespace --namespace trident

La salida del comando es similar al ejemplo siguiente:

NAME: trident
LAST DEPLOYED: Fri May  5 13:55:36 2023
NAMESPACE: trident
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
Thank you for installing trident-operator, which will deploy and manage NetApp's Trident CSI storage provisioner for Kubernetes.

Your release is named 'trident' and is installed into the 'trident' namespace.
Please note that there must be only one instance of Trident (and trident-operator) in a Kubernetes cluster.

To configure Trident to manage storage resources, you will need a copy of tridentctl, which is available in pre-packaged Trident releases.  You may find all Trident releases and source code online at https://github.com/NetApp/trident. 

To learn more about the release, try:

    $ helm status trident
      $ helm get all trident

Para confirmar que Astra Trident se instaló correctamente, ejecute el siguiente comando kubectl describe:

kubectl describe torc trident

La salida del comando es similar al ejemplo siguiente:

Name:         trident
Namespace:    
Labels:       app.kubernetes.io/managed-by=Helm
Annotations:  meta.helm.sh/release-name: trident
              meta.helm.sh/release-namespace: trident
API Version:  trident.netapp.io/v1
Kind:         TridentOrchestrator
Metadata:
    ...
Spec:
  IPv6:                  false
  Autosupport Image:     docker.io/netapp/trident-autosupport:23.04
  Autosupport Proxy:     <nil>
  Disable Audit Log:     true
  Enable Force Detach:   false
  Http Request Timeout:  90s
  Image Pull Policy:     IfNotPresent
  k8sTimeout:            0
  Kubelet Dir:           <nil>
  Log Format:            text
  Log Layers:            <nil>
  Log Workflows:         <nil>
  Namespace:             trident
  Probe Port:            17546
  Silence Autosupport:   false
  Trident Image:         docker.io/netapp/trident:23.04.0
  Windows:               false
Status:
  Current Installation Params:
    IPv6:                       false
    Autosupport Hostname:       
    Autosupport Image:          docker.io/netapp/trident-autosupport:23.04
    Autosupport Proxy:          
    Autosupport Serial Number:  
    Debug:                      false
    Disable Audit Log:          true
    Enable Force Detach:        false
    Http Request Timeout:       90s
    Image Pull Policy:          IfNotPresent
    Image Pull Secrets:
    Image Registry:       
    k8sTimeout:           30
    Kubelet Dir:          /var/lib/kubelet
    Log Format:           text
    Log Layers:           
    Log Level:            info
    Log Workflows:        
    Probe Port:           17546
    Silence Autosupport:  false
    Trident Image:        docker.io/netapp/trident:23.04.0
  Message:                Trident installed
  Namespace:              trident
  Status:                 Installed
  Version:                v23.04.0
Events:
  Type    Reason      Age    From                        Message
  ----    ------      ----   ----                        -------
  Normal  Installing  2m59s  trident-operator.netapp.io  Installing Trident
  Normal  Installed   2m31s  trident-operator.netapp.io  Trident installed

Crear un back-end

Para indicar a Astra Trident la suscripción de Azure NetApp Files y dónde debe crear los volúmenes, se crea un back-end. Este paso requiere detalles sobre la cuenta que se creó en el paso anterior.

Cree un archivo denominado backend-secret.yaml y cópielo en el siguiente código YAML. Cambie Client ID y clientSecret a los valores correctos para su entorno.

apiVersion: v1
kind: Secret
metadata:
  name: backend-tbc-anf-secret
type: Opaque
stringData:
  clientID: 00001111-aaaa-2222-bbbb-3333cccc4444
  clientSecret: rR0rUmWXfNioN1KhtHisiSAnoTherboGuskey6pU

Cree un archivo denominado backend-anf.yaml y cópielo en el siguiente código YAML. Cambie subscriptionID, tenantID, location y serviceLevel a los valores correctos para su entorno. Use subscriptionID para la suscripción de Azure donde se habilitará Azure NetApp Files. Obtenga tenantID, clientID y clientSecret desde un registro de aplicación en Microsoft Entra ID con permisos suficientes para el servicio Azure NetApp Files. El registro de la aplicación incluye el rol Propietario o Colaborador predefinido por Azure. La ubicación debe ser una ubicación de Azure que contenga al menos una subred delegada creada en un paso anterior. serviceLevel debe coincidir con el serviceLevel configurado para el grupo de capacidad en Configuración de Azure NetApp Files para cargas de trabajo de AKS.
```
apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-tbc-anf
spec:
  version: 1
  storageDriverName: azure-netapp-files
  subscriptionID: aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e
  tenantID: aaaabbbb-0000-cccc-1111-dddd2222eeee
  location: eastus
  serviceLevel: Premium
  credentials:
    name: backend-tbc-anf-secret
```
Para más información sobre los back-end, consulte Opciones y ejemplos de configuración de back-end en Azure NetApp Files.
Aplique el secreto y el back-end mediante el comando kubectl apply. En primer lugar, aplique el secreto:
```
kubectl apply -f backend-secret.yaml -n trident
```
La salida del comando es similar al ejemplo siguiente:
```
secret/backend-tbc-anf-secret created
```
Aplique el back-end:
```
kubectl apply -f backend-anf.yaml -n trident
```
La salida del comando es similar al ejemplo siguiente:
```
tridentbackendconfig.trident.netapp.io/backend-tbc-anf created
```

Confirme que el back-end se creó mediante el comando kubectl get:

 kubectl get tridentbackends -n trident

La salida del comando es similar al ejemplo siguiente:

NAME        BACKEND               BACKEND UUID
tbe-kfrdh   backend-tbc-anf   8da4e926-9dd4-4a40-8d6a-375aab28c566

Creación de una clase de almacenamiento

Una clase de almacenamiento se usa para definir cómo se crea dinámicamente una unidad de almacenamiento con un volumen persistente. Para utilizar volúmenes de Azure NetApp Files, se debe crear una clase de almacenamiento.

Cree un archivo denominado anf-storageclass.yaml y cópielo en el siguiente código YAML:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azure-netapp-files
provisioner: csi.trident.netapp.io
parameters:
  backendType: "azure-netapp-files"
  fsType: "nfs"

Cree la clase de almacenamiento con el comando kubectl apply:
```
kubectl apply -f anf-storageclass.yaml
```
La salida del comando es similar al ejemplo siguiente:
```
storageclass/azure-netapp-files created
```

Ejecute el comando kubectl get para ver el estado de la clase de almacenamiento:

kubectl get sc
NAME                 PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
azure-netapp-files   csi.trident.netapp.io   Delete          Immediate           false

Creación de un PVC

Una reclamación de volumen persistente (PVC) es una solicitud de almacenamiento realizada por un usuario. Tras la creación de una clase notificación de volumen persistente, Astra Trident crea automáticamente un volumen de Azure NetApp Files y lo pone a disposición para su consumo por las cargas de trabajo de Kubernetes.

Cree un archivo denominado anf-pvc.yaml y cópielo en el siguiente código YAML. En este ejemplo, hace falta un volumen de 1 TiB con acceso ReadWriteMany.

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: anf-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1Ti
  storageClassName: azure-netapp-files

Cree la notificación del volumen persistente con el comando kubectl apply:
```
kubectl apply -f anf-pvc.yaml
```
La salida del comando es similar al ejemplo siguiente:
```
persistentvolumeclaim/anf-pvc created
```

Para ver información sobre la notificación de volumen persistente, ejecute el comando kubectl get:

kubectl get pvc

La salida del comando es similar al ejemplo siguiente:

kubectl get pvc -n trident
NAME      STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS         AGE
anf-pvc   Bound    pvc-bffa315d-3f44-4770-86eb-c922f567a075   1Ti        RWO            azure-netapp-files   62s

Uso del volumen persistente

Una vez creado el PVC, Astra Trident crea el volumen persistente. Se puede activar un pod para montar y acceder al volumen de Azure NetApp Files.

El manifiesto siguiente se puede usar para definir un pod NGINX que monte el volumen de Azure NetApp Files que se creó en el paso anterior. En este ejemplo, el volumen se monta en /mnt/data.

Cree un archivo denominado anf-nginx-pod.yaml y cópielo en el siguiente código YAML:

kind: Pod
apiVersion: v1
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx
    image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 250m
        memory: 256Mi
    volumeMounts:
    - mountPath: "/mnt/data"
      name: volume
  volumes:
    - name: volume
      persistentVolumeClaim:
        claimName: anf-pvc

Cree el pod mediante el comando kubectl apply:

kubectl apply -f anf-nginx-pod.yaml

La salida del comando es similar al ejemplo siguiente:

pod/nginx-pod created

Kubernetes ha creado ahora un pod con el volumen montado y accesible dentro del contenedor nginx en /mnt/data. Para confirmarlo, compruebe los registros de eventos del pod mediante el comando kubectl describe:

kubectl describe pod nginx-pod

La salida del comando es similar al ejemplo siguiente:

[...]
Volumes:
  volume:
    Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:  anf-pvc
    ReadOnly:   false
  default-token-k7952:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-k7952
    Optional:    false
[...]
Events:
  Type    Reason                  Age   From                     Message
  ----    ------                  ----  ----                     -------
  Normal  Scheduled               15s   default-scheduler        Successfully assigned trident/nginx-pod to brameshb-non-root-test
  Normal  SuccessfulAttachVolume  15s   attachdetach-controller  AttachVolume.Attach succeeded for volume "pvc-bffa315d-3f44-4770-86eb-c922f567a075"
  Normal  Pulled                  12s   kubelet                  Container image "mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine" already present on machine
  Normal  Created                 11s   kubelet                  Created container nginx
  Normal  Started                 10s   kubelet                  Started container nginx

Pasos siguientes

Astra Trident admite muchas características con Azure NetApp Files. Para más información, consulte:

Compartir vía

Aprovisionamiento de volúmenes NFS de Azure NetApp Files para Azure Kubernetes Service

Configuración estática para aplicaciones que usan volúmenes NFS

Creación de un volumen NFS

Creación del volumen persistente

Creación de una notificación de volumen persistente

Montaje con un pod

Configuración dinámica para aplicaciones que usan volúmenes NFS

Instalación de Astra Trident

Instalación de Astra Trident mediante Helm

Crear un back-end

Creación de una clase de almacenamiento

Creación de un PVC

Uso del volumen persistente

Pasos siguientes

Recursos adicionales