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

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 vários pods, e ele pode ser provisionado dinamicamente ou estaticamente. Se vários pods precisarem de acesso simultâneo ao mesmo volume de armazenamento, você poderá usar os Arquivos do Azure para se conectar usando o protocolo SMB (Server Message Block). Este artigo mostra como criar dinamicamente um compartilhamento de arquivos do Azure para uso por vários pods em um cluster do Serviço Kubernetes do Azure (AKS).

Este artigo mostra-lhe como:

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

Para obter mais informações sobre volumes do Kubernetes, consulte Opções de armazenamento para aplicativos no AKS.

Antes de começar

• Você precisa de uma conta de armazenamento do Azure.
• Verifique se você tem a CLI do Azure versão 2.0.59 ou posterior instalada e configurada. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).
• Ao escolher entre compartilhamentos de arquivos padrão e premium, é importante entender o modelo de provisionamento e os requisitos do padrão de uso esperado que você planeja executar nos Arquivos do Azure. Para obter mais informações, consulte Escolhendo uma camada de desempenho do Azure Files com base em padrões de uso.

Provisionar dinamicamente um volume

Esta seção fornece orientação 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 declaração de volume persistente (PVC) usa o objeto de classe de armazenamento para provisionar dinamicamente um compartilhamento de arquivos do Azure Files.

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 personalizada 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 armazenar o compartilhamento de arquivos do Azure Files. Escolha entre as seguintes SKUs de redundância de armazenamento do Azure para skuName:

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

Para obter mais informações sobre classes de armazenamento do Kubernetes para arquivos do Azure, consulte Classes de armazenamento do Kubernetes.

1. Crie um arquivo nomeado azure-file-sc.yaml e copie no manifesto de exemplo a seguir. Para obter mais informações sobre mountOptionso , consulte 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 kubectl apply comando.

   kubectl apply -f azure-file-sc.yaml
   

Criar uma declaração de volume persistente

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

1. Crie um arquivo nomeado azure-file-pvc.yaml e copie no seguinte YAML. Verifique se o storageClassName corresponde à classe de armazenamento criada na etapa anterior.

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

   Nota

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

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

   kubectl apply -f azure-file-pvc.yaml
   

   Uma vez concluído, o compartilhamento de arquivos é criado. Também é criado um segredo do Kubernetes que inclui informações de conexão e credenciais. Você pode usar o kubectl get comando para visualizar 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 de arquivos do Azure Files 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.yamle copie no seguinte YAML. Certifique-se de que corresponde claimName ao PVC que criou no passo anterior.

   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 kubectl apply comando.

   kubectl apply -f azure-pvc-files.yaml
   

   Agora você tem um pod em execução com seu compartilhamento de arquivos de Arquivos do Azure montado no diretório /mnt/azure . Essa configuração pode ser vista ao inspecionar seu pod usando o kubectl describe comando. A saída de exemplo condensada a seguir 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 Kubernetes versões 1.13.0 e superiores. Se você estiver criando dinamicamente o volume persistente com uma classe de armazenamento, poderá especificar opções de montagem no objeto de classe de armazenamento. Para obter mais informações, consulte 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

Usando marcas do Azure

Para obter mais informações sobre como usar marcas do Azure, consulte Usar marcas do Azure no Serviço Kubernetes do Azure (AKS).

Provisionar estaticamente um volume

Esta seção fornece orientação para administradores de cluster que desejam criar um ou mais volumes persistentes que incluem detalhes de um compartilhamento existente de Arquivos do Azure para usar 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 uma partilha de ficheiros do Azure

Antes de usar um compartilhamento de arquivos do Azure Files como um volume do 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 az aks show comando com o --query nodeResourceGroup parâmetro.

   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 az storage account create comando com o --sku parâmetro. O comando a seguir cria uma conta de armazenamento usando a Standard_LRS SKU. Certifique-se de substituir os seguintes espaços reservados:

   • myAKSStorageAccount com o nome da conta de armazenamento
   • nodeResourceGroupName com o nome do grupo de recursos no qual os nós do cluster AKS estão hospedados
   • location com o nome da região na qual criar o recurso. Deve ser a mesma região que os nós de cluster 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 arquivos usando o az storage share create comando. Certifique-se de substituir shareName pelo nome do seu 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. Eco o nome e a chave da conta de armazenamento usando o seguinte comando. 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 do Kubernetes, que é referenciado quando você cria um pod do Kubernetes.

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

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

Monte o compartilhamento de arquivos como um volume persistente

1. Crie um novo arquivo com o nome azurefiles-pv.yaml e copie no conteúdo a seguir. Em csi, atualizar resourceGroup, volumeHandlee shareName. Para opções de montagem, o valor padrão para 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 kubectl create comando.

   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 kubectl apply comando.

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

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

   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 a seu PersistentVolumeClaim e seu pod no arquivo YAML. Por exemplo:

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

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

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

Monte o compartilhamento de arquivos como um volume embutido

Para montar o compartilhamento de arquivos do Azure Files em seu pod, configure o volume na especificação do contêiner.

1. Crie um novo arquivo com o nome azure-files-pod.yaml e copie no conteúdo a seguir. Se você alterou o nome do compartilhamento de arquivos ou o nome secreto, atualize o shareName e secretName. Você também pode atualizar o mountPath, que é o caminho onde o compartilhamento Arquivos está 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 kubectl apply comando.

   kubectl apply -f azure-files-pod.yaml
   

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

   kubectl describe pod mypod
   

Próximos passos

Para parâmetros de driver CSI do Azure Files, consulte Parâmetros de driver CSI.

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