Criar e usar um volume com os Arquivos do Azure no AKS (Serviço de Kubernetes do Azure)

Um volume persistente representa uma parte do armazenamento que foi provisionada para uso com pods do Kubernetes. Você pode usar um volume persistente com um ou muitos pods e ele pode ser provisionado dinamicamente ou estaticamente. 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. Este artigo mostra como criar dinamicamente um compartilhamento de Arquivos do Azure para uso por vários pods em um cluster do Serviço de Kubernetes do Azure (AKS).

Este artigo mostra como:

• Trabalhe com um PV (volume persistente) dinâmico instalando o driver da CSI (Interface de Armazenamento de Contêiner) e criando dinamicamente um ou mais compartilhamentos de arquivo do Azure para anexar a um pod.
• Trabalhe com um PV estático criando um ou mais compartilhamentos de arquivo do Azure ou use um existente e anexe-o a um pod.

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

Antes de começar

• Você precisa de uma conta de armazenamento.
• Certifique-se de possuir a CLI do Azure versão 2.0.59 ou posterior instalada e configurada. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.
• Ao escolher entre compartilhamentos de arquivos Standard e Premium, é importante que você entenda o modelo de provisionamento e os requisitos do padrão de uso esperado que você pretende executar nos Arquivos do Azure. Para obter mais informações, consulte Escolhendo uma camada de desempenho dos Arquivos do Azure com base em padrões de uso.

Provisionar um volume dinamicamente

Esta seção fornece diretrizes para administradores de cluster que desejam provisionar um ou mais volumes persistentes que incluem detalhes de um ou mais compartilhamentos nos Arquivos do Azure. Uma PVC (declaração de volume persistente) usa o objeto de classe de armazenamento para provisionar dinamicamente um compartilhamento dos Arquivos do Azure.

Parâmetros de classe de armazenamento para PersistentVolumes dinâmicos

A tabela a seguir inclui parâmetros que você pode usar para definir uma classe de armazenamento customizada para seu PersistentVolumeClaim.

Criar uma classe de armazenamento

As classes de armazenamento definem como criar um compartilhamento de arquivos do Azure. Uma conta de armazenamento é criada automaticamente no grupo de recursos do nó para uso com a classe de armazenamento para reter os compartilhamentos dos Arquivos do Azure. Escolha das seguintes SKUs de redundância de armazenamento do Azure para skuName:

• Standard_LRS: Armazenamento com redundância local (LRS) padrão
• Standard_GRS: Armazenamento com redundância geográfica (GRS) padrão
• Standard_ZRS: Armazenamento com redundância de zona (ZRS) padrão
• Standard_RAGRS: Armazenamento com redundância geográfica com acesso de leitura (RA-GRS) padrão
• Premium_LRS: Armazenamento com redundância local (LRS) premium
• Premium_ZRS: Armazenamento com redundância de zona (ZRS) premium

Para obter mais informações sobre classes de armazenamento do Kubernetes para o serviço Arquivos do Azure, veja Classes de armazenamento do Kubernetes.

1. Crie um arquivo chamado azure-file-sc.yaml e copie-o manifesto de exemplo a seguir. Para obter mais informações sobre mountOptions, veja a seção Opções de montagem.

   kind: StorageClass
   apiVersion: storage.k8s.io/v1
   metadata:
     name: my-azurefile
   provisioner: file.csi.azure.com # replace with "kubernetes.io/azure-file" if aks version is less than 1.21
   allowVolumeExpansion: true
   mountOptions:
    - dir_mode=0777
    - file_mode=0777
    - uid=0
    - gid=0
    - mfsymlinks
    - cache=strict
    - actimeo=30
    - nobrl  # disable sending byte range lock requests to the server and for applications which have challenges with posix locks
   parameters:
     skuName: Premium_LRS
   

2. Crie a classe de armazenamento usando o comando kubectl apply.

   kubectl apply -f azure-file-sc.yaml
   

Criar uma declaração de volume persistente

Uma PVC (declaração de volume persistente) usa o objeto de classe de armazenamento para provisionar dinamicamente um compartilhamento de arquivos do Azure. Você pode usar o YAML a seguir para criar uma declaração de volume persistente de 100 GB de tamanho com acesso do tipo ReadWriteMany. Para obter mais informações sobre os modos de acesso, confira Volume persistente de Kubernetes.

1. Crie um arquivo chamado azure-file-pvc.yaml e copie no YAML a seguir. Certifique-se que storageClassName corresponde à classe de armazenamento que você criou na etapa anterior.

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

   Observação

   Se estiver usando a SKU Premium_LRS para sua classe de armazenamento, o valor mínimo para storage deve ser 100Gi.

2. Crie a declaração do volume persistente usando o comando kubectl apply.

   kubectl apply -f azure-file-pvc.yaml
   

   Depois de concluído, o compartilhamento de arquivos é criado. Um segredo do Kubernetes que contém informações de conexão e credenciais também é criado. Use o comando kubectl get para exibir o status do PVC:

   kubectl get pvc my-azurefile
   

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

   NAME           STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS      AGE
   my-azurefile   Bound     pvc-8436e62e-a0d9-11e5-8521-5a8664dc0477   100Gi       RWX            my-azurefile      5m
   

Usar o volume persistente

O YAML a seguir cria um pod que usa a declaração de volume persistente my-azurefile para montar o compartilhamento dos Arquivos do Azure no caminho /mnt/azure. Para contêineres do Windows Server, especifique um mountPath usando a convenção de caminho do Windows, como “D:” .

1. Crie um arquivo chamado azure-pvc-files.yaml e copie no YAML a seguir. Certifique-se que claimName corresponda ao PVC que você criou na última etapa.

   kind: Pod
   apiVersion: v1
   metadata:
     name: mypod
   spec:
     containers:
       - name: mypod
         image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
         resources:
           requests:
             cpu: 100m
             memory: 128Mi
           limits:
             cpu: 250m
             memory: 256Mi
         volumeMounts:
           - mountPath: /mnt/azure
             name: volume
             readOnly: false
     volumes:
      - name: volume
        persistentVolumeClaim:
          claimName: my-azurefile
   

2. Crie o pod usando o comando kubectl apply.

   kubectl apply -f azure-pvc-files.yaml
   

   Agora você tem um pod em execução com seu compartilhamento dos Arquivos do Azure montado no diretório /mnt/azure. Essa configuração pode ser vista ao inspecionar o pod usando o comando kubectl describe. A seguinte saída de exemplo condensada mostra o volume montado no contêiner.

   Containers:
     mypod:
       Container ID:   docker://053bc9c0df72232d755aa040bfba8b533fa696b123876108dec400e364d2523e
       Image:          mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
       Image ID:       docker-pullable://nginx@sha256:d85914d547a6c92faa39ce7058bd7529baacab7e0cd4255442b04577c4d1f424
       State:          Running
         Started:      Fri, 01 Mar 2019 23:56:16 +0000
       Ready:          True
       Mounts:
         /mnt/azure from volume (rw)
         /var/run/secrets/kubernetes.io/serviceaccount from default-token-8rv4z (ro)
   [...]
   Volumes:
     volume:
       Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
       ClaimName:  my-azurefile
       ReadOnly:   false
   [...]
   

Opções de montagem

O valor padrão para fileMode e dirMode é 0777 para o Kubernetes versões 1.13.0 e superior. Se você estiver criando dinamicamente o volume persistente com uma classe de armazenamento, você pode especificar as opções de montagem no objeto da classe de armazenamento. Para obter mais informações, confira Opções de montagem. O exemplo a seguir define 0777:

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: my-azurefile
provisioner: file.csi.azure.com # replace with "kubernetes.io/azure-file" if aks version is less than 1.21
allowVolumeExpansion: true
mountOptions:
  - dir_mode=0777
  - file_mode=0777
  - uid=0
  - gid=0
  - mfsymlinks
  - cache=strict
  - actimeo=30
  - nobrl  # disable sending byte range lock requests to the server and for applications which have challenges with posix locks
parameters:
  skuName: Premium_LRS

Uso de marcas do Azure

Para mais informações como usar as marcas do Azure, confira Usar as marcas do Azure no AKS (Serviço de Kubernetes do Azure).

Provisionar um volume estaticamente

Esta seção fornece diretrizes para administradores de cluster que desejam criar um ou mais volumes persistentes que incluem detalhes de um compartilhamento dos Arquivos do Azure existente a ser usado com uma carga de trabalho.

Parâmetros de provisionamento estático para PersistentVolume

A tabela a seguir inclui parâmetros que você pode usar para definir um PersistentVolume.

Criar um compartilhamento de arquivo do Azure

Antes de usar um compartilhamento dos Arquivos do Azure como um volume Kubernetes, você deve criar uma conta de Armazenamento do Azure e o compartilhamento de arquivos.

1. Obtenha o nome do grupo de recursos usando o comando az aks show com o parâmetro --query nodeResourceGroup.

   az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
   

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

   MC_myResourceGroup_myAKSCluster_eastus
   

2. Crie uma conta de armazenamento usando o comando az storage account create com o parâmetro --sku. O comando a seguir cria uma conta de armazenamento usando a SKU Standard_LRS. Substitua os seguintes espaços reservados:

   • myAKSStorageAccount pelo nome da conta de armazenamento
   • nodeResourceGroupName pelo nome do grupo de recursos no qual os nós de cluster do AKS estão hospedados
   • location pelo nome da região na qual o recurso deve ser criado. Deve ser a mesma região que os nós de cluster do AKS.

   az storage account create -n myAKSStorageAccount -g nodeResourceGroupName -l location --sku Standard_LRS
   

3. Exporte a cadeia de conexão como uma variável de ambiente usando o comando a seguir, que você usa para criar o compartilhamento de arquivos.

   export AZURE_STORAGE_CONNECTION_STRING=$(az storage account show-connection-string -n storageAccountName -g resourceGroupName -o tsv)
   

4. Crie o compartilhamento de arquivo usando o comando az storage share create. Certifique-se de substituir shareName com seu nome do compartilhamento.

   az storage share create -n shareName --connection-string $AZURE_STORAGE_CONNECTION_STRING
   

5. Exporte a chave da conta de armazenamento como uma variável de ambiente usando o comando a seguir.

   STORAGE_KEY=$(az storage account keys list --resource-group nodeResourceGroupName --account-name myAKSStorageAccount --query "[0].value" -o tsv)
   

6. Ecoe o nome e a chave da conta de armazenamento usando o comando a seguir. Copie essas informações, pois você precisa desses valores ao criar o volume do Kubernetes.

   echo Storage account key: $STORAGE_KEY
   

Criar um segredo do Kubernetes

O Kubernetes precisa de credenciais para acessar o compartilhamento de arquivos criado na etapa anterior. Essas credenciais são armazenadas em um segredo Kubernetes, que é referenciado quando você cria um pod Kubernetes.

1. Crie o segredo usando o comando kubectl create secret. O exemplo a seguir cria um segredo chamado azure-secret e preenche os campos azurestorageaccountname e assszurestorageaccountkey da etapa anterior. Para usar uma conta de armazenamento existente do Azure, forneça o nome da conta e a chave.

   kubectl create secret generic azure-secret --from-literal=azurestorageaccountname=myAKSStorageAccount --from-literal=azurestorageaccountkey=$STORAGE_KEY
   

Montar o compartilhamento de arquivo como um volume persistente

1. Crie um novo arquivo chamado azurefiles-pv.yaml e copie o conteúdo a seguir. Emcsi, atualizar resourceGroup, volumeHandle e shareName. O valor padrão de fileMode e dirMode é 0777.

   apiVersion: v1
   kind: PersistentVolume
   metadata:
     annotations:
       pv.kubernetes.io/provisioned-by: file.csi.azure.com
     name: azurefile
   spec:
     capacity:
       storage: 5Gi
     accessModes:
       - ReadWriteMany
     persistentVolumeReclaimPolicy: Retain
     storageClassName: azurefile-csi
     csi:
       driver: file.csi.azure.com
       volumeHandle: "{resource-group-name}#{account-name}#{file-share-name}"  # make sure this volumeid is unique for every identical share in the cluster
       volumeAttributes:
         resourceGroup: resourceGroupName  # optional, only set this when storage account is not in the same resource group as node
         shareName: aksshare
       nodeStageSecretRef:
         name: azure-secret
         namespace: default
     mountOptions:
       - dir_mode=0777
       - file_mode=0777
       - uid=0
       - gid=0
       - mfsymlinks
       - cache=strict
       - nosharesock
       - nobrl  # disable sending byte range lock requests to the server and for applications which have challenges with posix locks
   

2. Crie o volume persistente usando o comando kubectl create.

   kubectl create -f azurefiles-pv.yaml
   

3. Crie um novo arquivo chamado azurefiles-mount-options-pvc.yaml e copie o conteúdo a seguir.

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: azurefile
   spec:
     accessModes:
       - ReadWriteMany
     storageClassName: azurefile-csi
     volumeName: azurefile
     resources:
       requests:
         storage: 5Gi
   

4. Crie o PersistentVolumeClaim usando o comando kubectl apply.

   kubectl apply -f azurefiles-mount-options-pvc.yaml
   

5. Verifique se o PersistentVolumeClaim foi criado e associado ao PersistentVolume usando o comando kubectl get.

   kubectl get pvc azurefile
   

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

   NAME        STATUS   VOLUME      CAPACITY   ACCESS MODES   STORAGECLASS   AGE
   azurefile   Bound    azurefile   5Gi        RWX            azurefile      5s
   

6. Atualize sua especificação de contêiner para fazer referência ao PersistentVolumeClaim e ao pod no arquivo YAML. Por exemplo:

   ...
     volumes:
     - name: azure
       persistentVolumeClaim:
         claimName: azurefile
   

7. Uma especificação de pod não pode ser atualizada no local, portanto, exclua o pod usando o comando e recrie-o kubectl delete usando o comando kubectl apply.

   kubectl delete pod mypod
   
   kubectl apply -f azure-files-pod.yaml
   

Montar o compartilhamento de arquivo como um volume embutido

Para montar o compartilhamento de arquivos dos Arquivos do Azure em seu pod, você configura o volume na especificação do contêiner.

1. Crie um novo arquivo chamado azure-files-pod.yaml e copie o conteúdo a seguir. Se você tiver alterado o nome do compartilhamento de arquivo ou o nome do segredo, atualize o shareName e o secretName. Você também pode atualizar o mountPath, que é o caminho em que os o compartilhamento de arquivos é montado no pod. Para contêineres do Windows Server, especifique um mountPath usando a convenção de caminho do Windows, como “D:” .

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  nodeSelector:
    kubernetes.io/os: linux
  containers:
    - image: 'mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine'
      name: mypod
      resources:
        requests:
          cpu: 100m
          memory: 128Mi
        limits:
          cpu: 250m
          memory: 256Mi
      volumeMounts:
        - name: azure
          mountPath: /mnt/azure
          readOnly: false
  volumes:
    - name: azure
      csi:
        driver: file.csi.azure.com
        volumeAttributes:
          secretName: azure-secret  # required
          shareName: aksshare  # required
          mountOptions: 'dir_mode=0777,file_mode=0777,cache=strict,actimeo=30,nosharesock,nobrl'  # optional

2. Crie o pod usando o comando kubectl apply.

   kubectl apply -f azure-files-pod.yaml
   

   Agora você tem um pod em execução com um compartilhamento dos Arquivos do Azure montado em /mnt/azure. Você pode verificar se o compartilhamento foi montado com êxito usando o comando kubectl describe.

   kubectl describe pod mypod
   

Próximas etapas

Para parâmetros de driver CSI dos Arquivos do Azure, confira Parâmetros de driver CSI.

Para obter as práticas recomendadas associadas, veja Práticas recomendadas para armazenamento e backups no AKS.