Använda Azure Container Storage med lokal NVMe

Artikel
07/30/2024

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 att använda tillfällig disk med lokal NVMe som serverdelslagring för dina Kubernetes-arbetsbelastningar. I slutet har du en podd som använder lokal NVMe som lagringsplats.

Vad är tillfällig disk?

När ditt program behöver svarstid på under millisekunder och inte kräver datahållbarhet kan du använda Tillfällig disk 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örlorade på dessa diskar om du stoppar/frigör den virtuella datorn.

Det finns två typer av tillfällig disk tillgänglig: lokal NVMe och temp SSD. NVMe är utformat för dataöverföring med hög hastighet mellan lagring och CPU. Välj NVMe när ditt program behöver högre IOPS eller dataflöde än temp SSD, eller kräver mer lagringsutrymme. Tänk på att Azure Container Storage endast stöder synkron datareplikering för lokal NVMe.

På grund av de här diskarnas tillfälliga karaktär stöder Azure Container Storage som standard användning av generiska tillfälliga volymer när du använder tillfälliga diskar. Vissa användningsfall kan dock kräva beständiga volymer även om data inte är varaktiga, till exempel om du vill använda befintliga YAML-filer eller distributionsmallar som är hårdkodade för att använda beständiga volymer, och din arbetsbelastning stöder replikering på programnivå för hållbarhet. I sådana fall kan du uppdatera installationen av Azure Container Storage och lägga till anteckningen acstor.azure.com/accept-ephemeral-storage=true i din beständiga volymanspråksdefinition för att stödja skapandet av beständiga volymer från tillfälliga disklagringspooler.

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.35.0 eller senare) av Azure CLI. Se Så här installerar du Azure CLI. Om du använder Bash-miljön i Azure Cloud Shell är den senaste versionen redan installerad. Om du planerar att köra kommandona lokalt i stället för i Azure Cloud Shell ska du köra dem med administratörsbehörighet. Mer information finns i Kom igång med Azure Cloud Shell.
Du behöver Kubernetes kommandoradsklient, kubectl. Det är redan installerat om du använder Azure Cloud Shell, eller om du kan installera det lokalt genom att az aks install-cli köra kommandot .
Om du inte redan har installerat Azure Container Storage följer du anvisningarna i Använda Azure Container Storage med Azure Kubernetes Service.
Kontrollera om målregionen stöds i Azure Container Storage-regioner.

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

Lokal NVMe-disk är endast tillgänglig i vissa typer av virtuella datorer, till exempel lagringsoptimerade VM-SKU:er eller GPU-accelererade VM-SKU:er. Om du planerar att använda lokal NVMe-kapacitet väljer du någon av dessa VM-SKU:er.

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 är ett exempel på utdata.

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

Vi rekommenderar att varje virtuell dator har minst fyra virtuella processorer (vCPU:er) och att varje nodpool har minst tre noder.

Skapa och bifoga generiska tillfälliga volymer

Följ dessa steg för att skapa och bifoga en allmän tillfällig volym.

1. Skapa en lagringspool

Skapa först en lagringspool, som är en logisk gruppering av lagring för ditt Kubernetes-kluster, genom att definiera den i en YAML-manifestfil.

Om du har aktiverat Azure Container Storage med hjälp av az aks create eller az aks update kommandon kanske du redan har en lagringspool. Använd kubectl get sp -n acstor för att hämta listan över lagringspooler. Om du redan har en tillgänglig lagringspool som du vill använda kan du hoppa över det här avsnittet och fortsätta till Visa tillgängliga lagringsklasser.

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

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

Klistra in följande kod och spara filen. Värdet för lagringspoolens namn kan vara vad du vill.

apiVersion: containerstorage.azure.com/v1
kind: StoragePool
metadata:
  name: ephemeraldisk-nvme
  namespace: acstor
spec:
  poolType:
    ephemeralDisk:
      diskType: nvme

Använd YAML-manifestfilen för att skapa lagringspoolen.
```
kubectl apply -f acstor-storagepool.yaml 
```
När lagringspoolen har skapats visas ett meddelande som:
```
storagepool.containerstorage.azure.com/ephemeraldisk-nvme created
```
Du kan också köra det här kommandot för att kontrollera lagringspoolens status. Ersätt <storage-pool-name> med värdet för lagringspoolens namn . I det här exemplet skulle värdet vara tillfälligadisk-nvme.
```
kubectl describe sp <storage-pool-name> -n acstor
```

När lagringspoolen skapas skapar Azure Container Storage en lagringsklass åt dig med hjälp av namngivningskonventionen acstor-<storage-pool-name>.

2. Visa tillgängliga lagringsklasser

När lagringspoolen är redo att användas måste du välja en lagringsklass för att definiera hur lagring skapas dynamiskt när du skapar och distribuerar volymer.

Kör kubectl get sc för att visa tillgängliga lagringsklasser. Du bör se en lagringsklass med namnet acstor-<storage-pool-name>.

$ kubectl get sc | grep "^acstor-"
acstor-azuredisk-internal   disk.csi.azure.com               Retain          WaitForFirstConsumer   true                   65m
acstor-ephemeraldisk-nvme        containerstorage.csi.azure.com   Delete          WaitForFirstConsumer   true                   2m27s

Viktigt!

Använd inte lagringsklassen som är markerad som intern. Det är en intern lagringsklass som behövs för att Azure Container Storage ska fungera.

3. Distribuera en podd med en 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.

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

Klistra in följande kod och spara filen.

kind: Pod
apiVersion: v1
metadata:
  name: fiopod
spec:
  nodeSelector:
    acstor.azure.com/io-engine: acstor
  containers:
    - name: fio
      image: nixery.dev/shell/fio
      args:
        - sleep
        - "1000000"
      volumeMounts:
        - mountPath: "/volume"
          name: ephemeralvolume
  volumes:
    - name: ephemeralvolume
      ephemeral:
        volumeClaimTemplate:
          metadata:
            labels:
              type: my-ephemeral-volume
          spec:
            accessModes: [ "ReadWriteOnce" ]
            storageClassName: acstor-ephemeraldisk-nvme # replace with the name of your storage class if different
            resources:
              requests:
                storage: 1Gi

När du ändrar lagringsstorleken för dina volymer kontrollerar du att storleken är mindre än den tillgängliga kapaciteten för en enskild nods tillfälliga disk. Se Kontrollera nodens tillfälliga diskkapacitet.

Använd YAML-manifestfilen för att distribuera podden.
```
kubectl apply -f acstor-pod.yaml
```
Du bör se utdata som liknar följande:
```
pod/fiopod created
```
Kontrollera att podden körs och att det tillfälliga volymanspråket har bundits till podden:
```
kubectl describe pod fiopod
kubectl describe pvc fiopod-ephemeralvolume
```

Kontrollera fio-testningen för att se dess aktuella status:

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

Nu har du distribuerat en podd som använder lokal NVMe som lagringsplats, och du kan använda den för dina Kubernetes-arbetsbelastningar.

Skapa och koppla beständiga volymer

Om du vill skapa en beständig volym från en tillfällig disklagringspool måste du inkludera en anteckning i dina beständiga volymanspråk (PVCs) som ett skydd för att säkerställa att du tänker använda beständiga volymer även när data är tillfälliga. Dessutom måste du aktivera --ephemeral-disk-volume-type flaggan med PersistentVolumeWithAnnotation värdet i klustret innan du skapar dina beständiga volymanspråk.

Följ de här stegen för att skapa och koppla en beständiga volym.

1. Uppdatera installationen av Azure Container Storage

Kör följande kommando för att uppdatera azure containerlagringsinstallationen så att du kan skapa beständiga volymer från tillfälliga disklagringspooler.

az aks update -n <cluster-name> -g <resource-group> --enable-azure-container-storage ephemeralDisk --storage-pool-option NVMe --ephemeral-disk-volume-type PersistentVolumeWithAnnotation

2. Skapa en lagringspool

Skapa en lagringspool, som är en logisk gruppering av lagring för kubernetes-klustret, genom att definiera den i en YAML-manifestfil.

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

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

Klistra in följande kod och spara filen. Värdet för lagringspoolens namn kan vara vad du vill.

apiVersion: containerstorage.azure.com/v1
kind: StoragePool
metadata:
  name: ephemeraldisk-nvme
  namespace: acstor
spec:
  poolType:
    ephemeralDisk:
      diskType: nvme

Använd YAML-manifestfilen för att skapa lagringspoolen.
```
kubectl apply -f acstor-storagepool.yaml 
```
När lagringspoolen har skapats visas ett meddelande som:
```
storagepool.containerstorage.azure.com/ephemeraldisk-nvme created
```
Du kan också köra det här kommandot för att kontrollera lagringspoolens status. Ersätt <storage-pool-name> med värdet för lagringspoolens namn . I det här exemplet skulle värdet vara tillfälligadisk-nvme.
```
kubectl describe sp <storage-pool-name> -n acstor
```

När lagringspoolen skapas skapar Azure Container Storage en lagringsklass åt dig med hjälp av namngivningskonventionen acstor-<storage-pool-name>.

3. Visa tillgängliga lagringsklasser

När lagringspoolen är redo att användas måste du välja en lagringsklass för att definiera hur lagring skapas dynamiskt när du skapar och distribuerar volymer.

Kör kubectl get sc för att visa tillgängliga lagringsklasser. Du bör se en lagringsklass med namnet acstor-<storage-pool-name>.

$ kubectl get sc | grep "^acstor-"
acstor-azuredisk-internal   disk.csi.azure.com               Retain          WaitForFirstConsumer   true                   65m
acstor-ephemeraldisk-nvme        containerstorage.csi.azure.com   Delete          WaitForFirstConsumer   true                   2m27s

Viktigt!

Använd inte lagringsklassen som är markerad som intern. Det är en intern lagringsklass som behövs för att Azure Container Storage ska fungera.

4. Skapa ett beständiga volymanspråk

Ett beständiga volymanspråk används för att automatiskt etablera lagring baserat på en lagringsklass. Följ dessa steg för att skapa en PVC med hjälp av den nya lagringsklassen.

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

Klistra in följande kod och spara filen. PVC-värdet name kan vara vad du vill.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ephemeralpvc
  annotations:
    acstor.azure.com/accept-ephemeral-storage: "true"
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: acstor-ephemeraldisk-nvme # replace with the name of your storage class if different
  resources:
    requests:
      storage: 100Gi

Använd YAML-manifestfilen för att skapa PVC.
```
kubectl apply -f acstor-pvc.yaml
```
Du bör se utdata som liknar följande:
```
persistentvolumeclaim/ephemeralpvc created
```
Du kan kontrollera status för PVC genom att köra följande kommando:
```
kubectl describe pvc ephemeralpvc
```

När PVC:en har skapats är den redo att användas av en podd.

5. Distribuera en podd och bifoga en beständiga volym

Skapa en podd med Fio (flexibel I/O-testare) för benchmarking och arbetsbelastningssimulering och ange en monteringssökväg för den beständiga volymen. För claimName använder du det namnvärde som du använde när du skapade det beständiga volymanspråket.

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

Klistra in följande kod och spara filen.

kind: Pod
apiVersion: v1
metadata:
  name: fiopod
spec:
  nodeSelector:
    acstor.azure.com/io-engine: acstor
  volumes:
    - name: ephemeralpv
      persistentVolumeClaim:
        claimName: ephemeralpvc
  containers:
    - name: fio
      image: nixery.dev/shell/fio
      args:
        - sleep
        - "1000000"
      volumeMounts:
        - mountPath: "/volume"
          name: ephemeralpv

Använd YAML-manifestfilen för att distribuera podden.
```
kubectl apply -f acstor-pod.yaml
```
Du bör se utdata som liknar följande:
```
pod/fiopod created
```
Kontrollera att podden körs och att det beständiga volymanspråket har bundits till podden:
```
kubectl describe pod fiopod
kubectl describe pvc ephemeralpvc
```

Kontrollera fio-testningen för att se dess aktuella status:

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

Nu har du distribuerat en podd som använder lokal NVMe och du kan använda den för dina Kubernetes-arbetsbelastningar.

Hantera volymer och lagringspooler

I det här avsnittet får du lära dig hur du kontrollerar den tillgängliga kapaciteten för tillfälliga diskar för en enskild nod, hur du expanderar eller tar bort en lagringspool och hur du optimerar prestanda.

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.

Kör följande kommando för att kontrollera den tillgängliga kapaciteten för tillfälliga diskar för en enskild nod.

$ kubectl get diskpool -n acstor
NAME                                CAPACITY      AVAILABLE     USED        RESERVED    READY   AGE
ephemeraldisk-nvme-diskpool-jaxwb   75660001280   75031990272   628011008   560902144   True    21h
ephemeraldisk-nvme-diskpool-wzixx   75660001280   75031990272   628011008   560902144   True    21h
ephemeraldisk-nvme-diskpool-xbtlj   75660001280   75031990272   628011008   560902144   True    21h

I det här exemplet är 75031990272 den tillgängliga kapaciteten för tillfälliga diskar för en enskild nod byte eller 69 GiB.

Expandera en lagringspool

Du kan expandera lagringspooler som backas upp av lokala NVMe för att skala upp snabbt och utan stilleståndstid. Krympande lagringspooler stöds inte för närvarande.

Eftersom en lagringspool som backas upp av tillfälliga diskar använder lokala lagringsresurser på AKS-klusternoderna (VM: ar), måste du lägga till en annan nod i klustret för att expandera lagringspoolen. Följ de här anvisningarna för att expandera lagringspoolen.

Kör följande kommando för att lägga till en nod i AKS-klustret. Ersätt <cluster-name>, <nodepool name> och <resource-group-name> med dina egna värden. Kör för att hämta namnet på nodpoolen kubectl get nodes.
```
az aks nodepool add --cluster-name <cluster name> --name <nodepool name> --resource-group <resource group> --node-vm-size Standard_L8s_v3 --node-count 1 --labels acstor.azure.com/io-engine=acstor
```
Kör kubectl get nodes så ser du att en nod har lagts till i klustret.
Kör kubectl get sp -A och du bör se att lagringspoolens kapacitet har ökat.

Ta bort en lagringspool

Kör följande kommando om du vill ta bort en lagringspool. Ersätt <storage-pool-name> med namnet på lagringspoolen.

kubectl delete sp -n acstor <storage-pool-name>

Optimera prestanda när du använder lokal NVMe

Beroende på arbetsbelastningens prestandakrav kan du välja mellan tre olika prestandanivåer: Basic, Standard och Premium. Ditt val påverkar antalet vCPU:er som Azure Container Storage-komponenter använder i noderna där de är installerade. Standard är standardkonfigurationen om du inte uppdaterar prestandanivån.

Dessa tre nivåer erbjuder ett annat IOPS-intervall. Följande tabell innehåller vägledning om vad du kan förvänta dig med var och en av dessa nivåer. Vi använde FIO, ett populärt benchmarkingverktyg, för att uppnå dessa siffror med följande konfiguration:

AKS: Node SKU – Standard_L16s_v3;
FIO: Blockstorlek - 4 KB; Ködjup – 32; Numjobs – antalet kärnor som tilldelats containerlagringskomponenter. Åtkomstmönster – slumpmässigt; Arbetsuppsättningsstorlek – 32 G

Nivå	Antal vCPU:er	100 % läs-IOPS	100 % skriv-IOPS
`Basic`	12,5 % av de totala VM-kärnorna	Upp till 120 000	Upp till 90 000
`Standard` (standard)	25 % av de totala VM-kärnorna	Upp till 220 000	Upp till 180 000
`Premium`	50 % av de totala VM-kärnorna	Upp till 550 000	Upp till 360 000

Kommentar

RAM och enorma sidor förbrukning kommer att förbli konsekvent över alla nivåer: 1 GiB RAM och 2 GiB av enorma sidor.

När du har identifierat den prestandanivå som passar bäst för dina behov kan du köra följande kommando för att uppdatera prestandanivån för din Azure Container Storage-installation. Ersätt <performance tier> med basic, standard eller premium.

az aks update -n <cluster-name> -g <resource-group> --enable-azure-container-storage <storage-pool-type> --ephemeral-disk-nvme-perf-tier <performance-tier>

Se även

Vad är Azure Container Storage?

Dela via