k8s如何安装spark_k8s spark - CSDN
  • 使用k8s搭建spark集群这几天尝试在k8s中搭建spark集群,踩了一些坑,跟大家分享一下。

    使用k8s搭建spark集群

    这几天尝试在k8s中搭建spark集群,踩了一些坑,跟大家分享一下。

    Spark的组件介绍可参考官方文档
    大数据生态圈简介可参考这篇文章

    基于k8s官方示例

    具体参考github k8s

    FAQ

    镜像拉取问题

    该方法需要访问gcr.io下载镜像(国内一般需要vpn),需要注意的是gcr.io/google_containers/spark:1.5.2_v1镜像不能使用index.tenxcloud.com/google_containers/spark替换,替换后拉取镜像时会出现“docker: filesystem layer verification failed”错误。

    可将zeppelin-controller.yaml使用的镜像修改为index.tenxcloud.com/google_containers/zeppelin:v0.5.6_v1

    webui service使用问题

    文档中的kubectl proxy –port=8001指令只能监听127.0.0.1的代理请求,不适用于测试环境和虚拟机环境,因为使用的ip地址不是127.0.0.1。
    此时使用kubectl proxy –port=8001 –address=\

    pyspark示例运行错误

    示例中的数据源存在问题,可使用本地文件运行,例如“sc.textFile(“/opt/spark/licenses/*”).map(lambda s: len(s.split())).sum()”

    Zeppelin webui使用问题

    同样只能通过localhost或127.0.0.1访问,可以通过将zeppelin service类型配置为NodePort。参考spark-20160427.zip中的zeppelin-service.yaml。
    使用方法为:

    • 使用zeppelin-service.yaml创建zeppelin service,可通过spec.ports.nodePort指定端口,不指定时为端口随机。
    • 使用kubectl describe svc zeppelin|grep NodePort指令查看端口。
    • 在浏览器中访问任意节点ip:NodePort访问zeppelin webui。
    • 点击“Create new note”,输入Note Name。
    • 在新页面中执行以下内容:

      %pyspark
      print sc.textFile("/opt/spark/licenses/*").map(lambda s: len(s.split())).sum()

    该示例会统计zeppelin本地/opt/spark/licenses/目录下的所有文件的单词数量,几秒后会看到执行结果。

    基于tenxcloud镜像库搭建

    需要根据k8s源码中的examples/spark/下的yaml文件搭建,将所有yaml文件复制到工作目录下。

    修改spark-master-controller.yaml和spark-worker-controller.yaml:
    * spec.template.spec.containers.command均修改为“/start.sh”
    * spec.template.spec.containers.images分别修改为index.tenxcloud.com/google_containers/spark-master:1.5.2_v1和index.tenxcloud.com/google_containers/spark-worker:1.5.2_v1

    zeppelin-controller.yaml使用的镜像修改为index.tenxcloud.com/google_containers/zeppelin:v0.5.6_v1

    修改完成后,按k8s官方示例的步骤启动即可。

    简易的spark-driver

    由于zeppelin镜像非常大,拉取会消耗很多时间。可以使用下面的spark-driver.yaml创建一个简易的spark-driver:

    kind: ReplicationController
    apiVersion: v1
    metadata:
      name: spark-driver 
    spec:
      replicas: 1
      selector:
        component: spark-driver
      template:
        metadata:
          labels:
            component: spark-driver
        spec:
          containers:
            - name: spark-driver
              image: index.tenxcloud.com/google_containers/spark-driver:1.5.2_v1
              resources:
                requests:
                  cpu: 100m
    

    创建后,使用kubectl exec <spark-driver-podname> -it pyspark即可访问。

    yaml配置参考这里

    展开全文
  • k8s中部署spark集群

    2020-02-27 00:16:43
    基于kubernetes部署的两种方式 直接使用kubernetes作为集群管理器(Cluster Manager),...第二是要求k8s版本大于1.6,但我这边版本1.5.1,线上在用,不太想升级,而spark只是想搭起来玩玩... 第二种方式是standa...

    基于kubernetes部署的两种方式

    • 直接使用kubernetes作为集群管理器(Cluster Manager),类似与mesos和yarn,使用方式可以看running-on-kubernetes。但是这个部署方式,一是还不成熟,不推荐在生产环境使用。第二是要求k8s版本大于1.6,但我这边版本1.5.1,线上在用,不太想升级,而spark只是想搭起来玩玩...
    • 第二种方式是standalone的方式,即便是不用集群也能很方便的用sbin下的脚本来部署,不过使用k8s有几个好处,一个是提高机器使用率。这边的k8s集群大部分是在白天使用,晚上空闲,刚好能拿来跑数据。二是方便一键扩容,一键升级,能复用本身在k8s集群上做好的监控以及日志收集

    在k8s上部署standalone集群

    以下内容主要依据github 上k8s example中spark的例子。做了一些适应版本的修改。

    首先我们需要一个有spark以及其依赖的的docker镜像,这边我就很简单的下载了spark-2.2.1-bin-hadoop2.7并放在了/opt目录下,打包的dockerfile就不发了,docker store上也有很多做好的镜像。另外,k8s需要有dns(现在似乎默认带的)。

    namespace

    为了方便管理,还是新建一个namespace,将所有的相关的都放在这个namespace下,方便资源管理。

     

    apiVersion: v1
    kind: Namespace
    metadata:
      name: "spark-cluster"
      labels:
        name: "spark-cluster"
    

    kubectl create -f namespace-spark-cluster.yaml 新建一个名为spark-cluster的namespace。

    master

    master分为两个部分,一个是类型为rc的主体,命名为spark-master-controller.yaml,另一部分为一个service,暴露master的端口给slaver使用。

     

    kind: ReplicationController
    apiVersion: v1
    metadata:
      name: spark-master-controller
    spec:
      replicas: 1
      selector:
        component: spk-master
      template:
        metadata:
          labels:
            component: spk-master
        spec:
          containers:
            - name: spk-master
              image: spark:2.2.1.1
              command: ["/bin/sh"]
              args: ["-c","sh /opt/spark-2.2.0-bin-hadoop2.7/sbin/start-master.sh && tail -f /opt/spark-2.2.0-bin-hadoop2.7/logs/spark--org.apache.spark.deploy.master.Master-1-*"]
              ports:
                - containerPort: 7077
                - containerPort: 8080
    

    以上为controller,直接使用spark的start-master脚本启动,但是启动后他会退到后台,导致k8s启动不了pod,所以还加了个tail -f一个master输出的log,顺便也方便查看log。

     

    kind: Service
    apiVersion: v1
    metadata:
      name: spk-master
    spec:
      ports:
        - port: 7077
          targetPort: 7077
          name: spark
        - port: 8080
          targetPort: 8080
          name: http
      selector:
        component: spk-master
    

    一个service,把7077端口和8080端口暴露出来给集群,方便slaver直接用spk-master:8080这样的方式进行访问。注意,只是暴露给集群,外部访问的方式最后会说。

    kubectl create -f spark-master-controller.yaml —namespace=spark-cluster

    kubectl create -f spark-master-service.yaml —namespace=spark-cluster

    这里有个坑,start-master这个启动脚本中会用到SPARK_MASTER_PORT这个参数,而上边这个service如果名字为spark-master的话刚好冲突了,会把SPARK_MASTER_PORT设置为 host:port的形式,导致脚本启动失败。所以我一股脑把所有的spark-master改成spk-master了

    worker

     

    kind: ReplicationController
    apiVersion: v1
    metadata:
      name: spark-worker-controller
    spec:
      replicas: 1
      selector:
        component: spark-worker
      template:
        metadata:
          labels:
            component: spark-worker
        spec:
          containers:
            - name: spark-worker
              image: spark:2.2.1.1
              command: ["/bin/sh"]
              args: ["-c","sh /opt/spark-2.2.0-bin-hadoop2.7/sbin/start-slave.sh spark://spk-master.spark-cluster:7077;tail -f /opt/spark-2.2.0-bin-hadoop2.7/logs/spark--org.apache.spark.deploy.worker.Worker*"]
              ports:
                - containerPort: 8081
              resources:
                requests:
                  cpu: "1"
                  memory: "10Gi"
                limits:
                  cpu: "2"
                  memory: "12Gi"
    

    kubectl create -f spark-worker-controller.yaml —namespace=spark-cluster

    启动worker脚本中需要传入master的地址,因为有dns且设置了service的缘故,可以通过spk-master.spark-cluster访问。把replicas设置为N即可启动N个worker。另外,我还在worker上加了资源的限制,限制最多使用2个cpu以及12g内存。

    proxy

    image为elsonrodriguez/spark-ui-proxy:1.0 这玩意在一般启动standalone集群的时候是没有的,但是在k8s集群里边,则必不可缺。

    设想一下,如果只是简单的暴露master的8080端口出来,我们只能看到master的管理页面,但是进一步从master访问worker的ui则变得不太现实(每个worker都有自己的ui地址,且ip分配很随机,这些ip只能在集群内部访问)。所以我们需要一个代理服务,从内部访问完我们需要的页面后,返回给我们,这样我们只需要暴露一个代理的地址即可。

     

    kind: ReplicationController
    apiVersion: v1
    metadata:
      name: spark-ui-proxy-controller
    spec:
      replicas: 1
      selector:
        component: spark-ui-proxy
      template:
        metadata:
          labels:
            component: spark-ui-proxy
        spec:
          containers:
            - name: spark-ui-proxy
              image: elsonrodriguez/spark-ui-proxy:1.0
              ports:
                - containerPort: 80
              resources:
                requests:
                  cpu: 100m
              args:
                - spk-master:8080
              livenessProbe:
                  httpGet:
                    path: /
                    port: 80
                  initialDelaySeconds: 120
                  timeoutSeconds: 5
    

    kubectl create -f spark-ui-proxy-controller.yaml —namespace=spark-cluster

    并且暴露proxy的80端口

     

    kind: Service
    apiVersion: v1
    metadata:
      name: spark-ui-proxy
    spec:
      type: NodePort
      ports:
        - port: 80
          targetPort: 80
          nodePort: 32180
      selector:
        component: spark-ui-proxy
    

    kubectl create -f spark-ui-proxy-service.yaml —namespace=spark-cluster

    至此,集群搭建完毕。可以通过集群的32180端口访问管理页面

    展开全文
  • hadoop组件—spark实战----spark on k8s模式k8s原生方式安装spark2.4.4 cluster mode hadoop组件—spark实战----spark on k8s模式k8s原生方式—cluster mode调用运行spark程序 本篇文章尝试安装client mode。 两种...

    我们在之前的文章中已经安装了cluster mode模式和尝试了使用。

    hadoop组件—spark实战----spark on k8s模式k8s原生方式安装spark2.4.4 cluster mode

    hadoop组件—spark实战----spark on k8s模式k8s原生方式—cluster mode调用运行spark程序

    本篇文章尝试安装client mode。

    两种模式的区别

    在这里插入图片描述

    cluster mode

    Driver程序在k8s的pod中运行,应用的运行结果不能在客户端显示。只能通过pod的log来查看相关结果输出。当运算任务运行完毕后,driver程序存在的pod会被销毁。

    client mode

    Driver运行在Client(某个node服务器)上,应用程序运行结果会在服务器的终端打印显示,driver会一直保留,除非手动关闭。

    允许用户运行spark-shell或Notebook,可以是集群之外的单独机器,或者是k8s集群的pod。

    client mode要求用户保证driver与k8s集群内executor之间的连通性。

    如果driver运行在ks8集群的pod内,推荐使用headless service以允许executor通过FQDN连接到driver;

    如果driver运行在k8s集群之外,用户需要确保集群内的executor Pod可访问到driver。

    **

    创建镜像和部署的yaml

    因为client mode需要与k8s有很好的连通性,以及权限之间的处理,所以 如果我们使用k8s集群节点之外的 服务器node作为client,那么会遇到 找不到executor等问题。

    所以最好的方案就是
    1、使用k8s集群中的node作为client
    2、启动一个pod作为client

    我们这里使用方案2,启动一个pod作为client。
    也就是 创建一个包含 spark安装包的镜像发布到 k8s中的pod。

    在包含spark安装目录的 目录中创建Dockerfile

    使用命令

    zhangxiofansmbp:spark joe$ ls
    spark-2.4.4-bin-hadoop2.7	spark-2.4.4-bin-hadoop2.7.tgz
    zhangxiofansmbp:spark joe$ vi Dockerfile
    

    输入内容:

    FROM williamyeh/java8
    
    WORKDIR /spark
    
    COPY spark-2.4.4-bin-hadoop2.7 /spark/spark-2.4.4-bin-hadoop2.7
    
    ENTRYPOINT [ "" ]
    

    我们这里使用williamyeh/java8作为基础镜像

    也可以使用其他java8的基础镜像,使用命令查找

    zhangxiofansmbp:spark joe$ docker search java8
    NAME                                    DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
    williamyeh/java8                        Oracle Java 8 image for Docker                  7                                       [OK]
    fiadliel/java8-jre                      Java 8 JRE image, based off Alpine Linux, in…   6  
    

    构建镜像使用命令

    docker build -t  spark-client:2.4.4  .
    docker tag  spark-client:2.4.4  <repo>/spark-client:2.4.4
    docker push <repo>/spark-client:2.4.4
    

    上传成功后 我们就得到了一个client的镜像地址,如:
    123.dkr.ecr.cn-northwest-1.amazonaws.com.cn/spark-client:2.4.4

    创建一个yaml文件用来deploy一个pod。

    使用命令如下:

    vi spark-client.yaml
    

    输入内容如下:

    apiVersion: v1
    kind: Pod
    metadata:
      name: spark-client-test
      labels:
        name: spark-client-test
    spec:
      hostname: spark-client-test
      containers:
        - name: spark-client-test
          image: 123.dkr.ecr.cn-northwest-1.amazonaws.com.cn/spark-client:2.4.4
          imagePullPolicy: IfNotPresent
          resources:
            requests:
               cpu: 100m
               memory: 512Mi
          command: ["/bin/sh","-c"]
          args: ['ls /spark;date;sleep 10m;date']
    
    
    

    yaml中增加headless-services内容

    client mode 需要注意 spark.kubernetes.driver.pod.name参数的配置,如果没有这个配置,默认是使用pod的hostname作为 spark.kubernetes.driver.pod.name,这样有可能导致executor连接不到driver,上报不了结果。

    如图:
    在这里插入图片描述

    所以我们需要 这个作为client的pod 需要 有一个固定的可以访问的 地址。

    这里我们需要借助k8s的headless-services功能。

    详情可参考k8s官网headless-services

    Headless Services是一种特殊的service,设置spec:clusterIP 为None,这样在实际运行时就不会被分配ClusterIP 。

    有时候我们创建的服务不想走 负载均衡,想直接通过 pod-ip 访问,但是在pod里又获取不到pod本身得ip地址,怎么办呢, 使用headless service接可以解决。

    首先kube-dns解析servicename:port 就会变成podIP:port。 如果设置headless-services的servicename与pod的的hostname一样,那么kube-dns解析servicename:port 就与podhostname:port 一样。达到了获得实际podIP的目的。

    apiVersion: v1
    kind: Service
    metadata:
      name: spark-client-test
    spec:
      clusterIP: None
      selector:
        name: spark-client-test
      ports:
        - protocol: TCP
          port: 8888
          targetPort: 8888
    

    则完整的yaml内容如下:

    apiVersion: v1
    kind: Pod
    metadata:
      name: spark-client-test
      labels:
        name: spark-client-test
    spec:
      hostname: spark-client-test
      containers:
        - name: spark-client-test
          image: 123.dkr.ecr.cn-northwest-1.amazonaws.com.cn/spark-client:2.4.4
          imagePullPolicy: IfNotPresent
          resources:
            requests:
               cpu: 100m
               memory: 512Mi
          command: ["/bin/sh","-c"]
          args: ['ls /spark;date;sleep 10m;date']
    
    ---
    
    apiVersion: v1
    kind: Service
    metadata:
      name: spark-client-test
    spec:
      clusterIP: None
      selector:
        name: spark-client-test
      ports:
        - protocol: TCP
          port: 8888
          targetPort: 8888
    
    

    注意 servicename 需要与pod的name 同名。

    hostname 需要与 servicename 同名。

    开始部署client mode的pod

    运行命令创建pod

    kubectl   create -f spark-client.yaml
    

    使用命令查看pod状态

    [comm@localhost sparktest]$ kubectl get pods|grep spark
    spark-client-test                                          1/1       Running       0          68s
    

    当pod的状态为running时,我们就可以进入pod中运行spark的命令了。

    使用命令进入pod

    kubectl exec -ti spark-client-test  -- bash
    

    进入pod后查看目录中的文件是否正常

    [zzq@localhost sparktest]$ kubectl exec -ti spark-client-test  -- bash
    root@spark-client-test-c9fbbc45d-46j9t:/spark# 
    root@spark-client-test-c9fbbc45d-46j9t:/spark# 
    root@spark-client-test-c9fbbc45d-46j9t:/spark# ls
    spark-2.4.4-bin-hadoop2.7
    root@spark-client-test-c9fbbc45d-46j9t:/spark# cd spark-2.4.4-bin-hadoop2.7/
    root@spark-client-test-c9fbbc45d-46j9t:/spark/spark-2.4.4-bin-hadoop2.7# ls
    LICENSE  NOTICE  R  README.md  RELEASE	bin  conf  data  examples  jars  kubernetes  licenses  python  sbin  yarn
    root@spark-client-test-c9fbbc45d-46j9t:/spark/spark-2.4.4-bin-hadoop2.7# 
    

    运行spark-submit

    运行spark-submit 的client mode 模式提交spark任务 使用命令

    $bin/spark-submit \
    --master k8s://https://<k8s-apiserver-host>:<k8s-apiserver-port> \
    --deploy-mode client \
    --name spark-pi  \
    --class org.apache.spark.examples.SparkPi \
    --conf spark.executor.instances=1  \
    --conf spark.kubernetes.container.image=<spark-image>  \
    ./examples/jars/spark-examples_2.11-2.4.4.jar
    

    其中 master 就是 kubernetes 的 apiserver 地址。

    获取apiserver的方法,使用命令

    kubectl cluster-info
    

    输出如下:

    zhangxiaofans-MacBook-Pro:spark-2.4.4-bin-hadoop2.7 joe$ kubectl cluster-info
    Kubernetes master is running at https://123.cn-northwest-1.elb.amazonaws.com.cn
    
    KubeDNS is running at https://123.cn-northwest-1.elb.amazonaws.com.cn/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
    
    kubernetes-dashboard is running at https://123.cn-northwest-1.elb.amazonaws.com.cn/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:https/proxy
    

    这里使用的是 master的 url。

    https://123.cn-northwest-1.elb.amazonaws.com.cn
    

    有些master url是带有端口的,则端口也需要带上。

    我使用的命令如下:

    bin/spark-submit \
     --master k8s://https://123.cn-northwest-1.elb.amazonaws.com.cn \
     --deploy-mode client \
     --name spark-SparkPi  \
     --class org.apache.spark.examples.SparkPi \
     --conf spark.executor.instances=1  \
     --conf spark.kubernetes.container.image=123.dkr.ecr.cn-northwest-1.amazonaws.com.cn/spark/spark\
     --conf spark.kubernetes.submission.waitAppCompletion=false  \
      ./examples/jars/spark-examples_2.11-2.4.4.jar
    

    也可以使用命令查找api-server所在的node节点内部ip作为master url。

    kubectl get pods -n kube-system -o wide
    

    输出如下:

    kube-apiserver-ip-10-30-22-78.cn-northwest-1.compute.internal            1/1       Running   4          97d       10.30.22.78    ip-10-30-22-78.cn-northwest-1.compute.internal    <none>
    
    

    因为pod在 Node 上运行时,kubelet 会为每个活跃的 Service 添加一组环境变量。也就是

    kubectl exec spark-client-test -- printenv | grep SERVICE
    KUBERNETES_SERVICE_HOST=10.0.0.1
    KUBERNETES_SERVICE_PORT=443
    KUBERNETES_SERVICE_PORT_HTTPS=443
    

    所以在pod内部 我们也可以使用这几个变量作为master url来提交命令行如下:

    bin/spark-submit \
      --master k8s://https://$KUBERNETES_SERVICE_HOST:$KUBERNETES_SERVICE_PORT \
     --deploy-mode client \
     --name spark-SparkPi  \
     --class org.apache.spark.examples.SparkPi \
     --conf spark.executor.instances=1  \
     --conf spark.kubernetes.container.image=123.dkr.ecr.cn-northwest-1.amazonaws.com.cn/spark/spark  \
     --conf spark.kubernetes.submission.waitAppCompletion=false  \
      ./examples/jars/spark-examples_2.11-2.4.4.jar
    

    运行spark shell

    因为pod在 Node 上运行时,kubelet 会为每个活跃的 Service 添加一组环境变量。也就是

    kubectl exec spark-client-test-757ff6cc45-blfjf -- printenv | grep SERVICE
    KUBERNETES_SERVICE_HOST=10.0.0.1
    KUBERNETES_SERVICE_PORT=443
    KUBERNETES_SERVICE_PORT_HTTPS=443
    

    所以在pod内部 我们也可以使用这几个变量作为master url来提交命令行如下:

    	 bin/spark-shell \
         --master k8s://https://$KUBERNETES_SERVICE_HOST:$KUBERNETES_SERVICE_PORT \
        --deploy-mode client \
        --name spark-shell \
        --driver-memory 512M \
        --executor-memory 512M \
        --conf spark.executor.instances=2 \
        --conf spark.kubernetes.container.image=123.dkr.ecr.cn-northwest-1.amazonaws.com.cn/spark/spark
    

    可能遇到的问题–Caused by: java.net.ConnectException: Connection refused (Connection refused)

    考虑网络联通性设置和api-server的地址端口是否正确。

    权限问题可以尝试创建权限如下:

    kubectl create rolebinding default-admin --clusterrole=admin --serviceaccount=default:default --namespace=default
    

    参考链接

    client mode使用

    构建镜像参考

    Pod 与 Service 的 DNS

    除了使用headless service,还有另一个方案
    在k8s中搭建可解析hostname的DNS服务**

    展开全文
  • 在本文的例子中,你将使用 ...你将使用 Spark standalone 模式 安装一个 Spark master 服务和一组 Spark workers 。 源代码 Docker 镜像主要基于 https://github.com/mattf/docker-spark 源码托管在 https://github....

    在本文的例子中,你将使用 Kubernetes 和 Docker 创建一个功能型 Apache Spark 集群。

    你将使用 Spark standalone 模式 安装一个 Spark master 服务和一组 Spark workers 。

    源代码

    Docker 镜像主要基于 https://github.com/mattf/docker-spark

    源码托管在 https://github.com/kubernetes/application-images/tree/master/spark

    准备工作

    本示例假定你已经具备以下条件:

    ● 有已安装并运行的 kubernetes 集群。
    ● 已在某个 path 路径中安装了 kubectl 命令行工具。
    ● 已运行了一个 spark-master 的 k8s service ,可以使用‘ spark-master ’域名在 kube DNS 实例中自动发现该服务。

    更多详细内容可在源码的 Dockerfile 中查看。

    第一步:创建命名空间

    $ kubectl create -f examples/spark/namespace-spark-cluster.yaml
    

    现在列出所有命名空间:

    $ kubectl get namespaces
    NAME          LABELS             STATUS
    default       <none>             Active
    spark-cluster name=spark-cluster Active
    

    对于 kubectl 客户端使用的命名空间,我们定义一个环境并使用它:

    $ kubectl config set-context spark --namespace=spark-cluster --cluster=${CLUSTER_NAME} --user=${USER_NAME}
    $ kubectl config use-context spark
    

    你可以在 Kubernetes 配置文件~/.kube/config 中查看集群名称以及用户名称。

    第二步:启动你的 master 服务

    Master service 是 Spark 集群的 master 服务。 使用 examples/spark/spark-master-controller.yaml 文件来创建一个 replication controller 运行 Spark Master 服务。

    $ kubectl create -f examples/spark/spark-master-controller.yaml
    replicationcontroller "spark-master-controller" created
    

    然后,用 examples/spark/spark-master-service.yaml 文件来创建一个逻辑上的服务端点, Spark workers 可以使用该服务来访问 Master pod

    $ kubectl create -f examples/spark/spark-master-service.yaml
    service "spark-master" created
    

    然后你可以为 Spark Master WebUI 创建一个服务:

    $ kubectl create -f examples/spark/spark-webui.yaml
    service "spark-webui" created
    

    查看 Master 是否能运行和可访问

    $ kubectl get podsNAME                            READY     STATUS    RESTARTS   AGEspark-master-controller-5u0q5   1/1       Running   0          8m
    

    检查日志以查看 master 的状态。(使用上一条指令输出的 pod 名称)

    {{{$ kubectl logs spark-master-controller-5u0q5
    starting org.apache.spark.deploy.master.Master, logging to /opt/spark
    -1.5.1-bin-hadoop2.6/sbin/../logs/spark--org.apache.spark.deploy.master.
    - Master-1-spark-
    master-controller-g0oao.out
    Spark Command: /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java -cp /
    opt/spark-1.5.1-bin-hadoop2.6/sbin/../conf/:/opt/spark-1.5.1-bin-
    hadoop2.6/lib/spark-assembly-1.5.1-hadoop2.6.0.jar:/opt/spark-1.5.1
    -bin-hadoop2.6/lib/datanucleus-rdbms-3.2.9.jar:/opt/spark-1.5.1-bin
    - -hadoop2.6/lib/datanucleus-core-3.2.10.jar:/opt/spark-1.5.1-bin-
    - hadoop2.6/lib/datanucleus-api-jdo-3.2.6.jar -Xms1g -Xmx1g org.apache.spark.deploy.master.Master --ip spark-master --port 7077
    -  --webui-port 8080
    ========================================
    15/10/27 21:25:05 INFO Master: Registered signal handlers for 
    [TERM, HUP, INT]
    15/10/27 21:25:05 INFO SecurityManager: Changing view acls to: root
    15/10/27 21:25:05 INFO SecurityManager: Changing modify acls to: root
    15/10/27 21:25:05 INFO SecurityManager: SecurityManager: authentication 
    disabled; ui acls disabled; users with view permissions: Set(root); users with 
    modify permissions: Set(root)
    15/10/27 21:25:06 INFO Slf4jLogger: Slf4jLogger started
    15/10/27 21:25:06 INFO Remoting: Starting remoting
    15/10/27 21:25:06 INFO Remoting: Remoting started; listening on addresses :[akka.tcp://sparkMaster@spark-master:7077]
    15/10/27 21:25:06 INFO Utils: Successfully started service 'sparkMaster' on port 
    7077.
    15/10/27 21:25:07 INFO Master: Starting Spark master at spark://spark-master:
    7077
    15/10/27 21:25:07 INFO Master: Running Spark version 1.5.1
    15/10/27 21:25:07 INFO Utils: Successfully started service 'MasterUI' on 
    port 8080.
    15/10/27 21:25:07 INFO MasterWebUI: Started MasterWebUI at http://
    spark-master:8080
    15/10/27 21:25:07 INFO Utils: Successfully started service on port 6066.
    15/10/27 21:25:07 INFO StandaloneRestServer: Started REST server for
     submitting applications on port 6066
    15/10/27 21:25:07 INFO Master: I have been elected leader! New state: ALIVE}}}
    

    确认 master 正常运行后,你可以使用 k8s 集群代理访问 Spark WebUI :

    kubectl proxy --port=8001
    

    此时可以通过 http://localhost:8001/api/v1/proxy/namespaces/spark-cluster/services/spark-webui/访问 UI

    第三步:启动 Spark workers
    Spark workers 在 Spark 集群中扮演十分重要的角色。他们为程序提供执行资源和数据缓存功能。

    Spark workers 需要 Master service 处于运行状态。

    使用 examples/spark/spark-worker-controller.yaml 文件创建一个 replication controller 来管理 worker pods 。

    $ kubectl create -f examples/spark/spark-worker-controller.yaml
    replicationcontroller "spark-worker-controller" created
    

    查看 workers 是否正常运行

    如果你启动 Spark WebUI ,当 worker 就绪后应该出现在 UI 中。(这可能需要一些时间来拉取镜像并启动 pods 。)你也可以用以下方式查询状态:

    $ kubectl get pods
    NAME                            READY     STATUS    RESTARTS   AGE
    spark-master-controller-5u0q5   1/1       Running   0          25m
    spark-worker-controller-e8otp   1/1       Running   0          6m
    spark-worker-controller-fiivl   1/1       Running   0          6m
    spark-worker-controller-ytc7o   1/1       Running   0          6m
    

    查看运行日志

    $ kubectl logs spark-master-controller-5u0q5
    [...]
    15/10/26 18:20:14 INFO Master: Registering worker 10.244.1.13:53567 
    with 2 cores, 6.3 GB RAM
    15/10/26 18:20:14 INFO Master: Registering worker 10.244.2.7:46195
     with 2 cores, 6.3 GB RAM
    15/10/26 18:20:14 INFO Master: Registering worker 10.244.3.8:39926 
    with 2 cores, 6.3 GB RAM
    

    假如上一节中 kubectl proxy 仍在运行,你应该也能在 UI 中看到 workers 。

    注: UI 将含有到 worker Web UI 的超链接。 这些链接是不能正常工作的(链接将尝试连接到集群 IP ,而 Kubernetes 不会自动代理的集群 IP )。

    第四步:在 Spark 集群中启动 Zeppelin UI 来加载工作任务
    Zeppelin UI pod 可以用来在 Spark 集群加载 jobs ,加载操作既可以通过 web 端的笔记本完成,也可以通过传统的 Spark 命令行方式完成。更多细节见 Zeppelin 和 Spark architecture 架构。

    
    $ kubectl create -f examples/spark/zeppelin-controller.yaml
    replicationcontroller "zeppelin-controller" created
    

    Zeppelin 需要 Master service 处于运行状态。

    查看 Zeppelin 是否正常运行

    $ kubectl get pods -l component=zeppelin
    NAME                        READY     STATUS    RESTARTS   AGE
    zeppelin-controller-ja09s   1/1       Running   0          53s
    

    第五步:操作集群
    现在你有两个选择:可以通过图形界面访问 Spark 集群,也可以保持使用 CLI 。

    快速使用 pyspark

    使用 kubectl exec 连接到 Zeppelin 驱动并运行 pipeline 。

    $ kubectl exec zeppelin-controller-ja09s -it pyspark
    Python 2.7.9 (default, Mar  1 2015, 12:57:24)
    [GCC 4.9.2] on linux2
    Type "help", "copyright", "credits" or "license" for more
     information.
    Welcome to
          ____              __
         / __/__  ___ _____/ /__
        _\ \/ _ \/ _ `/ __/  '_/
       /__ / .__/\_,_/_/ /_/\_\   version 1.5.1
          /_/
    Using Python version 2.7.9 (default, Mar  1 2015 12:57:24)
    SparkContext available as sc, HiveContext available as sqlContext.
    >>> sc.textFile("gs://dataflow-samples/shakespeare/*").map
    (lambda s: len(s.split())).sum()
    939193
    

    恭喜你,你把所有莎士比亚戏剧中的单词个数统计出来了。

    使用图形界面,亮瞎你的眼!

    使用之前创建的 Zeppelin pod ,设置 WebUI 的转发端口:

    $ kubectl port-forward zeppelin-controller-ja09s 8080:8080
    

    这条指令将访问 localhost 8080 端口的请求转发到容器中的 8080 端口。然后你可以通过 https://localhost:8080/ 访问 Zeppelin 。

    创建一个“ New Notebook ”。在其中输入:

    %pyspark
    print sc.textFile("gs://dataflow-samples/shakespeare/*").map
    (lambda s: len(s.split())).sum()
    

    结论

    现在你已为 Spark master , Spark workers 和 Spark driver 创建了 service 和 replication controller 。你可以用这个例子来进行下一步,并开始使用刚才创建的 Apache Spark 集群,更多信息见 Spark 文档。

    kubectl create -f examples/spark
    

    设置后:

    kubectl get pods # Make sure everything is running
    kubectl proxy --port=8001 # Start an application proxy, if you want
     to see the Spark Master WebUI
    kubectl get pods -lcomponent=zeppelin # Get the driver pod to interact
     with.
    

    此时 Master UI 可以通过 http://localhost:8001/api/v1/proxy/namespaces/spark-cluster/services/spark-webui/访问。

    你可以通过 kubectl exec 使用传统的 spark-shell / spark-subsubmit / pyspark 命令行与 Spark 集群进行交互,或者如果你想与 Zeppelin 交互:

    kubectl port-forward zeppelin-controller-abc123 8080:8080 &
    kubectl port-forward zeppelin-controller-abc123 8080:8080 &
    

    然后访问 http://localhost:8080/

    使用 Spark 的已知问题

    ● 该方案提供了一个仅限于集群网络的 Spark 配置,这意味着 Spark master 只能通过集群 service 访问。如果你需要在 zeppelin pod 中使用除了 Zeppelin 或 spark-submit 之外的外部客户端来提交 jobs ,你需要为客户端提供一种访问 examples/spark/spark-master-service.yaml 的方式。参见 service 以了解更多信息。

    使用 Zeppelin 的已知问题

    ● Zeppelin pod 很大,因此拉取镜像可能会消耗一段时间,拉取速度取决于你的网络条件。 Zeppelin pod 的尺寸是我们正要解决的问题,详见问题# 17231 。 ● 第一次运行 Zeppelin 时, pipeline 可能会花费很多时间(约一分钟)。似乎需要相当多的时间来加载。 ● 在 GKE 环境中, kubectl port-forward 不可能长时间保持稳定状态。如果你发现 Zeppelin 变成断开状态, port-forward 很可能出现故障,并需要重启。详见# 12179 。

    原文链接: https://github.com/kubernetes/kubernetes/blob/release-1.3/examples/spark/README.md
    译文链接: https://www.v2ex.com/amp/t/301395

    展开全文
  • 我们在之前的文章中 已经了解了 spark支持的模式,其中一种就是 使用k8s进行管理。 hadoop组件—spark----全面了解spark以及与hadoop的区别 是时候考虑让你的 Spark 跑在K8s 上了 spark on k8s的优势–为什么要把...
  • Spark on K8Sspark-on-kubernetes-operator)环境搭建以及demo过程环境要求基本原理环境安装kubernetes 1.13环境安装Spark-on-kubernetes-operator环境安装关于kerberos 环境要求 Operator Version:最新即可 ...
  • hadoop组件—spark实战----spark on k8s模式k8s原生方式安装spark2.4.4 client mode提交python程序和运行pyspark 不过 使用的方式 是spark-submit 或者 pyspark 来启动 spark on k8s。 但是 一般 我们进行业务编程,...
  • hadoop组件—spark实战----spark on k8s模式k8s原生方式安装spark2.4.4 client mode提交python程序和运行pyspark 本篇文章记录 在client pod中使用spark-submit提交python程序在spark on k8s中访问s3。 进入c...
  • 我们在上篇文章中已经记录了 如果 安装spark on k8s模式k8s原生方式—cluster mode。 hadoop组件—spark实战----spark on k8s模式k8s原生方式安装spark2.4.4 cluster mode 本章记录 cluster mode这种方式的spark集群...
  • 目前最新稳定版本2.4.4的...2、已经在运行的k8s集群版本需要大于1.6 使用命令查询 kubectl version 输出为: zhangxiaofans-MacBook-Pro:Downloads joe$ kubectl version Client Version: version.Info{Major:"1", M...
  • 一般我们在运行spark任务时,需要查看他的运行情况。 比较常用的方式就是在...spark on k8s比较特别的是 driver是一个在k8s集群中临时启动的pod,它一般没有外部ip,只有k8s的内部ip,同时这个内部ip 每次driver...
  • Spark on k8s 试用步骤

    2018-03-13 15:06:32
    Spark 2.3.0 开始支持使用k8s 作为资源管理原生调度spark。使用k8s原生调度的spark主要有以下好处: 采用k8s原生调度,不再需要二级调度,直接使用k8s原生的调度模块,实现与其他应用的混布; 资源隔离:任务...
  • Spark on K8Sspark-on-kubernetes-operator)环境搭建以及demo过程(二)Spark Demo过程中的常见问题Spark的executor/driver怎么持久化日志如何让Spark程序可以连接HDFS集群如何对hadoop的参数进行配置如何让...
  • 由于Spark的抽象设计,我们可以使用第三方资源管理平台调度和管理Spark作业,比如Yarn、Mesos和Kubernetes。 基本原理 基本原理当我们通过spark-submit将Spark作业提交到Kubernetes集群时,会执行以下流程: ...
  • 关于服务器k8s的部分这里不讨论,我们考论如何用一个已经好的k8s来进行部署spark安装配置 kubectl 和 Helm CLI 在本地计算机上安装和配置 kubectl。 参见...
  • 【摘要】 Spark社区在2.3版本开始,已经可以很好的支持跑着Kubernetes上了。这样对于统一资源池,提高整体资源利用率,...相信玩Spark的你已经注意到最新的Spark版本已经支持不做任何修改可以直接跑在K8S上了,即...
  • hadoop组件—spark实战----spark on k8s模式k8s原生方式安装spark2.4.4 client mode和使用 本篇文章记录运行pyspark和提交python程序。 制作有python和java环境和包含有spark2.4.4客户端的镜像 ...
  • Spark on k8s 全新手入门教程
  • 文章目录1 Overview2 译文2.2 A Deeper Look At Spark-Submit2.3 How Does Spark-Submit Work2.4 A Look At Kubernetes Operator For Apache Spark2.4 How Kubernetes Operator For Spark Works3 Summary ...
1 2 3 4 5 ... 20
收藏数 3,060
精华内容 1,224
关键字:

k8s如何安装spark