Baca dalam bahasa Inggris

Bagikan melalui


Memprovisikan volume NFS Azure NetApp Files untuk Azure Kubernetes Service

Setelah mengonfigurasi Azure NetApp Files untuk Azure Kubernetes Service, Anda dapat menyediakan volume Azure NetApp Files untuk Azure Kubernetes Service.

Azure NetApp Files mendukung volume menggunakan NFS (NFSv3 atau NFSv4.1), SMB, atau protokol ganda (NFSv3 dan SMB, atau NFSv4.1 dan SMB).

Konfigurasikan secara statis untuk aplikasi yang menggunakan volume NFS

Bagian ini menjelaskan cara membuat volume NFS di Azure NetApp Files dan mengekspos volume secara statis ke Kubernetes. Ini juga menjelaskan cara menggunakan volume dengan aplikasi dalam kontainer.

Membuat volume NFS

  1. Tentukan variabel untuk penggunaan nanti. Ganti myresourcegroup, mylocation, myaccountname, mypool1, premium, myfilepath, myvolsize, myvolname, vnetid, dan anfSubnetID dengan nilai yang sesuai dari akun dan lingkungan Anda. Jalur file harus unik dalam semua akun ANF.

    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"
    
  2. Buat volume menggunakan az netappfiles volume create perintah . Untuk informasi selengkapnya, lihat Membuat volume NFS untuk 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
    

Membuat volume persisten

  1. Cantumkan detail volume Anda menggunakan az netappfiles volume show perintah . Ganti variabel dengan nilai yang sesuai dari akun dan lingkungan Azure NetApp Files Anda jika tidak ditentukan di langkah sebelumnya.

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

    Output berikut adalah contoh perintah di atas yang dijalankan dengan nilai nyata.

    {
      ...
      "creationToken": "myfilepath2",
      ...
      "mountTargets": [
        {
          ...
          "ipAddress": "10.0.0.4",
          ...
        }
      ],
      ...
    }
    
  2. Buat file bernama pv-nfs.yaml dan salin dalam YAML berikut. Pastikan server cocok dengan alamat IP output dari Langkah 1, dan jalurnya cocok dengan output dari creationToken atas. Kapasitas juga harus sesuai dengan ukuran volume dari langkah di atas.

    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
    
  3. Buat volume persisten menggunakan kubectl apply perintah :

    kubectl apply -f pv-nfs.yaml
    
  4. Verifikasi status volume persisten Tersedia dengan menggunakan kubectl describe perintah :

    kubectl describe pv pv-nfs
    

Buat klaim volume persisten

  1. Buat file bernama pvc-nfs.yaml dan salin dalam YAML berikut. Manifes ini membuat PVC bernama pvc-nfs untuk penyimpanan 100Gi dan ReadWriteMany mode akses, cocok dengan PV yang Anda buat.

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: pvc-nfs
    spec:
      accessModes:
        - ReadWriteMany
      storageClassName: ""
      resources:
        requests:
          storage: 100Gi
    
  2. Buat klaim volume persisten menggunakan kubectl apply perintah :

    kubectl apply -f pvc-nfs.yaml
    
  3. Verifikasi Status klaim volume persisten Terikat dengan menggunakan kubectl describe perintah :

    kubectl describe pvc pvc-nfs
    

Memasang dengan pod

  1. Buat file bernama nginx-nfs.yaml dan salin dalam YAML berikut. Manifes ini mendefinisikan nginx pod yang menggunakan klaim volume persisten.

    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
    
  2. Buat pod menggunakan kubectl apply perintah :

    kubectl apply -f nginx-nfs.yaml
    
  3. Verifikasi pod berjalan dengan menggunakan kubectl describe perintah :

    kubectl describe pod nginx-nfs
    
  4. Pastikan volume Anda telah dipasang pada pod dengan menggunakan kubectl exec untuk menyambungkan ke pod, lalu gunakan df -h untuk memeriksa apakah volume dipasang.

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

Konfigurasikan secara dinamis untuk aplikasi yang menggunakan volume NFS

Astra Trident dapat digunakan untuk memprovisikan file NFS atau SMB secara dinamis di Azure NetApp Files. Volume SMB yang disediakan secara dinamis hanya didukung dengan simpul pekerja windows.

Bagian ini menjelaskan cara menggunakan Astra Trident untuk membuat volume NFS secara dinamis di Azure NetApp Files dan memasangnya secara otomatis ke aplikasi kontainer.

Menginstal Astra Trident

Untuk memprovisikan volume NFS secara dinamis, Anda perlu menginstal Astra Trident. Astra Trident adalah layanan provisi penyimpanan dinamis NetApp yang dibuat khusus untuk Kube. Menyederhanakan konsumsi penyimpanan untuk aplikasi Kubernetes menggunakan driver Container Storage Interface (CSI) standar industri Astra Trident. Astra Trident disebarkan pada kluster Kubernetes sebagai pod dan menyediakan layanan orkestrasi penyimpanan dinamis untuk beban kerja Kubernetes Anda.

Trident dapat diinstal menggunakan operator Trident (secara manual atau menggunakan Helm) atau tridentctl. Untuk mempelajari selengkapnya tentang metode penginstalan ini dan cara kerjanya, lihat Panduan Penginstalan Astra Trident.

Menginstal Astra Trident menggunakan Helm

Helm harus diinstal di stasiun kerja Anda untuk menginstal Astra Trident menggunakan metode ini. Untuk metode lain menginstal Astra Trident, lihat Panduan Penginstalan Astra Trident.

  1. Untuk menginstal Astra Trident menggunakan Helm untuk kluster hanya dengan simpul pekerja Linux, jalankan perintah berikut:

    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
    

    Output perintah menyerupai contoh berikut:

    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
    
  2. Untuk mengonfirmasi bahwa Astra Trident berhasil diinstal, jalankan perintah berikut kubectl describe :

    kubectl describe torc trident
    

    Output perintah menyerupai contoh berikut:

    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
    

Membuat backend

Untuk menginstruksikan Astra Trident tentang langganan Azure NetApp Files dan tempat volume perlu dibuat, backend akan dibuat. Langkah ini memerlukan detail tentang akun yang dibuat di langkah sebelumnya.

  1. Buat file bernama backend-secret.yaml dan salin dalam YAML berikut. Client ID Ubah dan clientSecret ke nilai yang benar untuk lingkungan Anda.

    apiVersion: v1
    kind: Secret
    metadata:
      name: backend-tbc-anf-secret
    type: Opaque
    stringData:
      clientID: 00001111-aaaa-2222-bbbb-3333cccc4444
      clientSecret: rR0rUmWXfNioN1KhtHisiSAnoTherboGuskey6pU
    
  2. Buat file bernama backend-anf.yaml dan salin dalam YAML berikut. subscriptionIDUbah , , tenantIDlocation, dan serviceLevel ke nilai yang benar untuk lingkungan Anda. subscriptionID Gunakan untuk langganan Azure tempat Azure NetApp Files diaktifkan. tenantIDDapatkan , clientID, dan clientSecret dari pendaftaran aplikasi di ID Microsoft Entra dengan izin yang memadai untuk layanan Azure NetApp Files. Pendaftaran aplikasi mencakup peran Pemilik atau Kontributor yang telah ditentukan sebelumnya oleh Azure. Lokasi harus merupakan lokasi Azure yang berisi setidaknya satu subnet yang didelegasikan yang dibuat pada langkah sebelumnya. serviceLevel harus cocok dengan yang dikonfigurasi serviceLevel untuk kumpulan kapasitas di Mengonfigurasi Azure NetApp Files untuk beban kerja AKS.

    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
    

    Untuk informasi selengkapnya tentang backend, lihat Opsi dan contoh konfigurasi backend Azure NetApp Files.

  3. Terapkan rahasia dan backend menggunakan kubectl apply perintah . Pertama terapkan rahasia:

    kubectl apply -f backend-secret.yaml -n trident
    

    Output perintah menyerupai contoh berikut:

    secret/backend-tbc-anf-secret created
    

    Terapkan backend:

    kubectl apply -f backend-anf.yaml -n trident
    

    Output perintah menyerupai contoh berikut:

    tridentbackendconfig.trident.netapp.io/backend-tbc-anf created
    
  4. Konfirmasi backend dibuat dengan menggunakan kubectl get perintah :

     kubectl get tridentbackends -n trident
    

    Output perintah menyerupai contoh berikut:

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

Buat kelas penyimpanan

Kelas penyimpanan digunakan untuk menentukan bagaimana sebuah unit penyimpanan dibuat secara dinamis dengan volume persisten. Untuk menggunakan volume Azure NetApp Files, kelas penyimpanan harus dibuat.

  1. Buat file bernama anf-storageclass.yaml dan salin di YAML berikut:

    apiVersion: storage.k8s.io/v1
    kind: StorageClass
    metadata:
      name: azure-netapp-files
    provisioner: csi.trident.netapp.io
    parameters:
      backendType: "azure-netapp-files"
      fsType: "nfs"
    
  2. Buat kelas penyimpanan menggunakan kubectl apply perintah :

    kubectl apply -f anf-storageclass.yaml
    

    Output perintah menyerupai contoh berikut:

    storageclass/azure-netapp-files created
    
  3. Jalankan kubectl get perintah untuk melihat status kelas penyimpanan:

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

Membuat PVC

Klaim volume persisten (PVC) adalah permintaan penyimpanan oleh pengguna. Setelah pembuatan klaim volume persisten, Astra Trident secara otomatis membuat volume Azure NetApp Files dan membuatnya tersedia untuk dikonsumsi beban kerja Kube.

  1. Buat file bernama anf-pvc.yaml dan salin dalam YAML berikut. Dalam contoh ini, volume 1-TiB diperlukan dengan akses ReadWriteMany.

    kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
      name: anf-pvc
    spec:
      accessModes:
        - ReadWriteMany
      resources:
        requests:
          storage: 1Ti
      storageClassName: azure-netapp-files
    
  2. Buat klaim volume persisten dengan kubectl apply perintah :

    kubectl apply -f anf-pvc.yaml
    

    Output perintah menyerupai contoh berikut:

    persistentvolumeclaim/anf-pvc created
    
  3. Untuk melihat informasi tentang klaim volume persisten, jalankan kubectl get perintah :

    kubectl get pvc
    

    Output perintah menyerupai contoh berikut:

    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
    

Menggunakan volume persisten

Setelah PVC dibuat, Astra Trident membuat volume persisten. Sebuah pod dapat dipisahkan untuk memasang dan mengakses volume Azure NetApp Files.

Manifes berikut dapat digunakan untuk menentukan pod NGINX yang memasang volume Azure NetApp Files yang dibuat pada langkah sebelumnya. Dalam contoh ini, volume dipasang di /mnt/data.

  1. Buat file bernama anf-nginx-pod.yaml dan salin di YAML berikut:

    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
    
  2. Buat pod menggunakan kubectl apply perintah :

    kubectl apply -f anf-nginx-pod.yaml
    

    Output perintah menyerupai contoh berikut:

    pod/nginx-pod created
    

    Kubernetes telah membuat pod dengan volume yang dipasang dan dapat diakses dalam nginx kontainer di /mnt/data. Anda dapat mengonfirmasi dengan memeriksa log peristiwa untuk pod menggunakan kubectl describe perintah:

    kubectl describe pod nginx-pod
    

    Output perintah menyerupai contoh berikut:

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

Langkah berikutnya

Astra Trident mendukung banyak fitur dengan Azure NetApp Files. Untuk informasi selengkapnya, lihat: