堆栈内存溢出
  繁体   English   中英

如何将Spark Client SubmitApplication转换为Yarn Rest API？

[英]How can I translate a Spark Client submitApplication to Yarn Rest API?

 原文  2018-12-09 09:45:06  9   1    java/ rest/ apache-spark/ hadoop/ yarn

问题描述

目前，我有一个工作代码实现，可以使用spark.deploy.yarn.Client向Yarn提交应用程序。 聚合此客户端所需的所有参数很复杂，但是提交应用程序很简单： 

ClientArguments cArgs = new ClientArguments(args.toArray(new String[0]));
client = new Client(cArgs, sparkConf);
applicationID = client.submitApplication();

在此之前，大多数代码都在累积sparkConf和args 。 现在，我希望退休客户并仅使用Rest。 Spark提供了包括提交应用程序在内的完整REST API-根据Spark文档，这是一个简单的json / xml帖子的问题： 

POST http://<rm http address:port>/ws/v1/cluster/apps
Accept: application/json
Content-Type: application/json
{
  "application-id":"application_1404203615263_0001",
  "application-name":"test",
  "am-container-spec":
{
  "local-resources":
  {
    "entry":
    [
      {
        "key":"AppMaster.jar",
        "value":
        {
          "resource":"hdfs://hdfs-namenode:9000/user/testuser/DistributedShell/demo-app/AppMaster.jar",
          "type":"FILE",
          "visibility":"APPLICATION",
          "size": 43004,
          "timestamp": 1405452071209
        }
      }
    ]
  },
  "commands":
  {
    "command":"{{JAVA_HOME}}/bin/java -Xmx10m org.apache.hadoop.yarn.applications.distributedshell.ApplicationMaster --container_memory 10 --container_vcores 1 --num_containers 1 --priority 0 1><LOG_DIR>/AppMaster.stdout 2><LOG_DIR>/AppMaster.stderr"
  },
  "environment":
  {
    "entry":
    [
      {
        "key": "DISTRIBUTEDSHELLSCRIPTTIMESTAMP",
        "value": "1405459400754"
      },
      {
        "key": "CLASSPATH",
        "value": "{{CLASSPATH}}<CPS>./*<CPS>{{HADOOP_CONF_DIR}}<CPS>{{HADOOP_COMMON_HOME}}/share/hadoop/common/*<CPS>{{HADOOP_COMMON_HOME}}/share/hadoop/common/lib/*<CPS>{{HADOOP_HDFS_HOME}}/share/hadoop/hdfs/*<CPS>{{HADOOP_HDFS_HOME}}/share/hadoop/hdfs/lib/*<CPS>{{HADOOP_YARN_HOME}}/share/hadoop/yarn/*<CPS>{{HADOOP_YARN_HOME}}/share/hadoop/yarn/lib/*<CPS>./log4j.properties"
      },
      {
        "key": "DISTRIBUTEDSHELLSCRIPTLEN",
        "value": "6"
      },
      {
        "key": "DISTRIBUTEDSHELLSCRIPTLOCATION",
        "value": "hdfs://hdfs-namenode:9000/user/testuser/demo-app/shellCommands"
      }
    ]
  }
},
"unmanaged-AM":false,
"max-app-attempts":2,
"resource":
{
  "memory":1024,
  "vCores":1
},
"application-type":"YARN",
"keep-containers-across-application-attempts":false,
"log-aggregation-context":
{
  "log-include-pattern":"file1",
  "log-exclude-pattern":"file2",
  "rolled-log-include-pattern":"file3",
  "rolled-log-exclude-pattern":"file4",
  "log-aggregation-policy-class-name":"org.apache.hadoop.yarn.server.nodemanager.containermanager.logaggregation.AllContainerLogAggregationPolicy",
  "log-aggregation-policy-parameters":""
},
"attempt-failures-validity-interval":3600000,
"reservation-id":"reservation_1454114874_1",
"am-black-listing-requests":
{
  "am-black-listing-enabled":true,
  "disable-failure-threshold":0.01
}
}

我试图将参数转换为POST请求的JSON主体，但这似乎是不可能的。 有人知道我是否可以对提交了JSON有效负载以通过REST发送的正在运行的应用程序进行逆向工程吗？ 或者我可以使用什么映射来获取Client参数并将其放在JSON中？

1 个解决方案

解决方案1
 0 已采纳  2018-12-24 15:22:24

经过一番搜索，我设法仅通过REST API提交了一个应用程序。 这不是一个有据可查的过程，所以我在这里发布。

注意：如果您希望在任何时候将请求的内容与客户端发送的请求进行比较，请使用调试断点检查客户端使用的应用程序上下文。 打开类org.apache.hadoop.yarn.client.api.impl.YarnClientImpl然后转到方法submitApplication(ApplicationSubmissionContext appContext) 。

首先，要将spark.deploy.yarn.Client替换为REST API请求，解决方案必须确保配置中提到的所有文件在HDFS上均可用。 稍后，它需要__spark_conf__.zip并上传一个名为__spark_conf__.zip额外文件。

第1步

SparkConf的文件（ Client的第二个参数）：“ AllJars ”标签中提到的文件，“ mainJarPath ”中提到的文件和“ FilesList ”中提到的文件。

对于每个文件，检查它是否存在于HDFS中；如果不存在，请从本地计算机上载它。 对于每个文件，从HDFS中获取其FileStatus 。 聚合资源列表，这是包含以下六个属性的每个文件的属性映射：

  • 大小= getLen（）
  • 时间戳= getModificationTime（）
  • 类型= FILE
  • 能见度=公开

另外两个属性：键和资源。

  • allJars列表中的文件：密钥是spark_libs / {{filename}}，资源是文件名。
  • 来自FilesList的文件：键是“ localEntry”标记，资源是“ hdfsPath”标记。
  • mainJarPath中的File：键是“ app .jar”，资源是文件名。

第2步

创建__spark_conf__.zip文件。 您可以在hdfs中的登台路径（通常为{{HDFS_base_folder}}/user/{{username}}/.sparkStaging/{{application_id}}/__spark_conf__.zip直接创建它。 该存档文件包含两个文件和一个空目录：一个文件__spark_hadoop_conf__.xml （重命名为core-site.xml ），另一个文件名为__spark_conf__.properties ，它是配置中sparkConf部分的稍作修改的版本。

要创建__spark_conf__.properties您需要从“ sparkConf”->“ org $ apache $ spark $ SparkConf $$ settings ”读取JSON映射，并转换JSON格式“ spark.safemine.addcontrol.driverMemory”中的每一行： “ 5120M”到spark.safemine.addcontrol.driverMemory = 5120M

在文件的底部添加6行：

  • spark.yarn.cache.confArchive = {{的位置，你将上传__spark_conf__.zip在sparkStaging}}
  • spark.yarn.cache.visibilities = {{文件的所有可见性，以逗号分隔-基本上是“ PUBLIC，PUBLIC，...，PUBLIC”}}
  • spark.yarn.cache.timestamps = {{文件的所有时间戳，以逗号分隔}}
  • spark.yarn.cache.types = {{所有文件的类型，以逗号分隔-基本上是“ FILE，FILE，...，FILE”}}
  • spark.yarn.cache.filenames = {{所有文件名和密钥，记录为resource＃key和逗号分隔}}
  • spark.yarn.cache.sizes = {{文件的所有大小，以逗号分隔}}

确保按相应顺序编译5条汇总行。 我使用以下代码： 

    String confArchive = "spark.yarn.cache.confArchive="+hdfs+"/user/"+userName+"/.sparkStaging/"+applicationId+"/__spark_conf__.zip";
    String filenames = "spark.yarn.cache.filenames=";
    String sizes = "spark.yarn.cache.sizes=";
    String timestamps = "spark.yarn.cache.timestamps=";
    String types = "spark.yarn.cache.types=";
    String visibilities = "spark.yarn.cache.visibilities=";
    for (Map<String,String> localResource:localResources) {
        filenames+=localResource.get("resource")+"#"+localResource.get("key")+",";
        sizes+=localResource.get("size")+",";
        timestamps+=localResource.get("timestamp")+",";
        types+=localResource.get("type")+",";
        visibilities+=localResource.get("visibility")+",";

    }
    properties+=confArchive+"\n";
    properties+=filenames.substring(0,filenames.length()-1)+"\n";
    properties+=sizes.substring(0,sizes.length()-1)+"\n";
    properties+=timestamps.substring(0,timestamps.length()-1)+"\n";
    properties+=types.substring(0,types.length()-1)+"\n";
    properties+=visibilities.substring(0,visibilities.length()-1)+"\n";

__spark_hadoop_conf__.xml文件是core-site.xml的简单重命名，使用它们创建的文件夹名为__hadoop_conf__并且为空。

您可以将文件直接保存到hdfs，如下所示： 

private void generateSparkConfInHdfs(String applicationId, String userName, String sparkConfProperties, String sparkHadoopConf) throws IOException {
    String path = hdfs+"/user/"+userName+"/.sparkStaging/"+applicationId+"/__spark_conf__.zip";
    Path hdfsPath = new Path(path);
    ZipOutputStream os = new ZipOutputStream(getHdfs().create(hdfsPath));
    os.putNextEntry(new ZipEntry("__hadoop_conf__/"));
    os.putNextEntry(new ZipEntry("__spark_conf__.properties"));
    os.write(sparkConfProperties.getBytes(),0,sparkConfProperties.getBytes().length);
    os.putNextEntry(new ZipEntry("__spark_hadoop_conf__.xml"));
    os.write(sparkHadoopConf.getBytes(),0,sparkHadoopConf.getBytes().length);
    os.close();
}

创建完文件后，按照以下说明将其添加到资源列表中：

  • 大小= getLen（）
  • 时间戳= getModificationTime（）
  • 类型=存档
  • 可见性=私人
  • 键= __spark_conf__
  • 资源是登台目录（通常为{{HDFS_base_folder}}/user/{{username}}/.sparkStaging/{{application_id}}/__spark_conf__.zip ）。

遍历完整的资源列表，并使用我们在{{}}占位符中收集的值从每个资源创建具有此结构的XML / JSON： 

    <entry>
        <key>{{key}}</key>
        <value>
            <resource>{{resource}}</resource>
            <size>{{size}}</size>
            <timestamp>{{timestamp}}</timestamp>
            <type>{{type}}</type>
            <visibility>{{visibility}}</visibility>
        </value>
    </entry>

累积的字符串将成为您的localResources XML段，如下所示。

第三步

生成Java命令。 您将需要从SparkConfig中提取一些元素：

  • driverMemory -从相同的属性sparkConf
  • extraJavaOptions =来自属性集合内的spark.driver.extraJavaOptions
  • mainClass -从相同的属性sparkConf
  • argstr-收集ClientArgs以外的所有ClientArgs 。

包含元素的结果命令为： 

String command = "$JAVA_HOME/bin/java -server -Xmx"+driverMemory+" -Djava.io.tmpdir=$PWD/tmp "+extraJavaOptions+" -Dspark.yarn.app.container.log.dir=&lt;LOG_DIR&gt; "
            + "org.apache.spark.deploy.yarn.ApplicationMaster --class "+mainClass+" "+argstr+" "
            + "--properties-file $PWD/__spark_conf__/__spark_conf__.properties 1&gt; &lt;LOG_DIR&gt;/stdout 2&gt; &lt;LOG_DIR&gt;/stderr";

第四步

编译请求XML。

注意 ：我的实现在AM容器上需要一个标签，因此添加了am-container-node-label-expression。 这并非在所有情况下都适用。

从sparkConf到REST请求的映射是（此处显示为XML，还支持JSON实现）： 

<application-submission-context>
    <application-id>"+applicationId+"</application-id> 
    <application-name>"+appName+"</application-name>
    <queue>default</queue>
    <priority>0</priority>
    <am-container-spec>
       <local-resources>+localResources+</local-resources>
       <environment>
          <entry>
             <key>SPARK_YARN_STAGING_DIR</key>
             <value>"+hdfs+"/user/"+userName+"/.sparkStaging/"+applicationId+"</value>
          </entry>
          <entry>
             <key>CLASSPATH</key>
             <value>$PWD:$PWD/__spark_conf__:$PWD/__spark_libs__/*:/spark-non-hdfs-storage/spark-assembly-2.3.0-hadoop2.7/*:%HADOOP_CONF_DIR%:%HADOOP_COMMON_HOME%/share/hadoop/common/*:%HADOOP_COMMON_HOME%/share/hadoop/common/lib/*:%HADOOP_HDFS_HOME%/share/hadoop/hdfs/*:%HADOOP_HDFS_HOME%/share/hadoop/hdfs/lib/*:%HADOOP_YARN_HOME%/share/hadoop/yarn/*:%HADOOP_YARN_HOME%/share/hadoop/yarn/lib/*:%HADOOP_MAPRED_HOME%/share/hadoop/mapreduce/*:%HADOOP_MAPRED_HOME%/share/hadoop/mapreduce/lib/*:$PWD/__spark_conf__/__hadoop_conf__</value>
          </entry>
          <entry>
             <key>SPARK_USER</key>
             <value>"+userName+"</value>
          </entry>
       </environment>
       <commands>
          <command>"+command+"</command>
       </commands>
    </am-container-spec>
    <unmanaged-AM>false</unmanaged-AM>
    <max-app-attempts>1</max-app-attempts>
    <resource>
      <memory>5632</memory>
      <vCores>1</vCores>
    </resource>
    <application-type>SPARK</application-type>
    <keep-containers-across-application-attempts>false</keep-containers-across-application-attempts>
    <application-tags>
      <tag>"+sparkYarnTag+"</tag>
    </application-tags>
    <am-container-node-label-expression>appMngr</am-container-node-label-expression>
    <log-aggregation-context/>
    <attempt-failures-validity-interval>1</attempt-failures-validity-interval>
    <reservation-id/>
</application-submission-context>

步骤5：

通过REST http PUT提交应用程序： 

private void submitApplication (String body, String userName) throws SMSparkManagerException {
    HttpClient client = HttpClientBuilder.create().build();
    HttpPost request = new HttpPost(uri+"?user.name="+userName);
    try {
        request.setEntity(new StringEntity(body, ContentType.APPLICATION_XML));
        HttpResponse response = client.execute(request);
        if (response.getStatusLine().getStatusCode()!=202) {
            throw new SMSparkManagerException("The application could not be submitted to Yarn, response http code "+response.getStatusLine().getStatusCode());
        }
    } catch (UnsupportedEncodingException e) {
        logger.error("The application Could not be submitted due to UnsupportedEncodingException in the provided body: "+body, e );
        throw new SMSparkManagerException("Error in submitting application to yarn");
    } catch (ClientProtocolException e) {
        logger.error("The application Could not be submitted due to ClientProtocolException", e);
        throw new SMSparkManagerException("Error in submitting application to yarn");
    } catch (IOException e) {
        logger.error("The application Could not be submitted due to IOException", e);
        throw new SMSparkManagerException("Error in submitting application to yarn");
    }
}

暂无
暂无

声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

相关问题 如何在YARN Spark作业中设置环境变量？ 如何在客户端上的Java程序中使用Google Translate API？ 我应该如何将此Spark Scala行转换为Java YARN REST API-提交简单的工作 如何使用REST API生成数据时传输数据？ 如何使用CMIS REST API访问Alfresco中的文件？ 如何通过jHipster REST API进行社交登录？ 如何用 websocket 客户端监听 rest api REST API客户端设计 如何基于我的其余API实现操作
相关标签
 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM