Share via

Azure NetApp Files NFS-volumes inrichten voor Azure Kubernetes Service

  • Artikel

Nadat u Azure NetApp Files voor Azure Kubernetes Service hebt geconfigureerd, kunt u Azure NetApp Files-volumes inrichten voor Azure Kubernetes Service.

Azure NetApp Files ondersteunt volumes met NFS (NFSv3 of NFSv4.1), SMB of dual-protocol (NFSv3 en SMB, of NFSv4.1 en SMB).

Statisch configureren voor toepassingen die gebruikmaken van NFS-volumes

In deze sectie wordt beschreven hoe u een NFS-volume in Azure NetApp Files maakt en het volume statisch beschikbaar maakt voor Kubernetes. Ook wordt beschreven hoe u het volume gebruikt met een containertoepassing.

Een NFS-volume maken

  1. Definieer variabelen voor later gebruik. Vervang myresourcegroup, mylocation, myaccountname, mypool1, premium, myfilepath, myvolsize, myvolname, vnetid en anfSubnetID door een juiste waarde uit uw account en omgeving. Het bestandspad moet uniek zijn binnen alle ANF-accounts.

    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. Maak een volume met behulp van de az netappfiles volume create opdracht. Zie Een NFS-volume maken voor Azure NetApp Files voor meer informatie.

    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

Het permanente volume maken

  1. Geef de details van uw volume weer met behulp van az netappfiles volume show de opdracht. Vervang de variabelen door de juiste waarden uit uw Azure NetApp Files-account en -omgeving als deze niet zijn gedefinieerd in een vorige stap.

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

    De volgende uitvoer is een voorbeeld van de bovenstaande opdracht die wordt uitgevoerd met echte waarden.

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

  2. Maak een bestand met de naam pv-nfs.yaml en kopieer dit in de volgende YAML. Zorg ervoor dat de server overeenkomt met het uitvoer-IP-adres van stap 1 en dat het pad overeenkomt met de bovenstaande uitvoer creationToken . De capaciteit moet ook overeenkomen met de volumegrootte uit de bovenstaande stap.

    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. Maak het permanente volume met behulp van de kubectl apply opdracht:

    kubectl apply -f pv-nfs.yaml

  4. Controleer of de status van het permanente volume beschikbaar is met behulp van de kubectl describe opdracht:

    kubectl describe pv pv-nfs

Een permanente volumeclaim maken

  1. Maak een bestand met de naam pvc-nfs.yaml en kopieer dit in de volgende YAML. Dit manifest maakt een PVC met de naam pvc-nfs 100Gi-opslag en ReadWriteMany toegangsmodus, die overeenkomt met de PV die u hebt gemaakt.

    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-nfs
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi

  2. Maak de permanente volumeclaim met behulp van de kubectl apply opdracht:

    kubectl apply -f pvc-nfs.yaml

  3. Controleer of de status van de permanente volumeclaim afhankelijk is met behulp van de kubectl describe opdracht:

    kubectl describe pvc pvc-nfs

Koppelen met een pod

  1. Maak een bestand met de naam nginx-nfs.yaml en kopieer dit in de volgende YAML. Dit manifest definieert een nginx pod die gebruikmaakt van de permanente volumeclaim.

    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. Maak de pod met behulp van de kubectl apply opdracht:

    kubectl apply -f nginx-nfs.yaml

  3. Controleer of de pod wordt uitgevoerd met behulp van de kubectl describe opdracht:

    kubectl describe pod nginx-nfs

  4. Controleer of het volume op de pod is gekoppeld door verbinding kubectl exec te maken met de pod en vervolgens te gebruiken df -h om te controleren of het volume is gekoppeld.

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

Dynamisch configureren voor toepassingen die gebruikmaken van NFS-volumes

Astra Trident kan worden gebruikt voor het dynamisch inrichten van NFS- of SMB-bestanden in Azure NetApp Files. Dynamisch ingerichte SMB-volumes worden alleen ondersteund met Windows-werkknooppunten.

In deze sectie wordt beschreven hoe u Astra Trident gebruikt om dynamisch een NFS-volume te maken in Azure NetApp Files en deze automatisch te koppelen aan een containertoepassing.

Astra Trident installeren

Als u NFS-volumes dynamisch wilt inrichten, moet u Astra Trident installeren. Astra Trident is de dynamische opslaginrichting van NetApp die speciaal is gebouwd voor Kubernetes. Vereenvoudig het verbruik van opslag voor Kubernetes-toepassingen met behulp van het CSI-stuurprogramma (Industry Standard Container Storage Interface) van Astra Trident. Astra Trident implementeert op Kubernetes-clusters als pods en biedt dynamische opslagindelingsservices voor uw Kubernetes-workloads.

Trident kan worden geïnstalleerd met behulp van de Trident-operator (handmatig of met helm) of tridentctl. Zie de installatiehandleiding van Astra Trident voor meer informatie over deze installatiemethoden en hoe ze werken.

Astra Trident installeren met Helm

Helm moet op uw werkstation zijn geïnstalleerd om Astra Trident te installeren met behulp van deze methode. Zie de Astra Trident Install Guide voor andere methoden voor het installeren van Astra Trident.

  1. Als u Astra Trident wilt installeren met behulp van Helm voor een cluster met alleen Linux-werkknooppunten, voert u de volgende opdrachten uit:

    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

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

    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. Voer de volgende kubectl describe opdracht uit om te bevestigen dat Astra Trident is geïnstalleerd:

    kubectl describe torc trident

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

    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

Een back-end maken

Als u Astra Trident wilt instrueren over het Azure NetApp Files-abonnement en waar het volumes moet maken, wordt er een back-end gemaakt. Voor deze stap zijn details vereist over het account dat in een vorige stap is gemaakt.

  1. Maak een bestand met de naam backend-secret.yaml en kopieer dit in de volgende YAML. Wijzig de Client ID en clientSecret de juiste waarden voor uw omgeving.

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

  2. Maak een bestand met de naam backend-anf.yaml en kopieer dit in de volgende YAML. Wijzig de subscriptionID, tenantIDen locationserviceLevel de juiste waarden voor uw omgeving. Gebruik het subscriptionID azure-abonnement waarvoor Azure NetApp Files is ingeschakeld. Haal de tenantID, clientIDen clientSecret van een toepassingsregistratie in Microsoft Entra ID op met voldoende machtigingen voor de Azure NetApp Files-service. De toepassingsregistratie bevat de rol Eigenaar of Inzender die vooraf is gedefinieerd door Azure. De locatie moet een Azure-locatie zijn die ten minste één gedelegeerd subnet bevat dat in een vorige stap is gemaakt. De serviceLevel moet overeenkomen met de serviceLevel geconfigureerde voor de capaciteitspool in Azure NetApp Files configureren voor AKS-workloads.

    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

    Zie de configuratieopties en voorbeelden voor back-end van Azure NetApp Files voor meer informatie over back-ends.

  3. Pas het geheim en de back-end toe met behulp van de kubectl apply opdracht. Pas eerst het geheim toe:

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

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

    secret/backend-tbc-anf-secret created

    De back-end toepassen:

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

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

    tridentbackendconfig.trident.netapp.io/backend-tbc-anf created

  4. Bevestig dat de back-end is gemaakt met behulp van de kubectl get opdracht:

     kubectl get tridentbackends -n trident

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

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

Een opslagklasse maken

Een opslagklasse wordt gebruikt om te definiëren hoe een opslageenheid dynamisch wordt gemaakt met een permanent volume. Als u Azure NetApp Files-volumes wilt gebruiken, moet er een opslagklasse worden gemaakt.

  1. Maak een bestand met de naam anf-storageclass.yaml en kopieer in de volgende YAML:

    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. Maak de opslagklasse met behulp van de kubectl apply opdracht:

    kubectl apply -f anf-storageclass.yaml

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

    storageclass/azure-netapp-files created

  3. Voer de kubectl get opdracht uit om de status van de opslagklasse weer te geven:

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

Een PVC maken

Een permanente volumeclaim (PVC) is een aanvraag voor opslag door een gebruiker. Na het maken van een permanente volumeclaim maakt Astra Trident automatisch een Azure NetApp Files-volume en maakt het beschikbaar voor Kubernetes-workloads die moeten worden gebruikt.

  1. Maak een bestand met de naam anf-pvc.yaml en kopieer dit in de volgende YAML. In dit voorbeeld is een 1 TiB-volume nodig met ReadWriteMany-toegang.

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

  2. Maak de permanente volumeclaim met de kubectl apply opdracht:

    kubectl apply -f anf-pvc.yaml

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

    persistentvolumeclaim/anf-pvc created

  3. Als u informatie over de permanente volumeclaim wilt weergeven, voert u de kubectl get opdracht uit:

    kubectl get pvc

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

    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

Het permanente volume gebruiken

Nadat het PVC is gemaakt, maakt Astra Trident het permanente volume. Een pod kan worden gesponnen om het Azure NetApp Files-volume te koppelen en te openen.

Het volgende manifest kan worden gebruikt om een NGINX-pod te definiëren die het Azure NetApp Files-volume koppelt dat in de vorige stap is gemaakt. In dit voorbeeld wordt het volume gekoppeld aan /mnt/data.

  1. Maak een bestand met de naam anf-nginx-pod.yaml en kopieer in de volgende YAML:

    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. Maak de pod met behulp van de kubectl apply opdracht:

    kubectl apply -f anf-nginx-pod.yaml

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

    pod/nginx-pod created

    Kubernetes heeft een pod gemaakt waarop het volume is gekoppeld en toegankelijk is binnen de nginx container op /mnt/data. U kunt dit bevestigen door de gebeurtenislogboeken voor de pod te controleren met behulp van kubectl describe de opdracht:

    kubectl describe pod nginx-pod

    De uitvoer van de opdracht lijkt op het volgende voorbeeld:

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

Volgende stappen

Astra Trident ondersteunt veel functies met Azure NetApp Files. Zie voor meer informatie: