Approvisionner des volumes Azure NetApp Files NFS pour Azure Kubernetes Service

Article
05/25/2023

Après avoir configuré Azure NetApp Files pour Azure Kubernetes Service, vous pouvez approvisionner des volumes Azure NetApp Files pour Azure Kubernetes Service.

Azure NetApp Files prend en charge la création de volumes avec NFS (NFSv3 ou NFSv4.1), SMB ou le double protocole (NFSv3 et SMB ou NFSv4.1 et SMB).

Cet article explique comment approvisionner des volumes NFS de manière statique ou dynamique.
Pour plus d’informations sur l’approvisionnement statique ou dynamique de volumes SMB, consultez Approvisionner des volumes Azure NetApp Files SMB pour Azure Kubernetes Service.
Pour plus d’informations sur l’approvisionnement statique ou dynamique de volumes à double protocole, consultez Approvisionner des volumes Azure NetApp Files à double protocole pour Azure Kubernetes Service.

Configuration statique pour les applications utilisant des volumes NFS

Cette section explique comment créer un volume NFS sur Azure NetApp Files et l’exposer de manière statique dans Kubernetes. Elle décrit également comment utiliser le volume avec une application conteneurisée.

Créer un volume NFS

Définissez les variables pour une utilisation ultérieure. Remplacez myresourcegroup, mylocation, myaccountname, mypool1, premium, myfilepath, myvolsize, myvolname, vnetid et anfSubnetID par les valeurs appropriées de votre compte et de votre environnement. Le filepath (chemin de fichier) doit être unique dans tous les comptes 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"
```

Créez un volume à l’aide de la commande az netappfiles volume create. Pour en savoir plus, consultez Créer un volume NFS pour 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

Créez le volume persistant

Listez les détails de votre volume en utilisant la commande az netappfiles volume show Remplacez les variables par les valeurs appropriées de votre compte et de votre environnement Azure NetApp Files si vous ne les avez pas déjà définies à l’étape précédente.
```
az netappfiles volume show \
    --resource-group $RESOURCE_GROUP \
    --account-name $ANF_ACCOUNT_NAME \
    --pool-name $POOL_NAME \
    --volume-name "$VOLUME_NAME -o JSON
```
La sortie suivante est un exemple de commande ci-dessus exécutée avec des valeurs réelles.
```
{
  ...
  "creationToken": "myfilepath2",
  ...
  "mountTargets": [
    {
      ...
      "ipAddress": "10.0.0.4",
      ...
    }
  ],
  ...
}
```
Créez un fichier nommé pv-nfs.yaml et copiez-y le YAML suivant. Assurez-vous que le serveur correspond à l’adresse IP de sortie de l’étape 1 et le chemin d’accès à la sortie de creationToken ci-dessus. La capacité doit également correspondre à la taille du volume de l’étape ci-dessus.
```
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
```
Créez le volume persistant à l’aide de la commande kubectl apply.
```
kubectl apply -f pv-nfs.yaml
```
Vérifiez que l’état du volume persistant est Disponible à l’aide de la commande kubectl describe :
```
kubectl describe pv pv-nfs
```

Créer une revendication de volume persistant

Créez un fichier nommé pvc-nfs.yaml et copiez-y le YAML suivant. Ce manifeste crée un PVC nommé pvc-nfs pour le mode de stockage 100 Gi et d’accès ReadWriteMany, correspondant au PV que vous avez créé.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi
```
Créez la revendication de volume persistant avec la commande kubectl apply :
```
kubectl apply -f pvc-nfs.yaml
```
Vérifiez que l’État de la revendication de volume persistant est Lié à l’aide de la commande kubectl describe :
```
kubectl describe pvc pvc-nfs
```

Monter avec un pod

Créez un fichier nommé nginx-nfs.yaml et copiez-y le YAML suivant. Ce manifeste définit un pod nginx qui utilise la revendication de volume persistant.

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

Créez le pod à l’aide de la commande kubectl apply :
```
kubectl apply -f nginx-nfs.yaml
```
Vérifiez que l’état du pod est En cours d’exécution à l’aide de la commande kubectl describe :
```
kubectl describe pod nginx-nfs
```

Vérifiez que votre volume a été monté dans le pod en utilisant kubectl exec pour vous connecter au pod, puis df -h pour vérifier si le volume est monté.

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

Configuration dynamique pour les applications utilisant des volumes NFS

Astra Trident peut être utilisé pour approvisionner de façon dynamique des fichiers NFS ou SMB sur Azure NetApp Files. Les volumes SMB approvisionnés de façon dynamique sont uniquement pris en charge avec les nœuds Worker Windows.

Cette section explique comment utiliser Astra Trident pour créer de façon dynamique un volume NFS sur Azure NetApp Files et le monter automatiquement sur une application conteneurisée.

Installer Astra Trident

Pour approvisionner des volumes de façon dynamique, vous devez installer Astra Trident. Astra Trident est l’approvisionneur de stockage dynamique de NetApp spécialement conçu pour Kubernetes. Simplifiez la consommation de stockage pour les applications Kubernetes en utilisant les pilotes Container Storage Interface (CSI) d’Astra Trident, conformes aux normes du secteur d’activité. Astra Trident se déploie dans les clusters Kubernetes sous forme de pods et fournit des services d’orchestration de stockage dynamique pour vos charges de travail Kubernetes.

Trident peut être installé à l’aide de l’opérateur Trident (manuellement ou à l’aide de Helm) ou tridentctl. Pour en savoir plus sur ces méthodes d’installation et leur fonctionnement, consultez le Guide d’installation Astra Trident.

Installer Astra Trident à l’aide de Helm

Helm doit être installé sur votre station de travail afin que vous puissiez installer Astra Trident à l’aide de cette méthode. Pour connaître d’autres méthodes d’installation d’Astra Trident, consultez le Guide d’installation d’Astra Trident.

Pour installer Astra Trident à l’aide de Helm pour un cluster avec uniquement des nœuds Worker Linux, exécutez les commandes suivantes :

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 sortie de la commande ressemble à l’exemple suivant :

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

Pour vérifier qu’Astra Trident a été correctement installé, exécutez la commande kubectl describe suivante :

kubectl describe torc trident

La sortie de la commande ressemble à l’exemple suivant :

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

Création d'un serveur principal

Pour indiquer à Astra Trident l’abonnement Azure NetApp Files et l’emplacement où il doit créer des volumes, un serveur principal est créé. Cette étape nécessite des informations sur le compte créé à l’étape précédente.

Créez un fichier nommé backend-secret.yaml et copiez-y le YAML suivant. Remplacez Client ID et clientSecret par les valeurs pertinentes de votre environnement.

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

Créez un fichier nommé backend-anf.yaml et copiez-y le YAML suivant. Remplacez subscriptionID, tenantID, location et serviceLevel par les valeurs pertinentes de votre environnement. Utilisez subscriptionID pour l’abonnement Azure où Azure NetApp Files est activé. Obtenez tenantID, clientID et clientSecret à partir d’une inscription d’application dans Microsoft Entra ID avec des autorisations suffisantes pour le service Azure NetApp Files. L’inscription d’application inclut le rôle propriétaire ou contributeur prédéfini par Azure. L’emplacement doit être un emplacement Azure qui contient au moins un sous-réseau délégué créé à l’étape précédente. Le serviceLevel doit correspondre au serviceLevel configuré pour le pool de capacités dans Configurer Azure NetApp Files pour les charges de travail AKS.
```
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
```
Pour en savoir plus sur les back-ends, consultez Options et exemples de configuration de back-ends Azure NetApp Files.
Appliquez le secret et le back-end à l’aide de la commande kubectl apply. Commencez par appliquer le secret :
```
kubectl apply -f backend-secret.yaml -n trident
```
La sortie de la commande ressemble à l’exemple suivant :
```
secret/backend-tbc-anf-secret created
```
Appliquez le back-end :
```
kubectl apply -f backend-anf.yaml -n trident
```
La sortie de la commande ressemble à l’exemple suivant :
```
tridentbackendconfig.trident.netapp.io/backend-tbc-anf created
```

Vérifiez que le back-end a été créé à l’aide de la commande kubectl get :

 kubectl get tridentbackends -n trident

La sortie de la commande ressemble à l’exemple suivant :

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

Créer une classe de stockage

Une classe de stockage permet de définir la création dynamique d’une unité de stockage avec un volume persistant. Pour consommer des volumes Azure NetApp Files, une classe de stockage doit être créée.

Créez un fichier nommé anf-storageclass.yaml, et copiez-y le code YAML suivant :

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

Créez la classe de stockage à l’aide de la commande kubectl apply :
```
kubectl apply -f anf-storageclass.yaml
```
La sortie de la commande ressemble à l’exemple suivant :
```
storageclass/azure-netapp-files created
```

Exécutez la commande kubectl get pour afficher l’état de la classe de stockage :

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

Créer un PVC

Une revendication de volume persistante (PVC) est une requête de stockage effectuée par un utilisateur. Lors de la création d’une revendication de volume persistent, Astra Trident crée automatiquement un volume Azure NetApp Files et le met à la disposition des charges de travail Kubernetes.

Créez un fichier nommé anf-pvc.yaml et copiez-y le YAML suivant. Dans cet exemple, un volume de 1 Tio avec un accès ReadWriteMany est requis.

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

Créez la revendication de volume persistant à l’aide de la commande kubectl apply :
```
kubectl apply -f anf-pvc.yaml
```
La sortie de la commande ressemble à l’exemple suivant :
```
persistentvolumeclaim/anf-pvc created
```

Pour afficher des informations sur la revendication de volume persistant, exécutez la commande kubectl get :

kubectl get pvc

La sortie de la commande ressemble à l’exemple suivant :

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

Utiliser le volume persistant

Une fois le PVC créé, Astra Trident crée le volume persistant. Un pod peut être lancé pour monter le volume Azure NetApp Files et y accéder.

Le manifeste ci-dessous peut être utilisé pour définir un pod NGINX qui monte le volume Azure NetApp Files créé à l’étape précédente. Dans cet exemple, le volume est monté sur /mnt/data.

Créez un fichier nommé anf-nginx-pod.yaml, et copiez-y le code YAML suivant :

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

Créez le pod à l’aide de la commande kubectl apply :

kubectl apply -f anf-nginx-pod.yaml

La sortie de la commande ressemble à l’exemple suivant :

pod/nginx-pod created

Kubernetes a créé un pod avec le volume monté et accessible dans le conteneur nginx sur /mnt/data. Vous pouvez confirmer en vérifiant les journaux des événements du pod à l’aide de la commande kubectl describe :

kubectl describe pod nginx-pod

La sortie de la commande ressemble à l’exemple suivant :

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

Étapes suivantes

Astra Trident prend en charge de nombreuses fonctionnalités avec Azure NetApp Files. Pour plus d'informations, consultez les pages suivantes :

Share via

Approvisionner des volumes Azure NetApp Files NFS pour Azure Kubernetes Service

Configuration statique pour les applications utilisant des volumes NFS

Créer un volume NFS

Créez le volume persistant

Créer une revendication de volume persistant

Monter avec un pod

Configuration dynamique pour les applications utilisant des volumes NFS

Installer Astra Trident

Installer Astra Trident à l’aide de Helm

Création d'un serveur principal

Créer une classe de stockage

Créer un PVC

Utiliser le volume persistant

Étapes suivantes

Ressources supplémentaires