该文章中主要体现了本人的一些心得可踩坑可供大家参考！
主要测试了3中方式：
1.spark-examples测试基础镜像是否可用
2.自主开发应用程序jar打入镜像运行
3.jar挂载到镜像内运行
需要测试人员有一定的开发基础和k8s基础

使用docker build命令制作spark基础镜像spark提供：
1.查看和清理历史环境命令
查看ClusterRole和ClusterRoleBinding
kubectl get ClusterRole
包含 “spark” 的 ClusterRole 资源
kubectl get ClusterRole | grep spark
删除角色
kubectl delete clusterrole <clusterrole_name>
查看Role和RoleBinding
kubectl get role -n apache-spark
kubectl get rolebinding -n apache-spark
删除 Apache-Spark 命名空间中的 ClusterRole 和 RoleBinding。
kubectl delete role spark-role -n apache-spark
kubectl delete rolebinding spark-role -n apache-spark
查看ServiceAccount
kubectl get serviceaccount -n provisioner
kubectl get serviceaccount -n apache-spark
删除ServiceAccount
kubectl delete serviceaccount nfs-client-provisioner -n provisioner

删除角色绑定
peace:
kubectl get ClusterRole -n provisioner
kubectl delete clusterrole nfs-client-provisioner-runner
peace:
kubectl get role -n provisioner
kubectl delete role leader-locking-nfs-client-provisioner -n provisioner
peace:
kubectl get rolebinding -n provisioner
kubectl delete rolebinding leader-locking-nfs-client-provisioner -n provisioner
peace:
kubectl get ClusterRolebinding -n provisioner
kubectl delete ClusterRolebinding run-nfs-client-provisioner -n provisioner

查看命名空间
kubectl get namespace
删除命名空间
kubectl delete namespace apache-spark
创建命名空间
kubectl create namespace apache-spark
2.创建环境前提条件
创建spark namespace
kubectl create namespace apache-spark
创建ServiceAccount
kubectl create serviceaccount spark -n apache-spark
kubectl create rolebinding spark-role --clusterrole=view --serviceaccount=spark-server:spark -n apache-spark
验证 ConfigMap 是否存在于相同的命名空间中
kubectl get configmap spark-conf-volume -n apache-spark
kubectl create configmap spark-conf-volume --from-file=/usr/spark-3.0/spark-3.0.0-bin-hadoop3.2/conf -n apache-spark

---

测试流程:
先决条件，在linxu装spar3.2.3版本环境
K8S：v1.23.17
spark：3.2.3 （spark-3.2.3-bin-hadoop3.2.tgz）需要使用submit命令

1.到DockerHub查找apache spark的镜像，并拉取到本地
docker pull apache/spark:v3.2.3
2.修改镜像tag
docker tag b614acd71f4d harbor:8008/public/apache/spark:v3.2.3
3.上传到harbor
docker push harbor:8008/public/apache/spark:v3.2.3
4.创建命名空间（随便创建一个文件夹目录内执行）
vi spark-namespace.yaml

apiVersion: v1
kind: Namespace
metadata:
  name: apache-spark
  labels:
    app.kubernetes.io/name: apache-spark
    app.kubernetes.io/instance: apache-spark

(注：在这个清单文件中，定义了一个名为 “apache-spark” 的命名空间，并为其添加了两个标签：
app.kubernetes.io/name: apache-spark
app.kubernetes.io/instance: apache-spark）
要使用该清单文件创建名为 “apache-spark” 的命名空间，可以执行以下命令：
kubectl apply -f spark-namespace.yaml
5.创建ServiceAccount
编写spark-service-account.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  namespace: apache-spark
  name: spark-service-account
  labels:
    app.kubernetes.io/name: apache-spark
    app.kubernetes.io/instance: apache-spark
    app.kubernetes.io/version: v3.2.3

(注：用于创建名为 “spark-service-account” 的 ServiceAccount（服务账号），并为其添加一些标签。
该清单文件的内容如下：
app.kubernetes.io/name: apache-spark
app.kubernetes.io/instance: apache-spark
app.kubernetes.io/version: v3.2.3)
提交yaml创建ServiceAccount
kubectl apply -f spark-service-account.yaml
查看ServiceAccount
kubectl get sa -n apache-spark
6.创建Role和RoleBinding
K8s使用RBAC实现对K8s上各类资源的权限管理，RBAC全称Role-Based Access Control
RBAC 授权规则是通过四种资源来进行配置的，它们可以分为两个组
*Role( 角色)和 ClusterRole (集群角色)， 它们指定了在资源可以执行哪些动词。
*RoleBinding 角色绑定)和 lusterRoleBinding 集联角色定)，它们将角色定到特定的用户，组ServiceAcount5上，角色定义了可以做什么提作，而定定义了谁可以做这些授作。
角色和集群角色，或者角色绑定和集群角色绑定之间的区别在于角色和角色绑定是命名空间的资源，而集群角色和集群角色绑定是集群级别的资源，
编写spark-role.yaml
vi spark-role.yaml

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  labels:
    app.kubernetes.io/name: apache-spark
    app.kubernetes.io/instance: apache-spark
    app.kubernetes.io/version: v3.2.3
  namespace: apache-spark
  name: spark-role
rules:
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["get", "watch", "list", "create", "delete"]
  - apiGroups: ["extensions", "apps"]
    resources: ["deployments"]
    verbs: ["get", "watch", "list", "create", "delete"]
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["get", "create", "update", "delete"]
  - apiGroups: [""]
    resources: ["secrets"]
    verbs: ["get"]
  - apiGroups: [""]
    resources: ["services"]
    verbs: ["get", "list", "create", "delete"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  labels:
    app.kubernetes.io/name: apache-spark
    app.kubernetes.io/instance: apache-spark
    app.kubernetes.io/version: v3.2.3
  name: spark-role-binding
  namespace: apache-spark
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: spark-role
subjects:
  - kind: ServiceAccount
    name: spark-service-account
    namespace: apache-spark

注：用于创建一个名为 “spark-role” 的 Role（角色）和一个名为 “spark-role-binding” 的 RoleBinding（角色绑定）为它们添加一些标签并且定义了一组针对不同资源的权限规则。
提交yaml创建Role和RoleBinding
kubectl apply -f spark-role.yaml
查看Role和RoleBinding
kubectl get role -n apache-spark kubectl get rolebinding -n apache-spark
7.创建ClusterRole和ClusterRoleBinding
编写cluster-role.yaml
vi cluster-role.yaml

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    app.kubernetes.io/name: apache-spark
    app.kubernetes.io/instance: apache-spark
    app.kubernetes.io/version: v3.2.3
  name: apache-spark-clusterrole
rules:
  - apiGroups:
      - ''
    resources:
      - configmaps
      - endpoints
      - nodes
      - pods
      - secrets
      - namespaces
    verbs:
      - list
      - watch
      - get
  - apiGroups:
      - ''
    resources:
      - services
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - ''
    resources:
      - events
    verbs:
      - create
      - patch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  labels:
    app.kubernetes.io/name: apache-spark
    app.kubernetes.io/instance: apache-spark
    app.kubernetes.io/version: v3.2.3
  name: apache-spark-clusterrole-binding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: apache-spark-clusterrole
subjects:
  - kind: ServiceAccount
    name: spark-service-account
    namespace: apache-spark

注：用于创建一个名为 “apache-spark-clusterrole” 的 ClusterRole（集群角色）和一个名为 “apache-spark-clusterrole-binding” 的 ClusterRoleBinding（集群角色绑定），并为它们添加一些标签。
提交yaml创建ClusterRole和ClusterRoleBinding
kubectl apply -f cluster-role.yaml
查看ClusterRole和ClusterRoleBinding
kubectl get ClusterRole | grep spark
kubectl get ClusterRoleBinding | grep spark
8.查看k8s master的url，获取Kubernetes control plane URL
kubectl cluster-info
9.提交Spark程序到K8s上运行

/spark/spark-3.2.3/bin/spark-submit \
 --name SparkPi \
 --verbose \
 --master k8s://https://xxx.xxx.xx.xx:6443 \
 --deploy-mode cluster \
 --conf spark.network.timeout=300 \
 --conf spark.executor.instances=3 \
 --conf spark.driver.cores=1 \
 --conf spark.executor.cores=1 \
 --conf spark.driver.memory=1024m \
 --conf spark.executor.memory=1024m \
 --conf spark.kubernetes.namespace=apache-spark \
 --conf spark.kubernetes.container.image.pullPolicy=IfNotPresent \
 --conf spark.kubernetes.container.image=harbor:8008/public/apache/spark:v3.2.3 \
 --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark-service-account \
 --conf spark.kubernetes.authenticate.executor.serviceAccountName=spark-service-account \
 --conf spark.driver.extraJavaOptions="-Dio.netty.tryReflectionSetAccessible=true" \
 --conf spark.executor.extraJavaOptions="-Dio.netty.tryReflectionSetAccessible=true" \
 --class org.apache.spark.examples.SparkPi \
 local:///opt/spark/examples/jars/spark-examples_2.12-3.2.3.jar \
 3000

–master为Kubernetes control plane URL
–deploy-mode为cluster，则driver和executor都运行在K8s里
–conf spark.kubernetes.namespace为前面创建的命名空间apache-spark
–conf spark.kubernetes.container.image为Spark的镜像地址
–conf spark.kubernetes.authenticate.executor.serviceAccountName为前面创建的spark-service-account
–class为Spark程序的启动类
local:///opt/spark/examples/jars/spark-examples_2.12-3.2.3.jar为Spark程序所在的Jar文件，spark-examples_2.12-3.2.3.jar是Spark镜像自带的，所以使用local schema
3000是传入Spark程序的启动类的参数多个需要空格隔开
11.观察driver pod和executor pod
kubectl get pods -n apache-spark
12.查看日志的统计结果
kubectl logs sparkpi-c39d518967ae4eb6-driver -n apache-spark
kubectl describe pod spark-pi-k8s-d606898966b7da18-driver -n apache-spark
13.结束清理POD
kubectl delete pod sparkpi-c39d518967ae4eb6-driver -n apache-spark
14.完成
-------------------------------------------------------------- （示例程序开发：）--------------------------------------------------------------
1、POM

<?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>org.example</groupId>
    <artifactId>spark-kubernete</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spark.version>3.2.3</spark.version>
        <java.version>1.8</java.version>
        <scala.binary.version>2.12</scala.binary.version>
        <slf4j.version>1.7.30</slf4j.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <!--            <scope>provided</scope>-->
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <!--            <scope>provided</scope>-->
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <!--            <scope>provided</scope>-->
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql-kafka-0-10_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <!--            <scope>provided</scope>-->
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.12</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>com.crealytics</groupId>
            <artifactId>spark-excel_2.12</artifactId>
            <version>0.13.7</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.2.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2、应用程序

object SparkToK8sExample {
  def main(args: Array[String]): Unit = {
    //创建 SparkSession
    val spark = SparkSession.builder
      .appName("SparkKubernetesExample")
      //      .master("local[*]")
      //      .config("spark.executor.instances", "2") //设置集群中启动executor节点的数量
      .getOrCreate()
    import spark.implicits._
    val df = Seq(
      ("sws", "gl", "12"),
      ("jxz", "wy", "13"),
      ("zxb", "ss", "14")
    ).toDF("col1", "col2", "col3")
    // 打印 DataFrame
    df.show()
    // 停止 SparkSession
    spark.stop()
  }
}

3、输出
+----+----+----+
|col1|col2|col3|
+----+----+----+
| sws|  gl|  12|
| jxz|  wy|  13|
| zxb|  ss|  14|
+----+----+----+
4、打包写dockerfile
mkdir -p /opt/s3file
cd /opt/s3file
vim Dockerfile

```html
FROM apache/spark:v3.2.3
COPY spark-kubernete-1.0-SNAPSHOT.jar /opt/spark/spark-kubernete-1.0.jar
WORKDIR /opt/spark/work-dir
ENTRYPOINT ["/opt/entrypoint.sh"]
USER 185

---

要查看 Kubernetes 集群中的 Worker 节点，可以使用以下命令：
kubectl get nodes --selector=‘!node-role.kubernetes.io/master’
192.168.11.119 rdph119
192.168.11.120 rdph120
192.168.11.121 rdph121

Dockerfile分发到k8s其他节点 (119-121-worker节点上)
cd /opt/s3file
copy 到其他节点上进行build
在k8s(119-121-worker节点上)每个节点上都执行
生成镜像：
docker build -f Dockerfile -t harbor:8008/public/spark-kubernete:v3.2.3 .
(docker push harbor:8008/public/spark-kubernete:v3.2.3)
如果你执行命令中拉取策略不是在本地的话可以不用分发因为是统一从一个镜像仓库拉取的
–conf spark.kubernetes.container.image.pullPolicy=IfNotPresent
查看镜像
docker images
5、提交Spark程序到K8s上运行 （根据环境更改拉取策略）

/spark/spark-3.2.3/bin/spark-submit \
 --name Spark-k8s-demo \
 --verbose \
 --master k8s://https://xxx.xxx.xx.xxx:6443 \
 --deploy-mode cluster \
 --conf spark.network.timeout=30000 \
 --conf spark.executor.instances=3 \
 --conf spark.driver.cores=1 \
 --conf spark.executor.cores=1 \
 --conf spark.driver.memory=1024m \
 --conf spark.executor.memory=1024m \
 --conf spark.kubernetes.namespace=apache-spark \
 --conf spark.kubernetes.container.image.pullPolicy=IfNotPresent \
 --conf spark.kubernetes.container.image=harbor:8008/public/spark-kubernete:v3.2.3 \
 --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark-service-account \
 --conf spark.kubernetes.authenticate.executor.serviceAccountName=spark-service-account \
 --conf spark.driver.extraJavaOptions="-Dio.netty.tryReflectionSetAccessible=true" \
 --conf spark.executor.extraJavaOptions="-Dio.netty.tryReflectionSetAccessible=true" \
 --class org.example.SparkToK8sExample \
 local:///opt/spark/spark-kubernete-1.0.jar

附：
进阶操作 pvc挂载jar包
参考： https://haokan.baidu.com/v?vid=18362527524991058921&collection_id=

---------前提条件安装nfsserver服务----------------
所有节点安装
yum install -y nfs-utils
k8s01master节点创建
echo “/nfs/data/ *(insecure,rw,sync,no_root_squash)” > /etc/exports
要重新加载 NFS 服务的话要执行下面命令以使 /etc/exports 文件的更改生效
exportfs -ra
所有节点创建共享目录
mkdir -p /nfs/data

1、检查k8s01master节点是否配置了NFD服务
查看rpcbind是否启动
systemctl status rpcbind
查看nfs-server是否启动
systemctl status nfs-server
用于在系统启动时启用 NFS 服务器服务
systemctl enable rpcbind
于在系统启动时启用 nfs-server 服务器服务
systemctl enable nfs-server
用于启动 rpcbind 服务。
systemctl restart rpcbind
systemctl start rpcbind
用于启动 nfs-server 服务。
systemctl restart nfs-server
systemctl start nfs-server
使配置生效
exportfs -r
检查配置是否生效
exportfs

3、每个节点都挂载没有需要在主节点的其他节点执行一下命令
查看挂载：
df -h
卸载挂载：
umount /nfs/data
报错的话可以强制卸载也可以kill掉进程再卸载
lsof | grep /nfs/data
*kill 31002
*umount -f /nfs/data

查看挂载路径（展示主机 “rdph108” 上可挂载的 NFS 共享。）
showmount -e rdph108 （rdph108为 cat/etc/hosts下域名名称）
创建挂载目录（递归方式创建路径中的所有目录）
mkdir -p /nfs/data
同步（将远程主机 rdph108 上的 NFS 共享挂载到本地目录 /data/nfs。）
mount -t nfs rdph108:/nfs/data /nfs/data
确认配置是否生效在master上执行 kubectl get sc

编写挂载pvc.yaml------------------
1、vim spark-jar-pvc.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: spark-jar-pvc  # jar pvc名称
  namespace: apache-spark
spec:
  storageClassName: nfs-storage   #sc名称
  accessModes:
    - ReadOnlyMany   #采用ReadOnlyMany的访问模式
  resources:
    requests:
      storage: 1Gi    #存储容量，根据实际需要更改
      

---

2、创建
kubectl apply -f spark-jar-pvc.yaml
3、查看
kubectl get pvc
kubectl get pvc -n apache-spark
4、将JAR包和wc_input.txt上传放到PV的实际路径 ll /nfs/data

/spark/spark-3.2.3/bin/spark-submit \
 --name Spark-k8s-demo-pvc \
 --verbose \
 --master k8s://https://xxx.xxx.xx.xxx:6443 \
 --deploy-mode cluster \
 --conf spark.network.timeout=300 \
 --conf spark.executor.instances=3 \
 --conf spark.driver.cores=1 \
 --conf spark.executor.cores=1 \
 --conf spark.driver.memory=1024m \
 --conf spark.executor.memory=1024m \
 --conf spark.driver.extraJavaOptions="-Dio.netty.tryReflectionSetAccessible=true" \
 --conf spark.executor.extraJavaOptions="-Dio.netty.tryReflectionSetAccessible=true" \
 --conf spark.kubernetes.namespace=apache-spark \
 --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark-service-account \
 --conf spark.kubernetes.authenticate.executor.serviceAccountName=spark-service-account \
 --conf spark.kubernetes.container.image.pullPolicy=IfNotPresent \
 --conf spark.kubernetes.container.image=apache/spark:v3.2.3 \
 --conf spark.kubernetes.driver.volumes.persistentVolumeClaim.jars-pvc.mount.path=/opt/spark/examples \
 --conf spark.kubernetes.driver.volumes.persistentVolumeClaim.jars-pvc.options.claimName=spark-jar-pvc \
 --conf spark.kubernetes.driver.volumes.persistentVolumeClaim.jars-pvc.mount.readOnly=false \
 --conf spark.kubernetes.executor.volumes.persistentVolumeClaim.jars-pvc.mount.path=/opt/spark/examples \
 --conf spark.kubernetes.executor.volumes.persistentVolumeClaim.jars-pvc.options.claimName=spark-jar-pvc \
 --class org.example.SparkToK8sExample \
 local:///opt/spark/examples/spark-kubernete-1.0.jar

---

其他命令：
pod命令：
查看pod
watch -n 1 kubectl get all -owide -n apache-spark
kubectl get pods -n apache-spark
kubectl get pods -n provisioner
查看日志的统计结果
kubectl logs nfs-client-provisioner-6f4c4cb8d-52fr4 -n provisioner
kubectl logs spark-k8s-demo-pvc-933082898fa459e8-driver -n apache-spark
kubectl describe pod spark-k8s-demo-pvc-6626a8898c8aaa76-driver -n apache-spark
kubectl describe pod mypod -n provisioner
删除pod
kubectl delete spark-deployment-5d46445d5b-smr98 -n apache-spark
删除失效pod
kubectl delete pod spark-k8s-demo-pvc-6fd467898c6f48a1-driver -n apache-spark
kubectl delete pod mypod -n provisioner
强制删除
kubectl delete pod kubectl delete pod spark-deployment-5d46445d5b-jjlks -n apache-spark --force --grace-period=0
全量删除
kubectl delete pods --all -n apache-spark
删除yaml创建的pod
kubectl delete -f sparkdemo.yaml
访问驱动程序用户界面
kubectl port-forward 4040:4040
查看部署
kubectl get deployments
无部署的话你可以使用以下命令切换到目标命名空间：
kubectl config set-context --current --namespace=apache-spark
删除
kubectl delete pod spark-k8s-demo-pvc-7d6ae68986eaf164-driver
k8s容器日志
kubectl logs spark-k8s-demo-pvc-f8926e89872bd5c1-driver -c compassionate_zhukovsky

docker命令：
dockerfile：

生成镜像：
docker build -t harbor:8008/public/spark-kubernete:spark-v3.0 .
docker push harbor:8008/public/spark-kubernete:spark-v3.0
查看镜像
docker images
批量删除镜像
docker rmi b614acd71f4d
强制删除镜像
docker rmi -f ab8b8dca8725

容器命令：
启动容器，每次启动 my_container要换个名字
docker run -it --name my_container harbor:8008/public/spark-kubernete:v3.2.3 /bin/bash
查看容器
docker ps -a
启动容器
docker start 18ff4e3f3143
进入容器
docker exec -it 18ff4e3f3143 /bin/bash
停止容器
docker stop 18ff4e3f3143
删除容器
docker rm 18ff4e3f3143
容器日志
docker logs 3a1cae5866bc

挂载相关命令：
要查看 Kubernetes 中可用的存储类
kubectl get storageclass
kubectl describe storageclass nfs-storage
kubectl delete storageclass nfs-storage

1.列出所有 PVC：
kubectl get pvc
1.1查看命名空间的PVC：
kubectl get pvc -n apache-spark
kubectl get pv -n apache-spark
2.PVC关联的持久卷
kubectl describe pvc pvc-2436e8be-55c4-4718-a90c-3504c5eb1a75 (将 替换为上一步（1.or1.1）中得到的 PVC 的名称)
2.2查看命名空间的PVC关联的持久卷
kubectl describe pvc spark-jar-pvc -n apache-spark
3.关联的存储卷的详细信息
kubectl describe pv (获取与上一步（2or2.2）中找到的 PersistentVolume 关联的存储卷的详细信息)
4.查看nfs-storage挂载路径
4.1此命令将列出所有与 spark-jar-pvc 相关联的持久卷名称和相应的本地挂载路径。
kubectl get pv -o=jsonpath=‘{range .items[?(@.spec.claimRef.name==“spark-jar-pvc”)]}{.metadata.name}{“\t”}{.spec.local.path}{“\n”}{end}’
4.2该命令将提供有关持久卷的更多详细信息，包括其所属的存储类、容量和访问模式等。
kubectl describe pv pvc-1e696fbe-b6a3-409c-ad54-0f8fa067fae5
kubectl get pv pvc-2436e8be-55c4-4718-a90c-3504c5eb1a75 -o yaml
5.删除pvc
kubectl delete pvc spark-jar-pvc -n apache-spark
6.删除pv
kubectl delete pv pvc-2436e8be-55c4-4718-a90c-3504c5eb1a75
7.查看pvc详情
kubectl describe pvc spark-jar-pvc -n apache-spark

spark 程序jar包获取方式
方式一：Jar包打进镜像
每个作业都要打一个镜像，容易导致镜像数量过多，不便于管理，不推荐使用
方式二：Jar包通过PV挂载
Jar包不用打到镜像，省去镜像构建工作，只需维护少量几个Spark基础镜像，节省空间，优先推荐此方式
方式三：HTTP/FTP下载方式
可以统一将作业Jar包发布到HTTP文件服务器，例如tomcat、apache或nginx，实现作业Jar包的统一存放，推荐使用
方式四：S3/HDFS方式
将作业Jar包发布到S3对象存储或HDFS上，通过s3a或hdfs schema访问作业Jar包，与方式3类似，但增加了对第三方集群环境的依赖，不推荐使用

附：nfs服务搭建后执行的yaml文件
kubectl create -f 和 kubectl apply -f 是两个 kubectl 命令用于创建或更新 Kubernetes 资源的方式。
*kubectl create -f：该命令会使用给定的 YAML 或 JSON 文件来创建 Kubernetes 资源。如果资源已经存在，将会返回错误。这意味着你不能使用相同的文件来多次创建同一个资源。
*kubectl apply -f：该命令也使用给定的 YAML 或 JSON 文件来创建或更新 Kubernetes 资源。如果资源不存在，它将创建新资源。如果资源已经存在，则会对其进行更新。这是通过比较文件中的配置与现有资源的配置来实现的。如果文件中的配置与现有资源的配置不同，kubectl apply -f 将会更新资源以匹配文件中的配置。
因此，区别在于 kubectl apply -f 具有更新资源的功能，而 kubectl create -f 则仅能用于创建资源，无法更新现有资源。推荐在大部分情况下使用 kubectl apply -f，因为它可以确保资源的状态与所提供的文件中的配置一致。
cd /opt/s3file/spark-yml/deploy
创建 RBAC：
kubectl apply -f nfs-rbac.yaml
创建 StorageClass：
-n: 指定应用部署的 Namespace
kubectl apply -f nfs-provisioner-deploy.yaml -n provisioner
创建 StorageClass：
kubectl apply -f nfs-storage.yaml
创建sparkpvc
cd /opt/s3file/spark-yml
kubectl apply -f spark-jar-pvc.yaml

测试流程
kubectl apply -f test-pvc.yaml
-n：指定创建 Pod 的 Namespace
kubectl apply -f test-pod.yaml -n apache-spark
进入容器
kubectl exec spark-k8s-demo-pvc-aa8fc78985f8ce9b-driver – /bin/bash

附：查阅资料
https://www.51cto.com/article/679824.html
https://kubernetes.io/docs/concepts/storage/volumes/#persistentvolumeclaim
https://spark.apache.org/docs/2.4.5/running-on-kubernetes.html