Azure NetApp Files NFS-kötetek kiépítése az Azure Kubernetes Service-hez

Cikk
11/01/2024

Miután konfigurálta az Azure NetApp Filest az Azure Kubernetes Service-hez, kiépítheti az Azure NetApp Files-köteteket az Azure Kubernetes Service-hez.

Az Azure NetApp Files támogatja az NFS -t (NFSv3 vagy NFSv4.1), SMB-t vagy kettős protokollt (NFSv3 és SMB, vagy NFSv4.1 és SMB) használó köteteket.

Ez a cikk az NFS-kötetek statikus vagy dinamikus kiépítésének részleteit ismerteti.
További információ az SMB-kötetek statikus vagy dinamikus kiépítéséről: Azure NetApp Files SMB-kötetek üzembe helyezése az Azure Kubernetes Service-hez.
A kétprotokollos kötetek statikus kiépítéséről további információt az Azure NetApp Files kétprotokollos köteteinek üzembe helyezése az Azure Kubernetes Service-hez című témakörben talál .

Statikus konfigurálás NFS-köteteket használó alkalmazásokhoz

Ez a szakasz azt ismerteti, hogyan hozhat létre NFS-kötetet az Azure NetApp Filesban, és hogyan teheti elérhetővé statikusan a kötetet a Kubernetes számára. Azt is ismerteti, hogyan használhatja a kötetet tárolóalapú alkalmazásokkal.

NFS-kötet létrehozása

Változók definiálása későbbi használathoz. Cserélje le a myresourcegroup, a mylocation, a myaccountname, a mypool1, a premium, a myfilepath, a myvolsize, a myvolname, a vnetid és az anfSubnetID értéket a fiókból és a környezetből származó megfelelő értékre. A fájlútnak egyedinek kell lennie az összes ANF-fiókban.
```
RESOURCE_GROUP="myresourcegroup"
LOCATION="mylocation"
ANF_ACCOUNT_NAME="myaccountname"
POOL_NAME="mypool1"
SERVICE_LEVEL="premium" # Valid values are Standard, Premium, and Ultra
UNIQUE_FILE_PATH="myfilepath"
VOLUME_SIZE_GIB="myvolsize"
VOLUME_NAME="myvolname"
VNET_ID="vnetId"
SUBNET_ID="anfSubnetId"
```

Hozzon létre egy kötetet a az netappfiles volume create paranccsal. További információ: NFS-kötet létrehozása az Azure NetApp Fileshoz.

az netappfiles volume create \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --account-name $ANF_ACCOUNT_NAME \
    --pool-name $POOL_NAME \
    --name "$VOLUME_NAME" \
    --service-level $SERVICE_LEVEL \
    --vnet $VNET_ID \
    --subnet $SUBNET_ID \
    --usage-threshold $VOLUME_SIZE_GIB \
    --file-path $UNIQUE_FILE_PATH \
    --protocol-types NFSv3

Az állandó kötet létrehozása

A parancs használatával az netappfiles volume show listázhatja a kötet részleteit. Cserélje le a változókat az Azure NetApp Files-fiók és -környezet megfelelő értékeire, ha az előző lépésben nincs definiálva.

az netappfiles volume show \
    --resource-group $RESOURCE_GROUP \
    --account-name $ANF_ACCOUNT_NAME \
    --pool-name $POOL_NAME \
    --volume-name "$VOLUME_NAME -o JSON

Az alábbi kimenet egy példa a fenti, valós értékekkel végrehajtott parancsra.

{
  ...
  "creationToken": "myfilepath2",
  ...
  "mountTargets": [
    {
      ...
      "ipAddress": "10.0.0.4",
      ...
    }
  ],
  ...
}

Hozzon létre egy fájlt, pv-nfs.yaml és másolja a következő YAML-fájlba. Győződjön meg arról, hogy a kiszolgáló megfelel az 1. lépés kimeneti IP-címének, és az elérési út megegyezik a fenti kimenettel creationToken . A kapacitásnak a fenti lépésben megadott kötetméretnek is meg kell egyeznie.
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-nfs
spec:
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  mountOptions:
    - vers=3
  nfs:
    server: 10.0.0.4
    path: /myfilepath2
```
Hozza létre az állandó kötetet a kubectl apply következő paranccsal:
```
kubectl apply -f pv-nfs.yaml
```
Ellenőrizze, hogy az állandó kötet állapota elérhető-e a kubectl describe következő paranccsal:
```
kubectl describe pv pv-nfs
```

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

Hozzon létre egy fájlt, pvc-nfs.yaml és másolja a következő YAML-fájlba. Ez a jegyzék egy 100Gi tárolási és ReadWriteMany hozzáférési módhoz tartozó pvc-nfs PVC-t hoz létre, amely megfelel a létrehozott PV-nek.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi
```
Hozza létre az állandó kötet jogcímét a kubectl apply következő paranccsal:
```
kubectl apply -f pvc-nfs.yaml
```
Ellenőrizze, hogy az állandó mennyiségi jogcím állapota kötött-e a kubectl describe következő paranccsal:
```
kubectl describe pvc pvc-nfs
```

Csatlakoztatás podtal

Hozzon létre egy fájlt, nginx-nfs.yaml és másolja a következő YAML-fájlba. Ez a jegyzék egy podot nginx határoz meg, amely az állandó mennyiségi jogcímet használja.

kind: Pod
apiVersion: v1
metadata:
  name: nginx-nfs
spec:
  containers:
  - image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
    name: nginx-nfs
    command:
    - "/bin/sh"
    - "-c"
    - while true; do echo $(date) >> /mnt/azure/outfile; sleep 1; done
    volumeMounts:
    - name: disk01
      mountPath: /mnt/azure
  volumes:
  - name: disk01
    persistentVolumeClaim:
      claimName: pvc-nfs

Hozza létre a podot a kubectl apply következő paranccsal:
```
kubectl apply -f nginx-nfs.yaml
```
Ellenőrizze, hogy a pod fut-e a kubectl describe következő paranccsal:
```
kubectl describe pod nginx-nfs
```
Ellenőrizze, hogy a kötet csatlakoztatva van-e a podhoz kubectl exec a podhoz való csatlakozáshoz, majd annak df -h ellenőrzéséhez, hogy a kötet csatlakoztatva van-e.
```
kubectl exec -it nginx-nfs -- sh
```
```
/ # df -h
Filesystem             Size  Used Avail Use% Mounted on
...
10.0.0.4:/myfilepath2  100T  384K  100T   1% /mnt/azure
...
```

Dinamikus konfigurálás NFS-köteteket használó alkalmazásokhoz

Az Astra Trident használható NFS- vagy SMB-fájlok dinamikus kiépítésére az Azure NetApp Filesban. A dinamikusan kiépített SMB-kötetek csak a Windows-feldolgozó csomópontok esetében támogatottak.

Ez a szakasz azt ismerteti, hogyan hozhat létre dinamikusan NFS-kötetet az Azure NetApp Filesban az Astra Trident használatával, és hogyan csatlakoztathatja automatikusan egy tárolóalapú alkalmazáshoz.

Az Astra Trident telepítése

Az NFS-kötetek dinamikus kiépítéséhez telepítenie kell az Astra Tridentet. Az Astra Trident a NetApp dinamikus tárolókiépítési szolgáltatása, amely a Kubernetes számára készült. A Kubernetes-alkalmazások tárolási használatának egyszerűsítése az Astra Trident iparági szabványnak megfelelő Tárolótároló-illesztő (CSI) illesztőprogramjával. Az Astra Trident podként települ a Kubernetes-fürtökön, és dinamikus tárolási vezénylési szolgáltatásokat nyújt a Kubernetes-számítási feladatokhoz.

A Trident a Trident operátorral (manuálisan vagy Helm használatával) vagy tridentctl. Ha többet szeretne megtudni ezekről a telepítési módszerekről és azok működéséről, tekintse meg az Astra Trident telepítési útmutatóját.

Az Astra Trident telepítése a Helm használatával

Az Astra Trident ezzel a módszerrel történő telepítéséhez telepíteni kell a Helmt a munkaállomásra. Az Astra Trident telepítésének egyéb módszereit az Astra Trident telepítési útmutatójában találja.

Ha az Astra Tridentet a Helm használatával szeretné telepíteni egy olyan fürthöz, amely csak Linux-feldolgozó csomópontokkal rendelkezik, futtassa a következő parancsokat:

helm repo add netapp-trident https://netapp.github.io/trident-helm-chart   
helm install trident netapp-trident/trident-operator --version 23.04.0  --create-namespace --namespace trident

A parancs kimenete a következő példához hasonlít:

NAME: trident
LAST DEPLOYED: Fri May  5 13:55:36 2023
NAMESPACE: trident
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
Thank you for installing trident-operator, which will deploy and manage NetApp's Trident CSI storage provisioner for Kubernetes.

Your release is named 'trident' and is installed into the 'trident' namespace.
Please note that there must be only one instance of Trident (and trident-operator) in a Kubernetes cluster.

To configure Trident to manage storage resources, you will need a copy of tridentctl, which is available in pre-packaged Trident releases.  You may find all Trident releases and source code online at https://github.com/NetApp/trident. 

To learn more about the release, try:

    $ helm status trident
      $ helm get all trident

Az Astra Trident sikeres telepítésének megerősítéséhez futtassa a következő kubectl describe parancsot:

kubectl describe torc trident

A parancs kimenete a következő példához hasonlít:

Name:         trident
Namespace:    
Labels:       app.kubernetes.io/managed-by=Helm
Annotations:  meta.helm.sh/release-name: trident
              meta.helm.sh/release-namespace: trident
API Version:  trident.netapp.io/v1
Kind:         TridentOrchestrator
Metadata:
    ...
Spec:
  IPv6:                  false
  Autosupport Image:     docker.io/netapp/trident-autosupport:23.04
  Autosupport Proxy:     <nil>
  Disable Audit Log:     true
  Enable Force Detach:   false
  Http Request Timeout:  90s
  Image Pull Policy:     IfNotPresent
  k8sTimeout:            0
  Kubelet Dir:           <nil>
  Log Format:            text
  Log Layers:            <nil>
  Log Workflows:         <nil>
  Namespace:             trident
  Probe Port:            17546
  Silence Autosupport:   false
  Trident Image:         docker.io/netapp/trident:23.04.0
  Windows:               false
Status:
  Current Installation Params:
    IPv6:                       false
    Autosupport Hostname:       
    Autosupport Image:          docker.io/netapp/trident-autosupport:23.04
    Autosupport Proxy:          
    Autosupport Serial Number:  
    Debug:                      false
    Disable Audit Log:          true
    Enable Force Detach:        false
    Http Request Timeout:       90s
    Image Pull Policy:          IfNotPresent
    Image Pull Secrets:
    Image Registry:       
    k8sTimeout:           30
    Kubelet Dir:          /var/lib/kubelet
    Log Format:           text
    Log Layers:           
    Log Level:            info
    Log Workflows:        
    Probe Port:           17546
    Silence Autosupport:  false
    Trident Image:        docker.io/netapp/trident:23.04.0
  Message:                Trident installed
  Namespace:              trident
  Status:                 Installed
  Version:                v23.04.0
Events:
  Type    Reason      Age    From                        Message
  ----    ------      ----   ----                        -------
  Normal  Installing  2m59s  trident-operator.netapp.io  Installing Trident
  Normal  Installed   2m31s  trident-operator.netapp.io  Trident installed

Háttérrendszer létrehozása

Ha az Astra Tridentet az Azure NetApp Files-előfizetésről szeretné meghívni, és hol kell köteteket létrehoznia, létrejön egy háttérrendszer. Ehhez a lépéshez az előző lépésben létrehozott fiók adataira van szükség.

Hozzon létre egy fájlt, backend-secret.yaml és másolja a következő YAML-fájlba. Módosítsa a Client ID clientSecret környezet megfelelő értékeit.

apiVersion: v1
kind: Secret
metadata:
  name: backend-tbc-anf-secret
type: Opaque
stringData:
  clientID: 00001111-aaaa-2222-bbbb-3333cccc4444
  clientSecret: rR0rUmWXfNioN1KhtHisiSAnoTherboGuskey6pU

Hozzon létre egy fájlt, backend-anf.yaml és másolja a következő YAML-fájlba. Módosítsa a subscriptionID, tenantID, locationés serviceLevel a környezet megfelelő értékeit. Használja azt az subscriptionID Azure-előfizetést, amelyben engedélyezve van az Azure NetApp Files. Szerezze be a tenantID, clientID, és clientSecret egy alkalmazásregisztrációból a Microsoft Entra ID-ban az Azure NetApp Files szolgáltatáshoz szükséges engedélyekkel. Az alkalmazásregisztráció tartalmazza az Azure által előre definiált tulajdonosi vagy közreműködői szerepkört. A helynek olyan Azure-helynek kell lennie, amely legalább egy, az előző lépésben létrehozott delegált alhálózatot tartalmaz. A serviceLevel kapacitáskészlethez konfiguráltnak kell lennie serviceLevel az Azure NetApp Files AKS-számítási feladatokhoz való konfigurálásához.
```
apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-tbc-anf
spec:
  version: 1
  storageDriverName: azure-netapp-files
  subscriptionID: aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e
  tenantID: aaaabbbb-0000-cccc-1111-dddd2222eeee
  location: eastus
  serviceLevel: Premium
  credentials:
    name: backend-tbc-anf-secret
```
A háttérrendszerekkel kapcsolatos további információkért tekintse meg az Azure NetApp Files háttérrendszer konfigurációs beállításait és példáit.
Alkalmazza a titkos kulcsot és a háttérrendszert a kubectl apply parancs használatával. Először alkalmazza a titkos kódot:
```
kubectl apply -f backend-secret.yaml -n trident
```
A parancs kimenete a következő példához hasonlít:
```
secret/backend-tbc-anf-secret created
```
A háttérrendszer alkalmazása:
```
kubectl apply -f backend-anf.yaml -n trident
```
A parancs kimenete a következő példához hasonlít:
```
tridentbackendconfig.trident.netapp.io/backend-tbc-anf created
```

Ellenőrizze, hogy a háttérrendszer a következő paranccsal lett-e kubectl get létrehozva:

 kubectl get tridentbackends -n trident

A parancs kimenete a következő példához hasonlít:

NAME        BACKEND               BACKEND UUID
tbe-kfrdh   backend-tbc-anf   8da4e926-9dd4-4a40-8d6a-375aab28c566

Tárosztály létrehozása

A tárolóosztályok határozzák meg, hogyan jön létre dinamikusan egy tárolóegység egy állandó kötettel. Az Azure NetApp Files-kötetek használatához létre kell hozni egy tárolási osztályt.

Hozzon létre egy fájlt, anf-storageclass.yaml és másolja a következő YAML-ben:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azure-netapp-files
provisioner: csi.trident.netapp.io
parameters:
  backendType: "azure-netapp-files"
  fsType: "nfs"

Hozza létre a tárosztályt a kubectl apply következő paranccsal:
```
kubectl apply -f anf-storageclass.yaml
```
A parancs kimenete a következő példához hasonlít:
```
storageclass/azure-netapp-files created
```

Futtassa a kubectl get parancsot a tárolási osztály állapotának megtekintéséhez:

kubectl get sc
NAME                 PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
azure-netapp-files   csi.trident.netapp.io   Delete          Immediate           false

PVC létrehozása

Az állandó kötetkérelmek (PVC) a felhasználó tárolási kérése. Egy állandó mennyiségi jogcím létrehozásakor az Astra Trident automatikusan létrehoz egy Azure NetApp Files-kötetet, és elérhetővé teszi a Kubernetes számítási feladatai számára.

Hozzon létre egy fájlt, anf-pvc.yaml és másolja a következő YAML-fájlba. Ebben a példában egy 1 TiB-os kötetre van szükség a ReadWriteMany-hozzáféréssel.

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: anf-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1Ti
  storageClassName: azure-netapp-files

Hozza létre az állandó kötet jogcímét a kubectl apply következő paranccsal:
```
kubectl apply -f anf-pvc.yaml
```
A parancs kimenete a következő példához hasonlít:
```
persistentvolumeclaim/anf-pvc created
```

Az állandó kötet jogcímével kapcsolatos információk megtekintéséhez futtassa a kubectl get következő parancsot:

kubectl get pvc

A parancs kimenete a következő példához hasonlít:

kubectl get pvc -n trident
NAME      STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS         AGE
anf-pvc   Bound    pvc-bffa315d-3f44-4770-86eb-c922f567a075   1Ti        RWO            azure-netapp-files   62s

Az állandó kötet használata

A PVC létrehozása után az Astra Trident létrehozza az állandó kötetet. A podokat fel lehet pörögni az Azure NetApp Files-kötet csatlakoztatásához és eléréséhez.

Az alábbi jegyzék egy olyan NGINX-pod definiálására használható, amely csatlakoztatja az előző lépésben létrehozott Azure NetApp Files-kötetet. Ebben a példában a kötet a következőre van csatlakoztatva /mnt/data: .

Hozzon létre egy fájlt, anf-nginx-pod.yaml és másolja a következő YAML-ben:

kind: Pod
apiVersion: v1
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx
    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/data"
      name: volume
  volumes:
    - name: volume
      persistentVolumeClaim:
        claimName: anf-pvc

Hozza létre a podot a kubectl apply következő paranccsal:

kubectl apply -f anf-nginx-pod.yaml

A parancs kimenete a következő példához hasonlít:

pod/nginx-pod created

A Kubernetes létrehozott egy podot, amelyen a kötet csatlakoztatva van, és elérhető a tárolóban a nginx következő helyen /mnt/data: . A pod kubectl describe eseménynaplóinak ellenőrzésével a következő paranccsal erősítheti meg a megerősítést:

kubectl describe pod nginx-pod

A parancs kimenete a következő példához hasonlít:

[...]
Volumes:
  volume:
    Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:  anf-pvc
    ReadOnly:   false
  default-token-k7952:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-k7952
    Optional:    false
[...]
Events:
  Type    Reason                  Age   From                     Message
  ----    ------                  ----  ----                     -------
  Normal  Scheduled               15s   default-scheduler        Successfully assigned trident/nginx-pod to brameshb-non-root-test
  Normal  SuccessfulAttachVolume  15s   attachdetach-controller  AttachVolume.Attach succeeded for volume "pvc-bffa315d-3f44-4770-86eb-c922f567a075"
  Normal  Pulled                  12s   kubelet                  Container image "mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine" already present on machine
  Normal  Created                 11s   kubelet                  Created container nginx
  Normal  Started                 10s   kubelet                  Started container nginx

Következő lépések

Az Astra Trident számos funkciót támogat az Azure NetApp Filesban. További információk:

Megosztás a következőn keresztül:

Azure NetApp Files NFS-kötetek kiépítése az Azure Kubernetes Service-hez

Statikus konfigurálás NFS-köteteket használó alkalmazásokhoz

NFS-kötet létrehozása

Az állandó kötet létrehozása

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

Csatlakoztatás podtal

Dinamikus konfigurálás NFS-köteteket használó alkalmazásokhoz

Az Astra Trident telepítése

Az Astra Trident telepítése a Helm használatával

Háttérrendszer létrehozása

Tárosztály létrehozása

PVC létrehozása

Az állandó kötet használata

Következő lépések

További források