Partilhar via

Usar o Armazenamento de Contêiner do Azure com NVMe local

O Armazenamento de Contêineres do Azure é um serviço de gerenciamento, implantação e orquestração de volumes baseado em nuvem criado nativamente para contêineres. Este artigo mostra como configurar o Armazenamento de Contêiner do Azure para usar o disco NVMe local como armazenamento back-end para suas cargas de trabalho do Kubernetes. O NVMe foi projetado para transferência de dados de alta velocidade entre armazenamento e CPU, proporcionando alta IOPS e taxa de transferência.

Importante

Este artigo aplica-se ao Armazenamento de Contentores do Azure (versão 2.x.x), que atualmente apenas suporta o disco NVMe local para armazenamento de suporte. Para obter detalhes sobre versões anteriores, consulte a documentação do Armazenamento de Contêiner do Azure (versão 1.x.x).

O que é NVMe local?

Quando a sua aplicação precisa de latência de armazenamento sub-milissegundos e alto rendimento, pode usar discos NVMe locais com Azure Container Storage para satisfazer os seus requisitos de desempenho. Efémero significa que os discos são implantados na máquina virtual (VM) local que hospeda o cluster AKS e não salvos em um serviço de armazenamento do Azure. Os dados são perdidos nesses discos se você parar/desalocar sua VM. Os discos NVMe locais são oferecidos em famílias de VMs do Azure selecionadas, como VMs otimizadas para armazenamento .

Por padrão, o Armazenamento de Contêiner do Azure cria volumes efêmeros genéricos ao usar discos NVMe locais. Para casos de uso que exigem declarações de volume persistentes, você pode adicionar a anotação localdisk.csi.acstor.io/accept-ephemeral-storage: "true" em seu modelo de declaração de volume persistente.

Distribuição de dados

Para maximizar o desempenho, o Armazenamento de Contêiner do Azure distribui automaticamente os dados em todos os discos NVMe locais disponíveis por VM. O striping é uma técnica em que os dados são divididos em pequenos blocos e gravados uniformemente em vários discos simultaneamente, o que aumenta a taxa de transferência e melhora o desempenho geral de E/S. Esse comportamento é habilitado por padrão e não pode ser desabilitado.

Como o desempenho se agrega nesses dispositivos distribuídos, tamanhos de VM maiores que expõem mais unidades NVMe podem desbloquear IOPS e largura de banda substancialmente maiores. A seleção de uma família de VMs maior permite que suas cargas de trabalho se beneficiem da taxa de transferência agregada extra sem configuração adicional.

Por exemplo, a série Lsv3 pode ser dimensionada a partir de uma única unidade NVMe de 1,92 TB em Standard_L8s_v3 (cerca de 400.000 IOPS e 2.000 MB/s) até 10 unidades NVMe em Standard_L80s_v3 (cerca de 3,8 milhões de IOPS e 20.000 MB/s).

Pré-requisitos

  • Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.

  • Este artigo requer a versão mais recente (2.77.0 ou posterior) da CLI do Azure. Consulte Como instalar a CLI do Azure. Evita o Azure Cloud Shell, porque az upgrade não está disponível no Cloud Shell. Certifique-se de executar os comandos neste artigo com privilégios administrativos.

  • Consulte as instruções de instalação e certifique-se de que o Azure Container Storage está devidamente instalado.

  • Você precisa do cliente de linha de comando Kubernetes, kubectl. Você pode instalá-lo localmente executando o az aks install-cli comando.

  • Verifique se a sua região de destino tem suporte nas regiões de Armazenamento de Contêiner do Azure.

Escolha um tipo de VM que suporte NVMe local

Os discos NVMe locais só estão disponíveis em determinados tipos de VMs, por exemplo, VMs otimizadas para armazenamento ou VMs aceleradas por GPU. Se você planeja usar a capacidade NVMe local, escolha um desses tamanhos de VM.

Execute o comando a seguir para obter o tipo de VM usado com seu pool de nós. Substitua <resource group> e <cluster name> com os seus próprios valores. Você não precisa fornecer valores para PoolName ou VmSize, portanto, mantenha a consulta como mostrado aqui.

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

A saída a seguir é um exemplo.

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

Nota

No Armazenamento de Contêiner do Azure (versão 2.x.x), agora você pode usar clusters com menos de três nós.

Criar uma classe de armazenamento para NVMe local

Se ainda não o fizeste, instala o Azure Container Storage.

Azure Container Storage (versão 2.x.x) apresenta o NVMe local como uma classe de armazenamento Kubernetes padrão. Crie a local classe de armazenamento uma vez por cluster e reutilize-a tanto para volumes efémeros genéricos como para reivindicações de volumes persistentes.

  1. Use o seu editor de texto favorito para criar um ficheiro de manifesto YAML, como storageclass.yaml, e depois cole a seguinte especificação.

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

  2. Aplica o manifesto para criar a classe de armazenamento.

    kubectl apply -f storageclass.yaml

Alternativamente, podes criar a classe de armazenamento usando o Terraform.

  1. Use o Terraform para gerir a classe de armazenamento criando uma configuração como a seguinte main.tf. Atualiza a versão do fornecedor ou o caminho do kubeconfig conforme necessário para o teu ambiente.

    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. Inicializar, rever e aplicar a configuração para criar a classe de armazenamento.

    terraform init
terraform plan
terraform apply

Verificar a classe de armazenamento

Execute o seguinte comando para verificar se a classe de armazenamento foi criada:

kubectl get storageclass local

Deverá ver um resultado semelhante a:

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

Criar e anexar volumes efémeros genéricos

Siga estas etapas para criar e anexar um volume efêmero genérico usando o Armazenamento de Contêiner do Azure. Certifique-se de que o Azure Container Storage está instalado e que a local classe de armazenamento existe antes de continuar.

Desplegar um pod com volume efémero genérico

Crie um pod usando Fio (Flexible I/O Tester) para benchmarking e simulação de carga de trabalho que usa um volume efêmero genérico.

  1. Use seu editor de texto favorito para criar um arquivo de manifesto YAML como code fiopod.yaml.

  2. Cole o código a seguir e salve o arquivo.

    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. Aplique o arquivo de manifesto YAML para implantar o pod.

    kubectl apply -f fiopod.yaml

Verifique a implementação e execute testes de desempenho

Verifique se o pod está funcionando:

kubectl get pod fiopod

Você deve ver o pod no estado Em Execução. Uma vez executado, você pode executar um teste 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

Criar e anexar volumes persistentes com anotação de armazenamento efêmera

Enquanto volumes efêmeros genéricos são recomendados para armazenamento efêmero, o Armazenamento de Contêiner do Azure também dá suporte a volumes persistentes com armazenamento efêmero quando necessário para compatibilidade com cargas de trabalho existentes.

Nota

O Armazenamento de Contêineres do Azure (versão 2.x.x) usa a nova anotação localdisk.csi.acstor.io/accept-ephemeral-storage: "true" em vez da anterior acstor.azure.com/accept-ephemeral-storage: "true".

Certifique-se de que o Azure Container Storage está instalado e que a local classe de armazenamento que criou anteriormente está disponível antes de implementar cargas de trabalho que a utilizem.

Implementar um StatefulSet com volumes persistentes

Se você precisar usar declarações de volume persistentes que não estejam vinculadas ao ciclo de vida do pod, deverá adicionar a localdisk.csi.acstor.io/accept-ephemeral-storage: "true" anotação. Os dados no volume são locais para o nó e são perdidos se o nó for excluído ou o pod for movido para outro nó.

Aqui está um exemplo de conjunto com estado usando volumes persistentes com a anotação de armazenamento efémero.

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

Salve e aplique este YAML para criar o Stateful Set com volumes persistentes.

kubectl apply -f statefulset-pvc.yaml

Gerenciar armazenamento

Nesta seção, irá aprender a verificar a capacidade do disco temporário do nó, expandir a capacidade de armazenamento e eliminar recursos de armazenamento.

Verificar a capacidade do disco temporário do nó

Um volume temporário é alocado num único nó. Quando você configura o tamanho de seus volumes efêmeros, o tamanho deve ser menor do que a capacidade disponível do disco efêmero do nó único.

Certifique-se de que existe uma StorageClass para localdisk.csi.acstor.io. Execute o seguinte comando para verificar a capacidade disponível do disco efémero para cada nó.

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"

Você deve ver uma saída semelhante ao exemplo a seguir:

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

Se encontrar saída de capacidade vazia, confirme que existe uma StorageClass para localdisk.csi.acstor.io . O csistoragecapacities.storage.k8s.io recurso só é gerado depois de existir uma StorageClass para localdisk.csi.acstor.io .

Expandir a capacidade de armazenamento

Como o armazenamento em disco efêmero usa recursos locais nos nós do cluster AKS, a expansão da capacidade de armazenamento requer a adição de nós ao cluster.

Para adicionar um nó ao cluster, execute o seguinte comando. Substitua <cluster-name>, <nodepool-name>, <resource-group>, e <new-count> pelos seus valores.

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

Excluir recursos de armazenamento

Para limpar os recursos de armazenamento, você deve primeiro excluir todos os PersistentVolumeClaims e/ou PersistentVolumes. A exclusão do Azure Container Storage StorageClass não remove automaticamente os seus PersistentVolumes/PersistentVolumeClaims existentes.

Para eliminar uma classe de armazenamento chamada local, execute o seguinte comando:

kubectl delete storageclass local

Consulte também

  • Last updated on