Utilizzo del driver CSI SMB per accedere al volume SMB sui nodi di Windows Server

Standard

Questa pagina fornisce un esempio di come utilizzare il Driver CSI SMB per Kubernetes open source per accedere a un servizio NetApp Cloud Volumes su un cluster Google Kubernetes Engine (GKE) con nodi server Windows.

Panoramica

Il protocollo SMB (Server Message Block) è un protocollo di condivisione di file di rete utilizzato per Microsoft Windows. Per utilizzare SMB con cluster GKE che utilizzano pool di nodi Windows Server, puoi utilizzare il driver CSI open source per Kubernetes.

Attività

Le sezioni seguenti illustrano un esempio di come accedere a un volume SMB del servizio NetApp Cloud Volumes su un cluster GKE con nodi Windows Server. L'esempio utilizza il Driver CSI PMI per Kubernetes open source.

Esegui il deployment di Active Directory

Questa attività crea una directory attiva. Se disponi già di Active Directory da utilizzare, puoi saltare questa attività.

Per eseguire il deployment di una Active Directory autogestita, le seguenti istruzioni utilizzano una soluzione Google Cloud Marketplace per creare un nuovo dominio Active Directory, con due controller di dominio Active Directory.

Nella console Google Cloud, vai alla pagina di Cloud Marketplace Microsoft Active Directory.
Fai clic su Launch .
Completa la configurazione del deployment. Assicurati che il server DNS si trovi nella stessa regione del volume SMB del servizio NetApp Cloud Volumes. Controlla la disponibilità per regione.
Fai clic su Esegui il deployment.

Se vuoi utilizzare Managed Service for Microsoft Active Directory (Managed Microsoft AD), completa i passaggi seguenti:

Crea un dominio Microsoft AD gestito.
Configura il peering di dominio tra il dominio e la rete del servizio NetApp Cloud Volumes.
Per eseguire le attività correlate ad Active Directory, connettiti al dominio.

Crea una zona di forwarding DNS privata

Crea una zona di forwarding DNS privata che inoltra le query DNS ai controller di dominio Active Directory.

Aggiorna la regola firewall

Per consentire alle query di Cloud DNS di raggiungere la connessione AD, nella regola firewall del tuo AD, aggiungi 35.199.192.0/19 come intervallo IP di origine al Filtro di origine.

Per ulteriori informazioni, vedi Considerazioni sulla sicurezza per l'accesso SMB del servizio Cloud Volumes.

Crea una connessione Active Directory al servizio Cloud Volumes

Per le istruzioni, consulta Creazione di una connessione AD.

Crea un volume SMB nel servizio Cloud Volumes

Per istruzioni, consulta la sezione Creazione di un volume SMB.

Usa la destinazione di montaggio del nuovo volume SMB come valore source nel tuo PersistentVolume o StorageClass, specificato nel formato seguente:

"//SMB_SERVER_NAME/SHARE_NAME"

I target e le istruzioni di montaggio sono disponibili nella pagina di elenco dei volumi del servizio Cloud Volumes e nelle singole pagine dei dettagli del volume.

Crea un cluster con nodi aggiunti al dominio AD

Segui le istruzioni riportate in Configurare i nodi Windows Server per l'aggiunta automatica a un dominio Active Directory.

Installa il driver CSI per SMB

Installa il driver CSI open source per le PMI per Kubernetes.
Per accedere a un volume SMB da un pod, crea un Secret che codifica il nome utente e la password.
```
kubectl create secret generic SECRET_NAME \
    --from-literal username="USERNAME" \
    --from-literal password="PASSWORD"
```
Sostituisci quanto segue:
- SECRET_NAME: il nome del tuo secret.
- USERNAME: il nome utente. Il nome utente codificato nel secret deve includere un nome di dominio e avere il seguente formato: domain\$username. Se la condivisione SMB non fa parte di alcun dominio, il dominio può essere una stringa qualsiasi.
- PASSWORD: la password dell'utente.

Accedere al volume SMB

Per accedere al volume SMB, puoi scegliere di utilizzare una delle seguenti opzioni:

StorageClass
PersistentVolume

Utilizzo di un oggetto StorageClass per accedere al volume SMB

Per accedere al volume SMB tramite un StorageClass, esegui queste operazioni:

Crea un StorageClass. Di seguito è riportato un esempio di file manifest denominato sc-smb.yaml:
```
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: smb
provisioner: smb.csi.k8s.io
parameters:
  source: "//SMB_SERVER_NAME/SHARE_NAME"
  csi.storage.k8s.io/node-stage-secret-name: "SECRET_NAME"
  csi.storage.k8s.io/node-stage-secret-namespace: "default"
  createSubDir: "false"    # optional: create a sub dir for new volume
reclaimPolicy: Retain      # only Retain is supported
volumeBindingMode: Immediate
mountOptions:
  - dir_mode=0777
  - file_mode=0777
  - uid=1001
  - gid=1001
```
In questo esempio utilizziamo il campo mountOptions, che è facoltativo per Windows Server, ma rende questo StorageClass adatto sia per Linux che Windows Server.

Sostituisci quanto segue:
- SMB_SERVER_NAME: il nome host del server SMB, incluso il dominio. Ad esempio, il nome host per il percorso di montaggio //adserver-faab.cvssmb.com/eager-hungry-skossi è adserver-faab.cvssmb.com.
- SHARE_NAME: il nome della condivisione SMB. Ad esempio, il nome della condivisione per il percorso di montaggio //adserver-faab.cvssmb.com/eager-hungry-skossi è eager-hungry-skossi. Utilizza la condivisione root solo per una condivisione SMB. Per i dettagli, consulta il Problema noto correlato.
- SECRET_NAME: il nome del secret contiene le credenziali per accedere al volume SMB.
Crea la risorsa StorageClass in base al file manifest:
```
kubectl create -f sc-smb.yaml
```

Esegui il deployment di un pod che utilizza StorageClass. Di seguito è riportato un esempio di file manifest denominato statefulset-smb.yaml. Il pod di cui è stato eseguito il deployment per StatefulSet crea un file data.txt nell'unità SMB montata:

apiVersion: v1
kind: Service
metadata:
  name: busybox
  labels:
    app: busybox
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: busybox
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: statefulset-smb
  labels:
    app: busybox
spec:
  serviceName: statefulset-smb
  replicas: 1
  template:
    metadata:
      labels:
        app: busybox
    spec:
      nodeSelector:
        "kubernetes.io/os": windows
      containers:
        - name: statefulset-smb
          image: e2eteam/busybox:1.29
          command:
            - "powershell.exe"
            - "-Command"
            - "while (1) { Add-Content -Encoding Ascii C:\\sc\\smb\\data.txt $(Get-Date -Format u); sleep 1 }"
          volumeMounts:
            - name: smb
              mountPath: "/sc/smb"
      tolerations:
        - key: "node.kubernetes.io/os"
          operator: "Exists"
          effect: "NoSchedule"
  updateStrategy:
    type: RollingUpdate
  selector:
    matchLabels:
      app: busybox
  volumeClaimTemplates:
    - metadata:
        name: smb
        annotations:
          volume.beta.kubernetes.io/storage-class: smb
      spec:
        accessModes: ["ReadWriteMany"]
        resources:
          requests:
            storage: 10Gi

Crea la risorsa StatefulSet in base al file manifest:
```
kubectl create -f statefulset-smb.yaml
```

Usa un PersistentVolume e un PersistentVolumeClaim per accedere al volume

Per accedere al volume SMB tramite un PersistentVolume e un PersistentVolumeClaim, esegui queste attività:

Crea un PersistentVolume. Di seguito è riportato un esempio di file manifest denominato pv-smb.yaml:
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-smb
spec:
  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: VOLUME_ID
    volumeAttributes:
      source: "//SMB_SERVER_NAME/SHARE_NAME"
    nodeStageSecretRef:
      name: SECRET_NAME
      namespace: default
```
In questo esempio utilizziamo il campo mountOptions, che è facoltativo per Windows Server, ma rende questo PersistentVolume adatto sia per Linux che Windows Server.

Sostituisci quanto segue:
- VOLUME_ID: un ID univoco del volume.
- SMB_SERVER_NAME: il nome host del server SMB, incluso il dominio.
- SHARE_NAME: il nome della condivisione SMB.
- SECRET_NAME: il nome del secret che contiene la credenziale per accedere al volume SMB.
Crea una risorsa PersistentVolume basata sul file manifest:
```
kubectl create -f pv-smb.yaml
```

Crea un PersistentVolumeClaim. Di seguito è riportato un esempio di file manifest denominato pvc-smb.yaml:

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

Crea una risorsa PersistentVolumeClaim basata sul file manifest:
```
kubectl create -f pvc-smb.yaml
```

Esegui il deployment di un pod che utilizza PersistentVolumeClaim. Ecco un file manifest di esempio denominato busybox-smb.yaml per un deployment di pod che utilizza pvc-smb. Questo deployment crea un file data.txt nell'unità SMB montata:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: busybox-smb
  labels:
    app: busybox
spec:
  replicas: 1
  template:
    metadata:
      name: busybox
      labels:
        app: busybox
    spec:
      nodeSelector:
        "kubernetes.io/os": windows
      containers:
        - name: busybox
          image: e2eteam/busybox:1.29
          command:
            - "powershell.exe"
            - "-Command"
            - "while (1) { Add-Content -Encoding Ascii C:\\pv\\pv-smb\\data.txt $(Get-Date -Format u); sleep 1 }"
          volumeMounts:
            - name: smb
              mountPath: "/pv/pv-smb"
      tolerations:
        - key: "node.kubernetes.io/os"
          operator: "Exists"
          effect: "NoSchedule"
      volumes:
        - name: smb
          persistentVolumeClaim:
            claimName: pvc-smb
  selector:
    matchLabels:
      app: busybox

Crea un Deployment dal file manifest:
```
kubectl apply -f  busybox-smb.yaml
```

Verifica l'accesso al volume SMB

Per verificare di poter accedere al file data.txt nel volume SMB, esegui una delle seguenti attività:

Avvia una sessione di PowerShell nel container ed elenca il file data.txt:
```
kubectl exec POD_NAME -- powershell.exe -c "ls PATH_TO_THE_FILE"
```
Apri l'unità SMB in un'altra VM per confermare che il file data.txt sia stato creato correttamente nella condivisione remota.

Problemi noti

Errore di montaggio su Windows dopo il riavvio

Problema: ad esempio, se \\smb-server\share\test1 è già montato, potresti ricevere un errore durante il montaggio del volume \\smb-server\share\test2 dopo il riavvio del nodo Windows.

Motivo: il campo source sia per StorageClass sia per PersistentVolume deve utilizzare la condivisione root solo per un server SMB in un cluster. Inoltre, devi utilizzare la proprietà volumeMounts.subPath nel deployment.

Soluzione: utilizza solo \\smb-server\share come source.

Per problemi più noti, consulta la pagina Problemi noti del driver CSI open source SMB per Kubernetes.

Passaggi successivi

Scopri come implementare un'applicazione Windows.
Scopri di più sul servizio NetApp Cloud Volumes.