Azure Container Storage gebruiken met lokale NVMe

Azure Container Storage is een cloudgebaseerde volumebeheer-, implementatie- en indelingsservice die systeemeigen is gebouwd voor containers. In dit artikel leest u hoe u Azure Container Storage configureert voor het gebruik van lokale NVMe-schijf als back-endopslag voor uw Kubernetes-workloads. NVMe is ontworpen voor snelle gegevensoverdracht tussen opslag en CPU en biedt hoge IOPS en doorvoer.

Wat is lokale NVMe?

Wanneer uw toepassing een latentie van sub milliseconden voor opslag en hoge doorvoer nodig heeft, kunt u lokale NVMe met Azure Container Storage gebruiken om te voldoen aan uw prestatievereisten. Kortstondig betekent dat de schijven worden geïmplementeerd op de lokale virtuele machine (VM) die als host fungeert voor het AKS-cluster en niet zijn opgeslagen in een Azure-opslagservice. Gegevens gaan verloren op deze schijven als u uw VIRTUELE machine stopt/de toewijzing ervan ongedaan maakt. Lokale NVMe-schijven worden aangeboden voor bepaalde Azure VM-families, zoals vm's die zijn geoptimaliseerd voor opslag .

Azure Container Storage maakt standaard algemene tijdelijke volumes wanneer u lokale NVMe-schijven gebruikt. Voor gebruiksvoorbeelden waarvoor permanente volumeclaims zijn vereist, kunt u de aantekening localdisk.csi.acstor.io/accept-ephemeral-storage: "true" toevoegen in uw permanente volumeclaimsjabloon.

Gegevensstriping

Om de prestaties te maximaliseren, worden in Azure Container Storage gegevens automatisch over alle beschikbare lokale NVMe-schijven gestriped, op basis van één VM per keer. Striping is een techniek waarbij gegevens worden onderverdeeld in kleine segmenten en gelijkmatig over meerdere schijven tegelijk worden geschreven, waardoor de doorvoer toeneemt en de algehele I/O-prestaties worden verbeterd. Dit gedrag is standaard ingeschakeld en kan niet worden uitgeschakeld.

Omdat de prestaties van deze gestreepte apparaten worden samengevoegd, kunnen grotere VM-groottes die meer NVMe-stations beschikbaar maken, aanzienlijk hogere IOPS en bandbreedte realiseren. Als u een grotere VM-serie selecteert, kunnen uw workloads profiteren van de extra geaggregeerde doorvoer zonder extra configuratie.

De Lsv3-serie schaalt bijvoorbeeld van één NVMe-station van 1,92 TB op Standard_L8s_v3 (ongeveer 400.000 IOPS en 20.000 MB/s) tot 10 NVMe-stations op Standard_L80s_v3 (ongeveer 3,8 miljoen IOPS en 20.000 MB/s).

Vereisten

• Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.

• Voor dit artikel is de nieuwste versie (2.77.0 of hoger) van de Azure CLI vereist. Zie Hoe u de Azure CLI installeert. Gebruik Azure Cloud Shell niet, omdat az upgrade deze niet beschikbaar is in Cloud Shell. Zorg ervoor dat u de opdrachten in dit artikel uitvoert met beheerdersbevoegdheden.

• U hebt de Kubernetes-opdrachtregelclient nodig. kubectl U kunt deze lokaal installeren door de az aks install-cli opdracht uit te voeren.

• Controleer of uw doelregio wordt ondersteund in Azure Container Storage-regio's.

• U kunt nu clusters met één knooppunt gebruiken, hoewel configuraties met meerdere knooppunten nog steeds worden aanbevolen.

Een VM-type kiezen dat ondersteuning biedt voor lokale NVMe

Lokale NVMe-schijven zijn alleen beschikbaar in bepaalde typen VM's, bijvoorbeeld voor opslag geoptimaliseerde VM's of versnelde GPU-VM's. Als u van plan bent om lokale NVMe-capaciteit te gebruiken, kiest u een van deze VM-grootten.

Voer de volgende opdracht uit om het VM-type op te halen dat wordt gebruikt met uw knooppuntgroep. Vervang <resource group> en <cluster name> door uw eigen waarden. U hoeft geen waarden op te geven voor PoolName of VmSize, dus behoud de query zoals hier wordt weergegeven.

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

De volgende uitvoer is een voorbeeld.

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

Algemene tijdelijke volumes maken en koppelen

Volg deze stappen om een algemeen kortstondig volume te maken en te koppelen met behulp van Azure Container Storage.

1. Een opslagklasse maken

In tegenstelling tot eerdere versies die een aangepaste opslaggroepresource moesten maken, maakt Azure Container Storage (versie 2.x.x) gebruik van standaard Kubernetes-opslagklassen. Deze wijziging vereenvoudigt het opslagconfiguratieproces.

Volg deze stappen om een opslagklasse te maken met behulp van lokale NVMe.

1. Gebruik uw favoriete teksteditor om een YAML-manifest zoals code storageclass.yaml te maken.

2. Plak de volgende code en sla het bestand op.

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

3. Pas het YAML-manifestbestand toe om de opslaggroep te maken.

   kubectl apply -f storageclass.yaml
   

2. Controleer de opslagklasse

Voer de volgende opdracht uit om te controleren of de opslagklasse is gemaakt:

kubectl get storageclass local

De uitvoer moet er ongeveer zo uitzien:

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

3. Implementeer een pod met een algemeen kortstondig volume

Maak een pod met Fio (Flexible I/O Tester) voor benchmarking en workloadsimulatie die gebruikmaakt van een algemeen kortstondig volume.

1. Gebruik uw favoriete teksteditor om een YAML-manifest zoals code fiopod.yaml te maken.

2. Plak de volgende code en sla het bestand op.

   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. Pas het YAML-manifestbestand toe om de pod te implementeren.

   kubectl apply -f fiopod.yaml
   

4. Controleer de implementatie en voer benchmarks uit

Controleer of de pod draait.

kubectl get pod fiopod

U zou de pod in de status Running moeten zien. Zodra deze is uitgevoerd, kunt u een Fio-benchmarktest uitvoeren:

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

Permanente volumes maken en koppelen met tijdelijke opslagaantekening

Hoewel algemene kortstondige volumes worden aanbevolen voor tijdelijke opslag, ondersteunt Azure Container Storage ook permanente volumes met tijdelijke opslag wanneer dat nodig is voor compatibiliteit met bestaande workloads.

1. Een opslagklasse maken (indien nog niet gemaakt)

Als u geen opslagklasse hebt gemaakt die gebruikmaakt van lokale NVMe in de vorige sectie, maakt u er nu een:

1. Gebruik uw favoriete teksteditor om een YAML-manifest zoals code storageclass.yaml te maken.

2. Plak de volgende code en sla het bestand op.

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

3. Pas het YAML-manifestbestand toe om de opslaggroep te maken.

   kubectl apply -f storageclass.yaml
   

2. Implementeer een stateful set met persistente volumes

Als u permanente volumeclaims wilt gebruiken die niet zijn gekoppeld aan de levenscyclus van de pod, moet u de localdisk.csi.acstor.io/accept-ephemeral-storage: "true" aantekening toevoegen. De gegevens op het volume zijn lokaal voor het knooppunt en gaan verloren als het knooppunt wordt verwijderd of als de pod naar een ander knooppunt wordt verplaatst.

Hier volgt een voorbeeld van een stateful set met behulp van permanente volumes met de tijdelijke opslagaantekening:

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

Sla deze YAML op en pas deze toe om de stateful set met permanente volumes te maken:

kubectl apply -f statefulset-pvc.yaml

Opslag beheren

In deze sectie leert u hoe u de tijdelijke schijfcapaciteit van knooppunten controleert, de opslagcapaciteit uitbreidt en opslagresources verwijdert.

Tijdelijke schijfcapaciteit van knooppunten controleren

Op één knooppunt wordt een ephemerisch volume toegewezen. Wanneer u de grootte van uw tijdelijke volumes configureert, moet de grootte kleiner zijn dan de beschikbare capaciteit van de tijdelijke schijf van het enkele knooppunt.

Zorg ervoor dat er een StorageClass voor localdisk.csi.acstor.io bestaat. Voer de volgende opdracht uit om de beschikbare capaciteit van tijdelijke schijf voor elk knooppunt te controleren.

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"

U zou uitvoer moeten zien die lijkt op het volgende voorbeeld:

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

Als u lege capaciteitsuitvoer tegenkomt, controleert u of er een StorageClass voor localdisk.csi.acstor.io bestaat. De csistoragecapacities.storage.k8s.io resource wordt alleen gegenereerd nadat er een StorageClass voor localdisk.csi.acstor.io bestaat.

Opslagcapaciteit uitbreiden

Omdat er bij tijdelijke schijfopslag gebruik wordt gemaakt van lokale resources op de AKS-clusterknooppunten, vereist het uitbreiden van de opslagcapaciteit het toevoegen van knooppunten aan het cluster.

Voer de volgende opdracht uit om een knooppunt toe te voegen aan uw cluster. Vervang <cluster-name>, <nodepool-name>, <resource-group>en <new-count> door uw waarden.

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

Opslagbronnen verwijderen

Als u opslagbronnen wilt opschonen, moet u eerst alle PersistentVolumeClaims en/of PersistentVolumes verwijderen. Als u azure Container Storage StorageClass verwijdert, wordt uw bestaande PersistentVolumes/PersistentVolumeClaims niet automatisch verwijderd.

Als u een lokale opslagklasse wilt verwijderen, voert u de volgende opdracht uit:

kubectl delete storageclass local

Zie ook

• Wat is Azure Container Storage?
• Azure Container Storage (versie 1.x.x) gebruiken met lokale NVMe
• Overzicht van het implementeren van een maximaal beschikbare PostgreSQL-database in Azure Kubernetes Service (AKS)