" （" to "（"

docs/15.md

@@ -35,24 +35,24 @@ Spark 除了运行在 Mesos 或者 YARN 上以外，Spark 还提供了一个简
 ./sbin/start-slave.sh <master-spark-URL> 
 ```
 
-在您启动一个 worker 之后，就可以通过 master 的 web UI ( 默认情况下是 [http://localhost:8080](http://localhost:8080))查看到了。您可以看到列出的新的 node （节点），以及其 CPU 的数量和数量（为操作系统留下了 1 GB 的空间）。
+在您启动一个 worker 之后，就可以通过 master 的 web UI ( 默认情况下是 [http://localhost:8080](http://localhost:8080))查看到了。您可以看到列出的新的 node（节点），以及其 CPU 的数量和数量（为操作系统留下了 1 GB 的空间）。
 
 最后，下面的配置选项可以传递给 master 和 worker：
 
 | Argument（参数） | Meaning（含义） |
 | --- | --- |
 | `-h HOST`，`--host HOST` | 监听的 Hostname |
-| `-i HOST`，`--ip HOST` | 监听的 Hostname （已弃用，请使用 -h or --host） |
-| `-p PORT`，`--port PORT` | 监听的服务 Port （端口） （默认：master 是 7077， worker 是随机的） |
+| `-i HOST`，`--ip HOST` | 监听的 Hostname（已弃用，请使用 -h or --host） |
+| `-p PORT`，`--port PORT` | 监听的服务 Port（端口）（默认：master 是 7077， worker 是随机的） |
 | `--webui-port PORT` | web UI 的端口（默认：master 是 8080， worker 是 8081） |
 | `-c CORES`，`--cores CORES` | Spark 应用程序在机器上可以使用的全部的 CPU 核数（默认是全部可用的）；这个选项仅在 worker 上可用 |
 | `-m MEM`，`--memory MEM` | Spark 应用程序可以使用的内存数量，格式像 1000M 或者 2G（默认情况是您的机器内存数减去 1 GB）；这个选项仅在 worker 上可用 |
-| `-d DIR`，`--work-dir DIR` | 用于 scratch space （暂存空间）和作业输出日志的目录（默认是：SPARK_HOME/work）；这个选项仅在 worker 上可用 |
+| `-d DIR`，`--work-dir DIR` | 用于 scratch space（暂存空间）和作业输出日志的目录（默认是：SPARK_HOME/work）；这个选项仅在 worker 上可用 |
 | `--properties-file FILE` | 自定义的 Spark 配置文件加载目录（默认：conf/spark-defaults.conf） |
 
 # 集群启动脚本
 
-要使用启动脚本启动 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` 中可用：
 
@@ -68,21 +68,21 @@ Spark 除了运行在 Mesos 或者 YARN 上以外，Spark 还提供了一个简
 
 您可以通过在 `conf/spark-env.sh` 中设置环境变量来进一步配置集群。利用 `conf/spark-env.sh.template` 文件来创建这个文件，然后将它复制到所有的 worker 机器上使设置有效。下面的设置是可用的：
 
-| Environment Variable （环境变量） | Meaning（含义） |
+| Environment Variable（环境变量） | Meaning（含义） |
 | --- | --- |
 | `SPARK_MASTER_HOST` | 绑定 master 到一个指定的 hostname 或者 IP 地址，例如一个 public hostname 或者 IP。 |
-| `SPARK_MASTER_PORT` | 在不同的端口上启动 master （默认：7077） |
+| `SPARK_MASTER_PORT` | 在不同的端口上启动 master（默认：7077） |
 | `SPARK_MASTER_WEBUI_PORT` | master 的 web UI 的端口（默认：8080） |
-| `SPARK_MASTER_OPTS` | 仅应用到 master 上的配置属性，格式是 "-Dx=y" （默认是：none）。查看下面的列表可能选项。 |
+| `SPARK_MASTER_OPTS` | 仅应用到 master 上的配置属性，格式是 "-Dx=y"（默认是：none）。查看下面的列表可能选项。 |
 | `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（随机）） |
-| `SPARK_WORKER_WEBUI_PORT` | worker 的 web UI 的 Port （端口）（默认：8081） |
+| `SPARK_WORKER_PORT` | 在一个指定的 port（端口）上启动 Spark worker（默认： random（随机）） |
+| `SPARK_WORKER_WEBUI_PORT` | worker 的 web UI 的 Port（端口）（默认：8081） |
 | `SPARK_WORKER_DIR` | 运行应用程序的目录，这个目录中包含日志和暂存空间（default：SPARK_HOME/work） |
-| `SPARK_WORKER_OPTS` | 仅应用到 worker 的配置属性，格式是 "-Dx=y" （默认：none）。查看下面的列表的可能选项。 |
+| `SPARK_WORKER_OPTS` | 仅应用到 worker 的配置属性，格式是 "-Dx=y"（默认：none）。查看下面的列表的可能选项。 |
 | `SPARK_DAEMON_MEMORY` | 分配给 Spark master 和 worker 守护进程的内存。（默认： 1g） |
-| `SPARK_DAEMON_JAVA_OPTS` | Spark master 和 worker 守护进程的 JVM 选项，格式是 "-Dx=y" （默认：none） |
+| `SPARK_DAEMON_JAVA_OPTS` | Spark master 和 worker 守护进程的 JVM 选项，格式是 "-Dx=y"（默认：none） |
 | `SPARK_PUBLIC_DNS` | Spark master 和 worker 的公开 DNS 名称。（默认：none） |
 
 **注意：** 启动脚本现在还不支持 Windows。要在 Windows 上运行一个 Spark 集群，需要手动启动 master 和 workers。
@@ -95,9 +95,9 @@ SPARK_MASTER_OPTS 支持以下系统属性:
  |
 | `spark.deploy.retainedDrivers` | 200 | 展示已完成的 drivers 的最大数量。老的 driver 会从 UI 删除掉以满足限制。
  |
-| `spark.deploy.spreadOut` | true | 这个选项控制 standalone 集群 manager 是应该跨界店 spread （传播）应用程序还是应该努力将应用程序整合到尽可能少的节点上。在 HDFS 中， Spreading 是数据本地化的更好的选择，但是对于计算密集型的负载，整合会更有效率。
+| `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`。
  |
@@ -122,7 +122,7 @@ SPARK_WORKER_OPTS 支持以下的系统属性：
 ./bin/spark-shell --master spark://IP:PORT 
 ```
 
-您还可以传递一个选项 `--total-executor-cores &lt;numCores&gt;` 来控制 spark-shell 在集群上使用的 cores （核）数。
+您还可以传递一个选项 `--total-executor-cores &lt;numCores&gt;` 来控制 spark-shell 在集群上使用的 cores（核）数。
 
 # 启动 Spark 应用程序
 
@@ -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（核）的数量。例如：
 
 ```
 val conf = new SparkConf()
@@ -180,7 +180,7 @@ 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)。
 
@@ -196,7 +196,7 @@ Spark 对网络的需求比较高，并且一些环境对于使用严格的防
 
 为了调度新的应用程序或者添加新的 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 在启动时的存在。
+在 “registering with a Master（使用 Master 注册）” 与正常操作之间有一个重要的区别。当启动的时候，一个应用程序或者 Worker 需要使用当前的 lead Master 找到并且注册。一旦它成功注册，它就是 “in the system（在系统中）”了（即存储在了 ZooKeeper 中）。如果发生故障切换，新的 leader 将会联系所有值钱已经注册的应用程序和 Workers 来通知他们领导层的变化，所以他们甚至不知道新的 Master 在启动时的存在。
 
 由于这个属性，新的 Masters 可以在任何时间创建，唯一需要担心的是，_new_ 应用程序和 Workers 可以找到它注册，以防其成为 leader。一旦注册了之后，您将被照顾。
 
@@ -219,4 +219,4 @@ ZooKeeper 是生产级别的高可用性的最佳方法，但是如果您只是
 
 *   该解决方案可以与像 [monit](http://mmonit.com/monit/) 这样的过程 monitor/manager 一起使用，或者只是通过重新启动手动恢复。
 *   尽管文件系统恢复似乎比完全没有任何恢复更好，但是对于某些特定的开发或者实验目的，此模式可能不太适合。特别是，通过 stop-master.sh 杀死 master 并不会清除其恢复状态，所以每当重新启动一个新的 Master 时，它将进入恢复模式。如果需要等待所有先前注册的 Worker/clients 超时，这可能会将启动时间增加 1 分钟。
-*   虽然没有正式的支持，你也可以挂载 NFS 目录作为恢复目录。如果 original Master w安全地死亡，则您可以在不同的节点上启动 Master，这将正确恢复所有以前注册的 Workers/applications （相当于 ZooKeeper 恢复）。然而，未来的应用程序必须能够找到新的 Master 才能注册。
\ No newline at end of file
+*   虽然没有正式的支持，你也可以挂载 NFS 目录作为恢复目录。如果 original Master w安全地死亡，则您可以在不同的节点上启动 Master，这将正确恢复所有以前注册的 Workers/applications（相当于 ZooKeeper 恢复）。然而，未来的应用程序必须能够找到新的 Master 才能注册。
\ No newline at end of file

docs/16.md

@@ -24,8 +24,8 @@ Spark 可以运行在 [Apache Mesos](http://mesos.apache.org/) 管理的硬件
 
 使用 Mesos 部署 Spark 的优点包括：
 
-*   Spark 与其他的 [frameworks（框架）](https://mesos.apache.org/documentation/latest/mesos-frameworks/) 之间的 dynamic partitioning （动态分区）
-*   在 Spark 的多个实例之间的 scalable partitioning （可扩展分区）
+*   Spark 与其他的 [frameworks（框架）](https://mesos.apache.org/documentation/latest/mesos-frameworks/) 之间的 dynamic partitioning（动态分区）
+*   在 Spark 的多个实例之间的 scalable partitioning（可扩展分区）
 
 # 运行原理
 
@@ -33,7 +33,7 @@ Spark 可以运行在 [Apache Mesos](http://mesos.apache.org/) 管理的硬件
 
 ![Spark 集群组件](img/1b193ef9791313508d0c806587f136fd.jpg "Spark 集群组件")
 
-现在当 driver 创建一个作业并开始执行调度任务时， Mesos 会决定什么机器处理什么任务。因为 Mesos 调度这些短期任务时会将其他的框架考虑在内，多个框架可以共存在同一个集群上，而不需要求助于一个 static partitioning of resources （资源的静态分区）。
+现在当 driver 创建一个作业并开始执行调度任务时， Mesos 会决定什么机器处理什么任务。因为 Mesos 调度这些短期任务时会将其他的框架考虑在内，多个框架可以共存在同一个集群上，而不需要求助于一个 static partitioning of resources（资源的静态分区）。
 
 要开始，请按照以下步骤安装 Mesos 并通过 Mesos 部署 Spark 作业。
 
@@ -43,7 +43,7 @@ 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。
 
 ## 从源码安装
 
@@ -56,9 +56,9 @@ Spark 2.2.0 专门为 Mesos 1.0.0 或更新的版本并且不需要 Mesos 的任
 
 ## 第三方软件包
 
-Apache Mesos 只发布了源码的发行版本，而不是 binary packages （二进制包）。但是其他的第三方项目发布了 binary releases （二进制发行版本），可能对设置 Mesos 有帮助。
+Apache Mesos 只发布了源码的发行版本，而不是 binary packages（二进制包）。但是其他的第三方项目发布了 binary releases（二进制发行版本），可能对设置 Mesos 有帮助。
 
-其中之一是 Mesosphere。使用 Mesosphere 提供的 binary releases （二进制发行版本）安装 Mesos：
+其中之一是 Mesosphere。使用 Mesosphere 提供的 binary releases（二进制发行版本）安装 Mesos：
 
 1.  从 [下载页面](http://mesosphere.io/downloads/) 下载 Mesos 安装包
 2.  按照他们的说明进行安装和配置
@@ -73,15 +73,15 @@ Mesosphere 安装文档建议安装 ZooKeeper 来处理 Mesos master 故障切
 
 要使用 Spark 中的 Mesos，您需要一个 Spark 的二进制包放到 Mesos 可以访问的地方，然后一个 Spark driver 程序配置来连接 Mesos。
 
-或者，您也可以将 Spark 安装在所有 Mesos slaves 中的相同位置，并且配置 `spark.mesos.executor.home` （默认是 SPARK_HOME）来指向该位置。
+或者，您也可以将 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://`。
 
 要使用预编译的包：
 
-1.  从 Spark 的 [下载页面](https://spark.apache.org/downloads.html) 下载一个 Spark binary package （Spark 二进制包）
+1.  从 Spark 的 [下载页面](https://spark.apache.org/downloads.html) 下载一个 Spark binary package（Spark 二进制包）
 2.  上传到 hdfs/http/s3
 
 要托管在 HDFS 上，使用 Hadoop fs put 命令：`hadoop fs -put spark-2.2.0.tar.gz /path/to/spark-2.2.0.tar.gz`
@@ -89,7 +89,7 @@ Mesosphere 安装文档建议安装 ZooKeeper 来处理 Mesos master 故障切
 或者如果您正在使用着一个自定义编译的 Spark 版本，您将需要使用 在 Spark 源码中的 tarball/checkout 的 `dev/make-distribution.sh` 脚本创建一个包。
 
 1.  按照说明 [这里](index.html) 来下载并构建 Spark。
-2.  使用 `./dev/make-distribution.sh --tgz` 创建一个 binary package （二进制包）
+2.  使用 `./dev/make-distribution.sh --tgz` 创建一个 binary package（二进制包）
 3.  将归档文件上传到 http/s3/hdfs
 
 ## 使用 Mesos Master URL
@@ -127,15 +127,15 @@ 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` 作为在主机上运行的守护程序。
+要使用集群模式，你必须在您的集群中通过 `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 的多个实例。
+如果您喜欢使用 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 的状态。
+从客户端，您可以提交一个作业到 Mesos 集群，通过执行 `spark-submit` 并指定 `MesosClusterDispatcher` 的 master URL（例如：mesos://dispatcher:7077）。您可以在 Spark cluster Web UI 查看 driver 的状态。
 
 例如：
 
@@ -169,9 +169,9 @@ Spark 可以以两种模式运行 Mesos： “coarse-grained（粗粒度）”
 
 当应用程序启动时，执行器就会高涨，直到达到 `spark.cores.max`。如果您没有设置 `spark.cores.max`，Spark 应用程序将会保留 Mesos 提供的所有的资源，因此我们当然会敦促您在任何类型的多租户集群上设置此变量，包括运行多个并发 Spark 应用程序的集群。
 
-调度程序将会在提供的 Mesos 上启动执行器循环给它，但是没有 spread guarantees （传播保证），因为 Mesos 不提供这样的保证在提供流上。
+调度程序将会在提供的 Mesos 上启动执行器循环给它，但是没有 spread guarantees（传播保证），因为 Mesos 不提供这样的保证在提供流上。
 
-在这个模式下 spark 执行器将遵守 port （端口）分配如果这些事由用户提供的。特别是如果用户在 Spark 配置中定义了 `spark.executor.port` 或者 `spark.blockManager.port`，mesos 调度器将检查有效端口的可用 offers 包含端口号。如果没有这样的 range 可用，它会不启动任何任务。如果用户提供的端口号不受限制，临时端口像往常一样使用。如果用户定义了一个端口，这个端口实现意味着 one task per host （每个主机一个任务）。在未来网络中，isolation 将被支持。
+在这个模式下 spark 执行器将遵守 port（端口）分配如果这些事由用户提供的。特别是如果用户在 Spark 配置中定义了 `spark.executor.port` 或者 `spark.blockManager.port`，mesos 调度器将检查有效端口的可用 offers 包含端口号。如果没有这样的 range 可用，它会不启动任何任务。如果用户提供的端口号不受限制，临时端口像往常一样使用。如果用户定义了一个端口，这个端口实现意味着 one task per host（每个主机一个任务）。在未来网络中，isolation 将被支持。
 
 粗粒度模式的好处是开销要低得多，但是在应用程序的整个持续时间内保留 Mesos 资源的代价。要配置您的作业以动态调整资源需求，请参阅 [动态分配](#dynamic-resource-allocation-with-mesos)。
 
@@ -179,7 +179,7 @@ Spark 可以以两种模式运行 Mesos： “coarse-grained（粗粒度）”
 
 **注意:** 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 执行器中的每个 Spark 任务作为单独的 Mesos 任务运行。这允许 Spark 的多个实例（和其他框架）以非常细的粒度来共享 cores（内核），其中每个应用程序在其上升和下降时获得更多或更少的核。但是它在启动每个任务时增加额外的开销。这种模式可能不适合低延迟要求，如交互式查询或者提供 web 请求。
 
 请注意，尽管细粒度的 Spark 任务在它们终止时将放弃内核，但是他们不会放弃内存，因为 JVM 不会将内存回馈给操作系统。执行器在空闲时也不会终止。
 
@@ -205,11 +205,11 @@ Spark 可以通过在您的 [SparkConf](configuration.html#spark-properties) 中
 
 需要 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://<namenode>:9000/path`），但是您可以在 Hadoop Namenode web UI 上找到正确的 URL。
+您可以在现有的 Hadoop 集群集成运行 Spark 和 Mesos，只需要在机器上启动他们作为分开的服务即可。要从 Spark 访问 Hadoop 数据，需要一个完整的 `hdfs://` URL（通常为 `hdfs://<namenode>:9000/path`），但是您可以在 Hadoop Namenode web UI 上找到正确的 URL。
 
 此外，还可以在 Mesos 上运行 Hadoop MapReduce，以便在两者之间实现更好的资源隔离和共享。在这种情况下，Mesos 将作为统一的调度程序，将 Core 核心分配给 Hadoop 或 Spark，而不是通过每个节点上的 Linux 调度程序共享资源。请参考 [Hadoop on Mesos](https://github.com/mesos/hadoop)。
 
@@ -231,7 +231,7 @@ Mesos 仅支持使用粗粒度模式的动态分配，这可以基于应用程
 | --- | --- | --- |
 | `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.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` 命令的自定义参数的列表。此属性的格式是逗号分隔的列表      键/值对。例：
@@ -272,7 +272,7 @@ key1=val1,key2=val2,key3=val3
 | `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`）将被<a     HREF = "http://mesos.apache.org/documentation/latest/fetcher/"> Mesos      Fetcher Cache</a> |
+| `spark.mesos.fetcherCache.enable` | `false` | 如果设置为 `true`，则所有 URI（例如：`spark.executor.uri`，      `spark.mesos.uris`）将被<a     HREF = "http://mesos.apache.org/documentation/latest/fetcher/"> Mesos      Fetcher Cache</a> |
 
 # 故障排查和调试
 

docs/17.md

@@ -53,7 +53,7 @@ $ ./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（分布式缓存）中。
 
@@ -71,7 +71,7 @@ yarn logs -applicationId <app ID>
 
 将打印来自给定的应用程序的所有容器（containers）的所有的日志文件的内容。你还可以使用 HDFS shell 或者 API 直接在 HDFS 中查看容器日志文件（container log files）。可以通过查看您的 YARN 配置（`yarn.nodemanager.remote-app-log-dir` 和 `yarn.nodemanager.remote-app-log-dir-suffix`）找到它们所在的目录。日志还可以在 Spark Web UI 的 “执行程序（Executors）”选项卡下找到。您需要同时运行 Spark 历史记录服务器（Spark history server） 和 MapReduce 历史记录服务器（MapReduce history server），并在 `yarn-site.xm`l 文件中正确配置 `yarn.log.server.url`。Spark 历史记录服务器 UI 上的日志将重定向您到 MapReduce 历史记录服务器以显示聚合日志（aggregated logs）。
 
-当未启用日志聚合时，日志将在每台计算机上的本地保留在 `YARN_APP_LOGS_DIR 目录下`，通常配置为 `/tmp/logs` 或者 `$HADOOP_HOME/logs/userlogs`，具体取决于 Hadoop 版本和安装。查看容器（container）的日志需要转到包含它们的主机并在此目录中查看它们。子目录根据应用程序 ID （application ID）和 容器 ID （container ID）组织日志文件。日志还可以在 Spark Web UI 的 “执行程序（Executors）”选项卡下找到，并且不需要运行 MapReduce history server。
+当未启用日志聚合时，日志将在每台计算机上的本地保留在 `YARN_APP_LOGS_DIR 目录下`，通常配置为 `/tmp/logs` 或者 `$HADOOP_HOME/logs/userlogs`，具体取决于 Hadoop 版本和安装。查看容器（container）的日志需要转到包含它们的主机并在此目录中查看它们。子目录根据应用程序 ID（application ID）和 容器 ID（container ID）组织日志文件。日志还可以在 Spark Web UI 的 “执行程序（Executors）”选项卡下找到，并且不需要运行 MapReduce history server。
 
 要查看每个 container（容器）的启动环境，请将 `yarn.nodemanager.delete.debug-delay-sec` 增加到一个较大的值（例如 `36000`），然后通过 `yarn.nodemanager.local-dirs` 访问应用程序缓存，在容器启动的节点上。此目录包含启动脚本（launch script）， JARs，和用于启动每个容器的所有的环境变量。这个过程对于调试 classpath 问题特别有用。（请注意，启用此功能需要集群设置的管理员权限并且还需要重新启动所有的 node managers，因此这不适用于托管集群）。
 
@@ -79,7 +79,7 @@ yarn logs -applicationId <app ID>
 
 *   使用 `spark-submit` 上传一个自定义的 `log4j.properties`，通过将 spark-submit 添加到要与应用程序一起上传的文件的 –files 列表中。
 *   add `-Dlog4j.configuration=&lt;location of configuration file&gt;` to `spark.driver.extraJavaOptions` (for the driver) or `spark.executor.extraJavaOptions` (for executors). Note that if using a file, the `file:` protocol should be explicitly provided, and the file needs to exist locally on all the nodes.
-*   添加 `-Dlog4j.configuration=&lt;配置文件的位置&gt;` 到 `spark.driver.extraJavaOptions`（对于驱动程序）或者 containers （对于执行者）。请注意，如果使用文件，文件：协议（protocol ）应该被显式提供，并且该文件需要在所有节点的本地存在。
+*   添加 `-Dlog4j.configuration=&lt;配置文件的位置&gt;` 到 `spark.driver.extraJavaOptions`（对于驱动程序）或者 containers（对于执行者）。请注意，如果使用文件，文件：协议（protocol ）应该被显式提供，并且该文件需要在所有节点的本地存在。
 *   更新 `$SPARK_CONF_DIR/log4j.properties` 文件，并且它将与其他配置一起自动上传。请注意，如果指定了多个选项，其他 2 个选项的优先级高于此选项。
 
 请注意，对于第一个选项，executors 和 application master 将共享相同的 log4j 配置，这当它们在同一个节点上运行的时候，可能会导致问题（例如，试图写入相同的日志文件）。

docs/22.md

@@ -63,7 +63,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 调优的讨论。
 

docs/27.md

@@ -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 构建
 
@@ -140,7 +140,7 @@ Spark 现在与一个独立的 Maven 安装包封装到了一起，以便从位
 
 这里应该运行连续编译（即等待更改）。然而这并没有得到广泛的测试。有几个需要注意的事情：
 
-*   它只扫描路径 `src/main` 和 `src/test` （查看 [docs](http://scala-tools.org/mvnsites/maven-scala-plugin/usage_cc.html)），所以其只对含有该结构的某些子模块起作用。
+*   它只扫描路径 `src/main` 和 `src/test`（查看 [docs](http://scala-tools.org/mvnsites/maven-scala-plugin/usage_cc.html)），所以其只对含有该结构的某些子模块起作用。
 
 *   您通常需要在工程的根目录运行 `mvn install` 在编译某些特定子模块时。这是因为依赖于其他子模块的子模块需要通过 `spark-parent` 模块实现。
 
@@ -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)。
 
 ## 加密文件系统
 
@@ -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

@@ -717,7 +717,7 @@ 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。
+| **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 的异步执行。.