【Spark】Spark Quick Start（快速入门翻译）

本文主要是翻译Spark官网Quick Start。只能保证大概意思，尽量保证细节。英文水平有限，如果有错误的地方请指正，轻喷

目录导航在右上角，感谢两个大佬（孤傲苍狼 JavaScript自动生成博文目录导航和 juejiang 为博客园添加目录的配置总结）提供的帮助。这篇文章还有个问题 scala/python/java 使用 Spark 的介绍不能像官网那样可以通过点击导航来显示不同的内容，很影响阅读。我在想办法改进

Quick Start

这个指南提供了使用Spark的快速介绍。我们会首先介绍Spark 交互式编程(使用Python或者Scala)的 API，然后展示如何用Java、Scala 和 Python来编写应用程序。

为了使用这个指南，您需要先从 Spark 网页下载打包发布的Spark安装包。由于我们将不会（在指南中）使用HDFS，您可以下载任意版本的Hadoop安装包。

需要注意的是，Spark2.0 之前， Spark的主要编程接口是弹性分布式数据集（Resilient Distributed Dataset (RDD)）。Spark2.0 之后， RDD 被 Dataset 取代，Dataset 和 RDD 一样是强类型，但是在底层进行了更多的优化。Spark2.0 之后仍然支持 RDD 接口，并且您可以从RDD编程指南中获取更详细的参考。当然，我们强烈建议您选择使用Dataset，因为它的性能比RDD更好。查看 SQL编程指南以得到更多关于Dataset的信息。

使用 Spark Shell 交互式编程

基本操作

Spark Shell 提供了一个简单的方式去学习 API，同时也提供了一个强大的交互式数据分析工具。它可以基于 Scala（一种在java 虚拟机上运行并因此可以很好地使用已有的java库的编程语言）或 Python 使用。在 Spark 目录下运行以下内容来开始（Sprk Shell）：

Scala 版

./bin/pyspark

Python 版

./bin/pyspark

如果你当前环境使用pip下载了 PySpark，可以使用如下下方式调用

pyspark

Spark 主要的抽象是一个被叫做 Dataset 的分布式集合。 Dataset 可以通过 Hadoop InputFormat（比如HDFS文件）或者转换其他 Dataset 中创建。让我们通过 Spark 源目录下的 README 文件内容创建一个新的 Dataset：

Scala 版

scala> val textFile = spark.read.textFile("README.md")
textFile: org.apache.spark.sql.Dataset[String] = [value: string]

Python 版

>>> textFile = spark.read.text("README.md")

你可以直接从Dataset中，通过调用一些操作或者转化Dataset以获得一个新的Dataset来获取它的值。请阅读 API 文档（Scala / Python）以获取更多细节

Scala 版

scala> textFile.count() // 该Dataset中的成员数量
res0: Long = 126 //  由于README.md 会随着时间的推移不断改变，所以结果可能会有所不同， 其他输出也有类似情况

scala> textFile.first() // 该Dataset的第一个成员
res1: String = # Apache Spark

Python 版

>>> textFile.count()  # 该DataFrame中的行数
126

>>> textFile.first()  # 该DataFrame的第一行
Row(value=u'# Apache Spark')

现在让我们使用该Dataset来转换成一个新的Dataset。我们调用 filter 来返回一个新的Dataset，其中包含这个文件内容的子集。

Scala 版

scala> val linesWithSpark = textFile.filter(line => line.contains("Spark"))
linesWithSpark: org.apache.spark.sql.Dataset[String] = [value: string]

Python 版

>>> linesWithSpark = textFile.filter(textFile.value.contains("Spark"))

我们可以将数据集转换和数据集操作串接在一起

Scala 版

scala> textFile.filter(line => line.contains("Spark")).count() // How many lines contain "Spark"?
res3: Long = 15

Python 版

>>> textFile.filter(textFile.value.contains("Spark")).count()  # How many lines contain "Spark"?
15

更多关于Dataset的操作

Dataset操作和转换可以用来做更复杂的计算。假设我们想要找到单词数量最多的那行：

Scala 版

scala> textFile.map(line => line.split(" ").size).reduce((a, b) => if (a > b) a else b)
res4: Long = 15

这首先将文件中的一行映射成一个整数值，并创建一个新的Dataset。调用该 Dataset 的 reduce 方法以找到最大的单词计数。map 和 reduce 的参数是 Scala 的函数字面量（闭包），并且可以使用任何语言的特性或者 Scala/Java 库。比如，我们可以很荣誉地调用任何地方声明地函数（方法）。我们将使用 Math.max() 方法以使这段代码易于理解：

scala> import java.lang.Math
import java.lang.Math

scala> textFile.map(line => line.split(" ").size).reduce((a, b) => Math.max(a, b))
res5: Int = 15

MapReduce是一种常见的数据流格式，这是由Hadoop推广的。Spark 可以很容易地实现MapReduce流：

scala> val wordCounts = textFile.flatMap(line => line.split(" ")).groupByKey(identity).count()
wordCounts: org.apache.spark.sql.Dataset[(String, Long)] = [value: string, count(1): bigint]

这里，我们调用 flatMap 来将一个行级（以文本中的一行为一个成员（Item））的 Dataset 转换成一个单词级的Dataset，然后串接调用 groupByKey 和 count 方法来计算文件中的每个单词的数量作为（String， Long）数据对形式的Dateset。为了在我们的shell中统计出单词的数量，我们可以调用 collect 方法：

scala> wordCounts.collect()
res6: Array[(String, Int)] = Array((means,1), (under,2), (this,3), (Because,1), (Python,2), (agree,1), (cluster.,1), ...)

Python 版

>>> from pyspark.sql.functions import *
>>> textFile.select(size(split(textFile.value, "\s+")).name("numWords")).agg(max(col("numWords"))).collect()
[Row(max(numWords)=15)]

这首先将文件中的一行映射成一个整数值并取一个为 “numWords” 的别名，同时创建一个新的DataFrame。调用该 Dataset 的 agg 方法以找到最大的单词计数。select 和 agg 的参数都是 Colum，我们可以使用 df.colName 方法来从一个DataFrame中获得一个 colum。我们同样可以导入 pyspark.sql.functions，它提供了很多简易的方法从一个已有的 Colum 构建一个新的 Colum。

MapReduce是一种常见的数据流格式，这是由Hadoop推广的。Spark 可以很容易地实现MapReduce流：

>>> wordCounts = textFile.select(explode(split(textFile.value, "\s+")).alias("word")).groupBy("word").count()

这里，我们在 select 方法中使用了 explode 方法来将一个行级（以文本中的一行为一个成员（Item））的 Dataset 转换成一个单词级的Dataset。然后串接调用 groupByKey 和 count 方法来计算文件中的每个单词的数量作为一个拥有两个Colum：“word” 和 “count” 的DataFrame。为了在我们的shell中统计出单词的数量，我们可以调用 collect 方法：

>>> wordCounts.collect()
[Row(word=u'online', count=1), Row(word=u'graphs', count=1), ...]

缓存（Caching）

Spark同样支持将数据集加入到一个集群中的内存缓存中。当数据被重复访问时，这是非常有用的。比如查询一个小的热点数据集或者运行像PageRank 这样的迭代算法。让我们标记我们的 linesWithSpark 作为缓存数据来作为一个例子：

Scala 版

scala> linesWithSpark.cache()
res7: linesWithSpark.type = [value: string]

scala> linesWithSpark.count()
res8: Long = 15

scala> linesWithSpark.count()
res9: Long = 15

Python 版

>>> linesWithSpark.cache()

>>> linesWithSpark.count()
15

>>> linesWithSpark.count()
15

使用Spark来探索和缓存一个100行的文本文件看起来很蠢。有趣的是，这些方法同样可以作用在非常大的数据集中，哪怕它们被分布在数十个或上百个节点中。正如 RDD编程指南中描述的那样，您可以通过连接 bin/spark-shell 到一个集群中来进行以上交互式操作。

独立的应用程序

假设我们希望使用 Spark API 编写一个独立的应用程序。我们将分别使用Scala(带sbt)，Java(带Maven) 和 Python（pip）编写一个简单的应用程序。

Scala

我们将在 Scala 中创建一个Spark 应用程序——非常简单。实际上，它被命名为 SimleApp.scala

/* SimpleApp.scala */
import org.apache.spark.sql.SparkSession

object SimpleApp {
  def main(args: Array[String]) {
    val logFile = "YOUR_SPARK_HOME/README.md" // Should be some file on your system
    val spark = SparkSession.builder.appName("Simple Application").getOrCreate()
    val logData = spark.read.textFile(logFile).cache()
    val numAs = logData.filter(line => line.contains("a")).count()
    val numBs = logData.filter(line => line.contains("b")).count()
    println(s"Lines with a: $numAs, Lines with b: $numBs")
    spark.stop()
  }
}

注意，这个应用程序需要定义一个 main() 方法而不是继承 scala.App. scala.App 的子类可能无法正常地工作。

我们调用 SparkSession.builder 来构造一个【SparkSession】，然后设置应用的名字，最后调用 getOrCreate 方法获取一个【SparkSession】实例。

我们的应用程序取决于Spark API，所以我们同样需要一个 sbt 配置文件， build.sbt，这表示 Spark 是一个依赖组件。

name := "Simple Project"

version := "1.0"

scalaVersion := "2.11.8"

libraryDependencies += "org.apache.spark" %% "spark-sql" % "2.3.1"

为了使 sbt 能够正常工作，我们需要根据经典的目录结构布局 SimpleApp.scala 和 build.sbt。一旦完成这些，我们就可以创建一个包含这个应用程序源代码的JAR包，然后使用 spark-submit 脚本运行我们的程序。

# Your directory layout should look like this
$ find .
.
./build.sbt
./src
./src/main
./src/main/scala
./src/main/scala/SimpleApp.scala

# Package a jar containing your application
$ sbt package
...
[info] Packaging {..}/{..}/target/scala-2.11/simple-project_2.11-1.0.jar

# Use spark-submit to run your application
$ YOUR_SPARK_HOME/bin/spark-submit \
  --class "SimpleApp" \
  --master local[4] \
  target/scala-2.11/simple-project_2.11-1.0.jar
...
Lines with a: 46, Lines with b: 23

Java

这个例子将会使用 Maven 编译一个JAR 应用程序，但是很多类似的构建系统都可以完成这些工作。

我们将创建一个简单的Spark应用程序， SimpleApp.java

/* SimpleApp.java */
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.Dataset;

public class SimpleApp {
  public static void main(String[] args) {
    String logFile = "YOUR_SPARK_HOME/README.md"; // Should be some file on your system
    SparkSession spark = SparkSession.builder().appName("Simple Application").getOrCreate();
    Dataset<String> logData = spark.read().textFile(logFile).cache();

    long numAs = logData.filter(s -> s.contains("a")).count();
    long numBs = logData.filter(s -> s.contains("b")).count();

    System.out.println("Lines with a: " + numAs + ", lines with b: " + numBs);

    spark.stop();
  }
}

为了构建这个程序，我们同样要编写一个 Maven pom.xml 文件，这个文件将 Spark 列为一个依赖组件。请注意，Spark 构件被标记为Scala版本

<project>
  <groupId>edu.berkeley</groupId>
  <artifactId>simple-project</artifactId>
  <modelVersion>4.0.0</modelVersion>
  <name>Simple Project</name>
  <packaging>jar</packaging>
  <version>1.0</version>
  <dependencies>
    <dependency> <!-- Spark dependency -->
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.11</artifactId>
      <version>2.3.1</version>
    </dependency>
  </dependencies>
</project>

我们根据规范的Maven目录结构列出这些文件

$ find .
./pom.xml
./src
./src/main
./src/main/java
./src/main/java/SimpleApp.java

现在，我们可以使用 Maven 打包这个应用程序并且通过 ./bin/spark-submit. 执行

# Package a JAR containing your application
$ mvn package
...
[INFO] Building jar: {..}/{..}/target/simple-project-1.0.jar

# Use spark-submit to run your application
$ YOUR_SPARK_HOME/bin/spark-submit \
  --class "SimpleApp" \
  --master local[4] \
  target/simple-project-1.0.jar
...
Lines with a: 46, Lines with b: 23

Python

这里我们将展示如何使用Python API（PySpark）来编写一个应用程序

如果你正构建一个打包的 PySpark应用程序或库，你可以将它添加到你的 setup.py 文件中，如下：

install_requires=[
        'pyspark=={site.SPARK_VERSION}'
    ]

作为示例，我们将创建一个简单的 Spark 应用程序, SimpleApp.py:

"""SimpleApp.py"""
from pyspark.sql import SparkSession

logFile = "YOUR_SPARK_HOME/README.md"  # Should be some file on your system
spark = SparkSession.builder.appName("SimpleApp").getOrCreate()
logData = spark.read.text(logFile).cache()

numAs = logData.filter(logData.value.contains('a')).count()
numBs = logData.filter(logData.value.contains('b')).count()

print("Lines with a: %i, lines with b: %i" % (numAs, numBs))

spark.stop()

这个程序只是统计 Spark README 文件中包含 “a” 的行数和包含"b" 的行数。注意，您需要使用 Spark 的安装位置来代替 YOUR_SPARK_HOME。与之前Spark Shell中的例子不同的是，Spark Shell 初始化它自己的SparkSession，而我们初始化一个SparkSeesion作为程序的一部分。和 Scala 和 Java 例子一样，我们使用 SparkSession 来创建 Dataset 。对于使用自定义类或者第三方库的应用程序，我们同样可以通过它的 --py-- files 参数将代码和依赖打包成zip文件（使用 spark-submit --help 查看细节）的形式添加到 spark-submit。 SimpleApp 足够简单，所以我们不用指定任何代码依赖组件。

我们使用 bin/spark-submit 脚本运行这个程序

# Use spark-submit to run your application
$ YOUR_SPARK_HOME/bin/spark-submit \
  --master local[4] \
  SimpleApp.py
...
Lines with a: 46, Lines with b: 23

如果您将PySpark通过 pip 安装到了您的环境中（eg. pip install pyspark），根据您的喜好，可以使用常规的Python解释器或者使用 spark-submit 来运行您的程序

# Use the Python interpreter to run your application
$ python SimpleApp.py
...
Lines with a: 46, Lines with b: 23

下一步

祝贺您运行了您的第一个 Spark 应用程序

　　关于API的深入概述，请从 RDD 编程指南和 SQL 编程指南开始，或者查看编程指南菜单以了解其他组件

　　关于使用集群运行应用程序，请移步部署概述

　　最后， Spark 包含了几个简单的例子，它们被保存在 example 目录下（Scala， Java， Python， R），你可以按照以下方式运行它们：

# For Scala and Java, use run-example:
./bin/run-example SparkPi

# For Python examples, use spark-submit directly:
./bin/spark-submit examples/src/main/python/pi.py

# For R examples, use spark-submit directly:
./bin/spark-submit examples/src/main/r/dataframe.R

posted @ 2018-09-16 01:31 早起的虫儿去吃鸟阅读(753) 评论(2) 编辑收藏举报

刷新页面返回顶部

莫问今朝

每天学习一点点，进步一点点，不管是什么知识

【Spark】Spark Quick Start（快速入门翻译）

Quick Start

使用 Spark Shell 交互式编程

基本操作

更多关于Dataset的操作

缓存（Caching）

独立的应用程序

下一步

公告

莫问今朝

每天学习一点点，进步一点点， 不管是什么知识

【Spark】Spark Quick Start（快速入门翻译）

Quick Start

使用 Spark Shell 交互式编程

基本操作

更多关于Dataset的操作

缓存（Caching）

独立的应用程序

下一步

公告

每天学习一点点，进步一点点，不管是什么知识