Partager via

Utiliser Azure Container Storage avec NVMe local

Azure Container Storage est un service cloud de gestion, de déploiement et d’orchestration de volumes conçu de manière native pour les conteneurs. Cet article explique comment configurer Azure Container Storage pour utiliser le disque NVMe local comme stockage principal pour vos charges de travail Kubernetes. NVMe est conçu pour le transfert de données à grande vitesse entre le stockage et le processeur, fournissant des E/S par seconde et un débit élevés.

Important

Cet article s’applique à Azure Container Storage (version 2.x.x), qui pour l'instant, ne supporte que l'unité NVMe locale pour le stockage. Pour plus d’informations sur les versions antérieures, consultez la documentation stockage de conteneurs Azure (version 1.x.x).

Qu’est-ce que nvMe local ?

Lorsque votre application a besoin d’une latence de stockage inférieure à milliseconde et d’un débit élevé, vous pouvez utiliser des disques NVMe locaux avec Stockage Conteneur Azure pour répondre à vos besoins en matière de performances. « Éphémère » signifie que les disques sont déployés sur la machine virtuelle locale hébergeant le cluster AKS, et pas enregistrés dans un service de stockage Azure. Les données sont perdues sur ces disques si vous arrêtez/désallouez votre machine virtuelle. Les disques NVMe locaux sont proposés sur certaines familles de machines virtuelles Azure telles que les machines virtuelles optimisées pour le stockage .

Par défaut, Azure Container Storage crée des volumes éphémères génériques lors de l’utilisation de disques NVMe locaux. Pour les cas d’usage nécessitant des revendications de volume persistant, vous pouvez ajouter l’annotation localdisk.csi.acstor.io/accept-ephemeral-storage: "true" dans votre modèle de revendication de volume persistant.

Répartition des données

Pour optimiser les performances, Le stockage conteneur Azure délace automatiquement les données sur tous les disques NVMe locaux disponibles par machine virtuelle. Le striping est une technique où les données sont divisées en petits blocs et écrites uniformément sur plusieurs disques simultanément, ce qui augmente le débit et améliore les performances globales des E/S. Ce comportement est activé par défaut et ne peut pas être désactivé.

Étant donné que les performances s'agrègent sur ces périphériques en bandes, des tailles de machines virtuelles plus grandes qui exposent davantage de lecteurs NVMe peuvent débloquer des IOPS et une bande passante nettement plus élevés. La sélection d’une plus grande famille de machines virtuelles permet à vos charges de travail de bénéficier du débit d’agrégation supplémentaire sans configuration supplémentaire.

Par exemple, la série Lsv3 passe d’un seul lecteur NVMe de 1,92 To sur Standard_L8s_v3 (environ 400 000 IOPS et 2 000 Mo/s) jusqu’à 10 lecteurs NVMe sur Standard_L80s_v3 (environ 3,8 millions d’IOPS et 20 000 Mo/s).

Prérequis

Choisir un type de machine virtuelle prenant en charge NVMe local

Les disques NVMe locaux sont disponibles uniquement dans certains types de machines virtuelles, par exemple, les machines virtuelles optimisées pour le stockage ou les machines virtuelles accélérées par GPU. Si vous envisagez d’utiliser la capacité NVMe locale, choisissez l’une de ces tailles de machine virtuelle.

Exécuter la commande suivante pour obtenir le type de machine virtuelle utilisé avec votre pool de nœuds. Remplacez <resource group> et <cluster name> par vos propres valeurs. Vous n’avez pas besoin de fournir des valeurs pour PoolName ou VmSize. Conservez la requête comme indiqué ici.

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

Voici un exemple de sortie.

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

Remarque

Dans Azure Container Storage (version 2.x.x), vous pouvez désormais utiliser des clusters avec moins de trois nœuds.

Créer une classe de stockage pour NVMe local

Si vous ne l’avez pas encore fait, installez Stockage Conteneur Azure.

Azure Container Storage (version 2.x.x) présente NVMe local en tant que classe de stockage Kubernetes standard. Créez la classe de stockage une fois par cluster et réutilisez-la local pour les volumes éphémères génériques et les revendications de volume persistant.

  1. Utilisez votre éditeur de texte favori pour créer un fichier manifeste YAML tel que storageclass.yaml, puis collez la spécification suivante.

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

  2. Appliquez le manifeste pour créer la classe de stockage.

    kubectl apply -f storageclass.yaml

Vous pouvez également créer la classe de stockage à l’aide de Terraform.

  1. Utilisez Terraform pour gérer la classe de stockage en créant une configuration comme celle-ci main.tf. Mettez à jour la version du fournisseur ou le chemin kubeconfig si nécessaire pour votre environnement.

    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. Initialisez, examinez et appliquez la configuration pour créer la classe de stockage.

    terraform init
terraform plan
terraform apply

Vérifier la classe de stockage

Exécutez la commande suivante pour vérifier que la classe de stockage est créée :

kubectl get storageclass local

La sortie doit ressembler à celle-ci :

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

Créer et attacher des volumes éphémères génériques

Suivez ces étapes pour créer et attacher un volume éphémère générique à l’aide d’Azure Container Storage. Vérifiez qu’Azure Container Storage est installé et que la local classe de stockage existe avant de continuer.

Déployer un pod avec un volume éphémère générique

Créez un pod à l’aide de Fio (testeur d’E/S flexible) pour la simulation de référence et de charge de travail qui utilise un volume éphémère générique.

  1. Utilisez votre éditeur de texte favori pour créer un fichier manifeste YAML tel que code fiopod.yaml.

  2. Collez le code suivant et enregistrez le fichier.

    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. Appliquez le fichier manifeste YAML pour déployer le pod.

    kubectl apply -f fiopod.yaml

Vérifier les benchmarks de déploiement et d’exécution

Vérifiez que le pod est en cours d’exécution :

kubectl get pod fiopod

Vous devez voir le pod en cours d’exécution. Une fois l’exécution effectuée, vous pouvez exécuter un test de benchmark Fio :

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

Créer et attacher des volumes persistants avec l’annotation éphémère de stockage

Bien que les volumes éphémères génériques soient recommandés pour le stockage éphémère, Azure Container Storage prend également en charge les volumes persistants avec un stockage éphémère si nécessaire pour la compatibilité avec les charges de travail existantes.

Remarque

Azure Container Storage (version 2.x.x) utilise la nouvelle annotation localdisk.csi.acstor.io/accept-ephemeral-storage: "true" au lieu de la précédente acstor.azure.com/accept-ephemeral-storage: "true".

Assurez-vous qu’Azure Container Storage est installé et que la local classe de stockage que vous avez créée précédemment est disponible avant de déployer des charges de travail qui l’utilisent.

Déployer un StatefulSet avec des volumes persistants

Si vous avez besoin d'utiliser des demandes de volumes persistants qui ne sont pas liées au cycle de vie du pod, vous devez ajouter l'annotation localdisk.csi.acstor.io/accept-ephemeral-storage: "true". Les données du volume sont locales sur le nœud et sont perdues si le nœud est supprimé ou si le pod est déplacé vers un autre nœud.

Voici un exemple de stateful set utilisant des volumes persistants avec l'annotation de stockage éphémère :

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

Enregistrez et appliquez ce fichier YAML pour créer l'ensemble StatefulSet avec des volumes persistants.

kubectl apply -f statefulset-pvc.yaml

Gérer le stockage

Dans cette section, vous allez apprendre à vérifier la capacité de disque éphémère du nœud, à développer la capacité de stockage et à supprimer des ressources de stockage.

Vérifier la capacité du disque éphémère du nœud

Un volume éphémère est alloué sur un seul nœud. Lorsque vous configurez la taille de vos volumes éphémères, la taille doit être inférieure à la capacité disponible du disque éphémère du nœud unique.

Vérifiez qu’une classe localdisk.csi.acstor.io de stockage existe. Exécutez la commande suivante pour vérifier la capacité disponible du disque éphémère pour chaque nœud.

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"

Vous devez obtenir une sortie similaire à la suivante :

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

Si vous rencontrez une sortie de capacité vide, vérifiez qu’une classe localdisk.csi.acstor.io de stockage existe. La csistoragecapacities.storage.k8s.io ressource est générée uniquement après l’existence d’une classe De stockage localdisk.csi.acstor.io .

Développer la capacité de stockage

Étant donné que le stockage de disque éphémère utilise des ressources locales sur les nœuds du cluster AKS, l’extension de la capacité de stockage nécessite l’ajout de nœuds au cluster.

Pour ajouter un nœud à votre cluster, exécutez la commande suivante. Remplacez <cluster-name>, <nodepool-name>, <resource-group> et <new-count> par vos valeurs.

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

Supprimer des ressources de stockage

Pour nettoyer les ressources de stockage, vous devez d’abord supprimer tous les persistentVolumeClaims et/ou PersistentVolumes. La suppression de la StorageClass d'Azure Container Storage ne supprime pas automatiquement vos PersistentVolumes/PersistentVolumeClaims existants.

Pour supprimer une classe de stockage nommée local, exécutez la commande suivante :

kubectl delete storageclass local

Voir aussi

  • Last updated on