标签：Node 创建 编程 应用程序 Red 使用 节点 RED

Node-Red 实战编程（全）

原文：zh.annas-archive.org/md5/C5AA5862C03AC3F75583D0632C740313

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

Node-RED 是由 Node.js 制作的基于流的编程工具。这个工具主要用于连接物联网设备和软件应用程序。然而，它不仅可以涵盖物联网，还可以涵盖标准的 Web 应用程序。

Node-RED 正在扩展为一个无代码/低代码编程工具。本书涵盖了如何使用它的基础知识，包括从 1.2 版本发布的新功能，以及高级教程。

这本书适合谁

这本书最适合那些第一次学习无代码/低代码编程工具的软件编程人员。Node-RED 是一个基于流的编程工具，这个工具可以轻松构建任何软件应用程序的 Web 应用程序，如物联网数据处理，标准 Web 应用程序，Web API 等。因此，这本书将帮助 Web 应用程序开发人员和物联网工程师。

本书涵盖的内容

第一章《介绍 Node-RED 和基于流的编程》教会我们什么是 Node-RED。内容还涉及基于流的编程，解释了为什么开发了 Node-RED 以及它的用途。了解这个新工具 Node-RED 有助于改善我们的编程经验。

第二章《设置开发环境》涵盖了通过安装 Node-RED 设置开发环境。Node-RED 可以安装在 Node.js 可以运行的任何操作系统上，如 Windows，macOS，Rasberry Pi OS 等。我们可以通过命令行或使用安装程序在每个环境中安装 Node-RED。本章涵盖了特定操作系统的重要注意事项。

第三章《通过创建基本流了解 Node-RED 特性》教会我们关于 Node-RED 的基本用法。在 Node-RED 中，各种功能与称为节点的部分一起使用。在 Node-RED 中，我们使用称为流的概念创建应用程序，就像工作流一样。我们将通过组合基本节点创建一个示例流。

第四章《学习主要节点》教会我们如何利用更多的节点。我们不仅将了解 Node-RED 默认提供的节点，还将学习如何获取社区发布的各种节点以及如何使用它们。

第五章《在本地实现 Node-RED》教会我们在本地环境，即我们的桌面环境中利用 Node-RED 的最佳实践。由于 Node-RED 是基于 Node.js 的工具，它擅长构建服务器端应用程序。然而，服务器不仅仅存在于网络之外。通过在边缘设备（如树莓派）的本地环境中使用 Node-RED 的虚拟运行时，我们可以更方便地使用它。

第六章《在云中实现 Node-RED》教会我们在云平台上利用 Node-RED 的最佳实践。由于 Node-RED 是基于 Node.js 的工具，它擅长构建服务器端应用程序。通过在任何云平台上使用 Node-RED，我们可以更方便地使用它，因此我们将在 IBM Cloud 上使用 Node-RED 制作流程作为云平台的一个用例。

第七章《从 Node-RED 调用 Web API》教会我们如何利用 Node-RED 中的 Web API。为了最大限度地提高 Web 应用程序的吸引力，与各种 Web API 链接是必不可少的。在 Node-RED 中，调用 Web API 与常规 Node.js 应用程序中调用 Web API 之间的区别，可以帮助我们充分利用 Node-RED。

[第八章]（B16353_08_ePub_AM.xhtml#_idTextAnchor102），使用 Git 的项目功能，教我们如何在 Node-RED 中使用源代码版本控制工具。在 Node-RED 中，项目功能在 1.x 版本及更高版本中可用。项目功能可以与基于 Git 的每个源代码版本控制工具进行链接。通过将流程版本化到存储库中，我们的开发将加速。

[第九章]（B16353_09_ePub_AM.xhtml#_idTextAnchor110），使用 Node-RED 创建 ToDo 应用程序，教我们如何使用 Node-RED 开发标准的 Web 应用程序。这里的 Web 应用程序是一个简单的 ToDo 应用程序。整个应用程序的架构非常简单，将帮助我们了解如何使用 Node-RED 开发 Web 应用程序，包括用户界面。

[第十章]（B16353_10_ePub_AM.xhtml#_idTextAnchor121），处理树莓派上的传感器数据，教我们使用 Node-RED 进行 IoT 数据处理的应用程序开发方法。Node-RED 最初是为处理 IoT 数据而开发的。因此，Node-RED 今天仍在使用的许多用例都是 IoT 数据处理。Node-RED 将从传感器获取的数据传递给我们想要进行的每个过程，并将其发布。

[第十一章]（B16353_11_ePub_AM.xhtml#_idTextAnchor134），通过在 IBM Cloud 中创建服务器端应用程序来可视化数据，教我们关于在云平台上使用 Node-RED 进行 IoT 数据处理的应用程序开发方法。我们通常使用来自任何云平台的边缘设备的数据进行分析、可视化等。Node-RED 处理从 MQTT 代理订阅的数据，并为任何目的可视化它。

[第十二章]（B16353_12_ePub_AM.xhtml#_idTextAnchor142），使用 Slack 和 IBM Watson 开发聊天机器人应用程序，教我们如何创建聊天机器人应用程序。乍一看，Node-RED 和聊天机器人似乎没有关联，但许多聊天机器人应用程序在幕后使用 Node-RED。原因是 Node-RED 可以像工作流程一样对数据进行逐个数据的服务器端处理。在这里，我们创建一个在全球范围内使用的 Slack 上运行的聊天机器人。

[第十三章]（B16353_13_ePub_AM.xhtml#_idTextAnchor150），在 Node-RED 库中创建和发布自己的节点，教我们如何自己开发节点。对于许多用例，我们可以从 Node-RED 库中找到我们需要的处理节点。这是因为许多节点由许多开发人员的贡献在互联网上公开。通过开发自己的节点并将其发布到 Node-RED 库，让我们帮助大量其他 Node-RED 用户。

为了充分利用本书

您将需要 Node-RED 版本 1.2 或更高版本，Node.js 版本 12 或更高版本，npm 版本 6 或更高版本，并最好安装在计算机上的最新次要版本。但这是在本地环境中运行 Node-RED 的情况。在 IBM Cloud 上运行的情况下，这取决于云平台的环境，这是本书中的教程之一。所有代码示例都经过了 macOS、Windows 和 Raspberry Pi OS 的测试，但一些章节基于 macOS 具有命令行说明。

如果您使用的是本书的数字版本，我们建议您自己输入代码或通过 GitHub 存储库访问代码（链接在下一节中提供）。这样做将帮助您避免与复制和粘贴代码相关的任何潜在错误。

下载示例代码文件

您可以从 GitHub 上下载本书的示例代码文件github.com/PacktPublishing/-Practical-Node-RED-Programming。如果代码有更新，将在现有的 GitHub 存储库上进行更新。

我们还有来自丰富书籍和视频目录的其他代码包可供下载github.com/PacktPublishing/。快去看看吧！

下载彩色图像

我们还提供了一个 PDF 文件，其中包含本书中使用的屏幕截图/图表的彩色图像。您可以在这里下载：static.packt-cdn.com/downloads/9781800201590_ColorImages.pdf。

使用的约定

本书中使用了许多文本约定。

文本中的代码：表示文本中的代码词，数据库表名，文件夹名，文件名，文件扩展名，路径名，虚拟 URL，用户输入和 Twitter 用户名。这是一个例子：“让我们使用<h1>标签将页面标题附加到正文。”

代码块设置如下：

// generate random number
var min = 1 ;
var max = 10 ;
var a = Math.floor( Math.random() * (max + 1 - min) ) + min ;
// set random number to message
msg.payload = a;
// return message
return msg;

任何命令行输入或输出都以以下方式编写：

$ node --version
v12.18.1
$ npm –version
6.14.5

粗体：表示一个新术语，一个重要的词，或者屏幕上看到的词。例如，菜单或对话框中的单词会以这种方式出现在文本中。这是一个例子：“在选择名称和付款计划后，点击选择区域按钮。”

提示或重要说明

会出现在这样。

第一部分：Node-RED 基础

在本节中，读者将了解什么是基于流程的编程（FBP）工具，包括 Node-RED，以及如何使用它进行物联网/网络编程，并将学习如何在基本水平上使用 Node-RED 流程编辑器。

在本节中，我们将涵盖以下章节：

• 第一章，介绍 Node-RED 和基于流程的编程

• 第二章，设置开发环境

• 第三章，通过创建基本流程了解 Node-RED 特性

• 第四章，学习主要节点

第一章：介绍 Node-RED 和基于流的编程

本章将帮助您从读者成长为 Node-RED 用户。首先，您将了解基于流的编程（FBP）工具的历史，而不仅仅是 Node-RED。然后，您将对 Node-RED 的整体有一个广泛的了解，作为构建 Web 应用程序和物联网（IoT）数据处理的有用工具，然后学习有关 Node-RED 的 IoT 和 Node.js 是什么。

提供技术内容将有助于加速软件应用程序的开发，但如果您看一下 Node-RED 工具本身的历史，将有助于您更好地理解为什么您需要像 Node-RED 这样的 FBP 工具。这就是本章将要做的事情。

更具体地，我们将涵盖以下主题：

• 什么是 FBP？

• 什么是 Node-RED？

• Node-RED 的好处

• Node-RED 和物联网

让我们开始吧！

什么是 FBP？

那么，首先什么是 FBP 呢？这是您在工作中使用的工作流程，您可以很容易地想象到。让我们回顾一下这些工作流程。

工作流程

在正常的工作流程中，方框和线表示进程流程。它可能只是一个业务设计。方框代表进程。方框处理由谁、何时、何地、什么以及多少来定义。有时，它就像明确地写出处理流程，例如使用游泳道或在方框内放置写定义。无论如何，看看方框应该能够看出将要做什么。

另一方面，让我们试着将这个业务流程总结为一个文件。你不觉得会很复杂吗？即使他们使用一些段落来组合，读者会在阅读时会感到困惑。他们将在什么时候做？这可能会令人困惑：

图 1.1 – 工作流程示例

现在，让我们回到软件编程。FBP 是一种用数据流定义应用程序的软件编程概念。处理的每个部分都是一个黑盒子。它们在预定义的连接的黑盒子之间传递数据。FBP 被认为是面向组件的，因为这些黑盒子进程可以重复连接，形成多个应用程序，而无需在内部进行修改。让我们更详细地探讨 FBP。

基于流的编程（FBP）

我认为 FBP 是工作流和数据流的良好结合。FBP 使用数据工厂的隐喻来定义应用程序。它将应用程序视为一组异步进程的网络，这些进程从某一点开始，并进行单个顺序处理，一次执行一个操作，直到结束，而不是通过使用结构化数据块流进行通信。这被称为信息包（IP）。这种观点侧重于数据及其转换过程，以产生所需的输出。网络通常在进程外部定义为一组由称为调度器的软件解释的连接列表。

进程通过固定容量连接进行通信。连接通过端口连接到进程。端口具有网络定义和进程代码所约定的特定名称。在这一点上，可以通过使用多个进程执行相同的代码。特定的 IP 通常只由单个进程拥有或在两个进程之间传输。端口可以是普通类型或数组类型。

FBP 应用程序通常比传统程序运行得更快，因为 FBP 进程可以继续运行，只要有空间放入数据并输出到处理。它不需要任何特殊的编程，并且可以充分利用机器上的所有处理器。

FBP 具有高级功能风格，因此系统的行为可以很容易地定义；例如，在分布式多方协议中，如分布式数据流模型中，可以准确分析确定变量或语句是否正确行为的标准：

图 1.2 - 简单的 FBP 设计示例

现在您已经对 FBP 有了扎实的了解，让我们学习如何以这种方式实现 Node-RED。

什么是 Node-RED？

Node-RED 是我们迄今为止描述的 FBP 工具之一。由 IBM 的新兴技术服务团队开发，Node-RED 现在属于 OpenJS 基金会。

概述

FBP 是由 J. Paul Morrison 在 20 世纪 70 年代发明的。正如我们之前提到的，FBP 将应用程序的行为描述为一个黑盒网络，在 Node-RED 中被描述为“节点”。每个节点中定义了处理；数据被传递给它，使用该数据进行处理，然后将该数据传递给下一个节点。网络起到了允许数据在节点之间流动的作用。

这种编程方法非常易于使用，可以用来直观地制作模型，并且易于多层用户访问。如果将问题分解为每个步骤，任何人都可以理解流程在做什么。这就是为什么您不需要在节点内部编写代码：

图 1.3 - Node-RED 流程编辑器作为 FBP 工具

流编辑器和运行时

Node-RED 不仅是一个编程工具，还是一个封装了 Node-RED 构建的应用程序的 Node.js 运行时的执行平台。

我们需要使用流编辑器为物联网、Web 服务等制作 Node-RED 应用程序。流编辑器也是一个 Node.js Web 应用程序。我们将在第三章**，通过创建基本流程了解 Node-RED 特性中清楚地告诉您如何使用流编辑器。

流编辑器是 Node-RED 的核心功能，实际上是一个使用 Node.js 制作的 Web 应用程序。它与 Node.js 运行时一起工作。这个流编辑器在浏览器中运行。您必须从调色板中选择要使用的节点，并将其拖到工作区。连线是将节点连接在一起的过程，从而创建一个应用程序。用户（开发人员）只需点击一次即可将应用程序部署到目标运行时。

包含各种节点的调色板可以轻松扩展，因为您可以安装开发人员创建的新节点，这意味着您可以将创建的流程轻松共享为 JSON 文件。在我们探讨 Node-RED 的好处之前，让我们先看一下其创建背后的简要历史。

Node-RED 的历史和起源

在 2013 年初，来自 IBM 英国新兴技术服务团队的 Nick-O'Leary 和 Dave Conway-Jones 创建了 Node-RED。

最初，它只是一个概念验证（PoC），用于帮助可视化和理解消息队列遥测传输（MQTT）主题之间的映射，但很快，它成为了一个非常受欢迎的工具，可以轻松扩展到各种用途。

Node-RED 于 2013 年 9 月成为开源项目，现在仍然作为开源项目进行开发。它于 2016 年 10 月成为 JS 基金会的创始项目之一，后来与 Node.js 基金会合并，于 2019 年 3 月创建了 OpenJS 基金会。

OpenJS 基金会支持 JavaScript 和 Web 技术的增长，作为一个中立的组织来领导和共同资助任何项目和活动，这对整个生态系统都有益处。OpenJS 基金会目前托管了 30 多个开源 JavaScript 项目，包括 Appium、Dojo、jQuery、Node.js 和 webpack。

Node-RED 已根据 Apache 2 许可证提供，这使得它在个人和商业领域都可以广泛使用：

图 1.4 - Dave Conway-Jones 和 Nick O'Leary

为什么叫 Node-RED？

官方文档（nodered.org/about/）指出，这个名字是一个简单的双关语，听起来像“Code Red”。这是一个死胡同，Node-RED 是对它在最初几天构思时的称呼的重大改进。 “Node”部分既反映了流/节点编程模型，也反映了底层的 Node.js 运行时。

Nick 和 Dave 从未就“RED”部分代表什么达成结论。“快速事件开发人员”是一个建议，但从未被迫正式确定任何事情。因此，“Node-RED”这个名字诞生了。

Node-RED 的好处

让我们在这里思考一下。为什么要使用汽车？我认为答案非常简单明了。首先，我们可以得出答案，即它们被用作广义上的交通工具。还有其他交通选择，比如步行、骑自行车、乘火车和公交车。然后，我们有从这些其他选择中选择汽车的原因，如下所示：

• 你不会感到疲惫。

• 你可以快速到达目的地。

• 你可以按自己的步调前进。

• 你可以保持个人空间。

当然，也有一些缺点，但我认为这些是使用汽车的主要原因。虽然其他交通工具也可以达到同样的目的，但重要的是要考虑每种交通工具的优缺点，并根据你认为最适合你的原因使用汽车作为交通工具。

我们在软件中也可以看到同样的情况。例如，为什么要使用 Word、Excel 和 PowerPoint？你可能会使用 Word，因为这是写文件的最有效方式。然而，你也可以使用其他文字处理软件或手写。同样地，你可以使用其他方式制作电子表格，而不是 Excel。除了 PowerPoint，如果你想制作有效的演示材料，也有其他方式。然而，你可能会选择最适合你情况的工具。

让我们回顾一下 Node-RED 的用途。它是一个适用于为 Web 应用程序和物联网制作数据控制应用程序的 FBP 工具。它的开发环境和执行环境是基于浏览器的应用程序，使用了 Node.js，使其开发尽可能简单。

那么，使用提供这些功能的 Node-RED 的原因是什么呢？你想避免繁重的编码吗？你没有编码技能吗？当然，这些也是使用该程序的原因。

让我们回顾一下汽车的例子。在广义上，我们的困境（交通工具）在这里被开发（创建）Node.js 应用程序来描述软件工具所取代。诸如汽车、自行车、火车、公交车、船、飞机等交通选择都是选项，而在软件开发中，我们也有许多选择，比如使用 Node.js scratch，或使用 Node.js 的各种框架和使用 Node-RED。至于选择 Node-RED 的原因，让我们看一下一些重要的要点。

简化

使用 Node-RED 进行编程时，你会注意到它的简单性。正如无代码/低代码的名称所示，编码被消除，编程是通过最少的操作直观完成的。

效率

Node-RED 所代表的 FBP 几乎可以完全通过图形界面操作完成。Node-RED 流编辑器负责构建应用程序执行环境、库同步、集成开发环境（IDE）和编辑器准备，这样你就可以专注于开发。

通用

正如面向对象开发所代表的，将源代码作为一个通用组件是开发中最重要的想法之一。在基于常规编码的开发中，每个通用组件存在于函数和类中，但在 Node-RED 中，它们存在为易于理解的节点（只是一个框）。如果你没有一个作为通用组件想要使用的节点，任何人都可以立即创建一个并将其发布到世界上。

高质量

高质量是基于流程和可视化编程的真正价值。每个作为组件提供的节点都是一个经过单元测试的完整模块。因此，应用程序作者可以专注于在连接级别检查操作，而不必担心节点的内容。这是一个消除单个级别的人为错误并确保高质量的重要因素。

开源

Node-RED 是一款开源软件。因此，它可以根据 Apache2 许可灵活使用。一些人正在基于 Node-RED 开发自己的服务，而另一些人则正在更改自己的用户界面，并将其部署为内置。正如我们之前提到的，我们还建立了一个平台，可以发布我们自己开发的节点，以便任何人都可以使用它。

Node-RED 库

该库索引了所有发布到公共 npm 存储库（www.npmjs.com/）的 Node-RED 模块，假设它们遵循适当的打包指南。

这是我们看到最多社区贡献的领域，有超过 2,000 个可用的节点 - 这意味着每个人都能找到适合自己的东西：

图 1.5 - Node-RED 库

各种平台

Node-RED 可以在各种平台上使用。这是因为 Node-RED 本身是一个 Node.js 应用程序，正如我们之前提到的。如果你有一个 Node.js 的运行环境，你就可以运行它。它主要用于边缘设备、云服务和嵌入式格式。

通过理解 Node-RED 和物联网之间的关系以及物联网的架构，可以对此有所了解，这将在下一节中解释。

Node-RED 和物联网

再次强调，Node-RED 是一个虚拟环境，以革命性的方式在浏览器上结合硬件设备、API 和在线服务。它提供以下功能：

• 基于浏览器的用户界面。

• 与 Node.js 一起工作，且轻量级。

• 封装功能，可以作为节点使用（意味着功能被锁在一个抽象的胶囊中）。

• 您可以创建和添加自己的节点。

• 轻松访问 IBM 云服务。

换句话说，可以说这个工具适合构建与物联网相关的服务，比如设备上的数据控制，以及连接边缘设备和云服务。最初，Node-RED 的开发概念是为了物联网，所以这是有道理的。

现在，让我们来看一下物联网的基本结构，以便那些对物联网只有模糊概念的人能够理解。可以说，物联网基本上由六个层组成，如下图所示：

图 1.6 - 物联网六层

让我们更详细地看看这些。

设备

设备是所谓的边缘设备。物联网具有各种传感器，并处理从它们获取的数据。由于仅在边缘设备上拥有数据是没有意义的，我们需要通过网关将数据发送到网络。

网络

这是发送从设备获取的数据到互联网服务器所需的网络。通常指的是互联网。除了互联网，还可以通过蓝牙或串行进行 P2P 连接。

平台

接收和使用数据的一方是平台。我们可能还有一个用于激活和验证事物、管理通信和持久化接收到的数据的数据库。

分析

这是一个分析接收到的数据的层。广义上来说，它可以被分类为一个应用程序。这部分准备数据，使其能够以有意义的形式进行处理。

应用程序

应用程序根据数据分析结果提供特定的服务。它可以是 Web 或移动应用程序，也可以是硬件特定的嵌入式应用程序。可以说这是物联网解决方案的最终用户使用的层。

现在我们对物联网有了一定的了解，我们将探讨为什么应该使用 Node-RED。

Node-RED 和物联网

在到目前为止解释物联网的过程中，我们已经明确说明了为什么 Node-RED 适合物联网。例如，你可以理解为什么为物联网开发的 FBP 工具在与 Node-RED 一起使用时能够生存下来。特别是，应该考虑以下三点：

• 由于它可以在边缘设备上运行（预装在特定版本的树莓派 OS 上），因此非常适合在设备层进行数据处理。

• 由于它可以在云上运行（作为 IBM Cloud 中的默认服务），因此很容易与存储和分析中间件进行链接。

• 由于可以涵盖 MQTT 和 HTTP 协议，因此在边缘设备和服务器处理云之间交换数据非常容易。

这样一来，Node-RED，它主要涵盖了物联网所需的元素，现在被用于各种应用，如 Web 服务和图表显示，以及物联网的编程。此外，截至 2020 年 6 月，如果你查看 Node-RED 的 Google 趋势，你会发现用户数量在逐渐增加。因此，Node-RED 是一个非常有吸引力的 FBP 工具：

图 1.7 - "Node-RED"的 Google 趋势

可以使用 Node-RED 的典型边缘设备是树莓派。当然，也可以在其他平台上使用 Node-RED，但它与树莓派配合得很好，树莓派还预装了操作系统的版本。

树莓派 OS 支持 Node-RED

Node-RED 也已经打包到了树莓派 OS 的存储库中，并出现在他们的推荐软件列表中。这使得可以使用apt-get install Node-RED进行安装，并包括了树莓派 OS 打包版本的 Node.js，但不包括 npm。更多信息可以在nodered.org/docs/getting-started/raspberrypi找到。

IBM Cloud 是一个可以使用 Node-RED 的典型云平台。当然，你也可以在其他云上使用 Node-RED，但 IBM Cloud 提供了一个任何人都可以轻松开始使用的服务。

重要说明

Node-RED 在 IBM Cloud 平台上作为其目录中的 Starter Kits 应用程序之一可用。在 IBM Cloud 上作为 Web 应用程序使用流程编辑器非常容易（nodered.org/docs/getting-started/ibmcloud）。

摘要

在本章中，你了解了什么是 FBP 和 Node-RED。因此，你现在明白了为什么 Node-RED 目前被很多人作为 FBP 工具所喜爱和使用。在这一点上，你可能想要使用 Node-RED 构建一个应用程序。在下一章中，我们将在我们的环境中安装 Node-RED，并更深入地了解它。

第二章：设置开发环境

在本章中，您将安装使用 Node-RED 所需的工具。这不仅包括 Node-RED 本身，还包括其运行时 Node.js，以及如何更新 Node-RED 和 Node.js。

Node-RED 于 2019 年 9 月发布了 1.0 里程碑版本。这反映了该项目的成熟度，因为它已经被广泛用于生产环境。它继续开发并通过对底层 Node.js 运行时进行更改来保持最新状态。您可以在nodered.org/docs/getting-started/上检查 Node-RED 安装的最新状态。

Node-RED 官方网站上有许多安装指南，例如本地安装、树莓派、Docker 和主要云平台。

在本章中，您将学习如何在本地计算机上安装 Node-RED，无论是在 Windows、Mac 还是在树莓派上运行。我们将涵盖以下主题：

• 为 Windows 安装npm和 Node.js

• 为 Mac 安装npm和 Node.js

• 为树莓派安装npm和 Node.js

• 为 Windows 安装 Node-RED

• 为 Mac 安装 Node-RED

• 为树莓派安装 Node-RED

本章结束时，我们将安装所有必要的工具，并准备好继续使用 Node-RED 构建一些基本流程。

作为参考，作者的测试操作环境是 Windows 10 2004 18363.476、macOS Mojave 10.14.6 (18G5033)和 Raspberry Pi OS 9.4 stretch。

技术要求

本章需要安装以下内容：

• Node.js (v12.18.1)*

• npm (v6.14.5)*

*写作时的 LTS 版本。

为 Windows 安装 npm 和 Node.js

如果您想在 Windows 上使用 Node-RED，必须通过以下网站安装 npm 和 Node.js：

https://nodejs.org/en/#home-downloadhead。

您可以直接在那里获取 Node.js 的 Windows 安装程序。之后，按照以下步骤操作：

1. 访问原始 Node.js 网站并下载安装程序。

您可以选择推荐或最新功能版本，但在本书中，应使用推荐版本：

图 2.1–选择推荐版本安装程序

1. 单击下载的msi文件以开始安装 Node.js。它包括当前版本的 npm。Node-RED 在 Node.js 运行时上运行，因此需要它。

2. 只需根据安装向导的对话框按钮进行单击，尽管在安装过程中需要注意一些要点。

3. 接下来，您需要接受最终用户许可协议：

图 2.2–最终用户许可协议窗口

您还可以更改安装目标文件夹。在本书中，将使用默认文件夹（C:/Program Files/nodejs/）：

图 2.3–安装目标文件夹

1. 在下一个屏幕上不需要自定义设置。您可以只选择默认功能并单击下一步：

图 2.4–不需要自定义设置

1. 在接下来的屏幕上，您可以单击下一步而无需勾选任何内容。但是，可以在此处选择可以选择的工具进行安装。这包括安装和设置这些环境的路径（Visual C++、windows-build-tools 和 Python）：

图 2.5–本机模块工具窗口

1. 当 Node.js 安装完成后，使用以下命令检查工具的版本：

$ node --version
v12.18.1
$ npm –version
6.14.5

当 Node.js 和 npm 安装完成后，您可以检查它们的版本号。有了这些，您就可以安装 Node-RED 了。

重要提示

根据项目的不同，使用旧的 Node.js 版本进行操作是稳定的，但如果您使用不同版本的 Node.js，它可能不起作用。然而，每次切换项目都卸载当前的 Node.js 版本并安装所需的 Node.js 版本需要时间。因此，如果您使用 Windows，我建议使用 Node.js 版本管理工具，如 nodist (github.com/nullivex/nodist)。还有其他类型的 Node.js 版本控制工具，请尝试找到一个对您来说容易使用的。

为 Mac 安装 npm 和 Node.js

如果您想在 macOS 上使用 Node-RED，您必须通过以下网站安装npm和 Node.js：

https://nodejs.org/en/#home-downloadhead

您可以直接在那里获取 Mac 安装程序。

访问原始的 Node.js 网站并下载安装程序。您可以选择推荐版本或最新功能版本，但是对于本书，您应该使用推荐版本：

图 2.6-选择推荐版本的安装程序

点击您下载的.pkg文件开始安装 Node.js。它包括当前版本的npm。Node-RED 在 Node.js 运行时上运行，所以它是必需的。尽管在安装过程中有一些需要注意的地方，但只需按照安装向导进行简单点击即可。

您需要接受最终用户许可协议：

图 2.7-最终用户许可协议窗口

您可以更改安装位置。在本书中，将使用默认位置（Macintosh HD）：

图 2.8-安装位置

当 Node.js 安装完成后，您可以使用以下命令检查工具的版本。一旦安装了 Node.js 和npm，您可以检查它们的版本号。您已经准备好安装 Node-RED 了：

$ node --version
v12.18.1
$ npm –version
6.14.5

注意

根据项目的不同，使用旧的 Node.js 版本进行操作是稳定的，如果您使用不同版本的 Node.js，它可能不起作用。然而，每次切换项目都卸载当前的 Node.js 版本并安装所需的 Node.js 版本需要时间。因此，如果您使用 macOS，我建议使用 Node.js 版本管理工具，如 Nodebrew (github.com/hokaccha/nodebrew)。还有其他类型的 Node.js 版本控制工具，请尝试找到一个对您来说容易使用的。

现在我们已经介绍了 Windows 和 Mac 的安装过程，让我们学习如何为树莓派安装npm和 Node.js。

为树莓派安装 npm 和 Node.js

如果您想在树莓派上使用 Node-RED，恭喜您-您已经准备好安装 Node-RED 了。这是因为 Node.js 和 npm 已经默认安装了。您可以使用现有的安装脚本来安装 Node-RED，包括 Node.js 和 npm。这个脚本将在本章的后面部分描述，在为树莓派安装 Node-RED部分，所以您现在可以跳过这个操作。

但是，您应该检查树莓派上的 Node.js 和 npm 版本。请键入以下命令：

$ node --version
v12.18.1
$ npm –version
6.14.5

如果不是 LTS 版本或稳定版本，您可以通过 CLI 进行更新。请键入并运行以下命令来执行此操作。在这个命令中，最后一行使用了lts，但如果您想安装稳定版本，也可以将lts替换为stable：

$ sudo apt-get update
$ sudo apt-get install -y nodejs npm
$ sudo npm install npm n -g
$ sudo n lts

现在我们已经成功检查了树莓派上 Node.js 和 npm 的版本，并进行了更新（如果适用），我们将继续安装 Windows 上的 Node-RED。

重要提示

Node-RED 项目提供的脚本负责安装 Node.js 和npm。通常不建议使用由树莓派 OS 提供的版本，因为它们的打包方式很奇怪。

为 Windows 安装 Node-RED

在本节中，我们将解释如何在 Windows 环境中设置 Node-RED。此过程适用于 Windows 10，但也适用于 Windows 7 和 Windows Server 2008 R2 及更高版本。目前不支持 Windows 7 或更早版本的 Windows Server 2008 R2，也不建议使用。

对于 Windows，将 Node-RED 安装为全局模块会将node-red命令添加到系统路径中。在命令提示符中运行以下命令：

$ npm install -g --unsafe-perm node-red

安装完成 Node-RED 后，您可以立即使用 Node-RED。请运行以下命令。运行此命令后，您将识别用于访问 Node-RED 流编辑器的 URL。通常会分配 localhost（127.0.0.1）和默认端口 1880：

$ node-red
Welcome to Node-RED
===================
…
[info] Starting flows
[info] Started flows
[info] Server now running at http://127.0.0.1:1880/

让我们在浏览器上访问 Node-RED。为此，请在命令提示符中收到的 URL 中输入。我强烈建议使用 Chrome 或 Firefox 来运行 Node-RED：

图 2.9 - Node-RED 流编辑器

现在，您已经准备好在 Node-RED 中编程。从第三章，通过创建基本流了解 Node-RED 特性，开始，我们将学习如何实际构建使用 Node-RED 的应用程序。

现在，让我们继续在 macOS 中安装 Node-RED。

在 Mac 上安装 Node-RED

在本节中，我们将解释如何在 macOS 环境中设置 Node-RED。此过程适用于 macOS Mojave。它可能适用于所有版本的 Mac OS X，但我强烈建议您使用当前版本的 macOS。

对于 macOS，将 Node-RED 安装为全局模块会将node-red命令添加到系统路径中。在终端中运行以下命令。根据您的本地设置，您可能需要在命令前加上sudo：

$ sudo npm install -g --unsafe-perm node-red

您还可以使用其他工具安装 Node-RED。这主要适用于 Mac/Linux 或支持以下工具的操作系统：

1. Docker (www.docker.com/)，如果您有运行 Docker 的环境。

当前的 Node-RED 1.x 存储库在 Docker Hub 上已更名为"nodered/node-red"。

0.20.x 版本之前的版本可从hub.docker.com/r/nodered/node-red-docker获取。

$ docker run -it -p 1880:1880 --name mynodered nodered/node-red

1. Snap（snapcraft.io/docs/installing-snapd），如果您的操作系统支持。

如果您将其安装为 Snap 软件包，可以在安全容器中运行它，该容器无法访问您必须使用的外部功能，例如以下功能：

• 访问主系统存储（只允许读/写本地主目录）。

• Gcc：需要为要安装的节点编译二进制组件。

• Git：如果您想利用项目功能，则需要。

• 直接访问 GPIO 硬件。

• 访问外部命令，例如在 Exec 节点中执行的流。

容器的安全性较低，但您也可以在经典模式下运行它们，这样您就可以获得更多访问权限。

运行以下命令以使用 Snap 安装 Node-RED：

$ sudo snap install node-red

安装完成 Node-RED 后，您可以立即使用 Node-RED。请运行以下命令。运行此命令后，您可以找到用于访问 Node-RED 流编辑器的 URL。通常会分配 localhost（127.0.0.1）和默认端口1880：

$ node-red
Welcome to Node-RED
===================
…
[info] Server now running at http://127.0.0.1:1880/
[info] Starting flows
[info] Started flows

让我们在浏览器上访问 Node-RED。在命令提示符中输入您收到的 URL。我强烈建议使用 Chrome 或 Firefox 来运行 Node-RED：

图 2.10 - Node-RED 流编辑器

现在，您已经准备好在 Node-RED 中编程。在第三章，通过创建基本流了解 Node-RED 特性，我们将学习如何实际使用 Node-RED 构建应用程序。

我们的最终安装将是在树莓派上的 Node-RED。

为树莓派安装 Node-RED

在本节中，我们将解释如何在树莓环境中设置 Node-RED。此过程适用于树莓派 OS Buster（Debian 10.x），但也适用于树莓派 OS Jessie（Debian 8.x）及以上版本。

你可以轻松检查你的树莓派 OS 版本。只需在终端上运行以下命令：

$ lsb_release -a

如果您还想检查您的 Debian 版本，请运行以下命令：

$ cat /etc/debian_version

您现在已经准备好安装 Node-RED。以下脚本安装 Node-RED，包括 Node.js 和npm。此脚本也可用于升级您已安装的应用程序。

注意

此说明可能会更改，因此建议根据需要参考官方文档。

此脚本适用于基于 Debian 的操作系统，包括 Ubuntu 和 Diet-Pi：

$ bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)

您可能需要运行sudo apt install build-essential git以确保 npm 可以构建需要安装的二进制组件。

Node-RED 已经打包为树莓派 OS 存储库的一部分，并包含在推荐软件列表中。可以使用apt-get install Node-RED命令进行安装，它还包含了 Node.js 的树莓派 OS 打包版本，但不包括 npm。

虽然使用这些软件包可能一开始看起来很方便，但强烈建议使用安装脚本。

安装完成后，您可以启动 Node-RED 并访问 Node-RED 流编辑器。我们有两种启动方式，如下：

1. 通过 CLI 运行：如果您想在本地运行 Node-RED，可以在终端中使用node-red命令启动 Node-RED。然后，您可以通过按Ctrl + C或关闭终端窗口来停止它：

$ node-red

1. 通过编程菜单运行：安装完 Node-RED 后，您可以从树莓派菜单启动它。单击菜单 | 编程 | Node-RED打开终端并启动 Node-RED。启动 Node-RED 后，您可以像在 CLI 中一样从浏览器访问 Node-RED 流编辑器：

图 2.11 - 通过树莓派菜单访问 Node-RED

从菜单启动 Node-RED 后，您应该在终端上检查 Node-RED 运行进程，并找到 Node-RED 流编辑器的 URL。通常情况下，它与可以直接通过 CLI 启动的 URL 相同：

图 2.12 - 检查访问 Node-RED 流编辑器的 URL

让我们在浏览器上访问 Node-RED。您可以在命令提示符中收到的 URL 中输入。如果您的树莓派默认的 Web 浏览器是 Chromium，那么使用 Node-RED 应该没有问题。但是，如果您希望使用其他浏览器，我强烈建议安装 Chromium 来运行 Node-RED：

图 2.13 - Node-RED 流编辑器

就是这样！我们现在已经涵盖了开始使用 Node-RED 所需的每个工具的所有安装选项。

总结

在本章中，您已经准备好了环境，以便可以使用 Node-RED 流编辑器。在这一点上，我相信您已经可以访问 Node-RED 流编辑器，所以您会想要学习如何使用它。在下一章中，我们将在其中制作一个示例流，并了解 Node-RED 流编辑器的主要功能。

第三章：通过创建基本流程了解 Node-RED 特性

在本章中，我们将使用 Node-RED Flow Editor 实际创建一个流程。通过创建一个简单的流程，您将了解如何使用该工具及其特性。为了更好地理解，我们将创建一些示例流程。

从现在开始，您将使用 Node-RED 创建名为流程的应用程序。在本章中，您将学习如何使用 Node-RED 以及如何将应用程序创建为流程。为此，我们将涵盖以下主题：

• Node-RED Flow Editor 机制

• 使用 Flow Editor

• 为数据处理应用程序制作流程

• 为 Web 应用程序制作流程

• 导入和导出流程定义

在本章结束时，您将掌握如何使用 Node-RED Flow Editor，并知道如何使用它构建一个简单的应用程序。

技术要求

要完成本章，您需要以下内容：

• Node-RED（v1.1.0 或更高版本）。

• 本章的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter03文件夹中找到。

Node-RED Flow Editor 机制

正如您在之前的章节中学到的，Node-RED 有两个逻辑部分：一个称为 Flow Editor 的开发环境，用于执行在那里创建的应用程序的执行环境。它们分别称为运行时和编辑器。让我们更详细地看看它们：

• 运行时：包括 Node.js 应用程序运行时。它负责运行部署的流程。

• 编辑器：这是一个 Web 应用程序，用户可以在其中编辑他们的流程。

主要的可安装包包括两个组件，一个用于提供 Flow Editor 的 Web 服务器，另一个用于管理运行时的 REST Admin API。在内部，这些组件可以分别安装并嵌入到现有的 Node.js 应用程序中，如下图所示：

图 3.1 - Node-RED 概述

现在您了解了 Node-RED 的机制，让我们立即学习如何使用 Flow Editor。

使用 Flow Editor

让我们来看看 Flow Editor 的主要功能。

Flow Editor 的主要特点如下：

• 节点：Node-RED 应用程序的主要构建块，它们代表定义明确的功能块。

• Flow：一系列通过连线连接在一起的节点，代表消息在应用程序中经过的一系列步骤。

• 左侧面板是调色板：编辑器中可用的节点集合，您可以使用它们来构建您的应用程序。

• 部署按钮：编辑应用程序后，按此按钮部署您的应用程序。

• 侧边栏：用于显示各种功能的面板，如处理参数设置、规格和调试器显示。

• 侧边栏标签：每个节点的设置，标准输出，变更管理等。

• 主菜单：流程删除，定义导入/导出，项目管理等。

这些功能在 Flow Editor 的屏幕上排列如下：

图 3.2 - Node-RED Flow Editor

在开始使用 Node-RED 之前，您需要了解 Flow 菜单中包含的内容。其内容可能会有所不同，取决于您使用的 Node-RED 版本，但它具有一些通用的设置项，如流程项目管理、排列视图、导入/导出流程、安装库中发布的节点等。有关如何使用 Node-RED 的更多信息，可以根据需要参考官方文档。

重要提示

Node-RED 用户指南：nodered.org/docs/user-guide/。

以下图表显示了 Node-RED 中 Flow Editor 菜单选项的所有内容：

图 3.3 – Node-RED 流编辑器菜单

有了这个，你就可以使用 Node-RED 来构建一个应用程序了。所以，让我们开始吧！

首先，你需要在你的环境中运行 Node-RED。如果你还没有这样做，请参考第二章**，设置开发环境，了解如何在你的环境中设置它，比如 Windows、Mac 或树莓派。

Node-RED 运行后，让我们继续下一节，我们将制作我们的第一个流程。

制作数据处理应用程序的流程

在本节中，你将创建一个工作应用程序（在 Node-RED 中称为流程）。无论是物联网（IoT）还是作为 Web 应用程序的服务器处理，Node-RED 执行的基本操作都是顺序传输数据。

在这里，我们将创建一个流程，其中 JSON 数据是以伪方式生成的，最终通过 Node-RED 上的一些节点将数据输出到标准输出。

调色板的左侧有许多节点。请注意这里的常用类别。你应该能够很容易地找到注入节点，如下面的截图所示：

图 3.4 – 注入节点

这个节点可以将消息注入到下一个节点。让我们开始吧：

1. 将其拖放到 Flow 1（默认流程标签）的调色板上。

你会看到节点上标有时间戳这个词。这是因为它的默认消息载荷是一个时间戳值。我们可以改变数据类型，所以让我们把它改成 JSON 类型。

1. 当节点的属性面板打开时，双击节点并更改其设置：

图 3.5 – 编辑注入节点属性面板

1. 点击第一个参数的下拉菜单，选择{}JSON。你可以通过点击右侧的[…]按钮编辑 JSON 数据。

2. 点击[…]按钮，JSON 编辑器将打开。你可以用基于文本的编辑器或可视化编辑器制作 JSON 数据。

3. 这次，让我们用一个名为{"name" : "太极"}的项目来制作 JSON 数据。你应该用你的名字替换我的名字：

图 3.6 – JSON 编辑器

太棒了 - 你成功地制作了一些示例 JSON 数据！

1. 点击完成按钮并关闭此面板。

2. 同样，在调色板上放置一个调试节点。

3. 放置后，将注入和调试节点连接到它。

一旦你执行了这个流程，从注入节点传递的 JSON 数据将被调试节点输出到调试控制台（标准输出）。你不需要在调试节点上配置任何东西：

图 3.7 – 放置调试节点并连接它

1. 最后，你需要部署你创建的流程。在 Node-RED 流编辑器中，我们可以通过点击右上角的部署按钮将所有的流程部署到 Node-RED 运行时。

2. 在运行流程之前，你应该从节点菜单的侧边栏中选择调试选项卡，以启用调试控制台，如下面的截图所示：

图 3.8 – 启用调试控制台

1. 让我们运行这个流程。点击注入节点的开关，看看在调试控制台上执行流程的结果：

图 3.9 – 执行流程并检查结果

这是一个非常简单和容易的数据处理流程示例。在本书的后半部分，我们还将通过实际连接物联网设备并传递从 Web API 获取的数据来实验数据处理。在本节中，你只需要了解如何在 Node-RED 中处理数据就足够了。接下来，我们将实验制作一个用于 Web 应用程序的流程。

为 Web 应用程序制作流程

在这一部分，您将为 Web 应用程序创建一个新的流程。我们将以与创建先前的数据处理流程相同的方式创建此流程。

您可以在相同流程（Flow 1）的工作区中创建它，但为了清晰和简单起见，让我们按照以下步骤为流程创建一个新的工作区：

1. 从Flow菜单中选择Flows | Add。 Flow 2 将添加到 Flow 1 的右侧。这些流名称，如“Flow 1”和“Flow 2”，是创建时提供的默认名称。如果需要，可以重命名流程，使其具有更具体的名称：

图 3.10 - 添加新流程

1. 从调色板的network类别中选择http 输入节点，然后将其拖放到 Flow 2 的调色板上（您刚刚添加的新流程选项卡）：

图 3.11 - 一个 http 输入节点

1. 双击节点以打开其Edit对话框。

2. 输入您将要创建的 Web 应用程序的 URL（路径）。

此路径将作为您将要创建的 Web 应用程序的 URL 的一部分，位于 Node-RED URL 下。在这种情况下，如果您的 Node-RED URL 是http://localhost:1880/，您的 Web 应用程序 URL 将是http://localhost:1880/web。可以在以下截图中看到示例：

图 3.12 - 设置 URL 的路径

1. 要通过 HTTP 发送请求，需要一个 HTTP 响应。因此，在 Node-RED 的工作区上放置一个http 响应节点。

您可以在调色板的network类别中找到此节点，位于http 输入节点旁边。在这里，http 响应节点只是返回响应，因此您无需打开配置面板。您可以将其保留不变。如果要在响应消息中包含状态代码，可以从settings面板中进行设置，如下截图所示：

图 3.13 - 一个 http 响应节点

1. 在调色板上放置http 响应节点后，从http 输入节点添加一根导线到http 响应节点。

这完成了 Web 应用程序的流程，因为我们已经允许了 HTTP 请求和响应。您将在每个节点的右上角看到一个浅蓝色的点，表示它们尚未部署 - 因此，请确保单击Deploy按钮：

图 3.14 - 连接的节点

1. 一旦成功部署，打开浏览器中的新标签页。

2. 然后，访问显示在http://localhost:1880/web中的 Web 应用程序的 URL。

您会发现屏幕上只显示{}。这不是错误。这是发送 HTTP 请求并返回响应的结果。现在，由于我们尚未设置要传递给响应的内容，因此将空 JSON 作为消息数据传递。如下所示：

图 3.15 - Web 应用程序结果

这并不好，所以让我们创建一些内容。让我们做一些非常简单的事情，并实现一些简单的 HTML 代码。那么我应该在哪里编写这个？答案很简单。Node-RED 有一个模板节点，允许您将 HTML 代码指定为输出。让我们使用这个：

1. 将一个模板节点拖放到http 输入节点和http 响应节点之间的导线上，以便模板节点将连接到它：

图 3.16 - 在我们现有的两个节点之间的导线上放置“模板”节点

1. 接下来，双击<h1>标签。使用<h2>标签排列类似菜单的内容。代码将如下所示：

<html>
  <head>
    <title>Node-RED Web sample</title>
  </head>
  <body>
    <h1>Hello Node-RED!!</h1>
    <h2>Menu 1</h2>
    <p>It is Node-RED sample webpage.</p>
    <hr>
    <h2>Menu 2</h2>
    <p>It is Node-RED sample webpage.</p>
  </body>
</html>

注意

您还可以从本书的 GitHub 存储库中获取此代码github.com/PacktPublishing/-Practical-Node-RED-Programming/tree/master/Chapter03。

1. 完成模板节点的编辑后，单击完成按钮关闭它。

以下屏幕截图显示了您编辑模板节点时的外观：

图 3.17-模板区域中的代码

有了这个，我们已经完成了准备要显示在我们页面上的 HTML。请确保再次单击http://localhost:1880/web。现在您应该看到以下输出：

图 3.18-Web 应用程序的结果

此时，您应该了解如何在 Node-RED 上制作 Web 应用程序。我想到目前为止一切都很顺利。现在我们已经积累了一些动力，让我们继续学习。在下一节中，我们将导入和导出我们创建的流程定义。

导入和导出流程定义

在这一部分，您将导入和导出您创建的流程定义。通常，在开发时，需要备份源代码和版本控制。您还可以导入他人创建的源代码，或者导出自己的源代码并传递给他人。Node-RED 有类似的概念。在 Node-RED 中，导入和导出流本身是一种正常的做法，而不是导入或导出源代码（例如，前面描述的模板节点）。

因此，首先让我们导出到目前为止创建的流程。这很容易做到：

1. 只需在 Node-RED Flow Editor 的Main菜单下的Edit对话框中选择导出。

当显示导出菜单时，您只能选择当前流或所有流。您还可以选择原始 JSON（无缩进）或格式化 JSON（带缩进）。

1. 在这里，选择当前流并选择格式化。

2. 现在，您可以选择如何保存导出的 JSON 数据-在计算机的下载位置中保存flows.json。

3. 在文本编辑器中打开此文件，以便检查 JSON 文件的内容。

有了这个，我们已经学会了如何导出。

接下来，我们需要将此定义（flows.json）导入到我们的 Node-RED Flow Editor 中。请按照以下步骤操作：

1. 只需在 Node-RED Flow Editor 的Flow菜单中选择导入。

显示导入菜单时，您可以选择粘贴流 json或选择基于文件的导入。您还可以从流选项卡中选择当前流或新流。如果选择新流，将自动添加一个新的流选项卡。

1. 在这里，请选择您导出到本地计算机的flows.json。

2. 文件加载完成后，单击导入按钮：

图 3.20-导入操作

1. 现在，您有了新的选项卡，名称为 Flow 2，与旧的 Flow 2 选项卡上相同的流。它已完全导入，但尚未部署，因此请单击部署按钮，如下所示：

图 3.21-添加新流

有了这个，我们已经成功地准备好了我们导入的流程将显示在我们的网页上。请确保单击部署按钮。

1. 通过转到http://localhost:1880/web再次访问网页。

在这里，您将看到此网页与您导出的网页具有相同的设计。干得好！

图 3.22-Web 应用程序的结果

现在，让我们结束这一章。

摘要

在本章中，您学习了如何使用 Node-RED Flow Editor 制作基本流程并导入/导出流程。现在您已经知道如何使用 Node-RED Flow Editor，您会想要了解更多其功能。当然，Node-RED 不仅具有诸如Inject、http和template等基本节点，还有更吸引人的节点，如switch、change、mqtt和dashboard。在下一章中，我们将尝试使用几个主要节点，以便我们可以编写 JavaScript，捕获错误，执行数据切换，延迟功能，使用 CSV 解析器等。

第四章：学习主要节点

在本章中，您将了解 Node-RED 中使用的主要节点。Node-RED 是一个开源项目，默认情况下提供了一些主要节点，但可以根据需要导入和使用来自公共库的节点。

Node-RED 有很多节点。因此，本书不足以解释所有这些节点。因此，在本章中，让我们挑选主要节点和最常用的基本节点，并学习如何使用它们，探索本章中的这些主题：

• 什么是节点？

• 如何使用节点

• 从库中获取各种节点

在本章结束时，您将掌握如何在 Node-RED 流编辑器中使用主要节点。

技术要求

要在本章中取得进展，您需要以下技术要求：

• Node-RED（v1.1.0 或更高版本）。

• 本章中使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter04文件夹中找到。

什么是节点？

首先让我们了解 Node-RED 中的节点到底是什么。

Node-RED 是一个使用图形用户界面（GUI）工具编程 Node.js 应用程序的工具。Node-RED 还作为在 Node-RED 上编程的软件（Node-RED Flow）的执行环境。

通常，在使用 Node.js 进行编程时，源代码是用代码编辑器或集成开发环境（IDE）编写的。通过构建编写的源代码（编译，与依赖文件关联等），生成可执行文件。

在 Node-RED 上进行可视化编程基本上遵循相同的过程。不同之处在于，编码部分是将节点放置在 Node-RED 上，而不是编辑器。

在 Node-RED 中，使用 Node.js 编程时提供的基本处理由称为节点的实现部分提供。在正常的面向对象编程中，这些部分通常以常见部分的形式提供为库文件。

由于 Node-RED 是基于 GUI 的可视化编程工具，这些常见部分不仅仅是库文件。这些常见部分形状像盒子，在 Node-RED 中称为节点。此外，除了一些节点外，通常在编程时，节点可以将可以作为节点属性的变量（参数，参数等）设置为节点属性。

换句话说，由于已经编程了部分（节点），因此只需将它们放置在 GUI 中即可完成编程。以下图比较了纯 Node.js 编程与在 Node-RED 中创建流的情况：

图 4.1 – Node-RED 与 Node.js 编程

现在您了解了 Node-RED 和节点的概念，让我们更仔细地看看节点。

当您启动 Node-RED 时，基本处理节点默认提供在 Node-RED 流编辑器中。这称为预安装节点。

以下是预安装节点的典型类别：

• 常见：这包括将特定数据注入流的节点，判断处理状态的节点以及用于调试输出日志的节点。

• 功能：这包括可以直接在 JavaScript 和 HTML 中编写的节点，可以转换参数变量的节点以及根据这些参数的内容进行条件分支的节点。

• 网络：这包括处理通信所需的协议处理的节点，如 MQTT，HTTP 和 WebSockets。

当然，这里给出的示例只是一小部分。实际上有许多更多的类别和节点。

重要提示

预安装的节点也取决于 Node-RED 版本。建议查看官方文档以获取有关您的 Node-RED 版本的信息：nodered.org/docs/。

节点在 Node-RED 流程编辑器中排列像零件一样，并且可以通过简单连接电线来使用。如前所述，除了一些节点外，您不必自己编写代码。

基本上，流程编辑器看起来像一个框，里面有一个设置窗口。在设置窗口中，您可以为每个节点设置所需的参数和配置：

图 4.2 - 节点

这就是您需要了解的有关节点的所有概念。在下一节中，您将学习如何实际使用节点。

如何使用节点

在本节中，我们将学习如何使用节点。

在 Node-RED 中进行可视化编程与其他可视化编程工具有些不同，因为它使用基于流的编程。但请放心，这一点并不难。如果您实际创建了一些简单的流程，您应该能够掌握如何在 Node-RED 中使用节点。

因此，现在让我们使用一些典型的预安装节点创建一个示例流程。树莓派、Windows 和 macOS 系统的环境是相同的。请使用您喜欢的环境。

常见类别

让我们介绍一下我们将用来制作流程的节点。您可以从常见类别中将所有节点放置在调色板上。

使用常见类别中的节点创建一个示例流程。使用以下四个节点：

• inject节点

• complete节点

• catch节点

• debug节点

请按照以下图示放置和连接节点：

图 4.3 - 具有常见类别节点的流程

这里inject节点中的数据是简单的 JSON 数据。双击放置的inject节点以打开设置面板并设置 JSON 数据。请参考以下内容：

{"name":"Taiji"}

您可以更改inject节点中的 JSON 数据以发送您想要发送的数据。此外，您应该设置complete节点的属性。打开设置面板并设置一个节点来观察状态。

将每个节点的参数设置如下：

• 使用以下 JSON 创建msg.payload：

{"name": "Taiji"}

您可以在这里设置任何值：

图 4.4 - 用于插入数据的注入节点

• complete节点：

检查属性选项卡的第一个选项以观察inject节点的状态：

图 4.5 - 用于观察状态的完整节点

其他节点的属性无需更改。

设置更改后，您需要部署并单击inject节点的按钮。之后，您可以在debug选项卡的右侧面板中看到 JSON 数据。

您可以从本书的 GitHub 存储库中获取流程定义github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter04/common-flows.json。

函数类别

在本节中，我们将学习如何使用函数类别中的一些主要节点，并将使用这些节点制作一个流程。

使用函数类别中的节点创建一个示例流程。在这里，我们将使用以下六个节点：

• inject节点

• function节点

• switch节点

• change节点

• template节点

• debug节点

请按照以下图示放置和连接节点：

图 4.6 - 具有函数类别节点的流程

请按照以下步骤制作流程：

1. 将inject节点和debug节点放置在调色板上。这两个节点可以使用其默认参数。这里不需要更改设置。

2. 在调色板上放置一个function节点。

3. 打开function节点的设置面板，并输入以下代码：

// generate random number
var min = 1 ;
var max = 10 ;
var a = Math.floor( Math.random() * (max + 1 - min) ) +   min ;
// set random number to message
msg.payload = a;
// return message
return msg;

1. 编码后，点击Done保存设置：

图 4.7–功能节点设置

1. 放置6

2. 5

应该如下所示：

图 4.8–开关节点设置

如果输入参数为5或更少，则输出路由为1，如果输入参数为6或更多，则输出路由为2。这意味着下一个节点取决于输入参数的数量。

1. 在调色板上放置两个template节点。

之前的功能是switch节点，因此数据根据输出结果而分割。

1. 打开switch节点的每个1的设置面板：

The number is small: {{payload}} !

一旦我们添加了前面的代码，template节点将看起来像以下屏幕截图：

图 4.9–第一个模板节点设置

1. 输入第二个2的switch节点的以下代码：

The number is big: {{payload}} !

它将看起来像以下屏幕截图：

图 4.10–第二个模板节点设置

1. 将change节点放置在调色板上，打开change节点的设置面板，并查看规则下方的设置框。

2. 从to旁边的下拉菜单中选择string，并在旁边的文本框中输入所需的字符串。这里写着已更改为字符串数据！。请参考以下屏幕截图：

图 4.11–更改节点设置

1. 更改设置后，您需要部署并单击inject节点的按钮。

一旦您这样做，您可以在右侧面板的调试选项卡中看到数据，如下所示：

图 4.12–在调试选项卡中显示结果

第一个调试消息是默认的inject节点值作为时间戳。第二个是change节点后放置的debug节点的调试消息。最后一个取决于随机数，并由template节点格式化。

您可以从书的 GitHub 存储库中获取流程定义：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter04/function-flows.json。

接下来，让我们了解一些默认未提供的节点。

从库中获取几个节点

您可以获得由 Node-RED 贡献者开发的几个更有吸引力的节点，并将它们安装在您的 Node-RED 流编辑器中。您可以找到新节点，分享您的流程，并查看其他人如何使用 Node-RED。在本节中，我们将学习如何从 Node-RED 库中获取几个其他节点。让我们首先访问 Node-RED 库站点：flows.nodered.org/。在以下屏幕截图中，您可以看到 Node-RED 库的外观：

图 4.13–Node-RED 库

在您自己的 Node-RED 环境的流编辑器中使用此库非常容易。让我们看看如何从库中安装节点：

1. 从侧边栏菜单中选择管理调色板。您将看到用户设置面板打开，并选择了调色板选项卡。

2. 在搜索字段中键入watson，或者您想要使用的任何其他节点的名称。如果找到想要的节点，请单击安装按钮：

图 4.14–打开用户设置面板并找到要使用的节点

1. 单击安装按钮后，将出现一个弹出窗口，您需要再次单击安装。

一旦您这样做并且安装完成，您将收到一个弹出消息，上面写着节点已添加到调色板。

就是这样！你可以在调色板中看到你安装的所有节点，如下图所示：

图 4.15 - 你安装的节点被添加到你的调色板中

提示

你可以在 Node-RED 库网站上搜索有用的节点。可以通过关键词搜索，并按照最近添加、下载次数和评分进行排序。我建议首先按下载次数排序，因为被许多开发者下载的节点很可能非常有用：flows.nodered.org/search?type=node&sort=downloads。

现在你已经成为了一个优秀的 Node-RED 用户，并且掌握了如何使用 Node-RED 流编辑器制作一些流程（应用程序）。

总结

在本章中，你学会了如何在 Node-RED 流编辑器中使用每个主要节点。你已经成功地制作了你的 Node-RED 流程！你在这里创建的流程步骤是你将来需要创建各种流程的大部分步骤。

本章学到的重要一点是，每个节点都有自己独特的特性。通过像拼图一样组合它们，我们可以创建一个类似于通过常规编程创建的应用程序的流程。

在下一章中，让我们为物联网边缘设备创建一个更实用的示例流程（应用程序）。

第二部分：掌握 Node-RED

在这一部分，读者将使用 Node-RED 流编辑器实际创建一个应用程序。他们将首先学习如何为每个主要环境（即树莓派、桌面和云等独立环境）创建一个示例流，而不是试图从头开始构建高级应用程序。

在这一部分，我们将涵盖以下章节：

• 第五章, 本地实现 Node-RED

• 第六章, 在云中实现 Node-RED

• 第七章, 从 Node-RED 调用 Web API

• 第八章, 使用 Git 的项目功能

第五章：本地实现 Node-RED

在本章中，让我们使用独立版本的 Node-RED。Node-RED 包括开发环境、执行环境和应用程序本身。您可以通过在本地环境中运行的独立版本来理解其机制。

具体来说，启动独立版本的 Node-RED 最常见的原因是在物联网边缘设备上使用它。物联网边缘设备通常具有传感器，这些传感器通常应用于“物联网”的“物”部分。在本章中，我们将查看边缘设备内的传感数据并创建一个示例流程。

让我们从以下四个主题开始：

• 在本地机器上运行 Node-RED

• 使用独立版本的 Node-RED

• 在边缘设备上使用物联网

• 创建一个示例流程

在本章结束时，您将学会如何构建处理物联网设备传感器数据的流程。

技术要求

要完成本章，您需要以下内容：

• Node-RED（v1.1.0 或更高版本）：nodered.org/

• 树莓派：www.raspberrypi.org/

本章中使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter05文件夹中找到。

在本地机器上运行 Node-RED

现在我们可以为物联网边缘设备上的传感数据创建流程，在这种情况下，本地机器使用的是树莓派。关于这一点将在使用独立版本的 Node-RED部分中描述，但总的来说，本教程是为物联网边缘设备而设计的。

我已经解释了如何在树莓派上启动 Node-RED，所以您现在应该知道如何运行它，但如果您需要复习，请参考第二章中的为树莓派安装 Node-RED部分，设置开发环境。

现在，按照以下步骤在您的树莓派上启动 Node-RED：

1. 让我们从树莓派菜单中执行 Node-RED 开始：

图 5.1 – 从树莓派菜单中运行 Node-RED

1. 您可以在终端上检查 Node-RED 的状态。如果显示Started flows，则 Node-RED 已准备就绪：

图 5.2 – 树莓派终端

1. 您可以通过localhost:1880 URL 访问 Node-RED 流程编辑器：

图 5.3 – Node-RED 流程编辑器

在使用流程编辑器之前，让我们学习一些概念。

使用独立版本的 Node-RED

现在我们将学习独立版本的 Node-RED 是什么，以及它与其他版本有何不同。通常我们使用 Node-RED 流程编辑器作为独立编辑器；然而，我们也可以在任何具有 Docker、Kubernetes 或 Cloud Foundry 等容器技术的云上使用 Node-RED 流程编辑器。我们将明确演示使用独立版本的用例，以学习如何使用它。

让我们思考一下 Node-RED 被使用的情况。

Node-RED 是用 Node.js 创建应用程序的工具。它也是执行环境。如果你能用 Node.js 编写应用程序，那就没问题。

那么，为什么要使用 Node-RED 构建应用程序呢？

一个答案是将每个数据处理单元视为黑匣子。这使得每个过程的作用非常清晰，易于构建和维护。

另一个答案是避免人为错误。由于每个过程都被模块化为一个节点，因此在使用该过程时，您只需要了解输入/输出规范。这意味着您可以避免人为错误，如编码错误和缺少测试规范。这也可以是无代码/低代码以及 Node-RED 的优势。

接下来，想象一个使用 Node-RED 的具体情况，具有刚刚描述的特征。

考虑一个控制数据并将其连接到下一个流程的业务逻辑。这在物联网解决方案中很常见。

物联网解决方案的标准架构是由边缘设备和云平台构建的。它将边缘设备获取的传感器数据发送到云端，然后在云端处理数据，如可视化、分析和持久化。

在本章中，我想专注于边缘设备部分。

边缘设备通常希望在将获取的传感器数据发送到云端之前对其进行一定程度的准备。这样做的原因是，如果您发送所有获取的数据，存在网络过载的风险。

因此，独立的 Node-RED 练习使用了树莓派，这是一个著名的物联网基础设施。

在本章中，我们将使用树莓派和 Grove Base 模块的Grove Base HAT。这是物联网边缘设备平台的标准之一，因此我们需要将 Grove Base 驱动程序安装到树莓派上。

重要提示

本章提供了一个使用 Grove Base HAT 的示例，这是相对便宜且可以购买的（链接在下一节中提到），但是任何可以连接到树莓派并在 Node-RED 上处理数据的传感器设备都可以处理数据。

当使用除 Grove Base HAT 传感器设备以外的模块时，请使用相应的节点并阅读本章。（如果没有相应的节点，则需要进行实现。）

您可以检查 Node-RED 库以查看是否存在与每个设备对应的节点：

flows.nodered.org/

让我们通过以下步骤准备在树莓派上使用 Grove Base HAT：

1. 让我们从在树莓派上执行以下命令开始：

 $ curl -sL https://github.com/Seeed-Studio/grove.py/raw/master/install.sh | sudo bash -s -

1. 如果一切顺利，您将看到以下通知：

图 5.4 – 成功安装 grove.py

1. 接下来的步骤是启用 ARM I2C。我们可以通过执行以下命令来实现：

 $ sudo raspi-config

1. 执行完命令后，您将看到以下配置窗口。请选择接口选项：

图 5.5 – 软件配置工具

1. 选择I2C：

图 5.6 – 启用 I2C

1. 选择后，同一窗口将显示是否要启用 ARM I2C 接口？消息。请选择是以接受它。

您现在已成功启用了 I2C。重新启动树莓派并重新启动 Node-RED 流编辑器。通过这样做，您的树莓派已经可以使用 I2C 接口，下一步，我们需要通过 I2C 接口连接传感器设备和树莓派。

在边缘设备上使用物联网

现在让我们考虑物联网中边缘设备的案例研究。

物联网最近在几个行业中得到了采用，例如天气预报和农业领域；但是，基本构成是相同的。边缘设备获取的各种数据被发送到服务器端平台，如云端，并且数据在服务器端进行处理和可视化，这是充满资源的。有各种各样的可视化方式，但在最简单的情况下，将必要的数据值输出到日志作为标准输出。

在本章中，我想考虑物联网用例中的边缘设备部分。这是关于在传感器模块使用获取的传感器数据在去往服务器端进行格式化和缩小之前进行处理。

有哪些不同类型的传感器？

以下传感器通常在物联网的实验级别上使用：

• 温度

• 湿度

• 陀螺仪（加速度，角速度）

• 光

• 声音

• 压敏

• 磁性

在这里，我们将考虑使用光传感器和温度/湿度传感器将获取的值输出到日志的用例。

为了获取传感器数据，您需要一个设备。在这个示例流程（应用程序）中，使用的是树莓派，但它没有传感功能，因为它只是一个基础。使用老式的板，您必须焊接传感器设备/模块，但树莓派的方便之处在于有许多传感器模块套件可以一键连接。

如前所介绍的，我们将使用 Seeed 提供的 Grove 系列，该系列具有树莓派的传感器模块和连接板：wiki.seeedstudio.com/Grove_Base_Hat_for_Raspberry_Pi/

让我们准备树莓派的 Grove Base HAT 模块。

重要提示

如果您没有树莓派的 Grove Base HAT 并且想要运行本教程，请通过官方网站购买（www.seeedstudio.com/Grove-Base-Hat-for-Raspberry-Pi.html）。

这就是用于树莓派的 Grove Base HAT 的样子：

图 5.7 – 用于树莓派的 Grove Base HAT

我们需要将 Grove Base HAT 和传感器模块连接到树莓派。要做到这一点，请按照以下步骤进行：

1. 将 Grove Base HAT 放在树莓派上并拧紧：

图 5.8 – 将 Base HAT 设置在您的树莓派上

这就是 Grove - 光传感器 v1.2 - LS06-S 光电晶体管的样子：

图 5.9 – Grove - 光传感器 v1.2

您可以从www.seeedstudio.com/Grove-Light-Sensor-v1-2-LS06-S-phototransistor.html获取它。

1. 将 Grove 光传感器连接到 Base HAT 的模拟端口：

图 5.10 – 将光传感器连接到您的 Base HAT

重要提示

请注意！这家供应商Seeed有一个类似的温湿度传感器SHT35，但它不受 Grove Base HAT 节点支持。您需要使用SHT31。

这就是 Grove - 温湿度传感器（SHT31）的样子：

图 5.11 – Grove – 温湿度传感器（SHT31）

您可以从www.seeedstudio.com/Grove-Temperature-Humidity-Sensor-SHT31.html获取它。

1. 将 Grove 温湿度传感器连接到 Base HAT 的 I2C 端口：

图 5.12 – 将温湿度传感器连接到您的 Base HAT

就是这样。现在您的设备已经设置好，我们准备进行下一步！在这一部分，我们已经了解了物联网边缘设备的流行简单用例，接下来，我们将为这些用例制作一个流程。

制作一个示例流程

在本节中，我们将在 Node-RED 流编辑器中创建这两个传感器数据输出流。

您将使用准备好的传感器模块收集数据，并创建一个示例流程，在 Node-RED 上将其可视化。通过使用两种不同的传感器模块，我们可以学习 Node-RED 中的数据处理基础知识。

用例 1 – 光传感器

第一个是光传感器。让我们创建一个流程（应用程序），检测光线并将固定点观察到的值输出到日志：

图 5.13 – 用例 1 – 获取光传感器数据

将光传感器模块连接到树莓派，并使用树莓派上的 Node-RED 流编辑器将获取的数据输出为标准输出。

用例 2 – 温湿度传感器

第二个是温度/湿度传感器。让我们创建一个应用程序（流），用于检测温度和湿度，并将通过固定点观察检测到的值输出到日志：

图 5.14 – 用例 2 – 获取温度/湿度数据

将温度/湿度传感器模块连接到树莓派，并使用树莓派上的 Node-RED 流程编辑器将获取的数据输出为标准输出。

如果您想在设备上对这两个用例进行现场测试，需要连接一个传感器，以获取传感器数据。

在创建流程之前，您可能需要准备这个。

这次，我们将使用 Grove Base HAT，它很容易与树莓派一起使用，由于上一步已经完成了设置，我们已经准备好在树莓派上访问数据。但是，我们还没有准备好 Node-RED。默认情况下，使用 Node-RED 访问这些数据是困难的。一种方法是使用 Function 节点并从头开始编写脚本，这非常困难但并非不可能。

为了处理 Raspberry Pi 在 Node-RED 上识别的传感器数据，需要一个专门用于 Grove Base HAT 的“节点”。

好消息是，您可以立即开始使用该节点。这是因为田中正吾（Seigo Tanaka）是 Node-RED 用户组日本董事会成员（nodered.jp/）和 Node-RED 贡献者，已经创建并发布了一个用于 Grove Base HAT 的节点。这是用于树莓派的 Grove Base HAT 节点：

node-red-contrib-grove-base-hat

您可以在这里了解更多信息：www.npmjs.com/package/node-red-contrib-grove-base-hat。

如果您需要复习如何安装发布在节点库中的节点，请阅读第四章中的从库中获取多个节点部分。

我之所以提到这一点，是因为下一步是将 Grove Base HAT 节点从库中安装到您的环境中。

让我们在 Node-RED 流程编辑器中启用 Grove Base HAT 节点：

1. 单击右上角的菜单，选择管理调色板以打开设置面板：

图 5.15 – 选择管理调色板

1. 打开设置面板后，在搜索窗口中输入您想要使用的节点名称。我们想要使用node-red-contrib-grove-base-hat，所以请键入以下内容：

grove base

1. 之后，您可以在搜索窗口中看到node-red-contrib-grove-base-hat节点。单击安装按钮：

图 5.16 – 安装 node-red-contrib-grove-base-hat 节点

1. 单击安装按钮后，您将看到一条消息，要求您阅读文档以了解有关此节点的更多信息。如有必要，请阅读文档，然后单击消息框上的安装按钮：

图 5.17 – 读取节点文档的消息窗口

现在您已经准备好使用 Grove Base HAT 节点了。检查流程编辑器中的调色板。在调色板底部，您可以看到已添加了 Grove Base HAT 节点：

图 5.18 – 仪表板上的 Grove Base HAT 节点

Grove Base HAT 可以连接许多传感器模块。这次只使用了光线和温度/湿度传感器，但通过查看节点类型，还可以看到其他东西。

在这里创建的两个用例所遵循的程序也可以应用于使用其他传感器时。如果感兴趣，请尝试其他传感器。在下一节中，我们将为用例 1 创建一个流程。

为用例 1 制作流程 – 光传感器

在用例 1 中，Node-RED 可以用来处理从光传感器获取的光照强度作为 JSON 数据。该数据可以被处理为 JSON 数据，然后发送到服务器端，各种处理可以在边缘设备上轻松进行。

从光传感器获取的数值被 Node-RED 接收，并且输出为调试日志（标准输出）。我们可以通过以下步骤设置这一点：

1. 从流编辑器左侧的调色板中选择grove light sensor v1_2节点，然后将其拖放到工作区中放置：

图 5.19 – grove light sensor v1_2

该节点允许传感器设备的值，通过 Raspberry Pi 通过 Grove Base HAT 持续获取，被处理为 Node-RED 上的 JSON 格式消息对象。

1. 在放置grove-light-sensor-v1_2节点后，放置inject节点和debug节点，并将它们连接，使得您放置的grove-light-sensor-v1_2节点被夹在它们之间：

图 5.20 – 放置节点并为光传感器连接它们

1. 接下来，检查grove-light-sensor-v1_2节点的设置。双击节点打开设置面板。

2. 在设置面板中有一个名为Port的选择项。A0是默认选择项。

这个Port设置是为了指定 Grove Base HAT 上的哪个连接器从连接的模块获取数据。

1. 早些时候，我们将 Grove 光传感器连接到了 Grove Base HAT。如果按照本教程中的步骤进行连接，它应该连接到 A2 端口，因此选择A2作为节点设置值。如果连接到另一个端口，请选择您要连接的端口：

图 5.21 – 如果您将传感器连接到 Base HAT 的 A2，则选择 A2 作为端口

1. 在设置面板上检查和设置Port后，点击右上角的Done按钮关闭设置面板。

就是这样！不要忘记点击deploy按钮。

您应该记住如何从 inject 节点执行流程，因为您在上一章中学习了这个。点击 inject 节点上的开关来运行流程。当点击开关时的时间数据被输出为日志，所以请尝试点击几次。

重要提示

不要忘记显示调试窗口，以显示获取数据的值将输出到调试窗口。即使调试输出被激活，Node-RED 也不会自动显示调试窗口。

debug窗口中的输出结果如下：

图 5.22 – 光传感器流的结果

您可以看到结果输出到debug窗口。

恭喜！通过这个，我们成功地创建了一个处理第一个光传感器值的基本流程（应用程序）与 Node-RED。

您也可以在这里下载流程定义文件：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter05/light-sensor-flows.json。

为用例 2 制作流程 – 温湿度传感器

在用例 2 中，Node-RED 可以用来处理从温湿度传感器获取的温度和湿度作为 JSON 数据。这些数据可以被处理为 JSON 数据，然后发送到服务器端，各种处理可以在边缘设备上轻松进行。

从温湿度传感器获取的数值被 Node-RED 接收，并且输出为调试日志（标准输出）：

1. 从流程编辑器左侧的调色板中选择 grove temperature humidity sensor sht3x 节点，然后将其拖放到工作区中放置：

图 5.23 - grove temperature humidity sensor sht3x

这个节点允许将在树莓派上通过 Grove Base HAT 持续获取的传感器设备的值作为 JSON 格式的消息对象在 Node-RED 上处理。

1. 放置 grove-temperature-humidity-sensor-sht3x 节点后，分别放置 inject 和 debug 节点，并将它们连接起来，使得您放置的 grove-temperature-humidity-sensor-sht3x 节点被夹在它们之间：

图 5.24 - 放置节点并为温湿度传感器连接线路

1. 接下来，检查 grove-temperature-humidity-sensor-sht3x 节点的设置，并双击节点打开设置面板。

实际上，这个节点没有要设置的值（严格来说，可以设置名称，但这个设置的有无不影响操作）：

图 5.25 - 已设置为 I2C 端口

您可以在设置面板上看到端口被指定为 I2C（不可更改）。如果您按照本文档中的步骤将 Grove 温湿度传感器连接到 Grove Base HAT，模块应正确连接到 I2C 端口。如果它连接到除 I2C 之外的端口，请重新正确连接。

1. 在设置面板上检查 端口，然后点击右上角的 完成 按钮关闭设置面板。

就是这样！不要忘记点击 部署 按钮。

1. 点击注入节点上的开关以运行流程。当点击开关时的时间数据将作为日志输出，所以请尝试点击几次。

重要提示

如前所述，请不要忘记显示调试窗口，以显示获取数据的值将作为输出显示在调试窗口中。即使启用了调试输出，Node-RED 也不会自动显示调试窗口。

调试 窗口中的输出如下所示：

图 5.26 - 温湿度传感器流程的结果

您可以看到结果被输出到 调试 窗口。

恭喜！通过这个，我们已经成功创建了一个基本的流程（应用程序），用 Node-RED 处理第二个样本，即温湿度传感器的数值。

您也可以在这里下载这个流程定义文件：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter05/light-sensor-flows.json。

干得好！现在您已经学会了如何在 Node-RED 上处理以 JSON 格式获得的光照传感器和温湿度传感器的数据。

总结

在本章中，您学会了如何通过将 Node-RED 与真实的 IoT 用例进行比较来创建一个样本流程（应用程序）。我们通过使用传感器模块和树莓派与 Node-RED 交换数据，对 IoT 有了一定的了解。

在这里创建的流程步骤将帮助您将来在边缘设备中使用其他传感器模块创建不同的流程。

在下一章中，我们将像这次一样使用 IoT 用例，但我们将在云端（服务器端）创建一个实际的样本流程（应用程序）。

第六章：在云中实现 Node-RED

在本章中，我们将学习如何利用 Node-RED，在云平台上（主要是作为服务的平台）独立使用。作为服务的平台（PaaS）提供了一个作为应用执行环境的实例，应用开发人员只需专注于执行自己创建的应用，而不用耗费精力构建环境。Node-RED 实际上是一个 Node.js 应用，因此您可以在任何具有 Node.js 运行时环境的地方运行它。

有各种主要的大型云，如 Azure、AWS 和 GCP，但 Node-RED 在 IBM Cloud 中默认准备了一个入门应用（在 IBM Cloud 上可以启动的 Web 应用称为入门应用），所以我们将在本章中使用它。

在本章中，我们将涵盖以下主题:

• 在云上运行 Node-RED

• 在云中使用 Node-RED 的具体情况是什么？

• 服务器端的物联网案例研究

• 创建一个示例流程

在本章结束时，您将掌握如何在云上构建处理传感器数据的流程。

技术要求

本章中使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter06文件夹中找到。

在云上运行 Node-RED

这次我们将使用 IBM Cloud。原因是 IBM Cloud 上有 Node-RED Starter Kit。这是一种软件样板，包括 Node-RED 在云上所需的服务，如数据库、CI/CD 工具等。

如果您还没有使用过 IBM Cloud，不用担心 - IBM 提供免费的 IBM Cloud 账户（Lite 账户），无需注册信用卡。您可以在ibm.biz/packt-nodered注册 IBM Cloud Lite 账户。

在 IBM Cloud 上使用 Node-RED 之前，您需要完成 IBM Cloud Lite 账户的注册流程。

重要提示

在本书中，我们强烈建议您在使用 IBM Cloud 时选择 Lite 账户。您可以随意从 Lite 账户升级到标准账户（PAYG/按使用付费），这意味着您可以通过注册信用卡自动升级到 PAYG。

请注意，使用 Lite 账户可以免费使用的服务，在 PAYG 中可能会收费。

现在，让我们按照以下步骤在 IBM Cloud 上启动 Node-RED：

重要提示

这里提供的说明/截图在撰写时是正确的。IBM Cloud 的用户界面变化如此之快，可能与当前的用户界面不同。

1. 使用您之前创建的账户登录 IBM Cloud (cloud.ibm.com)：

图 6.1 - 通过您的 Lite 账户登录

1. 登录 IBM Cloud 后，您将在屏幕上看到您自己的仪表板。如果这是您第一次使用 IBM Cloud，在仪表板上将不会显示任何资源:

图 6.2 - IBM Cloud 仪表板

接下来，我们将在这个云平台上创建 Node-RED。

1. 我们将在云上创建 Node-RED 作为一个服务。从左上角的菜单中点击应用开发，然后点击获取一个入门套件按钮。这样可以创建一个新的应用服务:

图 6.3 - 获取入门套件按钮

1. 如果您在搜索框中输入Node-RED，就可以找到 Node-RED。找到后，点击Node-RED面板:

图 6.4 - Node-RED 入门套件

1. 点击Node-RED面板后，我们需要设置一些项目。

您可以通过提供自己的值自由更改每个项目，但在本章中，这里设置的值将用于解释目的。

请参阅图 6.5以进行配置的设置和值。请注意，一旦设置，这些项目将无法在以后更改。

1. 设置所有项目后，点击创建按钮：

图 6.5 - 将 Node-RED 创建为 Node.js 应用程序

您现在已经创建了 Node-RED 应用程序的框架。之后，您将被自动重定向到应用程序详细信息屏幕，在那里您将能够看到链接服务的Cloudant实例也已经被配置。

然而，只有应用程序源代码和合作服务的实例被创建，它们尚未部署到 IBM Cloud 上的 Node.js 执行环境中。实际部署将在启用 CI/CD 工具链时完成。

1. 一切准备就绪后，点击屏幕中央的部署您的应用按钮以启用它：

图 6.6 - 部署您的 Node-RED 应用程序

1. 点击部署您的应用按钮后，转到应用程序设置窗口。

2. 您将被要求创建 IBM Cloud API 密钥。不用担心，因为它将自动生成。点击新建按钮打开一个新的弹出窗口，然后在弹出窗口上点击确定按钮。一旦您这样做，IBM Cloud API 密钥将被生成：

IBM Cloud API 密钥

IBM Cloud API 密钥用于控制您的 IBM Cloud 帐户和各种服务（例如，在本教程中是 Cloud Foundry）。您可以使用它来为 IBM Cloud 上的服务发行外部访问令牌，例如。您可以在这里了解有关 IBM Cloud API 密钥的更多信息：cloud.ibm.com/docs/account?topic=account-manapikey。

图 6.7 - 生成 IBM Cloud API 密钥

1. 在窗口中选择资源规范。

这一次，我们使用的是 IBM Cloud 的 Lite 帐户，因此我们在 IBM Cloud 上只有 256 MB 的内存可用于所有服务。因此，如果我们为 Cloud Foundry Node.js 服务使用 256 MB，我们将无法为其他服务使用更多内存。但是 Node-RED 需要 256 MB 才能在 IBM Cloud 上运行，因此请在这里使用 256 MB。默认情况下已经为实例分配了 256 MB，因此点击下一步按钮，不更改任何参数：

图 6.8 - Node.js 运行时实例详细信息

完成此操作后，将显示DevOps 工具链设置屏幕。

1. 点击创建按钮，填入默认值。

您可以将 DevOps 工具链名称更改为任何您喜欢的名称。这是用于标识您在 IBM Cloud 中创建的工具链的名称：

图 6.9 - 配置 DevOps 工具链窗口

现在，您可以使用环境（Node.js 运行时和 DevOps 工具链）来运行您在上一步中创建的 Node-RED 应用程序。您创建的 Node-RED 应用程序会通过工具链自动部署在 Node.js 运行时上。

1. 确认交付管道（DevOps 工具链中执行每个工具的管道）区域中显示的状态为成功，然后点击其上方的工具链名称（在本例中为Node-REDforPackt）：

图 6.10 - 检查 Node-RED 的状态并转到 Pipeline 工具

在交付管道中，检查构建和部署面板的状态是否都是绿色并显示阶段通过。

1. 在DEPLOY面板下的LAST EXECUTION RESULT下点击查看控制台：

图 6.11 - 检查每个阶段的状态并转到应用程序控制台

1. 在 Node-RED 应用程序的控制台屏幕上，确认状态为运行，然后单击查看应用 URL：

图 6.12 - 检查 Node-RED 是否正在运行并打开 Flow Editor

干得好！您在 IBM Cloud 上打开了 Node-RED 流编辑器。接下来，我们将开始使用您刚刚打开的 Node-RED 流编辑器。

如果在执行这些步骤时出现任何错误，最好删除 Cloud Foundry App、Cloudant 和 DevOps 工具链，并按照之前提到的相同步骤重新创建它们。

1. 设置用户名和密码以访问您在 IBM Cloud 上的流编辑器。

点击访问应用 URL后，您将被重定向到初始设置对话框，以便您可以在 IBM Cloud 上使用 Node-RED 流编辑器。

您可以通过单击每个下一步按钮来继续此对话框，但请注意，您应该选择安全地设置编辑器，以便只有经过授权的用户才能访问它，并使用用户名和密码登录以便登录到您自己的流编辑器。这是因为此流编辑器作为公共 Web 应用程序在 IBM Cloud 上。这意味着任何人都可以访问您的流编辑器，如果知道 URL 的话。因此，我强烈建议您选择此选项并设置您自己的用户名和密码值：

图 6.13 - 设置用户名和密码以访问流编辑器

我们快要完成了！

1. 单击转到您的 Node-RED 流编辑器按钮，然后使用在上一步中设置的用户名和密码详细信息登录：

图 6.14 - 登录到您的 Node-RED 流编辑器

接下来，我们将检查 IBM Cloud 上的 Node-RED 流编辑器，并查看它是否可用。

1. 单击注入节点并检查结果：

图 6.15 - 默认示例流

](https://gitee.com/OpenDocCN/freelearn-node-zh/raw/master/docs/prac-node-red-prog/img/Figure_6.15_B16353.jpg)

图 6.15 - 默认示例流

当您单击注入节点时，您将在调试选项卡上看到结果值：

图 6.16 - 检查结果

现在，您可以在 IBM Cloud 上的 Node-RED 中创建一个流。Node-RED 流编辑器始终作为 IBM Cloud 上的 Node.js 应用程序运行。这意味着在 IBM Cloud 上启用了 Node.js 运行时服务（实例）。换句话说，与在树莓派上运行的 Node-RED 不同，此版本的 Node-RED 通过互联网访问流编辑器。

在接下来的部分，我将简要解释一下在这样的云上使用 Node-RED 的情况。

在云中使用 Node-RED 的具体情况是什么？

让我们重新审视 Node-RED 在云中的使用情况。

正如我们在上一章中提到的，Node-RED 既是一个工具，也是一个用 Node.js 编写的 Node.js 应用程序的执行环境。作为使用 Node-RED 构建应用程序的原因，我解释了通过黑箱化数据处理的各个单元，每个过程的作用变得非常清晰，易于构建和维护。

这不仅是在边缘设备上的原因，也是在服务器端（云端），用于持久化、分析和可视化由边缘设备收集的数据。

Node-RED 最大的特点是以消息的形式将 Node.js 的处理以顺序或并行的方式连接到输入/输出数据块的处理。可以说这非常适合物联网数据处理。

再次，正如我们在上一章中讨论的那样，物联网解决方案的标准架构是建立在边缘设备和云平台上的。它将边缘设备获取的传感器数据发送到云端，使其持久化，并为所需的处理链进行处理。

本章将重点关注云的这一部分。

边缘设备和云实际上还没有连接。假设数据已传递到云端，让我们将数据持久化存储在数据库中并进行可视化。

我们将使用在 IBM Cloud 上的 Node-RED 中所有开发人员都喜欢的仪表板节点。

在您在 IBM Cloud 上使用 Node-RED 之前，请安装一个新节点；即node-red-dashboard。

Node-RED 提供了调色板管理器，它易于安装，用于直接安装额外的节点。当您使用大量节点时，这非常有帮助。但是，由于 IBM Cloud Lite 帐户的 Node-RED 应用内存有限，可能会出现问题。

因此，在这里，我们需要获取package.json文件并在 IBM Cloud 上重新部署 Node-RED 应用程序。

您可以在flows.nodered.org/node/node-red-dashboard了解有关此节点的信息。

按照以下步骤对package.json文件进行更改：

1. 在 IBM Cloud 的 Node-RED 应用详情页面上，点击源代码。这将把您重定向到一个 Git 仓库，您可以在那里编辑 Node-RED 应用的源代码：

图 6.17 – 访问您的应用源代码

1. 点击文件列表上的package.json。这个文件定义了您的应用程序的模块依赖关系：

图 6.18 – 选择 package.json

1. 点击dependencies部分：

"node-red-dashboard": "2.x",

1. 添加任何提交消息并点击提交更改按钮：

图 6.19 – 编辑 package.json 并添加 node-red-dashboard

之后，持续交付管道将自动开始构建和部署 Node-RED 应用程序。您可以随时在交付管道上检查状态，就像您在创建 Node-RED Starter 应用程序时所做的那样：

图 6.20 – 重新构建并自动部署您的应用程序

当您在 lite 帐户上收到部署阶段失败的内存限制错误时，请在 IBM Cloud 仪表板上停止您的 Node-RED 服务，然后运行部署阶段。您可以通过访问 IBM Cloud 仪表板并在资源摘要下点击Cloud Foundry 应用来停止 Node-RED 服务：

图 6.21 选择 Cloud Foundry 应用

之后，在Cloud Foundry 应用下的 Node-RED 记录上点击停止选项。

图 6.22 点击停止选项

就是这样。您可以通过关闭调色板管理屏幕并在流编辑器的左侧向下滚动来确认已添加仪表板节点，如下面的截图所示：

图 6.23 – 检查仪表板节点是否已安装

还有一件事：我们需要使用数据库，但 IBM Cloud 的 Node-RED 默认使用 Cloudant 数据库。我们将在下一节的案例研究中使用 Cloudant。

现在，您可以在 IBM Cloud 上使用 Node-RED 进行物联网服务器端的情况。

物联网案例研究重点在服务器端

现在，让我们考虑物联网的服务器端用例研究。

它并不取决于每个边缘设备的情况。它主要用于处理数据并将其存储在数据库中以进行可视化。

在本章中，我们将考虑物联网的用例；也就是说，假设使用传感器模块接收的传感器数据在服务器端接收，并进行后续处理。

与上一章不同的是，在这个服务器端处理教程中，数据的内容并不重要。主要目的是保存接收到的数据并根据需要进行可视化，因此我想定义以下两个用例。

用例 1 - 存储数据

第一个用例是存储数据。让我们创建一个应用程序（流程），将您从设备接收到的数据存储起来。在本节中，我们不使用来自设备的真实数据；我们只使用由 inject 节点生成的数据：

图 6.24 - 用例 1 概述

现在，让我们看看第二个用例。

用例 2 - 温度/湿度传感器

第二个用例是将数据显示为图表。让我们创建一个应用程序（流程），将您从设备接收到的数据发布到仪表板上。我们不会使用任何设备的真实数据，只使用由 inject 节点生成的数据：

图 6.25 - 用例 2 概述

正如我们之前提到的，我们将使用 Cloudant 作为用例 1 的数据库，使用仪表板作为用例 2 的图表显示。这些已经准备好了。

创建一个示例流程

现在，让我们在 Node-RED 流编辑器上创建这两个服务器端用例流程。

请再次检查Cloudant节点和仪表板节点是否已安装在您的流编辑器上。如果没有，请按照本章在云上使用 Node-RED 的具体情况中提到的步骤安装这些节点。

现在，您需要在Cloudant上为本教程准备一个特定的数据库。请按照以下步骤进行：

1. 访问您的 IBM Cloud 仪表板，并从资源摘要区域点击查看全部：

图 6.26 - IBM Cloud 仪表板视图

1. 您会发现使用 Node-RED 创建的Cloudant服务。请点击服务的名称：

图 6.27 - 从资源列表中选择 Cloudant 服务

1. 点击IBM Cloud左上角的启动仪表板按钮：

图 6.28 - 启动 Cloudant 仪表板

1. 启动 Cloudant 仪表板后，请点击packt_db。之后，点击创建按钮：

图 6.29 - 在 Cloudant 上创建一个新数据库

现在您已经为本教程创建了数据库，可以随时使用它！

为用例 1 创建一个流程 - 存储数据

在 IoT 中，服务器端处理从边缘设备接收到的数据开始。然而，正如我们之前提到的，我们将专注于将数据存储在数据库中，因此我们将使用由inject节点生成的虚拟数据。作为消息接收的数据块将在 Node-RED 上持久存储在 Cloudant 数据库中。

我们可以按照以下步骤制作流程：

1. 从左侧的调色板中将一个inject节点和一个cloudant out节点拖放到工作区中：

图 6.30 - 放置 Inject 节点和 cloudant out 节点

inject节点生成虚拟数据，而cloudant out节点将输入值原样存储在 Cloudant 数据库中。

1. 之后，我们还将创建一个从 Cloudant 检索数据的流程，但首先，让我们只创建保存数据的流程。连接这些节点：

图 6.31 - 连接这两个节点

1. 接下来，修改inject节点的设置。双击节点打开设置面板。

2. 选择JSON作为第一个参数；也就是msg.payload，然后点击右侧的[…]按钮打开 JSON 编辑器：

{"temp":"29.18", "humi":"55.72"}

您可以使用选项卡在文本编辑器和可视化编辑器之间切换。请参考以下图片：

图 6.33 - 有两种类型的 JSON 编辑器可用

无需编辑msg.topic。

1. 设置JSON数据后，点击右上角的完成按钮关闭设置面板。

2. 然后，编辑packt_db的设置作为数据库名称。这个名称是您在 Cloudant 仪表板上命名的数据库。

第一个参数Service会自动设置；它是 IBM Cloud 上的您的 Cloudant 服务。第三个参数Operation不需要从其默认值更改。

1. 设置数据库名称后，点击右上角的完成按钮关闭设置面板：

图 6.34 - 在 cloudant 输出节点上设置数据库名称

1. 就是这样！不要忘记点击部署按钮。

2. 点击inject节点上的按钮来运行流程。当按钮被点击时，数据将被存储在 Cloudant 数据库中。

此时，我们无法通过 Node-RED 流程编辑器检查 Cloudant 上的数据；我们只能在 Cloudant 仪表板上检查它：

图 6.35 - Cloudant 仪表板上的结果

现在，让我们按照以下步骤创建一个从 Cloudant 获取数据的流程：

1. 从左侧的调色板中将一个inject节点、一个cloudant in节点和一个debug节点拖放到工作区中，以创建一个新的流程。

inject节点只是作为触发器执行这个流程，所以不需要更改其中的参数。cloudant in节点从您的 Cloudant 数据库获取数据。debug节点在调试选项卡上输出日志。

1. 连接这些节点：

图 6.36 - 放置新的三个节点并将它们连接以获取数据

1. 接下来，通过双击节点来修改cloudant in节点的设置，以打开其设置面板。

2. 就像packt_db作为数据库的名称，并选择所有文档作为第三个参数，也就是搜索方式。

第一个参数Service会自动设置；它是 IBM Cloud 上的您的 Cloudant 服务。

1. 设置数据库名称和搜索目标后，点击右上角的完成按钮关闭设置面板：

图 6.37 - 在 cloudant in 节点上设置数据库名称并搜索目标的结果

1. 就是这样！不要忘记点击部署按钮。

2. 点击inject节点上的按钮来运行流程。这样做时，您将从 Cloudant 数据库中获取数据。

您会看到结果被输出到debug窗口：

图 6.38 - 从 Cloudant 获取数据的结果

恭喜！通过这样，我们成功地创建了一个基本的流程（应用程序），它可以将传感器数据存储在 Node-RED 中的数据库中。

您也可以在这里下载流程定义文件：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter06/cloudant-flows.json

重要提示

此流程在 cloudant in/out 流中没有 Cloudant 服务名称的值。请检查一旦导入了此流程定义，您的服务名称是否已自动设置在其中。

现在您已经了解了如何在 Node-RED 上处理数据。我们将在下一节中可视化这些数据。

创建用例 2 的流程-可视化数据

第一个用例是将传感器数据存储在数据库中，而第二个用例是在 Node-RED 上可视化传感器数据。在 IoT 中，获取传感器数据后，我们必须以某种形式对其进行可视化。重点是检索和可视化用例 1 中存储的数据。我们将通过以下步骤来实现这一点：

1. 从左侧的调色板中将inject节点、function节点和chart节点放置在流程编辑器的工作区中，然后将这些节点连接起来：

图 6.39 - 放置节点并连接它们以显示数据

Inject节点只是作为触发器执行此流程，因此无需更改其中的参数。function节点生成要显示在 Node-RED 上的图表上的数字数据。最后，chart节点使数据能够出现在图表上。

1. 在function节点中编写代码以生成可以传递给图表节点的数字数据。

2. 双击节点以打开设置面板。然后，将以下代码添加到您放置的function节点中：

// Set min and max for random number
var min = -10 ;
var max = 10 ;
// Generate random number and return it
msg.payload = Math.floor( Math.random() * (max + 1 - min) ) + min ;
return msg;

就是这样：

图 6.40 - 用于生成随机数的代码

1. 编写此脚本后，单击右上角的Done按钮关闭Settings面板。

2. 然后，在此处编辑Packt Chart的设置。

3. 输入名称后，单击Packt Chart。现在，单击右上角的Done按钮：

图 6.41 - 在图表节点上设置参数

1. 就是这样！不要忘记单击Deploy按钮。

2. 单击inject节点上的左按钮以运行流程。当单击按钮时，function节点生成的数据将被发送到chart节点。

您可以在仪表板窗口上查看结果。

1. 单击流程编辑器右上角的Dashboard按钮，然后单击Open window按钮。这两个按钮都是图标，因此请参考以下屏幕截图，以查看您必须单击哪些按钮：

图 6.42 - 单击仪表板图标按钮并打开窗口图标按钮

1. 新窗口中的折线图将为空。请多次单击inject节点的开关。之后，您将看到折线图中填充了值：

图 6.43 - 具有值的折线图

恭喜！通过这样做，我们已成功创建了一个基本的流程（应用程序），用 Node-RED 显示传感器数据的图表。

您还可以在此处下载此流程定义文件：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter06/dashboard-flows.json。

摘要

在本章中，您学会了如何通过遵循真实的 IoT 用例创建服务器端示例流程（应用程序）。这些都是简单的教程，但我相信对您有益，这样您就能够为 IoT 服务器端应用程序制作流程。

我们在这里创建的流程步骤将帮助您为将来创建其他服务器端应用程序的不同流程。

在下一章中，我们将使用与本章相同的 IoT 用例，但我们将创建一个实际的示例流程（应用程序），该流程将调用 Web API。

第七章：从 Node-RED 调用 Web API

在本章中，让我们从 Node-RED 调用 Web API。基本上，在 Node-RED 中，处理是根据创建的流程进行的，但连接处理的是 JSON 数据。从这个意义上说，它与 Web API 非常兼容。

让我们从以下四个主题开始：

• 学习节点的输入/输出参数

• 学习节点的输入/输出参数

• 如何在节点上调用 Web API

• 如何使用 IBM Watson API

到本章结束时，你将掌握如何从 Node-RED 调用任何类型的 Web API。

技术要求

要在本章中继续进行，你将需要以下内容：

• Node-RED（v1.1.0 或更高版本）

本章中使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter07文件夹中找到。

学习 RESTful API

阅读本书的许多人可能已经熟悉 Web API。然而，为了使用 Node-RED 调用 Web API，让我们回顾一下 RESTful API。

REST代表表述性状态转移。RESTful API 基本上指的是根据“REST 原则”实现的 Web 系统的 HTTP 调用接口。因此，广义上来说，可以说 REST API 和 RESTful API 是相同的东西。那么，RESTful API 究竟是什么？我们将在本节中学习 RESTful API 的概述和原则，以及使用 RESTful API 的优缺点。

REST 是由 HTTP 协议创造者之一 Roy Fielding 在 2000 年左右提出的，是一组（或一种思维方式）适用于构建分布式应用程序时链接多个软件的设计原则。此外，RESTful API 是根据以下四个 REST 原则设计的 API：

• 可寻址性：它具有能够通过 URI 直接指向资源的属性。所有信息都应该由唯一的 URI 表示，这样你就可以一目了然地看到 API 版本，是否获取数据，更新等。

• 无状态性：所有 HTTP 请求必须完全分离。不应执行会话等状态管理。

• 连接性：这指的是在一条信息中包含“链接到其他信息”的能力。通过包含链接，你可以“连接到其他信息”。

• 统一接口：使用 HTTP 方法进行所有操作，如信息获取、创建、更新和删除。在这种情况下，HTTP 方法是获取（“GET”）、创建（“POST”）、更新（“PUT”）和删除（“DELETE”）。

这些是四个原则。从这四个原则中可以看出，REST 的一个主要特点是它更有效地利用了 HTTP 技术，并且与 Web 技术有很高的亲和性。因此，它目前被用于开发各种 Web 服务和 Web 应用程序。

随着智能手机的广泛使用，业务系统不仅可以在 PC 上使用，还可以在移动设备上使用，这一点变得越来越明显。此外，用户不仅选择一个系统，而是选择可以与多个系统和各种 Web 服务链接的系统。RESTful API 作为解决这些问题的不可或缺的工具受到了极大的关注。

如下图所示，可以从任何地方通过互联网调用 Web API：

图 7.1 - RESTful API 图表

现在，让我们回顾一下 Node-RED 是什么。它的工作流工具样式类似于一个独立的工具，但 Node-RED 当然也是 Web 应用程序之一。换句话说，它是一个非常适合与此处描述的 RESTful API 一起使用的应用程序。

接下来，让我们再次介绍 Node-RED 节点具有哪些参数。

学习节点的输入/输出参数

在 Node-RED 中有许多节点，但适合调用 Web API（REST API）的并不多。调用 Web API 时常用的节点是http request节点。

要在 Node-RED 上调用外部 API，只需将 API 的端点 URL 设置为http request节点的 URL 属性。

例如，在调用 API 时需要在端点 URL 中设置参数时，可以设置连接的前一个节点的输出值。这种方法非常简单。在参数的值设置部分，可以设置{{payload}}变量，而不是字面字符串。

在{{payload}}中，输入从前一个处理节点继承的字符串。

以以下示例为例（请注意，此 URL 不存在）：http://api-test.packt.com/foo?username={{payload}}&format=json：

图 7.2 – 使用{{payload}}作为参数设置 API 端点 URL

http request节点的过程不能仅由http request节点执行。在http request节点之前，需要连接触发过程，例如inject节点。在那时，如果有要传递给 API 调用的参数，也就是http request节点，请在msg.payload中设置它。

如果要在http request节点中调用的 API 是POST，则通过在预处理节点中创建 JSON 数据，并将其存储在msg.payload中，然后连接到http request节点，可以将其作为请求参数满足。

通过像这样使用http request节点，可以轻松实现 API 协作。API 调用对于在 Node-RED 上链接多个服务非常重要。例如，Node-RED 的function节点基本上是通过 JavaScript 处理的，但是通过将用其他开发语言开发的程序制作成 API，可以通过从 Node-RED 调用来使用。

如何在节点上调用 Web API

到目前为止，我们已经了解了什么是 RESTful API，以及哪个节点适合调用 API。

在这部分，让我们创建一个实际从 Node-RED 调用 API 的流程，并学习如何调用 API 以及如何处理 API 的结果值。

首先要考虑一些事情，比如要调用哪个 API。幸运的是，互联网上发布了各种 API。

这次，我想使用 OpenWeatherMap API。在 OpenWeatherMap 中，例如，准备了以下用于数据获取的 API：

• 当前天气数据

• 每小时预报 4 天

• 每日预报 16 天

• 气候预报 30 天

• 天气警报

• 等等...

有关更多信息，请参阅 OpenWeatherMap 的官方网站：openweathermap.org/。

好的，让我们准备使用 OpenWeatherMap API。

创建账户

要使用 OpenWeatherMap API，我们需要创建一个账户。请访问以下 URL：openweathermap.org/。

如果您已经有账户，请直接登录，无需进行以下步骤。

对于第一次使用的人，请点击登录按钮，然后点击创建账户链接。注册很容易。只需按照指示操作，并在注册后确认 OpenWeatherMap 发送给您的电子邮件。这是创建账户页面的样子：

图 7.3 – 创建 OpenWeatherMap 账户

接下来，让我们创建一个 API 密钥。

创建 API 密钥

当您登录 OpenWeatherMap 时，可以看到API 密钥选项卡，请点击它。您已经有一个默认的 API 密钥，但请为本教程创建一个特定的 API 密钥。输入任何密钥字符串，然后点击生成按钮。

请注意，本书中显示的 API 密钥是我创建的示例，不能使用。请务必在您的账户中创建一个新的 API 密钥：

图 7.4 - 生成 API 密钥

重要提示

创建 API 密钥后，密钥将在 10 分钟到几个小时内不会激活。如果在访问下一节中描述的 API 端点 URL 时返回 Web 响应错误，例如 401，则指定的 API 密钥可能尚未激活，请等待并重试。

检查 API 端点 URL

要检查您的 API 端点 URL，请按照以下步骤操作：

1. 单击菜单栏上的API按钮。您可以在那里看到一些 API。

2. 在本教程中，我们将使用当前天气数据，所以请点击当前天气数据下的API 文档按钮：

图 7.5 - 打开当前天气数据的 API 文档

1. 这个 API 有一些类型的参数，比如按城市，按城市 ID，按邮政编码等等。请选择带有城市名称和 API 密钥参数的按城市名称。

API 文档，城市名称，州代码和国家代码来自 ISO 3166。API 调用区域下的 URL 是使用此 API 的端点 URL。请将此 URL 复制到剪贴板：

图 7.6 - 带参数的 API 端点 URL

接下来，让我们看看我们是否可以运行这个 API。

检查 API 是否可以运行

让我们尝试使用这个 API。您只需打开浏览器，粘贴 URL，并用您自己的城市名称和 API 密钥替换它。您可以选择任何城市名称，但 API 密钥是您在上一节中创建的特定密钥：

图 7.7 - 调用 API 并获取结果

我现在已经确认这个 API 可以正常工作。现在让我们从 Node-RED 调用这个 API 并使用它。

创建调用 API 的流程

现在让我们创建一个在 Node-RED 上调用 OpenWeatherMap API 的流程。在您的环境中启动 Node-RED。您可以使用独立的 Node-RED 或 IBM Cloud 上的 Node-RED：

图 7.8 - 使用 API 的流程

对于这个，流程非常简单，很容易制作。请按照以下步骤制作流程：

1. 在调色板上放置一个注入节点和两个调试节点。这些节点可以使用默认设置。这里不需要更改设置。

2. 在调色板上放置http 请求节点，然后打开http 请求节点的设置面板，并在设置面板的URL文本框中使用您的参数（城市名称和 API 密钥）设置 API 端点 URL，如下图所示：

图 7.9 - 使用您的参数设置 API 端点 URL

1. 在调色板上放置一个json节点。此节点可以与默认设置一起使用。这里不需要更改设置。但是，以防万一，让我们确保json节点的Action属性设置为在 JSON 字符串和对象之间转换。这是一个选项，将把作为输入参数传递的 JSON 数据转换为 JavaScript 对象：

图 7.10 - 检查 Action 属性

1. 将所有节点连接如下图所示：

图 7.11 - 连接所有节点

请将时间戳节点和http 请求节点连接起来。http 请求节点的输出连接到json节点和调试节点。最后，请将json节点的输出连接到另一个调试节点。

1. 更改设置并连接所有节点后，您需要部署并单击注入节点的开关。现在您可以在右侧面板的调试窗口中看到数据：

图 7.12 - 在调试窗口上的结果数据（JSON）

您还可以在与以下屏幕截图相同的调试窗口上查看结果数据的 JSON 对象：

图 7.13 – 调试窗口上的结果数据（对象）

恭喜！您已成功通过调用 OpenWeatherMap API 创建了一个示例流程。如果您没有完全成功创建此流程，您也可以在此处下载此流程定义文件：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter07/open-weather-flows.json。

在下一节中，我们将学习在 IBM Cloud 上使用 Node-RED 的便利性以及 IBM Watson API。

如何使用 IBM Watson API

在上一节中，您学习了如何调用 API 并处理 API 的结果值。

在本节中，我们将创建一个实际从 Node-RED 调用 API 的流程，但我们将学习如何调用 IBM 提供的 Watson API。我们还将创建一个实际从 Node-RED 调用 API 的流程，但我们将学习如何调用 IBM 提供的 Watson API。

为什么要使用 Watson？Watson 是 IBM 提供的人工智能服务和 API 的品牌。

所有 Watson API 都可以从 IBM Cloud 上使用。因此，通过在 IBM Cloud 上运行 Node-RED，您可以有效地使用 Watson 的服务。这样做的好处是，当从 Node-RED 调用 Watson API 时，可以省略身份验证的实现。

Watson 可以从 IBM Cloud 以外的环境调用，因此可以直接从树莓派调用，也可以从 AWS 和 Azure 等云平台或本地环境中使用。请参见下图，显示 Watson API 的外观：

图 7.14 – Watson API 图表

有关更多信息，请参阅 IBM Watson 官方网站：www.ibm.com/watson。

好的，让我们看看在 IBM Cloud 上使用 Node-RED 上的 Watson API 有多容易。

登录 IBM Cloud

如果您已经按照第一章的步骤进行操作，您应该已经有了 IBM Cloud 帐户。只需登录 IBM Cloud (cloud.ibm.com)。

如果您没有 IBM Cloud 帐户，请从以下网址创建一个并登录 IBM Cloud。有关详细说明，请参阅第六章，在云中实现 Node-RED：ibm.biz/packt-nodered。

在 IBM Cloud 上启动 Node-RED

在上一节中，我们使用独立的 Node-RED 或 IBM Cloud 上的 Node-RED 创建了一个示例流程。当然，您可以使用独立版本的 Node-RED 来调用 Watson API，但会丢失一些好处。因此，在本部分中，我们将使用 IBM Cloud 上的 Node-RED。

与上一步一样，如果您还没有在 IBM Cloud 上使用 Node-RED，请返回到第六章，在云中实现 Node-RED，并按照其中的步骤激活 IBM Cloud 上的 Node-RED，然后再进行下一步。

创建 Watson API

接下来，在 IBM Cloud 上创建 Watson 的服务。严格来说，这意味着创建一个作为服务的实例，以便您可以调用 IBM Cloud 上提供的 Watson API 服务作为您自己的 API。

Watson 有几个 API，例如语音识别、图像识别、自然语言分析、情感分析等。这次，我想使用情感分析 API。

按照以下步骤创建 Watson Tone Analyzer API 服务：

1. 从目录中搜索 Watson。在仪表板上，请单击tone analyzer，然后选择Tone Analyzer面板：

图 7.15 – 搜索 Watson 服务

1. 请参考以下列表和图 7.16填写每个属性：

a. 默认（您可以将其修改为任何您想要使用的名称）

d. 资源组：默认（对于 Lite 账户，您无法选择其他内容）

e. 标签：N/A

1. 在输入/选择所有属性后，点击创建按钮：

图 7.16 – 创建 Tone Analyzer 服务

1. 当创建并激活时，您可以在Tone Analyzer实例仪表板上看到状态为活动。请检查 API 密钥和 URL。API 密钥和 URL 在从任何应用程序调用 API 时使用。但是，在本教程中不使用这些，因为 IBM Cloud 上的 Node-RED 可以在不需要认证编码的情况下调用 Watson API。

您可以从此屏幕上的管理菜单中检查 API 密钥和 URL：

图 7.17 – 检查您的凭证

在下一节中，我们将连接 Node-RED 和 Tone Analyzer 服务。

连接 Node-RED 和 Tone Analyzer 服务

正如您已经知道的，Node-RED 可以在不需要认证编码的情况下调用 Watson API。在使用 Node-RED 与 Watson API 之前，我们需要连接 Node-RED 和 Watson API 实例。在上一步中，我们创建了Tone Analyzer API 实例，所以让我们按照以下步骤连接这两个实例：

1. 点击左上角的IBM Cloud标志按钮，转到主仪表板。

2. 点击资源摘要面板上的查看全部按钮。

3. 在Cloud Foundry 应用区域点击 Node-RED 实例（应用）名称：

图 7.18 – 选择您创建的 Node-RED 服务

1. 点击连接菜单，然后点击创建连接按钮：

图 7.19 – 为 Node-RED 和 Watson 创建连接

1. 检查Tone Analyzer服务并点击下一步按钮：

图 7.20 – 点击下一步按钮选择连接服务

1. 对于访问角色和服务 ID，无需进行修改。点击连接按钮：

图 7.21 – 点击连接按钮完成连接

1. 我们需要重新启动 Node-RED 以激活连接。点击重新启动按钮：

图 7.22 – 点击重新启动按钮开始重新启动 Node-RED 服务

1. 请等待直到您的 Node-RED 实例的重新设置完成。完成后，您将获得运行状态的成功连接。之后，请通过访问应用 URL链接打开 Node-RED 流程编辑器：

图 7.23 – 检查 Node-RED 服务的 Node.js 运行时状态

您已成功准备好 Node-RED 和 Watson API 流程。接下来，让我们通过调用 Tone Analyzer API 来创建流程。

通过调用 Tone Analyzer API 创建流程

现在，让我们创建一个在 Node-RED 上调用 Watson Tone Analyzer API 的流程。您已经在 IBM Cloud 上启动了 Node-RED。可以使用独立的 Node-RED 或 IBM Cloud 上的 Node-RED。

为了继续本教程，您需要安装以下两个节点：

• node-red-node-twitter：这是一个获取和发布推文到 Twitter 的节点。

图 7.24 – 安装 node-red-node-twitter

• msg.payload。在向 Watson Tone Analyzer API 传递参数时使用：

图 7.25 - 安装 node-red-node-sentiment

在调色板中搜索这些节点并将它们安装到您的 Node-RED 流编辑器中。之后，按照下图所示创建一个流程：

图 7.26 - 使用 Tone Analyzer API 的流程

在这个流程中，功能节点处理从 Twitter 获取的结果值中包含的文本、语调和情感，以便将它们作为单独的调试输出。这样可以更容易地查看结果。

这个流程比您在上一步创建的流程要复杂一些。请按照以下步骤进行流程：

1. 创建一个 Twitter ID（Twitter 账户）并在您的 Twitter 开发者帐户上创建一个应用程序，以便通过您的 Twitter 账户验证访问推文。

2. 在 Twitter 开发者的项目和应用下访问概述，然后单击创建应用按钮：

图 7.27 - 在 Twitter 开发者上创建应用程序

1. 使用任何字符串设置应用程序名称，然后单击完成按钮。

图 7.28 - 设置您的应用程序名称

1. 之后，请检查访问令牌和访问令牌密钥区域。

您将看到令牌。请注意并保存您的访问令牌和访问令牌密钥。这些也将用于twitter in节点的设置：

图 7.29 - 记下您的令牌和令牌密钥

1. 将twitter in节点放置在您的工作区，并双击它以打开设置窗口：

图 7.30 - 放置 twitter in 节点

1. 单击设置窗口上的编辑（铅笔图标）按钮以编辑您的 Twitter 信息：

图 7.31 - 编辑 Twitter 属性

1. 设置您的 Twitter ID，API 密钥和令牌。

API 密钥、API 密钥密钥、访问令牌和访问令牌密钥的值应从步骤 8中的文本编辑器中获取。

1. 设置这些设置后，请单击添加按钮返回到twitter in节点的主设置窗口：

图 7.32 - 配置您的 Twitter 信息

1. 选择#nodered作为标签。您可以为名称设置任何名称。

2. 最后，单击完成按钮以完成添加这些设置并关闭窗口：

图 7.33 - 完成节点中 Twitter 的设置

1. 将情感节点放置在您的工作区。它将在twitter in节点之后连接。

对于这个节点，不需要设置或更改任何属性：

图 7.34 - 放置情感节点

1. 按顺序在您的工作区上的情感节点之后放置情感分析器 v3节点：

图 7.35 - 放置情感分析器 v3 节点

1. 打开情感分析器 v3节点的设置面板，并将方法和URL属性设置如下：

a. 名称：您想要命名的任何字符串

b. 方法：一般语调

c. version_date：多个语调

d. 语调：全部

e. 句子：真

f. 内容类型：文本：

图 7.36 - 配置情感分析器 v3 节点属性

1. 按顺序在您的工作区上的情感分析器 v3节点之后放置功能节点：

图 7.37 - 放置功能节点

1. 打开function节点的设置面板，并使用以下源代码编写 JavaScript：

msg.payload = {
    "text" : msg.payload,
    "tone" : msg.response,
    "sentiment" : msg.sentiment
};
return msg;

有关function节点的编码，请参考以下屏幕截图：

图 7.38 - 功能节点的 JavaScript 源代码

您可以在这里获取代码：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter07/format-payload.js。

1. 最后，放置三个msg.payload.text：对于msg.payload.tone：对于msg.payload.sentiment：对于调试选项卡

有关布线说明，请参阅图 7.26。我们已经完成了流程节点的配置。

测试流程

流程现在已经完成。当您点击twitter in节点连接到您的 Twitter 帐户时，它将自动检索符合您标准的推文并处理后续流程。

这是自动完成的，因此您无需采取任何特殊操作。

在这里，它被设置为获取所有具有#nodered作为标签的推文。如果您没有收到很多推文，这意味着没有创建包含指定标签的推文，请更改twitter in节点中设置的标签并重试。

此流程的所有处理结果将显示在调试选项卡中。

从获取的推文中提取推文正文并显示的是msg.payload.text：

图 7.39 - 获取推文正文的结果

从获取的推文中提取和显示检测到的情绪的是msg.payload.tone：

图 7.40 - 从推文中的语调分析结果

从获取的推文中判断情感是积极还是消极的是msg.payload.sentiment：

图 7.41 - 推文情感的结果

恭喜！您已成功调用 Watson API 创建了一个示例流。如果您没有完全成功创建此流程，您也可以在此处下载此流程定义文件：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter07/get-sentiment-twitter-flows.json。

总结

在本章中，我们学习了如何创建调用两种类型的 Web API 的示例流（应用程序）。我们逐渐习惯于创建复杂的流程。在 Node-RED 中经常发现调用 Web API 的用例。我们在这里学到的流程创建方法将帮助我们将来创建更复杂的流程。

在下一章中，让我们了解一个可以与 GitHub 等存储库集成的项目功能，这是从 Node-RED 版本 1.0 添加的功能。

第八章：使用 Git 的项目功能

在本章中，您将学习到一个非常有用的项目功能。Node-RED 的项目功能是一种使用 Git 在 Node-RED 流程编辑器上进行版本管理的工具/功能。实际上，默认情况下是禁用的。启用此功能可以让您以一种新的方式管理您的流程。我相信许多开发人员熟悉 GitHub 和 GitLab 等 Git 服务。Node-RED 的项目功能使用 Git 和 GitHub 进行版本控制，因此我认为这非常容易理解。

以下是本章将涵盖的主题：

• 启用项目功能

• 使用 Git 存储库

• 连接远程存储库

在本章结束时，您将能够了解如何使用项目功能，如何将您自己的 Git 存储库连接到 Node-RED 流程编辑器，并如何使用版本控制工具 Git 管理流程作为项目。

在本章结束时，您将掌握如何使用项目功能并使用它制作应用程序。您可以在 GitHub 或 GitLab 等任何托管的 Git 服务中使用它。

技术要求

要在本章中取得进展，您将需要以下内容：

• 您可以通过官方网站创建 GitHub 帐户：github.com/。

• 需要通过官方网站安装的 Git 客户端工具：git-scm.com/downloads。

启用项目功能

例如，在您想要管理自己的流程同时与他人共享它，或者您想要更新他人创建的流程的情况下，当团队仅使用 Node-RED 流程编辑器时，开发会很困难。

Node-RED 的项目功能是一种管理与您制作的每个流程相关的文件的方法/功能。它涵盖了使用 Node-RED 可共享的创建应用程序所需的所有文件。

这些都受 Git 存储库支持。也就是说，所有文件都有版本。这使开发人员能够与其他用户合作。

在 Node-RED 版本 1.x 上，默认情况下禁用项目功能，因此必须在名为settings.js的config文件中启用它。

重要提示

在 Node-RED 的本地环境中创建项目时，到目前为止创建的流程可能会被覆盖为空白表格。您可以通过互联网下载此文档中创建的所有流程的流程配置的 JSON 文件，但是如果您在本地环境中的 Node-RED 中创建了自己的流程，则建议导出流程配置文件。

我们在本书中创建的所有流程定义和 JSON 文件都可以在此处下载：github.com/PacktPublishing/-Practical-Node-RED-Programming。

现在让我们尝试项目功能。我们将在本地环境（如 macOS 或 Windows）上使用独立版本的 Node-RED。为了使用项目功能，我们首先需要启用它。让我们按照以下步骤启用它：

1. 需要重写settings.js文件以启用/禁用项目功能。首先找到此文件。settings.js文件可以在存储所有用户配置的 Node-RED 用户目录中找到。

在 Mac 上，默认情况下，此文件位于以下路径下：

/Users/<User Name>/.node-red/settings.js。

在 Windows 上，默认情况下，此文件位于以下路径下：

C:\Users\<User Name>\.node-red\settings.js

1. 编辑settings.js文件。可以使用任何文本编辑器打开settings.js。我在这里使用了vi。使用以下命令打开settings.js：

$ vi /Users/<User Name>/.node-red/settings.js 

重要提示

请将命令替换为适用于您的环境的命令。

1. 编辑您的settings.js文件，并在module.exports块内的editorTheme块中设置true，以启用项目功能：

module.exports = {
   uiPort: process.env.PORT || 1880,
   …
   editorTheme: {
       projects: {
           enabled: true
       }
   },
   …
}

1. 保存并关闭settings.js文件。

2. 通过运行以下命令重新启动 Node-RED 以启用我们修改的设置：

$ node-red 

我们现在已成功启用了 Node-RED 的项目功能。

要使用此功能，您需要访问 Git 和 ssh-keygen 命令行工具。Node-RED 在启动时检查它们，并在缺少任何工具时通知您。

如果设置完成没有任何问题，并且您已重新启动 Node-RED，则项目功能将可用。接下来，让我们设置 Git 存储库以供使用。

使用 Git 存储库

我们在上一节中启用了项目功能。重新打开流程编辑器，您将被提示使用当时创建的流程内容创建您的第一个项目。这将是欢迎屏幕：

图 8.1 - 欢迎屏幕

我们需要设置 Git 等版本控制客户端。如前所述，Node-RED 的项目功能使用 Git 作为版本控制工具。与常规 Git 一样，您可以根据项目管理文件更改，并根据需要与远程存储库同步。

Git 跟踪谁做出了更改。它与您的用户名和电子邮件地址一起工作。用户名不必是您的真实姓名；您可以使用任何您喜欢的名称。

如果您的本地设备已经配置了 Git 客户端，Node-RED 将查找这些设置。

首先，在您的本地环境中执行版本控制。它利用了您本地环境中安装的 Git 客户端的功能。如果您尚未安装 Git，请提前安装。

现在，按照以下步骤在 Node-RED 流程编辑器上创建项目：

1. 首先，让我们创建一个项目。这非常容易。在项目创建窗口中输入项目名称和描述。

2. 命名流程文件。默认情况下，它已命名为flow.json。

换句话说，Node-RED 会自动将当前在流程编辑器上配置的流程迁移到一个新项目中。保持默认名称即可。当然，如果您愿意，也可以在此处选择重命名。

如果您将项目发布在 GitHub 等公共网站上，加密凭据文件是个好主意。

如果选择加密，必须创建一个用于加密的密钥。该密钥不包括在项目中，因此如果与某人共享项目，则需要单独向克隆项目的用户提供凭据文件解密密钥。

1. 在添加所需信息后，单击创建项目按钮：

图 8.2 - 项目屏幕

恭喜！您已创建了您的第一个项目。

1. 接下来，检查项目历史。我们可以在 Node-RED 流程编辑器上使用版本控制功能。您可以通过单击右上角的项目历史按钮访问项目历史面板：

图 8.3 - 项目历史面板

1. 您可以在此面板上看到没有更改的项目。要检查更改历史功能是否已启用，请在此工作区上创建一个流程。

如果您经常使用 Git 或 GitHub，您应该能够通过查看此面板的结构来理解每个项目的含义和作用。如果项目下的文件结构或内容发生变化，目标文件将显示在本地更改区域。当您将更改移动到提交阶段（即添加时），目标文件的显示将移动到要提交的更改区域。如果输入提交消息并完成提交，版本将增加一次。

这与 Git 客户端所做的完全相同。

1. 创建一个简单的流程。您可以创建任何您选择的流程，例如，我在flow.json文件中使用了一个flow.json文件，这是整个流程的配置文件，已经更新。因此，flow.json已被识别为 Git 管理中要更改的文件：

图 8.5-Node-RED 已经意识到 flow.json 已更改

1. 现在，让我们遵循 Git 的规范并继续进行。首先，将更改的文件放在提交阶段。这是 Git 的git add命令。

2. 单击flow.json文件已从本地更改区域移动到提交区域。

3. 接下来，让我们提交flow.json中的更改。单击git commit命令：

图 8.7-单击提交按钮提交文件

1. 单击提交按钮后，将打开提交注释窗口。请在此处输入提交注释，然后单击提交按钮：

图 8.8-单击提交按钮完成提交过程

1. 提交现在已完成。最后，让我们检查提交历史区域。您会看到已创建一个新版本作为更改历史：

图 8.9-已添加新历史

在创建项目后，您可以像往常一样使用 Node-RED 编辑器。

现在，让我们为 Node-RED 流编辑器添加一个新的用户界面以实现项目功能。

访问项目设置

您正在处理的项目将显示在右侧窗格的顶部。在项目名称旁边，还有一个显示项目设置按钮：

图 8.10-信息面板上的项目信息

您还可以从主菜单下的“项目 | 项目设置”选项中访问项目设置屏幕：

图 8.11-如何通过主菜单访问项目设置

当显示项目设置面板时，您会看到每个设置有三个选项卡：

• 此项目的README.md文件

• 依赖项：管理项目的节点列表

• 设置：管理项目设置和远程存储库：

图 8.12-项目设置面板

如果要检查和修改 Git 设置，可以通过主菜单访问设置面板：

![图 8.13-用户设置面板上的 Git 配置现在您知道如何在本地环境中进行版本控制。下一步是了解如何连接远程存储库，比如 GitHub 服务。# 连接远程存储库现在，让我们学习如何将 Node-RED 连接到 GitHub 等远程存储库。在这里，我们将使用 GitHub 服务作为远程存储库。这就像通过 Node-RED 连接本地 Git 和远程 GitHub 一样。这并没有什么特别之处。对于经常使用 Git/GitHub 的人来说，这是很熟悉的，但它与 GitHub 用作客户端工具的情况非常相似。您可以很容易地使用 Node-RED 管理版本。通过以下步骤在 GitHub 上创建 Node-RED 项目的远程存储库：1. 首先，转到您的 GitHub 帐户并创建一个存储库。最好使用与您的本地存储库类似的项目名称。我们不会在这里详细介绍如何使用 GitHub，但由于它是一个可以直观使用的服务，我相信任何人都可以在没有任何问题的情况下使用它：

图 8.14-在 GitHub 上创建存储库

1. 配置您的 Node-RED 项目设置。要做到这一点，请返回到 Node-RED 流编辑器，然后转到项目设置以连接本地和远程存储库。打开项目设置面板后，单击添加远程按钮以配置远程存储库信息：

图 8.15 - 在项目设置面板上点击添加远程按钮

1. 请输入您在 GitHub 上创建的存储库 URL，然后单击添加远程按钮：

图 8.16 - 设置您的 GitHub 存储库的 URL

1. 单击设置面板右上角的关闭按钮以完成此配置。

2. 接下来，合并存储库。

GitHub 上的远程存储库现在已连接到您本地环境中的 Git 存储库。但它们尚未同步。您只需在本地拉取远程并进行合并。要做到这一点，请在侧边信息菜单中选择历史面板，然后在提交历史面板上单击管理远程分支按钮以连接到您的远程存储库：

图 8.17 - 设置您的 GitHub 存储库的 URL

1. 选择您要推送的远程分支。通常会选择origin/master分支：

图 8.18 - 选择您的远程分支

这里，远程和本地之间存在差异，因为我们已经在本地创建了流程，并使用本地 Git 进行了版本控制。在这种情况下，您需要在将本地内容推送到远程之前，将远程内容拉取到本地。

1. 单击pull按钮：

图 8.19 - 从远程存储库拉取提交

在途中会显示冲突的消息，但请继续进行合并。在合并过程中，将会询问您是要应用远程更改还是本地更改。在这种情况下，请应用本地端的更改以完成合并。

操作完成后，您将看到您的本地分支已与提交历史面板上的远程分支合并：

图 8.20 - 合并远程和本地存储库

1. 在此之后，选择管理远程分支按钮（上下箭头）：

图 8.21 - 点击管理远程分支按钮

1. 选择要推送的分支，然后单击push按钮将这些更改发送（推送）到远程存储库：

图 8.22 - 将更改发送到远程存储库

恭喜！现在您已经学会了如何在 Node-RED 上使用项目功能，您还可以将 Node-RED 的本地存储库连接到远程存储库。

摘要

在本章中，您学会了如何启用 Node-RED 的项目功能，并使用 GitHub 上创建的远程存储库集成本地版本控制 Git。在未来使用 Node-RED 开发团队时，这将非常有用。

在下一章中，我们将使用此项目功能在本地克隆待办事项应用程序的存储库。通过一起学习本章和下一章，您应该对项目功能有更深入的了解。

第三部分：实际问题

在本节中，读者将掌握使用 Node-RED 制作逼真且可用的应用程序。Node-RED 中的实际应用程序通过分别执行 Node.js 的详细处理来传递数据。在本节的所有实践教程之后，您将掌握如何使用 Node-RED。

在本节中，我们将涵盖以下章节：

• 第九章, 使用 Node-RED 创建待办事项应用程序

• 第十章, 处理树莓派上的传感器数据

• 第十一章, 在 IBM Cloud 中创建服务器端应用程序可视化数据

• 第十二章, 使用 Slack 和 IBM Watson 开发聊天机器人应用程序

• 第十三章, 创建并发布自己的 Node-RED 库中的节点

第九章：使用 Node-RED 创建 ToDo 应用程序

在本章中，我们将在 Node-RED 中创建一个简单的 ToDo 应用程序。这是一个简单直接的教程，可以帮助你在 Node-RED 中创建应用程序（流程）。我们将使用上一章中介绍的项目功能，因此本章也将作为该功能的复习。

让我们从以下四个主题开始：

• 为什么应该使用 Node-RED 进行 Web 应用程序

• 创建数据库

• 如何连接数据库

• 运行应用程序

到本章结束时，你将掌握如何在 Node-RED 上制作一个带有数据库的简单 Web 应用程序。

技术要求

要完成本章，你需要以下内容：

• Node.js 12.x 或更高版本 (nodejs.org/).

• CouchDB 3.x (couchdb.apache.org/).

• 一个 GitHub 账户，可从github.com/获取。

• 本章中使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter09中找到。

为什么应该使用 Node-RED 进行 Web 应用程序

到目前为止，本书已经解释了 Node-RED 是物联网(IoT)的易于使用的工具。在物联网领域，Node-RED 被用作解决方案的情况很多。

然而，最近，Node-RED 被认为是一个用于创建 Web 应用程序以及物联网的工具。

我认为其中一个原因是无代码和低代码的理念已经在世界范围内得到了广泛传播。如今，了解基于流的编程工具和可视化编程工具的人数正在增加，并且它们正在被用于各个领域。

Node-RED 是使用 Node.js 制作的，自然而然地可以用于 Web 应用程序。

我们在上一章学习的项目功能，与 Git/GitHub 合作，也可能成为 Web 应用程序开发文化流程的一部分。

在本章中，我们将创建一个非常适合作为教程开发的 ToDo 应用程序。

要创建的应用程序的整体图景如下：

图 9.1 – 我们将创建的应用程序概述

图 9.1概述了应用程序的概况。该应用程序将从客户端 PC 浏览器访问。该应用程序的用户界面是使用 Node.js 框架TodoMVC和Todo-Backend制作的。数据处理编程是通过将 CouchDB 连接为存储数据的 Node-RED 构建的。

在这个应用程序中，用户界面和后端应用程序都不是基于 Node-RED 构建的。

该应用程序是直接在本地主机上作为 Node.js 应用程序实现的。我们将在稍后的步骤中介绍这一点，当访问 Node-RED 运行的本地主机端口时，我们将设置它重定向到本地主机 Node.js 应用程序。

在我们进行实际操作示例之前，我们应该了解一下这个应用程序使用了两个框架。我们将在这个实际操作教程中使用 Node-RED 制作我们的 ToDo 应用程序。该应用程序是通过这两个 Node.js 框架实现的：

• TodoMVC: todomvc.com/

图 9.2 – TodoMVC

• Todo-Backend: todobackend.com/

图 9.3 – Todo-Backend

正如你可以从可以通过链接 Web 应用程序框架创建 Node-RED 流的事实中看出来，Node-RED 与使用 Node.js 实现的 Web 应用程序及其周围的框架非常配合。这个实际操作教程将帮助你了解为什么 Node-RED 在以无代码/低代码方式开发 Web 应用程序方面如此受欢迎。

接下来，我们将进行实际操作步骤。

创建数据库

我们在上一节介绍了应用程序的整体情况，但更具体地，这个应用程序使用 CouchDB 作为数据库。在这个实践教程中，我们将创建一个在本地主机上运行的 Node-RED 应用程序。因此，你也需要在自己的本地机器上安装 CouchDB。

让我们按照以下步骤安装它：

1. 访问 CouchDB 网站couchdb.apache.org/，然后点击DOWNLOAD按钮：

图 9.4 - 点击 DOWNLOAD 按钮

1. 根据本地机器上运行的系统选择一个文件：

图 9.5 - 选择文件

1. 解压下载的 ZIP 文件并运行应用程序文件以启动 CouchDB，一旦文件下载完成：

图 9.6 - 启动 CouchDB

1. 运行 CouchDB 应用程序文件会启动浏览器并打开 CouchDB 管理控制台。如果没有自动打开，也可以从应用程序菜单手动打开：

图 9.7 - 打开 CouchDB 管理控制台

1. 在 CouchDB 管理控制台中创建一个新的数据库。使用名称todos创建它。不需要分区。最后，点击Create按钮完成：

图 9.8 - 创建名为"todos"的新数据库

现在你可以在 CouchDB 管理控制台上看到名为todos的数据库：

图 9.9 - 检查你创建的数据库

1. 创建一个管理员用户来访问这个数据库。为此，访问admin设置为用户名，adminpass设置为密码：

图 9.10 - 创建服务器管理员用户账户

这完成了所有与 CouchDB 相关的设置。接下来，让我们继续设置我们的 Node-RED 端。

如何连接到数据库

现在数据库实际上已经创建了，我们将朝着实践教程迈进，我们将从 GitHub 克隆 Node-RED 流，并实现从 Node-RED 流连接到该数据库。使用你在上一章学到的项目功能连接到你的 GitHub 存储库，加载准备好的流定义文件，并在本地环境中在 Node-RED 上实现它。由于你在上一章已经做过这个操作，这次不需要创建新的流。

配置 Node-RED

你需要做的第一件事是更改 Node-RED 流编辑器的本地主机路径（URL）。目前，你可以在localhost:1880访问流编辑器，但为了将由这个实践教程创建的 Web 应用程序的路径（URL）更改为localhost:1880，我们需要将流编辑器的路径更改为localhost:1880/admin。

这是因为你必须将 Node-RED 流编辑器的根路径移动到本地主机上运行的 Node.js ToDo 应用程序的相同端口上。

要配置 Node-RED，请按照以下步骤操作：

1. 打开设置文件（~/.node-red/settings.js）。

2. 找到你打开的settings.js文件中的httpAdminRoot设置。

这会更改你访问 Node-RED 流编辑器的路径。默认情况下，它使用根路径/，但是我们想要将其用于我们的应用程序，所以我们可以使用这个设置来移动编辑器。默认情况下是注释掉的，所以通过删除行首的//取消注释：

图 9.11 - 取消注释 httpAdminRoot 以启用流编辑器路径

1. 您现在已将流程编辑器移至/admin。在本地计算机上重新启动 Node-RED，并访问http://localhost:1880/admin URL 以运行您的 Node-RED 流程编辑器。

接下来，让我们克隆项目。

克隆 Node-RED 项目

这个实践教程为您提供了一个 Node-RED 项目的示例。在将其克隆到本地 Node-RED 实例之前，您应该首先分叉该项目，以便您有自己的副本可供使用。

分叉后，您需要将项目克隆到您的 Node-RED 实例中。

要克隆您的项目，请按照以下步骤进行：

1. 在github.com/taijihagino/node-red-todo-app上打开示例项目。

2. 单击fork按钮以创建存储库的自己的副本。

3. 复制您分叉的存储库的 URL。

4. 通过http://127.0.0.1:1880/admin/访问 Node-RED 编辑器。

5. 在项目欢迎屏幕上单击克隆存储库按钮。如果您已经关闭了该屏幕，可以从主菜单中使用项目 | 新建重新打开它：

图 9.12 - 单击项目菜单下的新建以克隆存储库

1. 在项目屏幕上，提供您的存储库 URL、用户名和密码。这些在提交更改到项目时使用。如果您的本地 Git 客户端已配置，它将选择这些值。将凭据加密密钥字段留空是可以的：

图 9.13 - 提供您的 GitHub 存储库信息

1. 这将克隆存储库到一个新的本地项目并开始运行它。在工作区中，您可以看到实现应用程序的每个部分的流程。

您将在所有cloudant节点上看到一些错误，但这些错误的原因来自连接设置。这些设置将在后续步骤中进行设置，所以现在不是问题：

图 9.14 - 您克隆的流程概述

1. 该项目还包括一些需要由运行时提供的静态资源。为此，需要对如何访问此 Web 应用程序的设置文件进行一些更改。

首先，您必须在本地文件系统中找到您新克隆的项目。它将在<node-red root>/projects/<name-of-project>中。在该文件夹中，您将找到一个名为public的文件夹。这包含了此 ToDo 应用程序项目的静态资源，例如以下内容：

/Users/taiji/.node-red/projects/node-red-todo-app

以下图像是一个示例。请在检查您自己的文件路径时使用它作为参考：

图 9.15 - ToDo 应用程序项目文件夹

1. 编辑您的设置文件（~/.node-red/settings.js），并在该文件中找到httpStatic属性。通过删除行首的//来取消注释，并使用绝对路径到public文件夹来设置其值。以下图像中的路径仅为示例；请用您的路径替换它：

图 9.16 - 取消注释 httpStatic 并设置您的应用程序项目路径

1. 重新启动 Node-RED。

通过重新启动 Node-RED，更改的settings.js内容将被重新加载和应用。

接下来，让我们配置 Node-RED 和 CouchDB 连接。

配置 Node-RED 和 CouchDB 连接

正如您所知，我们正在使用cloudant节点连接到 CouchDB，对吗？

Cloudant 是基于 Apache CouchDB 的 JSON 数据库。Cloudant 具有 CouchDB 风格的复制和同步功能，因此您可以使用 Node-RED 提供的cloudant节点连接到 CouchDB。

如前所述，Node-RED 上的cloudant节点出现错误。这是因为从 GitHub 克隆时，本地系统对 CouchDB 的连接信息未正确设置。

在这里，我们将纠正 Node-RED 上cloudant节点的设置。

现在，根据以下步骤进行设置：

1. 双击任何cloudant节点以打开设置屏幕。如果您在其中设置了一个cloudant节点，则同一流程上的所有cloudant节点的设置都将被更新，因此您选择哪个cloudant节点并不重要：

图 9.17–双击任何 cloudant 节点打开设置屏幕

1. 点击cloudant节点设置屏幕上服务器右侧的铅笔标记按钮，打开 CouchDB 的连接信息设置屏幕：

图 9.18–点击铅笔标记按钮

1. 当打开 CouchDB 的连接信息设置屏幕时，转到http://localhost:5984（如果您的 CouchDB 安装在不同的端口上，请相应地替换），并将用户名设置为您之前设置的 CouchDB 服务器管理员用户。对于密码，输入服务器管理员密码。

2. 在输入所有内容后，点击右上角的更新按钮返回到上一个屏幕：

图 9.19–设置您的 CouchDB URL 和服务器管理员用户名/密码

1. 点击完成按钮并返回到您的 Node-RED 流程编辑器的工作区。您将看到所有cloudant节点旁边的连接上有一个绿色方块的消息：

图 9.20–检查所有 cloudant 节点是否无错误

完美，您已成功配置了在 Node-RED 中启动 ToDo 应用程序的设置。接下来，让我们运行这个 ToDo 应用程序。

运行应用程序

如果一切正常，您应该能够在浏览器中打开http://localhost:1880并看到应用程序。

现在，让我们通过以下步骤确认 ToDo 应用程序是否正常工作：

1. 访问http://localhost:1880打开您的 ToDo 应用程序。

如果您在打开localhost:1880时看到 Node-RED 流程编辑器，则表示httpAdminRoot设置未启用，请再次检查您的settings.js文件。

当您访问此 URL 时，应显示以下屏幕：

图 9.21–打开您的 ToDo 应用程序

1. 对于此测试，任何 ToDo 项目都可以，因此输入任何单词作为示例任务。在这里，我输入了报告我的任务：

图 9.22–输入一个示例 ToDo 项目

1. 在文本框中输入值时，如果按下Enter键，该值将被注册为一个 ToDo 项目。在下面的截图中，我们可以看到它看起来已经在应用程序中注册了：

图 9.23–您输入的 ToDo 项目已被注册

让我们检查一下屏幕上显示为已注册的 ToDo 项目是否在数据库中注册。

1. 打开 CouchDB 管理控制台。

如果您忘记如何打开它，可以从 CouchDB 应用程序菜单中选择打开管理控制台选项打开它。如果重新打开管理控制台，或者时间已过，可能会要求您登录。在这种情况下，请使用您设置的服务器管理员用户名和密码登录。

1. 在侧边菜单中选择数据库选项，然后点击todos。您将看到您在 ToDo 应用程序上注册的记录。点击记录以查看更多细节：

图 9.24 - 检查您的待办事项数据库中的记录

1. 您将看到您选择的记录的详细信息。数据是您通过 ToDo 应用程序注册的确切项目，即报告我的任务：

图 9.25 - 检查结果

恭喜！这完成了从 GitHub 克隆 ToDo 应用程序并在 Node-RED 中实现的实践教程。

本教程的重点是使用 Node-RED 的项目功能从 GitHub 存储库克隆和执行应用程序项目。

这个实践教程帮助我们了解，我们不一定需要在使用 Node-RED 制作的 Web 应用程序中实现用户界面和服务器端业务逻辑。我们看到 Node-RED 的一个特点是，我们构建的 Web 应用程序的用户界面和服务器端业务逻辑位于 Node-RED 之外，而仅数据处理功能（如访问数据库）由 Node-RED 内部完成。

我们使用的 GitHub 存储库包含两件事，即处理数据的 Node-RED 流程和在 Node-RED 之外运行的 ToDo 应用程序。这里的重点是使用 Node-RED 的项目功能从 GitHub 存储库克隆和执行应用程序项目。

摘要

在本章中，我们通过实践教程的形式体验了如何使用项目功能在 Node-RED 上实际运行 Web 应用程序。当然，这只是在 Node-RED 上创建 Web 应用程序（包括 UI，使用模板节点等）的一种方式。然而，记住这种模式对于您未来的开发任务肯定会有用。

在下一章中，我们将看到一个实际场景，我们将使用 Node-RED 将传感器数据从边缘设备发送到服务器端（云）。

第十章：在树莓派上处理传感器数据

在本章中，我们将学习在物联网（IoT）中使用 Node-RED 处理来自边缘设备的数据的处理过程。我们不仅将涵盖数据处理，还将从边缘设备向服务器应用程序发送数据。对于设备，我想使用树莓派。完成本章中的教程后，你将能够处理边缘设备获取的传感器数据。

让我们从以下四个主题开始：

• 从树莓派上的传感器模块获取传感器数据

• 学习 MQTT 协议并使用 MQTT 节点

• 连接到 MQTT 代理

• 检查本地主机上数据的状态

技术要求

要在本章中取得进展，你需要以下内容：

• 从www.raspberrypi.org/获取的树莓派

• 本章中使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter10文件夹中找到

从树莓派上的传感器模块获取传感器数据

在本章中，我们将学习如何使用 Node-RED 在树莓派上处理从传感器设备获取的数据，并将数据发布到 MQTT 代理。

对于传感器设备，我们将使用在第五章中使用的温湿度传感器，本地实现 Node-RED。有关连接和如何在树莓派上启用传感器设备的详细信息，请参阅第五章中的每个步骤，本地实现 Node-RED。

准备将你的温湿度传感器连接到你的树莓派。这就是边缘设备。你已经在第五章中购买并配置了你的边缘设备，本地实现 Node-RED。本章不使用光传感器：

• 边缘设备：树莓派 3 (https://www.raspberrypi.org/)

• 传感器模块：Grove 树莓派底板，Grove 温湿度传感器（SHT31） (www.seeedstudio.com/Grove-Base-Hat-for-Raspberry-Pi.html, www.seeedstudio.com/Grove-Temperature-Humidity-Sensor-SHT31.html)

准备设备

请准备好设备，以收集树莓派上的温湿度传感器数据，步骤如下：

1. 将传感器模块连接到你的树莓派。

当所有设备准备就绪时，连接树莓派和 Grove 树莓派底板，并将 Grove 温湿度传感器（SHT31）连接到 I2C 端口（任何 I2C 端口都可以）：

图 10.1 – 连接温湿度传感器到你的树莓派

1. 将你的树莓派连接到互联网。

我们将继续从树莓派连接到服务器端，所以请确保通过 Wi-Fi 连接到互联网。当然，你也可以通过使用 LAN 电缆连接到调制解调器来访问互联网。树莓派默认具有 LAN 电缆端口，所以你只需插入 LAN 电缆即可：

图 10.2 – 将你的树莓派连接到互联网

这就是我们继续所需的全部内容。接下来，我们将看到如何从传感器节点获取数据。

检查 Node-RED 以从传感器设备获取数据

正如你在第五章中已经学到的，本地实现 Node-RED，从 Grove 树莓派温湿度传感器模块获取数据应该很容易。

以下是从传感器节点获取数据的步骤：

1. 创建一个简单的流程来获取数据。从流程编辑器左侧的调色板中选择三个节点，即一个inject节点，一个grove-temperature-humidity-sensor-sht3x节点和一个debug节点，并将它们拖放到工作区中放置。

2. 放置它们后，请按照以下图示将它们依次连接：

图 10.3 - 放置和连接节点

1. 检查grove-temperature-humidity-sensor-sht3x节点的设置。要检查设置，请双击grove-temperature-humidity-sensor-sht3x节点以打开设置屏幕。

在此设置屏幕上没有要设置的值或项目。您只需确保端口显示为I2C。检查后，关闭设置屏幕。

确保您看到一个蓝色的方形图标和grove-temperature-humidity-sensor-sht3x节点下方的I2C文本。这表示 Grove Base 温度/湿度传感器模块已成功连接到您的树莓派。如果此图标的颜色变为红色，则表示模块未正确连接到I2C端口，请重新正确连接硬件：

图 10.4 - 检查端口是否设置为 I2C

1. 执行流程并通过单击流程编辑器右上角的部署按钮来检查结果以完成部署。

2. 部署成功后，单击inject节点上的开关以启动流程：

图 10.5 - 部署并单击注入节点上的按钮

如果您可以确认在流程编辑器的debug选项卡中以 JSON 格式显示了收集到的传感器数据的值，那么它已成功工作。这样，可以从传感器模块获取数据：

图 10.6 - 确保从传感器模块中可见数据

现在我们知道树莓派上的 Node-RED 可以处理传感器数据。让我们学习将这些数据发布到 MQTT 代理的过程。

学习 MQTT 协议并使用 MQTT 节点

现在传感器数据已成功获取，让我们将数据发送到服务器。

我们通常选择适合传输内容的协议；例如，在交换邮件时，我们使用 SMTP。目前，HTTP 被用作互联网上的通用协议。

例如，HTTP 用于互联网上的各种通信，如在浏览器中显示网页和在服务器之间交换数据。HTTP 是为在互联网上交换内容而创建的协议。在许多情况下，互联网上的网络设备，如路由器和防火墙，被设置为允许使用 HTTP 通信以用于各种目的，并且 HTTP 与互联网兼容。

在物联网世界中，MQTT 通常用作 HTTP 的通用协议。这意味着 MQTT 协议是物联网世界的标准，就像 HTTP 协议是网络世界的标准一样。

MQTT（MQ Telemetry Transport的缩写）是由 IBM 和 Eurotech 于 1999 年首次创建的通信协议。2013 年，这一协议的标准化由一个名为 OASIS 的国际标准化组织推动。

MQTT 旨在在 TCP/IP 上使用。简而言之，它专门用于互联网上的机器对机器（M2M）通信，以及机器与互联网上的其他资源之间的通信。这里所指的机器是微型计算机板，如个人电脑和小型 Linux 板（包括树莓派）。

自 1999 年以来，M2M 已经发展，出现了IoT这个词，当传统机器通过互联网进行通信时，现在很常用 MQTT。因此，MQTT 是物联网的最佳协议。MQTT 重要的原因之一是它提供了一种轻量级协议来处理窄带网络和低性能设备上的数据：

图 10.7 – 典型 M2M 通信的概念图

从前面的信息中，您可以看到为什么在物联网中使用 MQTT 协议。现在让我们思考 Node-RED 如何使用 MQTT 协议传输数据。

Node-RED 默认提供以下两个与 MQTT 相关的节点：

• mqtt in：mqtt in节点连接到 MQTT 代理并订阅指定主题上的消息。

• mqtt out：mqtt out节点连接到 MQTT 代理并发布消息：

图 10.8 – mqtt in 节点和 mqtt out 节点

您可以在 Node-RED 流编辑器的侧边栏的网络类别下找到这些。

如果您想为 MQTT 代理设置服务器地址和主题，并使用发布和订阅，可以使用这两个节点。

现在让我们尝试将传感器数据发送到本地 MQTT 代理。

连接到 MQTT 代理

现在，让我们通过 Node-RED 将树莓派上的传感器数据发送到 MQTT 代理。在这里，我们将使用流行的 MQTT 代理Mosquitto。在本章中，我们将准备设备以将设备数据发送到服务器。实际在服务器端接收和处理数据的任务将在下一章的实际示例中进行演示。因此，在这里，我们将使用 Mosquitto 仅用于检查数据传输是否正确执行。

Mosquitto

Mosquitto 是根据开源 BSD 许可发布的，并为 MQTT V3.1/v3.1.1 提供代理功能。

它适用于主要的 Linux 发行版，如 RedHat Enterprise Linux，CentOS，Ubuntu 和 OpenSUSE，以及 Windows。它也适用于树莓派等小型计算机。

在本章中，我们将验证边缘设备的传感器数据是否可以通过 MQTT 代理发送到树莓派的本地主机。这非常容易。我相信，如果我们可以以这种方式将数据发送到 MQTT 代理，我们将能够立即在服务器端看到边缘设备的传感器数据。

以下是一个通用配置图，显示了 Mosquitto 的示例用法：

图 10.9 – Mosquitto 概述

在本章中，我们将实现从边缘设备到 Mosquitto 发送数据的 Node-RED 流程。下一章将实现使用 IBM Cloud 进行数据可视化。

重要提示

Mosquitto 是一个非常重要和有用的工具，是在 Node-RED 中实现物联网机制的平台。深入了解 Mosquitto 将帮助您使 Node-RED 更广泛地可用。

您可以在mosquitto.org/了解更多关于 Mosquitto 的信息。

现在，让我们在您的树莓派上准备 Mosquitto。

准备您的树莓派上的 Mosquitto

在本节中，我们将启用 Mosquitto，以便它可以在树莓派上运行。流程很简单。只需安装 Mosquitto 并启动服务。请按照以下步骤在您的树莓派上准备：

1. 要安装 Mosquitto，请在终端上执行以下命令：

$ sudo apt install mosquitto

1. 要启动 Mosquitto 服务，请在终端上执行以下命令：

sudo systemctl start mosquitto

启动后，您可以使用以下命令检查 Mosquitto 服务的状态：

sudo systemctl status mosquitto

在终端上看起来是这样的：

图 10.10 – Mosquitto 运行状态

1. 要安装 Mosquitto 客户端工具，请在终端上执行以下命令：

$ sudo apt install mosquitto-clients

1. 要检查发布和订阅功能，请运行packt作为主题：

$ sudo apt install mosquitto-clients
$ mosquitto_sub -d -t packt

在终端中的显示如下：

图 10.11 - 开始订阅 Mosquitto 与主题 packt

1. 使用另一个终端发送一些文本到这个代理的以下命令：

$ mosquitto_pub -d -t packt -m "Hello Packt!"

在终端中的显示如下：

图 10.12 - 使用主题 packt 发布消息到 Mosquitto

您将在终端订阅到您发布的消息。

现在，您可以使用 Mosquitto 了。接下来，我们将在您的树莓派上的 Node-RED 上实现发布/订阅。

制作一个流程来获取传感器数据并将其发送到 MQTT 代理

现在，在您的树莓派上启动 Node-RED 流编辑器，并按照以下步骤创建一个流程：

1. 在之前检查 Node-RED 是否可以从传感器设备获取数据部分创建的流程中，在grove-temperature-humidity-sensor-sht3x节点之后放置mqtt out节点，并将mqtt in节点和debug节点与mqtt out 流分开。请按照以下图示连接它们：

图 10.13 - 放置这些节点并连接它们

1. 编辑localhost

2. 端口：1883

*可以编辑packt

1. 1

2. true

设置窗口应该是这样的：

图 10.14 - 设置 mqtt out 节点的属性

1. 编辑localhost

2. 1883

*可以编辑packt

1. 1

2. 输出：自动检测（字符串或缓冲区）

设置窗口应该是这样的：

图 10.15 - 设置 mqtt in 节点的属性

有了这个，我们已经完成了通过Mosquitto MQTT 代理在您的树莓派 localhost 上订阅和发布主题packt的流程。接下来，我们将检查我们在 localhost 上的数据状态。

检查 localhost 上的数据状态

在本节中，我们将检查从您的树莓派发送的传感器数据是否可以通过 Node-RED 接收到 Mosquitto。

1. 在您的树莓派上的 Node-RED 实例上运行您在上一节中创建的流程。

2. 单击inject节点的开关以运行此流程并发布 Grove 温湿度传感器数据：

图 10.16 - 运行发布数据的流

1. 检查已订阅的数据。

当前在这个 Node-RED 实例中有两个流。一个是将数据发布到 Mosquitto MQTT 代理的流，另一个是从该代理订阅数据的流。订阅的流通常处于待机状态，因此当数据被发布时，订阅的数据会自动输出到debug选项卡。

1. 检查debug选项卡。您应该看到您发布的数据：


图 10.17 - 检查发布和订阅的结果\

恭喜！现在您知道如何处理树莓派和 Grove Base 传感器模块在边缘设备上获取的传感器数据，并将其发送到 MQTT 代理。

摘要

在本章中，通过实际操作教程的形式，我们体验了如何在边缘设备上处理传感器数据并将其发送到 MQTT 代理。这是使用 Node-RED 为物联网创建边缘设备端应用程序的一种方式。

在下一章中，我们将看一个实际的例子，接收传感器数据并通过 Node-RED 在服务器端（云端）进行可视化。

第十一章：通过在 IBM Cloud 中创建服务器端应用程序来可视化数据

在本章中，我们将创建一个服务器应用程序，用于可视化从物联网边缘设备发送的数据，使用 Node-RED。对于服务器端应用程序，我想在这里使用 IBM Cloud。通过本章中的教程，您将掌握如何在服务器应用程序上可视化传感器数据。

让我们从以下主题开始：

• 准备一个公共 MQTT 代理服务

• 在边缘设备上从 Node-RED 发布数据

• 在云端 Node-RED 上订阅和可视化数据

在本章结束时，您将掌握如何在云平台上可视化传感器数据。

技术要求

要在本章中取得进展，您将需要以下内容：

• IBM Cloud 帐户：cloud.ibm.com/

• CloudMQTT 帐户：cloudmqtt.com/

• 本章中使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter11文件夹中找到。

准备一个公共 MQTT 代理服务

回想一下上一章，第十章，在树莓派上处理传感器数据。我们将连接到边缘设备（树莓派）的温度/湿度传感器的数据发送到云端，并确认可以在云端观察到数据。

在上一章中，我们检查了如何使用名为Mosquitto的服务操作 MQTT 代理。这是为了专注于从边缘设备发送数据到 MQTT 代理。

然而，这是一个在树莓派上本地完成的机制。基本上，在尝试实现物联网机制时，MQTT 代理应该位于公共位置，并且可以通过互联网从任何地方访问。

在公共云中托管自己的Mosquitto MQTT 代理是可能的，但这会增加一些额外的复杂性，涉及设置和维护。有许多公共 MQTT 服务可用，可以使入门变得更容易。

在本章中，我们将使用名为CloudMQTT的服务作为 MQTT 代理，但您可以用您喜欢的服务替换 MQTT 代理部分。您还可以在 IaaS 上发布自己的 MQTT 代理，例如Mosquitto，而不是使用 SaaS：

图 11.1 - CloudMQTT 概述

重要提示

MQTT 代理是一个服务器，它接收来自发布者的消息并将其发送给订阅者。

在 PubSub 中传递消息的服务器称为 MQTT 代理。

PubSub 是发布者和订阅者这两个词的结合：

a) 发布者是传递消息的人。

b) 订阅者是订阅消息的人。

您可以将其视为从客户端接收消息并将其分发给客户端的服务器。

MQTT 与普通的套接字通信不同，它是一对多的通信。换句话说，它有一种机制，可以将一个客户端的消息分发给许多人。这个系统允许我们实时同时向许多人传递消息。

我们现在将学习如何准备CloudMQTT。如前所述，CloudMQTT是作为 SaaS 发布的 MQTT 代理。如果您不使用CloudMQTT，想要使用另一个 SaaS MQTT 代理或在 IaaS 上发布 MQTT 代理，您可以跳过此步骤。但是，使用 MQTT 代理的基本配置信息保持不变，因此我相信这一步将帮助您配置任何 MQTT 代理。

执行以下步骤在CloudMQTT上创建一个 MQTT 代理服务：

1. 登录到cloudmqtt.com/的CloudMQTT。

当您访问网站时，点击窗口右上角的登录按钮：

图 11.2 - CloudMQTT 网站

如果你已经有了 CloudMQTT 账户，请通过输入你的电子邮件地址和密码登录你的账户：

图 11.3 - 登录到 CloudMQTT

如果你还没有你的账户，请通过窗口底部的Sign up按钮创建一个新账户：

图 11.4 - 创建你的账户

1. 创建一个实例。

登录后，单击窗口右上角的Create New Instance按钮：

图 11.5 - 创建一个新实例

1. 选择一个名称和付款计划。

这个名称是为了你的 MQTT 代理服务。你可以给它任何你想要的名字。我用了Packt MQTT Broker。

不幸的是，免费计划Cute Cat已经不再可用。所以，我们将在这里选择最便宜的计划Humble Hedgehog。这个计划每月需要 5 美元。

使用这个付费服务取决于你。如果你想避免计费，你需要寻找一个免费的 MQTT 代理服务。

选择名称和付款计划后，单击Select Region按钮：

图 11.6 - 选择名称和付款计划

1. 选择一个区域和数据中心。

这个服务正在AWS上运行。所以，你可以选择数据中心所在的区域。你可以选择任何区域。在这里，我们使用US-East-1。

1. 做出选择后，点击Review按钮：

图 11.7 - 选择区域和数据中心

1. 接下来，完成 MQTT 代理实例的创建。

请检查付款计划、服务名称、服务提供商和数据中心区域。之后，点击Create instance按钮完成此实例的创建：

图 11.8 - 完成 MQTT 代理实例创建

在边缘设备上发布来自 Node-RED 的数据

在本节中，我们将配置我们的树莓派。首先，启动树莓派并打开 Node-RED 流编辑器。这个 Node-RED 流编辑器应该仍然有一个流来发送传感器数据，实现在第十章，在树莓派上处理传感器数据中。如果你已经删除了这个流，或者你还没有创建它，请参考第十章，在树莓派上处理传感器数据来重新执行它。双击组成流的mqtt out节点以打开设置窗口。我们上次使用了Mosquitto，但这次我们将连接到CloudMQTT。

执行以下步骤配置树莓派上的 Node-RED 连接到 CloudMQTT：

1. 访问你在第十章中创建的流程，在树莓派上处理传感器数据。

在本章中，我们只使用了一个带有mqtt out节点的流，因为这个场景只是为了向树莓派发送数据：

图 11.9 - 访问我们在上一章中创建的流程

1. 编辑packt

2. 1

3. true

4. 单击Edit按钮（铅笔标记）右侧的Server以打开凭证属性：

图 11.11 - 单击“编辑”按钮打开属性设置

1. 在服务器设置面板上，选择driver.cloudmqtt.com

2. 18913

Connection选项卡中的其他属性不应该被更改，必须保持它们的默认值。

你可以参考以下截图来设置Connection选项卡：

图 11.12 – MQTT 代理服务器设置

1. 接下来，选择安全选项卡来编辑配置以连接 MQTT 代理，并填写每个属性如下：

• 用户名：您从 CloudMQTT 获得的用户。

• 密码：您从 CloudMQTT 获得的密码。

您可以参考以下截图来设置安全选项卡：

图 11.13 – MQTT 代理用户和密码设置

您可以在 CloudMQTT 管理菜单中检查这些属性。此菜单可以通过 CloudMQTT 仪表板的实例列表访问：customer.cloudmqtt.com/instance

图 11.14 – CloudMQTT 实例列表

这完成了树莓派端的设置。接下来，让我们设置 Node-RED 流编辑器，以便可以在云端的 Node-RED 上获取（订阅）数据。

在云端 Node-RED 上订阅和可视化数据

在本节中，我们将看到如何使用 Node-RED 在云端可视化接收到的数据。这使用了我们在第六章中学到的仪表板节点之一，但这次，我们将选择 Gauge 的 UI，使其看起来更好一些。

这次使用的云端 Node-RED 运行在 IBM Cloud（PaaS）上，但是之前创建了 MQTT 代理服务的 CloudMQTT 是一种与 IBM Cloud 不同的云服务。

在本章中，我们将学习到 MQTT 代理存在的原因，以便可以从各个地方访问它，并且发布者（数据分发者）和订阅者（数据接收者）都可以在不知道它在哪里的情况下使用它。

在 IBM Cloud 上准备 Node-RED

现在，让我们通过以下步骤创建一个连接到 CloudMQTT 的 Node-RED 流。在这里，我们将在 IBM Cloud 上使用 Node-RED。请注意，这不是树莓派上的 Node-RED：

1. 打开 Node-RED 流编辑器，登录到您的 IBM Cloud，并从仪表板中调用您已经创建的 Node-RED 服务。

2. 要么点击查看全部，要么点击Cloud Foundry 服务在资源摘要仪表板上的瓷砖。点击任一选项都会带您到您在 IBM Cloud 上创建的资源列表：

图 11.15 – 打开资源列表

如果您在 IBM Cloud 上尚未创建 Node-RED 服务，请参考第六章，在云中实现 Node-RED，在继续之前创建一个。

1. 在资源列表屏幕上显示的Cloud Foundry 应用下，点击您创建的 Node-RED 服务以打开 Node-RED 流编辑器：

图 11.16 – 选择您创建的 Node-RED 服务

1. 然后，点击访问应用 URL来访问 Node-RED 流编辑器：

图 11.17 – 点击访问应用 URL

1. 当 Node-RED 流编辑器的顶部屏幕显示时，点击转到您的 Node-RED 流编辑器按钮来打开 Node-RED 流编辑器：

图 11.18 – 点击转到您的 Node-RED 流编辑器按钮

1. 创建一个流来可视化数据。

当您在 IBM Cloud 上访问您的 Node-RED 流编辑器时，请按以下步骤创建一个流。在每个change节点之后放置mqtt in节点，json节点，两个change节点和gauge节点。如果您想要获取此流的调试日志，请在任何节点之后添加debug节点。在本例中，在mqtt in节点和第一个change节点之后放置了两个debug节点。

您已经拥有仪表板节点，包括仪表节点。如果没有，请返回到第六章中的为用例 2 制作流程-可视化数据教程中，在云中实现 Node-RED，以获取仪表板节点：

图 11.19 – 制作流程

1. 编辑packt

2. 1

3. auto-detect（字符串或缓冲区）

4. 单击右侧的编辑按钮（铅笔图标）以打开凭据属性：

图 11.20 – 单击编辑按钮打开属性设置

1. 在服务器设置面板上，选择driver.cloudmqtt.com

2. 18913

连接选项卡的其他属性不应更改，必须保持其默认值。

您可以参考以下截图进行连接选项卡设置：

图 11.21 – MQTT 代理服务器设置

1. 接下来，选择安全选项卡以编辑连接 MQTT 服务器的配置，并使用以下值填写每个属性：

• 用户名：您从 CloudMQTT 获取的用户。

• 密码：您从 CloudMQTT 获取的密码。

您可以参考以下截图进行安全选项卡设置：

图 11.22 – MQTT 代理用户和密码设置

正如您可能已经注意到的那样，这些属性具有您在树莓派 Node-RED 上为mqtt out节点设置的相同值。如有必要，请参考 CloudMQTT 仪表板。

1. 现在，编辑 json 节点。双击属性中的msg.payload：

图 11.23 – 设置 json 节点属性

1. 编辑规则区域下to框中的msg.payload.temperature的设置。然后，单击完成按钮关闭设置窗口：

图 11.24 – 设置第一个更改节点的属性

1. 此外，在规则区域的to框中编辑第二个msg.payload.humidity的设置，然后单击完成按钮关闭设置窗口：

图 11.25 – 设置第二个更改节点的属性

1. 编辑第一个仪表节点的设置。双击第一个仪表节点以打开设置窗口，然后单击右侧的编辑按钮（铅笔图标）以打开属性：

图 11.26 – 单击编辑按钮打开属性设置

1. 在仪表板的组设置面板中，使用以下值填写每个属性：

• 树莓派传感器数据

• 在此处提供任何名称都可以。此名称将显示在我们将创建的图表网页上。

其他属性不应更改，必须保持其默认值。您可以参考以下截图：

图 11.27 – 设置组名

1. 返回到Temperature的主面板

2. °C（如果您希望使用华氏度，请使用°F）

3. 范围：-15 ~ 50（如果您希望使用华氏度，请相应调整范围）

其他属性不应更改其默认值。您可以参考以下截图进行设置：

图 11.28 – 设置仪表节点属性

1. 编辑第二个湿度的设置

2. ％

3. 范围：0 ~ 100

其他属性不应更改其默认值。您可以参考以下屏幕截图进行设置：

图 11.29 – 设置表盘节点属性

请确保在 Node-RED 上部署流程。

这完成了 IBM Cloud 上的 Node-RED 配置。这意味着此流程已经订阅（等待数据）使用主题packt进行 CloudMQTT 服务。接下来是发布和订阅数据的时间。

在 IBM Cloud 上可视化数据

在边缘设备端，即树莓派上，我们已准备好使用主题packt将传感器数据发布到 CloudMQTT。在云端，流程已经使用packt主题进行 CloudMQTT 服务。

对于树莓派，执行以下步骤发布您的数据：

1. 从您的树莓派发布数据。

访问您的树莓派上的 Node-RED 流程编辑器。单击注入节点的按钮以运行此流程以发布槽温度和湿度传感器数据：

图 11.30 – 运行发布数据的流程

1. 检查 IBM Cloud 上数据的接收情况。

您将能够通过 CloudMQTT 接收（订阅）数据。您可以在 IBM Cloud 上的 Node-RED 流程编辑器的调试选项卡上检查：

图 11.31 – 检查数据的订阅情况

1. 通过 IBM Cloud 上的 Node-RED 流程编辑器的图表选项卡打开图表网页，然后单击打开按钮（对角箭头图标）打开它：

图 11.32 – 打开图表网页

您将看到显示数据的网页表盘图表：

图 11.33 – 显示图表网页

恭喜！现在您知道如何观察从树莓派发送到服务器的数据并将其可视化为图表。

如果您希望在 Node-RED 上进行流程配置文件以使此流程生效，您可以在这里获取：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter11/getting-sensordata-with-iotplatform.json。

总结

在本章中，我们体验了如何接收从边缘设备发送的传感器数据并在服务器端进行可视化。

在本章中，我们在 IBM Cloud 上使用了 CloudMQTT 和 Node-RED。Node-RED 可以在任何云平台和本地运行，并且您可以尝试在任何环境中制作这种应用。因此，记住这种模式对于您未来在其他云 IoT 平台上的开发肯定会有用。

在下一章中，我们将介绍如何使用 Node-RED 制作一个聊天机器人应用的实际场景。这将为您介绍 Node-RED 的新用法。

第十二章：使用 Slack 和 IBM Watson 开发聊天机器人应用程序

在这一章中，我们将使用 Node-RED 创建一个聊天机器人应用程序。对于聊天机器人应用程序的用户界面，我们将使用 Slack，并且我们将使用 IBM Watson AI 来进行技能。完成本章的教程后，您将学会如何将 Node-RED 与外部 API 结合起来创建一个应用程序。这将帮助您在未来使用 Node-RED 创建可扩展的 Web 应用程序。

让我们从以下主题开始：

• 创建 Slack 工作区

• 创建 Watson 助手 API

• 从 Node-RED 启用与 Slack 的连接

• 构建聊天机器人应用程序

在本章结束时，您将掌握如何使用 Node-RED 制作 Slack 聊天机器人应用程序。

技术要求

要在本章中取得进展，您将需要以下内容：

• IBM Cloud 账户：cloud.ibm.com/。

• 本章使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter12文件夹中找到。

创建 Slack 工作区

这个实践教程使用Slack作为您的聊天机器人应用程序的用户界面。Node-RED 负责控制聊天机器人应用程序背后的消息交换。

这个聊天机器人应用程序的整体视图如下：

图 12.1 – 应用程序概述

首先，使用以下步骤为此应用程序创建一个 Slack 工作区。如果您已经有一个 Slack 工作区，可以使用现有的工作区。在这种情况下，跳过以下步骤，并在您的工作区中创建一个名为learning-node-red的频道：

1. 访问slack.com/create，输入您的电子邮件地址，然后点击下一步按钮：

图 12.2 – 输入您的电子邮件地址

1. 从 Slack 收到的电子邮件中检查六位数验证码：

图 12.3 – 检查六位数验证码

1. 在您点击下一步并输入您的电子邮件地址后显示的窗口中输入验证码。输入验证码后，您将被自动重定向到下一个窗口：

图 12.4 – 输入验证码

1. 给您的工作区取一个名字，然后点击下一步按钮：

图 12.5 – 给您的工作区取一个名字

1. 在您的工作区中创建一个频道。您可以使用Learning Node-RED：

图 12.6 – 您的工作区名字

1. 点击暂时跳过而不添加队友：

图 12.7 – 本教程不需要队友

1. 点击在 Slack 中查看您的频道打开您创建的工作区：

图 12.8 – 在 Slack 中查看您的频道

您已为本教程创建了工作区：

图 12.9 – 您已创建了工作区

重要提示

聊天机器人所在的频道最好是只有您参与的频道，除非有公共目的。这是因为聊天机器人的活动可能会对不喜欢（或对聊天机器人不感兴趣的）参与者造成干扰。

此时，您已经准备好在 Slack 中运行您的聊天机器人的工作区和频道。接下来，我们将创建一个将成为聊天机器人引擎的机制。

创建 Watson 助手 API

这个实践教程使用 IBM 的Watson 助手 API作为聊天机器人的引擎。Watson 助手可以使用自然语言分析来解释自然对话的意图和目的，并返回适当的答案。

有关 Watson 助手的详细信息，请访问以下网址：www.ibm.com/cloud/watson-assistant-2/。

要使用 Watson 助手 API，您需要在 IBM Cloud 上创建 Watson 助手 API 的实例。按照以下步骤创建它：

1. 登录到 IBM Cloud 仪表板，并在目录中搜索助手。单击搜索结果中的助手图块：

图 12.10 – 搜索 Watson 助手

1. 创建 Watson 助手 API 服务。为 Watson 助手服务数据中心选择一个区域。达拉斯很稳定，所以我们选择了达拉斯。

2. 选择Lite作为定价计划。其他项目，如服务名称和资源组，可以保留其默认值。

3. 单击创建按钮：

图 12.11 – 创建 Watson 助手服务

1. 启动 Watson 助手工具。单击启动 Watson 助手按钮打开 Watson 助手控制台：

图 12.12 – 启动 Watson 助手控制台

1. 在您的Watson 助手服务中创建一个技能。

当您第一次打开 Watson 助手控制台时，您将自动转到我的第一个技能屏幕。

通常，您会在这里创建一个 Watson 助手技能，但是这个实践教程将专注于 Node-RED 而不是如何使用 Watson 助手。因此，通过导入预先准备的定义文件在 Watson 助手中创建一个技能。

如果您想创建自己的技能，那很好。在这种情况下，官方的 Watson 助手文档会帮助您：cloud.ibm.com/apidocs/assistant/assistant-v2。

1. 点击告诉我一个笑话。

2. 为此框架创建一个助手，将助手的名称设置为Respond Joke Phrase，然后单击创建助手按钮：

图 12.14 – 创建助手

1. 导入对话。创建助手后，将显示所创建助手的设置屏幕。在该设置屏幕上的对话区域中，单击添加对话技能按钮：

图 12.15 – 添加对话技能

1. 选择导入技能选项卡，并选择要导入的技能的 JSON 文件。在github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter12/skill-Respond-Joke-Phrase.json下载此 JSON 文件。

2. 选择 JSON 文件后，单击导入按钮：

图 12.16 – 导入对话技能文件

您将在对话区域看到Respond Joke Phrase：

图 12.17 – 导入对话技能

1. 技能导入完成。您可以返回简单的问候和笑话短语，因此尝试使用 Watson 助手控制台中提供的试一试功能进行对话：

图 12.18 – 试一试

单击试一试按钮时，将打开聊天窗口。在聊天窗口中尝试输入以下对话：

"你好"; "嗨"; "告诉 我 笑话"; "你 知道 笑话吗?"*; 等等…

图 12.19 – 测试对话

如果您得不到一个好的答案，请尝试另一个短语。Watson 自然语言理解将在 Watson 助手的试一试窗口中说的对话分成意图或实体的类。如果对话没有分成所需的类，您可以在试一试窗口中训练助手 API。

现在您已经使用 Watson Assistant 创建了自动回答对话，还有一件事要做，那就是确认技能 ID。这是您以后需要从 Node-RED 操作 Watson Assistant 作为 API 所需的 ID。

通过以下步骤从技能屏幕检查技能 ID：

1. 在您创建的技能瓦片的右上角的技能菜单下点击查看 API 详细信息：

图 12.20 - 访问查看 API 详细信息菜单

1. 记下显示的技能 ID：

图 12.21 - 检查并记录技能 ID

我们现在已经创建了一个自动回复聊天的聊天机器人服务。接下来，让我们将其与 Slack 用户界面集成。

启用从 Node-RED 到 Slack 的连接

接下来，让我们继续在您的 Node-RED 环境中准备一个 Slack 节点。启动在 IBM Cloud 上创建的 Node-RED 流程编辑器。

在这一步中，您要做的是在您的 Node-RED 环境中安装一个连接到 Slack 的节点。这种方法很简单。您所要做的就是在管理调色板窗口中找到并安装节点，这在其他章节中已经做过多次。

按照以下步骤继续：

重要提示

我相信您在 IBM Cloud 上的 Node-RED 流程编辑器已经作为服务（作为 Node.js 应用程序）创建好了，但如果您还没有这样做，请参考第六章**，在云中实现 Node-RED，在继续本章之前在 IBM Cloud 上创建一个 Node-RED 服务。

1. 您需要安装node-red-contrib-slack节点才能从 Node-RED 中使用 Slack，因此点击管理调色板：

图 12.22 - 打开管理调色板窗口

1. 搜索node-red-contrib-slack节点并点击安装按钮：

图 12.23 - 安装 node-red-contrib-slack 节点

1. 您将在调色板上看到属于node-red-contrib-slack的四个节点。您必须为构建此示例应用程序准备 Slack 节点：

图 12.24 - Slack 节点将出现在您的调色板上

1. 通过在 Slack 应用程序（桌面或 Web）上通过设置和管理 | 管理应用访问Slack App 目录，在您的 Slack 工作区中创建一个机器人：

图 12.25 - 选择管理应用

1. 移动到 Slack App 目录网站后，点击https://<your workspace>.slack.com/apps。

以下 URL 仅供参考：packtnode-red.slack.com/apps。

此 URL 根据 Slack 上每个工作区的名称自动生成。

1. 点击获取基本应用程序按钮，转到应用程序搜索窗口：

图 12.27 - 点击获取基本应用程序按钮

1. 搜索单词bots并点击结果中的Bots：

图 12.28 - 搜索 Bots 并选择它

1. 在Bots应用程序屏幕上点击添加到 Slack按钮：

图 12.29 - 将 Bots 应用添加到您的工作区

1. 设置packt-bot。

2. 点击添加机器人集成按钮：

图 12.30 – 设置您的机器人名称

1. 在下一个屏幕上，将生成并显示用于使用机器人的 API 令牌。记下这个令牌，以免忘记。创建 Node-RED 流程时会使用这个 API 令牌：

重要提示

在与应用程序共享机器人用户令牌时要小心。不要在公共代码存储库中发布机器人用户令牌。这是因为任何人都可以使用这个 API 令牌访问机器人。

图 12.31 – 确认您的 API 令牌

1. 点击保存集成按钮完成 Bot 应用程序的集成：

图 12.32 – Bot 应用程序集成完成

现在您已经准备好了。让我们继续进行流程创建过程。

构建一个聊天机器人应用程序

到目前为止，您已经在 Watson 助手中创建了一个聊天机器人引擎，创建了一个 Slack 工作区，并集成了 Bot 应用程序，您可以在该 Slack 工作区中使用。

在这里，我们将把这些服务与 Node-RED 结合起来，并创建一个机制，使得在 Slack 工作区中说话时，机器人会在 Node-RED 中回答。

按照以下步骤创建一个流程：

1. 将 Watson 助手连接到 Node-RED。通过 IBM Cloud 上的资源列表访问您的 Node-RED 服务仪表板。选择连接选项卡，然后点击创建连接按钮：

图 12.33 – 在 Node-RED 上创建新连接

1. 选择您创建的 Watson 助手服务，然后点击下一步按钮：

图 12.34 – 在 Node-RED 上创建新连接

1. 点击连接按钮，使用默认选项完成连接设置。执行此操作将重新启动 Node-RED 应用程序，这将需要几分钟来完成：

图 12.35 – 完成在 Node-RED 上创建新连接

1. 创建处理 Slack 上对话的流程。

您已经有了 Slack 节点和 Watson 节点，可以在这个实践教程中使用。

1. 放置一个slack-rtm-in节点，两个function节点，一个assistant节点，slack-rtm-out和一个debug节点。放置它们后，按照以下图示将它们依次连接起来：

图 12.36 – 放置节点并连接它们

1. 为每个节点设置参数。

按照以下步骤设置每个节点的参数。对于需要编码的节点，请按照以下方式进行编码：

• slack-rtm-in节点：

a) 点击编辑按钮（铅笔图标）打开属性面板：

图 12.37 – 打开属性面板

b) 输入packt-bot：

图 12.38 – 设置连接 Slack 应用程序的配置属性

当您返回到此节点的主面板时，您会看到Slack 客户端属性中的配置已经设置。

c) 点击完成按钮关闭此设置：

图 12.39 – 完成设置 slack-rtm-in 节点的属性

• function节点（第一个）：

a) 在第一个function节点中，输入以下内容：

global.set("channel",msg.payload.channel);
msg.topic = "message";
msg.payload = msg.payload.text;
return msg

您也可以参考以下图示：

图 12.40 – 第一个 function 节点编码

在这个 function 节点中，从 Slack 发送的消息被从 Slack 发送的 JSON 数据中取出，并再次放入msg.payload中。

另一个重要的过程是将从 Slack 发送的频道信息存储在 Node-RED 的全局变量中。这里存储的频道信息将在稍后向 Slack 发送响应消息时使用。

• 助手节点：

在上一步中，您将 Watson 助手连接到了 Node-RED。这意味着您可以从 Node-RED 调用助手 API，而无需使用 API 密钥或密码。

当我双击助手节点以打开设置面板时，我没有看到任何属性，比如 API 密钥。如果您在设置面板中看到它们，这意味着 Watson 助手和 Node-RED 连接过程失败了。在这种情况下，请重新执行连接过程。

这里只有一个属性需要设置。在assistant节点的设置面板中，将您之前写下的 Watson 助手技能 ID 设置为工作区 ID属性：

图 12.41 - 将技能 ID 设置为工作区 ID

这完成了助手节点的设置。保存您的设置并关闭设置面板。

• 功能节点（第二个节点）：

在第一个功能节点中，输入以下代码：

var g_channel=global.get("channel");
msg.topic = "message";
msg.payload = {
    channel: g_channel,
    text: msg.payload.output.text[0]
}
return msg

您还可以参考以下图：

图 12.42 - 第二个功能节点编码

第二个功能节点将 Watson 助手返回的自动回复消息存储在msg.payload.text中，并获取保存在第一个功能节点中的 Slack 频道信息，并将其存储在msg.payload.channel中。

• 您创建的packt-bot已经放置在此节点属性中。如果尚未设置，请从下拉列表中手动选择。单击完成后，设置将完成：

图 12.43 - 检查 slack-rtm-out 节点的属性设置

• 调试节点：

这里的调试节点只是简单地输出日志。不需要设置。

1. 在 Slack 上检查机器人应用。

使用 Slack 创建了一个自动回答聊天机器人。让我们尝试对话。

1. 在您的 Slack 工作区创建的频道上，添加您集成的机器人应用程序，并单击频道上的添加应用链接：

图 12.44 - 单击添加应用链接

1. 单击添加按钮将机器人应用添加到您的频道中：

图 12.45 - 添加您创建的机器人应用

现在，让我们真正进行一次对话。在您添加了这个机器人应用的频道上提及并与您的机器人（例如packt-bot）交谈。由于我们这次学习的唯一对话是问候和听笑话，我们将从 Slack 发送一条看起来与这两者之一相关的消息。

首先，让我们打个招呼。您将看到一种问候的回应：

图 12.46 - 与聊天机器人交换问候

然后发送一条消息，比如请 告诉 我 一个 笑话。它会随机回复一个机器人选定的笑话：

图 12.47 - 机器人回答一些笑话

干得好！您终于用 Node-RED 创建了聊天机器人应用。

如果您希望在 Node-RED 环境中创建此流程的流程配置文件，可以在此处获取：github.com/PacktPublishing/-Practical-Node-RED-Programming/blob/master/Chapter12/slack-watson-chatbot-flows.json。

总结

在本章中，我们体验了如何使用 Slack、Watson 和 Node-RED 制作聊天机器人应用程序。这次，我们使用 Slack 作为聊天平台，但您可以使用任何具有 API 的聊天平台，例如 LINE、Microsoft Teams 等，而不是 Slack。

本章对于创建任何非物联网应用程序也非常有帮助。Node-RED 可以通过与任何 Web API 链接来开发各种应用程序。

在下一章中，让我们开发自己的节点。当然，它可以在任何环境中使用。使用 Node-RED 开发自己的节点意味着开发一个无法通过现有节点完成的新节点。这无疑是 Node-RED 高级用户的第一步。

第十三章：在 Node-RED 库中创建和发布自己的节点

到目前为止，我们已经学习了如何使用准备好的节点在 Node-RED 中进行操作。在本章中，您将学习如何创建自己的节点并将其发布到库中。完成本章的教程后，您将能够发布自己的节点供全球各地的开发人员使用。

让我们从以下主题开始：

• 创建您自己的节点

• 在本地环境中测试您自己的节点

• 将您自己的节点发布为 Node-RED 库中的模块

在本章结束时，您将掌握如何创建自己的节点。

技术要求

要在本章中继续进行，您将需要以下内容：

• GitHub 帐户：github.com/。

• npm 帐户：www.npmjs.com/。

• Node-RED（在本地环境中独立运行）。

• IBM Cloud 帐户。

• 本章中使用的代码可以在github.com/PacktPublishing/-Practical-Node-RED-Programming的Chapter13文件夹中找到。

• 本教程的步骤基本上在 Mac 上进行处理。如果您使用 Windows PC，请用您的环境替换命令和文件路径。

创建您自己的节点

在开发节点之前，有一些事情您需要首先了解。为节点开发设置了以下策略。让我们遵循这些策略并开发一个节点。

在创建新节点时，您需要遵循一些一般规则。它们遵循核心节点采用的方法，并提供一致的用户体验。

您可以在官方 Node-RED 网站上查看创建节点的规则：nodered.org/docs/creating-nodes/。

节点程序开发

Node-RED 节点由两个文件组成：定义处理的 JavaScript 文件和提供 UI（例如设置屏幕）的 HTML 文件。在 JavaScript 文件中，您创建的节点的处理由一个函数来定义。该函数接收一个包含特定于节点的属性的对象。HTML 文件描述了 Node-RED 流编辑器显示的属性设置屏幕。在此 HTML 文件中显示的属性设置屏幕上输入的设置值从 JavaScript 文件中调用并进行处理。

在这里，我们将创建一个 GitHub 存储库，但如果您只想创建一个节点，则不需要 GitHub 存储库。在本章中，我们将使用 GitHub 存储库将创建的节点发布到库中，因此我希望您在步骤开始时创建存储库。

请按照以下步骤创建 GitHub 存储库：

1. 转到github.com/并使用您的 GitHub 帐户登录。

2. 选择node-red-contrib-<表示一组节点的名称>，因此相应地指定 GitHub 存储库名称。在本例中，它是node-red-contrib-taiponrock。

3. 在指定存储库名称后，将存储库公开范围设置为公共，检查 README 文件，并指定许可证。在本例中，它是使用Apache License 2.0创建的。

4. 设置完所有内容后，点击创建存储库按钮创建存储库：

图 13.2 – 存储库创建为公共项目

您现在已经创建了 GitHub 存储库。

现在让我们按照以下步骤将我们刚刚创建的存储库克隆到我们的本地开发环境：

1. 将存储库 URL 复制到剪贴板。点击绿色的Code下拉菜单，然后点击clipboard按钮复制 URL：

图 13.3 – 复制克隆此存储库的 URL

从命令行界面（如终端）本地克隆（git clone）存储库，其中Bash可以运行。

1. 转到要克隆（复制）存储库的工作目录。在这里，我在user目录下创建了一个工作目录并切换到它：

$ mkdir work
$ cd work

1. 使用之前创建的存储库的 URL 执行git clone命令：

$ git clone https://github.com/<GitHub account>/node-red-contrib-<Any specified string>.git

1. 克隆完成后，使用ls命令确认克隆成功：

$ls
node-red-contrib-<Any specified string>

现在让我们创建一个 JavaScript 文件。

从这里开始，我们将创建实际的节点处理。但不用担心，我们已经准备好了代码。提供的代码非常简单，用于处理节点。只需将作为输入传递的字符串转换为小写。

1. 首先，切换到克隆存储库的目录：

$ cd node-red-contrib-<arbitrary specified string>

1. 在此目录下，创建一个名为node.js的文件，如下所示：

module.exports = function(RED) {
    function LowerCaseNode(config) {
        RED.nodes.createNode(this,config);
        var node = this;
        node.on('input', function(msg) {
            msg.payload = msg.payload.toLowerCase();
            node.send(msg);
        });
    }
    RED.nodes.registerType("lower-case",LowerCaseNode);
}

node.js已创建。

现在让我们创建一个 HTML 文件。

1. 在与node.js和node.html创建的目录相同的位置创建一个名为node.html的文件，如下所示：

<script type="text/javascript">
    RED.nodes.registerType('lower-case',{
        category: 'function',
        color: '#a6bbcf',
        defaults: {
            name: {value:""}
        },
        inputs:1,
        outputs:1,
        icon: "file.png",
        label: function() {
            return this.name||"lower-case";
        }
    });
</script>
<script type="text/html" data-template-name="lower-case">
    <div class="form-row">
        <label for="node-input-name"><i class="icon-          tag"></i> Name</label>
        <input type="text" id="node-input-name"           placeholder="Name">
    </div>
</script>
<script type="text/html" data-help-name="lower-case">
    <p>A simple node that converts the message payloads         into all lower-case characters</p>
</script>

node.html已创建。这个 HTML 文件负责创建的节点的用户界面和设计。如前所述，一个节点总是由一个 HTML 文件和一个 JavaScript 文件组成。

节点实现几乎已经完成。接下来，让我们打包创建的节点，以便部署。

节点打包

现在我们已经创建了节点处理（JavaScript）和外观（HTML），是时候打包了。在 Node-RED 中，流编辑器本身是一个Node.js应用程序，运行在其上的每个节点也是一个 Node.js 应用程序。换句话说，这里的打包是使用 npm 进行的处理。

我们不会在这里详细介绍 npm。如果您想了解更多信息，请访问 npm 官方网站或参考各种技术文章：www.npmjs.com/。

现在，使用npm命令执行以下步骤：

1. npm 初始化。在创建node.js和node.html的目录中执行以下命令：

$ npm init

1. 运行npm init时，将会交互式地询问各种参数，根据您的需求输入。这些是我使用的参数：

完成此步骤后，npm init命令将生成一个package.json文件：

图 13.4 – npm init

1. 编辑package.json。您需要手动向package.json中添加 Node-RED 特定的设置。用文本编辑器打开package.json文件，并在 JSON 的与"name"和"version"相同级别处添加新属性："node-red": {"nodes": "{" lower-case ":" node.js "} }：

{
   "name": "node-red-contrib-<arbitrary string      specified>",
   "version": "1.0.0",
   (abridgement)
   "node-red": {
     "nodes": {
       "lower-case": "node.js"
     }
   },
   (abridgement)
}

以下截图可用作参考，可帮助您添加此属性：

图 13.5 – 编辑 package.json

这样就完成了自己节点的打包。让我们在下一部分中实际使用这个节点。

在本地环境中测试您自己的节点

您已经完成了自己的节点。让我们将迄今为止创建的节点添加到本地环境中的 Node-RED 中。

对于您自己的节点，非常重要的是在本地检查它们的运行情况。在不确定它在您的环境中是否正常工作的情况下，将节点发布到互联网对许多开发人员来说并不是一个好主意。

因此，在本节中，您将在本地环境中测试自己的节点。

节点安装

您可以使用npm link命令在本地测试节点模块。这允许您在本地目录中开发节点，并在开发过程中将它们链接到本地 Node-RED 安装中。

这非常简单。按照以下步骤进行：

1. 在 CLI 上执行以下命令以添加一个节点并启动 Node-RED：

$ cd <path to node module>
$ npm link

这将创建适当的符号链接到目录，并且 Node-RED 将在启动时发现节点。只需重新启动 Node-RED 即可获取节点文件的更改。

1. 在命令行上运行node-red命令以启动本地 Node-RED。如果已经启动，请重新启动。

重新启动后，您应该看到一个名为lower case的节点已添加到调色板的function类别中：

图 13.6 – 添加了小写节点

1. 让我们看看它是否可以正常使用。通过依次连接inject lower case debug的每个节点来创建一个流。

2. 对于inject节点的属性，将其设置为字符串类型，并将其设置为输出任何全大写字母的字符串，例如MY NAME IS TAIJI：

图 13.7 – 创建一个流

1. 当部署创建的流并执行inject节点时，您会看到作为此流参数的全大写字符串被转换为全小写字符串并输出到debug选项卡：

图 13.8 – 这个流的结果

接下来，让我们看看如何定制节点。

节点定制

我能够确认我创建的节点可以在本地环境中使用。从这里开始，我们将定制该节点。可以通过修改 JavaScript 和 HTML 来编辑节点的功能和外观。这些更改将在重新启动 Node-RED 时生效。

更改节点名称

目前，创建的节点的节点名称仍然是示例程序的小写版本。在这里，将此名称更改为您喜欢的任何名称。每个节点必须具有唯一名称，因此您应该选择尚不存在的名称。按照以下步骤更改节点的名称：

1. 在package.json文件中描述的lower-case更改为您自己的节点名称。

在示例中，节点的存储库是node-red-contrib-taiponrock，因此将其更改为taiponrock节点。

这是修改前的package.json文件的样子：

图 13.9 – 修改 package.json 前

修改后的样子如下：

图 13.10 – 修改 package.json 后

1. 在node.js文件中描述的lower-case和LowerCaseNode更改为您自己的节点名称。

例如，将lower-case更改为taiponrock，将LowerCaseNode更改为TaiponrockNode。

这是修改前的node.js文件的样子：

图 13.11 – 修改 node.js 前

这是修改后的node.js文件的样子：

图 13.12 – 修改 node.js 后

1. 在node.html文件中描述的lower-case更改为您自己的节点名称。

例如，将lower-case更改为taiponrock。

这是修改前的node.html文件的样子：

图 13.13 – 修改 node.html 前

这是修改后的node.html文件的样子：

图 13.14 – 修改 node.html 后

重新启动 Node-RED 后，您会看到它已被正确重命名：

图 13.15 – 您的节点已被重命名

接下来，我们将看看如何更改特定节点的代码。

更改节点代码

实现节点处理的主要部分如下：

1. 更改代码。您可以通过重写node.js中定义的msg.payload = msg.payload.toLowerCase();来更改节点的处理：

(abridgement)
node.on ('input', function (msg) {
     msg.payload = msg.payload.toLowerCase ();
     node.send (msg);
}
(abridgement)

在这里，为了使工作更易于理解，让我们改为仅返回您的姓名或昵称的字符串的方法。

1. 让我们将node.js重写如下：

(abridgement)
node.on ('input', function (msg) {
     msg.payload = "Taiponrock";
     node.send (msg);
}
(abridgement)

1. 执行该流。

现在让我们看看它是否已更改。使用您之前创建的流程。此流程中的lower case节点已更改为更改了名称和处理的节点，但需要重新部署和提升。为了更容易理解，删除曾经是原始lower case节点的节点，并重新定位它。

图 13.16 - 用重命名的节点替换您创建的节点并执行

1. 检查结果。当您部署创建的流程并执行inject节点时，您会看到在debug选项卡中显示了在更改节点代码部分中设置为常量的字符串（名称或昵称）。

图 13.17 - 此流程的结果

在下一节中，我们将看到一些其他可以使用的节点自定义选项。

其他自定义选项

除了节点名称，您还可以以许多不同的方式自定义自己的节点，例如节点颜色，节点图标，节点类别，节点功能等。有关详细信息，请参阅官方文档：nodered.org/docs/creating-nodes/appearance。

现在我们已经在本地环境中测试和自定义了节点，让我们将节点发布到 Node-RED 库中。

将您自己的节点发布为 Node-RED 库中的模块

在这里，我们将在 Node-RED 库中发布创建的节点。为此，需要一些工作。到目前为止，您已经创建了自己的节点，并确认它只能在您的环境中使用。但是，由于这是您创建的唯一节点，让我们将其发布在互联网上，让世界上的每个人都可以使用它。为此，您需要将自己的节点发布到一个称为 Node-RED 库的位置，该位置可以在此处找到：flows.nodered.org/。

重要提示

Node-RED 库是一个社区发布节点和流的地方。因此，您应该避免暴露不完整或无用的节点。这是因为 Node-RED 用户应该能够找到他们想要的节点，而不希望有不需要的节点混合在一起。

因此，尽管本章将解释如何发布节点，请避免暴露测试节点或示例节点级别的节点。

发布您创建的节点

按照以下步骤在 Node-RED 库中发布您自己的节点：

1. 维护一个README.md文件。

我们将在README.md文件中写节点描述。考虑到英语是一种通用语言，最好用英语写。

例如，最好描述以下内容：

• 概述解释

• 如何使用节点

• 屏幕截图

• 使用此节点的示例流

• 先决条件环境

• 更改日志

在本节中，由于这是一个实践教程，README.md文件中只会写概述和用法。请使用以下内容更新README.md：

# node-red-contrib-<Any specified string>
## Overview
This node is a node for forcibly converting all the alphabet character strings passed as input to the character string "Taipon rock".
Even if the input parameter passed is not a character string, "Taiponrock" is forcibly returned.
In this process, it is a wonderful node that changed the sample node that was executing toLowerCase, which is an instance method of String object in JavaScript, to a process that just returns a meaningless constant.
## how to use
It is used when you want to forcibly convert all the character strings of the parameters to be passed to "Taiponrock".

1. 上传文件 - 确保您在目录中有五个文件：node.js，node.html，package.json，README.md和LICENSE（如果包括package.lock.json也没关系）：

push finishes without error, you can see that the target file has been uploaded in the repository on GitHub:![Figure 13.19 – Your node files are uploaded    ](https://gitee.com/OpenDocCN/freelearn-node-zh/raw/master/docs/prac-node-red-prog/img/Figure_13.19_B16353.jpg)Figure 13.19 – Your node files are uploaded

1. 发布您的节点（npm publish）。

现在让我们将节点公开为模块。使用npm命令上传文件集。再次在克隆的存储库目录中工作：

npm publish. Don't forget to edit package.json to increase the version number, as the version must be up when you run npm publish a second time or later.When `publish` is completed normally, it will be published at `https://www.npmjs.com/package/node-red-contrib-<arbitrary character string>`.An example is `https://www.npmjs.com/package/node-red-contrib-taiponrock`:![Figure 13.20 – Your node has been published on npm    ](https://gitee.com/OpenDocCN/freelearn-node-zh/raw/master/docs/prac-node-red-prog/img/Figure_13.20_B16353.jpg)Figure 13.20 – Your node has been published on npm

1. 从 Node-RED 库的添加节点中注册创建的节点。

2. 在将您的节点添加到 Flow 库中，输入您创建的节点的名称，然后单击添加节点按钮：

图 13.21 - 将您的节点添加到 Node-RED 库

注册完成后，您会看到已创建的节点已添加到库中：

图 13.22 – 您的节点已在 Node-RED 库中发布

新节点的注册大约需要 15 分钟。请注意，通过 Node-RED 流程编辑器注册的节点，如果在 Node-RED 库上没有完全注册，将无法找到。

如果升级版本并重新发布，请从 Node-RED 库的节点页面刷新，并在节点屏幕右侧的操作面板中单击检查更新：

图 13.23 – 检查节点状态更新

接下来，让我们看看如何删除您发布的节点。

删除您发布的节点

删除已发布的节点时要小心。目前（截至 2020 年 10 月），根据 npm 的包取消发布政策，取消发布的截止时间为发布后的 24 至 72 小时。此外，即使在 72 小时或更长时间内下载量少于 300 次，也有可能取消发布对特定条件影响不大的软件包。

这些信息预计会不时更新，因此请参考 npm 官方网站获取最新信息：www.npmjs.com/policies/unpublish。

取消发布后，请像更新时一样从 Node-RED 库的节点页面刷新。单击节点屏幕右侧操作面板底部的请求刷新。

要取消发布，请在模块目录（克隆存储库的目录）中执行以下命令：

$ npm unpublish --force node-red-contrib- <arbitrary string>

如果此命令成功完成，则模块取消发布成功。

安装您发布的节点

建议您在将您的节点添加到Node-RED 库后等待至少 15 分钟。

在本地环境的 Node-RED 中，我反映了自制节点，以便可以直接使用。我还将其发布到 npm 进行发布，并在 Node-RED 库中注册了该节点。现在任何人都应该能够使用此节点。

在这里，让我们尝试并检查此次创建的节点是否可以从 IBM Cloud 的 Node-RED 中安装和使用，而不会出现任何问题。请按照以下步骤操作：

1. 登录 IBM Cloud，创建 Node-RED 服务，并启动 Node-RED 流程编辑器。

2. 在流程编辑器中打开管理调色板：

图 13.24 – 访问管理调色板

1. 选择安装选项卡，并开始在搜索字段中输入您创建的节点的名称。

如果您创建的节点显示在搜索结果中，这意味着它是公开的，并且是安装的目标。

1. 单击安装按钮进行安装。

如果它未显示在搜索结果中，则您可能在节点注册后未等待 15 分钟。请在 30 分钟或 1 小时后再试一次。如果仍然找不到您的节点，则可能有其他原因，请检查您迄今为止所做的步骤，并再次尝试：

图 13.25 – 搜索并安装您的节点

1. 确认您在调色板上创建的节点已安装，创建如下图所示的流程，并执行inject节点：

图 13.26 – 制作流程

在示例中，当首次启动 Node-RED 流程编辑器时，默认准备的流程之间插入了自制节点。

1. 运行inject节点后，请验证结果是否显示在debug窗口中：

图 13.27 – 此流程的结果

干得好！您现在知道如何制作自己的节点并发布它。

摘要

恭喜！在本章中，你学会了如何创建自己的节点，如何自定义它，以及如何从 Node-RED 库或本地机器设置它。创建自己的节点并不像你想象的那么困难。如果你根据这个过程创建处理内容并安排外观，你可以发布自己的有用节点，这些节点还不存在，并且全世界的开发者都可以使用它！

此外，在本书的结尾，我会给你一个简要介绍 Node-RED 用户社区，所以一定要去了解一下。

第十四章：Node-RED 用户社区

Node-RED 作为一个开源工具仍在不断发展。在幕后，不仅是 Node-RED 的创建者，还有许多用户都是塑造这个工具并为其做出贡献的重要力量。

我相信 Node-RED 的用户市场在未来会有更大的增长。在这里，我们将介绍用户社区；无论您是刚开始使用 Node-RED 还是已经使用了一段时间，请积极参与用户社区。

Node-RED 社区 Slack

在 Node-RED 的 Slack 上，创建者和用户讨论各种话题。您还可以向 Node-RED 核心团队提供反馈。

此外，支持本地语言的频道数量正在逐渐增加，因此任何人都可以轻松地参与对话：nodered.org/slack/

Node-RED 论坛

Node-RED 论坛为您提供了来自用户或创建者的技术问题和开发主题的支持。当与之前提到的 Slack 频道一起使用时，您将获得更多的好处：discourse.nodered.org/

日本用户组

这是一个 Node-RED 日本用户社区，本书的作者太地属于并组织。其代表是 Uhuru 的 Atsushi Kojo。提供的信息主要是用日语，但最近来自日本以外的参与者数量增加，也可以找到英语交流。每年，我们还举办一次名为 Node-RED Con 的全球 Node-RED 大会：nodered.jp/

标签：Node,创建,编程,应用程序,Red,使用,节点,RED
From： https://www.cnblogs.com/apachecn/p/18208673