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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
如何使用树莓派测定颗粒物（PM 2.5）
|
Stephan Tetzel
|
https://opensource.com/article/18/3/how-measure-particulate-matter-raspberry-pi
|
使用两个简单的硬件设备和几行代码构建一个空气质量探测器。
|
/data/attachment/album/201805/08/235157zbhruvv0zms8kmor.png.thumb.jpg
|
/data/attachment/album/201805/08/235157zbhruvv0zms8kmor.png
| true | false | true |
HankChow
| false |
[
"空气",
"树莓派"
] |
树莓派
|
{
"viewnum": 8127,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 10939,
"displayorder": 0
}
] |
使用两个简单的硬件设备和几行代码构建一个空气质量探测器。
| 2018-05-08T23:51:54 | 2018-05-08T23:51:54 | 9,620 |
/article-9620-1.html
|
>
> 使用两个简单的硬件设备和几行代码构建一个空气质量探测器。
>
>
>
我们在东南亚的学校定期测定空气中的颗粒物。这里的测定值非常高，尤其是在二到五月之间，干燥炎热、土地干旱等各种因素都对空气质量产生了不利的影响。我将会在这篇文章中展示如何使用树莓派来测定颗粒物。
### 什么是颗粒物？
颗粒物就是粉尘或者空气中的微小颗粒。其中 PM10 和 PM2.5 之间的差别就是 PM10 指的是粒径小于 10 微米的颗粒，而 PM2.5 指的是粒径小于 2.5 微米的颗粒。在粒径小于 2.5 微米的的情况下，由于它们能被吸入肺泡中并且对呼吸系统造成影响，因此颗粒越小，对人的健康危害越大。
世界卫生组织的建议[颗粒物浓度](https://en.wikipedia.org/wiki/Particulates)是：
* 年均 PM10 不高于 20 µg/m³
* 年均 PM2.5 不高于 10 µg/m³
* 不允许超标时，日均 PM10 不高于 50 µg/m³
* 不允许超标时，日均 PM2.5 不高于 25 µg/m³
以上数值实际上是低于大多数国家的标准的，例如欧盟对于 PM10 所允许的年均值是不高于 40 µg/m³。
### 什么是<ruby> 空气质量指数 <rt> Air Quality Index </rt></ruby>（AQI）？
空气质量指数是按照颗粒物的测定值来评价空气质量的好坏，然而由于各国之间的计算方式有所不同，这个指数并没有统一的标准。维基百科上关于[空气质量指数](https://en.wikipedia.org/wiki/Air_quality_index)的词条对此给出了一个概述。我们学校则以<ruby> <a href="https://en.wikipedia.org/wiki/United_States_Environmental_Protection_Agency"> 美国环境保护协会 </a> <rt> Environment Protection Agency </rt></ruby>（EPA）建立的分类法来作为依据。
*空气质量指数*
### 测定颗粒物需要哪些准备？
测定颗粒物只需要以下两种器材：
* 树莓派（款式不限，最好带有 WiFi）
* SDS011 颗粒物传感器
*颗粒物传感器*
如果是只带有 Micro USB 的树莓派 Zero W，那还需要一根连接到标准 USB 端口的适配线，只需要 20 美元，而传感器则自带适配串行接口的 USB 适配器。
### 安装过程
对于树莓派，只需要下载对应的 Raspbian Lite 镜像并且[写入到 Micro SD 卡](https://www.raspberrypi.org/documentation/installation/installing-images/README.md)上就可以了（网上很多教程都有介绍如何设置 WLAN 连接，我就不细说了）。
如果要使用 SSH，那还需要在启动分区建立一个名为 `ssh` 的空文件。树莓派的 IP 通过路由器或者 DHCP 服务器获取，随后就可以通过 SSH 登录到树莓派了（默认密码是 raspberry）：
```
$ ssh pi@192.168.1.5
```
首先我们需要在树莓派上安装一下这些包：
```
$ sudo apt install git-core python-serial python-enum lighttpd
```
在开始之前，我们可以用 `dmesg` 来获取 USB 适配器连接的串行接口：
```
$ dmesg
[ 5.559802] usbcore: registered new interface driver usbserial
[ 5.559930] usbcore: registered new interface driver usbserial_generic
[ 5.560049] usbserial: USB Serial support registered for generic
[ 5.569938] usbcore: registered new interface driver ch341
[ 5.570079] usbserial: USB Serial support registered for ch341-uart
[ 5.570217] ch341 1–1.4:1.0: ch341-uart converter detected
[ 5.575686] usb 1–1.4: ch341-uart converter now attached to ttyUSB0
```
在最后一行，可以看到接口 `ttyUSB0`。然后我们需要写一个 Python 脚本来读取传感器的数据并以 JSON 格式存储，在通过一个 HTML 页面就可以把数据展示出来了。
### 在树莓派上读取数据
首先创建一个传感器实例，每 5 分钟读取一次传感器的数据，持续 30 秒，这些数值后续都可以调整。在每两次测定的间隔，我们把传感器调到睡眠模式以延长它的使用寿命（厂商认为元件的寿命大约 8000 小时）。
我们可以使用以下命令来下载 Python 脚本：
```
$ wget -O /home/pi/aqi.py https://raw.githubusercontent.com/zefanja/aqi/master/python/aqi.py
```
另外还需要执行以下两条命令来保证脚本正常运行：
```
$ sudo chown pi:pi /var/www/html/
$ echo '[]' > /var/www/html/aqi.json
```
下面就可以执行脚本了：
```
$ chmod +x aqi.p
$ ./aqi.py
PM2.5:55.3, PM10:47.5
PM2.5:55.5, PM10:47.7
PM2.5:55.7, PM10:47.8
PM2.5:53.9, PM10:47.6
PM2.5:53.6, PM10:47.4
PM2.5:54.2, PM10:47.3
…
```
### 自动化执行脚本
只需要使用诸如 crontab 的服务，我们就不需要每次都手动启动脚本了。按照以下命令打开 crontab 文件：
```
$ crontab -e
```
在文件末尾添加这一行：
```
@reboot cd /home/pi/ && ./aqi.py
```
现在我们的脚本就会在树莓派每次重启后自动执行了。
### 展示颗粒物测定值和空气质量指数的 HTML 页面
我们在前面已经安装了一个轻量级的 web 服务器 `lighttpd`，所以我们需要把 HTML、JavaScript、CSS 文件放置在 `/var/www/html` 目录中，这样就能通过电脑和智能手机访问到相关数据了。执行下面的三条命令，可以下载到对应的文件：
```
$ wget -O /var/www/html/index.html https://raw.githubusercontent.com/zefanja/aqi/master/html/index.html
$ wget -O /var/www/html/aqi.js https://raw.githubusercontent.com/zefanja/aqi/master/html/aqi.js
$ wget -O /var/www/html/style.css https://raw.githubusercontent.com/zefanja/aqi/master/html/style.css
```
在 JavaScript 文件中，实现了打开 JSON 文件、提取数据、计算空气质量指数的过程，随后页面的背景颜色将会根据 EPA 的划分标准而变化。
你只需要用浏览器访问树莓派的地址，就可以看到当前颗粒物浓度值等数据了： [http://192.168.1.5:](http://192.168.1.5/)
这个页面比较简单而且可扩展，比如可以添加一个展示过去数小时历史数据的表格等等。
这是[Github上的完整源代码](https://github.com/zefanja/aqi)。
### 总结
在资金相对紧张的情况下，树莓派是一种选择。除此以外，还有很多可以用来测定颗粒物的应用，包括室外固定装置、移动测定设备等等。我们学校则同时采用了这两种：固定装置在室外测定全天颗粒物浓度，而移动测定设备在室内检测空调过滤器的效果。
[Luftdaten.info](http://luftdaten.info/) 提供了一个如何设计类似的传感器的介绍，其中的软件效果出众，而且因为它没有使用树莓派，所以硬件更是小巧。
对于学生来说，设计一个颗粒物传感器确实算得上是一个优秀的课外项目。
你又打算如何使用你的[树莓派](https://openschoolsolutions.org/shutdown-servers-case-power-failure%e2%80%8a-%e2%80%8aups-nut-co/)呢？
---
via: <https://opensource.com/article/18/3/how-measure-particulate-matter-raspberry-pi>
作者：[Stephan Tetzel](https://opensource.com/users/stephan) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
DevOps 会让你失业吗？
|
Chris Collins
|
https://opensource.com/article/17/12/will-devops-steal-my-job
|
你是否担心工作中自动化将代替人？可能是对的，但是这并不是件坏事。
|
/data/attachment/album/201805/09/003014grrnq6r00qrcq44v.jpg.thumb.jpg
|
/data/attachment/album/201805/09/003014grrnq6r00qrcq44v.jpg
| true | false | true |
qhwdw
| false |
[
"DevOps"
] |
观点
|
{
"viewnum": 3778,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你是否担心工作中自动化将代替人？可能是对的，但是这并不是件坏事。
| 2018-05-09T00:30:18 | 2018-05-09T00:30:18 | 9,621 |
/article-9621-1.html
|
>
> 你是否担心工作中自动化将代替人？可能是对的，但是这并不是件坏事。
>
>
>
这是一个很正常的担心：DevOps 最终会让你失业？毕竟，DevOps 意味着开发人员做运营，对吗？DevOps 是自动化的。如果我的工作都自动化了，我去做什么？实行持续分发和容器化意味着运营已经过时了吗？对于 DevOps 来说，所有的东西都是代码：基础设施是代码、测试是代码、这个和那个都是代码。如果我没有这些技能怎么办？
[DevOps](https://opensource.com/resources/devops) 是一个即将到来的变化，它将颠覆这一领域，狂热的拥挤者们正在谈论，如何使用 [三种方法](http://itrevolution.com/the-three-ways-principles-underpinning-devops/) 去改变世界 —— 即 DevOps 的三大基础 —— 去推翻一个旧的世界。它是势不可档的。那么，问题来了 —— DevOps 将会让我失业吗？
### 第一个担心：再也不需要我了
由于开发者来管理应用程序的整个生命周期，接受 DevOps 的理念很容易。容器化可能是影响这一想法的重要因素。当容器化在各种场景下铺开之后，它们被吹嘘成开发者构建、测试和部署他们代码的一站式解决方案。DevOps 对于运营、测试、以及 QA 团队来说，有什么作用呢？
这源于对 DevOps 原则的误解。DevOps 的第一原则，或者第一方法是，<ruby> 系统思考 <rt> Systems Thinking </rt></ruby>，或者强调整体管理方法和了解应用程序或服务的整个生命周期。这并不意味着应用程序的开发者将学习和管理整个过程。相反，是拥有各个专业和技能的人共同合作，以确保成功。让开发者对这一过程完全负责的作法，几乎是将开发者置于使用者的对立面 —— 本质上就是 “将鸡蛋放在了一个篮子里”。
在 DevOps 中有一个为你保留的专门职位。就像将一个受过传统教育的、拥有线性回归和二分查找知识的软件工程师，被用去写一些 Ansible playbooks 和 Docker 文件，这是一种浪费。而对于那些拥有高级技能，知道如何保护一个系统和优化数据库执行的系统管理员，被浪费在写一些 CSS 和设计用户流这样的工作上。写代码、做测试、和维护应用程序的高效团队一般是跨学科、跨职能的、拥有不同专业技术和背景的人组成的混编团队。
### 第二个担心：我的工作将被自动化
或许是，或许不是，DevOps 可能在有时候是自动化的同义词。当自动化构建、测试、部署、监视，以及提醒等事项，已经占据了整个应用程序生命周期管理的时候，还会给我们剩下什么工作呢？这种对自动化的关注可能与第二个方法有关：<ruby> 放大反馈循环 <rt> Amplify Feedback Loops </rt></ruby>。DevOps 的第二个方法是在团队和部署的应用程序之间，采用相反的方向优先处理快速反馈 —— 从监视和维护部署、测试、开发、等等，通过强调，使反馈更加重要并且可操作。虽然这第二种方式与自动化并不是特别相关，许多自动化工具团队在它们的部署流水线中使用，以促进快速提醒和快速行动，或者基于对使用者的支持业务中产生的反馈来改进。传统的做法是靠人来完成的，这就可以理解为什么自动化可能会导致未来一些人失业的焦虑了。
自动化只是一个工具，它并不能代替人。聪明的人使用它来做一些重复的工作，不去开发智力和创造性的财富，而是去按红色的 “George Jetson” 按钮是一种极大的浪费。让每天工作中的苦活自动化，意味着有更多的时间去解决真正的问题和即将到来的创新的解决方案。人类需要解决更多的 “怎么做和为什么” 问题，而计算机只能处理 “复制和粘贴”。
并不会仅限于在可重复的、可预见的事情上进行自动化，自动化让团队有更多的时间和精力去专注于本领域中更高级别的任务上。监视团队不再花费他们的时间去配置报警或者管理传统的配置，它们可能专注于预测可能的报警、相关性统计、以及设计可能的预案。系统管理员从计划补丁或服务器配置中解放出来，可以花费更多的时间专注于整体管理、性能、和可伸缩性。与工厂车间和装配线上完全没有人的景像不同，DevOps 中的自动化任务，意味着人更多关注于创造性的、有更高价值的任务，而不是一些重复的、让人麻木的苦差事。
### 第三个担心：我没有这些技能怎么办
“我怎么去继续做这些事情？我不懂如何自动化。现在所有的工作都是代码 —— 我不是开发人员，我不会做 DevOps 中写代码的工作”，第三个担心是一种不自信的担心。由于文化的改变，是的，团队将也会要求随之改变，一些人可能担心，他们缺乏继续做他们工作的技能。
然而，大多数人或许已经比他们所想的更接近。Dockerfile 是什么，或者像 Puppet 或 Ansible 配置管理是什么，这就是环境即代码，系统管理员已经写了 shell 脚本和 Python 程序去处理他们重复的任务。学习更多的知识并使用已有的工具处理他们的更多问题 —— 编排、部署、维护即代码 —— 尤其是当从繁重的手动任务中解放出来，专注于成长时。
在 DevOps 的使用者中去回答这第三个担心，第三个方法是：<ruby> 一种不断实验和学习的文化 <rt> A Culture of Continual Experimentation and Learning </rt></ruby>。尝试、失败，并从错误中吸取教训而不是责怪它们的能力，是设计出更有创意的解决方案的重要因素。第三个方法是为前两个方法授权 —— 允许快速检测和修复问题，并且开发人员可以自由地尝试和学习，其它的团队也是如此。从未使用过配置管理或者写过自动供给基础设施程序的运营团队也要自由尝试并学习。测试和 QA 团队也要自由实现新测试流水线，并且自动批准和发布新流程。在一个拥抱学习和成长的文化中，每个人都可以自由地获取他们需要的技术，去享受工作带来的成功和喜悦。
### 结束语
在一个行业中，任何可能引起混乱的实践或变化都会产生担心和不确定，DevOps 也不例外。对自己工作的担心是对成百上千的文章和演讲的合理回应，其中列举了无数的实践和技术，而这些实践和技术正致力于授权开发者对行业的各个方面承担职责。
然而，事实上，DevOps 是 “[一个跨学科的沟通实践，致力于研究构建、进化、和运营快速变化的弹性系统](https://theagileadmin.com/what-is-devops/)”。 DevOps 意味着终结 “筒仓”，但并不专业化。它是受委托去做苦差事的自动化系统，解放你，让你去做人类更擅长做的事：思考和想像。并且，如果你愿意去学习和成长，它将不会终结你解决新的、挑战性的问题的机会。
DevOps 会让你失业吗？会的，但它同时给你提供了更好的工作。
---
via: <https://opensource.com/article/17/12/will-devops-steal-my-job>
作者：[Chris Collins](https://opensource.com/users/clcollins) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
4 个 Linux 下的命令行笔记程序
|
Scott Nesbitt
|
https://opensource.com/article/18/3/command-line-note-taking-applications
|
这些工具可以让你在 Linux 命令行下简单而有效地记录笔记和保存信息。
|
/data/attachment/album/201805/09/004244j526299tzvqz4lbq.jpg.thumb.jpg
|
/data/attachment/album/201805/09/004244j526299tzvqz4lbq.jpg
| true | false | true |
geekpi
| false |
[
"笔记"
] |
分享
|
{
"viewnum": 6930,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这些工具可以让你在 Linux 命令行下简单而有效地记录笔记和保存信息。
| 2018-05-09T00:42:42 | 2018-05-09T00:42:42 | 9,622 |
/article-9622-1.html
|
>
> 这些工具可以让你在 Linux 命令行下简单而有效地记录笔记和保存信息。
>
>
>
当你需要保存代码段或 URL、想法或引用时，可能会启动文本编辑器或使用[桌面](https://opensource.com/life/16/9/4-desktop-note-taking-applications)或[基于 Web 的](https://opensource.com/alternatives/evernote)笔记记录工具。但那些不是你唯一的选择。如果你在终端窗口中工作，则可以使用 Linux 命令行下的许多笔记记录工具之一。
我们来看看这四个程序。
### tnote
[tnote](https://github.com/tasdikrahman/tnote) 使在终端窗口中记笔记很简单 —— 几乎太简单了。
tnote 是一个 Python 脚本。首次启动时，它会要求你输入密码和口令来加密存储笔记的 [SQLite 数据库](http://en.wikipedia.org/wiki/SQLite)。完成之后，按 `A` 创建一个笔记。输入你的笔记，然后按 `CTRL-D` 保存。
一旦你有几个（或多个）笔记，你可以查看它们或搜索特定的笔记，单词或短语或标签。tnote 没有很多功能，但它确实实现了任务。
### Terminal Velocity
如果你使用过 Mac OS，你可能会看到一个名为 [Notational Velocity](http://notational.net/) 的流行开源笔记程序，这是一种记录笔记的简单有效方法。[Terminal Velocity](https://vhp.github.io/terminal_velocity/) 在将 Notational Velocity 体验带入命令行方面做得很好。
Terminal Velocity 打开你的默认文本编辑器（由你的 `.profile` 或 `.bashrc` 文件中的 `$EDITOR` 变量设置）。输入你的笔记，然后保存。该笔记出现在 Terminal Velocity 窗口的列表中。
使用键盘上的箭头键滚动查看你的笔记列表。要查看或编辑笔记，请按回车键。如果你有一长串笔记，则可以在 `Find or Create` 字段中输入笔记标题的前几个字符以缩小列表的范围。在那里滚动笔记并按下回车键将其打开。
### pygmynote
在本文中的四个应用中，[pygmynote](https://github.com/dmpop/pygmynote) 可能是最不用户友好的。然而，它是最灵活的。
像 tnote 一样，pygmynote 将你的笔记和附件保存在 SQLite 数据库中。当你启动它时，pygmynote 看起来并不特别有用。在任何时候，输入 `help` 并按下回车键获取命令列表。
你可以添加、编辑、查看和搜索笔记，并在笔记中添加[标签](https://en.wikipedia.org/wiki/Tag_(metadata))。标签使找到笔记更容易，特别是如果你有很多笔记的时候。
pygmynote 的灵活性在于它能够将附件添加到笔记中。这些附件可以是任何东西：图像、文本、word、PDF、电子表格或与笔记相关的任何其他内容。
### jrnl
[jrnl](http://jrnl.sh/) 是这里的一个奇怪应用。正如你可能从它的名字中猜到的那样，jrnl 意在成为一种日记工具。但这并不意味着你不能记笔记。 jrnl 做得很好。
当你第一次启动 jrnl 时，它会询问你想把文件 `journal.txt` （它存储你的笔记）保存的位置以及是否需要密码保护。如果你决定添加密码，那么你在应用内的操作都需要输入密码。
你可以通过两种方式输入笔记：直接从命令行或使用计算机的默认编辑器。你可以将标签（例如，`@opensource.com`）添加到笔记中，并指定日期和时间戳。如果你有很多笔记的话，添加标签和日期可以帮助搜索你的笔记（jrnl 有一个相当不错的搜索功能）。
由于 jrnl 将你的笔记保存为纯文本文件，因此你可以使用 [ownCloud](https://owncloud.com/)、[Nextcloud](https://nextcloud.com/) 或任何你喜欢的文件共享/同步服务在设备间同步它。
你有没有喜欢的工具或自制的命令行笔记工具？请发表评论，随时与社区分享。
---
via: <https://opensource.com/article/18/3/command-line-note-taking-applications>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 上寻找你正在寻找的东西
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3268768/linux/finding-what-you-re-looking-for-on-linux.html
|
怎样在 Linux 系统上使用 find、locate、mlocate、which、 whereis、 whatis 和 apropos 命令寻找文件。
|
/data/attachment/album/201805/09/084416d4oorf4r4o42th7z.jpg.thumb.jpg
|
/data/attachment/album/201805/09/084416d4oorf4r4o42th7z.jpg
| true | false | true |
MjSeven
| false |
[
"find",
"查找",
"locate"
] |
技术
|
{
"viewnum": 8164,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
怎样在 Linux 系统上使用 find、locate、mlocate、which、 whereis、 whatis 和 apropos 命令寻找文件。
| 2018-05-09T08:44:00 | 2018-05-09T08:44:00 | 9,623 |
/article-9623-1.html
|
>
> 怎样在 Linux 系统上使用 find、locate、mlocate、which、 whereis、 whatis 和 apropos 命令寻找文件。
>
>
>
在 Linux 系统上找到你要找的文件或命令并不难， 有很多种方法可以寻找。
### find
最显然的无疑是 `find` 命令，并且 `find` 变得比过去几年更容易使用了。它过去需要一个搜索的起始位置，但是现在，如果你想将搜索限制在当下目录中，你还可以使用仅包含文件名或正则表达式的 `find` 命令。
```
$ find e*
empty
examples.desktop
```
这样，它就像 `ls` 命令一样工作，并没有做太多的搜索。
对于更专业的搜索，`find` 命令需要一个起点和一些搜索条件（除非你只是希望它提供该起点目录的递归列表）。命令 `find -type f` 从当前目录开始将递归列出所有常规文件，而 `find ~nemo -type f -empty` 将在 nemo 的主目录中找到空文件。
```
$ find ~nemo -type f -empty
/home/nemo/empty
```
参见：[11 个好玩的 Linux 终端技巧](http://www.networkworld.com/article/2926630/linux/11-pointless-but-awesome-linux-terminal-tricks.html#tk.nww-fsb)。
### locate
`locate` 命令的名称表明它与 `find` 命令基本相同，但它的工作原理完全不同。`find` 命令可以根据各种条件 —— 名称、大小、所有者、权限、状态（如空文件）等等选择文件并作为搜索选择深度，`locate` 命令通过名为 `/var/lib/mlocate/mlocate.db` 的文件查找你要查找的内容。该数据文件会定期更新，因此你刚创建的文件的位置它可能无法找到。如果这让你感到困扰，你可以运行 `updatedb` 命令立即获得更新。
```
$ sudo updatedb
```
### mlocate
`mlocate` 命令的工作类似于 `locate` 命令，它使用与 `locate` 相同的 `mlocate.db` 文件。
### which
`which` 命令的工作方式与 `find` 命令和 `locate` 命令有很大的区别。它使用你的搜索路径（`$PATH`）并检查其上的每个目录中具有你要查找的文件名的可执行文件。一旦找到一个，它会停止搜索并显示该可执行文件的完整路径。
`which` 命令的主要优点是它回答了“如果我输入此命令，将运行什么可执行文件？”的问题。它会忽略不可执行文件，并且不会列出系统上带有该名称的所有可执行文件 —— 列出的就是它找到的第一个。如果你想查找具有某个名称的所有可执行文件，则可以像这样运行 `find` 命令，但是要比非常高效 `which` 命令用更长的时间。
```
$ find / -name locate -perm -a=x 2>/dev/null
/usr/bin/locate
/etc/alternatives/locate
```
在这个 `find` 命令中，我们在寻找名为 “locate” 的所有可执行文件（任何人都可以运行的文件）。我们也选择了不要查看所有“拒绝访问”的消息，否则这些消息会混乱我们的屏幕。
### whereis
`whereis` 命令与 `which` 命令非常类似，但它提供了更多信息。它不仅仅是寻找可执行文件，它还寻找手册页（man page）和源文件。像 `which` 命令一样，它使用搜索路径（`$PATH`） 来驱动搜索。
```
$ whereis locate
locate: /usr/bin/locate /usr/share/man/man1/locate.1.gz
```
### whatis
`whatis` 命令有其独特的使命。它不是实际查找文件，而是在手册页中查找有关所询问命令的信息，并从手册页的顶部提供该命令的简要说明。
```
$ whatis locate
locate (1) - find files by name
```
如果你询问你刚刚设置的脚本，它不会知道你指的是什么，并会告诉你。
```
$ whatis cleanup
cleanup: nothing appropriate.
```
### apropos
当你知道你想要做什么，但不知道应该使用什么命令来执行此操作时，`apropos` 命令很有用。例如，如果你想知道如何查找文件，那么 `apropos find` 和 `apropos locate` 会提供很多建议。
```
$ apropos find
File::IconTheme (3pm) - find icon directories
File::MimeInfo::Applications (3pm) - Find programs to open a file by mimetype
File::UserDirs (3pm) - find extra media and documents directories
find (1) - search for files in a directory hierarchy
findfs (8) - find a filesystem by label or UUID
findmnt (8) - find a filesystem
gst-typefind-1.0 (1) - print Media type of file
ippfind (1) - find internet printing protocol printers
locate (1) - find files by name
mlocate (1) - find files by name
pidof (8) - find the process ID of a running program.
sane-find-scanner (1) - find SCSI and USB scanners and their device files
systemd-delta (1) - Find overridden configuration files
xdg-user-dir (1) - Find an XDG user dir
$
$ apropos locate
blkid (8) - locate/print block device attributes
deallocvt (1) - deallocate unused virtual consoles
fallocate (1) - preallocate or deallocate space to a file
IO::Tty (3pm) - Low-level allocate a pseudo-Tty, import constants.
locate (1) - find files by name
mlocate (1) - find files by name
mlocate.db (5) - a mlocate database
mshowfat (1) - shows FAT clusters allocated to file
ntfsfallocate (8) - preallocate space to a file on an NTFS volume
systemd-sysusers (8) - Allocate system users and groups
systemd-sysusers.service (8) - Allocate system users and groups
updatedb (8) - update a database for mlocate
updatedb.mlocate (8) - update a database for mlocate
whereis (1) - locate the binary, source, and manual page files for a...
which (1) - locate a command
```
### 总结
Linux 上可用于查找和识别文件的命令有很多种，但它们都非常有用。
---
via: <https://www.networkworld.com/article/3268768/linux/finding-what-you-re-looking-for-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[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/) 荣誉推出
|
||
如何在 Linux 上查看用户的创建日期
|
Prakash Subramanian
|
https://www.2daygeek.com/how-to-check-user-created-date-on-linux/
|
基本上 Linux 系统不会跟踪这些信息，因此，获取这些信息的替代方法是什么？
|
/data/attachment/album/201805/10/111549oxsb87ssbt0m04b3.jpg.thumb.jpg
|
/data/attachment/album/201805/10/111549oxsb87ssbt0m04b3.jpg
| true | false | true |
geekpi
| false |
[
"用户"
] |
技术
|
{
"viewnum": 9053,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
基本上 Linux 系统不会跟踪这些信息，因此，获取这些信息的替代方法是什么？
| 2018-05-10T11:15:55 | 2018-05-10T11:15:55 | 9,624 |
/article-9624-1.html
|
你知道吗，如何在 Linux 系统上查看帐户的创建日期？如果知道，那么有些什么办法。
你成功了么？如果是的话，该怎么做？
基本上 Linux 系统不会跟踪这些信息，因此，获取这些信息的替代方法是什么？
你可能会问为什么我要查看这个？
是的，在某些情况下，你可能需要查看这些信息，那时就会对你会有帮助。
可以使用以下 7 种方法进行验证。
* 使用 `/var/log/secure`
* 使用 `aureport` 工具
* 使用 `.bash_logout`
* 使用 `chage` 命令
* 使用 `useradd` 命令
* 使用 `passwd` 命令
* 使用 `last` 命令
### 方式 1：使用 /var/log/secure
它存储所有安全相关的消息，包括身份验证失败和授权特权。它还会通过系统安全守护进程跟踪 `sudo` 登录、SSH 登录和其他错误记录。
```
# grep prakash /var/log/secure
Apr 12 04:07:18 centos.2daygeek.com useradd[21263]: new group: name=prakash, GID=501
Apr 12 04:07:18 centos.2daygeek.com useradd[21263]: new user: name=prakash, UID=501, GID=501, home=/home/prakash, shell=/bin/bash
Apr 12 04:07:34 centos.2daygeek.com passwd: pam_unix(passwd:chauthtok): password changed for prakash
Apr 12 04:08:32 centos.2daygeek.com sshd[21269]: Accepted password for prakash from 103.5.134.167 port 60554 ssh2
Apr 12 04:08:32 centos.2daygeek.com sshd[21269]: pam_unix(sshd:session): session opened for user prakash by (uid=0)
```
### 方式 2：使用 aureport 工具
`aureport` 工具可以根据记录在审计日志中的事件记录生成汇总和柱状报告。默认情况下，它会查询 `/var/log/audit/` 目录中的所有 `audit.log` 文件来创建报告。
```
# aureport --auth | grep prakash
46. 04/12/2018 04:08:32 prakash 103.5.134.167 ssh /usr/sbin/sshd yes 288
47. 04/12/2018 04:08:32 prakash 103.5.134.167 ssh /usr/sbin/sshd yes 291
```
### 方式 3：使用 .bash\_logout
家目录中的 `.bash_logout` 对 bash 有特殊的含义，它提供了一种在用户退出系统时执行命令的方式。
我们可以查看用户家目录中 `.bash_logout` 的更改日期。该文件是在用户第一次注销时创建的。
```
# stat /home/prakash/.bash_logout
File: `/home/prakash/.bash_logout'
Size: 18 Blocks: 8 IO Block: 4096 regular file
Device: 801h/2049d Inode: 256153 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 501/ prakash) Gid: ( 501/ prakash)
Access: 2017-03-22 20:15:00.000000000 -0400
Modify: 2017-03-22 20:15:00.000000000 -0400
Change: 2018-04-12 04:07:18.283000323 -0400
```
### 方式 4：使用 chage 命令
`chage` 意即 “change age”。该命令让用户管理密码过期信息。`chage` 命令可以修改上次密码更改日期后需要更改密码的天数。
系统使用此信息来确定用户何时必须更改其密码。如果用户自帐户创建日期以来没有更改密码，这个就有用。
```
# chage --list prakash
Last password change : Apr 12, 2018
Password expires : never
Password inactive : never
Account expires : never
Minimum number of days between password change : 0
Maximum number of days between password change : 99999
Number of days of warning before password expires : 7
```
### 方式 5：使用 useradd 命令
`useradd` 命令用于在 Linux 中创建新帐户。默认情况下，它不会添加用户创建日期，我们必须使用 “备注” 选项添加日期。
```
# useradd -m prakash -c `date +%Y/%m/%d`
# grep prakash /etc/passwd
prakash:x:501:501:2018/04/12:/home/prakash:/bin/bash
```
### 方式 6：使用 passwd 命令
`passwd` 命令用于将密码分配给本地帐户或用户。如果用户在帐户创建后没有修改密码，那么可以使用 `passwd` 命令查看最后一次密码修改的日期。
```
# passwd -S prakash
prakash PS 2018-04-11 0 99999 7 -1 (Password set, MD5 crypt.)
```
### 方式 7：使用 last 命令
`last` 命令读取 `/var/log/wtmp`，并显示自该文件创建以来所有登录（和退出）用户的列表。
```
# last | grep "prakash"
prakash pts/2 103.5.134.167 Thu Apr 12 04:08 still logged in
```
---
via: <https://www.2daygeek.com/how-to-check-user-created-date-on-linux/>
作者：[Prakash Subramanian](https://www.2daygeek.com/author/prakash/) 选题：[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/) 荣誉推出
|
||
在 GitLab CI 中使用 Docker 构建 Go 项目
|
Sean Drumm
|
https://seandrumm.co.uk/blog/building-go-projects-with-docker-on-gitlab-ci/
|
这篇文章是我在 CI 环境（特别是在 Gitlab 中）的 Docker 容器中构建 Go 项目的研究总结。我发现很难解决私有依赖问题（来自 Node/.NET 背景），因此这是我写这篇文章的主要原因。
|
/data/attachment/album/201805/10/115107wk2k2tmtvm1xkvt1.jpg.thumb.jpg
|
/data/attachment/album/201805/10/115107wk2k2tmtvm1xkvt1.jpg
| true | false | true |
geekpi
| false |
[
"Go",
"CI",
"Docker"
] |
技术
|
{
"viewnum": 7214,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这篇文章是我在 CI 环境（特别是在 Gitlab 中）的 Docker 容器中构建 Go 项目的研究总结。我发现很难解决私有依赖问题（来自 Node/.NET 背景），因此这是我写这篇文章的主要原因。
| 2018-05-10T11:51:00 | 2018-05-10T11:51:00 | 9,625 |
/article-9625-1.html
|
### 介绍
这篇文章是我在 CI 环境（特别是在 Gitlab 中）的 Docker 容器中构建 Go 项目的研究总结。我发现很难解决私有依赖问题（来自 Node/.NET 背景），因此这是我写这篇文章的主要原因。如果 Docker 镜像上存在任何问题或提交请求，请随时与我们联系。
### dep
由于 dep 是现在管理 Go 依赖关系的最佳选择，因此在构建前之前运行 `dep ensure`。
注意：我个人不会将我的 `vendor/` 文件夹提交到源码控制，如果你这样做，我不确定这个步骤是否可以跳过。
使用 Docker 构建的最好方法是使用 `dep ensure -vendor-only`。 [见这里](https://github.com/golang/dep/blob/master/docs/FAQ.md#how-do-i-use-dep-with-docker)。
### Docker 构建镜像
我第一次尝试使用 `golang:1.10`，但这个镜像没有：
* curl
* git
* make
* dep
* golint
我已经创建好了用于构建的镜像（[github](https://github.com/sjdweb/go-docker-build/blob/master/Dockerfile) / [dockerhub](https://hub.docker.com/r/sjdweb/go-docker-build/)），我会保持更新，但我不提供任何担保，因此你应该创建并管理自己的 Dockerhub。
### 内部依赖关系
我们完全有能力创建一个有公共依赖关系的项目。但是如果你的项目依赖于另一个私人 Gitlab 仓库呢？
在本地运行 `dep ensure` 应该可以和你的 git 设置一起工作，但是一旦在 CI 上不适用，构建就会失败。
#### Gitlab 权限模型
这是在 [Gitlab 8.12 中添加的](https://docs.gitlab.com/ce/user/project/new_ci_build_permissions_model.html)，这个我们最关心的有用的功能是在构建期提供的 `CI_JOB_TOKEN` 环境变量。
这基本上意味着我们可以像这样克隆[依赖仓库](https://docs.gitlab.com/ce/user/project/new_ci_build_permissions_model.html#dependent-repositories)：
```
git clone https://gitlab-ci-token:${CI_JOB_TOKEN}@gitlab.com/myuser/mydependentrepo
```
然而，我们希望使这更友好一点，因为 `dep` 在试图拉取代码时不会奇迹般地添加凭据。
我们将把这一行添加到 `.gitlab-ci.yml` 的 `before_script` 部分。
```
before_script:
- echo -e "machine gitlab.com\nlogin gitlab-ci-token\npassword ${CI_JOB_TOKEN}" > ~/.netrc
```
使用 `.netrc` 文件可以指定哪个凭证用于哪个服务器。这种方法可以避免每次从 Git 中拉取（或推送）时输入用户名和密码。密码以明文形式存储，因此你不应在自己的计算机上执行此操作。这实际用于 Git 在背后使用 `cURL`。 [在这里阅读更多](https://github.com/bagder/everything-curl/blob/master/usingcurl-netrc.md)。
### 项目文件
#### Makefile
虽然这是可选的，但我发现它使事情变得更容易。
配置这些步骤意味着在 CI 脚本（和本地）中，我们可以运行 `make lint`、`make build` 等，而无需每次重复步骤。
```
GOFILES = $(shell find . -name '*.go' -not -path './vendor/*')
GOPACKAGES = $(shell go list ./... | grep -v /vendor/)
default: build
workdir:
mkdir -p workdir
build: workdir/scraper
workdir/scraper: $(GOFILES)
GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o workdir/scraper .
test: test-all
test-all:
@go test -v $(GOPACKAGES)
lint: lint-all
lint-all:
@golint -set_exit_status $(GOPACKAGES)
```
#### .gitlab-ci.yml
这是 Gitlab CI 魔术发生的地方。你可能想使用自己的镜像。
```
image: sjdweb/go-docker-build:1.10
stages:
- test
- build
before_script:
- cd $GOPATH/src
- mkdir -p gitlab.com/$CI_PROJECT_NAMESPACE
- cd gitlab.com/$CI_PROJECT_NAMESPACE
- ln -s $CI_PROJECT_DIR
- cd $CI_PROJECT_NAME
- echo -e "machine gitlab.com\nlogin gitlab-ci-token\npassword ${CI_JOB_TOKEN}" > ~/.netrc
- dep ensure -vendor-only
lint_code:
stage: test
script:
- make lint
unit_tests:
stage: test
script:
- make test
build:
stage: build
script:
- make
```
### 缺少了什么
我通常会用我的二进制文件构建 Docker 镜像，并将其推送到 Gitlab 容器注册库中。
你可以看到我正在构建二进制文件并退出，你至少需要将该二进制文件（例如生成文件）存储在某处。
---
via: <https://seandrumm.co.uk/blog/building-go-projects-with-docker-on-gitlab-ci/>
作者：[SEAN DRUMM](https://seandrumm.co.uk/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Red Hat 的去 Docker 化容器实践
|
Anarcat
|
https://anarc.at/blog/2017-12-20-docker-without-docker/
|
使用一系列更小、可协同工作的组件替代 Docker。他的战斗口号是“拒绝臃肿的守护进程”，理由是与公认的 Unix 哲学相违背。
|
/data/attachment/album/201805/10/122423nn342z26ornon21o.jpg.thumb.jpg
|
/data/attachment/album/201805/10/122423nn342z26ornon21o.jpg
| true | false | true |
pinewall
| false |
[
"容器"
] |
观点
|
{
"viewnum": 6536,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
使用一系列更小、可协同工作的组件替代 Docker。他的战斗口号是“拒绝臃肿的守护进程”，理由是与公认的 Unix 哲学相违背。
| 2018-05-10T12:24:36 | 2018-05-10T12:24:36 | 9,626 |
/article-9626-1.html
|
最近几年，开源项目 Docker (已更名为[Moby](https://mobyproject.org/)) 在容器普及化方面建树颇多。然而，它的功能特性不断集中到一个单一、庞大的系统，该系统由具有 root 权限运行的守护进程 `dockerd` 管控，这引发了人们的焦虑。对这些焦虑的阐述，具有代表性的是 Red Hat 公司的容器团队负责人 Dan Walsh 在 [KubeCon + CloudNativecon](http://events.linuxfoundation.org/events/kubecon-and-cloudnativecon-north-america) 会议中的[演讲](https://kccncna17.sched.com/event/CU8j/cri-o-hosted-by-daniel-walsh-red-hat)。Walsh 讲述了他的容器团队目前的工作方向，即使用一系列更小、可协同工作的组件替代 Docker。他的战斗口号是“拒绝臃肿的守护进程”，理由是与公认的 Unix 哲学相违背。
### Docker 模块化实践
就像我们在[早期文献](https://lwn.net/Articles/741897/)中看到的那样，容器的基础操作不复杂：你首先拉取一个容器镜像，利用该镜像创建一个容器，最后启动这个容器。除此之外，你要懂得如何构建镜像并推送至镜像仓库。大多数人在上述这些步骤中使用 Docker，但其实 Docker 并不是唯一的选择，目前的可替换选择是 `rkt`。rkt 引发了一系列标准的创建，包括运行时标准 CRI，镜像标准 OCI 及网络标准 CNI 等。遵守这些标准的后端，如 [CRI-O](http://cri-o.io/) 和 Docker，可以与 [Kubernetes](https://kubernetes.io/) 为代表的管理软件协同工作。
这些标准促使 Red Hat 公司开发了一系列实现了部分标准的“核心应用”供 Kubernetes 使用，例如 CRI-O 运行时。但 Kubernetes 提供的功能不足以满足 Red Hat 公司的 [OpenShift](https://www.openshift.com/) 项目所需。开发者可能需要构建容器并推送至镜像仓库，实现这些操作需要额外的一整套方案。
事实上，目前市面上已有多种构建容器的工具。来自 Sysdig 公司的 Michael Ducy 在[分会场](https://kccncna17.sched.com/event/CU6B/building-better-containers-a-survey-of-container-build-tools-i-michael-ducy-chef)中回顾了 Docker 本身之外的 8 种镜像构建工具，而这也很可能不是全部。Ducy 将理想的构建工具定义如下：可以用可重现的方式创建最小化镜像。最小化镜像并不包含操作系统，只包含应用本身及其依赖。Ducy 认为 [Distroless](https://github.com/GoogleCloudPlatform/distroless), [Smith](https://github.com/oracle/smith) 及 [Source-to-Image](https://github.com/openshift/source-to-image) 都是很好的工具，可用于构建最小化镜像。Ducy 将最小化镜像称为“微容器”。
<ruby> 可重现镜像 <rt> reproducible container </rt></ruby>是指构建多次结果保持不变的镜像。为达到这个目标，Ducy 表示应该使用“宣告式”而不是“命令式”的方式。考虑到 Ducy 来自 Chef 配置管理工具领域，你应该能理解他的意思。Ducy 给出了符合标准的几个不错的实现，包括 [Ansible 容器](https://www.ansible.com/ansible-container)、 [Habitat](https://www.habitat.sh/)、 [nixos-容器](https://nixos.org/nixos/manual/#ch-containers)和 [Simth](https://github.com/oracle/smith) 等，但你需要了解这些项目对应的编程语言。Ducy 额外指出 Habitat 构建的容器自带管理功能，如果你已经使用了 systemd、 Docker 或 Kubernetes 等外部管理工具，Habitat 的管理功能可能是冗余的。除此之外，我们还要提到从 Docker 和 [Buildah](https://github.com/projectatomic/buildah) 项目诞生的新项目 [BuildKit](https://github.com/moby/buildkit)， 它是 Red Hat 公司 [Atomic 工程](https://www.projectatomic.io/)的一个组件。
### 使用 Buildah 构建容器
![\[Buildah logo\]](/data/attachment/album/201805/10/122437qhminlii9nhbwbbw.png "Buildah logo")
Buildah 名称显然来自于 Walsh 风趣的 [波士顿口音](https://en.wikipedia.org/wiki/Boston_accent)； 该工具的品牌宣传中充满了波士顿风格，例如 logo 使用了波士顿梗犬（如图所示）。该项目的实现思路与 Ducy 不同：为了构建容器，与其被迫使用宣告式配置管理的方案，不如构建一些简单工具，结合你最喜欢的配置管理工具使用。这样你可以如愿的使用命令行，例如使用 `cp` 命令代替 Docker 的自定义指令 `COPY` 。除此之外，你可以使用如下工具为容器提供内容：1) 配置管理工具，例如Ansible 或 Puppet；2) 操作系统相关或编程语言相关的安装工具，例如 APT 和 pip； 3) 其它系统。下面展示了基于通用 shell 命令的容器构建场景，其中只需要使用 `make` 命令即可为容器安装可执行文件。
```
# 拉取基础镜像, 类似 Dockerfile 中的 FROM 命令
buildah from redhat
# 挂载基础镜像, 在其基础上工作
crt=$(buildah mount)
ap foo $crt
make install DESTDIR=$crt
# 下一步，生成快照
buildah commit
```
有趣的是，基于这个思路，你可以复用主机环境中的构建工具，无需在镜像中安装这些依赖，故可以构建非常微小的镜像。通常情况下，构建容器镜像时需要在容器中安装目标应用的构建依赖。例如，从源码构建需要容器中有编译器工具链，这是因为构建并不在主机环境进行。大量的容器也包含了 `ps` 和 `bash` 这样的 Unix 命令，对微容器而言其实是多余的。开发者经常忘记或无法从构建好的容器中移除一些依赖，增加了不必要的开销和攻击面。
Buildah 的模块化方案能够以非 root 方式进行部分构建；但`mount` 命令仍然需要 `CAP_SYS_ADMIN`，有一个 [工单](https://github.com/projectatomic/buildah/issues/171) 试图解决该问题。但 Buildah 与 Docker [都有](https://github.com/projectatomic/buildah/issues/158)同样的[限制](https://github.com/moby/moby/issues/27886#issuecomment-281278525)，即无法在容器内构建容器。对于 Docker，你需要使用“特权”模式运行容器，一些特殊的环境很难满足这个条件，例如 [GitLab 持续集成](https://about.gitlab.com/features/gitlab-ci-cd/)；即使满足该条件，配置也特别[繁琐](https://jpetazzo.github.io/2015/09/03/do-not-use-docker-in-docker-for-ci/)。
手动提交的步骤可以对创建容器快照的时间节点进行细粒度控制。Dockerfile 每一行都会创建一个新的快照；相比而言，Buildah 的提交检查点都是事先选择好的，这可以减少不必要的快照并节省磁盘空间。这也有利于隔离私钥或密码等敏感信息，避免其出现在公共镜像中。
Docker 构建的镜像是非标准的、仅供其自身使用；相比而言，Buildah 提供[多种输出格式](https://github.com/projectatomic/buildah/blob/master/docs/buildah-push.md)，其中包括符合 OCI 标准的镜像。为向后兼容，Buildah 提供了一个“使用 Dockerfile 构建”的命令，即 [`buildah bud`](https://github.com/projectatomic/buildah/blob/master/docs/buildah-bud.md)， 它可以解析标准的 Dockerfile。Buildah 提供 `enter` 命令直接查看镜像内部信息，`run` 命令启动一个容器。实现这些功能仅使用了 `runc` 在内的标准工具，无需在后台运行一个“臃肿的守护进程”。
Ducy 对 Buildah 表示质疑，认为采用非宣告性不利于可重现性。如果允许使用 shell 命令，可能产生很多预想不到的情况；例如，一个 shell 脚本下载了任意的可执行程序，但后续无法追溯文件的来源。shell 命令的执行受环境变量影响，执行结果可能大相径庭。与基于 shell 的工具相比，Puppet 或 Chef 这样的配置管理系统在理论上更加可靠，因为它们的设计初衷就是收敛于最终配置；事实上，可以通过配置管理系统调用 shell 命令。但 Walsh 对此提出反驳，认为已有的配置管理工具可以在 Buildah 的基础上工作，用户可以选择是否使用配置管理；这样更加符合“机制与策略分离”的经典 Unix 哲学。
目前 Buildah 处于测试阶段，Red Hat 公司正努力将其集成到 OpenShift。我写这篇文章时已经测试过 Buildah，它缺少一些文档，但基本可以稳定运行。尽管在错误处理方面仍有待提高，但它确实是一款值得你关注的容器工具。
### 替换其它 Docker 命令行
Walsh 在其演讲中还简单介绍了 Red hat 公司 正在开发的另一个暂时叫做 [libpod](https://jpetazzo.github.io/2015/09/03/do-not-use-docker-in-docker-for-ci/) 的项目。项目名称来源于 Kubernetes 中的 “pod”， 在 Kubernetes 中 “pod” 用于分组主机内的容器，分享名字空间等。
Libpod 提供 `kpod` 命令，用于直接检查和操作容器存储。Walsh 分析了该命令发挥作用的场景，例如 `dockerd` 停止响应或 Kubernetes 集群崩溃。基本上，`kpod` 独立地再次实现了 `docker` 命令行工具。`kpod ps` 返回运行中的容器列表，`kpod images` 返回镜像列表。事实上，[命令转换速查手册](https://github.com/projectatomic/libpod/blob/master/transfer.md#development-transfer) 中给出了每一条 Docker 命令对应的 `kpod` 命令。
这种模块化实现的一个好处是，当你使用 `kpod run` 运行容器时，容器直接作为当前 shell 而不是 `dockerd` 的子进程启动。理论上，可以直接使用 systemd 启动容器，这样可以消除 `dockerd` 引入的冗余。这让[由套接字激活的容器](http://0pointer.de/blog/projects/socket-activated-containers.html)成为可能，但暂时基于 Docker 实现该特性[并不容易](https://legacy-developer.atlassian.com/blog/2015/03/docker-systemd-socket-activation/)，[即使借助 Kubernetes](https://github.com/kubernetes/kubernetes/issues/484) 也是如此。但我在测试过程中发现，使用 `kpod` 启动的容器有一些基础功能性缺失，具体而言是网络功能（!），相关实现在[活跃开发](https://github.com/projectatomic/libpod/issues/129)过程中。
我们最后提到的命令是 `push`。虽然上述命令已经足以满足本地使用容器的需求，但没有提到远程仓库，借助远程仓库开发者可以活跃地进行应用打包协作。仓库也是持续部署框架的核心组件。[skopeo](https://github.com/projectatomic/skopeo) 项目用于填补这个空白，它是另一个 Atomic 成员项目，按其 `README` 文件描述，“包含容器镜像及镜像库的多种操作”。该项目的设计初衷是，在不用类似 `docker pull` 那样实际去下载可能体积庞大的镜像的前提下，检查容器镜像的内容。Docker [拒绝加入](https://github.com/moby/moby/pull/14258) 检查功能，建议通过一个额外的工具实现该功能，这促成了 Skopeo 项目。除了 `pull`、`push`，Skopeo 现在还可以完成很多其它操作，例如在，不产生本地副本的情况下将镜像在不同的仓库中复制和转换。由于部分功能比较基础，可供其它项目使用，目前很大一部分 Skopeo 代码位于一个叫做 [containers/image](https://github.com/containers/image) 的基础库。[Pivotal](https://pivotal.io/)、 Google 的 [container-diff](https://github.com/GoogleCloudPlatform/container-diff) 、`kpod push` 及 `buildah push` 都使用了该库。
`kpod` 与 Kubernetes 并没有紧密的联系，故未来可能会更换名称（事实上，在本文刊发过程中，已经更名为 [`podman`](https://github.com/projectatomic/libpod/blob/master/docs/podman.1.md)），毕竟 Red Hat 法务部门还没有明确其名称。该团队希望实现更多 pod 级别的命令，这样可以对多个容器进行操作，有点类似于 [`docker compose`](https://docs.docker.com/compose/overview/#compose-documentation) 实现的功能。但在这方面，[Kompose](http://kompose.io/) 是更好的工具，可以通过 [复合 YAML 文件](https://docs.docker.com/compose/compose-file/) 在 Kubernetes 集群中运行容器。按计划，我们不会实现类似于 [`swarm`] 的 Docker 命令，这部分功能最好由 Kubernetes 本身完成。
目前看来，已经持续数年的 Docker 模块化努力终将硕果累累。但目前 `kpod` 处于快速迭代过程中，不太适合用于生产环境，不过那些工具的与众不同的设计理念让人很感兴趣，而且其中大部分的工具已经可以用于开发环境。目前只能通过编译源码的方式安装 libpod，但最终会提供各个发行版的二进制包。
>
> 本文[最初发表](https://lwn.net/Articles/741841/)于 [Linux Weekly News](http://lwn.net/)。
>
>
>
---
via: <https://anarc.at/blog/2017-12-20-docker-without-docker/>
作者：[Anarcat](https://anarc.at) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Ubuntu 和 Linux Mint 中轻松安装 Android Studio
|
Abhishek Prakash
|
https://itsfoss.com/install-android-studio-ubuntu-linux/
|
Android Studio 可以通过源代码安装，但在这篇文章中，我们将看到如何在 Ubuntu 18.04、16.04 和相应的 Linux Mint 变体中安装 Android Studio。
|
/data/attachment/album/201805/10/224829sscqqgz4q4m2scf2.jpg.thumb.jpg
|
/data/attachment/album/201805/10/224829sscqqgz4q4m2scf2.jpg
| true | false | true |
geekpi
| false |
[
"Android",
"Eclipse"
] |
分享
|
{
"viewnum": 10835,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Android Studio 可以通过源代码安装，但在这篇文章中，我们将看到如何在 Ubuntu 18.04、16.04 和相应的 Linux Mint 变体中安装 Android Studio。
| 2018-05-10T22:48:27 | 2018-05-10T22:48:27 | 9,627 |
/article-9627-1.html
|
[Android Studio](http://developer.android.com/sdk/installing/studio.html) 是谷歌自己的 Android 开发 IDE，是带 ADT 插件的 Eclipse 的不错替代品。Android Studio 可以通过源代码安装，但在这篇文章中，我们将看到**如何在 Ubuntu 18.04、16.04 和相应的 Linux Mint 变体**中安装 Android Studio。
在继续安装 Android Studio 之前，请确保你已经[在 Ubuntu 中安装了 Java](https://itsfoss.com/install-java-ubuntu-1404/)。
### 使用 Snap 在 Ubuntu 和其他发行版中安装 Android Studio
自从 Ubuntu 开始专注于 Snap 软件包以来，越来越多的软件开始提供易于安装的 Snap 软件包。Android Studio 就是其中之一。Ubuntu 用户可以直接在软件中心找到 Android Studio 程序并从那里安装。
如果你在软件中心安装 Android Studio 时看到错误，则可以使用 [Snap 命令](https://itsfoss.com/install-snap-linux/) 安装 Android Studio。
```
sudo snap install android-studio --classic
```
非常简单！
### 另一种方式 1：在 Ubuntu 中使用 umake 安装 Android Studio
你也可以使用 Ubuntu Developer Tools Center，现在称为 [Ubuntu Make](https://wiki.ubuntu.com/ubuntu-make)，轻松安装 Android Studio。Ubuntu Make 提供了一个命令行工具来安装各种开发工具和 IDE 等。Ubuntu Make 在 Ubuntu 仓库中就有。
要安装 Ubuntu Make，请在终端中使用以下命令：
```
sudo apt-get install ubuntu-make
```
安装 Ubuntu Make 后，请使用以下命令在 Ubuntu 中安装 Android Studio：
```
umake android
```
在安装过程中它会给你的几个选项。我认为你可以处理。如果你决定卸载 Android Studio，则可以按照以下方式使用相同的 umake 工具：
```
umake android --remove
```
### 另一种方式 2：通过非官方的 PPA 在 Ubuntu 和 Linux Mint 中安装 Android Studio
感谢 [Paolo Ratolo](https://plus.google.com/+PaoloRotolo)，我们有一个 PPA，可用于 Ubuntu 16.04、14.04、Linux Mint 和其他基于 Ubuntu 的发行版中轻松安装 Android Studio。请注意，它将下载大约 650MB 的数据。请注意你的互联网连接以及数据费用（如果有的话）。
打开一个终端并使用以下命令：
```
sudo apt-add-repository ppa:paolorotolo/android-studio
sudo apt-get update
sudo apt-get install android-studio
```
这不容易吗？虽然从源代码安装程序很有趣，但拥有这样的 PPA 总是不错的。我们看到了如何安装 Android Studio，现在来看看如何卸载它。
### 卸载 Android Studio：
如果你还没有安装 PPA Purge：
```
sudo apt-get install ppa-purge
```
现在使用 PPA Purge 来清除已安装的 PPA：
```
sudo apt-get remove android-studio
sudo ppa-purge ppa:paolorotolo/android-studio
```
就是这些了。我希望这能够帮助你**在 Ubuntu 和 Linux Mint 上安装 Android Studio**。在运行 Android Studio 之前，请确保[在 Ubuntu 中安装了Java](https://itsfoss.com/install-java-ubuntu-1404/ "How To Install Java On Ubuntu 14.04")。在类似的文章中，我建议你阅读[如何安装和配置 Ubuntu SDK](https://itsfoss.com/install-configure-ubuntu-sdk/) 和[如何在 Ubuntu 中轻松安装 Microsoft Visual Studio](https://itsfoss.com/install-visual-studio-code-ubuntu/)。
欢迎提出任何问题或建议。再见 ：）
---
via: <https://itsfoss.com/install-android-studio-ubuntu-linux/>
作者：[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/) 荣誉推出
|
||
系统调用，让世界转起来！
|
Gustavo Duarte
|
https://manybutfinite.com/post/system-calls/
|
我其实不想将它分解开给你看，用户应用程序其实就是一个可怜的瓮中大脑。
|
/data/attachment/album/201805/11/102324n76s77z4tsc737lm.jpg.thumb.jpg
|
/data/attachment/album/201805/11/102324n76s77z4tsc737lm.jpg
| true | false | true |
qhwdw
| false |
[
"系统调用"
] |
技术
|
{
"viewnum": 8143,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我其实不想将它分解开给你看，用户应用程序其实就是一个可怜的瓮中大脑。
| 2018-05-11T00:23:00 | 2018-05-11T00:23:00 | 9,628 |
/article-9628-1.html
|
我其实不想将它分解开给你看，用户应用程序其实就是一个可怜的<ruby> 瓮中大脑 <rt> brain in a vat </rt></ruby>：
它与外部世界的*每个*交流都要在内核的帮助下通过**系统调用**才能完成。一个应用程序要想保存一个文件、写到终端、或者打开一个 TCP 连接，内核都要参与。应用程序是被内核高度怀疑的：认为它到处充斥着 bug，甚至是个充满邪恶想法的脑子。
这些系统调用是从一个应用程序到内核的函数调用。出于安全考虑，它们使用了特定的机制，实际上你只是调用了内核的 API。“<ruby> 系统调用 <rt> system call </rt></ruby>”这个术语指的是调用由内核提供的特定功能（比如，系统调用 `open()`）或者是调用途径。你也可以简称为：**syscall**。
这篇文章讲解系统调用，系统调用与调用一个库有何区别，以及在操作系统/应用程序接口上的刺探工具。如果彻底了解了应用程序借助操作系统发生的哪些事情，那么就可以将一个不可能解决的问题转变成一个快速而有趣的难题。
那么，下图是一个运行着的应用程序，一个用户进程：
它有一个私有的 [虚拟地址空间](https://manybutfinite.com/post/anatomy-of-a-program-in-memory)—— 它自己的内存沙箱。整个系统都在它的地址空间中（即上面比喻的那个“瓮”），程序的二进制文件加上它所使用的库全部都 [被映射到内存中](https://manybutfinite.com/post/page-cache-the-affair-between-memory-and-files/)。内核自身也映射为地址空间的一部分。
下面是我们程序 `pid` 的代码，它通过 [getpid(2)](http://linux.die.net/man/2/getpid) 直接获取了其进程 id：
```
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main()
{
pid_t p = getpid();
printf("%d\n", p);
}
```
*pid.c [download](https://manybutfinite.com/code/x86-os/pid.c)*
在 Linux 中，一个进程并不是一出生就知道它的 PID。要想知道它的 PID，它必须去询问内核，因此，这个询问请求也是一个系统调用：
它的第一步是开始于调用 C 库的 [getpid()](https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/getpid.c;h=937b1d4e113b1cff4a5c698f83d662e130d596af;hb=4c6da7da9fb1f0f94e668e6d2966a4f50a7f0d85#l49)，它是系统调用的一个*封装*。当你调用一些函数时，比如，`open(2)`、`read(2)` 之类，你是在调用这些封装。其实，对于大多数编程语言在这一块的原生方法，最终都是在 libc 中完成的。
封装为这些基本的操作系统 API 提供了方便，这样可以保持内核的简洁。*所有的内核代码*运行在特权模式下，有 bug 的内核代码行将会产生致命的后果。能在用户模式下做的任何事情都应该在用户模式中完成。由库来提供友好的方法和想要的参数处理，像 `printf(3)` 这样。
我们拿一个 web API 进行比较，内核的封装方式可以类比为构建一个尽可能简单的 HTTP 接口去提供服务，然后提供特定语言的库及辅助方法。或者也可能有一些缓存，这就是 libc 的 `getpid()` 所做的：首次调用时，它真实地去执行了一个系统调用，然后，它缓存了 PID，这样就可以避免后续调用时的系统调用开销。
一旦封装完成，它做的第一件事就是进入了内核<ruby> <del> 超空间 </del> <rt> hyperspace </rt></ruby>。这种转换机制因处理器架构设计不同而不同。在 Intel 处理器中，参数和 [系统调用号](https://github.com/torvalds/linux/blob/v3.17/arch/x86/syscalls/syscall_64.tbl#L48) 是 [加载到寄存器中的](https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/x86_64/sysdep.h;h=4a619dafebd180426bf32ab6b6cb0e5e560b718a;hb=4c6da7da9fb1f0f94e668e6d2966a4f50a7f0d85#l139)，然后，运行一个 [指令](https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/x86_64/sysdep.h;h=4a619dafebd180426bf32ab6b6cb0e5e560b718a;hb=4c6da7da9fb1f0f94e668e6d2966a4f50a7f0d85#l179) 将 CPU 置于 [特权模式](https://manybutfinite.com/post/cpu-rings-privilege-and-protection) 中，并立即将控制权转移到内核中的全局系统调用 [入口](https://github.com/torvalds/linux/blob/v3.17/arch/x86/kernel/entry_64.S#L354-L386)。如果你对这些细节感兴趣，David Drysdale 在 LWN 上有两篇非常好的文章（[其一](http://lwn.net/Articles/604287/)，[其二](http://lwn.net/Articles/604515/)）。
内核然后使用这个系统调用号作为进入 [`sys_call_table`](https://github.com/torvalds/linux/blob/v3.17/arch/x86/kernel/syscall_64.c#L25) 的一个 [索引](https://github.com/torvalds/linux/blob/v3.17/arch/x86/kernel/entry_64.S#L422)，它是一个函数指针到每个系统调用实现的数组。在这里，调用了 [`sys_getpid`](https://github.com/torvalds/linux/blob/v3.17/kernel/sys.c#L800-L809)：
在 Linux 中，系统调用大多数都实现为架构无关的 C 函数，有时候这样做 [很琐碎](https://github.com/torvalds/linux/blob/v3.17/kernel/sys.c#L800-L859)，但是通过内核优秀的设计，系统调用机制被严格隔离。它们是工作在一般数据结构中的普通代码。嗯，除了*完全偏执*的参数校验以外。
一旦它们的工作完成，它们就会正常*返回*，然后，架构特定的代码会接手转回到用户模式，封装将在那里继续做一些后续处理工作。在我们的例子中，[getpid(2)](http://linux.die.net/man/2/getpid) 现在缓存了由内核返回的 PID。如果内核返回了一个错误，另外的封装可以去设置全局 `errno` 变量。这些细节可以让你知道 GNU 是怎么处理的。
如果你想要原生的调用，glibc 提供了 [syscall(2)](http://linux.die.net/man/2/syscall) 函数，它可以不通过封装来产生一个系统调用。你也可以通过它来做一个你自己的封装。这对一个 C 库来说，既不神奇，也不特殊。
这种系统调用的设计影响是很深远的。我们从一个非常有用的 [strace(1)](http://linux.die.net/man/1/strace) 开始，这个工具可以用来监视 Linux 进程的系统调用（在 Mac 上，参见 [dtruss(1m)](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/dtruss.1m.html) 和神奇的 [dtrace](http://dtrace.org/blogs/brendan/2011/10/10/top-10-dtrace-scripts-for-mac-os-x/)；在 Windows 中，参见 [sysinternals](http://technet.microsoft.com/en-us/sysinternals/bb842062.aspx)）。这是对 `pid` 程序的跟踪：
```
~/code/x86-os$ strace ./pid
execve("./pid", ["./pid"], [/* 20 vars */]) = 0
brk(0) = 0x9aa0000
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7767000
access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat64(3, {st_mode=S_IFREG|0644, st_size=18056, ...}) = 0
mmap2(NULL, 18056, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7762000
close(3) = 0
[...snip...]
getpid() = 14678
fstat64(1, {st_mode=S_IFCHR|0600, st_rdev=makedev(136, 1), ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7766000
write(1, "14678\n", 614678
) = 6
exit_group(6) = ?
```
输出的每一行都显示了一个系统调用、它的参数，以及返回值。如果你在一个循环中将 `getpid(2)` 运行 1000 次，你就会发现始终只有一个 `getpid()` 系统调用，因为，它的 PID 已经被缓存了。我们也可以看到在格式化输出字符串之后，`printf(3)` 调用了 `write(2)`。
`strace` 可以开始一个新进程，也可以附加到一个已经运行的进程上。你可以通过不同程序的系统调用学到很多的东西。例如，`sshd` 守护进程一天都在干什么？
```
~/code/x86-os$ ps ax | grep sshd
12218 ? Ss 0:00 /usr/sbin/sshd -D
~/code/x86-os$ sudo strace -p 12218
Process 12218 attached - interrupt to quit
select(7, [3 4], NULL, NULL, NULL
[
... nothing happens ...
No fun, it's just waiting for a connection using select(2)
If we wait long enough, we might see new keys being generated and so on, but
let's attach again, tell strace to follow forks (-f), and connect via SSH
]
~/code/x86-os$ sudo strace -p 12218 -f
[lots of calls happen during an SSH login, only a few shown]
[pid 14692] read(3, "-----BEGIN RSA PRIVATE KEY-----\n"..., 1024) = 1024
[pid 14692] open("/usr/share/ssh/blacklist.RSA-2048", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)
[pid 14692] open("/etc/ssh/blacklist.RSA-2048", O_RDONLY|O_LARGEFILE) = -1 ENOENT (No such file or directory)
[pid 14692] open("/etc/ssh/ssh_host_dsa_key", O_RDONLY|O_LARGEFILE) = 3
[pid 14692] open("/etc/protocols", O_RDONLY|O_CLOEXEC) = 4
[pid 14692] read(4, "# Internet (IP) protocols\n#\n# Up"..., 4096) = 2933
[pid 14692] open("/etc/hosts.allow", O_RDONLY) = 4
[pid 14692] open("/lib/i386-linux-gnu/libnss_dns.so.2", O_RDONLY|O_CLOEXEC) = 4
[pid 14692] stat64("/etc/pam.d", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
[pid 14692] open("/etc/pam.d/common-password", O_RDONLY|O_LARGEFILE) = 8
[pid 14692] open("/etc/pam.d/other", O_RDONLY|O_LARGEFILE) = 4
```
看懂 SSH 的调用是块难啃的骨头，但是，如果搞懂它你就学会了跟踪。能够看到应用程序打开的是哪个文件是有用的（“这个配置是从哪里来的？”）。如果你有一个出现错误的进程，你可以 `strace` 它，然后去看它通过系统调用做了什么？当一些应用程序意外退出而没有提供适当的错误信息时，你可以去检查它是否有系统调用失败。你也可以使用过滤器，查看每个调用的次数，等等：
```
~/code/x86-os$ strace -T -e trace=recv curl -silent www.google.com. > /dev/null
recv(3, "HTTP/1.1 200 OK\r\nDate: Wed, 05 N"..., 16384, 0) = 4164 <0.000007>
recv(3, "fl a{color:#36c}a:visited{color:"..., 16384, 0) = 2776 <0.000005>
recv(3, "adient(top,#4d90fe,#4787ed);filt"..., 16384, 0) = 4164 <0.000007>
recv(3, "gbar.up.spd(b,d,1,!0);break;case"..., 16384, 0) = 2776 <0.000006>
recv(3, "$),a.i.G(!0)),window.gbar.up.sl("..., 16384, 0) = 1388 <0.000004>
recv(3, "margin:0;padding:5px 8px 0 6px;v"..., 16384, 0) = 1388 <0.000007>
recv(3, "){window.setTimeout(function(){v"..., 16384, 0) = 1484 <0.000006>
```
我鼓励你在你的操作系统中的试验这些工具。把它们用好会让你觉得自己有超能力。
但是，足够有用的东西，往往要让我们深入到它的设计中。我们可以看到那些用户空间中的应用程序是被严格限制在它自己的虚拟地址空间里，运行在 Ring 3（非特权模式）中。一般来说，只涉及到计算和内存访问的任务是不需要请求系统调用的。例如，像 [strlen(3)](http://linux.die.net/man/3/strlen) 和 [memcpy(3)](http://linux.die.net/man/3/memcpy) 这样的 C 库函数并不需要内核去做什么。这些都是在应用程序内部发生的事。
C 库函数的 man 页面所在的节（即圆括号里的 `2` 和 `3`）也提供了线索。节 2 是用于系统调用封装，而节 3 包含了其它 C 库函数。但是，正如我们在 `printf(3)` 中所看到的，库函数最终可以产生一个或者多个系统调用。
如果你对此感到好奇，这里是 [Linux](https://github.com/torvalds/linux/blob/v3.17/arch/x86/syscalls/syscall_64.tbl) （也有 [Filippo 的列表](https://filippo.io/linux-syscall-table/)）和 [Windows](http://j00ru.vexillium.org/ntapi/) 的全部系统调用列表。它们各自有大约 310 和 460 个系统调用。看这些系统调用是非常有趣的，因为，它们代表了*软件*在现代的计算机上能够做什么。另外，你还可能在这里找到与进程间通讯和性能相关的“宝藏”。这是一个“不懂 Unix 的人注定最终还要重新发明一个蹩脚的 Unix ” 的地方。（LCTT 译注：原文 “Those who do not understand Unix are condemned to reinvent it，poorly。” 这句话是 [Henry Spencer](https://en.wikipedia.org/wiki/Henry_Spencer) 的名言，反映了 Unix 的设计哲学，它的一些理念和文化是一种技术发展的必须结果，看似糟糕却无法超越。）
与 CPU 周期相比，许多系统调用花[很长的时间](https://manybutfinite.com/post/what-your-computer-does-while-you-wait/)去执行任务，例如，从一个硬盘驱动器中读取内容。在这种情况下，调用进程在底层的工作完成之前一直*处于休眠状态*。因为，CPU 运行的非常快，一般的程序都因为 **I/O 的限制**在它的生命周期的大部分时间处于休眠状态，等待系统调用返回。相反，如果你跟踪一个计算密集型任务，你经常会看到没有任何的系统调用参与其中。在这种情况下，[top(1)](http://linux.die.net/man/1/top) 将显示大量的 CPU 使用。
在一个系统调用中的开销可能会是一个问题。例如，固态硬盘比普通硬盘要快很多，但是，操作系统的开销可能比 I/O 操作本身的开销 [更加昂贵](http://danluu.com/clwb-pcommit/)。执行大量读写操作的程序可能就是操作系统开销的瓶颈所在。[向量化 I/O](http://en.wikipedia.org/wiki/Vectored_I/O) 对此有一些帮助。因此要做 [文件的内存映射](https://manybutfinite.com/post/page-cache-the-affair-between-memory-and-files/)，它允许一个程序仅访问内存就可以读或写磁盘文件。类似的映射也存在于像视频卡这样的地方。最终，云计算的经济性可能导致内核消除或最小化用户模式/内核模式的切换。
最终，系统调用还有益于系统安全。一是，无论如何来历不明的一个二进制程序，你都可以通过观察它的系统调用来检查它的行为。这种方式可能用于去检测恶意程序。例如，我们可以记录一个未知程序的系统调用的策略，并对它的异常行为进行报警，或者对程序调用指定一个白名单，这样就可以让漏洞利用变得更加困难。在这个领域，我们有大量的研究，和许多工具，但是没有“杀手级”的解决方案。
这就是系统调用。很抱歉这篇文章有点长，我希望它对你有用。接下来的时间，我将写更多（短的）文章，也可以在 [RSS](http://feeds.feedburner.com/GustavoDuarte) 和 [Twitter](http://twitter.com/food4hackers) 关注我。这篇文章献给 glorious Clube Atlético Mineiro。
---
via:<https://manybutfinite.com/post/system-calls/>
作者：[Gustavo Duarte](http://duartes.org/gustavo/blog/about/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 Vim 编辑器编辑多个文件
|
Sk
|
https://www.ostechnix.com/how-to-edit-multiple-files-using-vim-editor/
|
在本教程中，我们将学习使用 vim 编辑器同时编辑多个文件。相信我，很有意思哒。
|
/data/attachment/album/201805/11/092242ho3kzb83ykq3oeo3.png.thumb.jpg
|
/data/attachment/album/201805/11/092242ho3kzb83ykq3oeo3.png
| true | false | true |
jessie-pang
| false |
[
"Vim",
"Vi"
] |
技术
|
{
"viewnum": 14743,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本教程中，我们将学习使用 vim 编辑器同时编辑多个文件。相信我，很有意思哒。
| 2018-05-11T09:22:40 | 2018-05-11T09:22:40 | 9,629 |
/article-9629-1.html
|
有时候，您可能需要修改多个文件，或要将一个文件的内容复制到另一个文件中。在图形用户界面中，您可以在任何图形文本编辑器（如 gedit）中打开文件，并使用 `CTRL + C` 和 `CTRL + V` 复制和粘贴内容。在命令行模式下，您不能使用这种编辑器。不过别担心，只要有 `vim` 编辑器就有办法。在本教程中，我们将学习使用 `vim` 编辑器同时编辑多个文件。相信我，很有意思哒。
### 安装 Vim
Vim 编辑器可在大多数 Linux 发行版的官方软件仓库中找到，所以您可以用默认的软件包管理器来安装它。例如，在 Arch Linux 及其变体上，您可以使用如下命令：
```
$ sudo pacman -S vim
```
在 Debian 和 Ubuntu 上：
```
$ sudo apt-get install vim
```
在 RHEL 和 CentOS 上：
```
$ sudo yum install vim
```
在 Fedora 上：
```
$ sudo dnf install vim
```
在 openSUSE 上：
```
$ sudo zypper install vim
```
### 使用 Linux 的 Vim 编辑器同时编辑多个文件
现在让我们谈谈正事，我们可以用两种方法做到这一点。
#### 方法一
有两个文件，即 `file1.txt` 和 `file2.txt`，带有一堆随机单词：
```
$ cat file1.txt
ostechnix
open source
technology
linux
unix
$ cat file2.txt
line1
line2
line3
line4
line5
```
现在，让我们同时编辑这两个文件。请运行：
```
$ vim file1.txt file2.txt
```
Vim 将按顺序显示文件的内容。首先显示第一个文件的内容，然后显示第二个文件，依此类推。
##### 在文件中切换
要移至下一个文件，请键入：
```
:n
```
要返回到前一个文件，请键入：
```
:N
```
如果有任何未保存的更改，Vim 将不允许您移动到下一个文件。要保存当前文件中的更改，请键入：
```
ZZ
```
请注意，是两个大写字母 `ZZ`（`SHIFT + zz`）。
要放弃更改并移至上一个文件，请键入：
```
:N!
```
要查看当前正在编辑的文件，请键入：
```
:buffers
```
您将在底部看到加载文件的列表。
要切换到下一个文件，请输入 `:buffer`，后跟缓冲区编号。例如，要切换到第一个文件，请键入：
```
:buffer 1
```
##### 打开其他文件进行编辑
目前我们正在编辑两个文件，即 `file1.txt` 和 `file2.txt`。我想打开另一个名为 `file3.txt` 的文件进行编辑。
您会怎么做？这很容易。只需键入 `:e`，然后输入如下所示的文件名即可：
```
:e file3.txt
```
现在你可以编辑 `file3.txt` 了。
要查看当前正在编辑的文件数量，请键入：
```
:buffers
```
请注意，对于使用 `:e` 打开的文件，您无法使用 `:n` 或 `:N` 进行切换。要切换到另一个文件，请输入 `:buffer`，然后输入文件缓冲区编号。
##### 将一个文件的内容复制到另一个文件中
您已经知道了如何同时打开和编辑多个文件。有时，您可能想要将一个文件的内容复制到另一个文件中。这也是可以做到的。切换到您选择的文件，例如，假设您想将 `file1.txt` 的内容复制到 `file2.txt` 中：
首先，请切换到 `file1.txt`：
```
:buffer 1
```
将光标移动至在想要复制的行的前面，并键入`yy` 以抽出（复制）该行。然后，移至 `file2.txt`：
```
:buffer 2
```
将光标移至要从 `file1.txt` 粘贴复制行的位置，然后键入 `p`。例如，您想要将复制的行粘贴到 `line2` 和 `line3` 之间，请将鼠标光标置于行前并键入 `p`。
输出示例：
```
line1
line2
ostechnix
line3
line4
line5
```
要保存当前文件中所做的更改，请键入：
```
ZZ
```
再次提醒，是两个大写字母 ZZ（`SHIFT + z`）。
保存所有文件的更改并退出 vim 编辑器，键入：
```
:wq
```
同样，您可以将任何文件的任何行复制到其他文件中。
##### 将整个文件内容复制到另一个文件中
我们知道如何复制一行，那么整个文件的内容呢？也是可以的。比如说，您要将 `file1.txt` 的全部内容复制到 `file2.txt` 中。
先打开 `file2.txt`：
```
$ vim file2.txt
```
如果文件已经加载，您可以通过输入以下命令切换到 `file2.txt`：
```
:buffer 2
```
将光标移动到您想要粘贴 `file1.txt` 的内容的位置。我想在 `file2.txt` 的第 5 行之后粘贴 `file1.txt` 的内容，所以我将光标移动到第 5 行。然后，键入以下命令并按回车键：
```
:r file1.txt
```
这里，`r` 代表 “read”。
现在您会看到 `file1.txt` 的内容被粘贴在 `file2.txt` 的第 5 行之后。
```
line1
line2
line3
line4
line5
ostechnix
open source
technology
linux
unix
```
要保存当前文件中的更改，请键入：
```
ZZ
```
要保存所有文件的所有更改并退出 vim 编辑器，请输入：
```
:wq
```
#### 方法二
另一种同时打开多个文件的方法是使用 `-o` 或 `-O` 标志。
要在水平窗口中打开多个文件，请运行：
```
$ vim -o file1.txt file2.txt
```
要在窗口之间切换，请按 `CTRL-w w`（即按 `CTRL + w` 并再次按 `w`）。或者，您可以使用以下快捷方式在窗口之间移动：
* `CTRL-w k` – 上面的窗口
* `CTRL-w j` – 下面的窗口
要在垂直窗口中打开多个文件，请运行：
```
$ vim -O file1.txt file2.txt file3.txt
```
要在窗口之间切换，请按 `CTRL-w w`（即按 `CTRL + w` 并再次按 `w`）。或者，使用以下快捷方式在窗口之间移动：
* `CTRL-w l` – 左面的窗口
* `CTRL-w h` – 右面的窗口
其他的一切都与方法一的描述相同。
例如，要列出当前加载的文件，请运行：
```
:buffers
```
在文件之间切换：
```
:buffer 1
```
打开其他文件，请键入：
```
:e file3.txt
```
将文件的全部内容复制到另一个文件中：
```
:r file1.txt
```
方法二的唯一区别是，只要您使用 `ZZ` 保存对当前文件的更改，文件将自动关闭。然后，您需要依次键入 `:wq` 来关闭文件。但是，如果您按照方法一进行操作，输入 `:wq` 时，所有更改将保存在所有文件中，并且所有文件将立即关闭。
有关更多详细信息，请参阅手册页。
```
$ man vim
```
### 建议阅读
您现在掌握了如何在 Linux 中使用 vim 编辑器编辑多个文件。正如您所见，编辑多个文件并不难。Vim 编辑器还有更强大的功能。我们接下来会提供更多关于 Vim 编辑器的内容。
再见！
---
via: <https://www.ostechnix.com/how-to-edit-multiple-files-using-vim-editor/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[jessie-pang](https://github.com/jessie-pang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
关于 BPF 和 eBPF 的笔记
|
Julia Evans
|
https://jvns.ca/blog/2017/06/28/notes-on-bpf---ebpf/
|
在 BPF 出现之前，如果你想去做包过滤，你必须拷贝所有的包到用户空间，然后才能去过滤它们
|
/data/attachment/album/201805/12/083555mztunjjnnrbjjlw4.jpg.thumb.jpg
|
/data/attachment/album/201805/12/083555mztunjjnnrbjjlw4.jpg
| true | false | true |
qhwdw
| false |
[
"eBPF",
"过滤"
] |
技术
|
{
"viewnum": 21600,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 BPF 出现之前，如果你想去做包过滤，你必须拷贝所有的包到用户空间，然后才能去过滤它们
| 2018-05-12T08:36:09 | 2018-05-12T08:36:09 | 9,630 |
/article-9630-1.html
|
今天，我喜欢的 meetup 网站上有一篇我超爱的文章！[Suchakra Sharma](http://suchakra.in/)（[@tuxology](https://twitter.com/tuxology) 在 twitter/github）的一篇非常棒的关于传统 BPF 和在 Linux 中最新加入的 eBPF 的讨论文章，正是它促使我想去写一个 eBPF 的程序！
这篇文章就是 —— [BSD 包过滤器：一个新的用户级包捕获架构](http://www.vodun.org/papers/net-papers/van_jacobson_the_bpf_packet_filter.pdf)
我想在讨论的基础上去写一些笔记，因为，我觉得它超级棒！
开始前，这里有个 [幻灯片](https://speakerdeck.com/tuxology/the-bsd-packet-filter) 和一个 [pdf](http://step.polymtl.ca/%7Esuchakra/PWL-Jun28-MTL.pdf)。这个 pdf 非常好，结束的位置有一些链接，在 PDF 中你可以直接点击这个链接。
### 什么是 BPF？
在 BPF 出现之前，如果你想去做包过滤，你必须拷贝所有的包到用户空间，然后才能去过滤它们（使用 “tap”）。
这样做存在两个问题：
1. 如果你在用户空间中过滤，意味着你将拷贝所有的包到用户空间，拷贝数据的代价是很昂贵的。
2. 使用的过滤算法很低效。
问题 #1 的解决方法似乎很明显，就是将过滤逻辑移到内核中。（虽然具体实现的细节并没有明确，我们将在稍后讨论）
但是，为什么过滤算法会很低效？
如果你运行 `tcpdump host foo`，它实际上运行了一个相当复杂的查询，用下图的这个树来描述它：
评估这个树有点复杂。因此，可以用一种更简单的方式来表示这个树，像这样：
然后，如果你设置 `ether.type = IP` 和 `ip.src = foo`，你必然明白匹配的包是 `host foo`，你也不用去检查任何其它的东西了。因此，这个数据结构（它们称为“控制流图” ，或者 “CFG”）是表示你真实希望去执行匹配检查的程序的最佳方法，而不是用前面的树。
### 为什么 BPF 要工作在内核中
这里的关键点是，包仅仅是个字节的数组。BPF 程序是运行在这些字节的数组之上。它们不允许有循环（loop），但是，它们 *可以* 有聪明的办法知道 IP 包头（IPv6 和 IPv4 长度是不同的）以及基于它们的长度来找到 TCP 端口：
```
x = ip_header_length
port = *(packet_start + x + port_offset)
```
（看起来不一样，其实它们基本上都相同）。在这个论文/幻灯片上有一个非常详细的虚拟机的描述，因此，我不打算解释它。
当你运行 `tcpdump host foo` 后，这时发生了什么？就我的理解，应该是如下的过程。
1. 转换 `host foo` 为一个高效的 DAG 规则
2. 转换那个 DAG 规则为 BPF 虚拟机的一个 BPF 程序（BPF 字节码）
3. 发送 BPF 字节码到 Linux 内核，由 Linux 内核验证它
4. 编译这个 BPF 字节码程序为一个<ruby> 原生 <rt> native </rt></ruby>代码。例如，这是个[ARM 上的 JIT 代码](https://github.com/torvalds/linux/blob/v4.10/arch/arm/net/bpf_jit_32.c#L512) 以及 [x86](https://github.com/torvalds/linux/blob/v3.18/arch/x86/net/bpf_jit_comp.c#L189) 的机器码
5. 当包进入时，Linux 运行原生代码去决定是否过滤这个包。对于每个需要去处理的包，它通常仅需运行 100 - 200 个 CPU 指令就可以完成，这个速度是非常快的！
### 现状：eBPF
毕竟 BPF 出现已经有很长的时间了！现在，我们可以拥有一个更加令人激动的东西，它就是 eBPF。我以前听说过 eBPF，但是，我觉得像这样把这些片断拼在一起更好（我在 4 月份的 netdev 上我写了这篇 [XDP & eBPF 的文章](https://jvns.ca/blog/2017/04/07/xdp-bpf-tutorial/)回复）
关于 eBPF 的一些事实是：
* eBPF 程序有它们自己的字节码语言，并且从那个字节码语言编译成内核原生代码，就像 BPF 程序一样
* eBPF 运行在内核中
* eBPF 程序不能随心所欲的访问内核内存。而是通过内核提供的函数去取得一些受严格限制的所需要的内容的子集
* 它们 *可以* 与用户空间的程序通过 BPF 映射进行通讯
* 这是 Linux 3.18 的 `bpf` 系统调用
### kprobes 和 eBPF
你可以在 Linux 内核中挑选一个函数（任意函数），然后运行一个你写的每次该函数被调用时都运行的程序。这样看起来是不是很神奇。
例如：这里有一个 [名为 disksnoop 的 BPF 程序](https://github.com/iovisor/bcc/blob/0c8c179fc1283600887efa46fe428022efc4151b/examples/tracing/disksnoop.py)，它的功能是当你开始/完成写入一个块到磁盘时，触发它执行跟踪。下图是它的代码片断：
```
BPF_HASH(start, struct request *);
void trace_start(struct pt_regs *ctx, struct request *req) {
// stash start timestamp by request ptr
u64 ts = bpf_ktime_get_ns();
start.update(&req, &ts);
}
...
b.attach_kprobe(event="blk_start_request", fn_name="trace_start")
b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_start")
```
本质上它声明一个 BPF 哈希（它的作用是当请求开始/完成时，这个程序去触发跟踪），一个名为 `trace_start` 的函数将被编译进 BPF 字节码，然后附加 `trace_start` 到内核函数 `blk_start_request` 上。
这里使用的是 `bcc` 框架，它可以让你写 Python 式的程序去生成 BPF 代码。你可以在 <https://github.com/iovisor/bcc> 找到它（那里有非常多的示例程序）。
### uprobes 和 eBPF
因为我知道可以附加 eBPF 程序到内核函数上，但是，我不知道能否将 eBPF 程序附加到用户空间函数上！那会有更多令人激动的事情。这是 [在 Python 中使用一个 eBPF 程序去计数 malloc 调用的示例](https://github.com/iovisor/bcc/blob/00f662dbea87a071714913e5c7382687fef6a508/tests/lua/test_uprobes.lua)。
### 附加 eBPF 程序时应该考虑的事情
* 带 XDP 的网卡（我之前写过关于这方面的文章）
* tc egress/ingress （在网络栈上）
* kprobes（任意内核函数）
* uprobes（很明显，任意用户空间函数？？像带调试符号的任意 C 程序）
* probes 是为 dtrace 构建的名为 “USDT probes” 的探针（像 [这些 mysql 探针](https://dev.mysql.com/doc/refman/5.7/en/dba-dtrace-ref-query.html))。这是一个 [使用 dtrace 探针的示例程序](https://github.com/iovisor/bcc/blob/master/examples/tracing/mysqld_query.py)
* [JVM](http://blogs.microsoft.co.il/sasha/2016/03/31/probing-the-jvm-with-bpfbcc/)
* 跟踪点
* seccomp / landlock 安全相关的事情
* 等等
### 这个讨论超级棒
在幻灯片里有很多非常好的链接，并且在 iovisor 仓库里有个 [LINKS.md](https://github.com/iovisor/bcc/blob/master/LINKS.md)。虽然现在已经很晚了，但是我马上要去写我的第一个 eBPF 程序了！
---
via: <https://jvns.ca/blog/2017/06/28/notes-on-bpf---ebpf/>
作者：[Julia Evans](https://jvns.ca/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
强制关闭你的系统的内核模块
|
Sk
|
https://www.ostechnix.com/kgotobed-a-kernel-module-that-forcibly-shutdown-your-system/
|
一个同学通宵开发了一个名为 “Kgotobed” 的内核模块，它迫使你在特定的时间上床睡觉。也就是说它会强制关闭你的系统。
|
/data/attachment/album/201805/12/084852hiwel0b0jqzkjk9w.png.thumb.jpg
|
/data/attachment/album/201805/12/084852hiwel0b0jqzkjk9w.png
| true | false | true |
geekpi
| false |
[
"关机",
"内核模块"
] |
技术
|
{
"viewnum": 5564,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一个同学通宵开发了一个名为 “Kgotobed” 的内核模块，它迫使你在特定的时间上床睡觉。也就是说它会强制关闭你的系统。
| 2018-05-12T08:48:49 | 2018-05-12T08:48:49 | 9,631 |
/article-9631-1.html
|
我知道熬夜对健康不利。但谁在乎？多年来我一直是一只夜猫子。我通常在 12 点以后睡觉，有时在凌晨 1 点以后睡觉。第二天早上，我至少推迟三次闹钟，醒来后又累又有脾气。每天，我向自己保证早点睡觉，但最终会像平常一样晚睡。而且，这个循环还在继续！如果你和我一样，这有一个好消息。一个同学通宵开发了一个名为 **“Kgotobed”** 的内核模块，它迫使你在特定的时间上床睡觉。也就是说它会强制关闭你的系统。
你可能会问！我为什么要用这个？我有很多其他的选择。我可以设置一个 cron 作业来安排在特定时间关闭系统。我可以设置提醒或闹钟。我可以使用浏览器插件或软件。但是，它们都可以轻易忽略或绕过。Kgotobed 是你不能忽视的东西。**即使您是 root 用户也无法禁用**。是的，它会在指定的时间强制关闭你的系统。没有推迟选项。你不能推迟关机过程，也不能取消它。无论如何，系统都会在指定的时间停止运行。你被警告了！！
### 安装 Kgotobed
确保你已经安装了 `dkms`。它在大多数 Linux 发行版的默认仓库中都有。
例如在 Fedora 上，你可以使用以下命令安装它：
```
$ sudo dnf install kernel-devel-$(uname -r) dkms
```
在 Debian、Ubuntu、linux Mint 上：
```
$ sudo apt install dkms
```
安装完成后，`git clone` Kgotobed 项目。
```
$ git clone https://github.com/nikital/kgotobed.git
```
该命令会在当前工作目录中将所有 Kgotobed 仓库的内容克隆到名为 `kgotobed` 的文件夹中。进入到该目录：
```
$ cd kgotobed/
```
接着，使用命令安装 Kgotobed 驱动：
```
$ sudo make install
```
上面的命令将 `kgotobed.ko` 模块注册到 **DKMS**（这样它会为每个你运行的内核重建）并在 `/usr/local/bin/` 目录下安装 `gotobed`，然后注册、启用并启动 kgotobed 服务。
### 如何运行
默认情况下，Kgotobed 将睡前时间设置为 **1:00 AM**。也就是说，无论你在做什么，你的电脑都会在凌晨 1 点关机。
要查看当前的睡前时间，请运行：
```
$ gotobed
Current bedtime is 2018-04-10 01:00:00
```
要提前睡眠时间，例如 22:00（晚上 10 点），请运行：
```
$ sudo gotobed 22:00
[sudo] password for sk:
Current bedtime is 2018-04-10 00:58:00
Setting bedtime to 2018-04-09 22:00:00
Bedtime will be in 2 hours 16 minutes
```
当你想早点睡觉时，这会很有帮助！
但是，你不能设置更晚的时间也就是凌晨 1 点以后。你无法卸载模块，并且调整系统时钟也无济于事。唯一的出路是重启！
要设置不同的默认时间，您需要自定义 `kgotobed.service`（通过编辑或使用 systemd 工具）。
### 卸载 Kgotobed
对 Kgotobed 不满意？别担心！进入我们先前克隆的 `kgotobed` 文件夹，然后运行以下命令将其卸载。
```
$ sudo make uninstall
```
再一次，我警告你，即使你是 root 用户，也没有办法推迟或取消关机过程。你的系统将在指定的时间强制关闭。这并不适合每个人！当你在做一项重要任务时，它可能会让你疯狂。在这种情况下，请确保你已经不时地保存工作，或使用下面链接中的一些高级工具来帮助你在特定时间自动关闭、重启、暂停和休眠系统。
* [在特定时间自动关闭、重启、暂停和休眠系统](https://www.ostechnix.com/auto-shutdown-reboot-suspend-hibernate-linux-system-specific-time/)
就是这些了。希望你觉得这个指南有帮助。还有更好的东西。敬请关注！
干杯!
### 资源
* [Kgotobed GitHub 仓库](https://github.com/nikital/kgotobed)
---
via: <https://www.ostechnix.com/kgotobed-a-kernel-module-that-forcibly-shutdown-your-system/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[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：全局、局部和非局部变量（带示例）
|
Programiz
|
https://www.programiz.com/python-programming/global-local-nonlocal-variables
|
在 Python 中，在函数之外或在全局范围内声明的变量被称为全局变量。
|
/data/attachment/album/201805/12/104634hn44z9dxolr4idcn.jpg.thumb.jpg
|
/data/attachment/album/201805/12/104634hn44z9dxolr4idcn.jpg
| true | false | true |
Flowsnow
| false |
[
"Python",
"变量"
] |
软件开发
|
{
"viewnum": 7068,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9561,
"displayorder": 0
}
] |
在 Python 中，在函数之外或在全局范围内声明的变量被称为全局变量。
| 2018-05-12T10:47:00 | 2018-05-12T10:47:00 | 9,632 |
/article-9632-1.html
|
### 全局变量
在 Python 中，在函数之外或在全局范围内声明的变量被称为全局变量。 这意味着，全局变量可以在函数内部或外部访问。
我们来看一个关于如何在 Python 中创建一个全局变量的示例。
#### 示例 1：创建全局变量
```
x = "global"
def foo():
print("x inside :", x)
foo()
print("x outside:", x)
```
当我们运行代码时，将会输出：
```
x inside : global
x outside: global
```
在上面的代码中，我们创建了 `x` 作为全局变量，并定义了一个 `foo()` 来打印全局变量 `x`。 最后，我们调用 `foo()` 来打印x的值。
倘若你想改变一个函数内的 `x` 的值该怎么办？
```
x = "global"
def foo():
x = x * 2
print(x)
foo()
```
当我们运行代码时，将会输出：
```
UnboundLocalError: local variable 'x' referenced before assignment
```
输出显示一个错误，因为 Python 将 `x` 视为局部变量，而 `x` 没有在 `foo()` 内部定义。
为了运行正常，我们使用 `global` 关键字，查看 [PythonGlobal 关键字](https://www.programiz.com/python-programming/global-keyword)以便了解更多。
### 局部变量
在函数体内或局部作用域内声明的变量称为局部变量。
#### 示例 2：访问作用域外的局部变量
```
def foo():
y = "local"
foo()
print(y)
```
当我们运行代码时，将会输出：
```
NameError: name 'y' is not defined
```
输出显示了一个错误，因为我们试图在全局范围内访问局部变量 `y`，而局部变量只能在 `foo()` 函数内部或局部作用域内有效。
我们来看一个关于如何在 Python 中创建一个局部变量的例子。
#### 示例 3：创建一个局部变量
通常，我们在函数内声明一个变量来创建一个局部变量。
```
def foo():
y = "local"
print(y)
foo()
```
当我们运行代码时，将会输出：
```
local
```
让我们来看看前面的问题，其中x是一个全局变量，我们想修改 `foo()` 内部的 `x`。
### 全局变量和局部变量
在这里，我们将展示如何在同一份代码中使用全局变量和局部变量。
#### 示例 4：在同一份代码中使用全局变量和局部变量
```
x = "global"
def foo():
global x
y = "local"
x = x * 2
print(x)
print(y)
foo()
```
当我们运行代码时，将会输出（LCTT 译注：原文中输出结果的两个 `global` 有空格，正确的是没有空格）：
```
globalglobal
local
```
在上面的代码中，我们将 `x` 声明为全局变量，将 `y` 声明为 `foo()` 中的局部变量。 然后，我们使用乘法运算符 `*` 来修改全局变量 `x`，并打印 `x` 和 `y`。
在调用 `foo()` 之后，`x` 的值变成 `globalglobal`了（LCTT 译注：原文同样有空格，正确的是没有空格），因为我们使用 `x * 2` 打印两次 `global`。 之后，我们打印局部变量y的值，即 `local` 。
#### 示例 5：具有相同名称的全局变量和局部变量
```
x = 5
def foo():
x = 10
print("local x:", x)
foo()
print("global x:", x)
```
当我们运行代码时，将会输出：
```
local x: 10
global x: 5
```
在上面的代码中，我们对全局变量和局部变量使用了相同的名称 `x`。 当我们打印相同的变量时却得到了不同的结果，因为这两个作用域内都声明了变量，即 `foo()` 内部的局部作用域和 `foo()` 外面的全局作用域。
当我们在 `foo()` 内部打印变量时，它输出 `local x: 10`，这被称为变量的局部作用域。
同样，当我们在 `foo()` 外部打印变量时，它输出 `global x: 5`，这被称为变量的全局作用域。
### 非局部变量
非局部变量用于局部作用域未定义的嵌套函数。 这意味着，变量既不能在局部也不能在全局范围内。
我们来看一个关于如何在 Python 中创建一个非局部变量的例子。（LCTT 译者注：原文为创建全局变量，疑为笔误）
我们使用 `nonlocal` 关键字来创建非局部变量。
#### 示例 6：创建一个非局部变量
```
def outer():
x = "local"
def inner():
nonlocal x
x = "nonlocal"
print("inner:", x)
inner()
print("outer:", x)
outer()
```
当我们运行代码时，将会输出：
```
inner: nonlocal
outer: nonlocal
```
在上面的代码中有一个嵌套函数 `inner()`。 我们使用 `nonlocal` 关键字来创建非局部变量。`inner()` 函数是在另一个函数 `outer()` 的作用域中定义的。
注意：如果我们改变非局部变量的值，那么变化就会出现在局部变量中。
---
via: <https://www.programiz.com/python-programming/global-local-nonlocal-variables>
作者：[programiz](https://www.programiz.com/) 译者：[Flowsnow](https://github.com/Flowsnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
放慢速度如何使我变成更好的领导者
|
Angela Robertson
|
https://opensource.com/open-organization/18/2/open-leadership-patience-listening
|
开放式领导和耐心、倾听一样重要，它们都是关于执行的。
|
/data/attachment/album/201805/12/114919hq2v2508r0588v4l.png.thumb.jpg
|
/data/attachment/album/201805/12/114919hq2v2508r0588v4l.png
| true | false | true |
MjSeven
| false |
[
"领导力"
] |
观点
|
{
"viewnum": 3354,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
开放式领导和耐心、倾听一样重要，它们都是关于执行的。
| 2018-05-12T11:49:15 | 2018-05-12T11:49:15 | 9,633 |
/article-9633-1.html
|
>
> 开放式领导和耐心、倾听一样重要，它们都是关于执行的。
>
>
>
在我职业生涯的早期，我认为我能做的最重要的事情就是行动。如果我的老板说跳，我的回答是“跳多高？”
但是当我成长为一个领导者和管理者时，我意识到了我能提供的最重要的品质是 [耐心](https://opensource.com/open-organization/16/3/my-most-difficult-leadership-lesson) 和倾听。耐心和倾听意味着我关注于真正重要的东西。我很果断，所以我会毫不犹豫地行动。然而我了解到，当我考虑来自多个来源的意见，并就我们应该做什么提供建议，而不仅仅是对眼前的请求做出反应时，我的行动更具影响力。
实行开放式领导需要培养耐心和倾听技能，我需要在[最佳行动计划上进行合作，而不仅仅是最快的计划](https://opensource.com/open-organization/16/3/fastest-result-isnt-always-best-result)。它还为我提供了一些工具，以解释 [为什么我会对某人说“不”](https://opensource.com/open-organization/17/5/saying-no-open-organization) （或者，也许是“不是现在”），这样我就能以透明和自信的方式领导。
如果你正在进行软件开发和实践 scrum 中，那么下面的观点可能会引起你的共鸣：在 sprint 计划和 sprint 演示中，耐心和倾听经理的表现和它的技能一样重要。（LCTT 译注： scrum 是迭代式增量软件开发过程，通常用于敏捷软件开发。 sprint 计划和 sprint 演示是其中的两个术语。）忘掉它们，你会减少你能够产生的影响。
### 专注于耐心
专注和耐心并不总是容易的。通常，我发现自己正坐在会议上，用行动项目填满我的笔记本时，我一般会思考：“我们只要做了某事，另外一件事就会得到改善”。然后我记得事物不是那么线性发展的。
我需要考虑可能影响情况的其他因素。暂停下来从多个人和资源中获取数据可以帮我充实策略，以确保组织长期成功。它还帮助我确定那些短期的里程碑，这些里程碑应该可以让我负责生产的业务完成交付。
这里有一个很好的例子，以前耐心不是我认为应该拥有、以及影响我的表现的东西。当我在北卡罗来纳州工作时，我与一个在亚利桑那州的人共事。我们没有使用视频会议技术，所以当我们交谈时我没有看到她的肢体语言。然而当我负责为我领导的项目交付结果时，她是确保我获得足够支持的两个人之一。
无论出于何种原因，当我与她交谈时，当她要求我做某件事时，我做了。她会为我的绩效评估提供意见，所以我想确保她高兴。那时，我还不够成熟不懂得其实没必要非要讨她开心；我的重点应该放在其他绩效指标上。我本应该花更多的时间倾听并与她合作，而不是在她还在说话的时候拿起第一个“行动项目”并开始工作。
在工作六个月后，她给了我一些负面的反馈。 我很生气，很伤心。 我没有做她所要求的一切吗？ 我工作了很长时间，每周工作近七天，为期六个月。 她怎么敢批评我的表现？
然后，在我经历了愤怒和悲伤之后，我想到了她说的话，她的反馈很重要。
在 sprint 计划和 sprint 演示中，耐心和倾听经理的表现和它的技能一样重要。
她对这个项目感到担忧，她继续让我负责是因为我是项目的负责人。我们解决了问题，并且我学到了关于如何领导的重要课程：领导力并不意味着“现在就完成”。 领导力意味着制定战略，然后制定沟通和实施支持战略的计划。这也意味着犯错和从这些问题中学习。
### 经验教训
事后看来，我意识到我可以提出更多的问题来更好地理解她的反馈意图。如果她的指导不符合我收到的其他意见，我也可能会推迟。通过耐心倾听给我的关于项目的各种信息来源，综合我所学到的知识，并创建一个连贯的行动计划，我会成为一个更好的领导者。我也会有更多的目的来推动我正在做的工作。 我不会对单个数据点做出反应，而是会实施一项战略计划。 这样我也会有一个更好的绩效评估。
我最终对她有一些反馈。 下次我们一起工作时，我不想在六个月后听到反馈意见。 我想早些时候和更频繁地听到反馈意见，以便我能够尽早从错误中学习。 关于这项工作的持续讨论是任何团队都应该发生的事情。
当我成为一名管理者和领导者时，我坚持要求我的团队达到相同的标准：计划，执行计划并反思。 重复。 不要让外力造成的麻烦让你偏离你需要实施的计划。 将工作分成小的增量，以便反思和调整计划。 正如 Daniel Goleman 写道：“把注意力放在需要的地方是领导力的一个主要任务。” 不要害怕面对这个挑战。
---
via: <https://opensource.com/open-organization/18/2/open-leadership-patience-listening>
作者：[Angela Robertson](https://opensource.com/users/arobertson98) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
5 个最佳实践开始你的 DevOps 之旅
|
Magnus Hedemark
|
https://opensource.com/article/17/11/5-keys-get-started-devops
|
想要采用 DevOps 的人通常会过早的被它的歧义性给吓跑，更不要说更加深入的使用了。当一些人开始使用 DevOps 的时候都会问：“如何开始使用呢？”，”怎么才算使用了呢？“。
|
/data/attachment/album/201805/13/073759q00kz56ze1eiqe1p.png.thumb.jpg
|
/data/attachment/album/201805/13/073759q00kz56ze1eiqe1p.png
| true | false | true |
aiwhj
| false |
[
"DevOps"
] |
观点
|
{
"viewnum": 3275,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
想要采用 DevOps 的人通常会过早的被它的歧义性给吓跑，更不要说更加深入的使用了。当一些人开始使用 DevOps 的时候都会问：“如何开始使用呢？”，”怎么才算使用了呢？“。
| 2018-05-13T07:37:56 | 2018-05-13T07:37:56 | 9,634 |
/article-9634-1.html
|
>
> 想要实现 DevOps 但是不知道如何开始吗？试试这 5 个最佳实践吧。
>
>
>
想要采用 DevOps 的人通常会过早的被它的歧义性给吓跑，更不要说更加深入的使用了。当一些人开始使用 DevOps 的时候都会问：“如何开始使用呢？”，”怎么才算使用了呢？“。这 5 个最佳实践是指导你的 DevOps 之旅的很好的路线图。
### 1、 衡量所有的事情
除非你能够量化输出结果，否则你并不能确认你的努力能否使事情变得更好。新功能能否快速的输出给客户？带给他们的缺陷更少吗？出错了能快速应对和恢复吗？
在你开始做任何修改之前，思考一下你切换到 DevOps 之后想要一些什么样的输出。随着你的 DevOps 之旅，将享受到服务的所有内容的丰富的实时报告，从这两个指标考虑一下：
* **上架时间** 衡量端到端，通常是面向客户的业务经验。这通常从一个功能被正式提出而开始，客户在产品中开始使用这个功能而结束。上架时间不是工程团队的主要指标；更加重要的是，当开发出一个有价值的新功能时，它表明了你完成业务的效率，为系统改进提供了一个机会。
* **时间周期** 衡量工程团队的进度。从开始开发一个新功能开始，到在产品环境中运行需要多久？这个指标对于你了解团队的效率是非常有用的，为团队层面的提升提供了一个机会。
### 2、 放飞你的流程
DevOps 的成功需要团队布置一个定期（但愿有效）流程并且持续提升它。这不总是有效的，但是必须是一个定期的流程。通常它有一些敏捷开发的味道，就像 Scrum 或者 Scrumban 一样；一些时候它也像精益开发。不论你用的什么方法，挑选一个正式的流程，开始使用它，并且做好这些基础。
定期检查和调整流程是 DevOps 成功的关键，抓住相关演示、团队回顾、每日会议的机会来提升你的流程。
DevOps 的成功取决于大家一起有效的工作。团队的成员需要在一个有权改进的公共流程中工作。他们也需要定期找机会分享从这个流程中上游或下游的其他人那里学到的东西。
随着你构建成功，好的流程规范能帮助你的团队以很快的速度体会到 DevOps 其他的好处
尽管更多面向开发的团队采用 Scrum 是常见的，但是以运营为中心的团队（或者其他中断驱动的团队）可能选用一个更短期的流程，例如 Kanban。
### 3、 可视化工作流程
这是很强大的，能够看到哪个人在给定的时间做哪一部分工作，可视化你的工作流程能帮助大家知道接下来应该做什么，流程中有多少工作以及流程中的瓶颈在哪里。
在你看到和衡量之前你并不能有效的限制流程中的工作。同样的，你也不能有效的排除瓶颈直到你清楚的看到它。
全部工作可视化能帮助团队中的成员了解他们在整个工作中的贡献。这样可以促进跨组织边界的关系建设，帮助您的团队更有效地协作，实现共同的成就感。
### 4、 持续化所有的事情
DevOps 应该是强制自动化的。然而罗马不是一日建成的。你应该注意的第一个事情应该是努力的[持续集成（CI）](https://martinfowler.com/articles/continuousIntegration.html)，但是不要停留到这里；紧接着的是[持续交付（CD）](https://martinfowler.com/bliki/ContinuousDelivery.html)以及最终的持续部署。
持续部署的过程中是个注入自动测试的好时机。这个时候新代码刚被提交，你的持续部署应该运行测试代码来测试你的代码和构建成功的加工品。这个加工品经受流程的考验被产出，直到最终被客户看到。
另一个“持续”是不太引人注意的持续改进。一个简单的场景是每天询问你旁边的同事：“今天做些什么能使工作变得更好？”，随着时间的推移，这些日常的小改进融合到一起会带来很大的结果，你将很惊喜！但是这也会让人一直思考着如何改进。
### 5、 Gherkinize
促进组织间更有效的沟通对于成功的 DevOps 的系统思想至关重要。在程序员和业务员之间直接使用共享语言来描述新功能的需求文档对于沟通是个好办法。一个好的产品经理能在一天内学会 [Gherkin](https://cucumber.io/docs/reference) 然后使用它以平实的英语构造出明确的描述需求文档，工程师会使用 Gherkin 描述的需求文档来写功能测试，之后开发功能代码直到代码通过测试。这是一个简化的 [验收测试驱动开发](https://en.wikipedia.org/wiki/Acceptance_test%E2%80%93driven_development)(ATDD)，能够帮助你开始你的 DevOps 文化和开发实践。
### 开始你旅程
不要自馁哦。希望这五个想法给你坚实的入门方法。
### 关于作者
Magnus Hedemark - Magnus 在 IT 行业已有 20 多年，并且一直热衷于技术。他目前是 nitedHealth Group 的 DevOps 工程师。在业余时间，Magnus 喜欢摄影和划独木舟。
---
via: <https://opensource.com/article/17/11/5-keys-get-started-devops>
作者：[Magnus Hedemark](https://opensource.com/users/magnus919) 译者：[aiwhj](https://github.com/aiwhj) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
给初学者看的 shuf 命令教程
|
Sk
|
https://www.ostechnix.com/the-shuf-command-tutorial-with-examples-for-beginners/
|
使用 shuf 命令，我们可以随机打乱给定输入文件的行。
|
/data/attachment/album/201805/13/074840tw9rfrjwmzrmm9jb.png.thumb.jpg
|
/data/attachment/album/201805/13/074840tw9rfrjwmzrmm9jb.png
| true | false | true |
geekpi
| false |
[
"shuf",
"随机"
] |
技术
|
{
"viewnum": 14467,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用 shuf 命令，我们可以随机打乱给定输入文件的行。
| 2018-05-13T07:48:38 | 2018-05-13T07:48:38 | 9,635 |
/article-9635-1.html
|
`shuf` 命令用于在类 Unix 操作系统中生成随机排列。使用 `shuf` 命令，我们可以随机打乱给定输入文件的行。`shuf` 命令是 GNU Coreutils 的一部分，因此你不必担心安装问题。在这个简短的教程中，让我向你展示一些 `shuf` 命令的例子。
### 带例子的 shuf 命令教程
我有一个名为 `ostechnix.txt` 的文件，内容如下：
```
$ cat ostechnix.txt
line1
line2
line3
line4
line5
line6
line7
line8
line9
line10
```
现在让我们以随机顺序显示上面的行。为此，请运行：
```
$ shuf ostechnix.txt
line2
line8
line5
line10
line7
line1
line4
line6
line9
line3
```
看到了吗？上面的命令将名为 `ostechnix.txt` 中的行随机排列并输出了结果。
你可能想将输出写入另一个文件。例如，我想将输出保存到 `output.txt` 中。为此，请先创建 `output.txt`：
```
$ touch output.txt
```
然后，像下面使用 `-o` 标志将输出写入该文件：
```
$ shuf ostechnix.txt -o output.txt
```
上面的命令将随机随机打乱 `ostechnix.txt` 的内容并将输出写入 `output.txt`。你可以使用命令查看 `output.txt` 的内容：
```
$ cat output.txt
line2
line8
line9
line10
line1
line3
line7
line6
line4
line5
```
我只想显示文件中的任意一行。我该怎么做？很简单！
```
$ shuf -n 1 ostechnix.txt
line6
```
同样，我们可以选择前 “n” 个随机条目。以下命令将只显示前五个随机条目：
```
$ shuf -n 5 ostechnix.txt
line10
line4
line5
line9
line3
```
如下所示，我们可以直接使用 `-e` 标志传入输入，而不是从文件中读取行：
```
$ shuf -e line1 line2 line3 line4 line5
line1
line3
line5
line4
line2
```
你也可以传入数字：
```
$ shuf -e 1 2 3 4 5
3
5
1
4
2
```
要快速在给定范围选择一个，请改用此命令：
```
$ shuf -n 1 -e 1 2 3 4 5
```
或者，选择下面的任意三个随机数字：
```
$ shuf -n 3 -e 1 2 3 4 5
3
5
1
```
我们也可以在特定范围内生成随机数。例如，要显示 1 到 10 之间的随机数，只需使用：
```
$ shuf -i 1-10
1
9
8
2
4
7
6
3
10
5
```
有关更多详细信息，请参阅手册页。
```
$ man shuf
```
今天就是这些。还有更多更好的东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/the-shuf-command-tutorial-with-examples-for-beginners/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[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 上开始 Java 开发
|
Shaun Assam
|
https://fedoramagazine.org/start-developing-java-fedora/
|
Java 是世界上最流行的编程语言之一。它广泛用于开发物联网设备、Android 程序、Web 和企业应用。本文将提供使用 OpenJDK 安装和配置工作站的指南。
|
/data/attachment/album/201805/13/075645epzn1bt0y1pn8huu.jpg.thumb.jpg
|
/data/attachment/album/201805/13/075645epzn1bt0y1pn8huu.jpg
| true | false | true |
geekpi
| false |
[
"Java"
] |
软件开发
|
{
"viewnum": 6932,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Java 是世界上最流行的编程语言之一。它广泛用于开发物联网设备、Android 程序、Web 和企业应用。本文将提供使用 OpenJDK 安装和配置工作站的指南。
| 2018-05-13T07:56:41 | 2018-05-13T07:56:41 | 9,636 |
/article-9636-1.html
|
Java 是世界上最流行的编程语言之一。它广泛用于开发物联网设备、Android 程序、Web 和企业应用。本文将提供使用 [OpenJDK](http://openjdk.java.net/) 安装和配置工作站的指南。
### 安装编译器和工具
在 Fedora 中安装编译器或 Java Development Kit（JDK）很容易。在写这篇文章时，可以用 v8 和 v9 版本。只需打开一个终端并输入：
```
sudo dnf install java-1.8.0-openjdk-devel
```
这安装 JDK v8。对于 v9，请输入：
```
sudo dnf install java-9-openjdk-devel
```
对于需要其他工具和库（如 Ant 和 Maven）的开发人员，可以使用 **Java Development** 组。要安装套件，请输入：
```
sudo dnf group install "Java Development"
```
要验证编译器是否已安装，请运行：
```
javac -version
```
输出显示编译器版本，如下所示：
```
javac 1.8.0_162
```
### 编译程序
你可以使用任何基本的文本编辑器（如 nano、vim 或 gedit）编写程序。这个例子提供了一个简单的 “Hello Fedora” 程序。
打开你最喜欢的文本编辑器并输入以下内容：
```
public class HelloFedora {
public static void main (String[] args) {
System.out.println("Hello Fedora!");
}
}
```
将文件保存为 `HelloFedora.java`。在终端切换到包含该文件的目录并执行以下操作：
```
javac HelloFedora.java
```
如果编译器遇到任何语法错误，它会发出错误。否则，它只会在下面显示 shell 提示符。
你现在应该有一个名为 `HelloFedora` 的文件，它是编译好的程序。使用以下命令运行它：
```
java HelloFedora
```
输出将显示：
```
Hello Fedora!
```
### 安装集成开发环境（IDE）
有些程序可能更复杂，IDE 可以帮助顺利进行。Java 程序员有很多可用的 IDE，其中包括：
* Geany，一个快速加载的基本 IDE，并提供内置模板
* Anjuta
* GNOME Builder，已经在 [Builder - 这是一个专门面向 GNOME 程序开发人员的新 IDE](https://fedoramagazine.org/builder-a-new-ide-specifically-for-gnome-app-developers-2/) 的文章中介绍过
然而，主要用 Java 编写的最流行的开源 IDE 之一是 [Eclipse](https://www.eclipse.org/)。 Eclipse 在官方仓库中有。要安装它，请运行以下命令：
```
sudo dnf install eclipse-jdt
```
安装完成后，Eclipse 的快捷方式会出现在桌面菜单中。
有关如何使用 Eclipse 的更多信息，请参阅其网站上的[用户指南](http://help.eclipse.org/oxygen/nav/0)。
### 浏览器插件
如果你正在开发 Web 小程序并需要一个用于浏览器的插件，则可以使用 [IcedTea-Web](https://icedtea.classpath.org/wiki/IcedTea-Web)。像 OpenJDK 一样，它是开源的并易于在 Fedora 中安装。运行这个命令：
```
sudo dnf install icedtea-web
```
从 Firefox 52 开始，Web 插件不再有效。有关详细信息，请访问 Mozilla 支持网站 <https://support.mozilla.org/en-US/kb/npapi-plugins?as=u&utm_source=inproduct>。
恭喜，你的 Java 开发环境已准备完毕。
---
via: <https://fedoramagazine.org/start-developing-java-fedora/>
作者：[Shaun Assam](https://fedoramagazine.org/author/sassam/) 选题：[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/) 荣誉推出
|
||
如何在任何地方使用 Vim 编辑器输入文本
|
Sk
|
https://www.ostechnix.com/how-to-use-vim-editor-to-input-text-anywhere/
|
这是一个简单的脚本，它允许你使用 Vim 编辑器在 Linux 中的任何地方输入文本。
|
/data/attachment/album/201805/14/111701l0i5s4i2fis595mo.png.thumb.jpg
|
/data/attachment/album/201805/14/111701l0i5s4i2fis595mo.png
| true | false | true |
paperzhang
| false |
[
"Vim"
] |
分享
|
{
"viewnum": 6818,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这是一个简单的脚本，它允许你使用 Vim 编辑器在 Linux 中的任何地方输入文本。
| 2018-05-14T11:16:58 | 2018-05-14T11:16:58 | 9,637 |
/article-9637-1.html
|
各位 Vim 使用者大家好！今天，我这里有个好消息告诉大家。我会向大家介绍 **Vim-anywhere**，这是一个简单的脚本，它允许你使用 Vim 编辑器在 Linux 中的任何地方输入文本。这意味着你能简单地调用自己最爱的 Vim 编辑器，输入任何你所想的，并将这些文本粘贴到任意的应用和网站中。这些文本将在剪贴板可用，直到你重启了系统。这个工具对那些喜欢在非 Vim 环境中使用 Vim 键位绑定的人来说十分有用。
### 在 Linux 中安装 Vim-anywhere
Vim-anywhere 工具可以运行在任何基于 GNOME（或其他衍生品）的 Linux 发行版上。另外，确保你已经安装了下面的依赖。
* Curl
* Git
* gVim
* xclip
比如，你可以用下面的命令在 Ubuntu 中安装这些工具：
```
$ sudo apt install curl git vim-gnome xclip
```
然后运行如下的命令来安装 Vim-anywhere：
```
$ curl -fsSL https://raw.github.com/cknadler/vim-anywhere/master/install | bash
```
Vim-anywhere 到此已经安装完成。现在我们来看看如何使用它。
### 在任何地方使用 Vim 编辑器输入文本
假如你需要创建一个 word 文档。但是你更愿意使用 Vim 编辑器，而不是 LibreOffice。没问题，这里 Vim-anywhere 就派上用场了。Vim-anywhere 自动化了整个流程。它仅仅简单地调用 Vim 编辑器，所以你能写任何你所想的，然后将之粘贴到 .doc 文件中。
让我给你展示一个用例。打开 LibreOffice 或者你选的任何图形文本编辑器。然后打开 Vim-anywhere。你只需要按下 `CTRL+ALT+V` 即可。它将会打开 gVim 编辑器。按下 `i` 切换到交互模式然后输入文本。完成之后，键入 `:wq` 关闭并保存文件。
这些文本会在剪贴板中可用，直到你重启了系统。在你关闭编辑器之后，你之前的应用会重新占据主界面。你只需按下 `CTRL+P` 将文本粘贴进去。
这仅仅只是一个例子。你甚至可以使用 Vim-anywhere 在烦人的 web 表单或者其他应用上进行输入。一旦 Vim-anywhere 被调用，它将会打开一个缓冲区。关闭 Vim-anywhere 之后，缓冲器内的内容会自动复制到你的剪贴板中，之前的应用会重新占据主界面。
Vim-anywhere 在被调用的时候会在 `/tmp/vim-anywhere` 中创建一个临时文件。这些临时文件会一致保存着，直到你重启了系统，并为你提供临时的历史记录。
```
$ ls /tmp/vim-anywhere
```
你可以用下面的命令重新打开最近的文件：
```
$ vim $( ls /tmp/vim-anywhere | sort -r | head -n 1 )
```
#### 更新 Vim-anywhere
运行下面的命令来更新 Vim-anywhere：
```
$ ~/.vim-anywhere/update
```
#### 更改快捷键
默认调用 Vim-anywhere 的键位是 `CTRL+ALT+V`。你可以用 `gconf` 工具将其更改为任何自定义的键位绑定。
```
$ gconftool -t str --set /desktop/gnome/keybindings/vim-anywhere/binding <custom binding>
```
#### 卸载 Vim-anywhere
可能有些人觉得每次打开 Vim 编辑器，输入一些文本，然后将文本复制到其他应用中是没有意义也毫无必要的。
如果你不觉得这个工具有用，只需使用下面的命令来卸载它：
```
$ ~/.vim-anywhere/uninstall
```
---
via: <https://www.ostechnix.com/how-to-use-vim-editor-to-input-text-anywhere/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[paperzhang](https://github.com/paperzhang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在终端中使用 Instagram
|
Sk
|
https://www.ostechnix.com/how-to-use-instagram-in-terminal/
|
现在你可以在任何类 Unix 操作系统上的终端中使用 Instagram
|
/data/attachment/album/201805/14/120659m79qf4m98899th4j.png.thumb.jpg
|
/data/attachment/album/201805/14/120659m79qf4m98899th4j.png
| true | false | true |
geekpi
| false |
[
"Instagram",
"终端"
] |
分享
|
{
"viewnum": 4757,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "64.120.89.30",
"message": "之前尝试很多相关教程,很多都不靠谱,而且f.cp46.cn/tfr2计数方式一直没摸透,这个播放量计数真的很诡异.今天刚找到个新的工具,比较干净",
"username": "来自美国的 Chrome 78.0|Windows 10 用户",
"date": "2021-04-15T10:49:36"
}
] |
[] |
现在你可以在任何类 Unix 操作系统上的终端中使用 Instagram
| 2018-05-14T12:06:57 | 2018-05-14T12:06:57 | 9,638 |
/article-9638-1.html
|
Instagram 不需要介绍。它是像 Facebook 和 Twitter 之类的流行社交网络平台之一，它可以公开或私下分享照片和视频给确认过的粉丝。它是由两位企业家 **Kevin Systrom** 和 **Mike Krieger**于 2010 年发起的。2012 年，社交网络巨头 Facebook 收购了 Instagram。Android 和 iOS 设备上可以免费下载 Instagram。我们也可以通过网络浏览器在桌面系统中使用它。而且，最酷的是现在你可以在任何类 Unix 操作系统上的终端中使用 Instagram。你兴奋了吗？那么，请阅读以下内容了解如何在终端上查看你的 Instagram feed。
### 终端中的 Instagram
首先，按照以下链接中的说明安装 `pip3`。
然后，git clone 它的脚本仓库。
```
$ git clone https://github.com/billcccheng/instagram-terminal-news-feed.git
```
以上命令会将 instagram 脚本的内容克隆到当前工作目录中名为 `instagram-terminal-news-feed` 的目录中。cd 到该目录：
```
$ cd instagram-terminal-news-feed/
```
然后，运行以下命令安装它：
```
$ pip3 install -r requirements.txt
```
现在，运行以下命令在 Linux 终端中启动 instagram。
```
$ python3 start.py
```
输入你的 Instagram 用户名和密码，并直接从终端中浏览你的 Instagram feed。你的 instragram 用户名和密码将仅本地存储在名为 `credential.json` 的文件中。所以，你不必担心它。你也可以选择不保存默认保存的凭证。
下面是[我的 Instagram 页面](https://www.instagram.com/ostechnix/)的一些截图。
请注意，你只能查看你的 feed。你不能关注任何人，喜欢或评论帖子。这只是一个 instagram feed 阅读器。
该项目可在 GitHub 上免费获得，因此你可以查看源代码，改进它，添加更多功能，修复任何 bug。
玩得开心！干杯！！
---
via: <https://www.ostechnix.com/how-to-use-instagram-in-terminal/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[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/) 荣誉推出
|
||
“Exit Trap” 让你的 Bash 脚本更稳固可靠
|
Aaron Maxwell
|
http://redsymbol.net/articles/bash-exit-traps/
|
要做到这一点，秘诀就是 bash 提供的一个叫做 EXIT 的伪信号，你可以 trap 它，当脚本因为任何原因退出时，相应的命令或函数就会执行。
|
/data/attachment/album/201805/14/150056qniv8u75vo7qmouz.jpg.thumb.jpg
|
/data/attachment/album/201805/14/150056qniv8u75vo7qmouz.jpg
| true | false | true |
Dotcra
| false |
[
"bash",
"脚本"
] |
软件开发
|
{
"viewnum": 7743,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
要做到这一点，秘诀就是 bash 提供的一个叫做 EXIT 的伪信号，你可以 trap 它，当脚本因为任何原因退出时，相应的命令或函数就会执行。
| 2018-05-14T15:01:00 | 2018-05-14T15:01:00 | 9,639 |
/article-9639-1.html
|
有个简单实用的技巧可以让你的 bash 脚本更稳健 -- 确保总是执行必要的收尾工作，哪怕是在发生异常的时候。要做到这一点，秘诀就是 bash 提供的一个叫做 EXIT 的伪信号，你可以 [trap](http://www.gnu.org/software/bash/manual/bashref.html#index-trap) 它，当脚本因为任何原因退出时，相应的命令或函数就会执行。我们来看看它是如何工作的。
基本的代码结构看起来像这样：
```
#!/bin/bash
function finish {
# 你的收尾代码
}
trap finish EXIT
```
你可以把任何你觉得务必要运行的代码放在这个 `finish` 函数里。一个很好的例子是：创建一个临时目录，事后再删除它。
```
#!/bin/bash
scratch=$(mktemp -d -t tmp.XXXXXXXXXX)
function finish {
rm -rf "$scratch"
}
trap finish EXIT
```
这样，在你的核心代码中，你就可以在这个 `$scratch` 目录里下载、生成、操作中间或临时数据了。<sup> <a href="http://redsymbol.net/articles/bash-exit-traps/#footnote-1"> 注1 </a></sup>
```
# 下载所有版本的 linux 内核…… 为了科学研究！
for major in {1..4}; do
for minor in {0..99}; do
for patchlevel in {0..99}; do
tarball="linux-${major}-${minor}-${patchlevel}.tar.bz2"
curl -q "http://kernel.org/path/to/$tarball" -o "$scratch/$tarball" || true
if [ -f "$scratch/$tarball" ]; then
tar jxf "$scratch/$tarball"
fi
done
done
done
# 整合成单个文件
# 复制到目标位置
cp "$scratch/frankenstein-linux.tar.bz2" "$1"
# 脚本结束， scratch 目录自动被删除
```
比较一下如果不用 `trap` ，你是怎么删除 `scratch` 目录的：
```
#!/bin/bash
# 别这样做！
scratch=$(mktemp -d -t tmp.XXXXXXXXXX)
# 在这里插入你的几十上百行代码
# 都搞定了，退出之前把目录删除
rm -rf "$scratch"
```
这有什么问题么？很多：
* 如果运行出错导致脚本提前退出， `scratch` 目录及里面的内容不会被删除。这会导致资料泄漏，可能引发安全问题。
* 如果这个脚本的设计初衷就是在脚本末尾以前退出，那么你必须手动复制粘贴 `rm` 命令到每一个出口。
* 这也给维护带来了麻烦。如果今后在脚本某处添加了一个 `exit` ，你很可能就忘了加上删除操作 -- 从而制造潜在的安全漏洞。
### 无论如何，服务要在线
另外一个场景： 想象一下你正在运行一些自动化系统运维任务，要临时关闭一项服务，最后这项服务需要重启，而且要万无一失，即使脚本运行出错。那么你可以这样做：
```
function finish {
# 重启服务
sudo /etc/init.d/something start
}
trap finish EXIT
sudo /etc/init.d/something stop
# 主要任务代码
# 脚本结束，执行 finish 函数重启服务
```
一个具体的实例：比如 Ubuntu 服务器上运行着 MongoDB ，你要为 crond 写一个脚本来临时关闭服务并做一些日常维护工作。你应该这样写：
```
function finish {
# 重启服务
sudo service mongdb start
}
trap finish EXIT
# 关闭 mongod 服务
sudo service mongdb stop
# （如果 mongod 配置了 fork ，比如 replica set ，你可能需要执行 “sudo killall --wait /usr/bin/mongod”）
```
### 控制开销
有一种情况特别能体现 EXIT `trap` 的价值：如果你的脚本运行过程中需要初始化一下成本高昂的资源，结束时要确保把它们释放掉。比如你在 AWS (Amazon Web Services) 上工作，要在脚本中创建一个镜像。
（名词解释: 在亚马逊云上的运行的服务器叫“[实例](http://aws.amazon.com/ec2/)”。实例从<ruby> 亚马逊机器镜像 <rt> Amazon Machine Image </rt></ruby>创建而来，通常被称为 “AMI” 或 “镜像” 。AMI 相当于某个特殊时间点的服务器快照。）
我们可以这样创建一个自定义的 AMI ：
1. 基于一个基准 AMI 运行一个实例（例如，启动一个服务器）。
2. 在实例中手动或运行脚本来做一些修改。
3. 用修改后的实例创建一个镜像。
4. 如果不再需要这个实例，可以将其删除。
最后一步**相当重要**。如果你的脚本没有把实例删除掉，它会一直运行并计费。（到月底你的账单让你大跌眼镜时，恐怕哭都来不及了！）
如果把 AMI 的创建封装在脚本里，我们就可以利用 `trap` EXIT 来删除实例了。我们还可以用上 EC2 的命令行工具：
```
#!/bin/bash
# 定义基准 AMI 的 ID
ami=$1
# 保存临时实例的 ID
instance=''
# 作为 IT 人，让我们看看 scratch 目录的另类用法
scratch=$(mktemp -d -t tmp.XXXXXXXXXX)
function finish {
if [ -n "$instance" ]; then
ec2-terminate-instances "$instance"
fi
rm -rf "$scratch"
}
trap finish EXIT
# 创建实例，将输出(包含实例 ID )保存到 scratch 目录下的文件里
ec2-run-instances "$ami" > "$scratch/run-instance"
# 提取实例 ID
instance=$(grep '^INSTANCE' "$scratch/run-instance" | cut -f 2)
```
脚本执行到这里，实例（EC2 服务器）已经开始运行 <sup> <a href="http://redsymbol.net/articles/bash-exit-traps/#footnote-2"> 注2 </a> 。接下来你可以做任何事情：在实例中安装软件，修改配置文件等，然后为最终版本创建一个镜像。实例会在脚本结束时被删除</sup> -- 即使脚本因错误而提前退出。（请确保实例创建成功后再运行业务代码。）
### 更多应用
这篇文章只讲了些皮毛。我已经使用这个 bash 技巧很多年了，现在还能不时发现一些有趣的用法。你也可以把这个方法应用到你自己的场景中，从而提升你的 bash 脚本的可靠性。
### 尾注
* 注1. `mktemp` 的选项 `-t` 在 Linux 上是可选的，在 OS X 上是必需的。带上此选项可以让你的脚本有更好的可移植性。
* 注2. 如果只是为了获取实例 ID ，我们不用创建文件，直接写成 `instance=$(ec2-run-instances "$ami" | grep '^INSTANCE' | cut -f 2)` 就可以。但把输出写入文件可以记录更多有用信息，便于调试 ，代码可读性也更强。
作者简介：美国加利福尼亚旧金山的作家，软件工程师，企业家。[Powerful Python](https://www.amazon.com/d/0692878971) 的作者，他的 [blog](https://powerfulpython.com/blog/)。
---
via: <http://redsymbol.net/articles/bash-exit-traps/>
作者：[aaron maxwell](http://redsymbol.net/) 译者：[Dotcra](https://github.com/Dotcra) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 命令行下的数学运算
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3268964/linux/how-to-do-math-on-the-linux-command-line.html
|
有几个有趣的命令可以在 Linux 系统下做数学运算： expr、factor、jot 和 bc 命令。
|
/data/attachment/album/201805/14/190605btc11bot16tiv2u8.jpg.thumb.jpg
|
/data/attachment/album/201805/14/190605btc11bot16tiv2u8.jpg
| true | false | true |
pinewall
| false |
[
"数学",
"bc",
"计算",
"expr"
] |
技术
|
{
"viewnum": 14562,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有几个有趣的命令可以在 Linux 系统下做数学运算： expr、factor、jot 和 bc 命令。
| 2018-05-14T19:04:00 | 2018-05-14T19:04:00 | 9,642 |
/article-9642-1.html
|
>
> 有几个有趣的命令可以在 Linux 系统下做数学运算： `expr`、`factor`、`jot` 和 `bc` 命令。
>
>
>
可以在 Linux 命令行下做数学运算吗？当然可以！事实上，有不少命令可以轻松完成这些操作，其中一些甚至让你大吃一惊。让我们来学习这些有用的数学运算命令或命令语法吧。
### expr
首先，对于在命令行使用命令进行数学运算，可能最容易想到、最常用的命令就是 `expr` （<ruby> 表达式 <rt> expression </rt></ruby>。它可以完成四则运算，也可以用于比较大小。下面是几个例子：
#### 变量递增
```
$ count=0
$ count=`expr $count + 1`
$ echo $count
1
```
#### 完成简单运算
```
$ expr 11 + 123
134
$ expr 134 / 11
12
$ expr 134 - 11
123
$ expr 11 * 123
expr: syntax error <== oops!
$ expr 11 \* 123
1353
$ expr 20 % 3
2
```
注意，你需要在 `*` 运算符之前增加 `\` 符号，避免语法错误（注：`*` 是 bash 的通配符，因此需要用 `\` 转义，下面的 `>` 也是由于是 bash 的管道符而需要转义）。`%` 运算符用于取余运算。
下面是一个稍微复杂的例子：
```
participants=11
total=156
share=`expr $total / $participants`
remaining=`expr $total - $participants \* $share`
echo $share
14
echo $remaining
2
```
假设某个活动中有 11 位参与者，需要颁发的奖项总数为 156，那么平均每个参与者获得 14 项奖项，额外剩余 2 个奖项。
#### 比较
下面让我们看一下比较的操作。从第一印象来看，语句看似有些怪异；这里并不是**设置**数值，而是进行数字比较。在本例中 `expr` 判断表达式是否为真：如果结果是 1，那么表达式为真；反之，表达式为假。
```
$ expr 11 = 11
1
$ expr 11 = 12
0
```
请读作“11 是否等于 11？”及“11 是否等于 12？”，你很快就会习惯这种写法。当然，我们不会在命令行上执行上述比较，可能的比较是 `$age` 是否等于 `11`。
```
$ age=11
$ expr $age = 11
1
```
在本例中，我们判断 10 是否大于 5，以及是否大于 99。
```
$ expr 10 \> 5
1
$ expr 10 \> 99
0
```
的确，返回 1 和 0 分别代表比较的结果为真和假，我们一般预期在 Linux 上得到这个结果。在下面的例子中，按照上述逻辑使用 `expr` 并不正确，因为 `if` 的工作原理刚好相反，即 0 代表真。
```
#!/bin/bash
echo -n "Cost to us> "
read cost
echo -n "Price we're asking> "
read price
if [ `expr $price \> $cost` ]; then
echo "We make money"
else
echo "Don't sell it"
fi
```
下面，我们运行这个脚本：
```
$ ./checkPrice
Cost to us> 11.50
Price we're asking> 6
We make money
```
这显然与我们预期不符！我们稍微修改一下，以便使其按我们预期工作：
```
#!/bin/bash
echo -n "Cost to us> "
read cost
echo -n "Price we're asking> "
read price
if [ `expr $price \> $cost` == 1 ]; then
echo "We make money"
else
echo "Don't sell it"
fi
```
### factor
`factor` 命令的功能基本与你预期相符。你给出一个数字，该命令会给出对应数字的因子。
```
$ factor 111
111: 3 37
$ factor 134
134: 2 67
$ factor 17894
17894: 2 23 389
$ factor 1987
1987: 1987
```
注：`factor` 命令对于最后一个数字没有返回更多因子，这是因为 1987 是一个**质数**。
### jot
`jot` 命令可以创建一系列数字。给定数字总数及起始数字即可。
```
$ jot 8 10
10
11
12
13
14
15
16
17
```
你也可以用如下方式使用 `jot`，这里我们要求递减至数字 2。
```
$ jot 8 10 2
10
9
8
7
5
4
3
2
```
`jot` 可以帮你构造一系列数字组成的列表，该列表可以用于其它任务。
```
$ for i in `jot 7 17`; do echo April $i; done
April 17
April 18
April 19
April 20
April 21
April 22
April 23
```
### bc
`bc` 基本上是命令行数学运算最佳工具之一。输入你想执行的运算，使用管道发送至该命令即可：
```
$ echo "123.4+5/6-(7.89*1.234)" | bc
113.664
```
可见 `bc` 并没有忽略精度，而且输入的字符串也相当直截了当。它还可以进行大小比较、处理布尔值、计算平方根、正弦、余弦和正切等。
```
$ echo "sqrt(256)" | bc
16
$ echo "s(90)" | bc -l
.89399666360055789051
```
事实上，`bc` 甚至可以计算 pi。你需要指定需要的精度。
```
$ echo "scale=5; 4*a(1)" | bc -l
3.14156
$ echo "scale=10; 4*a(1)" | bc -l
3.1415926532
$ echo "scale=20; 4*a(1)" | bc -l
3.14159265358979323844
$ echo "scale=40; 4*a(1)" | bc -l
3.1415926535897932384626433832795028841968
```
除了通过管道接收数据并返回结果，`bc`还可以交互式运行，输入你想执行的运算即可。本例中提到的 `scale` 设置可以指定有效数字的个数。
```
$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
scale=2
3/4
.75
2/3
.66
quit
```
你还可以使用 `bc` 完成数字进制转换。`obase` 用于设置输出的数字进制。
```
$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
obase=16
16 <=== entered
10 <=== response
256 <=== entered
100 <=== response
quit
```
按如下方式使用 `bc` 也是完成十六进制与十进制转换的最简单方式之一：
```
$ echo "ibase=16; F2" | bc
242
$ echo "obase=16; 242" | bc
F2
```
在上面第一个例子中，我们将输入进制（`ibase`）设置为十六进制（`hex`），完成十六进制到为十进制的转换。在第二个例子中，我们执行相反的操作，即将输出进制（`obase`）设置为十六进制。
### 简单的 bash 数学运算
通过使用双括号，我们可以在 bash 中完成简单的数学运算。在下面的例子中，我们创建一个变量，为变量赋值，然后依次执行加法、自减和平方。
```
$ (( e = 11 ))
$ (( e = e + 7 ))
$ echo $e
18
$ (( e-- ))
$ echo $e
17
$ (( e = e ** 2 ))
$ echo $e
289
```
允许使用的运算符包括：
```
+ - 加法及减法
++ -- 自增与自减
* / % 乘法、除法及求余数
** 指数运算（bash 中）
^ 指数运算（bc 中）
```
你还可以使用逻辑运算符和布尔运算符：
```
$ ((x=11)); ((y=7))
$ if (( x > y )); then
> echo "x > y"
> fi
x > y
$ ((x=11)); ((y=7)); ((z=3))
$ if (( x > y )) >> (( y > z )); then
> echo "letters roll downhill"
> fi
letters roll downhill
```
或者如下方式：
```
$ if [ x > y ] << [ y > z ]; then echo "letters roll downhill"; fi
letters roll downhill
```
下面计算 2 的 3 次幂：
```
$ echo "2 ^ 3"
2 ^ 3
$ echo "2 ^ 3" | bc
8
```
### 总结
在 Linux 系统中，有很多不同的命令行工具可以完成数字运算。希望你在读完本文之后，能掌握一两个新工具。
感谢 @[no1xsyzy](https://github.com/no1xsyzy) [提出的修改意见](https://github.com/LCTT/TranslateProject/issues/8841)。
---
via: <https://www.networkworld.com/article/3268964/linux/how-to-do-math-on-the-linux-command-line.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
两款 Linux 桌面端可用的科学计算器
|
Ricardo Berlasso
|
https://opensource.com/article/18/1/scientific-calculators-linux
|
如果你想找个高级的桌面计算器的话，你可以看看开源软件，以及一些其它有趣的工具。
|
/data/attachment/album/201805/15/102710qilkuv3eaiysdfyg.jpg.thumb.jpg
|
/data/attachment/album/201805/15/102710qilkuv3eaiysdfyg.jpg
| true | false | true |
zyk2290
| false |
[
"计算器"
] |
分享
|
{
"viewnum": 10206,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你想找个高级的桌面计算器的话，你可以看看开源软件，以及一些其它有趣的工具。
| 2018-05-15T10:27:00 | 2018-05-15T10:27:00 | 9,643 |
/article-9643-1.html
|
>
> 如果你想找个高级的桌面计算器的话，你可以看看开源软件，以及一些其它有趣的工具。
>
>
>
每个 Linux 桌面环境都至少带有一个功能简单的桌面计算器，但大多数计算器只能进行一些简单的计算。
幸运的是，还是有例外的：不仅可以做得比开平方根和一些三角函数还多，而且还很简单。这里将介绍两款强大的计算器，外加一大堆额外的功能。
### SpeedCrunch
[SpeedCrunch](http://speedcrunch.org/index.html) 是一款高精度科学计算器，有着简明的 Qt5 图像界面，并且强烈依赖键盘。
*SpeedCrunch 运行中*
它支持单位，并且可用在所有函数中。
例如，
```
2 * 10^6 newton / (meter^2)
```
你可以得到：
```
= 2000000 pascal
```
SpeedCrunch 会默认地将结果转化为国际标准单位，但还是可以用 `in` 命令转换：
例如：
```
3*10^8 meter / second in kilo meter / hour
```
结果是：
```
= 1080000000 kilo meter / hour
```
`F5` 键可以将所有结果转为科学计数法（`1.08e9 kilo meter / hour`），`F2` 键可以只将那些很大的数或很小的数转为科学计数法。更多选项可以在配置页面找到。
可用的函数的列表看上去非常壮观。它可以用在 Linux 、 Windows、macOS。许可证是 GPLv2，你可以在 [Bitbucket](https://bitbucket.org/heldercorreia/speedcrunch) 上得到它的源码。
### Qalculate!
[Qalculate!](https://qalculate.github.io/)（有感叹号）有一段长而复杂的历史。
这个项目给了我们一个强大的库，而这个库可以被其它程序使用（在 Plasma 桌面中，krunner 可以用它来计算），以及一个用 GTK3 搭建的图形界面。它允许你转换单位，处理物理常量，创建图像，使用复数，矩阵以及向量，选择任意精度，等等。
*在 Qalculate! 中查看物理常量*
在单位的使用方面，Qalculate! 会比 SppedCrunch 更加直观，而且可以识别一些常用前缀。你有听说过 exapascal 压力吗？反正我没有（太阳的中心大概在 `~26 PPa`），但 Qalculate! ，可以准确 `1 EPa` 的意思。同时，Qalculate! 可以更加灵活地处理语法错误，所以你不需要担心打括号：如果没有歧义，Qalculate! 会直接给出正确答案。
一段时间之后这个项目看上去被遗弃了。但在 2016 年，它又变得强大了，在一年里更新了 10 个版本。它的许可证是 GPLv2 （源码在 [GitHub](https://github.com/Qalculate) 上），提供Linux 、Windows 、macOS的版本。
### 更多计算器
#### ConvertAll
好吧，这不是“计算器”，但这个程序非常好用。
大部分单位转换器只是一个大的基本单位列表以及一大堆基本组合，但 [ConvertAll](http://convertall.bellz.org/) 与它们不一样。有试过把“天文单位每年”转换为“英尺每秒”吗？不管它们说不说得通，只要你想转换任何种类的单位，ConvertAll 就是你要的工具。
只需要在相应的输入框内输入转换前和转换后的单位：如果单位相容，你会直接得到答案。
主程序是在 PyQt5 上搭建的，但也有 [JavaScript 的在线版本](http://convertall.bellz.org/js/)。
#### 带有单位包的 (wx)Maxima
有时候（好吧，很多时候）一款桌面计算器时候不够你用的，然后你需要更多的原力。
[Maxima](http://maxima.sourceforge.net/) 是一款计算机代数系统（LCTT 译注：进行符号运算的软件。这种系统的要件是数学表示式的符号运算），你可以用它计算导数、积分、方程、特征值和特征向量、泰勒级数、拉普拉斯变换与傅立叶变换，以及任意精度的数字计算、二维或三维图像··· ···列出这些都够我们写几页纸的了。
[wxMaxima](https://andrejv.github.io/wxmaxima/) 是一个设计精湛的 Maxima 的图形前端，它简化了许多 Maxima 的选项，但并不会影响其它。在 Maxima 的基础上，wxMaxima 还允许你创建 “笔记本”，你可以在上面写一些笔记，保存你的图像等。其中一项 (wx)Maxima 最惊艳的功能是它可以处理尺寸单位。
在提示符只需要输入：
```
load("unit")
```
按 `Shift+Enter`，等几秒钟的时间，然后你就可以开始了。
默认地，单位包可以用基本的 MKS 单位，但如果你喜欢，例如，你可以用 `N` 为单位而不是 `kg*m/s2`，你只需要输入：`setunits(N)`。
Maxima 的帮助（也可以在 wxMaxima 的帮助菜单中找到）会给你更多信息。
你使用这些程序吗？你知道还有其它好的科学、工程用途的桌面计算器或者其它相关的计算器吗？在评论区里告诉我们吧！
---
via: <https://opensource.com/article/18/1/scientific-calculators-linux>
作者：[Ricardo Berlasso](https://opensource.com/users/rgb-es) 译者：[zyk2290](https://github.com/zyk2290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
基于命令行的任务管理器 Taskwarrior
|
Link Dupont
|
https://fedoramagazine.org/getting-started-taskwarrior/
|
Taskwarrior 在命令行里管理你的 TODO 列表。它灵活，快速，高效，不显眼，它默默做自己的事情让你避免自己管理。
|
/data/attachment/album/201805/15/104609d5en8uesea8gepn8.jpg.thumb.jpg
|
/data/attachment/album/201805/15/104609d5en8uesea8gepn8.jpg
| true | false | true |
MjSeven
| false |
[
"todo",
"Taskwarrior"
] |
分享
|
{
"viewnum": 5705,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Taskwarrior 在命令行里管理你的 TODO 列表。它灵活，快速，高效，不显眼，它默默做自己的事情让你避免自己管理。
| 2018-05-15T10:46:03 | 2018-05-15T10:46:03 | 9,644 |
/article-9644-1.html
|
Taskwarrior 是一个灵活的[命令行任务管理程序](https://taskwarrior.org/)，用他们[自己的话说](https://taskwarrior.org/docs/start.html)：
>
> Taskwarrior 在命令行里管理你的 TODO 列表。它灵活，快速，高效，不显眼，它默默做自己的事情让你避免自己管理。
>
>
>
Taskwarrior 是高度可定制的，但也可以“立即使用”。在本文中，我们将向你展示添加和完成任务的基本命令，然后我们将介绍几个更高级的命令。最后，我们将向你展示一些基本的配置设置，以开始自定义你的设置。
### 安装 Taskwarrior
Taskwarrior 在 Fedora 仓库中是可用的，所有安装它很容易：
```
sudo dnf install task
```
一旦完成安装，运行 `task` 命令。第一次运行将会创建一个 `~/.taskrc` 文件。
```
$ task
A configuration file could not be found in ~
Would you like a sample /home/link/.taskrc created, so Taskwarrior can proceed? (yes/no) yes
[task next]
No matches.
```
### 添加任务
添加任务快速而不显眼。
```
$ task add Plant the wheat
Created task 1.
```
运行 `task` 或者 `task list` 来显示即将来临的任务。
```
$ task list
ID Age Description Urg
1 8s Plant the wheat 0
1 task
```
让我们添加一些任务来完成这个示例。
```
$ task add Tend the wheat
Created task 2.
$ task add Cut the wheat
Created task 3.
$ task add Take the wheat to the mill to be ground into flour
Created task 4.
$ task add Bake a cake
Created task 5.
```
再次运行 `task` 来查看列表。
```
[task next]
ID Age Description Urg
1 3min Plant the wheat 0
2 22s Tend the wheat 0
3 16s Cut the wheat 0
4 8s Take the wheat to the mill to be ground into flour 0
5 2s Bake a cake 0
5 tasks
```
### 完成任务
将一个任务标记为完成， 查找其 ID 并运行：
```
$ task 1 done
Completed task 1 'Plant the wheat'.
Completed 1 task.
```
你也可以用它的描述来标记一个任务已完成。
```
$ task 'Tend the wheat' done
Completed task 1 'Tend the wheat'.
Completed 1 task.
```
通过使用 `add`、`list` 和 `done`，你可以说已经入门了。
### 设定截止日期
很多任务不需要一个截止日期：
```
task add Finish the article on Taskwarrior
```
但是有时候，设定一个截止日期正是你需要提高效率的动力。在添加任务时使用 `due` 修饰符来设置特定的截止日期。
```
task add Finish the article on Taskwarrior due:tomorrow
```
`due` 非常灵活。它接受特定日期 (`2017-02-02`) 或 ISO-8601 (`2017-02-02T20:53:00Z`)，甚至相对时间 (`8hrs`)。可以查看所有示例的 [Date & Time](https://taskwarrior.org/docs/dates.html) 文档。
日期也不只有截止日期，Taskwarrior 有 `scheduled`, `wait` 和 `until` 选项。
```
task add Proof the article on Taskwarrior scheduled:thurs
```
一旦日期（本例中的星期四）通过，该任务就会被标记为 `READY` 虚拟标记。它会显示在 `ready` 报告中。
```
$ task ready
ID Age S Description Urg
1 2s 1d Proof the article on Taskwarrior 5
```
要移除一个日期，使用空白值来 `modify` 任务：
```
$ task 1 modify scheduled:
```
### 查找任务
如果没有使用正则表达式搜索的能力，任务列表是不完整的，对吧？
```
$ task '/.* the wheat/' list
ID Age Project Description Urg
2 42min Take the wheat to the mill to be ground into flour 0
1 42min Home Cut the wheat 1
2 tasks
```
### 自定义 Taskwarrior
记得我们在开头创建的文件 (`~/.taskrc`)吗？让我们来看看默认设置：
```
# [Created by task 2.5.1 2/9/2017 16:39:14]
# Taskwarrior program configuration file.
# For more documentation, see http://taskwarrior.org or try 'man task', 'man task-color',
# 'man task-sync' or 'man taskrc'
# Here is an example of entries that use the default, override and blank values
# variable=foo -- By specifying a value, this overrides the default
# variable= -- By specifying no value, this means no default
# #variable=foo -- By commenting out the line, or deleting it, this uses the default
# Use the command 'task show' to see all defaults and overrides
# Files
data.location=~/.task
# Color theme (uncomment one to use)
#include /usr//usr/share/task/light-16.theme
#include /usr//usr/share/task/light-256.theme
#include /usr//usr/share/task/dark-16.theme
#include /usr//usr/share/task/dark-256.theme
#include /usr//usr/share/task/dark-red-256.theme
#include /usr//usr/share/task/dark-green-256.theme
#include /usr//usr/share/task/dark-blue-256.theme
#include /usr//usr/share/task/dark-violets-256.theme
#include /usr//usr/share/task/dark-yellow-green.theme
#include /usr//usr/share/task/dark-gray-256.theme
#include /usr//usr/share/task/dark-gray-blue-256.theme
#include /usr//usr/share/task/solarized-dark-256.theme
#include /usr//usr/share/task/solarized-light-256.theme
#include /usr//usr/share/task/no-color.theme
```
现在唯一生效的选项是 `data.location=~/.task`。要查看活动配置设置（包括内置的默认设置），运行 `show`。
```
task show
```
要改变设置，使用 `config`。
```
$ task config displayweeknumber no
Are you sure you want to add 'displayweeknumber' with a value of 'no'? (yes/no) yes
Config file /home/link/.taskrc modified.
```
### 示例
这些只是你可以用 Taskwarrior 做的一部分事情。
将你的任务分配到一个项目：
```
task 'Fix leak in the roof' modify project:Home
```
使用 `start` 来标记你正在做的事情，这可以帮助你回忆起你周末后在做什么：
```
task 'Fix bug #141291' start
```
使用相关的标签：
```
task add 'Clean gutters' +weekend +house
```
务必阅读[完整文档](https://taskwarrior.org/docs/)以了解你可以编目和组织任务的所有方式。
---
via: <https://fedoramagazine.org/getting-started-taskwarrior/>
作者：[Link Dupont](https://fedoramagazine.org/author/linkdupont/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
探秘“栈”之旅
|
Gustavo Duarte
|
https://manybutfinite.com/post/journey-to-the-stack/
|
栈非常重要，因为它追踪着一个程序中运行的函数，而函数又是一个软件的重要组成部分。
|
/data/attachment/album/201805/15/182842wn8zd9pnfynzfh4v.jpg.thumb.jpg
|
/data/attachment/album/201805/15/182842wn8zd9pnfynzfh4v.jpg
| true | false | true |
qhwdw
| false |
[
"堆栈",
"栈帧",
"函数"
] |
技术
|
{
"viewnum": 12538,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9731,
"displayorder": 0
}
] |
栈非常重要，因为它追踪着一个程序中运行的函数，而函数又是一个软件的重要组成部分。
| 2018-05-15T18:31:28 | 2018-05-15T18:31:28 | 9,645 |
/article-9645-1.html
|
早些时候，我们探索了 [“内存中的程序之秘”](/article-9255-1.html)，我们欣赏了在一台电脑中是如何运行我们的程序的。今天，我们去探索*栈的调用*，它在大多数编程语言和虚拟机中都默默地存在。在此过程中，我们将接触到一些平时很难见到的东西，像<ruby> 闭包 <rt> closure </rt></ruby>、递归、以及缓冲溢出等等。但是，我们首先要作的事情是，描绘出栈是如何运作的。
栈非常重要，因为它追踪着一个程序中运行的*函数*，而函数又是一个软件的重要组成部分。事实上，程序的内部操作都是非常简单的。它大部分是由函数向栈中推入数据或者从栈中弹出数据的相互调用组成的，而在堆上为数据分配内存才能在跨函数的调用中保持数据。不论是低级的 C 软件还是像 JavaScript 和 C# 这样的基于虚拟机的语言，它们都是这样的。而对这些行为的深刻理解，对排错、性能调优以及大概了解究竟发生了什么是非常重要的。
当一个函数被调用时，将会创建一个<ruby> 栈帧 <rt> stack frame </rt></ruby>去支持函数的运行。这个栈帧包含函数的*局部变量*和调用者传递给它的*参数*。这个栈帧也包含了允许被调用的函数（*callee*）安全返回给其调用者的内部事务信息。栈帧的精确内容和结构因处理器架构和函数调用规则而不同。在本文中我们以 Intel x86 架构和使用 C 风格的函数调用（`cdecl`）的栈为例。下图是一个处于栈顶部的一个单个栈帧：
在图上的场景中，有三个 CPU 寄存器进入栈。<ruby> 栈指针 <rt> stack pointer </rt></ruby> `esp`（LCTT 译注：扩展栈指针寄存器） 指向到栈的顶部。栈的顶部总是被最*后一个推入到栈且还没有弹出*的东西所占据，就像现实世界中堆在一起的一叠盘子或者 100 美元大钞一样。
保存在 `esp` 中的地址始终在变化着，因为栈中的东西不停被推入和弹出，而它总是指向栈中的最后一个推入的东西。许多 CPU 指令的一个副作用就是自动更新 `esp`，离开寄存器而使用栈是行不通的。
在 Intel 的架构中，绝大多数情况下，栈的增长是向着*低位内存地址*的方向。因此，这个“顶部” 在包含数据的栈中是处于低位的内存地址（在这种情况下，包含的数据是 `local_buffer`）。注意，关于从 `esp` 到 `local_buffer` 的箭头不是随意连接的。这个箭头代表着事务：它*专门*指向到由 `local_buffer` 所拥有的*第一个字节*，因为，那是一个保存在 `esp` 中的精确地址。
第二个寄存器跟踪的栈是 `ebp`（LCTT 译注：扩展基址指针寄存器），它包含一个<ruby> 基指针 <rt> base pointer </rt></ruby>或者称为<ruby> 帧指针 <rt> frame pointer </rt></ruby>。它指向到一个*当前运行*的函数的栈帧内的固定位置，并且它为参数和局部变量的访问提供一个稳定的参考点（基址）。仅当开始或者结束调用一个函数时，`ebp` 的内容才会发生变化。因此，我们可以很容易地处理在栈中的从 `ebp` 开始偏移后的每个东西。如图所示。
不像 `esp`， `ebp` 大多数情况下是在程序代码中通过花费很少的 CPU 来进行维护的。有时候，完成抛弃 `ebp` 有一些性能优势，可以通过 [编译标志](http://stackoverflow.com/questions/14666665/trying-to-understand-gcc-option-fomit-frame-pointer) 来做到这一点。Linux 内核就是一个这样做的示例。
最后，`eax`（LCTT 译注：扩展的 32 位通用数据寄存器）寄存器惯例被用来转换大多数 C 数据类型返回值给调用者。
现在，我们来看一下在我们的栈帧中的数据。下图清晰地按字节展示了字节的内容，就像你在一个调试器中所看到的内容一样，内存是从左到右、从顶部至底部增长的，如下图所示：
局部变量 `local_buffer` 是一个字节数组，包含一个由 null 终止的 ASCII 字符串，这是 C 程序中的一个基本元素。这个字符串可以读取自任意地方，例如，从键盘输入或者来自一个文件，它只有 7 个字节的长度。因为，`local_buffer` 只能保存 8 字节，所以还剩下 1 个未使用的字节。*这个字节的内容是未知的*，因为栈不断地推入和弹出，*除了你写入的之外*，你根本不会知道内存中保存了什么。这是因为 C 编译器并不为栈帧初始化内存，所以它的内容是未知的并且是随机的 —— 除非是你自己写入。这使得一些人对此很困惑。
再往上走，`local1` 是一个 4 字节的整数，并且你可以看到每个字节的内容。它似乎是一个很大的数字，在8 后面跟着的都是零，在这里可能会误导你。
Intel 处理器是<ruby> 小端 <rt> little endian </rt></ruby>机器，这表示在内存中的数字也是首先从小的一端开始的。因此，在一个多字节数字中，较小的部分在内存中处于最低端的地址。因为一般情况下是从左边开始显示的，这背离了我们通常的数字表示方式。我们讨论的这种从小到大的机制，使我想起《格里佛游记》：就像小人国的人们吃鸡蛋是从小头开始的一样，Intel 处理器处理它们的数字也是从字节的小端开始的。
因此，`local1` 事实上只保存了一个数字 8，和章鱼的腿数量一样。然而，`param1` 在第二个字节的位置有一个值 2，因此，它的数学上的值是 `2 * 256 = 512`（我们与 256 相乘是因为，每个位置值的范围都是从 0 到 255）。同时，`param2` 承载的数量是 `1 * 256 * 256 = 65536`。
这个栈帧的内部数据是由两个重要的部分组成：*前一个*栈帧的地址（保存的 `ebp` 值）和函数退出才会运行的指令的地址（返回地址）。它们一起确保了函数能够正常返回，从而使程序可以继续正常运行。
现在，我们来看一下栈帧是如何产生的，以及去建立一个它们如何共同工作的内部蓝图。首先，栈的增长是非常令人困惑的，因为它与你你预期的方式相反。例如，在栈上分配一个 8 字节，就要从 `esp` 减去 8，去，而减法是与增长不同的奇怪方式。
我们来看一个简单的 C 程序：
```
Simple Add Program - add.c
int add(int a, int b)
{
int result = a + b;
return result;
}
int main(int argc)
{
int answer;
answer = add(40, 2);
}
```
*简单的加法程序 - add.c*
假设我们在 Linux 中不使用命令行参数去运行它。当你运行一个 C 程序时，实际运行的第一行代码是在 C 运行时库里，由它来调用我们的 `main` 函数。下图展示了程序运行时每一步都发生了什么。每个图链接的 GDB 输出展示了内存和寄存器的状态。你也可以看到所使用的 [GDB 命令](https://github.com/gduarte/blog/blob/master/code/x86-stack/add-gdb-commands.txt)，以及整个 [GDB 输出](https://github.com/gduarte/blog/blob/master/code/x86-stack/add-gdb-output.txt)。如下：
第 2 步和第 3 步，以及下面的第 4 步，都只是函数的<ruby> 序言 <rt> prologue </rt></ruby>，几乎所有的函数都是这样的：`ebp` 的当前值被保存到了栈的顶部，然后，将 `esp` 的内容拷贝到 `ebp`，以建立一个新的栈帧。`main` 的序言和其它函数一样，但是，不同之处在于，当程序启动时 `ebp` 被清零。
如果你去检查栈下方（右边）的整形变量（`argc`），你将找到更多的数据，包括指向到程序名和命令行参数（传统的 C 的 `argv`）、以及指向 Unix 环境变量以及它们真实的内容的指针。但是，在这里这些并不是重点，因此，继续向前调用 `add()`：
在 `main` 从 `esp` 减去 12 之后得到它所需的栈空间，它为 `a` 和 `b` 设置值。在内存中的值展示为十六进制，并且是小端格式，与你从调试器中看到的一样。一旦设置了参数值，`main` 将调用 `add`，并且开始运行：
现在，有一点小激动！我们进入了另一个函数序言，但这次你可以明确看到栈帧是如何从 `ebp` 到栈建立一个链表。这就是调试器和高级语言中的 `Exception` 对象如何对它们的栈进行跟踪的。当一个新帧产生时，你也可以看到更多这种典型的从 `ebp` 到 `esp` 的捕获。我们再次从 `esp` 中做减法得到更多的栈空间。
当 `ebp` 寄存器的值拷贝到内存时，这里也有一个稍微有些怪异的字节逆转。在这里发生的奇怪事情是，寄存器其实并没有字节顺序：因为对于内存，没有像寄存器那样的“增长的地址”。因此，惯例上调试器以对人类来说最自然的格式展示了寄存器的值：数位从最重要的到最不重要。因此，这个在小端机器中的副本的结果，与内存中常用的从左到右的标记法正好相反。我想用图去展示你将会看到的东西，因此有了下面的图。
在比较难懂的部分，我们增加了注释：
这是一个临时寄存器，用于帮你做加法，因此没有什么警报或者惊喜。对于加法这样的作业，栈的动作正好相反，我们留到下次再讲。
对于任何读到这里的人都应该有一个小礼物，因此，我做了一个大的图表展示了 [组合到一起的所有步骤](https://manybutfinite.com/img/stack/callSequence.png)。
一旦把它们全部布置好了，看上起似乎很乏味。这些小方框给我们提供了很多帮助。事实上，在计算机科学中，这些小方框是主要的展示工具。我希望这些图片和寄存器的移动能够提供一种更直观的构想图，将栈的增长和内存的内容整合到一起。从软件的底层运作来看，我们的软件与一个简单的图灵机器差不多。
这就是我们栈探秘的第一部分，再讲一些内容之后，我们将看到构建在这个基础上的高级编程的概念。下周见！
---
via:<https://manybutfinite.com/post/journey-to-the-stack/>
作者：[Gustavo Duarte](http://duartes.org/gustavo/blog/about/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
从专有到开源的十个简单步骤
|
Mike Bursell
|
https://opensource.com/article/17/11/commonwealth-open-source
|
这个共同福利并不适用于专有软件：保持隐藏的东西是不能照亮或丰富这个世界的。
|
/data/attachment/album/201805/16/081220tpmrm9gptf75m5u9.jpg.thumb.jpg
|
/data/attachment/album/201805/16/081220tpmrm9gptf75m5u9.jpg
| true | false | true |
FelixYFZ
| false |
[
"开源",
"开源软件"
] |
观点
|
{
"viewnum": 4375,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
这个共同福利并不适用于专有软件：保持隐藏的东西是不能照亮或丰富这个世界的。
| 2018-05-16T08:12:18 | 2018-05-16T08:12:18 | 9,646 |
/article-9646-1.html
|
>
> 这个共同福利并不适用于专有软件：保持隐藏的东西是不能照亮或丰富这个世界的。
>
>
>
“开源软件肯定不太安全，因为每个人都能看到它的源代码，而且他们能重新编译它，用他们自己写的不好的东西进行替换。”举手示意：谁之前听说过这个说法？<sup> 注1</sup>
当我和客户讨论的时候（是的，他们有时候会让我和客户交谈），对于这个领域<sup> 注2</sup> 的人来说种问题是很常见的。在前一篇文章中，“[许多只眼睛的审查并不一定能防止错误代码]”，我谈论的是开源软件（尤其是安全软件）并不能神奇地比专有软件更安全，但是和专有软件比起来，我每次还是比较青睐开源软件。但我听到“关于开源软件不是很安全”这种问题表明了有时候只是说“开源需要参与”是不够的，我们也需要积极的参与辩护<sup> 注3</sup> 。
我并不期望能够达到牛顿或者维特根斯坦的逻辑水平，但是我会尽我所能，而且我会在结尾做个总结，如果你感兴趣的话可以去快速的浏览一下。
### 关键因素
首先，我们必须明白没有任何软件是完美的<sup> 注6</sup> 。无论是专有软件还是开源软件。第二，我们应该承认确实还是存在一些很不错的专有软件的，以及第三，也存在一些糟糕的开源软件。第四，有很多非常聪明的，很有天赋的，专业的架构师、设计师和软件工程师设计开发了专有软件。
但也有些问题：第五，从事专有软件的人员是有限的，而且你不可能总是能够雇佣到最好的员工。即使在政府部门或者公共组织 —— 他们拥有丰富的人才资源池，但在安全应用这块，他们的人才也是有限的。第六，可以查看、测试、改进、拆解、再次改进和发布开源软件的人总是无限的，而且还包含最好的人才。第七（也是我最喜欢的一条），这群人也包含很多编写专有软件的人才。第八，许多政府或者公共组织开发的软件也都逐渐开源了。
第九，如果你在担心你在运行的软件的不被支持或者来源不明，好消息是：有一批组织<sup> 注7</sup> 会来检查软件代码的来源，提供支持、维护和补丁更新。他们会按照专利软件模式那样去运行开源软件，你也可以确保你从他们那里得到的软件是正确的软件：他们的技术标准就是对软件包进行签名，以便你可以验证你正在运行的开源软件不是来源不明或者是恶意的软件。
第十（也是这篇文章的重点），当你运行开源软件，测试它，对问题进行反馈，发现问题并且报告的时候，你就是在为<ruby> 共同福利 <rt> commonwealth </rt></ruby>贡献知识、专业技能以及经验，这就是开源，其因为你的所做的这些而变得更好。如果你是通过个人或者提供支持开源软件的商业组织之一<sup> 注8</sup> 参与的，你已经成为了这个共同福利的一部分了。开源让软件变得越来越好，你可以看到它们的变化。没有什么是隐藏封闭的，它是完全开放的。事情会变坏吗？是的，但是我们能够及时发现问题并且修复。
这个共同福利并不适用于专有软件：保持隐藏的东西是不能照亮或丰富这个世界的。
我知道作为一个英国人在使用<ruby> 共同福利 <rt> commonwealth </rt></ruby>这个词的时候要小心谨慎的；它和帝国连接着的，但我所表达的不是这个意思。它不是克伦威尔<sup> 注9</sup> 在对这个词所表述的意思，无论如何，他是一个有争议的历史人物。我所表达的意思是这个词有“共同”和“福利”连接，福利不是指钱而是全人类都能拥有的福利。
我真的很相信这点的。如果i想从这篇文章中得到一些虔诚信息的话，那应该是第十条<sup> 注10</sup> ：共同福利是我们的遗产，我们的经验，我们的知识，我们的责任。共同福利是全人类都能拥有的。我们共同拥有它而且它是一笔无法估量的财富。
### 便利贴
1. （几乎）没有一款软件是完美无缺的。
2. 有很好的专有软件。
3. 有不好的专有软件。
4. 有聪明，有才能，专注的人开发专有软件。
5. 从事开发完善专有软件的人是有限的，即使在政府或者公共组织也是如此。
6. 相对来说从事开源软件的人是无限的。
7. …而且包括很多从事专有软件的人才。
8. 政府和公共组织的人经常开源它们的软件。
9. 有商业组织会为你的开源软件提供支持。
10. 贡献--即使是使用--为开源软件贡献。
### 脚注
* 注1： 好的--你现在可以放下手了
* 注2：这应该大写吗？有特定的领域吗？或者它是如何工作的？我不确定。
* 注3：我有一个英国文学和神学的学位--这可能不会惊讶到我的文章的普通读者<sup> 注4</sup> 。
* 注4： 我希望不是，因为我说的太多神学了<sup> 注5</sup> 。但是它经常充满了冗余的，无关紧要的人文科学引用。
* 注5： Emacs，每一次。
* 注6： 甚至是 Emacs。而且我知道有技术能够去证明一些软件的正确性。（我怀疑 Emacs 不能全部通过它们...）
* 注7： 注意这里：我被他们其中之一 [Red Hat](https://www.redhat.com/) 所雇佣，去查看一下--它是一个有趣的工作地方，而且[我们经常在招聘](https://www.redhat.com/en/jobs)。
* 注8： 假设他们完全遵守他们正在使用的开源软件许可证。
* 注9： 昔日的“英格兰、苏格兰、爱尔兰的上帝守护者”--比克伦威尔。
* 注10： 很明显，我选择 Emacs 而不是 Vi 变体。
这篇文章原载于 [Alice, Eve, and Bob - a security blog] 而且已经被授权重新发布。
---
via: <https://opensource.com/article/17/11/commonwealth-open-source>
作者：[Mike Bursell](https://opensource.com/users/mikecamel) 译者：[FelixYFZ](https://github.com/FelixYFZ) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 终端下检查笔记本电池状态
|
Sk
|
https://www.ostechnix.com/how-to-check-laptop-battery-status-in-terminal-in-linux/
|
在本文中我概括了三种简单的方法来让你在任何 Linux 发行版本中从终端查看笔记本电池的状态。
|
/data/attachment/album/201805/16/082358p32gn2ouvqs5uriu.png.thumb.jpg
|
/data/attachment/album/201805/16/082358p32gn2ouvqs5uriu.png
| true | false | true |
FSSlc
| false |
[
"电池"
] |
分享
|
{
"viewnum": 16876,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本文中我概括了三种简单的方法来让你在任何 Linux 发行版本中从终端查看笔记本电池的状态。
| 2018-05-16T08:23:56 | 2018-05-16T08:23:56 | 9,647 |
/article-9647-1.html
|
在图形界面下查看你的笔记本电池状态是很容易的，只需将鼠标指向任务栏中的电池图标上，你便可以很容易地知道电池的电量。但如果我们想要从命令行中获得这些信息呢？并不是所有人都知道如何做到这点。前几天我的一个朋友询问我如何从他的 Ubuntu 系统里，在终端中查看他的笔记本电池的电量。这便是我写这篇文章的起因。在本文中我概括了三种简单的方法来让你在任何 Linux 发行版本中从终端查看笔记本电池的状态。
### 在终端下检查笔记本电池状态
我们可以使用下面的三种方法来从命令行中查找到笔记本电池状态。
#### 方法一 – 使用 upower 命令
`upower` 命令预装在大多数的 Linux 发行版本中。为了使用 `upower` 命令来展示电池的状态，打开终端并运行如下命令：
```
$ upower -i /org/freedesktop/UPower/devices/battery_BAT0
```
示例输出：
```
native-path: BAT0
vendor: Samsung SDI
model: DELL 7XFJJA2
serial: 4448
power supply: yes
updated: Sat 12 May 2018 06:48:48 PM IST (41 seconds ago)
has history: yes
has statistics: yes
battery
present: yes
rechargeable: yes
state: charging
warning-level: none
energy: 43.3011 Wh
energy-empty: 0 Wh
energy-full: 44.5443 Wh
energy-full-design: 48.84 Wh
energy-rate: 9.8679 W
voltage: 12.548 V
time to full: 7.6 minutes
percentage: 97%
capacity: 91.2045%
technology: lithium-ion
icon-name: 'battery-full-charging-symbolic'
History (charge):
1526131128 97.000 charging
History (rate):
1526131128 9.868 charging
```
正如你所看到的那样，我的电池正处于充电状态，并且它的电量百分比是 97%。
假如上面的命令因为某些未知原因不起作用，可以尝试使用下面的命令：
```
$ upower -i `upower -e | grep 'BAT'`
```
示例输出：
```
native-path: BAT0
vendor: Samsung SDI
model: DELL 7XFJJA2
serial: 4448
power supply: yes
updated: Sat 12 May 2018 06:50:49 PM IST (22 seconds ago)
has history: yes
has statistics: yes
battery
present: yes
rechargeable: yes
state: charging
warning-level: none
energy: 43.6119 Wh
energy-empty: 0 Wh
energy-full: 44.5443 Wh
energy-full-design: 48.84 Wh
energy-rate: 8.88 W
voltage: 12.552 V
time to full: 6.3 minutes
percentage: 97%
capacity: 91.2045%
technology: lithium-ion
icon-name: 'battery-full-charging-symbolic'
History (rate):
1526131249 8.880 charging
```
`upower` 不仅可以显示出电池的状态，它还可以显示出已安装电池的其他完整信息，例如电池型号，供应商名称，电池的序列号，电池的状态，电池的电压等信息。
当然，如果你只想显示电池的状态，你可以可以结合使用 `upower` 命令和[grep](https://www.ostechnix.com/the-grep-command-tutorial-with-examples-for-beginners/) 命令，具体命令如下：
```
$ upower -i $(upower -e | grep BAT) | grep --color=never -E "state|to\ full|to\ empty|percentage"
```
示例输出：
```
state: fully-charged
percentage: 100%
```
从上面的输出中可以看到我的笔记本电池已经完全充满了。
想知晓更多的细节，可以参看 man 页：
```
$ man upower
```
#### 方法二 – 使用 acpi 命令
`acpi` 命令可以用来显示你的 Linux 发行版本中电池的状态以及其他 ACPI 信息。
在某些 Linux 发行版本中，你可能需要安装 `acpi` 命令。
要在 Debian、 Ubuntu 及其衍生版本中安装它，可以使用如下命令：
```
$ sudo apt-get install acpi
```
在 RHEL、 CentOS、 Fedora 等系统中使用：
```
$ sudo yum install acpi
```
或者使用如下命令：
```
$ sudo dnf install acpi
```
在 Arch Linux 及其衍生版本中使用：
```
$ sudo pacman -S acpi
```
一旦 `acpi` 安装好后，运行下面的命令：
```
$ acpi -V
```
注意： 在上面的命令中， `V` 是大写字母。
示例输出：
```
Battery 0: Charging, 99%, 00:02:09 until charged
Battery 0: design capacity 4400 mAh, last full capacity 4013 mAh = 91%
Battery 1: Discharging, 0%, rate information unavailable
Adapter 0: on-line
Thermal 0: ok, 77.5 degrees C
Thermal 0: trip point 0 switches to mode critical at temperature 84.0 degrees C
Cooling 0: Processor 0 of 3
Cooling 1: Processor 0 of 3
Cooling 2: LCD 0 of 15
Cooling 3: Processor 0 of 3
Cooling 4: Processor 0 of 3
Cooling 5: intel_powerclamp no state information available
Cooling 6: x86_pkg_temp no state information available
```
首先让我们来检查电池的电量，可以运行：
```
$ acpi
```
示例输出：
```
Battery 0: Charging, 99%, 00:01:41 until charged
Battery 1: Discharging, 0%, rate information unavailable
```
下面，让我们来查看电池的温度：
```
$ acpi -t
```
示例输出：
```
Thermal 0: ok, 63.5 degrees C
```
如果需要将温度以华氏温标显示，可以使用：
```
$ acpi -t -f
```
示例输出：
```
Thermal 0: ok, 144.5 degrees F
```
如果想看看交流电适配器是否连接上了没有，可以运行：
```
$ acpi -a
```
示例输出：
```
Adapter 0: on-line
```
假如交流电适配器没有连接上，则你将看到如下的输出：
```
Adapter 0: off-line
```
想获取更多的信息，可以查看 man 页：
```
$ man acpi
```
#### 方法三 - 使用 batstat 程序
`batstat` 是一个基于 ncurses 的命令行小工具，使用它可以在类 Unix 系统中展示笔记本电池状态。它可以展示如下具体信息：
* 当前电池电量
* 当前电池所存能量
* 充满时所存能量
* 从程序启动开始经历的时间，它不会追踪记录机器休眠的时间
* 电池电量消耗历史数据
安装 `batstat` 轻而易举。使用下面的命令来克隆该程序的最新版本：
```
$ git clone https://github.com/Juve45/batstat.git
```
上面的命令将拉取 `batstat` 的最新版本并将它的内容保存在一个名为 `batstat` 的文件夹中。
首先将目录切换到 `batstat/bin/` 中：
```
$ cd batstat/bin/
```
接着将 `batstat` 二进制文件复制到 `PATH` 环境变量中的某个目录中，例如 `/usr/local/bin/` 目录：
```
$ sudo cp batstat /usr/local/bin/
```
使用下面的命令来让它可被执行：
```
$ sudo chmod +x /usr/local/bin/batstat
```
最后，使用下面的命令来查看你的电池状态。
```
$ batstat
```
示例输出：
从上面的截图中可以看到我的笔记本电池正处于充电状态。
这个小工具还有某些小的限制。在书写本文之时，`batstat` 仅支持显示一个电池的相关信息。而且它只从 `/sys/class/power_supply/` 目录搜集相关的信息。假如你的电池信息被存放在另外的目录中，则这个小工具就不会起作用了。
想知晓更多信息，可以查看 `batstat` 的 [GitHub 主页](https://github.com/Juve45/batstat)。
上面就是今天我要分享的所有内容。当然，可能还有很多其他的命令或者程序来从 Linux 终端检查笔记本的电池状态。据我所知，上面给出的命令都运行良好。假如你知道其他命令来查看电池的状态，请在下面的评论框中让我们知晓。假如你所给出的方法能够起作用，我将对我的这篇文章进行更新。
最后，上面便是今天的全部内容了。更多的优质内容敬请期待，敬请关注！
欢呼吧!
---
via: <https://www.ostechnix.com/how-to-check-laptop-battery-status-in-terminal-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[FSSlc](https://github.com/FSSlc) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中使用 find
|
Ben Cotton
|
https://opensource.com/article/18/4/how-use-find-linux
|
使用正确的参数，find 命令是在你的系统上找到数据的强大而灵活的方式。
|
/data/attachment/album/201805/16/083712gelll7esoold7o7l.png.thumb.jpg
|
/data/attachment/album/201805/16/083712gelll7esoold7o7l.png
| true | false | true |
geekpi
| false |
[
"find"
] |
技术
|
{
"viewnum": 6734,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用正确的参数，find 命令是在你的系统上找到数据的强大而灵活的方式。
| 2018-05-16T08:37:09 | 2018-05-16T08:37:09 | 9,648 |
/article-9648-1.html
|
>
> 使用正确的参数，`find` 命令是在你的系统上找到数据的强大而灵活的方式。
>
>
>
在[最近的一篇文章](/article-9585-1.html)中，Lewis Cowles 介绍了 `find` 命令。
`find` 是日常工具箱中功能更强大、更灵活的命令行工具之一，因此值得花费更多的时间。
最简单的，`find` 跟上路径寻找一些东西。例如：
```
find /
```
它将找到（并打印出）系统中的每个文件。而且由于一切都是文件，你会得到很多需要整理的输出。这可能不能帮助你找到你要找的东西。你可以改变路径参数来缩小范围，但它不会比使用 `ls` 命令更有帮助。所以你需要考虑你想要找的东西。
也许你想在主目录中找到所有的 JPEG 文件。 `-name` 参数允许你将结果限制为与给定模式匹配的文件。
```
find ~ -name '*jpg'
```
可是等等！如果它们中的一些是大写的扩展名会怎么样？`-iname` 就像 `-name`，但是不区分大小写。
```
find ~ -iname '*jpg'
```
很好！但是 8.3 名称方案是如此的老。一些图片可能是 .jpeg 扩展名。幸运的是，我们可以将模式用“或”（表示为 `-o`）来组合。
```
find ~ ( -iname 'jpeg' -o -iname 'jpg' )
```
我们正在接近目标。但是如果你有一些以 jpg 结尾的目录呢？ （为什么你要命名一个 `bucketofjpg` 而不是 `pictures` 的目录就超出了本文的范围。）我们使用 `-type` 参数修改我们的命令来查找文件。
```
find ~ \( -iname '*jpeg' -o -iname '*jpg' \) -type f
```
或者，也许你想找到那些命名奇怪的目录，以便稍后重命名它们：
```
find ~ \( -iname '*jpeg' -o -iname '*jpg' \) -type d
```
你最近拍了很多照片，所以让我们把它缩小到上周更改的文件。
```
find ~ \( -iname '*jpeg' -o -iname '*jpg' \) -type f -mtime -7
```
你可以根据文件状态更改时间 （`ctime`）、修改时间 （`mtime`） 或访问时间 （`atime`） 来执行时间过滤。 这些是在几天内，所以如果你想要更细粒度的控制，你可以表示为在几分钟内（分别是 `cmin`、`mmin` 和 `amin`）。 除非你确切地知道你想要的时间，否则你可能会在 `+` （大于）或 `-` （小于）的后面加上数字。
但也许你不关心你的照片。也许你的磁盘空间不够用，所以你想在 `log` 目录下找到所有巨大的（让我们定义为“大于 1GB”）文件：
```
find /var/log -size +1G
```
或者，也许你想在 `/data` 中找到 bcotton 拥有的所有文件：
```
find /data -owner bcotton
```
你还可以根据权限查找文件。也许你想在你的主目录中找到对所有人可读的文件，以确保你不会过度分享。
```
find ~ -perm -o=r
```
这篇文章只说了 `find` 能做什么的表面。将测试条件与布尔逻辑相结合可以为你提供难以置信的灵活性，以便准确找到要查找的文件。并且像 `-exec` 或 `-delete` 这样的参数，你可以让 `find` 对它发现的内容采取行动。你有任何最喜欢的 `find` 表达式么？在评论中分享它们！
---
via: <https://opensource.com/article/18/4/how-use-find-linux>
作者：[Ben Cotton](https://opensource.com/users/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/) 荣誉推出
|
||
在 5 分钟内重置丢失的 root 密码
|
Curt Warfield
|
https://opensource.com/article/18/4/reset-lost-root-password
|
如何快速简单地在 Fedora 、 CentOS 及类似的 Linux 发行版上重置 root 密码。
|
/data/attachment/album/201805/17/090716ijbddjjptmudu9de.jpg.thumb.jpg
|
/data/attachment/album/201805/17/090716ijbddjjptmudu9de.jpg
| true | false | true |
geekpi
| false |
[
"密码"
] |
技术
|
{
"viewnum": 7495,
"commentnum": 0,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如何快速简单地在 Fedora 、 CentOS 及类似的 Linux 发行版上重置 root 密码。
| 2018-05-17T09:02:00 | 2018-05-17T09:02:00 | 9,649 |
/article-9649-1.html
|
>
> 如何快速简单地在 Fedora 、 CentOS 及类似的 Linux 发行版上重置 root 密码。
>
>
>
系统管理员可以轻松地为忘记密码的用户重置密码。但是如果系统管理员忘记 root 密码或他从公司离职了，会发生什么情况？本指南将向你介绍如何在不到 5 分钟的时间内在 Red Hat 兼容系统（包括 Fedora 和 CentOS）上重置丢失或忘记的 root 密码。
请注意，如果整个系统硬盘已用 LUKS 加密，则需要在出现提示时提供 LUKS 密码。此外，此过程适用于运行 systemd 的系统，该系统自 Fedora 15、CentOS 7.14.04 和 Red Hat Enterprise Linux 7.0 以来一直是缺省的初始系统。
首先你需要中断启动的过程，因此你需要启动或者如果已经启动就重启它。第一步可能有点棘手因为 GRUB 菜单会在屏幕上快速地闪烁过去。你可能需要尝试几次，直到你能够做到这一点。
当你看到这个屏幕时，按下键盘上的 `e` 键：
如果你正确地做了这点，你应该看到一个类似于这个的屏幕：
使用箭头键移动到 `Linux16` 这行：
使用你的 `del` 键或你的 `backspace` 键，删除 `rhgb quiet` 并替换为以下内容：
```
rd.break enforcing=0
```
设置 `enforcing=0` 可以避免执行完整的系统 SELinux 重标记。一旦系统重新启动，你只需要为 `/etc/shadow` 恢复正确的 SELinux 上下文。我会告诉你如何做到这一点。
按下 `Ctrl-x` 启动。
**系统现在将处于紧急模式。**
以读写权限重新挂载硬盘驱动器：
```
# mount –o remount,rw /sysroot
```
运行 `chroot` 来访问系统：
```
# chroot /sysroot
```
你现在可以更改 root 密码：
```
# passwd
```
出现提示时，输入新的 root 密码两次。如果成功，你应该看到一条消息显示 “all authentication tokens updated successfully”。
输入 `exit` 两次以重新启动系统。
以 root 身份登录并恢复 `/etc/shadow` 的 SELinux 标签。
```
# restorecon -v /etc/shadow
```
将 SELinux 回到 enforce 模式：
```
# setenforce 1
```
---
via: <https://opensource.com/article/18/4/reset-lost-root-password>
作者：[Curt Warfield](https://opensource.com/users/rcurtiswarfield) 选题：[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/) 荣誉推出
|
||
使用 syslog-ng 可靠地记录物联网事件
|
Peter Czanik
|
https://opensource.com/article/18/3/logging-iot-events-syslog-ng
|
用增强的日志守护进程 syslog-ng 来监控你的物联网设备。
|
/data/attachment/album/201805/17/094849iinnwxitxxn6tbtw.jpg.thumb.jpg
|
/data/attachment/album/201805/17/094849iinnwxitxxn6tbtw.jpg
| true | false | true |
qhwdw
| false |
[
"日志",
"物联网",
"syslog"
] |
技术
|
{
"viewnum": 5953,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用增强的日志守护进程 syslog-ng 来监控你的物联网设备。
| 2018-05-17T09:48:59 | 2018-05-17T09:48:59 | 9,650 |
/article-9650-1.html
|
>
> 用增强的日志守护进程 syslog-ng 来监控你的物联网设备。
>
>
>
现在，物联网设备和嵌入式系统越来越多。对于许多连接到因特网或者一个网络的设备来说，记录事件很有必要，因为你需要知道这些设备都做了些什么事情，这样你才能够解决可能出现的问题。
可以考虑去使用的一个监视工具是开源的 [syslog-ng](https://syslog-ng.com/open-source-log-management) 应用程序，它是一个强化的、致力于可移植的、中心化的日志收集守护程序。它可以从许多不同种类的来源、进程来收集日志，并且可以对这些日志进行处理和过滤，也可以存储或者路由它们，以便于做进一步的分析。syslog-ng 的大多数代码是用高效率的、高可移植的 C 代码写成的。它能够适用于各种场景，无论你是将它运行在一个处理能力很弱的设备上做一些简单的事情，还是运行在数据中心从成千上万的机器中收集日志的强大应用，它都能够胜任。
你可能注意到在这个段落中，我使用了大量的溢美词汇。为了让你更清晰地了解它，我们来复习一下，但这将花费更多的时间，也了解的更深入一些。
### 日志
首先解释一下日志。<ruby> 日志 <rt> logging </rt></ruby>是记录一台计算机上事件的东西。在一个典型的 Linux 机器上，你可以在 `/var/log` 目录中找到这些信息。例如，如果你通过 SSH 登录到机器中，你将可以在其中一个日志文件中找到类似于如下内容的信息：
```
Jan 14 11:38:48 linux-0jbu sshd[7716]: Accepted publickey for root from 127.0.0.1 port 48806 ssh2
```
日志的内容可能是关于你的 CPU 过热、通过 HTTP 下载了一个文档，或者你的应用程序认为重要的任何东西。
### syslog-ng
正如我在上面所写的那样，syslog-ng 应用程序是一个强化的、致力于可移植性、和中心化的日志收集守护程序。守护程序的意思是，syslog-ng 是一个持续运行在后台的应用程序，在这里，它用于收集日志信息。
虽然现在大多数应用程序的 Linux 测试是限制在 x86\_64 的机器上，但是，syslog-ng 也可以运行在大多数 BSD 和商业 UNIX 变种版本上的。从嵌入式/物联网的角度来看，这种能够运行在不同的 CPU 架构（包括 32 位和 64 位的 ARM、PowerPC、MIPS 等等）的能力甚至更为重要。（有时候，我通过阅读关于 syslog-ng 是如何使用它们的来学习新架构）
为什么中心化的日志收集如此重要？其中一个很重要的原因是易于使用，因为它放在一个地方，不用到成百上千的机器上挨个去检查它们的日志。另一个原因是可用性 —— 即使一个设备不论是什么原因导致了它不可用，你都可以检查这个设备的日志信息。第三个原因是安全性；当你的设备被黑，检查设备日志可以发现攻击的踪迹。
### syslog-ng 的四种用法
syslog-ng 有四种主要的用法：收集、处理、过滤、和保存日志信息。
**收集信息：** syslog-ng 能够从各种各样的 [特定平台源](https://syslog-ng.com/documents/html/syslog-ng-ose-latest-guides/en/syslog-ng-ose-guide-admin/html/sources.html) 上收集信息，比如 `/dev/log`，`journal`，或者 `sun-streams`。作为一个中心化的日志收集器，传统的（`rfc3164`）和最新的（`rfc5424`）系统日志协议、以及它们基于 UDP、TCP 和加密连接的各种变种，它都是支持的。你也可以从管道、套接字、文件、甚至应用程序输出来收集日志信息（或者各种文本数据）。
**处理日志信息：** 它的处理能力几乎是无限的。你可以用它内置的解析器来分类、规范，以及结构化日志信息。如果它没有为你提供在你的应用场景中所需要的解析器，你甚至可以用 Python 来自己写一个解析器。你也可以使用地理数据来丰富信息，或者基于信息内容来附加一些字段。日志信息可以按处理它的应用程序所要求的格式进行重新格式化。你也可以重写日志信息 —— 当然了，不是篡改日志内容 —— 比如在某些情况下，需要满足匿名要求的信息。
**过滤日志：** 过滤日志的用法主要有两种：丢弃不需要保存的日志信息 —— 像调试级别的信息；和路由日志信息—— 确保正确的日志到达正确的目的地。后一种用法的一个例子是，转发所有的认证相关的信息到一个安全信息与事件管理系统（SIEM）。
**保存信息：** 传统的做法是，将文件保存在本地或者发送到中心化日志服务器；不论是哪种方式，它们都被发送到一个[普通文件](https://en.wikipedia.org/wiki/Flat_file_database)。经过这些年的改进，syslog-ng 已经开始支持 SQL 数据库，并且在过去的几年里，包括 HDFS、Kafka、MongoDB、和 Elasticsearch 在内的大数据存储，都被加入到 syslog-ng 的支持中。
### 消息格式
当在你的 `/var/log` 目录中查看消息时，你将看到（如上面的 SSH 信息）大量的消息都是如下格式的内容：
```
日期 + 主机名 + 应用名 + 一句几乎完整的英文信息
```
在这里的每个应用程序事件都是用不同的语法描述的，基于这些数据去创建一个报告是个痛苦的任务。
解决这种混乱信息的一个方案是使用结构化日志。在这种情况下，事件被表示为键-值对，而不是随意的日志信息。比如，一个 SSH 日志能够按应用程序名字、源 IP 地址、用户名、认证方法等等来描述。
你可以从一开始就对你的日志信息按合适的格式进行结构化处理。当处理传统的日志信息时，你可以在 syslog-ng 中使用不同的解析器，转换非结构化（和部分结构化）的信息为键-值对格式。一旦你的日志信息表示为键-值对，那么，报告、报警、以及简单查找信息将变得很容易。
### 物联网日志
我们从一个棘手的问题开始：哪个版本的 syslog-ng 最流行？在你回答之前，想想如下这些事实：这个项目启动于 20 年以前，Red Hat 企业版 Linux EPEL 已经有了 3.5 版，而当前版本是 3.14。当我在我的演讲中问到这个问题时，观众通常回答是他们用的 Linux 发行版中自带的那个。你们绝对想不到的是，正确答案竟然是 1.6 版最流行，这个版本已经有 15 年的历史的。这什么这个版本是最为流行的，因为它是包含在亚马逊 Kindle 阅读器中的版本，它是电子书阅读器，因为它运行在全球范围内超过 1 亿台的设备上。另外一个在消费类设备上运行 syslog-ng 的例子是 BMW i3 电动汽车。
Kindle 使用 syslog-ng 去收集关于用户在这台设备上都做了些什么事情等所有可能的信息。在 BMW 电动汽车上，syslog-ng 所做的事情更复杂，基于内容过滤日志信息，并且在大多数情况下，只记录最重要的日志。
使用 syslog-ng 的其它类别设备还有网络和存储。一些比较知名的例子有，Turris Omnia 开源 Linux 路由器和群晖 NAS 设备。在大多数案例中，syslog-ng 是在设备上作为一个日志客户端来运行，但是在有些案例中，它运行为一个有丰富 Web 界面的中心日志服务器。
你还可以在一些行业服务中找到 syslog-ng 的身影。它运行在来自美国国家仪器有限公司（NI）的实时 Linux 设备上，执行测量和自动化任务。它也被用于从定制开发的应用程序中收集日志。从命令行就可以做配置，但是一个漂亮的 GUI 可用于浏览日志。
最后，还有大量的项目，比如，汽车和飞机，syslog-ng 在它们上面既可以运行为客户端，也可以运行为服务端。在这种使用案例中，syslog-ng 一般用来收集所有的日志和测量数据，然后发送它们到处理这些日志的中心化服务器集群上，然后保存它们到支持大数据的目的地，以备进一步分析。
### 对物联网的整体益处
在物联网环境中使用 syslog-ng 有几个好处。第一，它的分发性能很高，并且是一个可靠的日志收集器。第二，它的架构也很简单，因此，系统、应用程序日志、以及测量数据可以被一起收集。第三，它使数据易于使用，因为，数据可以被解析和表示为易于使用的格式。最后，通过 syslog-ng 的高效路由和过滤功能，可以显著降低处理程序的负载水平。
---
via: <https://opensource.com/article/18/3/logging-iot-events-syslog-ng>
作者：[Peter Czanik](https://opensource.com/users/czanik) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 KVM 中测试 IPv6 网络：第 2 部分
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2017/11/testing-ipv6-networking-kvm-part-2
|
今天，我们将使用 KVM 创建一个网络，去测试上一星期学习的 IPv6 的内容。
|
/data/attachment/album/201805/17/215300wph170t9ltmgmt93.png.thumb.jpg
|
/data/attachment/album/201805/17/215300wph170t9ltmgmt93.png
| true | false | true |
qhwdw
| false |
[
"IPv6",
"KVM"
] |
技术
|
{
"viewnum": 5469,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9594,
"displayorder": 0
}
] |
今天，我们将使用 KVM 创建一个网络，去测试上一星期学习的 IPv6 的内容。
| 2018-05-17T21:52:57 | 2018-05-17T21:52:57 | 9,652 |
/article-9652-1.html
|
我们又见面了，在上一篇 [在 KVM 中测试 IPv6 网络：第 1 部分](/article-9594-1.html) 中，我们学习了有关 IPv6 私有地址的内容。今天，我们将使用 KVM 创建一个网络，去测试上一星期学习的 IPv6 的内容。
如果你想重新温习如何使用 KVM，可以查看 [在 KVM 中创建虚拟机：第 1 部分](https://www.linux.com/learn/intro-to-linux/2017/5/creating-virtual-machines-kvm-part-1) 和 [在 KVM 中创建虚拟机：第 2 部分— 网络](https://www.linux.com/learn/intro-to-linux/2017/5/creating-virtual-machines-kvm-part-2-networking)。
### 在 KVM 中创建网络
在 KVM 中你至少需要两个虚拟机。当然了，如果你愿意，也可以创建更多的虚拟机。在我的系统中有 Fedora、Ubuntu、以及 openSUSE。去创建一个新的 IPv6 网络，在主虚拟机管理窗口中打开 “Edit > Connection Details > Virtual Networks”。点击左下角的绿色十字按钮去创建一个新的网络（图 1）。
*图 1：创建一个网络*
给新网络输入一个名字，然后，点击 “Forward” 按钮。如果你愿意，也可以不创建 IPv4 网络。当你创建一个新的 IPv4 网络时，虚拟机管理器将不让你创建重复网络，或者是使用了一个无效地址。在我的宿主机 Ubuntu 系统上，有效的地址是以绿色高亮显示的，而无效地址是使用高亮的玫瑰红色调。在我的 openSUSE 机器上没有高亮颜色。启用或不启用 DHCP，以及创建或不创建一个静态路由，然后进入下一个窗口。
选中 “Enable IPv6 network address space definition”，然后输入你的私有地址范围。你可以使用任何你希望的 IPv6 地址类，但是要注意，不能将你的实验网络泄漏到公网上去。我们将使用非常好用的 IPv6 唯一本地地址（ULA），并且使用在 [Simple DNS Plus](http://simpledns.com/private-ipv6.aspx) 上的在线地址生成器，去创建我们的网络地址。拷贝 “Combined/CID” 地址到网络框中（图 2）。
*图 2：拷贝 "Combined/CID" 地址到网络框中*
虚拟机认为我的地址是无效的，因为，它显示了高亮的玫瑰红色。它做的对吗？我们使用 `ipv6calc` 去验证一下：
```
$ ipv6calc -qi fd7d:844d:3e17:f3ae::/64
Address type: unicast, unique-local-unicast, iid, iid-local
Registry for address: reserved(RFC4193#3.1)
Address type has SLA: f3ae
Interface identifier: 0000:0000:0000:0000
Interface identifier is probably manual set
```
`ipv6calc` 认为没有问题。如果感兴趣，你可以改变其中一个数字为无效的东西，比如字母 `g`，然后再试一次。（问 “如果…？”，试验和错误是最好的学习方法）。
我们继续进行，启用 DHCPv6（图 3）。你可以接受缺省值，或者输入一个你自己的设置值。
*图 3： 启用 DHCPv6*
我们将跳过缺省路由定义这一步，继续进入下一屏，在那里我们将启用 “Isolated Virtual Network” 和 “Enable IPv6 internal routing/networking”。
### 虚拟机网络选择
现在，你可以配置你的虚拟机去使用新的网络。打开你的虚拟机，然后点击顶部左侧的 “i” 按钮去打开 “Show virtual hardware details” 屏幕。在 “Add Hardware” 列点击 “NIC” 按钮去打开网络选择器，然后选择你喜欢的新的 IPv6 网络。点击 “Apply”，然后重新启动。（或者使用你喜欢的方法去重新启动网络，或者更新你的 DHCP 租期。）
### 测试
`ifconfig` 告诉我们它做了什么？
```
$ ifconfig
ens3: flags=4163 UP,BROADCAST,RUNNING,MULTICAST mtu 1500
inet 192.168.30.207 netmask 255.255.255.0
broadcast 192.168.30.255
inet6 fd7d:844d:3e17:f3ae::6314
prefixlen 128 scopeid 0x0
inet6 fe80::4821:5ecb:e4b4:d5fc
prefixlen 64 scopeid 0x20
```
这是我们新的 ULA，`fd7d:844d:3e17:f3ae::6314`，它是自动生成的本地链路地址。如果你有兴趣，可以 ping 一下，ping 网络上的其它虚拟机：
```
vm1 ~$ ping6 -c2 fd7d:844d:3e17:f3ae::2c9f
PING fd7d:844d:3e17:f3ae::2c9f(fd7d:844d:3e17:f3ae::2c9f) 56 data bytes
64 bytes from fd7d:844d:3e17:f3ae::2c9f: icmp_seq=1 ttl=64 time=0.635 ms
64 bytes from fd7d:844d:3e17:f3ae::2c9f: icmp_seq=2 ttl=64 time=0.365 ms
vm2 ~$ ping6 -c2 fd7d:844d:3e17:f3ae:a:b:c:6314
PING fd7d:844d:3e17:f3ae:a:b:c:6314(fd7d:844d:3e17:f3ae:a:b:c:6314) 56 data bytes
64 bytes from fd7d:844d:3e17:f3ae:a:b:c:6314: icmp_seq=1 ttl=64 time=0.744 ms
64 bytes from fd7d:844d:3e17:f3ae:a:b:c:6314: icmp_seq=2 ttl=64 time=0.364 ms
```
当你努力去理解子网时，这是一个可以让你尝试不同地址是否可以正常工作的快速易用的方法。你可以给单个接口分配多个 IP 地址，然后 ping 它们去看一下会发生什么。在一个 ULA 中，接口，或者主机是 IP 地址的最后四部分，因此，你可以在那里做任何事情，只要它们在同一个子网中即可，在那个例子中是 `f3ae`。在我的其中一个虚拟机上，我只改变了这个示例的接口 ID，以展示使用这四个部分，你可以做任何你想做的事情：
```
vm1 ~$ sudo /sbin/ip -6 addr add fd7d:844d:3e17:f3ae:a:b:c:6314 dev ens3
vm2 ~$ ping6 -c2 fd7d:844d:3e17:f3ae:a:b:c:6314
PING fd7d:844d:3e17:f3ae:a:b:c:6314(fd7d:844d:3e17:f3ae:a:b:c:6314) 56 data bytes
64 bytes from fd7d:844d:3e17:f3ae:a:b:c:6314: icmp_seq=1 ttl=64 time=0.744 ms
64 bytes from fd7d:844d:3e17:f3ae:a:b:c:6314: icmp_seq=2 ttl=64 time=0.364 ms
```
现在，尝试使用不同的子网，在下面的示例中使用了 `f4ae` 代替 `f3ae`：
```
$ ping6 -c2 fd7d:844d:3e17:f4ae:a:b:c:6314
PING fd7d:844d:3e17:f4ae:a:b:c:6314(fd7d:844d:3e17:f4ae:a:b:c:6314) 56 data bytes
From fd7d:844d:3e17:f3ae::1 icmp_seq=1 Destination unreachable: No route
From fd7d:844d:3e17:f3ae::1 icmp_seq=2 Destination unreachable: No route
```
这也是练习路由的好机会，以后，我们将专门做一期，如何在不使用 DHCP 情况下实现自动寻址。
---
via: <https://www.linux.com/learn/intro-to-linux/2017/11/testing-ipv6-networking-kvm-part-2>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
成为你所在社区的美好力量
|
Rebecca Fernandez
|
https://opensource.com/open-organization/17/1/force-for-good-community
|
明白如何传递美好，了解积极意愿的力量，以及更多。
|
/data/attachment/album/201805/17/224122lcp16v5ipkgfuvs1.png.thumb.jpg
|
/data/attachment/album/201805/17/224122lcp16v5ipkgfuvs1.png
| true | false | true |
chao-zhi
| false |
[
"开放组织"
] |
观点
|
{
"viewnum": 3622,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
明白如何传递美好，了解积极意愿的力量，以及更多。
| 2018-05-17T22:41:00 | 2018-05-17T22:41:00 | 9,653 |
/article-9653-1.html
|
>
> 明白如何传递美好，了解积极意愿的力量，以及更多。
>
>
>
激烈的争论是开源社区和开放组织的标志特征之一。在好的时候，这些争论充满活力和建设性。他们面红耳赤的背后其实是幽默和善意。各方实事求是，共同解决问题，推动持续改进。对我们中的许多人来说，他们只是单纯的喜欢而已。
然而在那些不好的日子里，这些争论演变成了对旧话题的反复争吵。或者我们用各种方式来传递伤害和相互攻击，或是使用卑劣的手段，而这些侵蚀着我们社区的激情、信任和生产力。
我们茫然四顾，束手无策，因为社区的对话开始变得有毒。然而，正如 [DeLisa Alexander 最近的分享](https://opensource.com/business/15/5/5-ways-promote-inclusive-environment)，我们每个人都有很多方法可以成为我们社区的一种力量。
在这个“开源文化”系列的第一篇文章中，我将分享一些策略，教你如何在这个关键时刻进行干预，引导每个人走向更积极、更有效率的方向。
### 不要将人推开，而是将人推向前方
最近，我和我的朋友和同事 [Mark Rumbles](https://twitter.com/leadership_365) 一起吃午饭。多年来，我们在许多支持开源文化和引领 Red Hat 的项目中合作。在这一天，Mark 问我，他看到我最近介入了一个邮件列表的对话，当其中的辩论越来越过分时我是怎么坚持的。
幸运的是，这事早已尘埃落定，事实上我几乎忘记了谈话的内容。然而，它让我们开始讨论如何在一个拥有数千名成员的社区里，公开和坦率的辩论。
Mark 说了一些让我印象深刻的话。他说:“你知道，作为一个社区，我们真的很擅长将人推开。但我想看到的是，我们更多的是互相扶持 *向前* 。”
Mark 是绝对正确的。在我们的社区里，我们成为一种美好力量的最好的方法之一就是：以一种迫使每个人提升他们的行为的方式回应冲突，而不是使冲突升级的方式。
### 积极意愿假想
我们可以从一个简单的假想开始，当我们在一个激烈的对话中观察到不良行为时：完全有可能该不良行为其实有着积极意愿。
诚然，这不是一件容易的事情。当我看到一场辩论正在变得肮脏的迹象时，我停下来问自己，史蒂芬·科维（Steven Covey）所说的人性化问题是什么：
>
> “为什么一个理性、正直的人会做这样的事情？”
>
>
>
现在，如果他是你的一个“普通的观察对象”—— 一个有消极行为倾向的社区成员——也许你的第一个想法是，“嗯，也许这个人是个不靠谱，不理智的人”
回过头来说。我并不是说你让你自欺欺人。这其实就是人性化的问题，不仅是因为它让你理解别人的立场，它还让你变得人性化。
而这反过来又能帮助你做出反应，或者从最有效率的地方进行干预。
### 寻求了解社区异议的原因
当我再一次问自己为什么一个理性的、正直的人可能会做这样的事情时，归结为几个原因:
* 他认为没人聆听他
* 他认为没人尊重他
* 他认为没人理解他
一个简单的积极意愿假想，我们可以适用于几乎所有的不良行为，其实就是那个人想要被聆听，被尊重，或被理解。我想这是相当合理的。
通过站在这个更客观、更有同情心的角度，我们可以看到他们的行为几乎肯定 ***不会*** 帮助他们得到他们想要的东西，而社区也会因此而受到影响。如果没有我们的帮助的话。
对我来说，这激发了一个愿望：帮助每个人从我们所处的这个丑陋的地方“摆脱困境”。
在我介入之前，我问自己一个后续的问题：是否有其他积极的意图可能会驱使这种行为
容易想到的例子包括:
* 他们担心我们错过了一些重要的东西，或者我们犯了一个错误，没有人能看到它。
* 他们想感受到自己的贡献的价值。
* 他们精疲力竭，因为在社区里工作过度或者在他们的个人生活中发生了一些事情。
* 他们讨厌一些东西被破坏，并感到沮丧，因为没有人能看到造成的伤害或不便。
* ……诸如此类。
有了这些，我就有了丰富的积极的意图假想，我可以为他们的行为找到原因。我准备伸出援助之手，向他们提供一些帮助。
### 传递美好，挣脱泥潭
什么是 an out？（LCTT 译注：类似与佛家“解脱法门”的意思）把它想象成一个逃跑的门。这是一种退出对话的方式，或者放弃不良的行为，恢复表现得像一个体面的人，而不是丢面子。是叫某人振作向上，而不是叫他走开。
你可能经历过这样的事情，在你的生活中，当 *你* 在一次谈话中表现不佳时，咆哮着，大喊大叫，对某事大惊小怪，而有人慷慨地给 *你* 提供了一个台阶下。也许他们选择不去和你“抬杠”，相反，他们说了一些表明他们相信你是一个理性、正直的人，他们采用积极意愿假想，比如:
>
> 所以，嗯，我听到的是你真的很担心，你很沮丧，因为似乎没有人在听。或者你担心我们忽略了它的重要性。是这样对吧？
>
>
>
于是乎：即使这不是完全正确的（也许你的意图不那么高尚），在那一刻，你可能抓住了他们提供给你的台阶，并欣然接受了重新定义你的不良行为的机会。你几乎可以肯定地转向一个更富有成效的角度，甚至你自己可能都没有意识到。
也许你这样说，“哦，虽然不完全是这样，但我只是担心，我们这样会走向歧途，我明白你说的，作为社区，我们不能同时解决所有问题，但如果我们不尽快解决这个问题，会有更多不好的事情要发生……”
最后，谈话几乎可以肯定地开始转移到一个更有效率的方向。
我们都有机会让一个沮丧的人挣脱泥潭，而这就是方法。
### 坏行为还是坏人？
如果这个人特别激动，他们可能不会听到或者接受你给出的第一个台阶。没关系。最可能的是，他们迟钝的大脑已经被史前曾经对人类生存至关重要的杏仁体接管了，他们需要更多的时间来认识到你并不是一个威胁。只是需要你保持温和的态度，坚定地对待他们，就好像他们 *曾经是* 一个理性、正直的人，看看会发生什么。
根据我的经验，这些社区干预以三种方式结束:
大多数情况下，这个人实际上 *是* 一个理性的人，很快，他们就感激地接受了这个事实。在这个过程中，每个人都跳出了“黑与白”，“赢或输”的心态。人们开始思考创造性的选择和“双赢”的结果，每个人都将受益。
>
> 为什么一个理性、正直的人会做这样的事呢？
>
>
>
有时候，这个人天生不是特别理性或正直的，但当他被你以如此一致的、不知疲倦的、耐心的慷慨和善良的对待的时候，他们就会羞愧地从谈话中撤退。这听起来像是，“嗯，我想我已经说了所有要说的了。谢谢你听我的意见”。或者，对于不那么开明的人来说，“嗯，我厌倦了这种谈话。让我们结束吧。”（好的，谢谢）。
更少的情况是，这个人是一个“*坏人*”，或者在社区管理圈子里，是一个“搅屎棍”。这些人确实存在，而且他们在演戏方面很有发展。你猜怎么着？通过持续地以一种友善、慷慨、以社区为中心的方式，完全无视所有试图使局势升级的尝试，你有效地将谈话变成了一个对他们没有兴趣的领域。他们别无选择，只能放弃它。你成为赢家。
这就是积极意愿假想的力量。通过对愤怒和充满敌意的言辞做出回应，优雅而有尊严地回应，你就能化解一场战争，理清混乱，解决棘手的问题，而且在这个过程中很有可能会交到一个新朋友。
我每次应用这个原则都成功吗？见鬼，不会。但我从不后悔选择了积极意愿。但是我能生动的回想起，当我采用消极意愿假想时，将问题变得更糟糕的场景。
现在轮到你了。我很乐意听到你提出的一些策略和原则，当你的社区里的对话变得激烈的时候，要成为一股好力量。在下面的评论中分享你的想法。
下次，我们将探索更多的方法，在你的社区里成为一个美好力量，我将分享一些处理“坏脾气先生”的技巧。
---
作者简介：
<ruby> 丽贝卡·费尔南德斯 <rp> （ </rp> <rt> Rebecca Fernandez </rt> <rp> ） </rp></ruby>是红帽公司的首席就业品牌 + 通讯专家，是《开放组织》书籍的贡献者，也是开源决策框架的维护者。她的兴趣是开源和业务管理模型的开源方式。Twitter：@ruhbehka
---
via: <https://opensource.com/open-organization/17/1/force-for-good-community>
作者：[Rebecca Fernandez](https://opensource.com/users/rebecca) 译者：[chao-zhi](https://github.com/chao-zhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用树莓派和 projectx/os 托管你自己的电子邮件
|
Nolan Leake
|
https://opensource.com/article/18/3/host-your-own-email
|
这个开源项目可以通过低成本的服务器设施帮助你保护你的数据隐私和所有权。
|
/data/attachment/album/201805/18/120617zeoe2re6jo8eozt2.jpg.thumb.jpg
|
/data/attachment/album/201805/18/120617zeoe2re6jo8eozt2.jpg
| true | false | true |
qhwdw
| false |
[
"邮件",
"树莓派"
] |
树莓派
|
{
"viewnum": 12547,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这个开源项目可以通过低成本的服务器设施帮助你保护你的数据隐私和所有权。
| 2018-05-18T12:06:25 | 2018-05-18T12:06:25 | 9,654 |
/article-9654-1.html
|
>
> 这个开源项目可以通过低成本的服务器设施帮助你保护你的数据隐私和所有权。
>
>
>
现在有大量的理由，不能再将存储你的数据的任务委以他人之手，也不能在第三方公司运行你的服务；隐私、所有权，以及防范任何人拿你的数据去“赚钱”。但是对于大多数人来说，自己去运行一个服务器，是件即费时间又需要太多的专业知识的事情。不得已，我们只能妥协。抛开这些顾虑，使用某些公司的云服务，随之而来的就是广告、数据挖掘和售卖、以及其它可能的任何东西。
[projectx/os](https://git.sigbus.net/projectx/os) 项目就是要去除这种顾虑，它可以在家里毫不费力地做服务托管，并且可以很容易地创建一个类似于 Gmail 的帐户。实现上述目标，你只需一个 $35 的树莓派 3 和一个基于 Debian 的操作系统镜像 —— 并且不需要很多的专业知识。仅需要四步就可以实现：
1. 解压缩一个 ZIP 文件到 SD 存储卡中。
2. 编辑 SD 卡上的一个文本文件以便于它连接你的 WiFi（如果你不使用有线网络的话）。
3. 将这个 SD 卡插到树莓派 3 中。
4. 使用你的智能手机在树莓派 3 上安装 “email 服务器” 应用并选择一个二级域。
服务器应用程序（比如电子邮件服务器）被分解到多个容器中，它们中的每个都只能够使用指定的方式与外界通讯，它们使用了管理粒度非常细的隔离措施以提高安全性。例如，入站 SMTP、[SpamAssassin](http://spamassassin.apache.org/)（反垃圾邮件平台）、[Dovecot](https://www.dovecot.org/) （安全的 IMAP 服务器），以及 webmail 都使用了独立的容器，它们之间相互不能看到对方的数据，因此，单个守护进程出现问题不会波及其它的进程。
另外，它们都是无状态容器，比如 SpamAssassin 和入站 SMTP，每次收到电子邮件之后，它们的容器都会被销毁并重建，因此，即便是有人找到了 bug 并利用了它，他们也不能访问以前的电子邮件或者接下来的电子邮件；他们只能访问他们自己挖掘出漏洞的那封电子邮件。幸运的是，大多数对外发布的、最容易受到攻击的服务都是隔离的和无状态的。
所有存储的数据都使用 [dm-crypt](https://gitlab.com/cryptsetup/cryptsetup/wikis/DMCrypt) 进行加密。非公开的服务，比如 Dovecot（IMAP）或者 webmail，都是在内部监听，并使用 [ZeroTier One](https://www.zerotier.com/download.shtml) 所提供的私有的加密层叠网络，因此只有你的设备（智能手机、笔记本电脑、平板等等）才能访问它们。
虽然电子邮件并不是端到端加密的（除非你使用了 [PGP](https://en.wikipedia.org/wiki/Pretty_Good_Privacy)），但是非加密的电子邮件绝不会跨越网络，并且也不会存储在磁盘上。现在明文的电子邮件只存在于双方的私有邮件服务器上，它们都在他们的家中受到很好的安全保护并且只能通过他们的客户端访问（智能手机、笔记本电脑、平板等等）。
另一个好处就是，个人设备都使用一个密码保护（不是指纹或者其它生物识别技术），而且在你家中的设备都受到美国的 [第四宪法修正案](https://simple.wikipedia.org/wiki/Fourth_Amendment_to_the_United_States_Constitution) 的保护，比起由公司所有的第三方数据中心，它们受到更强的法律保护。当然，如果你的电子邮件使用的是 Gmail，Google 还保存着你的电子邮件的拷贝。
### 展望
电子邮件是我使用 project/os 项目打包的第一个应用程序。想像一下，一个应用程序商店有全部的服务器软件，打包起来易于安装和使用。想要一个博客？添加一个 WordPress 应用程序！想替换安全的 Dropbox ？添加一个 [Seafile](https://www.seafile.com/en/home/) 应用程序或者一个 [Syncthing](https://syncthing.net/) 后端应用程序。 [IPFS](https://ipfs.io/) 节点？ [Mastodon](https://github.com/tootsuite/mastodon) 实例？GitLab 服务器？各种家庭自动化/物联网后端服务？这里有大量的非常好的开源服务器软件 ，它们都非常易于安装，并且可以使用它们来替换那些有专利的云服务。
---
via: <https://opensource.com/article/18/3/host-your-own-email>
作者：[Nolan Leake](https://opensource.com/users/nolan) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 AppImageLauncher 轻松运行和集成 AppImage 文件
|
Logix
|
https://www.linuxuprising.com/2018/04/easily-run-and-integrate-appimage-files.html
|
你有没有下载过 AppImage 文件，而你不知道如何使用它？或许你可能知道如何使用它，但是你每次要运行它时必须要进入到下载了该 .AppImage 的文件夹中来运行它，或者手动为其创建启动程序。
|
/data/attachment/album/201805/18/122930e3crdimggjmmgi03.png.thumb.jpg
|
/data/attachment/album/201805/18/122930e3crdimggjmmgi03.png
| true | false | true |
geekpi
| false |
[
"AppImage"
] |
技术
|
{
"viewnum": 12144,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你有没有下载过 AppImage 文件，而你不知道如何使用它？或许你可能知道如何使用它，但是你每次要运行它时必须要进入到下载了该 .AppImage 的文件夹中来运行它，或者手动为其创建启动程序。
| 2018-05-18T12:28:00 | 2018-05-18T12:28:00 | 9,655 |
/article-9655-1.html
|
你有没有下载过 AppImage 文件，而你不知道如何使用它？或许你可能知道如何使用它，但是你每次要运行它时必须要进入到下载了该 .AppImage 的文件夹中来运行它，或者手动为其创建启动程序。
使用 AppImageLauncher，这些就都是过去的问题。该程序可让你轻松运行 AppImage 文件，而无需使其可执行。但它最有趣的特点是可以轻松地将 AppImage 与你的系统进行整合：AppImageLauncher 可以自动将 AppImage 程序快捷方式添加到桌面环境的程序启动器/菜单（包括程序图标和合适的说明）中。
这 里有个例子，我想在 Ubuntu 上使用 [Kdenlive](https://kdenlive.org/download/)，但我不想从仓库中安装它，因为它有大量的 KDE 依赖，我不想把它们弄到我的 Gnome 系统中。因为没有它的 Flatpak 或 Snap 镜像，我只能去下载了 Kdenlive 的 AppImage。
在没有把下载的 [Kdenline](https://kdenlive.org/download/) AppImage 变成可执行的情况下，我第一次双击它时（安装好了 AppImageLauncher），AppImageLauncher 提供了两个选项：
“Run once”或者“Integrate and run”。
点击 “Integrate and run”，这个 AppImage 就被复制到 `~/.bin/` （家目录中的隐藏文件夹）并添加到菜单中，然后启动该程序。
要删除它也很简单，只要您使用的桌面环境支持桌面动作就行。例如，在 Gnome Shell 中，只需右键单击“活动概览”中的应用程序图标，然后选择“Remove from system”：
更新：该应用只初步为 Ubuntu 和 Mint 做了开发，但它最近会提供 Debian、 Netrunner 和 openSUSE 支持。本文首次发布后添加的另一个功能是支持 AppImage 的更新；你在启动器中可以找到 “Update AppImage”。
### 下载 AppImageLauncher
AppImageLauncher 支持 Ubuntu、 Debian、Netrunner 和 openSUSE。如果你使用 Ubuntu 18.04，请确保你下载的 deb 包的名字中有“bionic”，而其它的 deb 是用于旧一些的 Ubuntu 版本的。
* [下载 AppImageLauncher](https://github.com/TheAssassin/AppImageLauncher/releases)
---
via: <https://www.linuxuprising.com/2018/04/easily-run-and-integrate-appimage-files.html>
作者：[Logix](https://plus.google.com/118280394805678839070) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy) 选题：[lujun9972](https://github.com/lujun9972)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何创建适合移动设备的文档
|
Scott Nesbitt
|
https://opensource.com/article/17/12/think-mobile
|
帮助用户在智能手机或平板上快速轻松地找到他们所需的信息。
|
/data/attachment/album/201805/18/170635a6e756r5evz033sv.jpg.thumb.jpg
|
/data/attachment/album/201805/18/170635a6e756r5evz033sv.jpg
| true | false | true |
MjSeven
| false |
[
"移动",
"文档"
] |
技术
|
{
"viewnum": 3890,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
帮助用户在智能手机或平板上快速轻松地找到他们所需的信息。
| 2018-05-18T17:06:00 | 2018-05-18T17:06:00 | 9,656 |
/article-9656-1.html
|
>
> 帮助用户在智能手机或平板上快速轻松地找到他们所需的信息。
>
>
>
我并不是完全相信[移动为先](https://www.uxmatters.com/mt/archives/2012/03/mobile-first-what-does-it-mean.php)的理念，但是我确实发现更多的人使用智能手机和平板电脑等移动设备来获取信息。这包括在线的软件和硬件文档，但它们大部分都是冗长的，不适合小屏幕。通常情况下，它的伸缩性不太好，而且很难导航。
当用户使用移动设备访问文档时，他们通常需要迅速获取信息以了解如何执行任务或解决问题，他们不想通过看似无尽的页面来寻找他们需要的特定信息。幸运的是，解决这个问题并不难。以下是一些技巧，可以帮助你构建文档以满足移动阅读器的需求。
### 简短一点
这意味着简短的句子，简短的段落和简短的流程。你不是在写一部长篇小说或一段长新闻。使你的文档简洁。尽可能使用少量的语言来获得想法和信息。
以广播新闻报道为示范：关注关键要素，用简单直接的语言对其进行解释。不要让你的读者在屏幕上看到冗长的文字。
另外，直接切入重点。关注读者需要的信息。在线发布的文档不应该像以前厚厚的手册一样。不要把所有东西都放在一个页面上，把你的信息分成更小的块。接下来是怎样做到这一点：
### 主题
在技术写作的世界里，主题是独立的，独立的信息块。每个主题都由你网站上的单个页面组成。读者应该能从特定的主题中获取他们需要的信息 -- 并且只是那些信息。要做到这一点，选择哪些主题要包含在文档中并决定如何组织它们：
### DITA
<ruby> <a href="https://en.wikipedia.org/wiki/Darwin_Information_Typing_Architecture"> 达尔文信息类型化体系结构 </a> <rt> Darwin Information Typing Architecture </rt></ruby> （DITA） 是用于编写和发布的一个 XML 模型。它[广泛采用](http://dita.xml.org/book/list-of-organizations-using-dita)在技术写作中，特别是作为较长的文档集中。
我并不是建议你将文档转换为 XML（除非你真的想）。相反，考虑将 DITA 的不同类型主题的概念应用到你的文档中：
* 一般：概述信息
* 任务：分步骤的流程
* 概念：背景或概念信息
* 参考：API 参考或数据字典等专用信息
* 术语表：定义术语
* 故障排除：有关用户可能遇到的问题以及如何解决问题的信息
你会得到很多单独的页面。要连接这些页面：
### 链接
许多内容管理系统、维基和发布框架都包含某种形式的导航 —— 通常是目录或[面包屑导航](https://en.wikipedia.org/wiki/Breadcrumb_(navigation))，这是一种在移动设备上逐渐消失的导航。
为了加强导航，在主题之间添加明确的链接。将这些链接放在每个主题末尾的“另请参阅”或“相关主题”的标题处。每个部分应包含两到五个链接，指向与当前主题相关的概述、概念和参考主题。
如果你需要指向文档集之外的信息，请确保链接在浏览器新的选项卡中打开。这将把读者送到另一个网站，同时也将读者继续留你的网站上。
这解决了文本问题，那么图片呢？
### 不使用图片
除少数情况之外，不应该加太多图片到文档中。仔细查看文档中的每个图片，然后问自己：
* 它有用吗？
* 它是否增强了文档？
* 如果删除它，读者会错过这张图片吗？
如果回答否，那么移除图片。
另一方面，如果你绝对不能没有图片，就让它变成[响应式的](https://en.wikipedia.org/wiki/Responsive_web_design)。这样，图片就会自动调整以适应更小的屏幕。
如果你仍然不确定图片是否应该出现，Opensource.com 社区版主 Ben Cotton 提供了一个关于在文档中使用屏幕截图的[极好的解释](https://opensource.com/business/15/9/when-does-your-documentation-need-screenshots)。
### 最后的想法
通过少量努力，你就可以构建适合移动设备用户的文档。此外，这些更改也改进了桌面计算机和笔记本电脑用户的文档体验。
---
via: <https://opensource.com/article/17/12/think-mobile>
作者：[Scott Nesbitt](https://opensource.com/users/chrisshort) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 局域网路由新手指南：第 1 部分
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2018/2/linux-lan-routing-beginners-part-1
|
现在我们继续深入学习 Linux 中的 IPv4 路由的基础知识。
|
/data/attachment/album/201805/19/104432ydrvfz6cqdr7q28d.jpg.thumb.jpg
|
/data/attachment/album/201805/19/104432ydrvfz6cqdr7q28d.jpg
| true | false | true |
qhwdw
| false |
[
"路由",
"IPv4",
"ipcalc"
] |
技术
|
{
"viewnum": 9378,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9675,
"displayorder": 0
},
{
"raid": 9708,
"displayorder": 0
}
] |
现在我们继续深入学习 Linux 中的 IPv4 路由的基础知识。
| 2018-05-19T10:44:37 | 2018-05-19T10:44:37 | 9,657 |
/article-9657-1.html
|
前面我们学习了 [IPv6 路由](https://www.linux.com/learn/intro-to-linux/2017/7/practical-networking-linux-admins-ipv6-routing)。现在我们继续深入学习 Linux 中的 IPv4 路由的基础知识。我们从硬件概述、操作系统和 IPv4 地址的基础知识开始，下周我们将继续学习它们如何配置，以及测试路由。
### 局域网路由器硬件
Linux 实际上是一个网络操作系统，一直都是，从一开始它就有内置的网络功能。要将你的局域网连入因特网，构建一个局域网路由器比起构建网关路由器要简单的多。你不要太过于执念安全或者防火墙规则，对于处理网络地址转换（NAT）它还是比较复杂的，NAT是 IPv4 的一个痛点。我们为什么不放弃 IPv4 去转到 IPv6 呢？这样将使网络管理员的工作更加简单。
有点跑题了。从理论上讲，你的 Linux 路由器是一个至少有两个网络接口的小型机器。Linux Gizmos 有一个很大的单板机名单：[98 个开放规格、适于黑客的 SBC 的目录](http://linuxgizmos.com/catalog-of-98-open-spec-hacker-friendly-sbcs/#catalog)。你能够使用一个很老的笔记本电脑或者台式计算机。你也可以使用一个紧凑型计算机，像 ZaReason Zini 或者 System76 Meerkat 一样，虽然这些有点贵，差不多要 $600。但是它们又结实又可靠，并且你不用在 Windows 许可证上浪费钱。
如果对路由器的要求不高，使用树莓派 3 Model B 作为路由器是一个非常好的选择。它有一个 10/100 以太网端口，板载 2.4GHz 的 802.11n 无线网卡，并且它还有四个 USB 端口，因此你可以插入多个 USB 网卡。USB 2.0 和低速板载网卡可能会让树莓派变成你的网络上的瓶颈，但是，你不能对它期望太高（毕竟它只有 $35，既没有存储也没有电源）。它支持很多种风格的 Linux，因此你可以选择使用你喜欢的版本。基于 Debian 的树莓派是我的最爱。
### 操作系统
你可以在你选择的硬件上安装将你喜欢的 Linux 的简化版，因为定制的路由器操作系统，比如 OpenWRT、 Tomato、DD-WRT、Smoothwall、Pfsense 等等，都有它们自己的非标准界面。我的观点是，没有必要这么麻烦，它们对你并没有什么帮助。尽量使用标准的 Linux 工具，因为你只需要学习它们一次就够了。
Debian 的网络安装镜像大约有 300MB 大小，并且支持多种架构，包括 ARM、i386、amd64 和 armhf。Ubuntu 的服务器网络安装镜像也小于 50MB，这样你就可以控制你要安装哪些包。Fedora、Mageia、和 openSUSE 都提供精简的网络安装镜像。如果你需要创意，你可以浏览 [Distrowatch](http://distrowatch.org/)。
### 路由器能做什么
我们需要网络路由器做什么？一个路由器连接不同的网络。如果没有路由，那么每个网络都是相互隔离的，所有的悲伤和孤独都没有人与你分享，所有节点只能孤独终老。假设你有一个 192.168.1.0/24 和一个 192.168.2.0/24 网络。如果没有路由器，你的两个网络之间不能相互沟通。这些都是 C 类的私有地址，它们每个都有 254 个可用网络地址。使用 `ipcalc` 可以非常容易地得到它们的这些信息：
```
$ ipcalc 192.168.1.0/24
Address: 192.168.1.0 11000000.10101000.00000001. 00000000
Netmask: 255.255.255.0 = 24 11111111.11111111.11111111. 00000000
Wildcard: 0.0.0.255 00000000.00000000.00000000. 11111111
=>
Network: 192.168.1.0/24 11000000.10101000.00000001. 00000000
HostMin: 192.168.1.1 11000000.10101000.00000001. 00000001
HostMax: 192.168.1.254 11000000.10101000.00000001. 11111110
Broadcast: 192.168.1.255 11000000.10101000.00000001. 11111111
Hosts/Net: 254 Class C, Private Internet
```
我喜欢 `ipcalc` 的二进制输出信息，它更加可视地表示了掩码是如何工作的。前三个八位组表示了网络地址，第四个八位组是主机地址，因此，当你分配主机地址时，你将 “掩盖” 掉网络地址部分，只使用剩余的主机部分。你的两个网络有不同的网络地址，而这就是如果两个网络之间没有路由器它们就不能互相通讯的原因。
每个八位组一共有 256 字节，但是它们并不能提供 256 个主机地址，因为第一个和最后一个值 ，也就是 0 和 255，是被保留的。0 是网络标识，而 255 是广播地址，因此，只有 254 个主机地址。`ipcalc` 可以帮助你很容易地计算出这些。
当然，这并不意味着你不能有一个结尾是 0 或者 255 的主机地址。假设你有一个 16 位的前缀：
```
$ ipcalc 192.168.0.0/16
Address: 192.168.0.0 11000000.10101000. 00000000.00000000
Netmask: 255.255.0.0 = 16 11111111.11111111. 00000000.00000000
Wildcard: 0.0.255.255 00000000.00000000. 11111111.11111111
=>
Network: 192.168.0.0/16 11000000.10101000. 00000000.00000000
HostMin: 192.168.0.1 11000000.10101000. 00000000.00000001
HostMax: 192.168.255.254 11000000.10101000. 11111111.11111110
Broadcast: 192.168.255.255 11000000.10101000. 11111111.11111111
Hosts/Net: 65534 Class C, Private Internet
```
`ipcalc` 列出了你的第一个和最后一个主机地址，它们是 192.168.0.1 和 192.168.255.254。你是可以有以 0 或者 255 结尾的主机地址的，例如，192.168.1.0 和 192.168.0.255，因为它们都在最小主机地址和最大主机地址之间。
不论你的地址块是私有的还是公共的，这个原则同样都是适用的。不要羞于使用 `ipcalc` 来帮你计算地址。
### CIDR
CIDR（无类域间路由）就是通过可变长度的子网掩码来扩展 IPv4 的。CIDR 允许对网络空间进行更精细地分割。我们使用 `ipcalc` 来演示一下：
```
$ ipcalc 192.168.1.0/22
Address: 192.168.1.0 11000000.10101000.000000 01.00000000
Netmask: 255.255.252.0 = 22 11111111.11111111.111111 00.00000000
Wildcard: 0.0.3.255 00000000.00000000.000000 11.11111111
=>
Network: 192.168.0.0/22 11000000.10101000.000000 00.00000000
HostMin: 192.168.0.1 11000000.10101000.000000 00.00000001
HostMax: 192.168.3.254 11000000.10101000.000000 11.11111110
Broadcast: 192.168.3.255 11000000.10101000.000000 11.11111111
Hosts/Net: 1022 Class C, Private Internet
```
网络掩码并不局限于整个八位组，它可以跨越第三和第四个八位组，并且子网部分的范围可以是从 0 到 3，而不是非得从 0 到 255。可用主机地址的数量并不一定是 8 的倍数，因为它是由整个八位组定义的。
给你留一个家庭作业，复习 CIDR 和 IPv4 地址空间是如何在公共、私有和保留块之间分配的，这个作业有助你更好地理解路由。一旦你掌握了地址的相关知识，配置路由器将不再是件复杂的事情了。
从 [理解 IP 地址和 CIDR 图表](https://www.ripe.net/about-us/press-centre/understanding-ip-addressing)、[IPv4 私有地址空间和过滤](https://www.arin.net/knowledge/address_filters.html)、以及 [IANA IPv4 地址空间注册](https://www.iana.org/assignments/ipv4-address-space/ipv4-address-space.xhtml) 开始。接下来的我们将学习如何创建和管理路由器。
通过来自 Linux 基金会和 edX 的免费课程 [“Linux 入门”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)学习更多 Linux 知识。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/2/linux-lan-routing-beginners-part-1>
作者：[Carla Schroder](https://www.linux.com/users/cschroder) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用交互式 shell 来增强你的 Python
|
Clément Verna
|
https://fedoramagazine.org/enhance-python-interactive-shell/
|
本文将介绍 Fedora 软件包集合中提供的一些有用的 Python shell 来简化开发。
|
/data/attachment/album/201805/19/205244xkk5ilwhk7yt5h77.jpg.thumb.jpg
|
/data/attachment/album/201805/19/205244xkk5ilwhk7yt5h77.jpg
| true | false | true |
geekpi
| false |
[
"Python",
"shell"
] |
技术
|
{
"viewnum": 8962,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文将介绍 Fedora 软件包集合中提供的一些有用的 Python shell 来简化开发。
| 2018-05-19T20:52:40 | 2018-05-19T20:52:40 | 9,658 |
/article-9658-1.html
|
Python 编程语言已经成为 IT 中使用的最流行的语言之一。成功的一个原因是它可以用来解决各种问题。从网站开发到数据科学、机器学习到任务自动化，Python 生态系统有丰富的框架和库。本文将介绍 Fedora 软件包集合中提供的一些有用的 Python shell 来简化开发。
### Python Shell
Python Shell 让你以交互模式使用解释器。这在测试代码或尝试新库时非常有用。在 Fedora 中，你可以通过在终端会话中输入 `python3` 来调用默认的 shell。虽然 Fedora 提供了一些更高级和增强的 shell。
### IPython
IPython 为 Python shell 提供了许多有用的增强功能。例如包括 tab 补全，对象内省，系统 shell 访问和命令历史检索。许多功能也被 [Jupyter Notebook](https://ipython.org/notebook.html) 使用，因为它底层使用 IPython。
#### 安装和运行 IPython
```
dnf install ipython3
ipython3
```
使用 tab 补全会提示你可能的选择。当你使用不熟悉的库时，此功能会派上用场。
如果你需要更多信息，输入 `?` 命令来查看文档。对此的更多详细信息，你可以使用 `??` 命令。
另一个很酷的功能是使用 `!` 字符执行系统 shell 命令的能力。然后可以在 IPython shell 中引用该命令的结果。
IPython 完整的功能列表可在[官方文档](https://ipython.readthedocs.io/en/stable/overview.html#main-features-of-the-interactive-shell)中找到。
### bpython
bpython 并不能像 IPython 做那么多，但它却在一个简单的轻量级包中提供了一系列有用功能。除其他功能之外，bpython 提供：
* 内嵌语法高亮显示
* 在你输入时提供自动补全建议
* 可预期的参数列表
* 能够将代码发送或保存到 pastebin 服务或文件中
#### 安装和运行 bpython
```
dnf install bpython3
bpython3
```
在你输入的时候，`bpython` 为你提供了选择来自动补全你的代码。
当你调用函数或方法时，会自动显示需要的参数和文档字符串。
另一个很好的功能是可以使用功能键 `F7` 在外部编辑器（默认为 Vim）中打开当前的 `bpython` 会话。这在测试更复杂的程序时非常有用。
有关配置和功能的更多细节，请参考 bpython [文档](https://docs.bpython-interpreter.org/)。
### 总结
使用增强的 Python shell 是提高生产力的好方法。它为你提供增强的功能来编写快速原型或尝试新库。你在使用增强的 Python shell 吗？请随意在评论区留言。
图片由 [David Clode](https://unsplash.com/photos/d0CasEMHDQs?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) 在 [Unsplash](https://unsplash.com/search/photos/python?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) 上发布
---
via: <https://fedoramagazine.org/enhance-python-interactive-shell/>
作者：[Clément Verna](https://fedoramagazine.org/author/cverna/) 选题：[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/) 荣誉推出
|
||
如何使用 Ansible 打补丁以及安装应用
|
Jonathan Lozada De La Matta
|
https://opensource.com/article/18/3/ansible-patch-systems
|
使用 Ansible IT 自动化引擎节省更新的时间。
|
/data/attachment/album/201805/20/035937k1jc6t90wi80je66.jpg.thumb.jpg
|
/data/attachment/album/201805/20/035937k1jc6t90wi80je66.jpg
| true | false | true |
HankChow
| false |
[
"Ansible"
] |
系统运维
|
{
"viewnum": 6960,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用 Ansible IT 自动化引擎节省更新的时间。
| 2018-05-20T03:59:00 | 2018-05-20T03:59:00 | 9,659 |
/article-9659-1.html
|
>
> 使用 Ansible IT 自动化引擎节省更新的时间。
>
>
>
你有没有想过，如何打补丁、重启系统，然后继续工作？
如果你的回答是肯定的，那就需要了解一下 [Ansible](https://www.ansible.com/overview/how-ansible-works) 了。它是一个配置管理工具，对于一些复杂的有时候需要几个小时才能完成的系统管理任务，又或者对安全性有比较高要求的时候，使用 Ansible 能够大大简化工作流程。
以我作为系统管理员的经验，打补丁是一项最有难度的工作。每次遇到<ruby> 公共漏洞批露 <rt> Common Vulnearbilities and Exposure </rt></ruby>（CVE）通知或者<ruby> 信息保障漏洞预警 <rt> Information Assurance Vulnerability Alert </rt></ruby>（IAVA）时都必须要高度关注安全漏洞，否则安全部门将会严肃追究自己的责任。
使用 Ansible 可以通过运行[封装模块](https://docs.ansible.com/ansible/latest/list_of_packaging_modules.html)以缩短打补丁的时间，下面以 [yum 模块](https://docs.ansible.com/ansible/latest/yum_module.html)更新系统为例，使用 Ansible 可以执行安装、更新、删除、从其它地方安装（例如持续集成/持续开发中的 `rpmbuild`）。以下是系统更新的任务：
```
- name: update the system
yum:
name: "*"
state: latest
```
在第一行，我们给这个任务命名，这样可以清楚 Ansible 的工作内容。第二行表示使用 `yum` 模块在CentOS虚拟机中执行更新操作。第三行 `name: "*"` 表示更新所有程序。最后一行 `state: latest` 表示更新到最新的 RPM。
系统更新结束之后，需要重新启动并重新连接：
```
- name: restart system to reboot to newest kernel
shell: "sleep 5 && reboot"
async: 1
poll: 0
- name: wait for 10 seconds
pause:
seconds: 10
- name: wait for the system to reboot
wait_for_connection:
connect_timeout: 20
sleep: 5
delay: 5
timeout: 60
- name: install epel-release
yum:
name: epel-release
state: latest
```
`shell` 模块中的命令让系统在 5 秒休眠之后重新启动，我们使用 `sleep` 来保持连接不断开，使用 `async` 设定最大等待时长以避免发生超时，`poll` 设置为 0 表示直接执行不需要等待执行结果。暂停 10 秒钟以等待虚拟机恢复，使用 `wait_for_connection` 在虚拟机恢复连接后尽快连接。随后由 `install epel-release` 任务检查 RPM 的安装情况。你可以对这个剧本执行多次来验证它的幂等性，唯一会显示造成影响的是重启操作，因为我们使用了 `shell` 模块。如果不想造成实际的影响，可以在使用 `shell` 模块的时候 `changed_when: False`。
现在我们已经知道如何对系统进行更新、重启虚拟机、重新连接、安装 RPM 包。下面我们通过 [Ansible Lightbulb](https://github.com/ansible/lightbulb/tree/master/examples/nginx-role) 来安装 NGINX:
```
- name: Ensure nginx packages are present
yum:
name: nginx, python-pip, python-devel, devel
state: present
notify: restart-nginx-service
- name: Ensure uwsgi package is present
pip:
name: uwsgi
state: present
notify: restart-nginx-service
- name: Ensure latest default.conf is present
template:
src: templates/nginx.conf.j2
dest: /etc/nginx/nginx.conf
backup: yes
notify: restart-nginx-service
- name: Ensure latest index.html is present
template:
src: templates/index.html.j2
dest: /usr/share/nginx/html/index.html
- name: Ensure nginx service is started and enabled
service:
name: nginx
state: started
enabled: yes
- name: Ensure proper response from localhost can be received
uri:
url: "http://localhost:80/"
return_content: yes
register: response
until: 'nginx_test_message in response.content'
retries: 10
delay: 1
```
以及用来重启 nginx 服务的操作文件：
```
# 安装 nginx 的操作文件
- name: restart-nginx-service
service:
name: nginx
state: restarted
```
在这个角色里，我们使用 RPM 安装了 `nginx`、`python-pip`、`python-devel`、`devel`，用 PIP 安装了 `uwsgi`，接下来使用 `template` 模块复制 `nginx.conf` 和 `index.html` 以显示页面，并确保服务在系统启动时启动。然后就可以使用 `uri` 模块检查到页面的连接了。
这个是一个系统更新、系统重启、安装 RPM 包的剧本示例，后续可以继续安装 nginx，当然这里可以替换成任何你想要的角色和应用程序。
```
- hosts: all
roles:
- centos-update
- nginx-simple
```
这只是关于如何更新系统、重启以及后续工作的示例。简单起见，我只添加了不带[变量](https://docs.ansible.com/ansible/latest/playbooks_variables.html)的包，当你在操作大量主机的时候，你就需要修改其中的一些设置了：
* [async & poll](https://docs.ansible.com/ansible/latest/playbooks_async.html)
* [serial](https://docs.ansible.com/ansible/latest/playbooks_delegation.html#rolling-update-batch-size)
* [forks](https://docs.ansible.com/ansible/latest/intro_configuration.html#forks)
这是由于在生产环境中如果你想逐一更新每一台主机的系统，你需要花相当一段时间去等待主机重启才能够继续下去。
---
via: <https://opensource.com/article/18/3/ansible-patch-systems>
作者：[Jonathan Lozada De La Matta](https://opensource.com/users/jlozadad) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何改善应用程序在 Linux 中的启动时间
|
Sk
|
https://www.ostechnix.com/how-to-improve-application-startup-time-in-linux/
|
大多数 Linux 发行版在默认配置下已经足够快了。但是，我们仍然可以借助一些额外的应用程序和方法让它们启动更快一点。
|
/data/attachment/album/201805/20/112221y4azq4onand1q4aa.png.thumb.jpg
|
/data/attachment/album/201805/20/112221y4azq4onand1q4aa.png
| true | false | true |
qhwdw
| false |
[
"Preload"
] |
分享
|
{
"viewnum": 4458,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
大多数 Linux 发行版在默认配置下已经足够快了。但是，我们仍然可以借助一些额外的应用程序和方法让它们启动更快一点。
| 2018-05-20T11:22:19 | 2018-05-20T11:22:19 | 9,660 |
/article-9660-1.html
|
大多数 Linux 发行版在默认配置下已经足够快了。但是，我们仍然可以借助一些额外的应用程序和方法让它们启动更快一点。其中一个可用的这种应用程序就是 Preload。它监视用户使用频率比较高的应用程序，并将它们添加到内存中，这样就比一般的方式加载更快一点。因为，正如你所知道的，内存的读取速度远远快于硬盘。Preload 以守护进程的方式在后台中运行，并记录用户使用较为频繁的程序的文件使用相关的统计数据。然后，它将这些二进制文件及它们的依赖项加载进内存，以改善应用程序的加载时间。简而言之，一旦安装了 Preload，你使用较为频繁的应用程序将可能加载的更快。
在这篇详细的教程中，我们将去了解如何安装和使用 Preload，以改善应用程序在 Linux 中的启动时间。
### 在 Linux 中使用 Preload 改善应用程序启动时间
Preload 可以在 [AUR](https://aur.archlinux.org/packages/preload/) 上找到。因此，你可以使用 AUR 助理程序在任何基于 Arch 的系统上去安装它，比如，Antergos、Manjaro Linux。
使用 [Pacaur](https://www.ostechnix.com/install-pacaur-arch-linux/)：
```
$ pacaur -S preload
```
使用 [Packer](https://www.ostechnix.com/install-packer-arch-linux-2/)：
```
$ packer -S preload
```
使用 [Trizen](https://www.ostechnix.com/trizen-lightweight-aur-package-manager-arch-based-systems/)：
```
$ trizen -S preload
```
使用 [Yay](https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/)：
```
$ yay -S preload
```
使用 [Yaourt](https://www.ostechnix.com/install-yaourt-arch-linux/)：
```
$ yaourt -S preload
```
在 Debian、Ubuntu、Linux Mint 上，Preload 可以在默认仓库中找到。因此，你可以像下面一样，使用 APT 包管理器去安装它。
```
$ sudo apt-get install preload
```
Preload 安装完成后，重新启动你的系统。从现在开始，Preload 将监视频繁使用的应用程序，并将它们的二进制文件和库添加到内存中，以使它的启动速度更快。比如，如果你经常使用 Firefox、Chrome 以及 LibreOffice，Preload 将添加这些二进制文件和库到内存中，因此，这些应用程序将启动的更快。而且更好的是，它不需要做任何配置。它是开箱即用的。但是，如果你想去对它进行微调，你可以通过编辑缺省的配置文件 `/etc/preload.conf` 来实现。
### Preload 并不一定适合每个人！
以下是 Preload 的一些缺点，它并不是对每个人都有帮助，在这个 [跟贴](https://askubuntu.com/questions/110335/drawbacks-of-using-preload-why-isnt-it-included-by-default) 中有讨论到。
1. 我使用的是一个有 8GB 内存的现代系统。因此，我的系统总体上来说很快。我每天只打开狂吃内存的应用程序（比如，Firefox、Chrome、VirtualBox、Gimp 等等）一到两次，并且它们始终处于打开状态，因此，它们的二进制文件和库被预读到内存中，并始终整天在内存中。我一般很少去关闭和打开这些应用程序，因此，内存使用纯属浪费。
2. 如果你使用的是带有 SSD 的现代系统，Preload 是绝对没用的。因为 SSD 的访问时间比起一般的硬盘来要快的多，因此，使用 Preload 是没有意义的。
3. Preload 显著影响启动时间。因为更多的应用程序要被预读到内存中，这将让你的系统启动运行时间更长。
你只有在每天都在大量的重新加载应用程序时，才能看到真正的差别。因此，Preload 最适合开发人员和测试人员，他们每天都打开和关闭应用程序好多次。
关于 Preload 更多的信息和它是如何工作的，请阅读它的作者写的完整版的 [Preload 论文](https://cs.uwaterloo.ca/%7Ebrecht/courses/702/Possible-Readings/prefetching-to-memory/preload-thesis.pdf)。
教程到此为止，希望能帮到你。后面还有更精彩的内容，请继续关注！
再见！
---
via: <https://www.ostechnix.com/how-to-improve-application-startup-time-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 Buildah 构建容器镜像
|
Ashutosh Sudhakar Bhakare
|
https://fedoramagazine.org/daemon-less-container-management-buildah/
|
Buildah 处理构建容器镜像时无需安装完整的容器运行时或守护进程。这对建立容器的持续集成和持续交付管道尤其有用。
|
/data/attachment/album/201805/21/071923ewuygn5g3vggjf3n.png.thumb.jpg
|
/data/attachment/album/201805/21/071923ewuygn5g3vggjf3n.png
| true | false | true |
geekpi
| false |
[
"Buildah",
"容器"
] |
容器与云
|
{
"viewnum": 5725,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Buildah 处理构建容器镜像时无需安装完整的容器运行时或守护进程。这对建立容器的持续集成和持续交付管道尤其有用。
| 2018-05-21T07:19:18 | 2018-05-21T07:19:18 | 9,661 |
/article-9661-1.html
|
Project Atomic 通过他们在 Open Container Initiative（OCI）上的努力创造了一个名为 [Buildah](https://github.com/projectatomic/buildah) 的伟大工具。Buildah 能帮助创建、构建和更新，它支持 Docker 容器镜像以及 OCI 兼容镜像。
Buildah 处理构建容器镜像时无需安装完整的容器运行时或守护进程。这对建立容器的持续集成和持续交付管道尤其有用。
Buildah 使容器的文件系统可以直接供构建主机使用。这意味着构建工具在主机上可用就行，而不需要在容器镜像中可用，从而使构建更快速，镜像更小，更安全。Buildah 有 CentOS、Fedora 和 Debian 的软件包。
### 安装 Buildah
从 Fedora 26 开始 Buildah 可以使用 `dnf` 进行安装。
```
$ sudo dnf install buildah -y
```
`buildah` 的当前版本为 0.16，可以通过以下命令显示。
```
$ buildah --version
```
### 基本命令
构建容器镜像的第一步是获取基础镜像，这是通过 Dockerfile 中的 `FROM` 语句完成的。Buildah 以类似的方式处理这个。
```
$ sudo buildah from fedora
```
该命令将拉取 Fedora 的基础镜像并存储在主机上。通过执行以下操作可以检查主机上可用的镜像。
```
$ sudo buildah images
IMAGE ID IMAGE NAME CREATED AT SIZE
9110ae7f579f docker.io/library/fedora:latest Mar 7, 2018 20:51 234.7 MB
```
在拉取基础镜像后，有一个该镜像的运行容器实例，这是一个“工作容器”。
以下命令显示正在运行的容器。
```
$ sudo buildah containers
CONTAINER ID BUILDER IMAGE ID IMAGE NAME
CONTAINER NAME
6112db586ab9 * 9110ae7f579f docker.io/library/fedora:latest fedora-working-container
```
Buildah 还提供了一个非常有用的命令来停止和删除当前正在运行的所有容器。
```
$ sudo buildah rm --all
```
完整的命令列表可以使用 `--help` 选项。
```
$ buildah --help
```
### 构建一个 Apache Web 服务器容器镜像
让我们看看如何使用 Buildah 在 Fedora 基础镜像上安装 Apache Web 服务器，然后复制一个可供服务的自定义 `index.html`。
首先让我们创建自定义的 `index.html`。
```
$ echo "Hello Fedora Magazine !!!" > index.html
```
然后在正在运行的容器中安装 httpd 包。
```
$ sudo buildah from fedora
$ sudo buildah run fedora-working-container dnf install httpd -y
```
让我们将 `index.html` 复制到 `/var/www/html/`。
```
$ sudo buildah copy fedora-working-container index.html /var/www/html/index.html
```
然后配置容器入口点以启动 httpd。
```
$ sudo buildah config --entrypoint "/usr/sbin/httpd -DFOREGROUND" fedora-working-container
```
现在为了使“工作容器”可用，`commit` 命令将容器保存到镜像。
```
$ sudo buildah commit fedora-working-container hello-fedora-magazine
```
hello-fedora-magazine 镜像现在可用，并且可以推送到仓库以供使用。
```
$ sudo buildah images
IMAGE ID IMAGE NAME CREATED
AT SIZE
9110ae7f579f docker.io/library/fedora:latest
Mar 7, 2018 22:51 234.7 MB
49bd5ec5be71 docker.io/library/hello-fedora-magazine:latest
Apr 27, 2018 11:01 427.7 MB
```
通过运行以下步骤，还可以使用 Buildah 来测试此镜像。
```
$ sudo buildah from --name=hello-magazine docker.io/library/hello-fedora-magazine
$ sudo buildah run hello-magazine
```
访问 <http://localhost> 将显示 “Hello Fedora Magazine !!!”
---
via: <https://fedoramagazine.org/daemon-less-container-management-buildah/>
作者：[Ashutosh Sudhakar Bhakare](https://fedoramagazine.org/author/ashutoshbhakare/) 选题：[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 的人
|
Lucy Benton
|
https://linuxaria.com/article/useful-resources-for-those-who-want-to-know-more-about-linux
|
为了帮助你，我们为那些想要了解更多关于 Linux 的人收集了 5 个有用的资源。
|
/data/attachment/album/201805/21/073426vdpz8p3xdnjejlrp.png.thumb.jpg
|
/data/attachment/album/201805/21/073426vdpz8p3xdnjejlrp.png
| true | false | true |
MjSeven
| false |
[
"Linux"
] |
分享
|
{
"viewnum": 7666,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
为了帮助你，我们为那些想要了解更多关于 Linux 的人收集了 5 个有用的资源。
| 2018-05-21T07:34:00 | 2018-05-21T07:34:00 | 9,662 |
/article-9662-1.html
|
Linux 是最流行和多功能的操作系统之一，它可以用在智能手机，电脑甚至汽车上。自 20 世纪 90 年代以来，Linux 存在至今，并且仍然是最普遍的操作系统之一。
Linux 实际上用于运行大多数网络服务，因为与其他操作系统相比，它被认为是相当稳定的。这是[人们选择 Linux 多于 Windows 的原因](https://www.lifewire.com/windows-vs-linux-mint-2200609)之一。此外，Linux 为用户提供了隐私，根本不收集用户信息，而 Windows 10 及其 Cortana 语音控制系统总是需要更新你的个人信息。
Linux 有很多优点。然而，人们并没有听到太多关于它的消息，因为它已被 Windows 和 Mac 挤出（桌面）场。许多人开始使用 Linux 时会感到困惑，因为它与流行的操作系统有点不同。
为了帮助你，我们为那些想要了解更多关于 Linux 的人收集了 5 个有用的资源。
### 1、[Linux 纯新手](https://www.eduonix.com/courses/system-programming/linux-for-absolute-beginners)
如果你想尽可能多地学习 Linux，你应该考虑 Eduonix 为[初学者提供的 Linux 完整教程](https://www.eduonix.com/courses/system-programming/linux-for-absolute-beginners)。这个课程将向你介绍 Linux 的所有功能，并为你提供所有必要的资料，以帮助你了解更多关于 Linux 工作原理的特性。
如果你是以下情况，你应该选择本课程：
* 你想了解有关 Linux 操作系统的详细信息；
* 你想知道如何安装它；
* 你想了解 Linux 如何与硬件配合使用；
* 你想学习如何操作 Linux 命令行。
### 2、[PC World: Linux 初学者指南](https://www.pcworld.com/article/2918397/operating-systems/how-to-get-started-with-linux-a-beginners-guide.html)
为想要在一个地方学习所有有关 Linux 的人提供[免费资源](https://www.pcworld.com/article/2918397/operating-systems/how-to-get-started-with-linux-a-beginners-guide.html)。PC World 专注于计算机操作系统的各个方面，并为订阅用户提供最准确和最新的信息。在这里，你还可以了解更多关于 [Linux 的好处](https://www.popsci.com/switch-to-linux-operating-system#page-4) 和关于其操作系统的最新消息。
该资源为你提供以下信息：
* 如何安装 Linux；
* 如何使用命令行；
* 如何安装软件；
* 如何操作 Linux 桌面环境。
### 3、[Linux.com：Linux 培训](https://www.linux.com/learn/training)
很多使用计算机的人都需要学习如何操作 Linux，以防 Windows 操作系统突然崩溃。还有什么比使用官方资源来启动你的 [Linux 培训](https://www.linux.com/learn/training)更好呢？
该资源可用让你在线注册 Linux 训练，你可以从官方来源获取最新信息。“一年前，我们的 IT 部门在官方网站上为我们提供了 Linux 培训” [Assignmenthelper.com.au](https://www.assignmenthelper.com.au/) 的开发人员 Martin Gibson 说道。“我们选择了这门课，因为我们需要学习如何将我们的所有文件备份到另一个系统，为我们的客户提供最大的安全性，而且这个资源真的教会了我们所有的东西。”
所以你肯定应该使用这个资源，如果：
* 你想获得有关操作系统的第一手信息；
* 想要了解如何在你的计算机上运行 Linux 的特性；
* 想要与其他 Linux 用户联系并与他们分享你的经验。
### 4、 [Linux 基金会：视频培训](https://training.linuxfoundation.org/free-linux-training/linux-training-videos)
如果你在阅读大量资源时容易感到无聊，那么该网站绝对适合你。Linux 基金会提供了由 IT 专家、软件开发技术人员和技术顾问举办的[视频培训](https://training.linuxfoundation.org/free-linux-training/linux-training-videos)，讲座和在线研讨会。
所有培训视频分为以下类别：
* 开发人员： 使用 Linux 内核来处理 Linux 设备驱动程序、Linux 虚拟化等；
* 系统管理员：在 Linux 上开发虚拟主机，构建防火墙，分析 Linux 性能等；
* 用户：Linux 入门，介绍嵌入式 Linux 等。
### 5、 [LinuxInsider](https://www.linuxinsider.com/)
你知道吗？微软对 Linux 的效率感到惊讶，它[允许用户在微软云计算设备上运行 Linux](https://www.wired.com/2016/08/linux-took-web-now-taking-world/)。如果你想了解更多关于 Linux 操作系统的知识，[Linux Insider](https://www.linuxinsider.com/) 会向用户提供关于 Linux 操作系统的最新消息，以及最新更新和 Linux 特性的信息。
在此资源上，你将有机会：
* 参与 Linux 社区；
* 了解如何在各种设备上运行 Linux；
* 看看评论；
* 参与博客讨论并阅读科技博客。
### 总结一下
Linux 提供了很多好处，包括完全的隐私，稳定的操作甚至恶意软件保护。它绝对值得尝试，学习如何使用会帮助你更好地了解你的计算机如何工作以及它需要如何平稳运行。
### 关于作者
Lucy Benton 是一位数字营销专家，商业顾问，帮助人们将他们的梦想变为有利润的业务。现在她正在为营销和商业资源撰写。Lucy 还有自己的博客 [*Prowritingpartner.com*](https://prowritingpartner.com/)，在那里你可以查看她最近发表的文章。
---
via: <https://linuxaria.com/article/useful-resources-for-those-who-want-to-know-more-about-linux>
作者：[Lucy Benton](https://www.lifewire.com) 选题：[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/) 荣誉推出
|
||
一个可以更好地调试的 Perl 模块
|
Ruth Holloway
|
https://opensource.com/article/18/4/perl-module-debugging-code
|
这个简单优雅的模块可以让你包含调试或仅用于开发环境的代码，而在产品环境中隐藏它们。
|
/data/attachment/album/201805/21/075502mmzlyfwlllbb1ffl.jpg.thumb.jpg
|
/data/attachment/album/201805/21/075502mmzlyfwlllbb1ffl.jpg
| true | false | true |
geekpi
| false |
[
"Perl",
"调试"
] |
软件开发
|
{
"viewnum": 4235,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这个简单优雅的模块可以让你包含调试或仅用于开发环境的代码，而在产品环境中隐藏它们。
| 2018-05-21T07:55:10 | 2018-05-21T07:55:10 | 9,663 |
/article-9663-1.html
|
>
> 这个简单优雅的模块可以让你包含调试或仅用于开发环境的代码，而在产品环境中隐藏它们。
>
>
>
仅用于调试或开发调整时的 Perl 代码块有时会很有用。这很好，但是这样的代码块可能会对性能产生很大的影响, 尤其是在运行时才决定是否执行它。
[Curtis "Ovid" Poe](https://metacpan.org/author/OVID) 最近编写了一个可以帮助解决这个问题的模块：[Keyword::DEVELOPMENT](https://metacpan.org/pod/release/OVID/Keyword-DEVELOPMENT-0.04/lib/Keyword/DEVELOPMENT.pm)。该模块利用 `Keyword::Simple` 和 Perl 5.012 中引入的可插入关键字架构来创建了新的关键字：`DEVELOPMENT`。它使用 `PERL_KEYWORD_DEVELOPMENT` 环境变量的值来确定是否要执行一段代码。
使用它不能更容易了：
```
use Keyword::DEVELOPMENT;
sub doing_my_big_loop {
my $self = shift;
DEVELOPMENT {
# insert expensive debugging code here!
}
}
```
在编译时，`DEVELOPMENT` 块内的代码已经被优化掉了，根本就不存在。
你看到好处了么？在沙盒中将 `PERL_KEYWORD_DEVELOPMENT` 环境变量设置为 `true`，在生产环境设为 `false`，并且可以将有价值的调试工具提交到你的代码库中，在你需要的时候随时可用。
在缺乏高级配置管理的系统中，你也可以使用此模块来处理生产和开发或测试环境之间的设置差异：
```
sub connect_to_my_database {
my $dsn = "dbi:mysql:productiondb";
my $user = "db_user";
my $pass = "db_pass";
DEVELOPMENT {
# Override some of that config information
$dsn = "dbi:mysql:developmentdb";
}
my $db_handle = DBI->connect($dsn, $user, $pass);
}
```
稍后对此代码片段的增强使你能在其他地方，比如 YAML 或 INI 中读取配置信息，但我希望您能在此看到该工具。
我查看了关键字 `Keyword::DEVELOPMENT` 的源码，花了大约半小时研究，“天哪，我为什么没有想到这个？”安装 `Keyword::Simple` 后，Curtis 给我们的模块就非常简单了。这是我长期以来在自己的编码实践中所需要的一个优雅解决方案。
---
via: <https://opensource.com/article/18/4/perl-module-debugging-code>
作者：[Ruth Holloway](https://opensource.com/users/druthb) 选题：[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/) 荣誉推出
|
||
Jupyter Notebooks 入门
|
Don Watkins
|
https://opensource.com/article/18/3/getting-started-jupyter-notebooks
|
通过 Jupyter 使用实时代码、方程式和可视化及文本创建交互式的共享笔记本。
|
/data/attachment/album/201805/21/082420s8r3azrm38op8b1n.png.thumb.jpg
|
/data/attachment/album/201805/21/082420s8r3azrm38op8b1n.png
| true | false | true |
MjSeven
| false |
[
"Jupyter",
"IPython",
"笔记"
] |
分享
|
{
"viewnum": 9252,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过 Jupyter 使用实时代码、方程式和可视化及文本创建交互式的共享笔记本。
| 2018-05-21T08:24:16 | 2018-05-21T08:24:16 | 9,664 |
/article-9664-1.html
|
>
> 通过 Jupyter 使用实时代码、方程式和可视化及文本创建交互式的共享笔记本。
>
>
>
自从有了纸莎草纸以来，出版人们一直在努力以吸引读者的方式来格式化数据。尤其是在数学、科学、和编程领域，设计良好的图表、插图和方程式可以成为帮助人们理解技术信息的关键。
[Jupyter Notebook](http://jupyter.org/) 通过重新构想我们如何制作教学文本来解决这个问题。Jupyter （我在 2017 年 10 月在 [All Things Open](https://allthingsopen.org/) 上首次了解到）是一款开源应用程序，它使用户能够创建包含实时代码、方程式、可视化和文本的交互式共享笔记本。
Jupyter 从 [IPython 项目](http://ipython.org/)发展而来，它是个具有交互式 shell 和基于浏览器的笔记本，支持代码、文本和数学表达式。Jupyter 支持超过 40 种编程语言，包括 Python、R 和 Julia，其代码可以导出为 HTML、LaTeX、PDF、图像和视频，或者作为 [IPyhton](https://en.wikipedia.org/wiki/IPython) 笔记本与其他用户共享。
>
> 一个有趣的事实是：“Jupyter” 是 “Julia、Python 和 R” 的缩写。
>
>
>
根据 Jupyter 项目网站介绍，它的一些用途包括“数据清理和转换，数值模拟，统计建模，数据可视化，机器学习等等”。科学机构正在使用 Jupyter Notebooks 来解释研究结果。代码可以来自实际数据，可以调整和重新调整以可视化成不同的结果和情景。通过这种方式，Jupyter Notebooks 变成了生动的文本和报告。
### 安装并开始 Jupyter
Jupyter 软件是开源的，其授权于[修改过的 BSD 许可证](https://opensource.org/licenses/BSD-3-Clause)，它可以[安装在 Linux、MacOS 或 Windows 上](http://jupyter.org/install.html)。有很多种方法可以安装 Jupyter；我在 Linux 和 MacOS 上试过 PIP 和 [Anaconda](https://www.anaconda.com/download/#linux) 安装方式。PIP 安装要求你的计算机上已经安装了 Python；Jupyter 推荐 Python 3。
由于 Python 3 已经安装在我的电脑上，我通过在终端（在 Linux 或 Mac 上）运行以下命令来安装 Jupyter：
```
$ python3 -m pip install --upgrade pip
$ python3 -m pip install jupyter
```
在终端提示符输入以下命令立即启动应用程序：
```
$ jupyter notebook
```
很快，我的浏览器打开并显示了我在 `http://localhost:8888` 的 Jupyter Notebook 服务器。（支持的浏览器有 Google Chrome、Firefox 和 Safari）
在右上角有一个标有 “New” 的下拉菜单，它使我能够根据自己的指示和代码快速创建新的笔记本。请注意，我的新笔记本默认为 Python 3，这是我目前的环境。
一个带有一些默认值的新笔记本，它可以被改变（包括笔记本的名字），已打开。
笔记本有两种不同的模式：“命令模式”和“编辑模式”。命令模式允许你添加或删除单元格。你可以通过按下 `Escape` 键进入命令模式，按 `Enter` 键或单击单元格进入编辑模式。
单元格周围的绿色高亮显示你处于编辑模式，蓝色高亮显示你处于命令模式。以下笔记本处于命令模式并准备好执行单元中的 Python 代码。注意，我已将笔记本的名称更改为 “First Notebook”。
### 使用 Jupyter
Jupyter Notebooks 的强大之处在于除了能够输入代码之外，你还可以用 Markdown 添加叙述性和解释性文本。我想添加一个标题，所以我在代码上面添加了一个单元格，并以 Markdown 输入了一个标题。当我按下 `Ctrl+Enter` 时，我的标题转换为 HTML。（LCTT 译注：或者可以按下 Run 按钮。）
我可以通过在命令前追加 `!` 来添加 Bash 命令或脚本的输出。
我也可以利用 IPython 的 [line magic 和 cell magic](http://ipython.readthedocs.io/en/stable/interactive/magics.html) 命令。你可以通过在代码单元内附加 `%` 或 `%%` 符号来列出魔术命令。例如，`%lsmagic` 将输出所有可用于 Jupyter notebooks 的魔法命令。
这些魔术命令的例子包括 `%pwd`——它输出当前工作目录（例如 `/Users/YourName`）和 `%ls`——它列出当前工作目录中的所有文件和子目录。另一个神奇命令显示从笔记本中的 `matplotlib` 生成的图表。`%%html` 将该单元格中的任何内容呈现为 HTML，这对嵌入视频和链接很有用，还有 JavaScript 和 Bash 的单元魔术命令。
如果你需要更多关于使用 Jupyter Notebooks 和它的特性的信息，它的帮助部分是非常完整的。
人们用许多有趣的方式使用 Jupyter Notebooks；你可以在这个[展示栏目](https://github.com/jupyter/jupyter/wiki/a-gallery-of-interesting-jupyter-notebooks#mathematics)里找到一些很好的例子。你如何使用 Jupyter 笔记本？请在下面的评论中分享你的想法。
---
via: <https://opensource.com/article/18/3/getting-started-jupyter-notebooks>
作者：[Don Watkins](https://opensource.com/users/don-watkins) 选题：[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/) 荣誉推出
|
||
如何编译 Linux 内核
|
Jack Wallen
|
https://www.linux.com/learn/intro-to-linux/2018/4/how-compile-linux-kernel-0
|
Jack 将带你在 Ubuntu 16.04 服务器上走过内核编译之旅。
|
/data/attachment/album/201805/22/125626duwkeqqh5l5103t5.jpg.thumb.jpg
|
/data/attachment/album/201805/22/125626duwkeqqh5l5103t5.jpg
| true | false | true |
icecoobe
| false |
[
"内核",
"编译"
] |
技术
|
{
"viewnum": 63112,
"commentnum": 4,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "115.200.234.203",
"message": "文中出现128GB是个错误，原文是12GB",
"username": "来自浙江杭州的 Chrome 75.0|Windows 10 用户",
"date": "2019-07-20T16:08:44"
},
{
"postip": "61.186.28.225",
"message": "谢谢！",
"username": "linux [Chrome 75.0|Mac 10.14]",
"date": "2019-07-28T23:22:53"
},
{
"postip": "14.30.37.16",
"message": "精辟",
"username": "来自广东广州的 Chrome 83.0|Windows 10 用户",
"date": "2020-07-09T17:17:12"
},
{
"postip": "101.249.56.29",
"message": "sad",
"username": "来自西藏的 Chrome 84.0|Windows 7 用户",
"date": "2020-10-10T17:12:19"
}
] |
[] |
Jack 将带你在 Ubuntu 16.04 服务器上走过内核编译之旅。
| 2018-05-22T12:56:00 | 2018-05-22T12:56:00 | 9,665 |
/article-9665-1.html
|
>
> Jack 将带你在 Ubuntu 16.04 服务器上走过内核编译之旅。
>
>
>
曾经有一段时间，升级 Linux 内核让很多用户打心里有所畏惧。在那个时候，升级内核包含了很多步骤，也需要很多时间。现在，内核的安装可以轻易地通过像 `apt` 这样的包管理器来处理。通过添加特定的仓库，你能很轻易地安装实验版本的或者指定版本的内核（比如针对音频产品的实时内核）。
考虑一下，既然升级内核如此容易，为什么你不愿意自行编译一个呢？这里列举一些可能的原因：
* 你想要简单了解编译内核的过程
* 你需要启用或者禁用内核中特定的选项，因为它们没有出现在标准选项里
* 你想要启用标准内核中可能没有添加的硬件支持
* 你使用的发行版需要你编译内核
* 你是一个学生，而编译内核是你的任务
不管出于什么原因，懂得如何编译内核是非常有用的，而且可以被视作一个通行权。当我第一次编译一个新的 Linux 内核（那是很久以前了），然后尝试从它启动，我从中（系统马上就崩溃了，然后不断地尝试和失败）感受到一种特定的兴奋。
既然这样，让我们来实验一下编译内核的过程。我将使用 Ubuntu 16.04 Server 来进行演示。在运行了一次常规的 `sudo apt upgrade` 之后，当前安装的内核版本是 `4.4.0-121`。我想要升级内核版本到 `4.17`， 让我们小心地开始吧。
有一个警告：强烈建议你在虚拟机里实验这个过程。基于虚拟机，你总能创建一个快照，然后轻松地从任何问题中回退出来。不要在产品机器上使用这种方式升级内核，除非你知道你在做什么。
### 下载内核
我们要做的第一件事是下载内核源码。在 [Kernel.org](https://www.kernel.org/) 找到你要下载的所需内核的 URL。找到 URL 之后，使用如下命令（我以 `4.17 RC2` 内核为例） 来下载源码文件:
```
wget https://git.kernel.org/torvalds/t/linux-4.17-rc2.tar.gz
```
在下载期间，有一些事需要去考虑。
### 安装需要的环境
为了编译内核，我们首先得安装一些需要的环境。这可以通过一个命令来完成：
```
sudo apt-get install git fakeroot build-essential ncurses-dev xz-utils libssl-dev bc flex libelf-dev bison
```
务必注意：你将需要至少 12 GB 的本地可用磁盘空间来完成内核的编译过程。因此你必须确保有足够的空间。
### 解压源码
在新下载的内核所在的文件夹下，使用该命令来解压内核：
```
tar xvzf linux-4.17-rc2.tar.gz
```
使用命令 `cd linux-4.17-rc2` 进入新生成的文件夹。
### 配置内核
在正式编译内核之前，我们首先必须配置需要包含哪些模块。实际上，有一些非常简单的方式来配置。使用一个命令，你能拷贝当前内核的配置文件，然后使用可靠的 `menuconfig` 命令来做任何必要的更改。使用如下命令来完成：
```
cp /boot/config-$(uname -r) .config
```
现在你有一个配置文件了，输入命令 `make menuconfig`。该命令将打开一个配置工具（图 1），它可以让你遍历每个可用模块，然后启用或者禁用你需要或者不需要的模块。
*图 1: 运行中的 `make menuconfig`*
很有可能你会禁用掉内核中的一个重要部分，所以在 `menuconfig` 期间小心地一步步进行。如果你对某个选项不确定，不要去管它。或者更好的方法是使用我们拷贝的当前运行的内核的配置文件（因为我们知道它可以工作）。一旦你已经遍历了整个配置列表（它非常长），你就准备好开始编译了。
### 编译和安装
现在是时候去实际地编译内核了。第一步是使用 `make` 命令去编译。调用 `make` 命令然后回答必要的问题（图 2）。这些问题取决于你将升级的现有内核以及升级后的内核。相信我，将会有非常多的问题要回答，因此你得预留大量的时间。
*图 2: 回答 `make` 命令的问题*
回答了长篇累牍的问题之后，你就可以用如下的命令安装那些之前启用的模块：
```
make modules_install
```
又来了，这个命令将耗费一些时间，所以要么坐下来看着编译输出，或者去做些其他事（因为编译期间不需要你的输入）。可能的情况是，你想要去进行别的任务（除非你真的喜欢看着终端界面上飞舞而过的输出）。
现在我们使用这个命令来安装内核：
```
sudo make install
```
又一次，另一个将要耗费大量可观时间的命令。事实上，`make install` 命令将比 `make modules_install` 命令花费更多的时间。去享用午餐，配置一个路由器，将 Linux 安装在一些服务器上，或者小睡一会吧。
### 启用内核作为引导
一旦 `make install` 命令完成了，就是时候将内核启用来作为引导。使用这个命令来实现：
```
sudo update-initramfs -c -k 4.17-rc2
```
当然，你需要将上述内核版本号替换成你编译完的。当命令执行完毕后，使用如下命令来更新 grub：
```
sudo update-grub
```
现在你可以重启系统并且选择新安装的内核了。
### 恭喜!
你已经编译了一个 Linux 内核！它是一项耗费时间的活动；但是，最终你的 Linux 发行版将拥有一个定制的内核，同时你也将拥有一项被许多 Linux 管理员所倾向忽视的重要技能。
从 Linux 基金会和 edX 提供的免费 [“Introduction to Linux”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 课程来学习更多的 Linux 知识。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/4/how-compile-linux-kernel-0>
作者：[Jack Wallen](https://www.linux.com/users/jlwallen) 选题：[lujun9972](https://github.com/lujun9972) 译者：[icecoobe](https://github.com/icecoobe) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
6 个 Python 的日期时间库
|
Lacey Williams Hensche
|
https://opensource.com/article/18/4/python-datetime-libraries
|
在 Python 中有许多库可以很容易地测试、转换和读取日期和时间信息。
|
/data/attachment/album/201805/22/161301ewwz66h6y8hkngmk.jpg.thumb.jpg
|
/data/attachment/album/201805/22/161301ewwz66h6y8hkngmk.jpg
| true | false | true |
MjSeven
| false |
[
"时间",
"日期",
"Python"
] |
软件开发
|
{
"viewnum": 6439,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 Python 中有许多库可以很容易地测试、转换和读取日期和时间信息。
| 2018-05-22T16:13:09 | 2018-05-22T16:13:09 | 9,666 |
/article-9666-1.html
|
>
> 在 Python 中有许多库可以很容易地测试、转换和读取日期和时间信息。
>
>
>
*这篇文章是与 [Jeff Triplett](https://opensource.com/users/jefftriplett) 一起合写的。*
曾几何时，我们中的一个人（Lacey）盯了一个多小时的 [Python 文档](https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior)中描述日期和时间格式化字符串的表格。当我试图编写从 API 中将日期时间字符串转换为 [Python datetime](https://opensource.com/article/17/5/understanding-datetime-python-primer) 对象时，我很难理解其中的特定部分，因此我决定请求帮助。
有人问道：“为什么你不使用 `dateutil` 呢？”
读者，如果你没有从这个月的 Python 专栏中获得任何东西，只是学习到有比 datetime 的 `strptime` 更容易地将 datetime 字符串转换为 datetime 对象的方法，那么我们觉得就已经成功了。
但是，除了将字符串转换为更有用的 Python 对象之外，还有许多库都有一些有用的方法和工具，可以让您更轻松地进行时间测试、将时间转换为不同的时区、以人类可读的格式传递时间信息，等等。如果这是你在 Python 中第一次接触日期和时间，请暂停并阅读 *[如何使用 Python的日期和时间](https://opensource.com/article/17/5/understanding-datetime-python-primer)* 。要理解为什么在编程中处理日期和时间是困难的，请阅读 [愚蠢的程序员相信时间](http://infiniteundo.com/post/25326999628/falsehoods-programmers-believe-about-time)。
这篇文章将会向你介绍以下库：
* [Dateutil](https://opensource.com/#Dateutil)
* [Arrow](https://opensource.com/#Arrow)
* [Moment](https://opensource.com/#Moment)
* [Maya](https://opensource.com/#Maya)
* [Delorean](https://opensource.com/#Delorean)
* [Freezegun](https://opensource.com/#Freezegun)
随意跳过那些你已经熟悉的库，专注于那些对你而言是新的库。
### 内建的 datetime 模块
在跳转到其他库之前，让我们回顾一下如何使用 `datetime` 模块将日期字符串转换为 Python datetime 对象。
假设我们从 API 接受到一个日期字符串，并且需要它作为 Python datetime 对象存在：
```
2018-04-29T17:45:25Z
```
这个字符串包括：
* 日期是 `YYYY-MM-DD` 格式的
* 字母 `T` 表示时间即将到来
* 时间是 `HH:II:SS` 格式的
* 表示此时间的时区指示符 `Z` 采用 UTC （详细了解[日期时间字符格式](https://www.w3.org/TR/NOTE-datetime)）
要使用 `datetime` 模块将此字符串转换为 Python datetime 对象，你应该从 `strptime` 开始。 `datetime.strptime` 接受日期字符串和格式化字符并返回一个 Python datetime 对象。
我们必须手动将日期时间字符串的每个部分转换为 Python 的 `datetime.strptime` 可以理解的合适的格式化字符串。四位数年份由 `%Y` 表示，两位数月份是 `%m`，两位数的日期是 `%d`。在 24 小时制中，小时是 `%H`，分钟是 `%M`，秒是 `%S`。
为了得出这些结论，需要在[Python 文档](https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior)的表格中多加注意。
由于字符串中的 `Z` 表示此日期时间字符串采用 UTC，所以我们可以在格式中忽略此项。（现在，我们不会担心时区。）
转换的代码是这样的：
```
$ from datetime import datetime
$ datetime.strptime('2018-04-29T17:45:25Z', '%Y-%m-%dT%H:%M:%SZ')
datetime.datetime(2018, 4, 29, 17, 45, 25)
```
格式字符串很难阅读和理解。我必须手动计算原始字符串中的字母 `T` 和 “Z”的位置，以及标点符号和格式化字符串，如 `%S` 和 `%m`。有些不太了解 datetime 的人阅读我的代码可能会发现它很难理解，尽管其含义已有文档记载，但它仍然很难阅读。
让我们看看其他库是如何处理这种转换的。
### Dateutil
[dateutil 模块](https://dateutil.readthedocs.io/en/stable/)对 `datetime` 模块做了一些扩展。
继续使用上面的解析示例，使用 `dateutil` 实现相同的结果要简单得多：
```
$ from dateutil.parser import parse
$ parse('2018-04-29T17:45:25Z')
datetime.datetime(2018, 4, 29, 17, 45, 25, tzinfo=tzutc())
```
如果字符串包含时区，那么 `dateutil` 解析器会自动返回字符串的时区。由于我们在 UTC 时区，你可以看到返回来一个 datetime 对象。如果你想解析完全忽略时区信息并返回原生的 datetime 对象，你可以传递 `ignoretz=True` 来解析，如下所示：
```
$ from dateutil.parser import parse
$ parse('2018-04-29T17:45:25Z', ignoretz=True)
datetime.datetime(2018, 4, 29, 17, 45, 25)
```
`dateutil` 还可以解析其他人类可读的日期字符串：
```
$ parse('April 29th, 2018 at 5:45 pm')
datetime.datetime(2018, 4, 29, 17, 45)
```
`dateutil` 还提供了像 [relativedelta](https://dateutil.readthedocs.io/en/stable/relativedelta.html) 的工具，它用于计算两个日期时间之间的时间差或向日期时间添加或删除时间，[rrule](https://dateutil.readthedocs.io/en/stable/rrule.html) 创建重复日期时间，[tz](https://dateutil.readthedocs.io/en/stable/tz.html) 用于解决时区以及其他工具。
### Arrow
[Arrow](https://github.com/crsmithdev/arrow) 是另一个库，其目标是操作、格式化，以及处理对人类更友好的日期和时间。它包含 `dateutil`，根据其[文档](https://pypi.python.org/pypi/arrow-fatisar/0.5.3)，它旨在“帮助你使用更少的包导入和更少的代码来处理日期和时间”。
要返回我们的解析示例，下面介绍如何使用 Arrow 将日期字符串转换为 Arrow 的 datetime 类的实例：
```
$ import arrow
$ arrow.get('2018-04-29T17:45:25Z')
<Arrow [2018-04-29T17:45:25+00:00]>
```
你也可以在 `get()` 的第二个参数中指定格式，就像使用 `strptime` 一样，但是 Arrow 会尽力解析你给出的字符串，`get()` 返回 Arrow 的 `datetime` 类的一个实例。要使用 Arrow 来获取 Python datetime 对象，按照如下所示链式 datetime：
```
$ arrow.get('2018-04-29T17:45:25Z').datetime
datetime.datetime(2018, 4, 29, 17, 45, 25, tzinfo=tzutc())
```
通过 Arrow datetime 类的实例，你可以访问 Arrow 的其他有用方法。例如，它的 `humanize()` 方法将日期时间翻译成人类可读的短语，就像这样：
```
$ import arrow
$ utc = arrow.utcnow()
$ utc.humanize()
'seconds ago'
```
在 Arrow 的[文档](https://arrow.readthedocs.io/en/latest/)中阅读更多关于其有用方法的信息。
### Moment
[Moment](https://github.com/zachwill/moment) 的作者认为它是“内部测试版”，但即使它处于早期阶段，它也是非常受欢迎的，我们想来讨论它。
Moment 的方法将字符转换为其他更有用的东西很简单，类似于我们之前提到的库：
```
$ import moment
$ moment.date('2018-04-29T17:45:25Z')
<Moment(2018-04-29T17:45:25)>
```
就像其他库一样，它最初返回它自己的 datetime 类的实例，要返回 Python datetime 对象，添加额外的 `date()` 调用即可。
```
$ moment.date('2018-04-29T17:45:25Z').date
datetime.datetime(2018, 4, 29, 17, 45, 25, tzinfo=<StaticTzInfo 'Z'>)
```
这将 Moment datetime 类转换为 Python datetime 对象。
Moment 还提供了使用人类可读的语言创建新日期的方法。例如创建一个明天的日期：
```
$ moment.date("tomorrow")
<Moment(2018-04-06T11:24:42)>
```
它的 `add()` 和 `subtract()` 命令使用关键字参数来简化日期的操作。为了获得后天，Moment 会使用下面的代码：
```
$ moment.date("tomorrow").add(days=1)
<Moment(2018-04-07T11:26:48)>
```
### Maya
[Maya](https://github.com/kennethreitz/maya) 包含了 Python 中其他流行处理日期时间的库，包括 Humanize、 pytz 和 pendulum 等等。这个项目旨在让人们更容易处理日期。
Maya 的 README 包含几个有用的实例。以下是如何使用 Maya 来重新处理以前的解析示例：
```
$ import maya
$ maya.parse('2018-04-29T17:45:25Z').datetime()
datetime.datetime(2018, 4, 29, 17, 45, 25, tzinfo=<UTC>)
```
注意我们必须在 `maya.parse()` 之后调用 `datetime()`。如果我们跳过这一步，Maya 将会返回一个 MayaDT 类的示例：`<MayaDT epoch=1525023925.0>`。
由于 Maya 与 datetime 库中很多有用的方法重叠，因此它可以使用 MayaDT 类的实例执行诸如使用 `slang_time()` 方法将时间偏移量转换为纯文本语言，并将日期时间间隔保存在单个类的实例中。以下是如何使用 Maya 将日期时间表示为人类可读的短语：
```
$ import maya
$ maya.parse('2018-04-29T17:45:25Z').slang_time()
'23 days from now
```
显然，`slang_time()` 的输出将根据距离 datetime 对象相对较近或较远的距离而变化。
### Delorean
[Delorean](https://github.com/myusuf3/delorean)，以 《返回未来》 电影中的时间旅行汽车命名，它对于操纵日期时间特别有用，包括将日期时间转换为其他时区并添加或减去时间。
Delorean 需要有效的 Python datetime 对象才能工作，所以如果你需要使用时间字符串，最好将其与上述库中的一个配合使用。例如，将 Maya 与 Delorean 一起使用：
```
$ import maya
$ d_t = maya.parse('2018-04-29T17:45:25Z').datetime()
```
现在，你有了一个 datetime 对象 d\_t，你可以使用 Delorean 来做一些事情，例如将日期时间转换为美国东部时区：
```
$ from delorean import Delorean
$ d = Delorean(d_t)
$ d
Delorean(datetime=datetime.datetime(2018, 4, 29, 17, 45, 25), timezone='UTC')
$ d.shift('US/Eastern')
Delorean(datetime=datetime.datetime(2018, 4, 29, 13, 45, 25), timezone='US/Eastern')
```
看到小时是怎样从 17 变成 13 了吗？
你也可以使用自然语言方法来操作 datetime 对象。获取 2018 年 4 月 29 日之后的下个星期五（我们现在使用的）：
```
$ d.next_friday()
Delorean(datetime=datetime.datetime(2018, 5, 4, 13, 45, 25), timezone='US/Eastern')
```
在 Delorean 的[文档](https://delorean.readthedocs.io/en/latest/)中阅读更多关于其的用法。
### Freezegun
[Freezegun](https://github.com/spulec/freezegun) 是一个可以帮助你在 Python 代码中测试特定日期的库。使用 `@freeze_time` 装饰器，你可以为测试用例设置特定的日期和时间，并且所有对 `datetime.datetime.now()`、 `datetime.datetime.utcnow()` 等的调用都将返回你指定的日期和时间。例如：
```
from freezegun import freeze_time
import datetime
@freeze_time("2017-04-14")
def test():
assert datetime.datetime.now() == datetime.datetime(2017, 4, 14)
```
要跨时区进行测试，你可以将 `tz_offset` 参数传递给装饰器。`freeze_time` 装饰器也接受更简单的口语化日期，例如 `@freeze_time('April 4, 2017')`。
---
上面提到的每个库都提供了一组不同的特性和功能，也许很难决定哪一个最适合你的需要。[Maya 的作者](https://github.com/kennethreitz/maya), Kenneth Reitz 说到：“所有这些项目相辅相成，它们都是我们的朋友”。
这些库共享一些功能，但不是全部。有些擅长时间操作，有些擅长解析，但它们都有共同的目标，即让你对日期和时间的工作更轻松。下次你发现自己对 Python 的内置 datetime 模块感到沮丧，我们希望你可以选择其中的一个库进行试验。
---
via: <https://opensource.com/article/18/4/python-datetime-libraries>
作者: [Lacey Williams Hensche](https://opensource.com/users/laceynwilliams) 选题: [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/) 荣誉推出
|
||
Bootiso ：让你安全地创建 USB 启动设备
|
Sk
|
https://www.ostechnix.com/bootiso-lets-you-safely-create-bootable-usb-drive/
|
我发现了另一个可以安全创建 USB 引导设备的工具 Bootiso 。它实际上是一个 BASH 脚本，但真的很智能！
|
/data/attachment/album/201805/22/163121prqrm82zr67vroom.png.thumb.jpg
|
/data/attachment/album/201805/22/163121prqrm82zr67vroom.png
| true | false | true |
kennethXia
| false |
[
"USB",
"iso"
] |
分享
|
{
"viewnum": 6289,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 4,
"likes": 0
}
|
[] |
[] |
我发现了另一个可以安全创建 USB 引导设备的工具 Bootiso 。它实际上是一个 BASH 脚本，但真的很智能！
| 2018-05-22T16:31:19 | 2018-05-22T16:31:19 | 9,667 |
/article-9667-1.html
|
你好，新兵！你们有些人经常使用 `dd` 命令做各种各样的事，比如创建 USB 启动盘或者克隆硬盘分区。不过请牢记，`dd` 是一个危险且有毁灭性的命令。如果你是个 Linux 的新手，最好避免使用 `dd` 命令。如果你不知道你在做什么，你可能会在几分钟里把硬盘擦掉。从原理上说，`dd` 只是从 `if` 读取然后写到 `of` 上。它才不管往哪里写呢。它根本不关心那里是否有分区表、引导区、家目录或是其他重要的东西。你叫它做什么它就做什么。可以使用像 [Etcher](https://www.ostechnix.com/etcher-beauitiful-app-create-bootable-sd-cards-usb-drives/) 这样的用户友好的应用来代替它。这样你就可以在创建 USB 引导设备之前知道你将要格式化的是哪块盘。
今天，我发现了另一个可以安全创建 USB 引导设备的工具 Bootiso 。它实际上是一个 BASH 脚本，但真的很智能！它有很多额外的功能来帮我们安全创建 USB 引导盘。如果你想确保你的目标是 USB 设备（而不是内部驱动器），或者如果你想检测 USB 设备，你可以使用 Bootiso。下面是使用此脚本的显著优点:
* 如果只有一个 USB 驱动器，Bootiso 会自动选择它。
* 如果有一个以上的 USB 驱动器存在，它可以让你从列表中选择其中一个。
* 万一你错误地选择一个内部硬盘驱动器，它将退出而不做任何事情。
* 它检查选定的 ISO 是否具有正确的 MIME 类型。如果 MIME 类型不正确，它将退出。
* 它判定所选的项目不是分区，如果判定失败则退出。
* 它将在擦除和对 USB 驱动器分区之前提示用户确认。
* 列出可用的 USB 驱动器。
* 安装 syslinux 引导系统 (可选)。
* 自由且开源。
### 使用 Bootiso 安全地创建 USB 驱动器
安装 Bootiso 非常简单。用这个命令下载最新版本：
```
$ curl -L https://rawgit.com/jsamr/bootiso/latest/bootiso -O
```
把下载的文件加到 `$PATH` 目录中，比如 `/usr/local/bin/`。
```
$ sudo cp bootiso /usr/local/bin/
```
最后，添加运行权限：
```
$ sudo chmod +x /usr/local/bin/bootiso
```
搞定！现在就可以创建 USB 引导设备了。首先，让我们用命令看看现在有哪些 USB 驱动器：
```
$ bootiso -l
```
输出：
```
Listing USB drives available in your system:
NAME HOTPLUG SIZE STATE TYPE
sdb 1 7.5G running disk
```
如你所见，我只有一个 USB 驱动器。让我们继续通过命令用 ISO 文件创建 USB 启动盘：
```
$ bootiso bionic-desktop-amd64.iso
```
这个命令会提示你输入 `sudo` 密码。输入密码并回车来安装缺失的组件（如果有的话），然后创建 USB 启动盘。
输出：
```
[...]
Listing USB drives available in your system:
NAME HOTPLUG SIZE STATE TYPE
sdb 1 7.5G running disk
Autoselecting `sdb' (only USB device candidate)
The selected device `/dev/sdb' is connected through USB.
Created ISO mount point at `/tmp/iso.c5m'
`bootiso' is about to wipe out the content of device `/dev/sdb'.
Are you sure you want to proceed? (y/n)>y
Erasing contents of /dev/sdb...
Creating FAT32 partition on `/dev/sdb1'...
Created USB device mount point at `/tmp/usb.QgV'
Copying files from ISO to USB device with `rsync'
Synchronizing writes on device `/dev/sdb'
`bootiso' took 303 seconds to write ISO to USB device with `rsync' method.
ISO succesfully unmounted.
USB device succesfully unmounted.
USB device succesfully ejected.
You can safely remove it !
```
如果你的 ISO 文件 MIME 类型不对，你会得到下列错误信息：
```
Provided file `bionic-desktop-amd64.iso' doesn't seem to be an iso file (wrong mime type: `application/octet-stream').
Exiting bootiso...
```
当然，你也能像下面那样使用 `–no-mime-check` 选项来跳过 MIME 类型检查。
```
$ bootiso --no-mime-check bionic-desktop-amd64.iso
```
就像我前面提到的，如果系统里只有 1 个 USB 设备 Bootiso 将自动选中它。所以我们不需要告诉它 USB 设备路径。如果你连接了多个设备，你可以像下面这样使用 `-d` 来指明 USB 设备。
```
$ bootiso -d /dev/sdb bionic-desktop-amd64.iso
```
用你自己的设备路径来换掉 `/dev/sdb`。
在多个设备情况下，如果你没有使用 `-d` 来指明要使用的设备，Bootiso 会提示你选择可用的 USB 设备。
Bootiso 在擦除和改写 USB 盘分区前会要求用户确认。使用 `-y` 或 `–assume-yes` 选项可以跳过这一步。
```
$ bootiso -y bionic-desktop-amd64.iso
```
您也可以把自动选择 USB 设备与 `-y` 选项连用，如下所示。
```
$ bootiso -y -a bionic-desktop-amd64.iso
```
或者，
```
$ bootiso?--assume-yes?--autoselect bionic-desktop-amd64.iso
```
请记住，当你只连接一个 USB 驱动器时，它才会起作用。
Bootiso 会默认创建一个 FAT 32 分区，挂载后用 `rsync` 程序把 ISO 的内容拷贝到 USB 盘里。 如果你愿意也可以使用 `dd` 代替 `rsync` 。
```
$ bootiso --dd -d /dev/sdb bionic-desktop-amd64.iso
```
如果你想增加 USB 引导的成功概率，请使用 `-b` 或 `–bootloader` 选项。
```
$ bootiso -b bionic-desktop-amd64.iso
```
上面这条命令会安装 `syslinux` 引导程序（安全模式）。注意，此时 `–dd` 选项不可用。
在创建引导设备后，Bootiso 会自动弹出 USB 设备。如果不想自动弹出，请使用 `-J` 或 `–no-eject` 选项。
```
$ bootiso -J bionic-desktop-amd64.iso
```
现在，USB 设备依然连接中。你可以使用 `umount` 命令随时卸载它。
需要完整帮助信息，请输入：
```
$ bootiso -h
```
好，今天就到这里。希望这个脚本对你有帮助。好货不断，不要走开哦！
---
via: <https://www.ostechnix.com/bootiso-lets-you-safely-create-bootable-usb-drive/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[kennethXia](https://github.com/kennethXia) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么建设一个社区值得额外的努力
|
Alessio Fattorini
|
https://opensource.com/open-organization/18/1/why-build-community-1
|
建立 NethServer 社区是有风险的。但是我们从这些激情的人们所带来的力量当中学习到了很多。
|
/data/attachment/album/201805/22/171454x5jfnf8rggfsrgzo.png.thumb.jpg
|
/data/attachment/album/201805/22/171454x5jfnf8rggfsrgzo.png
| true | false | true |
geekpi
| false |
[
"社区"
] |
观点
|
{
"viewnum": 4873,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
建立 NethServer 社区是有风险的。但是我们从这些激情的人们所带来的力量当中学习到了很多。
| 2018-05-22T17:15:00 | 2018-05-22T17:15:00 | 9,668 |
/article-9668-1.html
|
>
> 建立 NethServer 社区是有风险的。但是我们从这些激情的人们所带来的力量当中学习到了很多。
>
>
>
当我们在 2003 年推出 [Nethesis](http://www.nethesis.it/) 时，我们还只是系统集成商。我们只使用已有的开源项目。我们的业务模式非常明确：为这些项目增加多种形式的价值：实践知识、针对意大利市场的文档、额外模块、专业支持和培训课程。我们还通过向上游贡献代码并参与其社区来回馈上游项目。
那时时代不同。我们不能太张扬地使用“开源”这个词。人们将它与诸如“书呆子”，“没有价值”以及最糟糕的“免费”这些词联系起来。这些不太适合生意。
在 2010 年的一个星期六，Nethesis 的工作人员，他们手中拿着馅饼和浓咖啡，正在讨论如何推进事情发展（嘿，我们喜欢在创新的同时吃喝东西！）。尽管势头对我们不利，但我们决定不改变方向。事实上，我们决定加大力度 —— 去做开源和开放的工作方式，这是一个成功运营企业的模式。
多年来，我们已经证明了该模型的潜力。有一件事是我们成功的关键：社区。
在这个由三部分组成的系列文章中，我将解释社区在开放组织的存在中扮演的重要角色。我将探讨为什么一个组织希望建立一个社区，并讨论如何建立一个社区 —— 因为我确实认为这是如今产生新创新的最佳方式。
### 这个疯狂的想法
与 Nethesis 伙伴一起，我们决定构建自己的开源项目：我们自己的操作系统，它建立在 CentOS 之上（因为我们不想重新发明轮子）。我们假设我们拥有实现它的经验、实践知识和人力。我们感到很勇敢。
我们非常希望构建一个名为 [NethServer](http://www.nethserver.org/) 的操作系统，其使命是：通过开源使系统管理员的生活更轻松。我们知道我们可以为服务器创建一个 Linux 发行版，与当前已有的相比，它更容易使用、更易于部署，并且更易于理解。
不过，最重要的是，我们决定创建一个真正的，100％ 开放的项目，其主要规则有三条：
* 完全免费下载
* 开发公开
* 社区驱动
最后一个很重要。我们是一家公司。我们能够自己开发它。如果我们在内部完成这项工作，我们将会更有效（并且做出更快的决定）。与其他任何意大利公司一样，这将非常简单。
但是我们已经如此深入到开源文化中，所以我们选择了不同的路径。
我们确实希望有尽可能多的人围绕着我们、围绕着产品、围绕着公司周围。我们希望对工作有尽可能多的视角。我们意识到：独自一人，你可以走得快 —— 但是如果你想走很远，你需要一起走。
所以我们决定建立一个社区。
### 下一步是什么？
我们意识到创建社区有很多好处。例如，如果使用产品的人真正参与到项目中，他们将提供反馈和测试用例、编写文档、发现 bug，与其他产品进行比较，建议功能并为开发做出贡献。所有这些都会产生创新，吸引贡献者和客户，并扩展你产品的用户群。
但是很快就出现了这样一个问题：我们如何建立一个社区？我们不知道如何实现这一点。我们参加了很多社区，但我们从未建立过一个社区。
我们擅长编码 —— 而不是人。我们是一家公司，是一个有非常具体优先事项的组织。那么我们如何建立一个社区，并在公司和社区之间建立良好的关系呢？
我们做了你必须做的第一件事：学习。我们从专家、博客和许多书中学到了知识。我们进行了实验。我们失败了多次，从结果中收集数据，并再次进行测试。
最终我们学到了社区管理的黄金法则：**没有社区管理的黄金法则。**
人们太复杂了，社区无法用一条规则来“统治他们”。
然而，我可以说的一件事是，社区和公司之间的健康关系总是一个给予和接受的过程。在我的下一篇文章中，我将讨论你的组织如果想要一个蓬勃发展和创新的社区，应该期望提供什么。
---
via: <https://opensource.com/open-organization/18/1/why-build-community-1>
作者：[Alessio Fattorini](https://opensource.com/users/alefattorini) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
HeRM's ：一个命令行食谱管理器
|
Sk
|
https://www.ostechnix.com/herms-commandline-food-recipes-manager/
|
今天，我介绍 HeRM's，这是一个基于 Haskell 的命令行食谱管理器，能为你的美食食谱做笔记。
|
/data/attachment/album/201805/23/084210xvz2ld7a3we3w7wj.jpg.thumb.jpg
|
/data/attachment/album/201805/23/084210xvz2ld7a3we3w7wj.jpg
| true | false | true |
geekpi
| false |
[
"食谱"
] |
分享
|
{
"viewnum": 5187,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
今天，我介绍 HeRM's，这是一个基于 Haskell 的命令行食谱管理器，能为你的美食食谱做笔记。
| 2018-05-23T08:42:07 | 2018-05-23T08:42:07 | 9,669 |
/article-9669-1.html
|
烹饪让爱变得可见，不是吗？确实！烹饪也许是你的热情或爱好或职业，我相信你会维护一份烹饪日记。保持写烹饪日记是改善烹饪习惯的一种方法。有很多方法可以记录食谱。你可以维护一份小日记/笔记或将配方的笔记存储在智能手机中，或将它们保存在计算机中文档中。这有很多选择。今天，我介绍 **HeRM's**，这是一个基于 Haskell 的命令行食谱管理器，能为你的美食食谱做笔记。使用 Herm's，你可以添加、查看、编辑和删除食物配方，甚至可以制作购物清单。这些全部来自你的终端！它是免费的，是使用 Haskell 语言编写的开源程序。源代码在 GitHub 中免费提供，因此你可以复刻它，添加更多功能或改进它。
### HeRM's - 一个命令食谱管理器
#### 安装 HeRM's
由于它是使用 Haskell 编写的，因此我们需要首先安装 Cabal。 Cabal 是一个用于下载和编译用 Haskell 语言编写的软件的命令行程序。Cabal 存在于大多数 Linux 发行版的核心软件库中，因此你可以使用发行版的默认软件包管理器来安装它。
例如，你可以使用以下命令在 Arch Linux 及其变体（如 Antergos、Manjaro Linux）中安装 cabal：
```
sudo pacman -S cabal-install
```
在 Debian、Ubuntu 上：
```
sudo apt-get install cabal-install
```
安装 Cabal 后，确保你已经添加了 `PATH`。为此，请编辑你的 `~/.bashrc`：
```
vi ~/.bashrc
```
添加下面这行：
```
PATH=$PATH:~/.cabal/bin
```
按 `:wq` 保存并退出文件。然后，运行以下命令更新所做的更改。
```
source ~/.bashrc
```
安装 cabal 后，运行以下命令安装 `herms`：
```
cabal install herms
```
喝一杯咖啡！这将需要一段时间。几分钟后，你会看到一个输出，如下所示。
```
[...]
Linking dist/build/herms/herms ...
Installing executable(s) in /home/sk/.cabal/bin
Installed herms-1.8.1.2
```
恭喜！ Herms 已经安装完成。
#### 添加食谱
让我们添加一个食谱，例如 Dosa。对于那些想知道的，Dosa 是一种受欢迎的南印度食物，配以 sambar（LCTT 译注：扁豆和酸豆炖菜，像咖喱汤） 和**酸辣酱**。这是一种健康的，可以说是最美味的食物。它不含添加的糖或饱和脂肪。制作一个也很容易。有几种不同的 Dosas，在我们家中最常见的是 Plain Dosa。
要添加食谱，请输入：
```
herms add
```
你会看到一个如下所示的屏幕。开始输入食谱的详细信息。
要变换字段，请使用以下键盘快捷键：
* `Tab` / `Shift+Tab` - 下一个/前一个字段
* `Ctrl + <箭头键>` - 导航字段
* `[Meta 或者 Alt] + <h-j-k-l>` - 导航字段
* `Esc` - 保存或取消。
添加完配方的详细信息后，按下 `ESC` 键并点击 `Y` 保存。同样，你可以根据需要添加尽可能多的食谱。
要列出添加的食谱，输入：
```
herms list
```
要查看上面列出的任何食谱的详细信息，请使用下面的相应编号。
```
herms view 1
```
要编辑任何食谱，使用：
```
herms edit 1
```
完成更改后，按下 `ESC` 键。系统会询问你是否要保存。你只需选择适当的选项。
要删除食谱，命令是：
```
herms remove 1
```
要为指定食谱生成购物清单，运行：
```
herms shopping 1
```
要获得帮助，运行：
```
herms -h
```
当你下次听到你的同事、朋友或其他地方谈到好的食谱时，只需打开 Herm's，并快速记下，并将它们分享给你的配偶。她会很高兴！
今天就是这些。还有更好的东西。敬请关注！
干杯！！
---
via: <https://www.ostechnix.com/herms-commandline-food-recipes-manager/>
作者：[SK](https://www.ostechnix.com) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
程序员的学习之路
|
Terry Crowley
|
https://hackernoon.com/education-of-a-programmer-aaecf2d35312
|
2016 年 10 月，当我从微软离职时，我已经在微软工作了近 21 年，在业界也快 35 年了。我花了一些时间反思我这些年来学到的东西，这些文字是那篇帖子稍加修改后得到。请见谅，文章有一点长。
|
/data/attachment/album/201805/23/110510l6r65l555zlgc3ld.jpg.thumb.jpg
|
/data/attachment/album/201805/23/110510l6r65l555zlgc3ld.jpg
| true | false | true |
explosic4
| true |
[
"程序员"
] |
观点
|
{
"viewnum": 9930,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
2016 年 10 月，当我从微软离职时，我已经在微软工作了近 21 年，在业界也快 35 年了。我花了一些时间反思我这些年来学到的东西，这些文字是那篇帖子稍加修改后得到。请见谅，文章有一点长。
| 2018-05-23T11:05:00 | 2018-05-23T11:05:00 | 9,670 |
/article-9670-1.html
|
*2016 年 10 月，当我从微软离职时，我已经在微软工作了近 21 年，在业界也快 35 年了。我花了一些时间反思我这些年来学到的东西，这些文字是那篇帖子稍加修改后得到。请见谅，文章有一点长。*
要成为一名专业的程序员，你需要知道的事情多得令人吃惊：语言的细节、API、算法、数据结构、系统和工具。这些东西一直在随着时间变化——新的语言和编程环境不断出现，似乎总有一些“每个人”都在使用的热门的新工具或新语言。紧跟潮流，保持专业，这很重要。木匠需要知道如何为工作选择合适的锤子和钉子，并且要有能力笔直精准地钉入钉子。
与此同时，我也发现有一些理论和方法有着广泛的应用场景，它们能使用几十年。底层设备的性能和容量在这几十年来增长了几个数量级，但系统设计的思考方式还是互相有关联的，这些思考方式比具体的实现更根本。理解这些重复出现的主题对分析与设计我们所负责的系统大有帮助。
### 谦卑和自我
这不仅仅局限于编程，但在编程这个持续发展的领域，一个人需要在谦卑和自我中保持平衡。总有新的东西需要学习，并且总有人能帮助你学习——如果你愿意学习的话。一个人即需要保持谦卑，认识到自己不懂并承认它，也要保持自我，相信自己能掌握一个新的领域，并且能运用你已经掌握的知识。我见过的最大的挑战就是一些人在某个领域深入专研了很长时间，“忘记”了自己擅长学习新的东西。最好的学习来自放手去做，建造一些东西，即便只是一个原型或者 hack。我知道的最好的程序员对技术有广泛的认识，但同时他们对某个技术深入研究，成为了专家。而深入的学习来自努力解决真正困难的问题。
### 端到端观点
1981 年，Jerry Saltzer、 Dave Reed 和 Dave Clark 在做因特网和分布式系统的早期工作，他们提出了<ruby> 端到端 <rt> end to end </rt></ruby>观点，并作出了[经典的阐述](http://web.mit.edu/Saltzer/www/publications/endtoend/endtoend.pdf)。网络上的文章有许多误传，所以更应该阅读论文本身。论文的作者很谦虚，没有声称这是他们自己的创造——从他们的角度看，这只是一个常见的工程策略，不只在通讯领域中，在其他领域中也有运用。他们只是将其写下来并收集了一些例子。下面是文章的一个小片段：
>
> 当我们设计系统的一个功能时，仅依靠端点的知识和端点的参与，就能正确地完整地实现这个功能。在一些情况下，系统的内部模块局部实现这个功能，可能会对性能有重要的提升。
>
>
>
该论文称这是一个“观点”，虽然在维基百科和其他地方它已经被上升成“原则”。实际上，还是把它看作一个观点比较好，正如作者们所说，系统设计者面临的最难的问题之一就是如何在系统组件之间划分责任，这会引发不断的讨论：怎样在划分功能时权衡利弊，怎样隔离复杂性，怎样设计一个灵活的高性能系统来满足不断变化的需求。没有简单的原则可以直接遵循。
互联网上的大部分讨论集中在通信系统上，但端到端观点的适用范围其实更广泛。分布式系统中的“<ruby> 最终一致性 <rt> eventual consistency </rt></ruby>”就是一个例子。一个满足“最终一致性”的系统，可以让系统中的元素暂时进入不一致的状态，从而简化系统，优化性能，因为有一个更大的端到端过程来解决不一致的状态。我喜欢横向拓展的订购系统的例子（例如亚马逊），它不要求每个请求都通过中央库存的控制点。缺少中央控制点可能允许两个终端出售相同的最后一本书，所以系统需要用某种方法来解决这个问题，如通知客户该书会延期交货。不论怎样设计，想购买的最后一本书在订单完成前都有可能被仓库中的叉车运出厍（LCTT 译注：比如被其他人下单购买）。一旦你意识到你需要一个端到端的解决方案，并实现了这个方案，那系统内部的设计就可以被优化以利用这个解决方案。
事实上，这种设计上的灵活性可以优化系统的性能，或者提供其他的系统功能，从而使得端到端的方法变得如此强大。端到端的思考往往允许内部进行灵活的操作，使整个系统更加健壮，并且能适应每个组件特性的变化。这些都让端到端的方法变得健壮，并能适应变化。
端到端方法意味着，添加会牺牲整体性能灵活性的抽象层和功能时要非常小心（也可能是其他的灵活性，但性能，特别是延迟，往往是特殊的）。如果你展示出底层的原始性能（LCTT 译注：performance，也可能指操作，下同），端到端的方法可以根据这个性能（操作）来优化，实现特定的需求。如果你破坏了底层性能（操作），即使你实现了重要的有附加价值的功能，你也牺牲了设计灵活性。
如果系统足够庞大而且足够复杂，需要把整个开发团队分配给系统内部的组件，那么端到端观点可以和团队组织相结合。这些团队自然要扩展这些组件的功能，他们通常从牺牲设计上的灵活性开始，尝试在组件上实现端到端的功能。
应用端到端方法面临的挑战之一是确定端点在哪里。 俗话说，“大跳蚤上有小跳蚤，小跳蚤上有更少的跳蚤……等等”。
### 关注复杂性
编程是一门精确的艺术，每一行代码都要确保程序的正确执行。但这是带有误导的。编程的复杂性不在于各个部分的整合，也不在于各个部分之间如何相互交互。最健壮的程序会将复杂性隔离开，让最重要的部分变的简单直接，通过简单的方式与其他部分交互。虽然隐藏复杂性和信息隐藏、数据抽象等其他设计方法一样，但我仍然觉得，如果你真的要定位出系统的复杂所在，并将其隔离开，那你需要对设计特别敏锐。
在我的[文章](https://medium.com/@terrycrowley/model-view-controller-and-loose-coupling-6370f76e9cde#.o4gnupqzq)中反复提到的例子是早期的终端编辑器 VI 和 Emacs 中使用的屏幕重绘算法。早期的视频终端实现了控制序列，来控制绘制字符核心操作，也实现了附加的显示功能，来优化重新绘制屏幕，如向上向下滚动当前行，或者插入新行，或在当前行中移动字符。这些命令都具有不同的开销，并且这些开销在不同制造商的设备中也是不同的。（参见[TERMCAP](https://en.wikipedia.org/wiki/Termcap) 以获取代码和更完整的历史记录的链接。）像文本编辑器这样的全屏应用程序希望尽快更新屏幕，因此需要优化使用这些控制序列来从一个状态到另一个状态屏幕转换。
这些程序在设计上隐藏了底层的复杂性。系统中修改文本缓冲区的部分（功能上大多数创新都在这里）完全忽略了这些改变如何被转换成屏幕更新命令。这是可以接受的，因为针对*任何*内容的改变计算最佳命令所消耗的性能代价，远不及被终端本身实际执行这些更新命令的性能代价。在确定如何隐藏复杂性，以及隐藏哪些复杂性时，性能分析扮演着重要的角色，这一点在系统设计中非常常见。屏幕的更新与底层文本缓冲区的更改是异步的，并且可以独立于缓冲区的实际历史变化顺序。缓冲区是*怎样*改变的并不重要，重要的是改变了*什么*。异步耦合，在组件交互时消除组件对历史路径依赖的组合，以及用自然的交互方式以有效地将组件组合在一起是隐藏耦合复杂度的常见特征。
隐藏复杂性的成功不是由隐藏复杂性的组件决定的，而是由使用该模块的使用者决定的。这就是为什么组件的提供者至少要为组件的某些端到端过程负责。他们需要清晰的知道系统的其他部分如何与组件相互作用，复杂性是如何泄漏出来的（以及是否泄漏出来）。这常常表现为“这个组件很难使用”这样的反馈——这通常意味着它不能有效地隐藏内部复杂性，或者没有选择一个隐藏复杂性的功能边界。
### 分层与组件化
系统设计人员的一个基本工作是确定如何将系统分解成组件和层；决定自己要开发什么，以及从别的地方获取什么。开源项目在决定自己开发组件还是购买服务时，大多会选择自己开发，但组件之间交互的过程是一样的。在大规模工程中，理解这些决策将如何随着时间的推移而发挥作用是非常重要的。从根本上说，变化是程序员所做的一切的基础，所以这些设计决定不仅要在当下评估，还要随着产品的不断发展而在未来几年得到评估。
以下是关于系统分解的一些事情，它们最终会占用大量的时间，因此往往需要更长的时间来学习和欣赏。
* **层泄漏。**层（或抽象）[基本上是泄漏的](https://medium.com/@terrycrowley/leaky-by-design-7b423142ece0#.x67udeg0a)。这些泄漏会立即产生后果，也会随着时间的推移而产生两方面的后果。其中一方面就是该抽象层的特性渗透到了系统的其他部分，渗透的程度比你意识到得更深入。这些渗透可能是关于具体的性能特征的假设，以及抽象层的文档中没有明确的指出的行为发生的顺序。这意味着假如内部组件的行为发生变化，你的系统会比想象中更加脆弱。第二方面是你比表面上看起来更依赖组件内部的行为，所以如果你考虑改变这个抽象层，后果和挑战可能超出你的想象。
* **层具有太多功能。**您所采用的组件具有比实际需要更多的功能，这几乎是一个真理。在某些情况下，你决定采用这个组件是因为你想在将来使用那些尚未用到的功能。有时，你采用组件是想“上快车”，利用组件完成正在进行的工作。在功能强大的抽象层上开发会带来一些后果。
1. 组件往往会根据你并不需要的功能作出取舍。
2. 为了实现那些你并不没有用到的功能，组件引入了复杂性和约束，这些约束将阻碍该组件的未来的演变。
3. 层泄漏的范围更大。一些泄漏是由于真正的“抽象泄漏”，另一些是由于明显的，逐渐增加的对组件全部功能的依赖（但这些依赖通常都没有处理好）。Office 软件太大了，我们发现，对于我们建立的任何抽象层，我们最终都在系统的某个部分完全运用了它的功能。虽然这看起来是积极的（我们完全地利用了这个组件），但并不是所用的使用都有同样的价值。所以，我们最终要付出巨大的代价才能从一个抽象层往另一个抽象层迁移，这种“长尾”没什么价值，并且对使用场景认识不足。
4. 附加的功能会增加复杂性，并增加功能滥用的可能。如果将验证 XML 的 API 指定为 XML 树的一部分，那这个 API 可以选择动态下载 XML 的模式定义。这在我们的基本文件解析代码中被错误地执行，导致 w3c.org 服务器上的大量性能下降以及（无意）分布式拒绝服务攻击。（这些被通俗地称为“地雷”API）。
* **抽象层被更换。**需求在进化，系统在进化，组件被放弃。您最终需要更换该抽象层或组件。不管是对外部组件的依赖还是对内部组件的依赖都是如此。这意味着上述问题将变得重要起来。
* **自己构建还是购买的决定将会改变。**这是上面几方面的必然结果。这并不意味着自己构建还是购买的决定在当时是错误的。一开始时往往没有合适的组件，一段时间之后才有合适的组件出现。或者，也可能你使用了一个组件，但最终发现它不符合您不断变化的要求，而且你的要求非常窄、很好理解，或者对你的价值体系来说是非常重要的，以至于拥有自己的模块是有意义的。这意味着你像关心自己构造的模块一样，关心购买的模块，关心它们是怎样泄漏并深入你的系统中的。
* **抽象层会变臃肿。**一旦你定义了一个抽象层，它就开始增加功能。层是对使用模式优化的自然分界点。臃肿的层的困难在于，它往往会降低您利用底层的不断创新的能力。从某种意义上说，这就是操作系统公司憎恨构建在其核心功能之上的臃肿的层的原因——采用创新的速度放缓了。避免这种情况的一种比较规矩的方法是禁止在适配器层中进行任何额外的状态存储。微软基础类在 Win32 上采用这个一般方法。在短期内，将功能集成到现有层（最终会导致上述所有问题）而不是重构和重新推导是不可避免的。理解这一点的系统设计人员寻找分解和简化组件的方法，而不是在其中增加越来越多的功能。
### 爱因斯坦宇宙
几十年来，我一直在设计异步分布式系统，但是在微软内部的一次演讲中，SQL 架构师 Pat Helland 的一句话震惊了我。 “我们生活在爱因斯坦的宇宙中，没有同时性这种东西。”在构建分布式系统时（基本上我们构建的都是分布式系统），你无法隐藏系统的分布式特性。这是物理的。我一直感到远程过程调用在根本上错误的，这是一个原因，尤其是那些“透明的”远程过程调用，它们就是想隐藏分布式的交互本质。你需要拥抱系统的分布式特性，因为这些意义几乎总是需要通过系统设计和用户体验来完成。
拥抱分布式系统的本质则要遵循以下几个方面：
* 一开始就要思考设计对用户体验的影响，而不是试图在处理错误，取消请求和报告状态上打补丁。
* 使用异步技术来耦合组件。同步耦合是*不可能*的。如果某些行为看起来是同步的，是因为某些内部层尝试隐藏异步，这样做会遮蔽（但绝对不隐藏）系统运行时的基本行为特征。
* 认识到并且明确设计了交互状态机，这些状态表示长期的可靠的内部系统状态（而不是由深度调用堆栈中的变量值编码的临时，短暂和不可发现的状态）。
* 认识到失败是在所难免的。要保证能检测出分布式系统中的失败，唯一的办法就是直接看你的等待时间是否“太长”。这自然意味着[取消的等级最高](https://medium.com/@terrycrowley/how-to-think-about-cancellation-3516fc342ae#.3pfjc5b54)。系统的某一层（可能直接通向用户）需要决定等待时间是否过长，并取消操作。取消只是为了重建局部状态，回收局部的资源——没有办法在系统内广泛使用取消机制。有时用一种低成本，不可靠的方法广泛使用取消机制对优化性能可能有用。
* 认识到取消不是回滚，因为它只是回收本地资源和状态。如果回滚是必要的，它必须实现成一个端到端的功能。
* 承认永远不会真正知道分布式组件的状态。只要你发现一个状态，它可能就已经改变了。当你发送一个操作时，请求可能在传输过程中丢失，也可能被处理了但是返回的响应丢失了，或者请求需要一定的时间来处理，这样远程状态最终会在未来的某个任意的时间转换。这需要像幂等操作这样的方法，并且要能够稳健有效地重新发现远程状态，而不是期望可靠地跟踪分布式组件的状态。“[最终一致性](http://queue.acm.org/detail.cfm?id=2462076)”的概念简洁地捕捉了这其中大多数想法。
我喜欢说你应该“陶醉在异步”。与其试图隐藏异步，不如接受异步，为异步而设计。当你看到像幂等性或不变性这样的技术时，你就认识到它们是拥抱宇宙本质的方法，而不仅仅是工具箱中的一个设计工具。
### 性能
我确信 Don Knuth 会对人们怎样误解他的名言“过早的优化是一切罪恶的根源”而感到震惊。事实上，性能，及性能的持续超过 60 年的指数增长（或超过 10 年，取决于您是否愿意将晶体管，真空管和机电继电器的发展算入其中），为所有行业内的惊人创新和影响经济的“软件吃掉全世界”的变化打下了基础。
要认识到这种指数变化的一个关键是，虽然系统的所有组件正在经历指数级变化，但这些指数是不同的。硬盘容量的增长速度与内存容量的增长速度不同，与 CPU 的增长速度不同，与内存 CPU 之间的延迟的性能改善速度也不用。即使性能发展的趋势是由相同的基础技术驱动的，增长的指数也会有分歧。[延迟的改进跟不上带宽改善](http://www.ll.mit.edu/HPEC/agendas/proc04/invited/patterson_keynote.pdf)。指数变化在近距离或者短期内看起来是线性的，但随着时间的推移可能是压倒性的。系统不同组件的性能的增长不同，会出现压倒性的变化，并迫使对设计决策定期进行重新评估。
这样做的结果是，几年后，一度有意义的设计决策就不再有意义了。或者在某些情况下，二十年前有意义的方法又开始变成一个好的决策。现代内存映射的特点看起来更像是早期分时的进程切换，而不像分页那样。 （这样做有时会让我这样的老人说“这就是我们在 1975 年时用的方法”——忽略了这种方法在 40 年都没有意义，但现在又重新成为好的方法，因为两个组件之间的关系——可能是闪存和 NAND 而不是磁盘和核心内存——已经变得像以前一样了）。
当这些指数超越人自身的限制时，重要的转变就发生了。你能从 2 的 16 次方个字符（一个人可以在几个小时打这么多字）过渡到 2 的 32 次方个字符（远超出了一个人打字的范围）。你可以捕捉比人眼能感知的分辨率更高的数字图像。或者你可以将整个音乐专辑存在小巧的磁盘上，放在口袋里。或者你可以将数字化视频录制存储在硬盘上。再通过实时流式传输的能力，可以在一个地方集中存储一次，不需要在数千个本地硬盘上重复记录。
但有的东西仍然是根本的限制条件，那就是空间的三维和光速。我们又回到了爱因斯坦的宇宙。内存的分级结构将始终存在——它是物理定律的基础。稳定的存储和 IO、内存、计算和通信也都将一直存在。这些模块的相对容量，延迟和带宽将会改变，但是系统始终要考虑这些元素如何组合在一起，以及它们之间的平衡和折衷。Jim Gary 是这方面的大师。
空间和光速的根本限制造成的另一个后果是，性能分析主要是关于三件事：<ruby> 局部化 <rt> locality </rt></ruby>、<ruby> 局部化 <rt> locality </rt></ruby>、<ruby> 局部化 <rt> locality </rt></ruby>。无论是将数据打包在磁盘上，管理处理器缓存的层次结构，还是将数据合并到通信数据包中，数据如何打包在一起，如何在一段时间内从局部获取数据，数据如何在组件之间传输数据是性能的基础。把重点放在减少管理数据的代码上，增加空间和时间上的局部性，是消除噪声的好办法。
Jon Devaan 曾经说过：“设计数据，而不是设计代码”。这也通常意味着当查看系统结构时，我不太关心代码如何交互——我想看看数据如何交互和流动。如果有人试图通过描述代码结构来解释一个系统，而不理解数据流的速率和数量，他们就不了解这个系统。
内存的层级结构也意味着缓存将会一直存在——即使某些系统层正在试图隐藏它。缓存是根本的，但也是危险的。缓存试图利用代码的运行时行为，来改变系统中不同组件之间的交互模式。它们需要对运行时行为进行建模，即使模型填充缓存并使缓存失效，并测试缓存命中。如果模型由于行为改变而变差或变得不佳，缓存将无法按预期运行。一个简单的指导方针是，缓存必须被检测——由于应用程序行为的改变，事物不断变化的性质和组件之间性能的平衡，缓存的行为将随着时间的推移而退化。每一个老程序员都有缓存变糟的经历。
我很幸运，我的早期职业生涯是在互联网的发源地之一 BBN 度过的。 我们很自然地将将异步组件之间的通信视为系统连接的自然方式。流量控制和队列理论是通信系统的基础，更是任何异步系统运行的方式。流量控制本质上是资源管理（管理通道的容量），但资源管理是更根本的关注点。流量控制本质上也应该由端到端的应用负责，所以用端到端的方式思考异步系统是自然的。[缓冲区膨胀](https://en.wikipedia.org/wiki/Bufferbloat)的故事在这种情况下值得研究，因为它展示了当对端到端行为的动态性以及技术“改进”（路由器中更大的缓冲区）缺乏理解时，在整个网络基础设施中导致的长久的问题。
我发现“<ruby> 光速 <rt> light speed </rt></ruby>”的概念在分析任何系统时都非常有用。光速分析并不是从当前的性能开始分析，而是问“这个设计理论上能达到的最佳性能是多少？”真正传递的信息是什么，以什么样的速度变化？组件之间的底层延迟和带宽是多少？光速分析迫使设计师深入思考他们的方法能否达到性能目标，或者否需要重新考虑设计的基本方法。它也迫使人们更深入地了解性能在哪里损耗，以及损耗是由固有的，还是由于一些不当行为产生的。从构建的角度来看，它迫使系统设计人员了解其构建的模块的真实性能特征，而不是关注其他功能特性。
我的职业生涯大多花费在构建图形应用程序上。用户坐在系统的一端，定义关键的常量和约束。人类的视觉和神经系统没有经历过指数性的变化。它们固有地受到限制，这意味着系统设计者可以利用（必须利用）这些限制，例如，通过虚拟化（限制底层数据模型需要映射到视图数据结构中的数量），或者通过将屏幕更新的速率限制到人类视觉系统的感知限制。
### 复杂性的本质
我的整个职业生涯都在与复杂性做斗争。为什么系统和应用变得复杂呢？为什么在一个应用领域内进行开发并没有随着时间变得简单，而基础设施却没有变得更复杂，反而变得更强大了？事实上，管理复杂性的一个关键方法就是“走开”然后重新开始。通常新的工具或语言迫使我们从头开始，这意味着开发人员将工具的优点与从新开始的优点结合起来。从新开始是重要的。这并不是说新工具，新平台，或新语言可能不好，但我保证它们不能解决复杂性增长的问题。控制复杂性的最简单的方法就是用更少的程序员，建立一个更小的系统。
当然，很多情况下“走开”并不是一个选择——Office 软件建立在有巨大的价值的复杂的资源上。通过 OneNote， Office 从 Word 的复杂性上“走开”，从而在另一个维度上进行创新。Sway 是另一个例子， Office 决定从限制中跳出来，利用关键的环境变化，抓住机会从底层上采取全新的设计方案。我们有 Word、Excel、PowerPoint 这些应用，它们的数据结构非常有价值，我们并不能完全放弃这些数据结构，它们成为了开发中持续的显著的限制条件。
我受到 Fred Brook 讨论软件开发中的意外和本质的文章[《没有银弹》](http://worrydream.com/refs/Brooks-NoSilverBullet.pdf)的影响，他希望用两个趋势来尽可能地推动程序员的生产力：一是在选择自己开发还是购买时，更多地关注购买——这预示了开源社区和云架构的改变；二是从单纯的构建方法转型到更“有机”或者“生态”的增量开发方法。现代的读者可以认为是向敏捷开发和持续开发的转型。但那篇文章可是写于 1986 年！
我很欣赏 Stuart Kauffman 的在复杂性的基本性上的研究工作。Kauffman 从一个简单的布尔网络模型（“[NK 模型](https://en.wikipedia.org/wiki/NK_model)”）开始建立起来，然后探索这个基本的数学结构在相互作用的分子，基因网络，生态系统，经济系统，计算机系统（以有限的方式）等系统中的应用，来理解紧急有序行为的数学基础及其与混沌行为的关系。在一个高度连接的系统中，你固有地有一个相互冲突的约束系统，使得它（在数学上）很难向前发展（这被看作是在崎岖景观上的优化问题）。控制这种复杂性的基本方法是将系统分成独立元素并限制元素之间的相互连接（实质上减少 NK 模型中的“N”和“K”）。当然对那些使用复杂隐藏，信息隐藏和数据抽象，并且使用松散异步耦合来限制组件之间的交互的技术的系统设计者来说，这是很自然的。
我们一直面临的一个挑战是，我们想到的许多拓展系统的方法，都跨越了所有的方面。实时共同编辑是 Office 应用程序最近的一个非常具体的（也是最复杂的）例子。
我们的数据模型的复杂性往往等同于“能力”。设计用户体验的固有挑战是我们需要将有限的一组手势，映射到底层数据模型状态空间的转换。增加状态空间的维度不可避免地在用户手势中产生模糊性。这是“[纯数学](https://medium.com/@terrycrowley/the-math-of-easy-to-use-14645f819201#.untmk9eq7)”，这意味着确保系统保持“易于使用”的最基本的方式常常是约束底层的数据模型。
### 管理
我从高中开始担任一些领导角色（学生会主席！），对承担更多的责任感到理所当然。同时，我一直为自己在每个管理阶段都坚持担任全职程序员而感到自豪。但 Office 软件的开发副总裁最终还是让我从事管理，离开了日常的编程工作。当我在去年离开那份工作时，我很享受重返编程——这是一个出奇地充满创造力的充实的活动（当修完“最后”的 bug 时，也许也会有一点令人沮丧）。
尽管在我加入微软前已经做了十多年的“主管”，但是到了 1996 年我加入微软才真正了解到管理。微软强调“工程领导是技术领导”。这与我的观点一致，帮助我接受并承担更大的管理责任。
主管的工作是设计项目并透明地推进项目。透明并不简单，它不是自动的，也不仅仅是有好的意愿就行。透明需要被设计进系统中去。透明工作的最好方式是能够记录每个工程师每天活动的产出，以此来追踪项目进度（完成任务，发现 bug 并修复，完成一个情景）。留意主观上的红/绿/黄，点赞或踩的仪表板。
我过去说我的工作是设计反馈回路。独立工程师，经理，行政人员，每一个项目的参与者都能通过分析记录的项目数据，推进项目，产出结果，了解自己在整个项目中扮演的角色。最终，透明化最终成为增强能力的一个很好的工具——管理者可以将更多的局部控制权给予那些最接近问题的人，因为他们对所取得的进展有信心。这样的话，合作自然就会出现。
关键需要确定目标框架（包括关键资源的约束，如发布的时间表）。如果决策需要在管理链上下不断流动，那说明管理层对目标和约束的框架不好。
当我在 Beyond Software 工作时，我真正理解了一个项目拥有一个唯一领导的重要性。原来的项目经理离职了（后来从 FrontPage 团队雇佣了我）。我们四个主管在是否接任这个岗位上都有所犹豫，这不仅仅由于我们都不知道要在这家公司坚持多久。我们都技术高超，并且相处融洽，所以我们决定以同级的身份一起来领导这个项目。然而这槽糕透了。有一个显而易见的问题，我们没有相应的战略用来在原有的组织之间分配资源——这应当是管理者的首要职责之一！当你知道你是唯一的负责人时，你会有很深的责任感，但在这个例子中，这种责任感缺失了。我们没有真正的领导来负责统一目标和界定约束。
我有清晰地记得，我第一次充分认识到*倾听*对一个领导者的重要性。那时我刚刚担任了 Word、OneNote、Publisher 和 Text Services 团队的开发经理。关于我们如何组织文本服务团队，我们有一个很大的争议，我走到了每个关键参与者身边，听他们想说的话，然后整合起来，写下了我所听到的一切。当我向其中一位主要参与者展示我写下的东西时，他的反应是“哇，你真的听了我想说的话”！作为一名管理人员，我所经历的所有最大的问题（例如，跨平台和转型持续工程）涉及到仔细倾听所有的参与者。倾听是一个积极的过程，它包括：尝试以别人的角度去理解，然后写出我学到的东西，并对其进行测试，以验证我的理解。当一个关键的艰难决定需要发生的时候，在最终决定前，每个人都知道他们的想法都已经被听到并理解（不论他们是否同意最后的决定）。
在 FrontPage 团队担任开发经理的工作，让我理解了在只有部分信息的情况下做决定的“操作困境”。你等待的时间越长，你就会有更多的信息做出决定。但是等待的时间越长，实际执行的灵活性就越低。在某个时候，你仅需要做出决定。
设计一个组织涉及类似的两难情形。您希望增加资源领域，以便可以在更大的一组资源上应用一致的优先级划分框架。但资源领域越大，越难获得作出决定所需要的所有信息。组织设计就是要平衡这两个因素。软件复杂化，因为软件的特点可以在任意维度切入设计。Office 软件部门已经使用[共享团队](https://medium.com/@terrycrowley/breaking-conways-law-a0fdf8500413#.gqaqf1c5k)来解决这两个问题（优先次序和资源），让跨领域的团队能与需要产品的团队分享工作（增加资源）。
随着管理阶梯的提升，你会懂一个小秘密：你和你的新同事不会因为你现在承担更多的责任，就突然变得更聪明。这强调了整个组织比顶层领导者更聪明。赋予每个级别在一致框架下拥有自己的决定是实现这一目标的关键方法。听取并使自己对组织负责，阐明和解释决策背后的原因是另一个关键策略。令人惊讶的是，害怕做出一个愚蠢的决定可能是一个有用的激励因素，以确保你清楚地阐明你的推理，并确保你听取所有的信息。
### 结语
我离开大学寻找第一份工作时，面试官在最后一轮面试时问我对做“系统”和做“应用”哪一个更感兴趣。我当时并没有真正理解这个问题。在软件技术栈的每一个层面都会有趣的难题，我很高兴深入研究这些问题。保持学习。
---
via: <https://hackernoon.com/education-of-a-programmer-aaecf2d35312>
作者：[Terry Crowley](https://hackernoon.com/@terrycrowley) 译者：[explosic4](https://github.com/explosic4) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开始 Vagrant 之旅
|
Ruth Holloway
|
https://opensource.com/article/18/4/getting-started-vagrant
|
用管理虚拟机和容器的工具 Vagrant 清理你的开发环境和依赖。
|
/data/attachment/album/201805/23/114315cw6iy7ak7yikb9w9.jpg.thumb.jpg
|
/data/attachment/album/201805/23/114315cw6iy7ak7yikb9w9.jpg
| true | false | true |
MjSeven
| false |
[
"Vagrant"
] |
容器与云
|
{
"viewnum": 5165,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用管理虚拟机和容器的工具 Vagrant 清理你的开发环境和依赖。
| 2018-05-23T11:43:34 | 2018-05-23T11:43:34 | 9,671 |
/article-9671-1.html
|
>
> 用管理虚拟机和容器的工具 Vagrant 清理你的开发环境和依赖。
>
>
>
如果你和我一样，你可能在某一个地方有一个“沙盒”，你可以在那里进行你正在做的任何项目。随着时间的推移，沙盒会变得杂乱无章，充斥着各种想法、工具链元素、你不使用的代码模块，以及其他你不需要的东西。当你完成某件事情时，这会使你的部署变得复杂，因为你可能不确定项目的实际依赖关系 —— 随着时间推移你在沙盒中已经有了一些工具，但是你忘了必须安装它。你需要一个干净的环境，将所有的依赖关系放在一个地方，以便以后更方便。
或者你可能工作在 DevOps 中，你所服务的开发人员用模糊的依赖关系来编写代码，这使得测试变得更加困难。你需要一种方法来获得一个干净的盒子，将代码放入其中，并通过它运行代码，而且你希望这些环境是一次性的和可重复的。
那么选择 [Vagrant](https://vagrantup.com) 吧。由 HashiCorp 在 [MIT 许可证](https://opensource.org/licenses/MIT)下创建，Vagrant 可充当 VirtualBox、Microsoft Hyper-V 或 Docker 容器的包装器和前端，并且可以通过[许多其他供应商](https://github.com/hashicorp/vagrant/wiki/Available-Vagrant-Plugins#providers)的插件进行扩展。你可以配置 Vagrant 以提供可重复的、干净的环境，并且已安装需要的基础架构。配置脚本是可移植的，因此，如果你的仓库和 Vagrant 配置脚本位于基于云存储上，那么你只需要很少的限制就可以启动并在多台机器机器上工作。让我们来看一看。
### 安装
对于本次安装，我的环境是 Linux Mint 桌面，版本是 18.3 Cinnamon 64 位，在其他大多数 Debian 派生系统上安装非常类似。在大多数发行版中，对于基于 RPM 的系统也有类似的安装程序。Vagrant 的[安装页面](https://www.vagrantup.com/downloads.html)为 Debian、 Windows、 CentOS、 MacOS 和 Arch Linux 都提供下载，但是我在我的软件包管理器中找到了它，所以我在那进行了安装。
最简单的安装使用了 VirtualBox 作为虚拟化提供者，所以我需要安装它：
```
sudo apt-get install virtualbox vagrant
```
安装程序将会获取依赖项 —— 主要是 Ruby 的一些东西，安装它们。
### 建立一个项目
在设置你的项目之前，你需要了解一些你想要运行它的环境。你可以在 [Vagrant Boxes 仓库](https://app.vagrantup.com/boxes/search)中找到为许多虚拟化供应商提供的大量预配置的<ruby> 系统 <rt> box </rt></ruby>。许多会预先配置一些你可能需要的核心基础设置，比如 PHP、 MySQL 和 Apache，但是对于本次测试，我将安装一个 Debian 8 64 位 “Jessie” 裸机沙盒并手动安装一些东西，这样你就可以看到具体过程了。
```
mkdir ~/myproject
cd ~/myproject
vagrant init debian/contrib-jessie64
vagrant up
```
最后一条命令将根据需要从仓库中获取或更新 VirtualBox 镜像，然后运行启动器，你的系统上会出现一个运行的系统！下次启动这个项目时，除非镜像已经在仓库中更新，否则不会花费太长时间。
要访问该沙盒，只需要输入 `vagrant ssh`，你将进入虚拟机的全功能 SSH 会话中，你将会是 `vagrant` 用户，但也是 `sudo` 组的成员，所以你可以切换到 root，并在这里做你想做的任何事情。
你会在沙盒中看到一个名为 `/vagrant` 目录，对这个目录小心点，因为它与你主机上的 `~/myproject` 文件夹保持同步。在虚拟机 `/vagrant` 下建立一个文件它会立即复制到主机上，反之亦然。注意，有些沙盒并没有安装 VirtualBox 的附加功能，所以拷贝只能在启动时才起作用。有一些用于手动同步的命令行工具，这可能是测试环境中非常有用的特性。我倾向于坚持使用那些有附加功能的沙盒，所以这个目录可以正常工作，不必考虑它。
这个方案的好处很快显现出来了： 如果你在主机上有一个代码编辑工具链，并处于某种原因不希望它出现在虚拟机上，那么这不是问题 —— 在主机上进行编辑，虚拟机会立刻更改。快速更改虚拟机，它也将其同步到主机上的“官方”副本 。
让我们关闭这个系统，这样我们就可以在这个系统里提供一些我们需要的东西：
```
vagrant halt
```
### 在虚拟机上安装额外的软件
对于这个例子，我将使用 [Apache](https://httpd.apache.org/)、 [PostgreSQL](https://postgresql.org) 和 Perl 的 [Dancer](https://perldancer.org) web 框架进行项目开发。我将修改Vagrant 配置脚本，以便我需要的东西已经安装。 为了使之稍后更容易保持更新，我将在项目根目录下创建一个脚本`~/myproject/Vagrantfile`：
```
$provision_script = <<SCRIPT
export DEBIAN_FRONTEND=noninteractive
apt-get update
apt-get -y install \
apache2 \
postgresql-client-9.4 \
postgresql-9.4 \
libdbd-pg-perl \
libapache2-mod-fastcgi \
libdata-validate-email-perl \
libexception-class-perl \
libexception-class-trycatch-perl \
libtemplate-perl \
libtemplate-plugin-json-escape-perl \
libdbix-class-perl \
libyaml-tiny-perl \
libcrypt-saltedhash-perl \
libdancer2-perl \
libtemplate-plugin-gravatar-perl \
libtext-csv-perl \
libstring-tokenizer-perl \
cpanminus
cpanm -f -n \
Dancer2::Session::Cookie \
Dancer2::Plugin::DBIC \
Dancer2::Plugin::Auth::Extensible::Provider::DBIC \
Dancer2::Plugin::Locale \
Dancer2::Plugin::Growler
sudo a2enmod rewrite fastcgi
sudo apache2ctl restart
SCRIPT
```
在 Vagrantfile 结尾附近，你会发现一行 `config.vm.provision` 变量，正如你在示例中看到的那样，你可以在此处以内联方式进行操作，只需通过取消注释以下行：
```
# config.vm.provision "shell", inline: <<-SHELL
# sudo apt-get update
# sudo apt-get install -y apache2
# SHELL
```
相反，将那四行替换为使用你在文件顶部定义为变量的配置脚本：
```
config.vm.provision "shell", inline: $provision_script
```
你可能还希望将转发的端口设置为从主机访问虚拟机上的 Apache。寻找包含 `forwarded_port` 的行并取消注释它。如果你愿意，也可以将端口从 8080 更改为其他内容。我通常使用端口 5000，并在我的浏览器浏览 http://localhost:5000 就可以访问我虚拟机上的 Apache 服务器。
这里有一个设置提示：如果你的仓库位于云存储上，为了在多台机器上使用 Vagrant，你可能希望将不同机器上的 `VAGRANT_HOME` 环境变量设置为不同的东西。以 VirtualBox 的工作方式，你需要分别为这些系统存储状态信息，确保你的版本控制系统忽略了用于此的目录 —— 我将 `.vagrant.d*` 添加到仓库的 `.gitignore` 文件中。不过，我确实让 Vagrantfile 成为仓库的一部分！
### 好了！
我输入 `vagrant up`，我准备开始写代码了。一旦你做了一两次，你可能会想到你可以循环利用很多的 Vagrantfile 模板文件（就像我刚刚那样），这就是 Vagrant 的优势之一。你可以更快地完成实际的编码工作，并将很少的时间花在基础设施上！
你可以使用 Vagrant 做更多事情。配置工具存在于许多工具链中，因此，无论你需要复制什么环境，它都是快速而简单的。
---
via: <https://opensource.com/article/18/4/getting-started-vagrant>
作者：[Ruth Holloway](https://opensource.com/users/druthb) 选题：[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/) 荣誉推出
|
||
LikeCoin，一种给开放式许可的内容创作者的加密货币
|
Kin Ko
|
https://opensource.com/article/18/5/likecoin
|
在共创协议下授权作品和挣钱这二者不再是一种争议。
|
/data/attachment/album/201805/24/084556u7k0oguuuiu07ovh.jpg.thumb.jpg
|
/data/attachment/album/201805/24/084556u7k0oguuuiu07ovh.jpg
| true | false | true |
geekpi
| false |
[
"以太坊",
"CC",
"内容"
] |
观点
|
{
"viewnum": 4418,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
在共创协议下授权作品和挣钱这二者不再是一种争议。
| 2018-05-24T08:46:07 | 2018-05-24T08:46:07 | 9,674 |
/article-9674-1.html
|
>
> 在共创协议下授权作品和挣钱这二者不再是一种争议。
>
>
>
传统观点认为，作家、摄影师、艺术家和其他创作者在<ruby> 共创协议 <rt> Creative Commons </rt></ruby>和其他开放许可下免费共享内容的不会得到报酬。这意味着大多数独立创作者无法通过在互联网上发布他们的作品来赚钱。而现在有了 [LikeCoin](https://like.co/)：一个新的开源项目，旨在使这个让艺术家们经常为了贡献而不得不妥协或牺牲的常识成为过去。
LikeCoin 协议旨在通过创意内容获利，以便创作者可以专注于创造出色的内容而不是出售它。
该协议同样基于去中心化技术，它可以跟踪何时使用内容，并使用 LikeCoin 这种 [以太坊 ERC-20](https://en.wikipedia.org/wiki/ERC20) 加密货币通证来奖励其创作者。它通过“<ruby> 创造性共识 <rt> Proof of Creativity </rt></ruby>”算法进行操作，该算法一部分根据作品收到多少个“喜欢”，一部分根据有多少作品衍生自它而分配 LikeCoin。由于开放式授权的内容有更多机会被重复使用并获得 LikeCoin 令牌，因此系统鼓励内容创作者在<ruby> 共创协议 <rt> Creative Commons </rt></ruby>许可下发布。
### 如何运作的
当通过 LikeCoin 协议上传创意片段时，内容创作者也将包括作品的元数据，包括作者信息及其 InterPlanetary 关联数据（[IPLD](https://ipld.io/)）。这些数据构成了衍生作品的家族图谱；我们称作品与其衍生品之间的关系为“内容足迹”。这种结构使得内容的继承树可以很容易地追溯到原始作品。
LikeCoin 通证会使用作品的衍生历史记录的信息来将其分发给创作者。由于所有创意作品都包含作者钱包的元数据，因此相应的 LikeCoin 份额可以通过算法计算并分发。
LikeCoin 可以通过两种方式获得奖励：要么由想要通过支付给内容创建者来表示赞赏的个人直接给予，或通过 Creators Pool 收集观众的“赞”的并根据内容的 LikeRank 分配 LikeCoin。基于在 LikeCoin 协议中的内容追踪，LikeRank 衡量作品重要性（或者我们在这个场景下定义的创造性）。一般来说，一副作品有越多的衍生作品，创意内容的创新就越多，内容就会有更高的 LikeRank。 LikeRank 是内容创新性的量化者。
### 如何参与？
LikeCoin 仍然非常新，我们期望在 2018 年晚些时候推出我们的第一个去中心化程序来奖励<ruby> 共创协议 <rt> Creative Commons </rt></ruby>的内容，并与更大的社区无缝连接。
LikeCoin 的大部分代码都可以在 [LikeCoin GitHub](https://github.com/likecoin) 仓库中通过 [GPL 3.0 许可证](https://www.gnu.org/licenses/gpl-3.0.en.html)访问。由于它仍处于积极开发阶段，一些实验代码尚未公开，但我们会尽快完成。
我们欢迎功能请求、拉取请求、复刻和星标。请参与我们在 Github 上的开发，并加入我们在 [Telegram](https://t.me/likecoin) 的讨论组。我们同样在 [Medium](http://medium.com/likecoin)、[Facebook](http://fb.com/likecoin.foundation)、[Twitter](https://twitter.com/likecoin_fdn) 和我们的网站 [like.co](https://like.co/) 发布关于我们进展的最新消息。
---
via: <https://opensource.com/article/18/5/likecoin>
作者：[Kin Ko](https://opensource.com/users/ckxpress) 选题：[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 局域网路由新手指南：第 2 部分
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2018/3/linux-lan-routing-beginners-part-2
|
今天我们继续学习更精彩的内容：局域网路由器。
|
/data/attachment/album/201805/24/090919jy9w2h6eyysowa3s.jpg.thumb.jpg
|
/data/attachment/album/201805/24/090919jy9w2h6eyysowa3s.jpg
| true | false | true |
qhwdw
| false |
[
"IPv4",
"路由"
] |
技术
|
{
"viewnum": 8004,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9657,
"displayorder": 0
},
{
"raid": 9708,
"displayorder": 0
}
] |
今天我们继续学习更精彩的内容：局域网路由器。
| 2018-05-24T09:09:00 | 2018-05-24T09:09:00 | 9,675 |
/article-9675-1.html
|
上周 [我们学习了 IPv4 地址](/article-9657-1.html) 和如何使用管理员不可或缺的工具 —— `ipcalc`，今天我们继续学习更精彩的内容：局域网路由器。
VirtualBox 和 KVM 是测试路由的好工具，在本文中的所有示例都是在 KVM 中执行的。如果你喜欢使用物理硬件去做测试，那么你需要三台计算机：一台用作路由器，另外两台用于表示两个不同的网络。你也需要两台以太网交换机和相应的线缆。
我们假设这个示例是一个有线以太局域网，为了更符合真实使用场景，我们将假设有一些桥接的无线接入点，当然我并不会使用这些无线接入点做任何事情。（我也不会去尝试所有的无线路由器，以及使用一个移动宽带设备连接到以太网的局域网口进行混合组网，因为它们需要进一步的安装和设置）
### 网段
最简单的网段是两台计算机连接在同一个交换机上的相同地址空间中。这样两台计算机不需要路由器就可以相互通讯。这就是我们常说的术语 —— “广播域”，它表示所有在相同的网络中的一组主机。它们可能连接到一台单个的以太网交换机上，也可能是连接到多台交换机上。一个广播域可以包括通过以太网桥连接的两个不同的网络，通过网桥可以让两个网络像一个单个网络一样运转。无线访问点一般是桥接到有线以太网上。
一个广播域仅当在它们通过一台网络路由器连接的情况下，才可以与不同的广播域进行通讯。
### 简单的网络
以下示例的命令并不是永久生效的，重启之后你所做的改变将会消失。
一个广播域需要一台路由器才可以与其它广播域通讯。我们使用两台计算机和 `ip` 命令来解释这些。我们的两台计算机是 192.168.110.125 和 192.168.110.126，它们都插入到同一台以太网交换机上。在 VirtualBox 或 KVM 中，当你配置一个新网络的时候会自动创建一个虚拟交换机，因此，当你分配一个网络到虚拟虚拟机上时，就像是插入一个交换机一样。使用 `ip addr show` 去查看你的地址和网络接口名字。现在，这两台主机可以互 ping 成功。
现在，给其中一台主机添加一个不同网络的地址：
```
# ip addr add 192.168.120.125/24 dev ens3
```
你可以指定一个网络接口名字，在示例中它的名字是 `ens3`。这不需要去添加一个网络前缀，在本案例中，它是 `/24`，但是显式地添加它并没有什么坏处。你可以使用 `ip` 命令去检查你的配置。下面的示例输出为了清晰其见进行了删减：
```
$ ip addr show
ens3:
inet 192.168.110.125/24 brd 192.168.110.255 scope global dynamic ens3
valid_lft 875sec preferred_lft 875sec
inet 192.168.120.125/24 scope global ens3
valid_lft forever preferred_lft forever
```
主机在 192.168.120.125 上可以 ping 它自己（`ping 192.168.120.125`），这是对你的配置是否正确的一个基本校验，这个时候第二台计算机就已经不能 ping 通那个地址了。
现在我们需要做一些网络变更。添加第三台主机作为路由器。它需要两个虚拟网络接口并添加第二个虚拟网络。在现实中，你的路由器必须使用一个静态 IP 地址，但是现在，我们可以让 KVM 的 DHCP 服务器去为它分配地址，所以，你仅需要两个虚拟网络：
* 第一个网络：192.168.110.0/24
* 第二个网络：192.168.120.0/24
接下来你的路由器必须配置去转发数据包。数据包转发默认是禁用的，你可以使用 `sysctl` 命令去检查它的配置：
```
$ sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 0
```
`0` 意味着禁用，使用如下的命令去启用它：
```
# echo 1 > /proc/sys/net/ipv4/ip_forward
```
接下来配置你的另一台主机做为第二个网络的一部分，你可以通过将原来在 192.168.110.0/24 的网络中的一台主机分配到 192.168.120.0/24 虚拟网络中，然后重新启动两个 “连网的” 主机，注意不是路由器。（或者重启动主机上的网络服务；我年龄大了还有点懒，我记不住那些重启服务的奇怪命令，还不如重启主机来得干脆。）重启后各台机器的地址应该如下所示：
* 主机 1： 192.168.110.125
* 主机 2： 192.168.120.135
* 路由器： 192.168.110.126 和 192.168.120.136
现在可以去随意 ping 它们，可以从任何一台计算机上 ping 到任何一台其它计算机上。使用虚拟机和各种 Linux 发行版做这些事时，可能会产生一些意想不到的问题，因此，有时候 ping 的通，有时候 ping 不通。不成功也是一件好事，这意味着你需要动手去创建一条静态路由。首先，查看已经存在的路由表。主机 1 和主机 2 的路由表如下所示：
```
$ ip route show
default via 192.168.110.1 dev ens3 proto static metric 100
192.168.110.0/24 dev ens3 proto kernel scope link src 192.168.110.164 metric 100
$ ip route show
default via 192.168.110.1 dev ens3 proto static metric 100
default via 192.168.120.1 dev ens3 proto static metric 101
169.254.0.0/16 dev ens3 scope link metric 1000
192.168.110.0/24 dev ens3 proto kernel scope link
src 192.168.110.126 metric 100
192.168.120.0/24 dev ens9 proto kernel scope link
src 192.168.120.136 metric 100
```
这显示了我们使用的由 KVM 分配的缺省路由。169.\* 地址是自动链接的本地地址，我们不去管它。接下来我们看两条路由，这两条路由指向到我们的路由器。你可以有多条路由，在这个示例中我们将展示如何在主机 1 上添加一个非默认路由：
```
# ip route add 192.168.120.0/24 via 192.168.110.126 dev ens3
```
这意味着主机 1 可以通过路由器接口 192.168.110.126 去访问 192.168.110.0/24 网络。看一下它们是如何工作的？主机 1 和路由器需要连接到相同的地址空间，然后路由器转发到其它的网络。
以下的命令去删除一条路由：
```
# ip route del 192.168.120.0/24
```
在真实的案例中，你不需要像这样手动配置一台路由器，而是使用一个路由器守护程序，并通过 DHCP 做路由器通告，但是理解基本原理很重要。接下来我们将学习如何去配置一个易于使用的路由器守护程序来为你做这些事情。
通过来自 Linux 基金会和 edX 的免费课程 [“Linux 入门”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 来学习更多 Linux 的知识。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/3/linux-lan-routing-beginners-part-2>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 中轻松搜索和安装 Google Web 字体
|
Sk
|
https://www.ostechnix.com/font-finder-easily-search-and-install-google-web-fonts-in-linux/
|
Font Finder 是旧的 Typecatcher 的 Rust 实现，用于从 Google 的字体存档中轻松搜索和安装 Google Web 字体。
|
/data/attachment/album/201805/24/123748m7v2hgeh7ixhhxzj.png.thumb.jpg
|
/data/attachment/album/201805/24/123748m7v2hgeh7ixhhxzj.png
| true | false | true |
geekpi
| false |
[
"字体"
] |
分享
|
{
"viewnum": 5099,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Font Finder 是旧的 Typecatcher 的 Rust 实现，用于从 Google 的字体存档中轻松搜索和安装 Google Web 字体。
| 2018-05-24T12:37:47 | 2018-05-24T12:37:47 | 9,676 |
/article-9676-1.html
|
Font Finder 是旧的 [Typecatcher](https://www.ostechnix.com/install-google-web-fonts-ubuntu/) 的 Rust 实现，用于从 [Google 的字体存档](https://fonts.google.com/)中轻松搜索和安装 Google Web 字体。它可以帮助你在 Linux 桌面上安装数百种免费和开源字体。如果你正在为你的 Web 项目和应用以及其他任何地方寻找好看的字体，Font Finder 可以轻松地为你提供。它是用 Rust 编程语言编写的自由、开源的 GTK3 应用程序。与使用 Python 编写的 Typecatcher 不同，Font Finder 可以按类别过滤字体，没有 Python 运行时依赖关系，并且有更好的性能和更低的资源消耗。
在这个简短的教程中，我们将看到如何在 Linux 中安装和使用 Font Finder。
### 安装 Font Finder
由于 Fond Finder 是使用 Rust 语言编写的，因此你需要向下面描述的那样在系统中安装 Rust。
安装 Rust 后，运行以下命令安装 Font Finder：
```
$ cargo install fontfinder
```
Font Finder 也可以从 [flatpak app](https://flathub.org/apps/details/io.github.mmstick.FontFinder) 安装。首先在你的系统中安装 Flatpak，如下面的链接所述。
然后，使用命令安装 Font Finder：
```
$ flatpak install flathub io.github.mmstick.FontFinder
```
### 在 Linux 中使用 Font Finder 搜索和安装 Google Web 字体
你可以从程序启动器启动 Font Finder，也可以运行以下命令启动它。
```
$ flatpak run io.github.mmstick.FontFinder
```
这是 Font Finder 默认界面的样子。
正如你所看到的，Font Finder 的用户界面非常简单。所有 Google Web 字体都列在左侧窗格中，相应字体的预览显示在右侧窗格中。你可以在预览框中输入任何单词以查看单词在所选字体中的外观。在左上方还有一个搜索框，可以让你快速搜索你选择的字体。
默认情况下，Font Finder 显示所有类型的字体。但是，你可以通过搜索框上方的类别下拉框中的分类显示字体。
要安装字体，只需选择它并点击顶部的 “Install” 按钮即可。
你可以在任何文本处理程序中测试新安装的字体。
同样，要删除字体，只需从 Font Finder 面板中选择它并单击 “Uninstall” 按钮。就这么简单！
左上角的设置按钮（齿轮按钮）提供了切换到暗色预览的选项。
如你所见，Font Finder 非常简单，完全可以像在主页上宣传的那样完成工作。如果你正在寻找安装 Google Web 字体的程序，Font Finder 就是这样的一个程序。
今天就是这些。希望这有帮助。还有更好的东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/font-finder-easily-search-and-install-google-web-fonts-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[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/) 荣誉推出
|
||
使用树莓派构建一个婴儿监视器
|
Jonathan Ervine
|
https://opensource.com/article/18/3/build-baby-monitor-raspberry-pi
|
比一般的视频监控还要好，这种 DIY 型号还有婴儿房间的自动室温控制功能。
|
/data/attachment/album/201805/24/174758uck2cleyykckgomy.png.thumb.jpg
|
/data/attachment/album/201805/24/174758uck2cleyykckgomy.png
| true | false | true |
qhwdw
| false |
[
"树莓派"
] |
树莓派
|
{
"viewnum": 9425,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
比一般的视频监控还要好，这种 DIY 型号还有婴儿房间的自动室温控制功能。
| 2018-05-24T17:47:55 | 2018-05-24T17:47:55 | 9,677 |
/article-9677-1.html
|
>
> 比一般的视频监控还要好，这种 DIY 型号还有婴儿房间的自动室温控制功能。
>
>
>
香港很湿热，即便是晚上，许多人为了更舒适，在家里也使用空调。当我的大儿子还是一个小婴儿的时候，他卧室的空调还是需要手动控制的，没有温度自动调节的功能。它的控制器只有开或者关，让空调整个晚上持续运行会导致房间过冷，并且也浪费能源和钱。
我决定使用一个基于 [树莓派](https://opensource.com/tags/raspberry-pi) 的 [物联网](https://opensource.com/tags/internet-things) 解决方案去修复这个问题。后来我进一步为它添加了一个[婴儿监视器](https://opensource.com/article/17/9/gonimo)插件。在这篇文章中，我将解释我是如何做的，它的代码在 [我的 GitHub](https://github.com/jervine/rpi-temp-humid-monitor) 页面上。
### 设计空调控制器
解决我的问题的第一个部分是使用了一个 Orvibo S20 [可通过 WiFi 连接的智能插头](https://www.amazon.co.uk/marsboy-S20-Automation-Control-Smartphone/dp/B01LXKPUDK/ref=sr_1_1/258-6082934-2585109?ie=UTF8&qid=1520578769&sr=8-1&keywords=orvibo+s20)和智能手机应用程序。虽然这样可以让我通过远程来控制空调，但是它还是手动处理的，而我希望尝试让它自动化。我在 [Instructables](http://www.instructables.com/id/Raspberry-Pi-Temperature-Humidity-Network-Monitor/) 上找到了一个满足我的需求的项目：他使用树莓派从一个 [AM2302 传感器](https://www.adafruit.com/product/393) 上测量附近的温度和湿度，并将它们记录到一个 MySQL 数据库中。
使用压接头将温度/湿度传感器连接到树莓派的相应 GPIO 针脚上。幸运的是，AM2302 传感器有一个用于读取的 [开源软件](https://github.com/adafruit/Adafruit_Python_DHT)，并且同时提供了 [Python](https://opensource.com/tags/python) 示例。
与我的项目放在一起的用于 [AM2302 传感器](https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code/tree/legacy/Adafruit_DHT_Driver_Python) 接口的软件已经更新了，并且我使用的原始代码现在应该已经过时了，停止维护了。这个代码是由一个小的二进制组成，用于连接到传感器以及解释读取并返回正确值的 Python 脚本。
*树莓派、传感器、以及用于构建温度/湿度监视器的 Python 代码。*
将传感器连接到树莓派，这些 Python 代码能够正确地返回温度和湿度读数。将 Python 连接到 MySQL 数据库很简单，并且也有大量的使用 python-mysql 绑定的代码示例。因为我需要持续地监视温度和湿度，所以我写软件来实现这些。
事实上，最终我用了两个解决方案，一是作为一个持续运行的进程，周期性（一般是间隔一分钟）地获取传感器数据，另一种是让 Python 脚本运行一次然后退出。我决定使用第二种方法，并使用 cron 去每分钟调用一次这个脚本。之所以选择这种方法的主要原因是，（通过循环实现的）持续的脚本偶尔会不返回读数，这将导致尝试读取传感器的进程出现堆积，最终可能会导致系统挂起而缺乏可用资源。
我也找到了可以用程序来控制我的智能插头的一个 [Perl 脚本](https://github.com/franc-carter/bauhn-wifi)。它是解决这种问题所需的一部分，因此当某些温度/湿度达到触发条件，将触发这个 Perl 脚本。在做了一些测试之后，我决定去设计一个独立的 `checking` 脚本，从 MySQL 去拉取最新的数据，然后根据返回的值去设置智能开关为开或关。将插头控制逻辑与传感器读取脚本分开，意味着它们是各自独立运行的，就算是传感器读取脚本写的有问题也没事。
配置一个打开/关闭空调的温度值是很有意义的，因此，我将这些值转移到控制脚本读取的配置文件中。我也发现，虽然传感器的值一般都很准确，但是，偶尔也会出现返回不正确读数的情况。这个传感器脚本被修改为不向 MySQL 数据库中写入与前值差异非常大的值。同样也在配置文件中写入了连续读取的温度/湿度之间允许的最大差异值，如果读取的值处于这些限制值以外，这些值写不会提交到数据库中。
虽然，做这个自动调节器似乎花费了很多努力，但是，这意味着，记录到 MySQL 数据库的数据是有效的、可用于进一步去分析识别用户使用模式的有用数据。可以用多种图形方式去展示来自 MySQL 数据库中的数据，而我决定使用 [Google Chart](https://developers.google.com/chart/) 在一个 Web 页面上显示数据。
*过去六小时内测量到的温度和湿度*
### 添加一个婴儿监视摄像头
树莓派开放的性能意味着我可以不断地为它增加功能 —— 并且我有大量的未使用的可用 GPIO 针脚。我的下一个创意是去添加一个摄像头模块，将它放在孩子的卧室中，配置它去监视婴儿。
我需要一个能够在黑暗环境中工作的摄像头，而 [Pi Noir](https://www.raspberrypi.org/products/pi-noir-camera-v2/) 摄像头模块是非常适合这种条件的。Pi Noir 除了没有红外过滤之外，同样也是树莓派常用的摄像头模块。这意味着它在白天时的图像可能有点偏紫色，但是它可以在黑暗中借助红外灯来显示图像。
现在我需要一个红外光源。由于树莓派非常流行，并且进入门槛很低，因此它有大量的外围配件和插件。也有适合它的各种红外光源，我注意到的其中一个是 [Bright Pi](https://www.pi-supply.com/product/bright-pi-bright-white-ir-camera-light-raspberry-pi/)。它可以从树莓派上供电，并且它很适合为树莓派的摄像头模块提供红外光和普通光。它唯一的缺点是太考验我的焊接技能了。
我的焊接技能还是不错的，但是可能花费的时间比其他人更长。我成功地连接了外壳上所有的红外 LEDs，并将它们连接到树莓派的 GPIO 针脚上。这意味着树莓派能够编程控制红外 LED 是否点亮，以及它的亮度。
通过一个 Web 流去公开捕获的视频也很有意义，因为这样我就可以从 Web 页面上查看温度和湿度的读数图表。进一步研究之后，我选择了一个使用 M-JPEG 捕获器的 [流软件](https://elinux.org/RPi-Cam-Web-Interface)。通过 Web 页面公开 JPG 源，我可以在我的智能手机上去连接摄像头查看程序，去查看摄像头的输出。
### 做最后的修饰
没有哪个树莓派项目都已经完成了还没有为它选择一个合适的外壳，并且它有各种零件。在大量搜索和比较之后，有了一个显然的 [赢家](https://smarticase.com/collections/all/products/smartipi-kit-3)：SmartPi 的乐高积木式外壳。乐高的兼容性可以让我去安装温度/湿度传感器和摄像头。下面是最终的成果图：
在这以后，我对我的这个作品作了一些改变和更新：
* 我将它从树莓派 2 Model B 升级到了 [树莓派 3](https://opensource.com/article/18/3/raspberry-pi-3b-model-news)，这意味着我可以使用 USB WiFi 模块。
* 我用一个 [TP-Link HS110](https://www.tp-link.com/uk/products/details/cat-5258_HS110.html) 智能插头替换了 Orvibo S20。
* 我也将树莓派插到了一个智能插头上，这样我就可以远程重启/重置它了。
* 我从树莓派上将 MySQL 数据库移走了，它现在运行在一个 NAS 设备上的容器中。
* 我增加了一个非常 [灵活的三角夹](https://www.amazon.com/Flexpod-Flexible-Tripod-Discontinued-Manufacturer/dp/B000JC8WYA)，这样我就可以调整到最佳角度。
* 我重新编译了 USB WiFi 模块，禁用了板载 LED 指示灯，这就是升级到树莓派 3 的其中一个好处。
* 我因此为我的第二个孩子设计了另外一个监视器。
* 因为没有时间去折腾，我为我的第三个孩子购买了夜用摄像头。
想学习更多的东西吗？所有的代码都在 [我的 GitHub](https://github.com/jervine/rpi-temp-humid-monitor) 页面上。
想分享你的树莓派项目吗？[将你的故事和创意发送给我们](http://opensource.com/story)。
---
via: <https://opensource.com/article/18/3/build-baby-monitor-raspberry-pi>
作者：[Jonathan Ervine](https://opensource.com/users/jervine) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
You-Get：支持 80 多个网站的命令行多媒体下载器
|
Sk
|
https://www.ostechnix.com/you-get-a-cli-downloader-to-download-media-from-80-websites/
|
这是一个 Python 编写的命令行下载器，可以让你从 Youtube、Facebook、Twitter 等很多热门网站下载图片，音频和视频
|
/data/attachment/album/201805/25/091532ggbojrrbpzzt18xz.jpg.thumb.jpg
|
/data/attachment/album/201805/25/091532ggbojrrbpzzt18xz.jpg
| true | false | true |
pinewall
| false |
[
"下载",
"Youtube-dl",
"You-Get"
] |
分享
|
{
"viewnum": 11037,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这是一个 Python 编写的命令行下载器，可以让你从 Youtube、Facebook、Twitter 等很多热门网站下载图片，音频和视频
| 2018-05-25T09:15:28 | 2018-05-25T09:15:28 | 9,678 |
/article-9678-1.html
|
你们大多数人可能用过或听说过 **Youtube-dl**，这个命令行程序可以从包括 Youtube 在内的 100+ 网站下载视频。我偶然发现了一个类似的工具，名字叫做 **You-Get**。这是一个 Python 编写的命令行下载器，可以让你从 Youtube、Facebook、Twitter 等很多热门网站下载图片，音频和视频（LCTT 译注：首先，它们得是存在的网站）。目前该下载器支持 80+ 站点，点击[这里](https://you-get.org/#supported-sites)查看所有支持的网站。
You-Get 不仅仅是一个下载器，它还可以将在线视频导流至你的视频播放器。更进一步，它还允许你在 Google 上搜索视频，只要给出搜索项，You-Get 使用 Google 搜索并下载相关度最高的视频。另外值得一提的特性是，它允许你暂停和恢复下载过程。它是一个完全自由、开源及跨平台的应用，适用于 Linux、MacOS 及 Windows。
### 安装 You-Get
确保你已经安装如下依赖项：
* Python 3
* FFmpeg (强烈推荐) 或 Libav
* (可选) RTMPDump
有多种方式安装 You-Get，其中官方推荐采用 pip 包管理器安装。如果你还没有安装 pip，可以参考如下链接：
* [如何使用 pip 管理 Python 软件包](https://www.ostechnix.com/manage-python-packages-using-pip/)
需要注意的是，你需要安装 Python 3 版本的 `pip`。
接下来，运行如下命令安装 You-Get：
```
$ pip3 install you-get
```
可以使用命令升级 You-Get 至最新版本：
```
$ pip3 install --upgrade you-get
```
### 开始使用 You-Get
使用方式与 Youtube-dl 工具基本一致。
#### 下载视频
下载视频，只需运行：
```
$ you-get https://www.youtube.com/watch?v=HXaglTFJLMc
```
输出示例：
```
site: YouTube
title: The Last of The Mohicans by Alexandro Querevalú
stream:
- itag: 22
container: mp4
quality: hd720
size: 56.9 MiB (59654303 bytes)
# download-with: you-get --itag=22 [URL]
Downloading The Last of The Mohicans by Alexandro Querevalú.mp4 ...
100% ( 56.9/ 56.9MB) ├███████████████████████████████████████████████████████┤[1/1] 752 kB/s
```
下载视频前，你可能希望查看视频的细节信息。You-Get 提供了 `–info` 或 `-i` 参数，使用该参数可以获得给定视频所有可用的分辨率和格式。
```
$ you-get -i https://www.youtube.com/watch?v=HXaglTFJLMc
```
或者
```
$ you-get --info https://www.youtube.com/watch?v=HXaglTFJLMc
```
输出示例如下：
```
site: YouTube
title: The Last of The Mohicans by Alexandro Querevalú
streams: # Available quality and codecs
[ DASH ] ____________________________________
- itag: 137
container: mp4
quality: 1920x1080
size: 101.9 MiB (106816582 bytes)
# download-with: you-get --itag=137 [URL]
- itag: 248
container: webm
quality: 1920x1080
size: 90.3 MiB (94640185 bytes)
# download-with: you-get --itag=248 [URL]
- itag: 136
container: mp4
quality: 1280x720
size: 56.9 MiB (59672392 bytes)
# download-with: you-get --itag=136 [URL]
- itag: 247
container: webm
quality: 1280x720
size: 52.6 MiB (55170859 bytes)
# download-with: you-get --itag=247 [URL]
- itag: 135
container: mp4
quality: 854x480
size: 32.2 MiB (33757856 bytes)
# download-with: you-get --itag=135 [URL]
- itag: 244
container: webm
quality: 854x480
size: 28.0 MiB (29369484 bytes)
# download-with: you-get --itag=244 [URL]
[ DEFAULT ] _________________________________
- itag: 22
container: mp4
quality: hd720
size: 56.9 MiB (59654303 bytes)
# download-with: you-get --itag=22 [URL]
```
默认情况下，You-Get 会下载标记为 “DEFAULT” 的格式。如果你对格式或分辨率不满意，可以选择你喜欢的格式，使用格式对应的 itag 值即可。
```
$ you-get --itag=244 https://www.youtube.com/watch?v=HXaglTFJLMc
```
#### 下载音频
执行下面的命令，可以从 soundcloud 网站下载音频：
```
$ you-get 'https://soundcloud.com/uiceheidd/all-girls-are-same-999-prod-nick-mira'
Site: SoundCloud.com
Title: ALL GIRLS ARE THE SAME (PROD. NICK MIRA)
Type: MP3 (audio/mpeg)
Size: 2.58 MiB (2710046 Bytes)
Downloading ALL GIRLS ARE THE SAME (PROD. NICK MIRA).mp3 ...
100% ( 2.6/ 2.6MB) ├███████████████████████████████████████████████████████┤[1/1] 983 kB/s
```
查看音频文件细节，使用 `-i` 参数：
```
$ you-get -i 'https://soundcloud.com/uiceheidd/all-girls-are-same-999-prod-nick-mira'
```
#### 下载图片
运行如下命令下载图片：
```
$ you-get https://pixabay.com/en/mountain-crumpled-cyanus-montanus-3393209/
```
You-Get 也可以下载网页中的全部图片：
```
$ you-get https://www.ostechnix.com/pacvim-a-cli-game-to-learn-vim-commands/
```
#### 搜索视频
你只需向 You-Get 传递一个任意的搜索项，而无需给出有效的 URL；You-Get 会使用 Google 搜索并下载与你给出搜索项最相关的视频。(LCTT 译注：Google 的机器人检测机制可能导致 503 报错导致该功能无法使用）。
```
$ you-get 'Micheal Jackson'
Google Videos search:
Best matched result:
site: YouTube
title: Michael Jackson - Beat It (Official Video)
stream:
- itag: 43
container: webm
quality: medium
size: 29.4 MiB (30792050 bytes)
# download-with: you-get --itag=43 [URL]
Downloading Michael Jackson - Beat It (Official Video).webm ...
100% ( 29.4/ 29.4MB) ├███████████████████████████████████████████████████████┤[1/1] 2 MB/s
```
#### 观看视频
You-Get 可以将在线视频导流至你的视频播放器或浏览器，跳过广告和评论部分。（LCTT 译注：使用 `-p` 参数需要对应的 vlc/chrominum 命令可以调用，一般适用于具有图形化界面的操作系统）。
以 VLC 视频播放器为例，使用如下命令在其中观看视频：
```
$ you-get -p vlc https://www.youtube.com/watch?v=HXaglTFJLMc
```
或者
```
$ you-get --player vlc https://www.youtube.com/watch?v=HXaglTFJLMc
```
类似地，将视频导流至以 chromium 为例的浏览器中，使用如下命令：
```
$ you-get -p chromium https://www.youtube.com/watch?v=HXaglTFJLMc
```
在上述屏幕截图中，可以看到并没有广告和评论部分，只是一个包含视频的简单页面。
#### 设置下载视频的路径及文件名
默认情况下，使用视频标题作为默认文件名，下载至当前工作目录。当然，你可以按照你的喜好进行更改，使用 `–output-dir` 或 `-o` 参数可以指定路径，使用 `–output-filename` 或 `-O` 参数可以指定下载文件的文件名。
```
$ you-get -o ~/Videos -O output.mp4 https://www.youtube.com/watch?v=HXaglTFJLMc
```
#### 暂停和恢复下载
按 `CTRL+C` 可以取消下载。一个以 `.download` 为扩展名的临时文件会保存至输出路径。下次你使用相同的参数下载时，下载过程将延续上一次的过程。
当文件下载完成后，以 `.download` 为扩展名的临时文件会自动消失。如果这时你使用同样参数下载，You-Get 会跳过下载；如果你想强制重新下载，可以使用 `–force` 或 `-f` 参数。
查看命令的帮助部分可以获取更多细节，命令如下：
```
$ you-get --help
```
这次的分享到此结束，后续还会介绍更多的优秀工具，敬请期待！
感谢各位阅读！
---
via: <https://www.ostechnix.com/you-get-a-cli-downloader-to-download-media-from-80-websites/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Ubuntu 上安装和优化 Apache
|
Thishosting
|
https://thishosting.rocks/how-to-install-optimize-apache-ubuntu/
|
Apache (又名 httpd) 是最受欢迎和使用最广泛的 web 服务器，所以这应该对每个人都有用。
|
/data/attachment/album/201805/25/103013e2pkoalbrkk2t2rz.jpg.thumb.jpg
|
/data/attachment/album/201805/25/103013e2pkoalbrkk2t2rz.jpg
| true | false | true |
MjSeven
| false |
[
"Apache"
] |
技术
|
{
"viewnum": 7275,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Apache (又名 httpd) 是最受欢迎和使用最广泛的 web 服务器，所以这应该对每个人都有用。
| 2018-05-25T10:30:22 | 2018-05-25T10:30:22 | 9,679 |
/article-9679-1.html
|
这是我们的 LAMP 系列教程的开始：如何在 Ubuntu 上安装 Apache web 服务器。
这些说明适用于任何基于 Ubuntu 的发行版，包括 Ubuntu 14.04、 Ubuntu 16.04、 [Ubuntu 18.04](https://thishosting.rocks/ubuntu-18-04-new-features-release-date/)，甚至非 LTS 的 Ubuntu 发行版，例如 Ubuntu 17.10。这些说明经过测试并为 Ubuntu 16.04 编写。
Apache (又名 httpd) 是最受欢迎和使用最广泛的 web 服务器，所以这应该对每个人都有用。
### 开始安装 Apache 之前
在我们开始之前，这里有一些要求和说明：
* Apache 可能已经在你的服务器上安装了，所以开始之前首先检查一下。你可以使用 `apachectl -V` 命令来显示你正在使用的 Apache 的版本和一些其他信息。
* 你需要一个 Ubuntu 服务器。你可以从 [Vultr](https://thishosting.rocks/go/vultr/) 购买一个，它们是[最便宜的云托管服务商](https://thishosting.rocks/cheap-cloud-hosting-providers-comparison/)之一。它们的服务器价格每月 2.5 美元起。（LCTT 译注：广告 ≤\_≤ ）
* 你需要有 root 用户或具有 sudo 访问权限的用户。下面的所有命令都由 root 用户执行，所以我们不必为每个命令都添加 `sudo`。
* 如果你使用 Ubuntu，则需要[启用 SSH](https://thishosting.rocks/how-to-enable-ssh-on-ubuntu/)，如果你使用 Windows，则应该使用类似 [MobaXterm](https://mobaxterm.mobatek.net/) 的 SSH 客户端。
这就是全部要求和注释了，让我们进入安装过程。
### 在 Ubuntu 上安装 Apache
你需要做的第一件事就是更新 Ubuntu，这是在你做任何事情之前都应该做的。你可以运行：
```
apt-get update && apt-get upgrade
```
接下来，安装 Apache，运行以下命令：
```
apt-get install apache2
```
如果你愿意，你也可以安装 Apache 文档和一些 Apache 实用程序。对于我们稍后将要安装的一些模块，你将需要一些 Apache 实用程序。
```
apt-get install apache2-doc apache2-utils
```
\**就是这样。你已经成功安装了 Apache \**
你仍然需要配置它。
### 在 Ubuntu 上配置和优化 Apache
你可以在 Apache 上做各种各样的配置，但是主要的和最常见的配置将在下面做出解释。
#### 检查 Apache 是否正在运行
默认情况下，Apache 设置为在机器启动时自动启动，因此你不必手动启用它。你可以使用以下命令检查它是否正在运行以及其他相关信息：
```
systemctl status apache2
```
[](https://thishosting.rocks/wp-content/uploads/2018/01/apache-running.jpg)
并且你可以检查你正在使用的版本：
```
apachectl -V
```
一种更简单的检查方法时访问服务器的 IP 地址，如果你得到默认的 Apache 页面，那么一切都正常。
#### 更新你的防火墙
如果你使用防火墙（你应该使用它），则可能需要更新防火墙规则并允许访问默认端口。Ubuntu 上最常用的防火墙是 UFW，因此以下说明使用于 UFW。
要允许通过 80（http）和 443（https）端口的流量，运行以下命令：
```
ufw allow 'Apache Full'
```
#### 安装常见的 Apache 模块
一些模块经常被建议使用，所以你应该安装它们。我们将包含最常见模块的说明：
##### 使用 PageSpeed 加速你的网站
PageSpeed 模块将自动优化并加速你的 Apache 服务器。
首先，进入 [PageSpeed 下载页](https://www.modpagespeed.com/doc/download)并选择你需要的的文件。我们使用的是 64 位 Ubuntu 服务器，所以我们安装最新的稳定版本。使用 `wget` 下载它：
```
wget https://dl-ssl.google.com/dl/linux/direct/mod-pagespeed-stable_current_amd64.deb
```
然后，使用以下命令安装它：
```
dpkg -i mod-pagespeed-stable_current_amd64.deb
apt-get -f install
```
重启 Apache 以使更改生效：
```
systemctl restart apache2
```
##### 使用 mod\_rewrite 模块启动重写/重定向
顾名思义，该模块用于重写（重定向）。如果你使用 WordPress 或任何其他 CMS 来处理此问题，你就需要它。要安装它，只需运行：
```
a2enmod rewrite
```
然后再次重新启动 Apache。你可能需要一些额外的配置，具体取决于你使用的 CMS，如果有的话。为你的设置 Google 一下得到它的具体说明。
##### 使用 ModSecurity 模块保护你的 Apache
顾名思义，ModSecurity 是一个用于安全性的模块，它基本上起着防火墙的作用，它可以监控你的流量。要安装它，运行以下命令：
```
apt-get install libapache2-modsecurity
```
再次重启 Apache：
```
systemctl restart apache2
```
ModSecurity 自带了一个默认的设置，但如果你想扩展它，你可以使用 [OWASP 规则集](https://www.owasp.org/index.php/Category:OWASP_ModSecurity_Core_Rule_Set_Project)。
##### 使用 mod\_evasive 模块抵御 DDoS 攻击
尽管 mod\_evasive 在防止攻击方面有多大用处值得商榷，但是你可以使用它来阻止和防止服务器上的 DDoS 攻击。要安装它，使用以下命令：
```
apt-get install libapache2-mod-evasive
```
默认情况下，mod\_evasive 是禁用的，要启用它，编辑以下文件：
```
nano /etc/apache2/mods-enabled/evasive.conf
```
取消注释所有行（即删除 `#`），根据你的要求进行配置。如果你不知道要编辑什么，你可以保持原样。
[](https://thishosting.rocks/wp-content/uploads/2018/01/mod_evasive.jpg)
创建一个日志文件：
```
mkdir /var/log/mod_evasive
chown -R www-data:www-data /var/log/mod_evasive
```
就是这样。现在重启 Apache 以使更改生效。
```
systemctl restart apache2
```
你可以安装和配置[附加模块](https://httpd.apache.org/docs/2.4/mod/)，但完全取决于你和你使用的软件。它们通常不是必需的。甚至我们上面包含的 4 个模块也不是必需的。如果特定应用需要模块，那么它们可能会注意到这一点。
#### 用 Apache2Buddy 脚本优化 Apache
Apache2Buddy 是一个可以自动调整 Apache 配置的脚本。你唯一需要做的就是运行下面的命令，脚本会自动完成剩下的工作：
```
curl -sL https://raw.githubusercontent.com/richardforth/apache2buddy/master/apache2buddy.pl | perl
```
如果你没有安装 `curl`，那么你可能需要安装它。使用以下命令来安装 `curl`：
```
apt-get install curl
```
#### 额外配置
用 Apache 还可以做一些额外的东西，但我们会留下它们作为另一个教程。像启用 http/2 支持，关闭（或打开） KeepAlive，调整你的 Apache 甚至更多。这些东西你现在不需要做，但是如果你在网上找到了教程，并且如果你等不及我们的教程，那就去做吧。
### 使用 Apache 创建你的第一个网站
现在我们已经完成了所有的调优工作，让我们开始创建一个实际的网站。按照我们的指示创建一个简单的 HTML 页面和一个在 Apache 上运行的虚拟主机。
你需要做的第一件事是为你的网站创建一个新的目录。运行以下命令来执行此操作：
```
mkdir -p /var/www/example.com/public_html
```
当然，将 `example.com` 替换为你所需的域名。你可以从 [Namecheap](https://thishosting.rocks/neamcheap-review-cheap-domains-cool-names) 获得一个便宜的域名。
不要忘记在下面的所有命令中替换 `example.com`。
接下来，创建一个简单的静态网页。创建 HTML 文件：
```
nano /var/www/example.com/public_html/index.html
```
粘贴这些：
```
<html>
<head>
<title>Simple Page</title>
</head>
<body>
<p>If you're seeing this in your browser then everything works.</p>
</body>
</html>
```
保存并关闭文件。
配置目录的权限：
```
chown -R www-data:www-data /var/www/example.com
chmod -R og-r /var/www/example.com
```
为你的网站创建一个新的虚拟主机：
```
nano /etc/apache2/sites-available/example.com.conf
```
粘贴以下内容：
```
<VirtualHost *:80>
ServerAdmin admin@example.com
ServerName example.com
ServerAlias www.example.com
DocumentRoot /var/www/example.com/public_html
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
```
这是一个基础的虚拟主机。根据你的设置，你可能需要更高级的 `.conf` 文件。
在更新所有内容后保存并关闭文件。
现在，使用以下命令启用虚拟主机：
```
a2ensite example.com.conf
```
最后，重启 Apache 以使更改生效：
```
systemctl restart apache2
```
这就是全部了，你做完了。现在你可以访问 example.com 并查看你的页面。
---
via: <https://thishosting.rocks/how-to-install-optimize-apache-ubuntu/>
作者：[ThisHosting](https://thishosting.rocks) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 CentOS 6 系统上安装最新版 Python3 软件包的 3 种方法
|
Prakash Subramanian
|
https://www.2daygeek.com/3-methods-to-install-latest-python3-package-on-centos-6-system/
|
在本教程中，我们将向你展示，如何在 CentOS 6 操作系统上安装最新版本的 Python 3 软件包。
|
/data/attachment/album/201805/26/071008ki1rmqmar1q9yhyr.png.thumb.jpg
|
/data/attachment/album/201805/26/071008ki1rmqmar1q9yhyr.png
| true | false | true |
pinewall
| false |
[
"Python"
] |
技术
|
{
"viewnum": 6572,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本教程中，我们将向你展示，如何在 CentOS 6 操作系统上安装最新版本的 Python 3 软件包。
| 2018-05-26T07:10:31 | 2018-05-26T07:10:31 | 9,680 |
/article-9680-1.html
|
CentOS 克隆自 RHEL，无需付费即可使用。CentOS 是一个企业级标准的、前沿的操作系统，被超过 90% 的网络主机托管商采用，因为它提供了技术领先的服务器控制面板 cPanel/WHM。
该控制面板使得用户无需进入命令行即可通过其管理一切。
众所周知，RHEL 提供长期支持，出于稳定性考虑，不提供最新版本的软件包。
如果你想安装的最新版本软件包不在默认源中，你需要手动编译源码安装。但手动编译安装的方式有不小的风险，即如果出现新版本，无法升级手动安装的软件包；你不得不重新手动安装。
那么在这种情况下，安装最新版软件包的推荐方法和方案是什么呢？是的，可以通过为系统添加所需的第三方源来达到目的。
可供企业级 Linux 使用的第三方源有很多，但只有几个是 CentOS 社区推荐使用的，它们在很大程度上不修改基础软件包。
这几个推荐的源维护的很好，为 CentOS 提供大量补充软件包。
在本教程中，我们将向你展示，如何在 CentOS 6 操作系统上安装最新版本的 Python 3 软件包。
### 方法 1：使用 Software Collections 源 （SCL）
SCL 源目前由 CentOS SIG 维护，除了重新编译构建 Red Hat 的 Software Collections 外，还额外提供一些它们自己的软件包。
该源中包含不少程序的更高版本，可以在不改变原有旧版本程序包的情况下安装，使用时需要通过 `scl` 命令调用。
运行如下命令可以在 CentOS 上安装 SCL 源：
```
# yum install centos-release-scl
```
检查可用的 Python 3 版本：
```
# yum info rh-python35
Loaded plugins: fastestmirror, security
Loading mirror speeds from cached hostfile
* epel: ewr.edge.kernel.org
* remi-safe: mirror.team-cymru.com
Available Packages
Name : rh-python35
Arch : x86_64
Version : 2.0
Release : 2.el6
Size : 0.0
Repo : installed
From repo : centos-sclo-rh
Summary : Package that installs rh-python35
License : GPLv2+
Description : This is the main package for rh-python35 Software Collection.
```
运行如下命令从 `scl` 源安装可用的最新版 python 3：
```
# yum install rh-python35
```
运行如下特殊的 `scl` 命令，在当前 shell 中启用安装的软件包：
```
# scl enable rh-python35 bash
```
运行如下命令检查安装的 python3 版本：
```
# python --version
Python 3.5.1
```
运行如下命令获取系统已安装的 SCL 软件包列表：
```
# scl -l
rh-python35
```
### 方法 2：使用 EPEL 源 (Extra Packages for Enterprise Linux）
EPEL 是 Extra Packages for Enterprise Linux 的缩写，该源由 Fedora SIG （Special Interest Group）维护。
该 SIG 为企业级 Linux 创建、维护并管理了一系列高品质补充软件包，受益的企业级 Linux 发行版包括但不限于红帽企业级 Linux （RHEL）、 CentOS、 Scientific Linux （SL） 和 Oracle Linux （OL）等。
EPEL 通常基于 Fedora 对应代码提供软件包，不会与企业级 Linux 发行版中的基础软件包冲突或替换其中的软件包。
**推荐阅读：** [在 RHEL, CentOS, Oracle Linux 或 Scientific Linux 上安装启用 EPEL 源](https://www.2daygeek.com/install-enable-epel-repository-on-rhel-centos-scientific-linux-oracle-linux/)
EPEL 软件包位于 CentOS 的 Extra 源中，已经默认启用，故我们只需运行如下命令即可：
```
# yum install epel-release
```
检查可用的 python 3 版本：
```
# yum --disablerepo="*" --enablerepo="epel" info python34
Loaded plugins: fastestmirror, security
Loading mirror speeds from cached hostfile
* epel: ewr.edge.kernel.org
Available Packages
Name : python34
Arch : x86_64
Version : 3.4.5
Release : 4.el6
Size : 50 k
Repo : epel
Summary : Version 3 of the Python programming language aka Python 3000
URL : http://www.python.org/
License : Python
Description : Python 3 is a new version of the language that is incompatible with the 2.x
: line of releases. The language is mostly the same, but many details, especially
: how built-in objects like dictionaries and strings work, have changed
: considerably, and a lot of deprecated features have finally been removed.
```
运行如下命令从 EPEL 源安装可用的最新版 python 3 软件包：
```
# yum --disablerepo="*" --enablerepo="epel" install python34
```
默认情况下并不会安装 `pip` 和 `setuptools`，我们需要运行如下命令手动安装：
```
# curl -O https://bootstrap.pypa.io/get-pip.py
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 1603k 100 1603k 0 0 2633k 0 --:--:-- --:--:-- --:--:-- 4816k
# /usr/bin/python3.4 get-pip.py
Collecting pip
Using cached https://files.pythonhosted.org/packages/0f/74/ecd13431bcc456ed390b44c8a6e917c1820365cbebcb6a8974d1cd045ab4/pip-10.0.1-py2.py3-none-any.whl
Collecting setuptools
Downloading https://files.pythonhosted.org/packages/8c/10/79282747f9169f21c053c562a0baa21815a8c7879be97abd930dbcf862e8/setuptools-39.1.0-py2.py3-none-any.whl (566kB)
100% |████████████████████████████████| 573kB 4.0MB/s
Collecting wheel
Downloading https://files.pythonhosted.org/packages/1b/d2/22cde5ea9af055f81814f9f2545f5ed8a053eb749c08d186b369959189a8/wheel-0.31.0-py2.py3-none-any.whl (41kB)
100% |████████████████████████████████| 51kB 8.0MB/s
Installing collected packages: pip, setuptools, wheel
Successfully installed pip-10.0.1 setuptools-39.1.0 wheel-0.31.0
```
运行如下命令检查已安装的 python3 版本：
```
# python3 --version
Python 3.4.5
```
### 方法 3：使用 IUS 社区源
IUS 社区是 CentOS 社区批准的第三方 RPM 源，为企业级 Linux （RHEL 和 CentOS） 5、 6 和 7 版本提供最新上游版本的 PHP、 Python、 MySQL 等软件包。
IUS 社区源依赖于 EPEL 源，故我们需要先安装 EPEL 源，然后再安装 IUS 社区源。按照下面的步骤安装启用 EPEL 源和 IUS 社区源，利用该 RPM 系统安装软件包。
**推荐阅读：** [在 RHEL 或 CentOS 上安装启用 IUS 社区源](https://www.2daygeek.com/install-enable-ius-community-repository-on-rhel-centos/)
EPEL 软件包位于 CentOS 的 Extra 源中，已经默认启用，故我们只需运行如下命令即可：
```
# yum install epel-release
```
下载 IUS 社区源安装脚本：
```
# curl 'https://setup.ius.io/' -o setup-ius.sh
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 1914 100 1914 0 0 6563 0 --:--:-- --:--:-- --:--:-- 133k
```
安装启用 IUS 社区源：
```
# sh setup-ius.sh
```
检查可用的 python 3 版本：
```
# yum --enablerepo=ius info python36u
Loaded plugins: fastestmirror, security
Loading mirror speeds from cached hostfile
* epel: ewr.edge.kernel.org
* ius: mirror.team-cymru.com
* remi-safe: mirror.team-cymru.com
Available Packages
Name : python36u
Arch : x86_64
Version : 3.6.5
Release : 1.ius.centos6
Size : 55 k
Repo : ius
Summary : Interpreter of the Python programming language
URL : https://www.python.org/
License : Python
Description : Python is an accessible, high-level, dynamically typed, interpreted programming
: language, designed with an emphasis on code readability.
: It includes an extensive standard library, and has a vast ecosystem of
: third-party libraries.
:
: The python36u package provides the "python3.6" executable: the reference
: interpreter for the Python language, version 3.
: The majority of its standard library is provided in the python36u-libs package,
: which should be installed automatically along with python36u.
: The remaining parts of the Python standard library are broken out into the
: python36u-tkinter and python36u-test packages, which may need to be installed
: separately.
:
: Documentation for Python is provided in the python36u-docs package.
:
: Packages containing additional libraries for Python are generally named with
: the "python36u-" prefix.
```
运行如下命令从 IUS 源安装最新可用版本的 python 3 软件包：
```
# yum --enablerepo=ius install python36u
```
运行如下命令检查已安装的 python3 版本：
```
# python3.6 --version
Python 3.6.5
```
---
via: <https://www.2daygeek.com/3-methods-to-install-latest-python3-package-on-centos-6-system/>
作者：[PRAKASH SUBRAMANIAN](https://www.2daygeek.com/author/prakash/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
更深入的理解 Python 中的迭代
|
Trey Hunner
|
https://opensource.com/article/18/3/loop-better-deeper-look-iteration-python
|
在这篇文章中，我们将深入探讨 Python 的 for 循环来看看它们在底层如何工作，以及为什么它们会按照它们的方式工作。
|
/data/attachment/album/201805/26/080352ai3a6qticbnnbb8o.jpg.thumb.jpg
|
/data/attachment/album/201805/26/080352ai3a6qticbnnbb8o.jpg
| true | false | true |
MjSeven
| false |
[
"Python",
"循环",
"迭代"
] |
软件开发
|
{
"viewnum": 6880,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我们将深入探讨 Python 的 for 循环来看看它们在底层如何工作，以及为什么它们会按照它们的方式工作。
| 2018-05-26T08:04:00 | 2018-05-26T08:04:00 | 9,681 |
/article-9681-1.html
|
>
> 深入探讨 Python 的 `for` 循环来看看它们在底层如何工作，以及为什么它们会按照它们的方式工作。
>
>
>
Python 的 `for` 循环不会像其他语言中的 `for` 循环那样工作。在这篇文章中，我们将深入探讨 Python 的 `for` 循环来看看它们在底层如何工作，以及为什么它们会按照它们的方式工作。
### 循环的问题
我们将通过看一些“陷阱”开始我们的旅程，在我们了解循环如何在 Python 中工作之后，我们将再次看看这些问题并解释发生了什么。
#### 问题 1：循环两次
假设我们有一个数字列表和一个生成器，生成器会返回这些数字的平方：
```
>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)
```
我们可以将生成器对象传递给 `tuple` 构造器，从而使其变为一个元组：
```
>>> tuple(squares)
(1, 4, 9, 25, 49)
```
如果我们使用相同的生成器对象并将其传给 `sum` 函数，我们可能会期望得到这些数的和，即 `88`。
```
>>> sum(squares)
0
```
但是我们得到了 `0`。
#### 问题 2：包含的检查
让我们使用相同的数字列表和相同的生成器对象：
```
>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)
```
如果我们询问 `9` 是否在 `squares` 生成器中，Python 将会告诉我们 9 在 `squares` 中。但是如果我们再次询问相同的问题，Python 会告诉我们 9 不在 `squares` 中。
```
>>> 9 in squares
True
>>> 9 in squares
False
```
我们询问相同的问题两次，Python 给了两个不同的答案。
#### 问题 3 ：拆包
这个字典有两个键值对：
```
>>> counts = {'apples': 2, 'oranges': 1}
```
让我们使用多个变量来对这个字典进行拆包：
```
>>> x, y = counts
```
你可能会期望当我们对这个字典进行拆包时，我们会得到键值对或者得到一个错误。
但是解包字典不会引发错误，也不会返回键值对。当你解包一个字典时，你会得到键：
```
>>> x
'apples'
```
### 回顾：Python 的 for 循环
在我们了解一些关于这些 Python 片段的逻辑之后，我们将回到这些问题。
Python 没有传统的 `for` 循环。为了解释我的意思，让我们看一看另一种编程语言的 `for` 循环。
这是一种传统 C 风格的 `for` 循环，用 JavaScript 编写：
```
let numbers = [1, 2, 3, 5, 7];
for (let i = 0; i < numbers.length; i += 1) {
print(numbers[i])
}
```
JavaScript、 C、 C++、 Java、 PHP 和一大堆其他编程语言都有这种风格的 `for` 循环，但是 Python **确实没有**。
Python **确实没有** 传统 C 风格的 `for` 循环。在 Python 中确实有一些我们称之为 `for` 循环的东西，但是它的工作方式类似于 [foreach 循环](https://en.wikipedia.org/wiki/Foreach_loop)。
这是 Python 的 `for` 循环的风格：
```
numbers = [1, 2, 3, 5, 7]
for n in numbers:
print(n)
```
与传统 C 风格的 `for` 循环不同，Python 的 `for` 循环没有索引变量，没有索引变量初始化，边界检查，或者索引递增。Python 的 `for` 循环完成了对我们的 `numbers` 列表进行遍历的所有工作。
因此，当我们在 Python 中确实有 `for` 循环时，我们没有传统 C 风格的 `for` 循环。我们称之为 for 循环的东西的工作机制与之相比有很大的不同。
### 定义：可迭代和序列
既然我们已经解决了 Python 世界中无索引的 `for` 循环，那么让我们在此之外来看一些定义。
**可迭代**是任何你可以用 Python 中的 `for` 循环遍历的东西。可迭代意味着可以遍历，任何可以遍历的东西都是可迭代的。
```
for item in some_iterable:
print(item)
```
序列是一种非常常见的可迭代类型，列表，元组和字符串都是序列。
```
>>> numbers = [1, 2, 3, 5, 7]
>>> coordinates = (4, 5, 7)
>>> words = "hello there"
```
序列是可迭代的，它有一些特定的特征集。它们可以从 `0` 开始索引，以小于序列的长度结束，它们有一个长度并且它们可以被切分。列表，元组，字符串和其他所有序列都是这样工作的。
```
>>> numbers[0]
1
>>> coordinates[2]
7
>>> words[4]
'o'
```
Python 中很多东西都是可迭代的，但不是所有可迭代的东西都是序列。集合、字典、文件和生成器都是可迭代的，但是它们都不是序列。
```
>>> my_set = {1, 2, 3}
>>> my_dict = {'k1': 'v1', 'k2': 'v2'}
>>> my_file = open('some_file.txt')
>>> squares = (n**2 for n in my_set)
```
因此，任何可以用 `for` 循环遍历的东西都是可迭代的，序列只是一种可迭代的类型，但是 Python 也有许多其他种类的迭代器。
### Python 的 for 循环不使用索引
你可能认为，Python 的 `for` 循环在底层使用了索引进行循环。在这里我们使用 `while` 循环和索引手动遍历：
```
numbers = [1, 2, 3, 5, 7]
i = 0
while i < len(numbers):
print(numbers[i])
i += 1
```
这适用于列表，但它不会对所有东西都起作用。这种循环方式**只适用于序列**。
如果我们尝试用索引去手动遍历一个集合，我们会得到一个错误：
```
>>> fruits = {'lemon', 'apple', 'orange', 'watermelon'}
>>> i = 0
>>> while i < len(fruits):
... print(fruits[i])
... i += 1
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
TypeError: 'set' object does not support indexing
```
集合不是序列，所以它们不支持索引。
我们不能使用索引手动对 Python 中的每一个迭代对象进行遍历。对于那些不是序列的迭代器来说，这是行不通的。
### 迭代器驱动 for 循环
因此，我们已经看到，Python 的 `for` 循环在底层不使用索引。相反，Python 的 `for` 循环使用**迭代器**。
迭代器就是可以驱动可迭代对象的东西。你可以从任何可迭代对象中获得迭代器，你也可以使用迭代器来手动对它的迭代进行遍历。
让我们来看看它是如何工作的。
这里有三个可迭代对象：一个集合，一个元组和一个字符串。
```
>>> numbers = {1, 2, 3, 5, 7}
>>> coordinates = (4, 5, 7)
>>> words = "hello there"
```
我们可以使用 Python 的内置 `iter` 函数来访问这些迭代器，将一个迭代器传递给 `iter` 函数总会给我们返回一个迭代器，无论我们正在使用哪种类型的迭代器。
```
>>> iter(numbers)
<set_iterator object at 0x7f2b9271c860>
>>> iter(coordinates)
<tuple_iterator object at 0x7f2b9271ce80>
>>> iter(words)
<str_iterator object at 0x7f2b9271c860>
```
一旦我们有了迭代器，我们可以做的事情就是通过将它传递给内置的 `next` 函数来获取它的下一项。
```
>>> numbers = [1, 2, 3]
>>> my_iterator = iter(numbers)
>>> next(my_iterator)
1
>>> next(my_iterator)
2
```
迭代器是有状态的，这意味着一旦你从它们中消耗了一项，它就消失了。
如果你从迭代器中请求 `next` 项，但是其中没有更多的项了，你将得到一个 `StopIteration` 异常：
```
>>> next(my_iterator)
3
>>> next(my_iterator)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
```
所以你可以从每个迭代中获得一个迭代器，迭代器唯一能做的事情就是用 `next` 函数请求它们的下一项。如果你将它们传递给 `next`，但它们没有下一项了，那么就会引发 `StopIteration` 异常。
你可以将迭代器想象成 Pez 分配器（LCTT 译注：Pez 是一个结合玩具的独特复合式糖果），不能重新分配。你可以把 Pez 拿出去，但是一旦 Pez 被移走，它就不能被放回去，一旦分配器空了，它就没用了。
### 没有 for 的循环
既然我们已经了解了迭代器和 `iter` 以及 `next` 函数，我们将尝试在不使用 `for` 循环的情况下手动遍历迭代器。
我们将通过尝试将这个 `for` 循环变为 `while` 循环：
```
def funky_for_loop(iterable, action_to_do):
for item in iterable:
action_to_do(item)
```
为了做到这点，我们需要：
1. 从给定的可迭代对象中获得迭代器
2. 反复从迭代器中获得下一项
3. 如果我们成功获得下一项，就执行 `for` 循环的主体
4. 如果我们在获得下一项时得到了一个 `StopIteration` 异常，那么就停止循环
```
def funky_for_loop(iterable, action_to_do):
iterator = iter(iterable)
done_looping = False
while not done_looping:
try:
item = next(iterator)
except StopIteration:
done_looping = True
else:
action_to_do(item)
```
我们只是通过使用 `while` 循环和迭代器重新定义了 `for` 循环。
上面的代码基本上定义了 Python 在底层循环的工作方式。如果你理解内置的 `iter` 和 `next` 函数的遍历循环的工作方式，那么你就会理解 Python 的 `for` 循环是如何工作的。
事实上，你不仅仅会理解 `for` 循环在 Python 中是如何工作的，所有形式的遍历一个可迭代对象都是这样工作的。
<ruby> 迭代器协议 <rt> iterator protocol </rt></ruby> 是一种很好表示 “在 Python 中遍历迭代器是如何工作的”的方式。它本质上是对 `iter` 和 `next` 函数在 Python 中是如何工作的定义。Python 中所有形式的迭代都是由迭代器协议驱动的。
迭代器协议被 `for` 循环使用（正如我们已经看到的那样）：
```
for n in numbers:
print(n)
```
多重赋值也使用迭代器协议：
```
x, y, z = coordinates
```
星型表达式也是用迭代器协议：
```
a, b, *rest = numbers
print(*numbers)
```
许多内置函数依赖于迭代器协议：
```
unique_numbers = set(numbers)
```
在 Python 中任何与迭代器一起工作的东西都可能以某种方式使用迭代器协议。每当你在 Python 中遍历一个可迭代对象时，你将依赖于迭代器协议。
### 生成器是迭代器
所以你可能会想：迭代器看起来很酷，但它们看起来像一个实现细节，我们作为 Python 的使用者，可能不需要关心它们。
我有消息告诉你：在 Python 中直接使用迭代器是很常见的。
这里的 `squares` 对象是一个生成器：
```
>>> numbers = [1, 2, 3]
>>> squares = (n**2 for n in numbers)
```
生成器是迭代器，这意味着你可以在生成器上调用 `next` 来获得它的下一项：
```
>>> next(squares)
1
>>> next(squares)
4
```
但是如果你以前用过生成器，你可能也知道可以循环遍历生成器：
```
>>> squares = (n**2 for n in numbers)
>>> for n in squares:
... print(n)
...
1
4
9
```
如果你可以在 Python 中循环遍历某些东西，那么它就是**可迭代的**。
所以**生成器是迭代器**，但是生成器也是可迭代的，这又是怎么回事呢？
### 我欺骗了你
所以在我之前解释迭代器如何工作时，我跳过了它们的某些重要的细节。
#### 生成器是可迭代的
我再说一遍：Python 中的每一个迭代器都是可迭代的，意味着你可以循环遍历迭代器。
因为迭代器也是可迭代的，所以你可以使用内置 `next` 函数从可迭代对象中获得迭代器：
```
>>> numbers = [1, 2, 3]
>>> iterator1 = iter(numbers)
>>> iterator2 = iter(iterator1)
```
请记住，当我们在可迭代对象上调用 `iter` 时，它会给我们返回一个迭代器。
当我们在迭代器上调用 `iter` 时，它会给我们返回它自己：
```
>>> iterator1 is iterator2
True
```
迭代器是可迭代的，所有的迭代器都是它们自己的迭代器。
```
def is_iterator(iterable):
return iter(iterable) is iterable
```
迷惑了吗？
让我们回顾一些这些措辞。
* 一个**可迭代对象**是你可以迭代的东西
* 一个**迭代对象器**是一种实际上遍历可迭代对象的代理
此外，在 Python 中迭代器也是可迭代的，它们充当它们自己的迭代器。
所以迭代器是可迭代的，但是它们没有一些可迭代对象拥有的各种特性。
迭代器没有长度，它们不能被索引：
```
>>> numbers = [1, 2, 3, 5, 7]
>>> iterator = iter(numbers)
>>> len(iterator)
TypeError: object of type 'list_iterator' has no len()
>>> iterator[0]
TypeError: 'list_iterator' object is not subscriptable
```
从我们作为 Python 程序员的角度来看，你可以使用迭代器来做的唯一有用的事情是将其传递给内置的 `next` 函数，或者对其进行循环遍历：
```
>>> next(iterator)
1
>>> list(iterator)
[2, 3, 5, 7]
```
如果我们第二次循环遍历迭代器，我们将一无所获：
```
>>> list(iterator)
[]
```
你可以把迭代器看作是**惰性迭代器**，它们是**一次性使用**，这意味着它们只能循环遍历一次。
正如你在下面的真值表中所看到的，可迭代对象并不总是迭代器，但是迭代器总是可迭代的：
| 对象 | 可迭代？ | 迭代器？ |
| --- | --- | --- |
| 可迭代对象 | V | ? |
| 迭代器 | V | V |
| 生成器 | V | V |
| 列表 | V | X |
### 全部的迭代器协议
让我们从 Python 的角度来定义迭代器是如何工作的。
可迭代对象可以被传递给 `iter` 函数，以便为它们获得迭代器。
迭代器：
* 可以传递给 `next` 函数，它将给出下一项，如果没有下一项，那么它将会引发 `StopIteration` 异常
* 可以传递给 `iter` 函数，它会返回一个自身的迭代器
这些语句反过来也是正确的：
* 任何可以在不引发 `TypeError` 异常的情况下传递给 `iter` 的东西都是可迭代的
* 任何可以在不引发 `TypeError` 异常的情况下传递给 `next` 的东西都是一个迭代器
* 当传递给 `iter` 时，任何返回自身的东西都是一个迭代器
这就是 Python 中的迭代器协议。
#### 迭代器的惰性
迭代器允许我们一起工作，创建**惰性可迭代对象**，即在我们要求它们提供下一项之前，它们不做任何事情。因为可以创建惰性迭代器，所以我们可以创建无限长的迭代器。我们可以创建对系统资源比较保守的迭代器，可以节省我们的内存，节省 CPU 时间。
### 迭代器无处不在
你已经在 Python 中看到过许多迭代器，我也提到过生成器是迭代器。Python 的许多内置类型也是迭代器。例如，Python 的 `enumerate` 和 `reversed` 对象就是迭代器。
```
>>> letters = ['a', 'b', 'c']
>>> e = enumerate(letters)
>>> e
<enumerate object at 0x7f112b0e6510>
>>> next(e)
(0, 'a')
```
在 Python 3 中，`zip`, `map` 和 `filter` 也是迭代器。
```
>>> numbers = [1, 2, 3, 5, 7]
>>> letters = ['a', 'b', 'c']
>>> z = zip(numbers, letters)
>>> z
<zip object at 0x7f112cc6ce48>
>>> next(z)
(1, 'a')
```
Python 中的文件对象也是迭代器。
```
>>> next(open('hello.txt'))
'hello world\n'
```
在 Python 标准库和第三方库中内置了大量的迭代器。这些迭代器首先惰性迭代器一样，延迟工作直到你请求它们下一项。
### 创建你自己的迭代器
知道你已经在使用迭代器是很有用的，但是我希望你也知道，你可以创建自己的迭代器和你自己的惰性迭代器。
下面这个类构造了一个迭代器接受一个可迭代的数字，并在循环结束时提供每个数字的平方。
```
class square_all:
def __init__(self, numbers):
self.numbers = iter(numbers)
def __next__(self):
return next(self.numbers) * 2
def __iter__(self):
return self
```
但是在我们开始对该类的实例进行循环遍历之前，没有任何工作要做。
这里，我们有一个无限长的可迭代对象 `count`，你可以看到 `square_all` 接受 `count` 而不用完全循环遍历这个无限长的迭代：
```
>>> from itertools import count
>>> numbers = count(5)
>>> squares = square_all(numbers)
>>> next(squares)
25
>>> next(squares)
36
```
这个迭代器类是有效的，但我们通常不会这样做。通常，当我们想要做一个定制的迭代器时，我们会生成一个生成器函数：
```
def square_all(numbers):
for n in numbers:
yield n**2
```
这个生成器函数等价于我们上面所做的类，它的工作原理是一样的。
这种 `yield` 语句似乎很神奇，但它非常强大：`yield` 允许我们在调用 `next` 函数之间暂停生成器函数。`yield` 语句是将生成器函数与常规函数分离的东西。
另一种实现相同迭代器的方法是使用生成器表达式。
```
def square_all(numbers):
return (n**2 for n in numbers)
```
这和我们的生成器函数确实是一样的，但是它使用的语法看起来[像是一个列表推导一样](http://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/)。如果你需要在代码中使用惰性迭代，请考虑迭代器，并考虑使用生成器函数或生成器表达式。
### 迭代器如何改进你的代码
一旦你已经接受了在代码中使用惰性迭代器的想法，你就会发现有很多可能来发现或创建辅助函数，以此来帮助你循环遍历和处理数据。
#### 惰性求和
这是一个 `for` 循环，它对 Django queryset 中的所有工作时间求和：
```
hours_worked = 0
for event in events:
if event.is_billable():
hours_worked += event.duration
```
下面是使用生成器表达式进行惰性评估的代码：
```
billable_times = (
event.duration
for event in events
if event.is_billable()
)
hours_worked = sum(billable_times)
```
请注意，我们代码的形状发生了巨大变化。
将我们的计算工作时间变成一个惰性迭代器允许我们能够命名以前未命名（`billable_times`）的东西。这也允许我们使用 `sum` 函数，我们以前不能使用 `sum` 函数是因为我们甚至没有一个可迭代对象传递给它。迭代器允许你从根本上改变你组织代码的方式。
#### 惰性和打破循环
这段代码打印出日志文件的前 10 行：
```
for i, line in enumerate(log_file):
if i >= 10:
break
print(line)
```
这段代码做了同样的事情，但是我们使用的是 `itertools.islice` 函数来惰性地抓取文件中的前 10 行：
```
from itertools import islice
first_ten_lines = islice(log_file, 10)
for line in first_ten_lines:
print(line)
```
我们定义的 `first_ten_lines` 变量是迭代器，同样，使用迭代器允许我们给以前未命名的东西命名(`first_ten_lines`)。命名事物可以使我们的代码更具描述性，更具可读性。
作为奖励，我们还消除了在循环中使用 `break` 语句的需要，因为 `islice` 实用函数为我们处理了中断。
你可以在标准库中的 [itertools](https://docs.python.org/3/library/itertools.html) 中找到更多的迭代辅助函数，以及诸如 [boltons](https://boltons.readthedocs.io) 和 [more-itertools](https://more-itertools.readthedocs.io) 之类的第三方库。
#### 创建自己的迭代辅助函数
你可以在标准库和第三方库中找到用于循环的辅助函数，但你也可以自己创建！
这段代码列出了序列中连续值之间的差值列表。
```
current = readings[0]
for next_item in readings[1:]:
differences.append(next_item - current)
current = next_item
```
请注意，这段代码中有一个额外的变量，我们每次循环时都要指定它。还要注意，这段代码只适用于我们可以切片的东西，比如序列。如果 `readings` 是一个生成器，一个 zip 对象或其他任何类型的迭代器，那么这段代码就会失败。
让我们编写一个辅助函数来修复代码。
这是一个生成器函数，它为给定的迭代中的每个项目提供了当前项和下一项：
```
def with_next(iterable):
"""Yield (current, next_item) tuples for each item in iterable."""
iterator = iter(iterable)
current = next(iterator)
for next_item in iterator:
yield current, next_item
current = next_item
```
我们从可迭代对象中手动获取一个迭代器，在它上面调用 `next` 来获取第一项，然后循环遍历迭代器获取后续所有的项目，跟踪后一个项目。这个函数不仅适用于序列，而且适用于任何类型迭代。
这段代码和以前代码是一样的，但是我们使用的是辅助函数而不是手动跟踪 `next_item`：
```
differences = []
for current, next_item in with_next(readings):
differences.append(next_item - current)
```
请注意，这段代码不会挂在我们循环周围的 `next_item` 上，`with_next` 生成器函数处理跟踪 `next_item` 的工作。
还要注意，这段代码已足够紧凑，如果我们愿意，我们甚至可以[将方法复制到列表推导中来](http://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/)。
```
differences = [
(next_item - current)
for current, next_item in with_next(readings)
]
```
### 再次回顾循环问题
现在我们准备回到之前看到的那些奇怪的例子并试着找出到底发生了什么。
#### 问题 1：耗尽的迭代器
这里我们有一个生成器对象 `squares`：
```
>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)
```
如果我们把这个生成器传递给 `tuple` 构造函数，我们将会得到它的一个元组：
```
>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)
>>> tuple(squares)
(1, 4, 9, 25, 49)
```
如果我们试着计算这个生成器中数字的和，使用 `sum`,我们就会得到 `0`：
```
>>> sum(squares)
0
```
这个生成器现在是空的：我们已经把它耗尽了。如果我们试着再次创建一个元组，我们会得到一个空元组：
```
>>> tuple(squares)
()
```
生成器是迭代器，迭代器是一次性的。它们就像 Hello Kitty Pez 分配器那样不能重新加载。
#### 问题 2：部分消耗一个迭代器
再次使用那个生成器对象 `squares`：
```
>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)
```
如果我们询问 `9` 是否在 `squares` 生成器中，我们会得到 `True`：
```
>>> 9 in squares
True
```
但是我们再次询问相同的问题，我们会得到 `False`：
```
>>> 9 in squares
False
```
当我们询问 `9` 是否在迭代器中时，Python 必须对这个生成器进行循环遍历来找到 `9`。如果我们在检查了 `9` 之后继续循环遍历，我们只会得到最后两个数字，因为我们已经在找到 9 之前消耗了这些数字：
```
>>> numbers = [1, 2, 3, 5, 7]
>>> squares = (n**2 for n in numbers)
>>> 9 in squares
True
>>> list(squares)
[25, 49]
```
询问迭代器中是否包含某些东西将会部分地消耗迭代器。如果没有循环遍历迭代器，那么是没有办法知道某个东西是否在迭代器中。
#### 问题 3：拆包是迭代
当你在字典上循环时，你会得到键：
```
>>> counts = {'apples': 2, 'oranges': 1}
>>> for key in counts:
... print(key)
...
apples
oranges
```
当你对一个字典进行拆包时，你也会得到键：
```
>>> x, y = counts
>>> x, y
('apples', 'oranges')
```
循环依赖于迭代器协议，可迭代对象拆包也依赖于有迭代器协议。拆包一个字典与在字典上循环遍历是一样的，两者都使用迭代器协议，所以在这两种情况下都得到相同的结果。
### 回顾
序列是迭代器，但是不是所有的迭代器都是序列。当有人说“迭代器”这个词时，你只能假设他们的意思是“你可以迭代的东西”。不要假设迭代器可以被循环遍历两次、询问它们的长度或者索引。
迭代器是 Python 中最基本的可迭代形式。如果你想在代码中做一个惰性迭代，请考虑迭代器，并考虑使用生成器函数或生成器表达式。
最后，请记住，Python 中的每一种迭代都依赖于迭代器协议，因此理解迭代器协议是理解 Python 中的循环的关键。
这里有一些我推荐的相关文章和视频：
* [Loop Like a Native](https://nedbatchelder.com/text/iter.html)， Ned Batchelder 在 PyCon 2013 的讲演
* [Loop Better](https://www.youtube.com/watch?v=V2PkkMS2Ack) ，这篇文章是基于这个讲演的
* [The Iterator Protocol: How For Loops Work](http://treyhunner.com/2016/12/python-iterator-protocol-how-for-loops-work/)，我写的关于迭代器协议的短文
* [Comprehensible Comprehensions](https://www.youtube.com/watch?v=5_cJIcgM7rw)，关于推导和迭代器表达器的讲演
* [Python: Range is Not an Iterator](http://treyhunner.com/2018/02/python-range-is-not-an-iterator/)，我关于范围和迭代器的文章
* [Looping Like a Pro in Python](https://www.youtube.com/watch?v=u8g9scXeAcI)，DB 的 PyCon 2017 讲演
本文是基于作者去年在 [DjangoCon AU](https://www.youtube.com/watch?v=JYuE8ZiDPl4)、 [PyGotham](https://www.youtube.com/watch?v=Wd7vcuiMhxU) 和 [North Bay Python](https://www.youtube.com/watch?v=V2PkkMS2Ack) 中发表的 Loop Better 演讲。有关更多内容，请参加将于 2018 年 5 月 9 日至 17 日在 Columbus， Ohio 举办的 [PYCON](https://us.pycon.org/2018/)。
---
via: <https://opensource.com/article/18/3/loop-better-deeper-look-iteration-python>
作者：[Trey Hunner](https://opensource.com/users/treyhunner) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
DevOps 如何消除了 Ranger 社区的瓶颈
|
Willy Schaub
|
https://opensource.com/article/17/11/devops-rangers-transformation
|
拥抱 DevOps 让 Ranger 成员们变得更灵活、快捷和成为开发者社区更有价值的成员。
|
/data/attachment/album/201805/26/234527kiri747ofifrv6r3.png.thumb.jpg
|
/data/attachment/album/201805/26/234527kiri747ofifrv6r3.png
| true | false | true |
qhwdw
| false |
[
"DevOps"
] |
观点
|
{
"viewnum": 2817,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
拥抱 DevOps 让 Ranger 成员们变得更灵活、快捷和成为开发者社区更有价值的成员。
| 2018-05-26T23:45:00 | 2018-05-26T23:45:00 | 9,682 |
/article-9682-1.html
|
>
> 拥抱 DevOps 让 Ranger 成员们变得更灵活、快捷和成为开发者社区更有价值的成员。
>
>
>
Visual Studio 的<ruby> 应用周期管理 <rt> Application Lifecycle Management </rt></ruby>（ALM）项目 —— [Ranger](https://aka.ms/vsaraboutus) 是一个志愿者社区，它提供专业的指导、实践经验、以及开发者社区的漏洞修补解决方案。它创建于 2006 年，作为微软内部社区去 “将产品组与大家相连接，并去除推广阻力”。 在 2009 时，社区已经有超过 200 位成员，这导致了协作和计划面临很大的挑战，在依赖和手工流程上产生了瓶颈，并导致了开发者社区不断增加的延迟和各种报怨。在 2010 时，计划进一步去扩充包括微软最有价值专家（MVP）在内的分布在全球的社区。
这个社区被分割成十几个活跃的团队。每个团队都致力于通过它的生命周期去设计、构建和支持一个指导或处理项目。在以前，团队的瓶颈在团队管理级别上，原因是严格的、瀑布式的流程和高度依赖一个或多个项目经理。在制作、发布和“为什么、做什么、和怎么做”驱动的决定上，项目经理都要介入其中。另外，缺乏一个实时的指标阻止了团队对他们的解决方案效率的监控，以及对来自社区的关于 bug 和常见问题的关注。
是时候去寻找一些做好这些事情的方法了，更好地实现开发者社区的价值。
### DevOps 去“灭火”
>
> “DevOps 是人员、流程和产品的结合，使我们的最终用户能够持续传递价值。” --[Donovan Brown](http://donovanbrown.com/post/what-is-devops)
>
>
>
为解决这些挑战，社区停止了所有对新项目的冲刺，去探索敏捷实践和新产品。致力于使社区重新活跃起来，为找到促进自治、掌控、和目标的方法，正如在 Daniel H. Pink 的书《[Drive](http://www.danpink.com/books/drive/)》中所说的那样，对僵化的流程和产品进行彻底的改革。
>
> “成熟的自组织、自管理和跨职能团队，在自治、掌控和目标上茁壮成长。" --Drive, Daniel H. Pink.
>
>
>
从文化开始 —— 人 —— 第一步是去拥抱 DevOps。社区实现了 [Scrum](http://www.scrumguides.org/scrum-guide.html) 框架，使用 [kanban](https://leankit.com/learn/kanban/what-is-kanban/) 去提升工程化流程，并且通过可视化去提升透明度、意识和最重要的东西 —— 信任。使用自组织团队后，传统的等级制度和指挥系统消失了。自管理促使团队去积极监视和设计它们自己的流程。
在 2010 年 4 月份，社区再次实施了另外的关键一步，切换并提交它们的文化、流程、以及产品到云上。虽然开放的“为社区而社区”的核心 [解决方案](https://aka.ms/vsarsolutions) 仍然是指导和补充，但是在开源解决方案（OSS）上大量增加投资去研究和共享 DevOps 转换的成就。
持续集成（CI）和持续交付（CD）使用自动化流水线代替了死板的人工流程。这使得团队在不受来自项目经理的干预的情况下为早期问题和早期应用者部署解决方案。增加遥测技术可以使团队关注他们的解决方案，以及在用户注意到它们之前，检测和处理未知的问题。
DevOps 转变是一个持续进化的过程，通过实验去探索和验证人、流程和产品的改革。最新的试验引入了流水线革新，它可以持续提升价值流。自动扫描组件、持续地以及静默地检查安全、协议和开源组件的品质。部署环和特性标志允许团队对所有或者特定用户进行更细粒度的控制。
在 2017 年 10 月，社区将大部分的私有版本控制仓库转移到 [GitHub](https://github.com/ALM-Rangers) 上。将所有仓库转移所有者和管理职责到 ALM DevOps Rangers 社区，给团队提供自治和机会，去激励更多的社区对开源解决方案作贡献。团队被授权向他们的最终用户交付质量和价值。
### 好处和成就
拥抱 DevOps 使 Ranger 社区变得更加敏捷，实现了对市场的快速反应和快速学习和反应的流程，减少了宝贵的时间投入，并宣布自治。
下面是从这个转变中观察到的一个列表，排列没有特定的顺序：
* 自治、掌控和目标是核心。
* 从可触摸的和可迭代的东西开始 —— 避免摊子铺的过大。
* 可触摸的和可操作的指标很重要 —— 确保不要掺杂其它东西。
* 人（文化）的转变是最具挑战的部分。
* 没有蓝图；任何一个组织和任何一个团队都是独一无二的。
* 转变是一个持续的过程。
* 透明和可视非常关键。
* 使用工程化流程去强化预期行为。
转换变化表：
| | 过去 | 当前 | 想象 |
| --- | --- | --- | --- |
| 分支 | 服务于发布隔离 | 特性 | 主分支 |
| 构建 | 手动且易错 | 自动而一致 | |
| 问题检测 | 来自用户 | 主动感知 | |
| 问题解决 | 几天到几周 | 几分钟到几天 | 几分钟 |
| 计划 | 详细的设计 | 原型与故事板 | |
| 流程管理 | 2 个流程经理（PM） | 0.25 个 PM | 0.125 个 PM |
| 发布终止 | 6 到 12 个月 | 3 到 5 周期 | 每个周期 |
| 发布 | 手动且易错 | 自动而一致 | |
| 周期 | 1 个月 | 3 周 | |
| 团队规模 | 10 到 15 | 2 到 5 | |
| 构建时间 | 几小时 | 几秒钟 | |
| 发布时间 | 几天 | 几分钟 | |
但是，我们还没有做完，相反，我们就是一个令人兴奋的、持续不断的、几乎从不结束的转变的一部分。
如果你想去学习更多的关于我们的转变、有益的经验、以及想知道我们所经历的挑战，请查看 [转变到 DevOps 文化的记录](https://github.com/ALM-Rangers/Guidance/blob/master/src/Stories/our-journey-of-transforming-to-a-devops-culture.md)。"
---
via: <https://opensource.com/article/17/11/devops-rangers-transformation>
作者：[Willy Schaub](https://opensource.com/users/wpschaub) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中找到你的 IP 地址
|
Archit Modi
|
https://opensource.com/article/18/5/how-find-ip-address-linux
|
每个网站都有一个独有的公开 IP 地址，可供任何人从任何地方访问。
|
/data/attachment/album/201805/27/071823dewmmmiw8dwmapwp.jpg.thumb.jpg
|
/data/attachment/album/201805/27/071823dewmmmiw8dwmapwp.jpg
| true | false | true |
geekpi
| false |
[
"IP"
] |
技术
|
{
"viewnum": 9115,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
每个网站都有一个独有的公开 IP 地址，可供任何人从任何地方访问。
| 2018-05-27T07:02:00 | 2018-05-27T07:02:00 | 9,683 |
/article-9683-1.html
|
>
> 每个网站都有一个独有的公开 IP 地址，可供任何人从任何地方访问。
>
>
>
<ruby> 互联网协议 <rt> Internet Protocol </rt></ruby>（IP）不需要介绍 —— 我们每天都在使用它。即使你不直接使用它，当你在浏览器上输入 website-name.com 时，它会查找该 URL 的 IP 地址，然后加载该网站。
我们将 IP 地址分为两类：私有和公共。私有 IP 地址是你的无线路由（和公司内网）提供的私有 IP 地址。它们的范围是 10.xxx、172.16.xx-172.31.xx 和 192.168.xx，其中 x=0 到 255。公有 IP 地址，顾名思义，是“公共”的，你可以在世界上任何地方访问它。每个网站都有一个唯一的 IP 地址，任何人可在任何地点访问，这可被视为公共 IP 地址。
此外，还有两种类型的 IP 地址：IPv4 和 IPv6。
IPv4 地址格式为 x.x.x.x，其中 x=0 到 255。有 2<sup> 32（大约</sup> 40 亿个）可能的 IPv4 地址。
IPv6 地址使用更复杂的十六进制。总的比特数是 128，这意味着有 2<sup> 128</sup> （340 后面有 36 个零！）个可能的 IPv6 地址。IPv6 已经被引入解决了可预见的 IPv4 地址耗尽问题。
作为网络工程师，我建议不要与任何人共享你机器的公有 IP 地址。你的 WiFi 路由器有公共 IP，即 WAN（广域网）IP 地址，并且连接到该 WiFi 的任何设备都是相同的。连接到相同 WiFi 的所有设备都有上面所说的私有 IP 地址。例如，我的笔记本电脑的 IP 地址 192.168.0.5，而我的电话是 192.168.0.8。这些是私有 IP 地址，但两者都有相同的公有 IP 地址。
以下命令将列出IP地址列表，以查找你计算机的公有 IP 地址：
1. `ifconfig.me`
2. `curl -4/-6 icanhazip.com`
3. `curl ipinfo.io/ip`
4. `curl api.ipify.org`
5. `curl checkip.dyndns.org`
6. `dig +short myip.opendns.com @resolver1.opendns.com`
7. `host myip.opendns.com resolver1.opendns.com`
8. `curl ident.me`
9. `curl bot.whatismyipaddress.com`
10. `curl ipecho.net/plain`
以下命令将为你提供接口的私有 IP 地址：
1. `ifconfig -a`
2. `ip addr (ip a)`
3. `hostname -I | awk ‘{print $1}’`
4. `ip route get 1.2.3.4 | awk '{print $7}'`
5. `(Fedora) Wifi-Settings→ click the setting icon next to the Wifi name that you are connected to → Ipv4 and Ipv6 both can be seen`
6. `nmcli -p device show`
*注意：一些工具需要根据你正在使用的 Linux 发行版安装在你的系统上。另外，一些提到的命令使用第三方网站来获取 IP*
---
via: <https://opensource.com/article/18/5/how-find-ip-address-linux>
作者：[Archit Modi](https://opensource.com/users/architmodi) 选题：[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/) 荣誉推出
|
||
zzupdate：单条命令升级 Ubuntu 18.04 LTS
|
Prakash Subramanian
|
https://www.2daygeek.com/zzupdate-single-command-to-upgrade-ubuntu-18-04/
|
我们可以只通过一条命令使用 zzupdate 工具中将 Ubuntu PC/Server 从一个版本升级到另一个版本。
|
/data/attachment/album/201805/27/071719gd2db2ddoddd2d2o.jpg.thumb.jpg
|
/data/attachment/album/201805/27/071719gd2db2ddoddd2d2o.jpg
| true | false | true |
XiatianSummer
| false |
[
"zzupdate"
] |
技术
|
{
"viewnum": 7809,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们可以只通过一条命令使用 zzupdate 工具中将 Ubuntu PC/Server 从一个版本升级到另一个版本。
| 2018-05-27T07:18:06 | 2018-05-27T07:18:06 | 9,684 |
/article-9684-1.html
|
Ubuntu 18.04 版本已经发布，并得到各个社区的一致好评，因为 Ubuntu 18.04 可能是 Ubuntu 多年来最令人兴奋的版本。
通常情况下，Ubuntu 及其衍生版可以使用命令从一个版本升级到最新版本或者其它版本，这也是官方推荐的升级方式。
### Ubuntu 18.04 特性/亮点
这次更新包含大量改进和新功能，这里只列举的几个主要的。如果您想要更详细的更新信息，请访问 [Ubuntu 18.04 官方](https://wiki.ubuntu.com/BionicBeaver/ReleaseNotes) 页面。
* 使用 Linux 4.15 内核，提供了从上游继承的新功能
* 它具有最新版本的 GNOME 3.28
* 它提供了与 RHEL 相似的最简安装选项，该选项可安装只包含一个 web 浏览器和核心系统程序的基本桌面环境
* 对于新安装，交换文件将取代默认的交换分区
* 您可以启用 Livepatch 安装内核更新而无需重新启动
* 笔记本电脑在使用电池供电时会在无操作 20 分钟后自动待机
* 不再提供 32 位的 Ubuntu 桌面安装程序映像
注意：
1. 不要忘记备份重要数据。如果升级出现问题，我们将重新安装并恢复数据。
2. 安装所需时间取决于您的网络状况和安装的程序。
### zzupdate 是什么？
我们可以只通过一条命令使用 [zzupdate](https://github.com/TurboLabIt/zzupdate) 工具中将 Ubuntu PC/Server 从一个版本升级到另一个版本。它是一个自由开源工具，使用它不需要任何脚本知识，因为它只需要配置文件即可运行。
工具中提供两个默认 shell 文件。`setup.sh` 自动安装、更新代码，将脚本转换为一个简单的 zzupdate shell 命令。`zzupdate.sh` 将执行版本间的升级。
### 如何安装 zzupdate？
要安装 `zzupdate`，只需执行以下命令：
```
$ curl -s https://raw.githubusercontent.com/TurboLabIt/zzupdate/master/setup.sh | sudo sh
.
.
Installing...
-------------
Cloning into 'zzupdate'...
remote: Counting objects: 57, done.
remote: Total 57 (delta 0), reused 0 (delta 0), pack-reused 57
Unpacking objects: 100% (57/57), done.
Checking connectivity... done.
Already up-to-date.
Setup completed!
----------------
See https://github.com/TurboLabIt/zzupdate for the quickstart guide.
```
将 Ubuntu 系统从一个版本升级到另一个版本，您不需要输入很多命令，也不需要重新启动，只需要运行下面的 `zzupdate` 命令并坐下喝杯咖啡就可以了。
请注意，当您远程升级系统时，建议您使用以下的工具来帮助您在任何断开连接时重新连接会话。
建议阅读： [如何让一个进程/命令在 SSH 连接断开后继续运行](https://www.2daygeek.com/how-to-keep-a-process-command-running-after-disconnecting-ssh-session/)
### 如何配置 zzupdate（可选）
默认情况下，`zzupdate` 可以开箱即用，不需要配置任何东西。当然，如果您想要自己配置一些内容也是可以的。复制提供的示例配置文件 `zzupdate.default.conf` 到 `zzupdate.conf`，并在 `zzupdate.conf` 中配置您的首选项。
```
$ sudo cp /usr/local/turbolab.it/zzupdate/zzupdate.default.conf /etc/turbolab.it/zzupdate.conf
```
打开文件，默认配置如下。
```
$ sudo nano /etc/turbolab.it/zzupdate.conf
REBOOT=1
REBOOT_TIMEOUT=15
VERSION_UPGRADE=1
VERSION_UPGRADE_SILENT=0
COMPOSER_UPGRADE=1
SWITCH_PROMPT_TO_NORMAL=0
```
* `REBOOT=1`：系统在更新完成后自动重启
* `REBOOT_TIMEOUT=15`：重启的默认超时值
* `VERSION_UPGRADE=1`：执行从一个版本到另一个版本的版本升级
* `VERSION_UPGRADE_SILENT=0`：禁用自动升级
* `COMPOSER_UPGRADE=1`：自动升级
* `SWITCH_PROMPT_TO_NORMAL=0`：如果值为 `0`，将寻找相同种类的版本升级。例如您正在运行 LTS 的版本，那么将寻找 LTS 的版本升级，而不是用于正常版本升级。如果值为 `1`，那么无论您是运行 LTS 还是正常版本，都会查找最新版本
我现在正在使用 Ubuntu 17.10 ，查看一下详细信息。
```
$ cat /etc/*-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=17.10
DISTRIB_CODENAME=artful
DISTRIB_DESCRIPTION="Ubuntu 17.10"
NAME="Ubuntu"
VERSION="17.10 (Artful Aardvark)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 17.10"
VERSION_ID="17.10"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=artful
UBUNTU_CODENAME=artful
```
要升级 Ubuntu 到最新版本，只需要执行以下命令：
```
$ sudo zzupdate
O===========================================================O
zzupdate - Wed May 2 17:31:16 IST 2018
O===========================================================O
Self-update and update of other zzScript
----------------------------------------
.
.
0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.
Updating...
----------
Already up-to-date.
Setup completed!
----------------
See https://github.com/TurboLabIt/zzupdate for the quickstart guide.
Channel switching is disabled: using pre-existing setting
---------------------------------------------------------
Cleanup local cache
-------------------
Update available packages informations
--------------------------------------
Hit:1 https://download.docker.com/linux/ubuntu artful InRelease
Ign:2 http://dl.google.com/linux/chrome/deb stable InRelease
Hit:3 http://security.ubuntu.com/ubuntu artful-security InRelease
Hit:4 http://in.archive.ubuntu.com/ubuntu artful InRelease
Hit:5 http://dl.google.com/linux/chrome/deb stable Release
Hit:6 http://in.archive.ubuntu.com/ubuntu artful-updates InRelease
Hit:7 http://in.archive.ubuntu.com/ubuntu artful-backports InRelease
Hit:9 http://ppa.launchpad.net/notepadqq-team/notepadqq/ubuntu artful InRelease
Hit:10 http://ppa.launchpad.net/papirus/papirus/ubuntu artful InRelease
Hit:11 http://ppa.launchpad.net/twodopeshaggy/jarun/ubuntu artful InRelease
.
.
UPGRADE PACKAGES
----------------
Reading package lists...
Building dependency tree...
Reading state information...
Calculating upgrade...
The following packages were automatically installed and are no longer required:
.
.
Interactively upgrade to a new release, if any
----------------------------------------------
Reading cache
Checking package manager
Reading package lists... Done
Building dependency tree
Reading state information... Done
Ign http://dl.google.com/linux/chrome/deb stable InRelease
Hit https://download.docker.com/linux/ubuntu artful InRelease
Hit http://security.ubuntu.com/ubuntu artful-security InRelease
Hit http://dl.google.com/linux/chrome/deb stable Release
Hit http://in.archive.ubuntu.com/ubuntu artful InRelease
Hit http://in.archive.ubuntu.com/ubuntu artful-updates InRelease
Hit http://in.archive.ubuntu.com/ubuntu artful-backports InRelease
Hit http://ppa.launchpad.net/notepadqq-team/notepadqq/ubuntu artful InRelease
Hit http://ppa.launchpad.net/papirus/papirus/ubuntu artful InRelease
Hit http://ppa.launchpad.net/twodopeshaggy/jarun/ubuntu artful InRelease
Fetched 0 B in 6s (0 B/s)
Reading package lists... Done
Building dependency tree
Reading state information... Done
```
我们需要按下回车键禁用第三方仓库以继续升级。
```
Updating repository information
Third party sources disabled
Some third party entries in your sources.list were disabled. You can
re-enable them after the upgrade with the 'software-properties' tool
or your package manager.
To continue please press [ENTER]
.
.
Get:35 http://in.archive.ubuntu.com/ubuntu bionic-updates/universe i386 Packages [2,180 B]
Get:36 http://in.archive.ubuntu.com/ubuntu bionic-updates/universe Translation-en [1,644 B]
Fetched 38.2 MB in 6s (1,276 kB/s)
Checking package manager
Reading package lists... Done
Building dependency tree
Reading state information... Done
Calculating the changes
Calculating the changes
```
开始下载 `Ubuntu 18.04 LTS` 软件包，所需时间取决于您的网络状况，一般情况下这将需要几分钟。
```
Do you want to start the upgrade?
63 installed packages are no longer supported by Canonical. You can
still get support from the community.
4 packages are going to be removed. 175 new packages are going to be
installed. 1307 packages are going to be upgraded.
You have to download a total of 999 M. This download will take about
12 minutes with your connection.
Installing the upgrade can take several hours. Once the download has
finished, the process cannot be canceled.
Continue [yN] Details [d]y
Fetching
Get:1 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 base-files amd64 10.1ubuntu2 [58.2 kB]
Get:2 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 debianutils amd64 4.8.4 [85.7 kB]
Get:3 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 bash amd64 4.4.18-2ubuntu1 [614 kB]
Get:4 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 locales all 2.27-3ubuntu1 [3,612 kB]
.
.
Get:1477 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 liblouisutdml-bin amd64 2.7.0-1 [9,588 B]
Get:1478 http://in.archive.ubuntu.com/ubuntu bionic/universe amd64 libtbb2 amd64 2017~U7-8 [110 kB]
Get:1479 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 libyajl2 amd64 2.1.0-2build1 [20.0 kB]
Get:1480 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 usb-modeswitch amd64 2.5.2+repack0-2ubuntu1 [53.6 kB]
Get:1481 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 usb-modeswitch-data all 20170806-2 [30.7 kB]
Get:1482 http://in.archive.ubuntu.com/ubuntu bionic/main amd64 xbrlapi amd64 5.5-4ubuntu2 [61.8 kB]
Fetched 999 MB in 6s (721 kB/s)
```
安装新软件包时，很少有服务需要重新启动。 点击 `Yes` 按钮，它会自动重启所需的服务。
```
Upgrading
Inhibiting until Ctrl+C is pressed...
Preconfiguring packages ...
Preconfiguring packages ...
Preconfiguring packages ...
Preconfiguring packages ...
(Reading database ... 441375 files and directories currently installed.)
Preparing to unpack .../base-files_10.1ubuntu2_amd64.deb ...
Warning: Stopping motd-news.service, but it can still be activated by:
motd-news.timer
Unpacking base-files (10.1ubuntu2) over (9.6ubuntu102) ...
Setting up base-files (10.1ubuntu2) ...
Installing new version of config file /etc/debian_version ...
Installing new version of config file /etc/issue ...
Installing new version of config file /etc/issue.net ...
Installing new version of config file /etc/lsb-release ...
motd-news.service is a disabled or a static unit, not starting it.
(Reading database ... 441376 files and directories currently installed.)
.
.
Progress: [ 80%]
Progress: [ 85%]
Progress: [ 90%]
Progress: [ 95%]
```
现在删除旧版的、系统不再需要的包。点击 `y` 以删除。
```
Searching for obsolete software
ing package lists... 97%
ding package lists... 98%
Reading package lists... Done
Building dependency tree
Reading state information... Done
Reading state information... 23%
Reading state information... 47%
Reading state information... 71%
Reading state information... 94%
Reading state information... Done
Remove obsolete packages?
88 packages are going to be removed.
Continue [yN] Details [d]y
.
.
.
done
Removing perlmagick (8:6.9.7.4+dfsg-16ubuntu6) ...
Removing snapd-login-service (1.23-0ubuntu1) ...
Processing triggers for libc-bin (2.27-3ubuntu1) ...
Processing triggers for man-db (2.8.3-2) ...
Processing triggers for dbus (1.12.2-1ubuntu1) ...
Fetched 0 B in 0s (0 B/s)
```
升级成功，需要重启系统。点击 `y` 以重启系统。
```
System upgrade is complete.
Restart required
To finish the upgrade, a restart is required.
If you select 'y' the system will be restarted.
Continue [yN]y
```
注意： 少数情况下，会要求您确认配置文件替换以继续安装。
查看升级后的系统详情：
```
$ cat /etc/*-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=18.04
DISTRIB_CODENAME=bionic
DISTRIB_DESCRIPTION="Ubuntu 18.04 LTS"
NAME="Ubuntu"
VERSION="18.04 LTS (Bionic Beaver)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 18.04 LTS"
VERSION_ID="18.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=bionic
UBUNTU_CODENAME=bionic
```
---
via: <https://www.2daygeek.com/zzupdate-single-command-to-upgrade-ubuntu-18-04/>
作者：[PRAKASH SUBRAMANIAN](https://www.2daygeek.com/author/prakash/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[XiatianSummer](https://github.com/XiatianSummer) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么 Oil States 案对于开源界是个好消息
|
Matt J. Krupnick
|
https://opensource.com/article/18/4/why-oil-states-good-open-source
|
对于面临滥用专利制度的实体发起诉讼威胁的技术公司和创新者来说，此案是一个重大胜利。
|
/data/attachment/album/201805/27/162348bnjodo79vdjdj14o.jpg.thumb.jpg
|
/data/attachment/album/201805/27/162348bnjodo79vdjdj14o.jpg
| true | false | true |
薛亮
| false |
[
"专利"
] |
开源智慧
|
{
"viewnum": 7211,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
对于面临滥用专利制度的实体发起诉讼威胁的技术公司和创新者来说，此案是一个重大胜利。
| 2018-05-27T16:23:00 | 2018-05-27T16:23:00 | 9,685 |
/article-9685-1.html
|
>
> 提要：对于面临滥用专利制度的实体发起诉讼威胁的技术公司和创新者来说，此案是一个重大胜利。
>
>
>
对于面临滥用专利制度的实体发起诉讼威胁的技术公司和创新者来说，日前美国最高法院对 [Oil States 诉 Greene’s Energy 案](https://www.supremecourt.gov/opinions/17pdf/16-712_87ad.pdf)做出的[裁决是一个重大胜利](http://www.scotusblog.com/wp-content/uploads/2017/11/16-712-bsac-Dell.pdf)。此类滥用专利制度的实体试图从创新者和创造就业机会的企业身上攫取价值。
在 Oil States 案中，美国最高法院对美国专利商标局（USPTO）一项旨在质疑此前授权但存在问题的专利是否有效的行政程序是否违宪做出了裁决。<ruby> 专利流氓 <rp> （ </rp> <rt> patent trolls </rt> <rp> ） </rp></ruby>最喜欢利用此类专利发起诉讼。这一称为<ruby> “双方复审” <rp> （ </rp> <rt> inter partes review </rt> <rp> ） </rp></ruby>的程序已经成为一种应对基于可能无效专利而轻率发起的侵权主张的重要工具，其成本远低于在联邦法院检验此类专利有效性的成本。
美国国会根据<ruby> 《2011年美国发明法案》 <rp> （ </rp> <rt> America Invents Act of 2011 </rt> <rp> ） </rp></ruby>创建了这种双方复审程序，以清理美国国会所认为的大量被不当授权的专利。此类专利被专利流氓用于向创新者谋取费用。自 2012 年实施该程序以来，已经有 7000 多份申请被提交，主要是为了审查计算机和高科技领域的可疑专利，并且有超过 1300 项权利主张被裁定无效。
在 7 比 2 的多数意见中，托马斯法官表示：“授予专利的决定是涉及公共权利的事项。双方复审只是对该授权过程的再审，美国国会已经授权美国专利商标局实施此种再审。”法官认为双方复审程序并没有侵犯专利权人所拥有的案件需由联邦法院裁决（在联邦法院无效专利的成本更高，诉讼费用明显更为昂贵）的宪法权利。
与开发、销售或实施复杂技术的任何实体一样，开发或实施开源软件的成功企业是专利流氓诉讼威胁的颇有吸引力的目标。因此，确认双方复审程序的合宪性不仅提高了专利系统的质量，而且也保留了一种工具来保护开源技术免受那些滥用专利系统的实体的攻击。
美国专利商标局打算评估双方复审程序的实施情况，这可能会影响其作为防御工具的有效性。但科技行业人士应继续让政策制定者保留《2011 年美国发明法案》所带来的有益变革，以保护创新并阻止滥用专利的行为。
---
作者简介：Matt Krupnick 是<ruby> 红帽公司 <rp> （ </rp> <rt> Red Hat </rt> <rp> ） </rp></ruby>公共政策总监，于 2017 年加入红帽公司，负责政策制定以及为一系列对红帽公司及开源技术有潜在影响的各种政策问题提供建议。
译者简介：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
在 Ubuntu Snap 应用商店上发现的加密货币 ‘恶意软件’ 是怎么回事？
|
John Paul
|
https://itsfoss.com/snapstore-cryptocurrency-saga/
|
最近，有发现称一些 Ubuntu Snap 应用商店上的应用包含加密货币挖矿程序。Canonical 公司迅速下架了这些违规的应用，但是留下了几个有待回答的问题。
|
/data/attachment/album/201805/27/172420wm01d161f17s3q7v.jpg.thumb.jpg
|
/data/attachment/album/201805/27/172420wm01d161f17s3q7v.jpg
| true | false | true |
paperzhang
| false |
[
"Snap",
"挖矿"
] |
观点
|
{
"viewnum": 4531,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
最近，有发现称一些 Ubuntu Snap 应用商店上的应用包含加密货币挖矿程序。Canonical 公司迅速下架了这些违规的应用，但是留下了几个有待回答的问题。
| 2018-05-27T17:24:16 | 2018-05-27T17:24:16 | 9,686 |
/article-9686-1.html
|
最近，有发现称一些 Ubuntu Snap 应用商店上的应用包含加密货币挖矿程序。Canonical 公司迅速下架了这些违规的应用，但是留下了几个有待回答的问题。
### 在 Snap 应用商店上发现了加密矿工
5 月 11 号，一位名叫 [tarwirdur](https://github.com/tarwirdur) 的用户在 [snapcraft.io repository](https://github.com/canonical-websites/snapcraft.io/issues/651) 开了一个新的工单 ，他提到一个由 Nicolas Tomb 开发，叫做 2048buntu 的 snap 应用包含加密货币矿工。tarwirdur 询问，他怎样才能出于安全的原因而“投诉该应用” 。tarwirdur 后来发表说其它由 Nicolas Tomb 开发的 snap 应用也都包含加密货币矿工。
看起来该 snap 应用使用了 systemd 在系统启动时自动地运行代码，并在用户不知情的情况下在后台运行。
>
> 对那些不熟悉相关术语的人来说，<ruby> 加密货币 <rt> cryptocurrency </rt></ruby><ruby> 矿工 <rt> miner </rt></ruby>是一段使用计算机的主处理器或者图形处理器来“挖掘”数字货币的程序。“挖矿”通常涉及到解决一个数学等式。在这种情况下，如果你在运行 2048buntu 游戏，这个游戏将会额外使用处理器的计算能力去进行加密货币的挖掘。
>
>
>
Snapcraft 团队迅速地下架了所有由该违规者开发的应用来做出回应。他们同时也开展了调查。
### 隐匿者发声
5 月 13 号，一位同名为 Nicolas Tomb 的 Disqus 用户在 OMGUbuntu 的新闻报道上发表了[评论](https://disqus.com/home/discussion/omgubuntu/malware_found_on_the_ubuntu_snap_store/#comment-3899153046)，他在评论中称自己向 snap 应用中添加了加密货币矿工，从而获取收益。他为他的行为道歉，同时承诺将所有挖矿所得的收益送给 Ubuntu 基金会。
我们不能确认这个评论就是由 Nicolas Tomb 发表的，因为这个 Disqus 账户最近才被创建，也只有一条评论与之相关联。现在，我们假设他是。
### Canonical 公司发表了声明
5 月 15 号，Canonical 公司在这种情况下发表了一份声明。标题为 [“在 Snap 应用商店中的信任与安全”](https://blog.ubuntu.com/2018/05/15/trust-and-security-in-the-snap-store)，声明开头重申了当下的情况。他们也补充道[重新发布的 snap 应用中已经被删除了加密货币挖矿程序](https://forum.snapcraft.io/t/action-against-snap-store-malware/5417/8)。
Canonical 公司随后尝试调查 Nicolas Tomb 的动机。他们指出，他告诉他们说自己这样做是为了通过应用赚钱（如上所诉），而当面对质疑时就停止了。他们也指出“挖掘加密货币本身并非不合法和不道德的”。然而，他们仍对他没有在 snap 应用描述中披露加密矿工这件事表示了不满意。
随后 Canonical 公司将话题转移到审核软件上。根据这份申明，Snap 应用商店将会采用一种类似 iOS、Android、Windows 的质量控制系统，这个系统将有“自动化的检查点，安装包必须在被接受前通过检查，同时在特殊问题被标记时会进行人工审核”。
然后，Canonical 公司声称“对大规模的软件仓库来说，只接受每个单独文件都被仔细审核过的软件是不可能的”。因此，他们需要信任软件源而不是内容。毕竟，软件源是现在 Ubuntu 软件仓库系统的基础。
Canonical 公司紧接着谈到了 Snap 应用的未来。他们承认现在的系统是不完美的。他们也在不断地进行改善。他们“在开发非常有趣的安全功能，这些功能将会在改善系统安全性同时提升人们在服务器或桌面上进行软件开发的体验”。
其中一个他们正在开发的功能是查看一个软件发布者是否已通过验证。其他的改进包括：“将所有 AppArmor 内核补丁递交到上游”和其它底层修复。
### 一些关于“Snap 应用商店中的恶意软件”的想法
基于我所了解的所有内容，我产生了一些想法和问题。
#### 这种挖矿软件运行多久了？
首先，这些挖矿软件存在于 Snap 应用商店多久了？因为它们已经被下架了，我们没有这样的数据。我可以通过 Google 快照抓取一些 2048buntu 页面的图片，但这没有提供任何可用的信息。根据该软件运行时间，多少系统安装过，挖掘出了什么加密货币，我们能否知道违规者获取的是一点钱还是一笔钱。一个更长远的问题是：Canonical 公司将来有能力捕捉到这样的违规情况吗？
#### 这真的是一个恶意软件吗？
许多新闻网站将之报道为恶意软件感染。我想我甚至可以看到这个事件被称为 Linux 的第一个恶意软件。我不确定这个术语是否精确。Dictionary.com 这样定义 [恶意软件](http://www.dictionary.com/browse/malware?s=t)：“意图损害计算机、移动设备、计算机系统或者计算机网络，或者对其运作进行部分控制的软件”。
这个有问题的 snap 应用并没有损害或者控制涉及到的计算机。它同样没有感染其他计算机。它也不能这样做，因为所有的 snap 应用位于沙盒之中。它们最多利用了处理器的计算能力，就是这样。所以，我不会称之为恶意软件。
#### 无孔不入
Nicolas Tomb 使用的一个辩解是在他上传应用的时候 Snap 应用商店没有任何反对加密货币挖矿的规则。（我敢向你打赌他们正在纠正这个错误。）他们之所以没有这样的规则，原因很简单，之前没有人做过这种事。如果 Tomb 想正确地做事，他应该提前询问是否允许这种行为。而事实是他似乎没有指出他知道 Canonical 公司可能会拒绝的事实。至少，Canonical 公司会告诉他将这些写在软件的描述中。
#### 一看就不对劲
如我之前说的，我从 Google 快照获取了一个 2048buntu 的页面截图。仅仅看它就会感觉到一些危险的信号。首先，截图中几乎没有真实的描述。它是这样描述的“类似 2048 的游戏。这个游戏用 ubuntu 主题克隆了流行的游戏 2048。”哇，这将会引来容易上当受骗的人。当我读到类似空洞的描述时，我会多考虑下。
我注意到的另一件事是软件的大小。2048buntu 的 1.0 版本大小将近 140 MB。一个简单的游戏怎么需要这么多的空间？有用 Javascript 写的浏览器版本大概只用了不到它的四分之一。其他 snap 应用商店的 2048 游戏的大小没有一个达到了这个软件的一半。
然后，它有个许可证。这是一个使用了 Ubuntu 主题的流行游戏的克隆。它怎么能被认为是专有软件？我确信，其他合法的开发者会因为该内容而使用了 FOSS （自由开源软件）许可证来上传它。
单是这些因素就使得这个 snap 应用很特殊，应该进行审核。
#### 谁是 Nicolas Tomb？
当第一次了解到这些之后，我决定看看我能否找出造成这些混乱的人。当我搜索 Nicolas Tomb 的时候，我什么都没找到。所有我找到的只是一大堆关于加密货币挖矿 snap 应用的新闻和文章，以及去 tomb of St. Nicolas 旅游的信息。在 Twiter 和 Github 上都没有 Nicolas Tomb 的标志。看起来似乎是为了上传这些 snap 应用才创建的名称。
这同样引出了 Canonical 公司发表的申明中的一点，关于验证发布者。上一次我查看的时候，相当多的 snap 应用不是由应用的维护者发布的。这让我感到担忧。我更乐意相信由 Mozilla 基金会发布的 firefox 的 snap 应用，而不是 Leonard Borsch。如果对应用维护者来说关注应用的 snap 版本太耗费精力，应该有办法让维护者在他们软件的 snap 版本上贴上批准的标签。就像是 Firefox 的 snap 版本由 Fredrick 发布，经 Mozilla 基金会批准。这样才能让用户对下载的内容更放心。
#### 无疑 Snap 应用商店还有改善的空间
在我看来，Snap 应用商店团队应该实现的第一个特性是报告可疑应用的方式。tarwirdur 必须找到该网站的 Github 页面才行。而大多数用户不会想到这一点。如果 Snap 应用商店不能审核每一行代码，那么使用户能够报告问题是退而求其次的办法。即使评分系统也是一个不差的补充。我确信一定有部分人因为 2048buntu 使用了太多系统资源而给它很低的评分。
### 结论
从我所知道的情况来说，我认为这是某个人创建了一些简单的应用，在每个应用中嵌入了加密货币矿工，之后将这些应用上传到 Snap 应用商店，想着捞一笔钱。一旦他们被抓了，他们就声称这仅仅为了通过应用程序获利。如果真的是这样，他们应该在 snap 应用的描述中提到才对。隐藏加密矿工并不是什么[新鲜事](https://krebsonsecurity.com/2018/03/who-and-what-is-coinhive/)。他们通常是一种盗取计算能力的方法。
我希望 Canonical 公司已经具备了解决这个问题的功能，盼望这些功能能很快出来。
你对 Snap 应用商店的“恶意软件风波”有什么看法？你将如何改善这种情况？请在下面的评论中告诉我们。
如果你觉得这篇文章有趣，请花费一点时间将它分享到社交媒体上。
---
via: <https://itsfoss.com/snapstore-cryptocurrency-saga/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[paperzhang](https://github.com/paperzhang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Cron 任务入门指南
|
Sk
|
https://www.ostechnix.com/a-beginners-guide-to-cron-jobs/
|
Cron 通常用于运行计划备份、监视磁盘空间、定期删除不再需要的文件（例如日志文件）、运行系统维护任务等等。在本简要指南中，我们将看到 Linux 中 Cron 任务的基本用法。
|
/data/attachment/album/201805/28/004507fa4g4x4g89mqt9xm.jpg.thumb.jpg
|
/data/attachment/album/201805/28/004507fa4g4x4g89mqt9xm.jpg
| true | false | true |
KevinSJ
| false |
[
"cron",
"定时"
] |
技术
|
{
"viewnum": 7434,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Cron 通常用于运行计划备份、监视磁盘空间、定期删除不再需要的文件（例如日志文件）、运行系统维护任务等等。在本简要指南中，我们将看到 Linux 中 Cron 任务的基本用法。
| 2018-05-28T06:43:00 | 2018-05-28T06:43:00 | 9,687 |
/article-9687-1.html
|
**Cron** 是您可以在任何类 Unix 操作系统中找到的最有用的实用程序之一。它用于安排命令在特定时间执行。这些预定的命令或任务被称为 “Cron 任务”。Cron 通常用于运行计划备份、监视磁盘空间、定期删除不再需要的文件（例如日志文件）、运行系统维护任务等等。在本简要指南中，我们将看到 Linux 中 Cron 任务的基本用法。
### Cron 任务入门指南
cron 任务的典型格式是：
```
分钟(0-59) 小时(0-24) 日(1-31) 月(1-12) 星期(0-6) 要执行的命令
```
只需记住 cron 任务的格式或打印下面的插图并将其放在你桌面上即可。
在上图中，星号表示特定的时间块。
要显示当前登录用户的 crontab 文件的内容：
```
$ crontab -l
```
要编辑当前用户的 cron 任务，请执行以下操作：
```
$ crontab -e
```
如果这是第一次编辑此文件，会询问你使用哪个编辑器来编辑此文件。
```
no crontab for sk - using an empty one
Select an editor. To change later, run 'select-editor'.
1. /bin/nano <---- easiest
2. /usr/bin/vim.basic
3. /usr/bin/vim.tiny
4. /bin/ed
Choose 1-4 [1]:
```
选择适合你的编辑器。这里是一个示例 crontab 文件的样子。
在这个文件中，你需要添加你的 cron 任务。
要编辑其他用户的 crontab，例如 ostechnix，请执行：
```
$ crontab -u ostechnix -e
```
让我们看看一些例子。
要 **每分钟** 执行一次 cron 任务，需使用如下格式。
```
* * * * * <command-to-execute>
```
要每 5 分钟运行一次 cron 任务，请在 crontab 文件中添加以下内容。
```
*/5 * * * * <command-to-execute>
```
要在每 1/4 个小时（每 15 分钟）运行一次 cron 任务，请添加以下内容：
```
*/15 * * * * <command-to-execute>
```
要每小时的第 30 分钟运行一次 cron 任务，请运行：
```
30 * * * * <command-to-execute>
```
您还可以使用逗号定义多个时间间隔。例如，以下 cron 任务每小时运行三次，分别在第 0、 5 和 10 分钟运行：
```
0,5,10 * * * * <command-to-execute>
```
每半小时运行一次 cron 任务：
```
*/30 * * * * <command-to-execute>
```
每小时运行一次：
```
0 * * * * <command-to-execute>
```
每 2 小时运行一次：
```
0 */2 * * * <command-to-execute>
```
每天运行一项（在 00:00 运行）：
```
0 0 * * * <command-to-execute>
```
每天凌晨 3 点运行：
```
0 3 * * * <command-to-execute>
```
每周日运行：
```
0 0 * * SUN <command-to-execute>
```
或使用，
```
0 0 * * 0 <command-to-execute>
```
它将在每周日的午夜 00:00 运行。
星期一至星期五每天运行一次，亦即每个工作日运行一次：
```
0 0 * * 1-5 <command-to-execute>
```
这项工作将于 00:00 开始。
每个月运行一次：
```
0 0 1 * * <command-to-execute>
```
于每月第 1 天的 16:15 运行：
```
15 16 1 * * <command-to-execute>
```
每季度运行一次，亦即每隔 3 个月的第 1 天运行：
```
0 0 1 */3 * <command-to-execute>
```
在特定月份的特定时间运行：
```
5 0 * 4 * <command-to-execute>
```
每个四月的 00:05 运行。
每 6 个月运行：
```
0 0 1 */6 * <command-to-execute>
```
这个定时任务将在每六个月的第一天的 00:00 运行。
每年运行：
```
0 0 1 1 * <command-to-execute>
```
这项 cron 任务将于 1 月份的第一天的 00:00 运行。
我们也可以使用以下字符串来定义任务。
`@reboot` 在每次启动时运行一次。 `@yearly` 每年运行一次。 `@annually`（和 `@yearly` 一样）。 `@monthly` 每月运行一次。 `@weekly` 每周运行一次。 `@daily` 每天运行一次。 `@midnight` （和 `@daily` 一样）。 `@hourly` 每小时运行一次。
例如，要在每次重新启动服务器时运行任务，请将此行添加到您的 crontab 文件中。
```
@reboot <command-to-execute>
```
要删除当前用户的所有 cron 任务：
```
$ crontab -r
```
还有一个名为 [crontab.guru](https://crontab.guru/) 的专业网站，用于学习 cron 任务示例。这个网站提供了很多 cron 任务的例子。
有关更多详细信息，请查看手册页。
```
$ man crontab
```
那么，就是这样。到此为止，您应该对 cron 任务以及如何实时使用它们有了一个基本的了解。后续还会介绍更多的优秀工具。敬请关注！！
干杯!
---
via: <https://www.ostechnix.com/a-beginners-guide-to-cron-jobs/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[KevinSJ](https://github.com/KevinSJ) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 X 中启动用户软件
|
Enrico Zini
|
http://www.enricozini.org/blog/2018/debian/starting-user-software/
|
这是一篇试图将所有方法聚集在一起的文章。某些部分可能不精确或不正确，但这是一个开始
|
/data/attachment/album/201805/28/215431k8cpcr4cpc4ckb9k.jpg.thumb.jpg
|
/data/attachment/album/201805/28/215431k8cpcr4cpc4ckb9k.jpg
| true | false | true |
geekpi
| false |
[] |
桌面应用
|
{
"viewnum": 4338,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这是一篇试图将所有方法聚集在一起的文章。某些部分可能不精确或不正确，但这是一个开始
| 2018-05-28T21:54:53 | 2018-05-28T21:54:53 | 9,688 |
/article-9688-1.html
|
目前有很多方法可以在开启用户会话时启动软件。
这是一篇试图将所有方法聚集在一起的文章。某些部分可能不精确或不正确，但这是一个开始，如果我收到更正，我很乐意保持更新。
### x11-common
```
man xsession
```
* 由显示管理器启动，如 `/usr/share/lightdm/lightdm.conf.d/01_debian.conf` 或 `/etc/gdm3/Xsession`。
* Debian 特定。
* 在 `/etc/X11/Xsession.d/` 中运行脚本。
* `/etc/X11/Xsession.d/40x11-common_xsessionrc` 引用 `~/.xsessionrc` ，它能比设置环境变量能做的多一点，因为它在 X 会话启动时运行。
* 最后，它启动会话管理器（`gnome-session`、`xfce4-session` 等等）。
### systemd --user
* <https://wiki.archlinux.org/index.php/Systemd/User>
* 由 `pam_systemd` 启动，所以在环境变量中可能没有设置 `DISPLAY` 变量。
* 管理单元：
+ `/usr/lib/systemd/user/` 由已安装的软件包提供的单元。
+ `~/.local/share/systemd/user/` 由安装在家目录的软件包提供的单元。
+ `/etc/systemd/user/` 由系统管理员提供的系统范围的用户的单元。
+ `~/.config/systemd/user/` ，用户自己放置的单元。
* 当设置 X 会话和 `DISPLAY` 变量时，启动 systemd 用户单元的技巧是从 `.desktop` 自启动文件调用 `systemctl start`。
### dbus 激活
* <https://dbus.freedesktop.org/doc/system-activation.txt>
* 进行 dbus 请求的用户进程可以触发启动服务器程序。
* 对于系统调试，有没有一种方法可以监控哪些服务正在启动 dbus ？
### X 会话管理器
* <https://en.wikipedia.org/wiki/X_session_manager>
* 由 `x11-common` 的 `Xsession.d` 运行。
* 运行 freedesktop 自动启动的 `.desktop` 文件。
* 运行桌面环境特定的软件。
### xdg 自动启动
* <https://specifications.freedesktop.org/autostart-spec/autostart-spec-latest.html>
* 由会话管理器运行。
* 如果存在 `/etc/xdg/autostart/foo.desktop` 和 `~/.config/autostart/foo.desktop` ，那么只会使用 `~/.config/autostart/foo.desktop`，因为 `~/.config/autostart/` 比 `/etc/xdg/autostart/` 更重要。
* 是顺序的还是并行？
### 其他启动注意事项
#### ~/.Xauthority
要连接到 X 服务器，客户端需要从 `~/.Xauthority` 发送一个令牌，这证明他们可以读取用户的隐私数据。
`~/.Xauthority` 包含显示管理器生成的一个令牌，并在启动时传递给 X。
要查看它的内容，请使用 `xauth -i -f ~/.Xauthority list`。
---
via: <http://www.enricozini.org/blog/2018/debian/starting-user-software/>
作者：[Enrico Zini](http://www.enricozini.org/) 选题：[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/) 荣誉推出
|
||
如何在终端中显示图片
|
Sk
|
https://www.ostechnix.com/how-to-display-images-in-the-terminal/
|
Linux 上有许多 GUI 图片浏览器。但我尚未听说或使用过任何在终端中显示图片的应用程序。幸运的是，我刚刚发现了一个可用于在终端中显示图像的名叫 FIM 的图像查看器。
|
/data/attachment/album/201805/29/070700z6mmvldnva6akrek.png.thumb.jpg
|
/data/attachment/album/201805/29/070700z6mmvldnva6akrek.png
| true | false | true |
KevinSJ
| false |
[
"图片",
"终端"
] |
分享
|
{
"viewnum": 23359,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux 上有许多 GUI 图片浏览器。但我尚未听说或使用过任何在终端中显示图片的应用程序。幸运的是，我刚刚发现了一个可用于在终端中显示图像的名叫 FIM 的图像查看器。
| 2018-05-29T07:06:58 | 2018-05-29T07:06:58 | 9,690 |
/article-9690-1.html
|
Linux 上有许多 GUI 图片浏览器。但我尚未听说或使用过任何在终端中显示图片的应用程序。幸运的是，我刚刚发现了一个可用于在终端中显示图像的名叫 **FIM** 的图像查看器。FIM 引起了我的注意，是因为与大多数 GUI 图片浏览器相比，它非常轻巧。毫不迟疑，让我们来看看它能做什么。
### 使用 FIM 在终端中显示图像
**FIM** 意即 **F**bi **IM**proved。对于那些不知道的人，**Fbi** 是指 Linux 中的 **f**rame **b**uffer **i**mageviewer。它使用系统的帧缓冲器直接从命令行显示图像。默认情况下，它能用终端显示 bmp、gif、jpeg、PhotoCD、png、ppm、tiff 和 xwd。对于其他格式，它会尝试使用 ImageMagick 的转换。
FIM 基于 Fbi，它是一款高度可高度定制及脚本化的图像浏览器，非常适合使用 Vim 文本编辑器或 Mutt 等软件的用户。它会以全屏显示图像，并可通过键盘快捷键控制（如调整大小、翻转、缩放）。与 Fbi 不同的是，FIM 是通用的：它可以打开许多文件格式，并且可以在以下视频模式下显示图片：
* 使用 Linux framebuffer 设备，以图形方式呈现
* 在 X / Xorg 下，使用 SDL 库，以图形方式呈现
* 在 X / Xorg 下，使用 Imlib2 库，以图形方式呈现。
* 在任何文本控制台中使用 AAlib 库呈现为 ASCII 字符画
FIM 是完全免费且开源的。
### 安装 FIM
基于 DEB 的系统，如 Ubuntu、Linux Mint， 可从默认的仓库中获取 FIM 图像查看器。因此，你可以使用如下命令安装fbi：
```
$ sudo apt-get install fim
```
如果它在你使用的 Linux 发行版的仓库中不包含 FIM，则可以下载源代码进行编译和安装，如下所示。
```
wget http://download.savannah.nongnu.org/releases/fbi-improved/fim-0.6-trunk.tar.gz
wget http://download.savannah.nongnu.org/releases/fbi-improved/fim-0.6-trunk.tar.gz.sig
gpg --search 'dezperado autistici org'
＃按照屏幕上的说明，从密钥服务器导入密钥
gpg --verify fim-0.6-trunk.tar.gz.sig
```
```
tar xzf fim-0.6-trunk.tar.gz
cd fim-0.6-trunk
./configure --help=short
＃阅读./configure --help=short 的输出：你可以在 ./configure 中添加选项
./configure
make
su -c“make install”
```
### FIM用法
安装完成后，您可以使用以下命令以“自动缩放”显示的图像：
```
$ fim -a dog.jpg
```
这里是我的 Ubuntu 主机的示例输出。
正如你在上面的屏幕截图中看到的，FIM 没有使用任何外部 GUI 图片浏览器。相反，它使用我们系统的帧缓冲器来显示图像。
如果当前目录中有多个 .jpg 文件，可以使用通配符打开所有文件，如下所示。
```
$ fim -a * .jpg
```
要打开目录中的所有图像，例如 `Pictures`，请运行：
```
$ fim Pictures/
```
我们也可以在文件夹及其子文件夹中递归地打开图像，然后像下面那样对列表进行排序。
```
$ fim -R Pictures/ --sort
```
要以 ASCII 格式渲染图像，可以使用 `-t` 标志。
```
$ fim -t dog.jpg
```
要退出 Fim，请按 `ESC` 或 `q`。
#### 键盘快捷键
您可以使用各种键盘快捷键来管理图像。例如，要加载下一张图像和之前的图像，请按下 `PgUp` / `PgDown` 键。成倍放大或缩小，请使用 `+` / `-` 键。以下是用于在FIM中控制图像的常用按键。
* `PageUp` / `Down`：上一张/下一张图片
* `+` / `-` ：放大/缩小
* `a`：自动缩放
* `w`：自适应宽度
* `h`：自适应高度
* `j` / `k`：平移/向上
* `f` / `m`：翻转/镜像
* `r` / `R`：旋转（顺时针/逆时针）
* `ESC` / `q`：退出
有关完整详细信息，请参阅手册页。
```
$ man fim
```
那么，就是这样。希望这对你有所帮助。后续还会介绍更多的优秀工具。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/how-to-display-images-in-the-terminal/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[KevinSJ](https://github.com/KevinSJ) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
DevOps 接下来会发生什么：要关注的 5 个趋势
|
Kevin Casey
|
https://enterprisersproject.com/article/2017/10/what-s-next-devops-5-trends-watch
|
专家们权衡了 DevOps 团队最近会有何期望。
|
/data/attachment/album/201805/29/073014kx8s8oa778ii8i7i.png.thumb.jpg
|
/data/attachment/album/201805/29/073014kx8s8oa778ii8i7i.png
| true | false | true |
qhwdw
| false |
[
"DevOps"
] |
观点
|
{
"viewnum": 3955,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
专家们权衡了 DevOps 团队最近会有何期望。
| 2018-05-29T07:30:12 | 2018-05-29T07:30:12 | 9,691 |
/article-9691-1.html
|
>
> 专家们权衡了 DevOps 团队最近会有何期望。
>
>
>
“DevOps” 一词通常认为是来源于 [这篇 2008 年关于敏捷基础设施和运营的讲演中](http://www.jedi.be/presentations/agile-infrastructure-agile-2008.pdf)。现在的 IT 词汇中，它无处不在，这个“混搭”的词汇出现还不到 10 年：我们还在研究它在 IT 中更现代化的工作方法。
诚然，多年来一直在 “从事 DevOps” 的人积累了丰富的知识。但是大多数的 DevOps 环境 —— 人与 [文化](https://enterprisersproject.com/article/2017/9/5-ways-nurture-devops-culture) 、流程与方法、工具与技术的融合 —— 还远远没有成熟。
更多的变化即将到来。Robert Reeves 说 “DevOps 是一个过程，一种算法”，他是 [Datical](https://www.datical.com/) 的 CTO， “它的绝对目标就是随着时间进行改变和演进”，这就是重点。
那我们预计接下来会发生什么呢？这里有一些专家们观察到的重要趋势。
### 1、 预计 DevOps、容器、以及微服务之间的相互依赖会增强
驱动 DevOps 发展的文化本身可能会演进。当然，DevOps 仍然将在根本上摧毁传统的 IT 孤岛和瓶颈，但这样做的理由可能会变得更加急迫。证据 A & B： [对容器和微服务的兴趣](https://enterprisersproject.com/article/2017/9/microservices-and-containers-6-things-know-start-time) 与日俱增。这个技术组合很强大、可连续扩展、与规划和 [持续进行的管理](https://enterprisersproject.com/article/2017/10/microservices-and-containers-6-management-tips-long-haul)配合最佳。
Arvind Soni 说 “影响 DevOps 的其中一个主要因素是向微服务转变”，他是 [Netsil](https://netsil.com/) 的产品副总裁，补充道，容器和业务流程，使开发者打包和交付的速度越来越快。DevOps 团队的任务可能是帮助去加速打包并管理越来越复杂的微服务弹性架构。
### 2、 预计 ”安全网“ 更少
DevOps 使团队可以更快更敏捷地去构建软件，部署速度也更快更频繁、同时还能提升软件质量和稳定性。但是好的 IT 领导通常都不会忽视管理风险，因此，早期大量的 DevOps 迭代都是使用了安全防护 —— 从后备的不重要业务开始的。为了实现更快的速度和敏捷性，越来越多的团队将抛弃他们的 ”辅助轮“（LCTT 译注：意思说减少了安全防护措施）。
Nic Grange 说 “随着团队的成熟，他们决定不再需要一些早期增加的安全 ‘防护栏’ 了”，他是 [Retriever Communications](http://retrievercommunications.com/) 的 CTO。Grange 给出了一个阶段展示的服务器的示例：随着 DevOps 团队的成熟，他们决定不再需要阶段展示的服务器了，尤其是他们很少在试生产环境中发现问题。（Grange 指出，这一举措对于缺乏 DevOps 经验的团队来说，不可轻易效仿）
Grange 说 “这个团队可能在监视和发现并解决生产系统中出现的问题的能力上有足够的信心”，“部署过程和测试阶段，如果没有任何证据证明它的价值，那么它可能会把整个进度拖慢”。
### 3、 预计 DevOps 将在其它领域大面积展开
DevOps 将两个传统的 IT 部门（开发和运营）结合的更紧密。越来越多的公司看到了这种结合的好处，这种文化可能会传播开来。这种情况在一些组织中已经出现，在 “DevSecOps” 一词越来越多出现的情况下，它反映出了在软件开发周期中有意地、越来越早地包含了安全性。
Derek Weeks 说 “DevSecOps 不仅是一个工具，它是将安全思维更早地集成到开发实践中”，它是 [Sonatype](https://www.sonatype.com/) 的副总裁和 DevOps 拥挤者。
[Red Hat](https://www.redhat.com/en/) 的安全策略师 Kirsten Newcomer 说，这种做法并不是一个技术挑战，而是一个文化挑战。
Newcomer 说 “从历史来看，安全团队都是从开发团队中分离出来的 —— 每个团队在它们不同的 IT 领域中形成了各自的专长” ，“它并不需要这种方法。每个关心安全性的企业也关心他们通过软件快速交付业务价值的能力，这些企业正在寻找方法，将安全放进应用程序的开发周期中。它们采用 DevSecOps 通过 CI/CD 流水线去集成安全实践、工具和自动化。为了做的更好，他们整合他们的团队 —— 将安全专家整合到应用程序开发团队中，参与到从设计到产品部署的全过程中。这种做法使双方都看到了价值 —— 每个团队都扩充了它们的技能和知识，使他们成为更有价值的技术专家。DevOps 做对了 —— 或者说是 DevSecOps —— 提升了 IT 安全性。”
除了安全以外，还可以让 DevOps 扩展到其它领域，比如数据库团队、QA，甚至是 IT 以外的潜在领域。
Datical 的 Reeves 说 “这是一件非常 DevOps 化的事情：发现相互掣肘的地方并解决它们”，“对于以前采用 DevOps 的企业来说，安全和数据库是他们面临的最大瓶颈。”
### 4、 预计 ROI 将会增加
Eric Schabell 说，“由于公司深入推进他们的 DevOps 工作，IT 团队在方法、流程、容器和微服务方面的投资将得到更多的回报。” 他是 Red Hat 的全球技术传播总监，Schabell 说 “‘圣杯’将移动的更快、完成的更多、并且变得更灵活。由于这些组件找到了更宽阔的天地，组织在应用程序中更有归属感时，结果就会出现。”
“每当新兴技术获得我们的关注时，任何事都有一个令人兴奋的学习曲线，但当认识到它应用很困难的时候，同时也会经历一个从兴奋到幻灭的低谷。最终，我们将开始看到从低谷中爬出来，并收获到应用 DevOps、容器、和微服务的好处。”
### 5、 预计成功的指标将持续演进
Mike Kail 说 “我相信 DevOps 文化的两个核心原则 —— 自动化和可衡量是从来不会变的”，它是 [CYBRIC](https://www.cybric.io/) 的 CTO，也是 Yahoo 前 CIO。“总是有办法去自动化一个任务，或者提升一个已经自动化的解决方案，而随着时间的推移，重要的事情是测量可能的变化和扩展。这个成熟的过程是一个永不停步的旅行，而不是一个目的地或者已完成的任务。”
在 DevOps 的精神中，成熟和学习也与协作者和分享精神有关。Kail 认为，对于敏捷方法和 DevOps 文化来说，它仍然为时尚早，这意味着它们还有足够的增长空间。
Kail 说 “随着越来越多的成熟组织持续去测量可控指标，我相信（希望） —— 这些经验应该被广泛的分享，以便我们去学习并改善它们。”
作为 Red Hat 技术传播专家，[Gordon Haff](https://enterprisersproject.com/user/gordon-haff) 最近注意到，组织使用业务成果相关的因素去改善他们的 DevOps 指标的工作越来越困难。 [Haff 写道](https://enterprisersproject.com/article/2017/7/devops-metrics-are-you-measuring-what-matters) “你或许并不真正关心你的开发者写了多少行代码、服务器是否在一夜之间出现了硬件故障、或者你的测试覆盖面是否全面”。事实上，你可能并不直接关心你的网站的响应速度和更新快慢。但是你要注意的是，这些指标可能与消费者放弃购物车或者转到你的竞争对手那里有关。”
与业务成果相关的一些 DevOps 指标的例子包括，消费者交易金额（作为消费者花销统计的指标）和净推荐值（消费者推荐公司产品和服务的意愿）。关于这个主题更多的内容，请查看这篇完整的文章—— [DevOps 指标：你是否测量了重要的东西](https://enterprisersproject.com/article/2017/7/devops-metrics-are-you-measuring-what-matters)。
### 唯一不变的就是改变
顺利说一句，如果你希望这件事一蹴而就，那你就要倒霉了。
Reeves 说 “如果你认为今天发布非常快，那你就什么也没有看到”，“这就是为什么要让相关者包括数据库团队进入到 DevOps 中的重要原因。因为今天这两组人员的冲突会随着发布速度的提升而呈指数级增长。”
---
via: <https://enterprisersproject.com/article/2017/10/what-s-next-devops-5-trends-watch>
作者：[Kevin Casey](https://enterprisersproject.com/user/kevin-casey) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
四个 Linux 上的网络信息嗅探工具
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2018/1/4-tools-network-snooping-linux
|
在计算机网络中，数据是暴露的，因为数据包传输是无法隐藏的
|
/data/attachment/album/201805/30/051915svsqx6cuu1d1ht6t.jpg.thumb.jpg
|
/data/attachment/album/201805/30/051915svsqx6cuu1d1ht6t.jpg
| true | false | true |
wyxplus
| false |
[
"嗅探"
] |
技术
|
{
"viewnum": 11135,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在计算机网络中，数据是暴露的，因为数据包传输是无法隐藏的
| 2018-05-30T05:19:00 | 2018-05-30T05:19:00 | 9,692 |
/article-9692-1.html
|
在计算机网络中，数据是暴露的，因为数据包传输是无法隐藏的，所以让我们来使用 `whois`、`dig`、`nmcli` 和 `nmap` 这四个工具来嗅探网络吧。
请注意，不要在不属于自己的网络上运行 `nmap` ，因为这有可能会被其他人认为恶意攻击。
### 精简和详细域名信息查询
您可能已经注意到，之前我们用常用的老式 `whois` 命令查询域名信息，但现如今似乎没有提供同过去一样的详细程度。我们使用该命令查询 linux.com 的域名描述信息：
```
$ whois linux.com
Domain Name: LINUX.COM
Registry Domain ID: 4245540_DOMAIN_COM-VRSN
Registrar WHOIS Server: whois.namecheap.com
Registrar URL: http://www.namecheap.com
Updated Date: 2018-01-10T12:26:50Z
Creation Date: 1994-06-02T04:00:00Z
Registry Expiry Date: 2018-06-01T04:00:00Z
Registrar: NameCheap Inc.
Registrar IANA ID: 1068
Registrar Abuse Contact Email: abuse@namecheap.com
Registrar Abuse Contact Phone: +1.6613102107
Domain Status: ok https://icann.org/epp#ok
Name Server: NS5.DNSMADEEASY.COM
Name Server: NS6.DNSMADEEASY.COM
Name Server: NS7.DNSMADEEASY.COM
DNSSEC: unsigned
[...]
```
有很多令人讨厌的法律声明。但在哪有联系信息呢？该网站位于 `whois.namecheap.com` 站点上（见上面输出的第三行）：
```
$ whois -h whois.namecheap.com linux.com
```
我就不复制出来了，因为这实在太长了，包含了注册人，管理员和技术人员的联系信息。怎么回事啊，露西尔？（LCTT 译注：《行尸走肉》中尼根的棒子）有一些注册库，比如 .com 和 .net 是精简注册库，保存了一部分有限的域名信息。为了获取完整信息请使用 `-h` 或 `--host` 参数，该参数便会从域名的 `注册服务机构` 中获取。
大部分顶级域名是有详细的注册信息，如 .info。试着使用 `whois blockchain.info` 命令来查看。
想要摆脱这些烦人的法律声明？使用 `-H` 参数。
### DNS 解析
使用 `dig` 命令比较从不同的域名服务器返回的查询结果，去除陈旧的信息。域名服务器记录缓存各地的解析信息，并且不同的域名服务器有不同的刷新间隔。以下是一个简单的用法：
```
$ dig linux.com
<<>> DiG 9.10.3-P4-Ubuntu <<>> linux.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<<- opcode: QUERY, status: NOERROR, id: 13694
;; flags: qr rd ra; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1440
;; QUESTION SECTION:
;linux.com. IN A
;; ANSWER SECTION:
linux.com. 10800 IN A 151.101.129.5
linux.com. 10800 IN A 151.101.65.5
linux.com. 10800 IN A 151.101.1.5
linux.com. 10800 IN A 151.101.193.5
;; Query time: 92 msec
;; SERVER: 127.0.1.1#53(127.0.1.1)
;; WHEN: Tue Jan 16 15:17:04 PST 2018
;; MSG SIZE rcvd: 102
```
注意下靠近末尾的这行信息：`SERVER: 127.0.1.1#53(127.0.1.1)`，这是您默认的缓存解析器。当地址是本地时，就表明您的电脑上安装了 DNS 服务。在我看来这就是一个 Dnsmasq 工具（LCTT 译注：是一个小巧且方便地用于配置 DNS 和 DHCP 的工具），该工具被用作网络管理：
```
$ ps ax|grep dnsmasq
2842 ? S 0:00 /usr/sbin/dnsmasq --no-resolv --keep-in-foreground
--no-hosts --bind-interfaces --pid-file=/var/run/NetworkManager/dnsmasq.pid
--listen-address=127.0.1.1
```
`dig` 命令默认是返回 A 记录，也就是域名。IPv6 则有 AAAA 记录：
```
$ $ dig linux.com AAAA
[...]
;; ANSWER SECTION:
linux.com. 60 IN AAAA 64:ff9b::9765:105
linux.com. 60 IN AAAA 64:ff9b::9765:4105
linux.com. 60 IN AAAA 64:ff9b::9765:8105
linux.com. 60 IN AAAA 64:ff9b::9765:c105
[...]
```
仔细检查下，发现 linux.com 有 IPv6 地址。很好！如果您的网络服务支持 IPv6 那么您就可以用 IPv6 连接。（令人难过的是，我的移动宽带则没提供 IPv6）
假设您能对您的域名做一些 DNS 改变，又或是您使用 `dig` 查询的结果有误。试着用一个公共 DNS，如 OpenNIC：
```
$ dig @69.195.152.204 linux.com
[...]
;; Query time: 231 msec
;; SERVER: 69.195.152.204#53(69.195.152.204)
```
`dig` 回应您正在的查询是来自 69.195.152.204。您可以查询各种服务并且比较结果。
### 上游域名服务器
我想知道我的上游域名服务器（LCTT 译注：此处指解析器）是谁。为了查询，我首先看下 `/etc/resolv/conf` 的配置信息:
```
$ cat /etc/resolv.conf
# Dynamic resolv.conf(5) file for glibc resolver(3) generated by resolvconf(8)
# DO NOT EDIT THIS FILE BY HAND -- YOUR CHANGES WILL BE OVERWRITTEN
nameserver 127.0.1.1
```
好吧，不过我已经知道了。您的 Linux 发行版可能配置不同，您会看到您的上游服务器。接下来我们来试试网络管理器命令行工具 `nmcli`：
```
$ nmcli dev show | grep DNS
IP4.DNS[1]: 192.168.1.1
```
很好，现在我们已经知道了，其实那是我的移动热点，我能确认。我能够登录到简易管理面板，来查询上游服务器。然而许多用户级互联网网关不会让您看到或改变这些设置，因此只能尝试其他的方法，如 [我的域名服务器是什么？](http://www.whatsmydnsserver.com/)
### 查找在您的网络中 IPv4 地址
您的网络上有哪些 IPv4 地址已启用并正在使用中？
```
$ nmap -sn 192.168.1.0/24
Starting Nmap 7.01 ( https://nmap.org ) at 2018-01-14 14:03 PST
Nmap scan report for Mobile.Hotspot (192.168.1.1)
Host is up (0.011s latency).
Nmap scan report for studio (192.168.1.2)
Host is up (0.000071s latency).
Nmap scan report for nellybly (192.168.1.3)
Host is up (0.015s latency)
Nmap done: 256 IP addresses (2 hosts up) scanned in 2.23 seconds
```
每个人都想去扫描自己的局域网中开放的端口。下面的例子是寻找服务和他们的版本号：
```
$ nmap -sV 192.168.1.1/24
Starting Nmap 7.01 ( https://nmap.org ) at 2018-01-14 16:46 PST
Nmap scan report for Mobile.Hotspot (192.168.1.1)
Host is up (0.0071s latency).
Not shown: 997 closed ports
PORT STATE SERVICE VERSION
22/tcp filtered ssh
53/tcp open domain dnsmasq 2.55
80/tcp open http GoAhead WebServer 2.5.0
Nmap scan report for studio (192.168.1.102)
Host is up (0.000087s latency).
Not shown: 998 closed ports
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.2p2 Ubuntu 4ubuntu2.2 (Ubuntu Linux; protocol 2.0)
631/tcp open ipp CUPS 2.1
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 256 IP addresses (2 hosts up) scanned in 11.65 seconds
```
这些是有趣的结果。让我们尝试从不同的互联网连接进行相同的操作，以查看这些服务是否暴露于互联网中。如果您有智能手机，相当于您有第二个网络。您可以下载应用程序，还可以为您的 Linux 电脑提供热点。从热点控制面板获取广域网IP地址，然后重试：
```
$ nmap -sV 12.34.56.78
Starting Nmap 7.01 ( https://nmap.org ) at 2018-01-14 17:05 PST
Nmap scan report for 12.34.56.78
Host is up (0.0061s latency).
All 1000 scanned ports on 12.34.56.78 are closed
```
果然不出所料，结果和我想象的一样（LCTT 译注：这些服务和信息没有被暴露在公网上）。可以用手册来查询这些命令，以便了解更多有趣的嗅探技术。
了解更多 Linux 的相关知识可以从 Linux 基金会和 edX（LCTT译注：edX 是麻省理工和哈佛大学于 2012 年 4 月联手创建的大规模开放在线课堂平台）中获取免费的 [“介绍 Linux”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)课程。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/1/4-tools-network-snooping-linux>
作者：[Carla Schroder](https://www.linux.com/users/cschroder) 译者：[wyxplus](https://github.com/wyxplus) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中安装 Ncurses 库
|
Sk
|
https://www.ostechnix.com/how-to-install-ncurses-library-in-linux/
|
GNU Ncurses 是一个允许用户编写基于文本的用户界面（TUI）的编程库。许多基于文本的游戏都是使用这个库创建的。
|
/data/attachment/album/201805/30/052558qxq9b12iz8qk8nqh.png.thumb.jpg
|
/data/attachment/album/201805/30/052558qxq9b12iz8qk8nqh.png
| true | false | true |
geekpi
| false |
[
"Ncurses"
] |
技术
|
{
"viewnum": 28107,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
GNU Ncurses 是一个允许用户编写基于文本的用户界面（TUI）的编程库。许多基于文本的游戏都是使用这个库创建的。
| 2018-05-30T05:25:55 | 2018-05-30T05:25:55 | 9,693 |
/article-9693-1.html
|
**GNU Ncurses** 是一个允许用户编写基于文本的用户界面（TUI）的编程库。许多基于文本的游戏都是使用这个库创建的。一个受欢迎的例子是 [PacVim](https://www.ostechnix.com/pacvim-a-cli-game-to-learn-vim-commands/)，这是一款学习 VIM 命令的 CLI 游戏。在这篇简要的指南中，我将解释如何在类 Unix 操作系统中安装 Ncurses 库。
### 在 Linux 中安装 Ncurses 库
Ncurses 在大多数 Linux 发行版的默认仓库中都有。例如，你可以使用以下命令将其安装在基于 Arch 的系统上：
```
$ sudo pacman -S ncurses
```
在RHEL、CentOS 上：
```
$ sudo yum install ncurses-devel
```
在 Fedora 22 和更新版本上：
```
$ sudo dnf install ncurses-devel
```
在 Debian、Ubuntu、Linux Mint 上：
```
$ sudo apt-get install libncurses5-dev libncursesw5-dev
```
默认仓库中的 GNU ncureses 可能有点老了。如果你想要最新的稳定版本，可以从源代码进行编译和安装，如下所示。
从[这里](https://ftp.gnu.org/pub/gnu/ncurses/)下载最新的 ncurses 版本。在写这篇文章时，最新版本是 6.1。
```
$ wget https://ftp.gnu.org/pub/gnu/ncurses/ncurses-6.1.tar.gz
```
解压 tar 文件：
```
$ tar xzf ncurses-6.1.tar.gz
```
这将在当前目录中创建一个名为 ncurses-6.1 的文件夹。cd 到该目录：
```
$ cd ncurses-6.1
$ ./configure --prefix=/opt/ncurses
```
最后，使用以下命令进行编译和安装：
```
$ make
$ sudo make install
```
使用命令验证安装：
```
$ ls -la /opt/ncurses
```
就是这样。Ncurses 已经安装在 Linux 发行版上。继续使用 Ncurses 创建漂亮的 TUI。
还会有更多的好东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/how-to-install-ncurses-library-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[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 18.04 的一些事
|
Abhishek Prakash
|
https://itsfoss.com/ubuntu-18-04-faq/
|
我试图在这里回答关于 Ubuntu 18.04 的常见问题。如果您有任何疑问，我希望这能帮助您解决疑问。
|
/data/attachment/album/201805/30/053816snzvlyp5y1w681la.png.thumb.jpg
|
/data/attachment/album/201805/30/053816snzvlyp5y1w681la.png
| true | false | true |
wyxplus
| false |
[
"Ubuntu"
] |
桌面应用
|
{
"viewnum": 15276,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我试图在这里回答关于 Ubuntu 18.04 的常见问题。如果您有任何疑问，我希望这能帮助您解决疑问。
| 2018-05-30T05:38:14 | 2018-05-30T05:38:14 | 9,694 |
/article-9694-1.html
|
[Ubuntu 18.04 版本](/article-9583-1.html) 已经到来。我可以在各种 Facebook 群组和论坛中看到许多来自 Ubuntu 用户的提问。我还在 Facebook 和 Instagram 上组织了 Q&A 会议，以了解 Ubuntu 用户对 Ubuntu 18.04 的想法。
我试图在这里回答关于 Ubuntu 18.04 的常见问题。如果您有任何疑问，我希望这能帮助您解决疑问。如果您仍有问题，请随时在下面的评论区提问。
### Ubuntu 18.04 中有什么值得期待
解释一下，这里的一些问答会受到我个人的影响。如果您是一位经验丰富或了解 Ubuntu 的用户，其中一些问题可能对您而言很简单。如果是这样的话，就请忽略这些问题。
#### 我能够在 Ubuntu 18.04 中安装 Unity 吗？
当然能够哦！
Canonical 公司知道有些人喜欢 Unity。这就是为什么它已经在 Universe 软件库（LCTT译者注：社区维护的软件库）中提供了 Unity 7。但这是一个社区维护版，官方并不直接参与开发。
不过我建议是使用默认的 GNOME，除非您真的无法容忍它，再在 [Ubuntu 18.04 上安装 Unity](https://itsfoss.com/use-unity-ubuntu-17-10/)。
#### GNOME 是什么版本？
在这次发行的 Ubuntu 18.04 版本中，GNOME 版本号是 3.28。
#### 我能够安装原装的 GNOME 吗？
当然没问题！
因为存在一些 GNOME 用户可能不喜欢 Ubuntu 18.04 中的 Unity 风格。在 Ubuntu 中的 main（LCTT译者注：官方支持的软件库）和 universe 软件库有安装包可安装，能使您在 [Ubuntu 18.04 中安装原装的 GNOME](https://itsfoss.com/vanilla-gnome-ubuntu/)。
#### GNOME 中的内存泄漏已修复了吗？
已经修复了。[GNOME 3.28 中臭名昭着的内存泄漏](https://feaneron.com/2018/04/20/the-infamous-gnome-shell-memory-leak/) 已经被修复了，并且 [Ubuntu 官方已经在测试这个修复程序](https://community.ubuntu.com/t/help-test-memory-leak-fixes-in-18-04-lts/5251)。
澄清一点，内存泄漏不是由 Ubuntu 系统引起的。它影响了所有使用 GNOME 3.28 的 Linux 发行版。GNOME 3.28.1 发布了一个新的补丁修复内存泄漏问题。
#### Ubuntu 18.04 将会被支持多久？
这是一个长期支持（LTS）版本，与任何 LTS 版本一样，官方会支持五年。这意味着 Ubuntu 18.04 将在 2023 年 4 月之前能获得安全和维护更新。这对于除 Ubuntu Studio 之外的所有基于 Ubuntu 的 Linux 发行版也一样。
#### Ubuntu 18.04 什么时候发布的？
Ubuntu 18.04 LTS 在 4 月 26 日发布。 所有基于 Ubuntu 的 Linux 发行版，如 Kubuntu、Lubuntu、Xubuntu、Budgie、MATE 等都会在同一天发布其 18.04 版本。
不过 [Ubuntu Studio 不会有 18.04 的 LTS 版本](https://www.omgubuntu.co.uk/2018/04/ubuntu-studio-plans-to-reboot)。
#### 是否能从 16.04/17.10 升级到 Ubuntu 18.04？我可以从使用 Unity 的 Ubuntu 16.04 升级到使用 GNOME 的 Ubuntu 18.04 吗？
绝对没问题。当 Ubuntu 18.04 LTS 发布后，您可以很容易的升级到最新版。
如果您使用的是 Ubuntu 17.10，请确保在“软件和更新”->“更新”中，将“有新版本时通知我”设置为“适用任何新版本”。
如果您使用的是 Ubuntu 16.04，请确保在“软件和更新”->“更新”中，将“有新版本时通知我”设置为“适用长期支持版本”。
然后您应该能获得有关新版本更新的系统通知。之后，升级到 Ubuntu 18.04 只需要点击几下鼠标而已。
即使 Ubuntu 16.04 使用的是 Unity，但您仍然可以 [升级到使用 GNOME 的 Ubuntu 18.04](https://itsfoss.com/upgrade-ubuntu-version/)。
#### 升级到 Ubuntu 18.04 意味着什么？我会丢失数据吗？
如果您使用的是 Ubuntu 17.10 或 Ubuntu 16.04，系统会提示您可升级到 Ubuntu 18.04。如果您从互联网上下载 1.5 Gb 的数据不成问题，则只需点击几下鼠标，即可在 30 分钟内升级到 Ubuntu 18.04。
您不需要通过 U 盘来重装系统。升级过程完成后，您将可以使用新的 Ubuntu 版本。
通常，您的数据和文档等在升级过程中是安全的。但是，对重要文档进行备份始终是一个好的习惯。
#### 我什么时候能升级到 Ubuntu 18.04？
如果您使用的是 Ubuntu 17.10 并且正确设置（设置方法在之前提到的问题中），那么在 Ubuntu 18.04 发布的几天内应该会通知您升级到 Ubuntu 18.04。为避免 Ubuntu 服务器在发布时的负载量过大，因此不是每个人都会在同一天收到升级提示。
对于 Ubuntu 16.04 用户，可能需要几周时间才能正式收到 Ubuntu 18.04 升级提示。通常，这将在第一次发布 Ubuntu 18.04.1 之后提示。该版本修复了 18.04 中发现的新 bug。
#### 如果我升级到 Ubuntu 18.04，我可以降级到 17.10/16.04？
抱歉，并不行。尽管升级到新版本很容易，但没有降级的选项。如果您想回到 Ubuntu 16.04，只能重新安装。
#### 我能使用 Ubuntu 18.04 在 32 位系统上吗？
可以，但最好不要这样做。
如果您已经在使用 32 位版本的 Ubuntu 16.04 或 17.10，您依旧可以升级到 Ubuntu 18.04。 但是，您找到不到 32 位的 Ubuntu 18.04 ISO 镜像。换句话说，您无法安装 32 位版本的 Ubuntu 18.04。
有一个好消息是，Ubuntu MATE、Lubuntu 等其他官方版本仍然具有其新版本的 32 位 ISO 镜像。
无论如何，如果您使用一个 32 位系统，那么很可能您的计算机硬件性能过低。在这样的电脑上使用轻量级 [Ubuntu MATE](https://ubuntu-mate.org/) 或 [Lubuntu](https://lubuntu.net/) 系统会更好。
#### 我可以在哪下载 Ubuntu 18.04？
18.04 已经发布了，您可以从其网站获得 Ubuntu 18.04 的 ISO 镜像。您既可以直接官网下载，也能用种子下载。其他官方版本将在其官方网站上提供下载。
#### 我应该重新安装 Ubuntu 18.04 还是从 16.04/17.10 升级上来？
如果您有重新安装的机会，建议备份您的数据并重新安装 Ubuntu 18.04。
从现有版本升级到 18.04 是一个方便的选择。不过，就我个人而言，它仍然保留了旧版本的依赖包。重新安装还是比较干净。
#### 对于重新安装来说，我应该安装 Ubuntu 16.04 还是 Ubuntu 18.04？
如果您要在计算机上安装 Ubuntu，请尽量使用 Ubuntu 18.04 而不是 16.04。
他们都是长期支持版本，并被支持很长一段时间。Ubuntu 16.04 会获得维护和安全更新服务直到 2021 年，而 18.04 则会到 2023 年。
不过，我建议您使用 Ubuntu 18.04。任何 LTS 版本都会在 [一段时间内获得硬件更新支持](https://www.ubuntu.com/info/release-end-of-life)（我认为是两年半的时间内）。之后，它只获得维护更新。如果您有更新的硬件，您将在 18.04 获得更好的支持。
此外，许多应用程序开发人员将很快开始关注 Ubuntu 18.04。新创建的 PPA 可能仅在几个月内支持 18.04。所以使用 18.04 比 16.04 更好。
#### 安装打印机-扫描仪驱动程序比使用 CLI 安装会更容易吗？
在打印机方面，我不是专家，所以我的观点是基于我在这方面有限的知识。大多数新打印机都支持 [IPP协议](https://www.pwg.org/ipp/everywhere.html)，因此它们应该在 Ubuntu 18.04 中能够获到很好的支持。 然而对较旧的打印机我则无法保证。
#### Ubuntu 18.04 是否对 Realtek 和其他 WiFi 适配器有更好的支持？
抱歉，没有关于这部分的具体信息。
#### Ubuntu 18.04 的系统要求？
对于默认的 GNOME 版本，最好您应该有 [4 GB 的内存以便正常使用](https://help.ubuntu.com/community/Installation/SystemRequirements)。使用过去 8 年中发布的处理器也可以运行。但任何比这性能更差的硬件建议使用 [轻量级 Linux 发行版](https://itsfoss.com/lightweight-linux-beginners/)，例如 [Lubuntu](https://lubuntu.net/)。
#### 有关 Ubuntu 18.04 的其问题？
如果还有其他疑问，请随时在下方评论区留言。如果您认为应将其他信息添加到列表中，请告诉我。
（LCTT 译注：本文原文写于 Ubuntu 18.04 LTS 发布之前，译文翻译于发布之后，因此对部分内容做了修改。）
---
via: <https://itsfoss.com/ubuntu-18-04-faq/>
作者：[Abhishek Prakash](http://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wyxplus](https://github.com/wyxplus) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
微服务 vs. 整体服务：如何选择
|
Jakelumetta
|
https://opensource.com/article/18/1/how-choose-between-monolith-microservices
|
任何一种架构都是有利有弊的，而能满足你组织的独特需要的决策才是正确的选择。
|
/data/attachment/album/201805/30/055802hiuhbwgl09093gu6.jpg.thumb.jpg
|
/data/attachment/album/201805/30/055802hiuhbwgl09093gu6.jpg
| true | false | true |
qhwdw
| false |
[
"架构",
"微服务"
] |
观点
|
{
"viewnum": 6861,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
任何一种架构都是有利有弊的，而能满足你组织的独特需要的决策才是正确的选择。
| 2018-05-30T05:58:08 | 2018-05-30T05:58:08 | 9,695 |
/article-9695-1.html
|
>
> 任何一种架构都是有利有弊的，而能满足你组织的独特需要的决策才是正确的选择。
>
>
>
对于许多初创公司来说，传统的知识认为，从单一整体架构开始，而不是使用微服务。但是，我们还有别的选择吗？
这本新书 —— 《[初创公司的微服务](https://buttercms.com/books/microservices-for-startups/)》，从许多 CIO 们理解的微服务的角度，解释了微服务的优点与缺点。
对于初创公司，虽然不同的 CTO 对此给出的建议是不同的，但是他们都一致认为环境和性能很重要。如果你正考虑你的业务到底是采用微服务还是单一整体架构更好，下面讨论的这些因素正好可以为你提供一些参考。
### 理解范围
首先，我们先来准确定义我们所谓的 “整体服务” 和 “微服务” 是什么。
微服务是一种方法，它开发一个单一的应用程序来作为构成整体服务的小服务，每个小服务都运行在它自己的进程中，并且使用一个轻量级的机制进行通讯，通常是一个 HTTP 资源的 API。这些服务都围绕业务能力来构建，并且可依赖全自动部署机制来独立部署。
一个整体应用程序是按单个的、统一的单元来构建，并且，通常情况下它是基于一个大量的代码来实现的。一般来说，一个整体服务是由三部分组成的：数据库、客户端用户界面（由 HTML 页面和/或运行在浏览器中的 JavaScript 组成）、以及服务器端应用程序。
“系统架构处于一个范围之中”，Zachary Crockett，[Particle](https://www.particle.io/Particle) 的 CTO，在一次访谈中，他说，“在讨论微服务时，人们倾向于关注这个范围的一端：许多极小的应用程序给其它应用程序传递了过多的信息。在另一端，有一个巨大的整体服务做了太多的事情。在任何现实中的系统上，在这两个极端之间有很多合适的面向服务的架构”。
根据你的情况不同，不论是使用整体服务还是微服务都有很多很好的理由。
“我们希望为每个服务使用最好的工具”，Julien Lemoine 说，他是 Algolia 的 CTO。
与很多人的想法正好相反，整体服务并不是过去遗留下来的过时的架构。在某些情况下，整体服务是非常理想的。我采访了 Steven Czerwinski 之后，更好地理解了这一点，他是 [Scaylr](https://www.scalyr.com/) 的工程主管，前谷歌员工。
“尽管我们在谷歌时有使用微服务的一些好的经验，我们现在 [在 Scalyr] 却使用的是整体服务的架构，因为一个整体服务架构意味着我们的工作量更少，我们只有两位工程师。“ 他解释说。（采访他时，Scaylr 正处于早期阶段）
但是，如果你的团队使用微服务的经验很丰富，并且你对你们的发展方向有明确的想法，微服务可能是一个很好的替代者。
Julien Lemoine，[Algolia](https://www.algolia.com/) 的 CTO，在这个问题上，他认为：“我们通常从使用微服务开始，主要目的是我们可以使用不同的技术来构建我们的服务，因为如下的两个主要原因：
* 我们想为每个服务使用最好的工具。我们的搜索 API 是在底层做过高度优化的，而 C++ 是非常适合这项工作的。他说，在任何其它地方都使用 C++ 是一种生产力的浪费，尤其是在构建仪表板方面。
* 我们希望使用最好的人才，而只使用一种技术将极大地限制我们的选择。这就是为什么在公司中有不同语言的原因。
”
如果你的团队已经准备好从一开始就使用微服务，这样你的组织从一开始就可以适应微服务环境的开发节奏。
### 权衡利弊
在你决定那种方法更适合你的组织之前，考虑清楚每种方法的优缺点是非常重要的。
### 整体服务
#### 优点：
* **很少担心横向联系：** 大多数应用程序开发者都担心横向联系，比如，日志、速度限制、以及像审计跟踪和 DoS 防护这样的安全特性。当所有的东西都运行在同一个应用程序中时，通过组件钩子来处理这些关注点就非常容易了。
* **运营开销很少：** 只需要为一个应用程序设置日志、监视、以及测试。一般情况下，部署也相对要简单。
* **性能：** 一个整体的架构可能会有更好的性能，因为共享内存的访问速度要比进程间通讯（IPC）更快。
#### 缺点：
* **紧耦合：** 整体服务的应用程序倾向于紧耦合，并且应用程序是整体进化的，分离特定用途的服务是非常困难的，比如，独立扩展或者代码维护。
* **理解起来很困难：** 当你想查看一个特定的服务或者控制器时，因为依赖、副作用、和其它的不可预见因素，整体架构理解起来更困难。
### 微服务
#### 优点：
* **非常好组织：** 微服务架构一般很好组织它们，因为每个微服务都有一个特定的工作，并且还不用考虑其它组件的工作。
* **解耦合：** 解耦合的服务是能够非常容易地进行重组织和重配置，以服务于不同的应用程序（比如，同时向 Web 客户端和公共 API 提供服务）。它们在一个大的集成系统中，也允许快速、独立分发单个部分。
* **性能：** 根据组织的情况，微服务可以提供更好的性能，因为你可以分离热点服务，并根据其余应用程序的情况来扩展它们。
* **更少的错误：** 微服务允许系统中的不同部分，在维护良好边界的前提下进行并行开发。这样将使连接不该被连接的部分变得更困难，比如，需要连接的那些紧耦合部分。
#### 缺点：
* **跨每个服务的横向联系点：** 由于你构建了一个新的微服务架构，你可能会发现在设计时没有预料到的很多横向联系的问题。这也将导致需要每个横向联系点的独立模块（比如，测试）的开销增加，或者在其它服务层面因封装横向联系点，所导致的所有流量都需要路由。最终，即便是整体服务架构也倾向于通过横向联系点的外部服务层来路由流量，但是，如果使用整体架构，在项目更加成熟之前，也不过只是推迟了工作成本。
* **更高的运营开销：** 微服务在它所属的虚拟机或容器上部署非常频繁，导致虚拟机争用激增。这些任务都是使用容器管理工具进行频繁的自动化部署的。
### 决策时刻
当你了解了每种方法的利弊之后，如何在你的初创公司使用这些信息？通过与这些 CTO 们的访谈，这里有三个问题可以指导你的决策过程：
**你是在熟悉的领域吗？**
如果你的团队有以前的一些领域的经验（比如，电子商务）和了解你的客户需求，那么分割成微服务是低风险的。如果你从未做过这些，从另一个角度说，整体服务或许是一个更安全的选择。
**你的团队做好准备了吗？**
你的团队有使用微服务的经验吗？如果明年，你的团队扩充到现在的四倍，将为微服务提供更好的环境？评估团队大小对项目的成功是非常重要的。
**你的基础设施怎么样？**
实施微服务，你需要基于云的基础设施。
David Strauss，[Pantheon](https://pantheon.io/) 的 CTO，他解释说："[以前]，你使用整体服务是因为，你希望部署在一个数据库上。每个单个的微服务都需要配置数据库服务器，然后，扩展它将是一个很重大的任务。只有大的、技术力量雄厚的组织才能做到。现在，使用像谷歌云和亚马逊 AWS 这样的云服务，为部署一个小的东西而不需要为它们中的每个都提供持久存储，对于这种需求你有很多的选择。“
### 评估业务风险
技术力量雄厚的初创公司为追求较高的目标，可以考虑使用微服务。但是微服务可能会带来业务风险。Strauss 解释说，“许多团队一开始就过度构建他们的项目。每个人都认为，他们的公司会成为下一个 ‘独角兽’，因此，他们使用微服务构建任何一个东西，或者一些其它的高扩展性的基础设施。但是这通常是一种错误的做法”。Strauss 说，在那种情况下，他们认为需要扩大规模的领域往往并不是一开始真正需要扩展的领域，最后的结果是浪费了时间和努力。
### 态势感知
最终，环境是关键。以下是一些来自 CTO 们的提示：
#### 什么时候使用整体服务
* **你的团队还在创建阶段：** 你的团队很小 —— 也就是说，有 2 到 5 位成员 —— 还无法应对大范围、高成本的微服务架构。
* **你正在构建的是一个未经证实的产品或者概念验证：** 如果你将一个全新的产品推向市场，随着时间的推移，它有可能会成功，而对于一个快速迭代的产品，整体架构是最合适的。这个提示也同样适用于概念验证，你的目标是尽可能快地学习，即便最终你可能会放弃它。
* **你没有使用微服务的经验：** 除非你有合理的理由证明早期学习阶段的风险可控，否则，一个整体的架构更适用于一个没有经验的团队。
#### 什么时候开始使用微服务
* **你需要快速、独立的分发服务：** 微服务允许在一个大的集成系统中快速、独立分发单个部分。请注意，根据你的团队规模，获取与整体服务的比较优势，可能需要一些时间。
* **你的平台中的某些部分需要更高效：** 如果你的业务要求集中处理 PB 级别的日志卷，你可能需要使用一个像 C++ 这样的更高效的语言来构建这个服务，尽管你的用户仪表板或许还是用 [Ruby on Rails](http://rubyonrails.org/) 构建的。
* **计划扩展你的团队：** 使用微服务，将让你的团队从一开始就开发独立的小服务，而服务边界独立的团队更易于按需扩展。
要决定整体服务还是微服务更适合你的组织，要坦诚并正确认识自己的环境和能力。这将有助于你找到业务成长的最佳路径。
### 关于作者
jakelumetta - Jake 是 ButterCMS 的 CEO，它是一个 [API-first CMS](https://buttercms.com/)。他喜欢搅动出黄油双峰，以及构建让开发者工作更舒适的工具，喜欢他的更多内容，请在 Twitter 上关注 [@ButterCMS](https://twitter.com/ButterCMS)，订阅 [他的博客](https://buttercms.com/blog/)。[关于他的更多信息](https://opensource.com/users/jakelumetta)……
---
via: <https://opensource.com/article/18/1/how-choose-between-monolith-microservices>
作者：[jakelumetta](https://opensource.com/users/jakelumetta) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在无响应的 Linux 系统中杀掉内存消耗最大的进程
|
Aditya Goturu
|
https://www.ostechnix.com/kill-largest-process-unresponsive-linux-system/
|
Early OOM 每秒会检测可用内存和空余交换区 10 次，一旦两者都低于 10%，它就会把最大的进程杀死。
|
/data/attachment/album/201805/31/092105lkgrxeb8ytxxat8r.png.thumb.jpg
|
/data/attachment/album/201805/31/092105lkgrxeb8ytxxat8r.png
| true | false | true |
cizezsy
| false |
[
"进程",
"内存",
"OOM"
] |
技术
|
{
"viewnum": 10017,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Early OOM 每秒会检测可用内存和空余交换区 10 次，一旦两者都低于 10%，它就会把最大的进程杀死。
| 2018-05-31T09:21:00 | 2018-05-31T09:21:00 | 9,696 |
/article-9696-1.html
|
作为一名博客作者，我收藏了很多博客、网站和论坛用来寻找 Linux 和 Unix 相关的内容。有时候，我在浏览器中开启了非常多的标签页，导致操作系统会无响应好几分钟。我不能移动我的鼠标，也不能杀掉一个进程或关闭任何开启的标签页。在这种情况下，我别无选择，只能强制重启系统。当然我也用了 **OneTab** （LCTT 译注：OneTab 是一个 Chrome 的 Extension，可以将标签页转化成一个列表保存。）和 **Greate Suspender** （LCTT 译注：Great Suspender 是一个 Chrome 的 Extension， 可以自动冻结标签页）这样浏览器拓展，但它们在这里也起不到太大的作用。 我经常耗尽我的内存。而这就是 **Early OOM** 起作用的时候了。在情况严重时，它会杀掉一个未响应系统中的内存消耗最大的进程。Early OOM 每秒会检测可用内存和空余交换区 10 次，一旦两者都低于 10%，它就会把最大的进程杀死。
### 为什么用 Early OOM？为什么不用系统内置的 OOM killer？
在继续讨论下去之前，我想先简短的介绍下 OOM killer，也就是 **O**ut **O**f **M**emory killer。OOM killer 是一个由内核在可用内存非常低的时候使用的进程。它的主要任务是不断的杀死进程，直到释放出足够的内存，使内核正在运行的其它进程能顺利运行。OOM killer 会找到系统中最不重要并且能释放出最多内存的进程，然后杀掉他们。在 `/proc` 目录下的 `pid` 目录中，我们可以看到每个进程的 `oom_score`。
示例：
```
$ cat /proc/10299/oom_score
1
```
一个进程的 `oom_score` 的值越高，这个进程越有可能在系统内存耗尽的时候被 OOM killer 杀死。
Early OOM 的开发者表示，相对于内置的 OOM killer，Early OOM 有一个很大的优点。就像我之前说的那样，OOM killer 会杀掉 `oom_score` 最高的进程，而这也导致 Chrome 浏览器总是会成为第一个被杀死的进程。为了避免这种情况发生，Early OOM 使用 `/proc/*/status` 而不是 `echo f > /proc/sysrq-trigger`（LCTT 译注：这条命令会调用 OOM killer 杀死进程）。开发者还表示，手动触发 OOM killer 在最新版本的 Linux 内核中很可能不会起作用。
### 安装 Early OOM
Early OOM 在 AUR（Arch User Repository）中可以找到，所以你可以在 Arch 和它的衍生版本中使用任何 AUR 工具安装它。
使用 [Pacaur](https://www.ostechnix.com/install-pacaur-arch-linux/)：
```
pacaur -S earlyoom
```
使用 [Packer](https://www.ostechnix.com/install-packer-arch-linux-2/)：
```
packer -S earlyoom
```
使用 [Yaourt](https://www.ostechnix.com/install-yaourt-arch-linux/)：
```
yaourt -S earlyoom
```
启用并启动 Early OOM 守护进程：
```
sudo systemctl enable earlyoom
sudo systemctl start earlyoom
```
在其它的 Linux 发行版中，可以按如下方法编译安装它：
```
git clone https://github.com/rfjakob/earlyoom.git
cd earlyoom
make
sudo make install
```
### Early OOM - 杀掉无响应 Linux 系统中的最大的进程
运行如下命令启动 Early OOM：
```
earlyoom
```
如果是通过编译源代码安装的， 运行如下命令启动 Early OOM：
```
./earlyoom
```
示例输出：
```
earlyoom 0.12
mem total: 3863 MiB, min: 386 MiB (10 %)
swap total: 2047 MiB, min: 204 MiB (10 %)
mem avail: 1770 MiB (45 %), swap free: 2047 MiB (99 %)
mem avail: 1773 MiB (45 %), swap free: 2047 MiB (99 %)
mem avail: 1772 MiB (45 %), swap free: 2047 MiB (99 %)
mem avail: 1773 MiB (45 %), swap free: 2047 MiB (99 %)
mem avail: 1772 MiB (45 %), swap free: 2047 MiB (99 %)
mem avail: 1773 MiB (45 %), swap free: 2047 MiB (99 %)
mem avail: 1771 MiB (45 %), swap free: 2047 MiB (99 %)
mem avail: 1773 MiB (45 %), swap free: 2047 MiB (99 %)
mem avail: 1784 MiB (46 %), swap free: 2047 MiB (99 %)
[...]
```
就像你在上面的输出中可以看到的，Early OOM 将会显示你有多少内存和交换区，以及有多少可用的内存和交换区。记住它会一直保持运行，直到你按下 `CTRL+C`。
如果可用的内存和交换区大小都低于 10%，Early OOM 将会自动杀死最大的进程，直到系统有足够的内存可以流畅的运行。你也可以根据你的需求配置最小百分比值。
设置最小的可用内存百分比，运行：
```
earlyoom -m <PERCENT_HERE>
```
设置最小可用交换区百分比, 运行：
```
earlyoom -s <PERCENT_HERE>
```
在帮助部分，可以看到更多详细信息：
```
$ earlyoom -h
earlyoom 0.12
Usage: earlyoom [OPTION]...
-m PERCENT set available memory minimum to PERCENT of total (default 10 %)
-s PERCENT set free swap minimum to PERCENT of total (default 10 %)
-M SIZE set available memory minimum to SIZE KiB
-S SIZE set free swap minimum to SIZE KiB
-k use kernel oom killer instead of own user-space implementation
-i user-space oom killer should ignore positive oom_score_adj values
-d enable debugging messages
-v print version information and exit
-r INTERVAL memory report interval in seconds (default 1), set to 0 to
disable completely
-p set niceness of earlyoom to -20 and oom_score_adj to -1000
-h this help text
```
现在，你再也不用担心内存消耗最高的进程了。希望这能给你帮助。更多的好内容将会到来，敬请期待。
谢谢！
---
via: <https://www.ostechnix.com/kill-largest-process-unresponsive-linux-system/>
作者：[Aditya Goturu](https://www.ostechnix.com) 译者：[cizezsy](https://github.com/cizezsy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
/dev/[u]random：对熵的解释
|
James J
|
http://jhurani.com/linux/2017/11/01/entropy-explained.html
|
当谈到 /dev/random 和 /dev/urandom 的主题时，你总是会听到这个词：“熵（Entropy）”。
|
/data/attachment/album/201805/31/100548t7ueq7ssu8ss78pp.jpg.thumb.jpg
|
/data/attachment/album/201805/31/100548t7ueq7ssu8ss78pp.jpg
| true | false | true |
geekpi
| false |
[
"随机数"
] |
技术
|
{
"viewnum": 7634,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9478,
"displayorder": 0
},
{
"raid": 10816,
"displayorder": 0
}
] |
当谈到 /dev/random 和 /dev/urandom 的主题时，你总是会听到这个词：“熵（Entropy）”。
| 2018-05-31T10:05:00 | 2018-05-31T10:05:00 | 9,697 |
/article-9697-1.html
|
### 熵
当谈到 `/dev/random` 和 `/dev/urandom` 的主题时，你总是会听到这个词：“<ruby> 熵 <rt> Entropy </rt></ruby>”。每个人对此似乎都有自己的比喻。那为我呢？我喜欢将熵视为“随机果汁”。它是果汁，随机数需要它变得更随机。
如果你曾经生成过 SSL 证书或 GPG 密钥，那么可能已经看到过像下面这样的内容：
```
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
++++++++++..+++++.+++++++++++++++.++++++++++...+++++++++++++++...++++++
+++++++++++++++++++++++++++++.+++++..+++++.+++++.+++++++++++++++++++++++++>.
++++++++++>+++++...........................................................+++++
Not enough random bytes available. Please do some other work to give
the OS a chance to collect more entropy! (Need 290 more bytes)
```
通过在键盘上打字并移动鼠标，你可以帮助生成熵或随机果汁。
你可能会问自己……为什么我需要熵？以及为什么它对于随机数真的变得随机如此重要？那么，假设我们的熵的来源仅限于键盘、鼠标和磁盘 IO 的数据。但是我们的系统是一个服务器，所以我知道没有鼠标和键盘输入。这意味着唯一的因素是你的 IO。如果它是一个单独的、几乎不使用的磁盘，你将拥有较低的熵。这意味着你的系统随机的能力很弱。换句话说，我可以玩概率游戏，并大幅减少破解 ssh 密钥或者解密你认为是加密会话的时间。
好的，但这是很难实现的对吧？不，实际上并非如此。看看这个 [Debian OpenSSH 漏洞](http://jhurani.com/linux/2017/11/01/%22https://jblevins.org/log/ssh-vulnkey%22)。这个特定的问题是由于某人删除了一些负责添加熵的代码引起的。有传言说，他们因为它导致 valgrind 发出警告而删除了它。然而，在这样做的时候，随机数现在少了很多随机性。事实上，熵少了很多，因此暴力破解变成了一个可行的攻击向量。
希望到现在为止，我们理解了熵对安全性的重要性。无论你是否意识到你正在使用它。
### /dev/random 和 /dev/urandom
`/dev/urandom` 是一个伪随机数生成器，缺乏熵它也**不会**停止。
`/dev/random` 是一个真随机数生成器，它会在缺乏熵的时候停止。
大多数情况下，如果我们正在处理实际的事情，并且它不包含你的核心信息，那么 `/dev/urandom` 是正确的选择。否则，如果就使用 `/dev/random`，那么当系统的熵耗尽时，你的程序就会变得有趣。无论它直接失败，或只是挂起——直到它获得足够的熵，这取决于你编写的程序。
### 检查熵
那么，你有多少熵？
```
[root@testbox test]# cat /proc/sys/kernel/random/poolsize
4096
[root@testbox test]# cat /proc/sys/kernel/random/entropy_avail
2975
```
`/proc/sys/kernel/random/poolsize`，说明熵池的大小（以位为单位）。例如：在停止抽水之前我们应该储存多少随机果汁。`/proc/sys/kernel/random/entropy_avail` 是当前池中随机果汁的数量（以位为单位）。
### 我们如何影响这个数字？
这个数字可以像我们使用它一样耗尽。我可以想出的最简单的例子是将 `/dev/random` 定向到 `/dev/null` 中：
```
[root@testbox test]# cat /dev/random > /dev/null &
[1] 19058
[root@testbox test]# cat /proc/sys/kernel/random/entropy_avail
0
[root@testbox test]# cat /proc/sys/kernel/random/entropy_avail
1
```
影响这个最简单的方法是运行 [Haveged](http://www.issihosts.com/haveged/)。Haveged 是一个守护进程，它使用处理器的“抖动”将熵添加到系统熵池中。安装和基本设置非常简单。
```
[root@b08s02ur ~]# systemctl enable haveged
Created symlink from /etc/systemd/system/multi-user.target.wants/haveged.service to /usr/lib/systemd/system/haveged.service.
[root@b08s02ur ~]# systemctl start haveged
```
在流量相对中等的机器上：
```
[root@testbox ~]# pv /dev/random > /dev/null
40 B 0:00:15 [ 0 B/s] [ <=> ]
52 B 0:00:23 [ 0 B/s] [ <=> ]
58 B 0:00:25 [5.92 B/s] [ <=> ]
64 B 0:00:30 [6.03 B/s] [ <=> ]
^C
[root@testbox ~]# systemctl start haveged
[root@testbox ~]# pv /dev/random > /dev/null
7.12MiB 0:00:05 [1.43MiB/s] [ <=> ]
15.7MiB 0:00:11 [1.44MiB/s] [ <=> ]
27.2MiB 0:00:19 [1.46MiB/s] [ <=> ]
43MiB 0:00:30 [1.47MiB/s] [ <=> ]
^C
```
使用 `pv` 我们可以看到我们通过管道传递了多少数据。正如你所看到的，在运行 `haveged` 之前，我们是 2.1 位/秒（B/s）。而在开始运行 `haveged` 之后，加入处理器的抖动到我们的熵池中，我们得到大约 1.5MiB/秒。
---
via: <http://jhurani.com/linux/2017/11/01/entropy-explained.html>
作者：[James J](https://jblevins.org/log/ssh-vulnkey) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
4 个现在就该去装的 Firefox 扩展
|
Jeremy Garcia
|
https://opensource.com/article/18/5/firefox-extensions
|
合适的扩展能极大地增强你的浏览器功能，但是仔细的选择也是很重要的。
|
/data/attachment/album/201805/31/103037e6tq4oqog7tt74g1.jpg.thumb.jpg
|
/data/attachment/album/201805/31/103037e6tq4oqog7tt74g1.jpg
| true | false | true |
MjSeven
| false |
[
"Firefox",
"扩展",
"浏览器"
] |
分享
|
{
"viewnum": 9946,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
合适的扩展能极大地增强你的浏览器功能，但是仔细的选择也是很重要的。
| 2018-05-31T10:30:44 | 2018-05-31T10:30:44 | 9,698 |
/article-9698-1.html
|
>
> 合适的扩展能极大地增强你的浏览器功能，但是仔细的选择也是很重要的。
>
>
>
正如我在关于 Firefox 扩展的[原创文章](https://opensource.com/article/18/1/top-5-firefox-extensions)中提到的，web 浏览器已成为许多用户计算机体验的关键组件。现代浏览器已经发展成为功能强大且可扩展的平台，扩展可以添加或修改其功能。Firefox 的扩展是使用 WebExtensions API（一种跨浏览器开发系统）构建的。
在第一篇文章中，我问读者：“你应该安装哪些扩展？” 重申一下，这一决定主要取决于你如何使用浏览器，你对隐私的看法，你对扩展程序开发人员的信任程度以及其他个人偏好。自文章发表以来，我推荐的一个扩展（Xmarks）已经停止维护。另外，该文章收到了大量的反馈，在这篇更新中，这些反馈已经被考虑到。
我想再次指出，浏览器扩展通常需要能够阅读和（或）更改你访问的网页上的所有内容。你应该仔细考虑这一点。如果扩展程序修改了你访问的所有网页的访问权限，那么它可能成为键盘记录程序、拦截信用卡信息、在线跟踪、插入广告以及执行各种其他恶意活动。这并不意味着每个扩展程序都会暗中执行这些操作，但在安装任何扩展程序之前，你应该仔细考虑安装源，涉及的权限，风险配置文件以及其他因素。请记住，你可以使用配置文件来管理扩展如何影响你的攻击面 —— 例如，使用没有扩展的专用配置文件来执行网上银行等任务。
考虑到这一点，这里有你可能想要考虑的四个开源 Firefox 扩展。
### uBlock Origin
我的第一个建议保持不变。[uBlock Origin](https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/) 是一款快速、低内存消耗、广泛的拦截器，它不仅可以拦截广告，而且还可以执行你自己的内容过滤。 uBlock Origin 的默认行为是使用多个预定义的过滤器列表来拦截广告、跟踪器和恶意软件站点。它允许你任意添加列表和规则，甚至可以锁定到默认拒绝模式。尽管它很强大，但它已被证明是高效和高性能的。它将继续定期更新，并且是该功能的最佳选择之一。
### Privacy Badger
我的第二个建议也保持不变。如果说有什么区别的话，那就是自从我上一篇文章发表以来，隐私问题更被关注了，这使得这个扩展成为一个简单的建议。顾名思义，[Privacy Badger](https://www.eff.org/privacybadger) 是一个专注于隐私的扩展，可以拦截广告和其他第三方跟踪器。这是电子前哨基金会基金会（EFF）的一个项目，他们说：
>
> Privacy Badger 的诞生是我们希望能够推荐一个单独的扩展，它可以自动分析和拦截任何违反用户同意原则的追踪器或广告；在用户没有任何设置、有关知识或配置的情况下，它可以很好地运行；它是由一个明确为其用户而不是为广告商工作的组织所产生的；它使用了算法的方法来决定什么被跟踪，什么没有被跟踪。”
>
>
>
为什么 Privacy Badger 会出现在这个列表上，它的功能与上一个扩展看起来很类似？因为一些原因：首先，它从根本上工作原理与 uBlock Origin 不同。其次，深度防御的实践是一项合理的策略。说到深度防御，EFF 还维护着 [HTTPS Everywhere](https://www.eff.org/https-everywhere) 扩展，它自动确保 https 用于许多主流网站。当你安装 Privacy Badger 时，你也可以考虑使用 HTTPS Everywhere。
如果你开始认为这篇文章只是对上一篇文章的重新讨论，那么以下是我的建议分歧。
### Bitwarden
在上一篇文章中推荐 LastPass 时，我提到这可能是一个有争议的选择。这无疑属实。无论你是否应该使用密码管理器 —— 如果你使用，那么是否应该选择带有浏览器插件的密码管理器 —— 这是一个备受争议的话题，答案很大程度上取决于你的个人风险状况。我认为大多数普通的计算机用户应该使用一个，因为它比最常见的选择要好得多：在任何地方都使用相同的弱密码！我仍然相信这一点。
[Bitwarden](https://bitwarden.com/) 自从我上次点评以后确实更成熟了。像 LastPass 一样，它对用户友好，支持双因素身份验证，并且相当安全。与 LastPass 不同的是，它是[开源的](https://github.com/bitwarden)。它可以使用或不使用浏览器插件，并支持从其他解决方案（包括 LastPass）导入。它的核心功能完全免费，它还有一个 10 美元/年的高级版本。
### Vimium-FF
[Vimium](https://addons.mozilla.org/en-US/firefox/addon/vimium-ff/) 是另一个开源的扩展，它为 Firefox 键盘快捷键提供了类似 Vim 一样的导航和控制，其称之为“黑客的浏览器”。对于 `Ctrl+x`、 `Meta+x` 和 `Alt+x`，分别对应 `<c-x>`、`<m-x>` 和 `<a-x>`，默认值可以轻松定制。一旦你安装了 Vimium，你可以随时键入 `?` 来查看键盘绑定列表。请注意，如果你更喜欢 Emacs，那么也有一些针对这些键绑定的扩展。无论哪种方式，我认为键盘快捷键是未充分利用的生产力推动力。
### 额外福利: Grammarly
不是每个人都有幸在 Opensource.com 上撰写专栏 —— 尽管你应该认真考虑为这个网站撰写文章；如果你有问题，有兴趣，或者想要一个导师，伸出手，让我们聊聊吧。但是，即使没有专栏撰写，正确的语法在各种各样的情况下都是有益的。试一下 [Grammarly](https://www.grammarly.com/)。不幸的是，这个扩展不是开源的，但它确实可以确保你输入的所有东西都是清晰的 、有效的并且没有错误。它通过扫描你文本中的常见的和复杂的语法错误来实现这一点，涵盖了从主谓一致到文章使用，到修饰词的放置这些所有内容。它的基本功能是免费的，它有一个高级版本，每月收取额外的费用。我在这篇文章中使用了它，它发现了许多我的校对没有发现的错误。
再次说明，Grammarly 是这个列表中包含的唯一不是开源的扩展，因此如果你知道类似的高质量开源替代品，请在评论中告诉我们。
这些扩展是我发现有用并推荐给其他人的扩展。请在评论中告诉我你对更新建议的看法。
---
via: <https://opensource.com/article/18/5/firefox-extensions>
作者：[Jeremy Garcia](https://opensource.com/users/jeremy-garcia) 选题：[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/) 荣誉推出
|
||
编写有趣且有价值的 Systemd 服务
|
Paul Brown
|
https://www.linux.com/blog/learn/intro-to-linux/2018/5/writing-systemd-services-fun-and-profit
|
每次开机之后需要启动服务器，每次关机之前需要安全地关闭服务进程，十分繁琐和麻烦。
|
/data/attachment/album/201805/31/231539hsg1ybtwt09sb430.png.thumb.jpg
|
/data/attachment/album/201805/31/231539hsg1ybtwt09sb430.png
| true | false | true |
pinewall
| false |
[
"systemd"
] |
技术
|
{
"viewnum": 6683,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9703,
"displayorder": 0
},
{
"raid": 10182,
"displayorder": 0
}
] |
每次开机之后需要启动服务器，每次关机之前需要安全地关闭服务进程，十分繁琐和麻烦。
| 2018-05-31T23:15:35 | 2018-05-31T23:15:35 | 9,700 |
/article-9700-1.html
|
让我们假设你希望搭建一个游戏服务器，运行 [Minetest](https://www.minetest.net/) 这款非常酷、开源的，以采集 & 合成为主题的沙盒游戏。你希望将游戏运行在位于客厅的服务器中，以便搭建完成后可供你的学校或朋友使用。你知道内核邮件列表的管理就不过就是如此，那么对你来说也是足够的。
但你很快发现每次开机之后需要启动服务进程，每次关机之前需要安全地关闭服务器，十分繁琐和麻烦。
最初，你可能用守护进程的方式运行服务器：
```
minetest --server &
```
记住进程 PID 以便后续使用。
接着，你还需要通过邮件或短信的方式将服务器已经启动的信息告知你的朋友。然后你就可以开始游戏了。
转眼之间，已经凌晨三点，今天的战斗即将告一段落。但在你关闭主机、睡个好觉之前，还需要做一些操作。首先，你需要通知其它玩家服务器即将关闭，找到记录我们之前提到的 PID 的纸条，然后友好地关闭 Minetest 服务进程。
```
kill -2 <PID>
```
这是因为直接关闭主机电源很可能导致文件损坏。下一步也是最后一步，关闭主机电源。
一定有方法能让事情变得更简单。
### 让 Systemd 服务拯救你
让我们从构建一个普通用户可以（手动）运行的 systemd 服务开始，然后再逐步增加内容。
不需要管理员权限即可运行的服务位于 `~/.config/systemd/user/`，故首先需要创建这个目录：
```
cd
mkdir -p ~/.config/systemd/user/
```
有很多类型的 systemd 单元 (曾经叫做 systemd 脚本)，包括“计时器”和“路径”等，但我们这里关注的是“服务”类型。在 `~/.config/systemd/user/` 目录中创建 `minetest.service` 文件，使用文本编辑器打开并输入如下内容：
```
# minetest.service
[Unit]
Description= Minetest server
Documentation= https://wiki.minetest.net/Main_Page
[Service]
Type= simple
ExecStart= /usr/games/minetest --server
```
可以看到该单元中包含不同的段，其中 `[Unit]` 段主要为用户提供信息，给出该单元的描述及如何获得更多相关文档。
脚本核心位于 `[Service]` 段，首先使用 `Type` 指令确定服务类型。服务[有多种类型](http://man7.org/linux/man-pages/man5/systemd.service.5.html)，下面给出两个示例。如果你运行的进程设置环境变量、调用另外一个进程（主进程）、退出运行，那么你应该使用的服务类型为 `forking`。如果你希望在你的单元对应进程结束运行前阻断其他单元运行，那么你应该使用的服务类型为 `oneshot`。
但 Minetest 服务器的情形与上面两种都不同，你希望启动服务器并使其在后台持续运行；这种情况下应该使用 `simple` 类型。
下面来看 `ExecStart` 指令，它给出 systemd 需要运行的程序。在本例中，你希望在后台运行 `minetest` 服务器。如上所示，你可以在可执行程序后面添加参数，但不能将一系列 Bash 命令通过管道连接起来。下面给出的例子无法工作：
```
ExecStart: lsmod | grep nvidia > videodrive.txt
```
如果你需要将 Bash 命令通过管道连接起来，可以将其封装到一个脚本中，然后运行该脚本。
还需要注意一点，systemd 要求你给出程序的完整路径。故如果你想使用 `simple` 类型运行类似 `ls` 的命令，你需要使用 `ExecStart= /bin/ls`。
另外还有 `ExecStop` 指令用于定制服务终止的方式。我们会在第二部分讨论这个指令，但你要了解，如果你没有指定 `ExecStop`，systemd 会帮你尽可能友好地终止进程。
`systemd.directives` 的帮助页中包含完整指令列表，另外你可以在该[网站](http://man7.org/linux/man-pages/man7/systemd.directives.7.html)上找到同样的列表，点击即可查看每个指令的具体信息。
虽然只有 6 行，但你的 `minetest.service` 已经是一个有完整功能的 systemd 单元。执行如下命令启动服务：
```
systemd --user start minetest
```
执行如下命令终止服务：
```
systemd --user stop minetest
```
选项 `--user` 告知 systemd 在你的本地目录中检索服务并用你的用户权限执行服务。
我们的服务器管理故事到此完成了第一部分。在第二部分，我们将在启动和终止服务的基础上，学习如何给用户发邮件、告知用户服务器的可用性。敬请期待。
可以通过 Linux 基金会和 edX 的免费课程 “[Linux 入门](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)”学习更多 Linux 知识。
---
via: <https://www.linux.com/blog/learn/intro-to-linux/2018/5/writing-systemd-services-fun-and-profit>
作者：[Paul Brown](https://www.linux.com/users/bro66) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 中如何归档文件和目录
|
Sk
|
https://www.ostechnix.com/how-to-archive-files-and-directories-in-linux-part-1/
|
在本教程中，我们将学习如何在 Linux 归档文件。归档和压缩有什么不同吗？你们中的一些人可能经常认为这些术语有相同的含义。
|
/data/attachment/album/201806/01/100218qf1bmyu9bv4mlyzx.png.thumb.jpg
|
/data/attachment/album/201806/01/100218qf1bmyu9bv4mlyzx.png
| true | false | true |
MjSeven
| false |
[
"tar",
"归档"
] |
技术
|
{
"viewnum": 11020,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本教程中，我们将学习如何在 Linux 归档文件。归档和压缩有什么不同吗？你们中的一些人可能经常认为这些术语有相同的含义。
| 2018-06-01T10:02:16 | 2018-06-01T10:02:16 | 9,701 |
/article-9701-1.html
|
在我们之前的教程中，我们讨论了如何[使用 gzip 和 bzip2 压缩和解压缩文件](https://www.ostechnix.com/how-to-compress-and-decompress-files-in-linux/)。在本教程中，我们将学习如何在 Linux 归档文件。归档和压缩有什么不同吗？你们中的一些人可能经常认为这些术语有相同的含义。但是，这两者完全不同。归档是将多个文件和目录（相同或不同大小）组合成一个文件的过程。另一方面，压缩是减小文件或目录大小的过程。归档通常用作系统备份的一部分，或者将数据从一个系统移至另一个系统时。希望你了解归档和压缩之间的区别。现在，让我们进入主题。
### 归档文件和目录
归档文件和目录最常见的程序是：
1. tar
2. zip
这是一个很大的话题，所以，我将分两部分发表这篇文章。在第一部分中，我们将看到如何使用 tar 命令来归档文件和目录。
### 使用 tar 命令归档文件和目录
**Tar** 是一个 Unix 命令，代表 **T**ape **A**rchive（磁带归档）。它用于将多个文件（相同或不同大小）组合或存储到一个文件中。在 tar 实用程序中有 4 种主要的操作模式。
1. `c` – 从文件或目录中建立归档
2. `x` – 提取归档
3. `r` – 将文件追加到归档
4. `t` – 列出归档的内容
有关完整的模式列表，参阅 man 手册页。
#### 创建一个新的归档
为了本指南，我将使用名为 `ostechnix` 的文件夹，其中包含三种不同类型的文件。
```
$ ls ostechnix/
file.odt image.png song.mp3
```
现在，让我们为 `ostechnix` 目录创建一个新的 tar 归档。
```
$ tar cf ostechnix.tar ostechnix/
```
这里，`c` 标志指的是创建新的归档，`f` 是指定归档文件。
同样，对当前工作目录中的一组文件创建归档文件，使用以下命令：
```
$ tar cf archive.tar file1 file2 file 3
```
#### 提取归档
要在当前目录中提取归档文件，只需执行以下操作：
```
$ tar xf ostechnix.tar
```
我们还可以使用 `C` 标志（大写字母 C）将归档提取到不同的目录中。例如，以下命令将归档文件提取到 `Downloads` 目录中。
```
$ tar xf ostechnix.tar -C Downloads/
```
或者，转到 `Downloads` 文件夹并像下面一样提取其中的归档。
```
$ cd Downloads/
$ tar xf ../ostechnix.tar
```
有时，你可能想要提取特定类型的文件。例如，以下命令提取 “.png” 类型的文件。
```
$ tar xf ostechnix.tar --wildcards "*.png"
```
#### 创建 gzip 和 bzip 格式的压缩归档
默认情况下，tar 创建归档文件以 `.tar` 结尾。另外，`tar` 命令可以与压缩实用程序 `gzip` 和 `bzip` 结合使用。文件结尾以 `.tar` 为扩展名使用普通 tar 来归档文件，文件以 `tar.gz` 或 `.tgz` 结尾使用 `gzip` 归档并压缩文件，文件以 `tar.bz2` 或 `.tbz` 结尾使用 `bzip` 归档并压缩。
首先，让我们来创建一个 gzip 归档：
```
$ tar czf ostechnix.tar.gz ostechnix/
```
或者：
```
$ tar czf ostechnix.tgz ostechnix/
```
这里，我们使用 `z` 标志来使用 gzip 压缩方法压缩归档文件。
你可以使用 `v` 标志在创建归档时查看进度。
```
$ tar czvf ostechnix.tar.gz ostechnix/
ostechnix/
ostechnix/file.odt
ostechnix/image.png
ostechnix/song.mp3
```
这里，`v` 指显示进度。
从一个文件列表创建 gzip 归档文件：
```
$ tar czf archive.tgz file1 file2 file3
```
要提取当前目录中的 gzip 归档文件，使用：
```
$ tar xzf ostechnix.tgz
```
要提取到其他文件夹，使用 `-C` 标志：
```
$ tar xzf ostechnix.tgz -C Downloads/
```
现在，让我们创建 **bzip 归档**。为此，请使用下面的 `j` 标志。
创建一个目录的归档：
```
$ tar cjf ostechnix.tar.bz2 ostechnix/
```
或
```
$ tar cjf ostechnix.tbz ostechnix/
```
从一个列表文件中创建归档：
```
$ tar cjf archive.tar.bz2 file1 file2 file3
```
或
```
$ tar cjf archive.tbz file1 file2 file3
```
为了显示进度，使用 `v` 标志。
现在，在当前目录下，让我们提取一个 bzip 归档。这样做：
```
$ tar xjf ostechnix.tar.bz2
```
或者，提取归档文件到其他目录：
```
$ tar xjf ostechnix.tar.bz2 -C Downloads
```
#### 一次创建多个目录和/或文件的归档
这是 `tar` 命令的另一个最酷的功能。要一次创建多个目录或文件的 gzip 归档文件，使用以下文件：
```
$ tar czvf ostechnix.tgz Downloads/ Documents/ ostechnix/file.odt
```
上述命令创建 `Downloads`、 `Documents` 目录和 `ostechnix` 目录下的 `file.odt` 文件的归档，并将归档保存在当前工作目录中。
#### 在创建归档时跳过目录和/或文件
这在备份数据时非常有用。你可以在备份中排除不重要的文件或目录，这是 `–exclude` 选项所能帮助的。例如你想要创建 `/home` 目录的归档，但不希望包括 `Downloads`、 `Documents`、 `Pictures`、 `Music` 这些目录。
这是我们的做法：
```
$ tar czvf ostechnix.tgz /home/sk --exclude=/home/sk/Downloads --exclude=/home/sk/Documents --exclude=/home/sk/Pictures --exclude=/home/sk/Music
```
上述命令将对我的 `$HOME` 目录创建一个 gzip 归档，其中不包括 `Downloads`、`Documents`、`Pictures` 和 `Music` 目录。要创建 bzip 归档，将 `z` 替换为 `j`，并在上例中使用扩展名 `.bz2`。
#### 列出归档文件但不提取它们
要列出归档文件的内容，我们使用 `t` 标志。
```
$ tar tf ostechnix.tar
ostechnix/
ostechnix/file.odt
ostechnix/image.png
ostechnix/song.mp3
```
要查看详细输出，使用 `v` 标志。
```
$ tar tvf ostechnix.tar
drwxr-xr-x sk/users 0 2018-03-26 19:52 ostechnix/
-rw-r--r-- sk/users 9942 2018-03-24 13:49 ostechnix/file.odt
-rw-r--r-- sk/users 36013 2015-09-30 11:52 ostechnix/image.png
-rw-r--r-- sk/users 112383 2018-02-22 14:35 ostechnix/song.mp3
```
#### 追加文件到归档
文件或目录可以使用 `r` 标志添加/更新到现有的归档。看看下面的命令：
```
$ tar rf ostechnix.tar ostechnix/ sk/ example.txt
```
上面的命令会将名为 `sk` 的目录和名为 `exmple.txt` 添加到 `ostechnix.tar` 归档文件中。
你可以使用以下命令验证文件是否已添加：
```
$ tar tvf ostechnix.tar
drwxr-xr-x sk/users 0 2018-03-26 19:52 ostechnix/
-rw-r--r-- sk/users 9942 2018-03-24 13:49 ostechnix/file.odt
-rw-r--r-- sk/users 36013 2015-09-30 11:52 ostechnix/image.png
-rw-r--r-- sk/users 112383 2018-02-22 14:35 ostechnix/song.mp3
drwxr-xr-x sk/users 0 2018-03-26 19:52 sk/
-rw-r--r-- sk/users 0 2018-03-26 19:39 sk/linux.txt
-rw-r--r-- sk/users 0 2018-03-26 19:56 example.txt
```
### TL;DR
创建 tar 归档：
* **普通 tar 归档：** `tar -cf archive.tar file1 file2 file3`
* **Gzip tar 归档：** `tar -czf archive.tgz file1 file2 file3`
* **Bzip tar 归档：** `tar -cjf archive.tbz file1 file2 file3`
提取 tar 归档：
* **普通 tar 归档：** `tar -xf archive.tar`
* **Gzip tar 归档：** `tar -xzf archive.tgz`
* **Bzip tar 归档：** `tar -xjf archive.tbz`
我们只介绍了 `tar` 命令的基本用法，这些对于开始使用 `tar` 命令足够了。但是，如果你想了解更多详细信息，参阅 man 手册页。
```
$ man tar
```
好吧，这就是全部了。在下一部分中，我们将看到如何使用 Zip 实用程序来归档文件和目录。
干杯！
---
via: <https://www.ostechnix.com/how-to-archive-files-and-directories-in-linux-part-1/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[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/) 荣誉推出
|
||
Orbital Apps：新一代 Linux 程序
|
Sk
|
https://www.ostechnix.com/orbitalapps-new-generation-ubuntu-linux-applications/
|
Orbital Apps 或 ORB（Open Runnable Bundle）apps（开放可运行程序包），一个自由的、跨平台的开源程序集合
|
/data/attachment/album/201806/01/100858lobqssaekkxqepeo.jpg.thumb.jpg
|
/data/attachment/album/201806/01/100858lobqssaekkxqepeo.jpg
| true | false | true |
geekpi
| false |
[
"ORB"
] |
桌面应用
|
{
"viewnum": 5134,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Orbital Apps 或 ORB（Open Runnable Bundle）apps（开放可运行程序包），一个自由的、跨平台的开源程序集合
| 2018-06-01T10:08:55 | 2018-06-01T10:08:55 | 9,702 |
/article-9702-1.html
|
今天，我们要了解 **Orbital Apps** 或 **ORB**（**O**pen **R**unnable **B**undle）**apps**（开放可运行程序包），一个自由的、跨平台的开源程序集合。所有 ORB 程序都是可移动的。你可以将它们安装在你的 Linux 系统或 USB 驱动器上，以便你可以在任何系统上使用相同的程序。它们不需要 root 权限，并且没有依赖关系。所有必需的依赖关系都包含在程序中。只需将 ORB 程序复制到 USB 驱动器并将其插入到任何 Linux 系统中就立即开始使用它们。所有设置和配置以及程序的数据都将存储在 USB 驱动器上。由于不需要在本地驱动器上安装程序，我们可以在联机或脱机的计算机上运行应用程序。这意味着我们不需要 Internet 来下载任何依赖。
ORB 程序压缩了 60％，因此我们甚至可以从小型 USB 驱动器存储和使用它们。所有 ORB 应用程序都使用 PGP / RSA 进行签名，并通过 TLS 1.2 进行分发。所有应用程序打包时都不做任何修改，甚至不会重新编译。以下是当前可用的便携式 ORB 应用程序列表。
* abiword
* audacious
* audacity
* darktable
* deluge
* filezilla
* firefox
* gimp
* gnome-mplayer
* hexchat
* inkscape
* isomaster
* kodi
* libreoffice
* qbittorrent
* sound-juicer
* thunderbird
* tomahawk
* uget
* vlc
* 未来还有更多
Orb 是开源的，所以如果你是开发人员，欢迎协作并添加更多程序。
### 下载并使用可移动 ORB 程序
正如我已经提到的，我们不需要安装可移动 ORB 程序。但是，ORB 团队强烈建议你使用 **ORB 启动器** 来获得更好的体验。 ORB 启动器是一个小的安装程序（小于 5MB），它可帮助你启动 ORB 程序，并获得更好，更流畅的体验。
让我们先安装 ORB 启动器。为此，[下载 ORB 启动器](https://www.orbital-apps.com/documentation/orb-launcher-all-installers)。你可以手动下载 ORB 启动器的 ISO 并将其挂载到文件管理器上。或者在终端中运行以下任一命令来安装它：
```
$ wget -O - https://www.orbital-apps.com/orb.sh | bash
```
如果你没有 wget，请运行：
```
$ curl https://www.orbital-apps.com/orb.sh | bash
```
询问时输入 root 用户和密码。
就是这样。Orbit 启动器已安装并可以使用。
现在，进入 [ORB 可移动程序下载页面](https://www.orbital-apps.com/download/portable_apps_linux/)，并下载你选择的程序。在本教程中，我会下载 Firefox。
下载完后，进入下载位置并双击 ORB 程序来启动它。点击 Yes 确认。
Firefox ORB 程序能用了！
同样，你可以立即下载并运行任何程序。
如果你不想使用 ORB 启动器，请将下载的 `.orb` 安装程序设置为可执行文件，然后双击它进行安装。不过，建议使用 ORB 启动器，它可让你在使用 ORB 程序时更轻松、更顺畅。
就我测试的 ORB 程序而言，它们打开即可使用。希望这篇文章有帮助。今天就是这些。祝你有美好的一天！
干杯！！
---
via: <https://www.ostechnix.com/orbitalapps-new-generation-ubuntu-linux-applications/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[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/) 荣誉推出
|
||
Systemd 服务：比启动停止服务更进一步
|
Paul Brown
|
https://www.linux.com/blog/learn/2018/5/systemd-services-beyond-starting-and-stopping
|
让我们更进一步，让其可以向玩家发邮件，包括在服务器可用时通知玩家，在服务器关闭前警告玩家
|
/data/attachment/album/201806/02/052652hpe1dx1e7191tlx8.jpg.thumb.jpg
|
/data/attachment/album/201806/02/052652hpe1dx1e7191tlx8.jpg
| true | false | true |
pinewall
| false |
[
"systemd"
] |
技术
|
{
"viewnum": 10281,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9700,
"displayorder": 0
},
{
"raid": 10182,
"displayorder": 0
}
] |
让我们更进一步，让其可以向玩家发邮件，包括在服务器可用时通知玩家，在服务器关闭前警告玩家
| 2018-06-02T05:26:50 | 2018-06-02T05:26:50 | 9,703 |
/article-9703-1.html
|
在上一篇[文章](/article-9700-1.html)中，我们展示了如何创建一个 systemd 服务并使普通用户可以启动和终止游戏服务器。但到目前为止，使用这个服务并不比直接运行服务器高明多少。让我们更进一步，让其可以向玩家发邮件，包括在服务器可用时通知玩家，在服务器关闭前警告玩家：
```
# minetest.service
[Unit]
Description= Minetest server
Documentation= https://wiki.minetest.net/Main_Page
[Service]
Type= simple
ExecStart= /usr/games/minetest --server
ExecStartPost= /home/<username>/bin/mtsendmail.sh "Ready to rumble?" "Minetest Starting up"
TimeoutStopSec= 180
ExecStop= /home/<username>/bin/mtsendmail.sh "Off to bed. Nightie night!" "
Minetest Stopping in 2 minutes"
ExecStop= /bin/sleep 120
ExecStop= /bin/kill -2 $MAINPID
```
这里涉及几个新的指令。首先是 `ExecStartPost` 指令，该指令可以在主进程启动后马上执行任何你指定的操作。在本例中，你执行了一个自定义脚本 `mtsendmail` (内容如下)，该脚本以邮件形式通知你的朋友服务器已经启动。
```
#!/bin/bash
# mtsendmail
echo $1 | mutt -F /home/<username>/.muttrc -s "$2" my_minetest@mailing_list.com
```
我们使用 [Mutt](http://www.mutt.org/) 这个命令后邮件客户端发送消息。虽然从实际效果来看，上述脚本仅有 1 行，但 systemd 单元的参数中不能包含管道及重定向操作，故我们需要将其封装到脚本中。
顺便提一下，还有一个 `ExecStartPre` 指令，用于在服务主进程执行之前进行指定操作。
接下来我们看到，关闭服务器涉及了好几条指令。`TimeoutStopSec` 指令用于设置 systemd 友好关闭服务的最大等候时间，默认值大约是 90 秒。超过这个最大等候时间，systemd 会强制关闭服务并报错。考虑到你希望在彻底关闭服务器前给用户预留几分钟的时间，你需要将超时时间提高至 3 分钟，这样 systemd 就不会误认为服务关闭时出现问题。
接下来是关闭服务的具体指令部分。虽然没有 `ExecStopPre` 这样的指令，但你可以通过多次使用 `ExecStop` 指令实现关闭服务器前执行操作的目标。多个 `ExecStop` 指令按从上到下的顺序依次运行，这样你就可以在服务器真正关闭前向用户发送消息。
通过这个特性，你首先应该向你的朋友发邮件，警告其服务器即将关闭，然后等待两分钟，最后关闭服务器。可以使用 `Ctrl + c` 关闭 Minetest 服务器，该操作会被转换为一个中断信号（`SIGINT`）；当你执行 `kill -2 $MAINPID` 时就会发送该中断信号，其中 `$MAINPID` 是 systemd 变量，用于记录你服务中主进程的 PID 信息。
看上去好多了！如果你此时启动服务：
```
systemctl --user start minetest
```
服务会启动 Minetest 服务器并向你的用户发送邮件。关闭服务的情形基本类似，只不过会额外留给用户 2 分钟时间退出登录。
### 开机自启动
下一步我们让你的服务在主机启动后立即可用，在主机关闭时自动关闭。
我们需要将你的服务文件移动到系统服务目录，即 `/etc/systemd/system/`：
```
sudo mv /home/<username>/.config/systemd/user/minetest.service /etc/systemd/system/
```
如果你希望此时启动该服务，你需要拥有超级用户权限：
```
sudo systemctl start minetest
```
另外，可以使用如下命令检查服务状态：
```
sudo systemctl status minetest
```
你会发现服务很糟糕地处于失败状态，这是因为 systemd 不能通过上下文信息、特征、配置文件得知具体使用哪个用户运行该服务。在单元文件中增加 `User` 指令可以解决这个问题。
```
# minetest.service
[Unit]
Description= Minetest server
Documentation= https://wiki.minetest.net/Main_Page
[Service]
Type= simple
User= <username>
ExecStart= /usr/games/minetest --server
ExecStartPost= /home/<username>/bin/mtsendmail.sh "Ready to rumble?"
"Minetest Starting up"
TimeoutStopSec= 180
ExecStop= /home/<username>/bin/mtsendmail.sh "Off to bed. Nightie night!"
"Minetest Stopping in 2 minutes"
ExecStop= /bin/sleep 120
ExecStop= /bin/kill -2 $MAINPID
```
systemd 从 `User` 指令中得知应使用哪个用户的环境变量来正确运行该服务。你可以使用 root 用户，但这可能产生安全风险；使用你的个人用户会好一些，但不少管理员的做法是为服务单独创建一个用户，这样可以有效地将服务与其它用户和系统组件相互隔离。
下一步我们让你的服务在系统启动时自动启动，系统关闭时自动关闭。要达到这个目的，你需要 *启用* 你的服务；但在这之前，你还需要告知 systemd 从哪里 *安装* 它。
对于 systemd 而言，*安装* 意味着告知 systemd 在系统启动的具体哪个步骤激活你的服务。以通用 Unix 打印系统（`cups.service`）为例，它的启动在网络框架启动之后、其它打印服务启动之前。又如，`minetest.server` 需要使用用户邮件（及其它组件），需要等待网络和普通用户对应的服务就绪后才可启动。
你只需要在单元文件中添加一个新段和新指令：
```
...
[Install]
WantedBy= multi-user.target
```
你可以将其理解为“等待多用户系统的全部内容就绪”。systemd 中的“目标”类似于旧系统中的运行级别，可以用于将主机转移到一个或另一个状态，也可以像本例中这样让你的服务等待指定状态出现后运行。
你的最终 `minetest.service` 文件如下：
```
# minetest.service
[Unit]
Description= Minetest server
Documentation= https://wiki.minetest.net/Main_Page
[Service]
Type= simple
User= <username>
ExecStart= /usr/games/minetest --server
ExecStartPost= /home/<username>/bin/mtsendmail.sh "Ready to rumble?"
"Minetest Starting up"
TimeoutStopSec= 180
ExecStop= /home/<username>/bin/mtsendmail.sh "Off to bed. Nightie night!"
"Minetest Stopping in 2 minutes"
ExecStop= /bin/sleep 120
ExecStop= /bin/kill -2 $MAINPID
[Install]
WantedBy= multi-user.target
```
在尝试新的服务之前，你还需要对邮件脚本做一些调整：
```
#!/bin/bash
# mtsendmail
sleep 20
echo $1 | mutt -F /home/<username>/.muttrc -s "$2" my_minetest@mailing_list.com
sleep 10
```
这是因为系统需要一定的时间启动邮件系统（这里等待 20 秒），也需要一定时间完成邮件发送（这里等待 10 秒）。注意脚本中的等待时间数值适用于我的系统，你可能需要针对你的系统调整数值。
大功告成啦。执行如下操作：
```
sudo systemctl enable minetest
```
你的 Minetest 服务将在系统启动时自动启动，在系统关闭时友好关闭并通知你的用户。
### 总结
事实上 Debian、 Ubuntu 和一些族类的发行版提供了 `minetest-server` 这个特别的软件包，可以提供一部分上述功能，（但不包括邮件通知功能）。即使如此，你还是可以建立你独有的自定义服务；事实上，你目前建立的服务比 Debian 默认提供的服务更加通用，可以提供更多功能。
更进一步的说，我们这里描述的流程可以让你将大多数简单服务器转换为服务，类型可以是游戏、网站应用或其它应用。同时，这也是你名副其实地踏入 systemd 大师殿堂的第一步。
---
via: <https://www.linux.com/blog/learn/2018/5/systemd-services-beyond-starting-and-stopping>
作者：[Paul Brown](https://www.linux.com/users/bro66) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
你可以用 Linux 中的 IP 工具做 3 件有用的事情
|
Dave Neary
|
https://opensource.com/article/18/5/useful-things-you-can-do-with-IP-tool-Linux
|
如何使用 IP 工具来快速轻松地找到你的 IP 地址、显示路由表等等。
|
/data/attachment/album/201806/02/054023w7grjr6cjew6gz3e.jpg.thumb.jpg
|
/data/attachment/album/201806/02/054023w7grjr6cjew6gz3e.jpg
| true | false | true |
geekpi
| false |
[
"ip",
"ifconfig"
] |
系统运维
|
{
"viewnum": 9831,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如何使用 IP 工具来快速轻松地找到你的 IP 地址、显示路由表等等。
| 2018-06-02T05:40:47 | 2018-06-02T05:40:47 | 9,704 |
/article-9704-1.html
|
>
> 如何使用 IP 工具来快速轻松地找到你的 IP 地址、显示路由表等等。
>
>
>
`ifconfig` 命令在 Linux 上被弃用已有十多年的时间了，而 `iproute2` 项目包含了神奇的工具 `ip`。许多在线教程资源仍然采用旧的命令行工具，如 `ifconfig`、`route` 和 `netstat`。本教程的目标是分享一些可以使用 `ip` 工具轻松完成的网络相关的事情。
### 找出你的 IP 地址
```
[dneary@host]$ ip addr show
[snip]
44: wlp4s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
link/ether 5c:e0:c5:c7:f0:f1 brd ff:ff:ff:ff:ff:ff
inet 10.16.196.113/23 brd 10.16.197.255 scope global dynamic wlp4s0
valid_lft 74830sec preferred_lft 74830sec
inet6 fe80::5ee0:c5ff:fec7:f0f1/64 scope link
valid_lft forever preferred_lft forever
```
`ip addr show` 会告诉你很多关于你的所有网络链接设备的信息。在这里，我的无线以太网卡（`wlp4s0`）是 IPv4 地址（`inet` 字段）`10.16.196.113/23`。 `/23` 表示 32 位 IP 地址中的 23 位将被该子网中的所有 IP 地址共享。子网中的 IP 地址范围从 `10.16.196.0` 到 `10.16.197.254`。子网的广播地址（IP 地址后面的 `brd` 字段）`10.16.197.255` 保留给子网上所有主机的广播流量。
我们能只使用 `ip addr show dev wlp4s0` 来显示单个设备的信息。
### 显示你的路由表
```
[dneary@host]$ ip route list
default via 10.16.197.254 dev wlp4s0 proto static metric 600
10.16.196.0/23 dev wlp4s0 proto kernel scope link src 10.16.196.113 metric 601
192.168.122.0/24 dev virbr0 proto kernel scope link src 192.168.122.1 linkdown
```
路由表是本地主机帮助网络流量确定去哪里的方式。它包含一组路标，将流量发送到特定的接口，以及在其旅途中的特定下一个地点。
如果你运行任何虚拟机或容器，它们将获得自己的 IP 地址和子网，这可能会使这些路由表非常复杂，但在单个主机中，通常有两条指令。对于本地流量，将其发送到本地以太网上，并且网络交换机将找出（使用称为 ARP 的协议）哪个主机拥有目标 IP 地址，并且要将流量发送到哪里。对于到互联网的流量，将其发送到本地网关节点，它将更好地了解如何到达目的地。
在上面的情况中，第一行代表外部流量的外部网关，第二行代表本地流量，第三行代表主机上运行的虚拟机的虚拟网桥，但该链接当前未激活。
### 监视你的网络配置
```
[dneary@host]$ ip monitor all
[dneary@host]$ ip -s link list wlp4s0
```
`ip monitor` 命令可用于监视路由表（网络接口上的网络寻址）的更改或本地主机上 ARP 表的更改。此命令在调试与容器和网络相关的网络问题时特别有用，如当两个虚拟机应该能彼此通信，但实际不能。
在使用 `all` 时，`ip monitor` 会报告所有的更改，前缀以 `[LINK]`（网络接口更改）、`[ROUTE]`（更改路由表）、`[ADDR]`（IP 地址更改）或 `[NEIGH]`（与马无关 —— 与邻居的 ARP 地址相关的变化）。
你还可以监视特定对象上的更改（例如，特定的路由表或 IP 地址）。
另一个适用于许多命令的有用选项是 `ip -s`，它提供了一些统计信息。添加第二个 `-s` 选项可以添加更多统计信息。上面的 `ip -s link list wlp4s0` 会给出很多关于接收和发送的数据包的信息、丢弃的数据包数量、检测到的错误等等。
### 提示：缩短你的命令
一般来说，对于 `ip` 工具，你只需要包含足够的字母来唯一标识你想要做的事情。你可以使用 `ip mon` 来代替 `ip monitor`。你可以使用 `ip a l`，而不是 `ip addr list`，并且可以使用 `ip r`来代替 `ip route`。`ip link list` 可以缩写为 `ip l ls`。要了解可用于更改命令行为的许多选项，请浏览 [ip 手册页](https://www.systutorials.com/docs/linux/man/8-ip-route/)。
---
via: <https://opensource.com/article/18/5/useful-things-you-can-do-with-IP-tool-Linux>
作者：[Dave Neary](https://opensource.com/users/dneary) 选题：[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 的未来
|
Swapnil Bhartiya
|
https://www.linux.com/blog/2018/4/containerization-atomic-distributions-and-future-linux
|
容器支持者认为未来属于容器化操作系统，而其他人或许有不同看法。
|
/data/attachment/album/201806/02/060715t3keov434go5vo4l.jpg.thumb.jpg
|
/data/attachment/album/201806/02/060715t3keov434go5vo4l.jpg
| true | false | true |
pinewall
| false |
[
"发行版",
"容器"
] |
观点
|
{
"viewnum": 7087,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
容器支持者认为未来属于容器化操作系统，而其他人或许有不同看法。
| 2018-06-02T06:07:22 | 2018-06-02T06:07:22 | 9,705 |
/article-9705-1.html
|
>
> 容器支持者认为未来属于容器化操作系统，而其他人或许有不同看法。
>
>
>
自从 Linus Torvalds 在 1991 年发布 Linux 以来，Linux 已历经漫长的岁月。它已经成为企业级领域的主流操作系统。同时，我们看到桌面级领域出现了很多改进和调整，但在过去的 25 年来，主流 Linux 发行版的模式很大程度上没有变化。基于软件包管理的传统模式依然统治着桌面级和服务器级市场。
但随着 Google 发布了基于 Linux 的 Chrome OS，情况出现了微妙的转变，Chrome OS 采用镜像模式。Core OS (目前归属于 Red Hat) 受 Google 启发推出了一款操作系统 Container Linux，主要面向企业级用户。
Container Linux 改变了操作系统更新的方式，也改变了应用分发和更新的方式。这会是 Linux 发行版的未来吗？这是否会取代基于软件包的传统发行版模式呢？
### 三种模式
SLE (SUSE Linux Enterprise) 的产品管理总监 Matthias Eckermann 认为目前存在 3 种模式，而不是 2 种。Eckermann 提到：“除了传统模式（RHEL/SLE）和镜像模式（RedHat 的 Atomic Host），还存在第三种模型：事务模式。[SUSE CaaS 平台](https://www.suse.com/products/caas-platform/) 及 SUSE MicroOS 就采用这种模式。”
### 差异有哪些
Linux 用户对传统模式非常熟悉，它由独立的软件包和共享库组成。这种模式有独特的优势，让应用开发者无需将共享库捆绑在应用中。由于库不会多次引入，使得系统简洁和轻便。这也让用户无需下载很多软件包，节省了带宽。发行版对软件包全权负责，通过推送系统级别的更新，可以轻松地解决安全隐患。
RHEL （Red Hat Enterprise Linux）的产品管理总监 Ron Pacheco 表示，“传统的打包方式继续为我们提供精心构建和优化操作系统的机会，以便支持需要经过时间考验的任务关键型工作负载。”
但传统模式也有一些弊端。应用开发者受限使用发行版包含的库，使其无法从发行版不支持的新软件中获益。这也可能导致不同版本之间相互冲突。最终，传统模式给管理员增加了挑战，使其难以让软件包一直处于最新版本状态。
### 镜像模式
镜像模式应运而生。Eckermann 表示，“镜像模式解决了传统模式遇到的问题，它在每次迭代更新时替换整个操作系统，而不是单个的软件包”。
Pacheco 表示，“当我们用镜像作为操作系统的代名词进行讨论时，我们真正关心的是可编程式的开发和部署以及更好的集成式生命周期管理”，基于 RHEL 搭建的 OpenShift 被他用作示例。
Pacheco 认为基于镜像的操作系统是一种延续，从手工打造并部署镜像，到可大规模管理的高度自动化基础设施；无论客户使用哪种类型，都需要运行同样的应用。他说，“你肯定不希望使用一个完全不同的部署模式，这需要重做很多工作”。
镜像模式用新的库和软件包替代来整个操作系统，但也面临一系列问题。在镜像模式中，需要重建镜像才能适应特殊环境的需求。例如，用户有特殊需求，需要安装特定硬件的驱动或安装底层监控功能，镜像模式无法满足，需要重新设计功能以实现细粒度操作。
### 事务模式
第三种模式采用事务更新，基于传统的软件包更新，但将全部的软件包视为一个镜像，就像镜像那样在一次操作中更新全部软件包。
Eckermann 表示，“由于安装或回滚时操作对象是打包在一起的单一软件包，用户在需要时能够做相应的调整，这就是差别所在。结合传统模式和镜像模式的优点，避免两种模式的缺点，事务模式给用户提供了额外的灵活性。”
Pacheco 表示，将精心构造的工作负载部署成镜像的做法越来越成为主流，因为这种部署方式具有一致性和可靠性，而且可以弹性部署。“这正是我们用户目前的做法，部署环境包括在预置设备或公有/私有云上创建并部署的虚拟机，或在传统的裸机上。”
Pacheco 建议我们将这几种模式视为操作系统角色的进化和扩展，而不是仅仅“使用场景的比较和对比”。
### 原子化更新的问世
Google 的 Chrome OS 和 Core OS 为我们普及了事务更新的概念，该模型也被 Red Hat 和 SUSE 采用。
Eckermann 表示，“我们必须认识到，用于容器主机的操作系统已经不再是关注点 —— 至少不是管理员的关注点。RedHat Atomic 主机和 SUSE CaaS 平台都解决了该问题，实现方式在用户看来很相似。”
SUSE CaaS 平台、Red Hat Atomic Host和 Container Linux （前身是 Core OS）提供的[<ruby> 不可变基础设施 <rt> Immutable infrastructure </rt></ruby>](https://www.digitalocean.com/community/tutorials/what-is-immutable-infrastructure) 推广了事务更新的使用。Red Hat 高级技术产品经理 Ben Breard 表示，“在事务模式中，主机总是会变更到已确认正确的新状态，这让我们更有信心执行更新，进而实现更快速的功能流、安全优势以及易于采用的操作模式。”
这些新型操作系统使用 Linux 容器将应用与底层系统隔离，解除了传统模式中基础设施更新的诸多限制。
Breard 补充道，“当编排层可以智能处理更新、部署，甚至最终实现无缝操作时，我们才会真正意识到该模式的威力和好处”。
### 展望未来
Linux 的未来会是什么样子？不同的人会给出不同的回答。容器支持者认为未来属于容器化的操作系统，但依然拥有庞大市场的 Linux 供应商显然不这么认为。
当被问到原子化发行版是否会在很久以后将替换传统发行版时，Eckermann 表示，“如果我回答肯定的，那么表示我顺应潮流；如果回答是否定的，意味着我还是站在传统阵营。然而，我的回答是否定的，即 atomic 发行版在很久以后也不会替换传统发行版，传统负载和容器化负载将在数据中心、私有云以及公有云环境中共存。”
Pacheco 认为，从 Linux 的部署增长情况来看，一般情况下很难想象一种模式替换另一种模式。与其将多种模式视为相互竞争的关系，不如将原子化发行版视为操作系统进化和部署的一部分。
此外，在一些使用案例中，我们需要同时使用多种 Linux 发行版。Eckermann 表示，“想一想银行和保险公司中大量的 PL/1 和 Cobol 系统。再想一想内存数据库和核心数据总线系统。”
这些应用大多数无法进行容器化。就我们目前来看，容器化不是解决所有问题的万金油。总是会同时存在多种不同的技术。
Eckermann 相信，随着时间的推移，大量新的开发和部署将采用容器化，但仍然有不错的理由，促使我们在企业级环境中保留传统的部署方式和应用。
Pacheco 认为，“用户需要经历业务、设计和文化的转型，才能最大化基于容器的部署带来的优势。好消息是业界已经认识到并开始大规模转变，就像历史上大型机转变成 UNIX，UNIX 转变成 x86，x86 转变成虚拟化那样”。
### 结论
很明显，未来容器化负载的使用量会持续增长，也就意味着原子化发行版的需求量持续增长。与此同时，仍会有不少工作负载运行在传统发行版中。重要的是，这两类用户都在新模式上大规模投入，以便市场改变时可以做相应的策略改变。从外部观察者的视角来看，未来属于事务/原子化模式。我们已经见证了数据中心的发展，我们花了很长时间完成了从每个服务器一个应用到“函数即服务”模型的转变。Linux 发行版进入原子化时代的日子也不会太远了。
---
via: <https://www.linux.com/blog/2018/4/containerization-atomic-distributions-and-future-linux>
作者：[SWAPNIL BHARTIYA](https://www.linux.com/users/arnieswap) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
保护你的 Fedora 系统免受这个 DHCP 漏洞
|
Paul W. Frields
|
https://fedoramagazine.org/protect-fedora-system-dhcp-flaw/
|
前几天在 dhcp-client 中发现并披露了一个严重的安全漏洞。此 DHCP 漏洞会对你的系统和数据造成高风险，尤其是在使用不受信任的网络，如非你拥有的 WiFi 接入点时。
|
/data/attachment/album/201806/02/062337ncbcmjgkp9ltm404.jpg.thumb.jpg
|
/data/attachment/album/201806/02/062337ncbcmjgkp9ltm404.jpg
| true | false | true |
geekpi
| false |
[
"dhcp",
"安全"
] |
技术
|
{
"viewnum": 5234,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
前几天在 dhcp-client 中发现并披露了一个严重的安全漏洞。此 DHCP 漏洞会对你的系统和数据造成高风险，尤其是在使用不受信任的网络，如非你拥有的 WiFi 接入点时。
| 2018-06-02T06:23:34 | 2018-06-02T06:23:34 | 9,706 |
/article-9706-1.html
|
前几天在 `dhcp-client` 中发现并披露了一个严重的安全漏洞。此 DHCP 漏洞会对你的系统和数据造成高风险，尤其是在使用不受信任的网络，如非你拥有的 WiFi 接入点时。
动态主机控制协议（DHCP）能让你的系统从其加入的网络中获取配置。你的系统将请求 DHCP 数据，并且通常是由路由器等服务器应答。服务器为你的系统提供必要的数据以进行自我配置。例如，你的系统如何在加入无线网络时正确进行网络配置。
但是，本地网络上的攻击者可能会利用此漏洞。使用在 NetworkManager 下运行的 `dhcp-client` 脚本中的漏洞，攻击者可能能够在系统上以 root 权限运行任意命令。这个 DHCP 漏洞使你的系统和数据处于高风险状态。该漏洞已分配 CVE-2018-1111，并且有 [Bugzilla 来跟踪 bug](https://bugzilla.redhat.com/show_bug.cgi?id=1567974)。
### 防范这个 DHCP 漏洞
新的 dhcp 软件包包含了 Fedora 26、27 和 28 以及 Rawhide 的修复程序。维护人员已将这些更新提交到 updates-testing 仓库。对于大多数用户而言，它们应该在这篇文章的大约一天左右的时间内在稳定仓库出现。所需的软件包是：
* Fedora 26: dhcp-4.3.5-11.fc26
* Fedora 27: dhcp-4.3.6-10.fc27
* Fedora 28: dhcp-4.3.6-20.fc28
* Rawhide: dhcp-4.3.6-21.fc29
#### 更新稳定的 Fedora 系统
要在稳定的 Fedora 版本上立即更新，请[使用 sudo](https://fedoramagazine.org/howto-use-sudo/) 运行此命令。如有必要，请在提示时输入你的密码：
```
sudo dnf --refresh --enablerepo=updates-testing update dhcp-client
```
之后，使用标准稳定仓库进行更新。要从稳定的仓库更新 Fedora 系统，请使用以下命令：
```
sudo dnf --refresh update dhcp-client
```
#### 更新 Rawhide 系统
如果你的系统是 Rawhide，请使用以下命令立即下载和更新软件包：
```
mkdir dhcp && cd dhcp
koji download-build --arch={x86_64,noarch} dhcp-4.3.6-21.fc29
sudo dnf update ./dhcp-*.rpm
```
在每日的 Rawhide compose 后，只需运行 `sudo dnf update` 即可获取更新。
### Fedora Atomic Host
针对 Fedora Atomic Host 的修复程序版本为 28.20180515.1。要获得更新，请运行以下命令：
```
atomic host upgrade -r
```
此命令将重启系统以应用升级。
---
via: <https://fedoramagazine.org/protect-fedora-system-dhcp-flaw/>
作者：[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/) 荣誉推出
|
||
如何在 Ubuntu 18.04 服务器上安装和配置 KVM
|
Pradeep Kumar
|
https://www.linuxtechi.com/install-configure-kvm-ubuntu-18-04-server/
|
我们可以通过 virt-manager 的图形用户界面或使用 virt-install 和 virsh 命令在命令行界面来创建和管理基于 KVM 的虚拟机。
|
/data/attachment/album/201806/03/085134fdm943c199801h99.jpg.thumb.jpg
|
/data/attachment/album/201806/03/085134fdm943c199801h99.jpg
| true | false | true |
wyxplus
| false |
[
"虚拟化",
"kvm"
] |
容器与云
|
{
"viewnum": 23230,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们可以通过 virt-manager 的图形用户界面或使用 virt-install 和 virsh 命令在命令行界面来创建和管理基于 KVM 的虚拟机。
| 2018-06-03T08:51:00 | 2018-06-03T08:51:00 | 9,707 |
/article-9707-1.html
|
**KVM**（基于内核的虚拟机）是一款为类 Linux 系统提供的开源的全虚拟化解决方案，KVM 使用虚拟化扩展（如 **Intel VT** 或 **AMD-V**）提供虚拟化功能。无论何时我们在任何 Linux 机器上安装 KVM，都会通过加载诸如 `kvm-intel.ko`（基于 Intel 的机器）和 `kvm-amd.ko`（基于 amd 的机器）的内核模块，使其成为<ruby> 管理程序 <rt> hyervisor </rt></ruby>（LCTT 译注：一种监控和管理虚拟机运行的核心软件层）。
KVM 允许我们安装和运行多个虚拟机（Windows 和 Linux）。我们可以通过 `virt-manager` 的图形用户界面或使用 `virt-install` 和 `virsh` 命令在命令行界面来创建和管理基于 KVM 的虚拟机。
在本文中，我们将讨论如何在 Ubuntu 18.04 LTS 服务器上安装和配置 **KVM 管理程序**。我假设你已经在你的服务器上安装了 Ubuntu 18.04 LTS 。接下来登录到您的服务器执行以下步骤。
### 第一步：确认您的硬件是否支持虚拟化
执行 `egrep` 命令以验证您的服务器的硬件是否支持虚拟化，
```
linuxtechi@kvm-ubuntu18-04:~$ egrep -c '(vmx|svm)' /proc/cpuinfo
1
```
如果输出结果大于 0，就意味着您的硬件支持虚拟化。重启，进入 BIOS 设置中启用 VT 技术。
现在使用下面的命令安装 `kvm-ok` 实用程序，该程序用于确定您的服务器是否能够运行硬件加速的 KVM 虚拟机。
```
linuxtechi@kvm-ubuntu18-04:~$ sudo apt install cpu-checker
```
运行 kvm-ok 命令确认输出结果，
```
linuxtechi@kvm-ubuntu18-04:~$ sudo kvm-ok
INFO: /dev/kvm exists
KVM acceleration can be used
```
### 第二步：安装 KVM 及其依赖包
运行下面的 apt 命令安装 KVM 及其依赖项：
```
linuxtechi@kvm-ubuntu18-04:~$ sudo apt update
linuxtechi@kvm-ubuntu18-04:~$ sudo apt install qemu qemu-kvm libvirt-bin bridge-utils virt-manager
```
只要上图相应的软件包安装成功，那么你的本地用户（对于我来说是 `linuxtechi`）将被自动添加到 `libvirtd` 群组。
### 第三步：启动并启用 libvirtd 服务
我们在 Ubuntu 18.04 服务器上安装 qemu 和 libvirtd 软件包之后，它就会自动启动并启用 `libvirtd` 服务，如果 `libvirtd` 服务没有开启，则运行以下命令开启，
```
linuxtechi@kvm-ubuntu18-04:~$ sudo service libvirtd start
linuxtechi@kvm-ubuntu18-04:~$ sudo update-rc.d libvirtd enable
```
现在使用下面的命令确认 libvirtd 服务的状态，
```
linuxtechi@kvm-ubuntu18-04:~$ service libvirtd status
```
输出结果如下所示：
### 第四步：为 KVM 虚拟机配置桥接网络
只有通过桥接网络，KVM 虚拟机才能访问外部的 KVM 管理程序或主机。在Ubuntu 18.04中，网络由 `netplan` 实用程序管理，每当我们新安装一个 Ubuntu 18.04 系统时，会自动创建一个名称为 `/etc/netplan/50-cloud-init.yaml` 文件，其配置了静态 IP 和桥接网络，`netplan` 实用工具将引用这个文件。
截至目前，我已经在此文件配置了静态 IP，文件的具体内容如下：
```
network:
ethernets:
ens33:
addresses: [192.168.0.51/24]
gateway4: 192.168.0.1
nameservers:
addresses: [192.168.0.1]
dhcp4: no
optional: true
version: 2
```
我们在这个文件中添加桥接网络的配置信息，
```
linuxtechi@kvm-ubuntu18-04:~$ sudo vi /etc/netplan/50-cloud-init.yaml
network:
version: 2
ethernets:
ens33:
dhcp4: no
dhcp6: no
bridges:
br0:
interfaces: [ens33]
dhcp4: no
addresses: [192.168.0.51/24]
gateway4: 192.168.0.1
nameservers:
addresses: [192.168.0.1]
```
正如你所看到的，我们已经从接口（`ens33`）中删除了 IP 地址，并将该 IP 添加到 `br0` 中，并且还将接口（`ens33`）添加到 `br0`。使用下面的 `netplan` 命令使更改生效，
```
linuxtechi@kvm-ubuntu18-04:~$ sudo netplan apply
```
如果您想查看 debug 日志请使用以下命令，
```
linuxtechi@kvm-ubuntu18-04:~$ sudo netplan --debug apply
```
现在使用以下方法确认网络桥接状态：
```
linuxtechi@kvm-ubuntu18-04:~$ sudo networkctl status -a
```
```
linuxtechi@kvm-ubuntu18-04:~$ ifconfig
```
### 第五步：创建虚拟机（使用 virt-manager 或 virt-install 命令）
有两种方式创建虚拟机：
* `virt-manager`（图形化工具）
* `virt-install`（命令行工具）
#### 使用 virt-manager 创建虚拟机
通过执行下面的命令启动 `virt-manager`：
```
linuxtechi@kvm-ubuntu18-04:~$ sudo virt-manager
```
创建一个新的虚拟机：
点击“下一步”然后选择 ISO 镜像文件，我使用的是 RHEL 7.3 iso 镜像。
点击“下一步”。
在接下来的几个窗口中，系统会提示要求您为 VM 分配内存，处理器数量和磁盘空间。
并指定虚拟机名字和桥接网络名：
点击“结束”。
接下来只需要按照屏幕指示安装系统。
#### 使用virt-install命令从命令行界面创建虚拟机
使用下面的 `virt-install` 命令从终端创建一个虚拟机，它将在命令行界面中开始安装，并根据您对虚拟机的名字，说明，ISO 文件位置和桥接配置的设置创建虚拟机。
```
linuxtechi@kvm-ubuntu18-04:~$ sudo virt-install -n DB-Server --description "Test VM for Database" --os-type=Linux --os-variant=rhel7 --ram=1096 --vcpus=1 --disk path=/var/lib/libvirt/images/dbserver.img,bus=virtio,size=10 --network bridge:br0 --graphics none --location /home/linuxtechi/rhel-server-7.3-x86_64-dvd.iso --extra-args console=ttyS0
```
本文到此为止，我希望这篇文章能帮助你能够在 Ubuntu 18.04 服务器上成功安装 KVM。 除此之外，KVM 也是 Openstack 默认的管理程序。
阅读更多：“[如何使用 virsh 命令创建，还原和删除 KVM 虚拟机快照](https://www.linuxtechi.com/create-revert-delete-kvm-virtual-machine-snapshot-virsh-command/)”。
---
via: <https://www.linuxtechi.com/install-configure-kvm-ubuntu-18-04-server/>
作者：[Pradeep Kumar](http://www.linuxtechi.com/author/pradeep/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wyxplus](https://github.com/wyxplus) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Quagga 实现 Linux 动态路由
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2018/3/dynamic-linux-routing-quagga
|
学习如何使用 Quagga 套件的路由协议去管理动态路由。
|
/data/attachment/album/201806/03/105608rlzwdzcmiaan0zh7.png.thumb.jpg
|
/data/attachment/album/201806/03/105608rlzwdzcmiaan0zh7.png
| true | false | true |
qhwdw
| false |
[
"Quagga",
"路由"
] |
系统运维
|
{
"viewnum": 16581,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9657,
"displayorder": 0
},
{
"raid": 9675,
"displayorder": 1
}
] |
学习如何使用 Quagga 套件的路由协议去管理动态路由。
| 2018-06-03T10:56:00 | 2018-06-03T10:56:00 | 9,708 |
/article-9708-1.html
|
>
> 学习如何使用 Quagga 套件的路由协议去管理动态路由。
>
>
>
迄今为止，本系列文章中，我们已经在 [Linux 局域网路由新手指南：第 1 部分](/article-9657-1.html) 中学习了复杂的 IPv4 地址，在 [Linux 局域网路由新手指南：第 2 部分](/article-9675-1.html) 中学习了如何去手工创建静态路由。
今天，我们继续使用 [Quagga](https://www.quagga.net/) 去管理动态路由，这是一个安装完后就不用理它的的软件。Quagga 是一个支持 OSPFv2、OSPFv3、RIP v1 和 v2、RIPng、以及 BGP-4 的路由协议套件，并全部由 zebra 守护程序管理。
OSPF 的意思是<ruby> 最短路径优先 <rt> Open Shortest Path First </rt></ruby>。OSPF 是一个内部网关协议（IGP）;它可以用在局域网和跨因特网的局域网互联中。在你的网络中的每个 OSPF 路由器都包含整个网络的拓扑，并计算通过网络的最短路径。OSPF 会通过多播的方式自动对外传播它检测到的网络变化。你可以将你的网络分割为区域，以保持路由表的可管理性；每个区域的路由器只需要知道离开它的区域的下一跳接口地址，而不用记录你的网络的整个路由表。
RIP，即路由信息协议，是一个很老的协议，RIP 路由器向网络中周期性多播它的整个路由表，而不是像 OSPF 那样只多播网络的变化。RIP 通过跳数来测量路由，任何超过 15 跳的路由它均视为不可到达。RIP 设置很简单，但是 OSPF 在速度、效率以及弹性方面更佳。
BGP-4 是边界网关协议版本 4。这是用于因特网流量路由的外部网关协议（EGP）。你不会用到 BGP 协议的，除非你是因特网服务提供商。
### 准备使用 OSPF
在我们的小型 KVM 测试实验室中，用两台虚拟机表示两个不同的网络，然后将另一台虚拟机配置为路由器。创建两个网络：net1 是 192.168.110.0/24 ，而 net2 是 192.168.120.0/24。启用 DHCP 是明智的，否则你要分别进入这三个虚拟机，去为它们设置静态地址。Host 1 在 net1 中，Host 2 在 net2 中，而路由器同时与这两个网络连接。设置 Host 1 的网关地址为 192.168.110.126，Host 2 的网关地址为 192.168.120.136。
* Host 1： 192.168.110.125
* Host 2：192.168.120.135
* Router：192.168.110.126 和 192.168.120.136
在路由器上安装 Quagga。在大多数 Linux 中它是 quagga 软件包。在 Debian 上还有一个单独的文档包 quagga-doc。取消 `/etc/sysctl.conf` 配置文件中如下这一行的注释去启用包转发功能：
```
net.ipv4.ip_forward=1
```
然后，运行 `sysctl -p` 命令让变化生效。
### 配置 Quagga
查看你的 Quagga 包中的示例配置文件，比如，`/usr/share/doc/quagga/examples/ospfd.conf.sample`。除非你的 Linux 版本按你的喜好做了创新，否则，一般情况下配置文件应该在 `/etc/quagga` 目录中。大多数 Linux 版本在这个目录下有两个文件，`vtysh.conf` 和 `zebra.conf`。它们提供了守护程序运行所需要的最小配置。除非你的发行版做了一些特殊的配置，否则，zebra 总是首先运行，当你启动 ospfd 的时候，它将自动启动。Debian/Ubuntu 是一个特例，稍后我们将会说到它。
每个路由器守护程序将读取它自己的配置文件，因此，我们必须创建 `/etc/quagga/ospfd.conf`，并输入如下内容：
```
!/etc/quagga/ospfd.conf
hostname router1
log file /var/log/quagga/ospfd.log
router ospf
ospf router-id 192.168.110.15
network 192.168.110.0/0 area 0.0.0.0
network 192.168.120.0/0 area 0.0.0.0
access-list localhost permit 127.0.0.1/32
access-list localhost deny any
line vty
access-class localhost
```
你可以使用感叹号（`!`）或者井号（`#`）去注释掉这些行。我们来快速浏览一下这些选项。
* `hostname` 可以是你希望的任何内容。这里不是一般意义上的 Linux 主机名，但是，当你使用 `vtysh` 或者 `telnet` 登入时，你将看到它们。
* `log file` 是你希望用于保存日志的任意文件。
* `router` 指定路由协议。
* `ospf router-id` 是任意的 32 位数字。使用路由器的一个 IP 地址就是很好的选择。
* `network` 定义你的路由器要通告的网络。
* `access-list` 限制 `vtysh` 登入，它是 Quagga 命令行 shell，它允许本地机器登入，并拒绝任何远程管理。
### Debian/Ubuntu
在你启动守护程序之前，Debian/Ubuntu 相对其它的 Debian 衍生版可能多需要一步到多步。编辑 `/etc/quagga/daemons` ，除了 `zebra=yes` 和 `ospfd=yes` 外，使其它所有的行的值为 `no`。
然后，在 Debian 上运行 `ospfd` 去启动 Quagga：
```
# systemctl start quagga
```
在大多数的其它 Linux 上，包括 Fedora 和 openSUSE，用如下命令启动 `ospfd`：
```
# systemctl start ospfd
```
现在，Host 1 和 Host 2 将可以互相 ping 通对方和路由器。
这里用了许多篇幅去描述非常简单的设置。在现实中，路由器将连接两个交换机，然后为连接到这个交换机上的所有电脑提供一个网关。你也可以在你的路由器上添加更多的网络接口，这样你的路由器就可以为更多的网络提供路由服务，或者也可以直接连接到其它路由器上，或者连接到连接其它路由器的骨干网络上。
你或许不愿意如此麻烦地手工配置网络接口。最简单的方法是使用你的 DHCP 服务器去宣告你的路由器。如果你使用了 Dnsmasq，那么你就有了一个 DHCP 和 DNS 的一体化解决方案。
还有更多的配置选项，比如，加密的密码保护。更多内容请查看 [Quagga 路由套件](https://www.quagga.net/) 的官方文档。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/3/dynamic-linux-routing-quagga>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Audacity 快速指南：快速消除背景噪音
|
Ryan Lerch
|
https://fedoramagazine.org/audacity-quick-tip-quickly-remove-background-noise/
|
在这个快速指南中，我们会学习如何使用 Fedora 中的 Audacity 快速移除音频文件中的背景噪音。
|
/data/attachment/album/201806/03/110200t2nw5y8z0sl7z85n.png.thumb.jpg
|
/data/attachment/album/201806/03/110200t2nw5y8z0sl7z85n.png
| true | false | true |
geekpi
| false |
[
"Audacity",
"噪音"
] |
桌面应用
|
{
"viewnum": 9816,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这个快速指南中，我们会学习如何使用 Fedora 中的 Audacity 快速移除音频文件中的背景噪音。
| 2018-06-03T11:01:00 | 2018-06-03T11:01:00 | 9,709 |
/article-9709-1.html
|
当在笔记本电脑上录制声音时 —— 比如首次简单地录屏 —— 许多用户通常使用内置麦克风。但是，这些小型麦克风也会捕获很多背景噪音。在这个快速指南中，我们会学习如何使用 Fedora 中的 [Audacity](https://www.audacityteam.org/) 快速移除音频文件中的背景噪音。
### 安装 Audacity
Audacity 是 Fedora 中用于混合、剪切和编辑音频文件的程序。在 Fedora 上它支持各种开箱即用的格式 - 包括 MP3 和 OGG。从软件中心安装 Audacity。
如果你更喜欢终端，请使用以下命令：
```
sudo dnf install audacity
```
### 导入您的音频、样本背景噪音
安装 Audacity 后，打开程序，使用 “File > Import” 菜单项导入你的声音。这个例子使用了一个[来自 freesound.org 添加了噪音的声音](https://freesound.org/people/levinj/sounds/8323/)：
* <https://ryanlerch.fedorapeople.org/noise.ogg?_=1>
接下来，采样要滤除的背景噪音。导入音轨后，选择仅包含背景噪音的音轨区域。然后从菜单中选择 “Effect > Noise Reduction”，然后按下 “Get Noise Profile” 按钮。
### 过滤噪音
接下来，选择你要过滤噪音的音轨区域。通过使用鼠标进行选择，或者按 `Ctrl + a` 来选择整个音轨。最后，再次打开 “Effect > Noise Reduction” 对话框，然后单击确定以应用滤镜。
此外，调整设置，直到你的音轨听起来更好。这里是原始文件，接下来是用于比较的降噪音轨（使用默认设置）：
* <https://ryanlerch.fedorapeople.org/sidebyside.ogg?_=2>
---
via: <https://fedoramagazine.org/audacity-quick-tip-quickly-remove-background-noise/>
作者：[Ryan Lerch](https://fedoramagazine.org/introducing-flatpak/) 选题：[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/) 荣誉推出
|
||
diff 与 patch 的使用
|
Locez
|
http://locez.com/linux/diff-and-patch/
|
在 Linux 的日常使用中，我们经常需要修改一些配置文件，然而在软件升级以后，经常会面临配置更新后与原配置部分不兼容的问题（当然我们更多的可能是来制作软件升级的补丁）
|
/data/attachment/album/201806/03/112057zvh0tuwx1lljehhs.jpg.thumb.jpg
|
/data/attachment/album/201806/03/112057zvh0tuwx1lljehhs.jpg
| true | false | false | false |
[
"diff",
"patch",
"补丁"
] |
技术
|
{
"viewnum": 6984,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 Linux 的日常使用中，我们经常需要修改一些配置文件，然而在软件升级以后，经常会面临配置更新后与原配置部分不兼容的问题（当然我们更多的可能是来制作软件升级的补丁）
| 2018-06-03T11:21:06 | 2018-06-03T11:21:06 | 9,710 |
/article-9710-1.html
|
### 摘要
在 Linux 的日常使用中，我们经常需要修改一些配置文件，然而在软件升级以后，经常会面临配置更新后与原配置部分不兼容的问题（当然我们更多的可能是来制作软件升级的补丁）。在这种情况下我们通常有两种选择：
* 对比现有配置，手动在新配置文件中改动
* 利用 `sed`、`awk` 等工具配合改动
* 采用 `diff` 与 `patch` 制作增量补丁的方式改动
本文主要通过一个升级`awesome` 配置的例子，对第三种方法进行介绍和讲解。
### diff 介绍
`diff` 是一个文件比较工具，可以逐行比较两个文件的不同，其中它有三种输出方式，分别是 `normal`， `context` 以及 `unified`。区别如下：
* `normal` 方式为默认输出方式，不需要加任何参数
* `context` 相较于 `normal` 模式的简单输出，`contetx` 模式会输出修改过部分的上下文，默认是前后 **3** 行。使用参数 `-c`
* `unified` 合并上下文模式则为新的上下文输出模式，同样为前后 **3** 行，只不过把上下文合并了显示了。使用参数 `-u`
**注**：本文主要介绍 `unified` 模式
其他常用参数：
* `-r` 递归处理目录
* `-N` 将缺失的文件当作空白文件处理
#### diff 语法与文件格式
```
diff [options] old new
```
先来看一个简单的例子：
```
$ cat test1
linux
linux
linux
linux
```
```
$ cat test2
locez
linux
locez
linux
```
此时输入 `diff -urN test1 test2` 会输出以下信息：
```
--- test1 2018-05-12 18:39:41.508375114 +0800
+++ test2 2018-05-12 18:41:00.124031736 +0800
@@ -1,4 +1,4 @@
+locez
linux
-linux
-linux
+locez
linux
```
先看前面 2 行，这两行为文件的基本信息，`---` 开头为改变前的文件，`+++` 开头为更新后的文件。
```
--- test1 2018-05-12 18:39:41.508375114 +0800
+++ test2 2018-05-12 18:41:00.124031736 +0800
```
第三行为上下文描述块，其中 `-1,4` 为旧文件的 4 行上下文，`+1,4` 为新文件的：
```
@@ -1,4 +1,4 @@
```
而具体到块里面的内容，前面有 `-` 号的则为删除，有 `+` 号为新增，不带符号则未做改变，仅仅是上下文输出。
### patch 介绍
`patch` 是一个可以将 `diff` 生成的**补丁**应用到源文件，生成一个打过补丁版本的文件。语法：
```
patch [oiption] [originalfile [patchfile]]
```
常用参数：
* `-i` 指定补丁文件
* `-pNum` 在 `diff` 生成的补丁中，第一二行是文件信息，其中文件名是可以包含路径的，例如 `--- /tmp/test1 2018-05-12 18:39:41.508375114 +0800` 其中 `-p0` 代表完整的路径 `/tmp/test1`，而 `-p1` 则指 `tmp/test1`，`-pN` 依此类推
* `-E` 删除应用补丁后为空文件的文件
* `-o` 输出到一个文件而不是直接覆盖文件
### 应用
awesome 桌面 3.5 与 4.0 之间的升级是不兼容的，所以在升级完 4.0 以后，awesome 桌面部分功能无法使用，因此需要迁移到新配置，接下来则应用 `diff` 与 `patch` 实现迁移，当然你也可以单纯使用 `diff` 找出不同，然后手动修改新配置。
现在有以下几个文件：
* `rc.lua.3.5` 3.5 版本的默认配置文件，未修改
* `rc.lua.myconfig` 基于 3.5 版本的个人配置文件
* `rc.lua.4.2` 4.2 新默认配置，未修改
思路为利用 `diff` 提取出个人配置与 3.5 默认配置文件的增量补丁，然后把补丁应用在 4.2 的文件上实现迁移。
#### 制作补丁
```
$ diff -urN rc.lua.3.5 rc.lua.myconfig > mypatch.patch
```
#### 应用补丁
```
$ patch rc.lua.4.2 -i mypatch.patch -o rc.lua
patching file rc.lua (read from rc.lua.4.2)
Hunk #1 FAILED at 38.
Hunk #2 FAILED at 55.
Hunk #3 succeeded at 101 with fuzz 1 (offset 5 lines).
Hunk #4 succeeded at 276 with fuzz 2 (offset 29 lines).
2 out of 4 hunks FAILED -- saving rejects to file rc.lua.rej
```
显然应用没有完全成功，其中在 38 行以及 55 行应用失败，并记录在 `rc.lua.rej` 里。
```
$ cat rc.lua.rej
--- rc.lua.3.5 2018-05-12 19:15:54.922286085 +0800
+++ rc.lua.myconfig 2018-05-12 19:13:35.057911463 +0800
@@ -38,10 +38,10 @@
-- {{{ Variable definitions
-- Themes define colours, icons, font and wallpapers.
-beautiful.init("@AWESOME_THEMES_PATH@/default/theme.lua")
+beautiful.init("~/.config/awesome/default/theme.lua")
-- This is used later as the default terminal and editor to run.
-terminal = "xterm"
+terminal = "xfce4-terminal"
editor = os.getenv("EDITOR") or "nano"
editor_cmd = terminal .. " -e " .. editor
@@ -55,18 +55,18 @@
-- Table of layouts to cover with awful.layout.inc, order matters.
local layouts =
{
- awful.layout.suit.floating,
- awful.layout.suit.tile,
- awful.layout.suit.tile.left,
- awful.layout.suit.tile.bottom,
- awful.layout.suit.tile.top,
+-- awful.layout.suit.floating,
+-- awful.layout.suit.tile,
+-- awful.layout.suit.tile.left,
+-- awful.layout.suit.tile.bottom,
+-- awful.layout.suit.tile.top,
awful.layout.suit.fair,
awful.layout.suit.fair.horizontal,
awful.layout.suit.spiral,
awful.layout.suit.spiral.dwindle,
awful.layout.suit.max,
awful.layout.suit.max.fullscreen,
- awful.layout.suit.magnifier
+-- awful.layout.suit.magnifier
}
-- }}}
```
这里是主题，终端，以及常用布局的个人设置。
#### 修正补丁
再次通过对比补丁文件与 4.2 文件，发现 38 行区块是要删除的东西不匹配，而 55 行区块则是上下文与要删除的内容均不匹配，导致不能应用补丁，于是手动修改补丁
```
$ vim mypatch.patch
```
```
--- rc.lua.3.5 2018-05-12 19:15:54.922286085 +0800
+++ rc.lua.myconfig 2018-05-12 19:13:35.057911463 +0800
@@ -38,10 +38,10 @@
-- {{{ Variable definitions
-- Themes define colours, icons, font and wallpapers.
-beautiful.init(gears.filesystem.get_themes_dir() .. "default/theme.lua")
+beautiful.init("~/.config/awesome/default/theme.lua")
-- This is used later as the default terminal and editor to run.
-terminal = "xterm"
+terminal = "xfce4-terminal"
editor = os.getenv("EDITOR") or "nano"
editor_cmd = terminal .. " -e " .. editor
@@ -55,18 +55,18 @@
-- Table of layouts to cover with awful.layout.inc, order matters.
awful.layout.layouts = {
- awful.layout.suit.floating,
- awful.layout.suit.tile,
- awful.layout.suit.tile.left,
- awful.layout.suit.tile.bottom,
- awful.layout.suit.tile.top,
+-- awful.layout.suit.floating,
+-- awful.layout.suit.tile,
+-- awful.layout.suit.tile.left,
+-- awful.layout.suit.tile.bottom,
+-- awful.layout.suit.tile.top,
awful.layout.suit.fair,
awful.layout.suit.fair.horizontal,
awful.layout.suit.spiral,
awful.layout.suit.spiral.dwindle,
awful.layout.suit.max,
awful.layout.suit.max.fullscreen,
- awful.layout.suit.magnifier,
+-- awful.layout.suit.magnifier,
awful.layout.suit.corner.nw,
-- awful.layout.suit.corner.ne,
-- awful.layout.suit.corner.sw,
....
....
```
输出省略显示，有兴趣的读者可以仔细与`rc.lua.rej` 文件对比，看看笔者是怎样改的。
#### 再次应用补丁
```
$ patch rc.lua.4.2 -i mypatch.patch -o rc.lua
patching file rc.lua (read from rc.lua.4.2)
Hunk #1 succeeded at 41 (offset 3 lines).
Hunk #2 succeeded at 57 with fuzz 2 (offset 2 lines).
Hunk #3 succeeded at 101 with fuzz 1 (offset 5 lines).
Hunk #4 succeeded at 276 with fuzz 2 (offset 29 lines).
$ cp rc.lua ~/.config/awesome/rc.lua ### 打完补丁直接使用
```
### 总结
`diff` 与 `patch` 配合使用，能当增量备份，而且还可以将补丁分发给他人使用，而且在日常的软件包打补丁也具有重要的意义，特别是内核补丁或者一些驱动补丁，打补丁遇到错误时候可以尝试自己修改，已满足自身特殊要求，修改的时候一定要抓住 2 个非常重要的要素：
1. 要修改的内容是否匹配？特别是要删除的
2. 上下文是否满足，特别是距离要修改的地方前后一行，以及上下文的行数是否满足，默认是 3 行上下文
|
|||
异步决策：帮助远程团队走向成功
|
Bertrand Delacretaz
|
https://opensource.com/article/17/12/asynchronous-decision-making
|
更好的沟通和少量的会议并不是白日梦。这里告诉您异步决策是如何实现这一切的。
|
/data/attachment/album/201806/03/171213hlgf9fz879w8k9xl.png.thumb.jpg
|
/data/attachment/album/201806/03/171213hlgf9fz879w8k9xl.png
| true | false | true |
lujun9972
| false |
[
"决策"
] |
观点
|
{
"viewnum": 3810,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
更好的沟通和少量的会议并不是白日梦。这里告诉您异步决策是如何实现这一切的。
| 2018-06-03T17:12:07 | 2018-06-03T17:12:07 | 9,711 |
/article-9711-1.html
|
>
> 更好的沟通和少量的会议并不是白日梦。这里告诉您异步决策是如何实现这一切的。
>
>
>
异步决策能够让地理和文化上分散的软件团队更有效率地做出决策。本文就将讨论一下实现异步决策所需要的一些原则和工具。
同步决策，要求参与者实时地进行互动，而这对那些需要<ruby> <a href="http://www.paulgraham.com/makersschedule.html"> 大块完整时间工作 </a> <rt> Maker's Schedule </rt></ruby>的人来说代价非常大，而且对于远程团队来说这也不现实。我们会发现这种会议最后浪费的时间让人难以置信。
相比之下，异步决策常应用于大型开源项目中（比如我常参与的 Apache 软件基金会 ASF）。它为团队提供了一种尽可能少开会的有效方法。很多开源项目每年只开很少的几次会议（有的甚至完全没开过会），然而开发团队却始终如一地在生产高质量的软件。
怎样才能异步决策呢？
### 所需工具
#### 中心化的异步沟通渠道
异步决策的第一步就是构建一个中心化的异步沟通渠道。你所使用的技术必须能让所有的团队成员都获得同样的信息，并能进行<ruby> 线索讨论 <rt> threaded discussions </rt></ruby>，也就是说你要既能对一个主题进行发散也要能封禁其他主题的讨论。想一想航海专用无线电台，其中广播渠道的作用只是为了引起特定人员的注意，这些人然后再创建一个子渠道来进行详细的讨论。
很多开源项目依旧使用邮件列表作为中心渠道，不过很多新一代的软件开发者可能会觉得这个方法又古老又笨拙。邮件列表需要遵循大量的准则才能有效的管理热门项目，比如你需要进行有意义的引用，每个线索只讨论一个主题，保证 [标题与内容相吻合](https://grep.codeconsult.ch/2017/11/10/large-mailing-lists-survival-guide/)。虽然这么麻烦，但使用得当的话，再加上一个经过索引的归档系统，邮件列表依然在创建中心渠道的工具中占据绝对主导的地位。
公司团队可以从一个更加现代化的协作工具中收益，这类工具更易使用并提供了更加强大的多媒体功能。不管你用的是哪个工具，关键在于要创建一个能让大量的人员有效沟通并异步地讨论各种主题的渠道。要创建一个一致而活跃的社区，使用一个 [繁忙的渠道要好过建立多个渠道](https://grep.codeconsult.ch/2011/12/06/stefanos-mazzocchis-busy-list-pattern/)。
#### 构建共识的机制
第二个工具是一套构建共识的机制，这样你才不会陷入死循环从而确保能做出决策。做决策最理想的情况就是一致同意，而次佳的就是达成共识，也就是 “有决策权的人之间广泛形成了一致的看法”。强求完全一致的赞同或者允许一票否决都会阻碍决策的制定，因此 ASF 中只在非常有限的决策类型中允许否决权。[ASF 投票制度](http://www.apache.org/foundation/voting.html) 为类似 ASF 这样没有大老板的松散组织构建了一个久经考验的，用于达成共识的好方法。当共识无法自然产生时也可以使用该套制度。
#### 案例管理系统
如上所述，我们通常在项目的中心渠道中构建共识。但是在讨论一些复杂的话题时，使用案例管理系统这一第三方的工具很有意义。小组可以使用中心渠道专注于非正式的讨论和头脑风暴上，当讨论要转变成一个决策时将其转到一个更加结构化的案例管理系统中去。
案例管理系统能够更精确地组织决策。小型团队不用做太多决策可以不需要它，但很多团队会发现能有一个相对独立的地方讨论决策的细节并保存相关信息会方便很多。
案例管理系统不一定就是个很复杂的软件; 在 ASF 中我们所使用的只是简单的问题跟踪软件而已，这些基于网页的系统原本是创建来进行软件支持和 bug 管理的。每个案例列在一个单独的网页上，还有一些历史的注释和动作信息。该途径可以很好的追踪决策是怎么制定出来的。比如，某些非紧急的决策或者复杂的决策可能会花很长时间才会制定出来，这时有一个地方能够了解这些决策的历史就很有用了。新来的团队成员也能很快地了解到最近做出了哪些决策，哪些决策还在讨论，每个决策都有那些人参与其中，每个决策的背景是什么。
### 成功的案例
ASF 董事会中的九名董事在每个月的电话会议上只做很少的一些决策，耗时不超过 2 个小时。在准备这些会议之前，大多数的决策都预先通过异步的方式决定好了。这使得我们可以在会议上集中讨论复杂和难以确定的问题，而不是讨论那些已经达成普遍或部分共识的问题上。
软件世界外的一个有趣的案例是 [瑞士联邦委员会的周会](https://www.admin.ch/gov/en/start/federal-council/tasks/decision-making/federal-council-meeting.html)，它的运作方式跟 ASF 很类似。团队以异步决策构建共识的方式来准备会议。会议议程由一组不同颜色编码的列表组成，这些颜色标识了那些事项可以很快通过批准，那些事项需要进一步的讨论，哪些事项特别的复杂。这使得只要 7 个人就能每年忙完超过 2500 项决策，共 50 个周会，每个周会只需要几个小时时间。我觉得这个效率已经很高了。
就我的经验来看，异步决策带来的好处完全值得上为此投入的时间和工具。而且它也能让团队成员更快乐，这也是成功的关键因素之一。
---
via: <https://opensource.com/article/17/12/asynchronous-decision-making>
作者：[Bertrand Delacretaz](https://opensource.com) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
最小权限的容器编排
|
Diogo Mónica
|
https://blog.docker.com/2017/10/least-privilege-container-orchestration/
|
在这篇文章中，我们将讨论容器编排器安全模型中没有考虑到的、但是很重要的这方面的详细情况，以及 Docker 企业版中如何使用内置的编排性能、Swarm 模式，去克服这些问题。
|
/data/attachment/album/201806/03/215723n53ak5ndex3bapnk.jpg.thumb.jpg
|
/data/attachment/album/201806/03/215723n53ak5ndex3bapnk.jpg
| true | false | true |
qhwdw
| false |
[
"容器",
"编排",
"Docker",
"Swarm"
] |
容器与云
|
{
"viewnum": 5541,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我们将讨论容器编排器安全模型中没有考虑到的、但是很重要的这方面的详细情况，以及 Docker 企业版中如何使用内置的编排性能、Swarm 模式，去克服这些问题。
| 2018-06-03T21:57:35 | 2018-06-03T21:57:35 | 9,712 |
/article-9712-1.html
|
Docker 平台和容器已经成为打包、部署、和管理应用程序的标准。为了在一个集群内协调跨节点的容器，必须有一个关键的能力：一个容器编排器。
对于关键的集群化以及计划的任务，编排器是起重大作用的，比如：
* 管理容器计划和资源分配。
* 支持服务发现和无缝的应用程序部署。
* 分配应用程序运行必需的资源。
不幸的是，在这种环境下，编排器的分布式特性和资源的短暂性使得确保编排器的安全是一个极具挑战性的任务。在这篇文章中，我们将讨论容器编排器安全模型中没有考虑到的、但是很重要的这方面的详细情况，以及 Docker 企业版中如何使用内置的编排性能、Swarm 模式，去克服这些问题。
### 诱因和威胁模型
使用 swarm 模式的 Docker 企业版的其中一个主要目标是提供一个内置安全特性的编排器。为达到这个目标，我们部署了第一个在我们心目中认为的以最小权限原则设计的容器编排器。
在计算机科学中，一个分布式系统所要求的最小权限原则是，系统中的每个参与者仅仅能访问它正当目的所需要的信息和资源。不是更多，也不是更少。
>
> “一个进程必须仅仅能去访问它的正当目的所需要的信息和资源”
>
>
>
#### 最小权限原则
在一个 Docker 企业版集群中的每个节点分配的角色：既不是管理者（manager），也不是工人（worker）。这些角色为节点定义了一个很粗粒度的权限级别：分别进行管理和任务执行。尽管如此，不用理会它的角色，通过使用加密的方式，来保证一个节点仅仅有执行它的任务所需要的信息和资源。结果是，确保集群安全变得更容易了，甚至可以防止大多数的有经验的攻击者模式：攻击者控制了底层通讯网络，或者甚至攻陷了集群节点。
### 内核缺省安全
这是一个很老的安全最大化状态：如果它不是缺省的，就没人用它。Docker Swarm 模式将缺省安全这一概念融入了核心，并且使用这一机制去解决编排器生命周期中三个很难并且很重要的部分：
1. 可信引导和节点引入。
2. 节点身份发布和管理。
3. 认证、授权和加密的信息存储和传播。
我们来分别看一下这三个部分：
#### 可信引导和节点引入
确保集群安全的第一步，没有别的，就是严格控制成员和身份。管理员不能依赖它们节点的身份，并且在节点之间强制实行绝对的负载隔离。这意味着，未授权的节点不能允许加入到集群中，并且，已经是集群一部分的节点不能改变身份，突然去伪装成另一个节点。
为解决这种情况，通过 Docker 企业版 Swarm 模式管理的节点，维护了健壮的、不可改变的身份。期望的特性是，通过使用两种关键的构建块去保证加密：
1. 为集群成员使用<ruby> 安全加入令牌 <rt> Secure join token </rt></ruby>。
2. 从一个集中化的认证机构发行的内嵌唯一身份的证书。
##### 加入 Swarm
要加入 Swarm，节点需要一份<ruby> 安全加入令牌 <rt> Secure join token </rt></ruby>的副本。在集群内的每个操作角色的令牌都是独一无二的 —— 现在有两种类型的节点：工人（workers）和管理者（managers）。由于这种区分，拥有一个工人令牌的节点将不允许以管理者角色加入到集群。唯一得到这个特殊令牌的方式是通过 swarm 的管理 API 去向集群管理者请求一个。
令牌是安全的并且是随机生成的，它还有一个使得令牌泄露更容易被检测到的特殊语法：一个可以在你的日志和仓库中很容易监视的特殊前缀。幸运的是，即便发现一个泄露，令牌也可以很容易去更新，并且，推荐你经常去更新它们 —— 特别是，在一段时间中你的集群不进行扩大的情况下。
##### 引导信任
作为它的身份标识创建的一部分，一个新的节点将向任意一个网络管理者请求发布一个新的身份。但是，在我们下面的威胁模型中，所有的通讯可以被一个第三方拦截。这种请求存在的问题是：一个节点怎么知道与它进行对话的对方是合法的管理者？
幸运的是，Docker 有一个内置机制可以避免这种情况。这个加入令牌被主机用于加入 Swarm，包含了一个根 CA 证书的哈希串。所以，主机可以使用单向 TLS，并且使用这个哈希串去验证它加入的 Swarm 是否正确：如果管理者持有的证书没有被正确的 CA 哈希串签名，节点就知道它不可信任。
#### 节点身份发布和管理
在一个 Swarm 中，身份标识是内嵌在每个节点都单独持有的一个 x509 证书中。在一个最小权限原则的表现形式中，证书的私钥被绝对限制在主机的原始位置。尤其是，管理者不能访问除了它自己的私钥以外的任何一个私钥。
##### 身份发布
要接收它们的证书而无需共享它们的私钥，新的主机通过发布一个证书签名请求（CSR）来开始，管理者收到证书签名请求之后，转换成一个证书。这个证书成为这个新的主机的身份标识，使这个节点成为 Swarm 的一个完全合格成员！
当和安全引导机制一起使用时，发行身份标识的这个机制来加入节点是缺省安全的：所有的通讯部分都是经过认证的、授权的，并且非敏感信息从来都不会以明文方式进行交换。
##### 身份标识延期
尽管如此，给一个 Swarm 中安全地加入节点，仅仅是 “故事” 的一部分。为降低证书的泄露或者失窃造成的影响，并且移除管理 CRL 列表的复杂性，Swarm 模式为身份标识使用了较短存活周期的证书。这些证书缺省情况下三个月后将过期，但是，也可以配置为一个小时后即刻过期！
较短的证书过期时间意味着不能手动去处理证书更新，所以，通常会使用一个 PKI 系统。对于 Swarm，所有的证书是以一种不中断的方式进行自动更新的。这个过程很简单：使用一个相互认证的 TLS 连接去证明一个特定身份标识的所有者，一个 Swarm 节点定期生成一个新的公钥/私钥密钥对，并且用相关的 CSR 去签名发送，创建一个维持相同身份标识的完整的新证书。
#### 经过认证、授权、和加密的信息存储和传播。
在一个正常的 Swarm 的操作中，关于任务的信息被发送给去运行的工人（worker）节点。这里不仅仅包含将被一个节点运行的容器的信息；也包含那个容器运行所必需的资源的所有信息，包括敏感的机密信息，比如，私钥、密码和 API 令牌。
##### 传输安全
事实上，参与 Swarm 的每个节点都拥有一个独一无二的 X509 格式的证书，因此，节点之间的通讯安全是没有问题的：节点使用它们各自的证书，与另一个连接方进行相互认证、继承机密、真实性、和 TLS 的完整性。
关于 Swarm 模式的一个有趣的细节是，本质上它是使用了一个推送模式：仅管理者被允许去发送信息到工人们（workers）—— 显著降低了暴露在低权限的工人节点面前的管理者节点的攻击面。
##### 将负载严格隔离进安全区域
管理者节点的其中一个责任是，去决定发送到每个工人（worker）节点的任务是什么。管理者节点使用多种策略去做这个决定；根据每个节点和每个负载的特性，去跨 Swarm 去安排负载。
在使用 Swarm 模式的 Docker 企业版中，管理者节点通过使用附加到每个单个节点标识上的安全标签，去影响这些安排决定。这些标签允许管理者将节点组与不同的安全区域连接到一起，以限制敏感负载暴露，以及使相关机密信息更安全。
##### 安全分发机密
除了加快身份标识发布过程之外，管理者节点还有存储和分发工人节点所需要的任何资源的任务。机密信息像任何其它类型的资源一样处理，并且基于安全的 mTLS 连接，从管理者推送到工人节点。
在主机上，Docker 企业版能确保机密仅提供给它们指定的容器。在同一个主机上的其它容器并不能访问它们。Docker 以一个临时文件系统的方式显露机密给一个容器，确保机密总是保存在内存中，并且从不写入到磁盘。这种方式比其它竞争的替代者更加安全，比如，[在环境变量中存储它们](https://diogomonica.com/2017/03/27/why-you-shouldnt-use-env-variables-for-secret-data/)。一旦这个任务完成，这个机密将永远消失。
##### 存储机密
在管理者主机上的机密总是保持加密的。缺省情况下，加密这些机密的密钥（被称为数据加密密钥，DEK）是以明文的方式存储在硬盘上的。这使得那些对安全性要求较低的人可以轻松地去使用 Docker Swarm 模式。
但是，如果你运行一个生产集群，我们推荐你启用自动锁定模式。当自动锁定模式启用后，一个重新更新过的 DEK 被一个独立的加密密钥的密钥（KEK）所加密。这个密钥从不被存储在集群中；管理者有责任将它存储在一个安全可靠的地方，并且当集群启动的时候可以提供它。这就是所谓的 “解锁” Swarm。
根据 Raft 故障容错一致性算法，Swarm 模式支持多个管理者。在这个场景中，无缝扩展了机密存储的安全性。每个管理者主机除了共享密钥之外，还有一个唯一的磁盘加密密钥。幸运的是，Raft 日志在磁盘上也是加密的，并且，在自动锁定模式下，没有 KEK 同样是不可访问的。
#### 当一个节点被攻陷后发生了什么？
在传统的编排器中，挽回一台被攻陷的主机是一个缓慢而复杂的过程。使用 Swarm 模式，恢复它就像运行一个 Docker 节点的 `rm` 命令一样容易。这是从集群中删除一个受影响的节点，而 Docker 将去处理剩下的事情，即，重新均衡负载，并且确保其它的主机已经知道，而不会去与受影响的节点通讯。
正如我们看到的那样，感谢最小权限的编排器，甚至是，如果攻击者在主机上持续活动，它们将被从剩余的网络上切断。主机的证书 —— 它的身份标识 —— 被列入黑名单，因此，管理者也不能有效访问它。
### 结论
使用 Swarm 模式的 Docker 企业版，在缺省情况下确保了编排器的所有关键区域的安全：
* 加入集群。阻止恶意节点加入到集群。
* 把主机分组为安全区域。阻止攻击者的横向移动。
* 安排任务。任务将仅被委派到允许的节点。
* 分配资源。恶意节点不能 “盗取” 其它的负载或者资源。
* 存储机密。从不明文保存并且从不写入到工人节点的磁盘上。
* 与工人节点的通讯。使用相互认证的 TLS 加密。
因为 Swarm 模式的持续改进，Docker 团队正在努力将最小权限原则进一步推进。我们正在处理的一个任务是：如果一个管理者被攻陷了，怎么去保证剩下的节点的安全？路线图已经有了，其中一些功能已经可以使用，比如，白名单功能，仅允许特定的 Docker 镜像，阻止管理者随意运行负载。这是通过 Docker 可信内容来实现的。
---
via: <https://blog.docker.com/2017/10/least-privilege-container-orchestration/>
作者：[Diogo Mónica](https://blog.docker.com/author/diogo/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Go 程序的持续分析
|
Jbd
|
https://medium.com/google-cloud/continuous-profiling-of-go-programs-96d4416af77b
|
Google 最有趣的部分之一就是我们规模庞大的持续分析服务。
|
/data/attachment/album/201806/04/110004y0orb4eeepzovqed.png.thumb.jpg
|
/data/attachment/album/201806/04/110004y0orb4eeepzovqed.png
| true | false | true |
geekpi
| false |
[
"优化",
"Go"
] |
技术
|
{
"viewnum": 7898,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Google 最有趣的部分之一就是我们规模庞大的持续分析服务。
| 2018-06-04T11:00:21 | 2018-06-04T11:00:21 | 9,713 |
/article-9713-1.html
|
Google 最有趣的部分之一就是我们规模庞大的持续分析服务。我们可以看到谁在使用 CPU 和内存，我们可以持续地监控我们的生产服务以争用和阻止配置文件，并且我们可以生成分析和报告，并轻松地告诉我们可以进行哪些有重要影响的优化。
我简单研究了 [Stackdriver Profiler](https://cloud.google.com/profiler/)，这是我们的新产品，它填补了针对云端用户在云服务范围内分析服务的空白。请注意，你无需在 Google 云平台上运行你的代码即可使用它。实际上，我现在每天都在开发时使用它。它也支持 Java 和 Node.js。
### 在生产中分析
pprof 可安全地用于生产。我们针对 CPU 和堆分配分析的额外会增加 5% 的开销。一个实例中每分钟收集 10 秒。如果你有一个 Kubernetes Pod 的多个副本，我们确保进行分摊收集。例如，如果你拥有一个 pod 的 10 个副本，模式，那么开销将变为 0.5％。这使用户可以一直进行分析。
我们目前支持 Go 程序的 CPU、堆、互斥和线程分析。
### 为什么？
在解释如何在生产中使用分析器之前，先解释为什么你想要在生产中进行分析将有所帮助。一些非常常见的情况是：
* 调试仅在生产中可见的性能问题。
* 了解 CPU 使用率以减少费用。
* 了解争用的累积和优化的地方。
* 了解新版本的影响，例如看到 canary 和产品级之间的区别。
* 通过[关联](https://rakyll.org/profiler-labels/)分析样本以了解延迟的根本原因来丰富你的分布式经验。
### 启用
Stackdriver Profiler 不能与 `net/http/pprof` 处理程序一起使用，并要求你在程序中安装和配置一个一行的代理。
```
go get cloud.google.com/go/profiler
```
在你的主函数中，启动分析器：
```
if err := profiler.Start(profiler.Config{
Service: "indexing-service",
ServiceVersion: "1.0",
ProjectID: "bamboo-project-606", // optional on GCP
}); err != nil {
log.Fatalf("Cannot start the profiler: %v", err)
}
```
当你运行你的程序后，profiler 包将每分钟报告给分析器 10 秒钟。
### 可视化
当分析被报告给后端后，你将在 <https://console.cloud.google.com/profiler> 上看到火焰图。你可以按标签过滤并更改时间范围，也可以按服务名称和版本进行细分。数据将会长达 30 天。
你可以选择其中一个分析，按服务，区域和版本分解。你可以在火焰中移动并通过标签进行过滤。
### 阅读火焰图
[Brendan Gregg](http://www.brendangregg.com/flamegraphs.html) 非常全面地解释了火焰图可视化。Stackdriver Profiler 增加了一点它自己的特点。
我们将查看一个 CPU 分析，但这也适用于其他分析。
1. 最上面的 x 轴表示整个程序。火焰上的每个框表示调用路径上的一帧。框的宽度与执行该函数花费的 CPU 时间成正比。
2. 框从左到右排序，左边是花费最多的调用路径。
3. 来自同一包的帧具有相同的颜色。这里所有运行时功能均以绿色表示。
4. 你可以单击任何框进一步展开执行树。
你可以将鼠标悬停在任何框上查看任何帧的详细信息。
### 过滤
你可以显示、隐藏和高亮符号名称。如果你特别想了解某个特定调用或包的消耗，这些信息非常有用。
1. 选择你的过滤器。你可以组合多个过滤器。在这里，我们将高亮显示 `runtime.memmove`。
2. 火焰将使用过滤器过滤帧并可视化过滤后的框。在这种情况下，它高亮显示所有 `runtime.memmove` 框。
---
via: <https://medium.com/google-cloud/continuous-profiling-of-go-programs-96d4416af77b>
作者：[JBD](https://medium.com/@rakyll?source=post_header_lockup) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 Arduino 制作一个绘图仪
|
Heiko W.rupp
|
https://opensource.com/article/18/3/diy-plotter-arduino
|
使用开源硬件和软件的 DIY 绘图仪可以自动地绘制、雕刻。
|
/data/attachment/album/201806/04/201132zgx6x2yqywrwyucq.png.thumb.jpg
|
/data/attachment/album/201806/04/201132zgx6x2yqywrwyucq.png
| true | false | true |
qhwdw
| false |
[
"Arduino",
"绘图仪"
] |
树莓派
|
{
"viewnum": 9949,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用开源硬件和软件的 DIY 绘图仪可以自动地绘制、雕刻。
| 2018-06-04T20:11:26 | 2018-06-04T20:11:26 | 9,714 |
/article-9714-1.html
|
>
> 使用开源硬件和软件的 DIY 绘图仪可以自动地绘制、雕刻。
>
>
>
在上学时，科学系的壁橱里藏着一台惠普绘图仪。虽然我在上学的期间可以经常使用它，但我还是想拥有一台属于自己的绘图仪。许多年之后，步进电机已经很容易获得了，我又在从事电子产品和微控制器方面的工作，最近，我看到有人用丙烯酸塑料（acrylic）制作了一个显示器。这件事启发了我，并最终制作了我自己的绘图仪。
*我 DIY 的绘图仪；在这里看它工作的[视频](https://twitter.com/pilhuhn/status/948205323726344193)。*
由于我是一个很怀旧的人，我真的很喜欢最初的 [Arduino Uno](https://en.wikipedia.org/wiki/Arduino#Official_boards)。下面是我用到的其它东西的一个清单（仅供参考，其中一些我也不是很满意）：
* [FabScan shield](http://www.watterott.com/de/Arduino-FabScan-Shield)：承载步进电机驱动器。
* [SilentStepSticks](http://www.watterott.com/de/SilentStepStick-TMC2130)：步进电机驱动器，因为 Arduino 自身不能处理步进电机所需的电压和电流。因此我使用了一个 Trinamic TMC2130 芯片，但它是工作在单独模式。这些替换为 Pololu 4988，但是它们运转更安静。
* [SilentStepStick 保护装置](http://www.watterott.com/de/SilentStepStick-Protector)：一个防止你的电机驱动器转动过快的二极管（相信我，你肯定会需要它的）。
* 步进电机：我选择的是使用 12 V 电压的 NEMA 17 电机（如，来自 [Watterott](http://www.watterott.com/de/Schrittmotor-incl-Anschlusskabel) 和 [SparkFun](https://www.sparkfun.com/products/9238) 的型号）。
* [直线导杆](https://www.ebay.de/itm/CNC-Set-12x-600mm-Linearfuhrung-Linear-Guide-Rail-Stage-3D-/322917927292?hash=item4b2f68897c)
* 木制的基板
* 木螺丝
* GT2 皮带
* [GT2 同步滑轮](http://www.watterott.com/de/OpenBuilds-GT2-2mm-Aluminium-Timing-Pulley)
这是我作为个人项目而设计的。如果你想找到一个现成的工具套件，你可以从 German Make 杂志上找到 [MaXYposi](https://www.heise.de/make/artikel/MaXYposi-Projektseite-zum-universellen-XY-Portalroboter-von-Make-3676050.html)。
### 硬件安装
正如你所看到的，我刚开始做的太大了。这个绘图仪并不合适放在我的桌子上。但是，没有关系，我只是为了学习它（并且，我也将一些东西进行重新制作，下次我将使用一个更小的横梁）。
*带 X 轴和 Y 轴轨道的绘图仪基板*
皮带安装在轨道的侧面，并且用它将一些辅助轮和电机挂在一起：
*电机上的皮带路由*
我在 Arduino 上堆叠了几个组件。Arduino 在最下面，它之上是 FabScan shield，接着是一个安装在 1 和 2 号电机槽上的 StepStick 保护装置，SilentStepStick 在最上面。注意，SCK 和 SDI 针脚没有连接。
*Arduino 堆叠配置（[高清大图](https://www.dropbox.com/s/7bp3bo5g2ujser8/IMG_20180103_110111.jpg?dl=0)）*
注意将电机的连接线接到正确的针脚上。如果有疑问，就去查看它的数据表，或者使用欧姆表去找出哪一对线是正确的。
### 软件配置
#### 基础部分
虽然像 [grbl](https://github.com/gnea/grbl) 这样的软件可以解释诸如像装置移动和其它一些动作的 G-codes，并且，我也可以将它刷进 Arduino 中，但是我很好奇，想更好地理解它是如何工作的。（我的 X-Y 绘图仪软件可以在 [GitHub](https://github.com/pilhuhn/xy-plotter) 上找到，不过我不提供任何保修。）
使用 StepStick（或者其它兼容的）驱动器去驱动步进电机，基本上只需要发送一个高电平信号或者低电平信号到各自的针脚即可。或者使用 Arduino 的术语：
```
digitalWrite(stepPin, HIGH);
delayMicroseconds(30);
digitalWrite(stepPin, LOW);
```
在 `stepPin` 的位置上是步进电机的针脚编号：3 是 1 号电机，而 6 是 2 号电机。
在步进电机能够工作之前，它必须先被启用。
```
digitalWrite(enPin, LOW);
```
实际上，StepStick 能够理解针脚的三个状态：
* Low：电机已启用
* High：电机已禁用
* Pin 未连接：电机已启用，但在一段时间后进入节能模式
电机启用后，它的线圈已经有了力量并用来保持位置。这时候几乎不可能用手来转动它的轴。这样可以保证很好的精度，但是也意味着电机和驱动器芯片都“充满着”力量，并且也因此会发热。
最后，也是很重要的，我们需要一个决定绘图仪方向的方法：
```
digitalWrite(dirPin, direction);
```
下面的表列出了功能和针脚：
| 功能 | 1 号电机 | 2 号电机 |
| --- | --- | --- |
| 启用 | 2 | 5 |
| 方向 | 4 | 7 |
| 步进 | 3 | 6 |
在我们使用这些针脚之前，我们需要在代码的 `setup()` 节中设置它的 `OUTPUT` 模式。
```
pinMode(enPin1, OUTPUT);
pinMode(stepPin1, OUTPUT);
pinMode(dirPin1, OUTPUT);
digitalWrite(enPin1, LOW);
```
了解这些知识后，我们可以很容易地让步进电机四处移动：
```
totalRounds = ...
for (int rounds =0 ; rounds < 2*totalRounds; rounds++) {
if (dir==0){ // set direction
digitalWrite(dirPin2, LOW);
} else {
digitalWrite(dirPin2, HIGH);
}
delay(1); // give motors some breathing time
dir = 1-dir; // reverse direction
for (int i=0; i < 6400; i++) {
int t = abs(3200-i) / 200;
digitalWrite(stepPin2, HIGH);
delayMicroseconds(70 + t);
digitalWrite(stepPin2, LOW);
delayMicroseconds(70 + t);
}
}
```
这将使滑块向左和向右移动。这些代码只操纵一个步进电机，但是，对于一个 X-Y 绘图仪，我们要考虑两个轴。
#### 命令解释器
我开始做一个简单的命令解释器去使用规范的路径，比如：
```
"X30|Y30|X-30 Y-30|X-20|Y-20|X20|Y20|X-40|Y-25|X40 Y25
```
用毫米来描述相对移动（1 毫米等于 80 步）。
绘图仪软件实现了一个 *持续模式* ，这可以允许一台 PC 给它提供一个很大的路径（很多的路径）去绘制。（在这个[视频](https://twitter.com/pilhuhn/status/949737734654124032)中展示了如何绘制 Hilbert 曲线）
### 设计一个好用的握笔器
在上面的第一张图中，绘图笔是细绳子绑到 Y 轴上的。这样绘图也不精确，并且也无法在软件中实现提笔和下笔（如示例中的大黑点）。
因此，我设计了一个更好用的、更精确的握笔器，它使用一个伺服器去提笔和下笔。可以在下面的这张图中看到这个新的、改进后的握笔器，上面视频链接中的 Hilbert 曲线就是使用它绘制的。
*图中的特写镜头就是伺服器臂提起笔的图像*
笔是用一个小夹具固定住的（图上展示的是一个大小为 8 的夹具，它一般用于将线缆固定在墙上）。伺服器臂能够提起笔；当伺服器臂放下来的时候，笔就会被放下来。
#### 驱动伺服器
驱动伺服器是非常简单的：只需要提供位置，伺服器就可以完成所有的工作。
```
#include <Servo.h>
// Servo pin
#define servoData PIN_A1
// Positions
#define PEN_UP 10
#define PEN_DOWN 50
Servo penServo;
void setup() {
// Attach to servo and raise pen
penServo.attach(servoData);
penServo.write(PEN_UP);
}
```
我把伺服器接头连接在 FabScan shield 的 4 号电机上，因此，我将用 1 号模拟针脚。
放下笔也很容易：
```
penServo.write(PEN_DOWN);
```
### 进一步扩展
我的进一步扩展的其中一项就是添加一些终止检测器，但是，我也可以不用它们，进而使用 TMC2130 的 StallGuard 模式来代替。这些检测器也可以用于去实现一个 `home` 命令。
以后，我或许还将添加一个真实的 Z 轴，这样它就可以对一个木头进行铣削雕刻，或者钻一个 PCB 板，或者雕刻一块丙烯酸塑料，或者 … （我还想到了用激光）。
这篇文章最初发布在 [Some Things to Remember](http://pilhuhn.blogspot.com/2018/01/homegrown-xy-plotter-with-arduino.html) 博客中并授权重分发。
---
via: <https://opensource.com/article/18/3/diy-plotter-arduino>
作者：[Heiko W.Rupp](https://opensource.com/users/pilhuhn) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 系统中结束进程或是中止程序
|
Sachin Patil
|
https://opensource.com/article/18/5/how-kill-process-stop-program-linux
|
在 Linux 中有几种使用命令行或图形界面终止一个程序的方式。
|
/data/attachment/album/201806/04/221410kjzxqzhnwxy5ng6n.jpg.thumb.jpg
|
/data/attachment/album/201806/04/221410kjzxqzhnwxy5ng6n.jpg
| true | false | true |
CYLeft
| false |
[
"kill",
"killall"
] |
技术
|
{
"viewnum": 41962,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 Linux 中有几种使用命令行或图形界面终止一个程序的方式。
| 2018-06-04T22:14:00 | 2018-06-04T22:14:00 | 9,715 |
/article-9715-1.html
|
>
> 在 Linux 中有几种使用命令行或图形界面终止一个程序的方式。
>
>
>
进程出错的时候，您可能会想要中止或是杀掉这个进程。在本文中，我们将探索在命令行和图形界面中终止进程或是应用程序，这里我们使用 [gedit](https://wiki.gnome.org/Apps/Gedit) 作为样例程序。
### 使用命令行或字符终端界面
#### Ctrl + C
在命令行中调用 `gedit` （如果您没有使用 `gedit &` 命令）程序的一个问题是 shell 会话被阻塞，没法释放命令行提示符。在这种情况下，`Ctrl + C` （`Ctrl` 和 `C` 的组合键） 会很管用。这会终止 `gedit` ，并且所有的工作都将丢失（除非文件已经被保存）。`Ctrl + C` 会给 `gedit` 发送了 `SIGINT` 信号。这是一个默认终止进程的停止信号，它将指示 shell 停止 `gedit` 的运行，并返回到主函数的循环中，您将返回到提示符。
```
$ gedit
^C
```
#### Ctrl + Z
它被称为挂起字符。它会发送 `SIGTSTP` 信号给进程。它也是一个停止信号，但是默认行为不是杀死进程，而是挂起进程。
下面的命令将会停止（杀死/中断） `gedit` 的运行，并返回到 shell 提示符。
```
$ gedit
^Z
[1]+ Stopped gedit
$
```
一旦进程被挂起（以 `gedit` 为例），将不能在 `gedit` 中写入或做任何事情。而在后台，该进程变成了一个作业，可以使用 `jobs` 命令验证。
```
$ jobs
[1]+ Stopped gedit
```
`jobs` 允许您在单个 shell 会话中控制多个进程。您可以终止，恢复作业，或是根据需要将作业移动到前台或是后台。
让我们在后台恢复 `gedit`，释放提示符以运行其它命令。您可以通过 `bg` 命令来做到，后跟作业 ID（注意上面的 `jobs` 命令显示出来的 `[1]`，这就是作业 ID）。
```
$ bg 1
[1]+ gedit &
```
这和直接使用 `gedit &` 启动程序效果差不多：
```
$ gedit &
```
### 使用 kill
`kill` 命令提供信号的精确控制，允许您通过指定信号名或是信号数字为进程发送信号，后跟进程 ID 或是 PID。
我喜欢 `kill` 命令的一点是它也能够根据作业 ID 控制进程。让我们使用 `gedit &` 命令在后台开启 `gedit` 服务。假设通过 `jobs` 命令我得到了一个 `gedit` 的作业 ID，让我们为 `gedit` 发送 `SIGINT` 信号：
```
$ kill -s SIGINT %1
```
作业 ID 需要使用 `%` 前缀，不然 `kill` 会将其视作 PID。
不明确指定信号，`kill` 仍然可以工作。此时，默认会发送能中断进程的 `SIGTERM` 信号。执行 `kill -l` 可以查看信号名列表，使用 `man kill` 命令阅读手册。
### 使用 killall
如果您不想使用特定的工作 ID 或者 PID，`killall` 允许您使用特定的进程名。中断 `gedit` 最简单的 `killall` 使用方式是：
```
$ killall gedit
```
它将终止所有名为 `gedit` 的进程。和 `kill` 相似，默认发送的信号是 `SIGTERM`。使用 `-I` 选项忽略进程名的大小写。
```
$ gedit &
[1] 14852
$ killall -I GEDIT
[1]+ Terminated gedit
```
查看手册学习更多 `killall` 命令选项（如 `-u`）。
### 使用 xkill
您是否遇见过播放器崩溃，比如 [VLC](https://www.videolan.org/vlc/index.html) 灰屏或挂起？现在你可以像上面一样获得进程的 PID 来杀掉它，或者使用 `xkill` 命令终止应用程序。
`xkill` 允许您使用鼠标关闭窗口。仅需在终端执行 `xkill` 命令，它将会改变鼠标光标为一个 **X** 或是一个小骷髅图标。在你想关闭的进程窗口上点击 **x**。小心使用 `xkill`，如手册描述的一致，它很危险。我已经提醒过您了！
参阅手册，了解上述命令更多信息。您还可以接续探索 `pkill` 和 `pgrep` 命令。
---
via: <https://opensource.com/article/18/5/how-kill-process-stop-program-linux>
作者：[Sachin Patil](https://opensource.com/users/psachin) 选题：[lujun9972](https://github.com/lujun9972) 译者：[CYLeft](https://github.com/CYLeft) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
3 个 Python 模板库比较
|
Jason Baker
|
https://opensource.com/resources/python/template-libraries
|
你的下一个 Python 项目需要一个模板引擎来自动生成 HTML 吗？这有几种选择。
|
/data/attachment/album/201806/04/223936dcd4s2zszs4g3qu1.png.thumb.jpg
|
/data/attachment/album/201806/04/223936dcd4s2zszs4g3qu1.png
| true | false | true |
MjSeven
| false |
[
"Python",
"模板"
] |
软件开发
|
{
"viewnum": 8628,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你的下一个 Python 项目需要一个模板引擎来自动生成 HTML 吗？这有几种选择。
| 2018-06-05T08:38:00 | 2018-06-05T08:38:00 | 9,716 |
/article-9716-1.html
|
>
> 你的下一个 Python 项目需要一个模板引擎来自动生成 HTML 吗？这有几种选择。
>
>
>
在我的日常工作中，我花费大量的时间将各种来源的数据转化为可读的信息。虽然很多时候这只是电子表格或某种类型的图表或其他数据可视化的形式，但也有其他时候，将数据以书面形式呈现是有意义的。
但我的头疼地方就是复制和粘贴。如果你要将数据从源头移动到标准化模板，则不应该复制和粘贴。这很容易出错，说实话，这会浪费你的时间。
因此，对于我定期发送的任何遵循一个共同的模式的信息，我倾向于找到某种方法来自动化至少一部分信息。也许这涉及到在电子表格中创建一些公式，一个快速 shell 脚本或其他解决方案，以便使用从外部源提取的信息自动填充模板。
但最近，我一直在探索 Python 模板来完成从其他数据集创建报告和图表的大部分工作。
Python 模板引擎非常强大。我的简化报告创建的使用案例仅仅触及了它的皮毛。许多开发人员正在利用这些工具来构建完整的 web 应用程序和内容管理系统。但是，你并不需要有一个复杂的 web 应用程序才能使用 Python 模板工具。
### 为什么选择模板？
每个模板工具都不甚相同，你应该阅读文档以了解其确切的用法。但让我们创建一个假设的例子。假设我想创建一个简短的页面，列出我最近编写的所有 Python 主题。就像这样：
```
<html>
<head>
<title>My Python articles</title>
</head>
<body>
<p>These are some of the things I have written about Python:</p>
<ul>
<li>Python GUIs</li>
<li>Python IDEs</li>
<li>Python web scrapers</li>
</ul>
</body>
</html>
```
当它仅仅是这三个项目时，维护它是很简单的。但是当我想添加第四个、第五个或第六十七个时会发生什么？我可以从包含我所有页面列表的 CSV 文件或其他数据文件生成它，而不是手动编码此页面吗？我可以轻松地为我写的每个主题创建重复内容吗？我可以以编程方式更改每个页面上的文本标题吗？这就是模板引擎可以发挥作用的地方。
有许多不同的选择，今天我将与你其中分享三个，顺序不分先后：[Mako](http://www.makotemplates.org/)、 [Jinja2](http://jinja.pocoo.org/) 和 [Genshi](https://genshi.edgewall.org/)。
### Mako
[Mako](http://www.makotemplates.org/) 是以 MIT 许可证发布的 Python 模板工具，专为快速展现而设计的（与 Jinja2 不同）。Reddit 已经使用 Mako 来展现他们的网页，它同时也是 Pyramid 和 Pylons 等 web 框架的默认模板语言。它相当简单且易于使用。你可以使用几行代码来设计模板；支持 Python 2.x 和 3.x，它是一个功能强大且功能丰富的工具，具有[良好的文档](http://docs.makotemplates.org/en/latest/)，这一点我认为是必须的。其功能包括过滤器、继承、可调用块和内置缓存系统，这些系统可以被大型或复杂的 web 项目导入。
### Jinja2
Jinja2 是另一个快速且功能全面的选项，可用于 Python 2.x 和 3.x，遵循 BSD 许可证。Jinja2 从功能角度与 Mako 有很多重叠，因此对于新手来说，你在两者之间的选择可能会归结为你喜欢的格式化风格。Jinja2 还将模板编译为字节码，并具有 HTML 转义、沙盒、模板继承和模板沙盒部分的功能。其用户包括 Mozilla、 SourceForge、 NPR、 Instagram 等，并且还具有[强大的文档](http://jinja.pocoo.org/docs/2.10/)。与 Mako 在模板内部使用 Python 逻辑不同的是，Jinja2 使用自己的语法。
### Genshi
[Genshi](https://genshi.edgewall.org/) 是我会提到的第三个选择。它是一个 XML 工具，具有强大的模板组件，所以如果你使用的数据已经是 XML 格式，或者你需要使用网页以外的格式，Genshi 可能成为你的一个很好的解决方案。HTML 基本上是一种 XML（好吧，不是精确的，但这超出了本文的范围，有点卖弄学问了），因此格式化它们非常相似。由于我通常使用的很多数据都是 XML 或其他类型的数据，因此我非常喜欢使用我可以用于多种事物的工具。
发行版目前仅支持 Python 2.x，尽管 Python 3 支持存在于主干中，但我提醒你，它看起来并没有得到有效的开发。Genshi 遵循 BSD 许可证提供。
### 示例
因此，在上面的假设示例中，我不会每次写新主题时都更新 HTML 文件，而是通过编程方式对其进行更新。我可以创建一个模板，如下所示：
```
<html>
<head>
<title>My Python articles</title>
</head>
<body>
<p>These are some of the things I have written about Python:</p>
<ul>
%for topic in topics:
<li>${topic}</li>
%endfor
</ul>
</body>
</html>
```
然后我可以使用我的模板库来迭代每个主题，比如使用 Mako，像这样：
```
from mako.template import Template
mytemplate = Template(filename='template.txt')
print(mytemplate.render(topics=("Python GUIs","Python IDEs","Python web scrapers")))
```
当然，在现实世界的用法中，我不会将这些内容手动地列在变量中，而是将它们从外部数据源（如数据库或 API）中提取出来。
这些不是仅有的 Python 模板引擎。如果你正在开始创建一个将大量使用模板的新项目，那么你考虑的可能不仅仅是这三种选择。在 [Python 维基](https://wiki.python.org/moin/Templating)上查看更全面的列表，以获得更多值得考虑的项目。
---
via: <https://opensource.com/resources/python/template-libraries>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 选题：[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/) 荣誉推出
|
||
Linux vs. Unix：有什么不同？
|
Phil Estes
|
https://opensource.com/article/18/5/differences-between-linux-and-unix
|
深入了解这两个有许多共同的传统和相同的目标的操作系统之间的不同。
|
/data/attachment/album/201806/05/221628zcsu1oi3ofe6ei1c.jpg.thumb.jpg
|
/data/attachment/album/201806/05/221628zcsu1oi3ofe6ei1c.jpg
| true | false | true |
MjSeven
| true |
[
"Unix",
"Linux"
] |
观点
|
{
"viewnum": 14183,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
深入了解这两个有许多共同的传统和相同的目标的操作系统之间的不同。
| 2018-06-05T22:16:45 | 2018-06-05T22:16:45 | 9,717 |
/article-9717-1.html
|
>
> 深入了解这两个有许多共同的传统和相同的目标的操作系统之间的不同。
>
>
>
如果你是位二、三十岁的软件开发人员，那么你已经成长在一个由 Linux 主导的世界。数十年来，它一直是数据中心的重要参与者，尽管很难找到明确的操作系统市场份额报告，但 Linux 的数据中心操作系统份额可能高达 70%，而 Windows 及其变体几乎涵盖了所有剩余的百分比。使用任何主流公共云服务的开发人员都可以预期目标系统会运行 Linux。近些年来，随着 Android 和基于 Linux 的嵌入式系统在智能手机、电视、汽车和其他设备中的应用，Linux 已经随处可见。
即便如此，大多数软件开发人员，甚至是那些在这场历史悠久的 “Linux 革命”中长大的软件开发人员，也都听过说 Unix。它听起来与 Linux 相似，你可能已经听到人们互换使用这些术语。或者你也许听说过 Linux 被称为“类 Unix ”操作系统。
那么，Unix 是什么？漫画中提到了像巫师一样留着“灰胡子”，坐在发光的绿色屏幕后面，写着 C 代码和 shell 脚本，由老式的、滴灌的咖啡提供动力。但是，Unix 的历史比上世纪 70 年代那些留着胡子的 C 程序员要丰富得多。虽然详细介绍 Unix 历史和 “Unix 与 Linux” 比较的文章比比皆是，但本文将提供高级背景和列出这些互补世界之间的主要区别。
### Unix 的起源
Unix 的历史始于 20 世纪 60 年代后期的 AT&T 贝尔实验室，有一小组程序员希望为 PDP-7 编写一个多任务、多用户操作系统。这个贝尔实验室研究机构的团队中最著名的两名成员是 Ken Thompson 和 Dennis Ritchie。尽管 Unix 的许多概念都是其前身（[Multics](https://en.wikipedia.org/wiki/Multics)）的衍生物，但 Unix 团队早在 70 年代就决定用 C 语言重写这个小型操作系统，这是将 Unix 与其他操作系统区分开来的原因。当时，操作系统很少，更不要说可移植的操作系统。相反，由于它们的设计和底层语言的本质，操作系统与他们所编写的硬件平台紧密相关。而通过 C 语言重构 Unix、Unix 现在可以移植到许多硬件体系结构中。
除了这种新的可移植性，之所以使得 Unix 迅速扩展到贝尔实验室以外的其他研究和学术机构甚至商业用途，是因为操作系统设计原则的几个关键点吸引了用户和程序员们。首先是 Ken Thompson 的 [Unix 哲学](https://en.wikipedia.org/wiki/Unix_philosophy)成为模块化软件设计和计算的强大模型。Unix 哲学推荐使用小型的、专用的程序组合起来完成复杂的整体任务。由于 Unix 是围绕文件和管道设计的，因此这种“管道”模式的输入和输出程序的组合成一组线性的输入操作，现在仍然流行。事实上，目前的云功能即服务（FaaS）或无服务器计算模型要归功于 Unix 哲学的许多传统。
### 快速增长和竞争
到 70 年代末和 80 年代，Unix 成为了一个操作系统家族的起源，它遍及了研究和学术机构以及日益增长的商业 Unix 操作系统业务领域。Unix 不是开源软件，Unix 源代码可以通过与它的所有者 AT&T 达成协议来获得许可。第一个已知的软件许可证于 1975 年出售给<ruby> 伊利诺伊大学 <rt> University of Illinois </rt></ruby>。
Unix 在学术界迅速发展，在 Ken Thompson 在上世纪 70 年代的学术假期间，伯克利成为一个重要的活动中心。通过在伯克利的各种有关 Unix 的活动，Unix 软件的一种新的交付方式诞生了：<ruby> 伯克利软件发行版 <rt> Berkeley Software Distribution </rt></ruby>（BSD）。最初，BSD 不是 AT&T Unix 的替代品，而是一种添加类似于附加软件和功能。在 1979 年， 2BSD（第二版伯克利软件发行版）出现时，伯克利研究生 Bill Joy 已经添加了现在非常有名的程序，例如 `vi` 和 C shell（`/bin/csh`）。
除了成为 Unix 家族中最受欢迎的分支之一的 BSD 之外，Unix 的商业产品的爆发贯穿了二十世纪八、九十年代，其中包括 HP-UX、IBM 的 AIX、 Sun 的 Solaris、 Sequent 和 Xenix 等。随着分支从根源头发展壮大，“[Unix 战争](https://en.wikipedia.org/wiki/Unix_wars)”开始了，标准化成为社区的新焦点。POSIX 标准诞生于 1988 年，其他标准化后续工作也开始通过 The Open Group 在 90 年代到来。
在此期间，AT&T 和 Sun 发布了 System V Release 4（SVR4），许多商业供应商都采用了这一版本。另外，BSD 系列操作系统多年来一直在增长，最终一些开源的变体在现在熟悉的 [BSD许可证](https://en.wikipedia.org/wiki/BSD_licenses)下发布。这包括 FreeBSD、 OpenBSD 和 NetBSD，每个在 Unix 服务器行业的目标市场略有不同。这些 Unix 变体今天仍然有一些在使用，尽管人们已经看到它们的服务器市场份额缩小到个位数字（或更低）。在当今的所有 Unix 系统中，BSD 可能拥有最大的安装基数。另外，每台 Apple Mac 硬件设备从历史的角度看都可以算做是 BSD ，这是因为 OS X（现在是 macOS）操作系统是 BSD 衍生产品。
虽然 Unix 的全部历史及其学术和商业变体可能需要更多的篇幅，但为了我们文章的重点，让我们来讨论 Linux 的兴起。
### 进入 Linux
今天我们所说的 Linux 操作系统实际上是 90 年代初期的两个努力的结合。Richard Stallman 希望创建一个真正的自由而开放源代码的专有 Unix 系统的替代品。他正在以 GNU 的名义开发实用程序和程序，这是一种递归的说法，意思是“GNU‘s not Unix!”。虽然当时有一个内核项目正在进行，但事实证明这是一件很困难的事情，而且没有内核，自由和开源操作系统的梦想无法实现。而这是 Linus Torvald 的工作 —— 生产出一种可工作和可行的内核，他称之为 Linux -- 它将整个操作系统带入了生活。鉴于 Linus 使用了几个 GNU 工具（例如 GNU 编译器集合，即 [GCC](https://en.wikipedia.org/wiki/GNU_Compiler_Collection)），GNU 工具和 Linux 内核的结合是完美的搭配。
Linux 发行版采用了 GNU 的组件、Linux 内核、MIT 的 X-Windows GUI 以及可以在开源 BSD 许可下使用的其它 BSD 组件。像 Slackware 和 Red Hat 这样的发行版早期的流行给了 20 世纪 90 年代的“普通 PC 用户”一个进入 Linux 操作系统的机会，并且让他们在工作和学术生活中可以使用许多 Unix 系统特有的功能和实用程序。
由于所有 Linux 组件都是自由和开放的源代码，任何人都可以通过一些努力来创建一个 Linux 发行版，所以不久后发行版的总数达到了数百个。今天，[distrowatch.com](https://distrowatch.com/) 列出了 312 种各种形式的独特的 Linux 发行版。当然，许多开发人员通过云提供商或使用流行的免费发行版来使用 Linux，如 Fedora、 Canonical 的 Ubuntu、 Debian、 Arch Linux、 Gentoo 和许多其它变体。随着包括 IBM 在内的许多企业从专有 Unix 迁移到 Linux 上并提供了中间件和软件解决方案，商用 Linux 产品在自由和开源组件之上提供支持变得可行。红帽公司围绕 Red Hat Enterprise Linux（红帽企业版 Linux） 建立了商业支持模式，德国供应商 SUSE 使用 SUSE Linux Enterprise Server（SLES）也提供了这种模式。
### 比较 Unix 和 Linux
到目前为止，我们已经了解了 Unix 的历史以及 Linux 的兴起，以及 GNU/自由软件基金会对 Unix 的自由和开源替代品的支持。让我们来看看这两个操作系统之间的差异，它们有许多共同的传统和许多相同的目标。
从用户体验角度来看，两者差不多！Linux 的很大吸引力在于操作系统在许多硬件体系结构（包括现代 PC）上的可用性以及类似使用 Unix 系统管理员和用户熟悉的工具的能力。
由于 POSIX 的标准和合规性，在 Unix 上编写的软件可以针对 Linux 操作系统进行编译，通常只有少量的移植工作量。在很多情况下，Shell 脚本可以在 Linux 上直接使用。虽然一些工具在 Unix 和 Linux 之间有着略微不同的标志或命令行选项，但许多工具在两者上都是相同的。
一方面要注意的是，macOS 硬件和操作系统作为主要针对 Linux 的开发平台的流行可能归因于类 BSD 的 macOS 操作系统。许多用于 Linux 系统的工具和脚本可以在 macOS 终端内轻松工作。Linux 上的许多开源软件组件都可以通过 [Homebrew](https://brew.sh/) 等工具轻松获得。
Linux 和 Unix 之间的其他差异主要与许可模式有关：开源与专有许可软件。另外，在 Unix 发行版中缺少一个影响软件和硬件供应商的通用内核。对于 Linux，供应商可以为特定的硬件设备创建设备驱动程序，并期望在合理的范围内它可以在大多数发行版上运行。由于 Unix 家族的商业和学术分支，供应商可能必须为 Unix 的变体编写不同的驱动程序，并且需要许可和其他相关的权限才能访问 SDK 或软件的分发模型，以跨越多个二进制设备驱动程序的 Unix 变体。
随着这两个社区在过去十年中的成熟，Linux 的许多优点已经在 Unix 世界中被采用。当开发人员需要来自不属于 Unix 的 GNU 程序的功能时，许多 GNU 实用程序可作为 Unix 系统的附件提供。例如，IBM 的 AIX 为 Linux 应用程序提供了一个 AIX Toolbox，其中包含数百个 GNU 软件包（如 Bash、 GCC、 OpenLDAP 和许多其他软件包），这些软件包可添加到 AIX 安装包中以简化 Linux 和基于 Unix 的 AIX 系统之间的过渡。
专有的 Unix 仍然活着而且还不错，许多主要供应商承诺支持其当前版本，直到 2020 年。不言而喻，Unix 还会在可预见的将来一直出现。此外，Unix 的 BSD 分支是开源的，而 NetBSD、 OpenBSD 和 FreeBSD 都有强大的用户基础和开源社区，它们可能不像 Linux 那样显眼或活跃，但在最近的服务器报告中，在 Web 服务等领域它们远高于专有 Unix 的数量。
Linux 已经显示出其超越 Unix 的显著优势在于其在大量硬件平台和设备上的可用性。<ruby> 树莓派 <rt> Raspberry Pi </rt></ruby>受到业余爱好者的欢迎，它是由 Linux 驱动的，为运行 Linux 的各种物联网设备打开了大门。我们已经提到了 Android 设备，汽车（包括 Automotive Grade Linux）和智能电视，其中 Linux 占有巨大的市场份额。这个星球上的每个云提供商都提供运行 Linux 的虚拟服务器，而且当今许多最受欢迎的原生云架构都是基于 Linux 的，无论你是在谈论容器运行时还是 Kubernetes，或者是许多正在流行的无服务器平台。
其中一个最显著的代表 Linux 的优势是近年来微软的转变。如果你十年前告诉软件开发人员，Windows 操作系统将在 2016 年“运行 Linux”，他们中的大多数人会歇斯底里地大笑。 但是 Windows Linux 子系统（WSL）的存在和普及，以及最近宣布的诸如 Docker 的 Windows 移植版，包括 LCOW（Windows 上的 Linux 容器）支持等功能都证明了 Linux 在整个软件世界中所产生的影响 —— 而且显然还会继续存在。
---
via: <https://opensource.com/article/18/5/differences-between-linux-and-unix>
作者：[Phil Estes](https://opensource.com/users/estesp) 选题：[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/) 荣誉推出
|
||
使用 GNU Parallel 提高 Linux 命令行执行效率
|
Seth Kenlon
|
https://opensource.com/article/18/5/gnu-parallel
|
将您的计算机变成一个多任务的动力室。
|
/data/attachment/album/201806/06/101823qlborkn96moromor.jpg.thumb.jpg
|
/data/attachment/album/201806/06/101823qlborkn96moromor.jpg
| true | false | true |
pinewall
| false |
[
"并行",
"Parallel"
] |
技术
|
{
"viewnum": 20524,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
将您的计算机变成一个多任务的动力室。
| 2018-06-07T08:16:00 | 2018-06-07T08:16:00 | 9,718 |
/article-9718-1.html
|
>
> 将您的计算机变成一个多任务的动力室。
>
>
>
你是否有过这种感觉，你的主机运行速度没有预期的那么快？我也曾经有过这种感觉，直到我发现了 GNU Parallel。
GNU Parallel 是一个 shell 工具，可以并行执行任务。它可以解析多种输入，让你可以同时在多份数据上运行脚本或命令。你终于可以使用全部的 CPU 了！
如果你用过 `xargs`，上手 Parallel 几乎没有难度。如果没有用过，这篇教程会告诉你如何使用，同时给出一些其它的用例。
### 安装 GNU Parallel
GNU Parallel 很可能没有预装在你的 Linux 或 BSD 主机上，你可以从软件源中安装。以 Fedora 为例：
```
$ sudo dnf install parallel
```
对于 NetBSD：
```
# pkg_add parallel
```
如果各种方式都不成功，请参考[项目主页](https://www.gnu.org/software/parallel)。
### 从串行到并行
正如其名称所示，Parallel 的强大之处是以并行方式执行任务；而我们中不少人平时仍然以串行方式运行任务。
当你对多个对象执行某个命令时，你实际上创建了一个任务队列。一部分对象可以被命令处理，剩余的对象需要等待，直到命令处理它们。这种方式是低效的。只要数据够多，总会形成任务队列；但与其只使用一个任务队列，为何不使用多个更小规模的任务队列呢？
假设你有一个图片目录，你希望将目录中的图片从 JEEG 格式转换为 PNG 格式。有多种方法可以完成这个任务。可以手动用 GIMP 打开每个图片，输出成新格式，但这基本是最差的选择，费时费力。
上述方法有一个漂亮且简洁的变种，即基于 shell 的方案：
```
$ convert 001.jpeg 001.png
$ convert 002.jpeg 002.png
$ convert 003.jpeg 003.png
... 略 ...
```
对于初学者而言，这是一个不小的转变，而且看起来是个不小的改进。不再需要图像界面和不断的鼠标点击，但仍然是费力的。
进一步改进：
```
$ for i in *jpeg; do convert $i $i.png ; done
```
至少，这一步设置好任务执行，让你节省时间去做更有价值的事情。但问题来了，这仍然是串行操作；一张图片转换完成后，队列中的下一张进行转换，依此类推直到全部完成。
使用 Parallel:
```
$ find . -name "*jpeg" | parallel -I% --max-args 1 convert % %.png
```
这是两条命令的组合：`find` 命令，用于收集需要操作的对象；`parallel` 命令，用于对象排序并确保每个对象按需处理。
* `find . -name "*jpeg"` 查找当前目录下以 `jpeg` 结尾的所有文件。
* `parallel` 调用 GNU Parallel。
* `-I%` 创建了一个占位符 `%`，代表 `find` 传递给 Parallel 的内容。如果不使用占位符，你需要对 `find` 命令的每一个结果手动编写一个命令，而这恰恰是你想要避免的。
* `--max-args 1` 给出 Parallel 从队列获取新对象的速率限制。考虑到 Parallel 运行的命令只需要一个文件输入，这里将速率限制设置为 1。假如你需要执行更复杂的命令，需要两个文件输入（例如 `cat 001.txt 002.txt > new.txt`），你需要将速率限制设置为 2。
* `convert % %.png` 是你希望 Parallel 执行的命令。
组合命令的执行效果如下：`find` 命令收集所有相关的文件信息并传递给 `parallel`，后者（使用当前参数）启动一个任务，（无需等待任务完成）立即获取参数行中的下一个参数（LCTT 译注：管道输出的每一行对应 `parallel` 的一个参数，所有参数构成参数行）；只要你的主机没有瘫痪，Parallel 会不断做这样的操作。旧任务完成后，Parallel 会为分配新任务，直到所有数据都处理完成。不使用 Parallel 完成任务大约需要 10 分钟，使用后仅需 3 至 5 分钟。
### 多个输入
只要你熟悉 `find` 和 `xargs` （整体被称为 GNU 查找工具，或 `findutils`），`find` 命令是一个完美的 Parallel 数据提供者。它提供了灵活的接口，大多数 Linux 用户已经很习惯使用，即使对于初学者也很容易学习。
`find` 命令十分直截了当：你向 `find` 提供搜索路径和待查找文件的一部分信息。可以使用通配符完成模糊搜索；在下面的例子中，星号匹配任何字符，故 `find` 定位（文件名）以字符 `searchterm` 结尾的全部文件：
```
$ find /path/to/directory -name "*searchterm"
```
默认情况下，`find` 逐行返回搜索结果，每个结果对应 1 行：
```
$ find ~/graphics -name "*jpg"
/home/seth/graphics/001.jpg
/home/seth/graphics/cat.jpg
/home/seth/graphics/penguin.jpg
/home/seth/graphics/IMG_0135.jpg
```
当使用管道将 `find` 的结果传递给 `parallel` 时，每一行中的文件路径被视为 `parallel` 命令的一个参数。另一方面，如果你需要使用命令处理多个参数，你可以改变队列数据传递给 `parallel` 的方式。
下面先给出一个不那么实际的例子，后续会做一些修改使其更加有意义。如果你安装了 GNU Parallel，你可以跟着这个例子操作。
假设你有 4 个文件，按照每行一个文件的方式列出，具体如下：
```
$ echo ada > ada ; echo lovelace > lovelace
$ echo richard > richard ; echo stallman > stallman
$ ls -1
ada
lovelace
richard
stallman
```
你需要将两个文件合并成第三个文件，后者同时包含前两个文件的内容。这种情况下，Parallel 需要访问两个文件，使用 `-I%` 变量的方式不符合本例的预期。
Parallel 默认情况下读取 1 个队列对象：
```
$ ls -1 | parallel echo
ada
lovelace
richard
stallman
```
现在让 Parallel 每个任务使用 2 个队列对象：
```
$ ls -1 | parallel --max-args=2 echo
ada lovelace
richard stallman
```
现在，我们看到行已经并合并；具体而言，`ls -1` 的两个查询结果会被同时传送给 Parallel。传送给 Parallel 的参数涉及了任务所需的 2 个文件，但目前还只是 1 个有效参数：（对于两个任务分别为）“ada lovelace” 和 “richard stallman”。你真正需要的是每个任务对应 2 个独立的参数。
值得庆幸的是，Parallel 本身提供了上述所需的解析功能。如果你将 `--max-args` 设置为 `2`，那么 `{1}` 和 `{2}` 这两个变量分别代表传入参数的第一和第二部分：
```
$ ls -1 | parallel --max-args=2 cat {1} {2} ">" {1}_{2}.person
```
在上面的命令中，变量 `{1}` 值为 `ada` 或 `richard` （取决于你选取的任务），变量 `{2}` 值为 `lovelace` 或 `stallman`。通过使用重定向符号（放到引号中，防止被 Bash 识别，以便 Parallel 使用），（两个）文件的内容被分别重定向至新文件 `ada_lovelace.person` 和 `richard_stallman.person`。
```
$ ls -1
ada
ada_lovelace.person
lovelace
richard
richard_stallman.person
stallman
$ cat ada_*person
ada lovelace
$ cat ri*person
richard stallman
```
如果你整天处理大量几百 MB 大小的日志文件，那么（上述）并行处理文本的方法对你帮忙很大；否则，上述例子只是个用于上手的示例。
然而，这种处理方法对于很多文本处理之外的操作也有很大帮助。下面是来自电影产业的真实案例，其中需要将一个目录中的视频文件和（对应的）音频文件进行合并。
```
$ ls -1
12_LS_establishing-manor.avi
12_wildsound.flac
14_butler-dialogue-mixed.flac
14_MS_butler.avi
...略...
```
使用同样的方法，使用下面这个简单命令即可并行地合并文件：
```
$ ls -1 | parallel --max-args=2 ffmpeg -i {1} -i {2} -vcodec copy -acodec copy {1}.mkv
```
### 简单粗暴的方式
上述花哨的输入输出处理不一定对所有人的口味。如果你希望更直接一些，可以将一堆命令甩给 Parallel，然后去干些其它事情。
首先，需要创建一个文本文件，每行包含一个命令：
```
$ cat jobs2run
bzip2 oldstuff.tar
oggenc music.flac
opusenc ambiance.wav
convert bigfile.tiff small.jpeg
ffmepg -i foo.avi -v:b 12000k foo.mp4
xsltproc --output build/tmp.fo style/dm.xsl src/tmp.xml
bzip2 archive.tar
```
接着，将文件传递给 Parallel：
```
$ parallel --jobs 6 < jobs2run
```
现在文件中对应的全部任务都在被 Parallel 执行。如果任务数量超过允许的数目（LCTT 译注：应该是 `--jobs` 指定的数目或默认值），Parallel 会创建并维护一个队列，直到任务全部完成。
### 更多内容
GNU Parallel 是个强大而灵活的工具，还有很多很多用例无法在本文中讲述。工具的 man 页面提供很多非常酷的例子可供你参考，包括通过 SSH 远程执行和在 Parallel 命令中使用 Bash 函数等。[YouTube](https://www.youtube.com/watch?v=OpaiGYxkSuQ&list=PL284C9FF2488BC6D1) 上甚至有一个系列，包含大量操作演示，让你可以直接从 GNU Parallel 团队学习。GNU Paralle 的主要维护者还发布了官方使用指导手册，可以从 [Lulu.com](http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html) 获取。
GNU Parallel 有可能改变你完成计算的方式；即使没有，也会至少改变你主机花在计算上的时间。马上上手试试吧！
---
via: <https://opensource.com/article/18/5/gnu-parallel>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Buildah 创建小体积的容器
|
Tom Sweeney
|
https://opensource.com/article/18/5/containers-buildah
|
技术问题推动了开源协作的力量。
|
/data/attachment/album/201806/06/104008xf00r3xfqjh03913.png.thumb.jpg
|
/data/attachment/album/201806/06/104008xf00r3xfqjh03913.png
| true | false | true |
pinewall
| false |
[
"Buildah",
"协作"
] |
观点
|
{
"viewnum": 5864,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
技术问题推动了开源协作的力量。
| 2018-06-06T10:40:14 | 2018-06-06T10:40:14 | 9,719 |
/article-9719-1.html
|
>
> 技术问题推动了开源协作的力量。
>
>
>
我最近加入了 Red Hat，在这之前我在另外一家科技公司工作了很多年。在我的上一份工作岗位上，我开发了不少不同类型的软件产品，这些产品是成功的，但都有版权保护。不仅法规限制了我们不能在公司外将软件共享，而且我们在公司内部也基本不进行共享。在那时，我觉得这很有道理：公司花费了时间、精力和预算用于开发软件，理应保护并要求软件涉及的利益。
时间如梭，去年我加入 Red Hat 并培养出一种完全不同的理念。[Buildah 项目](https://github.com/projectatomic/buildah)是我最早加入的项目之一，该项目用于构建 OCI (Open Container Initiative) 标准的镜像，特别擅长让你精简创建好的镜像的体积。那时 Buildah 还处于非常早期的阶段，包含一些瑕疵，不适合用于生产环境。
刚接触项目不久，我做了一些小变更，然后询问公司内部 git 仓库地址，以便提交我做的变更。收到的回答是：没有内部仓库，直接将变更提交到 GitHub 上。这让我感到困惑，将我的变更提交到 GitHub 意味着：任何人都可以查看这部分代码并在他们自己的项目中使用。况且代码还有一些瑕疵，这样做简直有悖常理。但作为一个新人，我只是惊讶地摇了摇头并提交了变更。
一年后，我终于相信了开源软件的力量和价值。我仍为 Buildah 项目工作，我们最近遇到的一个主题很形象地说明了这种力量和价值。这个标题为 [Buildah 镜像体积并不小？](https://github.com/projectatomic/buildah/issues/532) 的工单由 Tim Dudgeon (@tdudgeon) 提出。简而言之，他发现使用 Buildah 创建的镜像比使用 Docker 创建的镜像体积更大，而且 Buildah 镜像中并不包含一些额外应用，但 Docker 镜像中却包含它们。
为了比较，他首先操作如下：
```
$ docker pull centos:7
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
docker.io/centos 7 2d194b392dd1 2 weeks ago 195 MB
```
他发现 Docker 镜像的体积为 195MB。Tim 接着使用 Buildah 创建了一个（基于 scratch 的）最小化镜像，仅仅将 `coreutils` 和 `bash` 软件包加入到镜像中，使用的脚本如下：
```
$ cat ./buildah-base.sh
#!/bin/bash
set -x
# build a minimal image
newcontainer=$(buildah from scratch)
scratchmnt=$(buildah mount $newcontainer)
# install the packages
yum install --installroot $scratchmnt bash coreutils --releasever 7 --setopt install_weak_deps=false -y
yum clean all -y --installroot $scratchmnt --releasever 7
sudo buildah config --cmd /bin/bash $newcontainer
# set some config info
buildah config --label name=centos-base $newcontainer
# commit the image
buildah unmount $newcontainer
buildah commit $newcontainer centos-base
$ sudo ./buildah-base.sh
$ sudo buildah images
IMAGE ID IMAGE NAME CREATED AT SIZE
8379315d3e3e docker.io/library/centos-base:latest Mar 25, 2018 17:08 212.1 MB
```
Tim 想知道为何 Buildah 镜像体积反而大 17MB，毕竟 `python` 和 `yum` 软件包都没有安装到 Buildah 镜像中，而这些软件已经安装到 Docker 镜像中。这个结果并不符合预期，在 Github 的相关主题中引发了广泛的讨论。
不仅 Red Hat 的员工参与了讨论，还有不少公司外人士也加入了讨论，这很有意义。值得一提的是，GitHub 用户 @pixdrift 主导了很多重要的讨论并提出很多发现，他指出在这个 Buildah 镜像中文档和语言包就占据了比 100MB 略多一点的空间。Pixdrift 建议在 yum 安装器中强制指定语言，据此提出如下修改过的 `buildah-bash.sh` 脚本：
```
#!/bin/bash
set -x
# build a minimal image
newcontainer=$(buildah from scratch)
scratchmnt=$(buildah mount $newcontainer)
# install the packages
yum install --installroot $scratchmnt bash coreutils --releasever 7 --setopt=install_weak_deps=false --setopt=tsflags=nodocs --setopt=override_install_langs=en_US.utf8 -y
yum clean all -y --installroot $scratchmnt --releasever 7
sudo buildah config --cmd /bin/bash $newcontainer
# set some config info
buildah config --label name=centos-base $newcontainer
# commit the image
buildah unmount $newcontainer
buildah commit $newcontainer centos-base
```
Tim 运行这个新脚本，得到的镜像体积缩减至 92MB，相比之前的 Buildah 镜像体积减少了 120MB，这比较接近我们的预期；然而，出于工程师的天性，56% 的体积缩减不能让他们满足。讨论继续深入下去，涉及如何移除个人语言包以节省更多空间。如果想了解讨论细节，点击 [Buildah 镜像体积并不小？](https://github.com/projectatomic/buildah/issues/532) 这个链接。说不定你也能给出有帮助的点子，甚至更进一步成为 Buildah 项目的贡献者。这个主题的解决从一个侧面告诉我们，Buildah 软件可以多么快速和容易地创建体积最小化的容器，该容器仅包含你高效运行任务所需的软件。额外的好处是，你无需运行一个守护进程。
这个镜像体积缩减的主题让我意识到开源软件的力量。来自不同公司的大量开发者，在一天多的时间内，以开放讨论的形式进行合作解决问题。虽然解决这个具体问题并没有修改已有代码，但 Red Hat 公司外开发者对 Buildah 做了很多代码贡献，进而帮助项目变得更好。这些贡献也吸引了更多人才关注项目代码；如果像之前那样，代码作为版权保护软件的一部分放置在私有 git 仓库中，不会获得上述好处。我只用了一年的时间就转向拥抱 [开源方式](https://twitter.com/opensourceway)，而且可能不会再转回去了。
文章最初发表于 [Project Atomic](http://www.projectatomic.io/blog/2018/04/open-source-what-a-concept/)，已获得转载许可。
---
via: <https://opensource.com/article/18/5/containers-buildah>
作者：[Tom Sweeney](https://opensource.com/users/tomsweeneyredhat) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
5 个理由，开源助你求职成功
|
Sophie Polson
|
https://opensource.com/article/18/1/5-ways-turn-open-source-new-job
|
为开源项目工作可以给你或许从其他地方根本得不到的经验和人脉。
|
/data/attachment/album/201806/06/110106s2klxgan0c4n305f.png.thumb.jpg
|
/data/attachment/album/201806/06/110106s2klxgan0c4n305f.png
| true | false | true |
lontow
| false |
[
"求职"
] |
职业生涯
|
{
"viewnum": 3669,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
为开源项目工作可以给你或许从其他地方根本得不到的经验和人脉。
| 2018-06-06T11:01:00 | 2018-06-06T11:01:00 | 9,720 |
/article-9720-1.html
|
>
> 为开源项目工作可以给你或许从其他地方根本得不到的经验和人脉。
>
>
>
你正在在繁华的技术行业中寻找工作吗？无论你是寻找新挑战的技术团体老手，还是正在寻找第一份工作的毕业生，参加开源项目都是可以让你在众多应聘者中脱颖而出的好方法。以下是从事开源项目工作可以增强你求职竞争力的五个理由。
### 1、 获得项目经验
或许从事开源项目工作能带给你的最明显的好处是提供了项目经验。如果你是一个学生，你可能没有很多实质上的项目可以在你的简历中展示。如果你还在工作，由于保密限制，或者你对正在完成的任务不感兴趣，你不能或者不能很详细的讨论你当前的项目。无论那种情况，找出并参加那些有吸引力的，而且又正好可以展现你的技能的开源项目，无疑对求职有帮助。这些项目不仅在众多简历中引人注目，而且可以是面试环节中完美的谈论主题。
另外，很多开源项目托管在公共仓库（比如 [Github](https://github.com/dbaldwin/DronePan) ）上，所以对任何想参与其中的任何人，获取这些项目的源代码都异常简单。同时，你对项目的公开代码贡献，也能很方便的被招聘单位或者潜在雇主找到。开源项目提供了一个可以让你以一种更实际的的方式展现你的技能，而不是仅仅在面试中纸上谈兵。
### 2、 学会提问
开源项目团体的新成员总会有机会去学习大量的新技能。他们肯定会发现该项目独特的的多种交流方式、结构层次、文档格式和其他的方方面面。在刚刚参与到项目中时，你需要问大量的问题，才能找准自己的定位。正如俗语说得好，没有愚蠢的问题。开源社区提倡好奇心，特别是在问题答案不容易找到的时候。
在从事开源项目工作初期，对项目的不熟悉感会驱使个人去提问，去经常提问。这可以帮助参与者学会提问。学会去分辨问什么，怎么问，问谁。学会提问在找工作、[面试](https://www.thebalance.com/why-you-should-ask-questions-in-a-job-interview-1669548)，甚至生活中都非常有用。解决问题和寻求帮助的能力在人才市场中都非常重要。
### 3、 获取新的技能与持续学习
大量的软件项目同时使用很多不同的技术。很少有贡献者可以熟悉项目中的所有技术。即使已经在项目中工作了一段时间后，很多人很可能不能对项目中所用的所有技术都熟悉。
虽然一个开源项目中的老手可能会对项目的一些特定的方面不熟悉，但是新手不熟悉的显然更多。这种情况产生了大量的学习机会。在一个人刚开始从事开源工作时，可能只是去提高项目中的一些小功能，甚至很可能是在他熟悉的领域。但是以后的旅程就大不相同了。
从事项目的某一方面的工作可能会把你带进一个不熟悉的领域，可能会驱使你开始新的学习。而从事开源项目的工作，可能会把你带向一个你以前可能从没用过的技术。这会激起新的激情，或者，至少促进你继续学习（[这正是雇主渴望具备的能力](https://www.computerworld.com/article/3177442/it-careers/lifelong-learning-is-no-longer-optional.html)）。
### 4、增加人脉
开源项目被不同的社区维护和支持。一些人在他们的业余时间进行开源工作，他们都有各自的经历、兴趣和人脉。正如他们所说，“你了解什么人决定你成为什么人”。不通过开源项目，可能你永远不会遇到特定的人。或许你和世界各地的人一起工作，或许你和你的邻里有联系。但是，你不知道谁能帮你找到下一份工作。参加开源项目扩展人脉的可能性将对你寻找下一份（或者第一份）工作极有帮助。
### 5、 建立自信
最后，参与开源项目可能给你新的自信。很多科技企业的新员工会有些[冒充者综合症](https://en.wikipedia.org/wiki/Impostor_syndrome)。由于没有完成重要工作，他们会感到没有归属感，好像自己是冒名顶替的那个人，认为自己配不上他们的新职位。在被雇佣前参加开源项目可以最小化这种问题。
开源项目的工作往往是独立完成的，但是对于项目来说，所有的贡献是一个整体。开源社区具有强大的包容性和合作性，只要你有所贡献，一定会被看到。别的社区成员（特别是更高级的成员）对你肯定无疑也是一种回报。在你进行代码提交时获得的认可可以提高你的自信，打败冒充者综合症。这份自信也会被带到面试，新职位，等等。
这只是从事开源工作的一些好处。如果你知道更多的好处，请在下方评论区留言分享。
### 关于作者
Sophie Polson ：一名研究计算机科学的杜克大学的学生。通过杜克大学 2017 秋季课程 “开源世界（ Open Source World ）”，开始了开源社区的冒险。对探索 [DevOps](https://en.wikipedia.org/wiki/DevOps) 十分有兴趣。在 2018 春季毕业后，将成为一名软件工程师。
---
via: <https://opensource.com/article/18/1/5-ways-turn-open-source-new-job>
作者：[Sophie Polson](https://opensource.com/users/sophiepolson) 译者：[Lontow](https://github.com/lontow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
<sup> <sup> <sup> <sup> <sup> ^ </sup> </sup> </sup> </sup></sup>
|
||
IT 自动化：如何去实现
|
Kevin Casey
|
https://enterprisersproject.com/article/2018/1/how-make-case-it-automation
|
想要你的整个团队都登上 IT 自动化之旅吗？ IT 执行者们分享了他们的战略。
|
/data/attachment/album/201806/06/190848x5k8u2o85bu9krmt.jpg.thumb.jpg
|
/data/attachment/album/201806/06/190848x5k8u2o85bu9krmt.jpg
| true | false | true |
FelixYFZ
| false |
[
"自动化"
] |
观点
|
{
"viewnum": 4874,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
想要你的整个团队都登上 IT 自动化之旅吗？ IT 执行者们分享了他们的战略。
| 2018-06-06T19:08:45 | 2018-06-06T19:08:45 | 9,721 |
/article-9721-1.html
|
>
> 想要你的整个团队都登上 IT 自动化之旅吗？ IT 执行者们分享了他们的战略。
>
>
>
在任何重要的项目或主动变更刚开始的时候，IT 的管理者在前进的道路上面临着普遍的抉择。
第一条路径看上去是提供了一个从 A 到 B 的最短路径：简单的把项目强制分配给每个人去执行，本质来说就是你要么按照要求去做要么就不要做了。
第二条路径可能看上去会不是很直接，因为要通过这条路径你需要花时间去解释项目背后的策略以及原因。你会沿着这条路线设置停靠站点而不是从起点到终点的马拉松：“这就是我们正在做的 —— 和为什么我们这么做。”
猜想一下哪条路径会赢得更好的结果？
如果你选的是路径 2，你肯定是以前都经历过这两条路径——而且经历了第一次的结局。让人们参与到重大变革中总会是最明智的选择。
IT 领导者也知道重大的变革总会带来严重的恐慌、怀疑，和其他的挑战。IT 自动化确实是很正确的改变。这个术语对某些人来说是很可怕的，而且容易被曲解。帮助人们理解你的公司需要 IT 自动化的必要性的原因以及如何去实现是达到你的目标和策略的重要步骤。
[**阅读我们的相关文章，**[**IT自动化最佳实践：持久成功的7个关键点**](https://enterprisersproject.com/article/2018/1/it-automation-best-practices-7-keys-long-term-success?sc_cid=70160000000h0aXAAQ)。]
考虑到这一点，我们咨询了许多 IT 管理者关于如何在你的组织中实现 IT 自动化。
### 1、向人们展示它的优点
我们要面对的一点事实是：自我利益和自我保护是本能。利用人们的这种本能是一个吸引他们的好方法：向他们展示自动化策略将如何让他们和他们的工作获益。自动化将会是软件管道中的一个特定过程意味着将会减少在半夜呼叫团队同事来解决故障？它将能让一些人丢弃技术含量低的技能，用更有策略、高效的有序工作代替手工作业，这将会帮助他们的职业生涯更进一步？
“向他们传达他们能得到什么好处，自动化将会如何让他们的客户和公司受益，”来自 ADP 全球首席技术官 vipual Nagrath 的建议。“将现在的状态和未来光明的未来进行对比，展现公司将会变得如何稳定，敏捷，高效和安全。”
这样的方法同样适用于 IT 领域之外的其他领域；只要在向非技术领域的股东们解读利益的时候解释清楚一些术语即可，Nagrath 说道。
设置好前后的情景是一个不错的帮助人们理解的更透彻的故事机。
“你要描述一幅人们能够联想到的当前状态的画面，” Nagrath 说。“描述现在是什么工作，但也要重点强调是什么导致团队的工作效率不够敏捷。”然后再阐释自动化过程将如何提高现在的状态。
### 2、将自动化和特定的商业目标绑定在一起
一个强有力的案列的一部分要确保人们理解你不只是在追逐潮流趋势。如果只是为了自动化而自动化，人们会很快察觉到进而会更加抵制的——也许在 IT 界更是如此。
“自动化需要商业需求的驱动，例如收入和运营开销，” Cyxtera的副总裁和首席信息安全官 David Emerson 说道。“没有自动化的努力是自我辩护的，而且任何技术专长都不应该被当做一种手段，除非它是公司的一项核心能力。”
像 Nagrath 一样，Emerson 建议将达到自动化的商业目标和奖励措施挂钩，用迭代式的循序渐进的方式推进这些目标和相关的激励措施。
### 3、 将自动化计划分解为可管理的条目
即使你的自动化策略字面上是“一切都自动化”，对大多数组织来说那也是很艰难的，而且可能是没有灵活性的。你需要制定一个强有力的方案，将自动化目标分解为可管理的目标计划。而且这将能够创造很大的灵活性来适应之后漫长的道路。
“当制定一个自动化方案的时候，我建议详细的阐明推进自动化进程的奖励措施，而且允许迭代朝着目标前进来介绍和证明利益处于一个低风险水平，”Emerson 说道。
GA Connector 的创始人 Sergey Zuev 分享了一个为什么自动化如此重要的快节奏体验的报告——它将怎样为你的策略建立一个强壮持久的论点。Zuevz 应该知道：他的公司的自动化工具将公司的客户关系应用数据导入谷歌分析。但实际上是公司的内部经验使顾客培训进程自动化从而出现了一个闪耀的时刻。
“起初， 我们曾尝试去建立整个培训机制，结果这个项目搁浅了好几个月，”Zuev 说道。“认识到这将无法继续下去之后，我们决定挑选其中的一个能够有巨大的时效的领域，而且立即启动。结果我们只用了一周就实现了其中的电子邮件序列的目标，而且我们已经从被亵渎的体力劳动中获益。”
### 4、 出售主要部分也有好处
循序渐进的方法并不会阻碍构建一个宏伟的蓝图。就像以个人或者团队的水平来制定方案是一个好主意，帮助人们理解全公司的利益也是一个不错的主意。
“如果我们能够加速达到商业需求所需的时间，那么一切质疑将会平息。”
AHEAD 的首席技术官 Eric Kaplan 赞同通过小范围的胜利来展示自动化的价值是一个赢得人心的聪明策略。但是那些所谓的“小的”的价值揭示能够帮助你提高人们的整体形象。Kaplan 指出个人和组织间的价值是每个人都可以容易联系到的领域。
“最能展现的地方就是你能够节约多少时间，”Kaaplan 说。“如果我们能够加速达到商业需求所需的时间，那么一切质疑将会消失。”
时间和可伸缩性是业务和 IT 同事的强大优势，都复制业务的增长，可以把握。
“自动化的结果是灵活伸缩的——每个人只需较少的努力就能保持和改善你的 IT 环境”，红帽的全球服务副总裁 John Allessio 最近提到。“如果增加人力是提升你的商业的唯一途径，那么灵活伸缩就是白日梦。自动化减少了你的人力需求而且提供了 IT 演进所需的灵活性和韧性。”(详细内容请参考他的文章，[DevOps 团队对 CIO 的真正需求是什么。])
### 5、 推广你的成果。
在你自动化策略的开始时，你可能是在目标和要达到目标的预期利益上制定方案。但随着你的自动化策略的不断演进，没有什么能够比现实中的实际结果令人信服。
“眼见为实，”ADP 的首席技术官 Nagrath 说。“没有什么比追踪记录能够平息质疑。”
那意味着，不仅仅要达到你的目标，还要准时的完成——这是迭代的循序渐进的方法论的另一个不错的解释。
而量化的结果如比利润的提高或者成本的节省可以大声宣扬出来，Nagrath 建议他的 IT 领导者同行在讲述你们的自动化故事的时候不要仅仅止步于此。
为自动化提供案例也是一个定性的讨论，通过它我们能够促进问题的预防，归总商业的连续性，减伤失败或错误，而且能够在他们处理更有价值的任务时承担更多的责任。
---
via: <https://enterprisersproject.com/article/2018/1/how-make-case-it-automation>
作者：[Kevin Casey](https://enterprisersproject.com/user/kevin-casey) 译者：[FelixYFZ](https://github.com/FelixYFZ) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
最好的 Linux 工具献给老师和学生们
|
Jack Wallen
|
https://www.linux.com/news/best-linux-tools-teachers-and-students
|
Linux 与教育齐头并进。无论你是老师，学生还是管理员，你都会找到大量工具来帮助教育机构开放，灵活和强大。
|
/data/attachment/album/201806/06/211205d26t06htv9scjthx.jpg.thumb.jpg
|
/data/attachment/album/201806/06/211205d26t06htv9scjthx.jpg
| true | false | true |
MjSeven
| false |
[
"教育",
"教学"
] |
分享
|
{
"viewnum": 9060,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux 与教育齐头并进。无论你是老师，学生还是管理员，你都会找到大量工具来帮助教育机构开放，灵活和强大。
| 2018-06-08T08:02:00 | 2018-06-08T08:02:00 | 9,722 |
/article-9722-1.html
|
Linux 是一个适合每个人的平台。如果你有一份合适的工作，Linux 已经可以满足或超过它的需求，其中一个工作是教育。如果你是一名教师或一名学生，Linux 已经准备好帮助你在几乎任何级别的教育系统领域中畅游。从辅助学习、写作论文、管理课程，到管理整个机构，Linux 已经全部涵盖了。
如果你不确定，请让我介绍一下 Linux 准备好的一些工具。其中一些工具几乎没有学习曲线，而另一些工具则需要一个全面的系统管理员来安装、设置和管理。我们将从简单开始，然后到复杂。
### 学习辅助工具
每个人的学习方式都有所不同，每个班级都需要不同的学习类型和水平。幸运的是，Linux 有很多学习辅助工具。让我们来看几个例子：
闪卡 —— [KWordQuiz](https://edu.kde.org/kwordquiz/)（图 1）是适用于 Linux 平台的许多闪卡应用程序之一。KWordQuiz 使用 kvtml 文件格式，你可以下载大量预制的、人们贡献的文件。 KWordQuiz 是 KDE 桌面环境的一部分，但可以安装在其他桌面上（KDE 依赖文件将与闪卡应用程序一起安装）。
### 语言工具
由于全球化进程，外语已成为教育的重要组成部分。你会发现很多语言工具，包括 [Kiten](https://edu.kde.org/kiten/)（图 2）—— KDE 桌面的日语汉字浏览器。
如果日文不是你的母语，你可以试试 [Jargon Informatique](http://jargon.asher256.com/index.php)。这本词典完全是法文的，所以如果你对这门语言还不熟悉，你可能要需要 [Google 翻译](https://translate.google.com/)的帮助才能坚持下去。
### Writing Aids / Note Taking
Linux 拥有你需要的所有东西比如记录一个主题，撰写那些学期论文。让我们从记笔记开始。如果你熟悉 Microsoft OneNote，你一定会喜欢 [BasKet Note Pads](http://basket.kde.org/)。有了这个应用程序，你可以为主题创建<ruby> 笔记本 <rt> basket </rt></ruby>，并添加任何东西——注释、链接、图像、交叉引用（到其他笔记本─图 3）、应用程序启动器、从文件加载等等。
你可以创建任意形式的笔记本，可以移动元素来满足你的需求。如果你更喜欢有序的感觉，那么创建一个表状的 basket 来保留那些封装的笔记。
当然，所有 Linux 写作辅助工具都是由 [LibreOffice](http://www.libreoffice.com) 发展而来。LibreOffice 是大多数 Linux 发行版默认的办公套件，它能打开文本文档、电子表格、演示文稿、数据库、公式和绘图。
在教育环境中使用 LibreOffice 的一个警告是，你很可能不得不将文档以 MS Office 格式保存。
### 为教育而生的发行版
所有这些都是关于 Linux 面向学生的应用程序，你可以看看专门为教育而开发的一个发行版。最好的是 [Edubuntu](http://www.edubuntu.org/)。这种平易的 Linux 发行版旨在让 Linux 进入学校、家庭和社区。Edubuntu 使用默认的 Ubuntu 桌面（Unity shell）并添加以下软件：
* KDE 教育套件
* GCompris
* Celestia
* Tux4Kids
* Epoptes
* LTSP
* GBrainy
* 等等
Edubuntu 并不是唯一的发行版。如果你想测试其他特定于教育的 Linux 发行版，以下是简短列表：
* Debian-Edu
* Fedora Education Spin
* Guadalinux-Edu
* OpenSuse-Edu
* Qimo
* Uberstudent
### 课堂/机构管理
这是 Linux 平台真正闪耀的地方。有许多专门用于管理的工具。我们先来看看教室特有的工具。
[iTalc](http://italc.sourceforge.net/) 是一个强大的课堂教学环境。借助此工具，教师可以查看和控制学生桌面（支持 Linux 和 Windows）。iTalc 系统允许教师查看学生桌面上发生了什么，控制他们的桌面，锁定他们的桌面，对桌面演示，打开或关闭桌面，向学生桌面发送文本消息等等。
[aTutor](http://www.atutor.ca/)（图 4）是一个开源的学习管理系统（LMS），专注于开发在线课程和电子学习内容。一个老师真正发挥的就是创建和管理在线考试和测验。当然，aTutor 不限于测试的目的，有了这个强大的软件，学生和老师可以享受：
* 社交网络
* 配置文件
* 消息
* 自适应导航
* 工作组
* 文件存储
* 小组博客
* 以及更多。
课程资料易于创建和部署（你甚至可以将考试/测验分配给特定的学习小组）。
[Moodle](https://moodle.org/) 是目前使用最广泛的教育管理软件之一。通过 Moodle，你可以管理、教授、学习甚至参与孩子的教育。这个强大的软件为教师和学生、考试、日历、论坛、文件管理、课程管理（图 5）、通知、进度跟踪、大量注册、批量课程创建、考勤等提供协作工具。
[OpenSIS](http://www.opensis.com/) 意即开源学生信息系统，在管理你的教育机构方面做得很好。有一个免费的社区版，但即使使用付费版本，你也可以期待将学区的拥有成本降低高达 75％（与专有解决方案相比）。
OpenSIS 包括以下特点或模块：
* 出席情况（图 6）
* 联系信息
* 学生人口统计
* 成绩簿
* 计划
* 健康记录
* 报告卡
OpenSIS 有四个版本，在[这里](http://www.opensis.com/compare_edition.php)查看它们的功能比较。
[vufind](http://vufind-org.github.io/vufind/) 是一个优秀的图书馆管理系统，允许学生和教师轻松浏览图书馆资源，例如：
* 目录记录
* 本地缓存期刊
* 数字图书馆项目
* 机构知识库
* 机构书目
* 其他图书馆集合和资源
Vufind 系统允许用户登录，通过认证的用户可以节省资源以便快速回忆，并享受“更像这样”的结果。
这份列表仅仅触及了 Linux 在教育领域可用性的一点皮毛。而且，正如你所期望的那样，每个工具都是高度可定制且开放源代码的 —— 所以如果软件不能精确地满足你的需求，那么你可以自由（在大多数情况下）修改源代码并进行更改。
Linux 与教育齐头并进。无论你是老师，学生还是管理员，你都会找到大量工具来帮助教育机构开放，灵活和强大。
---
via: <https://www.linux.com/news/best-linux-tools-teachers-and-students>
作者：[Jack Wallen](https://www.linux.com/users/jlwallen) 选题：[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/) 荣誉推出
|
||
Pidgin：Skype for Business 的开源替代品
|
Ray Shimko
|
https://opensource.com/article/18/4/pidgin-open-source-replacement-skype-business
|
用可以和 Office 365 协同工作的开源软件换下你的专有化的沟通软件。
|
/data/attachment/album/201806/06/214708qillzt9lj59llwn6.png.thumb.jpg
|
/data/attachment/album/201806/06/214708qillzt9lj59llwn6.png
| true | false | true |
geekpi
| false |
[
"Office",
"Pidgin",
"Skype"
] |
分享
|
{
"viewnum": 6335,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用可以和 Office 365 协同工作的开源软件换下你的专有化的沟通软件。
| 2018-06-06T21:46:54 | 2018-06-06T21:46:54 | 9,723 |
/article-9723-1.html
|
>
> 用可以和 Office 365 协同工作的开源软件换下你的专有化的沟通软件。
>
>
>
技术正处在一个有趣的十字路口，Linux 统治服务器领域，但微软统治企业桌面。 Office 365、Skype for Business、Microsoft Teams、OneDrive、Outlook ......等等，这些是支配企业工作空间的是微软软件和服务。
如果你可以使用自由和开源程序替换该专有软件，并使其与你别无选择，但只能使用的 Office 365 的后端一起工作？是的，因为这正是我们要用 Pidgin 做的，它是 Skype 的开源替代品。
### 安装 Pidgin 和 SIPE
微软的 Office Communicator 变成了 Microsoft Lync，它成为我们今天所知的 Skype for Business。现在有针对 Linux 的[付费软件](https://tel.red/linux.php)提供了与 Skype for Business 相同的功能，但 [Pidgin](https://pidgin.im/) 是 GNU GPL 授权的、完全自由开源的选择。
Pidgin 可以在几乎每个 Linux 发行版的仓库中找到，因此，使用它不应该是一个问题。唯一不能在 Pidgin 中使用的 Skype 功能是屏幕共享，并且文件共享可能会失败，但有办法解决这个问题。
你还需要一个 [SIPE](http://sipe.sourceforge.net/) 插件，因为它是使 Pidgin 成为 Skype for Business 替代品的秘密武器的一部分。请注意，`sipe` 库在不同的发行版中有不同的名称。例如，库在 System76 的 Pop\_OS! 中是 `pidgin-sipe`，而在 Solus 3 仓库中是 `sipe`。
满足了先决条件，你可以开始配置 Pidgin。
### 配置 Pidgin
首次启动 Pidgin 时，点击 “Add” 添加一个新帐户。在基本选项卡（如下截图所示）中，选择 “Protocol” 下拉菜单中的 “Office Communicator”，然后在 “Username” 字段中输入你的“公司电子邮件地址”。
接下来，点击高级选项卡。在 “Server[:Port]” 字段中输入 “sipdir.online.lync.com:443”，在 “User Agent” 中输入 “UCCAPI/16.0.6965.5308 OC/16.0.6965.2117”。
你的高级选项卡现在应该如下所示：
你不需要对“Proxy”选项卡或“Voice and Video”选项卡进行任何更改。只要确定，请确保 “Proxy type” 设置为 “Use Global Proxy Settings”，并且在“Voice and Video”选项卡中，“Use silence suppression” 复选框为**取消选中**。
完成这些配置后，点击 “Add”，系统会提示你输入电子邮件帐户的密码。
### 添加联系人
要将联系人添加到好友列表，请点击**好友窗口**中的 “Manage Accounts”。将鼠标悬停在你的帐户上，然后选择 “Contact Search” 查找你的同事。如果您在使用姓氏和名字进行搜索时遇到任何问题，请尝试使用你同事的完整电子邮件地址进行搜索，你就会找到正确的人。
你现在已经开始使用 Skype for Business 替代产品，该产品可为你提供 98％ 的功能，从你的桌面上消除专有软件。
---
via: <https://opensource.com/article/18/4/pidgin-open-source-replacement-skype-business>
作者：[Ray Shimko](https://opensource.com/users/shickmo) 选题：[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/) 荣誉推出
|
||
Git 分支操作介绍
|
Kedar Vijay Kulkarni
|
https://opensource.com/article/18/5/git-branching
|
在这个 Git 入门系列的第三篇中，我们来学习一下如何添加和删除 Git 分支。
|
/data/attachment/album/201806/07/232158l3slzxx33kezcc5x.jpg.thumb.jpg
|
/data/attachment/album/201806/07/232158l3slzxx33kezcc5x.jpg
| true | false | true |
pinewall
| false |
[
"Git"
] |
技术
|
{
"viewnum": 6683,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9517,
"displayorder": 0
}
] |
在这个 Git 入门系列的第三篇中，我们来学习一下如何添加和删除 Git 分支。
| 2018-06-07T23:22:50 | 2018-06-07T23:22:50 | 9,724 |
/article-9724-1.html
|
>
> 在这个 Git 入门系列的第三篇中，我们来学习一下如何添加和删除 Git 分支。
>
>
>
在本系列的前两篇文章中，我们[开始使用 Git](/article-9319-1.html)，学会如何[克隆项目，修改、增加和删除内容](/article-9517-1.html)。在这第三篇文章中，我将介绍 Git 分支，为何以及如何使用分支。
不妨用树来描绘 Git 仓库。图中的树有很多分支，或长或短，或从树干延伸或从其它分支延伸。在这里，我们用树干比作仓库的 master 分支，其中 `master` 代指 ”master 分支”，是 Git 仓库的中心分支或第一个分支。为简单起见，我们假设 `master` 是树干，其它分支都是从该分支分出的。
### 为何在 Git 仓库中使用分支
使用分支的主要理由为：
* 如果你希望为项目增加新特性，但很可能会影响当前可正常工作的代码。对于该项目的活跃用户而言，这是很糟糕的事情。与其将特性加入到其它人正在使用的 `master` 分支，更好的方法是在仓库的其它分支中变更代码，下面会给出具体的工作方式。
* 更重要的是，[Git 其设计](https://en.wikipedia.org/wiki/Git)用于协作。如果所有人都在你代码仓库的 `master` 分支上操作，会引发很多混乱。对编程语言或项目的知识和阅历因人而异；有些人可能会编写有错误或缺陷的代码，也可能会编写你觉得不适合该项目的代码。使用分支可以让你核验他人的贡献并选择适合的加入到项目中。（这里假设你是代码库唯一的所有者，希望对增加到项目中的代码有完全的控制。在真实的项目中，代码库有多个具有合并代码权限的所有者）
### 创建分支
让我们回顾[本系列上一篇文章](/article-9517-1.html)，看一下在我们的 Demo 目录中分支是怎样的。如果你没有完成上述操作，请按照文章中的指示从 GitHub 克隆代码并进入 Demo 目录。运行如下命令：
```
pwd
git branch
ls -la
```
`pwd` 命令（是当前工作目录的英文缩写）返回当前你所处的目录（以便确认你在 `Demo` 目录中），`git branch` 列出该项目在你主机上的全部分支，`ls -la` 列出当前目录下的所有文件。你的终端输出类似于：
在 `master` 分支中，只有一个文件 `README.md`。（Git 会友好地忽略掉其它目录和文件。）
接下来，运行如下命令：
```
git status
git checkout -b myBranch
git status
```
第一条命令 `git status` 告知你当前位于 `branch master`，（就像在终端中看到的那样）它与 `origin/master` 处于同步状态，这意味着 master 分支的本地副本中的全部文件也出现在 GitHub 中。两份副本没有差异，所有的提交也是一致的。
下一条命令 `git checkout -b myBranch` 中的 `-b` 告知 Git 创建一个名为 `myBranch` 的新分支，然后 `checkout` 命令将我们切换到新创建的分支。运行第三条命令 `git status` 确保你已经位于刚创建的分支下。
如你所见，`git status` 告知你当前处于 `myBranch` 分支，没有变更需要提交。这是因为我们既没有增加新文件，也没有修改已有文件。
如果希望以可视化的方式查看分支，可以运行 `gitk` 命令。如果遇到报错 `bash: gitk: command not found...`，请先安装 `gitk` 软件包（找到你操作系统对应的安装文档，以获得安装方式）。
（LCTT 译注：需要在有 X 服务器的终端运行 `gitk`，否则会报错）
下图展示了我们在 Demo 项目中的所作所为：你最后一次提交（的对应信息）是 `Delete file.txt`，在此之前有三次提交。当前的提交用黄点标注，之前的提交用蓝点标注，黄点和 `Delete file.txt` 之间的三个方块展示每个分支所在的位置（或者说每个分支中的最后一次提交的位置）。由于 `myBranch` 刚创建，提交状态与 `master` 分支及其对应的记为 `remotes/origin/master` 的远程 `master` 分支保持一致。（非常感谢来自 Red Hat 的 [Peter Savage](https://opensource.com/users/psav) 让我知道 `gitk` 这个工具）
下面让我们在 `myBranch` 分支下创建一个新文件并观察终端输出。运行如下命令：
```
echo "Creating a newFile on myBranch" > newFile
cat newFile
git status
```
第一条命令中的 `echo` 创建了名为 `newFile` 的文件，接着 `cat newFile` 打印出文件内容，最后 `git status` 告知你我们 `myBranch` 分支的当前状态。在下面的终端输出中，Git 告知 `myBranch` 分支下有一个名为 `newFile` 的文件当前处于 `untracked` 状态。这表明我们没有让 Git 追踪发生在文件 `newFile` 上的变更。
下一步是增加文件，提交变更并将 `newFile` 文件推送至 `myBranch` 分支（请回顾本系列上一篇文章获得更多细节）。
```
git add newFile
git commit -m "Adding newFile to myBranch"
git push origin myBranch
```
在上述命令中，`push` 命令使用的分支参数为 `myBranch` 而不是 `master`。Git 添加 `newFile` 并将变更推送到你 GitHub 账号下的 Demo 仓库中，告知你在 GitHub 上创建了一个与你本地副本分支 `myBranch` 一样的新分支。终端输出截图给出了运行命令的细节及命令输出。
当你访问 GitHub 时，在分支选择的下拉列表中可以发现两个可供选择的分支。
点击 `myBranch` 切换到 `myBranch` 分支，你可以看到在此分支上新增的文件。
截至目前，我们有两个分支：一个是 `master` 分支，只有一个 `README.md` 文件；另一个是 `myBranch` 分支，有两个文件。
你已经知道如何创建分支了，下面我们再创建一个分支。输入如下命令：
```
git checkout master
git checkout -b myBranch2
touch newFile2
git add newFile2
git commit -m "Adding newFile2 to myBranch2"
git push origin myBranch2
```
我不再给出终端输出，需要你自己尝试，但你可以在 [GitHub 代码库](https://github.com/kedark3/Demo/tree/myBranch2) 中验证你的结果。
### 删除分支
由于我们增加了两个分支，下面删除其中的一个（`myBranch`），包括两步：
1. **删除本地分支** 你不能删除正在操作的分支，故切换到 `master` 分支 （或其它你希望保留的分支），命令及终端输出如下：
`git branch` 可以列出可用的分支，使用 `checkout` 切换到 `master` 分支，然后使用 `git branch -D myBranch` 删除该分支。再次运行 `git branch` 检查是否只剩下两个分支（而不是三个）。
2. **删除 GitHub 上的分支** 使用如下命令删除 `myBranch` 的远程分支：
```
git push origin :myBranch
```
上面 `push` 命令中分支名称前面的冒号（`:`）告知 GitHub 删除分支。另一种写法为：
```
git push -d origin myBranch
```
其中 `-d` (也可以用 `--delete`) 也用于告知 GitHub 删除你的分支。
我们学习了 Git 分支的使用，在本系列的下一篇文章中，我们将介绍如何执行 `fetch` 和 `rebase` 操作，对于多人同时的贡献的项目而言，这是很必须学会的。
---
via: <https://opensource.com/article/18/5/git-branching>
作者：[Kedar Vijay Kulkarni](https://opensource.com/users/kkulkarn) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GDPR 将如何影响开源社区？
|
Robin Muilwijk
|
https://opensource.com/article/18/4/gdpr-impact
|
许多组织正在争先恐后地了解隐私法的变化如何影响他们的工作。
|
/data/attachment/album/201806/07/235158c1xuqmxx71xx75hm.jpg.thumb.jpg
|
/data/attachment/album/201806/07/235158c1xuqmxx71xx75hm.jpg
| true | false | true |
pinewall
| false |
[
"GDPR"
] |
观点
|
{
"viewnum": 4037,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
许多组织正在争先恐后地了解隐私法的变化如何影响他们的工作。
| 2018-06-07T23:52:49 | 2018-06-07T23:52:49 | 9,725 |
/article-9725-1.html
|
>
> 许多组织正在争先恐后地了解隐私法的变化如何影响他们的工作。
>
>
>
2018 年 5 月 25 日，[<ruby> 通用数据保护条例 <rt> General Data Protection Regulation, GDPR </rt></ruby>](https://www.eugdpr.org/eugdpr.org.html) 开始生效。欧盟出台的该条例将在全球范围内对企业如何保护个人数据产生重大影响。影响也会波及到开源项目以及开源社区。
### GDPR 概述
GDPR 于 2016 年 4 月 14 日在欧盟议会通过，从 2018 年 5 月 25 日起开始生效。GDPR 用于替代 95/46/EC 号<ruby> 数据保护指令 <rt> Data Protection Directive </rt></ruby>，该指令被设计用于“协调欧洲各国数据隐私法，保护和授权全体欧盟公民的数据隐私，改变欧洲范围内企业处理数据隐私的方式”。
GDPR 目标是在当前日益数据驱动的世界中保护欧盟公民的个人数据。
### 它对谁生效
GDPR 带来的最大改变之一是影响范围的扩大。不管企业本身是否位于欧盟，只要涉及欧盟公民个人数据的处理，GDPR 就会对其生效。
大部分提及 GDPR 的网上文章关注销售商品或服务的公司，但关注影响范围时，我们也不要忘记开源项目。有几种不同的类型，包括运营开源社区的（营利性）软件公司和非营利性组织（例如，开源软件项目及其社区）。对于面向全球的社区，几乎总是会有欧盟居民加入其中。
如果一个面向全球的社区有对应的在线平台，包括网站、论坛和问题跟踪系统等，那么很可能会涉及欧盟居民的个人数据处理，包括姓名、邮箱地址甚至更多。这些处理行为都需要遵循 GDPR。
### GDPR 带来的改变及其影响
相比被替代的指令，GDPR 带来了[很多改变](https://www.eugdpr.org/key-changes.html)，强化了对欧盟居民数据和隐私的保护。正如前文所说，一些改变给社区带来了直接的影响。我们来看看若干改变。
#### 授权
我们假设社区为成员提供论坛，网站中包含若干个用于注册的表单。要遵循 GDPR，你不能再使用冗长、无法辨识的隐私策略和条件条款。无论是每种特殊用途，在论坛注册或使用网站表单注册，你都需要获取明确的授权。授权必须是无条件的、具体的、通知性的以及无歧义的。
以表单为例，你需要提供一个复选框，处于未选中状态并给出个人数据用途的明确说明，一般是当前使用的隐私策略和条件条款附录的超链接。
#### 访问权
GDPR 赋予欧盟公民更多的权利。其中一项权利是向企业查询个人数据包括哪些，保存在哪里；如果<ruby> 数据相关人 <rt> data subject </rt></ruby>（例如欧盟公民）提出获取相应数据副本的需求，企业还应免费提供数字形式的数据。
#### 遗忘权
欧盟居民还从 GDPR 获得了“遗忘权”，即数据擦除。该权利是指，在一定限制条件下，企业必须删除个人数据，甚至可能停止其自身或第三方机构后续处理申请人的数据。
上述三种改变要求你的平台软件也要遵循 GDPR 的某些方面。需要提供特定的功能，例如获取并保存授权，提取数据并向数据相关人提供数字形式的副本，以及删除数据相关人对应的数据等。
#### 泄露通知
在 GDPR 看来，不经数据相关人授权情况下使用或偷取个人数据都被视为<ruby> 数据泄露 <rt> data breach </rt></ruby>。一旦发现，你应该在 72 小时内通知社区成员，除非这些个人数据不太可能给<ruby> 自然人 <rt> natural persons </rt></ruby>的权利与自由带来风险。GDPR 强制要求执行泄露通知。
#### 披露记录
企业负责提供一份记录，用于详细披露个人数据处理的过程和目的等。该记录用于证明企业遵从 GDPR 要求，维护了一份个人数据处理行为的记录；同时该记录也用于审计。
#### 罚款
不遵循 GDPR 的企业最高可面临全球年收入总额 4% 或 2000 万欧元 （取两者较大值）的罚款。根据 GDPR，“最高处罚针对严重的侵权行为，包括未经用户充分授权的情况下处理数据，以及违反设计理念中核心隐私部分”。
### 补充说明
本文不应用于法律建议或 GDPR 合规的指导书。我提到了可能对开源社区有影响的条约部分，希望引起大家对 GDPR 及其影响的关注。当然，条约包含了更多你需要了解和可能需要遵循的条款。
你自己也可能认识到，当运营一个面向全球的社区时，需要行动起来使其遵循 GDPR。如果在社区中，你已经遵循包括 ISO 27001，NIST 和 PCI DSS 在内的健壮安全标准，你已经先人一步。
可以从如下网站/资源中获取更多关于 GDPR 的信息：
* [GDPR 官网](https://www.eugdpr.org/eugdpr.org.html) (欧盟提供)
* [官方条约 （欧盟） 2016/679](http://eur-lex.europa.eu/legal-content/EN/TXT/?qid=1520531479111&uri=CELEX:32016R0679) （GDPR，包含翻译）
* [GDPR 是什么？ 领导人需要知道的 8 件事](https://enterprisersproject.com/article/2018/4/what-gdpr-8-things-leaders-should-know) （企业人项目）
* [如何规避 GDPR 合规审计：最佳实践](https://enterprisersproject.com/article/2017/9/avoiding-gdpr-compliance-audit-best-practices) （企业人项目）
### 关于作者
Robin Muilwijk 是一名互联网和电子政务顾问，在 Red Hat 旗下在线发布平台 Opensource.com 担任社区版主，在 Open Organization 担任大使。此外，Robin 还是 eZ 社区董事会成员，[eZ 系统](http://ez.no) 社区的管理员。Robin 活跃在社交媒体中，促进和支持商业和生活领域的开源项目。可以在 Twitter 上关注 [Robin Muilwijk](https://opensource.com/users/robinmuilwijk) 以获取更多关于他的信息。[更多关于我的信息](https://opensource.com/users/robinmuilwijk)
---
via: <https://opensource.com/article/18/4/gdpr-impact>
作者: [Robin Muilwijk](https://opensource.com/users/robinmuilwijk) 选题者: [lujun9972](https://github.com/lujun9972) 译者: [pinewall](https://github.com/pinewall) 校对: [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一些常见的并发编程错误
|
Go101
|
https://go101.org/article/concurrent-common-mistakes.html
|
Go 并不会阻止一些因 Go 程序员粗心大意或者缺乏经验而造成的并发编程错误。在本文的下面部分将展示一些在 Go 编程中常见的并发编程错误，以帮助 Go 程序员们避免再犯类似的错误。
|
/data/attachment/album/201806/08/005141b113xwdldwcv1wgv.jpg.thumb.jpg
|
/data/attachment/album/201806/08/005141b113xwdldwcv1wgv.jpg
| true | false | true |
qhwdw
| false |
[
"Go",
"并发",
"协程"
] |
软件开发
|
{
"viewnum": 6021,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Go 并不会阻止一些因 Go 程序员粗心大意或者缺乏经验而造成的并发编程错误。在本文的下面部分将展示一些在 Go 编程中常见的并发编程错误，以帮助 Go 程序员们避免再犯类似的错误。
| 2018-06-08T00:52:05 | 2018-06-08T00:52:05 | 9,726 |
/article-9726-1.html
|
Go 是一个内置支持并发编程的语言。借助使用 `go` 关键字去创建<ruby> 协程 <rt> goroutine </rt></ruby>（轻量级线程）和在 Go 中提供的 [使用](https://go101.org/article/channel-use-cases.html) [信道](https://go101.org/article/channel.html) 和 [其它的并发](https://go101.org/article/concurrent-atomic-operation.html) [同步方法](https://go101.org/article/concurrent-synchronization-more.html)，使得并发编程变得很容易、很灵活和很有趣。
另一方面，Go 并不会阻止一些因 Go 程序员粗心大意或者缺乏经验而造成的并发编程错误。在本文的下面部分将展示一些在 Go 编程中常见的并发编程错误，以帮助 Go 程序员们避免再犯类似的错误。
### 需要同步的时候没有同步
代码行或许 [不是按出现的顺序运行的](https://go101.org/article/memory-model.html)。
在下面的程序中有两个错误。
* 第一，在 `main` 协程中读取 `b` 和在新的 协程 中写入 `b` 可能导致数据争用。
* 第二，条件 `b == true` 并不能保证在 `main` 协程 中的 `a != nil`。在新的协程中编译器和 CPU 可能会通过 [重排序指令](https://go101.org/article/memory-model.html) 进行优化，因此，在运行时 `b` 赋值可能发生在 `a` 赋值之前，在 `main` 协程 中当 `a` 被修改后，它将会让部分 `a` 一直保持为 `nil`。
```
package main
import (
"time"
"runtime"
)
func main() {
var a []int // nil
var b bool // false
// a new goroutine
go func () {
a = make([]int, 3)
b = true // write b
}()
for !b { // read b
time.Sleep(time.Second)
runtime.Gosched()
}
a[0], a[1], a[2] = 0, 1, 2 // might panic
}
```
上面的程序或者在一台计算机上运行的很好，但是在另一台上可能会引发异常。或者它可能运行了 *N* 次都很好，但是可能在第 *(N+1)* 次引发了异常。
我们将使用 `sync` 标准包中提供的信道或者同步方法去确保内存中的顺序。例如，
```
package main
func main() {
var a []int = nil
c := make(chan struct{})
// a new goroutine
go func () {
a = make([]int, 3)
c <- struct{}{}
}()
<-c
a[0], a[1], a[2] = 0, 1, 2
}
```
### 使用 `time.Sleep` 调用去做同步
我们先来看一个简单的例子。
```
package main
import (
"fmt"
"time"
)
func main() {
var x = 123
go func() {
x = 789 // write x
}()
time.Sleep(time.Second)
fmt.Println(x) // read x
}
```
我们预期程序将打印出 `789`。如果我们运行它，通常情况下，它确定打印的是 `789`。但是，这个程序使用的同步方式好吗？No！原因是 Go 运行时并不保证 `x` 的写入一定会发生在 `x` 的读取之前。在某些条件下，比如在同一个操作系统上，大部分 CPU 资源被其它运行的程序所占用的情况下，写入 `x` 可能就会发生在读取 `x` 之后。这就是为什么我们在正式的项目中，从来不使用 `time.Sleep` 调用去实现同步的原因。
我们来看一下另外一个示例。
```
package main
import (
"fmt"
"time"
)
var x = 0
func main() {
var num = 123
var p = &num
c := make(chan int)
go func() {
c <- *p + x
}()
time.Sleep(time.Second)
num = 789
fmt.Println(<-c)
}
```
你认为程序的预期输出是什么？`123` 还是 `789`？事实上它的输出与编译器有关。对于标准的 Go 编译器 1.10 来说，这个程序很有可能输出是 `123`。但是在理论上，它可能输出的是 `789`，或者其它的随机数。
现在，我们来改变 `c <- *p + x` 为 `c <- *p`，然后再次运行这个程序。你将会发现输出变成了 `789` （使用标准的 Go 编译器 1.10）。这再次说明它的输出是与编译器相关的。
是的，在上面的程序中存在数据争用。表达式 `*p` 可能会被先计算、后计算、或者在处理赋值语句 `num = 789` 时计算。`time.Sleep` 调用并不能保证 `*p` 发生在赋值语句处理之前进行。
对于这个特定的示例，我们将在新的协程创建之前，将值保存到一个临时值中，然后在新的协程中使用临时值去消除数据争用。
```
...
tmp := *p + x
go func() {
c <- tmp
}()
...
```
### 使协程挂起
挂起协程是指让协程一直处于阻塞状态。导致协程被挂起的原因很多。比如，
* 一个协程尝试从一个 nil 信道中或者从一个没有其它协程给它发送值的信道中检索数据。
* 一个协程尝试去发送一个值到 nil 信道，或者发送到一个没有其它的协程接收值的信道中。
* 一个协程被它自己死锁。
* 一组协程彼此死锁。
* 当运行一个没有 `default` 分支的 `select` 代码块时，一个协程被阻塞，以及在 `select` 代码块中 `case` 关键字后的所有信道操作保持阻塞状态。
除了有时我们为了避免程序退出，特意让一个程序中的 `main` 协程保持挂起之外，大多数其它的协程挂起都是意外情况。Go 运行时很难判断一个协程到底是处于挂起状态还是临时阻塞。因此，Go 运行时并不会去释放一个挂起的协程所占用的资源。
在 [谁先响应谁获胜](https://go101.org/article/channel-use-cases.html#first-response-wins) 的信道使用案例中，如果使用的 future 信道容量不够大，当尝试向 Future 信道发送结果时，一些响应较慢的信道将被挂起。比如，如果调用下面的函数，将有 4 个协程处于永远阻塞状态。
```
func request() int {
c := make(chan int)
for i := 0; i < 5; i++ {
i := i
go func() {
c <- i // 4 goroutines will hang here.
}()
}
return <-c
}
```
为避免这 4 个协程一直处于挂起状态， `c` 信道的容量必须至少是 `4`。
在 [实现谁先响应谁获胜的第二种方法](https://go101.org/article/channel-use-cases.html#first-response-wins-2) 的信道使用案例中，如果将 future 信道用做非缓冲信道，那么有可能这个信息将永远也不会有响应而挂起。例如，如果在一个协程中调用下面的函数，协程可能会挂起。原因是，如果接收操作 `<-c` 准备就绪之前，五个发送操作全部尝试发送，那么所有的尝试发送的操作将全部失败，因此那个调用者协程将永远也不会接收到值。
```
func request() int {
c := make(chan int)
for i := 0; i < 5; i++ {
i := i
go func() {
select {
case c <- i:
default:
}
}()
}
return <-c
}
```
将信道 `c` 变成缓冲信道将保证五个发送操作中的至少一个操作会发送成功，这样，上面函数中的那个调用者协程将不会被挂起。
### 在 `sync` 标准包中拷贝类型值
在实践中，`sync` 标准包中的类型值不会被拷贝。我们应该只拷贝这个值的指针。
下面是一个错误的并发编程示例。在这个示例中，当调用 `Counter.Value` 方法时，将拷贝一个 `Counter` 接收值。作为接收值的一个字段，`Counter` 接收值的各个 `Mutex` 字段也会被拷贝。拷贝不是同步发生的，因此，拷贝的 `Mutex` 值可能会出错。即便是没有错误，拷贝的 `Counter` 接收值的访问保护也是没有意义的。
```
import "sync"
type Counter struct {
sync.Mutex
n int64
}
// This method is okay.
func (c *Counter) Increase(d int64) (r int64) {
c.Lock()
c.n += d
r = c.n
c.Unlock()
return
}
// The method is bad. When it is called, a Counter
// receiver value will be copied.
func (c Counter) Value() (r int64) {
c.Lock()
r = c.n
c.Unlock()
return
}
```
我们只需要改变 `Value` 接收类型方法为指针类型 `*Counter`，就可以避免拷贝 `Mutex` 值。
在官方的 Go SDK 中提供的 `go vet` 命令将会报告潜在的错误值拷贝。
### 在错误的地方调用 `sync.WaitGroup` 的方法
每个 `sync.WaitGroup` 值维护一个内部计数器，这个计数器的初始值为 0。如果一个 `WaitGroup` 计数器的值是 0，调用 `WaitGroup` 值的 `Wait` 方法就不会被阻塞，否则，在计数器值为 0 之前，这个调用会一直被阻塞。
为了让 `WaitGroup` 值的使用有意义，当一个 `WaitGroup` 计数器值为 0 时，必须在相应的 `WaitGroup` 值的 `Wait` 方法调用之前，去调用 `WaitGroup` 值的 `Add` 方法。
例如，下面的程序中，在不正确位置调用了 `Add` 方法，这将使最后打印出的数字不总是 `100`。事实上，这个程序最后打印的数字可能是在 `[0, 100)` 范围内的一个随意数字。原因就是 `Add` 方法的调用并不保证一定会发生在 `Wait` 方法调用之前。
```
package main
import (
"fmt"
"sync"
"sync/atomic"
)
func main() {
var wg sync.WaitGroup
var x int32 = 0
for i := 0; i < 100; i++ {
go func() {
wg.Add(1)
atomic.AddInt32(&x, 1)
wg.Done()
}()
}
fmt.Println("To wait ...")
wg.Wait()
fmt.Println(atomic.LoadInt32(&x))
}
```
为让程序的表现符合预期，在 `for` 循环中，我们将把 `Add` 方法的调用移动到创建的新协程的范围之外，修改后的代码如下。
```
...
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
atomic.AddInt32(&x, 1)
wg.Done()
}()
}
...
```
### 不正确使用 futures 信道
在 [信道使用案例](https://go101.org/article/channel-use-cases.html) 的文章中，我们知道一些函数将返回 [futures 信道](https://go101.org/article/channel-use-cases.html#future-promise)。假设 `fa` 和 `fb` 就是这样的两个函数，那么下面的调用就使用了不正确的 future 参数。
```
doSomethingWithFutureArguments(<-fa(), <-fb())
```
在上面的代码行中，两个信道接收操作是顺序进行的，而不是并发的。我们做如下修改使它变成并发操作。
```
ca, cb := fa(), fb()
doSomethingWithFutureArguments(<-c1, <-c2)
```
### 没有等协程的最后的活动的发送结束就关闭信道
Go 程序员经常犯的一个错误是，还有一些其它的协程可能会发送值到以前的信道时，这个信道就已经被关闭了。当这样的发送（发送到一个已经关闭的信道）真实发生时，将引发一个异常。
这种错误在一些以往的著名 Go 项目中也有发生，比如在 Kubernetes 项目中的 [这个 bug](https://github.com/kubernetes/kubernetes/pull/45291/files?diff=split) 和 [这个 bug](https://github.com/kubernetes/kubernetes/pull/39479/files?diff=split)。
如何安全和优雅地关闭信道，请阅读 [这篇文章](https://go101.org/article/channel-closing.html)。
### 在值上做 64 位原子操作时没有保证值地址 64 位对齐
到目前为止（Go 1.10），在标准的 Go 编译器中，在一个 64 位原子操作中涉及到的值的地址要求必须是 64 位对齐的。如果没有对齐则导致当前的协程异常。对于标准的 Go 编译器来说，这种失败仅发生在 32 位的架构上。请阅读 [内存布局](https://go101.org/article/memory-layout.html) 去了解如何在一个 32 位操作系统上保证 64 位对齐。
### 没有注意到大量的资源被 `time.After` 函数调用占用
在 `time` 标准包中的 `After` 函数返回 [一个延迟通知的信道](https://go101.org/article/channel-use-cases.html#timer)。这个函数在某些情况下用起来很便捷，但是，每次调用它将创建一个 `time.Timer` 类型的新值。这个新创建的 `Timer` 值在通过传递参数到 `After` 函数指定期间保持激活状态，如果在这个期间过多的调用了该函数，可能会有太多的 `Timer` 值保持激活，这将占用大量的内存和计算资源。
例如，如果调用了下列的 `longRunning` 函数，将在一分钟内产生大量的消息，然后在某些周期内将有大量的 `Timer` 值保持激活，即便是大量的这些 `Timer` 值已经没用了也是如此。
```
import (
"fmt"
"time"
)
// The function will return if a message arrival interval
// is larger than one minute.
func longRunning(messages <-chan string) {
for {
select {
case <-time.After(time.Minute):
return
case msg := <-messages:
fmt.Println(msg)
}
}
}
```
为避免在上述代码中创建过多的 `Timer` 值，我们将使用一个单一的 `Timer` 值去完成同样的任务。
```
func longRunning(messages <-chan string) {
timer := time.NewTimer(time.Minute)
defer timer.Stop()
for {
select {
case <-timer.C:
return
case msg := <-messages:
fmt.Println(msg)
if !timer.Stop() {
<-timer.C
}
}
// The above "if" block can also be put here.
timer.Reset(time.Minute)
}
}
```
### 不正确地使用 `time.Timer` 值
在最后，我们将展示一个符合语言使用习惯的 `time.Timer` 值的使用示例。需要注意的一个细节是，那个 `Reset` 方法总是在停止或者 `time.Timer` 值释放时被使用。
在 `select` 块的第一个 `case` 分支的结束部分，`time.Timer` 值被释放，因此，我们不需要去停止它。但是必须在第二个分支中停止定时器。如果在第二个分支中 `if` 代码块缺失，它可能至少在 `Reset` 方法调用时，会（通过 Go 运行时）发送到 `timer.C` 信道，并且那个 `longRunning` 函数可能会早于预期返回，对于 `Reset` 方法来说，它可能仅仅是重置内部定时器为 0，它将不会清理（耗尽）那个发送到 `timer.C` 信道的值。
例如，下面的程序很有可能在一秒内而不是十秒时退出。并且更重要的是，这个程序并不是 DRF 的（LCTT 译注：data race free，多线程程序的一种同步程度）。
```
package main
import (
"fmt"
"time"
)
func main() {
start := time.Now()
timer := time.NewTimer(time.Second/2)
select {
case <-timer.C:
default:
time.Sleep(time.Second) // go here
}
timer.Reset(time.Second * 10)
<-timer.C
fmt.Println(time.Since(start)) // 1.000188181s
}
```
当 `time.Timer` 的值不再被其它任何一个东西使用时，它的值可能被停留在一种非停止状态，但是，建议在结束时停止它。
在多个协程中如果不按建议使用 `time.Timer` 值并发，可能会有 bug 隐患。
我们不应该依赖一个 `Reset` 方法调用的返回值。`Reset` 方法返回值的存在仅仅是为了兼容性目的。
---
via: <https://go101.org/article/concurrent-common-mistakes.html>
作者：<go101.org> 译者：[qhwdw](https://github.com/qhwdw) 校对：[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.