如何使用 Docker、JupyterLab 和 Apache Livy 构建 Spark 集群——Apache Spark 的 REST API

最初由 Michał Klóska 和 Lidia Kurasińska 撰写您有没有想过如何在您的项目中利用 Apache Livy 将您的 Apache Spark 集群体验提升到一个新的水平?我整理了一份分步指南,可帮助您实现该目标。要运行示例项目并充分利用本指南,您需要先安装 Docker 容器服务。如果您不熟悉容器,可以在Docker 文档中找到更多详细信息。通过阅读本文,您将了解

云O生

311人浏览 · 2022-08-14 22:59:50

云O生 · 2022-08-14 22:59:50 发布

最初由 Michał Klóska 和 Lidia Kurasińska 撰写

您有没有想过如何在您的项目中利用 Apache Livy 将您的 Apache Spark 集群体验提升到一个新的水平?我整理了一份分步指南,可帮助您实现该目标。

要运行示例项目并充分利用本指南,您需要先安装 Docker 容器服务。如果您不熟悉容器,可以在Docker 文档中找到更多详细信息。

通过阅读本文,您将了解如何使用 Livy 服务器和基于 Docker 虚拟环境的 JupyterLab 构建 Spark 集群。

您还将了解如何在 JupyterLab 中准备业务逻辑,并了解我如何使用示例项目通过 Livy 服务运行 PySpark 代码。

什么是 Apache Spark?为什么要使用它?

Apache Spark 是一种分析引擎,用于以并行方式处理 PB 级数据。

得益于简单易用的API和 RDD、数据集、具有丰富运算符集合的数据帧等结构,以及对Python、Scala、R、Java 和 SQL 等语言的支持,它已成为数据工程师的首选工具。

由于其速度(比 Hadoop MapReduce 快 100 倍)和灵活性(例如支持 SQL 查询、机器学习、流式传输和图形处理),Apache Spark 被各行各业的企业大规模部署.

[ Spark 生态系统 ](https://res.cloudinary.com/practicaldev/image/fetch/s--rEF00oIA--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to- uploads.s3.amazonaws.com/uploads/articles/xe43hkij390snhbd88nn.png) 来源:https://databricks.com/spark/about

什么是 Apache Livy?它如何使您的项目受益?

Apache Livy 是一项服务,可通过 REST API 与 Spark 集群轻松交互。

它的一些有用功能包括:

在 Python/Scala/R 中将作业作为预编译的 jar 或代码片段提交,
同步或异步运行 Spark 作业,
同时管理多个 SparkContexts,
长时间运行的 SparkContext 可以被许多 Spark 作业重用,
在多个作业和客户端之间共享缓存的 RDD 或数据帧,
安全经过身份验证的通信。

您可能想知道如何使 Apache Spark 更易于在自动化处理中使用。

例如,我们可以想象这样一种情况,我们将用 Python 或 Scala 编写的 Spark 代码提交到集群中,就像我们将 SQL 查询提交到数据库引擎一样。如果我们不想通过命令行直接使用 SSH 访问集群,那么 Apache Livy 就可以使用其 REST API 接口。

[ Livy 架构 ](https://res.cloudinary.com/practicaldev/image/fetch/s--U8S9nUrm--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to- uploads.s3.amazonaws.com/uploads/articles/adjy6bc74yxxfzbv1mzo.png)来源:https://livy.apache.org/assets/images/livy-architecture.png

您是否必须创建额外的逻辑层来管理连接和所有 REST API 功能?

不,幸运的是,我将在示例项目中使用一个名为 pylivy 的专用库。您可以在此处](https://pylivy.readthedocs.io/en/stable/)找到 pylivy 示例和文档[。

测试在 Spark 集群中使用 Apache Livy 的概念

假设我们必须创建一个应用程序来处理 Spark 上的一些客户或市场数据,并且我们的应用程序将每天运行。

从开发人员的角度来看,我们首先必须准备带有业务逻辑的脚本。接下来,我们应该准备作业的控制器,以通过 Livy REST API 管理与 Spark 集群的通信。

但在我们开发任何东西之前,我们需要安装和配置 Livy 和 Spark 集群。

设置要求

正如我在本文开头提到的,为了使操作系统不受依赖,我们使用 Docker 容器服务来运行我们的基础设施。因此,首先,我们需要为 Spark master 和 worker 容器准备 Docker 文件,并为 JupyterLab 准备一个单独的容器。

安装服务配置

如果您没有安装 Docker 服务,请按照这些说明让它在您的机器上运行。

如果你在这里,我假设你已经准备好运行我们的容器的 Docker,所以我们可以专注于代码。

为了使我们的概念更加现实,我决定将基础架构拆分为三个独立的服务:

jupyterlab,
火花大师,
火花工人 1。

此外,为了保持逻辑简单明了,我为 Docker 服务创建了一个专用文件夹,名为 livy_poc_docker。

第一步,我们将创建一个基础镜像。

基本映像使用 Debian Linux 并包含所有必需的库:python3、open-jdk-8 和实用程序,例如wget,卷曲和解压缩。

 FROM debian:stretch

   # System packages
   RUN apt-get clean && apt-get update -y && \
      apt-get install -y python3 python3-pip curl wget unzip procps openjdk-8-jdk && \
      ln -s /usr/bin/python3 /usr/bin/python && \
      rm -rf /var/lib/apt/lists/*

进入全屏模式退出全屏模式

为了简化镜像结构,我决定将 Spark 安装添加到基础镜像中。对于生产用途,应将 Spark 添加到单独的映像中。

 # Install Spark
   RUN curl https://apache.mirrors.tworzy.net/spark/spark-2.4.7/spark-2.4.7-bin-hadoop2.7.tgz -o spark.tgz && \
      tar -xf spark.tgz && \
      mv spark-2.4.7-bin-hadoop2.7 /usr/bin/ && \
      mkdir /usr/bin/spark-2.4.7-bin-hadoop2.7/logs && \
      rm spark.tgz

进入全屏模式退出全屏模式

接下来,我创建了所需的目录并设置了环境变量。

 # Prepare dirs
   RUN mkdir -p /tmp/logs/ && chmod a+w /tmp/logs/ && mkdir /app && chmod a+rwx /app && mkdir /data && chmod a+rwx /data
   ENV JAVA_HOME=/usr
   ENV SPARK_HOME=/usr/bin/spark-2.4.7-bin-hadoop2.7
   ENV PATH=$SPARK_HOME:$PATH:/bin:$JAVA_HOME/bin:$JAVA_HOME/jre/bin
   ENV SPARK_MASTER_HOST spark-master
   ENV SPARK_MASTER_PORT 7077
   ENV PYSPARK_PYTHON=/usr/bin/python
   ENV PYTHONPATH=$SPARK_HOME/python:$PYTHONPATH
   ENV APP=/app
   ENV SHARED_WORKSPACE=/opt/workspace
   RUN mkdir -p ${SHARED_WORKSPACE}
   VOLUME ${SHARED_WORKSPACE}

进入全屏模式退出全屏模式

然后,我为 Spark 主容器创建了一个映像。

Spark 主容器负责托管 Spark 主节点和 Livy 服务。

此映像基于先前创建的名为 mk-spark-base 的映像。

在此步骤中将安装 Python 的其他包。

 FROM mk-spark-base

   # Python packages
   RUN pip3 install wget requests datawrangler

进入全屏模式退出全屏模式

当然,我们不能忘记 Apache Livy。

 # Get Livy
   RUN wget https://apache.mirrors.tworzy.net/incubator/livy/0.7.0-incubating/apache-livy-0.7.0-incubating-bin.zip -O livy.zip && \
      unzip livy.zip -d /usr/bin/

进入全屏模式退出全屏模式

Spark master 将是我们必须公开端口并设置入口点的最终映像。

 EXPOSE 8080 7077 8998 8888
   WORKDIR ${APP}
   ADD entryfile.sh entryfile.sh
   ENTRYPOINT ["sh", "entryfile.sh"]

进入全屏模式退出全屏模式

好的,主映像的配置已准备就绪。现在,我们需要一个 worker 映像。

它只负责在工作模式下运行 Spark 节点,没有别的。

此镜像还使用 mk-spark-base 镜像作为基础。

 FROM mk-spark-base

   ENV APP=/app
   ENV JAVA_HOME=/usr
   ENV SPARK_HOME=/usr/bin/spark-2.4.7-bin-hadoop2.7
   ENV PATH=$SPARK_HOME:$PATH:/bin:$JAVA_HOME/bin:$JAVA_HOME/jre/bin
   ENV PYSPARK_PYTHON=/usr/bin/python
   ENV PYTHONPATH=$SPARK_HOME/python:$PYTHONPATH

   EXPOSE 8081 7077 8998 8888

   WORKDIR ${APP}

   CMD /usr/bin/spark-2.4.7-bin-hadoop2.7/bin/spark-class org.apache.spark.deploy.worker.Worker spark://${SPARK_MASTER_HOST}:${SPARK_MASTER_PORT} >> /tmp/logs/spark-worker.out

进入全屏模式退出全屏模式

现在,是时候为 JupyterLab 映像创建配置了。 我们将其命名为 mk-jupyter。

  FROM mk-spark-base

   # Python packages
   RUN pip3 install wget requests pandas numpy datawrangler findspark jupyterlab pyspark==2.4.7

   EXPOSE 8888

   WORKDIR ${SHARED_WORKSPACE}

   CMD jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root --NotebookApp.token=

进入全屏模式退出全屏模式

这有多简单?

最后,我们已经完成了集群所有容器的配置,是时候构建镜像了。这个简单的脚本运行docker build命令来创建所有需要的图像。

  # Builds images
   docker build \
   -f base.Dockerfile \
   -t mk-spark-base .
   docker build \
   -f master.Dockerfile \
   -t mk-spark-master .
   docker build \
   -f worker.Dockerfile \
   -t mk-spark-worker .
   docker build \
   -f jupyter.Dockerfile \
   -t mk-jupyter .

进入全屏模式退出全屏模式

让我们在 CLI 中运行它:sh build.sh。

要启动已经构建的容器,我们必须准备一个 Docker compose 文件。

 version: "3.6"
   volumes:
   shared-workspace:
   name: "hadoop-distributed-file-system"
   driver: local
   services:
   jupyterlab:
   image: mk-jupyter
   container_name: mk-jupyter
   ports:
   - 8888:8888
   volumes:
   - shared-workspace:/opt/workspace
   spark-master:
   image: mk-spark-master
   container_name: mk-spark-master
   ports:
   - 8080:8080
   - 7077:7077
   - 8998:8998
   volumes:
   - shared-workspace:/opt/workspace
   spark-worker-1:
   image: mk-spark-worker
   container_name: mk-spark-worker-1
   environment:
   - SPARK_WORKER_CORES=1
   - SPARK_WORKER_MEMORY=512m
   ports:
   - 8081:8081
   volumes:
   - shared-workspace:/opt/workspace
   depends_on:
   - spark-master

进入全屏模式退出全屏模式

Docker compose 文件负责服务编排,并描述服务名称、端口、卷和环境变量等输入参数,以及服务之间的依赖关系(如果存在)。

编码业务逻辑

如果您在这里,我假设您已成功完成所有前面的步骤并且所有容器都在运行。这是服务器站点。

现在,我们将专注于我们项目的业务逻辑——客户端站点。正如我之前提到的,现在我们需要创建客户端脚本以使用 REST API 与 Spark 服务器进行通信。

在我们开始编码之前,我建议创建一个单独的项目来放置我们的代码。我们称之为 livy_poc。

为了使用 Livy 服务器,我们将使用一个名为 pylivy 的 Python 库。当然,您可以使用 requests 包直接使用 REST API,但我认为 pylivy 将大大简化我们的代码。

因此,首先,我们必须安装所需的 pylivy 包,如_pip install -U livy_。

创建专用于给定项目的虚拟环境并像上面一样手动安装所有必需的包或使用 requirements.txt 文件_pip install -t requirements.txt_是一种常见的做法。

您可以在此处找到有关如何使用 venv的有用信息。

现在,我们可以创建一个名为 titanic_data.py 的文件并将所有逻辑放在那里。

为简单起见,我们将所有逻辑放在一个文件中,但在实际项目中,根据所使用的框架或项目结构将业务逻辑拆分为多个文件是一种很好的做法。

在客户端脚本中,我们必须导入所有必需的包(livy 和 textwrap)以使我们的代码模式友好。

from livy import LivySession, SessionKind
   import textwrap

进入全屏模式退出全屏模式

在此示例中,我们将使用非常流行且免费使用的 Titanic 数据集。

 # Get and load Titanic data into Spark
   get_titanic_data = textwrap.dedent(
   """
   from pathlib import Path
   import wget
   data_file = Path("/opt/workspace/titanic.csv")
   if not data_file.is_file():
   url = "https://web.stanford.edu/class/archive/cs/cs109/cs109.1166/stuff/titanic.csv"
   wget.download(url, "/opt/workspace/titanic.csv")
   """
   )

进入全屏模式退出全屏模式

如您所见,我们将 Python 代码嵌入到多行字符串中,并将其分配给 Python 变量 get_titanic_data。

我们可以将多行字符串包裹的代码视为将提交给我们的 Spark 集群的查询脚本。就像数据库中的 SQL 查询一样。

注意我们的多行字符串中的导入。这意味着 Spark 必须在执行其余代码之前导入这些包。

现在,我们必须创建一个 SparkSession 对象并将之前下载的数据集加载到 Spark 数据框中。

在这里,您可以在 Spark 端找到 SparkSession、SQLContext 库的其他导入。

 load_to_spark = textwrap.dedent(
   """
   from pyspark.sql import SparkSession, SQLContext
   spark = SparkSession.\
   builder.\
   appName("pyspark-notebook-titanic").\
   master("spark://spark-master:7077").\
   config("spark.executor.memory", "512m").\
   getOrCreate()

   sql = SQLContext(spark)

   data = sql.read.option("header", "true").option("inferSchema", "true").csv("/opt/workspace/titanic.csv")
   print("---"*20)
   print("Loaded rows:", data.count())
   print("---"*20)
   """
   )

进入全屏模式退出全屏模式

您可以在下面看到分配给变量的逻辑,这些变量将针对 Spark 集群上的 Titanic 数据集运行。

  # Run some analysis
   general_number_of_survived_passengers = textwrap.dedent(
   """
   survived = data[data["Survived"] == 1]
   survived_percent = survived.count()/data.count() * 100
   print("Total number of passengers:", data.count())
   print("Count of survived passengers:", survived.count())
   print("Percent of survived passengers:", survived_percent)
   """
   )

   percent_of_survived_passengers_with_siblings_spouses = textwrap.dedent(
   """
   sur_with_siblings = data[data["Siblings/Spouses Aboard"] != 0]
   sur_with_siblings_percent = sur_with_siblings.count()/data.count() * 100
   print("Count of passengers with siblings-spouses:", sur_with_siblings.count())
   print("Percent of survived passengers with siblings-spouses", sur_with_siblings_percent)
   """
   )

   percent_of_survived_passengers_with_parent_children = textwrap.dedent(
   """
   sur_with_parents = data[data["Parents/Children Aboard"] != 0]
   sur_with_parents_percent = sur_with_parents.count()/data.count() * 100
   print("Count of passengers with parents-children:", sur_with_parents.count())
   print("Percent of survived passengers with parents-children", sur_with_parents_percent)
   """
   )

   some_aggregations = textwrap.dedent(
   """
   grouped_passengers = data.groupby("pclass", "age", "survived").count() \
   .orderBy(
   data.Pclass,
   data.Age.desc(),
   data.Survived.asc()
   )
   print("---"*20)
   print("Aggregated data:")
   grouped_passengers.show(n=10)
   print("---"*20)
   """
   )

   save_aggregations_as_parquet = textwrap.dedent(
   """
   grouped_passengers.write \
   .option("header", "true") \
   .mode("overwrite") \
   .parquet("/opt/workspace/titanic_grouped_passengers.parquet")
   """
   )

进入全屏模式退出全屏模式

这里重要的是,称为数据的源数据帧在所有片段中使用和共享。这意味着我们可以在一个地方创建一个变量或一个数据框,然后在一个 Spark 会话中的代码中的任何其他地方使用它。

现在,是时候将我们的业务逻辑提交到集群了。这里到底发生了什么?

在 main 函数中,我们将连接到 Livy 服务器并创建 session 对象。接下来,我们将调用 run 方法并使用之前定义的业务逻辑变量。

 # Execute pyspark code
   LIVY_SERVER = "http://127.0.0.1:8998"

   def main():
   with LivySession.create(LIVY_SERVER, kind=SessionKind.PYSPARK) as session:
   session.run(get_titanic_data)
   session.run(load_to_spark)
   session.run(general_number_of_survived_passengers)
   session.run(percent_of_survived_passengers_with_siblings_spouses)
   session.run(percent_of_survived_passengers_with_parent_children)
   session.run(some_aggregations)
   session.run(save_aggregations_as_parquet)

   # Let's download data locally from Spark as Pandas data frame
   grouped_passengers_1 = session.read("grouped_passengers")
   print("Spark data frame 'grouped_passengers' as local Pandas data frame:")
   print("grouped_passengers_1: ", grouped_passengers_1)

   # Run same aggregation using SparkSQL
   session.run("data.createOrReplaceTempView('titanic_data')")
   session.run(textwrap.dedent(
   """
   grouped_passengers_2 = sql.sql(
   '''
   select pclass, age, survived, count(*) as cnt
   from titanic_data
   group by pclass, age, survived
   '''
   )
   """
   ))

   # Read the result from spark as Pandas data frame
   grouped_passengers_2 = session.read("grouped_passengers_2")
   print("Spark data frame 'grouped_passengers' as local Pandas data frame generated by SparkSQL:")
   print("grouped_passengers_2: ", grouped_passengers_2)

   # Compare local data frames
   print("---"*20)
   print("Results comparison of Spark MR vs SparkSQL")
   print(f"len(grouped_passengers_1) ==", str(len(grouped_passengers_1)))
   print(f"len(grouped_passengers_2) ==", str(len(grouped_passengers_2)))
   print("---"*20)

   print("Spark session closed.")

   if __name__ == "__main__":
   main()

进入全屏模式退出全屏模式

如您所见,我们使用了两种不同的方法来执行我们的 Spark 代码。

run 方法用于执行代码;它返回一个 object 请求 status 和 text 包含前十行。

但是,如果我们想在本地使用 Spark 集群上处理的数据,我们可以使用返回 Pandas 数据帧的 read 方法。

此外,Livy 为我们提供了使用 SparkSQL 的可能性(您可以在我们的简单示例中看到如何使用)。您还可以使用专用方法,例如_download_sql_ 和_read_sql_。

值得注意的是,在我们的示例中,我们使用 with 子句创建会话对象,因此我们不必担心在脚本结束时关闭 Livy 的会话。

请记住,关闭 Livy 会话后,所有数据帧、变量和对象都将被永久销毁。

集群执行

如果您在虚拟环境中安装了 pylivy,是时候将其激活为_source my_venv/bin/activate_。您可以将_source_替换为.(一个点)。

要执行我们的示例代码,首先您必须在您的机器上启动一个 Docker 服务器。在下一步中,使用 CLI 转到具有 Docker 服务配置的项目,在本例中称为 livy_poc_docker。然后编写_docker-compose start_命令并回车。

一两分钟后,当所有服务都使用 CLI 运行时,使用我们的业务登录名进入项目——在我们的例子中称为 livy_poc。

在我们的项目中,写入_python tytanic_data.py_作为输出,您应该会看到如下内容:

 ------------------------------------------------------------
   Loaded rows: 887
   ------------------------------------------------------------
   Total number of passengers: 887
   Count of survived passengers: 342
   Percent of survived passengers: 38.55693348365276
   Count of passengers with siblings-spouses: 283
   Percent of survived passengers with siblings-spouses 31.905298759864714
   Count of passengers with parents-children: 213
   Percent of survived passengers with parents-children 24.01352874859076
   ------------------------------------------------------------
   Aggregated data:
   +------+----+--------+-----+
   |pclass| age|survived|count|
   +------+----+--------+-----+
   | 1|80.0| 1| 1|
   | 1|71.0| 0| 2|
   | 1|70.0| 0| 1|
   | 1|65.0| 0| 2|
   | 1|64.0| 0| 3|
   | 1|63.0| 1| 1|
   | 1|62.0| 0| 2|
   | 1|62.0| 1| 1|
   | 1|61.0| 0| 2|
   | 1|60.0| 0| 2|
   +------+----+--------+-----+
   only showing top 10 rows

   ------------------------------------------------------------
   Spark data frame 'grouped_passengers' as local Pandas data frame:
   grouped_passengers_1: pclass age survived count
   0 1 80.00 1 1
   1 1 71.00 0 2
   2 1 70.00 0 1
   3 1 65.00 0 2
   4 1 64.00 0 3
   .. ... ... ... ...
   277 3 2.00 1 2
   278 3 1.00 0 2
   279 3 1.00 1 3
   280 3 0.75 1 2
   281 3 0.42 1 1

   [282 rows x 4 columns]
   Spark data frame 'grouped_passengers' as local Pandas data frame generated by SparkSQL:
   grouped_passengers_2: pclass age survived cnt
   0 2 13.0 1 1
   1 1 58.0 0 2
   2 3 28.5 0 2
   3 1 23.0 1 3
   4 1 32.0 1 2
   .. ... ... ... ...
   277 3 22.0 1 9
   278 2 21.0 0 5
   279 2 33.0 1 2
   280 3 20.0 1 4
   281 1 60.0 1 2

   [282 rows x 4 columns]
   ------------------------------------------------------------
   Results comparison of Spark MR vs SparkSQL
   len(grouped_passengers_1) == 282
   len(grouped_passengers_2) == 282
   ------------------------------------------------------------
   Spark session closed.

进入全屏模式退出全屏模式

Apache Livy、Apache Spark 和 JupyterLab 中的状态监控

最后,我们已经启动并运行了一切。但是我们如何监控服务状态呢?您将在下面找到一些提示。

Apache Livy 会话监控

要检查 Livy 会话状态,请转到http://localhost:8998。

如果您有任何会话正在运行,您将看到已启动会话的列表及其状态。

[ Livy 会话 - 空闲 ](https://res.cloudinary.com/practicaldev/image/fetch/s--9HTzqUpe--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev- to-uploads.s3.amazonaws.com/uploads/articles/wfkvoz9zy0sdpzz7tabd.png)

[ Livy 会话 - 忙碌 ](https://res.cloudinary.com/practicaldev/image/fetch/s--6eq2xzJX--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev- to-uploads.s3.amazonaws.com/uploads/articles/fh637x07qzb13ygt84me.png)

[ Livy 会话 - 关闭 ](https://res.cloudinary.com/practicaldev/image/fetch/s--xDJy6fqH--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev -to-uploads.s3.amazonaws.com/uploads/articles/77xd6i49zkq85rmhwho8.png)

您可以单击会话编号以查看详细信息,例如执行的代码、状态和进度。

[ Livy 会话 - 概述 ](https://res.cloudinary.com/practicaldev/image/fetch/s--pjTtC0Q5--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev- to-uploads.s3.amazonaws.com/uploads/articles/82hqxb9rpt89ee1idc00.png)

如果您单击 logs 列中的会话以查看所有会话的日志,您将看到以下内容:

[ Livy 会话 - 错误日志 ](https://res.cloudinary.com/practicaldev/image/fetch/s--s5NW_6IF--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev -to-uploads.s3.amazonaws.com/uploads/articles/lizld9bb39g9q43xajue.png)

如果没有任何会话正在运行,您将看到:

[ Livy - 无会话 ](https://res.cloudinary.com/practicaldev/image/fetch/s--DD7GZAJt--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev- to-uploads.s3.amazonaws.com/uploads/articles/fwo4hmz3q4nihprzk17c.png)

Apache Spark集群监控

访问http://localhost:8080/查看 Spark 集群。

[ 火花监测 ](https://res.cloudinary.com/practicaldev/image/fetch/s--_wqwSQMs--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to- uploads.s3.amazonaws.com/uploads/articles/cw02ea9amjazgieb6wfp.png)

使用 JupyterLab 开发

现在,是时候解释我创建 JupyterLab 服务的原因了。老实说,我真的很喜欢这种设置,因为它让我可以使用 JupyterLab 环境来开发和测试我的 Spark 脚本。准备好后,我可以使用 Livy API 自动化它们,而无需任何其他配置。

这就是我开发本文中示例的业务逻辑的方式。

去http://localhost:8888可以看到JupyterLab的界面。

[ Jupyter 代码 ](https://res.cloudinary.com/practicaldev/image/fetch/s--MWebuqxR--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to- uploads.s3.amazonaws.com/uploads/articles/66ctrkmyyg5pg6xmyhgi.png)

关于 Apache Livy REST API 的最终想法

在本文中,我们介绍了如何将 Apache Livy 与 Spark 结合使用,以及 Livy 可以为您的工作带来哪些好处。我还解释了如何将它与 Python 项目集成,并基于 Docker 环境准备一个简单的项目,这使得该项目与系统无关。

尽管看起来可能需要吸收很多东西,但请记住,我向您展示的只是冰山一角。 Livy 可以做得更多,特别是如果您使用 pylivy 作为抽象层。这将为您提供一个强大的工具来从您的应用程序创建和管理 Spark 作业或创建更灵活的数据管道。

如果你决定在你的下一个项目中使用 Apache Livy,那么先熟悉一下pylivy 文档对你很有帮助。在那里,您会发现许多有用的类和方法,它们使 Livy 的使用变得非常高效和简单。

其他资源和进一步阅读

码头工人

https://www.docker.com/get-started

阿帕奇李维

https://livy.apache.org/

https://livy.apache.org/docs/latest/rest-api.html

https://livy.incubator.apache.org/examples/

灌溉

https://pylivy.readthedocs.io/en/stable/

https://pylivy.readthedocs.io/en/stable/api/session.html

阿帕奇星火

https://spark.apache.org/

https://spark.apache.org/examples.html

JupyterLab

https://jupyter.org/

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...