国内电子书厂商“文石”无视 Linux 内核协议引开源社区指责

Summary: • 国内的开源 PHP 论坛软件“修罗 BBS”停止，官方论坛关闭 • 优麒麟 20.04 LTS 发布：优化高清屏支持 上架 6 款新应用 • 谜之操作：巴克莱银行把互联网档案馆作为 JS 文件的 CDN

文石真的过分

文石会不会给国内开了不好的头？(我承认但是我接着干)

GPL其实是可以绕开的，就像安卓那样

# 国内电子书厂商“文石”无视 Linux 内核协议引开源社区指责

<img src="content_image/album_202007_07_114435bnh0tbd19gdbdld1.jpg" alt="" title="">

#### 国内电子书厂商文石无视 Linux 内核协议引开源社区指责

国内电子书厂商文石（Onyx）被指拒绝发布其电子书设备源码，违反 GPL v2 开源协议。Onyx 的电子书设备是在 Linux 内核基础上的改版，而 Linux 内核基于 GPL v2 许可证，该许可证有很明显的“传染性”，要求二次分发项目也必须开源。Onyx 官方回应“技术团队表示目前不能把源码开放”，并希望他人谅解。似乎是承认了自己已经违规，但是也没有办法改正。Onyx 的态度激起许多人的不满，甚至把对 Onyx 的批评上升到国家层面。

来源：[开源中国](https://www.oschina.net/news/116984/onyx-violate-the-linuxs-license)

>
> 拍一拍：毫无疑问，这是一种应该严厉谴责的行为。一些厂商，不仅不遵守开源许可证，而且对开源许可证非常无知。
>
>
>

#### 国内的开源 PHP 论坛软件“修罗 BBS”停止，官方论坛关闭

PHP 开源论坛“修罗 BBS”（Xiuno BBS）已于 7 月 6 日关闭，其官网称“国内什么时候有真正的开源环境了再见!”。同时，在其 4.0 版本的源码库中看到 18 小时前更新了 README，意指项目的开源之路将暂时停止。

来源：[开源中国](https://www.oschina.net/news/116992/xiunobbs-closed)

>
> 拍一拍：没有找到可持续发展模式的开源软件，或者说，不能应对恶劣环境的开源软件，早晚是这个结果。可惜了。
>
>
>

#### 优麒麟 20.04 LTS 发布：优化高清屏支持 上架 6 款新应用

除了功能改进与BUG修复，麒麟软件商店新增应用：Opera 浏览器、Vivaldi 浏览器、亿图图示软件、亿图项目管理软件、MindMaster思维导图软件、TeamViewer远程连接控制软件。

来源：[优麒麟](https://www.ubuntukylin.com/news/1597-cn.html)

>
> 拍一拍：这次发布的时间有点晚了啊。
>
>
>

#### 谜之操作：巴克莱银行把互联网档案馆作为 JS 文件的 CDN

英国金融集团巴克莱银行被发现会从互联网档案馆调用 JS 文件。调用的文件指向的是互联网档案馆时光机器存档的巴克莱银行网址。在引发广泛关注之后，巴克莱银行修改了代码不再把互联网档案馆作为 CDN，但没有解释它之前为什么这么做。

来源：[solidot](https://www.solidot.org/story?sid=64865)

>
> 拍一拍：这家银行连互联网档案馆的油都要揩，也是够了，心疼一下互联网档案馆。
>
>
>


使用一条 CI/CD 流水线管理所有的产品

Summary: 统一的持续集成与持续交付的流水线的构想是一种梦想吗？

统一的持续集成与持续交付的流水线的构想是一种梦想吗？

# 使用一条 CI/CD 流水线管理所有的产品

>
> 统一的持续集成与持续交付的流水线的构想是一种梦想吗？
>
>
>

当我加入 WorkSafeBC 负责云端运维和工程流程优化的云端运维团队时，我和大家分享了我的梦想，那就是一个工具化的流水线，每一个产品都可以持续集成和持续交付。

根据 Lukas Klose 的说法，<ruby>   流程  <rt>  flow </rt></ruby>（在软件工程的语境内）是“软件系统以稳定和可预测的速度创造价值的状态”。我认为这是最大的挑战和机遇之一，特别是在复杂的新兴解决方案领域。我力求通过一种持续、高效和优质的解决方案，提供一种持续交付模式，并且能够构建正确的事物让我们的用户感到满意。想办法把我们的系统分解成更小的碎片，这些碎片本身是有价值的，使团队能够渐进式地交付价值。这需要业务和工程部门改变思维方式。

### 持续集成和持续交付的（CI/CD）流水线

CI/CD 流水线是一种 DevOps 实践，用于更频繁、一致、可靠的地交付代码变更。它可以帮助敏捷开发团队提高**部署频率**，减少**变更准备时间**、**变更失败率**和关键绩效指标（KPI）的**平均恢复时间**，从而提高质量并且实现更快的交付。唯一的先决条件就是坚实的开发流程、对质量的心态和对需求从构想到废弃的责任心，以及一个全面的流水线（如下图所示）。

它简化了工程流程和产品，以稳定基础架构环境；优化工作流程；并创建一致的、可重复的、自动化的任务。正如 Dave Snowden 的 [Cynefin Sensemaking](https://en.wikipedia.org/wiki/Cynefin_framework) 模型所说的那样，这样就允许我们将复杂不可解决的任务变成了复杂可解决的任务，降低了维护成本，提高了质量和可靠性。

精简流程的一部分是将 <ruby>   浪费实践类型  <rt>  wasteful practice types </rt></ruby> Muri（过载）、Mura（变异）和 Muda（浪费）的浪费降低最低。

* **Muri（过载）**：避免过度工程化，避免与商业价值不相关的功能以及过多的文档。
* **Mura（变异）**：改善审批和验证流程（比如，安全签批）；推动 <ruby>   左移提前  <rt>  shift-left </rt></ruby> 策略以推行单元测试、安全漏洞扫描与代码质量检查；并改进风险评定。
* **Muda（浪费）**：避免技术债、错误或前期的详细文档等浪费。

看起来 80％ 的重点都集中在提供一种可以集成和协作的工程产品上，这些系统可以采用一个创意和计划、开发、测试和监控你的解决方案。然而，一个成功的转型和工程系统是由 5％ 的产品、15％ 的过程和 80％ 的开发人员组成的。

我们可以使用的产品有很多。比如，Azure DevOps 为持续集成（CI）、持续交付（CD）和可扩展性提供了丰富支持，并与 Stryker、SonarQube、WhiteSource、Jenkins 和 Octopus 等开源集成和商用成品（COTS）软件即服务（SaaS）进行集成。对于工程师来说，关注产品总是一种诱惑，但请记住，它们只是我们旅程的 5%。

最大的挑战是打破数十年的规则、规定和已经步入舒适区的流程：“*我们一直都是这样做的；为什么需要改变呢？*”

开发和运维人员之间的摩擦导致了各种支离破碎的、重复的、不间断的集成和交付流水线。开发人员希望能访问所有东西，以便持续迭代，让用户使用起来和持续地快速发布。运维人员希望将所有东西锁起来，保护业务、用户和品质。这些矛盾在不经意间导致了很难做到一种自动化的流程，进而导致发布周期晚于预期。

让我们使用最近的一次白板讨论中的片段来探索流水线。

想要支持流水线的变化是一项困难并且花费巨大的工作；版本和可追溯性的不一致使得这个问题变得更加复杂，因此不断精简开发流程和流水线是一项挑战。

我主张一些原则使得每个产品都能使用通用流水线：

* 使一切可自动化的东西都自动化
* 一次构建
* 保持持续集成和持续交付
* 保持持续精简和改进
* 保持一个构建的定义
* 保持一个发布流水线的定义
* 尽早、频繁地扫描漏洞，并且*尽快失败*
* 尽早、频繁地进行测试，并且*尽快失败*
* 保持已发布版本的可追踪和监控

但是，如果我要打破这些，最重要的原则就是*保持简单*。如果你不能说明流水线化的原因（是什么、为什么）和过程（如何），你或许是不了解自己的软件过程的。我们大多数人想要的不是最好的、超现代的和具有革命意义的流水线 —— 我们仅仅是需要一个功能强大的、有价值的和能促进工程的流水线。首先需要解决的是那 80% —— 文化、人员和他们的心态。请你的 CI/CD 骑士们穿上闪亮的盔甲，在他们的盾牌上贴上 TLA（<ruby> 两个/三个字母的缩写 <rt>  two/three-lettered acronym </rt></ruby>）符号，加入到实践和经验工程的力量中来。

### 统一流水线

让我们逐步完成我们的白板会议实践。

每个应用使用一套构建定义来定义一个 CI/CD 流水线，用来触发*拉取请求的预合并验证*与*持续集成*的构建。生成一个带有调试信息的*发布*的构建，并且将其上传到 [符号服务器](https://en.wikipedia.org/wiki/Microsoft_Symbol_Server)。这使开发人员可以在本地和远程生产环境进行调试，而在不用考虑需要加载哪个构建和符号，符号服务器为我们施展了这样的魔法。

在构建过程中进行尽可能多的验证（*左移提前*），这允许开发新特性的团队可以尽快失败，不断的提高整体的产品质量，并在拉取请求中为代码审核人员提供宝贵证据。你喜欢有大量提交的拉取请求吗？还是一个带有少数提交和提供了漏洞检查、测试覆盖率、代码质量检查和 [Stryker](https://stryker-mutator.io/) 突变残余等支持的拉取请求？就我个人而言，我投后者的票。

不要使用构建转换来生成多个特定环境的构建。通过一个构建实现*发布时转换*、*标记化*和 XML/JSON 的*值替换*。换句话说，*右移滞后*具体环境的配置。

安全存储发布配置数据，并且根据数据的*信任度*和*敏感度*，让开发和运维都能使用。使用开源的密钥管理工具、Azure 密钥保险库、AWS 密钥管理服务或者其他产品，记住你的工具箱中有很多方便的工具。

使用*用户组*而不是*用户*，将审批人管理从跨多个流水线的多个阶段移动到简单的组成员。

创建一条流水线并且对赋予特定的交付阶段的权限，而不是重复流水线让团队进入他们感兴趣的地方。

最后，但并非最不重要的是，拥抱拉取请求，以帮助提高对代码仓库的洞察力和透明度，增进整体质量、协作，并将预验证构建发布到选定的环境，比如，开发环境。

这是整个白板更正式的视图。

所以，你对 CI/CD 流水线有什么想法和经验？我的通过*一条流水线来管理它们*的这个梦想是空想吗？

---

via: <https://opensource.com/article/19/7/cicd-pipeline-rule-them-all>

作者：[Willy-Peter Schaub](https://opensource.com/users/wpschaub/users/bclaster/users/matt-micene/users/barkerd427) 选题：[lujun9972](https://github.com/lujun9972) 译者：[chunibyo-wly](https://github.com/chunibyo-wly) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


如何在 Mac 上安装 Java

Summary: macOS 用户可以运行 Java 的开源版本，以及用于云原生开发的新框架。

macOS 用户可以运行 Java 的开源版本，以及用于云原生开发的新框架。

# 如何在 Mac 上安装 Java

>
> macOS 用户可以运行 Java 的开源版本，以及用于<ruby> 云原生 <rt>  cloud native </rt></ruby>开发的新框架。
>
>
>

五月底，Java 庆祝了它的 25 周年纪念日，为了纪念这一时刻，世界各地的开发人员使用 [#MovedByJava](https://twitter.com/search?q=%23MovedByJava&src=typed_query) 这一标签分享他们使用这一编程语言的成就、记忆以及愿景。

>
> 我的时间线：
>
>
> * 1999 开始学习 Java
> * 2007 创建 [@grailsframework](https://twitter.com/grailsframework?ref_src=twsrc%5Etfw)
> * 2008 共同创建 G20ne
> * 2009 被 SpringSource 收购
> * 2015 加入 [@ObjectComputing](https://twitter.com/ObjectComputing?ref_src=twsrc%5Etfw)
> * 2018 创建 [@micronautfw](https://twitter.com/micronautfw?ref_src=twsrc%5Etfw) / 获得 [@groundbreakers](https://twitter.com/groundbreakers?ref_src=twsrc%5Etfw) 奖
> * 2019 成为 [@Java\_Champions](https://twitter.com/Java_Champions?ref_src=twsrc%5Etfw)
>
>
> 感谢你 [@java](https://twitter.com/java?ref_src=twsrc%5Etfw)！[#MovedByJava](https://twitter.com/hashtag/MovedByJava?src=hash&ref_src=twsrc%5Etfw)
>
>
> — Graeme Rocher (@graemerocher) [2020年5月21日](https://twitter.com/graemerocher/status/1263484918157410304?ref_src=twsrc%5Etfw)
>
>
>

多年来，许多技术和趋势都促进了 Java 堆栈的开发、部署和在标准应用程序服务器上运行多个应用的能力。为 [Kubernetes](https://opensource.com/resources/what-is-kubernetes) 构建容器镜像使得 Java 开发者可以在多个云环境中打包和部署<ruby>   微服务  <rt>  microservices </rt></ruby>，而不是在虚拟机上运行几个应用程序服务器。

有了这些技术，Java 应用程序栈被优化为运行更大的堆和可以在运行时做出决策的高动态框架。然而不幸的是，这些努力还不足以使 Java 成为开发人员为<ruby> 无服务器 <rt>  serverless </rt></ruby>和事件驱动平台开发<ruby> 云原生 <rt>  cloud native </rt></ruby> Java 应用程序的首选编程语言。其他语言填补了这部分空缺，特别是 JavaScript、Python 和 Go，而 Rust 和 WebAssembly 也成了新的选择。

尽管存在这种竞争，<ruby>   云原生 Java  <rt>  cloud native Java </rt></ruby> 正在对以云为中心的软件开发产生影响。好在，新的 Java 框架（比如，[Quarkus](https://quarkus.io/)、[Micronaut](https://micronaut.io/) 和 [Helidon](https://helidon.io/#/)）最近已经战胜了这些挑战，它们提供了编译速度更快而且更小的应用，同时它们在设计之初就将分布式系统考虑了进去。

### 如何在 macOS 上安装 Java

Java 开发的未来将从更多人安装和使用 Java 开始。因此，我将介绍如何在 macOS 上安装并开始使用 Java 开发环境。（如果你运行的是 Linux，请查看 Seth Kenlon 的文章《[如何在 Linux 上安装 Java](/article-11614-1.html)》）

#### 通过 Brew 仓库安装 OpenJDK

Homebrew 是 macOS 事实上的标准软件包管理器。如果你还没有安装的话，Matthew Broberg 的文章《[Homebrew 简介](/article-12338-1.html)》将带你完成这些步骤。

当你在 Mac 上安装好 Homebrew 后，使用 `brew` 命令安装 [OpenJDK](https://openjdk.java.net/)，这是编写 Java 应用程序的开源方式：

```
$ brew cask install java

```

不到一分钟就能看到：

```
? java was successfully installed!

```

通过 `java -version` 命令确认 OpenJDK 已经正确安装：

```
$ java -version
openjdk version "14.0.1" 2020-04-14
OpenJDK Runtime Environment (build 14.0.1+7)
OpenJDK 64-Bit Server VM (build 14.0.1+7, mixed mode, sharing

```

从输出中可以确认 OpenJDK 14 （本文撰写时的最新版本）已经安装。

#### 从二进制文件安装 OpenJDK

如果你并不热衷于包管理器，并且更愿意自己来管理 Java 的话，那么你总是可以选择下载并且手动安装。

我在 OpenJDK 主页上找到了最新版本的下载链接。下载 OpenJDK 14 的二进制文件：

```
$ wget https://download.java.net/java/GA/jdk14.0.1/664493ef4a6946b186ff29eb326336a2/7/GPL/openjdk-14.0.1_osx-x64_bin.tar.gz

```

移动到你保存二进制文件的目录，然后解压：

```
$ tar -xf openjdk-14.0.1_osx-x64_bin.tar.gz

```

接下来，将 Java 加入到你的 PATH：

```
$ export PATH=$PWD/jdk-14.0.1.jdk/Contents/Home/bin:$PATH

```

同时，将这条命令加到你的点文件中，`.bash_profile` 还是 `.zshrc` 取决于你运行的 shell。你可以在《[如何在 Linux 中设置你的 PATH 变量][23]》一文中了解更多关于配置 `PATH变量][23]》一文中了解更多关于配置‘](https://opensource.com/article/17/6/set-path-linux)》一文中了解更多关于配置 `$PATH` 变量的内容。

最后，验证你安装的 OpenJDK 14：

```
$ java -version
openjdk version "14.0.1" 2020-04-14
OpenJDK Runtime Environment (build 14.0.1+7)
OpenJDK 64-Bit Server VM (build 14.0.1+7, mixed mode, sharing)

```

### 在 Mac 上编写你的第一个<ruby>   微服务  <rt>  microservices </rt></ruby>

现在，你已经准备好在 maxOS 上使用 OpenJDK 堆栈开发<ruby> 云原生 <rt>  cloud native </rt></ruby> Java 应用程序了。在本教程中，你将在 [Quarkus](https://quarkus.io/) 上创建一个新的 Java 项目，这个项目使用<ruby> 依赖注入 <rt>  dependency injection </rt></ruby>来公布 REST API。

你需要 [Maven](https://maven.apache.org/index.html) 启动，它是一个非常流行的 Java 依赖管理器。从 Maven 的网站[安装](https://maven.apache.org/install.html)它，或者通过 Homebrew 使用 `brew install maven` 命令。

执行以下 Maven 命令来配置 Quarkus 项目，并且创建一个简单的 web 应用：

```
$ mvn io.quarkus:quarkus-maven-plugin:1.5.1.Final:create \
    -DprojectGroupId=com.example \
    -DprojectArtifactId=getting-started \
    -DclassName="com.example.GreetingResource" \
    -Dpath="/hello"
cd getting-started

```

运行这个应用：

```
$ ./mvnw quarkus:dev

```

当应用程序运行的时候，你可以看到这个输出：

```
__  ____  __  _____   ___  __ ____  ______
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
\--\\___\\_\\____/_/ |_/_/|_/_/|_|\\____/___/
2020-06-13 00:03:06,413 INFO  [io.quarkus] (Quarkus Main Thread) getting-started 1.0-SNAPSHOT on JVM (powered by Quarkus 1.5.1.Final) started in 1.125s. Listening on: <http://0.0.0.0:8080>
2020-06-13 00:03:06,416 INFO  [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
2020-06-13 00:03:06,416 INFO  [io.quarkus] (Quarkus Main Thread) Installed features: [cdi, resteasy]

```

使用 `curl` 命令访问 REST 端点：

```
$ curl -w "\n" http://localhost:8080/hello
hello

```

恭喜！通过使用 Mavan 和 Quarkus，你很快从没有安装 Java 的环境里创建了第一个 web 应用。

### 接下来用 Java 做什么

Java 是一个成熟的编程语言，通过专门为<ruby> 云原生 <rt>  cloud native </rt></ruby>应用程序开发设计的新框架，Java 的热度会一直持续下去。

如果你正走在这样构建未来应用的路上，你可能会对更多实用的 Quarkus 开发课程或其他现代化框架感兴趣。无论你在构建什么，下一步是配置你的文本编辑器。阅读我关于《[在 VS Code 用 Quarkus 编写 Java](https://opensource.com/article/20/4/java-quarkus-vs-code)》的教程，然后再看看你能做什么。

---

via: <https://opensource.com/article/20/7/install-java-mac>

作者：[Daniel Oh](https://opensource.com/users/daniel-oh) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Yufei-Yan](https://github.com/Yufei-Yan) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


“Linux文章”小程序支持分享到朋友圈了

Summary: 昨天看到一个令人振奋的消息，小程序现在开始测试分享到朋友圈的功能。

昨天看到一个令人振奋的消息，小程序现在开始测试分享到朋友圈的功能。

# “Linux文章”小程序支持分享到朋友圈了

昨天看到一个令人振奋的消息，小程序现在开始测试分享到朋友圈的功能。

目前该功能尚属测试，具有如下限制：

* 仅支持安卓版微信中将小程序分享到朋友圈，不过 iOS 版微信可以打开分享到朋友圈的小程序
* 需要几乎是最新版的小程序基础库 2.11.3，只有 83.66% 的微信用户支持该版本
* 如果使用了云开发，需要修改云开发中的若干限制
* 分享到朋友圈中的页面是一个新的“单页模式”，在此模式下，小程序的功能受限，仅适合做内容展示
* 存在 web-view 的页面不能分享

我考虑了一下，我们视作官方 APP 的 “Linux文章” 小程序正好是一个纯内容类的小程序，特别适合。于是昨晚花了一晚上研究[文档](https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/share-timeline.html)和调试，[遇到了一些问题](https://developers.weixin.qq.com/community/develop/doc/0008ca995b81a8e4eb9ac2e0f5b000?fromCreate=0)，今天上午终于开发完成，并成功发布了！

*小程序分享到朋友圈*

点击分享内容，可以看到一个“单页模式”下的页面：

*小程序的“单页模式”*

根据微信的说法，“单页模式”有比较多的限制和变化：

1. “单页模式”下，小程序会有一些固定组件，样式会有所变化
2. “单页模式”下，一些组件或接口存在一定限制
3. 页面无登录态，与登录相关的接口不可用；云开发资源需开启未登录访问方可在单页模式下使用
4. 不允许跳转到其它页面
5. 不允许横屏使用
6. tabBar 不会渲染
7. 本地存储与小程序普通模式不共用
8. 对于一些会产生交互的组件或接口，在点击后调用时，会提示“请前往小程序使用完整服务”

这个页面适合直接查看内容。

对于小程序这次开放支持朋友圈的能力，我认为对小程序生态来说是个好事，但是从微信官方的态度来看，他们还是特别审慎的，专门在文档中警告：“**分享朋友圈能力是为了满足纯内容场景的分享诉求，滥用于营销、诱导等行为将会被打击。**”

不过，不管通过朋友圈能带来多少流量，我觉得，至少分享内容下面的小尾巴显示了小程序名称，就值得我开发这个支持。

大家使用安卓版微信的，可以试试。


#新闻拍一拍# AppGet 作者：WSL 是一个神奇之举

Summary: • 开发者开源了一款工具，可将 Ubuntu 转变为滚动更新版本 • 新 H.266 VCC 编解码器效率比上一代提升 50% • 研究显示许多家用路由器未打补丁容易受漏洞影响

# #新闻拍一拍# AppGet 作者：WSL 是一个神奇之举

<img src="content_image/album_202007_08_143014onswyikbnkn3w8zh.jpg" alt="" title="">

#### AppGet 作者：WSL 是一个神奇之举

Keivan Beigi 认为，WSL 是微软的一个神奇之举。我认为这是微软的一项神奇举措。虽然其最初的发行版本非常糟糕，但是之后的每个发行版本都在变得越来越好。但 WSL 并不会让很多人从 Linux 切换到 Windows，不过它有可能减少从 Windows 迁移到 Mac 或 Linux 的开发人员的数量。

来源：[开源中国](https://www.oschina.net/news/117014/appget-developer-keivan-beigi-interview)

>
> 拍一拍：确实，这一招堪称神来之笔。其带来的影响非常深远。
>
>
>

#### 开发者开源了一款工具，可将 Ubuntu 转变为滚动更新版本

Ubuntu 开发者 Martin Wimpress 开源了一个可以将 Ubuntu 转换为滚动版本的工具 Rolling Rhino，可以通过选择并跟踪一系列更改/程序包，将 Ubuntu 每日构建镜像转换为滚动发行版 devel。

来源：[开源中国](https://www.oschina.net/news/117015/rolling-rhino-rolling-ubuntu)

>
> 拍一拍：就喜欢滚着滚着就挂了的感觉。
>
>
>

#### 新 H.266 VCC 编解码器效率比上一代提升 50%

今天压缩的视频数据占到了全球流量的八成，H.266 VCC 的前两代编解码器分别为 H.264/Advanced Video Coding (AVC) 和 H.265/HEVC。传输 90 分钟的 UHD 视频 H.265/HEVC 编码需要传输 10GB 数据，而 H.266/VVC 编码只需要 5GB。H.264 到 H.266 都需要支付专利使用费的，Google 等公司主导推出了免专利的 AV1 编解码器，但 AV1 目前还缺乏硬件支持。

来源：[solidot](https://www.solidot.org/story?sid=64876)

>
> 拍一拍：技术的进步真快，可惜专利费会阻碍它的普及。
>
>
>

#### 研究显示许多家用路由器未打补丁容易受漏洞影响

许多流行的家用路由器设备受到数百个已知漏洞的影响，超过三分之一的设备在去年没有收到更新。涉及 7 个品牌的 127 个家用路由器，它们来自于华硕、Netgear、D-Link、Linksys、TP-Link 等。报告比较了每个路由器的最新固件版本与已知的安全漏洞，发现没有一个是完美无缺的。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/1000315.htm)

>
> 拍一拍：似乎我家的路由器也好久没更新了？这种不显眼的安全缺陷可能带来的隐私泄露是大多数人所注意不到的。
>
>
>


GIMP 教程：如何在 GIMP 中创建曲线文本

Summary: 在本篇教程中，我将向你展示我最喜欢的创建曲线文本的方法。

在本篇教程中，我将向你展示我最喜欢的创建曲线文本的方法。

# GIMP 教程：如何在 GIMP 中创建曲线文本

当你在 GIMP 中制作一个徽章、海报或其它任何作品时，你需要扭曲或弯曲一些文本。多功能的 [GIMP](https://www.gimp.org/) 工具提供了一些创建弯曲文本的方法。取决于你将如何使用它和你想给予文本的弧度，有一些适合不同情况的方法。

在本篇教程中，我将向你展示我最喜欢的创建曲线文本的方法。

### 如何在 GIMP 中创建曲线文本

请确保你已经在你的系统上安装了 GIMP。

#### 步骤 1: 创建一个你想要的匹配曲线的路径

创建一个新的图像或打开一个现有的图像。选择 “工具 -> 路径”，然后大致考虑曲线文本的位置，通过分别单击路径点的开始点和结束点来创建路径。

\*\*然后给你的路径一个曲率。\*\*首先向上或向下拖动中间的直线，然后通过移动调整点进行微调。这将给予它一个拱形结构。

#### 步骤 2: 创建你想弯曲的文本

当你对自己的曲线路径满意时，你可以移动到接下来的步骤，并 **创建你的文本**。

你可能想更改字体及其大小。我的选择只是为了演示用途。

#### 步骤 3: 创建一个新的图层

我强烈建议分割 GIMP 图像中的每个不同的元素到不同的图层中，以便很容易地控制它们，像移动，打开/关闭一个元素等等。

遵循这一规则，我们要弯曲的文本将被放置到一个新的图层中。建议使用像 “Curved Text” 一样的名字来命名你的新的图层，或者一些类似的东西来很容易地识别它。

#### 步骤 4: 弯曲文本

现在你需要在你的文本图层上单击，接下来在其上右击，并单击“文字对齐路径”来折弯你的文本。弯曲的文本将被放置到新创建的图层。

你把文本弯曲了！让我们使用颜色填充文本来使其更令人满意。

### 步骤 5: 最后的修饰和导出

单击弯曲的文本图层，然后转到路径选项卡来选择文本边界。

最后，选择油漆桶工具，选择一种颜色，并如下应用你的选择区。

随着最后一步的到来，打开不需要的层的可见性，只保留曲线文本。接下来，需要导出你的文件为你喜欢的图像格式。

#### 额外提示：创建阴影效果

我还有一个作为一次挑战的额外的步骤，如果你想更进一步的话。让我们在 [GIMP 中勾勒文本](https://itsfoss.com/gimp-text-outline/)以创建一个弯曲文本的阴影效果。

我将给予你一些提示:

* 重新启用所有图层
* 单击弯曲文本图层，并使用移动工具来到处移动文本
* 创建另一个图层，并使用黑色来重复油漆桶填充程序
* 以一种模拟一种阴影位置的方式覆盖图层（你可能需要更改图层顺序）
* 关闭辅助图层

最终结果：

让我在评论区知道你们对这篇 GIMP 教程的想法，以及有多少人尝试了这一额外的步骤。

---

via: <https://itsfoss.com/curve-text-gimp/>

作者：[Dimitrios Savvopoulos](https://itsfoss.com/author/dimitrios/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[robsean](https://github.com/robsean) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


#新闻拍一拍# 微博将采用外链白名单机制

Summary: • 谷歌开源世界上首个开源的芯片工艺设计套件 PDK • Synergy：全球超大规模数据中心升至 541 个，176 个在建 • SuSE 已就收购 Rancher 事宜正式达成最终协议 • 谷歌成立 Open Usage Commons 帮助开源项目管理商标 • • LibreOffice 社区抗议项目商业化

# #新闻拍一拍# 微博将采用外链白名单机制

<img src="content_image/album_202007_09_145229qighyffysidrfszt.jpg" alt="" title="">

#### 微博将采用外链白名单机制

7月8日，微博官方发布《微博平台实施外链白名单机制的公告》称将目前的短链服务调整为受限制的免费服务，即采用外链白名单机制，仅对白名单网站，如政府、新闻、认证企业网站提供免费服务。对白名单以外的网址均不再支持跳转。认证企业网站需要企业认证账号自行向微博平台申报。微博外链白名单机制将于8月初上线。

来源：[蓝鲸财经](https://www.cnbeta.com/articles/tech/1000675.htm)

>
> 拍一拍：?
>
>
>

#### 谷歌开源世界上首个开源的芯片工艺设计套件 PDK

如果想要制造芯片，在已经拥有 RTL（电阻晶体管逻辑电路）的前提下，还需要克服两大障碍，一是从芯片代工厂获得工艺设计套件（PDK），二是有足够的资金支付制造费用。PDK 是连接 IC 设计公司、代工厂和 EDA 公司的桥梁。PDK 包括设计规则文件、电学规则文件、版图层次定义文件、SPICE 仿真模型、器件版图和期间定制参数。而 PDK 是将 RTL 转化为物理芯片的关键步骤，也是实流程开源的障碍，因此想制造自己的芯片，就要有一套可制造且开源的 PDK。最近，Google 宣布了同 SkyWater 合作的第一个可制造的、开源的 PDK——SkyWater PDK。另外，无需承担昂贵的制造费用，Google 也将提供完全免费的芯片制造流程。

来源：[雷锋网](https://www.cnbeta.com/articles/tech/1000777.htm)

>
> 拍一拍：谷歌做的很多事情都是在推进产业前进。就是不知道受不受美国的出口管制。
>
>
>

#### Synergy：全球超大规模数据中心升至 541 个，176 个在建

EMEA（欧洲、中东和非洲地区）以及亚太地区的增长率仍然最高，不过美国仍然占据了近30%。数据中心覆盖范围最广的公司是领先的云提供商--亚马逊、微软、谷歌和 IBM，每家都拥有 60 个或更多的数据中心节点。

来源：[C114中国通信网](https://www.cnbeta.com/articles/tech/1000659.htm)

>
> 拍一拍：我觉得国内的云服务商出海比较难。
>
>
>

#### SuSE 已就收购 Rancher 事宜正式达成最终协议

全球最大的独立开源公司 SUSE 与业界应用最为广泛的 Kubernetes 管理平台创建者 Rancher Labs（Rancher）共同宣布，双方已就 SUSE 收购 Rancher 事宜正式达成最终协议。据称，此次收购将使 SUSE/Rancher 成为企业级 Linux、容器、Kubernetes、边缘计算领域的首选开源公司。

来源：[开源中国](https://www.oschina.net/news/117025/suse-acquires-rancher)

>
> 拍一拍：这笔收购买卖双方都高兴。
>
>
>

#### 谷歌成立 Open Usage Commons 帮助开源项目管理商标

谷歌宣布成立 Open Usage Commons，旨在帮助开源项目管理其商标。谷歌自己正在将自己的三个开源商标放入这个新的组织中：移动端的 Angular Web 应用框架、Gerrit 代码审查工具和 Istio 服务网格。现有的开源许可比较注重版权和专利，商标往往被很多人忽略掉。即便是 Apache 许可，也基本上会撇开关系。传统上，开源许可证并不涵盖商标，因为生态系统中根本没有多少商标需要担心。这里的一个例外是Linux，这个商标现在由 Linux Mark Institute 代表 Linus Torvalds 管理。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/1000967.htm)

>
> 拍一拍：确实，商标也是一个值得注意的地方，否则被恶意抢注会很难受。
>
>
>

#### LibreOffice 社区抗议项目商业化

近日，LibreOffice 在最新的 7.0 版本中加入的商业化探索引发了社区用户的不满，多名 LibreOffice 社区资深参与者表示这将阻碍该自由与开源软件的推广。用户发现最新安装的 LibreOffice 7.0 RC 版现已被标记为 “个人版”，并且在关于对话框中声明 “该个人版由志愿者支持并仅供个人使用”。文档基金会解释确实在对 LibreOffice 进行商业化的尝试，其目的是使“生态合作伙伴”能够提供带有 “LibreOffice Enterprise” 标签的付费产品。有用户认为，“个人版” 往往会让人联想到一些商业软件推出的功能简化版，即给非企业用户提供功能有限的免费版本。

来源：[开源中国](https://my.oschina.net/editorial-story/blog/4341422)

>
> 拍一拍：产品没做多好，尽想着怎么挣钱，看来文档基金会的日子不太好过啊。
>
>
>


开源代码广阔天地造福人类

# 开源代码广阔天地造福人类

>
> 了解 2020 年开源社区女性奖获得者 Megan Byrd-Sanicki 如何将人们聚集在一起。
>
>
>

“在成长的过程中，我曾经有点像陆军元帅，” 2020 年[开源社区女性奖获得者](https://www.redhat.com/en/about/women-in-open-source) Megan Byrd-Sanicki 笑着说。“我总是那个把同学们拉到一起的人。‘大家来吧，我们告诉你们规则。’我也会注意旁听，尝试找出没有被接纳进来的人，并把他们拉进圈子。”

这种将人们聚集在一起，并为他们建立一个组织，让他们表现出色的动力贯穿了她的大部分职业生涯和社区工作。“我回想起二年级体育课上的我，不得不承认，今天的我依然是这样的人。”

作为第一任 [Drupal 协会](https://www.drupal.org/association)执行主任，Megan 十年来活跃于开源社区，现在是谷歌开源项目办公室的研发和运营主管。“我很幸运能担任这个职位，因为它可以让我看到谷歌 2000 多个不同目标、不同治理结构、不同策略的开源项目。这个也是难得的学习机会。” Megan 最近被推选为 [开源代码促进会](https://opensource.org/)的董事会成员，她努力加强该组织为全球项目和企业提供的开源领导力。

### 从地下室台阶上学到的知识

Megan 原以为她会从商，远离循规的技术。坐在地下室台阶上，耳濡目染父亲的销售电话，到 16 岁时候就知道父亲的所有产品系列，也熟悉了其他知识。

“我从父亲学到了做生意就是解决问题和帮助别人” Megan 说。“在我的职业生涯这个信念我始终放在第一位。在某些角度看选择这条路我并不觉得奇怪；这是我个人选择的自然延伸，但它也把我带到了我从未梦想过的地方。”

开源事业对 Megan 不仅仅是一个职业；她在她的社区活动中也使用同样的理念。“现在，我正在与 [Covid Act Now](https://www.covidactnow.org/) 的一大群优秀的工程师、数据科学家以及流行病科学家合作。团队成员是义务提供他们的专业知识，公开合作，为政府公共人员提供数据建模，以便他们快速的做出有效的决策。”

她也活跃于 [FOSS Responders](https://fossresponders.com/)，这是一个为受 COVID-19 事件影响的开源项目和社区成员点亮温暖的组织。“在疫情期间，项目很难得到他们需要的帮助。我们可以帮忙需要帮忙的组织和个人扩散他们的请求。”这个组织的一个重要的事务是管理 [FOSS Responders 基金](https://fossresponders.com/)，这是一个寻求开源项目基金的融资需求的机制，避免社区衰亡。

### 在这不断变化的世界中一群可爱的人

影响 Megan 参与到社区的两个宗旨分别是对开源的明确承诺和把大家团结在一起的动力。“人们有梦想的时候，他们就积极的去实现它，这就造就了共同的信念和强烈的 ‘为什么’。人们很容易围绕着‘为什么’参与其中。我知道我是这样做的。” Megan 在被问到她这么努力时说到。

“不管是帮助 Drupal 基金会筹集资金的任务还是赋能开源项目可持续发展，都会对人类产生真正的影响。帮助人们达到他们的目标，实现他们的梦想和愿景，而我也实实在在感受到收获这种蝴蝶效应般的热情。”

开源技术在技术领域占的比重越来越大，Megan 对未来抱有很大希望。“令人兴奋的是故事还没有结束。作为一个社区，我们还在摸索，”她说：“关于开源，我们需要学习的东西太多了，我们的外部环境不断发生变化，它可以以多种方式发展，同时我们周围的环境也在变化。我们需要正确的对话，并找出如何共同发展的方法。确保每个人都有一席之地。”

用她的话说，这些都是经常从她的父亲生意电话里听到的感悟，做生意就是解决问题并帮助别人。“帮助更多的人学习如何使用和贡献开源来解决问题，的确是一件有益的事情。不管是推动创新，提升效率，还是实现业务目标，有很多方法可以从开源中获得价值。”

### 属于你的荣耀

当被问到对其他想参与到开源社区的女性有哪些建议时，Megan 兴奋的说：“请记住，在开源社区，所有人都有一席之地。这可能会让人望而生畏，但是从我的经验来看，人们都想帮忙。当你需要帮助的时候，就寻求帮助，但也要清楚你能在哪里做出贡献，如何做出贡献，以及你的需求是什么。”

她也认识到，在开源领域的所有声音中，有时会感觉到缺乏集中的领导力，但她提醒不要把它看成是一种只留给少数人的特权角色。“做你期望的领导者。当社区领导角色空缺时，每个个体可以自己填补空缺。每一个开源的贡献者都是领导者，不管是领导他人，领导社区，甚至领导自己。不要等待被动赋予属于你的权力和精彩。”

对 Megan 来说，开源之旅就如：一个前途不明朗的心路之旅。尽管如此，对风险和未来的不确定性她从不逃避。“我把生命看作一张你正在编织的美丽挂毯，日复一日，你仅仅看到后面的线头。如果你可以看到全貌，你将意识到，你只要每天尽自己最大的努力，就会以无数的方式为这个美好的作品做出贡献。”

---

via: <https://opensource.com/article/20/4/interview-Megan-Byrd-Sanicki>

作者：[Jay Barber](https://opensource.com/users/jaybarber) 选题：[lujun9972](https://github.com/lujun9972) 译者：[guevaraya](https://github.com/guevaraya) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


使用 Delve 代替 Println 来调试 Go 程序

Summary: Delve 是能让调试变成轻而易举的事的万能工具包。

Delve 是能让调试变成轻而易举的事的万能工具包。

# 使用 Delve 代替 Println 来调试 Go 程序

>
> Delve 是能让调试变成轻而易举的事的万能工具包。
>
>
>

<img src="content_image/album_202007_09_234357pavw88sbxab0makj.jpg" alt="" title="">

你上次尝试去学习一种新的编程语言时什么时候？你有没有持之以恒，你是那些在新事物发布的第一时间就勇敢地去尝试的一员吗？不管怎样，学习一种新的语言也许非常有用，也会有很多乐趣。

你尝试着写简单的 “Hello, world!”，然后写一些示例代码并执行，继续做一些小的修改，之后继续前进。我敢保证我们都有过这个经历，不论我们使用哪种技术。假如你尝试用一段时间一种语言，并且你希望能够精通它，那么有一些事物能在你的进取之路上帮助你。

其中之一就是调试器。有些人喜欢在代码中用简单的 “print” 语句进行调试，这种方式很适合代码量少的简单程序；然而，如果你处理的是有多个开发者和几千行代码的大型项目，你应该使用调试器。

最近我开始学习 Go 编程语言了，在本文中，我们将探讨一种名为 Delve 的调试器。Delve 是专门用来调试 Go 程序的工具，我们会借助一些 Go 示例代码来了解下它的一些功能。不要担心这里展示的 Go 示例代码；即使你之前没有写过 Go 代码也能看懂。Go 的目标之一是简单，因此代码是始终如一的，理解和解释起来都很容易。

### Delve 介绍

Delve 是托管在 [GitHub](https://github.com/go-delve/delve) 上的一个开源项目。

它自己的文档中写道：

>
> Delve 是 Go 编程语言的调试器。该项目的目标是为 Go 提供一个简单、全功能的调试工具。Delve 应该是易于调用和易于使用的。当你使用调试器时，事情可能不会按你的思路运行。如果你这样想，那么你不适合用 Delve。
>
>
>

让我们来近距离看一下。

我的测试系统是运行着 Fedora Linux 的笔记本电脑，Go 编译器版本如下：

```
$ cat /etc/fedora-release
Fedora release 30 (Thirty)
$
$ go version
go version go1.12.17 linux/amd64
$

```

### Golang 安装

如果你没有安装 Go，你可以运行下面的命令，很轻松地就可以从配置的仓库中获取。

```
$ dnf install golang.x86_64

```

或者，你可以在[安装页面](https://golang.org/doc/install)找到适合你的操作系统的其他安装版本。

在开始之前，请先确认已经设置好了 Go 工具依赖的下列各个路径。如果这些路径没有设置，有些示例可能不能正常运行。你可以在 SHELL 的 RC 文件中轻松设置这些环境变量，我的机器上是在 `$HOME/bashrc` 文件中设置的。

```
$ go env | grep GOPATH
GOPATH="/home/user/go"
$
$ go env | grep GOBIN
GOBIN="/home/user/go/gobin"
$

```

### Delve 安装

你可以像下面那样，通过运行一个简单的 `go get` 命令来安装 Delve。`go get` 是 Golang 从外部源下载和安装需要的包的方式。如果你安装过程中遇到了问题，可以查看 [Delve 安装教程](https://github.com/go-delve/delve/blob/master/Documentation/installation/linux/install.md)。

```
$ go get -u github.com/go-delve/delve/cmd/dlv
$

```

运行上面的命令，就会把 Delve 下载到你的 `$GOPATH` 的位置，如果你没有把 `$GOPATH` 设置成其他值，那么默认情况下 `$GOPATH` 和 `$HOME/go` 是同一个路径。

你可以进入 `go/` 目录，你可以在 `bin/` 目录下看到 `dlv`。

```
$ ls -l $HOME/go
total 8
drwxrwxr-x. 2 user user 4096 May 25 19:11 bin
drwxrwxr-x. 4 user user 4096 May 25 19:21 src
$
$ ls -l ~/go/bin/
total 19596
-rwxrwxr-x. 1 user user 20062654 May 25 19:17 dlv
$

```

因为你把 Delve 安装到了 `$GOPATH`，所以你可以像运行普通的 shell 命令一样运行它，即每次运行时你不必先进入它所在的目录。你可以通过 `version` 选项来验证 `dlv` 是否正确安装。示例中安装的版本是 1.4.1。

```
$ which dlv
~/go/bin/dlv
$
$ dlv version
Delve Debugger
Version: 1.4.1
Build: $Id: bda606147ff48b58bde39e20b9e11378eaa4db46 $
$

```

现在，我们一起在 Go 程序中使用 Delve 来理解下它的功能以及如何使用它们。我们先来写一个 `hello.go`，简单地打印一条 `Hello, world!` 信息。

记着，我把这些示例程序放到了 `$GOBIN` 目录下。

```
$ pwd
/home/user/go/gobin
$
$ cat hello.go
package main

import "fmt"

func main() {
        fmt.Println("Hello, world!")
}
$

```

运行 `build` 命令来编译一个 Go 程序，它的输入是 `.go` 后缀的文件。如果程序没有语法错误，Go 编译器把它编译成一个二进制可执行文件。这个文件可以被直接运行，运行后我们会在屏幕上看到 `Hello, world!` 信息。

```
$ go build hello.go
$
$ ls -l hello
-rwxrwxr-x. 1 user user 1997284 May 26 12:13 hello
$
$ ./hello
Hello, world!
$

```

### 在 Delve 中加载程序

把一个程序加载进 Delve 调试器有两种方式。

#### 在源码编译成二进制文件之前使用 debug 参数

第一种方式是在需要时对源码使用 `debug` 命令。Delve 会为你编译出一个名为 `__debug_bin` 的二进制文件，并把它加载进调试器。

在这个例子中，你可以进入 `hello.go` 所在的目录，然后运行 `dlv debug` 命令。如果目录中有多个源文件且每个文件都有自己的主函数，Delve 则可能抛出错误，它期望的是单个程序或从单个项目构建成单个二进制文件。如果出现了这种错误，那么你就应该用下面展示的第二种方式。

```
$ ls -l
total 4
-rw-rw-r--. 1 user user 74 Jun  4 11:48 hello.go
$
$ dlv debug
Type 'help' for list of commands.
(dlv)

```

现在打开另一个终端，列出目录下的文件。你可以看到一个多出来的 `__debug_bin` 二进制文件，这个文件是由源码编译生成的，并会加载进调试器。你现在可以回到 `dlv` 提示框继续使用 Delve。

```
$ ls -l
total 2036
-rwxrwxr-x. 1 user user 2077085 Jun  4 11:48 __debug_bin
-rw-rw-r--. 1 user user      74 Jun  4 11:48 hello.go
$

```

#### 使用 exec 参数

如果你已经有提前编译好的 Go 程序或者已经用 `go build` 命令编译完成了，不想再用 Delve 编译出 `__debug_bin` 二进制文件，那么第二种把程序加载进 Delve 的方法在这些情况下会很有用。在上述情况下，你可以使用 `exec` 命令来把整个目录加载进 Delve 调试器。

```
$ ls -l
total 4
-rw-rw-r--. 1 user user 74 Jun  4 11:48 hello.go
$
$ go build hello.go
$
$ ls -l
total 1956
-rwxrwxr-x. 1 user user 1997284 Jun  4 11:54 hello
-rw-rw-r--. 1 user user      74 Jun  4 11:48 hello.go
$
$ dlv exec ./hello
Type 'help' for list of commands.
(dlv)

```

### 查看 delve 帮助信息

在 `dlv` 提示符中，你可以运行 `help` 来查看 Delve 提供的多种帮助选项。命令列表相当长，这里我们只列举一些重要的功能。下面是 Delve 的功能概览。

```
(dlv) help
The following commands are available:

Running the program:

Manipulating breakpoints:

Viewing program variables and memory:

Listing and switching between threads and goroutines:

Viewing the call stack and selecting frames:

Other commands:

Type help followed by a command for full documentation.
(dlv)

```

#### 设置断点

现在我们已经把 hello.go 程序加载进了 Delve 调试器，我们在主函数处设置断点，稍后来确认它。在 Go 中，主程序从 `main.main` 处开始执行，因此你需要给这个名字提供个 `break` 命令。之后，我们可以用 `breakpoints` 命令来检查断点是否正确设置了。

不要忘了你还可以用命令简写，因此你可以用 `b main.main` 来代替 `break main.main`，两者效果相同，`bp` 和 `breakpoints` 同理。你可以通过运行 `help` 命令查看帮助信息来找到你想要的命令简写。

```
(dlv) break main.main
Breakpoint 1 set at 0x4a228f for main.main() ./hello.go:5
(dlv) breakpoints
Breakpoint runtime-fatal-throw at 0x42c410 for runtime.fatalthrow() /usr/lib/golang/src/runtime/panic.go:663 (0)
Breakpoint unrecovered-panic at 0x42c480 for runtime.fatalpanic() /usr/lib/golang/src/runtime/panic.go:690 (0)
        print runtime.curg._panic.arg
Breakpoint 1 at 0x4a228f for main.main() ./hello.go:5 (0)
(dlv)

```

#### 程序继续执行

现在，我们用 `continue` 来继续运行程序。它会运行到断点处中止，在我们的例子中，会运行到主函数的 `main.main` 处中止。从这里开始，我们可以用 `next` 命令来逐行执行程序。请注意，当我们运行到 `fmt.Println("Hello, world!")` 处时，即使我们还在调试器里，我们也能看到打印到屏幕的 `Hello, world!`。

```
(dlv) continue
> main.main() ./hello.go:5 (hits goroutine(1):1 total:1) (PC: 0x4a228f)
     1: package main
     2:
     3: import "fmt"
     4:
=>   5:      func main() {
     6:         fmt.Println("Hello, world!")
     7: }
(dlv) next
> main.main() ./hello.go:6 (PC: 0x4a229d)
     1: package main
     2:
     3: import "fmt"
     4:
     5: func main() {
=>   6:              fmt.Println("Hello, world!")
     7: }
(dlv) next
Hello, world!
> main.main() ./hello.go:7 (PC: 0x4a22ff)
     2:
     3: import "fmt"
     4:
     5: func main() {
     6:         fmt.Println("Hello, world!")
=>   7:      }
(dlv)

```

#### 退出 Delve

你随时可以运行 `quit` 命令来退出调试器，退出之后你会回到 shell 提示符。相当简单，对吗？

```
(dlv) quit
$

```

### Delve 的其他功能

我们用其他的 Go 程序来探索下 Delve 的其他功能。这次，我们从 [golang 教程](https://tour.golang.org/basics/4) 中找了一个程序。如果你要学习 Go 语言，那么 Golang 教程应该是你的第一站。

下面的程序，`functions.go` 中简单展示了 Go 程序中是怎样定义和调用函数的。这里，我们有一个简单的把两数相加并返回和值的 `add()` 函数。你可以像下面那样构建程序并运行它。

```
$ cat functions.go
package main

import "fmt"

func add(x int, y int) int {
        return x + y
}

func main() {
        fmt.Println(add(42, 13))
}
$

```

你可以像下面那样构建和运行程序。

```
$ go build functions.go  && ./functions
55
$

```

#### 进入函数

跟前面展示的一样，我们用前面提到的一个选项来把二进制文件加载进 Delve 调试器，再一次在 `main.main` 处设置断点，继续运行程序直到断点处。然后执行 `next` 直到 `fmt.Println(add(42, 13))` 处；这里我们调用了 `add()` 函数。我们可以像下面展示的那样，用 Delve 的 `step` 命令从 `main` 函数进入 `add()` 函数。

```
$ dlv debug
Type 'help' for list of commands.
(dlv) break main.main
Breakpoint 1 set at 0x4a22b3 for main.main() ./functions.go:9
(dlv) c
> main.main() ./functions.go:9 (hits goroutine(1):1 total:1) (PC: 0x4a22b3)
     4:
     5: func add(x int, y int) int {
     6:         return x + y
     7: }
     8:
=>   9:      func main() {
    10:         fmt.Println(add(42, 13))
    11: }
(dlv) next
> main.main() ./functions.go:10 (PC: 0x4a22c1)
     5: func add(x int, y int) int {
     6:         return x + y
     7: }
     8:
     9: func main() {
=>  10:              fmt.Println(add(42, 13))
    11: }
(dlv) step
> main.add() ./functions.go:5 (PC: 0x4a2280)
     1: package main
     2:
     3: import "fmt"
     4:
=>   5:      func add(x int, y int) int {
     6:         return x + y
     7: }
     8:
     9: func main() {
    10:         fmt.Println(add(42, 13))
(dlv)

```

#### 使用`文件名:行号`来设置断点

上面的例子中，我们经过 `main` 函数进入了 `add()` 函数，但是你也可以在你想加断点的地方直接使用“文件名:行号”的组合。下面是在 `add()` 函数开始处加断点的另一种方式。

```
(dlv) break functions.go:5
Breakpoint 1 set at 0x4a2280 for main.add() ./functions.go:5
(dlv) continue
> main.add() ./functions.go:5 (hits goroutine(1):1 total:1) (PC: 0x4a2280)
     1: package main
     2:
     3: import "fmt"
     4:
=>   5:      func add(x int, y int) int {
     6:         return x + y
     7: }
     8:
     9: func main() {
    10:         fmt.Println(add(42, 13))
(dlv)

```

#### 查看当前的栈信息

现在我们运行到了 `add()` 函数，我们可以在 Delve 中用 `stack` 命令查看当前栈的内容。这里在 `0` 位置展示了栈顶的函数 `add()` ，紧接着在 `1` 位置展示了调用 `add()` 函数的 `main.main`。在 `main.main` 下面的函数属于 Go 运行时，是用来处理加载和执行该程序的。

```
(dlv) stack
0  0x00000000004a2280 in main.add
   at ./functions.go:5
1  0x00000000004a22d7 in main.main
   at ./functions.go:10
2  0x000000000042dd1f in runtime.main
   at /usr/lib/golang/src/runtime/proc.go:200
3  0x0000000000458171 in runtime.goexit
   at /usr/lib/golang/src/runtime/asm_amd64.s:1337
(dlv)

```

#### 在帧之间跳转

在 Delve 中我们可以用 `frame` 命令实现帧之间的跳转。在下面的例子中，我们用 `frame` 实现了从 `add()` 帧跳到 `main.main` 帧，以此类推。

```
(dlv) frame 0
> main.add() ./functions.go:5 (hits goroutine(1):1 total:1) (PC: 0x4a2280)
Frame 0: ./functions.go:5 (PC: 4a2280)
     1: package main
     2:
     3: import "fmt"
     4:
=>   5:      func add(x int, y int) int {
     6:         return x + y
     7: }
     8:
     9: func main() {
    10:         fmt.Println(add(42, 13))
(dlv) frame 1
> main.add() ./functions.go:5 (hits goroutine(1):1 total:1) (PC: 0x4a2280)
Frame 1: ./functions.go:10 (PC: 4a22d7)
     5: func add(x int, y int) int {
     6:         return x + y
     7: }
     8:
     9: func main() {
=>  10:              fmt.Println(add(42, 13))
    11: }
(dlv)

```

#### 打印函数参数

一个函数通常会接收多个参数。在 `add()` 函数中，它的入参是两个整型。Delve 有个便捷的 `args` 命令，它能打印出命令行传给函数的参数。

```
(dlv) args
x = 42
y = 13
~r2 = 824633786832
(dlv)

```

#### 查看反汇编码

由于我们是调试编译出的二进制文件，因此如果我们能查看编译器生成的汇编语言指令将会非常有用。Delve 提供了一个 `disassemble` 命令来查看这些指令。在下面的例子中，我们用它来查看 `add()` 函数的汇编指令。

```
(dlv) step
> main.add() ./functions.go:5 (PC: 0x4a2280)
     1: package main
     2:
     3: import "fmt"
     4:
=>   5:      func add(x int, y int) int {
     6:         return x + y
     7: }
     8:
     9: func main() {
    10:         fmt.Println(add(42, 13))
(dlv) disassemble
TEXT main.add(SB) /home/user/go/gobin/functions.go
=>   functions.go:5  0x4a2280   48c744241800000000   mov qword ptr [rsp+0x18], 0x0
        functions.go:6  0x4a2289   488b442408           mov rax, qword ptr [rsp+0x8]
        functions.go:6  0x4a228e   4803442410           add rax, qword ptr [rsp+0x10]
        functions.go:6  0x4a2293   4889442418           mov qword ptr [rsp+0x18], rax
        functions.go:6  0x4a2298   c3                   ret
(dlv)

```

#### 单步退出函数

另一个功能是 `stepout`，这个功能可以让我们跳回到函数被调用的地方。在我们的例子中，如果我们想回到 `main.main` 函数，我们只需要简单地运行 `stepout` 命令，它就会把我们带回去。在我们调试大型代码库时，这个功能会是一个非常便捷的工具。

```
(dlv) stepout
> main.main() ./functions.go:10 (PC: 0x4a22d7)
Values returned:
        ~r2: 55

     5: func add(x int, y int) int {
     6:         return x + y
     7: }
     8:
     9: func main() {
=>  10:              fmt.Println(add(42, 13))
    11: }
(dlv)

```

#### 打印变量信息

我们一起通过 [Go 教程](https://tour.golang.org/basics/9) 的另一个示例程序来看下 Delve 是怎么处理 Go 中的变量的。下面的示例程序定义和初始化了一些不同类型的变量。你可以构建和运行程序。

```
$ cat variables.go
package main

import "fmt"

var i, j int = 1, 2

func main() {
        var c, python, java = true, false, "no!"
        fmt.Println(i, j, c, python, java)
}
$

$ go build variables.go &&; ./variables
1 2 true false no!
$

```

像前面说过的那样，用 `delve debug` 在调试器中加载程序。你可以在 Delve 中用 `print` 命令通过变量名来展示他们当前的值。

```
(dlv) print c
true
(dlv) print java
"no!"
(dlv)

```

或者，你还可以用 `locals` 命令来打印函数内所有的局部变量。

```
(dlv) locals
python = false
c = true
java = "no!"
(dlv)

```

如果你不知道变量的类型，你可以用 `whatis` 命令来通过变量名来打印它的类型。

```
(dlv) whatis python
bool
(dlv) whatis c
bool
(dlv) whatis java
string
(dlv)

```

### 总结

现在我们只是了解了 Delve 所有功能的皮毛。你可以自己去查看帮助内容，尝试下其它的命令。你还可以把 Delve 绑定到运行中的 Go 程序上（守护进程！），如果你安装了 Go 源码库，你甚至可以用 Delve 导出 Golang 库内部的信息。勇敢去探索吧！

---

via: <https://opensource.com/article/20/6/debug-go-delve>

作者：[Gaurav Kamathe](https://opensource.com/users/gkamathe) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lxbwolf](https://github.com/lxbwolf) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


Summary: Serpent OS 是一个不想被归类为“轻量级、用户友好、注重隐私的 Linux 桌面发行版”。

这个意义何在呢？

不使用所有的GNU？<br />
起的名字叫：Serpent Linux，既然名字中有linux，就表示使用的是linux内核。可linux内核也属于GNU吧，感觉挺矛盾的

linux内核不属于GNU的

来自广东广州的 Microsoft Edge 18.18362|Windows 10 用户

linux内核不属于GNU的

GNU的包袱很重，里面引入一系列依赖，导致你很多时候本来只需要一小丢丢东西，结果扔给你一坨。

还是挺期待的

垃圾項目，去掉GNU有啥意義？

幾年沒上，還是老樣子，把web browser user agent string firefox debian GNU/Linux解讀為firefox GNU/Linux，直接把debian掐掉了

真,没有意义.

# Solus Linux 创始人正在开发一个没有 GNU 的“真正现代”的 Linux 发行版

曾经创建独立 Linux 发行版 Solus 的开发人员 [Ikey Doherty](https://itsfoss.com/ikey-doherty-serpent-interview/) 宣布了他的新项目：Serpent OS。

[Serpent OS](https://www.serpentos.com/) 是一个**不想**被归类为“轻量级、用户友好、注重隐私的 Linux 桌面发行版”。

相反，Serpent OS 具有“与主流产品不同的目标”。具体怎么样？请继续阅读。

### Serpent OS：制作“真正现代”的 Linux 发行版

<img src="content_image/album_202007_10_100350vw0a5pc650c0za6z.jpg" alt="" title="">

Serpent 采用发行版优先，兼容靠后的方法。这使他们可以做出一些非常大胆的决定。

Ikey 表示，这个项目不会对阻碍 Linux 的负面角色容忍。例如，不会容忍 NVIDIA 在其 GPU 上缺乏对 Wayland 加速的支持，并将 NVIDIA 专有驱动加入发行版黑名单。

这是 Serpent Linux 项目的拟议计划（摘自[其网站](https://www.serpentos.com/about/)）：

* 不再分割 usrbin
* 100％ clang 构建（包括内核）
* musl 作为 libc，依靠编译器优化而不是内联 asm
* 使用 libc++ 而不是 libstdc++
* LLVM 的 binutils 变体（lld、as 等）
* 混合源代码/二进制分发
* 从 x86\_64 通用基线转移到更新的 CPU，包括针对 Intel 和 AMD 的优化
* 包管理器中基于功能的订阅（硬件/用户选择等）
* 只支持 UEFI。不支持老式启动方式
* 完全开源，包括引导程序/重建脚本
* 针对高工作负载进行了认真的优化
* 第三方应用仅依赖于容器。没有兼容性修改
* 仅支持 Wayland。将调查通过容器的 X11 兼容性
* 完全无状态的管理工具和上游补丁

Ikey 大胆地宣称 Serpent Linux 不是 Serpent GNU/Linux，因为它不再依赖于 GNU 工具链或运行时。

Serpent OS 项目的开发将于 7 月底开始。没有确定最终稳定版本的时间表。

### 要求过高？但是 Ikey 过去做到了

你可能会怀疑 Serpent OS 是否会出现，是否能够兑现其所作的所有承诺。

但是 Ikey Doherty 过去已经做到了。如果我没记错的话，他首先基于 Debian 创建了 SolusOS。他于 2013 年停止了基于 [Debian 的 SolusOS](https://distrowatch.com/table.php?distribution=solusos) 的开发，甚至它还没有进入 Beta 阶段。

然后，他从头开始创建 [evolve OS](https://itsfoss.com/beta-evolve-os-released/)，而不是使用其他发行版作为基础。由于某些命名版权问题，项目名称已更改为 Solus（是的，相同的旧名称）。[Ikey 在 2018 年退出了 Solus 项目](https://itsfoss.com/ikey-leaves-solus/)，其他开发人员现在负责该项目。

Solus 是一个独立的 Linux 发行版，它为我们提供了漂亮的 Budgie 桌面环境。

Ikey 过去做到了（当然，在其他开发人员的帮助下）。他现在也应该能够做到。

### 看好还是不看好？

你如何看待这个 Serpent Linux？你是否认为是时候让开发人员采取大胆的立场，并着眼于未来开发操作系统，而不是坚持过去？请分享你的观点。

---

via: <https://itsfoss.com/serpent-os-announcement/>

作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


#新闻拍一拍#  英伟达市值超过英特尔

Summary: • Google 和 Canonical 合作将 Flutter Apps 带到 Linux • KeePassXC 2.6.0 释出 • Debian 8 LTS 生命周期已结束 • 立陶宛央行开始预售数字货币 LBCoin • 据称加密货币交易所 Coinbase 计划最早于今年上市

dd

# #新闻拍一拍#  英伟达市值超过英特尔

<img src="content_image/album_202007_10_110509roddhnb2so8difdn.jpg" alt="" title="">

#### 英伟达市值超过英特尔

英伟达超过英特尔成为美国市值最高的芯片公司。市值并不反映公司本身的销售收入，而是反映了投资者对该公司未来的期望。英特尔的股价在 2020 年内下降了 3%，而英伟达同期增长了 68%。但英伟达的收入只占芯片巨人的很小一部分，分析师估计当前财年英伟达的收入能达到 146 亿美元，而英特尔则高达 738 亿美元。

来源：[solidot](https://www.solidot.org/story?sid=64900)

>
> 拍一拍：风起于青萍之末，半导体行业正在向着一个新的方向发展。
>
>
>

#### Google 和 Canonical 合作将 Flutter Apps 带到 Linux

Google 和 Canonical 合作将它的开源 UI 框架 Flutter 带到 Linux 平台，将 Flutter Apps 带到 Canonical 的 Snap 商店。Google 和 Canonical 称，Flutter SDK snap 提供了在 Linux 发行版上开发 Flutter app 所需的所有组件，无需安装大量的依赖。

来源：[solidot](https://www.solidot.org/story?sid=64895)

>
> 拍一拍：从大的方面来看是利好，但是社区对 Snap 有所不喜。
>
>
>

#### KeePassXC 2.6.0 释出

KeePassXC 是另一个开源密码管理器 KeePassX 的分支，起因是 KeePassX 开发停滞；而 KeePassX 则是 KeePass 的净室实现，它的最新版本还是 2016 年发布的。KeePassXC 2.6.0 的主要新特性包括：大幅修改了用户界面，引入了轻色和暗色自定义主题；加入了 Have I Been Pwned 密码检查功能检查密码是否泄露；改进了 YubiKey 和 OnlyKey 密钥整合，支持同时插入 4 个 USB 密钥；等等。

来源：

>
> 拍一拍：密码管理器是安全基石之一。
>
>
>

#### Debian 8 LTS 生命周期已结束

Debian 8 首发于2015年4月26日，在接收来自官方 5 年的技术支持后，已于2020年6月30日到达 EOL 阶段。而 Debian 项目的 LTS 团队将转移至为 Debian 9 “Stretch” 提供技术支持，LTS 团队已于 2020 年 7 月 6 日从安全团队接管了对 Debian 9 的支持，“Stretch” 的最后一个小数点版本更新将于 7 月 18 日发布。

来源：[开源中国](https://www.oschina.net/news/117072/debian-8-eol)

>
> 拍一拍：感觉 Debian 8 还在耳边，这就过了 LTS 了？
>
>
>

#### 立陶宛央行开始预售数字货币 LBCoin

本月 2日，立陶宛中央银行发布消息，将发行数字货币 LBcoin。LBCoin 数字货币基于区块链技术生产，也是立陶宛试点具有国家支持背景的数字货币和区块链技术项目的一部分。7 月 9 日，立陶宛央行发行的数字货币 LBCoin 开始在网站上注册预售，7 月 23 日将正式发售。LBCoin 可以直接与中央银行以及专用区块链网络进行交换。

来源：[央视网](https://www.cnbeta.com/articles/tech/1001357.htm)

>
> 拍一拍：船小好调头啊。
>
>
>

#### 据称加密货币交易所 Coinbase 计划最早于今年上市

消息人士称，Coinbase 可能会在今年晚些时候或明年年初进行上市，并警告说计划仍可能会发生变化。消息人士补充说，该公司尚未向美国证券交易委员会（SEC）登记上市意向，但一直在就聘请投行和律所进行谈判。Coinbase 成立于 2012 年，是全球最知名的加密货币平台之一，拥有超过 3500 万用户。

来源：[新浪美股](https://www.cnbeta.com/articles/tech/1001339.htm)

>
> 拍一拍：如果真能上市，那一定是极大的利好。
>
>
>


entr：文件更改时重新运行构建

Summary: entr 是一个命令行工具，当每次更改一组指定文件中的任何一个时，都能运行一个任意命令。

# entr：文件更改时重新运行构建

<img src="content_image/album_202007_11_094223uct6386d9iwctmbh.jpg" alt="" title="">

这是一篇简短的文章。我是最近才发现 [entr](http://eradman.com/entrproject/) 的，我很惊奇从来没有人告诉过我？！因此，如果你和我一样，那么我告诉你它是什么。

[entr 的网站](http://eradman.com/entrproject/)上对它已经有很好的解释，也有很多示例。

总结在其头部：`entr` 是一个命令行工具，当每次更改一组指定文件中的任何一个时，都能运行一个任意命令。你在标准输入给它传递要监控的文件列表，如下所示：

```
git ls-files | entr bash my-build-script.sh

```

或者

```
find . -name *.rs | entr cargo test

```

或者任何你希望的。

### 快速反馈很棒

就像世界上的每个程序员一样，我发现每次更改代码时都必须手动重新运行构建/测试非常烦人。

许多工具（例如 hugo 和 flask）都有一个内置的系统，可以在更改文件时自动重建，这很棒！

但是通常我会自己编写一些自定义的构建过程（例如 `bash build.sh`），而 `entr` 让我有了一种神奇的构建经验，我只用一行 bash 就能得到即时反馈，知道我的改变是否修复了那个奇怪的 bug。万岁！

### 重启服务器（entr -r）

但是如果你正在运行服务器，并且每次都需要重新启动服务器怎么办？如果你传递 `-r`，那么 `entr` 会帮你的

```
git ls-files | entr -r python my-server.py

```

### 清除屏幕（entr -c）

另一个简洁的标志是 `-c`，它让你可以在重新运行命令之前清除屏幕，以免被前面构建的输出分散注意力。

### 与 git ls-files 一起使用

通常，我要跟踪的文件集和我在 git 中的文件列表大致相同，因此将 `git ls-files` 传递给 `entr` 是很自然的事情。

我现在有一个项目，有时候我刚创建的文件还没有在 git 里。那么如果你想包含未被跟踪的文件怎么办呢？这些 `git` 命令行参数就可以做到（我是从一个读者的邮件中得到的，谢谢你！）：

```
git ls-files -cdmo --exclude-standard  | entr your-build-script

```

有人给我发了邮件，说他们做了一个 `git-entr` 命令，可以执行：

```
git ls-files -cdmo --exclude-standard | entr -d "$@"

```

我觉得这真是一个很棒的主意。

### 每次添加新文件时重启：entr -d

`git ls-files` 的另一个问题是有时候我添加一个新文件，当然它还没有在 git 中。`entr` 为此提供了一个很好的功能。如果你传递 `-d`，那么如果你在 `entr` 跟踪的任何目录中添加新文件，它就会退出。

我将它与一个 `while` 循环配合使用，它将重启 `entr` 来包括新文件，如下所示：

```
while true
do
{ git ls-files; git ls-files . --exclude-standard --others; } | entr -d your-build-scriot
done

```

### entr 在 Linux 上的工作方式：inotify

在 Linux 中，`entr` 使用 `inotify`（用于跟踪文件更改这样的文件系统事件的系统）工作。如果用 `strace` 跟踪它，那么你会看到每个监控文件的 `inotify_add_watch` 系统调用，如下所示：

```
inotify_add_watch(3, "static/stylesheets/screen.css", IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE_SELF|IN_MOVE_SELF) = 1152

```

### 就这样了

我希望这可以帮助一些人了解 `entr`！

---

via: <https://jvns.ca/blog/2020/06/28/entr/>

作者：[Julia Evans](https://jvns.ca/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


安装 Linux Mint 20 后需要做的 13 件事

# 安装 Linux Mint 20 后需要做的 13 件事

Linux Mint 毫无疑问是 [最佳 Linux 发行版](https://itsfoss.com/best-linux-distributions/) 之一，特别是考虑到 [Linux Mint 20](/article-12297-1.html) 的功能，我确信你也会同意这一说法。

假设你错过了我们的新闻报道，[Linux Mint 20 终于可以下载了](/article-12376-1.html)。

当然，如果你使用 Linux Mint 有一段时间了，你可能知道最好做一些什么。但是，对于新用户来说，在安装 Linux Mint 20 后，你需要做一些事，让你的体验更比以往任何时候都好。

### 在安装 Linux Mint 20 后建议做的事

在这篇文章中，我将列出其中一些要做的事来帮助你改善 Linux Mint 20 的用户体验。

#### 1、执行一次系统更新

安装后首先应该马上检查的是 —— 使用更新管理器进行系统更新，如上图所示。

为什么？因为你需要构建可用软件的本地缓存。更新所有软件包的更新也是一个好主意。

如果你喜欢使用终端，只需输入下面的命令来执行系统更新：

```
sudo apt update && sudo apt upgrade -y

```

#### 2、使用 Timeshift 来创建系统快照

如果你想在意外更改或错误更新后快速地恢复系统状态，有一个系统快照总是很有用的。

因此，如果你希望能够随时备份你的系统状态，那么使用 Timeshift 配置和创建系统快照是超级重要的。

如果你还不知道如何使用它的话，你可以遵循我们 [使用 Timeshift](/article-11619-1.html) 的详细指南。

#### 3、安装有用的软件

尽管在 Linux Mint 20 中已经安装有一些有用的预安装应用程序，你可能需要安装一些没有随之一起出炉的必不可少的应用程序。

你可以简单地使用软件包管理器或 synaptic 软件包管理器来查找和安装所需要的软件。

对于初学者来说，如果你想探索各种各样的工具，那么你可以遵循我们的 [必不可少的 Linux 应用程序](/article-10165-1.html) 的列表。

也参见：

* [75 个最常用的 Linux 应用程序（2018 年）](/article-10099-1.html)
* 100 个最佳 Ubuntu 应用（[上](/article-11044-1.html)、[中](/article-11048-1.html)、[下](/article-11057-1.html)）

这里是一个我最喜欢的软件包列表，我希望你也来尝试一下：

* [VLC 多媒体播放器](https://www.videolan.org/vlc/) 用于视频播放
* [FreeFileSync](https://itsfoss.com/freefilesync/) 用来同步文件
* [Flameshot](https://itsfoss.com/flameshot/) 用于截图
* [Stacer](https://itsfoss.com/optimize-ubuntu-stacer/) 用来优化和监控系统
* [ActivityWatch](https://itsfoss.com/activitywatch/) 用来跟踪你的屏幕时间并保持高效唤醒

#### 4、自定义主题和图标

当然，这在技术上不是必不可少的事，除非你想更改 Linux Mint 20 的外观和感觉。

但是，[在 Linux Mint 中更改主题和图标是非常容易的](https://itsfoss.com/install-icon-linux-mint/) ，而不需要安装任何额外的东西。

你会在欢迎屏幕中获得优化外观的选项。或者，你只需要进入 “主题”，并开始自定义主题。

为此，你可以搜索它或在系统设置中如上图所示找到它。

根据你正在使用的桌面环境，你也可以看看可用的 [最佳图标主题](https://itsfoss.com/best-icon-themes-ubuntu-16-04/)。

#### 5、启用 Redshift 来保护你的眼睛

你可以在 Linux Mint 上搜索 “[Redshift](https://itsfoss.com/install-redshift-linux-mint/)”，并启用它以在晚上保护你的眼睛。如你在上面的截图所见，它将根据时间自动地调整屏幕的色温。

你可能想启用自动启动选项，以便它在你重新启动计算机时自动启动。它可能与 [Ubuntu 20.04 LTS](https://itsfoss.com/ubuntu-20-04-release-features/) 的夜光功能不太一样，但是如果你不需要自定义时间表或微调色温的能力，那么它就足够好了。

#### 6、启用 snap（如果需要的话）

尽管 Ubuntu 比前所未有的更倾向于推崇使用 Snap，但是 Linux Mint 团队却反对使用它。因此，它禁止 APT 使用 snapd。

因此，你将无法获得 snap 开箱即用的支持。然而，你迟早会意识到一些软件包只以 Snap 的格式打包。在这种情况下，你将不得不在 Mint 上启用对 snap 的支持。

```
sudo apt install snapd

```

在你完成后，你可以遵循我们的指南来了解更多关于 [在 Linux 上安装和使用 snap](https://itsfoss.com/install-snap-linux/) 的信息。

#### 7、学习使用 Flatpak

默认情况下，Linux Mint 带有对 Flatpak 的支持。所以，不管你是讨厌使用 snap 或只是更喜欢使用 Flatpak，在系统中保留它是个好主意。

现在，你只需要遵循我们关于 [在 Linux 上使用 Flatpak](https://itsfoss.com/flatpak-guide/) 的指南来开始吧！

#### 8、清理或优化你的系统

优化或清理系统总是好的，以避免不必要的垃圾文件占用存储空间。

你可以通过在终端机上输入以下内容，快速删除系统中不需要的软件包：

```
sudo apt autoremove

```

除此之外，你也可以遵循我们 [在 Linux Mint 上释放空间的一些建议](https://itsfoss.com/free-up-space-ubuntu-linux/) 。

#### 9、使用 Warpinator 通过网络发送/接收文件

Warpinator 是 Linux Mint 20 的一个新功能，可以让你在连接到网络的多台电脑上共享文件。这里是它看起来的样子：

你只需要在菜单中搜索它就可以开始了！

#### 10、使用驱动程序管理器

如果你正在使用需要驱动程序的 Wi-Fi 设备、NVIDIA 显卡或 AMD 显卡，以及其它设备（如果适用的话）时，驱动程序管理器是一个重要的部分。

你只需要找到驱动程序管理器并启用它。它应该可以检测到正在使用的任何专有驱动程序，或者你也可以使用驱动程序管理器来利用 DVD 来安装驱动程序。

#### 11、设置防火墙

在大多数情况下，你可能已经保护了你的家庭网络。但是，如果你想在 Linux Mint 上有一些特殊的防火墙设置，你可以通过在菜单中搜索 “Firewall” 来实现。

正如你在上述截图中所看到的，你可以为家庭、企业和公共设置不同的配置文件。你只需要添加规则，并定义什么是允许访问互联网的，什么是不允许的。

你可以阅读我们关于 [使用 UFW 配置防火墙](https://itsfoss.com/set-up-firewall-gufw/) 的详细指南。

#### 12、学习管理启动应用程序

如果你是一个有经验的用户，你可能已经知道这一点了。但是，新用户经常忘记管理他们的启动应用程序，最终影响了系统启动时间。

你只需要从菜单中搜索 “Startup Applications” ，你可以启动它来查找像这样的东西：

你可以简单地切换你想要禁用的那些启动应用程序，添加一个延迟计时器，或从启动应用程序的列表中完全地移除它。

#### 13、安装必不可少的游戏应用程序

当然，如果你对游戏感兴趣，你可能想去阅读我们关于 [在 Linux 上的游戏](https://itsfoss.com/linux-gaming-guide/) 的文章来探索所有的选择。

但是，对于初学者来说，你可以尝试安装 [GameHub](https://itsfoss.com/gamehub/)、[Steam](https://store.steampowered.com) 和 [Lutris](https://lutris.net) 来玩一些游戏。

### 总结

就是这样，各位！在大多数情况下，如果你在安装 Linux Mint 20 后按照上面的要点进行操作，使其发挥出最好的效果，应该就可以了。

我确信你还能够做更多的事。我想知道你喜欢在安装 Linux Mint 20 后马上做了什么。在下面的评论中告诉我你的想法吧！

---

via: <https://itsfoss.com/things-to-do-after-installing-linux-mint-20/>

作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[robsean](https://github.com/robsean) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


#新闻拍一拍# 阿里将打造自主可控、安全可靠的国产操作系统

Summary: • Chrome 和 Firefox 浏览器将很快支持全新的 AVIF 图像格式 • 利用区块链“智能合约”，3 名 95 后诈骗 1300 余人上亿元 • 有史最贵游戏诞生：1985 年的《超级马里奥》以 11.4 万美元拍出

QQ都还不能识别WebP图片呢

看到国产操作系统就想笑，不过只要别骗经费，随便你们玩

# #新闻拍一拍# 阿里将打造自主可控、安全可靠的国产操作系统

<img src="content_image/album_202007_11_135714tobdvd59od9ddolv.jpg" alt="" title="">

#### 阿里将打造自主可控、安全可靠的国产操作系统

阿里副总裁今天表示，打造国产自主可控、安全可靠的操作系统是阿里重要的战略布局。在阿里，操作系统项目已经有多个，其中 AliOS 一度成为手机厂商替代安卓的选择，不过这几年 AliOS 已经转向物联网、车联网等领域，AliOS 官网上也很久没有更新了。

来源：[快科技](https://www.cnbeta.com/articles/tech/1001759.htm)

>
> 拍一拍：希望不是下一个 Linux 发行版。
>
>
>

#### Chrome 和 Firefox 浏览器将很快支持全新的 AVIF 图像格式

继流媒体视频网站 Netflix、Windows 10 操作系统、VLC 视频播放器、以及某些图像编辑器之后，Google Chrome 和 Mozilla Firefox 浏览器也终于添加了对全新的 AVIF 图像格式的支持。作为一种新面世的图像格式，AVIF 最大的特点就是轻量和免授权。与现有的 JPEG、PNG、甚至 WebP 等图像格式相比，AVIF 的压缩效率可以做到更高，Netflix 等企业更是对其赞赏有加。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/1001671.htm)

>
> 拍一拍：这真是一个好消息，相比 H.264 等专有格式，这种免授权的格式才会得到更多的支持。
>
>
>

#### 利用区块链“智能合约”，3 名 95 后诈骗 1300 余人上亿元

3 名大学刚毕业就“创业”的 95 后，不到一年获利亿元，开上了价值 400 万的迈凯伦-650S、300 万的法拉利-California T，买了价值 800 万的豪华奢景别墅。此类新型犯罪，传统的侦查手段难以奏效。警方发现受害人加入的群管理人员一直在利用其自身发布的 HT “智能合约”非法获取受害人的 ETH，将 ETH 转到“群主”提供的账户内，返还没有任何价值的虚假 HT，从而非法获利。

来源：[澎湃新闻](https://www.cnbeta.com/articles/tech/1001691.htm)

>
> 拍一拍：不能据此就对“智能合约”污名化，这个事情和智能合约无关，这是嫌犯和贪婪者的问题。
>
>
>

#### 有史最贵游戏诞生：1985 年的《超级马里奥》以 11.4 万美元拍出

日前，一个未拆封的 1985 年美国版《超级马里奥》在美国遗产拍卖公司以 11.4 万美元的价格拍出，这打破了该游戏在此前创下的纪录。

来源：[cnBeta.COM](https://hot.cnbeta.com/articles/game/1001901.htm)

>
> 拍一拍：这是当文物收藏了啊！
>
>
>


使用 Cloud-init 将节点添加到你的私有云中

Summary: 像主流云提供商的处理方式一样，在家中添加机器到你的私有云。

像主流云提供商的处理方式一样，在家中添加机器到你的私有云。

# 使用 Cloud-init 将节点添加到你的私有云中

>
> 像主流云提供商的处理方式一样，在家中添加机器到你的私有云。
>
>
>

[Cloud-init](https://cloudinit.readthedocs.io/) 是一种广泛使用的行业标准方法，用于初始化云实例。云提供商使用 Cloud-init 来定制实例的网络配置、实例信息，甚至用户提供的配置指令。它也是一个可以在你的“家庭私有云”中使用的很好的工具，可以为你的家庭实验室的虚拟机和物理机的初始设置和配置添加一点自动化 —— 并了解更多关于大型云提供商是如何工作的信息。关于更多的细节和背景，请看我之前的文章《[在你的树莓派家庭实验室中使用 Cloud-init](/article-12371-1.html)》。

*运行 Cloud-init 的 Linux 服务器的启动过程（Chris Collins，[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）*

诚然，Cloud-init 对于为许多不同客户配置机器的云提供商来说，比对于由单个系统管理员运行的家庭实验室更有用，而且 Cloud-init 解决的许多问题对于家庭实验室来说可能有点多余。然而，设置它并了解它的工作原理是了解更多关于这种云技术的好方法，更不用说它是首次启动时配置设备的好方法。

本教程使用 Cloud-init 的 NoCloud 数据源，它允许 Cloud-init 在传统的云提供商环境之外使用。本文将向你展示如何在客户端设备上安装 Cloud-init，并设置一个运行 Web 服务的容器来响应客户端的请求。你还将学习如何审查客户端从 Web 服务中请求的内容，并修改 Web 服务的容器，以提供基本的、静态的 Cloud-init 服务。

### 在现有系统上设置 Cloud-init

Cloud-init 可能在新系统首次启动时最有用，它可以查询配置数据，并根据指令对系统进行定制。它可以[包含在树莓派和单板计算机的磁盘镜像中](/article-12277-1.html)，也可以添加到用于<ruby> 配给 <rt>  provision </rt></ruby>虚拟机的镜像中。对于测试用途来说，无论是在现有系统上安装并运行 Cloud-init，还是安装一个新系统，然后设置 Cloud-init，都是很容易的。

作为大多数云提供商使用的主要服务，大多数 Linux 发行版都支持 Cloud-init。在这个例子中，我将使用 Fedora 31 Server 来安装树莓派，但在 Raspbian、Ubuntu、CentOS 和大多数其他发行版上也可以用同样的方式来完成。

#### 安装并启用云计算初始服务

在你想作为 Cloud-init 客户端的系统上，安装 Cloud-init 包。如果你使用的是 Fedora：

```
# Install the cloud-init package
dnf install -y cloud-init

```

Cloud-init 实际上是四个不同的服务（至少在 systemd 下是这样），这些服务负责检索配置数据，并在启动过程的不同阶段进行配置更改，这使得可以做的事情更加灵活。虽然你不太可能直接与这些服务进行太多交互，但在你需要排除一些故障时，知道它们是什么还是很有用的。它们是：

* cloud-init-local.service
* cloud-init.service
* cloud-config.service
* cloud-final.service

启用所有四个服务：

```
# Enable the four cloud-init services
systemctl enable cloud-init-local.service
systemctl enable cloud-init.service
systemctl enable cloud-config.service
systemctl enable cloud-final.service

```

#### 配置数据源以查询

启用服务后，请配置数据源，客户端将从该数据源查询配置数据。有[许多数据源类型](https://cloudinit.readthedocs.io/en/latest/topics/datasources.html)，而且大多数都是为特定的云提供商配置的。对于你的家庭实验室，请使用 NoCloud 数据源，（如上所述）它是为在没有云提供商的情况下使用 Cloud-init 而设计的。

NoCloud 允许以多种方式包含配置信息：以内核参数中的键/值对，用于在启动时挂载的 CD（或虚拟机中的虚拟 CD）；包含在文件系统中的文件中；或者像本例中一样，通过 HTTP 从指定的 URL（“NoCloud Net” 选项）获取配置信息。

数据源配置可以通过内核参数提供，也可以在 Cloud-init 配置文件 `/etc/cloud/cloud.cfg` 中进行设置。该配置文件对于使用自定义磁盘镜像设置 Cloud-init 或在现有主机上进行测试非常方便。

Cloud-init 还会合并在 `/etc/cloud/cloud.cfg.d/` 中找到的任何 `*.cfg` 文件中的配置数据，因此为了保持整洁，请在 `/etc/cloud/cloud.cfg.d/10_datasource.cfg` 中配置数据源。Cloud-init 可以通过使用以下语法从 `seedfrom` 键指向的 HTTP 数据源中读取数据。

```
seedfrom: http://ip_address:port/

```

IP 地址和端口是你将在本文后面创建的 Web 服务。我使用了我的笔记本电脑的 IP 和 8080 端口。这也可以是 DNS 名称。

创建 `/etc/cloud/cloud.cfg.d/10_datasource.cfg` 文件：

```
# Add the datasource:
# /etc/cloud/cloud.cfg.d/10_datasource.cfg

# NOTE THE TRAILING SLASH HERE!
datasource:
  NoCloud:
    seedfrom: http://ip_address:port/

```

客户端设置就是这样。现在，重新启动客户端后，它将尝试从你在 `seedfrom` 键中输入的 URL 检索配置数据，并进行必要的任何配置更改。

下一步是设置一个 Web 服务器来侦听客户端请求，以便你确定需要提供的服务。

### 设置网络服务器以审查客户请求

你可以使用 [Podman](https://podman.io/) 或其他容器编排工具（如 Docker 或 Kubernetes）快速创建和运行 Web 服务器。这个例子使用的是 Podman，但同样的命令也适用于 Docker。

要开始，请使用 `fedora:31` 容器镜像并创建一个容器文件（对于 Docker 来说，这会是一个 Dockerfile）来安装和配置 Nginx。从该容器文件中，你可以构建一个自定义镜像，并在你希望提供 Cloud-init 服务的主机上运行它。

创建一个包含以下内容的容器文件：

```
FROM fedora:31

ENV NGINX_CONF_DIR "/etc/nginx/default.d"
ENV NGINX_LOG_DIR "/var/log/nginx"
ENV NGINX_CONF "/etc/nginx/nginx.conf"
ENV WWW_DIR "/usr/share/nginx/html"

# Install Nginx and clear the yum cache
RUN dnf install -y nginx \
      && dnf clean all \
      && rm -rf /var/cache/yum

# forward request and error logs to docker log collector
RUN ln -sf /dev/stdout ${NGINX_LOG_DIR}/access.log \
    && ln -sf /dev/stderr ${NGINX_LOG_DIR}/error.log

# Listen on port 8080, so root privileges are not required for podman
RUN sed -i -E 's/(listen)([[:space:]]*)(\[\:\:\]\:)?80;$/\1\2\38080 default_server;/' $NGINX_CONF
EXPOSE 8080

# Allow Nginx PID to be managed by non-root user
RUN sed -i '/user nginx;/d' $NGINX_CONF
RUN sed -i 's/pid \/run\/nginx.pid;/pid \/tmp\/nginx.pid;/' $NGINX_CONF

# Run as an unprivileged user
USER 1001

CMD ["nginx", "-g", "daemon off;"]

```

注：本例中使用的容器文件和其他文件可以在本项目的 [GitHub 仓库](https://github.com/clcollins/homelabCloudInit/tree/master/simpleCloudInitService/data)中找到。

上面容器文件中最重要的部分是改变日志存储方式的部分（写到 STDOUT 而不是文件），这样你就可以在容器日志中看到进入该服务器的请求。其他的一些改变使你可以在没有 root 权限的情况下使用 Podman 运行容器，也可以在没有 root 权限的情况下运行容器中的进程。

在 Web 服务器上的第一个测试并不提供任何 Cloud-init 数据；只是用它来查看 Cloud-init 客户端的请求。

创建容器文件后，使用 Podman 构建并运行 Web 服务器镜像：

```
# Build the container image
$ podman build -f Containerfile -t cloud-init:01 .

# Create a container from the new image, and run it
# It will listen on port 8080
$ podman run --rm -p 8080:8080 -it cloud-init:01

```

这会运行一个容器，让你的终端连接到一个伪 TTY。一开始看起来什么都没有发生，但是对主机 8080 端口的请求会被路由到容器内的 Nginx 服务器，并且在终端窗口中会出现一条日志信息。这一点可以用主机上的 `curl` 命令进行测试。

```
# Use curl to send an HTTP request to the Nginx container
$ curl http://localhost:8080

```

运行该 `curl` 命令后，你应该会在终端窗口中看到类似这样的日志信息：

```
127.0.0.1 - - [09/May/2020:19:25:10 +0000] "GET / HTTP/1.1" 200 5564 "-" "curl/7.66.0" "-"

```

现在，有趣的部分来了：重启 Cloud-init 客户端，并观察 Nginx 日志，看看当客户端启动时， Cloud-init 向 Web 服务器发出了什么请求。

当客户端完成其启动过程时，你应该会看到类似的日志消息。

```
2020/05/09 22:44:28 [error] 2#0: *4 open() "/usr/share/nginx/html/meta-data" failed (2: No such file or directory), client: 127.0.0.1, server: _, request: "GET /meta-data HTTP/1.1", host: "instance-data:8080"
127.0.0.1 - - [09/May/2020:22:44:28 +0000] "GET /meta-data HTTP/1.1" 404 3650 "-" "Cloud-Init/17.1" "-"

```

注：使用 `Ctrl+C` 停止正在运行的容器。

你可以看到请求是针对 `/meta-data` 路径的，即 `http://ip_address_of_the_webserver:8080/meta-data`。这只是一个 GET 请求 —— Cloud-init 并没有向 Web 服务器发送任何数据。它只是盲目地从数据源 URL 中请求文件，所以要由数据源来识别主机的要求。这个简单的例子只是向任何客户端发送通用数据，但一个更大的家庭实验室应该需要更复杂的服务。

在这里，Cloud-init 请求的是[实例元数据](https://cloudinit.readthedocs.io/en/latest/topics/instancedata.html#what-is-instance-data)信息。这个文件可以包含很多关于实例本身的信息，例如实例 ID、分配实例的主机名、云 ID，甚至网络信息。

创建一个包含实例 ID 和主机名的基本元数据文件，并尝试将其提供给 Cloud-init 客户端。

首先，创建一个可复制到容器镜像中的 `meta-data` 文件。

```
instance-id: iid-local01
local-hostname: raspberry
hostname: raspberry

```

实例 ID（`instance-id`）可以是任何东西。但是，如果你在 Cloud-init 运行后更改实例 ID，并且文件被送达客户端，就会触发 Cloud-init 再次运行。你可以使用这种机制来更新实例配置，但你应该意识到它是这种工作方式。

`local-hostname` 和 `hostname` 键正如其名，它们会在 Cloud-init 运行时为客户端设置主机名信息。

在容器文件中添加以下行以将 `meta-data` 文件复制到新镜像中。

```
# Copy the meta-data file into the image for Nginx to serve it
COPY meta-data ${WWW_DIR}/meta-data

```

现在，用元数据文件重建镜像（使用一个新的标签以方便故障排除），并用 Podman 创建并运行一个新的容器。

```
# Build a new image named cloud-init:02
podman build -f Containerfile -t cloud-init:02 .

# Run a new container with this new meta-data file
podman run --rm -p 8080:8080 -it cloud-init:02

```

新容器运行后，重启 Cloud-init 客户端，再次观察 Nginx 日志。

```
127.0.0.1 - - [09/May/2020:22:54:32 +0000] "GET /meta-data HTTP/1.1" 200 63 "-" "Cloud-Init/17.1" "-"
2020/05/09 22:54:32 [error] 2#0: *2 open() "/usr/share/nginx/html/user-data" failed (2: No such file or directory), client: 127.0.0.1, server: _, request: "GET /user-data HTTP/1.1", host: "instance-data:8080"
127.0.0.1 - - [09/May/2020:22:54:32 +0000] "GET /user-data HTTP/1.1" 404 3650 "-" "Cloud-Init/17.1" "-"

```

你看，这次 `/meta-data` 路径被提供给了客户端。成功了！

然而，客户端接着在 `/user-data` 路径上寻找第二个文件。该文件包含实例所有者提供的配置数据，而不是来自云提供商的数据。对于一个家庭实验室来说，这两个都是你自己提供的。

你可以使用[许多 user-data 模块](https://cloudinit.readthedocs.io/en/latest/topics/modules.html)来配置你的实例。对于这个例子，只需使用 `write_files` 模块在客户端创建一些测试文件，并验证 Cloud-init 是否工作。

创建一个包含以下内容的用户数据文件：

```
#cloud-config

# Create two files with example content using the write_files module
write_files:
 - content: |
    "Does cloud-init work?"
   owner: root:root
   permissions: '0644'
   path: /srv/foo
 - content: |
   "IT SURE DOES!"
   owner: root:root
   permissions: '0644'
   path: /srv/bar

```

除了使用 Cloud-init 提供的 `user-data` 模块制作 YAML 文件外，你还可以将其制作成一个可执行脚本供 Cloud-init 运行。

创建 `user-data` 文件后，在容器文件中添加以下行，以便在重建映像时将其复制到镜像中：

```
# Copy the user-data file into the container image
COPY user-data ${WWW_DIR}/user-data

```

重建镜像，并创建和运行一个新的容器，这次使用用户数据信息：

```
# Build a new image named cloud-init:03
podman build -f Containerfile -t cloud-init:03 .

# Run a new container with this new user-data file
podman run --rm -p 8080:8080 -it cloud-init:03

```

现在，重启 Cloud-init 客户端，观察 Web 服务器上的 Nginx 日志：

```
127.0.0.1 - - [09/May/2020:23:01:51 +0000] "GET /meta-data HTTP/1.1" 200 63 "-" "Cloud-Init/17.1" "-"
127.0.0.1 - - [09/May/2020:23:01:51 +0000] "GET /user-data HTTP/1.1" 200 298 "-" "Cloud-Init/17.1" "-

```

成功了！这一次，元数据和用户数据文件都被送到了 Cloud-init 客户端。

### 验证 Cloud-init 已运行

从上面的日志中，你知道 Cloud-init 在客户端主机上运行并请求元数据和用户数据文件，但它用它们做了什么？你可以在 `write_files` 部分验证 Cloud-init 是否写入了你在用户数据文件中添加的文件。

在 Cloud-init 客户端上，检查 `/srv/foo` 和 `/srv/bar` 文件的内容：

```
# cd /srv/ && ls
bar foo
# cat foo
"Does cloud-init work?"
# cat bar
"IT SURE DOES!"

```

成功了！文件已经写好了，并且有你期望的内容。

如上所述，还有很多其他模块可以用来配置主机。例如，用户数据文件可以配置成用 `apt` 添加包、复制 SSH 的 `authorized_keys`、创建用户和组、配置和运行配置管理工具等等。我在家里的私有云中使用它来复制我的 `authorized_keys`、创建一个本地用户和组，并设置 sudo 权限。

### 你接下来可以做什么

Cloud-init 在家庭实验室中很有用，尤其是专注于云技术的实验室。本文所演示的简单服务对于家庭实验室来说可能并不是超级有用，但现在你已经知道 Cloud-init 是如何工作的了，你可以继续创建一个动态服务，可以用自定义数据配置每台主机，让家里的私有云更类似于主流云提供商提供的服务。

在数据源稍显复杂的情况下，将新的物理（或虚拟）机器添加到家中的私有云中，可以像插入它们并打开它们一样简单。

---

via: <https://opensource.com/article/20/5/create-simple-cloud-init-service-your-homelab>

作者：[Chris Collins](https://opensource.com/users/clcollins) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


关于哈希（散列）函数你应该知道的东西

Summary: 从输出的哈希值反推回输入，这从计算的角度是不可行的。

从输出的哈希值反推回输入，这从计算的角度是不可行的。

# 关于哈希（散列）函数你应该知道的东西

>
> 从输出的哈希值反推回输入，这从计算的角度是不可行的。
>
>
>

<img src="content_image/album_202007_12_145709d3ne3vee330oh3lv.jpg" alt="" title="">

无论安全从业人员用计算机做什么，有一种工具对他们每个人都很有用：加密<ruby> 哈希（散列） <rt>  hash </rt></ruby>函数。这听起来很神秘、很专业，甚至可能有点乏味，但是， 在这里，关于什么是哈希函数以及它们为什么对你很重要，我会作出一个简洁的解释。

加密哈希函数，比如 SHA-256 或者 MD5，接受一组二进制数据（通常是字节）作为输入，并且对每个可能的输入集给出一个<ruby> 希望唯一 <rt>  hopefully unique </rt></ruby>的输出。对于任意模式的输入，给定的哈希函数的输出（“哈希值”）的长度都是一样的（对于 SHA-256，是 32 字节或者 256 比特，这从名字中就能看出来）。最重要的是：从输出的哈希值反推回输入，这从计算的角度是<ruby> 不可行的 <rt>  implausible </rt></ruby>（密码学家讨厌 “<ruby> 不可能 <rt>  impossible </rt></ruby>” 这个词）。这就是为什么它们有时候被称作<ruby> 单向哈希函数 <rt>  one-way hash function </rt></ruby>。

但是哈希函数是用来做什么的呢？为什么“唯一”的属性如此重要？

### 唯一的输出

在描述哈希函数的输出时，“<ruby> 希望唯一 <rt>  hopefully unique </rt></ruby>”这个短语是至关重要的，因为哈希函数就是用来呈现完全唯一的输出。比如，哈希函数可以用于验证 *你* 下载的文件副本的每一个字节是否和 *我* 下载的文件一样。你下载一个 Linux 的 ISO 文件或者从 Linux 的仓库中下载软件时，你会看到使用这个验证过程。没有了唯一性，这个技术就没用了，至少就通常的目的而言是这样的。

如果两个不同的输入产生了相同的输出，那么这样的哈希过程就称作“<ruby> 碰撞 <rt>  collision </rt></ruby>”。事实上，MD5 算法已经被弃用，因为虽然可能性微乎其微，但它现在可以用市面上的硬件和软件系统找到碰撞。

另外一个重要的特性是，消息中的一个微小变化，甚至只是改变一个比特位，都可能会在输出中产生一个明显的变化（这就是“<ruby> 雪崩效应 <rt>  avalanche effect </rt></ruby>”）。

### 验证二进制数据

哈希函数的典型用途是当有人给你一段二进制数据，确保这些数据是你所期望的。无论是文本、可执行文件、视频、图像或者一个完整的数据库数据，在计算世界中，所有的数据都可以用二进制的形式进行描述，所以至少可以这么说，哈希是广泛适用的。直接比较二进制数据是非常缓慢的且计算量巨大，但是哈希函数在设计上非常快。给定两个大小为几 M 或者几 G 的文件，你可以事先生成它们的哈希值，然后在需要的时候再进行比较。

通常，对哈希值进行签名比对大型数据集本身进行签名更容易。这个特性太重要了，以至于密码学中对哈希值最常见的应用就是生成“数字”签名。

由于生成数据的哈希值很容易，所以通常不需要有两套数据。假设你想在你的电脑上运行一个可执行文件。但是在你运行之前，你需要检查这个文件就是你要的文件，没有被黑客篡改。你可以方便快捷的对文件生成哈希值，只要你有一个这个哈希值的副本，你就可以相当肯定这就是你想要的文件。

下面是一个简单的例子：

```
$ shasum -a256 ~/bin/fop
87227baf4e1e78f6499e4905e8640c1f36720ae5f2bd167de325fd0d4ebc791c  /home/bob/bin/fop

```

如果我知道 `fop` 这个可执行文件的 SHA-256 校验和，这是由供应商（这个例子中是 Apache 基金会）提供的：

```
87227baf4e1e78f6499e4905e8640c1f36720ae5f2bd167de325fd0d4ebc791c

```

然后我就可以确信，我驱动器上的这个可执行文件和 Apache 基金会网站上发布的文件是一模一样的。这就是哈希函数难以发生碰撞（或者至少是 *很难通过计算得到碰撞*）这个性质的重要之处。如果黑客能将真实文件用哈希值相同的文件轻易的进行替换，那么这个验证过程就毫无用处。

事实上，这些性质还有更技术性的名称，我上面所描述的将三个重要的属性混在了一起。更准确地说，这些技术名称是：

1. <ruby> 抗原像性 <rt>  pre-image resistance </rt></ruby>：给定一个哈希值，即使知道用了什么哈希函数，也很难得到用于创建它的消息。
2. <ruby> 抗次原像性 <rt>  second pre-image resistance </rt> <ruby>  ：给定一个消息，很难找到另一个消息，使得这个消息可以产生相同的哈希值。 </ruby></ruby>
3. <ruby> 抗碰撞性 <rt>  collision resistance </rt></ruby>：很难得到任意两个可以产生相同哈希值的消息。

*抗碰撞性* 和 *抗次原像性* 也许听上去是同样的性质，但它们具有细微而显著的不同。*抗次原像性* 说的是如果 *已经* 有了一个消息，你也很难得到另一个与之哈希值相匹配的消息。*抗碰撞性* 使你很难找到两个可以生成相同哈希值的消息，并且要在哈希函数中实现这一性质则更加困难。

让我回到黑客试图替换文件（可以通过哈希值进行校验）的场景。现在，要在“外面”使用加密哈希算法（除了使用那些在现实世界中由独角兽公司开发的完全无 Bug 且安全的实现之外），还有一些重要且困难的附加条件需要满足。认真的读者可能已经想到了其中一些，特别需要指出的是：

1. 你必须确保自己所拥有的哈希值副本也没有被篡改。
2. 你必须确保执行哈希算法的实体能够正确执行并报告了结果。
3. 你必须确保对比两个哈希值的实体确实报告了这个对比的正确结果。

确保你能满足这些条件绝对不是一件容易的事。这就是<ruby> 可信平台模块 <rt>  Trusted Platform Modules </rt></ruby>（TPM）成为许多计算系统一部分的原因之一。它们扮演着信任的硬件基础，可以为验证重要二进制数据真实性的加密工具提供保证。TPM 对于现实中的系统来说是有用且重要的工具，我也打算将来写一篇关于 TPM 的文章。

---

via: <https://opensource.com/article/20/7/hash-functions>

作者：[Mike Bursell](https://opensource.com/users/mikecamel) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Yufei-Yan](https://github.com/Yufei-Yan) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


#新闻拍一拍#  微软将在 Windows 中放弃对 PHP 的支持

Summary: • 想替代 C 的 Zig 语言成立了基金会 • 因被黑客滥用 Mozilla 宣布暂停 Firefox Send 文件共享服务

# #新闻拍一拍#  微软将在 Windows 中放弃对 PHP 的支持

<img src="content_image/album_202007_12_154201rww764wj5t3722l7.jpg" alt="" title="">

#### 微软将在 Windows 中放弃对 PHP 的支持

PHP 8.0 将于 11 月发布，但当这个重要的新版本出现时，Windows 将不支持它，原因未知。该公司表示，在 PHP 7.2、7.3 和 7.4 版本的生命周期内，Windows 将继续为其准备错误修复和安全补丁。但当今年晚些时候发布最新版本时，微软将“不为 8.0 及以后的版本以及以任何方式支持 PHP for Windows”。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/1002019.htm)

>
> 拍一拍：希望这个决定只是基于用户数量缺乏的考虑。
>
>
>

#### 想替代 C 的 Zig 语言成立了基金会

Zig 语言官方宣布成立 Zig 软件基金会（Zig Software Foundation，ZFS），致力于促进、保护和推进 Zig 编程语言，支持并促进多元化和国际化的 Zig 开发者社区的发展。Zig 是一门通用编程语言，专为稳定性、可维护性和性能而设计，追求替代 C 语言在系统编程上的最佳地位。

来源：[开源中国](https://www.oschina.net/news/117118/announcing-zig-software-foundation)

>
> 拍一拍：C：“想取代我的多呢……”
>
>
>

#### 因被黑客滥用 Mozilla 宣布暂停 Firefox Send 文件共享服务

Firefox Send 服务于 2019 年 3 月上线。Firefox Send 在恶意软件社区得到了更广泛的应用。恶意软件作者在 Firefox Send 上传恶意软件的有效文件，这些文件以加密格式存储，然后黑客在给客户的电子邮件中分享该链接。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/1002131.htm)

>
> 拍一拍：确实很难防范被滥用，“自由”的代价。
>
>
>


Linux 上无痛文件提取

# Linux 上无痛文件提取

<img src="content_image/album_202007_12_233401zickd110d2dl6u6f.jpg" alt="" title="">

从 Linux 系统的存档中提取文件没有拔牙那么痛苦，但有时看起来更复杂。在这篇文章中，我们将看看如何轻松地从 Linux 系统中可能遇到的几乎所有类型的存档中提取文件。

它们有很多格式，从 .gz 到 .tbz2，这些文件的命名方式都各有一些不同。当然，你可以记住所有从存档中提取文件的各种命令以及它们的选项，但是你也可以将所有经验保存到脚本中，而不再担心细节。

在本文中，我们将一系列提取命令组合成一个脚本，它会调用适当的命令根据文档名提取文件的内容。该脚本首先以一些命令来验证是否已经提供了一个文件名作为参数，或要求运行脚本的人提供文件名。

```
#!/bin/bash

if [ $# -eq 0 ]; then
    echo -n "filename> "
    read filename
else
    filename=$1
fi

if [ ! -f "$filename" ]; then
    echo "No such file: $filename"
    exit $?
fi

```

了解了么？如果未提供任何参数，脚本将提示输入文件名，如果存在则使用它。然后，它验证文件是否实际存在。如果不是，那么脚本退出。

下一步是使用 bash 的 `case` 语句根据存档文件的名称调用适当的提取命令。对于其中某些文件类型（例如 .bz2），也可以使用除 `tar` 之外的其它命令，但是对于每种文件命名约定，我们仅包含一个提取命令。因此，这是带有各种存档文件名的 `case` 语句：

```
 case $filename in
    *.tar)      tar xf $filename;;
    *.tar.bz2)  tar xjf $filename;;
    *.tbz)      tar xjf $filename;;
    *.tbz2)     tar xjf $filename;;
    *.tgz)      tar xzf $filename;;
    *.tar.gz)   tar xzf $filename;;
    *.gz)       gunzip $filename;;
    *.bz2)      bunzip2 $filename;;
    *.zip)      unzip $filename;;
    *.Z)        uncompress $filename;;
    *)          echo "No extract option for $filename"
esac

```

如果提供给脚本的文件扩展名与脚本已知的扩展名都不匹配，那么会发出 “No extract option for $filename” 的消息。如果缺少你使用的任何存档类型，只需将它们与所需的提取命令一起添加即可。

将 bash 头添加到脚本顶部，使其可执行，然后就可以开始了。

```
#!/bin/bash

if [ $# -eq 0 ]; then
    echo -n "filename> "
    read filename
else
    filename=$1
fi

if [ ! -f "$filename" ]; then
    echo "No such file: $filename"
    exit $?
fi

case $filename in
    *.tar)      tar xf $filename;;
    *.tar.bz2)  tar xjf $filename;;
    *.tbz)      tar xjf $filename;;
    *.tbz2)     tar xjf $filename;;
    *.tgz)      tar xzf $filename;;
    *.tar.gz)   tar xzf $filename;;
    *.gz)       gunzip $filename;;
    *.bz2)      bunzip2 $filename;;
    *.zip)      unzip $filename;;
    *.Z)        uncompress $filename;;
    *.rar)      rar x $filename ;;
    *)

```

如果你希望脚本在提取文件时显示内容，请将详细选项（`-v`）添加到每个命令参数字符串中：

```
#!/bin/bash

if [ $# -eq 0 ]; then
    echo -n "filename> "
    read filename
else
    filename=$1
fi

if [ ! -f "$filename" ]; then
    echo "No such file: $filename"
    exit $?
fi

case $filename in
    *.tar)      tar xvf $filename;;
    *.tar.bz2)  tar xvjf $filename;;
    *.tbz)      tar xvjf $filename;;
    *.tbz2)     tar xvjf $filename;;
    *.tgz)      tar xvzf $filename;;
    *.tar.gz)   tar xvzf $filename;;
    *.gz)       gunzip -v $filename;;
    *.bz2)      bunzip2 -v $filename;;
    *.zip)      unzip -v $filename;;
    *.Z)        uncompress -v $filename;;
    *)          echo "No extract option for $filename"
esac

```

### 总结

虽然可以为每个可能用到的提取命令创建别名，但是让脚本为遇到的每种文件类型提供命令要比自己停下来编写每个命令和选项容易。

---

via: <https://www.networkworld.com/article/3564265/painless-file-extraction-on-linux.html>

作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


物联网（IoT）简介

# 物联网（IoT）简介

>
> 物联网（IoT）是一个由智能设备连接起来的网络，并提供了丰富的数据，但是它也有可能是一场安全领域的噩梦。
>
>
>

<ruby> 物联网 <rt>  Internet of Things </rt></ruby>（IoT）是一个统称，指的是越来越多不属于传统计算设备，但却连接到互联网接收或发送数据，或既接收也发送的电子设备组成的网络。

现在有数不胜数的东西可以归为这一类：可以联网的“智能”版传统设备，比如说电冰箱和灯泡；那些只能运行于有互联网环境的小设备，比如像 Alexa 之类的电子助手；与互联网连接的传感器，它们正在改变着工厂、医疗、运输、物流中心和农场。

### 什么是物联网？

物联网将互联网、数据处理和分析的能力带给了现实的实物世界。对于消费者来说，这就意味着不需要键盘和显示器这些东西，就能和这个全球信息网络进行互动；他们的日常用品当中，很多都可以通过该网络接受操作指令，而只需很少的人工干预。

互联网长期以来为知识工作提供了便利，在企业环境当中，物联网也能为制造和分销带来同样的效率。全球数以百万计甚至数十亿计的嵌入式具有互联网功能的传感器正在提供令人难以置信丰富的数据集，企业可以利用这些数据来保证他们运营的安全、跟踪资产和减少人工流程。研究人员也可以使用物联网来获取人们的喜好和行为数据，尽管这些行为可能会严重影响隐私和安全。

### 它有多大？

一句话：非常庞大。[Priceonomics 对此进行了分析](https://priceonomics.com/the-iot-data-explosion-how-big-is-the-iot-data/)：在 2020 年的时候，有超过 50 亿的物联网设备，这些设备可以生成 4.4 <ruby> 泽字节 <rt>  zettabyte </rt></ruby>（LCTT 译注：1 zettabyte = 10 9 terabyte = 10 12 gigabyte）的数据。相比较，物联网设备在 2013 年仅仅产生了 1000 亿<ruby> 千兆字节 <rt>  gigabyte </rt></ruby>的数据。在物联网市场上可能挣到的钱也同样让人瞠目；到 2025 年，这块市场的价值可以达到 1.6 万亿美元到 14.4 万亿美元不等。

### 物联网的历史

一个联网设备和传感器无处不在的世界，是科幻小说中最经典的景象之一。物联网传说中将 1970 年 [卡耐基•梅隆大学的一台连接到 APRANET 的自动贩卖机](https://www.machinedesign.com/automation-iiot/article/21836968/iot-started-with-a-vending-machine) 称之为世界上第一个物联网设备，而且许多技术都被吹捧为可以实现 “智能” 的物联网式特征，使其颇具有未来主义的光彩。但是“物联网”这个词是由英国的技术专家 [Kevin Ashton](https://www.visioncritical.com/blog/kevin-ashton-internet-of-things) 于 1999 年提出来的。

一开始，技术是滞后于当时对未来的憧憬的。每个与互联网相连的设备都需要一个处理器和一种能和其他东西通信的方式，无线的最好，这些因素都增加了物联网大规模实际应用的成本和性能要求，这种情况至少一直持续到 21 世纪头十年中期，直到摩尔定律赶上来。

一个重要的里程碑是 [RFID 标签的大规模使用](https://www.networkworld.com/article/2319384/rfid-readers-route-tag-traffic.html)，这种价格低廉的极简转发器可以被贴在任何物品上，然后这些物品就可以连接到更大的互联网上了。对于设计者来说，无处不在的 Wi-Fi 和 4G 让任何地方的无线连接都变得非常简单。而且，IPv6 的出现再也不用让人们担心把数十亿小设备连接到互联网上会将 IP 地址耗尽。（相关报道：[物联网网络可以促进 IPv6 的使用吗？](https://www.networkworld.com/article/3338106/can-iot-networking-drive-adoption-of-ipv6.html)）

### 物联网是如何工作的？

物联网的基本元素是收集数据的设备。广义地说，它们是和互联网相连的设备，所以每一个设备都有 IP 地址。它们的复杂程度不一，这些设备涵盖了从工厂运输货物的自动驾驶车辆到监控建筑温度的简单传感器。这其中也包括每天统计步数的个人手环。为了让这些数据变得有意义，就需要对其收集、处理、过滤和分析，每一种数据都可以通过多种方式进行处理。

采集数据的方式是将数据从设备上传输到采集点。可以通过各种无线或者有线网络进行数据的转移。数据可以通过互联网发送到具有存储空间或者计算能力的数据中心或者云端，或者这些数据也可以分段进行传输，由中间设备汇总数据后再沿路径发送。

处理数据可以在数据中心或者云端进行，但是有时候这不太可行。对于一些非常重要的设备，比如说工业领域的关停设备，从设备上将数据发送到远程数据中心的延迟太大了。发送、处理、分析数据和返回指令（在管道爆炸之前关闭阀门）这些操作，来回一趟的时间可能要花费非常多的时间。在这种情况下，<ruby> 边缘计算 <rt>  edge-computing </rt></ruby>就可以大显身手了，智能边缘设备可以汇总数据、分析数据，在需要的时候进行回应，所有这些都在相对较近的物理距离内进行，从而减少延迟。边缘设备可以有上游连接，这样数据就可以进一步被处理和储存。

*物联网是如何工作的。*

### 物联网设备的一些例子

本质上，任何可以搜集来自于真实世界数据，并且可以发送回去的设备都可以参与到物联网生态系统中。典型的例子包括智能家居设备、射频识别标签（RFID）和工业传感器。这些传感器可以监控一系列的因素，包括工业系统中的温度和压力、机器中关键设备的状态、患者身上与生命体征相关的信号、水电的使用情况，以及其它许许多多可能的东西。

整个工厂的机器人可以被认为是物联网设备，在工业环境和仓库中移动产品的自主车辆也是如此。

其他的例子包括可穿戴设备和家庭安防系统。还有一些其它更基础的设备，比如说[树莓派](https://www.networkworld.com/article/3176091/10-killer-raspberry-pi-projects-collection-1.html)和[Arduino](https://www.networkworld.com/article/3075360/arduino-targets-the-internet-of-things-with-primo-board.html)，这些设备可以让你构建你自己的物联网终端节点。尽管你可能会认为你的智能手机是一台袖珍电脑，但它很可能也会以非常类似物联网的方式将你的位置和行为数据传送到后端服务。

#### 设备管理

为了能让这些设备一起工作，所有这些设备都需要进行验证、分配、配置和监控，并且在必要时进行修复和更新。很多时候，这些操作都会在一个单一的设备供应商的专有系统中进行；要么就完全不会进行这些操作，而这样也是最有风险的。但是整个业界正在向[标准化的设备管理模式](https://www.networkworld.com/article/3258812/the-future-of-iot-device-management.html)过渡，这使得物联网设备之间可以相互操作，并保证设备不会被孤立。

#### 物联网通信标准和协议

当物联网上的小设备和其他设备通信的时候，它们可以使用各种通信标准和协议，这其中许多都是为这些处理能力有限和电源功率不大的设备专门定制的。你一定听说过其中的一些，尽管有一些设备使用的是 Wi-Fi 或者蓝牙，但是更多的设备是使用了专门为物联网世界定制的标准。比如，ZigBee 就是一个低功耗、远距离传输的无线通信协议，而 MQTT（<ruby> 消息队列遥测传输 <rt>  Message Queuing Telemetry Transport </rt></ruby>）是为连接在不可靠或者易发生延迟的网络上的设备定制的一个发布/订阅信息协议。（参考 Network World 的词汇表：[物联网标准和协议](file:///Users/xingyuwang/develop/TranslateProject-wxy/translated/talk/11)。）

物联网也会受益于 5G 为蜂窝网络带来的高速度和高带宽，尽管这种使用场景会[滞后于普通的手机](https://www.networkworld.com/article/3291778/what-s-so-special-about-5g-and-iot.html)。

### 物联网、边缘计算和云

*边缘计算如何使物联网成为可能。*

对于许多物联网系统来说，大量的数据会以极快的速度涌来，这种情况催生了一个新的科技领域，<ruby>   边缘计算  <rt>  edge computing </rt></ruby>，它由放置在物联网设备附近的设备组成，处理来自那些设备的数据。这些机器对这些数据进行处理，只将相关的素材数据发送到一个更集中的系统系统进行分析。比如，想象一个由几十个物联网安防摄像头组成的网络，边缘计算会直接分析传入的视频，而且只有当其中一个摄像头检测到有物体移动的时候才向安全操作中心（SoC）发出警报，而不会是一下子将所有的在线数据流全部发送到建筑物的 SoC。

一旦这些数据已经被处理过了，它们又去哪里了呢？好吧，它也许会被送到你的数据中心，但是更多情况下，它最终会进入云。

对于物联网这种间歇或者不同步的数据来往场景来说，具有弹性的云计算是再适合不过的了。许多云计算巨头，包括[谷歌](https://cloud.google.com/solutions/iot)、[微软](https://azure.microsoft.com/en-us/overview/iot/)和[亚马逊](https://aws.amazon.com/iot/)，都有物联网产品。

### 物联网平台

云计算巨头们正在尝试出售的，不仅仅是存放传感器搜集的数据的地方。他们正在提供一个可以协调物联网系统中各种元素的完整平台，平台会将很多功能捆绑在一起。本质上，物联网平台作为中间件，将物联网设备和边缘网关与你用来处理物联网数据的应用程序连接起来。也就是说，每一个平台的厂商看上去都会对物联网平台应该是什么这个问题有一些稍微不同的解释，以更好地[与其他竞争者拉开差距](https://www.networkworld.com/article/3336166/why-are-iot-platforms-so-darn-confusing.html)。

### 物联网和数据

正如前面所提到的，所有这些物联网设备收集了 ZB 级的数据，这些数据通过边缘网关被发送到平台上进行处理。在很多情况下，这些数据就是要部署物联网的首要原因。通过从现实世界中的传感器搜集来的数据，企业就可以实时的作出灵活的决定。

例如，Oracle 公司[假想了一个这样的场景](https://blogs.oracle.com/bigdata/how-big-data-powers-the-internet-of-things)，当人们在主题公园的时候，会被鼓励下载一个可以提供公园信息的应用。同时，这个程序会将 GPS 信号发回到公园的管理部门来帮助他们预测排队时间。有了这些信息，公园就可以在短期内（比如通过增加员工数量来提升景点的一些容量）和长期内（通过了解哪些设施最受欢迎，那些最不受欢迎）采取行动。

这些决定可以在没有人工干预的情况作出。比如，从化工厂管道中的压力传感器收集的数据可以通过边缘设备的软件进行分析，从而发现管道破裂的威胁，这样的信息可以触发关闭阀门的信号，从而避免泄漏。

### 物联网和大数据分析

主题公园的例子可以让你很容易理解，但是和许多现实世界中物联网收集数据的操作相比，就显得小菜一碟了。许多大数据业务都会使用到来自物联网设备收集的信息，然后与其他数据关联，这样就可以分析预测到人类的行为。Software Advice 给出了[一些例子](https://www.softwareadvice.com/resources/iot-data-analytics-use-cases/)，其中包括由 Birst 提供的一项服务，该服务将从联网的咖啡机中收集的咖啡冲泡的信息与社交媒体上发布的帖子进行匹配，看看顾客是否在网上谈论咖啡品牌。

另一个最近才发生的戏剧性的例子，X-Mode 发布了一张基于位置追踪数据的地图，地图上显示了在 2020 年 3 月春假的时候，正当新冠病毒在美国加速传播的时候，人们在<ruby> 劳德代尔堡 <rt>  Ft. Lauderdale </rt></ruby>聚会完[最终都去了哪里](https://www.cnn.com/2020/04/04/tech/location-tracking-florida-coronavirus/index.html)。这张地图令人震撼，不仅仅是因为它显示出病毒可能的扩散方向，更是因为它说明了物联网设备是可以多么密切地追踪我们。（更多关于物联网和分析的信息，请点击[此处](https://www.networkworld.com/article/3311919/iot-analytics-guide-what-to-expect-from-internet-of-things-data.html)。）

### 物联网数据和 AI

物联网设备能够收集的数据量远远大于任何人类能够以有效的方式处理的数据量，而且这肯定也不是能实时处理的。我们已经看到，仅仅为了理解从物联网终端传来的原始数据，就需要边缘计算设备。此外，还需要检测和处理可能就是[完全错误的数据](https://www.networkworld.com/article/3396230/when-iot-systems-fail-the-risk-of-having-bad-iot-data.html)。

许多物联网供应商也同时提供机器学习和人工智能的功能，可以用来理解收集来的数据。比如，IBM 的 Jeopardy!-winning Watson 平台就可以在[物联网数据集上进行训练](https://www.networkworld.com/article/3449243/watson-iot-chief-ai-can-broaden-iot-services.html)，这样就可以在预测性维护领域产生有用的结果 —— 比如说，分析来自无人机的数据，可以区分桥梁上轻微的损坏和需要重视的裂缝。同时，ARM 也在研发[低功耗芯片](https://www.networkworld.com/article/3532094/ai-everywhere-iot-chips-coming-from-arm.html)，它可以在物联网终端上提供 AI 的能力。

### 物联网和商业

物联网的商业用途包括跟踪客户、库存和重要部件的状态。[IoT for All](https://www.iotforall.com/4-unlikely-industries-iot-changing/) 列举了四个已经被物联网改变的行业：

* **石油和天然气**：与人工干预相比，物联网传感器可以更好的检测孤立的钻井现场。
* **农业**：通过物联网传感器获得的田间作物的数据，可以用来提高产量。
* **采暖通风**：制造商可以监控全国各地的气候控制系统。
* **实体零售**：当顾客在商店的某些地方停留的时候，可以通过手机进行微目标定位，提供优惠信息。

更普遍的情况是，企业正在寻找能够在[四个领域](https://www.networkworld.com/article/3396128/the-state-of-enterprise-iot-companies-want-solutions-for-these-4-areas.html)上获得帮助的物联网解决方案：能源使用、资产跟踪、安全领域和客户体验。

---

via: <https://www.networkworld.com/article/3207535/what-is-iot-the-internet-of-things-explained.html>

作者：[Josh Fruhlinger](https://www.networkworld.com/author/Josh-Fruhlinger/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Yufei-Yan](https://github.com/Yufei-Yan) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


#新闻拍一拍# Linux 内核批准采用中性的术语

Summary: • Linus Torvalds 对 Linux 内核支持 Rust 的看法：默认可以有效启用 • Android 10 的普及率最快

# #新闻拍一拍# Linux 内核批准采用中性的术语

<img src="content_image/album_202007_13_161653nx2sgg3200c0m3m5.jpg" alt="" title="">

#### Linux 内核批准采用中性的术语

Linus Torvalds 批准了 Linux 内核代码和文档采用中性术语的拉取请求。从现在开始，内核开发者被要求使用新的术语去替换 master/slave 和 blacklist/whitelist。

来源：[solidot](https://www.solidot.org/story?sid=64919)

>
> 拍一拍：你们高兴就好。
>
>
>

#### Linus Torvalds 对 Linux 内核支持 Rust 的看法：默认可以有效启用

去年就有开发者询问 Linux 内核稳定版维护者 Greg Kroah-Hartman “Linux 有没有想法拥抱 Rust”，Greg 希望 Linux 中的 Rust 支持是以可选的方式存在，而不能全面默认启用。但 Linus 则认为应该在默认情况下可以有效地启用支持，以确保进行广泛的测试，而不是只有某些开发者孤立地在进行疯狂/错误的使用。

来源：[开源中国](https://www.oschina.net/news/117139/linus-linux-rust-support-remark)

>
> 拍一拍：这个态度要比 Greg 的积极多了。
>
>
>

#### Android 10 的普及率最快

Google 刚刚宣布：去年 9 月发布的 Android 10 是所有 Android 版本中普及率最快的，发布五个月设备安装量已经达到了一亿。但搜索巨人没有提供安装百分比等数据，它已经完全停止更新不同 Android 版本的占有率数据。相比下，苹果的数据很清晰：它的 iOS 13 安装比例为 81%。苹果完全控制了它的软件和硬件，而 Google 只控制软件。

来源：[solidot](https://www.solidot.org/story?sid=64920)

>
> 拍一拍：但是如果 Android 不采用开源模式，恐怕也不能这样迅速崛起。
>
>
>


把你的树莓派家庭实验室变成一个网络文件系统

Summary: 使用 NFS 服务器将共享文件系统添加到你的家庭实验室。

使用 NFS 服务器将共享文件系统添加到你的家庭实验室。

# 把你的树莓派家庭实验室变成一个网络文件系统

>
> 使用 NFS 服务器将共享文件系统添加到你的家庭实验室。
>
>
>

共享文件系统是为家庭实验室增加通用性和功能性的好方法。在实验室中为客户端共享一个集中的文件系统，使得组织数据、进行备份和共享数据变得相当容易。这对于在多个服务器上进行负载均衡的 Web 应用和 [Kubernetes](https://opensource.com/resources/what-is-kubernetes) 使用的持久化卷来说，尤其有用，因为它允许在任何数量的节点上用持久化数据来轮转 Pod。

无论你的家庭实验室是由普通计算机、多余的企业服务器，还是树莓派或其他单板计算机（SBC）组成，共享文件系统都是一种有用的资产，而网络文件系统（NFS）服务器是创建共享文件系统的好方法。

我之前写过关于[建立“家庭私有云”](/article-12277-1.html)的文章，这是一个由树莓派或其他 SBC 组成的家庭实验室，也许还有其他一些消费类硬件或台式 PC。NFS 服务器是这些组件之间共享数据的理想方式。由于大多数 SBC 的操作系统是通过 SD 卡运行的，所以存在一些挑战。尤其是在用作计算机的操作系统磁盘时，SD 卡的故障率会增加，它们并不是用来不断地读写的。你实际需要的是一个真正的硬盘：它们通常比 SD 卡的每 GB 价格便宜，特别是对于较大的磁盘，而且它们不太可能持续发生故障。树莓派 4 现在带有 USB 3.0 接口，而 USB 3.0 硬盘无处不在，价格也很实惠。这是一个完美的搭配。在这个项目中，我将使用一个 2TB 的 USB 3.0 外置硬盘插入到运行 NFS 服务器的树莓派 4 中。

### 安装 NFS 服务器软件

我在树莓派上运行 Fedora 服务器，但这个项目也可以在其他发行版上运行。要在 Fedora 上运行 NFS 服务器，你需要 `nfs-utils` 包，幸运的是它已经安装好了（至少在 Fedora 31 中是这样）。如果你打算运行 NFSv3 服务，你还需要 `rpcbind` 包，但它不是 NFSv4 的严格要求。

如果你的系统中还没有这些软件包，请使用 `dnf` 命令安装它们。

```
# 安装 nfs-utils 和 rpcbind
$ sudo dnf install nfs-utils rpcbind

```

Raspbian 是另一个与树莓派一起使用的流行操作系统，设置几乎完全相同。软件包名称不同而已，但这是唯一的主要区别。要在运行 Raspbian 的系统上安装 NFS 服务器，你需要以下软件包。

* `nfs-common`：这些文件是 NFS 服务器和客户端的通用文件。
* `nfs-kernel-server`：主要的 NFS 服务器软件包。

Raspbian 使用 `apt-get` 来管理软件包（而不是像 Fedora 那样使用 `dnf`），所以用它来安装软件包。

```
# 对于 Raspbian 系统，使用 apt-get 来安装 NFS 软件包
$ sudo apt-get install nfs-common nfs-kernel-server

```

### 准备一个 USB 硬盘作为存储设备

正如我上面提到的，USB 硬盘是为树莓派或其他 SBC 提供存储的好选择，尤其是用于操作系统磁盘镜像的 SD 卡并不适合这个用途。对于家庭私有云，你可以使用廉价的 USB 3.0 硬盘进行大规模存储。插入磁盘，使用 `fdisk` 找出分配给它的设备 ID，就可以使用它工作了。

```
# 使用 fdisk 找到你的硬盘
# 无关的硬盘信息已经省略
$ sudo fdisk -l

Disk /dev/sda: 1.84 TiB, 2000398933504 bytes, 3907029167 sectors
Disk model: BUP Slim BK
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xe3345ae9

Device     Boot Start        End    Sectors  Size Id Type
/dev/sda1        2048 3907028991 3907026944  1.8T 83 Linux

```

为了清楚起见，在上面的例子输出中，除了我感兴趣的那个磁盘，我省略了所有其它磁盘的信息。你可以看到我想使用的 USB 磁盘被分配了设备 `/dev/sda`，你可以看到一些关于型号的信息（`Disk model: BUP Slim BK`），这有助于我识别正确的磁盘。该磁盘已经有了一个分区，它的大小也证实了它就是我要找的磁盘。

注意：请确保正确识别你的设备的磁盘和分区。它可能与上面的例子不同。

在驱动器上创建的每个分区都有一个特殊的通用唯一标识符（UUID）。计算机使用 UUID 来确保它使用 `/etc/fstab` 配置文件将正确的分区挂载到正确的位置。你可以使用 `blkid` 命令检索分区的 UUID。

```
# 获取该分区的块设备属性
# 确保你使用了合适的分区，它应该有所不同。
$ sudo blkid /dev/sda1

/dev/sda1: LABEL="backup" UUID="bd44867c-447c-4f85-8dbf-dc6b9bc65c91" TYPE="xfs" PARTUUID="e3345ae9-01"

```

在这里，`/dev/sda1` 的 UUID 是 `bd44867c-447c-4f85-8dbf-dc6b9bc65c91`。你的 UUID 会有所不同，所以要记下来。

### 配置树莓派在启动时挂载这个磁盘，然后挂载它

现在你已经确定了要使用的磁盘和分区，你需要告诉计算机如何挂载它，每次启动时都要这样做。现在就去挂载它。因为这是一个 USB 磁盘，可能会被拔掉，所以你还要配置树莓派在启动时如果磁盘没有插入或有其它不可用情况时不要等待。

在 Linux 中，通过将分区添加到 `/etc/fstab` 配置文件中，包括你希望它被挂载的位置和一些参数来告诉计算机如何处理它。这个例子将把分区挂载到 `/srv/nfs`，所以先创建这个路径：

```
# 创建该磁盘分区的挂载点
$ sudo mkdir -p /srv/nfs

```

接下来，使用以下语法格式修改 `/etc/fstab` 文件：

```
<disk id>     <mountpoint>      <filesystem type>     <options>     <fs_freq> <fs_passno>

```

使用你之前确定的 UUID 作为磁盘 ID。正如我在上一步提到的，挂载点是 `/srv/nfs`。对于文件系统类型，通常最好选择其实际的文件系统，但是因为这是一个 USB 磁盘，所以使用 `auto`。

对于选项值，使用 `nosuid,nodev,nofail`。

#### 关于手册页的一个旁白

其实，有*很多*可能的选项，手册页（`man`）是查看它们的最好方法。查看 `fstab` 的手册页是一个很好的开始。

```
# 打开 fstab 的手册页
$ man fstab

```

这将打开与 `fstab` 命令相关的手册/文档。在手册页中，每个选项都被分解成了不同的内容，以显示它的作用和常用的选择。例如，“第四个字段（fs\_mntopts）”给出了该字段中可用选项的一些基本信息，并引导你到 `man 8 mount` 中获取 `mount` 选项更深入的描述。这是有道理的，因为 `/etc/fstab` 文件，本质上是告诉计算机如何自动挂载磁盘，就像你手动使用 `mount` 命令一样。

你可以从 `mount` 的手册页中获得更多关于你将使用的选项的信息。数字 8 表示手册页的章节。在这里，第 8 章节是*系统管理工具和守护进程*。

你可以从 `man` 的手册页中得到标准章节的列表。

回到挂载磁盘，让我们看看 `man 8 mount`。

```
# 打开第 8 章节的 mount 手册页
$ man 8 mount

```

在这个手册页中，你可以查看上面列出的选项的作用。

* `nosuid`：不理会 suid/guid 位。不允许放在 U 盘上的任何文件以 root 身份执行。这是一个良好的安全实践。
* `nodev`：不识别文件系统中的字符或块特殊设备，即不理会在 U 盘上的任何设备节点。另一个良好的安全实践。
* `nofail`：如果设备不存在，不要记录任何错误。这是一个 U 盘，可能没有插入，所以在这种情况下，它将被忽略。

回到你正在添加到 `/etc/fstab` 文件的那一行，最后还有两个选项：`fs_freq` 和 `fs_passno`。它们的值与一些过时的选项有关，*大多数*现代系统对这两个选项都只用 `0`，特别是对 USB 磁盘上的文件系统而言。`fs_freq` 的值与 `dump` 命令和文件系统的转储有关。`fs_passno` 的值定义了启动时要 `fsck` 的文件系统及其顺序，如果设置了这个值，通常根分区是 `1`，其他文件系统是 `2`，将该值设置为 `0` 以跳过在该分区上使用 `fsck`。

在你喜欢的编辑器中，打开 `/etc/fstab` 文件，添加 U 盘上分区的条目，将这里的值替换成前面步骤中得到的值。

```
# With sudo, or as root, add the partition info to the /etc/fstab file
UUID="bd44867c-447c-4f85-8dbf-dc6b9bc65c91"    /srv/nfs    auto    nosuid,nodev,nofail,noatime 0 0

```

### 启用并启动 NFS 服务器

安装好软件包，并将分区添加到你的 `/etc/fstab` 文件中，现在你可以开始启动 NFS 服务器了。在 Fedora 系统中，你需要启用和启动两个服务：`rpcbind` 和 `nfs-server`。使用 `systemctl` 命令来完成这项工作。

```
# 启动 NFS 服务器和 rpcbind
$ sudo systemctl enable rpcbind.service
$ sudo systemctl enable nfs-server.service
$ sudo systemctl start rpcbind.service
$ sudo systemctl start nfs-server.service

```

在 Raspbian 或其他基于 Debian 的发行版上，你只需要使用 `systemctl` 命令启用并启动 `nfs-kernel-server` 服务即可，方法同上。

#### RPCBind

rpcbind 工具用于将远程过程调用（RPC）服务映射到其监听的端口。根据 rpcbind 手册页：

>
> “当一个 RPC 服务启动时，它会告诉 rpcbind 它正在监听的地址，以及它准备服务的 RPC 程序号。当客户机想对给定的程序号进行 RPC 调用时，它首先与服务器机器上的 rpcbind 联系，以确定 RPC 请求应该发送到哪里的地址。”
>
>
>

在 NFS 服务器这个案例中，rpcbind 会将 NFS 的协议号映射到 NFS 服务器监听的端口上。但是，NFSv4 不需要使用 rpcbind。如果你*只*使用 NFSv4 （通过从配置中删除版本 2 和版本 3），则不需要使用 rpcbind。我把它放在这里是为了向后兼容 NFSv3。

### 导出挂载的文件系统

NFS 服务器根据另一个配置文件 `/etc/exports` 来决定与哪些远程客户端共享（导出）哪些文件系统。这个文件只是一个 IP（或子网）与要共享的文件系统的映射，以及一些选项（只读或读写、root 去除等）。该文件的格式是：

```
<目录>     <主机>(选项)

```

在这个例子中，你将导出挂载到 `/srv/nfs` 的分区。这是“目录”部分。

第二部分，主机，包括你要导出这个分区的主机。这些主机可以是单个主机：使用具有完全限定域名（FQDN）或主机名、主机的 IP 地址来指定；也可以是一组主机：使用通配符字符来匹配域（如 \*.example.org）、IP 网络（如无类域间路由 CIDR 标识）或网组表示。

第三部分包括应用于该导出的选项。

* `ro/rw`：将文件系统导出为只读或读写。
* `wdelay`：如果即将进行另一次写入，则推迟对磁盘的写入，以提高性能（如果你使用的是固态 USB 磁盘，这*可能*没有那么有用）
* `root_squash`：防止客户机上的任何 root 用户在主机上有 root 权限，并将 root UID 设置为 `nfsnobody` 作为安全防范措施。

测试导出你挂载在 `/srv/nfs` 处的分区到一个客户端 —— 例如，一台笔记本电脑。确定你的客户机的 IP 地址（我的笔记本是 `192.168.2.64`，但你的可能会不同）。你可以把它共享到一个大的子网，但为了测试，请限制在单个 IP 地址上。这个 IP 的 CIDR 标识是 `192.168.2.64/32`，`/32` 子网代表一个 IP。

使用你喜欢的编辑器编辑 `/etc/exports` 文件，写上你的目录、主机 CIDR 以及 `rw` 和 `root_squash` 选项。

```
# 像这样编辑你的 /etc/exports 文件，替换为你的系统上的信息
/srv/nfs    192.168.2.64/32(rw,root_squash)

```

注：如果你从另一个地方复制了 `/etc/exports` 文件，或者用副本覆盖了原文件，你可能需要恢复该文件的 SELinux 上下文。你可以使用 `restorecon` 命令来恢复。

```
# 恢复 /etc/exports 文件的 SELinux 上下文
$ sudo restorecon /etc/exports

```

完成后，重新启动 NFS 服务器，以接收对 `/etc/exports` 文件的更改。

```
# 重新启动 NFS 服务器
$ sudo systemctl restart nfs-server.service

```

### 给 NFS 服务打开防火墙

有些系统，默认不运行[防火墙服务](https://opensource.com/article/18/9/linux-iptables-firewalld)。比如 Raspbian，默认是开放 iptables 规则，不同服务打开的端口在机器外部立即就可以使用。相比之下，Fedora 服务器默认运行的是 firewalld 服务，所以你必须为 NFS 服务器（以及 rpcbind，如果你将使用 NFSv3）打开端口。你可以通过 `firewall-cmd` 命令来实现。

检查 firewalld 使用的区域并获取默认区域。对于 Fedora 服务器，这是 `FedoraServer` 区域。

```
# 列出区域
# 出于简洁省略了部分输出
$ sudo firewall-cmd --list-all-zones

# R获取默认区域信息
# 记下默认区域
$ sudo firewall-cmd --get-default-zone

# 永久加入 nfs 服务到允许端口列表
$ sudo firewall-cmd --add-service=nfs --permanent

# 对于 NFSv3，我们需要再加一些端口： nfsv3、 rpc-mountd、 rpc-bind
$ sudo firewall-cmd --add-service=(nfs3,mountd,rpc-bind)

# 查看默认区域的服务，以你的系统中使用的默认区域相应替换
$ sudo firewall-cmd --list-services --zone=FedoraServer

# 如果一切正常，重载 firewalld
$ sudo firewall-cmd --reload

```

就这样，你已经成功地将 NFS 服务器与你挂载的 U 盘分区配置在一起，并将其导出到你的测试系统中进行共享。现在你可以在你添加到导出列表的系统上测试挂载它。

### 测试 NFS 导出

首先，从 NFS 服务器上，在 `/srv/nfs` 目录下创建一个文件来读取。

```
# 创建一个测试文件以共享
echo "Can you see this?" >> /srv/nfs/nfs_test

```

现在，在你添加到导出列表中的客户端系统上，首先确保 NFS 客户端包已经安装好。在 Fedora 系统上，它是 `nfs-utils` 包，可以用 `dnf` 安装。Raspbian 系统有 `libnfs-utils` 包，可以用 `apt-get` 安装。

安装 NFS 客户端包：

```
# 用 dnf 安装 nfs-utils 软件包
$ sudo dnf install nfs-utils

```

一旦安装了客户端包，你就可以测试 NFS 的导出了。同样在客户端，使用带有 NFS 服务器 IP 和导出路径的 `mount` 命令，并将其挂载到客户端的一个位置，在这个测试中是 `/mnt` 目录。在这个例子中，我的 NFS 服务器的 IP 是 `192.168.2.109`，但你的可能会有所不同。

```
# 挂载 NFS 服务器的输出到客户端主机
# 确保替换为你的主机的相应信息
$ sudo mount 192.168.2.109:/srv/nfs /mnt

# 查看 nfs_test 文件是不是可见
$ cat /mnt/nfs_test
Can you see this?

```

成功了！你现在已经有了一个可以工作的 NFS 服务器，可以与多个主机共享文件，允许多个读/写访问，并为你的数据提供集中存储和备份。家庭实验室的共享存储有很多选择，但 NFS 是一种古老的、高效的、可以添加到你的“家庭私有云”家庭实验室中的好选择。本系列未来的文章将扩展如何在客户端上自动挂载 NFS 共享，以及如何将 NFS 作为 Kubernetes 持久卷的存储类。

---

via: <https://opensource.com/article/20/5/nfs-raspberry-pi>

作者：[Chris Collins](https://opensource.com/users/clcollins) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


如何在 Ubuntu 20.04 上禁用坞站（dock）

Dash 你会翻译成什么？

直接切成 GNOME on Xorg 不就行了

其实我比较喜欢dash-to-dock；能禁用super+数字键启动程序，我都是用来切换工作区的。还能设置外观收缩dash，使面板变的窄一些，面板背景设置成透明。

# 如何在 Ubuntu 20.04 上禁用坞站（dock）

左侧的启动器已成为 [Ubuntu](https://ubuntu.com/) 桌面的标识。它是在 [Unity 桌面](https://itsfoss.com/keeping-ubuntu-unity-alive/)中引入的，甚至在 [Ubuntu 切换到 GNOME](https://itsfoss.com/ubuntu-unity-shutdown/)时就有了，它复刻了 “Dash to Panel”，以在 [GNOME](https://www.gnome.org/) 上创建一个类似的<ruby> 坞站 <rt>  dock </rt></ruby>。

就个人而言，我发现它对于快速访问常用应用非常方便，但并非所有人都希望它额外占用屏幕上的一些空间。

从 [Ubuntu 20.04](https://itsfoss.com/download-ubuntu-20-04/) 开始，你可以轻松禁用坞站。在本教程中，让我向你展示如何以图形和命令的方式执行此操作。

### 通过扩展应用禁用 Ubuntu Dock

[Ubuntu 20.04 的主要功能](https://itsfoss.com/ubuntu-20-04-release-features/)之一是引入“<ruby> 扩展 <rt>  Extension </rt></ruby>”应用来管理系统上的 GNOME 扩展。只需在 GNOME 菜单中查找它（按下 Windows 键并输入）：

>
> 没有找到扩展应用？
>
>
> 如果尚未安装，你应该启用 GNOME Shell 扩展，“扩展” GUI 是此软件包的一部分。
>
>
>
> ```
> sudo apt install gnome-shell-extensions
>
> ```
>
> 这仅对 [GNOME 3.36](https://itsfoss.com/gnome-3-36-release/) 或 Ubuntu 20.04（或更高版本） 中的更高版本有效。
>
>
>

启动“扩展”应用，你应该在“内置”扩展下看到 Ubuntu Dock。你只需要关闭即可禁用坞站。

更改是即时的，你会看到坞站立即消失。

你可以用相同的方式恢复。只需打开它，它就会立即显示。

在 Ubuntu 20.04 中非常容易隐藏坞站，不是吗？

### 替代方法：通过命令行禁用 Ubuntu 坞站

如果你是终端爱好者，并且喜欢在终端中做事，那么我有一个对你而言的好消息。你可以从命令行禁用 Ubuntu 坞站。

使用 `Ctrl+Alt+T` 打开终端。你可能已经知道 [Ubuntu 中的键盘快捷键](https://itsfoss.com/ubuntu-shortcuts/)。

在终端中，使用以下命令列出所有可用的 GNOME 扩展：

```
gnome-extensions list

```

这将显示类似于以下的输出：

默认的 Ubuntu 坞站扩展是 `ubuntu-dock@ubuntu.com`。你可以使用以下命令将其禁用：

```
gnome-extensions disable ubuntu-dock@ubuntu.com

```

屏幕上不会显示任何输出，但是你会注意到启动器（坞站）从左侧消失了。

如果需要，你可以使用与上面相同的命令再次启用它，但使用启用选项：

```
gnome-extensions enable ubuntu-dock@ubuntu.com

```

### 总结

在 Ubuntu 18.04 中也有禁用坞站的方法。但是，如果你尝试在 18.04 中删除它，这可能会导致不想要的结果。删除此软件包也会删除 ubuntu-desktop 包，最终可能会导致系统崩溃，例如没有应用菜单。

这就是为什么我不建议在 Ubuntu 18.04 上删除它的原因。

好消息是 Ubuntu 20.04 提供了一种隐藏任务栏的方法。用户拥有更大的自由度和更多的屏幕空间。说到更多的屏幕空间，你是否知道可以[从 Firefox 移除顶部标题栏并获得更多的屏幕空间](https://itsfoss.com/remove-title-bar-firefox/)？

我想知道你喜欢怎样的 Ubuntu 桌面？要坞站，不要坞站，还是不要 GNOME？

---

via: <https://itsfoss.com/disable-ubuntu-dock/>

作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


使用 Linux 实用程序 gPhoto2 备份手机存储

# 使用 Linux 实用程序 gPhoto2 备份手机存储

>
> 尽情地拍照吧，gphoto2 能够方便、快速地将照片从你的设备传输到 Linux 计算机上。
>
>
>

移动设备的最大缺点之一就是其将数据从设备传输到计算机很困难。移动设备在这一缺点上有着悠久的历史。早期的移动设备，如 Pilot 和掌上电脑 PDA 设备，需要使用特殊的同步软件来传输数据（你必须小心翼翼地做这件事，因为你的设备可能会因为电池耗尽而导致数据永久丢失）；旧版 iPod 只提供特定平台的界面。现代移动设备默认将你的数据发送到在线帐户，以便你可以在计算机上再次下载。

好消息——如果你正在运行 Linux，你可以使用 `gphoto2` 命令与移动设备进行连接。`gphoto2` 最初是作为一种与数码相机通信的方式而开发的，那时的数码相机只有传统的相机功能，现在的 `gphoto2` 可以和许多不同种类的移动设备通讯。别让这个名字骗了你，它可以处理所有类型的文件，而不仅仅是照片。更棒的是，它可以编写脚本、很灵活、并且比大多数 GUI 界面功能强大得多。

如果你曾经为在计算机和移动设备之间同步数据而苦恼，请了解一下 `gphoto2`。

### 安装 gPhoto2

很可能你的 Linux 系统已经安装了 libgphoto2，因为它是与移动设备连接的一个关键库，但你可能还需要安装命令 `gphoto2`，该命令可能在你的存储库中。

在 Fedora 或 RHEL 上：

```
$ sudo dnf install gphoto2

```

在 Debian 或 Ubuntu 上：

```
$ sudo apt install gphoto2

```

### 验证兼容性

若要确认你的移动设备是否受支持，请使用 `--list-cameras`，通过管道传输到 `less`：

```
$ gPhoto2 --list-cameras | less

```

或者你可以通过管道把它传送到 `grep` 来搜索一个词。例如，如果你有三星 Galaxy，则使用 `grep`，并通过选项 `-i` 关闭区分大小写：

```
$ gphoto2 --list-cameras | grep -i galaxy
  "Samsung Galaxy models (MTP)"
  "Samsung Galaxy models (MTP+ADB)"
  "Samsung Galaxy models Kies mode"

```

这证实了三星 Galaxy 设备支持通过 MTP 连接和通过 ADB 连接 MTP。

如果你没有在列表中找到自己的移动设备，你仍然可以尝试使用 `gphoto2`，可能你的设备在列表中使用了不同的称呼。

### 查找移动设备

要使用 gPhoto2，首先必须将移动设备插入计算机，设置为 MTP 模式，并且授予计算机与它交互的权限。这通常需要在你的移动设备上操作，往往是在屏幕上按下一个按钮，以允许其文件系统被刚刚连接的计算机访问。

如果你不授权电脑访问移动设备，那么 gPhoto2 可以检测到你的移动设备，但它不能与之交互。

要确保计算机检测到你连接的移动设备，请使用 `--auto-detect` 选项：

```
$ gphoto2 --auto-detect
Model                       Port
---------------------------------------
Samsung Galaxy models (MTP) usb:002,010

```

如果你的移动设备没有被检测到，请先检查数据线，然后检查你的设备是否配置为通过 MTP、ADB 或其它 gPhoto2 支持的协议连接，如 `--list-cameras` 所示。

### 查询你的设备支持的特性

对于现代设备，通常有过多的潜在功能，但并非所有移动设备都支持这些功能。你可以用 `--abilities` 选项来确定自己的移动设备支持哪些功能。我觉得结果看起来直观。

```
$ gphoto2 --abilities
Abilities for camera            : Samsung Galaxy models (MTP)
Serial port support             : no
USB support                     : yes
Capture choices                 : Capture not supported by driver
Configuration support           : no
Delete selected files on camera : yes
Delete all files on camera      : no
File preview (thumbnail) support: no
File upload support             : yes

```

如果只连接一个设备，那么不需要指定查询的设备。但是，如果连接了多个 gPhoto2 可以与之交互的设备，则可以通过端口、相机型号或 usbid 指定设备。

### 与你的移动设备交互

如果你的设备支持拍摄功能，则可以从计算机调用你的摄像头来获取媒体。例如，要拍摄照片：

```
$ gphoto2 --capture-image

```

要拍摄照片并立即将其传输到连接的计算机：

```
$ gphoto2 --capture-image-and-download

```

你也可以录制视频和声音。如果连接了多个拍摄设备，可以按端口、相机型号或 usbid 指定要使用的设备：

```
$ gphoto2 --camera "Samsung Galaxy models (MTP)" \
--capture-image-and-download

```

### 文件和文件夹

要想更加智能地管理移动设备上的文件，你需要了解 gPhoto2 连接的文件系统的结构。

你可以使用 `--get-folders` 选项查看可用文件夹：

```
$ gphoto2 --list-folders
There are 2 folders in folder '/'.
 - store_00010001
 - store_00020002
There are 0 folders in folder '/store_00010001'.
There are 0 folders in folder '/store_00020002'.

```

每个文件夹代表设备上的一个存储单元。在本例中，`store_00010001` 是内部存储器，`store_00020002` 是 SD 卡，这可能与你的设备的结构不同。

### 获取文件

现在你知道了设备的文件夹布局，就可以从设备获取照片了。你可以使用许多不同的选项，具体取决于你想从设备中获取什么。

如果你知道绝对路径，则可以获取指定的文件：

```
$ gphoto2 --get-file IMG_0001.jpg --folder /store_00010001/myphotos

```

你可以同时获得所有的文件：

```
$ gphoto2 --get-all-files --folder /store_00010001/myfiles

```

你可以只获取音频文件：

```
gphoto2 --get-all-audio-data --folder /store_00010001/mysounds

```

gPhoto2 还有其他的选择，其中大多数取决于你连接的设备和使用协议是否支持。

### 上传文件

现在你知道了潜在的目标文件夹，就可以将文件从计算机上传到你的设备。例如，假设有一个名为 `example.epub` 的文件在当前目录中，你可以使用 `--upload-file` 选项和 `--folder` 选项将文件发送到设备并指定要上传到的目录：

```
$ gphoto2 --upload file example.epub \
--folder store_00010001

```

如果你希望将多个文件上传到同一个位置，你可以在设备上创建一个目录：

```
$ gphoto2 --mkdir books \
--folder store_00010001
$ gphoto2 --upload-file *.epub \
--folder store_00010001/books

```

### 列出文件

若要查看设备上的文件，请使用 `--list-files` 选项：

```
$ gphoto2 --list-files --folder /store_00010001
There is 1 file in folder '/store_00010001'
#1     example.epub 17713 KB application/x-unknown
$ gphoto2 --list-files --folder /store_00010001/books
There is 1 file in folder '/store_00010001'
#1    example0.epub 17713 KB application/x-unknown
#2    example1.epub 12264 KB application/x-unknown
[...]

```

### 探索你的使用方式

gPhoto2 的大部分功能取决于你的设备，因此不同用户的体验可能不尽相同。在 `gphoto2 --help` 中列出了许多操作供你探索。使用gPhoto2，再也不用费劲把文件从你的设备传输到电脑上了！

这些开源图片库能够帮助你组织文件，并让的图片看起来很棒。

---

via: <https://opensource.com/article/20/7/gphoto2-linux>

作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[summer2233](https://github.com/summer2233) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


#新闻拍一拍# IBM 招聘广告要求应聘者具备至少 12 年 K8S 使用经验

Summary: • Mac 前主管：Windows PC 也终将积极拥抱 ARM 处理器 • Fedora 33 确认使用 Nano 作为默认文本编辑器

“拥有 12 年以上 Kubernetes 使用经验”？人家的意思是说“拥有1、2年以上 Kubernetes 使用经验”:-)

英文~~

# #新闻拍一拍# IBM 招聘广告要求应聘者具备至少 12 年 K8S 使用经验

<img src="content_image/album_202007_14_175144nc58y5j0ecxygcgr.jpg" alt="" title="">

#### IBM 招聘广告要求应聘者具备至少 12 年 K8S 使用经验

IBM 全球技术服务部门近日发布了一则招聘广告，其中一条招聘说明要求应聘者“拥有 12 年以上 Kubernetes 使用经验”。这条要求有点令人迷惑，因为 Kubernetes 项目在 GitHub 的初次提交时间为2014年6月7日，直到2015年5月22日才宣布 1.0 版本进入功能冻结阶段，也就是说诞生至今才 6 年。

来源：[开源中国](https://www.oschina.net/news/117168/ibm-kubernetes-experience-job-ad)

>
> 拍一拍：或许加班能将一天算成两天？
>
>
>

#### Mac 前主管：Windows PC 也终将积极拥抱 ARM 处理器

Mac 前主管 Jean-Louis Gassée 对苹果从英特尔处理器向自研 ARM 处理器转型一事发表了评论：A12Z Bionic 证明了未来的 Mac 将在不影响性能的前提下，大幅降低整机的热设计功耗。为了保持在市场上的竞争力，竞争对手也终将不得不提供对 ARM CPU 的更好支持。

来源：[cnBeta.COM](https://www.cnbeta.com/articles/tech/1002869.htm)

>
> 拍一拍：不知道 Intel 怎么想？
>
>
>

#### Fedora 33 确认使用 Nano 作为默认文本编辑器

Fedora 工程和指导委员会(FESCo)上周全员批准 Fedora 33 使用 Nano 作为默认文本编辑器的提案。

来源：[开源中国](https://www.oschina.net/news/117170/fedora-33-nano-is-the-default)

>
> 拍一拍：好吧，毕竟还是要往前走的。虽然作为老系统管理员有点不适应，但是不能进步的技术人员就不是技术人员。
>
>
>


使用 fail2ban 和 FirewallD 黑名单保护你的系统

# 使用 fail2ban 和 FirewallD 黑名单保护你的系统

<img src="content_image/album_202007_15_124648wugu6bzpw7q5zg72.png" alt="" title="">

如果你运行的服务器有面向公众的 SSH 访问，你可能遇到过恶意登录尝试。本文介绍了如何使用两个实用程序来防止入侵者进入我们的系统。

为了防止反复的 ssh 登录尝试，我们来看看 fail2ban。而且，如果你不经常旅行，基本上停留在一两个国家，你可以将 FirewallD 配置为只允许[从你选择的国家访问](https://www.linode.com/community/questions/11143/top-tip-firewalld-and-ipset-country-blacklist)。

首先，让我们为不熟悉这些应用程序的人员介绍一些术语，以完成这项工作：

**fail2ban**：一个守护进程，用于禁止发生多次认证错误的主机。fail2ban 将监控 SystemD 日志，以查找对任何已启用的“<ruby> 监狱 <rt>  jail </rt></ruby>”的失败的验证尝试。在达到指定失败次数后，它将添加一个防火墙规则，在配置的时间内阻止该特定 IP 地址。

**FirewallD**：一个带有 D-Bus 接口的防火墙守护进程，提供动态防火墙。除非你另行决定使用传统的 iptables，否则你已经在所有支持的 Fedora 和 CentOS 上安装了 FirewallD。

### 假定前提

* 主机系统有一个互联网连接，并且要么是直接暴露在互联网上，要么是通过 DMZ（这两个都是非常糟糕的想法，除非你知道你在做什么），要么是有一个端口从路由器转发过来。
* 虽然大部分的内容可能适用于其他系统，但本文假设当前系统是 Fedora（31 及以上）或 RHEL/CentOS 8 版本。在 CentOS 上，你必须用 `sudo dnf install epel-release` 启用 Fedora EPEL 仓库。

### 安装与配置

#### Fail2Ban

很有可能已经有某个 Firewalld 区已经允许 SSH 访问，但 sshd 服务本身默认没有启用。要手动启动它，并且不在启动时永久启用它：

```
$ sudo systemctl start sshd

```

或者在系统启动时启用，并同时启动它：

```
$ sudo systemctl enable --now sshd

```

下一步就是安装、配置、启用 fail2ban。和往常一样，安装可以通过命令行完成：

```
$ sudo dnf install fail2ban

```

安装完毕后，下一步就是配置“监狱”（你要以设置的任何阈值监视并禁止的服务）。默认情况下，IP 会被禁止 1 小时（这其实不够长）。最好的做法是使用 `*.local` 文件覆盖系统默认值，而不是直接修改 `*.config` 文件。如果我们查看我的 `jail.local`，我们可以看到：

```
# cat /etc/fail2ban/jail.local
[DEFAULT]

# "bantime" is the number of seconds that a host is banned.
bantime  = 1d

# A host is banned if it has generated "maxretry" during the last "findtime"
findtime  = 1h

# "maxretry" is the number of failures before a host get banned.
maxretry = 5

```

换成通俗的语言讲，就是在过去一小时内尝试 5 次后，该 IP 将被封禁 1 天。对于多次被封的 IP，也可以选择增加封禁时间，但这是另一篇文章的主题。

下一步是配置“监狱”。在本教程中显示的是 `sshd`，但其他服务的步骤大致相同。在 `/etc/fail2ban/jail.d` 中创建一个配置文件。这是我的文件：

```
# cat /etc/fail2ban/jail.d/sshd.local
[sshd]
enabled = true

```

就这么简单! 很多配置已经在为 Fedora 构建的软件包中处理了（提示：我是当前的维护者）。接下来启用并启动 fail2ban 服务：

```
$ sudo systemctl enable --now fail2ban

```

希望没有立即出错，如果没有，请使用下面的命令检查 fail2ban 的状态：

```
$ sudo systemctl status fail2ban

```

如果它没有错误地启动，应该是这样的：

```
$ systemctl status fail2ban
● fail2ban.service - Fail2Ban Service
Loaded: loaded (/usr/lib/systemd/system/fail2ban.service; disabled; vendor preset: disabled)
Active: active (running) since Tue 2020-06-16 07:57:40 CDT; 5s ago
Docs: man:fail2ban(1)
Process: 11230 ExecStartPre=/bin/mkdir -p /run/fail2ban (code=exited, status=0/SUCCESS)
Main PID: 11235 (f2b/server)
Tasks: 5 (limit: 4630)
Memory: 12.7M
CPU: 109ms
CGroup: /system.slice/fail2ban.service
└─11235 /usr/bin/python3 -s /usr/bin/fail2ban-server -xf start
Jun 16 07:57:40 localhost.localdomain systemd[1]: Starting Fail2Ban Service…
Jun 16 07:57:40 localhost.localdomain systemd[1]: Started Fail2Ban Service.
Jun 16 07:57:41 localhost.localdomain fail2ban-server[11235]: Server ready

```

如果是刚刚启动的，fail2ban 不太可能显示任何有意思的信息，但要检查 fail2ban 的状态，并确保“监狱”被启用，请输入：

```
$ sudo fail2ban-client status
Status
|- Number of jail:      1
`- Jail list:   sshd

```

sshd “监狱”的上级状态也会显示出来。如果启用了多个“监狱”，它们会在这里显示出来。

要查看一个“监狱”的详细状态，只需在前面的命令中添加“监狱”名称。下面是我的系统的输出，它已经运行了一段时间。我已经从输出中删除了被禁止的 IP：

```
$ sudo fail2ban-client status sshd
Status for the jail: sshd
|- Filter
|  |- Currently failed: 8
|  |- Total failed:     4399
|  `- Journal matches:  _SYSTEMD_UNIT=sshd.service + _COMM=sshd
`- Actions
   |- Currently banned: 101
   |- Total banned:     684
   `- Banned IP list:   ...

```

监控 fail2ban 日志文件是否有入侵尝试，可以通过“尾随”日志来实现：

```
$ sudo tail -f /var/log/fail2ban.log

```

`tail` 是一个很好的命令行工具，默认情况下，它可以显示一个文件的最后 10 行。添加 `-f` 告诉它尾随文件，这是个观察一个仍在被写入的文件的很好方式。

由于输出的内容中有真实的 IP，所以这里不会提供样本，但它的可读性很高。`INFO` 行通常是登录的尝试。如果从一个特定的 IP 地址进行了足够多的尝试，你会看到一个 `NOTICE` 行显示一个 IP 地址被禁止。在达到禁止时间后，你会看到一个 `NOTICE` 解禁行。

注意几个警告行。最常见的情况是，当添加了一个禁止后，fail2ban 发现该 IP 地址已经在其禁止数据库中，这意味着禁止可能无法正常工作。如果是最近安装的 fail2ban 包，它应该被设置为 FirewallD 的富规则。这个包在 fail2ban-0.11.1-6 版本时从 ipset 方式切换到了富规则方式，所以如果你的 fail2ban 安装时间较早，它可能还在尝试使用 ipset 方式，这种方式使用的是传统的 iptables，不是很可靠。

#### FirewallD 配置

##### 被动还是主动？

有两种策略可以分开或一起使用：**被动**地将单个 IP 地址或**主动**地根据来源国将子网永久列入黑名单。

对于被动方式，一旦 fail2ban 运行了一段时间，最好再运行 `sudo fail2ban-client status sshd` 来看看有哪些坏蛋。很可能会有很多被禁止的 IP 地址。选择一个，然后试着对它运行 `whois`。在输出结果中可能会有很多有趣的信息，但是对于这个方法来说，只有来源国是重要的。为了保持简单，让我们过滤掉除了国家以外的所有信息。

在这个例子中，我们将使用一些著名的域名：

```
$ whois google.com | grep -i country
Registrant Country: US
Admin Country: US
Tech Country: US

```

```
$ whois rpmfusion.org | grep -i country
Registrant Country: FR

```

```
$ whois aliexpress.com | grep -i country
Registrant Country: CN

```

使用 `grep -i` 的原因是为了使 `grep` 不区分大小写，而大多数条目都使用的是 “Country”，而有些条目则是全小写的 “country”，所以这种方法无论如何都能匹配。

现在知道了尝试入侵的来源国，问题是，“是否有来自这个国家的人有合法的理由连接到这台计算机？”如果答案是否定的，那么封锁整个国家应该是可以接受的。

从功能上看，主动式方法它与被动式方法没有太大区别，然而，来自有些国家的入侵企图是非常普遍的。如果你的系统既不放在这些国家里，也没有任何源自这些国家的客户，那么为什么不现在就把它们加入黑名单而是等待呢？（LCTT 译注：我的经验是，动辄以国家的范畴而列入黑名单有些过于武断。建议可以将该 IP 所属的 WHOIS 网段放入到黑名单，因为这些网段往往具有相同的使用性质，如都用于用户接入或 IDC 托管，其安全状况也大致相同，因此，如果有来自该网段的某个 IP 的恶意尝试，可以预期该网段内的其它 IP 也可能被利用来做这样的尝试。）

##### 黑名单脚本和配置

那么如何做到这一点呢？用 FirewallD ipset。我开发了下面的脚本来尽可能地自动化这个过程：

```
#!/bin/bash
# Based on the below article
# https://www.linode.com/community/questions/11143/top-tip-firewalld-and-ipset-country-blacklist

# Source the blacklisted countries from the configuration file
. /etc/blacklist-by-country

# Create a temporary working directory
ipdeny_tmp_dir=$(mktemp -d -t blacklist-XXXXXXXXXX)
pushd $ipdeny_tmp_dir

# Download the latest network addresses by country file
curl -LO http://www.ipdeny.com/ipblocks/data/countries/all-zones.tar.gz
tar xf all-zones.tar.gz

# For updates, remove the ipset blacklist and recreate
if firewall-cmd -q --zone=drop --query-source=ipset:blacklist; then
    firewall-cmd -q --permanent --delete-ipset=blacklist
fi

# Create the ipset blacklist which accepts both IP addresses and networks
firewall-cmd -q --permanent --new-ipset=blacklist --type=hash:net \
    --option=family=inet --option=hashsize=4096 --option=maxelem=200000 \
    --set-description="An ipset list of networks or ips to be dropped."

# Add the address ranges by country per ipdeny.com to the blacklist
for country in $countries; do
    firewall-cmd -q --permanent --ipset=blacklist \
        --add-entries-from-file=./$country.zone && \
        echo "Added $country to blacklist ipset."
done

# Block individual IPs if the configuration file exists and is not empty
if [ -s "/etc/blacklist-by-ip" ]; then
    echo "Adding IPs blacklists."
    firewall-cmd -q --permanent --ipset=blacklist \
        --add-entries-from-file=/etc/blacklist-by-ip && \
        echo "Added IPs to blacklist ipset."
fi

# Add the blacklist ipset to the drop zone if not already setup
if firewall-cmd -q --zone=drop --query-source=ipset:blacklist; then
    echo "Blacklist already in firewalld drop zone."
else
    echo "Adding ipset blacklist to firewalld drop zone."
    firewall-cmd --permanent --zone=drop --add-source=ipset:blacklist
fi

firewall-cmd -q --reload

popd
rm -rf $ipdeny_tmp_dir

```

这个应该安装到 `/usr/local/sbin`，不要忘了让它可执行！

```
$ sudo chmod +x /usr/local/sbin/firewalld-blacklist

```

然后创建一个配置文件 `/etc/blacklist-by-country`：

```
# Which countries should be blocked?
# Use the two letter designation separated by a space.
countries=""

```

而另一个配置文件 `/etc/blacklist-by-ip`，每行只有一个 IP，没有任何额外的格式化。

在这个例子中，从 ipdeny 的区文件中随机选择了 10 个国家：

```
# ls | shuf -n 10 | sed "s/\.zone//g" | tr '\n' ' '
nl ee ie pk is sv na om gp bn

```

现在只要在配置文件中加入至少一个国家，就可以运行了！

```
$ sudo firewalld-blacklist
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   142  100   142    0     0   1014      0 --:--:-- --:--:-- --:--:--  1014
100  662k  100  662k    0     0   989k      0 --:--:-- --:--:-- --:--:--  989k
Added nl to blacklist ipset.
Added ee to blacklist ipset.
Added ie to blacklist ipset.
Added pk to blacklist ipset.
Added is to blacklist ipset.
Added sv to blacklist ipset.
Added na to blacklist ipset.
Added om to blacklist ipset.
Added gp to blacklist ipset.
Added bn to blacklist ipset.
Adding ipset blacklist to firewalld drop zone.
success

```

要验证 FirewallD 黑名单是否成功，请检查 `drop` 区和 `blacklist` ipset。

```
$ sudo firewall-cmd --info-zone=drop
drop (active)
  target: DROP
  icmp-block-inversion: no
  interfaces:
  sources: ipset:blacklist
  services:
  ports:
  protocols:
  masquerade: no
  forward-ports:
  source-ports:
  icmp-blocks:
  rich rules:

$ sudo firewall-cmd --info-ipset=blacklist | less
blacklist
  type: hash:net
  options: family=inet hashsize=4096 maxelem=200000
  entries:

```

第二条命令将输出所有的子网，这些子网是基于被封杀的国家而添加的，可能会相当长。

### 那么现在我该怎么做？

虽然在开始的时候，监控的频率会比较高，但随着时间的推移，入侵尝试的次数应该会随着黑名单的增加而减少。那么目标应该是维护而不是主动监控。

为此，我创建了一个 SystemD 服务文件和定时器，这样每月都会刷新由 ipdeny 维护的每个国家的子网。事实上，这里讨论的所有内容都可以从我的 [pagure.io](https://pagure.io/firewalld-blacklist) 项目中下载。

是不是很高兴你看完了整篇文章？现在只要把服务文件和定时器下载到 `/etc/systemd/system/`，并启用定时器就行了：

```
$ sudo systemctl daemon-reload
$ sudo systemctl enable --now firewalld-blacklist.timer

```

---

via: <https://fedoramagazine.org/protect-your-system-with-fail2ban-and-firewalld-blacklists/>

作者：[hobbes1069](https://fedoramagazine.org/author/hobbes1069/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出


如何解密 Linux 版本信息

Summary: 显示和解释有关 Linux 版本的信息比看起来要复杂一些。

显示和解释有关 Linux 版本的信息比看起来要复杂一些。

# 如何解密 Linux 版本信息

>
> 显示和解释有关 Linux 版本的信息比看起来要复杂一些。
>
>
>

<img src="content_image/album_202007_15_133043wh4c83s5iezdj414.jpg" alt="" title="">

与引用一个简单的版本号不同，识别 Linux 版本有很多种方法。即使只是快速查看一下 `uname` 命令的输出，也可以告诉你一些信息。这些信息是什么，它告诉你什么？

在本文中，我们将认真研究 `uname` 命令的输出以及其他一些命令和文件提供的版本说明。

### 使用 uname

每当在 Linux 系统终端窗口中执行命令 `uname -a` 时，都会显示很多信息。那是因为这个小小的 `a` 告诉 `uname` 命令你想查看该命令能提供的*全部*输出。结果显示的内容将告诉你许多有关该系统的各种信息。实际上，显示的每一块信息都会告诉你一些关于系统的不同信息。

例如，`uname -a` 输出看起来像这样：

```
$ uname -a
Linux dragonfly 5.4.0-37-generic #41-Ubuntu SMP Wed Jun 3 18:57:02 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux

```

尽管这可能不太重要，但你可以使用一个按适当的顺序包含 `uname` 所有选项来显示相同的信息：

```
$ uname -snmrvpio
Linux dragonfly 5.4.0-37-generic #41-Ubuntu SMP Wed Jun 3 18:57:02 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux

```

要将这一长串信息分解为单独的块，可以使用类似这样的 `for` 循环来遍历每个选项：

```
$ for option in s n m r v p i o; do echo -n "$option: "; uname -$option; done
s: Linux
n: dragonfly
m: x86_64
r: 5.4.0-37-generic
v: #41-Ubuntu SMP Wed Jun 3 18:57:02 UTC 2020
p: x86_64
i: x86_64
o: GNU/Linux

```

该循环显示了该选项提供了哪些信息。`uname` 手册页提供了每个选项的描述。以下是清单：

* Linux –- 内核名称（选项 `s`）
* dragonfly –- 节点名（选项 `n`）
* x86\_64 –- 机器硬件名（选项 `m`）
* 5.4.0-37-generic –- 内核发布版本（选项 `r`）
* #41-Ubuntu SMP Wed Jun 3 18:57:02 UTC 2020 -- 内核版本（选项 `v`）
* x86\_64 –- 处理器（选项 `p`）
* x86\_64 –- 硬件平台（选项 `i`）
* GNU/Linux –- 操作系统（选项 `o`）

要更深入地研究显示的信息，请认真查看显示的内核发行数据。第四行中的 `5.4.0-37` 不仅仅是一串任意数字。每个数字都很重要。

* `5` 表示内核版本
* `4` 表示主要版本
* `0` 表示次要版本
* `37` 表示最新补丁

此外，在上面的循环中输出的第 5 行（内核版本）中的 `#41` 表示此发布版本已编译 41 次。

如果你只想显示所有信息中的一项，那么单个选项可能很有用。例如，命令 `uname -n` 可以仅告诉你系统名称，而 `uname -r` 仅可以告诉你内核发布版本。在盘点服务器或构建脚本时，这些和其他选项可能很有用。

在 Red Hat 系统时，`uname -a` 命令将提供相同种类的信息。这是一个例子：

```
$ uname -a
Linux fruitfly 4.18.0-107.el8.x86_64 #1 SMP Fri Jun 14 13:46:34 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux

```

### 发行版信息

如果你需要了解运行的发行版是什么，那么 `uname` 的输出不会对你有太大帮助。毕竟，内核版本与发行版不同。关于这个信息，你可以在 Ubuntu 和其他基于 Debian 的系统上使用 `lsb_release -r` 命令，而在 Red Hat 上可以显示 `/etc/redhat-release` 文件的内容。

对于 Debian 系统：

```
$ lsb_release -r
Release: 20.04

```

对于 Red Hat 及相关系统：

```
$ cat /etc/redhat-release
Red Hat Enterprise Linux release 8.1 Beta (Ootpa)

```

### 使用 /proc/version

`/proc/version` 文件还可以提供有关 Linux 版本的信息。该文件中提供的信息与 `uname -a` 输出有很多共同点。以下是例子。

在 Ubuntu 上：

```
$ cat /proc/version
Linux version 5.4.0-37-generic (buildd@lcy01-amd64-001) (gcc version 9.3.0 (Ubuntu 9.3.0-10ubuntu2)) #41-Ubuntu SMP Wed Jun 3 18:57:02 UTC 2020

```

在 RedHat 上：

```
$ cat /proc/version
Linux version 4.18.0-107.el8.x86_64 (mockbuild@x86-vm-09.build.eng.bos.redhat.com) (gcc version 8.3.1 20190507 (Red Hat 8.3.1-4) (GCC)) #1 SMP Fri Jun 14 13:46:34 UTC 2019

```

### 总结

Linux 系统提供了很多关于内核和发行版安装的信息。你只需要知道在哪里或如何寻找并理解它的含义。

---

via: <https://www.networkworld.com/article/3565432/how-to-decipher-linux-release-info.html>

作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出