超级会员免费看
大数据处理：Azure 上的 Spark 实践与 Twitter 标签统计
1. 在 Microsoft Azure HDInsight Spark 集群上实现 Spark 词频统计
在 Azure 上实现 Spark 词频统计，可按以下步骤操作：
1.
创建 Apache Spark 集群
：通过 Azure 门户创建，参考链接：https://docs.microsoft.com/en-us/azure/hdinsight/spark/apache-spark-jupyter-spark-sql-use-portal 。创建时注意选择集群类型为 Spark，默认配置资源较多，可将工作节点数改为 2，并配置工作节点和头节点使用 D3 v2 计算机。点击创建后，配置和部署集群需 20 - 30 分钟。
2.
安装库到集群
：若 Spark 代码需要未安装的库，可使用以下命令查看默认安装的库：
/usr/bin/anaconda/envs/py35/bin/conda list
使用提供的安装脚本安装所需库，步骤如下：
1. 在 Azure 门户中选择集群。
2. 点击集群搜索框下的“Script Actions”。
3. 点击“Submit new”，脚本类型选“Custom”，名称指定为“libraries”，Bash 脚本 URI 使用：http://deitel.com/bookresources/IntroToPython/install_libraries.sh 。
4. 勾选“Head”和“Worker”确保脚本在所有节点安装库。
5. 点击“Create”。执行成功会在脚本操作列表中显示绿色对勾，否则 Azure 会通知错误。
3.
复制 RomeoAndJuliet.txt 到 HDInsight 集群
：
1. 使用
scp
命令上传文件，命令如下：
scp RomeoAndJuliet.txt sshuser@YourClusterName-ssh.azurehdinsight.net:
2. 使用 `ssh` 登录集群：
ssh sshuser@YourClusterName-ssh.azurehdinsight.net
3. 将文件复制到集群的 Hadoop 文件系统：
hadoop fs -copyFromLocal RomeoAndJuliet.txt /example/data/RomeoAndJuliet.txt
- 访问 HDInsight 中的 Jupyter 笔记本 ：HDInsight 使用旧版 Jupyter Notebook 界面，可参考：https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Notebook%20Basics.html 。在 Azure 门户选择所有资源，再选集群，在“Overview”标签下选择“Jupyter notebook”，使用集群设置时的用户名和密码登录。
- 上传 RomeoAndJulietCounter.ipynb 笔记本 ：点击“Upload”按钮，选择 ch16 示例文件夹的 SparkWordCount 文件夹中的 RomeoAndJulietCounter.ipynb 文件，点击“Open”，再点击右侧“Upload”将笔记本放入当前文件夹，点击笔记本名称在新标签页打开，选择“PySpark3”内核。
-
修改笔记本以适配 Azure
：
-
修改
nltk.download('stopwords')为：
-
修改
nltk.download('stopwords', download_dir='.')
2. 在第二个单元格的导入语句后添加：
nltk.data.path.append('.')
3. 删除原笔记本的第三和第四个单元格。
4. 将 `'RomeoAndJuliet.txt'` 替换为 `'wasb:///example/data/RomeoAndJuliet.txt'`。
5. 将最后一个单元格的 f - 字符串替换为：
print('{:>{width}}: {}'.format(word, count, width=max_len))
2. 使用 pyspark - notebook Docker 栈统计 Twitter 标签
此部分将创建并运行 Spark 流式应用，接收指定主题的推文流，并每 10 秒更新一次前 20 个标签的柱状图。
1.
启动 Docker 容器并安装 Tweepy
：按照相关说明启动容器并安装 Python 库，使用以下命令安装 Tweepy：
pip install tweepy
-
将推文流式传输到套接字
：
- 执行脚本 ：在 JupyterLab 的终端窗口执行 starttweetstream.py 脚本。先导航到 SparkHashtagSummarizer 文件夹：
cd work/SparkHashtagSummarizer
然后执行脚本，例如获取 1000 条关于足球的推文：
ipython starttweetstream.py 1000 football
此时脚本会显示“Waiting for connection”，等待 Spark 连接。
- **starttweetstream.py 脚本分析**：
# starttweetstream.py
"""Script to get tweets on topic(s) specified as script argument(s)
and send tweet text to a socket for processing by Spark."""
import keys
import socket
import sys
import tweepy
class TweetListener(tweepy.StreamListener):
"""Handles incoming Tweet stream."""
def __init__(self, api, connection, limit=10000):
"""Create instance variables for tracking number of tweets."""
self.connection = connection
self.tweet_count = 0
self.TWEET_LIMIT = limit # 10,000 by default
super().__init__(api) # call superclass's init
def on_connect(self):
"""Called when your connection attempt is successful, enabling
you to perform appropriate application tasks at that point."""
print('Successfully connected to Twitter\n')
def on_status(self, status):
"""Called when Twitter pushes a new tweet to you."""
# get the hashtags
hashtags = []
for hashtag_dict in status.entities['hashtags']:
hashtags.append(hashtag_dict['text'].lower())
hashtags_string = ' '.join(hashtags) + '\n'
print(f'Screen name: {status.user.screen_name}:')
print(f' Hashtags: {hashtags_string}')
self.tweet_count += 1 # track number of tweets processed
try:
# send requires bytes, so encode the string in utf-8 format
self.connection.send(hashtags_string.encode('utf-8'))
except Exception as e:
print(f'Error: {e}')
# if TWEET_LIMIT is reached, return False to terminate streaming
return self.tweet_count != self.TWEET_LIMIT
def on_error(self, status):
print(status)
return True
if __name__ == '__main__':
tweet_limit = int(sys.argv[1]) # get maximum number of tweets
client_socket = socket.socket() # create a socket
# app will use localhost (this computer) port 9876
client_socket.bind(('localhost', 9876))
print('Waiting for connection')
client_socket.listen() # wait for client to connect
# when connection received, get connection/client address
connection, address = client_socket.accept()
print(f'Connection received from {address}')
# configure Twitter access
auth = tweepy.OAuthHandler(keys.consumer_key, keys.consumer_secret)
auth.set_access_token(keys.access_token, keys.access_token_secret)
# configure Tweepy to wait if Twitter rate limits are reached
api = tweepy.API(auth, wait_on_rate_limit=True,
wait_on_rate_limit_notify=True)
# create the Stream
twitter_stream = tweepy.Stream(api.auth,
TweetListener(api, connection, tweet_limit))
# sys.argv[2] is the first search term
twitter_stream.filter(track=sys.argv[2:])
connection.close()
client_socket.close()
- **关键说明**：
- `__init__` 方法接收套接字参数并存储在 `self.connection` 中，用于向 Spark 应用发送标签。
- `on_status` 方法提取标签，转换为小写并发送到套接字。
以下是创建 Apache Spark 集群和安装库的流程 mermaid 流程图：
graph LR
A[开始] --> B[创建 Apache Spark 集群]
B --> C[安装库到集群]
C --> D[复制文件到集群]
D --> E[访问 Jupyter 笔记本]
E --> F[上传笔记本]
F --> G[修改笔记本适配 Azure]
G --> H[完成]
3. 总结推文标签；引入 Spark SQL
可创建新笔记本或加载提供的 hashtagsummarizer.ipynb 笔记本进行操作。
1.
导入库
：
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
from pyspark.sql import Row, SparkSession
from IPython import display
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
- 获取 SparkSession 的实用函数 ：
def getSparkSessionInstance(sparkConf):
"""Spark Streaming Programming Guide's recommended method
for getting an existing SparkSession or creating a new one."""
if ("sparkSessionSingletonInstance" not in globals()):
globals()["sparkSessionSingletonInstance"] = SparkSession \
.builder \
.config(conf=sparkConf) \
.getOrCreate()
return globals()["sparkSessionSingletonInstance"]
- 基于 Spark DataFrame 显示柱状图的实用函数 ：
def display_barplot(spark_df, x, y, time, scale=2.0, size=(16, 9)):
"""Displays a Spark DataFrame's contents as a bar plot."""
df = spark_df.toPandas()
# remove prior graph when new one is ready to display
display.clear_output(wait=True)
print(f'TIME: {time}')
# create and configure a Figure containing a Seaborn barplot
plt.figure(figsize=size)
sns.set(font_scale=scale)
barplot = sns.barplot(data=df, x=x, y=y, palette=sns.color_palette('cool', 20))
# rotate the x-axis labels 90 degrees for readability
for item in barplot.get_xticklabels():
item.set_rotation(90)
plt.tight_layout()
plt.show()
- 总结前 20 个标签的实用函数 ：
def count_tags(time, rdd):
"""Count hashtags and display top-20 in descending order."""
try:
# get SparkSession
spark = getSparkSessionInstance(rdd.context.getConf())
# map hashtag string-count tuples to Rows
rows = rdd.map(
lambda tag: Row(hashtag=tag[0], total=tag[1]))
# create a DataFrame from the Row objects
hashtags_df = spark.createDataFrame(rows)
# create a temporary table view for use with Spark SQL
hashtags_df.createOrReplaceTempView('hashtags')
# use Spark SQL to get top 20 hashtags in descending order
top20_df = spark.sql(
"""select hashtag, total
from hashtags
order by total, hashtag desc
limit 20""")
display_barplot(top20_df, x='hashtag', y='total', time=time)
except Exception as e:
print(f'Exception: {e}')
-
设置 Spark 流式处理
：
- 获取 SparkContext ：
sc = SparkContext()
- **获取 StreamingContext**：
ssc = StreamingContext(sc, 10)
- **设置检查点**：
ssc.checkpoint('hashtagsummarizer_checkpoint')
- **连接到流**：
stream = ssc.socketTextStream('localhost', 9876)
- **分词**：
tokenized = stream.flatMap(lambda line: line.split())
- **映射标签到标签 - 计数对**：
mapped = tokenized.map(lambda hashtag: (hashtag, 1))
- **汇总标签计数**：
hashtag_counts = tokenized.updateStateByKey(
lambda counts, prior_total: sum(counts) + (prior_total or 0))
- **指定处理每个 RDD 的方法**：
hashtag_counts.foreachRDD(count_tags)
- **启动 Spark 流**：
ssc.start() # start the Spark streaming
以下是统计 Twitter 标签的流程 mermaid 流程图：
graph LR
A[开始] --> B[启动 Docker 容器并安装 Tweepy]
B --> C[将推文流式传输到套接字]
C --> D[总结推文标签；引入 Spark SQL]
D --> E[设置 Spark 流式处理]
E --> F[启动 Spark 流]
F --> G[完成]
在完成操作后，务必删除集群和其他资源以避免产生费用，可参考：https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-portal 。同时，可在 Jupyter 中选择“File > Download as > Notebook (.ipynb)”下载执行的笔记本。
大数据处理：Azure 上的 Spark 实践与 Twitter 标签统计
4. 操作步骤总结与注意事项
为了更清晰地展示整个大数据处理流程，下面将操作步骤进行总结，并列出一些需要注意的事项。
4.1 操作步骤总结
| 操作阶段 | 具体步骤 |
|---|---|
| 创建 Apache Spark 集群 |
1. 通过 Azure 门户，参考指定链接创建集群，选择集群类型为 Spark。
2. 修改默认配置，将工作节点数改为 2，配置工作节点和头节点使用 D3 v2 计算机。 3. 点击创建，等待 20 - 30 分钟完成配置和部署。 |
| 安装库到集群 |
1. 使用
ssh
登录集群，执行命令查看默认安装的库。
2. 在 Azure 门户选择集群，点击“Script Actions”，再点击“Submit new”。 3. 配置脚本类型、名称和 Bash 脚本 URI。 4. 勾选“Head”和“Worker”，点击“Create”。 |
| 复制文件到集群 |
1. 使用
scp
命令上传文件到集群。
2. 使用
ssh
登录集群。
3. 将文件复制到集群的 Hadoop 文件系统。 |
| 访问 Jupyter 笔记本 |
1. 在 Azure 门户选择所有资源和集群，在“Overview”标签下选择“Jupyter notebook”。
2. 使用集群设置时的用户名和密码登录。 |
| 上传笔记本 |
1. 点击“Upload”按钮，选择指定文件夹中的文件，点击“Open”。
2. 点击右侧“Upload”将笔记本放入当前文件夹，点击笔记本名称在新标签页打开，选择“PySpark3”内核。 |
| 修改笔记本适配 Azure |
1. 修改
nltk.download('stopwords')
。
2. 在第二个单元格添加语句。 3. 删除原笔记本的第三和第四个单元格。 4. 替换文件路径。 5. 替换最后一个单元格的 f - 字符串。 |
| 启动 Docker 容器并安装 Tweepy |
1. 按照相关说明启动容器。
2. 使用
pip install tweepy
命令安装 Tweepy。
|
| 将推文流式传输到套接字 |
1. 在 JupyterLab 的终端窗口导航到指定文件夹。
2. 执行脚本获取指定数量和主题的推文。 |
| 总结推文标签；引入 Spark SQL |
1. 导入所需库。
2. 定义获取 SparkSession、显示柱状图和总结标签的实用函数。 |
| 设置 Spark 流式处理 |
1. 获取 SparkContext 和 StreamingContext。
2. 设置检查点。 3. 连接到流，进行分词、映射、汇总标签计数等操作。 4. 指定处理每个 RDD 的方法，启动 Spark 流。 |
4.2 注意事项
- 资源管理 ：完成操作后，务必删除集群和其他资源，避免产生不必要的费用。可参考相关链接进行资源删除操作。
- 笔记本保存 ：在 Jupyter 中可选择“File > Download as > Notebook (.ipynb)”下载执行的笔记本，防止资源删除时笔记本丢失。
- 代码兼容性 ：Azure 目前使用 Python 3.5.x，不支持 f - 字符串，需进行相应替换。
- 文件路径 ：在修改笔记本适配 Azure 时，要注意文件路径的替换，确保代码能正确访问文件。
5. 技术点分析
在整个大数据处理过程中，涉及到多个关键技术点，下面对这些技术点进行详细分析。
5.1 Spark 与 Azure HDInsight
Spark 是一个快速通用的集群计算系统，而 Azure HDInsight 是微软提供的托管式云服务，可轻松在 Azure 上运行 Spark 集群。通过在 HDInsight 上创建 Spark 集群，我们可以利用其强大的计算能力处理大规模数据。在创建集群时，需要注意配置资源，避免资源浪费。同时，安装所需库时，要确保脚本能在所有节点上正确执行。
5.2 数据处理与分析
- 文本处理 ：在处理 RomeoAndJuliet.txt 文件时，需要进行文本清洗和分词操作，以便后续进行词频统计。在统计 Twitter 标签时，同样需要对推文进行处理，提取标签并进行计数。
- Spark SQL ：Spark SQL 提供了一种统一的方式来处理结构化数据，可将 Spark DataFrame 视为关系数据库中的表，使用 SQL 语句进行查询和分析。在统计 Twitter 标签时，我们使用 Spark SQL 从临时表中查询前 20 个标签。
5.3 流式处理
Spark Streaming 是 Spark 的一个扩展，用于处理实时数据流。在统计 Twitter 标签的示例中，我们使用 Spark Streaming 接收推文流，并每 10 秒更新一次前 20 个标签的柱状图。通过设置检查点，可实现容错和状态管理，确保在集群节点或应用程序故障时能恢复流处理。
6. 总结
通过本文的介绍，我们详细了解了在 Azure 上使用 Spark 进行大数据处理的完整流程，包括创建集群、安装库、处理文件、统计 Twitter 标签等操作。同时，我们还对涉及的关键技术点进行了分析，深入理解了 Spark、Azure HDInsight、数据处理和流式处理等技术的应用。
在实际应用中，我们可以根据具体需求调整参数和配置，优化处理性能。例如，根据数据量和处理速度调整批处理间隔，根据集群资源情况调整节点数量等。希望本文能为你在大数据处理领域的实践提供有价值的参考。
以下是整个大数据处理流程的 mermaid 流程图：
graph LR
A[开始] --> B[创建 Apache Spark 集群]
B --> C[安装库到集群]
C --> D[复制文件到集群]
D --> E[访问 Jupyter 笔记本]
E --> F[上传笔记本]
F --> G[修改笔记本适配 Azure]
G --> H[启动 Docker 容器并安装 Tweepy]
H --> I[将推文流式传输到套接字]
I --> J[总结推文标签；引入 Spark SQL]
J --> K[设置 Spark 流式处理]
K --> L[启动 Spark 流]
L --> M[完成]
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
