Usa Azure Container Storage con NVMe locale

Archiviazione di Azure Container è un servizio di gestione, distribuzione e orchestrazione basato sul cloud creato in modo nativo per i contenitori. Questo articolo illustra come configurare l'archiviazione di Azure Container per l'uso del disco NVMe locale come risorsa di archiviazione back-end per i carichi di lavoro Kubernetes. NVMe è progettato per il trasferimento di dati ad alta velocità tra archiviazione e CPU, offrendo operazioni di I/O al secondo e velocità effettiva elevate.

Importante

Questo articolo si applica ad Azure Container Storage (versione 2.x.x), che attualmente supporta solo il disco NVMe locale come supporto di archiviazione. Per informazioni dettagliate sulle versioni precedenti, vedere la documentazione di Archiviazione contenitori di Azure (versione 1.x.x).

Che cos'è nvme locale?

Quando l'applicazione necessita di latenza di archiviazione di sotto millisecondi e velocità effettiva elevata, è possibile usare dischi NVMe locali con Archiviazione Azure Container per soddisfare i requisiti di prestazioni. Temporaneo significa che i dischi vengono distribuiti nella macchina virtuale locale che ospita il cluster del servizio Azure Kubernetes e non vengono salvati in un servizio di archiviazione di Azure. I dati vengono persi in questi dischi se si arresta/dealloca la macchina virtuale. I dischi NVMe locali vengono offerti in famiglie di macchine virtuali di Azure selezionate, ad esempio macchine virtuali ottimizzate per l'archiviazione .

Per impostazione predefinita, Archiviazione Contenitori di Azure crea volumi temporanei generici quando si usano dischi NVMe locali. Per i casi d'uso che richiedono attestazioni di volume persistente, è possibile aggiungere l'annotazione localdisk.csi.acstor.io/accept-ephemeral-storage: "true" nel modello di attestazione di volume permanente.

Striping dei dati

Per ottimizzare le prestazioni, Azure Container Storage esegue automaticamente lo striping dei dati su tutti i dischi NVMe locali disponibili su base per VM. Lo striping è una tecnica in cui i dati sono suddivisi in piccoli blocchi e scritti uniformemente su più dischi contemporaneamente, aumentando la velocità effettiva e migliorando le prestazioni di I/O complessive. Questo comportamento è abilitato per impostazione predefinita e non può essere disabilitato.

Poiché le prestazioni si aggregano tra i dispositivi con striping, le dimensioni delle macchine virtuali più grandi che espongono più unità NVMe possono sbloccare operazioni di I/O al secondo e larghezza di banda notevolmente superiori. La selezione di una famiglia di macchine virtuali di dimensioni maggiori consente ai carichi di lavoro di trarre vantaggio dalla velocità effettiva aggregata aggiuntiva senza una configurazione aggiuntiva.

Ad esempio, la serie Lsv3 viene ridimensionata da una singola unità NVMe da 1,92 TB su Standard_L8s_v3 (circa 400.000 operazioni di I/O al secondo e 2.000 MB/s) fino a 10 unità NVMe su Standard_L80s_v3 (circa 3,8 milioni di operazioni di I/O al secondo e 20.000 MB/s).

Prerequisiti

• Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

• Questo articolo richiede la versione più recente (2.77.0 o successiva) dell'interfaccia della riga di comando di Azure. Vedere Come installare l'interfaccia della riga di comando di Azure. Evitare Azure Cloud Shell perché az upgrade non è disponibile in Cloud Shell. Assicurarsi di eseguire i comandi in questo articolo con privilegi amministrativi.

• Esaminare le istruzioni di installazione e verificare che Archiviazione di Azure Container sia installata correttamente.

• È necessario il client della riga di comando Kubernetes, kubectl. È possibile installarlo in locale eseguendo il az aks install-cli comando .

• Controllare se l'area di destinazione è supportata nelle aree di Azure Container Storage.

Scegliere un tipo di macchina virtuale che supporti NVMe locale

I dischi NVMe locali sono disponibili solo in determinati tipi di macchine virtuali, ad esempio macchine virtuali ottimizzate per l'archiviazione o macchine virtuali con accelerazione GPU. Se si prevede di usare la capacità NVMe locale, scegliere una di queste dimensioni della macchina virtuale.

È possibile eseguire il comando seguente per ottenere il tipo di macchina virtuale usato con il pool di nodi. Sostituire <resource group> e <cluster name> con valori personalizzati. Non è necessario specificare valori per PoolName o VmSize, quindi mantenere la query come illustrato di seguito.

az aks nodepool list --resource-group <resource group> --cluster-name <cluster name> --query "[].{PoolName:name, VmSize:vmSize}" -o table

Di seguito è riportato un esempio di risultato.

PoolName    VmSize
----------  ---------------
nodepool1   standard_l8s_v3

Note

In Archiviazione Azure Container (versione 2.x.x) è ora possibile usare cluster con meno di tre nodi.

Creare e collegare volumi temporanei generici

Se non l'hai già fatto, installa Azure Container Storage.

Segui questi passaggi per creare e collegare un volume effimero generico utilizzando il servizio Azure Storage per i Contenitori.

1. Creare una classe di archiviazione

A differenza delle versioni precedenti che richiedevano la creazione di un pool di archiviazione personalizzato, Azure Container Storage (versione 2.x.x) utilizza classi di archiviazione Kubernetes standard.

Seguire questa procedura per creare una classe di archiviazione usando nvme locale.

1. Usare l'editor di testo preferito per creare un file manifesto YAML, ad esempio code storageclass.yaml.

2. Incollare il codice seguente e salvare il file.

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: local
   provisioner: localdisk.csi.acstor.io
   reclaimPolicy: Delete
   volumeBindingMode: WaitForFirstConsumer
   allowVolumeExpansion: true
   

3. Applicare il file manifesto YAML per creare il pool di archiviazione.

   kubectl apply -f storageclass.yaml
   

2. Verificare la classe di archiviazione

Eseguire il comando seguente per verificare che la classe di archiviazione sia stata creata:

kubectl get storageclass local

Verrà visualizzato un output simile al seguente:

NAME    PROVISIONER                RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
local   localdisk.csi.acstor.io    Delete          WaitForFirstConsumer   true                   10s

3. Distribuire un pod con volume effimero generico

Creare un pod usando Fio (Flexible I/O Tester o tester di I/O flessibile) per il benchmarking e la simulazione del carico di lavoro, che usa un volume temporaneo generico.

1. Usare l'editor di testo preferito per creare un file manifesto YAML, ad esempio code fiopod.yaml.

2. Incollare il codice seguente e salvare il file.

   kind: Pod
   apiVersion: v1
   metadata:
     name: fiopod
   spec:
     nodeSelector:
       "kubernetes.io/os": linux
     containers:
       - name: fio
         image: mayadata/fio
         args: ["sleep", "1000000"]
         volumeMounts:
           - mountPath: "/volume"
             name: ephemeralvolume
     volumes:
       - name: ephemeralvolume
         ephemeral:
           volumeClaimTemplate:
             spec:
               volumeMode: Filesystem
               accessModes: ["ReadWriteOnce"]
               storageClassName: local
               resources:
                 requests:
                   storage: 10Gi
   

3. Applicare il file manifesto YAML per distribuire il pod.

   kubectl apply -f fiopod.yaml
   

4. Verificare la distribuzione ed eseguire benchmark

Verificare che il pod sia in esecuzione:

kubectl get pod fiopod

Il pod verrà visualizzato nello stato In corso di esecuzione. Dopo l'esecuzione, è possibile eseguire un test di benchmark Fio:

kubectl exec -it fiopod -- fio --name=benchtest --size=800m --filename=/volume/test --direct=1 --rw=randrw --ioengine=libaio --bs=4k --iodepth=16 --numjobs=8 --time_based --runtime=60

Creare e collegare volumi persistenti con annotazione di archiviazione effimera

Sebbene i volumi temporanei generici siano consigliati per l'archiviazione temporanea, Archiviazione Contenitori di Azure supporta anche volumi persistenti con archiviazione temporanea quando necessario per la compatibilità con i carichi di lavoro esistenti.

Note

Azure Container Storage (versione 2.x.x) usa la nuova annotazione localdisk.csi.acstor.io/accept-ephemeral-storage: "true" anziché quella precedente acstor.azure.com/accept-ephemeral-storage: "true".

1. Creare una classe di archiviazione (se non è già stata creata)

Se non è già stato fatto, installare Archiviazione di Container Azure.

Se non è stata creata una classe di archiviazione che usa NVMe locale nella sezione precedente, crearne una ora:

1. Usare l'editor di testo preferito per creare un file manifesto YAML, ad esempio code storageclass.yaml.

2. Incollare il codice seguente e salvare il file.

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: local
   provisioner: localdisk.csi.acstor.io
   reclaimPolicy: Delete
   volumeBindingMode: WaitForFirstConsumer
   allowVolumeExpansion: true
   

3. Applicare il file manifesto YAML per creare il pool di archiviazione.

   kubectl apply -f storageclass.yaml
   

2. Distribuire un set con stato con volumi persistenti

Se è necessario usare attestazioni di volume persistente che non sono associate al ciclo di vita del pod, è necessario aggiungere l'annotazione localdisk.csi.acstor.io/accept-ephemeral-storage: "true" . I dati nel volume sono locali nel nodo e vengono persi se il nodo viene eliminato o il pod viene spostato in un altro nodo.

Di seguito è riportato un esempio di set con stato che utilizza volumi persistenti con l'annotazione di archiviazione effimera:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: statefulset-lcd-lvm-annotation
  labels:
    app: busybox
spec:
  podManagementPolicy: Parallel
  serviceName: statefulset-lcd
  replicas: 10
  template:
    metadata:
      labels:
        app: busybox
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
        - name: statefulset-lcd
          image: mcr.microsoft.com/azurelinux/busybox:1.36
          command:
            - "/bin/sh"
            - "-c"
            - set -euo pipefail; trap exit TERM; while true; do date -u +"%Y-%m-%dT%H:%M:%SZ" >> /mnt/lcd/outfile; sleep 1; done
          volumeMounts:
            - name: persistent-storage
              mountPath: /mnt/lcd
  updateStrategy:
    type: RollingUpdate
  selector:
    matchLabels:
      app: busybox
  volumeClaimTemplates:
    - metadata:
        name: persistent-storage
        annotations:
          localdisk.csi.acstor.io/accept-ephemeral-storage: "true"
      spec:
        accessModes: ["ReadWriteOnce"]
        storageClassName: local
        resources:
          requests:
            storage: 10Gi

Salvare e applicare questo YAML per creare il set con stato con volumi persistenti:

kubectl apply -f statefulset-pvc.yaml

Gestire l'archiviazione

In questa sezione viene illustrato come controllare la capacità temporanea del nodo, espandere la capacità di archiviazione ed eliminare le risorse di archiviazione.

Controllare la capacità temporanea del disco del nodo

Un volume temporaneo viene allocato in un singolo nodo. Quando si configurano le dimensioni dei volumi temporanei, le dimensioni devono essere inferiori alla capacità disponibile del disco temporaneo del nodo singolo.

Assicurarsi che esista una storageClass per localdisk.csi.acstor.io . Eseguire il comando seguente per controllare la capacità disponibile del disco temporaneo per ogni nodo.

kubectl get csistoragecapacities.storage.k8s.io -n kube-system -o custom-columns=NAME:.metadata.name,STORAGE_CLASS:.storageClassName,CAPACITY:.capacity,NODE:.nodeTopology.matchLabels."topology\.localdisk\.csi\.acstor\.io/node"

L'output dovrebbe essere simile all'esempio seguente:

NAME          STORAGE_CLASS   CAPACITY    NODE
csisc-2pkx4   local           1373172Mi   aks-storagepool-31410930-vmss000001
csisc-gnmm9   local           1373172Mi   aks-storagepool-31410930-vmss000000

Se si ottiene un risultato di capacità vuoto, verifica che esista una StorageClass per localdisk.csi.acstor.io. La risorsa csistoragecapacities.storage.k8s.io viene generata solo dopo l'esistenza di un oggetto StorageClass per localdisk.csi.acstor.io.

Espandere la capacità di archiviazione

Poiché l'archiviazione su disco temporanea usa risorse locali nei nodi del cluster del servizio Azure Kubernetes, l'espansione della capacità di archiviazione richiede l'aggiunta di nodi al cluster.

Per aggiungere un nodo al cluster, eseguire il comando seguente. Sostituire <cluster-name>, <nodepool-name>, <resource-group> e <new-count> con i propri valori.

az aks nodepool scale --cluster-name <cluster-name> --name <nodepool-name> --resource-group <resource-group> --node-count <new-count>

Eliminare le risorse di archiviazione

Per pulire le risorse di archiviazione, è prima necessario eliminare tutti i valori PersistentVolumeClaims e/o PersistentVolumes. L'eliminazione di Azure Container Storage StorageClass non rimuove automaticamente PersistentVolumes/PersistentVolumeClaims esistenti.

Per eliminare una classe di archiviazione denominata local, eseguire il comando seguente:

kubectl delete storageclass local

Vedere anche

• Cos'è Archiviazione di Azure Container?
• Installare Archiviazione di Container Azure con AKS
• Usare Archiviazione di Container Azure (versione 1.x.x) con NVMe locale
• Panoramica della distribuzione di un database PostgreSQL a disponibilità elevata nel servizio Azure Kubernetes
• Procedure consigliate per dischi dati NVMe temporanei nel servizio Azure Kubernetes