Skip to content

S
spark-doc-zh

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

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

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

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

"[SPACE]。" to "。"

上级 3b007b11
隐藏空白更改
内联 并排
Showing with 98 addition and 98 deletion
docs/13.md
浏览文件 @ 9fd817c4
......@@ -118,7 +118,7 @@ export HADOOP_CONF_DIR=XXX
| `local[*,F]` | 使用更多的 worker 线程作为逻辑的 core 在您的机器上来本地的运行 Spark并允许最多失败 F次。 |
| `spark://HOST:PORT` | 连接至给定的 [Spark standalone cluster](spark-standalone.html) master. master。该 port（端口）必须有一个作为您的 master 配置来使用，默认是 7077。 |
| `spark://HOST1:PORT1,HOST2:PORT2` | 连接至给定的 [Spark standalone cluster with standby masters with Zookeeper](spark-standalone.html#standby-masters-with-zookeeper). 该列表必须包含由zookeeper设置的高可用集群中的所有master主机。该 port（端口）必须有一个作为您的 master 配置来使用，默认是 7077。 |
| `mesos://HOST:PORT` | 连接至给定的 [Mesos](running-on-mesos.html) 集群. 该 port（端口）必须有一个作为您的配置来使用，默认是 5050。或者，对于使用了 ZooKeeper 的 Mesos cluster 来说，使用 `mesos://zk://...`. 。使用 `--deploy-mode cluster`, 来提交，该 HOST:PORT 应该被配置以连接到 [MesosClusterDispatcher](running-on-mesos.html#cluster-mode). |
| `mesos://HOST:PORT` | 连接至给定的 [Mesos](running-on-mesos.html) 集群. 该 port（端口）必须有一个作为您的配置来使用，默认是 5050。或者，对于使用了 ZooKeeper 的 Mesos cluster 来说，使用 `mesos://zk://...`.。使用 `--deploy-mode cluster`, 来提交，该 HOST:PORT 应该被配置以连接到 [MesosClusterDispatcher](running-on-mesos.html#cluster-mode). |
| `yarn` | 连接至一个 [YARN](running-on-yarn.html) cluster in `client` or `cluster` mode 取决于 `--deploy-mode`. 的值在 client 或者 cluster 模式中。该 cluster 的位置将根据 `HADOOP_CONF_DIR` 或者 `YARN_CONF_DIR` 变量来找到。 |
# 从文件中加载配置
......
docs/15.md
浏览文件 @ 9fd817c4
......@@ -27,7 +27,7 @@ Spark 除了运行在 Mesos 或者 YARN 上以外，Spark 还提供了一个简
./sbin/start-master.sh
```
一旦启动，master 将会为自己打印出一个 `spark://HOST:PORT` URL，您可以使用它来连接 workers，或者像传递 “master” 参数一样传递到 `SparkContext` 。您在 master 的web UI 上也会找到这个 URL ，默认情况下是 [http://localhost:8080](http://localhost:8080) 。
一旦启动，master 将会为自己打印出一个 `spark://HOST:PORT` URL，您可以使用它来连接 workers，或者像传递 “master” 参数一样传递到 `SparkContext`。您在 master 的web UI 上也会找到这个 URL ，默认情况下是 [http://localhost:8080](http://localhost:8080)。
类似地，您可以启动一个或多个 workers 并且通过下面的代码连接到 master ：
......@@ -59,10 +59,10 @@ Spark 除了运行在 Mesos 或者 YARN 上以外，Spark 还提供了一个简
* `sbin/start-master.sh` - 在执行的机器上启动一个 master 实例。
* `sbin/start-slaves.sh` - 在 `conf/slaves` 文件中指定的每个机器上启动一个 slave 实例。
* `sbin/start-slave.sh` - 在执行的机器上启动一个 slave 实例。
* `sbin/start-all.sh` - 启动一个 master 和上面说到的一定数量 slaves 。
* `sbin/start-all.sh` - 启动一个 master 和上面说到的一定数量 slaves。
* `sbin/stop-master.sh` - 停止通过 `sbin/start-master.sh` 脚本启动的 master。
* `sbin/stop-slaves.sh` - 停止在 `conf/slaves` 文件中指定的所有机器上的 slave 实例。
* `sbin/stop-all.sh` - 停止 master 和上边说到的 slaves 。
* `sbin/stop-all.sh` - 停止 master 和上边说到的 slaves。
注意，这些脚本必须在您想要运行 Spark master 的机器上执行，而不是您本地的机器。
......@@ -70,11 +70,11 @@ Spark 除了运行在 Mesos 或者 YARN 上以外，Spark 还提供了一个简
| Environment Variable （环境变量） | Meaning（含义） |
| --- | --- |
| `SPARK_MASTER_HOST` | 绑定 master 到一个指定的 hostname 或者 IP 地址，例如一个 public hostname 或者 IP 。 |
| `SPARK_MASTER_HOST` | 绑定 master 到一个指定的 hostname 或者 IP 地址，例如一个 public hostname 或者 IP。 |
| `SPARK_MASTER_PORT` | 在不同的端口上启动 master （默认：7077） |
| `SPARK_MASTER_WEBUI_PORT` | master 的 web UI 的端口（默认：8080） |
| `SPARK_MASTER_OPTS` | 仅应用到 master 上的配置属性，格式是 "-Dx=y" （默认是：none）。查看下面的列表可能选项。 |
| `SPARK_LOCAL_DIRS` | Spark 中 "scratch" space（暂存空间）的目录，包括 map 的输出文件和存储在磁盘上的 RDDs 。这必须在您的系统中的一个快速的，本地的磁盘上。这也可以是逗号分隔的不同磁盘上的多个目录的列表。 |
| `SPARK_LOCAL_DIRS` | Spark 中 "scratch" space（暂存空间）的目录，包括 map 的输出文件和存储在磁盘上的 RDDs。这必须在您的系统中的一个快速的，本地的磁盘上。这也可以是逗号分隔的不同磁盘上的多个目录的列表。 |
| `SPARK_WORKER_CORES` | 机器上 Spark 应用程序可以使用的全部的 cores（核）的数量。（默认：全部的核可用） |
| `SPARK_WORKER_MEMORY` | 机器上 Spark 应用程序可以使用的全部的内存数量，例如 `1000m`， `2g`（默认：全部的内存减去 1 GB）；注意每个应用程序的_individual（独立）_内存是使用 `spark.executor.memory` 属性进行配置的。 |
| `SPARK_WORKER_PORT` | 在一个指定的 port （端口）上启动 Spark worker （默认： random（随机）） |
......@@ -85,7 +85,7 @@ Spark 除了运行在 Mesos 或者 YARN 上以外，Spark 还提供了一个简
| `SPARK_DAEMON_JAVA_OPTS` | Spark master 和 worker 守护进程的 JVM 选项，格式是 "-Dx=y" （默认：none） |
| `SPARK_PUBLIC_DNS` | Spark master 和 worker 的公开 DNS 名称。（默认：none） |
**注意：** 启动脚本现在还不支持 Windows 。要在 Windows 上运行一个 Spark 集群，需要手动启动 master 和 workers 。
**注意：** 启动脚本现在还不支持 Windows。要在 Windows 上运行一个 Spark 集群，需要手动启动 master 和 workers。
SPARK_MASTER_OPTS 支持以下系统属性:
......@@ -97,9 +97,9 @@ SPARK_MASTER_OPTS 支持以下系统属性:
|
| `spark.deploy.spreadOut` | true | 这个选项控制 standalone 集群 manager 是应该跨界店 spread （传播）应用程序还是应该努力将应用程序整合到尽可能少的节点上。在 HDFS 中， Spreading 是数据本地化的更好的选择，但是对于计算密集型的负载，整合会更有效率。
|
| `spark.deploy.defaultCores` | (infinite) | 如果没有设置 `spark.cores.max` ，在 Spark 的 standalone 模式下默认分配给应用程序的 cores （核）数。如果没有设置，应用程序将总是获得所有的可用核，除非设置了 `spark.cores.max` 。在共享集群中设置较低的核数,可用于防止用户 grabbing （抓取）整个集群。
| `spark.deploy.defaultCores` | (infinite) | 如果没有设置 `spark.cores.max` ，在 Spark 的 standalone 模式下默认分配给应用程序的 cores （核）数。如果没有设置，应用程序将总是获得所有的可用核，除非设置了 `spark.cores.max`。在共享集群中设置较低的核数,可用于防止用户 grabbing （抓取）整个集群。
|
| `spark.deploy.maxExecutorRetries` | 10 | 限制在 standalone 集群 manager 删除一个不正确地应用程序之前可能发生的 back-to-back 执行器失败的最大次数。如果一个应用程序有任何正在运行的执行器，则它永远不会被删除。如果一个应用程序经历过超过 `spark.deploy.maxExecutorRetries` 次的连续失败，没有执行器成功开始运行在这些失败之间，并且应用程序没有运行着的执行器，然后 standalone 集群 manager 将会移除这个应用程序并将它标记为失败。要禁用这个自动删除功能，设置`spark.deploy.maxExecutorRetries` 为 `-1` 。
| `spark.deploy.maxExecutorRetries` | 10 | 限制在 standalone 集群 manager 删除一个不正确地应用程序之前可能发生的 back-to-back 执行器失败的最大次数。如果一个应用程序有任何正在运行的执行器，则它永远不会被删除。如果一个应用程序经历过超过 `spark.deploy.maxExecutorRetries` 次的连续失败，没有执行器成功开始运行在这些失败之间，并且应用程序没有运行着的执行器，然后 standalone 集群 manager 将会移除这个应用程序并将它标记为失败。要禁用这个自动删除功能，设置`spark.deploy.maxExecutorRetries` 为 `-1`。
|
| `spark.worker.timeout` | 60 | standalone 部署模式下 master 如果没有接收到心跳，认为一个 worker 丢失的间隔时间，秒数。 |
......@@ -114,7 +114,7 @@ SPARK_WORKER_OPTS 支持以下的系统属性：
# 提交应用程序到集群中
要在 Spark 集群中运行一个应用程序，只需要简单地将 master 的 `spark://IP:PORT` URL 传递到 [`SparkContext` constructor](programming-guide.html#initializing-spark) 。
要在 Spark 集群中运行一个应用程序，只需要简单地将 master 的 `spark://IP:PORT` URL 传递到 [`SparkContext` constructor](programming-guide.html#initializing-spark)。
要针对集群运行交互式 Spark shell ，运行下面的命令：
......@@ -128,15 +128,15 @@ 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` 。然后，如果您想杀死一个重复失败的应用程序，您可以使用如下方式：
另外，standalone `cluster` 模式支持自动重新启动应用程序如果它是以非零的退出码退出的。要使用此功能，您可以在启动您的应用程序的时候将 `--supervise` 标志传入 `spark-submit`。然后，如果您想杀死一个重复失败的应用程序，您可以使用如下方式：
```
./bin/spark-class org.apache.spark.deploy.Client kill <master url> <driver ID>
```
您可以查看 driver ID 通过 standalone Master web UI 在 `http://&lt;master url&gt;:8080` 。
您可以查看 driver ID 通过 standalone Master web UI 在 `http://&lt;master url&gt;:8080`。
# Resource Scheduling（资源调度）
......@@ -168,17 +168,17 @@ 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` ，其中所有输出都写入其控制台。
# 与 Hadoop 集成
您可以运行 Spark 集成到您现有的 Hadoop 集群，只需在同一台机器上将其作为单独的服务启动。要从 Spark 访问 Hadoop 的数据，只需要使用 hdfs:// URL (通常为 `hdfs://&lt;namenode&gt;:9000/path`, 但是您可以在您的 Hadoop Namenode 的 web UI 中找到正确的 URL 。) 或者，您可以为 Spark 设置一个单独的集群，并且仍然可以通过网络访问 HDFS ；这将比磁盘本地访问速度慢，但是如果您仍然在同一个局域网中运行（例如，您将 Hadoop 上的每个机架放置几台 Spark 机器），可能不会引起关注。
您可以运行 Spark 集成到您现有的 Hadoop 集群，只需在同一台机器上将其作为单独的服务启动。要从 Spark 访问 Hadoop 的数据，只需要使用 hdfs:// URL (通常为 `hdfs://&lt;namenode&gt;:9000/path`, 但是您可以在您的 Hadoop Namenode 的 web UI 中找到正确的 URL。) 或者，您可以为 Spark 设置一个单独的集群，并且仍然可以通过网络访问 HDFS ；这将比磁盘本地访问速度慢，但是如果您仍然在同一个局域网中运行（例如，您将 Hadoop 上的每个机架放置几台 Spark 机器），可能不会引起关注。
# 配置网络安全端口
Spark 对网络的需求比较高，并且一些环境对于使用严格的防火墙设置有严格的要求，请查看 [security page](security.html#configuring-ports-for-network-security) 。
Spark 对网络的需求比较高，并且一些环境对于使用严格的防火墙设置有严格的要求，请查看 [security page](security.html#configuring-ports-for-network-security)。
# 高可用性
......@@ -188,25 +188,25 @@ Spark 对网络的需求比较高，并且一些环境对于使用严格的防
**概述**
使用 ZooKeeper 提供的 leader election （领导选举）和一些 state storage （状态存储），在连接到同一 ZooKeeper 实例的集群中启动多个 Masters 。一个节点将被选举为 “leader” 并且其他节点将会维持备用模式。如果当前的 leader 宕掉了，另一个 Master 将会被选举，恢复老的 Master 的状态，并且恢复调度。整个恢复过程（从第一个 leader 宕掉开始）应该会使用 1 到 2 分钟。注意此延迟仅仅影响调度 _new_ 应用程序 – 在 Master 故障切换期间已经运行的应用程序不受影响。
使用 ZooKeeper 提供的 leader election （领导选举）和一些 state storage （状态存储），在连接到同一 ZooKeeper 实例的集群中启动多个 Masters。一个节点将被选举为 “leader” 并且其他节点将会维持备用模式。如果当前的 leader 宕掉了，另一个 Master 将会被选举，恢复老的 Master 的状态，并且恢复调度。整个恢复过程（从第一个 leader 宕掉开始）应该会使用 1 到 2 分钟。注意此延迟仅仅影响调度 _new_ 应用程序 – 在 Master 故障切换期间已经运行的应用程序不受影响。
详细了解如何开始使用 ZooKeeper [这里](http://zookeeper.apache.org/doc/trunk/zookeeperStarted.html) 。
详细了解如何开始使用 ZooKeeper [这里](http://zookeeper.apache.org/doc/trunk/zookeeperStarted.html)。
**配置**
为了启用这个恢复模式，您可以在 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 将会独立调度）。
可能的陷阱：如果您在您的集群中有多个 Masters 但是没有正确地配置 Masters 使用 ZooKeeper ， Masters 将无法相互发现，并认为它们都是 leader。这将不会形成一个健康的集群状态（因为所有的 Masters 将会独立调度）。
**细节**
在您设置了 ZooKeeper 集群之后，实现高可用性是很简单的。只需要在具有相同 ZooKeeper 配置（ZooKeeper URL 和 目录）的不同节点上启动多个 Master 进程。Masters 随时可以被添加和删除。
为了调度新的应用程序或者添加新的 Worker 到集群中，他们需要知道当前的 leader 的 IP 地址。这可以通过简单地传递一个您在一个单一的进程中传递的 Masters 的列表来完成。例如，您可以启动您的 SparkContext 指向 `spark://host1:port1,host2:port2` 。这将导致您的 SparkContext 尝试去注册两个 Masters – 如果 `host1` 宕掉，这个配置仍然是正确地，因为我们将会发现新的 leader `host2` 。
为了调度新的应用程序或者添加新的 Worker 到集群中，他们需要知道当前的 leader 的 IP 地址。这可以通过简单地传递一个您在一个单一的进程中传递的 Masters 的列表来完成。例如，您可以启动您的 SparkContext 指向 `spark://host1:port1,host2:port2`。这将导致您的 SparkContext 尝试去注册两个 Masters – 如果 `host1` 宕掉，这个配置仍然是正确地，因为我们将会发现新的 leader `host2`。
在 “registering with a Master （使用 Master 注册）” 与正常操作之间有一个重要的区别。当启动的时候，一个应用程序或者 Worker 需要使用当前的 lead Master 找到并且注册。一旦它成功注册，它就是 “in the system（在系统中）”了（即存储在了 ZooKeeper 中）。如果发生故障切换，新的 leader 将会联系所有值钱已经注册的应用程序和 Workers 来通知他们领导层的变化，所以他们甚至不知道新的 Master 在启动时的存在。
由于这个属性，新的 Masters 可以在任何时间创建，唯一需要担心的是，_new_ 应用程序和 Workers 可以找到它注册，以防其成为 leader 。一旦注册了之后，您将被照顾。
由于这个属性，新的 Masters 可以在任何时间创建，唯一需要担心的是，_new_ 应用程序和 Workers 可以找到它注册，以防其成为 leader。一旦注册了之后，您将被照顾。
## 用本地文件系统做单节点恢复
......
docs/16.md
浏览文件 @ 9fd817c4
......@@ -29,7 +29,7 @@ Spark 可以运行在 [Apache Mesos](http://mesos.apache.org/) 管理的硬件
# 运行原理
在一个 standalone 集群部署中，下图中的集群的 manager 是一个 Spark master 实例。当使用 Mesos 时，Mesos master 会将 Spark master 替换掉，成为集群 manager 。
在一个 standalone 集群部署中，下图中的集群的 manager 是一个 Spark master 实例。当使用 Mesos 时，Mesos master 会将 Spark master 替换掉，成为集群 manager。
![Spark 集群组件](img/1b193ef9791313508d0c806587f136fd.jpg "Spark 集群组件")
......@@ -43,27 +43,27 @@ Spark 2.2.0 专门为 Mesos 1.0.0 或更新的版本并且不需要 Mesos 的任
如果您已经有一个 Mesos 集群正在运行着，您可以跳过这个 Mesos 安装的步骤。
否则，安装 Mesos for Spark 与安装 Mesos for 其他框架是没有区别的。您可以通过源码或者 prebuilt packages （预构建软件安装包）来安装 Mesos 。
否则，安装 Mesos for Spark 与安装 Mesos for 其他框架是没有区别的。您可以通过源码或者 prebuilt packages （预构建软件安装包）来安装 Mesos。
## 从源码安装
通过源码安装 Apache Mesos ，请按照以下步骤：
1. 从镜像网站 [mirror](http://www.apache.org/dyn/closer.lua/mesos/1.0.0/) 下载一个 Mesos 发行版。
2. 按照 Mesos 的 [快速开始](http://mesos.apache.org/gettingstarted) 页面来编译和安装 Mesos 。
2. 按照 Mesos 的 [快速开始](http://mesos.apache.org/gettingstarted) 页面来编译和安装 Mesos。
**注意:** 如果您希望运行 Mesos 并且又不希望将其安装在您的系统的默认路径（例如，如果您没有安装它的管理权限），将 `--prefix` 选项传入 `configure` 来告知它安装在什么地方。例如，将 `--prefix=/home/me/mesos` 传入。默认情况下，前缀是 `/usr/local` 。
**注意:** 如果您希望运行 Mesos 并且又不希望将其安装在您的系统的默认路径（例如，如果您没有安装它的管理权限），将 `--prefix` 选项传入 `configure` 来告知它安装在什么地方。例如，将 `--prefix=/home/me/mesos` 传入。默认情况下，前缀是 `/usr/local`。
## 第三方软件包
Apache Mesos 只发布了源码的发行版本，而不是 binary packages （二进制包）。但是其他的第三方项目发布了 binary releases （二进制发行版本），可能对设置 Mesos 有帮助。
其中之一是 Mesosphere 。使用 Mesosphere 提供的 binary releases （二进制发行版本）安装 Mesos ：
其中之一是 Mesosphere。使用 Mesosphere 提供的 binary releases （二进制发行版本）安装 Mesos ：
1. 从 [下载页面](http://mesosphere.io/downloads/) 下载 Mesos 安装包
2. 按照他们的说明进行安装和配置
Mesosphere 安装文档建议安装 ZooKeeper 来处理 Mesos master 故障切换，但是 Mesos 可以在没有 ZooKeeper 的情况下使用 single master 。
Mesosphere 安装文档建议安装 ZooKeeper 来处理 Mesos master 故障切换，但是 Mesos 可以在没有 ZooKeeper 的情况下使用 single master。
## 验证
......@@ -71,13 +71,13 @@ Mesosphere 安装文档建议安装 ZooKeeper 来处理 Mesos master 故障切
# 连接 Spark 到 Mesos
要使用 Spark 中的 Mesos ，您需要一个 Spark 的二进制包放到 Mesos 可以访问的地方，然后一个 Spark driver 程序配置来连接 Mesos 。
要使用 Spark 中的 Mesos ，您需要一个 Spark 的二进制包放到 Mesos 可以访问的地方，然后一个 Spark driver 程序配置来连接 Mesos。
或者，您也可以将 Spark 安装在所有 Mesos slaves 中的相同位置，并且配置 `spark.mesos.executor.home` （默认是 SPARK_HOME）来指向该位置。
## 上传 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://`。
要使用预编译的包：
......@@ -88,7 +88,7 @@ Mesosphere 安装文档建议安装 ZooKeeper 来处理 Mesos master 故障切
或者如果您正在使用着一个自定义编译的 Spark 版本，您将需要使用 在 Spark 源码中的 tarball/checkout 的 `dev/make-distribution.sh` 脚本创建一个包。
1. 按照说明 [这里](index.html) 来下载并构建 Spark 。
1. 按照说明 [这里](index.html) 来下载并构建 Spark。
2. 使用 `./dev/make-distribution.sh --tgz` 创建一个 binary package （二进制包）
3. 将归档文件上传到 http/s3/hdfs
......@@ -103,11 +103,11 @@ Mesosphere 安装文档建议安装 ZooKeeper 来处理 Mesos master 故障切
driver 需要在 `spark-env.sh` 中进行一些配置才能与 Mesos 进行交互：
1. 在 `spark-env.sh` 中设置一些环境变量：
* `export MESOS_NATIVE_JAVA_LIBRARY=&lt;path to libmesos.so&gt;`. 这个路径通常是 `&lt;prefix&gt;/lib/libmesos.so` 默认情况下前缀是 `/usr/local` 。请参阅上边的 Mesos 安装说明。在 Mac OS X 上，这个 library 叫做 `libmesos.dylib` 而不是 `libmesos.so` 。
* `export MESOS_NATIVE_JAVA_LIBRARY=&lt;path to libmesos.so&gt;`. 这个路径通常是 `&lt;prefix&gt;/lib/libmesos.so` 默认情况下前缀是 `/usr/local`。请参阅上边的 Mesos 安装说明。在 Mac OS X 上，这个 library 叫做 `libmesos.dylib` 而不是 `libmesos.so`。
* `export SPARK_EXECUTOR_URI=&lt;URL of spark-2.2.0.tar.gz uploaded above&gt;`。
2. 还需要设置 `spark.executor.uri` 为 `&lt;URL of spark-2.2.0.tar.gz&gt;`。
现在，当针对集群启动一个 Spark 应用程序时，在创建 `SparkContext` 时传递一个 `mesos://` URL 作为 master 。例如：
现在，当针对集群启动一个 Spark 应用程序时，在创建 `SparkContext` 时传递一个 `mesos://` URL 作为 master。例如：
......@@ -135,13 +135,13 @@ val sc = new SparkContext(conf)
## Cluster mode（集群模式）
Spark on Mesos 还支持 cluster mode （集群模式），其中 driver 在集群中启动并且 client（客户端）可以在 Mesos Web UI 中找到 driver 的 results 。
Spark on Mesos 还支持 cluster mode （集群模式），其中 driver 在集群中启动并且 client（客户端）可以在 Mesos Web UI 中找到 driver 的 results。
要使用集群模式，你必须在您的集群中通过 `sbin/start-mesos-dispatcher.sh` 脚本启动 `MesosClusterDispatcher` ，传入 Mesos master URL （例如：mesos://host:5050）。这将启动 `MesosClusterDispatcher` 作为在主机上运行的守护程序。
如果您喜欢使用 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 的状态。
......@@ -163,7 +163,7 @@ Spark on Mesos 还支持 cluster mode （集群模式），其中 driver 在集
请注意，传入到 spark-submit 的 jars 或者 python 文件应该是 Mesos slaves 可访问的 URIs ，因为 Spark driver 不会自动上传本地 jars 。
请注意，传入到 spark-submit 的 jars 或者 python 文件应该是 Mesos slaves 可访问的 URIs ，因为 Spark driver 不会自动上传本地 jars。
# Mesos 运行模式
......@@ -179,23 +179,23 @@ Spark 可以以两种模式运行 Mesos ： “coarse-grained（粗粒度）”
请参阅 [Spark 配置](configuration.html) 页面来了解细节和默认值。
当应用程序启动时，执行器就会高涨，直到达到 `spark.cores.max` 。如果您没有设置 `spark.cores.max` ，Spark 应用程序将会保留 Mesos 提供的所有的资源，因此我们当然会敦促您在任何类型的多租户集群上设置此变量，包括运行多个并发 Spark 应用程序的集群。
当应用程序启动时，执行器就会高涨，直到达到 `spark.cores.max`。如果您没有设置 `spark.cores.max` ，Spark 应用程序将会保留 Mesos 提供的所有的资源，因此我们当然会敦促您在任何类型的多租户集群上设置此变量，包括运行多个并发 Spark 应用程序的集群。
调度程序将会在提供的 Mesos 上启动执行器循环给它，但是没有 spread guarantees （传播保证），因为 Mesos 不提供这样的保证在提供流上。
在这个模式下 spark 执行器将遵守 port （端口）分配如果这些事由用户提供的。特别是如果用户在 Spark 配置中定义了 `spark.executor.port` 或者 `spark.blockManager.port` ，mesos 调度器将检查有效端口的可用 offers 包含端口号。如果没有这样的 range 可用，它会不启动任何任务。如果用户提供的端口号不受限制，临时端口像往常一样使用。如果用户定义了一个端口，这个端口实现意味着 one task per host （每个主机一个任务）。在未来网络中，isolation 将被支持。
粗粒度模式的好处是开销要低得多，但是在应用程序的整个持续时间内保留 Mesos 资源的代价。要配置您的作业以动态调整资源需求，请参阅 [动态分配](#dynamic-resource-allocation-with-mesos) 。
粗粒度模式的好处是开销要低得多，但是在应用程序的整个持续时间内保留 Mesos 资源的代价。要配置您的作业以动态调整资源需求，请参阅 [动态分配](#dynamic-resource-allocation-with-mesos)。
## Fine-Grained (deprecated)（细粒度，不推荐）
**注意:** Spark 2.0.0 中的细粒度模式已弃用。为了一些优点，请考虑使用 [动态分配](#dynamic-resource-allocation-with-mesos) 有关完整的解释，请参阅 [SPARK-11857](https://issues.apache.org/jira/browse/SPARK-11857) 。
**注意:** Spark 2.0.0 中的细粒度模式已弃用。为了一些优点，请考虑使用 [动态分配](#dynamic-resource-allocation-with-mesos) 有关完整的解释，请参阅 [SPARK-11857](https://issues.apache.org/jira/browse/SPARK-11857)。
在细粒度模式下，Spark 执行器中的每个 Spark 任务作为单独的 Mesos 任务运行。这允许 Spark 的多个实例（和其他框架）以非常细的粒度来共享 cores （内核），其中每个应用程序在其上升和下降时获得更多或更少的核。但是它在启动每个任务时增加额外的开销。这种模式可能不适合低延迟要求，如交互式查询或者提供 web 请求。
请注意，尽管细粒度的 Spark 任务在它们终止时将放弃内核，但是他们不会放弃内存，因为 JVM 不会将内存回馈给操作系统。执行器在空闲时也不会终止。
要以细粒度模式运行，请在您的 [SparkConf](configuration.html#spark-properties) 中设置 `spark.mesos.coarse` 属性为 false 。:
要以细粒度模式运行，请在您的 [SparkConf](configuration.html#spark-properties) 中设置 `spark.mesos.coarse` 属性为 false。:
......@@ -221,21 +221,21 @@ conf.set("spark.mesos.constraints", "os:centos7;us-east-1:false")
Spark 可以通过在您的 [SparkConf](configuration.html#spark-properties) 中设置属性 `spark.mesos.executor.docker.image` 来使用 Mesos Docker 容器。
所使用的 Docker 图像必须有一个适合的版本的 Spark 已经是图像的一部分，也可以通过通常的方法让 Mesos 下载 Spark 。
所使用的 Docker 图像必须有一个适合的版本的 Spark 已经是图像的一部分，也可以通过通常的方法让 Mesos 下载 Spark。
需要 Mesos 的 0.20.1 版本或者更高版本。
请注意，默认情况下，如果 agent （代理程序中）的 Mesos 代理已经存在，则 Mesos agents 将不会 pull 图像。如果您使用 mutable image tags （可变图像标签）可以将 `spark.mesos.executor.docker.forcePullImage` 设置为 `true` ，以强制 agent 总是在运行执行器之前拉取 image 。Force pulling images （强制拉取图像）仅在 Mesos 0.22 版本及以上版本中可用。
请注意，默认情况下，如果 agent （代理程序中）的 Mesos 代理已经存在，则 Mesos agents 将不会 pull 图像。如果您使用 mutable image tags （可变图像标签）可以将 `spark.mesos.executor.docker.forcePullImage` 设置为 `true` ，以强制 agent 总是在运行执行器之前拉取 image。Force pulling images （强制拉取图像）仅在 Mesos 0.22 版本及以上版本中可用。
# 集成 Hadoop 运行
您可以在现有的 Hadoop 集群集成运行 Spark 和 Mesos ，只需要在机器上启动他们作为分开的服务即可。要从 Spark 访问 Hadoop 数据，需要一个完整的 `hdfs://` URL （通常为 `hdfs://&lt;namenode&gt;:9000/path`），但是您可以在 Hadoop Namenode web UI 上找到正确的 URL 。
您可以在现有的 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`。
......@@ -243,7 +243,7 @@ Mesos 仅支持使用粗粒度模式的动态分配，这可以基于应用程
# 配置
有关 Spark 配置的信息，请参阅 [配置页面](configuration.html) 。以下配置特定于 Mesos 上的 Spark。
有关 Spark 配置的信息，请参阅 [配置页面](configuration.html)。以下配置特定于 Mesos 上的 Spark。
#### Spark 属性
......@@ -261,7 +261,7 @@ 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]
......
docs/17.md
浏览文件 @ 9fd817c4
......@@ -4,11 +4,11 @@
# 启动 Spark on YARN
确保 `HADOOP_CONF_DIR` 或者 `YARN_CONF_DIR` 指向包含 Hadoop 集群的（客户端）配置文件的目录。这些配置被用于写入 HDFS 并连接到 YARN ResourceManager 。此目录中包含的配置将被分发到 YARN 集群，以便 application（应用程序）使用的所有的所有 containers（容器）都使用相同的配置。如果配置引用了 Java 系统属性或者未由 YARN 管理的环境变量，则还应在 Spark 应用程序的配置（driver（驱动程序），executors（执行器），和在客户端模式下运行时的 AM ）。
确保 `HADOOP_CONF_DIR` 或者 `YARN_CONF_DIR` 指向包含 Hadoop 集群的（客户端）配置文件的目录。这些配置被用于写入 HDFS 并连接到 YARN ResourceManager。此目录中包含的配置将被分发到 YARN 集群，以便 application（应用程序）使用的所有的所有 containers（容器）都使用相同的配置。如果配置引用了 Java 系统属性或者未由 YARN 管理的环境变量，则还应在 Spark 应用程序的配置（driver（驱动程序），executors（执行器），和在客户端模式下运行时的 AM ）。
有两种部署模式可以用于在 YARN 上启动 Spark 应用程序。在 `cluster` 集群模式下， Spark driver 运行在集群上由 YARN 管理的application master 进程内，并且客户端可以在初始化应用程序后离开。在 `client` 客户端模式下，driver 在客户端进程中运行，并且 application master 仅用于从 YARN 请求资源。
与 [Spark standalone](spark-standalone.html) 和 [Mesos](running-on-mesos.html) 不同的是，在这两种模式中，master 的地址在 `--master` 参数中指定，在 YARN 模式下， ResourceManager 的地址从 Hadoop 配置中选取。因此， `--master` 参数是 `yarn` 。
与 [Spark standalone](spark-standalone.html) 和 [Mesos](running-on-mesos.html) 不同的是，在这两种模式中，master 的地址在 `--master` 参数中指定，在 YARN 模式下， ResourceManager 的地址从 Hadoop 配置中选取。因此， `--master` 参数是 `yarn`。
在 `cluster` 集群模式下启动 Spark 应用程序:
......@@ -32,7 +32,7 @@ $ ./bin/spark-submit --class org.apache.spark.examples.SparkPi \
上面启动一个 YARN 客户端程序，启动默认的 Application Master。然后 SparkPi 将作为 Application Master 的子进程运行。客户端将定期轮询 Application Master 以获取状态的更新并在控制台中显示它们。一旦您的应用程序完成运行后，客户端将退出。请参阅下面的 “调试应用程序” 部分，了解如何查看 driver 和 executor 的日志。
要在 `client` 客户端模式下启动 Spark 应用程序，请执行相同的操作，但是将 `cluster` 替换 `client` 。下面展示了如何在 `client` 客户端模式下运行 `spark-shell`:
要在 `client` 客户端模式下启动 Spark 应用程序，请执行相同的操作，但是将 `cluster` 替换 `client`。下面展示了如何在 `client` 客户端模式下运行 `spark-shell`:
```
$ ./bin/spark-shell --master yarn --deploy-mode client
......@@ -53,13 +53,13 @@ $ ./bin/spark-submit --class my.main.Class \
# 准备
在 YARN 上运行 Spark 需要使用 YARN 支持构建的二进制分布式的 Spark （a binary distribution of Spark）。二进制文件（binary distributions）可以从项目网站的 [下载页面](http://spark.apache.org/downloads.html) 下载。要自己构建 Spark ，请参考 [构建 Spark](building-spark.html). 。
在 YARN 上运行 Spark 需要使用 YARN 支持构建的二进制分布式的 Spark （a binary distribution of Spark）。二进制文件（binary distributions）可以从项目网站的 [下载页面](http://spark.apache.org/downloads.html) 下载。要自己构建 Spark ，请参考 [构建 Spark](building-spark.html).。
要使 Spark 运行时 jars 可以从 YARN 端访问，您可以指定 `spark.yarn.archive` 或者 `spark.yarn.jars` 。更多详细的信息，请参阅 [Spark 属性](running-on-yarn.html#spark-properties) 。如果既没有指定 `spark.yarn.archive` 也没有指定 `spark.yarn.jars` ，Spark 将在 `$SPARK_HOME/jars` 目录下创建一个包含所有 jar 的 zip 文件，并将其上传到 distributed cache（分布式缓存）中。
要使 Spark 运行时 jars 可以从 YARN 端访问，您可以指定 `spark.yarn.archive` 或者 `spark.yarn.jars`。更多详细的信息，请参阅 [Spark 属性](running-on-yarn.html#spark-properties)。如果既没有指定 `spark.yarn.archive` 也没有指定 `spark.yarn.jars` ，Spark 将在 `$SPARK_HOME/jars` 目录下创建一个包含所有 jar 的 zip 文件，并将其上传到 distributed cache（分布式缓存）中。
# 配置
对于 Spark on YARN 和其他的部署模式，大多数的配置是相同的。有关这些的更多信息，请参阅 [配置页面](configuration.html) 。这些是特定于 YARN 上的 Spark 的配置。
对于 Spark on YARN 和其他的部署模式，大多数的配置是相同的。有关这些的更多信息，请参阅 [配置页面](configuration.html)。这些是特定于 YARN 上的 Spark 的配置。
# 调试应用
......
docs/20.md
浏览文件 @ 9fd817c4
......@@ -234,7 +234,7 @@ _注意:_ 在客户端模式下，这一套配置不能通过 `SparkConf` 直接
| `spark.kryoserializer.buffer` | 64k | Kryo 序列化缓冲区的初始大小。注意，每个 worker上 _每个 core_ 会有一个缓冲区。如果需要，此缓冲区将增长到 `spark.kryoserializer.buffer.max`。 |
| `spark.rdd.compress` | false | 是否压缩序列化RDD分区（例如，在 Java 和 Scala 中为 `StorageLevel.MEMORY_ONLY_SER` 或在 Python 中为 `StorageLevel.MEMORY_ONLY`）。可以节省大量空间，花费一些额外的CPU时间。压缩将使用 `spark.io.compression.codec`。 |
| `spark.serializer` | org.apache.spark.serializer.
JavaSerializer | 用于序列化将通过网络发送或需要以序列化形式缓存的对象的类。Java 序列化的默认值与任何Serializable Java对象一起使用，但速度相当慢，所以我们建议您在需要速度时使用 [使用 `org.apache.spark.serializer.KryoSerializer` 并配置 Kryo 序列化](tuning.html) 。可以是 [`org.apache.spark.Serializer`](api/scala/index.html#org.apache.spark.serializer.Serializer) 的任何子类。 |
JavaSerializer | 用于序列化将通过网络发送或需要以序列化形式缓存的对象的类。Java 序列化的默认值与任何Serializable Java对象一起使用，但速度相当慢，所以我们建议您在需要速度时使用 [使用 `org.apache.spark.serializer.KryoSerializer` 并配置 Kryo 序列化](tuning.html)。可以是 [`org.apache.spark.Serializer`](api/scala/index.html#org.apache.spark.serializer.Serializer) 的任何子类。 |
| `spark.serializer.objectStreamReset` | 100 | 当正使用 org.apache.spark.serializer.JavaSerializer 序列化时, 序列化器缓存对象虽然可以防止写入冗余数据，但是却停止这些缓存对象的垃圾回收。通过调用 'reset' 你从序列化程序中清除该信息，并允许收集旧的对象。要禁用此周期性重置，请将其设置为 -1。默认情况下，序列化器会每过 100 个对象被重置一次。 |
### Memory Management （内存管理）
......
docs/22.md
浏览文件 @ 9fd817c4
......@@ -23,7 +23,7 @@
* [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 类。
......@@ -88,7 +88,7 @@ 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 对象）更小。
## 垃圾收集调整
......@@ -104,17 +104,17 @@ GC 调整的第一步是收集关于垃圾收集发生频率和GC花费的时间
为了进一步调整垃圾收集，我们首先需要了解一些关于 JVM 内存管理的基本信息：
* Java堆空间分为两个区域 Young 和 Old 。Young 一代的目的是持有短命的物体，而 Old 一代的目标是使用寿命更长的物体。
* Java堆空间分为两个区域 Young 和 Old。Young 一代的目的是持有短命的物体，而 Old 一代的目标是使用寿命更长的物体。
* Young 一代进一步分为三个区域[ Eden ， Survivor1 ， Survivor2 ]。
* 垃圾收集过程的简化说明：当 Eden 已满时， Eden 上运行了一个小型 GC ，并将 Eden 和 Survivor1 中存在的对象复制到 Survivor2 。幸存者地区被交换。如果一个对象足够老，或者 Survivor2 已满，则会移动到 Old 。最后，当 Old 接近满时，一个完整的 GC 被调用。
* 垃圾收集过程的简化说明：当 Eden 已满时， Eden 上运行了一个小型 GC ，并将 Eden 和 Survivor1 中存在的对象复制到 Survivor2。幸存者地区被交换。如果一个对象足够老，或者 Survivor2 已满，则会移动到 Old。最后，当 Old 接近满时，一个完整的 GC 被调用。
Spark 中 GC 调优的目的是确保只有长寿命的 RDD 存储在 Old 版本中，并且 Young 版本的大小足够存储短命期的对象。这将有助于避免使用完整的 GC 来收集任务执行期间创建的临时对象。可能有用的一些步骤是：
* 通过收集 GC 统计信息来检查垃圾收集是否太多。如果在任务完成之前多次调用完整的 GC ，这意味着没有足够的可用于执行任务的内存。
* 如果太小的集合太多，而不是很多主要的 GC ，为 Eden 分配更多的内存将会有所帮助。您可以将 Eden 的大小设置为对每个任务需要多少内存的估计。如果确定 Eden 的大小 `E` ，那么您可以使用该选项设置年轻一代的大小 `-Xmn=4/3*E` 。（按比例增加4/3是考虑幸存者地区使用的空间。）
* 如果太小的集合太多，而不是很多主要的 GC ，为 Eden 分配更多的内存将会有所帮助。您可以将 Eden 的大小设置为对每个任务需要多少内存的估计。如果确定 Eden 的大小 `E` ，那么您可以使用该选项设置年轻一代的大小 `-Xmn=4/3*E`。（按比例增加4/3是考虑幸存者地区使用的空间。）
* 在打印的 GC 统计信息中，如果 OldGen 接近于满，则通过降低减少用于缓存的内存量 `spark.memory.fraction` ; 缓存较少的对象比减慢任务执行更好。或者，考虑减少年轻一代的大小。这意味着 `-Xmn` 如果您将其设置为如上所述降低。如果没有，请尝试更改 JVM `NewRatio` 参数的值。许多 JVM 默认为2，这意味着 Old 版本占据堆栈的2/3。它应该足够大，使得该分数超过 `spark.memory.fraction`。
......@@ -156,7 +156,7 @@ Spark 中 GC 调优的目的是确保只有长寿命的 RDD 存储在 Old 版本
Spark 喜欢将所有 task 安排在最佳的本地级别，但这并不总是可能的。在任何空闲 executor 中没有未处理数据的情况下， Spark 将切换到较低的本地级别。有两个选项： a ）等待一个繁忙的 CPU 释放在相同服务器上的数据上启动任务，或者 b ）立即在更远的地方启动一个新的任务，需要在那里移动数据。
Spark 通常做的是等待一个繁忙的 CPU 释放的希望。一旦超时，它将开始将数据从远处移动到可用的 CPU 。每个级别之间的回退等待超时可以在一个参数中单独配置或全部配置; 有关详细信息，请参阅[配置页面](configuration.html#scheduling) `spark.locality` 上的 参数。如果您的 task 很长，并且本地化差，您应该增加这些设置，但默认值通常会很好。
Spark 通常做的是等待一个繁忙的 CPU 释放的希望。一旦超时，它将开始将数据从远处移动到可用的 CPU。每个级别之间的回退等待超时可以在一个参数中单独配置或全部配置; 有关详细信息，请参阅[配置页面](configuration.html#scheduling) `spark.locality` 上的 参数。如果您的 task 很长，并且本地化差，您应该增加这些设置，但默认值通常会很好。
# 概要
......
docs/25.md
浏览文件 @ 9fd817c4
......@@ -6,9 +6,9 @@ Spark 开发者都会遇到一个常见问题，那就是如何为 Spark 配置
因为大多数 Spark 作业都很可能必须从外部存储系统（例如 Hadoop 文件系统或者 HBase）读取输入的数据，所以部署 Spark 时**尽可能靠近这些系统**是很重要的。我们建议如下 :
* 如果可以，在 HDFS 相同的节点上运行 Spark 。最简单的方法是在相同节点上设置 Spark [独立集群模式](spark-standalone.html)，并且配置 Spark 和 Hadoop 的内存和 CPU 的使用以避免干扰（Hadoop 的相关选项为 : 设置每个任务内存大小的选项 `mapred.child.java.opts` 以及设置任务数量的选项 `mapred.tasktracker.map.tasks.maximum` 和 `mapred.tasktracker.reduce.tasks.maximum`）。当然您也可以在常用的集群管理器（比如 [Mesos](running-on-mesos.html) 或者 [YARN](running-on-yarn.html)）上运行 Hadoop 和 Spark。
* 如果可以，在 HDFS 相同的节点上运行 Spark。最简单的方法是在相同节点上设置 Spark [独立集群模式](spark-standalone.html)，并且配置 Spark 和 Hadoop 的内存和 CPU 的使用以避免干扰（Hadoop 的相关选项为 : 设置每个任务内存大小的选项 `mapred.child.java.opts` 以及设置任务数量的选项 `mapred.tasktracker.map.tasks.maximum` 和 `mapred.tasktracker.reduce.tasks.maximum`）。当然您也可以在常用的集群管理器（比如 [Mesos](running-on-mesos.html) 或者 [YARN](running-on-yarn.html)）上运行 Hadoop 和 Spark。
* 如果不可以在相同的节点上运行，建议在与 HDFS 相同的局域网中的不同节点上运行 Spark 。
* 如果不可以在相同的节点上运行，建议在与 HDFS 相同的局域网中的不同节点上运行 Spark。
* 对于低延迟数据存储（如HBase），在这些存储系统不同的节点上运行计算作业来可能更有利于避免干扰。
......
docs/27.md
浏览文件 @ 9fd817c4
......@@ -28,7 +28,7 @@
## Apache Maven
基于 Maven 的构建是 Apache Spark 的参考构建。构建 Spark 需要 Maven 3.3.9 或者更高版本和 Java 8+ 。请注意，Spark 2.2.0 对于 Java 7 的支持已经删除了。
基于 Maven 的构建是 Apache Spark 的参考构建。构建 Spark 需要 Maven 3.3.9 或者更高版本和 Java 8+。请注意，Spark 2.2.0 对于 Java 7 的支持已经删除了。
### 设置 Maven 的内存使用
......@@ -54,7 +54,7 @@ export MAVEN_OPTS="-Xmx2g -XX:ReservedCodeCacheSize=512m"
### build/mvn
Spark 现在与一个独立的 Maven 安装包封装到了一起，以便从位于 `build/` 目录下的源代码构建和部署 Spark 。该脚本将自动下载并设置所有必要的构建需求 ([Maven](https://maven.apache.org/) ，[Scala](http://www.scala-lang.org/) 和 [Zinc](https://github.com/typesafehub/zinc)) 到本身的 `build/` 目录下。其尊重任何已经存在的 `mvn` 二进制文件，但是将会 pull down 其自己的 Scala 和 Zinc 的副本，不管是否满足适当的版本需求。`build/mvn` 的执行作为传递到 `mvn` 的调用，允许从以前的构建方法轻松转换。例如，可以像下边这样构建 Spark 的版本：
Spark 现在与一个独立的 Maven 安装包封装到了一起，以便从位于 `build/` 目录下的源代码构建和部署 Spark。该脚本将自动下载并设置所有必要的构建需求 ([Maven](https://maven.apache.org/) ，[Scala](http://www.scala-lang.org/) 和 [Zinc](https://github.com/typesafehub/zinc)) 到本身的 `build/` 目录下。其尊重任何已经存在的 `mvn` 二进制文件，但是将会 pull down 其自己的 Scala 和 Zinc 的副本，不管是否满足适当的版本需求。`build/mvn` 的执行作为传递到 `mvn` 的调用，允许从以前的构建方法轻松转换。例如，可以像下边这样构建 Spark 的版本：
```
./build/mvn -DskipTests clean package
......@@ -64,7 +64,7 @@ Spark 现在与一个独立的 Maven 安装包封装到了一起，以便从位
## 构建一个可运行的 Distribution 版本
想要创建一个像 [Spark 下载](http://spark.apache.org/downloads.html) 页面中的 Spark distribution 版本，并且使其能够运行，请使用项目 root 目录下的 `./dev/make-distribution.sh` 。它可以使用 Maven 的配置文件等等进行配置，如直接使用 Maven 构建。例如：
想要创建一个像 [Spark 下载](http://spark.apache.org/downloads.html) 页面中的 Spark distribution 版本，并且使其能够运行，请使用项目 root 目录下的 `./dev/make-distribution.sh`。它可以使用 Maven 的配置文件等等进行配置，如直接使用 Maven 构建。例如：
```
./dev/make-distribution.sh --name custom-spark --pip --r --tgz -Psparkr -Phadoop-2.7 -Phive -Phive-thriftserver -Pmesos -Pyarn
......@@ -74,7 +74,7 @@ Spark 现在与一个独立的 Maven 安装包封装到了一起，以便从位
## 指定 Hadoop 版本并启用 YARN
您可以通过 `hadoop.version` 属性指定要编译的 Hadoop 的确切版本。如果未指定， Spark 将默认构建为 Hadoop 2.6.X 。
您可以通过 `hadoop.version` 属性指定要编译的 Hadoop 的确切版本。如果未指定， Spark 将默认构建为 Hadoop 2.6.X。
您可以启用 `yarn` 配置文件，如果与 `hadoop.version` 不同的话，可以选择设置 `yarn.version` 属性。
......@@ -128,7 +128,7 @@ Spark 现在与一个独立的 Maven 安装包封装到了一起，以便从位
./build/mvn -pl :spark-streaming_2.11 clean install
```
其中 `spark-streaming_2.11` 是在 `streaming/pom.xml` 文件中定义的 `artifactId` 。
其中 `spark-streaming_2.11` 是在 `streaming/pom.xml` 文件中定义的 `artifactId`。
## Continuous Compilation（连续编译）
......@@ -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,7 +164,7 @@ 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)。
## 加密文件系统
......@@ -181,11 +181,11 @@ 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
有关设置 IntelliJ IDEA 或 Eclipse 用于 Spark 开发和故障排除的帮助，请参阅 [有用的开发工具页面](http://spark.apache.org/developer-tools.html) 。
有关设置 IntelliJ IDEA 或 Eclipse 用于 Spark 开发和故障排除的帮助，请参阅 [有用的开发工具页面](http://spark.apache.org/developer-tools.html)。
# 运行测试
......@@ -207,11 +207,11 @@ scalacOptions in Compile ++= Seq("-Xmax-classfile-name", "128"),
## 运行独立测试
有关如何运行独立测试的信息，请参阅 [有用的开发工具页面](http://spark.apache.org/developer-tools.html#running-individual-tests) 。
有关如何运行独立测试的信息，请参阅 [有用的开发工具页面](http://spark.apache.org/developer-tools.html#running-individual-tests)。
## 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
......@@ -219,11 +219,11 @@ cd python; python setup.py sdist
**注意:** 由于打包要求，您无法直接从 Python 目录中进行 pip 安装，而是必须首先按照上述方式构建 sdist 包。
或者，您还可以使用 –pip 选项运行 make-distribution 。
或者，您还可以使用 –pip 选项运行 make-distribution。
## 使用 Maven 进行 PySpark 测试
如果您正在构建 PySpark 并希望运行 PySpark 测试，则需要使用 Hive 支持构建 Spark 。
如果您正在构建 PySpark 并希望运行 PySpark 测试，则需要使用 Hive 支持构建 Spark。
```
./build/mvn -DskipTests clean package -Phive
......@@ -236,7 +236,7 @@ run-tests 脚本也可以限于特定的 Python 版本或者特定的模块。
./python/run-tests --python-executables=python --modules=pyspark-sql
```
**注意:** 您还可以使用 sbt 构建来运行 Python 测试，只要您使用 Hive 支持构建 Spark 。
**注意:** 您还可以使用 sbt 构建来运行 Python 测试，只要您使用 Hive 支持构建 Spark。
## 运行 R 测试
......
docs/4.md
浏览文件 @ 9fd817c4
......@@ -893,8 +893,8 @@ We could also use `counts.sortByKey()`, for example, to sort the pairs alphabeti
(Java and Scala) | 将 dataset 中的元素以 Hadoop SequenceFile 的形式写入到本地文件系统、HDFS 或其它 Hadoop 支持的文件系统指定的路径中。该操作可以在实现了 Hadoop 的 Writable 接口的键值对（key-value pairs）的 RDD 上使用。在 Scala 中，它还可以隐式转换为 Writable 的类型（Spark 包括了基本类型的转换，例如 Int, Double, String 等等). |
| **saveAsObjectFile**(_path_)
(Java and Scala) | 使用 Java 序列化（serialization）以简单的格式（simple format）编写数据集的元素，然后使用 `SparkContext.objectFile()` 进行加载. |
| **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) 部分. |
| **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 的异步执行。.
......
docs/6.md
浏览文件 @ 9fd817c4
......@@ -503,7 +503,7 @@ The batch interval must be set based on the latency requirements of your applica
* 一旦一个 context 已经启动，将不会有新的数据流的计算可以被创建或者添加到它。.
* 一旦一个 context 已经停止，它不会被重新启动.
* 同一时间内在 JVM 中只有一个 StreamingContext 可以被激活.
* 在 StreamingContext 上的 stop() 同样也停止了 SparkContext 。为了只停止 StreamingContext ，设置 `stop()` 的可选参数，名叫 `stopSparkContext` 为 false.
* 在 StreamingContext 上的 stop() 同样也停止了 SparkContext。为了只停止 StreamingContext ，设置 `stop()` 的可选参数，名叫 `stopSparkContext` 为 false.
* 一个 SparkContext 就可以被重用以创建多个 StreamingContexts，只要前一个 StreamingContext 在下一个StreamingContext 被创建之前停止（不停止 SparkContext）.
* * *
......@@ -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。这些操作细节会在后边的章节中讨论。
* * *
......
docs/7.md
浏览文件 @ 9fd817c4
......@@ -2915,7 +2915,7 @@ Spark SQL CLI 是在本地模式下运行 Hive 转移服务并执行从命令行
* Dataset API 和 DataFrame API 进行了统一。在 Scala 中，`DataFrame` 变成了 `Dataset[Row]` 类型的一个别名，而 Java API 使用者必须将 `DataFrame` 替换成 `Dataset&lt;Row&gt;`。Dataset 类既提供了强类型转换操作（如 `map`，`filter` 以及 `groupByKey`）也提供了非强类型转换操作（如 `select` 和 `groupBy`）。由于编译期的类型安全不是 Python 和 R 语言的一个特性，Dataset 的概念并不适用于这些语言的 API。相反，`DataFrame` 仍然是最基本的编程抽象, 就类似于这些语言中单节点 data frame 的概念。
* Dataset 和 DataFrame API 中 unionAll 已经过时并且由 `union` 替代。
* Dataset 和 DataFrame API 中 explode 已经过时，作为选择，可以结合 select 或 flatMap 使用 `functions.explode()` 。
* Dataset 和 DataFrame API 中 explode 已经过时，作为选择，可以结合 select 或 flatMap 使用 `functions.explode()`。
* Dataset 和 DataFrame API 中 `registerTempTable` 已经过时并且由 `createOrReplaceTempView` 替代。
* 对 Hive tables `CREATE TABLE ... LOCATION` 行为的更改.
......@@ -2938,7 +2938,7 @@ Spark SQL CLI 是在本地模式下运行 Hive 转移服务并执行从命令行
* 从 1.6.1 开始，在 sparkR 中 withColumn 方法支持添加一个新列或更换 DataFrame 同名的现有列。
* 从 Spark 1.6 开始，LongType 强制转换为 TimestampType 期望是秒，而不是微秒。这种更改是为了匹配 Hive 1.2 的行为，以便从 numeric（数值）类型进行更一致的类型转换到 TimestampType。更多详情请参阅 [SPARK-11724](https://issues.apache.org/jira/browse/SPARK-11724) 。
* 从 Spark 1.6 开始，LongType 强制转换为 TimestampType 期望是秒，而不是微秒。这种更改是为了匹配 Hive 1.2 的行为，以便从 numeric（数值）类型进行更一致的类型转换到 TimestampType。更多详情请参阅 [SPARK-11724](https://issues.apache.org/jira/browse/SPARK-11724)。
## 从 Spark SQL 1.4 升级到 1.5
......@@ -2946,7 +2946,7 @@ Spark SQL CLI 是在本地模式下运行 Hive 转移服务并执行从命令行
* Parquet 的模式合并默认情况下不再启用。它可以通过设置 `spark.sql.parquet.mergeSchema` 到 `true` 以重新启用。
* 字符串在 Python 列的 columns（列）现在支持使用点（`.`）来限定列或访问嵌套值。例如 `df['table.column.nestedField']`。但是，这意味着如果你的列名中包含任何圆点，你现在必须避免使用反引号（如 `table.`column.with.dots`.nested`）。
* 在内存中的列存储分区修剪默认是开启的。它可以通过设置 `spark.sql.inMemoryColumnarStorage.partitionPruning` 为 `false` 来禁用。
* 无限精度的小数列不再支持，而不是 Spark SQL 最大精度为 38 。当从 `BigDecimal` 对象推断模式时，现在使用（38，18）。在 DDL 没有指定精度时，则默认保留 `Decimal(10, 0)`。
* 无限精度的小数列不再支持，而不是 Spark SQL 最大精度为 38。当从 `BigDecimal` 对象推断模式时，现在使用（38，18）。在 DDL 没有指定精度时，则默认保留 `Decimal(10, 0)`。
* 时间戳现在存储在 1 微秒的精度，而不是 1 纳秒的。
* 在 sql 语句中，floating point（浮点数）现在解析为 decimal。HiveQL 解析保持不变。
* SQL / DataFrame 函数的规范名称现在是小写（例如 sum vs SUM）。
......@@ -3023,11 +3023,11 @@ sqlContext.setConf("spark.sql.retainGroupColumns", "false")
## 从 Spark SQL 1.0-1.2 升级到 1.3
在 Spark 1.3 中，我们从 Spark SQL 中删除了 “Alpha” 的标签，作为一部分已经清理过的可用的 API 。从 Spark 1.3 版本以上，Spark SQL 将提供在 1.X 系列的其他版本的二进制兼容性。这种兼容性保证不包括被明确标记为不稳定的（即 DeveloperApi 类或 Experimental） API。
在 Spark 1.3 中，我们从 Spark SQL 中删除了 “Alpha” 的标签，作为一部分已经清理过的可用的 API。从 Spark 1.3 版本以上，Spark SQL 将提供在 1.X 系列的其他版本的二进制兼容性。这种兼容性保证不包括被明确标记为不稳定的（即 DeveloperApi 类或 Experimental） API。
#### 重命名 DataFrame 的 SchemaRDD
升级到 Spark SQL 1.3 版本时，用户会发现最大的变化是，`SchemaRDD` 已更名为 `DataFrame`。这主要是因为 DataFrames 不再从 RDD 直接继承，而是由 RDDS 自己来实现这些功能。DataFrames 仍然可以通过调用 `.rdd` 方法转换为 RDDS 。
升级到 Spark SQL 1.3 版本时，用户会发现最大的变化是，`SchemaRDD` 已更名为 `DataFrame`。这主要是因为 DataFrames 不再从 RDD 直接继承，而是由 RDDS 自己来实现这些功能。DataFrames 仍然可以通过调用 `.rdd` 方法转换为 RDDS。
在 Scala 中，有一个从 `SchemaRDD` 到 `DataFrame` 类型别名，可以为一些情况提供源代码兼容性。它仍然建议用户更新他们的代码以使用 `DataFrame` 来代替。Java 和 Python 用户需要更新他们的代码。
......
docs/9.md
浏览文件 @ 9fd817c4
......@@ -105,7 +105,7 @@ val userGraph: Graph[(String, String), String]
从原始文件， RDD 甚至合成生成器构建属性图有许多方法，这些在[图形构建器](#graph_builders)的一节中有更详细的讨论 。最普遍的方法是使用 [Graph 对象](api/scala/index.html#org.apache.spark.graphx.Graph$)。例如，以下代码从 RDD 集合中构建一个图：
从原始文件， RDD 甚至合成生成器构建属性图有许多方法，这些在[图形构建器](#graph_builders)的一节中有更详细的讨论。最普遍的方法是使用 [Graph 对象](api/scala/index.html#org.apache.spark.graphx.Graph$)。例如，以下代码从 RDD 集合中构建一个图：
......@@ -187,7 +187,7 @@ facts.collect.foreach(println(_))
# Graph 运算符
正如 RDDs 有这样的基本操作 `map`， `filter`， 以及 `reduceByKey`，性能图表也有采取用户定义的函数基本运算符的集合，产生具有转化特性和结构的新图。定义了优化实现的核心运算符，并定义了 [`Graph`](api/scala/index.html#org.apache.spark.graphx.Graph) 表示为核心运算符组合的方便运算符 [`GraphOps`](api/scala/index.html#org.apache.spark.graphx.GraphOps) 。不过，由于 Scala 的含义，操作员 `GraphOps` 可自动作为成员使用 `Graph` 。例如，我们可以通过以下方法计算每个顶点的入度（定义 `GraphOps` ）：
正如 RDDs 有这样的基本操作 `map`， `filter`， 以及 `reduceByKey`，性能图表也有采取用户定义的函数基本运算符的集合，产生具有转化特性和结构的新图。定义了优化实现的核心运算符，并定义了 [`Graph`](api/scala/index.html#org.apache.spark.graphx.Graph) 表示为核心运算符组合的方便运算符 [`GraphOps`](api/scala/index.html#org.apache.spark.graphx.GraphOps)。不过，由于 Scala 的含义，操作员 `GraphOps` 可自动作为成员使用 `Graph`。例如，我们可以通过以下方法计算每个顶点的入度（定义 `GraphOps` ）：
......@@ -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`。因此，用户需要为用户定义的函数提供类型注释：
......@@ -463,11 +463,11 @@ val joinedGraph = graph.joinVertices(uniqueCosts,
许多图形分析任务的关键步骤是聚合关于每个顶点邻域的信息。例如，我们可能想知道每个用户拥有的关注者数量或每个用户的追随者的平均年龄。许多迭代图表算法（例如：网页级别，最短路径，以及连接成分）相邻顶点（例如：电流值的 PageRank ，最短到源路径，和最小可达顶点 ID ）的重复聚合性质。
> 为了提高性能，主聚合操作员 `graph.mapReduceTriplets` 从新的更改 `graph.AggregateMessages` 。虽然 API 的变化相对较小，但我们在下面提供了一个转换指南。
> 为了提高性能，主聚合操作员 `graph.mapReduceTriplets` 从新的更改 `graph.AggregateMessages`。虽然 API 的变化相对较小，但我们在下面提供了一个转换指南。
### 聚合消息 (aggregateMessages)
GraphX 中的核心聚合操作是 [`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]) 。该运算符将用户定义的 `sendMsg` 函数应用于图中的每个_边缘三元组_，然后使用该 `mergeMsg` 函数在其目标顶点聚合这些消息。
GraphX 中的核心聚合操作是 [`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])。该运算符将用户定义的 `sendMsg` 函数应用于图中的每个_边缘三元组_，然后使用该 `mergeMsg` 函数在其目标顶点聚合这些消息。
......@@ -485,7 +485,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) 中。
另外，[`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) 表示我们只需要源字段。
另外，[`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) 表示我们只需要源字段。
> 在早期版本的 GraphX 中，我们使用字节码检测来推断， [`TripletFields`](api/java/org/apache/spark/graphx/TripletFields.html) 但是我们发现字节码检查稍微不可靠，而是选择了更明确的用户控制。
......@@ -593,7 +593,7 @@ val maxDegrees: (VertexId, Int) = graph.degrees.reduce(max)
### 收集相邻点
在某些情况下，通过在每个顶点处收集相邻顶点及其属性可以更容易地表达计算。这可以使用 [`collectNeighborIds`](api/scala/index.html#org.apache.spark.graphx.GraphOps@collectNeighborIds(EdgeDirection):VertexRDD[Array[VertexId]]) 和 [`collectNeighbors`](api/scala/index.html#org.apache.spark.graphx.GraphOps@collectNeighbors(EdgeDirection):VertexRDD[Array[(VertexId,VD)]]) 运算符轻松实现 。
在某些情况下，通过在每个顶点处收集相邻顶点及其属性可以更容易地表达计算。这可以使用 [`collectNeighborIds`](api/scala/index.html#org.apache.spark.graphx.GraphOps@collectNeighborIds(EdgeDirection):VertexRDD[Array[VertexId]]) 和 [`collectNeighbors`](api/scala/index.html#org.apache.spark.graphx.GraphOps@collectNeighbors(EdgeDirection):VertexRDD[Array[(VertexId,VD)]]) 运算符轻松实现。
......@@ -757,7 +757,7 @@ object Graph {
# Vertex and Edge RDDs
GraphX 公开 `RDD` 了图中存储的顶点和边的视图。然而，由于 GraphX 在优化的数据结构中维护顶点和边，并且这些数据结构提供了附加功能，所以顶点和边分别作为[`VertexRDD`](api/scala/index.html#org.apache.spark.graphx.VertexRDD) 和 [`EdgeRDD`](api/scala/index.html#org.apache.spark.graphx.EdgeRDD) 返回 。在本节中，我们将回顾一些这些类型中的其他有用功能。请注意，这只是一个不完整的列表，请参阅API文档中的正式操作列表。
GraphX 公开 `RDD` 了图中存储的顶点和边的视图。然而，由于 GraphX 在优化的数据结构中维护顶点和边，并且这些数据结构提供了附加功能，所以顶点和边分别作为[`VertexRDD`](api/scala/index.html#org.apache.spark.graphx.VertexRDD) 和 [`EdgeRDD`](api/scala/index.html#org.apache.spark.graphx.EdgeRDD) 返回。在本节中，我们将回顾一些这些类型中的其他有用功能。请注意，这只是一个不完整的列表，请参阅API文档中的正式操作列表。
## VertexRDDs
......@@ -841,15 +841,15 @@ GraphX 不是沿着边沿分割图形，而是沿着顶点分割图形，这可
# Graph 算法
GraphX 包括一组简化分析任务的图算法。该算法被包含在 `org.apache.spark.graphx.lib` 包可直接作为方法来访问 `Graph` 通过 [`GraphOps`](api/scala/index.html#org.apache.spark.graphx.GraphOps) 。本节介绍算法及其使用方法。
GraphX 包括一组简化分析任务的图算法。该算法被包含在 `org.apache.spark.graphx.lib` 包可直接作为方法来访问 `Graph` 通过 [`GraphOps`](api/scala/index.html#org.apache.spark.graphx.GraphOps)。本节介绍算法及其使用方法。
## PageRank
PageRank 测量在图中每个顶点的重要性，假设从边缘 _u_ 到 _v_ 表示的认可 _v_ 通过的重要性 _u_ 。例如，如果 Twitter 用户遵循许多其他用户，则用户将被高度排名。
PageRank 测量在图中每个顶点的重要性，假设从边缘 _u_ 到 _v_ 表示的认可 _v_ 通过的重要性 _u_。例如，如果 Twitter 用户遵循许多其他用户，则用户将被高度排名。
GraphX 附带了 PageRank 的静态和动态实现方法作[`PageRank 对象`](api/scala/index.html#org.apache.spark.graphx.lib.PageRank$)上的方法。静态 PageRank 运行固定次数的迭代，而动态 PageRank 运行直到排列收敛（即，停止改变超过指定的公差）。[`GraphOps`](api/scala/index.html#org.apache.spark.graphx.GraphOps) 允许直接调用这些算法作为方法 `Graph` 。
GraphX 附带了 PageRank 的静态和动态实现方法作[`PageRank 对象`](api/scala/index.html#org.apache.spark.graphx.lib.PageRank$)上的方法。静态 PageRank 运行固定次数的迭代，而动态 PageRank 运行直到排列收敛（即，停止改变超过指定的公差）。[`GraphOps`](api/scala/index.html#org.apache.spark.graphx.GraphOps) 允许直接调用这些算法作为方法 `Graph`。
GraphX还包括一个可以运行 PageRank 的社交网络数据集示例。给出了一组用户 `data/graphx/users.txt` ，并给出了一组用户之间的关系 `data/graphx/followers.txt` 。我们计算每个用户的 PageRank 如下：
GraphX还包括一个可以运行 PageRank 的社交网络数据集示例。给出了一组用户 `data/graphx/users.txt` ，并给出了一组用户之间的关系 `data/graphx/followers.txt`。我们计算每个用户的 PageRank 如下：
```
import org.apache.spark.graphx.GraphLoader
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或