Usar o driver da Interface de Armazenamento de Contêiner (CSI) no Serviço de Kubernetes do Azure (AKS)

O driver da CSI (Interface de Armazenamento de Contêiner) para arquivos do Azure é um driver em conformidade com a especificação CSI usado pelo AKS (Serviço de Kubernetes do Azure) para gerenciar o ciclo de vida dos compartilhamentos de arquivos do Azure. A CSI é um padrão para expor sistemas de blocos e de armazenamento de arquivos arbitrários a cargas de trabalho em contêineres no Kubernetes.

Ao adotar e usar a CSI, o AKS pode escrever, implantar e iterar plug-ins para expor novos sistemas de armazenamento ou aprimorar os existentes no Kubernetes. O uso de drivers CSI no AKS evita ter que tocar no código principal do Kubernetes e aguardar os ciclos de lançamento dele.

Para criar um cluster do AKS com suporte aos drivers da CSI, confira Habilitar drivers da CSI no AKS.

Novos recursos do driver da CSI nos Arquivos do Azure

Além dos recursos originais do driver na árvore, o driver da CSI nos Arquivos do Azure dá suporte aos seguintes recursos:

• NFS (Network File System) versão 4.1
• Ponto de extremidade privado
• Criar grandes montagens de compartilhamentos de arquivos em paralelo.

Usar um volume persistente com arquivos do Azure

Um PV (volume persistente) representa um armazenamento provisionado para uso com pods do Kubernetes. Um PV pode ser usado por um ou vários pods e pode ser provisionado estática ou dinamicamente. Se vários pods precisarem de acesso simultâneo ao mesmo volume de armazenamento, use o serviço Arquivos do Azure para se conectar por meio do protocolo SMB ou do protocolo NFS. Este artigo mostra como criar dinamicamente um compartilhamento de Arquivos do Azure para uso por vários pods em um cluster do AKS. Para provisionamento estático, confira Criar e usar manualmente um volume com compartilhamento de arquivo do Azure.

Nos compartilhamentos de Arquivos do Azure, não há limite para quantos podem ser montados em um nó.

Para obter mais informações sobre o Kubernetes, veja Opções de armazenamento para aplicativos no AKS.

Criar dinamicamente PVs de arquivo do Azure usando as classes de armazenamento internas

Uma classe de armazenamento é usada para definir como um compartilhamento de arquivos do Azure é criado. Uma conta de armazenamento é criada automaticamente no grupo de recursos do nó para uso com a classe de armazenamento para manter o compartilhamento de arquivos do Azure. Escolha a seguinte redundância de armazenamento SKU do Azure para skuName:

• Standard_LRS: armazenamento com redundância local
• Standard_GRS: armazenamento com redundância geográfica
• Standard_ZRS: armazenamento com redundância de zona padrão
• Standard_RAGRS: armazenamento com redundância geográfica e acesso de leitura padrão (Standard-RAGRS)
• Standard_RAGRS: Standard-RAGRS (armazenamento com redundância de zona geográfica com acesso de leitura Standard)
• Premium_LRS: Armazenamento com redundância local Premium
• Premium_ZRS: armazenamento com redundância de zona Premium

Quando você usa drivers da CSI de armazenamento no AKS, há dois outros StorageClasses internos que usam os drivers de armazenamento da CSI nos Arquivos do Azure. As outras classes de armazenamento da CSI são criadas com o cluster juntamente com as classes de armazenamento padrão na árvore.

• azurefile-csi: usa o Armazenamento Standard do Azure para criar um compartilhamento de arquivos do Azure.
• azurefile-csi-premium: usa o Armazenamento Premium do Azure para criar um compartilhamento de arquivos do Azure.

A política de recuperação em ambas as classes de armazenamento garante que o compartilhamento de arquivos subjacente do Azure seja excluído quando o respectivo PV for excluído. As classes de armazenamento também configuram os compartilhamentos de arquivos para serem expansíveis, você só precisa editar a PVC (declaração de volume persistente) com o novo tamanho.

Para usar essas classes de armazenamento, crie uma PVC e o respectivo pod que a referencie e utilize. Uma PVC é usada para provisionar automaticamente o armazenamento com base em uma classe de armazenamento. Um PVC pode usar uma das classes de armazenamento pré-criadas ou uma classe de armazenamento definida pelo usuário para criar um compartilhamento de arquivos do Azure para o SKU e o tamanho desejados. Quando você cria uma definição de pod, a PVC é especificada para solicitar o armazenamento desejado.

Crie um PVC de exemplo e um pod que imprime a data atual em um outfile executando os comandos kubectl apply:

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/pvc-azurefile-csi.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/nginx-pod-azurefile.yaml

A saída do comando é semelhante ao seguinte exemplo:

persistentvolumeclaim/pvc-azurefile created
pod/nginx-azurefile created

Depois que o Pod estiver no estado executando, você poderá validar se o compartilhamento de arquivos está montado corretamente executando o comando a seguir e verificando se a saída contém outfile :

kubectl exec nginx-azurefile -- ls -l /mnt/azurefile

A saída do comando é semelhante ao seguinte exemplo:

total 29
-rwxrwxrwx 1 root root 29348 Aug 31 21:59 outfile

Criar uma classe de armazenamento personalizada

As classes de armazenamento padrão se adaptam aos cenários mais comuns, mas não a todos. Para alguns casos, talvez você queira ter a própria classe de armazenamento personalizada com os próprios parâmetros. Por exemplo, use o manifesto a seguir para configurar o mountOptions do compartilhamento de arquivos.

O valor padrão para fileMode e dirMode é 0777 para compartilhamentos de arquivos montados pelo Kubernetes. Você pode especificar as opções de montagem diferentes no objeto de classe de armazenamento.

Crie um arquivo chamado azure-file-sc.yaml e cole de acordo com o manifesto de exemplo a seguir.

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: my-azurefile
provisioner: file.csi.azure.com
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
mountOptions:
  - dir_mode=0640
  - file_mode=0640
  - uid=0
  - gid=0
  - mfsymlinks
  - cache=strict # https://linux.die.net/man/8/mount.cifs
  - nosharesock
parameters:
  skuName: Standard_LRS

Crie a classe de armazenamento executando o comando kubectl apply:

kubectl apply -f azure-file-sc.yaml

A saída do comando é semelhante ao seguinte exemplo:

storageclass.storage.k8s.io/my-azurefile created

O driver CSI dos arquivos do Azure dá suporte à criação de instantâneos de volumes persistentes e aos compartilhamentos de arquivos subjacentes.

Crie uma classe de instantâneo de volume com o comando kubectl Apply :

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/snapshot/volumesnapshotclass-azurefile.yaml

A saída do comando é semelhante ao seguinte exemplo:

volumesnapshotclass.snapshot.storage.k8s.io/csi-azurefile-vsc created

Criar um instantâneo de volume da PVC que criamos dinamicamente no início deste tutorial, pvc-azurefile.

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/snapshot/volumesnapshot-azurefile.yaml

A saída do comando é semelhante ao seguinte exemplo:

volumesnapshot.snapshot.storage.k8s.io/azurefile-volume-snapshot created

Verifique se o instantâneo foi criado corretamente executando o seguinte comando:

kubectl describe volumesnapshot azurefile-volume-snapshot

A saída do comando é semelhante ao seguinte exemplo:

Name:         azurefile-volume-snapshot
Namespace:    default
Labels:       <none>
Annotations:  API Version:  snapshot.storage.k8s.io/v1beta1
Kind:         VolumeSnapshot
Metadata:
  Creation Timestamp:  2020-08-27T22:37:41Z
  Finalizers:
    snapshot.storage.kubernetes.io/volumesnapshot-as-source-protection
    snapshot.storage.kubernetes.io/volumesnapshot-bound-protection
  Generation:        1
  Resource Version:  955091
  Self Link:         /apis/snapshot.storage.k8s.io/v1beta1/namespaces/default/volumesnapshots/azurefile-volume-snapshot
  UID:               c359a38f-35c1-4fb1-9da9-2c06d35ca0f4
Spec:
  Source:
    Persistent Volume Claim Name:  pvc-azurefile
  Volume Snapshot Class Name:      csi-azurefile-vsc
Status:
  Bound Volume Snapshot Content Name:  snapcontent-c359a38f-35c1-4fb1-9da9-2c06d35ca0f4
  Ready To Use:                        false
Events:                                <none>

Redimensionar um volume persistente

Você pode solicitar um volume maior para uma PVC. Edite o objeto PVC e especifique um tamanho maior. Essa alteração dispara a expansão do volume subjacente que faz o backup do VP.

No AKS, a classe de armazenamento azurefile-csi interna já permite a expansão, portanto, use a PVC criada anteriormente com essa classe de armazenamento. A PVC solicitou um compartilhamento de arquivos do 100 GiB. Podemos confirmar isso executando:

kubectl exec -it nginx-azurefile -- df -h /mnt/azurefile

A saída do comando é semelhante ao seguinte exemplo:

Filesystem                                                                                Size  Used Avail Use% Mounted on
//f149b5a219bd34caeb07de9.file.core.windows.net/pvc-5e5d9980-da38-492b-8581-17e3cad01770  100G  128K  100G   1% /mnt/azurefile

Vamos expandir a PVC aumentando o campo spec.resources.requests.storage:

kubectl patch pvc pvc-azurefile --type merge --patch '{"spec": {"resources": {"requests": {"storage": "200Gi"}}}}'

A saída do comando é semelhante ao seguinte exemplo:

persistentvolumeclaim/pvc-azurefile patched

Verifique se o PVC e o sistema de arquivos dentro do pod mostram o novo tamanho:

kubectl get pvc pvc-azurefile
NAME            STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS    AGE
pvc-azurefile   Bound    pvc-5e5d9980-da38-492b-8581-17e3cad01770   200Gi      RWX            azurefile-csi   64m

kubectl exec -it nginx-azurefile -- df -h /mnt/azurefile
Filesystem                                                                                Size  Used Avail Use% Mounted on
//f149b5a219bd34caeb07de9.file.core.windows.net/pvc-5e5d9980-da38-492b-8581-17e3cad01770  200G  128K  200G   1% /mnt/azurefile

Usar um volume persistente com Armazenamento particular do Arquivos do Azure (ponto de extremidade privado)

Se os recursos dos Arquivos do Azure estiverem protegidos com um ponto de extremidade privado, você deverá criar sua própria classe de armazenamento. Verifique se você definiu as suas configurações de DNS para que o endereço IP do ponto de extremidade privado seja resolvido para o FQDN da cadeia de conexão. Personalize os seguintes parâmetros:

• resourceGroup: o grupo de recursos em que a conta de armazenamento é implantada.
• storageAccount: o nome da conta de armazenamento.
• server: o FQDN do ponto de extremidade privado da conta de armazenamento.

Crie um arquivo nomeado como private-azure-file-sc.yaml e depois cole o seguinte manifesto de exemplo no arquivo. Substitua os valores de <resourceGroup> e <storageAccountName>.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: private-azurefile-csi
provisioner: file.csi.azure.com
allowVolumeExpansion: true
parameters:
  resourceGroup: <resourceGroup>
  storageAccount: <storageAccountName>
  server: <storageAccountName>.file.core.windows.net
reclaimPolicy: Delete
volumeBindingMode: Immediate
mountOptions:
  - dir_mode=0777
  - file_mode=0777
  - uid=0
  - gid=0
  - mfsymlinks
  - cache=strict  # https://linux.die.net/man/8/mount.cifs
  - nosharesock  # reduce probability of reconnect race
  - actimeo=30  # reduce latency for metadata-heavy workload

Crie a classe de armazenamento usando o comando kubectl apply:

kubectl apply -f private-azure-file-sc.yaml

A saída do comando é semelhante ao seguinte exemplo:

storageclass.storage.k8s.io/private-azurefile-csi created

Crie um arquivo nomeado como private-pvc.yaml e depois cole o seguinte manifesto de exemplo no arquivo:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: private-azurefile-pvc
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: private-azurefile-csi
  resources:
    requests:
      storage: 100Gi

Crie a classe PVC usando o comando kubectl apply:

kubectl apply -f private-pvc.yaml

Compartilhamentos de arquivo NFS

Arquivos do Azure oferece suporte ao protocolo NFS v 4.1. O suporte a NFS versão 4.1 para Arquivos do Azure fornece um sistema de arquivos NFS totalmente gerenciado como um serviço criado em uma plataforma de armazenamento resiliente distribuída altamente disponível e altamente durável.

Essa opção é otimizada para cargas de trabalho de acesso aleatório com atualizações de dados in-locar e fornece suporte completo ao sistema de arquivos POSIX. Esta seção mostra como usar compartilhamentos NFS com o driver CSI de arquivos do Azure em um cluster do AKS.

Pré-requisitos

• A identidade do Painel de controle do cluster do AKS (ou seja, o nome do cluster do AKS) é adicionada à função Colaborador na VNet e NetworkSecurityGroup.
• A entidade de serviço ou a MSI (identidade do serviço gerenciado) do cluster do AKS deve ser adicionada à função Colaborador da conta de armazenamento.

Otimizando opções de tamanho de leitura e gravação

Esta seção fornece informações sobre como abordar o ajuste de desempenho do NFS com o driver CSI dos Arquivos do Azure com as opções rsize e wsize. As opções rsize e wsize definem o tamanho máximo de transferência de uma operação NFS. Se rsize ou wsize não for especificado na montagem, o cliente e o servidor negociarão o maior tamanho compatível com os dois. Atualmente, as distribuições modernas do Linux e o Azure NetApp Files dão suporte a tamanhos de leitura e gravação que chegam a 1.048.576 bytes (1 MiB).

O desempenho ideal baseia-se na comunicação cliente-servidor eficiente. Aumentar ou diminuir os valores de tamanho da opção de leitura e gravação da montagem pode melhorar o desempenho do NFS. O tamanho padrão dos pacotes de leitura/gravação transferidos entre o cliente e o servidor é de 8 KB para NFS versão 2 e 32 KB para NFS versão 3 e 4. Esses padrões podem ser muito grandes ou muito pequenos. Reduzir o rsize e o wsize pode melhorar o desempenho do NFS em uma rede congestionada enviando pacotes menores para cada resposta de leitura e solicitação de gravação do NFS. No entanto, isso pode aumentar o número de pacotes necessários para enviar dados pela rede, aumentando o tráfego total e a utilização da CPU no cliente e no servidor.

É importante que você execute testes para encontrar um rsize e wsize que sustente a transferência de pacotes eficiente, onde não diminua a taxa de transferência e aumente a latência.

Para obter mais informações sobre como otimizar o rsize e o wsize, confira Melhores práticas de opções de montagem do NFS Linux para Azure NetApp Files.

Por exemplo, para configurar um rsize máximo e um wsize de 256 KiB, configure o mountOptions na classe de armazenamento da seguinte maneira:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azurefile-csi-nfs
provisioner: file.csi.azure.com
allowVolumeExpansion: true
parameters:
  protocol: nfs
mountOptions:
  - nconnect=4
  - noresvport
  - actimeo=30
  - rsize=262144
  - wsize=262144

Criar classe de armazenamento de compartilhamento de arquivos NFS

Crie um arquivo chamado nfs-sc.yaml e copie o manifesto abaixo. Para obter uma lista de mountOptions com suporte, confira Opções de montagem do NFS.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azurefile-csi-nfs
provisioner: file.csi.azure.com
allowVolumeExpansion: true
parameters:
  protocol: nfs
mountOptions:
  - nconnect=4
  - noresvport
  - actimeo=30

Depois de editar e salvar o arquivo, crie a classe de armazenamento com o comando kubectl apply:

kubectl apply -f nfs-sc.yaml

A saída do comando é semelhante ao seguinte exemplo:

storageclass.storage.k8s.io/azurefile-csi-nfs created

Criar uma implantação com um compartilhamento de arquivos com suporte de NFS

Você pode implantar um conjunto com estado de exemplo que salva carimbos de data/hora em um arquivo data.txt com o comando kubectl apply:

kubectl apply -f

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: statefulset-azurefile
  labels:
    app: nginx
spec:
  podManagementPolicy: Parallel  # default is OrderedReady
  serviceName: statefulset-azurefile
  replicas: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
        - name: statefulset-azurefile
          image: mcr.microsoft.com/oss/nginx/nginx:1.19.5
          command:
            - "/bin/bash"
            - "-c"
            - set -euo pipefail; while true; do echo $(date) >> /mnt/azurefile/outfile; sleep 1; done
          volumeMounts:
            - name: persistent-storage
              mountPath: /mnt/azurefile
  updateStrategy:
    type: RollingUpdate
  selector:
    matchLabels:
      app: nginx
  volumeClaimTemplates:
    - metadata:
        name: persistent-storage
      spec:
        storageClassName: azurefile-csi-nfs
        accessModes: ["ReadWriteMany"]
        resources:
          requests:
            storage: 100Gi

A saída do comando é semelhante ao seguinte exemplo:

statefulset.apps/statefulset-azurefile created

Valide o conteúdo do volume executando o seguinte comando:

kubectl exec -it statefulset-azurefile-0 -- df -h

A saída do comando é semelhante ao seguinte exemplo:

Filesystem      Size  Used Avail Use% Mounted on
...
/dev/sda1                                                                                 29G   11G   19G  37% /etc/hosts
accountname.file.core.windows.net:/accountname/pvc-fa72ec43-ae64-42e4-a8a2-556606f5da38  100G     0  100G   0% /mnt/azurefile
...

Contêineres do Windows

O driver da CSI para arquivos do Azure também dá suporte a nós e contêineres do Windows. Para usar contêineres do Windows, siga o Início rápido de contêineres do Windows para adicionar um pool de nós do Windows.

Depois de ter um pool de nós do Windows, você pode usar as classes de armazenamento internas como azurefile-csi ou criar personalizadas. Você pode implantar um Conjunto com estado baseado em Windows de exemplo que salva carimbos de data/hora no arquivo data.txt ao executar o comando kubectl apply:

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/windows/statefulset.yaml

A saída do comando é semelhante ao seguinte exemplo:

statefulset.apps/busybox-azurefile created

Valide o conteúdo do volume executando o seguinte comando kubectl exec:

kubectl exec -it busybox-azurefile-0 -- cat c:\\mnt\\azurefile\\data.txt # on Linux/MacOS Bash
kubectl exec -it busybox-azurefile-0 -- cat c:\mnt\azurefile\data.txt # on Windows Powershell/CMD

A saída dos comandos é semelhante ao seguinte exemplo:

2020-08-27 22:11:01Z
2020-08-27 22:11:02Z
2020-08-27 22:11:04Z
(...)

Próximas etapas

• Para saber como usar o driver da CSI para Discos do Azure, confira Usar os Discos do Azure com driver da CSI.
• Para saber como usar o driver CSI para armazenamento de BLOBs do Azure, confira Usar o Armazenamento de BLOBs do Azure com driver da CSI.
• Para saber mais sobre melhores práticas de armazenamento, confira Melhores práticas para armazenamento e backups no Serviço de Kubernetes do Azure.