Bereitstellen von Azure NetApp Files-NFS-Volumes in Azure Kubernetes Service

Artikel
08/02/2024

Nachdem Sie Azure NetApp Files für Azure Kubernetes Service konfiguriert haben, können Sie Azure NetApp Files-Volumes für Azure Kubernetes Service bereitstellen.

Azure NetApp Files unterstützt Volumes unter Verwendung von NFS (NFSv3 oder NFSv4.1), SMB oder Dual-Protokoll (NFSv3 and SMB oder NFSv4.1 and SMB).

In diesem Artikel werden Details zur statischen oder dynamischen Bereitstellung von NFS-Volumes beschrieben.
Informationen zum statischen oder dynamischen Bereitstellen von SMB-Volumes finden Sie unter Bereitstellen von Azure NetApp Files-SMB-Volumes für Azure Kubernetes Service.
Informationen zum statischen Bereitstellen von Dual-Protokoll-Volumes finden Sie unter Bereitstellen von Azure NetApp Files-Dual-Protokoll-Volumes für Azure Kubernetes Service.

Statisches Konfigurieren für Anwendungen, die NFS-Volumes verwenden

In diesem Abschnitt wird beschrieben, wie Sie ein NFS-Volume auf Azure NetApp Files erstellen und das Volume statisch für Kubernetes verfügbar machen. Außerdem wird beschrieben, wie das Volume mit einer containerisierten Anwendung verwendet wird.

Erstellen eines NFS-Volumes

Definieren Sie Variablen zur späteren Verwendung. Ersetzen Sie myresourcegroup, mylocation, myaccountname, mypool1, premium, myfilepath, myvolsize, myvolname, vnetid und anfSubnetID durch einen entsprechenden Wert aus Ihrem Konto und Ihrer Umgebung. Der Dateipfad muss innerhalb aller ANF-Konten eindeutig sein.

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"

Erstellen Sie mithilfe des Befehls az netappfiles volume create ein Volume. Weitere Informationen finden Sie unter Erstellen eines NFS-Volumes für Azure NetApp Files.

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

Erstellen des persistenten Volumes

Listen Sie die Details Ihres Volumes mithilfe des Befehls az netappfiles volume show auf. Ersetzen Sie die Variablen durch geeignete Werte aus Ihrem Azure NetApp Files-Konto und Ihrer Umgebung, sofern sie nicht in einem vorherigen Schritt definiert wurden.
```
az netappfiles volume show \
    --resource-group $RESOURCE_GROUP \
    --account-name $ANF_ACCOUNT_NAME \
    --pool-name $POOL_NAME \
    --volume-name "$VOLUME_NAME -o JSON
```
Die folgende Ausgabe ist ein Beispiel für den obigen Befehl, der mit echten Werten ausgeführt wird.
```
{
  ...
  "creationToken": "myfilepath2",
  ...
  "mountTargets": [
    {
      ...
      "ipAddress": "10.0.0.4",
      ...
    }
  ],
  ...
}
```
Erstellen Sie eine Datei namens „pv-nfs.yaml“, und fügen Sie den folgenden YAML-Code ein. Stellen Sie sicher, dass der Server mit der AUSGABE-IP-Adresse aus Schritt 1 und der Pfad mit der Ausgabe von creationToken oben übereinstimmt. Die Kapazität muss auch mit der Volumegröße aus dem obigen Schritt übereinstimmen.
```
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
```
Erstellen Sie das persistente Volume mit dem Befehl kubectl apply:
```
kubectl apply -f pv-nfs.yaml
```
Überprüfen Sie mithilfe des Befehls kubectl describe, ob der Status des persistenten Volumes Verfügbar ist:
```
kubectl describe pv pv-nfs
```

Erstellen eines Anspruchs auf ein persistentes Volume

Erstellen Sie eine Datei namens „pvc-nfs.yaml“, und fügen Sie den folgenden YAML-Code ein. Mit diesem Manifest wird einen PVC mit dem Namen pvc-nfs für den Speicher- und ReadWriteMany-Zugriffsmodus 100Gi erstellt, der dem von Ihnen erstellten PV entspricht.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi
```
Erstellen Sie den Anspruch des persistenten Volumes mit dem Befehl kubectl apply:
```
kubectl apply -f pvc-nfs.yaml
```
Überprüfen Sie, ob der Status des Anspruchs auf persistentes Volume Gebunden ist, indem Sie den Befehl kubectl describe verwenden:
```
kubectl describe pvc pvc-nfs
```

Einbinden mit einem Pod

Erstellen Sie eine Datei namens „nginx-nfs.yaml“, und fügen Sie den folgenden YAML-Code ein. Mit diesem Manifest wird ein nginx-Pod definiert, der den Anspruch auf persistentes Volume verwendet.

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

Planen Sie den Pod mit dem Befehl kubectl apply:
```
kubectl apply -f nginx-nfs.yaml
```
Überprüfen Sie, ob der Pod ausgeführt wird, indem Sie den Befehl kubectl describe verwenden:
```
kubectl describe pod nginx-nfs
```
Stellen Sie sicher, dass Ihr Volume in den Pod eingebunden wurde, indem Sie kubectl exec verwenden, um eine Verbindung mit dem Pod herzustellen, und überprüfen Sie dann mit df -h, ob das Volume eingebunden ist.
```
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
...
```

Dynamisches Konfigurieren für Anwendungen, die NFS-Volumes verwenden

Astra Trident kann verwendet werden, um NFS- oder SMB-Dateien auf Azure NetApp Files dynamisch bereitzustellen. Dynamisch bereitgestellte SMB-Volumes werden nur mit Windows-Workerknoten unterstützt.

In diesem Abschnitt wird beschrieben, wie Sie mit Astra Trident ein NFS-Volume dynamisch auf Azure NetApp Files erstellen und es automatisch in eine containerisierte Anwendung einbinden.

Installieren von Astra Trident

Um NFS-Volumes dynamisch bereitstellen zu können, müssen Sie Astra Trident installieren. Astra Trident ist der dynamische Speicherbereitstellungsdienst von NetApp, der speziell für Kubernetes entwickelt wurde. Vereinfachen Sie die Speichernutzung für Kubernetes-Anwendungen mithilfe von CSI-Treibern (Container Storage Interface) von Astra Trident nach Industriestandard. Astra Trident wird in Kubernetes-Clustern als Pods bereitgestellt und bietet dynamische Speicherorchestrierungsdienste für Ihre Kubernetes-Workloads.

Trident kann mit dem Trident-Operator (manuell oder mit Helm) oder mit tridentctl installiert werden. Weitere Informationen zu diesen Installationsmethoden und deren Funktionsweise finden Sie im Astra Trident-Installationsleitfaden.

Installieren von Astra Trident mithilfe von Helm

Helm muss auf Ihrer Arbeitsstation installiert sein, damit Sie Astra Trident mit dieser Methode installieren können. Weitere Methoden zum Installieren von Astra Trident finden Sie im Astra Trident-Installationsleitfaden.

Führen Sie die folgenden Befehle aus, um Astra Trident mit Helm für einen Cluster nur mit Linux-Workerknoten zu installieren:

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

Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:

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

Führen Sie den folgenden Befehl kubectl describe aus, um zu überprüfen, ob Astra Trident erfolgreich installiert wurde:

kubectl describe torc trident

Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:

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

Erstellen eines Back-Ends

Um Astra Trident über das Azure NetApp Files-Abonnement und den Ort zu informieren, an dem Volumes erstellt werden müssen, wird ein Back-End erstellt. Für diesen Schritt sind Details zum Konto erforderlich, das in einem vorherigen Schritt erstellt wurde.

Erstellen Sie eine Datei namens „backend-secret.yaml“, und fügen Sie den folgenden YAML-Code ein. Ändern Sie die Werte Client ID und clientSecret in die richtigen Werte für Ihre Umgebung.

apiVersion: v1
kind: Secret
metadata:
  name: backend-tbc-anf-secret
type: Opaque
stringData:
  clientID: abcde356-bf8e-fake-c111-abcde35613aa
  clientSecret: rR0rUmWXfNioN1KhtHisiSAnoTherboGuskey6pU

Erstellen Sie eine Datei namens „backend-anf.yaml“, und fügen Sie den folgenden YAML-Code ein. Ändern Sie die Werte subscriptionID, tenantID, location und serviceLevel in die richtigen Werte für Ihre Umgebung. Verwenden Sie subscriptionID für das Azure-Abonnement, in dem Azure NetApp Files aktiviert ist. Rufen Sie tenantID, clientID und clientSecret aus einer Anwendungsregistrierung in Microsoft Entra ID mit ausreichenden Berechtigungen für den Azure NetApp Files-Dienst ab. Die Anwendungsregistrierung umfasst die von Azure vordefinierte Rolle „Besitzer“ oder „Mitwirkender“. Der Speicherort muss ein Azure-Speicherort sein, der mindestens ein delegiertes Subnetz enthält, das in einem vorherigen Schritt erstellt wurde. Der serviceLevel muss mit dem serviceLevel für den Kapazitätspool konfigurierten in Konfigurieren von Azure NetApp Files für AKS-Workloads übereinstimmen.
```
apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-tbc-anf
spec:
  version: 1
  storageDriverName: azure-netapp-files
  subscriptionID: 12abc678-4774-fake-a1b2-a7abcde39312
  tenantID: a7abcde3-edc1-fake-b111-a7abcde356cf
  location: eastus
  serviceLevel: Premium
  credentials:
    name: backend-tbc-anf-secret
```
Weitere Informationen zu Back-Ends finden Sie unter Azure NetApp Files Back-End-Konfigurationsoptionen und Beispiele.
Wenden Sie das Geheimnis und das Back-End mithilfe des Befehls kubectl apply an. Wenden Sie zunächst das Geheimnis an:
```
kubectl apply -f backend-secret.yaml -n trident
```
Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:
```
secret/backend-tbc-anf-secret created
```
Wenden Sie das Back-End an:
```
kubectl apply -f backend-anf.yaml -n trident
```
Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:
```
tridentbackendconfig.trident.netapp.io/backend-tbc-anf created
```
Vergewissern Sie sich, dass das Back-End erstellt wurde, indem Sie den Befehl kubectl get verwenden:
```
 kubectl get tridentbackends -n trident
```
Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:
```
NAME        BACKEND               BACKEND UUID
tbe-kfrdh   backend-tbc-anf   8da4e926-9dd4-4a40-8d6a-375aab28c566
```

Erstellen einer Speicherklasse

Mit einer Speicherklasse wird festgelegt, wie eine Speichereinheit dynamisch in einem persistenten Volume erstellt wird. Um Azure NetApp Files-Volumes zu nutzen, muss eine Speicherklasse erstellt werden.

Erstellen Sie eine Datei namens anf-storageclass.yaml, und fügen Sie den folgenden YAML-Code ein:

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

Verwenden Sie den Befehl kubectl apply, um die Speicherklasse zu erstellen:
```
kubectl apply -f anf-storageclass.yaml
```
Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:
```
storageclass/azure-netapp-files created
```

Mit dem Befehl kubectl get können Sie den Status der Speicherklasse anzeigen:

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

Erstellen eines PVC

Ein Anspruch auf persistente Volumes (Persistent Volume Claim, PVC) ist eine von einem Benutzer gestellte Anforderung an Speicher. Nach der Erstellung eines Anspruchs für ein persistentes Volume erstellt Astra Trident automatisch ein Azure NetApp Files-Volume und macht es für Kubernetes-Workloads verfügbar.

Erstellen Sie eine Datei namens „anf-pvc.yaml“, und fügen Sie den folgenden YAML-Code ein. In diesem Beispiel wird ein 1-TiB-Volume mit ReadWriteMany-Zugriff erstellt.

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

Erstellen Sie den Anspruch des persistenten Volumes mit dem Befehl kubectl apply:
```
kubectl apply -f anf-pvc.yaml
```
Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:
```
persistentvolumeclaim/anf-pvc created
```

Um Informationen zum Anspruch für ein persistentes Volume anzuzeigen, führen Sie den Befehl kubectl get aus:

kubectl get pvc

Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:

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

Verwenden des persistenten Volumes

Nachdem das PVC erstellt wurde, erstellt Astra Trident das persistente Volume. Ein Pod kann für das Einbinden des Azure NetApp Files-Volumes und den Zugriff darauf gestartet werden.

Mithilfe des folgenden Manifests kann ein NGINX-Pod definiert werden, der das im vorherigen Schritt erstellte Azure NetApp Files-Volume einbindet. In diesem Beispiel wird das Volume unter /mnt/data eingebunden.

Erstellen Sie eine Datei namens anf-nginx-pod.yaml, und fügen Sie den folgenden YAML-Code ein:

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

Planen Sie den Pod mit dem Befehl kubectl apply:

kubectl apply -f anf-nginx-pod.yaml

Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:

pod/nginx-pod created

Kubernetes hat einen Pod mit dem eingebundenen Volume erstellt, auf das im Container nginx unter /mnt/data zugegriffen werden kann. Sie können dies bestätigen, indem Sie die Ereignisprotokolle für den Pod mithilfe des Befehls kubectl describe überprüfen:

kubectl describe pod nginx-pod

Die Ausgabe des Befehls sieht in etwa wie im folgenden Beispiel aus:

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

Nächste Schritte

Astra Trident unterstützt zahlreiche Features für Azure NetApp Files. Weitere Informationen finden Sie unter

Freigeben über

Bereitstellen von Azure NetApp Files-NFS-Volumes in Azure Kubernetes Service

Statisches Konfigurieren für Anwendungen, die NFS-Volumes verwenden

Erstellen eines NFS-Volumes

Erstellen des persistenten Volumes

Erstellen eines Anspruchs auf ein persistentes Volume

Einbinden mit einem Pod

Dynamisches Konfigurieren für Anwendungen, die NFS-Volumes verwenden

Installieren von Astra Trident

Installieren von Astra Trident mithilfe von Helm

Erstellen eines Back-Ends

Erstellen einer Speicherklasse

Erstellen eines PVC

Verwenden des persistenten Volumes

Nächste Schritte

Zusätzliche Ressourcen