Använda Azure Container Storage med lokal NVMe

Azure Container Storage är en molnbaserad volymhanterings-, distributions- och orkestreringstjänst som skapats internt för containrar. Den här artikeln visar hur du konfigurerar Azure Container Storage för att använda lokal NVMe-disk som serverdelslagring för dina Kubernetes-arbetsbelastningar. NVMe är utformat för dataöverföring med hög hastighet mellan lagring och processor, vilket ger hög IOPS och dataflöde.

Vad är lokal NVMe?

När ditt program behöver svarstid på under millisekunder och högt dataflöde kan du använda lokal NVMe med Azure Container Storage för att uppfylla dina prestandakrav. Tillfälliga innebär att diskarna distribueras på den lokala virtuella datorn (VM) som är värd för AKS-klustret och inte sparas i en Azure-lagringstjänst. Data går förlorat på dessa diskar om du stoppar/deallokerar den virtuella maskinen. Lokala NVMe-diskar erbjuds på utvalda azure VM-familjer, till exempel lagringsoptimerade virtuella datorer.

Som standard skapar Azure Container Storage allmänna tillfälliga volymer när du använder lokala NVMe-diskar. För användningsfall som kräver persistent volume claims kan du lägga till annoteringen localdisk.csi.acstor.io/accept-ephemeral-storage: "true" i din mall för persistent volume claim.

Datastripning

För att maximera prestandan strimlar Azure Container Storage automatiskt data över alla tillgängliga lokala NVMe-diskar per virtuell dator. Striping är en teknik där data delas in i små segment och skrivs jämnt över flera diskar samtidigt, vilket ökar dataflödet och förbättrar övergripande I/O-prestanda. Det här beteendet är aktiverat som standard och kan inte inaktiveras.

Eftersom prestanda aggregeras över dessa randiga enheter kan större VM-storlekar som exponerar fler NVMe-enheter låsa upp betydligt högre IOPS och bandbredd. Om du väljer en större VM-familj kan dina arbetsbelastningar dra nytta av det extra aggregerade dataflödet utan ytterligare konfiguration.

Till exempel skalar Lsv3-serien från en enda 1,92 TB NVMe-enhet på Standard_L8s_v3 (cirka 400 000 IOPS och 2 000 MB/s) upp till 10 NVMe-enheter på Standard_L80s_v3 (cirka 3,8 miljoner IOPS och 20 000 MB/s).

Förutsättningar

• Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

• Den här artikeln kräver den senaste versionen (2.77.0 eller senare) av Azure CLI. Se Så här installerar du Azure CLI. Använd inte Azure Cloud Shell eftersom az upgrade det inte är tillgängligt i Cloud Shell. Se till att köra kommandona i den här artikeln med administratörsbehörighet.

• Du behöver Kubernetes kommandoradsklient, kubectl. Du kan installera det lokalt genom att az aks install-cli köra kommandot .

• Kontrollera om målregionen stöds i Azure Container Storage-regioner.

• Nu kan du använda kluster med en enda nod, men konfigurationer med flera noder rekommenderas fortfarande.

Välj en VM-typ som stöder lokal NVMe

Lokala NVMe-diskar är endast tillgängliga i vissa typer av virtuella datorer, till exempel lagringsoptimerade virtuella datorer eller GPU-accelererade virtuella datorer. Om du planerar att använda lokal NVMe-kapacitet väljer du någon av dessa VM-storlekar.

Kör följande kommando för att hämta den vm-typ som används med nodpoolen. Ersätt <resource group> och <cluster name> med dina egna värden. Du behöver inte ange värden för PoolName eller VmSize, så behåll frågan som du ser här.

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

Följande utdata är ett exempel.

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

Skapa och bifoga generiska tillfälliga volymer

Följ de här stegen för att skapa och bifoga en allmän tillfällig volym med hjälp av Azure Container Storage.

1. Skapa en lagringsklass

Till skillnad från tidigare versioner som krävde att du skapade en anpassad lagringspoolresurs använder Azure Container Storage (version 2.x.x) kubernetes-standardlagringsklasser. Den här ändringen förenklar lagringskonfigurationsprocessen.

Följ de här stegen för att skapa en lagringsklass med hjälp av lokal NVMe.

1. Använd din favorittextredigerare för att skapa en YAML-manifestfil, code storageclass.yamltill exempel .

2. Klistra in följande kod och spara filen.

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

3. Använd YAML-manifestfilen för att skapa lagringspoolen.

   kubectl apply -f storageclass.yaml
   

2. Kontrollera lagringsklassen

Kör följande kommando för att kontrollera att lagringsklassen har skapats:

kubectl get storageclass local

Du bör se utdata som liknar följande:

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

3. Distribuera en podd med allmän tillfällig volym

Skapa en podd med Fio (flexibel I/O-testare) för benchmarking och arbetsbelastningssimulering som använder en allmän tillfällig volym.

1. Använd din favorittextredigerare för att skapa en YAML-manifestfil, code fiopod.yamltill exempel .

2. Klistra in följande kod och spara filen.

   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. Använd YAML-manifestfilen för att distribuera podden.

   kubectl apply -f fiopod.yaml
   

4. Kontrollera distributionen och kör benchmarks

Kontrollera att podden körs:

kubectl get pod fiopod

Du bör se podden i körläge. När du har kört kan du köra ett Fio-benchmark-test:

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

Skapa och koppla beständiga volymer med tillfälliga lagringsanteckningar

Generiska tillfälliga volymer rekommenderas för tillfällig lagring, men Azure Container Storage har även stöd för beständiga volymer med tillfällig lagring när det behövs för kompatibilitet med befintliga arbetsbelastningar.

1. Skapa en lagringsklass (om den inte redan har skapats)

Om du inte skapade en lagringsklass som använder lokal NVMe i föregående avsnitt skapar du en nu:

1. Använd din favorittextredigerare för att skapa en YAML-manifestfil, code storageclass.yamltill exempel .

2. Klistra in följande kod och spara filen.

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

3. Använd YAML-manifestfilen för att skapa lagringspoolen.

   kubectl apply -f storageclass.yaml
   

2. Distribuera en tillståndskänslig uppsättning med beständiga volymer

Om du behöver använda Persistent Volume Claims som inte är knutna till poddlivscykeln måste du lägga till anteckningen localdisk.csi.acstor.io/accept-ephemeral-storage: "true". Data på volymen är lokala för noden och går förlorade om noden tas bort eller podden flyttas till en annan nod.

Här är ett exempel på tillståndskänslig uppsättning med beständiga volymer med den tillfälliga lagringsanteckningen:

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

Spara och tillämpa denna YAML för att skapa den tillståndskänsliga uppsättningen med beständiga volymer:

kubectl apply -f statefulset-pvc.yaml

Hantera lagring

I det här avsnittet får du lära dig hur du kontrollerar nodens tillfälliga diskkapacitet, utökar lagringskapaciteten och tar bort lagringsresurser.

Kontrollera nodens tillfälliga diskkapacitet

En tillfällig volym allokeras på en enda nod. När du konfigurerar storleken på dina tillfälliga volymer bör storleken vara mindre än den tillgängliga kapaciteten för den enskilda nodens tillfälliga disk.

Kontrollera att en StorageClass för localdisk.csi.acstor.io finns. Kör följande kommando för att kontrollera den tillgängliga kapaciteten för tillfälliga diskar för varje nod.

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"

Du bör se utdata som liknar följande exempel:

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

Om du stöter på tomma kapacitetsutdata verifierar du att det finns en StorageClass för localdisk.csi.acstor.io. Den csistoragecapacities.storage.k8s.io resursen genereras bara efter att en StorageClass för localdisk.csi.acstor.io finns.

Utöka lagringskapaciteten

Eftersom tillfällig disklagring använder lokala resurser på AKS-klusternoderna måste du lägga till noder i klustret för att utöka lagringskapaciteten.

Om du vill lägga till en nod i klustret kör du följande kommando. Ersätt <cluster-name>, <nodepool-name>, <resource-group>och <new-count> med dina värden.

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

Ta bort lagringsresurser

Om du vill rensa lagringsresurser måste du först ta bort alla PersistentVolumeClaims och/eller PersistentVolumes. Om du tar bort Azure Container Storage StorageClass tas inte dina befintliga PersistentVolumes/PersistentVolumeClaims bort automatiskt.

Om du vill ta bort en lagringsklass med namnet local kör du följande kommando:

kubectl delete storageclass local

Se även

• Vad är Azure Container Storage?
• Använda Azure Container Storage (version 1.x.x) med lokal NVMe
• Översikt över distribution av en PostgreSQL-databas med hög tillgänglighet i Azure Kubernetes Service (AKS)