Eseguire il provisioning dei volumi SMB di Azure NetApp Files per servizio Azure Kubernetes

Dopo aver configurato Azure NetApp Files per il servizio Azure Kubernetes, è possibile eseguire il provisioning di volumi Azure NetApp Files per il servizio Azure Kubernetes.

Azure NetApp Files supporta volumi che usano NFS (NFSv3 o NFSv4.1), SMB e dual-protocol (NFSv3 e SMB o NFSv4.1 e SMB).

Configurazione in modo statico per le applicazioni che usano volumi SMB

Questa sezione descrive come creare un volume SMB in Azure NetApp Files ed esporre il volume in modo statico a Kubernetes per un'applicazione in contenitori da utilizzare.

Creare un volume SMB

  1. Definire le variabili per un uso successivo. Sostituire myresourcegroup, mylocation, myaccountname, mypool1, premium , myfilepath, myvolsize, myvolname e virtnetid con un valore appropriato per l'ambiente. Il percorso file deve essere univoco all'interno di tutti gli account 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. Creare un volume tramite il comando az netappfiles volume create.

    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 CIFS

Creare un segreto con le credenziali di dominio

  1. Creare un segreto nel cluster AKS per accedere al server Active Directory (AD) usando il comando kubectl create secret. Questo segreto verrà usato dal volume permanente Kubernetes per accedere al volume SMB Azure NetApp Files. Usare il comando seguito per creare il segreto, sostituendo USERNAME con il nome utente, PASSWORD con la password e DOMAIN_NAME con il nome di dominio per il dominio dell'Active Directory.

        kubectl create secret generic smbcreds --from-literal=username=USERNAME --from-literal=password="PASSWORD" --from-literal=domain='DOMAIN_NAME'

  2. Controllare che il segreto sia stato effettivamente creato.

       kubectl get secret
   NAME       TYPE     DATA   AGE
   smbcreds   Opaque   2      20h

Installare un driver CSI SMB

È necessario installare un driver CSI (Container Storage Interface) per creare un PersistentVolume SMB Kubernetes.

  1. Installare il driver CSI SMB nel cluster usando Helm. Verificare di impostare l'opzione windows.enabled su true:

    helm repo add csi-driver-smb https://raw.githubusercontent.com/kubernetes-csi/csi-driver-smb/master/charts   
helm install csi-driver-smb csi-driver-smb/csi-driver-smb --namespace kube-system --version v1.13.0 --set windows.enabled=true

    Per altri metodi di installazione del driver CSI SMB, vedere Installare la versione master del driver CSI SMB in un cluster Kubernetes.

  2. Verificare che il pod controller csi-smb sia in esecuzione e che ogni nodo di lavoro abbia un pod in esecuzione usando il comando kubectl get pods:

    kubectl get pods -n kube-system | grep csi-smb

csi-smb-controller-68df7b4758-xf2m9   3/3     Running   0          3m46s
csi-smb-node-s6clj                    3/3     Running   0          3m47s
csi-smb-node-win-tfxvk                3/3     Running   0          3m47s

Creare il volume permanente

  1. Elenca i dettagli del tuo volume utilizzando az netappfiles volume show. Sostituire le variabili con i valori appropriati dell'account e dell'ambiente Azure NetApp Files se non definiti in un passaggio precedente.

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

    L'output seguente è un esempio del comando precedente eseguito con valori reali.

    {
  ...
  "creationToken": "myvolname",
  ...
  "mountTargets": [
    {
      ...
      "
         "smbServerFqdn": "ANF-1be3.contoso.com",
      ...
    }
  ],
  ...
}

  2. Creare un file denominato pv-smb.yaml e copiarlo nel codice YAML seguente. Se necessario, sostituire myvolname con creationToken e sostituire ANF-1be3.contoso.com\myvolname con il valore di smbServerFqdn del passaggio precedente. Assicurarsi di includere i segreti delle credenziali di Active Directory insieme allo spazio dei nomi in cui si trova il segreto creato in un passaggio precedente.

    apiVersion: v1
kind: PersistentVolume
metadata:
  name: anf-pv-smb
spec:
  storageClassName: ""
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  mountOptions:
    - dir_mode=0777
    - file_mode=0777
    - vers=3.0
  csi:
    driver: smb.csi.k8s.io
    readOnly: false
    volumeHandle: myvolname  # make sure it's a unique name in the cluster
    volumeAttributes:
      source: \\ANF-1be3.contoso.com\myvolname
    nodeStageSecretRef:
      name: smbcreds
      namespace: default

  3. Creare il volume permanente usando il comando kubectl apply:

    kubectl apply -f pv-smb.yaml

  4. Verificare che lo stato del volume permanente sia Disponibile usando il comando kubectl describe:

    kubectl describe pv pv-smb

Creare una richiesta di volume persistente

  1. Creare un file denominato pvc-smb.yaml e copiarvi il codice YAML seguente.

    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: anf-pvc-smb
spec:
  accessModes:
    - ReadWriteMany
  volumeName: anf-pv-smb
  storageClassName: ""
  resources:
    requests:
      storage: 100Gi

  2. Creare l'attestazione di volume permanente usando il comando kubectl apply:

    kubectl apply -f pvc-smb.yaml

    Verificare che lo stato del Persistent Volume Claim sia Bound usando il comando kubectl describe:

    kubectl describe pvc pvc-smb

Eseguire il montaggio con un pod

  1. Creare un file denominato iis-smb.yaml e copiarlo nel codice YAML seguente. Questo file verrà usato per creare un pod di Internet Information Services per montare il volume nel percorso /inetpub/wwwroot.

    apiVersion: v1
kind: Pod 
metadata:
  name: iis-pod
  labels:
     app: web
spec:
  nodeSelector:
    "kubernetes.io/os": windows
  volumes:
  - name: smb
    persistentVolumeClaim:
      claimName: anf-pvc-smb 
  containers:
  - name: web
    image: mcr.microsoft.com/windows/servercore/iis:windowsservercore 
    resources:
      limits:
        cpu: 1
        memory: 800M
    ports:
      - containerPort: 80
    volumeMounts:
    - name: smb
      mountPath: "/inetpub/wwwroot"
      readOnly: false

  2. Creare il pod con il comando kubectl apply:

    kubectl apply -f iis-smb.yaml

  3. Verificare che il pod sia nello stato Running e che l'elemento /inetpub/wwwroot sia montato tramite SMB usando il comando kubectl describe:

    kubectl describe pod iis-pod

    L'output del comando è simile all'esempio seguente:

    Name:         iis-pod
Namespace:    default
Priority:     0
Node:         akswin000001/10.225.5.246
Start Time:   Fri, 05 May 2023 09:34:41 -0400
Labels:       app=web
Annotations:  <none>
Status:       Running
IP:           10.225.5.248
IPs:
  IP:  10.225.5.248
Containers:
  web:
    Container ID:   containerd://39a1659b6a2b6db298df630237b2b7d959d1b1722edc81ce9b1bc7f06237850c
    Image:          mcr.microsoft.com/windows/servercore/iis:windowsservercore
    Image ID:       mcr.microsoft.com/windows/servercore/iis@sha256:0f0114d0f6c6ee569e1494953efdecb76465998df5eba951dc760ac5812c7409
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 05 May 2023 09:34:55 -0400
    Ready:          True
    Restart Count:  0
    Limits:
      cpu:     1
      memory:  800M
    Requests:
      cpu:        1
      memory:     800M
    Environment:  <none>
    Mounts:
      /inetpub/wwwroot from smb (rw)
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-mbnv8 (ro)
...

  4. Verificare che il volume sia stato montato nel pod usando il comando kubectl exec per connettersi al pod, quindi usare il comando dir nella directory corretta per verificare se il volume è montato e le dimensioni corrispondono alle dimensioni del volume di cui è stato effettuato il provisioning.

    kubectl exec -it iis-pod –- cmd.exe

    L'output del comando è simile all'esempio seguente:

    Microsoft Windows [Version 10.0.20348.1668]
(c) Microsoft Corporation. All rights reserved.

C:\>cd /inetpub/wwwroot

C:\inetpub\wwwroot>dir
 Volume in drive C has no label.
 Volume Serial Number is 86BB-AA55

 Directory of C:\inetpub\wwwroot

05/04/2023  08:15 PM    <DIR>          .
05/04/2023  08:15 PM    <DIR>          ..
           0 File(s)              0 bytes
           2 Dir(s)  107,373,838,336 bytes free

Configurazione in modo dinamico per le applicazioni che usano volumi SMB

Questa sezione illustra come usare Trident per creare dinamicamente un volume SMB in Azure NetApp Files e montarlo automaticamente in un'applicazione Windows in contenitori.

Installare Trident

Per effettuare il provisioning dinamico dei volumi SMB, è necessario installare Trident versione 22.10 o successiva. Il provisioning dinamico dei volumi SMB richiede nodi di lavoro Windows.

Trident è il provisioner di archiviazione dinamico di NetApp creato appositamente per Kubernetes. Semplificare il consumo dell'archiviazione per le applicazioni Kubernetes usando il driver CSI (Container Storage Interface) standard di settore di Trident. Trident si distribuisce nei cluster Kubernetes come pod e fornisce servizi di orchestrazione di archiviazione dinamica per i carichi di lavoro Kubernetes.

Trident può essere installato usando l'operatore Trident (manualmente o tramite Helm) o tridentctl. Per altre informazioni su questi metodi di installazione e sul loro funzionamento, vedere la Guida all'installazione.

Installare Trident utilizzando Helm

Helm deve essere installato nella workstation per installare Trident usando questo metodo. Per altri metodi di installazione di Trident, vedere la Guida all'installazione di Trident. Se nel cluster sono presenti nodi di lavoro Windows, verificare di abilitare Windows con qualsiasi metodo di installazione.

  1. Per installare Trident usando Helm per un cluster con nodi di lavoro di Windows, eseguire i comandi seguenti:

    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 –-set windows=true

    L'output del comando è simile all'esempio seguente:

    NAME: trident
LAST DEPLOYED: Fri May  5 14:23:05 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. Per verificare che Trident sia stato installato correttamente, eseguire il comando seguente kubectl describe :

    kubectl describe torc trident

    L'output del comando è simile all'esempio seguente:

    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:               true
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  74s   trident-operator.netapp.io  Installing Trident
  Normal  Installed   46s   trident-operator.netapp.io  Trident installed

Creare un back-end

È necessario creare un back-end per comunicare a Trident l'abbonamento Azure NetApp Files e dove deve creare i volumi. Per altre informazioni sui back-end, vedere Azure NetApp Files opzioni di configurazione back-end ed esempi.

  1. Creare un file denominato backend-secret-smb.yaml e copiarlo nel codice YAML seguente. Modificare Client ID e clientSecret con i valori specifici del proprio ambiente.

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

  2. Creare un file denominato backend-anf-smb.yaml e copiarlo nel codice YAML seguente. Modificare ClientID, clientSecret, subscriptionID, tenantID, location e serviceLevel impostando i valori corretti per l'ambiente. Il tenantID, clientID e clientSecret è reperibile da una registrazione dell'applicazione in Microsoft Entra ID con autorizzazioni sufficienti per il servizio Azure NetApp Files. La registrazione dell'applicazione include il ruolo Proprietario o Collaboratore predefinito da Azure. La posizione Azure deve contenere almeno una subnet delegata. serviceLevel deve corrispondere a serviceLevel configurato per il pool di capacità in Configurare Azure NetApp Files per i carichi di lavoro del servizio Azure Kubernetes.

    apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-tbc-anf-smb
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
  nasType: smb

  3. Creare il segreto e il backend usando il comando kubectl apply.

    Creare il segreto :

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

    L'output del comando è simile all'esempio seguente:

    secret/backend-tbc-anf-secret created

    Creare il back-end:

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

    L'output del comando è simile all'esempio seguente:

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

  4. Verificare che il back-end sia stato creato eseguendo il comando seguente:

    kubectl get tridentbackends -n trident

    L'output del comando è simile all'esempio seguente:

    NAME        BACKEND               BACKEND UUID
tbe-9shfq   backend-tbc-anf-smb   09cc2d43-8197-475f-8356-da7707bae203

Creare un segreto con le credenziali di dominio per SMB

  1. Creare un segreto nel cluster AKS per accedere al server Active Directory utilizzando il comando kubectl create secret. Queste informazioni verranno usate dal volume permanente Kubernetes per accedere al volume SMB Azure NetApp Files. Usare il comando seguente, sostituendo DOMAIN_NAME\USERNAME con il nome di dominio e il nome utente e PASSWORD con la password.

    kubectl create secret generic smbcreds --from-literal=username=DOMAIN_NAME\USERNAME –from-literal=password="PASSWORD"

  2. Verificare che il segreto sia stato creato.

    kubectl get secret

    L'output sarà simile al seguente esempio:

    NAME       TYPE     DATA   AGE
smbcreds   Opaque   2      2h

Creare una classe di archiviazione

Una classe di archiviazione viene usata per definire la creazione dinamica di un'unità di archiviazione con un volume permanente. Per utilizzare i volumi Azure NetApp Files, è necessario creare una classe di archiviazione.

  1. Creare un file denominato anf-storageclass-smb.yaml e copiarlo nel codice YAML seguente.

    apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: anf-sc-smb
provisioner: csi.trident.netapp.io
allowVolumeExpansion: true
parameters:
  backendType: "azure-netapp-files"
  trident.netapp.io/nasType: "smb"
  csi.storage.k8s.io/node-stage-secret-name: "smbcreds"
  csi.storage.k8s.io/node-stage-secret-namespace: "default"

  2. Creare la classe di archiviazione usando il comando kubectl apply:

    kubectl apply -f anf-storageclass-smb.yaml

    L'output del comando è simile all'esempio seguente:

    storageclass/anf-sc-smb created

  3. Eseguire il comando kubectl get per visualizzare lo stato della classe di archiviazione:

    kubectl get sc anf-sc-smb
NAME         PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
anf-sc-smb   csi.trident.netapp.io   Delete          Immediate           true                   13s

Creazione di un PVC

Una persistent volume claim (PVC) è una richiesta di spazio di archiviazione da parte di un utente. Dopo la creazione di un'attestazione di volume permanente, Trident crea automaticamente una condivisione SMB Azure NetApp Files e la rende disponibile per l'utilizzo dei carichi di lavoro Kubernetes.

  1. Creare un file denominato anf-pvc-smb.yaml e copiare il seguente YAML. In questo esempio viene creato un volume da 100 GiB con accesso ReadWriteMany che usa la classe di archiviazione creata in Creare una classe di archiviazione.

    kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: anf-pvc-smb
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 100Gi
  storageClassName: anf-sc-smb

  2. Creare l'attestazione di volume permanente con il comando kubectl apply:

    kubectl apply -f anf-pvc-smb.yaml

    L'output del comando è simile all'esempio seguente:

    persistentvolumeclaim/anf-pvc-smb created

  3. Per visualizzare informazioni sull'attestazione del volume permanente, eseguire il comando kubectl get:

    kubectl get pvc

    L'output del comando è simile all'esempio seguente:

    NAME          STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
anf-pvc-smb   Bound    pvc-209268f5-c175-4a23-b61b-e34faf5b6239   100Gi      RWX            anf-sc-smb     5m38s

  4. Per visualizzare il volume permanente creato da Trident, eseguire il comando seguente kubectl get :

    kubectl get pv
NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                 STORAGECLASS   REASON   AGE
pvc-209268f5-c175-4a23-b61b-e34faf5b6239   100Gi      RWX            Delete           Bound    default/anf-pvc-smb   anf-sc-smb              5m52s

Usare il volume permanente

Dopo aver creato l'attestazione di volume persistente, è possibile attivare un pod per accedere al volume Azure NetApp Files. Il manifesto seguente può essere usato per definire un pod Internet Information Services (IIS) che monta la condivisione SMB Azure NetApp Files creata nel passaggio precedente. In questo esempio il volume viene montato in /inetpub/wwwroot.

  1. Creare un file denominato anf-iis-pod.yaml e copiarlo nel codice YAML seguente:

    apiVersion: v1
kind: Pod 
metadata:
  name: iis-pod
  labels:
     app: web
spec:
  nodeSelector:
    "kubernetes.io/os": windows
  volumes:
  - name: smb
    persistentVolumeClaim:
      claimName: anf-pvc-smb 
  containers:
  - name: web
    image: mcr.microsoft.com/windows/servercore/iis:windowsservercore 
    resources:
      limits:
        cpu: 1
        memory: 800M
    ports:
      - containerPort: 80
    volumeMounts:
    - name: smb
      mountPath: "/inetpub/wwwroot"
      readOnly: false

  2. Creare la distribuzione mediante il comando kubectl apply:

    kubectl apply -f anf-iis-deploy-pod.yaml

    L'output del comando è simile all'esempio seguente:

    pod/iis-pod created

    Verificare che il pod sia in esecuzione e montato tramite SMB su /inetpub/wwwroot usando il comando kubectl describe:

    kubectl describe pod iis-pod

    L'output del comando è simile all'esempio seguente:

    Name:         iis-pod
Namespace:    default
Priority:     0
Node:         akswin000001/10.225.5.246
Start Time:   Fri, 05 May 2023 15:16:36 -0400
Labels:       app=web
Annotations:  <none>
Status:       Running
IP:           10.225.5.252
IPs:
  IP:  10.225.5.252
Containers:
  web:
    Container ID:   containerd://1e4959f2b49e7ad842b0ec774488a6142ac9152ca380c7ba4d814ae739d5ed3e
    Image:          mcr.microsoft.com/windows/servercore/iis:windowsservercore
    Image ID:       mcr.microsoft.com/windows/servercore/iis@sha256:0f0114d0f6c6ee569e1494953efdecb76465998df5eba951dc760ac5812c7409
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 05 May 2023 15:16:44 -0400
    Ready:          True
    Restart Count:  0
    Limits:
      cpu:     1
      memory:  800M
    Requests:
      cpu:        1
      memory:     800M
    Environment:  <none>
    Mounts:
      /inetpub/wwwroot from smb (rw)
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-zznzs (ro)

  3. Verificare che il volume sia stato montato nel pod usando kubectl exec per connettersi al pod. Usare il comando dir nella directory corretta per verificare se il volume è montato e se le dimensioni corrispondono con quelle del volume di cui è stato eseguito il provisioning.

    kubectl exec -it iis-pod –- cmd.exe

    L'output del comando è simile all'esempio seguente:

    Microsoft Windows [Version 10.0.20348.1668]
(c) Microsoft Corporation. All rights reserved.

C:\>cd /inetpub/wwwroot

C:\inetpub\wwwroot>dir
 Volume in drive C has no label.
 Volume Serial Number is 86BB-AA55

 Directory of C:\inetpub\wwwroot

05/05/2023  01:38 AM    <DIR>          .
05/05/2023  01:38 AM    <DIR>          ..
           0 File(s)              0 bytes
           2 Dir(s)  107,373,862,912 bytes free

C:\inetpub\wwwroot>exit

Passaggi successivi

Trident supporta molte funzionalità con Azure NetApp Files. Per altre informazioni, vedi:

  • Last updated on