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 Azure Container Storage per usare il disco NVMe locale come storage di 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 supporta il disco NVMe locale e Azure Elastic SAN come tipi di archiviazione di base. 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 di aggregazione aggiuntiva senza più configurazione.

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 l'interfaccia della riga di comando di Azure versione 2.83.0 o successiva. Per ulteriori informazioni, vedere Come installare l'interfaccia della riga di comando di Azure. Disabilitare le estensioni, ad aks-preview esempio se si verificano problemi. Installare o aggiornare le estensioni in base alle esigenze:
- az extension add --upgrade --name k8s-extension
- az extension add --upgrade --name elastic-san (Elastic SAN solo)
È necessario il client della riga di comando Kubernetes, kubectl. È già installato se si usa Azure Cloud Shell. È possibile installarlo in locale eseguendo il az aks install-cli comando .
Controllare se l'area di destinazione è supportata nelle aree di Azure Container Storage.

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

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.

Negli scenari in cui le dimensioni delle macchine virtuali con un singolo disco NVMe locale vengono usate insieme ai dischi OS effimeri, il disco NVMe locale viene allocato per il sistema operativo, senza capacità per l'uso di Archiviazione di Container Azure. Per garantire prestazioni ottimali e disponibilità di dischi NVMe locali per l'elaborazione dei dati ad alte prestazioni, è consigliabile eseguire le operazioni seguenti:

Selezionare le dimensioni delle macchine virtuali con due o più dischi NVMe locali.
Usare i dischi gestiti per il sistema operativo, liberando tutti i dischi NVMe locali per l'elaborazione dei dati.

Per altre informazioni, vedere Procedure consigliate per dischi dati NVMe temporanei nel servizio Azure Kubernetes.

Creare una classe di archiviazione per NVMe locale

Se l'archiviazione di Azure Container non è già installata, installarla.

Azure Container Storage (versione 2.x.x) presenta l'unità NVMe locale come una classe di archiviazione standard di Kubernetes. Creare la local-csi classe di archiviazione una volta per ogni cluster e riutilizzarla sia per i volumi temporanei generici che per le attestazioni di volume persistente.

Utilizza il tuo editor di testo preferito per creare un file manifesto YAML, ad esempio storageclass.yaml, quindi incollare la specifica seguente.

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

Applicare il manifesto per creare la classe di archiviazione.
```
kubectl apply -f storageclass.yaml
```

In alternativa, è possibile creare la classe di archiviazione usando Terraform.

Usare Terraform per gestire la classe di archiviazione creando una configurazione simile alla seguente main.tf. Aggiornare la versione del provider o il percorso kubeconfig in base alle esigenze dell'ambiente.

terraform {
  required_version = ">= 1.5.0"
  required_providers {
    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "~> 3.0"
    }
  }
}

provider "kubernetes" {
  config_path = "~/.kube/config"
}

resource "kubernetes_storage_class_v1" "local_csi" {
  metadata {
    name = "local-csi"
  }

  storage_provisioner    = "localdisk.csi.acstor.io"
  reclaim_policy         = "Delete"
  volume_binding_mode    = "WaitForFirstConsumer"
  allow_volume_expansion = true
}

Inizializzare, esaminare e applicare la configurazione per creare la classe di archiviazione.
```
terraform init
terraform plan
terraform apply
```

Verificare la classe di archiviazione

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

kubectl get storageclass local-csi

Verrà visualizzato un output simile al seguente:

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

Creare e collegare volumi temporanei generici

Segui questi passaggi per creare e collegare un volume effimero generico utilizzando il servizio Azure Storage per i Contenitori. Assicurati di avere Azure Container Storage installato e che la local-csi storage class esista prima di continuare.

Distribuire un pod con un volume temporaneo 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.

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

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-csi
            resources:
              requests:
                storage: 10Gi

Applicare il file manifesto YAML per distribuire il pod.
```
kubectl apply -f fiopod.yaml
```

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".

Assicurarsi che Azure Container Storage sia installata e che la local-csi classe di archiviazione creata in precedenza sia disponibile prima di distribuire i carichi di lavoro che lo utilizzano.

Distribuire un set con stato con volumi permanenti

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-csi
        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 sia presente un oggetto 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 visualizzato sarà simile all'esempio seguente:

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

Se si riscontra un output di capacità vuoto, verificare che esista una StorageClass per localdisk.csi.acstor.io. La csistoragecapacities.storage.k8s.io risorsa 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-csi, eseguire il comando seguente:

kubectl delete storageclass local-csi

Vedere anche

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-02-12