Creare e gestire volumi persistenti con l'archiviazione BLOB di Azure nel servizio Azure Kubernetes

Se più pod richiedono l'accesso simultaneo allo stesso volume di archiviazione, è possibile usare l'archiviazione BLOB di Azure per connettersi usando blobfuse o Network File System (NFS).

Questo articolo illustra come creare in modo dinamico e statico contenitori di archiviazione BLOB di Azure per l'uso da parte di più pod in un cluster del servizio Azure Kubernetes.

Prerequisiti

• Il driver CSI dell'archiviazione BLOB di Azure abilitato nel cluster del servizio Azure Kubernetes.

• Un account di archiviazione abilitato per NFS v3 in modo da poter montare un volume permanente usando il protocollo NFS. Non è possibile abilitare NFS v3 in un account di archiviazione esistente. Per altre informazioni, vedere Creare un account NFS v3.

• Per supportare un account Azure Data Lake Storage quando si usa il montaggio blobfuse, completare le attività seguenti:

  • Per creare un account Data Lake Storage usando il driver nel provisioning dinamico, specificare isHnsEnabled: "true" nei parametri della classe di archiviazione.
  • Per abilitare l'accesso blobfuse a un account Data Lake Storage nel provisioning statico, specificare l'opzione --use-adls=true di montaggio nel volume permanente.
  • Se si intende abilitare un account di archiviazione con spazio dei nomi gerarchico, i volumi permanenti esistenti devono essere rimontati con l'opzione --use-adls=true di montaggio.

• Per impostazione predefinita, la cache blobfuse si trova nella /mnt directory . Se lo SKU della macchina virtuale fornisce un disco temporaneo, la /mnt directory viene montata sul disco temporaneo. Tuttavia, se lo SKU della macchina virtuale non fornisce un disco temporaneo, la /mnt directory viene montata sul disco del sistema operativo, è possibile impostare --tmp-path= l'opzione di montaggio per specificare una directory cache diversa.

Usare classi di archiviazione predefinite per creare PV dinamici con l'archiviazione BLOB di Azure

Per definire la modalità di creazione di un contenitore di Archiviazione BLOB di Azure, viene utilizzata una classe di archiviazione. Nel gruppo di risorse nodo viene creato automaticamente un account di archiviazione da usare insieme alla classe di archiviazione per includere il contenitore di Archiviazione BLOB di Azure. Quando si usano i driver CSI di archiviazione nel servizio Azure Kubernetes, ci sono altre due StorageClasses predefinite usano il driver CSI dell'archiviazione BLOB di Azure.

I criteri di recupero in entrambe le classi di archiviazione garantiscono che l'istanza di Archiviazione BLOB di Azure sottostante venga eliminata quando viene eliminato il rispettivo volume persistente. Le classi di archiviazione configurano anche il contenitore per essere espandibili per impostazione predefinita, perché il parametro set allowVolumeExpansion è impostato su true.

È possibile selezionare uno degli SKU di ridondanza dell'archiviazione di Azure seguenti per il parametro skuname nella definizione della classe di archiviazione:

• Standard_LRS: Archiviazione Standard con ridondanza locale
• Premium_LRS: Archiviazione con ridondanza locale Premium
• Standard_ZRS: archiviazione con ridondanza della zona standard
• Premium_ZRS: archiviazione con ridondanza locale premium
• Standard_GRS: Archiviazione con ridondanza geografica standard
• Standard_RAGRS: archiviazione con ridondanza geografica e accesso in lettura Standard

Creare classi di archiviazione personalizzate per volumi persistenti dinamici con l'archiviazione BLOB di Azure

Le classi di archiviazione predefinite sono adatte per la maggior parte degli scenari. In alcuni casi, potrebbe essere necessario personalizzare la propria classe di archiviazione con i propri parametri. In questa sezione vengono forniti due esempi: uno che usa il protocollo NFS e uno con blobfuse.

Esempio di classe di archiviazione personalizzata con il protocollo NFS

Il manifesto in questo esempio monta un contenitore di archiviazione BLOB usando il protocollo NFS. È possibile usarlo per aggiungere il tags parametro .

1. Creare un file denominato blob-nfs-sc.yaml e incollarlo nel manifesto di esempio seguente:

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: blob-nfs
   provisioner: blob.csi.azure.com
   parameters:
     protocol: nfs
     tags: environment=Development
   volumeBindingMode: Immediate
   allowVolumeExpansion: true
   

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

   kubectl apply -f blob-nfs-sc.yaml
   

   L'output dovrebbe essere simile all'output di esempio seguente:

   storageclass.storage.k8s.io/blob-nfs created
   

Esempio di classe di archiviazione personalizzata con blobfuse

Il manifesto in questo esempio usa blobfuse e monta un contenitore di archiviazione BLOB. È possibile usarlo per aggiornare il skuName parametro .

1. Creare un file denominato blobfuse-sc.yaml e incollarlo nel manifesto di esempio seguente:

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: blob-fuse
   provisioner: blob.csi.azure.com
   parameters:
     skuName: Standard_GRS  # available values: Standard_LRS, Premium_LRS, Standard_GRS, Standard_RAGRS
   reclaimPolicy: Delete
   volumeBindingMode: Immediate
   allowVolumeExpansion: true
   mountOptions:
     - -o allow_other
     - --file-cache-timeout-in-seconds=120
     - --use-attr-cache=true
     - --cancel-list-on-mount-seconds=10  # prevent billing charges on mounting
     - -o attr_timeout=120
     - -o entry_timeout=120
     - -o negative_timeout=120
     - --log-level=LOG_WARNING  # LOG_WARNING, LOG_INFO, LOG_DEBUG
     - --cache-size-mb=1000  # Default will be 80% of available memory, eviction will happen beyond that.
   

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

   kubectl apply -f blobfuse-sc.yaml
   

   L'output dovrebbe essere simile all'output di esempio seguente:

   storageclass.storage.k8s.io/blob-fuse created
   

Parametri della classe di archiviazione per i volumi persistenti dinamici con l'archiviazione BLOB di Azure

Usare i gruppi di parametri seguenti per definire una classe di archiviazione personalizzata per le attestazioni del volume permanente con Azure'archiviazione BLOB:

• Account di archiviazione: skuName, resourceGrouplocation, subscriptionID, storageAccount, networkEndpointType, accessTier, allowSharedKeyAccessallowBlobPublicAccesspublicNetworkAccessrequireInfraEncryptiontagse .matchTags
• Contenitore ed endpoint: protocol, containerName, containerNamePrefixserver, storageEndpointSuffix, useDataPlaneAPI, softDeleteBlobs, , softDeleteContainerse enableBlobVersioning.
• BlobFuse: storeAccountKey, getLatestAccountKey, secretNamesecretNamespace, e isHnsEnabled.
• NFS: mountPermissions e fsGroupChangePolicy.
• Rete virtuale: vnetResourceGroup, vnetName, subnetNamee vnetLinkName.

Configurare i parametri dell'account di archiviazione per i TELEVISORi dinamici con archiviazione BLOB Azure

Usare i parametri seguenti per configurare l'account di archiviazione Azure per un pv con provisioning dinamico:

Configurare i parametri del contenitore e dell'endpoint per i TELEVISORi dinamici con archiviazione BLOB Azure

Usare i parametri seguenti per configurare il contenitore, il protocollo di montaggio, l'endpoint di archiviazione e i tag per un pv con provisioning dinamico:

Configurare i parametri BlobFuse per i TELEVISORi dinamici con archiviazione BLOB Azure

I parametri seguenti si applicano solo quando si usa BlobFuse per un pv con provisioning dinamico:

Configurare i parametri NFS per i TELEVISORi dinamici con archiviazione BLOB Azure

Il parametro seguente si applica solo quando si usa NFS per un pv con provisioning dinamico:

Configurare i parametri di rete virtuale per i TELEVISORi dinamici con archiviazione BLOB di Azure

Usare i parametri seguenti quando il driver configura l'accesso alla rete virtuale per un pv con provisioning dinamico:

Configurare gli endpoint privati per i TELEVISORi dinamici con archiviazione BLOB di Azure

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: blob-fuse
provisioner: blob.csi.azure.com
parameters:
  skuName: Premium_LRS  # available values: Standard_LRS, Premium_LRS, Standard_GRS, Standard_RAGRS, Standard_ZRS, Premium_ZRS
  protocol: fuse2
  networkEndpointType: privateEndpoint
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
mountOptions:
  - -o allow_other
  - --file-cache-timeout-in-seconds=120
  - --use-attr-cache=true
  - --cancel-list-on-mount-seconds=10  # prevent billing charges on mounting
  - -o attr_timeout=120
  - -o entry_timeout=120
  - -o negative_timeout=120
  - --log-level=LOG_WARNING  # LOG_WARNING, LOG_INFO, LOG_DEBUG
  - --cache-size-mb=1000  # Default will be 80% of available memory, eviction will happen beyond that.

Creare un PVC per il provisioning dinamico

Un PVC utilizza l'oggetto classe di archiviazione per effettuare il provisioning dinamico di un Azure Blob Storage. È possibile usare il manifesto YAML di esempio in questa sezione per creare un PVC di dimensioni pari a 5 GB con accesso ReadWriteMany . Per altre informazioni sulle modalità di accesso, vedere Kubernetes PV access modes.

1. Creare un file denominato blob-nfs-pvc.yaml e incollarlo nel manifesto YAML seguente:

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: azure-blob-storage
   spec:
     accessModes:
     - ReadWriteMany
     storageClassName: azureblob-nfs-premium
     resources:
       requests:
         storage: 5Gi
   

2. Creare il PVC usando il kubectl create comando :

   kubectl create -f blob-nfs-pvc.yaml
   

3. Visualizzare lo stato del PVC con il kubectl get comando :

   kubectl get pvc azure-blob-storage
   

   L'output dovrebbe essere simile all'output di esempio seguente, che mostra che l'attestazione di volume persistente si trova in uno stato Bound:

   NAME                 STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS                AGE
   azure-blob-storage   Bound    pvc-aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb   5Gi        RWX            azureblob-nfs-premium       92m
   

Montare un volume di archiviazione BLOB con provisioning dinamico in un pod

Il seguente YAML crea un pod che utilizza la dichiarazione di volume persistente azure-blob-storage per montare lo storage BLOB di Azure nel percorso /mnt/blob.

1. Creare un file denominato blob-nfs-pv e incollare il manifesto YAML seguente. Assicurarsi che corrisponda claimName al PVC creato in precedenza (azure-blob-storage).

   kind: Pod
   apiVersion: v1
   metadata:
     name: mypod
   spec:
     containers:
     - name: mypod
       image: mcr.microsoft.com/oss/nginx/nginx:1.17.3-alpine
       resources:
         requests:
           cpu: 100m
           memory: 128Mi
         limits:
           cpu: 250m
           memory: 256Mi
       volumeMounts:
       - mountPath: "/mnt/blob"
         name: volume
         readOnly: false
     volumes:
       - name: volume
         persistentVolumeClaim:
           claimName: azure-blob-storage
   

2. Creare il pod usando il kubectl apply comando :

   kubectl apply -f blob-nfs-pv.yaml
   

3. Dopo aver eseguito correttamente il pod, creare un nuovo file denominato test.txt usando il comando seguente:

   kubectl exec mypod -- touch /mnt/blob/test.txt
   

4. Verificare che il disco sia montato correttamente usando il comando seguente per elencare i file nella directory montata:

   kubectl exec mypod -- ls /mnt/blob
   

   L'output dovrebbe essere simile all'output di esempio seguente, che mostra il file test.txt creato nell'archiviazione BLOB di Azure montata:

   test.txt
   

Usare un oggetto StatefulSet per gestire il ciclo di vita di un volume con l'archiviazione BLOB di Azure

Per rendere persistente un volume di archiviazione per il carico di lavoro, è possibile usare un oggetto StatefulSet. Questa configurazione semplifica l'assegnazione dei volumi esistenti ai nuovi pod che sostituiscono quelli che hanno smesso di funzionare. Gli esempi seguenti illustrano come configurare un oggetto StatefulSet per l'archiviazione BLOB usando il protocollo NFS o Blobfuse.

Creare un PV statico con l'archiviazione Blob di Azure

Le sezioni seguenti forniscono istruzioni per la creazione di un pv statico con l'archiviazione BLOB di Azure. Un pv statico è un volume permanente creato manualmente da un amministratore. Questo volume persistente è disponibile per l'uso da parte dei pod nel cluster. Per usare un PV statico, si crea un PVC che fa riferimento al PV e quindi si crea un pod che fa riferimento al PVC.

Parametri del volume CSI per i TELEVISORi statici con archiviazione BLOB Azure

La tabella seguente elenca i parametri che è possibile usare nell'origine del volume CSI per un pv statico con archiviazione BLOB Azure:

Creare un contenitore di archiviazione BLOB

Quando si crea una risorsa di Archiviazione BLOB di Azure da usare con Azure Kubernetes Service (AKS), è possibile creare la risorsa nel gruppo di risorse del nodo. Questo approccio consente al cluster AKS di accedere e gestire la risorsa di archiviazione BLOB.

1. Ottieni il nome del gruppo di risorse del nodo del tuo cluster AKS 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. Se si crea l'account di archiviazione nel gruppo di risorse del nodo, usare il nome del gruppo di risorse del nodo restituito nel passaggio precedente, ad esempio MC_myResourceGroup_myAKSCluster_eastus. Seguire quindi la procedura descritta in Gestire l'archiviazione BLOB per autorizzare l'accesso e creare un contenitore in tale account di archiviazione.

Montare il volume

In questa sezione si monta il volume permanente usando il protocollo NFS o Blobfuse.

Usare il volume permanente

Il codice YAML seguente crea un pod che usa il volume persistente o l'attestazione di volume persistente denominata pvc-blob creata in precedenza per montare l'archiviazione BLOB di Azure nel percorso /mnt/blob.

1. Creare un file denominato nginx-pod-blob.yaml e incollarlo nel manifesto YAML seguente. Assicurarsi che corrisponda claimName al PVC creato in precedenza (pvc-blob).

   kind: Pod
   apiVersion: v1
   metadata:
     name: nginx-blob
   spec:
     nodeSelector:
       "kubernetes.io/os": linux
     containers:
       - image: mcr.microsoft.com/oss/nginx/nginx:1.17.3-alpine
         name: nginx-blob
         volumeMounts:
           - name: blob01
             mountPath: "/mnt/blob"
             readOnly: false
     volumes:
       - name: blob01
         persistentVolumeClaim:
           claimName: pvc-blob
   

2. Creare il pod e montare il PVC usando il kubectl create comando :

   kubectl create -f nginx-pod-blob.yaml
   

3. Creare una sessione interattiva della shell con il pod per verificare che l'archiviazione BLOB sia montata correttamente usando il comando kubectl exec seguente:

   kubectl exec -it nginx-blob -- df -h
   

   L'output dovrebbe essere simile all'output di esempio seguente, che mostra che l'archiviazione BLOB è montata nel percorso /mnt/blob.

   Filesystem      Size  Used Avail Use% Mounted on
   ...
   blobfuse         14G   41M   13G   1% /mnt/blob
   ...
   

Contenuti correlati

• Usare i tag di Azure nel servizio Azure Kubernetes
• Problemi noti relativi al supporto del protocollo NFS (NFS) 3.0 per Archiviazione BLOB di Azure