标签：NFS

之前的《 Kubernetes持久卷实战两部曲》系列中，我们实战了先声明一个存储卷，再使用这个存储卷，这种方式要求每次都要提前申明存储，不是很方便，而动态卷存储不需要提前申明，而是使用时自动申明，今天我们就来一起实战；

原文地址：https://blog.csdn.net/boling_cavalry/article/details/79598905

本章概要

今天的实战，我们要做下列操作：

1. 准备好NFS服务；
2. 创建namespace；
3. 创建NFS服务的provisioner；
4. 创建存储类StorageClass，与刚刚创建的provisioner绑定；
5. 创建应用Pod，此应用是个web服务，外部通过HTTP请求将二进制文件上传到服务端，存储在Pod的本地路径，而这个路径已经被挂载到NFS；
6. 通过客户端上传文件，检查文件是否保存在NFS上；
7. 将web应用的Pod数扩展到两个，检查动态卷存储是否自动扩展；

网络服务图

本次实战涉及到客户端、K8S、NFS等网络节点，如下图：

源码下载

您可以在GitHub下载web服务的源码，地址和链接信息如下表所示：

这个git项目中有多个目录，本次需要其中的三个，如下：

1. 在K8S上创建Pod，service，StorageClass等资源的时候用到的各种yaml文件，存放在storageclass目录；
2. 接收客户端上传文件的web应用，源码在k8spvdemo目录；
3. 上传文件client工程，源码在uploadfileclient目录；

准备好NFS服务

参照 https://blog.csdn.net/boling_cavalry/article/details/79498346 搭建好NFS服务，服务器的IP地址是192.168.238.132，开放的目录/usr/local/work/nfs；

创建namespace

在能够执行kubectl的机器上执行命令kubectl create namespace bolingcavalry，即可创建本次实战要用到的namespace；

创建NFS服务的provisioner

创建provisioner对应的deployment-nfs.yaml脚本：

kind: Deployment
apiVersion: extensions/v1beta1
metadata:
  name: nfs-client-provisioner
  namespace: bolingcavalry
spec:
  replicas: 1
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: nfs-client-provisioner
    spec:
      containers:
        - name: nfs-client-provisioner
          image: registry.cn-hangzhou.aliyuncs.com/open-ali/nfs-client-provisioner
          volumeMounts:
            - name: nfs-client-root
              mountPath: /persistentvolumes
          env:
            - name: PROVISIONER_NAME
              value: fuseim.pri/ifs
            - name: NFS_SERVER
              value: 192.168.238.132
            - name: NFS_PATH
              value: /usr/local/work/nfs
      volumes:
        - name: nfs-client-root
          nfs:
            server: 192.168.238.132
            path: /usr/local/work/nfs

在此文件所在目录下执行kubectl create -f deployment-nfs.yaml，即可创建NFS的provisioner的pod，创建成功后，在dashboard页面看到，如下图：

这里三处需要注意：

1、设置了NFS的共享目录后，记得执行以下命令使设置生效：

systemctl restart rpcbind.service && systemctl restart nfs.service

2、此处用到的镜像是”registry.cn-hangzhou.aliyuncs.com/open-ali/nfs-client-provisioner”，这是我在阿里云的搜索到的，原本打算使用”quay.io/kubernetes_incubator/nfs-client-provisioner:v1”，但是在pull的时候报错：{“error”: “Permission Denied”}，在实战过程中用了阿里云的镜像可以正常工作，没有影响；
3、环境变量中有个PROVISIONER_NAME，值为fuseim.pri/ifs，后面的StorageClass就以“fuseim.pri/ifs”作为参数来定位到此Pod作为NFS服务的提供者；

创建存储类StorageClass

1、创建provisioner对应的nfs-class.yaml脚本：

apiVersion: storage.k8s.io/v1beta1
kind: StorageClass
metadata:
  name: managed-nfs-storage
provisioner: fuseim.pri/ifs

2、在此文件所在目录下执行kubectl create -f nfs-class.yaml，即可创建存储类的资源，创建成功后，在dashboard页面看到，如下图：

创建web应用的Pod

存储已经准备好了，接下来制作一个web服务的应用来使用这个存储，该应用我已经做成镜像，可以直接使用；

1、创建web服务的部署脚本k8spvdemo.yaml：

apiVersion: apps/v1beta1
kind: StatefulSet
metadata:
  name: k8spvdemo
  namespace:  bolingcavalry
spec:
  serviceName: "k8spvdemo"
  replicas: 1
  volumeClaimTemplates:
  - metadata:
      name: test 
      annotations:
        volume.beta.kubernetes.io/storage-class: "managed-nfs-storage"
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 2Gi 
  template:
    metadata:
     labels:
       name: k8spvdemo
    spec:
     containers:
     - name: k8spvdemo
       image: bolingcavalry/k8spvdemo:0.0.1-SNAPSHOT
       volumeMounts:
       - mountPath: "/usr/local/uploadfiles"
         name: test
       tty: true
       ports:
       - containerPort: 8080

2、在k8spvdemo.yaml文件所在目录执行命令kubectl create -f k8spvdemo.yaml，即可创建应用的Pod，如下图：

3、将应用Pod包裹成Service以便外部访问，创建服务配置文件k8spvdemo-svc.yaml：

apiVersion: v1
kind: Service
metadata:
  name: k8spvdemo
  namespace:  bolingcavalry
spec:
  type: NodePort
  ports:
       - port: 8080
         nodePort: 30010
  selector:
    name: k8spvdemo

4、在k8spvdemo.yaml文件所在目录执行命令kubectl create -f k8spvdemo-svc.yaml，即可创建服务，在dashboard页面看到服务如下图：

经历了以上四步，就把服务启动起来了，并且使用了NFS，小结出以下几个关键点需要注意：

• 参数kind: StatefulSet表示使用了有状态资源，因为普通deployment是无法使用StorageClass资源的；
• web工程中，收到客户端POST上来的文件后，保存在本地的/usr/local/uploadfiles目录，该目录在k8spvdemo.yaml的配置中通过volumeMounts参数挂在到StorageClass上；
• 在k8spvdemo-svc.yaml的配置中做了端口映射，我的k8s节点机器的IP是192.168.238.130，那么通过192.168.238.130:30010就能访问到Pod服务；
• 将springboot工程制作成镜像的方法请参考《maven构建docker镜像三部曲》系列文章；
• 在NFS机器的/usr/local/work/nfs目录下，可以看到新创建的文件夹，如下图：

• 在容器的事件中可以看到挂载信息，挂载的PV名称与NFS上创建的文件夹是可以对应起来的，如下图红框3所示：

服务已经准备好了，接下来试试上传文件，看应用能否正常使用动态卷存储；

运行客户端，上传本地文件到Tomcat

1、创建一个maven工程，pom.xml如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bolingcavalry</groupId>
    <artifactId>uploadfileclient</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 指明编译源代码时使用的字符编码，maven编译的时候默认使用的GBK编码， 通过project.build.sourceEncoding属性设置字符编码，告诉maven这个项目使用UTF-8来编译 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3.5</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.3.5</version>
        </dependency>
    </dependencies>

</project>

1. 工程中创建一个java类，源码如下：

package com.bolingcavalry;

import org.apache.http.HttpEntity;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.File;
import java.io.IOException;

/**
 * @Description : 上传文件的类，将本地文件POST到server
 * @Author : [email protected]
 * @Date : 2018-02-24 18:12
 */
public class UploadFileClient {

    /**
     * 文件服务的ULR
     */
    private static final String POST_URL = "http://192.168.238.130:30010//upload";

    /**
     * 要上传的本地文件的完整路径加文件名
     */
    private static final String UPLOAD_FILE_FULLPATH = "D:\temp\201802\21\abc.zip";

    public static void main(String[] args) throws Exception{
        System.out.println("start upload");
        CloseableHttpClient httpclient = HttpClients.createDefault();
        try {
            HttpPost httppost = new HttpPost(POST_URL);

            //基本的配置信息
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(200000).setSocketTimeout(200000).build();

            httppost.setConfig(requestConfig);

            //要上传的文件
            FileBody bin = new FileBody(new File(UPLOAD_FILE_FULLPATH));

            //在POST中添加一个字符串请求参数
            StringBody comment = new StringBody("This is comment", ContentType.TEXT_PLAIN);

            HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("file", bin).addPart("comment", comment).build();

            httppost.setEntity(reqEntity);

            System.out.println("executing request " + httppost.getRequestLine());

            //发起POST
            CloseableHttpResponse response = httpclient.execute(httppost);

            try {

                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    String responseEntityStr = EntityUtils.toString(response.getEntity());
                    System.out.println("response status : " + response.getStatusLine());
                    System.out.println("response content length: " + resEntity.getContentLength());
                    System.out.println("response entity str : " + responseEntityStr);
                }
                EntityUtils.consume(resEntity);
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        System.out.println("end upload");
    }
}

以上源码中，有两处要注意：
第一，POST_URL = “http://192.168.238.130:30010//upload”中的192.168.238.130是Pod所在的节点机器的IP地址，请替换为您的k8s环境中的节点IP地址；
第二，UPLOAD_FILE_FULLPATH = “D:temp20180221abc.zip”，这里配置的是要上传的本地文件的路径，请替换为您要上传的文件路径；

3、直接运行UploadFileClient.java，看到控制台输出如下信息表示上传成功：

start upload
executing request POST http://192.168.238.130:30010/upload HTTP/1.1
response status : HTTP/1.1 200 
response content length: 40
response entity str : SpringBoot环境下，上传文件成功
end upload

Process finished with exit code 0

上传成功了，在dashboard上查看容器的日志，能看到上传有关的日志如下图红框所示：

现在理论上现在文件已经保存在NFS Server的/usr/local/work/nfs目录下了，去检查一下；

去NFS Server检查上传的文件

登录NFS Server，进入/usr/local/work/nfs，查看文件信息如下图：

可见k8s上的tomcat应用可以通过动态卷存储的方式将客户端上传的文件保存在NFS服务器上；

扩展web应用的Pod数量

目前web应用的Pod数量是1，执行以下命令扩展到两个：

kubectl scale StatefulSet k8spvdemo --replicas=2 --namespace=bolingcavalry

执行完毕后，在dashboard可以看见创建的动态卷，如下图：

您可以再次上传文件，然后去NFS服务器检查是否已经创建了新的文件夹，并且存放了新的上传文件；

至此，Kubernetes动态卷存储的实战就全部完成了，希望PV&&PVC和动态存储两种方案可以帮助您在应用中解决独立存储的问题；