Skip to content

S
spark-doc-zh

OpenDocCN / spark-doc-zh
10 个月 前同步成功

通知 35
Star 1189
Fork 345
S
spark-doc-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 3b007b11 编写于 作者: 取昵称好难啊's avatar 取昵称好难啊
浏览文件
操作

"。[SPACE]" to "。"

上级 fcaba1c3
展开全部 隐藏空白更改
内联 并排
Showing with 192 addition and 192 deletion
docs/1.md
浏览文件 @ 3b007b11
# Spark 概述
Apache Spark 是一个快速的, 多用途的集群计算系统。 它提供了 Java, Scala, Python 和 R 的高级 API，以及一个支持通用的执行图计算的优化过的引擎. 它还支持一组丰富的高级工具, 包括使用 SQL 处理结构化数据处理的 [Spark SQL](sql-programming-guide.html), 用于机器学习的 [MLlib](ml-guide.html), 用于图计算的 [GraphX](graphx-programming-guide.html), 以及 [Spark Streaming](streaming-programming-guide.html)。
Apache Spark 是一个快速的, 多用途的集群计算系统。它提供了 Java, Scala, Python 和 R 的高级 API，以及一个支持通用的执行图计算的优化过的引擎. 它还支持一组丰富的高级工具, 包括使用 SQL 处理结构化数据处理的 [Spark SQL](sql-programming-guide.html), 用于机器学习的 [MLlib](ml-guide.html), 用于图计算的 [GraphX](graphx-programming-guide.html), 以及 [Spark Streaming](streaming-programming-guide.html)。
# 下载
......@@ -42,7 +42,7 @@ Python 中也提供了应用示例。例如,
./bin/spark-submit examples/src/main/python/pi.py 10
```
从 1.4 开始（仅包含了 DataFrames APIs）Spark 也提供了一个用于实验性的 [R API](sparkr.html)。 为了在 R interpreter（解释器）中运行交互式的 Spark, 请执行 `bin/sparkR`:
从 1.4 开始（仅包含了 DataFrames APIs）Spark 也提供了一个用于实验性的 [R API](sparkr.html)。为了在 R interpreter（解释器）中运行交互式的 Spark, 请执行 `bin/sparkR`:
```
./bin/sparkR --master local[2]
......@@ -56,7 +56,7 @@ R 中也提供了应用示例。例如,
# 在集群上运行
该 Spark [集群模式概述](cluster-overview.html) 说明了在集群上运行的主要的概念。 Spark 既可以独立运行, 也可以在一些现有的 Cluster Manager（集群管理器）上运行。它当前提供了几种用于部署的选项:
该 Spark [集群模式概述](cluster-overview.html) 说明了在集群上运行的主要的概念。Spark 既可以独立运行, 也可以在一些现有的 Cluster Manager（集群管理器）上运行。它当前提供了几种用于部署的选项:
* [Standalone Deploy Mode](spark-standalone.html): 在私有集群上部署 Spark 最简单的方式
* [Apache Mesos](running-on-mesos.html)
......
docs/12.md
浏览文件 @ 3b007b11
......@@ -14,7 +14,7 @@ Spark 应用在集群上作为独立的进程组来运行，在您的 main 程
1. 每个应用获取到它自己的 Executor 进程，它们会保持在整个应用的生命周期中并且在多个线程中运行 Task（任务）。这样做的优点是把应用互相隔离，在调度方面（每个 driver 调度它自己的 task）和 Executor 方面（来自不同应用的 task 运行在不同的 JVM 中）。然而，这也意味着若是不把数据写到外部的存储系统中的话，数据就不能够被不同的 Spark 应用（SparkContext 的实例）之间共享。
2. Spark 是不知道底层的 Cluster Manager 到底是什么类型的。只要它能够获得 Executor 进程，并且它们可以和彼此之间通信，那么即使是在一个也支持其它应用的 Cluster Manager（例如，Mesos / YARN）上来运行它也是相对简单的。
3. Driver 程序必须在自己的生命周期内（例如，请参阅 [在网络配置章节中的 spark.driver.port 章节](configuration.html＃networking)。 监听和接受来自它的 Executor 的连接请求。同样的，driver 程序必须可以从 worker 节点上网络寻址（就是网络没问题）。
3. Driver 程序必须在自己的生命周期内（例如，请参阅 [在网络配置章节中的 spark.driver.port 章节](configuration.html＃networking)。监听和接受来自它的 Executor 的连接请求。同样的，driver 程序必须可以从 worker 节点上网络寻址（就是网络没问题）。
4. 因为 driver 调度了集群上的 task（任务），更好的方式应该是在相同的局域网中靠近 worker 的节点上运行。如果您不喜欢发送请求到远程的集群，倒不如打开一个 RPC 至 driver 并让它就近提交操作而不是从很远的 worker 节点上运行一个 driver。
# Cluster Manager 类型
......@@ -25,7 +25,7 @@ Spark 应用在集群上作为独立的进程组来运行，在您的 main 程
* [Apache Mesos](running-on-mesos.html) – 一个通用的 Cluster Manager，它也可以运行 Hadoop MapReduce 和其它服务应用。
* [Hadoop YARN](running-on-yarn.html) –Hadoop 2 中的 resource manager（资源管理器）。
* [Kubernetes (experimental)](https://github.com/apache-spark-on-k8s/spark) – 除了上述之外，还有 Kubernetes 的实验支持。 Kubernetes 提供以容器为中心的基础设施的开源平台。 Kubernetes 的支持正在 apache-spark-on-k8s Github 组织中积极开发。有关文档，请参阅该项目的 README。
* [Kubernetes (experimental)](https://github.com/apache-spark-on-k8s/spark) – 除了上述之外，还有 Kubernetes 的实验支持。Kubernetes 提供以容器为中心的基础设施的开源平台。Kubernetes 的支持正在 apache-spark-on-k8s Github 组织中积极开发。有关文档，请参阅该项目的 README。
# 提交应用程序
......@@ -33,11 +33,11 @@ Spark 应用在集群上作为独立的进程组来运行，在您的 main 程
# 监控
每个 driver 都有一个 Web UI，通常在端口 4040 上，可以显示有关正在运行的 task，executor，和存储使用情况的信息。 只需在 Web 浏览器中的`http://<driver-node>:4040` 中访问此 UI。[监控指南](monitoring.html) 中还介绍了其他监控选项。
每个 driver 都有一个 Web UI，通常在端口 4040 上，可以显示有关正在运行的 task，executor，和存储使用情况的信息。只需在 Web 浏览器中的`http://<driver-node>:4040` 中访问此 UI。[监控指南](monitoring.html) 中还介绍了其他监控选项。
# Job 调度
Spark 即可以在应用间（Cluster Manager 级别），也可以在应用内（如果多个计算发生在相同的 SparkContext 上时）控制资源分配。 在 [任务调度概述](job-scheduling.html) 中更详细地描述了这一点。
Spark 即可以在应用间（Cluster Manager 级别），也可以在应用内（如果多个计算发生在相同的 SparkContext 上时）控制资源分配。在 [任务调度概述](job-scheduling.html) 中更详细地描述了这一点。
# 术语
......
docs/13.md
浏览文件 @ 3b007b11
......@@ -29,7 +29,7 @@
一些常用的 options（选项）有 :
* `--class`: 您的应用程序的入口点（例如。 `org.apache.spark.examples.SparkPi`)
* `--class`: 您的应用程序的入口点（例如。`org.apache.spark.examples.SparkPi`)
* `--master`: 集群的 [master URL](#master-urls) (例如 `spark://23.195.26.187:7077`)
* `--deploy-mode`: 是在 worker 节点(`cluster`) 上还是在本地作为一个外部的客户端(`client`) 部署您的 driver(默认: `client`) **†**
* `--conf`: 按照 key=value 格式任意的 Spark 配置属性。对于包含空格的 value（值）使用引号包 “key=value” 起来。
......@@ -141,7 +141,7 @@ Spark 使用下面的 URL 格式以允许传播 jar 时使用不同的策略 :
N注意，那些 JAR 和文件被复制到 working directory（工作目录）用于在 executor 节点上的每个 SparkContext。这可以使用最多的空间显著量随着时间的推移，将需要清理。在 Spark On YARN 模式中，自动执行清理操作。在 Spark standalone 模式中，可以通过配置 `spark.worker.cleanup.appDataTtl` 属性来执行自动清理。
用户也可以通过使用 `--packages`来提供一个逗号分隔的 maven coordinates（maven 坐标）以包含任何其它的依赖。在使用这个命令时所有可传递的依赖将被处理。其它的 repository（或者在 SBT 中被解析的）可以使用 `--repositories`该标记添加到一个逗号分隔的样式中。 (注意，对于那些设置了密码保护的库，在一些情况下可以在库URL中提供验证信息，例如 `https://user:password@host/...`.以这种方式提供验证信息需要小心。) 这些命令可以与 `pyspark`, `spark-shell` 和 `spark-submit` 配置会使用以包含 Spark Packages（Spark 包）。 对于 Python 来说，也可以使用 `--py-files` 选项用于分发 `.egg`, `.zip` 和 `.py` libraries 到 executor 中。
用户也可以通过使用 `--packages`来提供一个逗号分隔的 maven coordinates（maven 坐标）以包含任何其它的依赖。在使用这个命令时所有可传递的依赖将被处理。其它的 repository（或者在 SBT 中被解析的）可以使用 `--repositories`该标记添加到一个逗号分隔的样式中。(注意，对于那些设置了密码保护的库，在一些情况下可以在库URL中提供验证信息，例如 `https://user:password@host/...`.以这种方式提供验证信息需要小心。) 这些命令可以与 `pyspark`, `spark-shell` 和 `spark-submit` 配置会使用以包含 Spark Packages（Spark 包）。对于 Python 来说，也可以使用 `--py-files` 选项用于分发 `.egg`, `.zip` 和 `.py` libraries 到 executor 中。
# 更多信息
......
docs/15.md
浏览文件 @ 3b007b11
......@@ -52,7 +52,7 @@ Spark 除了运行在 Mesos 或者 YARN 上以外，Spark 还提供了一个简
# 集群启动脚本
要使用启动脚本启动 Spark standalone 集群，你应该首先在 Spark 目录下创建一个叫做 conf/slaves 的文件，这个文件中必须包含所有你想要启动的 Spark workers 的机器的 hostname ，每个 hostname 占一行。 如果 conf/slaves 不存在，启动脚本默认启动单个机器（localhost），这对于测试是有效的。 注意， master 机器通过 ssh 访问所有的 worker 机器。默认情况下，ssh 是 parallel （并行）运行的并且需要配置无密码（使用一个私钥）的访问。 如果您没有设置无密码访问，您可以设置环境变量 SPARK_SSH_FOREGROUND 并且为每个 worker 提供一个密码。
要使用启动脚本启动 Spark standalone 集群，你应该首先在 Spark 目录下创建一个叫做 conf/slaves 的文件，这个文件中必须包含所有你想要启动的 Spark workers 的机器的 hostname ，每个 hostname 占一行。如果 conf/slaves 不存在，启动脚本默认启动单个机器（localhost），这对于测试是有效的。注意， master 机器通过 ssh 访问所有的 worker 机器。默认情况下，ssh 是 parallel （并行）运行的并且需要配置无密码（使用一个私钥）的访问。如果您没有设置无密码访问，您可以设置环境变量 SPARK_SSH_FOREGROUND 并且为每个 worker 提供一个密码。
一旦您创建了这个文件，您就可以启动或者停止您的集群使用下面的 shell 脚本，基于 Hadoop 的部署脚本，并在 `SPARK_HOME/sbin` 中可用：
......@@ -110,7 +110,7 @@ SPARK_WORKER_OPTS 支持以下的系统属性：
| `spark.worker.cleanup.enabled` | false | 激活周期性清空 worker / application 目录。注意，这只影响 standalone 模式，因为 YARN 工作方式不同。只有已停止的应用程序的目录会被清空。 |
| `spark.worker.cleanup.interval` | 1800 (30 minutes) | 在本地机器上，worker 控制清空老的应用程序的工作目录的时间间隔，以秒计数。 |
| `spark.worker.cleanup.appDataTtl` | 604800 (7 days, 7 * 24 * 3600) | 每个 worker 中应用程序工作目录的保留时间。这是一个 Live 时间，并且应该取决于您拥有的可用的磁盘空间量。应用程序的日志和 jars 都会被下载到应用程序的工作目录。随着时间的推移，这个工作目录会很快填满磁盘空间，特别是如果您经常运行作业。 |
| `spark.worker.ui.compressedLogFileLengthCacheSize` | 100 | 对于压缩日志文件，只能通过未压缩文件来计算未压缩文件。 Spark 缓存未压缩日志文件的未压缩文件大小。此属性控制缓存的大小。 |
| `spark.worker.ui.compressedLogFileLengthCacheSize` | 100 | 对于压缩日志文件，只能通过未压缩文件来计算未压缩文件。Spark 缓存未压缩日志文件的未压缩文件大小。此属性控制缓存的大小。 |
# 提交应用程序到集群中
......@@ -128,7 +128,7 @@ SPARK_WORKER_OPTS 支持以下的系统属性：
[`spark-submit` 脚本](submitting-applications.html) 提供了最简单的方法将一个编译好的 Spark 应用程序提交到集群中。对于 standalone 集群，Spark 目前支持两种部署模式。在 `client` 模式下，driver 在与 client 提交应用程序相同的进程中启动。在 `cluster` 模式下，driver 是集群中的某个 Worker 中的进程中启动，并且 client 进程将会在完成提交应用程序的任务之后退出，而不需要等待应用程序完成再退出。
如果您的应用程序是通过 Spark 提交来启动的，则应用程序的 jar 将自动启动分发给所有的 worker 节点。对于您的应用程序依赖的其他的 jar ，您应该通过 `--jars` 标志使用逗号作为分隔符（例如 `--jars jar1,jar2`）来指定它们。 要控制应用程序的配置或执行环境，请参阅 [Spark Configuration](configuration.html) 。
如果您的应用程序是通过 Spark 提交来启动的，则应用程序的 jar 将自动启动分发给所有的 worker 节点。对于您的应用程序依赖的其他的 jar ，您应该通过 `--jars` 标志使用逗号作为分隔符（例如 `--jars jar1,jar2`）来指定它们。要控制应用程序的配置或执行环境，请参阅 [Spark Configuration](configuration.html) 。
另外，standalone `cluster` 模式支持自动重新启动应用程序如果它是以非零的退出码退出的。要使用此功能，您可以在启动您的应用程序的时候将 `--supervise` 标志传入 `spark-submit` 。然后，如果您想杀死一个重复失败的应用程序，您可以使用如下方式：
......@@ -140,7 +140,7 @@ SPARK_WORKER_OPTS 支持以下的系统属性：
# Resource Scheduling（资源调度）
standalone 集群模式当前只支持一个简单的跨应用程序的 FIFO 调度。 然而，为了允许多个并发的用户，您可以控制每个应用程序能用的最大资源数。 默认情况下，它将获取集群中的 _all_ cores （核），这只有在某一时刻只允许一个应用程序运行时才有意义。您可以通过 `spark.cores.max` 在 [SparkConf](configuration.html#spark-properties) 中设置 cores （核）的数量。例如：
standalone 集群模式当前只支持一个简单的跨应用程序的 FIFO 调度。然而，为了允许多个并发的用户，您可以控制每个应用程序能用的最大资源数。默认情况下，它将获取集群中的 _all_ cores （核），这只有在某一时刻只允许一个应用程序运行时才有意义。您可以通过 `spark.cores.max` 在 [SparkConf](configuration.html#spark-properties) 中设置 cores （核）的数量。例如：
......@@ -154,7 +154,7 @@ val sc = new SparkContext(conf)
此外，您可以在集群的 master 进程中配置 `spark.deploy.defaultCores` 来修改默认为没有将 `spark.cores.max` 设置为小于无穷大的应用程序。 通过添加下面的命令到 `conf/spark-env.sh` 执行以上的操作：
此外，您可以在集群的 master 进程中配置 `spark.deploy.defaultCores` 来修改默认为没有将 `spark.cores.max` 设置为小于无穷大的应用程序。通过添加下面的命令到 `conf/spark-env.sh` 执行以上的操作：
......@@ -168,7 +168,7 @@ export SPARK_MASTER_OPTS="-Dspark.deploy.defaultCores=<value>"
# 监控和日志
Spark 的 standalone 模式提供了一个基于 web 的用户接口来监控集群。master 和每个 worker 都有它自己的显示集群和作业信息的 web UI 。 默认情况下，您可以通过 master 的 8080 端口来访问 web UI 。这个端口可以通过配置文件修改或者通过命令行选项修改。
Spark 的 standalone 模式提供了一个基于 web 的用户接口来监控集群。master 和每个 worker 都有它自己的显示集群和作业信息的 web UI 。默认情况下，您可以通过 master 的 8080 端口来访问 web UI 。这个端口可以通过配置文件修改或者通过命令行选项修改。
此外，对于每个作业的详细日志输出也会写入到每个 slave 节点的工作目录中。（默认是 `SPARK_HOME/work`）。你会看到每个作业的两个文件，分别是 `stdout` 和 `stderr` ，其中所有输出都写入其控制台。
......@@ -194,7 +194,7 @@ Spark 对网络的需求比较高，并且一些环境对于使用严格的防
**配置**
为了启用这个恢复模式，您可以在 spark-env 中设置 SPARK_DAEMON_JAVA_OPTS 通过配置 `spark.deploy.recoveryMode` 和相关的 spark.deploy.zookeeper.* 配置。 有关这些配置的更多信息，请参阅 [配置文档](configuration.html#deploy) 。
为了启用这个恢复模式，您可以在 spark-env 中设置 SPARK_DAEMON_JAVA_OPTS 通过配置 `spark.deploy.recoveryMode` 和相关的 spark.deploy.zookeeper.* 配置。有关这些配置的更多信息，请参阅 [配置文档](configuration.html#deploy) 。
可能的陷阱：如果您在您的集群中有多个 Masters 但是没有正确地配置 Masters 使用 ZooKeeper ， Masters 将无法相互发现，并认为它们都是 leader 。这将不会形成一个健康的集群状态（因为所有的 Masters 将会独立调度）。
......
docs/16.md
浏览文件 @ 3b007b11
......@@ -77,7 +77,7 @@ Mesosphere 安装文档建议安装 ZooKeeper 来处理 Mesos master 故障切
## 上传 Spark 包
当 Mesos 第一次在 Mesos slave 上运行任务的时候，这个 slave 必须有一个 Spark binary package （Spark 二进制包）用于执行 Spark Mesos executor backend （执行器后端）。 Spark 软件包可以在任何 Hadoop 可访问的 URI 上托管，包括 HTTP 通过 `http://` ，[Amazon Simple Storage Service](http://aws.amazon.com/s3) 通过 `s3n://` ，或者 HDFS 通过 `hdfs://` 。
当 Mesos 第一次在 Mesos slave 上运行任务的时候，这个 slave 必须有一个 Spark binary package （Spark 二进制包）用于执行 Spark Mesos executor backend （执行器后端）。Spark 软件包可以在任何 Hadoop 可访问的 URI 上托管，包括 HTTP 通过 `http://` ，[Amazon Simple Storage Service](http://aws.amazon.com/s3) 通过 `s3n://` ，或者 HDFS 通过 `hdfs://` 。
要使用预编译的包：
......@@ -141,7 +141,7 @@ Spark on Mesos 还支持 cluster mode （集群模式），其中 driver 在集
如果您喜欢使用 Marathon 来运行 `MesosClusterDispatcher` ，您需要在 foreground （前台）运行 `MesosClusterDispatcher` （即 `bin/spark-class org.apache.spark.deploy.mesos.MesosClusterDispatcher`）。注意，`MesosClusterDispatcher` 尚不支持 HA 的多个实例。
`MesosClusterDispatcher` 还支持将 recovery state （恢复状态）写入 Zookeeper 。这将允许 `MesosClusterDispatcher` 能够在重新启动时恢复所有提交和运行的 containers （容器）。为了启用这个恢复模式，您可以在 spark-env 中通过配置 `spark.deploy.recoveryMode` 来设置 SPARK_DAEMON_JAVA_OPTS 和相关的 spark.deploy.zookeeper.* 配置。 有关这些配置的更多信息，请参阅配置 [doc](configurations.html#deploy) 。
`MesosClusterDispatcher` 还支持将 recovery state （恢复状态）写入 Zookeeper 。这将允许 `MesosClusterDispatcher` 能够在重新启动时恢复所有提交和运行的 containers （容器）。为了启用这个恢复模式，您可以在 spark-env 中通过配置 `spark.deploy.recoveryMode` 来设置 SPARK_DAEMON_JAVA_OPTS 和相关的 spark.deploy.zookeeper.* 配置。有关这些配置的更多信息，请参阅配置 [doc](configurations.html#deploy) 。
从客户端，您可以提交一个作业到 Mesos 集群，通过执行 `spark-submit` 并指定 `MesosClusterDispatcher` 的 master URL （例如：mesos://dispatcher:7077）。您可以在 Spark cluster Web UI 查看 driver 的状态。
......@@ -171,7 +171,7 @@ Spark 可以以两种模式运行 Mesos ： “coarse-grained（粗粒度）”
## Coarse-Grained（粗粒度）
在 “coarse-grained（粗粒度） 模式下，每个 Spark 执行器都作为单个 Mesos 任务运行。 Spark 执行器的大小是根据下面的配置变量确定的：
在 “coarse-grained（粗粒度） 模式下，每个 Spark 执行器都作为单个 Mesos 任务运行。Spark 执行器的大小是根据下面的配置变量确定的：
* Executor memory（执行器内存）: `spark.executor.memory`
* Executor cores（执行器核）: `spark.executor.cores`
......@@ -231,13 +231,13 @@ Spark 可以通过在您的 [SparkConf](configuration.html#spark-properties) 中
您可以在现有的 Hadoop 集群集成运行 Spark 和 Mesos ，只需要在机器上启动他们作为分开的服务即可。要从 Spark 访问 Hadoop 数据，需要一个完整的 `hdfs://` URL （通常为 `hdfs://&lt;namenode&gt;:9000/path`），但是您可以在 Hadoop Namenode web UI 上找到正确的 URL 。
此外，还可以在 Mesos 上运行 Hadoop MapReduce，以便在两者之间实现更好的资源隔离和共享。 在这种情况下，Mesos 将作为统一的调度程序，将 Core 核心分配给 Hadoop 或 Spark，而不是通过每个节点上的 Linux 调度程序共享资源。 请参考 [Hadoop on Mesos](https://github.com/mesos/hadoop) 。
此外，还可以在 Mesos 上运行 Hadoop MapReduce，以便在两者之间实现更好的资源隔离和共享。在这种情况下，Mesos 将作为统一的调度程序，将 Core 核心分配给 Hadoop 或 Spark，而不是通过每个节点上的 Linux 调度程序共享资源。请参考 [Hadoop on Mesos](https://github.com/mesos/hadoop) 。
# 使用 Mesos 动态分配资源
Mesos 仅支持使用粗粒度模式的动态分配，这可以基于应用程序的统计信息调整执行器的数量。 有关一般信息，请参阅 [Dynamic Resource Allocation](job-scheduling.html#dynamic-resource-allocation) 。
Mesos 仅支持使用粗粒度模式的动态分配，这可以基于应用程序的统计信息调整执行器的数量。有关一般信息，请参阅 [Dynamic Resource Allocation](job-scheduling.html#dynamic-resource-allocation) 。
要使用的外部 Shuffle 服务是 Mesos Shuffle 服务。 它在 Shuffle 服务之上提供 shuffle 数据清理功能，因为 Mesos 尚不支持通知另一个框架的终止。 要启动它，在所有从节点上运 `$SPARK_HOME/sbin/start-mesos-shuffle-service.sh` ，并将 `spark.shuffle.service.enabled` 设置为`true`。
要使用的外部 Shuffle 服务是 Mesos Shuffle 服务。它在 Shuffle 服务之上提供 shuffle 数据清理功能，因为 Mesos 尚不支持通知另一个框架的终止。要启动它，在所有从节点上运 `$SPARK_HOME/sbin/start-mesos-shuffle-service.sh` ，并将 `spark.shuffle.service.enabled` 设置为`true`。
这也可以通过 Marathon，使用唯一的主机约束和以下命令实现 : `bin/spark-class org.apache.spark.deploy.mesos.MesosExternalShuffleService`。
......@@ -249,33 +249,33 @@ Mesos 仅支持使用粗粒度模式的动态分配，这可以基于应用程
| Property Name（属性名称） | Default（默认） | Meaning（含义） |
| --- | --- | --- |
| `spark.mesos.coarse` | true | 如果设置为`true`，则以 “粗粒度” 共享模式在 Mesos 集群上运行，其中 Spark 在每台计算机上获取一个长期存在的 Mesos 任务。 如果设置为`false`，则以 “细粒度” 共享模式在 Mesos 集群上运行，其中每个 Spark 任务创建一个 Mesos 任务。 ['Mesos Run Modes'](running-on-mesos.html#mesos-run-modes) 中的详细信息。 |
| `spark.mesos.extra.cores` | `0` | 设置执行程序公布的额外核心数。 这不会导致分配更多的内核。 它代替意味着执行器将“假装”它有更多的核心，以便驱动程序将发送更多的任务。 使用此来增加并行度。 此设置仅用于 Mesos 粗粒度模式。 |
| `spark.mesos.mesosExecutor.cores` | `1.0` | （仅限细粒度模式）给每个 Mesos 执行器的内核数。 这不包括用于运行 Spark 任务的核心。 换句话说，即使没有运行 Spark 任务，每个 Mesos 执行器将占用这里配置的内核数。 该值可以是浮点数。 |
| `spark.mesos.executor.docker.image` | (none) | 设置 Spark 执行器将运行的 docker 映像的名称。所选映像必须安装 Spark，以及兼容版本的 Mesos 库。 Spark 在图像中的安装路径可以通过 `spark.mesos.executor.home` 来指定; 可以使用 `spark.executorEnv.MESOS_NATIVE_JAVA_LIBRARY` 指定 Mesos 库的安装路径。 |
| `spark.mesos.executor.docker.forcePullImage` | false | 强制 Mesos 代理拉取 `spark.mesos.executor.docker.image` 中指定的图像。      默认情况下，Mesos 代理将不会拉取已经缓存的图像。 |
| `spark.mesos.executor.docker.parameters` | (none) | 在使用 docker 容器化器在 Mesos 上启动 Spark 执行器时，设置将被传递到 `docker run` 命令的自定义参数的列表。 此属性的格式是逗号分隔的列表      键/值对。 例：
| `spark.mesos.coarse` | true | 如果设置为`true`，则以 “粗粒度” 共享模式在 Mesos 集群上运行，其中 Spark 在每台计算机上获取一个长期存在的 Mesos 任务。如果设置为`false`，则以 “细粒度” 共享模式在 Mesos 集群上运行，其中每个 Spark 任务创建一个 Mesos 任务。['Mesos Run Modes'](running-on-mesos.html#mesos-run-modes) 中的详细信息。 |
| `spark.mesos.extra.cores` | `0` | 设置执行程序公布的额外核心数。这不会导致分配更多的内核。它代替意味着执行器将“假装”它有更多的核心，以便驱动程序将发送更多的任务。使用此来增加并行度。此设置仅用于 Mesos 粗粒度模式。 |
| `spark.mesos.mesosExecutor.cores` | `1.0` | （仅限细粒度模式）给每个 Mesos 执行器的内核数。这不包括用于运行 Spark 任务的核心。换句话说，即使没有运行 Spark 任务，每个 Mesos 执行器将占用这里配置的内核数。该值可以是浮点数。 |
| `spark.mesos.executor.docker.image` | (none) | 设置 Spark 执行器将运行的 docker 映像的名称。所选映像必须安装 Spark，以及兼容版本的 Mesos 库。Spark 在图像中的安装路径可以通过 `spark.mesos.executor.home` 来指定; 可以使用 `spark.executorEnv.MESOS_NATIVE_JAVA_LIBRARY` 指定 Mesos 库的安装路径。 |
| `spark.mesos.executor.docker.forcePullImage` | false | 强制 Mesos 代理拉取 `spark.mesos.executor.docker.image` 中指定的图像。     默认情况下，Mesos 代理将不会拉取已经缓存的图像。 |
| `spark.mesos.executor.docker.parameters` | (none) | 在使用 docker 容器化器在 Mesos 上启动 Spark 执行器时，设置将被传递到 `docker run` 命令的自定义参数的列表。此属性的格式是逗号分隔的列表      键/值对。例：
```
key1=val1,key2=val2,key3=val3
```
|
| `spark.mesos.executor.docker.volumes` | (none) | 设置要装入到 Docker 镜像中的卷列表，这是使用 `spark.mesos.executor.docker.image` 设置的。 此属性的格式是以逗号分隔的映射列表，后面的形式传递到 `docker run -v` 。 这是他们采取的形式 :
| `spark.mesos.executor.docker.volumes` | (none) | 设置要装入到 Docker 镜像中的卷列表，这是使用 `spark.mesos.executor.docker.image` 设置的。此属性的格式是以逗号分隔的映射列表，后面的形式传递到 `docker run -v` 。这是他们采取的形式 :
```
[host_path:]container_path[:ro&#124;:rw]
```
|
| `spark.mesos.task.labels` | (none) | 设置 Mesos 标签以添加到每个任务。 标签是自由格式的键值对。      键值对应以冒号分隔，并用逗号分隔多个。 Ex. key:value,key2:value2. |
| `spark.mesos.executor.home` | driver side `SPARK_HOME` | 在 Mesos 中的执行器上设置 Spark 安装目录。 默认情况下，执行器将只使用驱动程序的 Spark 主目录，它们可能不可见。 请注意，这只有当 Spark 二进制包没有通过 `spark.executor.uri` 指定时才是有意义的。 |
| `spark.mesos.executor.memoryOverhead` | executor memory * 0.10, with minimum of 384 | 以每个执行程序分配的额外内存量（以 MB 为单位）。 默认情况下，开销将大于 `spark.executor.memory` 的 384 或 10%。 如果设置，最终开销将是此值。 |
| `spark.mesos.uris` | (none) | 当驱动程序或执行程序由 Mesos 启动时，要下载到沙箱的 URI 的逗号分隔列表。 这适用于粗粒度和细粒度模式。 |
| `spark.mesos.task.labels` | (none) | 设置 Mesos 标签以添加到每个任务。标签是自由格式的键值对。     键值对应以冒号分隔，并用逗号分隔多个。Ex. key:value,key2:value2. |
| `spark.mesos.executor.home` | driver side `SPARK_HOME` | 在 Mesos 中的执行器上设置 Spark 安装目录。默认情况下，执行器将只使用驱动程序的 Spark 主目录，它们可能不可见。请注意，这只有当 Spark 二进制包没有通过 `spark.executor.uri` 指定时才是有意义的。 |
| `spark.mesos.executor.memoryOverhead` | executor memory * 0.10, with minimum of 384 | 以每个执行程序分配的额外内存量（以 MB 为单位）。默认情况下，开销将大于 `spark.executor.memory` 的 384 或 10%。如果设置，最终开销将是此值。 |
| `spark.mesos.uris` | (none) | 当驱动程序或执行程序由 Mesos 启动时，要下载到沙箱的 URI 的逗号分隔列表。这适用于粗粒度和细粒度模式。 |
| `spark.mesos.principal` | (none) | 设置 Spark 框架将用来与 Mesos 进行身份验证的主体。 |
| `spark.mesos.secret` | (none) | 设置 Spark 框架将用来与 Mesos 进行身份验证的机密。 |
| `spark.mesos.role` | `*` | 设置这个 Spark 框架对 Mesos 的作用。 角色在 Mesos 中用于预留和资源权重共享。 |
| `spark.mesos.constraints` | (none) | 基于属性的约束对 mesos 资源提供。 默认情况下，所有资源优惠都将被接受。 有关属性的更多信息，请参阅 [Mesos Attributes & Resources](http://mesos.apache.org/documentation/attributes-resources/)
| `spark.mesos.role` | `*` | 设置这个 Spark 框架对 Mesos 的作用。角色在 Mesos 中用于预留和资源权重共享。 |
| `spark.mesos.constraints` | (none) | 基于属性的约束对 mesos 资源提供。默认情况下，所有资源优惠都将被接受。有关属性的更多信息，请参阅 [Mesos Attributes & Resources](http://mesos.apache.org/documentation/attributes-resources/)
* 标量约束与 “小于等于” 语义匹配，即约束中的值必须小于或等于资源提议中的值。
* 范围约束与 “包含” 语义匹配，即约束中的值必须在资源提议的值内。
......@@ -284,14 +284,14 @@ key1=val1,key2=val2,key3=val3
* 如果没有作为约束的一部分存在的值，则将接受具有相应属性的任何报价（没有值检查）。
|
| `spark.mesos.containerizer` | `docker` | 这只影响 docker containers ，而且必须是 "docker" 或 "mesos"。 Mesos 支持两种类型 docker 的 containerizer："docker" containerizer，和首选 "mesos" containerizer。 在这里阅读更多：http://mesos.apache.org/documentation/latest/container-image/ |
| `spark.mesos.driver.webui.url` | `(none)` | 设置 Spark Mesos 驱动程序 Web UI URL 以与框架交互。 如果取消设置，它将指向 Spark 的内部 Web UI。 |
| `spark.mesos.driverEnv.[EnvironmentVariableName]` | `(none)` | 这仅影响以群集模式提交的驱动程序。 添加由EnvironmentVariableName指定的环境变量驱动程序进程。 用户可以指定多个这些设置多个环境变量。 |
| `spark.mesos.dispatcher.webui.url` | `(none)` | 设置 Spark Mesos 分派器 Web UI URL 以与框架交互。 如果取消设置，它将指向 Spark 的内部 Web UI。 |
| `spark.mesos.dispatcher.driverDefault.[PropertyName]` | `(none)` | 设置驱动程序提供的默认属性通过 dispatcher。 例如，spark.mesos.dispatcher.driverProperty.spark.executor.memory=32g 导致在群集模式下提交的所有驱动程序的执行程序运行在 32g 容器中。 |
| `spark.mesos.dispatcher.historyServer.url` | `(none)` | 设置[history server](http://spark.apache.org/docs/latest/monitoring.html#viewing-after-the-fact)。 然后，dispatcher 将链接每个驱动程序到其条目在历史服务器中。 |
| `spark.mesos.gpus.max` | `0` | 设置要为此作业获取的 GPU 资源的最大数量。 请注意，当没有找到 GPU 资源时，执行器仍然会启动因为这个配置只是一个上限，而不是保证数额。 |
| `spark.mesos.network.name` | `(none)` | 将 containers 附加到给定的命名网络。 如果这个作业是在集群模式下启动，同时在给定的命令中启动驱动程序网络。 查看 [Mesos CNI 文档](http://mesos.apache.org/documentation/latest/cni/)了解更多细节。 |
| `spark.mesos.containerizer` | `docker` | 这只影响 docker containers ，而且必须是 "docker" 或 "mesos"。Mesos 支持两种类型 docker 的 containerizer："docker" containerizer，和首选 "mesos" containerizer。在这里阅读更多：http://mesos.apache.org/documentation/latest/container-image/ |
| `spark.mesos.driver.webui.url` | `(none)` | 设置 Spark Mesos 驱动程序 Web UI URL 以与框架交互。如果取消设置，它将指向 Spark 的内部 Web UI。 |
| `spark.mesos.driverEnv.[EnvironmentVariableName]` | `(none)` | 这仅影响以群集模式提交的驱动程序。添加由EnvironmentVariableName指定的环境变量驱动程序进程。用户可以指定多个这些设置多个环境变量。 |
| `spark.mesos.dispatcher.webui.url` | `(none)` | 设置 Spark Mesos 分派器 Web UI URL 以与框架交互。如果取消设置，它将指向 Spark 的内部 Web UI。 |
| `spark.mesos.dispatcher.driverDefault.[PropertyName]` | `(none)` | 设置驱动程序提供的默认属性通过 dispatcher。例如，spark.mesos.dispatcher.driverProperty.spark.executor.memory=32g 导致在群集模式下提交的所有驱动程序的执行程序运行在 32g 容器中。 |
| `spark.mesos.dispatcher.historyServer.url` | `(none)` | 设置[history server](http://spark.apache.org/docs/latest/monitoring.html#viewing-after-the-fact)。然后，dispatcher 将链接每个驱动程序到其条目在历史服务器中。 |
| `spark.mesos.gpus.max` | `0` | 设置要为此作业获取的 GPU 资源的最大数量。请注意，当没有找到 GPU 资源时，执行器仍然会启动因为这个配置只是一个上限，而不是保证数额。 |
| `spark.mesos.network.name` | `(none)` | 将 containers 附加到给定的命名网络。如果这个作业是在集群模式下启动，同时在给定的命令中启动驱动程序网络。查看 [Mesos CNI 文档](http://mesos.apache.org/documentation/latest/cni/)了解更多细节。 |
| `spark.mesos.fetcherCache.enable` | `false` | 如果设置为 `true`，则所有 URI （例如：`spark.executor.uri`，      `spark.mesos.uris`）将被&lt;a     HREF = "http://mesos.apache.org/documentation/latest/fetcher/"&gt; Mesos      Fetcher Cache&lt;/a&gt; |
# 故障排查和调试
......
docs/17.md
浏览文件 @ 3b007b11
此差异已折叠。
docs/20.md
浏览文件 @ 3b007b11
此差异已折叠。
docs/21.md
浏览文件 @ 3b007b11
......@@ -11,13 +11,13 @@
* 环境信息
* 正在运行的执行器的信息
您可以通过在Web浏览器中打开 `http://&lt;driver-node&gt;:4040` 来访问此界面。 如果多个SparkContexts在同一主机上运行，则它们将绑定到连续的端口从4040（4041，4042等）开始。
您可以通过在Web浏览器中打开 `http://&lt;driver-node&gt;:4040` 来访问此界面。如果多个SparkContexts在同一主机上运行，则它们将绑定到连续的端口从4040（4041，4042等）开始。
请注意，默认情况下此信息仅适用于运行中的应用程序。要在事后还能通过Web UI查看，请在应用程序启动之前，将`spark.eventLog.enabled`设置为true。 这配置Spark持久存储以记录Spark事件，再通过编码该信息在UI中进行显示。
请注意，默认情况下此信息仅适用于运行中的应用程序。要在事后还能通过Web UI查看，请在应用程序启动之前，将`spark.eventLog.enabled`设置为true。这配置Spark持久存储以记录Spark事件，再通过编码该信息在UI中进行显示。
## 事后查看
仍然可以通过Spark的历史服务器构建应用程序的UI， 只要应用程序的事件日志存在。 您可以通过执行以下命令启动历史服务器：
仍然可以通过Spark的历史服务器构建应用程序的UI， 只要应用程序的事件日志存在。您可以通过执行以下命令启动历史服务器：
```
./sbin/start-history-server.sh
......@@ -27,7 +27,7 @@
当使用file-system提供程序类（见下面 `spark.history.provider`）时，基本日志记录目录必须在`spark.history.fs.logDirectory`配置选项中提供，并且应包含每个代表应用程序的事件日志的子目录。
Spark任务本身必须配置启用记录事件，并将其记录到相同共享的可写目录下。 例如，如果服务器配置了日志目录`hdfs://namenode/shared/spark-logs`，那么客户端选项将是：
Spark任务本身必须配置启用记录事件，并将其记录到相同共享的可写目录下。例如，如果服务器配置了日志目录`hdfs://namenode/shared/spark-logs`，那么客户端选项将是：
```
spark.eventLog.enabled true
......@@ -49,20 +49,20 @@ history server 可以配置如下：
| 属性名称 | 默认 | 含义 |
| --- | --- | --- |
| spark.history.provider | `org.apache.spark.deploy.history.FsHistoryProvider` | 执行应用程序历史后端的类的名称。 目前只有一个实现，由Spark提供，它查找存储在文件系统中的应用程序日志。 |
| spark.history.fs.logDirectory | file:/tmp/spark-events | 为了文件系统的历史提供者，包含要加载的应用程序事件日志的目录URL。 这可以是local `file://` 路径， HDFS `hdfs://namenode/shared/spark-logs` 或者是 Hadoop API支持的替代文件系统。 |
| spark.history.fs.update.interval | 10s | 文件系统历史的提供者在日志目录中检查新的或更新的日志期间。 更短的时间间隔可以更快地检测新的应用程序，而不必更多服务器负载重新读取更新的应用程序。 一旦更新完成，完成和未完成的应用程序的列表将反映更改。 |
| spark.history.retainedApplications | 50 | 在缓存中保留UI数据的应用程序数量。 如果超出此上限，则最早的应用程序将从缓存中删除。 如果应用程序不在缓存中，如果从UI 界面访问它将不得不从磁盘加载。 |
| spark.history.ui.maxApplications | Int.MaxValue | 在历史记录摘要页面上显示的应用程序数量。 应用程序UI仍然可以通过直接访问其URL，即使它们不显示在历史记录摘要页面上。 |
| spark.history.provider | `org.apache.spark.deploy.history.FsHistoryProvider` | 执行应用程序历史后端的类的名称。目前只有一个实现，由Spark提供，它查找存储在文件系统中的应用程序日志。 |
| spark.history.fs.logDirectory | file:/tmp/spark-events | 为了文件系统的历史提供者，包含要加载的应用程序事件日志的目录URL。这可以是local `file://` 路径， HDFS `hdfs://namenode/shared/spark-logs` 或者是 Hadoop API支持的替代文件系统。 |
| spark.history.fs.update.interval | 10s | 文件系统历史的提供者在日志目录中检查新的或更新的日志期间。更短的时间间隔可以更快地检测新的应用程序，而不必更多服务器负载重新读取更新的应用程序。一旦更新完成，完成和未完成的应用程序的列表将反映更改。 |
| spark.history.retainedApplications | 50 | 在缓存中保留UI数据的应用程序数量。如果超出此上限，则最早的应用程序将从缓存中删除。如果应用程序不在缓存中，如果从UI 界面访问它将不得不从磁盘加载。 |
| spark.history.ui.maxApplications | Int.MaxValue | 在历史记录摘要页面上显示的应用程序数量。应用程序UI仍然可以通过直接访问其URL，即使它们不显示在历史记录摘要页面上。 |
| spark.history.ui.port | 18080 | history server 的Web界面绑定的端口。 |
| spark.history.kerberos.enabled | false | 表明 history server 是否应该使用kerberos进行登录。 如果 history server 正在访问安全的Hadoop集群上的HDFS文件，则需要这样做。 如果这是真的，它使用配置 `spark.history.kerberos.principal` 和 `spark.history.kerberos.keytab` |
| spark.history.kerberos.enabled | false | 表明 history server 是否应该使用kerberos进行登录。如果 history server 正在访问安全的Hadoop集群上的HDFS文件，则需要这样做。如果这是真的，它使用配置 `spark.history.kerberos.principal` 和 `spark.history.kerberos.keytab` |
| spark.history.kerberos.principal | (none) | history server 的Kerberos主要名称。 |
| spark.history.kerberos.keytab | (none) | history server 的kerberos keytab文件的位置。 |
| spark.history.ui.acls.enable | false | 指定是否应检查acls授权查看应用程序的用户。 如果启用，则进行访问控制检查，无论单个应用程序在运行时为 `spark.ui.acls.enable` 设置了什么。 应用程序所有者将始终有权查看自己的应用程序和通过 `spark.ui.view.acls` 指定的任何用户和通过`spark.ui.view.acls.groups`，当应用程序运行时也将有权查看该应用程序。 如果禁用，则不进行访问控制检查。 |
| spark.history.ui.admin.acls | empty | 通过逗号来分隔具有对history server中所有Spark应用程序的查看访问权限的用户/管理员列表。 默认情况下只允许在运行时查看应用程序的用户可以访问相关的应用程序历史记录，配置的用户/管理员也可以具有访问权限。 在列表中添加 "*" 表示任何用户都可以拥有管理员的权限。 |
| spark.history.ui.admin.acls.groups | empty | 通过逗号来分隔具有对history server中所有Spark应用程序的查看访问权限的组的列表。 默认情况下只允许在运行时查看应用程序的组可以访问相关的应用程序历史记录，配置的组也可以具有访问权限。 在列表中放置 "*" 表示任何组都可以拥有管理员权限。 |
| spark.history.ui.acls.enable | false | 指定是否应检查acls授权查看应用程序的用户。如果启用，则进行访问控制检查，无论单个应用程序在运行时为 `spark.ui.acls.enable` 设置了什么。应用程序所有者将始终有权查看自己的应用程序和通过 `spark.ui.view.acls` 指定的任何用户和通过`spark.ui.view.acls.groups`，当应用程序运行时也将有权查看该应用程序。如果禁用，则不进行访问控制检查。 |
| spark.history.ui.admin.acls | empty | 通过逗号来分隔具有对history server中所有Spark应用程序的查看访问权限的用户/管理员列表。默认情况下只允许在运行时查看应用程序的用户可以访问相关的应用程序历史记录，配置的用户/管理员也可以具有访问权限。在列表中添加 "*" 表示任何用户都可以拥有管理员的权限。 |
| spark.history.ui.admin.acls.groups | empty | 通过逗号来分隔具有对history server中所有Spark应用程序的查看访问权限的组的列表。默认情况下只允许在运行时查看应用程序的组可以访问相关的应用程序历史记录，配置的组也可以具有访问权限。在列表中放置 "*" 表示任何组都可以拥有管理员权限。 |
| spark.history.fs.cleaner.enabled | false | 指定 History Server是否应该定期从存储中清除事件日志。 |
| spark.history.fs.cleaner.interval | 1d | 文件系统 job history清洁程序多久检查要删除的文件。 如果文件比 `spark.history.fs.cleaner.maxAge` 更旧，那么它们将被删除。 |
| spark.history.fs.cleaner.interval | 1d | 文件系统 job history清洁程序多久检查要删除的文件。如果文件比 `spark.history.fs.cleaner.maxAge` 更旧，那么它们将被删除。 |
| spark.history.fs.cleaner.maxAge | 7d | 较早的Job history文件将在文件系统历史清除程序运行时被删除。 |
| spark.history.fs.numReplayThreads | 25% of available cores | history server 用于处理事件日志的线程数。 |
......@@ -70,9 +70,9 @@ history server 可以配置如下：
注意
1. history server 显示完成的和未完成的Spark作业。 如果应用程序在失败后进行多次尝试，将显示失败的尝试，以及任何持续未完成的尝试或最终成功的尝试。
1. history server 显示完成的和未完成的Spark作业。如果应用程序在失败后进行多次尝试，将显示失败的尝试，以及任何持续未完成的尝试或最终成功的尝试。
2. 未完成的程序只会间歇性地更新。 更新的时间间隔由更改文件的检查间隔 (`spark.history.fs.update.interval`) 定义。 在较大的集群上，更新间隔可能设置为较大的值。 查看正在运行的应用程序的方式实际上是查看自己的Web UI。
2. 未完成的程序只会间歇性地更新。更新的时间间隔由更改文件的检查间隔 (`spark.history.fs.update.interval`) 定义。在较大的集群上，更新间隔可能设置为较大的值。查看正在运行的应用程序的方式实际上是查看自己的Web UI。
3. 没有注册完成就退出的应用程序将被列出为未完成的，即使它们不再运行。如果应用程序崩溃，可能会发生这种情况。
......@@ -80,9 +80,9 @@ history server 可以配置如下：
## REST API
除了在UI中查看指标之外，还可以使用JSON。 这为开发人员提供了一种简单的方法来为Spark创建新的可视化和监控工具。 JSON可用于运行的应用程序和 history server。The endpoints are mounted at `/api/v1`。 例如，对于 history server，它们通常可以在 `http://&lt;server-url&gt;:18080/api/v1` 访问，对于正在运行的应用程序，在 `http://localhost:4040/api/v1`。
除了在UI中查看指标之外，还可以使用JSON。这为开发人员提供了一种简单的方法来为Spark创建新的可视化和监控工具。JSON可用于运行的应用程序和 history server。The endpoints are mounted at `/api/v1`。例如，对于 history server，它们通常可以在 `http://&lt;server-url&gt;:18080/api/v1` 访问，对于正在运行的应用程序，在 `http://localhost:4040/api/v1`。
在API中，一个应用程序被其应用程序ID `[app-id]`引用。 当运行在YARN上时，每个应用程序可能会有多次尝试，但是仅针对群集模式下的应用程序进行尝试，而不是客户端模式下的应用程序。 YARN群集模式中的应用程序可以通过它们的 `[attempt-id]`来识别。 在下面列出的API中，当以YARN集群模式运行时，`[app-id]`实际上是 `[base-app-id]/[attempt-id]`，其中 `[base-app-id]`YARN应用程序ID。
在API中，一个应用程序被其应用程序ID `[app-id]`引用。当运行在YARN上时，每个应用程序可能会有多次尝试，但是仅针对群集模式下的应用程序进行尝试，而不是客户端模式下的应用程序。YARN群集模式中的应用程序可以通过它们的 `[attempt-id]`来识别。在下面列出的API中，当以YARN集群模式运行时，`[app-id]`实际上是 `[base-app-id]/[attempt-id]`，其中 `[base-app-id]`YARN应用程序ID。
| Endpoint | 含义 |
| --- | --- |
......@@ -130,26 +130,26 @@ Example: `?offset=10&length=50&sortBy=runtime` |
| `/applications/[app-id]/streaming/batches/[batch-id]/operations/[outputOp-id]` | 给定操作和给定batch的详细信息。 |
| `/applications/[app-id]/environment` | 给定应用程序环境的详细信息。 |
可检索的 job 和 stage 的数量被standalone Spark UI 的相同保留机制所约束。 `"spark.ui.retainedJobs"` 定义触发job垃圾收集的阈值，以及 `spark.ui.retainedStages` 限定stage。 请注意，垃圾回收在play时进行：可以通过增加这些值并重新启动history server来检索更多条目。
可检索的 job 和 stage 的数量被standalone Spark UI 的相同保留机制所约束。`"spark.ui.retainedJobs"` 定义触发job垃圾收集的阈值，以及 `spark.ui.retainedStages` 限定stage。请注意，垃圾回收在play时进行：可以通过增加这些值并重新启动history server来检索更多条目。
### API 版本控制策略
这些 endpoint已被强力版本化，以便更容易开发应用程序。 特别是Spark保证：
这些 endpoint已被强力版本化，以便更容易开发应用程序。特别是Spark保证：
* endpoint 永远不会从一个版本中删除
* 任何给定 endpoint都不会删除个别字段
* 可以添加新的 endpoint
* 可以将新字段添加到现有 endpoint
* 将来可能会在单独的 endpoint添加新版本的api（例如: `api/v2`）。 新版本 _不_ 需要向后兼容。
* 将来可能会在单独的 endpoint添加新版本的api（例如: `api/v2`）。新版本 _不_ 需要向后兼容。
* Api版本可能会被删除，但只有在至少一个与新的api版本共存的次要版本之后才可以删除。
请注意，即使在检查正在运行的应用程序的UI时，仍然需要 `applications/[app-id]`部分，尽管只有一个应用程序可用。 例如：要查看正在运行的应用程序的作业列表，您可以访问 `http://localhost:4040/api/v1/applications/[app-id]/jobs`。 这是为了在两种模式下保持路径一致。
请注意，即使在检查正在运行的应用程序的UI时，仍然需要 `applications/[app-id]`部分，尽管只有一个应用程序可用。例如：要查看正在运行的应用程序的作业列表，您可以访问 `http://localhost:4040/api/v1/applications/[app-id]/jobs`。这是为了在两种模式下保持路径一致。
# Metrics
Spark具有基于[Dropwizard Metrics Library](http://metrics.dropwizard.io/)的可配置metrics系统。 这允许用户将Spark metrics报告给各种接收器，包括HTTP，JMX和CSV文件。 metrics系统是通过配置文件进行配置的，Spark配置文件是Spark预计出现在 `$SPARK_HOME/conf/metrics.properties`上。 可以通过`spark.metrics.conf` [配置属性](configuration.html#spark-properties)指定自定义文件位置。 默认情况下，用于 driver或 executor metrics标准的根命名空间是 `spark.app.id`的值。 然而，通常用户希望能够跟踪 driver和executors的应用程序的metrics，这与应用程序ID（即：`spark.app.id`）很难相关，因为每次调用应用程序都会发生变化。 对于这种用例，可以为使用 `spark.metrics.namespace`配置属性的metrics报告指定自定义命名空间。 例如，如果用户希望将度量命名空间设置为应用程序的名称，则可以将`spark.metrics.namespace`属性设置为像 `${spark.app.name}`这样的值。 然后，该值会被Spark适当扩展，并用作度量系统的根命名空间。 非 driver和 executor的metrics标准永远不会以 `spark.app.id`为前缀，`spark.metrics.namespace`属性也不会对这些metrics有任何这样的影响。
Spark具有基于[Dropwizard Metrics Library](http://metrics.dropwizard.io/)的可配置metrics系统。这允许用户将Spark metrics报告给各种接收器，包括HTTP，JMX和CSV文件。metrics系统是通过配置文件进行配置的，Spark配置文件是Spark预计出现在 `$SPARK_HOME/conf/metrics.properties`上。可以通过`spark.metrics.conf` [配置属性](configuration.html#spark-properties)指定自定义文件位置。默认情况下，用于 driver或 executor metrics标准的根命名空间是 `spark.app.id`的值。然而，通常用户希望能够跟踪 driver和executors的应用程序的metrics，这与应用程序ID（即：`spark.app.id`）很难相关，因为每次调用应用程序都会发生变化。对于这种用例，可以为使用 `spark.metrics.namespace`配置属性的metrics报告指定自定义命名空间。例如，如果用户希望将度量命名空间设置为应用程序的名称，则可以将`spark.metrics.namespace`属性设置为像 `${spark.app.name}`这样的值。然后，该值会被Spark适当扩展，并用作度量系统的根命名空间。非 driver和 executor的metrics标准永远不会以 `spark.app.id`为前缀，`spark.metrics.namespace`属性也不会对这些metrics有任何这样的影响。
Spark的metrics被分解为与Spark组件相对应的不同_instances_。 在每个实例中，您可以配置一组报告汇总指标。 目前支持以下实例：
Spark的metrics被分解为与Spark组件相对应的不同_instances_。在每个实例中，您可以配置一组报告汇总指标。目前支持以下实例：
* `master`: Spark standalone的 master进程。
* `applications`: 主机内的一个组件，报告各种应用程序。
......@@ -158,7 +158,7 @@ Spark的metrics被分解为与Spark组件相对应的不同_instances_。 在每
* `driver`: Spark driver进程（创建SparkContext的过程）。
* `shuffleService`: The Spark shuffle service.
每个实例可以报告为 0 或更多 _sinks_。 Sinks包含在 `org.apache.spark.metrics.sink`包中：
每个实例可以报告为 0 或更多 _sinks_。Sinks包含在 `org.apache.spark.metrics.sink`包中：
* `ConsoleSink`: 将metrics信息记录到控制台。
* `CSVSink`: 定期将metrics数据导出到CSV文件。
......@@ -171,7 +171,7 @@ Spark还支持由于许可限制而不包含在默认构建中的Ganglia接收
* `GangliaSink`: 向Ganglia节点或 multicast组发送metrics。
要安装 `GangliaSink` ，您需要执行Spark的自定义构建。 _**请注意，通过嵌入此库，您将包括 [LGPL](http://www.gnu.org/copyleft/lesser.html)-licensed Spark包中的代码**_。 对于sbt用户，在构建之前设置 `SPARK_GANGLIA_LGPL`环境变量。 对于Maven用户，启用 `-Pspark-ganglia-lgpl`配置文件。 除了修改集群的Spark构建用户，应用程序还需要链接到 `spark-ganglia-lgpl`工件。
要安装 `GangliaSink` ，您需要执行Spark的自定义构建。_**请注意，通过嵌入此库，您将包括 [LGPL](http://www.gnu.org/copyleft/lesser.html)-licensed Spark包中的代码**_。对于sbt用户，在构建之前设置 `SPARK_GANGLIA_LGPL`环境变量。对于Maven用户，启用 `-Pspark-ganglia-lgpl`配置文件。除了修改集群的Spark构建用户，应用程序还需要链接到 `spark-ganglia-lgpl`工件。
metrics配置文件的语法在示例配置文件 `$SPARK_HOME/conf/metrics.properties.template`中定义。
......
docs/22.md
浏览文件 @ 3b007b11
......@@ -14,16 +14,16 @@
* [数据本地化](#数据本地化)
* [概要](#概要)
由于大多数 Spark 计算的内存性质， Spark 程序可能由集群中的任何资源（ CPU ，网络带宽或内存）导致瓶颈。 通常情况下，如果数据有合适的内存，瓶颈就是网络带宽，但有时您还需要进行一些调整，例如 [以序列化形式存储 RDD](programming-guide.html#rdd-persistence) 来减少内存的使用。 本指南将涵盖两个主要的主题：数据序列化，这对于良好的网络性能至关重要，并且还可以减少内存使用和内存优化。 我们选几个较小的主题进行展开。
由于大多数 Spark 计算的内存性质， Spark 程序可能由集群中的任何资源（ CPU ，网络带宽或内存）导致瓶颈。通常情况下，如果数据有合适的内存，瓶颈就是网络带宽，但有时您还需要进行一些调整，例如 [以序列化形式存储 RDD](programming-guide.html#rdd-persistence) 来减少内存的使用。本指南将涵盖两个主要的主题：数据序列化，这对于良好的网络性能至关重要，并且还可以减少内存使用和内存优化。我们选几个较小的主题进行展开。
# 数据序列化
序列化在任何分布式应用程序的性能中起着重要的作用。 很慢的将对象序列化或消费大量字节的格式将会大大减慢计算速度。 通常，这可能是您优化 Spark 应用程序的第一件事。 Spark 宗旨在于方便和性能之间取得一个平衡（允许您使用操作中的任何 Java 类型）。 它提供了两种序列化库：
序列化在任何分布式应用程序的性能中起着重要的作用。很慢的将对象序列化或消费大量字节的格式将会大大减慢计算速度。通常，这可能是您优化 Spark 应用程序的第一件事。Spark 宗旨在于方便和性能之间取得一个平衡（允许您使用操作中的任何 Java 类型）。它提供了两种序列化库：
* [Java serialization](http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html): 默认情况下，使用 Java `ObjectOutputStream` 框架的 Spark 序列化对象，并且可以与您创建的任何实现 [`java.io.Serializable`](http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html) 的类一起使用。 您还可以通过扩展 [`java.io.Externalizable`](http://docs.oracle.com/javase/6/docs/api/java/io/Externalizable.html) 来更紧密地控制序列化的性能。 Java 序列化是灵活的，但通常相当缓慢，并导致许多类的大型序列化格式。
* [Kryo serialization](https://github.com/EsotericSoftware/kryo): Spark 也可以使用 Kryo 库（版本2）来更快地对对象进行序列化。 Kryo 比 Java 序列化（通常高达10x）要快得多，而且更紧凑，但并不支持所有的 `Serializable` 类型，并且需要先_注册_您将在程序中使用的类以获得最佳性能。
* [Java serialization](http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html): 默认情况下，使用 Java `ObjectOutputStream` 框架的 Spark 序列化对象，并且可以与您创建的任何实现 [`java.io.Serializable`](http://docs.oracle.com/javase/6/docs/api/java/io/Serializable.html) 的类一起使用。您还可以通过扩展 [`java.io.Externalizable`](http://docs.oracle.com/javase/6/docs/api/java/io/Externalizable.html) 来更紧密地控制序列化的性能。Java 序列化是灵活的，但通常相当缓慢，并导致许多类的大型序列化格式。
* [Kryo serialization](https://github.com/EsotericSoftware/kryo): Spark 也可以使用 Kryo 库（版本2）来更快地对对象进行序列化。Kryo 比 Java 序列化（通常高达10x）要快得多，而且更紧凑，但并不支持所有的 `Serializable` 类型，并且需要先_注册_您将在程序中使用的类以获得最佳性能。
您可以通过使用 [SparkConf](configuration.html#spark-properties) 初始化作业 并进行调用来切换到使用 Kryo `conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")`。此设置配置用于不仅在工作节点之间进行洗牌数据的串行器，而且还将 RDD 序列化到磁盘。 Kryo 不是默认的唯一原因是因为自定义注册要求，但我们建议您尝试在任何网络密集型应用程序。自从 Spark 2.0.0 以来，我们在使用简单类型，简单类型的数组或字符串类型对RDD进行混洗时，内部使用 Kryo serializer 。
您可以通过使用 [SparkConf](configuration.html#spark-properties) 初始化作业 并进行调用来切换到使用 Kryo `conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")`。此设置配置用于不仅在工作节点之间进行洗牌数据的串行器，而且还将 RDD 序列化到磁盘。Kryo 不是默认的唯一原因是因为自定义注册要求，但我们建议您尝试在任何网络密集型应用程序。自从 Spark 2.0.0 以来，我们在使用简单类型，简单类型的数组或字符串类型对RDD进行混洗时，内部使用 Kryo serializer 。
Spark 自动包含 Kryo 序列化器，用于 [Twitter chill](https://github.com/twitter/chill) 中 AllScalaRegistrar 涵盖的许多常用的核心 Scala 类。
......@@ -67,7 +67,7 @@ Spark 中的内存使用大部分属于两类：执行和存储。执行存储
虽然有两种相关配置，但典型用户不需要调整它们，因为默认值适用于大多数工作负载：
* `spark.memory.fraction` 表示大小 `M`（JVM堆空间 - 300MB）（默认为0.6）的一小部分。剩余的空间（40％）保留用于用户数据结构，Spark中的内部元数据，并且在稀疏和异常大的记录的情况下保护OOM错误。
* `spark.memory.storageFraction` 表示大小 `R` 为 `M` （默认为0.5）的一小部分。 `R` 是 `M` 缓存块中的缓存被执行驱逐的存储空间。
* `spark.memory.storageFraction` 表示大小 `R` 为 `M` （默认为0.5）的一小部分。`R` 是 `M` 缓存块中的缓存被执行驱逐的存储空间。
`spark.memory.fraction` 应该设置值，以便在 JVM 的旧版或”终身”版本中舒适地适应这一堆堆空间。有关详细信息，请参阅下面高级 GC 调优的讨论。
......@@ -88,11 +88,11 @@ Spark 中的内存使用大部分属于两类：执行和存储。执行存储
## 序列化 RDD 存储
当您的对象仍然太大而无法有效存储，尽管这种调整，减少内存使用的一个更简单的方法是以序列化形式存储它们，使用 [RDD 持久性 API](programming-guide.html#rdd-persistence) 中的序列化 StorageLevel ，例如： `MEMORY_ONLY_SER` 。 Spark 将会将每个 RDD 分区存储为一个大字节数组。以序列化形式存储数据的唯一缺点是访问时间较短，因为必须对每个对象进行反序列化。如果您想以序列化形式缓存数据，我们强烈建议[使用 Kryo](#data-serialization) ，因为它导致比 Java 序列化更小的尺寸（而且肯定比原 Java 对象）更小。
当您的对象仍然太大而无法有效存储，尽管这种调整，减少内存使用的一个更简单的方法是以序列化形式存储它们，使用 [RDD 持久性 API](programming-guide.html#rdd-persistence) 中的序列化 StorageLevel ，例如： `MEMORY_ONLY_SER` 。Spark 将会将每个 RDD 分区存储为一个大字节数组。以序列化形式存储数据的唯一缺点是访问时间较短，因为必须对每个对象进行反序列化。如果您想以序列化形式缓存数据，我们强烈建议[使用 Kryo](#data-serialization) ，因为它导致比 Java 序列化更小的尺寸（而且肯定比原 Java 对象）更小。
## 垃圾收集调整
当您的程序存储的 RDD 有很大的”流失”时， JVM 垃圾收集可能是一个问题。（程序中通常没有问题，只读一次 RDD ，然后在其上运行许多操作）。 当 Java 需要驱逐旧对象为新的对象腾出空间时，需要跟踪所有 Java 对象并找到未使用的。要记住的要点是，垃圾收集的成本与 Java 对象的数量成正比，因此使用较少对象的数据结构（例如： `Ints` 数组，而不是 `LinkedList` ）大大降低了此成本。 一个更好的方法是如上所述以序列化形式持久化对象：现在每个 RDD 分区只有一个对象（一个字节数组）。 在尝试其他技术之前，如果 GC 是一个问题，首先要使用[序列化缓存](#serialized-rdd-storage)。
当您的程序存储的 RDD 有很大的”流失”时， JVM 垃圾收集可能是一个问题。（程序中通常没有问题，只读一次 RDD ，然后在其上运行许多操作）。当 Java 需要驱逐旧对象为新的对象腾出空间时，需要跟踪所有 Java 对象并找到未使用的。要记住的要点是，垃圾收集的成本与 Java 对象的数量成正比，因此使用较少对象的数据结构（例如： `Ints` 数组，而不是 `LinkedList` ）大大降低了此成本。一个更好的方法是如上所述以序列化形式持久化对象：现在每个 RDD 分区只有一个对象（一个字节数组）。在尝试其他技术之前，如果 GC 是一个问题，首先要使用[序列化缓存](#serialized-rdd-storage)。
由于任务的工作记忆（运行任务所需的空间）和缓存在节点上的 RDD 之间的干扰， GC 也可能是一个问题。我们将讨论如何控制分配给RDD缓存的空间来减轻这一点。
......@@ -104,7 +104,7 @@ GC 调整的第一步是收集关于垃圾收集发生频率和GC花费的时间
为了进一步调整垃圾收集，我们首先需要了解一些关于 JVM 内存管理的基本信息：
* Java堆空间分为两个区域 Young 和 Old 。 Young 一代的目的是持有短命的物体，而 Old 一代的目标是使用寿命更长的物体。
* Java堆空间分为两个区域 Young 和 Old 。Young 一代的目的是持有短命的物体，而 Old 一代的目标是使用寿命更长的物体。
* Young 一代进一步分为三个区域[ Eden ， Survivor1 ， Survivor2 ]。
......@@ -136,15 +136,15 @@ Spark 中 GC 调优的目的是确保只有长寿命的 RDD 存储在 Old 版本
## 减少任务的内存使用
有时，您将得到一个 OutOfMemoryError ，因为您的 RDD 不适合内存，而是因为您的其中一个任务的工作集（如其中一个 reduce 任务`groupByKey`）太大。 Spark 的 shuffle 操作（`sortByKey`， `groupByKey`， `reduceByKey`， `join`，等）建立每个任务中的哈希表来进行分组，而这往往是很大的。这里最简单的解决方案是_增加并行级别_，以便每个任务的输入集都更小。 Spark 可以有效地支持短达200 ms 的任务，因为它可以将多个任务中的一个执行者JVM重用，并且任务启动成本低，因此您可以将并行级别安全地提高到集群中的核心数量。
有时，您将得到一个 OutOfMemoryError ，因为您的 RDD 不适合内存，而是因为您的其中一个任务的工作集（如其中一个 reduce 任务`groupByKey`）太大。Spark 的 shuffle 操作（`sortByKey`， `groupByKey`， `reduceByKey`， `join`，等）建立每个任务中的哈希表来进行分组，而这往往是很大的。这里最简单的解决方案是_增加并行级别_，以便每个任务的输入集都更小。Spark 可以有效地支持短达200 ms 的任务，因为它可以将多个任务中的一个执行者JVM重用，并且任务启动成本低，因此您可以将并行级别安全地提高到集群中的核心数量。
## 广播大的变量
使用 可用的[广播功能](programming-guide.html#broadcast-variables) `SparkContext` 可以大大减少每个序列化任务的大小，以及在群集上启动作业的成本。如果您的任务使用其中的驱动程序中的任何大对象（例如：静态查找表），请考虑将其变为广播变量。 Spark 打印主机上每个任务的序列化大小，因此您可以查看该任务以决定您的任务是否过大; 一般任务大于20 KB大概值得优化。
使用 可用的[广播功能](programming-guide.html#broadcast-variables) `SparkContext` 可以大大减少每个序列化任务的大小，以及在群集上启动作业的成本。如果您的任务使用其中的驱动程序中的任何大对象（例如：静态查找表），请考虑将其变为广播变量。Spark 打印主机上每个任务的序列化大小，因此您可以查看该任务以决定您的任务是否过大; 一般任务大于20 KB大概值得优化。
## 数据本地化
数据本地化可能会对 Spark job 的性能产生重大影响。如果数据和在其上操作的代码在一起，则计算往往是快速的。但如果代码和数据分开，则必须移动到另一个。通常，代码大小远小于数据，因此将数据代码从一个地方寄送到另一个地方比一大块数据更快。 Spark 围绕数据局部性的一般原则构建其调度。
数据本地化可能会对 Spark job 的性能产生重大影响。如果数据和在其上操作的代码在一起，则计算往往是快速的。但如果代码和数据分开，则必须移动到另一个。通常，代码大小远小于数据，因此将数据代码从一个地方寄送到另一个地方比一大块数据更快。Spark 围绕数据局部性的一般原则构建其调度。
数据本地化是指数据和代码处理有多近。根据数据的当前位置有几个地方级别。从最近到最远的顺序：
......
docs/23.md
浏览文件 @ 3b007b11
......@@ -79,7 +79,7 @@ Spark会分轮次来申请执行器。实际的资源申请，会在任务挂起
默认，Spark 应用内部使用 FIFO 调度策略。每个作业被划分为多个阶段（stage）（例如 : map 阶段和 reduce 阶段），第一个作业在其启动后会优先获取所有的可用资源，然后是第二个作业再申请，再第三个……。如果前面的作业没有把集群资源占满，则后续的作业可以立即启动运行，否则，后提交的作业会有明显的延迟等待。
不过从 Spark 0.8 开始，Spark 也能支持各个作业间的公平（Fair）调度。公平调度时，Spark 以轮询的方式给每个作业分配资源，因此所有的作业获得的资源大体上是平均分配。这意味着，即使有大作业在运行，小的作业再提交也能立即获得计算资源而不是等待前面的作业结束，大大减少了延迟时间。这种模式特别适合于多用户配置。 要启用公平调度器，只需设置一下 SparkContext 中 spark.scheduler.mode 属性为 FAIR 即可 :
不过从 Spark 0.8 开始，Spark 也能支持各个作业间的公平（Fair）调度。公平调度时，Spark 以轮询的方式给每个作业分配资源，因此所有的作业获得的资源大体上是平均分配。这意味着，即使有大作业在运行，小的作业再提交也能立即获得计算资源而不是等待前面的作业结束，大大减少了延迟时间。这种模式特别适合于多用户配置。要启用公平调度器，只需设置一下 SparkContext 中 spark.scheduler.mode 属性为 FAIR 即可 :
......
docs/27.md
浏览文件 @ 3b007b11
......@@ -90,7 +90,7 @@ Spark 现在与一个独立的 Maven 安装包封装到了一起，以便从位
## 使用 Hive 和 JDBC 支持构建
要启用 Spark SQL 及其 JDBC server 和 CLI 的 Hive 集成，将 `-Phive` 和 `Phive-thriftserver` 配置文件添加到现有的构建选项中。 默认情况下， Spark 将使用 Hive 1.2.1 绑定构建。
要启用 Spark SQL 及其 JDBC server 和 CLI 的 Hive 集成，将 `-Phive` 和 `Phive-thriftserver` 配置文件添加到现有的构建选项中。默认情况下， Spark 将使用 Hive 1.2.1 绑定构建。
```
# With Hive 1.2.1 support
......@@ -99,7 +99,7 @@ Spark 现在与一个独立的 Maven 安装包封装到了一起，以便从位
## 打包没有 Hadoop 依赖关系的 YARN
默认情况下，由 `mvn package` 生成的 assembly directory （组件目录）将包含所有的Spark 依赖，包括 Hadoop 及其一些生态系统项目。 在 YARN 部署中，导致这些的多个版本显示在执行器 classpaths 上： Spark 组件的打包的版本和每个节点上的版本，包含在 `yarn.application.classpath` 中。 `hadoop-provided` 配置文件构建了不包括 Hadoop 生态系统项目的组件，就像 ZooKeeper 和 Hadoop 本身。
默认情况下，由 `mvn package` 生成的 assembly directory （组件目录）将包含所有的Spark 依赖，包括 Hadoop 及其一些生态系统项目。在 YARN 部署中，导致这些的多个版本显示在执行器 classpaths 上： Spark 组件的打包的版本和每个节点上的版本，包含在 `yarn.application.classpath` 中。`hadoop-provided` 配置文件构建了不包括 Hadoop 生态系统项目的组件，就像 ZooKeeper 和 Hadoop 本身。
## 使用 Mesos 构建
......@@ -154,7 +154,7 @@ $ ../build/mvn scala:cc
## 使用 SBT 构建
Maven 是推荐用于打包 Spark 的官方构建工具，是 _build of reference_ 。但是 SBT 支持日常开发，因为它可以提供更快的迭代编译。更多高级的开发者可能希望使用 SBT 。SBT 构建是从 Maven POM 文件导出的，因此也是相同的 Maven 配置文件和变量可以设置来控制 SBT 构建。 例如：
Maven 是推荐用于打包 Spark 的官方构建工具，是 _build of reference_ 。但是 SBT 支持日常开发，因为它可以提供更快的迭代编译。更多高级的开发者可能希望使用 SBT 。SBT 构建是从 Maven POM 文件导出的，因此也是相同的 Maven 配置文件和变量可以设置来控制 SBT 构建。例如：
```
./build/sbt package
......@@ -164,11 +164,11 @@ Maven 是推荐用于打包 Spark 的官方构建工具，是 _build of referenc
## 加速编译
经常编译 Spark 的开发人员可能希望加快编译速度; 例如通过使用 Zinc（对于使用 Maven 构建的开发人员）或避免重新编译组件 JAR （对于使用 SBT 构建的开发人员）。 有关如何执行此操作的更多信息，请参阅 [有用的开发工具页面](http://spark.apache.org/developer-tools.html#reducing-build-times) 。
经常编译 Spark 的开发人员可能希望加快编译速度; 例如通过使用 Zinc（对于使用 Maven 构建的开发人员）或避免重新编译组件 JAR （对于使用 SBT 构建的开发人员）。有关如何执行此操作的更多信息，请参阅 [有用的开发工具页面](http://spark.apache.org/developer-tools.html#reducing-build-times) 。
## 加密文件系统
当在加密文件系统上构建时（例如，如果您的 home 目录是加密的），则 Spark 构建可能会失败，并导致 “Filename too long” 错误。 作为解决方法，在项目 `pom.xml` 中的 `scala-maven-plugin` 的配置参数中添加以下内容：
当在加密文件系统上构建时（例如，如果您的 home 目录是加密的），则 Spark 构建可能会失败，并导致 “Filename too long” 错误。作为解决方法，在项目 `pom.xml` 中的 `scala-maven-plugin` 的配置参数中添加以下内容：
```
<arg>-Xmax-classfile-name</arg>
......@@ -181,7 +181,7 @@ Maven 是推荐用于打包 Spark 的官方构建工具，是 _build of referenc
scalacOptions in Compile ++= Seq("-Xmax-classfile-name", "128"),
```
到 `sharedSettings` val。 如果您不确定添加这些行的位置，请参阅 [this PR](https://github.com/apache/spark/pull/2883/files) 。
到 `sharedSettings` val。如果您不确定添加这些行的位置，请参阅 [this PR](https://github.com/apache/spark/pull/2883/files) 。
## IntelliJ IDEA 或 Eclipse
......@@ -211,7 +211,7 @@ scalacOptions in Compile ++= Seq("-Xmax-classfile-name", "128"),
## PySpark pip 可安装
如果您正在构建 Spark 以在 Python 环境中使用，并且希望对其进行 pip 安装，那么您将首先需要如上所述构建 Spark JARs 。 然后，您可以构建适合于 setup.py 和 pip 可安装软件包的 sdist 软件包。
如果您正在构建 Spark 以在 Python 环境中使用，并且希望对其进行 pip 安装，那么您将首先需要如上所述构建 Spark JARs 。然后，您可以构建适合于 setup.py 和 pip 可安装软件包的 sdist 软件包。
```
cd python; python setup.py sdist
......@@ -254,7 +254,7 @@ R -e "install.packages(c('knitr', 'rmarkdown', 'testthat', 'e1071', 'survival'),
## 运行基于 Docker 的集成测试套装
为了运行 Docker 集成测试，你必须在你的 box 上安装 `docker` engine （引擎）。 有关安装说明，请参见 [Docker 站点](https://docs.docker.com/engine/installation/)。 一旦安装，如果还没有运行 Docker 服务，`docker` service 就需要启动。 在 Linux 上，这可以通过 `sudo service docker start` 来完成。
为了运行 Docker 集成测试，你必须在你的 box 上安装 `docker` engine （引擎）。有关安装说明，请参见 [Docker 站点](https://docs.docker.com/engine/installation/)。一旦安装，如果还没有运行 Docker 服务，`docker` service 就需要启动。在 Linux 上，这可以通过 `sudo service docker start` 来完成。
```
./build/mvn install -DskipTests
......
docs/4.md
浏览文件 @ 3b007b11
......@@ -170,7 +170,7 @@ sc = SparkContext(conf=conf)
这个 `appName` 参数是一个在集群 UI 上展示应用程序的名称。 `master` 是一个 [Spark, Mesos 或 YARN 的 cluster URL](submitting-applications.html#master-urls)，或者指定为在 local mode（本地模式）中运行的 “local” 字符串。在实际工作中，当在集群上运行时，您不希望在程序中将 master 给硬编码，而是用 [使用 `spark-submit` 启动应用](submitting-applications.html) 并且接收它。然而，对于本地测试和单元测试，您可以通过 “local” 来运行 Spark 进程。
这个 `appName` 参数是一个在集群 UI 上展示应用程序的名称。`master` 是一个 [Spark, Mesos 或 YARN 的 cluster URL](submitting-applications.html#master-urls)，或者指定为在 local mode（本地模式）中运行的 “local” 字符串。在实际工作中，当在集群上运行时，您不希望在程序中将 master 给硬编码，而是用 [使用 `spark-submit` 启动应用](submitting-applications.html) 并且接收它。然而，对于本地测试和单元测试，您可以通过 “local” 来运行 Spark 进程。
## 使用 Shell
......@@ -301,7 +301,7 @@ Once created, the distributed dataset (`distData`) can be operated on in paralle
## 外部 Datasets（数据集）
Spark 可以从 Hadoop 所支持的任何存储源中创建 distributed dataset（分布式数据集），包括本地文件系统，HDFS，Cassandra，HBase，[Amazon S3](http://wiki.apache.org/hadoop/AmazonS3) 等等。 Spark 支持文本文件，[SequenceFiles](http://hadoop.apache.org/common/docs/current/api/org/apache/hadoop/mapred/SequenceFileInputFormat.html)，以及任何其它的 Hadoop [InputFormat](http://hadoop.apache.org/docs/stable/api/org/apache/hadoop/mapred/InputFormat.html)。
Spark 可以从 Hadoop 所支持的任何存储源中创建 distributed dataset（分布式数据集），包括本地文件系统，HDFS，Cassandra，HBase，[Amazon S3](http://wiki.apache.org/hadoop/AmazonS3) 等等。Spark 支持文本文件，[SequenceFiles](http://hadoop.apache.org/common/docs/current/api/org/apache/hadoop/mapred/SequenceFileInputFormat.html)，以及任何其它的 Hadoop [InputFormat](http://hadoop.apache.org/docs/stable/api/org/apache/hadoop/mapred/InputFormat.html)。
可以使用 `SparkContext` 的 `textFile` 方法来创建文本文件的 RDD。此方法需要一个文件的 URI（计算机上的本地路径 ，`hdfs://`，`s3n://` 等等的 URI），并且读取它们作为一个 lines（行）的集合。下面是一个调用示例:
......@@ -896,7 +896,7 @@ We could also use `counts.sortByKey()`, for example, to sort the pairs alphabeti
| **countByKey**() | 仅适用于（K,V）类型的 RDD 。返回具有每个 key 的计数的 （K , Int）pairs 的 hashmap. |
| **foreach**(_func_) | 对 dataset 中每个元素运行函数 _func_ 。这通常用于副作用（side effects），例如更新一个 [Accumulator](#accumulators)（累加器）或与外部存储系统（external storage systems）进行交互。**Note**：修改除 `foreach()`之外的累加器以外的变量（variables）可能会导致未定义的行为（undefined behavior）。详细介绍请阅读 [Understanding closures（理解闭包）](#understanding-closures-a-nameclosureslinka) 部分. |
该 Spark RDD API 还暴露了一些 actions（操作）的异步版本，例如针对 `foreach` 的 `foreachAsync`，它们会立即返回一个`FutureAction` 到调用者，而不是在完成 action 时阻塞。 这可以用于管理或等待 action 的异步执行。.
该 Spark RDD API 还暴露了一些 actions（操作）的异步版本，例如针对 `foreach` 的 `foreachAsync`，它们会立即返回一个`FutureAction` 到调用者，而不是在完成 action 时阻塞。这可以用于管理或等待 action 的异步执行。.
### Shuffle 操作
......@@ -958,7 +958,7 @@ Spark 的存储级别的选择，核心问题是在 memory 内存使用率和 CP
* 如果您的 RDD 适合于默认存储级别 (`MEMORY_ONLY`), leave them that way. 这是CPU效率最高的选项，允许RDD上的操作尽可能快地运行.
* 如果不是, 试着使用 `MEMORY_ONLY_SER` 和 [selecting a fast serialization library](tuning.html) 以使对象更加节省空间，但仍然能够快速访问。 (Java和Scala)
* 如果不是, 试着使用 `MEMORY_ONLY_SER` 和 [selecting a fast serialization library](tuning.html) 以使对象更加节省空间，但仍然能够快速访问。(Java和Scala)
* 不要溢出到磁盘，除非计算您的数据集的函数是昂贵的, 或者它们过滤大量的数据. 否则, 重新计算分区可能与从磁盘读取分区一样快.
......@@ -966,7 +966,7 @@ Spark 的存储级别的选择，核心问题是在 memory 内存使用率和 CP
### 删除数据
Spark 会自动监视每个节点上的缓存使用情况，并使用 least-recently-used（LRU）的方式来丢弃旧数据分区。 如果您想手动删除 RDD 而不是等待它掉出缓存，使用 `RDD.unpersist()` 方法。
Spark 会自动监视每个节点上的缓存使用情况，并使用 least-recently-used（LRU）的方式来丢弃旧数据分区。如果您想手动删除 RDD 而不是等待它掉出缓存，使用 `RDD.unpersist()` 方法。
# 共享变量
......@@ -1021,7 +1021,7 @@ broadcastVar.value();
Accumulators（累加器）是一个仅可以执行 “added”（添加）的变量来通过一个关联和交换操作，因此可以高效地执行支持并行。累加器可以用于实现 counter（ 计数，类似在 MapReduce 中那样）或者 sums（求和）。原生 Spark 支持数值型的累加器，并且程序员可以添加新的支持类型。
作为一个用户，您可以创建 accumulators（累加器）并且重命名. 如下图所示, 一个命名的 accumulator 累加器（在这个例子中是 `counter`）将显示在 web UI 中，用于修改该累加器的阶段。 Spark 在 “Tasks” 任务表中显示由任务修改的每个累加器的值.
作为一个用户，您可以创建 accumulators（累加器）并且重命名. 如下图所示, 一个命名的 accumulator 累加器（在这个例子中是 `counter`）将显示在 web UI 中，用于修改该累加器的阶段。Spark 在 “Tasks” 任务表中显示由任务修改的每个累加器的值.
![Accumulators in the Spark UI](img/15dfb146313300f30241c551010cf1a0.jpg "Accumulators in the Spark UI")
......@@ -1078,7 +1078,7 @@ sc.register(myVectorAcc, "MyVectorAcc1")
A numeric accumulator can be created by calling `SparkContext.longAccumulator()` or `SparkContext.doubleAccumulator()` to accumulate values of type Long or Double, respectively. Tasks running on a cluster can then add to it using the `add` method. However, they cannot read its value. Only the driver program can read the accumulator’s value, using its `value` method.
可以通过调用 `SparkContext.longAccumulator()` 或 `SparkContext.doubleAccumulator()` 来创建一个数值累加器分别累积 Long 或 Double 类型的值。 然后可以使用群集中的任务进行添加 `add` 方法。 但是，他们看不到它的 value（值）。 只有 driver 可以读取累加器的值，使用它的 `value` 方法.
可以通过调用 `SparkContext.longAccumulator()` 或 `SparkContext.doubleAccumulator()` 来创建一个数值累加器分别累积 Long 或 Double 类型的值。然后可以使用群集中的任务进行添加 `add` 方法。但是，他们看不到它的 value（值）。只有 driver 可以读取累加器的值，使用它的 `value` 方法.
下面的代码显示了一个累加器用于将数组的元素相加:
......
docs/6.md
浏览文件 @ 3b007b11
......@@ -518,7 +518,7 @@ The batch interval must be set based on the latency requirements of your applica
![Spark Streaming](img/5269c32b4eab09bcd3ce4380a4dc0408.jpg "Spark Streaming data flow")
这些底层的 RDD 变换由 Spark 引擎（engine）计算。 DStream 操作隐藏了大多数这些细节并为了方便起见，提供给了开发者一个更高级别的 API 。这些操作细节会在后边的章节中讨论。
这些底层的 RDD 变换由 Spark 引擎（engine）计算。DStream 操作隐藏了大多数这些细节并为了方便起见，提供给了开发者一个更高级别的 API 。这些操作细节会在后边的章节中讨论。
* * *
......@@ -768,7 +768,7 @@ Spark Streaming 也支持 _windowed computations（窗口计算）_，它允许
![Spark Streaming](img/1b937bade7446f9fd81619d91c662d70.jpg "Spark Streaming data flow")
如上图显示，窗口在源 DStream 上 _slides（滑动）_，合并和操作落入窗内的源 RDDs，产生窗口化的 DStream 的 RDDs。在这个具体的例子中，程序在三个时间单元的数据上进行窗口操作，并且每两个时间单元滑动一次。 这说明，任何一个窗口操作都需要指定两个参数.
如上图显示，窗口在源 DStream 上 _slides（滑动）_，合并和操作落入窗内的源 RDDs，产生窗口化的 DStream 的 RDDs。在这个具体的例子中，程序在三个时间单元的数据上进行窗口操作，并且每两个时间单元滑动一次。这说明，任何一个窗口操作都需要指定两个参数.
* _window length（窗口长度）_ - 窗口的持续时间（图 3）.
* _sliding interval（滑动间隔）_ - 执行窗口操作的间隔（图 2）.
......
docs/7.md
浏览文件 @ 3b007b11
此差异已折叠。
docs/9.md
浏览文件 @ 3b007b11
......@@ -52,7 +52,7 @@ import org.apache.spark.rdd.RDD
# 属性 Graph
[属性 Graph](api/scala/index.html#org.apache.spark.graphx.Graph) 是一个定向多重图形，用户定义的对象附加到每个顶点和边缘。定向多图是具有共享相同源和目标顶点的潜在多个平行边缘的有向图。支持平行边缘的能力简化了在相同顶点之间可以有多个关系（例如： 同事和朋友）的建模场景。每个顶点都由唯一的64位长标识符（ `VertexId` ）键入。 GraphX 不对顶点标识符施加任何排序约束。类似地，边缘具有对应的源和目标顶点标识符。
[属性 Graph](api/scala/index.html#org.apache.spark.graphx.Graph) 是一个定向多重图形，用户定义的对象附加到每个顶点和边缘。定向多图是具有共享相同源和目标顶点的潜在多个平行边缘的有向图。支持平行边缘的能力简化了在相同顶点之间可以有多个关系（例如： 同事和朋友）的建模场景。每个顶点都由唯一的64位长标识符（ `VertexId` ）键入。GraphX 不对顶点标识符施加任何排序约束。类似地，边缘具有对应的源和目标顶点标识符。
属性图是通过 vertex (`VD`)和 edge (`ED`) 类型进行参数化的。这些是分别与每个顶点和边缘相关联的对象的类型。
......@@ -87,7 +87,7 @@ class Graph[VD, ED] {
`VertexRDD[VD]` 和 `EdgeRDD[ED]` 分别扩展了 `RDD[(VertexId, VD)]` 和 `RDD[Edge[ED]]` 的优化版本。 `VertexRDD[VD]` 和 `EdgeRDD[ED]` 都提供了围绕图计算和利用内部优化的附加功能。 我们在[顶点和边缘 RDD](#vertex_and_edge_rdds) 部分更详细地讨论了 [`VertexRDD`](api/scala/index.html#org.apache.spark.graphx.VertexRDD) 和 [`EdgeRDD`](api/scala/index.html#org.apache.spark.graphx.EdgeRDD) API，但现在它们可以被认为是 `RDD[(VertexId, VD)]` 和 `RDD[Edge[ED]]` 的简单 RDD。
`VertexRDD[VD]` 和 `EdgeRDD[ED]` 分别扩展了 `RDD[(VertexId, VD)]` 和 `RDD[Edge[ED]]` 的优化版本。`VertexRDD[VD]` 和 `EdgeRDD[ED]` 都提供了围绕图计算和利用内部优化的附加功能。我们在[顶点和边缘 RDD](#vertex_and_edge_rdds) 部分更详细地讨论了 [`VertexRDD`](api/scala/index.html#org.apache.spark.graphx.VertexRDD) 和 [`EdgeRDD`](api/scala/index.html#org.apache.spark.graphx.EdgeRDD) API，但现在它们可以被认为是 `RDD[(VertexId, VD)]` 和 `RDD[Edge[ED]]` 的简单 RDD。
### 示例属性 Graph
......@@ -170,7 +170,7 @@ ON e.srcId = src.Id AND e.dstId = dst.Id
![Edge Triplet](img/a0f9441a5c59b2607cccf63ae2887065.jpg "Edge Triplet")
[`EdgeTriplet`](api/scala/index.html#org.apache.spark.graphx.EdgeTriplet) 类通过分别添加包含源和目标属性的 `srcAttr` 和 `dstAttr` 成员来扩展 [`Edge`](api/scala/index.html#org.apache.spark.graphx.Edge) 类。 我们可以使用图形的三元组视图来渲染描述用户之间关系的字符串集合。
[`EdgeTriplet`](api/scala/index.html#org.apache.spark.graphx.EdgeTriplet) 类通过分别添加包含源和目标属性的 `srcAttr` 和 `dstAttr` 成员来扩展 [`Edge`](api/scala/index.html#org.apache.spark.graphx.Edge) 类。我们可以使用图形的三元组视图来渲染描述用户之间关系的字符串集合。
......@@ -380,7 +380,7 @@ validGraph.triplets.map(
> 注意在上面的例子中只提供了顶点谓词。 如果未提供顶点或边缘谓词，则 `subgraph` 运算符默认为 `true`。
> 注意在上面的例子中只提供了顶点谓词。如果未提供顶点或边缘谓词，则 `subgraph` 运算符默认为 `true`。
在 [`mask`](api/scala/index.html#org.apache.spark.graphx.Graph@mask[VD2,ED2](Graph[VD2,ED2])(ClassTag[VD2],ClassTag[ED2]):Graph[VD,ED]) 操作者通过返回包含该顶点和边，它们也在输入图形中发现的曲线构造一个子图。这可以与 `subgraph` 运算符一起使用， 以便根据另一个相关图中的属性限制图形。例如，我们可以使用缺少顶点的图运行连接的组件，然后将答案限制为有效的子图。
......@@ -397,7 +397,7 @@ val validCCGraph = ccGraph.mask(validGraph)
[`groupEdges`](api/scala/index.html#org.apache.spark.graphx.Graph@groupEdges((ED,ED)⇒ED):Graph[VD,ED]) 操作符将多边形中的平行边（即，顶点对之间的重复边）合并。 在许多数值应用中，可以将平行边缘（它们的权重组合）合并成单个边缘，从而减小图形的大小。
[`groupEdges`](api/scala/index.html#org.apache.spark.graphx.Graph@groupEdges((ED,ED)⇒ED):Graph[VD,ED]) 操作符将多边形中的平行边（即，顶点对之间的重复边）合并。在许多数值应用中，可以将平行边缘（它们的权重组合）合并成单个边缘，从而减小图形的大小。
## Join 运算符
......@@ -416,7 +416,7 @@ class Graph[VD, ED] {
[`joinVertices`](api/scala/index.html#org.apache.spark.graphx.GraphOps@joinVertices[U](RDD[(VertexId,U)])((VertexId,VD,U)⇒VD)(ClassTag[U]):Graph[VD,ED]) 操作符将顶点与输入 RDD 相连，并返回一个新的图形，其中通过将用户定义的 `map` 函数应用于已连接顶点的结果而获得的顶点属性。 RDD 中没有匹配值的顶点保留其原始值。
[`joinVertices`](api/scala/index.html#org.apache.spark.graphx.GraphOps@joinVertices[U](RDD[(VertexId,U)])((VertexId,VD,U)⇒VD)(ClassTag[U]):Graph[VD,ED]) 操作符将顶点与输入 RDD 相连，并返回一个新的图形，其中通过将用户定义的 `map` 函数应用于已连接顶点的结果而获得的顶点属性。RDD 中没有匹配值的顶点保留其原始值。
> 请注意，如果 RDD 包含给定顶点的多个值，则只能使用一个值。因此，建议使用以下命令使输入 RDD 变得独一无二，这也将对结果值进行 _pre-index_ ，以显着加速后续连接。
......@@ -432,7 +432,7 @@ val joinedGraph = graph.joinVertices(uniqueCosts)(
除了将用户定义的 `map` 函数应用于所有顶点并且可以更改顶点属性类型之外，更一般的 [`outerJoinVertices`](api/scala/index.html#org.apache.spark.graphx.Graph@outerJoinVertices[U,VD2](RDD[(VertexId,U)])((VertexId,VD,Option[U])⇒VD2)(ClassTag[U],ClassTag[VD2]):Graph[VD2,ED]) 的行为类似于 `joinVertices` 。 因为不是所有的顶点都可能在输入 RDD 中具有匹配的值，所以 `map` 函数采用 `Option` 类型。 例如，我们可以通过使用 `outDegree` 初始化顶点属性来为 PageRank 设置一个图。
除了将用户定义的 `map` 函数应用于所有顶点并且可以更改顶点属性类型之外，更一般的 [`outerJoinVertices`](api/scala/index.html#org.apache.spark.graphx.Graph@outerJoinVertices[U,VD2](RDD[(VertexId,U)])((VertexId,VD,Option[U])⇒VD2)(ClassTag[U],ClassTag[VD2]):Graph[VD2,ED]) 的行为类似于 `joinVertices` 。因为不是所有的顶点都可能在输入 RDD 中具有匹配的值，所以 `map` 函数采用 `Option` 类型。例如，我们可以通过使用 `outDegree` 初始化顶点属性来为 PageRank 设置一个图。
......@@ -448,7 +448,7 @@ val degreeGraph = graph.outerJoinVertices(outDegrees) { (id, oldAttr, outDegOpt)
> 您可能已经注意到上述示例中使用的多个参数列表（例如： `f(a)(b)` curried 函数模式。 虽然我们可以将 `f(a)(b)` 同样地写成 `f(a,b)` ，这意味着 `b` 上的类型推断不依赖于 `a` 。 因此，用户需要为用户定义的函数提供类型注释：
> 您可能已经注意到上述示例中使用的多个参数列表（例如： `f(a)(b)` curried 函数模式。虽然我们可以将 `f(a)(b)` 同样地写成 `f(a,b)` ，这意味着 `b` 上的类型推断不依赖于 `a` 。因此，用户需要为用户定义的函数提供类型注释：
......@@ -461,7 +461,7 @@ val joinedGraph = graph.joinVertices(uniqueCosts,
## 邻域聚合
许多图形分析任务的关键步骤是聚合关于每个顶点邻域的信息。 例如，我们可能想知道每个用户拥有的关注者数量或每个用户的追随者的平均年龄。 许多迭代图表算法（例如：网页级别，最短路径，以及连接成分）相邻顶点（例如：电流值的 PageRank ，最短到源路径，和最小可达顶点 ID ）的重复聚合性质。
许多图形分析任务的关键步骤是聚合关于每个顶点邻域的信息。例如，我们可能想知道每个用户拥有的关注者数量或每个用户的追随者的平均年龄。许多迭代图表算法（例如：网页级别，最短路径，以及连接成分）相邻顶点（例如：电流值的 PageRank ，最短到源路径，和最小可达顶点 ID ）的重复聚合性质。
> 为了提高性能，主聚合操作员 `graph.mapReduceTriplets` 从新的更改 `graph.AggregateMessages` 。虽然 API 的变化相对较小，但我们在下面提供了一个转换指南。
......@@ -483,7 +483,7 @@ class Graph[VD, ED] {
用户定义的 `sendMsg` 函数接受一个 [`EdgeContext`](api/scala/index.html#org.apache.spark.graphx.EdgeContext) ，它将源和目标属性以及 edge 属性和函数 ([`sendToSrc`](api/scala/index.html#org.apache.spark.graphx.EdgeContext@sendToSrc(msg:A):Unit), 和 [`sendToDst`](api/scala/index.html#org.apache.spark.graphx.EdgeContext@sendToDst(msg:A):Unit)) 一起发送到源和目标属性。 在 map-reduce 中，将 `sendMsg` 作为 _map_ 函数。 用户定义的 `mergeMsg` 函数需要两个发往同一顶点的消息，并产生一条消息。 想想 `mergeMsg` 是 map-reduce 中的_reduce_ 函数。 [`aggregateMessages`](api/scala/index.html#org.apache.spark.graphx.Graph@aggregateMessages[A]((EdgeContext[VD,ED,A])⇒Unit,(A,A)⇒A,TripletFields)(ClassTag[A]):VertexRDD[A]) 运算符返回一个 `VertexRDD[Msg]` ，其中包含去往每个顶点的聚合消息（Msg类型）。 没有收到消息的顶点不包括在返回的 `VertexRDD`[VertexRDD](api/scala/index.html#org.apache.spark.graphx.VertexRDD) 中。
用户定义的 `sendMsg` 函数接受一个 [`EdgeContext`](api/scala/index.html#org.apache.spark.graphx.EdgeContext) ，它将源和目标属性以及 edge 属性和函数 ([`sendToSrc`](api/scala/index.html#org.apache.spark.graphx.EdgeContext@sendToSrc(msg:A):Unit), 和 [`sendToDst`](api/scala/index.html#org.apache.spark.graphx.EdgeContext@sendToDst(msg:A):Unit)) 一起发送到源和目标属性。在 map-reduce 中，将 `sendMsg` 作为 _map_ 函数。用户定义的 `mergeMsg` 函数需要两个发往同一顶点的消息，并产生一条消息。想想 `mergeMsg` 是 map-reduce 中的_reduce_ 函数。[`aggregateMessages`](api/scala/index.html#org.apache.spark.graphx.Graph@aggregateMessages[A]((EdgeContext[VD,ED,A])⇒Unit,(A,A)⇒A,TripletFields)(ClassTag[A]):VertexRDD[A]) 运算符返回一个 `VertexRDD[Msg]` ，其中包含去往每个顶点的聚合消息（Msg类型）。没有收到消息的顶点不包括在返回的 `VertexRDD`[VertexRDD](api/scala/index.html#org.apache.spark.graphx.VertexRDD) 中。
另外，[`aggregateMessages`](api/scala/index.html#org.apache.spark.graphx.Graph@aggregateMessages[A]((EdgeContext[VD,ED,A])⇒Unit,(A,A)⇒A,TripletFields)(ClassTag[A]):VertexRDD[A]) 采用一个可选的`tripletsFields` ，它们指示在 [`EdgeContext`](api/scala/index.html#org.apache.spark.graphx.EdgeContext) 中访问哪些数据（即源顶点属性，而不是目标顶点属性）。`tripletsFields` 定义的可能选项， [`TripletFields`](api/java/org/apache/spark/graphx/TripletFields.html) 默认值是 [`TripletFields.All`](api/java/org/apache/spark/graphx/TripletFields.html#All) 指示用户定义的 `sendMsg` 函数可以访问的任何字段[`EdgeContext`](api/scala/index.html#org.apache.spark.graphx.EdgeContext) 。该 `tripletFields` 参数可用于通知 GraphX ，只有部分 [`EdgeContext`](api/scala/index.html#org.apache.spark.graphx.EdgeContext) 需要允许 GraphX 选择优化的连接策略。例如，如果我们计算每个用户的追随者的平均年龄，我们只需要源字段，因此我们将用于 [`TripletFields.Src`](api/java/org/apache/spark/graphx/TripletFields.html#Src) 表示我们只需要源字段。
......@@ -540,7 +540,7 @@ class Graph[VD, ED] {
`mapReduceTriplets` 操作符接受用户定义的映射函数，该函数应用于每个三元组，并且可以使用用户定义的缩减函数来生成聚合的_消息_。 然而，我们发现返回的迭代器的用户是昂贵的，并且它阻止了我们应用其他优化（例如：局部顶点重新编号）的能力。 在 [`aggregateMessages`](api/scala/index.html#org.apache.spark.graphx.Graph@aggregateMessages[A]((EdgeContext[VD,ED,A])⇒Unit,(A,A)⇒A,TripletFields)(ClassTag[A]):VertexRDD[A]) 中，我们引入了 EdgeContext ，它暴露了三元组字段，并且还显示了向源和目标顶点发送消息的功能。 此外，我们删除了字节码检查，而是要求用户指出三元组中实际需要哪些字段。
`mapReduceTriplets` 操作符接受用户定义的映射函数，该函数应用于每个三元组，并且可以使用用户定义的缩减函数来生成聚合的_消息_。然而，我们发现返回的迭代器的用户是昂贵的，并且它阻止了我们应用其他优化（例如：局部顶点重新编号）的能力。在 [`aggregateMessages`](api/scala/index.html#org.apache.spark.graphx.Graph@aggregateMessages[A]((EdgeContext[VD,ED,A])⇒Unit,(A,A)⇒A,TripletFields)(ClassTag[A]):VertexRDD[A]) 中，我们引入了 EdgeContext ，它暴露了三元组字段，并且还显示了向源和目标顶点发送消息的功能。此外，我们删除了字节码检查，而是要求用户指出三元组中实际需要哪些字段。
以下代码块使用 `mapReduceTriplets` ：
......@@ -606,7 +606,7 @@ class GraphOps[VD, ED] {
> 这些操作可能相当昂贵，因为它们重复信息并需要大量通信。 如果可能，请直接使用 [`aggregateMessages`](api/scala/index.html#org.apache.spark.graphx.Graph@aggregateMessages[A]((EdgeContext[VD,ED,A])⇒Unit,(A,A)⇒A,TripletFields)(ClassTag[A]):VertexRDD[A]) 操作来表达相同的计算。
> 这些操作可能相当昂贵，因为它们重复信息并需要大量通信。如果可能，请直接使用 [`aggregateMessages`](api/scala/index.html#org.apache.spark.graphx.Graph@aggregateMessages[A]((EdgeContext[VD,ED,A])⇒Unit,(A,A)⇒A,TripletFields)(ClassTag[A]):VertexRDD[A]) 操作来表达相同的计算。
## Caching and Uncaching
......@@ -618,7 +618,7 @@ class GraphOps[VD, ED] {
图形是固有的递归数据结构，因为顶点的属性取决于其邻居的属性，而邻居的属性又依赖于_其_邻居的属性。因此，许多重要的图算法迭代地重新计算每个顶点的属性，直到达到一个固定点条件。已经提出了一系列图并行抽象来表达这些迭代算法。GraphX 公开了 Pregel API 的变体。
在高层次上，GraphX 中的 Pregel 运算符是_限制到图形拓扑的_批量同步并行消息抽象。 Pregel 操作符在一系列超级步骤中执行，其中顶点接收来自先前超级步骤的入站消息的_总和_，计算顶点属性的新值，然后在下一个超级步骤中将消息发送到相邻顶点。与 Pregel 不同，消息作为边缘三元组的函数并行计算，消息计算可以访问源和目标顶点属性。在超级步骤中跳过不接收消息的顶点。 Pregel 运算符终止迭代，并在没有剩余的消息时返回最终的图。
在高层次上，GraphX 中的 Pregel 运算符是_限制到图形拓扑的_批量同步并行消息抽象。Pregel 操作符在一系列超级步骤中执行，其中顶点接收来自先前超级步骤的入站消息的_总和_，计算顶点属性的新值，然后在下一个超级步骤中将消息发送到相邻顶点。与 Pregel 不同，消息作为边缘三元组的函数并行计算，消息计算可以访问源和目标顶点属性。在超级步骤中跳过不接收消息的顶点。Pregel 运算符终止迭代，并在没有剩余的消息时返回最终的图。
> 注意，与更多的标准 Pregel 实现不同，GraphX 中的顶点只能将消息发送到相邻顶点，并且使用用户定义的消息传递功能并行完成消息构造。这些约束允许在 GraphX 中进行额外优化。
......@@ -753,7 +753,7 @@ object Graph {
[`Graph.fromEdges`](api/scala/index.html#org.apache.spark.graphx.Graph$@fromEdges[VD,ED](RDD[Edge[ED]],VD)(ClassTag[VD],ClassTag[ED]):Graph[VD,ED]) 允许仅从 RDD 的边缘创建图形，自动创建边缘提到的任何顶点并将其分配给默认值。
[`Graph.fromEdgeTuples`](api/scala/index.html#org.apache.spark.graphx.Graph$@fromEdgeTuples[VD](RDD[(VertexId,VertexId)],VD,Option[PartitionStrategy])(ClassTag[VD]):Graph[VD,Int]) 允许仅从边缘元组的 RDD 创建图形，将边缘分配为值1，并自动创建边缘提到的任何顶点并将其分配给默认值。 它还支持重复数据删除边缘; 重复数据删除，将`某些` [`PartitionStrategy`](api/scala/index.html#org.apache.spark.graphx.PartitionStrategy) 作为 `uniqueEdges` 参数传递（例如：`uniqueEdges = Some(PartitionStrategy.RandomVertexCut)`）。 分区策略是必须的，以便在相同的分区上共同使用相同的边，以便可以进行重复数据删除。
[`Graph.fromEdgeTuples`](api/scala/index.html#org.apache.spark.graphx.Graph$@fromEdgeTuples[VD](RDD[(VertexId,VertexId)],VD,Option[PartitionStrategy])(ClassTag[VD]):Graph[VD,Int]) 允许仅从边缘元组的 RDD 创建图形，将边缘分配为值1，并自动创建边缘提到的任何顶点并将其分配给默认值。它还支持重复数据删除边缘; 重复数据删除，将`某些` [`PartitionStrategy`](api/scala/index.html#org.apache.spark.graphx.PartitionStrategy) 作为 `uniqueEdges` 参数传递（例如：`uniqueEdges = Some(PartitionStrategy.RandomVertexCut)`）。分区策略是必须的，以便在相同的分区上共同使用相同的边，以便可以进行重复数据删除。
# Vertex and Edge RDDs
......@@ -788,7 +788,7 @@ class VertexRDD[VD] extends RDD[(VertexId, VD)] {
请注意，例如，`filter` 运算符 如何返回 [`VertexRDD`](api/scala/index.html#org.apache.spark.graphx.VertexRDD)。过滤器实际上是通过 `BitSet` 使用索引重新实现的，并保留与其他`VertexRDD` 进行快速连接的能力。同样，`mapValues` 运算符不允许 `map` 功能改变， `VertexId` 从而使相同的 `HashMap` 数据结构能够被重用。无论是 `leftJoin` 和 `innerJoin` 能够连接两个时识别 `VertexRDD` 来自同一来源的小号 `HashMap` 和落实线性扫描，而不是昂贵的点查找的加入。
`aggregateUsingIndex` 运算符对于从 `RDD[(VertexId, A)]` 有效构建新的 [`VertexRDD`](api/scala/index.html#org.apache.spark.graphx.VertexRDD) 非常有用。 在概念上，如果我在一组顶点上构造了一个 `VertexRDD[B]`，这是一些 `RDD[(VertexId, A)]` 中的顶点的_超集_，那么我可以重用索引来聚合然后再索引 `RDD[(VertexId, A)]`。 例如：
`aggregateUsingIndex` 运算符对于从 `RDD[(VertexId, A)]` 有效构建新的 [`VertexRDD`](api/scala/index.html#org.apache.spark.graphx.VertexRDD) 非常有用。在概念上，如果我在一组顶点上构造了一个 `VertexRDD[B]`，这是一些 `RDD[(VertexId, A)]` 中的顶点的_超集_，那么我可以重用索引来聚合然后再索引 `RDD[(VertexId, A)]`。例如：
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或