Partager via

Provisionner des volumes Azure NetApp Files SMB pour Azure Kubernetes Service

  • Article

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 les volumes utilisant NFS (NFSv3 ou NFSv4.1), SMB et double protocole (NFSv3 et SMB, ou NFSv4.1 et SMB).

Configuration statique pour les applications qui utilisent des volumes SMB

Cette section explique comment créer un volume SMB sur Azure NetApp Files et exposer le volume de manière statique à Kubernetes pour qu'une application conteneurisée puisse l'utiliser.

Créer un volume SMB

  1. Définissez les variables pour une utilisation ultérieure. Remplacez myresourcegroup, mylocation, myaccountname, mypool1, premium, myfilepath, myvolsize, myvolname, et virtnetid par une valeur appropriée à votre environnement. Le chemin d'accès au fichier doit être unique pour 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"

  2. Créez un volume à l'aide de la commandeaz netappfiles volume create.

    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 CIFS

Créer un secret avec les informations d'identification du domaine

  1. Créez un secret sur votre cluster AKS pour accéder au serveur Active Directory (AD) à l'aide de la kubectl create secretcommande. Ce secret sera utilisé par le volume persistant Kubernetes pour accéder au volume SMB Azure NetApp Files. Utilisez la commande suivante pour créer le secret, en remplaçant USERNAME par votre nom d'utilisateur, PASSWORD par votre mot de passe et DOMAIN_NAME par le nom de domaine de votre AD.

        kubectl create secret generic smbcreds --from-literal=username=USERNAME --from-literal=password="PASSWORD" --from-literal=domain='DOMAIN_NAME'

  2. Vérifier que le secret a été créé.

       kubectl get secret
   NAME       TYPE     DATA   AGE
   smbcreds   Opaque   2      20h

Installer un pilote SMB CSI

Vous devez installer un pilote d'interface de stockage de conteneurs (CSI) pour créer un SMB KubernetesPersistentVolume .

  1. Installez le pilote SMB CSI sur votre cluster en utilisant helm. Veillez à définir l’option windows.enabled sur true:

    helm repo add csi-driver-smb https://raw.githubusercontent.com/kubernetes-csi/csi-driver-smb/master/charts   
helm install csi-driver-smb csi-driver-smb/csi-driver-smb --namespace kube-system --version v1.13.0 --set windows.enabled=true

    Pour d’autres méthodes d’installation du pilote CSI SMB, consultez Installer le pilote CSI SMB master version sur un cluster Kubernetes.

  2. Vérifiez que le csi-smb pod de contrôleur est en cours d’exécution et que chaque nœud Worker dispose d’un pod en cours d’exécution à l’aide de la commande kubectl get pods :

    kubectl get pods -n kube-system | grep csi-smb

csi-smb-controller-68df7b4758-xf2m9   3/3     Running   0          3m46s
csi-smb-node-s6clj                    3/3     Running   0          3m47s
csi-smb-node-win-tfxvk                3/3     Running   0          3m47s

Créez le volume persistant

  1. Listez les détails de votre volume en utilisant az netappfiles volume show Remplacez les variables par les valeurs appropriées de votre compte Azure NetApp Files et de votre environnement si elles n'ont pas été définies lors d'une é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": "myvolname",
  ...
  "mountTargets": [
    {
      ...
      "
         "smbServerFqdn": "ANF-1be3.contoso.com",
      ...
    }
  ],
  ...
}

  2. Créez un fichier nommé pv-smb.yaml et copiez-y le YAML suivant. Si nécessaire, remplacez myvolname par creationToken et remplacez ANF-1be3.contoso.com\myvolname par la valeur de smbServerFqdn l’étape précédente. Veillez à inclure votre secret d'identification AD ainsi que l'espace de noms dans lequel se trouve le secret que vous avez créé lors d'une étape précédente.

    apiVersion: v1
kind: PersistentVolume
metadata:
  name: anf-pv-smb
spec:
  storageClassName: ""
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  mountOptions:
    - dir_mode=0777
    - file_mode=0777
    - vers=3.0
  csi:
    driver: smb.csi.k8s.io
    readOnly: false
    volumeHandle: myvolname  # make sure it's a unique name in the cluster
    volumeAttributes:
      source: \\ANF-1be3.contoso.com\myvolname
    nodeStageSecretRef:
      name: smbcreds
      namespace: default

  3. Créez le volume persistant à l'aide de la kubectl applycommande :

    kubectl apply -f pv-smb.yaml

  4. Vérifiez que l’état du volume persistant est Disponible à l’aide de la commande kubectl describe :

    kubectl describe pv pv-smb

Créer une revendication de volume persistant

  1. Créez un fichier nommé pvc-smb.yaml et copiez-y le YAML suivant.

    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: anf-pvc-smb
spec:
  accessModes:
    - ReadWriteMany
  volumeName: anf-pv-smb
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi

  2. Créez la revendication de volume persistant avec la commande kubectl apply :

    kubectl apply -f pvc-smb.yaml

    Vérifiez l'état de la demande de volume persistant est Bound en utilisant la commande kubectl describe commande :

    kubectl describe pvc pvc-smb

Monter avec un pod

  1. Créez un fichier nommé iis-smb.yaml et copiez-y le YAML suivant. Ce fichier sera utilisé pour créer un pod Internet Information Services afin de monter le volume sur le chemin d’accès /inetpub/wwwroot.

    apiVersion: v1
kind: Pod 
metadata:
  name: iis-pod
  labels:
     app: web
spec:
  nodeSelector:
    "kubernetes.io/os": windows
  volumes:
  - name: smb
    persistentVolumeClaim:
      claimName: anf-pvc-smb 
  containers:
  - name: web
    image: mcr.microsoft.com/windows/servercore/iis:windowsservercore 
    resources:
      limits:
        cpu: 1
        memory: 800M
    ports:
      - containerPort: 80
    volumeMounts:
    - name: smb
      mountPath: "/inetpub/wwwroot"
      readOnly: false

  2. Créez le pod en utilisant la commande kubectl apply :

    kubectl apply -f iis-smb.yaml

  3. Vérifiez que le pod fonctionne et /inetpub/wwwroot est monté à partir de SMB en utilisant la commande kubectl describe :

    kubectl describe pod iis-pod

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

    Name:         iis-pod
Namespace:    default
Priority:     0
Node:         akswin000001/10.225.5.246
Start Time:   Fri, 05 May 2023 09:34:41 -0400
Labels:       app=web
Annotations:  <none>
Status:       Running
IP:           10.225.5.248
IPs:
  IP:  10.225.5.248
Containers:
  web:
    Container ID:   containerd://39a1659b6a2b6db298df630237b2b7d959d1b1722edc81ce9b1bc7f06237850c
    Image:          mcr.microsoft.com/windows/servercore/iis:windowsservercore
    Image ID:       mcr.microsoft.com/windows/servercore/iis@sha256:0f0114d0f6c6ee569e1494953efdecb76465998df5eba951dc760ac5812c7409
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 05 May 2023 09:34:55 -0400
    Ready:          True
    Restart Count:  0
    Limits:
      cpu:     1
      memory:  800M
    Requests:
      cpu:        1
      memory:     800M
    Environment:  <none>
    Mounts:
      /inetpub/wwwroot from smb (rw)
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-mbnv8 (ro)
...

  4. Vérifiez que votre volume a été monté sur le pod à l’aide de la commande kubectl exec pour vous connecter au pod, puis utilisez la commande dir dans le répertoire approprié pour vérifier si le volume est monté et que la taille correspond à la taille du volume que vous avez approvisionnée.

    kubectl exec -it iis-pod –- cmd.exe

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

    Microsoft Windows [Version 10.0.20348.1668]
(c) Microsoft Corporation. All rights reserved.

C:\>cd /inetpub/wwwroot

C:\inetpub\wwwroot>dir
 Volume in drive C has no label.
 Volume Serial Number is 86BB-AA55

 Directory of C:\inetpub\wwwroot

05/04/2023  08:15 PM    <DIR>          .
05/04/2023  08:15 PM    <DIR>          ..
           0 File(s)              0 bytes
           2 Dir(s)  107,373,838,336 bytes free

Configuration dynamique pour les applications qui utilisent des volumes SMB

Cette section explique comment utiliser Astra Trident pour créer dynamiquement un volume SMB sur Azure NetApp Files et le monter automatiquement sur une application Windows conteneurisée.

Installer l'Astra Trident

Pour provisionner dynamiquement des volumes SMB, vous devez installer Astra Trident version 22.10 ou ultérieure. Le provisionnement dynamique des volumes SMB nécessite des nœuds de travail Windows.

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.

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. Si vous avez des nœuds de travail Windows dans le cluster, assurez-vous d'activer Windows avec n'importe quelle méthode d'installation.

  1. Pour installer Astra Trident à l'aide de Helm pour un cluster avec des nœuds de travail Windows, 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 –-set windows=true

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

    NAME: trident
LAST DEPLOYED: Fri May  5 14:23:05 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

  2. 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:               true
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  74s   trident-operator.netapp.io  Installing Trident
  Normal  Installed   46s   trident-operator.netapp.io  Trident installed

Création d'un serveur principal

Un backend doit être créé pour indiquer à Astra Trident l'abonnement Azure NetApp Files et l'endroit où il doit créer des volumes. Pour en savoir plus sur les back-ends, consultez Options et exemples de configuration de back-ends Azure NetApp Files.

  1. Créez un fichier nommé backend-secret-smb.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

  2. Créez un fichier nommé backend-anf-smb.yaml et copiez-y le YAML suivant. Remplacez ClientID, clientSecret, subscriptionID, tenantID, location et serviceLevelpar les valeurs pertinentes de votre environnement. tenantID, clientID et clientSecret peuvent être trouvées dans une inscription d’application dans Microsoft Entra ID avec des autorisations suffisantes pour le service Azure NetApp Files. L'enregistrement de l'application inclut le rôle de propriétaire ou de contributeur prédéfini par Azure. L'emplacement Azure doit contenir au moins un sous-réseau délégué. 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-smb
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
  nasType: smb

  3. Créez le secret et le backend à l'aide de la commande kubectl apply.

    Créer 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

    Créer le backend :

    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

  4. Vérifiez que le backend a été créé en exécutant la commande suivante :

    kubectl get tridentbackends -n trident

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

    NAME        BACKEND               BACKEND UUID
tbe-9shfq   backend-tbc-anf-smb   09cc2d43-8197-475f-8356-da7707bae203

Créer un secret avec les informations d'identification du domaine pour SMB

  1. Créez un secret sur votre cluster AKS pour accéder au serveur AD à l’aide de la commande kubectl create secret. Ces informations seront utilisées par le volume persistant Kubernetes pour accéder au volume SMB Azure NetApp Files. Utilisez la commande suivante, en remplaçantDOMAIN_NAME\USERNAME par votre nom de domaine et votre nom d'utilisateur et PASSWORD par votre mot de passe.

    kubectl create secret generic smbcreds --from-literal=username=DOMAIN_NAME\USERNAME –from-literal=password="PASSWORD"

  2. Vérifiez que le secret a été créé.

    kubectl get secret

    La sortie ressemble à l’exemple suivant :

    NAME       TYPE     DATA   AGE
smbcreds   Opaque   2      2h

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.

  1. Créez un fichier nommé anf-storageclass-smb.yaml et copiez-y le YAML suivant.

    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: anf-sc-smb
provisioner: csi.trident.netapp.io
allowVolumeExpansion: true
parameters:
  backendType: "azure-netapp-files"
  trident.netapp.io/nasType: "smb"
  csi.storage.k8s.io/node-stage-secret-name: "smbcreds"
  csi.storage.k8s.io/node-stage-secret-namespace: "default"

  2. Créez la classe de stockage à l'aide de la commande kubectl apply:

    kubectl apply -f anf-storageclass-smb.yaml

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

    storageclass/anf-sc-smb created

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

    kubectl get sc anf-sc-smb
NAME         PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
anf-sc-smb   csi.trident.netapp.io   Delete          Immediate           true                   13s

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 réclamation de volume persistant, Astra Trident crée automatiquement un partage SMB Azure NetApp Files et le met à la disposition des charges de travail Kubernetes.

  1. Créez un fichier nommé anf-pvc-smb.yaml et copiez le YAML suivant. Dans cet exemple, un volume de 100 Go est créé avec ReadWriteMany accès et utilise la classe de stockage créée dans Créer une classe de stockage .

    kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: anf-pvc-smb
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 100Gi
  storageClassName: anf-sc-smb

  2. Créez la demande de volume persistant à l'aide de la commande kubectl apply:

    kubectl apply -f anf-pvc-smb.yaml

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

    persistentvolumeclaim/anf-pvc-smb created

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

    NAME          STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
anf-pvc-smb   Bound    pvc-209268f5-c175-4a23-b61b-e34faf5b6239   100Gi      RWX            anf-sc-smb     5m38s

  4. Pour afficher le volume persistant créé par Astra Trident, exécutez la commande suivante kubectl get:

    kubectl get pv
NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                 STORAGECLASS   REASON   AGE
pvc-209268f5-c175-4a23-b61b-e34faf5b6239   100Gi      RWX            Delete           Bound    default/anf-pvc-smb   anf-sc-smb              5m52s

Utiliser le volume persistant

Une fois la PVC créée, un pod peut être lancé pour accéder au volume Azure NetApp Files. Le manifeste suivant peut être utilisé pour définir un pod Internet Information Services (IIS) qui monte le partage SMB Azure NetApp Files créé à l'étape précédente. Dans cet exemple, le volume est monté sur /inetpub/wwwroot.

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

    apiVersion: v1
kind: Pod 
metadata:
  name: iis-pod
  labels:
     app: web
spec:
  nodeSelector:
    "kubernetes.io/os": windows
  volumes:
  - name: smb
    persistentVolumeClaim:
      claimName: anf-pvc-smb 
  containers:
  - name: web
    image: mcr.microsoft.com/windows/servercore/iis:windowsservercore 
    resources:
      limits:
        cpu: 1
        memory: 800M
    ports:
      - containerPort: 80
    volumeMounts:
    - name: smb
      mountPath: "/inetpub/wwwroot"
      readOnly: false

  2. Créez le déploiement avec la commande suivantekubectl apply :

    kubectl apply -f anf-iis-deploy-pod.yaml

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

    pod/iis-pod created

    Vérifiez que le pod fonctionne et qu'il est monté via SMB sur /inetpub/wwwroot en utilisant la commande kubectl describe :

    kubectl describe pod iis-pod

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

    Name:         iis-pod
Namespace:    default
Priority:     0
Node:         akswin000001/10.225.5.246
Start Time:   Fri, 05 May 2023 15:16:36 -0400
Labels:       app=web
Annotations:  <none>
Status:       Running
IP:           10.225.5.252
IPs:
  IP:  10.225.5.252
Containers:
  web:
    Container ID:   containerd://1e4959f2b49e7ad842b0ec774488a6142ac9152ca380c7ba4d814ae739d5ed3e
    Image:          mcr.microsoft.com/windows/servercore/iis:windowsservercore
    Image ID:       mcr.microsoft.com/windows/servercore/iis@sha256:0f0114d0f6c6ee569e1494953efdecb76465998df5eba951dc760ac5812c7409
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 05 May 2023 15:16:44 -0400
    Ready:          True
    Restart Count:  0
    Limits:
      cpu:     1
      memory:  800M
    Requests:
      cpu:        1
      memory:     800M
    Environment:  <none>
    Mounts:
      /inetpub/wwwroot from smb (rw)
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-zznzs (ro)

  3. Vérifiez que votre volume a été monté sur le pod en utilisant kubectl exec pour vous connecter au pod. Ensuite, utilisez ladir commande dans le bon répertoire pour vérifier si le volume est monté et si sa taille correspond à celle du volume que vous avez provisionné.

    kubectl exec -it iis-pod –- cmd.exe

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

    Microsoft Windows [Version 10.0.20348.1668]
(c) Microsoft Corporation. All rights reserved.

C:\>cd /inetpub/wwwroot

C:\inetpub\wwwroot>dir
 Volume in drive C has no label.
 Volume Serial Number is 86BB-AA55

 Directory of C:\inetpub\wwwroot

05/05/2023  01:38 AM    <DIR>          .
05/05/2023  01:38 AM    <DIR>          ..
           0 File(s)              0 bytes
           2 Dir(s)  107,373,862,912 bytes free

C:\inetpub\wwwroot>exit

Étapes suivantes

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