Creare e usare un volume con l'archiviazione BLOB di Azure nel servizio Azure Kubernetes

Articolo
08/05/2024

Le applicazioni basate su contenitore hanno spesso necessità di accedere e salvare in modo permanente i dati in un volume di dati esterno. Se più pod necessitano di accesso simultaneo allo stesso volume di archiviazione, è possibile usare l’archiviazione BLOB di Azure per connettersi usando blobfuse o NFS (Network File System).

Questo articolo illustra come:

Usare un volume permanente dinamico installando il driver CSI (Container Storage Interface) e creando dinamicamente un contenitore di archiviazione BLOB di Azure da collegare a un pod.
Usare un volume permanente statico creando un contenitore di archiviazione BLOB di Azure oppure usare un contenitore 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

Abilitare il driver CSI di archiviazione BLOB nel cluster del servizio Azure Kubernetes.
Per supportare un account di archiviazione di Azure DataLake Gen2 quando si usa il montaggio blobfuse, è necessario seguire questa procedura:
- Per creare un account ADLS usando il driver nel provisioning dinamico, specificare isHnsEnabled: "true" nei parametri della classe di archiviazione.
- Per abilitare l'accesso blobfuse a un account ADLS nel provisioning statico, specificare l'opzione di montaggio --use-adls=true 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 di montaggio --use-adls=true.
Informazioni sulla cache blobfuse
- Per impostazione predefinita, la cache blobfuse si trova nella directory /mnt. Se lo SKU della macchina virtuale fornisce un disco temporaneo, la directory /mnt viene montata sul disco temporaneo. Tuttavia, se lo SKU della macchina virtuale non fornisce un disco temporaneo, la directory /mnt viene montata sul disco del sistema operativo. È possibile impostare l'opzione di montaggio --tmp-path= per specificare una directory della cache diversa

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 dell'archiviazione BLOB per l'uso da parte di un carico di lavoro. Un'attestazione di volume permanente usa l'oggetto classe di archiviazione per effettuare il provisioning dinamico di un contenitore di archiviazione BLOB di Azure.

Parametri della classe di archiviazione per i volumi permanenti dinamici

La tabella seguente mostra i parametri utilizzabili per definire una classe di archiviazione personalizzata per la richiesta di volume permanente.

Nome	Descrizione	Esempio	Obbligatorio	Default value
skuName	Specificare un tipo di account di archiviazione di Azure (alias: `storageAccountType`).	`Standard_LRS`, `Premium_LRS`, `Standard_GRS`, `Standard_RAGRS`	No	`Standard_LRS`
posizione	specificare una località di Azure.	`eastus`	No	Se vuoto, il driver userà lo stesso nome di posizione del cluster corrente.
resourceGroup	Specificare un nome del gruppo di risorse di Azure.	myResourceGroup	No	Se vuoto, il driver userà lo stesso nome del gruppo di risorse del cluster corrente.
storageAccount	Specificare un nome di account di archiviazione di Azure.	storageAccountName	- No	Quando non viene indicato un nome di account di archiviazione specifico, il driver cercherà un account di archiviazione appropriato che corrisponda alle impostazioni dell'account all'interno dello stesso gruppo di risorse. Se non riesce a trovare un account di archiviazione corrispondente, ne creerà uno nuovo. Tuttavia, se viene specificato un nome di account di archiviazione, tale account di archiviazione deve essere già presente.
networkEndpointType	Consente di specificare il tipo di endpoint di rete per l'account di archiviazione creato dal driver. Se viene specificato privateEndpoint, viene creato un endpoint privato per l'account di archiviazione. Per altri casi, verrà creato un endpoint di servizio per il protocollo NFS.¹	`privateEndpoint`	No	Per un cluster del servizio Azure Kubernetes, aggiungere il nome del cluster del servizio Azure Kubernetes al ruolo Collaboratore nel gruppo di risorse che ospita la rete virtuale.
protocollo	Consente di specificare il montaggio blobfuse o il montaggio NFSv3.	`fuse`, `nfs`	No	`fuse`
containerName	Consente di specificare il nome del contenitore esistente (directory).	container	No	Se vuoto, il driver crea un nuovo nome contenitore, a partire da `pvc-fuse` per blobfuse o `pvc-nfs` per NFS v3.
containerNamePrefix	Consente di specificare il prefisso della directory di archiviazione di Azure creato dal driver.	my	Può contenere solo lettere minuscole, numeri e trattini e la lunghezza deve essere inferiore a 21 caratteri.	No
server	Consente di specificare il nome di dominio dell'account di archiviazione di Azure.	Nome di dominio DNS dell'account di archiviazione esistente, ad esempio `<storage-account>.privatelink.blob.core.windows.net`.	No	Se vuoto, il driver usa un nome di dominio DNS dell'account di archiviazione cloud sovrano o predefinito o il nome di dominio predefinito `<storage-account>.blob.core.windows.net`.
allowBlobPublicAccess	Permette di consentire o impedire l'accesso pubblico a tutti i BLOB o contenitori per l'account di archiviazione creato dal driver.	`true`,`false`	No	`false`
storageEndpointSuffix	Consente di specificare il suffisso dell'endpoint di archiviazione di Azure.	`core.windows.net`	No	Se vuoto, il driver userà il suffisso dell'endpoint di archiviazione predefinito in base all'ambiente cloud.
tag	Tags verrebbe creato nel nuovo account di archiviazione.	Formato tag: 'foo=aaa,bar=bbb'	No	""
matchTags	Trova tag di corrispondenza quando il driver prova a trovare un account di archiviazione appropriato.	`true`,`false`	No	`false`
---	I parametri seguenti sono solo per blobfuse	---	---	---
subscriptionid	Consente di specificare l'ID sottoscrizione di Azure in cui verrà creata la directory di archiviazione BLOB.	ID sottoscrizione di Azure	No	Se non è vuoto, `resourceGroup` deve essere specificato.
storeAccountKey	Consente di specificare la chiave dell'account di archiviazione per il segreto Kubernetes. Nota: `false` significa che il driver usa l'identità kubelet per ottenere la chiave dell'account.	`true`,`false`	No	`true`
secretName	Consente di specificare il nome del segreto per archiviare la chiave dell'account.		No
secretNamespace	Consente di specificare lo spazio dei nomi del segreto per archiviare la chiave dell'account.	`default`, `kube-system` e così via	No	Spazio dei nomi dell'attestazione di volume permanente
isHnsEnabled	Abilitare `Hierarchical namespace` per l'account di Azure Data Lake Storage.	`true`,`false`	No	`false`
---	I parametri seguenti sono solo per il protocollo NFS	---	---	---
mountPermissions	Consente di specificare le autorizzazioni per le cartelle montate.	Il valore predefinito è `0777`. Se impostato su `0`, il driver non eseguirà `chmod` dopo il montaggio.	`0777`	No

¹ Se l'account di archiviazione viene creato dal driver, è sufficiente specificare il parametro networkEndpointType: privateEndpoint nella classe di archiviazione. Il driver CSI crea l'endpoint privato insieme all'account. Se si usa un account di archiviazione personalizzato, è necessario creare l'endpoint privato per l'account di archiviazione.

Creare un'attestazione di volume permanente usando la classe di archiviazione predefinita

Un'attestazione di volume permanente usa l'oggetto classe di archiviazione per effettuare il provisioning dinamico di un contenitore di archiviazione BLOB di Azure. È possibile usare il codice YAML seguente per creare un'attestazione di volume permanente di dimensioni pari a 5 GB con accesso ReadWriteMany usando la classe di archiviazione predefinita. Per altre informazioni sulle modalità di accesso, vedere la documentazione sui volumi permanenti di Kubernetes.

Creare un file denominato blob-nfs-pvc.yaml e copiarlo nel codice YAML seguente.

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

Creare l'attestazione di volume permanente con il comando kubectl create:
```
kubectl create -f blob-nfs-pvc.yaml
```

Al termine, verrà creato il contenitore di archiviazione BLOB. È possibile usare il comando kubectl get per visualizzare lo stato dell'attestazione di volume permanente:

kubectl get pvc azure-blob-storage

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

NAME                 STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS                AGE
azure-blob-storage   Bound    pvc-b88e36c5-c518-4d38-a5ee-337a7dda0a68   5Gi        RWX            azureblob-nfs-premium       92m

Usare l'attestazione di volume permanente

Il codice YAML seguente crea un pod che usa l'attestazione di volume permanente azure-blob-storage per montare l’archiviazione BLOB di Azure nel percorso '/mnt/blob'.

Creare un file denominato blob-nfs-pv e copiarlo nel codice YAML seguente. Assicurarsi che claimName corrisponda all'attestazione di volume permanente creata nel passaggio precedente.

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

Creare il pod con il comando kubectl apply:
```
kubectl apply -f blob-nfs-pv.yaml
```
Quando il pod è in esecuzione, eseguire il comando seguente per creare un nuovo file denominato test.txt.
```
kubectl exec mypod -- touch /mnt/blob/test.txt
```
Per verificare che il disco sia montato correttamente, eseguire il comando seguente e verificare che il file test.txt sia visualizzato nell'output:
```
kubectl exec mypod -- ls /mnt/blob
```
L'output del comando è simile all'esempio seguente:
```
test.txt
```

Creare una classe di archiviazione personalizzata

Le classi di archiviazione predefinite soddisfano gli scenari più comuni, ma non tutti. In alcuni casi potrebbe essere necessario personalizzare la classe di archiviazione con i propri parametri. Questa sezione contiene due esempi. Il primo usa il protocollo NFS e il secondo usa BlobFuse.

Classe di archiviazione con il protocollo NFS

In questo esempio il manifesto seguente configura il montaggio di un contenitore di archiviazione BLOB con il protocollo NFS. Usarlo per aggiungere il parametro tags.

Creare un file denominato blob-nfs-sc.yaml e incollare il manifesto di esempio seguente:

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

Creare la classe di archiviazione con il comando kubectl apply:
```
kubectl apply -f blob-nfs-sc.yaml
```
L'output del comando è simile all'esempio seguente:
```
storageclass.storage.k8s.io/blob-nfs-premium created
```

Classe di archiviazione con blobfuse

In questo esempio il manifesto seguente esegue la configurazione con blobfuse e monta un contenitore di archiviazione BLOB. Usarlo per aggiornare il parametro skuName.

Creare un file denominato blobfuse-sc.yaml e incollare il manifesto di esempio seguente:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azureblob-fuse-premium
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.

Creare la classe di archiviazione con il comando kubectl apply:
```
kubectl apply -f blobfuse-sc.yaml
```
L'output del comando è simile all'esempio seguente:
```
storageclass.storage.k8s.io/blob-fuse-premium created
```

Effettuare il provisioning statico di un volume

Questa sezione fornisce indicazioni per gli amministratori dei cluster che vogliono creare uno o più volumi permanenti che includono i dettagli dell'archiviazione BLOB per l'uso da parte di un carico di lavoro.

Parametri di provisioning statico per volumi permanenti

La tabella seguente include i parametri che possono essere utilizzati per definire un volume permanente.

Nome	Descrizione	Esempio	Obbligatorio	Default value
volumeHandle	Consente di specificare un valore che il driver può usare per identificare in modo univoco il contenitore BLOB di archiviazione nel cluster.	Un modo consigliato per produrre un valore univoco consiste nel combinare il nome dell'account di archiviazione univoco globale e il nome del contenitore: `{account-name}_{container-name}`. Nota: i caratteri `#` e `/` sono riservati per l'uso interno e non possono essere usati in un handle di volume.	Sì
volumeAttributes.resourceGroup	Consente di specificare un nome del gruppo di risorse di Azure.	myResourceGroup	No	Se vuoto, il driver usa lo stesso nome del gruppo di risorse del cluster corrente.
volumeAttributes.storageAccount	Consente di specificare il nome di un account di archiviazione di Azure esistente.	storageAccountName	Sì
volumeAttributes.containerName	Consente di specificare il nome del contenitore esistente.	container	Sì
volumeAttributes.protocol	Consente di specificare il montaggio blobfuse o il montaggio NFS v3.	`fuse`, `nfs`	No	`fuse`
---	I parametri seguenti sono solo per blobfuse	---	---	---
volumeAttributes.secretName	Nome segreto che archivia il nome e la chiave dell'account di archiviazione. Si applica solo per SMB.		No
volumeAttributes.secretNamespace	Consente di specificare lo spazio dei nomi del segreto per archiviare la chiave dell'account.	`default`	No	Spazio dei nomi dell'attestazione di volume permanente
nodeStageSecretRef.name	Consente di specificare il nome del segreto che archivia uno degli elementi seguenti: `azurestorageaccountkey` `azurestorageaccountsastoken` `msisecret` `azurestoragespnclientsecret`.		No	Nome del segreto Kubernetes esistente
nodeStageSecretRef.namespace	Consente di specificare lo spazio dei nomi del segreto.	Spazio dei nomi Kubernetes	Sì
---	I parametri seguenti sono solo per il protocollo NFS	---	---	---
volumeAttributes.mountPermissions	Consente di specificare le autorizzazioni per le cartelle montate.	`0777`	No
---	I parametri seguenti sono solo per l'impostazione della rete virtuale NFS	---	---	---
vnetResourceGroup	Consente di specificare il gruppo di risorse della rete virtuale che ospita la rete virtuale.	myResourceGroup	No	Se vuoto, il driver usa il valore `vnetResourceGroup` specificato nel file di configurazione cloud di Azure.
vnetName	Consente di specificare il nome della rete virtuale.	aksVNet	No	Se vuoto, il driver usa il valore `vnetName` specificato nel file di configurazione cloud di Azure.
subnetName	Consente di specificare il nome della subnet esistente del nodo dell'agente.	aksSubnet	No	Se vuoto, il driver usa il valore `subnetName` nel file di configurazione cloud di Azure.
---	I parametri seguenti sono solo per la funzionalità: blobfuse Autenticazione dell'identità gestita e del nome dell'entità servizio	---	---	---
volumeAttributes.AzureStorageAuthType	Specificare il tipo di autenticazione.	`Key`, `SAS`, `MSI`, `SPN`	No	`Key`
volumeAttributes.AzureStorageIdentityClientID	Consente di specificare l'ID client di identità.		No
volumeAttributes.AzureStorageIdentityResourceID	Consente di specificare l'ID risorsa identità.		No
volumeAttributes.MSIEndpoint	Consente di specificare l'endpoint MSI.		No
volumeAttributes.AzureStorageSPNClientID	Consente di specificare l'ID client del nome dell'entità servizio (SPN, Service Principal Name) di Azure.		No
volumeAttributes.AzureStorageSPNTenantID	Consente di specificare l'ID tenant del nome dell'entità servizio (SPN, Service Principal Name) di Azure.		No
volumeAttributes.AzureStorageAADEndpoint	Specificare l'endpoint Microsoft Entra.		No
---	I parametri seguenti sono solo per la funzionalità: chiave dell'account di lettura blobfuse o token di firma di accesso condiviso dall'insieme di credenziali delle chiavi	---	---	---
volumeAttributes.keyVaultURL	Consente di specificare il nome DNS di Azure Key Vault.	{vault-name}.vault.azure.net	No
volumeAttributes.keyVaultSecretName	Consente di specificare il nome del segreto di Azure Key Vault.	Nome del segreto di Azure Key Vault esistente.	No
volumeAttributes.keyVaultSecretVersion	Versione del segreto di Azure Key Vault.	Versione esistente	No	Se vuoto, il driver usa la versione corrente.

Creazione di un contenitore di archiviazione BLOB

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

Per questo articolo creare il contenitore nel gruppo di risorse del nodo. Per prima cosa, ottenere il nome del gruppo di risorse con il comando az servizio Azure Kubernetes show e aggiungere il parametro di query --query nodeResourceGroup. L'esempio seguente ottiene il gruppo di risorse del nodo per il del cluster servizio Azure Kubernetes denominato myAKSCluster nel gruppo di risorse denominato myResourceGroup:

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

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

MC_myResourceGroup_myAKSCluster_eastus

Creare quindi un contenitore per l'archiviazione dei BLOB seguendo la procedura descritta in Gestire l'archiviazione BLOB per autorizzare l'accesso e quindi creare il contenitore.

Montaggio del volume

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

Montare il volume con il protocollo NFS
Montare il volume con Blobfuse

Il montaggio dell'archiviazione BLOB con il protocollo NFS v3 non esegue l'autenticazione usando una chiave dell'account. Il cluster del servizio Azure Kubernetes deve trovarsi nella stessa rete virtuale o nella rete virtuale con peering del nodo dell'agente. L'unico modo per proteggere i dati nell'account di archiviazione consiste nell'usare una rete virtuale e altre impostazioni di sicurezza di rete. Per altre informazioni su come configurare l'accesso NFS all'account di archiviazione, vedere Montare l'archiviazione BLOB usando il protocollo NFS (Network File System) 3.0.

L'esempio seguente illustra come montare un contenitore di archiviazione BLOB come volume permanente usando il protocollo NFS.

Creare un file denominato pv-blob-nfs.yaml e copiarlo nel codice YAML seguente. In storageClass aggiornare resourceGroup, storageAccount e containerName.

Nota

Il valore volumeHandle deve essere un volumeID univoco per ogni contenitore BLOB di archiviazione identico nel cluster. I caratteri # e / sono riservati per uso interno e non possono essere usati.
```
apiVersion: v1
kind: PersistentVolume
metadata:
  annotations:
    pv.kubernetes.io/provisioned-by: blob.csi.azure.com
  name: pv-blob
spec:
  capacity:
    storage: 1Pi
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain  # If set as "Delete" container would be removed after pvc deletion
  storageClassName: azureblob-nfs-premium
  mountOptions:
    - nconnect=4
  csi:
    driver: blob.csi.azure.com
    # make sure volumeid is unique for every identical storage blob container in the cluster
    # character `#` and `/` are reserved for internal use and cannot be used in volumehandle
    volumeHandle: account-name_container-name
    volumeAttributes:
      resourceGroup: resourceGroupName
      storageAccount: storageAccountName
      containerName: containerName
      protocol: nfs
```
Nota

Mentre nell'API di Kubernetes l'attributo capacity è obbligatorio, questo valore non viene usato dal driver CSI di Archiviazione BLOB di Azure perché è possibile scrivere dati in modo flessibile fino a raggiungere il limite di capacità dell'account di archiviazione. Il valore dell'attributo capacity viene usato solo per la corrispondenza delle dimensioni tra PersistentVolumes e PersistentVolumeClaims. È consigliabile usare un valore elevato fittizio. Il pod vede un volume montato con una dimensione fittizia di 5 Petabyte.
Eseguire il comando seguente per creare il volume permanente usando il comando kubectl create che fa riferimento al file YAML creato in precedenza:
```
kubectl create -f pv-blob-nfs.yaml
```

Creare un file pvc-blob-nfs.yaml con PersistentVolumeClaim. Ad esempio:

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: pvc-blob
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 10Gi
  volumeName: pv-blob
  storageClassName: azureblob-nfs-premium

Eseguire il comando seguente per creare l'attestazione di volume permanente usando il comando kubectl create che fa riferimento al file YAML creato in precedenza:
```
kubectl create -f pvc-blob-nfs.yaml
```

Kubernetes necessita di credenziali per accedere al contenitore di archiviazione BLOB creato in precedenza, ovvero una chiave di accesso di Azure o token di firma di accesso condiviso. Queste credenziali sono archiviate in un segreto Kubernetes, cui viene fatto riferimento durante la creazione di un pod Kubernetes.

Usare kubectl create secret command per creare il segreto. È possibile eseguire l'autenticazione usando un segreto Kubernetes o token di firma di accesso condiviso (SAS).
- Segreto
- Token di firma di accesso condiviso
L'esempio seguente crea un oggetto Secret denominato azure-secret e popola azurestorageaccountname e azurestorageaccountkey. È necessario specificare il nome e la chiave dell'account da un account di archiviazione di Azure esistente.
```
kubectl create secret generic azure-secret --from-literal azurestorageaccountname=NAME --from-literal azurestorageaccountkey="KEY" --type=Opaque
```
L'esempio seguente crea un oggetto Secret denominato azure-sas-token e popola azurestorageaccountname e azurestorageaccountsastoken. È necessario specificare il nome dell'account e la firma di accesso condiviso da un account di archiviazione di Azure esistente.
```
kubectl create secret generic azure-sas-token --from-literal azurestorageaccountname=NAME --from-literal azurestorageaccountsastoken
="sastoken" --type=Opaque
```

Creare un file pv-blobfuse.yaml . In volumeAttributes aggiornare containerName. In nodeStateSecretRef aggiornare name con il nome dell'oggetto Secret creato in precedenza. Ad esempio:

Nota

Il valore volumeHandle deve essere un volumeID univoco per ogni contenitore BLOB di archiviazione identico nel cluster. I caratteri # e / sono riservati per uso interno e non possono essere usati.

apiVersion: v1
kind: PersistentVolume
metadata:
  annotations:
    pv.kubernetes.io/provisioned-by: blob.csi.azure.com
  name: pv-blob
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain  # If set as "Delete" container would be removed after pvc deletion
  storageClassName: azureblob-fuse-premium
  mountOptions:
    - -o allow_other
    - --file-cache-timeout-in-seconds=120
  csi:
    driver: blob.csi.azure.com
    # volumeid has to be unique for every identical storage blob container in the cluster
    # character `#`and `/` are reserved for internal use and cannot be used in volumehandle
    volumeHandle: account-name_container-name
    volumeAttributes:
      containerName: containerName
    nodeStageSecretRef:
      name: azure-secret
      namespace: default

Eseguire il comando seguente per creare il volume permanente usando il comando kubectl create che fa riferimento al file YAML creato in precedenza:
```
kubectl create -f pv-blobfuse.yaml
```

Creare un file pvc-blobfuse.yaml con un PersistentVolume. Ad esempio:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-blob
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 10Gi
  volumeName: pv-blob
  storageClassName: azureblob-fuse-premium

Eseguire il comando seguente per creare l'attestazione di volume permanente usando il comando kubectl create che fa riferimento al file YAML creato in precedenza:
```
kubectl create -f pvc-blobfuse.yaml
```

Usare il volume permanente

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

Creare un file denominato nginx-pod-blob.yaml e copiarlo nel codice YAML seguente. Assicurarsi che il claimName corrisponda all'attestazione di volume permanente creata nel passaggio precedente durante la creazione di un volume permanente per NFS o Blobfuse.

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

Eseguire il comando seguente per creare il pod e montare l'attestazione di volume permanente usando il comando kubectl create che fa riferimento al file YAML creato in precedenza:
```
kubectl create -f nginx-pod-blob.yaml
```
Eseguire il comando seguente per creare una sessione interattiva della shell con il pod per verificare l'archiviazione BLOB montata:
```
kubectl exec -it nginx-blob -- df -h
```
L'output dal comando è simile all'esempio seguente:
```
Filesystem      Size  Used Avail Use% Mounted on
...
blobfuse         14G   41M   13G   1% /mnt/blob
...
```

Passaggi successivi

Per informazioni su come usare il driver CSI per l'archiviazione BLOB di Azure, vedere Usare l'archiviazione BLOB di Azure con il driver CSI.
Per le procedure consigliate associate, vedere Procedure consigliate per archiviazione e backup nel servizio Azure Kubernetes.

Condividi tramite