Container Service for Kubernetes:Use NAS dynamically provisioned volumes

kubectl

1. Create a file named alicloud-nas-subpath.yaml that has the following content.

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     # StorageClass name. Must be unique in the cluster.
     name: alicloud-nas-subpath  
   mountOptions:
   - nolock,tcp,noresvport
   - vers=3
   parameters:
     # Set to subpath.
     volumeAs: subpath
     # Format of the server field: <nas-server-address>:/<path>
     server: "0cd8b4a576-g****.cn-hangzhou.nas.aliyuncs.com:/k8s"
     archiveOnDelete: "true"
   provisioner: nasplugin.csi.alibabacloud.com
   reclaimPolicy: Retain
   allowVolumeExpansion: true

   Parameter		Description
   mountOptions		Mount options for NAS, including the NFS protocol version. By default, NAS mounts using NFS v3. To specify another version, use vers=4.0. For supported NFS versions per NAS type, see NFS protocol.
   parameters.volumeAs		Mount mode. Set to subpath.
   parameters.server		The NAS mount target address and the subdirectory path to mount. Format: <nas-server-address>:/<path>. <nas-server-address>: The mount target address of the NAS file system. See Manage mount targets. :/<path>: The NAS subdirectory to mount. If unset or if the subdirectory does not exist, the root directory is mounted by default. General-purpose NAS: Root directory is /. Extreme NAS: Root directory is /share. When mounting a subdirectory, the path must start with /share (for example, /share/data).
   parameters.archiveOnDelete		Determines whether files and directories in the backend storage are permanently deleted when you delete a PVC. Applies only when reclaimPolicy is Delete. Because NAS is a shared storage service, a confirmation prompt is provided for this option. true (default): Files and directories are not deleted. Instead, they are archived and renamed in the format archived-{pvName}.{timestamp}. false: The corresponding directory and data in the backend are permanently deleted. This deletes only the NAS subdirectory and its contents—not the NAS file system itself. To delete a NAS file system, see Delete a file system. In scenarios with frequent creation and deletion of PVs, setting this to false may block the CSI controller task queue and prevent new PVs from being created. See CSI controller task queue is full and new PVs cannot be created when using NAS dynamically provisioned volumes.
   provisioner		The type of driver. When you use the Alibaba Cloud NAS CSI component, this parameter is fixed at nasplugin.csi.alibabacloud.com.
   reclaimPolicy		Recycling policy for the PV. Delete (default): When you delete the PVC, the system handles backend storage data according to the archiveOnDelete setting. Retain: When you delete the PVC, the PV and NAS file remain intact. You must delete them manually. Use this for high-security scenarios to prevent accidental data loss.
   allowVolumeExpansion		Supported only for General-purpose NAS Allows online expansion of PVs created by this StorageClass by modifying the PVC capacity. This StorageClass uses NAS directory quota to manage and limit PV capacity precisely. To expand online, edit the spec.resources.requests.storage field in the PVC. See Set directory quotas for NAS dynamically provisioned volumes. Applying NAS directory quotas is asynchronous. Immediately after creating or expanding a PV, high-speed, bulk writes may exceed the quota before it fully takes effect. See Limits for more details.

2. Create the StorageClass.

   kubectl create -f alicloud-nas-subpath.yaml

Console

1. Log on to the ACK console. In the left navigation pane, click Clusters.

2. On the Clusters page, click the name of the target cluster. In the navigation pane on the left, choose Volumes > StorageClasses.

3. Click Create. Enter a unique name for the StorageClass in the cluster and set Volume Type to NAS. Complete the creation of the StorageClass as prompted.

   The following table describes the main configuration items.

   Configuration item	Description
   Select mount target	The mount target address of the NAS file system.
   Volume mode	Volume access mode. In this example, select Subdirectory (subpath). The system automatically creates a subdirectory under the mount path. Data is stored under <NAS mount target>:<mount path>/<pv-name>/.
   Mount path	The subdirectory of the NAS file system to mount. If you do not set this parameter, the root directory is mounted by default. If the directory does not exist in the NAS file system, it is automatically created and mounted. General-purpose NAS file system: The root directory is /. Extreme NAS file system: The root directory is /share. When you mount a subdirectory, the path must start with /share (for example, /share/data).
   Recycling policy	Recycling policy for the PV. Delete (default): When you delete the PVC, the system handles backend storage data according to the archiveOnDelete setting. Retain: When you delete the PVC, the PV and NAS file remain intact. You must delete them manually. Use this for high-security scenarios to prevent accidental data loss.
   Mount options	Mount options for NAS, including the NFS protocol version. By default, NAS mounts using NFS v3. To specify another version, use vers=4.0. For supported NFS versions per NAS type, see NFS protocol.

   After the StorageClass is created, you can view it in the Storage Classes list.

kubectl

1. Create a file named nas-pvc.yaml that has the following content.

   kind: PersistentVolumeClaim
   apiVersion: v1
   metadata: 
     name: nas-csi-pvc
   spec:
     accessModes:
     - ReadWriteMany 
     # Specify the StorageClass to bind.
     storageClassName: alicloud-nas-subpath  
     resources: 
       requests:
         # Declare the required volume capacity.
         storage: 20Gi  

   Parameter	Description
   accessModes	The access mode. Valid values: ReadWriteMany (default): The volume can be mounted as read-write by many nodes. ReadWriteOnce: The volume can be mounted as read-write by a single node. ReadOnlyMany: The volume can be mounted as read-only by many nodes.
   storageClassName	The StorageClass to bind.
   storage	Declare the required volume capacity. By default, this serves as a resource request and does not restrict the actual storage space available to the pod. The maximum NAS capacity depends on the specification. See General-purpose NAS and Extreme NAS. However, when allowVolumeExpansion is set to true in the StorageClass, this value becomes a hard limit. The CSI driver sets a NAS directory quota to enforce this limit.

2. Create the PVC.

   kubectl create -f nas-pvc.yaml

3. View the PVs.

   kubectl get pv

   Expected output: A PV is automatically created and bound to the PVC based on the StorageClass.

   NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                 STORAGECLASS             VOLUMEATTRIBUTESCLASS   REASON   AGE
   nas-a7540d97-0f53-4e05-b7d9-557309******   20Gi       RWX            Retain           Bound    default/nas-csi-pvc   alicloud-nas-subpath     <unset>                          5m

Console

1. In the left-side navigation pane of the details page, choose Volumes > Persistent Volume Claims.

2. On the Persistent Volume Claims page, click Create. Configure the PVC and click Create.

   Configuration item	Description
   Persistent volume claim type	Select NAS.
   Name	PVC name. Must be unique within the namespace.
   Allocation mode	Select Dynamically create using storage class.
   Existing storage class	Click Select storage class and choose the StorageClass you created earlier.
   Total	Declare the required volume capacity. By default, this serves as a resource request and does not restrict the actual storage space available to the pod. The maximum NAS capacity depends on the specification. See General-purpose NAS and Extreme NAS. However, when allowVolumeExpansion is set to true in the StorageClass, this value becomes a hard limit. The CSI driver sets a NAS directory quota to enforce this limit.
   Access mode	The access mode. Valid values: ReadWriteMany (default): The volume can be mounted as read-write by many nodes. ReadWriteOnce: The volume can be mounted as read-write by a single node. ReadOnlyMany: The volume can be mounted as read-only by many nodes.

kubectl

Create two deployments and mount the same PVC to share the same subdirectory of the same NAS file system.

To mount different subdirectories of the same NAS file system to multiple pods, you must create separate StorageClasses and corresponding PVCs for each subdirectory, and then mount each PVC separately.

1. Create two files named nginx-1.yaml and nginx-2.yaml that have the following content.

   The configurations for both applications are nearly identical. Both reference the same PVC.

   • nginx-1.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: nas-test-1     
       labels:
         app: nginx
     spec:
       selector:
         matchLabels:
           app: nginx
       template:
         metadata:
           labels:
             app: nginx
         spec:
           containers:
           - name: nginx
             image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
             ports:
             - containerPort: 80
             volumeMounts:
               - name: nas-pvc
                 # Mount path for NAS in the container.
                 mountPath: "/data"          
           volumes:
             - name: nas-pvc                 
               persistentVolumeClaim:
                 # Bind the PVC created earlier.
                 claimName: nas-csi-pvc      

   • nginx-2.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: nas-test-2     
       labels:
         app: nginx
     spec:
       selector:
         matchLabels:
           app: nginx
       template:
         metadata:
           labels:
             app: nginx
         spec:
           containers:
           - name: nginx
             image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
             ports:
             - containerPort: 80
             volumeMounts:
               - name: nas-pvc
                 # Mount path for NAS in the container.
                 mountPath: "/data"           
           volumes:
             - name: nas-pvc                 
               persistentVolumeClaim:
                 # Bind the PVC created earlier.
                 claimName: nas-csi-pvc       

2. Create the two deployments.

   kubectl create -f nginx-1.yaml -f nginx-2.yaml

3. You can check pod status.

   kubectl get pod -l app=nginx

   Expected output

   NAME                         READY   STATUS    RESTARTS   AGE
   nas-test-1-b75d5b6bc-*****   1/1     Running   0          51s
   nas-test-2-b75d5b6bc-*****   1/1     Running   0          44s

4. Check the detailed configuration of both pods to confirm that the PVC is mounted.

   Replace <podName> with the actual pod name.

   kubectl describe pod <podName> | grep "ClaimName:"

   In the expected output, both pods mount the same PVC and share the same NAS subdirectory.

Console

Repeat the following steps to create two deployments and mount the same PVC to share the same subdirectory of the same NAS file system.

1. On the ACK Clusters page, click the name of the target cluster. In the left navigation pane, choose Workloads > Deployments.

2. Click Create from Image. Configure and create the application as prompted.

   The following table describes the main parameters. Keep other parameters at their default values. For more information, see Create a Deployment.

   Configuration item	Parameter	Description
   Application basics	Replicas	Number of replicas for the deployment.
   Container configuration	Image name	Image address used to deploy the application.
   	Required resources	vCPU and memory resources required.
   	Volumes	Click Add cloud storage claim, then complete the configuration. Mount source: Select the PVC created earlier. Container path: Enter the path in the container where the NAS file system will be mounted.

   After the deployment completes, you can click the application name on the Stateless page and then confirm that the Pod is running normally on the Container Group tab. The Pod status must be Running.

kubectl

Console

1. On the Clusters page, click the name of the target cluster. In the navigation pane on the left, choose Volumes > StorageClasses.

2. Click Create. Enter a unique name for the StorageClass in the cluster and set Volume Type to NAS. Complete the creation of the StorageClass as prompted.

   Configuration item	Description
   Select mount target	The mount target address of the NAS file system.
   Volume mode	Volume access mode. In this example, select Shared directory (sharepath).
   Mount path	The subdirectory of the NAS file system to mount. If you do not set this parameter, the root directory is mounted by default. If the directory does not exist in the NAS file system, it is automatically created and mounted. General-purpose NAS file system: The root directory is /. Extreme NAS file system: The root directory is /share. When you mount a subdirectory, the path must start with /share (for example, /share/data).
   Recycling policy	For sharepath, set this to Retain.
   Mount options	Mount options for NAS, including the NFS protocol version. By default, NAS mounts using NFS v3. To specify another version, use vers=4.0. For supported NFS versions per NAS type, see NFS protocol.

kubectl

1. Create the `ns1` and `ns2` namespaces.

   kubectl create ns ns1
   kubectl create ns ns2

2. Create a file named pvc.yaml to create PVCs that have the same name in the `ns1` and `ns2` namespaces.

   kind: PersistentVolumeClaim
   apiVersion: v1
   metadata: 
     name: nas-csi-pvc
     namespace: ns1
   spec:
     accessModes:
     - ReadWriteMany 
     storageClassName: alicloud-nas-sharepath
     resources: 
       requests:
         storage: 20Gi
   ---
   kind: PersistentVolumeClaim
   apiVersion: v1
   metadata: 
     name: nas-csi-pvc
     namespace: ns2
   spec:
     accessModes:
     - ReadWriteMany 
     storageClassName: alicloud-nas-sharepath
     resources: 
       requests:
         storage: 20Gi

   Parameter	Description
   accessModes	The access mode. Valid values: ReadWriteMany (default): The volume can be mounted as read-write by many nodes. ReadWriteOnce: The volume can be mounted as read-write by a single node. ReadOnlyMany: The volume can be mounted as read-only by many nodes.
   storageClassName	The StorageClass to bind.
   storage	Declare the required volume capacity. By default, this serves as a resource request and does not restrict the actual storage space available to the pod. The maximum NAS capacity depends on the specification. See General-purpose NAS and Extreme NAS. However, when allowVolumeExpansion is set to true in the StorageClass, this value becomes a hard limit. The CSI driver sets a NAS directory quota to enforce this limit.

3. Create the PVCs.

   kubectl create -f pvc.yaml

4. Check the PV status to confirm that the PVs were automatically created and bound to the PVCs.

   kubectl get pv

   Expected output: The status of both PVs is Bound. The CLAIM column shows that each PV is bound to a PVC in a different namespace (ns1/nas-csi-pvc and ns2/nas-csi-pvc).

   NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                 STORAGECLASS             VOLUMEATTRIBUTESCLASS   REASON   AGE
   nas-0b448885-6226-4d22-8a5b-d0768c******   20Gi       RWX            Retain           Bound    ns1/nas-csi-pvc       alicloud-nas-sharepath   <unset>                          74s
   nas-bcd21c93-8219-4a11-986b-fd934a******   20Gi       RWX            Retain           Bound    ns2/nas-csi-pvc       alicloud-nas-sharepath   <unset>                          74s

Console

1. Create namespaces.

   • On the Clusters page, find the cluster you want and click its name. In the left-side navigation pane, click Namespaces and Quotas.

   • Click Create. Follow the prompts to create the `ns1` and `ns2` namespaces.

2. In the left-side navigation pane of the details page, choose Volumes > Persistent Volume Claims.

3. Create a persistent volume claim in the `ns1` namespace.

   On the Persistent Volume Claims page, set Namespace to ns1 and follow the prompts to create the PVC.

   Configuration item	Description
   Persistent volume claim type	Select NAS.
   Name	PVC name. Must be unique within the namespace.
   Allocation mode	Select Dynamically create using storage class.
   Existing storage class	Click Select storage class and choose the StorageClass created earlier.
   Total	Declare the required volume capacity. By default, this serves as a resource request and does not restrict the actual storage space available to the pod. The maximum NAS capacity depends on the specification. See General-purpose NAS and Extreme NAS. However, when allowVolumeExpansion is set to true in the StorageClass, this value becomes a hard limit. The CSI driver sets a NAS directory quota to enforce this limit.
   Access mode	The access mode. Valid values: ReadWriteMany (default): The volume can be mounted as read-write by many nodes. ReadWriteOnce: The volume can be mounted as read-write by a single node. ReadOnlyMany: The volume can be mounted as read-only by many nodes.

4. Repeat the previous step to create a PVC in the `ns2` namespace.

   After the PVCs are created, return to the Persistent Volume Claims page and confirm that the PVCs in the `ns1` and `ns2` namespaces are bound to the automatically created PVs.

kubectl

1. Create two files named nginx-ns1.yaml and nginx-ns2.yaml that have the following content.

   The configurations for both applications are nearly identical. Each binds the PVC in its respective namespace.

   • nginx-ns1.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: nas-test
       namespace: ns1   
     spec:
       selector:
         matchLabels:
           app: nginx
       template:
         metadata:
           labels:
             app: nginx
         spec:
           containers:
           - name: nginx
             image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
             ports:
             - containerPort: 80
             volumeMounts:
               - name: nas-pvc
                 mountPath: "/data"
           volumes:
             - name: nas-pvc
               persistentVolumeClaim:
                 claimName: nas-csi-pvc

   • nginx-ns2.yaml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: nas-test
       namespace: ns2   
     spec:
       selector:
         matchLabels:
           app: nginx
       template:
         metadata:
           labels:
             app: nginx
         spec:
           containers:
           - name: nginx
             image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
             ports:
             - containerPort: 80
             volumeMounts:
               - name: nas-pvc
                 mountPath: "/data"
           volumes:
             - name: nas-pvc
               persistentVolumeClaim:
                 claimName: nas-csi-pvc

2. Create the two deployments.

   kubectl create -f nginx-ns1.yaml -f nginx-ns2.yaml

3. Check the pod status.

   kubectl get pod -A -l app=nginx

   Expected output:

   NAMESPACE   NAME                         READY   STATUS    RESTARTS   AGE
   ns1         nas-test-b75d5b6bc-*****     1/1     Running   0          2m19s
   ns2         nas-test-b75d5b6bc-*****     1/1     Running   0          2m11s

4. Check the pod configuration to confirm that the PVC is mounted.

   Replace <namespace-name> and <pod-name> with the actual namespace and pod names.

   kubectl describe pod -n <namespace-name> <pod-name> | grep "ClaimName:"

   In the expected output, the two pods mount ns1/nas-csi-pvc and ns2/nas-csi-pvc, respectively.

Console

1. On the ACK Clusters page, click the name of the target cluster. In the left navigation pane, choose Workloads > Deployments.

2. Create a deployment in the `ns1` namespace and mount the corresponding PVC.

   1. Set Namespace to ns1 and click Create from Image.

   2. Complete the application creation as prompted.

      The following table describes the main parameters. Keep other parameters at their default values. For more information, see Create a Deployment.

      Configuration item	Parameter	Description
      Application basics	Replicas	Number of replicas for the deployment.
      Container configuration	Image name	Image address used to deploy the application.
      	Required resources	vCPU and memory resources required.
      	Volumes	Click Add cloud storage claim, then complete the configuration. Mount source: Select the PVC created earlier. Container path: Enter the path in the container where the NAS file system will be mounted, such as /data.

3. Repeat the previous step to create a deployment in the `ns2` namespace and mount the corresponding PVC.

   You can return to the Stateless page to check the deployment status of the two deployments in the ns1 and ns2 namespaces, and to confirm that the pods are running properly with their corresponding PVCs mounted.