title
stringlengths 5
75
| author
stringlengths 0
48
| fromurl
stringlengths 0
185
| summary
stringlengths 4
460
| pic
stringlengths 32
70
| largepic
stringlengths 0
69
| titlepic
bool 2
classes | thumb
bool 2
classes | islctt
bool 2
classes | selector
stringclasses 14
values | translator
stringlengths 0
45
| reviewer
stringclasses 27
values | editorchoice
bool 2
classes | tags
list | category
stringclasses 20
values | count
dict | comments_data
list | related
list | excerpt
stringlengths 4
460
| date
timestamp[s] | updated
timestamp[s] | id
int64 1
16.6k
| permalink
stringlengths 17
21
| content
stringlengths 116
82.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Adobe Photoshop 的 4 种自由开源替代品
|
Ankush Das
|
https://itsfoss.com/open-source-photoshop-alternatives/
|
想寻找免费的 Photoshop 替代品？这里有一些最好的自由开源软件，你可以用它们来代替 Adobe Photoshop。
|
/data/attachment/album/201910/17/233850adhmddd1d2dxnkxf.png.thumb.jpg
|
/data/attachment/album/201910/17/233850adhmddd1d2dxnkxf.png
| true | false | true |
lujun9972
|
algzjh
|
wxy
| false |
[
"GIMP",
"Photoshop"
] |
分享
|
{
"viewnum": 17079,
"commentnum": 2,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "124.64.18.133",
"message": "Photoshop的替代品当然是下一个版本的Photoshop啊?",
"username": "来自北京的 Chrome 78.0|Windows 10 用户",
"date": "2019-10-18T09:15:54"
},
{
"postip": "175.102.15.232",
"message": "Inkscape 也算？要说替代，Inkscape 也是替代 illustrator 吧？",
"username": "绿色圣光 [Firefox 69.0|Windows 10]",
"date": "2019-10-18T18:16:30"
}
] |
[] |
想寻找免费的 Photoshop 替代品？这里有一些最好的自由开源软件，你可以用它们来代替 Adobe Photoshop。
| 2019-10-17T23:37:00 | 2019-10-17T23:37:00 | 11,474 |
/article-11474-1.html
|
>
> 想寻找免费的 Photoshop 替代品？这里有一些最好的自由开源软件，你可以用它们来代替 Adobe Photoshop。
>
>
>
Adobe Photoshop 是一个可用于 Windows 和 macOS 的高级图像编辑和设计工具。毫无疑问，几乎每个人都知道它。其十分受欢迎。在 Linux 上，你可以在虚拟机中使用 Windows 或[通过 Wine](https://itsfoss.com/install-latest-wine/) 来使用 Photoshop，但这并不是一种理想的体验。
一般来说，我们没有太多可以替代 Adobe Photoshop 的选项。然而，在本文中，我们将提到一些在 Linux 上可用的最佳的开源 Photoshop 替代品（也支持跨平台）。
请注意 Photoshop 不仅仅是一个图片编辑器。摄影师、数码艺术家、专业编辑使用它用于各种用途。此处的替代软件可能不具备 Photoshop 的所有功能，但你可以将它们用于在 Photoshop 中完成的各种任务。
### 适用于 Linux、Windows 和 macOS 的 Adobe Photoshop 的开源替代品
最初，我想只关注 Linux 中的 Photoshop 替代品，但为什么要把这个列表局限于 Linux 呢？其他操作系统用户也可使用开源软件。
**如果你正在使用 Linux，则所有提到的软件都应该可以在你的发行版的存储库中找到。你可以使用软件中心或包管理器进行安装。**
对于其他平台，请查看官方项目网站以获取安装文件。
*该列表没有特定的排名顺序*
#### 1、GIMP：真正的 Photoshop 替代品
主要特点：
* 可定制的界面
* 数字级修饰
* 照片增强（使用变换工具）
* 支持广泛的硬件（压敏平板、音乐数字接口等）
* 几乎支持所有主要的图像文件
* 支持图层管理
可用平台：Linux、Windows 和 macOS
[GIMP](https://www.gimp.org/) 是我处理任何事情的必备工具，无论任务多么基础/高级。也许，这是你在 Linux 下最接近 Photoshop 的替代品。除此之外，它还是一个开源和免费的解决方案，适合希望在 Linux 上创作伟大作品的艺术家。
它具有任何类型的图像处理所必需的所有功能。当然，还有图层管理支持。根据你的经验水平，利用率会有所不同。因此，如果你想充分利用它，则应阅读 [文档](https://www.gimp.org/docs/) 并遵循 [官方教程](https://www.gimp.org/tutorials/)。
#### 2、Krita
主要特点：
* 支持图层管理
* 转换工具
* 丰富的笔刷/绘图工具
可用平台：Linux、Windows 和 macOS
[Krita](https://krita.org/) 是一个令人印象深刻的开源的数字绘画工具。图层管理支持和转换工具的存在使它成为 Photoshop 的基本编辑任务的替代品之一。
如果你喜欢素描/绘图，这将对你很有帮助。
#### 3、Darktable
主要特点：
* RAW 图像显影
* 支持多种图像格式
* 多个带有混合运算符的图像操作模块
可用平台：Linux、Windows 和 macOS
[Darktable](https://www.darktable.org/) 是一个由摄影师制作的开源摄影工作流应用程序。它可以让你在数据库中管理你的数码底片。从你的收藏中，显影 RAW 格式的图像并使用可用的工具对其进行增强。
从基本的图像编辑工具到支持混合运算符的多个图像模块，你将在探索中发现许多。
#### 4、Inkscape
主要特点：
* 创建对象的工具（最适合绘图/素描）
* 支持图层管理
* 用于图像处理的转换工具
* 颜色选择器（RGB、HSL、CMYK、色轮、CMS）
* 支持所有主要文件格式
可用平台：Linux、Windows 和 macOS
[Inkscape](https://inkscape.org/) 是一个非常流行的开源矢量图形编辑器，许多专业人士都使用它。它提供了灵活的设计工具，可帮助你创作漂亮的艺术作品。从技术上说，它是 Adobe Illustrator 的直接替代品，但它也提供了一些技巧，可以帮助你将其作为 Photoshop 的替代品。
与 GIMP 的官方资源类似，你可以利用 [Inkscape 的教程](https://inkscape.org/learn/) 来最大程度地利用它。
### 在你看来，真正的 Photoshop 替代品是什么？
很难提供与 Adobe Photoshop 完全相同的功能。然而，如果你遵循官方文档和资源，则可以使用上述 Photoshop 替代品做很多很棒的事情。
Adobe 提供了一系列的图形工具，并且我们有 [整个 Adobe 创意套件的开源替代方案](https://itsfoss.com/adobe-alternatives-linux/)。 你也可以去看看。
你觉得我们在此提到的 Photoshop 替代品怎么样？你是否知道任何值得提及的更好的替代方案？请在下面的评论中告诉我们。
---
via: <https://itsfoss.com/open-source-photoshop-alternatives/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[algzjh](https://github.com/algzjh) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 sshuttle 构建一个穷人的虚拟专网
|
Paul W. Frields
|
https://fedoramagazine.org/use-sshuttle-to-build-a-poor-mans-vpn/
|
试试 sshuttle，它可以通过 SSH 访问来设置快速简易的虚拟专网。
|
/data/attachment/album/201910/18/210615fx29ppjtycecfa99.jpg.thumb.jpg
|
/data/attachment/album/201910/18/210615fx29ppjtycecfa99.jpg
| true | false | true |
geekpi
| false |
[
"VPN"
] |
技术
|
{
"viewnum": 7445,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "218.6.135.169",
"message": "很棒，救急很有效",
"username": "来自四川雅安的 Firefox 92.0|GNU/Linux 用户",
"date": "2021-10-07T17:22:52"
}
] |
[] |
试试 sshuttle，它可以通过 SSH 访问来设置快速简易的虚拟专网。
| 2019-10-18T23:50:00 | 2019-10-18T23:50:00 | 11,476 |
/article-11476-1.html
|
如今，企业网络经常使用“虚拟专用网络”[来保证员工通信安全](https://en.wikipedia.org/wiki/Virtual_private_network)。但是，使用的协议有时会降低性能。如果你可以使用 SSH 连接远程主机，那么你可以设置端口转发。但这可能会很痛苦，尤其是在你需要与该网络上的许多主机一起使用的情况下。试试 `sshuttle`，它可以通过 SSH 访问来设置快速简易的虚拟专网。请继续阅读以获取有关如何使用它的更多信息。
`sshuttle` 正是针对上述情况而设计的。远程端的唯一要求是主机必须有可用的 Python。这是因为 `sshuttle` 会构造并运行一些 Python 代码来帮助传输数据。
### 安装 sshuttle
`sshuttle` 被打包在官方仓库中，因此很容易安装。打开一个终端，并[使用 sudo](https://fedoramagazine.org/howto-use-sudo/) 来运行以下命令：
```
$ sudo dnf install sshuttle
```
安装后，你可以在手册页中找到相关信息：
```
$ man sshuttle
```
### 设置虚拟专网
最简单的情况就是将所有流量转发到远程网络。这不一定是一个疯狂的想法，尤其是如果你不在自己家里这样的受信任的本地网络中。将 `-r` 选项与 SSH 用户名和远程主机名一起使用：
```
$ sshuttle -r username@remotehost 0.0.0.0/0
```
但是，你可能希望将该虚拟专网限制为特定子网，而不是所有网络流量。（有关子网的完整讨论超出了本文的范围，但是你可以在[维基百科](https://en.wikipedia.org/wiki/Subnetwork)上阅读更多内容。）假设你的办公室内部使用了预留的 A 类子网 10.0.0.0 和预留的 B 类子网 172.16.0.0。上面的命令变为：
```
$ sshuttle -r username@remotehost 10.0.0.0/8 172.16.0.0/16
```
这非常适合通过 IP 地址访问远程网络的主机。但是，如果你的办公室是一个拥有大量主机的大型网络，该怎么办？名称可能更方便，甚至是必须的。不用担心，`sshuttle` 还可以使用 `–dns` 选项转发 DNS 查询：
```
$ sshuttle --dns -r username@remotehost 10.0.0.0/8 172.16.0.0/16
```
要使 `sshuttle` 以守护进程方式运行，请加上 `-D` 选项。它会以 syslog 兼容的日志格式发送到 systemd 日志中。
根据本地和远程系统的功能，可以将 `sshuttle` 用于基于 IPv6 的虚拟专网。如果需要，你还可以设置配置文件并将其与系统启动集成。如果你想阅读更多有关 `sshuttle` 及其工作方式的信息，请[查看官方文档](https://sshuttle.readthedocs.io/en/stable/index.html)。要查看代码，请[进入 GitHub 页面](https://github.com/sshuttle/sshuttle)。
*题图由 [Kurt Cotoaga](https://unsplash.com/@kydroon?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) 拍摄并发表在 [Unsplash](https://unsplash.com/s/photos/shuttle?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) 上。*
---
via: <https://fedoramagazine.org/use-sshuttle-to-build-a-poor-mans-vpn/>
作者：[Paul W. Frields](https://fedoramagazine.org/author/pfrields/) 选题：[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/) 荣誉推出
|
||
在 Intel NUC 上安装 Linux
|
Abhishek Prakash
|
https://itsfoss.com/install-linux-on-intel-nuc/
|
在上周，我买了一台 InteL NUC。虽然它是如此之小，但它与成熟的桌面型电脑差别甚小。实际上，大部分的基于 Linux 的微型 PC 都是基于 Intel NUC 构建的。
|
/data/attachment/album/201910/18/221221pw3hbbi3bbbbprr4.jpg.thumb.jpg
|
/data/attachment/album/201910/18/221221pw3hbbi3bbbbprr4.jpg
| true | false | true |
amwps290
| false |
[
"NUC"
] |
技术
|
{
"viewnum": 17167,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.172.45.98",
"message": "巧了 我也是 NUC 用户，并且 用的也是linux发型版，但我用的是 deepin。",
"username": "来自湖北武汉的 Chrome Mobile 62.0|Android 7.1 用户",
"date": "2019-10-19T21:12:20"
}
] |
[
{
"raid": 11485,
"displayorder": 0
}
] |
在上周，我买了一台 InteL NUC。虽然它是如此之小，但它与成熟的桌面型电脑差别甚小。实际上，大部分的基于 Linux 的微型 PC 都是基于 Intel NUC 构建的。
| 2019-10-18T23:52:00 | 2019-10-18T23:52:00 | 11,477 |
/article-11477-1.html
|
在上周，我买了一台 [InteL NUC](https://www.amazon.com/Intel-NUC-Mainstream-Kit-NUC8i3BEH/dp/B07GX4X4PW?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B07GX4X4PW "Intel NUC")。虽然它是如此之小，但它与成熟的桌面型电脑差别甚小。实际上，大部分的[基于 Linux 的微型 PC](https://itsfoss.com/linux-based-mini-pc/) 都是基于 Intel NUC 构建的。
我买了第 8 代 Core i3 处理器的“<ruby> 准系统 <rt> barebone </rt></ruby>” NUC。准系统意味着该设备没有 RAM、没有硬盘，显然也没有操作系统。我添加了一个 [Crucial 的 8 GB 内存条](https://www.amazon.com/Crucial-Single-PC4-19200-SODIMM-260-Pin/dp/B01BIWKP58?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B01BIWKP58 "8GB RAM from Crucial")（大约 33 美元）和一个 [240 GB 的西数的固态硬盘](https://www.amazon.com/Western-Digital-240GB-Internal-WDS240G1G0B/dp/B01M9B2VB7?SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B01M9B2VB7 "240 GB Western Digital SSD")（大约 45 美元）。
现在，我已经有了一台不到 400 美元的电脑。因为我已经有了一个电脑屏幕和键鼠套装，所以我没有把它们计算在内。
我买这个 Intel NUC 的主要原因就是我想在实体机上测试各种各样的 Linux 发行版。我已经有一个 [树莓派 4](https://itsfoss.com/raspberry-pi-4/) 设备作为一个入门级的桌面系统，但它是一个 [ARM](https://en.wikipedia.org/wiki/ARM_architecture) 设备，因此，只有少数 Linux 发行版可用于树莓派上。（LCTT 译注：新发布的 Ubuntu 19.10 支持树莓派 4B）
*这个文章里的亚马逊链接是（原文的）受益连接。请参阅我们的[受益政策](https://itsfoss.com/affiliate-policy/)。*
### 在 NUC 上安装 Linux
现在我准备安装 Ubuntu 18.04 长期支持版，因为我现在就有这个系统的安装文件。你也可以按照这个教程安装其他的发行版。在最重要的分区之前，前边的步骤都大致相同。
#### 第一步：创建一个 USB 启动盘
你可以在 Ubuntu 官网下载它的安装文件。使用另一个电脑去[创建一个 USB 启动盘](https://itsfoss.com/create-live-usb-of-ubuntu-in-windows/)。你可以使用像 [Rufus](https://rufus.ie/) 和 [Etcher](https://www.balena.io/etcher/) 这样的软件。在 Ubuntu上，你可以使用默认的启动盘创建工具。
#### 第二步：确认启动顺序是正确的
将你的 USB 启动盘插入到你的电脑并开机。一旦你看到 “Intel NUC” 字样出现在你的屏幕上，快速的按下 `F2` 键进入到 BIOS 设置中。
在这里，只是确认一下你的第一启动项是你的 USB 设备。如果不是，切换启动顺序。
如果你修改了一些选项，按 `F10` 键保存退出，否则直接按下 `ESC` 键退出 BIOS 设置。
#### 第三步：正确分区，安装 Linux
现在当机器重启的时候，你就可以看到熟悉的 Grub 界面，可以让你试用或者安装 Ubuntu。现在我们选择安装它。
开始的几个安装步骤非常简单，选择键盘的布局，是否连接网络还有一些其他简单的设置。
你可能会使用常规安装，默认情况下会安装一些有用的应用程序。
接下来的是要注意的部分。你有两种选择：
* “<ruby> 擦除磁盘并安装 Ubuntu <rt> Erase disk and install Ubuntu </rt></ruby>”：最简单的选项，它将在整个磁盘上安装 Ubuntu。如果你只想在 Intel NUC 上使用一个操作系统，请选择此选项，Ubuntu 将负责剩余的工作。
* “<ruby> 其他选项 <rt> Something else </rt></ruby>”：这是一个控制所有选择的高级选项。就我而言，我想在同一 SSD 上安装多个 Linux 发行版。因此，我选择了此高级选项。
**如果你选择了“<ruby> 擦除磁盘并安装 Ubuntu <rt> Erase disk and install Ubuntu </rt></ruby>”，点击“<ruby> 继续 <rt> Continue </rt></ruby>”，直接跳到第四步，**
如果你选择了高级选项，请按照下面剩下的部分进行操作。
选择固态硬盘，然后点击“<ruby> 新建分区表 <rt> New Partition Table </rt></ruby>”。
它会给你显示一个警告。直接点击“<ruby> 继续 <rt> Continue </rt></ruby>”。
现在你就可以看到你 SSD 磁盘里的空闲空间。我的想法是为 EFI bootloader 创建一个 EFI 系统分区。一个根（`/`）分区，一个主目录（`/home`）分区。这里我并没有创建[交换分区](https://itsfoss.com/swap-size/)。Ubuntu 会根据自己的需要来创建交换分区。我也可以通过[创建新的交换文件](https://itsfoss.com/create-swap-file-linux/)来扩展交换分区。
我将在磁盘上保留近 200 GB 的可用空间，以便可以在此处安装其他 Linux 发行版。你可以将其全部用于主目录分区。保留单独的根分区和主目录分区可以在你需要重新安装系统时帮你保存里面的数据。
选择可用空间，然后单击加号以添加分区。
一般来说，100MB 足够 EFI 的使用，但是某些发行版可能需要更多空间，因此我要使用 500MB 的 EFI 分区。
接下来，我将使用 20GB 的根分区。如果你只使用一个发行版，则可以随意地将其增加到 40GB。
根目录（`/`）是系统文件存放的地方。你的程序缓存和你安装的程序将会有一些文件放在这个目录下边。我建议你可以阅读一下 [Linux 文件系统层次结构](https://linuxhandbook.com/linux-directory-structure/)来了解更多相关内容。
填入分区的大小，选择 Ext4 文件系统，选择 `/` 作为挂载点。
接下来是创建一个主目录分区，我再说一下，如果你仅仅想使用一个 Linux 发行版。那就把剩余的空间都使用完吧。为主目录分区选择一个合适的大小。
主目录是你个人的文件，比如文档、图片、音乐、下载和一些其他的文件存储的地方。
既然你创建好了 EFI 分区、根分区、主目录分区，那你就可以点击“<ruby> 现在安装 <rt> Install Now </rt></ruby>”按钮安装系统了。
它将会提示你新的改变将会被写入到磁盘，点击“<ruby> 继续 <rt> Continue </rt></ruby>”。
#### 第四步：安装 Ubuntu
事情到了这就非常明了了。现在选择你的分区或者以后选择也可以。
接下来，输入你的用户名、主机名以及密码。
看 7-8 分钟的幻灯片就可以安装完成了。
一旦安装完成，你就可以重新启动了。
当你重启的时候，你必须要移除你的 USB 设备，否则你将会再次进入安装系统的界面。
这就是在 Intel NUC 设备上安装 Linux 所需要做的一切。坦白说，你可以在其他任何系统上使用相同的过程。
### Intel NUC 和 Linux 在一起：如何使用它？
我非常喜欢 Intel NUC。它不占用太多的桌面空间，而且有足够的能力去取代传统的桌面型电脑。你可以将它的内存升级到 32GB。你也可以安装两个 SSD 硬盘。总之，它提供了一些配置和升级范围。
如果你想购买一个桌面型的电脑，我非常推荐你购买使用 [Intel NUC](https://www.amazon.com/Intel-NUC-Mainstream-Kit-NUC8i3BEH/dp/B07GX4X4PW?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B07GX4X4PW "Intel NUC") 迷你主机。如果你不想自己安装系统，那么你可以购买一个[基于 Linux 的已经安装好的系统迷你主机](https://itsfoss.com/linux-based-mini-pc/)。
你是否已经有了一个 Intel NUC？有一些什么相关的经验？你有什么相关的意见与我们分享吗？可以在下面评论。
---
via: <https://itsfoss.com/install-linux-on-intel-nuc/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
什么是 Java 构造器？
|
Seth Kenlon
|
https://opensource.com/article/19/6/what-java-constructor
|
构造器是编程的强大组件。使用它们来释放 Java 的全部潜力。
|
/data/attachment/album/201910/18/230523hdx7sy804xdtxybb.jpg.thumb.jpg
|
/data/attachment/album/201910/18/230523hdx7sy804xdtxybb.jpg
| true | false | false |
laingke
| false |
[
"Java"
] |
软件开发
|
{
"viewnum": 3370,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
构造器是编程的强大组件。使用它们来释放 Java 的全部潜力。
| 2019-10-18T23:55:00 | 2019-10-18T23:55:00 | 11,478 |
/article-11478-1.html
|
>
> 构造器是编程的强大组件。使用它们来释放 Java 的全部潜力。
>
>
>
在开源、跨平台编程领域，Java 无疑（？）是无可争议的重量级语言。尽管有许多[伟大的跨平台](https://opensource.com/resources/python)[框架](https://opensource.com/article/17/4/pyqt-versus-wxpython)，但很少有像 [Java](https://opensource.com/resources/java) 那样统一和直接的。
当然，Java 也是一种非常复杂的语言，具有自己的微妙之处和惯例。Java 中与<ruby> 构造器 <rt> constructor </rt></ruby>有关的最常见问题之一是：它们是什么，它们的作用是什么？
简而言之：构造器是在 Java 中创建新<ruby> 对象 <rt> object </rt></ruby>时执行的操作。当 Java 应用程序创建一个你编写的类的实例时，它将检查构造器。如果（该类）存在构造器，则 Java 在创建实例时将运行构造器中的代码。这几句话中包含了大量的技术术语，但是当你看到它的实际应用时就会更加清楚，所以请确保你已经[安装了 Java](https://openjdk.java.net/install/index.html) 并准备好进行演示。
### 没有使用构造器的开发日常
如果你正在编写 Java 代码，那么你已经在使用构造器了，即使你可能不知道它。Java 中的所有类都有一个构造器，因为即使你没有创建构造器，Java 也会在编译代码时为你生成一个。但是，为了进行演示，请忽略 Java 提供的隐藏构造器（因为默认构造器不添加任何额外的功能），并观察没有显式构造器的情况。
假设你正在编写一个简单的 Java 掷骰子应用程序，因为你想为游戏生成一个伪随机数。
首先，你可以创建骰子类来表示一个骰子。你玩了很久[《龙与地下城》](https://opensource.com/article/19/5/free-rpg-day)，所以你决定创建一个 20 面的骰子。在这个示例代码中，变量 `dice` 是整数 20，表示可能的最大掷骰数（一个 20 边骰子的掷骰数不能超过 20）。变量 `roll` 是最终的随机数的占位符，`rand` 用作随机数种子。
```
import java.util.Random;
public class DiceRoller {
private int dice = 20;
private int roll;
private Random rand = new Random();
```
接下来，在 `DiceRoller` 类中创建一个函数，以执行计算机模拟模子滚动所必须采取的步骤：从 `rand` 中获取一个整数并将其分配给 `roll`变量，考虑到 Java 从 0 开始计数但 20 面的骰子没有 0 值的情况，`roll` 再加 1 ，然后打印结果。
```
import java.util.Random;
public class DiceRoller {
private int dice = 20;
private int roll;
private Random rand = new Random();
```
最后，产生 `DiceRoller` 类的实例并调用其关键函数 `Roller`：
```
// main loop
public static void main (String[] args) {
System.out.printf("You rolled a ");
DiceRoller App = new DiceRoller();
App.Roller();
}
}
```
只要你安装了 Java 开发环境（如 [OpenJDK](https://openjdk.java.net/)），你就可以在终端上运行你的应用程序：
```
$ java dice.java
You rolled a 12
```
在本例中，没有显式构造器。这是一个非常有效和合法的 Java 应用程序，但是它有一点局限性。例如，如果你把游戏《龙与地下城》放在一边，晚上去玩一些《快艇骰子》，你将需要六面骰子。在这个简单的例子中，更改代码不会有太多的麻烦，但是在复杂的代码中这不是一个现实的选择。解决这个问题的一种方法是使用构造器。
### 构造函数的作用
这个示例项目中的 `DiceRoller` 类表示一个虚拟骰子工厂：当它被调用时，它创建一个虚拟骰子，然后进行“滚动”。然而，通过编写一个自定义构造器，你可以让掷骰子的应用程序询问你希望模拟哪种类型的骰子。
大部分代码都是一样的，除了构造器接受一个表示面数的数字参数。这个数字还不存在，但稍后将创建它。
```
import java.util.Random;
public class DiceRoller {
private int dice;
private int roll;
private Random rand = new Random();
// constructor
public DiceRoller(int sides) {
dice = sides;
}
```
模拟滚动的函数保持不变：
```
public void Roller() {
roll = rand.nextInt(dice);
roll += 1;
System.out.println (roll);
}
```
代码的主要部分提供运行应用程序时提供的任何参数。这的确会是一个复杂的应用程序，你需要仔细解析参数并检查意外结果，但对于这个例子，唯一的预防措施是将参数字符串转换成整数类型。
```
public static void main (String[] args) {
System.out.printf("You rolled a ");
DiceRoller App = new DiceRoller( Integer.parseInt(args[0]) );
App.Roller();
}
```
启动这个应用程序，并提供你希望骰子具有的面数：
```
$ java dice.java 20
You rolled a 10
$ java dice.java 6
You rolled a 2
$ java dice.java 100
You rolled a 44
```
构造器已接受你的输入，因此在创建类实例时，会将 `sides` 变量设置为用户指定的任何数字。
构造器是编程的功能强大的组件。练习用它们来解开了 Java 的全部潜力。
---
via: <https://opensource.com/article/19/6/what-java-constructor>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[laingke](https://github.com/laingke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Ubuntu 上安装和配置 PostgreSQL
|
Sergiu
|
https://itsfoss.com/install-postgresql-ubuntu/
|
本教程中，你将学习如何在 Ubuntu Linux 上安装和使用开源数据库 PostgreSQL。
|
/data/attachment/album/201910/19/225041hsuuqxi6qq2mx6j8.png.thumb.jpg
|
/data/attachment/album/201910/19/225041hsuuqxi6qq2mx6j8.png
| true | false | false |
lnrCoder
| false |
[
"PostgreSQL"
] |
技术
|
{
"viewnum": 35916,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "183.131.162.101",
"message": "写的好！非常清晰",
"username": "来自浙江温州的 Chrome 87.0|Mac 11.0 用户",
"date": "2020-12-22T17:56:30"
},
{
"postip": "113.137.58.77",
"message": "PostgreSQL linux 安装指导:<br />\r\nRPM 软件包安装 <a href=\"https://doc.rockdata.net/zh-cn/installation/redhat/\" target=\"_blank\">https://doc.rockdata.net/zh-cn/installation/redhat/</a><br />\r\nDEB 软件包安装 <a href=\"https://doc.rockdata.net/zh-cn/installation/debian/\" target=\"_blank\">https://doc.rockdata.net/zh-cn/installation/debian/</a><br />\r\n二进制软件包安装 <a href=\"https://doc.rockdata.net/zh-cn/installation/binary/\" target=\"_blank\">https://doc.rockdata.net/zh-cn/installation/binary/</a>",
"username": "来自陕西咸阳的 Chrome 113.0|Windows 10 用户",
"date": "2023-05-06T10:10:55"
}
] |
[] |
本教程中，你将学习如何在 Ubuntu Linux 上安装和使用开源数据库 PostgreSQL。
| 2019-10-19T23:50:00 | 2019-10-19T23:50:00 | 11,480 |
/article-11480-1.html
|
>
> 本教程中，你将学习如何在 Ubuntu Linux 上安装和使用开源数据库 PostgreSQL。
>
>
>
[PostgreSQL](https://www.postgresql.org/) (又名 Postgres) 是一个功能强大的自由开源的关系型数据库管理系统 ([RDBMS](https://www.codecademy.com/articles/what-is-rdbms-sql)) ，其在可靠性、稳定性、性能方面获得了业内极高的声誉。它旨在处理各种规模的任务。它是跨平台的，而且是 [macOS Server](https://www.apple.com/in/macos/server/) 的默认数据库。
如果你喜欢简单易用的 SQL 数据库管理器，那么 PostgreSQL 将是一个正确的选择。PostgreSQL 对标准的 SQL 兼容的同时提供了额外的附加特性，同时还可以被用户大量扩展，用户可以添加数据类型、函数并执行更多的操作。
之前我曾论述过 [在 Ubuntu 上安装 MySQL](https://itsfoss.com/install-mysql-ubuntu/)。在本文中，我将向你展示如何安装和配置 PostgreSQL，以便你随时可以使用它来满足你的任何需求。
### 在 Ubuntu 上安装 PostgreSQL
PostgreSQL 可以从 Ubuntu 主存储库中获取。然而，和许多其它开发工具一样，它可能不是最新版本。
首先在终端中使用 [apt 命令](https://itsfoss.com/apt-command-guide/) 检查 [Ubuntu 存储库](https://itsfoss.com/ubuntu-repositories/) 中可用的 PostgreSQL 版本：
```
apt show postgresql
```
在我的 Ubuntu 18.04 中，它显示 PostgreSQL 的可用版本是 10（10+190 表示版本 10）而 PostgreSQL 版本 11 已经发布。
```
Package: postgresql
Version: 10+190
Priority: optional
Section: database
Source: postgresql-common (190)
Origin: Ubuntu
```
根据这些信息，你可以自主决定是安装 Ubuntu 提供的版本还是还是获取 PostgreSQL 的最新发行版。
我将向你介绍这两种方法：
#### 方法一：通过 Ubuntu 存储库安装 PostgreSQL
在终端中，使用以下命令安装 PostgreSQL：
```
sudo apt update
sudo apt install postgresql postgresql-contrib
```
根据提示输入你的密码，依据于你的网速情况，程序将在几秒到几分钟安装完成。说到这一点，随时检查 [Ubuntu 中的各种网络带宽](https://itsfoss.com/network-speed-monitor-linux/)。
>
> 什么是 postgresql-contrib?
>
>
> postgresql-contrib 或者说 contrib 包，包含一些不属于 PostgreSQL 核心包的实用工具和功能。在大多数情况下，最好将 contrib 包与 PostgreSQL 核心一起安装。
>
>
>
#### 方法二：在 Ubuntu 中安装最新版本的 PostgreSQL 11
要安装 PostgreSQL 11, 你需要在 `sources.list` 中添加官方 PostgreSQL 存储库和证书，然后从那里安装它。
不用担心，这并不复杂。 只需按照以下步骤。
首先添加 GPG 密钥：
```
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
```
现在，使用以下命令添加存储库。如果你使用的是 Linux Mint，则必须手动替换你的 Mint 所基于的 Ubuntu 版本号：
```
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ `lsb_release -cs`-pgdg main" >> /etc/apt/sources.list.d/pgdg.list'
```
现在一切就绪。使用以下命令安装 PostgreSQL：
```
sudo apt update
sudo apt install postgresql postgresql-contrib
```
>
> PostgreSQL GUI 应用程序
>
>
> 你也可以安装用于管理 PostgreSQL 数据库的 GUI 应用程序（pgAdmin）：
>
>
> `sudo apt install pgadmin4`
>
>
>
### PostgreSQL 配置
你可以通过执行以下命令来检查 PostgreSQL 是否正在运行：
```
service postgresql status
```
通过 `service` 命令，你可以启动、关闭或重启 `postgresql`。输入 `service postgresql` 并按回车将列出所有选项。现在，登录该用户。
默认情况下，PostgreSQL 会创建一个拥有所权限的特殊用户 `postgres`。要实际使用 PostgreSQL，你必须先登录该账户：
```
sudo su postgres
```
你的提示符会更改为类似于以下的内容：
```
postgres@ubuntu-VirtualBox:/home/ubuntu$
```
现在，使用 `psql` 来启动 PostgreSQL Shell：
```
psql
```
你应该会看到如下提示符：
```
postgress=#
```
你可以输入 `\q` 以退出，输入 `\?` 获取帮助。
要查看现有的所有表，输入如下命令：
```
\l
```
输出内容类似于下图所示（单击 `q` 键退出该视图）：
使用 `\du` 命令，你可以查看 PostgreSQL 用户：
你可以使用以下命令更改任何用户（包括 `postgres`）的密码：
```
ALTER USER postgres WITH PASSWORD 'my_password';
```
**注意：**将 `postgres` 替换为你要更改的用户名，`my_password` 替换为所需要的密码。另外，不要忘记每条命令后面的 `;`（分号）。
建议你另外创建一个用户（不建议使用默认的 `postgres` 用户）。为此，请使用以下命令：
```
CREATE USER my_user WITH PASSWORD 'my_password';
```
运行 `\du`，你将看到该用户，但是，`my_user` 用户没有任何的属性。来让我们给它添加超级用户权限：
```
ALTER USER my_user WITH SUPERUSER;
```
你可以使用以下命令删除用户：
```
DROP USER my_user;
```
要使用其他用户登录，使用 `\q` 命令退出，然后使用以下命令登录：
```
psql -U my_user
```
你可以使用 `-d` 参数直接连接数据库：
```
psql -U my_user -d my_db
```
你可以使用其他已存在的用户调用 PostgreSQL。例如，我使用 `ubuntu`。要登录，从终端执行以下命名：
```
psql -U ubuntu -d postgres
```
**注意：**你必须指定一个数据库（默认情况下，它将尝试将你连接到与登录的用户名相同的数据库）。
如果遇到如下错误：
```
psql: FATAL: Peer authentication failed for user "my_user"
```
确保以正确的用户身份登录，并使用管理员权限编辑 `/etc/postgresql/11/main/pg_hba.conf`：
```
sudo vim /etc/postgresql/11/main/pg_hba.conf
```
**注意：**用你的版本替换 `11`（例如 `10`）。
对如下所示的一行进行替换：
```
local all postgres peer
```
替换为：
```
local all postgres md5
```
然后重启 PostgreSQL：
```
sudo service postgresql restart
```
使用 PostgreSQL 与使用其他 SQL 类型的数据库相同。由于本文旨在帮助你进行初步的设置，因此不涉及具体的命令。不过，这里有个 [非常有用的要点](https://gist.github.com/Kartones/dd3ff5ec5ea238d4c546) 可供参考! 另外, 手册（`man psql`）和 [文档](https://www.postgresql.org/docs/manuals/) 也非常有用。
### 总结
阅读本文有望指导你完成在 Ubuntu 系统上安装和准备 PostgreSQL 的过程。如果你不熟悉 SQL，你应该阅读 [基本的 SQL 命令](https://itsfoss.com/basic-sql-commands/)。
如果你有任何问题或疑惑，请随时在评论部分提出。
---
via: <https://itsfoss.com/install-postgresql-ubuntu/>
作者：[Sergiu](https://itsfoss.com/author/sergiu/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lnrCoder](https://github.com/lnrCoder) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 中的十大开源视频播放器
|
Stella Aldridge
|
https://opensourceforu.com/2019/10/top-10-open-source-video-players-for-linux/
|
选择合适的视频播放器有助于确保你获得最佳的观看体验，并为你提供创建视频网站的工具。你甚至可以根据个人喜好自定义正在观看的视频。
|
/data/attachment/album/201910/19/232315urlvflauoefulfrv.jpg.thumb.jpg
|
/data/attachment/album/201910/19/232315urlvflauoefulfrv.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"播放器",
"视频"
] |
分享
|
{
"viewnum": 28197,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
选择合适的视频播放器有助于确保你获得最佳的观看体验，并为你提供创建视频网站的工具。你甚至可以根据个人喜好自定义正在观看的视频。
| 2019-10-19T23:22:00 | 2019-10-19T23:22:00 | 11,481 |
/article-11481-1.html
|
>
> 选择合适的视频播放器有助于确保你获得最佳的观看体验，并为你提供[创建视频网站](https://www.ning.com/create-video-website/)的工具。你甚至可以根据个人喜好自定义正在观看的视频。
>
>
>
因此，为了帮助你挑选适合你需求的最佳播放器，我们列出了 Linux 中的十大开源播放器。
让我们来看看：
### 1、XBMC – Kodi 媒体中心
这是一个灵活的跨平台播放器，核心使用 C++ 编写，并提供 Python 脚本作为附加组件。使用 Kodi 的好处包括：
* 提供超过 69 种语言版本
* 用户可以从网络和本地存储播放音频、视频和媒体播放文件
* 可与 JeOS 一起作为应用套件用于智能电视和机顶盒等设备
* 有很多不错的附加组件，如视频和音频流插件、主题、屏幕保护程序等
* 它支持多种格式，如 MPEG-1、2、4、RealVideo、HVC、HEVC 等
### 2、VLC 媒体播放器
由于该播放器在一系列操作系统上具有令人印象深刻的功能和可用性，它出现在列表上是理所当然的。它使用 C、C++ 和 Objective C 编写，用户无需使用插件，这要归功于它对解码库的广泛支持。VLC 媒体播放器的优势包括：
* 在 Linux 上支持 DVD 播放器
* 能够播放 .iso 文件
* 能够播放高清录制的 D-VHS 磁带
* 可以直接从 U 盘或外部驱动器运行
* API 支持和浏览器支持（通过插件）
### 3、Bomi（CMPlayer）
这个灵活和强大的播放器被许多普通用户选择，它的优势有：
* 易于使用的图形用户界面（GUI）
* 令人印象深刻的播放能力
* 可以恢复播放
* 支持字幕，可以渲染多个字幕文件
### 4、Miro 音乐与视频播放器
以前被称为 Democracy Player（DTV），Miro 由<ruby> 参与文化基金会 <rt> Participatory Culture Foundation </rt></ruby>重新开发，是一个不错的跨平台音频视频播放器。令人印象深刻，因为：
* 支持一些高清音频和视频
* 提供超过 40 种语言版本
* 可以播放多种文件格式，例如，QuickTime、WMV、MPEG 文件、AVI、XVID
* 一旦可用，可以自动通知用户并下载视频
### 5、SMPlayer
这个跨平台的媒体播放器，只使用 C++ 的 Qt 库编写，它是一个强大的多功能播放器。我们喜欢它，因为：
* 有多语言选择
* 支持所有默认格式
* 支持 EDL 文件，你可以配置从互联网获取的字幕
* 可从互联网下载的各种皮肤
* 倍速播放
### 6、MPV 播放器
它用 C、Objective-C、Lua 和 Python 编写，免费、易于使用，并且有许多新功能，便于使用。主要加分是：
* 可以编译为一个库，公开客户端 API，从而增强控制
* 允许媒体编码
* 平滑动画
### 7、Deepin Movie
此播放器是开源媒体播放器的一个极好的例子，它有很多优势，包括：
* 通过键盘完成所有播放操作
* 各种格式的视频文件可以通过这个播放器轻松播放
* 流媒体功能能让用户享受许多在线视频资源
### 8、Gnome 视频
以前称为 Totem，这是 Gnome 桌面环境的播放器。
完全用 C 编写，使用 GStreamer 多媒体框架构建，高于 2.7.1 的版本使用 xine 作为后端。它是很棒的，因为：
它支持大量的格式，包括：
* SHOUTcast、SMIL、M3U、Windows 媒体播放器格式等
* 你可以在播放过程中调整灯光设置，如亮度和对比度
* 加载 SubRip 字幕
* 支持从互联网频道（如 Apple）直接播放视频
### 9、Xine 多媒体播放器
我们列表中用 C 编写的另外一个跨平台多媒体播放器。这是一个全能播放器，因为：
* 它支持物理媒体以及视频设备。3gp、MKV、 MOV、Mp4、音频格式
* 网络协议，V4L、DVB 和 PVR 等
* 它可以手动校正音频和视频流的同步
### 10、ExMPlayer
最后但同样重要的一个，ExMPlayer 是一个惊人的、强大的 MPlayer 的 GUI 前端。它的优点包括：
* 可以播放任何媒体格式
* 支持网络流和字幕
* 易于使用的音频转换器
* 高品质的音频提取，而不会影响音质
上面这些视频播放器在 Linux 上工作得很好。我们建议你尝试一下，选择一个最适合你的播放器。
---
via: <https://opensourceforu.com/2019/10/top-10-open-source-video-players-for-linux/>
作者：[Stella Aldridge](https://opensourceforu.com/author/stella-aldridge/) 选题：[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/) 荣誉推出
|
变异测试：如何利用故障？
|
Alex Bunardzic
|
https://opensource.com/article/19/9/mutation-testing-example-tdd
|
使用事先设计好的故障以确保你的代码达到预期的结果，并遵循 .NET xUnit.net 测试框架来进行测试。
|
/data/attachment/album/201910/23/164730vtddtydtktazagnz.jpg.thumb.jpg
|
/data/attachment/album/201910/23/164730vtddtydtktazagnz.jpg
| true | false | true |
lujun9972
|
Morisun029
|
wxy
| false |
[
"TDD",
"变异测试"
] |
软件开发
|
{
"viewnum": 4713,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11468,
"displayorder": 0
},
{
"raid": 11494,
"displayorder": 0
}
] |
使用事先设计好的故障以确保你的代码达到预期的结果，并遵循 .NET xUnit.net 测试框架来进行测试。
| 2019-10-21T07:57:00 | 2019-10-21T07:57:00 | 11,483 |
/article-11483-1.html
|
>
> 使用事先设计好的故障以确保你的代码达到预期的结果，并遵循 .NET xUnit.net 测试框架来进行测试。
>
>
>
[在变异测试是 TDD 的演变](/article-11468-1.html) 一文中，我谈到了迭代的力量。在可度量的测试中，迭代能够保证找到问题的解决方案。在那篇文章中，我们讨论了迭代法帮助确定实现计算给定数字平方根的代码。
我还演示了最有效的方法是找到可衡量的目标或测试，然后以最佳猜测值开始迭代。正如所预期的，第一次测试通常会失败。因此，必须根据可衡量的目标或测试对失败的代码进行完善。根据运行结果，对测试值进行验证或进一步加以完善。
在此模型中，学习获得解决方案的唯一方法是反复失败。这听起来有悖常理，但它确实有效。
按照这种分析，本文探讨了在构建包含某些依赖项的解决方案时使用 DevOps 的最佳方法。第一步是编写一个预期结果失败的用例。
### 依赖性问题是你不能依赖它们
正如<ruby> 迈克尔·尼加德 <rt> Michael Nygard </rt></ruby>在《[没有终结状态的架构](https://www.infoq.com/presentations/Architecture-Without-an-End-State/)》中机智的表示的那样，依赖问题是一个很大的话题，最好留到另一篇文章中讨论。在这里，你将会看到依赖项给项目带来的一些潜在问题，以及如何利用测试驱动开发（TDD）来避免这些陷阱。
首先，找到现实生活中的一个挑战，然后看看如何使用 TDD 解决它。
### 谁把猫放出来？
在敏捷开发环境中，通过定义期望结果开始构建解决方案会很有帮助。通常，在 <ruby> <a href="https://www.agilealliance.org/glossary/user-stories"> 用户故事 </a> <rt> user story </rt></ruby> 中描述期望结果：
>
> 我想使用我的家庭自动化系统（HAS）来控制猫何时可以出门，因为我想保证它在夜间的安全。
>
>
>
现在你已经有了一个用户故事，你需要通过提供一些功能要求（即指定验收标准）来对其进行详细说明。 从伪代码中描述的最简单的场景开始：
>
> 场景 1：在夜间关闭猫门
>
>
> * 用时钟监测到了晚上的时间
> * 时钟通知 HAS 系统
> * HAS 关闭支持物联网（IoT）的猫门
>
>
>
### 分解系统
开始构建之前，你需要将正在构建的系统（HAS）进行分解（分解为依赖项）。你必须要做的第一件事是识别任何依赖项（如果幸运的话，你的系统没有依赖项，这将会更容易，但是，这样的系统可以说不是非常有用）。
从上面的简单场景中，你可以看到所需的业务成果（自动控制猫门）取决于对夜间情况监测。这种依赖性取决于时钟。但是时钟是无法区分白天和夜晚的。需要你来提供这种逻辑。
正在构建的系统中的另一个依赖项是能够自动访问猫门并启用或关闭它。该依赖项很可能取决于具有 IoT 功能的猫门提供的 API。
### 依赖管理面临快速失败
为了满足依赖项，我们将构建确定当前时间是白天还是晚上的逻辑。本着 TDD 的精神，我们将从一个小小的失败开始。
有关如何设置此练习所需的开发环境和脚手架的详细说明，请参阅我的[上一篇文章](/article-11468-1.html)。我们将重用相同的 NET 环境和 [xUnit.net](https://xunit.net/) 框架。
接下来，创建一个名为 HAS（“家庭自动化系统”）的新项目，创建一个名为 `UnitTest1.cs` 的文件。在该文件中，编写第一个失败的单元测试。在此单元测试中，描述你的期望结果。例如，当系统运行时，如果时间是晚上 7 点，负责确定是白天还是夜晚的组件将返回值 `Nighttime`。
这是描述期望值的单元测试：
```
using System;
using Xunit;
namespace unittest
{
public class UnitTest1
{
DayOrNightUtility dayOrNightUtility = new DayOrNightUtility();
[Fact]
public void Given7pmReturnNighttime()
{
var expected = "Nighttime";
var actual = dayOrNightUtility.GetDayOrNight();
Assert.Equal(expected, actual);
}
}
}
```
至此，你可能已经熟悉了单元测试的结构。快速复习一下：在此示例中，通过给单元测试一个描述性名称`Given7pmReturnNighttime` 来描述期望结果。然后，在单元测试的主体中，创建一个名为 `expected` 的变量，并为该变量指定期望值（在该示例中，值为 `Nighttime`）。然后，为实际值指定一个 `actual`（在组件或服务处理一天中的时间之后可用）。
最后，通过断言期望值和实际值是否相等来检查是否满足期望结果：`Assert.Equal(expected, actual)`。
你还可以在上面的列表中看到名为 `dayOrNightUtility` 的组件或服务。该模块能够接收消息`GetDayOrNight`，并且返回 `string` 类型的值。
同样，本着 TDD 的精神，描述的组件或服务还尚未构建（仅为了后面说明在此进行描述）。构建这些是由所描述的期望结果来驱动的。
在 `app` 文件夹中创建一个新文件，并将其命名为 `DayOrNightUtility.cs`。将以下 C＃ 代码添加到该文件中并保存：
```
using System;
namespace app {
public class DayOrNightUtility {
public string GetDayOrNight() {
string dayOrNight = "Undetermined";
return dayOrNight;
}
}
}
```
现在转到命令行，将目录更改为 `unittests` 文件夹，然后运行：
```
[Xunit.net 00:00:02.33] unittest.UnitTest1.Given7pmReturnNighttime [FAIL]
Failed unittest.UnitTest1.Given7pmReturnNighttime
[...]
```
恭喜，你已经完成了第一个失败的单元测试。单元测试的期望结果是 `DayOrNightUtility` 方法返回字符串 `Nighttime`，但相反，它返回是 `Undetermined`。
### 修复失败的单元测试
修复失败的测试的一种快速而粗略的方法是将值 `Undetermined` 替换为值 `Nighttime` 并保存更改：
```
using System;
namespace app {
public class DayOrNightUtility {
public string GetDayOrNight() {
string dayOrNight = "Nighttime";
return dayOrNight;
}
}
}
```
现在运行，成功了。
```
Starting test execution, please wait...
Total tests: 1. Passed: 1. Failed: 0. Skipped: 0.
Test Run Successful.
Test execution time: 2.6470 Seconds
```
但是，对值进行硬编码基本上是在作弊，最好为 `DayOrNightUtility` 方法赋予一些智能。修改 `GetDayOrNight` 方法以包括一些时间计算逻辑：
```
public string GetDayOrNight() {
string dayOrNight = "Daylight";
DateTime time = new DateTime();
if(time.Hour < 7) {
dayOrNight = "Nighttime";
}
return dayOrNight;
}
```
该方法现在从系统获取当前时间，并与 `Hour` 比较，查看其是否小于上午 7 点。如果小于，则处理逻辑将 `dayOrNight` 字符串值从 `Daylight` 转换为 `Nighttime`。现在，单元测试通过。
### 测试驱动解决方案的开始
现在，我们已经开始了基本的单元测试，并为我们的时间依赖项提供了可行的解决方案。后面还有更多的测试案例需要执行。
在下一篇文章中，我将演示如何对白天时间进行测试以及如何在整个过程中利用故障。
---
via: <https://opensource.com/article/19/9/mutation-testing-example-tdd>
作者：[Alex Bunardzic](https://opensource.com/users/alex-bunardzic) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Morisun029](https://github.com/Morisun029) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
英特尔 NUC 迷你 PC 的基本配件
|
Abhishek Prakash
|
https://itsfoss.com/intel-nuc-essential-accessories/
|
如果你正在考虑购买英特尔 NUC，你需要买一些配件，以便开始使用它。
|
/data/attachment/album/201910/20/224650me0qoiqjeiysqqph.jpg.thumb.jpg
|
/data/attachment/album/201910/20/224650me0qoiqjeiysqqph.jpg
| true | false | true |
geekpi
| false |
[
"NUC"
] |
技术
|
{
"viewnum": 6295,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11477,
"displayorder": 0
}
] |
如果你正在考虑购买英特尔 NUC，你需要买一些配件，以便开始使用它。
| 2019-10-21T07:35:00 | 2019-10-21T07:35:00 | 11,485 |
/article-11485-1.html
|
几周前，我买了一台 [英特尔 NUC 迷你 PC](https://www.amazon.com/Intel-NUC-Mainstream-Kit-NUC8i3BEH/dp/B07GX4X4PW?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B07GX4X4PW "barebone Intel NUC mini PC")。我[在上面安装了 Linux](/article-11477-1.html)，我非常喜欢它。这个小巧的无风扇机器取代了台式机那庞大的 CPU。
英特尔 NUC 通常采用准系统形式，这意味着它没有任何内存、硬盘，也显然没有操作系统。许多[基于 Linux 的微型 PC](https://itsfoss.com/linux-based-mini-pc/) 定制化英特尔 NUC 并添加磁盘、RAM 和操作系统将它出售给终端用户。
不用说，它不像大多数其他台式机那样带有键盘、鼠标或屏幕。
[英特尔 NUC](https://www.intel.in/content/www/in/en/products/boards-kits/nuc.html) 是一款出色的设备，如果你要购买台式机，我强烈建议你购买它。如果你正在考虑购买英特尔 NUC，你需要买一些配件，以便开始使用它。
### 基本的英特尔 NUC 配件
\*文章中的 Amazon 链接是（原文的）受益链接。请阅读我们的[受益政策](https://itsfoss.com/affiliate-policy/)。
#### 外围设备：显示器、键盘和鼠标
这很容易想到。你需要有屏幕、键盘和鼠标才能使用计算机。你需要一台有 HDMI 连接的显示器和一个 USB 或无线键盘鼠标。如果你已经有了这些东西，那你可以继续。
如果你正在寻求建议，我建议购买 LG IPS LED 显示器。我有两台 22 英寸的型号，我对它提供的清晰视觉效果感到满意。
这些显示器有一个简单的固定支架。如果要使显示器可以上下移动并纵向旋转，请尝试使用 [HP EliteDisplay 显示器](https://www.amazon.com/HP-EliteDisplay-21-5-Inch-1FH45AA-ABA/dp/B075L4VKQF?SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B075L4VKQF "HP EliteDisplay monitors")。
我在多屏设置中同时连接了三台显示器。一台显示器连接到指定的 HDMI 端口。两台显示器通过 [Club 3D 的 Thunderbolt 转 HDMI 分配器](https://www.amazon.com/Club3D-CSV-1546-USB-C-Multi-Monitor-Splitter/dp/B06Y2FX13G?SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B06Y2FX13G "thunderbolt to HDMI splitter from Club 3D")连接到 Thunderbolt 端口。
你也可以选择超宽显示器。我对此没有亲身经历。
#### 内存
英特尔 NUC 有两个内存插槽，最多可支持 32GB 内存。由于我的是 i3 核心处理器，因此我选择了 [Crucial 的 8GB DDR4 内存](https://www.amazon.com/Crucial-Single-PC4-19200-SODIMM-260-Pin/dp/B01BIWKP58?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B01BIWKP58 "8GB DDR4 RAM from Crucial")，价格约为 $33。
8 GB 内存在大多数情况下都没问题，但是如果你的是 i7 核心处理器，那么可以选择 [16GB 内存](https://www.amazon.com/Crucial-Single-PC4-19200-SODIMM-260-Pin/dp/B019FRBHZ0?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B019FRBHZ0 "16 GB RAM")，价格约为 $67。你可以加两条，以获得最大 32GB。选择全在于你。
#### 硬盘（重要）
英特尔 NUC 同时支持 2.5 英寸驱动器和 M.2 SSD，因此你可以同时使用两者以获得更多存储空间。
2.5 英寸插槽可同时容纳 SSD 和 HDD。我强烈建议选择 SSD，因为它比 HDD 快得多。[480GB 2.5 英寸](https://www.amazon.com/Green-480GB-Internal-SSD-WDS480G2G0A/dp/B01M3POPK3?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B01M3POPK3 "480 GB 2.5")的价格是 $60。我认为这是一个合理的价格。
2.5 英寸驱动器的标准 SATA 口速度为 6 Gb/秒。根据你是否选择 NVMe SSD，M.2 插槽可能会更快。 NVMe（非易失性内存主机控制器接口规范）SSD 的速度比普通 SSD（也称为 SATA SSD）快 4 倍。但是它们可能也比 SATA M2 SSD 贵一些。
当购买 M.2 SSD 时，请检查产品图片。无论是 NVMe 还是 SATA SSD，都应在磁盘本身的图片中提到。你可以考虑使用[经济的三星 EVO NVMe M.2 SSD](https://www.amazon.com/Samsung-970-EVO-500GB-MZ-V7E500BW/dp/B07BN4NJ2J?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B07BN4NJ2J "Samsung EVO is a cost effective NVMe M.2 SSD")。
M.2 插槽和 2.5 英寸插槽中的 SATA SSD 具有相同的速度。这就是为什么如果你不想选择昂贵的 NVMe SSD，建议你选择 2.5 英寸 SATA SSD，并保留 M.2 插槽供以后升级。
#### 交流电源线
当我拿到 NUC 时，为惊讶地发现，尽管它有电源适配器，但它并没有插头。
正如一些读者指出的那样，你可能有完整的电源线。这取决于你的地理区域和供应商。因此，请检查产品说明和用户评论，以验证其是否具有完整的电源线。
#### 其他配套配件
你需要使用 HDMI 线缆连接显示器。如果你要购买新显示器，通常应会有一根线缆。
如果要使用 M.2 插槽，那么可能需要螺丝刀。英特尔 NUC 是一款出色的设备，你只需用手旋转四个脚即可拧开底部面板。你必须打开设备才能放置内存和磁盘。
NUC 还有防盗孔，可与防盗绳一起使用。在业务环境中，建议使用防盗绳保护计算机安全。购买[防盗绳几美元](https://www.amazon.com/Kensington-Combination-Laptops-Devices-K64673AM/dp/B005J7Y99W?psc=1&SubscriptionId=AKIAJ3N3QBK3ZHDGU54Q&tag=chmod7mediate-20&linkCode=xm2&camp=2025&creative=165953&creativeASIN=B005J7Y99W "few dollars in the security cable")便可节省数百美元。
### 你使用什么配件？
这些就是我在使用和建议使用的英特尔 NUC 配件。你呢？如果你有一台 NUC，你会使用哪些配件并推荐给其他 NUC 用户？
---
via: <https://itsfoss.com/intel-nuc-essential-accessories/>
作者：[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/) 荣誉推出
|
||
Manjaro 18.1（KDE）安装图解
|
Pradeep Kumar
|
https://www.linuxtechi.com/install-manjaro-18-1-kde-edition-screenshots/
|
在 Manjaro 18.0（Illyria）发布一年之际，该团队发布了他们的下一个重要版本，即 Manjaro 18.1，代号为 “Juhraya”。
|
/data/attachment/album/201910/21/230843z6w3weimv3o3gw70.jpg.thumb.jpg
|
/data/attachment/album/201910/21/230843z6w3weimv3o3gw70.jpg
| true | false | false |
wxy
| false |
[
"Manjaro"
] |
技术
|
{
"viewnum": 30850,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "119.86.34.177",
"message": "hhh",
"username": "来自重庆的 Chrome 79.0|Windows 7 用户",
"date": "2020-05-04T18:53:51"
}
] |
[] |
在 Manjaro 18.0（Illyria）发布一年之际，该团队发布了他们的下一个重要版本，即 Manjaro 18.1，代号为 “Juhraya”。
| 2019-10-22T07:00:00 | 2019-10-22T07:00:00 | 11,487 |
/article-11487-1.html
|
在 Manjaro 18.0（Illyria）发布一年之际，该团队发布了他们的下一个重要版本，即 Manjaro 18.1，代号为 “Juhraya”。该团队还发布了一份官方声明，称 Juhraya 包含了许多改进和错误修复。
### Manjaro 18.1 中的新功能
以下列出了 Manjaro 18.1 中的一些新功能和增强功能：
* 可以在 LibreOffice 或 Free Office 之间选择
* Xfce 版的新 Matcha 主题
* 在 KDE 版本中重新设计了消息传递系统
* 使用 bhau 工具支持 Snap 和 FlatPak 软件包
### 最小系统需求
* 1 GB RAM
* 1 GHz 处理器
* 大约 30 GB 硬盘空间
* 互联网连接
* 启动介质（USB/DVD）
### 安装 Manjaro 18.1（KDE 版）的分步指南
要在系统中开始安装 Manjaro 18.1（KDE 版），请遵循以下步骤：
#### 步骤 1) 下载 Manjaro 18.1 ISO
在安装之前，你需要从位于 [这里](https://manjaro.org/download/official/kde/) 的官方下载页面下载 Manjaro 18.1 的最新副本。由于我们这里介绍的是 KDE 版本，因此我们选择 KDE 版本。但是对于所有桌面环境（包括 Xfce、KDE 和 Gnome 版本），安装过程都是相同的。
#### 步骤 2) 创建 USB 启动盘
从 Manjaro 下载页面成功下载 ISO 文件后，就可以创建 USB 磁盘了。将下载的 ISO 文件复制到 USB 磁盘中，然后创建可引导磁盘。确保将你的引导设置更改为使用 USB 引导，并重新启动系统。
#### 步骤 3) Manjaro Live 版安装环境
系统重新启动时，它将自动检测到 USB 驱动器，并开始启动进入 Manjaro Live 版安装屏幕。
接下来，使用箭头键选择 “<ruby> 启动：Manjaro x86_64 kde <rt> Boot: Manjaro x86_64 kde </rt></ruby>”，然后按回车键以启动 Manjaro 安装程序。
#### 安装 4) 选择启动安装程序
接下来，将启动 Manjaro 安装程序，如果你已连接到互联网，Manjaro 将自动检测你的位置和时区。单击 “<ruby> 启动安装程序 <rt> Launch Installer </rt></ruby>”，开始在系统中安装 Manjaro 18.1 KDE 版本。
#### 步骤 5) 选择语言
接下来，安装程序将带你选择你的首选语言。
选择你想要的语言，然后单击“<ruby> 下一步 <rt> Next </rt></ruby>”。
#### 步骤 6) 选择时区和区域
在下一个屏幕中，选择所需的时区和区域，然后单击“<ruby> 下一步 <rt> Next </rt></ruby>”继续。
#### 步骤 7) 选择键盘布局
在下一个屏幕中，选择你喜欢的键盘布局，然后单击“<ruby> 下一步 <rt> Next </rt></ruby>”继续。
#### 步骤 8) 选择分区类型
这是安装过程中非常关键的一步。 它将允许你选择分区方式：
* 擦除磁盘
* 手动分区
* 并存安装
* 替换分区
如果在 VM（虚拟机）中安装 Manjaro 18.1，则将看不到最后两个选项。
如果你不熟悉 Manjaro Linux，那么我建议你使用第一个选项（<ruby> 擦除磁盘 <rt> Erase Disk </rt></ruby>），它将为你自动创建所需的分区。如果要创建自定义分区，则选择第二个选项“<ruby> 手动分区 <rt> Manual Partitioning </rt></ruby>”，顾名思义，它将允许我们创建自己的自定义分区。
在本教程中，我将通过选择“<ruby> 手动分区 <rt> Manual Partitioning </rt></ruby>”选项来创建自定义分区：
选择第二个选项，然后单击“<ruby> 下一步 <rt> Next </rt></ruby>”继续。
如我们所见，我有 40 GB 硬盘，因此我将在其上创建以下分区，
* `/boot` – 2GB（ext4）
* `/` – 10 GB（ext4）
* `/home` – 22 GB（ext4）
* `/opt` – 4 GB（ext4）
* <ruby> 交换分区 <rt> Swap </rt></ruby> – 2 GB
当我们在上方窗口中单击“<ruby> 下一步 <rt> Next </rt></ruby>”时，将显示以下屏幕，选择“<ruby> 新建分区表 <rt> new partition table </rt></ruby>”：
点击“<ruby> 确定 <rt> OK </rt></ruby>”。
现在选择可用空间，然后单击“<ruby> 创建 <rt> create </rt></ruby>”以将第一个分区设置为大小为 2 GB 的 `/boot`，
单击“<ruby> 确定 <rt> OK </rt></ruby>”以继续操作，在下一个窗口中再次选择可用空间，然后单击“<ruby> 创建 <rt> create </rt></ruby>”以将第二个分区设置为 `/`，大小为 10 GB：
同样，将下一个分区创建为大小为 22 GB 的 `/home`：
到目前为止，我们已经创建了三个分区作为主分区，现在创建下一个分区作为扩展分区：
单击“<ruby> 确定 <rt> OK </rt></ruby>”以继续。
创建大小分别为 5 GB 和 2 GB 的 `/opt` 和交换分区作为逻辑分区。
完成所有分区的创建后，单击“<ruby> 下一步 <rt> Next </rt></ruby>”：
#### 步骤 9) 提供用户信息
在下一个屏幕中，你需要提供用户信息，包括你的姓名、用户名、密码、计算机名等：
提供所有信息后，单击“<ruby> 下一步 <rt> Next </rt></ruby>”继续安装。
在下一个屏幕中，系统将提示你选择办公套件，因此请做出适合你的选择：
单击“<ruby> 下一步 <rt> Next </rt></ruby>”以继续。
#### 步骤 10) 摘要信息
在完成实际安装之前，安装程序将向你显示你选择的所有详细信息，包括语言、时区、键盘布局和分区信息等。单击“<ruby> 安装 <rt> Install </rt></ruby>”以继续进行安装过程。
#### 步骤 11) 进行安装
现在，实际的安装过程开始，一旦完成，请重新启动系统以登录到 Manjaro 18.1 KDE 版：
#### 步骤 12) 安装成功后登录
重新启动后，我们将看到以下登录屏幕，使用我们在安装过程中创建的用户凭据登录：
点击“<ruby> 登录 <rt> Login </rt></ruby>”。
就是这样！你已经在系统中成功安装了 Manjaro 18.1 KDE 版，并探索了所有令人兴奋的功能。请在下面的评论部分中发表你的反馈和建议。
---
via: <https://www.linuxtechi.com/install-manjaro-18-1-kde-edition-screenshots/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[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 中国徽标征集活动公开评选
|
老王
|
本次公开投票将在微信投票上进行，敬请来自其他平台的读者和爱好者移步至微信投票。
|
/data/attachment/album/201910/22/142227vq0gjj00qabbo09z.jpg.thumb.jpg
|
/data/attachment/album/201910/22/142227vq0gjj00qabbo09z.jpg
| true | false | false | false |
[
"Linux中国",
"徽标"
] |
新闻
|
{
"viewnum": 11748,
"commentnum": 6,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "59.41.206.251",
"message": "个人觉得微信投票不太公平呢。很多人根本不会点开Github看详情就投了，而且还可以发给好友投票。而且分成两个多选也很不科学，即使下面乘了4/30也不公平。希望最后还是看委员会结果吧，微信投票就图一乐惹(*￣︶￣)",
"username": "来自广东广州的 Chrome 68.0|Android 5.0 用户",
"date": "2019-10-24T20:33:47"
},
{
"postip": "59.41.206.251",
"message": "吐槽一下感觉有些作品感觉是用画图软件画来凑数的吧(*￣︶￣)而且有些设计风格我实在不能苟同。我比较欣赏的设计风格大家可以参考一下MangoDB的官网，是开源的项目呢",
"username": "来自广东广州的 Chrome 68.0|Android 5.0 用户",
"date": "2019-10-24T20:45:00"
},
{
"postip": "117.159.17.195",
"message": "4号，16号个人感觉喜欢。",
"username": "来自河南焦作的 Chrome 77.0|GNU/Linux 用户",
"date": "2019-10-30T16:51:21"
},
{
"postip": "113.246.152.149",
"message": "28号作品",
"username": "来自湖南长沙的 Firefox 70.0|GNU/Linux 用户",
"date": "2019-10-30T23:08:16"
},
{
"postip": "60.28.138.11",
"message": "把重设logo的精力放在改进网页代码上不好吗？像这样字体不能放大否则就出窗口的网站真的已经很少了～",
"username": "来自天津的 Firefox 70.0|GNU/Linux 用户",
"date": "2019-10-31T11:22:13"
},
{
"postip": "58.247.171.4",
"message": "喜欢4号,简约大气 gif做的也很好",
"username": "来自上海的 Chrome 77.0|Windows 10 用户",
"date": "2019-10-31T14:54:31"
}
] |
[
{
"raid": 11363,
"displayorder": 0
},
{
"raid": 11407,
"displayorder": 1
},
{
"raid": 11524,
"displayorder": 0
}
] |
本次公开投票将在微信投票上进行，敬请来自其他平台的读者和爱好者移步至微信投票。
| 2019-10-22T14:23:00 | 2019-10-22T14:23:00 | 11,488 |
/article-11488-1.html
|
一个月前，我们发起了徽标公开征集活动，这次活动得到了很多成员和爱好者的积极关注，截止至昨天，我们收到了 25 位设计师提交的多份设计投稿。
按照计划，我们将从今天开始，至 10 月 30 日公示投稿，并发起投票活动请大家投票支持。并在投票结果的基础上，由我们的管理委员会做最终裁定（意即，并不会以投票结果作为最终结果，投票结果会作为一个重要的参考因素）。
**本次公开投票将在微信投票上进行，敬请来自其他平台的读者和爱好者移步至微信投票。**
此外，在活动中，一直有声音表示，原本的徽标就挺好，或者原本徽标只需要做适当修改即可。对于这种意见，说实话我是有点吃惊的。不过尊重大家的意见，我决定将原本的徽标也放入评选，如果原本的徽标胜出，那这次的一等奖可能就要空缺了，我们就不会更换徽标（或对原本的徽标做少量修改）。
以下是这次投稿的徽标，
* 按投稿时间列出
* 变体视作同一徽标
* 尺寸裁剪至同一大小（128px），缩放过程中会有精度损失
* 设计思路在此不展示，可访问在 GitHub 上的原始投稿了解
### 徽标投稿
#### 1、原本的徽标
| |
| --- |
| |
#### 2、wxy
| |
| --- |
| |
地址： <https://github.com/LCTT/logo/tree/master/wxy>
#### 3、RedInLinux
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/RedInLinux>
#### 4、1466587594
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/1466587594>
#### 5、tinnx
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/tinnx>
#### 6、alim0x
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/alim0x>
#### 7、flag
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/flag-2>
#### 8、WSJ
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/WSJ>
#### 9、logo0281
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/logo0281>
#### 10、logo0964
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/logo0964>
#### 11、long
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/long>
#### 12、kokialoves
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/kokialoves>
#### 13、hacker
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/hacker>
#### 14、lartpang
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/lartpang>
#### 15、OLC
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/OLC>
#### 16、garywill
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/garywill>
#### 17、lightyisu
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/lightyisu>
#### 18、lightyisu2
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/blob/master/lightyisu2>
#### 19、icekylin-design-1
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/icekylin-design>
#### 20、icekylin-design-2
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/icekylin-design>
#### 21、icekylin-design-3
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/icekylin-design>
#### 22、whsasf\_work
| |
| --- |
| |
| |
地址：<https://github.com/LCTT/logo/tree/master/whsasf_work>
#### 23、whsasf\_work2
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/whsasf_work2>
#### 24、whsasf\_work3
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/whsasf_work3>
#### 25、CodingOctocat
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/CodingOctocat>
#### 26、JUNEN-1
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/JUNEN>
#### 27、JUNEN-2
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/JUNEN>
#### 28、ZIN
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/ZIN>
#### 29、Fine
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/Fine>
#### 30、SmarterC
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/blob/master/SmarterC>
#### 31、water0902
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/tree/master/water0902>
#### 32、logo yk
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/blob/master/logo%20yk>
#### 33、schiway
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/blob/master/schiway>
#### 34、aimeDesign
| |
| --- |
| |
地址：<https://github.com/LCTT/logo/blob/master/aimeDesign>
|
||||
在 Linux 中使用 Bash 脚本删除早于 “X” 天的文件/文件夹
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/bash-script-to-delete-files-folders-older-than-x-days-in-linux/
|
该脚本可防止来自 监控工具 的警报，因为我们会在填满磁盘空间之前删除旧的日志文件。
|
/data/attachment/album/201910/22/150713e1brlrxnowxcxx7d.jpg.thumb.jpg
|
/data/attachment/album/201910/22/150713e1brlrxnowxcxx7d.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"日志",
"删除"
] |
技术
|
{
"viewnum": 7709,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
该脚本可防止来自 监控工具 的警报，因为我们会在填满磁盘空间之前删除旧的日志文件。
| 2019-10-22T15:07:21 | 2019-10-22T15:07:21 | 11,490 |
/article-11490-1.html
|
[磁盘使用率](https://www.2daygeek.com/linux-check-disk-usage-files-and-directories-folders-size-du-command/) 监控工具能够在达到给定阈值时提醒我们。但它们无法自行解决 [磁盘使用率](https://www.2daygeek.com/linux-check-disk-space-usage-df-command/) 问题。需要手动干预才能解决该问题。
如果你想完全自动化此类操作，你会做什么。是的，可以使用 bash 脚本来完成。
该脚本可防止来自 [监控工具](https://www.2daygeek.com/category/monitoring-tools/) 的警报，因为我们会在填满磁盘空间之前删除旧的日志文件。
我们过去做了很多 shell 脚本。如果要查看，请进入下面的链接。
* [如何使用 shell 脚本自动化日常活动？](https://www.2daygeek.com/category/shell-script/)
我在本文中添加了两个 bash 脚本，它们有助于清除旧日志。
### 1）在 Linux 中删除早于 “X” 天的文件夹的 Bash 脚本
我们有一个名为 `/var/log/app/` 的文件夹，其中包含 15 天的日志，我们将删除早于 10 天的文件夹。
```
$ ls -lh /var/log/app/
drwxrw-rw- 3 root root 24K Oct 1 23:52 app_log.01
drwxrw-rw- 3 root root 24K Oct 2 23:52 app_log.02
drwxrw-rw- 3 root root 24K Oct 3 23:52 app_log.03
drwxrw-rw- 3 root root 24K Oct 4 23:52 app_log.04
drwxrw-rw- 3 root root 24K Oct 5 23:52 app_log.05
drwxrw-rw- 3 root root 24K Oct 6 23:54 app_log.06
drwxrw-rw- 3 root root 24K Oct 7 23:53 app_log.07
drwxrw-rw- 3 root root 24K Oct 8 23:51 app_log.08
drwxrw-rw- 3 root root 24K Oct 9 23:52 app_log.09
drwxrw-rw- 3 root root 24K Oct 10 23:52 app_log.10
drwxrw-rw- 3 root root 24K Oct 11 23:52 app_log.11
drwxrw-rw- 3 root root 24K Oct 12 23:52 app_log.12
drwxrw-rw- 3 root root 24K Oct 13 23:52 app_log.13
drwxrw-rw- 3 root root 24K Oct 14 23:52 app_log.14
drwxrw-rw- 3 root root 24K Oct 15 23:52 app_log.15
```
该脚本将删除早于 10 天的文件夹，并通过邮件发送文件夹列表。
你可以根据需要修改 `-mtime X` 的值。另外，请替换你的电子邮箱，而不是用我们的。
```
# /opt/script/delete-old-folders.sh
#!/bin/bash
prev_count=0
fpath=/var/log/app/app_log.*
find $fpath -type d -mtime +10 -exec ls -ltrh {} \; > /tmp/folder.out
find $fpath -type d -mtime +10 -exec rm -rf {} \;
count=$(cat /tmp/folder.out | wc -l)
if [ "$prev_count" -lt "$count" ] ; then
MESSAGE="/tmp/file1.out"
TO="[email protected]"
echo "Application log folders are deleted older than 15 days" >> $MESSAGE
echo "+----------------------------------------------------+" >> $MESSAGE
echo "" >> $MESSAGE
cat /tmp/folder.out | awk '{print $6,$7,$9}' >> $MESSAGE
echo "" >> $MESSAGE
SUBJECT="WARNING: Apache log files are deleted older than 15 days $(date)"
mail -s "$SUBJECT" "$TO" < $MESSAGE
rm $MESSAGE /tmp/folder.out
fi
```
给 `delete-old-folders.sh` 设置可执行权限。
```
# chmod +x /opt/script/delete-old-folders.sh
```
最后添加一个 [cronjob](https://www.2daygeek.com/crontab-cronjob-to-schedule-jobs-in-linux/) 自动化此任务。它于每天早上 7 点运行。
```
# crontab -e
0 7 * * * /bin/bash /opt/script/delete-old-folders.sh
```
你将看到类似下面的输出。
```
Application log folders are deleted older than 20 days
+--------------------------------------------------------+
Oct 11 /var/log/app/app_log.11
Oct 12 /var/log/app/app_log.12
Oct 13 /var/log/app/app_log.13
Oct 14 /var/log/app/app_log.14
Oct 15 /var/log/app/app_log.15
```
### 2）在 Linux 中删除早于 “X” 天的文件的 Bash 脚本
我们有一个名为 `/var/log/apache/` 的文件夹，其中包含15天的日志，我们将删除 10 天前的文件。
以下文章与该主题相关，因此你可能有兴趣阅读。
* [如何在 Linux 中查找和删除早于 “X” 天和 “X” 小时的文件？](https://www.2daygeek.com/how-to-find-and-delete-files-older-than-x-days-and-x-hours-in-linux/)
* [如何在 Linux 中查找最近修改的文件/文件夹](https://www.2daygeek.com/check-find-recently-modified-files-folders-linux/)
* [如何在 Linux 中自动删除或清理 /tmp 文件夹内容？](https://www.2daygeek.com/automatically-delete-clean-up-tmp-directory-folder-contents-in-linux/)
```
# ls -lh /var/log/apache/
-rw-rw-rw- 3 root root 24K Oct 1 23:52 2daygeek_access.01
-rw-rw-rw- 3 root root 24K Oct 2 23:52 2daygeek_access.02
-rw-rw-rw- 3 root root 24K Oct 3 23:52 2daygeek_access.03
-rw-rw-rw- 3 root root 24K Oct 4 23:52 2daygeek_access.04
-rw-rw-rw- 3 root root 24K Oct 5 23:52 2daygeek_access.05
-rw-rw-rw- 3 root root 24K Oct 6 23:54 2daygeek_access.06
-rw-rw-rw- 3 root root 24K Oct 7 23:53 2daygeek_access.07
-rw-rw-rw- 3 root root 24K Oct 8 23:51 2daygeek_access.08
-rw-rw-rw- 3 root root 24K Oct 9 23:52 2daygeek_access.09
-rw-rw-rw- 3 root root 24K Oct 10 23:52 2daygeek_access.10
-rw-rw-rw- 3 root root 24K Oct 11 23:52 2daygeek_access.11
-rw-rw-rw- 3 root root 24K Oct 12 23:52 2daygeek_access.12
-rw-rw-rw- 3 root root 24K Oct 13 23:52 2daygeek_access.13
-rw-rw-rw- 3 root root 24K Oct 14 23:52 2daygeek_access.14
-rw-rw-rw- 3 root root 24K Oct 15 23:52 2daygeek_access.15
```
该脚本将删除 10 天前的文件并通过邮件发送文件夹列表。
你可以根据需要修改 `-mtime X` 的值。另外，请替换你的电子邮箱，而不是用我们的。
```
# /opt/script/delete-old-files.sh
#!/bin/bash
prev_count=0
fpath=/var/log/apache/2daygeek_access.*
find $fpath -type f -mtime +15 -exec ls -ltrd {} \; > /tmp/file.out
find $fpath -type f -mtime +15 -exec rm -rf {} \;
count=$(cat /tmp/file.out | wc -l)
if [ "$prev_count" -lt "$count" ] ; then
MESSAGE="/tmp/file1.out"
TO="[email protected]"
echo "Apache Access log files are deleted older than 20 days" >> $MESSAGE
echo "+--------------------------------------------- +" >> $MESSAGE
echo "" >> $MESSAGE
cat /tmp/file.out | awk '{print $6,$7,$9}' >> $MESSAGE
echo "" >> $MESSAGE
SUBJECT="WARNING: Apache log folders are deleted older than 15 days $(date)"
mail -s "$SUBJECT" "$TO" < $MESSAGE
rm $MESSAGE /tmp/file.out
fi
```
给 `delete-old-files.sh` 设置可执行权限。
```
# chmod +x /opt/script/delete-old-files.sh
```
最后添加一个 [cronjob](https://www.2daygeek.com/crontab-cronjob-to-schedule-jobs-in-linux/) 自动化此任务。它于每天早上 7 点运行。
```
# crontab -e
0 7 * * * /bin/bash /opt/script/delete-old-folders.sh
```
你将看到类似下面的输出。
```
Apache Access log files are deleted older than 20 days
+--------------------------------------------------------+
Oct 11 /var/log/apache/2daygeek_access.11
Oct 12 /var/log/apache/2daygeek_access.12
Oct 13 /var/log/apache/2daygeek_access.13
Oct 14 /var/log/apache/2daygeek_access.14
Oct 15 /var/log/apache/2daygeek_access.15
```
---
via: <https://www.2daygeek.com/bash-script-to-delete-files-folders-older-than-x-days-in-linux/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[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/) 荣誉推出
|
如何在批处理模式下运行 top 命令
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/linux-run-execute-top-command-in-batch-mode/
|
可能已经知道 top 命令的绝大部分操作，除了很少的几个操作，如果我没错的话，批处理模式就是其中之一。
|
/data/attachment/album/201910/22/235420ylswdescv5ddffit.jpg.thumb.jpg
|
/data/attachment/album/201910/22/235420ylswdescv5ddffit.jpg
| true | false | true |
lujun9972
|
way-ww
|
wxy
| false |
[
"top"
] |
技术
|
{
"viewnum": 8189,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "222.212.90.185",
"message": "666",
"username": "来自四川成都的 Chrome 77.0|Windows 10 用户",
"date": "2019-10-23T10:09:25"
}
] |
[] |
可能已经知道 top 命令的绝大部分操作，除了很少的几个操作，如果我没错的话，批处理模式就是其中之一。
| 2019-10-22T23:54:52 | 2019-10-22T23:54:52 | 11,491 |
/article-11491-1.html
|
[top 命令](https://www.2daygeek.com/linux-top-command-linux-system-performance-monitoring-tool/) 是每个人都在使用的用于 [监控 Linux 系统性能](https://www.2daygeek.com/category/system-monitoring/) 的最好的命令。你可能已经知道 `top` 命令的绝大部分操作，除了很少的几个操作，如果我没错的话，批处理模式就是其中之一。
大部分的脚本编写者和开发人员都知道这个，因为这个操作主要就是用来编写脚本。
如果你不了解这个，不用担心，我们将在这里介绍它。
### 什么是 top 命令的批处理模式
批处理模式允许你将 `top` 命令的输出发送至其他程序或者文件中。
在这个模式中，`top` 命令将不会接收输入并且持续运行，直到迭代次数达到你用 `-n` 选项指定的次数为止。
如果你想解决 Linux 服务器上的任何性能问题，你需要正确的 [理解 top 命令的输出](https://www.2daygeek.com/understanding-linux-top-command-output-usage/)。
### 1) 如何在批处理模式下运行 top 命令
默认地，`top` 命令按照 CPU 的使用率来排序输出结果，所以当你在批处理模式中运行以下命令时，它会执行同样的操作并打印前 35 行：
```
# top -bc | head -35
top - 06:41:14 up 8 days, 20:24, 1 user, load average: 0.87, 0.77, 0.81
Tasks: 139 total, 1 running, 136 sleeping, 0 stopped, 2 zombie
%Cpu(s): 0.0 us, 3.2 sy, 0.0 ni, 96.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 3880940 total, 1595932 free, 886736 used, 1398272 buff/cache
KiB Swap: 1048572 total, 514640 free, 533932 used. 2648472 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 191144 2800 1596 S 0.0 0.1 5:43.63 /usr/lib/systemd/systemd --switched-root --system --deserialize 22
2 root 20 0 0 0 0 S 0.0 0.0 0:00.32 [kthreadd]
3 root 20 0 0 0 0 S 0.0 0.0 0:28.10 [ksoftirqd/0]
5 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kworker/0:0H]
7 root rt 0 0 0 0 S 0.0 0.0 0:33.96 [migration/0]
8 root 20 0 0 0 0 S 0.0 0.0 0:00.00 [rcu_bh]
9 root 20 0 0 0 0 S 0.0 0.0 63:05.12 [rcu_sched]
10 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [lru-add-drain]
11 root rt 0 0 0 0 S 0.0 0.0 0:08.79 [watchdog/0]
12 root rt 0 0 0 0 S 0.0 0.0 0:08.82 [watchdog/1]
13 root rt 0 0 0 0 S 0.0 0.0 0:44.27 [migration/1]
14 root 20 0 0 0 0 S 0.0 0.0 1:22.45 [ksoftirqd/1]
16 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kworker/1:0H]
18 root 20 0 0 0 0 S 0.0 0.0 0:00.01 [kdevtmpfs]
19 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [netns]
20 root 20 0 0 0 0 S 0.0 0.0 0:01.35 [khungtaskd]
21 root 0 -20 0 0 0 S 0.0 0.0 0:00.02 [writeback]
22 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kintegrityd]
23 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [bioset]
24 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kblockd]
25 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [md]
26 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [edac-poller]
33 root 20 0 0 0 0 S 0.0 0.0 1:19.07 [kswapd0]
34 root 25 5 0 0 0 S 0.0 0.0 0:00.00 [ksmd]
35 root 39 19 0 0 0 S 0.0 0.0 0:12.80 [khugepaged]
36 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [crypto]
44 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kthrotld]
46 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kmpath_rdacd]
```
### 2) 如何在批处理模式下运行 top 命令并按内存使用率排序结果
在批处理模式中运行以下命令按内存使用率对结果进行排序：
```
# top -bc -o +%MEM | head -n 20
top - 06:42:00 up 8 days, 20:25, 1 user, load average: 0.66, 0.74, 0.80
Tasks: 146 total, 1 running, 145 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 3880940 total, 1422044 free, 1059176 used, 1399720 buff/cache
KiB Swap: 1048572 total, 514640 free, 533932 used. 2475984 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
18105 mysql 20 0 1453900 156096 8816 S 0.0 4.0 2:12.98 /usr/sbin/mysqld --daemonize --pid-file=/var/run/mysqld/mysqld.pid
1841 root 20 0 228980 107036 5360 S 0.0 2.8 0:05.56 /usr/local/cpanel/3rdparty/perl/528/bin/perl -T -w /usr/local/cpanel/3rdparty/bin/spamd --max-children=3 --max-spare=1 --allowed-ips=127.0.0.+
4301 root 20 0 230208 104608 1816 S 0.0 2.7 0:03.77 spamd child
8139 nobody 20 0 257000 27108 3408 S 0.0 0.7 0:00.04 /usr/sbin/httpd -k start
7961 nobody 20 0 256988 26912 3160 S 0.0 0.7 0:00.05 /usr/sbin/httpd -k start
8190 nobody 20 0 256976 26812 3140 S 0.0 0.7 0:00.05 /usr/sbin/httpd -k start
8353 nobody 20 0 256976 26812 3144 S 0.0 0.7 0:00.04 /usr/sbin/httpd -k start
8629 nobody 20 0 256856 26736 3108 S 0.0 0.7 0:00.02 /usr/sbin/httpd -k start
8636 nobody 20 0 256856 26712 3100 S 0.0 0.7 0:00.03 /usr/sbin/httpd -k start
8611 nobody 20 0 256844 25764 2228 S 0.0 0.7 0:00.01 /usr/sbin/httpd -k start
8451 nobody 20 0 256844 25760 2220 S 0.0 0.7 0:00.04 /usr/sbin/httpd -k start
8610 nobody 20 0 256844 25748 2224 S 0.0 0.7 0:00.01 /usr/sbin/httpd -k start
8632 nobody 20 0 256844 25744 2216 S 0.0 0.7 0:00.03 /usr/sbin/httpd -k start
```
上面命令的详细信息：
* `-b`：批处理模式选项
* `-c`：打印运行中的进程的绝对路径
* `-o`：指定进行排序的字段
* `head`：输出文件的第一部分
* `-n`：打印前 n 行
### 3) 如何在批处理模式下运行 top 命令并按照指定的用户进程对结果进行排序
如果你想要按照指定用户进程对结果进行排序请运行以下命令：
```
# top -bc -u mysql | head -n 10
top - 06:44:58 up 8 days, 20:27, 1 user, load average: 0.99, 0.87, 0.84
Tasks: 140 total, 1 running, 137 sleeping, 0 stopped, 2 zombie
%Cpu(s): 13.3 us, 3.3 sy, 0.0 ni, 83.3 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 3880940 total, 1589832 free, 885648 used, 1405460 buff/cache
KiB Swap: 1048572 total, 514640 free, 533932 used. 2649412 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
18105 mysql 20 0 1453900 156888 8816 S 0.0 4.0 2:16.42 /usr/sbin/mysqld --daemonize --pid-file=/var/run/mysqld/mysqld.pid
```
### 4) 如何在批处理模式下运行 top 命令并按照处理时间进行排序
在批处理模式中使用以下 `top` 命令按照处理时间对结果进行排序。这展示了任务从启动以来已使用的总 CPU 时间。
但是如果你想要检查一个进程在 Linux 上运行了多长时间请看接下来的文章：
* [检查 Linux 中进程运行时间的五种方法](https://www.2daygeek.com/how-to-check-how-long-a-process-has-been-running-in-linux/)
```
# top -bc -o TIME+ | head -n 20
top - 06:45:56 up 8 days, 20:28, 1 user, load average: 0.56, 0.77, 0.81
Tasks: 148 total, 1 running, 146 sleeping, 0 stopped, 1 zombie
%Cpu(s): 0.0 us, 3.1 sy, 0.0 ni, 96.9 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 3880940 total, 1378664 free, 1094876 used, 1407400 buff/cache
KiB Swap: 1048572 total, 514640 free, 533932 used. 2440332 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
9 root 20 0 0 0 0 S 0.0 0.0 63:05.70 [rcu_sched]
272 root 20 0 0 0 0 S 0.0 0.0 16:12.13 [xfsaild/vda1]
3882 root 20 0 229832 6212 1220 S 0.0 0.2 9:00.84 /usr/sbin/httpd -k start
1 root 20 0 191144 2800 1596 S 0.0 0.1 5:43.75 /usr/lib/systemd/systemd --switched-root --system --deserialize 22
3761 root 20 0 68784 9820 2048 S 0.0 0.3 5:09.67 tailwatchd
3529 root 20 0 404380 3472 2604 S 0.0 0.1 3:24.98 /usr/sbin/rsyslogd -n
3520 root 20 0 574208 572 164 S 0.0 0.0 3:07.74 /usr/bin/python2 -Es /usr/sbin/tuned -l -P
444 dbus 20 0 58444 1144 612 S 0.0 0.0 2:23.90 /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation
18105 mysql 20 0 1453900 157152 8816 S 0.0 4.0 2:17.29 /usr/sbin/mysqld --daemonize --pid-file=/var/run/mysqld/mysqld.pid
249 root 0 -20 0 0 0 S 0.0 0.0 1:28.83 [kworker/0:1H]
14 root 20 0 0 0 0 S 0.0 0.0 1:22.46 [ksoftirqd/1]
33 root 20 0 0 0 0 S 0.0 0.0 1:19.07 [kswapd0]
342 root 20 0 39472 2940 2752 S 0.0 0.1 1:18.17 /usr/lib/systemd/systemd-journald
```
### 5) 如何在批处理模式下运行 top 命令并将结果保存到文件中
如果出于解决问题的目的，你想要和别人分享 `top` 命令的输出，请使用以下命令重定向输出到文件中：
```
# top -bc | head -35 > top-report.txt
# cat top-report.txt
top - 06:47:11 up 8 days, 20:30, 1 user, load average: 0.67, 0.77, 0.81
Tasks: 133 total, 4 running, 129 sleeping, 0 stopped, 0 zombie
%Cpu(s): 59.4 us, 12.5 sy, 0.0 ni, 28.1 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 3880940 total, 1596268 free, 843284 used, 1441388 buff/cache
KiB Swap: 1048572 total, 514640 free, 533932 used. 2659084 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
9686 daygeekc 20 0 406132 62184 43448 R 94.1 1.6 0:00.34 /opt/cpanel/ea-php56/root/usr/bin/php-cgi
9689 nobody 20 0 256588 24428 1184 S 5.9 0.6 0:00.01 /usr/sbin/httpd -k start
1 root 20 0 191144 2800 1596 S 0.0 0.1 5:43.79 /usr/lib/systemd/systemd --switched-root --system --deserialize 22
2 root 20 0 0 0 0 S 0.0 0.0 0:00.32 [kthreadd]
3 root 20 0 0 0 0 S 0.0 0.0 0:28.11 [ksoftirqd/0]
5 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kworker/0:0H]
7 root rt 0 0 0 0 S 0.0 0.0 0:33.96 [migration/0]
8 root 20 0 0 0 0 S 0.0 0.0 0:00.00 [rcu_bh]
9 root 20 0 0 0 0 R 0.0 0.0 63:05.82 [rcu_sched]
10 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [lru-add-drain]
11 root rt 0 0 0 0 S 0.0 0.0 0:08.79 [watchdog/0]
12 root rt 0 0 0 0 S 0.0 0.0 0:08.82 [watchdog/1]
13 root rt 0 0 0 0 S 0.0 0.0 0:44.28 [migration/1]
14 root 20 0 0 0 0 S 0.0 0.0 1:22.46 [ksoftirqd/1]
16 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kworker/1:0H]
18 root 20 0 0 0 0 S 0.0 0.0 0:00.01 [kdevtmpfs]
19 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [netns]
20 root 20 0 0 0 0 S 0.0 0.0 0:01.35 [khungtaskd]
21 root 0 -20 0 0 0 S 0.0 0.0 0:00.02 [writeback]
22 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kintegrityd]
23 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [bioset]
24 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kblockd]
25 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [md]
26 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [edac-poller]
33 root 20 0 0 0 0 S 0.0 0.0 1:19.07 [kswapd0]
34 root 25 5 0 0 0 S 0.0 0.0 0:00.00 [ksmd]
35 root 39 19 0 0 0 S 0.0 0.0 0:12.80 [khugepaged]
36 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [crypto]
```
### 如何按照指定字段对结果进行排序
在 `top` 命令的最新版本中， 按下 `f` 键进入字段管理界面。
要使用新字段进行排序， 请使用 `up`/`down` 箭头选择正确的选项，然后再按下 `s` 键进行排序。最后按 `q` 键退出此窗口。
```
Fields Management for window 1:Def, whose current sort field is %CPU
Navigate with Up/Dn, Right selects for move then or Left commits,
'd' or toggles display, 's' sets sort. Use 'q' or to end!
PID = Process Id nsUTS = UTS namespace Inode
USER = Effective User Name LXC = LXC container name
PR = Priority RSan = RES Anonymous (KiB)
NI = Nice Value RSfd = RES File-based (KiB)
VIRT = Virtual Image (KiB) RSlk = RES Locked (KiB)
RES = Resident Size (KiB) RSsh = RES Shared (KiB)
SHR = Shared Memory (KiB) CGNAME = Control Group name
S = Process Status NU = Last Used NUMA node
%CPU = CPU Usage
%MEM = Memory Usage (RES)
TIME+ = CPU Time, hundredths
COMMAND = Command Name/Line
PPID = Parent Process pid
UID = Effective User Id
RUID = Real User Id
RUSER = Real User Name
SUID = Saved User Id
SUSER = Saved User Name
GID = Group Id
GROUP = Group Name
PGRP = Process Group Id
TTY = Controlling Tty
TPGID = Tty Process Grp Id
SID = Session Id
nTH = Number of Threads
P = Last Used Cpu (SMP)
TIME = CPU Time
SWAP = Swapped Size (KiB)
CODE = Code Size (KiB)
DATA = Data+Stack (KiB)
nMaj = Major Page Faults
nMin = Minor Page Faults
nDRT = Dirty Pages Count
WCHAN = Sleeping in Function
Flags = Task Flags
CGROUPS = Control Groups
SUPGIDS = Supp Groups IDs
SUPGRPS = Supp Groups Names
TGID = Thread Group Id
OOMa = OOMEM Adjustment
OOMs = OOMEM Score current
ENVIRON = Environment vars
vMj = Major Faults delta
vMn = Minor Faults delta
USED = Res+Swap Size (KiB)
nsIPC = IPC namespace Inode
nsMNT = MNT namespace Inode
nsNET = NET namespace Inode
nsPID = PID namespace Inode
nsUSER = USER namespace Inode
```
对 `top` 命令的旧版本，请按 `shift+f` 或 `shift+o` 键进入字段管理界面进行排序。
要使用新字段进行排序，请选择相应的排序字段字母， 然后按下回车键排序。
```
Current Sort Field: N for window 1:Def
Select sort field via field letter, type any other key to return
a: PID = Process Id
b: PPID = Parent Process Pid
c: RUSER = Real user name
d: UID = User Id
e: USER = User Name
f: GROUP = Group Name
g: TTY = Controlling Tty
h: PR = Priority
i: NI = Nice value
j: P = Last used cpu (SMP)
k: %CPU = CPU usage
l: TIME = CPU Time
m: TIME+ = CPU Time, hundredths
* N: %MEM = Memory usage (RES)
o: VIRT = Virtual Image (kb)
p: SWAP = Swapped size (kb)
q: RES = Resident size (kb)
r: CODE = Code size (kb)
s: DATA = Data+Stack size (kb)
t: SHR = Shared Mem size (kb)
u: nFLT = Page Fault count
v: nDRT = Dirty Pages count
w: S = Process Status
x: COMMAND = Command name/line
y: WCHAN = Sleeping in Function
z: Flags = Task Flags
Note1:
If a selected sort field can't be
shown due to screen width or your
field order, the '<' and '>' keys
will be unavailable until a field
within viewable range is chosen.
Note2:
Field sorting uses internal values,
not those in column display. Thus,
the TTY & WCHAN fields will violate
strict ASCII collating sequence.
(shame on you if WCHAN is chosen)
```
---
via: <https://www.2daygeek.com/linux-run-execute-top-command-in-batch-mode/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[way-ww](https://github.com/way-ww) 校对：[校对者ID](https://github.com/%E6%A0%A1%E5%AF%B9%E8%80%85ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
你需要知道的 DevSecOps 流程及工具
|
Sagar Nangare
|
https://opensource.com/article/19/10/devsecops-pipeline-and-tools
|
DevSecOps 对 DevOps 进行了改进，以确保安全性仍然是该过程的一个重要部分。
|
/data/attachment/album/201910/23/002010fvzh282e8ghhdzpk.jpg.thumb.jpg
|
/data/attachment/album/201910/23/002010fvzh282e8ghhdzpk.jpg
| true | false | true |
lujun9972
|
lnrCoder
|
wxy
| false |
[
"DevSecOps"
] |
技术
|
{
"viewnum": 6617,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
DevSecOps 对 DevOps 进行了改进，以确保安全性仍然是该过程的一个重要部分。
| 2019-10-23T00:21:03 | 2019-10-23T00:21:03 | 11,492 |
/article-11492-1.html
|
>
> DevSecOps 对 DevOps 进行了改进，以确保安全性仍然是该过程的一个重要部分。
>
>
>
到目前为止，DevOps 在 IT 世界中已广为人知，但其并非完美无缺。试想一下，你在一个项目的现代应用程序交付中实施了所有 DevOps 工程实践。你已经到达开发流程的末尾，但是渗透测试团队（内部或外部）检测到安全漏洞并提出了报告。现在，你必须重新启动所有流程，并要求开发人员修复该漏洞。
在基于 DevOps 的软件开发生命周期（SDLC）系统中，这并不繁琐，但它确实会浪费时间并影响交付进度。如果从 SDLC 初期就已经集成了安全性，那么你可能已经跟踪到了该故障，并在开发流程中就消除了它。但是，如上述情形那样，将安全性推到开发流程的最后将导致更长的开发生命周期。
这就是引入 DevSecOps 的原因，它以自动化的方式巩固了整个软件交付周期。
在现代 DevOps 方法中，组织广泛使用容器托管应用程序，我们看到 [Kubernetes](https://opensource.com/resources/what-is-kubernetes) 和 [Istio](https://opensource.com/article/18/9/what-istio) 使用的较多。但是，这些工具都有其自身的漏洞。例如，云原生计算基金会（CNCF）最近完成了一项 [kubernetes 安全审计](https://www.cncf.io/blog/2019/08/06/open-sourcing-the-kubernetes-security-audit/)，发现了几个问题。DevOps 开发流程中使用的所有工具在流程运行时都需要进行安全检查，DevSecOps 会推动管理员去监视工具的存储库以获取升级和补丁。
### 什么是 DevSecOps?
与 DevOps 一样，DevSecOps 是开发人员和 IT 运营团队在开发和部署软件应用程序时所遵循的一种思维方式或文化。它将主动和自动化的安全审计以及渗透测试集成到敏捷应用程序开发中。
要使用 [DevSecOps](https://resources.whitesourcesoftware.com/blog-whitesource/devsecops)，你需要：
* 从 SDLC 开始就引入安全性概念，以最大程度地减少软件代码中的漏洞。
* 确保每个人（包括开发人员和 IT 运营团队）共同承担在其任务中遵循安全实践的责任。
* 在 DevOps 工作流程开始时集成安全控件、工具和流程。这些将在软件交付的每个阶段启用自动安全检查。
DevOps 一直致力于在开发和发布过程中包括安全性以及质量保证（QA）、数据库管理和其他所有方面。然而，DevSecOps 是该过程的一个演进，以确保安全永远不会被遗忘，成为该过程的一个重要部分。
### 了解 DevSecOps 流程
典型的 DevOps 流程有不同的阶段；典型的 SDLC 流程包括计划、编码、构建、测试、发布和部署等阶段。在 DevSecOps 中，每个阶段都会应用特定的安全检查。
* **计划**：执行安全性分析并创建测试计划，以确定在何处、如何以及何时进行测试的方案。
* **编码**：部署整理工具和 Git 控件以保护密码和 API 密钥。
* **构建**：在构建执行代码时，请结合使用静态应用程序安全测试（SAST）工具来跟踪代码中的缺陷，然后再部署到生产环境中。这些工具针对特定的编程语言。
* **测试**：在运行时使用动态应用程序安全测试（DAST）工具来测试您的应用程序。 这些工具可以检测与用户身份验证，授权，SQL 注入以及与 API 相关的端点相关的错误。
* **发布**：在发布应用程序之前，请使用安全分析工具来进行全面的渗透测试和漏洞扫描。
* **部署**：在运行时完成上述测试后，将安全的版本发送到生产中以进行最终部署。
### DevSecOps 工具
SDLC 的每个阶段都有可用的工具。有些是商业产品，但大多数是开源的。在我的下一篇文章中，我将更多地讨论在流程的不同阶段使用的工具。
随着基于现代 IT 基础设施的企业安全威胁的复杂性增加，DevSecOps 将发挥更加关键的作用。然而，DevSecOps 流程将需要随着时间的推移而改进，而不是仅仅依靠同时实施所有安全更改即可。这将消除回溯或应用交付失败的可能性。
---
via: <https://opensource.com/article/19/10/devsecops-pipeline-and-tools>
作者：[Sagar Nangare](https://opensource.com/users/sagarnangare) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lnrCoder](https://github.com/lnrCoder) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
变异测试：基于故障的试验
|
Alex Bunardzic
|
https://opensource.com/article/19/9/mutation-testing-example-failure-experimentation
|
基于 .NET 的 xUnit.net 测试框架，开发一款自动猫门的逻辑，让门在白天开放，夜间锁定。
|
/data/attachment/album/201910/23/171508cd7q7ilais29disa.jpg.thumb.jpg
|
/data/attachment/album/201910/23/171508cd7q7ilais29disa.jpg
| true | false | false |
Morisun029
| false |
[
"变异测试"
] |
软件开发
|
{
"viewnum": 3297,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11483,
"displayorder": 0
}
] |
基于 .NET 的 xUnit.net 测试框架，开发一款自动猫门的逻辑，让门在白天开放，夜间锁定。
| 2019-10-24T06:00:00 | 2019-10-24T06:00:00 | 11,494 |
/article-11494-1.html
|
>
> 基于 .NET 的 xUnit.net 测试框架，开发一款自动猫门的逻辑，让门在白天开放，夜间锁定。
>
>
>
在本系列的[第一篇文章](/article-11483-1.html)中，我演示了如何使用设计的故障来确保代码中的预期结果。在第二篇文章中，我将继续开发示例项目：一款自动猫门，该门在白天开放，夜间锁定。
在此提醒一下，你可以按照[此处的说明](/article-11468-1.html)使用 .NET 的 xUnit.net 测试框架。
### 关于白天时间
回想一下，测试驱动开发（TDD）围绕着大量的单元测试。
第一篇文章中实现了满足 `Given7pmReturnNighttime` 单元测试期望的逻辑。但还没有完，现在，你需要描述当前时间大于 7 点时期望发生的结果。这是新的单元测试，称为 `Given7amReturnDaylight`：
```
[Fact]
public void Given7amReturnDaylight()
{
var expected = "Daylight";
var actual = dayOrNightUtility.GetDayOrNight();
Assert.Equal(expected, actual);
}
```
现在，新的单元测试失败了（越早失败越好！）：
```
Starting test execution, please wait...
[Xunit.net 00:00:01.23] unittest.UnitTest1.Given7amReturnDaylight [FAIL]
Failed unittest.UnitTest1.Given7amReturnDaylight
[...]
```
期望接收到字符串值是 `Daylight`，但实际接收到的值是 `Nighttime`。
### 分析失败的测试用例
经过仔细检查，代码本身似乎已经出现问题。 事实证明，`GetDayOrNight` 方法的实现是不可测试的！
看看我们面临的核心挑战：
1. `GetDayOrNight` 依赖隐藏输入。
`dayOrNight` 的值取决于隐藏输入（它从内置系统时钟中获取一天的时间值）。
2. `GetDayOrNight` 包含非确定性行为。
从系统时钟中获取到的时间值是不确定的。（因为）该时间取决于你运行代码的时间点，而这一点我们认为这是不可预测的。
3. `GetDayOrNight` API 的质量差。
该 API 与具体的数据源（系统 `DateTime`）紧密耦合。
4. `GetDayOrNight` 违反了单一责任原则。
该方法实现同时使用和处理信息。优良作法是一种方法应负责执行一项职责。
5. `GetDayOrNight` 有多个更改原因。
可以想象内部时间源可能会更改的情况。同样，很容易想象处理逻辑也将改变。这些变化的不同原因必须相互隔离。
6. 当（我们）尝试了解 `GetDayOrNight` 行为时，会发现它的 API 签名不足。
最理想的做法就是通过简单的查看 API 的签名，就能了解 API 预期的行为类型。
7. `GetDayOrNight` 取决于全局共享可变状态。
要不惜一切代价避免共享的可变状态！
8. 即使在阅读源代码之后，也无法预测 `GetDayOrNight` 方法的行为。
这是一个严重的问题。通过阅读源代码，应该始终非常清晰，系统一旦开始运行，便可以预测出其行为。
### 失败背后的原则
每当你遇到工程问题时，建议使用久经考验的<ruby> 分而治之 <rt> divide and conquer </rt></ruby>策略。在这种情况下，遵循<ruby> 关注点分离 <rt> separation of concerns </rt></ruby>的原则是一种可行的方法。
>
> 关注点分离（SoC）是一种用于将计算机程序分为不同模块的设计原理，以便每个模块都可以解决一个关注点。关注点是影响计算机程序代码的一组信息。关注点可以和要优化代码的硬件的细节一样概括，也可以和要实例化的类的名称一样具体。完美体现 SoC 的程序称为模块化程序。
>
>
> （[出处](https://en.wikipedia.org/wiki/Separation_of_concerns)）
>
>
>
`GetDayOrNight` 方法应仅与确定日期和时间值表示白天还是夜晚有关。它不应该与寻找该值的来源有关。该问题应留给调用客户端。
必须将这个问题留给调用客户端，以获取当前时间。这种方法符合另一个有价值的工程原理——<ruby> 控制反转 <rt> inversion of control </rt></ruby>。Martin Fowler [在这里](https://martinfowler.com/bliki/InversionOfControl.html)详细探讨了这一概念。
>
> 框架的一个重要特征是用户定义的用于定制框架的方法通常来自于框架本身，而不是从用户的应用程序代码调用来的。该框架通常在协调和排序应用程序活动中扮演主程序的角色。控制权的这种反转使框架有能力充当可扩展的框架。用户提供的方法为框架中的特定应用程序量身制定泛化算法。
>
>
> – [Ralph Johnson and Brian Foote](http://www.laputan.org/drc/drc.html)
>
>
>
### 重构测试用例
因此，代码需要重构。摆脱对内部时钟的依赖（`DateTime` 系统实用程序）：
```
DateTime time = new DateTime();
```
删除上述代码（在你的文件中应该是第 7 行）。通过将输入参数 `DateTime` 时间添加到 `GetDayOrNight` 方法，进一步重构代码。
这是重构的类 `DayOrNightUtility.cs`：
```
using System;
namespace app {
public class DayOrNightUtility {
public string GetDayOrNight(DateTime time) {
string dayOrNight = "Nighttime";
if(time.Hour >= 7 && time.Hour < 19) {
dayOrNight = "Daylight";
}
return dayOrNight;
}
}
}
```
重构代码需要更改单元测试。 需要准备 `nightHour` 和 `dayHour` 的测试数据，并将这些值传到`GetDayOrNight` 方法中。 以下是重构的单元测试：
```
using System;
using Xunit;
using app;
namespace unittest
{
public class UnitTest1
{
DayOrNightUtility dayOrNightUtility = new DayOrNightUtility();
DateTime nightHour = new DateTime(2019, 08, 03, 19, 00, 00);
DateTime dayHour = new DateTime(2019, 08, 03, 07, 00, 00);
[Fact]
public void Given7pmReturnNighttime()
{
var expected = "Nighttime";
var actual = dayOrNightUtility.GetDayOrNight(nightHour);
Assert.Equal(expected, actual);
}
[Fact]
public void Given7amReturnDaylight()
{
var expected = "Daylight";
var actual = dayOrNightUtility.GetDayOrNight(dayHour);
Assert.Equal(expected, actual);
}
}
}
```
### 经验教训
在继续开发这种简单的场景之前，请先回顾复习一下本次练习中所学到的东西。
运行无法测试的代码，很容易在不经意间制造陷阱。从表面上看，这样的代码似乎可以正常工作。但是，遵循测试驱动开发（TDD）的实践（首先描述期望结果，然后才描述实现），暴露了代码中的严重问题。
这表明 TDD 是确保代码不会太凌乱的理想方法。TDD 指出了一些问题区域，例如缺乏单一责任和存在隐藏输入。此外，TDD 有助于删除不确定性代码，并用行为明确的完全可测试代码替换它。
最后，TDD 帮助交付易于阅读、逻辑易于遵循的代码。
在本系列的下一篇文章中，我将演示如何使用在本练习中创建的逻辑来实现功能代码，以及如何进行进一步的测试使其变得更好。
---
via: <https://opensource.com/article/19/9/mutation-testing-example-failure-experimentation>
作者：[Alex Bunardzic](https://opensource.com/users/alex-bunardzic) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Morisun029](https://github.com/Morisun029) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux sudo 漏洞可能导致未经授权的特权访问
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3446036/linux-sudo-flaw-can-lead-to-unauthorized-privileges.html
|
在 Linux 中利用新发现的 sudo 漏洞可以使某些用户以 root 身份运行命令，尽管对此还有所限制。
|
/data/attachment/album/201910/23/173934huyi6siys2u33w9z.png.thumb.jpg
|
/data/attachment/album/201910/23/173934huyi6siys2u33w9z.png
| true | false | false | false |
[
"sudo"
] |
技术
|
{
"viewnum": 5080,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "223.104.3.40",
"message": "又发一遍",
"username": "来自北京的 Mobile Safari 13.0|iOS 13.1 用户",
"date": "2019-10-24T17:54:48"
}
] |
[] |
在 Linux 中利用新发现的 sudo 漏洞可以使某些用户以 root 身份运行命令，尽管对此还有所限制。
| 2019-10-24T06:05:00 | 2019-10-24T06:05:00 | 11,495 |
/article-11495-1.html
|
>
> 在 Linux 中利用新发现的 sudo 漏洞可以使某些用户以 root 身份运行命令，尽管对此还有所限制。
>
>
>
[sudo](https://www.networkworld.com/article/3236499/some-tricks-for-using-sudo.html) 命令中最近发现了一个严重漏洞，如果被利用，普通用户可以 root 身份运行命令，即使在 `/etc/sudoers` 文件中明确禁止了该用户这样做。
将 `sudo` 更新到版本 1.8.28 应该可以解决该问题，因此建议 Linux 管理员尽快这样做。
如何利用此漏洞取决于 `/etc/sudoers` 中授予的特定权限。例如，一条规则允许用户以除了 root 用户之外的任何用户身份来编辑文件，这实际上将允许该用户也以 root 用户身份来编辑文件。在这种情况下，该漏洞可能会导致非常严重的问题。
用户要能够利用此漏洞，需要在 `/etc/sudoers` 中为**用户**分配特权，以使该用户可以以其他用户身份运行命令，并且该漏洞仅限于以这种方式分配的命令特权。
此问题影响 1.8.28 之前的版本。要检查你的 `sudo` 版本，请使用以下命令：
```
$ sudo -V
Sudo version 1.8.27 <===
Sudoers policy plugin version 1.8.27
Sudoers file grammar version 46
Sudoers I/O plugin version 1.8.27
```
该漏洞已在 CVE 数据库中分配了编号 [CVE-2019-14287](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-14287)。它的风险是，任何被指定能以任意用户运行某个命令的用户，即使被明确禁止以 root 身份运行，它都能逃脱限制。
下面这些行让 `jdoe` 能够以除了 root 用户之外的其他身份使用 `vi` 编辑文件（`!root` 表示“非 root”），同时 `nemo` 有权运行以除了 root 身份以外的任何用户使用 `id` 命令：
```
# affected entries on host "dragonfly"
jdoe dragonfly = (ALL, !root) /usr/bin/vi
nemo dragonfly = (ALL, !root) /usr/bin/id
```
但是，由于存在漏洞，这些用户中要么能够绕过限制并以 root 编辑文件，或者以 root 用户身份运行 `id` 命令。
攻击者可以通过指定用户 ID 为 `-1` 或 `4294967295` 来以 root 身份运行命令。
```
sudo -u#-1 id -u
```
或者
```
sudo -u#4294967295 id -u
```
响应为 `1` 表明该命令以 root 身份运行（显示 root 的用户 ID）。
苹果信息安全团队的 Joe Vennix 找到并分析该问题。
---
via: <https://www.networkworld.com/article/3446036/linux-sudo-flaw-can-lead-to-unauthorized-privileges.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/) 荣誉推出
|
|||
每周开源点评：Kubernetes 网络、OpenStack Train 以及更多的行业趋势
|
Tim Hildred
|
https://opensource.com/article/19/10/kubernetes-openstack-and-more-industry-trends
|
开源社区和行业趋势的每周总览。
|
/data/attachment/album/201910/24/060738rt1fr5vac56aj5zi.png.thumb.jpg
|
/data/attachment/album/201910/24/060738rt1fr5vac56aj5zi.png
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"OpenStack",
"Kubernetes"
] |
观点
|
{
"viewnum": 4087,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
开源社区和行业趋势的每周总览。
| 2019-10-24T06:05:00 | 2019-10-24T06:05:00 | 11,497 |
/article-11497-1.html
|
>
> 开源社区和行业趋势的每周总览。
>
>
>
作为我在具有开源开发模型的企业软件公司担任高级产品营销经理的角色的一部分，我为产品营销人员、经理和其他影响者定期发布有关开源社区，市场和行业趋势的定期更新。以下是该更新中我和他们最喜欢的五篇文章。
### OpenStack Train 中最令人兴奋的功能
* [文章地址](https://www.redhat.com/en/blog/look-most-exciting-features-openstack-train)
>
> 考虑到 Train 版本必须提供的所有技术优势（[你可以在此处查看版本亮点](https://releases.openstack.org/train/highlights.html)），你可能会对 Red Hat 认为这些将使我们的电信和企业客户受益的顶级功能及其用例感到好奇。以下我们对该版本最兴奋的功能的概述。
>
>
>
**影响**：OpenStack 对我来说就像 Shia LaBeouf：它在几年前达到了炒作的顶峰，然后继续产出了好的作品。Train 版本看起来是又一次令人难以置信的创新下降。
### 以 Ansible 原生的方式构建 Kubernetes 操作器
* [文章地址](https://www.cncf.io/webinars/building-kubernetes-operators-in-an-ansible-native-way/)
>
> 操作器简化了 Kubernetes 上复杂应用程序的管理。它们通常是用 Go 语言编写的，并且需要懂得 Kubernetes 内部的专业知识。但是，还有另一种进入门槛较低的选择。Ansible 是操作器 SDK 中的一等公民。使用 Ansible 可以释放应用程序工程师的精力，最大限度地利用时间来自动化和协调你的应用程序，并使用一种简单的语言在新的和现有的平台上进行操作。在这里我们可以看到如何做。
>
>
>
**影响**：这就像你发现可以用搅拌器和冷冻香蕉制作出不错的冰淇淋一样：Ansible（通常被认为很容易掌握）可以使你比你想象的更容易地做一些令人印象深刻的操作器魔术。
### Kubernetes 网络：幕后花絮
* [文章地址](https://itnext.io/kubernetes-networking-behind-the-scenes-39a1ab1792bb)
>
> 尽管围绕该主题有很多很好的资源（链接在[这里](https://github.com/nleiva/kubernetes-networking-links)），但我找不到一个示例，可以将所有的点与网络工程师喜欢和讨厌的命令输出连接起来，以显示背后实际发生的情况。因此，我决定从许多不同的来源收集这些信息，以期帮助你更好地了解事物之间的联系。
>
>
>
**影响**：这是一篇对复杂主题（带有图片）阐述的很好的作品。保证可以使 Kubenetes 网络的混乱程度降低 10％。
### 保护容器供应链
* [文章地址](https://www.devprojournal.com/technology-trends/open-source/securing-the-container-supply-chain/)
>
> 随着容器、软件即服务和函数即服务的出现，人们开始着眼于在使用现有服务、函数和容器映像的过程中寻求新的价值。[Red Hat](https://www.redhat.com/en) 的容器首席产品经理 Scott McCarty 表示，关注这个重点既有优点也有缺点。“它使我们能够集中精力编写满足我们需求的新应用程序代码，同时将对基础架构的关注转移给其他人身上，”McCarty 说，“容器处于一个最佳位置，提供了足够的控制，而卸去了许多繁琐的基础架构工作。”但是，容器也会带来与安全性相关的劣势。
>
>
>
**影响**：我在一个由大约十位安全人员组成的小组中，可以肯定地说，整天要考虑软件安全性需要一定的倾向。当你长时间凝视深渊时，它也凝视着你。如果你不是如此倾向的软件开发人员，请听取 Scott 的建议并确保你的供应商考虑安全。
### 15 岁的 Fedora：为何 Matthew Miller 看到 Linux 发行版的光明前景
* [文章链接](https://www.techrepublic.com/article/fedora-at-15-why-matthew-miller-sees-a-bright-future-for-the-linux-distribution/)
>
> 在 TechRepublic 的一个大范围采访中，Fedora 项目负责人 Matthew Miller 讨论了过去的经验教训、软件容器的普遍采用和竞争性标准、Fedora 的潜在变化以及包括 systemd 在内的热门话题。
>
>
>
**影响**：我喜欢 Fedora 项目的原因是它的清晰度；该项目知道它代表什么。像 Matt 这样的人就是为什么能看到光明前景的原因。
*我希望你喜欢这张上周让我印象深刻的列表，并在下周一回来了解更多的开放源码社区、市场和行业趋势。*
---
via: <https://opensource.com/article/19/10/kubernetes-openstack-and-more-industry-trends>
作者：[Tim Hildred](https://opensource.com/users/thildred) 选题：[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/) 荣誉推出
|
DevOps 专业人员如何成为网络安全拥护者
|
Jessica Repka
|
https://opensource.com/article/19/9/devops-security-champions
|
打破信息孤岛，成为网络安全的拥护者，这对你、对你的职业、对你的公司都会有所帮助。
|
/data/attachment/album/201910/24/202520u09xw2vm4w2jm0mx.jpg.thumb.jpg
|
/data/attachment/album/201910/24/202520u09xw2vm4w2jm0mx.jpg
| true | false | true |
lujun9972
|
hopefully2333
|
wxy
| false |
[
"DevSecOps",
"DevOps"
] |
观点
|
{
"viewnum": 3730,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
打破信息孤岛，成为网络安全的拥护者，这对你、对你的职业、对你的公司都会有所帮助。
| 2019-10-24T20:26:57 | 2019-10-24T20:26:57 | 11,498 |
/article-11498-1.html
|
>
> 打破信息孤岛，成为网络安全的拥护者，这对你、对你的职业、对你的公司都会有所帮助。
>
>
>
安全是 DevOps 中一个被误解了的部分，一些人认为它不在 DevOps 的范围内，而另一些人认为它太过重要（并且被忽视），建议改为使用 DevSecOps。无论你同意哪一方的观点，网络安全都会影响到我们每一个人，这是很明显的事实。
每年，[黑客行为的统计数据](https://hostingtribunal.com/blog/hacking-statistics/) 都会更加令人震惊。例如，每 39 秒就有一次黑客行为发生，这可能会导致你为公司写的记录、身份和专有项目被盗。你的安全团队可能需要花上几个月（也可能是永远找不到）才能发现这次黑客行为背后是谁，目的是什么，人在哪，什么时候黑进来的。
运维专家面对这些棘手问题应该如何是好？呐我说，现在是时候成为网络安全的拥护者，变为解决方案的一部分了。
### 孤岛势力范围的战争
在我和我本地的 IT 安全（ITSEC）团队一起肩并肩战斗的岁月里，我注意到了很多事情。一个很大的问题是，安全团队和 DevOps 之间关系紧张，这种情况非常普遍。这种紧张关系几乎都是来源于安全团队为了保护系统、防范漏洞所作出的努力（例如，设置访问控制或者禁用某些东西），这些努力会中断 DevOps 的工作并阻碍他们快速部署应用程序。
你也看到了，我也看到了，你在现场碰见的每一个人都有至少一个和它有关的故事。一小撮的怨恨最终烧毁了信任的桥梁，要么是花费一段时间修复，要么就是两个团体之间开始一场小型的地盘争夺战，这个结果会使 DevOps 实现起来更加艰难。
### 一种新观点
为了打破这些孤岛并结束势力战争，我在每个安全团队中都选了至少一个人来交谈，了解我们组织日常安全运营里的来龙去脉。我开始做这件事是出于好奇，但我持续做这件事是因为它总是能带给我一些有价值的、新的观点。例如，我了解到，对于每个因为失败的安全性而被停止的部署，安全团队都在疯狂地尝试修复 10 个他们看见的其他问题。他们反应的莽撞和尖锐是因为他们必须在有限的时间里修复这些问题，不然这些问题就会变成一个大问题。
考虑到发现、识别和撤销已完成操作所需的大量知识，或者指出 DevOps 团队正在做什么（没有背景信息）然后复制并测试它。所有的这些通常都要由人手配备非常不足的安全团队完成。
这就是你的安全团队的日常生活，并且你的 DevOps 团队看不到这些。ITSEC 的日常工作意味着超时加班和过度劳累，以确保公司，公司的团队，团队里工作的所有人能够安全地工作。
### 成为安全拥护者的方法
这些是你成为你的安全团队的拥护者之后可以帮到它们的。这意味着，对于你做的所有操作，你必须仔细、认真地查看所有能够让其他人登录的方式，以及他们能够从中获得什么。
帮助你的安全团队就是在帮助你自己。将工具添加到你的工作流程里，以此将你知道的要干的活和他们知道的要干的活结合到一起。从小事入手，例如阅读公共漏洞披露（CVE），并将扫描模块添加到你的 CI/CD 流程里。对于你写的所有代码，都会有一个开源扫描工具，添加小型开源工具（例如下面列出来的）在长远看来是可以让项目更好的。
**容器扫描工具：**
* [Anchore Engine](https://github.com/anchore/anchore-engine)
* [Clair](https://github.com/coreos/clair)
* [Vuls](https://vuls.io/)
* [OpenSCAP](https://www.open-scap.org/)
**代码扫描工具：**
* [OWASP SonarQube](https://github.com/OWASP/sonarqube)
* [Find Security Bugs](https://find-sec-bugs.github.io/)
* [Google Hacking Diggity Project](https://resources.bishopfox.com/resources/tools/google-hacking-diggity/)
**Kubernetes 安全工具：**
* [Project Calico](https://www.projectcalico.org/)
* [Kube-hunter](https://github.com/aquasecurity/kube-hunter)
* [NeuVector](https://github.com/neuvector/neuvector-helm)
### 保持你的 DevOps 态度
如果你的工作角色是和 DevOps 相关的，那么学习新技术和如何运用这项新技术创造新事物就是你工作的一部分。安全也是一样。我在 DevOps 安全方面保持到最新，下面是我的方法的列表。
* 每周阅读一篇你工作的方向里和安全相关的文章.
* 每周查看 [CVE](https://cve.mitre.org/) 官方网站，了解出现了什么新漏洞.
* 尝试做一次黑客马拉松。一些公司每个月都要这样做一次；如果你觉得还不够、想了解更多，可以访问 Beginner Hack 1.0 网站。
* 每年至少一次和那你的安全团队的成员一起参加安全会议，从他们的角度来看事情。
### 成为拥护者是为了变得更好
你应该成为你的安全的拥护者，下面是我们列出来的几个理由。首先是增长你的知识，帮助你的职业发展。第二是帮助其他的团队，培养新的关系，打破对你的组织有害的孤岛。在你的整个组织内建立由很多好处，包括设置沟通团队的典范，并鼓励人们一起工作。你同样能促进在整个组织中分享知识，并给每个人提供一个在安全方面更好的内部合作的新契机。
总的来说，成为一个网络安全的拥护者会让你成为你整个组织的拥护者。
---
via: <https://opensource.com/article/19/9/devops-security-champions>
作者：[Jessica Repka](https://opensource.com/users/jrepka) 选题：[lujun9972](https://github.com/lujun9972) 译者：[hopefully2333](https://github.com/hopefully2333) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 Git 帮助写作者更好地完成工作
|
Seth Kenlon
|
https://opensource.com/article/19/4/write-git
|
如果你是一名写作者，你也能从使用 Git 中受益。在我们的系列文章中了解有关 Git 鲜为人知的用法。
|
/data/attachment/album/201910/24/222747ltajik2ymzmmttha.png.thumb.jpg
|
/data/attachment/album/201910/24/222747ltajik2ymzmmttha.png
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Git"
] |
技术
|
{
"viewnum": 5617,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "114.251.218.194",
"message": "真的挺有意思的",
"username": "来自北京的 Chrome 77.0|Windows 10 用户",
"date": "2019-10-25T17:03:43"
}
] |
[
{
"raid": 11342,
"displayorder": 0
},
{
"raid": 11768,
"displayorder": 0
}
] |
如果你是一名写作者，你也能从使用 Git 中受益。在我们的系列文章中了解有关 Git 鲜为人知的用法。
| 2019-10-24T22:30:00 | 2019-10-24T22:30:00 | 11,499 |
/article-11499-1.html
|
>
> 如果你是一名写作者，你也能从使用 Git 中受益。在我们的系列文章中了解有关 Git 鲜为人知的用法。
>
>
>
[Git](https://git-scm.com/) 是一个少有的能将如此多的现代计算封装到一个程序之中的应用程序，它可以用作许多其他应用程序的计算引擎。虽然它以跟踪软件开发中的源代码更改而闻名，但它还有许多其他用途，可以让你的生活更轻松、更有条理。在这个 Git 系列中，我们将分享七种鲜为人知的使用 Git 的方法。
今天我们来看看写作者如何使用 Git 更好的地完成工作。
### 写作者的 Git
有些人写小说，也有人撰写学术论文、诗歌、剧本、技术手册或有关开源的文章。许多人都在做一些各种写作。相同的是，如果你是一名写作者，或许能从使用 Git 中受益。尽管 Git 是著名的计算机程序员所使用的高度技术性工具，但它也是现代写作者的理想之选，本文将向你演示如何改变你的书写方式以及为什么要这么做的原因。
但是，在谈论 Git 之前，重要的是先谈谈“副本”（或者叫“内容”，对于数字时代而言）到底是什么，以及为什么它与你的交付*媒介*不同。这是 21 世纪，大多数写作者选择的工具是计算机。尽管计算机看似擅长将副本的编辑和布局等过程结合在一起，但写作者还是（重新）发现将内容与样式分开是一个好主意。这意味着你应该在计算机上像在打字机上而不是在文字处理器中进行书写。以计算机术语而言，这意味着以*纯文本*形式写作。
### 以纯文本写作
这个假设曾经是毫无疑问的：你知道自己的写作所要针对的市场，你可以为书籍、网站或软件手册等不同市场编写内容。但是，近来各种市场趋于扁平化：你可能决定在纸质书中使用为网站编写的内容，并且纸质书可能会在以后发布 EPUB 版本。对于你的内容的数字版本，读者才是最终控制者：他们可以在你发布内容的网站上阅读你的文字，也可以点击 Firefox 出色的[阅读视图](https://support.mozilla.org/en-US/kb/firefox-reader-view-clutter-free-web-pages)，还可能会打印到纸张上，或者可能会使用 Lynx 将网页转储到文本文件中，甚至可能因为使用屏幕阅读器而根本看不到你的内容。
你只需要逐字写下你的内容，而将交付工作留给发布者。即使你是自己发布，将字词作为写作作品的一种源代码也是一种更聪明、更有效的工作方式，因为在发布时，你可以使用相同的源（你的纯文本）生成适合你的目标输出（用于打印的 PDF、用于电子书的 EPUB、用于网站的 HTML 等）。
用纯文本编写不仅意味着你不必担心布局或文本样式，而且也不再需要专门的工具。无论是手机或平板电脑上的基本的记事本应用程序、计算机附带的文本编辑器，还是从互联网上下载的免费编辑器，任何能够产生文本内容的工具对你而言都是有效的“文字处理器”。无论你身在何处或在做什么，几乎可以在任何设备上书写，并且所生成的文本可以与你的项目完美集成，而无需进行任何修改。
而且，Git 专门用来管理纯文本。
### Atom 编辑器
当你以纯文本形式书写时，文字处理程序会显得过于庞大。使用文本编辑器更容易，因为文本编辑器不会尝试“有效地”重组输入内容。它使你可以将脑海中的单词输入到屏幕中，而不会受到干扰。更好的是，文本编辑器通常是围绕插件体系结构设计的，这样应用程序本身很基础（它用来编辑文本），但是你可以围绕它构建一个环境来满足你的各种需求。
[Atom](http://atom.io) 编辑器就是这种设计理念的一个很好的例子。这是一个具有内置 Git 集成的跨平台文本编辑器。如果你不熟悉纯文本格式，也不熟悉 Git，那么 Atom 是最简单的入门方法。
#### 安装 Git 和 Atom
首先，请确保你的系统上已安装 Git。如果运行 Linux 或 BSD，则 Git 在软件存储库或 ports 树中可用。你使用的命令将根据你的发行版而有所不同。例如在 Fedora 上：
```
$ sudo dnf install git
```
你也可以下载并安装适用于 [Mac](https://git-scm.com/download/mac) 和 [Windows](https://git-scm.com/download/win) 的 Git。
你不需要直接使用 Git，因为 Atom 会充当你的 Git 界面。下一步是安装 Atom。
如果你使用的是 Linux，请通过软件安装程序或适当的命令从软件存储库中安装 Atom，例如：
```
$ sudo dnf install atom
```
Atom 当前没有在 BSD 上构建。但是，有很好的替代方法，例如 [GNU Emacs](http://gnu.org/software/emacs)。对于 Mac 和 Windows 用户，可以在 [Atom 网站](http://atom.io)上找到安装程序。
安装完成后，启动 Atom 编辑器。
#### 快速指导
如果要使用纯文本和 Git，则需要适应你的编辑器。Atom 的用户界面可能比你习惯的更加动态。实际上，你可以将它视为 Firefox 或 Chrome，而不是文字处理程序，因为它具有可以根据需要打开或关闭的选项卡和面板，甚至还可以安装和配置附件。尝试全部掌握 Atom 如许之多的功能是不切实际的，但是你至少可以知道有什么功能。
当打开 Atom 时，它将显示一个欢迎屏幕。如果不出意外，此屏幕很好地介绍了 Atom 的选项卡式界面。你可以通过单击 Atom 窗口顶部选项卡上的“关闭”图标来关闭欢迎屏幕，并使用“文件 > 新建文件”创建一个新文件。
使用纯文本格式与使用文字处理程序有点不同，因此这里有一些技巧，以人可以理解的方式编写内容，并且 Git 和计算机可以解析，跟踪和转换。
#### 用 Markdown 书写
如今，当人们谈论纯文本时，大多是指 Markdown。Markdown 与其说是格式，不如说是样式，这意味着它旨在为文本提供可预测的结构，以便计算机可以检测自然的模式并智能地转换文本。Markdown 有很多定义，但是最好的技术定义和备忘清单在 [CommonMark 的网站](https://commonmark.org/help/)上。
```
# Chapter 1
This is a paragraph with an *italic* word and a **bold** word in it.
And it can even reference an image.
```
从示例中可以看出，Markdown 读起来感觉不像代码，但可以将其视为代码。如果你遵循 CommonMark 定义的 Markdown 规范，那么一键就可以可靠地将 Markdown 的文字转换为 .docx、.epub、.html、MediaWiki、.odt、.pdf、.rtf 和各种其他的格式，而*不会*失去格式。
你可以认为 Markdown 有点像文字处理程序的样式。如果你曾经为出版社撰写过一套样式来控制章节标题及其样式，那基本上就是一回事，除了不是从下拉菜单中选择样式以外，你需要给你的文字添加一些小记号。对于任何习惯“以文字交谈”的现代阅读者来说，这些表示法都是很自然的，但是在呈现文本时，它们会被精美的文本样式替换掉。实际上，这就是文字处理程序在后台秘密进行的操作。文字处理器显示粗体文本，但是如果你可以看到使文本变为粗体的生成代码，则它与 Markdown 很像（实际上，它是更复杂的 XML）。使用 Markdown 可以消除这种代码和样式之间的阻隔，一方面看起来更可怕一些，但另一方面，你可以在几乎所有可以生成文本的东西上书写 Markdown 而不会丢失任何格式信息。
Markdown 文件流行的文件扩展名是 .md。如果你使用的平台不知道 .md 文件是什么，则可以手动将该扩展名与 Atom 关联，或者仅使用通用的 .txt 扩展名。文件扩展名不会更改文件的性质。它只会改变你的计算机决定如何处理它的方式。Atom 和某些平台足够聪明，可以知道该文件是纯文本格式，无论你给它以什么扩展名。
#### 实时预览
Atom 具有 “Markdown 预览” 插件，该插件可以向你显示正在编写的纯文本 Markdown 及其（通常）呈现的方式。
要激活此预览窗格，请选择“包 > Markdown 预览 > 切换预览” 或按 `Ctrl + Shift + M`。
此视图为你提供了两全其美的方法。无需承担为你的文本添加样式的负担就可以写作，而你也可以看到一个通用的示例外观，至少是以典型的数字化格式显示文本的外观。当然，关键是你无法控制文本的最终呈现方式，因此不要试图调整 Markdown 来强制以某种方式显示呈现的预览。
#### 每行一句话
你的高中写作老师不会看你的 Markdown。
一开始它不那么自然，但是在数字世界中，保持每行一个句子更有意义。Markdown 会忽略单个换行符（当你按下 `Return` 或 `Enter` 键时），并且只在单个空行之后才会创建一个新段落。
每行写一个句子的好处是你的工作更容易跟踪。也就是说，假如你在段落的开头更改了一个单词，如果更改仅限于一行而不是一个长的段落中的一个单词，那么 Atom、Git 或任何应用程序很容易以有意义的方式突出显示该更改。换句话说，对一个句子的更改只会影响该句子，而不会影响整个段落。
你可能会想：“许多文字处理器也可以跟踪更改，它们可以突出显示已更改的单个单词。”但是这些修订跟踪器绑定在该字处理器的界面上，这意味着你必须先打开该字处理器才能浏览修订。在纯文本工作流程中，你可以以纯文本形式查看修订，这意味着无论手头有什么，只要该设备可以处理纯文本（大多数都可以），就可以进行编辑或批准编辑。
诚然，写作者通常不会考虑行号，但它对于计算机有用，并且通常是一个很好的参考点。默认情况下，Atom 为文本文档的行进行编号。按下 `Enter` 键或 `Return` 键后，一*行*就是一行。
如果（在 Atom 的）一行的行号中有一个点而不是一个数字，则表示它是上一行折叠的一部分，因为它超出了你的屏幕。
#### 主题
如果你是一个在意视觉形象的人，那么你可能会非常注重自己的写作环境。即使你使用普通的 Markdown 进行编写，也并不意味着你必须使用程序员的字体或在使你看起来像码农的黑窗口中进行书写。修改 Atom 外观的最简单方法是使用[主题包](https://atom.io/themes)。主题设计人员通常将深色主题与浅色主题区分开，因此你可以根据需要使用关键字“Dark”或“Light”进行搜索。
要安装主题，请选择“编辑 > 首选项”。这将在 Atom 界面中打开一个新标签页。是的，标签页可以用于处理文档*和*用于配置及控制面板。在“设置”标签页中，单击“安装”类别。
在“安装”面板中，搜索要安装的主题的名称。单击搜索字段右侧的“主题”按钮，以仅搜索主题。找到主题后，单击其“安装”按钮。
要使用已安装的主题或根据喜好自定义主题，请导航至“设置”标签页中的“主题”类别中。从下拉菜单中选择要使用的主题。更改会立即进行，因此你可以准确了解主题如何影响你的环境。
你也可以在“设置”标签的“编辑器”类别中更改工作字体。Atom 默认采用等宽字体，程序员通常首选这种字体。但是你可以使用系统上的任何字体，无论是衬线字体、无衬线字体、哥特式字体还是草书字体。无论你想整天盯着什么字体都行。
作为相关说明，默认情况下，Atom 会在其屏幕上绘制一条垂直线，以提示编写代码的人员。程序员通常不想编写太长的代码行，因此这条垂直线会提醒他们不要写太长的代码行。不过，这条竖线对写作者而言毫无意义，你可以通过禁用 “wrap-guide” 包将其删除。
要禁用 “wrap-guide” 软件包，请在“设置”标签中选择“折行”类别，然后搜索 “wrap-guide”。找到该程序包后，单击其“禁用”按钮。
#### 动态结构
创建长文档时，我发现每个文件写一个章节比在一个文件中写整本书更有意义。此外，我不会以明显的语法 `chapter-1.md` 或 `1.example.md` 来命名我的章节，而是以章节标题或关键词（例如 `example.md`）命名。为了将来为自己提供有关如何编写本书的指导，我维护了一个名为 `toc.md` （用于“目录”）的文件，其中列出了各章的（当前）顺序。
我这样做是因为，无论我多么相信第 6 章都不可能出现在第 1 章之前，但在我完成整本书之前，几乎难以避免我会交换一两个章节的顺序。我发现从一开始就保持动态变化可以帮助我避免重命名混乱，也可以帮助我避免僵化的结构。
### 在 Atom 中使用 Git
每位写作者的共同点是两件事：他们为流传而写作，而他们的写作是一段旅程。你不能一坐下来写作就完成了最终稿件。顾名思义，你有一个初稿。该草稿会经过修订，你会仔细地将每个修订保存一式两份或三份的备份，以防万一你的文件损坏了。最终，你得到了所谓的最终草稿，但很有可能你有一天还会回到这份最终草稿，要么恢复好的部分，要么修改坏的部分。
Atom 最令人兴奋的功能是其强大的 Git 集成。无需离开 Atom，你就可以与 Git 的所有主要功能进行交互，跟踪和更新项目、回滚你不喜欢的更改、集成来自协作者的更改等等。最好的学习方法就是逐步学习，因此这是在一个写作项目中从始至终在 Atom 界面中使用 Git 的方法。
第一件事：通过选择 “视图 > 切换 Git 标签页” 来显示 Git 面板。这将在 Atom 界面的右侧打开一个新标签页。现在没什么可看的，所以暂时保持打开状态就行。
#### 建立一个 Git 项目
你可以认为 Git 被绑定到一个文件夹。Git 目录之外的任何文件夹都不知道 Git，而 Git 也不知道外面。Git 目录中的文件夹和文件将被忽略，直到你授予 Git 权限来跟踪它们为止。
你可以通过在 Atom 中创建新的项目文件夹来创建 Git 项目。选择 “文件 > 添加项目文件夹”，然后在系统上创建一个新文件夹。你创建的文件夹将出现在 Atom 窗口的左侧“项目面板”中。
#### Git 添加文件
右键单击你的新项目文件夹，然后选择“新建文件”以在项目文件夹中创建一个新文件。如果你要导入文件到新项目中，请右键单击该文件夹，然后选择“在文件管理器中显示”，以在系统的文件查看器中打开该文件夹（Linux 上为 Dolphin 或 Nautilus，Mac 上为 Finder，在 Windows 上是 Explorer），然后拖放文件到你的项目文件夹。
在 Atom 中打开一个项目文件（你创建的空文件或导入的文件）后，单击 Git 标签中的 “<ruby> 创建存储库 <rt> Create Repository </rt></ruby>” 按钮。在弹出的对话框中，单击 “<ruby> 初始化 <rt> Init </rt></ruby>” 以将你的项目目录初始化为本地 Git 存储库。 Git 会将 `.git` 目录（在系统的文件管理器中不可见，但在 Atom 中可见）添加到项目文件夹中。不要被这个愚弄了：`.git` 目录是 Git 管理的，而不是由你管理的，因此一般你不要动它。但是在 Atom 中看到它可以很好地提醒你正在由 Git 管理的项目中工作。换句话说，当你看到 `.git` 目录时，就有了修订历史记录。
在你的空文件中，写一些东西。你是写作者，所以输入一些单词就行。你可以随意输入任何一组单词，但要记住上面的写作技巧。
按 `Ctrl + S` 保存文件，该文件将显示在 Git 标签的 “<ruby> 未暂存的改变 <rt> Unstaged Changes </rt></ruby>” 部分中。这意味着该文件存在于你的项目文件夹中，但尚未提交给 Git 管理。通过单击 Git 选项卡右上方的 “<ruby> 暂存全部 <rt> Stage All </rt></ruby>” 按钮，以允许 Git 跟踪这些文件。如果你使用过带有修订历史记录的文字处理器，则可以将此步骤视为允许 Git 记录更改。
#### Git 提交
你的文件现在已暂存。这意味着 Git 知道该文件存在，并且知道自上次 Git 知道该文件以来，该文件已被更改。
Git 的<ruby> 提交 <rt> commit </rt></ruby>会将你的文件发送到 Git 的内部和永久存档中。如果你习惯于文字处理程序，这就类似于给一个修订版命名。要创建一个提交，请在 Git 选项卡底部的“<ruby> 提交 <rt> Commit </rt></ruby>”消息框中输入一些描述性文本。你可能会感到含糊不清或随意写点什么，但如果你想在将来知道进行修订的原因，那么输入一些有用的信息会更有用。
第一次提交时，必须创建一个<ruby> 分支 <rt> branch </rt></ruby>。Git 分支有点像另外一个空间，它允许你从一个时间轴切换到另一个时间轴，以进行你可能想要也可能不想要永久保留的更改。如果最终喜欢该更改，则可以将一个实验分支合并到另一个实验分支，从而统一项目的不同版本。这是一个高级过程，不需要先学会，但是你仍然需要一个活动分支，因此你必须为首次提交创建一个分支。
单击 Git 选项卡最底部的“<ruby> 分支 <rt> Branch </rt></ruby>”图标，以创建新的分支。
通常将第一个分支命名为 `master`，但不是必须如此；你可以将其命名为 `firstdraft` 或任何你喜欢的名称，但是遵守当地习俗有时会使谈论 Git（和查找问题的答案）变得容易一些，因为你会知道有人提到 “master” 时，它们的真正意思是“主干”而不是“初稿”或你给分支起的什么名字。
在某些版本的 Atom 上，UI 也许不会更新以反映你已经创建的新分支。不用担心，做了提交之后，它会创建分支（并更新 UI）。按下 “<ruby> 提交 <rt> Commit </rt></ruby>” 按钮，无论它显示的是 “<ruby> 创建脱离的提交 <rt> Create detached commit </rt></ruby>” 还是 “<ruby> 提交到主干 <rt> Commit to master </rt></ruby>。
提交后，文件的状态将永久保留在 Git 的记忆之中。
#### 历史记录和 Git 差异
一个自然而然的问题是你应该多久做一次提交。这并没有正确的答案。使用 `Ctrl + S` 保存文件和提交到 Git 是两个单独的过程，因此你会一直做这两个过程。每当你觉得自己已经做了重要的事情或打算尝试一个可能会被干掉的疯狂的新想法时，你可能都会想要做次提交。
要了解提交对工作流程的影响，请从测试文档中删除一些文本，然后在顶部和底部添加一些文本。再次提交。 这样做几次，直到你在 Git 标签的底部有了一小段历史记录，然后单击其中一个提交以在 Atom 中查看它。
查看过去的提交时，你会看到三种元素：
1. 绿色文本是该提交中已被添加到文档中的内容。
2. 红色文本是该提交中已从文档中删除的内容。
3. 其他所有文字均未做更改。
#### 远程备份
使用 Git 的优点之一是，按照设计它是分布式的，这意味着你可以将工作提交到本地存储库，并将所做的更改推送到任意数量的服务器上进行备份。你还可以从这些服务器中拉取更改，以便你碰巧正在使用的任何设备始终具有最新更改。
为此，你必须在 Git 服务器上拥有一个帐户。有几种免费的托管服务，其中包括 GitHub，这个公司开发了 Atom，但奇怪的是 GitHub 不是开源的；而 GitLab 是开源的。相比私有软件，我更喜欢开源，在本示例中，我将使用 GitLab。
如果你还没有 GitLab 帐户，请注册一个帐户并开始一个新项目。项目名称不必与 Atom 中的项目文件夹匹配，但是如果匹配，则可能更有意义。你可以将项目保留为私有，在这种情况下，只有你和任何一个你给予了明确权限的人可以访问它，或者，如果你希望该项目可供任何互联网上偶然发现它的人使用，则可以将其公开。
不要将 README 文件添加到项目中。
创建项目后，它将为你提供有关如何设置存储库的说明。如果你决定在终端中或通过单独的 GUI 使用 Git，这是非常有用的信息，但是 Atom 的工作流程则有所不同。
单击 GitLab 界面右上方的 “<ruby> 克隆 <rt> Clone </rt></ruby>” 按钮。这显示了访问 Git 存储库必须使用的地址。复制 “SSH” 地址（而不是 “https” 地址）。
在 Atom 中，点击项目的 `.git` 目录，然后打开 `config` 文件。将下面这些配置行添加到该文件中，调整 `url` 值的 `seth/example.git` 部分以匹配你自己独有的地址。
```
[remote "origin"]
url = git@gitlab.com:seth/example.git
fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
remote = origin
merge = refs/heads/master
```
在 Git 标签的底部，出现了一个新按钮，标记为 “<ruby> 提取 <rt> Fetch </rt></ruby>”。由于你的服务器是全新的服务器，因此没有可供你提取的数据，因此请右键单击该按钮，然后选择“<ruby> 推送 <rt> Push </rt></ruby>”。这会将你的更改推送到你的 GitLab 帐户，现在你的项目已备份到 Git 服务器上。
你可以在每次提交后将更改推送到服务器。它提供了即刻的异地备份，并且由于数据量通常很少，因此它几乎与本地保存一样快。
### 撰写而 Git
Git 是一个复杂的系统，不仅对修订跟踪和备份有用。它还支持异步协作并鼓励实验。本文介绍了一些基础知识，但还有更多关于 Git 的文章和整本的书，以及如何使用它使你的工作更高效、更具弹性和更具活力。 从使用 Git 完成小任务开始，使用的次数越多，你会发现自己提出的问题就越多，最终你将学到的技巧越多。
---
via: <https://opensource.com/article/19/4/write-git>
作者：[Seth Kenlon](https://opensource.com/users/sethhttps://opensource.com/users/noreplyhttps://opensource.com/users/seth) 选题：[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 QQ 突然复活！
|
老王, 小白
|
就在 1024 将将过去的深夜，突然，有人在 QQ 群内丢了一个链接和一句话“Linux QQ 发布了”，顿时在静悄悄的 QQ 群内，大家纷纷冒了出来。
|
/data/attachment/album/201910/25/060435upy74uwpb2fdku4p.jpg.thumb.jpg
|
/data/attachment/album/201910/25/060435upy74uwpb2fdku4p.jpg
| true | false | false | false |
[
"QQ"
] |
新闻
|
{
"viewnum": 11518,
"commentnum": 24,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "106.91.215.130",
"message": "无论如何，还是值得表扬和鼓励的。",
"username": "来自重庆的 Chrome 77.0|Fedora 用户",
"date": "2019-10-25T08:17:48"
},
{
"postip": "113.68.82.230",
"message": "期盼多年的linuxQQ终于再次回来。正如文中所说的，如果越来越多的公司为linux提供优质的日常和企业级应用，那系统排名中linux就不是其它那项了，就应该独立的显示为linux。",
"username": "来自广东广州的 Firefox 69.0|Windows 7 用户",
"date": "2019-10-25T08:48:54"
},
{
"postip": "123.139.41.177",
"message": "坐井观天",
"username": "来自陕西西安的 Firefox 68.0|Android 8.0 用户",
"date": "2019-10-25T08:56:31"
},
{
"postip": "112.123.164.84",
"message": "很难想象，腾讯这样的公司linux版本的qq做的这么差",
"username": "来自安徽的 Chrome 69.0|Windows 10 用户",
"date": "2019-10-25T10:05:41"
},
{
"postip": "60.28.138.115",
"message": "linux有了软件生态就能发展，是基于一个错误认知。linux需要的是教育出一批乐意用且会用linux的用户。因为linux各个版本是基于技术在发展，而不是用户偏好。配置文件说拆就拆，系统文件说改就改，不跟着学又怎么办？如果用户不能一直随着技术发展去学习，很快会耗散掉。当然，最基本的需求是完全可以满足的，但是遇到一些问题，身边总要起码有一两个同事是会用linux稍微能钻研一下的人吧。这是国内推广linux最大的瓶颈。而国内大学则是基于windows培养学生的。<br />\r\n最后，我不看好腾讯，我觉得这是应付上面的一个临时性qq。",
"username": "来自天津的 Firefox 69.0|GNU/Linux 用户",
"date": "2019-10-25T10:48:23"
},
{
"postip": "218.68.192.243",
"message": "说实话,这篇报道写的真烂.尤其是使用linux的理由居然是QQ? <br />\r\n如果你真的喜欢linux,想qq有各种办法去实现.<br />\r\n我使用linux的原因恰恰就是为了避开这些毒瘤应用.<br />\r\n即便现在出了linux平台的应用,我也会放在隔离空间运行.<br />\r\n<br />\r\n居然在linux社区发布这种内容,微软来的记者?",
"username": "来自天津的 Chrome 78.0|Windows 7 用户",
"date": "2019-10-25T12:07:07"
},
{
"postip": "218.68.192.243",
"message": "说实话,这篇报道写的真烂.尤其是使用linux的理由居然是QQ? <br />\r\n如果你真的喜欢linux,想qq有各种办法去实现.<br />\r\n我使用linux的原因恰恰就是为了避开这些毒瘤应用.<br />\r\n即便现在出了linux平台的应用,我也会放在隔离空间运行.<br />\r\n<br />\r\n居然在linux社区发布这种内容,微软来的记者?",
"username": "来自天津的 Chrome 78.0|Windows 7 用户",
"date": "2019-10-25T12:07:11"
},
{
"postip": "218.68.192.243",
"message": "说实话,这篇报道写的真烂.尤其是使用linux的理由居然是QQ? <br />\r\n如果你真的喜欢linux,想qq有各种办法去实现.<br />\r\n我使用linux的原因恰恰就是为了避开这些毒瘤应用.<br />\r\n即便现在出了linux平台的应用,我也会放在隔离空间运行.<br />\r\n<br />\r\n居然在linux社区发布这种内容,微软来的记者?",
"username": "来自天津的 Chrome 78.0|Windows 7 用户",
"date": "2019-10-25T12:07:14"
},
{
"postip": "218.68.192.243",
"message": "说实话,这篇报道写的真烂.尤其是使用linux的理由居然是QQ? <br />\r\n如果你真的喜欢linux,想qq有各种办法去实现.<br />\r\n我使用linux的原因恰恰就是为了避开这些毒瘤应用.<br />\r\n即便现在出了linux平台的应用,我也会放在隔离空间运行.<br />\r\n<br />\r\n居然在linux社区发布这种内容,微软来的记者?",
"username": "来自天津的 Chrome 78.0|Windows 7 用户",
"date": "2019-10-25T12:07:14"
},
{
"postip": "218.68.192.243",
"message": "linux发展至今,从来没有因为qq而崛起,同样离开qq也一样长存.<br />\r\n我使用 linux的原因恰恰是因为可以避开这些毒瘤应用.<br />\r\n即便现在linux版的QQ出来了,如果要运行,也是在隔离空间中.<br />\r\n<br />\r\n文章中,居然说 没有QQ还怎么用Linux? 你是微软请来的记者?<br />\r\n在一个linux社区出现这种文章,真是悲哀!",
"username": "来自天津的 Chrome 78.0|Windows 7 用户",
"date": "2019-10-25T12:09:18"
},
{
"postip": "218.66.68.115",
"message": "为什么你需要 QQ 因为你需要与麻瓜们聊些有的没的，然而你不得不去跟他们聊些有的没的，然后我们这些傲罗们用起了 wineQQ/wineTim; 现在给了一个能与麻瓜愉巴拉巴拉的机会，应该“感谢”腾讯才是",
"username": "来自福建福州的 Yandex Browser 19.10|Windows 7 用户",
"date": "2019-10-25T14:43:24"
},
{
"postip": "218.66.68.115",
"message": "为什么你需要 QQ 因为你需要与麻瓜们聊些有的没的，然而你不得不去跟他们聊些有的没的，然后我们这些傲罗们用起了 wineQQ/wineTim; 现在给了一个能与麻瓜愉巴拉巴拉的机会，应该“感谢”腾讯才是",
"username": "来自福建福州的 Yandex Browser 19.10|Windows 7 用户",
"date": "2019-10-25T14:43:29"
},
{
"postip": "113.128.99.195",
"message": "你不用不代表别人不用，没有qq等常用软件才是linux无法普及的根本原因，你竟然还冷嘲热讽，到底是何居心？是不是微软派来的卧底？",
"username": "来自山东济南的 Firefox 69.0|Windows 10 用户",
"date": "2019-10-25T14:52:08"
},
{
"postip": "202.104.117.157",
"message": "赞同，不过现在工作中，交流用的都是企业微信、钉钉，非常不便，有不能改成其他交流方式，烦人",
"username": "来自广东深圳的 Chrome 80.0|Windows 10 用户",
"date": "2019-10-25T16:36:34"
},
{
"postip": "202.104.117.157",
"message": "开什么国际玩笑，android某种程度上也算是linux的一个发行版，按你的说法，是因为它有QQ才称霸世界的？<br />\r\n<br />\r\nPS: linux.cn第一次验证码提示错误的问题又出现了",
"username": "来自广东深圳的 Chrome 80.0|Windows 10 用户",
"date": "2019-10-25T16:42:12"
},
{
"postip": "180.139.132.80",
"message": "搞笑的鸡肋。要手机扫码登陆的没有群共享的可有可无的聊天工具，<br />\r\n纯净的LINUX 不需要鹅厂的垃圾，喜欢用LINUX的人不会因为一个QQ或者VX而不用。",
"username": "来自广西南宁的 Firefox 68.0|GNU/Linux 用户",
"date": "2019-10-25T17:24:16"
},
{
"postip": "115.203.219.47",
"message": "玩 Linux 的都比较低调。",
"username": "来自浙江台州的 Firefox 69.0|Windows 10 用户",
"date": "2019-10-25T18:59:30"
},
{
"postip": "115.203.219.47",
"message": "玩 Linux 的都比较低调。",
"username": "来自浙江台州的 Firefox 69.0|Windows 10 用户",
"date": "2019-10-25T18:59:35"
},
{
"postip": "110.17.81.70",
"message": "Linux QQ的确有很长的路，我还是愿意花时间试试看",
"username": "qlk [Chrome 78.0|Windows 7]",
"date": "2019-10-26T00:14:38"
},
{
"postip": "175.5.101.252",
"message": "说不定 交付上去 是有钱拿的 这个仅代表个人参考意见",
"username": "来自湖南永州的 Chrome 69.0|Windows 7 用户",
"date": "2019-10-27T17:57:28"
},
{
"postip": "175.5.101.252",
"message": "楼主是脑子不够用吗？ linux 从来就不是为桌面系统而生的，它是为了开发或者称为研究人员而生的，而且它开源的意义也在此，",
"username": "来自湖南永州的 Chrome 69.0|Windows 7 用户",
"date": "2019-10-27T18:00:38"
},
{
"postip": "59.51.123.215",
"message": "「近两年来，自主研发的操作系统不断的刷屏，我们也一次次为自主研发的操作系统而欢呼。」<br />\r\n<br />\r\n你把我逗笑了，究竟有多**才会为这些“自主研发”的操作系统“欢呼”。",
"username": "来自湖南衡阳的 Chrome 78.0|Windows 10 用户",
"date": "2019-10-31T18:34:44"
},
{
"postip": "117.78.51.235",
"message": "使用linux的理由，的确不应该是QQ。呃...除非它想统治世界",
"username": "Mr.Wang [Firefox 68.0|Windows 10]",
"date": "2019-11-18T17:47:42"
},
{
"postip": "123.103.9.7",
"message": "已经凉勿悲伤。",
"username": "来自北京的 Chrome 89.0|GNU/Linux 用户",
"date": "2021-03-23T14:56:19"
}
] |
[] |
就在 1024 将将过去的深夜，突然，有人在 QQ 群内丢了一个链接和一句话“Linux QQ 发布了”，顿时在静悄悄的 QQ 群内，大家纷纷冒了出来。
| 2019-10-25T06:07:00 | 2019-10-25T06:07:00 | 11,501 |
/article-11501-1.html
|
### BREAKING NEWS!!!
就在 1024 将将过去的深夜，突然，有人在 QQ 群内丢了一个链接和一句话“Linux QQ 发布了”，顿时在静悄悄的 QQ 群内，大家纷纷冒了出来。一时间，群内就和开了锅一样热闹，大家纷纷抄起心爱的土琵琶 Linux，各种截屏与测试消息齐飞，臭虫共吐槽一色。
为什么这么热闹？因为 Linux 桌面在中国得不到日常用户的青睐的一个主要吐槽点就是，“没有 QQ 啊！”，自从 10 年前——没错，就是 10 年前——据说是一位实习生随手做的 Linux QQ 停更并停用后，在 Linux 中使用 QQ 就成了一件麻烦事。这十年来，中国的 Linux 社区们有过种种努力和尝试，如，被封杀的 libqq，也有逐渐摸索和改善后的 Wine QQ 方案，各路 Linux 爱好者们在入门 Linux 之后大都会总结或整理一份 Linux QQ 秘籍，当然，随着各路国内的 Linux 操作系统的成熟，也纷纷提供了各种成熟的 Linux QQ 解决方案——至少能用吧。但是，这些都总有隔靴挠痒之憾。
好了，我想你肯定已经等急了，那么下面是 Linux QQ 的下载链接：
>
> <https://im.qq.com/linuxqq/download.html>
>
>
>
在下载安装时，我们继续聊聊 Linux QQ。
据[官方的消息](https://im.qq.com/linuxqq/features.html)，这次是 “Linux QQ全新回归”，并且支持“支持x64、ARM64、MIPS64三种架构”，“每种架构支持Debian系、红帽系、Arch Linux系、其它发行版中的一种或几种”，也“优化消息体验，完善消息收发能力”，版本则是明晃晃的“Linux QQ 2.0.0 Beta”，而在十年前，最后一个公开发布的版本是“QQ for Linux 1.0 Beta1”（据闻有未公示的 Beta2 版本）。
之所以支持 ARM64、MIPS64，我想这应该是对龙芯（mips64el）、飞腾（arm64）的额外支持吧。
据大家的反馈，这次的更新作为十年后第一次发布，亮点略有，但是大致还是沿袭了之前的版本，也存在一些 bug，有的同学经过几次重启、输入法适配，还是可以完成 QQ 基本功能的体验。
新版 Linux QQ 的发布，让不少极客们大呼“有生之年”。对于开发者来说，Linux 是他们所推崇的，但一直以来，因为中国办公习惯等历史原因，QQ 和微信的 Linux 版本很难获得新的用户。毕竟，一旦老板要给你发一个文件时，你发现你没有办法方便的传递到电脑上，或者在更多的场景下存在问题，都会让 Linux 的新用户们望而却步。
### 成也萧何败萧何
在 10 月 24 日这个程序员节上发布了 Linux QQ 2.0 版本让人觉得有点无厘头，甚至让人觉得可能仅仅是一个快闪活动，频繁的断线都让人担心是不是到了 25 日，可能 Linux QQ 就又不能用了。在 1024 程序员节的释出，使得 Linux QQ 可以以一个怀旧的形态重新出现在人们的眼前。但是，同样的，在这个节日的释出，也让人觉得这件事似乎并没有相信中的那么重视，对于 Linux QQ 的前景蒙上了一层阴影。
而且，腾讯并非一个慈善组织，对于腾讯这样的一个企业，是否会长期为一个很难产生现金流，而且小众的操作系统提供长期维护还尚未可知，更是让人无法相信 Linux QQ 的未来。
### 生态决定了操作系统的一切
近两年来，自主研发的操作系统不断的刷屏，我们也一次次为自主研发的操作系统而欢呼。但是，高潮之后，还能剩下来的是什么？
**我一直强调，操作系统卖的不是系统本身，而是卖因其产生的生态，由生态倒逼用户为系统本身付费**。就如同我尝试很多次从 iPhone 转回 Andorid ，从 macOS 转回 Windows，但是，也正如我自己每次失败后的总结一样，我没有办法完全抛弃掉 iPhone 、macOS，因为其所带来的生态是我无法迁移到 Android 上的，被操作系统所挟裹，不得不去面对的现实是：最终，我还是回到了 iPhone 所构建的生态。
对于 Linux 也是一样的，Linux 的服务端的用户诉求是明确的、简单直接的、绝大多数场景都可以被覆盖掉的。而桌面端的产品可能会有数万种不同类型的需求，这使得产品经理在进行设计时预见不了需求的问题，也就很正常的问题。
我们回过头去看，Linux 想要占领桌面市场还需要什么呢？需要的不仅仅是一个 Linux QQ，我们需要给更多人提供 Linux 上的微信、办公套件等等一系列软件。没有这些软件，我们就很难让用户迈过入门的第一关：**我如何登录 QQ /微信和我的同事、家人沟通**。如果他发现，我用了 Linux ，但是我却没有办法使用 QQ /微信进行沟通，那么我用 Linux 还有什么意义呢？
对于 Linux 来说，除了去适配这些我们所熟悉的软件以外，更是需要有厂商能够面向 Linux 开发出独占的杀手级用户，这样，才能够更好的去推动一个操作系统的发展。
### Linux 距离成为流行操作系统，还差多少个 QQ 微信
如果 Linux QQ 仍然继续更新，那对于 Linux 来说，是一大利好消息，一些做的好的、做的不好的应用，都可能会重新考虑创建自己的 Linux 版本。而过去，可能没有这样的机会。
你怎么看呢？
|
||||
Pylint：让你的 Python 代码保持一致
|
Moshe Zadka
|
https://opensource.com/article/19/10/python-pylint-introduction
|
当你想要争论代码复杂性时，Pylint 是你的朋友。
|
/data/attachment/album/201910/25/170108bq8kq28esj8q9eq4.jpg.thumb.jpg
|
/data/attachment/album/201910/25/170108bq8kq28esj8q9eq4.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Pylint"
] |
软件开发
|
{
"viewnum": 4609,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
当你想要争论代码复杂性时，Pylint 是你的朋友。
| 2019-10-25T17:01:05 | 2019-10-25T17:01:05 | 11,502 |
/article-11502-1.html
|
>
> 当你想要争论代码复杂性时，Pylint 是你的朋友。
>
>
>
Pylint 是更高层级的 Python 样式强制程序。而 [flake8](https://opensource.com/article/19/5/python-flake8) 和 [black](https://opensource.com/article/19/5/python-black) 检查的是“本地”样式：换行位置、注释的格式、发现注释掉的代码或日志格式中的错误做法之类的问题。
默认情况下，Pylint 非常激进。它将对每样东西都提供严厉的意见，从检查是否实际实现声明的接口到重构重复代码的可能性，这对新用户来说可能会很多。一种温和地将其引入项目或团队的方法是先关闭*所有*检查器，然后逐个启用检查器。如果你已经在使用 flake8、black 和 [mypy](https://opensource.com/article/19/5/python-mypy)，这尤其有用：Pylint 有相当多的检查器和它们在功能上重叠。
但是，Pylint 独有之处之一是能够强制执行更高级别的问题：例如，函数的行数或者类中方法的数量。
这些数字可能因项目而异，并且可能取决于开发团队的偏好。但是，一旦团队就参数达成一致，使用自动工具*强制化*这些参数非常有用。这是 Pylint 闪耀的地方。
### 配置 Pylint
要以空配置开始，请将 `.pylintrc` 设置为
```
[MESSAGES CONTROL]
disable=all
```
这将禁用所有 Pylint 消息。由于其中许多是冗余的，这是有道理的。在 Pylint 中，`message` 是一种特定的警告。
你可以通过运行 `pylint` 来确认所有消息都已关闭：
```
$ pylint <my package>
```
通常，向 `pylint` 命令行添加参数并不是一个好主意：配置 `pylint` 的最佳位置是 `.pylintrc`。为了使它做*一些*有用的事，我们需要启用一些消息。
要启用消息，在 `.pylintrc` 中的 `[MESSAGES CONTROL]` 下添加
```
enable=<message>,
...
```
对于看起来有用的“消息”（Pylint 称之为不同类型的警告）。我最喜欢的包括 `too-many-lines`、`too-many-arguments` 和 `too-many-branches`。所有这些会限制模块或函数的复杂性，并且无需进行人工操作即可客观地进行代码复杂度测量。
*检查器*是*消息*的来源：每条消息只属于一个检查器。许多最有用的消息都在[设计检查器](https://pylint.readthedocs.io/en/latest/technical_reference/features.html#design-checker)下。默认数字通常都不错，但要调整最大值也很简单：我们可以在 `.pylintrc` 中添加一个名为 `DESIGN` 的段。
```
[DESIGN]
max-args=7
max-locals=15
```
另一个有用的消息来源是“重构”检查器。我已启用一些最喜欢的消息有 `consider-using-dict-comprehension`、`stop-iteration-return`（它会查找正确的停止迭代的方式是 `return` 而使用了 `raise StopIteration` 的迭代器）和 `chained-comparison`，它将建议使用如 `1 <= x < 5`，而不是不太明显的 `1 <= x && 5 > 5` 的语法。
最后是一个在性能方面消耗很大的检查器，但它非常有用，就是 `similarities`。它会查找不同部分代码之间的复制粘贴来强制执行“不要重复自己”（DRY 原则）。它只启用一条消息：`duplicate-code`。默认的 “最小相似行数” 设置为 4。可以使用 `.pylintrc` 将其设置为不同的值。
```
[SIMILARITIES]
min-similarity-lines=3
```
### Pylint 使代码评审变得简单
如果你厌倦了需要指出一个类太复杂，或者两个不同的函数基本相同的代码评审，请将 Pylint 添加到你的[持续集成](https://opensource.com/business/15/7/six-continuous-integration-tools)配置中，并且只需要对项目复杂性准则的争论一次就行。
---
via: <https://opensource.com/article/19/10/python-pylint-introduction>
作者：[Moshe Zadka](https://opensource.com/users/moshez) 选题：[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 中的目录大小
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/find-get-size-of-directory-folder-linux-disk-usage-du-command/
|
我将向您展示如何使用各种选项获取文件夹大小。
|
/data/attachment/album/201910/25/171357abibvrznqqvqrrq7.jpg.thumb.jpg
|
/data/attachment/album/201910/25/171357abibvrznqqvqrrq7.jpg
| true | false | true |
lujun9972
|
lnrCoder
|
wxy
| false |
[
"磁盘",
"目录"
] |
技术
|
{
"viewnum": 14536,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我将向您展示如何使用各种选项获取文件夹大小。
| 2019-10-25T17:14:40 | 2019-10-25T17:14:40 | 11,503 |
/article-11503-1.html
|
你应该已经注意到，在 Linux 中使用 [ls 命令](https://www.2daygeek.com/linux-unix-ls-command-display-directory-contents/) 列出的目录内容中，目录的大小仅显示 4KB。这个大小正确吗？如果不正确，那它代表什么，又该如何获取 Linux 中的目录或文件夹大小？这是一个默认的大小，是用来存储磁盘上存储目录的元数据的大小。
Linux 上有一些应用程序可以 [获取目录的实际大小](https://www.2daygeek.com/how-to-get-find-size-of-directory-folder-linux/)。其中，磁盘使用率（`du`）命令已被 Linux 管理员广泛使用。
我将向您展示如何使用各种选项获取文件夹大小。
### 什么是 du 命令?
[du 命令](https://www.2daygeek.com/linux-check-disk-usage-files-directories-size-du-command/) 表示 <ruby> 磁盘使用率 <rt> Disk Usage </rt></ruby>。这是一个标准的 Unix 程序，用于估计当前工作目录中的文件空间使用情况。
它使用递归方式总结磁盘使用情况，以获取目录及其子目录的大小。
如同我说的那样, 使用 `ls` 命令时，目录大小仅显示 4KB。参见下面的输出。
```
$ ls -lh | grep ^d
drwxr-xr-x 3 daygeek daygeek 4.0K Aug 2 13:57 Bank_Details
drwxr-xr-x 2 daygeek daygeek 4.0K Mar 15 2019 daygeek
drwxr-xr-x 6 daygeek daygeek 4.0K Feb 16 2019 drive-2daygeek
drwxr-xr-x 13 daygeek daygeek 4.0K Jan 6 2019 drive-mageshm
drwxr-xr-x 15 daygeek daygeek 4.0K Sep 29 21:32 Thanu_Photos
```
### 1) 在 Linux 上如何只获取父目录的大小
使用以下 `du` 命令格式获取给定目录的总大小。在该示例中，我们将得到 `/home/daygeek/Documents` 目录的总大小。
```
$ du -hs /home/daygeek/Documents
或
$ du -h --max-depth=0 /home/daygeek/Documents/
20G /home/daygeek/Documents
```
详细说明：
* `du` – 这是一个命令
* `-h` – 以易读的格式显示大小 (例如 1K 234M 2G)
* `-s` – 仅显示每个参数的总数
* `--max-depth=N` – 目录的打印深度
### 2) 在 Linux 上如何获取每个目录的大小
使用以下 `du` 命令格式获取每个目录（包括子目录）的总大小。
在该示例中，我们将获得每个 `/home/daygeek/Documents` 目录及其子目录的总大小。
```
$ du -h /home/daygeek/Documents/ | sort -rh | head -20
20G /home/daygeek/Documents/
9.6G /home/daygeek/Documents/drive-2daygeek
6.3G /home/daygeek/Documents/Thanu_Photos
5.3G /home/daygeek/Documents/Thanu_Photos/Camera
5.3G /home/daygeek/Documents/drive-2daygeek/Thanu-videos
3.2G /home/daygeek/Documents/drive-mageshm
2.3G /home/daygeek/Documents/drive-2daygeek/Thanu-Photos
2.2G /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month
916M /home/daygeek/Documents/drive-mageshm/Tanisha
454M /home/daygeek/Documents/drive-mageshm/2g-backup
415M /home/daygeek/Documents/Thanu_Photos/WhatsApp Video
300M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Jan-2017
288M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Oct-2017
226M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Sep-2017
219M /home/daygeek/Documents/Thanu_Photos/WhatsApp Documents
213M /home/daygeek/Documents/drive-mageshm/photos
163M /home/daygeek/Documents/Thanu_Photos/WhatsApp Video/Sent
161M /home/daygeek/Documents/Thanu_Photos/WhatsApp Images
154M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/June-2017
150M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Nov-2016
```
### 3) 在 Linux 上如何获取每个目录的摘要
使用如下 `du` 命令格式仅获取每个目录的摘要。
```
$ du -hs /home/daygeek/Documents/* | sort -rh | head -10
9.6G /home/daygeek/Documents/drive-2daygeek
6.3G /home/daygeek/Documents/Thanu_Photos
3.2G /home/daygeek/Documents/drive-mageshm
756K /home/daygeek/Documents/Bank_Details
272K /home/daygeek/Documents/user-friendly-zorin-os-15-has-been-released-TouchInterface1.png
172K /home/daygeek/Documents/user-friendly-zorin-os-15-has-been-released-NightLight.png
164K /home/daygeek/Documents/ConfigServer Security and Firewall (csf) Cheat Sheet.pdf
132K /home/daygeek/Documents/user-friendly-zorin-os-15-has-been-released-Todo.png
112K /home/daygeek/Documents/user-friendly-zorin-os-15-has-been-released-ZorinAutoTheme.png
96K /home/daygeek/Documents/distro-info.xlsx
```
### 4) 在 Linux 上如何获取每个目录的不含子目录的大小
使用如下 `du` 命令格式来展示每个目录的总大小，不包括子目录。
```
$ du -hS /home/daygeek/Documents/ | sort -rh | head -20
5.3G /home/daygeek/Documents/Thanu_Photos/Camera
5.3G /home/daygeek/Documents/drive-2daygeek/Thanu-videos
2.3G /home/daygeek/Documents/drive-2daygeek/Thanu-Photos
1.5G /home/daygeek/Documents/drive-mageshm
831M /home/daygeek/Documents/drive-mageshm/Tanisha
454M /home/daygeek/Documents/drive-mageshm/2g-backup
300M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Jan-2017
288M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Oct-2017
253M /home/daygeek/Documents/Thanu_Photos/WhatsApp Video
226M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Sep-2017
219M /home/daygeek/Documents/Thanu_Photos/WhatsApp Documents
213M /home/daygeek/Documents/drive-mageshm/photos
163M /home/daygeek/Documents/Thanu_Photos/WhatsApp Video/Sent
154M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/June-2017
150M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Nov-2016
127M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Dec-2016
100M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Oct-2016
94M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Nov-2017
92M /home/daygeek/Documents/Thanu_Photos/WhatsApp Images
90M /home/daygeek/Documents/drive-2daygeek/Thanu-photos-by-month/Dec-2017
```
### 5) 在 Linux 上如何仅获取一级子目录的大小
如果要获取 Linux 上给定目录的一级子目录（包括其子目录）的大小，请使用以下命令格式。
```
$ du -h --max-depth=1 /home/daygeek/Documents/
3.2G /home/daygeek/Documents/drive-mageshm
4.0K /home/daygeek/Documents/daygeek
756K /home/daygeek/Documents/Bank_Details
9.6G /home/daygeek/Documents/drive-2daygeek
6.3G /home/daygeek/Documents/Thanu_Photos
20G /home/daygeek/Documents/
```
### 6) 如何在 du 命令输出中获得总计
如果要在 `du` 命令输出中获得总计，请使用以下 `du` 命令格式。
```
$ du -hsc /home/daygeek/Documents/* | sort -rh | head -10
20G total
9.6G /home/daygeek/Documents/drive-2daygeek
6.3G /home/daygeek/Documents/Thanu_Photos
3.2G /home/daygeek/Documents/drive-mageshm
756K /home/daygeek/Documents/Bank_Details
272K /home/daygeek/Documents/user-friendly-zorin-os-15-has-been-released-TouchInterface1.png
172K /home/daygeek/Documents/user-friendly-zorin-os-15-has-been-released-NightLight.png
164K /home/daygeek/Documents/ConfigServer Security and Firewall (csf) Cheat Sheet.pdf
132K /home/daygeek/Documents/user-friendly-zorin-os-15-has-been-released-Todo.png
112K /home/daygeek/Documents/user-friendly-zorin-os-15-has-been-released-ZorinAutoTheme.png
```
---
via: <https://www.2daygeek.com/find-get-size-of-directory-folder-linux-disk-usage-du-command/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lnrCoder](https://github.com/lnrCoder) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 GameHub 集中管理你 Linux 上的所有游戏
|
Ankush Das
|
https://itsfoss.com/gamehub/
|
GameHub 是为 Linux 发行版设计的一个桌面应用，它能让你“集中管理你的所有游戏”。
|
/data/attachment/album/201910/27/000309ippisos4osgpwsss.png.thumb.jpg
|
/data/attachment/album/201910/27/000309ippisos4osgpwsss.png
| true | false | true |
lujun9972
|
wenwensnow
|
wxy
| false |
[
"游戏",
"GameHub"
] |
分享
|
{
"viewnum": 5869,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
GameHub 是为 Linux 发行版设计的一个桌面应用，它能让你“集中管理你的所有游戏”。
| 2019-10-27T00:02:00 | 2019-10-27T00:02:00 | 11,504 |
/article-11504-1.html
|
你在 Linux 上是怎么[玩游戏的呢](https://itsfoss.com/linux-gaming-guide/)? 让我猜猜，要不就是从软件中心直接安装，要不就选 Steam、GOG、Humble Bundle 等平台，对吧？但是，如果你有多个游戏启动器和客户端，又要如何管理呢？好吧，对我来说这简直令人头疼 —— 这也是我发现 [GameHub](https://tkashkin.tk/projects/gamehub/) 这个应用之后，感到非常高兴的原因。
GameHub 是为 Linux 发行版设计的一个桌面应用，它能让你“集中管理你的所有游戏”。这听起来很有趣，是不是？下面让我来具体说明一下。
### 集中管理不同平台 Linux 游戏的 GameHub
让我们看看，对玩家来说，让 GameHub 成为一个[不可或缺的 Linux 应用](https://itsfoss.com/essential-linux-applications/)的功能，都有哪些。
#### Steam、GOG & Humble Bundle 支持
它支持 Steam、[GOG](https://www.gog.com/) 和 [Humble Bundle](https://www.humblebundle.com/monthly?partner=itsfoss) 账户整合。你可以登录你的 GameHub 账号，从而在你的库管理器中管理所有游戏。
对我来说，我在 Steam 上有很多游戏，Humble Bundle 上也有一些。我不能确保它支持所有平台，但可以确信的是，主流平台游戏是没有问题的。
#### 支持原生游戏
[有很多网站专门推荐 Linux 游戏，并支持下载](https://itsfoss.com/download-linux-games/)。你可以通过下载安装包，或者添加可执行文件，从而管理原生游戏。
可惜的是，现在无法在 GameHub 内搜索 Linux 游戏。如上图所示，你需要分别下载游戏，随后再将其添加到 GameHub 中。
#### 模拟器支持
用模拟器，你可以在 [Linux 上玩复古游戏](https://itsfoss.com/play-retro-games-linux/)。正如上图所示，你可以添加模拟器（并导入模拟的镜像）。
你可以在 [RetroArch](https://www.retroarch.com/) 查看已有的模拟器，但也能根据需求添加自定义模拟器。
#### 用户界面
当然，用户体验很重要。因此，探究下用户界面都有些什么，也很有必要。
我个人觉得，这一应用很容易使用，并且黑色主题是一个加分项。
#### 手柄支持
如果你习惯在 Linux 系统上用手柄玩游戏 —— 你可以轻松在设置里添加，启用或禁用它。
#### 多个数据提供商
因为它需要获取你的游戏信息（或元数据），也意味着它需要一个数据源。你可以看到下图列出的所有数据源。
这里你什么也不用做 —— 但如果你使用的是 steam 之外的其他平台，你需要为 [IDGB 生成一个 API 密钥](https://www.igdb.com/api)。
我建议只有出现 GameHub 中的提示/通知，或有些游戏在 GameHub 上没有任何描述/图片/状态时，再这么做。
#### 兼容性选项
你有不支持在 Linux 上运行的游戏吗？
不用担心，GameHub 上提供了多种兼容工具，如 Wine/Proton，你可以利用它们来玩游戏。
我们无法确定具体哪个兼容工具适用于你 —— 所以你需要自己亲自测试。然而，对许多游戏玩家来说，这的确是个很有用的功能。
### GameHub: 如何安装它呢？
首先，你可以直接在软件中心或者应用商店内搜索。 它在 “Pop!\_Shop” 之下。所以，它在绝大多数官方源中都能找到。
如果你在这些地方都没有找到，你可以手动添加源，并从终端上安装它，你需要输入以下命令：
```
sudo add-apt-repository ppa:tkashkin/gamehub
sudo apt update
sudo apt install com.github.tkashkin.gamehub
```
如果你遇到了 “add-apt-repository command not found” 这个错误，你可以看看，[add-apt-repository not found error.](https://itsfoss.com/add-apt-repository-command-not-found/)这篇文章，它能帮你解决这一问题。
这里还提供 AppImage 和 FlatPak 版本。 在[官网](https://tkashkin.tk/projects/gamehub/) 上，你可以针对找到其他 Linux 发行版的安装手册。
同时，你还可以从它的 [GitHub 页面](https://github.com/tkashkin/GameHub/releases)下载之前版本的安装包.
[GameHub](https://tkashkin.tk/projects/gamehub/)
### 如何在 GameHub 上管理你的游戏？
在启动程序后，你可以将自己的 Steam/GOG/Humble Bundle 账号添加进来。
对于 Steam，你需要在 Linux 发行版上安装 Steam 客户端。一旦安装完成，你可以轻松将账号中的游戏导入 GameHub。
对于 GOG & Humble Bundle，登录后，就能直接在 GameHub 上管理游戏了。
如果你想添加模拟器或者本地安装文件，点击窗口右上角的 “+” 按钮进行添加。
### 如何安装游戏？
对于 Steam 游戏，它会自动启动 Steam 客户端，从而下载/安装游戏（我希望之后安装游戏，可以不用启动 Steam！）
但对于 GOG/Humble Bundle，登录后就能直接、下载安装游戏。必要的话，对于那些不支持在 Linux 上运行的游戏，你可以使用兼容工具。
无论是模拟器游戏，还是本地游戏，只需添加安装包或导入模拟器镜像就可以了。这里没什么其他步骤要做。
### 注意
GameHub 是相当灵活的一个集中游戏管理应用。 用户界面和选项设置也相当直观。
你之前是否使用过这一应用呢？如果有，请在评论里写下你的感受。
而且，如果你想尝试一些与此功能相似的工具/应用，请务必告诉我们。
---
via: <https://itsfoss.com/gamehub/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 CentOS8/RHEL8 中配置 Rsyslog 服务器
|
James Kiarie
|
https://www.linuxtechi.com/configure-rsyslog-server-centos-8-rhel-8/
|
Rsyslog 是一个自由开源的日志记录程序，在 CentOS 8 和 RHEL 8 系统上默认可用。它提供了一种从客户端节点到单个中央服务器的“集中日志”的简单有效的方法。
|
/data/attachment/album/201910/27/062908v4nnzgf7bhnplgvg.jpg.thumb.jpg
|
/data/attachment/album/201910/27/062908v4nnzgf7bhnplgvg.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"日志",
"Rsyslog"
] |
系统运维
|
{
"viewnum": 9757,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Rsyslog 是一个自由开源的日志记录程序，在 CentOS 8 和 RHEL 8 系统上默认可用。它提供了一种从客户端节点到单个中央服务器的“集中日志”的简单有效的方法。
| 2019-10-27T06:29:00 | 2019-10-27T06:29:00 | 11,505 |
/article-11505-1.html
|
Rsyslog 是一个自由开源的日志记录程序，在 CentOS 8 和 RHEL 8 系统上默认可用。它提供了一种从客户端节点到单个中央服务器的“集中日志”的简单有效的方法。日志集中化有两个好处。首先，它简化了日志查看，因为系统管理员可以在一个中心节点查看远程服务器的所有日志，而无需登录每个客户端系统来检查日志。如果需要监视多台服务器，这将非常有用，其次，如果远程客户端崩溃，你不用担心丢失日志，因为所有日志都将保存在中心的 Rsyslog 服务器上。rsyslog 取代了仅支持 UDP 协议的 syslog。它以优异的功能扩展了基本的 syslog 协议，例如在传输日志时支持 UDP 和 TCP 协议，增强的过滤功能以及灵活的配置选项。让我们来探讨如何在 CentOS 8 / RHEL 8 系统中配置 Rsyslog 服务器。
### 预先条件
我们将搭建以下实验环境来测试集中式日志记录过程：
* Rsyslog 服务器 CentOS 8 Minimal IP 地址： 10.128.0.47
* 客户端系统 RHEL 8 Minimal IP 地址： 10.128.0.48
通过上面的设置，我们将演示如何设置 Rsyslog 服务器，然后配置客户端系统以将日志发送到 Rsyslog 服务器进行监视。
让我们开始！
### 在 CentOS 8 上配置 Rsyslog 服务器
默认情况下，Rsyslog 已安装在 CentOS 8 / RHEL 8 服务器上。要验证 Rsyslog 的状态，请通过 SSH 登录并运行以下命令：
```
$ systemctl status rsyslog
```
示例输出:
如果由于某种原因 Rsyslog 不存在，那么可以使用以下命令进行安装：
```
$ sudo yum install rsyslog
```
接下来，你需要修改 Rsyslog 配置文件中的一些设置。打开配置文件：
```
$ sudo vim /etc/rsyslog.conf
```
滚动并取消注释下面的行，以允许通过 UDP 协议接收日志：
```
module(load="imudp") # needs to be done just once
input(type="imudp" port="514")
```
同样，如果你希望启用 TCP rsyslog 接收，请取消注释下面的行：
```
module(load="imtcp") # needs to be done just once
input(type="imtcp" port="514")
```
保存并退出配置文件。
要从客户端系统接收日志，我们需要在防火墙上打开 Rsyslog 默认端口 514。为此，请运行：
```
# sudo firewall-cmd --add-port=514/tcp --zone=public --permanent
```
接下来，重新加载防火墙保存更改：
```
# sudo firewall-cmd --reload
```
示例输出：
接下来，重启 Rsyslog 服务器:
```
$ sudo systemctl restart rsyslog
```
要在启动时运行 Rsyslog，运行以下命令：
```
$ sudo systemctl enable rsyslog
```
要确认 Rsyslog 服务器正在监听 514 端口，请使用 `netstat` 命令，如下所示：
```
$ sudo netstat -pnltu
```
示例输出：
完美！我们已经成功配置了 Rsyslog 服务器来从客户端系统接收日志。
要实时查看日志消息，请运行以下命令：
```
$ tail -f /var/log/messages
```
现在开始配置客户端系统。
### 在 RHEL 8 上配置客户端系统
与 Rsyslog 服务器一样，登录并通过以下命令检查 rsyslog 守护进程是否正在运行：
```
$ sudo systemctl status rsyslog
```
示例输出：
接下来，打开 rsyslog 配置文件：
```
$ sudo vim /etc/rsyslog.conf
```
在文件末尾，添加以下行：
```
*.* @10.128.0.47:514 # Use @ for UDP protocol
*.* @@10.128.0.47:514 # Use @@ for TCP protocol
```
保存并退出配置文件。就像 Rsyslog 服务器一样，打开 514 端口，这是防火墙上的默认 Rsyslog 端口：
```
$ sudo firewall-cmd --add-port=514/tcp --zone=public --permanent
```
接下来，重新加载防火墙以保存更改：
```
$ sudo firewall-cmd --reload
```
接下来，重启 rsyslog 服务：
```
$ sudo systemctl restart rsyslog
```
要在启动时运行 Rsyslog，请运行以下命令：
```
$ sudo systemctl enable rsyslog
```
### 测试日志记录操作
已经成功安装并配置 Rsyslog 服务器和客户端后，就该验证你的配置是否按预期运行了。
在客户端系统上，运行以下命令：
```
# logger "Hello guys! This is our first log"
```
现在进入 Rsyslog 服务器并运行以下命令来实时查看日志消息：
```
# tail -f /var/log/messages
```
客户端系统上命令运行的输出显示在了 Rsyslog 服务器的日志中，这意味着 Rsyslog 服务器正在接收来自客户端系统的日志：
就是这些了！我们成功设置了 Rsyslog 服务器来接收来自客户端系统的日志信息。
---
via: <https://www.linuxtechi.com/configure-rsyslog-server-centos-8-rhel-8/>
作者：[James Kiarie](https://www.linuxtechi.com/author/james/) 选题：[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/) 荣誉推出
|
如何使用物联网设备来确保儿童安全？
|
Andrew Carroll
|
https://opensourceforu.com/2019/10/how-to-use-iot-devices-to-keep-children-safe/
|
物联网设备提供的好处很多。举例来说，父母可以远程监控自己的孩子，而又不会显得太霸道。因此，儿童在拥有安全环境的同时也会有空间和自由让自己变得独立。
|
/data/attachment/album/201910/27/064228phqcuk9cuggkkk1t.jpg.thumb.jpg
|
/data/attachment/album/201910/27/064228phqcuk9cuggkkk1t.jpg
| true | false | true |
lujun9972
|
Morisun029
|
wxy
| false |
[
"IoT"
] |
观点
|
{
"viewnum": 3747,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
物联网设备提供的好处很多。举例来说，父母可以远程监控自己的孩子，而又不会显得太霸道。因此，儿童在拥有安全环境的同时也会有空间和自由让自己变得独立。
| 2019-10-27T06:42:26 | 2019-10-27T06:42:26 | 11,506 |
/article-11506-1.html
|
IoT （物联网）设备正在迅速改变我们的生活。这些设备无处不在，从我们的家庭到其它行业。根据一些预测数据，到 2020 年，将会有 100 亿个 IoT 设备。到 2025 年，该数量将增长到 220 亿。目前，物联网已经在很多领域得到了应用，包括智能家居、工业生产过程、农业甚至医疗保健领域。伴随着如此广泛的应用，物联网显然已经成为近年来的热门话题之一。
多种因素促成了物联网设备在多个学科的爆炸式增长。这其中包括低成本处理器和无线连接的的可用性，以及开源平台的信息交流推动了物联网领域的创新。与传统的应用程序开发相比，物联网设备的开发成指数级增长，因为它的资源是开源的。
在解释如何使用物联网设备来保护儿童之前，必须对物联网技术有基本的了解。
### IoT 设备是什么？
IoT 设备是指那些在没有人类参与的情况下彼此之间可以通信的设备。因此，许多专家并不将智能手机和计算机视为物联网设备。此外，物联网设备必须能够收集数据并且能将收集到的数据传送到其他设备或云端进行处理。
然而，在某些领域中，我们需要探索物联网的潜力。儿童往往是脆弱的，他们很容易成为犯罪分子和其他蓄意伤害者的目标。无论在物理世界还是数字世界中，儿童都很容易面临犯罪的威胁。因为父母不能始终亲自到场保护孩子；这就是为什么需要监视工具了。
除了适用于儿童的可穿戴设备外，还有许多父母监视应用程序，例如 Xnspy，可实时监控儿童并提供信息的实时更新。这些工具可确保儿童安全。可穿戴设备确保儿童身体上的安全性，而家长监控应用可确保儿童的上网安全。
由于越来越多的孩子花费时间在智能手机上，毫无意外地，他们也就成为诈骗分子的主要目标。此外，由于恋童癖、网络自夸和其他犯罪在网络上的盛行，儿童也有可能成为网络欺凌的目标。
这些解决方案够吗？我们需要找到物联网解决方案，以确保孩子们在网上和线下的安全。在当代，我们如何确保孩子的安全？我们需要提出创新的解决方案。 物联网可以帮助保护孩子在学校和家里的安全。
### 物联网的潜力
物联网设备提供的好处很多。举例来说，父母可以远程监控自己的孩子，而又不会显得太霸道。因此，儿童在拥有安全环境的同时也会有空间和自由让自己变得独立。
而且，父母也不必在为孩子的安全而担忧。物联网设备可以提供 7x24 小时的信息更新。像 Xnspy 之类的监视应用程序在提供有关孩子的智能手机活动信息方面更进了一步。随着物联网设备变得越来越复杂，拥有更长使用寿命的电池只是一个时间问题。诸如位置跟踪器之类的物联网设备可以提供有关孩子下落的准确详细信息，所以父母不必担心。
虽然可穿戴设备已经非常好了，但在确保儿童安全方面，这些通常还远远不够。因此，要为儿童提供安全的环境，我们还需要其他方法。许多事件表明，儿童在学校比其他任何公共场所都容易受到攻击。因此，学校需要采取安全措施，以确保儿童和教师的安全。在这一点上，物联网设备可用于检测潜在威胁并采取必要的措施来防止攻击。威胁检测系统包括摄像头。系统一旦检测到威胁，便可以通知当局，如一些执法机构和医院。智能锁等设备可用于封锁学校（包括教室），来保护儿童。除此之外，还可以告知父母其孩子的安全，并立即收到有关威胁的警报。这将需要实施无线技术，例如 Wi-Fi 和传感器。因此，学校需要制定专门用于提供教室安全性的预算。
智能家居实现拍手关灯，也可以让你的家庭助手帮你关灯。同样，物联网设备也可用在屋内来保护儿童。在家里，物联网设备（例如摄像头）为父母在照顾孩子时提供 100％ 的可见性。当父母不在家里时，可以使用摄像头和其他传感器检测是否发生了可疑活动。其他设备（例如连接到这些传感器的智能锁）可以锁门和窗，以确保孩子们的安全。
同样，可以引入许多物联网解决方案来确保孩子的安全。
### 有多好就有多坏
物联网设备中的传感器会创建大量数据。数据的安全性是至关重要的一个因素。收集的有关孩子的数据如果落入不法分子手中会存在危险。因此，需要采取预防措施。IoT 设备中泄露的任何数据都可用于确定行为模式。因此，必须对提供不违反用户隐私的安全物联网解决方案投入资金。
IoT 设备通常连接到 Wi-Fi，用于设备之间传输数据。未加密数据的不安全网络会带来某些风险。这样的网络很容易被窃听。黑客可以使用此类网点来入侵系统。他们还可以将恶意软件引入系统，从而使系统变得脆弱、易受攻击。此外，对设备和公共网络（例如学校的网络）的网络攻击可能导致数据泄露和私有数据盗用。 因此，在实施用于保护儿童的物联网解决方案时，保护网络和物联网设备的总体计划必须生效。
物联网设备保护儿童在学校和家里的安全的潜力尚未发现有什么创新。我们需要付出更多努力来保护连接 IoT 设备的网络安全。此外，物联网设备生成的数据可能落入不法分子手中，从而造成更多麻烦。因此，这是物联网安全至关重要的一个领域。
---
via: <https://opensourceforu.com/2019/10/how-to-use-iot-devices-to-keep-children-safe/>
作者：[Andrew Carroll](https://opensourceforu.com/author/andrew-carroll/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Morisun029](https://github.com/Morisun029) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
那个你们眼中的硬件厂商，其实已经是云计算的急先锋
|
老王
|
可能在很多人眼里，戴尔还是那个生产、销售硬件服务器的戴尔，但是很多人不知道的是，戴尔已经在云计算领域布局多年。
|
/data/attachment/album/201910/27/145726b67lqu33t4a32tqq.jpg.thumb.jpg
|
/data/attachment/album/201910/27/145726b67lqu33t4a32tqq.jpg
| true | false | false | false |
[
"戴尔",
"混合云"
] |
观点
|
{
"viewnum": 3286,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
可能在很多人眼里，戴尔还是那个生产、销售硬件服务器的戴尔，但是很多人不知道的是，戴尔已经在云计算领域布局多年。
| 2019-10-27T15:01:29 | 2019-10-27T15:01:29 | 11,508 |
/article-11508-1.html
|
从业计算机行业以来，我接触过很多计算机硬件厂商，不知自何时开始，从我们的身边的个人电脑到企业级的服务器和存储设备，越来越多的见到了戴尔的身影。就在我前两天参加的戴尔科技峰会的一个媒体群访会上，戴尔科技集团全球副总裁、大中华区数据中心销售总经理孔大勇先生就笑言，“在座的诸位中有 15 台笔记本电脑，其中 9 台是戴尔的”。更别说如浩如烟海般充斥在数据中心的各式戴尔设备。
可能在很多人眼里，戴尔还是那个生产、销售硬件服务器的戴尔，但是很多人不知道的是，戴尔已经在云计算领域布局多年。
云计算这个 IT 时髦词虽然已经提出很久了，但是令人有些意外的是，这个时髦词居然历久弥新，在 IT 领域这么变化日新月异的行业中，还能不断焕发新的变化。从早期的分布式计算、虚拟技术，到现在的容器技术，从公有云、私有云，到混合云、多云，不经意间，一篇篇新的技术篇章掀过，我们所面临的已经是一个崭新的云时代。
这次有幸参加戴尔科技峰会 2019，让我恍若置身一场云原生大会，除了很多的新技术突破和硬件新品发布，戴尔也在云计算领域取得了长足的发展。由于我们长期以来一直关注云技术的发展，所以我专门着眼于观察戴尔在云计算方面的新变化，下面就让我来给大家介绍一下本次大会中我的感受。
### 戴尔的云端之路
自 2010 年戴尔发布<ruby> 高效企业生态系统 <rp> （ </rp> <rt> Efficient Enterprise Ecosystem </rt> <rp> ） </rp></ruby>（E3）的云计算战略以后，就开始不断布局云计算生态，将戴尔从一个传统的计算机硬件企业，转变成为一个软硬件两把抓的云计算强企。
得益于多年企业级硬件的产品与设备，戴尔从一开始就为其在企业级场景下的硬件设施打好了基础，而近年来，戴尔也不断并购了一些企业，并以此为契机，增加了自己在云计算领域的能力。
近年来，戴尔收购了 EMC，从而掌握了虚拟化领域巨头 VMWare，又在其后收购了Pivotal （后者是顶尖的云计算平台公司，我们所熟悉的 12306 的架构中，就有一大部分在使用 Pivotal 的产品），不断增强自己在云计算领域的能力，并借助于自己在传统硬件领域的强项，去改变企业、政府对于云计算的认识，协助他们完成数字化转型。同时，可能会令很多人意外的是，戴尔也是 Kubernetes 项目代码贡献度全球第二的企业，拥有丰富的 Kubernetes 开发人才。
和我们所熟悉的很多公有云厂商不同，他们很多是从开始做云的时候，就决定要做公有云，希望去服务尽可能多的用户，服务更多的中长尾用户。戴尔则是更关注于企业级市场，关注企业用户的需求。当然，这也是源自于戴尔在服务器等企业级市场的深耕，能够精确把握企业对于云计算的需求。
### 源自不同认识的混合云
在不断服务企业级客户的过程中，戴尔收集到了大量的用户反馈，企业级用户往往不同于个人用户，将自己的所有业务都集中在一个平台上，企业级客户会同时使用两家甚至是更多的云平台，以确保自己的业务不会因为某一家的云服务出现问题而整体业务崩盘。单一平台所构建的信息孤岛对于企业级用户来说，是一个很大的风险，这也是为什么近些年来，我们看到 Kubernetes 的不断发展。企业面临着信息孤岛的问题而不知如何解决，Kubernetes 是一个标准化的云计算解决方案，帮助他们提升产品和能力的可迁移性，而戴尔则对该问题提供了更进一步的解决方案。
前面我们提到，VMWare 目前是属于戴尔公司的，而 VMWare 本身，是目前全球用量最大的云计算虚拟化平台，你所知道或不知道的云计算平台，他们的背后运转的很多都是 VMWare 计算平台。得益于 VMWare 多年的积累，戴尔拥有丰富的私有云建设经验，可以在企业现有的基础设施上快速构建起一套能力强大的私有云体系。同时，因为不少云计算平台使用的也是 VMWare，使得企业自行构建的私有云能够更加轻松的与使用了 VMWare 的公有云结合，构建出一体化体验的云计算平台，让用户可以在一个平台上调度和管理多个不同的云计算平台，在这个平台上做计算、做数据挖掘、做资源调度，帮助企业更加简单的构建私有云。
这样构建出的私有云，拥有真正意义上的“混合”云的能力，而不再是仅仅与某一家云计算厂商提供的能力所结合，它可以让你同时和多个不同的云计算平台对接，还可以和你自己企业内部构建的私有云所结合，让不同云计算平台的业务可以通过戴尔所提供的服务和产品无缝对接，让业务正常运转。
### VCF 如何解决问题
由我们所熟悉的一些云计算公司，诸如 AWS、Azure、Google ，以及全球 4000 多家 VCPP（VMware Cloud Provider Program）项目成员所组成的VCF（VMware Cloud Foundation）建立起一套云计算基础设施的标准，都采用统一的 VCF 作为其标准，构建自己的云计算服务。而基于VMware最佳实践来搭建的软件定义的数据中心，其中所有的云都是基于同一个标准、同一个架构，其中的产品也就可以随意的在不同的云计算平台中任意迁移。
对于企业来说，VCF 的存在大大降低了其产品在不同服务商之间切换的成本，企业可以根据自己的需求，随意的在其所使用的几个云服务商之间进行切换，甚至是切换到私有云上！相比于我们熟悉的 Kubernetes，VCF 在易用性上的投入，更是让企业可以简单的实现业务需求，支撑业务的整体运转。
### SDDC 的未来
SDDC 是 VCF 的一个产品组件，想来这个词去描述戴尔的混合云战略真是再准确不过了。
什么是 SDDC？和我们所熟悉的 SDN（<ruby> 软件定义网络 <rp> （ </rp> <rt> Software-defined Network </rt> <rp> ） </rp></ruby>）类似，SDDC 就是<ruby> 软件定义的数据中心 <rp> （ </rp> <rt> Software-Defined DataCenter </rt> <rp> ） </rp></ruby>，以软件的方式来定义数据中心。而能够做到这些，源自于戴尔自己多年制作企业级服务器和其所收购的 VMWare 多年来在虚拟化领域的投入。VMware 目前是全球私有云环境里面市场占有率体量也是最大的。和其他云计算厂商相比，戴尔拥有业界体量最大、份额最高、方案最全、价值最高的方案，可以满足用户的不同场景下的需求。
在戴尔看来，未来企业级云计算的市场会逐渐归一，所有的公有云也好、私有云也好，终将会回归到混合云的模式，因为企业不可能将所有的核心数据都交付给云计算厂商，他们需要一个私有云，帮助承载和处理企业内部的一些机密数据。而私有云和公有云的对接，就会逐渐成为一个大的问题。做虚拟化出身的 VMWare 帮助戴尔解决了自己的问题，提出了 SDDC 的方式，来完成这个业务需求，并基于 VMWare 多年的积累，为 SDDC 加入大量云计算企业的支持，为客户拉了一针强心剂。
### 在中国，为中国
在过去的数年里，戴尔不但在技术研究方面深入到云计算行业，也将自己的云计算产品推向市场，接受市场的考验。
比如说，戴尔近几年借助于区域服务商，将其云计算的产品铺设到政府和企业场景中，帮助他们完成信息化、数字化。
很多企业和部门内部的基础设施虽然投入昂贵，但是，由于维护和管理不善，从而导致大量的病毒、木马潜伏在服务器内，占用了设备性能，并造成了数据泄露和安全隐患。此外，也因为基础设施维护的不完善，没有办法有效利用基础设施资源，更谈不上数据的共享。同时导致了各部门都需要自行建设基础设施，造成了大量的基础设施和资源的浪费，数据中心建设标准参差不齐，无法保证数据的安全和业务的稳定，为服务埋下了隐患。
引入戴尔的混合云方案以后，机构对机房进行统一，建设一个主数据中心，从而完成管理集群、高性能集群、vSAN 集群等，帮助他们构建了一套性能良好、基础设施完备的内部云方案，同时，得益于 VMWare 本身基础设施建设的能力，还引入了 vSAN，借助其拓展能力，实现了双活的副数据中心的构建，以确保数据的安全和业务的运转。
借助不断推动企业、政府的数字化、信息化，戴尔实现了自己在几年前定下的诺言，“在中国、为中国”，帮助中国变得越来越好。
### 结语
这一次的戴尔科技峰会让我大开眼界，过去那个只做硬件的戴尔，如今不仅做了云，还做取得了长足的发展，站在了云计算技术的前沿，不知道未来，戴尔还能够为我们带来什么更加亮眼的产品？
|
||||
随着 Debian 10.1 “Buster” 的发布，MX Linux 19 也发布了
|
Ankush Das
|
https://itsfoss.com/mx-linux-19/
|
MX Linux 19 带来了许多重大改进和变更。在这里，我们将看一下主要亮点。
|
/data/attachment/album/201910/28/005713x1p1yyzja2tyxjn1.jpg.thumb.jpg
|
/data/attachment/album/201910/28/005713x1p1yyzja2tyxjn1.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Debian"
] |
新闻
|
{
"viewnum": 4574,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "59.41.206.1",
"message": "MX Linux排行都是刷的。要说最好的发行版还是Manjaro( ￣▽￣)σ",
"username": "来自广东广州的 Chrome 68.0|Android 5.0 用户",
"date": "2019-10-28T18:52:01"
}
] |
[
{
"raid": 11071,
"displayorder": 0
}
] |
MX Linux 19 带来了许多重大改进和变更。在这里，我们将看一下主要亮点。
| 2019-10-28T00:57:10 | 2019-10-28T00:57:10 | 11,509 |
/article-11509-1.html
|
MX Linux 18 是我在[最佳 Linux 发行版](/article-11411-1.html)中的主要推荐的发行版之一，特别是当你在考虑 Ubuntu 以外的发行版时。
它基于 Debian 9.6 “Stretch”，具有令人难以置信的快速流畅的体验。
现在，作为该发行版的主要升级版本，MX Linux 19 带来了许多重大改进和变更。在这里，我们将看一下主要亮点。
### MX Linux 19 中的新功能
#### Debian 10 “Buster”
这个值得一提，因为 Debian 10 实际上是 MX Linux 18 所基于的 Debian 9.6 “Stretch” 的主要升级。
如果你对 Debian 10 “Buster” 的变化感到好奇，建议你阅读有关 [Debian 10 “Buster” 的新功能](/article-11071-1.html)的文章。
#### Xfce 桌面 4.14
[Xfce 4.14](https://xfce.org/about/news) 正是 Xfce 开发团队提供的最新产品。就个人而言，我不是 Xfce 桌面环境的粉丝，但是当你在 Linux 发行版（尤其是 MX Linux 19）上使用它时，它超快的性能会让你惊叹。
或许你会感兴趣，我们也有一个快速指南来帮助你[自定义 Xfce](https://itsfoss.com/customize-xfce/)。
#### 升级的软件包及最新的 Debian 内核 4.19
除了 [GIMP](https://itsfoss.com/gimp-2-10-release/)、MESA、Firefox 等的更新软件包之外，它还随附有 Debian “Buster” 可用的最新内核 4.19。
#### 升级的 MX 系列应用
如果你以前使用过 MX Linux，则可能会知道它已经预装了有用的 MX 系列应用，可以帮助你快速完成更多工作。
像 MX-installer 和 MX-packageinstaller 这样的应用程序得到了显著改进。
除了这两个以外，所有其他 MX 工具也已不同程度的进行了更新和修复错误、添加了新的翻译（或只是改善了用户体验）。
#### 其它改进
考虑到这是一次重大升级，很明显，底层的更改要多于表面（包括最新的 antiX live 系统更新）。
你可以在他们的[官方公告](https://mxlinux.org/blog/mx-19-patito-feo-released/)中查看更多详细信息。你还可以从开发人员那里观看以下视频，它介绍了 MX Linux 19 中的所有新功能：
### 获取 MX Linux 19
即使是你现在正在使用 MX Linux 18 版本，你也[无法](https://mxlinux.org/migration/)升级到 MX Linux 19。你需要像其他人一样进行全新安装。
你可以从此页面下载 MX Linux 19：
* [下载 MX Linux 19](https://mxlinux.org/download-links/)
### 结语
在 MX Linux 18 上，我在使用 WiFi 适配器时遇到了问题，通过[论坛](https://forum.mxlinux.org/viewtopic.php?t=52201)解决了该问题，但看来 MX Linux 19 仍未解决该问题。因此，如果你在安装 MX Linux 19 之后遇到了相同的问题，你可能想要查看一下我的[论坛帖子](https://forum.mxlinux.org/viewtopic.php?t=52201)。
如果你使用的是 MX Linux 18，那么这绝对是一个令人印象深刻的升级。
你尝试过了吗？你对新的 MX Linux 19 版本有何想法？让我知道你在以下评论中的想法。
---
via: <https://itsfoss.com/mx-linux-19/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[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/) 荣誉推出
|
构建一个即时消息应用（二）：OAuth
|
Nicolás Parada
|
https://nicolasparada.netlify.com/posts/go-messenger-oauth/
|
在这篇帖子中，我们将会通过为应用添加社交登录功能进入后端开发。
|
/data/attachment/album/201910/28/070221l7wmy37l9llsl23z.jpg.thumb.jpg
|
/data/attachment/album/201910/28/070221l7wmy37l9llsl23z.jpg
| true | false | true |
lujun9972
|
PsiACE
|
wxy
| false |
[
"即时消息"
] |
软件开发
|
{
"viewnum": 5861,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11396,
"displayorder": 0
},
{
"raid": 12056,
"displayorder": 0
}
] |
在这篇帖子中，我们将会通过为应用添加社交登录功能进入后端开发。
| 2019-10-28T07:03:29 | 2019-10-28T07:03:29 | 11,510 |
/article-11510-1.html
|
[上一篇：模式](/article-11396-1.html)。
在这篇帖子中，我们将会通过为应用添加社交登录功能进入后端开发。
社交登录的工作方式十分简单：用户点击链接，然后重定向到 GitHub 授权页面。当用户授予我们对他的个人信息的访问权限之后，就会重定向回登录页面。下一次尝试登录时，系统将不会再次请求授权，也就是说，我们的应用已经记住了这个用户。这使得整个登录流程看起来就和你用鼠标单击一样快。
如果进一步考虑其内部实现的话，过程就会变得复杂起来。首先，我们需要注册一个新的 [GitHub OAuth 应用](https://github.com/settings/applications/new)。
这一步中，比较重要的是回调 URL。我们将它设置为 `http://localhost:3000/api/oauth/github/callback`。这是因为，在开发过程中，我们总是在本地主机上工作。一旦你要将应用交付生产，请使用正确的回调 URL 注册一个新的应用。
注册以后，你将会收到“客户端 id”和“安全密钥”。安全起见，请不要与任何人分享他们 ?
顺便让我们开始写一些代码吧。现在，创建一个 `main.go` 文件：
```
package main
import (
"database/sql"
"fmt"
"log"
"net/http"
"net/url"
"os"
"strconv"
"github.com/gorilla/securecookie"
"github.com/joho/godotenv"
"github.com/knq/jwt"
_ "github.com/lib/pq"
"github.com/matryer/way"
"golang.org/x/oauth2"
"golang.org/x/oauth2/github"
)
var origin *url.URL
var db *sql.DB
var githubOAuthConfig *oauth2.Config
var cookieSigner *securecookie.SecureCookie
var jwtSigner jwt.Signer
func main() {
godotenv.Load()
port := intEnv("PORT", 3000)
originString := env("ORIGIN", fmt.Sprintf("http://localhost:%d/", port))
databaseURL := env("DATABASE_URL", "postgresql://root@127.0.0.1:26257/messenger?sslmode=disable")
githubClientID := os.Getenv("GITHUB_CLIENT_ID")
githubClientSecret := os.Getenv("GITHUB_CLIENT_SECRET")
hashKey := env("HASH_KEY", "secret")
jwtKey := env("JWT_KEY", "secret")
var err error
if origin, err = url.Parse(originString); err != nil || !origin.IsAbs() {
log.Fatal("invalid origin")
return
}
if i, err := strconv.Atoi(origin.Port()); err == nil {
port = i
}
if githubClientID == "" || githubClientSecret == "" {
log.Fatalf("remember to set both $GITHUB_CLIENT_ID and $GITHUB_CLIENT_SECRET")
return
}
if db, err = sql.Open("postgres", databaseURL); err != nil {
log.Fatalf("could not open database connection: %v\n", err)
return
}
defer db.Close()
if err = db.Ping(); err != nil {
log.Fatalf("could not ping to db: %v\n", err)
return
}
githubRedirectURL := *origin
githubRedirectURL.Path = "/api/oauth/github/callback"
githubOAuthConfig = &oauth2.Config{
ClientID: githubClientID,
ClientSecret: githubClientSecret,
Endpoint: github.Endpoint,
RedirectURL: githubRedirectURL.String(),
Scopes: []string{"read:user"},
}
cookieSigner = securecookie.New([]byte(hashKey), nil).MaxAge(0)
jwtSigner, err = jwt.HS256.New([]byte(jwtKey))
if err != nil {
log.Fatalf("could not create JWT signer: %v\n", err)
return
}
router := way.NewRouter()
router.HandleFunc("GET", "/api/oauth/github", githubOAuthStart)
router.HandleFunc("GET", "/api/oauth/github/callback", githubOAuthCallback)
router.HandleFunc("GET", "/api/auth_user", guard(getAuthUser))
log.Printf("accepting connections on port %d\n", port)
log.Printf("starting server at %s\n", origin.String())
addr := fmt.Sprintf(":%d", port)
if err = http.ListenAndServe(addr, router); err != nil {
log.Fatalf("could not start server: %v\n", err)
}
}
func env(key, fallbackValue string) string {
v, ok := os.LookupEnv(key)
if !ok {
return fallbackValue
}
return v
}
func intEnv(key string, fallbackValue int) int {
v, ok := os.LookupEnv(key)
if !ok {
return fallbackValue
}
i, err := strconv.Atoi(v)
if err != nil {
return fallbackValue
}
return i
}
```
安装依赖项：
```
go get -u github.com/gorilla/securecookie
go get -u github.com/joho/godotenv
go get -u github.com/knq/jwt
go get -u github.com/lib/pq
ge get -u github.com/matoous/go-nanoid
go get -u github.com/matryer/way
go get -u golang.org/x/oauth2
```
我们将会使用 `.env` 文件来保存密钥和其他配置。请创建这个文件，并保证里面至少包含以下内容：
```
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
我们还要用到的其他环境变量有：
* `PORT`：服务器运行的端口，默认值是 `3000`。
* `ORIGIN`：你的域名，默认值是 `http://localhost:3000/`。我们也可以在这里指定端口。
* `DATABASE_URL`：Cockroach 数据库的地址。默认值是 `postgresql://root@127.0.0.1:26257/messenger?sslmode=disable`。
* `HASH_KEY`：用于为 cookie 签名的密钥。没错，我们会使用已签名的 cookie 来确保安全。
* `JWT_KEY`：用于签署 JSON <ruby> 网络令牌 <rt> Web Token </rt></ruby>的密钥。
因为代码中已经设定了默认值，所以你也不用把它们写到 `.env` 文件中。
在读取配置并连接到数据库之后，我们会创建一个 OAuth 配置。我们会使用 `ORIGIN` 信息来构建回调 URL（就和我们在 GitHub 页面上注册的一样）。我们的数据范围设置为 “read:user”。这会允许我们读取公开的用户信息，这里我们只需要他的用户名和头像就够了。然后我们会初始化 cookie 和 JWT 签名器。定义一些端点并启动服务器。
在实现 HTTP 处理程序之前，让我们编写一些函数来发送 HTTP 响应。
```
func respond(w http.ResponseWriter, v interface{}, statusCode int) {
b, err := json.Marshal(v)
if err != nil {
respondError(w, fmt.Errorf("could not marshal response: %v", err))
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(statusCode)
w.Write(b)
}
func respondError(w http.ResponseWriter, err error) {
log.Println(err)
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
}
```
第一个函数用来发送 JSON，而第二个将错误记录到控制台并返回一个 `500 Internal Server Error` 错误信息。
### OAuth 开始
所以，用户点击写着 “Access with GitHub” 的链接。该链接指向 `/api/oauth/github`，这将会把用户重定向到 github。
```
func githubOAuthStart(w http.ResponseWriter, r *http.Request) {
state, err := gonanoid.Nanoid()
if err != nil {
respondError(w, fmt.Errorf("could not generte state: %v", err))
return
}
stateCookieValue, err := cookieSigner.Encode("state", state)
if err != nil {
respondError(w, fmt.Errorf("could not encode state cookie: %v", err))
return
}
http.SetCookie(w, &http.Cookie{
Name: "state",
Value: stateCookieValue,
Path: "/api/oauth/github",
HttpOnly: true,
})
http.Redirect(w, r, githubOAuthConfig.AuthCodeURL(state), http.StatusTemporaryRedirect)
}
```
OAuth2 使用一种机制来防止 CSRF 攻击，因此它需要一个“状态”（`state`）。我们使用 `Nanoid()` 来创建一个随机字符串，并用这个字符串作为状态。我们也把它保存为一个 cookie。
### OAuth 回调
一旦用户授权我们访问他的个人信息，他将会被重定向到这个端点。这个 URL 的查询字符串上将会包含状态（`state`）和授权码（`code`）： `/api/oauth/github/callback?state=&code=`。
```
const jwtLifetime = time.Hour * 24 * 14
type GithubUser struct {
ID int `json:"id"`
Login string `json:"login"`
AvatarURL *string `json:"avatar_url,omitempty"`
}
type User struct {
ID string `json:"id"`
Username string `json:"username"`
AvatarURL *string `json:"avatarUrl"`
}
func githubOAuthCallback(w http.ResponseWriter, r *http.Request) {
stateCookie, err := r.Cookie("state")
if err != nil {
http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
return
}
http.SetCookie(w, &http.Cookie{
Name: "state",
Value: "",
MaxAge: -1,
HttpOnly: true,
})
var state string
if err = cookieSigner.Decode("state", stateCookie.Value, &state); err != nil {
http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
return
}
q := r.URL.Query()
if state != q.Get("state") {
http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
return
}
ctx := r.Context()
t, err := githubOAuthConfig.Exchange(ctx, q.Get("code"))
if err != nil {
respondError(w, fmt.Errorf("could not fetch github token: %v", err))
return
}
client := githubOAuthConfig.Client(ctx, t)
resp, err := client.Get("https://api.github.com/user")
if err != nil {
respondError(w, fmt.Errorf("could not fetch github user: %v", err))
return
}
var githubUser GithubUser
if err = json.NewDecoder(resp.Body).Decode(&githubUser); err != nil {
respondError(w, fmt.Errorf("could not decode github user: %v", err))
return
}
defer resp.Body.Close()
tx, err := db.BeginTx(ctx, nil)
if err != nil {
respondError(w, fmt.Errorf("could not begin tx: %v", err))
return
}
var user User
if err = tx.QueryRowContext(ctx, `
SELECT id, username, avatar_url FROM users WHERE github_id = $1
`, githubUser.ID).Scan(&user.ID, &user.Username, &user.AvatarURL); err == sql.ErrNoRows {
if err = tx.QueryRowContext(ctx, `
INSERT INTO users (username, avatar_url, github_id) VALUES ($1, $2, $3)
RETURNING id
`, githubUser.Login, githubUser.AvatarURL, githubUser.ID).Scan(&user.ID); err != nil {
respondError(w, fmt.Errorf("could not insert user: %v", err))
return
}
user.Username = githubUser.Login
user.AvatarURL = githubUser.AvatarURL
} else if err != nil {
respondError(w, fmt.Errorf("could not query user by github ID: %v", err))
return
}
if err = tx.Commit(); err != nil {
respondError(w, fmt.Errorf("could not commit to finish github oauth: %v", err))
return
}
exp := time.Now().Add(jwtLifetime)
token, err := jwtSigner.Encode(jwt.Claims{
Subject: user.ID,
Expiration: json.Number(strconv.FormatInt(exp.Unix(), 10)),
})
if err != nil {
respondError(w, fmt.Errorf("could not create token: %v", err))
return
}
expiresAt, _ := exp.MarshalText()
data := make(url.Values)
data.Set("token", string(token))
data.Set("expires_at", string(expiresAt))
http.Redirect(w, r, "/callback?"+data.Encode(), http.StatusTemporaryRedirect)
}
```
首先，我们会尝试使用之前保存的状态对 cookie 进行解码。并将其与查询字符串中的状态进行比较。如果它们不匹配，我们会返回一个 `418 I'm teapot`（未知来源）错误。
接着，我们使用授权码生成一个令牌。这个令牌被用于创建 HTTP 客户端来向 GitHub API 发出请求。所以最终我们会向 `https://api.github.com/user` 发送一个 GET 请求。这个端点将会以 JSON 格式向我们提供当前经过身份验证的用户信息。我们将会解码这些内容，一并获取用户的 ID、登录名（用户名）和头像 URL。
然后我们将会尝试在数据库上找到具有该 GitHub ID 的用户。如果没有找到，就使用该数据创建一个新的。
之后，对于新创建的用户，我们会发出一个将用户 ID 作为主题（`Subject`）的 JSON 网络令牌，并使用该令牌重定向到前端，查询字符串中一并包含该令牌的到期日（`Expiration`）。
这一 Web 应用也会被用在其他帖子，但是重定向的链接会是 `/callback?token=&expires_at=`。在那里，我们将会利用 JavaScript 从 URL 中获取令牌和到期日，并通过 `Authorization` 标头中的令牌以 `Bearer token_here` 的形式对 `/api/auth_user` 进行 GET 请求，来获取已认证的身份用户并将其保存到 localStorage。
### Guard 中间件
为了获取当前已经过身份验证的用户，我们设计了 Guard 中间件。这是因为在接下来的文章中，我们会有很多需要进行身份认证的端点，而中间件将会允许我们共享这一功能。
```
type ContextKey struct {
Name string
}
var keyAuthUserID = ContextKey{"auth_user_id"}
func guard(handler http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var token string
if a := r.Header.Get("Authorization"); strings.HasPrefix(a, "Bearer ") {
token = a[7:]
} else if t := r.URL.Query().Get("token"); t != "" {
token = t
} else {
http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
return
}
var claims jwt.Claims
if err := jwtSigner.Decode([]byte(token), &claims); err != nil {
http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
return
}
ctx := r.Context()
ctx = context.WithValue(ctx, keyAuthUserID, claims.Subject)
handler(w, r.WithContext(ctx))
}
}
```
首先，我们尝试从 `Authorization` 标头或者是 URL 查询字符串中的 `token` 字段中读取令牌。如果没有找到，我们需要返回 `401 Unauthorized`（未授权）错误。然后我们将会对令牌中的申明进行解码，并使用该主题作为当前已经过身份验证的用户 ID。
现在，我们可以用这一中间件来封装任何需要授权的 `http.handlerFunc`，并且在处理函数的上下文中保有已经过身份验证的用户 ID。
```
var guarded = guard(func(w http.ResponseWriter, r *http.Request) {
authUserID := r.Context().Value(keyAuthUserID).(string)
})
```
### 获取认证用户
```
func getAuthUser(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
authUserID := ctx.Value(keyAuthUserID).(string)
var user User
if err := db.QueryRowContext(ctx, `
SELECT username, avatar_url FROM users WHERE id = $1
`, authUserID).Scan(&user.Username, &user.AvatarURL); err == sql.ErrNoRows {
http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
return
} else if err != nil {
respondError(w, fmt.Errorf("could not query auth user: %v", err))
return
}
user.ID = authUserID
respond(w, user, http.StatusOK)
}
```
我们使用 Guard 中间件来获取当前经过身份认证的用户 ID 并查询数据库。
这一部分涵盖了后端的 OAuth 流程。在下一篇帖子中，我们将会看到如何开始与其他用户的对话。
* [源代码](https://github.com/nicolasparada/go-messenger-demo)
---
via: <https://nicolasparada.netlify.com/posts/go-messenger-oauth/>
作者：[Nicolás Parada](https://nicolasparada.netlify.com/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[PsiACE](https://github.com/PsiACE) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
过渡到 nftables
|
Vijay Marcel D
|
https://opensourceforu.com/2019/10/transition-to-nftables/
|
开源世界中的每个主要发行版都在演进，逐渐将 nftables 作为了默认防火墙。换言之，古老的 iptables 现在已经消亡。本文是有关如何构建 nftables 的教程。
|
/data/attachment/album/201910/29/085827o8b7rbswjjr7ijsr.jpg.thumb.jpg
|
/data/attachment/album/201910/29/085827o8b7rbswjjr7ijsr.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"nftables"
] |
技术
|
{
"viewnum": 9141,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
开源世界中的每个主要发行版都在演进，逐渐将 nftables 作为了默认防火墙。换言之，古老的 iptables 现在已经消亡。本文是有关如何构建 nftables 的教程。
| 2019-10-29T08:58:42 | 2019-10-29T08:58:42 | 11,513 |
/article-11513-1.html
|
>
> 开源世界中的每个主要发行版都在演进，逐渐将 nftables 作为了默认防火墙。换言之，古老的 iptables 现在已经消亡。本文是有关如何构建 nftables 的教程。
>
>
>
当前，有一个与 nftables 兼容的 iptables-nft 后端，但是很快，即使是它也不再提供了。另外，正如 Red Hat 开发人员所指出的那样，有时它可能会错误地转换规则。我们需要知道如何构建自己的 nftables，而不是依赖于 iptables 到 nftables 的转换器。
在 nftables 中，所有地址族都遵循一个规则。与 iptables 不同，nftables 在用户空间中运行，iptables 中的每个模块都运行在内核（空间）中。它很少需要更新内核，并带有一些新功能，例如映射、地址族和字典。
### 地址族
地址族确定要处理的数据包的类型。在 nftables 中有六个地址族，它们是：
* ip
* ipv6
* inet
* arp
* bridge
* netdev
在 nftables 中，ipv4 和 ipv6 协议可以被合并为一个称为 inet 的单一地址族。因此，我们不需要指定两个规则：一个用于 ipv4，另一个用于 ipv6。如果未指定地址族，它将默认为 ip 协议，即 ipv4。我们感兴趣的领域是 inet 地址族，因为大多数家庭用户将使用 ipv4 或 ipv6 协议。
### nftables
典型的 nftables 规则包含三个部分：表、链和规则。
表是链和规则的容器。它们由其地址族和名称来标识。链包含 inet/arp/bridge/netdev 等协议所需的规则，并具有三种类型：过滤器、NAT 和路由。nftables 规则可以从脚本加载，也可以在终端键入，然后另存为规则集。
对于家庭用户，默认链为过滤器。inet 系列包含以下钩子：
* Input
* Output
* Forward
* Pre-routing
* Post-routing
### 使用脚本还是不用？
最大的问题之一是我们是否可以使用防火墙脚本。答案是：这是你自己的选择。这里有一些建议：如果防火墙中有数百条规则，那么最好使用脚本，但是如果你是典型的家庭用户，则可以在终端中键入命令，然后（保存并在重启时）加载规则集。每种选择都有其自身的优缺点。在本文中，我们将在终端中键入它们以构建防火墙。
nftables 使用一个名为 `nft` 的程序来添加、创建、列出、删除和加载规则。确保使用以下命令将 nftables 与 conntrackd 和 netfilter-persistent 软件包一起安装，并删除 iptables：
```
apt-get install nftables conntrackd netfilter-persistent
apt-get purge iptables
```
`nft` 需要以 root 身份运行或使用 `sudo` 运行。使用以下命令分别列出、刷新、删除规则集和加载脚本。
```
nft list ruleset
nft flush ruleset
nft delete table inet filter
/usr/sbin/nft -f /etc/nftables.conf
```
### 输入策略
就像 iptables 一样，防火墙将包含三部分：输入（`input`）、转发（`forward`）和输出（`output`）。在终端中，为输入（`input`）策略键入以下命令。在开始之前，请确保已刷新规则集。我们的默认策略将会删除所有内容。我们将在防火墙中使用 inet 地址族。将以下规则以 root 身份添加或使用 `sudo` 运行：
```
nft add table inet filter
nft add chain inet filter input { type filter hook input priority 0 \; counter \; policy drop \; }
```
你会注意到有一个名为 `priority 0` 的东西。这意味着赋予该规则更高的优先级。挂钩通常赋予负整数，这意味着更高的优先级。每个挂钩都有自己的优先级，过滤器链的优先级为 0。你可以检查 nftables Wiki 页面以查看每个挂钩的优先级。
要了解你计算机中的网络接口，请运行以下命令：
```
ip link show
```
它将显示已安装的网络接口，一个是本地主机、另一个是以太网端口或无线端口。以太网端口的名称如下所示：`enpXsY`，其中 `X` 和 `Y` 是数字，无线端口也是如此。我们必须允许本地主机的流量，并且仅允许从互联网建立的传入连接。
nftables 具有一项称为裁决语句的功能，用于解析规则。裁决语句为 `accept`、`drop`、`queue`、`jump`、`goto`、`continue` 和 `return`。由于这是一个很简单的防火墙，因此我们将使用 `accept` 或 `drop` 处理数据包。
```
nft add rule inet filter input iifname lo accept
nft add rule inet filter input iifname enpXsY ct state new, established, related accept
```
接下来，我们必须添加规则以保护我们免受隐秘扫描。并非所有的隐秘扫描都是恶意的，但大多数都是。我们必须保护网络免受此类扫描。第一组规则列出了要测试的 TCP 标志。在这些标志中，第二组列出了要与第一组匹配的标志。
```
nft add rule inet filter input iifname enpXsY tcp flags \& \(syn\|fin\) == \(syn\|fin\) drop
nft add rule inet filter input iifname enpXsY tcp flags \& \(syn\|rst\) == \(syn\|rst\) drop
nft add rule inet filter input iifname enpXsY tcp flags \& \(fin\|rst\) == \(fin\|rst\) drop
nft add rule inet filter input iifname enpXsY tcp flags \& \(ack\|fin\) == fin drop
nft add rule inet filter input iifname enpXsY tcp flags \& \(ack\|psh\) == psh drop
nft add rule inet filter input iifname enpXsY tcp flags \& \(ack\|urg\) == urg drop
```
记住，我们在终端中键入这些命令。因此，我们必须在一些特殊字符之前添加一个反斜杠，以确保终端能够正确解释该斜杠。如果你使用的是脚本，则不需要这样做。
### 关于 ICMP 的警告
互联网控制消息协议（ICMP）是一种诊断工具，因此不应完全丢弃该流量。完全阻止 ICMP 的任何尝试都是不明智的，因为它还会导致停止向我们提供错误消息。仅启用最重要的控制消息，例如回声请求、回声应答、目的地不可达和超时等消息，并拒绝其余消息。回声请求和回声应答是 `ping` 的一部分。在输入策略中，我们仅允许回声应答、而在输出策略中，我们仅允许回声请求。
```
nft add rule inet filter input iifname enpXsY icmp type { echo-reply, destination-unreachable, time-exceeded } limit rate 1/second accept
nft add rule inet filter input iifname enpXsY ip protocol icmp drop
```
最后，我们记录并丢弃所有无效数据包。
```
nft add rule inet filter input iifname enpXsY ct state invalid log flags all level info prefix \”Invalid-Input: \”
nft add rule inet filter input iifname enpXsY ct state invalid drop
```
### 转发和输出策略
在转发和输出策略中，默认情况下我们将丢弃数据包，仅接受已建立连接的数据包。
```
nft add chain inet filter forward { type filter hook forward priority 0 \; counter \; policy drop \; }
nft add rule inet filter forward ct state established, related accept
nft add rule inet filter forward ct state invalid drop
nft add chain inet filter output { type filter hook output priority 0 \; counter \; policy drop \; }
```
典型的桌面用户只需要端口 80 和 443 即可访问互联网。最后，允许可接受的 ICMP 协议并在记录无效数据包时丢弃它们。
```
nft add rule inet filter output oifname enpXsY tcp dport { 80, 443 } ct state established accept
nft add rule inet filter output oifname enpXsY icmp type { echo-request, destination-unreachable, time-exceeded } limit rate 1/second accept
nft add rule inet filter output oifname enpXsY ip protocol icmp drop
nft add rule inet filter output oifname enpXsY ct state invalid log flags all level info prefix \”Invalid-Output: \”
nft add rule inet filter output oifname enpXsY ct state invalid drop
```
现在我们必须保存我们的规则集，否则重新启动时它将丢失。为此，请运行以下命令：
```
sudo nft list ruleset. > /etc/nftables.conf
```
我们须在引导时加载 nftables，以下将在 systemd 中启用 nftables 服务：
```
sudo systemctl enable nftables
```
接下来，编辑 nftables 单元文件以删除 `Execstop` 选项，以避免在每次引导时刷新规则集。该文件通常位于 `/etc/systemd/system/sysinit.target.wants/nftables.service`。现在重新启动nftables：
```
sudo systemctl restart nftables
```
### 在 rsyslog 中记录日志
当你记录丢弃的数据包时，它们直接进入 syslog，这使得读取该日志文件非常困难。最好将防火墙日志重定向到单独的文件。在 `/var/log` 目录中创建一个名为 `nftables` 的目录，并在其中创建两个名为 `input.log` 和 `output.log` 的文件，分别存储输入和输出日志。确保系统中已安装 rsyslog。现在转到 `/etc/rsyslog.d` 并创建一个名为 `nftables.conf` 的文件，其内容如下：
```
:msg,regex,”Invalid-Input: “ -/var/log/nftables/Input.log
:msg,regex,”Invalid-Output: “ -/var/log/nftables/Output.log & stop
```
现在，我们必须确保日志是可管理的。为此，使用以下代码在 `/etc/logrotate.d` 中创建另一个名为 `nftables` 的文件：
```
/var/log/nftables/* { rotate 5 daily maxsize 50M missingok notifempty delaycompress compress postrotate invoke-rc.d rsyslog rotate > /dev/null endscript }
```
重新启动 nftables。现在，你可以检查你的规则集。如果你觉得在终端中键入每个命令很麻烦，则可以使用脚本来加载 nftables 防火墙。我希望本文对保护你的系统有用。
---
via: <https://opensourceforu.com/2019/10/transition-to-nftables/>
作者：[Vijay Marcel D](https://opensourceforu.com/author/vijay-marcel/) 选题：[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/) 荣誉推出
|
在 Fedora 上使用 SSH 端口转发
|
Paul W. Frields
|
https://fedoramagazine.org/using-ssh-port-forwarding-on-fedora/
|
ssh 命令背后所使用的协议允许终端的输入和输出流经安全通道。但是你知道也可以使用 ssh 来安全地发送和接收其他数据吗？
|
/data/attachment/album/201910/29/123804dql3aqqlghza9txt.jpg.thumb.jpg
|
/data/attachment/album/201910/29/123804dql3aqqlghza9txt.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"ssh"
] |
系统运维
|
{
"viewnum": 7301,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
ssh 命令背后所使用的协议允许终端的输入和输出流经安全通道。但是你知道也可以使用 ssh 来安全地发送和接收其他数据吗？
| 2019-10-29T12:38:42 | 2019-10-29T12:38:42 | 11,515 |
/article-11515-1.html
|
你可能已经熟悉使用 [ssh 命令](https://en.wikipedia.org/wiki/Secure_Shell)访问远程系统。`ssh` 命令背后所使用的协议允许终端的输入和输出流经[安全通道](https://fedoramagazine.org/open-source-ssh-clients/)。但是你知道也可以使用 `ssh` 来安全地发送和接收其他数据吗？一种方法是使用“<ruby> 端口转发 <rt> port forwarding </rt></ruby>”，它允许你在进行 `ssh` 会话时安全地连接网络端口。本文向你展示了它是如何工作的。
### 关于端口
标准 Linux 系统已分配了一组网络端口，范围是 0 - 65535。系统会保留 0 - 1023 的端口以供系统使用。在许多系统中，你不能选择使用这些低端口号。通常有几个端口用于运行特定的服务。你可以在系统的 `/etc/services` 文件中找到这些定义。
你可以认为网络端口是类似的物理端口或可以连接到电缆的插孔。端口可以连接到系统上的某种服务，类似物理插孔后面的接线。一个例子是 Apache Web 服务器（也称为 `httpd`）。对于 HTTP 非安全连接，Web 服务器通常要求在主机系统上使用端口 80，对于 HTTPS 安全连接通常要求使用 443。
当你连接到远程系统（例如，使用 Web 浏览器）时，你是将浏览器“连接”到你的主机上的端口。这通常是一个随机的高端口号，例如 54001。你的主机上的端口连接到远程主机上的端口（例如 443）来访问其安全的 Web 服务器。
那么，当你有这么多可用端口时，为什么还要使用端口转发呢？这是 Web 开发人员生活中的几种常见情况。
### 本地端口转发
想象一下，你正在名为 `remote.example.com` 的远程系统上进行 Web 开发。通常，你是通过 `ssh` 进入此系统的，但是它位于防火墙后面，而且该防火墙很少允许其他类型的访问，并且会阻塞大多数其他端口。要尝试你的网络应用，能够使用浏览器访问远程系统会很有帮助。但是，由于使用了讨厌的防火墙，你无法通过在浏览器中输入 URL 的常规方法来访问它。
本地转发使你可以通过 `ssh` 连接来建立可通过远程系统访问的端口。该端口在系统上显示为本地端口（因而称为“本地转发”）。
假设你的网络应用在 `remote.example.com` 的 8000 端口上运行。要将那个系统的 8000 端口本地转发到你系统上的 8000 端口，请在开始会话时将 `-L` 选项与 `ssh` 结合使用：
```
$ ssh -L 8000:localhost:8000 remote.example.com
```
等等，为什么我们使用 `localhost` 作为转发目标？这是因为从 `remote.example.com` 的角度来看，你是在要求主机使用其自己的端口 8000。（回想一下，任何主机通常可以通过网络连接 `localhost` 而连接到自身。）现在那个端口连接到你系统的 8000 端口了。`ssh` 会话准备就绪后，将其保持打开状态，然后可以在浏览器中键入 `http://localhost:8000` 来查看你的 Web 应用。现在，系统之间的流量可以通过 `ssh` 隧道安全地传输！
如果你有敏锐的眼睛，你可能已经注意到了一些东西。如果我们要 `remote.example.com` 转发到与 `localhost` 不同的主机名怎么办？如果它可以访问该网络上另一个系统上的端口，那么通常可以同样轻松地转发该端口。例如，假设你想访问也在该远程网络中的 `db.example.com` 的 MariaDB 或 MySQL 服务。该服务通常在端口 3306 上运行。因此，即使你无法 `ssh` 到实际的 `db.example.com` 主机，你也可以使用此命令将其转发：
```
$ ssh -L 3306:db.example.com:3306 remote.example.com
```
现在，你可以在 `localhost` 上运行 MariaDB 命令，而实际上是在使用 `db.example.com` 主机。
### 远程端口转发
远程转发让你可以进行相反操作。想象一下，你正在为办公室的朋友设计一个 Web 应用，并想向他们展示你的工作。不过，不幸的是，你在咖啡店里工作，并且由于网络设置，他们无法通过网络连接访问你的笔记本电脑。但是，你同时使用着办公室的 `remote.example.com` 系统，并且仍然可在这里登录。你的 Web 应用似乎在本地 5000 端口上运行良好。
远程端口转发使你可以通过 `ssh` 连接从本地系统建立端口的隧道，并使该端口在远程系统上可用。在开始 `ssh` 会话时，只需使用 `-R` 选项：
```
$ ssh -R 6000:localhost:5000 remote.example.com
```
现在，当在公司防火墙内的朋友打开浏览器时，他们可以进入 `http://remote.example.com:6000` 查看你的工作。就像在本地端口转发示例中一样，通信通过 `ssh` 会话安全地进行。
默认情况下，`sshd` 守护进程运行在设置的主机上，因此**只有**该主机可以连接它的远程转发端口。假设你的朋友希望能够让其他 `example.com` 公司主机上的人看到你的工作，而他们不在 `remote.example.com` 上。你需要让 `remote.example.com` 主机的所有者将以下选项**之一**添加到 `/etc/ssh/sshd_config` 中：
```
GatewayPorts yes # 或
GatewayPorts clientspecified
```
第一个选项意味着 `remote.example.com` 上的所有网络接口都可以使用远程转发的端口。第二个意味着建立隧道的客户端可以选择地址。默认情况下，此选项设置为 `no`。
使用此选项，你作为 `ssh` 客户端仍必须指定可以共享你这边转发端口的接口。通过在本地端口之前添加网络地址范围来进行此操作。有几种方法可以做到，包括：
```
$ ssh -R *:6000:localhost:5000 # 所有网络
$ ssh -R 0.0.0.0:6000:localhost:5000 # 所有网络
$ ssh -R 192.168.1.15:6000:localhost:5000 # 单个网络
$ ssh -R remote.example.com:6000:localhost:5000 # 单个网络
```
### 其他注意事项
请注意，本地和远程系统上的端口号不必相同。实际上，有时你甚至可能无法使用相同的端口。例如，普通用户可能不会在默认设置中转发到系统端口。
另外，可以限制主机上的转发。如果你需要在联网主机上更严格的安全性，那么这你来说可能很重要。 `sshd` 守护程进程的 `PermitOpen` 选项控制是否以及哪些端口可用于 TCP 转发。默认设置为 `any`，这让上面的所有示例都能正常工作。要禁止任何端口转发，请选择 `none`，或仅允许的特定的“主机:端口”。有关更多信息，请在手册页中搜索 `PermitOpen` 来配置 `sshd` 守护进程：
```
$ man sshd_config
```
最后，请记住，只有在 `ssh` 会话处于打开状态时才会端口转发。如果需要长时间保持转发活动，请尝试使用 `-N` 选项在后台运行会话。确保控制台已锁定，以防止在你离开控制台时其被篡夺。
---
via: <https://fedoramagazine.org/using-ssh-port-forwarding-on-fedora/>
作者：[Paul W. Frields](https://fedoramagazine.org/author/pfrields/) 选题：[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/) 荣誉推出
|
2019 年最可怕的黑客事件与安全漏洞（上）
|
Catalin Cimpanu
|
https://www.zdnet.com/article/the-scariest-hacks-and-vulnerabilities-of-2019/
|
是的，这是年终摘要文章之一。这是一篇很长的文章，因为就网络安全新闻来说，2019 年就是一场灾难，每周都会有一个或多个重大事件发生。
|
/data/attachment/album/201910/29/233311sgk6h0qqiv60gk2g.png.thumb.jpg
|
/data/attachment/album/201910/29/233311sgk6h0qqiv60gk2g.png
| true | false | true |
wxy
| false |
[
"黑客",
"网络安全"
] |
观点
|
{
"viewnum": 7640,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11520,
"displayorder": 0
}
] |
是的，这是年终摘要文章之一。这是一篇很长的文章，因为就网络安全新闻来说，2019 年就是一场灾难，每周都会有一个或多个重大事件发生。
| 2019-10-30T07:00:00 | 2019-10-30T07:00:00 | 11,516 |
/article-11516-1.html
|
是的，这是年终摘要文章之一。这是一篇很长的文章，因为就网络安全新闻来说，2019 年就是一场灾难，每周都会有一个或多个重大事件发生。
以下是按月组织的过去 10 个月安全灾难的摘要。
### 一月
[Apple FaceTime 中的严重漏洞](https://www.zdnet.com/article/apple-facetime-exploit-found-by-14-year-old-playing-fortnite/)：Apple FaceTime 应用程序中的一个错误使攻击者可以在不与被呼叫者进行任何用户交互的情况下呼叫并自行应答 FaceTime 呼叫，从而为进行秘密监视打开了大门。
[在通过 Skype 面试后，朝鲜黑客渗透到智利的 ATM 网络](https://www.zdnet.com/article/north-korean-hackers-infiltrate-chiles-atm-network-after-skype-job-interview/)：该文章的标题不言而喻，值得你花时间阅读该故事。
[黑客破坏并窃取了韩国国防部的数据](https://www.zdnet.com/article/hackers-breach-and-steal-data-from-south-koreas-defense-ministry/)：首尔政府表示，黑客破坏了 30 台计算机并窃取了 10 台计算机中的数据。被黑客入侵的计算机存储了有关武器和弹药采购的数据。
[有人入侵了 PHP PEAR 网站](https://www.zdnet.com/article/mystery-still-surrounds-hack-of-php-pear-website/)：我们仍然不知道发生了什么，但是一些黑客侵入了 PHP PEAR 存储库，并给某个版本的 PHP PEAR 软件包管理器添加了后门。
[26 种低端加密货币中发现的安全漏洞](https://www.zdnet.com/article/security-flaws-found-in-26-low-end-cryptocurrencies/)：该报告显示了一些低端的不著名的加密货币的危险性，以及黑客如何随时窃取大量资金。
[俄克拉荷马州政府数据泄漏暴露了联邦调查局的调查记录](https://www.zdnet.com/article/oklahoma-gov-data-leak-exposes-millions-of-department-files-fbi-investigations/)：俄克拉荷马州证券部的服务器允许任何人下载政府文件，例如内部文件，甚至是联邦调查局的调查。
[被怀疑参与了全球 DNS 劫持活动的伊朗黑客](https://www.zdnet.com/article/iranian-hackers-suspected-in-worldwide-dns-hijacking-campaign/)：FireEye 和 Cisco Talos 先后披露了由伊朗黑客发起的全球劫持活动，伊朗黑客通过其伊朗服务器重定向了来自全球各地公司的流量，并记录了公司的凭据以备将来攻击。他们在域名注册商处入侵了 DNS 管理帐户，以执行 DNS 劫持攻击。这些黑客也[入侵了希腊的顶级域名注册商](https://www.zdnet.com/article/hackers-breached-greeces-top-level-domain-registrar/)。
[存在了 36 年之久的 SCP 软件安全漏洞](https://www.zdnet.com/article/scp-implementations-impacted-by-36-years-old-security-flaws/)：自 1983 年以来，过去 36 年中的所有 SCP（安全复制协议）软件版本均受到了四个安全漏洞的影响，这些漏洞允许恶意的 SCP 服务器对客户（用户）的系统进行未经授权的更改，并在终端隐藏其恶意操作。
年度 LTE 安全漏洞：今年发现了两组新的 LTE 安全漏洞。一组影响 [3G、4G 和 5G](https://www.zdnet.com/article/new-security-flaw-impacts-5g-4g-and-3g-telephony-protocols/)，另一组 [36 个漏洞](https://www.zdnet.com/article/researchers-find-36-new-security-flaws-in-lte-protocol/)在韩国安全研究人员进行的一项模糊项目之后被发现。
[网站可以通过浏览器扩展 API 窃取浏览器数据](https://www.zdnet.com/article/websites-can-steal-browser-data-via-extensions-apis/)：研究人员发现有将近 200 个 Chrome、Firefox 和 Opera 扩展容易受到恶意站点的攻击。
[WiFi 固件错误会影响笔记本电脑、智能手机、路由器、游戏设备](https://www.zdnet.com/article/wifi-firmware-bug-affects-laptops-smartphones-routers-gaming-devices/)：Marvell Avastar 芯片组中发现的重大安全漏洞。受影响的设备列表包括 PS4、Xbox One、三星 Chromebook 和微软 Surface 设备。
恶意软件被发现预装在 Android 设备上：在 2019 年发生了两次。首先，在一月份，研究人员在[预安装在阿尔卡特智能手机上的阿尔卡特应用程序](https://www.zdnet.com/article/malware-found-preinstalled-on-some-alcatel-smartphones/)中发现了恶意软件。其次，在六月，德国的网络安全机构在[四种中国智能手机型号中发现了后门](https://www.zdnet.com/article/germany-backdoor-found-in-four-smartphone-models-20000-users-infected/)。
### 二月
[重大 WinRAR 错误暴露](https://www.zdnet.com/article/winrar-versions-released-in-the-last-19-years-impacted-by-severe-security-flaw/)：Check Point 研究人员发现了一个 WinRAR 错误，该错误影响了自 2000 年以来发行的所有 WinRAR 版本。超过 5 亿个 WinRAR 用户面临风险。这些漏洞最终被网络罪犯和国家黑客广泛使用。
[新的 WinPot 恶意软件可以使 ATM 吐出现金](https://www.zdnet.com/article/this-malware-turns-atm-hijacking-into-slot-machine-games/)：WinPot 自 2018 年 3 月以来一直在地下论坛上出售。
[从 Tor 流量检测单个 Android 应用程序的准确性为 97％](https://www.zdnet.com/article/tor-traffic-from-individual-android-apps-detected-with-97-percent-accuracy/)：新的机器学习算法可以通过 Tor 检测 Tor 用户何时使用了特定的应用程序，例如 YouTube、Instagram、Spotify 等。
[黑客抹除了电子邮件提供商 VFEmail 的美国服务器](https://www.zdnet.com/article/hackers-wipe-us-servers-of-email-provider-vfemail/)：黑客没有要求赎金。VFEmail 将事件描述为“攻击并摧毁”。
[Thunderclap 漏洞](https://www.zdnet.com/article/thunderclap-flaws-impact-how-windows-mac-linux-handle-thunderbolt-peripherals/)：该安全漏洞影响 Windows、Mac、Linux 处理 Thunderbolt 外围设备的方式。它们允许创建可能从操作系统内存中窃取数据的高度危险的恶意外围设备。
PDF 协议攻击：一组德国学者发现了一种在 PDF 文档中[伪造签名的方法](https://www.zdnet.com/article/researchers-break-digital-signatures-for-most-desktop-pdf-viewers/)，并在今年晚些时候找到了[一种破解 PDF 加密的方法](https://www.zdnet.com/article/researchers-break-digital-signatures-for-most-desktop-pdf-viewers/)。
使用 CPU 隐藏恶意软件：学者们已经找到了在[使用推测执行](https://www.zdnet.com/article/researchers-hide-malware-in-benign-apps-with-the-help-of-speculative-execution/)和[英特尔 SGX 安全区系统](https://www.zdnet.com/article/researchers-hide-malware-in-intel-sgx-enclaves/)的计算机上隐藏恶意软件的方法。
### 三月
[黑客在大风暴发生前将龙卷风警报器离线](https://www.zdnet.com/article/hacked-tornado-sirens-taken-offline-in-two-texas-cities-ahead-of-major-storm/)：是的，就是为了作恶。
[华硕供应链黑客事件](https://www.zdnet.com/article/supply-chain-attack-installs-backdoors-through-hijacked-asus-live-update-software/)：黑客劫持了华硕 Live Update 实用程序，以便在用户系统上部署恶意软件。黑客攻击发生在 2018 年，但在今年 3 月被披露。据信已经影响了超过一百万台 PC。
[GitHub 帐户环推广了 300 多个带后门的应用程序](https://www.zdnet.com/article/researchers-uncover-ring-of-github-accounts-promoting-300-backdoored-apps/)：该 GitHub 账户环由 89 个帐户组成，推广了 73 个仓库，其中包含 300 多个带有后门的 Windows、Mac 和 Linux 应用程序。
[Bithumb 加密货币交易所在两年内第三次被黑客入侵](https://www.zdnet.com/article/bithumb-cryptocurrency-exchange-hacked-a-third-time-in-two-years/)：据信黑客已经赚了近 2000 万美元的 EOS 和瑞波加密货币。在这一点上，Bithumb 似乎放弃挣扎了。
[Chrome 零日漏洞正受到活跃攻击](https://www.zdnet.com/article/google-reveals-chrome-zero-day-under-active-attacks/)：CVE-2019-5786（Chrome 的 FileReader API 中的一个错误）被广泛利用以从用户计算机中读取内容。谷歌表示，该漏洞是由一个国家攻击者[与 Windows 7 零日漏洞一起使用](https://www.zdnet.com/article/google-chrome-zero-day-was-used-together-with-a-windows-7-zero-day/)的。
[新的英特尔 CPU 错误](https://www.zdnet.com/article/researchers-discover-and-abuse-new-undocumented-feature-in-intel-chipsets/)：研究人员发现了新的 Intel VISA（内部信号架构可视化）调试技术。
[法国加油站的黑客事件](https://www.zdnet.com/article/french-gas-stations-robbed-after-forgetting-to-change-gas-pump-pins/)：加油站忘记更换加油站油泵的 PIN 之后，犯罪集团从巴黎附近的道达尔加油站偷走了 12 万升燃油。
[Citrix 数据泄露](https://www.zdnet.com/article/citrix-discloses-security-breach-of-internal-network/)：Citrix 从 FBI 获悉了本次黑客攻击。黑客偷走了商业文件。Citrix 的许多客户都是政府机构和财富 500 强公司。
智能手机解锁问题：我们今年遇到了一些这样的案例，但第一起案例是在三月份报道的，当时用户发现三星 Galaxy S10 面部识别可能被[手机所有者的视频](https://www.zdnet.com/article/samsung-galaxy-s10-facial-recognition-fooled-by-a-video-of-the-phone-owner/)所欺骗。一个月后，用户发现他可以用[一包口香糖](https://www.zdnet.com/article/nokia-9-buggy-update-lets-anyone-bypass-fingerprint-scanner-with-a-pack-of-gum/)解锁诺基亚 9 智能手机的指纹扫描仪。然后在十月，用户发现可以在[闭着眼睛](https://www.zdnet.com/article/google-pixel-4s-face-unlock-works-even-if-you-have-your-eyes-closed/)时解锁 Pixel 4 的面部解锁技术；一对夫妇发现，如果该设备由硅保护套保护，他们可以使用任何用户的手指[解锁使用指纹保护的 Samsung S10 设备](https://www.zdnet.com/article/samsung-to-patch-s10-fingerprint-sensor-bug-next-week/)。实际上，绕过面部识别的问题非常普遍。去年，一家荷兰非营利组织进行的一项研究发现，攻击者可以在测试的 [110 部智能手机中的 42 部](https://www.zdnet.com/article/facial-recognition-doesnt-work-as-intended-on-42-of-110-tested-smartphones/)中绕过面部解锁类的功能。
### 四月
[美国联合航空公司盖上了座席摄像头](https://www.zdnet.com/article/united-airlines-covers-up-infotainment-seat-camera-following-passenger-outrage/)：该航空公司坚称这些摄像头尚未投入使用；但是，客户首先仍然对该摄像头的存在感到非常不安和烦恼。
[由于未修复的 API，研究人员在数百个 GPS 手表的地图上显示 “PWNED!”](https://www.zdnet.com/article/researcher-prints-pwned-on-hundreds-of-gps-watches-maps-due-to-unfixed-api/) ：超过 20 种型号的 GPS 手表允许恶意行为者跟踪设备所有者，并修改手表功能。
[成千上万辆汽车因使用硬编码的密码而暴露于小偷视野之中](https://www.zdnet.com/article/tens-of-thousands-of-cars-left-exposed-to-thieves-due-to-a-hardcoded-password/)：二月中以来，MyCar 发布的 Android 和 iOS 应用程序的安全更新已删除了硬编码的密码。
[被勒索软件感染后，“天气”频道的播出空缺了 90 分钟](https://www.zdnet.com/article/the-weather-channel-goes-off-the-air-for-90-minutes-after-ransomware-infection/)：10 月对[法国电视台 M6](https://www.zdnet.com/article/m6-one-of-frances-biggest-tv-channels-hit-by-ransomware/) 的类似攻击未成功。
[Facebook 承认存储了数百万个 Instagram 用户的明文密码](https://www.zdnet.com/article/facebook-admits-to-storing-plaintext-passwords-for-millions-of-instagram-users/)：该事件发生的一个月前，Facebook 也承认[存储了 Facebook 帐户的明文密码](https://www.zdnet.com/article/facebook-we-stored-hundreds-of-millions-of-passwords-in-plain-text/)。
[Telegram 上泄露了伊朗网络间谍工具的源代码](https://www.zdnet.com/article/source-code-of-iranian-cyber-espionage-tools-leaked-on-telegram/)：每天都有恶意软件开发人员使用这些工具，从而使更多用户受到攻击。[五月](https://www.zdnet.com/article/new-leaks-of-iranian-cyber-espionage-operations-hit-telegram-and-the-dark-web/)和[六月](https://www.zdnet.com/article/new-iranian-hacking-tool-leaked-on-telegram/)发生了第二次和第三次伊朗黑客工具泄漏。
[印度政府机构保留的数百万孕妇的详细信息暴露在线上](https://www.zdnet.com/article/indian-govt-agency-left-details-of-millions-of-pregnant-women-exposed-online/)：超过 1250 万孕妇医学记录被暴露。三个多星期后，泄漏的服务器中删除了记录。
[超过 13000 个 iSCSI 存储群集暴露在网上而没有密码](https://www.zdnet.com/article/over-13k-iscsi-storage-clusters-left-exposed-online-without-a-password/)：新的攻击方式在企业磁盘存储阵列和人们的 NAS 设备内部打开了后门。
[Gnosticplayers 的黑客事件](https://www.zdnet.com/article/a-hacker-has-dumped-nearly-one-billion-user-records-over-the-past-two-months/)：几个月之内，一个被称为 Gnosticplayers 的黑客在网上放出了超过 10 亿条用户记录。
[黑客组织已经在 D-Link 路由器上劫持了 DNS 流量达三个月](https://www.zdnet.com/article/hacker-group-has-been-hijacking-dns-traffic-on-d-link-routers-for-three-months/)：他们还针对了其他路由器型号进行了劫持，例如 ARG、DSLink、Secutech 和 TOTOLINK。这些攻击[在巴西尤其活跃](https://www.zdnet.com/article/brazil-is-at-the-forefront-of-a-new-type-of-router-attack/)。
### 五月
[黑客擦除了 Git 存储库，并要求赎金](https://www.zdnet.com/article/a-hacker-is-wiping-git-repositories-and-asking-for-a-ransom/)：成千上万的存储库受到了影响，但几乎所有项目都已恢复。
[对现代 CPU 的新 MDS 攻击](https://www.zdnet.com/article/intel-cpus-impacted-by-new-zombieload-side-channel-attack/)：研究人员和学者详细介绍了新的微体系结构数据采样（MDS）攻击，例如 Zombieload、Fallout 和 RIDL。
[Thrangrycat 漏洞](https://www.zdnet.com/article/thrangrycat-flaw-lets-attackers-plant-persistent-backdoors-on-cisco-gear/)：Thrangrycat 漏洞使攻击者可以在 Cisco 设备上植入持久的后门。据信大多数 Cisco 设备都会受到影响。没有广泛检测到攻击。
BlueKeep 漏洞：五月中旬，微软警告了一个[新的 “可用作蠕虫的” RDP 漏洞](https://www.zdnet.com/article/microsoft-patches-windows-xp-server-2003-to-try-to-head-off-wormable-flaw/)，该漏洞后来被称为 BlueKeep。后来在八月披露了两个新的类似 BlueKeep 的可用做蠕虫的漏洞（[DejaBlue](https://www.zdnet.com/article/microsoft-warns-of-two-new-wormable-flaws-in-windows-remote-desktop-services/)）。经过数月的迫切等待之后，九月公开发布了一种[概念验证攻击](https://www.zdnet.com/article/metasploit-team-releases-bluekeep-exploit/)。
[不安全的服务器公开了 85％ 巴拿马公民的的数据](https://www.zdnet.com/article/unsecured-server-exposes-data-for-85-percent-of-all-panama-citizens/)：该服务器包含患者数据，但没有公开医疗记录，仅公开了个人身份信息（PII）。
[软件更新导致荷兰警察的脚踝监控器崩溃](https://www.zdnet.com/article/software-update-crashes-police-ankle-monitors-in-the-netherlands/)：有问题的更新阻止了脚踝监控器将数据发送回警察控制室。导致需要找到一些嫌疑人并送回监狱。
[以色列对空袭哈马斯的黑客首次作出回应](https://www.zdnet.com/article/in-a-first-israel-responds-to-hamas-hackers-with-an-air-strike/)：以色列军方称轰炸了住着哈马斯网络部队的房屋。
[Google 替换了有问题的 Titan 安全密钥](https://www.zdnet.com/article/google-to-replace-faulty-titan-security-keys/)：蓝牙配对协议中的漏洞迫使 Google 替换了在美国销售的 Titan 密钥。微软后来被迫[发布了一个特殊修复程序](https://www.zdnet.com/article/microsoft-blocks-ble-security-keys-with-known-pairing-vulnerability/)以解决该问题。
[Canva 黑客事件](https://www.zdnet.com/article/australian-tech-unicorn-canva-suffers-security-breach/)：Gnosticplayers 的受害者之一。该公司被黑客窃取了 1.39 亿条用户记录。
[StackOverflow 黑客事件](https://www.zdnet.com/article/stack-overflow-says-hackers-breached-production-systems/)：Stack Overflow 表示黑客破坏了生产系统，而黑客发现已经活动了[一周以上](https://www.zdnet.com/article/stack-overflow-hacker-went-undetected-for-a-week/)。
[Flipboard 黑客事件](https://www.zdnet.com/article/flipboard-says-hackers-stole-user-details/)：黑客入侵的程度尚不得而知，但 Flipboard 表示，黑客已经访问其系统将近九个月的时间。
[伦敦地铁开始通过 Wi-Fi 热点跟踪乘客](https://www.zdnet.com/article/london-underground-to-begin-tracking-passengers-through-wi-fi-hotspots/)：伦敦交通局（TfL）表示，计划在未来几个月内推出一种系统，以利用伦敦地铁上的公共 Wi-Fi 热点跟踪通勤者。
[安全浏览器的主要错误](https://www.zdnet.com/article/mobile-chrome-safari-and-firefox-failed-to-show-phishing-warnings-for-more-than-a-year/)：移动版 Chrome、Safari 和 Firefox 一年多都未能显示网络钓鱼警告。
### 六月
[黑客攻击了 10 家电信供应商](https://www.zdnet.com/article/these-hackers-broke-into-10-telecoms-companies-to-steal-customers-phone-records/)：Cybereason 的研究人员说，一个由国家支持的情报机构已经破坏了至少 10 家全球电信公司：在某种程度上，攻击者运行着“事实上的影子 IT 部门”。
[新的 Silex 恶意软件使成千上万的 IoT 设备变砖](https://www.zdnet.com/article/new-silex-malware-is-bricking-iot-devices-has-scary-plans/)：攻击持续了数天，但黑客最终停止并撤回了 Silex 恶意软件代码。
[NASA 因未经授权的树莓派连接到其网络而被黑客入侵](https://www.zdnet.com/article/nasa-hacked-because-of-unauthorized-raspberry-pi-connected-to-its-network/)：NASA 将该黑客攻击描述为“高级持续威胁（APT）”，该术语通常用于国家黑客组织，但未提供其他详细信息。
[流行的 Facebook 悲伤支持页面被黑客入侵](https://www.zdnet.com/article/popular-grief-support-page-hacked-ignored-by-facebook-for-weeks/)：Facebok 数周都无视了该黑客攻击。
[Google Nest 的摄像头可以允许前拥有者监视新拥有者](https://www.zdnet.com/article/google-pushes-nest-cam-update-to-prevent-former-owners-spying-on-new-buyers/)：Google 最终推出了更新解决这个问题。
两个 Firefox 零日漏洞：Mozilla 修复了两个 Firefox 零日漏洞[[1](https://www.zdnet.com/article/mozilla-fixes-second-firefox-zero-day-exploited-in-the-wild/)、[2](https://www.zdnet.com/article/mozilla-fixes-second-firefox-zero-day-exploited-in-the-wild/)] ，它们被用于攻击 Coinbase 员工。
[AMCA 数据泄露](https://www.zdnet.com/article/amca-data-breach-has-now-gone-over-the-20-million-mark/)：去年，美国医疗保健计费供应商被黑客入侵，黑客将患者数据在线出售。该漏洞影响了多家医疗保健提供商，最终数量超过了 2000 万。
[CBP 说，黑客窃取了车牌和旅行者的照片](https://www.zdnet.com/article/cbp-says-hackers-stole-license-plate-and-travelers-photos/)：CBP 说，分包商未经授权将照片存储在其内部服务器上，然后遭到黑客攻击。
[HSM 重大漏洞影响着银行、云提供商、政府](https://www.zdnet.com/article/major-hsm-vulnerabilities-impact-banks-cloud-providers-governments/)：两名安全研究人员透露，可以远程利用这些漏洞来检索存储在称为 HSM（硬件安全模块）的特殊计算机组件中的敏感数据。
[SIM 交换攻击浪潮袭击了美国加密货币用户](https://www.zdnet.com/article/wave-of-sim-swapping-attacks-hit-us-cryptocurrency-users/)：六月的一周，数十名美国加密货币用户认为他们是 SIM 交换攻击的受害者。
|
||
使用 ansible-bender 构建容器镜像
|
Tomas Tomecek
|
https://opensource.com/article/19/10/building-container-images-ansible
|
了解如何使用 Ansible 在容器中执行命令。
|
/data/attachment/album/201910/30/090738vzbifzfpa6qz9bij.jpg.thumb.jpg
|
/data/attachment/album/201910/30/090738vzbifzfpa6qz9bij.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Ansible",
"容器"
] |
容器与云
|
{
"viewnum": 5027,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
了解如何使用 Ansible 在容器中执行命令。
| 2019-10-30T09:08:37 | 2019-10-30T09:08:37 | 11,518 |
/article-11518-1.html
|
>
> 了解如何使用 Ansible 在容器中执行命令。
>
>
>
容器和 [Ansible](https://www.ansible.com/) 可以很好地融合在一起：从管理和编排到供应和构建。在本文中，我们将重点介绍构建部分。
如果你熟悉 Ansible，就会知道你可以编写一系列任务，`ansible-playbook` 命令将为你执行这些任务。你知道吗，如果你编写 Dockerfile 并运行 `podman build`，你还可以在容器环境中执行此类命令，并获得相同的结果。
这是一个例子：
```
- name: Serve our file using httpd
hosts: all
tasks:
- name: Install httpd
package:
name: httpd
state: installed
- name: Copy our file to httpd’s webroot
copy:
src: our-file.txt
dest: /var/www/html/
```
你可以在 Web 服务器本地或容器中执行这个剧本，并且只要你记得先创建 `our-file.txt`，它就可以工作。
但是这里缺少了一些东西。你需要启动（并配置）httpd 以便提供文件。这是容器构建和基础架构供应之间的区别：构建镜像时，你只需准备内容；而运行容器是另一项任务。另一方面，你可以将元数据附加到容器镜像，它会默认运行命令。
这有个工具可以帮助。试试看 `ansible-bender` 怎么样？
```
$ ansible-bender build the-playbook.yaml fedora:30 our-httpd
```
该脚本使用 `ansible-bender` 对 Fedora 30 容器镜像执行该剧本，并将生成的容器镜像命名为 `our-httpd`。
但是，当你运行该容器时，它不会启动 httpd，因为它不知道如何操作。你可以通过向该剧本添加一些元数据来解决此问题：
```
- name: Serve our file using httpd
hosts: all
vars:
ansible_bender:
base_image: fedora:30
target_image:
name: our-httpd
cmd: httpd -DFOREGROUND
tasks:
- name: Install httpd
package:
name: httpd
state: installed
- name: Listen on all network interfaces.
lineinfile:
path: /etc/httpd/conf/httpd.conf
regexp: '^Listen '
line: Listen 0.0.0.0:80
- name: Copy our file to httpd’s webroot
copy:
src: our-file.txt
dest: /var/www/html
```
现在你可以构建镜像（从这里开始，请以 root 用户身份运行所有命令。目前，Buildah 和 Podman 不会为无 root 容器创建专用网络）：
```
# ansible-bender build the-playbook.yaml
PLAY [Serve our file using httpd] ****************************************************
TASK [Gathering Facts] ***************************************************************
ok: [our-httpd-20191004-131941266141-cont]
TASK [Install httpd] *****************************************************************
loaded from cache: 'f053578ed2d47581307e9ba3f64f4b4da945579a082c6f99bd797635e62befd0'
skipping: [our-httpd-20191004-131941266141-cont]
TASK [Listen on all network interfaces.] *********************************************
changed: [our-httpd-20191004-131941266141-cont]
TASK [Copy our file to httpd’s webroot] **********************************************
changed: [our-httpd-20191004-131941266141-cont]
PLAY RECAP ***************************************************************************
our-httpd-20191004-131941266141-cont : ok=3 changed=2 unreachable=0 failed=0 skipped=1 rescued=0 ignored=0
Getting image source signatures
Copying blob sha256:4650c04b851c62897e9c02c6041a0e3127f8253fafa3a09642552a8e77c044c8
Copying blob sha256:87b740bba596291af8e9d6d91e30a01d5eba9dd815b55895b8705a2acc3a825e
Copying blob sha256:82c21252bd87532e93e77498e3767ac2617aa9e578e32e4de09e87156b9189a0
Copying config sha256:44c6dc6dda1afe28892400c825de1c987c4641fd44fa5919a44cf0a94f58949f
Writing manifest to image destination
Storing signatures
44c6dc6dda1afe28892400c825de1c987c4641fd44fa5919a44cf0a94f58949f
Image 'our-httpd' was built successfully \o/
```
镜像构建完毕，可以运行容器了：
```
# podman run our-httpd
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 10.88.2.106. Set the 'ServerName' directive globally to suppress this message
```
是否提供文件了？首先，找出你容器的 IP：
```
# podman inspect -f '{{ .NetworkSettings.IPAddress }}' 7418570ba5a0
10.88.2.106
```
你现在可以检查了：
```
$ curl http://10.88.2.106/our-file.txt
Ansible is ❤
```
你文件内容是什么？
这只是使用 Ansible 构建容器镜像的介绍。如果你想了解有关 `ansible-bender` 可以做什么的更多信息，请查看它的 [GitHub](https://github.com/ansible-community/ansible-bender) 页面。构建快乐！
---
via: <https://opensource.com/article/19/10/building-container-images-ansible>
作者：[Tomas Tomecek](https://opensource.com/users/tomastomecek) 选题：[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/) 荣誉推出
|
面向对象编程和根本状态
|
Simon Arneaud
|
https://theartofmachinery.com/2019/10/13/oop_and_essential_state.html
|
早在 2015 年，Brian Will 撰写了一篇有挑衅性的博客：面向对象编程：一个灾难故事。他随后发布了一个名为面向对象编程很糟糕的视频，该视频更加详细。
|
/data/attachment/album/201910/30/232452kvdivhgb9b2yi0ug.jpg.thumb.jpg
|
/data/attachment/album/201910/30/232452kvdivhgb9b2yi0ug.jpg
| true | false | false |
geekpi
| false |
[
"OOP"
] |
软件开发
|
{
"viewnum": 6817,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
早在 2015 年，Brian Will 撰写了一篇有挑衅性的博客：面向对象编程：一个灾难故事。他随后发布了一个名为面向对象编程很糟糕的视频，该视频更加详细。
| 2019-10-31T07:00:00 | 2019-10-31T07:00:00 | 11,519 |
/article-11519-1.html
|
早在 2015 年，Brian Will 撰写了一篇有挑衅性的博客：[面向对象编程：一个灾难故事](https://medium.com/@brianwill/object-oriented-programming-a-personal-disaster-1b044c2383ab)。他随后发布了一个名为[面向对象编程很糟糕](https://www.youtube.com/watch?v=QM1iUe6IofM)的视频，该视频更加详细。
我建议你花些时间观看视频，下面是我的一段总结：
>
> OOP 的柏拉图式理想是一堆相互解耦的对象，它们彼此之间发送无状态消息。没有人真的像这样制作软件，Brian 指出这甚至没有意义：对象需要知道向哪个对象发送消息，这意味着它们需要相互引用。该视频大部分讲述的是这样一个痛点：人们试图将对象耦合以实现控制流，同时假装它们是通过设计解耦的。
>
>
>
总的来说，他的想法与我自己的 OOP 经验产生了共鸣：对象没有问题，但是我一直不满意的是*面向*对象建模程序控制流，并且试图使代码“正确地”面向对象似乎总是在创建不必要的复杂性。
有一件事我认为他无法完全解释。他直截了当地说“封装没有作用”，但在脚注后面加上“在细粒度的代码级别”，并继续承认对象有时可以奏效，并且在库和文件级别封装是可以的。但是他没有确切解释为什么有时会奏效，有时却没有奏效，以及如何和在何处划清界限。有人可能会说这使他的 “OOP 不好”的说法有缺陷，但是我认为他的观点是正确的，并且可以在根本状态和偶发状态之间划清界限。
如果你以前从未听说过“<ruby> 根本 <rt> essential </rt></ruby>”和“<ruby> 偶发 <rt> accidental </rt></ruby>”这两个术语的使用，那么你应该阅读 Fred Brooks 的经典文章《[没有银弹](http://www.cs.nott.ac.uk/%7Epszcah/G51ISS/Documents/NoSilverBullet.html)》。（顺便说一句，他写了许多很棒的有关构建软件系统的文章。）我以前曾写过[关于根本和偶发的复杂性的文章](https://theartofmachinery.com/2017/06/25/compression_complexity_and_software.html)，这里有一个简短的摘要：软件是复杂的。部分原因是因为我们希望软件能够解决混乱的现实世界问题，因此我们将其称为“根本复杂性”。“偶发复杂性”是所有其它的复杂性，因为我们正尝试使用硅和金属来解决与硅和金属无关的问题。例如，对于大多数程序而言，用于内存管理或在内存与磁盘之间传输数据或解析文本格式的代码都是“偶发的复杂性”。
假设你正在构建一个支持多个频道的聊天应用。消息可以随时到达任何频道。有些频道特别有趣，当有新消息传入时，用户希望得到通知。而其他频道静音：消息被存储，但用户不会受到打扰。你需要跟踪每个频道的用户首选设置。
一种实现方法是在频道和频道设置之间使用<ruby> 映射 <rt> map </rt></ruby>（也称为哈希表、字典或关联数组）。注意，映射是 Brian Will 所说的可以用作对象的抽象数据类型（ADT）。
如果我们有一个调试器并查看内存中的映射对象，我们将看到什么？我们当然会找到频道 ID 和频道设置数据（或至少指向它们的指针）。但是我们还会找到其它数据。如果该映射是使用红黑树实现的，我们将看到带有红/黑标签和指向其他节点的指针的树节点对象。与频道相关的数据是根本状态，而树节点是偶发状态。不过，请注意以下几点：该映射有效地封装了它的偶发状态 —— 你可以用 AVL 树实现的另一个映射替换该映射，并且你的聊天程序仍然可以使用。另一方面，映射没有封装根本状态（仅使用 `get()` 和 `set()` 方法访问数据并不是封装）。事实上，映射与根本状态是尽可能不可知的，你可以使用基本相同的映射数据结构来存储与频道或通知无关的其他映射。
这就是映射 ADT 如此成功的原因：它封装了偶发状态，并与根本状态解耦。如果你思考一下，Brian 用封装描述的问题就是尝试封装根本状态。其他描述的好处是封装偶发状态的好处。
要使整个软件系统都达到这一理想状况相当困难，但扩展开来，我认为它看起来像这样：
* 没有全局的可变状态
* 封装了偶发状态（在对象或模块或以其他任何形式）
* 无状态偶发复杂性封装在单独函数中，与数据解耦
* 使用诸如依赖注入之类的技巧使输入和输出变得明确
* 组件可由易于识别的位置完全拥有和控制
其中有些违反了我很久以来的直觉。例如，如果你有一个数据库查询函数，如果数据库连接处理隐藏在该函数内部，并且唯一的参数是查询参数，那么接口会看起来会更简单。但是，当你使用这样的函数构建软件系统时，协调数据库的使用实际上变得更加复杂。组件不仅以自己的方式做事，而且还试图将自己所做的事情隐藏为“实现细节”。数据库查询需要数据库连接这一事实从来都不是实现细节。如果无法隐藏某些内容，那么显露它是更合理的。
我对将面向对象编程和函数式编程放在对立的两极非常警惕，但我认为从函数式编程进入面向对象编程的另一极端是很有趣的：OOP 试图封装事物，包括无法封装的根本复杂性，而纯函数式编程往往会使事情变得明确，包括一些偶发复杂性。在大多数时候，这没什么问题，但有时候（比如[在纯函数式语言中构建自我指称的数据结构](https://wiki.haskell.org/Tying_the_Knot)）设计更多的是为了函数编程，而不是为了简便（这就是为什么 [Haskell 包含了一些“<ruby> 逃生出口 <rt> escape hatches </rt></ruby>”](https://en.wikibooks.org/wiki/Haskell/Mutable_objects#The_ST_monad)）。我之前写过一篇[所谓“<ruby> 弱纯性 <rt> weak purity </rt></ruby>”的中间立场](https://theartofmachinery.com/2016/03/28/dirtying_pure_functions_can_be_useful.html)。
Brian 发现封装对更大规模有效，原因有几个。一个是，由于大小的原因，较大的组件更可能包含偶发状态。另一个是“偶发”与你要解决的问题有关。从聊天程序用户的角度来看，“偶发的复杂性”是与消息、频道和用户等无关的任何事物。但是，当你将问题分解为子问题时，更多的事情就变得“根本”。例如，在解决“构建聊天应用”问题时，可以说频道名称和频道 ID 之间的映射是偶发的复杂性，而在解决“实现 `getChannelIdByName()` 函数”子问题时，这是根本复杂性。因此，封装对于子组件的作用比对父组件的作用要小。
顺便说一句，在视频的结尾，Brian Will 想知道是否有任何语言支持*无法*访问它们所作用的范围的匿名函数。[D](https://dlang.org) 语言可以。 D 中的匿名 Lambda 通常是闭包，但是如果你想要的话，也可以声明匿名无状态函数：
```
import std.stdio;
void main()
{
int x = 41;
// Value from immediately executed lambda
auto v1 = () {
return x + 1;
}();
writeln(v1);
// Same thing
auto v2 = delegate() {
return x + 1;
}();
writeln(v2);
// Plain functions aren't closures
auto v3 = function() {
// Can't access x
// Can't access any mutable global state either if also marked pure
return 42;
}();
writeln(v3);
}
```
---
via: <https://theartofmachinery.com/2019/10/13/oop_and_essential_state.html>
作者：[Simon Arneaud](https://theartofmachinery.com) 选题：[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/) 荣誉推出
|
||
2019 年最可怕的黑客事件与安全漏洞（下）
|
Catalin Cimpanu
|
https://www.zdnet.com/article/the-scariest-hacks-and-vulnerabilities-of-2019/
|
是的，这是年终摘要文章之一。这是一篇很长的文章，因为就网络安全新闻来说，2019 年就是一场灾难，每周都会有一个或多个重大事件发生。
|
/data/attachment/album/201910/30/234824ok4qo2o5rryyrwd5.png.thumb.jpg
|
/data/attachment/album/201910/30/234824ok4qo2o5rryyrwd5.png
| true | false | true |
wxy
| false |
[
"安全"
] |
观点
|
{
"viewnum": 6662,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11516,
"displayorder": 0
}
] |
是的，这是年终摘要文章之一。这是一篇很长的文章，因为就网络安全新闻来说，2019 年就是一场灾难，每周都会有一个或多个重大事件发生。
| 2019-10-31T07:02:00 | 2019-10-31T07:02:00 | 11,520 |
/article-11520-1.html
|
是的，这是年终摘要文章之一。这是一篇很长的文章，因为就网络安全新闻来说，2019 年就是一场灾难，每周都会有一个或多个重大事件发生。
以下是按月组织的过去 10 个月安全灾难的摘要。
### 七月
[哈萨克斯坦政府拦截了所有本地 HTTPS 流量](https://www.zdnet.com/article/kazakhstan-government-is-now-intercepting-all-https-traffic/)：HTTPS 拦截工作[针对 Facebook，Google，Twitter 和其他站点](https://www.zdnet.com/article/kazakhstans-https-interception-efforts-target-facebook-google-twitter-others/)。[苹果、谷歌和 Mozilla](https://www.zdnet.com/article/apple-google-and-mozilla-block-kazakhstans-https-intercepting-certificate/) 最终干预并禁止了用于 HTTPS 中间人攻击的证书。
[黑客窃取了数百万保加利亚人的数据](https://www.zdnet.com/article/hacker-steals-data-of-millions-of-bulgarians-emails-it-to-local-media/)：一名黑客窃取了数百万保加利亚人的个人详细信息，并将窃取的数据的下载链接通过电子邮件发送给了本地新闻出版物。该数据窃取自该国国家税务局，[最终在网上泄露](https://www.zdnet.com/article/bulgarias-hacked-database-is-now-available-on-hacking-forums/)。
[黑客侵入了 FSB 的承包商](https://www.zdnet.com/article/hackers-breach-fsb-contractor-expose-tor-deanonymization-project/)：黑客侵入了俄罗斯国家情报局 FSB 的承包商 SyTech，他们从那里窃取了该公司代表该机构开展的内部项目的信息，包括将 Tor 流量匿名化的信息。
[iMessages 可能使你的 iPhone 变砖](https://www.zdnet.com/article/google-project-zero-reveals-bad-imessages-could-have-bricked-your-iphone/)：该漏洞在被广泛利用之前得到了修补。
[Urgent/11 安全漏洞](https://www.zdnet.com/article/urgent11-security-flaws-impact-routers-printers-scada-and-many-iot-devices/)：TCP 库中的主要错误影响了路由器、打印机、SCADA、医疗设备和许多 IoT 设备。
[苹果公司的 AWDL 协议受到安全漏洞的困扰](https://www.zdnet.com/article/apples-awdl-protocol-plagued-by-flaws-that-enable-tracking-and-mitm-attacks/)：苹果公司在五月份修补了一个错误，但学者说，其余的漏洞需要重新设计某些苹果服务。错误会启用跟踪和中间人攻击。
[DHS 警告小型飞机的 CAN 总线漏洞](https://www.zdnet.com/article/dhs-warns-about-can-bus-vulnerabilities-in-small-aircraft/)：DHS 网络安全机构 CISA 建议这些小型飞机的所有者“尽其所能”限制对飞机的访问，以防止这个漏洞可能被用来破坏飞机。
[GE 麻醉机中发现的漏洞](https://www.zdnet.com/article/vulnerabilities-found-in-ge-anesthesia-machines/)：GE 建议设备所有者不要将脆弱的麻醉机连接到医院的主要网络。该公司否认这些漏洞可能导致患者受到伤害，但后来撤回该说法并承认这些问题可能对人类生命构成危险。
[洛杉矶警方陷入数据泄露](https://www.zdnet.com/article/thousands-of-los-angeles-police-caught-up-in-data-breach-personal-records-stolen/)：黑客窃取了 2500 多名洛杉矶警察的个人记录。黑客直接通过电子邮件发送给该部门，并提供了一些据称是被盗信息的样本以支持他们的说法。
[路易斯安那州州长在当地勒索软件爆发后宣布州紧急状态](https://www.zdnet.com/article/louisiana-governor-declares-state-emergency-after-local-ransomware-outbreak/)：是的。勒索软件变得非常糟糕。然后它[袭击了德克萨斯州](https://www.zdnet.com/article/at-least-20-texas-local-governments-hit-in-coordinated-ransomware-attack/)、[牙医办公室](https://www.zdnet.com/article/ransomware-hits-hundreds-of-dentist-offices-in-the-us/)和[托管服务提供商](https://www.zdnet.com/article/ransomware-gang-hacks-msps-to-deploy-ransomware-on-customer-systems/)。
[蓝牙漏洞利用可以跟踪和识别 iOS、微软移动设备用户](https://www.zdnet.com/article/bluetooth-vulnerability-can-be-exploited-to-track-and-id-iphone-smartwatch-microsoft-tablet-users/)：尽管存在本机操作系统保护但该漏洞可用于监视用户，它影响 Windows 10、iOS 和 macOS 计算机上的蓝牙设备。其中包括 iPhone、iPad、Apple Watch、MacBook 和微软的平板电脑和笔记本电脑。
[“7-11” 日本的客户由于移动应用漏洞而损失了 50 万美元](https://www.zdnet.com/article/7-eleven-japanese-customers-lose-500000-due-to-mobile-app-flaw/)：7-11 最终关闭了该应用。
### 八月
[SWAPGSAttack CPU 漏洞](https://www.zdnet.com/article/new-windows-hack-warning-patch-intel-systems-now-to-block-swapgsattack-exploits/)：研究人员详细介绍了该硬件漏洞，它绕过了 Windows 系统上针对 Spectre 和 Meltdown CPU 漏洞的缓解措施，并影响了所有使用自 2012 年以来制造的英特尔处理器的系统。
[新的 Dragonblood 漏洞](https://www.zdnet.com/article/new-dragonblood-vulnerabilities-found-in-wifi-wpa3-standard/)：今年四月初，两名安全研究人员披露了 WiFi 联盟最近发布的 WPA3 WiFi 安全和身份验证标准中五个漏洞（[统称为 Dragonblood](https://www.zdnet.com/article/dragonblood-vulnerabilities-disclosed-in-wifi-wpa3-standard/)）的详细信息。
[14 个 iOS 零日漏洞](https://www.zdnet.com/article/google-finds-malicious-sites-pushing-ios-exploits-for-years/)：自 2016 年 9 月以来，谷歌发现了针对 14 个 iOS 漏洞的攻击，这些漏洞分为五个漏洞利用链，并已被广泛部署。
[VPN 安全漏洞](https://www.zdnet.com/article/hackers-mount-attacks-on-webmin-servers-pulse-secure-and-fortinet-vpns/)：黑客对 Pulse Secure 和 Fortinet VPN 发起攻击。
[Windows CTF 漏洞](https://www.zdnet.com/article/vulnerability-in-microsoft-ctf-protocol-goes-back-to-windows-xp/)：Microsoft CTF 协议中的漏洞可以追溯到 Windows XP。该错误允许黑客劫持任何 Windows 应用，逃脱沙箱并获得管理员权限。
[WS-Discovery 协议被滥用于 DDoS 攻击](https://www.zdnet.com/article/protocol-used-by-630000-devices-can-be-abused-for-devastating-ddos-attacks/)：该协议被 DDoS 租用服务所利用，已在实际攻击中使用。
[Capitol One 黑客事件](https://www.zdnet.com/article/100-million-americans-and-6-million-canadians-caught-up-in-capital-one-breach/)：一名黑客侵入了 Capitol One，从那里窃取了 1 亿用户的记录。她还[入侵了其他 30 家公司](https://www.zdnet.com/article/capital-one-hacker-took-data-from-more-than-30-companies-new-court-docs-reveal/)。
[Hy-Vee 卡泄露](https://www.zdnet.com/article/hy-vee-issues-warning-to-customers-after-discovering-point-of-sale-breach/)：超市连锁店 Hy-Vee 承认其某些 PoS 系统存在安全漏洞。该数据最终被在黑客论坛上出售。
[员工将核电厂连接到互联网，以便他们可以开采加密货币](https://www.zdnet.com/article/employees-connect-nuclear-plant-to-the-internet-so-they-can-mine-cryptocurrency/)：乌克兰核电厂的员工为了开采比特币而承担了不必要的安全风险。他们最终被捕。
[莫斯科的区块链投票系统在大选前一个月就被攻破了](https://www.zdnet.com/article/moscows-blockchain-voting-system-cracked-a-month-before-election/)：法国研究人员因在基于以太坊的投票系统中发现漏洞而获得 15000 美元的奖金。
[美国军方购买了价值 3280 万美元的具有已知安全风险的电子产品](https://www.zdnet.com/article/us-military-purchased-32-8m-worth-of-electronics-with-known-security-risks/)：国防部购买的易受攻击产品包括 Lexmark 打印机、GoPro相机和联想计算机。
[AT＆T 员工受贿以在公司网络上植入恶意软件](https://www.zdnet.com/article/at-t-employees-took-bribes-to-plant-malware-on-the-companys-network/)：美国司法部指控巴基斯坦男子贿赂 AT＆T 员工超过 100 万美元，以在该公司网络上安装恶意软件，解锁超过 200 万台设备。
[Windows 恶意软件会记录用户在成人网站上的访问](https://www.zdnet.com/article/windows-malware-strain-records-users-on-adult-sites/)：新的 Varenyky 木马会记录用户浏览成人网站的桌面视频。当前仅针对法国用户。
[TrickBot 木马具备协助 SIM 交换攻击的功能](https://www.zdnet.com/article/trickbot-todays-top-trojan-adds-feature-to-aid-sim-swapping-attacks/)：TrickBot 木马可以收集 Sprint、T-Mobile 和 Verizon Wireless 帐户的凭据和 PIN 码。
[战争技术](https://www.zdnet.com/article/new-warshipping-technique-gives-hackers-access-to-enterprise-offices/)：黑客可以使用包裹传递服务将黑客设备直接运送到你公司的门口。
[Instagram 踢掉了广告合作伙伴 Hyp3r](https://www.zdnet.com/article/instagram-boots-ad-partner-hyp3r-for-mass-collection-of-user-data/)：Instagram 发现该广告合作伙伴收集其用户数据。
### 九月
[Simjacker 攻击](https://www.zdnet.com/article/new-simjacker-attack-exploited-in-the-wild-to-track-users-for-at-least-two-years/)：安全研究人员详细介绍了一种基于 SMS 的攻击，该攻击可以通过滥用 SIM 卡上运行的鲜为人知的应用程序，使恶意行为者可以跟踪用户的设备。发现 [29 个国家/地区](https://www.zdnet.com/article/these-are-the-29-countries-vulnerable-to-simjacker-attacks/)的 SIM 卡受到了影响。 还发现了第二起名为 [WIBAttack](https://www.zdnet.com/article/new-sim-card-attack-disclosed-similar-to-simjacker/) 的攻击。
[智能电视间谍活动](https://www.zdnet.com/article/smart-tvs-send-user-data-to-tech-heavyweights-including-facebook-google-netflix/)：两项学术论文发现，智能电视正在收集有关用户的电视观看习惯的数据。
[Checkm8 iOS 越狱](https://www.zdnet.com/article/new-checkm8-jailbreak-released-for-all-ios-devices-running-a5-to-a11-chips/)：针对所有运行 A5 至 A11 芯片的 iOS 设备（在 iPhone 4S 以及 iPhone 8 和 X 上）发布的新 Checkm8 越狱。过去九年来，这是第一个在硬件级别起作用的越狱漏洞。
[数据库泄漏了厄瓜多尔大多数公民的数据](https://www.zdnet.com/article/database-leaks-data-on-most-of-ecuadors-citizens-including-6-7-million-children/)：Elasticsearch 服务器泄漏了有关厄瓜多尔公民其家谱和孩子的个人数据，还泄漏了一些用户的财务记录和汽车登记信息。[该公司高管随后被捕](https://www.zdnet.com/article/arrest-made-in-ecuadors-massive-data-breach/)。
[Limin PDF 泄露事件](https://www.zdnet.com/article/data-of-24-3-million-lumin-pdf-users-shared-on-hacking-forum/)：九月中旬，超过 2430 万 Lumin PDF 的用户详细信息在黑客论坛上被分享。该公司在第二天承认这次泄露。
[Heyyo 约会应用程序泄漏事件](https://www.zdnet.com/article/heyyo-dating-app-leaked-users-personal-data-photos-location-data-more/)：他们泄漏了除私人消息以外的几乎所有内容。
[vBulletin 零日漏洞和随后的黑客攻击](https://www.zdnet.com/article/anonymous-researcher-drops-vbulletin-zero-day-impacting-tens-of-thousands-of-sites/)：一位匿名安全研究人员发布了 vBulletin 论坛软件中的零日漏洞。该漏洞立即被黑客用于入侵一系列论坛。
[大量的帐户劫持事件袭击了 YouTube 创作者](https://www.zdnet.com/article/massive-wave-of-account-hijacks-hits-youtube-creators/)：汽车社区的 YouTube 创作者遭受了鱼叉式网络钓鱼攻击，这些攻击可以绕过 2FA，从而使黑客可以接管其 Google 和 YouTube 帐户。
[Lilocked（Lilu）勒索软件](https://www.zdnet.com/article/thousands-of-servers-infected-with-new-lilocked-lilu-ransomware/)：成千上万的 Linux 服务器感染了新的 Lilocked（Lilu）勒索软件。
[超过 47,000 台超微服务器正在互联网上暴露了其 BMC 端口](https://www.zdnet.com/article/over-47000-supermicro-servers-are-exposing-bmc-ports-on-the-internet/)：研究人员在超微服务器上发现了一个新的远程攻击方式，发现它在互联网上暴露了其 BMC 端口。
[勒索软件事件给公司造成了高达 9500 万美元的损失](https://www.zdnet.com/article/ransomware-incident-to-cost-danish-company-a-whopping-95-million/)：丹麦制造助听器 Demant 的勒索软件事件造成了近 9500 万美元的损失，这是迄今为止最昂贵的事件之一。
[Exim 漏洞（CVE-2019-15846）](https://www.zdnet.com/article/millions-of-exim-servers-vulnerable-to-root-granting-exploit/)：数百万的 Exim 服务器容易受到一个安全漏洞的攻击，利用该漏洞可以使攻击者能够以 root 特权运行恶意代码。
### 十月
[Avast 黑客事件](https://www.zdnet.com/article/avast-says-hackers-breached-internal-network-through-compromised-vpn-profile/)：这家捷克的杀毒软件制造商在 2017 年遭受攻击之后，披露了其受到了第二次攻击，旨在破坏 CCleaner 版本。该公司表示，黑客通过受损的 VPN 配置文件破坏了该公司。
[被广泛利用的 Android 零日漏洞](https://www.zdnet.com/article/google-finds-android-zero-day-impacting-pixel-samsung-huawei-xiaomi-devices/)：Google Project Zero 研究人员发现了被广泛利用的 Android 零日漏洞，影响了 Pixel、三星、华为、小米设备。
[Alexa 和 Google Home 设备再次被利用来网络钓鱼和窃听用户](https://www.zdnet.com/article/alexa-and-google-home-devices-leveraged-to-phish-and-eavesdrop-on-users-again/)：亚马逊、Google 在首次报告后一年多未能解决 Alexa 和 Home 设备中的安全漏洞。
[捷克当局拆除了据称是俄罗斯的网络间谍网络](https://www.zdnet.com/article/czech-authorities-dismantle-alleged-russian-cyber-espionage-network/)：捷克官员说，俄罗斯特工利用当地公司对外国目标发起网络攻击。官员们表示，运营得到了俄罗斯国家情报局 FSB 的支持以及当地大使馆的财政帮助。
[约翰内斯堡被黑客团伙勒索赎金](https://www.zdnet.com/article/city-of-johannesburg-held-for-ransom-by-hacker-gang/)：一个名为“Shadow Kill Hackers”的组织正在向当地官员索要 4 枚比特币，否则他们将在线发布该城市数据。这是在七月遭到勒索软件攻击之后对约翰内斯堡的第二次重大袭击，当时导致一些当地居民[断电](https://www.zdnet.com/article/ransomware-incident-leaves-some-johannesburg-residents-without-electricity/)。
[CPDoS 攻击事件](https://www.zdnet.com/article/cpdos-attack-can-poison-cdns-to-deliver-error-pages-instead-of-legitimate-sites/)：CloudFront、Cloudflare、Fastly、Akamai 等受到新的 CPDoS Web 缓存中毒攻击的影响。
[被广泛利用的 PHP7 RCE](https://www.zdnet.com/article/nasty-php7-remote-code-execution-bug-exploited-in-the-wild/)：新的 PHP7 错误 CVE-2019-11043 甚至可以使非技术攻击者接管运行 PHP-FPM 模块的 Nginx 服务器。
[遭受 DDoS 攻击的 macOS 系统](https://www.zdnet.com/article/macos-systems-abused-in-ddos-attacks/)：多达 4 万个 macOS 系统在线暴露了一个特定的端口，该端口可能被滥用于相当大的 DDoS 攻击。
|
||
Fedora 31 正式发布
|
Matthew Miller
|
https://fedoramagazine.org/announcing-fedora-31/
|
这里，我们很荣幸地宣布 Fedora 31 的发布。感谢成千上万的 Fedora 社区成员和贡献者的辛勤工作，我们现在正在庆祝又一次的准时发布。这已成为一种惯例！
|
/data/attachment/album/201910/31/081800segipgcqazg2gi8q.jpg.thumb.jpg
|
/data/attachment/album/201910/31/081800segipgcqazg2gi8q.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Fedora"
] |
新闻
|
{
"viewnum": 5286,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "114.92.29.72",
"message": "昨晚在虚拟机里安装了一下，源的速度很快。<br />\r\n很喜欢fedora，祝愿越来越好。",
"username": "来自上海的 Chrome 78.0|Mac 10.15 用户",
"date": "2019-10-31T11:22:57"
},
{
"postip": "113.98.224.193",
"message": "最爱fedora!",
"username": "白栋毅 [Chrome 79.0|Windows 10]",
"date": "2019-10-31T22:34:47"
},
{
"postip": "210.21.68.56",
"message": "已经用上了，感觉不错！",
"username": "白栋毅 [Firefox 71.0|Fedora]",
"date": "2019-12-20T21:10:12"
}
] |
[] |
这里，我们很荣幸地宣布 Fedora 31 的发布。感谢成千上万的 Fedora 社区成员和贡献者的辛勤工作，我们现在正在庆祝又一次的准时发布。这已成为一种惯例！
| 2019-10-31T08:17:57 | 2019-10-31T08:17:57 | 11,522 |
/article-11522-1.html
|
这里，我们很荣幸地宣布 Fedora 31 的发布。感谢成千上万的 Fedora 社区成员和贡献者的辛勤工作，我们现在正在庆祝又一次的准时发布。这已成为一种惯例！
如果你只想立即获取它，请立即访问 <https://getfedora.org/>。要了解详细信息，请继续阅读！
### 工具箱
如果你还没有使用过 [Fedora 工具箱](https://docs.fedoraproject.org/en-US/fedora-silverblue/toolbox/)，那么现在是尝试一下的好时机。这是用于启动和管理个人工作区容器的简单工具，你可以在一个单独的环境中进行开发或试验。它只需要在命令行运行 `toolbox enter` 就行。
这种容器化的工作流程对于基于 ostree 的 Fedora 变体（如 CoreOS、IoT 和 Silverblue）的用户至关重要，但在任何工作站甚至服务器系统上也非常有用。在接下来的几个月中，希望对该工具及其相关的用户体验进行更多增强，非常欢迎你提供反馈。
### Fedora 风味版
Fedora 的“版本”是针对特定的“展示柜”用途输出的。
Fedora 工作站版本专注于台式机，以及希望获得“可以工作的” Linux 操作系统体验的特定软件开发人员。此版本具有 GNOME 3.34，它带来了显著的性能增强，在功耗较低的硬件上尤其明显。
Fedora 服务器版本以易于部署的方式为系统管理员带来了最新的、最先进的开源服务器软件。
而且，我们还有处于预览状态下的 Fedora CoreOS（一个定义了现代容器世界分类的操作系统）和[Fedora IoT](https://iot.fedoraproject.org/)（用于“边缘计算”用例）。（敬请期待计划中的给该物联网版本的征集名称的活动！）
当然，我们不仅仅提供的是各种版本。还有面向各种受众和用例的 [Fedora Spins](https://spins.fedoraproject.org/) 和 [Labs](https://labs.fedoraproject.org/)，包括 [Fedora 天文学](https://labs.fedoraproject.org/en/astronomy/) 版本，为业余和专业的天文学家带来了完整的开源工具链，以及支持各种桌面环境（例如 [KDE Plasma](https://spins.fedoraproject.org/en/kde/) 和 [Xfce](https://spins.fedoraproject.org/en/xfce/)）。
而且，请不要忘记我们的替代架构 [ARM AArch64、Power 和 S390x](https://alt.fedoraproject.org/alt/)。特别要注意的是，我们对包括 Rock960、RockPro64 和 Rock64 在内的 Rockchip 片上系统设备的支持得到了改善，并初步支持了 “[panfrost](https://panfrost.freedesktop.org/)”，这是一种较新的开源 3D 加速图形驱动程序 Arm Mali midgard GPU。
不过，如果你使用的是只支持 32 位的 i686 旧系统，那么该找个替代方案了，[我们的基本系统告别了 32 位 Intel 架构](https://fedoramagazine.org/in-fedora-31-32-bit-i686-is-86ed/)。
### 常规改进
无论你使用哪种 Fedora 版本，你都将获得开源世界所提供的最新版本。遵循 “[First](https://docs.fedoraproject.org/en-US/project/#_first)” 准则，我们启用了 CgroupsV2（如果你使用的是 Docker，[请确保检查一下](https://fedoraproject.org/wiki/Common_F31_bugs#Docker_package_no_longer_available_and_will_not_run_by_default_.28due_to_switch_to_cgroups_v2.29)）。Glibc 2.30 和 NodeJS 12 是 Fedora 31 中许多更新的软件包之一。而且，我们已经将 `python` 命令切换为 Python 3，请记住，Python 2 在[今年年底](https://pythonclock.org/)生命期就终止了。
我们很高兴你能试用新版本！转到 <https://getfedora.org/> 并立即下载吧。或者，如果你已经在运行 Fedora 操作系统，请遵循简单的[升级说明](https://docs.fedoraproject.org/en-US/quick-docs/upgrading/)就行。
### 万一出现问题……
如果遇到问题，请查看 [Fedora 31 常见错误](https://fedoraproject.org/wiki/Common_F31_bugs)页面，如果有疑问，请访问我们的 [Ask Fedora](http://ask.fedoraproject.org) 用户支持平台。
### 谢谢大家
感谢在此发行周期中成千上万为 Fedora 项目做出贡献的人们，尤其是那些为使该发行版再次按时发行而付出更多努力的人。而且，如果你本周在波特兰参加 [USENIX LISA](https://www.usenix.org/conference/lisa19)，请在博览会大厅，在 Red Hat、Fedora 和 CentOS 展位找到我。
---
via: <https://fedoramagazine.org/announcing-fedora-31/>
作者：[Matthew Miller](https://fedoramagazine.org/author/mattdm/) 选题：[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/) 荣誉推出
|
使用 GNOME 优化工具自定义 Linux 桌面的 10 种方法
|
Abhishek Prakash
|
https://itsfoss.com/gnome-tweak-tool/
|
你可以通过多种方法来调整 Ubuntu，以自定义其外观和行为。我发现最简单的方法是使用 GNOME 优化工具。
|
/data/attachment/album/201910/31/182712cxeq2vvble33zie3.jpg.thumb.jpg
|
/data/attachment/album/201910/31/182712cxeq2vvble33zie3.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Ubuntu",
"GNOME"
] |
桌面应用
|
{
"viewnum": 12664,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你可以通过多种方法来调整 Ubuntu，以自定义其外观和行为。我发现最简单的方法是使用 GNOME 优化工具。
| 2019-10-31T18:27:08 | 2019-10-31T18:27:08 | 11,523 |
/article-11523-1.html
|
你可以通过多种方法来调整 Ubuntu，以自定义其外观和行为。我发现最简单的方法是使用 [GNOME 优化工具](https://wiki.gnome.org/action/show/Apps/Tweaks?action=show&redirect=Apps%2FGnomeTweakTool)。它也被称为 GNOME Tweak 或简单地称为 Tweak（优化）。
在过去的教程中，我已经多次介绍过它。在这里，我列出了你可以使用此工具执行的所有主要优化。
我在这里使用的是 Ubuntu，但是这些步骤应该适用于使用 GNOME 桌面环境的任何 Linux 发行版。
### 在 Ubuntu 18.04 或其它版本上安装 GNOME 优化工具
GNOME 优化工具可从 [Ubuntu 中的 Universe 存储库](https://itsfoss.com/ubuntu-repositories/)中安装，因此请确保已在“软件和更新”工具中启用了该仓库：
之后，你可以从软件中心安装 GNOME 优化工具。只需打开软件中心并搜索 “GNOME Tweaks” 并从那里安装它：
或者，你也可以使用命令行通过 [apt 命令](https://itsfoss.com/apt-command-guide/)安装此软件：
```
sudo apt install gnome-tweaks
```
### 用优化工具定制 GNOME 桌面
GNOME 优化工具使你可以进行许多设置更改。其中的某些更改（例如墙纸更改、启动应用程序等）也可以在官方的“系统设置”工具中找到。我将重点介绍默认情况下“设置”中不可用的优化。
#### 1、改变主题
你可以通过各种方式[在 Ubuntu 中安装新主题](https://itsfoss.com/install-themes-ubuntu/)。但是，如果要更改为新安装的主题，则必须安装GNOME 优化工具。
你可以在“<ruby> 外观 <rt> Appearance </rt></ruby>”部分找到主题和图标设置。你可以浏览可用的主题和图标并设置你喜欢的主题和图标。更改将立即生效。
#### 2、禁用动画以提速你的桌面体验
应用程序窗口的打开、关闭、最大化等操作都有一些细微的动画。你可以禁用这些动画以稍微加快系统的速度，因为它会稍微使用一点资源。
#### 3、控制桌面图标
至少在 Ubuntu 中，你会在桌面上看到“<ruby> 家目录 <rt> Home </rt></ruby>”和“<ruby> 垃圾箱 <rt> Trash </rt></ruby>”图标。如果你不喜欢，可以选择禁用它。你还可以选择要在桌面上显示的图标。
#### 4、管理 GNOME 扩展
我想你可能知道 [GNOME 扩展](https://extensions.gnome.org/)。这些是用于桌面的小型“插件”，可扩展 GNOME 桌面的功能。有[大量的 GNOME 扩展](https://itsfoss.com/best-gnome-extensions/)，可用于在顶部面板中查看 CPU 消耗、获取剪贴板历史记录等等。
我已经写了一篇[安装和使用 GNOME 扩展](https://itsfoss.com/gnome-shell-extensions/)的详细文章。在这里，我假设你已经在使用它们，如果是这样，可以从 GNOME 优化工具中对其进行管理。
#### 5、改变字体和缩放比例
你可以[在 Ubuntu 中安装新字体](https://itsfoss.com/install-fonts-ubuntu/)，并使用这个优化工具在系统范围应用字体更改。如果你认为桌面上的图标和文本太小，也可以更改缩放比例。
#### 6、控制触摸板行为，例如在键入时禁用触摸板，使触摸板右键单击可以工作
GNOME 优化工具还允许你在键入时禁用触摸板。如果你在笔记本电脑上快速键入，这将很有用。手掌底部可能会触摸触摸板，并导致光标移至屏幕上不需要的位置。
在键入时自动禁用触摸板可解决此问题。
你还会注意到[当你按下触摸板的右下角以进行右键单击时，什么也没有发生](https://itsfoss.com/fix-right-click-touchpad-ubuntu/)。你的触摸板并没有问题。这是一项系统设置，可对没有实体右键按钮的任何触摸板（例如旧的 Thinkpad 笔记本电脑）禁用这种右键单击功能。两指点击可为你提供右键单击操作。
你也可以通过在“<ruby> 鼠标单击模拟 <rt> Mouse Click Simulation </rt></ruby>”下设置为“<ruby> 区域 <rt> Area </rt></ruby>”中而不是“<ruby> 手指 <rt> Fingers </rt></ruby>”来找回这项功能。
你可能必须[重新启动 Ubuntu](https://itsfoss.com/schedule-shutdown-ubuntu/) 来使这项更改生效。如果你是 Emacs 爱好者，还可以强制使用 Emacs 键盘绑定。
#### 7、改变电源设置
电源这里只有一个设置。它可以让你在盖上盖子后将笔记本电脑置于挂起模式。
#### 8、决定什么显示在顶部面板
桌面的顶部面板显示了一些重要的信息。在这里有日历、网络图标、系统设置和“<ruby> 活动 <rt> Activities </rt></ruby>”选项。
你还可以[显示电池百分比](https://itsfoss.com/display-battery-ubuntu/)、添加日期及时间，并显示星期数。你还可以启用鼠标热角，以便将鼠标移至屏幕的左上角时可以获得所有正在运行的应用程序的活动视图。
如果将鼠标焦点放在应用程序窗口上，你会注意到其菜单显示在顶部面板中。如果你不喜欢这样，可以将其关闭，然后应用程序菜单将显示应用程序本身。
#### 9、配置应用窗口
你可以决定是否在应用程序窗口中显示最大化和最小化选项（右上角的按钮）。你也可以改变它们的位置到左边或右边。
这里还有其他一些配置选项。我不使用它们，但你可以自行探索。
#### 10、配置工作区
GNOME 优化工具还允许你围绕工作区配置一些内容。
### 总结
对于任何 GNOME 用户，GNOME 优化（Tweaks）工具都是必备工具。它可以帮助你配置桌面的外观和功能。 我感到惊讶的是，该工具甚至没有出现在 Ubuntu 的主存储库中。我认为应该默认安装它，要不，你就得在 Ubuntu 中手动安装 GNOME 优化工具。
如果你在 GNOME 优化工具中发现了一些此处没有讨论的隐藏技巧，为什么不与大家分享呢？
---
via: <https://itsfoss.com/gnome-tweak-tool/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[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 中国徽标征集活动结果
|
老王
|
一等奖空缺，维持原徽标不变，二三等奖作品奖品翻倍。
|
/data/attachment/album/201911/01/000424jszdtatzq0lzptq7.jpg.thumb.jpg
|
/data/attachment/album/201911/01/000424jszdtatzq0lzptq7.jpg
| true | false | false | false |
[
"Linux中国",
"徽标"
] |
新闻
|
{
"viewnum": 5754,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "180.140.32.113",
"message": "把原Logo的背景色由黑色换成别的彩色试一试？象深蓝色或Ubuntu的紫色？",
"username": "来自广西桂林的 Firefox 70.0|Ubuntu 用户",
"date": "2019-11-04T08:46:57"
},
{
"postip": "36.101.26.32",
"message": "所有获奖者奖金均已送出，感谢诸位中奖和未中奖的贡献者！",
"username": "linux [Chrome 78.0|Mac 10.14]",
"date": "2019-11-04T08:51:17"
}
] |
[
{
"raid": 11488,
"displayorder": 0
}
] |
一等奖空缺，维持原徽标不变，二三等奖作品奖品翻倍。
| 2019-11-01T00:29:00 | 2019-11-01T00:29:00 | 11,524 |
/article-11524-1.html
|
一个月多前，我们发起了 [Linux 中国徽标征集活动](/article-11363-1.html)，陆续得到了诸位朋友的[鼎力支持](/article-11407-1.html)，并于 10 天前进入了[公开评选意见征集](/article-11488-1.html)阶段。
说实话，这次活动的举办有点仓促，我们并没有做好完美的活动计划。所以，活动中也出现了一些不足，如一些对 GitHub 操作不熟悉或非技术圈的朋友对如何通过 GitHub 提交投稿感到困难；也有一些朋友从根本上不认可征集活动，觉得原来的徽标就挺习惯，或者适当改改就行；最后，我们在公开征集过程中，通过微信投票时还出了乌龙，过多的投稿选项导致不恰当地分成了两个问题，从而影响了投票公正性。
后来，不得已，又再次根据投票结果筛选掉部分票数较低的作品，重新发起了投票。（在这次投票中，误筛选掉 water0902 这份作品，特别不好意思，再次向作者道歉。）
其实，在第一次投票后期，我们就尴尬的发现，居然还是我们原本的徽标得到票数最高。而在第二次投票结果中，原本的徽标的票数位列第二名。而 JUNEN-1 这个作品在第一次投票中的票数几乎和原本的徽标所得票数一样，第二次投票中得到了更高的票数，位列第一名。具体得票情况如下：
| | | |
| --- | --- | --- |
| 投稿作品名 | 第一次投票数 | 第二次投票数 |
| 原本的徽标 | **182** | **149** |
| JUNEN-1 | **181** | **163** |
| JUNEN-2 | **167** | **136** |
| whsasf\_work3 | 126 | 8 |
| whsasf\_work2 | 120 | 8 |
| alim0x | 86 | 55 |
| garywill | 61 | 38 |
| Logo0964 | 60 | 35 |
| wxy | 58 | 27 |
| tinnx | 57 | 30 |
| lightyisu | 56 | 26 |
| RedInLinux | 55 | 24 |
| lightyisu2 | 47 | 37 |
| aimeDesign | 44 | 71 |
| 1466587594 | 40 | 32 |
| CodingOctocat | 36 | 16 |
| logoyk | 36 | 30 |
| water0902 | 32 | N/A |
| SmarterC | 29 | 18 |
| hacker | 27 | 19 |
| WSJ | 27 | 19 |
| long | 25 | 7 |
| icekylin-design-2 | 24 | 22 |
| ZIN | 23 | 10 |
| icekylin-design-3 | 20 | 8 |
| OLC | 19 | N/A |
| schiway | 17 | N/A |
| flag | 14 | N/A |
| icekylin-design-1 | 14 | N/A |
| logo0281 | 13 | N/A |
| Fine | 11 | N/A |
| kokialoves | 8 | 0 |
| lartpang | 8 | 0 |
| whsasf\_work | 8 | 0 |
在这次徽标征集活动当中，这些投票数是我们的重要参考依据，但是不是唯一依据，经过团队内部合议，我们决定仍维持原本的徽标，但是会做精简风格处理。因此，一等奖空缺。
二等奖我们决定授予 **JUNEN**，空缺一名，他提交了多份作品，而且作品均得到了比较广泛的好评。考虑到一等奖空缺，我决定将二等奖的单个奖金提升至 1000 元。
三等奖我们决定扩大到十名，授予 **alim0x**、**garywill**、**icekylin**、**water0902**、**aimeDesign**、**whsasf\_work3**、**liujiacode**（logo0964 和 logo0281）、**WSJ**、**long**、**fine**。同样，奖金翻倍为 200 元。
同时，按照活动规则，由于一等奖空缺，二、三等奖作品的版权仍然归作者所有，我们并不取得版权。
请上述中奖者加我微信 **linux\_china** ，我在验证中奖者身份后会颁发奖金。
最后，在这个征集活动中，无论您是否提交了作品，也无论是否评选中奖，我们都对诸位的积极参与和贡献致以最热忱的谢意，是你们大家，让我们觉到了社区的温暖和支持！我们必将在诸位的陪伴和支持下发展的更好！
此致敬礼，
Linux 中国 / 老王
|
||||
Collapse OS：为世界末日创建的操作系统
|
John Paul
|
https://itsfoss.com/collapse-os/
|
当大多数人考虑为末日后的世界做准备时，想到的第一件事就是准备食物和其他生活必需品。最近，有一个程序员觉得，在社会崩溃之后，创建一个多功能的、且可生存的操作系统同样重要。
|
/data/attachment/album/201911/01/065411ss5e2ts46vzv6x7b.jpg.thumb.jpg
|
/data/attachment/album/201911/01/065411ss5e2ts46vzv6x7b.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"末日"
] |
观点
|
{
"viewnum": 7645,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "119.137.1.45",
"message": "末日吗》",
"username": "来自广东深圳的 QQ Browser 10.5|Windows 7 用户",
"date": "2019-11-01T09:53:47"
},
{
"postip": "119.137.1.45",
"message": "末日吗》",
"username": "来自广东深圳的 QQ Browser 10.5|Windows 7 用户",
"date": "2019-11-01T09:53:52"
}
] |
[] |
当大多数人考虑为末日后的世界做准备时，想到的第一件事就是准备食物和其他生活必需品。最近，有一个程序员觉得，在社会崩溃之后，创建一个多功能的、且可生存的操作系统同样重要。
| 2019-11-01T06:54:09 | 2019-11-01T06:54:09 | 11,525 |
/article-11525-1.html
|
当大多数人考虑为末日后的世界做准备时，想到的第一件事就是准备食物和其他生活必需品。最近，有一个程序员觉得，在社会崩溃之后，创建一个多功能的、且可生存的操作系统同样重要。我们今天将尽我们所能地来了解一下它。
### Collapse OS：当文明被掩埋在垃圾中
这里说的操作系统称为 [Collapse OS（崩溃操作系统）](https://collapseos.org/)。根据该官方网站的说法，Collapse OS 是 “z80 内核以及一系列程序、工具和文档的集合”。 它可以让你：
* 可在最小的和临时拼凑的机器上运行。
* 通过临时拼凑的方式（串行、键盘、显示）进行接口。
* 可编辑文本文件。
* 编译适用于各种 MCU 和 CPU 的汇编源代码文件。
* 从各种存储设备读取和写入。
* 自我复制。
其创造者 [Virgil Dupras](https://github.com/hsoft) 之所以开始这个项目，是因为[他认为](https://collapseos.org/why.html)“我们的全球供应链在我们到达 2030 年之前就会崩溃”。他是根据<ruby> 巴勃罗·塞维尼 <rt> Pablo Servigne </rt></ruby>的作品得出了这一结论的。他似乎也觉得并非所有人都会认可[他的观点](https://collapseos.org/why.html)，“话虽如此，我认为不相信到 2030 年可能会发生崩溃也是可以理解的，所以请不要为我的信念而感到受到了冲击。”
该项目的总体目标是迅速让瓦解崩溃后的文明重新回到计算机时代。电子产品的生产取决于非常复杂的供应链。一旦供应链崩溃，人类将回到一个技术水平较低的时代。要恢复我们以前的技术水平，将需要数十年的时间。Dupras 希望通过创建一个生态系统来跨越几个步骤，该生态系统将与从各种来源搜寻到的更简单的芯片一起工作。
### z80 是什么？
最初的 Collapse OS 内核是为 [z80 芯片](https://en.m.wikipedia.org/wiki/Z80)编写的。作为复古计算机历史的爱好者，我对 [Zilog](https://en.wikipedia.org/wiki/Zilog) 和 z80 芯片很熟悉。在 1970 年代后期，Zilog 公司推出了 z80，以和 [Intel 的 8080](https://en.wikipedia.org/wiki/Intel_8080) CPU 竞争。z80 被用于许多早期的个人计算机中，例如 [Sinclair ZX Spectrum](https://en.wikipedia.org/wiki/ZX_Spectrum) 和 [Tandy TRS-80](https://en.wikipedia.org/wiki/TRS-80)。这些系统中的大多数使用了 [CP/M 操作系统](https://en.wikipedia.org/wiki/CP/M)，这是当时最流行的操作系统。（有趣的是，Dupras 最初希望使用[一个开源版本的 CP/M](https://github.com/davidgiven/cpmish)，但最终决定[从头开始](https://github.com/hsoft/collapseos/issues/52)。）
在 1981 年 [IBM PC](https://en.wikipedia.org/wiki/IBM_Personal_Computer) 发布之后，z80 和 CP/M 的普及率开始下降。Zilog 确实发布了其它几种微处理器（Z8000 和 Z80000），但并没有获得成功。该公司将重点转移到了微控制器上。今天，更新后的 z80 后代产品可以在图形计算器、嵌入式设备和消费电子产品中找到。
Dupras 在 [Reddit](https://old.reddit.com/r/collapse/comments/dejmvz/collapse_os_bootstrap_postcollapse_technology/f2w3sid/?st=k1gujoau&sh=1b344da9) 上说，他为 z80 编写了 Collapse OS，因为“它已经投入生产很长时间了，并且因为它被用于许多机器上，所以拾荒者有很大的机会拿到它。”
### 该项目的当前状态和未来发展
Collapse OS 的起步相当不错。有足够的内存和存储空间它就可以进行自我复制。它可以在 [RC2014 家用计算机](https://rc2014.co.uk/)或世嘉 Master System / MegaDrive（Genesis）上运行。它可以读取 SD 卡。它有一个简单的文本编辑器。其内核由用粘合代码连接起来的模块组成。这是为了使系统具有灵活性和适应性。
还有一个详细的[路线图](https://collapseos.org/roadmap.html)列出了该项目的方向。列出的目标包括：
* 支持其他 CPU，例如 8080 和 [6502](https://en.wikipedia.org/wiki/MOS_Technology_6502)。
* 支持临时拼凑的外围设备，例如 LCD 屏幕、电子墨水显示器和 [ACIA 设备](https://en.wikipedia.org/wiki/MOS_Technology_6551)。
* 支持更多的存储方式，例如软盘、CD、SPI RAM/ROM 和 AVR MCU。
* 使它可以在其他 z80 机器上工作，例如 [TI-83+](https://en.wikipedia.org/wiki/TI-83_series#TI-83_Plus) 和 [TI-84+](https://en.wikipedia.org/wiki/TI-84_Plus_series) 图形计算器和 TRS-80s。
如果你有兴趣帮助或只是想窥视一下这个项目，请访问其 [GitHub 页面](https://github.com/hsoft/collapseos)。
### 最后的思考
坦率地说，我认为 Collapse OS 与其说是一个有用的项目，倒不如说更像是一个有趣的爱好项目（对于那些喜欢构建操作系统的人来说）。当崩溃真的到来时，我认为 GitHub 也会宕机，那么 Collapse OS 将如何分发？我无法想像，得具有多少技能的人才能够从捡来的零件中创建出一个系统。到时候会有新一代的创客们，但大多数创客们会习惯于选择 Arduino 或树莓派来构建项目，而不是从头开始。
与 Dupras 相反，我最担心的是[电磁脉冲炸弹（EMP）](https://en.wikipedia.org/wiki/Electromagnetic_pulse) 的使用。这些东西会炸毁所有的电气系统，这意味着将没有任何构建系统的可能。如果没有发生这种事情，我想我们将能够找到过去 30 年制造的那么多的 x86 组件，以保持它们运行下去。
话虽如此，对于那些喜欢为奇奇怪怪的应用编写低级代码的人来说，Collapse OS 听起来是一个有趣且具有高度挑战性的项目。如果你是这样的人，去检出 [Collapse OS](https://collapseos.org/) 代码吧。
让我提个假设的问题：你选择的世界末日操作系统是什么？请在下面的评论中告诉我们。
如果你觉得这篇文章有趣，请花一点时间在社交媒体、Hacker News 或 [Reddit](https://reddit.com/r/linuxusersgroup) 上分享。
---
via: <https://itsfoss.com/collapse-os/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[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/) 荣誉推出
|
RPM 包是如何从源 RPM 制作的
|
Ankur Sinha "franciscod"
|
https://fedoramagazine.org/how-rpm-packages-are-made-the-source-rpm/
|
Fedora 中的所有软件都必须从其源代码构建。我们不包括预构建的二进制文件。
|
/data/attachment/album/201911/02/093550p3t13v3sxif3vx73.jpg.thumb.jpg
|
/data/attachment/album/201911/02/093550p3t13v3sxif3vx73.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"RPM"
] |
技术
|
{
"viewnum": 6978,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11452,
"displayorder": 0
},
{
"raid": 11538,
"displayorder": 0
}
] |
Fedora 中的所有软件都必须从其源代码构建。我们不包括预构建的二进制文件。
| 2019-11-02T09:35:46 | 2019-11-02T09:35:46 | 11,527 |
/article-11527-1.html
|
在[上一篇文章中，我们研究了什么是 RPM 软件包](/article-11452-1.html)。它们是包含文件和元数据的档案文件。当安装或卸载 RPM 时，此元数据告诉 RPM 在哪里创建或删除文件。正如你将在上一篇文章中记住的，元数据还包含有关“依赖项”的信息，它可以是“运行时”或“构建时”的依赖信息。
例如，让我们来看看 `fpaste`。你可以使用 `dnf` 下载该 RPM。这将下载 Fedora 存储库中可用的 `fpaste` 最新版本。在 Fedora 30 上，当前版本为 0.3.9.2：
```
$ dnf download fpaste
...
fpaste-0.3.9.2-2.fc30.noarch.rpm
```
由于这是个构建 RPM，因此它仅包含使用 `fpaste` 所需的文件：
```
$ rpm -qpl ./fpaste-0.3.9.2-2.fc30.noarch.rpm
/usr/bin/fpaste
/usr/share/doc/fpaste
/usr/share/doc/fpaste/README.rst
/usr/share/doc/fpaste/TODO
/usr/share/licenses/fpaste
/usr/share/licenses/fpaste/COPYING
/usr/share/man/man1/fpaste.1.gz
```
### 源 RPM
在此链条中的下一个环节是源 RPM。Fedora 中的所有软件都必须从其源代码构建。我们不包括预构建的二进制文件。因此，要制作一个 RPM 文件，RPM（工具）需要：
* 给出必须要安装的文件，
* 例如，如果要编译出这些文件，则告诉它们如何生成这些文件，
* 告知必须在何处安装这些文件，
* 该特定软件需要其他哪些依赖才能正常工作。
源 RPM 拥有所有这些信息。源 RPM 与构建 RPM 相似，但顾名思义，它们不包含已构建的二进制文件，而是包含某个软件的源文件。让我们下载 `fpaste` 的源 RPM：
```
$ dnf download fpaste --source
...
fpaste-0.3.9.2-2.fc30.src.rpm
```
注意文件的结尾是 `src.rpm`。所有的 RPM 都是从源 RPM 构建的。你也可以使用 `dnf` 轻松检查“二进制” RPM 的源 RPM：
```
$ dnf repoquery --qf "%{SOURCERPM}" fpaste
fpaste-0.3.9.2-2.fc30.src.rpm
```
另外，由于这是源 RPM，因此它不包含构建的文件。相反，它包含有关如何从中构建 RPM 的源代码和指令：
```
$ rpm -qpl ./fpaste-0.3.9.2-2.fc30.src.rpm
fpaste-0.3.9.2.tar.gz
fpaste.spec
```
这里，第一个文件只是 `fpaste` 的源代码。第二个是 spec 文件。spec 文件是个配方，可告诉 RPM（工具）如何使用源 RPM 中包含的源代码创建 RPM（档案文件）— 它包含 RPM（工具）构建 RPM（档案文件）所需的所有信息。在 spec 文件中。当我们软件包维护人员添加软件到 Fedora 中时，我们大部分时间都花在编写和完善 spec 文件上。当软件包需要更新时，我们会回过头来调整 spec 文件。你可以在 <https://src.fedoraproject.org/browse/projects/> 的源代码存储库中查看 Fedora 中所有软件包的 spec 文件。
请注意，一个源 RPM 可能包含构建多个 RPM 的说明。`fpaste` 是一款非常简单的软件，一个源 RPM 生成一个“二进制” RPM。而 Python 则更复杂。虽然只有一个源 RPM，但它会生成多个二进制 RPM：
```
$ sudo dnf repoquery --qf "%{SOURCERPM}" python3
python3-3.7.3-1.fc30.src.rpm
python3-3.7.4-1.fc30.src.rpm
$ sudo dnf repoquery --qf "%{SOURCERPM}" python3-devel
python3-3.7.3-1.fc30.src.rpm
python3-3.7.4-1.fc30.src.rpm
$ sudo dnf repoquery --qf "%{SOURCERPM}" python3-libs
python3-3.7.3-1.fc30.src.rpm
python3-3.7.4-1.fc30.src.rpm
$ sudo dnf repoquery --qf "%{SOURCERPM}" python3-idle
python3-3.7.3-1.fc30.src.rpm
python3-3.7.4-1.fc30.src.rpm
$ sudo dnf repoquery --qf "%{SOURCERPM}" python3-tkinter
python3-3.7.3-1.fc30.src.rpm
python3-3.7.4-1.fc30.src.rpm
```
用 RPM 行话来讲，“python3” 是“主包”，因此该 spec 文件将称为 `python3.spec`。所有其他软件包均为“子软件包”。你可以下载 python3 的源 RPM，并查看其中的内容。（提示：补丁也是源代码的一部分）：
```
$ dnf download --source python3
python3-3.7.4-1.fc30.src.rpm
$ rpm -qpl ./python3-3.7.4-1.fc30.src.rpm
00001-rpath.patch
00102-lib64.patch
00111-no-static-lib.patch
00155-avoid-ctypes-thunks.patch
00170-gc-assertions.patch
00178-dont-duplicate-flags-in-sysconfig.patch
00189-use-rpm-wheels.patch
00205-make-libpl-respect-lib64.patch
00251-change-user-install-location.patch
00274-fix-arch-names.patch
00316-mark-bdist_wininst-unsupported.patch
Python-3.7.4.tar.xz
check-pyc-timestamps.py
idle3.appdata.xml
idle3.desktop
python3.spec
```
### 从源 RPM 构建 RPM
现在我们有了源 RPM，并且其中有什么内容，我们可以从中重建 RPM。但是，在执行此操作之前，我们应该设置系统以构建 RPM。首先，我们安装必需的工具：
```
$ sudo dnf install fedora-packager
```
这将安装 `rpmbuild` 工具。`rpmbuild` 需要一个默认布局，以便它知道源 RPM 中每个必需组件的位置。让我们看看它们是什么：
```
# spec 文件将出现在哪里？
$ rpm -E %{_specdir}
/home/asinha/rpmbuild/SPECS
# 源代码将出现在哪里？
$ rpm -E %{_sourcedir}
/home/asinha/rpmbuild/SOURCES
# 临时构建目录是哪里？
$ rpm -E %{_builddir}
/home/asinha/rpmbuild/BUILD
# 构建根目录是哪里？
$ rpm -E %{_buildrootdir}
/home/asinha/rpmbuild/BUILDROOT
# 源 RPM 将放在哪里？
$ rpm -E %{_srcrpmdir}
/home/asinha/rpmbuild/SRPMS
# 构建的 RPM 将放在哪里？
$ rpm -E %{_rpmdir}
/home/asinha/rpmbuild/RPMS
```
我已经在系统上设置了所有这些目录：
```
$ cd
$ tree -L 1 rpmbuild/
rpmbuild/
├── BUILD
├── BUILDROOT
├── RPMS
├── SOURCES
├── SPECS
└── SRPMS
6 directories, 0 files
```
RPM 还提供了一个为你全部设置好的工具：
```
$ rpmdev-setuptree
```
然后，确保已安装 `fpaste` 的所有构建依赖项：
```
sudo dnf builddep fpaste-0.3.9.2-3.fc30.src.rpm
```
对于 `fpaste`，你只需要 Python，并且它肯定已经安装在你的系统上（`dnf` 也使用 Python）。还可以给 `builddep` 命令一个 spec 文件，而不是源 RPM。在手册页中了解更多信息：
```
$ man dnf.plugin.builddep
```
现在我们有了所需的一切，从源 RPM 构建一个 RPM 就像这样简单：
```
$ rpmbuild --rebuild fpaste-0.3.9.2-3.fc30.src.rpm
..
..
$ tree ~/rpmbuild/RPMS/noarch/
/home/asinha/rpmbuild/RPMS/noarch/
└── fpaste-0.3.9.2-3.fc30.noarch.rpm
0 directories, 1 file
```
`rpmbuild` 将安装源 RPM 并从中构建你的 RPM。现在，你可以使用 `dnf` 安装 RPM 以使用它。当然，如前所述，如果你想在 RPM 中进行任何更改，则必须修改 spec 文件，我们将在下一篇文章中介绍 spec 文件。
### 总结
总结一下这篇文章有两点：
* 我们通常安装使用的 RPM 是包含软件的构建版本的 “二进制” RPM
* 构建 RPM 来自于源 RPM，源 RPM 包括用于生成二进制 RPM 所需的源代码和规范文件。
如果你想开始构建 RPM，并帮助 Fedora 社区维护我们提供的大量软件，则可以从这里开始： <https://fedoraproject.org/wiki/Join_the_package_collection_maintainers>
如有任何疑问，请发邮件到 [Fedora 开发人员邮件列表](https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/)，我们随时乐意为你提供帮助！
---
via: <https://fedoramagazine.org/how-rpm-packages-are-made-the-source-rpm/>
作者：[Ankur Sinha FranciscoD](https://fedoramagazine.org/author/ankursinha/) 选题：[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/) 荣誉推出
|
COPR 仓库中 4 个很酷的新项目（2019.10）
|
Dominik Turecek
|
https://fedoramagazine.org/4-cool-new-projects-to-try-in-copr-for-october-2019/
|
本文介绍了 COPR 中一些有趣的新项目。
|
/data/attachment/album/201911/02/100854n5icfu7lpculf5yf.jpg.thumb.jpg
|
/data/attachment/album/201911/02/100854n5icfu7lpculf5yf.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"COPR"
] |
分享
|
{
"viewnum": 5281,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文介绍了 COPR 中一些有趣的新项目。
| 2019-11-02T10:08:51 | 2019-11-02T10:08:51 | 11,528 |
/article-11528-1.html
|
COPR 是个人软件仓库[集合](https://copr.fedorainfracloud.org/)，它不在 Fedora 中。这是因为某些软件不符合轻松打包的标准；或者它可能不符合其他 Fedora 标准，尽管它是自由而开源的。COPR 可以在 Fedora 套件之外提供这些项目。COPR 中的软件不受 Fedora 基础设施的支持，或者是由项目自己背书的。但是，这是一种尝试新的或实验性的软件的一种巧妙的方式。
本文介绍了 COPR 中一些有趣的新项目。如果你第一次使用 COPR，请参阅 [COPR 用户文档](https://docs.pagure.org/copr.copr/user_documentation.html#)。
### Nu
[Nu](https://github.com/nushell/nushell) 也被称为 Nushell，是受 PowerShell 和现代 CLI 工具启发的 shell。通过使用基于结构化数据的方法，Nu 可轻松处理命令的输出，并通过管道传输其他命令。然后将结果显示在可以轻松排序或过滤的表中，并可以用作其他命令的输入。最后，Nu 提供了几个内置命令、多 shell 和对插件的支持。
#### 安装说明
该[仓库](https://copr.fedorainfracloud.org/coprs/atim/nushell/)目前为 Fedora 30、31 和 Rawhide 提供 Nu。要安装 Nu，请使用以下命令：
```
sudo dnf copr enable atim/nushell
sudo dnf install nushell
```
### NoteKit
[NoteKit](https://github.com/blackhole89/notekit) 是一个笔记程序。它支持 Markdown 来格式化笔记，并支持使用鼠标创建手绘笔记的功能。在 NoteKit 中，笔记以树状结构进行排序和组织。
#### 安装说明
该[仓库](https://copr.fedorainfracloud.org/coprs/lyessaadi/notekit/)目前为 Fedora 29、30、31 和 Rawhide 提供 NoteKit。要安装 NoteKit，请使用以下命令：
```
sudo dnf copr enable lyessaadi/notekit
sudo dnf install notekit
```
### Crow Translate
[Crow Translate](https://github.com/crow-translate/crow-translate) 是一个翻译程序。它可以翻译文本并且可以对输入和结果发音，它还提供命令行界面。对于翻译，Crow Translate 使用 Google、Yandex 或 Bing 的翻译 API。
#### 安装说明
该[仓库](https://copr.fedorainfracloud.org/coprs/faezebax/crow-translate/)目前为 Fedora 30、31 和 Rawhide 以及 Epel 8 提供 Crow Translate。要安装 Crow Translate，请使用以下命令：
```
sudo dnf copr enable faezebax/crow-translate
sudo dnf install crow-translate
```
### dnsmeter
[dnsmeter](https://github.com/DNS-OARC/dnsmeter) 是用于测试域名服务器及其基础设施性能的命令行工具。为此，它发送 DNS 查询并计算答复数，从而测量各种统计数据。除此之外，dnsmeter 可以使用不同的加载步骤，使用 PCAP 文件中的载荷和欺骗发送者地址。
#### 安装说明
该仓库目前为 Fedora 29、30、31、Rawhide 以及 Epel 7 提供 dnsmeter。要安装 dnsmeter，请使用以下命令：
```
sudo dnf copr enable @dnsoarc/dnsmeter
sudo dnf install dnsmeter
```
---
via: <https://fedoramagazine.org/4-cool-new-projects-to-try-in-copr-for-october-2019/>
作者：[Dominik Turecek](https://fedoramagazine.org/author/dturecek/) 选题：[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/) 荣誉推出
|
由于 GIMP 是令人反感的字眼，有人将它复刻了
|
John Paul
|
https://itsfoss.com/gimp-fork-glimpse/
|
在开源应用程序世界中，当社区成员希望以与其他人不同的方向来开发应用程序时，复刻是很常见的。最新的具有新闻价值的一个复刻称为 Glimpse，旨在解决用户在使用 GNU 图像处理程序（通常称为 GIMP）时遇到的某些问题。
|
/data/attachment/album/201911/02/111446un3919yc19a3kbnk.png.thumb.jpg
|
/data/attachment/album/201911/02/111446un3919yc19a3kbnk.png
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"GIMP"
] |
观点
|
{
"viewnum": 7534,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "219.140.28.21",
"message": "grub蛆<br />\r\nGNOME侏儒",
"username": "来自湖北武汉的 Chrome Mobile 57.0|Android 8.1 用户",
"date": "2019-11-04T07:11:48"
}
] |
[] |
在开源应用程序世界中，当社区成员希望以与其他人不同的方向来开发应用程序时，复刻是很常见的。最新的具有新闻价值的一个复刻称为 Glimpse，旨在解决用户在使用 GNU 图像处理程序（通常称为 GIMP）时遇到的某些问题。
| 2019-11-02T11:14:42 | 2019-11-02T11:14:42 | 11,529 |
/article-11529-1.html
|
在开源应用程序世界中，当社区成员希望以与其他人不同的方向来开发应用程序时，<ruby> 复刻 <rt> fork </rt></ruby>是很常见的。最新的具有新闻价值的一个复刻称为 [Glimpse](https://getglimpse.app/)，旨在解决用户在使用 <ruby> <a href="https://www.gimp.org/"> GNU 图像处理程序 </a> <rt> GNU Image Manipulation Program </rt></ruby>（通常称为 GIMP）时遇到的某些问题。
### 为什么创建 GIMP 的复刻？
当你访问 Glimpse 应用的[主页](https://getglimpse.app/)时，它表示该项目的目标是“尝试其他设计方向并修复长期存在的错误。”这听起来并不奇怪。但是，如果你开始阅读该项目的博客文章，则是另外一种印象。
根据该项目的[第一篇博客文章](https://getglimpse.app/posts/so-it-begins/)，他们创建了这个复刻是因为他们不喜欢 GIMP 这个名称。根据该帖子，“我们中的许多人不认为该软件的名称适用于所有用户，并且在拒绝该项目的 13 年后，我们决定复刻！”
如果你想知道为什么这些人认为 GIMP 令人讨厌，他们在[关于页面](https://getglimpse.app/about/)中回答该问题：
>
> “如果英语不是你的母语，那么你可能没有意识到 ‘gimp’ 一词有问题。在某些国家，这被视为针对残疾人的侮辱和针对不受欢迎儿童的操场侮辱。它也可以与成年人同意的某些‘天黑后’活动联系起来。”
>
>
>
他们还指出，他们并没有使这一举动脱离政治正确或过于敏感。“除了可能给边缘化社区带来的痛苦外，我们当中许多人都有过倡导自由软件的故事，比如在 GNU 图像处理程序没有被专业环境中的老板或同事视为可选项这件事上。”
他们似乎在回答许多质疑，“不幸的是，我们不得不复刻整个项目来更改其名称，我们认为有关此问题的讨论陷入了僵局，而这是最积极的前进方向。 ”
看起来 Glimpse 这个名称不是确定不变的。他们的 GitHub 页面上有个关于可能选择其他名称的[提案](https://github.com/glimpse-editor/Glimpse/issues/92)。也许他们应该放弃 GNU 这个词，我认为 IMP 这个词没有不好的含义。（LCTT 译注：反讽）
### 分叉之路
[GIMP](https://itsfoss.com/gimp-2-10-release/) 已经存在了 20 多年，因此任何形式的复刻都是一项艰巨的任务。当前，[他们正在计划](https://getglimpse.app/posts/six-week-checkpoint/)首先在 2019 年 9 月发布 Glimpse 0.1。这将是一个软复刻，这意味着在迁移到新身份时的更改将主要是装饰性的。（LCTT 译注：事实上到本译文发布时，该项目仍然处于蛋疼的 0.1 beta，也许 11 月，也许 12 月，才能发布 0.1 的正式版本。）
Glimpse 1.0 将是一个硬复刻，他们将积极更改代码库并将其添加到代码库中。他们想将 1.0 移植到 GTK3 并拥有自己的文档。他们估计，直到 2020 年 GIMP 3 发布之后才能做到。
除了 1.0，Glimpse 团队还计划打响自己的名声。他们计划进行“前端 UI 重写”。他们目前正在讨论[改用哪种语言](https://github.com/glimpse-editor/Glimpse/issues/70)。D 和 Rust 似乎有很多支持者。随着时间的流逝，他们也[希望](https://getglimpse.app/posts/so-it-begins/)“添加新功能以解决普通用户的抱怨”。
### 最后的思考
我过去曾经使用过一点 GIMP，但从来没有对它的名称感到困扰。老实说，我很长一段时间都不知道这意味着什么。有趣的是，当我在 Wikipedia 上搜索 GIMP 时，看到了一个 [GIMP 项目](https://en.wikipedia.org/wiki/The_Gimp_Project)的条目，这是纽约的一个现代舞蹈项目，其中包括残疾人。我想 gimp 并不是每个人视为一个贬低词汇的。
对我来说，更改名称似乎需要大量工作。似乎改写 UI 的想法会使项目看起来更有价值一些。我想知道他们是否会调整它以带来更经典的 UI，例如[使用 Ctrl + S 保存到 GIMP](https://itsfoss.com/how-to-solve-gimp-2-8-does-not-save-in-jpeg-or-png-format/) / Glimpse。让我们拭目以待。
如果你对该项目感兴趣，可以在 [Twitter](https://twitter.com/glimpse_editor) 上关注他们，查看其 [GitHub 帐户](https://github.com/glimpse-editor/Glimpse)，或查看其 [Patreon 页面](https://www.patreon.com/glimpse)。
你觉得被 GIMP 名称冒犯了吗？你是否认为值得对应用程序进行复刻，以便你可以对其进行重命名？在下面的评论中让我们知道。
如果你觉得这篇文章有趣，请花一点时间在社交媒体、Hacker News 或 [Reddit](https://reddit.com/r/linuxusersgroup) 上分享。
---
via: <https://itsfoss.com/gimp-fork-glimpse/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[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/) 荣誉推出
|
5 个 Linux 桌面上的最佳密码管理器
|
Ankush Das
|
https://itsfoss.com/password-managers-linux/
|
密码管理器是创建唯一密码并安全存储它们的有用工具，这样你无需记住密码。了解一下适用于 Linux 桌面的最佳密码管理器。
|
/data/attachment/album/201911/03/102528e97mr0ls89lz9rrr.jpg.thumb.jpg
|
/data/attachment/album/201911/03/102528e97mr0ls89lz9rrr.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"密码管理器"
] |
分享
|
{
"viewnum": 9016,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
密码管理器是创建唯一密码并安全存储它们的有用工具，这样你无需记住密码。了解一下适用于 Linux 桌面的最佳密码管理器。
| 2019-11-03T10:25:57 | 2019-11-03T10:25:57 | 11,531 |
/article-11531-1.html
|
>
> 密码管理器是创建唯一密码并安全存储它们的有用工具，这样你无需记住密码。了解一下适用于 Linux 桌面的最佳密码管理器。
>
>
>
密码无处不在。网站、论坛、Web 应用等，你需要为其创建帐户和密码。麻烦在于密码，为各个帐户使用相同的密码会带来安全风险，因为[如果其中一个网站遭到入侵，黑客也会在其他网站上尝试相同的电子邮件密码组合](https://medium.com/@computerphonedude/one-of-my-old-passwords-was-hacked-on-6-different-sites-and-i-had-no-clue-heres-how-to-quickly-ced23edf3b62)。
但是，为所有新帐户设置独有的密码意味着你必须记住所有密码，这对普通人而言不太可能。这就是密码管理器可以提供帮助的地方。
密码管理应用会为你建议/创建强密码，并将其存储在加密的数据库中。你只需要记住密码管理器的主密码即可。
主流的现代浏览器（例如 Mozilla Firefox 和 Google Chrome）内置了密码管理器。这有帮助，但是你只能在浏览器上使用它。
有一些第三方专门的密码管理器，其中一些还提供 Linux 的原生桌面应用。在本文中，我们将筛选出可用于 Linux 的最佳密码管理器。
继续之前，我还建议你仔细阅读 [Linux 的免费密码生成器](https://itsfoss.com/password-generators-linux/)，来为你生成强大的唯一密码。
### Linux 密码管理器
>
> 可能的非 FOSS 警报！
>
>
> 我们优先考虑开源软件（有一些专有软件，请不要讨厌我！），并提供适用于 Linux 的独立桌面应用（GUI）。专有软件已高亮显示。
>
>
>
#### 1、Bitwarden
主要亮点：
* 开源
* 免费供个人使用（可选付费升级）
* 云服务器的端到端加密
* 跨平台
* 有浏览器扩展
* 命令行工具
Bitwarden 是 Linux 上最令人印象深刻的密码管理器之一。老实说，直到现在我才知道它。我已经从 [LastPass](https://www.lastpass.com/) 切换到了它。我能够轻松地从 LastPass 导入数据，而没有任何问题和困难。
付费版本的价格仅为每年 10 美元。这似乎是值得的（我已经为个人使用进行了升级）。
它是一个开源解决方案，因此没有任何可疑之处。你甚至可以将其托管在自己的服务器上，并为你的组织创建密码解决方案。
除此之外，你还将获得所有必需的功能，例如用于登录的两步验证、导入/导出凭据、指纹短语（唯一键）、密码生成器等等。
你可以免费将帐户升级为组织帐户，以便最多与 2 个用户共享你的信息。但是，如果你想要额外的加密存储以及与 5 个用户共享密码的功能，那么付费升级的费用低至每月 1 美元。我认为绝对值得一试！
* [Bitwarden](https://bitwarden.com/)
#### 2、Buttercup
主要亮点：
* 开源
* 免费，没有付费方式。
* 跨平台
* 有浏览器扩展
这是 Linux 中的另一个开源密码管理器。Buttercup 可能不是一个非常流行的解决方案。但是，如果你在寻找一种更简单的保存凭据的方法，那么这将是一个不错的开始。
与其他软件不同，你不必对怀疑其云服务器的安全，因为它只支持离线使用并支持连接 [Dropbox](https://www.dropbox.com/)、[OwnCloud](https://owncloud.com/)、[Nextcloud](https://nextcloud.com/) 和 [WebDAV](https://en.wikipedia.org/wiki/WebDAV) 等云服务。
因此，如果需要同步数据，那么可以选择云服务。你有不同选择。
* [Buttercup](https://buttercup.pw/)
#### 3、KeePassXC
主要亮点：
* 开源
* 简单的密码管理器
* 跨平台
* 没有移动设备支持
KeePassXC 是 [KeePassX](https://www.keepassx.org/) 的社区分支，它最初是 Windows 上 [KeePass](https://keepass.info/) 的 Linux 移植版本。
除非你没意识到，KeePassX 已经多年没有维护。因此，如果你在寻找简单易用的密码管理器，那么 KeePassXC 是一个不错的选择。KeePassXC 可能不是最漂亮或最好的密码管理器，但它确实可以做到该做的事。
它也是安全和开源的。我认为这值得一试，你说呢？
* [KeePassXC](https://keepassxc.org)
#### 4、Enpass （非开源）
主要亮点：
* 专有软件
* 有许多功能，包括对“可穿戴”设备支持。
* Linux 完全免费（具有付费支持）
Enpass 是非常流行的跨平台密码管理器。即使它不是开源解决方案，但还是有很多人依赖它。因此，至少可以肯定它是可行的。
它提供了很多功能，如果你有可穿戴设备，它也可以支持它，这点很少见。
很高兴能看到 Enpass 积极管理 Linux 发行版的软件包。另外，请注意，它仅适用于 64 位系统。你可以在它的网站上找到[官方的安装说明](https://www.enpass.io/support/kb/general/how-to-install-enpass-on-linux/)。它需要使用终端，但是我按照步骤进行了测试，它非常好用。
* [Enpass](https://www.enpass.io/)
#### 5、myki （非开源）
主要亮点：
* 专有软件
* 不使用云服务器存储密码
* 专注于本地点对点同步
* 能够在移动设备上用指纹 ID 替换密码
这可能不是一个受欢迎的建议，但我发现它很有趣。它是专有软件密码管理器，它让你避免使用云服务器，而是依靠点对点同步。
因此，如果你不想使用任何云服务器来存储你的信息，那么它适合你。另外值得注意的是，用于 Android 和 iOS 的程序可让你用指纹 ID 替换密码。如果你希望便于在手机上使用，又有桌面密码管理器的基本功能，这似乎是个不错的选择。
但是，如果你选择升级到付费版，这有个付费计划供你判断，绝对不便宜。
尝试一下，让我们知道它如何!
* [myki](https://myki.com/)
### 其他一些值得说的密码管理器
即使没有为 Linux 提供独立的应用，但仍有一些密码管理器值得一提。
如果你需要使用基于浏览器的（扩展）密码管理器，建议你尝试使用 [LastPass](https://lastpass.com/)、[Dashlane](https://www.dashlane.com/) 和 [1Password](https://1password.com/)。LastPass 甚至提供了 [Linux 客户端（和命令行工具）](https://lastpass.com/misc_download2.php)。
如果你正在寻找命令行密码管理器，那你应该试试 [Pass](https://www.passwordstore.org/)。
[Password Safe](https://pwsafe.org/) 也是种选择，但它的 Linux 客户端还处于 beta 阶段。我不建议依靠 “beta” 程序来存储密码。还有 [Universal Password Manager](http://upm.sourceforge.net/)，但它不再维护。你可能也听说过 [Password Gorilla](https://github.com/zdia/gorilla/wiki)，但并它没有积极维护。
### 总结
目前，Bitwarden 似乎是我个人的最爱。但是，在 Linux 上有几个替代品可供选择。你可以选择提供原生应用的程序，也可选择浏览器插件，选择权在你。
如果我有错过值得尝试的密码管理器，请在下面的评论中告诉我们。与往常一样，我们会根据你的建议扩展列表。
---
via: <https://itsfoss.com/password-managers-linux/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[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/) 荣誉推出
|
Java 中初始化数组
|
Chris Hermansen
|
https://opensource.com/article/19/10/initializing-arrays-java
|
数组是一种有用的数据类型，用于管理在连续内存位置中建模最好的集合元素。下面是如何有效地使用它们。
|
/data/attachment/album/201911/03/133858thw7h2enpdvhhv0t.jpg.thumb.jpg
|
/data/attachment/album/201911/03/133858thw7h2enpdvhhv0t.jpg
| true | false | true |
lujun9972
|
laingke
|
wxy
| false |
[
"数组"
] |
软件开发
|
{
"viewnum": 5951,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
数组是一种有用的数据类型，用于管理在连续内存位置中建模最好的集合元素。下面是如何有效地使用它们。
| 2019-11-03T13:38:53 | 2019-11-03T13:38:53 | 11,533 |
/article-11533-1.html
|
>
> 数组是一种有用的数据类型，用于管理在连续内存位置中建模最好的集合元素。下面是如何有效地使用它们。
>
>
>
有使用 C 或者 FORTRAN 语言编程经验的人会对数组的概念很熟悉。它们基本上是一个连续的内存块，其中每个位置都是某种数据类型：整型、浮点型或者诸如此类的数据类型。
Java 的情况与此类似，但是有一些额外的问题。
### 一个数组的示例
让我们在 Java 中创建一个长度为 10 的整型数组：
```
int[] ia = new int[10];
```
上面的代码片段会发生什么？从左到右依次是：
1. 最左边的 `int[]` 将变量的*类型*声明为 `int` 数组（由 `[]` 表示）。
2. 它的右边是变量的名称，当前为 `ia`。
3. 接下来，`=` 告诉我们，左侧定义的变量赋值为右侧的内容。
4. 在 `=` 的右侧，我们看到了 `new`，它在 Java 中表示一个对象正在*被初始化中*，这意味着已为其分配存储空间并调用了其构造函数（[请参见此处以获取更多信息](https://opensource.com/article/19/8/what-object-java)）。
5. 然后，我们看到 `int[10]`，它告诉我们正在初始化的这个对象是包含 10 个整型的数组。
因为 Java 是强类型的，所以变量 `ia` 的类型必须跟 `=` 右侧表达式的类型兼容。
### 初始化示例数组
让我们把这个简单的数组放在一段代码中，并尝试运行一下。将以下内容保存到一个名为 `Test1.java` 的文件中，使用 `javac` 编译，使用 `java` 运行（当然是在终端中）：
```
import java.lang.*;
public class Test1 {
public static void main(String[] args) {
int[] ia = new int[10]; // 见下文注 1
System.out.println("ia is " + ia.getClass()); // 见下文注 2
for (int i = 0; i < ia.length; i++) // 见下文注 3
System.out.println("ia[" + i + "] = " + ia[i]); // 见下文注 4
}
}
```
让我们来看看最重要的部分。
1. 我们声明和初始化了长度为 10 的整型数组，即 `ia`，这显而易见。
2. 在下面的行中，我们看到表达式 `ia.getClass()`。没错，`ia` 是属于一个*类*的*对象*，这行代码将告诉我们是哪个类。
3. 在紧接的下一行中，我们看到了一个循环 `for (int i = 0; i < ia.length; i++)`，它定义了一个循环索引变量 `i`，该变量遍历了从 0 到比 `ia.length` 小 1 的序列，这个表达式告诉我们在数组 `ia` 中定义了多少个元素。
4. 接下来，循环体打印出 `ia` 的每个元素的值。
当这个程序编译和运行时，它产生以下结果：
```
me@mydesktop:~/Java$ javac Test1.java
me@mydesktop:~/Java$ java Test1
ia is class [I
ia[0] = 0
ia[1] = 0
ia[2] = 0
ia[3] = 0
ia[4] = 0
ia[5] = 0
ia[6] = 0
ia[7] = 0
ia[8] = 0
ia[9] = 0
me@mydesktop:~/Java$
```
`ia.getClass()` 的输出的字符串表示形式是 `[I`，它是“整数数组”的简写。与 C 语言类似，Java 数组以第 0 个元素开始，扩展到第 `<数组大小> - 1` 个元素。如上所见，我们可以看到数组 `ia` 的每个元素都（似乎由数组构造函数）设置为零。
所以，就这些吗？声明类型，使用适当的初始化器，就完成了吗?
好吧，并没有。在 Java 中有许多其它方法来初始化数组。
### 为什么我要初始化一个数组，有其它方式吗？
像所有好的问题一样，这个问题的答案是“视情况而定”。在这种情况下，答案取决于初始化后我们希望对数组做什么。
在某些情况下，数组自然会作为一种累加器出现。例如，假设我们正在编程实现计算小型办公室中一组电话分机接收和拨打的电话数量。一共有 8 个分机，编号为 1 到 8，加上话务员的分机，编号为 0。 因此，我们可以声明两个数组：
```
int[] callsMade;
int[] callsReceived;
```
然后，每当我们开始一个新的累计呼叫统计数据的周期时，我们就将每个数组初始化为：
```
callsMade = new int[9];
callsReceived = new int[9];
```
在每个累计通话统计数据的最后阶段，我们可以打印出统计数据。粗略地说，我们可能会看到：
```
import java.lang.*;
import java.io.*;
public class Test2 {
public static void main(String[] args) {
int[] callsMade;
int[] callsReceived;
// 初始化呼叫计数器
callsMade = new int[9];
callsReceived = new int[9];
// 处理呼叫……
// 分机拨打电话：callsMade[ext]++
// 分机接听电话：callsReceived[ext]++
// 汇总通话统计
System.out.printf("%3s%25s%25s\n", "ext", " calls made",
"calls received");
for (int ext = 0; ext < callsMade.length; ext++) {
System.out.printf("%3d%25d%25d\n", ext,
callsMade[ext], callsReceived[ext]);
}
}
}
```
这会产生这样的输出：
```
me@mydesktop:~/Java$ javac Test2.java
me@mydesktop:~/Java$ java Test2
ext calls made calls received
0 0 0
1 0 0
2 0 0
3 0 0
4 0 0
5 0 0
6 0 0
7 0 0
8 0 0
me@mydesktop:~/Java$
```
看来这一天呼叫中心不是很忙。
在上面的累加器示例中，我们看到由数组初始化程序设置的零起始值可以满足我们的需求。但是在其它情况下，这个起始值可能不是正确的选择。
例如，在某些几何计算中，我们可能需要将二维数组初始化为单位矩阵（除沿主对角线———左上角到右下角——以外所有全是零）。我们可以选择这样做：
```
double[][] m = new double[3][3];
for (int d = 0; d < 3; d++) {
m[d][d] = 1.0;
}
```
在这种情况下，我们依靠数组初始化器 `new double[3][3]` 将数组设置为零，然后使用循环将主对角线上的元素设置为 1。在这种简单情况下，我们可以使用 Java 提供的快捷方式：
```
double[][] m = {
{1.0, 0.0, 0.0},
{0.0, 1.0, 0.0},
{0.0, 0.0, 1.0}};
```
这种可视结构特别适用于这种应用程序，在这种应用程序中，它便于复查数组的实际布局。但是在这种情况下，行数和列数只在运行时确定时，我们可能会看到这样的东西:
```
int nrc;
// 一些代码确定行数和列数 = nrc
double[][] m = new double[nrc][nrc];
for (int d = 0; d < nrc; d++) {
m[d][d] = 1.0;
}
```
值得一提的是，Java 中的二维数组实际上是数组的数组，没有什么能阻止无畏的程序员让这些第二层数组中的每个数组的长度都不同。也就是说，下面这样的事情是完全合法的：
```
int [][] differentLengthRows = {
{1, 2, 3, 4, 5},
{6, 7, 8, 9},
{10, 11, 12},
{13, 14},
{15}};
```
在涉及不规则形状矩阵的各种线性代数应用中，可以应用这种类型的结构（有关更多信息，请参见[此 Wikipedia 文章](https://en.wikipedia.org/wiki/Irregular_matrix)）。除此之外，既然我们了解到二维数组实际上是数组的数组，那么以下内容也就不足为奇了：
```
differentLengthRows.length
```
可以告诉我们二维数组 `differentLengthRows` 的行数，并且：
```
differentLengthRows[i].length
```
告诉我们 `differentLengthRows` 第 `i` 行的列数。
### 深入理解数组
考虑到在运行时确定数组大小的想法，我们看到数组在实例化之前仍需要我们知道该大小。但是，如果在处理完所有数据之前我们不知道大小怎么办？这是否意味着我们必须先处理一次以找出数组的大小，然后再次处理？这可能很难做到，尤其是如果我们只有一次机会使用数据时。
[Java 集合框架](https://en.wikipedia.org/wiki/Java_collections_framework)很好地解决了这个问题。提供的其中一项是 `ArrayList` 类，它类似于数组，但可以动态扩展。为了演示 `ArrayList` 的工作原理，让我们创建一个 `ArrayList` 对象并将其初始化为前 20 个[斐波那契数字](https://en.wikipedia.org/wiki/Fibonacci_number)：
```
import java.lang.*;
import java.util.*;
public class Test3 {
public static void main(String[] args) {
ArrayList<Integer> fibos = new ArrayList<Integer>();
fibos.add(0);
fibos.add(1);
for (int i = 2; i < 20; i++) {
fibos.add(fibos.get(i - 1) + fibos.get(i - 2));
}
for (int i = 0; i < fibos.size(); i++) {
System.out.println("fibonacci " + i + " = " + fibos.get(i));
}
}
}
```
上面的代码中，我们看到：
* 用于存储多个 `Integer` 的 `ArrayList` 的声明和实例化。
* 使用 `add()` 附加到 `ArrayList` 实例。
* 使用 `get()` 通过索引号检索元素。
* 使用 `size()` 来确定 `ArrayList` 实例中已经有多少个元素。
这里没有展示 `put()` 方法，它的作用是将一个值放在给定的索引号上。
该程序的输出为：
```
fibonacci 0 = 0
fibonacci 1 = 1
fibonacci 2 = 1
fibonacci 3 = 2
fibonacci 4 = 3
fibonacci 5 = 5
fibonacci 6 = 8
fibonacci 7 = 13
fibonacci 8 = 21
fibonacci 9 = 34
fibonacci 10 = 55
fibonacci 11 = 89
fibonacci 12 = 144
fibonacci 13 = 233
fibonacci 14 = 377
fibonacci 15 = 610
fibonacci 16 = 987
fibonacci 17 = 1597
fibonacci 18 = 2584
fibonacci 19 = 4181
```
`ArrayList` 实例也可以通过其它方式初始化。例如，可以给 `ArrayList` 构造器提供一个数组，或者在编译过程中知道初始元素时也可以使用 `List.of()` 和 `array.aslist()` 方法。我发现自己并不经常使用这些方式，因为我对 `ArrayList` 的主要用途是当我只想读取一次数据时。
此外，对于那些喜欢在加载数据后使用数组的人，可以使用 `ArrayList` 的 `toArray()` 方法将其实例转换为数组；或者，在初始化 `ArrayList` 实例之后，返回到当前数组本身。
Java 集合框架提供了另一种类似数组的数据结构，称为 `Map`（映射）。我所说的“类似数组”是指 `Map` 定义了一个对象集合，它的值可以通过一个键来设置或检索，但与数组（或 `ArrayList`）不同，这个键不需要是整型数；它可以是 `String` 或任何其它复杂对象。
例如，我们可以创建一个 `Map`，其键为 `String`，其值为 `Integer` 类型，如下：
```
Map<String, Integer> stoi = new Map<String, Integer>();
```
然后我们可以对这个 `Map` 进行如下初始化：
```
stoi.set("one",1);
stoi.set("two",2);
stoi.set("three",3);
```
等类似操作。稍后，当我们想要知道 `"three"` 的数值时，我们可以通过下面的方式将其检索出来：
```
stoi.get("three");
```
在我的认知中，`Map` 对于将第三方数据集中出现的字符串转换为我的数据集中的一致代码值非常有用。作为[数据转换管道](https://towardsdatascience.com/data-science-for-startups-data-pipelines-786f6746a59a)的一部分，我经常会构建一个小型的独立程序，用作在处理数据之前清理数据；为此，我几乎总是会使用一个或多个 `Map`。
值得一提的是，`ArrayList` 的 `ArrayList` 和 `Map` 的 `Map` 是很可能的，有时也是合理的。例如，假设我们在看树，我们对按树种和年龄范围累计树的数目感兴趣。假设年龄范围定义是一组字符串值（“young”、“mid”、“mature” 和 “old”），物种是 “Douglas fir”、“western red cedar” 等字符串值，那么我们可以将这个 `Map` 中的 `Map` 定义为：
```
Map<String, Map<String, Integer>> counter = new Map<String, Map<String, Integer>>();
```
这里需要注意的一件事是，以上内容仅为 `Map` 的*行*创建存储。因此，我们的累加代码可能类似于：
```
// 假设我们已经知道了物种和年龄范围
if (!counter.containsKey(species)) {
counter.put(species,new Map<String, Integer>());
}
if (!counter.get(species).containsKey(ageRange)) {
counter.get(species).put(ageRange,0);
}
```
此时，我们可以这样开始累加：
```
counter.get(species).put(ageRange, counter.get(species).get(ageRange) + 1);
```
最后，值得一提的是（Java 8 中的新特性）Streams 还可以用来初始化数组、`ArrayList` 实例和 `Map` 实例。关于此特性的详细讨论可以在[此处](https://stackoverflow.com/questions/36885371/lambda-expression-to-initialize-array)和[此处](https://stackoverflow.com/questions/32868665/how-to-initialize-a-map-using-a-lambda)中找到。
---
via: <https://opensource.com/article/19/10/initializing-arrays-java>
作者：[Chris Hermansen](https://opensource.com/users/clhermansen) 选题：[lujun9972](https://github.com/lujun9972) 译者：[laingke](https://github.com/laingke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
开源 CMS Ghost 3.0 发布，带来新功能
|
Ankush Das
|
https://itsfoss.com/ghost-3-release/
|
Ghost 是目前最好的开源 CMS 之一。它主要聚焦于创建轻量级、快速加载、界面美观的博客。
|
/data/attachment/album/201911/03/135724c0c8glrhf1dyzdd6.jpg.thumb.jpg
|
/data/attachment/album/201911/03/135724c0c8glrhf1dyzdd6.jpg
| true | false | true |
lujun9972
|
Morisun029
|
wxy
| false |
[
"Ghost"
] |
新闻
|
{
"viewnum": 5975,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Ghost 是目前最好的开源 CMS 之一。它主要聚焦于创建轻量级、快速加载、界面美观的博客。
| 2019-11-03T13:57:23 | 2019-11-03T13:57:23 | 11,534 |
/article-11534-1.html
|
[Ghost](https://itsfoss.com/recommends/ghost/) 是一个自由开源的内容管理系统（CMS）。如果你还不了解 CMS，那我在此解释一下。CMS 是一种软件，用它可以构建主要专注于创建内容的网站，而无需了解 HTML 和其他与 Web 相关的技术。
事实上，Ghost 是目前[最好的开源 CMS](https://itsfoss.com/open-source-cms/) 之一。它主要聚焦于创建轻量级、快速加载、界面美观的博客。
Ghost 系统有一个现代直观的编辑器，该编辑器内置 SEO（搜索引擎优化）功能。你也可以用本地桌面（包括 Linux 系统）和移动应用程序。如果你喜欢终端，也可以使用其提供的 CLI（命令行界面）工具。
让我们看看 Ghost 3.0 带来了什么新功能。
### Ghost 3.0 的新功能
我通常对开源的 CMS 解决方案很感兴趣。因此，在阅读了官方公告后，我通过在 Digital Ocean 云服务器上安装新的 Ghost 实例来进一步尝试它。
与以前的版本相比，Ghost 3.0 在功能和用户界面上的改进给我留下了深刻的印象。
在此，我将列出一些值得一提的关键点。
#### 书签卡
除了编辑器的所有细微更改之外，3.0 版本现在支持通过输入 URL 添加漂亮的书签卡。
如果你使用过 WordPress（你可能已经注意到，WordPress 需要添加一个插件才能添加类似的卡片），所以该功能绝对是 Ghost 3.0 系统的一个最大改进。
#### 改进的 WordPress 迁移插件
我没有专门对此进行测试，但它更新了 WordPress 的迁移插件，可以让你轻松地将帖子（带有图片）克隆到 Ghost CMS。
基本上，使用该插件，你就能够创建一个存档（包含图片）并将其导入到 Ghost CMS。
#### 响应式图像库和图片
为了使用户体验更好，Ghost 团队还更新了图像库（现已为响应式），以便在所有设备上舒适地呈现你的图片集。
此外，帖子和页面中的图片也更改为响应式的了。
#### 添加成员和订阅选项
虽然，该功能目前还处于测试阶段，但如果你是以此平台作为维持你业务关系的重要发布平台，你可以为你的博客添加成员、订阅选项。
该功能可以确保只有订阅的成员才能访问你的博客，你也可以选择让未订阅者也可以访问。
#### Stripe：集成支付功能
默认情况下，该版本支持 Stripe 付款网关，帮助你轻松启用订阅功能（或使用任何类型的付款的付款方式），而 Ghost 不收取任何额外费用。
#### 新的应用程序集成
你现在可以在 Ghost 3.0 的博客中集成各种流行的应用程序/服务。它可以使很多事情自动化。
#### 默认主题改进
引入的默认主题（设计）已得到改进，现在也提供了夜间模式。
你也可以随时选择创建自定义主题（如果没有可用的预置主题）。
#### 其他小改进
除了所有关键亮点以外，用于创建帖子/页面的可视编辑器也得到了改进（具有某些拖放功能）。
我确定还有很多技术方面的更改，如果你对此感兴趣，可以在他们的[更改日志](https://ghost.org/faq/upgrades/)中查看。
### Ghost 影响力渐增
要在以 WordPress 为主导的世界中获得认可并不是一件容易的事。但 Ghost 逐渐形成了它的一个专门的发布者社区。
不仅如此，它的托管服务 [Ghost Pro](https://itsfoss.com/recommends/ghost-pro/) 现在拥有像 NASA、Mozilla 和 DuckDuckGo 这样的客户。
在过去的六年中，Ghost 从其 Ghost Pro 客户那里获得了 500 万美元的收入。就从它是致力于开源系统解决方案的非营利组织这一点来讲，这确实是一项成就。
这些收入有助于它们保持独立，避免风险投资家的外部资金投入。Ghost CMS 的托管客户越多，投入到免费和开源的 CMS 的研发款项就越多。
总体而言，Ghost 3.0 是迄今为止提供的最好的升级版本。这些功能给我留下了深刻的印象。
如果你拥有自己的网站，你会使用什么 CMS？你曾经使用过 Ghost 吗？你的体验如何？请在评论部分分享你的想法。
---
via: <https://itsfoss.com/ghost-3-release/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Morisun029](https://github.com/Morisun029) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 CentOS 8 和 RHEL 8 服务器上启用 EPEL 仓库
|
Pradeep Kumar
|
https://www.linuxtechi.com/enable-epel-repo-centos8-rhel8-server/
|
EPEL 仓库提供了额外的软件包，这些软件在 CentOS 8 和 RHEL 8 的默认软件包仓库中不可用。
|
/data/attachment/album/201911/04/113307wz4y3lnczzlxzn2j.jpg.thumb.jpg
|
/data/attachment/album/201911/04/113307wz4y3lnczzlxzn2j.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"EPEL"
] |
技术
|
{
"viewnum": 7402,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
EPEL 仓库提供了额外的软件包，这些软件在 CentOS 8 和 RHEL 8 的默认软件包仓库中不可用。
| 2019-11-04T11:33:00 | 2019-11-04T11:33:00 | 11,535 |
/article-11535-1.html
|
EPEL 代表 “Extra Packages for Enterprise Linux”，它是一个自由开源的附加软件包仓库，可用于 CentOS 和 RHEL 服务器。顾名思义，EPEL 仓库提供了额外的软件包，这些软件在 [CentOS 8](https://www.linuxtechi.com/centos-8-installation-guide-screenshots/) 和 [RHEL 8](https://www.linuxtechi.com/install-configure-kvm-on-rhel-8/) 的默认软件包仓库中不可用。
在本文中，我们将演示如何在 CentOS 8 和 RHEL 8 服务器上启用和使用 EPEL 存储库。
### EPEL 仓库的先决条件
* 最小化安装的 CentOS 8 和 RHEL 8 服务器
* root 或 sudo 管理员权限
* 网络连接
### 在 RHEL 8.x 服务器上安装并启用 EPEL 仓库
登录或 SSH 到你的 RHEL 8.x 服务器，并执行以下 `dnf` 命令来安装 EPEL rpm 包，
```
[root@linuxtechi ~]# dnf install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm -y
```
上面命令的输出将如下所示，
EPEL rpm 包成功安装后，它将自动启用并配置其 yum/dnf 仓库。运行以下 `dnf` 或 `yum` 命令，以验证是否启用了 EPEL 仓库，
```
[root@linuxtechi ~]# dnf repolist epel
或者
[root@linuxtechi ~]# dnf repolist epel -v
```
### 在 CentOS 8.x 服务器上安装并启用 EPEL 仓库
登录或 SSH 到你的 CentOS 8 服务器，并执行以下 `dnf` 或 `yum` 命令来安装 `epel-release` rpm 软件包。在 CentOS 8 服务器中，EPEL rpm 在其默认软件包仓库中。
```
[root@linuxtechi ~]# dnf install epel-release -y
或者
[root@linuxtechi ~]# yum install epel-release -y
```
执行以下命令来验证 CentOS 8 服务器上 EPEL 仓库的状态，
```
[root@linuxtechi ~]# dnf repolist epel
Last metadata expiration check: 0:00:03 ago on Sun 13 Oct 2019 04:18:05 AM BST.
repo id repo name status
*epel Extra Packages for Enterprise Linux 8 - x86_64 1,977
[root@linuxtechi ~]#
[root@linuxtechi ~]# dnf repolist epel -v
……………………
Repo-id : epel
Repo-name : Extra Packages for Enterprise Linux 8 - x86_64
Repo-status : enabled
Repo-revision: 1570844166
Repo-updated : Sat 12 Oct 2019 02:36:32 AM BST
Repo-pkgs : 1,977
Repo-size : 2.1 G
Repo-metalink: https://mirrors.fedoraproject.org/metalink?repo=epel-8&arch=x86_64&infra=stock&content=centos
Updated : Sun 13 Oct 2019 04:28:24 AM BST
Repo-baseurl : rsync://repos.del.extreme-ix.org/epel/8/Everything/x86_64/ (34 more)
Repo-expire : 172,800 second(s) (last: Sun 13 Oct 2019 04:28:24 AM BST)
Repo-filename: /etc/yum.repos.d/epel.repo
Total packages: 1,977
[root@linuxtechi ~]#
```
以上命令的输出说明我们已经成功启用了 EPEL 仓库。让我们在 EPEL 仓库上执行一些基本操作。
### 列出 EPEL 仓库种所有可用包
如果要列出 EPEL 仓库中的所有的软件包，请运行以下 `dnf` 命令，
```
[root@linuxtechi ~]# dnf repository-packages epel list
……………
Last metadata expiration check: 0:38:18 ago on Sun 13 Oct 2019 04:28:24 AM BST.
Installed Packages
epel-release.noarch 8-6.el8 @epel
Available Packages
BackupPC.x86_64 4.3.1-2.el8 epel
BackupPC-XS.x86_64 0.59-3.el8 epel
CGSI-gSOAP.x86_64 1.3.11-7.el8 epel
CGSI-gSOAP-devel.x86_64 1.3.11-7.el8 epel
Field3D.x86_64 1.7.2-16.el8 epel
Field3D-devel.x86_64 1.7.2-16.el8 epel
GraphicsMagick.x86_64 1.3.33-1.el8 epel
GraphicsMagick-c++.x86_64 1.3.33-1.el8 epel
…………………………
zabbix40-web-mysql.noarch 4.0.12-1.el8 epel
zabbix40-web-pgsql.noarch 4.0.12-1.el8 epel
zerofree.x86_64 1.1.1-3.el8 epel
zimg.x86_64 2.8-4.el8 epel
zimg-devel.x86_64 2.8-4.el8 epel
zstd.x86_64 1.4.2-1.el8 epel
zvbi.x86_64 0.2.35-9.el8 epel
zvbi-devel.x86_64 0.2.35-9.el8 epel
zvbi-fonts.noarch 0.2.35-9.el8 epel
[root@linuxtechi ~]#
```
### 从 EPEL 仓库中搜索软件包
假设我们要搜索 EPEL 仓库中的 Zabbix 包，请执行以下 `dnf` 命令，
```
[root@linuxtechi ~]# dnf repository-packages epel list | grep -i zabbix
```
上面命令的输出类似下面这样，
### 从 EPEL 仓库安装软件包
假设我们要从 EPEL 仓库安装 htop 包，运行以下 `dnf` 命令，
语法：
```
# dnf –enablerepo=”epel” install <包名>
```
```
[root@linuxtechi ~]# dnf --enablerepo="epel" install htop -y
```
注意：如果我们在上面的命令中未指定 `–enablerepo=epel`，那么它将在所有可用的软件包仓库中查找 htop 包。
本文就是这些内容了，我希望上面的步骤能帮助你在 CentOS 8 和 RHEL 8 服务器上启用并配置 EPEL 仓库，请在下面的评论栏分享你的评论和反馈。
---
via: <https://www.linuxtechi.com/enable-epel-repo-centos8-rhel8-server/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[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/) 荣誉推出
|
SQLite 真的很容易编译
|
Julia Evans
|
https://jvns.ca/blog/2019/10/28/sqlite-is-really-easy-to-compile/
|
事实证明，这个过程超麻烦（如通常一样），但是非常有趣！
|
/data/attachment/album/201911/04/120656cedfznzenxxvmxq1.jpg.thumb.jpg
|
/data/attachment/album/201911/04/120656cedfznzenxxvmxq1.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"SQLite"
] |
技术
|
{
"viewnum": 7963,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
事实证明，这个过程超麻烦（如通常一样），但是非常有趣！
| 2019-11-04T12:07:28 | 2019-11-04T12:07:28 | 11,536 |
/article-11536-1.html
|
上周，我一直在做一个 SQL 网站（<https://sql-steps.wizardzines.com/>，一个 SQL 示例列表）。我使用 sqlite 运行网站上的所有查询，并且我想在其中一个例子（[这个](https://sql-steps.wizardzines.com/lag.html)）中使用窗口函数。
但是我使用的是 Ubuntu 18.04 中的 sqlite 版本，它太旧了，不支持窗口函数。所以我需要升级 sqlite！
事实证明，这个过程超麻烦（如通常一样），但是非常有趣！我想起了一些有关可执行文件和共享库如何工作的信息，结论令人满意。所以我想在这里写下来。
（剧透：<https://www.sqlite.org/howtocompile.html> 中解释了如何编译 SQLite，它只需花费 5 秒左右，这比我平时从源码编译的体验容易了许多。）
### 尝试 1：从它的网站下载 SQLite 二进制文件
[SQLite 的下载页面](https://www.sqlite.org/download.html)有一个用于 Linux 的 SQLite 命令行工具的二进制文件的链接。我下载了它，它可以在笔记本电脑上运行，我以为这就完成了。
但是后来我尝试在构建服务器（Netlify） 上运行它，得到了这个极其奇怪的错误消息：“File not found”。我进行了追踪，并确定 `execve` 返回错误代码 ENOENT，这意味着 “File not found”。这有点令人发狂，因为该文件确实存在，并且有正确的权限。
我搜索了这个问题（通过搜索 “execve enoen”），找到了[这个 stackoverflow 中的答案](https://stackoverflow.com/questions/5234088/execve-file-not-found-when-stracing-the-very-same-file)，它指出要运行二进制文件，你不仅需要二进制文件存在！你还需要它的**加载程序**才能存在。（加载程序的路径在二进制文件内部）
要查看加载程序的路径，可以使用 `ldd`，如下所示：
```
$ ldd sqlite3
linux-gate.so.1 (0xf7f9d000)
libdl.so.2 => /lib/i386-linux-gnu/libdl.so.2 (0xf7f70000)
libm.so.6 => /lib/i386-linux-gnu/libm.so.6 (0xf7e6e000)
libz.so.1 => /lib/i386-linux-gnu/libz.so.1 (0xf7e4f000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xf7c73000)
/lib/ld-linux.so.2
```
所以 `/lib/ld-linux.so.2` 是加载程序，而该文件在构建服务器上不存在，可能是因为 Xenial（Xenial 是 Ubuntu 16.04，本文应该使用的是 18.04 “Bionic Beaver”）安装程序不支持 32 位二进制文件（？），因此我需要尝试一些不同的东西。
### 尝试 2：安装 Debian sqlite3 软件包
好吧，我想我也许可以安装来自 [debian testing 的 sqlite 软件包](https://packages.debian.org/bullseye/amd64/sqlite3/download)。尝试从另一个我不使用的 Debian 版本安装软件包并不是一个好主意，但是出于某种原因，我还是决定尝试一下。
这次毫不意外地破坏了我计算机上的 sqlite（这也破坏了 git），但我设法通过 `sudo dpkg --purge --force-all libsqlite3-0` 恢复了，并使所有依赖于 sqlite 的软件再次工作。
### 尝试 3：提取 Debian sqlite3 软件包
我还尝试仅从 Debian sqlite 软件包中提取 sqlite3 二进制文件并运行它。毫不意外，这也行不通，但这个更容易理解：我有旧版本的 libreadline（`.so.7`），但它需要 `.so.8`。
```
$ ./usr/bin/sqlite3
./usr/bin/sqlite3: error while loading shared libraries: libreadline.so.8: cannot open shared object file: No such file or directory
```
### 尝试 4：从源代码进行编译
我花费这么多时间尝试下载 sqlite 二进制的原因是我认为从源代码编译 sqlite 既烦人又耗时。但是显然，下载随便一个 sqlite 二进制文件根本不适合我，因此我最终决定尝试自己编译它。
这有指导：[如何编译 SQLite](https://www.sqlite.org/howtocompile.html)。它是宇宙中最简单的东西。通常，编译的感觉是类似这样的：
* 运行 `./configure`
* 意识到我缺少依赖
* 再次运行 `./configure`
* 运行 `make`
* 编译失败，因为我安装了错误版本的依赖
* 去做其他事，之后找到二进制文件
编译 SQLite 的方式如下：
* [从下载页面下载整合的 tarball](https://www.sqlite.org/download.html)
* 运行 `gcc shell.c sqlite3.c -lpthread -ldl`
* 完成！！！
所有代码都在一个文件（`sqlite.c`）中，并且没有奇怪的依赖项！太奇妙了。
对我而言，我实际上并不需要线程支持或 readline 支持，因此我用编译页面上的说明来创建了一个非常简单的二进制文件，它仅使用了 libc 而没有其他共享库。
```
$ ldd sqlite3
linux-vdso.so.1 (0x00007ffe8e7e9000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fbea4988000)
/lib64/ld-linux-x86-64.so.2 (0x00007fbea4d79000)
```
### 这很好，因为它使体验 sqlite 变得容易
我认为 SQLite 的构建过程如此简单很酷，因为过去我很乐于[编辑 sqlite 的源码](https://jvns.ca/blog/2014/10/02/how-does-sqlite-work-part-2-btrees/)来了解其 B 树的实现方式。
鉴于我对 SQLite 的了解，这并不令人感到意外（它在受限环境/嵌入式中确实可以很好地工作，因此可以以一种非常简单/最小的方式进行编译是有意义的）。 但这真是太好了！
---
via: <https://jvns.ca/blog/2019/10/28/sqlite-is-really-easy-to-compile/>
作者：[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/) 荣誉推出
|
如何编写 RPM 的 spec 文件
|
Ankur Sinha "franciscod"
|
https://fedoramagazine.org/how-rpm-packages-are-made-the-spec-file/
|
这篇文章深入研究了 spec 文件，该文件中包含了有关如何构建 RPM 的指令。
|
/data/attachment/album/201911/05/090750of1l5tt91r1eqlag.jpg.thumb.jpg
|
/data/attachment/album/201911/05/090750of1l5tt91r1eqlag.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"RPM"
] |
技术
|
{
"viewnum": 9027,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11527,
"displayorder": 0
}
] |
这篇文章深入研究了 spec 文件，该文件中包含了有关如何构建 RPM 的指令。
| 2019-11-05T09:07:46 | 2019-11-05T09:07:46 | 11,538 |
/article-11538-1.html
|
在[关于 RPM 软件包构建的上一篇文章](/article-11527-1.html)中，你了解到了源 RPM 包括软件的源代码以及 spec 文件。这篇文章深入研究了 spec 文件，该文件中包含了有关如何构建 RPM 的指令。同样，本文以 `fpaste` 为例。
### 了解源代码
在开始编写 spec 文件之前，你需要对要打包的软件有所了解。在这里，你正在研究 `fpaste`，这是一个非常简单的软件。它是用 Python 编写的，并且是一个单文件脚本。当它发布新版本时，可在 Pagure 上找到：<https://pagure.io/releases/fpaste/fpaste-0.3.9.2.tar.gz>。
如该档案文件所示，当前版本为 0.3.9.2。下载它，以便你查看该档案文件中的内容：
```
$ wget https://pagure.io/releases/fpaste/fpaste-0.3.9.2.tar.gz
$ tar -tvf fpaste-0.3.9.2.tar.gz
drwxrwxr-x root/root 0 2018-07-25 02:58 fpaste-0.3.9.2/
-rw-rw-r-- root/root 25 2018-07-25 02:58 fpaste-0.3.9.2/.gitignore
-rw-rw-r-- root/root 3672 2018-07-25 02:58 fpaste-0.3.9.2/CHANGELOG
-rw-rw-r-- root/root 35147 2018-07-25 02:58 fpaste-0.3.9.2/COPYING
-rw-rw-r-- root/root 444 2018-07-25 02:58 fpaste-0.3.9.2/Makefile
-rw-rw-r-- root/root 1656 2018-07-25 02:58 fpaste-0.3.9.2/README.rst
-rw-rw-r-- root/root 658 2018-07-25 02:58 fpaste-0.3.9.2/TODO
drwxrwxr-x root/root 0 2018-07-25 02:58 fpaste-0.3.9.2/docs/
drwxrwxr-x root/root 0 2018-07-25 02:58 fpaste-0.3.9.2/docs/man/
drwxrwxr-x root/root 0 2018-07-25 02:58 fpaste-0.3.9.2/docs/man/en/
-rw-rw-r-- root/root 3867 2018-07-25 02:58 fpaste-0.3.9.2/docs/man/en/fpaste.1
-rwxrwxr-x root/root 24884 2018-07-25 02:58 fpaste-0.3.9.2/fpaste
lrwxrwxrwx root/root 0 2018-07-25 02:58 fpaste-0.3.9.2/fpaste.py -> fpaste
```
你要安装的文件是：
* `fpaste.py`：应该安装到 `/usr/bin/`。
* `docs/man/en/fpaste.1`：手册，应放到 `/usr/share/man/man1/`。
* `COPYING`：许可证文本，应放到 `/usr/share/license/fpaste/`。
* `README.rst`、`TODO`：放到 `/usr/share/doc/fpaste/` 下的其它文档。
这些文件的安装位置取决于文件系统层次结构标准（FHS）。要了解更多信息，可以在这里阅读：<http://www.pathname.com/fhs/> 或查看 Fedora 系统的手册页：
```
$ man hier
```
#### 第一部分：要构建什么？
现在我们知道了源文件中有哪些文件，以及它们要存放的位置，让我们看一下 spec 文件。你可以在此处查看这个完整的文件：<https://src.fedoraproject.org/rpms/fpaste/blob/master/f/fpaste.spec>。
这是 spec 文件的第一部分：
```
Name: fpaste
Version: 0.3.9.2
Release: 3%{?dist}
Summary: A simple tool for pasting info onto sticky notes instances
BuildArch: noarch
License: GPLv3+
URL: https://pagure.io/fpaste
Source0: https://pagure.io/releases/fpaste/fpaste-0.3.9.2.tar.gz
Requires: python3
%description
It is often useful to be able to easily paste text to the Fedora
Pastebin at http://paste.fedoraproject.org and this simple script
will do that and return the resulting URL so that people may
examine the output. This can hopefully help folks who are for
some reason stuck without X, working remotely, or any other
reason they may be unable to paste something into the pastebin
```
`Name`、`Version` 等称为*标签*，它们定义在 RPM 中。这意味着你不能只是随意写点标签，RPM 无法理解它们！需要注意的标签是：
* `Source0`：告诉 RPM 该软件的源代码档案文件所在的位置。
* `Requires`：列出软件的运行时依赖项。RPM 可以自动检测很多依赖项，但是在某些情况下，必须手动指明它们。运行时依赖项是系统上必须具有的功能（通常是软件包），才能使该软件包起作用。这是 [dnf](https://fedoramagazine.org/managing-packages-fedora-dnf/) 在安装此软件包时检测是否需要拉取其他软件包的方式。
* `BuildRequires`：列出了此软件的构建时依赖项。这些通常必须手动确定并添加到 spec 文件中。
* `BuildArch`：此软件为该计算机体系结构所构建。如果省略此标签，则将为所有受支持的体系结构构建该软件。值 `noarch` 表示该软件与体系结构无关（例如 `fpaste`，它完全是用 Python 编写的）。
本节提供有关 `fpaste` 的常规信息：它是什么，正在将什么版本制作为 RPM，其许可证等等。如果你已安装 `fpaste`，并查看其元数据时，则可以看到该 RPM 中包含的以下信息：
```
$ sudo dnf install fpaste
$ rpm -qi fpaste
Name : fpaste
Version : 0.3.9.2
Release : 2.fc30
...
```
RPM 会自动添加一些其他标签，以代表它所知道的内容。
至此，我们掌握了要为其构建 RPM 的软件的一般信息。接下来，我们开始告诉 RPM 做什么。
#### 第二部分：准备构建
spec 文件的下一部分是准备部分，用 `％prep` 代表：
```
%prep
%autosetup
```
对于 `fpaste`，这里唯一的命令是 `％autosetup`。这只是将 tar 档案文件提取到一个新文件夹中，并为下一部分的构建阶段做好了准备。你可以在此处执行更多操作，例如应用补丁程序，出于不同目的修改文件等等。如果你查看过 Python 的源 RPM 的内容，那么你会在那里看到许多补丁。这些都将在本节中应用。
通常，spec 文件中带有 `％` 前缀的所有内容都是 RPM 以特殊方式解释的宏或标签。这些通常会带有大括号，例如 `％{example}`。
#### 第三部分：构建软件
下一部分是构建软件的位置，用 `％build` 表示。现在，由于 `fpaste` 是一个简单的纯 Python 脚本，因此无需构建。因此，这里是：
```
%build
#nothing required
```
不过，通常来说，你会在此处使用构建命令，例如：
```
configure; make
```
构建部分通常是 spec 文件中最难的部分，因为这是从源代码构建软件的地方。这要求你知道该工具使用的是哪个构建系统，该系统可能是许多构建系统之一：Autotools、CMake、Meson、Setuptools（用于 Python）等等。每个都有自己的命令和语法样式。你需要充分了解这些才能正确构建软件。
#### 第四部分：安装文件
软件构建后，需要在 `％install` 部分中安装它：
```
%install
mkdir -p %{buildroot}%{_bindir}
make install BINDIR=%{buildroot}%{_bindir} MANDIR=%{buildroot}%{_mandir}
```
在构建 RPM 时，RPM 不会修改你的系统文件。在一个可以正常运行的系统上添加、删除或修改文件的风险太大。如果发生故障怎么办？因此，RPM 会创建一个专门打造的文件系统并在其中工作。这称为 `buildroot`。 因此，在 `buildroot` 中，我们创建由宏 `％{_bindir}` 代表的 `/usr/bin` 目录，然后使用提供的 `Makefile` 将文件安装到其中。
至此，我们已经在专门打造的 `buildroot` 中安装了 `fpaste` 的构建版本。
#### 第五部分：列出所有要包括在 RPM 中的文件
spec 文件其后的一部分是文件部分：`％files`。在这里，我们告诉 RPM 从该 spec 文件创建的档案文件中包含哪些文件。`fpaste` 的文件部分非常简单：
```
%files
%{_bindir}/%{name}
%doc README.rst TODO
%{_mandir}/man1/%{name}.1.gz
%license COPYING
```
请注意，在这里，我们没有指定 `buildroot`。所有这些路径都是相对路径。`％doc` 和 `％license`命令做的稍微多一点，它们会创建所需的文件夹，并记住这些文件必须放在那里。
RPM 很聪明。例如，如果你在 `％install` 部分中安装了文件，但未列出它们，它会提醒你。
#### 第六部分：在变更日志中记录所有变更
Fedora 是一个基于社区的项目。许多贡献者维护或共同维护软件包。因此，当务之急是不要被软件包做了哪些更改所搞混。为了确保这一点，spec 文件包含的最后一部分是变更日志 `％changelog`：
```
%changelog
* Thu Jul 25 2019 Fedora Release Engineering < ...> - 0.3.9.2-3
- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild
* Thu Jan 31 2019 Fedora Release Engineering < ...> - 0.3.9.2-2
- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild
* Tue Jul 24 2018 Ankur Sinha - 0.3.9.2-1
- Update to 0.3.9.2
* Fri Jul 13 2018 Fedora Release Engineering < ...> - 0.3.9.1-4
- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild
* Wed Feb 07 2018 Fedora Release Engineering < ..> - 0.3.9.1-3
- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild
* Sun Sep 10 2017 Vasiliy N. Glazov < ...> - 0.3.9.1-2
- Cleanup spec
* Fri Sep 08 2017 Ankur Sinha - 0.3.9.1-1
- Update to latest release
- fixes rhbz 1489605
...
....
```
spec 文件的*每项*变更都必须有一个变更日志条目。如你在此处看到的，虽然我以维护者身份更新了该 spec 文件，但其他人也做过更改。清楚地记录变更内容有助于所有人知道该 spec 文件的当前状态。对于系统上安装的所有软件包，都可以使用 `rpm` 来查看其更改日志：
```
$ rpm -q --changelog fpaste
```
### 构建 RPM
现在我们准备构建 RPM 包。如果要继续执行以下命令，请确保遵循[上一篇文章](/article-11527-1.html)中的步骤设置系统以构建 RPM。
我们将 `fpaste` 的 spec 文件放置在 `~/rpmbuild/SPECS` 中，将源代码档案文件存储在 `~/rpmbuild/SOURCES/` 中，现在可以创建源 RPM 了：
```
$ cd ~/rpmbuild/SPECS
$ wget https://src.fedoraproject.org/rpms/fpaste/raw/master/f/fpaste.spec
$ cd ~/rpmbuild/SOURCES
$ wget https://pagure.io/fpaste/archive/0.3.9.2/fpaste-0.3.9.2.tar.gz
$ cd ~/rpmbuild/SOURCES
$ rpmbuild -bs fpaste.spec
Wrote: /home/asinha/rpmbuild/SRPMS/fpaste-0.3.9.2-3.fc30.src.rpm
```
让我们看一下结果：
```
$ ls ~/rpmbuild/SRPMS/fpaste*
/home/asinha/rpmbuild/SRPMS/fpaste-0.3.9.2-3.fc30.src.rpm
$ rpm -qpl ~/rpmbuild/SRPMS/fpaste-0.3.9.2-3.fc30.src.rpm
fpaste-0.3.9.2.tar.gz
fpaste.spec
```
我们看到源 RPM 已构建。让我们同时构建源 RPM 和二进制 RPM：
```
$ cd ~/rpmbuild/SPECS
$ rpmbuild -ba fpaste.spec
..
..
..
```
RPM 将向你显示完整的构建输出，并在我们之前看到的每个部分中详细说明它的工作。此“构建日志”非常重要。当构建未按预期进行时，我们的打包人员将花费大量时间来遍历它们，以跟踪完整的构建路径来查看出了什么问题。
就是这样！准备安装的 RPM 应该位于以下位置：
```
$ ls ~/rpmbuild/RPMS/noarch/
fpaste-0.3.9.2-3.fc30.noarch.rpm
```
### 概括
我们已经介绍了如何从 spec 文件构建 RPM 的基础知识。这绝不是一份详尽的文档。实际上，它根本不是文档。它只是试图解释幕后的运作方式。简短回顾一下：
* RPM 有两种类型：源 RPM 和 二进制 RPM。
* 二进制 RPM 包含要安装以使用该软件的文件。
* 源 RPM 包含构建二进制 RPM 所需的信息：完整的源代码，以及 spec 文件中的有关如何构建 RPM 的说明。
* spec 文件包含多个部分，每个部分都有其自己的用途。 在这里，我们已经在安装好的 Fedora 系统中本地构建了 RPM。虽然这是个基本的过程，但我们从存储库中获得的 RPM 是建立在具有严格配置和方法的专用服务器上的，以确保正确性和安全性。这个 Fedora 打包流程将在以后的文章中讨论。
你想开始构建软件包，并帮助 Fedora 社区维护我们提供的大量软件吗？你可以[从这里开始加入软件包集合维护者](https://fedoraproject.org/wiki/Join_the_package_collection_maintainers)。
如有任何疑问，请发布到 [Fedora 开发人员邮件列表](https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/)，我们随时乐意为你提供帮助！
### 参考
这里有一些构建 RPM 的有用参考：
* <https://fedoraproject.org/wiki/How_to_create_an_RPM_package>
* <https://docs.fedoraproject.org/en-US/quick-docs/create-hello-world-rpm/>
* <https://docs.fedoraproject.org/en-US/packaging-guidelines/>
* <https://rpm.org/documentation.html>
---
via: <https://fedoramagazine.org/how-rpm-packages-are-made-the-spec-file/>
作者：[Ankur Sinha FranciscoD](https://fedoramagazine.org/author/ankursinha/) 选题：[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/) 荣誉推出
|
为什么你不必害怕 Kubernetes
|
Scott Mccarty
|
https://opensource.com/article/19/10/kubernetes-complex-business-problem
|
Kubernetes 绝对是满足复杂 web 应用程序需求的最简单、最容易的方法。
|
/data/attachment/album/201911/05/115817v397nh7jx3hx5ffs.png.thumb.jpg
|
/data/attachment/album/201911/05/115817v397nh7jx3hx5ffs.png
| true | false | true |
lujun9972
|
laingke
|
wxy
| false |
[
"Kubernetes"
] |
观点
|
{
"viewnum": 3225,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11011,
"displayorder": 0
}
] |
Kubernetes 绝对是满足复杂 web 应用程序需求的最简单、最容易的方法。
| 2019-11-05T11:58:13 | 2019-11-05T11:58:13 | 11,539 |
/article-11539-1.html
|
>
> Kubernetes 绝对是满足复杂 web 应用程序需求的最简单、最容易的方法。
>
>
>
在 90 年代末和 2000 年代初，在大型网站工作很有趣。我的经历让我想起了 American Greetings Interactive，在情人节那天，我们拥有了互联网上排名前 10 位之一的网站（以网络访问量衡量）。我们为 [AmericanGreetings.com](http://AmericanGreetings.com)、[BlueMountain.com](http://BlueMountain.com) 等公司提供了电子贺卡，并为 MSN 和 AOL 等合作伙伴提供了电子贺卡。该组织的老员工仍然深切地记得与 Hallmark 等其它电子贺卡网站进行大战的史诗般的故事。顺便说一句，我还为 Holly Hobbie、Care Bears 和 Strawberry Shortcake 运营过大型网站。
我记得那就像是昨天发生的一样，这是我们第一次遇到真正的问题。通常，我们的前门（路由器、防火墙和负载均衡器）有大约 200Mbps 的流量进入。但是，突然之间，Multi Router Traffic Grapher（MRTG）图示突然在几分钟内飙升至 2Gbps。我疯了似地东奔西跑。我了解了我们的整个技术堆栈，从路由器、交换机、防火墙和负载平衡器，到 Linux/Apache web 服务器，到我们的 Python 堆栈（FastCGI 的元版本），以及网络文件系统（NFS）服务器。我知道所有配置文件在哪里，我可以访问所有管理界面，并且我是一位经验丰富的，打过硬仗的系统管理员，具有多年解决复杂问题的经验。
但是，我无法弄清楚发生了什么……
当你在一千个 Linux 服务器上疯狂地键入命令时，五分钟的感觉就像是永恒。我知道站点可能会在任何时候崩溃，因为当它被划分成更小的集群时，压垮上千个节点的集群是那么的容易。
我迅速*跑到*老板的办公桌前，解释了情况。他几乎没有从电子邮件中抬起头来，这使我感到沮丧。他抬头看了看，笑了笑，说道：“是的，市场营销可能会开展广告活动。有时会发生这种情况。”他告诉我在应用程序中设置一个特殊标志，以减轻 Akamai 的访问量。我跑回我的办公桌，在上千台 web 服务器上设置了标志，几分钟后，站点恢复正常。灾难也就被避免了。
我可以再分享 50 个类似的故事，但你脑海中可能会有一点好奇：“这种运维方式将走向何方?”
关键是，我们遇到了业务问题。当技术问题使你无法开展业务时，它们就变成了业务问题。换句话说，如果你的网站无法访问，你就不能处理客户交易。
那么，所有这些与 Kubernetes 有什么关系？一切！世界已经改变。早在 90 年代末和 00 年代初，只有大型网站才出现大型的、<ruby> 规模级 <rt> web-scale </rt></ruby>的问题。现在，有了微服务和数字化转型，每个企业都面临着一个大型的、规模级的问题——可能是多个大型的、规模级的问题。
你的企业需要能够通过许多不同的人构建的许多不同的、通常是复杂的服务来管理复杂的规模级的网站。你的网站需要动态地处理流量，并且它们必须是安全的。这些属性需要在所有层（从基础结构到应用程序层）上由 API 驱动。
### 进入 Kubernetes
Kubernetes 并不复杂；你的业务问题才复杂。当你想在生产环境中运行应用程序时，要满足性能（伸缩性、性能抖动等）和安全性要求，就需要最低程度的复杂性。诸如高可用性（HA）、容量要求（N+1、N+2、N+100）以及保证最终一致性的数据技术等就会成为必需。这些是每家进行数字化转型的公司的生产要求，而不仅仅是 Google、Facebook 和 Twitter 这样的大型网站。
在旧时代，我还在 American Greetings 任职时，每次我们加入一个新的服务，它看起来像这样：所有这些都是由网站运营团队来处理的，没有一个是通过订单系统转移给其他团队来处理的。这是在 DevOps 出现之前的 DevOps：
1. 配置 DNS（通常是内部服务层和面向公众的外部）
2. 配置负载均衡器（通常是内部服务和面向公众的）
3. 配置对文件的共享访问（大型 NFS 服务器、群集文件系统等）
4. 配置集群软件（数据库、服务层等）
5. 配置 web 服务器群集（可以是 10 或 50 个服务器）
大多数配置是通过配置管理自动完成的，但是配置仍然很复杂，因为每个系统和服务都有不同的配置文件，而且格式完全不同。我们研究了像 [Augeas](http://augeas.net/) 这样的工具来简化它，但是我们认为使用转换器来尝试和标准化一堆不同的配置文件是一种反模式。
如今，借助 Kubernetes，启动一项新服务本质上看起来如下：
1. 配置 Kubernetes YAML/JSON。
2. 提交给 Kubernetes API（`kubectl create -f service.yaml`）。
Kubernetes 大大简化了服务的启动和管理。服务所有者（无论是系统管理员、开发人员还是架构师）都可以创建 Kubernetes 格式的 YAML/JSON 文件。使用 Kubernetes，每个系统和每个用户都说相同的语言。所有用户都可以在同一 Git 存储库中提交这些文件，从而启用 GitOps。
而且，可以弃用和删除服务。从历史上看，删除 DNS 条目、负载平衡器条目和 Web 服务器的配置等是非常可怕的，因为你几乎肯定会破坏某些东西。使用 Kubernetes，所有内容都处于命名空间下，因此可以通过单个命令删除整个服务。尽管你仍然需要确保其它应用程序不使用它（微服务和函数即服务 [FaaS] 的缺点），但你可以更加确信：删除服务不会破坏基础架构环境。
### 构建、管理和使用 Kubernetes
太多的人专注于构建和管理 Kubernetes 而不是使用它（详见 [Kubernetes 是一辆翻斗车](/article-11011-1.html)）。
在单个节点上构建一个简单的 Kubernetes 环境并不比安装 LAMP 堆栈复杂得多，但是我们无休止地争论着构建与购买的问题。不是 Kubernetes 很难；它以高可用性大规模运行应用程序。建立一个复杂的、高可用性的 Kubernetes 集群很困难，因为要建立如此规模的任何集群都是很困难的。它需要规划和大量软件。建造一辆简单的翻斗车并不复杂，但是建造一辆可以运载 [10 吨垃圾并能以 200 迈的速度稳定行驶的卡车](http://crunchtools.com/kubernetes-10-ton-dump-truck-handles-pretty-well-200-mph/)则很复杂。
管理 Kubernetes 可能很复杂，因为管理大型的、规模级的集群可能很复杂。有时，管理此基础架构很有意义；而有时不是。由于 Kubernetes 是一个社区驱动的开源项目，它使行业能够以多种不同方式对其进行管理。供应商可以出售托管版本，而用户可以根据需要自行决定对其进行管理。（但是你应该质疑是否确实需要。）
使用 Kubernetes 是迄今为止运行大规模网站的最简单方法。Kubernetes 正在普及运行一组大型、复杂的 Web 服务的能力——就像当年 Linux 在 Web 1.0 中所做的那样。
由于时间和金钱是一个零和游戏，因此我建议将重点放在使用 Kubernetes 上。将你的时间和金钱花费在[掌握 Kubernetes 原语](/article-11036-1.html)或处理[活跃度和就绪性探针](https://srcco.de/posts/kubernetes-liveness-probes-are-dangerous.html)的最佳方法上（表明大型、复杂的服务很难的另一个例子）。不要专注于构建和管理 Kubernetes。（在构建和管理上）许多供应商可以为你提供帮助。
### 结论
我记得对无数的问题进行了故障排除，比如我在这篇文章的开头所描述的问题——当时 Linux 内核中的 NFS、我们自产的 CFEngine、仅在某些 Web 服务器上出现的重定向问题等）。开发人员无法帮助我解决所有这些问题。实际上，除非开发人员具备高级系统管理员的技能，否则他们甚至不可能进入系统并作为第二双眼睛提供帮助。没有带有图形或“可观察性”的控制台——可观察性在我和其他系统管理员的大脑中。如今，有了 Kubernetes、Prometheus、Grafana 等，一切都改变了。
关键是：
1. 时代不一样了。现在，所有 Web 应用程序都是大型的分布式系统。就像 AmericanGreetings.com 过去一样复杂，现在每个网站都有扩展性和 HA 的要求。
2. 运行大型的分布式系统是很困难的。绝对是。这是业务的需求，不是 Kubernetes 的问题。使用更简单的编排系统并不是解决方案。
Kubernetes 绝对是满足复杂 Web 应用程序需求的最简单，最容易的方法。这是我们生活的时代，而 Kubernetes 擅长于此。你可以讨论是否应该自己构建或管理 Kubernetes。有很多供应商可以帮助你构建和管理它，但是很难否认这是大规模运行复杂 Web 应用程序的最简单方法。
---
via: <https://opensource.com/article/19/10/kubernetes-complex-business-problem>
作者：[Scott McCarty](https://opensource.com/users/fatherlinux) 选题：[lujun9972](https://github.com/lujun9972) 译者：[laingke](https://github.com/laingke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
将 Fedora 30 升级到 Fedora 31
|
Ben Cotton
|
https://fedoramagazine.org/upgrading-fedora-30-to-fedora-31/
|
Fedora 工作站有图形化的升级方式。另外，Fedora 提供了一种命令行方式来将 Fedora 30 升级到 Fedora 31。
|
/data/attachment/album/201911/05/122015z1efmatm6mff667o.jpg.thumb.jpg
|
/data/attachment/album/201911/05/122015z1efmatm6mff667o.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Fedora"
] |
技术
|
{
"viewnum": 4188,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Fedora 工作站有图形化的升级方式。另外，Fedora 提供了一种命令行方式来将 Fedora 30 升级到 Fedora 31。
| 2019-11-05T12:20:12 | 2019-11-05T12:20:12 | 11,541 |
/article-11541-1.html
|
Fedora 31 [日前发布了](/article-11522-1.html)。你也许想要升级系统来获得 Fedora 中的最新功能。Fedora 工作站有图形化的升级方式。另外，Fedora 提供了一种命令行方式来将 Fedora 30 升级到 Fedora 31。
### 将 Fedora 30 工作站升级到 Fedora 31
在该发布不久之后，就会有通知告诉你有可用升级。你可以点击通知打开 GNOME “软件”。或者在 GNOME Shell 选择“软件”。
在 GNOME 软件中选择*更新*，你应该会看到告诉你有 Fedora 31 更新的提示。
如果你在屏幕上看不到任何内容，请尝试使用左上方的重新加载按钮。在发布后，所有系统可能需要一段时间才能看到可用的升级。
选择*下载*以获取升级包。你可以继续工作，直到下载完成。然后使用 GNOME “软件”重启系统并应用升级。升级需要时间，因此你可能需要喝杯咖啡，稍后再返回系统。
### 使用命令行
如果你是从 Fedora 以前的版本升级的，那么你可能对 `dnf upgrade` 插件很熟悉。这是推荐且支持的从 Fedora 30 升级到 Fedora 31 的方法。使用此插件能让你轻松地升级到 Fedora 31。
#### 1、更新软件并备份系统
在开始升级之前，请确保你安装了 Fedora 30 的最新软件。如果你安装了模块化软件，这点尤为重要。`dnf` 和 GNOME “软件”的最新版本对某些模块化流的升级过程进行了改进。要更新软件，请使用 GNOME “软件” 或在终端中输入以下命令：
```
sudo dnf upgrade --refresh
```
此外，在继续操作之前，请确保备份系统。有关备份的帮助，请参阅 Fedora Magazine 上的[备份系列](https://fedoramagazine.org/taking-smart-backups-duplicity/)。
#### 2、安装 DNF 插件
接下来，打开终端并输入以下命令安装插件：
```
sudo dnf install dnf-plugin-system-upgrade
```
#### 3、使用 DNF 开始更新
现在，你的系统是最新的，已经备份并且安装了 DNF 插件，你可以通过在终端中使用以下命令来开始升级：
```
sudo dnf system-upgrade download --releasever=31
```
该命令将开始在本地下载计算机的所有升级。如果由于缺乏更新包、损坏的依赖项或已淘汰的软件包而在升级时遇到问题，请在输入上面的命令时添加 `‐-allowerasing` 标志。这将使 DNF 删除可能阻止系统升级的软件包。
#### 4、重启并升级
上面的命令下载更新完成后，你的系统就可以重启了。要将系统引导至升级过程，请在终端中输入以下命令：
```
sudo dnf system-upgrade reboot
```
此后，你的系统将重启。在许多版本之前，`fedup` 工具会在内核选择/引导页面上创建一个新选项。使用 `dnf-plugin-system-upgrade` 软件包，你的系统将重新引导到当前 Fedora 30 使用的内核。这很正常。在内核选择页面之后不久，你的系统会开始升级过程。
现在也许可以喝杯咖啡休息下！升级完成后，系统将重启，你将能够登录到新升级的 Fedora 31 系统。
### 解决升级问题
有时，升级系统时可能会出现意外问题。如果遇到任何问题，请访问 [DNF 系统升级文档](https://docs.fedoraproject.org/en-US/quick-docs/dnf-system-upgrade/#Resolving_post-upgrade_issues)，以获取有关故障排除的更多信息。
如果升级时遇到问题，并且系统上安装了第三方仓库，那么在升级时可能需要禁用这些仓库。对于 Fedora 不提供的仓库的支持，请联系仓库的提供者。
---
via: <https://fedoramagazine.org/upgrading-fedora-30-to-fedora-31/>
作者：[Ben Cotton](https://fedoramagazine.org/author/bcotton/) 选题：[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 中找出内存消耗最大的进程
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/linux-find-top-memory-consuming-processes/
|
很多次，你可能遇见过系统消耗了过多的内存。如果是这种情况，那么最好的办法是识别出 Linux 机器上消耗过多内存的进程。
|
/data/attachment/album/201911/06/110149r81efjx12afjat7f.jpg.thumb.jpg
|
/data/attachment/album/201911/06/110149r81efjx12afjat7f.jpg
| true | false | true |
lujun9972
|
lnrCoder
|
wxy
| false |
[
"内存"
] |
技术
|
{
"viewnum": 18676,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
很多次，你可能遇见过系统消耗了过多的内存。如果是这种情况，那么最好的办法是识别出 Linux 机器上消耗过多内存的进程。
| 2019-11-06T11:02:00 | 2019-11-06T11:02:00 | 11,542 |
/article-11542-1.html
|
很多次，你可能遇见过系统消耗了过多的内存。如果是这种情况，那么最好的办法是识别出 Linux 机器上消耗过多内存的进程。我相信，你可能已经运行了下文中的命令以进行检查。如果没有，那你尝试过哪些其他的命令？我希望你可以在评论中更新这篇文章，它可能会帮助其他用户。
使用 [top 命令](https://www.2daygeek.com/linux-top-command-linux-system-performance-monitoring-tool/) 和 [ps 命令](https://www.2daygeek.com/linux-ps-command-find-running-process-monitoring/) 可以轻松的识别这种情况。我过去经常同时使用这两个命令，两个命令得到的结果是相同的。所以我建议你从中选择一个喜欢的使用就可以。
### 1) 如何使用 ps 命令在 Linux 中查找内存消耗最大的进程
`ps` 命令用于报告当前进程的快照。`ps` 命令的意思是“进程状态”。这是一个标准的 Linux 应用程序，用于查找有关在 Linux 系统上运行进程的信息。
它用于列出当前正在运行的进程及其进程 ID（PID）、进程所有者名称、进程优先级（PR）以及正在运行的命令的绝对路径等。
下面的 `ps` 命令格式为你提供有关内存消耗最大进程的更多信息。
```
# ps aux --sort -rss | head
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
mysql 1064 3.2 5.4 886076 209988 ? Ssl Oct25 62:40 /usr/sbin/mysqld
varnish 23396 0.0 2.9 286492 115616 ? SLl Oct25 0:42 /usr/sbin/varnishd -P /var/run/varnish.pid -f /etc/varnish/default.vcl -a :82 -T 127.0.0.1:6082 -S /etc/varnish/secret -s malloc,256M
named 1105 0.0 2.7 311712 108204 ? Ssl Oct25 0:16 /usr/sbin/named -u named -c /etc/named.conf
nobody 23377 0.2 2.3 153096 89432 ? S Oct25 4:35 nginx: worker process
nobody 23376 0.1 2.1 147096 83316 ? S Oct25 2:18 nginx: worker process
root 23375 0.0 1.7 131028 66764 ? Ss Oct25 0:01 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf
nobody 23378 0.0 1.6 130988 64592 ? S Oct25 0:00 nginx: cache manager process
root 1135 0.0 0.9 86708 37572 ? S 05:37 0:20 cwpsrv: worker process
root 1133 0.0 0.9 86708 37544 ? S 05:37 0:05 cwpsrv: worker process
```
使用以下 `ps` 命令格式可在输出中仅展示有关内存消耗过程的特定信息。
```
# ps -eo pid,ppid,%mem,%cpu,cmd --sort=-%mem | head
PID PPID %MEM %CPU CMD
1064 1 5.4 3.2 /usr/sbin/mysqld
23396 23386 2.9 0.0 /usr/sbin/varnishd -P /var/run/varnish.pid -f /etc/varnish/default.vcl -a :82 -T 127.0.0.1:6082 -S /etc/varnish/secret -s malloc,256M
1105 1 2.7 0.0 /usr/sbin/named -u named -c /etc/named.conf
23377 23375 2.3 0.2 nginx: worker process
23376 23375 2.1 0.1 nginx: worker process
3625 977 1.9 0.0 /usr/local/bin/php-cgi /home/daygeekc/public_html/index.php
23375 1 1.7 0.0 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf
23378 23375 1.6 0.0 nginx: cache manager process
1135 3034 0.9 0.0 cwpsrv: worker process
```
如果你只想查看命令名称而不是命令的绝对路径，请使用下面的 `ps` 命令格式。
```
# ps -eo pid,ppid,%mem,%cpu,comm --sort=-%mem | head
PID PPID %MEM %CPU COMMAND
1064 1 5.4 3.2 mysqld
23396 23386 2.9 0.0 cache-main
1105 1 2.7 0.0 named
23377 23375 2.3 0.2 nginx
23376 23375 2.1 0.1 nginx
23375 1 1.7 0.0 nginx
23378 23375 1.6 0.0 nginx
1135 3034 0.9 0.0 cwpsrv
1133 3034 0.9 0.0 cwpsrv
```
### 2) 如何使用 top 命令在 Linux 中查找内存消耗最大的进程
Linux 的 `top` 命令是用来监视 Linux 系统性能的最好和最知名的命令。它在交互界面上显示运行的系统进程的实时视图。但是，如果要查找内存消耗最大的进程，请 [在批处理模式下使用 top 命令](/article-11491-1.html)。
你应该正确地 [了解 top 命令输出](https://www.2daygeek.com/understanding-linux-top-command-output-usage/) 以解决系统中的性能问题。
```
# top -c -b -o +%MEM | head -n 20 | tail -15
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1064 mysql 20 0 886076 209740 8388 S 0.0 5.4 62:41.20 /usr/sbin/mysqld
23396 varnish 20 0 286492 115616 83572 S 0.0 3.0 0:42.24 /usr/sbin/varnishd -P /var/run/varnish.pid -f /etc/varnish/default.vcl -a :82 -T 127.0.0.1:6082 -S /etc/varnish/secret -s malloc,256M
1105 named 20 0 311712 108204 2424 S 0.0 2.8 0:16.41 /usr/sbin/named -u named -c /etc/named.conf
23377 nobody 20 0 153240 89432 2432 S 0.0 2.3 4:35.74 nginx: worker process
23376 nobody 20 0 147096 83316 2416 S 0.0 2.1 2:18.09 nginx: worker process
23375 root 20 0 131028 66764 1616 S 0.0 1.7 0:01.07 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf
23378 nobody 20 0 130988 64592 592 S 0.0 1.7 0:00.51 nginx: cache manager process
1135 root 20 0 86708 37572 2252 S 0.0 1.0 0:20.18 cwpsrv: worker process
1133 root 20 0 86708 37544 2212 S 0.0 1.0 0:05.94 cwpsrv: worker process
3034 root 20 0 86704 36740 1452 S 0.0 0.9 0:00.09 cwpsrv: master process /usr/local/cwpsrv/bin/cwpsrv
1067 nobody 20 0 1356200 31588 2352 S 0.0 0.8 0:56.06 /usr/local/apache/bin/httpd -k start
977 nobody 20 0 1356088 31268 2372 S 0.0 0.8 0:30.44 /usr/local/apache/bin/httpd -k start
968 nobody 20 0 1356216 30544 2348 S 0.0 0.8 0:19.95 /usr/local/apache/bin/httpd -k start
```
如果你只想查看命令名称而不是命令的绝对路径，请使用下面的 `top` 命令格式。
```
# top -b -o +%MEM | head -n 20 | tail -15
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1064 mysql 20 0 886076 210340 8388 S 6.7 5.4 62:40.93 mysqld
23396 varnish 20 0 286492 115616 83572 S 0.0 3.0 0:42.24 cache-main
1105 named 20 0 311712 108204 2424 S 0.0 2.8 0:16.41 named
23377 nobody 20 0 153240 89432 2432 S 13.3 2.3 4:35.74 nginx
23376 nobody 20 0 147096 83316 2416 S 0.0 2.1 2:18.09 nginx
23375 root 20 0 131028 66764 1616 S 0.0 1.7 0:01.07 nginx
23378 nobody 20 0 130988 64592 592 S 0.0 1.7 0:00.51 nginx
1135 root 20 0 86708 37572 2252 S 0.0 1.0 0:20.18 cwpsrv
1133 root 20 0 86708 37544 2212 S 0.0 1.0 0:05.94 cwpsrv
3034 root 20 0 86704 36740 1452 S 0.0 0.9 0:00.09 cwpsrv
1067 nobody 20 0 1356200 31588 2352 S 0.0 0.8 0:56.04 httpd
977 nobody 20 0 1356088 31268 2372 S 0.0 0.8 0:30.44 httpd
968 nobody 20 0 1356216 30544 2348 S 0.0 0.8 0:19.95 httpd
```
### 3) 奖励技巧：如何使用 ps\_mem 命令在 Linux 中查找内存消耗最大的进程
[ps\_mem 程序](https://www.2daygeek.com/ps_mem-report-core-memory-usage-accurately-in-linux/) 用于显示每个程序（而不是每个进程）使用的核心内存。该程序允许你检查每个程序使用了多少内存。它根据程序计算私有和共享内存的数量，并以最合适的方式返回已使用的总内存。
它使用以下逻辑来计算内存使用量。总内存使用量 = sum(用于程序进程的专用内存使用量) + sum(用于程序进程的共享内存使用量)。
```
# ps_mem
Private + Shared = RAM used Program
128.0 KiB + 27.5 KiB = 155.5 KiB agetty
228.0 KiB + 47.0 KiB = 275.0 KiB atd
284.0 KiB + 53.0 KiB = 337.0 KiB irqbalance
380.0 KiB + 81.5 KiB = 461.5 KiB dovecot
364.0 KiB + 121.5 KiB = 485.5 KiB log
520.0 KiB + 65.5 KiB = 585.5 KiB auditd
556.0 KiB + 60.5 KiB = 616.5 KiB systemd-udevd
732.0 KiB + 48.0 KiB = 780.0 KiB crond
296.0 KiB + 524.0 KiB = 820.0 KiB avahi-daemon (2)
772.0 KiB + 51.5 KiB = 823.5 KiB systemd-logind
940.0 KiB + 162.5 KiB = 1.1 MiB dbus-daemon
1.1 MiB + 99.0 KiB = 1.2 MiB pure-ftpd
1.2 MiB + 100.5 KiB = 1.3 MiB master
1.3 MiB + 198.5 KiB = 1.5 MiB pickup
1.3 MiB + 198.5 KiB = 1.5 MiB bounce
1.3 MiB + 198.5 KiB = 1.5 MiB pipe
1.3 MiB + 207.5 KiB = 1.5 MiB qmgr
1.4 MiB + 198.5 KiB = 1.6 MiB cleanup
1.3 MiB + 299.5 KiB = 1.6 MiB trivial-rewrite
1.5 MiB + 145.0 KiB = 1.6 MiB config
1.4 MiB + 291.5 KiB = 1.6 MiB tlsmgr
1.4 MiB + 308.5 KiB = 1.7 MiB local
1.4 MiB + 323.0 KiB = 1.8 MiB anvil (2)
1.3 MiB + 559.0 KiB = 1.9 MiB systemd-journald
1.8 MiB + 240.5 KiB = 2.1 MiB proxymap
1.9 MiB + 322.5 KiB = 2.2 MiB auth
2.4 MiB + 88.5 KiB = 2.5 MiB systemd
2.8 MiB + 458.5 KiB = 3.2 MiB smtpd
2.9 MiB + 892.0 KiB = 3.8 MiB bash (2)
3.3 MiB + 555.5 KiB = 3.8 MiB NetworkManager
4.1 MiB + 233.5 KiB = 4.3 MiB varnishd
4.0 MiB + 662.0 KiB = 4.7 MiB dhclient (2)
4.3 MiB + 623.5 KiB = 4.9 MiB rsyslogd
3.6 MiB + 1.8 MiB = 5.5 MiB sshd (3)
5.6 MiB + 431.0 KiB = 6.0 MiB polkitd
13.0 MiB + 546.5 KiB = 13.6 MiB tuned
22.5 MiB + 76.0 KiB = 22.6 MiB lfd - sleeping
30.0 MiB + 6.2 MiB = 36.2 MiB php-fpm (6)
5.7 MiB + 33.5 MiB = 39.2 MiB cwpsrv (3)
20.1 MiB + 25.3 MiB = 45.4 MiB httpd (5)
104.7 MiB + 156.0 KiB = 104.9 MiB named
112.2 MiB + 479.5 KiB = 112.7 MiB cache-main
69.4 MiB + 58.6 MiB = 128.0 MiB nginx (4)
203.4 MiB + 309.5 KiB = 203.7 MiB mysqld
---------------------------------
775.8 MiB
=================================
```
---
via: <https://www.2daygeek.com/linux-find-top-memory-consuming-processes/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[lnrCoder](https://github.com/lnrCoder) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
awk 入门 —— 强大的文本分析工具
|
Seth Kenlon
|
https://opensource.com/article/19/10/intro-awk
|
让我们开始使用它。
|
/data/attachment/album/201911/06/114421e006e9mbh0xxe8bb.jpg.thumb.jpg
|
/data/attachment/album/201911/06/114421e006e9mbh0xxe8bb.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"awk"
] |
技术
|
{
"viewnum": 8189,
"commentnum": 3,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "124.207.182.101",
"message": "awk '$3&gt;5 {print $1, $2}' colours.txt<br />\r\n应该为<br />\r\nawk '$3 gt 5 {print $1, $2}' colours.txt",
"username": "来自北京的 Chrome 78.0|Mac 10.15 用户",
"date": "2019-11-07T18:38:13"
},
{
"postip": "61.186.24.41",
"message": "谢谢！",
"username": "linux [Chrome 78.0|Mac 10.14]",
"date": "2019-11-08T20:34:11"
},
{
"postip": "218.75.145.85",
"message": "ZHAPING",
"username": "来自湖南常德的 Internet Explorer 11.0|Windows 7 用户",
"date": "2019-12-02T01:20:46"
}
] |
[
{
"raid": 11611,
"displayorder": 0
}
] |
让我们开始使用它。
| 2019-11-06T11:44:00 | 2019-11-06T11:44:00 | 11,543 |
/article-11543-1.html
|
>
> 让我们开始使用它。
>
>
>
`awk` 是用于 Unix 和类 Unix 系统的强大文本解析工具，但是由于它有可编程函数，因此你可以用它来执行常规解析任务，因此它也被视为一种编程语言。你可能不会使用 `awk` 开发下一个 GUI 应用，并且它可能不会代替你的默认脚本语言，但是它是用于特定任务的强大程序。
这些任务或许是惊人的多样化。了解 `awk` 可以解决你的哪些问题的最好方法是学习 `awk`。你会惊讶于 `awk` 如何帮助你完成更多工作，却花费更少的精力。
`awk` 的基本语法是：
```
awk [options] 'pattern {action}' file
```
首先，创建此示例文件并将其保存为 `colours.txt`。
```
name color amount
apple red 4
banana yellow 6
strawberry red 3
grape purple 10
apple green 8
plum purple 2
kiwi brown 4
potato brown 9
pineapple yellow 5
```
数据被一个或多个空格分隔为列。以某种方式组织要分析的数据是很常见的。它不一定总是由空格分隔的列，甚至可以不是逗号或分号，但尤其是在日志文件或数据转储中，通常有一个可预测的格式。你可以使用数据格式来帮助 `awk` 提取和处理你关注的数据。
### 打印列
在 `awk` 中，`print` 函数显示你指定的内容。你可以使用许多预定义的变量，但是最常见的是文本文件中以整数命名的列。试试看：
```
$ awk '{print $2;}' colours.txt
color
red
yellow
red
purple
green
purple
brown
brown
yellow
```
在这里，`awk` 显示第二列，用 `$2` 表示。这是相对直观的，因此你可能会猜测 `print $1` 显示第一列，而 `print $3` 显示第三列，依此类推。
要显示*全部*列，请使用 `$0`。
美元符号（`$`）后的数字是*表达式*，因此 `$2` 和 `$(1+1)` 是同一意思。
### 有条件地选择列
你使用的示例文件非常结构化。它有一行充当标题，并且各列直接相互关联。通过定义*条件*，你可以限定 `awk` 在找到此数据时返回的内容。例如，要查看第二列中与 `yellow` 匹配的项并打印第一列的内容：
```
awk '$2=="yellow"{print $1}' file1.txt
banana
pineapple
```
正则表达式也可以工作。此表达式近似匹配 `$2` 中以 `p` 开头跟上任意数量（一个或多个）字符后继续跟上 `p` 的值：
```
$ awk '$2 ~ /p.+p/ {print $0}' colours.txt
grape purple 10
plum purple 2
```
数字能被 `awk` 自然解释。例如，要打印第三列包含大于 5 的整数的行：
```
awk '$3>5 {print $1, $2}' colours.txt
name color
banana yellow
grape purple
apple green
potato brown
```
### 字段分隔符
默认情况下，`awk` 使用空格作为字段分隔符。但是，并非所有文本文件都使用空格来定义字段。例如，用以下内容创建一个名为 `colours.csv` 的文件：
```
name,color,amount
apple,red,4
banana,yellow,6
strawberry,red,3
grape,purple,10
apple,green,8
plum,purple,2
kiwi,brown,4
potato,brown,9
pineapple,yellow,5
```
只要你指定将哪个字符用作命令中的字段分隔符，`awk` 就能以完全相同的方式处理数据。使用 `--field-separator`（或简称为 `-F`）选项来定义分隔符：
```
$ awk -F"," '$2=="yellow" {print $1}' file1.csv
banana
pineapple
```
### 保存输出
使用输出重定向，你可以将结果写入文件。例如：
```
$ awk -F, '$3>5 {print $1, $2} colours.csv > output.txt
```
这将创建一个包含 `awk` 查询内容的文件。
你还可以将文件拆分为按列数据分组的多个文件。例如，如果要根据每行显示的颜色将 `colours.txt` 拆分为多个文件，你可以在 `awk` 中包含重定向语句来重定向*每条查询*：
```
$ awk '{print > $2".txt"}' colours.txt
```
这将生成名为 `yellow.txt`、`red.txt` 等文件。
在下一篇文章中，你将了解有关字段，记录和一些强大的 awk 变量的更多信息。
本文改编自社区技术播客 [Hacker Public Radio](http://hackerpublicradio.org/eps.php?id=2114)。
---
via: <https://opensource.com/article/19/10/intro-awk>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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 上用 strace 来理解系统调用
|
Gaurav Kamathe
|
https://opensource.com/article/19/10/strace
|
使用 strace 跟踪用户进程和 Linux 内核之间的交互。
|
/data/attachment/album/201911/06/131316xf9059emez99a829.jpg.thumb.jpg
|
/data/attachment/album/201911/06/131316xf9059emez99a829.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"strace"
] |
技术
|
{
"viewnum": 7419,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "1.192.90.183",
"message": "有用，赞",
"username": "来自河南郑州的 Firefox 74.0|GNU/Linux 用户",
"date": "2020-03-26T09:12:07"
},
{
"postip": "101.87.61.82",
"message": "非常详细，感谢！",
"username": "来自上海的 Safari 15.5|Mac 10.15 用户",
"date": "2022-07-24T21:24:34"
}
] |
[] |
使用 strace 跟踪用户进程和 Linux 内核之间的交互。
| 2019-11-06T13:13:45 | 2019-11-06T13:13:45 | 11,545 |
/article-11545-1.html
|
>
> 使用 strace 跟踪用户进程和 Linux 内核之间的交互。
>
>
>
<ruby> 系统调用 <rt> system call </rt></ruby>是程序从内核请求服务的一种编程方式，而 `strace` 是一个功能强大的工具，可让你跟踪用户进程与 Linux 内核之间的交互。
要了解操作系统的工作原理，首先需要了解系统调用的工作原理。操作系统的主要功能之一是为用户程序提供抽象机制。
操作系统可以大致分为两种模式：
* 内核模式：操作系统内核使用的一种强大的特权模式
* 用户模式：大多数用户应用程序运行的地方 用户大多使用命令行实用程序和图形用户界面（GUI）来执行日常任务。系统调用在后台静默运行，与内核交互以完成工作。
系统调用与函数调用非常相似，这意味着它们都接受并处理参数然后返回值。唯一的区别是系统调用进入内核，而函数调用不进入。从用户空间切换到内核空间是使用特殊的 [trap](https://en.wikipedia.org/wiki/Trap_(computing)) 机制完成的。
通过使用系统库（在 Linux 系统上又称为 glibc），大部分系统调用对用户隐藏了。尽管系统调用本质上是通用的，但是发出系统调用的机制在很大程度上取决于机器（架构）。
本文通过使用一些常规命令并使用 `strace` 分析每个命令进行的系统调用来探索一些实际示例。这些示例使用 Red Hat Enterprise Linux，但是这些命令运行在其他 Linux 发行版上应该也是相同的：
```
[root@sandbox ~]# cat /etc/redhat-release
Red Hat Enterprise Linux Server release 7.7 (Maipo)
[root@sandbox ~]#
[root@sandbox ~]# uname -r
3.10.0-1062.el7.x86_64
[root@sandbox ~]#
```
首先，确保在系统上安装了必需的工具。你可以使用下面的 `rpm` 命令来验证是否安装了 `strace`。如果安装了，则可以使用 `-V` 选项检查 `strace` 实用程序的版本号：
```
[root@sandbox ~]# rpm -qa | grep -i strace
strace-4.12-9.el7.x86_64
[root@sandbox ~]#
[root@sandbox ~]# strace -V
strace -- version 4.12
[root@sandbox ~]#
```
如果没有安装，运行命令安装：
```
yum install strace
```
出于本示例的目的，在 `/tmp` 中创建一个测试目录，并使用 `touch` 命令创建两个文件：
```
[root@sandbox ~]# cd /tmp/
[root@sandbox tmp]#
[root@sandbox tmp]# mkdir testdir
[root@sandbox tmp]#
[root@sandbox tmp]# touch testdir/file1
[root@sandbox tmp]# touch testdir/file2
[root@sandbox tmp]#
```
（我使用 `/tmp` 目录是因为每个人都可以访问它，但是你可以根据需要选择另一个目录。）
在 `testdir` 目录下使用 `ls` 命令验证该文件已经创建：
```
[root@sandbox tmp]# ls testdir/
file1 file2
[root@sandbox tmp]#
```
你可能每天都在使用 `ls` 命令，而没有意识到系统调用在其下面发挥的作用。抽象地来说，该命令的工作方式如下：
>
> 命令行工具 -> 从系统库（glibc）调用函数 -> 调用系统调用
>
>
>
`ls` 命令内部从 Linux 上的系统库（即 glibc）调用函数。这些库去调用完成大部分工作的系统调用。
如果你想知道从 glibc 库中调用了哪些函数，请使用 `ltrace` 命令，然后跟上常规的 `ls testdir/`命令：
```
ltrace ls testdir/
```
如果没有安装 `ltrace`，键入如下命令安装：
```
yum install ltrace
```
大量的输出会被堆到屏幕上；不必担心，只需继续就行。`ltrace` 命令输出中与该示例有关的一些重要库函数包括：
```
opendir("testdir/") = { 3 }
readdir({ 3 }) = { 101879119, "." }
readdir({ 3 }) = { 134, ".." }
readdir({ 3 }) = { 101879120, "file1" }
strlen("file1") = 5
memcpy(0x1665be0, "file1\0", 6) = 0x1665be0
readdir({ 3 }) = { 101879122, "file2" }
strlen("file2") = 5
memcpy(0x166dcb0, "file2\0", 6) = 0x166dcb0
readdir({ 3 }) = nil
closedir({ 3 })
```
通过查看上面的输出，你或许可以了解正在发生的事情。`opendir` 库函数打开一个名为 `testdir` 的目录，然后调用 `readdir` 函数，该函数读取目录的内容。最后，有一个对 `closedir` 函数的调用，该函数将关闭先前打开的目录。现在请先忽略其他 `strlen` 和 `memcpy` 功能。
你可以看到正在调用哪些库函数，但是本文将重点介绍由系统库函数调用的系统调用。
与上述类似，要了解调用了哪些系统调用，只需将 `strace` 放在 `ls testdir` 命令之前，如下所示。 再次，一堆乱码丢到了你的屏幕上，你可以按照以下步骤进行操作：
```
[root@sandbox tmp]# strace ls testdir/
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
brk(NULL) = 0x1f12000
<<< truncated strace output >>>
write(1, "file1 file2\n", 13file1 file2
) = 13
close(1) = 0
munmap(0x7fd002c8d000, 4096) = 0
close(2) = 0
exit_group(0) = ?
+++ exited with 0 +++
[root@sandbox tmp]#
```
运行 `strace` 命令后屏幕上的输出就是运行 `ls` 命令的系统调用。每个系统调用都为操作系统提供了特定的用途，可以将它们大致分为以下几个部分：
* 进程管理系统调用
* 文件管理系统调用
* 目录和文件系统管理系统调用
* 其他系统调用
分析显示到屏幕上的信息的一种更简单的方法是使用 `strace` 方便的 `-o` 标志将输出记录到文件中。在 `-o` 标志后添加一个合适的文件名，然后再次运行命令：
```
[root@sandbox tmp]# strace -o trace.log ls testdir/
file1 file2
[root@sandbox tmp]#
```
这次，没有任何输出干扰屏幕显示，`ls` 命令如预期般工作，显示了文件名并将所有输出记录到文件 `trace.log` 中。仅仅是一个简单的 `ls` 命令，该文件就有近 100 行内容：
```
[root@sandbox tmp]# ls -l trace.log
-rw-r--r--. 1 root root 7809 Oct 12 13:52 trace.log
[root@sandbox tmp]#
[root@sandbox tmp]# wc -l trace.log
114 trace.log
[root@sandbox tmp]#
```
让我们看一下这个示例的 `trace.log` 文件的第一行:
```
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
```
* 该行的第一个单词 `execve` 是正在执行的系统调用的名称。
* 括号内的文本是提供给该系统调用的参数。
* 符号 `=` 后的数字（在这种情况下为 `0`）是 `execve` 系统调用的返回值。
现在的输出似乎还不太吓人，对吧。你可以应用相同的逻辑来理解其他行。
现在，将关注点集中在你调用的单个命令上，即 `ls testdir`。你知道命令 `ls` 使用的目录名称，那么为什么不在 `trace.log` 文件中使用 `grep` 查找 `testdir` 并查看得到的结果呢？让我们详细查看一下结果的每一行：
```
[root@sandbox tmp]# grep testdir trace.log
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
stat("testdir/", {st_mode=S_IFDIR|0755, st_size=32, ...}) = 0
openat(AT_FDCWD, "testdir/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3
[root@sandbox tmp]#
```
回顾一下上面对 `execve` 的分析，你能说一下这个系统调用的作用吗？
```
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
```
你无需记住所有系统调用或它们所做的事情，因为你可以在需要时参考文档。手册页可以解救你！在运行 `man` 命令之前，请确保已安装以下软件包：
```
[root@sandbox tmp]# rpm -qa | grep -i man-pages
man-pages-3.53-5.el7.noarch
[root@sandbox tmp]#
```
请记住，你需要在 `man` 命令和系统调用名称之间添加 `2`。如果使用 `man man` 阅读 `man` 命令的手册页，你会看到第 2 节是为系统调用保留的。同样，如果你需要有关库函数的信息，则需要在 `man` 和库函数名称之间添加一个 `3`。
以下是手册的章节编号及其包含的页面类型：
* `1`：可执行的程序或 shell 命令
* `2`：系统调用（由内核提供的函数）
* `3`：库调用（在程序的库内的函数）
* `4`：特殊文件（通常出现在 `/dev`）
使用系统调用名称运行以下 `man` 命令以查看该系统调用的文档：
```
man 2 execve
```
按照 `execve` 手册页，这将执行在参数中传递的程序（在本例中为 `ls`）。可以为 `ls` 提供其他参数，例如本例中的 `testdir`。因此，此系统调用仅以 `testdir` 作为参数运行 `ls`：
```
execve - execute program
DESCRIPTION
execve() executes the program pointed to by filename
```
下一个系统调用，名为 `stat`，它使用 `testdir` 参数：
```
stat("testdir/", {st_mode=S_IFDIR|0755, st_size=32, ...}) = 0
```
使用 `man 2 stat` 访问该文档。`stat` 是获取文件状态的系统调用，请记住，Linux 中的一切都是文件，包括目录。
接下来，`openat` 系统调用将打开 `testdir`。密切注意返回的 `3`。这是一个文件描述符，将在以后的系统调用中使用：
```
openat(AT_FDCWD, "testdir/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3
```
到现在为止一切都挺好。现在，打开 `trace.log` 文件，并转到 `openat` 系统调用之后的行。你会看到 `getdents` 系统调用被调用，该调用完成了执行 `ls testdir` 命令所需的大部分操作。现在，从 `trace.log` 文件中用 `grep` 获取 `getdents`：
```
[root@sandbox tmp]# grep getdents trace.log
getdents(3, /* 4 entries */, 32768) = 112
getdents(3, /* 0 entries */, 32768) = 0
[root@sandbox tmp]#
```
`getdents` 的手册页将其描述为 “获取目录项”，这就是你要执行的操作。注意，`getdents` 的参数是 `3`，这是来自上面 `openat` 系统调用的文件描述符。
现在有了目录列表，你需要一种在终端中显示它的方法。因此，在日志中用 `grep` 搜索另一个用于写入终端的系统调用 `write`：
```
[root@sandbox tmp]# grep write trace.log
write(1, "file1 file2\n", 13) = 13
[root@sandbox tmp]#
```
在这些参数中，你可以看到将要显示的文件名：`file1` 和 `file2`。关于第一个参数（`1`），请记住在 Linux 中，当运行任何进程时，默认情况下会为其打开三个文件描述符。以下是默认的文件描述符：
* `0`：标准输入
* `1`：标准输出
* `2`：标准错误
因此，`write` 系统调用将在标准显示（就是这个终端，由 `1` 所标识的）上显示 `file1` 和 `file2`。
现在你知道哪个系统调用完成了 `ls testdir/` 命令的大部分工作。但是在 `trace.log` 文件中其它的 100 多个系统调用呢？操作系统必须做很多内务处理才能运行一个进程，因此，你在该日志文件中看到的很多内容都是进程初始化和清理。阅读整个 `trace.log` 文件，并尝试了解 `ls` 命令是怎么工作起来的。
既然你知道了如何分析给定命令的系统调用，那么就可以将该知识用于其他命令来了解正在执行哪些系统调用。`strace` 提供了许多有用的命令行标志，使你更容易使用，下面将对其中一些进行描述。
默认情况下，`strace` 并不包含所有系统调用信息。但是，它有一个方便的 `-v` 冗余选项，可以在每个系统调用中提供附加信息：
```
strace -v ls testdir
```
在运行 `strace` 命令时始终使用 `-f` 选项是一种好的作法。它允许 `strace` 对当前正在跟踪的进程创建的任何子进程进行跟踪：
```
strace -f ls testdir
```
假设你只需要系统调用的名称、运行的次数以及每个系统调用花费的时间百分比。你可以使用 `-c` 标志来获取这些统计信息：
```
strace -c ls testdir/
```
假设你想专注于特定的系统调用，例如专注于 `open` 系统调用，而忽略其余部分。你可以使用`-e` 标志跟上系统调用的名称：
```
[root@sandbox tmp]# strace -e open ls testdir
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libcap.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libacl.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libpcre.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libattr.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
open("/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
file1 file2
+++ exited with 0 +++
[root@sandbox tmp]#
```
如果你想关注多个系统调用怎么办？不用担心，你同样可以使用 `-e` 命令行标志，并用逗号分隔开两个系统调用的名称。例如，要查看 `write` 和 `getdents` 系统调用：
```
[root@sandbox tmp]# strace -e write,getdents ls testdir
getdents(3, /* 4 entries */, 32768) = 112
getdents(3, /* 0 entries */, 32768) = 0
write(1, "file1 file2\n", 13file1 file2
) = 13
+++ exited with 0 +++
[root@sandbox tmp]#
```
到目前为止，这些示例是明确地运行的命令进行了跟踪。但是，要跟踪已经运行并正在执行的命令又怎么办呢？例如，如果要跟踪用来长时间运行进程的守护程序，该怎么办？为此，`strace` 提供了一个特殊的 `-p` 标志，你可以向其提供进程 ID。
我们的示例不在守护程序上运行 `strace`，而是以 `cat` 命令为例，如果你将文件名作为参数，通常 `cat` 会显示文件的内容。如果没有给出参数，`cat` 命令会在终端上等待用户输入文本。输入文本后，它将重复给定的文本，直到用户按下 `Ctrl + C` 退出为止。
从一个终端运行 `cat` 命令；它会向你显示一个提示，并等待在那里（记住 `cat` 仍在运行且尚未退出）：
```
[root@sandbox tmp]# cat
```
在另一个终端上，使用 `ps` 命令找到进程标识符（PID）：
```
[root@sandbox ~]# ps -ef | grep cat
root 22443 20164 0 14:19 pts/0 00:00:00 cat
root 22482 20300 0 14:20 pts/1 00:00:00 grep --color=auto cat
[root@sandbox ~]#
```
现在，使用 `-p` 标志和 PID（在上面使用 `ps` 找到）对运行中的进程运行 `strace`。运行 `strace` 之后，其输出说明了所接驳的进程的内容及其 PID。现在，`strace` 正在跟踪 `cat` 命令进行的系统调用。看到的第一个系统调用是 `read`，它正在等待文件描述符 `0`（标准输入，这是运行 `cat` 命令的终端）的输入：
```
[root@sandbox ~]# strace -p 22443
strace: Process 22443 attached
read(0,
```
现在，返回到你运行 `cat` 命令的终端，并输入一些文本。我出于演示目的输入了 `x0x0`。注意 `cat` 是如何简单地重复我输入的内容的。因此，`x0x0` 出现了两次。我输入了第一个，第二个是 `cat` 命令重复的输出：
```
[root@sandbox tmp]# cat
x0x0
x0x0
```
返回到将 `strace` 接驳到 `cat` 进程的终端。现在你会看到两个额外的系统调用：较早的 `read` 系统调用，现在在终端中读取 `x0x0`，另一个为 `write`，它将 `x0x0` 写回到终端，然后是再一个新的 `read`，正在等待从终端读取。请注意，标准输入（`0`）和标准输出（`1`）都在同一终端中：
```
[root@sandbox ~]# strace -p 22443
strace: Process 22443 attached
read(0, "x0x0\n", 65536) = 5
write(1, "x0x0\n", 5) = 5
read(0,
```
想象一下，对守护进程运行 `strace` 以查看其在后台执行的所有操作时这有多大帮助。按下 `Ctrl + C` 杀死 `cat` 命令；由于该进程不再运行，因此这也会终止你的 `strace` 会话。
如果要查看所有的系统调用的时间戳，只需将 `-t` 选项与 `strace` 一起使用：
```
[root@sandbox ~]#strace -t ls testdir/
14:24:47 execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
14:24:47 brk(NULL) = 0x1f07000
14:24:47 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f2530bc8000
14:24:47 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
14:24:47 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
```
如果你想知道两次系统调用之间所花费的时间怎么办？`strace` 有一个方便的 `-r` 命令，该命令显示执行每个系统调用所花费的时间。非常有用，不是吗？
```
[root@sandbox ~]#strace -r ls testdir/
0.000000 execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
0.000368 brk(NULL) = 0x1966000
0.000073 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fb6b1155000
0.000047 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
0.000119 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
```
### 总结
`strace` 实用程序非常有助于理解 Linux 上的系统调用。要了解它的其它命令行标志，请参考手册页和在线文档。
---
via: <https://opensource.com/article/19/10/strace>
作者：[Gaurav Kamathe](https://opensource.com/users/gkamathe) 选题：[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/) 荣誉推出
|
用 Jenkins 构建 CI/CD 流水线
|
Bryant Son
|
https://opensource.com/article/19/9/intro-building-cicd-pipelines-jenkins
|
通过这份 Jenkins 分步教程，构建持续集成和持续交付（CI/CD）流水线。
|
/data/attachment/album/201911/07/001349rbbbswpeqnnteeee.jpg.thumb.jpg
|
/data/attachment/album/201911/07/001349rbbbswpeqnnteeee.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Jenkins"
] |
系统运维
|
{
"viewnum": 12120,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9741,
"displayorder": 0
},
{
"raid": 11307,
"displayorder": 1
}
] |
通过这份 Jenkins 分步教程，构建持续集成和持续交付（CI/CD）流水线。
| 2019-11-07T00:07:00 | 2019-11-07T00:07:00 | 11,546 |
/article-11546-1.html
|
>
> 通过这份 Jenkins 分步教程，构建持续集成和持续交付（CI/CD）流水线。
>
>
>
在我的文章《[使用开源工具构建 DevOps 流水线的初学者指南](/article-11307-1.html)》中，我分享了一个从头开始构建 DevOps 流水线的故事。推动该计划的核心技术是 [Jenkins](https://jenkins.io/)，这是一个用于建立持续集成和持续交付（CI/CD）流水线的开源工具。
在花旗，有一个单独的团队为专用的 Jenkins 流水线提供稳定的主从节点环境，但是该环境仅用于质量保证（QA）、构建阶段和生产环境。开发环境仍然是非常手动的，我们的团队需要对其进行自动化以在加快开发工作的同时获得尽可能多的灵活性。这就是我们决定为 DevOps 建立 CI/CD 流水线的原因。Jenkins 的开源版本由于其灵活性、开放性、强大的插件功能和易用性而成为显而易见的选择。
在本文中，我将分步演示如何使用 Jenkins 构建 CI/CD 流水线。
### 什么是流水线？
在进入本教程之前，了解有关 CI/CD <ruby> 流水线 <rt> pipeline </rt></ruby>的知识会很有帮助。
首先，了解 Jenkins 本身并不是流水线这一点很有帮助。只是创建一个新的 Jenkins 作业并不能构建一条流水线。可以把 Jenkins 看做一个遥控器，在这里点击按钮即可。当你点击按钮时会发生什么取决于遥控器要控制的内容。Jenkins 为其他应用程序 API、软件库、构建工具等提供了一种插入 Jenkins 的方法，它可以执行并自动化任务。Jenkins 本身不执行任何功能，但是随着其它工具的插入而变得越来越强大。
流水线是一个单独的概念，指的是按顺序连接在一起的事件或作业组：
>
> “<ruby> 流水线 <rt> pipeline </rt></ruby>”是可以执行的一系列事件或作业。
>
>
>
理解流水线的最简单方法是可视化一系列阶段，如下所示：
在这里，你应该看到两个熟悉的概念：<ruby> 阶段 <rt> Stage </rt></ruby>和<ruby> 步骤 <rt> Step </rt></ruby>。
* 阶段：一个包含一系列步骤的块。阶段块可以命名为任何名称；它用于可视化流水线过程。
* 步骤：表明要做什么的任务。步骤定义在阶段块内。
在上面的示例图中，阶段 1 可以命名为 “构建”、“收集信息”或其它名称，其它阶段块也可以采用类似的思路。“步骤”只是简单地说放上要执行的内容，它可以是简单的打印命令（例如，`echo "Hello, World"`）、程序执行命令（例如，`java HelloWorld`）、shell 执行命令（ 例如，`chmod 755 Hello`）或任何其他命令，只要通过 Jenkins 环境将其识别为可执行命令即可。
Jenkins 流水线以**编码脚本**的形式提供，通常称为 “Jenkinsfile”，尽管可以用不同的文件名。下面这是一个简单的 Jenkins 流水线文件的示例：
```
// Example of Jenkins pipeline script
pipeline {
stages {
stage("Build") {
steps {
// Just print a Hello, Pipeline to the console
echo "Hello, Pipeline!"
// Compile a Java file. This requires JDKconfiguration from Jenkins
javac HelloWorld.java
// Execute the compiled Java binary called HelloWorld. This requires JDK configuration from Jenkins
java HelloWorld
// Executes the Apache Maven commands, clean then package. This requires Apache Maven configuration from Jenkins
mvn clean package ./HelloPackage
// List the files in current directory path by executing a default shell command
sh "ls -ltr"
}
}
// And next stages if you want to define further...
} // End of stages
} // End of pipeline
```
从此示例脚本很容易看到 Jenkins 流水线的结构。请注意，默认情况下某些命令（如 `java`、`javac`和 `mvn`）不可用，需要通过 Jenkins 进行安装和配置。 因此：
>
> Jenkins 流水线是一种以定义的方式依次执行 Jenkins 作业的方法，方法是将其编码并在多个块中进行结构化，这些块可以包含多个任务的步骤。
>
>
>
好。既然你已经了解了 Jenkins 流水线是什么，我将向你展示如何创建和执行 Jenkins 流水线。在本教程的最后，你将建立一个 Jenkins 流水线，如下所示：
### 如何构建 Jenkins 流水线
为了便于遵循本教程的步骤，我创建了一个示例 [GitHub 存储库](https://github.com/bryantson/CICDPractice)和一个视频教程。
开始本教程之前，你需要：
* Java 开发工具包（JDK）：如果尚未安装，请安装 JDK 并将其添加到环境路径中，以便可以通过终端执行 Java 命令（如 `java jar`）。这是利用本教程中使用的 Java Web Archive（WAR）版本的 Jenkins 所必需的（尽管你可以使用任何其他发行版）。
* 基本计算机操作能力：你应该知道如何键入一些代码、通过 shell 执行基本的 Linux 命令以及打开浏览器。
让我们开始吧。
#### 步骤一：下载 Jenkins
导航到 [Jenkins 下载页面](https://jenkins.io/download/)。向下滚动到 “Generic Java package (.war)”，然后单击下载文件；将其保存在易于找到的位置。（如果你选择其他 Jenkins 发行版，除了步骤二之外，本教程的其余步骤应该几乎相同。）使用 WAR 文件的原因是它是个一次性可执行文件，可以轻松地执行和删除。
#### 步骤二：以 Java 二进制方式执行 Jenkins
打开一个终端窗口，并使用 `cd <your path>` 进入下载 Jenkins 的目录。（在继续之前，请确保已安装 JDK 并将其添加到环境路径。）执行以下命令，该命令将 WAR 文件作为可执行二进制文件运行：
```
java -jar ./jenkins.war
```
如果一切顺利，Jenkins 应该在默认端口 8080 上启动并运行。
#### 步骤三：创建一个新的 Jenkins 作业
打开一个 Web 浏览器并导航到 `localhost:8080`。除非你有以前安装的 Jenkins，否则应直接转到 Jenkins 仪表板。点击 “Create New Jobs”。你也可以点击左侧的 “New Item”。
#### 步骤四：创建一个流水线作业
在此步骤中，你可以选择并定义要创建的 Jenkins 作业类型。选择 “Pipeline” 并为其命名（例如，“TestPipeline”）。单击 “OK” 创建流水线作业。
你将看到一个 Jenkins 作业配置页面。向下滚动以找到 “Pipeline” 部分。有两种执行 Jenkins 流水线的方法。一种方法是在 Jenkins 上直接编写流水线脚本，另一种方法是从 SCM（源代码管理）中检索 Jenkins 文件。在接下来的两个步骤中，我们将体验这两种方式。
#### 步骤五：通过直接脚本配置并执行流水线作业
要使用直接脚本执行流水线，请首先从 GitHub 复制该 [Jenkinsfile 示例](https://github.com/bryantson/CICDPractice)的内容。选择 “Pipeline script” 作为 “Destination”，然后将该 Jenkinsfile 的内容粘贴到 “Script” 中。花一些时间研究一下 Jenkins 文件的结构。注意，共有三个阶段：Build、Test 和 Deploy，它们是任意的，可以是任何一个。每个阶段中都有一些步骤；在此示例中，它们只是打印一些随机消息。
单击 “Save” 以保留更改，这将自动将你带回到 “Job Overview” 页面。
要开始构建流水线的过程，请单击 “Build Now”。如果一切正常，你将看到第一个流水线（如下面的这个）。
要查看流水线脚本构建的输出，请单击任何阶段，然后单击 “Log”。你会看到这样的消息。
#### 步骤六：通过 SCM 配置并执行流水线作业
现在，换个方式：在此步骤中，你将通过从源代码控制的 GitHub 中复制 Jenkinsfile 来部署相同的 Jenkins 作业。在同一个 [GitHub 存储库](https://github.com/bryantson/CICDPractice)中，通过单击 “Clone or download” 并复制其 URL 来找到其存储库 URL。
单击 “Configure” 以修改现有作业。滚动到 “Advanced Project Options” 设置，但这一次，从 “Destination” 下拉列表中选择 “Pipeline script from SCM” 选项。将 GitHub 存储库的 URL 粘贴到 “Repository URL” 中，然后在 “Script Path” 中键入 “Jenkinsfile”。 单击 “Save” 按钮保存。
要构建流水线，回到 “Task Overview” 页面后，单击 “Build Now” 以再次执行作业。结果与之前相同，除了多了一个称为 “Declaration: Checkout SCM” 的阶段。
要查看来自 SCM 构建的流水线的输出，请单击该阶段并查看 “Log” 以检查源代码控制克隆过程的进行情况。
### 除了打印消息，还能做更多
恭喜你！你已经建立了第一个 Jenkins 流水线！
“但是等等”，你说，“这太有限了。除了打印无用的消息外，我什么都做不了。”那没问题。到目前为止，本教程仅简要介绍了 Jenkins 流水线可以做什么，但是你可以通过将其与其他工具集成来扩展其功能。以下是给你的下一个项目的一些思路：
* 建立一个多阶段的 Java 构建流水线，从以下阶段开始：从 Nexus 或 Artifactory 之类的 JAR 存储库中拉取依赖项、编译 Java 代码、运行单元测试、打包为 JAR/WAR 文件，然后部署到云服务器。
* 实现一个高级代码测试仪表板，该仪表板将基于 Selenium 的单元测试、负载测试和自动用户界面测试，报告项目的运行状况。
* 构建多流水线或多用户流水线，以自动化执行 Ansible 剧本的任务，同时允许授权用户响应正在进行的任务。
* 设计完整的端到端 DevOps 流水线，该流水线可提取存储在 SCM 中的基础设施资源文件和配置文件（例如 GitHub），并通过各种运行时程序执行该脚本。
学习本文结尾处的任何教程，以了解这些更高级的案例。
#### 管理 Jenkins
在 Jenkins 主面板，点击 “Manage Jenkins”。
#### 全局工具配置
有许多可用工具，包括管理插件、查看系统日志等。单击 “Global Tool Configuration”。
#### 增加附加能力
在这里，你可以添加 JDK 路径、Git、Gradle 等。配置工具后，只需将该命令添加到 Jenkinsfile 中或通过 Jenkins 脚本执行即可。
### 后继
本文为你介绍了使用酷炫的开源工具 Jenkins 创建 CI/CD 流水线的方法。要了解你可以使用 Jenkins 完成的许多其他操作，请在 Opensource.com 上查看以下其他文章：
* [Jenkins X 入门](https://opensource.com/article/18/11/getting-started-jenkins-x)
* [使用 Jenkins 安装 OpenStack 云](https://opensource.com/article/18/4/install-OpenStack-cloud-Jenkins)
* [在容器中运行 Jenkins](/article-9741-1.html)
* [Jenkins 流水线入门](https://opensource.com/article/18/4/jenkins-pipelines-with-cucumber)
* [如何与 Jenkins 一起运行 JMeter](https://opensource.com/life/16/7/running-jmeter-jenkins-continuous-delivery-101)
* [将 OpenStack 集成到你的 Jenkins 工作流中](https://opensource.com/business/15/5/interview-maish-saidel-keesing-cisco)
你可能对我为你的开源之旅而写的其他一些文章感兴趣：
* [9 个用于构建容错系统的开源工具](https://opensource.com/article/19/3/tools-fault-tolerant-system)
* [了解软件设计模式](https://opensource.com/article/19/7/understanding-software-design-patterns)
* [使用开源工具构建 DevOps 流水线的初学者指南](/article-11307-1.html)
---
via: <https://opensource.com/article/19/9/intro-building-cicd-pipelines-jenkins>
作者：[Bryant Son](https://opensource.com/users/brson) 选题：[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/) 荣誉推出
|
用 bmon 查看网络带宽使用情况
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3447936/viewing-network-bandwidth-usage-with-bmon.html
|
介绍一下 bmon，这是一个监视和调试工具，可捕获网络统计信息并使它们易于理解。
|
/data/attachment/album/201911/07/010237a8gb5oqddvl3bnd0.jpg.thumb.jpg
|
/data/attachment/album/201911/07/010237a8gb5oqddvl3bnd0.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"bmon"
] |
分享
|
{
"viewnum": 9635,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
介绍一下 bmon，这是一个监视和调试工具，可捕获网络统计信息并使它们易于理解。
| 2019-11-07T01:03:00 | 2019-11-07T01:03:00 | 11,547 |
/article-11547-1.html
|
>
> 介绍一下 bmon，这是一个监视和调试工具，可捕获网络统计信息并使它们易于理解。
>
>
>
`bmon` 是一种监视和调试工具，可在终端窗口中捕获网络统计信息，并提供了如何以易于理解的形式显示以及显示多少数据的选项。
要检查系统上是否安装了 `bmon`，请使用 `which` 命令：
```
$ which bmon
/usr/bin/bmon
```
### 获取 bmon
在 Debian 系统上，使用 `sudo apt-get install bmon` 安装该工具。
对于 Red Hat 和相关发行版，你可以使用 `yum install bmon` 或 `sudo dnf install bmon` 进行安装。或者，你可能必须使用更复杂的安装方式，例如使用以下命令，这些命令首先使用 root 帐户或 sudo 来设置所需的 `libconfuse`：
```
# wget https://github.com/martinh/libconfuse/releases/download/v3.2.2/confuse-3.2.2.zip
# unzip confuse-3.2.2.zip && cd confuse-3.2.2
# sudo PATH=/usr/local/opt/gettext/bin:$PATH ./configure
# make
# make install
# git clone https://github.com/tgraf/bmon.git &&ammp; cd bmon
# ./autogen.sh
# ./configure
# make
# sudo make install
```
前面五行会安装 `libconfuse`，而后面五行会获取并安装 `bmon` 本身。
### 使用 bmon
启动 `bmon` 的最简单方法是在命令行中键入 `bmon`。根据你正在使用的窗口的大小，你能够查看并显示各种数据。
显示区域的顶部将显示你的网络接口的统计信息：环回接口（lo）和可通过网络访问的接口（例如 eth0）。如果你的终端窗口只有区区几行高，下面这就是你可能会看到的所有内容，它将看起来像这样：
```
lo bmon 4.0
Interfaces x RX bps pps %x TX bps pps %
>lo x 4B0 x0 0 0 4B 0
qdisc none (noqueue) x 0 0 x 0 0
enp0s25 x 244B0 x1 0 0 470B 2
qdisc none (fq_codel) x 0 0 x 0 0 462B 2
q Increase screen height to see graphical statistics qq
q Press d to enable detailed statistics qq
q Press i to enable additional information qq
Wed Oct 23 14:36:27 2019 Press ? for help
```
在此示例中，网络接口是 enp0s25。请注意列出的接口下方的有用的 “Increase screen height” 提示。拉伸屏幕以增加足够的行（无需重新启动 bmon），你将看到一些图形：
```
Interfaces x RX bps pps %x TX bps pps %
>lo x 0 0 x 0 0
qdisc none (noqueue) x 0 0 x 0 0
enp0s25 x 253B 3 x 2.65KiB 6
qdisc none (fq_codel) x 0 0 x 2.62KiB 6
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
(RX Bytes/second)
0.00 ............................................................
0.00 ............................................................
0.00 ............................................................
0.00 ............................................................
0.00 ............................................................
0.00 ............................................................
1 5 10 15 20 25 30 35 40 45 50 55 60
(TX Bytes/second)
0.00 ............................................................
0.00 ............................................................
0.00 ............................................................
0.00 ............................................................
0.00 ............................................................
0.00 ............................................................
1 5 10 15 20 25 30 35 40 45 50 55 60
```
但是请注意，该图形未显示值。这是因为它正在显示环回 “>lo” 接口。按下箭头键指向公共网络接口，你将看到一些流量。
```
Interfaces x RX bps pps %x TX bps pps %
lo x 0 0 x 0 0
qdisc none (noqueue) x 0 0 x 0 0
>enp0s25 x 151B 2 x 1.61KiB 3
qdisc none (fq_codel) x 0 0 x 1.60KiB 3
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
B (RX Bytes/second)
635.00 ...............................|............................
529.17 .....|.........................|....|.......................
423.33 .....|................|..|..|..|..|.|.......................
317.50 .|..||.|..||.|..|..|..|..|..|..||.||||......................
211.67 .|..||.|..||.|..||||.||.|||.||||||||||......................
105.83 ||||||||||||||||||||||||||||||||||||||......................
1 5 10 15 20 25 30 35 40 45 50 55 60
KiB (TX Bytes/second)
4.59 .....................................|......................
3.83 .....................................|......................
3.06 ....................................||......................
2.30 ....................................||......................
1.53 |||..............|..|||.|...|.|||.||||......................
0.77 ||||||||||||||||||||||||||||||||||||||......................
1 5 10 15 20 25 30 35 40 45 50 55 60
q Press d to enable detailed statistics qq
q Press i to enable additional information qq
Wed Oct 23 16:42:06 2019 Press ? for help
```
通过更改接口，你可以查看显示了网络流量的图表。但是请注意，默认值是按每秒字节数显示的。要按每秒位数来显示，你可以使用 `bmon -b` 启动该工具。
如果你的窗口足够大并按下 `d` 键，则可以显示有关网络流量的详细统计信息。你看到的统计信息示例如下所示。由于其宽度太宽，该显示分为左右两部分。
左侧：
```
RX TX │ RX TX │
Bytes 11.26MiB 11.26MiB│ Packets 25.91K 25.91K │
Collisions - 0 │ Compressed 0 0 │
Errors 0 0 │ FIFO Error 0 0 │
ICMPv6 2 2 │ ICMPv6 Checksu 0 - │
Ip6 Broadcast 0 0 │ Ip6 Broadcast 0 0 │
Ip6 Delivers 8 - │ Ip6 ECT(0) Pac 0 - │
Ip6 Header Err 0 - │ Ip6 Multicast 0 152B │
Ip6 Non-ECT Pa 8 - │ Ip6 Reasm/Frag 0 0 │
Ip6 Reassembly 0 - │ Ip6 Too Big Er 0 - │
Ip6Discards 0 0 │ Ip6Octets 530B 530B │
Missed Error 0 - │ Multicast - 0 │
Window Error - 0 │ │
```
右侧：
```
│ RX TX │ RX TX
│ Abort Error - 0 │ Carrier Error - 0
│ CRC Error 0 - │ Dropped 0 0
│ Frame Error 0 - │ Heartbeat Erro -
│ ICMPv6 Errors 0 0 │ Ip6 Address Er 0 -
│ Ip6 CE Packets 0 - │ Ip6 Checksum E 0 -
│ Ip6 ECT(1) Pac 0 - │ Ip6 Forwarded - 0
│ Ip6 Multicast 0 2 │ Ip6 No Route 0 0
│ Ip6 Reasm/Frag 0 0 │ Ip6 Reasm/Frag 0 0
│ Ip6 Truncated 0 - │ Ip6 Unknown Pr 0 -
│ Ip6Pkts 8 8 │ Length Error 0
│ No Handler 0 - │ Over Error 0 -
```
如果按下 `i` 键，将显示网络接口上的其他信息。
左侧：
```
MTU 1500 | Flags broadcast,multicast,up |
Address 00:1d:09:77:9d:08 | Broadcast ff:ff:ff:ff:ff:ff |
Family unspec | Alias |
```
右侧：
```
| Operstate up | IfIndex 2 |
| Mode default | TXQlen 1000 |
| Qdisc fq_codel |
```
如果你按下 `?` 键，将会出现一个帮助菜单，其中简要介绍了如何在屏幕上移动光标、选择要显示的数据以及控制图形如何显示。
要退出 `bmon`，输入 `q`，然后输入 `y` 以响应提示来确认退出。
需要注意的一些重要事项是：
* `bmon` 会将其显示调整为终端窗口的大小
* 显示区域底部显示的某些选项仅在窗口足够大可以容纳数据时才起作用
* 除非你使用 `-R`（例如 `bmon -R 5`）来减慢显示速度，否则每秒更新一次显示
---
via: <https://www.networkworld.com/article/3447936/viewing-network-bandwidth-usage-with-bmon.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[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 中加速工作的键盘快捷键
|
S Sathyanarayanan
|
https://opensourceforu.com/2019/11/keyboard-shortcuts-to-speed-up-your-work-in-linux/
|
学习键盘快捷键将使生产率提高 3.3％
|
/data/attachment/album/201911/08/075723x7pf4kuu5x7cxbbb.jpg.thumb.jpg
|
/data/attachment/album/201911/08/075723x7pf4kuu5x7cxbbb.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"快捷键"
] |
技术
|
{
"viewnum": 5126,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "202.114.122.193",
"message": "这计算略简单了，省下来的时间全去折腾显卡了",
"username": "来自湖北武汉武汉大学测绘学院的 Firefox 70.0|Ubuntu 用户",
"date": "2019-11-08T15:04:19"
}
] |
[] |
学习键盘快捷键将使生产率提高 3.3％
| 2019-11-08T07:57:00 | 2019-11-08T07:57:00 | 11,549 |
/article-11549-1.html
|
>
> 操作鼠标、键盘和菜单会占用我们很多时间，这些可以使用键盘快捷键来节省时间。这不仅节省时间，还可以使用户更高效。
>
>
>
你是否意识到每次在打字时从键盘切换到鼠标需要多达两秒钟？如果一个人每天工作八小时，每分钟从键盘切换到鼠标一次，并且一年中大约有 240 个工作日，那么所浪费的时间（根据 Brainscape 的计算）为： [每分钟浪费 2 秒] x [每天 480 分钟] x 每年 240 个工作日 = 每年浪费 64 小时 这相当于损失了八个工作日，因此学习键盘快捷键将使生产率提高 3.3％（<https://www.brainscape.com/blog/2011/08/keyboard-shortcuts-economy/>）。
键盘快捷键提供了一种更快的方式来执行任务，不然就需要使用鼠标和/或菜单分多个步骤来完成。图 1 列出了 Ubuntu 18.04 Linux 和 Web 浏览器中一些最常用的快捷方式。我省略了非常有名的快捷方式，例如复制、粘贴等，以及不经常使用的快捷方式。读者可以参考在线资源以获得完整的快捷方式列表。请注意，Windows 键在 Linux 中被重命名为 Super 键。
### 常规快捷方式
下面列出了常规快捷方式。
### 打印屏幕和屏幕录像
以下快捷方式可用于打印屏幕或录制屏幕视频。
### 在应用之间切换
此处列出的快捷键可用于在应用之间切换。
### 平铺窗口
可以使用下面提供的快捷方式以不同方式将窗口平铺。
### 浏览器快捷方式
此处列出了浏览器最常用的快捷方式。大多数快捷键对于 Chrome/Firefox 浏览器是通用的。
| **组合键** | **行为** |
| --- | --- |
| `Ctrl + T` | 打开一个新标签。 |
| `Ctrl + Shift + T` | 打开最近关闭的标签。 |
| `Ctrl + D` | 添加一个新书签。 |
| `Ctrl + W` | 关闭浏览器标签。 |
| `Alt + D` | 将光标置于浏览器的地址栏中。 |
| `F5 或 Ctrl-R` | 刷新页面。 |
| `Ctrl + Shift + Del` | 清除私人数据和历史记录。 |
| `Ctrl + N` | 打开一个新窗口。 |
| `Home` | 滚动到页面顶部。 |
| `End` | 滚动到页面底部。 |
| `Ctrl + J` | 打开下载文件夹（在 Chrome 中） |
| `F11` | 全屏视图（切换效果） |
### 终端快捷方式
这是终端快捷方式的列表。
你还可以在 Ubuntu 中配置自己的自定义快捷方式，如下所示：
* 在 Ubuntu Dash 中单击设置。
* 在“设置”窗口的左侧菜单中选择“设备”选项卡。
* 在设备菜单中选择键盘标签。
* 右面板的底部有个 “+” 按钮。点击 “+” 号打开自定义快捷方式对话框并配置新的快捷方式。
学习本文提到的三个快捷方式可以节省大量时间，并使你的工作效率更高。
### 引用
[Cohen, Andrew. How keyboard shortcuts could revive America’s economy; www.brainscape.com. [Online] Brainscape, 26 May 2017;](https://www.brainscape.com/blog/2011/08/keyboard-shortcuts-economy/)
---
via: <https://opensourceforu.com/2019/11/keyboard-shortcuts-to-speed-up-your-work-in-linux/>
作者：[S Sathyanarayanan](https://opensourceforu.com/author/s-sathyanarayanan/) 选题：[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/) 荣誉推出
|
初级：如何更新 Fedora Linux 系统
|
Ankush Das
|
https://itsfoss.com/update-fedora/
|
本快速教程介绍了更新 Fedora Linux 安装的多种方法。
|
/data/attachment/album/201911/08/082740ffftm1j09teedxjl.jpg.thumb.jpg
|
/data/attachment/album/201911/08/082740ffftm1j09teedxjl.jpg
| true | false | true |
lujun9972
|
Morisun029
|
wxy
| false |
[
"Fedora"
] |
技术
|
{
"viewnum": 7002,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "114.92.29.72",
"message": "文章的营养有点……<br />\r\n还是谢谢编辑",
"username": "来自上海的 Chrome 78.0|Mac 10.15 用户",
"date": "2019-11-08T17:29:29"
}
] |
[] |
本快速教程介绍了更新 Fedora Linux 安装的多种方法。
| 2019-11-08T08:27:50 | 2019-11-08T08:27:50 | 11,550 |
/article-11550-1.html
|
>
> 本快速教程介绍了更新 Fedora Linux 安装的多种方法。
>
>
>
前几天，我安装了[新发布的 Fedora 31](https://itsfoss.com/fedora-31-release/)。老实说，这是我第一次使用[非 Ubuntu 发行版](https://itsfoss.com/non-ubuntu-beginner-linux/)。
安装 Fedora 之后，我做的第一件事就是尝试安装一些软件。我打开软件中心，发现该软件中心已“损坏”。 我无法从中安装任何应用程序。
我不确定我的系统出了什么问题。在团队内部讨论时，Abhishek 建议我先更新系统。我更新了，更新后一切恢复正常。更新 [Fedora](https://getfedora.org/) 系统后，软件中心也能正常工作了。
有时我们一直尝试解决我们所面临的问题，而忽略了对系统的更新。不管问题有多大或多小，为了避免它们，你都应该保持系统更新。
在本文中，我将向你展示更新 Fedora Linux 系统的多种方法。
* 使用软件中心更新 Fedora
* 使用命令行更新 Fedora
* 从系统设置更新 Fedora
请记住，更新 Fedora 意味着安装安全补丁、更新内核和软件。如果要从 Fedora 的一个版本更新到另一个版本，这称为版本升级，你可以[在此处阅读有关 Fedora 版本升级过程的信息](https://itsfoss.com/upgrade-fedora-version/)。
### 从软件中心更新 Fedora
你很可能会收到通知，通知你有一些系统更新需要查看，你应该在单击该通知时启动软件中心。
你所要做的就是 —— 点击“更新”，并验证 root 密码开始更新。
如果你没有收到更新的通知，则只需启动软件中心并转到“更新”选项卡即可。现在，你只需要继续更新。
### 使用终端更新 Fedora
如果由于某种原因无法加载软件中心，则可以使用 `dnf` 软件包管理命令轻松地更新系统。
只需启动终端并输入以下命令即可开始更新（系统将提示你确认 root 密码）：
```
sudo dnf upgrade
```
>
> \*\*dnf 更新 vs dnf 升级 \*\*
>
>
> 你会发现有两个可用的 dnf 命令：`dnf update` 和 `dnf upgrade`。这两个命令执行相同的工作，即安装 Fedora 提供的所有更新。那么，为什么要会有这两个呢，你应该使用哪一个？`dnf update` 基本上是 `dnf upgrade` 的别名。尽管 `dnf update` 可能仍然有效，但最好使用 `dnf upgrade`，因为这是真正的命令。
>
>
>
### 从系统设置中更新 Fedora
如果其它方法都不行（或者由于某种原因已经进入“系统设置”），请导航至“设置”底部的“详细信息”选项。
如上图所示，该选项中显示操作系统和硬件的详细信息以及一个“检查更新”按钮。你只需要单击它并提供 root 密码即可继续安装可用的更新。
### 总结
如上所述，更新 Fedora 系统非常容易。有三种方法供你选择，因此无需担心。
如果你按上述说明操作时发现任何问题，请随时在下面的评论部分告诉我。
---
via: <https://itsfoss.com/update-fedora/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Morisun029](https://github.com/Morisun029) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
怎样用 Bash 编程：语法和工具
|
David Both
|
https://opensource.com/article/19/10/programming-bash-part-1
|
让我们通过本系列文章来学习基本的 Bash 编程语法和工具，以及如何使用变量和控制运算符，这是三篇中的第一篇。
|
/data/attachment/album/201911/08/092559r5wdg0w97dtf350j.jpg.thumb.jpg
|
/data/attachment/album/201911/08/092559r5wdg0w97dtf350j.jpg
| true | false | true |
lujun9972
|
jdh8383
|
wxy
| false |
[
"bash",
"shell"
] |
软件开发
|
{
"viewnum": 10816,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11687,
"displayorder": 0
}
] |
让我们通过本系列文章来学习基本的 Bash 编程语法和工具，以及如何使用变量和控制运算符，这是三篇中的第一篇。
| 2019-11-08T09:26:00 | 2019-11-08T09:26:00 | 11,552 |
/article-11552-1.html
|
>
> 让我们通过本系列文章来学习基本的 Bash 编程语法和工具，以及如何使用变量和控制运算符，这是三篇中的第一篇。
>
>
>
Shell 是操作系统的命令解释器，其中 Bash 是我最喜欢的。每当用户或者系统管理员将命令输入系统的时候，Linux 的 shell 解释器就会把这些命令转换成操作系统可以理解的形式。而执行结果返回 shell 程序后，它会将结果输出到 STDOUT（标准输出），默认情况下，这些结果会[显示在你的终端](https://opensource.com/article/18/10/linux-data-streams)。所有我熟悉的 shell 同时也是一门编程语言。
Bash 是个功能强大的 shell，包含众多便捷特性，比如：tab 补全、命令回溯和再编辑、别名等。它的命令行默认编辑模式是 Emacs，但是我最喜欢的 Bash 特性之一是我可以将其更改为 Vi 模式，以使用那些储存在我肌肉记忆中的的编辑命令。
然而，如果你把 Bash 当作单纯的 shell 来用，则无法体验它的真实能力。我在设计一套包含三卷的 [Linux 自学课程](http://www.both.org/?page_id=1183)时（这个系列的文章正是基于此课程），了解到许多 Bash 的知识，这些是我在过去 20 年的 Linux 工作经验中所没有掌握的，其中的一些知识就是关于 Bash 的编程用法。不得不说，Bash 是一门强大的编程语言，是一个能够同时用于命令行和 shell 脚本的完美设计。
本系列文章将要探讨如何使用 Bash 作为命令行界面（CLI）编程语言。第一篇文章简单介绍 Bash 命令行编程、变量以及控制运算符。其他文章会讨论诸如：Bash 文件的类型；字符串、数字和一些逻辑运算符，它们能够提供代码执行流程中的逻辑控制；不同类型的 shell 扩展；通过 `for`、`while` 和 `until` 来控制循环操作。
### Shell
Bash 是 Bourne Again Shell 的缩写，因为 Bash shell 是 [基于](https://opensource.com/19/9/command-line-heroes-bash) 更早的 Bourne shell，后者是 Steven Bourne 在 1977 年开发的。另外还有很多[其他的 shell](https://en.wikipedia.org/wiki/Comparison_of_command_shells) 可以使用，但下面四个是我经常见到的：
* `csh`：C shell 适合那些习惯了 C 语言语法的开发者。
* `ksh`：Korn shell，由 David Korn 开发，在 Unix 用户中更流行。
* `tcsh`：一个 csh 的变种，增加了一些易用性。
* `zsh`：Z shell，集成了许多其他流行 shell 的特性。
所有 shell 都有内置命令，用以补充或替代核心工具集。打开 shell 的 man 说明页，找到“BUILT-INS”那一段，可以查看都有哪些内置命令。
每种 shell 都有它自己的特性和语法风格。我用过 csh、ksh 和 zsh，但我还是更喜欢 Bash。你可以多试几个，寻找更适合你的 shell，尽管这可能需要花些功夫。但幸运的是，切换不同 shell 很简单。
所有这些 shell 既是编程语言又是命令解释器。下面我们来快速浏览一下 Bash 中集成的编程结构和工具。
### 作为编程语言的 Bash
大多数场景下，系统管理员都会使用 Bash 来发送简单明了的命令。但 Bash 不仅可以输入单条命令，很多系统管理员可以编写简单的命令行程序来执行一系列任务，这些程序可以作为通用工具，能节省时间和精力。
编写 CLI 程序的目的是要提高效率（做一个“懒惰的”系统管理员）。在 CLI 程序中，你可以用特定顺序列出若干命令，逐条执行。这样你就不用盯着显示屏，等待一条命令执行完，再输入另一条，省下来的时间就可以去做其他事情了。
### 什么是“程序”？
自由在线计算机词典（[FOLDOC](http://foldoc.org/program)）对于程序的定义是：“由计算机执行的指令，而不是运行它们的物理硬件。”普林斯顿大学的 [WordNet](https://wordnet.princeton.edu/) 将程序定义为：“……计算机可以理解并执行的一系列指令……”[维基百科](https://en.wikipedia.org/wiki/Computer_program)上也有一条不错的关于计算机程序的条目。
总结下，程序由一条或多条指令组成，目的是完成一个具体的相关任务。对于系统管理员而言，一段程序通常由一系列的 shell 命令构成。Linux 下所有的 shell （至少我所熟知的）都有基本的编程功能，Bash 作为大多数 linux 发行版的默认 shell，也不例外。
本系列用 Bash 举例（因为它无处不在），假如你使用一个不同的 shell 也没关系，尽管结构和语法有所不同，但编程思想是相通的。有些 shell 支持某种特性而其他 shell 则不支持，但它们都提供编程功能。Shell 程序可以被存在一个文件中被反复使用，或者在需要的时候才创建它们。
### 简单 CLI 程序
最简单的命令行程序只有一或两条语句，它们可能相关，也可能无关，在按回车键之前被输入到命令行。程序中的第二条语句（如果有的话）可能取决于第一条语句的操作，但也不是必须的。
这里需要特别讲解一个标点符号。当你在命令行输入一条命令，按下回车键的时候，其实在命令的末尾有一个隐含的分号（`;`）。当一段 CLI shell 程序在命令行中被串起来作为单行指令使用时，必须使用分号来终结每个语句并将其与下一条语句分开。但 CLI shell 程序中的最后一条语句可以使用显式或隐式的分号。
### 一些基本语法
下面的例子会阐明这一语法规则。这段程序由单条命令组成，还有一个显式的终止符：
```
[student@studentvm1 ~]$ echo "Hello world." ;
Hello world.
```
看起来不像一个程序，但它确是我学习每个新编程语言时写下的第一个程序。不同语言可能语法不同，但输出结果是一样的。
让我们扩展一下这段微不足道却又无所不在的代码。你的结果可能与我的有所不同，因为我的家目录有点乱，而你可能是在 GUI 桌面中第一次登录账号。
```
[student@studentvm1 ~]$ echo "My home directory." ; ls ;
My home directory.
chapter25 TestFile1.Linux dmesg2.txt Downloads newfile.txt softlink1 testdir6
chapter26 TestFile1.mac dmesg3.txt file005 Pictures Templates testdir
TestFile1 Desktop dmesg.txt link3 Public testdir Videos
TestFile1.dos dmesg1.txt Documents Music random.txt testdir1
```
现在是不是更明显了。结果是相关的，但是两条语句彼此独立。你可能注意到我喜欢在分号前后多输入一个空格，这样会让代码的可读性更好。让我们再运行一遍这段程序，这次不要带结尾的分号：
```
[student@studentvm1 ~]$ echo "My home directory." ; ls
```
输出结果没有区别。
### 关于变量
像所有其他编程语言一样，Bash 支持变量。变量是个象征性的名字，它指向内存中的某个位置，那里存着对应的值。变量的值是可以改变的，所以它叫“变~量”。
Bash 不像 C 之类的语言，需要强制指定变量类型，比如：整型、浮点型或字符型。在 Bash 中，所有变量都是字符串。整数型的变量可以被用于整数运算，这是 Bash 唯一能够处理的数学类型。更复杂的运算则需要借助 [bc](https://www.gnu.org/software/bc/manual/html_mono/bc.html) 这样的命令，可以被用在命令行编程或者脚本中。
变量的值是被预先分配好的，这些值可以用在命令行编程或者脚本中。可以通过变量名字给其赋值，但是不能使用 `$` 符开头。比如，`VAR=10` 这样会把 `VAR` 的值设为 `10`。要打印变量的值，你可以使用语句 `echo $VAR`。变量名必须以文本（即非数字）开始。
Bash 会保存已经定义好的变量，直到它们被取消掉。
下面这个例子，在变量被赋值前，它的值是空（`null`）。然后给它赋值并打印出来，检验一下。你可以在同一行 CLI 程序里完成它：
```
[student@studentvm1 ~]$ echo $MyVar ; MyVar="Hello World" ; echo $MyVar ;
Hello World
[student@studentvm1 ~]$
```
*注意：变量赋值的语法非常严格，等号（`=`）两边不能有空格。*
那个空行表明了 `MyVar` 的初始值为空。变量的赋值和改值方法都一样，这个例子展示了原始值和新的值。
正如之前说的，Bash 支持整数运算，当你想计算一个数组中的某个元素的位置，或者做些简单的算术运算，这还是挺有帮助的。然而，这种方法并不适合科学计算，或是某些需要小数运算的场景，比如财务统计。这些场景有其它更好的工具可以应对。
下面是个简单的算术题：
```
[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var1*Var2))"
Result = 63
```
好像没啥问题，但如果运算结果是浮点数会发生什么呢？
```
[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var1/Var2))"
Result = 0
[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var2/Var1))"
Result = 1
[student@studentvm1 ~]$
```
结果会被取整。请注意运算被包含在 `echo` 语句之中，其实计算在 echo 命令结束前就已经完成了，原因是 Bash 的内部优先级。想要了解详情的话，可以在 Bash 的 man 页面中搜索 “precedence”。
### 控制运算符
Shell 的控制运算符是一种语法运算符，可以轻松地创建一些有趣的命令行程序。在命令行上按顺序将几个命令串在一起，就变成了最简单的 CLI 程序：
```
command1 ; command2 ; command3 ; command4 ; . . . ; etc. ;
```
只要不出错，这些命令都能顺利执行。但假如出错了怎么办？你可以预设好应对出错的办法，这就要用到 Bash 内置的控制运算符， `&&` 和 `||`。这两种运算符提供了流程控制功能，使你能改变代码执行的顺序。分号也可以被看做是一种 Bash 运算符，预示着新一行的开始。
`&&` 运算符提供了如下简单逻辑，“如果 command1 执行成功，那么接着执行 command2。如果 command1 失败，就跳过 command2。”语法如下：
```
command1 && command2
```
现在，让我们用命令来创建一个新的目录，如果成功的话，就把它切换为当前目录。确保你的家目录（`~`）是当前目录，先尝试在 `/root` 目录下创建，你应该没有权限：
```
[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir/ && cd $Dir
mkdir: cannot create directory '/root/testdir/': Permission denied
[student@studentvm1 ~]$
```
上面的报错信息是由 `mkdir` 命令抛出的，因为创建目录失败了。`&&` 运算符收到了非零的返回码，所以 `cd` 命令就被跳过，前者阻止后者继续运行，因为创建目录失败了。这种控制流程可以阻止后面的错误累积，避免引发更严重的问题。是时候讲点更复杂的逻辑了。
当一段程序的返回码大于零时，使用 `||` 运算符可以让你在后面接着执行另一段程序。简单语法如下：
```
command1 || command2
```
解读一下，“假如 command1 失败，执行 command2”。隐藏的逻辑是，如果 command1 成功，跳过 command2。下面实践一下，仍然是创建新目录：
```
[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir || echo "$Dir was not created."
mkdir: cannot create directory '/root/testdir': Permission denied
/root/testdir was not created.
[student@studentvm1 ~]$
```
正如预期，因为目录无法创建，第一条命令失败了，于是第二条命令被执行。
把 `&&` 和 `||` 两种运算符结合起来才能发挥它们的最大功效。请看下面例子中的流程控制方法：
```
前置 commands ; command1 && command2 || command3 ; 跟随 commands
```
语法解释：“假如 command1 退出时返回码为零，就执行 command2，否则执行 command3。”用具体代码试试：
```
[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir && cd $Dir || echo "$Dir was not created."
mkdir: cannot create directory '/root/testdir': Permission denied
/root/testdir was not created.
[student@studentvm1 ~]$
```
现在我们再试一次，用你的家目录替换 `/root` 目录，你将会有权限创建这个目录了：
```
[student@studentvm1 ~]$ Dir=~/testdir ; mkdir $Dir && cd $Dir || echo "$Dir was not created."
[student@studentvm1 testdir]$
```
像 `command1 && command2` 这样的控制语句能够运行的原因是，每条命令执行完毕时都会给 shell 发送一个返回码，用来表示它执行成功与否。默认情况下，返回码为 `0` 表示成功，其他任何正值表示失败。一些系统管理员使用的工具用值为 `1` 的返回码来表示失败，但其他很多程序使用别的数字来表示失败。
Bash 的内置变量 `$?` 可以显示上一条命令的返回码，可以在脚本或者命令行中非常方便地检查它。要查看返回码，让我们从运行一条简单的命令开始，返回码的结果总是上一条命令给出的。
```
[student@studentvm1 testdir]$ ll ; echo "RC = $?"
total 1264
drwxrwxr-x 2 student student 4096 Mar 2 08:21 chapter25
drwxrwxr-x 2 student student 4096 Mar 21 15:27 chapter26
-rwxr-xr-x 1 student student 92 Mar 20 15:53 TestFile1
drwxrwxr-x. 2 student student 663552 Feb 21 14:12 testdir
drwxr-xr-x. 2 student student 4096 Dec 22 13:15 Videos
RC = 0
[student@studentvm1 testdir]$
```
在这个例子中，返回码为零，意味着命令执行成功了。现在对 root 的家目录测试一下，你应该没有权限：
```
[student@studentvm1 testdir]$ ll /root ; echo "RC = $?"
ls: cannot open directory '/root': Permission denied
RC = 2
[student@studentvm1 testdir]$
```
本例中返回码是 `2`，表明非 root 用户没有权限进入这个目录。你可以利用这些返回码，用控制运算符来改变程序执行的顺序。
### 总结
本文将 Bash 看作一门编程语言，并从这个视角介绍了它的简单语法和基础工具。我们学习了如何将数据输出到 STDOUT，怎样使用变量和控制运算符。在本系列的下一篇文章中，将会重点介绍能够控制指令执行流程的逻辑运算符。
---
via: <https://opensource.com/article/19/10/programming-bash-part-1>
作者：[David Both](https://opensource.com/users/dboth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[jdh8383](https://github.com/jdh8383) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
全面介绍 Linux 权限
|
Alex Juarez
|
https://opensource.com/article/19/8/linux-permissions-101
|
知道如何控制用户对文件的访问是一项基本的系统管理技能。
|
/data/attachment/album/201911/08/233101y043rn4ua00r3lqn.jpg.thumb.jpg
|
/data/attachment/album/201911/08/233101y043rn4ua00r3lqn.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"权限"
] |
技术
|
{
"viewnum": 8832,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
知道如何控制用户对文件的访问是一项基本的系统管理技能。
| 2019-11-08T23:31:00 | 2019-11-08T23:31:00 | 11,553 |
/article-11553-1.html
|
>
> 知道如何控制用户对文件的访问是一项基本的系统管理技能。
>
>
>
了解 Linux 权限以及如何控制哪些用户可以访问文件是系统管理的一项基本技能。
本文将介绍标准 Linux 文件系统权限，并进一步研究特殊权限，以及使用 `umask` 来解释默认权限作为文章的结束。
### 理解 ls 命令的输出
在讨论如何修改权限之前，我们需要知道如何查看权限。通过 `ls` 命令的长列表参数（`-l`）为我们提供了有关文件的许多信息。
```
$ ls -lAh
total 20K
-rwxr-xr--+ 1 root root 0 Mar 4 19:39 file1
-rw-rw-rw-. 1 root root 0 Mar 4 19:39 file10
-rwxrwxr--+ 1 root root 0 Mar 4 19:39 file2
-rw-rw-rw-. 1 root root 0 Mar 4 19:39 file8
-rw-rw-rw-. 1 root root 0 Mar 4 19:39 file9
drwxrwxrwx. 2 root root 4.0K Mar 4 20:04 testdir
```
为了理解这些是什么意思，让我们将关于权限的输出分解为各个部分。单独理解每个部分会更容易。
让我们看看在上面的输出中的最后一行的每个组件：
```
drwxrwxrwx. 2 root root 4.0K Mar 4 20:04 testdir
```
| 第 1 节 | 第 2 节 | 第 3 节 | 第 4 节 | 第 5 节 | 第 6 节 | 第 7 节 |
| --- | --- | --- | --- | --- | --- | --- |
| `d` | `rwx` | `rwx` | `rwx` | `.` | `root` | `root` |
第 1 节（左侧）显示文件的类型。
| 符号 | 类型 |
| --- | --- |
| `d` | 目录 |
| `-` | 常规文件 |
| `l` | 软链接 |
`ls` 的 [info 页面](https://www.gnu.org/software/texinfo/manual/info-stnd/info-stnd.html)完整列出了不同的文件类型。
每个文件都有三种访问方式：
* 属主
* 组
* 所有其他人 第 2、3 和 4 节涉及用户（属主）、组和“其他用户”权限。每个部分都可以包含 `r`（读取）、`w`（写入）和 `x`（执行）权限的组合。
每个权限还分配了一个数值，这在以八进制表示形式讨论权限时很重要。
| 权限 | 八进制值 |
| --- | --- |
| `r` | 4 |
| `w` | 2 |
| `x` | 1 |
第 5 节描述了其他替代访问方法，例如 SELinux 或文件访问控制列表（FACL）。
| 访问方法 | 字符 |
| --- | --- |
| 没有其它访问方法 | `-` |
| SELinux | `.` |
| FACL | `+` |
| 各种方法的组合 | `+` |
第 6 节和第 7 节分别是属主和组的名称。
### 使用 chown 和 chmod
#### chown 命令
`chown`（更改所有权）命令用于更改文件的用户和组的所有权。
要将文件 `foo` 的用户和组的所有权更改为 `root`，我们可以使用以下命令：
```
$ chown root:root foo
$ chown root: foo
```
在用户名后跟冒号（`:`）运行该命令将同时设置用户和组所有权。
要仅将文件 `foo` 的用户所有权设置为 `root` 用户，请输入：
```
$ chown root foo
```
要仅更改文件 `foo` 的组所有权，请在组之前加冒号：
```
$ chown :root foo
```
#### chmod 命令
`chmod`（更改模式）命令控制属主、组以及既不是属主也不属于与文件关联的组的所有其他用户的文件许可权。
`chmod` 命令可以以八进制（例如 `755`、`644` 等）和符号（例如 `u+rwx`、`g-rwx`、`o=rw`）格式设置权限。
八进制表示法将 4 个“点”分配给“读取”，将 2 个“点”分配给“写入”，将 1 个点分配给“执行”。如果要给用户（属主）分配“读取”权限，则将 4 分配给第一个插槽，但是如果要添加“写入”权限，则必须添加 2。如果要添加“执行”，则要添加 1。我们对每种权限类型执行此操作：属主、组和其他。
例如，如果我们想将“读取”、“写入”和“执行”分配给文件的属主，但仅将“读取”和“执行”分配给组成员和所有其他用户，则我们应使用 `755`（八进制格式）。这是属主的所有权限位（`4+2+1`），但组和其他权限的所有权限位只有 `4` 和 `1`（`4+1`）。
>
> 细分为：4+2+1=7，4+1=5 和 4+1=5。
>
>
>
如果我们想将“读取”和“写入”分配给文件的属主，而只将“读取”分配给组的成员和所有其他用户，则可以如下使用 `chmod`：
```
$ chmod 644 foo_file
```
在下面的示例中，我们在不同的分组中使用符号表示法。注意字母 `u`、`g` 和 `o` 分别代表“用户”（属主）、“组”和“其他”。我们将 `u`、`g` 和 `o` 与 `+`、`-` 或 `=` 结合使用来添加、删除或设置权限位。
要将“执行”位添加到所有权权限集中：
```
$ chmod u+x foo_file
```
要从组成员中删除“读取”、“写入”和“执行”：
```
$ chmod g-rwx foo_file
```
要将所有其他用户的所有权设置为“读取”和“写入”：
```
$ chmod o=rw
```
### 特殊位：设置 UID、设置 GID 和粘滞位
除了标准权限外，还有一些特殊的权限位，它们具有一些别的用处。
#### 设置用户 ID（suid）
当在文件上设置 `suid` 时，将以文件的属主的身份而不是运行该文件的用户身份执行操作。一个[好的例子](https://www.theurbanpenguin.com/using-a-simple-c-program-to-explain-the-suid-permission/)是 `passwd` 命令。它需要设置 `suid` 位，以便更改密码的操作具有 root 权限。
```
$ ls -l /bin/passwd
-rwsr-xr-x. 1 root root 27832 Jun 10 2014 /bin/passwd
```
设置 `suid` 位的示例：
```
$ chmod u+s /bin/foo_file_name
```
#### 设置组 ID（sgid）
`sgid` 位与 `suid` 位类似，操作是在目录的组所有权下完成的，而不是以运行命令的用户身份。
一个使用 `sgid` 的例子是，如果多个用户正在同一个目录中工作，并且目录中创建的每个文件都需要具有相同的组权限。下面的示例创建一个名为 `collab_dir` 的目录，设置 `sgid` 位，并将组所有权更改为 `webdev`。
```
$ mkdir collab_dir
$ chmod g+s collab_dir
$ chown :webdev collab_dir
```
现在，在该目录中创建的任何文件都将具有 `webdev` 的组所有权，而不是创建该文件的用户的组。
```
$ cd collab_dir
$ touch file-sgid
$ ls -lah file-sgid
-rw-r--r--. 1 root webdev 0 Jun 12 06:04 file-sgid
```
#### “粘滞”位
粘滞位表示，只有文件所有者才能删除该文件，即使组权限允许该文件可以删除。通常，在 `/tmp` 这样的通用或协作目录上，此设置最有意义。在下面的示例中，“所有其他人”权限集的“执行”列中的 `t` 表示已应用粘滞位。
```
$ ls -ld /tmp
drwxrwxrwt. 8 root root 4096 Jun 12 06:07 /tmp/
```
请记住，这不会阻止某个人编辑该文件，它只是阻止他们删除该目录的内容（LCTT 译注：即删除目录下文件）。
我们将粘滞位设置为：
```
$ chmod o+t foo_dir
```
你可以自己尝试在目录上设置粘滞位并赋予其完整的组权限，以便多个属于同一组的用户可以在目录上进行读取、写入和执行。
接着，以每个用户的身份创建文件，然后尝试以另一个用户的身份删除它们。
如果一切配置正确，则一个用户应该不能从另一用户那里删除文件。
请注意，这些位中的每个位也可以用八进制格式设置：SUID = 4、SGID = 2 和 粘滞位 = 1。（LCTT 译注：这里是四位八进制数字）
```
$ chmod 4744
$ chmod 2644
$ chmod 1755
```
#### 大写还是小写？
如果要设置特殊位时看到大写的 `S` 或 `T` 而不是小写的字符（如我们之前所见），那是因为不存在（对应的）底层的执行位。为了说明这一点，下面的示例创建一个设置了粘滞位的文件。然后，我们可以添加和删除执行位以演示大小写更改。
```
$ touch file cap-ST-demo
$ chmod 1755 cap-ST-demo
$ ls -l cap-ST-demo
-rwxr-xr-t. 1 root root 0 Jun 12 06:16 cap-ST-demo
$ chmod o-x cap-X-demo
$ ls -l cap-X-demo
-rwxr-xr-T. 1 root root 0 Jun 12 06:16 cap-ST-demo
```
#### 有条件地设置执行位
至此，我们使用小写的 `x` 设置了执行位，而无需询问任何问题即可对其进行设置。我们还有另一种选择：使用大写的 `X` 而不是小写的，它将仅在权限组中某个位置已经有执行位时才设置执行位。这可能是一个很难解释的概念，但是下面的演示将帮助说明它。请注意，在尝试将执行位添加到组特权之后，该位没有被设置上。
```
$ touch cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod g+X cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
```
在这个类似的例子中，我们首先使用小写的 `x` 将执行位添加到组权限，然后使用大写的 `X` 为所有其他用户添加权限。这次，大写的 `X`设置了该权限。
```
$ touch cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod g+x cap-X-file
$ ls -l cap-X-file
-rw-r-xr--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod o+X cap-X-file
ls -l cap-X-file
-rw-r-xr-x. 1 root root 0 Jun 12 06:31 cap-X-file
```
### 理解 umask
`umask` 会屏蔽（或“阻止”）默认权限集中的位，以定义文件或目录的权限。例如，`umask`输出中的 `2` 表示它至少在默认情况下阻止了文件的“写入”位。
使用不带任何参数的 `umask` 命令可以使我们看到当前的 `umask` 设置。共有四列：第一列为特殊的`suid`、`sgid` 或粘滞位而保留，其余三列代表属主、组和其他人的权限。
```
$ umask
0022
```
为了理解这意味着什么，我们可以用 `-S` 标志来执行 `umask`（如下所示）以解释屏蔽位的结果。例如，由于第三列中的值为 `2`，因此将“写入”位从组和其他部分中屏蔽掉了；只能为它们分配“读取”和“执行”。
```
$ umask -S
u=rwx,g=rx,o=rx
```
要查看文件和目录的默认权限集是什么，让我们将 `umask` 设置为全零。这意味着我们在创建文件时不会掩盖任何位。
```
$ umask 000
$ umask -S
u=rwx,g=rwx,o=rwx
$ touch file-umask-000
$ ls -l file-umask-000
-rw-rw-rw-. 1 root root 0 Jul 17 22:03 file-umask-000
```
现在，当我们创建文件时，我们看到所有部分的默认权限分别为“读取”（`4`）和“写入”（`2`），相当于八进制表示 `666`。
我们可以对目录执行相同的操作，并看到其默认权限为 `777`。我们需要在目录上使用“执行”位，以便可以遍历它们。
```
$ mkdir dir-umask-000
$ ls -ld dir-umask-000
drwxrwxrwx. 2 root root 4096 Jul 17 22:03 dir-umask-000/
```
### 总结
管理员还有许多其他方法可以控制对系统文件的访问。这些权限是 Linux 的基本权限，我们可以在这些基础上进行构建。如果你的工作为你引入了 FACL 或 SELinux，你会发现它们也建立在这些文件访问的首要规则之上。
---
via: <https://opensource.com/article/19/8/linux-permissions-101>
作者：[Alex Juarez](https://opensource.com/users/mralexjuarezhttps://opensource.com/users/marcobravohttps://opensource.com/users/greg-p) 选题：[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/) 荣誉推出
|
6 款面向 Linux 用户的开源绘图应用程序
|
Ankush Das
|
https://itsfoss.com/open-source-paint-apps/
|
既然你是一名 Linux 用户，为什么不关注一下开源绘图应用程序呢？
|
/data/attachment/album/201911/09/081317j5msq7a33s4w4xx4.png.thumb.jpg
|
/data/attachment/album/201911/09/081317j5msq7a33s4w4xx4.png
| true | false | true |
lujun9972
|
robsean
|
wxy
| false |
[
"绘图"
] |
分享
|
{
"viewnum": 17017,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
既然你是一名 Linux 用户，为什么不关注一下开源绘图应用程序呢？
| 2019-11-09T08:13:13 | 2019-11-09T08:13:13 | 11,554 |
/article-11554-1.html
|
小时候，当我开始使用计算机（在 Windows XP 中）时，我最喜欢的应用程序是微软的“画图”。我能在它上面涂鸦数个小时。出乎意料，孩子们仍然喜欢这个“画图”应用程序。不仅仅是孩子们，这个简单的“画图”应用程序，在很多情况下都能派上用场。
你可以找到一堆可以让你绘制/绘图或操作图片的应用程序。然而，其中一些是专有软件。既然你是一名 Linux 用户，为什么不关注一下开源绘图应用程序呢？
在这篇文章中，我们将列出一些最好的开源绘图应用程序，它们可以替代可用于 Linux 的专有绘画软件。
### 开源绘图 & 绘制应用程序
**注意:** 该列表没有特别的排名顺序。
#### 1、Pinta
主要亮点：
* Paint.NET / 微软“画图”的极好替代品
* 支持附加组件（有对 WebP 图像的支持）
* 支持图层
[Pinta](https://pinta-project.com/pintaproject/pinta/) 是一款令人赞叹的开源绘图应用程序，非常适合绘图和简单的图片编辑。换句话说，它是一款具有精美功能的简单绘图应用程序。
你可以将 [Pinta](https://itsfoss.com/pinta-1-6-ubuntu-linux-mint/) 视为 Linux 上的“画图”的一个替代品，但是带有图层支持等等。不仅仅是“画图”，它也可以替代 Windows 上的 Paint.NET。尽管 Paint.NET 更好一些，但 Pinta 似乎是个不错的选择。
几个附加组件可以用于增强功能，例如[在 Linux 上支持 WebP 图像](https://itsfoss.com/webp-ubuntu-linux/)。除了图层支持之外，你还可以轻松地调整图片大小、添加特效、进行调整（亮度、对比度等等），以及在导出图片时调整其质量。
##### 如何安装 Pinta ？
你应该能够在软件中心/应用程序中心/软件包管理器中简单地找到它。只需要输入 “Pinta”，并开始安装它。要么也可以尝试 [Flatpak](https://www.flathub.org/apps/details/com.github.PintaProject.Pinta) 软件包。
或者，你可以在终端中输入下面的命令（Ubuntu/Debian）：
```
sudo apt install pinta
```
下载软件包和安装指南的更多信息，参考[官方下载页面](https://pinta-project.com/pintaproject/pinta/releases)。
#### 2、Krita
主要亮点：
* HDR 绘图
* 支持 PSD
* 支持图层
* 笔刷稳定器
* 二维动画
Krita 是 Linux 上最高级的开源绘图应用程序之一。当然，对于本文而言，它可以帮助你绘制草图和在画布上胡写乱画。除此之外，它还提供很多功能。
例如，如果你的手有点颤抖，它可以帮助你稳定笔刷的笔划。你可以使用内置的矢量工具来创建漫画画板和其它有趣的东西。如果你正在寻找具有全面的颜色管理支持、绘图助理和图层管理的软件，Krita 应该是你最好的选择。
##### 如何安装 Krita ？
类似于 pinta，你可以在软件中心/应用程序中心或软件包管理器的列表中找到它。它也可以 [Flatpak 存储库](https://www.flathub.org/apps/details/org.kde.krita)中找到。
考虑通过终端安装它？输入下面的命令：
```
sudo apt install krita
```
要么你也可以前往它们的[官方下载页面](https://krita.org/en/download/krita-desktop/)来获取 AppImage 文件并运行它。
如果你对 AppImage 文件一无所知，查看我们的指南 —— [如何使用 AppImage](https://itsfoss.com/use-appimage-linux/)。
#### 3、Tux Paint
主要亮点：
* 给儿童用的一个简单直接的绘图应用程序
我不是开玩笑，对于 3-12 岁儿童来说，Tux Paint 是最好的开源绘图应用程序之一。当然，当你只想乱画时，那无需选择，所以，在这种情况下，Tux Paint 似乎是最好的选择（即使是成年人！）。
##### 如何安装 Tuxpaint ？
Tuxpaint 可以从软件中心或软件包管理器下载。无论哪种情况，在 Ubuntu/Debian 上安装它，在终端中输入下面的命令：
```
sudo apt install tuxpaint
```
关于它的更多信息，前往[官方站点](http://www.tuxpaint.org/)。
#### 4、Drawpile
主要亮点：
* 协同绘制
* 内置聊天功能，可与其他用户互动
* 图层支持
* 记录绘制会话
Drawpile 是一个有趣的开源绘图应用程序，在该程序中，你可以与其他用户实时协作。确切地说，你们可以单个画布中同时绘制。除了这个独特的功能，它还有图层支持、记录绘制会话的能力，甚至还有与协作用户进行交互的聊天功能。
你可以主持或加入一个公共会话，或通过一个密码与你的朋友建立私有会话。默认情况下，服务器将是你的计算机，但是如果你需要远程服务器那也可以。
注意，你将需要[注册一个 Drawpile 账户](https://drawpile.net/accounts/signup/) 才能进行协作。
##### 如何安装 Drawpile ？
据我所知，你只能在 [Flatpak 存储库](https://flathub.org/apps/details/net.drawpile.drawpile)的列表中找到它。
#### 5、MyPaint
主要亮点：
* 易用的数码画家工具
* 支持图层管理
* 很多微调你的画笔和绘制的选项
对于数码画家来说，[MyPaint](https://mypaint.org/) 是一个简单而强大的工具。它具有许多选项，可以调整以制作出完美的数字画笔笔触。我不是一个数字艺术家（但我是一个涂鸦者），但是我注意到有很多调整笔刷、颜色的选项，和一个添加中间结果暂存器面板的选项。
它也支持图层管理，也许你需要它。最新的稳定版本已经有几年没有更新了，但是当前的 alpha 构建版本（我测试过）运行良好。如果你正在 Linux 上寻找一个开源绘图应用程序 —— 试试这个。
##### 如何安装 MyPaint ？
MyPaint 可在官方存储库中获得。然而，这是老旧的版本。如果你仍然想继续，你可以在软件中心搜索它，或在终端中输入下面的命令：
```
sudo apt install mypaint
```
你可以前往它的官方 [GitHub 发布页面](https://github.com/mypaint/mypaint/releases)获取最新的 alpha 构建版本，获取 [AppImage 文件](https://itsfoss.com/use-appimage-linux/)（任意版本）并使它可执行并启动应用程序。
#### 6、KolourPaint
主要亮点：
* 一个 Linux 上的“画图”的简单替代品
* 不支持图层管理
如果你不需要任何图层管理的支持，而只是想要一个开源绘图应用程序来绘制东西 —— 那就是它了。
[KolourPaint](http://kolourpaint.org/) 最初是为 KDE 桌面环境定制的，但是它在其它的桌面环境中也能完美地工作。
##### 如何安装 KolourPaint ？
你可以从软件中心安装 KolourPaint，或通过终端使用下面的命令：
```
sudo apt install kolourpaint4
```
你总可以试试 [Flathub](https://flathub.org/apps/details/org.kde.kolourpaint)。
### 总结
如果你在考虑如 GIMP/Inkscape 这样的应用程序，我们在另一篇关于[给数码艺术家的最好 Linux 工具](https://itsfoss.com/best-linux-graphic-design-software/)的文章中列出。如果你对更多的选择好奇，我建议你去查看它。
在这里，我们尝试编写一份 Linux 可用的最佳开源绘图应用程序列表。如果你认为我们错过一些东西，请在下面的评论区告诉我们！
---
via: <https://itsfoss.com/open-source-paint-apps/>
作者：[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/) 荣誉推出
|
Chrome/Chromium 用户必知必会的 11 个基本快捷键
|
Abhishek Prakash
|
https://itsfoss.com/google-chrome-shortcuts/
|
掌握这些 Google Chrome 键盘快捷键，以获得更好、更流畅、更高效的 Web 浏览体验。还包括可下载的备忘单。
|
/data/attachment/album/201911/09/214207wh96q76ejacnn5as.png.thumb.jpg
|
/data/attachment/album/201911/09/214207wh96q76ejacnn5as.png
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Chrome"
] |
桌面应用
|
{
"viewnum": 6191,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
掌握这些 Google Chrome 键盘快捷键，以获得更好、更流畅、更高效的 Web 浏览体验。还包括可下载的备忘单。
| 2019-11-09T21:42:14 | 2019-11-09T21:42:14 | 11,556 |
/article-11556-1.html
|
>
> 掌握这些 Google Chrome 键盘快捷键，以获得更好、更流畅、更高效的 Web 浏览体验。还包括可下载的备忘单。
>
>
>
无可否认，Google Chrome 是[最受欢迎的网络浏览器](https://en.wikipedia.org/wiki/Usage_share_of_web_browsers)。它的开源版本 [Chromium](https://www.chromium.org/Home) 也越来越受欢迎，现在一些 Linux 发行版将其作为默认的网络浏览器。
如果你经常在台式机上使用它，则可以使用 Google Chrome 键盘快捷键来改善浏览体验。没有必要用你的鼠标移来移去、点来点去。只要掌握这些快捷方式，你可以节省一些时间并提高工作效率。
我这里使用的名称是 Google Chrome，但是这些快捷方式同样适用于 Chromium 浏览器。
### 你应该使用的 11 个酷炫的 Chrome 键盘快捷键
如果你是专业人士，可能已经知道其中一些 Chrome 快捷方式，但是有可能你仍然可以在这里找到一些隐藏的宝石。让我们来看看。
| **键盘快捷键** | **动作** |
| --- | --- |
| `Ctrl+T` | 打开一个新标签页 |
| `Ctrl+N` | 打开一个新窗口 |
| `Ctrl+Shift+N` | 打开一个新无痕式窗口 |
| `Ctrl+W` | 关闭当前标签页 |
| `Ctrl+Shift+T` | 重新打开上一个关闭的标签页 |
| `Ctrl+Shift+W` | 关闭窗口 |
| `Ctrl+Tab` 和 `Ctrl+Shift+Tab` | 切换到右侧或左侧的标签页 |
| `Ctrl+L` | 访问搜索/地址栏 |
| `Ctrl+D` | 将网址放入书签 |
| `Ctrl+H` | 访问浏览历史 |
| `Ctrl+J` | 访问下载历史 |
| `Shift+Esc` | 打开 Chrome 任务管理器 |
你可以[下载这份有用的 Chrome 键盘快捷键列表来作为快速参考](tmp.3qZNXSy2FC#download-cheatsheet)。
#### 1、用 `Ctrl+T` 打开一个新标签页
需要打开一个新标签页吗？只需同时按 `Ctrl` 和 `T` 键，你就会打开一个新标签。
#### 2、使用 `Ctrl+N` 打开一个新窗口
已经打开太多标签页？是时候打开一个新的窗口。使用 `Ctrl` 和 `N` 键打开一个新的浏览器窗口。
#### 3、使用 `Ctrl+Shift+N` 隐身
在线查询航班或酒店价格？隐身可能会有所帮助。使用 `Ctrl+Shift+N` 在 Chrome 中打开一个隐身窗口。
#### 4、使用 `Ctrl+W` 关闭标签页
使用 `Ctrl` 和 `W` 键关闭当前标签页。无需将鼠标移到顶部并寻找 `x` 按钮。
#### 5、不小心关闭了标签页？用 `Ctrl+Shift+T` 重新打开
这是我最喜欢的 Google Chrome 浏览器快捷方式。当你关闭了原本不想关的标签页时，就不用再懊悔了。使用 `Ctrl+Shift+T`，它将打开最后一个关闭的选项卡。继续按此组合键，它把关闭的选项卡再次打开。
#### 6、使用 `Ctrl+Shift+W` 关闭整个浏览器窗口
完成工作了吗？是时候关闭带有所有标签页的整个浏览器窗口了。使用 `Ctrl+Shift+W` 键，浏览器窗口将消失，就像以前不存在一样。
#### 7、使用 `Ctrl+Tab` 在标签之间切换
打开的标签页太多了吗？你可以使用 `Ctrl+Tab` 移至右侧标签页。想左移吗？使用 `Ctrl+Shift+Tab`。重复按这些键，你可以在当前浏览器窗口的所有打开的标签页之间移动。
你也可以使用 `Ctrl+0` 直到 `Ctrl+9` 转到前 10 个标签页之一。但是此 Chrome 键盘快捷键不适用于第 11 个及更多标签页。
#### 8、使用 `Ctrl+L` 转到搜索/地址栏
想要输入新的 URL 或快速搜索一些内容。你可以使用 `Ctrl+L`，它将在顶部突出显示地址栏。
#### 9、用 `Ctrl+D` 收藏当前网站
找到了有趣的东西？使用 `Ctrl+D` 组合键将其保存在书签中。
#### 10、使用 `Ctrl+H` 返回历史记录
你可以使用 `Ctrl+H` 键打开浏览器历史记录。如果你正在寻找前一段时间访问过的页面，或者删除你不想再看到的页面，可以搜索历史记录。
#### 11、使用 `Ctrl+J` 查看下载
在 Chrome 中按 `Ctrl+J` 键将带你进入下载页面。此页面将显示你执行的所有下载操作。
#### 意外惊喜：使用 `Shift+Esc` 打开 Chrome 任务管理器
很多人甚至都不知道 Chrome 浏览器中有一个任务管理器。Chrome 以消耗系统内存而臭名昭著。而且，当你打开大量标签时，找到罪魁祸首并不容易。
使用 Chrome 任务管理器，你可以查看所有打开的标签页及其系统利用率统计信息。你还可以看到各种隐藏的进程，例如 Chrome 扩展程序和其他服务。
### 下载 Chrome 快捷键备忘单
我知道掌握键盘快捷键取决于习惯，你可以通过反复使用使其习惯。为了帮助你完成此任务，我创建了此 Google Chrome 键盘快捷键备忘单。
你可以[下载以下 PDF 格式的图像](https://drive.google.com/open?id=1lZ4JgRuFbXrnEXoDQqOt7PQH6femIe3t)，进行打印并将其放在办公桌上。这样，你可以一直练习快捷方式。
如果你对掌握快捷方式感兴趣，还可以查看 [Ubuntu 键盘快捷键](https://itsfoss.com/ubuntu-shortcuts/)。
顺便问一下，你最喜欢的 Chrome 快捷方式是什么？
---
via: <https://itsfoss.com/google-chrome-shortcuts/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[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/) 荣誉推出
|
如何拥有一个 Windows 10 和 Debian 10 的双系统
|
James Kiarie
|
https://www.linuxtechi.com/dual-boot-windows-10-debian-10/
|
在无数次劝说自己后，你终于做出了一个大胆的决定，试试 Linux。
|
/data/attachment/album/201911/09/233210opqiyx6wabpmg3mo.jpg.thumb.jpg
|
/data/attachment/album/201911/09/233210opqiyx6wabpmg3mo.jpg
| true | false | true |
lujun9972
|
wenwensnow
|
wxy
| false |
[
"Windows"
] |
技术
|
{
"viewnum": 18512,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "117.181.103.11",
"message": "是否要将 grub 的引导装载程序安装到主引导记录表（MBR）上？<br />\r\nwin10都是用UEFI的，还来MBR这套？",
"username": "来自117.181.103.11的 Chrome 78.0|Windows 10 用户",
"date": "2019-11-11T10:32:02"
},
{
"postip": "111.196.78.158",
"message": "win10 的ubuntu子系统就挺好",
"username": "来自北京的 Chrome 69.0|Windows 10 用户",
"date": "2019-11-13T15:52:21"
},
{
"postip": "111.196.78.158",
"message": "win10 的ubuntu子系统就挺好",
"username": "来自北京的 Chrome 69.0|Windows 10 用户",
"date": "2019-11-13T15:52:26"
}
] |
[] |
在无数次劝说自己后，你终于做出了一个大胆的决定，试试 Linux。
| 2019-11-09T23:32:00 | 2019-11-09T23:32:00 | 11,557 |
/article-11557-1.html
|
在无数次劝说自己后，你终于做出了一个大胆的决定，试试 Linux。不过，在完全熟悉 Linux 之前，你依旧需要使用 Windows 10 系统。幸运的是，通过一个双系统引导设置，能让你在启动时，选择自己想要进入的系统。在这个指南中，你会看到如何 如何双重引导 Windows 10 和 Debian 10。
### 前提条件
在开始之前，确保你满足下列条件:
* 一个 Debian 10 的可引导 USB 或 DVD
* 一个快速且稳定的网络（为了安装更新以及第三方软件）
另外，记得注意你系统的引导策略（UEFI 或 Legacy），需要确保两个系统使用同一种引导模式。
### 第一步：在硬盘上创建一个空余分区
第一步，你需要在你的硬盘上创建一个空余分区。之后，这将是我们安装 Debian 系统的地方。为了实现这一目的，需要使用下图所示的磁盘管理器：
同时按下 `Windows + R` 键，启动“运行程序”。接下来，输入 `diskmgmt.msc`，按回车键。
这会启动“磁盘管理”窗口，它会显示你 Windows 上所有已有磁盘。
接下来，你需要为安装的 Debian 系统创建空余空间。为此，你需要缩小其中一个磁盘（卷）上的分区，从而创建一个未分配的新分区。在这个例子里，我会从 D 盘中创建一个 30 GB 的新分区。
为了缩小一个卷，右键点击它，然后选中选项 “<ruby> 缩小 <rt> Shrink volume… </rt></ruby>”。
在弹出窗口中，定义你想缩小的空间大小。记住，这是将来要安装 Debian 10 的磁盘空间。我选择了 30000MB（大约 30 GB）。压缩完成后，点击“<ruby> 缩小 <rt> Shrink </rt></ruby>”。
在缩小操作结束后，你会看到一个如下图所示的未分配分区：
完美！现在可以准备开始安装了。
### 第二步：开始安装 Debian 10
空余分区已经创建好了，将你的可引导 USB 或安装 DVD 插入电脑，重新启动系统。记得更改 BIOS 中的引导顺序，需要在启动时按住功能键（通常，根据品牌不同，是 `F9`、`F10` 或 `F12` 中的某一个）。 这一步骤，对系统是否能进入安装媒体来说，至关重要。保存 BIOS 设置，并重启电脑。
如下图所示，界面会显示一个新的引导菜单：点击 “Graphical install”。
下一步，选择你的偏好语言，然后点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
接着，选择你的地区，点击“<ruby> 继续 <rt> Continue </rt></ruby>”。 根据地区，系统会自动选择当地对应的时区。如果你无法找到你所对应的地区，将界面往下拉， 点击“<ruby> 其他 <rt> Other </rt></ruby>”后，选择相对应位置。
而后，选择你的键盘布局。
接下来，设置系统的主机名，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
下一步，确定域名。如果你的电脑不在域中，直接点击 “<ruby> 继续 <rt> Continue </rt></ruby>”按钮。
然后，如图所示，设置 root 密码，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
下一步骤，设置账户的用户全名，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
接着，设置与此账户相关联的用户名。
下一步，设置用户密码，点击“<ruby> 继续 <rt> Continue </rt></ruby>”。
然后，设置时区。
这时，你要为 Debian10 安装创建分区。如果你是新手用户，点击菜单中的第一个选项，“<ruby> 使用最大的连续空余空间 <rt> Use the largest continuous free space </rt></ruby>”，点击“<ruby> 继续 <rt> Continue </rt></ruby>”。
不过，如果你对创建分区有所了解的话，选择“<ruby> 手动 <rt> Manual </rt></ruby>” 选项，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
接着，选择被标记为 “<ruby> 空余空间 <rt> FREE SPACE </rt></ruby>” 的磁盘，点击 “<ruby> 继续 <rt> Continue </rt></ruby>” 。接下来，点击“<ruby> 创建新分区 <rt> Create a new partition </rt></ruby>”。
下一界面，首先确定交换空间大小。我的交换空间大小为 2GB，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
点击下一界面的 “<ruby> 主分区 <rt> Primary </rt></ruby>”，点击“<ruby> 继续 <rt> Continue </rt></ruby>”。
选择在磁盘 “<ruby> 初始位置 <rt> beginning </rt></ruby>” 创建新分区后，点击继续。
选择 “<ruby> Ext 4 日志文件系统 <rt> Ext 4 journaling file system </rt></ruby>”，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
下个界面选择“<ruby> 交换空间 <rt> swap space </rt></ruby>” ，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
选中 “<ruby> 完成此分区设置 <rt> done setting the partition </rt></ruby>”，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
返回磁盘分区界面，点击 “<ruby> 空余空间 <rt> FREE SPACE </rt></ruby>”，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
为了让自己能轻松一点，选中 “<ruby> 自动为空余空间分区 <rt> Automatically partition the free space </rt></ruby>”后，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
接着点击 “<ruby> 将所有文件存储在同一分区（新手用户推荐） <rt> All files in one partition (recommended for new users) </rt></ruby>”。
最后， 点击 “<ruby> 完成分区设置，并将改动写入磁盘 <rt> Finish partitioning and write changes to disk </rt></ruby>” ，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
确定你要将改动写入磁盘，点击 “<ruby> 是 <rt> Yes </rt></ruby>”。
而后，安装程序会开始安装所有必要的软件包。
当系统询问是否要扫描其他 CD 时，选择 “<ruby> 否 <rt> No </rt></ruby>” ，并点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
接着，选择离你最近的镜像站点地区，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
然后，选择最适合你的镜像站点，点击“<ruby> 继续 <rt> Continue </rt></ruby>”。
如果你打算使用代理服务器，在下面输入具体信息，没有的话就留空，点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
随着安装进程的继续， 你会被问到，是否想参加一个软件包用途调查。你可以选择任意一个选项，之后点击“<ruby> 继续 <rt> Continue </rt></ruby>”，我选择了“<ruby> 否 <rt> No </rt></ruby>”。
在软件选择窗口选中你想安装的软件包，点击“<ruby> 继续 <rt> Continue </rt></ruby>”。
安装程序会将选中的软件一一安装，在这期间，你可以去喝杯咖啡休息一下。
系统将会询问你，是否要将 grub 的引导装载程序安装到主引导记录表（MBR）上。点击 “<ruby> 是 <rt> Yes </rt></ruby>”，而后点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
接着，选中你想安装 grub 的硬盘，点击“<ruby> 继续 <rt> Continue </rt></ruby>”。
最后，安装完成，直接点击 “<ruby> 继续 <rt> Continue </rt></ruby>”。
你现在应该会有一个列出 Windows 和 Debian 的 grub 菜单。为了引导 Debian 系统，往下选择 Debian。之后，你就能看见登录界面。输入密码之后，按回车键。
这就完成了！这样，你就拥有了一个全新的 Debian 10 和 Windows 10 双系统。
---
via: <https://www.linuxtechi.com/dual-boot-windows-10-debian-10/>
作者：[James Kiarie](https://www.linuxtechi.com/author/james/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
低价 Linux 智能手机 PinePhone 即将接受预订
|
Ankush Das
|
https://itsfoss.com/pinephone/
|
好消息是 PinePhone 将从 11 月 15 日开始接受预订。
|
/data/attachment/album/201911/10/220647vi11iianvw5wxebh.jpg.thumb.jpg
|
/data/attachment/album/201911/10/220647vi11iianvw5wxebh.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"手机"
] |
每日安全资讯
|
{
"viewnum": 5342,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "110.17.81.232",
"message": "昨天晚上在Ubuntu touch 那看了下，新支持的手机型号，linux.cn就碰到这篇文章，鼓励我换个gnu/linux的手机吗！~? haha:):)",
"username": "qlk [Chrome 78.0|Windows 7]",
"date": "2019-11-10T23:09:17"
},
{
"postip": "119.103.223.201",
"message": "用安卓就是 支持 linux 手机了，是不是 gnu 应该是RMS该关心的事",
"username": "来自湖北武汉的 Chrome Mobile 62.0|Android 7.1 用户",
"date": "2019-11-11T08:42:19"
}
] |
[] |
好消息是 PinePhone 将从 11 月 15 日开始接受预订。
| 2019-11-10T22:06:43 | 2019-11-10T22:06:43 | 11,559 |
/article-11559-1.html
|
你还记得[在 2017 年首次披露](https://itsfoss.com/pinebook-kde-smartphone/)的 Pine64 正在开发一个基于 Linux（可以运行 KDE Plasma 及其他发行版）的智能手机的事情吗？从那以后已经有一段时间了，但是好消息是 PinePhone 将从 11 月 15 日开始接受预订。
让我来为你提供有关 PinePhone 的更多详细信息，例如其规格、价格和发布日期。
### PinePhone：基于 Linux 的廉价智能手机
PinePhone 开发者套件已经经过了一些开发人员的测试，更多此类套件将于 11 月 15 日发货。你可以查看下面的照片：
开发者套件是由 PINE A64 基板 + SOPine 模块 + 7 英寸触摸屏显示器 + 摄像头 + Wifi / BT + 外壳 + 锂离子电池盒 + LTE cat 4 USB 软件狗组成的组合套件。
这些组合套件可以使开发人员快速开始 PinePhone 开发。由于 PINE64 社区和 [KDE neon](https://neon.kde.org/) 的支持，主线 Linux 操作系统已经可以在 PINE A64 平台上构建。
#### PinePhone 规格
* Allwinner A64 四核 SoC，带有 Mali 400 MP2 GPU
* 2GB 的 LPDDR3 RAM
* 5.95 英寸 LCD 1440×720，长宽比 18：9（钢化玻璃）
* 可启动的 Micro SD
* 16GB eMMC
* 高清数字视频输出
* USB Type-C（电源、数据和视频输出）
* Quectel EG-25G 全球波段
* WiFi：802.11 b/g/n，单频，支持热点
* 蓝牙：4.0，A2DP
* GNSS：GPS，GPS-A，GLONASS
* 振动器
* RGB 状态 LED
* 自拍和主摄像头（分别为 2/5 Mpx）
* 主摄像头：单颗 OV6540、5MP，1/4 英寸，LED 闪光灯
* 自拍相机：单 GC2035、2MP，f/2.8、1/5 英寸
* 传感器：加速器、陀螺仪、距离感应器、罗盘、气压计、环境光感
* 3 个外部开关：上、下和电源
* 硬件开关：LTE/GNSS、WiFi、麦克风、扬声器、USB
* 三星 J7 外形尺寸 3000mAh 电池
* 外壳是磨砂黑色成品塑料
* 耳机插孔
#### 产品、价格和交付时间
PinePhone 的价格约为 150 美元。尝鲜版命名为“勇敢的心”，将于 2019 年 11 月 15 日开始销售。如上图所示，[Pine64 的主页](https://www.pine64.org/)包含了用于首次预订 PinePhone 的计时器。
预期“勇敢的心”尝鲜版在 2019 年 12 月或 2020 年 1 月之前发货。
大规模生产将在中国的农历新年后开始，也就是说在 2020 年第二季度早期或最早 2020 年 3 月开始。
该电话尚未在 Pine Store 中列出，因此，如果你想成为尝鲜者之一，请务必查看 [Pine64 在线商店](https://store.pine64.org/)以预订“勇敢的心”版本。
#### 你对 PinePhone 如何看？
Pine64 已经开发了一款名为 [Pinebook](https://itsfoss.com/pinebook-linux-notebook/) 的廉价笔记本电脑和一款功能相对强大的 [Pinebook Pro](https://itsfoss.com/pinebook-pro/) 笔记本电脑。因此，PinePhone 至少在 DIY 爱好者和 Linux 忠实拥护者的狭窄市场中绝对有希望获得成功。与其他价格超过 600 美元的 [Linux 智能手机 Librem5](https://itsfoss.com/librem-linux-phone/) 相比，低廉的价格绝对是一个巨大的优势。
PinePhone 的另一个优点是，你可以通过安装 Ubuntu Touch、Plasma Mobile 或 Aurora OS/Sailfish OS 来试验操作系统。
这些基于 Linux 的智能手机尚不具备取代 Android 或 iOS 的功能。如果你正在寻找功能全面的智能手机来替代你的 Android 智能手机，那么 PinePhone 当然不适合你。但对于喜欢尝试并且不害怕排除故障的人来说，它的优势更大。
如果你想购买 PinePhone，请记住这个日期并设置提醒。供应应该是限量的，到目前为止，我所了解的，Pine 设备很快就会脱销。
你要预订 PinePhone 吗？在评论部分将你的意见告知我们。
---
via: <https://itsfoss.com/pinephone/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[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/) 荣誉推出
|
在 Fedora 上优化 bash 或 zsh
|
George Luiz Maluf
|
https://fedoramagazine.org/tuning-your-bash-or-zsh-shell-in-workstation-and-silverblue/
|
本文将向你展示如何在 Fedora 的命令行解释器（CLI）Shell 中设置一些强大的工具。如果使用bash（默认）或zsh，Fedora 可让你轻松设置这些工具。
|
/data/attachment/album/201911/10/233630ibjmiz5lz6egtizr.jpg.thumb.jpg
|
/data/attachment/album/201911/10/233630ibjmiz5lz6egtizr.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"bash",
"zsh"
] |
桌面应用
|
{
"viewnum": 10153,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文将向你展示如何在 Fedora 的命令行解释器（CLI）Shell 中设置一些强大的工具。如果使用bash（默认）或zsh，Fedora 可让你轻松设置这些工具。
| 2019-11-10T23:36:26 | 2019-11-10T23:36:26 | 11,560 |
/article-11560-1.html
|
本文将向你展示如何在 Fedora 的命令行解释器（CLI）Shell 中设置一些强大的工具。如果使用bash（默认）或zsh，Fedora 可让你轻松设置这些工具。
### 前置需求
这需要一些已安装的软件包。在 Fedora 工作站上，运行以下命令：
```
sudo dnf install git wget curl ruby ruby-devel zsh util-linux-user redhat-rpm-config gcc gcc-c++ make
```
在 Silverblue 上运行：
```
sudo rpm-ostree install git wget curl ruby ruby-devel zsh util-linux-user redhat-rpm-config gcc gcc-c++ make
```
注意：在 Silverblue 上，你需要重新启动才能继续。
### 字体
你可以通过安装新字体使终端焕然一新。为什么不使用可以同时显示字符和图标的字体呢？
#### Nerd-Fonts
打开一个新终端，然后键入以下命令：
```
git clone https://github.com/ryanoasis/nerd-fonts ~/.nerd-fonts
cd .nerd-fonts
sudo ./install.sh
```
#### Awesome-Fonts
在工作站上，使用以下命令进行安装：
```
sudo dnf fontawesome-fonts
```
在 Silverblue 上键入：
```
sudo rpm-ostree install fontawesome-fonts
```
### Powerline
Powerline 是 vim 的状态行插件，并为其他几个应用程序也提供了状态行和提示符，包括 bash、zsh、tmus、i3、Awesome、IPython 和 Qtile。你也可以在官方[文档站点](https://powerline.readthedocs.io/en/latest/)上找到更多信息。
#### 安装
要在 Fedora 工作站上安装 Powerline 实用程序，请打开一个新终端并运行：
```
sudo dnf install powerline vim-powerline tmux-powerline powerline-fonts
```
在 Silverblue 上，命令更改为：
```
sudo rpm-ostree install powerline vim-powerline tmux-powerline powerline-fonts
```
注意：在 Silverblue 上，你需要重新启动才能继续。
#### 激活 Powerline
要使 Powerline 默认处于活动状态，请将下面的代码放在 `~/.bashrc` 文件的末尾：
```
if [ -f `which powerline-daemon` ]; then
powerline-daemon -q
POWERLINE_BASH_CONTINUATION=1
POWERLINE_BASH_SELECT=1
. /usr/share/powerline/bash/powerline.sh
fi
```
最后，关闭终端并打开一个新终端。它看起来像这样：
### Oh-My-Zsh
[Oh-My-Zsh](https://ohmyz.sh) 是用于管理 Zsh 配置的框架。它捆绑了有用的功能、插件和主题。要了解如何将 Zsh 设置为默认外壳程序，请参见[这篇文章](https://fedoramagazine.org/set-zsh-fedora-system/)。
#### 安装
在终端中输入：
```
sh -c "$(curl -fsSL https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"
```
或者，你也可以输入以下内容：
```
sh -c "$(wget https://raw.github.com/robbyrussell/oh-my-zsh/master/tools/install.sh -O -)"
```
最后，你将看到如下所示的终端：
恭喜，Oh-my-zsh 已安装成功。
#### 主题
安装后，你可以选择主题。我喜欢使用 powerlevel10k。优点之一是它比 powerlevel9k 主题快 100 倍。要安装它，请运行以下命令行：
```
git clone https://github.com/romkatv/powerlevel10k.git ~/.oh-my-zsh/themes/powerlevel10k
```
并在你的 `~/.zshrc` 文件设置 `ZSH_THEME`：
```
ZSH_THEME=powerlevel10k/powerlevel10k
```
关闭终端。再次打开终端时，powerlevel10k 配置向导将询问你几个问题以正确配置提示符。
完成 powerline10k 配置向导后，你的提示符将如下所示：
如果你不喜欢它。你可以随时使用 `p10k configure` 命令来运行 powerline10k 向导。
#### 启用插件
插件存储在 `.oh-my-zsh/plugins` 文件夹中。要激活插件，你需要编辑 `~/.zshrc` 文件。安装插件意味着你创建了一系列执行特定功能的别名或快捷方式。
例如，要启用 firewalld 和 git 插件，请首先编辑 `~/.zshrc`：
```
plugins=(firewalld git)
```
注意：使用空格分隔插件名称列表。
然后重新加载配置：
```
source ~/.zshrc
```
要查看创建的别名，请使用以下命令：
```
alias | grep firewall
```
#### 更多配置
我建议安装语法高亮和语法自动建议插件。
```
git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions
```
将它们添加到文件 `~/.zshrc` 的插件列表中。
```
plugins=( [plugins...] zsh-syntax-highlighting zsh-autosuggestions)
```
重新加载配置。
```
source ~/.zshrc
```
查看结果：
### 彩色的文件夹和图标
`colorls` 是一个 ruby gem，可使用颜色和超棒的字体图标美化终端的 `ls` 命令。你可以访问官方[网站](https://github.com/athityakumar/colorls)以获取更多信息。
因为它是个 ruby gem，所以请按照以下简单步骤操作：
```
sudo gem install colorls
```
要保持最新状态，只需执行以下操作：
```
sudo gem update colorls
```
为防止每次输入 `colorls`，你可以在 `~/.bashrc` 或 `~/.zshrc` 中创建别名。
```
alias ll='colorls -lA --sd --gs --group-directories-first'
alias ls='colorls --group-directories-first'
```
另外，你可以为 `colorls` 的选项启用制表符补完功能，只需在 shell 配置末尾输入以下行：
```
source $(dirname ($gem which colorls))/tab_complete.sh
```
重新加载并查看会发生什么：
---
via: <https://fedoramagazine.org/tuning-your-bash-or-zsh-shell-in-workstation-and-silverblue/>
作者：[George Luiz Maluf](https://fedoramagazine.org/author/georgelmaluf/) 选题：[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/) 荣誉推出
|
确认了！微软 Edge 浏览器将发布 Linux 版
|
Abhishek Prakash
|
https://itsfoss.com/microsoft-edge-linux/
|
微软正在全面重制其 Edge Web 浏览器，它将基于开源 Chromium 浏览器。微软还要将新的 Edge 浏览器带到 Linux 桌面上，但是 Linux 版本可能会有所延迟。
|
/data/attachment/album/201911/11/164600uv7yrbe7gtkxi4xg.jpg.thumb.jpg
|
/data/attachment/album/201911/11/164600uv7yrbe7gtkxi4xg.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Edge"
] |
新闻
|
{
"viewnum": 7918,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11576,
"displayorder": 0
}
] |
微软正在全面重制其 Edge Web 浏览器，它将基于开源 Chromium 浏览器。微软还要将新的 Edge 浏览器带到 Linux 桌面上，但是 Linux 版本可能会有所延迟。
| 2019-11-11T16:47:53 | 2019-11-11T16:47:53 | 11,562 |
/article-11562-1.html
|
>
> 微软正在全面重制其 Edge Web 浏览器，它将基于开源 [Chromium](https://itsfoss.com/install-chromium-ubuntu/) 浏览器。微软还要将新的 Edge 浏览器带到 Linux 桌面上，但是 Linux 版本可能会有所延迟。
>
>
>
微软的 Internet Explorer 曾经一度统治了浏览器市场，但在过去的十年中，它将统治地位丢给了谷歌的 Chrome。
微软试图通过创造 Edge 浏览器来找回失去的位置，Edge 是一种使用 EdgeHTML 和 [Chakra 引擎](https://itsfoss.com/microsoft-chakra-core/)构建的全新 Web 浏览器。它与 Microsoft 的数字助手 [Cortana](https://www.microsoft.com/en-in/windows/cortana) 和 Windows 10 紧密集成。
但是，它仍然无法夺回冠军位置，截至目前，它处于[桌面浏览器使用份额的第四位](https://en.wikipedia.org/wiki/Usage_share_of_web_browsers)。
最近，微软决定通过基于[开源 Chromium 项目](https://www.chromium.org/Home)重新对 Edge 进行大修。谷歌的 Chrome 浏览器也是基于 Chromium 的。[Chromium 还可以作为独立的 Web 浏览器使用](https://itsfoss.com/install-chromium-ubuntu/)，某些 Linux 发行版将其用作默认的 Web 浏览器。
### Linux 上新的微软 Edge Web 浏览器
经过最初的犹豫和不确定性之后，微软似乎最终决定把新的 Edge 浏览器引入到 Linux。
在其年度开发商大会 [Microsoft Ignite](https://www.microsoft.com/en-us/ignite) 中，[关于 Edge 浏览器的演讲](https://myignite.techcommunity.microsoft.com/sessions/79341?source=sessions)中提到了它未来将进入 Linux 中。
新的 Edge 浏览器将于 2020 年 1 月 15 日发布，但我认为 Linux 版本会推迟。
### 微软 Edge 进入 Linux 真的重要吗？
微软 Edge 进入 Linux 有什么大不了的吗？我们又不是没有很多[可用于 Linux 的 Web 浏览器](https://itsfoss.com/open-source-browsers-linux/)？
我认为这与 “微软 Linux 竞争”（如果有这样的事情）有关。微软为 Linux（特别是 Linux 桌面）做的任何事情，都会成为新闻。
我还认为 Linux 上的 Edge 对于微软和 Linux 用户都有好处。这就是为什么。
#### 对于微软有什么用？
当谷歌在 2008 年推出其 Chrome 浏览器时，没有人想到它会在短短几年内占领市场。但是，为什么作为一个搜索引擎会在一个“免费的 Web 浏览器”后面投入如此多的精力呢？
答案是谷歌是一家搜索引擎，它希望有更多的人使用其搜索引擎和其他服务，以便它可以从广告服务中获得收入。使用 Chrome，Google 是默认的搜索引擎。在 Firefox 和 Safari 等其他浏览器上，谷歌支付了数亿美元作为默认 Web 浏览器的费用。如果没有 Chrome，则谷歌必须完全依赖其他浏览器。
微软也有一个名为 Bing 的搜索引擎。Internet Explorer 和 Edge 使用 Bing 作为默认搜索引擎。如果更多用户使用 Edge，它可以增加将更多用户带到 Bing 的机会。而微软显然希望拥有更多的 Bing 用户。
#### 对 Linux 用户有什么用？
对于 Linux 桌面用户，我看到有两个好处。借助 Edge，你可以在 Linux 上使用某些微软特定的产品。 例如，微软的流式游戏服务 [xCloud](https://www.pocket-lint.com/games/news/147429-what-is-xbox-project-xcloud-cloud-gaming-service-price-release-date-devices) 可能仅能在 Edge 浏览器上使用。另一个好处是提升了 [Linux 上的 Netflix 体验](https://itsfoss.com/watch-netflix-in-ubuntu-linux/)。当然，你可以在 Linux 上使用 Chrome 或 [Firefox 观看 Netflix](https://itsfoss.com/netflix-firefox-linux/)，但可能无法获得全高清或超高清流。
据我所知，[全高清和超高清 Netflix 流仅在微软 Edge 上可用](https://help.netflix.com/en/node/23742)。这意味着你可以使用 Linux 上的 Edge 以高清格式享受 Netflix。
### 你怎么看？
你对微软 Edge 进入 Linux 有什么感觉？当 Linux 版本可用时，你会使用吗？请在下面的评论部分中分享你的观点。
---
via: <https://itsfoss.com/microsoft-edge-linux/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[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/) 荣誉推出
|
酌一杯云之酒，以开源佐之 ——专访灵雀云陈恺
|
老王
|
陈恺给我的感觉如同多年的老友一样言无不尽，而他对于我提到的每个话题，都非常认真、仔细的做了阐述，让人感到浓浓的专业技术风格。我想，这就是陈恺的技术初心，也是灵雀云一直以来的风格吧。
|
/data/attachment/album/201911/11/212652is95t99bz659m9l5.jpeg.thumb.jpg
|
/data/attachment/album/201911/11/212652is95t99bz659m9l5.jpeg
| true | false | false | true |
[
"灵雀云"
] |
穿山甲专访
|
{
"viewnum": 8108,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
陈恺给我的感觉如同多年的老友一样言无不尽，而他对于我提到的每个话题，都非常认真、仔细的做了阐述，让人感到浓浓的专业技术风格。我想，这就是陈恺的技术初心，也是灵雀云一直以来的风格吧。
| 2019-11-11T22:20:00 | 2019-11-11T22:20:00 | 11,563 |
/article-11563-1.html
|
>
> 在云原生技术实践峰会召开前夕，匆匆奔赴北京的我，见到了刚刚从美国飞回来，却毫无时差之扰的陈恺——灵雀云的 CTO。
>
>
>
虽然我早就和灵雀云有了联系，也有好几位朋友在灵雀云任职，不过作为国内新锐云原生厂商灵雀云的创始人之一的陈恺，我之前并没有直接接触过。虽然我们是初次相识，但是在聊到了开源，聊到云技术，我们以云做老酒，以开源为佐酒菜，很快就俨然如同老友般进入了旁若无人的状态——旁边的朋友被我们暂时性忽视了，虽然这张合影就是她帮我们照的。 :D
滥觞始于云计算。
### 缘起
陈恺和左玥等人在创立灵雀云之前，他们都曾在微软 Azure 从事云计算领域的专业研究。回忆起那时候，陈恺说，那时他们也在想象云里面的应用应该长什么样子，设计最早版本的“云服务模型”、“云服务运行时”，而现在回过头看，其实云计算的发展已经千差万别。
2013 年 Docker 出现以后，左玥和陈恺他们第一时间就意识到容器技术会很有影响力，它重新了定义云技术之后发展的路径，这恍然在他们面前掀开了一个新的时代，于是灵雀云诞生了。
云技术领域发展演变的非常快，事实上，在云计算早期并不能预见到如今的云计算格局。“早期我们尝试过很多东西，总的想法是觉得容器就像是一种轻量级虚拟机，一种新的虚拟化技术。就像虚拟机需要虚拟机平台去作为它的管理平台一样，容器也需要一个容器云平台，所以我们早期想做的就是容器云平台，这一点一直没变，现在也是在做企业级的容器平台。”陈恺说，“我们最早的技术选型是 Mesos 技术栈，经历了几次大的改变，包括从 Mesos 转到支持当时的三种主流的调度系统，然后开始倾向于Kubernetes，到最后全面转向 Kubernetes，以及最近在架构上和 Kubernetes全面对齐，把我们的平台做成一个 Kubernetes 原生的平台，技术上一直在做升级。”
### 云原生吞噬一切，Kubernetes 编排一切
不知不觉之间，云原生已经吞噬了整个世界，如今，云原生已经是技术界最时髦的词汇之一。而应运而生并推动了这一切发生的云原生计算基金会（CNCF）也在不同的时期、不同的场所，对云原生做了不同角度的解读。那么作为一家很早就涉入云计算领域的新锐力量，陈恺对云原生的理解是什么呢？
陈恺说，“CNCF 旗下涵盖这么多云计算的技术、产品和服务，所以它对‘云原生’的定义必然会比较宽泛，但的确，‘云原生’不是一个特定的技术或者一种方法，很难把它精确的定义，也不应该把它和具体的技术对等，比如说把它直接跟 Kubernetes 挂钩，跟 Kubernetes 没关系就不是云原生？跟 Kubernetes 有关系就叫云原生？这两者都是不对的。”
他接着补充说，“我对云原生定义的观点也是比较宽泛的，（云原生）就是**让应用能够最大化的释放云计算生产力的一系列的思维方式、最佳实践和技术体系**，这里的关键词是**让应用去释放云计算最大的生产力**。这是关键。所有的云原生我觉得都是首先应该围绕应用的。什么叫‘云原生’？主要是以应用为中心的。‘原生’这个名字看起来起的不是很好，听上去似乎是只有在云上生出来的才叫‘云原生’，或者只有在公有云上才叫‘云原生’，并不是。关键不是说你在哪里跑你的应用，而是你是不是能够释放云的生产力——广义的云的生产力。”
在容器编排市场尚三分天下的时候，很多容器服务商都同时支持三种主流的编排系统，当时有一些观点认为这种三分格局会持续比较久，然而 Kubernetes 迅速崛起，很快就一家独大地统治了容器编排市场。
陈恺说，“我觉得当时 Kubernetes 可以很快的从编排之争当中胜出，并没有那么让人吃惊。为什么我们比较早的时候就开始往 Kubernetes 发力？其实第一个触发的点比较偶然。那时经常会有人问起三种容器编排系统各自的优势是什么？我们做了一些研究，业界有一些对比，当时我印象比较深的是一个细节，我觉得这才是关键——有一项对比的是基于这三种技术有哪些商业版？基于 Docker Swarm 的有一个商业版 Docker EE；Mesos 有一个商业版 MesosPhere；基于 Kubernetes 有**好多**商业版——这是本质的区别。这一点对它们的社区的发展速度和后续影响很广，因为它是开放式的治理。Kubernetes 虽然是谷歌发明的，但是它是开放式治理，背后有很多商业版。如果从开源软件本身社区发展角度看，很关键一点是上面有多少商业版，商业版越多说明从开源软件里面可以获利的公司越多，这样就有了正向的良性循环，会有更多资源投进来，社区里面参与的人就会更多，最后的发展会更好，生态会很繁荣。当时从这一点我们就觉得这个生态肯定会赢。”
Kubernetes 一统容器编排市场的今天，业界一些专家对此有所忧虑，担心这种垄断会形成市场压制。从长期来看，如果 Kubernetes 的发展会形成类似 Android 一样的巨头化，那么作为下游厂商，灵雀云是如何看待和应对这种发展变化的呢？
陈恺说，“回到垄断这个问题，如果是商业软件的话会有垄断这个问题，如果是开源软件的话，它的治理模式有可能是封闭式的，也有可能是开放式的，而 Kubernetes 是一个开放式的治理模式，会有一些厂商有更大的影响力，但不是被一家完全控制，所以我觉得从这个角度来说，谈不上垄断，更多的是一个标准。它可能更多像 Linux 而不像是 Android。从标准的角度来说，肯定是利大于弊，而且是远大于弊。因为有了标准，大家都围绕着标准做投入，风险就大大降低，可以放心去投入，也就会有越来越多的技术厂商会向它靠拢。”
### 灵雀云的 Kubernetes 生态
灵雀云在围绕 Kubernetes 生态方面也做了自己的发行版，他们是如何在符合 Kubernetes 标准的基础上形成差异化的服务和产品的呢？
“Kubernetes 发行版首先必须是跟 Kubernetes 兼容的。在 Kubernetes 上可以增加各种各样的能力，但它本身的第一属性一定是一个真正的 Kubernetes。如果为了做差异性，把它做得不像 Kubernetes，不兼容会是个很大的问题。”陈恺说，“我们走的比这个更深一步，我们的 ACP 2.0 是把整个平台都做成 Kubernetes 原生的，因为 Kubernetes 本质上是声明式 API 加上基于控制器模型的架构设计范式，容器编排相当于它的一个副产品，是它基于这个架构的一种应用，当然也可以把这种架构应用到对任意资源的编排。前一段时间有一篇很多人转发的《[Kubernetes 编排一切](/article-11565-1.html)》的文章，讲的就是这个事情，它不光可以用来编排容器，可以做各种各样的事情。我很赞同这个观点。”
灵雀云是从 2017 年底的时候决定这样做的，当时的做法是一些新的产品开始在新的架构上做一些实践，比如 DevOps 平台、基于 Istio 的 Service Mesh 等产品，完全基于新的架构来做。今年年初，灵雀云认为所有方面都成熟了：第一，方向肯定没问题，Kubernetes 编排一切；第二，对如何基于 Kubernetes 的架构构建上层产品有了更多的经验和体会。灵雀云于是把以前产品上的所有功能都逐渐迁移到 Kubernetes 原生架构上，重新融合到统一的架构里面，这就是 ACP 2.0。在此之上灵雀云还做了一些差异化。
灵雀云在这里的技术栈分为三层：
最底层的产品是一个 Kubernetes 发行版，Kubernetes 是一个开源的技术，并不是一个平台，大多数企业做不到直接把它当一个平台用。灵雀云的做法是将 Kubernetes 技术变成一个企业就绪的 Kubernetes 发行版。
再往上是 ACP 层，定位是云原生应用赋能平台。包含有三个子产品：容器平台、DevOps 平台和基于 Istio 的 Service Mesh 产品。容器平台和发行版最接近，但对发行版进行了大量扩展，比如在发行版之上增加了多集群管理和企业级多租户。ACP 把单一的 Kubernetes 集群变成企业平台级的产品，经过了三年多 100+ 企业客户生产环境的考验，而且考虑到更多开发者的场景。DevOps 也基于 Kubernetes 原生，用 Kubernetes 去编排所有的工具，定位是一个开放式 DevOps 工具链集成和编排的平台。
在此之上还有一层是灵雀云新的 ACE 3.0，它的定位是一个企业级的 PaaS 平台，或者用现在更时髦的说法，可以称之为企业技术中台，集成了更多企业需要的其他服务，比如第三方的中间件、开发框架等。它是个完整的技术中台，以容器平台为底座，以云原生黄金三角为核心，其他服务在上面做成一个个插件。这部分主要是和生态合作伙伴合作，国内外的一些最优秀的 PaaS 类服务都可以放在里面，为企业提供完整的解决方案。
### 云原生之于微服务和 DevOps
我们知道微服务、DevOps 等模式在云原生概念发展起来之前就已经存在，但是随着云原生的发展，似乎给它们注入了更多的活力。
陈恺认为云原生显著地推动了 DevOps、微服务的发展，对于这一现象他还专门用了一个词汇来形容：**后 Kubernetes**。这是在容器和 Kubernetes 出现之后开始对 DevOps 侧的微服务反过来的助推。
他认为，微服务架构的本质是用运维复杂度为代价去换取敏捷性。企业至少要考虑两件事：第一是否真的有这么高的敏捷性需求，值得用那么大的运维代价去替换，第二，假设你有着敏捷性需求，那么多出来的复杂度怎么办？早期微服务落地会很痛苦，因为大家没有准备好怎么去应付这个复杂度，而且会低估它。这复杂度是未知的，用未知的复杂度去替代已知的复杂度，这通常都是不好的，所以才会有各种各样的治理框架出来。其实它需要底下有一个好的基础设施来支撑它。
容器和微服务天生一对，容器 Kubernetes 的出现，对微服务有非常明显地推动。Kubernetes 作为底层的应用管理平台非常合适，而且很多微服务里面要考虑的与业务无关的能力也可以慢慢推到 Kubernetes 里面去。而进一步，Service Mesh 等其上的技术栈就重新定义了微服务技术栈，微服务治理方式发生了变化，反过来作用到微服务上，形成了新的最佳实践。
因此，要做微服务应该先容器化，才能解决运维复杂度的问题，容器化的服务应该跑在 Kubernetes 之上；如果进一步做服务治理，应该往 Service Mesh 方向走，Service Mesh 是基于 Kubernetes 平台的微服务治理的最佳实践。
云原生之于 DevOps 也是如此。早期大家很多的精力在持续集成上面，比如 Jenkins 最初是作为 CI 工具出现的，而有了容器和 Kubernetes 之后，持续集成变得简化了，最终生成 Docker 镜像就好。重心开始转到部署，转到 CD 上。而且，现在的 DevOps 实践或 CI/CD 通常会把 Kubernetes 作为最重要的部署目标。也就是说CI会围绕容器镜像，CD 会围绕 Kubernetes。这是容器和 Kubernetes 带给 DevOps 的影响，基础设施越强大，对 DevOps、微服务就越有帮助。以 Kubernetes 为核心的基础设施变成新的标准，DevOps 和微服务的一些最佳实践都会围绕它去改变。
### 源于开源，茁壮于开源
云计算构筑在开源之上，灵雀云的基础设施和服务也构建在开源之上，那么灵雀云是如何拥抱开源和贡献开源的？
陈恺说，“有几个开源社区跟我们是非常相关的，最早的时候是 Docker 社区，现在 Kubernetes 则是跟我们关系最大的开源社区。我们核心的产品是容器、DevOps 和微服务三部分。Jenkins、Istio 等相关开源项目是我们的重点，我们非常重视在开源社区的投入。我们的许多工程师会参与其中，对社区进行贡献，也会开源一些项目，我们在一步一步持续地做这件事情。我们首先会选择一些偏底层的技术或者机制，选择那些有足够亮点，真的被需要的项目和技术开源出来。”
目前灵雀云已经开源了的项目，包括基于 OVN 的网络插件 Kube-OVN，它是把 OVN 的网络和 Kubernetes 所集成的网络插件。现在该项目在国内外都受到关注，也有来自外部贡献者参与。另外一个开源的项目叫 Captain，是一个基于 Helm v3 标准的 Kubernetes 控制器，对 Helm 应用分发进行改进。
后续灵雀云还计划将更完整的东西放出来，比如灵雀云的 Kubernetes 发行版，供社区用户用来管理自己的 Kubernetes 平台，可以达到和使用灵雀云产品接近的体验。另外灵雀云也计划将其 ACP 释放社区版或者开源版本出来。陈恺说，“我们很乐意把它开源出来，因为这是一个标准的产品，我们让它较早期的接触更多用户，也能得到更多反馈，甚至吸收一些外部的贡献者参与进来。”
### 尾声
我采访过很多技术领袖和技术专家，不过陈恺的这场采访让我有一点不同的感受。一场对话下来，陈恺给我的感觉如同多年的老友一样言无不尽，而他对于我提到的每个话题，都非常认真、仔细的做了阐述，让人感到浓浓的专业技术风格。我想，这就是陈恺的技术初心，也是灵雀云一直以来的风格吧。
---
>
> 
>
>
> “穿山甲专访”栏目是 Linux 中国社区推出的面向开源界、互联网技术圈的重要领军人物的系列采访，将为大家介绍中国开源领域中一些积极推动开源，谙熟开源思想的技术人，并辨析其思考、挖掘其动因，揭示其背后所发生的事情，为关注开源、有志于开源的企业和技术人标出一条路径。
>
>
> 取名为“穿山甲”寓意有二：取穿山甲挖掘、深入之意来象征技术进步和表征技术领袖的作用；穿山甲是珍稀保护动物，宣传公益。
>
>
>
|
||||
克隆 MAC 地址来绕过强制门户
|
Esteban Wilson
|
https://fedoramagazine.org/cloning-a-mac-address-to-bypass-a-captive-portal/
|
本文向你展示了如何在 Fedora 上使用 NetworkManager 在某些故障情况下让你仍然可以访问互联网。
|
/data/attachment/album/201911/11/234459tiio6ix8sx6pu0o8.jpg.thumb.jpg
|
/data/attachment/album/201911/11/234459tiio6ix8sx6pu0o8.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"MAC"
] |
技术
|
{
"viewnum": 4754,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 10028,
"displayorder": 0
}
] |
本文向你展示了如何在 Fedora 上使用 NetworkManager 在某些故障情况下让你仍然可以访问互联网。
| 2019-11-11T23:44:54 | 2019-11-11T23:44:54 | 11,564 |
/article-11564-1.html
|
如果你曾经在家和办公室之外连接到 WiFi，那么通常会看到一个门户页面。它可能会要求你接受服务条款或其他协议才能访问。但是，当你无法通过这类门户进行连接时会发生什么？本文向你展示了如何在 Fedora 上使用 NetworkManager 在某些故障情况下让你仍然可以访问互联网。
### 强制门户如何工作
强制门户是新设备连接到网络时显示的网页。当用户首次访问互联网时，门户网站会捕获所有网页请求并将其重定向到单个门户页面。
然后，页面要求用户采取一些措施，通常是同意使用政策。用户同意后，他们可以向 RADIUS 或其他类型的身份验证系统进行身份验证。简而言之，强制门户根据设备的 MAC 地址和终端用户接受条款来注册和授权设备。（MAC 地址是附加到任何网络接口的[基于硬件的值](https://en.wikipedia.org/wiki/MAC_address)，例如 WiFi 芯片或卡。）
有时设备无法加载强制门户来进行身份验证和授权以使用 WiFI 接入。这种情况的例子包括移动设备和游戏机（Switch、Playstation 等）。当连接到互联网时，它们通常不会打开强制门户页面。连接到酒店或公共 WiFi 接入点时，你可能会看到这种情况。
不过，你可以在 Fedora 上使用 NetworkManager 来解决这些问题。Fedora 可以使你临时克隆要连接的设备的 MAC 地址，并代表该设备通过强制门户进行身份验证。你需要得到连接设备的 MAC 地址。通常，它被打印在设备上的某个地方并贴上标签。它是一个六字节的十六进制值，因此看起来类似 `4A:1A:4C:B0:38:1F`。通常，你也可以通过设备的内置菜单找到它。
### 使用 NetworkManager 克隆
首先，打开 `nm-connection-editor`，或通过“设置”打开 WiFi 设置。然后，你可以使用 NetworkManager 进行克隆：
* 对于以太网：选择已连接的以太网连接。然后选择 “Ethernet” 选项卡。记录或复制当前的 MAC 地址。在 “<ruby> 克隆 MAC 地址 <rt> Cloned MAC address </rt></ruby>” 字段中输入游戏机或其他设备的 MAC 地址。
* 对于 WiFi：选择 WiFi 配置名。然后选择 “WiFi” 选项卡。记录或复制当前的 MAC 地址。在 “<ruby> 克隆 MAC 地址 <rt> Cloned MAC address </rt></ruby>” 字段中输入游戏机或其他设备的 MAC 地址。
### 启动所需的设备
当 Fedora 系统与以太网或 WiFi 配置连接，克隆的 MAC 地址将用于请求 IP 地址，并加载强制门户。输入所需的凭据和/或选择用户协议。该 MAC 地址将获得授权。
现在，断开 WiF i或以太网配置连接，然后将 Fedora 系统的 MAC 地址更改回其原始值。然后启动游戏机或其他设备。该设备现在应该可以访问互联网了，因为它的网络接口已通过你的 Fedora 系统进行了授权。
不过，这不是 NetworkManager 全部能做的。例如，请参阅[随机化系统硬件地址](/article-10028-1.html)，来获得更好的隐私保护。
---
via: <https://fedoramagazine.org/cloning-a-mac-address-to-bypass-a-captive-portal/>
作者：[Esteban Wilson](https://fedoramagazine.org/author/swilson/) 选题：[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/) 荣誉推出
|
为什么容器和 Kubernetes 有潜力运行一切
|
Scott Mccarty
|
https://opensource.com/article/19/6/kubernetes-potential-run-anything
|
不仅可以部署简单的应用程序，还可以用 Kubernetes 运维器应对第 2 天运营。
|
/data/attachment/album/201911/12/011140mp75sd0ynppd77da.jpg.thumb.jpg
|
/data/attachment/album/201911/12/011140mp75sd0ynppd77da.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Kubernetes"
] |
观点
|
{
"viewnum": 3532,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11011,
"displayorder": 0
},
{
"raid": 11026,
"displayorder": 1
},
{
"raid": 11036,
"displayorder": 2
},
{
"raid": 11101,
"displayorder": 3
},
{
"raid": 11567,
"displayorder": 0
}
] |
不仅可以部署简单的应用程序，还可以用 Kubernetes 运维器应对第 2 天运营。
| 2019-11-12T01:11:50 | 2019-11-12T01:11:50 | 11,565 |
/article-11565-1.html
|
>
> 不仅可以部署简单的应用程序，还可以用 Kubernetes 运维器应对第 2 天运营。
>
>
>
在我的第一篇文章 [为什么说 Kubernetes 是一辆翻斗车](https://opensource.com/article/19/6/kubernetes-dump-truck) 中，我谈到了 Kubernetes 如何在定义、分享和运行应用程序方面很出色，类似于翻斗车在移动垃圾方面很出色。在第二篇中，[如何跨越 Kubernetes 学习曲线](https://opensource.com/article/19/6/kubernetes-learning-curve)，我解释了 Kubernetes 的学习曲线实际上与运行任何生产环境中的应用程序的学习曲线相同，这确实比学习所有传统组件要容易（如负载均衡器、路由器、防火墙、交换机、集群软件、集群文件系统等）。这是 DevOps，是开发人员和运维人员之间的合作，用于指定事物在生产环境中的运行方式，这意味着双方都需要学习。在第三篇 [Kubernetes 基础：首先学习如何使用](https://opensource.com/article/19/6/kubernetes-basics) 中，我重新设计了 Kubernetes 的学习框架，重点是驾驶翻斗车而不是制造或装备翻斗车。在第四篇文章 [帮助你驾驭 Kubernetes 的 4 个工具](https://opensource.com/article/19/6/tools-drive-kubernetes) 中，我分享了我喜爱的工具，这些工具可帮助你在 Kubernetes 中构建应用程序（驾驶翻斗车）。
在这最后一篇文章中，我会分享我为什么对在 Kubernetes 上运行应用程序的未来如此兴奋的原因。
从一开始，Kubernetes 就能够很好地运行基于 Web 的工作负载（容器化的）。Web 服务器、Java 和相关的应用程序服务器（PHP、Python等）之类的工作负载都可以正常工作。该平台处理诸如 DNS、负载平衡和 SSH（由 `kubectl exec` 取代）之类的支持服务。在我的职业生涯的大部分时间里，这些都是我在生产环境中运行的工作负载，因此，我立即意识到，除了 DevOps 之外，除了敏捷之外，使用 Kubernetes 运行生产环境工作负载的强大功能。即使是我们几乎不改变我们的文化习惯，也可以提高效率。调试和退役变得非常容易，而这对于传统 IT 来说是极为困难的。因此，从早期开始，Kubernetes 就用一种单一的配置语言（Kube YAML/Json）为我提供了对生产环境工作负载进行建模所需的所有基本原语。
但是，如果你需要运行具有复制功能的多主 MySQL，会发生什么情况？使用 Galera 的冗余数据呢？你如何进行快照和备份？那么像 SAP 这样复杂的工作呢？使用 Kubernetes，简单的应用程序（Web 服务器等）的第 0 天（部署）相当简单，但是没有解决第 2 天的运营和工作负载。这并不是说，具有复杂工作负载的第 2 天运营要比传统 IT 难解决，而是使用 Kubernetes 并没有使它们变得更容易。每个用户都要设计自己的天才想法来解决这些问题，这基本上是当今的现状。在过去的五年中，我遇到的第一类问题是复杂工作负载的第 2 天操作。（LCTT 译注：在软件生命周期中，第 0 天是指软件的设计阶段；第 1 天是指软件的开发和部署阶段；第 2 天是指生产环境中的软件运维阶段。）
值得庆幸的是，随着 Kubernetes <ruby> 运维器 <rt> Operator </rt></ruby>的出现，这种情况正在改变。随着运维器的出现，我们现在有了一个框架，可以将第 2 天的运维知识汇总到平台中。现在，我们可以应用我在 [Kubernetes 基础：首先学习如何使用](https://opensource.com/article/19/6/kubernetes-basics) 中描述的相同的定义状态、实际状态的方法，现在我们可以定义、自动化和维护各种各样的系统管理任务。
（LCTT 译注： Operator 是 Kubernetes 中的一种可以完成运维工程师的特定工作的组件，业界大多没有翻译这个名词，此处仿运维工程师例首倡翻译为“运维器”。）
我经常将运维器称为“系统管理机器人”，因为它们实质上是在第 2 天的工作中整理出一堆运维知识，该知识涉及<ruby> 主题专家 <rt> Subject Matter Expert </rt></ruby>（SME、例如数据库管理员或系统管理员）针对的工作负载类型（数据库、Web 服务器等），通常会记录在 Wiki 中的某个地方。这些知识放在 Wiki 中的问题是，为了将该知识应用于解决问题，我们需要：
1. 生成事件，通常监控系统会发现故障，然后我们创建故障单
2. SME 人员必须对此问题进行调查，即使这是我们之前见过几百万次的问题
3. SME 人员必须执行该知识（执行备份/还原、配置 Galera 或事务复制等）
通过运维器，所有这些 SME 知识都可以嵌入到单独的容器镜像中，该镜像在有实际工作负荷之前就已部署。 我们部署运维器容器，然后运维器部署和管理一个或多个工作负载实例。然后，我们使用“运维器生命周期管理器”（Katacoda 教程）之类的方法来管理运维器。
因此，随着我们进一步使用 Kubernetes，我们不仅简化了应用程序的部署，而且简化了整个生命周期的管理。运维器还为我们提供了工具，可以管理具有深层配置要求（群集、复制、修复、备份/还原）的非常复杂的有状态应用程序。而且，最好的地方是，构建容器的人员可能是做第 2 天运维的主题专家，因此现在他们可以将这些知识嵌入到操作环境中。
### 本系列的总结
Kubernetes 的未来是光明的，就像之前的虚拟化一样，工作负载的扩展是不可避免的。学习如何驾驭 Kubernetes 可能是开发人员或系统管理员可以对自己的职业发展做出的最大投资。随着工作负载的增多，职业机会也将增加。因此，这是驾驶一辆令人惊叹的 [在移动垃圾时非常优雅的翻斗车](https://opensource.com/article/19/6/kubernetes-dump-truck)……
你可能想在 Twitter 上关注我，我在 [@fatherlinux](https://twitter.com/fatherlinux) 上分享有关此主题的很多内容。
---
via: <https://opensource.com/article/19/6/kubernetes-potential-run-anything>
作者：[Scott McCarty](https://opensource.com/users/fatherlinux) 选题：[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/) 荣誉推出
|
第 0 天/第 1 天/第 2 天：云时代的软件生命周期
|
Wojciech Urbański
|
https://codilime.com/day-0-day-1-day-2-the-software-lifecycle-in-the-cloud-age/
|
在当今的专业 IT 媒体中有一个非常突出的话题，那就是在软件生命周期中的“第 0 天/第 1 天/第 2 天”。
|
/data/attachment/album/201911/12/112035eg1zrhg1abv040aq.jpg.thumb.jpg
|
/data/attachment/album/201911/12/112035eg1zrhg1abv040aq.jpg
| true | false | true |
wxy
| false |
[
"软件开发"
] |
观点
|
{
"viewnum": 2902,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11565,
"displayorder": 0
}
] |
在当今的专业 IT 媒体中有一个非常突出的话题，那就是在软件生命周期中的“第 0 天/第 1 天/第 2 天”。
| 2019-11-12T11:31:54 | 2019-11-12T11:31:54 | 11,567 |
/article-11567-1.html
|
在当今的专业 IT 媒体中有一个非常突出的话题，那就是在软件生命周期中的“第 0 天/第 1 天/第 2 天”。在演讲和会议讲话当中，通常着重于使软件开发过程有效且易于管理，为此，有必要明确定义所使用的概念。通常，如果直观地理解基本术语“<ruby> 第 0 天 <rp> （ </rp> <rt> Day 0 </rt> <rp> ） </rp></ruby>/<ruby> 第 1 天 <rp> （ </rp> <rt> Day 1 </rt> <rp> ） </rp></ruby>/<ruby> 第 2 天 <rp> （ </rp> <rt> Day 2 </rt> <rp> ） </rp></ruby>”，这在谈论软件生命周期时可能会引起一些歧义。因此，我决定更准确地定义它们，以展示软件开发的整个过程以及它们在实际项目中的使用方式。这篇简短的博客文章提供了“天”的定义，这些“天”被理解为软件生命周期的各个阶段。它还描述了云如何改变了有关软件开发和维护过程的传统思维方式。毕竟，正如《[RightScale 2019 云状态报告](https://www.flexera.com/about-us/press-center/rightscale-2019-state-of-the-cloud-report-from-flexera-identifies-cloud-adoption-trends.html)》所确认的那样，我们正处于“云时代”。该报告解释说，有 94％ 的调查受访者正在使用云（私有云或公有云）。因此，闲话少说，让我们探讨一下“天”和云如何结合在一起。
### “天”究竟是什么？
在 IT 中，术语“第 0 天/第 1 天/第 2 天”指的是软件生命周期的不同阶段。用军事术语来说，“第 0 天”是训练的第一天，新兵进入训练阶段。在软件开发中，它代表设计阶段，在此阶段中指定项目需求并确定解决方案的体系结构。
“第 1 天”涉及开发和部署在“第 0 天”阶段设计的软件。在此阶段，我们不仅创建应用程序本身，还创建应用程序的基础设施、网络、外部服务，并实现所有部分的初始配置。
“第 2 天”是产品出厂或交付给客户的时间。在这里，大部分工作都集中在维护、监控和优化系统上。分析系统的行为并做出正确的反应至关重要，因为所产生的反馈循环将一直持续到应用程序生命周期结束为止。
在云时代之前的日子里，这些阶段是分别处理的，彼此之间没有重叠。今天，情况已不再如此。让我们看一下所有这些如何应用于现代应用程序的生命周期。
#### 第 0 天：无聊但必不可少
第 0 天经常被忽略，因为它可能很无聊，但这并不会降低其重要性。成功的软件产品是经过全面规划和设计过程的结果。必须仔细计划系统或应用程序的体系结构以及启动和运行所需的资源（CPU、存储空间、RAM）。其次，你应该定义可衡量的里程碑，以实现项目目标。每个里程碑应有一个准确的日期。这有助于衡量项目的进度，并确定你是否延迟了计划运行。所有项目时间估算都应基于概率，而不仅仅是按最佳情况预估。进行计划时，最好添加缓冲余量，因为意外事件甚至可能使精心策划的计划陷入困境。测试阶段也起着重要的作用，也应该包括在初始项目计划中。这些是基本要求，它们在“云时代”中同以往一样重要。
尽管如此，在计算资源的第 0 天计划中，云还是改变了两件事。由于云可以在项目的任何地方获得不同的资源或新资源（CPU、存储空间、RAM），因此比本地基础设施要容易得多。因此，可以避免在计划阶段犯下的一些错误。另一方面，在计划阶段对特定云供应商的承诺可能会在以后导致供应商锁定。这可能会花费你的金钱，并且需要时间来进行更改，因此选择云供应商时要明智一些。
其次，正如我们当前在向云的迁移中观察到的那样，与运维相关的工作依旧保持不变，但不再专注于基础设施。现在，正是软件在推动着自动化和价值。
#### 第 1 天：实现创意的阶段
对于开发人员和项目负责人而言，第 1 天绝对是最有趣的阶段。最初的设计得以实现，并根据项目的规范创建了基础设施。为了成为真正的云原生，必须遵守最佳实践。可以遵循诸如<ruby> <a href="https://en.wikipedia.org/wiki/Twelve-Factor_App_methodology"> 十二要素应用程序方法 </a> <rp> （ </rp> <rt> Twelve-Factor Apps methodology </rt> <rp> ） </rp></ruby>之类的准则。此外，使用云端意味着你应该遵循重要的 DevOps 惯例：持续集成/持续交付（如果你想了解有关 CI/CD 的更多信息，请参阅我们的[博客文章](https://codilime.com/what-is-ci-cd-all-you-need-to-know/)）。
云为我们带来了从传统方法到软件开发的重要变化：将第一行代码拼凑在一起以进行概念验证后，应用程序即开始运行。你可以从持续集成实践开始，以测试你的应用程序的健全性，但是你很快会让企业迈入到持续交付。在开发应用程序时，我们开始引入一些运维元素，尤其是在使用多个环境的情况下。注意这些运维要素将使维护团队在维护阶段（第 2 天）的工作更加轻松。
在第 1 天期间可以使用几种工具。可以将它们按解决的问题分组。这个列表的顶部应提及“<ruby> 基础设施即代码 <rp> （ </rp> <rt> Infrastructure-as-a-code </rt> <rp> ） </rp></ruby>”（IaaC）。 IaaC 就像应用程序或代码一样管理运维环境。这种方法允许将 DevOps 最佳实践（包括版本控制、虚拟化测试和持续监视）应用于驱动基础设施的代码。这里有很多工具可供我们使用，例如 Terraform、Ansible 或 Puppet 等。第二类工具与容器的自动化部署和管理的容器编排系统有关。Kubernetes 及其实现（例如 Google Kubernetes Engine 和亚马逊的 Elastic Kubernetes Service）至关重要。最后，还有诸如 Jenkins、Zuul 和 CircleCI 之类的 CI/CD 系统，可帮助工程师自动化软件的构建、测试以及交付或部署。
### 第 2 天：日常运维环节
一旦软件准备就绪，它就会上线，客户开始使用它。第 2 天始于此，并引入了包括软件维护和客户支持在内的各个元素。该软件本身将不断发展，以适应不断变化的需求和客户需求。在第 2 天期间，主要重点是建立反馈循环。我们监控该应用程序的工作方式，收集用户反馈并将其发送给开发团队，该团队将在产品中实施该应用程序并发布新版本。军事术语“<ruby> 观察-导向-决定-行动 <rp> （ </rp> <rt> Observe-Orient-Decide-Act </rt> <rp> ） </rp></ruby>”（OODA）恰当地抓住了这一阶段发生的事情。
* 观察：从监视系统获取信息（资源使用情况和指标，应用程序性能监控）。
* 导向：执行问题的根本原因分析。
* 决定：找到解决问题的方法。
* 行动：实施解决方案。
与战斗中一样，该循环不断重复。
监控程序基于<ruby> 服务水平协议 <rp> （ </rp> <rt> Service Level Agreement </rt> <rp> ） </rp></ruby>（SLA）中定义的要求。 SLA 基于<ruby> 服务水平目标 <rp> （ </rp> <rt> Service Level Objectives </rt> <rp> ） </rp></ruby>（SLO），代表我们的<ruby> 服务水平指标 <rp> （ </rp> <rt> Service Level Indicators </rt> <rp> ） </rp></ruby>（SLI）的状态。自动化和监控是解决第 2 天职责的关键。
有几种工具可帮助完成第 2 天的工作。 <ruby> 应用程序性能监控 <rp> （ </rp> <rt> Application Performance Monitoring </rt> <rp> ） </rp></ruby>（APM）类软件可以帮助 IT 管理员监控应用程序性能，从而提供高质量的用户体验。在这里，我们可以点名 Datadog、Dynatrace、SignalFX 或 Nutanix Xi Epoch。 还有一些自动化和编排工具，例如 Ansible 或 Kubernetes，可帮助管理应用程序环境。你可能已经注意到，这些工具的应用与第 1 天的工作重叠。最后，工单系统（例如 Servicedesk 或 Zendesk）可以处理客户服务，使用户可以报告故障以及与他们正在运行的应用程序有关的问题。
### 云将改变游戏规则
在前云时代，这些阶段之间的分隔清晰可见，但是今天，随着云的日常运行，事物在不断变化。使用云和现代软件开发实践，可以更轻松地处理软件生命周期中不断变化的要求。持续集成/持续开发方法使我们能够动态响应客户反馈并实时改进应用程序，而无需等待主要版本进行改进。
基于云和原生云的软件中的 DevOps 实践有助于实现<ruby> 向左移动 <rp> （ </rp> <rt> shift left </rt> <rp> ） </rp></ruby>（LCTT 译注：环节前置的意思），这意味着传统上一直保留到最后的步骤现在可以更快地执行。除此以外，这导致第 1 天和第 2 天现在相互重叠。此外，传统软件开发的最大痛点在于从第 1 天到第 2 天的过渡：从开发人员到运维人员的过渡。现在，DevOps 展示了如何解决此问题：及早启动流程，并使流程一直运行到应用程序生命周期结束。最后但同样重要的是，工具链正在完善，这使得执行第 1 天的任务和适应第 2 天的更改成为可能。 可以根据我们的需求对所使用的工具进行建模，并且过程中涉及的每个人都可以使用同一套工具。
|
||
如何使用 cron 任务在 Linux 中计划和自动化任务
|
Pradeep Kumar
|
https://www.linuxtechi.com/schedule-automate-tasks-linux-cron-jobs/
|
cron 任务用于“自动执行的任务”，它有助于简化重复的、有时是乏味的任务的执行。
|
/data/attachment/album/201911/13/221859va2t4gg0amlgza00.jpg.thumb.jpg
|
/data/attachment/album/201911/13/221859va2t4gg0amlgza00.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"cron"
] |
系统运维
|
{
"viewnum": 8255,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
cron 任务用于“自动执行的任务”，它有助于简化重复的、有时是乏味的任务的执行。
| 2019-11-13T22:19:00 | 2019-11-13T22:19:00 | 11,571 |
/article-11571-1.html
|
有时，你可能需要定期或以预定的时间间隔执行任务。这些任务包括备份数据库、更新系统、执行定期重新引导等。这些任务称为 “cron 任务”。cron 任务用于“自动执行的任务”，它有助于简化重复的、有时是乏味的任务的执行。cron 是一个守护进程，可让你安排这些任务，然后按指定的时间间隔执行这些任务。在本教程中，你将学习如何使用 cron 来安排任务。
### crontab 文件
crontab 即 “cron table”，是一个简单的文本文件，其中包含指定任务执行时间间隔的规则和命令。 crontab 文件分为两类：
1）系统范围的 crontab 文件
这些通常由需要 root 特权的 Linux 服务及关键应用程序使用。系统 crontab 文件位于 `/etc/crontab` 中，并且只能由 root 用户访问和编辑。通常用于配置系统范围的守护进程。`crontab` 文件的看起来类似如下所示：
2）用户创建的 crontab 文件
Linux 用户还可以在 `crontab` 命令的帮助下创建自己的 cron 任务。创建的 cron 任务将以创建它们的用户身份运行。
所有 cron 任务都存储在 `/var/spool/cron`（对于 RHEL 和 CentOS 发行版）和 `/var/spool/cron/crontabs`（对于 Debian 和 Ubuntu 发行版）中，cron 任务使用创建该文件的用户的用户名列出。
cron 守护进程在后台静默地检查 `/etc/crontab` 文件和 `/var/spool/cron` 及 `/etc/cron.d*/` 目录。
`crontab` 命令用于编辑 cron 文件。让我们看一下 crontab 文件的结构。
### crontab 文件剖析
在继续之前，我们要首先探索 crontab 文件的格式。crontab 文件的基本语法包括 5 列，由星号表示，后跟要执行的命令。
```
* * * * * command
```
此格式也可以表示如下：
```
m h d moy dow command
```
或
```
m h d moy dow /path/to/script
```
让我们来解释一下每个条目
* `m`：代表分钟。范围是 0 到 59
* `h`：表示小时，范围是 0 到 23
* `d`：代表一个月中的某天，范围是 1 到 31
* `moy`：这是一年中的月份。范围是 1 到 12
* `dow`：这是星期几。范围是 0 到 6，其中 0 代表星期日
* `command`：这是要执行的命令，例如备份命令、重新启动和复制命令等
### 管理 cron 任务
看完 crontab 文件的结构之后，让我们看看如何创建、编辑和删除 cron 任务。
#### 创建 cron 任务
要以 root 用户身份创建或编辑 cron 任务，请运行以下命令：
```
# crontab -e
```
要为另一个用户创建或安排 cron 任务，请使用以下语法：
```
# crontab -u username -e
```
例如，要以 Pradeep 用户身份运行 cron 任务，请发出以下命令：
```
# crontab -u Pradeep -e
```
如果该 crontab 文件尚不存在，那么你将打开一个空白文本文件。如果该 crontab 文件已经存在，则 `-e` 选项会让你编辑该文件，
#### 列出 crontab 文件
要查看已创建的 cron 任务，只需传递 `-l` 选项：
```
# crontab -l
```
#### 删除 crontab 文件
要删除 cron 任务，只需运行 `crontab -e` 并删除所需的 cron 任务行，然后保存该文件。
要删除所有的 cron 任务，请运行以下命令：
```
# crontab -r
```
然后，让我们看一下安排任务的不同方式。
### 使用 crontab 安排任务示例
如图所示，所有 cron 任务文件都带有<ruby> 释伴 <rt> shebang </rt></ruby>标头。
```
#!/bin/bash
```
这表示你正在使用的 shell，在这种情况下，即 bash shell。
接下来，使用我们之前指定的 cron 任务条目指定要安排任务的时间间隔。
要每天下午 12:30 重启系统，请使用以下语法：
```
30 12 * * * /sbin/reboot
```
要安排在凌晨 4:00 重启，请使用以下语法：
```
0 4 * * * /sbin/reboot
```
注：星号 `*` 用于匹配所有记录。
要每天两次运行脚本（例如，凌晨 4:00 和下午 4:00），请使用以下语法：
```
0 4,16 * * * /path/to/script
```
要安排 cron 任务在每个星期五下午 5:00 运行，请使用以下语法：
```
0 17 * * Fri /path/to/script
```
或
```
0 17 * * * 5 /path/to/script
```
如果你希望每 30 分钟运行一次 cron 任务，请使用：
```
*/30 * * * * /path/to/script
```
要安排 cron 任务每 5 小时运行一次，请运行：
```
* */5 * * * /path/to/script
```
要在选定的日期（例如，星期三和星期五的下午 6:00）运行脚本，请执行以下操作：
```
0 18 * * wed,fri /path/to/script
```
要使用单个 cron 任务运行多个命令，请使用分号分隔任务，例如：
```
* * * * * /path/to/script1 ; /path/to/script2
```
### 使用特殊字符串节省编写 cron 任务的时间
某些 cron 任务可以使用对应于特定时间间隔的特殊字符串轻松配置。例如，
1）`@hourly` 时间戳等效于 `0 * * * *`
它将在每小时的第一分钟执行一次任务。
```
@hourly /path/to/script
```
2）`@daily` 时间戳等效于 `0 0 * * *`
它在每天的第一分钟（午夜）执行任务。它可以在执行日常工作时派上用场。
```
@daily /path/to/script
```
3）`@weekly` 时间戳等效于 `0 0 * * 0`
它在每周的第一分钟执行 cron 任务，一周第一天是从星期日开始的。
```
@weekly /path/to/script
```
3）`@monthly` 时间戳等效于 `0 0 1 * *`
它在每月第一天的第一分钟执行任务。
```
@monthly /path/to/script
```
4）`@yearly` 时间戳等效于 `0 0 1 1 *`
它在每年的第一分钟执行任务，可以用于发送新年问候。
```
@yearly /path/to/script
```
### 限制 crontab
作为 Linux 用户，你可以控制谁有权使用 `crontab` 命令。可以使用 `/etc/cron.deny` 和 `/etc/cron.allow` 文件来控制。默认情况下，只有一个 `/etc/cron.deny` 文件，并且不包含任何条目。要限制用户使用 `crontab` 实用程序，只需将用户的用户名添加到该文件中即可。当用户添加到该文件中，并且该用户尝试运行 `crontab` 命令时，他/她将遇到以下错误。
要允许用户继续使用 `crontab` 实用程序，只需从 `/etc/cron.deny` 文件中删除用户名即可。
如果存在 `/etc/cron.allow` 文件，则仅文件中列出的用户可以访问和使用 `crontab` 实用程序。
如果两个文件都不存在，则只有 root 用户具有使用 `crontab` 命令的特权。
### 备份 crontab 条目
始终建议你备份 crontab 条目。为此，请使用语法：
```
# crontab -l > /path/to/file.txt
```
例如：
```
# crontab -l > /home/james/backup.txt
```
### 检查 cron 日志
cron 日志存储在 `/var/log/cron` 文件中。要查看 cron 日志，请运行以下命令：
```
# cat /var/log/cron
```
要实时查看日志，请使用 `tail` 命令，如下所示：
```
# tail -f /var/log/cron
```
### 总结
在本指南中，你学习了如何创建 cron 任务以自动执行重复性任务，如何备份和查看 cron 日志。我们希望本文提供有关 cron 作业的有用见解。请随时分享你的反馈和意见。
---
via: <https://www.linuxtechi.com/schedule-automate-tasks-linux-cron-jobs/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[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/) 荣誉推出
|
如何在 CentOS 8/RHEL 8 上安装和配置 Nagios Core
|
James Kiarie
|
https://www.linuxtechi.com/install-nagios-core-rhel-8-centos-8/
|
Nagios 是一个自由开源的网络和警报引擎，它用于监控各种设备，例如网络设备和网络中的服务器。
|
/data/attachment/album/201911/13/230150f6q98q96b6ppflqm.jpg.thumb.jpg
|
/data/attachment/album/201911/13/230150f6q98q96b6ppflqm.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Nagios"
] |
系统运维
|
{
"viewnum": 6496,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Nagios 是一个自由开源的网络和警报引擎，它用于监控各种设备，例如网络设备和网络中的服务器。
| 2019-11-13T23:01:25 | 2019-11-13T23:01:25 | 11,572 |
/article-11572-1.html
|
Nagios 是一个自由开源的网络和警报引擎，它用于监控各种设备，例如网络设备和网络中的服务器。它支持 Linux 和 Windows，并提供了直观的 Web 界面，可让你轻松监控网络资源。经过专业配置后，它可以在服务器或网络设备下线或者故障时向你发出邮件警报。在本文中，我们说明了如何在 RHEL 8/CentOS 8 上安装和配置 Nagios Core。
### Nagios Core 的先决条件
在开始之前，请先检查并确保有以下各项：
* RHEL 8/CentOS 8 环境
* 能通过 SSH 访问该环境
* 快速稳定的互联网连接
满足上述要求后，我们开始吧！
### 步骤 1：安装 LAMP
为了使 Nagios 能够按预期工作，你需要安装 LAMP 或其他 Web 软件，因为它们将在浏览器上运行。为此，请执行以下命令：
```
# dnf install httpd mariadb-server php-mysqlnd php-fpm
```
你需要确保 Apache Web 服务器已启动并正在运行。为此，请使用以下命令启用并启动 Apache 服务器：
```
# systemctl start httpd
# systemctl enable httpd
```
检查 Apache 服务器运行状态：
```
# systemctl status httpd
```
接下来，我们需要启用并启动 MariaDB 服务器，运行以下命令：
```
# systemctl start mariadb
# systemctl enable mariadb
```
要检查 MariaDB 状态，请运行：
```
# systemctl status mariadb
```
另外，你可能会考虑加强或保护服务器，使其不容易受到未经授权的访问。要保护服务器，请运行以下命令：
```
# mysql_secure_installation
```
确保为你的 MySQL 实例设置一个强密码。对于后续提示，请输入 “Y” 并按回车。
### 步骤 2：安装必需的软件包
除了安装 LAMP 外，还需要一些其他软件包来安装和正确配置 Nagios。因此，如下所示安装软件包：
```
# dnf install gcc glibc glibc-common wget gd gd-devel perl postfix
```
### 步骤 3：创建 Nagios 用户帐户
接下来，我们需要为 Nagios 用户创建一个用户帐户。为此，请运行以下命令：
```
# adduser nagios
# passwd nagios
```
现在，我们需要为 Nagios 创建一个组，并将 Nagios 用户添加到该组中。
```
# groupadd nagiosxi
```
现在添加 Nagios 用户到组中：
```
# usermod -aG nagiosxi nagios
```
另外，将 Apache 用户添加到 Nagios 组：
```
# usermod -aG nagiosxi apache
```
### 步骤 4：下载并安装 Nagios Core
现在，我们可以继续安装 Nagios Core。Nagios 4.4.5 的最新稳定版本于 2019 年 8 月 19 日发布。但首先，请从它的官方网站下载 Nagios tarball 文件。
要下载 Nagios Core，请首进入 `/tmp` 目录：
```
# cd /tmp
```
接下来下载 tarball 文件：
```
# wget https://assets.nagios.com/downloads/nagioscore/releases/nagios-4.4.5.tar.gz
```
下载完 tarball 文件后，使用以下命令将其解压缩：
```
# tar -xvf nagios-4.4.5.tar.gz
```
接下来，进入未压缩的文件夹：
```
# cd nagios-4.4.5
```
按此顺序运行以下命令：
```
# ./configure --with-command-group=nagcmd
# make all
# make install
# make install-init
# make install-daemoninit
# make install-config
# make install-commandmode
# make install-exfoliation
```
要配置 Apache，请运行以下命令：
```
# make install-webconf
```
### 步骤 5：配置 Apache Web 服务器身份验证
接下来，我们将为用户 `nagiosadmin` 设置身份验证。请注意不要更改该用户名，否则，可能会要求你进一步的配置，这可能很繁琐。
要设置身份验证，请运行以下命令：
```
# htpasswd -c /usr/local/nagios/etc/htpasswd.users nagiosadmin
```
系统将提示你输入 `nagiosadmin` 用户的密码。输入并按要求确认密码。在本教程结束时，你将使用该用户登录 Nagios。
为使更改生效，请重新启动 Web 服务器：
```
# systemctl restart httpd
```
### 步骤 6：下载并安装 Nagios 插件
插件可以扩展 Nagios 服务器的功能。它们将帮助你监控各种服务、网络设备和应用。要下载插件的 tarball 文件，请运行以下命令：
```
# wget https://nagios-plugins.org/download/nagios-plugins-2.2.1.tar.gz
```
接下来，解压 tarball 文件并进入到未压缩的插件文件夹：
```
# tar -xvf nagios-plugins-2.2.1.tar.gz
# cd nagios-plugins-2.2.1
```
要安装插件，请编译源代码，如下所示：
```
# ./configure --with-nagios-user=nagios --with-nagios-group=nagiosxi
# make
# make install
```
### 步骤 7：验证和启动 Nagios
成功安装 Nagios 插件后，验证 Nagios 配置以确保一切良好，并且配置中没有错误：
```
# /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg
```
接下来，启动 Nagios 并验证其状态：
```
# systemctl start nagios
# systemctl status nagios
```
如果系统中有防火墙，那么使用以下命令允许 ”80“ 端口：
```
# firewall-cmd --permanent --add-port=80/tcp# firewall-cmd --reload
```
### 步骤 8：通过 Web 浏览器访问 Nagios 面板
要访问 Nagios，请打开服务器的 IP 地址，如下所示：<http://server-ip/nagios> 。
这将出现一个弹出窗口，提示输入我们在步骤 5 创建的用户名和密码。输入凭据并点击“Sign In”。
这将引导你到 Nagios 面板，如下所示：
我们终于成功地在 CentOS 8 / RHEL 8 上安装和配置了 Nagios Core。欢迎你的反馈。
---
via: <https://www.linuxtechi.com/install-nagios-core-rhel-8-centos-8/>
作者：[James Kiarie](https://www.linuxtechi.com/author/james/) 选题：[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/) 荣誉推出
|
开源与标准：为什么对待专利如此不同？
|
Scott Peterson
|
https://opensource.com/article/19/2/why-patents-treated-differently
|
两者之间的差异对我们如何构建软件开发过程产生了影响。
|
/data/attachment/album/201911/14/134133sotop83i9i08fdhf.jpg.thumb.jpg
|
/data/attachment/album/201911/14/134133sotop83i9i08fdhf.jpg
| true | false | true |
薛亮
| false |
[
"专利"
] |
开源智慧
|
{
"viewnum": 9152,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
两者之间的差异对我们如何构建软件开发过程产生了影响。
| 2019-11-14T13:42:00 | 2019-11-14T13:42:00 | 11,574 |
/article-11574-1.html
|
>
> 两者之间的差异对我们如何构建软件开发过程产生了影响。
>
>
>
制定标准规范和开源软件的开发有许多共同之处：两者都是竞争者可以合作的机制；两者都可以促进互操作性；两者都可用于促进新技术的采用；两者都可用于聚合或协调成熟技术。
一项技术可以同时使用标准和开源：有时一个先于另一个；在其他情况下，它们可以并行进行。它们越来越多地使用类似的工具和流程实践（例如，细粒度版本控制；利用问题跟踪器一起推动某些开发讨论）。
相似程度可能导致过度概括，错误地暗示一切都是可互换的（混合与搭配），在这儿选择一种做法；在那儿将它与一个过程相结合。实际上，获取在一个领域中获得的经验并查看它提供的好处是否可以在其他环境中获得，可能是有价值的。但是，对于某些实践而言，背景更为重要。
虽然有相似之处，但也存在显著差异。在前面的文章《[没有规则的治理：复刻潜力如何帮助项目](https://opensource.com/article/19/1/forking-good)》中，我讨论了在利用<ruby> 复刻 <rp> （ </rp> <rt> forking </rt> <rp> ） </rp></ruby>潜力作为一种可以促进轻量级治理的力量方面，开源软件开发和标准开发治理能力的不同。另一个不同之处在于专利规则的选择。
### 如何对待专利
参与者专利权的处理通常在开源软件开发和标准开发中以不同方式排列。这种差异有一个理由。而且，这种差异会对构建开发过程产生影响。
* 开源：在为开源项目做出贡献时授予的专利许可通常由每个贡献者的贡献确定。
* 标准：参与者在标准制定方面做出的专利承诺通常由整个最终规范确定。
### 开源项目：基于贡献的专利规则
基于贡献的专利规则是什么意思？如果专利所有者提供软件，由于软件添加到项目中，项目软件侵犯了该贡献者拥有的专利，那么贡献者不应该返回来期望获得使用它所贡献的软件的专利许可费。当然，有许多不同的许可文本可以让我们忙于分析每个许可的解释，并讨论情况中的不确定性和细微差别。在另一篇文章中，我在 MIT 许可协议的背景下谈到了这个问题（《[为什么 MIT 的专利许可不讨人喜欢？](/article-9605-1.html)》）。我认为，基本上来说，开源开发中的共同期望就像我上面所描述的那样：当你为开源做出贡献时，你将为你提供的软件提供所有必需的权限，之后你将无法返回来再要求获得使用你所贡献软件的许可费。
### 标准制定：基于标准规范的专利规则
相比之下，在制定标准时，通常会有更高的期望：参与者应对专利做出承诺，这些专利对整个最终规范至关重要，而不仅仅是对其贡献。这些专利承诺并不取决于确定谁对规范提出了什么想法；对于那些参与开发规范的人来说，他们的承诺是整个标准规范。
### 包括在其中的专利
确定相关专利的分析在软件和规范之间也有所不同。软件通常包括与相应的标准规范相比不需要的实现细节；在提供软件时，将包括对这些细节使用任何专利的许可。相反，规范开发的专利承诺仅限于对规范“必要”或“必需”的专利。当然，这取决于规范的内容。对于互操作性标准，规范应仅包括实现互操作性所需的详细级别，从而允许实现细节在标准的竞争性实现之间有所不同。对必要专利的承诺不包括实施细节方面的专利，这些专利可用作竞争优势。
### 专利规则差异的基础
为什么在专利处理方面存在这种差异？鉴于标准和开源软件的开发方式存在差异，这种不同的处理方式很有意义。
更有限的与贡献范围相关的专利符合大多数协作软件开发的渐进式、开放式特性。开源项目经常持续发展，其方向可能会随着时间的推移而演化。虽然可以设置路线图和里程碑并发布快照版本，但这些不太常见，并且比标准项目中常见的范围限制和版本目标具有更少的限制性影响。
可以看出，考虑到标准规范开发结构的差异，标准开发的更高期望值（整个最终规范，不仅仅是贡献）是有意义的。标准规范通常采用具有明确范围的强版本导向演进。规范开发通常适用于特定的快照版本。标准开发活动通常具有一组目标功能（通常在诸如章程之类的文档中表示）。与许多软件开发活动的情况相比，这为可能应用到标准开发活动的技术范围提供了更清晰的公共的进展预期。这种范围的明确性有助于潜在参与者在开始参与时评估参与标准制定项目的专利影响。相比之下，开源软件开发项目更为开放，通常不会排除采用任何特定技术的可能性。
### 对开源项目和标准管理的影响
这些对待专利的不同措施需要不同的项目管理方法。
开源项目通常准备接受来自新贡献者的补丁。贡献者可能会随着时间的推移而来去。一些贡献者留下来。其他人可能会为该项目来解决一个有限的问题。通过软件贡献，可以更容易地了解谁贡献了什么软件，而不是准确理解谁以一种更抽象的方式“参与”。
另一方面，参与标准制定活动通常具有大量的正式手续。而且，在涉及专利承诺时，这种参与的正式性非常重要。当一个人参与该规范的大部分开发时，对最终规范的专利承诺是有意义的。标准制定过程是否可以从提供单一、有限贡献的人那里获得完整的最终规范承诺？重要的是要有一个过程，以便清楚地了解谁参与谁，谁不参与。需要明确参与者以支持来自实际专利所有者的专利承诺，实际专利所有者通常是由坐在桌旁（比喻，尽管这可能涉及实际的谈判桌）的个人所代表的公司。
如何获得基于规范的承诺？软件标准中典型的免许可费专利承诺最常被作为获得标准组织成员资格或负责规范开发的特定委员会成员资格的条件。为了使这一机制发挥作用，成员资格必须是一个定义明确的概念，以便有一个明确的成员资格决策点（即，用于触发专利承诺的明确行动）和承诺的受益人可以依赖的明确的记录文件。除了参与清晰度之外，为了促进持怀疑态度的专利参与者的参与，项目需要具有明确的范围和明确的开始和结束（明确指出专利承诺将适用的“最终规范”）。这种参与模式与典型的开源项目有很大不同，典型的开源项目可能有一个连续的参与，其范围包括维护几个主要的驱动程序到只提交一个补丁。
### 专利政策
虽然我所描述的差异通常是这种情况，但某些特定活动遵循不同模式可能有一些原因。例如，考虑作为标准开发活动附带的参考实现的软件。可能有一个强有力的理由期望参与者对完整的最终参考实施提供承诺，而不仅仅是限定于他们对它的贡献。当然，可能存在其他边缘情况；可能存在严格安排的开源开发；可能会有连续的、随心所欲的规范开发。
标准制定的专利政策可分为合理和非歧视（RAND）或免许可费（RF）：基本上来说，实施标准的专利许可费包括需要交（RAND）或不需要交（RF）。制定与软件相关的标准（本文的重点）更多地使用免许可费政策。关于专利许可费预期问题是许可或承诺范围政策之外的另一个维度。
### 结论
标准的制定和开源软件的开发通常具有不同的参与者专利期望范围（仅限于贡献或整个最终可交付成果）。这些不同的选择基于通常如何进行开发的显著差异，而不是任意差异。
---
作者简介：Scott Peterson 是红帽公司法律团队成员。很久以前，一位工程师就一个叫做 GPL 的奇怪文件向 Scott 征询法律建议，这个致命的问题让 Scott 走上了探索包括技术标准和开源软件在内的协同开发法律问题的纠结之路。
译者简介：薛亮，集慧智佳知识产权咨询公司总监，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
为什么区块链（可能会）来到你身边的物联网
|
Jon Gold
|
https://www.networkworld.com/article/3386881/why-blockchain-might-be-coming-to-an-iot-implementation-near-you.html
|
在物联网应用中实施区块链可能具有挑战性，并且需要对技术有深入的了解。
|
/data/attachment/album/201911/14/161529d3lqtttqvbe2993k.jpg.thumb.jpg
|
/data/attachment/album/201911/14/161529d3lqtttqvbe2993k.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"区块链",
"物联网"
] |
观点
|
{
"viewnum": 3565,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在物联网应用中实施区块链可能具有挑战性，并且需要对技术有深入的了解。
| 2019-11-14T16:15:04 | 2019-11-14T16:15:04 | 11,575 |
/article-11575-1.html
|
各个公司发现，物联网与最近其他许多流行的企业级计算技术有着良好的合作关系，以支持加密货币而闻名的创新的分布式信任系统的区块链也不例外。然而，在物联网应用中实施区块链可能具有挑战性，并且需要对技术有深入的了解。
区块链是一个跟踪各种交易的分布式账本。链上的每个“块”都包含要防止篡改的交易记录或其他数据，并通过加密散列链接到前一个，这意味着对块的任何篡改都将使该链接无效。节点（几乎可以是其中装有 CPU 的任何节点）通过分布式的对等网络进行通信，以共享数据并确保链中数据的有效性。
北卡罗来纳大学格林波若分校的管理学教授 Nir Kshetri 表示，区块链系统之所以有效，是因为所有的块都必须就它们所保护的数据的细节达成一致。如果有人尝试更改给定节点上先前的事务，则存储在网络上的其余数据会回推回来。“数据的旧记录仍然存在，” Kshetri 说。
这是一项强大的安全技术 —— 如果没有坏人成功控制给定区块链上的所有（LCTT 译注：应为“大部分”）节点（[著名的“51％ 攻击”](https://bitcoinist.com/51-percent-attack-hackers-steals-18-million-bitcoin-gold-btg-tokens/)），那么该区块链保护的数据就不会被伪造或以其他方式弄乱。因此，对于在物联网世界某些角落的公司来说，使用区块链是一种有吸引力的选择也就不足为奇了。
物联网安全初创企业 NXMLabs 的首席技术官兼联合创始人 Jay Fallah 认为，除了区块链能够在网络上安全地分发可信信息的能力这一事实之外，部分原因还在于区块链在技术堆栈中的地位。
“区块链站在一个非常有趣的交叉点。在过去的 15 年中，在存储、CPU 等方面，计算技术一直在加速发展，但是直到最近，网络技术并没有发生太大变化。”他说，“ 区块链不是网络技术、不是数据技术，而是二者兼具。”
### 区块链和物联网
区块链作为物联网世界的部分意义取决于你在和谁交谈以及他们在出售什么，但是最接近的概括可能来自企业区块链供应商 Filament 的首席执行官 Allison Clift-Jenning。
她说：“在任何地方，人们都想互相信任，并且用的是非常古老的方式，这通常是进入场景的好地方。”
直接从 Filament 自己的客户群中挑选出来的一个例子是二手车销售。Filament 与“一家主要的底特律汽车制造商”合作，创建了一个受信任的车辆历史平台，该平台基于一种设备，该设备可插入二手车的诊断端口，从那里获取信息，并将该数据写入区块链。像这样，二手车的历史记录就是不可变的，包括它的安全气囊是否曾经打开过，是否被水淹过等等。任何不道德的二手车或不诚实的前车主都无法更改数据，甚至拔掉设备也将意味着记录中存在可疑的空白期。
SAP 物联网高级副总裁兼全球负责人 Elvira Wallis 表示，当今大多数区块链物联网方案都与信任和数据验证有关。
她说：“我们遇到的大多数用例都在项目的跟踪和溯源领域，”她举例说明了高端食品的农场到餐桌跟踪系统，该系统使用安装在板条箱和卡车上的区块链节点，这样就可以为物品在运输基础设施中创建无懈可击的记录。（例如，该牛排在这样的温度下冷藏了多长时间，今天运输了多长时间，等等。）
### 将区块链与物联网一起使用是个好主意吗？
不同的供应商针对不同的用例出售不同的基于区块链的产品，这些产品使用不同的区块链技术实现，其中一些与加密货币中所使用的经典的、线性的、挖矿式交易区块链不太一样。
这意味着你目前需要从供应商那里购买特定功能。451 Research 高级分析师 Csilla Zsigri 表示，很少有客户组织拥有可以实施区块链安全系统的内部专家。
她说，区块链技术的任何智能应用的想法都是发挥其优势，为关键信息创建可信赖的平台。
Zsigri 说：“这就是我真正看到增值的地方，只是增加了一层信任和验证。”
专家们一致认为，尽管相当了解基于区块链的物联网应用程序的基本概念，但它并不适用于每个物联网用例。 将区块链应用于非交易系统（尽管有例外，包括 NXM Labs 的用于物联网设备的基于区块链配置的产品）通常不是正确的举动。
如果不需要在两个不同的参与方之间共享数据，而是简单地将数据从传感器移到后端，那么区块链通常就没有意义，因为它实际上并没有为当前大多数物联网实现中的数据分析增加任何关键的增值。
“今天，我们仍处于区块链的早期拨号时代。”Clift-Jennings 说，“它比典型的数据库要慢，它甚至无法读取，也常常没有查询引擎。从本质上讲，你并没有真正获得隐私。”
---
via: <https://www.networkworld.com/article/3386881/why-blockchain-might-be-coming-to-an-iot-implementation-near-you.html>
作者：[Jon Gold](https://www.networkworld.com/author/Jon-Gold/) 选题：[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：安全杀毒软件 Defender ATP 要出 Linux 版了！
|
Abhishek Prakash
|
https://itsfoss.com/microsoft-defender-atp-linux/
|
微软宣布将于 2020 年将其企业安全产品 Defender 高级威胁防护（ATP）引入 Linux。
|
/data/attachment/album/201911/14/183733rllau7hvkgzkuwgg.jpg.thumb.jpg
|
/data/attachment/album/201911/14/183733rllau7hvkgzkuwgg.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"微软",
"Defender"
] |
新闻
|
{
"viewnum": 5231,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "15.89.167.141",
"message": "Linux需要杀毒软件？",
"username": "来自美国的 Chrome 78.0|Windows 10 用户",
"date": "2019-11-15T09:03:54"
},
{
"postip": "114.92.29.72",
"message": "丰富生态，还是有益的。",
"username": "来自上海的 Chrome 78.0|Mac 10.15 用户",
"date": "2019-11-15T11:01:44"
}
] |
[
{
"raid": 11562,
"displayorder": 0
}
] |
微软宣布将于 2020 年将其企业安全产品 Defender 高级威胁防护（ATP）引入 Linux。
| 2019-11-14T18:38:00 | 2019-11-14T18:38:00 | 11,576 |
/article-11576-1.html
|
>
> 微软宣布将于 2020 年将其企业安全产品 Defender 高级威胁防护（ATP）引入 Linux。
>
>
>
微软的年度开发者大会 Microsoft Ignite 刚刚结束，会上发布了一些与 Linux 有关的重要公告。你可能已经知道[微软将 Edge Web 浏览器引入 Linux](/article-11562-1.html)，而下一个大新闻是微软将 Defender ATP 引入 Linux！
让我们详细介绍一下它是什么，以及微软为何不厌其烦为 Linux 开发某些东西。
### 微软 Defender ATP 是什么？
如果你过去几年使用过 Windows，那么你一定遇到过 Windows Defender。它基本上可以说是微软的防病毒产品，通过检测病毒和恶意软件来提供一定程度的安全性。
微软通过引入 Windows Defender ATP（高级威胁防护）来为其企业用户改进了此功能。Defender ATP 致力于行为分析。它收集使用使用数据并将其存储在同一系统上。但是，当发现行为不一致时，它将数据发送到 Azure 服务（微软的云服务）。在这里，它将收集行为数据和异常信息。
例如，如果你收到一封包含 PDF 附件的电子邮件，你将其打开并打开了命令提示符，Defender ATP 就会注意到此异常行为。我建议[阅读本文以了解有关 Defender 和 Defender ATP 之间的区别的更多信息](https://www.concurrency.com/blog/november-2017/windows-defender-vs-windows-defender-atp)。
现在，这完全是一种企业级产品。在具有成百上千个端点（计算机）的大型企业中，Defender ATP 提供了很好的保护层。IT 管理员可以在其 Azure 实例上集中查看端点的视图，可以分析威胁并采取相应措施。
### 适用于 Linux（和 Mac）的微软 Defender ATP
通常，企业的计算机上装有 Windows，但 Mac 和 Linux 在开发人员中也特别受欢迎。在混合了 Mac 和 Linux 的 Windows 机器环境中，Defender ATP 必须将其服务扩展到这些操作系统，以便它可以为网络上的所有设备提供整体防御。
请注意，微软先是[在 2019 年 3 月将 Windows Defender ATP 更改为微软 Defender ATP](https://www.theregister.co.uk/2019/03/21/microsoft_defender_atp/)，这表明该产品不仅限于 Windows 操作系统。
此后不久微软[宣布推出 Mac 版 Defender ATP](https://techcommunity.microsoft.com/t5/Microsoft-Defender-ATP/Announcing-Microsoft-Defender-ATP-for-Mac/ba-p/378010)。
现在，为了涵盖企业环境中的所有主要操作系统，[微软将于 2020 年将 Defender ATP 引入到 Linux](https://www.zdnet.com/article/microsoft-defender-atp-is-coming-to-linux-in-2020/)。
### Linux 上的微软 Defender ATP 对 Linux 用户有何影响？
由于 Defender ATP 是企业产品，因此我认为你无需为此而烦恼。组织需要保护其端点免受威胁，因此，微软也在改进其产品以使其涵盖 Linux。
对于像你我这样的普通 Linux 用户，这没有任何区别。我不会用它“保护”我的三个 Linux 系统，并为此而向微软付费。
请随时在评论部分中分享你对微软将 Defender ATP 引入 Linux 的看法。
---
via: <https://itsfoss.com/microsoft-defender-atp-linux/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[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/) 荣誉推出
|
如何使用 metaflac 管理音乐标签
|
Chris Hermansen
|
https://opensource.com/article/19/11/metaflac-fix-music-tags
|
使用这个强大的开源工具可以在命令行中纠正音乐标签错误。
|
/data/attachment/album/201911/16/093629njth88bej8ttekh2.jpg.thumb.jpg
|
/data/attachment/album/201911/16/093629njth88bej8ttekh2.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"音乐",
"metaflac"
] |
技术
|
{
"viewnum": 4525,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用这个强大的开源工具可以在命令行中纠正音乐标签错误。
| 2019-11-16T09:36:00 | 2019-11-16T09:36:00 | 11,579 |
/article-11579-1.html
|
>
> 使用这个强大的开源工具可以在命令行中纠正音乐标签错误。
>
>
>
很久以来我就将 CD 翻录到电脑。在此期间，我用过几种不同的翻录工具，观察到每种工具在标记上似乎有不同的做法，特别是在保存哪些音乐元数据上。所谓“观察”，我是指音乐播放器似乎按照有趣的顺序对专辑进行排序，它们将一个目录中的曲目分为两张专辑，或者产生了其他令人沮丧的烦恼。
我还看到有些标签非常不明确，许多音乐播放器和标签编辑器没有显示它们。即使这样，在某些极端情况下，它们仍可以使用这些标签来分类或显示音乐，例如播放器将所有包含 XYZ 标签的音乐文件与不包含该标签的所有文件分离到不同的专辑中。
那么，如果标记应用和音乐播放器没有显示“奇怪”的标记，但是它们受到了某种影响，你该怎么办？
### Metaflac 来拯救！
我一直想要熟悉 [metaflac](https://xiph.org/flac/documentation_tools_metaflac.html)，它是一款开源命令行 [FLAC 文件](https://xiph.org/flac/index.html)元数据编辑器，这是我选择的开源音乐文件格式。并不是说 [EasyTAG](https://wiki.gnome.org/Apps/EasyTAG) 这样出色的标签编辑软件有什么问题，但我想起“如果你手上有个锤子……”这句老话（LCTT 译注：指如果你手上有个锤子，那么所有的东西看起来都像钉子。意指人们惯于用熟悉的方式解决问题，而不管合不合适）。另外，从实际的角度来看，带有 [Armbian](https://www.armbian.com/) 和 [MPD](https://www.musicpd.org/) 的小型专用服务器，音乐存储在本地、运行精简的仅限音乐的无头环境就可以满足我的家庭和办公室的立体音乐的需求，因此命令行元数据管理工具将非常有用。
下面的截图显示了我的长期翻录过程中产生的典型问题：Putumayo 的哥伦比亚音乐汇编显示为两张单独的专辑，一张包含单首曲目，另一张包含其余 11 首：
我使用 `metaflac` 为目录中包含这些曲目的所有 FLAC 文件生成了所有标签的列表：
```
rm -f tags.txt
for f in *.flac; do
echo $f >> tags.txt
metaflac --export-tags-to=tags.tmp "$f"
cat tags.tmp >> tags.txt
rm tags.tmp
done
```
我将其保存为可执行的 shell 脚本（请参阅我的同事 [David Both](https://opensource.com/users/dboth) 关于 Bash shell 脚本的精彩系列专栏文章，[特别是关于循环这章](https://opensource.com/article/19/10/programming-bash-loops)）。基本上，我在这做的是创建一个文件 `tags.txt`，包含文件名（`echo` 命令），后面是它的所有标签，然后是下一个文件名，依此类推。这是结果的前几行：
```
A Guapi.flac
TITLE=A Guapi
ARTIST=Grupo Bahia
ALBUMARTIST=Various Artists
ALBUM=Putumayo Presents: Colombia
DATE=2001
TRACKTOTAL=12
GENRE=Latin Salsa
MUSICBRAINZ_ALBUMARTISTID=89ad4ac3-39f7-470e-963a-56509c546377
MUSICBRAINZ_ALBUMID=6e096386-1655-4781-967d-f4e32defb0a3
MUSICBRAINZ_ARTISTID=2993268d-feb6-4759-b497-a3ef76936671
DISCID=900a920c
ARTISTSORT=Grupo Bahia
MUSICBRAINZ_DISCID=RwEPU0UpVVR9iMP_nJexZjc_JCc-
COMPILATION=1
MUSICBRAINZ_TRACKID=8a067685-8707-48ff-9040-6a4df4d5b0ff
ALBUMARTISTSORT=50 de Joselito, Los
Cumbia Del Caribe.flac
```
经过一番调查，结果发现我同时翻录了很多 Putumayo CD，并且当时我所使用的所有软件似乎给除了一个之外的所有文件加上了 `MUSICBRAINZ_*` 标签。（是 bug 么？大概吧。我在六张专辑中都看到了。）此外，关于有时不寻常的排序，我注意到，`ALBUMARTISTSORT` 标签将西班牙语标题 “Los” 移到了标题的最后面（逗号之后）。
我使用了一个简单的 `awk` 脚本来列出 `tags.txt` 中报告的所有标签：
```
awk -F= 'index($0,"=") > 0 {print $1}' tags.txt | sort -u
```
这会使用 `=` 作为字段分隔符将所有行拆分为字段，并打印包含等号的行的第一个字段。结果通过使用 `sort` 及其 `-u` 标志来传递，从而消除了输出中的所有重复项（请参阅我的同事 Seth Kenlon 的[关于 `sort` 程序的文章](https://opensource.com/article/19/10/get-sorted-sort)）。对于这个 `tags.txt` 文件，输出为：
```
ALBUM
ALBUMARTIST
ALBUMARTISTSORT
ARTIST
ARTISTSORT
COMPILATION
DATE
DISCID
GENRE
MUSICBRAINZ_ALBUMARTISTID
MUSICBRAINZ_ALBUMID
MUSICBRAINZ_ARTISTID
MUSICBRAINZ_DISCID
MUSICBRAINZ_TRACKID
TITLE
TRACKTOTAL
```
研究一会后，我发现 `MUSICBRAINZ_*` 标签出现在除了一个 FLAC 文件之外的所有文件上，因此我使用 `metaflac` 命令删除了这些标签：
```
for f in *.flac; do metaflac --remove-tag MUSICBRAINZ_ALBUMARTISTID "$f"; done
for f in *.flac; do metaflac --remove-tag MUSICBRAINZ_ALBUMID "$f"; done
for f in *.flac; do metaflac --remove-tag MUSICBRAINZ_ARTISTID "$f"; done
for f in *.flac; do metaflac --remove-tag MUSICBRAINZ_DISCID "$f"; done
for f in *.flac; do metaflac --remove-tag MUSICBRAINZ_TRACKID "$f"; done
```
完成后，我可以使用音乐播放器重建 MPD 数据库。结果如下：
完成了，12 首曲目出现在了一张专辑中。
太好了，我很喜欢 `metaflac`。我希望我会更频繁地使用它，因为我会试图去纠正最后一些我弄乱的音乐收藏标签。强烈推荐！
### 关于音乐
我花了几个晚上在 CBC 音乐（CBC 是加拿大的公共广播公司）上收听 Odario Williams 的节目 After Dark。感谢 Odario，我听到了让我非常享受的 [Kevin Fox 的 Songs for Cello and Voice](https://burlingtonpac.ca/events/kevin-fox/)。在这里，他演唱了 Eurythmics 的歌曲 “[Sweet Dreams（Are Made of This）](https://www.youtube.com/watch?v=uyN66XI1zp4)”。
我购买了这张 CD，现在它在我的音乐服务器上，还有组织正确的标签！
---
via: <https://opensource.com/article/19/11/metaflac-fix-music-tags>
作者：[Chris Hermansen](https://opensource.com/users/clhermansen) 选题：[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/) 荣誉推出
|
在 CentOS/RHEL 系统上生成补丁合规报告的 Bash 脚本
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/bash-script-to-generate-patching-compliance-report-on-centos-rhel-systems/
|
补丁合规性报告通常每月创建一次或三个月一次，具体取决于公司的需求。根据你的需要添加 cronjob 来自动执行此功能。
|
/data/attachment/album/201911/16/101428n1nsj74wifp4k1dz.jpg.thumb.jpg
|
/data/attachment/album/201911/16/101428n1nsj74wifp4k1dz.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"补丁"
] |
系统运维
|
{
"viewnum": 8507,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
补丁合规性报告通常每月创建一次或三个月一次，具体取决于公司的需求。根据你的需要添加 cronjob 来自动执行此功能。
| 2019-11-16T10:15:08 | 2019-11-16T10:15:08 | 11,580 |
/article-11580-1.html
|
如果你运行的是大型 Linux 环境，那么你可能已经将 Red Hat 与 Satellite 集成了。如果是的话，你不必担心补丁合规性报告，因为有一种方法可以从 Satellite 服务器导出它。
但是，如果你运行的是没有 Satellite 集成的小型 Red Hat 环境，或者它是 CentOS 系统，那么此脚本将帮助你创建该报告。
补丁合规性报告通常每月创建一次或三个月一次，具体取决于公司的需求。根据你的需要添加 cronjob 来自动执行此功能。
此 [bash 脚本](https://www.2daygeek.com/category/bash-script/) 通常适合于少于 50 个系统运行，但没有限制。
保持系统最新是 Linux 管理员的一项重要任务，它使你的计算机非常稳定和安全。
以下文章可以帮助你了解有关在红帽 （RHEL） 和 CentOS 系统上安装安全修补程序的更多详细信息。
* [如何在 CentOS 或 RHEL 系统上检查可用的安全更新？](/article-10938-1.html)
* [在 RHEL 和 CentOS 系统上安装安全更新的四种方法](https://www.2daygeek.com/install-security-updates-on-redhat-rhel-centos-system/)
* [在 RHEL 和 CentOS 上检查或列出已安装的安全更新的两种方法](/article-10960-1.html)
此教程中包含四个 [shell 脚本](https://www.2daygeek.com/category/shell-script/)，请选择适合你的脚本。
### 方法 1：为 CentOS / RHEL 系统上的安全修补生成补丁合规性报告的 Bash 脚本
此脚本只会生成安全修补合规性报告。它会通过纯文本发送邮件。
```
# vi /opt/scripts/small-scripts/sec-errata.sh
#!/bin/sh
/tmp/sec-up.txt
SUBJECT="Patching Reports on "date""
MESSAGE="/tmp/sec-up.txt"
TO="[email protected]"
echo "+---------------+-----------------------------+" >> $MESSAGE
echo "| Server_Name | Security Errata |" >> $MESSAGE
echo "+---------------+-----------------------------+" >> $MESSAGE
for server in `more /opt/scripts/server.txt`
do
sec=`ssh $server yum updateinfo summary | grep 'Security' | grep -v 'Important|Moderate' | tail -1 | awk '{print $1}'`
echo "$server $sec" >> $MESSAGE
done
echo "+---------------------------------------------+" >> $MESSAGE
mail -s "$SUBJECT" "$TO" < $MESSAGE
```
添加完上面的脚本后运行它。
```
# sh /opt/scripts/small-scripts/sec-errata.sh
```
你会看到下面的输出。
```
# cat /tmp/sec-up.txt
+---------------+-------------------+
| Server_Name | Security Errata |
+---------------+-------------------+
server1
server2
server3 21
server4
+-----------------------------------+
```
添加下面的 cronjob 来每个月得到一份补丁合规性报告。
```
# crontab -e
@monthly /bin/bash /opt/scripts/system-uptime-script-1.sh
```
### 方法 1a：为 CentOS / RHEL 系统上的安全修补生成补丁合规性报告的 Bash 脚本
脚本会为你生成安全修补合规性报告。它会通过 CSV 文件发送邮件。
```
# vi /opt/scripts/small-scripts/sec-errata-1.sh
#!/bin/sh
echo "Server Name, Security Errata" > /tmp/sec-up.csv
for server in `more /opt/scripts/server.txt`
do
sec=`ssh $server yum updateinfo summary | grep 'Security' | grep -v 'Important|Moderate' | tail -1 | awk '{print $1}'`
echo "$server, $sec" >> /tmp/sec-up.csv
done
echo "Patching Report for `date +"%B %Y"`" | mailx -s "Patching Report on `date`" -a /tmp/sec-up.csv [email protected]
rm /tmp/sec-up.csv
```
添加完上面的脚本后运行它。
```
# sh /opt/scripts/small-scripts/sec-errata-1.sh
```
你会看到下面的输出。
### 方法 2：为 CentOS / RHEL 系统上的安全修补、bugfix、增强生成补丁合规性报告的 Bash 脚本
脚本会为你生成安全修补、bugfix、增强的补丁合规性报告。它会通过纯文本发送邮件。
```
# vi /opt/scripts/small-scripts/sec-errata-bugfix-enhancement.sh
#!/bin/sh
/tmp/sec-up.txt
SUBJECT="Patching Reports on "`date`""
MESSAGE="/tmp/sec-up.txt"
TO="[email protected]"
echo "+---------------+-------------------+--------+---------------------+" >> $MESSAGE
echo "| Server_Name | Security Errata | Bugfix | Enhancement |" >> $MESSAGE
echo "+---------------+-------------------+--------+---------------------+" >> $MESSAGE
for server in `more /opt/scripts/server.txt`
do
sec=`ssh $server yum updateinfo summary | grep 'Security' | grep -v 'Important|Moderate' | tail -1 | awk '{print $1}'`
bug=`ssh $server yum updateinfo summary | grep 'Bugfix' | tail -1 | awk '{print $1}'`
enhance=`ssh $server yum updateinfo summary | grep 'Enhancement' | tail -1 | awk '{print $1}'`
echo "$server $sec $bug $enhance" >> $MESSAGE
done
echo "+------------------------------------------------------------------+" >> $MESSAGE
mail -s "$SUBJECT" "$TO" < $MESSAGE
```
添加完上面的脚本后运行它。
```
# sh /opt/scripts/small-scripts/sec-errata-bugfix-enhancement.sh
```
你会看到下面的输出。
```
# cat /tmp/sec-up.txt
+---------------+-------------------+--------+---------------------+
| Server_Name | Security Errata | Bugfix | Enhancement |
+---------------+-------------------+--------+---------------------+
server01 16
server02 5 16
server03 21 266 20
server04 16
+------------------------------------------------------------------+
```
添加下面的 cronjob 来每三个月得到补丁合规性报告。该脚本计划在一月、四月、七月、十月的 1 号运行。
```
# crontab -e
0 0 01 */3 * /bin/bash /opt/scripts/system-uptime-script-1.sh
```
### 方法 2a：为 CentOS / RHEL 系统上的安全修补、bugfix、增强生成补丁合规性报告的 Bash 脚本
脚本会为你生成安全修补、bugfix、增强的补丁合规性报告。它会通过 CSV 文件发送邮件。
```
# vi /opt/scripts/small-scripts/sec-errata-bugfix-enhancement-1.sh
#!/bin/sh
echo "Server Name, Security Errata,Bugfix,Enhancement" > /tmp/sec-up.csv
for server in `more /opt/scripts/server.txt`
do
sec=`ssh $server yum updateinfo summary | grep 'Security' | grep -v 'Important|Moderate' | tail -1 | awk '{print $1}'`
bug=`ssh $server yum updateinfo summary | grep 'Bugfix' | tail -1 | awk '{print $1}'`
enhance=`ssh $server yum updateinfo summary | grep 'Enhancement' | tail -1 | awk '{print $1}'`
echo "$server,$sec,$bug,$enhance" >> /tmp/sec-up.csv
done
echo "Patching Report for `date +"%B %Y"`" | mailx -s "Patching Report on `date`" -a /tmp/sec-up.csv [email protected]
rm /tmp/sec-up.csv
```
添加完上面的脚本后运行它。
```
# sh /opt/scripts/small-scripts/sec-errata-bugfix-enhancement-1.sh
```
你会看到下面的输出。
---
via: <https://www.2daygeek.com/bash-script-to-generate-patching-compliance-report-on-centos-rhel-systems/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[校对者ID](https://github.com/%E6%A0%A1%E5%AF%B9%E8%80%85ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 autoplank 在多个显示器上使用 Plank 扩展坞
|
Logix
|
https://www.linuxuprising.com/2018/08/use-plank-on-multiple-monitors-without.html
|
autoplank 是用 Go 语言编写的小型工具，它为 Plank 扩展坞增加了多显示器支持，而无需创建多个扩展坞。
|
/data/attachment/album/201911/16/161121nbbncrlxa5s5a5r5.png.thumb.jpg
|
/data/attachment/album/201911/16/161121nbbncrlxa5s5a5r5.png
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Plank"
] |
桌面应用
|
{
"viewnum": 3681,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
autoplank 是用 Go 语言编写的小型工具，它为 Plank 扩展坞增加了多显示器支持，而无需创建多个扩展坞。
| 2019-11-16T16:10:00 | 2019-11-16T16:10:00 | 11,582 |
/article-11582-1.html
|
[autoplank](https://github.com/abiosoft/autoplank) 是用 Go 语言编写的小型工具，它为 Plank 扩展坞增加了多显示器支持，而无需创建[多个](https://answers.launchpad.net/plank/+question/204593)扩展坞。
当你将鼠标光标移动到显示器的底部时，`autoplank` 会使用 `xdotool` 检测到你的鼠标移动，并且自动将 Plank 扩展坞移动到该显示器。该工具仅在将 Plank 设置为在屏幕底部的情况下工作（至少目前如此）。
在 Plank 实际出现在鼠标所在的显示器上前会稍有延迟。开发人员说这是有意设计的，以确保你确实要在该显示器上访问 Plank。显示 Plank 之前的时间延迟目前尚不可配置，但将来可能会改变。
`autoplank` 可以在 elementary OS 以及其它的桌面环境或发行版上使用。
Plank 是一个简单的扩展坞，它显示了正在运行的应用程序/窗口的图标。它允许将应用程序固定到扩展坞，并带有一些内置的简单“扩展组件”：剪贴板管理器、时钟、CPU 监视器、显示桌面和垃圾桶。要访问其设置，请按住 `Ctrl` 键，同时右键单击 Plank 扩展坞上的任意位置，然后单击 “Preferences”。
Plank 默认用在 elementary OS 中，但也可以在任何桌面环境或 Linux 发行版中使用。
### 安装 autoplank
在其 GitHub 页面上，提到你需要 Go 1.8 或更高版本才能构建 `autoplank`，但我能够在 Ubuntu 16.04（elementary OS 0.4 Loki）中使用 Go 1.6 成功构建它。
开发者说：
1、安装所需的依赖项。
要构建 `autoplank`，你需要 Go（在 Debian、Ubuntu、elementary OS 等中使用 golang-go）。要获取最新的 Git 代码，你还需要 `git`，要在显示器上检测你的鼠标移动，还需要安装 `xdotool`。
使用以下命令将它们安装在 Ubuntu、Debian、elementary OS 等中：
```
sudo apt install git golang-go xdotool
```
2、从 [Git](https://github.com/abiosoft/autoplank) 获取最新的 `autoplank`，构建并将其安装在 `/usr/local/bin` 中：
```
git clone https://github.com/abiosoft/autoplank
cd autoplank
go build -o autoplank
sudo mv autoplank /usr/local/bin/
```
你现在可以从主目录中删除 `autoplank` 文件夹。
当你想卸载 `autoplank` 时，只需删除 `/usr/local/bin/autoplank` 二进制文件（`sudo rm /usr/local/bin/autoplank`）。
3、将 `autoplank` 添加到启动中。
如果你想在将 `autoplank` 添加到启动项或为其创建 systemd 服务之前尝试使用 `autoplank`，则只需在终端中键入 `/usr/local/bin/autoplank` 即可启动它。
要使 `autoplank` 在重新启动后起作用，你需要将其添加到启动项中。确切的操作步骤取决于你的桌面环境，因此我不会确切告诉你如何在每个桌面环境中执行此操作，但是请记住在启动项中将 `/usr/local/bin/autoplank` 设置为可执行文件。
在 elementary OS 中，你可以打开“系统设置”，然后在“应用程序”的“启动”选项卡上，单击窗口左下角的“+”按钮，然后在“键入自定义命令”字段中添加 “/usr/local/bin/autoplank”：
如[此处](https://github.com/abiosoft/autoplank#optional-create-a-service)的解释，使用 `autoplank` 的另一种方法是通过为其创建 systemd 服务。将 systemd 服务用于 autoplank 的优点是，无论它出于何种原因而崩溃，都可以重新启动 `autoplank`。可以使用 systemd 服务或将 `autoplank` 添加到启动应用程序中（但不要同时使用两者）。
4、完成此操作后，注销、登录，`autoplank` 应该已在运行，因此你可以将鼠标移至显示器底部以将 Plank 停靠此处。
---
via: <https://www.linuxuprising.com/2018/08/use-plank-on-multiple-monitors-without.html>
作者：[Logix](https://plus.google.com/118280394805678839070) 选题：[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/) 荣誉推出
|
红帽对 Zombieload v2 缺陷的应对
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3453596/red-hat-responds-to-zombieload-v2.html
|
红帽呼吁更新 Linux 软件，以解决可能导致数据盗用的英特尔处理器缺陷。
|
/data/attachment/album/201911/16/223222agxrd54xgvaexbrp.jpg.thumb.jpg
|
/data/attachment/album/201911/16/223222agxrd54xgvaexbrp.jpg
| true | false | false |
wxy
| false |
[
"CPU"
] |
技术
|
{
"viewnum": 3001,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
红帽呼吁更新 Linux 软件，以解决可能导致数据盗用的英特尔处理器缺陷。
| 2019-11-17T07:00:00 | 2019-11-17T07:00:00 | 11,583 |
/article-11583-1.html
|
>
> 红帽呼吁更新 Linux 软件，以解决可能导致数据盗用的英特尔处理器缺陷。
>
>
>
前两天公开的三个“常见漏洞和披露”（CVE）跟踪的是某些英特尔处理器中的三个漏洞，如果利用这些漏洞，可能会使敏感数据面临风险。
在报告的缺陷中，新发现的英特尔处理器缺陷是今年早些时候发现的 Zombieload 攻击的变种，并且仅会影响英特尔的 Cascade Lake 芯片。
红帽强烈建议，所有的红帽系统即使不认为其配置构成直接威胁，也要对其进行更新，并且红帽正在向其客户和企业 IT 社区提供资源。
这三个 CVE 是：
* CVE-2018-12207：页面大小更改时的机器检查错误
* CVE-2019-11135：TSX异步中止
* CVE-2019-0155 和 CVE-2019-0154：i915 图形驱动程序
### CVE-2018-12207
红帽将该漏洞评为重要。此漏洞可能使本地和非特权的攻击者绕过安全控制并导致系统范围的拒绝服务。
硬件缺陷是在英特尔微处理器中发现的，并且与指令翻译后备缓冲区（ITLB）有关。它缓存从虚拟地址到物理地址的转换，旨在提高性能。但是，在缓存页面更改后，使缓存的条目无效的延迟可能导致处理器使用无效的地址转换，从而导致机器检查错误异常并使系统进入挂起状态。
攻击者可以制作这种情况来关闭系统。
### CVE-2019-11135
红帽将此漏洞评为中级。这个事务同步扩展（TSX）异步中止是一个微体系结构数据采样（MDS）缺陷。使用定制代码的本地攻击者可以利用此漏洞从处理器以及支持同时多线程（SMT）和 TSX 的处理器上的缓存内容中收集信息。
### CVE-2019-0155，CVE-2019-0154
红帽将 CVE-2019-0155 漏洞评为重要，将 CVE-2019-0154 漏洞评为中级。这两个缺陷都与 i915 图形驱动程序有关。
CVE-2019-0155 允许攻击者绕过常规的内存安全限制，从而允许对应该受到限制的特权内存进行写访问。
当图形处理单元（GPU）处于低功耗模式时，CVE-2019-0154 可能允许本地攻击者创建无效的系统状态，从而导致系统无法访问。
唯一受 CVE-2019-0154 影响的的显卡在 i915 内核模块上受到影响。`lsmod` 命令可用于指示该漏洞。 如下所示的任何输出（即以 i915 开头）都表明该系统易受攻击：
```
$ lsmod | grep ^i915
i915 2248704 10
```
### 更多资源
红帽在以下链接中向其客户和其他人提供了详细信息和进一步的说明：
* <https://access.redhat.com/security/vulnerabilities/ifu-page-mce>
* <https://access.redhat.com/solutions/tsx-asynchronousabort>
* <https://access.redhat.com/solutions/i915-graphics>
---
via: <https://www.networkworld.com/article/3453596/red-hat-responds-to-zombieload-v2.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[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 桌面添加用户
|
Alan Formy-duval
|
https://opensource.com/article/19/11/add-user-gui-linux
|
无论是在安装过程中还是在桌面中，通过图形界面管理用户都非常容易。
|
/data/attachment/album/201911/16/232237po6ntnrnj40jjtk4.jpg.thumb.jpg
|
/data/attachment/album/201911/16/232237po6ntnrnj40jjtk4.jpg
| true | false | false |
geekpi
| false |
[
"用户"
] |
桌面应用
|
{
"viewnum": 7059,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
无论是在安装过程中还是在桌面中，通过图形界面管理用户都非常容易。
| 2019-11-17T07:05:00 | 2019-11-17T07:05:00 | 11,584 |
/article-11584-1.html
|
>
> 无论是在安装过程中还是在桌面中，通过图形界面管理用户都非常容易。
>
>
>
添加用户是你在一个新系统上要做的第一件事。而且，你通常需要在计算机的整个生命周期中管理用户。
我的关于 [useradd 命令](https://opensource.com/article/19/10/linux-useradd-command)文章提供了更深入的对 Linux 的用户管理的了解。`useradd` 是一个命令行工具，但是你也可以在 Linux 上以图形方式管理用户。这就是本文的主题。
### 在 Linux 安装过程中添加用户
大多数 Linux 发行版都提供了在安装过程中创建用户的步骤。例如，Fedora 30 安装程序 Anaconda 创建标准的 `root` 用户和另一个本地用户帐户。在安装过程中进入“配置”页面时，单击“用户设置”下的“用户创建”。
在用户创建页面上，输入用户的详细信息：全名、用户名和密码。你还可以选择是否使用户成为管理员。
点击“高级”按钮打开“高级用户配置”页面。如果需要除默认设置以外的其他设置，那么可以在此处指定主目录的路径以及用户和组 ID。你也可以输入用户所属的其他组。
### 在 Linux 桌面上添加用户
#### GNOME
许多 Linux 发行版都使用 GNOME 桌面。以下截图来自 Red Hat Enterprise Linux 8.0，但是在其他发行版（如 Fedora、Ubuntu 或 Debian）中，该过程相似。
首先打开“设置”。然后打开“详细”，选择“用户”，单击“解锁”，然后输入密码（除非你已经以 root 用户登录）。这样将用“添加用户”按钮代替“解锁”按钮。
现在，你可以通过单击“添加用户”，然后选择“帐户类型”然后输入“用户名”和“密码”来添加用户。
在下面的截图中，已经输入了用户名，设置保留为默认设置。我不必输入“用户名”，因为它是在我在“全名”字段中输入时自动创建的。如果你不喜欢自动补全，你仍然可以对其进行修改。
这将为名为 Sonny 的用户创建一个标准帐户。Sonny 首次登录时需要提供密码。
接下来，将显示用户。在此页面可以选择每个用户进行自定义或者删除。例如，你可能想选择一个头像或设置默认语言。
#### KDE
KDE 是另一个流行的 Linux 桌面环境。下面是 Fedora 30 上 KDE Plasma 的截图。你可以看到，在 KDE 中添加用户与在 GNOME 中添加用户非常相似。
### 总结
除 GNOME 和 KDE 外，其他桌面环境和窗口管理器也有图形用户管理工具。无论是在安装时还是安装后，在 Linux 中以图形方式添加用户都是快速简便的。
---
via: <https://opensource.com/article/19/11/add-user-gui-linux>
作者：[Alan Formy-Duval](https://opensource.com/users/alanfdoss) 选题：[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/) 荣誉推出
|
||
为什么我从 Mac 换到了 Linux
|
Matthew Broberg
|
https://opensource.com/article/19/10/why-switch-mac-linux
|
感谢这么多的开源开发人员，日常使用 Linux 比以往任何时候都容易得多。
|
/data/attachment/album/201911/17/203212qes7o7zpeefbpffe.jpg.thumb.jpg
|
/data/attachment/album/201911/17/203212qes7o7zpeefbpffe.jpg
| true | false | false |
wxy
| false |
[
"Mac"
] |
观点
|
{
"viewnum": 9939,
"commentnum": 4,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "117.78.51.235",
"message": "linux可以用了——是这个意思吧？",
"username": "Mr.Wang [Firefox 68.0|Windows 10]",
"date": "2019-11-18T17:41:58"
},
{
"postip": "113.14.187.247",
"message": "好，现在请译者wxy谈谈日常使用Mac而不是Linux的体验：",
"username": "来自广西桂林的 Firefox 70.0|Ubuntu 用户",
"date": "2019-11-19T14:17:12"
},
{
"postip": "114.92.29.72",
"message": "讲真的，说了跟没说一样",
"username": "来自上海的 Chrome 78.0|Mac 10.15 用户",
"date": "2019-11-20T10:12:08"
},
{
"postip": "221.236.99.165",
"message": "戛然而止，极具文学价值",
"username": "来自四川德阳的 Chrome 78.0|Windows 10 用户",
"date": "2020-03-26T09:19:53"
}
] |
[] |
感谢这么多的开源开发人员，日常使用 Linux 比以往任何时候都容易得多。
| 2019-11-18T07:30:00 | 2019-11-18T07:30:00 | 11,586 |
/article-11586-1.html
|
>
> 感谢这么多的开源开发人员，日常使用 Linux 比以往任何时候都容易得多。
>
>
>
自 2004 年开始从事 IT 工作以来，我一直是 Mac 的忠实粉丝。但是几个月前，由于种种原因，我决定将 Linux 用作日常使用的系统。这不是我第一次尝试完全采用 Linux，但是我发现它比以往更加容易。下面是促使我转换的原因。
### 我在个人电脑上的首次 Linux 体验
我记得，我抬头看着投影机，而它和我面面相觑。我们俩都不明白为什么它不显示。VGA 线完全接好了，针脚也没有弯折。我按了我所有想到的可能的按键组合，以向我的笔记本电脑发出信号，想让它克服“舞台恐惧症”。
我在大学里运行 Linux 只是作为实验。而我在 IT 部门的经理是多种口味的倡导者，随着我对桌面支持和编写脚本的信心增强，我想了解更多 Linux 的信息。对我来说，IT 比我的计算机科学学位课程有趣得多，课程的感觉是如此抽象和理论化：“二叉树有啥用？”，我如是想 —— 而我们的系统管理员团队的工作却是如此的真真切切。
这个故事的结尾是，我登录到 Windows 工作站完成了我的课堂演讲，这标志着我将 Linux 作为我的日常操作系统的第一次尝试的终结。我很欣赏 Linux 的灵活性，但是它缺乏兼容性。我偶尔会写个脚本，脚本通过 SSH 连接到一个机器中以运行另一个脚本，但是我对 Linux 的日常使用仅止于此。
### 对 Linux 兼容性的全新印象
几个月前，当我决定再试一次 Linux 时，我曾觉得我遇到更多的兼容性噩梦，但我错了。
安装过程完成后，我立即插入了 USB-C 集线器以了解兼容性到底如何。一切立即工作。连接 HDMI 的超宽显示器作为镜像显示器弹出到我的笔记本电脑屏幕上，我轻松地将其调整为第二台显示器。USB 连接的网络摄像头对我的[在家工作方式](https://opensource.com/article/19/8/rules-remote-work-sanity)至关重要，它可以毫无问题地显示视频。甚至自从我使用 Mac 以来就一直插在集线器的 Mac 充电器可以为我的非常不 Mac 的硬件充电。
我的正面体验可能与 USB-C 的一些更新有关，它在 2018 年得到一些所需的关注，因此才能与其他操作系统的体验相媲美。正如 [Phoronix 解释的那样](https://www.phoronix.com/scan.php?page=news_item&px=Linux-USB-Type-C-Port-DP-Driver)：
>
> “USB Type-C 接口为非 USB 信号提供了‘替代模式’扩展，在规范中该替代模式的最大使用场景是支持 DisplayPort。除此之外，另一个替代模式是支持 Thunderbolt 3。DisplayPort 替代模式支持 4K 甚至 8Kx4K 的视频输出，包括多声道音频。
>
>
> “虽然 USB-C 替代模式和 DisplayPort 已经存在了一段时间，并且在 Windows 上很常见，但是主线 Linux 内核不支持此功能。所幸的是，多亏英特尔，这种情况正在改变。”
>
>
>
而在端口之外，快速浏览一下 [笔记本电脑 Linux](https://www.linux-laptop.net/) 的硬件选择，列出了比我 2000 年代初期所经历的更加完整的选择集。
与我第一次尝试采用 Linux 相比，这已经天差地别，这是我张开双臂欢迎的。
### 突破 Apple 的樊篱
使用 Linux 给我的日常工作流程增加了一些新的麻烦，而我喜欢这种麻烦。
我的 Mac 工作流程是无缝的：早上打开 iPad，写下关于我今天想要做什么的想法，然后开始在 Safari 中阅读一些文章；移到我的 iPhone 上可以继续阅读；然后登录我的 MacBook，这些地方我进行了多年的微调，已经弄清楚了所有这些部分之间的连接方式。键盘快捷键已内置在我的大脑中；用户体验一如既往。简直不要太舒服了。
这种舒适需要付出代价。我基本上忘记了我的环境如何运作的，也无法解答我想解答的问题。我是否自定义了一些 [PLIST 文件](https://fileinfo.com/extension/plist)以获得快捷方式，是不是记得将其签入[我的 dotfiles](https://opensource.com/article/19/3/move-your-dotfiles-version-control) 当中？当 Firefox 的功能更好时，我为何还如此依赖 Safari 和 Chrome？为什么我不使用基于 Android 的手机代替我的 i-系列产品呢？
关于这一点，我经常考虑改用基于 Android 的手机，但是我会失去在所有这些设备之间的连接性以及为这种生态系统设计的一些便利。例如，我将无法在 iPhone 上为 Apple TV 输入搜索内容，也无法与其他用 Apple 的朋友用 AirDrop 共享密码。这些功能是同类设备环境的巨大好处，并且是一项了不起的工程。也就是说，这些便利是被生态系统所困的代价。
我喜欢了解设备的工作方式。我希望能够解释使我的系统变得有趣或容易使用的环境配置，但我也想看看增加一些麻烦对我的观点有什么影响。用 [Marcel Proust](https://www.age-of-the-sage.org/quotations/proust_having_seeing_with_new_eyes.html) 的话来说，“真正的发现之旅不在于寻找新的土地，而在于用新的眼光来看待。”技术的使用是如此的方便，以至于我不再对它的工作原理感到好奇，而 Linux 使我有机会再次有了新的眼光。
### 受你的启发
以上所有内容足以成为探索 Linux 的理由，但我也受到了你的启发。尽管所有操作系统都受到开源社区的欢迎，但 Opensource.com 的作者和读者对 Linux 的喜悦是充满感染力的。它激发了我重新潜入的乐趣，我享受这段旅途的乐趣。
---
via: <https://opensource.com/article/19/10/why-switch-mac-linux>
作者：[Matthew Broberg](https://opensource.com/users/mbbroberg) 选题：[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/) 荣誉推出
|
||
7 个有助于 AI 技术的最佳开源工具
|
Nitin Garg
|
https://opensourceforu.com/2019/11/7-best-open-source-tools-that-will-help-in-ai-technology/
|
人工智能是一种紧跟未来道路的卓越技术。在这个不断发展的时代，它吸引了所有跨国组织的关注。谷歌、IBM、Facebook、亚马逊、微软等业内知名公司不断投资于这种新时代技术。
|
/data/attachment/album/201911/18/100020qccpk635kd5co5xh.jpg.thumb.jpg
|
/data/attachment/album/201911/18/100020qccpk635kd5co5xh.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"AI"
] |
技术
|
{
"viewnum": 4200,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
人工智能是一种紧跟未来道路的卓越技术。在这个不断发展的时代，它吸引了所有跨国组织的关注。谷歌、IBM、Facebook、亚马逊、微软等业内知名公司不断投资于这种新时代技术。
| 2019-11-18T10:00:12 | 2019-11-18T10:00:12 | 11,587 |
/article-11587-1.html
|
>
> 人工智能是一种紧跟未来道路的卓越技术。在这个不断发展的时代，它吸引了所有跨国组织的关注。谷歌、IBM、Facebook、亚马逊、微软等业内知名公司不断投资于这种新时代技术。
>
>
>
预测业务需求需要利用人工智能，并在另一个层面上进行研发。这项先进技术正成为提供超智能解决方案的研发组织不可或缺的一部分。它可以帮助你保持准确性并以更好的结果提高生产率。
AI 开源工具和技术以频繁且准确的结果吸引了每个行业的关注。这些工具可帮助你分析绩效，同时为你带来更大的收益。
无需赘言，这里我们列出了一些最佳的开源工具，来帮助你更好地了解人工智能。
### 1、TensorFlow
TensorFlow 是用于人工智能的开源机器学习框架。它主要是为了进行机器学习和深度学习的研究和生产而开发的。TensorFlow 允许开发者创建数据流的图结构，它会在网络或系统节点中移动，图提供了数据的多维数组或张量。
TensorFlow 是一个出色的工具，它有无数的优势。
* 简化数值计算
* TensorFlow 在多种模型上提供了灵活性。
* TensorFlow 提高了业务效率
* 高度可移植
* 自动区分能力
### 2、Apache SystemML
Apache SystemML 是由 IBM 创建的非常流行的开源机器学习平台，它提供了使用大数据的良好平台。它可以在 Apache Spark 上高效运行，并自动扩展数据，同时确定代码是否可以在磁盘或 Apache Spark 集群上运行。不仅如此，它丰富的功能使其在行业产品中脱颖而出；
* 算法自定义
* 多种执行模式
* 自动优化
它还支持深度学习，让开发者更有效率地实现机器学习代码并优化。
### 3、OpenNN
OpenNN 是用于渐进式分析的开源人工智能神经网络库。它可帮助你使用 C++ 和 Python 开发健壮的模型，它还包含用于处理机器学习解决方案（如预测和分类）的算法和程序。它还涵盖了回归和关联，可提供业界的高性能和技术演化。
它有丰富的功能，如：
* 数字化协助
* 预测分析
* 快速的性能
* 虚拟个人协助
* 语音识别
* 高级分析
它可帮助你设计实现数据挖掘的先进方案，而从取得丰硕结果。
### 4、Caffe
Caffe（快速特征嵌入的卷积结构）是一个开源深度学习框架。它优先考虑速度、模块化和表达式。Caffe 最初由加州大学伯克利分校视觉和学习中心开发，它使用 C++ 编写，带有 Python 接口。能在 Linux、macOS 和 Windows 上顺利运行。
Caffe 中的一些有助于 AI 技术的关键特性。
1. 具有表现力的结构
2. 具有扩展性的代码
3. 大型社区
4. 开发活跃
5. 性能快速
它可以帮助你激发创新，同时引入刺激性增长。充分利用此工具来获得所需的结果。
### 5、Torch
Torch 是一个开源机器学习库，通过提供多种方便的功能，帮助你简化序列化、面向对象编程等复杂任务。它在机器学习项目中提供了最大的灵活性和速度。Torch 使用脚本语言 Lua 编写，底层使用 C 实现。它用于多个组织和研究实验室中。
Torch 有无数的优势，如：
* 快速高效的 GPU 支持
* 线性代数子程序
* 支持 iOS 和 Android 平台
* 数值优化子程序
* N 维数组
### 6、Accord .NET
Accord .NET 是著名的自由开源 AI 开发工具之一。它有一组库，可以用来组合使用 C# 编写的音频和图像处理库。从计算机视觉到计算机听觉、信号处理和统计应用，它可以帮助你构建用于商业用途一切需求。它附带了一套全面的示例应用来快速运行各类库。
你可以使用 Accord .NET 引人注意的功能开发一个高级应用，例如：
* 统计分析
* 数据接入
* 自适应
* 深度学习
* 二阶神经网络学习算法
* 数字协助和多语言
* 语音识别
### 7、Scikit-Learn
Scikit-Learn 是流行的辅助 AI 技术的开源工具之一。它是 Python 中用于机器学习的一个很有价值的库。它包括机器学习和统计建模（包括分类、聚类、回归和降维）等高效工具。
让我们了解下 Scikit-Learn 的更多功能：
* 交叉验证
* 聚类和分类
* 流形学习
* 机器学习
* 虚拟流程自动化
* 工作流自动化
从预处理到模型选择，Scikit-learn 可帮助你处理所有问题。它简化了从数据挖掘到数据分析的所有任务。
### 总结
这些是一些流行的开源 AI 工具，它们提供了全面的功能。在开发新时代应用之前，人们必须选择其中一个工具并做相应的工作。这些工具提供先进的人工智能解决方案，并紧跟最新趋势。
人工智能在全球范围内应用，无处不在。借助 Amazon Alexa、Siri 等应用，AI 为客户提供了很好的用户体验。它在吸引用户关注的行业中具有显著优势。在医疗保健、银行、金融、电子商务等所有行业中，人工智能在促进增长和生产力的同时节省了大量的时间和精力。
选择这些开源工具中的任何一个，获得更好的用户体验和令人难以置信的结果。它将帮助你成长，并在质量和安全性方面获得更好的结果。
---
via: <https://opensourceforu.com/2019/11/7-best-open-source-tools-that-will-help-in-ai-technology/>
作者：[Nitin Garg](https://opensourceforu.com/author/nitin-garg/) 选题：[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/) 荣誉推出
|
如何修复使用 Python ORM 工具 SQLAlchemy 时的常见陷阱
|
Zach Todd
|
https://opensource.com/article/19/9/common-pitfalls-python
|
在使用 SQLAlchemy 时，那些看似很小的选择可能对这种对象关系映射工具包的性能产生重要影响。
|
/data/attachment/album/201911/19/093238t4z4zmrj736mzx2x.jpg.thumb.jpg
|
/data/attachment/album/201911/19/093238t4z4zmrj736mzx2x.jpg
| true | false | true |
lujun9972
|
MjSeven
|
wxy
| false |
[
"ORM"
] |
软件开发
|
{
"viewnum": 3394,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在使用 SQLAlchemy 时，那些看似很小的选择可能对这种对象关系映射工具包的性能产生重要影响。
| 2019-11-19T09:32:35 | 2019-11-19T09:32:35 | 11,590 |
/article-11590-1.html
|
>
> 在使用 SQLAlchemy 时，那些看似很小的选择可能对这种对象关系映射工具包的性能产生重要影响。
>
>
>
<ruby> 对象关系映射 <rt> Object-relational mapping </rt></ruby>（[ORM](https://en.wikipedia.org/wiki/Object-relational_mapping)）使应用程序开发人员的工作更轻松，在很大程度是因为它允许你使用你可能知道的语言（例如 Python）与数据库交互，而不是使用原始 SQL 语句查询。[SQLAlchemy](https://www.sqlalchemy.org/) 是一个 Python ORM 工具包，它提供使用 Python 访问 SQL 数据库的功能。它是一个成熟的 ORM 工具，增加了模型关系、强大的查询构造范式、简单的序列化等优点。然而，它的易用性使得人们很容易忘记其背后发生了什么。使用 SQLAlchemy 时做出的看似很小的选择可能产生非常大的性能影响。
本文解释了开发人员在使用 SQLAlchemy 时遇到的一些最重要的性能问题，以及如何解决这些问题。
### 只需要计数但检索整个结果集
有时开发人员只需要一个结果计数，但是没有使用数据库计数功能，而是获取了所有结果，然后使用 Python 中的 `len` 完成计数。
```
count = len(User.query.filter_by(acct_active=True).all())
```
相反，使用 SQLAlchemy 的 `count` 方法将在服务器端执行计数，从而减少发送到客户端的数据。在前面的例子中调用 `all()` 也会导致模型对象的实例化，如果有很多数据，那么时间代价可能会非常昂贵。
除非还需要做其他的事情，否则只需使用 `count` 方法：
```
count = User.query.filter_by(acct_active=True).count()
```
### 只需要几列时检索整个模型
在许多情况下，发出查询时只需要几列数据。SQLAlchemy 可以只获取你想要的列，而不是返回整个模型实例。这不仅减少了发送的数据量，还避免了实例化整个对象。使用列数据的元组而不是模型可以快得多。
```
result = User.query.all()
for user in result:
print(user.name, user.email)
```
反之，使用 `with_entities` 方法只选择所需要的内容：
```
result = User.query.with_entities(User.name, User.email).all()
for (username, email) in result:
print(username, email)
```
### 每次循环都更新一个对象
避免使用循环来单独更新集合。虽然数据库可以非常快地执行单个更新，但应用程序和数据库服务器之间的往返时间将快速累加。通常，在合理的情况下争取更少的查询。
```
for user in users_to_update:
user.acct_active = True
db.session.add(user)
```
改用批量更新方法：
```
query = User.query.filter(user.id.in_([user.id for user in users_to_update]))
query.update({"acct_active": True}, synchronize_session=False)
```
### 触发级联删除
ORM 允许在模型关系上进行简单的配置，但是有一些微妙的行为可能会令人吃惊。大多数数据库通过外键和各种级联选项维护关系完整性。SQLAlchemy 允许你使用外键和级联选项定义模型，但是 ORM 具有自己的级联逻辑，可以取代数据库。
考虑以下模型：
```
class Artist(Base):
__tablename__ = "artist"
id = Column(Integer, primary_key=True)
songs = relationship("Song", cascade="all, delete")
class Song(Base):
__tablename__ = "song"
id = Column(Integer, primary_key=True)
artist_id = Column(Integer, ForeignKey("artist.id", ondelete="CASCADE"))
```
删除歌手将导致 ORM 在 `song` 表上发出 `delete` 查询，从而防止由于外键导致的删除操作。这种行为可能会成为复杂关系和大量记录的瓶颈。
请包含 `passive_deletes` 选项，以确保让数据库来管理关系。但是，请确保你的数据库具有此功能。例如，SQLite 默认情况下不管理外键。
```
songs = relationship("Song", cascade all, delete", passive_deletes=True)
```
### 当要使用贪婪加载时，应使用延迟加载
延迟加载是 SQLAlchemy 处理关系的默认方法。从上一个例子构建来看，加载一个歌手时不会同时加载他或她的歌曲。这通常是一个好主意，但是如果总是需要加载某些关系，单独的查询可能会造成浪费。
如果允许以延迟方式加载关系，像 [Marshmallow](https://marshmallow.readthedocs.io/en/stable/) 这样流行的序列化框架可以触发级联查询。
有几种方法可以控制此行为。最简单的方法是通过 relationship 函数本身。
```
songs = relationship("Song", lazy="joined", cascade="all, delete")
```
这将导致一个左连接被添加到任何歌手的查询中，因此，`songs` 集合将立即可用。尽管有更多数据返回给客户端，但往返次数可能会少得多。
SQLAlchemy 为无法采用这种综合方法的情况提供了更细粒度的控制，可以使用 `joinedload()` 函数在每个查询的基础上切换连接的加载。
```
from sqlalchemy.orm import joinedload
artists = Artist.query.options(joinedload(Artist.songs))
print(artists.songs) # Does not incur a roundtrip to load
```
### 使用 ORM 进行批量记录导入
导入成千上万条记录时，构建完整模型实例的开销会成为主要瓶颈。想象一下，从一个文件中加载数千首歌曲记录，其中每首歌曲都先被转换为字典。
```
for song in songs:
db.session.add(Song(`song))
```
相反，绕过 ORM，只使用核心的 SQLAlchemy 参数绑定功能。
```
batch = []
insert_stmt = Song.__table__.insert()
for song in songs:
if len(batch) > 1000:
db.session.execute(insert_stmt, batch)
batch.clear()
batch.append(song)
if batch:
db.session.execute(insert_stmt, batch)
```
请记住，此方法会自然而然地跳过你可能依赖的任何客户端 ORM 逻辑，例如基于 Python 的列默认值。尽管此方法比将对象加载为完整的模型实例要快，但是你的数据库可能具有更快的批量加载方法。例如，PostgreSQL 的 `COPY` 命令为加载大量记录提供了最佳性能。
### 过早调用提交或刷新
在很多情况下，你需要将子记录与其父记录相关联，反之亦然。一种显然的方法是刷新会话，以便为有问题的记录分配一个 ID。
```
artist = Artist(name="Bob Dylan")
song = Song(title="Mr. Tambourine Man")
db.session.add(artist)
db.session.flush()
song.artist_id = artist.id
```
对于每个请求，多次提交或刷新通常是不必要的，也是不可取的。数据库刷新涉及强制在数据库服务器上进行磁盘写入，在大多数情况下，客户端将阻塞，直到服务器确认已写入数据为止。
SQLAlchemy 可以在幕后跟踪关系和管理相关键。
```
artist = Artist(name="Bob Dylan")
song = Song(title="Mr. Tambourine Man")
artist.songs.append(song)
```
### 总结
我希望这一系列常见的陷阱可以帮助你避免这些问题，并使你的应用平稳运行。通常，在诊断性能问题时，测量是关键。大多数数据库都提供性能诊断功能，可以帮助你定位问题，例如 PostgreSQL 的 `pg_stat_statements` 模块。
---
via: <https://opensource.com/article/19/9/common-pitfalls-python>
作者：[Zach Todd](https://opensource.com/users/zchtoddhttps://opensource.com/users/lauren-pritchetthttps://opensource.com/users/liranhaimovitchhttps://opensource.com/users/moshez) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
丢失的开放剪贴画库和新的公共艺术品图书馆 FreeSVG.org 的诞生
|
Seth Kenlon
|
https://opensource.com/article/19/10/how-community-saved-artwork-creative-commons
|
开放剪贴画库兴衰的故事以及一个新的公共艺术品图书馆 FreeSVG.org 的诞生。
|
/data/attachment/album/201911/19/102040imbybpl32vgdibbm.jpg.thumb.jpg
|
/data/attachment/album/201911/19/102040imbybpl32vgdibbm.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"CC0"
] |
观点
|
{
"viewnum": 4891,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
开放剪贴画库兴衰的故事以及一个新的公共艺术品图书馆 FreeSVG.org 的诞生。
| 2019-11-19T10:21:00 | 2019-11-19T10:21:00 | 11,592 |
/article-11592-1.html
|
>
> 开放剪贴画库兴衰的故事以及一个新的公共艺术品图书馆 FreeSVG.org 的诞生。
>
>
>
<ruby> 开放剪贴画库 <rt> Open Clip Art Library </rt></ruby>（OCAL）发布于 2004 年，成为了免费插图的来源，任何人都可以出于任何目的使用它们，而无需注明出处或提供任何回报。针对 1990 年代每个家庭办公室书架上的大量剪贴画 CD 以及由闭源公司和艺术品软件提供的艺术品转储，这个网站是开源世界的回应。
最初，这个剪贴画库主要由一些贡献者提供，但是在 2010 年，它重新打造成了一个全新的交互式网站，可以让任何人使用矢量插图应用程序创建和贡献剪贴画。该网站立即获得了来自全球的、各种形式的自由软件和自由文化项目的贡献。[Inkscape](https://opensource.com/article/18/1/inkscape-absolute-beginners) 中甚至包含了该库的专用导入器。
但是，在 2019 年初，托管开放剪贴画库的网站离线了，没有任何警告或解释。它已经成长为有着成千上万的人的社区，起初以为这是暂时的故障。但是，这个网站一直离线已超过六个月，而没有任何清楚的解释。
谣言开始膨胀。该网站一直在更新中（“要偿还数年的技术债务”，网站开发者 Jon Philips 在一封电子邮件中说）。一个 Twitter 帐户声称，该网站遭受了猖狂的 DDoS 攻击。另一个 Twitter 帐户声称，该网站维护者已经成为身份盗用的牺牲品。今天，在撰写本文时，该网站的一个且唯一的页面声明它处于“维护和保护模式”，其含义不清楚，只是用户无法访问其内容。
### 恢复公地
网站会随着时间的流逝而消失，但是对其社区而言，开放剪贴画库的丢失尤其令人惊讶，因为它被视为一个社区项目。很少有社区成员知道托管该库的网站已经落入单个维护者手中，因此，由于 [CC0 许可证](https://creativecommons.org/share-your-work/public-domain/cc0/)，该库中的艺术品归所有人所有，但对它的访问是由单个维护者功能性拥有的。而且，由于该社区通过网站彼此保持联系，因此该维护者实际上拥有该社区。
当网站发生故障时，社区以及成员彼此之间都无法访问剪贴画。没有该网站，就没有社区。
最初，该网站离线后其上的所有东西都是被封锁的。不过，在几个月之后，用户开始意识到该网站的数据仍然在线，这意味着用户能够通过输入精确的 URL 访问单个剪贴画。换句话说，你不能通过在网站上到处点击来浏览剪贴画文件，但是如果你确切地知道该地址，你就可以在浏览器中访问它。类似的，技术型（或偷懒的）用户意识到能够通过类似 `wget` 的自动 Web 浏览器将网站“抓取”下来。
Linux 的 `wget` 命令从技术上来说是一个 Web 浏览器，虽然它不能让你像用 Firefox 一样交互式地浏览。相反，`wget` 可以连到互联网，获取文件或文件集，并下载到你的本次硬盘。然后，你可以在 Firefox、文本编辑器或最合适的应用程序中打开这些文件，查看内容。
通常，`wget` 需要知道要提取的特定文件。如果你使用的是安装了 `wget` 的 Linux 或 macOS，则可以通过下载 [example.com](http://example.com) 的索引页来尝试此过程：
```
$ wget example.org/index.html
[...]
$ tail index.html
<body><div>
<h1>Example Domain</h1>
<p>This domain is for illustrative examples in documents.
You may use this domain in examples without permission.</p>
<p><a href="http://www.iana.org/domains/example">More info</a></p>
</div></body></html>
```
为了抓取 OCAL，我使用了 `--mirror` 选项，以便可以只是将 `wget` 指向到包含剪贴画的目录，就可以下载该目录中的所有内容。此操作持续下载了连续四天（96 个小时），最终得到了超过 50,000 个社区成员贡献的 100,000 个 SVG 文件。不幸的是，任何没有适当元数据的文件的作者信息都是无法恢复的，因为此信息被锁定在该数据库中不可访问的文件中，但是 CC0 许可证意味着此问题*在技术上*无关紧要（因为 CC0 文件不需要归属）。
随意分析了一下下载的文件进行还显示，其中近 45,000 个文件是同一个文件（该网站的徽标）的副本。这是由于指向该网站徽标的重定向引起的（原因未知），仔细分析能够提取到原始的文件，又过了 96 个小时，并且恢复了直到最后一天发布在 OCAL 上的所有剪贴画：总共约有 156,000 张图像。
SVG 文件通常很小，但这仍然是大量工作，并且会带来一些非常实际的问题。首先，将需要数 GB 的在线存储空间，这样这些剪贴画才能供其先前的社区使用。其次，必须使用一种搜索剪贴画的方法，因为手动浏览 55,000 个文件是不现实的。
很明显，社区真正需要的是一个平台。
### 构建新的平台
一段时间以来，[公共领域矢量图](http://publicdomainvectors.org) 网站一直在发布公共领域的矢量图。虽然它仍然是一个受欢迎的网站，但是开源用户通常只是将其用作辅助的图片资源，因为其中大多数文件都是 EPS 和 AI 格式的，这两者均与 Adobe 相关。这两种文件格式通常都可以转换为 SVG，但是特性会有所损失。
当公共领域矢量图网站的维护者（Vedran 和 Boris）得知 OCAL 丢失时，他们决定创建一个面向开源社区的网站。诚然，他们选择了开源 [Laravel](https://github.com/viralsolani/laravel-adminpanel) 框架作为后端，该框架为网站提供了管理控制台和用户访问权限。该框架功能强大且开发完善，还使他们能够快速响应错误报告和功能请求，并根据需要升级网站。他们正在建立的网站称为 [FreeSVG.org](https://freesvg.org)，已经是一个强大而繁荣的公共艺术品图书馆。
从那时起，他们就一直从 OCAL 上载所有剪贴画，并且他们甚至在努力地对这些剪贴画进行标记和分类。作为公共领域矢量图网站的创建者，他们还以 SVG 格式贡献了自己的图像。他们的目标是成为互联网上具有 CC0 许可证的 SVG 图像的主要资源。
### 贡献
[FreeSVG.org](https://freesvg.org) 的维护者意识到他们已经继承了重要的管理权。他们正在努力对网站上的所有图像加上标题和描述，以便用户可以轻松找到这些剪贴画，并在准备就绪后将其提供给社区，同时坚信同这些剪贴画一样，与这些剪贴画有关的元数据属于创建和使用它们的人。他们还意识到可能会发生无法预料的情况，因此他们会定期为其网站和内容创建备份，并打算在其网站出现故障时向公众提供最新备份。
如果要为 [FreeSVG.org](http://freesvg.org)的知识共享内容添砖加瓦，请下载 [Inkscape](http://inkscape.org) 并开始绘制。世界上有很多公共领域的艺术品，例如[历史广告](https://freesvg.org/drinking-coffee-vector-drawing)、[塔罗牌](https://freesvg.org/king-of-swords-tarot-card)和[故事书](https://freesvg.org/space-pioneers-135-scene-vector-image)，只是在等待转换为 SVG，因此即使你对自己的绘画技巧没有信心你也可以做出贡献。访问 [FreeSVG 论坛](http://forum.freesvg.org/)与其他贡献者联系并支持他们。
*公地*的概念很重要。无论你是学生、老师、图书馆员、小企业主还是首席执行官，[知识共享都会使所有人受益](https://opensource.com/article/18/1/creative-commons-real-world)。如果你不直接捐款，那么你随时可以帮助推广。
这是自由文化的力量：它不仅可以扩展，而且随着更多人的参与，它会变得更好。
### 艰辛的教训
从 OCAL 的消亡到 FreeSVG.org 的兴起，开放文化社区已经吸取了一些艰辛的经验。对于以后，以下是我认为最重要的那些。
#### 维护你的元数据
如果你是内容创建者，请帮助将来的档案管理员，将元数据添加到文件中。大多数图像、音乐、字体和视频文件格式都可以嵌入 EXIF 数据，其他格式在创建它们的应用程序中具有元数据输入界面。勤于用你的姓名、网站或公共电子邮件以及许可证来标记你的作品。
#### 做个副本
不要以为别人在做备份。如果你关心公用数字内容，请自己备份，否则不要指望永远提供它。无论*任何上传到互联网上的内容是永久的*的说法是不是正确的，但这并不意味着你永远可以使用。如果 OCAL 文件不再暗地可用，那么任何人都不太可能成功地从网络上的某个位置或从全球范围内的人们的硬盘中成功地发现全部的 55,000 张图像。
#### 创建外部渠道
如果一个社区是由单个网站或实际位置来定义的，那么该社区失去访问该空间的能力就如同解散了一样。如果你是由单个组织或网站驱动的社区的成员，则你应该自己与关心的人共享联系信息，并即使在该网站不可用时也可以建立沟通渠道。
例如，[Opensource.com](http://Opensource.com) 本身维护其作者和通讯者的邮件列表和其他异地渠道，以便在有或没有网站干预或甚至没有网站的情况下相互交流。
#### 自由文化值得为此努力
互联网有时被视为懒人社交俱乐部。你可以在需要时登录并在感到疲倦时将其关闭，也可以漫步到所需的任何社交圈。
但实际上，自由文化可能是项艰难的工作。但是这种艰难从某种意义上讲并不是说要成为其中的一分子很困难，而是你必须努力维护。如果你忽略你所在的社区，那么该社区可能会在你意识到之前就枯萎并褪色。
花点时间环顾四周，确定你属于哪个社区，如果不是，那么请告诉某人你对他们带给你生活的意义表示赞赏。同样重要的是，请记住，这样你也为社区的生活做出了贡献。
几周前，知识共享组织在华沙举行了它的全球峰会，令人惊叹的国际盛会…
>
> 老王文末感想：刚刚看到这篇文章的英文标题（How I used the wget Linux command to recover lost images）时，我以为这是一篇技术文章，然而翻译校对下来之后，却是一篇披着技术外衣的对自由文化社区的教训和反思。作为一个同样建设公地社区的负责人，我不禁深深地对 “Linux 中国”社区的将来有了忧虑。如何避免 “Linux 中国”也同样陷入这种困境，这是一个问题……
>
>
> 就目前来看，我们需要定期不定期的构建离线归档，也需要以更开放的方式留下现有文章的数据，也欢迎大家来支持和帮助我们。
>
>
> 又及，再给产生这一切的 Linux 中国翻译组织 LCTT 打个招新广告吧，欢迎大家加入： <https://linux.cn/lctt/>
>
>
>
---
via: <https://opensource.com/article/19/10/how-community-saved-artwork-creative-commons>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
PostgreSQL 入门
|
Greg Pittman
|
https://opensource.com/article/19/11/getting-started-postgresql
|
安装、设置、创建和开始使用 PostgreSQL 数据库。
|
/data/attachment/album/201911/20/085936u10q7eme1euu4ak3.jpg.thumb.jpg
|
/data/attachment/album/201911/20/085936u10q7eme1euu4ak3.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"PostgreSQL"
] |
技术
|
{
"viewnum": 5956,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "113.137.58.77",
"message": "PostgreSQL 14.1 版本文档 <a href=\"https://www.rockdata.net/zh-cn/docs/14/\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/14/</a><br />\r\nPostgreSQL 13.1 版本文档 <a href=\"https://www.rockdata.net/zh-cn/docs/13/\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/13/</a><br />\r\nPostgreSQL 12.2 版本文档 <a href=\"https://www.rockdata.net/zh-cn/docs/12/\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/12/</a><br />\r\nPostgreSQL 11.2 版本文档 <a href=\"https://www.rockdata.net/zh-cn/docs/11/\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/11/</a><br />\r\nPostgreSQL 10.1 版本文档 <a href=\"https://www.rockdata.net/zh-cn/docs/10/\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/10/</a>",
"username": "来自陕西咸阳的 Chrome 113.0|Windows 10 用户",
"date": "2023-05-06T10:15:37"
}
] |
[
{
"raid": 11904,
"displayorder": 0
}
] |
安装、设置、创建和开始使用 PostgreSQL 数据库。
| 2019-11-20T09:00:01 | 2019-11-20T09:00:01 | 11,593 |
/article-11593-1.html
|
>
> 安装、设置、创建和开始使用 PostgreSQL 数据库。
>
>
>
每个人或许都有需要在数据库中保存的东西。即使你执着于使用纸质文件或电子文件，它们也会变得很麻烦。纸质文档可能会丢失或混乱，你需要访问的电子信息可能会隐藏在段落和页面的深处。
在我从事医学工作的时候，我使用 [PostgreSQL](https://www.postgresql.org/) 来跟踪我的住院患者名单并提交有关住院患者的信息。我将我的每日患者名单打印在口袋里，以便快速了解患者房间、诊断或其他细节的任何变化并做出快速记录。
我以为一切没问题，直到去年我妻子决定买一辆新车，我“接手”了她以前的那辆车。她保留了汽车维修和保养服务收据的文件夹，但随着时间的流逝，它变得杂乱。与其花时间筛选所有纸条以弄清楚什么时候做了什么，我认为 PostgreSQL 将是更好的跟踪此信息的方法。
### 安装 PostgreSQL
自上次使用 PostgreSQL 以来已经有一段时间了，我已经忘记了如何使用它。实际上，我甚至没有在计算机上安装它。安装它是第一步。我使用 Fedora，因此在控制台中运行：
```
dnf list postgresql*
```
请注意，你无需使用 `sudo` 即可使用 `list` 选项。该命令返回了很长的软件包列表。看了眼后，我决定只需要三个：postgresql、postgresql-server 和 postgresql-docs。
为了了解下一步需要做什么，我决定查看 [PostgreSQL 文档](http://www.postgresql.org/docs)。文档参考内容非常丰富，实际上，丰富到令人生畏。幸运的是，我发现我在升级 Fedora 时曾经做过的一些笔记，希望有效地导出数据库，在新版本上重新启动 PostgreSQL，以及导入旧数据库。
### 设置 PostgreSQL
与大多数其他软件不同，你不能只是安装好 PostgreSQL 就开始使用它。你必须预先执行两个基本步骤：首先，你需要设置 PostgreSQL，第二，你需要启动它。你必须以 `root` 用户身份执行这些操作（`sudo` 在这里不起作用）。
要设置它，请输入：
```
postgresql-setup –initdb
```
这将确定 PostgreSQL 数据库在计算机上的位置。然后（仍为 `root`）输入以下两个命令：
```
systemctl start postgresql.service
systemctl enable postgresql.service
```
第一个命令为当前会话启动 PostgreSQL（如果你关闭机器，那么 PostgreSQL 也将关闭）。第二个命令使 PostgreSQL 在随后的重启中自动启动。
### 创建用户
PostgreSQL 正在运行，但是你仍然不能使用它，因为你还没有用户。为此，你需要切换到特殊用户 `postgres`。当你仍以 `root` 身份运行时，输入：
```
su postgres
```
由于你是以 `root` 的身份执行此操作的，因此无需输入密码。root 用户可以在不知道密码的情况下以任何用户身份操作；这就是使其强大而危险的原因之一。
现在你就是 `postgres` 了，请运行下面两个命令，如下所示创建用户（创建用户 `gregp`）：
```
createuser gregp
createdb gregp
```
你可能会看到错误消息，如：`Could not switch to /home/gregp`。这只是意味着用户 `postgres`不能访问该目录。尽管如此，你的用户和数据库已创建。接下来，输入 `exit` 并按回车两次，这样就回到了原来的用户下（`root`）。
### 设置数据库
要开始使用 PostgreSQL，请在命令行输入 `psql`。你应该在每行左侧看到类似 `gregp=>` 的内容，以显示你使用的是 PostgreSQL，并且只能使用它理解的命令。你自动获得一个数据库（我的名为 `gregp`），它里面完全没有内容。对 PostgreSQL 来说，数据库只是一个工作空间。在空间内，你可以创建*表*。表包含变量列表，而表中的每个变量是构成数据库的数据。
以下是我设置汽车服务数据库的方式：
```
CREATE TABLE autorepairs (
date date,
repairs varchar(80),
location varchar(80),
cost numeric(6,2)
);
```
我本可以在一行内输入，但为了更好地说明结构，并表明 PostgreSQL 不会解释制表符和换行的空白，我分成了多行。字段包含在括号中，每个变量名和数据类型与下一个变量用逗号分隔（最后一个除外），命令以分号结尾。所有命令都必须以分号结尾！
第一个变量名是 `date`，它的数据类型也是 `date`，这在 PostgreSQL 中没关系。第二个和第三个变量 `repairs` 和 `location` 都是 `varchar(80)` 类型，这意味着它们可以是最多 80 个任意字符（字母、数字等）。最后一个变量 `cost` 使用 `numeric` 类型。括号中的数字表示最多有六位数字，其中两位是小数。最初，我尝试了 `real` 类型，这将是一个浮点数。`real` 类型的问题是作为数据类型在使用时，在遇到 `WHERE` 子句，类似 `WHERE cost = 0` 或其他任何特定数字。由于 `real` 值有些不精确，因此特定数字将永远不会匹配。
### 输入数据
接下来，你可以使用 `INSERT INTO` 命令添加一些数据（在 PostgreSQL 中称为*行*）：
```
INSERT INTO autorepairs VALUES ('2017-08-11', 'airbag recall', 'dealer', 0);
```
请注意，括号构成了一个值的容器，它必须以正确的顺序，用逗号分隔，并在命令末尾加上分号。`date` 和 `varchar(80)` 类型的值必须包含在单引号中，但数字值（如 `numeric`）不用。作为反馈，你应该会看到：
```
INSERT 0 1
```
与常规终端会话一样，你会有输入命令的历史记录，因此，在输入后续行时，通常可以按向上箭头键来显示最后一个命令并根据需要编辑数据，从而节省大量时间。
如果出了什么问题怎么办？使用 `UPDATE` 更改值：
```
UPDATE autorepairs SET date = '2017-11-08' WHERE repairs = 'airbag recall';
```
或者，也许你不再需要表中的行。使用 `DELETE`：
```
DELETE FROM autorepairs WHERE repairs = 'airbag recall';
```
这将删除整行。
最后一件事：即使我在 PostgreSQL 命令中一直使用大写字母（在大多数文档中也这么做），你也可以用小写字母输入，我也经常如此。
### 输出数据
如果你想展示数据，使用 `SELECT`：
```
SELECT * FROM autorepairs ORDER BY date;
```
没有 `ORDER BY` 的话，行将不管你输入的内容来显示。例如，以下就是我终端中输出的我的汽车服务数据：
```
SELECT date, repairs FROM autorepairs ORDER BY date;
date | repairs
-----------+-----------------------------------------------------------------
2008-08-08 | oil change, air filter, spark plugs
2011-09-30 | 35000 service, oil change, rotate tires/balance wheels
2012-03-07 | repl battery
2012-11-14 | 45000 maint, oil/filter
2014-04-09 | 55000 maint, oil/filter, spark plugs, air/dust filters
2014-04-21 | replace 4 tires
2014-04-21 | wheel alignment
2016-06-01 | 65000 mile service, oil change
2017-05-16 | oil change, replce oil filt housing
2017-05-26 | rotate tires
2017-06-05 | air filter, cabin filter,spark plugs
2017-06-05 | brake pads and rotors, flush brakes
2017-08-11 | airbag recall
2018-07-06 | oil/filter change, fuel filter, battery svc
2018-07-06 | transmission fl, p steering fl, rear diff fl
2019-07-22 | oil & filter change, brake fluid flush, front differential flush
2019-08-20 | replace 4 tires
2019-10-09 | replace passenger taillight bulb
2019-10-25 | replace passenger taillight assembly
(19 rows)
```
要将此发送到文件，将输出更改为：
```
\o autorepairs.txt
```
然后再次运行 `SELECT` 命令。
### 退出 PostgreSQL
最后，在终端中退出 PostgreSQL，输入：
```
quit
```
或者它的缩写版：
```
\q
```
虽然这只是 PostgreSQL 的简要介绍，但我希望它展示了将数据库用于这样的简单任务既不困难也不费时。
---
via: <https://opensource.com/article/19/11/getting-started-postgresql>
作者：[Greg Pittman](https://opensource.com/users/greg-p) 选题：[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/) 荣誉推出
|
关于 sudo 你可能不知道的
|
Peter Czanik
|
https://opensource.com/article/19/10/know-about-sudo
|
觉得你已经了解了 sudo 的所有知识了吗？再想想。
|
/data/attachment/album/201911/20/091740ape5b74jppjj4q36.jpg.thumb.jpg
|
/data/attachment/album/201911/20/091740ape5b74jppjj4q36.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"sudo"
] |
技术
|
{
"viewnum": 8151,
"commentnum": 1,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "121.69.58.214",
"message": "虽然基本看不懂，但是感觉好NB的样子",
"username": "来自北京的 Firefox 52.0|GNU/Linux 用户",
"date": "2019-12-05T15:43:55"
}
] |
[] |
觉得你已经了解了 sudo 的所有知识了吗？再想想。
| 2019-11-20T09:18:37 | 2019-11-20T09:18:37 | 11,595 |
/article-11595-1.html
|
>
> 觉得你已经了解了 sudo 的所有知识了吗？再想想。
>
>
>
大家都知道 `sudo`，对吗？默认情况下，该工具已安装在大多数 Linux 系统上，并且可用于大多数 BSD 和商业 Unix 变体。不过，在与数百名 `sudo` 用户交谈之后，我得到的最常见的答案是 `sudo` 是一个使生活复杂化的工具。
有 root 用户和 `su` 命令，那么为什么还要使用另一个工具呢？对于许多人来说，`sudo` 只是管理命令的前缀。只有极少数人提到，当你在同一个系统上有多个管理员时，可以使用 `sudo` 日志查看谁做了什么。
那么，`sudo` 是什么？ 根据 [sudo 网站](https://www.sudo.ws)：
>
> “sudo 允许系统管理员通过授予某些用户以 root 用户或其他用户身份运行某些命令的能力，同时提供命令及其参数的审核记录，从而委派权限。”
>
>
>
默认情况下，`sudo` 只有简单的配置，一条规则允许一个用户或一组用户执行几乎所有操作（在本文后面的配置文件中有更多信息）：
```
%wheel ALL=(ALL) ALL
```
在此示例中，参数表示以下含义：
* 第一个参数（`%wheel`）定义组的成员。
* 第二个参数（`ALL`）定义组成员可以在其上运行命令的主机。
* 第三个参数（`(ALL)`）定义了可以执行命令的用户名。
* 最后一个参数（`ALL`）定义可以运行的应用程序。
因此，在此示例中，`wheel` 组的成员可以以所有主机上的所有用户身份运行所有应用程序。但即使是这个一切允许的规则也很有用，因为它会记录谁在计算机上做了什么。
### 别名
当然，它不仅可以让你和你最好的朋友管理一个共享机器，你还可以微调权限。你可以将以上配置中的项目替换为列表：用户列表、命令列表等。多数情况下，你可能会复制并粘贴配置中的一些列表。
在这种情况下，别名可以派上用场。在多个位置维护相同的列表容易出错。你可以定义一次别名，然后可以多次使用。因此，当你对一位管理员不再信任时，将其从别名中删除就行了。使用多个列表而不是别名，很容易忘记从具有较高特权的列表之一中删除用户。
### 为特定组的用户启用功能
`sudo` 命令带有大量默认设置。不过，在某些情况下，你想覆盖其中的一些情况，这时你可以在配置中使用 `Defaults` 语句。通常，对每个用户都强制使用这些默认值，但是你可以根据主机、用户名等将设置缩小到一部分用户。这里有个我那一代的系统管理员都喜欢玩的一个示例：“羞辱”。这些只不过是一些有人输入错误密码时的有趣信息：
```
czanik@linux-mewy:~> sudo ls
[sudo] password for root:
Hold it up to the light --- not a brain in sight! # 把灯举高点，脑仁太小看不到
[sudo] password for root:
My pet ferret can type better than you! # 我的宠物貂也比你输入的好
[sudo] password for root:
sudo: 3 incorrect password attempts
czanik@linux-mewy:~>
```
由于并非所有人都喜欢系统管理员的这种幽默，因此默认情况下会禁用这些羞辱信息。以下示例说明了如何仅对经验丰富的系统管理员（即 `wheel` 组的成员）启用此设置：
```
Defaults !insults
Defaults:%wheel insults
```
我想，感谢我将这些消息带回来的人用两只手也数不过来吧。
### 摘要验证
当然，`sudo` 还有更严肃的功能。其中之一是摘要验证。你可以在配置中包括应用程序的摘要：
```
peter ALL = sha244:11925141bb22866afdf257ce7790bd6275feda80b3b241c108b79c88 /usr/bin/passwd
```
在这种情况下，`sudo` 在运行应用程序之前检查应用程序摘要，并将其与配置中存储的摘要进行比较。如果不匹配，`sudo` 拒绝运行该应用程序。尽管很难在配置中维护此信息（没有用于此目的的自动化工具），但是这些摘要可以为你提供额外的保护层。
### 会话记录
会话记录也是 `sudo` 鲜为人知的功能。在演示之后，许多人离开我的演讲后就计划在其基础设施上实施它。为什么？因为使用会话记录，你不仅可以看到命令名称，还可以看到终端中发生的所有事情。你可以看到你的管理员在做什么，要不他们用 shell 访问了机器而日志仅会显示启动了 `bash`。
当前有一个限制。记录存储在本地，因此具有足够的权限的话，用户可以删除他们的痕迹。所以请继续关注即将推出的功能。
### 插件
从 1.8 版开始，`sudo` 更改为基于插件的模块化体系结构。通过将大多数功能实现为插件，你可以编写自己的功能轻松地替换或扩展 `sudo` 的功能。已经有了 `sudo` 上的开源和商业插件。
在我的演讲中，我演示了 `sudo_pair` 插件，该插件可在 [GitHub](https://github.com/square/sudo_pair/) 上获得。这个插件是用 Rust 开发的，这意味着它不是那么容易编译，甚至更难以分发其编译结果。另一方面，该插件提供了有趣的功能，需要第二个管理员通过 `sudo` 批准（或拒绝）运行命令。不仅如此，如果有可疑活动，可以在屏幕上跟踪会话并终止会话。
在最近的 All Things Open 会议上的一次演示中，我做了一个臭名昭著的演示：
```
czanik@linux-mewy:~> sudo rm -fr /
```
看着屏幕上显示的命令。每个人都屏住呼吸，想看看我的笔记本电脑是否被毁了，然而它逃过一劫。
### 日志
正如我在开始时提到的，日志记录和警报是 `sudo` 的重要组成部分。如果你不会定期检查 `sudo` 日志，那么日志在使用 `sudo` 中并没有太多价值。该工具通过电子邮件提醒配置中指定的事件，并将所有事件记录到 syslog 中。可以打开调试日志用于调试规则或报告错误。
### 警报
电子邮件警报现在有点过时了，但是如果你使用 syslog-ng 来收集日志消息，则会自动解析 `sudo` 日志消息。你可以轻松创建自定义警报并将其发送到各种各样的目的地，包括 Slack、Telegram、Splunk 或 Elasticsearch。你可以从[我在 syslong-ng.com 上的博客](https://www.syslog-ng.com/community/b/blog/posts/alerting-on-sudo-events-using-syslog-ng)中了解有关此功能的更多信息。
### 配置
我们谈论了很多 `sudo` 功能，甚至还看到了几行配置。现在，让我们仔细看看 `sudo` 的配置方式。配置本身可以在 `/etc/sudoers` 中获得，这是一个简单的文本文件。不过，不建议直接编辑此文件。相反，请使用 `visudo`，因为此工具还会执行语法检查。如果你不喜欢 `vi`，则可以通过将 `EDITOR` 环境变量指向你的首选编辑器来更改要使用的编辑器。
在开始编辑 `sudo` 配置之前，请确保你知道 root 密码。（是的，即使在默认情况下 root 用户没有密码的 Ubuntu 上也是如此。）虽然 `visudo` 会检查语法，但创建语法正确而将你锁定在系统之外的配置也很容易。
如果在紧急情况下，而你手头有 root 密码，你也可以直接编辑配置。当涉及到 `sudoers` 文件时，有一件重要的事情要记住：从上到下读取该文件，以最后的设置为准。这个事实对你来说意味着你应该从通用设置开始，并在末尾放置例外情况，否则，通用设置会覆盖例外情况。
你可以在下面看到一个基于 CentOS 的简单 `sudoers` 文件，并添加我们之前讨论的几行：
```
Defaults !visiblepw
Defaults always_set_home
Defaults match_group_by_gid
Defaults always_query_group_plugin
Defaults env_reset
Defaults env_keep = "COLORS DISPLAY HOSTNAME HISTSIZE KDEDIR LS_COLORS"
Defaults env_keep += "MAIL PS1 PS2 QTDIR USERNAME LANG LC_ADDRESS LC_CTYPE"
Defaults secure_path = /sbin:/bin:/usr/sbin:/usr/bin
root ALL=(ALL) ALL
%wheel ALL=(ALL) ALL
Defaults:%wheel insults
Defaults !insults
Defaults log_output
```
该文件从更改多个默认值开始。然后是通常的默认规则：`root` 用户和 `wheel` 组的成员对计算机具有完全权限。接下来，我们对 `wheel` 组启用“羞辱”，但对其他所有人禁用它们。最后一行启用会话记录。
上面的配置在语法上是正确的，但是你可以发现逻辑错误吗？是的，有一个：后一个通用设置覆盖了先前的更具体设置，让所有人均禁用了“羞辱”。一旦交换了这两行的位置，设置就会按预期进行：`wheel` 组的成员会收到有趣的消息，但其他用户则不会收到。
### 配置管理
一旦必须在多台机器上维护 `sudoers` 文件，你很可能希望集中管理配置。这里主要有两种可能的开源方法。两者都有其优点和缺点。
你可以使用也用来配置其余基础设施的配置管理应用程序之一：Red Hat Ansible、Puppet 和 Chef 都具有用于配置 `sudo` 的模块。这种方法的问题在于更新配置远非实时。同样，用户仍然可以在本地编辑 `sudoers` 文件并更改设置。
`sudo` 工具也可以将其配置存储在 LDAP 中。在这种情况下，配置更改是实时的，用户不能弄乱`sudoers` 文件。另一方面，该方法也有局限性。例如，当 LDAP 服务器不可用时，你不能使用别名或使用 `sudo`。
### 新功能
新版本的 `sudo` 即将推出。1.9 版将包含许多有趣的新功能。以下是最重要的计划功能：
* 记录服务可集中收集会话记录，与本地存储相比，它具有许多优点：
+ 在一个地方搜索更方便。
+ 即使发送记录的机器关闭，也可以进行记录。
+ 记录不能被想要删除其痕迹的人删除。
* audit 插件没有向 `sudoers` 添加新功能，而是为插件提供了 API，以方便地访问任何类型的 `sudo` 日志。这个插件允许使用插件从 `sudo` 事件创建自定义日志。
* approval 插件无需使用第三方插件即可启用会话批准。
* 以及我个人最喜欢的：插件的 Python 支持，这使你可以轻松地使用 Python 代码扩展 `sudo`，而不是使用 C 语言进行原生编码。 ### 总结
希望本文能向你证明 `sudo` 不仅仅是一个简单的命令前缀。有无数种可能性可以微调系统上的权限。你不仅可以微调权限，还可以通过检查摘要来提高安全性。会话记录使你能够检查系统上正在发生的事情。你也可以使用插件扩展 `sudo` 的功能，或者使用已有的插件或编写自己的插件。最后，从即将发布的功能列表中你可以看到，即使 `sudo` 已有数十年的历史，它也是一个不断发展的有生命力的项目。
如果你想了解有关 `sudo` 的更多信息，请参考以下资源：
* [sudo 网站](https://www.sudo.ws/)
* [sudo 博客](https://blog.sudo.ws/)
* [在 Twitter 上关注我们](https://twitter.com/sudoproject)
---
via: <https://opensource.com/article/19/10/know-about-sudo>
作者：[Peter Czanik](https://opensource.com/users/czanik) 选题：[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/) 荣誉推出
|
如何在 CentOS 8 上安装和配置 Postfix 邮件服务器
|
James Kiarie
|
https://www.linuxtechi.com/install-configure-postfix-mailserver-centos-8/
|
Postfix 是一个自由开源的 MTA（邮件传输代理），用于在 Linux 系统上路由或传递电子邮件。在本指南中，你将学习如何在 CentOS 8 上安装和配置 Postfix。
|
/data/attachment/album/201911/21/072857e9bvnzrbqayraxva.jpg.thumb.jpg
|
/data/attachment/album/201911/21/072857e9bvnzrbqayraxva.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Postfix",
"邮件"
] |
系统运维
|
{
"viewnum": 22606,
"commentnum": 2,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "110.185.52.203",
"message": "我一直不理解这个hostname 设置的含义，有些是mail.mydomain.com 你这里是server1.mydomain.com， 能细致的分析一下吗？",
"username": "来自四川成都的 Chrome 80.0|Windows 10 用户",
"date": "2020-03-04T01:46:47"
},
{
"postip": "113.200.150.53",
"message": "那只是为IP取了个名字，做到IP与名字对应，当你访问server1.mydomain.com时，他会使用这个hostname文件解析为对应IP，这是我自己的一点见解",
"username": "墨子威 [Chrome 87.0|Windows 10]",
"date": "2021-01-04T13:34:09"
}
] |
[] |
Postfix 是一个自由开源的 MTA（邮件传输代理），用于在 Linux 系统上路由或传递电子邮件。在本指南中，你将学习如何在 CentOS 8 上安装和配置 Postfix。
| 2019-11-21T07:28:53 | 2019-11-21T07:28:53 | 11,597 |
/article-11597-1.html
|
Postfix 是一个自由开源的 MTA（邮件传输代理），用于在 Linux 系统上路由或传递电子邮件。在本指南中，你将学习如何在 CentOS 8 上安装和配置 Postfix。
实验室设置：
* 系统：CentOS 8 服务器
* IP 地址：192.168.1.13
* 主机名：server1.crazytechgeek.info（确保域名指向服务器的 IP）
### 步骤 1）更新系统
第一步是确保系统软件包是最新的。为此，请按如下所示更新系统：
```
# dnf update
```
继续之前，还请确保不存在其他 MTA（如 Sendmail），因为这将导致与 Postfix 配置冲突。例如，要删除 Sendmail，请运行以下命令：
```
# dnf remove sendmail
```
### 步骤 2）设置主机名并更新 /etc/hosts
使用下面的 `hostnamectl` 命令在系统上设置主机名：
```
# hostnamectl set-hostname server1.crazytechgeek.info
# exec bash
```
此外，你需要在 `/etc/hosts` 中添加系统的主机名和 IP：
```
# vim /etc/hosts
192.168.1.13 server1.crazytechgeek.info
```
保存并退出文件。
### 步骤 3）安装 Postfix 邮件服务器
验证系统上没有其他 MTA 在运行后，运行以下命令安装 Postfix：
```
# dnf install postfix
```
### 步骤 4）启动并启用 Postfix 服务
成功安装 Postfix 后，运行以下命令启动并启用 Postfix 服务：
```
# systemctl start postfix
# systemctl enable postfix
```
要检查 Postfix 状态，请运行以下 `systemctl` 命令：
```
# systemctl status postfix
```
太好了，我们已经验证了 Postfix 已启动并正在运行。接下来，我们将配置 Postfix 从本地发送邮件到我们的服务器。
### 步骤 5）安装 mailx 邮件客户端
在配置 Postfix 服务器之前，我们需要安装 `mailx`，要安装它，请运行以下命令：
```
# dnf install mailx
```
### 步骤 6）配置 Postfix 邮件服务器
Postfix 的配置文件位于 `/etc/postfix/main.cf` 中。我们需要对配置文件进行一些修改，因此请使用你喜欢的文本编辑器将其打开：
```
# vi /etc/postfix/main.cf
```
更改以下几行：
```
myhostname = server1.crazytechgeek.info
mydomain = crazytechgeek.info
myorigin = $mydomain
## 取消注释并将 inet_interfaces 设置为 all##
inet_interfaces = all
## 更改为 all ##
inet_protocols = all
## 注释 ##
#mydestination = $myhostname, localhost.$mydomain, localhost
## 取消注释 ##
mydestination = $myhostname, localhost.$mydomain, localhost, $mydomain
## 取消注释并添加 IP 范围 ##
mynetworks = 192.168.1.0/24, 127.0.0.0/8
## 取消注释 ##
home_mailbox = Maildir/
```
完成后，保存并退出配置文件。重新启动 postfix 服务以使更改生效：
```
# systemctl restart postfix
```
### 步骤 7）测试 Postfix 邮件服务器
测试我们的配置是否有效，首先，创建一个测试用户。
```
# useradd postfixuser
# passwd postfixuser
```
接下来，运行以下命令，从本地用户 `pkumar` 发送邮件到另一个用户 `postfixuser`。
```
# telnet localhost smtp
或者
# telnet localhost 25
```
如果未安装 telnet 服务，那么可以使用以下命令进行安装：
```
# dnf install telnet -y
```
如前所述运行命令时，应获得如下输出：
```
[root@linuxtechi ~]# telnet localhost 25
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
220 server1.crazytechgeek.info ESMTP Postfix
```
上面的结果确认与 postfix 邮件服务器的连接正常。接下来，输入命令：
```
# ehlo localhost
```
输出看上去像这样：
```
250-server1.crazytechgeek.info
250-PIPELINING
250-SIZE 10240000
250-VRFY
250-ETRN
250-STARTTLS
250-ENHANCEDSTATUSCODES
250-8BITMIME
250-DSN
250 SMTPUTF8
```
接下来，运行橙色高亮的命令，例如 `mail from`、`rcpt to`、`data`，最后输入 `quit`：
```
mail from:<pkumar>
250 2.1.0 Ok
rcpt to:<postfixuser>
250 2.1.5 Ok
data
354 End data with <CR><LF>.<CR><LF>
Hello, Welcome to my mailserver (Postfix)
.
250 2.0.0 Ok: queued as B56BF1189BEC
quit
221 2.0.0 Bye
Connection closed by foreign host
```
完成 `telnet` 命令可从本地用户 `pkumar` 发送邮件到另一个本地用户 `postfixuser`，如下所示：
如果一切都按计划进行，那么你应该可以在新用户的家目录中查看发送的邮件：
```
# ls /home/postfixuser/Maildir/new
1573580091.Vfd02I20050b8M635437.server1.crazytechgeek.info
#
```
要阅读邮件，只需使用 cat 命令，如下所示：
```
# cat /home/postfixuser/Maildir/new/1573580091.Vfd02I20050b8M635437.server1.crazytechgeek.info
```
### Postfix 邮件服务器日志
Postfix 邮件服务器邮件日志保存在文件 `/var/log/maillog` 中，使用以下命令查看实时日志，
```
# tail -f /var/log/maillog
```
### 保护 Postfix 邮件服务器
建议始终确保客户端和 Postfix 服务器之间的通信安全，这可以使用 SSL 证书来实现，它们可以来自受信任的权威机构或自签名证书。在本教程中，我们将使用 `openssl` 命令生成用于 Postfix 的自签名证书，
我假设 `openssl` 已经安装在你的系统上，如果未安装，请使用以下 `dnf` 命令：
```
# dnf install openssl -y
```
使用下面的 `openssl` 命令生成私钥和 CSR（证书签名请求）：
```
# openssl req -nodes -newkey rsa:2048 -keyout mail.key -out mail.csr
```
现在，使用以下 openssl 命令生成自签名证书：
```
# openssl x509 -req -days 365 -in mail.csr -signkey mail.key -out mail.crt
Signature ok
subject=C = IN, ST = New Delhi, L = New Delhi, O = IT, OU = IT, CN = server1.crazytechgeek.info, emailAddress = root@linuxtechi
Getting Private key
#
```
现在将私钥和证书文件复制到 `/etc/postfix` 目录下：
```
# cp mail.key mail.crt /etc/postfix
```
在 Postfix 配置文件中更新私钥和证书文件的路径：
```
# vi /etc/postfix/main.cf
………
smtpd_use_tls = yes
smtpd_tls_cert_file = /etc/postfix/mail.crt
smtpd_tls_key_file = /etc/postfix/mail.key
smtpd_tls_security_level = may
………
```
重启 Postfix 服务以使上述更改生效：
```
# systemctl restart postfix
```
让我们尝试使用 `mailx` 客户端将邮件发送到内部本地域和外部域。
从 `pkumar` 发送内部本地邮件到 `postfixuser` 中：
```
# echo "test email" | mailx -s "Test email from Postfix MailServer" -r root@linuxtechi root@linuxtechi
```
使用以下命令检查并阅读邮件：
```
# cd /home/postfixuser/Maildir/new/
# ll
total 8
-rw-------. 1 postfixuser postfixuser 476 Nov 12 17:34 1573580091.Vfd02I20050b8M635437.server1.crazytechgeek.info
-rw-------. 1 postfixuser postfixuser 612 Nov 13 02:40 1573612845.Vfd02I20050bbM466643.server1.crazytechgeek.info
# cat 1573612845.Vfd02I20050bbM466643.server1.crazytechgeek.info
```
从 `postfixuser` 发送邮件到外部域（`root@linuxtechi.com`）：
```
# echo "External Test email" | mailx -s "Postfix MailServer" -r root@linuxtechi root@linuxtechi
```
注意：如果你的 IP 没有被任何地方列入黑名单，那么你发送到外部域的邮件将被发送，否则它将被退回，并提示你的 IP 被 spamhaus 之类的数据库列入黑名单。
### 检查 Postfix 邮件队列
使用 `mailq` 命令列出队列中的邮件：
```
# mailq
Mail queue is empty
#
```
完成！我们的 Postfix 配置正常工作了！目前就这样了。我们希望你觉得本教程有见地，并且你可以轻松地设置本地 Postfix 服务器。
---
via: <https://www.linuxtechi.com/install-configure-postfix-mailserver-centos-8/>
作者：[James Kiarie](https://www.linuxtechi.com/author/james/) 选题：[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/) 荣誉推出
|
在 Ubuntu 19.10 上入门 ZFS 文件系统
|
John Paul
|
https://itsfoss.com/zfs-ubuntu/
|
Ubuntu 19.10 的主要新特性之一就是 ZFS。现在你可以很容易的无需额外努力就可以在 Ubuntu 系统上安装 ZFS了。
|
/data/attachment/album/201911/21/081609la0a7c7kpypppkt8.jpg.thumb.jpg
|
/data/attachment/album/201911/21/081609la0a7c7kpypppkt8.jpg
| true | false | true |
lujun9972
|
guevaraya
|
wxy
| false |
[
"ZFS"
] |
技术
|
{
"viewnum": 17236,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "126.227.176.124",
"message": "注意一个最重要的点：<br />\r\nzfs无法移除硬盘，只能替换。这点和btrfs不同",
"username": "来自日本的 Chrome Mobile 78.0|Android 用户",
"date": "2019-11-21T19:38:11"
}
] |
[
{
"raid": 7422,
"displayorder": 0
}
] |
Ubuntu 19.10 的主要新特性之一就是 ZFS。现在你可以很容易的无需额外努力就可以在 Ubuntu 系统上安装 ZFS了。
| 2019-11-21T08:16:06 | 2019-11-21T08:16:06 | 11,598 |
/article-11598-1.html
|
Ubuntu 19.10 的主要新特性之一就是 [ZFS](/article-10034-1.html)。现在你可以很容易的无需额外努力就可以在 Ubuntu 系统上安装 ZFS了。
一般情况下，安装 Linux 都会选择 Ext4 文件系统。但是如果是全新安装 Ubuntu 19.10，在安装的启动阶段可以看到 ZFS 选项。
让我们看看 ZFS 为何重要，以及如何在已经安装了 ZFS 的 Ubuntu 上使用它。
### ZFS 与其他文件系统有哪些区别？
ZFS 的设计初衷是：处理海量存储和避免数据损坏。ZFS 可以处理 256 千万亿的 ZB 数据。（这就是 ZFS 的 Z）且它可以处理最大 16 EB 的文件。
如果你仅有一个单磁盘的笔记本电脑，你可以体验 ZFS 的数据保护特性。写时复制（COW）特性确保正在使用的数据不会被覆盖，相反，新的数据会被写到一个新的块中，同时文件系统的元数据会被更新到新块中。ZFS 可容易的创建文件系统的快照。这个快照可追踪文件系统的更改，并共享数据块确保节省数据空间。
ZFS 为磁盘上的每个文件分配一个校验和。它会不断的校验文件的状态和校验和。如果发现文件被损坏了，它就会尝试修复文件。
我写过一个文章详细介绍 [什么是 ZFS以及它有哪些特性](/article-10034-1.html)。如果你感兴趣可以去阅读下。
注：请谨记 ZFS 的数据保护特性会导致性能下降。
### Ubuntu 下使用 ZFS [适用于中高级用户]
一旦你在你的主磁盘上全新安装了带有 ZFS 的 Ubuntu，你就可以开始体验它的特性。
请注意所有的 ZFS 设置过程都需要命令行。我不知道它有任何 GUI 工具。
#### 创建一个 ZFS 池
**这段仅针对拥有多个磁盘的系统。如果你只有一个磁盘，Ubuntu 会在安装的时候自动创建池。**
在创建池之前，你需要为池找到磁盘的 id。你可以用命令 `lsblk` 查询出这个信息。
为三个磁盘创建一个基础池，用以下命令：
```
sudo zpool create pool-test /dev/sdb /dev/sdc /dev/sdd
```
请记得替换 `pool-test` 为你选择的的命名。
这个命令将会设置“无冗余 RAID-0 池”。这意味着如果一个磁盘被破坏或有故障，你将会丢失数据。如果你执行以上命令，还是建议做一个常规备份。
你可以用下面命令将另一个磁盘增加到池中：
```
sudo zpool add pool-name /dev/sdx
```
#### 查看 ZFS 池的状态
你可以用这个命令查询新建池的状态：
```
sudo zpool status pool-test
```
#### 镜像一个 ZFS 池
为确保数据的安全性，你可以创建镜像。镜像意味着每个磁盘包含同样的数据。使用镜像设置，你可能会丢失三个磁盘中的两个，并且仍然拥有所有信息。
要创建镜像你可以用下面命令：
```
sudo zpool create pool-test mirror /dev/sdb /dev/sdc /dev/sdd
```
#### 创建 ZFS 用于备份恢复的快照
快照允许你创建一个后备，以防某个文件被删除或被覆盖。比如，我们创建一个快照，当在用户主目录下删除一些目录后，然后把它恢复。
首先，你需要找到你想要的快照数据集。你可以这样做：
```
zfs list
```
你可以看到我的家目录位于 `rpool/USERDATA/johnblood_uwcjk7`。
我们用下面命令创建一个名叫 `1910` 的快照：
```
sudo zfs snapshot rpool/USERDATA/johnblood_uwcjk7@1019
```
快照很快创建完成。现在你可以删除 `Downloads` 和 `Documents` 目录。
现在你用以下命令恢复快照：
```
sudo zfs rollback rpool/USERDATA/johnblood_uwcjk7@1019
```
回滚的时间长短取决于有多少信息改变。现在你可以查看家目录，被删除的目录（和它的内容）将会被恢复过来。
### 要不要试试 ZFS ？
这篇文章仅简单介绍的 Ubuntu下 ZFS 的用法。更多的信息请参考 [Ubuntu 的 ZFS Wiki页面](https://wiki.ubuntu.com/Kernel/Reference/ZFS)。我也推荐阅读 [ArsTechnica 的精彩文章](https://arstechnica.com/information-technology/2019/10/a-detailed-look-at-ubuntus-new-experimental-zfs-installer/)。
这个是试验性的功能。如果你还不了解 ZFS，你想用一个简单稳定的系统，请安装标准文件系统 EXT4。如果你想用闲置的机器体验，可以参照上面了解 ZFS。如果你是一个“专家”，并且知道自己在做什么，则可以随时随地随意尝试ZFS。
你之前用过 ZFS 吗？请在下面留言。
---
via: <https://itsfoss.com/zfs-ubuntu/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[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/) 荣誉推出
know in the comments below. If you found this article interesting, please take a minute to share it on social media, Hacker News or [Reddit](https://reddit.com/r/linuxusersgroup).
---
via: <https://itsfoss.com/zfs-ubuntu/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[译者ID](https://github.com/%E8%AF%91%E8%80%85ID) 校对：[校对者ID](https://github.com/%E6%A0%A1%E5%AF%B9%E8%80%85ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何使用 Protobuf 做数据交换
|
Marty Kalin
|
https://opensource.com/article/19/10/protobuf-data-interchange
|
在以不同语言编写并在不同平台上运行的应用程序之间交换数据时，Protobuf 编码可提高效率。
|
/data/attachment/album/201911/22/075757pn2fxfth30ntwefg.jpg.thumb.jpg
|
/data/attachment/album/201911/22/075757pn2fxfth30ntwefg.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Protobuf",
"JSON",
"XML"
] |
软件开发
|
{
"viewnum": 6301,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在以不同语言编写并在不同平台上运行的应用程序之间交换数据时，Protobuf 编码可提高效率。
| 2019-11-22T07:59:06 | 2019-11-22T07:59:06 | 11,600 |
/article-11600-1.html
|
>
> 在以不同语言编写并在不同平台上运行的应用程序之间交换数据时，Protobuf 编码可提高效率。
>
>
>
<ruby> 协议缓冲区 <rt> Protocol Buffers </rt></ruby>（[Protobufs](https://developers.google.com/protocol-buffers/)）像 XML 和 JSON 一样，可以让用不同语言编写并在不同平台上运行的应用程序交换数据。例如，用 Go 编写的发送程序可以在 Protobuf 中对以 Go 表示的销售订单数据进行编码，然后用 Java 编写的接收方可以对它进行解码，以获取所接收订单数据的 Java 表示方式。这是在网络连接上的结构示意图：
>
> Go 销售订单 —> Pbuf 编码 —> 网络 —> Pbuf 界面 —> Java 销售订单
>
>
>
与 XML 和 JSON 相比，Protobuf 编码是二进制而不是文本，这会使调试复杂化。但是，正如本文中的代码示例所确认的那样，Protobuf 编码在大小上比 XML 或 JSON 编码要有效得多。
Protobuf 以另一种方式提供了这种有效性。在实现级别，Protobuf 和其他编码系统对结构化数据进行<ruby> 序列化 <rt> serialize </rt></ruby>和<ruby> 反序列化 <rt> deserialize </rt></ruby>。序列化将特定语言的数据结构转换为字节流，反序列化是将字节流转换回特定语言的数据结构的逆运算。序列化和反序列化可能成为数据交换的瓶颈，因为这些操作会占用大量 CPU。高效的序列化和反序列化是 Protobuf 的另一个设计目标。
最近的编码技术，例如 Protobuf 和 FlatBuffers，源自 1990 年代初期的 [DCE/RPC](https://en.wikipedia.org/wiki/DCE/RPC)（<ruby> 分布式计算环境/远程过程调用 <rt> Distributed Computing Environment/Remote Procedure Call </rt></ruby>）计划。与 DCE/RPC 一样，Protobuf 在数据交换中为 [IDL](https://en.wikipedia.org/wiki/Interface_description_language)（接口定义语言）和编码层做出了贡献。
本文将着眼于这两层，然后提供 Go 和 Java 中的代码示例以充实 Protobuf 的细节，并表明 Protobuf 是易于使用的。
### Protobuf 作为一个 IDL 和编码层
像 Protobuf 一样，DCE/RPC 被设计为与语言和平台无关。适当的库和实用程序允许任何语言和平台用于 DCE/RPC 领域。此外，DCE/RPC 体系结构非常优雅。IDL 文档是一侧的远程过程与另一侧的调用者之间的协定。Protobuf 也是以 IDL 文档为中心的。
IDL 文档是文本，在 DCE/RPC 中，使用基本 C 语法以及元数据的语法扩展（方括号）和一些新的关键字，例如 `interface`。这是一个例子：
```
[uuid (2d6ead46-05e3-11ca-7dd1-426909beabcd), version(1.0)]
interface echo {
const long int ECHO_SIZE = 512;
void echo(
[in] handle_t h,
[in, string] idl_char from_client[ ],
[out, string] idl_char from_service[ECHO_SIZE]
);
}
```
该 IDL 文档声明了一个名为 `echo` 的过程，该过程带有三个参数：类型为 `handle_t`（实现指针）和 `idl_char`（ASCII 字符数组）的 `[in]` 参数被传递给远程过程，而 `[out]` 参数（也是一个字符串）从该过程中传回。在此示例中，`echo` 过程不会显式返回值（`echo` 左侧的 `void`），但也可以返回值。返回值，以及一个或多个 `[out]` 参数，允许远程过程任意返回许多值。下一节将介绍 Protobuf IDL，它的语法不同，但同样用作数据交换中的协定。
DCE/RPC 和 Protobuf 中的 IDL 文档是创建用于交换数据的基础结构代码的实用程序的输入：
>
> IDL 文档 —> DCE/PRC 或 Protobuf 实用程序 —> 数据交换的支持代码
>
>
>
作为相对简单的文本，IDL 是同样便于人类阅读的关于数据交换细节的文档（特别是交换的数据项的数量和每个项的数据类型）。
Protobuf 可用于现代 RPC 系统，例如 [gRPC](https://grpc.io/)；但是 Protobuf 本身仅提供 IDL 层和编码层，用于从发送者传递到接收者的消息。与原本的 DCE/RPC 一样，Protobuf 编码是二进制的，但效率更高。
目前，XML 和 JSON 编码仍在通过 Web 服务等技术进行的数据交换中占主导地位，这些技术利用 Web 服务器、传输协议（例如 TCP、HTTP）以及标准库和实用程序等原有的基础设施来处理 XML 和 JSON 文档。 此外，各种类型的数据库系统可以存储 XML 和 JSON 文档，甚至旧式关系型系统也可以轻松生成查询结果的 XML 编码。现在，每种通用编程语言都具有支持 XML 和 JSON 的库。那么，是什么让我们回到 Protobuf 之类的**二进制**编码系统呢？
让我们看一下负十进制值 `-128`。以 2 的补码二进制表示形式（在系统和语言中占主导地位）中，此值可以存储在单个 8 位字节中：`10000000`。此整数值在 XML 或 JSON 中的文本编码需要多个字节。例如，UTF-8 编码需要四个字节的字符串，即 `-128`，即每个字符一个字节（十六进制，值为 `0x2d`、`0x31`、`0x32` 和 `0x38`）。XML 和 JSON 还添加了标记字符，例如尖括号和大括号。有关 Protobuf 编码的详细信息下面就会介绍，但现在的关注点是一个通用点：文本编码的压缩性明显低于二进制编码。
### 在 Go 中使用 Protobuf 的示例
我的代码示例着重于 Protobuf 而不是 RPC。以下是第一个示例的概述：
* 名为 `dataitem.proto` 的 IDL 文件定义了一个 Protobuf 消息，它具有六个不同类型的字段：具有不同范围的整数值、固定大小的浮点值以及两个不同长度的字符串。
* Protobuf 编译器使用 IDL 文件生成 Go 版本（以及后面的 Java 版本）的 Protobuf 消息及支持函数。
* Go 应用程序使用随机生成的值填充原生的 Go 数据结构，然后将结果序列化为本地文件。为了进行比较， XML 和 JSON 编码也被序列化为本地文件。
* 作为测试，Go 应用程序通过反序列化 Protobuf 文件的内容来重建其原生数据结构的实例。
* 作为语言中立性测试，Java 应用程序还会对 Protobuf 文件的内容进行反序列化以获取原生数据结构的实例。
[我的网站](http://condor.depaul.edu/mkalin)上提供了该 IDL 文件以及两个 Go 和一个 Java 源文件，打包为 ZIP 文件。
最重要的 Protobuf IDL 文档如下所示。该文档存储在文件 `dataitem.proto` 中，并具有常规的`.proto` 扩展名。
#### 示例 1、Protobuf IDL 文档
```
syntax = "proto3";
package main;
message DataItem {
int64 oddA = 1;
int64 evenA = 2;
int32 oddB = 3;
int32 evenB = 4;
float small = 5;
float big = 6;
string short = 7;
string long = 8;
}
```
该 IDL 使用当前的 proto3 而不是较早的 proto2 语法。软件包名称（在本例中为 `main`）是可选的，但是惯例使用它以避免名称冲突。这个结构化的消息包含八个字段，每个字段都有一个 Protobuf 数据类型（例如，`int64`、`string`）、名称（例如，`oddA`、`short`）和一个等号 `=` 之后的数字标签（即键）。标签（在此示例中为 1 到 8）是唯一的整数标识符，用于确定字段序列化的顺序。
Protobuf 消息可以嵌套到任意级别，而一个消息可以是另外一个消息的字段类型。这是一个使用 `DataItem` 消息作为字段类型的示例：
```
message DataItems {
repeated DataItem item = 1;
}
```
单个 `DataItems` 消息由重复的（零个或多个）`DataItem` 消息组成。
为了清晰起见，Protobuf 还支持枚举类型：
```
enum PartnershipStatus {
reserved "FREE", "CONSTRAINED", "OTHER";
}
```
`reserved` 限定符确保用于实现这三个符号名的数值不能重复使用。
为了生成一个或多个声明 Protobuf 消息结构的特定于语言的版本，包含这些结构的 IDL 文件被传递到`protoc` 编译器（可在 [Protobuf GitHub 存储库](https://github.com/protocolbuffers/protobuf)中找到）。对于 Go 代码，可以以通常的方式安装支持的 Protobuf 库（这里以 `％` 作为命令行提示符）：
```
% go get github.com/golang/protobuf/proto
```
将 Protobuf IDL 文件 `dataitem.proto` 编译为 Go 源代码的命令是：
```
% protoc --go_out=. dataitem.proto
```
标志 `--go_out` 指示编译器生成 Go 源代码。其他语言也有类似的标志。在这种情况下，结果是一个名为 `dataitem.pb.go` 的文件，该文件足够小，可以将其基本内容复制到 Go 应用程序中。以下是生成的代码的主要部分：
```
var _ = proto.Marshal
type DataItem struct {
OddA int64 `protobuf:"varint,1,opt,name=oddA" json:"oddA,omitempty"`
EvenA int64 `protobuf:"varint,2,opt,name=evenA" json:"evenA,omitempty"`
OddB int32 `protobuf:"varint,3,opt,name=oddB" json:"oddB,omitempty"`
EvenB int32 `protobuf:"varint,4,opt,name=evenB" json:"evenB,omitempty"`
Small float32 `protobuf:"fixed32,5,opt,name=small" json:"small,omitempty"`
Big float32 `protobuf:"fixed32,6,opt,name=big" json:"big,omitempty"`
Short string `protobuf:"bytes,7,opt,name=short" json:"short,omitempty"`
Long string `protobuf:"bytes,8,opt,name=long" json:"long,omitempty"`
}
func (m *DataItem) Reset() { *m = DataItem{} }
func (m *DataItem) String() string { return proto.CompactTextString(m) }
func (*DataItem) ProtoMessage() {}
func init() {}
```
编译器生成的代码具有 Go 结构 `DataItem`，该结构导出 Go 字段（名称现已大写开头），该字段与 Protobuf IDL 中声明的名称匹配。该结构字段具有标准的 Go 数据类型：`int32`、`int64`、`float32` 和 `string`。在每个字段行的末尾，是描述 Protobuf 类型的字符串，提供 Protobuf IDL 文档中的数字标签及有关 JSON 信息的元数据，这将在后面讨论。
此外也有函数；最重要的是 `Proto.Marshal`，用于将 `DataItem` 结构的实例序列化为 Protobuf 格式。辅助函数包括：清除 `DataItem` 结构的 `Reset`，生成 `DataItem` 的单行字符串表示的 `String`。
描述 Protobuf 编码的元数据应在更详细地分析 Go 程序之前进行仔细研究。
### Protobuf 编码
Protobuf 消息的结构为键/值对的集合，其中数字标签为键，相应的字段为值。字段名称（例如，`oddA` 和 `small`）是供人类阅读的，但是 `protoc` 编译器的确使用了字段名称来生成特定于语言的对应名称。例如，Protobuf IDL 中的 `oddA` 和 `small` 名称在 Go 结构中分别成为字段 `OddA` 和 `Small`。
键和它们的值都被编码，但是有一个重要的区别：一些数字值具有固定大小的 32 或 64 位的编码，而其他数字（包括消息标签）则是 `varint` 编码的，位数取决于整数的绝对值。例如，整数值 1 到 15 需要 8 位 `varint` 编码，而值 16 到 2047 需要 16 位。`varint` 编码在本质上与 UTF-8 编码类似（但细节不同），它偏爱较小的整数值而不是较大的整数值。（有关详细分析，请参见 Protobuf [编码指南](https://developers.google.com/protocol-buffers/docs/encoding)）结果是，Protobuf 消息应该在字段中具有较小的整数值（如果可能），并且键数应尽可能少，但每个字段至少得有一个键。
下表 1 列出了 Protobuf 编码的要点：
| 编码 | 示例类型 | 长度 |
| --- | --- | --- |
| `varint` | `int32`、`uint32`、`int64` | 可变长度 |
| `fixed` | `fixed32`、`float`、`double` | 固定的 32 位或 64 位长度 |
| 字节序列 | `string`、`bytes` | 序列长度 |
*表 1. Protobuf 数据类型*
未明确固定长度的整数类型是 `varint` 编码的；因此，在 `varint` 类型中，例如 `uint32`（`u` 代表无符号），数字 32 描述了整数的范围（在这种情况下为 0 到 2<sup> 32</sup> - 1），而不是其位的大小，该位大小取决于值。相比之下，对于固定长度类型（例如 `fixed32` 或 `double`），Protobuf 编码分别需要 32 位和 64 位。Protobuf 中的字符串是字节序列；因此，字段编码的大小就是字节序列的长度。
另一个高效的方法值得一提。回想一下前面的示例，其中的 `DataItems` 消息由重复的 `DataItem` 实例组成：
```
message DataItems {
repeated DataItem item = 1;
}
```
`repeated` 表示 `DataItem` 实例是*打包的*：集合具有单个标签，在这里是 1。因此，具有重复的 `DataItem` 实例的 `DataItems` 消息比具有多个但单独的 `DataItem` 字段、每个字段都需要自己的标签的消息的效率更高。
了解了这一背景，让我们回到 Go 程序。
### dataItem 程序的细节
`dataItem` 程序创建一个 `DataItem` 实例，并使用适当类型的随机生成的值填充字段。Go 有一个 `rand` 包，带有用于生成伪随机整数和浮点值的函数，而我的 `randString` 函数可以从字符集中生成指定长度的伪随机字符串。设计目标是要有一个具有不同类型和位大小的字段值的 `DataItem` 实例。例如，`OddA` 和 `EvenA` 值分别是 64 位非负整数值的奇数和偶数；但是 `OddB` 和 `EvenB` 变体的大小为 32 位，并存放 0 到 2047 之间的小整数值。随机浮点值的大小为 32 位，字符串为 16（`Short`）和 32（`Long`）字符的长度。这是用随机值填充 `DataItem` 结构的代码段：
```
// 可变长度整数
n1 := rand.Int63() // 大整数
if (n1 & 1) == 0 { n1++ } // 确保其是奇数
...
n3 := rand.Int31() % UpperBound // 小整数
if (n3 & 1) == 0 { n3++ } // 确保其是奇数
// 固定长度浮点数
...
t1 := rand.Float32()
t2 := rand.Float32()
...
// 字符串
str1 := randString(StrShort)
str2 := randString(StrLong)
// 消息
dataItem := &DataItem {
OddA: n1,
EvenA: n2,
OddB: n3,
EvenB: n4,
Big: f1,
Small: f2,
Short: str1,
Long: str2,
}
```
创建并填充值后，`DataItem` 实例将以 XML、JSON 和 Protobuf 进行编码，每种编码均写入本地文件：
```
func encodeAndserialize(dataItem *DataItem) {
bytes, _ := xml.MarshalIndent(dataItem, "", " ") // Xml to dataitem.xml
ioutil.WriteFile(XmlFile, bytes, 0644) // 0644 is file access permissions
bytes, _ = json.MarshalIndent(dataItem, "", " ") // Json to dataitem.json
ioutil.WriteFile(JsonFile, bytes, 0644)
bytes, _ = proto.Marshal(dataItem) // Protobuf to dataitem.pbuf
ioutil.WriteFile(PbufFile, bytes, 0644)
}
```
这三个序列化函数使用术语 `marshal`，它与 `serialize` 意思大致相同。如代码所示，三个 `Marshal` 函数均返回一个字节数组，然后将其写入文件。（为简单起见，忽略可能的错误处理。）在示例运行中，文件大小为：
```
dataitem.xml: 262 bytes
dataitem.json: 212 bytes
dataitem.pbuf: 88 bytes
```
Protobuf 编码明显小于其他两个编码方案。通过消除缩进字符（在这种情况下为空白和换行符），可以稍微减小 XML 和 JSON 序列化的大小。
以下是 `dataitem.json` 文件，该文件最终是由 `json.MarshalIndent` 调用产生的，并添加了以 `##` 开头的注释：
```
{
"oddA": 4744002665212642479, ## 64-bit >= 0
"evenA": 2395006495604861128, ## ditto
"oddB": 57, ## 32-bit >= 0 but < 2048
"evenB": 468, ## ditto
"small": 0.7562016, ## 32-bit floating-point
"big": 0.85202795, ## ditto
"short": "ClH1oDaTtoX$HBN5", ## 16 random chars
"long": "xId0rD3Cri%3Wt%^QjcFLJgyXBu9^DZI" ## 32 random chars
}
```
尽管这些序列化的数据写入到本地文件中，但是也可以使用相同的方法将数据写入网络连接的输出流。
### 测试序列化和反序列化
Go 程序接下来通过将先前写入 `dataitem.pbuf` 文件的字节反序列化为 `DataItem` 实例来运行基本测试。这是代码段，其中去除了错误检查部分：
```
filebytes, err := ioutil.ReadFile(PbufFile) // get the bytes from the file
...
testItem.Reset() // clear the DataItem structure
err = proto.Unmarshal(filebytes, testItem) // deserialize into a DataItem instance
```
用于 Protbuf 反序列化的 `proto.Unmarshal` 函数与 `proto.Marshal` 函数相反。原始的 `DataItem` 和反序列化的副本将被打印出来以确认完全匹配：
```
Original:
2041519981506242154 3041486079683013705 1192 1879
0.572123 0.326855
boPb#T0O8Xd&Ps5EnSZqDg4Qztvo7IIs 9vH66AiGSQgCDxk&
Deserialized:
2041519981506242154 3041486079683013705 1192 1879
0.572123 0.326855
boPb#T0O8Xd&Ps5EnSZqDg4Qztvo7IIs 9vH66AiGSQgCDxk&
```
### 一个 Java Protobuf 客户端
用 Java 写的示例是为了确认 Protobuf 的语言中立性。原始 IDL 文件可用于生成 Java 支持代码，其中涉及嵌套类。但是，为了抑制警告信息，可以进行一些补充。这是修订版，它指定了一个 `DataMsg` 作为外部类的名称，内部类在该 Protobuf 消息后面自动命名为 `DataItem`：
```
syntax = "proto3";
package main;
option java_outer_classname = "DataMsg";
message DataItem {
...
```
进行此更改后，`protoc` 编译与以前相同，只是所期望的输出现在是 Java 而不是 Go：
```
% protoc --java_out=. dataitem.proto
```
生成的源文件（在名为 `main` 的子目录中）为 `DataMsg.java`，长度约为 1,120 行：Java 并不简洁。编译然后运行 Java 代码需要具有 Protobuf 库支持的 JAR 文件。该文件位于 [Maven 存储库](https://mvnrepository.com/artifact/com.google.protobuf/protobuf-java)中。
放置好这些片段后，我的测试代码相对较短（并且在 ZIP 文件中以 `Main.java` 形式提供）：
```
package main;
import java.io.FileInputStream;
public class Main {
public static void main(String[] args) {
String path = "dataitem.pbuf"; // from the Go program's serialization
try {
DataMsg.DataItem deserial =
DataMsg.DataItem.newBuilder().mergeFrom(new FileInputStream(path)).build();
System.out.println(deserial.getOddA()); // 64-bit odd
System.out.println(deserial.getLong()); // 32-character string
}
catch(Exception e) { System.err.println(e); }
}
}
```
当然，生产级的测试将更加彻底，但是即使是该初步测试也可以证明 Protobuf 的语言中立性：`dataitem.pbuf` 文件是 Go 程序对 Go 语言版的 `DataItem` 进行序列化的结果，并且该文件中的字节被反序列化以产生一个 Java 语言的 `DataItem` 实例。Java 测试的输出与 Go 测试的输出相同。
### 用 numPairs 程序来结束
让我们以一个示例作为结尾，来突出 Protobuf 效率，但又强调在任何编码技术中都会涉及到的成本。考虑以下 Protobuf IDL 文件：
```
syntax = "proto3";
package main;
message NumPairs {
repeated NumPair pair = 1;
}
message NumPair {
int32 odd = 1;
int32 even = 2;
}
```
`NumPair` 消息由两个 `int32` 值以及每个字段的整数标签组成。`NumPairs` 消息是嵌入的 `NumPair` 消息的序列。
Go 语言的 `numPairs` 程序（如下）创建了 200 万个 `NumPair` 实例，每个实例都附加到 `NumPairs` 消息中。该消息可以按常规方式进行序列化和反序列化。
#### 示例 2、numPairs 程序
```
package main
import (
"math/rand"
"time"
"encoding/xml"
"encoding/json"
"io/ioutil"
"github.com/golang/protobuf/proto"
)
// protoc-generated code: start
var _ = proto.Marshal
type NumPairs struct {
Pair []*NumPair `protobuf:"bytes,1,rep,name=pair" json:"pair,omitempty"`
}
func (m *NumPairs) Reset() { *m = NumPairs{} }
func (m *NumPairs) String() string { return proto.CompactTextString(m) }
func (*NumPairs) ProtoMessage() {}
func (m *NumPairs) GetPair() []*NumPair {
if m != nil { return m.Pair }
return nil
}
type NumPair struct {
Odd int32 `protobuf:"varint,1,opt,name=odd" json:"odd,omitempty"`
Even int32 `protobuf:"varint,2,opt,name=even" json:"even,omitempty"`
}
func (m *NumPair) Reset() { *m = NumPair{} }
func (m *NumPair) String() string { return proto.CompactTextString(m) }
func (*NumPair) ProtoMessage() {}
func init() {}
// protoc-generated code: finish
var numPairsStruct NumPairs
var numPairs = &numPairsStruct
func encodeAndserialize() {
// XML encoding
filename := "./pairs.xml"
bytes, _ := xml.MarshalIndent(numPairs, "", " ")
ioutil.WriteFile(filename, bytes, 0644)
// JSON encoding
filename = "./pairs.json"
bytes, _ = json.MarshalIndent(numPairs, "", " ")
ioutil.WriteFile(filename, bytes, 0644)
// ProtoBuf encoding
filename = "./pairs.pbuf"
bytes, _ = proto.Marshal(numPairs)
ioutil.WriteFile(filename, bytes, 0644)
}
const HowMany = 200 * 100 * 100 // two million
func main() {
rand.Seed(time.Now().UnixNano())
// uncomment the modulus operations to get the more efficient version
for i := 0; i < HowMany; i++ {
n1 := rand.Int31() // % 2047
if (n1 & 1) == 0 { n1++ } // ensure it's odd
n2 := rand.Int31() // % 2047
if (n2 & 1) == 1 { n2++ } // ensure it's even
next := &NumPair {
Odd: n1,
Even: n2,
}
numPairs.Pair = append(numPairs.Pair, next)
}
encodeAndserialize()
}
```
每个 `NumPair` 中随机生成的奇数和偶数值的范围在 0 到 20 亿之间变化。就原始数据（而非编码数据）而言，Go 程序中生成的整数总共为 16MB：每个 `NumPair` 为两个整数，总计为 400 万个整数，每个值的大小为四个字节。
为了进行比较，下表列出了 XML、JSON 和 Protobuf 编码的示例 `NumsPairs` 消息的 200 万个 `NumPair` 实例。原始数据也包括在内。由于 `numPairs` 程序生成随机值，因此样本运行的输出有所不同，但接近表中显示的大小。
| 编码 | 文件 | 字节大小 | Pbuf/其它 比例 |
| --- | --- | --- | --- |
| 无 | pairs.raw | 16MB | 169% |
| Protobuf | pairs.pbuf | 27MB | — |
| JSON | pairs.json | 100MB | 27% |
| XML | pairs.xml | 126MB | 21% |
*表 2. 16MB 整数的编码开销*
不出所料，Protobuf 和之后的 XML 和 JSON 差别明显。Protobuf 编码大约是 JSON 的四分之一，是 XML 的五分之一。但是原始数据清楚地表明 Protobuf 也会产生编码开销：序列化的 Protobuf 消息比原始数据大 11MB。包括 Protobuf 在内的任何编码都涉及结构化数据，这不可避免地会增加字节。
序列化的 200 万个 `NumPair` 实例中的每个实例都包含**四**个整数值：Go 结构中的 `Even` 和 `Odd` 字段分别一个，而 Protobuf 编码中的每个字段、每个标签一个。对于原始数据（而不是编码数据），每个实例将达到 16 个字节，样本 `NumPairs` 消息中有 200 万个实例。但是 Protobuf 标记（如 `NumPair` 字段中的 `int32` 值）使用 `varint` 编码，因此字节长度有所不同。特别是，小的整数值（在这种情况下，包括标签在内）需要不到四个字节进行编码。
如果对 `numPairs` 程序进行了修改，以使两个 `NumPair` 字段的值小于 2048，且其编码为一或两个字节，则 Protobuf 编码将从 27MB 下降到 16MB，这正是原始数据的大小。下表总结了样本运行中的新编码大小。
| 编码 | 文件 | 字节大小 | Pbuf/其它 比例 |
| --- | --- | --- | --- |
| None | pairs.raw | 16MB | 100% |
| Protobuf | pairs.pbuf | 16MB | — |
| JSON | pairs.json | 77MB | 21% |
| XML | pairs.xml | 103MB | 15% |
*表 3. 编码 16MB 的小于 2048 的整数*
总之，修改后的 `numPairs` 程序的字段值小于 2048，可减少原始数据中每个四字节整数值的大小。但是 Protobuf 编码仍然需要标签，这些标签会在 Protobuf 消息中添加字节。Protobuf 编码确实会增加消息大小，但是如果要编码相对较小的整数值（无论是字段还是键），则可以通过 `varint` 因子来减少此开销。
对于包含混合类型的结构化数据（且整数值相对较小）的中等大小的消息，Protobuf 明显优于 XML 和 JSON 等选项。在其他情况下，数据可能不适合 Protobuf 编码。例如，如果两个应用程序需要共享大量文本记录或大整数值，则可以采用压缩而不是编码技术。
---
via: <https://opensource.com/article/19/10/protobuf-data-interchange>
作者：[Marty Kalin](https://opensource.com/users/mkalindepauledu) 选题：[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/) 荣誉推出
|
使用 apt-get 清理
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3453032/cleaning-up-with-apt-get.html
|
大多数使用基于 Debian 的系统的人通常会使用 apt-get 来安装软件包和升级，但是我们多久才清理一次？让我们看下该工具本身的一些清理选项。
|
/data/attachment/album/201911/22/082025p39oeuufdote517e.jpg.thumb.jpg
|
/data/attachment/album/201911/22/082025p39oeuufdote517e.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"apt-get"
] |
技术
|
{
"viewnum": 11187,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
大多数使用基于 Debian 的系统的人通常会使用 apt-get 来安装软件包和升级，但是我们多久才清理一次？让我们看下该工具本身的一些清理选项。
| 2019-11-22T08:20:49 | 2019-11-22T08:20:49 | 11,601 |
/article-11601-1.html
|
>
> 大多数使用基于 Debian 的系统的人通常会使用 apt-get 来安装软件包和升级，但是我们多久才清理一次？让我们看下该工具本身的一些清理选项。
>
>
>
在基于 Debian 的系统上运行 `apt-get` 命令是很常规的。软件包的更新相当频繁，诸如 `apt-get update` 和 `apt-get upgrade` 之类的命令使此过程非常容易。另一方面，你多久使用一次 `apt-get clean`、`apt-get autoclean` 或 `apt-get autoremove`？
这些命令会在 `apt-get` 的安装操作后清理并删除仍在系统上但不再需要的文件，这通常是因为需要它们的程序已经卸载。
### apt-get clean
`apt-get clean` 命令清除遗留在 `/var/cache` 中的已取回的包文件的本地仓库。它清除的目录是 `/var/cache/apt/archives/` 和 `/var/cache/apt/archives/partial/`。它留在 `/var/cache/apt/archives` 中的唯一文件是 `lock` 文件和 `partial` 子目录。
在运行清理操作之前，目录中可能包含许多文件：
```
/var/cache/apt/archives/db5.3-util_5.3.28+dfsg1-0.6ubuntu1_amd64.deb
/var/cache/apt/archives/db-util_1%3a5.3.21~exp1ubuntu2_all.deb
/var/cache/apt/archives/lock
/var/cache/apt/archives/postfix_3.4.5-1ubuntu1_amd64.deb
/var/cache/apt/archives/sasl2-bin_2.1.27+dfsg-1build3_amd64.deb
```
之后，只会存在这些：
```
$ sudo ls -lR /var/cache/apt/archives
/var/cache/apt/archives:
total 4
-rw-r----- 1 root root 0 Jan 5 2018 lock
drwx------ 2 _apt root 4096 Nov 12 07:24 partial
/var/cache/apt/archives/partial:
total 0 <== 空
```
`apt-get clean` 命令通常用于根据需要清除磁盘空间，一般作为定期计划维护的一部分。
### apt-get autoclean
`apt-get autoclean` 类似于 `apt-get clean`，它会清除已检索包文件的本地仓库，但它只会删除不会再下载且几乎无用的文件。它有助于防止缓存过大。
### apt-get autoremove
`apt-get autoremove` 将删除自动安装的软件包，因为某些其他软件包需要它们，但是在删除了其他软件包之后，而不再需要它们。有时会在升级时建议运行此命令。
```
The following packages were automatically installed and are no longer required:
g++-8 gir1.2-mutter-4 libapache2-mod-php7.2 libcrystalhd3
libdouble-conversion1 libgnome-desktop-3-17 libigdgmm5 libisl19 libllvm8
liblouisutdml8 libmutter-4-0 libmysqlclient20 libpoppler85 libstdc++-8-dev
libtagc0 libvpx5 libx265-165 php7.2 php7.2-cli php7.2-common php7.2-json
php7.2-opcache php7.2-readline
Use 'sudo apt autoremove' to remove them. <==
```
要删除的软件包通常称为“未使用的依赖项”。实际上，一个好的做法是在卸载软件包后使用 `autoremove`，以确保不会留下不需要的文件。
---
via: <https://www.networkworld.com/article/3453032/cleaning-up-with-apt-get.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/) 荣誉推出
|
Zorin OS 15 Lite 发布：好看的轻量级 Linux
|
Ankush Das
|
https://itsfoss.com/zorin-os-lite/
|
Zorin OS 15 Lite 版刚刚发布。我们将向你展示此新版本的桌面体验，并向你重点展示其主要功能。
|
/data/attachment/album/201911/23/093708axez5ntegftjgtkk.jpg.thumb.jpg
|
/data/attachment/album/201911/23/093708axez5ntegftjgtkk.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Zorin"
] |
新闻
|
{
"viewnum": 6702,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Zorin OS 15 Lite 版刚刚发布。我们将向你展示此新版本的桌面体验，并向你重点展示其主要功能。
| 2019-11-23T09:37:06 | 2019-11-23T09:37:06 | 11,603 |
/article-11603-1.html
|
>
> Zorin OS 15 Lite 版刚刚发布。我们将向你展示此新版本的桌面体验，并向你重点展示其主要功能。
>
>
>
[Zorin OS](https://zorinos.com/) 是一款日益流行的 Linux 发行版。它基于 Ubuntu，因此，毫不奇怪，它也正是[适合初学者的最佳 Linux 发行版](https://itsfoss.com/best-linux-beginners/)之一。 类似 Windows 的界面是许多从 Windows 到 Linux 的迁移者偏爱它的主要原因之一。
Zorin OS 有两个主要变体：
* Zorin Core：它使用 GNOME 桌面，用于较新的机器。
* Zorin Lite：它使用轻量级的 [Xfce 桌面](https://www.xfce.org/)，可以用作[老旧的笔记本电脑和计算机的 Linux](https://itsfoss.com/lightweight-linux-beginners/)。
### Zorin OS 15 Lite：新特性
Zorin OS 15 Core 发布之后过了很久，Zorin OS 15 Lite 版终于出现了。你现在就可以使用免费的 Lite 版或付费的 Lite Ultimate 版。
我尝试了 Zorin OS 15 Lite Ultimate 版。在本文中，我将介绍此版本的详细信息以及在为你的计算机下载 Zorin OS 15 Lite 之前应了解的知识。
Zorin OS 15 Lite 与全面的 Zorin OS 15 版本基本差不多。你可以在我们的原来的报道中查看 [Zorin OS 15 的功能](/article-11058-1.html)。
此发行版重点关注资源，因此过去十年中任何类型的旧硬件配置都可以轻松地在其上运行。
在此版本中，它们依靠基于 Xfce 4.14 的轻量级桌面环境在低规格计算机上提供了最佳体验。除了 Xfce 桌面环境外，与使用 GNOME 的完整版本相比，它还做了一些底层更改。
#### Zorin OS 15 Lite 是针对 Windows 7 用户的
Zorin OS 15 Lite 主要针对 Windows 7 用户，因为对 Windows 7 的官方支持结束于今年 1 月。因此，如果你对 Windows 7 感到满意，可以尝试一下，切换到此版本应该是一种流畅的体验。
Zorin OS 15 Lite 允许你在 “Zorin 外观”设置中将布局切换为 macOS 风格/ Windows 风格的外观。
#### 32 位和 64 位支持
很高兴看到 Zorin OS 考虑到对 32 位/ 64 位 ISO 的支持，因为 Lite 版本是针对具有低规格硬件的用户的。
#### 默认启用 Flatpak 支持
你可以使用软件中心利用 Flathub 来立即安装 Flatpak 软件包。如果你不确定该怎么做，请务必查看有关[使用 Flatpak](https://itsfoss.com/flatpak-guide/)的指南。
除此之外，你已经拥有 Snap 软件包支持。因此，通过软件中心安装任何内容应该更容易。
#### 用户界面的印象
老实说，默认的 Xfce 界面看起来很陈旧。有一些方法可以 [定制 Xfce](https://itsfoss.com/customize-xfce/)，但是 Zorin 也可以开箱即用。定制外观给人以良好印象。它看起来非常整洁，可以按预期工作。
#### 性能
即使我没有在超级老旧的系统上尝试过，但我也在老式硬盘上安装了它，它难以启动 Ubuntu 或类似发行版。
根据我的体验，我可以肯定该性能非常出色。感觉就好像我将其安装在 SSD 上。这显然是一件好事。如果你碰巧在超级老旧的系统上尝试使用它，可以在本文底部的评论部分中告诉我您的经验。
### Ultimate Lite 版和免费的 Lite 版有何区别？
没错，你可以免费下载 Zorin OS 15。
但是，有一个单独的“终极版”（Ultimate），其基本目的是用来支持该项目及其开发者。除此之外，它还捆绑了许多预安装的软件，作为计算机的“最终”软件包。
因此，如果你购买 Ultimate 版，则可以访问 Lite 版和完整版。
如果你不想为此付费，仍然可以根据需要选择免费版本（Core、Lite、Education）。你可以在它们的[下载页面](https://zorinos.com/download/)上了解更多信息。
### 如何下载 Zorin OS 15 Lite？
你可以转到其[官方下载网页](https://zorinos.com/download/)，然后向下滚动找到 Zorin OS 15 Lite 版。
你可以找到 32 位/ 64 位的 ISO，可以下载所需的 ISO。
* [Zorin OS 15 Lite](https://zorinos.com/download/)
安装 Zorin OS 与安装 Ubuntu 类似。
### 总结
虽然 Zorin OS 15 作为向 Windows / macOS 老手提供的 Linux 发行版已经是一个不错的产品，但新的 Lite 版本肯定会吸引更多的眼球。
您是否尝试过 Lite 版？在下面的评论中让我知道你的想法。
---
via: <https://itsfoss.com/zorin-os-lite/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[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/) 荣誉推出
|
使用 Flutter 开发简单的 Web 应用
|
Jis Joe Mathew
|
https://opensourceforu.com/2019/11/developing-a-simple-web-application-using/
|
本文指导读者如何使用 Flutter 运行和部署第一个 Web 应用。
|
/data/attachment/album/201911/23/100430bf3mtnbrv7btftz2.png.thumb.jpg
|
/data/attachment/album/201911/23/100430bf3mtnbrv7btftz2.png
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"Flutter"
] |
软件开发
|
{
"viewnum": 7738,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文指导读者如何使用 Flutter 运行和部署第一个 Web 应用。
| 2019-11-23T10:01:00 | 2019-11-23T10:01:00 | 11,604 |
/article-11604-1.html
|
>
> 本文指导读者如何使用 Flutter 运行和部署第一个 Web 应用。
>
>
>
Flutter 在 Android 和 iOS 开发方面走了很长一段路之后，已经迈入了一个新的阶段，即 Web 开发。Google 发布了 Flutter 1.5，同时支持 Web 应用开发。
### 为 Web 开发配置 Flutter
为了使用 Web 包，输入命令 `flutter upgrade` 更新到 Flutter 1.5.4。
* 打开终端
* 输入 `flutter upgrade`
* 输入 `flutter –version` 检查版本
也可以将 Android Studio 3.0 或更高版本用于 Flutter Web 开发，但在本教程中，我们使用 Visual Studio Code。
### 使用 Flutter Web 创建新项目
打开 Visual Studio Code，然后按 `Shift+Ctrl+P` 开始一个新项目。输入 `flutter` 并选择 “New Web Project”。
现在，为项目命名。我将其命名为 `open_source_for_you`。
在 VSC 中打开终端窗口，然后输入以下命令：
```
flutter packages pub global activate webdev
flutter packages upgrade
```
现在，使用以下命令在 localhost 上运行网站，IP 地址是 127.0.0.1。
```
flutter packages pub global run webdev serve
```
打开任何浏览器，然后输入 `http://127.0.0.1:8080/`。
在项目目录中有个 Web 文件夹，其中包含了 `index.html`。`dart` 文件被编译成 JavaScript 文件，并使用以下代码包含在 HTML 文件中：
```
<script defer src="main.dart.js" type="application/javascript"></script>
```
### 编码和修改演示页面
让我们创建一个简单的应用，它会在网页上打印 “Welcome to OSFY”。
现在打开 Dart 文件，它位于 `lib` 文件夹 `main.dart`（默认名）中（参见图 5）。
现在，我们可以在 `MaterialApp` 的属性中删除调试标记，如下所示：
```
debugShowCheckedModeBanner: false
```
现在，向 Dart 中添加更多内容与用 Dart 编写 Flutter 很类似。为此，我们可以声明一个名为 `MyClass` 的类，它继承了 `StatelessWidget`。
我们使用 `Center` 部件将元素定位到中心。我们还可以添加 `Padding` 部件来添加填充。使用以下代码获得图 5 所示的输出。使用刷新按钮查看更改。
```
class MyClass extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Scaffold(
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
Padding(
padding: EdgeInsets.all(20.0),
child: Text(
'Welcome to OSFY',
style: TextStyle(fontSize: 24.0, fontWeight: FontWeight.bold),
),
),
],
),
),
);
}
}
```
让我们从互联网中添加一张图片，我已经从一个杂志网站选择了一张 “Open Source for You” 徽标。我们使用 `Image.network`。
```
Image.network(
'https://opensourceforu.com/wp-content/uploads/2014/03/OSFY-Logo.jpg',
height: 100,
width: 150
),
```
最终输出如图 7 所示。
---
via: <https://opensourceforu.com/2019/11/developing-a-simple-web-application-using/>
作者：[Jis Joe Mathew](https://opensourceforu.com/author/jis-joe/) 选题：[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/) 荣誉推出
|
容器如何工作：OverlayFS
|
Julia Evans
|
https://jvns.ca/blog/2019/11/18/how-containers-work--overlayfs/
|
你可以运行一条 mount 咒语，而实际上并没有做任何与容器相关的其他事情，看看叠加层是如何工作的！
|
/data/attachment/album/201911/23/102537d50a06jizddcc0c8.jpg.thumb.jpg
|
/data/attachment/album/201911/23/102537d50a06jizddcc0c8.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"容器"
] |
容器与云
|
{
"viewnum": 5419,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "1.192.90.183",
"message": "删除文件后的验证部分似乎有错误，另外为何挂载 work 目录没有解释",
"username": "来自河南郑州的 Firefox 70.0|GNU/Linux 用户",
"date": "2019-11-23T17:58:50"
}
] |
[] |
你可以运行一条 mount 咒语，而实际上并没有做任何与容器相关的其他事情，看看叠加层是如何工作的！
| 2019-11-23T10:25:32 | 2019-11-23T10:25:32 | 11,605 |
/article-11605-1.html
|
今天早上，我为未来潜在容器[杂志](https://wizardzines.com)画了一幅 OverlayFS 的漫画，我对这个主题感到兴奋，想写一篇关于它的博客来提供更多详细信息。
### 容器镜像很大
容器镜像可能会很大（尽管有些很小，例如 [alpine linux 才 2.5MB](https://hub.docker.com/_/alpine?tab=tags)）。Ubuntu 16.04 约为 27 MB，[Anaconda Python 发行版为 800MB 至 1.5GB](https://hub.docker.com/r/continuumio/anaconda3/tags)。
你以镜像启动的每个容器都是原始空白状态，仿佛它只是为使用容器而复制的一份镜像拷贝一样。但是对于大的容器镜像，像 800MB 的 Anaconda 镜像，复制一份拷贝既浪费磁盘空间也很慢。因此 Docker 不会复制，而是采用**叠加**。
### 叠加如何工作
OverlayFS，也被称为 **联合文件系统**或 **联合挂载**，它可让你使用 2 个目录挂载文件系统：“下层”目录和“上层”目录。
基本上：
* 文件系统的**下层**目录是只读的
* 文件系统的**上层**目录可以读写
当进程“读取”文件时，OverlayFS 文件系统驱动将在上层目录中查找并从该目录中读取文件（如果存在）。否则，它将在下层目录中查找。
当进程“写入”文件时，OverlayFS 会将其写入上层目录。
### 让我们使用 mount 制造一个叠加层！
这有点抽象，所以让我们制作一个 OverlayFS 并尝试一下！这将只包含一些文件：我将创建上、下层目录，以及用来挂载合并的文件系统的 `merged` 目录：
```
$ mkdir upper lower merged work
$ echo "I'm from lower!" > lower/in_lower.txt
$ echo "I'm from upper!" > upper/in_upper.txt
$ # `in_both` is in both directories
$ echo "I'm from lower!" > lower/in_both.txt
$ echo "I'm from upper!" > upper/in_both.txt
```
合并上层目录和下层目录非常容易：我们可以通过 `mount` 来完成！
```
$ sudo mount -t overlay overlay
-o lowerdir=/home/bork/test/lower,upperdir=/home/bork/test/upper,workdir=/home/bork/test/work
/home/bork/test/merged
```
在执行此操作时，我不断收到一条非常烦人的错误消息，内容为：`mount: /home/bork/test/merged: special device overlay does not exist.`。这条消息是错误的，实际上只是意味着我指定的一个目录缺失（我写成了 `~/test/merged`，但它没有被展开）。
让我们尝试从 OverlayFS 中读取其中一个文件！文件 `in_both.txt` 同时存在于 `lower/` 和 `upper/` 中，因此应从 `upper/` 目录中读取该文件。
```
$ cat merged/in_both.txt
"I'm from upper!
```
可以成功！
目录的内容就是我们所期望的：
```
find lower/ upper/ merged/
lower/
lower/in_lower.txt
lower/in_both.txt
upper/
upper/in_upper.txt
upper/in_both.txt
merged/
merged/in_lower.txt
merged/in_both.txt
merged/in_upper.txt
```
### 创建新文件时会发生什么？
```
$ echo 'new file' > merged/new_file
$ ls -l */new_file
-rw-r--r-- 1 bork bork 9 Nov 18 14:24 merged/new_file
-rw-r--r-- 1 bork bork 9 Nov 18 14:24 upper/new_file
```
这是有作用的，新文件会在 `upper` 目录创建。
### 删除文件时会发生什么？
读写似乎很简单。但是删除会发生什么？开始试试！
```
$ rm merged/in_both.txt
```
发生了什么？让我们用 `ls` 看下：
```
ls -l upper/in_both.txt lower/lower1.txt merged/lower1.txt
ls: cannot access 'merged/in_both.txt': No such file or directory
-rw-r--r-- 1 bork bork 6 Nov 18 14:09 lower/in_both.txt
c--------- 1 root root 0, 0 Nov 18 14:19 upper/in_both.txt
```
所以：
* `in_both.txt` 仍在 `lower` 目录中，并且保持不变
* 它不在 `merged` 目录中。到目前为止，这就是我们所期望的。
* 但是在 `upper` 中发生的事情有点奇怪：有一个名为 `upper/in_both.txt` 的文件，但是它是字符设备？我想这就是 overlayfs 驱动表示删除的文件的方式。
如果我们尝试复制这个奇怪的字符设备文件，会发生什么？
```
$ sudo cp upper/in_both.txt upper/in_lower.txt
cp: cannot open 'upper/in_both.txt' for reading: No such device or address
```
好吧，这似乎很合理，复制这个奇怪的删除信号文件并没有任何意义。
### 你可以挂载多个“下层”目录
Docker 镜像通常由 25 个“层”组成。OverlayFS 支持具有多个下层目录，因此你可以运行：
```
mount -t overlay overlay
-o lowerdir:/dir1:/dir2:/dir3:...:/dir25,upperdir=...
```
因此，我假设这是有多个 Docker 层的容器的工作方式，它只是将每个层解压缩到一个单独的目录中，然后要求 OverlayFS 将它们全部合并在一起，并使用一个空的上层目录，容器将对其进行更改。
### Docker 也可以使用 btrfs 快照
现在，我使用的是 ext4，而 Docker 使用 OverlayFS 快照来运行容器。但是我曾经用过 btrfs，接着 Docker 将改为使用 btrfs 的写时复制快照。（这是 Docker 何时使用哪种[存储驱动](https://docs.docker.com/storage/storagedriver/select-storage-driver/)的列表）
以这种方式使用 btrfs 快照会产生一些有趣的结果：去年某个时候，我在笔记本上运行了数百个临时的 Docker 容器，这导致我用尽了 btrfs 元数据空间（像[这个人](https://www.reddit.com/r/archlinux/comments/5jrmfe/btrfs_metadata_and_docker/)一样）。这真的很令人困惑，因为我以前从未听说过 btrfs 元数据，而且弄清楚如何清理文件系统以便再次运行 Docker 容器非常棘手。（[这个 docker github 上的提案](https://github.com/moby/moby/issues/27653)描述了 Docker 和 btrfs 的类似问题）
### 以简单的方式尝试容器功能很有趣！
我认为容器通常看起来像是在做“复杂的”事情，我认为将它们分解成这样很有趣。你可以运行一条 `mount` 咒语，而实际上并没有做任何与容器相关的其他事情，看看叠加层是如何工作的！
---
via: [https://jvns.ca/blog/2019/11/18/how-containers-work–overlayfs/](https://jvns.ca/blog/2019/11/18/how-containers-work--overlayfs/)
作者：[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 更快吗？
|
Oracle
|
https://www.linux.com/blog/can-better-task-stealing-make-linux-faster
|
Oracle Linux 内核开发人员 Steve Sistare 参与了这场有关内核调度程序改进的讨论。
|
/data/attachment/album/201911/23/235729l71755he6e4mpvkq.jpg.thumb.jpg
|
/data/attachment/album/201911/23/235729l71755he6e4mpvkq.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"内核",
"CPU"
] |
技术
|
{
"viewnum": 4748,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Oracle Linux 内核开发人员 Steve Sistare 参与了这场有关内核调度程序改进的讨论。
| 2019-11-23T23:58:15 | 2019-11-23T23:58:15 | 11,607 |
/article-11607-1.html
|
>
> Oracle Linux 内核开发人员 Steve Sistare 参与了这场有关内核调度程序改进的讨论。
>
>
>
### 通过可扩展的任务窃取进行负载平衡
Linux 任务调度程序通过将唤醒的任务推送到空闲的 CPU，以及在 CPU 空闲时从繁忙的 CPU 中拉取任务来平衡整个系统的负载。在大型系统上的推送侧和拉取侧，有效的伸缩都是挑战。对于拉取，调度程序搜索连续的更大范围中的所有 CPU，直到找到过载的 CPU，然后从最繁忙的组中拉取任务。这代价非常昂贵，在大型系统上要花费 10 到 100 微秒，因此搜索时间受到平均空闲时间的限制，并且某些范围不会被搜索。并非总能达到平衡，而且闲置的 CPU 依旧闲置。
我实现了一种备用机制，该机制在 `idle_balance()` 中的现有搜索中自身受限并且没有找到之后被调用。我维护了一个过载的 CPU 的位图，当可运行的 CFS 任务计数超过 1 时，CPU 会设置该位。这个位图是稀疏的，每个高速缓存线的有效位数量有限。当许多线程同时设置、清除和访问元素时，这可以减少缓存争用。每个末级缓存都有一个位图。当 CPU 空闲时，它将搜索该位图以查找第一个具有可迁移任务的过载 CPU，然后将其窃取。这种简单的窃取会比单独的 `idle_balance()` 产生更高的 CPU 利用率，因为该搜索的成本很便宜，花费 1 到 2 微秒，因此每次 CPU 即将空闲时都可以调用它。窃取不会减轻全局最繁忙的队列的负担，但是它比根本不执行任何操作要好得多。
### 结果
偷窃仅在调度程序代码中占用少量 CPU 开销即可提高利用率。在以下实验中，以不同数量的组（每个组 40 个任务）运行 hackbench，并对每次运行结果显示 `/proc/schedstat` 中的增量（按 CPU 平均），并增加了这些非标准的统计信息：
* `％find`：在旧函数和新函数中花费的时间百分比，这些函数用于搜索空闲的 CPU 和任务以窃取并设置过载的 CPU 位图。
* `steal`：任务从另一个 CPU 窃取的次数。经过的时间增加了 8％ 到 36％，最多增加了 0.4％ 的发现时间。
如下图的绿色曲线所示，新内核的 CPU 繁忙利用率接近 100％，作为比较的基线内核是橙色曲线： 
根据负载的不同，窃取可将 Oracle 数据库 OLTP 性能提高多达 9％，并且我们已经看到 MySQL、Pgsql、gcc、Java 和网络方面有了一些不错的改进。通常，窃取对上下文切换率高的工作负载最有帮助。
### 代码
截至撰写本文时，这项工作尚未完成，但最新的修补程序系列位于 <https://lkml.org/lkml/2018/12/6/1253>。如果你的内核是使用 `CONFIG_SCHED_DEBUG=y` 构建的，则可以使用以下命令验证其是否包含窃取优化：
```
# grep -q STEAL /sys/kernel/debug/sched_features && echo Yes
Yes
```
如果要尝试使用，请注意，对于具有 2 个以上 NUMA 节点的系统，禁用了窃取功能，因为 hackbench 在此类系统上发生了回归，正如我在 <https://lkml.org/lkml/2018/12/6/1250> 中解释的那样。但是，我怀疑这种影响是特定于 hackbench 的，并且窃取将有助于多节点系统上的其他工作负载。要尝试使用它，请用内核参数 `sched_steal_node_limit=8`（或更大）重新启动。
### 进一步工作
在将基本盗用算法推向上游之后，我正在考虑以下增强功能：
* 如果在末级缓存中进行窃取找不到候选者，在 LLC 和 NUMA 节点之间进行窃取。
* 维护稀疏位图以标识 RT 调度类中的偷窃候选者。当前 `pull_rt_task()` 搜索所有运行队列。
* 从 `idle_balance()` 中删除核心和套接字级别，因为窃取会处理这些级别。当支持跨 LLC 窃取时，完全删除 `idle_balance()`。
* 维护位图以标识空闲核心和空闲 CPU，以实现推平衡。
这篇文章最初发布于 [Oracle Developers Blog](https://blogs.oracle.com/linux/can-better-task-stealing-make-linux-faster)。
---
via: <https://www.linux.com/blog/can-better-task-stealing-make-linux-faster>
作者：[Oracle](https://www.linux.com/author/oracle/) 选题：[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/) 荣誉推出
|
你需要知道什么才能成为系统管理员？
|
Seth Kenlon
|
https://opensource.com/article/19/7/be-a-sysadmin
|
通过获得这些起码的能力，开始你的系统管理员职业。
|
/data/attachment/album/201911/24/103900w5m09jyyyeyrnovu.jpg.thumb.jpg
|
/data/attachment/album/201911/24/103900w5m09jyyyeyrnovu.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"系统管理员"
] |
观点
|
{
"viewnum": 5540,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过获得这些起码的能力，开始你的系统管理员职业。
| 2019-11-24T10:39:18 | 2019-11-24T10:39:18 | 11,608 |
/article-11608-1.html
|
>
> 通过获得这些起码的能力，开始你的系统管理员职业。
>
>
>
昔日的系统管理员整天都在调教用户和摆弄服务器，一天的时间都奔波在几百米长的电缆之间。随着云计算、容器和虚拟机的复杂性的增加，而今依然如此。
以外行人来看，很难准确确定系统管理员的确切职能，因为他们在许多地方都扮演着一个不起眼的角色。没人能在培训中知道自己工作中所需要的一切知识，但是每个人其实都需要一个坚实的基础。如果你想走上系统管理的道路，那么这是你个人自学或在正式培训中应重点关注的内容。
### Bash
当你学习 Bash Shell 时，你学习的不仅是 Bash Shell，你学习的也是 Linux、BSD、MacOS 甚至Windows（在适当条件下）的通用界面。你将了解语法的重要性，因此可以快速适应思科路由器的命令行或微软 PowerShell 等系统，最终你甚至可以学习更强大的语言，如 Python 或 Go。而且，你还会开始进行程序性思考，以便可以分析复杂的问题并将其分解为单个组件，这很关键，因为这就是系统（例如互联网、组织的内部网、Web 服务器、备份解决方案）是如何设计的。
不止于此，还有更多。
由于最近 DevOps 和[容器](https://opensource.com/article/19/6/kubernetes-dump-truck)的发展趋势，了解 Bash shell 变得尤为重要。你的系统管理员职业可能会将你带入一个视基础设施为代码的世界，这通常意味着你必须了解脚本编写的基础知识、[基于 YAML](https://www.redhat.com/sysadmin/yaml-tips)配置的结构，以及如何与[容器](https://opensource.com/resources/what-are-linux-containers)（运行在[沙盒文件](https://opensource.com/article/18/11/behind-scenes-linux-containers)内部的微型 Linux 系统）[交互](https://opensource.com/article/19/6/how-ssh-running-container)。你会知道 Bash 是高效管理激动人心的开源技术的门户，因此请进入 [Bash](https://opensource.com/article/18/7/admin-guide-bash) 世界吧。
#### 资源
有很多方法可以在 Bash shell 中进行练习。
尝试一下[便携式 Linux 发行版](https://opensource.com/article/19/6/linux-distros-to-try)。你无需安装 Linux 即可使用 Linux，因此，请拿一块闲置的 U 盘，花个晚上或周末的空闲时光，来适应基于文本的界面。
这里有[几篇很棒的](https://www.redhat.com/sysadmin/managing-files-linux-terminal) [Bash 文章](https://opensource.com/tags/bash)。
要注意的是 Bash 练习的关键在于要练习，你必须有要做的练习才行。而且，在你知道如何使用 Bash 之前，你可能不知道该练习什么。如果是这样，请去 Over The Wire 玩一下 [Bandit](http://overthewire.org/wargames/bandit) 游戏。这是一款针对绝对初学者的游戏，具有 34 个级别的交互式基本技巧，可让你熟悉 Linux shell。
### Web 服务器设置
一旦你习惯了 Bash，你应该尝试设置一个 Web 服务器。并不是所有的系统管理员都会四处设置 Web 服务器甚至维护 Web 服务器，但是你在安装和启动 HTTP 守护程序、配置 Apache 或 Nginx，设置[正确权限](https://opensource.com/article/19/6/understanding-linux-permissions)和[配置防火墙](https://www.redhat.com/sysadmin/secure-linux-network-firewall-cmd)时所掌握的技能是你每天都需要使用的技能。经过一些努力，你可能会开始注意到自己的某些工作模式。在尝试管理可用于生产环境的软件和硬件之前，你可能认为某些概念是理所当然的，而你在成为新手的管理员角色时，将不再受到它们的影响。起初这可能会令人沮丧，因为每个人都喜欢在自己做好所做的事情，但这实际上是一件好事。让自己接触新技能，那就是你学习的方式。
此外，你在第一步中付出的努力越多，最终当你在默认的 index.html 上看到胜利的“it works!”就越甜蜜！
#### 资源
David Both 撰写了有关 [Apache Web 服务器](https://opensource.com/article/18/2/how-configure-apache-web-server)配置的出色文章。值得一提的是，请逐步阅读他的后续文章，其中介绍了如何在一台计算机上[托管多个站点](https://opensource.com/article/18/3/configuring-multiple-web-sites-apache)。
### DHCP
动态主机配置协议（DHCP）是为网络上的设备分配 IP 地址的系统。在家里，ISP（互联网服务提供商）支持的调制解调器或路由器可能内置了 DHCP 服务器，因此可能不在你的权限范围内。如果你曾经登录家用路由器来调整 IP 地址范围或为某些网络设备设置了静态地址，那么你至少对该概念有所了解。你可能会将其理解为对网络上的设备分配了一种 IP 地址形式的电话号码，并且你可能会意识到计算机之间通过广播发送到特定 IP 地址的消息彼此进行通信。消息标头由路径上的路由器读取，每个消息标头都将消息定向到路径上的第二个逻辑路由器，以达到其最终目标。
即使你了解了这些概念，要从对 DHCP 的基本了解再进一步是架设 DHCP 服务器。安装和配置自己的 DHCP 服务器可能会导致家庭网络中的 DHCP 冲突（如果可以的话，请尽量避免这样做，因为它肯定会干掉你的网络，直到解决为止），要控制地址的分配、创建子网，并监控连接和租赁时间。
更重要的是，设置 DHCP 并尝试不同的配置有助于你了解网络之间的关系。你会了解网络如何在数据传输中表示“分区”，以及必须采取哪些步骤才能将信息从一个网络传递到另一个。这对于系统管理员来说至关重要，因为网络肯定是工作中最重要的方面之一。
#### 资源
在运行自己的 DHCP 服务器之前，请确保家庭路由器（如果有）中的 DHCP 服务器处于非活动状态。一旦启动并运行了 DHCP 服务器，请阅读 Archit Modi 的[网络命令指南](https://opensource.com/article/18/7/sysadmin-guide-networking-commands)，以获取有关如何探索网络的提示。
### 网络电缆
这听起来很普通，但是熟悉网络电缆的工作方式不仅使你的周末变得非常有趣，而且还使你对数据是如何通过缆线的得到了全新的了解。最好的学习方法是去当地的业余爱好商店并购买五类线剥线钳和压线钳以及一些五类线水晶头。然后回家，拿一根备用的以太网电缆，切断水晶头，花一些时间重新制作网线接头，将电缆重新投入使用。
解决了这个难题后，请再做一次，这次创建一条有效的[交叉电缆](https://en.wikipedia.org/wiki/Ethernet_crossover_cable)。
你现在应该还在沉迷于有关电缆管理。如果你有些强迫症，喜欢沿着地板线或桌子的边缘整齐地排列电缆，或者将电缆绑在一起以保持它们的整齐有序，那么就可以使自己免受永久混乱的电缆困扰。你一开始可能不会理解这样做的必要性，但是当你第一次走进服务器机房时，你会马上知道原因。
### Ansible
[Ansible](https://opensource.com/sitewide-search?search_api_views_fulltext=ansible) 是配置管理软件，它在系统管理员和 DevOps 之间架起了一座桥梁。系统管理员使用 Ansible 来配置全新安装的操作系统并在计算机上维护特定的状态。DevOps 使用 Ansible 减少了在工具上花费的时间和精力，从而在开发上可以花费更多的时间和精力。作为系统管理员培训的一部分，你应该学习 Ansible，并着眼于 DevOps 实践，因为 DevOps 现在开创的大多数功能将最终成为将来系统管理中工作流的一部分。
Ansible 的好处是你可以立即开始使用它。它是跨平台的，并且可以向上和向下缩放。对于单用户计算机， Ansible 可能是小题大做，但是话又说回来，Ansible 可能会改变你启动虚拟机的方式，或者可以帮助你同步家庭或[家庭实验室](https://opensource.com/article/19/6/create-centos-homelab-hour)中所有计算机的状态。
#### 资源
阅读 Jay LaCroix 的[如何使用 Ansible 管理工作站配置](https://opensource.com/article/18/3/manage-workstation-ansible)中的典型介绍，以轻松地在日常之中开始使用 Ansible。
### 破坏
由于用户的错误、软件的错误、管理员（就是你！）的错误以及许多其他因素，计算机上会出现问题。无法预测将要失败的原因，因此你的个人系统管理员培训制度的一部分应该是破坏你设置的系统，直到它们失败为止。你自己的实验室基础设施越是脆弱，发现弱点的可能性就越大。而且，你越是经常修复这些弱点，你对解决问题的能力就越有信心。
除了严格设置所有常见的软件和硬件之外，作为系统管理员的主要工作是查找解决方案。有时候，你可能会遇到职位描述之外的问题，甚至可能无法解决，但这完全取决于你的解决方法。
现在，你越多地折腾并努力加以解决，则以系统管理员的身份进行的准备就越充分。
你是系统管理员吗？你是否希望自己为更好的任务做好准备？在下面的评论中写下它们！
---
via: <https://opensource.com/article/19/7/be-a-sysadmin>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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 平台上的写作者必备工具
|
Jack Wallen
|
https://www.linux.com/learn/2018/11/must-have-tools-writers-linux-platform
|
Linux 演进和基于 Web 的工具的相得益彰使得它可以让任何写作者都能在 Linux 上完成工作（并且做得很好）。
|
/data/attachment/album/201911/25/000129eee2zydelz22vj9h.jpg.thumb.jpg
|
/data/attachment/album/201911/25/000129eee2zydelz22vj9h.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"写作"
] |
分享
|
{
"viewnum": 9054,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux 演进和基于 Web 的工具的相得益彰使得它可以让任何写作者都能在 Linux 上完成工作（并且做得很好）。
| 2019-11-25T00:02:00 | 2019-11-25T00:02:00 | 11,610 |
/article-11610-1.html
|
我从事作家已有 20 多年了。我撰写了数千篇有关各种技术主题的文章和指南，并撰写了 40 多本小说。因此，书面文字不仅对我很重要，还很熟悉，成为了我的第二种自然交流的方式。在过去的二十年中（而且还在继续），我几乎都是在 Linux 平台上完成的所有工作。我必须承认，在早期，这并不总是那么容易。格式并不总是与编辑器所需要的相吻合，在某些情况下，开源平台根本没有完成工作所需的必要工具。
那时已经过去，现在已经不同了。
Linux 演进和基于 Web 的工具的相得益彰使得它可以让任何写作者都能在 Linux 上完成工作（并且做得很好）。但是你需要什么工具？你可能会惊讶地发现，在某些情况下，使用 100％ 开源的工具无法有效完成这项工作。不过即使如此，工作总是可以完成的。让我们来看看我作为技术作家和小说作者一直使用的工具。我将通过小说和非小说类的写作过程来概述这一点（因为过程不同，需要特定的工具）。
对认真的 Linux 硬核用户预先做个预警。很久以前，我就放弃了使用 LaTeX 和 DocBook 之类的工具进行写作。为什么？因为对我而言，重点必须放在内容上，而不是过程上。当你面临最后期限时，必须以效率为先。
### 非小说类
我们将从非虚构写作入手，因为这是两者中较简单的过程。为了编写技术指南，我与不同的编辑人员合作，并且在某些情况下，必须将内容复制/粘贴到 CMS 中。但是就像我的小说一样，整个过程总是从 Google 云端硬盘开始。在这一点上，许多开源纯粹主义者会转身走开。不用担心，你始终可以选择将所有文件保存在本地，也可以使用更开放友好的云服务（例如 [Zoho](https://www.zoho.com/) 或 [nextCloud](https://nextcloud.com/)）。
为什么要从云端开始？多年来，我发现我需要能够随时随地访问那些内容。最简单的解决方案是迁移到云上。我对丢失工作成果这件事也很偏执。为此，我使用了 [Insync](https://www.insynchq.com) 之类的工具来使我的 Google 云端硬盘与桌面保持同步。有了桌面同步功能，我知道我的工作成果总是有备份，以防万一 Google 云端硬盘出了问题。
对于那些我必须与之一起将内容输入到内容管理系统（CMS）的客户，该过程到此结束。我可以直接从 Google 文档复制/粘贴到 CMS 中，并完成此操作。当然，对于技术内容，总是涉及到屏幕截图。为此，我使用 [Gimp](https://www.gimp.org/)，它使得截取屏幕截图变得简单：
*图 1：使用 Gimp 截屏。*
1. 打开 Gimp。
2. 单击“文件>创建>屏幕快照”。
3. 选择单个窗口、整个屏幕或要抓取的区域（图 1）。
4. 单击“抓取”。
我的大多数客户倾向于使用 Google 文档，因为我可以共享文件夹，以便他们可以可靠地访问该内容。我有一些无法使用 Google 文档的客户，因此我必须将文件下载为可以使用的格式。为此，我要做的是下载 .odt 格式，以 [LibreOffice](https://www.libreoffice.org/) 打开文档（图 2），根据需要设置格式，保存为客户所需的格式，然后发送文档。
*图 2：在 LibreOffice 中打开我下载的 Google 文档。*
非小说类作品这样就行了。
### 小说类
这里会稍微变得有点复杂。开始的步骤是相同的，因为我总是在 Google 文档中写小说的每个初稿。完成后，我将文件下载到 Linux 桌面，在 LibreOffice 中打开文件，根据需要设置格式，然后另存为编辑器支持的文件类型（不幸的是，这意味着是 .docx）。
该过程的下一步变得有些琐碎。我的编辑更喜欢使用注释来跟踪更改（因为这使我们俩阅读文档和做出更改一样容易）。因此，一个 60k 的 word 文档可以包含成百上千的注释，这会使 LibreOffice 慢的像爬一样。从前，你可以增加用于文档的内存，但是从 LibreOffice 6 开始，这不再可行。这意味着任何较大的、像小说一样长的、带有大量注释的文档都将无法使用。因此，我不得不采取一些极端的措施，使用 [WPS Office](https://www.wps.com/en-US/)（图 3）。尽管这不是开源解决方案，但 WPS Office 在文档中包含大量注释的情况下做得很好，因此无需处理 LibreOffice 所带来的麻烦（当处理带有数百个注释的大型文件时）。
*图 3：WPS 可以轻松处理大量注释。*
一旦我和我的编辑完成了对书的编辑（所有评论都已删除），我就可以在 LibreOffice 中打开文件进行最终格式化。格式化完成后，我将文件保存为 .html 格式，然后以 [Calibre](https://calibre-ebook.com/) 打开文件以将文件导出为 .mobi 和 .epub 格式。
对于希望在 Amazon、Barnes＆Noble、Smashwords 或其他平台上出版的任何人，Calibre 都是必备工具。Caliber 比其他类似解决方案更好地方是，它使你可以直接编辑 .epub 文件（图 4）。对于 Smashword 来说，这是绝对必要的（因为导出过程将添加 Smashwords 转换工具上不接受的元素）。
*图 4：直接在 Calibre 中编辑 epub 文件。*
写作过程结束后（或有时在等待编辑完成一校时），我将开始为书制作封面。该任务完全在 Gimp 中处理（图 5）。
*图 5：在 Gimp 中创建 POTUS 的封面。*
这样就完成了在 Linux 平台上创建小说的过程。由于文档的篇幅以及某些编辑人员的工作方式，与创建非小说类的过程相比，它可能会变得有些复杂，但这远没有挑战性。实际上，在 Linux 上创建小说与其他平台一样简单（并且更可靠）。
### 希望这可以帮助你
我希望这可以帮助有抱负的作家有信心在 Linux 平台上进行写作。还有许多其他工具可供使用，但是多年来我在这里列出的工具很好地服务了我。而且，尽管我确实使用了几个专有的工具，但只要它们在 Linux 上都能正常运行，我觉得是可以的。
---
via: <https://www.linux.com/learn/2018/11/must-have-tools-writers-linux-platform>
作者：[Jack Wallen](https://www.linux.com/users/jlwallen) 选题：[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/) 荣誉推出
|
awk 中的字段、记录和变量
|
Seth Kenlon
|
https://opensource.com/article/19/11/fields-records-variables-awk
|
这个系列的第二篇，我们会学习字段，记录和一些非常有用的 Awk 变量。
|
/data/attachment/album/201911/25/090333m34qx395vwtxx5vx.jpg.thumb.jpg
|
/data/attachment/album/201911/25/090333m34qx395vwtxx5vx.jpg
| true | false | true |
lujun9972
|
wenwensnow
|
wxy
| false |
[
"awk"
] |
技术
|
{
"viewnum": 6288,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11543,
"displayorder": 0
},
{
"raid": 11636,
"displayorder": 0
}
] |
这个系列的第二篇，我们会学习字段，记录和一些非常有用的 Awk 变量。
| 2019-11-25T09:03:54 | 2019-11-25T09:03:54 | 11,611 |
/article-11611-1.html
|
>
> 这个系列的第二篇，我们会学习字段，记录和一些非常有用的 Awk 变量。
>
>
>
Awk 有好几个变种：最早的 `awk`，是 1977 年 AT&T 贝尔实验室所创。它还有一些重构版本，例如 `mawk`、`nawk`。在大多数 Linux 发行版中能见到的，是 GNU awk，也叫 `gawk`。在大多数 Linux 发行版中，`awk` 和 `gawk` 都是指向 GNU awk 的软链接。输入 `awk`，调用的是同一个命令。[GNU awk 用户手册](https://www.gnu.org/software/gawk/manual/html_node/History.html#History)中，能看到 `awk` 和 `gawk` 的全部历史。
这一系列的[第一篇文章](/article-11543-1.html) 介绍了 `awk` 命令的基本格式：
```
$ awk [选项] '模式 {动作}' 输入文件
```
`awk` 是一个命令，后面要接选项 （比如用 `-F` 来定义字段分隔符）。想让 `awk` 执行的部分需要写在两个单引号之间，至少在终端中需要这么做。在 `awk` 命令中，为了进一步强调你想要执行的部分，可以用 `-e` 选项来突出显示（但这不是必须的）：
```
$ awk -F, -e '{print $2;}' colours.txt
yellow
blue
green
[...]
```
### 记录和字段
`awk` 将输入数据视为一系列*记录*，通常是按行分割的。换句话说，`awk` 将文本中的每一行视作一个记录。每一记录包含多个*字段*。一个字段由*字段分隔符*分隔开来，字段是记录的一部分。
默认情况下，`awk` 将各种空白符，如空格、制表符、换行符等视为分隔符。值得注意的是，在 `awk` 中，多个*空格*将被视为一个分隔符。所以下面这行文本有两个字段：
```
raspberry red
```
这行也是：
```
tuxedo black
```
其他分隔符，在程序中不是这么处理的。假设字段分隔符是逗号，如下所示的记录，就有三个字段。其中一个字段可能会是 0 个字节（假设这一字段中不包含隐藏字符）
```
a,,b
```
### awk 程序
`awk` 命令的*程序部分*是由一系列规则组成的。通常来说，程序中每个规则占一行（尽管这不是必须的）。每个规则由一个模式，或一个或多个动作组成：
```
模式 { 动作 }
```
在一个规则中，你可以通过定义模式，来确定动作是否会在记录中执行。模式可以是简单的比较条件、正则表达式，甚至两者结合等等。
这个例子中，程序*只会*显示包含单词 “raspberry” 的记录：
```
$ awk '/raspberry/ { print $0 }' colours.txt
raspberry red 99
```
如果没有文本符合模式，该动作将会应用到所有记录上。
并且，在一条规则只包含模式时，相当于对整个记录执行 `{ print }`，全部打印出来。
Awk 程序本质上是*数据驱动*的，命令执行结果取决于数据。所以，与其他编程语言中的程序相比，它还是有些区别的。
### NF 变量
每个字段都有指定变量，但针对字段和记录，也存在一些特殊变量。`NF` 变量，能存储 `awk` 在当前记录中找到的字段数量。其内容可在屏幕上显示，也可用于测试。下面例子中的数据，来自上篇文章[文本](/article-11543-1.html)：
```
$ awk '{ print $0 " (" NF ")" }' colours.txt
name color amount (3)
apple red 4 (3)
banana yellow 6 (3)
[...]
```
`awk` 的 `print` 函数会接受一系列参数（可以是变量或者字符串），并将它们拼接起来。这就是为什么在这个例子里，每行结尾处，`awk` 会以一个被括号括起来的整数表示字段数量。
### NR 变量
另外，除了统计每个记录中的字段数，`awk` 也统计输入记录数。记录数被存储在变量 `NR` 中，它的使用方法和其他变量没有任何区别。例如，为了在每一行开头显示行号：
```
$ awk '{ print NR ": " $0 }' colours.txt
1: name color amount
2: apple red 4
3: banana yellow 6
4: raspberry red 3
5: grape purple 10
[...]
```
注意，写这个命令时可以不在 `print` 后的多个参数间添加空格，尽管这样会降低可读性：
```
$ awk '{print NR": "$0}' colours.txt
```
### printf() 函数
为了让输出结果时格式更灵活，你可以使用 `awk` 的 `printf()` 函数。 它与 C、Lua、Bash 和其他语言中的 `printf` 相类似。它也接受以逗号分隔的*格式*参数。参数列表需要写在括号里。
```
$ printf 格式, 项目1, 项目2, ...
```
格式这一参数（也叫*格式符*）定义了其他参数如何显示。这一功能是用*格式修饰符*实现的。`%s` 输出字符，`%d` 输出十进制数字。下面的 `printf` 语句，会在括号内显示字段数量：
```
$ awk 'printf "%s (%d)\n",$0,NF}' colours.txt
name color amount (3)
raspberry red 4 (3)
banana yellow 6 (3)
[...]
```
在这个例子里，`%s (%d)` 确定了每一行的输出格式，`$0,NF` 定义了插入 `%s` 和 `%d` 位置的数据。注意，和 `print` 函数不同，在没有明确指令时，输出不会转到下一行。出现转义字符 `\n` 时才会换行。
### Awk 脚本编程
这篇文章中出现的所有 `awk` 代码，都在 Bash 终端中执行过。面对更复杂的程序，将命令放在文件（*脚本*）中会更容易。`-f FILE` 选项（不要和 `-F` 弄混了，那个选项用于字段分隔符），可用于指明包含可执行程序的文件。
举个例子，下面是一个简单的 awk 脚本。创建一个名为 `example1.awk` 的文件，包含以下内容：
```
/^a/ {print "A: " $0}
/^b/ {print "B: " $0}
```
如果一个文件包含 `awk` 程序，那么在给文件命名时，最好写上 `.awk` 的扩展名。 这样命名不是强制的，但这么做，会给文件管理器、编辑器（和你）一个关于文件内容的很有用的提示。
执行这一脚本：
```
$ awk -f example1.awk colours.txt
A: raspberry red 4
B: banana yellow 6
A: apple green 8
```
一个包含 `awk` 命令的文件，在最开头一行加上释伴 `#!`，就能变成可执行脚本。创建一个名为 `example2.awk` 的文件，包含以下内容：
```
#!/usr/bin/awk -f
#
# 除了第一行，在其他行前显示行号
#
NR > 1 {
printf "%d: %s\n",NR,$0
}
```
可以说，脚本中只有一行，大多数情况下没什么用。但在某些情况下，执行一个脚本，比记住，然后打一条命令要容易的多。一个脚本文件，也提供了一个记录命令具体作用的好机会。以 `#` 号开头的行是注释，`awk` 会忽略它们。
给文件可执行权限：
```
$ chmod u+x example2.awk
```
执行脚本：
```
$ ./example2.awk colours.txt
2: apple red 4
2: banana yellow 6
4: raspberry red 3
5: grape purple 10
[...]
```
将 `awk` 命令放在脚本文件中，有一个好处就是，修改和格式化输出会更容易。在终端中，如果能用一行执行多条 `awk` 命令，那么输入多行，才能达到同样效果，就显得有些多余了。
### 试一试
你现在已经足够了解，`awk` 是如何执行指令的了。现在你应该能编写复杂的 `awk` 程序了。试着编写一个 awk 脚本，它需要: 至少包括一个条件模式，以及多个规则。如果你想使用除 `print` 和 `printf` 以外的函数，可以参考在线 [gawk 手册](https://www.gnu.org/software/gawk/manual/)。
下面这个例子是个很好的切入点：
```
#!/usr/bin/awk -f
#
# 显示所有记录 除了出现以下情况
# 如果第一个记录 包含 “raspberry”
# 将 “red” 替换成 “pi”
$1 == "raspberry" {
gsub(/red/,"pi")
}
{ print }
```
试着执行这个脚本，看看输出是什么。接下来就看你自己的了。
这一系列的下一篇文章，将会介绍更多，能在更复杂(更有用!) 脚本中使用的函数。
这篇文章改编自 [Hacker Public Radio](http://hackerpublicradio.org/eps.php?id=2129) 系列，一个技术社区博客。
---
via: <https://opensource.com/article/19/11/fields-records-variables-awk>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Linux 上使用 pkgsrc
|
Seth Kenlon
|
https://opensource.com/article/19/11/pkgsrc-netbsd-linux
|
NetBSD 的软件包管理器通用、灵活又容易。下面是如何使用它。
|
/data/attachment/album/201911/26/064538fbktfzxba18wykde.jpg.thumb.jpg
|
/data/attachment/album/201911/26/064538fbktfzxba18wykde.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"pkgsrc"
] |
技术
|
{
"viewnum": 5682,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
NetBSD 的软件包管理器通用、灵活又容易。下面是如何使用它。
| 2019-11-26T06:46:07 | 2019-11-26T06:46:07 | 11,613 |
/article-11613-1.html
|
>
> NetBSD 的软件包管理器通用、灵活又容易。下面是如何使用它。
>
>
>
NetBSD 以能在几乎所有平台上运行而闻名，但你知道它*第二*有名的 [pkgsrc](http://pkgsrc.org) 包管理器吗？像 NetBSD 一样，pkgsrc 基本上可以在任何系统上运行，或者至少在任意 Unix 和类 Unix 的系统上上运行。你可以在 BSD、Linux、Illumos、Solaris 和 Mac 上安装 pkgsrc。它总共支持 20 多种操作系统。
### 为什么使用 pkgsrc？
除了 MacOS 之外，所有 Unix 操作系统均自带包管理器。你不一定*需要* pkgsrc，但这可能是你想尝试的三个重要原因：
* **打包**。如果你对打包感到好奇，但尚未尝试自己创建一个软件包，那么 pkgsrc 是一个相对简单的系统，尤其是如果你已经熟悉 Makefile 和类似 [GNU Autotools](https://opensource.com/article/19/7/introduction-gnu-autotools) 之类的构建系统时。
* **通用**。如果你使用多个操作系统或发行版，那么可能会遇到每个系统的包管理器。你可以在不同的系统上使用 pkgsrc，以便你为一个系统打包了程序，就为所有系统打包了。
* **灵活**。在许多打包系统中，如何选择二进制包或源码包并不总是很明显。使用 pkgsrc，区别很明显，两种安装方法都一样容易，并且都可以为你解决依赖关系。
### 如何安装 pkgsrc
无论你使用的是 BSD、Linux、Illumos、Solaris 还是 MacOS，安装过程都基本相同：
1. 使用 CVS 检出 pkgsrc 树
2. 引导 pkgsrc 系统
3. 安装软件包
#### 使用 CVS 检出 pkgsrc 树
在 Git 和 Subversion 之前，就有了 [CVS](http://www.netbsd.org/developers/cvs-repos/cvs_intro.html#intro)。要检出代码你无需了解 CVS 太多，如果你习惯 Git，那么可以将<ruby> 检出 <rt> checkout </rt></ruby>称为<ruby> 克隆 <rt> clone </rt></ruby>。当你用 CVS 检出 pkgsrc 时，你就下载了详细说明如何构建每个软件包的“<ruby> 配方 <rt> recipes </rt></ruby>”。它有很多文件，但是它们都很小，因为你实际上并没有拉取每个包的源码，而只有按需构建时需要的构建基础架构和 Makefile。使用 CVS，你可以轻松地在新版本发布时更新 pkgsrc 检出。
pkgsrc 文档建议将其源码树放在 `/usr` 目录下，因此你必须使用 `sudo`（或成为 root）运行此命令：
```
$ cd /usr
$ sudo cvs -q -z2 -d anoncvs@anoncvs.NetBSD.org:/cvsroot checkout -r pkgsrc-2019Q3 -P pkgsrc
```
在我撰写本文时，最新版本是 2019Q3。请检查 [pkgsrc.org](http://pkgsrc.org/) 主页的新闻部分或 [NetBSD文档](http://www.netbsd.org/docs/pkgsrc/getting.html)，以确定最新版本。
#### 引导 pkgsrc
pkgsrc 树复制到你的计算机后，你会看到一个充满构建脚本的 `/usr/pkgsrc` 目录。在使用之前，你必须引导 pkgsrc，以便你可以轻松地访问构建和安装软件所需的相关命令。
引导 pkgsrc 的方式取决于你所使用操作系统。
对于 NetBSD，你只需使用捆绑的引导器：
```
# cd pkgsrc/bootstrap
# ./bootstrap
```
在其他系统上，还有更好的方法，包括一些自定义功能，它是由 Joyent 提供的。要了解运行的确切命令，请访问 [pkgsrc.joyent.com](http://pkgsrc.joyent.com/)。比如，在 Linux（Fedora、Debian、Slackware 等）上：
```
$ curl -O https://pkgsrc.joyent.com/packages/Linux/el7/bootstrap/bootstrap-trunk-x86_64-20170127.tar.gz
$ BOOTSTRAP_SHA="eb0d6911489579ca893f67f8a528ecd02137d43a"
```
尽管路径暗示文件适用于 RHEL 7，但二进制文件往往与所有（最前沿的 Linux 发行版）兼容。如果你发现二进制文件与你的发行版不兼容，你可以选择从源码构建。
验证 SHA1 校验和：
```
$ echo "${BOOTSTRAP_SHA}" bootstrap-trunk*gz > check-shasum
sha1sum -c check-shasum
```
你还可以验证 PGP 签名：
```
$ curl -O https://pkgsrc.joyent.com/packages/Linux/el7/bootstrap/bootstrap-trunk-x86_64-20170127.tar.gz.asc
$ curl -sS https://pkgsrc.joyent.com/pgp/56AAACAF.asc | gpg --import
$ gpg --verify ${BOOTSTRAP_TAR}{.asc,}
```
当你确认你已有正确的引导套件，将其安装到 `/usr/pkg`：
```
sudo tar -zxpf ${BOOTSTRAP_TAR} -C /
```
它为你提供了通常的 pkgsrc 命令。将这些位置添加到[你的 PATH 环境变量中](https://opensource.com/article/17/6/set-path-linux)：
```
$ echo "PATH=/usr/pkg/sbin:/usr/pkg/bin:$PATH" >> ~/.bashrc
$ echo "MANPATH=/usr/pkg/man:$MANPATH" >> ~/.bashrc
```
如果你宁愿使用 pkgsrc 而不依赖于 Joyent 的构建，那么只需运行 pkgsrc 源码树的引导脚本即可。在运行特定于系统的脚本之前，请先阅读 `bootstrap` 目录中相关 `README` 文件。
### 如何使用 pkgsrc 安装软件
使用 pkgsrc 安装预编译的二进制文件（就像使用 DNF 或 Apt 一样）是很容易的。二进制安装的命令是 `pgkin`，它有自己的专门网站 [pkgin.net](http://pkgin.net)。对于任何用过 Linux 的人来说，这个过程应该感觉相当熟悉。
要搜索 `tmux` 包：
```
$ pkgin search tmux
```
要安装 tmux 包：
```
$ sudo pkgin install tmux
```
`pkgin` 命令的目的是模仿典型的 Linux 包管理器的行为，因此有选项可以列出可用的包、查找包提供的特定可执行文件，等等。
### 如何使用 pkgsrc 从源码构建
然而，pkgsrc 真正强大的地方是方便地从源码构建包。你在第一步中检出了所有 20000 多个构建脚本，你可以直接进入 pkgsrc 源码树来访问这些脚本。
例如，要从源码构建 `tcsh`，首先找到构建脚本：
```
$ find /usr/pkgsrc -type d -name "tcsh"
/usr/pkgsrc/shells/tcsh
```
接下来，进入源码目录：
```
$ cd /usr/pgksrc/shells/tcsh
```
构建脚本目录包含许多文件来帮助在你的系统上构建应用，但值得注意的是，这里面有包含了软件说明的 `DESCR` 文件，以及触发构建的 `Makefile`。
```
$ ls
CVS DESCR Makefile
PLIST distinfo patches
$ cat DESCR
TCSH is an extended C-shell with many useful features like
filename completion, history editing, etc.
$
```
准备就绪后，构建并安装：
```
$ sudo bmake install
```
pkgsrc 系统使用 `bmake` 命令（在第一步检出 pkgsrc 后提供），因此请务必使用 `bmake`（而不是出于习惯使用 `make`）。
如果要为多个系统构建，那么你可以创建一个包，而不是立即安装：
```
$ cd /usr/pgksrc/shells/tcsh
$ sudo bmake package
[...]
=> Creating binary package in /usr/pkgsrc/packages/All/tcsh-X.Y.Z.tgz
```
pkgsrc 创建的包是标准的 tarball，但它可以方便地通过 `pkg_add` 安装：
```
$ sudo pkg_add /usr/pkgsrc/packages/All/tcsh-X.Y.Z.tgz
tcsh-X.Y.Z: adding /usr/pkg/bin/tcsh to /etc/shells
$ tcsh
localhost%
```
pkgsrc 的 pkgtools 集合提供 `pkg_add`、`pkg_info`、`pkg_admin`、`pkg_create` 和 `pkg_delete` 命令，来帮助管理你在系统上构建和维护软件包。
### pkgsrc，易于管理
pkgsrc 系统提供了直接，容易上手的软件包管理方法。如果你正在寻找一个不妨碍你并且可以定制的包管理器，请在任何运行 Unix 或类 Unix 的系统上试试 pkgsrc。
---
via: <https://opensource.com/article/19/11/pkgsrc-netbsd-linux>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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 上安装 Java
|
Seth Kenlon
|
https://opensource.com/article/19/11/install-java-linux
|
在桌面上拥抱 Java 应用程序，然后在所有桌面上运行它们。
|
/data/attachment/album/201911/26/065307hk22caubakkos0u0.jpg.thumb.jpg
|
/data/attachment/album/201911/26/065307hk22caubakkos0u0.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Java"
] |
技术
|
{
"viewnum": 18073,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11620,
"displayorder": 0
}
] |
在桌面上拥抱 Java 应用程序，然后在所有桌面上运行它们。
| 2019-11-26T06:53:40 | 2019-11-26T06:53:40 | 11,614 |
/article-11614-1.html
|
>
> 在桌面上拥抱 Java 应用程序，然后在所有桌面上运行它们。
>
>
>
无论你运行的是哪种操作系统，通常都有几种安装应用程序的方法。有时你可能会在应用程序商店中找到一个应用程序，或者使用 Fedora 上的 DNF 或 Mac 上的 Brew 这样的软件包管理器进行安装，而有时你可能会从网站上下载可执行文件或安装程序。因为 Java 是这么多流行的应用程序的后端，所以最好了解安装它的不同方法。好消息是你有很多选择，本文涵盖了所有这些内容。
坏消息是 Java *太大*，我说的不仅仅是文件大小。Java 是一种开放源代码语言和规范，这意味着从理论上讲，任何人都可以创建它的实现版本。这意味着，在安装任何东西之前，必须确定要安装的 Java 发行版。
### 我需要 JVM 还是 JRE 或者 JDK？
Java 大致分为两个下载类别。<ruby> Java 虚拟机 <rt> Java Virtual Machine </rt></ruby>（JVM）是运行时组件；它是使 Java 应用程序能够在计算机上启动和运行的“引擎”。它包含在 <ruby> Java 运行时环境 <rt> Java Runtime Environment </rt></ruby>（JRE）中。
<ruby> Java 开发工具包 <rt> Java Development Kit </rt></ruby>（JDK）是一个开发工具包：你可以将其视为一个车库，修理工可以坐在那里进行调整、修理和改进。JDK 包含 Java 运行时环境（JRE）。
以下载来说，这意味着：
* 如果你是希望运行 Java 应用程序的用户，则只需 JRE（包括了 JVM）。
* 如果你是希望使用 Java 进行编程的开发人员，则需要 JDK（包括 JRE 库，而 JRE 库又包括 JVM）。 ### OpenJDK、IcedTea 和 OracleJDK 有什么不同？
当<ruby> 太阳微系统 <rt> Sun Microsystems </rt></ruby>被 Oracle 收购时，Java 是该交易的主要部分。幸运的是，Java 是一种开源技术，因此，如果你对 Oracle 维护该项目的方式不满意，则可以选择其他方法。Oracle 将专有组件与 Java 下载捆绑在一起，而 OpenJDK 项目是完全开源的。
IcedTea 项目本质上是 OpenJDK，但其目标是使用户在使用完全自由开源的工具时更容易构建和部署 OpenJDK。
（LCTT 译注：阿里巴巴也有一个它自己维护的 Open JDK 发行版“<ruby> 龙井 <rt> Dragonwell </rt></ruby>”。以下引自其官网：“Alibaba Dragonwell 是一款免费的，生产就绪型 Open JDK 发行版，提供长期支持，包括性能增强和安全修复。……Alibaba Dragonwell 作为 Java 应用的基石，支撑了阿里经济体内所有的 Java 业务。Alibaba Dragonwell 完全兼容 Java SE 标准，……”）
### 我应该安装哪个 Java？
如果你对这些选择感到不知所措，那么简单的答案就是你应该安装的 Java 实现应该是最容易安装的那个。当应用程序告诉你需要 Java 12，但你的存储库中只有 Java 8 时，可以安装可以从可靠来源中找到的 Java 12 的任何实现。在 Linux 上，你可以一次安装几个不同版本的 Java，它们不会互相干扰。
如果你是需要选择使用哪个版本的开发人员，则应考虑所需的组件。如果选择 Oracle 的版本，请注意，软件包中包含专有的插件和字体，可能会[影响你分发你的应用程序](https://www.oracle.com/technetwork/java/javase/overview/oracle-jdk-faqs.html)。在 IcedTea 或 OpenJDK 上进行开发是最安全的。
### 从存储库安装 OpenJDK？
现在，你已经知道要选择什么了，你可以使用软件包管理器搜索 OpenJDK 或 IcedTea，然后安装所需的版本。有些发行版使用关键字 `latest` 来指示最新版本，这通常是你要运行的应用程序所需要的。根据你使用的软件包管理器，你甚至可以考虑使用 `grep` 过滤搜索结果以仅包括最新版本。例如，在 Fedora 上：
```
$ sudo dnf search openjdk | grep latest | cut -f1 -d':'
java-latest-openjdk-demo.x86_64
java-openjdk.i686
java-openjdk.x86_64
java-latest-openjdk-jmods.x86_64
java-latest-openjdk-src.x86_64
java-latest-openjdk.x86_64
[...]
```
只有当你尝试运行的应用程序坚持要求你使用 Java 的旧版本时，你才应该看看 `latest` 之前的版本。
在 Fedora 或类似系统上安装 Java：
```
$ sudo dnf install java-latest-openjdk
```
如果你的发行版不使用 `latest` 标签，则可以使用其他关键字，例如 `default`。以下是在 Debian 上搜索 OpenJDK 的信息：
```
$ sudo apt search openjdk | less
default-jdk
Standard Java development kit
default-jre
Standard Java runtime
openjdk-11-jdk
OpenJDK development kit (JDK)
[...]
```
在这种情况下，`default-jre` 软件包适合用户，而 `default-jdk` 则适合开发人员。
例如，要在 Debian 上安装 JRE：
```
$ sudo apt install default-jre
```
现在已安装好 Java。
你的存储库中可能有*许多*与 Java 相关的软件包。要搜索 OpenJDK，如果你是用户，则查找最新的 JRE 或 JVM，如果你是开发人员，则查找最新的 JDK。
### 从互联网上安装 Java
如果在存储库中找不到 JRE 或 JDK，或者找不到满足你需求的 JRE 或 JDK，则可以从互联网上下载开源的 Java 软件包。你可以在 [openjdk.java.net](http://openjdk.java.net) 中找到需要手动安装的 tar 形式的 OpenJDK 下载文件，或者可以从 Azul 下载 tar 形式的 [Zulu 社区版](https://www.azul.com/downloads/zulu-community)或其可安装的 RPM 或 DEB 软件包。
#### 从 TAR 文件安装 Java
如果从 Java.net 或 Azul 下载 TAR 文件，则必须手动安装。这通常称为“本地”安装，因为你没有将 Java 安装到“全局”位置。你可以在 `PATH` 中选择一个合适的位置。
如果你不知道 `PATH` 中包含什么，请查看一下以找出：
```
$ echo $PATH
/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/home/seth/bin
```
在此示例 `PATH` 中，位置 `/usr/local/bin` 和 `/home/seth/bin` 是不错的选择。如果你是计算机上的唯一用户，那么你自己的家目录就很有意义。如果你的计算机上有很多用户，则最好选择一个通用位置，例如 `/usr/local` 或 `/opt`。
如果你无权访问需要 `sudo` 权限的 `/usr/local` 之类的系统级目录，则可以在你自己的家目录中创建一个本地 `bin`（意思是 “<ruby> 二进制 <rt> binary </rt></ruby>”，而不是“<ruby> 垃圾箱 <rt> waste bin </rt></ruby>”）或 `Applications` 文件夹：
```
$ mkdir ~/bin
```
如果它不在你的 `PATH` 中，请将其添加到其中：
```
$ echo PATH=$PATH:$HOME/bin >> ~/.bashrc
$ source ~/.bashrc
```
最后，将压缩包解压缩到你选择的目录中。
```
$ tar --extract --file openjdk*linux-x64_bin.tar.gz --directory=$HOME/bin
```
Java 现在安装好了。
#### 从 RPM 或 DEB 安装 Java
如果从 Azul.com 下载 RPM 或 DEB 文件，则可以使用软件包管理器进行安装。
对于 Fedora、CentOS、RHEL 等，请下载 RPM 并使用 DNF 进行安装：
```
$ sudo dnf install zulu*linux.x86_64.rpm
```
对于 Debian、Ubuntu、Pop\_OS 和类似发行版，请下载 DEB 软件包并使用 Apt 安装它：
```
$ sudo dpkg -i zulu*linux_amd64.deb
```
Java 现在安装好了。
#### 用 alternatives 安装你的 Java 版本
一些应用程序是为特定版本的 Java 开发的，不能与其他任何版本一起使用。这种情况很少见，但确实会发生，在 Linux 上，你可以使用本地安装方法（请参阅上面“从 TAR 文件安装 Java”一节）或使用 `alternatives` 应用程序来解决此冲突。
`alternatives` 命令会查找 Linux 系统上安装的应用程序，并让你选择要使用的版本。有些发行版，例如 Slackware，不提供 `alternatives` 命令，因此你必须使用本地安装方法。在 Fedora、CentOS 和类似的发行版上，该命令是 `alternatives`。在 Debian、Ubuntu 和类似的系统上，该命令是 `update-alternatives`。
要获取当前已安装在 Fedora 系统上的应用程序的可用版本列表：
```
$ alternatives --list
```
在 Debian 上，你必须指定可供替代的应用程序：
```
$ update-alternatives --list java
```
在 Fedora 上选择要使系统将哪个版本作为默认版本：
```
$ sudo alternatives --config java
```
在 Debian 上：
```
$ sudo updates-alternatives --config java
```
你可以根据需要运行的应用程序，根据需要更改默认的 Java 版本。
### 运行 Java 应用
Java 应用程序通常以 JAR 文件的形式分发。根据你安装 Java 的方式，你的系统可能已经为运行 Java 应用程序配置好了，这使你只需双击应用程序图标（或从应用程序菜单中选择它）即可运行。如果必须执行未与系统其余部分集成的本地 Java 安装，则可以直接从终端启动 Java 应用程序：
```
$ java -jar ~/bin/example.jar &
```
### Java 是个好东西
Java 是少数将跨平台开发放在首位的编程环境之一。没有什么比问一个应用程序是否能在你的平台上运行然后发现该应用程序是用 Java 编写要让人感到松一口气的了。它是如此简单，无论你是开发人员还是用户，你都可以摆脱任何平台上的焦虑。在桌面上拥抱 Java 应用程序，然后在*所有*桌面上运行它们吧。
---
via: <https://opensource.com/article/19/11/install-java-linux>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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 内核支持
|
John Paul
|
https://itsfoss.com/mainline-linux-kernel-android/
|
当前的安卓生态系统被数百种不同版本的安卓所污染，每种版本都运行着 Linux 内核的不同变体。每个版本均针对不同的手机和不同的配置而设计。谷歌试图通过将主线 Linux 内核添加到安卓来解决该问题。
|
/data/attachment/album/201911/27/085706ec16q899q5uzflj9.png.thumb.jpg
|
/data/attachment/album/201911/27/085706ec16q899q5uzflj9.png
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"Android",
"Linux"
] |
观点
|
{
"viewnum": 4797,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "221.203.162.50",
"message": "Android Police 指出谷歌正在开发其 Fuchsia 操作系统，这似乎是为了有一天取代谷歌。<br />\r\n很显然,应该是为了取代Android,而非谷歌.",
"username": "只三言两语 [Firefox 70.0|Ubuntu]",
"date": "2019-11-27T10:18:42"
}
] |
[] |
当前的安卓生态系统被数百种不同版本的安卓所污染，每种版本都运行着 Linux 内核的不同变体。每个版本均针对不同的手机和不同的配置而设计。谷歌试图通过将主线 Linux 内核添加到安卓来解决该问题。
| 2019-11-27T08:57:01 | 2019-11-27T08:57:01 | 11,616 |
/article-11616-1.html
|
当前的安卓生态系统被数百种不同版本的安卓所污染，每种版本都运行着 Linux 内核的不同变体。每个版本均针对不同的手机和不同的配置而设计。谷歌试图通过将主线 Linux 内核添加到安卓来解决该问题。
### 当前在安卓中是如何处理 Linux 内核的
在到达你的手机之前，你手机上的 Linux 内核经历了[三个主要步骤](https://arstechnica.com/gadgets/2019/11/google-outlines-plans-for-mainline-linux-kernel-support-in-android/)。
首先，谷歌采用了 Linux 内核的 LTS（长期支持）版本，并添加了所有的安卓专用代码。这将成为“安卓通用内核”。
然后，谷歌将此代码发送给创建可运行在手机的片上系统（SoC）的公司。这通常是高通公司。
SoC 制造商添加了支持 CPU 和其他芯片的代码后，便会将该内核传递给实际的设备制造商，例如三星和摩托罗拉。然后，设备制造商添加代码以支持手机的其余部分，例如显示屏和摄像头。
每个步骤都需要一段时间才能完成，并且会导致该内核无法与其他任何设备一起使用。这也意味着内核会非常旧，通常是大约两年前的内核。例如，上个月交付的谷歌 Pixel 4 带有来自 2017 年 11 月的内核，而且它将永远不会得到更新。
谷歌承诺会为较旧的设备创建安全补丁，这意味着他们会一直盯着大量的旧代码。
### 将来
去年，谷歌宣布[计划](https://lwn.net/Articles/771974/)解决此问题。今年，他们在 2019 Linux Plumbers Conference 上展示了他们取得的进展。
>
> “我们知道运行安卓需要什么，但不一定是在任何给定的硬件上。因此，我们的目标是从根本上找出所有这些，然后将其交给上游，并尝试尽可能接近主线。”
>
>
> Sandeep Patil，[安卓内核团队负责人](https://arstechnica.com/gadgets/2019/11/google-outlines-plans-for-mainline-linux-kernel-support-in-android/)
>
>
>
他们确实炫耀了运行带有合适的 Linux 内核的小米 Poco F1。但是，有些东西[似乎没有工作](https://www.androidpolice.com/2019/11/19/google-wants-android-to-use-regular-linux-kernel-potentially-improving-updates-and-security/)，例如电池电量百分比一直留在 0％。
那么，谷歌计划如何使其工作呢？从他们的 [Treble 项目](https://www.computerworld.com/article/3306443/what-is-project-treble-android-upgrade-fix-explained.html)计划中摘录。在 Treble 项目之前，与设备和安卓本身交互的底层代码是一大堆代码。Treble 项目将两者分开，并使它们模块化，以便可以更快地交付安卓更新，并且在更新时，这些低级代码可以保持不变。
谷歌希望为内核带来同样的模块化。他们的[计划](https://arstechnica.com/gadgets/2019/11/google-outlines-plans-for-mainline-linux-kernel-support-in-android/)“涉及稳定 Linux 的内核 ABI，并为 Linux 内核和硬件供应商提供稳定的接口来进行写入。谷歌希望将 Linux 内核与其硬件支持脱钩。”
因此，这意味着谷歌将交付一个内核，而硬件驱动程序将作为内核模块加载。目前，这只是一个草案。仍然有很多技术问题有待解决。因此，这不会很快有结果。
### 来自开源的反对意见
开源社区不会对将专有代码放入内核的想法感到满意。[Linux 内核准则](https://www.kernel.org/doc/Documentation/process/stable-api-nonsense.rst)指出，驱动程序必须具有 GPL 许可证才能包含在内核中。他们还指出，如果驱动程序的更改导致错误，应由导致该错误的人来解决。从长远来看，这意味着设备制造商的工作量将减少。
### 关于将主线内核包含到安卓中的最终想法
到目前为止，这只是一个草案。谷歌有很大的可能会开始进行该项目，除非他们意识到这将需要多少工作后才会放弃。看看谷歌[已经放弃](https://killedbygoogle.com/)了多少个项目！
[Android Police](https://www.androidpolice.com/2019/11/19/google-wants-android-to-use-regular-linux-kernel-potentially-improving-updates-and-security/) 指出谷歌正在开发其 [Fuchsia 操作系统](https://itsfoss.com/fuchsia-os-what-you-need-to-know/)，这似乎是为了有一天取代谷歌。
那么，问题是谷歌会尝试完成那些艰巨的任务，使安卓以主线 Linux 内核运行，还是完成他们统一的安卓替代产品的工作？只有时间可以回答。
你对此话题有何看法？请在下面的评论中告诉我们。
---
via: <https://itsfoss.com/mainline-linux-kernel-android/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[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/) 荣誉推出
|
bauh：在一个界面中管理 Snap、Flatpak 和 AppImage
|
John Paul
|
https://itsfoss.com/bauh-package-manager/
|
幸运的是，我偶然发现了一个支持这几种通用包格式的应用程序。
|
/data/attachment/album/201911/27/092926pzzdtytda80yaany.jpg.thumb.jpg
|
/data/attachment/album/201911/27/092926pzzdtytda80yaany.jpg
| true | false | true |
lujun9972
|
wxy
|
wxy
| false |
[
"软件包"
] |
分享
|
{
"viewnum": 6173,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "110.184.69.233",
"message": "我使用manjaro或Arco安装后，打开bauh需要输入密码，然后点击继续，无响应。无法进入软件主界面。",
"username": "来自四川成都的 Firefox 88.0|GNU/Linux 用户",
"date": "2021-04-23T14:36:42"
}
] |
[] |
幸运的是，我偶然发现了一个支持这几种通用包格式的应用程序。
| 2019-11-27T09:30:00 | 2019-11-27T09:30:00 | 11,617 |
/article-11617-1.html
|
[Snap](https://snapcraft.io/)、[Flatpak](https://flatpak.org/) 和 [AppImage](https://appimage.org/) 等通用软件包的最大问题之一就是管理它们。大多数内置的软件包管理器都不能全部支持这些新格式。
幸运的是，我偶然发现了一个支持这几种通用包格式的应用程序。
### bauh：多包装需求的管理器
[bauh](https://github.com/vinifmor/bauh)（LCTT：我给该软件建议一个中文名：“包豪”）最初名为 fpakman，旨在处理 Flatpak、Snap、[AppImage](https://itsfoss.com/use-appimage-linux/) 和 [AUR](https://itsfoss.com/best-aur-helpers/) 软件包。创建者 [vinifmor](https://github.com/vinifmor) 在 2019 年 6 月启动了该项目，[意图](https://forum.manjaro.org/t/bauh-formerly-known-as-fpakman-a-gui-for-flatpak-and-snap-management/96180)“为 Manjaro 用户提供管理 Flatpak 的图形界面”。此后，他扩展了该应用程序，以添加对基于 Debian 的系统的支持。
首次打开 bauh 时，它将扫描已安装的应用程序并检查更新。如果有任何需要更新的内容，它们将列在前面并居中。更新所有软件包后，你将看到已安装的软件包列表。你可以取消选择不需要更新的软件包，以防止其被更新。你也可以选择安装该应用程序的早期版本。
你也可以搜索应用程序。bauh 提供了有关已安装和已搜索软件包的详细信息。如果你对一种（或多种）软件包类型不感兴趣，则可以在设置中取消选择它们。
### 在你的 Linux 发行版上安装 bauh
让我们看看如何安装 bauh。
#### 基于 Arch 的发行版
如果你安装的是最近的 [Manjaro](https://manjaro.org/)，则应该一切已经就绪。bauh 默认情况下已安装。如果你安装的是较早版本的 Manjaro（如我一样）或其他基于 Arch 的发行版，则可以在终端中输入以下内容从 [AUR](https://aur.archlinux.org/packages/bauh) 中进行安装：
```
sudo pacman -S bauh
```
#### 基于 Debian/Ubuntu 的发行版
如果你拥有基于 Debian 或 Ubuntu 的 Linux 发行版，则可以使用 `pip` 安装 bauh。首先，请确保[在 Ubuntu 上安装了 pip](https://itsfoss.com/install-pip-ubuntu/)。
```
sudo apt install python3-pip
```
然后使用它来安装 bauh：
```
pip3 install bauh
```
但是，该软件的创建者建议[手动](https://github.com/vinifmor/bauh#manual-installation)安装它，以避免弄乱系统的库。
要手动安装 bauh，你必须先下载其[最新版本](https://github.com/vinifmor/bauh/releases)。下载后，可以[使用图形工具](https://itsfoss.com/unzip-linux/)或 [unzip 命令](https://linuxhandbook.com/unzip-command/)解压缩。接下来，在终端中打开该文件夹。你将需要使用以下步骤来完成安装。
首先，在名为 `env` 的文件夹中创建一个虚拟环境：
```
python3 -m venv env
```
现在在该环境中安装该应用程序的代码：
```
env/bin/pip install .
```
启动该应用程序：
```
env/bin/bauh
```
一旦完成了 bauh 的安装，就可以通过更改环境设置和参数来对其进行[微调](https://github.com/vinifmor/bauh#general-settings)。
### bauh 的未来之路
bauh 在短短的几个月中增长了很多。它有计划继续增长。当前的[路线图](https://github.com/vinifmor/bauh#roadmap)包括：
* 支持其他打包技术
* 每种打包技术一个单独模块
* 内存和性能改进
* 改善用户体验
### 结语
当我尝试 bauh 时，遇到了两个问题。当我第一次打开它时，它告诉我尚未安装 Snap，如果要使用 Snap 软件包，则必须安装它。我知道我已经安装了 Snap，因为我在终端中运行了 `snap list`，并且可以正常工作。我重新启动系统，Snap 才工作正常。
我遇到的另一个问题是我的一个 AUR 软件包无法更新。我可以用 `yay` 更新软件包，而没有任何问题。可能是我的 Manjaro 有问题，我已经使用了它 3 到 4 年。
总体而言，bauh 可以工作。它做到了宣称的功能。我不能要求更多。
你有没有用过 hauh？如果有的话，你最喜欢的用于管理不同打包格式的工具是什么？在下面的评论中让我们知道。
---
via: <https://itsfoss.com/bauh-package-manager/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[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/) 荣誉推出
|
如何使用 TimeShift 备份和还原 Ubuntu Linux
|
James Kiarie
|
https://www.linuxtechi.com/timeshift-backup-restore-ubuntu-linux/
|
你是否曾经想过如何备份和还原 Ubuntu 或 Debian 系统？Timeshift 是一款自由开源工具，可让你创建文件系统的增量快照。你可以使用 RSYNC 或 BTRFS 两种方式创建快照。
|
/data/attachment/album/201911/27/235959fejmb080e7z0jnu0.jpg.thumb.jpg
|
/data/attachment/album/201911/27/235959fejmb080e7z0jnu0.jpg
| true | false | true |
lujun9972
|
geekpi
|
wxy
| false |
[
"备份",
"Timeshift"
] |
技术
|
{
"viewnum": 21794,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你是否曾经想过如何备份和还原 Ubuntu 或 Debian 系统？Timeshift 是一款自由开源工具，可让你创建文件系统的增量快照。你可以使用 RSYNC 或 BTRFS 两种方式创建快照。
| 2019-11-28T00:14:00 | 2019-11-28T00:14:00 | 11,619 |
/article-11619-1.html
|
你是否曾经想过如何备份和还原 Ubuntu 或 Debian 系统？Timeshift 是一款自由开源工具，可让你创建文件系统的增量快照。你可以使用 RSYNC 或 BTRFS 两种方式创建快照。
让我们深入研究并安装 Timeshift。在本教程，我们将安装在 Ubuntu 18.04 LTS 系统上。
### 在 Ubuntu / Debian Linux 上安装 TimeShift
TimeShift 尚未正式托管在 Ubuntu 和 Debian 仓库中。考虑到这一点，我们将运行以下命令来添加 PPA：
```
# add-apt-repository -y ppa:teejee2008/ppa
```
接下来，使用以下命令更新系统软件包：
```
# apt update
```
成功更新系统后，使用以下 `apt` 命令安装 Timeshift：
```
# apt install timeshift
```
### 准备备份存储设备
最佳实践要求我们将系统快照保存在系统硬盘之外的单独的存储卷上。对于本指南，我们将使用 16GB 闪存作为第二个驱动器，并在该驱动器上保存快照。
```
# lsblk | grep sdb
```
为了将闪存用作快照的备份位置，我们需要在设备上创建一个分区表。运行以下命令：
```
# parted /dev/sdb mklabel gpt
# parted /dev/sdb mkpart primary 0% 100%
# mkfs.ext4 /dev/sdb1
```
在 USB 闪存上创建分区表后，我们可以开始创建文件系统的快照！
### 使用 Timeshift 创建快照
要启动 Timeshift，使用应用程序菜单搜索 “Timeshift”。
单击 Timeshift 图标，系统将提示你输入管理员密码。提供密码，然后单击验证。
接下来，选择你喜欢的快照类型。
点击 “Next”。选择快照的目标驱动器。在这里，我的位置是标记为 `/dev/sdb` 的外部 USB 驱动器。
接下来，定义快照级别。级别是指创建快照的时间间隔。你可以选择每月、每周、每天或每小时的快照级别。
点击 “Finish”。
在下一个窗口中，单击 “Create” 按钮开始创建快照。此后，系统将开始创建快照。
最后，你的快照将显示如下：
### 从快照还原 Ubuntu / Debian
创建系统快照后，现在让我们看看如何从同一快照还原系统。在同一个 Timeshift 中，单击快照，然后单击 “Restore” 按钮，如图所示。
接下来，将提示你选择目标设备。保留默认选择，然后点击 “Next”。
恢复过程开始之前，Timeshift 将会试运行。
在下一个窗口中，点击 “Next” 按钮确认显示的操作。
如图所示，你会看到警告和免责声明。点击 “Next” 初始化恢复过程。
此后，将开始还原过程，最后，系统之后将重新启动到快照定义的早期版本。
### 总结
如你所见，使用 TimeShift 从快照还原系统非常容易。在备份系统文件时，它非常方便，并允许你在系统故障时进行恢复。因此，不要害怕修改系统或弄乱系统。TimeShift 使你能够返回到一切运行平稳的时间点。
---
via: <https://www.linuxtechi.com/timeshift-backup-restore-ubuntu-linux/>
作者：[James Kiarie](https://www.linuxtechi.com/author/james/) 选题：[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/) 荣誉推出
|
给新手 Java 开发者的 7 点提示
|
Seth Kenlon
|
https://opensource.com/article/19/10/java-basics
|
如果你才刚开始学习 Java 编程，这里有七个你需要知道的基础知识。
|
/data/attachment/album/201911/28/120421di3744urqnyyr6xi.jpg.thumb.jpg
|
/data/attachment/album/201911/28/120421di3744urqnyyr6xi.jpg
| true | false | true |
lujun9972
|
robsean
|
wxy
| false |
[
"Java"
] |
软件开发
|
{
"viewnum": 4965,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 11614,
"displayorder": 0
}
] |
如果你才刚开始学习 Java 编程，这里有七个你需要知道的基础知识。
| 2019-11-28T12:04:57 | 2019-11-28T12:04:57 | 11,620 |
/article-11620-1.html
|
>
> 如果你才刚开始学习 Java 编程，这里有七个你需要知道的基础知识。
>
>
>
Java 是一个多功能的编程语言，在某种程度上，它用在几乎所有可能涉及计算机的行业了里。Java 的最大优势是，它运行在一个 Java 虚拟机（JVM）中，这是一个翻译 Java 代码为与操作系统兼容的字节码的层。只要有 JVM 存在于你的操作系统上 —— 不管这个操作系统是在一个服务器（或“[无服务器](https://www.redhat.com/en/resources/building-microservices-eap-7-reference-architecture)”，也是同样的）、桌面电脑、笔记本电脑、移动设备，或嵌入式设备 —— 那么，Java 应用程序就可以运行在它上面。
这使得 Java 成为程序员和用户的一种流行语言。程序员知道，他们只需要写一个软件版本就能最终得到一个可以运行在任何平台上的应用程序；用户知道，应用程序可以运行在他们的计算机上，而不用管他们使用的是什么样的操作系统。
很多语言和框架是跨平台的，但是没有实现同样的抽象层。使用 Java，你针对的是 JVM，而不是操作系统。对于程序员，当面对一些编程难题时，这是阻力最小的线路，但是它仅在当你知道如何编程 Java 时有用。如果你刚开始学习 Java 编程，这里有你需要知道的七个基础的提示。
但是，首先，如果你不确定是否你安装了 Java ，你可以在一个终端（例如 [Bash](https://www.gnu.org/software/bash/) 或 [PowerShell](https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell?view=powershell-6)）中找出来，通过运行：
```
$ java --version
openjdk 12.0.2 2019-07-16
OpenJDK Runtime Environment 19.3 (build 12.0.2+9)
OpenJDK 64-Bit Server VM 19.3 (build 12.0.2+9, mixed mode, sharing)
```
如果你得到一个错误，或未返回任何东西，那么你应该安装 [Java 开发套件](http://openjdk.java.net/)（JDK）来开始 Java 开发。或者，安装一个 Java 运行时环境（JRE），如果你只是需要来运行 Java 应用程序。
### 1、Java 软件包
在 Java 语言中，相关的类被分组到一个*软件包*中。当你下载 JDK 时所获得的 Java 基础库将被分组到以 `java` 或 `javax` 开头的软件包中。软件包提供一种类似于计算机上的文件夹的功能：它们为相关的元素提供结构和定义（以编程术语说，*命名空间*）。额外的软件包可以从独立开发者、开源项目和商业供应商获得，就像可以为任何编程语言获得库一样。
当你写一个 Java 程序时，你应该在你的代码是顶部声明一个软件包名称。如果你只是编写一个简单的应用程序来入门 Java，你的软件包名称可以简单地用你的项目名称。如果你正在使用一个 Java 集成开发环境，如 [Eclipse](http://www.eclipse.org/)，当你启动一个新的项目时，它为你生成一个合乎情理的软件包名称。
```
package helloworld;
/**
* @author seth
* An application written in Java.
*/
```
除此之外，你可以通过查找它相对于你的项目整体的路径来确定你的软件包名称。例如，如果你正在写一组类来帮助游戏开发，并且该集合被称为 `jgamer`，那么你可能在其中有一些唯一的类。
```
package jgamer.avatar;
/**
* @author seth
* An imaginary game library.
*/
```
你的软件包的顶层是 `jgamer`，并且在其内部中每个软件包都是一个独立的派生物，例如 `jgamer.avatar` 和 `jgamer.score` 等等。在你的文件系统里，其目录结构反映了这一点，`jgamer` 是包含文件 `avatar.java` 和 `score.java` 的顶级目录。
### 2、Java 导入
作为一名通晓多种语言的程序员，最大的乐趣是找出是否用 `include`、`import`、`use`、`require`，或一些其它术语来引入你不管使用何种编程语言编写的库。在 Java 中，顺便说一句，当导入你的代码的需要的库时，使用 `import` 关键字。
```
package helloworld;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
* @author seth
* A GUI hello world.
*/
```
导入是基于该环境的 Java 路径。如果 Java 不知道 Java 库存储在系统上的何处，那么，就不能成功导入。只要一个库被存储在系统的 Java 路径中，那么导入能够成功，并且库能够被用于构建和运行一个 Java 应用程序。
如果一个库并不在 Java 路径中（因为，例如，你正在写你自己的库），那么该库可以与你的应用程序绑定在一起（协议许可），以便导入可以按预期地工作。
### 3、Java 类
Java 类使用关键字 `public class` 声明，以及一个唯一的对应于它的文件名的类名。例如，在项目 `helloworld` 中的一个文件 `Hello.java` 中：
```
package helloworld;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
* @author seth
* A GUI hello world.
*/
public class Hello {
// this is an empty class
}
```
你可以在一个类内部声明变量和函数。在 Java 中，在一个类中的变量被称为*字段*。
### 4、Java 方法
Java 的方法本质上是对象中的函数。基于预期返回的数据类型（例如 `void`、`int`、`float` 等等），它们被定义为 `public`（意味着它们可以被任何其它类访问）或 `private`（限制它们的使用）。
```
public void helloPrompt(ActionEvent event) {
String salutation = "Hello %s";
string helloMessage = "World";
message = String.format(salutation, helloMessage);
JOptionPane.showMessageDialog(this, message);
}
private int someNumber (x) {
return x*2;
}
```
当直接调用一个方法时，以其类和方法名称来引用。例如，`Hello.someNumber` 指向在 `Hello` 类中的 `someNumber` 方法。
### 5、static
Java 中的 `static` 关键字使代码中的成员可以独立于包含其的对象而被访问。
在面向对象编程中，你编写的代码用作“对象”的模板，这些对象在应用程序运行时产生。例如，你不需要编写一个具体的窗口，而是编写基于 Java 中的窗口类的窗口实例（并由你的代码修改）。由于在应用程序生成它的实例之前，你编写的所有代码都不会“存在”，因此在创建它们所依赖的对象之前，大多数方法和变量（甚至是嵌套类）都无法使用。
然而，有时，在对象被通过应用程序创建前，你需要访问或使用其中的数据。（例如，除非事先知道球是红色时，应用程序无法生成一个红色的球）。对于这些情况，请使用 `static` 关键字。
### 6、try 和 catch
Java 擅长捕捉错误，但是，只有你告诉它遇到错误时该做什么，它才能优雅地恢复。在 Java 中，尝试执行一个动作的级联层次结构以 `try` 开头，出现错误时回落到 `catch`，并以 `finally` 结束。如果 `try` 子句失败，则将调用 `catch`，最后，不管结果如何，总是由 `finally` 来执行一些合理的动作。这里是一个示例：
```
try {
cmd = parser.parse(opt, args);
if(cmd.hasOption("help")) {
HelpFormatter helper = new HelpFormatter();
helper.printHelp("Hello <options>", opt);
System.exit(0);
}
else {
if(cmd.hasOption("shell") || cmd.hasOption("s")) {
String target = cmd.getOptionValue("tgt");
} // else
} // fi
} catch (ParseException err) {
System.out.println(err);
System.exit(1);
} //catch
finally {
new Hello().helloWorld(opt);
} //finally
} //try
```
这是一个健壮的系统，它试图避免无法挽回的错误，或者，至少，为你提供让用户提交有用的反馈的选项。经常使用它，你的用户将会感谢你！
### 7、运行 Java 应用程序
Java 文件，通常以 `.java` 结尾，理论上说，可以使用 `java` 命令运行。然而，如果一个应用程序很复杂，运行一个单个文件是否会产生有意义的结果是另外一个问题。
来直接运行一个 `.java` 文件：
```
$ java ./Hello.java
```
通常，Java 应用程序以 Java 存档（JAR）文件的形式分发，以 `.jar` 结尾。一个 JAR 文件包含一个清单文件（可以指定主类、项目结构的一些元数据），以及运行应用程序所需的所有代码部分。
要运行一个 JAR 文件，你可以双击它的图标（取决于你的操作系统设置），你也可以从终端中启动它：
```
$ java -jar ./Hello.jar
```
### 适合所有人的 Java
Java 是一种强大的语言，由于有了 [OpenJDK](https://openjdk.java.net/) 项目及其它的努力，它是一种开放式规范，允许像 [IcedTea](https://icedtea.classpath.org/wiki/Main_Page)、[Dalvik](https://source.android.com/devices/tech/dalvik/) 和 [Kotlin](https://kotlinlang.org/) 项目的茁壮成长。学习 Java 是一种准备在各种行业中工作的好方法，而且，[使用 Java 的理由很多](https://opensource.com/article/19/9/why-i-use-java)。
---
via: <https://opensource.com/article/19/10/java-basics>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[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/) 荣誉推出
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.