Kötet létrehozása és használata az Azure Files használatával az Azure Kubernetes Service-ben (AKS)

Cikk
03/05/2024

Az állandó kötetek olyan tárterületet jelölnek, amely a Kubernetes-podokkal való használatra lett kiépítve. Egy állandó kötetet egy vagy több podtal is használhat, és dinamikusan vagy statikusan kiépítve is lehet. Ha több podnak egyszerre kell hozzáférnie ugyanahhoz a tárkötethez, az Azure Files használatával csatlakozhat a Kiszolgálói üzenetblokk (SMB) protokoll használatával. Ez a cikk bemutatja, hogyan hozhat létre dinamikusan egy Azure-fájlmegosztást egy Azure Kubernetes Service- (AKS-) fürt több podja számára.

Ez a cikk bemutatja, hogyan:

Dinamikus állandó kötet (PV) használata a Container Storage Interface (CSI) illesztő telepítésével és egy vagy több Azure-fájlmegosztás dinamikus létrehozásával egy podhoz csatolva.
Statikus PV-vel dolgozhat egy vagy több Azure-fájlmegosztás létrehozásával, vagy egy meglévő használatával, és csatolhatja azt egy podhoz.

A Kubernetes-kötetekkel kapcsolatos további információkért tekintse meg az AKS-alkalmazások tárolási lehetőségeit.

Mielőtt elkezdené

Azure Storage-fiókra van szüksége.
Győződjön meg arról, hogy telepítve és konfigurálva van az Azure CLI 2.0.59-es vagy újabb verziója. A verzió azonosításához futtassa a következőt: az --version. Ha telepíteni vagy frissíteni szeretne: Az Azure CLI telepítése.
A standard és a prémium szintű fájlmegosztások közötti választáskor fontos tisztában lenni a kiépítési modellel és az Azure Fileson futtatni kívánt elvárt használati mintával. További információ: Azure Files-teljesítményszint kiválasztása használati minták alapján.

Kötet dinamikus kiépítése

Ez a szakasz útmutatást nyújt a fürt rendszergazdáinak, akik egy vagy több állandó kötetet szeretnének kiépíteni, amelyek tartalmazzák az Azure Files egy vagy több megosztásának részleteit. Egy állandó mennyiségi jogcím (PVC) a tárolási osztály objektumával dinamikusan kiépíteni egy Azure Files-fájlmegosztást.

A dinamikus PersistentVolumes tárolási osztályparaméterei

Az alábbi táblázat olyan paramétereket tartalmaz, amelyekkel egyéni tárosztályt definiálhat a PersistentVolumeClaim-hez.

Név	Értelmezés	Elérhető érték	Kötelező	Alapértelmezett érték
accountAccessTier	Tárfiók hozzáférési szintje	A standard fiók választhat `Hot` vagy `Cool`választhat, a Prémium fiók pedig csak a választható lehetőségek közül választhat `Premium`.	Nem	Üres. Használja az alapértelmezett beállítást a különböző tárfióktípusokhoz.
accountQuota	Egy fiók kvótájának korlátozása. A maximális kvótát GB-ban (alapértelmezés szerint 102400 GB) adhatja meg. Ha a fiók túllépi a megadott kvótát, az illesztőprogram kihagyja a fiók kiválasztását.		Nem	`102400`
allowBlobPublicAccess	Az illesztőprogram által létrehozott tárfiók összes blobjának vagy tárolójának nyilvános hozzáférésének engedélyezése vagy letiltása.	`true` vagy `false`	Nem	`false`
disableDeleteRetentionPolicy	Adja meg, hogy letiltsa-e a DeleteRetentionPolicy funkciót az illesztőprogram által létrehozott tárfiókhoz.	`true` vagy `false`	Nem	`false`
enableLargeFileShares	Adja meg, hogy használjon-e olyan tárfiókot, amelyen engedélyezve van a nagy fájlmegosztások használata. Ha ez a jelző be van állítva `true` , és nem létezik olyan tárfiók, amelyen engedélyezve vannak a nagy fájlmegosztások, létrejön egy új tárfiók, amelyen engedélyezve vannak a nagy fájlmegosztások. Ezt a jelzőt a Standard termékváltozattal kell használni, mivel a Prémium termékváltozattal létrehozott tárfiókok alapértelmezés szerint engedélyezve vannak `largeFileShares` .	`true` vagy `false`	Nem	false
folderName	Adja meg a mappa nevét az Azure-fájlmegosztásban.	Meglévő mappanév az Azure-fájlmegosztásban.	Nem	Ha a mappanév nem létezik a fájlmegosztásban, a csatlakoztatás sikertelen lesz.
getLatestAccount	Meghatározza, hogy a létrehozási idő alapján lekérje-e a legújabb fiókkulcsot. Alapértelmezés szerint ez az illesztőprogram kapja meg az első kulcsot.	`true` vagy `false`	Nem	`false`
hely	Adja meg az Azure Storage-fiók Azure-régióját.	Például: `eastus`.	Nem	Ha üres, az illesztőprogram ugyanazt a helynevet használja, mint az aktuális AKS-fürt.
egyezéscímkék	A címkék egyezése, amikor az illesztőprogram megfelelő tárfiókot próbál megtalálni.	`true` vagy `false`	Nem	`false`
networkEndpointType	Adja meg az illesztőprogram által létrehozott tárfiók hálózati végponttípusát. Ha `privateEndpoint` meg van adva, létrejön egy privát végpont a tárfiókhoz. Más esetekben alapértelmezés szerint létrejön egy szolgáltatásvégpont.	"",`privateEndpoint`	Nem	""
Protokoll	Adja meg a fájlmegosztási protokollt.	`smb`, `nfs`	Nem	`smb`
requireInfraEncryption	Adja meg, hogy a szolgáltatás egy másodlagos titkosítási réteget alkalmaz-e platform által felügyelt kulcsokkal a inaktív adatokhoz az illesztőprogram által létrehozott tárfiókhoz.	`true` vagy `false`	Nem	`false`
resourceGroup	Adja meg az Azure Disks erőforráscsoportját.	Meglévő erőforráscsoport neve	Nem	Ha üres, az illesztőprogram ugyanazt az erőforráscsoportnevet használja, mint az aktuális AKS-fürt.
selectRandomMatchingAccount	Meghatározza, hogy véletlenszerűen válasszon-e egy egyező fiókot. Alapértelmezés szerint az illesztőprogram mindig betűrendben választja ki az első egyező fiókot (megjegyzés: Ez az illesztőprogram fiókkeresési gyorsítótárat használ, ami a fájllétrehozás több fiók közötti egyenlőtlen elosztását eredményezi).	`true` vagy `false`	Nem	`false`
kiszolgáló	Adja meg az Azure Storage-fiók kiszolgálói címét.	Meglévő kiszolgáló címe, például `accountname.privatelink.file.core.windows.net`.	Nem	Ha üres, az illesztőprogram alapértelmezett `accountname.file.core.windows.net` vagy más szuverén felhőfiók-címet használ.
shareAccessTier	A fájlmegosztás hozzáférési szintje	Az általános célú v2-fiók választhat `TransactionOptimized` az (alapértelmezett) `Hot`és a `Cool`. Prémium szintű tárfióktípus csak fájlmegosztásokhoz.	Nem	Üres. Használja az alapértelmezett beállítást a különböző tárfióktípusokhoz.
shareName	Adja meg az Azure-fájlmegosztás nevét.	Meglévő vagy új Azure-fájlmegosztás neve.	Nem	Ha üres, az illesztőprogram létrehoz egy Azure-fájlmegosztási nevet.
shareNamePrefix	Adja meg az illesztőprogram által létrehozott Azure-fájlmegosztásnév-előtagot.	A megosztási név csak kisbetűket, számokat, kötőjeleket és hosszúságokat tartalmazhat 21 karakternél kevesebb karakternél.	Nem
skuName	Azure Files-tárfiók típusa (alias: `storageAccountType`)	`Standard_LRS`, `Standard_ZRS`, `Standard_GRS`, `Standard_RAGRSStandard_RAGZRS`,`Premium_LRS`,`Premium_ZRS`	Nem	`StandardSSD_LRS` A prémium szintű fióktípus minimális fájlmegosztási mérete 100 GB. A ZRS-fiók típusa korlátozott régiókban támogatott. Az NFS-fájlmegosztás csak a Prémium fióktípust támogatja.
storageEndpointSuffix	Adja meg az Azure Storage-végpont utótagját.	`core.windows.net`, stb `core.chinacloudapi.cn`.	Nem	Ha üres, az illesztőprogram az alapértelmezett tárolási végpont utótagját használja a felhőkörnyezetnek megfelelően. Például: `core.windows.net`.
címkét	A címkék új tárfiókban jönnek létre.	Címkeformátum: 'foo=aaa,bar=bbb'	Nem	""
---	A következő paraméterek csak az SMB protokollhoz tartoznak	---	---
subscriptionID	Adja meg az Azure-előfizetés azonosítóját, ahol létrejön az Azure-fájlmegosztás.	Azure-előfizetés azonosítója	Nem	Ha nem üres, `resourceGroup` meg kell adni.
storeAccountKey	Adja meg, hogy a kubernetes titkos kulcsában tárolja-e a fiókkulcsot.	`true` vagy `false` `false` azt jelenti, hogy az illesztőprogram kubelet-identitást használ a fiókkulcs lekéréséhez.	Nem	`true`
secretName	Adja meg a fiókkulcs tárolásához használt titkos nevet.		Nem
secretNamespace	Adja meg a fiókkulcs tárolására használt titkos kód névterét. Megjegyzés: Ha `secretNamespace` nincs megadva, a titkos kód ugyanabban a névtérben jön létre, mint a pod.	`default`stb`kube-system`.	Nem	PVC-névtér, például `csi.storage.k8s.io/pvc/namespace`
useDataPlaneAPI	Adja meg, hogy az adatsík API-t használja-e a fájlmegosztás létrehozásához/törléséhez/átméretezéséhez, ami megoldhatja az SRP API szabályozásával kapcsolatos problémát, mivel az adatsík API-jának szinte nincs korlátja, miközben a tárfiók tűzfal- vagy Vnetbeállításai meghiúsulnának.	`true` vagy `false`	Nem	`false`
---	A következő paraméterek csak az NFS protokollhoz tartoznak	---	---
mountPermissions	Csatlakoztatott mappaengedélyek. Az alapértelmezett érték `0777`. Ha be van állítva, az `0`illesztő nem működik `chmod` a csatlakoztatás után	`0777`	Nem
rootSquashType	Adja meg a megosztás gyökérpréselési viselkedését. Az alapértelmezett érték: `NoRootSquash`	`AllSquash`, , `NoRootSquashRootSquash`	Nem
---	A következő paraméterek csak a VNet-beállításokhoz tartoznak. Például: NFS, privát végpont	---	---
fsGroupChangePolicy	Azt jelzi, hogy az illesztőprogram hogyan változtatja meg a kötet tulajdonjogát. A pod `securityContext.fsGroupChangePolicy` figyelmen kívül lesz hagyva.	`OnRootMismatch` (alapértelmezett), `Always`, `None`	Nem	`OnRootMismatch`
alhálózatnév	Alhálózat neve	Az ügynökcsomópont meglévő alhálózati neve.	Nem	Ha üres, az illesztőprogram az `subnetName` Azure cloud config fájlban lévő értéket használja.
vnetName	Virtuális hálózat neve	Meglévő virtuális hálózat neve.	Nem	Ha üres, az illesztőprogram az `vnetName` Azure cloud config fájlban lévő értéket használja.
vnetResourceGroup	Adja meg a virtuális hálózat erőforráscsoportját, ahol a virtuális hálózat definiálva van.	Meglévő erőforráscsoport neve.	Nem	Ha üres, az illesztőprogram az `vnetResourceGroup` Azure cloud config fájlban lévő értéket használja.

Tárosztály létrehozása

A tárolási osztályok határozzák meg az Azure-fájlmegosztások létrehozását. A rendszer automatikusan létrehoz egy tárfiókot a csomópont erőforráscsoportjában az Azure Files-fájlmegosztás tárolására szolgáló tárosztályhoz. A következő Azure Storage-redundancia-termékváltozatokskuNameközül választhat:

Standard_LRS: Standard helyileg redundáns tárolás (LRS)
Standard_GRS: Standard georedundáns tárolás (GRS)
Standard_ZRS: Standard zónaredundáns tárolás (ZRS)
Standard_RAGRS: Standard olvasási hozzáférésű georedundáns tárolás (RA-GRS)
Premium_LRS: Helyileg redundáns prémium szintű tárolás (LRS)
Premium_ZRS: pPremium zónaredundáns tárolás (ZRS)

Feljegyzés

A prémium szintű fájlmegosztás minimális értéke 100 GB.

Az Azure Files Kubernetes Storage-osztályokkal kapcsolatos további információkért lásd: Kubernetes Storage Classes.

Hozzon létre egy fájlt, azure-file-sc.yaml és másolja a következő példajegyzékbe. További információ: mountOptionsCsatlakoztatási beállítások szakasz.

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

Hozza létre a tárosztályt a kubectl apply paranccsal.
```
kubectl apply -f azure-file-sc.yaml
```

Állandó mennyiségi jogcím létrehozása

Egy állandó mennyiségi jogcím (PVC) a tárolási osztály objektumával dinamikusan kiépíteni egy Azure-fájlmegosztást. A következő YAML-lel létrehozhat egy 100 GB méretű állandó mennyiségi jogcímet ReadWriteMany-hozzáféréssel. A hozzáférési módokról további információt a Kubernetes állandó kötetében talál.

Hozzon létre egy fájlt, azure-file-pvc.yaml és másolja a következő YAML-fájlba. Győződjön meg arról, hogy az storageClassName előző lépésben létrehozott tárosztály megegyezik.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-azurefile
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: my-azurefile
  resources:
    requests:
      storage: 100Gi
```
Feljegyzés

Ha a Premium_LRS tárosztály termékváltozatát használja, a minimális értéknek storage meg kell lennie 100Gi.
Hozza létre az állandó kötet jogcímét a kubectl apply parancs használatával.
```
kubectl apply -f azure-file-pvc.yaml
```
Miután elkészült, létrejön a fájlmegosztás. Létrejön egy Kubernetes-titkos kód is, amely tartalmazza a kapcsolati adatokat és a hitelesítő adatokat. A parancs segítségével kubectl get megtekintheti a PVC állapotát:
```
kubectl get pvc my-azurefile
```
A parancs kimenete a következő példához hasonlít:
```
NAME           STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS      AGE
my-azurefile   Bound     pvc-8436e62e-a0d9-11e5-8521-5a8664dc0477   100Gi       RWX            my-azurefile      5m
```

Az állandó kötet használata

Az alábbi YAML létrehoz egy podot, amely a my-azurefile állandó kötet használatával csatlakoztatja az Azure Files-fájlmegosztást az /mnt/azure elérési úton. Windows Server-tárolók esetén adja meg mountPath a Windows elérési út konvencióját, például a "D:"-t.

Hozzon létre egy fájlt, azure-pvc-files.yamlés másolja a következő YAML-be. Győződjön meg arról, hogy az claimName előző lépésben létrehozott PVC-vel egyezik.

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

Hozza létre a podot a kubectl apply paranccsal.

kubectl apply -f azure-pvc-files.yaml

Most már rendelkezik egy futó podgal, amelyen az Azure Files-fájlmegosztás az /mnt/azure könyvtárban van csatlakoztatva. Ez a konfiguráció látható a pod parancs használatával kubectl describe történő vizsgálatakor. Az alábbi tömörített példakimenet a tárolóba csatlakoztatott kötetet mutatja.

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

Csatlakoztatási beállítások

A Kubernetes 1.13.0-s és újabb verzióinak alapértelmezett értéke fileModedirMode0777. Ha dinamikusan hozza létre az állandó kötetet egy tárosztálysal, megadhatja a csatlakoztatási beállításokat a tárolási osztály objektumán. További információ: Csatlakoztatási beállítások. A következő példa a 0777-et állítja be:

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

Azure-címkék használata

További információ az Azure-címkék használatáról: Azure-címkék használata az Azure Kubernetes Service-ben (AKS).

Kötet statikus kiépítése

Ez a szakasz útmutatást nyújt a fürt rendszergazdáinak, akik egy vagy több állandó kötetet szeretnének létrehozni, amelyek tartalmazzák a számítási feladathoz használandó meglévő Azure Files-megosztás részleteit.

Statikus kiépítési paraméterek a PersistentVolume-hoz

Az alábbi táblázat a PersistentVolume definiálásához használható paramétereket tartalmazza.

Név	Értelmezés	Elérhető érték	Kötelező	Alapértelmezett érték
volumeAttributes.resourceGroup	Adjon meg egy Azure-erőforráscsoportnevet.	myResourceGroup	Nem	Ha üres, az illesztőprogram ugyanazt az erőforráscsoportnevet használja, mint az aktuális fürt.
volumeAttributes.storageAccount	Adjon meg egy meglévő Azure Storage-fióknevet.	storageAccountName	Igen
volumeAttributes.shareName	Adja meg az Azure-fájlmegosztás nevét.	fileShareName	Igen
volumeAttributes.folderName	Adjon meg egy mappanevet az Azure-fájlmegosztásban.	folderName	Nem	Ha a mappanév nem létezik a fájlmegosztásban, a csatlakoztatás sikertelen lesz.
volumeAttributes.protocol	Adja meg a fájlmegosztási protokollt.	`smb`, `nfs`	Nem	`smb`
volumeAttributes.server	Az Azure Storage-fiók kiszolgálói címének megadása	Meglévő kiszolgáló címe, például `accountname.privatelink.file.core.windows.net`.	Nem	Ha üres, az illesztőprogram alapértelmezett `accountname.file.core.windows.net` vagy más szuverén felhőfiók-címet használ.
---	A következő paraméterek csak az SMB protokollhoz tartoznak	---	---	---
volumeAttributes.secretName	Adjon meg egy titkos nevet, amely tárolja a tárfiók nevét és kulcsát.		Nem
volumeAttributes.secretNamespace	Adjon meg egy titkos névteret.	`default`stb`kube-system`.	Nem	PVC-névtér (`csi.storage.k8s.io/pvc/namespace`)
nodeStageSecretRef.name	Adjon meg egy titkos nevet, amely tárolja a tárfiók nevét és kulcsát.	Meglévő titkos kódnév	Igen
nodeStageSecretRef.namespace	Adjon meg egy titkos névteret.	Kubernetes-névtér	Igen
---	A következő paraméterek csak az NFS protokollhoz tartoznak	---	---	---
volumeAttributes.fsGroupChangePolicy	Azt jelzi, hogy az illesztőprogram hogyan módosítja a kötet tulajdonjogát. A pod `securityContext.fsGroupChangePolicy` figyelmen kívül lesz hagyva.	`OnRootMismatch` (alapértelmezett), `Always`, `None`	Nem	`OnRootMismatch`
volumeAttributes.mountPermissions	A csatlakoztatott mappák engedélyeinek megadása. Az alapértelmezett érték: `0777`		Nem

Ahhoz, hogy Egy Azure Files-fájlmegosztást Kubernetes-kötetként használhasson, létre kell hoznia egy Azure Storage-fiókot és a fájlmegosztást.

Kérje le az erőforráscsoport nevét a az aks show paraméterrel rendelkező --query nodeResourceGroup paranccsal.
```
az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv
```
A parancs kimenete a következő példához hasonlít:
```
MC_myResourceGroup_myAKSCluster_eastus
```
Hozzon létre egy tárfiókot a az storage account create paraméterrel rendelkező --sku paranccsal. Az alábbi parancs létrehoz egy tárfiókot az Standard_LRS SKU használatával. Mindenképpen cserélje le a következő helyőrzőket:
- myAKSStorageAccount a tárfiók nevével
- nodeResourceGroupName az AKS-fürtcsomópontok által üzemeltetett erőforráscsoport nevével
- location a régió nevével, amelyben létre kívánja hozni az erőforrást. Ennek az AKS-fürtcsomópontokkal megegyező régiónak kell lennie.
```
az storage account create -n myAKSStorageAccount -g nodeResourceGroupName -l location --sku Standard_LRS
```
Exportálja a kapcsolati sztring környezeti változóként az alábbi paranccsal, amelyet a fájlmegosztás létrehozásához használ.
```
export AZURE_STORAGE_CONNECTION_STRING=$(az storage account show-connection-string -n storageAccountName -g resourceGroupName -o tsv)
```
Hozza létre a fájlmegosztást a az storage share create paranccsal. Ügyeljen arra, hogy lecserélje shareName a megosztás nevére.
```
az storage share create -n shareName --connection-string $AZURE_STORAGE_CONNECTION_STRING
```

Exportálja a tárfiókkulcsot környezeti változóként az alábbi paranccsal.

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

Az alábbi paranccsal adja vissza a tárfiók nevét és kulcsát. Másolja ki ezeket az adatokat, mivel ezekre az értékekre szüksége van a Kubernetes-kötet létrehozásakor.
```
echo Storage account key: $STORAGE_KEY
```

Kubernetes-titkos kód létrehozása

A Kubernetesnek hitelesítő adatokra van szüksége az előző lépésben létrehozott fájlmegosztás eléréséhez. Ezek a hitelesítő adatok egy Kubernetes-titkos kódban vannak tárolva, amelyre egy Kubernetes-pod létrehozásakor hivatkozunk.

Hozza létre a titkos kulcsot a kubectl create secret paranccsal. Az alábbi példa létrehoz egy azure-secret nevű titkos kulcsot, és feltölti az azurestorageaccountname és az azurestorageaccountkey nevet az előző lépésből. Meglévő Azure Storage-fiók használatához adja meg a fiók nevét és kulcsát.
```
kubectl create secret generic azure-secret --from-literal=azurestorageaccountname=myAKSStorageAccount --from-literal=azurestorageaccountkey=$STORAGE_KEY
```

Hozzon létre egy új, elnevezett azurefiles-pv.yaml fájlt, és másolja a következő tartalomba. Alatt csi, frissítés resourceGroup, volumeHandleés shareName. Csatlakoztatási beállítások esetén az alapértelmezett érték fileModedirModea 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

Hozza létre az állandó kötetet a kubectl create paranccsal.
```
kubectl create -f azurefiles-pv.yaml
```

Hozzon létre egy azurefiles-mount-options-pvc.yaml nevű új fájlt, és másolja a következő tartalmat.

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

Hozza létre a PersistentVolumeClaim kubectl apply parancsot.
```
kubectl apply -f azurefiles-mount-options-pvc.yaml
```
Ellenőrizze, hogy létrejön-e a PersistentVolumeClaim, és a parancs használatával kubectl get a PersistentVolume-hoz van-e kötve.
```
kubectl get pvc azurefile
```
A parancs kimenete a következő példához hasonlít:
```
NAME        STATUS   VOLUME      CAPACITY   ACCESS MODES   STORAGECLASS   AGE
azurefile   Bound    azurefile   5Gi        RWX            azurefile      5s
```
Frissítse a tároló specifikációját, hogy hivatkozzon a PersistentVolumeClaim-ra és a podra a YAML-fájlban. Példa:
```
...
  volumes:
  - name: azure
    persistentVolumeClaim:
      claimName: azurefile
```
A pod specifikációja nem frissíthető a helyén, ezért törölje a podot a kubectl delete paranccsal, és hozza létre újra a kubectl apply parancs használatával.
```
kubectl delete pod mypod

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

Feljegyzés

A teljesítményproblémák elkerülése érdekében javasoljuk, hogy használjon állandó kötetet beágyazott kötet helyett, ha több pod is hozzáfér ugyanahhoz a fájlmegosztáshoz. A beágyazott kötet csak a pod névterében fér hozzá a titkos kulcsokhoz. Egy másik titkos névtér megadásához használjon állandó kötetet.

Ha csatlakoztatni szeretné az Azure Files-fájlmegosztást a podhoz, konfigurálja a kötetet a tároló specifikációjában.

Hozzon létre egy új, elnevezett azure-files-pod.yaml fájlt, és másolja a következő tartalomba. Ha módosította a fájlmegosztás vagy titkos kód nevét, frissítse az és secretNamea shareName . Azt is módosíthatja mountPath, hogy melyik elérési úton csatlakozik a Fájlmegosztás a podhoz. Windows Server-tárolók esetén adja meg mountPath a Windows elérési út konvencióját, például a "D:"-t.

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

Hozza létre a podot a kubectl apply paranccsal.
```
kubectl apply -f azure-files-pod.yaml
```
Most már rendelkezik egy futó podgal, amelyen egy Azure Files-fájlmegosztás van csatlakoztatva az /mnt/azure címen. A parancs használatával kubectl describe ellenőrizheti, hogy a megosztás sikeresen csatlakoztatva van-e.
```
kubectl describe pod mypod
```

Következő lépések

Az Azure Files CSI-illesztő paramétereit lásd a CSI-illesztőprogram paramétereiben.

A kapcsolódó ajánlott eljárásokért tekintse meg az ajánlott tárolási és biztonsági mentési eljárásokat az AKS-ben.