Creare e usare un volume con File di Azure nel servizio Azure Kubernetes

Un volume permanente rappresenta una parte di risorsa di archiviazione di cui è stato eseguito il provisioning per l'uso con pod Kubernetes. È possibile usare un volume permanente con uno o più pod ed è possibile eseguirne il provisioning in modo dinamico o statico. Se più pod necessitano di accesso simultaneo allo stesso volume di archiviazione, è possibile usare File di Azure per connettersi usando il protocollo Server Message Block (SMB). Questo articolo illustra come creare in modo dinamico una condivisione di file di Azure per l'uso da più POD in un cluster del servizio Azure Kubernetes.

Questo articolo illustra come:

• Usare un volume permanente dinamico installando il driver CSI (Container Storage Interface) e creando dinamicamente una o più condivisioni di file di Azure da collegare a un pod.
• Usare un PV statico creando una o più condivisioni file di Azure oppure usando un file esistente e collegarlo a un pod.

Per altre informazioni sui volumi Kubernetes, vedere Opzioni di archiviazione per le applicazioni nel servizio Azure Kubernetes.

Operazioni preliminari

• È necessario aggiungere un account di archiviazione di Azure.
• Assicurarsi che sia installata e configurata l'interfaccia della riga di comando di Azure versione 2.0.59 o successiva. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.
• Quando si sceglie tra condivisioni file standard e Premium, è importante comprendere il modello di provisioning e i requisiti del modello di utilizzo previsto che si prevede di eseguire in File di Azure. Per altre informazioni, vedere Scelta di un livello di prestazioni di File di Azure in base ai modelli di utilizzo.

Effettuare il provisioning dinamico di un volume

Questa sezione fornisce indicazioni per gli amministratori dei cluster che vogliono effettuare il provisioning di uno o più volumi permanenti che includono i dettagli di una o più condivisioni in File di Azure. Un'attestazione di volume permanente usa l'oggetto classe di archiviazione per effettuare il provisioning dinamico di una condivisione file di File di Azure.

Parametri della classe di archiviazione per PersistentVolumes dinamici

La tabella seguente mostra i parametri utilizzabili per definire una classe di archiviazione personalizzata per PersistentVolumeClaim.

Creare una classe di archiviazione

Le classi di archiviazione definiscono come creare una condivisione file di Azure. Nel gruppo di risorse nodo viene creato automaticamente un account di archiviazione da usare insieme alla classe di archiviazione per contenere la condivisione file di File di Azure. Scegliere gli SKU di ridondanza di Archiviazione di Azure seguenti per skuName:

• Standard_LRS: archiviazione con ridondanza locale Standard
• Standard_GRS: archiviazione con ridondanza geografica standard
• Standard_ZRS: archiviazione con ridondanza della zona standard
• Standard_RAGRS: archiviazione con ridondanza geografica e accesso in lettura standard (RA-GRS)
• Premium_LRS: archiviazione con ridondanza locale Premium
• Premium_ZRS: archiviazione con ridondanza della zona Premium (ZRS)

Per altre informazioni sulle classi di archiviazione Kubernetes per File di Azure, vedere l'articolo sulle classi di archiviazione di Kubernetes.

1. Creare un file denominato azure-file-sc.yaml e copiarlo nell'esempio di manifesto seguente. Per altre informazioni su mountOptions, vedere la sezione opzioni di montaggio.

   kind: StorageClass
   apiVersion: storage.k8s.io/v1
   metadata:
     name: my-azurefile
   provisioner: file.csi.azure.com # replace with "kubernetes.io/azure-file" if aks version is less than 1.21
   allowVolumeExpansion: true
   mountOptions:
    - dir_mode=0777
    - file_mode=0777
    - uid=0
    - gid=0
    - mfsymlinks
    - cache=strict
    - actimeo=30
    - nobrl  # disable sending byte range lock requests to the server and for applications which have challenges with posix locks
   parameters:
     skuName: Premium_LRS
   

2. Creare la classe di archiviazione usando il comando kubectl apply.

   kubectl apply -f azure-file-sc.yaml
   

Creare un'attestazione di volume permanente

Un'attestazione di volume permanente usa l'oggetto classe di archiviazione per effettuare il provisioning dinamico di una condivisione file di Azure. È possibile usare il codice YAML seguente per creare un'attestazione di volume permanente 100 GB in dimensioni con accesso ReadWriteMany. Per altre informazioni sulle modalità di accesso, vedere volume permanente Kubernetes.

1. Creare un file denominato azure-file-pvc.yaml e copiarlo nel codice YAML seguente. Assicurarsi che storageClassName corrisponda alla classe di archiviazione creata nel passaggio precedente.

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: my-azurefile
   spec:
     accessModes:
       - ReadWriteMany
     storageClassName: my-azurefile
     resources:
       requests:
         storage: 100Gi
   

   Nota

   Se si usa lo SKU Premium_LRS per la classe di archiviazione, il valore minimo per storage deve essere 100Gi.

2. Creare l'attestazione di volume permanente usando il comando kubectl apply.

   kubectl apply -f azure-file-pvc.yaml
   

   Al termine, viene creata la condivisione file. Viene creato anche un segreto Kubernetes che comprende le credenziali e le informazioni di connessione. È possibile usare il comando kubectl get per visualizzare lo stato dell'attestazione di volume permanente:

   kubectl get pvc my-azurefile
   

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

   NAME           STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS      AGE
   my-azurefile   Bound     pvc-8436e62e-a0d9-11e5-8521-5a8664dc0477   100Gi       RWX            my-azurefile      5m
   

Usare il volume permanente

Il codice YAML seguente crea un pod che usa l'attestazione di volume permanente my-azurefile per montare la condivisione file di File di Azure nel percorso /mnt/azure. Per i contenitori di Windows Server, specificare un mountPath usando la convenzione del percorso di Windows, ad esempio 'D:'.

1. Creare un file denominato azure-pvc-files.yaml e copiarlo nel codice YAML seguente. Assicurarsi che claimName corrisponda al PVC creato nel passaggio precedente.

   kind: Pod
   apiVersion: v1
   metadata:
     name: mypod
   spec:
     containers:
       - name: mypod
         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/azure
             name: volume
             readOnly: false
     volumes:
      - name: volume
        persistentVolumeClaim:
          claimName: my-azurefile
   

2. Creare il pod usando il comando kubectl apply.

   kubectl apply -f azure-pvc-files.yaml
   

   È ora disponibile un pod in esecuzione con la condivisione file di File di Azure montata nella directory /mnt/azure. Questa configurazione può essere visualizzata quando si esamina il pod usando il comando kubectl describe. L'esempio sintetico di output seguente illustra il volume montato nel contenitore.

   Containers:
     mypod:
       Container ID:   docker://053bc9c0df72232d755aa040bfba8b533fa696b123876108dec400e364d2523e
       Image:          mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
       Image ID:       docker-pullable://nginx@sha256:d85914d547a6c92faa39ce7058bd7529baacab7e0cd4255442b04577c4d1f424
       State:          Running
         Started:      Fri, 01 Mar 2019 23:56:16 +0000
       Ready:          True
       Mounts:
         /mnt/azure from volume (rw)
         /var/run/secrets/kubernetes.io/serviceaccount from default-token-8rv4z (ro)
   [...]
   Volumes:
     volume:
       Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
       ClaimName:  my-azurefile
       ReadOnly:   false
   [...]
   

Opzioni di montaggio

Il valore predefinito per fileMode e dirMode è 0777 per Kubernetes versioni 1.13.0 e successive. Se si crea dinamicamente il volume permanente con una classe di archiviazione, è possibile specificare le opzioni di montaggio nell'oggetto classe di archiviazione. Per altre informazioni, vedere Opzioni di montaggio. L'esempio seguente imposta 0777:

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: my-azurefile
provisioner: file.csi.azure.com # replace with "kubernetes.io/azure-file" if aks version is less than 1.21
allowVolumeExpansion: true
mountOptions:
  - dir_mode=0777
  - file_mode=0777
  - uid=0
  - gid=0
  - mfsymlinks
  - cache=strict
  - actimeo=30
  - nobrl  # disable sending byte range lock requests to the server and for applications which have challenges with posix locks
parameters:
  skuName: Premium_LRS

Uso dei tag di Azure

Per altre informazioni sull'uso dei tag di Azure, vedere Usare i tag di Azure nel servizio Azure Kubernetes.

Effettuare il provisioning statico di un volume

Questa sezione fornisce indicazioni per gli amministratori del cluster che vogliono creare uno o più volumi persistenti che includono i dettagli di una condivisione file di Azure esistente da usare con un carico di lavoro.

Parametri di provisioning statico per PersistentVolume

La tabella seguente mostra i parametri utilizzabili per definire un PersistentVolume.

Creare una condivisione file di Azure

Prima di poter usare una condivisione file di File di Azure come volume Kubernetes, è necessario creare un account di archiviazione di Azure e la condivisione file.

1. Ottenere il nome del gruppo di risorse usando il comando az aks show con il parametro --query nodeResourceGroup.

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

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

   MC_myResourceGroup_myAKSCluster_eastus
   

2. Creare un account di archiviazione usando il comando az storage account create con il parametro --sku. Il comando seguente crea un account di archiviazione usando lo SKU Standard_LRS. Assicurarsi di sostituire i segnaposto seguenti:

   • myAKSStorageAccount con il nome dell'account di archiviazione
   • nodeResourceGroupName con il nome del gruppo di risorse in cui sono ospitati i nodi del cluster del servizio Azure Kubernetes
   • location con il nome dell'area in cui creare la risorsa. Deve essere la stessa area dei nodi del cluster del servizio Azure Kubernetes.

   az storage account create -n myAKSStorageAccount -g nodeResourceGroupName -l location --sku Standard_LRS
   

3. Esportare la stringa di connessione come variabile di ambiente usando il comando seguente, che viene usato per creare la condivisione file.

   export AZURE_STORAGE_CONNECTION_STRING=$(az storage account show-connection-string -n storageAccountName -g resourceGroupName -o tsv)
   

4. Creare la condivisione file usando il comando az storage share create. Assicurarsi di sostituire shareName con il nome della condivisione.

   az storage share create -n shareName --connection-string $AZURE_STORAGE_CONNECTION_STRING
   

5. Esportare la chiave dell'account di archiviazione come variabile di ambiente usando il comando seguente.

   STORAGE_KEY=$(az storage account keys list --resource-group nodeResourceGroupName --account-name myAKSStorageAccount --query "[0].value" -o tsv)
   

6. Ripetere il nome e la chiave dell'account di archiviazione usando il comando seguente. Copiare queste informazioni, perché sono necessari questi valori durante la creazione del volume Kubernetes.

   echo Storage account key: $STORAGE_KEY
   

Creare un segreto Kubernetes

Kubernetes necessita di credenziali per accedere alla condivisione file creata nel passaggio precedente. Queste credenziali sono archiviate in un segreto Kubernetes, cui viene fatto riferimento durante la creazione di un pod Kubernetes.

1. Creare il segreto usando il comando kubectl create secret. L'esempio seguente crea un oggetto segreto denominato azure-secret e popola azurestorageaccountname e azurestorageaccountkey del passaggio precedente. Per usare l'account di archiviazione di Azure indicare il nome e la chiave dell'account.

   kubectl create secret generic azure-secret --from-literal=azurestorageaccountname=myAKSStorageAccount --from-literal=azurestorageaccountkey=$STORAGE_KEY
   

Montare una condivisione file come volume permanente

1. Creare un nuovo file denominato azurefiles-pv.yaml e copiarlo nel contenuto seguente. In csi, aggiornare resourceGroup, volumeHandle e shareName. Per le opzioni di montaggio, il valore predefinito per fileMode e dirMode è 0777.

   apiVersion: v1
   kind: PersistentVolume
   metadata:
     annotations:
       pv.kubernetes.io/provisioned-by: file.csi.azure.com
     name: azurefile
   spec:
     capacity:
       storage: 5Gi
     accessModes:
       - ReadWriteMany
     persistentVolumeReclaimPolicy: Retain
     storageClassName: azurefile-csi
     csi:
       driver: file.csi.azure.com
       volumeHandle: "{resource-group-name}#{account-name}#{file-share-name}"  # make sure this volumeid is unique for every identical share in the cluster
       volumeAttributes:
         resourceGroup: resourceGroupName  # optional, only set this when storage account is not in the same resource group as node
         shareName: aksshare
       nodeStageSecretRef:
         name: azure-secret
         namespace: default
     mountOptions:
       - dir_mode=0777
       - file_mode=0777
       - uid=0
       - gid=0
       - mfsymlinks
       - cache=strict
       - nosharesock
       - nobrl  # disable sending byte range lock requests to the server and for applications which have challenges with posix locks
   

2. Creare il volume permanente usando il comando kubectl create.

   kubectl create -f azurefiles-pv.yaml
   

3. Creare un nuovo file denominato azurefiles-mount-options-pvc.yaml e copiare il contenuto seguente.

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: azurefile
   spec:
     accessModes:
       - ReadWriteMany
     storageClassName: azurefile-csi
     volumeName: azurefile
     resources:
       requests:
         storage: 5Gi
   

4. Creare PersistentVolumeClaim usando il comando kubectl apply.

   kubectl apply -f azurefiles-mount-options-pvc.yaml
   

5. Verificare che persistentVolumeClaim sia stato creato e associato a PersistentVolume usando il comando kubectl get.

   kubectl get pvc azurefile
   

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

   NAME        STATUS   VOLUME      CAPACITY   ACCESS MODES   STORAGECLASS   AGE
   azurefile   Bound    azurefile   5Gi        RWX            azurefile      5s
   

6. Aggiornare la specifica del contenitore per fare riferimento al PersistentVolumeClaim e al pod nel file YAML. Ad esempio:

   ...
     volumes:
     - name: azure
       persistentVolumeClaim:
         claimName: azurefile
   

7. Non è possibile aggiornare una specifica di pod, quindi eliminare il pod usando il comando kubectl delete e ricrearlo usando il comando kubectl apply.

   kubectl delete pod mypod
   
   kubectl apply -f azure-files-pod.yaml
   

Montare la condivisione file come volume inline

Per montare la condivisione file di File di Azure nel pod, configurare il volume nella specifica del contenitore.

1. Creare un nuovo file denominato azure-files-pod.yaml e copiarlo nel contenuto seguente. Se è stato modificato il nome della condivisione file o del nome del segreto, aggiornare shareName e secretName. È anche possibile aggiornare il mountPath, ovvero il percorso in cui è montata la condivisione File nel pod. Per i contenitori di Windows Server, specificare un mountPath usando la convenzione del percorso di Windows, ad esempio 'D:'.

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  nodeSelector:
    kubernetes.io/os: linux
  containers:
    - image: 'mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine'
      name: mypod
      resources:
        requests:
          cpu: 100m
          memory: 128Mi
        limits:
          cpu: 250m
          memory: 256Mi
      volumeMounts:
        - name: azure
          mountPath: /mnt/azure
          readOnly: false
  volumes:
    - name: azure
      csi:
        driver: file.csi.azure.com
        volumeAttributes:
          secretName: azure-secret  # required
          shareName: aksshare  # required
          mountOptions: 'dir_mode=0777,file_mode=0777,cache=strict,actimeo=30,nosharesock,nobrl'  # optional

2. Creare il pod usando il comando kubectl apply.

   kubectl apply -f azure-files-pod.yaml
   

   A questo punto è disponibile un pod in esecuzione con una condivisione file di File di Azure montata in /mnt/azure. È possibile verificare che la condivisione sia montata correttamente usando il comando kubectl describe.

   kubectl describe pod mypod
   

Passaggi successivi

Per i parametri del driver CSI di File di Azure, vedere Parametri del driver CSI.

Per le procedure consigliate associate, vedere Procedure consigliate per archiviazione e backup nel servizio Azure Kubernetes.