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

Artigo
03/05/2024

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.

Nome	Significado	Valor disponível	Obrigatório	Default value
accountAccessTier	Nível de acesso para conta de armazenamento	A conta Standard pode escolher `Hot` ou `Cool`, e a conta Premium só pode escolher `Premium`.	Não	Vazio. Use a configuração padrão para diferentes tipos de conta de armazenamento.
contaQuota	Limita a cota de uma conta. Você pode especificar uma cota máxima em GB (102400GB por padrão). Se a conta exceder a cota especificada, o driver ignorará a seleção da conta.		Não	`102400`
allowBlobPublicAccess	Permitir ou não permitir o acesso público a todos os blobs ou contêineres para a conta de armazenamento criada pelo driver.	`true` ou `false`	Não	`false`
disableDeleteRetentionPolicy	Especifique se desabilita DeleteRetentionPolicy para a conta de armazenamento criada pelo driver.	`true` ou `false`	Não	`false`
enableLargeFileShares	Especifique se deseja usar uma conta de armazenamento com compartilhamentos de arquivos grandes habilitados ou não. Se esse sinalizador estiver definido como `true` e uma conta de armazenamento com compartilhamentos de arquivos grandes habilitados não existir, uma nova conta de armazenamento com compartilhamentos de arquivos grandes habilitados será criada. Esse sinalizador deve ser usado com o sku padrão, pois as contas de armazenamento criadas com o sku Premium têm `largeFileShares` a opção ativada por padrão.	`true` ou `false`	Não	false
nomedapasta:	Especifique o nome da pasta no compartilhamento de arquivos do Azure.	Nome da pasta existente no compartilhamento de arquivos do Azure.	Não	Se o nome da pasta não existir no compartilhamento de arquivos, a montagem falhará.
getLatestAccount	Determina se a chave de conta mais recente deve ser obtida com base no tempo de criação. Este driver obtém a primeira chave por padrão.	`true` ou `false`	Não	`false`
localização	Especifique a região do Azure da conta de armazenamento do Azure.	Por exemplo, `eastus`.	Não	Se estiver vazio, o driver usará o mesmo nome de local do cluster AKS atual.
matchTags	Corresponder tags quando o driver tenta encontrar uma conta de armazenamento adequada.	`true` ou `false`	Não	`false`
networkEndpointType	Especifique o tipo de ponto de extremidade de rede para a conta de armazenamento criada pelo driver. Se `privateEndpoint` for especificado, um ponto de extremidade privado será criado para a conta de armazenamento. Para outros casos, um ponto de extremidade de serviço é criado por padrão.	"",`privateEndpoint`	Não	""
protocolo	Especifique o protocolo de compartilhamento de arquivos.	`smb`, `nfs`	Não	`smb`
requireInfraEncryption	Especifique se o serviço aplica ou não uma camada secundária de criptografia com chaves gerenciadas pela plataforma para dados em repouso para a conta de armazenamento criada pelo driver.	`true` ou `false`	Não	`false`
resourceGroup	Especifique o grupo de recursos para os Discos do Azure.	Nome do grupo de recursos existente	Não	Se estiver vazio, o driver usa o mesmo nome de grupo de recursos do cluster AKS atual.
selecionarRandomMatchingAccount	Determina se uma conta correspondente deve ser selecionada aleatoriamente. Por padrão, o driver sempre seleciona a primeira conta correspondente em ordem alfabética (Observação: esse driver usa o cache de pesquisa de conta, o que resulta em uma distribuição desigual da criação de arquivos entre várias contas).	`true` ou `false`	Não	`false`
servidor	Especifique o endereço do servidor da conta de armazenamento do Azure.	Endereço do servidor existente, por exemplo `accountname.privatelink.file.core.windows.net`.	Não	Se estiver vazio, o driver usa o endereço padrão `accountname.file.core.windows.net` ou outro endereço de conta de nuvem soberana.
shareAccessTier	Camada de acesso para compartilhamento de arquivos	A conta v2 de uso geral pode escolher entre `TransactionOptimized` (padrão), `Hot`e `Cool`. Tipo de conta de armazenamento premium apenas para compartilhamentos de arquivos.	Não	Vazio. Use a configuração padrão para diferentes tipos de conta de armazenamento.
nome_do-compartilhamento	Especifique o nome do compartilhamento de arquivos do Azure.	Nome de compartilhamento de arquivos do Azure novo ou existente.	Não	Se estiver vazio, o driver gerará um nome de compartilhamento de arquivos do Azure.
shareNamePrefix	Especifique o prefixo do nome de compartilhamento de arquivos do Azure criado pelo driver.	O nome do compartilhamento só pode conter letras minúsculas, números, hífenes e o comprimento deve ter menos de 21 caracteres.	Não
skuName	Tipo de conta de armazenamento do Azure Files (alias: `storageAccountType`)	`Standard_LRS`, `Standard_ZRS`, `Standard_GRS`, `Standard_RAGRS`, `Standard_RAGZRS`, ,`Premium_LRSPremium_ZRS`	Não	`StandardSSD_LRS` O tamanho mínimo de compartilhamento de arquivos para o tipo de conta Premium é de 100 GB. O tipo de conta ZRS é suportado em regiões limitadas. O compartilhamento de arquivos NFS suporta apenas o tipo de conta Premium.
storageEndpointSufixo	Especifique o sufixo do ponto de extremidade de armazenamento do Azure.	`core.windows.net`, `core.chinacloudapi.cn`, etc.	Não	Se estiver vazio, o driver usa o sufixo de ponto de extremidade de armazenamento padrão de acordo com o ambiente de nuvem. Por exemplo, `core.windows.net`.
etiquetas	As tags são criadas em uma nova conta de armazenamento.	Formato da tag: 'foo=aaa,bar=bbb'	Não	""
---	Os seguintes parâmetros são apenas para o protocolo SMB	---	---
ID da subscrição	Especifique a ID de assinatura do Azure onde o compartilhamento de arquivos do Azure é criado.	Id de subscrição do Azure	Não	Se não estiver vazio, `resourceGroup` deve ser fornecido.
storeAccountKey	Especifique se deseja armazenar a chave da conta no segredo do Kubernetes.	`true` ou `false` `false` significa que o driver usa a identidade kubelet para obter a chave da conta.	Não	`true`
secretName	Especifique o nome secreto para armazenar a chave da conta.		Não
secretNamespace	Especifique o namespace de secret para armazenar a chave da conta. Nota: Se `secretNamespace` não for especificado, o segredo será criado no mesmo namespace do pod.	`default`,`kube-system`, etc.	Não	Namespace PVC, por exemplo `csi.storage.k8s.io/pvc/namespace`
useDataPlaneAPI	Especifique se deseja usar a API do plano de dados para criar/excluir/redimensionar o compartilhamento de arquivos, o que poderia resolver o problema de limitação da API SRP porque a API do plano de dados quase não tem limite, enquanto falharia quando há configurações de firewall ou Vnet na conta de armazenamento.	`true` ou `false`	Não	`false`
---	Os seguintes parâmetros são apenas para o protocolo NFS	---	---
mountPermissions	Permissões de pasta montada. A predefinição é `0777`. Se definido como `0`, o driver não é executado `chmod` após a montagem	`0777`	Não
rootSquashType	Especifique o comportamento de esmagamento de raiz no compartilhamento. A predefinição é `NoRootSquash`	`AllSquash`, `NoRootSquash`, `RootSquash`	Não
---	Os parâmetros a seguir são apenas para a configuração de VNet. Por exemplo, NFS, ponto final privado	---	---
fsGroupChangePolicy	Indica como o driver altera a propriedade do volume. Pod `securityContext.fsGroupChangePolicy` é ignorado.	`OnRootMismatch` (por defeito), `Always`, `None`	Não	`OnRootMismatch`
Nome da sub-rede	Nome da sub-rede	Nome da sub-rede existente do nó do agente.	Não	Se estiver vazio, o driver usará o valor no arquivo de configuração de `subnetName` nuvem do Azure.
vnetName	Nome da rede virtual	Nome da rede virtual existente.	Não	Se estiver vazio, o driver usará o valor no arquivo de configuração de `vnetName` nuvem do Azure.
vnetResourceGroup	Especifique o grupo de recursos de rede virtual onde a rede virtual está definida.	Nome do grupo de recursos existente.	Não	Se estiver vazio, o driver usará o valor no arquivo de configuração de `vnetResourceGroup` nuvem do Azure.

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 pPremium (ZRS)

Nota

A partilha de ficheiros premium mínima é de 100GB.

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

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
parameters:
  skuName: Premium_LRS

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.

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.
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:'.

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

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
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.

Nome	Significado	Valor disponível	Obrigatório	Default value
volumeAttributes.resourceGroup	Especifique um nome de grupo de recursos do Azure.	myResourceGroup	Não	Se estiver vazio, o driver usará o mesmo nome de grupo de recursos do cluster atual.
volumeAttributes.storageAccount	Especifique um nome de conta de armazenamento do Azure existente.	storageAccountName	Sim
volumeAttributes.shareName	Especifique um nome de compartilhamento de arquivos do Azure.	fileShareName	Sim
volumeAttributes.folderName	Especifique um nome de pasta no compartilhamento de arquivos do Azure.	nomedapasta:	Não	Se o nome da pasta não existir no compartilhamento de arquivos, a montagem falhará.
volumeAttributes.protocol	Especifique o protocolo de compartilhamento de arquivos.	`smb`, `nfs`	Não	`smb`
volumeAttributes.server	Especificar o endereço do servidor da conta de armazenamento do Azure	Endereço do servidor existente, por exemplo `accountname.privatelink.file.core.windows.net`.	Não	Se estiver vazio, o driver usa o endereço padrão `accountname.file.core.windows.net` ou outro endereço de conta de nuvem soberana.
---	Os seguintes parâmetros são apenas para o protocolo SMB	---	---	---
volumeAttributes.secretName	Especifique um nome secreto que armazene o nome e a chave da conta de armazenamento.		Não
volumeAttributes.secretNamespace	Especifique um namespace secreto.	`default`,`kube-system`, etc.	Não	Espaço de nomes PVC (`csi.storage.k8s.io/pvc/namespace`)
nodeStageSecretRef.name	Especifique um nome secreto que armazene o nome e a chave da conta de armazenamento.	Nome secreto existente	Sim
nodeStageSecretRef.namespace	Especifique um namespace secreto.	Espaço de nomes do Kubernetes	Sim
---	Os seguintes parâmetros são apenas para o protocolo NFS	---	---	---
volumeAttributes.fsGroupChangePolicy	Indica como o driver altera a propriedade de um volume. Pod `securityContext.fsGroupChangePolicy` é ignorado.	`OnRootMismatch` (por defeito), `Always`, `None`	Não	`OnRootMismatch`
volumeAttributes.mountPermissions	Especifique as permissões de pasta montada. A predefinição é `0777`		Não

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.

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
```
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
```
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)
```
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
```

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)

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.

Crie o segredo usando o kubectl create secret comando. O exemplo a seguir cria um segredo chamado azure-secret e preenche azurestorageaccountnamee 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
```

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: unique-volumeid  # 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

Crie o volume persistente usando o kubectl create comando.
```
kubectl create -f azurefiles-pv.yaml
```

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

Crie o PersistentVolumeClaim usando o kubectl apply comando.
```
kubectl apply -f azurefiles-mount-options-pvc.yaml
```

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

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
```
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
```

Nota

Para evitar problemas de desempenho, recomendamos que você use um volume persistente em vez de um volume embutido quando vários pods estiverem acessando o mesmo compartilhamento de arquivos. O volume embutido só pode acessar segredos no mesmo namespace que o pod. Para especificar um namespace secreto diferente, use um volume persistente.

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

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'  # optional

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.