SEODeploy 可以帮助我们在网站部署之前识别出 SEO 问题。

作为一个技术性搜索引擎优化开发者，我经常被请来协助做网站迁移、新网站发布、分析实施和其他一些影响网站在线可见性和测量等领域，以控制风险。许多公司每月经常性收入的很大一部分来自用户通过搜索引擎找到他们的产品和服务。虽然搜索引擎已经能妥善地处理没有被良好格式化的代码，但在开发过程中还是会出问题，对搜索引擎如何索引和为用户显示页面产生不利影响。

我曾经也尝试通过评审各阶段会破坏 SEO（ 搜索引擎优化 search engine optimization ）的问题来手动降低这种风险。我的团队最终审查到的结果，决定了该项目是否可以上线。但这个过程通常很低效，只能用于有限的页面，而且很有可能出现人为错误。

长期以来，这个行业一直在寻找可用且值得信赖的方式来自动化这一过程，同时还能让开发人员和搜索引擎优化人员在必须测试的内容上获得有意义的发言权。这是非常重要的，因为这些团队在开发冲刺中优先级通常会发生冲突，搜索引擎优化者需要推动变化，而开发人员需要控制退化和预期之外的情况。

常见的破坏 SEO 的问题

我合作过的很多网站有成千上万的页面，甚至上百万。实在令人费解，为什么一个开发过程中的改动能影响这么多页面。在 SEO 的世界中，Google 或其他搜索引擎展示你的页面时，一个非常微小和看起来无关紧要的修改也可能导致全网站范围的变化。在部署到生产环境之前，必须要处理这类错误。

下面是我去年见过的几个例子。

偶发的 noindex

在部署到生产环境之后，我们用的一个专用的第三方 SEO 监控工具 ContentKing 马上发现了这个问题。这个错误很隐蔽，因为它在 HTML 中是不可见的，确切地说，它隐藏在服务器响应头里，但它能很快导致搜索不可见。

HTTP/1.1 200 OK
Date: Tue May 25 2010 21:12:42 GMT
[...]
X-Robots-Tag: noindex
[...]

canonical 小写

上线时错误地把整个网站的 canonical 链接元素全改成小写了。这个改动影响了接近 30000 个 URL。在修改之前，所有的 URL 大小写都正常（例如 URL-Path 这样）。这之所以是个问题是因为 canonical 链接元素是用来给 Google 提示一个网页真实的规范 URL 版本的。这个改动导致很多 URL 被从 Google 的索引中移除并用小写的版本（/url-path）重新建立索引。影响范围是流量损失了 10% 到 15%，也污染了未来几个星期的网页监控数据。

源站退化

有个网站的 React 实现复杂而奇特，它有个神奇的问题，origin.domain.com URL 退化显示为 CDN 服务器的源站。它会在网站元数据（如 canonical 链接元素、URL 和 Open Graph 链接）中间歇性地显示原始的主机而不是 CDN 边缘主机。这个问题在原始的 HTML 和渲染后的 HTML 中都存在。这个问题影响搜索的可见性和在社交媒体上的分享质量。

SEODeploy 介绍

SEO 通常使用差异测试工具来检测渲染后和原始的 HTML 的差异。差异测试是很理想的，因为它避免了肉眼测试的不确定性。你希望检查 Google 对你的页面的渲染过程的差异，而不是检查用户对你页面的渲染。你希望查看下原始的 HTML 是什么样的，而不是渲染后的 HTML，因为 Google 的渲染过程是有独立的两个阶段的。

这促使我和我的同事创造了 SEODeploy 这个“在部署流水线中用于自动化 SEO 测试的 Python 库。”我们的使命是：

开发一个工具，让开发者能提供若干 URL 路径，并允许这些 URL 在生产环境和预演环境的主机上进行差异测试，尤其是对 SEO 相关数据的非预期的退化。

SEODeploy 的机制很简单：提供一个每行内容都是 URL 路径的文本文件，SEODeploy 对那些路径运行一系列模块，对比 生产环境 production 和 预演环境 staging 的 URL，把检测到的所有的错误和改动信息报告出来。

这个工具及其模块可以用一个 YAML 文件来配置，可以根据预期的变化进行定制。

最初的发布版本包含下面的的核心功能和概念：

1. 开源：我们坚信分享代码可以被大家批评、改进、扩展、分享和复用。
2. 模块化：Web 开发中有许多不同的堆栈和边缘案例。SEODeploy 工具在概念上很简单，因此采用模块化用来控制复杂性。我们提供了两个建好的模块和一个实例模块来简述基本结构。
3. URL 抽样：由于它不是对所有 URL 都是可行和有效的，因此我们引入了一种随机抽取 XML 网站地图 URL 或被 ContentKing 监控的 URL 作为样本的方法。
4. 灵活的差异检测：Web 数据是凌乱的。无论被检测的数据是什么类型（如 ext、数组或列表、JSON 对象或字典、整数、浮点数等等），差异检测功能都会尝试将这些数据转换为差异信息。
5. 自动化: 你可以在命令行来调用抽样和运行方法，将 SEODeploy 融合到已有的流水线也很简单。

模块

虽然核心功能很简单，但在设计上，SEODeploy 的强大功能和复杂度体现在模块上。模块用来处理更难的任务：获取、清理和组织预演服务器和生产服务器上的数据来作对比。

Headless 模块

Headless 模块 是为那些从库里获取数据时不想为第三方服务付费的开发者准备的。它可以运行任意版本的 Chrome，会从每组用来比较的 URL 中提取渲染的数据。

Headless 模块会提取下面的核心数据用来比较：

1. SEO 内容，如标题、H1-H6、链接等等。
2. 从 Chrome 计时器 Timings 和 CDP（ Chrome 开发工具协议 Chrome DevTools Protocol ）性能 API 中提取性能数据
3. 计算出的性能指标，包括 CLS（ 累积布局偏移 Cumulative Layout Shift ），这是 Google 最近发布的一个很受欢迎的 Web 核心数据
4. 从上述 CDP 的覆盖率 API 获取的 CSS 和 JavaScript 的覆盖率数据

这个模块引入了处理预演环境、网络速度预设（为了让对比更规范化）等功能，也引入了一个处理在预演对比数据中替换预演主机的方法。开发者也能很容易地扩展这个模块，以收集他们想要在每个页面上进行比较的任何其他数据。

其他模块

我们为开发者创建了一个示例模块，开发者可以参照它来使用框架创建一个自定义的提取模块。另一个示例模块是与 ContentKing 结合的。ContentKing 模块需要有 ContentKing 订阅，而 Headless 可以在所有能运行 Chrome 的机器上运行。

需要解决的问题

我们有扩展和强化工具库的计划，但正在寻求开发人员的反馈，了解哪些是可行的，哪些是不符合他们的需求。我们正在解决的问题和条目有：

1. 对于某些对比元素（尤其是 schema），动态时间戳会产生误报。
2. 把测试数据保存到数据库，以便查看部署历史以及与上次的预演推送进行差异测试。
3. 通过云基础设施的渲染，强化提取的规模和速度。
4. 把测试覆盖率从现在的 46% 提高到 99% 以上。
5. 目前，我们依赖 Poetry 进行部署管理，但我们希望发布一个 PyPl 库，这样就可以用 pip install 轻松安装。
6. 我们还在关注更多使用时的问题和相关数据。

开始使用

这个项目在 GitHub 上，我们对大部分功能都提供了 文档。

我们希望你能克隆 SEODeploy 并试试它。我们的目标是通过这个由技术性搜索引擎优化开发者开发的、经过开发者和工程师们验证的工具来支持开源社区。我们都见过验证复杂的预演问题需要多长时间，也都见过大量 URL 的微小改动能有什么样的业务影响。我们认为这个库可以为开发团队节省时间、降低部署过程中的风险。

如果你有问题或者想提交代码，请查看项目的关于页面。

via: https://opensource.com/article/20/7/seodeploy

作者：JR Oakes 选题：lujun9972 译者：lxbwolf 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

使用流行的 Flutter 框架开始你的跨平台开发之旅。

Flutter 是一个深受全球移动开发者欢迎的项目。该框架有一个庞大的、友好的爱好者社区，随着 Flutter 帮助程序员将他们的项目带入移动领域，这个社区还在继续增长。

本教程旨在帮助你开始使用 Flutter 进行移动开发。阅读之后，你将了解如何快速安装和设置框架，以便开始为智能手机、平板电脑和其他平台开发。

本操作指南假定你已在计算机上安装了 Android Studio，并且具有一定的使用经验。

什么是 Flutter ？

Flutter 使得开发人员能够为多个平台构建应用程序，包括：

• Android
• iOS
• Web（测试版）
• macOS（正在开发中）
• Linux（正在开发中）

对 macOS 和 Linux 的支持还处于早期开发阶段，而 Web 支持预计很快就会发布。这意味着你可以立即试用其功能（如下所述）。

安装 Flutter

我使用的是 Ubuntu 18.04，但其他 Linux 发行版安装过程与之类似，比如 Arch 或 Mint。

使用 snapd 安装

要使用 Snapd 在 Ubuntu 或类似发行版上安装 Flutter，请在终端中输入以下内容：

$ sudo snap install flutter --classic

$ sudo snap install flutter –classic
flutter 0+git.142868f from flutter Team/ installed

然后使用 flutter 命令启动它。 首次启动时，该框架会下载到你的计算机上：

$ flutter
Initializing Flutter
Downloading https://storage.googleapis.com/flutter_infra[...]

下载完成后，你会看到一条消息，告诉你 Flutter 已初始化：

手动安装

如果你没有安装 Snapd，或者你的发行版不是 Ubuntu，那么安装过程会略有不同。在这种情况下，请下载 为你的操作系统推荐的 Flutter 版本。

然后将其解压缩到你的主目录。

在你喜欢的文本编辑器中打开主目录中的 .bashrc 文件（如果你使用 Z shell，则打开 .zshc）。因为它是隐藏文件，所以你必须首先在文件管理器中启用显示隐藏文件，或者使用以下命令从终端打开它：

$ gedit ~/.bashrc &

将以下行添加到文件末尾：

export PATH="$PATH:~/flutter/bin"

保存并关闭文件。 请记住，如果在你的主目录之外的其他位置解压 Flutter，则 Flutter SDK 的路径 将有所不同。

关闭你的终端，然后再次打开，以便加载新配置。 或者，你可以通过以下命令使配置立即生效：

$ . ~/.bashrc

如果你没有看到错误，那说明一切都是正常的。

这种安装方法比使用 snap 命令稍微困难一些，但是它非常通用，可以让你在几乎所有的发行版上安装该框架。

检查安装结果

要检查安装结果，请在终端中输入以下内容：

flutter doctor -v

你将看到有关已安装组件的信息。 如果看到错误，请不要担心。 你尚未安装任何用于 Flutter SDK 的 IDE 插件。

安装 IDE 插件

你应该在你的 集成开发环境（IDE） 中安装插件，以帮助它与 Flutter SDK 接口、与设备交互并构建代码。

Flutter 开发中常用的三个主要 IDE 工具是 IntelliJ IDEA（社区版）、Android Studio 和 VS Code（或 VSCodium）。我在本教程中使用的是 Android Studio，但步骤与它们在 IntelliJ Idea（社区版）上的工作方式相似，因为它们构建在相同的平台上。

首先，启动 Android Studio。打开 “Settings”，进入 “Plugins” 窗格，选择 “Marketplace” 选项卡。在搜索行中输入 “Flutter”，然后单击 “Install”。

你可能会看到一个安装 “Dart” 插件的选项；同意它。如果看不到 Dart 选项，请通过重复上述步骤手动安装它。我还建议使用 “Rainbow Brackets” 插件，它可以让代码导航更简单。

就这样！你已经安装了所需的所有插件。你可以在终端中输入一个熟悉的命令进行检查：

flutter doctor -v

构建你的 “Hello World” 应用程序

要启动新项目，请创建一个 Flutter 项目：

1、选择 “New -> New Flutter project”。

2、在窗口中，选择所需的项目类型。 在这种情况下，你需要选择 “Flutter Application”。

3、命名你的项目为 hello_world。 请注意，你应该使用合并的名称，因此请使用下划线而不是空格。 你可能还需要指定 SDK 的路径。

4、输入软件包名称。

你已经创建了一个项目！现在，你可以在设备上或使用模拟器启动它。

选择你想要的设备，然后按 “Run”。稍后，你将看到结果。

现在你可以在一个 中间项目 上开始工作了。

尝试 Flutter for web

在安装 Flutter 的 Web 组件之前，你应该知道 Flutter 目前对 Web 应用程序的支持还很原始。 因此，将其用于复杂的项目并不是一个好主意。

默认情况下，基本 SDK 中不启用 “Flutter for web”。 要打开它，请转到 beta 通道。 为此，请在终端中输入以下命令：

flutter channel beta

接下来，使用以下命令根据 beta 分支升级 Flutter：

flutter upgrade

要使 “Flutter for web” 工作，请输入：

flutter config --enable-web

重新启动 IDE；这有助于 Android Studio 索引新的 IDE 并重新加载设备列表。你应该会看到几个新设备：

选择 “Chrome” 会在浏览器中启动一个应用程序， “Web Server” 会提供指向你的 Web 应用程序的链接，你可以在任何浏览器中打开它。

不过，现在还不是急于开发的时候，因为你当前的项目不支持 Web。要改进它，请打开项目根目录下的终端，然后输入：

flutter create

此命令重新创建项目，并添加 Web 支持。 现有代码不会被删除。

请注意，目录树已更改，现在有了一个 web 目录：

现在你可以开始工作了。 选择 “Chrome”，然后按 “Run”。 稍后，你会看到带有应用程序的浏览器窗口。

恭喜你！ 你刚刚为浏览器启动了一个项目，并且可以像其他任何网站一样继续使用它。

所有这些都来自同一代码库，因为 Flutter 使得几乎无需更改就可以为移动平台和 Web 编写代码。

用 Flutter 做更多的事情

Flutter 是用于移动开发的强大工具，而且它也是迈向跨平台开发的重要一步。 了解它，使用它，并将你的应用程序交付到所有平台！

via: https://opensource.com/article/20/9/mobile-app-flutter

作者：Vitaly Kuprenko 选题：lujun9972 译者：gxlct008 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

本文是该系列的第六篇。

• 第一篇: 模式
• 第二篇: OAuth
• 第三篇: 对话
• 第四篇: 消息
• 第五篇: 实时消息

我们已经实现了通过 GitHub 登录，但是如果想把玩一下这个 app，我们需要几个用户来测试它。在这篇文章中，我们将添加一个为任何用户提供登录的端点，只需提供用户名即可。该端点仅用于开发。

首先在 main() 函数中添加此路由。

router.HandleFunc("POST", "/api/login", requireJSON(login))

登录

此函数处理对 /api/login 的 POST 请求，其中 JSON body 只包含用户名，并以 JSON 格式返回通过认证的用户、令牌和过期日期。

func login(w http.ResponseWriter, r \*http.Request) {
    if origin.Hostname() != "localhost" {
        http.NotFound(w, r)
        return
    }

    var input struct {
        Username string `json:"username"`
    }
    if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    defer r.Body.Close()

    var user User
    if err := db.QueryRowContext(r.Context(), `
 SELECT id, avatar\_url
 FROM users
 WHERE username = $1
 `, input.Username).Scan(
        &user.ID,
        &user.AvatarURL,
    ); err == sql.ErrNoRows {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    } else if err != nil {
        respondError(w, fmt.Errorf("could not query user: %v", err))
        return
    }

    user.Username = input.Username

    exp := time.Now().Add(jwtLifetime)
    token, err := issueToken(user.ID, exp)
    if err != nil {
        respondError(w, fmt.Errorf("could not create token: %v", err))
        return
    }

    respond(w, map[string]interface{}{
        "authUser":  user,
        "token":     token,
        "expiresAt": exp,
    }, http.StatusOK)
}

首先，它检查我们是否在本地主机上，或者响应为 404 Not Found。它解码主体跳过验证，因为这只是为了开发。然后在数据库中查询给定用户名的用户，如果没有，则返回 404 NOT Found。然后，它使用用户 ID 作为主题发布一个新的 JSON Web 令牌。

func issueToken(subject string, exp time.Time) (string, error) {
    token, err := jwtSigner.Encode(jwt.Claims{
        Subject:    subject,
        Expiration: json.Number(strconv.FormatInt(exp.Unix(), 10)),
    })
    if err != nil {
        return "", err
    }
    return string(token), nil
}

该函数执行的操作与 前文 相同。我只是将其移过来以重用代码。

创建令牌后，它将使用用户、令牌和到期日期进行响应。

种子用户

现在，你可以将要操作的用户添加到数据库中。

INSERT INTO users (id, username) VALUES
    (1, 'john'),
    (2, 'jane');

你可以将其保存到文件中，并通过管道将其传送到 Cockroach CLI。

cat seed_users.sql | cockroach sql --insecure -d messenger

就是这样。一旦将代码部署到生产环境并使用自己的域后，该登录功能将不可用。

本文也结束了所有的后端开发部分。

• 源代码

via: https://nicolasparada.netlify.com/posts/go-messenger-dev-login/

作者：Nicolás Parada 选题：lujun9972 译者：gxlct008 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

下载我们的电子书，学习如何更好地使用 awk。

在众多 Linux 命令中，sed、awk 和 grep 恐怕是其中最经典的三个命令了。它们引人注目或许是由于名字发音与众不同，也可能是它们无处不在，甚至是因为它们存在已久，但无论如何，如果要问哪些命令很有 Linux 风格，这三个命令是当之无愧的。其中 sed 和 grep 已经有很多简洁的标准用法了，但 awk 的使用难度却相对突出。

在日常使用中，通过 sed 实现字符串替换、通过 grep 实现过滤，这些都是司空见惯的操作了，但 awk 命令相对来说是用得比较少的。在我看来，可能的原因是大多数人都只使用 sed 或者 grep 的一些变化实现某些功能，例如：

$ sed -e 's/foo/bar/g' file.txt
$ grep foo file.txt

因此，尽管你可能会觉得 sed 和 grep 使用起来更加顺手，但实际上它们还有更多更强大的作用没有发挥出来。当然，我们没有必要在这两个命令上钻研得很深入，但我有时会好奇自己“学习”命令的方式。很多时候我会记住一整串命令“咒语”，而不会去了解其中的运作过程，这就让我产生了一种很熟悉命令的错觉，我可以随口说出某个命令的好几个选项参数，但这些参数具体有什么作用，以及它们的相关语法，我都并不明确。

这大概就是很多人对 awk 缺乏了解的原因了。

为使用而学习 awk

awk 并不深奥。它是一种相对基础的编程语言，因此你可以把它当成一门新的编程语言来学习：使用一些基本命令来熟悉语法、了解语言中的关键字并实现更复杂的功能，然后再多加练习就可以了。

awk 是如何解析输入内容的

awk 的本质是将输入的内容看作是一个数组。当 awk 扫描一个文本文件时，会把每一行作为一条 记录 record ，每一条记录中又分割为多个 字段 field 。awk 记录了各条记录各个字段的信息，并通过内置变量 NR（记录数） 和 NF（字段数） 来调用相关信息。例如一下这个命令可以查看文件的行数：

$ awk 'END { print NR;}' example.txt
36

从上面的命令可以看出 awk 的基本语法，无论是一个单行命令还是一整个脚本，语法都是这样的：

模式或关键字 { 操作 }

在上面的例子中，END 是一个关键字而不是模式，与此类似的另一个关键字是 BEGIN。使用 BEGIN 或 END 可以让 awk 在解析内容前或解析内容后执行大括号中指定的操作。

你可以使用 模式 pattern 作为过滤器或限定符，这样 awk 只会对匹配模式的对应记录执行指定的操作。以下这个例子就是使用 awk 实现 grep 命令在文件中查找“Linux”字符串的功能：

$ awk '/Linux/ { print $0; }' os.txt
OS: CentOS Linux (10.1.1.8)
OS: CentOS Linux (10.1.1.9)
OS: Red Hat Enterprise Linux (RHEL) (10.1.1.11)
OS: Elementary Linux (10.1.2.4)
OS: Elementary Linux (10.1.2.5)
OS: Elementary Linux (10.1.2.6)

awk 会将文件中的每一行作为一条记录，将一条记录中的每个单词作为一个字段，默认情况下会以空格作为 字段分隔符 field separator （FS）切割出记录中的字段。如果想要使用其它内容作为分隔符，可以使用 --field-separator 选项指定分隔符：

$ awk --field-separator ':' '/Linux/ { print $2; }' os.txt
 CentOS Linux (10.1.1.8)
 CentOS Linux (10.1.1.9)
 Red Hat Enterprise Linux (RHEL) (10.1.1.11)
 Elementary Linux (10.1.2.4)
 Elementary Linux (10.1.2.5)
 Elementary Linux (10.1.2.6)

在上面的例子中，可以看到在 awk 处理后每一行的行首都有一个空格，那是因为在源文件中每个冒号（:）后面都带有一个空格。和 cut 有所不同的是，awk 可以指定一个字符串作为分隔符，就像这样：

$ awk --field-separator ': ' '/Linux/ { print $2; }' os.txt
CentOS Linux (10.1.1.8)
CentOS Linux (10.1.1.9)
Red Hat Enterprise Linux (RHEL) (10.1.1.11)
Elementary Linux (10.1.2.4)
Elementary Linux (10.1.2.5)
Elementary Linux (10.1.2.6)

awk 中的函数

可以通过这样的语法在 awk 中自定义函数：

函数名称(参数) { 操作 }

函数的好处在于只需要编写一次就可以多次复用，因此函数在脚本中起到的作用会比在构造单行命令时大。同时 awk 自身也带有很多预定义的函数，并且工作原理和其它编程语言或电子表格一样。你只需要了解函数需要接受什么参数，就可以放心使用了。

awk 中提供了数学运算和字符串处理的相关函数。数学运算函数通常比较简单，传入一个数字，它就会传出一个结果：

$ awk 'BEGIN { print sqrt(1764); }'
42

而字符串处理函数则稍微复杂一点，但 GNU awk 手册中也有充足的文档。例如 split() 函数需要传入一个待分割的单一字段、一个用于存放分割结果的数组，以及用于分割的 定界符 delimiter 。

例如前面示例中的输出内容，每条记录的末尾都包含了一个 IP 地址。由于变量 NF 代表的是每条记录的字段数量，刚好对应的是每条记录中最后一个字段的序号，因此可以通过引用 NF 将每条记录的最后一个字段传入 split() 函数：

$ awk --field-separator ': ' '/Linux/ { split($NF, IP, "."); print "subnet: " IP[3]; }' os.txt
subnet: 1
subnet: 1
subnet: 1
subnet: 2
subnet: 2
subnet: 2

还有更多的函数，没有理由将自己限制在每个 awk 代码块中。你可以在终端中使用 awk 构建复杂的管道，也可以编写 awk 脚本来定义和使用你自己的函数。

下载电子书

使用 awk 本身就是一个学习 awk 的过程，即使某些操作使用 sed、grep、cut、tr 命令已经完全足够了，也可以尝试使用 awk 来实现。只要熟悉了 awk，就可以在 Bash 中自定义一些 awk 函数，进而解析复杂的数据。

下载我们的这本电子书（需注册）学习并开始使用 awk 吧！

via: https://opensource.com/article/20/9/awk-ebook

作者：Seth Kenlon 选题：lujun9972 译者：HankChow 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

本文是该系列的第五篇。

• 第一篇: 模式
• 第二篇: OAuth
• 第三篇: 对话
• 第四篇: 消息

对于实时消息，我们将使用 服务器发送事件 Server-Sent Events 。这是一个打开的连接，我们可以在其中传输数据流。我们会有个端点，用户会在其中订阅发送给他的所有消息。

消息户端

在 HTTP 部分之前，让我们先编写一个 映射 map ，让所有客户端都监听消息。 像这样全局初始化：

type MessageClient struct {
    Messages chan Message
    UserID   string
}

var messageClients sync.Map

已创建的新消息

还记得在 上一篇文章 中，当我们创建这条消息时，我们留下了一个 “TODO” 注释。在那里，我们将使用这个函数来调度一个 goroutine。

go messageCreated(message)

把这行代码插入到我们留注释的位置。

func messageCreated(message Message) error {
    if err := db.QueryRow(`
 SELECT user\_id FROM participants
 WHERE user\_id != $1 and conversation\_id = $2
 `, message.UserID, message.ConversationID).
    Scan(&message.ReceiverID); err != nil {
        return err
    }

    go broadcastMessage(message)

    return nil
}

func broadcastMessage(message Message) {
    messageClients.Range(func(key, \_ interface{}) bool {
        client := key.(\*MessageClient)
        if client.UserID == message.ReceiverID {
            client.Messages <- message
        }
        return true
    })
}

该函数查询接收者 ID（其他参与者 ID），并将消息发送给所有客户端。

订阅消息

让我们转到 main() 函数并添加以下路由：

router.HandleFunc("GET", "/api/messages", guard(subscribeToMessages))

此端点处理 /api/messages 上的 GET 请求。请求应该是一个 EventSource 连接。它用一个事件流响应，其中的数据是 JSON 格式的。

func subscribeToMessages(w http.ResponseWriter, r \*http.Request) {
    if a := r.Header.Get("Accept"); !strings.Contains(a, "text/event-stream") {
        http.Error(w, "This endpoint requires an EventSource connection", http.StatusNotAcceptable)
        return
    }

    f, ok := w.(http.Flusher)
    if !ok {
        respondError(w, errors.New("streaming unsupported"))
        return
    }

    ctx := r.Context()
    authUserID := ctx.Value(keyAuthUserID).(string)

    h := w.Header()
    h.Set("Cache-Control", "no-cache")
    h.Set("Connection", "keep-alive")
    h.Set("Content-Type", "text/event-stream")

    messages := make(chan Message)
    defer close(messages)

    client := &MessageClient{Messages: messages, UserID: authUserID}
    messageClients.Store(client, nil)
    defer messageClients.Delete(client)

    for {
        select {
        case <-ctx.Done():
            return
        case message := <-messages:
            if b, err := json.Marshal(message); err != nil {
                log.Printf("could not marshall message: %v\n", err)
                fmt.Fprintf(w, "event: error\ndata: %v\n\n", err)
            } else {
                fmt.Fprintf(w, "data: %s\n\n", b)
            }
            f.Flush()
        }
    }
}

首先，它检查请求头是否正确，并检查服务器是否支持流式传输。我们创建一个消息通道，用它来构建一个客户端，并将其存储在客户端映射中。每当创建新消息时，它都会进入这个通道，因此我们可以通过 for-select 循环从中读取。

服务器发送事件 Server-Sent Events 使用以下格式发送数据：

data: some data here\n\n

我们以 JSON 格式发送：

data: {"foo":"bar"}\n\n

我们使用 fmt.Fprintf() 以这种格式写入响应 写入器 writter ，并在循环的每次迭代中刷新数据。

这个循环会一直运行，直到使用请求上下文关闭连接为止。我们延迟了通道的关闭和客户端的删除，因此，当循环结束时，通道将被关闭，客户端不会收到更多的消息。

注意， 服务器发送事件 Server-Sent Events （EventSource）的 JavaScript API 不支持设置自定义请求头?，所以我们不能设置 Authorization: Bearer <token>。这就是为什么 guard() 中间件也会从 URL 查询字符串中读取令牌的原因。

实时消息部分到此结束。我想说的是，这就是后端的全部内容。但是为了编写前端代码，我将再增加一个登录端点：一个仅用于开发的登录。

• 源代码

via: https://nicolasparada.netlify.com/posts/go-messenger-realtime-messages/

作者：Nicolás Parada 选题：lujun9972 译者：gxlct008 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

来学习下 Go 语言的安全检查工具 gosec。

Go 语言写的代码越来越常见，尤其是在容器、Kubernetes 或云生态相关的开发中。Docker 是最早采用 Golang 的项目之一，随后是 Kubernetes，之后大量的新项目在众多编程语言中选择了 Go。

像其他语言一样，Go 也有它的长处和短处（如安全缺陷）。这些缺陷可能会因为语言本身的缺陷加上程序员编码不当而产生，例如，C 代码中的内存安全问题。

无论它们出现的原因是什么，安全问题都应该在开发过程的早期修复，以免在封装好的软件中出现。幸运的是，静态分析工具可以帮你以更可重复的方式处理这些问题。静态分析工具通过解析用某种编程语言写的代码来找到问题。

这类工具中很多被称为 linter。传统意义上，linter 更注重的是检查代码中编码问题、bug、代码风格之类的问题，它们可能不会发现代码中的安全问题。例如，Coverity 是一个很流行的工具，它可以帮助寻找 C/C++ 代码中的问题。然而，也有一些工具专门用来检查源码中的安全问题。例如，Bandit 可以检查 Python 代码中的安全缺陷。而 gosec 则用来搜寻 Go 源码中的安全缺陷。gosec 通过扫描 Go 的 AST（ 抽象语法树 abstract syntax tree ）来检查源码中的安全问题。

开始使用 gosec

在开始学习和使用 gosec 之前，你需要准备一个 Go 语言写的项目。有这么多开源软件，我相信这不是问题。你可以在 GitHub 的 热门 Golang 仓库中找一个。

本文中，我随机选了 Docker CE 项目，但你可以选择任意的 Go 项目。

安装 Go 和 gosec

如果你还没安装 Go，你可以先从仓库中拉取下来。如果你用的是 Fedora 或其他基于 RPM 的 Linux 发行版本：

$ dnf install golang.x86_64

如果你用的是其他操作系统，请参照 Golang 安装页面。

使用 version 参数来验证 Go 是否安装成功：

$ go version
go version go1.14.6 linux/amd64

运行 go get 命令就可以轻松地安装 gosec：

$ go get github.com/securego/gosec/cmd/gosec

上面这行命令会从 GitHub 下载 gosec 的源码，编译并安装到指定位置。在仓库的 README 中你还可以看到安装该工具的其他方法。

gosec 的源码会被下载到 $GOPATH 的位置，编译出的二进制文件会被安装到你系统上设置的 bin 目录下。你可以运行下面的命令来查看 $GOPATH 和 $GOBIN 目录：

$ go env | grep GOBIN
GOBIN="/root/go/gobin"
$ go env | grep GOPATH
GOPATH="/root/go"

如果 go get 命令执行成功，那么 gosec 二进制应该就可以使用了：

$ ls -l ~/go/bin/
total 9260
-rwxr-xr-x. 1 root root 9482175 Aug 20 04:17 gosec

你可以把 $GOPATH 下的 bin 目录添加到 $PATH 中。这样你就可以像使用系统上的其他命令一样来使用 gosec 命令行工具（CLI）了。

$ which gosec
/root/go/bin/gosec
$

使用 gosec 命令行工具的 -help 选项来看看运行是否符合预期：

$ gosec -help

gosec - Golang security checker

gosec analyzes Go source code to look for common programming mistakes that
can lead to security problems.

VERSION: dev
GIT TAG:
BUILD DATE:

USAGE:

之后，创建一个目录，把源码下载到这个目录作为实例项目（本例中，我用的是 Docker CE）：

$ mkdir gosec-demo
$ cd gosec-demo/
$ pwd
/root/gosec-demo
$ git clone https://github.com/docker/docker-ce.git
Cloning into 'docker-ce'...
remote: Enumerating objects: 1271, done.
remote: Counting objects: 100% (1271/1271), done.
remote: Compressing objects: 100% (722/722), done.
remote: Total 431003 (delta 384), reused 981 (delta 318), pack-reused 429732
Receiving objects: 100% (431003/431003), 166.84 MiB | 28.94 MiB/s, done.
Resolving deltas: 100% (221338/221338), done.
Updating files: 100% (10861/10861), done.

代码统计工具（本例中用的是 cloc）显示这个项目大部分是用 Go 写的，恰好迎合了 gosec 的功能。

$ ./cloc /root/gosec-demo/docker-ce/
   10771 text files.
    8724 unique files.                                          
    2560 files ignored.


-----------------------------------------------------------------------------------
Language                         files          blank        comment           code
-----------------------------------------------------------------------------------
Go                                7222         190785         230478        1574580
YAML                                37           4831            817         156762
Markdown                           529          21422              0          67893
Protocol Buffers                   149           5014          16562          10071

使用默认选项运行 gosec

在 Docker CE 项目中使用默认选项运行 gosec，执行 gosec ./... 命令。屏幕上会有很多输出内容。在末尾你会看到一个简短的 “Summary”，列出了浏览的文件数、所有文件的总行数，以及源码中发现的问题数。

$ pwd
/root/gosec-demo/docker-ce
$ time gosec ./...
[gosec] 2020/08/20 04:44:15 Including rules: default
[gosec] 2020/08/20 04:44:15 Excluding rules: default
[gosec] 2020/08/20 04:44:15 Import directory: /root/gosec-demo/docker-ce/components/engine/opts
[gosec] 2020/08/20 04:44:17 Checking package: opts
[gosec] 2020/08/20 04:44:17 Checking file: /root/gosec-demo/docker-ce/components/engine/opts/address_pools.go
[gosec] 2020/08/20 04:44:17 Checking file: /root/gosec-demo/docker-ce/components/engine/opts/env.go
[gosec] 2020/08/20 04:44:17 Checking file: /root/gosec-demo/docker-ce/components/engine/opts/hosts.go

# End of gosec run

Summary:
   Files: 1278
   Lines: 173979
   Nosec: 4
  Issues: 644

real    0m52.019s
user    0m37.284s
sys     0m12.734s
$

滚动屏幕你会看到不同颜色高亮的行：红色表示需要尽快查看的高优先级问题，黄色表示中优先级的问题。

关于误判

在开始检查代码之前，我想先分享几条基本原则。默认情况下，静态检查工具会基于一系列的规则对测试代码进行分析，并报告出它们发现的所有问题。这是否意味着工具报出来的每一个问题都需要修复？非也。这个问题最好的解答者是设计和开发这个软件的人。他们最熟悉代码，更重要的是，他们了解软件会在什么环境下部署以及会被怎样使用。

这个知识点对于判定工具标记出来的某段代码到底是不是安全缺陷至关重要。随着工作时间和经验的积累，你会慢慢学会怎样让静态分析工具忽略非安全缺陷，使报告内容的可执行性更高。因此，要判定 gosec 报出来的某个问题是否需要修复，让一名有经验的开发者对源码做人工审计会是比较好的办法。

高优先级问题

从输出内容看，gosec 发现了 Docker CE 的一个高优先级问题，它使用的是低版本的 TLS（ 传输层安全 Transport Layer Security ）。无论什么时候，使用软件和库的最新版本都是确保它更新及时、没有安全问题的最好的方法。

[/root/gosec-demo/docker-ce/components/engine/daemon/logger/splunk/splunk.go:173] - G402 (CWE-295): TLS MinVersion too low. (Confidence: HIGH, Severity: HIGH)
    172:
  > 173:        tlsConfig := &tls.Config{}
    174:

它还发现了一个弱随机数生成器。它是不是一个安全缺陷，取决于生成的随机数的使用方式。

[/root/gosec-demo/docker-ce/components/engine/pkg/namesgenerator/names-generator.go:843] - G404 (CWE-338): Use of weak random number generator (math/rand instead of crypto/rand) (Confidence: MEDIUM, Severity: HIGH)
    842: begin:
  > 843:        name := fmt.Sprintf("%s_%s", left[rand.Intn(len(left))], right[rand.Intn(len(right))])
    844:        if name == "boring_wozniak" /* Steve Wozniak is not boring */ {

中优先级问题

这个工具还发现了一些中优先级问题。它标记了一个通过与 tar 相关的解压炸弹这种方式实现的潜在的 DoS 威胁，这种方式可能会被恶意的攻击者利用。

[/root/gosec-demo/docker-ce/components/engine/pkg/archive/copy.go:357] - G110 (CWE-409): Potential DoS vulnerability via decompression bomb (Confidence: MEDIUM, Severity: MEDIUM)
    356:
  > 357:                        if _, err = io.Copy(rebasedTar, srcTar); err != nil {
    358:                                w.CloseWithError(err)

它还发现了一个通过变量访问文件的问题。如果恶意使用者能访问这个变量，那么他们就可以改变变量的值去读其他文件。

[/root/gosec-demo/docker-ce/components/cli/cli/context/tlsdata.go:80] - G304 (CWE-22): Potential file inclusion via variable (Confidence: HIGH, Severity: MEDIUM)
    79:         if caPath != "" {
  > 80:                 if ca, err = ioutil.ReadFile(caPath); err != nil {
    81:                         return nil, err

文件和目录通常是操作系统安全的最基础的元素。这里，gosec 报出了一个可能需要你检查目录的权限是否安全的问题。

[/root/gosec-demo/docker-ce/components/engine/contrib/apparmor/main.go:41] - G301 (CWE-276): Expect directory permissions to be 0750 or less (Confidence: HIGH, Severity: MEDIUM)
    40:         // make sure /etc/apparmor.d exists
  > 41:         if err := os.MkdirAll(path.Dir(apparmorProfilePath), 0755); err != nil {
    42:                 log.Fatal(err)

你经常需要在源码中启动命令行工具。Go 使用内建的 exec 库来实现。仔细地分析用来调用这些工具的变量，就能发现安全缺陷。

[/root/gosec-demo/docker-ce/components/engine/testutil/fakestorage/fixtures.go:59] - G204 (CWE-78): Subprocess launched with variable (Confidence: HIGH, Severity: MEDIUM)
    58:
  > 59:              cmd := exec.Command(goCmd, "build", "-o", filepath.Join(tmp, "httpserver"), "github.com/docker/docker/contrib/httpserver")
    60:                 cmd.Env = append(os.Environ(), []string{

低优先级问题

在这个输出中，gosec 报出了一个 unsafe 调用相关的低优先级问题，这个调用会绕开 Go 提供的内存保护。再仔细分析下你调用 unsafe 的方式，看看是否有被别人利用的可能性。

[/root/gosec-demo/docker-ce/components/engine/pkg/archive/changes_linux.go:264] - G103 (CWE-242): Use of unsafe calls should be audited (Confidence: HIGH, Severity: LOW)
    263:        for len(buf) > 0 {
  > 264:                dirent := (*unix.Dirent)(unsafe.Pointer(&buf[0]))
    265:                buf = buf[dirent.Reclen:]



[/root/gosec-demo/docker-ce/components/engine/pkg/devicemapper/devmapper_wrapper.go:88] - G103 (CWE-242): Use of unsafe calls should be audited (Confidence: HIGH, Severity: LOW)
    87: func free(p *C.char) {
  > 88:         C.free(unsafe.Pointer(p))
    89: }

它还标记了源码中未处理的错误。源码中出现的错误你都应该处理。

[/root/gosec-demo/docker-ce/components/cli/cli/command/image/build/context.go:172] - G104 (CWE-703): Errors unhandled. (Confidence: HIGH, Severity: LOW)
    171:                err := tar.Close()
  > 172:                os.RemoveAll(dockerfileDir)
    173:                return err

自定义 gosec 扫描

使用 gosec 的默认选项会带来很多的问题。然而，经过人工审计，随着时间推移你会掌握哪些问题是不需要标记的。你可以自己指定排除和包含哪些测试。

我上面提到过，gosec 是基于一系列的规则从 Go 源码中查找问题的。下面是它使用的完整的规则列表：

• G101：查找硬编码凭证
• G102：绑定到所有接口
• G103：审计 unsafe 块的使用
• G104：审计未检查的错误
• G106：审计 ssh.InsecureIgnoreHostKey 的使用
• G107: 提供给 HTTP 请求的 url 作为污点输入
• G108: /debug/pprof 上自动暴露的剖析端点
• G109: strconv.Atoi 转换到 int16 或 int32 时潜在的整数溢出
• G110: 潜在的通过解压炸弹实现的 DoS
• G201：SQL 查询构造使用格式字符串
• G202：SQL 查询构造使用字符串连接
• G203：在 HTML 模板中使用未转义的数据
• G204：审计命令执行情况
• G301：创建目录时文件权限分配不合理
• G302：使用 chmod 时文件权限分配不合理
• G303：使用可预测的路径创建临时文件
• G304：通过污点输入提供的文件路径
• G305：提取 zip/tar 文档时遍历文件
• G306: 写到新文件时文件权限分配不合理
• G307: 把返回错误的函数放到 defer 内
• G401：检测 DES、RC4、MD5 或 SHA1 的使用
• G402：查找错误的 TLS 连接设置
• G403：确保最小 RSA 密钥长度为 2048 位
• G404：不安全的随机数源（rand）
• G501：导入黑名单列表：crypto/md5
• G502：导入黑名单列表：crypto/des
• G503：导入黑名单列表：crypto/rc4
• G504：导入黑名单列表：net/http/cgi
• G505：导入黑名单列表：crypto/sha1
• G601: 在 range 语句中使用隐式的元素别名

排除指定的测试

你可以自定义 gosec 来避免对已知为安全的问题进行扫描和报告。你可以使用 -exclude 选项和上面的规则编号来忽略指定的问题。

例如，如果你不想让 gosec 检查源码中硬编码凭证相关的未处理的错误，那么你可以运行下面的命令来忽略这些错误：

$ gosec -exclude=G104 ./...
$ gosec -exclude=G104,G101 ./...

有时候你知道某段代码是安全的，但是 gosec 还是会报出问题。然而，你又不想完全排除掉整个检查，因为你想让 gosec 检查新增的代码。通过在你已知为安全的代码块添加 #nosec 标记可以避免 gosec 扫描。这样 gosec 会继续扫描新增代码，而忽略掉 #nosec 标记的代码块。

运行指定的检查

另一方面，如果你只想检查指定的问题，你可以通过 -include 选项和规则编号来告诉 gosec 运行哪些检查：

$ gosec -include=G201,G202 ./...

扫描测试文件

Go 语言自带对测试的支持，通过单元测试来检验一个元素是否符合预期。在默认模式下，gosec 会忽略测试文件，你可以使用 -tests 选项把它们包含进来：

gosec -tests ./...

修改输出的格式

找出问题只是它的一半功能；另一半功能是把它检查到的问题以用户友好同时又方便工具处理的方式报告出来。幸运的是，gosec 可以用不同的方式输出。例如，如果你想看 JSON 格式的报告，那么就使用 -fmt 选项指定 JSON 格式并把结果保存到 results.json 文件中：

$ gosec -fmt=json -out=results.json ./...

$ ls -l results.json
-rw-r--r--. 1 root root 748098 Aug 20 05:06 results.json
$

         {
             "severity": "LOW",
             "confidence": "HIGH",
             "cwe": {
                 "ID": "242",
                 "URL": "https://cwe.mitre.org/data/definitions/242.html"
             },
             "rule_id": "G103",
             "details": "Use of unsafe calls should be audited",
             "file": "/root/gosec-demo/docker-ce/components/engine/daemon/graphdriver/graphtest/graphtest_unix.go",
             "code": "304: \t// Cast to []byte\n305: \theader := *(*reflect.SliceHeader)(unsafe.Pointer(\u0026buf))\n306: \theader.      Len *= 8\n",
             "line": "305",
             "column": "36"
         },

用 gosec 检查容易被发现的问题

静态检查工具不能完全代替人工代码审计。然而，当代码量变大、有众多开发者时，这样的工具往往有助于以可重复的方式找出容易被发现的问题。它对于帮助新开发者识别和在编码时避免引入这些安全缺陷很有用。

via: https://opensource.com/article/20/9/gosec

作者：Gaurav Kamathe 选题：lujun9972 译者：lxbowlf 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出