Skapa och använda en volym med Azure Files i Azure Kubernetes Service (AKS)

Artikel
03/10/2024

En beständiga volym representerar en lagringsdel som har etablerats för användning med Kubernetes-poddar. Du kan använda en beständig volym med en eller flera poddar och den kan etableras dynamiskt eller statiskt. Om flera poddar behöver samtidig åtkomst till samma lagringsvolym kan du använda Azure Files för att ansluta med hjälp av SMB-protokollet (Server Message Block). Den här artikeln visar hur du dynamiskt skapar en Azure-filresurs för användning av flera poddar i ett AKS-kluster (Azure Kubernetes Service).

Den här artikeln visar hur du gör följande:

Arbeta med en dynamisk beständig volym (PV) genom att installera CSI-drivrutinen (Container Storage Interface) och dynamiskt skapa en eller flera Azure-filresurser som ska kopplas till en podd.
Arbeta med en statisk PV genom att skapa en eller flera Azure-filresurser eller använda en befintlig och koppla den till en podd.

Mer information om Kubernetes-volymer finns i Lagringsalternativ för program i AKS.

Innan du börjar

Du behöver ett Azure Storage-konto.
Kontrollera att Azure CLI version 2.0.59 eller senare har installerats och konfigurerats. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.
När du väljer mellan standard- och premiumfilresurser är det viktigt att du förstår etableringsmodellen och kraven för det förväntade användningsmönstret som du planerar att köra på Azure Files. Mer information finns i Välja en Azure Files-prestandanivå baserat på användningsmönster.

Etablera en volym dynamiskt

Det här avsnittet innehåller vägledning för klusteradministratörer som vill etablera en eller flera beständiga volymer som innehåller information om en eller flera resurser i Azure Files. Ett beständiga volymanspråk (PVC) använder lagringsklassobjektet för att dynamiskt etablera en Azure Files-filresurs.

Lagringsklassparametrar för dynamiska PersistentVolumes

Följande tabell innehåller parametrar som du kan använda för att definiera en anpassad lagringsklass för din PersistentVolumeClaim.

Name	Innebörd	Tillgängligt värde	Obligatorisk	Default value
accountAccessTier	Åtkomstnivå för lagringskonto	Standardkontot kan välja `Hot` eller `Cool`, och Premium-kontot kan bara välja `Premium`.	Nej	Tom. Använd standardinställningen för olika typer av lagringskonton.
accountQuota	Begränsar kvoten för ett konto. Du kan ange en maximal kvot i GB (102400 GB som standard). Om kontot överskrider den angivna kvoten hoppar drivrutinen över att välja kontot.		Nej	`102400`
allowBlobPublicAccess	Tillåt eller tillåt inte offentlig åtkomst till alla blobar eller containrar för lagringskonto som skapats av drivrutinen.	`true` eller `false`	Nej	`false`
disableDeleteRetentionPolicy	Ange om du vill inaktivera DeleteRetentionPolicy för lagringskonto som skapats av drivrutinen.	`true` eller `false`	Nej	`false`
enableLargeFileShares	Ange om du vill använda ett lagringskonto med stora filresurser aktiverade eller inte. Om den här flaggan är inställd på `true` och ett lagringskonto med stora filresurser aktiverade inte finns, skapas ett nytt lagringskonto med stora filresurser aktiverade. Den här flaggan ska användas med standard-sku:n eftersom lagringskontona som skapats med Premium-SKU:n har `largeFileShares` aktiverats som standard.	`true` eller `false`	Nej	falskt
Mappnamn	Ange mappnamn i Azure-filresursen.	Befintligt mappnamn i Azure-filresursen.	Nej	Om mappnamnet inte finns i filresursen misslyckas monteringen.
getLatestAccount	Avgör om den senaste kontonyckeln ska hämtas baserat på skapandetiden. Den här drivrutinen hämtar den första nyckeln som standard.	`true` eller `false`	Nej	`false`
plats	Ange Azure-regionen för Azure Storage-kontot.	Exempel: `eastus`	Nej	Om den är tom använder drivrutinen samma platsnamn som det aktuella AKS-klustret.
matchTags	Matcha taggar när drivrutinen försöker hitta ett lämpligt lagringskonto.	`true` eller `false`	Nej	`false`
networkEndpointType	Ange nätverksslutpunktstyp för lagringskontot som skapats av drivrutinen. Om `privateEndpoint` anges skapas en privat slutpunkt för lagringskontot. I andra fall skapas en tjänstslutpunkt som standard.	"",`privateEndpoint`	Nej	""
Protokollet	Ange filresursprotokoll.	`smb`, `nfs`	Nej	`smb`
requireInfraEncryption	Ange om tjänsten tillämpar ett sekundärt krypteringslager med plattformshanterade nycklar för vilande data för lagringskonto som skapats av drivrutinen.	`true` eller `false`	Nej	`false`
resourceGroup	Ange resursgruppen för Azure Disks.	Befintligt resursgruppsnamn	Nej	Om den är tom använder drivrutinen samma resursgruppsnamn som det aktuella AKS-klustret.
selectRandomMatchingAccount	Avgör om ett matchande konto ska väljas slumpmässigt. Som standard väljer drivrutinen alltid det första matchande kontot i alfabetisk ordning (Obs! Den här drivrutinen använder kontosökningscache, vilket resulterar i ojämn fördelning av filskapande mellan flera konton).	`true` eller `false`	Nej	`false`
server	Ange serveradress för Azure-lagringskontot.	Befintlig serveradress, till exempel `accountname.privatelink.file.core.windows.net`.	Nej	Om den är tom använder drivrutinen standardadressen `accountname.file.core.windows.net` eller annan kontoadress för nationellt moln.
shareAccessTier	Åtkomstnivå för filresurs	Generell användning v2-konto kan välja mellan `TransactionOptimized` (standard), `Hot`och `Cool`. Premium-lagringskontotyp endast för filresurser.	Nej	Tom. Använd standardinställningen för olika typer av lagringskonton.
Resursnamn	Ange Namnet på Azure-filresursen.	Befintligt eller nytt Namn på Azure-filresurs.	Nej	Om den är tom genererar drivrutinen ett Azure-filresursnamn.
shareNamePrefix	Ange prefixet för Azure-filresursens namn som skapats av drivrutinen.	Resursnamnet får bara innehålla gemener, siffror, bindestreck och längd ska vara färre än 21 tecken.	Nej
skuName	Azure Files-lagringskontotyp (alias: `storageAccountType`)	`Standard_LRS`, `Standard_ZRS`, `Standard_GRS`, `Standard_RAGRS`, `Standard_RAGZRS`,`Premium_LRS`, `Premium_ZRS`	Nej	`StandardSSD_LRS` Minsta filresursstorlek för Premium-kontotyp är 100 GB. ZRS-kontotypen stöds i begränsade regioner. NFS-filresursen stöder endast Premium-kontotyp.
storageEndpointSuffix	Ange Azure Storage-slutpunktssuffix.	`core.windows.net`, `core.chinacloudapi.cn`, osv.	Nej	Om det är tomt använder drivrutinen standardsuffixet för lagringsslutpunkter enligt molnmiljön. Exempel: `core.windows.net`
taggar	Taggar skapas i ett nytt lagringskonto.	Taggformat: 'foo=aaa,bar=bbb'	Nej	""
---	Följande parametrar gäller endast för SMB-protokoll	---	---
subscriptionID	Ange Azure-prenumerations-ID där Azure-filresursen skapas.	Azure-prenumerations-ID	Nej	Om den inte är tom `resourceGroup` måste den anges.
storeAccountKey	Ange om kontonyckeln ska lagras i Kubernetes-hemligheten.	`true` eller `false` `false` innebär att drivrutinen använder kubelet-identitet för att hämta kontonyckeln.	Nej	`true`
secretName	Ange hemligt namn för att lagra kontonyckeln.		Nej
secretNamespace	Ange namnområdet för hemligheten för att lagra kontonyckeln. Obs! Om `secretNamespace` inte anges skapas hemligheten i samma namnområde som podden.	`default`,`kube-system` osv.	Nej	PVC-namnrymd, till exempel `csi.storage.k8s.io/pvc/namespace`
useDataPlaneAPI	Ange om dataplanets API ska användas för att skapa/ta bort/ändra storlek på filresursen, vilket kan lösa SRP API-begränsningsproblemet eftersom dataplanets API nästan inte har någon gräns, medan det skulle misslyckas när det finns brandväggs- eller Vnet-inställningar för lagringskontot.	`true` eller `false`	Nej	`false`
---	Följande parametrar gäller endast för NFS-protokoll	---	---
mountPermissions	Behörigheter för monterade mappar. Standardvärdet är `0777`. Om värdet `0`är , utförs `chmod` inte drivrutinen efter monteringen	`0777`	Nej
rootSquashType	Ange beteende för rot squashing på resursen. Standardvärdet är `NoRootSquash`	`AllSquash`, , `NoRootSquashRootSquash`	Nej
---	Följande parametrar gäller endast för VNet-inställning. Till exempel NFS, privat slutpunkt	---	---
fsGroupChangePolicy	Anger hur drivrutinen ändrar volymens ägarskap. Podden `securityContext.fsGroupChangePolicy` ignoreras.	`OnRootMismatch` (standard), `Always`, `None`	Nej	`OnRootMismatch`
subnetName	Namn på undernät	Agentnodens befintliga undernätsnamn.	Nej	Om den är tom använder `subnetName` drivrutinen värdet i Azure Cloud-konfigurationsfilen.
vnetName	Virtuellt nätverksnamn	Befintligt namn på virtuellt nätverk.	Nej	Om den är tom använder `vnetName` drivrutinen värdet i Azure Cloud-konfigurationsfilen.
vnetResourceGroup	Ange den VNet-resursgrupp där det virtuella nätverket har definierats.	Befintligt resursgruppsnamn.	Nej	Om den är tom använder `vnetResourceGroup` drivrutinen värdet i Azure Cloud-konfigurationsfilen.

Skapa en lagringsklass

Lagringsklasser definierar hur du skapar en Azure-filresurs. Ett lagringskonto skapas automatiskt i nodresursgruppen för användning med lagringsklassen för att lagra Azure Files-filresursen. Välj följande SKU:er för Azure Storage-redundans för skuName:

Standard_LRS: Standard lokalt redundant lagring (LRS)
Standard_GRS: Standard geo-redundant lagring (GRS)
Standard_ZRS: Standard zonredundant lagring (ZRS)
Standard_RAGRS: Geo-redundant lagring med standardläsningsåtkomst (RA-GRS)
Premium_LRS: Lokalt redundant Premium-lagring (LRS)
Premium_ZRS: pPremium zone redundant storage (ZRS)

Kommentar

Minsta premiumfilresurs är 100 GB.

Mer information om Kubernetes-lagringsklasser för Azure Files finns i Kubernetes Storage-klasser.

Skapa en fil med namnet azure-file-sc.yaml och kopiera i följande exempelmanifest. Mer information om mountOptionsfinns i avsnittet Monteringsalternativ .

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

Skapa lagringsklassen kubectl apply med kommandot .
```
kubectl apply -f azure-file-sc.yaml
```

Skapa ett beständigt volymanspråk

Ett beständiga volymanspråk (PVC) använder lagringsklassobjektet för att dynamiskt etablera en Azure-filresurs. Du kan använda följande YAML för att skapa ett beständigt volymanspråk på 100 GB i storlek med ReadWriteMany-åtkomst . Mer information om åtkomstlägen finns i Kubernetes beständiga volym.

Skapa en fil med namnet azure-file-pvc.yaml och kopiera i följande YAML. Kontrollera att matchar storageClassName lagringsklassen som du skapade i föregående steg.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-azurefile
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: my-azurefile
  resources:
    requests:
      storage: 100Gi
```
Kommentar

Om du använder Premium_LRS SKU:n för lagringsklassen måste minimivärdet för storage vara 100Gi.
Skapa det beständiga volymanspråket kubectl apply med kommandot .
```
kubectl apply -f azure-file-pvc.yaml
```
När det är klart skapas filresursen. En Kubernetes-hemlighet skapas också som innehåller anslutningsinformation och autentiseringsuppgifter. Du kan använda kubectl get kommandot för att visa status för PVC:
```
kubectl get pvc my-azurefile
```
Kommandots utdata liknar följande exempel:
```
NAME           STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS      AGE
my-azurefile   Bound     pvc-8436e62e-a0d9-11e5-8521-5a8664dc0477   100Gi       RWX            my-azurefile      5m
```

Använd den beständiga volymen

Följande YAML skapar en podd som använder den beständiga volymanspråket my-azurefile för att montera Azure Files-filresursen på sökvägen /mnt/azure . För Windows Server-containrar anger du en mountPath med hjälp av Windows-sökvägskonventionen, till exempel "D:".

Skapa en fil med namnet azure-pvc-files.yamloch kopiera i följande YAML. Kontrollera att matchar claimName DEN PVC som du skapade i föregående steg.

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

Skapa podden med kommandot kubectl apply .

kubectl apply -f azure-pvc-files.yaml

Nu har du en podd som körs med din Azure Files-filresurs monterad i katalogen /mnt/azure . Den här konfigurationen visas när du inspekterar din podd med hjälp av kubectl describe kommandot . Följande komprimerade exempelutdata visar volymen monterad i containern.

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

Monteringsalternativ

Standardvärdet för fileMode och dirMode är 0777 för Kubernetes version 1.13.0 och senare. Om du dynamiskt skapar den beständiga volymen med en lagringsklass kan du ange monteringsalternativ för lagringsklassobjektet. Mer information finns i Monteringsalternativ. I följande exempel anges 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

Använda Azure-taggar

Mer information om hur du använder Azure-taggar finns i Använda Azure-taggar i Azure Kubernetes Service (AKS).

Statiskt etablera en volym

Det här avsnittet innehåller vägledning för klusteradministratörer som vill skapa en eller flera beständiga volymer som innehåller information om en befintlig Azure Files-resurs som ska användas med en arbetsbelastning.

Statiska etableringsparametrar för PersistentVolume

Följande tabell innehåller parametrar som du kan använda för att definiera en PersistentVolume.

Name	Innebörd	Tillgängligt värde	Obligatorisk	Default value
volumeAttributes.resourceGroup	Ange ett Namn på Azure-resursgrupp.	myResourceGroup	Nej	Om den är tom använder drivrutinen samma resursgruppsnamn som det aktuella klustret.
volumeAttributes.storageAccount	Ange ett befintligt Azure Storage-kontonamn.	storageAccountName	Ja
volumeAttributes.shareName	Ange ett Azure-filresursnamn.	fileShareName	Ja
volumeAttributes.folderName	Ange ett mappnamn i Azure-filresursen.	Mappnamn	Nej	Om mappnamnet inte finns i filresursen misslyckas monteringen.
volumeAttributes.protocol	Ange filresursprotokoll.	`smb`, `nfs`	Nej	`smb`
volumeAttributes.server	Ange serveradress för Azure Storage-konto	Befintlig serveradress, till exempel `accountname.privatelink.file.core.windows.net`.	Nej	Om den är tom använder drivrutinen standardadressen `accountname.file.core.windows.net` eller annan kontoadress för nationellt moln.
---	Följande parametrar gäller endast för SMB-protokoll	---	---	---
volumeAttributes.secretName	Ange ett hemligt namn som lagrar lagringskontots namn och nyckel.		Nej
volumeAttributes.secretNamespace	Ange ett hemligt namnområde.	`default`,`kube-system` osv.	Nej	PVC-namnområde (`csi.storage.k8s.io/pvc/namespace`)
nodeStageSecretRef.name	Ange ett hemligt namn som lagrar lagringskontots namn och nyckel.	Befintligt hemligt namn	Ja
nodeStageSecretRef.namespace	Ange ett hemligt namnområde.	Kubernetes-namnområde	Ja
---	Följande parametrar gäller endast för NFS-protokoll	---	---	---
volumeAttributes.fsGroupChangePolicy	Anger hur drivrutinen ändrar en volyms ägarskap. Podden `securityContext.fsGroupChangePolicy` ignoreras.	`OnRootMismatch` (standard), `Always`, `None`	Nej	`OnRootMismatch`
volumeAttributes.mountPermissions	Ange behörigheter för monterade mappar. Standardvärdet är `0777`		Nej

Innan du kan använda en Azure Files-filresurs som kubernetes-volym måste du skapa ett Azure Storage-konto och filresursen.

Hämta resursgruppens namn med kommandot az aks show med parametern --query nodeResourceGroup .

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

Kommandots utdata liknar följande exempel:

MC_myResourceGroup_myAKSCluster_eastus

Skapa ett lagringskonto med kommandot az storage account create med parametern --sku . Följande kommando skapar ett lagringskonto med hjälp av SKU:n Standard_LRS . Ersätt följande platshållare:
- myAKSStorageAccount med namnet på lagringskontot
- nodeResourceGroupName med namnet på resursgruppen som AKS-klusternoderna finns i
- location med namnet på regionen som resursen ska skapas i. Det bör vara samma region som AKS-klusternoderna.
```
az storage account create -n myAKSStorageAccount -g nodeResourceGroupName -l location --sku Standard_LRS
```

Exportera anslutningssträng som en miljövariabel med hjälp av följande kommando, som du använder för att skapa filresursen.

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

Skapa filresursen az storage share create med kommandot . Ersätt shareName med resursnamnet.

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

Exportera lagringskontonyckeln som en miljövariabel med hjälp av följande kommando.

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

Upprepa lagringskontots namn och nyckel med hjälp av följande kommando. Kopiera den här informationen eftersom du behöver dessa värden när du skapar Kubernetes-volymen.
```
echo Storage account key: $STORAGE_KEY
```

Skapa en Kubernetes-hemlighet

Kubernetes behöver autentiseringsuppgifter för att komma åt filresursen som skapades i föregående steg. Dessa autentiseringsuppgifter lagras i en Kubernetes-hemlighet, som refereras när du skapar en Kubernetes-podd.

Skapa hemligheten med kommandot kubectl create secret . I följande exempel skapas en hemlighet med namnet azure-secret och fyller i azurestorageaccountname och azurestorageaccountkey från föregående steg. Om du vill använda ett befintligt Azure-lagringskonto anger du kontonamnet och nyckeln.
```
kubectl create secret generic azure-secret --from-literal=azurestorageaccountname=myAKSStorageAccount --from-literal=azurestorageaccountkey=$STORAGE_KEY
```

Skapa en ny fil med namnet azurefiles-pv.yaml och kopiera i följande innehåll. Under csi, uppdatera resourceGroup, volumeHandleoch shareName. För monteringsalternativ är standardvärdet för fileMode och 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

Skapa den beständiga volymen med kommandot kubectl create .
```
kubectl create -f azurefiles-pv.yaml
```

Skapa en ny fil med namnet azurefiles-mount-options-pvc.yaml och kopiera följande innehåll.

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

Skapa PersistentVolumeClaim med kommandot kubectl apply .
```
kubectl apply -f azurefiles-mount-options-pvc.yaml
```

Kontrollera att PersistentVolumeClaim har skapats och bundits till PersistentVolume med hjälp av kubectl get kommandot .

kubectl get pvc azurefile

Utdata från kommandot liknar följande exempel:

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

Uppdatera containerspecifikationen så att den refererar till PersistentVolumeClaim och podden i YAML-filen. Till exempel:
```
...
  volumes:
  - name: azure
    persistentVolumeClaim:
      claimName: azurefile
```
Det går inte att uppdatera en poddspecifikation på plats, så ta bort podden med kubectl delete kommandot och återskapa den med kommandot kubectl apply .
```
kubectl delete pod mypod

kubectl apply -f azure-files-pod.yaml
```

Kommentar

För att undvika prestandaproblem rekommenderar vi att du använder en beständig volym i stället för en infogad volym när flera poddar har åtkomst till samma filresurs. Infogad volym kan bara komma åt hemligheter i samma namnområde som podden. Om du vill ange ett annat hemligt namnområde använder du en beständiga volym.

Om du vill montera Azure Files-filresursen i podden konfigurerar du volymen i containerspecifikationen.

Skapa en ny fil med namnet azure-files-pod.yaml och kopiera i följande innehåll. Om du har ändrat namnet på filresursen eller det hemliga namnet uppdaterar shareName du och secretName. Du kan också uppdatera mountPath, vilket är sökvägen där filresursen monteras i podden. För Windows Server-containrar anger du en mountPath med hjälp av Windows-sökvägskonventionen, till exempel "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

Skapa podden med kommandot kubectl apply .
```
kubectl apply -f azure-files-pod.yaml
```
Nu har du en podd som körs med en Azure Files-filresurs monterad på /mnt/azure. Du kan kontrollera att resursen har monterats med hjälp av kubectl describe kommandot .
```
kubectl describe pod mypod
```

Nästa steg

Information om CSI-drivrutinsparametrar för Azure Files finns i CSI-drivrutinsparametrar.

För tillhörande metodtips, se Metodtips för lagring och säkerhetskopior i AKS.