Effettuare il provisioning dei volumi NFS di Azure NetApp Files per il servizio Azure Kubernetes

Articolo
03/25/2024

Dopo aver configurato Azure NetApp Files per il servizio Azure Kubernetes, è possibile effettuare il provisioning dei volumi di Azure NetApp Files per il servizio Azure Kubernetes.

Azure NetApp Files supporta volumi che usano NFS (NFSv3 o NFSv4.1), SMB o doppio protocollo (NFSv3 e SMB o NFSv4.1 e SMB).

Questo articolo descrive i dettagli per il provisioning di volumi NFS in modo statico o dinamico.
Per informazioni sul provisioning di volumi SMB in modo statico o dinamico, vedere Effettuare il provisioning di volumi SMB di Azure NetApp Files per il servizio Azure Kubernetes.
Per informazioni sul provisioning di volumi a doppio protocollo in modo statico, vedere Effettuare il provisioning di volumi a doppio protocollo di Azure NetApp Files per il servizio Azure Kubernetes

Configurazione in modo statico per le applicazioni che usano volumi NFS

Questa sezione descrive come creare un volume NFS su Azure NetApp Files ed esporre il volume in modo statico a Kubernetes. Descrive anche come usare il volume con un'applicazione in contenitori.

Creare un volume NFS

Definire le variabili per un uso successivo. Sostituire myresourcegroup, mylocation, myaccountname, mypool1, premium , myfilepath, myvolsize, myvolname, vnetid e anfSubnetID con un valore appropriato dall'account e dall'ambiente. Il percorso file deve essere univoco all'interno di tutti gli account 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"

Creare un volume tramite il comando az netappfiles volume create. Per altre informazioni, vedere Creare un volume NFS per 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

Creare il volume permanente

Elencare i dettagli del volume usando il comando az netappfiles volume show. Sostituire le variabili con i valori appropriati dell'account e dell'ambiente Azure NetApp Files, se non definiti in un passaggio precedente.

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

L'output seguente è un esempio del comando precedente eseguito con valori reali.

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

Creare un file denominato pv-nfs.yaml e copiarlo nel codice YAML seguente. Assicurarsi che il server corrisponda all'indirizzo IP di output del passaggio 1 e che il percorso corrisponda all'output precedente creationToken. La capacità deve corrispondere anche alle dimensioni del volume del passaggio precedente.
```
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
```
Creare il volume permanente usando il comando kubectl apply:
```
kubectl apply -f pv-nfs.yaml
```
Verificare che lo stato del volume permanente sia Disponibile usando il comando kubectl describe:
```
kubectl describe pv pv-nfs
```

Creare un'attestazione di volume permanente

Creare un file denominato pvc-nfs.yaml e copiarlo nel codice YAML seguente. Questo manifesto crea un PVC denominato pvc-nfs per la modalità di archiviazione 100Gi e di accesso ReadWriteMany, corrispondente al volume permanente creato.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi
```
Creare l'attestazione di volume permanente usando il comando kubectl apply:
```
kubectl apply -f pvc-nfs.yaml
```
Verificare che lo Stato dell’attestazione di volume permanente sia Associato usando il comando kubectl describe:
```
kubectl describe pvc pvc-nfs
```

Montaggio con un pod

Creare un file denominato nginx-nfs.yaml e copiarlo nel codice YAML seguente. Questo manifesto definisce un pod nginx che usa l'attestazione di volume permanente.

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

Creare il pod usando il comando kubectl apply:
```
kubectl apply -f nginx-nfs.yaml
```
Verificare che il pod sia In esecuzione usando il comando kubectl describe:
```
kubectl describe pod nginx-nfs
```

Verificare che il volume sia stato montato nel pod usando kubectl exec per connettersi al pod, quindi usare df -h per verificare se il volume è montato.

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
...

Configurazione in modo dinamico per le applicazioni che usano volumi NFS

Astra Trident può essere usato per effettuare dinamicamente il provisioning di file NFS o SMB in Azure NetApp Files. I volumi SMB con provisioning dinamico sono supportati solo con i nodi di lavoro di Windows.

Questa sezione descrive come usare Astra Trident per creare in modo dinamico un volume NFS in Azure NetApp Files e montarlo automaticamente in un'applicazione in contenitori.

Installare Astra Trident

Per effettuare il provisioning dinamico dei volumi NFS, è necessario installare Astra Trident. Astra Trident è lo strumento di provisioning di archiviazione dinamico di NetApp progettato per Kubernetes. Semplificare l'utilizzo dell’archiviazione per le applicazioni Kubernetes usando il driver Container Storage Interface (CSI) standard del settore di Astra Trident. Astra Trident distribuisce nei cluster Kubernetes come pod e fornisce servizi di orchestrazione dell'archiviazione dinamica per i carichi di lavoro Kubernetes.

Trident può essere installato usando l'operatore Trident (manualmente o tramite Helm) o tridentctl. Per altre informazioni su questi metodi di installazione e sul loro funzionamento, vedere la Guida all'installazione di Astra Trident.

Installare Astra Trident con Helm

Helm deve essere installato nella workstation per installare Astra Trident usando questo metodo. Per altri metodi di installazione di Astra Trident, vedere la Guida all'installazione di Astra Trident.

Per installare Astra Trident con Helm per un cluster con solo nodi di lavoro Linux, eseguire i comandi seguenti:

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

L'output del comando è simile all'esempio seguente:

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

Per verificare che Astra Trident sia stato installato correttamente, eseguire il comando kubectl describe seguente:

kubectl describe torc trident

L'output del comando è simile all'esempio seguente:

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

Creare un back-end

Per indicare ad Astra Trident la sottoscrizione di Azure NetApp Files e dove deve creare volumi, viene creato un back-end. Questo passaggio richiede informazioni dettagliate sull'account creato in un passaggio precedente.

Creare un file denominato backend-secret.yaml e copiarlo nel codice YAML seguente. Modificare Client ID e clientSecret con i valori specifici del proprio ambiente.

apiVersion: v1
kind: Secret
metadata:
  name: backend-tbc-anf-secret
type: Opaque
stringData:
  clientID: abcde356-bf8e-fake-c111-abcde35613aa
  clientSecret: rR0rUmWXfNioN1KhtHisiSAnoTherboGuskey6pU

Creare un file denominato backend-anf.yaml e copiarlo nel codice YAML seguente. Modificare subscriptionID, tenantID, location e serviceLevel con i valori specifici del proprio ambiente. Usare subscriptionID per la sottoscrizione di Azure in cui è abilitato Azure NetApp Files. Ottenere tenantID, clientID e clientSecret da una registrazione dell'applicazione in Microsoft Entra ID con autorizzazioni sufficienti per il servizio Azure NetApp Files. La registrazione dell'applicazione include il ruolo Proprietario o Collaboratore predefinito da Azure. Il percorso deve essere un percorso di Azure che contiene almeno una subnet delegata creata in un passaggio precedente. serviceLevel deve corrispondere all'oggetto serviceLevel configurato per il pool di capacità in Configurare Azure NetApp Files per i carichi di lavoro del servizio Azure Kubernetes.
```
apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-tbc-anf
spec:
  version: 1
  storageDriverName: azure-netapp-files
  subscriptionID: 12abc678-4774-fake-a1b2-a7abcde39312
  tenantID: a7abcde3-edc1-fake-b111-a7abcde356cf
  location: eastus
  serviceLevel: Premium
  credentials:
    name: backend-tbc-anf-secret
```
Per altre informazioni sui back-end, vedere Opzioni ed esempi di configurazione back-end di Azure NetApp Files.
Applicare il segreto e il back-end usando il comando kubectl apply. Applicare prima di tutto il segreto:
```
kubectl apply -f backend-secret.yaml -n trident
```
L'output del comando è simile all'esempio seguente:
```
secret/backend-tbc-anf-secret created
```
Applicare il back-end:
```
kubectl apply -f backend-anf.yaml -n trident
```
L'output del comando è simile all'esempio seguente:
```
tridentbackendconfig.trident.netapp.io/backend-tbc-anf created
```

Verificare che il back-end sia stato creato usando il comando kubectl get:

 kubectl get tridentbackends -n trident

L'output del comando è simile all'esempio seguente:

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

Creare una classe di archiviazione

Una classe di archiviazione viene usata per definire la creazione dinamica di un'unità di archiviazione con un volume permanente. Per usare i volumi di Azure NetApp Files, è necessario creare una classe di archiviazione.

Creare un file denominato anf-storageclass.yaml e copiarlo nel codice YAML seguente:

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

Creare la classe di archiviazione usando il comando kubectl apply:
```
kubectl apply -f anf-storageclass.yaml
```
L'output del comando è simile all'esempio seguente:
```
storageclass/azure-netapp-files created
```

Eseguire il comando kubectl get per visualizzare lo stato della classe di archiviazione:

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

Creare un’attestazione di volume permanente

Una richiesta di volume permanente è una richiesta di spazio di archiviazione da parte di un utente. Dopo la creazione di un'attestazione di volume permanente, Astra Trident crea automaticamente un volume di Azure NetApp Files e lo rende disponibile per l'utilizzo dei carichi di lavoro Kubernetes.

Creare un file denominato anf-pvc.yaml e copiarlo nel codice YAML seguente. In questo esempio è necessario un volume di 1 TiB con l'accesso ReadWriteMany.

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

Creare l'attestazione di volume permanente con il comando kubectl apply:
```
kubectl apply -f anf-pvc.yaml
```
L'output del comando è simile all'esempio seguente:
```
persistentvolumeclaim/anf-pvc created
```

Per visualizzare informazioni sull'attestazione del volume permanente, eseguire il comando kubectl get:

kubectl get pvc

L'output del comando è simile all'esempio seguente:

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

Usare il volume permanente

Dopo aver creato l’attestazione del volume permanente, Astra Trident crea il volume permanente. È possibile attivare un pod per montare e accedere al volume di Azure NetApp Files.

Il manifesto seguente può essere usato per definire un pod NGINX che monta il volume di Azure NetApp Files creato nel passaggio precedente. In questo esempio il volume viene montato in /mnt/data.

Creare un file denominato anf-nginx-pod.yaml e copiarlo nel codice YAML seguente:

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

Creare il pod usando il comando kubectl apply:

kubectl apply -f anf-nginx-pod.yaml

L'output del comando è simile all'esempio seguente:

pod/nginx-pod created

Kubernetes ha creato un pod con il volume montato e accessibile all'interno del contenitore nginx all'indirizzo /mnt/data. È possibile confermare controllando i registri eventi per il pod con il comando kubectl describe:

kubectl describe pod nginx-pod

L'output del comando è simile all'esempio seguente:

[...]
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

Passaggi successivi

Astra Trident supporta molte funzionalità con Azure NetApp Files. Per altre informazioni, vedi:

Share via

Effettuare il provisioning dei volumi NFS di Azure NetApp Files per il servizio Azure Kubernetes

Configurazione in modo statico per le applicazioni che usano volumi NFS

Creare un volume NFS

Creare il volume permanente

Creare un'attestazione di volume permanente

Montaggio con un pod

Configurazione in modo dinamico per le applicazioni che usano volumi NFS

Installare Astra Trident

Installare Astra Trident con Helm

Creare un back-end

Creare una classe di archiviazione

Creare un’attestazione di volume permanente

Usare il volume permanente

Passaggi successivi

Risorse aggiuntive