Azure Container Storage gebruiken met lokale NVMe

Artikel
07/30/2024

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 tijdelijke schijf met lokale NVMe als back-endopslag voor uw Kubernetes-workloads. Aan het einde hebt u een pod die lokale NVMe als opslag gebruikt.

Wat is tijdelijke schijf?

Wanneer uw toepassing een opslaglatentie van sub milliseconden nodig heeft en geen duurzaamheid van gegevens vereist, kunt u kortstondige schijf 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 of de toewijzing ervan ongedaan maakt.

Er zijn twee typen tijdelijke schijf beschikbaar: lokale NVMe en tijdelijke SSD. NVMe is ontworpen voor snelle gegevensoverdracht tussen opslag en CPU. Kies NVMe wanneer uw toepassing een hogere IOPS of doorvoer nodig heeft dan tijdelijke SSD of meer opslagruimte nodig heeft. Houd er rekening mee dat Azure Container Storage alleen synchrone gegevensreplicatie voor lokale NVMe ondersteunt.

Vanwege de tijdelijke aard van deze schijven biedt Azure Container Storage standaard ondersteuning voor het gebruik van algemene kortstondige volumes bij het gebruik van tijdelijke schijven. Bepaalde gebruiksvoorbeelden kunnen echter persistente volumes aanroepen, zelfs als de gegevens niet duurzaam zijn. Als u bijvoorbeeld bestaande YAML-bestanden of implementatiesjablonen wilt gebruiken die in code zijn vastgelegd voor het gebruik van permanente volumes en uw workload ondersteuning biedt voor replicatie op toepassingsniveau voor duurzaamheid. In dergelijke gevallen kunt u uw Azure Container Storage-installatie bijwerken en de aantekening acstor.azure.com/accept-ephemeral-storage=true toevoegen in de definitie van uw permanente volumeclaim om het maken van permanente volumes van tijdelijke schijfopslaggroepen te ondersteunen.

Vereisten

Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.
Voor dit artikel is de nieuwste versie (2.35.0 of hoger) van de Azure CLI vereist. Zie Hoe u de Azure CLI installeert. Als u de Bash-omgeving in Azure Cloud Shell gebruikt, is de nieuwste versie al geïnstalleerd. Als u van plan bent om de opdrachten lokaal uit te voeren in plaats van in Azure Cloud Shell, moet u deze uitvoeren met beheerdersbevoegdheden. Zie Aan de slag met Azure Cloud Shell voor meer informatie.
U hebt de Kubernetes-opdrachtregelclient nodig. kubectl Deze is al geïnstalleerd als u Azure Cloud Shell gebruikt of als u deze lokaal kunt installeren door de opdracht uit te az aks install-cli voeren.
Als u Azure Container Storage nog niet hebt geïnstalleerd, volgt u de instructies in Azure Container Storage gebruiken met Azure Kubernetes Service.
Controleer of uw doelregio wordt ondersteund in Azure Container Storage-regio's.

Een VM-type kiezen dat ondersteuning biedt voor lokale NVMe

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

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

Hier volgt een voorbeeld van uitvoer.

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

We raden u aan dat elke virtuele machine minimaal vier virtuele CPU's (vCPU's) heeft en dat elke knooppuntgroep ten minste drie knooppunten heeft.

Algemene tijdelijke volumes maken en koppelen

Volg deze stappen om een algemeen kortstondig volume te maken en te koppelen.

1. Een opslaggroep maken

Maak eerst een opslaggroep, een logische groepering van opslag voor uw Kubernetes-cluster, door deze te definiëren in een YAML-manifestbestand.

Als u Azure Container Storage hebt ingeschakeld met behulp van az aks create of az aks update opdrachten, hebt u mogelijk al een opslaggroep. Gebruik kubectl get sp -n acstor dit om de lijst met opslaggroepen op te halen. Als u al een opslaggroep hebt die u wilt gebruiken, kunt u deze sectie overslaan en doorgaan met het weergeven van de beschikbare opslagklassen.

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

Gebruik uw favoriete teksteditor om een YAML-manifestbestand zoals code acstor-storagepool.yaml.

Plak de volgende code en sla het bestand op. De naamwaarde van de opslaggroep kan de gewenste waarde zijn.

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

Pas het YAML-manifestbestand toe om de opslaggroep te maken.
```
kubectl apply -f acstor-storagepool.yaml 
```
Wanneer het maken van de opslaggroep is voltooid, ziet u een bericht zoals:
```
storagepool.containerstorage.azure.com/ephemeraldisk-nvme created
```
U kunt deze opdracht ook uitvoeren om de status van de opslaggroep te controleren. Vervang door <storage-pool-name> de naamwaarde van uw opslaggroep. In dit voorbeeld is de waarde kortstondigedisk-nvme.
```
kubectl describe sp <storage-pool-name> -n acstor
```

Wanneer de opslaggroep wordt gemaakt, maakt Azure Container Storage namens u een opslagklasse met behulp van de naamconventie acstor-<storage-pool-name>.

2. De beschikbare opslagklassen weergeven

Wanneer de opslaggroep klaar is voor gebruik, moet u een opslagklasse selecteren om te definiëren hoe opslag dynamisch wordt gemaakt bij het maken en implementeren van volumes.

Voer uit kubectl get sc om de beschikbare opslagklassen weer te geven. Als het goed is, ziet u een opslagklasse met de naam 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

Belangrijk

Gebruik niet de opslagklasse die is gemarkeerd als intern. Het is een interne opslagklasse die nodig is om Azure Container Storage te laten werken.

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.

Gebruik uw favoriete teksteditor om een YAML-manifestbestand zoals code acstor-pod.yaml.

Plak de volgende code en sla het bestand op.

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

Wanneer u de opslaggrootte van uw volumes wijzigt, moet u ervoor zorgen dat de grootte kleiner is dan de beschikbare capaciteit van de tijdelijke schijf van één knooppunt. Zie De tijdelijke schijfcapaciteit van het knooppunt controleren.

Pas het YAML-manifestbestand toe om de pod te implementeren.
```
kubectl apply -f acstor-pod.yaml
```
De uitvoer ziet er als volgt uit:
```
pod/fiopod created
```
Controleer of de pod wordt uitgevoerd en of de tijdelijke volumeclaim is gebonden aan de pod:
```
kubectl describe pod fiopod
kubectl describe pvc fiopod-ephemeralvolume
```

Controleer fio-tests om de huidige status ervan te zien:

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

U hebt nu een pod geïmplementeerd die lokale NVMe als opslag gebruikt en u kunt deze gebruiken voor uw Kubernetes-workloads.

Permanente volumes maken en koppelen

Als u een permanent volume wilt maken op basis van een tijdelijke schijfopslaggroep, moet u een aantekening opnemen in uw persistente volumeclaims (PVC's) als een beveiliging om ervoor te zorgen dat u permanente volumes wilt gebruiken, zelfs wanneer de gegevens kortstondig zijn. Daarnaast moet u de --ephemeral-disk-volume-type vlag met de PersistentVolumeWithAnnotation waarde in uw cluster inschakelen voordat u uw permanente volumeclaims maakt.

Volg deze stappen om een permanent volume te maken en te koppelen.

1. Uw Azure Container Storage-installatie bijwerken

Voer de volgende opdracht uit om uw Azure Container Storage-installatie bij te werken om het maken van permanente volumes vanuit tijdelijke schijfopslaggroepen mogelijk te maken.

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

2. Een opslaggroep maken

Maak een opslaggroep, een logische groepering van opslag voor uw Kubernetes-cluster door deze te definiëren in een YAML-manifestbestand.

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

Gebruik uw favoriete teksteditor om een YAML-manifestbestand zoals code acstor-storagepool.yaml.

Plak de volgende code en sla het bestand op. De naamwaarde van de opslaggroep kan de gewenste waarde zijn.

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

Pas het YAML-manifestbestand toe om de opslaggroep te maken.
```
kubectl apply -f acstor-storagepool.yaml 
```
Wanneer het maken van de opslaggroep is voltooid, ziet u een bericht zoals:
```
storagepool.containerstorage.azure.com/ephemeraldisk-nvme created
```
U kunt deze opdracht ook uitvoeren om de status van de opslaggroep te controleren. Vervang door <storage-pool-name> de naamwaarde van uw opslaggroep. In dit voorbeeld is de waarde kortstondigedisk-nvme.
```
kubectl describe sp <storage-pool-name> -n acstor
```

Wanneer de opslaggroep wordt gemaakt, maakt Azure Container Storage namens u een opslagklasse met behulp van de naamconventie acstor-<storage-pool-name>.

3. De beschikbare opslagklassen weergeven

Wanneer de opslaggroep klaar is voor gebruik, moet u een opslagklasse selecteren om te definiëren hoe opslag dynamisch wordt gemaakt bij het maken en implementeren van volumes.

Voer uit kubectl get sc om de beschikbare opslagklassen weer te geven. Als het goed is, ziet u een opslagklasse met de naam 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

Belangrijk

Gebruik niet de opslagklasse die is gemarkeerd als intern. Het is een interne opslagklasse die nodig is om Azure Container Storage te laten werken.

4. Maak een permanente volumeclaim

Een permanente volumeclaim wordt gebruikt om automatisch opslag in te richten op basis van een opslagklasse. Volg deze stappen om een PVC te maken met behulp van de nieuwe opslagklasse.

Gebruik uw favoriete teksteditor om een YAML-manifestbestand zoals code acstor-pvc.yaml.

Plak de volgende code en sla het bestand op. De PVC-waarde name kan zijn wat u wilt.

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

Pas het YAML-manifestbestand toe om het PVC te maken.
```
kubectl apply -f acstor-pvc.yaml
```
De uitvoer moet er ongeveer zo uitzien:
```
persistentvolumeclaim/ephemeralpvc created
```
U kunt de status van het PVC controleren door de volgende opdracht uit te voeren:
```
kubectl describe pvc ephemeralpvc
```

Zodra het PVC is gemaakt, is het klaar voor gebruik door een pod.

5. Implementeer een pod en koppel een permanent volume

Maak een pod met Fio (Flexibele I/O-tester) voor benchmarking en workloadsimulatie en geef een koppelpad op voor het permanente volume. Gebruik voor claimName de naamwaarde die u hebt gebruikt bij het maken van de permanente volumeclaim.

Gebruik uw favoriete teksteditor om een YAML-manifestbestand zoals code acstor-pod.yaml.

Plak de volgende code en sla het bestand op.

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

Pas het YAML-manifestbestand toe om de pod te implementeren.
```
kubectl apply -f acstor-pod.yaml
```
De uitvoer ziet er als volgt uit:
```
pod/fiopod created
```
Controleer of de pod wordt uitgevoerd en of de permanente volumeclaim is gebonden aan de pod:
```
kubectl describe pod fiopod
kubectl describe pvc ephemeralpvc
```

Controleer fio-tests om de huidige status ervan te zien:

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

U hebt nu een pod geïmplementeerd die gebruikmaakt van lokale NVMe en u kunt deze gebruiken voor uw Kubernetes-workloads.

Volumes en opslaggroepen beheren

In deze sectie leert u hoe u de beschikbare capaciteit van tijdelijke schijven voor één knooppunt controleert, hoe u een opslaggroep uitvouwt of verwijdert en hoe u de prestaties optimaliseert.

Tijdelijke schijfcapaciteit van knooppunten controleren

Een kortstondig volume wordt toegewezen op één knooppunt. 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.

Voer de volgende opdracht uit om de beschikbare capaciteit van tijdelijke schijf voor één knooppunt te controleren.

$ 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

In dit voorbeeld is 75031990272 de beschikbare capaciteit van tijdelijke schijf voor één knooppunt bytes of 69 GiB.

Een opslaggroep uitvouwen

U kunt opslaggroepen uitbreiden die worden ondersteund door lokale NVMe om snel en zonder downtime omhoog te schalen. Het verkleinen van opslaggroepen wordt momenteel niet ondersteund.

Omdat een opslaggroep die wordt ondersteund door tijdelijke schijf gebruikmaakt van lokale opslagresources op de AKS-clusterknooppunten (VM's), moet u voor het uitbreiden van de opslaggroep een ander knooppunt toevoegen aan het cluster. Volg deze instructies om de opslaggroep uit te vouwen.

Voer de volgende opdracht uit om een knooppunt toe te voegen aan het AKS-cluster. Vervang <cluster-name>, <nodepool name> en <resource-group-name> door uw eigen waarden. Voer de opdracht uit kubectl get nodesom de naam van uw knooppuntgroep op te halen.
```
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
```
Voer uit kubectl get nodes en u ziet dat er een knooppunt is toegevoegd aan het cluster.
Voer uit kubectl get sp -A en u ziet dat de capaciteit van de opslaggroep is toegenomen.

Een opslaggroep verwijderen

Als u een opslaggroep wilt verwijderen, voert u de volgende opdracht uit. Vervang door <storage-pool-name> de naam van de opslaggroep.

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

Prestaties optimaliseren bij het gebruik van lokale NVMe

Afhankelijk van de prestatievereisten van uw workload kunt u kiezen uit drie verschillende prestatielagen: Basic, Standard en Premium. Uw selectie heeft invloed op het aantal vCPU's dat Azure Container Storage-onderdelen verbruiken in de knooppunten waarop deze is geïnstalleerd. Standard is de standaardconfiguratie als u de prestatielaag niet bijwerkt.

Deze drie lagen bieden een ander scala aan IOPS. De volgende tabel bevat richtlijnen voor wat u kunt verwachten met elk van deze lagen. We hebben FIO, een populair benchmarkprogramma, gebruikt om deze getallen te bereiken met de volgende configuratie:

AKS: Knooppunt-SKU - Standard_L16s_v3;
FIO: Blokgrootte - 4 KB; Wachtrijdiepte - 32; Numjobs : het aantal kernen dat is toegewezen aan containeropslagonderdelen; Toegangspatroon - willekeurig; Grootte van werkrolset - 32G

Laag	Aantal vCPU's	100 % lees-IOPS	IOPS schrijven van 100 %
`Basic`	12,5% van de totale VM-kernen	Tot 120.000	Tot 90.000
`Standard` (standaard)	25% van de totale VM-kernen	Tot 220.000	Tot 180.000
`Premium`	50% van de totale VM-kernen	Tot 550.000	Tot 360.000

Notitie

RAM- en enorme paginaverbruik blijven consistent in alle lagen: 1 GiB van RAM en 2 GiB van enorme pagina's.

Nadat u de prestatielaag hebt geïdentificeerd die het beste aansluit bij uw behoeften, kunt u de volgende opdracht uitvoeren om de prestatielaag van uw Azure Container Storage-installatie bij te werken. Vervang door <performance tier> basic, standard of premium.

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

Zie ook

Wat is Azure Container Storage?

Delen via