Usa el controlador CSI de SMB para acceder al volumen SMB en los nodos de Windows Server


En esta página, se proporciona un ejemplo sobre cómo usar el controlador CSI de SMB para Kubernetes de código abierto a fin de acceder a un volumen de SMB de NetApp Cloud Volumes Service en un clúster de Google Kubernetes Engine (GKE) con nodos del servidor de Windows.

Descripción general

El bloque de mensajes del servidor (SMB) es un protocolo de sistema de archivos compartidos en red para Microsoft Windows. Si quieres usar SMB con clústeres de GKE mediante grupos de nodos de Windows Server, puedes usar el código abierto del controlador CSI de SMB para Kubernetes.

Tareas

En las siguientes secciones, se muestra un ejemplo de cómo acceder a un volumen de NetApp Cloud Volumes Service de SMB en un clúster de GKE con nodos de Windows Server. En el ejemplo, se usa el controlador CSI de SMB para Kubernetes de código abierto.

Implementa Active Directory

Esta tarea crea un Active Directory. Si ya tienes un Active Directory para usar, puedes omitir esta tarea.

Para implementar un Active Directory autoadministrado, las siguientes instrucciones utilizan una solución de Google Cloud Marketplace a fin de crear un dominio nuevo de Active Directory, con dos controladores de dominio de Active Directory.

  1. En la consola de Google Cloud, ve a la página de Cloud Marketplace de Microsoft Active Directory.
  2. Haga clic en Iniciar.
  3. Completa la configuración de implementación. Asegúrate de que el servidor DNS esté en la misma región que el volumen de SMB de NetApp Cloud Volumes Service. Verifica la disponibilidad por región.
  4. Haz clic en Implementar.

Si, en cambio, deseas usar el Servicio administrado para Microsoft Active Directory (Microsoft AD administrado), completa los siguientes pasos:

  1. Cree un dominio de Managed Microsoft AD.
  2. Configura el intercambio de tráfico entre dominios entre el dominio y la red de NetApp Cloud Volumes Service.
  3. Para realizar las tareas relacionadas con Active Directory, conéctate al dominio.

Crea una zona de desvío de DNS privado

Crea una zona de reenvío de DNS privado que reenvíe las consultas de DNS a los controladores de dominio de Active Directory.

Actualiza tu regla de firewall

Para permitir que las consultas de Cloud DNS lleguen a tu conexión de AD, agrega 35.199.192.0/19 como un rango de IP de origen al Filtro de fuente en la regla de firewall de tu AD.

Si quieres obtener más información, consulta Consideraciones de seguridad para el acceso de Cloud Volumes Service a SMB.

Crear una conexión de Active Directory con Cloud Volumes Service

Para obtener instrucciones, consulta la sección sobre cómo crear una conexión de AD.

Crea un volumen SMB en Cloud Volumes Service

Para obtener instrucciones, consulta Crea un volumen SMB.

Usa el destino de activación del nuevo volumen SMB como el valor source en tu PersistentVolume o StorageClass, especificado en el siguiente formato:

"//SMB_SERVER_NAME/SHARE_NAME"

Los objetivos y las instrucciones de activación están disponibles en la página de la lista de volúmenes de Cloud Volumes Service y en las páginas de detalles de volumen individuales.

Crea un clúster con nodos unidos al dominio de AD

Sigue las instrucciones en Configura nodos de Windows Server que se unan automáticamente a un dominio de Active Directory.

Instala el controlador CSI de SMB

  1. Instala el controlador CSI de SMB para Kubernetes de código abierto.
  2. Para acceder a un volumen SMB desde un Pod, crea un Secret que codifique el nombre de usuario y la contraseña.

    kubectl create secret generic SECRET_NAME \
        --from-literal username="USERNAME" \
        --from-literal password="PASSWORD"
    

    Reemplaza lo siguiente:

    • SECRET_NAME: el nombre de tu Secret
    • USERNAME: el nombre de usuario El nombre de usuario codificado en el Secret debe incluir un nombre de dominio y tener el siguiente formato: domain\$username. Si el porcentaje de SMB no forma parte de ningún dominio, el dominio puede ser cualquier string.
    • PASSWORD: la contraseña del usuario

Accede al volumen SMB

Para acceder al volumen de SMB, puedes usar una de las siguientes opciones:

Usa una StorageClass para acceder al volumen SMB

Para acceder al volumen SMB a través de una StorageClass, realiza las siguientes tareas:

  1. Crea una StorageClass. Este es un archivo de manifiesto de muestra llamado 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
    

    En este ejemplo, usamos el campo mountOptions, que es opcional para Windows Server, pero permite que StorageClass funcione tanto en Linux como en Windows Server.

    Reemplaza lo siguiente:

    • SMB_SERVER_NAME: el nombre de host del servidor SMB, incluido el dominio Por ejemplo, el nombre de host para la ruta de activación //adserver-faab.cvssmb.com/eager-hungry-skossi es adserver-faab.cvssmb.com.
    • SHARE_NAME: el nombre del porcentaje de SMB Por ejemplo, el nombre del recurso compartido para la ruta de activación //adserver-faab.cvssmb.com/eager-hungry-skossi es eager-hungry-skossi. Solo usa el recurso compartido de raíz para un recurso compartido SMB. Para obtener más detalles, consulta el problema conocido relacionado.
    • SECRET_NAME: el nombre del Secret que contiene la credencial para acceder al volumen SMB
  2. Crea el recurso StorageClass en función del archivo de manifiesto:

    kubectl create -f sc-smb.yaml
    
  3. Implementa un Pod que consuma el StorageClass. Este es un archivo de manifiesto de muestra llamado statefulset-smb.yaml. El Pod implementado para este StatefulSet crea un archivo data.txt en la unidad de SMB activada:

    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
    
  4. Crea el recurso StatefulSet en función del archivo de manifiesto:

    kubectl create -f statefulset-smb.yaml
    

Usa un PersistentVolume y PersistentVolumeClaim para acceder al volumen

Para acceder al volumen SMB a través de un PersistentVolume y PersistentVolumeClaim, realiza las siguientes tareas:

  1. Crea una PersistentVolume. Este es un archivo de manifiesto de muestra llamado 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
    

    En este ejemplo, usamos el campo mountOptions, que es opcional para Windows Server, pero permite que PersistentVolume funcione tanto en Linux como en Windows Server.

    Reemplaza lo siguiente:

    • VOLUME_ID: un ID único para el volumen
    • SMB_SERVER_NAME: el nombre de host del servidor SMB, incluido el dominio
    • SHARE_NAME: el nombre del porcentaje de SMB
    • SECRET_NAME: el nombre del Secret que contiene la credencial para acceder al volumen SMB
  2. Crea un recurso PersistentVolume en función del archivo de manifiesto:

    kubectl create -f pv-smb.yaml
    
  3. Crea una PersistentVolumeClaim. Este es un archivo de manifiesto de muestra llamado pvc-smb.yaml:

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: pvc-smb
    spec:
      accessModes:
        - ReadWriteMany
      resources:
        requests:
          storage: 10Gi
      volumeName: pv-smb
      storageClassName: ""
    
  4. Crea un recurso PersistentVolumeClaim en función del archivo de manifiesto:

    kubectl create -f pvc-smb.yaml
    
  5. Implementa un Pod que consuma el PersistentVolumeClaim. Este es un archivo de manifiesto de muestra llamado busybox-smb.yaml para una implementación de Pod que consume pvc-smb. Esta implementación crea un archivo data.txt en la unidad SMB activada:

    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
    
  6. Crea una Deployment desde el archivo de manifiesto:

    kubectl apply -f  busybox-smb.yaml
    

Prueba el acceso al volumen SMB

Para verificar que puedas acceder al archivo data.txt en el volumen SMB, realiza una de las siguientes tareas:

  • Inicia una sesión de PowerShell en el contenedor y enumera el archivo data.txt:

    kubectl exec POD_NAME -- powershell.exe -c "ls PATH_TO_THE_FILE"
    
  • Abre la unidad SMB en otra VM para confirmar que el archivo data.txt se haya creado correctamente en el uso compartido remoto.

Problemas conocidos

Activa el error en Windows después del reinicio

Problema: Por ejemplo, si \\smb-server\share\test1 ya está activado, es posible que recibas un error cuando actives el volumen \\smb-server\share\test2 después de que se reinicie el nodo de Windows.

Motivo: El campo source de StorageClass y PersistentVolume solo debe usar el recurso compartido de raíz para un servidor SMB en un clúster. Además, debes usar la propiedad volumeMounts.subPath en la implementación.

Solución alternativa: Solo usa \\smb-server\share como source.

Si deseas obtener información sobre problemas conocidos, consulta la página Problemas conocidos del controlador de CSI de código abierto de CSI para Kubernetes.

¿Qué sigue?