Skip to content

S
spark-doc-zh

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

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

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

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

" ）" to "）"

上级 068b5af0
隐藏空白更改
内联 并排
Showing with 105 addition and 105 deletion
docs/12.md
浏览文件 @ b89e0d9a
......@@ -43,15 +43,15 @@ Spark 即可以在应用间（Cluster Manager 级别），也可以在应用内
下表总结了您将看到的用于引用集群概念的术语：
| Term（术语） | Meaning（含义） |
| Term（术语）| Meaning（含义）|
| --- | --- |
| Application | 用户构建在 Spark 上的程序。由集群上的一个 driver 程序和多个 executor 组成。 |
| Application jar | 一个包含用户 Spark 应用的 Jar。有时候用户会想要去创建一个包含他们应用以及它的依赖的 “uber jar”。用户的 Jar 应该没有包括 Hadoop 或者 Spark 库，然而，它们将会在运行时被添加。 |
| Driver program | 该进程运行应用的 main() 方法并且创建了 SparkContext。 |
| Cluster manager | 一个外部的用于获取集群上资源的服务。（例如，Standlone Manager，Mesos，YARN） |
| Cluster manager | 一个外部的用于获取集群上资源的服务。（例如，Standlone Manager，Mesos，YARN）|
| Deploy mode | 根据 driver 程序运行的地方区别。在 “Cluster” 模式中，框架在群集内部启动 driver。在 “Client” 模式中，submitter（提交者）在 Custer 外部启动 driver。 |
| Worker node | 任何在集群中可以运行应用代码的节点。 |
| Executor | 一个为了在 worker 节点上的应用而启动的进程，它运行 task 并且将数据保持在内存中或者硬盘存储。每个应用有它自己的 Executor。 |
| Task | 一个将要被发送到 Executor 中的工作单元。 |
| Job | 一个由多个任务组成的并行计算，并且能从 Spark action 中获取响应（例如 `save`，`collect`）; 您将在 driver 的日志中看到这个术语。 |
| Stage | 每个 Job 被拆分成更小的被称作 stage（阶段） 的 task（任务） 组，stage 彼此之间是相互依赖的（与 MapReduce 中的 map 和 reduce stage 相似）。您将在 driver 的日志中看到这个术语。 |
\ No newline at end of file
| Stage | 每个 Job 被拆分成更小的被称作 stage（阶段）的 task（任务）组，stage 彼此之间是相互依赖的（与 MapReduce 中的 map 和 reduce stage 相似）。您将在 driver 的日志中看到这个术语。 |
\ No newline at end of file
docs/15.md
浏览文件 @ b89e0d9a
......@@ -39,16 +39,16 @@ Spark 除了运行在 Mesos 或者 YARN 上以外，Spark 还提供了一个简
最后，下面的配置选项可以传递给 master 和 worker：
| Argument（参数） | Meaning（含义） |
| Argument（参数）| Meaning（含义）|
| --- | --- |
| `-h HOST`，`--host HOST` | 监听的 Hostname |
| `-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） |
| `-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 上可用 |
| `--properties-file FILE` | 自定义的 Spark 配置文件加载目录（默认：conf/spark-defaults.conf） |
| `--properties-file FILE` | 自定义的 Spark 配置文件加载目录（默认：conf/spark-defaults.conf）|
# 集群启动脚本
......@@ -68,28 +68,28 @@ 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_WEBUI_PORT` | master 的 web UI 的端口（默认：8080） |
| `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_WORKER_CORES` | 机器上 Spark 应用程序可以使用的全部的 cores（核）的数量。（默认：全部的核可用） |
| `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_DIR` | 运行应用程序的目录，这个目录中包含日志和暂存空间（default：SPARK_HOME/work） |
| `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_DAEMON_MEMORY` | 分配给 Spark master 和 worker 守护进程的内存。（默认： 1g） |
| `SPARK_DAEMON_JAVA_OPTS` | Spark master 和 worker 守护进程的 JVM 选项，格式是 "-Dx=y"（默认：none） |
| `SPARK_PUBLIC_DNS` | Spark master 和 worker 的公开 DNS 名称。（默认：none） |
| `SPARK_DAEMON_MEMORY` | 分配给 Spark master 和 worker 守护进程的内存。（默认： 1g）|
| `SPARK_DAEMON_JAVA_OPTS` | Spark master 和 worker 守护进程的 JVM 选项，格式是 "-Dx=y"（默认：none）|
| `SPARK_PUBLIC_DNS` | Spark master 和 worker 的公开 DNS 名称。（默认：none）|
**注意：** 启动脚本现在还不支持 Windows。要在 Windows 上运行一个 Spark 集群，需要手动启动 master 和 workers。
SPARK_MASTER_OPTS 支持以下系统属性:
| Property Name（属性名称） | Default（默认） | Meaning（含义） |
| Property Name（属性名称）| Default（默认）| Meaning（含义）|
| --- | --- | --- |
| `spark.deploy.retainedApplications` | 200 | 展示的已完成的应用程序的最大数量。旧的应用程序将会从 UI 中被删除以满足限制。
|
......@@ -210,9 +210,9 @@ ZooKeeper 是生产级别的高可用性的最佳方法，但是如果您只是
为了启用此恢复模式，你可以使用以下配置在 spark-env 中设置 SPARK_DAEMON_JAVA_OPTS：
| System property（系统属性） | Meaning（含义） |
| System property（系统属性）| Meaning（含义）|
| --- | --- |
| `spark.deploy.recoveryMode` | 设置为 FILESYSTEM 以启用单节点恢复模式（默认：NONE） |
| `spark.deploy.recoveryMode` | 设置为 FILESYSTEM 以启用单节点恢复模式（默认：NONE）|
| `spark.deploy.recoveryDirectory` | Spark 将存储恢复状态的目录，可以从 Master 的角度访问。 |
**细节**
......
docs/16.md
浏览文件 @ b89e0d9a
......@@ -155,11 +155,11 @@ Spark on Mesos 还支持 cluster mode（集群模式），其中 driver 在集
# Mesos 运行模式
Spark 可以以两种模式运行 Mesos： “coarse-grained（粗粒度）”（默认） 和 “fine-grained（细粒度）”（不推荐）。
Spark 可以以两种模式运行 Mesos： “coarse-grained（粗粒度）”（默认）和 “fine-grained（细粒度）”（不推荐）。
## Coarse-Grained（粗粒度）
在 “coarse-grained（粗粒度） 模式下，每个 Spark 执行器都作为单个 Mesos 任务运行。Spark 执行器的大小是根据下面的配置变量确定的：
在 “coarse-grained（粗粒度）模式下，每个 Spark 执行器都作为单个 Mesos 任务运行。Spark 执行器的大小是根据下面的配置变量确定的：
* Executor memory（执行器内存）：`spark.executor.memory`
* Executor cores（执行器核）：`spark.executor.cores`
......@@ -227,7 +227,7 @@ Mesos 仅支持使用粗粒度模式的动态分配，这可以基于应用程
#### Spark 属性
| Property Name（属性名称） | Default（默认） | Meaning（含义） |
| 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 粗粒度模式。 |
......
docs/17.md
浏览文件 @ b89e0d9a
......@@ -69,7 +69,7 @@ $ ./bin/spark-submit --class my.main.Class \
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）。
将打印来自给定的应用程序的所有容器（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。
......@@ -94,7 +94,7 @@ To use a custom metrics.properties for the application master and executors, upd
</tr> </table> # 重要提示 - core request 在调度决策中是否得到执行取决于使用的调度程序及其配置方式。- 在 `cluster 集群` 模式中，Spark executors 和 Spark dirver 使用的本地目录是为 YARN（Hadoop YARN 配置 `yarn.nodemanager.local-dirs`）配置的本地目录。如果用户指定 `spark.local.dir`，它将被忽略。在 `client 客户端` 模式下，Spark executors 将使用为 YARN 配置的本地目录，Spark dirver 将使用 `spark.local.dir` 中定义的目录。这是因为 Spark drivers 不在 YARN cluster 的 `client ` 模式中运行，仅仅 Spark 的 executors 会这样做。- `--files` 和 `--archives` 支持用 # 指定文件名，与 Hadoop 相似。例如您可以指定：`--files localtest.txt#appSees.txt` 然后就会上传本地名为 `localtest.txt` 的文件到 HDFS 中去，但是会通过名称 `appSees.txt` 来链接，当你的应用程序在 YARN 上运行时，你应该使用名称 `appSees.txt` 来引用它。- The `--jars` 选项允许你在 `cluster 集群` 模式下使用本地文件时运行 `SparkContext.addJar` 函数。如果你使用 HDFS，HTTP，HTTPS 或 FTP 文件，则不需要使用它。# 在安全集群中运行 如 [security](security.html) 所讲的，Kerberos 被应用在安全的 Hadoop 集群中去验证与服务和客户端相关联的 principals。这允许客户端请求这些已验证的服务; 向授权的 principals 授予请求服务的权利。Hadoop 服务发出 *hadoop tokens* 去授权访问服务和数据。客户端必须首先获取它们将要访问的服务的 tokens，当启动应用程序时，将它和应用程序一起发送到 YAYN 集群中。如果 Spark 应用程序与其它任何的 Hadoop 文件系统（例如 hdfs，webhdfs，等等），HDFS，HBase 和 Hive 进行交互，它必须使用启动应用程序的用户的 Kerberos 凭据获取相关 tokens，也就是说身份将成为已启动的 Spark 应用程序的 principal。这通常在启动时完成：在安全集群中，Spark 将自动为集群的 HDFS 文件系统获取 tokens，也可能为 HBase 和 Hive 获取。如果 HBase 在 classpath 中，HBase token 是可以获取的，HBase 配置声明应用程序是安全的（即 `hbase-site.xml` 将 `hbase.security.authentication` 设置为 `kerberos`），并且 `spark.yarn.security.tokens.hbase.enabled` 未设置为 `false`，HBase tokens 将被获得。类似地，如果 Hive 在 classpath 中，其配置包括元数据存储的 URI（`hive.metastore.uris`），并且 `spark.yarn.security.tokens.hive.enabled` 未设置为 `false`，则将获得 Hive token（令牌）。如果应用程序需要与其他安全 Hadoop 文件系统交互，则在启动时必须显式请求访问这些集群所需的 tokens。这是通过将它们列在 1spark.yarn.access.namenodes1 属性中来实现的。``` spark.yarn.access.hadoopFileSystems hdfs://ireland.example.org:8020/,webhdfs://frankfurt.example.org:50070/ ``` Spark 支持通过 Java Services 机制（请看 `java.util.ServiceLoader`）与其它的具有安全性的服务来进行集成。为了实现该目标，通过在 jar 的 `META-INF/services` 目录中列出相应 `org.apache.spark.deploy.yarn.security.ServiceCredentialProvider` 的实现的名字就可应用到 Spark。这些插件可以通过设置 `spark.yarn.security.tokens.{service}.enabled` 为 `false` 来禁用，这里的 `{service}` 是 credential provider（凭证提供者）的名字。## 配置外部的 Shuffle Service 要在 YARN cluster 中的每个 `NodeManager` 中启动 Spark Shuffle，按照以下说明：1\. 用 [YARN profile](building-spark.html) 来构建 Spark。如果你使用了预包装的发布可以跳过该步骤。1\. 定位 `spark-<version>-yarn-shuffle.jar`。如果是你自己构建的 Spark，它应该在 `$SPARK_HOME/common/network-yarn/target/scala-<version>` 下，如果你使用的是一个发布的版本，那么它应该在 `yarn` 下。1\. 添加这个 jar 到你集群中所有的 `NodeManager` 的 classpath 下去。1\. 在每个 node（节点）的 `yarn-site.xml` 文件中，添加 `spark_shuffle` 到 `yarn.nodemanager.aux-services`，然后设置 `yarn.nodemanager.aux-services.spark_shuffle.class` 为 `org.apache.spark.network.yarn.YarnShuffleService`。1\. 通过在 `etc/hadoop/yarn-env.sh` 文件中设置 `YARN_HEAPSIZE` (默认值 1000) 增加 `NodeManager's` 堆大小以避免在 shuffle 时的 garbage collection issues（垃圾回收问题）。1\. 重启集群中所有的 `NodeManager`。当 shuffle service 服务在 YARN 上运行时，可以使用以下额外的配置选项:</version></version>
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.yarn.am.memory` | `512m` | 在客户端模式下用于 YARN Application Master 的内存量，与 JVM 内存字符串格式相同 (e.g. `512m`，`2g`)。在 `cluster` 集群模式下，使用 `spark.driver.memory` 代替.使用小写字母尾后缀，例如. `k`，`m`，`g`，`t`，and `p`，分别表示 kibi-，mebi-，gibi-，tebi- 和 pebibytes，respectively。 |
| `spark.yarn.am.cores` | `1` | 在客户端模式下用于 YARN Application Master 的核数。在集群模式下，请改用 `spark.driver.cores` 代替。 |
......@@ -137,7 +137,7 @@ To use a custom metrics.properties for the application master and executors, upd
| `spark.yarn.rolledLog.includePattern` | (none) | Java Regex 过滤与定义的包含模式匹配的日志文件，这些日志文件将以滚动的方式进行聚合。这将与 YARN 的滚动日志聚合一起使用，在 yarn-site.xml 文件中配置 `yarn.nodemanager.log-aggregation.roll-monitoring-interval-seconds` 以在 YARN 方面启用此功能。此功能只能与 Hadoop 2.6.4+ 一起使用。Spark log4j appender 需要更改才能使用 FileAppender 或其他 appender 可以处理正在运行的文件被删除。基于在 log4j 配置中配置的文件名（如 spark.log）上，用户应该设置正则表达式（spark *）包含需要聚合的所有日志文件。 |
| `spark.yarn.rolledLog.excludePattern` | (none) | Java Regex 过滤与定义的排除模式匹配的日志文件，并且这些日志文件将不会以滚动的方式进行聚合。如果日志文件名称匹配include 和 exclude 模式，最终将排除此文件。 |
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.yarn.shuffle.stopOnFailure` | `false` | 是否在 Spark Shuffle Service 初始化出现故障时停止 NodeManager。This prevents application failures caused by running containers on NodeManagers where the Spark Shuffle Service is not running. |
......
docs/20.md
浏览文件 @ b89e0d9a
......@@ -49,7 +49,7 @@ val conf = new SparkConf()
val sc = new SparkContext(conf)
```
注意，本地模式下，我们可以使用多个线程，而且在像 Spark Streaming 这样的场景下，我们可能需要多个线程来防止任一类型的类似 starvation issues（线程饿死） 这样的问题。配置时间段的属性应该写明时间单位，如下格式都是可接受的:
注意，本地模式下，我们可以使用多个线程，而且在像 Spark Streaming 这样的场景下，我们可能需要多个线程来防止任一类型的类似 starvation issues（线程饿死）这样的问题。配置时间段的属性应该写明时间单位，如下格式都是可接受的:
```
25ms (milliseconds)
......@@ -105,11 +105,11 @@ spark.serializer org.apache.spark.serializer.KryoSerializer
## 可用属性
大多数控制 internal settings（内部设置） 的属性具有合理的默认值。一些常见的选项是：
大多数控制 internal settings（内部设置）的属性具有合理的默认值。一些常见的选项是：
### 应用程序属性
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.app.name` | (none) | Spark 应用的名字。会在 SparkUI 和日志中出现。 |
| `spark.driver.cores` | 1 | 在 cluster 模式下，用几个 core 运行 driver 进程。 |
......@@ -128,7 +128,7 @@ Apart from these, the following properties are also available, and may be useful
### 运行环境
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.driver.extraClassPath` | (none) | 额外的classpath条目需预先添加到驱动程序 classpath中。注意：在客户端模式下，这一套配置不能通过 SparkConf 直接在应用在应用程序中，因为 JVM 驱动已经启用了。相反，请在配置文件中通过设置 --driver-class-path 选项或者选择默认属性。 |
| `spark.driver.extraJavaOptions` | (none) | 一些额外的 JVM 属性传递给驱动。例如，GC 设置或其他日志方面设置。注意，设置最大堆大小（-Xmx）是不合法的。最大堆大小设置可以通过在集群模式下设置 `spark.driver.memory` 选项，并且可以通过`--driver-memory` 在客户端模式设置。
......@@ -163,7 +163,7 @@ _注意:_ 在客户端模式下，这一套配置不能通过 `SparkConf` 直接
### Shuffle Behavior（Shuffle 行为）
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.reducer.maxSizeInFlight` | 48m | 从每个 Reduce 任务中并行的 fetch 数据的最大大小。因为每个输出都要求我们创建一个缓冲区，这代表要为每一个 Reduce 任务分配一个固定大小的内存。除非内存足够大否则尽量设置小一点。 |
| `spark.reducer.maxReqsInFlight` | Int.MaxValue | 在集群节点上，这个配置限制了远程 fetch 数据块的连接数目。当集群中的主机数量的增加时候，这可能导致大量的到一个或多个节点的主动连接，导致负载过多而失败。通过限制获取请求的数量，可以缓解这种情况。 |
......@@ -185,7 +185,7 @@ _注意:_ 在客户端模式下，这一套配置不能通过 `SparkConf` 直接
### Spark UI
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.eventLog.compress` | false | 是否压缩记录的事件，如果 `spark.eventLog.enabled` 为true。压缩将使用`spark.io.compression.codec`。 |
| `spark.eventLog.dir` | file:///tmp/spark-events | Spark 事件日志的文件路径。如果 `spark.eventLog.enabled` 为 true。在这个基本目录下，Spark 为每个应用程序创建一个二级目录，日志事件特定于应用程序的目录。用户可能希望设置一个统一的文件目录像一个 HDFS 目录那样，所以历史文件可以从历史文件服务器中读取。 |
......@@ -207,7 +207,7 @@ _注意:_ 在客户端模式下，这一套配置不能通过 `SparkConf` 直接
### Compression and Serialization（压缩和序列化）
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.broadcast.compress` | true | 是否在发送之前压缩广播变量。一般是个好主意压缩将使用 `spark.io.compression.codec`。 |
| `spark.io.compression.codec` | lz4 | 内部数据使用的压缩编解码器，如 RDD 分区，广播变量和混洗输出。默认情况下，Spark 提供三种编解码器：`lz4`，`lzf`，和 `snappy`。您还可以使用完全限定类名来指定编码解码器， 例如：`org.apache.spark.io.LZ4CompressionCodec`， `org.apache.spark.io.LZFCompressionCodec`， 和 `org.apache.spark.io.SnappyCompressionCodec`。 |
......@@ -227,7 +227,7 @@ JavaSerializer | 用于序列化将通过网络发送或需要以序列化形式
### Memory Management（内存管理）
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.memory.fraction` | 0.6 | 用于执行和存储的（堆空间 - 300MB）的分数。这个值越低，溢出和缓存数据逐出越频繁。此配置的目的是在稀疏、异常大的记录的情况下为内部元数据，用户数据结构和不精确的大小估计预留内存。推荐使用默认值。有关更多详细信息，包括关于在增加此值时正确调整 JVM 垃圾回收的重要信息，请参阅 [this description](tuning.html#memory-management-overview)。 |
| `spark.memory.storageFraction` | 0.5 | 不会被逐出内存的总量，表示为 `s​park.memory.fraction` 留出的区域大小的一小部分。这个越高，工作内存可能越少，执行和任务可能更频繁地溢出到磁盘。推荐使用默认值。有关更多详细信息，请参阅 [this description](tuning.html#memory-management-overview)。 |
......@@ -243,7 +243,7 @@ JavaSerializer | 用于序列化将通过网络发送或需要以序列化形式
### Execution Behavior（执行行为）
| Property Name（属性名称） | Default（默认行为） | Meaning（含义） |
| Property Name（属性名称）| Default（默认行为）| Meaning（含义）|
| --- | --- | --- |
| `spark.broadcast.blockSize` | 4m | `TorrentBroadcastFactory` 的一个块的每个分片大小。过大的值会降低广播期间的并行性（更慢了）; 但是，如果它过小，`BlockManager` 可能会受到性能影响。 |
| `spark.executor.cores` | 在 YARN 模式下默认为 1，standlone 和 Mesos 粗粒度模型中的 worker 节点的所有可用的 core。 | 在每个 executor（执行器）上使用的 core 数。在 standlone 和 Mesos 的粗粒度模式下，设置此参数允许应用在相同的 worker 上运行多个 executor（执行器），只要该 worker 上有足够的 core。否则，每个 application（应用）在单个 worker 上只会启动一个 executor（执行器）。 |
......@@ -267,7 +267,7 @@ JavaSerializer | 用于序列化将通过网络发送或需要以序列化形式
### Networking（网络）
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.rpc.message.maxSize` | 128 | 在 “control plane” 通信中允许的最大消息大小（以 MB 为单位）; 一般只适用于在 executors 和 driver 之间发送的映射输出大小信息。如果您正在运行带有数千个 map 和 reduce 任务的作业，并查看有关 RPC 消息大小的消息，请增加此值。 |
| `spark.blockManager.port` | (random) | 所有块管理器监听的端口。这些都存在于 driver 和 executors 上。 |
......@@ -285,7 +285,7 @@ It also allows a different address from the local one to be advertised to execut
### Scheduling（调度）
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.cores.max` | (not set) | 当以 “coarse-grained（粗粒度）” 共享模式在 [standalone deploy cluster](spark-standalone.html) 或 [Mesos cluster in "coarse-grained" sharing mode](running-on-mesos.html#mesos-run-modes) 上运行时，从集群（而不是每台计算机）请求应用程序的最大 CPU 内核数量。如果未设置，默认值将是 Spar k的 standalone deploy 管理器上的 `spark.deploy.defaultCores`，或者 Mesos上的无限（所有可用核心）。 |
| `spark.locality.wait` | 3s | 等待启动本地数据任务多长时间，然后在较少本地节点上放弃并启动它。相同的等待将用于跨越多个地点级别（process-local，node-local，rack-local 等所有）。也可以通过设置 `spark.locality.wait.node` 等来自定义每个级别的等待时间。如果任务很长并且局部性较差，则应该增加此设置，但是默认值通常很好。 |
......@@ -319,7 +319,7 @@ It also allows a different address from the local one to be advertised to execut
### Dynamic Allocation（动态分配）
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.dynamicAllocation.enabled` | false | 是否使用动态资源分配，它根据工作负载调整为此应用程序注册的执行程序数量。有关更多详细信息，请参阅 [here](job-scheduling.html#dynamic-resource-allocation) 的说明。这需要设置 `spark.shuffle.service.enabled`。以下配置也相关：`spark.dynamicAllocation.minExecutors`，`spark.dynamicAllocation.maxExecutors` 和`spark.dynamicAllocation.initialExecutors`。 |
| `spark.dynamicAllocation.executorIdleTimeout` | 60s | 如果启用动态分配，并且执行程序已空闲超过此持续时间，则将删除执行程序。有关更多详细信息，请参阅此[description](job-scheduling.html#resource-allocation-policy)。 |
......@@ -332,12 +332,12 @@ It also allows a different address from the local one to be advertised to execut
### Security（安全）
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.acls.enable` | false | 是否开启 Spark acls。如果开启了，它检查用户是否有权限去查看或修改 job。Note this requires the user to be known, so if the user comes across as null no checks are done. UI 利用使用过滤器验证和设置用户。 |
| `spark.admin.acls` | Empty | 逗号分隔的用户或者管理员列表，列表中的用户或管理员有查看和修改所有 Spark job 的权限。如果你运行在一个共享集群，有一组管理员或开发者帮助 debug，这个选项有用。 |
| `spark.admin.acls.groups` | Empty | 具有查看和修改对所有Spark作业的访问权限的组的逗号分隔列表。如果您有一组帮助维护和调试的 administrators 或 developers 可以使用此功能基础设施。在列表中输入 "*" 表示任何组中的任何用户都可以使用 admin 的特权。用户组是从 groups mapping provider 的实例获得的。由 `spark.user.groups.mapping` 指定。检查 entry `spark.user.groups.mapping` 了解更多详细信息。 |
| `spark.user.groups.mapping` | `org.apache.spark.security.ShellBasedGroupsMappingProvider` | 用户的组列表由特征定义的 group mapping service 决定可以通过此属性配置的org.apache.spark.security.GroupMappingServiceProvider. 提供了基于 unix shell 的默认实现 `org.apache.spark.security.ShellBasedGroupsMappingProvider` 可以指定它来解析用户的组列表。     _注意:_ 此实现仅支持基于 Unix/Linux 的环境。Windows 环境是      目前 **不** 支持。但是，通过实现可以支持新的 platform/protocol（平台/协议） trait `org.apache.spark.security.GroupMappingServiceProvider`。 |
| `spark.user.groups.mapping` | `org.apache.spark.security.ShellBasedGroupsMappingProvider` | 用户的组列表由特征定义的 group mapping service 决定可以通过此属性配置的org.apache.spark.security.GroupMappingServiceProvider. 提供了基于 unix shell 的默认实现 `org.apache.spark.security.ShellBasedGroupsMappingProvider` 可以指定它来解析用户的组列表。     _注意:_ 此实现仅支持基于 Unix/Linux 的环境。Windows 环境是      目前 **不** 支持。但是，通过实现可以支持新的 platform/protocol（平台/协议）trait `org.apache.spark.security.GroupMappingServiceProvider`。 |
| `spark.authenticate` | false | 是否 Spark 验证其内部连接。如果不是运行在 YARN 上，请看 `spark.authenticate.secret`。 |
| `spark.authenticate.secret` | None | 设置密钥用于 spark 组件之间进行身份验证。这需要设置 不启用运行在 yarn 和身份验证。 |
| `spark.network.crypto.enabled` | false | Enable encryption using the commons-crypto library for RPC and block transfer service. Requires `spark.authenticate` to be enabled. |
......@@ -407,7 +407,7 @@ showDF(properties, numRows = 200, truncate = FALSE)
### Spark Streaming
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.streaming.backpressure.enabled` | false | 开启或关闭 Spark Streaming 内部的 backpressure mecheanism（自 1.5 开始）。基于当前批次调度延迟和处理时间，这使得 Spark Streaming 能够控制数据的接收率，因此，系统接收数据的速度会和系统处理的速度一样快。从内部来说，这动态地设置了 receivers 的最大接收率。这个速率上限通过 `spark.streaming.receiver.maxRate` 和 `spark.streaming.kafka.maxRatePerPartition` 两个参数设定（如下）。 |
| `spark.streaming.backpressure.initialRate` | not set | 当 backpressure mecheanism 开启时，每个 receiver 接受数据的初始最大值。 |
......@@ -424,7 +424,7 @@ showDF(properties, numRows = 200, truncate = FALSE)
### SparkR
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.r.numRBackendThreads` | 2 | 使用 RBackend 处理来自 SparkR 包中的 RPC 调用的线程数。 |
| `spark.r.command` | Rscript | 在 driver 和 worker 两种集群模式下可执行的 R 脚本。 |
......@@ -441,7 +441,7 @@ showDF(properties, numRows = 200, truncate = FALSE)
### Deploy（部署）
| Property Name（属性名称） | Default（默认值） | Meaning（含义） |
| Property Name（属性名称）| Default（默认值）| Meaning（含义）|
| --- | --- | --- |
| `spark.deploy.recoveryMode` | NONE | 集群模式下，Spark jobs 执行失败或者重启时，恢复提交 Spark jobs 的恢复模式设定。 |
| `spark.deploy.zookeeper.url` | None | 当 `spark.deploy.recoveryMode` 被设定为 ZOOKEEPER，这一配置被用来连接 zookeeper URL。 |
......@@ -462,7 +462,7 @@ Spark 中的每个集群管理器都有额外的配置选项，这些配置可
通过环境变量配置特定的 Spark 设置。环境变量从 Spark 安装目录下的 `conf/spark-env.sh` 脚本读取（或者是 window 环境下的 `conf/spark-env.cmd` ）。在 Standalone 和 Mesos 模式下，这个文件可以指定机器的特定信息，比如 hostnames。它也可以为正在运行的 Spark Application 或者提交脚本提供 sourced（来源）.
注意，当 Spark 被安装，默认情况下 `conf/spark-env.sh` 是不存在的。但是，你可以通过拷贝 `conf/spark-env.sh.template` 来创建它。确保你的拷贝文件时可执行的。`spark-env.sh`：中有有以下变量可以被设置 :
| Environment Variable（环境变量） | Meaning（含义） |
| Environment Variable（环境变量）| Meaning（含义）|
| --- | --- |
| `JAVA_HOME` | Java 的安装路径（如果不在你的默认 `PATH` 下）。 |
| `PYSPARK_PYTHON` | 在 driver 和 worker 中 PySpark 用到的 Python 二进制可执行文件（如何有默认为 `python2.7`，否则为 `python` ）。如果设置了属性 `spark.pyspark.python`，则会优先考虑。 |
......
docs/21.md
浏览文件 @ b89e0d9a
......@@ -40,10 +40,10 @@ history server 可以配置如下：
| 环境变量 | 含义 |
| --- | --- |
| `SPARK_DAEMON_MEMORY` | history server 内存分配（默认值：1g） |
| `SPARK_DAEMON_JAVA_OPTS` | history server JVM选项（默认值：无） |
| `SPARK_DAEMON_MEMORY` | history server 内存分配（默认值：1g）|
| `SPARK_DAEMON_JAVA_OPTS` | history server JVM选项（默认值：无）|
| `SPARK_PUBLIC_DNS` | history server 公共地址。如果没有设置，应用程序历史记录的链接可能会使用服务器的内部地址，导致链接断开（默认值：无）。 |
| `SPARK_HISTORY_OPTS` | `spark.history.*` history server 配置选项（默认值：无） |
| `SPARK_HISTORY_OPTS` | `spark.history.*` history server 配置选项（默认值：无）|
### Spark配置选项
......
docs/24.md
浏览文件 @ b89e0d9a
......@@ -27,7 +27,7 @@ Spark 支持 HTTP SSL 协议。SASL 加密用于块传输服务和 RPC 端。也
SSL 配置是分级组织的。用户可以对所有的通讯协议配置默认的 SSL 设置，除非被特定协议的设置覆盖掉。这样用户可以很容易的为所有的协议提供通用的设置，无需禁用每个单独配置的能力。通用的 SSL 设置在 Spark 配置文件的 `spark.ssl` 命名空间中。下表描述了用于覆盖特定组件默认配置的命名空间:
| Config Namespace（配置空间） | Component（组件） |
| Config Namespace（配置空间）| Component（组件）|
| --- | --- |
| `spark.ssl.fs` | 文件下载客户端 (用于从启用了 HTTPS 的服务器中下载 jars 和 files)。 |
| `spark.ssl.ui` | Spark application Web UI |
......@@ -67,7 +67,7 @@ Spark 严重依赖 network，同时一些环境对使用防火墙有严格的要
### Standalone mode only
| From | To | Default Port（默认端口） | Purpose（目的） | Configuration Setting（配置设置） | Notes（注意） |
| From | To | Default Port（默认端口）| Purpose（目的）| Configuration Setting（配置设置）| Notes（注意）|
| --- | --- | --- | --- | --- | --- |
| Browser | Standalone Master | 8080 | Web UI | `spark.master.ui.port /
SPARK_MASTER_WEBUI_PORT` | Jetty-based. Standalone mode only. |
......@@ -80,7 +80,7 @@ Join cluster | `SPARK_MASTER_PORT` | Set to "0" to choose a port randomly. Stand
### All cluster managers
| From | To | Default Port（默认端口） | Purpose（目的） | Configuration Setting（配置设置） | Notes（注意） |
| From | To | Default Port（默认端口）| Purpose（目的）| Configuration Setting（配置设置）| Notes（注意）|
| --- | --- | --- | --- | --- | --- |
| Browser | Application | 4040 | Web UI | `spark.ui.port` | Jetty-based |
| Browser | History Server | 18080 | Web UI | `spark.history.ui.port` | Jetty-based |
......
docs/30.md
浏览文件 @ b89e0d9a
......@@ -24,34 +24,34 @@ github：[https://github.com/apachecn/spark-doc-zh](https://github.com/apachecn/
| 是否完成 | 完成百分比 | 任务名称 | Markdown | 工期 | 开始时间 | 结束时间 | 贡献者 | 备注 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 否 | 98% | ◢ Apache Spark 2.2.0 官方文档中文版翻译 | | 14 天 | 2017-07-18 | 2017-07-31 | | |
| 是 | 100% |     Overview | index.md | 1 天 | 2017-07-18 | 2017-07-18 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑） | |
| 是 | 100% |     Overview | index.md | 1 天 | 2017-07-18 | 2017-07-18 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑）| |
| 否 | 98% |     ◢ Spark Programming Guide | | | | | | |
| 是 | 100% |         Quick Start | quick-start.md | 1 天 | 2017-07-19 | 2017-07-19 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑） | |
| 是 | 100% |         Spark Programming Guide | rdd-programming-guide.md | 1 天 | 2017-07-21 | 2017-07-21 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑） | |
| 是 | 100% |         Quick Start | quick-start.md | 1 天 | 2017-07-19 | 2017-07-19 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑）| |
| 是 | 100% |         Spark Programming Guide | rdd-programming-guide.md | 1 天 | 2017-07-21 | 2017-07-21 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑）| |
| 是 | 100% |         Spark streaming | streaming-programming-guide.md | 1 天 | 2017-08-03 | 2017-08-03 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑）
[@jiangzhonglian](https://github.com/jiangzhonglian)（片刻）
[@chenyyx](https://github.com/chenyyx)（Joy yx） | |
[@chenyyx](https://github.com/chenyyx)（Joy yx）| |
| 否 | 98% |         Data Frames, Datasets and SQL | sql-programming-guide.md | 1 天 | 2017-07-18 | | [@qinchaofeng](https://github.com/qinchaofeng)（qinchaofeng）
[@chenyyx](https://github.com/chenyyx)（Joy yx）
[@jiangzhonglian](https://github.com/jiangzhonglian)（片刻）
[@wangyangting](https://github.com/wangyangting)（那伊抹微笑） | |
| 是 | 100% |         Structured Streaming | structured-streaming-programming-guide.md | 1 天 | 2017-07-21 | 2017-07-21 | [@chenyyx](https://github.com/chenyyx)（Joy yx） | |
| 是 | 100% |         Mlib(Machine Learning) | ml-guide.md | 1 天 | 2017-07-20 | 2017-07-20 | [@chenyyx](https://github.com/chenyyx)（Joy yx） | |
| 是 | 100% |         GraphX(Graph Processing) | graphx-programming-guide.md | 1 天 | 2017-07-21 | 2017-07-21 | [@jiangzhonglian](https://github.com/jiangzhonglian)（片刻） | |
[@wangyangting](https://github.com/wangyangting)（那伊抹微笑）| |
| 是 | 100% |         Structured Streaming | structured-streaming-programming-guide.md | 1 天 | 2017-07-21 | 2017-07-21 | [@chenyyx](https://github.com/chenyyx)（Joy yx）| |
| 是 | 100% |         Mlib(Machine Learning) | ml-guide.md | 1 天 | 2017-07-20 | 2017-07-20 | [@chenyyx](https://github.com/chenyyx)（Joy yx）| |
| 是 | 100% |         GraphX(Graph Processing) | graphx-programming-guide.md | 1 天 | 2017-07-21 | 2017-07-21 | [@jiangzhonglian](https://github.com/jiangzhonglian)（片刻）| |
| 是 | 100% |         SparkR(R on Spark) | sparkr.md | 1 天 | 2017-07-24 | 2017-07-24 | [@kris37](https://github.com/kris37)（kris37）
[@wangyangting](https://github.com/wangyangting)（那伊抹微笑） | |
[@wangyangting](https://github.com/wangyangting)（那伊抹微笑）| |
| 是 | 100% |     ◢ Deploying | | | | | | |
| 是 | 100% |         Overview | cluster-overview.md | 1 天 | 2017-07-20 | 2017-07-20 | [@huangtianan](https://github.com/huangtianan)（huangtianan） | |
| 是 | 100% |         Submitting Applications | submitting-applications.md | 1 天 | 2017-07-20 | 2017-07-20 | [@sehriff](https://github.com/sehriff)（sehriff） | |
| 是 | 100% |         Spark Standalone | spark-standalone.md | 1 天 | 2017-07-19 | 2017-07-19 | [@chenyyx](https://github.com/chenyyx)（Joy yx） | |
| 是 | 100% |         Mesos | running-on-mesos.md | 1 天 | 2017-07-19 | 2017-07-19 | [@chenyyx](https://github.com/chenyyx)（Joy yx） | |
| 是 | 100% |         YARN | running-on-yarn.md | 1 天 | 2017-07-19 | 2017-07-19 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑） | |
| 是 | 100% |         Overview | cluster-overview.md | 1 天 | 2017-07-20 | 2017-07-20 | [@huangtianan](https://github.com/huangtianan)（huangtianan）| |
| 是 | 100% |         Submitting Applications | submitting-applications.md | 1 天 | 2017-07-20 | 2017-07-20 | [@sehriff](https://github.com/sehriff)（sehriff）| |
| 是 | 100% |         Spark Standalone | spark-standalone.md | 1 天 | 2017-07-19 | 2017-07-19 | [@chenyyx](https://github.com/chenyyx)（Joy yx）| |
| 是 | 100% |         Mesos | running-on-mesos.md | 1 天 | 2017-07-19 | 2017-07-19 | [@chenyyx](https://github.com/chenyyx)（Joy yx）| |
| 是 | 100% |         YARN | running-on-yarn.md | 1 天 | 2017-07-19 | 2017-07-19 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑）| |
| 是 | 100% |     ◢ More | | | | | | |
| 是 | 100% |         Configuration | configuration.md | 1 天 | 2017-07-25 | 2017-07-25 | [@chenyyx](https://github.com/chenyyx)（Joy yx）
[@jiangzhonglian](https://github.com/jiangzhonglian)（片刻） | |
| 是 | 100% |         Monitoring | monitoring.md | 1 天 | 2017-07-19 | 2017-07-19 | [@jiangzhonglian](https://github.com/jiangzhonglian)（片刻） | |
| 是 | 100% |         Tuning Guide | tuning.md | 1 天 | 2017-07-20 | 2017-07-20 | [@jiangzhonglian](https://github.com/jiangzhonglian)（片刻） | |
| 是 | 100% |         Job Scheduling | job-scheduling.md | 1 天 | 2017-07-27 | 2017-07-27 | [@stealthsMrs](https://github.com/stealthsMrs)（stealthsMrs） | |
| 是 | 100% |         Security | security.md | 1 天 | 2017-07-19 | 2017-07-19 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑） | |
| 是 | 100% |         Hardware Provisioning | hardware-provisioning.md | 1 天 | 2017-07-24 | 2017-07-24 | [@huangtianan](https://github.com/huangtianan)（huangtianan） | |
| 是 | 100% |         Building Spark | building-spark.md | 1 天 | 2017-07-20 | 2017-07-20 | [@chenyyx](https://github.com/chenyyx)（Joy yx） | |
\ No newline at end of file
[@jiangzhonglian](https://github.com/jiangzhonglian)（片刻）| |
| 是 | 100% |         Monitoring | monitoring.md | 1 天 | 2017-07-19 | 2017-07-19 | [@jiangzhonglian](https://github.com/jiangzhonglian)（片刻）| |
| 是 | 100% |         Tuning Guide | tuning.md | 1 天 | 2017-07-20 | 2017-07-20 | [@jiangzhonglian](https://github.com/jiangzhonglian)（片刻）| |
| 是 | 100% |         Job Scheduling | job-scheduling.md | 1 天 | 2017-07-27 | 2017-07-27 | [@stealthsMrs](https://github.com/stealthsMrs)（stealthsMrs）| |
| 是 | 100% |         Security | security.md | 1 天 | 2017-07-19 | 2017-07-19 | [@wangyangting](https://github.com/wangyangting)（那伊抹微笑）| |
| 是 | 100% |         Hardware Provisioning | hardware-provisioning.md | 1 天 | 2017-07-24 | 2017-07-24 | [@huangtianan](https://github.com/huangtianan)（huangtianan）| |
| 是 | 100% |         Building Spark | building-spark.md | 1 天 | 2017-07-20 | 2017-07-20 | [@chenyyx](https://github.com/chenyyx)（Joy yx）| |
\ No newline at end of file
docs/4.md
浏览文件 @ b89e0d9a
......@@ -672,7 +672,7 @@ We could also use `counts.sortByKey()`, for example, to sort the pairs alphabeti
下表列出了一些 Spark 常用的 transformations（转换）。详情请参考 RDD API 文档 ([Scala](api/scala/index.html#org.apache.spark.rdd.RDD)，[Java](api/java/index.html?org/apache/spark/api/java/JavaRDD.html)，[Python](api/python/pyspark.html#pyspark.RDD)，[R](api/R/index.html)) 和 pair RDD 函数文档 ([Scala](api/scala/index.html#org.apache.spark.rdd.PairRDDFunctions)，[Java](api/java/index.html?org/apache/spark/api/java/JavaPairRDD.html)).
| Transformation（转换） | Meaning（含义） |
| Transformation（转换）| Meaning（含义）|
| --- | --- |
| **map**(_func_) | 返回一个新的 distributed dataset（分布式数据集），它由每个 source（数据源）中的元素应用一个函数 _func_ 来生成。
| **filter**(_func_) | 返回一个新的 distributed dataset（分布式数据集），它由每个 source（数据源）中应用一个函数 _func_ 且返回值为 true 的元素来生成。
......@@ -703,7 +703,7 @@ We could also use `counts.sortByKey()`, for example, to sort the pairs alphabeti
和 pair RDD 函数文档 ([Scala](api/scala/index.html#org.apache.spark.rdd.PairRDDFunctions)，[Java](api/java/index.html?org/apache/spark/api/java/JavaPairRDD.html)).
| Action（动作） | Meaning（含义） |
| Action（动作）| Meaning（含义）|
| --- | --- |
| **reduce**(_func_) | 使用函数 _func_ 聚合 dataset 中的元素，这个函数 _func_ 输入为两个元素，返回为一个元素。这个函数应该是可交换（commutative ）和关联（associative）的，这样才能保证它可以被并行地正确计算。
| **collect**() | 在 driver 程序中，以一个 array 数组的形式返回 dataset 的所有元素。这在过滤器（filter）或其他操作（other operation）之后返回足够小（sufficiently small）的数据子集通常是有用的。
......@@ -760,7 +760,7 @@ RDD 可以使用 `persist()` 方法或 `cache()` 方法进行持久化。数据
另外，每个持久化的 RDD 可以使用不同的 _storage level_ 存储级别进行缓存，例如，持久化到磁盘、已序列化的 Java 对象形式持久化到内存（可以节省空间）、跨节点间复制、以 off-heap 的方式存储在 Tachyon。这些存储级别通过传递一个 `StorageLevel` 对象 ([Scala](api/scala/index.html#org.apache.spark.storage.StorageLevel)，[Java](api/java/index.html?org/apache/spark/storage/StorageLevel.html)，[Python](api/python/pyspark.html#pyspark.StorageLevel)) 给 `persist()` 方法进行设置。`cache()` 方法是使用默认存储级别的快捷设置方法，默认的存储级别是 `StorageLevel.MEMORY_ONLY`（将反序列化的对象存储到内存中）。详细的存储级别介绍如下:
| Storage Level（存储级别） | Meaning（含义） |
| Storage Level（存储级别）| Meaning（含义）|
| --- | --- |
| MEMORY_ONLY | 将 RDD 以反序列化的 Java 对象的形式存储在 JVM 中。如果内存空间不够，部分数据分区将不再缓存，在每次需要用到这些数据时重新进行计算。这是默认的级别。
| MEMORY_AND_DISK | 将 RDD 以反序列化的 Java 对象的形式存储在 JVM 中。如果内存空间不够，将未缓存的数据分区存储到磁盘，在需要使用这些分区时从磁盘读取。
......@@ -794,7 +794,7 @@ Spark 会自动监视每个节点上的缓存使用情况，并使用 least-rece
# 共享变量
通常情况下，一个传递给 Spark 操作（例如 `map` 或 `reduce`）的函数 func 是在远程的集群节点上执行的。该函数 func 在多个节点执行过程中使用的变量，是同一个变量的多个副本。这些变量的以副本的方式拷贝到每个机器上，并且各个远程机器上变量的更新并不会传播回 driver program（驱动程序）。通用且支持 read-write（读-写） 的共享变量在任务间是不能胜任的。所以，Spark 提供了两种特定类型的共享变量：broadcast variables（广播变量）和 accumulators（累加器）。
通常情况下，一个传递给 Spark 操作（例如 `map` 或 `reduce`）的函数 func 是在远程的集群节点上执行的。该函数 func 在多个节点执行过程中使用的变量，是同一个变量的多个副本。这些变量的以副本的方式拷贝到每个机器上，并且各个远程机器上变量的更新并不会传播回 driver program（驱动程序）。通用且支持 read-write（读-写）的共享变量在任务间是不能胜任的。所以，Spark 提供了两种特定类型的共享变量：broadcast variables（广播变量）和 accumulators（累加器）。
## 广播变量
......
docs/6.md
浏览文件 @ b89e0d9a
......@@ -82,7 +82,7 @@ val pairs = words.map(word => (word, 1))
val wordCounts = pairs.reduceByKey(_ + _)
// 在控制台打印出在这个离散流（DStream）中生成的每个 RDD 的前十个元素
// 注意：必需要触发 action（很多初学者会忘记触发 action 操作，导致报错：No output operations registered, so nothing to execute）
// 注意：必需要触发 action（很多初学者会忘记触发 action 操作，导致报错：No output operations registered, so nothing to execute）
wordCounts.print()
```
......@@ -318,7 +318,7 @@ libraryDependencies += "org.apache.spark" % "spark-streaming_2.11" % "2.2.0"
针对从 Spark Streaming Core API 中不存在的数据源中获取数据，如 Kafka， Flume，Kinesis，你必须添加相应的坐标 `spark-streaming-xyz_2.11` 到依赖中。例如，有一些常见的依赖如下.
| Source（数据源） | Artifact（坐标） |
| Source（数据源）| Artifact（坐标）|
| --- | --- |
| Kafka | spark-streaming-kafka-0-8_2.11 |
| Flume | spark-streaming-flume_2.11 |
......@@ -466,7 +466,7 @@ Spark Streaming 提供了两种内置的 streaming source（流的数据源）.
Spark Streaming 将监控`dataDirectory` 目录并且该目录中任何新建的文件 (写在嵌套目录中的文件是不支持的)。注意
* 文件必须具有相同的数据格式.
* 文件必须被创建在 `dataDirectory` 目录中，通过 atomically（院子的） _moving（移动）_ 或 _renaming（重命名）_ 它们到数据目录.
* 文件必须被创建在 `dataDirectory` 目录中，通过 atomically（院子的）_moving（移动）_ 或 _renaming（重命名）_ 它们到数据目录.
* 一旦移动，这些文件必须不能再更改，因此如果文件被连续地追加，新的数据将不会被读取.
对于简单的文本文件，还有一个更加简单的方法 `streamingContext.textFileStream(dataDirectory)`。并且文件流（file streams）不需要运行一个接收器（receiver），因此，不需要分配内核（core）。
......@@ -518,7 +518,7 @@ Input DStreams 也可以从自定义数据源中创建。如果您想这样做
与RDD类似，类似，transformation 允许修改来自 input DStream 的数据。DStreams 支持标准的 Spark RDD 上可用的许多转换。一些常见的如下.
| Transformation（转换） | Meaning（含义） |
| Transformation（转换）| Meaning（含义）|
| --- | --- |
| **map**(_func_) | 利用函数 _func_ 处理原 DStream 的每个元素，返回一个新的 DStream。
| **flatMap**(_func_) | 与 map 相似，但是每个输入项可用被映射为 0 个或者多个输出项。。
......@@ -542,7 +542,7 @@ Input DStreams 也可以从自定义数据源中创建。如果您想这样做
该 `updateStateByKey` 操作允许您维护任意状态，同时不断更新新信息。你需要通过两步来使用它.
1. 定义 state - state 可以是任何的数据类型.
2. 定义 state update function（状态更新函数） - 使用函数指定如何使用先前状态来更新状态，并从输入流中指定新值.
2. 定义 state update function（状态更新函数）- 使用函数指定如何使用先前状态来更新状态，并从输入流中指定新值.
在每个 batch 中，Spark 会使用状态更新函数为所有已有的 key 更新状态，不管在 batch 中是否含有新的数据。如果这个更新函数返回一个 none，这个 key-value pair 也会被消除.
......@@ -662,7 +662,7 @@ windowedWordCounts = pairs.reduceByKeyAndWindow(lambda x, y: x + y, lambda x, y:
一些常用的窗口操作如下所示，这些操作都需要用到上文提到的两个参数 - _windowLength（窗口长度）_ 和 _slideInterval（滑动的时间间隔）_.
| Transformation（转换） | Meaning（含义） |
| Transformation（转换）| Meaning（含义）|
| --- | --- |
| **window**(_windowLength_, _slideInterval_) | 返回一个新的 DStream，它是基于 source DStream 的窗口 batch 进行计算的。
| **countByWindow**(_windowLength_, _slideInterval_) | 返回 stream（流）中滑动窗口元素的数 |
......@@ -1353,7 +1353,7 @@ web UI 中的以下两个 metrics（指标）特别重要:
* _Processing Time（处理时间）_ - 处理每 batch（批）数据的时间 .
* _Scheduling Delay（调度延迟）_ - batch（批处理）在 queue（队列）中等待处理 previous batches（以前批次）完成的时间.
如果 batch processing time（批处理时间）始终 more than（超过） batch interval（批间隔） and/or queueing delay（排队延迟）不断增加，表示系统是无法快速 process the batches（处理批次），并且正在 falling behind（落后）。在这种情况下，请考虑 [reducing（减少）](#reducing-the-batch-processing-times) batch processing time（批处理时间）.
如果 batch processing time（批处理时间）始终 more than（超过）batch interval（批间隔）and/or queueing delay（排队延迟）不断增加，表示系统是无法快速 process the batches（处理批次），并且正在 falling behind（落后）。在这种情况下，请考虑 [reducing（减少）](#reducing-the-batch-processing-times) batch processing time（批处理时间）.
Spark Streaming 程序的进展也可以使用 [StreamingListener](api/scala/index.html#org.apache.spark.streaming.scheduler.StreamingListener) 接口，这允许您获得 receiver status（接收器状态）和 processing times（处理时间）.请注意，这是一个开发人员 API 并且将来可能会改善（即，更多的信息报告）.
......@@ -1401,9 +1401,9 @@ unifiedStream = streamingContext.union(*kafkaStreams)
unifiedStream.pprint()
```
应考虑的另一个参数是 receiver’s block interval（接收器的块间隔），这由[configuration parameter（配置参数）](configuration.html#spark-streaming) 的 `spark.streaming.blockInterval` 决定.对于大多数 receivers（接收器），接收到的数据 coalesced（合并）在一起存储在 Spark 内存之前的 blocks of data（数据块）.每个 batch（批次）中的 blocks（块）数确定将用于处理接收到的数据以 map-like（类似与 map 形式的） transformation（转换）的 task（任务）的数量.每个 receiver（接收器）每 batch（批次）的任务数量将是大约（ batch interval（批间隔）/ block interval（块间隔））.例如，200 ms的 block interval（块间隔）每 2 秒 batches（批次）创建 10 个 tasks（任务）.如果 tasks（任务）数量太少（即少于每个机器的内核数量），那么它将无效，因为所有可用的内核都不会被使用处理数据.要增加 given batch interval（给定批间隔）的 tasks（任务）数量，请减少 block interval（块间​​隔）.但是，推荐的 block interval（块间隔）最小值约为 50ms，低于此任务启动开销可能是一个问题.
应考虑的另一个参数是 receiver’s block interval（接收器的块间隔），这由[configuration parameter（配置参数）](configuration.html#spark-streaming) 的 `spark.streaming.blockInterval` 决定.对于大多数 receivers（接收器），接收到的数据 coalesced（合并）在一起存储在 Spark 内存之前的 blocks of data（数据块）.每个 batch（批次）中的 blocks（块）数确定将用于处理接收到的数据以 map-like（类似与 map 形式的）transformation（转换）的 task（任务）的数量.每个 receiver（接收器）每 batch（批次）的任务数量将是大约（ batch interval（批间隔）/ block interval（块间隔））.例如，200 ms的 block interval（块间隔）每 2 秒 batches（批次）创建 10 个 tasks（任务）.如果 tasks（任务）数量太少（即少于每个机器的内核数量），那么它将无效，因为所有可用的内核都不会被使用处理数据.要增加 given batch interval（给定批间隔）的 tasks（任务）数量，请减少 block interval（块间​​隔）.但是，推荐的 block interval（块间隔）最小值约为 50ms，低于此任务启动开销可能是一个问题.
使用 multiple input streams（多个输入流）/ receivers（接收器）接收数据的替代方法是明确 repartition（重新分配） input data stream（输入数据流）（使用 `inputStream.repartition(&lt;number of partitions&gt;)` ）。这会在 further processing（进一步处理）之前将 received batches of data（收到的批次数据） distributes（分发）到集群中指定数量的计算机.
使用 multiple input streams（多个输入流）/ receivers（接收器）接收数据的替代方法是明确 repartition（重新分配）input data stream（输入数据流）（使用 `inputStream.repartition(&lt;number of partitions&gt;)` ）。这会在 further processing（进一步处理）之前将 received batches of data（收到的批次数据）distributes（分发）到集群中指定数量的计算机.
### Level of Parallelism in Data Processing（数据处理中的并行度水平）
......@@ -1516,7 +1516,7 @@ streaming systems（流系统）的语义通常是通过系统可以处理每个
1. _At most once（最多一次）_：每个 record（记录）将被处理一次或根本不处理.
2. _At least once（至少一次）_：每个 record（记录）将被处理一次或多次.这比_at-most once_，因为它确保没有数据将丢失.但可能有重复.
3. _Exactly once（有且仅一次）_：每个 record（记录） 将被精确处理一次 - 没有数据丢失，数据不会被多次处理.这显然是三者的最强保证.
3. _Exactly once（有且仅一次）_：每个 record（记录）将被精确处理一次 - 没有数据丢失，数据不会被多次处理.这显然是三者的最强保证.
## Basic Semantics（基本语义）
......@@ -1557,10 +1557,10 @@ streaming systems（流系统）的语义通常是通过系统可以处理每个
下表总结了失败的语义:
| Deployment Scenario（部署场景） | Worker Failure（Worker 故障） | Driver Failure（Driver 故障） |
| Deployment Scenario（部署场景）| Worker Failure（Worker 故障）| Driver Failure（Driver 故障）|
| --- | --- | --- |
| _Spark 1.1 或更早版本，_ 或者 <br> _Spark 1.2 或者没有 write ahead logs 的更高的版本_ | Buffered data lost with unreliable receivers（unreliable receivers 的缓冲数据丢失） <br> Zero data loss with reliable receivers（reliable receivers 的零数据丢失） <br> At-least once semantics（至少一次性语义） | Buffered data lost with unreliable receivers（unreliable receivers 的缓冲数据丢失） <br> Past data lost with all receivers（所有的 receivers 的过去的数据丢失） <br> Undefined semantics（未定义语义） |
| _Spark 1.2 或者带有 write ahead logs 的更高版本_ | Zero data loss with reliable receivers（reliable receivers 的零数据丢失） <br> At-least once semantics（至少一次性语义） | Zero data loss with reliable receivers and files（reliable receivers 和 files 的零数据丢失） <br> At-least once semantics（至少一次性语义） |
| _Spark 1.1 或更早版本，_ 或者 <br> _Spark 1.2 或者没有 write ahead logs 的更高的版本_ | Buffered data lost with unreliable receivers（unreliable receivers 的缓冲数据丢失）<br> Zero data loss with reliable receivers（reliable receivers 的零数据丢失）<br> At-least once semantics（至少一次性语义）| Buffered data lost with unreliable receivers（unreliable receivers 的缓冲数据丢失）<br> Past data lost with all receivers（所有的 receivers 的过去的数据丢失）<br> Undefined semantics（未定义语义）|
| _Spark 1.2 或者带有 write ahead logs 的更高版本_ | Zero data loss with reliable receivers（reliable receivers 的零数据丢失）<br> At-least once semantics（至少一次性语义）| Zero data loss with reliable receivers and files（reliable receivers 和 files 的零数据丢失）<br> At-least once semantics（至少一次性语义）|
| | | |
### With Kafka Direct API（使用 Kafka Direct API）
......@@ -1569,7 +1569,7 @@ streaming systems（流系统）的语义通常是通过系统可以处理每个
## Semantics of output operations（输出操作的语义）
Output operations（输出操作）（如 `foreachRDD` ）具有 _at-least once_ 语义，也就是说，transformed data（变换后的数据）可能会不止一次写入 external entity（外部实体）在一个 worker 故障事件中.虽然这是可以接受的使用 `saveAs***Files`操作（因为文件将被相同的数据简单地覆盖） 保存到文件系统，可能需要额外的努力来实现 exactly-once（一次且仅一次）语义.有两种方法.
Output operations（输出操作）（如 `foreachRDD` ）具有 _at-least once_ 语义，也就是说，transformed data（变换后的数据）可能会不止一次写入 external entity（外部实体）在一个 worker 故障事件中.虽然这是可以接受的使用 `saveAs***Files`操作（因为文件将被相同的数据简单地覆盖）保存到文件系统，可能需要额外的努力来实现 exactly-once（一次且仅一次）语义.有两种方法.
* _Idempotent updates（幂等更新）_：多次尝试总是写入相同的数据.例如，`saveAs***Files` 总是将相同的数据写入生成的文件.
......
docs/7.md
浏览文件 @ b89e0d9a
......@@ -1490,7 +1490,7 @@ Save operations（保存操作）可以选择使用 `SaveMode`，它指定如何
### Saving to Persistent Tables（保存到持久表）
`DataFrames` 也可以使用 `saveAsTable` 命令作为 persistent tables（持久表）保存到 Hive metastore 中。请注意，existing Hive deployment（现有的 Hive 部署）不需要使用此功能。Spark 将为您创建默认的 local Hive metastore（本地 Hive metastore）（使用 Derby ）。与 `createOrReplaceTempView` 命令不同，`saveAsTable` 将 materialize（实现） DataFrame 的内容，并创建一个指向 Hive metastore 中数据的指针。即使您的 Spark 程序重新启动，Persistent tables（持久性表）仍然存在，因为您保持与同一个 metastore 的连接。可以通过使用表的名称在 `SparkSession` 上调用 `table` 方法来创建 persistent tabl（持久表）的 DataFrame .
`DataFrames` 也可以使用 `saveAsTable` 命令作为 persistent tables（持久表）保存到 Hive metastore 中。请注意，existing Hive deployment（现有的 Hive 部署）不需要使用此功能。Spark 将为您创建默认的 local Hive metastore（本地 Hive metastore）（使用 Derby ）。与 `createOrReplaceTempView` 命令不同，`saveAsTable` 将 materialize（实现）DataFrame 的内容，并创建一个指向 Hive metastore 中数据的指针。即使您的 Spark 程序重新启动，Persistent tables（持久性表）仍然存在，因为您保持与同一个 metastore 的连接。可以通过使用表的名称在 `SparkSession` 上调用 `table` 方法来创建 persistent tabl（持久表）的 DataFrame .
对于 file-based（基于文件）的 data source（数据源），例如 text，parquet，json等，您可以通过 `path` 选项指定 custom table path（自定义表路径），例如 `df.write.option("path", "/some/path").saveAsTable("t")`。当表被 dropped（删除）时，custom table path（自定义表路径）将不会被删除，并且表数据仍然存在。如果未指定自定义表路径，Spark 将把数据写入 warehouse directory（仓库目录）下的默认表路径。当表被删除时，默认的表路径也将被删除.
......@@ -1499,7 +1499,7 @@ Save operations（保存操作）可以选择使用 `SaveMode`，它指定如何
* 由于 metastore 只能返回查询的必要 partitions（分区），因此不再需要将第一个查询上的所有 partitions discovering 到表中.
* Hive DDLs 如 `ALTER TABLE PARTITION ... SET LOCATION` 现在可用于使用 Datasource API 创建的表.
请注意，创建 external datasource tables（外部数据源表）（带有 `path` 选项）的表时，默认情况下不会收集 partition information（分区信息）。要 sync（同步） metastore 中的分区信息，可以调用 `MSCK REPAIR TABLE` .
请注意，创建 external datasource tables（外部数据源表）（带有 `path` 选项）的表时，默认情况下不会收集 partition information（分区信息）。要 sync（同步）metastore 中的分区信息，可以调用 `MSCK REPAIR TABLE` .
### Bucketing, Sorting and Partitioning（分桶，排序和分区）
......@@ -1780,7 +1780,7 @@ root
|-- country: string (nullable = true)
```
请注意，会自动 inferred（推断） partitioning columns（分区列）的 data types（数据类型）.目前，支持 numeric data types（数字数据类型）和 string type（字符串类型）.有些用户可能不想自动推断 partitioning columns（分区列）的数据类型.对于这些用例，automatic type inference（自动类型推断）可以由 `spark.sql.sources.partitionColumnTypeInference.enabled` 配置，默认为 `true` .当禁用 type inference（类型推断）时，string type（字符串类型）将用于 partitioning columns（分区列）.
请注意，会自动 inferred（推断）partitioning columns（分区列）的 data types（数据类型）.目前，支持 numeric data types（数字数据类型）和 string type（字符串类型）.有些用户可能不想自动推断 partitioning columns（分区列）的数据类型.对于这些用例，automatic type inference（自动类型推断）可以由 `spark.sql.sources.partitionColumnTypeInference.enabled` 配置，默认为 `true` .当禁用 type inference（类型推断）时，string type（字符串类型）将用于 partitioning columns（分区列）.
从 Spark 1.6.0 开始，默认情况下，partition discovery（分区发现）只能找到给定路径下的 partitions（分区）.对于上述示例，如果用户将 `path/to/table/gender=male` 传递给 `SparkSession.read.parquet` 或 `SparkSession.read.load`，则 `gender` 将不被视为 partitioning column（分区列）.如果用户需要指定 partition discovery（分区发现）应该开始的基本路径，则可以在数据源选项中设置 `basePath`.例如，当 `path/to/table/gender=male` 是数据的路径并且用户将 `basePath` 设置为 `path/to/table/`，`gender` 将是一个 partitioning column（分区列）.
......@@ -1790,8 +1790,8 @@ root
由于 schema merging（模式合并）是一个 expensive operation（相对昂贵的操作），并且在大多数情况下不是必需的，所以默认情况下从 1.5.0 开始。你可以按照如下的方式启用它:
1. 读取 Parquet 文件时，将 data source option（数据源选项） `mergeSchema` 设置为 `true`（如下面的例子所示），或
2. 将 global SQL option（全局 SQL 选项） `spark.sql.parquet.mergeSchema` 设置为 `true` .
1. 读取 Parquet 文件时，将 data source option（数据源选项）`mergeSchema` 设置为 `true`（如下面的例子所示），或
2. 将 global SQL option（全局 SQL 选项）`spark.sql.parquet.mergeSchema` 设置为 `true` .
```
// This is used to implicitly convert an RDD to a DataFrame.
......@@ -1990,15 +1990,15 @@ REFRESH TABLE my_table;
可以使用 `SparkSession` 上的 `setConf` 方法或使用 SQL 运行 `SET key = value` 命令来完成 Parquet 的配置.
| Property Name（参数名称） | Default（默认） | Meaning（含义） |
| Property Name（参数名称）| Default（默认）| Meaning（含义）|
| --- | --- | --- |
| `spark.sql.parquet.binaryAsString` | false | 一些其他 Parquet-producing systems（Parquet 生产系统），特别是 Impala，Hive 和旧版本的 Spark SQL，在 writing out（写出） Parquet schema 时，不区分 binary data（二进制数据）和 strings（字符串）。该 flag 告诉 Spark SQL 将 binary data（二进制数据）解释为 string（字符串）以提供与这些系统的兼容性。
| `spark.sql.parquet.binaryAsString` | false | 一些其他 Parquet-producing systems（Parquet 生产系统），特别是 Impala，Hive 和旧版本的 Spark SQL，在 writing out（写出）Parquet schema 时，不区分 binary data（二进制数据）和 strings（字符串）。该 flag 告诉 Spark SQL 将 binary data（二进制数据）解释为 string（字符串）以提供与这些系统的兼容性。
| `spark.sql.parquet.int96AsTimestamp` | true | 一些 Parquet-producing systems，特别是 Impala 和 Hive，将 Timestamp 存入INT96。该 flag 告诉 Spark SQL 将 INT96 数据解析为 timestamp 以提供与这些系统的兼容性。
| `spark.sql.parquet.cacheMetadata` | true | 打开 Parquet schema metadata 的缓存。可以加快查询静态数据。
| `spark.sql.parquet.compression.codec` | snappy | 在编写 Parquet 文件时设置 compression codec（压缩编解码器）的使用。可接受的值包括：uncompressed，snappy，gzip，lzo。
| `spark.sql.parquet.filterPushdown` | true | 设置为 true 时启用 Parquet filter push-down optimization。
| `spark.sql.hive.convertMetastoreParquet` | true | 当设置为 false 时，Spark SQL 将使用 Hive SerDe 作为 parquet tables，而不是内置的支持。
| `spark.sql.parquet.mergeSchema` | false | 当为 true 时，Parquet data source（Parquet 数据源） merges（合并）从所有 data files（数据文件）收集的 schemas，否则如果没有可用的 summary file，则从 summary file 或 random data file 中挑选 schema。
| `spark.sql.parquet.mergeSchema` | false | 当为 true 时，Parquet data source（Parquet 数据源）merges（合并）从所有 data files（数据文件）收集的 schemas，否则如果没有可用的 summary file，则从 summary file 或 random data file 中挑选 schema。
| `spark.sql.optimizer.metadataOnly` | true | 如果为 true，则启用使用表的 metadata 的 metadata-only query optimization 来生成 partition columns（分区列）而不是 table scans（表扫描）。当 scanned（扫描）的所有 columns（列）都是 partition columns（分区列）并且 query（查询）具有满足 distinct semantics（不同语义）的 aggregate operator（聚合运算符）时，它将适用。
## JSON Datasets（JSON 数据集）
......@@ -2690,7 +2690,7 @@ Spark SQL 可以通过调用 `spark.catalog.cacheTable("tableName")` 或 `dataFr
| --- | --- | --- |
| `spark.sql.files.maxPartitionBytes` | 134217728 (128 MB) | 在读取文件时，将单个分区打包的最大字节数。 |
| `spark.sql.files.openCostInBytes` | 4194304 (4 MB) | 按照字节数来衡量的打开文件的估计费用可以在同一时间进行扫描。将多个文件放入分区时使用。最好过度估计，那么具有小文件的分区将比具有较大文件的分区（首先计划的）更快。 |
| `spark.sql.broadcastTimeout` | 300 | 广播连接中的广播等待时间超时（秒） |
| `spark.sql.broadcastTimeout` | 300 | 广播连接中的广播等待时间超时（秒）|
| `spark.sql.autoBroadcastJoinThreshold` | 10485760 (10 MB) | 配置执行连接时将广播给所有工作节点的表的最大大小（以字节为单位）。通过将此值设置为-1可以禁用广播。请注意，目前的统计信息仅支持 Hive Metastore 表，其中已运行命令 `ANALYZE TABLE &lt;tableName&gt; COMPUTE STATISTICS noscan`。 |
| `spark.sql.shuffle.partitions` | 200 | Configures the number of partitions to use when shuffling data for joins or aggregations。
......@@ -2886,7 +2886,7 @@ 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
......@@ -3058,7 +3058,7 @@ import org.apache.spark.sql.types._
<small>Find full example code at "examples/src/main/scala/org/apache/spark/examples/sql/SparkSQLExample.scala" in the Spark repo.</small>
| Data type（数据类型） | Scala 中的 Value 类型 | 访问或创建数据类型的 API |
| Data type（数据类型）| Scala 中的 Value 类型 | 访问或创建数据类型的 API |
| --- | --- | --- |
| **ByteType** | Byte | ByteType |
| **ShortType** | Short | ShortType |
......
docs/paper.md
浏览文件 @ b89e0d9a
......@@ -121,16 +121,16 @@ errors.filter(_.contains("HDFS"))
为了理解作为分布式内存抽象的 RDDs 的好处，我们在表一种用 RDDs 和分布式共享内存系统（Distributed shared memory 即 DSM）进行了对比。在所有的 DSM 系统中，应用从一个全局的地址空间中的任意位置中读写数据。需要注意的是，依据这个定义，我们所说的 DSM 系统不仅包含了传统的共享内存系统，还包含了对共享状态的细粒度写操作的其他系统（比如 Piccolo），以及分布式数据库。DSM 是一个很普遍的抽象，但是这个普遍性使得它在商用集群中实现高效且容错的系统比较困难.
| Aspect（概念） | RDDs | Distribute shared memory（分布式共享内存） |
| Aspect（概念）| RDDs | Distribute shared memory（分布式共享内存）|
| --- | --- | --- |
| Reads | 粗粒度或者细粒度 | 细粒度 |
| Writes | 粗粒度 | 细粒度 |
| 数据一致性 | 不重要的（因为RDD是不可变的） | 取决于app 或者 runtime |
| 数据一致性 | 不重要的（因为RDD是不可变的）| 取决于app 或者 runtime |
| 容错 | 利用lineage达到细粒度且低延迟的容错 | 需要应用checkpoints（就是需要写磁盘）
并且需要程序回滚 |
| 计算慢的任务 | 可以利用备份的任务来解决 | 很难做到 |
| 计算数据的位置 | 自动的机遇数据本地性 | 取决于app（runtime是以透明为目标的） |
| 内存不足时的行为 | 和已经存在的数据流处理系统一样，写磁盘 | 非常糟糕的性能（需要内存的交换？） |
| 计算数据的位置 | 自动的机遇数据本地性 | 取决于app（runtime是以透明为目标的）|
| 内存不足时的行为 | 和已经存在的数据流处理系统一样，写磁盘 | 非常糟糕的性能（需要内存的交换？）|
表一：RDDs 和 Distributed shared memory 对比
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或