Freigeben über

Verwenden von Azure Container Storage mit lokalem NVMe

Azure Container Storage ist ein cloudbasierter Dienst zum Verwalten, Bereitstellen und Orchestrieren von Volumes, der nativ für Container entwickelt wurde. In diesem Artikel erfahren Sie, wie Sie Azure Container Storage so konfigurieren, dass der lokale NVMe-Datenträger als Back-End-Speicher für Ihre Kubernetes-Workloads verwendet wird. NVMe ist für die Datenübertragung mit hoher Geschwindigkeit zwischen Speicher und CPU konzipiert und bietet hohe IOPS und hohen Durchsatz.

Wichtig

Dieser Artikel bezieht sich auf Azure Container Storage (Version 2.x.x), der derzeit nur den lokalen NVMe-Datenträger für den Sicherungsspeicher unterstützt. Ausführliche Informationen zu früheren Versionen finden Sie in der Dokumentation zu Azure Container Storage (Version 1.x.x).

Was ist lokales NVMe?

Wenn Ihre Anwendung unter Millisekunden Speicherlatenz und hohen Durchsatz benötigt, können Sie lokale NVMe-Datenträger mit Azure Container Storage verwenden, um Ihre Leistungsanforderungen zu erfüllen. „Kurzlebig“ bedeutet, dass die Datenträger auf dem lokalen virtuellen Computer (VM), der den AKS-Cluster hostet, bereitgestellt und nicht in einem Azure-Speicherdienst gespeichert werden. Daten gehen auf diesen Datenträgern verloren, wenn Sie ihre VM beenden/verlagern. Lokale NVMe-Datenträger werden für ausgewählte Azure-VM-Familien wie speicheroptimierte VMs angeboten.

Standardmäßig erstellt Azure Container Storage generische ephemerale Volumes bei Verwendung lokaler NVMe-Datenträger. Bei Anwendungsfällen, für die Persistent Volume Claims erforderlich sind, können Sie die Annotation localdisk.csi.acstor.io/accept-ephemeral-storage: "true" in der Persistent Volume Claim Vorlage hinzufügen.

Datenstreifen

Um die Leistung zu maximieren, verteilt Azure Container Storage Daten automatisch auf alle verfügbaren lokalen NVMe-Datenträger pro VM. Das Striping ist eine Technik, bei der Daten in kleine Blöcke unterteilt und gleichmäßig auf mehreren Datenträgern gleichzeitig geschrieben werden, wodurch der Durchsatz erhöht und die Gesamtleistung von E/A verbessert wird. Dieses Verhalten ist standardmäßig aktiviert und kann nicht deaktiviert werden.

Da die Leistung auf diesen gestreiften Geräten aggregiert wird, können größere VM-Größen, die mehr NVMe-Laufwerke verfügbar machen, wesentlich höhere IOPS und Bandbreite entsperren. Wenn Sie eine größere VM-Familie auswählen, profitieren Ihre Workloads vom zusätzlichen Aggregatdurchsatz ohne zusätzliche Konfiguration.

Beispielsweise skaliert die Lsv3-Serie von einem einzelnen NVMe-Laufwerk von 1,92 TB auf Standard_L8s_v3 (ca. 400.000 IOPS und 2.000 MB/s) bis zu 10 NVMe-Laufwerke auf Standard_L80s_v3 (ca. 3,8 Millionen IOPS und 20.000 MB/s).

Voraussetzungen

  • Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

  • Dieser Artikel erfordert die neueste Version (2.77.0 oder höher) der Azure CLI. Weitere Informationen finden Sie unter Installieren der Azure-Befehlszeilenschnittstelle. Vermeiden Sie Azure Cloud Shell, da az upgrade sie in Cloud Shell nicht verfügbar ist. Führen Sie die Befehle in diesem Artikel mit Administratorrechten aus.

  • Überprüfen Sie die Installationsanweisungen , und stellen Sie sicher, dass Azure Container Storage ordnungsgemäß installiert ist.

  • Sie benötigen den Kubernetes-Befehlszeilenclient. kubectl Sie können es lokal installieren, indem Sie den az aks install-cli Befehl ausführen.

  • Überprüfen Sie unter Azure Container Storage-Regionen, ob Ihre Zielregion unterstützt wird.

Auswählen eines VM-Typs, der lokale NVMe unterstützt

Lokale NVMe-Datenträger sind nur in bestimmten Typen von VMs verfügbar, z. B. speicheroptimierte VMs oder gpubeschleunigte VMs. Wenn Sie die lokale NVMe-Kapazität verwenden möchten, wählen Sie eine dieser VM-Größen aus.

Führen Sie den folgenden Befehl aus, um den VM-Typ abzurufen, der mit Ihrem Knotenpool verwendet wird. Ersetzen Sie <resource group> und <cluster name> durch Ihre eigenen Werte. Sie müssen keine Werte für PoolName oder VmSize angeben, damit die Abfrage wie hier dargestellt beibehalten wird.

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

Die folgende Ausgabe dient als Beispiel.

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

Hinweis

In Azure Container Storage (Version 2.x.x) können Sie jetzt Cluster mit weniger als drei Knoten verwenden.

Erstellen einer Speicherklasse für lokale NVMe

Falls noch nicht geschehen, installieren Sie Azure Container Storage.

Azure Container Storage (Version 2.x.x) stellt lokale NVMe als Standard-Kubernetes-Speicherklasse dar. Erstellen Sie die local Speicherklasse einmal pro Cluster, und verwenden Sie sie sowohl für generische ephemerale Volumes als auch für dauerhafte Volumeansprüche.

  1. Verwenden Sie Ihren bevorzugten Texteditor, um eine YAML-Manifestdatei wie storageclass.yaml zu erstellen, und fügen Sie dann die folgende Spezifikation ein.

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

  2. Wenden Sie das Manifest an, um die Speicherklasse zu erstellen.

    kubectl apply -f storageclass.yaml

Alternativ können Sie die Speicherklasse mithilfe von Terraform erstellen.

  1. Verwenden Sie Terraform, um die Speicherklasse zu verwalten, indem Sie eine Konfiguration wie die folgende main.tferstellen. Aktualisieren Sie den Anbieterversions- oder Kubeconfig-Pfad nach Bedarf für Ihre Umgebung.

    terraform {
  required_version = ">= 1.5.0"
  required_providers {
    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "~> 3.x"
    }
  }
}

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

resource "kubernetes_storage_class_v1" "local" {
  metadata {
    name = "local"
  }

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

  2. Initialisieren, Überprüfen und Anwenden der Konfiguration zum Erstellen der Speicherklasse.

    terraform init
terraform plan
terraform apply

Überprüfen der Speicherklasse

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Speicherklasse erstellt wird:

kubectl get storageclass local

Eine ähnliche Ausgabe wie die folgende sollte angezeigt werden:

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

Erstellen und Anfügen generischer kurzlebiger Volumes

Führen Sie die folgenden Schritte aus, um ein generisches ephemeres Volume mit Azure Container Storage zu erstellen und anzufügen. Stellen Sie sicher, dass Azure Container Storage installiert ist und die local Speicherklasse vorhanden ist, bevor Sie fortfahren.

Bereitstellen eines Pods mit einem generischen kurzlebigen Volume

Erstellen Sie einen Pod mithilfe von FIO (Flexibler E/A-Tester) für die Benchmarking und Workloadsimulation, die ein generisches, kurzlebiges Volume verwendet.

  1. Verwenden Sie Ihren bevorzugten Text-Editor, um eine YAML-Manifestdatei wie code fiopod.yaml zu erstellen.

  2. Fügen Sie den folgenden Code ein, und speichern Sie die Datei.

    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. Wenden Sie die YAML-Manifestdatei an, um den Pod bereitzustellen.

    kubectl apply -f fiopod.yaml

Überprüfen der Bereitstellung und Ausführen von Benchmarks

Überprüfen Sie, ob der Pod ausgeführt wird:

kubectl get pod fiopod

Der Pod sollte den Zustand „Wird ausgeführt“ aufweisen. Nach der Ausführung können Sie einen Fio-Benchmarktest ausführen:

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

Erstellen und Verbinden persistenter Volumes mit flüchtiger Speicheranmerkung

Während generische ephemerale Volumes für den kurzlebigen Speicher empfohlen werden, unterstützt Azure Container Storage auch persistente Volumes mit ephemerem Speicher, wenn sie für die Kompatibilität mit vorhandenen Workloads erforderlich sind.

Hinweis

Azure Container Storage (Version 2.x.x) verwendet die neue Anmerkung localdisk.csi.acstor.io/accept-ephemeral-storage: "true" anstelle des vorherigen acstor.azure.com/accept-ephemeral-storage: "true".

Stellen Sie sicher, dass Azure Container Storage installiert ist und die local zuvor erstellte Speicherklasse verfügbar ist, bevor Sie Workloads bereitstellen, die sie verwenden.

Bereitstellen eines StatefulSets mit persistenten Volumes

Wenn Sie persistente Volumeansprüche verwenden müssen, die nicht an den Pod-Lebenszyklus gebunden sind, müssen Sie die localdisk.csi.acstor.io/accept-ephemeral-storage: "true" Anmerkung hinzufügen. Die Daten auf dem Volume befinden sich lokal auf dem Knoten und gehen verloren, wenn der Knoten gelöscht oder der Pod in einen anderen Knoten verschoben wird.

Hier ist ein Beispiel für ein StatefulSet mit persistenten Volumes und der kurzlebigen Speicheranmerkung:

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

Speichern Sie diese YAML, und wenden Sie sie an, um den StatefulSet mit persistenten Volumes zu erstellen:

kubectl apply -f statefulset-pvc.yaml

Speicher verwalten

In diesem Abschnitt erfahren Sie, wie Sie die ephemere Speicherkapazität des Knotens überprüfen, die Speicherkapazität erweitern und Speicherressourcen löschen.

Überprüfen der Ephemeralkapazität des Knotens

Ein kurzlebiges Volume wird einem einzelnen Knoten zugewiesen. Wenn Sie die Größe Ihrer kurzlebigen Volumes konfigurieren, sollte diese kleiner als die verfügbare Kapazität des kurzlebigen Datenträgers des einzelnen Knotens sein.

Stellen Sie sicher, dass eine StorageClass localdisk.csi.acstor.io vorhanden ist. Führen Sie den folgenden Befehl aus, um die verfügbare Kapazität des kurzlebigen Datenträgers für jeden Knoten zu überprüfen.

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"

Die Ausgabe sollte etwa folgendem Beispiel entsprechen:

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

Wenn Sie eine leere Kapazitätsausgabe erhalten, vergewissern Sie sich, dass eine StorageClass localdisk.csi.acstor.io existiert. Die Ressource csistoragecapacities.storage.k8s.io wird nur generiert, nachdem eine StorageClass localdisk.csi.acstor.io vorhanden ist.

Erweitern der Speicherkapazität

Da der kurzlebige Datenträgerspeicher lokale Ressourcen auf den AKS-Clusterknoten verwendet, erfordert die Erweiterung der Speicherkapazität das Hinzufügen von Knoten zum Cluster.

Führen Sie den folgenden Befehl aus, um Ihrem Cluster einen Knoten hinzuzufügen. Ersetzen Sie <cluster-name>, <nodepool-name>, <resource-group>und <new-count> durch Ihre Werte.

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

Löschen von Speicherressourcen

Zum Bereinigen von Speicherressourcen müssen Sie zuerst alle PersistentVolumeClaims und/oder PersistentVolumes löschen. Durch das Löschen der Azure Container Storage StorageClass werden Ihre vorhandenen PersistentVolumes/PersistentVolumeClaims nicht automatisch entfernt.

Führen Sie den folgenden Befehl aus, um eine Speicherklasse namens zu locallöschen:

kubectl delete storageclass local

Weitere Informationen

  • Last updated on