document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-01-28 23:20:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #99 from LCTT/master

Browse Source 
update
This commit is contained in:
MjSeven 2018-11-06 14:35:36 +08:00 committed by GitHub
commit 92417b03e0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 2107 additions and 910 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
published/20170928 A 3-step process for making more transparent decisions.md Normal file
View File

@ -0,0 +1,80 @@
让决策更透明的三步
======
> 当您使用这种决策技巧时，可以使你作为一个开源领导人做出决策时更透明。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/GOV_Transparency_A.png?itok=2r47nFJB)
要让你的领导工作更加透明，其中一个最有效的方法就是将一个现有的流程开放给你的团队进行反馈，然后根据反馈去改变流程。下面这些练习能让透明度更加切实，并且它有助于让你在持续评估并调整你的工作的透明度时形成“肌肉记忆”。
我想说，你可以通过任何流程来完成这项工作 —— 即使有些流程看起来像是“禁区”流程，比如晋升或者调薪。但是如果第一次它对于初步实践来说太大了，那么你可能需要从一个不那么敏感的流程开始，比如旅行批准流程或者为你的团队寻找空缺候选人的系统。（举个例子，我在我们的招聘和晋升流程中使用了这种方式）
开放流程并使其更加透明可以建立你的信誉并增强团队成员对你的信任。它会使你以一种可能超乎你设想和舒适程度的方式“走在透明的路上”。以这种方式工作确实会产生额外的工作，尤其是在过程的开始阶段 —— 但是，最终这种方法对于让管理者（比如我）对团队成员更具责任，而且它会更加相容。
### 阶段一：选择一个流程
**第一步** 想想你的团队使用的一个普通的或常规的流程，但是这个流程通常不需要仔细检查。下面有一些例子：
* 招聘：如何创建职位描述、如何挑选面试团队、如何筛选候选人以及如何做出最终的招聘决定。
* 规划：你的团队或组织如何确定年度或季度目标。
* 升职：你如何选择并考虑升职候选人，并决定谁升职。
* 经理绩效评估：谁有机会就经理绩效提供反馈，以及他们是如何反馈。
* 旅游：旅游预算如何分配，以及你如何决定是否批准旅行（或提名某人是否旅行）。
上面的某个例子可能会引起你的共鸣，或者你可能会发现一些你觉得更合适的流程。也许你已经收到了关于某个特定流程的问题，又或者你发现自己屡次解释某个特定决策的逻辑依据。选择一些你能够控制或影响的东西 —— 一些你认为你的成员所关心的东西。
**第二步** 现在回答以下关于这个流程的问题：
* 该流程目前是否记录在一个所有成员都知道并可以访问的地方？如果没有，现在就开始创建文档（不必太详细；只需要解释这个流程的不同步骤以及它是如何工作的）。你可能会发现这个过程不够清晰或一致，无法记录到文档。在这种情况下，用你*认为*理想情况下所应该的方式去记录它。
* 完成流程的文档是否说明了在不同的点上是如何做出决定？例如，在旅行批准流程中，它是否解释了如何批准或拒绝请求。
* 流程的*输入信息*是什么？例如，在确定部门年度目标时，哪些数据用于关键绩效指标，查找或者采纳谁的反馈，谁有机会审查或“签字”。
* 这个过程会做出什么*假设*？例如，在升职决策中，你是否认为所有的晋升候选人都会在适当的时间被他们的经理提出。
* 流程的*输出物*是什么？例如，在评估经理的绩效时，评估的结果是否会与经理共享，该审查报告的任何方面是否会与经理的直接报告更广泛地共享（例如，改进的领域)？
回答上述问题时，避免作出判断。如果这个流程不能清楚地解释一个决定是如何做出的，那也可以接受。这些问题只是评估现状的一个机会。
接下来，修改流程的文档，直到你对它充分说明了流程并预测潜在的问题感到满意。
### 阶段二：收集反馈
下一个阶段涉及到与你的成员分享这个流程并要求反馈。分享说起来容易做起来难。
**第一步** 鼓励人们提供反馈。考虑一下实现此目的的各种机制：
* 把这个流程公布在人们可以在内部找到的地方，并提示他们可以在哪里发表评论或提供反馈。谷歌文档可以很好地评论特定的文本或直接提议文本中的更改。
* 通过电子邮件分享过程文档，邀请反馈。
* 提及流程文档，在团队会议或一对一的谈话时要求反馈。
* 给人们一个他们可以提供反馈的时间窗口，并在此窗口内定期发送提醒。
如果你得不到太多的反馈，不要认为沉默就等于认可。你可以试着直接询问人们，他们为什么没有反馈。是因为他们太忙了吗？这个过程对他们来说不像你想的那么重要吗？你清楚地表达了你的要求吗？
**第二步** 迭代。当你获得关于流程的反馈时，鼓励团队对流程进行修改和迭代。加入改进的想法和建议，并要求确认预期的反馈已经被应用。如果你不同意某个建议，那就接受讨论，问问自己为什么不同意，以及一种方法和另一种方法的优点是什么。
设置一个收集反馈和迭代的时间窗口有助于向前推进。一旦收集和审查了反馈，你应当讨论和应用它，并且发布最终的流程供团队审查。
### 阶段三：实现
实现一个流程通常是计划中最困难的阶段。但如果你在修改过程中考虑了反馈意见，人们应该已经预料到了，并且可能会更支持你。从上面迭代过程中获得的文档是一个很好的工具，可以让你对实现负责。
**第一步** 审查实施需求。许多可以从提高透明度中获益的流程只需要做一点不同的事情，但是你确实需要检查你是否需要其他支持（例如工具）。
**第二步** 设置实现的时间表。与成员一起回顾时间表，这样他们就知道会发生什么。如果新流程需要对其他流程进行更改，请确保为人们提供足够的时间去适应新方式，并提供沟通和提醒。
**第三步** 跟进。在使用该流程 3-6 个月后，与你的成员联系，看看进展如何。新流程是否更加透明、更有效、更可预测？你有什么经验教训可以用来进一步改进这个流程吗？
### 关于作者
Sam Knuth —— 我有幸在 Red Hat 领导客户内容服务团队；我们生成提供给我们的客户的所有文档。我们的目标是为客户提供他们在企业中使用开源技术取得成功所需要的洞察力。在 Twitter 上与我联系（[@samfw][1]）。
--------------------------------------------------------------------------------
via: https://opensource.com/open-organization/17/9/exercise-in-transparent-decisions
作者：[Sam Knuth][a]
译者：[MarineFish](https://github.com/MarineFish)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/samfw
[1]: https://twitter.com/samfw

142
translated/tech/20180101 Manage Your Games Using Lutris In Linux.md → published/20180101 Manage Your Games Using Lutris In Linux.md
View File

@ -1,67 +1,71 @@
在 Linux 上使用 Lutries 管理你的游戏
======
![](https://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-1-720x340.jpg)
让我们用游戏开始 2018 的第一天吧！今天我们要讨论的是 **Lutris**，一个 Linux 上的开源游戏平台。你可以使用 Lutries 安装、移除、配置、启动和管理你的游戏。它可以以一个界面帮你管理你的 Linux 游戏、Windows 游戏、仿真控制台游戏和浏览器游戏。它还包含社区编写的安装脚本，使得游戏的安装过程更加简单。
今天我们要讨论的是 **Lutris**，一个 Linux 上的开源游戏平台。你可以使用 Lutries 安装、移除、配置、启动和管理你的游戏。它可以在一个单一界面中帮你管理你的 Linux 游戏、Windows 游戏、仿真控制台游戏和浏览器游戏。它还包含社区编写的安装脚本，使得游戏的安装过程更加简单。
Lutries 自动安装（或者你可以单击点击安装）了超过 20 个模拟器，它提供了从七十年代到现在的大多数游戏系统。目前支持的游戏系统如下：
* Native Linux
* Linux 原生
* Windows
* Steam (Linux and Windows)
* Steam (Linux 和 Windows)
* MS-DOS
* 街机
* Amiga 电脑
* Atari 8 和 16 位计算机和控制器
* 浏览器 (Flash 或者 HTML5 游戏)
* Commmodore 8 位计算机
* 基于 SCUMM 的游戏和其他点击冒险游戏
* Magnavox Odyssey², Videopac+
* 基于 SCUMM 的游戏和其他点击式冒险游戏
* Magnavox Odyssey²、Videopac+
* Mattel Intellivision
* NEC PC-Engine Turbographx 16, Supergraphx, PC-FX
* Nintendo NES, SNES, Game Boy, Game Boy Advance, DS
* Game Cube and Wii
* Sega Master Sytem, Game Gear, Genesis, Dreamcast
* SNK Neo Geo, Neo Geo Pocket
* NEC PC-Engine Turbographx 16、Supergraphx、PC-FX
* Nintendo NES、SNES、Game Boy、Game Boy Advance、DS
* Game Cube 和 Wii
* Sega Master Sytem、Game Gear、Genesis、Dreamcast
* SNK Neo Geo、Neo Geo Pocket
* Sony PlayStation
* Sony PlayStation 2
* Sony PSP
* 像 Zork 这样的 Z-Machine 游戏
* 还有更多
### 安装 Lutris
就像 Steam 一样，Lutries 包含两部分：网站和客户端程序。从网站你可以浏览可用的游戏，添加最喜欢的游戏到个人库，以及使用安装链接安装他们。
首先，我们还是来安装客户端。它目前支持 Arch Linux、Debian、Fedroa、Gentoo、openSUSE 和 Ubuntu。
对于 Arch Linux 和它的衍生版本，像是 Antergos, Manjaro Linux，都可以在 [**AUR**][1] 中找到。因此，你可以使用 AUR 帮助程序安装它。
对于 **Arch Linux** 和它的衍生版本，像是 Antergos, Manjaro Linux，都可以在 [AUR][1] 中找到。因此，你可以使用 AUR 帮助程序安装它。
使用 [Pacaur][2]：
使用 [**Pacaur**][2]:
```
pacaur -S lutris
```
使用 **[Packer][3]** :
使用 [Packer][3]：
```
packer -S lutris
```
使用 [**Yaourt**][4]:
使用 [Yaourt][4]：
```
yaourt -S lutris
```
使用 [**Yay**][5]:
使用 [Yay][5]：
```
yay -S lutris
```
**Debian:**
在 **Debian 9.0** 上以 **root** 身份运行以下命令：
在 **Debian 9.0** 上以 **root** 身份运行以下命令：
```
echo 'deb http://download.opensuse.org/repositories/home:/strycore/Debian_9.0/ /' > /etc/apt/sources.list.d/lutris.list
wget -nv https://download.opensuse.org/repositories/home:strycore/Debian_9.0/Release.key -O Release.key
@ -71,6 +75,7 @@ apt-get install lutris
```
在 **Debian 8.0** 上以 **root** 身份运行以下命令：
```
echo 'deb http://download.opensuse.org/repositories/home:/strycore/Debian_8.0/ /' > /etc/apt/sources.list.d/lutris.list
wget -nv https://download.opensuse.org/repositories/home:strycore/Debian_8.0/Release.key -O Release.key
@ -79,19 +84,22 @@ apt-get update
apt-get install lutris
```
在 **Fedora 27** 上以 **root** 身份运行以下命令： r
在 **Fedora 27** 上以 **root** 身份运行以下命令：
```
dnf config-manager --add-repo https://download.opensuse.org/repositories/home:strycore/Fedora_27/home:strycore.repo
dnf install lutris
```
在 **Fedora 26** 上以 **root** 身份运行以下命令：
在 **Fedora 26** 上以 **root** 身份运行以下命令：
```
dnf config-manager --add-repo https://download.opensuse.org/repositories/home:strycore/Fedora_26/home:strycore.repo
dnf install lutris
```
在 **openSUSE Tumbleweed** 上以 **root** 身份运行以下命令：
```
zypper addrepo https://download.opensuse.org/repositories/home:strycore/openSUSE_Tumbleweed/home:strycore.repo
zypper refresh
@ -99,13 +107,15 @@ zypper install lutris
```
在 **openSUSE Leap 42.3** 上以 **root** 身份运行以下命令：
```
zypper addrepo https://download.opensuse.org/repositories/home:strycore/openSUSE_Leap_42.3/home:strycore.repo
zypper refresh
zypper install lutris
```
**Ubuntu 17.10**:
**Ubuntu 17.10**：
```
sudo sh -c "echo 'deb http://download.opensuse.org/repositories/home:/strycore/xUbuntu_17.10/ /' > /etc/apt/sources.list.d/lutris.list"
wget -nv https://download.opensuse.org/repositories/home:strycore/xUbuntu_17.10/Release.key -O Release.key
@ -114,7 +124,8 @@ sudo apt-get update
sudo apt-get install lutris
```
**Ubuntu 17.04**:
**Ubuntu 17.04**：
```
sudo sh -c "echo 'deb http://download.opensuse.org/repositories/home:/strycore/xUbuntu_17.04/ /' > /etc/apt/sources.list.d/lutris.list"
wget -nv https://download.opensuse.org/repositories/home:strycore/xUbuntu_17.04/Release.key -O Release.key
@ -123,7 +134,8 @@ sudo apt-get update
sudo apt-get install lutris
```
**Ubuntu 16.10**:
**Ubuntu 16.10**：
```
sudo sh -c "echo 'deb http://download.opensuse.org/repositories/home:/strycore/xUbuntu_16.10/ /' > /etc/apt/sources.list.d/lutris.list"
wget -nv https://download.opensuse.org/repositories/home:strycore/xUbuntu_16.10/Release.key -O Release.key
@ -132,7 +144,8 @@ sudo apt-get update
sudo apt-get install lutris
```
**Ubuntu 16.04**:
**Ubuntu 16.04**：
```
sudo sh -c "echo 'deb http://download.opensuse.org/repositories/home:/strycore/xUbuntu_16.04/ /' > /etc/apt/sources.list.d/lutris.list"
wget -nv https://download.opensuse.org/repositories/home:strycore/xUbuntu_16.04/Release.key -O Release.key
@ -141,71 +154,75 @@ sudo apt-get update
sudo apt-get install lutris
```
对于其他平台，参考 [**Lutris 下载链接**][6].
对于其他平台，参考 [Lutris 下载链接][6]。
### 使用 Lutris 管理你的游戏
安装完成后，从菜单或者应用启动器里打开 Lutries。首次启动时，Lutries 的默认界面像下面这样：
[![][7]][8]
![][8]
**登录你的 Lutris.net 账号**
#### 登录你的 Lutris.net 账号
为了能同步你个人库中的游戏，下一步你需要在客户端中登录你的 Lutris.net 账号。如果你没有，先 [**注册一个新的账号**][9]。然后点击 **"连接到你的 Lutirs.net 账号同步你的库 "** 连接到 Lutries 客户端。
为了能同步你个人库中的游戏，下一步你需要在客户端中登录你的 Lutris.net 账号。如果你没有，先 [注册一个新的账号][9]。然后点击 “Connecting to your Lutirs.net account to sync your library” 连接到 Lutries 客户端。
输入你的账号信息然后点击 **继续**。
输入你的账号信息然后点击 “Connect”。
[![][7]][10]
![][10]
现在你已经连接到你的 Lutries.net 账号了。
[![][7]][11]**Browse Games**
![][11]
#### 浏览游戏
点击工具栏里的浏览图标（游戏控制器图标）可以搜索任何游戏。它会自动定向到 Lutries 网站的游戏页。你可以以字母顺序查看所有可用的游戏。Lutries 现在已经有了很多游戏，而且还有更多的不断添加进来。
[![][7]][12]
![][12]
任选一个游戏，添加到你的库中。
[![][7]][13]
![][13]
然后返回到你的 Lutries 客户端，点击 **菜单 - > Lutris -> 同步库**。现在你可以在本地的 Lutries 客户端中看到所有在库中的游戏了。
然后返回到你的 Lutries 客户端，点击 “Menu -> Lutris -> Synchronize library”。现在你可以在本地的 Lutries 客户端中看到所有在库中的游戏了。
[![][7]][14]
![][14]
如果你没有看到游戏，只需要重启一次。
**安装游戏**
#### 安装游戏
安装游戏，只需要点击游戏，然后点击 **安装** 按钮。例如，我想在我的系统安装 [**2048**][15]，就像你在底下的截图中看到的，它要求我选择一个版本去安装。因为它只有一个版本（例如，在线），它就会自动选择这个版本。点击 **继续**。
安装游戏，只需要点击游戏，然后点击 “Install” 按钮。例如，我想在我的系统安装 [2048][15]，就像你在底下的截图中看到的，它要求我选择一个版本去安装。因为它只有一个版本（例如，在线），它就会自动选择这个版本。点击 “Continue”。
[![][7]][16]Click Install:
![][16]
[![][7]][17]
点击“Install”：
![][17]
安装完成之后，你可以启动新安装的游戏或是关闭这个窗口，继续从你的库中安装其他游戏。
**导入 Steam 库**
#### 导入 Steam 库
你也可以导入你的 Steam 库。在你的头像处点击 **"通过 Steam 登录"** 按钮。接下来你将被重定向到 Steam，输入你的账号信息。填写正确后，你的 Steam 账号将被连接到 Lutries 账号。请注意，为了同步库中的游戏，这里你的 Steam 账号将被公开。你可以在同步完成之后将其重新设为私密状态。
你也可以导入你的 Steam 库。在你的头像处点击 “Sign in through Steam” 按钮。接下来你将被重定向到 Steam，输入你的账号信息。填写正确后，你的 Steam 账号将被连接到 Lutries 账号。请注意，为了同步库中的游戏，这里你的 Steam 账号将被公开。你可以在同步完成之后将其重新设为私密状态。
**手动添加游戏**
#### 手动添加游戏
Lutries 有手动添加游戏的选项。在工具栏中点击 + 号登录。
Lutries 有手动添加游戏的选项。在工具栏中点击 “+” 号登录。
[![][7]][18]
![][18]
在下一个窗口，输入游戏名，在游戏信息栏选择一个运行器。运行器是指 Linux 上类似 wine，Steam 之类的程序，它们可以帮助你启动这个游戏。你可以从 菜单 -> 管理运行器 中安装运行器。
在下一个窗口，输入游戏名，在游戏信息栏选择一个运行器。运行器是指 Linux 上类似 wine、Steam 之类的程序，它们可以帮助你启动这个游戏。你可以从 “Menu -> Manage” 中安装运行器。
[![][7]][19]
![][19]
然后在下一栏中选择可执行文件或者 ISO。最后点击保存。有一个好消息是，你可以添加一个游戏的多个版本。
**移除游戏**
#### 移除游戏
移除任何已安装的游戏，只需在 Lutries 客户端的本地库中点击对应的游戏。选择 **移除** 然后 **应用**。
移除任何已安装的游戏，只需在 Lutries 客户端的本地库中点击对应的游戏。选择 “Remove” 然后 “Apply”。
[![][7]][20]
![][20]
Lutries 就像 Steam。只是从网站向你的库中添加游戏，并在客户端中为你安装它们。
@ -215,15 +232,13 @@ Lutries 就像 Steam。只是从网站向你的库中添加游戏，并在客户
：）
--------------------------------------------------------------------------------
via: https://www.ostechnix.com/manage-games-using-lutris-linux/
作者：[SK][a]
译者：[dianbanjiu](https://github.com/dianbanjiu)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
@ -234,17 +249,16 @@ via: https://www.ostechnix.com/manage-games-using-lutris-linux/
[4]:https://www.ostechnix.com/install-yaourt-arch-linux/
[5]:https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/
[6]:https://lutris.net/downloads/
[7]:data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
[8]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-1-1.png ()
[8]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-1-1.png
[9]:https://lutris.net/user/register/
[10]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-2.png ()
[11]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-3.png ()
[12]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-15-1.png ()
[13]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-16.png ()
[14]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-6.png ()
[10]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-2.png
[11]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-3.png
[12]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-15-1.png
[13]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-16.png
[14]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-6.png
[15]:https://www.ostechnix.com/let-us-play-2048-game-terminal/
[16]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-12.png ()
[17]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-13.png ()
[18]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-18-1.png ()
[19]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-19.png ()
[20]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-14-1.png ()
[16]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-12.png
[17]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-13.png
[18]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-18-1.png
[19]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-19.png
[20]:http://www.ostechnix.com/wp-content/uploads/2018/01/Lutris-14-1.png

75
translated/tech/20180716 How To Find The Mounted Filesystem Type In Linux.md → published/20180716 How To Find The Mounted Filesystem Type In Linux.md
View File

@ -3,17 +3,18 @@
![](https://www.ostechnix.com/wp-content/uploads/2018/07/filesystem-720x340.png)
如你所知，Linux 支持非常多的文件系统，例如 Ext4、ext3、ext2、sysfs、securityfs、FAT16、FAT32、NTFS 等等，当前被使用最多的文件系统是 Ext4。你曾经疑惑过你的 Linux 系统使用的是什么类型的文件系统吗？没有疑惑过？不用担心！我们将帮助你。本指南将解释如何在类 Unix 的操作系统中查看已挂载的文件系统类型。
如你所知，Linux 支持非常多的文件系统，例如 ext4、ext3、ext2、sysfs、securityfs、FAT16、FAT32、NTFS 等等，当前被使用最多的文件系统是 ext4。你曾经疑惑过你的 Linux 系统使用的是什么类型的文件系统吗？没有疑惑过？不用担心！我们将帮助你。本指南将解释如何在类 Unix 的操作系统中查看已挂载的文件系统类型。
### 在 Linux 中查看已挂载的文件系统类型
有很多种方法可以在 Linux 中查看已挂载的文件系统类型，下面我将给出 8 种不同的方法。那现在就让我们开始吧！
#### 方法 1 – 使用 `findmnt` 命令
#### 方法 1 – 使用 findmnt 命令
这是查出文件系统类型最常使用的方法。**findmnt** 命令将列出所有已挂载的文件系统或者搜索出某个文件系统。`findmnt` 命令能够在 `/etc/fstab`、`/etc/mtab` 或 `/proc/self/mountinfo` 这几个文件中进行搜索。
这是查出文件系统类型最常使用的方法。`findmnt` 命令将列出所有已挂载的文件系统或者搜索出某个文件系统。`findmnt` 命令能够在 `/etc/fstab`、`/etc/mtab` 或 `/proc/self/mountinfo` 这几个文件中进行搜索。
`findmnt` 预装在大多数的 Linux 发行版中，因为它是 `util-linux` 包的一部分。如果 `findmnt` 命令不可用，你可以安装这个软件包。例如，你可以使用下面的命令在基于 Debian 的系统中安装 `util-linux` 包：
`findmnt` 预装在大多数的 Linux 发行版中，因为它是 **util-linux** 包的一部分。为了防止 `findmnt` 命令不可用，你可以安装这个软件包。例如，你可以使用下面的命令在基于 Debian 的系统中安装 **util-linux** 包：
```
$ sudo apt install util-linux
```
@ -21,24 +22,27 @@ $ sudo apt install util-linux
下面让我们继续看看如何使用 `findmnt` 来找出已挂载的文件系统。
假如你只敲 `findmnt` 命令而不带任何的参数或选项，它将像下面展示的那样以树状图形式列举出所有已挂载的文件系统。
```
$ findmnt
```
**示例输出：**
示例输出：
![][2]
正如你看到的那样，`findmnt` 展示出了目标挂载点(TARGET)、源设备(SOURCE)、文件系统类型(FSTYPE)以及相关的挂载选项(OPTIONS)，例如文件系统是否是可读可写或者只读的。以我的系统为例，我的根(`/`)文件系统的类型是 EXT4 。
正如你看到的那样，`findmnt` 展示出了目标挂载点（`TARGET`）、源设备（`SOURCE`）、文件系统类型（`FSTYPE`）以及相关的挂载选项（`OPTIONS`），例如文件系统是否是可读可写或者只读的。以我的系统为例，我的根（`/`）文件系统的类型是 EXT4 。
假如你不想以树状图的形式来展示输出，可以使用 `-l` 选项来以简单平凡的形式来展示输出：
假如你不想以树状图的形式来展示输出，可以使用 **-l** 选项来以简单平凡的形式来展示输出：
```
$ findmnt -l
```
![][3]
你还可以使用 **-t** 选项来列举出特定类型的文件系统，例如下面展示的 **ext4** 文件系统类型：
你还可以使用 `-t` 选项来列举出特定类型的文件系统，例如下面展示的 `ext4` 文件系统类型：
```
$ findmnt -t ext4
TARGET SOURCE FSTYPE OPTIONS
@ -47,15 +51,18 @@ TARGET SOURCE FSTYPE OPTIONS
```
`findmnt` 还可以生成 `df` 类型的输出，使用命令
```
$ findmnt --df
```
或
```
$ findmnt -D
```
**示例输出：**
示例输出：
```
SOURCE FSTYPE SIZE USED AVAIL USE% TARGET
@ -75,6 +82,7 @@ gvfsd-fuse fuse.gvfsd-fuse 0 0 0 - /run/user/1000/gvfs
你还可以展示某个特定设备或者挂载点的文件系统类型。
查看某个特定的设备：
```
$ findmnt /dev/sda1
TARGET SOURCE FSTYPE OPTIONS
@ -82,6 +90,7 @@ TARGET SOURCE FSTYPE OPTIONS
```
查看某个特定的挂载点：
```
$ findmnt /
TARGET SOURCE FSTYPE OPTIONS
@ -89,34 +98,38 @@ TARGET SOURCE FSTYPE OPTIONS
```
你甚至还可以查看某个特定标签的文件系统的类型：
```
$ findmnt LABEL=Storage
```
更多详情，请参考其 man 手册。
```
$ man findmnt
```
`findmnt` 命令已足够完成在 Linux 中查看已挂载文件系统类型的任务，这个命令就是为了这个特定任务而生的。然而，还存在其他方法来查看文件系统的类型，假如你感兴趣的话，请接着让下看。
`findmnt` 命令已足够完成在 Linux 中查看已挂载文件系统类型的任务，这个命令就是为了这个特定任务而生的。然而，还存在其他方法来查看文件系统的类型，假如你感兴趣的话，请接着往下看。
#### 方法 2 – 使用 `blkid` 命令
#### 方法 2 – 使用 blkid 命令
**blkid** 命令被用来查找和打印块设备的属性。它也是 **util-linux** 包的一部分，所以你不必再安装它。
`blkid` 命令被用来查找和打印块设备的属性。它也是 `util-linux` 包的一部分，所以你不必再安装它。
为了使用 `blkid` 命令来查看某个文件系统的类型，可以运行：
```
$ blkid /dev/sda1
```
#### 方法 3 – 使用 `df` 命令
#### 方法 3 – 使用 df 命令
在类 Unix 的操作系统中，`df` 命令被用来报告文件系统的磁盘空间使用情况。为了查看所有已挂载文件系统的类型，只需要运行：
在类 Unix 的操作系统中， **df** 命令被用来报告文件系统的磁盘空间使用情况。为了查看所有已挂载文件系统的类型，只需要运行：
```
$ df -T
```
**示例输出：**
示例输出：
![][4]
@ -125,15 +138,17 @@ $ df -T
- [针对新手的 df 命令教程](https://www.ostechnix.com/the-df-command-tutorial-with-examples-for-beginners/)
同样也可以参考其 man 手册：
```
$ man df
```
#### 方法 4 – 使用 `file` 命令
#### 方法 4 – 使用 file 命令
**file** 命令可以判读出某个特定文件的类型，即便该文件没有文件后缀名也同样适用。
`file` 命令可以判读出某个特定文件的类型，即便该文件没有文件后缀名也同样适用。
运行下面的命令来找出某个特定分区的文件系统类型：
```
$ sudo file -sL /dev/sda1
[sudo] password for sk:
@ -141,13 +156,14 @@ $ sudo file -sL /dev/sda1
```
查看其 man 手册可以知晓更多细节：
```
$ man file
```
#### 方法 5 – 使用 `fsck` 命令
#### 方法 5 – 使用 fsck 命令
**fsck** 命令被用来检查某个文件系统是否健全或者修复它。你可以像下面那样通过将分区名字作为 `fsck` 的参数来查看该分区的文件系统类型：
`fsck` 命令被用来检查某个文件系统是否健全或者修复它。你可以像下面那样通过将分区名字作为 `fsck` 的参数来查看该分区的文件系统类型：
```
$ fsck -N /dev/sda1
@ -156,15 +172,17 @@ fsck from util-linux 2.32
```
如果想知道更多的内容，请查看其 man 手册：
```
$ man fsck
```
#### 方法 6 – 使用 `fstab` 命令
#### 方法 6 – 使用 fstab 命令
**fstab** 是一个包含文件系统静态信息的文件。这个文件通常包含了挂载点、文件系统类型和挂载选项等信息。
`fstab` 是一个包含文件系统静态信息的文件。这个文件通常包含了挂载点、文件系统类型和挂载选项等信息。
要查看某个文件系统的类型，只需要运行：
```
$ cat /etc/fstab
```
@ -172,15 +190,17 @@ $ cat /etc/fstab
![][5]
更多详情，请查看其 man 手册：
```
$ man fstab
```
#### 方法 7 – 使用 `lsblk` 命令
#### 方法 7 – 使用 lsblk 命令
**lsblk** 命令可以展示设备的信息。
`lsblk` 命令可以展示设备的信息。
要展示已挂载文件系统的信息，只需运行：
```
$ lsblk -f
NAME FSTYPE LABEL UUID MOUNTPOINT
@ -193,15 +213,17 @@ sr0
```
更多细节，可以参考它的 man 手册：
```
$ man lsblk
```
#### 方法 8 – 使用 `mount` 命令
#### 方法 8 – 使用 mount 命令
**mount** 被用来在类 Unix 系统中挂载本地或远程的文件系统。
`mount` 被用来在类 Unix 系统中挂载本地或远程的文件系统。
要使用 `mount` 命令查看文件系统的类型，可以像下面这样做：
```
$ mount | grep "^/dev"
/dev/sda2 on / type ext4 (rw,relatime,commit=360)
@ -209,6 +231,7 @@ $ mount | grep "^/dev"
```
更多详情，请参考其 man 手册的内容：
```
$ man mount
```
@ -224,7 +247,7 @@ via: https://www.ostechnix.com/how-to-find-the-mounted-filesystem-type-in-linux/
作者：[SK][a]
选题：[lujun9972](https://github.com/lujun9972)
译者：[FSSlc](https://github.com/FSSlc)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

38
translated/tech/20180820 How To Disable Ads In Terminal Welcome Message In Ubuntu Server.md → published/20180820 How To Disable Ads In Terminal Welcome Message In Ubuntu Server.md
View File

@ -1,34 +1,32 @@
如何在 Ubuntu 服务器中禁用终端欢迎消息中的广告
如何禁用 Ubuntu 服务器中终端欢迎消息中的广告
======
如果你正在使用最新的 Ubuntu 服务器版本，你可能已经注意到欢迎消息中有一些与 Ubuntu 服务器平台无关的促销链接。你可能已经知道 **MOTD**，即 **M**essage **O**f **T**he **D**ay 的开头首字母，在 Linux 系统每次登录时都会显示欢迎信息。通常，欢迎消息包含操作系统版本，基本系统信息，官方文档链接以及有关最新安全更新等的链接。这些是我们每次通过 SSH 或本地登录时通常会看到的内容。但是，最近在终端欢迎消息中出现了一些其他链接。我已经几次注意到这些链接，但我并在意，也从未点击过。以下是我的 Ubuntu 18.04 LTS 服务器上显示的终端欢迎消息。
![](http://www.ostechnix.com/wp-content/uploads/2018/08/Ubuntu-Terminal-welcome-message.png)
正如你在上面截图中所看到的，欢迎消息中有一个 bit.ly 链接和 Ubuntu wiki 链接。有些人可能会惊讶并想知道这是什么。其实欢迎信息中的链接无需担心。它可能看起来像广告，但并不是商业广告。链接实际上指的是 [**Ubuntu 官方博客**][1] 和 [**Ubuntu wiki**][2]。正如我之前所说，其中的一个链接是不相关的，没有任何与 Ubuntu 服务器相关的细节，这就是为什么我开头称它们为广告。
（to 校正：这里是其中一个链接不相关还是两个链接都不相关）
正如你在上面截图中所看到的，欢迎消息中有一个 bit.ly 链接和 Ubuntu wiki 链接。有些人可能会惊讶并想知道这是什么。其实欢迎信息中的链接无需担心。它可能看起来像广告，但并不是商业广告。链接实际上指向到了 [Ubuntu 官方博客][1] 和 [Ubuntu wiki][2]。正如我之前所说，其中的一个链接是不相关的，没有任何与 Ubuntu 服务器相关的细节，这就是为什么我开头称它们为广告。
虽然我们大多数人都不会访问 bit.ly 链接，但是有些人可能出于好奇去访问这些链接，结果失望地发现它只是指向一个外部链接。你可以使用任何 URL 短网址服务，例如 unshorten.it，在访问真正链接之前，查看它会指向哪里。或者，你只需在 bit.ly 链接的末尾输入加号（**+**）即可查看它们的实际位置以及有关链接的一些统计信息。
虽然我们大多数人都不会访问 bit.ly 链接，但是有些人可能出于好奇去访问这些链接，结果失望地发现它只是指向一个外部链接。你可以使用任何 URL 去短网址服务，例如 unshorten.it，在访问真正链接之前，查看它会指向哪里。或者，你只需在 bit.ly 链接的末尾输入加号（`+`）即可查看它们的实际位置以及有关链接的一些统计信息。
![](http://www.ostechnix.com/wp-content/uploads/2018/08/shortlink.png)
### 什么是 MOTD 以及它是如何工作的？
2009 年，来自 Canonical 的 **Dustin Kirkland** 在 Ubuntu 中引入了 MOTD 的概念。它是一个灵活的框架，使管理员或发行包能够在 /etc/update-motd.d/* 位置添加可执行脚本，目的是生成在登录时显示有益的，有趣的消息。它最初是为 Landscape（Canonical 的商业服务）实现的，但是其它发行版维护者发现它很有用，并且在他们自己的发行版中也采用了这个特性。
2009 年，来自 Canonical 的 Dustin Kirkland 在 Ubuntu 中引入了 MOTD 的概念。它是一个灵活的框架，使管理员或发行包能够在 `/etc/update-motd.d/` 位置添加可执行脚本，目的是生成在登录时显示有益的、有趣的消息。它最初是为 Landscape（Canonical 的商业服务）实现的，但是其它发行版维护者发现它很有用，并且在他们自己的发行版中也采用了这个特性。
如果你在 Ubuntu 系统中查看 **/etc/update-motd.d/**，你会看到一组脚本。一个是打印通用的 “ Welcome” 横幅。下一个打印 3 个链接，显示在哪里可以找到操作系统的帮助。另一个计算并显示本地系统包可以更新的数量。另一个脚本告诉你是否需要重新启动等等。
如果你在 Ubuntu 系统中查看 `/etc/update-motd.d/`，你会看到一组脚本。一个是打印通用的 “欢迎” 横幅。下一个打印 3 个链接，显示在哪里可以找到操作系统的帮助。另一个计算并显示本地系统包可以更新的数量。另一个脚本告诉你是否需要重新启动等等。
从 Ubuntu 17.04 起，开发人员添加了 **/etc/update-motd.d/50-motd-news**，这是一个脚本用来在欢迎消息中包含一些附加信息。这些附加信息是：
1. 重要的关键信息，例如 ShellShock, Heartbleed 等
从 Ubuntu 17.04 起，开发人员添加了 `/etc/update-motd.d/50-motd-news`，这是一个脚本用来在欢迎消息中包含一些附加信息。这些附加信息是：
1. 重要的关键信息，例如 ShellShock、Heartbleed 等
2. 生命周期（EOL）消息，新功能可用性等
3. 在 Ubuntu 官方博客和其他有关 Ubuntu 的新闻中发布的一些有趣且有益的帖子
另一个特点是异步，启动后约 60 秒，systemd 计时器运行 “/etc/update-motd.d/50-motd-news –force” 脚本。它提供了 /etc/default/motd-news 脚本中定义的 3 个配置变量。默认值为：ENABLED=1, URLS=”<https://motd.ubuntu.com”>, WAIT=”5″。
另一个特点是异步，启动后约 60 秒，systemd 计时器运行 `/etc/update-motd.d/50-motd-news –force` 脚本。它提供了 `/etc/default/motd-news` 脚本中定义的 3 个配置变量。默认值为：`ENABLED=1, URLS="https://motd.ubuntu.com", WAIT="5"`。
以下是 `/etc/default/motd-news` 文件的内容：
以下是 /etc/default/motd-news 文件的内容：
```
$ cat /etc/default/motd-news
# Enable/disable the dynamic MOTD news service
@ -50,20 +48,20 @@ URLS="https://motd.ubuntu.com"
# Note that news messages are fetched in the background by
# a systemd timer, so this should never block boot or login
WAIT=5
```
好事情是 MOTD 是完全可定制的，所以你可以彻底禁用它（ENABLED=0），根据你的意愿更改或添加脚本，并以秒为单位更改等待时间。
好事情是 MOTD 是完全可定制的，所以你可以彻底禁用它（`ENABLED=0`）、根据你的意愿更改或添加脚本、以秒为单位更改等待时间等等。
如果启用了 MOTD，那么 systemd 计时器作业将循环遍历每个 URL，将它们缩减到每行 80 个字符，最多 10 行，并将它们连接（to 校正：也可能是链接？）到 /var/cache/motd-news 中的缓存文件。此 systemd 计时器作业将每隔 12 小时运行并更新 /var/cache/motd-news。用户登录后，/var/cache/motd-news 的内容会打印到屏幕上。这就是 MOTD 的工作原理。
如果启用了 MOTD，那么 systemd 计时器作业将循环遍历每个 URL，将它们的内容缩减到每行 80 个字符、最多 10 行，并将它们连接到 `/var/cache/motd-news` 中的缓存文件。此 systemd 计时器作业将每隔 12 小时运行并更新 `/var/cache/motd-news`。用户登录后，`/var/cache/motd-news` 的内容会打印到屏幕上。这就是 MOTD 的工作原理。
此外，`/etc/update-motd.d/50-motd-news` 文件中包含自定义的用户代理字符串，以报告有关计算机的信息。如果你查看 `/etc/update-motd.d/50-motd-news` 文件，你会看到：
此外，**/etc/update-motd.d/50-motd-news** 文件中包含自定义用户代理字符串，以报告有关计算机的信息。如果你查看 **/etc/update-motd.d/50-motd-news** 文件，你会看到
```
# Piece together the user agent
USER_AGENT="curl/$curl_ver $lsb $platform $cpu $uptime"
```
这意味着，MOTD 检索器将向 Canonical 报告你的**操作系统版本**，**硬件平台**，**CPU 类型**和**正常运行时间**。
这意味着，MOTD 检索器将向 Canonical 报告你的操作系统版本、硬件平台、CPU 类型和正常运行时间。
到这里，希望你对 MOTD 有了一个基本的了解。
@ -72,11 +70,13 @@ USER_AGENT="curl/$curl_ver $lsb $platform $cpu $uptime"
### 在 Ubuntu 服务器中禁用终端欢迎消息中的广告
要禁用这些广告，编辑文件：
```
$ sudo vi /etc/default/motd-news
```
找到以下行并将其值设置为 0（零）。
找到以下行并将其值设置为 `0`（零）。
```
[...]
ENABLED=0
@ -101,7 +101,7 @@ via: https://www.ostechnix.com/how-to-disable-ads-in-terminal-welcome-message-in
作者：[SK][a]
选题：[lujun9972](https://github.com/lujun9972)
译者：[MjSeven](https://github.com/MjSeven)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

54
translated/talk/20181008 3 areas to drive DevOps change.md → published/20181008 3 areas to drive DevOps change.md
View File

@ -1,12 +1,13 @@
推动 DevOps 变革的三个方面
======
推动大规模的组织变革是一个痛苦的过程。对于 DevOps 来说，尽管也有阵痛，但变革带来的价值则相当可观。
> 推动大规模的组织变革是一个痛苦的过程。对于 DevOps 来说，尽管也有阵痛，但变革带来的价值则相当可观。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/diversity-inclusion-transformation-change_20180927.png?itok=2E-g10hJ)
避免痛苦是一种强大的动力。一些研究表明，[植物也会通过遭受疼痛的过程][1]以采取措施来保护自己。我们人类有时也会刻意让自己受苦——在剧烈运动之后，身体可能会发生酸痛，但我们仍然坚持运动。那是因为当人认为整个过程利大于弊时，几乎可以忍受任何事情。
推动大规模的组织变革得过程确实是痛苦的。有人可能会因难以改变价值观和行为而感到痛苦，有人可能会因难以带领团队而感到痛苦，也有人可能会因难以开展工作而感到痛苦。但就 DevOps 而言，我可以说这些痛苦都是值得的。
推动大规模的组织变革的过程确实是痛苦的。有人可能会因难以改变价值观和行为而感到痛苦，有人可能会因难以带领团队而感到痛苦，也有人可能会因难以开展工作而感到痛苦。但就 DevOps 而言，我可以说这些痛苦都是值得的。
我也曾经关注过一个团队耗费大量时间优化技术流程的过程，在这个过程中，团队逐渐将流程进行自动化改造，并最终获得了成功。
@ -14,60 +15,64 @@
图片来源：Lee Eason. CC BY-SA 4.0
这张图表充分表明了变革的价值。一家公司在我主导实行了 DevOps 转型之后，60 多个团队每月提交了超过 900 个发布请求。这些工作量的原耗时高达每个月 350 天，而这么多的工作量对于任何公司来说都是不可忽视的。除此以外，他们每月的部署次数从 100 次增加到了 9000 次，高危 bug 减少了 24%，工程师们更轻松了，<ruby>净推荐值<rt>Net Promoter Score</rt></ruby>（NPS）也提高了，而 NPS 提高反过来也让团队的 DevOps 转型更加顺利。正如 [Puppet 发布的 DevOps 报告][4]所预测的，用在技术流程改进上的投资可以在业务成果上明显地体现出来。
这张图表充分表明了变革的价值。一家公司在我主导实行了 DevOps 转型之后，60 多个团队每月提交了超过 900 个发布请求。这些工作量的原耗时高达每个月 350 人/天，而这么多的工作量对于任何公司来说都是不可忽视的。除此以外，他们每月的部署次数从 100 次增加到了 9000 次，高危 bug 减少了 24%，工程师们更轻松了，<ruby>净推荐值<rt>Net Promoter Score</rt></ruby>（NPS）也提高了，而 NPS 提高反过来也让团队的 DevOps 转型更加顺利。正如 [Puppet 发布的 DevOps 报告][4]所预测的，用在技术流程改进上的投入可以在业务成果上明显地体现出来。
而 DevOps 主导者在推动变革是必须关注这三个方面：团队管理，团队文化和团队活力。
而 DevOps 主导者在推动变革时必须关注这三个方面：团队管理，团队文化和团队活力。
### 团队管理
最重要的是，改进对技术流程的投入可以转化为更好的业务成果。
组织架构越大，业务领导与一线员工之间的距离就会越大，当然发生误解的可能性也会越大。而且各种技术工具和实际应用都在以日新月异的速度变化，这就导致业务领导几乎不可能对 DevOps 或敏捷开发的转型方向有一个亲身的了解。
DevOps 主导者必须和管理层密切合作，在进行决策的时候给出相关的意见，以帮助他们做出正确的决策。
公司的管理层只是知道 DevOps 会对产品部署的方式进行改进，而并不了解其中的具体过程。当管理层发现你在和软件团队执行自动化部署失败时，就会想要了解这件事情的细节。如果管理层了解到进行部署的是软件团队而不是专门的发布管理团队，就可能会坚持使用传统的变更流程来保证业务的正常运作。你可能会失去团队的信任，团队也可能不愿意作出进一步的改变。
公司的管理层只是知道 DevOps 会对产品部署的方式进行改进，而并不了解其中的具体过程。假设你正在帮助一个软件开发团队实现自动化部署，当管理层得知某次部署失败时（这种情况是有的），就会想要了解这件事情的细节。如果管理层了解到进行部署的是软件团队而不是专门的发布管理团队，就可能会坚持使用传统的变更流程来保证业务的正常运作。你可能会失去团队的信任，团队也可能不愿意做出进一步的改变。
如果没有和管理层做好心理上的预期，一旦发生意外的生产事件，都会对你和管理层之间的信任造成难以消除的影响。所以，最好事先和管理层之间在各方面协调好，这会让你在后续的工作中避免很多麻烦。
如果没有和管理层做好心理上的预期，一旦发生意外的生产事件，重建管理层的信任并得到他们的支持比事先对他们进行教育需要更长的时间。所以，最好事先和管理层在各方面协调好，这会让你在后续的工作中避免很多麻烦。
对于和管理层之间的协调，这里有两条建议：
* 一是**重视所有规章制度**。如果管理层对合同、安全等各方面有任何疑问，你都可以向法务或安全负责人咨询，这样做可以避免犯下后果严重的错误。
* 二是**将管理层的重点关注的方面输出为量化指标**。举个例子，如果公司的目标是减少客户流失，而你调查得出计划外的停机是造成客户流失的主要原因，那么就可以让团队对故障的<ruby>平均检测时间<rt>Mean Time To Detection</rt></ruby>（MTTD）和<ruby>平均解决时间<rt>Mean Time To Resolution</rt></ruby>（MTTR）实行重点优化。你可以使用这些关键指标来量化团队的工作成果，而管理层对此也可以有一个直观的了解。
* 一是**重视所有规章制度**。如果管理层对合同、安全等各方面有任何疑问，你都可以向法务或安全负责人咨询，这样做可以避免犯下后果严重的错误。
* 二是**将管理层重点关注的方面输出为量化指标**。举个例子，如果公司的目标是减少客户流失，而你调查得出计划外的服务宕机是造成客户流失的主要原因，那么就可以让团队对故障的<ruby>平均排查时间<rt>Mean Time To Detection</rt></ruby>（MTTD）和<ruby>平均解决时间<rt>Mean Time To Resolution</rt></ruby>（MTTR）实行重点优化。你可以使用这些关键指标来量化团队的工作成果，而管理层对此也可以有一个直观的了解。
### 团队文化
DevOps 是一种专注于持续改进代码、构建、部署和操作流程的文化，而团队文化代表了团队的价值观和行为。从本质上说，团队文化是要塑造团队成员的行为方式，而这并不是一件容易的事。
我推荐一本叫做《[披着狼皮的 CIO][5]》的书。另外，研究心理学、阅读《[Drive][6]》、观看 Daniel Pink 的 [TED 演讲][7]、阅读《[千面英雄][7]》、了解每个人的心路历程，以上这些都是你推动公司技术变革所应该尝试去做的事情。
我推荐一本叫做《[披着狼皮的 CIO][5]》的书。另外，研究心理学、阅读《[Drive][6]》、观看 Daniel Pink 的 [TED 演讲][7]、阅读《[千面英雄][7]》、了解每个人的心路历程，以上这些都是你推动公司技术变革所应该尝试去做的事情。如果这些你都没兴趣，说明你不是那个推动公司变革的人。如果你想成为那个人，那就开始学习吧！
理性的人大多都按照自己的价值观工作，然而团队通常没有让每个人都能达成共识的明确价值观。因此，你需要明确团队目前的价值观，包括价值观的形成过程和价值观的目标导向。也不能将这些价值观强加到团队成员身上，只需要让团队成员在目前的硬件条件下力所能及地做到最好就可以了
从本质上说，改变一个人真不是件容易的事。
同时需要向团队成员阐明，公司正在发生组织上的变化，团队的价值观也随之改变，最好也厘清整个过程中将会作出什么变化。例如，公司以往或许是由于资金有限，一直将节约成本的原则放在首位，在研发新产品的时候，基础架构团队不得不通过共享数据库集群或服务器，从而导致了服务之间的紧密耦合。然而随着时间的推移，这种做法会产生难以维护的混乱，即使是一个小小的变化也可能造成无法预料的后果。这就导致交付团队难以执行变更控制流程，进而令变更停滞不前。
理性的人大多都按照自己的价值观工作，然而团队通常没有让每个人都能达成共识的明确价值观。因此，你需要明确团队目前的价值观，包括价值观的形成过程和价值观的目标导向。但不能将这些价值观强加到团队成员身上，只需要让团队成员在现有条件下力所能及地做到最好就可以了。
如果这种状况持续多年，最终的结果将会是毫无创新、技术老旧、问题繁多以及产品品质低下，公司的发展到达了瓶颈，原本的价值观已经不再适用。所以，工作效率的优先级必须高于节约成本。
同时需要向团队成员阐明，公司正在发生组织和团队目标的变化，团队的价值观也随之改变，最好也厘清整个过程中将会作出什么变化。例如，公司以往或许是由于资金有限，一直将节约成本的原则放在首位，在研发新产品的时候，基础架构团队不得不共享数据库集群或服务器，从而导致了服务之间的紧密耦合。然而随着时间的推移，这种做法会产生难以维护的混乱，即使是一个小小的变化也可能造成无法预料的后果。这就导致交付团队难以执行变更控制流程，进而令变更停滞不前。
你必须强调团队的价值观。每当团队按照价值观取得了一定的工作进展，都应该对团队作出激励。在团队部署出现失败时，鼓励他们承担风险、继续学习，同时指导团队如何改进他们的工作并表示支持。长此下来，团队成员就会对你产生信任，并逐渐切合团队的价值观。
如果这种状况持续几年，最终的结果将会是毫无创新、技术老旧、问题繁多以及产品品质低下，公司的发展到达了瓶颈，原本的价值观已经不再适用。所以，工作效率的优先级必须高于节约成本。如果一个选择能让团队运作更好，另一个选择只是短期来看成本便宜，那你应该选择前者。
你必须反复强调团队的价值观。每当团队取得了一定的工作进展（即使探索创新时出现一些小的失误），都应该对团队作出激励。在团队部署出现失败时，鼓励他们承担风险、吸取教训，同时指导团队如何改进他们的工作并表示支持。长此下来，团队成员就会对你产生信任，不再顾虑为切合团队的价值观而做出改变。
### 团队活力
你有没有在会议上听过类似这样的话？“在张三度假回来之前，我们无法对这件事情做出评估。他是唯一一个了解代码的人”，或者是“我们完成不了这项任务，它在网络上需要跨团队合作，而防火墙管理员刚好请病假了”，又或者是“张三最清楚这个系统最好，他说是怎么样，通常就是怎么样”。那么如果团队在处理工作时，谁才是主力？就是张三。而且也一直会是他。
你有没有在会议上听过类似这样的话？“在张三度假回来之前，我们无法对这件事情做出评估。他是唯一一个了解代码的人”，或者是“我们完成不了这项任务，它在网络上需要跨团队合作，而防火墙管理员刚好请病假了”，又或者是“张三最清楚这个系统，他说是怎么样，通常就是怎么样”。那么如果团队在处理工作时，谁才是主力？就是张三。而且也一直会是他。
我们一直都认为这就是软件开发的本质。但是如果我们不作出改变，这种循环就会一直保持下去。
我们一直都认为这就是软件开发的自带属性。但是如果我们不作出改变，这种循环就会一直持续下去。
熵的存在会让团队自发地变得混乱和缺乏活力，团队的成员和主导者的都有责任控制这个熵并保持团队的活力。DevOps、敏捷开发、上云、代码重构这些行为都会令熵增加速，这是因为转型让团队需要学习更多新技能和专业知识以开展新工作。
熵的存在会让团队自发地变得混乱和缺乏活力，团队的成员和主导者的都有责任控制这个熵并保持团队的活力。DevOps、敏捷开发、上云、代码重构这些行为都会令熵加速增长，这是因为转型让团队需要学习更多新技能和专业知识以开展新工作。
我们来看一个产品团队重构遗留代码的例子。像往常一样，他们在 AWS 上构建新的服务。而传统的系统则在数据中心部署，并由 IT 部门进行监控和备份。IT 部门会确保在基础架构的层面上满足应用的安全需求、进行灾难恢复测试、系统补丁、安装配置了入侵检测和防病毒代理，而且 IT 部门还保留了年度审计流程所需的变更控制记录。
我们来看一个产品团队重构历史代码的例子。像往常一样，他们在 AWS 上构建新的服务。而传统的系统则在数据中心部署，并由 IT 部门进行监控和备份。IT 部门会确保在基础架构的层面上满足应用的安全需求、进行灾难恢复测试、系统补丁、安装配置了入侵检测和防病毒代理，而且 IT 部门还保留了年度审计流程所需的变更控制记录。
产品团队经常会犯一个致命的错误，就是认为 IT 部门是需要突破的瓶颈。他们希望脱离已有的 IT 部门并使用公有云，但实际上是他们忽视了 IT 部门提供的关键服务。迁移到云上只是以不同的方式实现这些关键服务，因为 AWS 也是一个数据中心，团队即使使用 AWS 也需要完成 IT 运维任务。
产品团队经常会犯一个致命的错误，就是认为 IT 是消耗资源的部门，是需要突破的瓶颈。他们希望脱离已有的 IT 部门并使用公有云，但实际上是他们忽视了 IT 部门提供的关键服务。迁移到云上只是以不同的方式实现这些关键服务，因为 AWS 也是一个数据中心，团队即使使用 AWS 也需要完成 IT 运维任务。
实际上，产品团队在迁移到云时候也必须学习如何使用这些 IT 服务。因此，当产品团队开始重构遗留的代码并部署到云上时，也需要学习大量的技能才能正常运作。这些技能不会无师自通，必须自行学习或者聘用相关的人员，团队的主导者也必须积极进行管理。
实际上，产品团队在向云迁移的时候也必须学习如何使用这些 IT 服务。因此，当产品团队开始重构历史代码并部署到云上时，也需要学习大量的技能才能正常运作。这些技能不会无师自通，必须自行学习或者聘用相关的人员，团队的主导者也必须积极进行管理。
在带领团队时，我找不到任何适合我的工具，因此我建立了 [Tekita.io][9] 这个项目。Tekata 免费而且容易使用。但相比起来，把注意力集中在人员和流程上更为重要，你需要不断学习，持续关注团队的弱项，因为它们会影响团队的交付能力，而修补这些弱项往往需要学习大量的新知识，这就需要团队成员之间有一个很好的协作。因此 76％ 的年轻人都认为个人发展机会是公司文化[最重要的的一环][10]。
在带领团队时，我找不到任何适合我的工具，因此我建立了 [Tekita.io][9] 这个项目。Tekata 免费而且容易使用。但相比起来，把注意力集中在人员和流程上更为重要，你需要不断学习，持续关注团队的短板，因为它们会影响团队的交付能力，而弥补这些短板往往需要学习大量的新知识，这就需要团队成员之间有一个很好的协作。因此 76％ 的年轻人都认为个人发展机会是公司文化[最重要的的一环][10]。
### 效果就是最好的证明
DevOps 转型会改变团队的工作方式和文化，这需要得到管理层的支持和理解。同时，工作方式的改变意味着新技术的引入，所以在管理上也必须谨慎。但转型的最终结果是团队变得更高效、成员变得更积极、产品变得更优质，客户也变得更快乐。
DevOps 转型会改变团队的工作方式和文化，这需要得到管理层的支持和理解。同时，工作方式的改变意味着新技术的引入，所以在管理上也必须谨慎。但转型的最终结果是团队变得更高效、成员变得更积极、产品变得更优质，客户也变得更满意。
Lee Eason 将于 10 月 21-23 日在北卡罗来纳州 Raleigh 举行的 [All Things Open][12] 上讲述 [DevOps 转型的故事][11]。
免责声明：本文中的内容仅为 Lee Eason 的个人立场，不代表 Ipreo 或 IHS Markit。
@ -78,7 +83,7 @@ via: https://opensource.com/article/18/10/tales-devops-transformation
作者：[Lee Eason][a]
选题：[lujun9972][b]
译者：[HankChow](https://github.com/HankChow)
校对：[校对者ID](https://github.com/校对者ID)
校对：[pityonline](https://github.com/pityonline)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
@ -96,4 +101,3 @@ via: https://opensource.com/article/18/10/tales-devops-transformation
[10]: https://www.execu-search.com/~/media/Resources/pdf/2017_Hiring_Outlook_eBook
[11]: https://allthingsopen.org/talk/tales-from-a-devops-transformation/
[12]: https://allthingsopen.org/

45
translated/tech/20181015 Kali Linux- What You Must Know Before Using it - FOSS Post.md → published/20181015 Kali Linux- What You Must Know Before Using it - FOSS Post.md
View File

@ -1,71 +1,74 @@
Kali Linux：在开始使用之前你必须知道的 – FOSS Post
在你开始使用 Kali Linux 之前必须知道的事情
======
![](https://i1.wp.com/fosspost.org/wp-content/uploads/2018/10/kali-linux.png?fit=1237%2C527&ssl=1)
Kali Linux 在渗透测试和白帽子方面，是业界领先的 Linux 发行版。默认情况下，该发行版附带了大量黑客和渗透工具和软件，并且在全世界都得到了广泛认可。即使在那些甚至可能不知道 Linux 是什么的 Windows 用户中也是如此。
Kali Linux 在渗透测试和白帽子方面是业界领先的 Linux 发行版。默认情况下，该发行版附带了大量入侵和渗透的工具和软件，并且在全世界都得到了广泛认可。即使在那些甚至可能不知道 Linux 是什么的 Windows 用户中也是如此。
由于后者的原因，许多人都试图单独使用 Kali Linux，尽管他们甚至不了解 Linux 系统的基础知识。原因可能各不相同，有的为了玩乐，有的是为了取悦女友而伪装成黑客，有的仅仅是试图破解邻居的 WiFi 网络以免费上网。如果你打算使用 Kali Linux，所有的这些都是不好的事情。
由于后者的原因（LCTT 译注：Windows 用户），许多人都试图单独使用 Kali Linux，尽管他们甚至不了解 Linux 系统的基础知识。原因可能各不相同，有的为了玩乐，有的是为了取悦女友而伪装成黑客，有的仅仅是试图破解邻居的 WiFi 网络以免费上网。如果你打算使用 Kali Linux，记住，所有的这些都是不好的事情。
在计划使用 Kali Linux 之前，你应该了解一些提示。
### Kali Linux 不适合初学者
![](https://i0.wp.com/fosspost.org/wp-content/uploads/2018/10/Kali-Linux-000.png?resize=850%2C478&ssl=1)
Kali Linux 默认 GNOME 桌面
如果你是几个月前刚开始使用 Linux 的人，或者你认为自己的知识水平低于平均水平，那么 Kali Linux 就不适合你。如果你打算问“如何在 Kali 上安装 Stream？如何让我的打印机在 Kali 上工作？如何解决 Kali 上的 APT 源错误？”这些东西，那么 Kali Linux 并不适合你。
*Kali Linux 默认 GNOME 桌面*
Kali Linux 主要面向想要运行渗透测试的专家或想要学习成为白帽子和数字取证的人。但即使你来自后者，普通的 Kali Linux 用户在日常使用时也会遇到很多麻烦。他还被要求以非常谨慎的方式使用工具和软件，而不仅仅是“让我们安装并运行一切”。每一个工具必须小心使用，你安装的每一个软件都必须仔细检查。
如果你是几个月前刚开始使用 Linux 的人，或者你认为自己的知识水平低于平均水平，那么 Kali Linux 就不适合你。如果你打算问“如何在 Kali 上安装 Steam？如何让我的打印机在 Kali 上工作？如何解决 Kali 上的 APT 源错误？”这些东西，那么 Kali Linux 并不适合你。
**建议阅读：** [Linux 系统的组件是什么?][1]
Kali Linux 主要面向想要运行渗透测试套件的专家或想要学习成为白帽子和数字取证的人。但即使你属于后者，普通的 Kali Linux 用户在日常使用时也会遇到很多麻烦。他还被要求以非常谨慎的方式使用工具和软件，而不仅仅是“让我们安装并运行一切”。每一个工具必须小心使用，你安装的每一个软件都必须仔细检查。
普通 Linux 用户无法做正常的事情。（to 校正：这里什么意思呢？）一个更好的方法是花几周时间学习 Linux 及其守护进程，服务，软件，发行版及其工作方式，然后观看几十个关于白帽子攻击的视频和课程，然后再尝试使用 Kali 来应用你学习到的东西。
**建议阅读：** [Linux 系统的组件有什么?][1]
普通 Linux 用户都无法自如地使用它。一个更好的方法是花几周时间学习 Linux 及其守护进程、服务、软件、发行版及其工作方式，然后观看几十个关于白帽子攻击的视频和课程，然后再尝试使用 Kali 来应用你学习到的东西。
### 它会让你被黑客攻击
![](https://i0.wp.com/fosspost.org/wp-content/uploads/2018/10/Kali-Linux-001.png?resize=850%2C478&ssl=1)
Kali Linux 入侵和测试工具
*Kali Linux 入侵和测试工具*
在普通的 Linux 系统中，普通用户有一个账户，而 root 用户也有一个单独的账号。但在 Kali Linux 中并非如此。Kali Linux 默认使用 root 账户，不提供普通用户账户。这是因为 Kali 中几乎所有可用的安全工具都需要 root 权限，并且为了避免每分钟要求你输入 root 密码，所以这样设计。
当然，你可以简单地创建一个普通用户账户并开始使用它。但是，这种方式仍然不推荐，因为这不是 Kali Linux 系统设计的工作方式。然后，在使用程序，打开端口，调试软件时，你会遇到很多问题，你会发现为什么这个东西不起作用，最终却发现它是一个奇怪的权限错误。另外每次在系统上做任何事情时，你会被每次运行工具都要求输入密码而烦恼。
当然，你可以简单地创建一个普通用户账户并开始使用它。但是，这种方式仍然不推荐，因为这不是 Kali Linux 系统设计的工作方式。使用普通用户在使用程序，打开端口，调试软件时，你会遇到很多问题，你会发现为什么这个东西不起作用，最终却发现它是一个奇怪的权限错误。另外每次在系统上做任何事情时，你会被每次运行工具都要求输入密码而烦恼。
现在，由于你被迫以 root 用户身份使用它，因此你在系统上运行的所有软件也将以 root 权限运行。如果你不知道自己在做什么，那么这很糟糕，因为如果 Firefox 中存在漏洞，并且你访问了一个受感染的网站，那么黑客能够在你的 PC 上获得全部 root 权限并入侵你。如果你使用的是普通用户账户，则会收到限制。此外，你安装和使用的某些工具可能会在你不知情的情况下打开端口并泄露信息，因此如果你不是非常小心，人们可能会以你尝试入侵他们的方式入侵你。
现在，由于你被迫以 root 用户身份使用它，因此你在系统上运行的所有软件也将以 root 权限运行。如果你不知道自己在做什么，那么这很糟糕，因为如果 Firefox 中存在漏洞，并且你访问了一个受感染的网站，那么黑客能够在你的 PC 上获得全部 root 权限并入侵你。如果你使用的是普通用户账户，则会受到限制。此外，你安装和使用的某些工具可能会在你不知情的情况下打开端口并泄露信息，因此如果你不是非常小心，人们可能会以你尝试入侵他们的方式入侵你。
如果你在一些情况下访问于与 Kali Linux 相关的 Facebook 群组，你会发现这些群组中几乎有四分之一的帖子是人们在寻求帮助，因为有人入侵了他们。
如果你曾经访问过与 Kali Linux 相关的 Facebook 群组，你会发现这些群组中几乎有四分之一的帖子是人们在寻求帮助，因为有人入侵了他们。
### 它可以让你入狱
Kali Linux 仅提供软件。那么，如何使用它们完全是你自己的责任。
Kali Linux 只是提供了软件。那么，如何使用它们完全是你自己的责任。
在世界上大多数发达国家，使用针对公共 WiFi 网络或其他设备的渗透测试工具很容易让你入狱。现在不要以为你使用了 Kali 就无法被跟踪，许多系统都配置了复杂的日志记录设备来简单地跟踪试图监听或入侵其网络的人，你可能无意间成为其中的一个，那么它会毁掉你的生活。
永远不要对不属于你的设备或网络使用 Kali Linux 系统，也不要明确允许对它们进行入侵。如果你说你不知道你在做什么，在法庭上它不会被当作借口来接受。
### 修改了内核和软件
### 修改了的内核和软件
Kali [基于][2] Debian（测试分支，这意味着 Kali Linux 使用滚动发布模型），因此它使用了 Debian 的大部分软件体系结构，你会发现 Kali Linux 中的大部分软件跟 Debian 中的没什么区别。
Kali [基于][2] Debian（“测试”分支，这意味着 Kali Linux 使用滚动发布模型），因此它使用了 Debian 的大部分软件体系结构，你会发现 Kali Linux 中的大部分软件跟 Debian 中的没什么区别。
但是，Kali 修改了一些包来加强安全性并修复了一些可能的漏洞。例如，Kali 使用的 Linux 内核被打了补丁，允许在各种设备上进行无线注入。这些补丁通常在普通内核中不可用。此外，Kali Linux 不依赖于 Debian 服务器和镜像，而是通过自己的服务器构建软件包。以下是最新版本中的默认软件源：
```
deb http://http.kali.org/kali kali-rolling main contrib non-free
deb-src http://http.kali.org/kali kali-rolling main contrib non-free
deb http://http.kali.org/kali kali-rolling main contrib non-free
deb-src http://http.kali.org/kali kali-rolling main contrib non-free
```
这就是为什么，对于某些特定的软件，当你在 Kali Linux 和 Fedora 中使用相同的程序时，你会发现不同的行为。你可以从 [git.kali.org][3] 中查看 Kali Linux 软件的完整列表。你还可以在 Kali Linux（GNOME）上找到我们[自己生成的已安装包列表][4]。
更重要的是，Kali Linux 官方文档极力建议不要添加任何其他第三方软件仓库，因为 Kali Linux 是一个滚动发行版，并且依赖于 Debian 测试，由于依赖关系冲突和包钩子，所以你很可能只是添加一个新的仓库源就会破坏系统。
更重要的是，Kali Linux 官方文档极力建议不要添加任何其他第三方软件仓库，因为 Kali Linux 是一个滚动发行版，并且依赖于 Debian 测试分支，由于依赖关系冲突和包钩子，所以你很可能只是添加一个新的仓库源就会破坏系统。
### 不要安装 Kali Linux
![](https://i0.wp.com/fosspost.org/wp-content/uploads/2018/10/Kali-Linux-002.png?resize=750%2C504&ssl=1)
使用 Kali Linux 在 fosspost.org 上运行 wpscan
*使用 Kali Linux 在 fosspost.org 上运行 wpscan*
我在极少数情况下使用 Kali Linux 来测试我部署的软件和服务器。但是，我永远不敢安装它并将其用作主系统。
如果你要将其用作主系统，那么你必须保留自己的个人文件，密码，数据以及系统上的所有内容。你还需要安装大量日常使用的软件，以解放你的生活。但正如我们上面提到的，使用 Kali Linux 是非常危险的，应该非常小心地进行，如果你被入侵了，你将丢失所有数据，并且可能会暴露给更多的人。如果你在做一些不合法的事情，你的个人信息也可用于跟踪你。如果你不小心使用这些工具，那么你甚至可能会毁掉自己的数据。
如果你要将其用作主系统，那么你必须保留自己的个人文件、密码、数据以及系统上的所有内容。你还需要安装大量日常使用的软件，以解放你的生活。但正如我们上面提到的，使用 Kali Linux 是非常危险的，应该非常小心地进行，如果你被入侵了，你将丢失所有数据，并且可能会暴露给更多的人。如果你在做一些不合法的事情，你的个人信息也可用于跟踪你。如果你不小心使用这些工具，那么你甚至可能会毁掉自己的数据。
即使是专业的白帽子也不建议将其作为主系统安装，而是通过 USB 使用它来进行渗透测试工作，然后再回到普通的 Linux 发行版。
@ -83,7 +86,7 @@ via: https://fosspost.org/articles/must-know-before-using-kali-linux
作者：[M.Hanny Sabbagh][a]
选题：[lujun9972][b]
译者：[MjSeven](https://github.com/MjSeven)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

10
translated/tech/20181017 Browsing the web with Min, a minimalist open source web browser.md → published/20181017 Browsing the web with Min, a minimalist open source web browser.md
View File

@ -1,9 +1,11 @@
使用极简浏览器 Min 浏览网页
======
> 并非所有 web 浏览器都要做到无所不能，Min 就是一个极简主义风格的浏览器。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/openweb-osdc-lead.png?itok=yjU4KliG)
现在还有开发新的网络浏览器的需要吗？即使现在浏览器领域已经成为了寡头市场，但仍然不断涌现出各种前所未有的浏览器产品。
现在还有开发新的 Web 浏览器的需要吗？即使现在浏览器领域已经成为了寡头市场，但仍然不断涌现出各种前所未有的浏览器产品。
[Min][1] 就是其中一个。顾名思义，Min 是一个小的浏览器，也是一个极简主义的浏览器。但它麻雀虽小五脏俱全，而且还是一个开源的浏览器，它的 Apache 2.0 许可证引起了我的注意。
@ -29,7 +31,7 @@ Min 号称是更智能、更快速的浏览器。经过尝试以后，我觉得
Min 和其它浏览器一样，支持页面选项卡。它还有一个称为 Tasks 的功能，可以对打开的选项卡进行分组。
[DuckDuckGo][6]是我最喜欢的搜索引擎，而 Min 的默认搜索引擎恰好就是它，这正合我意。当然，如果你喜欢另一个搜索引擎，也可以在 Min 的偏好设置中配置你喜欢的搜索引擎作为默认搜索引擎。
[DuckDuckGo][6] 是我最喜欢的搜索引擎，而 Min 的默认搜索引擎恰好就是它，这正合我意。当然，如果你喜欢另一个搜索引擎，也可以在 Min 的偏好设置中配置你喜欢的搜索引擎作为默认搜索引擎。
Min 没有使用类似 AdBlock 这样的插件来过滤你不想看到的内容，而是使用了一个名为 [EasyList][7] 的内置的广告拦截器，你可以使用它来屏蔽脚本和图片。另外 Min 还带有一个内置的防跟踪软件。
@ -54,7 +56,7 @@ Min 确实也有自己的缺点，例如它无法将网站添加为书签。替
### 总结
Min 算是一个中规中矩的浏览器，它可以凭借轻量、快速的优点吸引很多极简主义的用户。但是对于追求多功能的用户来说，Min 就显得相当捉襟见肘了。
.
所以，如果你想摆脱当今多功能浏览器的束缚，我觉得可以试用一下 Min。
@ -65,7 +67,7 @@ via: https://opensource.com/article/18/10/min-web-browser
作者：[Scott Nesbitt][a]
选题：[lujun9972][b]
译者：[HankChow](https://github.com/HankChow)
校对：[校对者ID](https://github.com/校对者ID)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

260
sources/tech/20171002 Three Alternatives for Enabling Two Factor Authentication For SSH On Ubuntu 16.04 And Debian Jessie.md
View File

@ -1,260 +0,0 @@
Translating by cielllll
Three Alternatives for Enabling Two Factor Authentication For SSH On Ubuntu 16.04 And Debian Jessie
======
Security is now more important than ever and securing your SSH server is one of the most important things that you can do as a systems administrator. Traditionally this has meant disabling password authentication and instead using SSH keys. Whilst this is absolutely the first thing you should do that doesn't mean that SSH can't be made even more secure.
Two-factor authentication simply means that two means of identification are required to log in. These could be a password and an SSH key, or a key and a 3rd party service like Google. It means that the compromise of a single authentication method does not compromise the server.
The following guides are three ways to enable two-factor authentication for SSH.
Whenever you are modifying the configuration of SSH always ensure that you have a second terminal open to the server. The second terminal means that you will be able to fix any mistakes you make with the SSH configuration. Open terminals will stay open even through SSH restarts.
### SSH Key and Password
SSH supports the ability to require more than a single authentication method for logins.
The authentication methods are set with the `AuthenticationMethods` option in the SSH server's configuration file at `/etc/ssh/sshd_config`.
When the following line is added into `/etc/ssh/sshd_config` SSH requires an SSH key to be submitted and then a password is prompted for:
```
AuthenticationMethods "publickey,password"
```
If you want to set these methods on a per use basis then use the following additional configuration:
```
Match User jsmith
AuthenticationMethods "publickey,password"
```
When you have edited and saved the new `sshd_config` file you should check that you did not make any errors by running this command:
```
sshd -t
```
Any syntax or other errors that would stop SSH from starting will be flagged here. When `ssh -t` runs without error use `systemctl` to restart SSH"
```
systemctl restart sshd
```
Now you can log in with a new terminal to check that you are prompted for a password and your SSH key is required. If you use `ssh -v` e.g.:
```
ssh -v jsmith@example.com
```
you will be able to see every step of the login.
Note, if you do set `password` as a required authentication method then you will need to ensure that `PasswordAuthentication` option is set to `yes`.
### SSH With Google Authenticator
Google's two-factor authentication system that is used on Google's own products can be integrated into your SSH server. This makes this method very convenient if you already have use the Google Authenticator app.
Although the `libpam-google-authenticator` is written by Google it is [open source][1]. Also, the Google Authenticator app is written by Google but does not require a Google account to work. Thanks to [Sitaram Chamarty][2] for the heads up on that.
If you don't already have the Google Authenticator app installed and configured on your phone please see the instructions [here][3].
First, we need to install the Google Authenticator package on the server. The following commands will update your system and install the needed packages:
```
apt-get update
apt-get upgrade
apt-get install libpam-google-authenticator
```
Now, we need to register the server with the Google Authenticator app on your phone. This is done by first running the program we just installed:
```
google-authenticator
```
You will be asked a few questions when you run this. You should answer in the way that suits your setup, however, the most secure options are to answer `y` to every question. If you need to change these later you can simply re-run `google-authenticator` and select different options.
When you run `google-authenticator` a QR code will be printed to the terminal and some codes that look like:
```
Your new secret key is: VMFY27TYDFRDNKFY
Your verification code is 259652
Your emergency scratch codes are:
96915246
70222983
31822707
25181286
28919992
```
You should record all of these codes to a secure location like a password manager. The scratch codes are single use codes that will always allow you access even if your phone is unavailable.
All you need to do to register your server with the Authenticator app is to open the app and hit the red plus symbol on the bottom right. Then select the **Scan a barcode** option and scan the QR code that was printed to the terminal. Your server and the app are now linked.
Back on the server, we now need to edit the PAM (Pluggable Authentication Module) for SSH so that it uses the authenticator package we just installed. PAM is the standalone system that takes care of most authentication on a Linux server.
The PAM file for SSH that needs modifying is located at `/etc/pam.d/sshd` and edited with the following command:
```
nano /etc/pam.d/sshd
```
Add the following line to the top of the file:
```
auth required pam_google_authenticator.so
```
In addition, we also need to comment out a line so that PAM will not prompt for a password. Change this line:
```
# Standard Un*x authentication.
@include common-auth
```
To this:
```
# Standard Un*x authentication.
# @include common-auth
```
Next, we need to edit the SSH server configuration file:
```
nano /etc/ssh/sshd_config
```
And change this line:
```
ChallengeResponseAuthentication no
```
To:
```
ChallengeResponseAuthentication yes
```
Next, add the following line to enable two authentication schemes; SSH keys and Google Authenticator (keyboard-interactive):
```
AuthenticationMethods "publickey,keyboard-interactive"
```
Before we reload the SSH server it is a good idea to check that we did not make any errors in the configuration. This is done with the following command:
```
sshd -t
```
If this does not flag any errors, reload SSH with the new configuration:
```
systemctl reload sshd.service
```
Everything should now be working. Now, when you log into to your server you will need to use your SSH keys and when you are prompted for the:
```
Verification code:
```
open the Authenticator app and enter the 6 digit code that is displaying for your server.
### Authy
[Authy][4] is a two-factor authentication service that, like Google, offers time-based codes. However, Authy does not require a phone as they provide desktop and tables clients. They also enable offline authentication and do not require a Google account.
You will need to install the Authy app from your app store, or the desktop client all of which are linked to from the Authy [download page][5].
After you have installed the app you will need an API key that will be used on the server. This process requires a few steps:
1. Sign up for an account [here][6].
2. Scroll down to the **Authy** section.
3. Enable 2FA on the account.
4. Return to the **Authy** section.
5. Create a new Application for your server.
6. Obtain the API key from the top of the `General Settings` page for the new Application. You need to click the eye symbol next to the `PRODUCTION API KEY` line to reveal the key. Shown here:
![][7]
Take a note of the API key somewhere secure.
Now, go back to your server and run the following commands as root:
```
curl -O 'https://raw.githubusercontent.com/authy/authy-ssh/master/authy-ssh'
bash authy-ssh install /usr/local/bin
```
Enter the API key when prompted. If you input it incorrectly you can always edit `/usr/local/bin/authy-ssh.conf` and add it again.
Authy is now installed. However, it will not start working until it is enabled for a user. The command to enable Authy has the form:
```
/usr/local/bin/authy-ssh enable <system-user> <your-email> <your-phone-country-code> <your-phone-number>
```
With some example details for **root** logins:
```
/usr/local/bin/authy-ssh enable root john@example.com 44 20822536476
```
If everything was successful you will see:
```
User was registered
```
You can test Authy now by running the command:
```
authy-ssh test
```
Finally, reload SSH to implement the new configuration:
```
systemctl reload sshd.service
```
Authy is now working and will be required for SSH logins.
Now, when you log in you will see the following prompt:
```
Authy Token (type 'sms' to request a SMS token):
```
You can either enter the code from the Authy app on your phone or desktop client. Or you can type `sms` and Authy will send you an SMS message with a login code.
Authy is uninstalled by running the following:
```
/usr/local/bin/authy-ssh uninstall
```
--------------------------------------------------------------------------------
via: https://bash-prompt.net/guides/ssh-2fa/
作者：[Elliot Cooper][a]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:https://bash-prompt.net
[1]:https://github.com/google/google-authenticator-libpam
[2]:https://plus.google.com/115609618223925128756
[3]:https://support.google.com/accounts/answer/1066447?hl=en
[4]:https://authy.com/
[5]:https://authy.com/download/
[6]:https://www.authy.com/signup
[7]:/images/guides/2FA/twilio-authy-api.png

177
sources/tech/20181017 How To Determine Which System Manager Is Running On Linux System.md
View File

@ -1,177 +0,0 @@
(translating by runningwater)
How To Determine Which System Manager Is Running On Linux System
======
We all are heard about this word many times but only few of us know what is this exactly. We will show you how to identify the system manager.
I will try my best to let you know about this. Most of us know about System V and systemd system manager. System V (Sysv) is an old and traditional init system and system manager for old systems.
Systemd is a new init system and system manager which was adapted by most of the major distribution.
There are three major init systems are available in Linux which are very famous and still in use. Most of the Linux distribution falls under in one of the below init system.
### What is init System Manager?
In Linux/Unix based operating systems, init (short for initialization) is the first process that started during the system boot up by the kernel.
It’s holding a process id (PID) of 1. It will be running in the background continuously until the system is shut down.
Init looks at the `/etc/inittab` file to decide the Linux run level then it starts all other processes & applications in the background as per the run level.
BIOS, MBR, GRUB and Kernel processes were kicked up before hitting init process as part of Linux booting process.
Below are the available run levels for Linux (There are seven runlevels exist, from zero to six).
* **`0:`** halt
* **`1:`** Single user mode
* **`2:`** Multiuser, without NFS
* **`3:`** Full multiuser mode
* **`4:`** Unused
* **`5:`** X11 (GUI – Graphical User Interface)
* **`:`** reboot
Below three init systems are widely used in Linux.
* **`System V (Sys V):`** System V (Sys V) is one of the first and traditional init system for Unix like operating system.
* **`Upstart:`** Upstart is an event-based replacement for the /sbin/init daemon.
* **`systemd:`** Systemd is a new init system and system manager which was implemented/adapted into all the major Linux distributions over the traditional SysV init systems.
### What is System V (Sys V)?
System V (Sys V) is one of the first and traditional init system for Unix like operating system. init is the first process that started during the system boot up by the kernel and it’s a parent process for everything.
Most of the Linux distributions started using traditional init system called System V (Sys V) first. Over the years, several replacement init systems were released to address design limitations in the standard versions such as launchd, the Service Management Facility, systemd and Upstart.
But systemd has been adopted by several major Linux distributions over the traditional SysV init systems.
### How to identify the System V (Sys V) system manager on Linux
Run the following commands to identify that your system is running with System V (Sys V) system manager.
### Method-1: Using ps command
ps – report a snapshot of the current processes. ps displays information about a selection of the active processes.
This output doesn’t give the exact results either System V (SysV) or upstart so, i would suggest you to go with other method to confirm this.
```
# ps -p1 | grep "init\|upstart\|systemd"
1 ? 00:00:00 init
```
### Method-2: Using rpm command
RPM stands for `Red Hat Package Manager` is a powerful, command line [Package Management][1] utility for Red Hat based system such as (RHEL, CentOS, Fedora, openSUSE & Mageia) distributions. The utility allow you to install, upgrade, remove, query & verify the software on your Linux system/server. RPM files comes with `.rpm` extension.
RPM package built with required libraries and dependency which will not conflicts other packages were installed on your system.
```
# rpm -qf /sbin/init
SysVinit-2.86-17.el5
```
### What is Upstart?
Upstart is an event-based replacement for the /sbin/init daemon which handles starting of tasks and services during boot, stopping them during shutdown and supervising them while the system is running.
It was originally developed for the Ubuntu distribution, but is intended to be suitable for deployment in all Linux distributions as a replacement for the venerable System-V init.
It was used in Ubuntu from 9.10 to Ubuntu 14.10 & RHEL 6 based systems after that they are replaced with systemd.
### How to identify the Upstart system manager on Linux
Run the following commands to identify that your system is running with Upstart system manager.
### Method-1: Using ps command
ps – report a snapshot of the current processes. ps displays information about a selection of the active processes.
This output doesn’t give the exact results either System V (SysV) or upstart so, i would suggest you to go with other method to confirm this.
```
# ps -p1 | grep "init\|upstart\|systemd"
1 ? 00:00:00 init
```
### Method-2: Using rpm command
RPM stands for `Red Hat Package Manager` is a powerful, command line Package Management utility for Red Hat based system such as (RHEL, CentOS, Fedora, openSUSE & Mageia) distributions. The [RPM Command][2] allow you to install, upgrade, remove, query & verify the software on your Linux system/server. RPM files comes with `.rpm` extension.
RPM package built with required libraries and dependency which will not conflicts other packages were installed on your system.
```
# rpm -qf /sbin/init
upstart-0.6.5-16.el6.x86_64
```
### Method-3: Using /sbin/init file
The `/sbin/init` program will load or switch the root file system from memory to the hard disk.
This is the main part of the boot process. The runlevel at the start of this process is “N” (none). The /sbin/init program initializes the system following the description in the /etc/inittab configuration file.
```
# /sbin/init --version
init (upstart 0.6.5)
Copyright (C) 2010 Canonical Ltd.
This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
```
### What is systemd?
Systemd is a new init system and system manager which was implemented/adapted into all the major Linux distributions over the traditional SysV init systems.
systemd is compatible with SysV and LSB init scripts. It can work as a drop-in replacement for sysvinit system. systemd is the first process get started by kernel and holding PID 1.
It’s a parant process for everything and Fedora 15 is the first distribution which was adapted systemd instead of upstart. [systemctl][3] is command line utility and primary tool to manage the systemd daemons/services such as (start, restart, stop, enable, disable, reload & status).
systemd uses .service files Instead of bash scripts (SysVinit uses). systemd sorts all daemons into their own Linux cgroups and you can see the system hierarchy by exploring `/cgroup/systemd` file.
### How to identify the systemd system manager on Linux
Run the following commands to identify that your system is running with systemd system manager.
### Method-1: Using ps command
ps – report a snapshot of the current processes. ps displays information about a selection of the active processes.
```
# ps -p1 | grep "init\|upstart\|systemd"
1 ? 00:18:09 systemd
```
### Method-2: Using rpm command
RPM stands for `Red Hat Package Manager` is a powerful, command line Package Management utility for Red Hat based system such as (RHEL, CentOS, Fedora, openSUSE & Mageia) distributions. The utility allow you to install, upgrade, remove, query & verify the software on your Linux system/server. RPM files comes with `.rpm` extension.
RPM package built with required libraries and dependency which will not conflicts other packages were installed on your system.
```
# rpm -qf /sbin/init
systemd-219-30.el7_3.9.x86_64
```
### Method-3: Using /sbin/init file
The `/sbin/init` program will load or switch the root file system from memory to the hard disk.
This is the main part of the boot process. The runlevel at the start of this process is “N” (none). The /sbin/init program initializes the system following the description in the /etc/inittab configuration file.
```
# file /sbin/init
/sbin/init: symbolic link to `../lib/systemd/systemd'
```
--------------------------------------------------------------------------------
via: https://www.2daygeek.com/how-to-determine-which-init-system-manager-is-running-on-linux-system/
作者：[Prakash Subramanian][a]
选题：[lujun9972][b]
译者：[runningwater](https://github.com/runningwater)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.2daygeek.com/author/prakash/
[b]: https://github.com/lujun9972
[1]: https://www.2daygeek.com/category/package-management/
[2]: https://www.2daygeek.com/rpm-command-examples/
[3]: https://www.2daygeek.com/how-to-check-all-running-services-in-linux/

2
sources/tech/20181026 Ultimate Plumber - Writing Linux Pipes With Instant Live Preview.md
View File

@ -1,3 +1,5 @@
HankChow translating
Ultimate Plumber – Writing Linux Pipes With Instant Live Preview
======

114
sources/tech/20181029 Machine learning with Python- Essential hacks and tricks.md
View File

@ -1,114 +0,0 @@
HankChow translating
Machine learning with Python: Essential hacks and tricks
======
Master machine learning, AI, and deep learning with Python.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/programming-code-keyboard-laptop.png?itok=pGfEfu2S)
It's never been easier to get started with machine learning. In addition to structured massive open online courses (MOOCs), there are a huge number of incredible, free resources available around the web. Here are a few that have helped me.
2. Learn to clearly differentiate between the buzzwords—for example, machine learning, artificial intelligence, deep learning, data science, computer vision, and robotics. Read or listen to talks by experts on each of them. Watch this [amazing video by Brandon Rohrer][1], an influential data scientist. Or this video about the [clear differences between various roles][2] associated with data science.
3. Clearly set a goal for what you want to learn. Then go and take [that Coursera course][3]. Or take the one [from the University of Washington][4], which is pretty good too.
5. If you are enthusiastic about taking online courses, check out this article for guidance on [choosing the right MOOC][5].
6. Most of all, develop a feel for it. Join some good social forums, but resist the temptation to latch onto sensationalized headlines and news. Do your own reading to understand what it is and what it is not, where it might go, and what possibilities it can open up. Then sit back and think about how you can apply machine learning or imbue data science principles into your daily work. Build a simple regression model to predict the cost of your next lunch or download your electricity usage data from your energy provider and do a simple time-series plot in Excel to discover some pattern of usage. And after you are thoroughly enamored with machine learning, you can watch this video.
<https://www.youtube.com/embed/IpGxLWOIZy4>
### Is Python a good language for machine learning/AI?
Familiarity and moderate expertise in at least one high-level programming language is useful for beginners in machine learning. Unless you are a Ph.D. researcher working on a purely theoretical proof of some complex algorithm, you are expected to mostly use the existing machine learning algorithms and apply them in solving novel problems. This requires you to put on a programming hat.
There's a lot of talk about the best language for data science. While the debate rages, grab a coffee and read this insightful FreeCodeCamp article to learn about [data science languages][6] . Or, check out this post on KDnuggets to dive directly into the [Python vs. R debate][7]
For now, it's widely believed that Python helps developers be more productive from development to deployment and maintenance. Python's syntax is simpler and at a higher level when compared to Java, C, and C++. It has a vibrant community, open source culture, hundreds of high-quality libraries focused on machine learning, and a huge support base from big names in the industry (e.g., Google, Dropbox, Airbnb, etc.).
### Fundamental Python libraries
Assuming you go with the widespread opinion that Python is the best language for machine learning, there are a few core Python packages and libraries you need to master.
#### NumPy
Short for [Numerical Python][8], NumPy is the fundamental package required for high-performance scientific computing and data analysis in the Python ecosystem. It's the foundation on which nearly all of the higher-level tools, such as [Pandas][9] and [scikit-learn][10], are built. [TensorFlow][11] uses NumPy arrays as the fundamental building blocks underpinning Tensor objects and graphflow for deep learning tasks. Many NumPy operations are implemented in C, making them super fast. For data science and modern machine learning tasks, this is an invaluable advantage.
![](https://opensource.com/sites/default/files/uploads/machine-learning-python_numpy-cheat-sheet.jpeg)
#### Pandas
Pandas is the most popular library in the scientific Python ecosystem for doing general-purpose data analysis. Pandas is built upon a NumPy array, thereby preserving fast execution speed and offering many data engineering features, including:
* Reading/writing many different data formats
* Selecting subsets of data
* Calculating across rows and down columns
* Finding and filling missing data
* Applying operations to independent groups within the data
* Reshaping data into different forms
* Combing multiple datasets together
* Advanced time-series functionality
* Visualization through Matplotlib and Seaborn
![](https://opensource.com/sites/default/files/uploads/pandas_cheat_sheet_github.png)
#### Matplotlib and Seaborn
Data visualization and storytelling with data are essential skills for every data scientist because it's crtitical to be able to communicate insights from analyses to any audience effectively. This is an equally critical part of your machine learning pipeline, as you often have to perform an exploratory analysis of a dataset before deciding to apply a particular machine learning algorithm.
[Matplotlib][12] is the most widely used 2D Python visualization library. It's equipped with a dazzling array of commands and interfaces for producing publication-quality graphics from your data. This amazingly detailed and rich article will help you [get started with Matplotlib][13].
![](https://opensource.com/sites/default/files/uploads/matplotlib_gallery_-1.png)
[Seaborn][14] is another great visualization library focused on statistical plotting. It provides an API (with flexible choices for plot style and color defaults) on top of Matplotlib, defines simple high-level functions for common statistical plot types, and integrates with functionality provided by Pandas. You can start with this great tutorial on [Seaborn for beginners][15].
![](https://opensource.com/sites/default/files/uploads/machine-learning-python_seaborn.png)
#### Scikit-learn
Scikit-learn is the most important general machine learning Python package to master. It features various [classification][16], [regression][17], and [clustering][18] algorithms, including [support vector machines][19], [random forests][20], [gradient boosting][21], [k-means][22], and [DBSCAN][23], and is designed to interoperate with the Python numerical and scientific libraries NumPy and [SciPy][24]. It provides a range of supervised and unsupervised learning algorithms via a consistent interface. The library has a level of robustness and support required for use in production systems. This means it has a deep focus on concerns such as ease of use, code quality, collaboration, documentation, and performance. Look at this [gentle introduction to machine learning vocabulary][25] used in the Scikit-learn universe or this article demonstrating [a simple machine learning pipeline][26] method using Scikit-learn.
This article was originally published on [Heartbeat][27] under [CC BY-SA 4.0][28].
--------------------------------------------------------------------------------
via: https://opensource.com/article/18/10/machine-learning-python-essential-hacks-and-tricks
作者：[Tirthajyoti Sarkar][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/tirthajyoti
[b]: https://github.com/lujun9972
[1]: https://www.youtube.com/watch?v=tKa0zDDDaQk
[2]: https://www.youtube.com/watch?v=Ura_ioOcpQI
[3]: https://www.coursera.org/learn/machine-learning
[4]: https://www.coursera.org/specializations/machine-learning
[5]: https://towardsdatascience.com/how-to-choose-effective-moocs-for-machine-learning-and-data-science-8681700ed83f
[6]: https://medium.freecodecamp.org/which-languages-should-you-learn-for-data-science-e806ba55a81f
[7]: https://www.kdnuggets.com/2017/09/python-vs-r-data-science-machine-learning.html
[8]: http://numpy.org/
[9]: https://pandas.pydata.org/
[10]: http://scikit-learn.org/
[11]: https://www.tensorflow.org/
[12]: https://matplotlib.org/
[13]: https://realpython.com/python-matplotlib-guide/
[14]: https://seaborn.pydata.org/
[15]: https://www.datacamp.com/community/tutorials/seaborn-python-tutorial
[16]: https://en.wikipedia.org/wiki/Statistical_classification
[17]: https://en.wikipedia.org/wiki/Regression_analysis
[18]: https://en.wikipedia.org/wiki/Cluster_analysis
[19]: https://en.wikipedia.org/wiki/Support_vector_machine
[20]: https://en.wikipedia.org/wiki/Random_forests
[21]: https://en.wikipedia.org/wiki/Gradient_boosting
[22]: https://en.wikipedia.org/wiki/K-means_clustering
[23]: https://en.wikipedia.org/wiki/DBSCAN
[24]: https://en.wikipedia.org/wiki/SciPy
[25]: http://scikit-learn.org/stable/tutorial/basic/tutorial.html
[26]: https://towardsdatascience.com/machine-learning-with-python-easy-and-robust-method-to-fit-nonlinear-data-19e8a1ddbd49
[27]: https://heartbeat.fritz.ai/some-essential-hacks-and-tricks-for-machine-learning-with-python-5478bc6593f2
[28]: https://creativecommons.org/licenses/by-sa/4.0/

181
sources/tech/20181102 Create a containerized machine learning model.md Normal file
View File

@ -0,0 +1,181 @@
Create a containerized machine learning model
======
![](https://fedoramagazine.org/wp-content/uploads/2018/10/machinelearning-816x345.jpg)
After data scientists have created a machine learning model, it has to be deployed into production. To run it on different infrastructures, using containers and exposing the model via a REST API is a common way to deploy a machine learning model. This article demonstrates how to roll out a [TensorFlow][1] machine learning model, with a REST API delivered by [Connexion][2] in a container with [Podman][3].
### Preparation
First, install Podman with the following command:
```
sudo dnf -y install podman
```
Next, create a new folder for the container and switch to that directory.
```
mkdir deployment_container && cd deployment_container
```
### REST API for the TensorFlow model
The next step is to create the REST-API for the machine learning model. This [github repository][4] contains a pretrained model, and well as the setup already configured for getting the REST API working.
Clone this in the deployment_container directory with the command:
```
git clone https://github.com/svenboesiger/titanic_tf_ml_model.git
```
#### prediction.py & ml_model/
The [prediction.py][5] file allows for a Tensorflow prediction, while the weights for the 20x20x20 neural network are located in folder [ml_model/][6].
#### swagger.yaml
The file swagger.yaml defines the API for the Connexion library using the [Swagger specification][7]. This file contains all of the information necessary to configure your server to provide input parameter validation, output response data validation, URL endpoint definition.
As a bonus Connexion will provide you also with a simple but useful single page web application that demonstrates using the API with JavaScript and updating the DOM with it.
```
swagger: "2.0"
info:
description: This is the swagger file that goes with our server code
version: "1.0.0"
title: Tensorflow Podman Article
consumes:
- "application/json"
produces:
- "application/json"
basePath: "/"
paths:
/survival_probability:
post:
operationId: "prediction.post"
tags:
- "Prediction"
summary: "The prediction data structure provided by the server application"
description: "Retrieve the chance of surviving the titanic disaster"
parameters:
- in: body
name: passenger
required: true
schema:
$ref: '#/definitions/PredictionPost'
responses:
'201':
description: 'Survival probability of an individual Titanic passenger'
definitions:
PredictionPost:
type: object
```
#### server.py & requirements.txt
[server.py][8] defines an entry point to start the Connexion server.
```
import connexion
app = connexion.App(__name__, specification_dir='./')
app.add_api('swagger.yaml')
if __name__ == '__main__':
app.run(debug=True)
```
[requirements.txt][9] defines the python requirements we need to run the program.
```
connexion
tensorflow
pandas
```
### Containerize!
For Podman to be able to build an image, create a new file called “Dockerfile” in the **deployment_container** directory created in the preparation step above:
```
FROM fedora:28
# File Author / Maintainer
MAINTAINER Sven Boesiger <donotspam@ujelang.com>
# Update the sources
RUN dnf -y update --refresh
# Install additional dependencies
RUN dnf -y install libstdc++
RUN dnf -y autoremove
# Copy the application folder inside the container
ADD /titanic_tf_ml_model /titanic_tf_ml_model
# Get pip to download and install requirements:
RUN pip3 install -r /titanic_tf_ml_model/requirements.txt
# Expose ports
EXPOSE 5000
# Set the default directory where CMD will execute
WORKDIR /titanic_tf_ml_model
# Set the default command to execute
# when creating a new container
CMD python3 server.py
```
Next, build the container image with the command:
```
podman build -t ml_deployment .
```
### Run the container
With the Container image built and ready to go, you can run it locally with the command:
```
podman run -p 5000:5000 ml_deployment
```
Navigate to [http://0.0.0.0:5000/ui][10] in your web browser to access the Swagger/Connexion UI and to test-drive the model:
![][11]
Of course you can now also access the model with your application via the REST-API.
--------------------------------------------------------------------------------
via: https://fedoramagazine.org/create-containerized-machine-learning-model/
作者：[Sven Bösiger][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://fedoramagazine.org/author/r00nz/
[b]: https://github.com/lujun9972
[1]: https://www.tensorflow.org
[2]: https://connexion.readthedocs.io/en/latest/
[3]: https://fedoramagazine.org/running-containers-with-podman/
[4]: https://github.com/svenboesiger/titanic_tf_ml_model
[5]: https://github.com/svenboesiger/titanic_tf_ml_model/blob/master/prediction.py
[6]: https://github.com/svenboesiger/titanic_tf_ml_model/tree/master/ml_model/titanic
[7]: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md
[8]: https://github.com/svenboesiger/titanic_tf_ml_model/blob/master/server.py
[9]: https://github.com/svenboesiger/titanic_tf_ml_model/blob/master/requirements.txt
[10]: http://0.0.0.0:5000/
[11]: https://fedoramagazine.org/wp-content/uploads/2018/10/Screenshot-from-2018-10-27-14-46-56-682x1024.png

78
sources/tech/20181102 How To Create A Bootable Linux USB Drive From Windows OS 7,8 and 10.md Normal file
View File

@ -0,0 +1,78 @@
How To Create A Bootable Linux USB Drive From Windows OS 7,8 and 10?
======
If you would like to learn about Linux, the first thing you have to do is install the Linux OS on your system.
It can be achieved in two ways either go with virtualization applications like Virtualbox, VMWare, etc, or install Linux on your system.
If you are preferring to move from windows OS to Linux OS or planning to install Linux operating system on your spare machine then you have to create a bootable USB stick for that.
We had wrote many articles for creating [bootable USB drive on Linux][1] such as [BootISO][2], [Etcher][3] and [dd command][4] but we never get an opportunity to write an article about creating Linux bootable USB drive in windows. Somehow, we got a opportunity today to perform this task.
In this article we are going to show you, how to create a bootable Ubuntu USB flash drive from windows 10.
These step will work for other Linux as well but you have to choose the corresponding OS from the drop down instead of Ubuntu.
### Step-1: Download Ubuntu ISO
Visit [Ubuntu releases][5] page and download a latest version. I would like to advise you to download a latest LTS version and not for a normal release.
Make sure you have downloaded the proper ISO by performing checksum using MD5 or SHA256. The output value should be matched with the Ubuntu releases page value.
### Step-2: Download Universal USB Installer
There are many applications are available for this but my preferred application is [Universal USB Installer][6] which is very simple to perform this task. Just visit Universal USB Installer page and download the app.
### Step-3: How To Create a bootable Ubuntu ISO using Universal USB Installer
There is no complication on this application to perform this. First connect your USB drive then hit the downloaded Universal USB Installer. Once it’s launched you can see the interface similar to us.
![][8]
* **`Step-1:`** Select Ubuntu OS.
* **`Step-2:`** Navigate to Ubuntu ISO downloaded location.
* **`Step-3:`** By default it’s select a USB drive however verify this then check the option to format it.
![][9]
When you hit `Create` button, it will pop-up a window with warnings. No need to worry, just hit `Yes` to proceed further on this.
![][10]
USB drive partition is in progress.
![][11]
Wait for sometime to complete this. If you would like to move this process to background, yes, you can by hitting `Background` button.
![][12]
Yes, it’s completed.
![][13]
Now you are ready to perform [Ubuntu OS installation][14]. However, it’s offering a live mode also so, you can play around it if you want to try before performing the installation.
--------------------------------------------------------------------------------
via: https://www.2daygeek.com/create-a-bootable-live-usb-drive-from-windows-using-universal-usb-installer/
作者：[Prakash Subramanian][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.2daygeek.com/author/prakash/
[b]: https://github.com/lujun9972
[1]: https://www.2daygeek.com/category/bootable-usb/
[2]: https://www.2daygeek.com/bootiso-a-simple-bash-script-to-securely-create-a-bootable-usb-device-in-linux-from-iso-file/
[3]: https://www.2daygeek.com/etcher-easy-way-to-create-a-bootable-usb-drive-sd-card-from-an-iso-image-on-linux/
[4]: https://www.2daygeek.com/create-a-bootable-usb-drive-from-an-iso-image-using-dd-command-on-linux/
[5]: http://releases.ubuntu.com/
[6]: https://www.pendrivelinux.com/universal-usb-installer-easy-as-1-2-3/
[7]: data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
[8]: https://www.2daygeek.com/wp-content/uploads/2018/11/create-a-live-linux-os-usb-from-windows-using-universal-usb-installer-1.png
[9]: https://www.2daygeek.com/wp-content/uploads/2018/11/create-a-live-linux-os-usb-from-windows-using-universal-usb-installer-2.png
[10]: https://www.2daygeek.com/wp-content/uploads/2018/11/create-a-live-linux-os-usb-from-windows-using-universal-usb-installer-3.png
[11]: https://www.2daygeek.com/wp-content/uploads/2018/11/create-a-live-linux-os-usb-from-windows-using-universal-usb-installer-4.png
[12]: https://www.2daygeek.com/wp-content/uploads/2018/11/create-a-live-linux-os-usb-from-windows-using-universal-usb-installer-5.png
[13]: https://www.2daygeek.com/wp-content/uploads/2018/11/create-a-live-linux-os-usb-from-windows-using-universal-usb-installer-6.png
[14]: https://www.2daygeek.com/how-to-install-ubuntu-16-04/

104
sources/tech/20181105 CPod- An Open Source, Cross-platform Podcast App.md Normal file
View File

@ -0,0 +1,104 @@
CPod: An Open Source, Cross-platform Podcast App
======
Podcasts are a great way to be entertained and informed. In fact, I listen to about ten different podcasts covering technology, mysteries, history, and comedy. Of course, [Linux podcasts][1] are also on this list.
Today, we will take a look at a simple cross-platform application for handling your podcasts.
![][2]
Recommended podcasts and podcast search
### The Application
[CPod][3] is the creation of [Zack Guard (z————-)][4]. **It is an[Election][5] app** , which gives it the ability to run on the largest operating systems (Linux, Windows, Mac OS).
Trivia: CPod was originally named Cumulonimbus.
The majority of the application is taken up by two large panels to display content and options. A small bar along the left side of the screen gives you access to the different parts of the application. The different sections of CPod include Home, Queue, Subscriptions, Explore and Settings.
![cpod settings][6]Settings
### Features of CPod
Here is a list of features that CPod has to offer:
* Simple, clean design
* Available on the top computer platforms
* Available as a Snap
* Search iTunes’ podcast directory
* Download and play episodes without downloading
* View podcast information and episode
* Search for an individual episode of a podcast
* Dark mode
* Change playback speed
* Keyboard shortcuts
* Sync your podcast subscriptions with gpodder.net
* Import and export subscriptions
* Sort subscriptions based on length, date, download status, and play progress
* Auto-fetch new episodes on application startup
* Multiple language support
![search option in cpod application][7]Searching for ZFS episode
### Experiencing CPod on Linux
I ended up installing CPod on two systems: ArchLabs and Windows. There are two versions of CPod in the [Arch User Repository][8]. However, they are both out of date, one is version 1.14.0 and the other was 1.22.6. The most recent version of CPod is 1.27.0. Because of the version difference between ArchLabs and Windows, I had to different experiences. For this article, I will focus on 1.27.0, since that is the most current and has the most features.
Right out of the gate, I was able to find most of my favorite podcasts. I was able to add the ones that were not on the iTunes’ list by pasting in the URL for the RSS feed.
It was also very easy to find a particular episode of a podcast. for example, I was recently looking for an episode of [Late Night Linux][9] where they were talking about [ZFS][10]. I clicked on the podcast, typed “ZFS” in the search box and found it.
I quickly discovered that the easiest way to play a bunch of podcast episodes was to add them to the queue. Once they are in the queue, you can either stream them or download them. You can also reorder them by dragging and dropping. As each episode played, it displayed a visualization of the sound wave, along with the episode summary.
### Installating CPod
On [GitHub][11], you can download an AppImage or Deb file for Linux, a .exe file for Windows or a .dmg file for Mac OS.
You can also install CPod as a [Snap][12]. All you need to do is use the following command:
```
sudo snap install cpod
```
Like I said earlier, the [Arch User Repository][8] version of CPod is old. I already messaged one of the packagers. If you use Arch (or an Arch-based distro), I would recommend doing the same.
![cpod for Linux pidcasts][13]Playing one of my favorite podcasts
### Final Thoughts
Overall, I liked CPod. It was nice looking and simple to use. In fact, I like the original name (Cumulonimbus) better, but it is a bit of a mouthful.
I just had two problems with the application. First, I wish that the ratings were available for each podcast. Second, the menus that allow you to sort episodes based on length, date, download status, and play progress don’t work when the dork mode is turned on.
Have you ever used CPod? If not, what is your favorite podcast app? What are some of your favorite podcasts? Let us know in the comments below.
If you found this article interesting, please take a minute to share it on social media, Hacker News or [Red][14][d][14][it][14].
--------------------------------------------------------------------------------
via: https://itsfoss.com/cpod-podcast-app/
作者：[John Paul][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/john/
[b]: https://github.com/lujun9972
[1]: https://itsfoss.com/linux-podcasts/
[2]: https://4bds6hergc-flywheel.netdna-ssl.com/wp-content/uploads/2018/10/cpod1.1.jpg
[3]: https://github.com/z-------------/CPod
[4]: https://github.com/z-------------
[5]: https://electronjs.org/
[6]: https://4bds6hergc-flywheel.netdna-ssl.com/wp-content/uploads/2018/10/cpod2.1.png
[7]: https://4bds6hergc-flywheel.netdna-ssl.com/wp-content/uploads/2018/10/cpod4.1.jpg
[8]: https://aur.archlinux.org/packages/?O=0&K=cpod
[9]: https://latenightlinux.com/
[10]: https://itsfoss.com/what-is-zfs/
[11]: https://github.com/z-------------/CPod/releases
[12]: https://snapcraft.io/cumulonimbus
[13]: https://4bds6hergc-flywheel.netdna-ssl.com/wp-content/uploads/2018/10/cpod3.1.jpg
[14]: http://reddit.com/r/linuxusersgroup

229
sources/tech/20181105 Commandline quick tips- How to locate a file.md Normal file
View File

@ -0,0 +1,229 @@
Commandline quick tips: How to locate a file
======
![](https://fedoramagazine.org/wp-content/uploads/2018/10/commandlinequicktips-816x345.jpg)
We all have files on our computers — documents, photos, source code, you name it. So many of them. Definitely more than I can remember. And if not challenging, it might be time consuming to find the right one you’re looking for. In this post, we’ll have a look at how to make sense of your files on the command line, and especially how to quickly find the ones you’re looking for.
Good news is there are few quite useful utilities in the Linux commandline designed specifically to look for files on your computer. We’ll have a look at three of those: ls, tree, and find.
### ls
If you know where your files are, and you just need to list them or see information about them, ls is here for you.
Just running ls lists all visible files and directories in the current directory:
```
$ ls
Documents Music Pictures Videos notes.txt
```
Adding the **-l** option shows basic information about the files. And together with the **-h** option you’ll see file sizes in a human-readable format:
```
$ ls -lh
total 60K
drwxr-xr-x 2 adam adam 4.0K Nov 2 13:07 Documents
drwxr-xr-x 2 adam adam 4.0K Nov 2 13:07 Music
drwxr-xr-x 2 adam adam 4.0K Nov 2 13:13 Pictures
drwxr-xr-x 2 adam adam 4.0K Nov 2 13:07 Videos
-rw-r--r-- 1 adam adam 43K Nov 2 13:12 notes.txt
```
**Is** can also search a specific place:
```
$ ls Pictures/
trees.png wallpaper.png
```
Or a specific file — even with just a part of the name:
```
$ ls *.txt
notes.txt
```
Something missing? Looking for a hidden file? No problem, use the **-a** option:
```
$ ls -a
. .bash_logout .bashrc Documents Pictures notes.txt
.. .bash_profile .vimrc Music Videos
```
There are many other useful options for **ls** , and you can combine them together to achieve what you need. Learn about them by running:
```
$ man ls
```
### tree
If you want to see, well, a tree structure of your files, tree is a good choice. It’s probably not installed by default which you can do yourself using the package manager DNF:
```
$ sudo dnf install tree
```
Running tree without any options or parameters shows the whole tree starting at the current directory. Just a warning, this output might be huge, because it will include all files and directories:
```
$ tree
.
|-- Documents
| |-- notes.txt
| |-- secret
| | `-- christmas-presents.txt
| `-- work
| |-- project-abc
| | |-- README.md
| | |-- do-things.sh
| | `-- project-notes.txt
| `-- status-reports.txt
|-- Music
|-- Pictures
| |-- trees.png
| `-- wallpaper.png
|-- Videos
`-- notes.txt
```
If that’s too much, I can limit the number of levels it goes using the -L option followed by a number specifying the number of levels I want to see:
```
$ tree -L 2
.
|-- Documents
| |-- notes.txt
| |-- secret
| `-- work
|-- Music
|-- Pictures
| |-- trees.png
| `-- wallpaper.png
|-- Videos
`-- notes.txt
```
You can also display a tree of a specific path:
```
$ tree Documents/work/
Documents/work/
|-- project-abc
| |-- README.md
| |-- do-things.sh
| `-- project-notes.txt
`-- status-reports.txt
```
To browse and search a huge tree, you can use it together with less:
```
$ tree | less
```
Again, there are other options you can use with three, and you can combine them together for even more power. The manual page has them all:
```
$ man tree
```
### find
And what about files that live somewhere in the unknown? Let’s find them!
In case you don’t have find on your system, you can install it using DNF:
```
$ sudo dnf install findutils
```
Running find without any options or parameters recursively lists all files and directories in the current directory.
```
$ find
.
./Documents
./Documents/secret
./Documents/secret/christmas-presents.txt
./Documents/notes.txt
./Documents/work
./Documents/work/status-reports.txt
./Documents/work/project-abc
./Documents/work/project-abc/README.md
./Documents/work/project-abc/do-things.sh
./Documents/work/project-abc/project-notes.txt
./.bash_logout
./.bashrc
./Videos
./.bash_profile
./.vimrc
./Pictures
./Pictures/trees.png
./Pictures/wallpaper.png
./notes.txt
./Music
```
But the true power of find is that you can search by name:
```
$ find -name do-things.sh
./Documents/work/project-abc/do-things.sh
```
Or just a part of a name — like the file extension. Let’s find all .txt files:
```
$ find -name "*.txt"
./Documents/secret/christmas-presents.txt
./Documents/notes.txt
./Documents/work/status-reports.txt
./Documents/work/project-abc/project-notes.txt
./notes.txt
```
You can also look for files by size. That might be especially useful if you’re running out of space. Let’s list all files larger than 1 MB:
```
$ find -size +1M
./Pictures/trees.png
./Pictures/wallpaper.png
```
Searching a specific directory is also possible. Let’s say I want to find a file in my Documents directory, and I know it has the word “project” in its name:
```
$ find Documents -name "*project*"
Documents/work/project-abc
Documents/work/project-abc/project-notes.txt
```
Ah! That also showed the directory. One thing I can do is to limit the search query to files only:
```
$ find Documents -name "*project*" -type f
Documents/work/project-abc/project-notes.txt
```
And again, find have many more options you can use, the man page might definitely help you:
```
$ man find
```
--------------------------------------------------------------------------------
via: https://fedoramagazine.org/commandline-quick-tips-locate-file/
作者：[Adam Šamalík][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://fedoramagazine.org/author/asamalik/
[b]: https://github.com/lujun9972

169
sources/tech/20181105 Introducing pydbgen- A random dataframe-database table generator.md Normal file
View File

@ -0,0 +1,169 @@
Introducing pydbgen: A random dataframe/database table generator
======
Simple tool generates large database files with multiple tables to practice SQL commands for data science.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/features_solutions_command_data.png?itok=4_VQN3RK)
When you start learning data science, often your biggest worry is not the algorithms or techniques but getting access to raw data. While there are many high-quality, real-life datasets available on the web for trying out cool machine learning techniques, I've found that the same is not true when it comes to learning SQL.
For data science, having a basic familiarity with SQL is almost as important as knowing how to write code in Python or R. But it's far easier to find toy datasets on Kaggle than it is to access a large enough database with real data (such as name, age, credit card, social security number, address, birthday, etc.) specifically designed or curated for machine learning tasks.
Wouldn't it be great to have a simple tool or library to generate a large database with multiple tables filled with data of your own choice?
Aside from beginners in data science, even seasoned software testers may find it useful to have a simple tool where, with a few lines of code, they can generate arbitrarily large data sets with random (fake), yet meaningful entries.
For this reason, I am glad to introduce a lightweight Python library called **[pydbgen][1]**. In this article, I'll briefly share some information about the package, and you can learn much more [by reading the docs][2].
### What is pydbgen?
Pydbgen is a lightweight, pure-Python library to generate random useful entries (e.g., name, address, credit card number, date, time, company name, job title, license plate number, etc.) and save them in a Pandas dataframe object, as an SQLite table in a database file, or in a Microsoft Excel file.
### How to install pydbgen
The current version (1.0.5) is hosted on PyPI (the Python Package Index repository). You need to have [Faker][3] installed to make this work. To install Pydbgen, enter:
```
pip install pydbgen
```
It has been tested on Python 3.6 and won't work on Python 2 installations.
### How to use it
To start using Pydbgen, initiate a **pydb** object.
```
import pydbgen
from pydbgen import pydbgen
myDB=pydbgen.pydb()
```
Then you can access the various internal functions exposed by the **pydb** object. For example, to print random US cities, enter:
```
myDB.city_real()
>> 'Otterville'
for _ in range(10):
    print(myDB.license_plate())
>> 8NVX937
   6YZH485
   XBY-564
   SCG-2185
   XMR-158
   6OZZ231
   CJN-850
   SBL-4272
   TPY-658
   SZL-0934
```
By the way, if you enter **city** instead of **city_real** , it will return fictitious city names.
```
print(myDB.gen_data_series(num=8,data_type='city'))
>>
New Michelle
Robinborough
Leebury
Kaylatown
Hamiltonfort
Lake Christopher
Hannahstad
West Adamborough
```
### Generate a Pandas dataframe with random entries
You can choose how many and what data types will be generated. Note that everything returns as string/texts.
```
testdf=myDB.gen_dataframe(5,['name','city','phone','date'])
testdf
```
The resulting dataframe looks like the following image.
![](https://opensource.com/sites/default/files/uploads/pydbgen_pandas-dataframe.png)
### Generate a database table
You can choose how many and what data types will be generated. Everything is returned in the text/VARCHAR data type for the database. You can specify the database filename and the table name.
```
myDB.gen_table(db_file='Testdb.DB',table_name='People',
fields=['name','city','street_address','email'])
```
This generates a .db file which can be used with MySQL or the SQLite database server. The following image shows a database table opened in DB Browser for SQLite.
![](https://opensource.com/sites/default/files/uploads/pydbgen_db-browser-for-sqlite.png)
### Generate an Excel file
Similar to the examples above, the following code will generate an Excel file with random data. Note that **phone_simple** is set to **False** so it can generate complex, long-form phone numbers. This can come in handy when you want to experiment with more involved data extraction codes.
```
myDB.gen_excel(num=20,fields=['name','phone','time','country'],
phone_simple=False,filename='TestExcel.xlsx')
```
The resulting file looks like this image:
![](https://opensource.com/sites/default/files/uploads/pydbgen_excel.png)
### Generate random email IDs for scrap use
A built-in method in pydbgen is **realistic_email** , which generates random email IDs from a seed name. This is helpful when you don't want to use your real email address on the web—but something close.
```
for _ in range(10):
    print(myDB.realistic_email('Tirtha Sarkar'))
>>
Tirtha_Sarkar@gmail.com
Sarkar.Tirtha@outlook.com
Tirtha_S48@verizon.com
Tirtha_Sarkar62@yahoo.com
Tirtha.S46@yandex.com
Tirtha.S@att.com
Sarkar.Tirtha60@gmail.com
TirthaSarkar@zoho.com
Sarkar.Tirtha@protonmail.com
Tirtha.S@comcast.net
```
### Future improvements and user contributions
There may be many bugs in the current version—if you notice any and your program crashes during execution (except for a crash due to your incorrect entry), please let me know. Also, if you have a cool idea to contribute to the source code, the [GitHub repo][1] is open. Some questions readily come to mind:
* Can we integrate some machine learning/statistical modeling with this random data generator?
* Should a visualization function be added to the generator?
The possibilities are endless and exciting!
If you have any questions or ideas to share, please contact me at [tirthajyoti[AT]gmail.com][4]. If you are, like me, passionate about machine learning and data science, please [add me on LinkedIn][5] or [follow me on Twitter][6]. Also, check my [GitHub repo][7] for other fun code snippets in Python, R, or MATLAB and some machine learning resources.
Originally published on [Towards Data Science][8]. Licensed under [CC BY-SA 4.0][9].
--------------------------------------------------------------------------------
via: https://opensource.com/article/18/11/pydbgen-random-database-table-generator
作者：[Tirthajyoti Sarkar][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/tirthajyoti
[b]: https://github.com/lujun9972
[1]: https://github.com/tirthajyoti/pydbgen
[2]: http://pydbgen.readthedocs.io/en/latest/
[3]: https://faker.readthedocs.io/en/latest/index.html
[4]: mailto:tirthajyoti@gmail.com
[5]: https://www.linkedin.com/in/tirthajyoti-sarkar-2127aa7/
[6]: https://twitter.com/tirthajyotiS
[7]: https://github.com/tirthajyoti?tab=repositories
[8]: https://towardsdatascience.com/introducing-pydbgen-a-random-dataframe-database-table-generator-b5c7bdc84be5
[9]: https://creativecommons.org/licenses/by-sa/4.0/

104
sources/tech/20181105 Revisiting the Unix philosophy in 2018.md Normal file
View File

@ -0,0 +1,104 @@
Revisiting the Unix philosophy in 2018
======
The old strategy of building small, focused applications is new again in the modern microservices environment.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/brain_data.png?itok=RH6NA32X)
In 1984, Rob Pike and Brian W. Kernighan published an article called "[Program Design in the Unix Environment][1]" in the AT&T Bell Laboratories Technical Journal, in which they argued the Unix philosophy, using the example of BSD's **cat -v** implementation. In a nutshell that philosophy is: Build small, focused programs—in whatever language—that do only one thing but do this thing well, communicate via **stdin** / **stdout** , and are connected through pipes.
Sound familiar?
Yeah, I thought so. That's pretty much the [definition of microservices][2] offered by James Lewis and Martin Fowler:
> In short, the microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API.
While one *nix program or one microservice may be very limited or not even very interesting on its own, it's the combination of such independently working units that reveals their true benefit and, therefore, their power.
### *nix vs. microservices
The following table compares programs (such as **cat** or **lsof** ) in a *nix environment against programs in a microservices environment.
| | *nix | Microservices |
| ----------------------------------- | -------------------------- | ----------------------------------- |
| Unit of execution | program using stdin/stdout | service with HTTP or gRPC API |
| Data flow | Pipes | ? |
| Configuration & parameterization | Command-line arguments, | |
| environment variables, config files | JSON/YAML docs | |
| Discovery | Package manager, man, make | DNS, environment variables, OpenAPI |
Let's explore each line in slightly greater detail.
#### Unit of execution
**stdin** and writes output to **stdout**. A microservices setup deals with a service that exposes one or more communication interfaces, such as HTTP or gRPC APIs. In both cases, you'll find stateless examples (essentially a purely functional behavior) and stateful examples, where, in addition to the input, some internal (persisted) state decides what happens.
#### Data flow
The unit of execution in *nix (such as Linux) is an executable file (binary or interpreted script) that, ideally, reads input fromand writes output to. A microservices setup deals with a service that exposes one or more communication interfaces, such as HTTP or gRPC APIs. In both cases, you'll find stateless examples (essentially a purely functional behavior) and stateful examples, where, in addition to the input, some internal (persisted) state decides what happens.
Traditionally, *nix programs could communicate via pipes. In other words, thanks to [Doug McIlroy][3], you don't need to create temporary files to pass around and each can process virtually endless streams of data between processes. To my knowledge, there is nothing comparable to a pipe standardized in microservices, besides my little [Apache Kafka-based experiment from 2017][4].
#### Configuration and parameterization
How do you configure a program or service—either on a permanent or a by-call basis? Well, with *nix programs you essentially have three options: command-line arguments, environment variables, or full-blown config files. In microservices, you typically deal with YAML (or even worse, JSON) documents, defining the layout and configuration of a single microservice as well as dependencies and communication, storage, and runtime settings. Examples include [Kubernetes resource definitions][5], [Nomad job specifications][6], or [Docker Compose][7] files. These may or may not be parameterized; that is, either you have some templating language, such as [Helm][8] in Kubernetes, or you find yourself doing an awful lot of **sed -i** commands.
#### Discovery
How do you know what programs or services are available and how they are supposed to be used? Well, in *nix, you typically have a package manager as well as good old man; between them, they should be able to answer all the questions you might have. In a microservices setup, there's a bit more automation in finding a service. In addition to bespoke approaches like [Airbnb's SmartStack][9] or [Netflix's Eureka][10], there usually are environment variable-based or DNS-based [approaches][11] that allow you to discover services dynamically. Equally important, [OpenAPI][12] provides a de-facto standard for HTTP API documentation and design, and [gRPC][13] does the same for more tightly coupled high-performance cases. Last but not least, take developer experience (DX) into account, starting with writing good [Makefiles][14] and ending with writing your docs with (or in?) [**style**][15].
### Pros and cons
Both *nix and microservices offer a number of challenges and opportunities
#### Composability
It's hard to design something that has a clear, sharp focus and can also play well with others. It's even harder to get it right across different versions and to introduce respective error case handling capabilities. In microservices, this could mean retry logic and timeouts—maybe it's a better option to outsource these features into a service mesh? It's hard, but if you get it right, its reusability can be enormous.
#### Observability
In a monolith (in 2018) or a big program that tries to do it all (in 1984), it's rather straightforward to find the culprit when things go south. But, in a
```
yes | tr \\n x | head -c 450m | grep n
```
or a request path in a microservices setup that involves, say, 20 services, how do you even start to figure out which one is behaving badly? Luckily we have standards, notably [OpenCensus][16] and [OpenTracing][17]. Observability still might be the biggest single blocker if you are looking to move to microservices.
#### Global state
While it may not be such a big issue for *nix programs, in microservices, global state remains something of a discussion. Namely, how to make sure the local (persistent) state is managed effectively and how to make the global state consistent with as little effort as possible.
### Wrapping up
In the end, the question remains: Are you using the right tool for a given task? That is, in the same way a specialized *nix program implementing a range of functions might be the better choice for certain use cases or phases, it might be that a monolith [is the best option][18] for your organization or workload. Regardless, I hope this article helps you see the many, strong parallels between the Unix philosophy and microservices—maybe we can learn something from the former to benefit the latter.
--------------------------------------------------------------------------------
via: https://opensource.com/article/18/11/revisiting-unix-philosophy-2018
作者：[Michael Hausenblas][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/mhausenblas
[b]: https://github.com/lujun9972
[1]: http://harmful.cat-v.org/cat-v/
[2]: https://martinfowler.com/articles/microservices.html
[3]: https://en.wikipedia.org/wiki/Douglas_McIlroy
[4]: https://speakerdeck.com/mhausenblas/distributed-named-pipes-and-other-inter-services-communication
[5]: http://kubernetesbyexample.com/
[6]: https://www.nomadproject.io/docs/job-specification/index.html
[7]: https://docs.docker.com/compose/overview/
[8]: https://helm.sh/
[9]: https://github.com/airbnb/smartstack-cookbook
[10]: https://github.com/Netflix/eureka
[11]: https://kubernetes.io/docs/concepts/services-networking/service/#discovering-services
[12]: https://www.openapis.org/
[13]: https://grpc.io/
[14]: https://suva.sh/posts/well-documented-makefiles/
[15]: https://www.linux.com/news/improve-your-writing-gnu-style-checkers
[16]: https://opencensus.io/
[17]: https://opentracing.io/
[18]: https://robertnorthard.com/devops-days-well-architected-monoliths-are-okay/

308
sources/tech/20181105 Some Good Alternatives To ‘du- Command.md Normal file
View File

@ -0,0 +1,308 @@
Some Good Alternatives To ‘du’ Command
======
![](https://www.ostechnix.com/wp-content/uploads/2018/11/du-command-720x340.jpg)
As you may already know, the **“du”** command is used to compute and summarize the file and directory space usage in Unix-like systems. If you are a heavy user of du command, you will find this guide interesting! Today, I came across five good **alternatives to du** command. There could be many, but these are the ones that I am aware of at the moment. If I came across anything in future, I will add it in this list. Also, if you know any other alternatives, please let me know in the comment section below. I will review and add them in the list as well.
### 1\. Ncdu
The **Ncdu** is the popular alternative to du command in the Linux community. The developer of Ncdu is not satisfied with the performance of the du command, so he ended up creating his own. Ncdu is simple, yet fast disk usage analyzer written using **C** programming language with an **ncurses** interface to find which directories or files are taking up more space either on a local or remote systems. We already have published a detailed guide about Ncdu. Check the following link if you are interested to know more about it.
### 2\. Tin Summer
The **Tin Summer** is used to find the build artifacts that are taking up disk space. It is also an yet another good alternative for du command. Thanks to multi-threading, Tin-summer is significantly faster than du command when calculating the size of the big directories. Unlike Du command, it reads file sizes, not disk usage. Tin SUmmer is free, open source tool written using **Rust** programming language.
The developer claims Tin Summer is good alternative to du command, because,
* It is faster on larger directories compared to du command,
* It displays the disk usage results in human-readable format by default,
* It uses **regex** to exclude files/directories,
* Provides sorted and colorized output,
* Extensible,
* And more.
**Installing Tin Summer**
To install Tin Summer, open your Terminal and run the following command:
```
$ curl -LSfs https://japaric.github.io/trust/install.sh | sh -s -- --git vmchale/tin-summer
```
Alternatively, you can install Tin Summer using **Cargo** package manager. Make sure you have installed **Rust** on your system as described in the following link.
After installing Rust, run the following command to install Tin Summer:
```
$ cargo install tin-summer
```
If either of the above mentioned methods doesn’t not work, download the latest binary from the [**releases page**][1] and compile and install it manually.
**Usage**
To find the file sizes in a current working directory, use this command:
```
$ sn f
749 MB ./.rustup/toolchains
749 MB ./.rustup
147 MB ./.cargo/bin
147 MB ./.cargo
900 MB .
```
See? It displays a nicer input in human-readable format by default. You need not to use any extra flags (like **-h** in du command) to get this result.
To find the file sizes in a specific directory, mention the actual path like below:
```
$ sn f <path-to-the-directory>
```
We can also sort the list in the output as well. To display the sorted list of the top 5 biggest directories, run:
```
$ sn sort /home/sk/ -n5
749 MB /home/sk/.rustup
749 MB /home/sk/.rustup/toolchains
147 MB /home/sk/.cargo
147 MB /home/sk/.cargo/bin
2.6 MB /home/sk/mcelog
900 MB /home/sk/
```
For your information, the last result in the above output is the total size of the biggest directories in the given directory i.e **/home/sk/**. So, don’t wonder why you get six results instead of 5.
To search current directory for directories with build artifacts:
```
$ sn ar
```
Tin Summer can also search for directories containing artifacts that occupy a certain size of the disk space. Say for example, to search for directories containing artifacts that occupy more than **100MB** of disk space, run:
```
$ sn ar -t100M
```
Like already mentioned, Tin Summer is faster on larger directories, but it is also slower on small ones. However, the developer assures he will find a way to fix this in the future releases!
To get help, run:
```
$ sn --help
```
For more details, check the project’s GitHub repository given at the end of this guide.
### 3\. Dust
**Dust** (du+rust=dust) is more intuitive version of du utility. It will give us an instant overview of which directories are occupying the disk space without having to use **head** or **sort** commands. Like Tin Summer, it also displays the size of each directory in human-readable format by default. It is free, open source and written using **Rust** programming language.
**Installing Dust**
Since the dust utility is written in Rust, It can be installed using “cargo” package manager like below.
```
$ cargo install du-dust
```
Alternatively, you can download the latest binary from the [**releases page**][2] and install it as shown below. As of writing this guide, the latest version was **0.3.1**.
```
$ wget https://github.com/bootandy/dust/releases/download/v0.3.1/dust-v0.3.1-x86_64-unknown-linux-gnu.tar.gz
```
Extract the download file:
```
$ tar -xvf dust-v0.3.1-x86_64-unknown-linux-gnu.tar.gz
```
Finally, copy the executable file to your $PATH, for example **/usr/local/bin**.
```
$ sudo mv dust /usr/local/bin/
```
**Usage**
To find the total file sizes in the current directory and its sub-directories, run:
```
$ dust
```
Sample output:
![](http://www.ostechnix.com/wp-content/uploads/2018/11/dust-1.png)
We can also get the full path of all directories using **-p** flag.
```
$ dust -p
```
![dust 2][4]
To get the total size of multiple directories, just mention them with space-separated:
```
$ dust <dir1> <dir2>
```
Here are some more examples.
Show the apparent size of the files:
```
$ dust -s
```
Show particular number of directories only:
```
$ dust -n 10
```
Show 3 levels of sub-directories in the current directory:
```
$ dust -d 3
```
For help, run:
```
$ dust -h
```
For more details, refer the project’s GitHub page given at the end.
### 4\. Diskus
**Diskus** It is a simple and fast alternative command line utility to `du -sh`command. The diskus utility computes the total file size of the current directory. It is a parallelized version of `du -sh` or rather `du -sh --bytes` command. The developer of diskus utility claims that it is about **nine times faster** compared to ‘du -sh’. Diskus is minimal, fast and open source program written in **Rust** programming language.
**Installing diskus**
The diskus utility is available in [**AUR**][5], so you can install it on Arch-based systems using any AUR helper programs, for example [**Yay**][6] , as shown below.
```
$ yay -S diskus
```
On Ubuntu and its derivatives, download the latest diskus utility from the [**releases page**][7] and install it as shown below.
```
$ wget "https://github.com/sharkdp/diskus/releases/download/v0.3.1/diskus_0.3.1_amd64.deb"
$ sudo dpkg -i diskus_0.3.1_amd64.deb
```
Alternatively, you can install diskus using **Cargo** package manager. Make sure you have installed **Rust 1.29** or higher on your system as described in the link given above in “Installing Tin Summer” section.
Once you have Rust on your system, run the following command to install diskus:
```
$ cargo install diskus
```
**Usage**
Usually, when I want to check the total disk space used by a particular directory, I use the **-sh** flags with **du** command as shown below.
```
$ du -sh dir
```
Here, **-s** flag indicates summary.
Using Diskus tool, I find the total size of current working directory with command:
```
$ diskus
```
![](https://www.ostechnix.com/wp-content/uploads/2018/11/diskus-in-action.png)
I tested diskus to compute the total size of different directories in my Arch Linux system. The speed of computing the total size of the directory is pretty impressive! I must admit that this utility is quite faster than ‘du -sh’. Please be mindful that it can find the size of the current directory only at the moment.
For getting help, run:
```
$ diskus -h
```
For more details about Diskus, refer the official GitHub page (link at the end).
**Suggested read:**
### 5\. Duu
**Duu** , short for **D** irectory **U** sage **U** tility, is another tool to find the disk usage of given directory. It is a cross-platform, so you can use it on Windows, Mac OS and Linux operating systems. It is written in **Python** programming language.
**Installing Duu**
Make sure you have installed Python3. Python3 is available in the default repositories of most Linux distributions, so the installation wouldn’t be a problem.
Once Python3 is installed, download the latest Duu version from the official [**releases page**][8].
```
$ wget https://github.com/jftuga/duu/releases/download/2.20/duu.py
```
**Usage**
To find the disk space occupied by the current working directory, simply run:
```
$ python3 duu.py
```
Sample output:
![](https://www.ostechnix.com/wp-content/uploads/2018/11/duu.png)
As you can see in the above output, Duu utility will display a nice summary of total number of files and directories and their total size in bytes, KB and MB. It will also display the total size of each item.
To display the total disk usage of a specific directory, just mention the full path like below:
```
$ python3 duu.py /home/sk/Downloads/
```
For more details, refer Duu github page included at the end.
And, that’s all for now. Hope this was useful. You know now five alternatives to du command. Personally, I prefer Ncdu over all of them given in this guide. Now is your turn. Give them a try and let us know your thoughts on these tools in the comment section below.
More good stuffs to come. Stay tuned!
Cheers!
--------------------------------------------------------------------------------
via: https://www.ostechnix.com/some-good-alternatives-to-du-command/
作者：[SK][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.ostechnix.com/author/sk/
[b]: https://github.com/lujun9972
[1]: https://github.com/vmchale/tin-summer/releases
[2]: https://github.com/bootandy/dust/releases
[3]: data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7
[4]: http://www.ostechnix.com/wp-content/uploads/2018/11/dust-2.png
[5]: https://aur.archlinux.org/packages/diskus-bin/
[6]: https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/
[7]: https://github.com/sharkdp/diskus/releases
[8]: https://github.com/jftuga/duu/releases

80
translated/tech/20170928 A 3-step process for making more transparent decisions.md
View File

@ -1,80 +0,0 @@
A 3-step process for making more transparent decisions
======
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/GOV_Transparency_A.png?itok=2r47nFJB)
要让你的领导工作更加透明，其中一个最有效的方法就是将一个现有的程序开放给你的团队进行反馈，然后根据反馈去改变程序。下面这些练习能让透明度更佳切实，并且它有助于开发“肌肉记忆”，此二者可以持续评估且调整你的工作。
我想说，你可以通过任何程序来完成这项工作—即使是那些“范围外的”的程序，像是晋升或者自行调整程序。但是如果第一次它对于机内测试设备来说太大了，那么你可能需要从一个不那么程序的方法开始，比如旅行批准程序或者你的寻找团队空缺候选人的系统。（举个例子，我使用了在我们的招聘和晋升程序）
开放程序并使其更佳透明可以建立你的信誉并增强团队成员对你的信任。它会迫使你以一种可能超乎你设想和舒适程度的方式 “走透明的路”。以这种方式工作确实会产生额外的工作，尤其是在过程的开始阶段——但是，最终这种方法对于让管理者（比如我）对团队成员很有效的负责，而且它会更加相容。
### 阶段一：选择一个程序
**第一步.** 想想你的团队使用的一个普通的或常规的程序，但是这个程序通常不需要仔细检查。下面有一些例子:
* 招聘：如何创建职位描述、如何挑选面试团队、如何筛选候选人以及如何做出最终的招聘决定。
* 规划：你的团队或组织如何确定目标年度或季度。
* 升职：你如何选择并考虑升职候选人,并决定谁升职。
* 经理绩效评估：谁有机会就经理绩效提供反馈，以及他们是如何反馈。
* 旅游：旅游预算如何分配,以及你如何决定是否批准旅行（或提名某人是否旅行）。
上面的某个例子可能会引起你的共鸣，或者你可能会发现一些你觉得更合适的东西。也许你已经收到了关于某个特定程序的问题，又或者你发现自己屡次解释某个特定决策的基本原理。选择一些你能够控制或影响的东西——一些你相信你的成员关心的东西。
**第二步.** 现在回答以下关于这个程序的问题：
* 该程序目前是否记录在一个所有成员都知道并可以访问的地方？如果没有，现在就开始创建文档(不必太详细;只需要解释这个程序的不同步骤以及它是如何工作的)。你可能会发现这个过程不够清晰或一致，无法进行文档记录。在这种情况下，用你认为理想情况下应该使用的方式去记录它。
* 完成程序的文档是否说明了在不同的点上是如何做出决定？例如，在旅行批准程序中，它是否解释了如何批准或拒绝请求。
* 程序的输入是什么？例如，在确定部门年度目标时，哪些数据用于关键绩效指标，查找或者采纳谁的反馈，谁有机会回顾或“停止活动”。
* 这个过程会做出什么假设？例如，在升职决策中，你是否认为所有的晋升候选人都会在适当的时间被他们的经理提出。
* 程序的输出是什么？例如，在评估经理的绩效时，评估的结果是否会与经理共享，任何审查的方面是否会与经理的直接报告(例如，改进的领域)更广泛地共享？
回答上述问题时，避免作出判断。如果这个程序不能清楚地解释一个决定是如何做出的，那也可以接受。这些问题只是评估现状的一个机会。
接下来,修改程序的文档,直到你对它充分说明了程序并预测潜在的问题感到满意。
### 阶段二:收集反馈
下一个阶段牵涉与你的成员分享这个程序并要求反馈。分享说起来容易做起来难。
**第一步.** 鼓励人们提供反馈。考虑一下实现此目的的各种机制：
* 把这个程序公布在人们可以在内部找到的地方，并注意他们可以在哪里发表评论或提供反馈。谷歌文档可以很好地评论特定的文本或直接建议文本中的更改。
* 通过电子邮件分享过程文档，邀请反馈。
* 提及程序文档，在团队会议或一对一的谈话时要求反馈。
* 给人们一个他们可以提供反馈的时间窗口，并在此窗口定期发送提醒。
如果你得不到太多的反馈，不要认为沉默就等于认可。你可以试着直接询问人们，他们为什么没有反馈。是因为他们太忙了吗？这个过程对他们来说不像你想的那么重要吗？你清楚地表达了你的要求吗？
**第二步.** 迭代。当你获得关于程序的反馈时，请让团队对流程进行修改和迭代。加入改进的想法和建议，并要求确认预期的反馈已经被应用。如果你不同意某个建议，那就接受讨论，问问自己为什么不同意，以及一种方法和另一种方法的优点是什么。
设置一个收集反馈和迭代的时间盒有助于向前推进。一旦反馈被收集和审查，你应当讨论和应用它，并且发布最终的程序供团队审查。
### 阶段三：实现
实现程序通常是计划中最困难的阶段。但如果你在修改过程中考虑了反馈意见，人们应该已经预料到了，并且可能会更支持你。从上面迭代过程中获得的文档是一个很好的工具，可以让你对实现负责。
**第一步.** 审查实施需求。许多可以从提高透明度中获益的程序只需要做一点不同的事情，但是你确实需要检查你是否需要其他支持（例如工具）。
**第二步.** 设置实现的时间表。与成员一起回顾时间表，这样他们就知道会发生什么。如果新程序需要对其他程序进行更改，请确保为人们提供足够的时间去适应新性能，并提供沟通和提醒。
**第三步.** 跟进。在使用程序3-6个月后，与你的成员联系，看看进展如何。新流程是否更加透明，更有效，更可预测？你有什么经验教训可以用来进一步改进这个程序吗？
### 关于作者
Sam Knuth；我有幸在 Red Hat 领导客户内容服务团队；我们提供给我们的客户所有产生的文档。我们的目标是为客户提供他们在企业中使用开源技术取得成功所需要的洞察力。在Twitter上与我联系
--------------------------------------------------------------------------------
via: https://opensource.com/open-organization/17/9/exercise-in-transparent-decisions
作者：[a][Sam Knuth]
译者：[MarineFish](https://github.com/MarineFish)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:https://opensource.com/users/samfw<!doctype html>

237
translated/tech/20171002 Three Alternatives for Enabling Two Factor Authentication For SSH On Ubuntu 16.04 And Debian Jessie.md Normal file
View File

@ -0,0 +1,237 @@
在 Ubuntu16.04 和 Debian Jessie 上启用双因素身份验证的三种备选方案
=====
如今，安全比以往更加重要，保护 SSH 服务器是作为系统管理员可以做的最为重要的事情之一。传统地，这意味着禁用密码身份验证而改用 SSH 密钥。无疑这是你首先应该做的，但这并不意味着 SSH 无法变得更加安全。
双因素身份验证就是指需要两种身份验证才能登录。可以是密码和 SSH 密钥，也可以是密钥和第三方服务，比如 Google。这意味着单个验证方法的泄露不会危及服务器。
以下指南是为 SSH 启用双因素验证的三种方式。
当你修改 SSH 配置时，总是要确保有一个对服务器开放的第二终端。第二终端意味着你可以修复你在 SSH 配置中犯的任何错误。开放终端将保持开放，即便 SSH 重启。
### SSH 密钥和密码
SSH 支持对登录要求不止一个身份验证方法。
在 `/etc/sh/sshd_config` 中的 SSH 服务器配置文件中的 `AuthenticationMethods` 选项中设置了身份验证方法。
当在 `/etc/ssh/sshd_config` 中添加下一行时，SSH需要提交一个 SSH 密钥，然后提示输入密码:
`AuthenticationMethods“publickey,password”`
 
如果你想要根据使用情况设置这些方法，那么请使用以下附加配置:
```
Match User jsmith
AuthenticationMethods“publickey,password”
```
当你已经编辑或保存了新的 `sshd_config` 文件，你应该通过运行以下程序来确保你没有犯任何错误：
`sshd -t`
任何阻止 SSH 启动的语法或其他错误都将在这里标记。当 `ssh-t` 运行时没有错误，使用 `systemctl` 重新启动 SSH
`systemctl restart sshd`
现在，你可以使用新终端登录，以核实你会被提示输入密码并需要 SSH 密钥。如果你用 `ssh-v` 例如：
`ssh -v jsmith@example.com`
你将可以看到登录的每一步。
注意，如果你确实将密码设置成必需的身份验证方法，你要确保将 ` PasswordAuthentication` 选项设置成 `yes`。
### 使用 Google Authenticator 的 SSH
Google 在 Google 自己的产品上使用的双因素身份验证系统可以集成到你的 SSH 服务器中。如果你已经使用了Google Authenticator，那么此方法将非常方便。
虽然 libpam-google-authenticator 是由 Google 编写的，但它是[开源][1]的。此外，Google Authenticator 是由Google 编写的，但不需要 Google 帐户才能工作。多亏了 [Sitaram Chamarty][2] 的贡献。
如果你还没有在手机上安装和配置 Google Authenticator，请参阅 [这里][3]的说明。
首先，我们需要在服务器上安装 Google Authenticatior 安装包。以下命令将更新你的系统并安装所需的软件包：
apt-get update
apt-get upgrade
apt-get install libpam-google-authenticator
现在，我们需要在你的手机上使用 Google Authenticatior APP 注册服务器。这是通过首先运行我们刚刚安装的程序完成的:
`google-authenticator`
 运行这个程序时，有几个问题会被问到。你应该以适合你的设置的方式回答，然而，最安全的选项是对每个问题回答`y`。如果以后需要更改这些选项，您可以简单地重新运行 `google-authenticator` 并选择不同的选项。
当你运行 `google-authenticator` 时，一个二维码会被打印到终端上，有些代码看起来像这样:
Your new secret key is:VMFY27TYDFRDNKFY
Your verification code is:259652
Your emergency scratch codes are:
96915246
70222983
31822707
25181286
28919992
 
你应该将所有这些代码记录到一个像密码管理器一样安全的位置。scratch codes 是单一的使用代码，即使你的手机不可用，它总是允许你访问。
要将服务器注册到 Authenticator APP 中，只需打开应用程序并点击右下角的红色加号即可。然后选择扫描条码选项，扫描打印到终端的二维码。你的服务器和应用程序现在连接。
回到服务器上，我们现在需要编辑用于 SSH 的 PAM (可插入身份验证模块)，以便它使用我们刚刚安装的身份验证器安装包。PAM 是独立系统，负责 Linux 服务器上的大多数身份验证。
需要修改的 SSH PAM 文件位于 ` /etc/ pamc。d/sshd` ，用以下命令编辑:
`nano/etc/pam.d/sshd`
 
在文件顶部添加以下行:
`auth required pam_google_authenticator.so`
 
此外，我们还需要注释掉一行，这样 PAM 就不会提示输入密码。改变这行:
#Standard Un*x authentication.
@include common-auth
 
为如下：
#Standard Un*x authentication.
# @include common-auth
 
接下来，我们需要编辑 SSH 服务器配置文件:
`nano/etc/ssh/sshd_config`
 
改变这一行:
`ChallengeResponseAuthentication no`
 
为:
`ChallengeResponseAuthentication yes`
 
接下来，添加以下代码行来启用两个身份验证方案; SSH 密钥和谷歌认证器(键盘交互):
`AuthenticationMethods“publickey keyboard-interactive”`
 
在重新加载 SSH 服务器之前，最好检查一下在配置中没有出现任何错误。执行以下命令:
`sshd - t`
 
如果这没有标记任何错误，用新的配置重载 SSH:
`systemctl reload sshd.service`
 
现在一切都应该开始工作了。现在，当你登录到你的服务器时，你将需要使用 SSH 密钥，并且当你被提示输入:
`Verification code:`
 
打开 Authenticator APP 并输入为您的服务器显示的6位代码。
### Authy
[Authy][4] 是一个双重身份验证服务，与 Google 一样，它提供基于时间的代码。然而，Authy 不需要手机，因为它提供桌面和表客户端。它们还支持离线身份验证，不需要 Google 帐户。
你需要从应用程序商店安装 Authy 应用程序，或从 Authy [下载页面][5]链接到的桌面客户端。
安装完应用程序后，需要在服务器上使用 API 密钥。这个过程需要几个步骤:
1.在[这里][6]注册一个账户。
2.向下滚动到 **Authy** 部分。
3.在帐户上启用 2FA。
4.回 **Authy** 部分。
5.为你的服务器创建一个新的应用程序。
6.从新应用程序的 `General Settings`页面顶部获取 API 密钥。你需要`PRODUCTION API KEY`旁边的眼睛符号来显示密钥。所示:
在某个安全的地方记下API密钥。
现在，回到服务器，以root身份运行以下命令:
curl - o ' https://raw.githubusercontent.com/authy/authy-ssh/master/authy-ssh '
bash authy-ssh install/usr/local/bin
 
当提示时输入API键。如果输入错误，你始终可以编辑`/usr/local/bin/authy-ssh`。再添加一次。
Authy 现已安装。但是，在为用户启用它之前，它不会开始工作。启用 Authy 的命令有以下形式:
/usr/local/bin/authy-ssh<system-user> <your-email> <your-phone-country-code> <your-phone-number>
 
root登录的一些示例细节:
/usr/local/bin/authy-ssh enable root john@example.com 44 20822536476
 
如果一切顺利，你会看到:
User was registered 
现在可以通过运行以下命令来测试 Authy:
authy-ssh test
 
最后，重载 SSH 实现新的配置:
Systemctl reload sshd.service
 
Authy 现在正在工作，需要 SSH 登录。
现在，当你登录时，你将看到以下提示:
`Authy Token(type'sms'to request a SMS token):`
 
你可以从手机或桌面客户端上的 Authy APP 输入代码。或者你可以输入 sms, Authy 会给你发送一条带有登录码的 sms 消息。
通过运行以下命令卸载 Authy:
/usr/local/bin/authy-ssh uninstall
--------------------------------------------------------------------------------
via: https://bash-prompt.net/guides/ssh-2fa/
作者：[Elliot Cooper][a]
译者：[cielllll](https://github.com/cielllll)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]:https://bash-prompt.net
[1]:https://github.com/google/google-authenticator-libpam
[2]:https://plus.google.com/115609618223925128756
[3]:https://support.google.com/accounts/answer/1066447?hl=en
[4]:https://authy.com/
[5]:https://authy.com/download/
[6]:https://www.authy.com/signup
[7]:/images/guides/2FA/twilio-authy-api.png

138
translated/tech/20180618 What-s all the C Plus Fuss- Bjarne Stroustrup warns of dangerous future plans for his C.md
View File

@ -1,148 +1,138 @@
# 关于 C ++ 的所有争论？Bjarne Stroustrup 警告他的 C++ 未来的计划很危险
# 对 C++ 的忧虑？Bjarne Stroustrup 警告，关于 C++ 的某些未来计划十分危险
![](https://regmedia.co.uk/2018/06/15/shutterstock_38621860.jpg?x=442&y=293&crop=1)
今年早些时候，我们**访谈**了 Bjarne Stroustrup，他是 C++ 语言的创始人，摩根士丹利技术部门的董事总经理，美国哥伦比亚大学计算机科学的客座教授，他写了[一封信][1]邀请那些关注编程语言演进的人去“想想瓦萨号！”
今年早些时候，我们对 Bjarne Stroustrup 进行了采访。他是 C++ 语言的创始人，摩根士丹利技术部门的董事总经理，美国哥伦比亚大学计算机科学的客座教授。他写了[一封信][1]，请那些关注编程语言进展的人去“想想瓦萨号！”
毫无疑问，对于丹麦人来说，这句话很容易理解，而那些对于 17 世纪的斯堪的纳维亚历史了解不多的人，还需要展开说一下。瓦萨号是一艘瑞典军舰，由国王 Gustavus Adolphus 委托建造。它是在 1628 年 8 月 10 日首航时，当时波罗的海国家中最强大的军舰，但是它在首航几分钟之后就沉没了。
这句话对于丹麦人来说，毫无疑问，很容易理解。而那些对于 17 世纪的斯堪的纳维亚历史了解不多的人，还需要详细说明一下。瓦萨号是一艘瑞典军舰，由国王 Gustavus Adolphus 定做。它是当时波罗的海国家中最强大的军舰，但在 1628 年 8 月 10 日首航没几分钟之后，就沉没了。
巨大的瓦萨号有一个难以解决的设计缺陷：头重脚轻，以至于它被[一阵狂风刮翻了][2]。通过这段翻船历史的回忆，Stroustrup 警示了 C++ 所面临的风险，因为现在越来越多的特性被添加到了 C++ 中。
巨大的瓦萨号有一个难以解决的设计缺陷：头重脚轻，以至于它被[一阵狂风刮翻了][2]。通过援引这艘沉船的历史，Stroustrup 警示了 C++ 所面临的风险——现在越来越多的特性被添加到了 C++ 中。
现在已经提议了不少这样的特性。Stroustrup 在他的信中引用了 43 条提议。他认为那些参与 C++ 语言 ISO 标准演进的人（指众所周知的 [WG21][3]），正在努力地让语言更高级，但他们的努力方向却并不一致。
我们现在已经发现了好些能导致头重脚轻的特性。Stroustrup 在他的信中引用了 43 个提议。他认为那些参与 C++ 语言 ISO 标准演进的人（被称为 [WG21][3]），正在努力推进语言发展，但成员们的努力方向却并不一致。
在他的信中，他写道：
> 分开来看，许多提议都很有道理。但将它们综合到一起，这些提议是很愚蠢的，将危害 C++ 的未来。
>分开来看，许多提议都很有道理。但将它们综合到一起，这些提议是很愚蠢的，将危害 C++ 的未来。
他明确表示，不希望 C++ 重蹈瓦萨号的覆辙，这种渐近式的改进将敲响 C++ 的丧钟。相反，应该吸取瓦萨号的教训，构建一个坚实的基础，吸取经验教训，并做彻底的测试。
他明确表示，他用瓦萨号作为比喻并不是说他认为不断提升会带来毁灭。我们应该吸取瓦萨号的教训，构建一个坚实的基础，从错误中学习并对新版本做彻底的测试。
在瑞士拉普斯威尔（Rapperswill）召开的 C++ 标准化委员会会议之后，本月早些时候，Stroustrup 接受了_《The Register》_ 的采访，回答了有关 C++ 语言下一步发展方向方面的几个问题。（最新版是 C++17，它去年刚发布；下一个版本是 C++20，它正在开发中，预计于 2020 年发布。）
在瑞士<ruby>拉普斯威尔<rt>Rapperswill</rt></ruby>召开 C++ 标准化委员会会议之后，本月早些时候，Stroustrup 接受了 <i>The Register</i> 的采访，回答了有关 C++ 语言下一步发展方向方面的几个问题。（最新版是 C++17，它去年刚发布；下一个版本是 C++20，它正在开发中，预计于 2020 年发布。）
**Register：在你的信件《想想瓦萨号！》中，你写道：**
**<i>Register：</i>在您的信件《想想瓦萨号！》中，您写道：**
> 在 C++11 开始基础不再完整，而 C++17 中在使基础更加稳固、规范和完整方面几乎没有改善。相反地，却增加了重要接口的复杂度，让人们需要学习的特性数量越来越多。C++ 可能在这种提议的重压之下崩溃 —— 这些提议大多数都不成熟。我们不应该花费大量的时间为专家级用户们（比如我们自己）去创建越来越复杂的东西。~~（还要考虑普通用户的学习曲线，越复杂的东西越不易普及。）~~
>在 C++11 开始的基础建设尚未完成，而 C++17 基本没有在使基础更加稳固、规范和完整方面做出改善。相反地，却增加了重要接口的复杂度（原文为 surface complexity，直译“表面复杂度”），让人们需要学习的特性数量越来越多。C++ 可能在这种不成熟的提议的重压之下崩溃。我们不应该花费大量的时间为专家级用户们（比如我们自己）去创建越来越复杂的东西。~~（还要考虑普通用户的学习曲线，越复杂的东西越不易普及。）~~
**对新人来说，C++ 很难吗？如果是这样，你认为怎样的特性让新人更易理解？**
**对新人来说，C++ 过难了吗？如果是这样，您认为怎样的特性让新人更易理解？**
**Stroustrup：**C++ 的有些东西对于新人来说确实很难。
<b><i>Stroustrup：</i></b>C++ 的有些东西对于新人来说确实很具有挑战性。
换句话说，C++ 中有些东西对于新人来说，比起 C 或上世纪九十年代的 C++ 更容易理解了。而难点是让大型社区专注于这些部分，并且帮助新手和普通 C++ 用户去规避那些对高级库实现提供支持的部分。
另一方面而言，C++ 中有些东西对于新人来说，比起 C 或上世纪九十年代的 C++ 更容易理解了。而难点是让大型社区专注于这些部分，并且帮助新手和非专业的 C++ 用户去规避那些对高级库实现提供支持的部分。
我建议使用 [C++ 核心准则][4] 作为实现上述目标的一个辅助。
此外，我的 “C++ 教程” 也可以帮助人们在使用现代 C++ 时走上正确的方向，而不会迷失在自上世纪九十年代以来的复杂性中，或困惑于只有专家级的用户才能理解的东西中。第二版的 “C++ 教程” 涵盖了 C++17 和部分 C++20 的内容，这本书即将要出版了。
此外，我的“C++ 教程”也可以帮助人们在使用现代 C++ 时走上正确的方向，而不会迷失在自上世纪九十年代以来的复杂性中，或困惑于只有专家级的用户才能理解的东西中。这本即将出版的第二版的“ C++ 教程”涵盖了 C++17 和部分 C++20 的内容。
我和其他人给没有编程经验的大一新生教过 C++，只要你不去深挖编程语言的每个晦涩难懂的角落，把注意力集中到 C++ 中最主流的部分，在三个月内新可以学会 C++。
我和其他人给没有编程经验的大一新生教过 C++，只要你不去深入编程语言的每个晦涩难懂的角落，把注意力集中到 C++ 中最主流的部分，就可以在三个月内学会 C++。
“让简单的东西保持简单” 是我长期追求的目标。比如 C++11 的 `range-for` 循环：
“让简单的东西保持简单”是我长期追求的目标。比如 C++11 的 `range-for` 循环：
```
for (int& x : v) ++x; // increment each element of the container v
```
`v` 的位置可以是任何容器。在 C 和 C 风格的 C++ 中，它可能看到的是这样：
`v` 的位置可以是任何容器。在 C 和 C 风格的 C++ 中，它可能看起来是这样：
```
for (int i=0; i<MAX; i++) ++v[i]; // increment each element of the array v
```
一些人报怨说添加了 `range-for` 循环让 C++ 变得更复杂了，很显然，他们是正确的，因为它添加了一个新特性，但它却让 C++ 用起来更简单。同时它还解决掉了传统 for 循环中出现的一些常见错误。
一些人抱怨说添加了 `range-for` 循环让 C++ 变得更复杂了，很显然，他们是正确的，因为它添加了一个新特性。但它却让 C++ 用起来更简单，而且同时它还消除掉了使用传统 for 循环时会出现的一些常见错误。
另外的一个例子是 C++11 的标准线程库。它比起使用 POSIX 或直接使用 Windows 的 C API 来说更简单，并且更不易出错。
**Register：你如何看待 C++ 现在的状况？**
**<i>Register：</i>您如何看待 C++ 现在的状况？**
**Stroustrup：** C++11 是 C++ 的最重大的改进版，并且在 C++14 上全面完成了改进工作。C++17 添加了相当多的新特性，但是没有提供对新技术的很多支持。C++20 目前看上去可能会成为一个重大改进版。编译器的状况和标准库实现的非常好，非常接近最新的标准。C++17 已经可用。持续改进了对工具的支持。已经有了许多第三方的库和许多新工具。而不幸的是，这些东西不太好找到。
<b><i>Stroustrup：</i></b>C++11 中作出了许多重大改进，并且我们在 C++14 上全面完成了改进工作。C++17 添加了相当多的新特性，但是没有提供对新技术的很多支持。C++20 目前看上去可能会成为一个重大改进版。编译器的状况非常好，标准库实现得也很优秀，非常接近最新的标准。C++17 现在已经可以使用，对于工具的支持正在逐步推进。已经有了许多第三方的库和好些新工具。然而，不幸的是，这些东西不太好找到。
我在《想想瓦萨号！》一文中所表达的担忧与标准化过程有关，对新东西的过度热情与完美主义的组合拖延了重大的改进。“追述完美是优秀的敌人”，在六月份拉普斯威尔的会议上有 160 人参与。在这样一个数量庞大和多样化的人群中很难取得一致意见。这就导致了专家们更多地为他们自己去设计，而不是为了整个社区。
我在《想想瓦萨号！》一文中所表达的担忧与标准化过程有关，对新东西的过度热情与完美主义的组合推迟了重大改进。“追求完美是获得优秀成绩的障碍”。在六月份拉普斯威尔的会议上有 160 人参与；在这样一个数量庞大且多样化的人群中很难取得一致意见。专家们也本来就有只为自己设计语言的倾向，这让他们不会时常在设计时考虑整个社区的需求。
**Register： C++ 是否有一个期望的状况，或为了期望的适应性而努力简化以满足程序员们在任意时间的需要？**
**<i>Register：</i>C++ 是否有一个理想的状态，或者与之相反，您只是为了程序员们的期望而努力，随时适应并且努力满足程序员们的需要？**
**Stroustrup：** 二者都有。我很乐意看到 C++ 支持彻底保证类型安全和资源安全的编程方式。这不应该通过限制适用性或增加成本来实现，而是应该通过改进的表达能力和性能来实现。我认为可以做到这些，通过让程序员使用更好的（更易用的）语言可以实现这一点。
<b><i>Stroustrup：</i></b>二者都有。我很乐意看到 C++ 支持彻底保证类型安全和资源安全的编程方式。这不应该通过限制适用性或增加性能损耗来实现，而是应该通过改进的表达能力和更好的性能来实现。通过让程序员使用更好的（和更易用的）语言工具可以达到这个目标，我们可以做到的。
终极目标不会马上实现，也不会单靠语言的设计来实现。为了让编程更高效，我们需要通过改进语言特性、最好的库、静态分析、以及规则的组合来实现。C++ 核心准则是我提升 C++ 代码质量的广泛而长远的方法。
终极目标不会马上实现，也不会单靠语言设计来实现。为了实现这一目标，我们需要改进语言特性、提供更好的库和静态分析，并且设立提升编程效率的规则。C++ 核心准则是我为了提升 C++ 代码质量而实行的广泛而长期的计划的一部分。
**Register：对于 C++ 是否有明显的风险？如果有，它是如何产生的？（如，改进过于缓慢，新出现的低级语言，等等，从你的信中看，似乎是提议过多。）**
**<i>Register：</i>目前 C++ 是否面临着可以预见的风险？如果有，它是什么？（如，迭代过于缓慢，新兴低级语言，等等……据您的观点来看，似乎是提出的提议过多。）**
**Stroustrup：**毫无疑问，今年我们已经收到了 400 个提议。当然，它们并不都是新提议。许多提议都与规范语言和标准库这一必需而乏味的工作相关，但是量大到难以管理。你可以在 WG21 的网站上找到所有这些文章。
<b><i>Stroustrup：</i></b>就是这样。今年我们已经收到了 400 篇文章。当然了，它们并不都是新提议。许多提议都与规范语言和标准库这一必需而乏味的工作相关，但是量大到难以管理。你可以在 WG21 的网站上找到所有这些文章。
我写了《想想瓦萨号！》这封信作为一个呼吁。我感受到了这种压力，为解决紧急需要和赶时髦而增加语言特性，而不是去加强语言基础（比如，改善静态类型系统）。增加的任何新东西，无论它是多小都会产生成本，比如实现、学习、工具升级。重大的特性是那些改变我们编程思想的特性。那才是我们必须关注的东西。
我写了《想想瓦萨号！》这封信作为一个呼吁，因为这种为了解决即刻需求（或者赶时髦）而不断增添语言特性，却对巩固语言基础（比如，改善静态类型系统）不管不问的倾向让我感到震惊。增加的任何新东西，无论它多小都会产生成本，比如实现、学习、工具升级。重大的特性改变能够改变我们对编程的想法，而它们才是我们必须关注的东西。
委员会已经设立了一个”指导小组“，这个小组由在语言、标准库、实现、以及实际使用领域中拥有极强履历的人组成。我是其中的成员之一。我们负责为重点领域写一些关于方向、设计理念和建议方面的东西。
委员会已经设立了一个”指导小组“，这个小组由在语言、标准库、实现、以及工程实践领域中拥有不错履历的人组成。我是其中的成员之一。我们负责为重点领域写一些关于发展方向、设计理念和建议重点发展领域的东西。
对于 C++20，我们建议去关注：
```
概念
模块(提供适当的模块化和令人称奇的编译时改进)
Ranges（包括一些无限序列的扩展）
标准库中的网络概念
```
* 概念
* 模块(适度地模块化并带来编译时的显著改进)
* Ranges（包括一些无限序列的扩展）
* 标准库中的网络概念
在拉普斯威尔会议之后，虽然带来的模块和网络化很显然只是一种延伸，但机会还是有的。我是一个乐观主义者，并且委员会的成员们都非常努力。
在拉普斯威尔会议之后，这些都有了实现的机会，虽然模块和网络化都不是会议的重点讨论对象。我是一个乐观主义者，并且委员会的成员们都非常努力。
我并不担心其它语言或新语言会取代它。我喜欢编程语言。如果一个新的语言提供了其它编程语言没有提供的非常有用的东西，那它就是我们从中学习的榜样，当然，每个语言都有它自己的问题。许多 C++ 的问题都与它广泛的应用领域、大量的使用人群和过度的热情有关。大多数语言的社区都喜欢有这样的问题。
我并不担心其它语言或新语言会取代它。我喜欢编程语言。如果一门新的语言提供了独一无二的、非常有用的东西，那它就是我们的榜样，我们可以向它学习。当然，每门语言本身都有一些问题。 C++ 的许多问题都与它广泛的应用领域、大量的使用人群和过度的热情有关。大多数语言的社区都会有这样的问题。
**Register：关于 C++ 你是否重新考虑过任何架构方面的决策？**
**<i>Register：</i>关于 C++ 您是否重新考虑过任何架构方面的决策？**
**Stroustrup：** 当我使用一些新的编程语言时，我经常思考 C++ 原来的决策和设计。例如，可以看我的《编程的历史》论文第 1、2 部分。
<b><i>Stroustrup：</i></b>当我着手规划新版本时，我经常反思原来的决策和设计。关于这些，可以看我的《编程的历史》论文第 1、2 部分。
并没有让我觉得很懊悔的重大决策，如果让我重新再做一次决策，几乎不会对现有的特性做任何不同的改变。
并没有让我觉得很后悔的重大决策。虽然如果我必须重新做一次，我不能保证我不会改变这门语言的特性。
与以前一样，能够直接处理硬件加上零开销的抽象是设计的指导思想。使用构造函数和析构函数去处理资源是关键（RAII），STL 就是在 C++ 库中能够做什么的一个很好的例子。
与以前一样，能够直接处理硬件加上零开销的抽象是设计的指导思想。使用构造函数和析构函数去处理资源是关键（RAII）；STL 就是解释 C++ 库能够做什么的一个很好的例子。
**Register：在 2011 年采纳的每三年发布一个标准的节奏是否仍然有效？我之所以这样问是因为 Java 为了更快地迭代，一直在解决需求。**
**<i>Register：</i>在 2011 年被采纳的，每三年发布一个标准的节奏是否仍然有效？我之所以这样问是因为 Java 已经决定更快地迭代。**
**Stroustrup：**我认为 C++20 将会按时发布（就像 C++14 和 C++17 那样），并且主要的编译器也会立即遵从它。我也希望 C++20 比起 C++17 能有重大的改进。
<b><i>Stroustrup：</i></b>我认为 C++20 将会按时发布（就像 C++14 和 C++17 那样），并且主流的编译器也会立即采用它。我也希望 C++20 基于 C++17 能有重大的改进。
对于其它语言如何管理它们的发行版我并不焦虑。C++ 是由一个遵循 ISO 规则的委员会来管理的，并不是由一个大公司或一个”创造它的权威“来管理。这一点不会改变。关于 ISO 标准，C++ 每三年发布一次的周期是一个激动人心的创举。标准的周期是 5 或 10 年。
对于其它语言如何管理它们的版本，我并不十分关心。C++ 是由一个遵循 ISO 规则的委员会来管理的，而不是由某个大公司或某种“终生的仁慈独裁者”来管理。这一点不会改变。C++ 每三年发布一次的周期在ISO标准中是一个引人注目的创举。通常而言，周期应该是 5 或 10 年。
**Register：在你的信中你写道：**
**<i>Register：</i>在您的信中您写道：**
```
我们需要一个能够被”普通程序员“使用的条理还算清楚的编程语言，他们主要关心的是能否按时高质量地交付他们的应用程序。
```
>我们需要一个能够被”普通程序员“使用的，条理还算清楚的编程语言。他们主要关心的是，能否按时高质量地交付他们的应用程序。
对语言的改变是否能够去解决这个问题，或者还可能涉及到更多容易获得的工具和教育支持？
改进语言能够解决这个问题吗？或者，我们还需要更容易获得的工具和教育支持？
**Stroustrup：**我努力去宣传我的理念 —— C++ 是什么以及如何使用它，并且我鼓励其他人也和我一样去做。
<b><i>Stroustrup：</i></b>我尽力宣传我关于 C++ 的实质和使用方式的理念，并且我鼓励其他人也和我采取相同的行动。
特别是，我鼓励讲师和作者们向 C++ 程序员们宣扬有用易用的理念，而不是去示范复杂的示例和技术来展示他们自己有多高明。我在 2017 年的 CppCon 大会上的演讲主题就是”学习和教学 C++“，并且也指出 C++ 需要更好的工具。
特别是，我鼓励讲师和作者们向 C++ 程序员们提出有用的建议，而不是去示范复杂的示例和技术，来展示他们自己有多高明。我在 2017 年的 CppCon 大会上的演讲主题就是“学习和传授 C++”，并且也指出，我们需要更好的工具。
我在演讲中提到构建支持和包管理器。这些历来都是 C++ 的弱点项。标准化委员会现在有一个工具研究小组，或许不久的将来也会有一个教育研究小组。
我在演讲中提到了构建技术支持和包管理器，这些历来都是 C++ 的弱点项。标准化委员会现在有一个工具研究小组，或许不久的将来也会组建一个教育研究小组。
C++ 的社区以前基本上是很乱的，但是在过去的五年里，为了满足社区对新闻和支持的需要，出现了很多会议和博客。CppCon、isocpp.org、以及 Meeting++ 就是这样的例子。
C++ 的社区以前是十分无组织性的，但是在过去的五年里，为了满足社区对新闻和技术支持的需要，出现了很多集会和博客。CppCon、isocpp.org、以及 Meeting++ 就是一些例子。
在委员会中做设计是非常困难的。但是，对于所有的大型项目来说，委员会又是必不可少的。我很关注它们，但是为了成功，关注和面对问题是必需的。
设计一个委员会是非常困难的。但是，对于所有的大型项目来说，委员会又是必不可少的。我很忧虑，但是关注它们并且面对问题是成功的必要条件。
**Register：你如何看待 C++ 社区的流程？在沟通和决策方面你希望看到哪些变化？**
**<i>Register：</i>您如何看待 C++ 社区的流程？在沟通和决策方面你希望看到哪些变化？**
**Stroustrup：**C++ 并没有企业管理的”社区流程“；它有一个 ISO 标准流程。我们不能对 ISO 的角色做重大的改变。理想的情况是，我们设立一个小的全职的”秘书处“来做最终决策和方向管理，但这种理想情况是不会出现的。相反，我们有成百上千的人在线来讨论，大约有 160 人在技术问题上进行投票，大约有 70 组织和 11 个国家在结果提议上正式投票。这样是很混乱的，但是在将来某个时候我们会让它好起来。
<b><i>Stroustrup：</i></b>C++ 并没有企业管理一般的“社区流程”；它所遵循的是 ISO 标准流程。我们不能对 ISO 的条例做大的改变。理想的情况是，我们设立一个小型的、全职的“秘书处”来做最终决策和方向管理，但这种理想情况是不会出现的。相反，我们有成百上千的人在线讨论，大约有 160 人在技术问题上进行投票，大约有 70 组织和 11 个国家的人在最终提议上正式投票。这样很混乱，但是有些时候它的确能发挥作用。
**Register：最终你认为那些即将推出的 C++ 特性中，对 C++ 用户最有帮助的是哪些？**
**<i>Register：</i>在最后，您认为那些即将推出的 C++ 特性中，对 C++ 用户最有帮助的是哪些？**
**Stroustrup：**
**<i>Stroustrup：</i>**
```
大大地简化了一般编程的概念
并行算法 – 没有比使用现代化硬件的并发特性更好的方法了
协程，如果委员会能够确定在 C++20 上推出。
模块改进了组织源代码的方式，并且大幅改善了编译时间。我希望能有这样的模块，但是它还不能确定能否在 C++20 上推出。
一个标准的网络库，但是它还不能确定能否在 C++20 上推出。
```
* 那些能让编程显著变简单的概念
* 并行算法 – 如果要使用现代硬件的并发特性的话，这方法再简单不过了
* 协程，如果委员会能够确定在 C++20 上推出。
* 改进了组织源代码方式的，并且大幅改善了编译时间的模块。我希望能有这样的模块，但是还没办法确定我们能不能在 C++20 上推出。
* 一个标准的网络库，但是还没办法确定我们能否在 C++20 上推出。
此外：
```
Contracts（运行时检查的先决条件、后置条件、和断言）可能对许多人都非常重要。
date 和 time-zone 支持库可能对许多人（行业）非常重要。
```
* Contracts（运行时检查的先决条件、后置条件、和断言）可能对许多人都非常重要。
* date 和 time-zone 支持库可能对许多人（行业）非常重要。
**Register：最后你还有需要向读者说的话吗？**
**<i>Register：</i>您还有想对读者们说的话吗？**
**Stroustrup：**如果 C++ 标准化委员会能够专注于重大问题，去解决重大问题，那么 C++20 将会是非常优秀的。但是在 C++20 推出之前，我们的 C++17 仍然是非常好的，它将改变很多人关于 C++ 已经落伍的旧印象。®
<b><i>Stroustrup：</i></b>如果 C++ 标准化委员会能够专注于重大问题，去解决重大问题，那么 C++20 将会非常优秀。但是在 C++20 推出之前，我们还有 C++17；无论如何，它仍然远超许多人对 C++ 的旧印象。®
------
@ -151,7 +141,7 @@ via: https://www.theregister.co.uk/2018/06/18/bjarne_stroustrup_c_plus_plus/
作者：[Thomas Claburn][a]
选题：[lujun9972](https://github.com/lujun9972)
译者：[qhwdw](https://github.com/qhwdw)
校对：[校对者ID](https://github.com/校对者ID)
校对：[thecyanbird](https://github.com/thecyanbird)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
@ -160,4 +150,4 @@ via: https://www.theregister.co.uk/2018/06/18/bjarne_stroustrup_c_plus_plus/
[2]: https://www.vasamuseet.se/en/vasa-history/disaster
[3]: http://open-std.org/JTC1/SC22/WG21/
[4]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md
[5]: https://go.theregister.co.uk/tl/1755/shttps://continuouslifecycle.london/
[5]: https://go.theregister.co.uk/tl/1755/shttps://continuouslifecycle.london/

94
sources/tech/20180803 SDKMAN - A CLI Tool To Easily Manage Multiple Software Development Kits.md → translated/tech/20180803 SDKMAN - A CLI Tool To Easily Manage Multiple Software Development Kits.md
View File

@ -1,40 +1,40 @@
translating by dianbanjiu
SDKMAN – A CLI Tool To Easily Manage Multiple Software Development Kits
SDKMAN – 轻松管理多个软件开发套件 (SDK) 的命令行工具
======
![](https://www.ostechnix.com/wp-content/uploads/2018/08/sdkman-720x340.png)
Are you a developer who often install and test applications on different SDKs? I’ve got a good news for you! Say hello to **SDKMAN** , a CLI tool that helps you to easily manage multiple software development kits. It provides a convenient way to install, switch, list and remove candidates. Using SDKMAN, you can now manage parallel versions of multiple SDKs easily on any Unix-like operating system. It allows the developers to install Software Development Kits for the JVM such as Java, Groovy, Scala, Kotlin and Ceylon. Ant, Gradle, Grails, Maven, SBT, Spark, Spring Boot, Vert.x and many others are also supported. SDKMAN is free, light weight, open source and written in **Bash**.
你是否是一个经常在不同的 SDK 下安装和测试应用的开发者？我有一个好消息要告诉你！**SDKMAN**，一个可以帮你轻松管理多个 SDK 的命令行工具。它为安装、切换、列出和移除 SDK 提供了一个简便的方式。有了 SDKMAN，你可以在任何类 Unix 的操作系统上轻松地并行管理多个 SDK 的多个版本。它允许开发者为 JVM 安装不同的 SDK，例如 Java、Groovy、Scala、Kotlin 和 Ceylon、Ant、Gradle、Grails、Maven、SBT、Spark、Spring Boot、Vert.x，以及许多其他支持的 SDK。SDKMAN 是免费、轻量、开源、使用 **Bash** 编写的程序。
### Installing SDKMAN
### 安装 SDKMAN
Installing SDKMAN is trivial. First, make sure you have installed **zip** and **unzip** applications. It is available in the default repositories of most Linux distributions. For instance, to install unzip on Debian-based systems, simply run:
安装 SDKMAN 很简单。首先，确保你已经安装了 **zip** 和 **unzip** 这两个应用。它们在大多数的 Linux 发行版的默认仓库中。
例如，在基于 Debian 的系统上安装 unzip，只需要运行：
```
$ sudo apt-get install zip unzip
```
Then, install SDKMAN using command:
然后使用下面的命令安装 SDKMAN：
```
$ curl -s "https://get.sdkman.io" | bash
```
It’s that simple. Once the installation is completed, run the following command:
在安装完成之后，运行以下命令：
```
$ source "$HOME/.sdkman/bin/sdkman-init.sh"
```
If you want to install it in a custom location of your choice other than **$HOME/.sdkman** , for example **/usr/local/** , do:
如果你希望自定义安装到其他位置，例如 **/usr/local/**，你可以这样做：
```
$ export SDKMAN_DIR="/usr/local/sdkman" && curl -s "https://get.sdkman.io" | bash
```
Make sure your user has full access rights to this folder.
确保你的用户有足够的权限访问这个目录。
Finally, check if the installation is succeeded using command:
最后，在安装完成后使用下面的命令检查一下：
```
$ sdk version
==== BROADCAST =================================================================
@ -47,17 +47,17 @@ SDKMAN 5.7.2+323
```
Congratulations! SDKMAN has been installed. Let us go ahead and see how to install and manage SDKs.
恭喜你！SDKMAN 已经安装完成了。让我们接下来看如何安装和管理 SDKs 吧。
### Manage Multiple Software Development Kits
### 管理多个 SDK
To view the list of available candidates(SDKs), run:
查看可用的 SDK 清单，运行：
```
$ sdk list
```
Sample output would be:
将会输出：
```
================================================================================
Available Candidates
@ -82,15 +82,15 @@ tasks.
```
As you can see, SDKMAN list one candidate at a time along with the description of the candidate and it’s official website and the installation command. Press ENTER key to list the next candidates.
就像你看到的，SDK 每次列出众多 SDK 中的一个，以及该 SDK 的描述信息、官方网址和安装命令。按回车键继续下一个。
To install a SDK, for example Java JDK, run:
安装一个新的 SDK，例如 Java JDK，运行：
```
$ sdk install java
```
Sample output:
将会输出：
```
Downloading: java 8.0.172-zulu
@ -109,27 +109,27 @@ Setting java 8.0.172-zulu as default.
```
If you have multiple SDKs, it will prompt if you want the currently installed version to be set as **default**. Answering **Yes** will set the currently installed version as default.
如果你安装了多个 SDK，它将会提示你是否想要将当前安装的版本设置为 **默认版本**。回答 **Yes** 将会把当前版本设置为默认版本。
To install particular version of a SDK, do:
使用以下命令安装一个 SDK 的其他版本：
```
$ sdk install ant 1.10.1
```
If you already have local installation of a specific candidate, you can set it as local version like below.
如果你之前已经在本地安装了一个 SDK，你可以像下面这样设置它为本地版本。
```
$ sdk install groovy 3.0.0-SNAPSHOT /path/to/groovy-3.0.0-SNAPSHOT
```
To list a particular candidates versions:
列出一个 SDK 的多个版本：
```
$ sdk list ant
```
Sample output:
将会输出
```
================================================================================
Available Ant Versions
@ -148,21 +148,21 @@ Available Ant Versions
```
Like I already said, If you have installed multiple versions, SDKMAN will prompt you if you want the currently installed version to be set as **default**. You can answer Yes to set it as default. Also, you can do that later by using the following command:
像我之前说的，如果你安装了多个版本，SDKMAN 会提示你是否想要设置当前安装的版本为 **默认版本**。你可以回答 Yes 设置它为默认版本。当然，你也可以在稍后使用下面的命令设置：
```
$ sdk default ant 1.9.9
```
The above command will set Apache Ant version 1.9.9 as default.
上面的命令将会设置 Apache Ant 1.9.9 为默认版本。
You can choose which version of an installed candidate to use by using the following command:
你可以根据自己的需要选择使用任何已安装的 SDK 版本，仅需运行以下命令：
```
$ sdk use ant 1.9.9
```
To check what is currently in use for a Candidate, for example Java, run:
检查某个具体 SDK 当前的版本号，例如 Java，运行：
```
$ sdk current java
@ -170,7 +170,7 @@ Using java version 8.0.172-zulu
```
To check what is currently in use for all Candidates, for example Java, run:
检查所有当下在使用的 SDK 版本号，运行：
```
$ sdk current
@ -181,19 +181,19 @@ java: 8.0.172-zulu
```
To upgrade an outdated candidate, do:
升级过时的 SDK，运行：
```
$ sdk upgrade scala
```
You can also check what is outdated for all Candidates as well.
你也可以检查所有的 SDKs 中还有哪些是过时的。
```
$ sdk upgrade
```
SDKMAN has offline mode feature that allows the SDKMAN to function when working offline. You can enable or disable the offline mode at any time by using the following commands:
SDKMAN 有离线模式，可以让 SDKMAN 在离线时也正常运作。你可以使用下面的命令在任何时间开启或者关闭离线模式：
```
$ sdk offline enable
@ -201,13 +201,13 @@ $ sdk offline disable
```
To remove an installed SDK, run:
要移除已安装的 SDK，运行：
```
$ sdk uninstall ant 1.9.9
```
For more details, check the help section.
要了解更多的细节，参阅帮助章节。
```
$ sdk help
@ -239,15 +239,15 @@ version : where optional, defaults to latest stable if not provided
```
### Update SDKMAN
### 更新 SDKMAN
The following command installs a new version of SDKMAN if it is available.
如果有可用的新版本，可以使用下面的命令安装：
```
$ sdk selfupdate
```
SDKMAN will also periodically check for any updates and let you know with instruction on how to update.
SDKMAN 会定期检查更新，以及让你了解如何更新的指令。
```
WARNING: SDKMAN is out-of-date and requires an update.
@ -256,30 +256,29 @@ Adding new candidates(s): scala
```
### Remove cache
### 清除缓存
It is recommended to clean the cache that contains the downloaded SDK binaries for time to time. To do so, simply run:
建议时不时的清理缓存（包括那些下载的 SDK 的二进制文件）。仅需运行下面的命令就可以了：
```
$ sdk flush archives
```
It is also good to clean temporary folder to save up some space:
它也可以用于清理空的文件夹，节省一点空间：
```
$ sdk flush temp
```
### Uninstall SDKMAN
### 卸载 SDKMAN
If you don’t need SDKMAN or don’t like it, remove as shown below.
如果你觉得不需要或者不喜欢 SDKMAN，可以使用下面的命令删除。
```
$ tar zcvf ~/sdkman-backup_$(date +%F-%kh%M).tar.gz -C ~/ .sdkman
$ rm -rf ~/.sdkman
```
Finally, open your **.bashrc** , **.bash_profile** and/or **.profile** files and find and remove the following lines.
最后打开你的 **.bashrc**，**.bash_profile** 和/或者 **.profile**，找到并删除下面这几行。
```
#THIS MUST BE AT THE END OF THE FILE FOR SDKMAN TO WORK!!!
export SDKMAN_DIR="/home/sk/.sdkman"
@ -287,11 +286,14 @@ export SDKMAN_DIR="/home/sk/.sdkman"
```
If you use ZSH, remove the above line from the **.zshrc** file.
如果你使用的是 ZSH，就从 **.zshrc** 中删除上面这一行。
And, that’s all for today. I hope you find SDKMAN useful. More good stuffs to come. Stay tuned!
这就是所有的内容了。我希望 SDKMAN 可以帮到你。还有更多的干货即将到来。敬请期待！
Cheers!
祝近祺！
：）
@ -301,7 +303,7 @@ via: https://www.ostechnix.com/sdkman-a-cli-tool-to-easily-manage-multiple-softw
作者：[SK][a]
选题：[lujun9972](https://github.com/lujun9972)
译者：[译者ID](https://github.com/译者ID)
译者：[dianbanjiu](https://github.com/dianbanjiu)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

175
translated/tech/20181017 How To Determine Which System Manager Is Running On Linux System.md Normal file
View File

@ -0,0 +1,175 @@
弄清 Linux 系统运行何种系统管理程序
======
虽然我们经常听到系统管理器这词，但很少有人深究其确切意义。现在我们将向你展示其区别。
我会尽自己所能来解释清楚一切。我们大多都知道 System V 和 systemd 两种系统管理器。 System V （简写 Sysv） 是老系统所使用的古老且传统的 init 进程和系统管理器。
Systemd 是全新的 init 进程和系统管理器，并且适配大部分主发布版本 Linux 系统。
Linux 系统中主要有三种 init 进程系统，很出名且仍在使用。大多数 Linux 发布版本都使用其中之一。
### 什么是初始化系统管理器 (init System Manager)？
在基于 Linux/Unix 的操作系统中，init (初始化的简称) 是内核启动系统时开启的第一个进程。
它持有的进程 ID（PID）号为 1，其在后台一直运行着，直到关机。
Init 会查找 `/etc/inittab` 文件中相应配置信息来确定系统的运行级别，然后根据运行级别启动所有的后台进程和后台应用。
作为 Linux 启动过程的一部分，BIOS，MBR，GRUB 和内核进程此进程之前就被激活了。
下面列出的是 Linux 的可用运行级别（存在七个运行级别，从零到六）。
* **`0:`** 停机
* **`1:`** 单用户模式
* **`2:`** 多用户, 无 NFS (译者注：Network File System 即网络文件系统)
* **`3:`** 全功能多用户模式
* **`4:`** 未使用
* **`5:`** X11 (GUI – 图形用户界面)
* **`6:`** 重启
下面列出的是 Linux 系统中广泛使用的三种 init 进程系统。
* **`System V (Sys V):`** System V（Sys V）是类 Unix 操作系统的首款传统的 `init` 进程系统。
* **`Upstart:`** Upstart 基于事件驱动，是 `/sbin/init` 守护进程的替代品。
* **`systemd:`** Systemd 是一款全新的 `init` 进程系统和系统管理器，它通过传统的 `SysV init` 进程系统来实现/适配全部的 Linux 主版本。
### 什么是 System V (Sys V)?
System V（Sys V）是类 Unix 操作系统的首款传统的 `init` 进程系统。init 是内核启动系统期间启动的第一个进程，它是所有进程的父进程。
起初，大多数 Linux 发行版都使用名为 System V（Sys V）的传统 `init` 进程系统。 多年来，为了解决标准版本中的设计限制，发布了几个替代的 init 进程系统，例如launchd、Service Management Facility、systemd 和 Upstart。
但只有 systemd 最终被几个主要 Linux 发行版本所采用，而放弃传统的 SysV。
### 在 Linux 上如何识别出 `System V(Sys V)` 系统管理器
在系统上运行如下命令来查看是否在运行着 System V (Sys V) 系统管理器：
### 方法 1: 使用 `ps` 命令
**ps** – 显示当前进程快照。`ps` 会显示当前活动进程的信息。其输出区分不出是 System V(SysV) 还是 upstart，所以我建议使用其它方法。
```
# ps -p1 | grep "init\|upstart\|systemd"
1 ? 00:00:00 init
```
### 方法 2: 使用 `rpm` 命令
RPM 即 `Red Hat Package Manager （红帽包管理）`，是一款功能强大的[安装包管理][1]命令行具，在基于 Red Hat 的发布系统中使用，如 RHEL、CentOS、Fedora、openSUSE 和 Mageia。此工具可以在系统/服务上对软件进行安装、更新、删除、查询及验证等操作。通常 RPM 文件都带有 `.rpm` 后缀。
RPM 会使用必须的库和依赖库来构建软件，并具不会与系统上安装的其它包冲突。
```
# rpm -qf /sbin/init
SysVinit-2.86-17.el5
```
### 什么是 Upstart?
Upstart 基于事件驱动，是 `/sbin/init` 守护进程的替代品。用来启动、停止及监视系统的所有任务和服务。
最初，它是为 Ubuntu 系统而开发的，但也可以在所有的 Linux 发布版本中部署运行，以替代古老的 System-V init 进程系统。
它在 Ubuntu 9.10 到 14.10 版本和基于 RHEL 6 的系统中使用，之后的 Linux 版本被 systemd 取代了。
### 在 Linux 上如何识别出 `Upstart` 系统管理器
在系统上运行如下命令来查看是否在运行着 Upstart 系统管理器：
### 方法 1: 使用 `ps` 命令
**ps** – 显示当前进程快照。`ps` 会显示当前活动进程的信息。其输出区分不出是 System V(SysV) 还是 upstart，所以我建议使用其它方法。
```
# ps -p1 | grep "init\|upstart\|systemd"
1 ? 00:00:00 init
```
### 方法 2: 使用 `rpm` 命令
RPM 即 `Red Hat Package Manager （红帽包管理）`，是一款功能强大的安装包管理命令行具，在基于 Red Hat 的发布系统中使用，如 RHEL、CentOS、Fedora、openSUSE 和 Mageia。此[ RPM 命令][2]可以让你在系统/服务上对软件进行安装、更新、删除、查询及验证等操作。通常 RPM 文件都带有 `.rpm` 后缀。
RPM 会使用必须的库和依赖库来构建软件，并具不会与系统上安装的其它包冲突。
```
# rpm -qf /sbin/init
upstart-0.6.5-16.el6.x86_64
```
### 方法 3: 使用 `/sbin/init` 文件
`/sbin/init` 程序会将根文件系统从内存加载或切换到磁盘。
这是启动过程的主要部分。这个进程开始时的运行级别为 “N”（无）。`/sbin/init` 此程序会按照 `/etc/inittab` 配制文件的描述来初始化系统。
```
# /sbin/init --version
init (upstart 0.6.5)
Copyright (C) 2010 Canonical Ltd.
This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
```
### 什么是 systemd?
Systemd 是一款全新的 `init` 进程系统和系统管理器，它通过传统的 `SysV init` 进程系统来实现/适配全部的 Linux 主版本。
systemd 与 SysV 和 LSB (全称：Linux Standards Base) init 脚本兼容。它可以作为 sysv init 系统的直接替代品。其是内核启动的第一个进程并占有 1 的 PID。
它是所有进程的父进程，Fedora 15 是第一个采用 systemd 而不是 upstart 的发行版本。[systemctl][3] 是一款命令行工具，它是管理 systemd 守护进程/服务（如 start、restart、stop、enable、disable、reload 和 status ）的主要工具。
systemd 使用 `.service` 文件而不是 bash 脚本（SysV init 使用）。systemd 把所有守护进程按顺序排列到自己 Cgroups （译者注：Cgroups 是 control groups 的缩写，是 Linux 内核提供的一种可以限制、记录、隔离进程组（process groups）所使用的物理资源（如：cpu,memory,IO等等）的机制。最初由 google 的工程师提出，后来被整合进Linux内核。Cgroups 也是 LXC 为实现虚拟化所使用的资源管理手段，可以说没有 cgroups 就没有 LXC。）中，所以通过探索 `/ cgroup/systemd` 文件就可以查看系统层次结构。
### 在 Linux 上如何识别出 `systemd` 系统管理器
在系统上运行如下命令来查看是否在运行着 systemd 系统管理器：
### 方法 1: 使用 `ps` 命令
**ps** – 显示当前进程快照。`ps` 会显示当前活动进程的信息。
```
# ps -p1 | grep "init\|upstart\|systemd"
1 ? 00:18:09 systemd
```
### 方法 2: 使用 `rpm` 命令
RPM 即 `Red Hat Package Manager （红帽包管理）`，是一款功能强大的安装包管理命令行具，在基于 Red Hat 的发布系统中使用，如 RHEL、CentOS、Fedora、openSUSE 和 Mageia。此工具可以在系统/服务上对软件进行安装、更新、删除、查询及验证等操作。通常 RPM 文件都带有 `.rpm` 后缀。
RPM 会使用必须的库和依赖库来构建软件，并具不会与系统上安装的其它包冲突。
```
# rpm -qf /sbin/init
systemd-219-30.el7_3.9.x86_64
```
### 方法 3: 使用 `/sbin/init` 文件
`/sbin/init` 程序会将根文件系统从内存加载或切换到磁盘。
这是启动过程的主要部分。这个进程开始时的运行级别为 “N”（无）。`/sbin/init` 此程序会按照 `/etc/inittab` 配制文件的描述来初始化系统。
```
# file /sbin/init
/sbin/init: symbolic link to `../lib/systemd/systemd'
```
--------------------------------------------------------------------------------
via: https://www.2daygeek.com/how-to-determine-which-init-system-manager-is-running-on-linux-system/
作者：[Prakash Subramanian][a]
选题：[lujun9972][b]
译者：[runningwater](https://github.com/runningwater)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.2daygeek.com/author/prakash/
[b]: https://github.com/lujun9972
[1]: https://www.2daygeek.com/category/package-management/
[2]: https://www.2daygeek.com/rpm-command-examples/
[3]: https://www.2daygeek.com/how-to-check-all-running-services-in-linux/

123
translated/tech/20181029 Machine learning with Python- Essential hacks and tricks.md Normal file
View File

@ -0,0 +1,123 @@
Python 机器学习的必备技巧
======
> 尝试使用 Python 掌握机器学习、人工智能和深度学习。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/programming-code-keyboard-laptop.png?itok=pGfEfu2S)
想要入门机器学习并不难。除了<ruby>大规模网络公开课<rt>Massive Open Online Courses</rt></ruby>（MOOCs）之外，还有很多其它优秀的免费资源。下面我分享一些我觉得比较有用的方法。
1. 阅览一些关于这方面的视频、文章或者书籍，例如 [The Master Algorithm: How the Quest for the Ultimate Learning Machine Will Remake Our World][29]，你肯定会喜欢这些[关于机器学习的互动页面][30]。
2. 对于“机器学习”、“人工智能”、“深度学习”、“数据科学”、“计算机视觉”和“机器人技术”这一堆新名词，你需要知道它们之前的区别。你可以阅览这些领域的专家们的演讲，例如[数据科学家 Brandon Rohrer 的这个视频][1]。
3. 明确你自己的学习目标，并选择合适的 [Coursera 课程][3]，或者参加高校的网络公开课。例如[华盛顿大学的课程][4]就很不错。
4. 关注优秀的博客：例如 [KDnuggets][32] 的博客、[Mark Meloon][33] 的博客、[Brandon Rohrer][34] 的博客、[Open AI][35] 的博客，这些都值得推荐。
5. 如果你对在线课程有很大兴趣，后文中会有如何[正确选择 MOOC 课程][31]的指导。
6. 最重要的是，培养自己对这些技术的兴趣。加入一些优秀的社交论坛，专注于阅读和了解，将这些技术的背景知识和发展方向理解透彻，并积极思考在日常生活和工作中如何应用机器学习或数据科学的原理。例如建立一个简单的回归模型来预测下一次午餐的成本，又或者是从电力公司的网站上下载历史电费数据，在 Excel 中进行简单的时序分析以发现某种规律。在你对这些技术产生了浓厚兴趣之后，可以观看以下这个视频。
<https://www.youtube.com/embed/IpGxLWOIZy4>
### Python 是机器学习和人工智能方面的最佳语言吗？
除非你是一名专业的研究一些复杂算法纯理论证明的研究人员，否则，对于一个机器学习的入门者来说，需要熟悉至少一种高级编程语言一家相关的专业知识。因为大多数情况下都是需要考虑如何将机器学习算法应用于解决实际问题，而这需要有一定的编程能力作为基础。
哪一种语言是数据科学的最佳语言？这个讨论一直没有停息过。对于这方面，你可以提起精神来看一下 FreeCodeCamp 上这一篇关于[数据科学语言][6]的文章，又或者是 KDnuggets 关于 [Python 和 R][7] 之间的深入探讨。
目前人们普遍认为 Python 在开发、部署、维护各方面的效率都是比较高的。与 Java、C 和 C++ 这些较为传统的语言相比，Python 的语法更为简单和高级。而且 Python 拥有活跃的社区群体、广泛的开源文化、数百个专用于机器学习的优质代码库，以及来自业界巨头（包括Google、Dropbox、Airbnb 等）的强大技术支持。
### 基础 Python 库
如果你打算使用 Python 实施机器学习，你必须掌握一些 Python 包和库的使用方法。
#### NumPy
NumPy 的完整名称是 [Numerical Python][8]，它是 Python 生态里高性能科学计算和数据分析都需要用到的基础包，几乎所有高级工具（例如 [Pandas][9] 和 [scikit-learn][10]）都依赖于它。[TensorFlow][11] 使用了 NumPy 数组作为基础构建块以支持 Tensor 对象和深度学习的图形流。很多 NumPy 操作的速度都非常快，因为它们都是通过 C 实现的。高性能对于数据科学和现代机器学习来说是一个非常宝贵的优势。
![](https://opensource.com/sites/default/files/uploads/machine-learning-python_numpy-cheat-sheet.jpeg)
#### Pandas
Pandas 是 Python 生态中用于进行通用数据分析的最受欢迎的库。Pandas 基于 NumPy 数组构建，在保证了可观的执行速度的同时，还提供了许多数据工程方面的功能，包括：
* 对多种不同数据格式的读写操作
* 选择数据子集
* 跨行列计算
* 查找并补充缺失的数据
* 将操作应用于数据中的独立组
* 按照多种格式转换数据
* 组合多个数据集
* 高级时间序列功能
* 通过 Matplotlib 和 Seaborn 进行可视化
![](https://opensource.com/sites/default/files/uploads/pandas_cheat_sheet_github.png)
#### Matplotlib 和 Seaborn
数据可视化和数据分析是数据科学家的必备技能，毕竟仅凭一堆枯燥的数据是无法有效地将背后蕴含的信息向受众传达的。这两项技能对于机器学习来说同样重要，因为首先要对数据集进行一个探索性分析，才能更准确地选择合适的机器学习算法。
[Matplotlib][12] 是应用最广泛的 2D Python 可视化库。它包含海量的命令和接口，可以让你根据数据生成高质量的图表。要学习使用 Matplotlib，可以参考这篇详尽的[文章][13]。
![](https://opensource.com/sites/default/files/uploads/matplotlib_gallery_-1.png)
[Seaborn][14] 也是一个强大的用于统计和绘图的可视化库。它在 Matplotlib 的基础上提供样式灵活的 API、用于统计和绘图的常见高级函数，还可以和 Pandas 提供的功能相结合。要学习使用 Seaborn，可以参考这篇优秀的[教程][15]。
![](https://opensource.com/sites/default/files/uploads/machine-learning-python_seaborn.png)
#### Scikit-learn
Scikit-learn 是机器学习方面通用的重要 Python 包。它实现了多种[分类][16]、[回归][17]和[聚类][18]算法，包括[支持向量机][19]、[随机森林][20]、[梯度增强][21]、[k-means 算法][22]和 [DBSCAN 算法][23]，可以与 Python 的数值库 NumPy 和科学计算库 [SciPy][24] 结合使用。它通过兼容的接口提供了有监督和无监督的学习算法。Scikit-learn 的强壮性让它可以稳定运行在生产环境中，同时它在易用性、代码质量、团队协作、文档和性能等各个方面都有良好的表现。可以参考这篇基于 Scikit-learn 的[机器学习入门][25]，或者这篇基于 Scikit-learn 的[简单机器学习用例演示][26]。
本文使用 [CC BY-SA 4.0][28] 许可，在 [Heartbeat][27] 上首发。
--------------------------------------------------------------------------------
via: https://opensource.com/article/18/10/machine-learning-python-essential-hacks-and-tricks
作者：[Tirthajyoti Sarkar][a]
选题：[lujun9972][b]
译者：[HankChow](https://github.com/HankChow)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/tirthajyoti
[b]: https://github.com/lujun9972
[1]: https://www.youtube.com/watch?v=tKa0zDDDaQk
[2]: https://www.youtube.com/watch?v=Ura_ioOcpQI
[3]: https://www.coursera.org/learn/machine-learning
[4]: https://www.coursera.org/specializations/machine-learning
[5]: https://towardsdatascience.com/how-to-choose-effective-moocs-for-machine-learning-and-data-science-8681700ed83f
[6]: https://medium.freecodecamp.org/which-languages-should-you-learn-for-data-science-e806ba55a81f
[7]: https://www.kdnuggets.com/2017/09/python-vs-r-data-science-machine-learning.html
[8]: http://numpy.org/
[9]: https://pandas.pydata.org/
[10]: http://scikit-learn.org/
[11]: https://www.tensorflow.org/
[12]: https://matplotlib.org/
[13]: https://realpython.com/python-matplotlib-guide/
[14]: https://seaborn.pydata.org/
[15]: https://www.datacamp.com/community/tutorials/seaborn-python-tutorial
[16]: https://en.wikipedia.org/wiki/Statistical_classification
[17]: https://en.wikipedia.org/wiki/Regression_analysis
[18]: https://en.wikipedia.org/wiki/Cluster_analysis
[19]: https://en.wikipedia.org/wiki/Support_vector_machine
[20]: https://en.wikipedia.org/wiki/Random_forests
[21]: https://en.wikipedia.org/wiki/Gradient_boosting
[22]: https://en.wikipedia.org/wiki/K-means_clustering
[23]: https://en.wikipedia.org/wiki/DBSCAN
[24]: https://en.wikipedia.org/wiki/SciPy
[25]: http://scikit-learn.org/stable/tutorial/basic/tutorial.html
[26]: https://towardsdatascience.com/machine-learning-with-python-easy-and-robust-method-to-fit-nonlinear-data-19e8a1ddbd49
[27]: https://heartbeat.fritz.ai/some-essential-hacks-and-tricks-for-machine-learning-with-python-5478bc6593f2
[28]: https://creativecommons.org/licenses/by-sa/4.0/
[29]: https://www.goodreads.com/book/show/24612233-the-master-algorithm
[30]: http://www.r2d3.us/visual-intro-to-machine-learning-part-1/
[31]: https://towardsdatascience.com/how-to-choose-effective-moocs-for-machine-learning-and-data-science-8681700ed83f
[32]: https://www.kdnuggets.com/
[33]: http://www.markmeloon.com/
[34]: https://brohrer.github.io/blog.html
[35]: https://blog.openai.com/