title
stringlengths 5
75
| author
stringlengths 0
48
| fromurl
stringlengths 0
185
| summary
stringlengths 4
460
| pic
stringlengths 32
70
| largepic
stringlengths 0
69
| titlepic
bool 2
classes | thumb
bool 2
classes | islctt
bool 2
classes | selector
stringclasses 14
values | translator
stringlengths 0
45
| reviewer
stringclasses 27
values | editorchoice
bool 2
classes | tags
list | category
stringclasses 20
values | count
dict | comments_data
list | related
list | excerpt
stringlengths 4
460
| date
timestamp[s] | updated
timestamp[s] | id
int64 1
16.6k
| permalink
stringlengths 17
21
| content
stringlengths 116
82.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
如何使用 CGI 脚本生成网页
|
David Both
|
https://opensource.com/article/17/12/cgi-scripts
|
通用网关接口（CGI）提供了使用任何语言生成动态网站的简易方法。
|
/data/attachment/album/201804/04/204833m9mtx6i2nxxd3tw0.jpg.thumb.jpg
|
/data/attachment/album/201804/04/204833m9mtx6i2nxxd3tw0.jpg
| true | false | true |
ucasFL
| false |
[
"CGI"
] |
软件开发
|
{
"viewnum": 6557,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通用网关接口（CGI）提供了使用任何语言生成动态网站的简易方法。
| 2018-04-04T20:48:46 | 2018-04-04T20:48:46 | 9,514 |
/article-9514-1.html
|
>
> 通用网关接口（CGI）提供了使用任何语言生成动态网站的简易方法。
>
>
>
回到互联网的开端，当我第一次创建了我的第一个商业网站，生活是如此的美好。
我安装 Apache 并写了一些简单的 HTML 网页，网页上列出了一些关于我的业务的重要信息，比如产品概览以及如何联系我。这是一个静态网站，因为内容很少改变。由于网站的内容很少发生改变这一性质，因此维护起来也很简单。
### 静态内容
静态内容很简单，同时也很常见。让我们快速的浏览一些静态网页的例子。你不需要一个可运行网站来执行这些小实验，只需要把这些文件放到家目录，然后使用浏览器打开。你所看到的内容将和通过 Web 服务器提供这一文件看到的内容一样。
对于一个静态网站，你需要的第一件东西就是 `index.html` 文件，该文件通常放置在 `/var/www/html` 目录下。这个文件的内容可以非常简单，比如可以是像 “Hello, world” 这样一句短文本，没有任何 HTML 标记。它将简单的展示文本串内容。在你的家目录创建 `index.html` 文件，并添加 “hello, world” 作为内容（不需要引号）。在浏览器中通过下面的链接来打开这一文件：
```
file:///home/<你的家目录>/index.html
```
所以 HTML 不是必须的，但是，如果你有大量需要格式化的文本，那么，不用 HTML 编码的网页的结果将会令人难以理解。
所以，下一步就是通过使用一些 HTML 编码来提供格式化，从而使内容更加可读。下面这一命令创建了一个具有 HTML 静态网页所需要的绝对最小标记的页面。你也可以使用你最喜欢的编辑器来创建这一内容。
```
echo "<h1>Hello World</h1>" > test1.html
```
现在，再次查看 `index.html` 文件，将会看到和刚才有些不同。
当然，你可以在实际的内容行上添加大量的 HTML 标记，以形成更加完整和标准的网页。下面展示的是更加完整的版本，尽管在浏览器中会看到同样的内容，但这也为更加标准化的网站奠定了基础。继续在 `index.html` 中写入这些内容并通过浏览器查看。
```
<!DOCTYPE HTML PUBLIC "-//w3c//DD HTML 4.0//EN">
<html>
<head>
<title>My Web Page</title>
</head>
<body>
<h1>Hello World</h1>
</body>
</html>
```
我使用这些技术搭建了一些静态网站，但我的生活正在改变。
### 动态网页
我找了一份新工作，这份工作的主要任务就是创建并维护用于一个动态网站的 CGI（<ruby> <a href="https://en.wikipedia.org/wiki/Common_Gateway_Interface"> 公共网关接口 </a> <rt> Common Gateway InterfaceM </rt></ruby>）代码。字面意思来看，动态意味着在浏览器中生成的网页所需要的 HTML 是由每次访问页面时不同的数据所生成的。这些数据包括网页表单中的用户输入，以用来在数据库中进行数据查找，结果数据被一些恰当的 HTML 包围着并展示在所请求的浏览器中。但是这不需要非常复杂。
通过使用 CGI 脚本，你可以创建一些简单或复杂的交互式程序，通过运行这些程序能够生成基于输入、计算、服务器的当前条件等改变的动态页面。有许多种语言可以用来写 CGI 脚本，在这篇文章中，我将谈到的是 Perl 和 Bash ，其他非常受欢迎的 CGI 语言包括 PHP 和 Python 。
这篇文章不会介绍 Apache 或其他任何 web 服务器的安装和配置。如果你能够访问一个你可以进行实验的 Web 服务器，那么你可以直接查看它们在浏览器中出现的结果。否则，你可以在命令行中运行程序来查看它们所创建的 HTML 文本。你也可以重定向 HTML 输出到一个文件中，然后通过浏览器查看结果文件。
### 使用 Perl
Perl 是一门非常受欢迎的 CGI 脚本语言，它的优势是强大的文本操作能力。
为了使 CGI 脚本可执行，你需要在你的网站的 `httpd.conf` 中添加下面这行内容。这会告诉服务器可执行 CGI 文件的位置。在这次实验中，不必担心这个问题。
```
ScriptAlias /cgi-bin/ "/var/www/cgi-bin/"
```
把下面的 Perl 代码添加到文件 `index.cgi`，在这次实验中，这个文件应该放在你的家目录下。如果你使用 Web 服务器，那么应把文件的所有者更改为 `apache.apache`，同时将文件权限设置为 755，因为无论位于哪，它必须是可执行的。
```
#!/usr/bin/perl
print "Content-type: text/html\n\n";
print "<html><body>\n";
print "<h1>Hello World</h1>\n";
print "Using Perl<p>\n";
print "</body></html>\n";
```
在命令行中运行这个程序并查看结果，它将会展示出它所生成的 HTML 内容
现在，在浏览器中查看 `index.cgi` 文件，你所看到的只是文件的内容。浏览器需要将它看做 CGI 内容，但是，Apache 不知道需要将这个文件作为 CGI 程序运行，除非 Apache 的配置中包括上面所展示的 `ScriptAlias` 定义。没有这一配置，Apache 只会简单地将文件中的数据发送给浏览器。如果你能够访问 Web 服务器，那么你可以将可执行文件放到 `/var/www/cgi-bin` 目录下。
如果想知道这个脚本的运行结果在浏览器中长什么样，那么，重新运行程序并把输出重定向到一个新文件，名字可以是任何你想要的。然后使用浏览器来查看这一文件，它包含了脚本所生成的内容。
上面这个 CGI 程序依旧生成静态内容，因为它总是生成相同的输出。把下面这行内容添加到 CGI 程序中 “Hello, world” 这一行后面。Perl 的 `system` 命令将会执行跟在它后面的 shell 命令，并把结果返回给程序。此时，我们将会通过 `free` 命令获得当前的内存使用量。
```
system "free | grep Mem\n";
```
现在，重新运行这个程序，并把结果重定向到一个文件，在浏览器中重新加载这个文件。你将会看到额外的一行，它展示了系统的内存统计数据。多次运行程序并刷新浏览器，你将会发现，内存使用量应该是不断变化的。
### 使用 Bash
Bash 可能是用于 CGI 脚本中最简单的语言。用 Bash 来进行 CGI 编程的最大优势是它能够直接访问所有的标准 GNU 工具和系统程序。
把已经存在的 `index.cgi` 文件重命名为 `Perl.index.cgi`，然后创建一个新的 `index.cgi 文件并添加下面这些内容。记得设置权限使它可执行。
```
#!/bin/bash
echo "Content-type: text/html"
echo ""
echo '<html>'
echo '<head>'
echo '<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">'
echo '<title>Hello World</title>'
echo '</head>'
echo '<body>'
echo '<h1>Hello World</h1><p>'
echo 'Using Bash<p>'
free | grep Mem
echo '</body>'
echo '</html>'
exit 0
```
在命令行中执行这个文件并查看输出，然后再次运行并把结果重定向到一个临时结果文件中。然后，刷新浏览器查看它所展示的网页是什么样子。
### 结论
创建能够生成许多种动态网页的 CGI 程序实际上非常简单。尽管这是一个很简单的例子，但是现在你应该看到一些可能性了。
---
via: <https://opensource.com/article/17/12/cgi-scripts>
作者：[David Both](https://opensource.com/users/dboth) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Oh My Fish! 让你的 Shell 漂亮起来
|
Sk
|
https://www.ostechnix.com/oh-fish-make-shell-beautiful/
|
如何使用 Oh My Fish (简称 omf ) ，让我们的 Fish shell 变得漂亮且优雅。
|
/data/attachment/album/201804/04/213630umlzt27nult9lmn3.jpg.thumb.jpg
|
/data/attachment/album/201804/04/213630umlzt27nult9lmn3.jpg
| true | false | true |
MjSeven
| false |
[
"Fish"
] |
桌面应用
|
{
"viewnum": 35656,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "27.47.129.159",
"message": "我的agnoster的箭头是蓝色的？？",
"username": "来自广东广州的 Firefox 72.0|Windows 10 用户",
"date": "2020-01-10T10:14:38"
}
] |
[] |
如何使用 Oh My Fish (简称 omf ) ，让我们的 Fish shell 变得漂亮且优雅。
| 2018-04-04T21:36:00 | 2018-04-04T21:36:00 | 9,515 |
/article-9515-1.html
|
几天前，我们讨论了如何[安装 Fish shell](https://www.ostechnix.com/install-fish-friendly-interactive-shell-linux/)，这是一个健壮的、完全可用的 shell，带有许多很酷的功能，如自动建议、内置搜索功能、语法高亮显示、基于 web 配置等等。今天，我们将讨论如何使用 Oh My Fish (简称 `omf` ) ，让我们的 Fish shell 变得漂亮且优雅。它是一个 Fishshell 框架，允许你安装扩展或更改你的 shell 外观的软件包。它简单易用，快速可扩展。使用 `omf`，你可以根据你的想法，很容易地安装主题，丰富你的外观和安装插件来调整你的 Fish shell。
### 安装 Oh My Fish
安装 omf 很简单。你要做的只是在你的 Fish shell 中运行下面的命令。
```
curl -L https://get.oh-my.fish | fish
```
一旦安装完成，你将看到提示符已经自动更改，如上图所所示。另外，你会注意到当前时间在 shell 窗口的右边。
就是这样。让我们继续并调整我们的 fish shell。
### 现在，让我们将 Fish Shell 变漂亮
列出所有的安装包，运行：
```
omf list
```
这条命令将显示已安装的主题和插件。请注意，包可以是主题或插件。安装包意味着安装主题和插件。
所有官方和社区支持的包（包括插件和主题）都托管在 [Omf 主仓库](https://github.com/oh-my-fish) 中。在这个主仓库中，你可以看到大量的仓库，其中包含大量的插件和主题。
现在让我们看一下可用的和已安装的主题列表。为此，运行：
```
omf theme
```
如你所见，我们只有一个已安装的主题，这是默认的，但是还有大量可用的主题。在安装之前，你在[这里](https://github.com/oh-my-fish/oh-my-fish/blob/master/docs/Themes.md)可以预览所有可用的主题。这个页面包含了所有的主题细节，特性，每个主题的截图示例，以及哪个主题适合谁。
#### 安装一个新主题
请允许我安装一个主题，例如 clearance 主题，这是一个极简的 fish shell 主题，供那些经常使用 `git` 的人使用。为此，运行：
```
omf install clearance
```
如上图所示，在安装新主题后，Fish shell 的提示立即发生了变化。
让我浏览一下系统文件，看看它如何显示。
看起来不错！这是一个非常简单的主题。它将当前工作目录，文件夹和文件以不同的颜色区分开来。你可能会注意到，它还会在提示符的顶部显示当前工作目录。现在，clearance 是我的默认主题。
#### 改变主题
就像我之前说的一样，这个主题在安装后被立即应用。如果你有多个主题，你可以使用以下命令切换到另一个不同的主题：
```
omf theme <theme-name>
```
例如：
```
omf theme agnoster
```
现在我正在使用 agnoster 主题。 agnoster 就是这样改变了我 shell 的外观。
#### 安装插件
例如，我想安装一个天气插件。为此，只要运行：
```
omf install weather
```
天气插件依赖于 [jq](https://stedolan.github.io/jq/)（LCTT 译注：jq 是一个轻量级且灵活的命令行JSON处理器）。所以，你可能也需要安装 `jq`。它通常在 Linux 发行版的默认仓库中存在。因此，你可以使用默认的包管理器来安装它。例如，以下命令将在 Arch Linux 及其衍生版中安装 `jq`。
```
sudo pacman -S jq
```
现在，在 Fish shell 中使用以下命令查看天气：
```
weather
```
#### 寻找包
要搜索主题或插件，请执行以下操作：
```
omf search <search_string>
```
例如：
```
omf search nvm
```
为了限制搜索的主题范围，使用 `-t` 选项。
```
omf search -t chain
```
这条命令只会搜索主题名字中包含 “chain” 的主题。
为了限制搜索的插件范围，使用 `-p` 选项。
```
omf search -p emacs
```
#### 更新包
要仅更新核心功能（`omf` 本身），运行：
```
omf update omf
```
如果是最新的，你会看到以下输出：
```
Oh My Fish is up to date.
You are now using Oh My Fish version 6.
Updating https://github.com/oh-my-fish/packages-main master... Done!
```
更新所有包：
```
omf update
```
要有选择地更新软件包，只需包含如下所示的包名称：
```
omf update clearance agnoster
```
#### 显示关于包的信息
当你想知道关于一个主题或插件的信息时，使用以下命令：
```
omf describe clearance
```
这条命令将显示关于包的信息。
```
Package: clearance
Description: A minimalist fish shell theme for people who use git
Repository: https://github.com/oh-my-fish/theme-clearance
Maintainer:
```
#### 移除包
移除一个包，例如 emacs，运行：
```
omf remove emacs
```
#### 管理仓库
默认情况下，当你安装了 Oh My Fish 时，会自动添加官方仓库。这个仓库包含了开发人员构建的所有包。要管理用户安装的仓库包，使用这条命令：
```
omf repositories [list|add|remove]
```
列出所有安装的仓库，运行：
```
omf repositories list
```
添加一个仓库：
```
omf repositories add <URL>
```
例如：
```
omf repositories add https://github.com/ostechnix/theme-sk
```
移除一个仓库：
```
omf repositories remove <repository-name>
```
#### Oh My Fish 排错
如果出现了错误，`omf` 足够聪明来帮助你，它可以列出解决问题的方法。例如，我安装了 clearance 包，得到了文件冲突的错误。幸运的是，在继续之前，Oh My Fish 会指示我该怎么做。因此，我只是简单地运行了以下代码来了解如何修正错误。
```
omf doctor
```
通过运行以下命令来解决错误：
```
rm ~/.config/fish/functions/fish_prompt.fish
```
无论你何时遇到问题，只要运行 `omf doctor` 命令，并尝试所有的建议方法。
#### 获取帮助
显示帮助部分，运行：
```
omf -h
```
或者
```
omf --help
```
#### 卸载 Oh My Fish
卸载 Oh My Fish，运行以下命令：
```
omf destroy
```
继续前进，开始自定义你的 fish shell。获取更多细节，请参考项目的 GitHub 页面。
这就是全部了。我很快将会在这里开始另一个有趣的指导。在此之前，请继续关注我们！
干杯！
---
via: <https://www.ostechnix.com/oh-fish-make-shell-beautiful/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何知道 CPU 是否支持虚拟化技术（VT）
|
Sk
|
https://www.ostechnix.com/how-to-find-if-a-cpu-supports-virtualization-technology-vt/
|
在安装虚拟化程序（如 VirtualBox 或 VMWare workstation）以在 Linux 系统上运行虚拟机之前，你应该首先验证这一点。
|
/data/attachment/album/201804/05/212925y5wryp5eq0gkrwge.png.thumb.jpg
|
/data/attachment/album/201804/05/212925y5wryp5eq0gkrwge.png
| true | false | true |
geekpi
| false |
[
"VT",
"虚拟化"
] |
技术
|
{
"viewnum": 22664,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在安装虚拟化程序（如 VirtualBox 或 VMWare workstation）以在 Linux 系统上运行虚拟机之前，你应该首先验证这一点。
| 2018-04-05T21:29:21 | 2018-04-05T21:29:21 | 9,516 |
/article-9516-1.html
|
我们已经知道如何[检查你的 Linux 操作系统是 32 位还是 64 位](https://www.ostechnix.com/check-linux-system-32-bit-64-bit/)以及如何[知道你的 Linux 系统是物理机还是虚拟机](https://www.ostechnix.com/check-linux-system-physical-virtual-machine/)。今天，我们将学习另一个有用的话题 - 如何知道 CPU 是否支持虚拟化技术 （VT）？在安装虚拟化程序（如 VirtualBox 或 VMWare workstation）以在 Linux 系统上运行虚拟机之前，你应该首先验证这一点。现在让我们来看看你的电脑是否支持 VT。相信我，这真的很简单！
### 了解 CPU 是否支持虚拟化技术 （VT）
我们可以通过几种方法检查 CPU 是否支持 VT。在这里我向你展示四种方法。
#### 方法 1：使用 egrep 命令
`egrep` 是 [grep](https://www.ostechnix.com/the-grep-command-tutorial-with-examples-for-beginners/) 命令的变体之一，用于使用正则表达式搜索文本文件。为了本指南的目的，我们将 grep `/cpu/procinfo/` 文件来确定 CPU 是否支持 VT。
要使用 `egrep` 命令查明你的CPU是否支持VT，请运行：
```
$ egrep "(svm|vmx)" /proc/cpuinfo
```
示例输出：
你将在输出中看到 `vmx`（Intel-VT 技术）或 `svm` （AMD-V 支持）。
```
flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx rdtscp lm constant_tsc arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc cpuid aperfmperf pni pclmulqdq dtes64 monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic popcnt tsc_deadline_timer xsave avx lahf_lm epb pti tpr_shadow vnmi flexpriority ept vpid xsaveopt dtherm arat pln pts
[...]
```
由于输出很长，你可能会发现很难在输出中找到 `vmx` 或 `svm`。别担心！你可以像下面那样用颜色来区分这些术语。
```
$ egrep --color -i "svm|vmx" /proc/cpuinfo
```
如果你没有看到任何输出，这意味着你的系统不支持虚拟化。
请注意，`cpuinfo` 中的这些 CPU 标志（`vmx` 或 `svm`）表示你的系统支持 VT。在某些 CPU 型号中，默认情况下，可能会在 BIOS 中禁用 VT 支持。在这种情况下，你应该检查 BIOS 设置以启用 VT 支持。
有关 `grep`/`egrep` 命令的更多详细信息，请参阅手册页。
```
$ man grep
```
#### 方法 2： 使用 lscpu 命令
`lscpu` 命令用于显示有关 CPU 架构的信息。它从 `sysfs`、`/proc/cpuinfo` 收集信息，并显示主机系统的 CPU、线程、内核、套接字和非统一内存访问 （NUMA） 节点的数量。
要确定是否启用 VT 支持，只需运行：
```
$ lscpu
```
有关更多详细信息，请查看手册页。
```
$ man lscpu
```
#### 方法 3：使用 cpu-checker 工具
cpu-checker 是另一个有用的工具，用于测试你的 CPU 是否支持虚拟化。就我在网上搜索得到的，该程序仅适用于基于 Ubuntu 的系统。要安装它，请运行：
```
$ sudo apt-get install cpu-checker
```
安装 cpu-checker 包之后，运行以下命令来检查是否启用 VT 支持：
```
$ sudo kvm-ok
```
如果您的 CPU 支持 VT，你将得到以下输出：
```
INFO: /dev/kvm exists
KVM acceleration can be used
```
如果你的 CPU 不支持 VT，你会看到如下的输出。
```
INFO: Your CPU does not support KVM extensions
KVM acceleration can NOT be used
```
#### 方法 4：使用 virt-host-validate 工具
该工具专门用于基于 RHEL 的发行版，如 CentOS 和 Scientific Linux。 libvirt-client 包提供 `virt-host-validate` 二进制文件。所以你需要安装 libvert-client 包来使用这个工具。
```
$ sudo yum install libvirt-client
```
现在，运行 `virt-host-validate` 命令来确定基于 RHEL 的系统中是否启用了 VT。
```
$ sudo virt-host-validate
```
如果所有的结果是 `pass`，那么你的系统支持 VT。
```
QEMU: Checking for hardware virtualization : PASS
QEMU: Checking if device /dev/vhost-net exists : PASS
QEMU: Checking if device /dev/net/tun exists : PASS
QEMU: Checking for cgroup 'memory' controller support : PASS
QEMU: Checking for cgroup 'memory' controller mount-point : PASS
QEMU: Checking for cgroup 'cpu' controller support : PASS
QEMU: Checking for cgroup 'cpu' controller mount-point : PASS
QEMU: Checking for cgroup 'cpuacct' controller support : PASS
QEMU: Checking for cgroup 'cpuacct' controller mount-point : PASS
QEMU: Checking for cgroup 'cpuset' controller support : PASS
QEMU: Checking for cgroup 'cpuset' controller mount-point : PASS
QEMU: Checking for cgroup 'devices' controller support : PASS
QEMU: Checking for cgroup 'devices' controller mount-point : PASS
QEMU: Checking for cgroup 'blkio' controller support : PASS
QEMU: Checking for cgroup 'blkio' controller mount-point : PASS
QEMU: Checking for device assignment IOMMU support : PASS
LXC: Checking for Linux >= 2.6.26 : PASS
LXC: Checking for namespace ipc : PASS
LXC: Checking for namespace mnt : PASS
LXC: Checking for namespace pid : PASS
LXC: Checking for namespace uts : PASS
LXC: Checking for namespace net : PASS
LXC: Checking for namespace user : PASS
LXC: Checking for cgroup 'memory' controller support : PASS
LXC: Checking for cgroup 'memory' controller mount-point : PASS
LXC: Checking for cgroup 'cpu' controller support : PASS
LXC: Checking for cgroup 'cpu' controller mount-point : PASS
LXC: Checking for cgroup 'cpuacct' controller support : PASS
LXC: Checking for cgroup 'cpuacct' controller mount-point : PASS
LXC: Checking for cgroup 'cpuset' controller support : PASS
LXC: Checking for cgroup 'cpuset' controller mount-point : PASS
LXC: Checking for cgroup 'devices' controller support : PASS
LXC: Checking for cgroup 'devices' controller mount-point : PASS
LXC: Checking for cgroup 'blkio' controller support : PASS
LXC: Checking for cgroup 'blkio' controller mount-point : PASS
```
如果你的系统不支持 VT，你会看到下面的输出。
```
QEMU: Checking for hardware virtualization : FAIL (Only emulated CPUs are available, performance will be significantly limited)
[...]
```
就是这样了。在本文中，我们讨论了确定 CPU 是否支持 VT 的不同方法。如你所见，这很简单。希望这个有用。还有更多好的东西。敬请关注！
干杯！
---
via: <https://www.ostechnix.com/how-to-find-if-a-cpu-supports-virtualization-technology-vt/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Git 中怎样克隆、修改、添加和删除文件？
|
Kedar Vijay Kulkarni
|
https://opensource.com/article/18/2/how-clone-modify-add-delete-git-files
|
在本文中，我们将学习一些关于 Git 的其他内容，即如何克隆（下载）、修改、添加和删除 Git 仓库中的文件。
|
/data/attachment/album/201804/05/221612b9tvoj69g1otctqp.jpg.thumb.jpg
|
/data/attachment/album/201804/05/221612b9tvoj69g1otctqp.jpg
| true | false | true |
MjSeven
| false |
[
"git"
] |
技术
|
{
"viewnum": 11855,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9319,
"displayorder": 0
},
{
"raid": 9724,
"displayorder": 0
}
] |
在本文中，我们将学习一些关于 Git 的其他内容，即如何克隆（下载）、修改、添加和删除 Git 仓库中的文件。
| 2018-04-05T22:16:16 | 2018-04-05T22:16:16 | 9,517 |
/article-9517-1.html
|
在 [本系列的第一篇文章](/article-9319-1.html) 开始使用 Git 时，我们创建了一个简单的 Git 仓库，并用我们的计算机连接到它，向其中添加一个文件。在本文中，我们将学习一些关于 Git 的其他内容，即如何克隆（下载）、修改、添加和删除 Git 仓库中的文件。
### 让我们来克隆一下
假设你在 GitHub 上已经有一个 Git 仓库，并且想从它那里获取你的文件——也许你在你的计算机上丢失了本地副本，或者你正在另一台计算机上工作，但是想访问仓库中的文件，你该怎么办？从 GitHub 下载你的文件？没错！在 Git 术语中我们称之为“<ruby> 克隆 <rt> clone </rt></ruby>”。（你也可以将仓库作为 ZIP 文件下载，但我们将在本文中探讨克隆方式。）
让我们克隆在上一篇文章中创建的名为 Demo 的仓库。（如果你还没有创建 Demo 仓库，请跳回到[那篇文章](/article-9319-1.html)并在继续之前执行那些步骤）要克隆文件，只需打开浏览器并导航到 `https://github.com/<your_username>/Demo` (其中 `<your_username>` 是你仓库的名称。例如，我的仓库是 `https://github.com/kedark3/Demo`)。一旦你导航到该 URL，点击“<ruby> 克隆或下载 <rt> Clone or download </rt></ruby>”按钮，你的浏览器看起来应该是这样的：
正如你在上面看到的，“<ruby> 使用 HTTPS 克隆 <rt> Clone with HTTPS </rt></ruby>”选项已打开。从该下拉框中复制你的仓库地址（`https://github.com/<your_username>/Demo.git`），打开终端并输入以下命令将 GitHub 仓库克隆到你的计算机：
```
git clone https://github.com/<your_username>/Demo.git
```
然后，要查看 `Demo` 目录中的文件列表，请输入以下命令：
```
ls Demo/
```
终端看起来应该是这样的：
### 修改文件
现在我们已经克隆了仓库，让我们修改文件并在 GitHub 上更新它们。首先，逐个输入下面的命令，将目录更改为 `Demo/`，检查 `README.md` 中的内容，添加新的（附加的）内容到 `README.md`，然后使用 `git status` 检查状态:
```
cd Demo/
ls
cat README.md
echo "Added another line to REAMD.md" >> README.md
cat README.md
git status
```
如果你逐一运行这些命令，终端看起开将会是这样：
让我们看一下 `git status` 的输出，并了解它的意思。不要担心这样的语句：
```
On branch master
Your branch is up-to-date with 'origin/master'.".
```
因为我们还没有学习这些。（LCTT 译注：学了你就知道了）下一行说：`Changes not staged for commit`（变化未筹划提交）；这是告诉你，它下面列出的文件没有被标记准备（“<ruby> 筹划 <rt> stage </rt></ruby>”）提交。如果你运行 `git add`，Git 会把这些文件标记为 `Ready for commit`（准备提交）；换句话说就是 `Changes staged for commit`（变化筹划提交）。在我们这样做之前，让我们用 `git diff` 命令来检查我们添加了什么到 Git 中，然后运行 `git add`。
这里是终端输出：
我们来分析一下：
* `diff --git a/README.md b/README.md` 是 Git 比较的内容（在这个例子中是 `README.md`）。
* `--- a/README.md` 会显示从文件中删除的任何东西。
* `+++ b/README.md` 会显示从文件中添加的任何东西。
* 任何添加到文件中的内容都以绿色文本打印，并在该行的开头加上 `+` 号。
* 如果我们删除了任何内容，它将以红色文本打印，并在该行的开头加上 `-` 号。
* 现在 `git status` 显示 `Changes to be committed:`（变化将被提交），并列出文件名（即 `README.md`）以及该文件发生了什么（即它已经被 `modified` 并准备提交）。
提示：如果你已经运行了 `git add`，现在你想看看文件有什么不同，通常 `git diff` 不会输出任何东西，因为你已经添加了文件。相反，你必须使用 `git diff --cached`。它会告诉你 Git 添加的当前版本和以前版本文件之间的差别。你的终端输出看起来会是这样：
### 上传文件到你的仓库
我们用一些新内容修改了 `README.md` 文件，现在是时候将它上传到 GitHub。
让我们提交更改并将其推送到 GitHub。运行：
```
git commit -m "Updated Readme file"
```
这告诉 Git 你正在“提交”已经“添加”的更改，你可能还记得，从本系列的第一部分中，添加一条消息来解释你在提交中所做的操作是非常重要的，以便你在稍后回顾 Git 日志时了解当时的目的。（我们将在下一篇文章中更多地关注这个话题。）`Updated Readme file` 是这个提交的消息——如果你认为这没有合理解释你所做的事情，那么请根据需要写下你的提交消息。
运行 `git push -u origin master`，这会提示你输入用户名和密码，然后将文件上传到你的 GitHub 仓库。刷新你的 GitHub 页面，你应该会看到刚刚对 `README.md` 所做的更改。
终端的右下角显示我提交了更改，检查了 Git 状态，并将更改推送到了 GitHub。`git status` 显示：
```
Your branch is ahead of 'origin/master' by 1 commit
(use "git push" to publish your local commits)
```
第一行表示在本地仓库中有一个提交，但不在 `origin/master` 中（即在 GitHub 上）。下一行指示我们将这些更改推送到 `origin/master` 中，这就是我们所做的。（在本例中，请参阅本系列的第一篇文章，以唤醒你对 `origin` 含义的记忆。我将在下一篇文章中讨论分支的时候，解释 `master` 的含义。）
### 添加新文件到 Git
现在我们修改了一个文件并在 GitHub 上更新了它，让我们创建一个新文件，将它添加到 Git，然后将其上传到 GitHub。 运行：
```
echo "This is a new file" >> file.txt
```
这将会创建一个名为 `file.txt` 的新文件。
如果使用 `cat` 查看它：
```
cat file.txt
```
你将看到文件的内容。现在继续运行：
```
git status
```
Git 报告说你的仓库中有一个未跟踪的文件（名为 `file.txt`）。这是 Git 告诉你说在你的计算机中的仓库目录下有一个新文件，然而你并没有告诉 Git，Git 也没有跟踪你所做的任何修改。
我们需要告诉 Git 跟踪这个文件，以便我们可以提交并上传文件到我们的仓库。以下是执行该操作的命令：
```
git add file.txt
git status
```
终端输出如下：
`git status` 告诉你有 `file.txt` 被修改，对于 Git 来说它是一个 `new file`，Git 在此之前并不知道。现在我们已经为 Git 添加了 `file.txt`，我们可以提交更改并将其推送到 `origin/master`。
Git 现在已经将这个新文件上传到 GitHub；如果刷新 GitHub 页面，则应该在 GitHub 上的仓库中看到新文件 `file.txt`。
通过这些步骤，你可以创建尽可能多的文件，将它们添加到 Git 中，然后提交并将它们推送到 GitHub。
### 从 Git 中删除文件
如果我们发现我们犯了一个错误，并且需要从我们的仓库中删除 `file.txt`，该怎么办？一种方法是使用以下命令从本地副本中删除文件：
```
rm file.txt
```
如果你现在做 `git status`，Git 就会说有一个文件 `not staged for commit`（未筹划提交），并且它已经从仓库的本地拷贝中删除了。如果我们现在运行：
```
git add file.txt
git status
```
我知道我们正在删除这个文件，但是我们仍然运行 `git add`，因为我们需要告诉 Git 我们正在做的**更改**，`git add` 可以用于我们添加新文件、修改一个已存在文件的内容、或者从仓库中删除文件时。实际上，`git add` 将所有更改考虑在内，并将这些筹划提交这些更改。如果有疑问，请仔细查看下面终端屏幕截图中每个命令的输出。
Git 会告诉我们已删除的文件正在进行提交。只要你提交此更改并将其推送到 GitHub，该文件也将从 GitHub 的仓库中删除。运行以下命令：
```
git commit -m "Delete file.txt"
git push -u origin master
```
现在你的终端看起来像这样：
你的 GitHub 看起来像这样：
现在你知道如何从你的仓库克隆、添加、修改和删除 Git 文件。本系列的下一篇文章将检查 Git 分支。
---
via: <https://opensource.com/article/18/2/how-clone-modify-add-delete-git-files>
作者：[Kedar Vijay Kulkarni](https://opensource.com/users/kkulkarn) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何记录 Linux 的系统运行时间的统计信息
|
Vivek Gite
|
https://www.cyberciti.biz/hardware/see-records-statistics-about-a-linux-servers-uptime/
|
Linux/Unix 系统管理员对服务器的系统运行时间有一种奇怪的痴迷。
|
/data/attachment/album/201804/05/225745wnm0m8gxamhtdglz.jpg.thumb.jpg
|
/data/attachment/album/201804/05/225745wnm0m8gxamhtdglz.jpg
| true | false | true |
MjSeven
| false |
[
"uptime",
"运行时间"
] |
技术
|
{
"viewnum": 6529,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux/Unix 系统管理员对服务器的系统运行时间有一种奇怪的痴迷。
| 2018-04-05T22:57:56 | 2018-04-05T22:57:56 | 9,518 |
/article-9518-1.html
|
Linux/Unix 系统管理员对服务器的系统运行时间有一种奇怪的痴迷。这里有一个关于这个主题的 xkcd 漫画，一个好的系统管理员是一股不可阻挡的力量，他伫立在你家猫咪博客的服务器之前，对抗黑暗势力。
[](https://www.cyberciti.biz/media/new/cms/2017/11/devotion_to_duty.png)
我们可以使用 `uptime` 命令或 [w 命令](https://www.cyberciti.biz//www.cyberciti.biz/faq/unix-linux-w-command-examples-syntax-usage-2/ "See Linux/Unix w command examples for more info") 或 `top` 命令来判断 Linux 系统运行了多久。我可以使用 `tuptime` 工具保留每次重新启动的运行时间，以[获得系统运行时间的历史和统计报告](https://www.cyberciti.biz/hardware/howto-see-historical-statistical-uptime-on-linux-server/)。
这就像 `uptime` 命令一样，但输出结果更令人印象深刻。最近我发现了另一种称为 `uptimed` 的工具，用于记录关于机器的系统运行时间和统计信息。让我们看看如何使用 Linux 操作系统上的 `uptimed` 和 `uprecords` 来获得运行时间的记录统计信息。
查找系统运行时间非常简单，只需在基于 Linux 的系统上键入以下命令即可：
```
$ uptime -p
up 2 weeks, 4 days, 7 hours, 28 minutes
```
要保留有关 `uptime` 的历史统计信息，请使用 [tuptime](https://www.cyberciti.biz/hardware/howto-see-historical-statistical-uptime-on-linux-server/) 或 `uptimed` 工具。
### 安装 uptimed
安装 `uptimed` 的最简单的方式是通过你的软件包管理器，比如 apt/apt-get/yum 这些你的 Linux 发行版的朋友。
#### 在 Debian/Ubuntu Linux 上安装 uptimed
键入以下 [apt 命令](https://www.cyberciti.biz//www.cyberciti.biz/faq/ubuntu-lts-debian-linux-apt-command-examples/ "See Linux/Unix apt command examples for more info")/[apt-get 命令](https://www.cyberciti.biz//www.cyberciti.biz/tips/linux-debian-package-management-cheat-sheet.html "See Linux/Unix apt-get command examples for more info")：
```
$ sudo apt-get install uptimed
```
示例输出：
```
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following additional packages will be installed:
libuptimed0
The following NEW packages will be installed:
libuptimed0 uptimed
0 upgraded, 2 newly installed, 0 to remove and 3 not upgraded.
Need to get 40.7 kB of archives.
After this operation, 228 kB of additional disk space will be used.
Do you want to continue? [Y/n] y
Get:1 http://mirrors.linode.com/ubuntu xenial/universe amd64 libuptimed0 amd64 1:0.3.17-4 [9,050 B]
Get:2 http://mirrors.linode.com/ubuntu xenial/universe amd64 uptimed amd64 1:0.3.17-4 [31.6 kB]
Fetched 40.7 kB in 0s (2,738 kB/s)
Preconfiguring packages ...
Selecting previously unselected package libuptimed0.
(Reading database ... 39163 files and directories currently installed.)
Preparing to unpack .../libuptimed0_1%3a0.3.17-4_amd64.deb ...
Unpacking libuptimed0 (1:0.3.17-4) ...
Selecting previously unselected package uptimed.
Preparing to unpack .../uptimed_1%3a0.3.17-4_amd64.deb ...
Unpacking uptimed (1:0.3.17-4) ...
Processing triggers for systemd (229-4ubuntu21) ...
Processing triggers for ureadahead (0.100.0-19) ...
Processing triggers for man-db (2.7.5-1) ...
Setting up libuptimed0 (1:0.3.17-4) ...
Setting up uptimed (1:0.3.17-4) ...
Processing triggers for libc-bin (2.23-0ubuntu9) ...
Processing triggers for systemd (229-4ubuntu21) ...
Processing triggers for ureadahead (0.100.0-19) ...
```
#### 在 CentOS/RHEL/Fedora/Oracle/Scientific Linux 上安装 uptimed
首先 [在 CentOS/RHEL 使用 EPEL 仓库](https://www.cyberciti.biz/faq/installing-rhel-epel-repo-on-centos-redhat-7-x/)：
```
$ sudo yum -y install epel-release
```
然后，键入以下 [yum 命令](https://www.cyberciti.biz//www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/ "See Linux/Unix yum command examples for more info")：
```
$ sudo yum install uptimed
```
示例输出：
```
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
* base: centos.excellmedia.net
* epel: ftp.cuhk.edu.hk
* extras: centos.excellmedia.net
* updates: centos.excellmedia.net
Resolving Dependencies
--> Running transaction check
---> Package uptimed.x86_64 0:0.4.0-6.el7 will be installed
--> Finished Dependency Resolution
Dependencies Resolved
===============================================================================
Package Arch Version Repository Size
===============================================================================
Installing:
uptimed x86_64 0.4.0-6.el7 epel 47 k
Transaction Summary
===============================================================================
Install 1 Package
Total download size: 47 k
Installed size: 98 k
Is this ok [y/d/N]: y
Downloading packages:
uptimed-0.4.0-6.el7.x86_64.rpm | 47 kB 00:01
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
Installing : uptimed-0.4.0-6.el7.x86_64 1/1
Verifying : uptimed-0.4.0-6.el7.x86_64 1/1
Installed:
uptimed.x86_64 0:0.4.0-6.el7
Complete!
```
如果你正在使用 Fedora Linux，运行以下 `dnf` 命令：
```
$ sudo dnf install uptimed
```
#### 在 Arch Linux 上安装 uptimed
键入以下 `pacman` 命令：
```
$ sudo pacman -S uptimed
```
#### 在 Gentoo Linux 上安装 uptimed
键入以下 `emerge` 命令：
```
$ sudo emerge --ask uptimed
```
### 如何配置 uptimed
使用文本编辑器编辑 `/etc/uptimed.conf` 文件，例如 `vim` 命令：
```
$ sudo vim /etc/uptimed.conf
```
最少设置一个 email 地址来发送记录。假定有个兼容 sendmail 的 MTA 安装在 `/usr/lib/sendmail`。
```
EMAIL=vivek@server1.cyberciti.biz
```
保存并关闭文件。
### 如何在系统启动时启动 uptimed 服务？
使用 `systemctl` 命令启动 `uptimed` 服务：
```
$ sudo systemctl enable uptimed
```
### 我该如何 启动/停止/重启 或者查看 uptimed 服务的状态？
```
$ sudo systemctl start uptimed ## start it ##
$ sudo systemctl stop uptimed ## stop it ##
$ sudo systemctl restart uptimed ## restart it ##
$ sudo systemctl status uptimed ## view status ##
```
示例输出：
```
● uptimed.service - uptime record daemon
Loaded: loaded (/lib/systemd/system/uptimed.service; enabled; vendor preset: enabled)
Active: active (running) since Thu 2017-11-09 17:49:14 UTC; 18min ago
Main PID: 11137 (uptimed)
CGroup: /system.slice/uptimed.service
└─11137 /usr/sbin/uptimed -f
Nov 09 17:49:14 gfs04 systemd[1]: Started uptime record daemon.
```
### 如何查看 uptime 记录
只需键入以下命令即可查看 `uptimed(8)` 程序的统计信息：
```
$ uprecords
```
示例输出：
[](https://www.cyberciti.biz/media/new/cms/2017/11/uprecord-screenshot.jpg)
`uprecords` 有一些选项：
```
$ uprecords -?
```
示例输出：
```
usage: uprecords [OPTION]...
-? this help
-a do not print ansi codes
-b sort by boottime
-B reverse sort by boottime
-k sort by sysinfo
-K reverse sort by sysinfo
-d print downtime seen before every uptimes instead of system
-c do not show current entry if not in top entries
-f run continously in a loop
-s do not print extra statistics
-w wide output (more than 80 cols per line)
-i INTERVAL use INTERVAL seconds for loop instead of 5, implies -f
-m COUNT show a maximum of top COUNT entries instead of 10
-M show next milestone
-v version information
```
### 结论
这是一个极好的小工具，可以显示服务器正常运行时间的记录，以证明机器正常运行时间和你的业务连续性。在相关说明中，你可以看到官方的 [XKCD 系统管理员 T恤](https://store.xkcd.com/collections/apparel/products/sysadmin) 因为漫画被制作成衬衫，其中包括背面的新插图。
[](https://www.cyberciti.biz/media/new/cms/2017/11/sysadmin_shirt_5_1024x1024.jpg)
---
via: <https://www.cyberciti.biz/hardware/see-records-statistics-about-a-linux-servers-uptime/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
给初学者的 type 命令教程
|
Sk
|
https://www.ostechnix.com/the-type-command-tutorial-with-examples-for-beginners/
|
你可以使用 type 命令轻松找出给定的命令是否是别名、shell 内置命令、文件、函数或关键字。另外，你也可以找到命令的实际路径。
|
/data/attachment/album/201804/06/201902q8dlio8et8d5q0zg.png.thumb.jpg
|
/data/attachment/album/201804/06/201902q8dlio8et8d5q0zg.png
| true | false | true |
geekpi
| false |
[
"type",
"命令"
] |
技术
|
{
"viewnum": 8142,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你可以使用 type 命令轻松找出给定的命令是否是别名、shell 内置命令、文件、函数或关键字。另外，你也可以找到命令的实际路径。
| 2018-04-06T20:18:59 | 2018-04-06T20:18:59 | 9,519 |
/article-9519-1.html
|
`type` 命令用于查找 Linux 命令的信息。顾名思义，你可以使用 `type` 命令轻松找出给定的命令是否是别名、shell 内置命令、文件、函数或关键字。另外，你也可以找到命令的实际路径。为什么有人需要找到命令类型？例如，如果你经常在共享的计算机上工作，则某些人可能会故意或意外地为特定的 Linux 命令创建别名来执行不需要的操作，例如 `alias ls = rm -rf /`。因此，在发生更糟糕的事情之前检查它们总是一个好主意。这是 `type` 命令有用的地方。
让我给你看一些例子。
不带任何选项运行 `type` 命令。
```
$ type ls
ls is aliased to `ls --color=auto'
```
正如你在上面的输出中看到的那样，`ls` 命令已被别名为 `ls -color-auto`。但是，它是无害的。但只要想想 `ls` 如果被别名为了其他一些危险的命令。你不想那样，是吗？
你可以使用 `-t` 选项仅找出 Linux 命令的类型。例如：
```
$ type -t ls
alias
$ type -t mkdir
file
$ type -t pwd
builtin
$ type -t if
keyword
$ type -t rvm
function
```
该命令仅显示命令的类型，例如别名。它不显示被别名的内容。如果该命令找不到，你将在终端中看不到任何内容。
`type` 命令的另一个有用的地方是我们可以很容易地找出给定 Linux 命令的绝对路径。为此，请使用 `-p` 选项，如下所示。
```
$ type -p cal
/usr/bin/cal
```
这与 `which ls` 命令类似。如果给定的命令是别名，则不会打印任何内容。
要显示命令的所有信息，请使用 `-a` 选项。
```
$ type -a ls
ls is aliased to `ls --color=auto'
ls is /usr/bin/ls
ls is /bin/ls
```
如你所见，`-a` 标志显示给定命令的类型及其绝对路径。有关更多详细信息，请参阅手册页。
```
$ man type
```
希望这有帮助。会有更多的好东西。请继续访问！
干杯!
---
via: <https://www.ostechnix.com/the-type-command-tutorial-with-examples-for-beginners/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
让我们做个简单的解释器（二）
|
Ruslan Spivak
|
https://ruslanspivak.com/lsbasi-part2/
|
让我们再次深入了解解释器和编译器。
|
/data/attachment/album/201804/07/103057jm2ojoccjg3jj3ey.jpg.thumb.jpg
|
/data/attachment/album/201804/07/103057jm2ojoccjg3jj3ey.jpg
| true | false | true |
BriFuture
| false |
[
"解释器",
"编译器"
] |
软件开发
|
{
"viewnum": 5205,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9399,
"displayorder": 0
}
] |
让我们再次深入了解解释器和编译器。
| 2018-04-07T10:31:05 | 2018-04-07T10:31:05 | 9,520 |
/article-9520-1.html
|
在一本叫做 《高效思考的 5 要素》 的书中，作者 Burger 和 Starbird 讲述了一个关于他们如何研究 Tony Plog 的故事，他是一位举世闻名的交响曲名家，为一些有才华的演奏者开创了一个大师班。这些学生一开始演奏复杂的乐曲，他们演奏的非常好。然后他们被要求演奏非常基础简单的乐曲。当他们演奏这些乐曲时，与之前所演奏的相比，听起来非常幼稚。在他们结束演奏后，老师也演奏了同样的乐曲，但是听上去非常娴熟。差别令人震惊。Tony 解释道，精通简单音符可以让人更好的掌握复杂的部分。这个例子很清晰 —— 要成为真正的名家，必须要掌握简单基础的思想。
故事中的例子明显不仅仅适用于音乐，而且适用于软件开发。这个故事告诉我们不要忽视繁琐工作中简单基础的概念的重要性，哪怕有时候这让人感觉是一种倒退。尽管熟练掌握一门工具或者框架非常重要，了解它们背后的原理也是极其重要的。正如 Palph Waldo Emerson 所说：
>
> “如果你只学习方法，你就会被方法束缚。但如果你知道原理，就可以发明自己的方法。”
>
>
>
有鉴于此，让我们再次深入了解解释器和编译器。
今天我会向你们展示一个全新的计算器，与 [第一部分](/article-9399-1.html) 相比，它可以做到：
1. 处理输入字符串任意位置的空白符
2. 识别输入字符串中的多位整数
3. 做两个整数之间的减法（目前它仅能加减整数）
新版本计算器的源代码在这里，它可以做到上述的所有事情：
```
# 标记类型
# EOF （end-of-file 文件末尾）标记是用来表示所有输入都解析完成
INTEGER, PLUS, MINUS, EOF = 'INTEGER', 'PLUS', 'MINUS', 'EOF'
class Token(object):
def __init__(self, type, value):
# token 类型: INTEGER, PLUS, MINUS, or EOF
self.type = type
# token 值: 非负整数值, '+', '-', 或无
self.value = value
def __str__(self):
"""String representation of the class instance.
Examples:
Token(INTEGER, 3)
Token(PLUS '+')
"""
return 'Token({type}, {value})'.format(
type=self.type,
value=repr(self.value)
)
def __repr__(self):
return self.__str__()
class Interpreter(object):
def __init__(self, text):
# 客户端字符输入， 例如. "3 + 5", "12 - 5",
self.text = text
# self.pos 是 self.text 的索引
self.pos = 0
# 当前标记实例
self.current_token = None
self.current_char = self.text[self.pos]
def error(self):
raise Exception('Error parsing input')
def advance(self):
"""Advance the 'pos' pointer and set the 'current_char' variable."""
self.pos += 1
if self.pos > len(self.text) - 1:
self.current_char = None # Indicates end of input
else:
self.current_char = self.text[self.pos]
def skip_whitespace(self):
while self.current_char is not None and self.current_char.isspace():
self.advance()
def integer(self):
"""Return a (multidigit) integer consumed from the input."""
result = ''
while self.current_char is not None and self.current_char.isdigit():
result += self.current_char
self.advance()
return int(result)
def get_next_token(self):
"""Lexical analyzer (also known as scanner or tokenizer)
This method is responsible for breaking a sentence
apart into tokens.
"""
while self.current_char is not None:
if self.current_char.isspace():
self.skip_whitespace()
continue
if self.current_char.isdigit():
return Token(INTEGER, self.integer())
if self.current_char == '+':
self.advance()
return Token(PLUS, '+')
if self.current_char == '-':
self.advance()
return Token(MINUS, '-')
self.error()
return Token(EOF, None)
def eat(self, token_type):
# 将当前的标记类型与传入的标记类型作比较，如果他们相匹配，就
# “eat” 掉当前的标记并将下一个标记赋给 self.current_token，
# 否则抛出一个异常
if self.current_token.type == token_type:
self.current_token = self.get_next_token()
else:
self.error()
def expr(self):
"""Parser / Interpreter
expr -> INTEGER PLUS INTEGER
expr -> INTEGER MINUS INTEGER
"""
# 将输入中的第一个标记设置成当前标记
self.current_token = self.get_next_token()
# 当前标记应该是一个整数
left = self.current_token
self.eat(INTEGER)
# 当前标记应该是 ‘+’ 或 ‘-’
op = self.current_token
if op.type == PLUS:
self.eat(PLUS)
else:
self.eat(MINUS)
# 当前标记应该是一个整数
right = self.current_token
self.eat(INTEGER)
# 在上述函数调用后，self.current_token 就被设为 EOF 标记
# 这时要么是成功地找到 INTEGER PLUS INTEGER，要么是 INTEGER MINUS INTEGER
# 序列的标记，并且这个方法可以仅仅返回两个整数的加或减的结果，就能高效解释客户端的输入
if op.type == PLUS:
result = left.value + right.value
else:
result = left.value - right.value
return result
def main():
while True:
try:
# To run under Python3 replace 'raw_input' call
# with 'input'
text = raw_input('calc> ')
except EOFError:
break
if not text:
continue
interpreter = Interpreter(text)
result = interpreter.expr()
print(result)
if __name__ == '__main__':
main()
```
把上面的代码保存到 `calc2.py` 文件中，或者直接从 [GitHub](https://github.com/rspivak/lsbasi/blob/master/part2/calc2.py) 上下载。试着运行它。看看它是不是正常工作：它应该能够处理输入中任意位置的空白符；能够接受多位的整数，并且能够对两个整数做减法和加法。
这是我在自己的笔记本上运行的示例：
```
$ python calc2.py
calc> 27 + 3
30
calc> 27 - 7
20
calc>
```
与 [第一部分](/article-9399-1.html) 的版本相比，主要的代码改动有：
1. `get_next_token` 方法重写了很多。增加指针位置的逻辑之前是放在一个单独的方法中。
2. 增加了一些方法：`skip_whitespace` 用于忽略空白字符，`integer` 用于处理输入字符的多位整数。
3. `expr` 方法修改成了可以识别 “整数 -> 减号 -> 整数” 词组和 “整数 -> 加号 -> 整数” 词组。在成功识别相应的词组后，这个方法现在可以解释加法和减法。
[第一部分](/article-9399-1.html) 中你学到了两个重要的概念，叫做 <ruby> 标记 <rt> token </rt></ruby> 和<ruby> 词法分析 <rt> lexical analyzer </rt></ruby>。现在我想谈一谈<ruby> 词法 <rt> lexeme </rt></ruby>、 <ruby> 解析 <rt> parsing </rt></ruby> 和<ruby> 解析器 <rt> parser </rt></ruby>。
你已经知道了标记。但是为了让我详细的讨论标记，我需要谈一谈词法。词法是什么？<ruby> 词法 <rt> lexeme </rt></ruby>是一个<ruby> 标记 <rt> token </rt></ruby>中的字符序列。在下图中你可以看到一些关于标记的例子，这可以让它们之间的关系变得清晰：
现在还记得我们的朋友，`expr` 方法吗？我之前说过，这是数学表达式实际被解释的地方。但是你要先识别这个表达式有哪些词组才能解释它，比如它是加法还是减法。`expr` 方法最重要的工作是：它从 `get_next_token` 方法中得到流，并找出该标记流的结构，然后解释已经识别出的词组，产生数学表达式的结果。
在标记流中找出结构的过程，或者换种说法，识别标记流中的词组的过程就叫<ruby> 解析 <rt> parsing </rt></ruby>。解释器或者编译器中执行这个任务的部分就叫做<ruby> 解析器 <rt> parser </rt></ruby>。
现在你知道 `expr` 方法就是你的解释器的部分，<ruby> 解析 <rt> parsing </rt></ruby>和<ruby> 解释 <rt> interpreting </rt></ruby>都在这里发生 —— `expr` 方法首先尝试识别（解析）标记流里的 “整数 -> 加法 -> 整数” 或者 “整数 -> 减法 -> 整数” 词组，成功识别后 （解析了） 其中一个词组，这个方法就开始解释它，返回两个整数的和或差。
又到了练习的时间。
1. 扩展这个计算器，让它能够计算两个整数的乘法
2. 扩展这个计算器，让它能够计算两个整数的除法
3. 修改代码，让它能够解释包含了任意数量的加法和减法的表达式，比如 “9 - 5 + 3 + 11”
**检验你的理解：**
1. 词法是什么？
2. 找出标记流结构的过程叫什么，或者换种说法，识别标记流中一个词组的过程叫什么？
3. 解释器（编译器）执行解析的部分叫什么？
希望你喜欢今天的内容。在该系列的下一篇文章里你就能扩展计算器从而处理更多复杂的算术表达式。敬请期待。
---
via: <https://ruslanspivak.com/lsbasi-part2/>
作者：[Ruslan Spivak](https://ruslanspivak.com) 译者：[BriFuture](https://github.com/BriFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
让我们做个简单的解释器（三）
|
Ruslan Spivak
|
https://ruslanspivak.com/lsbasi-part3/
|
识别出记号流中的词组的过程就叫做 解析。解释器或者编译器执行这个任务的部分叫做 解析器。解析也称为 语法分析，并且解析器这个名字很合适，你猜的对，就是 语法分析器。
|
/data/attachment/album/201804/07/110210ybh46d5kvrbmd565.jpg.thumb.jpg
|
/data/attachment/album/201804/07/110210ybh46d5kvrbmd565.jpg
| true | false | true |
BriFuture
| false |
[
"解释器",
"编译器"
] |
软件开发
|
{
"viewnum": 4607,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
识别出记号流中的词组的过程就叫做 解析。解释器或者编译器执行这个任务的部分叫做 解析器。解析也称为 语法分析，并且解析器这个名字很合适，你猜的对，就是 语法分析器。
| 2018-04-09T09:01:00 | 2018-04-09T09:01:00 | 9,521 |
/article-9521-1.html
|
早上醒来的时候，我就在想：“为什么我们学习一个新技能这么难？”
我不认为那是因为它很难。我认为原因可能在于我们花了太多的时间，而这件难事需要有丰富的阅历和足够的知识，然而我们要把这样的知识转换成技能所用的练习时间又不够。
拿游泳来说，你可以花上几天时间来阅读很多有关游泳的书籍，花几个小时和资深的游泳者和教练交流，观看所有可以获得的训练视频，但你第一次跳进水池的时候，仍然会像一个石头那样沉入水中，
要点在于：你认为自己有多了解那件事都无关紧要 —— 你得通过练习把知识变成技能。为了帮你练习，我把训练放在了这个系列的 [第一部分](/article-9399-1.html) 和 [第二部分](/article-9520-1.html) 了。当然，你会在今后的文章中看到更多练习，我保证 ：)
好，让我们开始今天的学习。
到现在为止，你已经知道了怎样解释像 “7 + 3” 或者 “12 - 9” 这样的两个整数相加减的算术表达式。今天我要说的是怎么解析（识别）、解释有多个数字相加减的算术表达式，比如 “7 - 3 + 2 - 1”。
文中的这个算术表达式可以用下面的这个语法图表示：
什么是<ruby> 语法图 <rt> syntax diagram </rt></ruby>？ **语法图** 是对一门编程语言中的语法规则进行图像化的表示。基本上，一个语法图就能告诉你哪些语句可以在程序中出现，哪些不能出现。
语法图很容易读懂：按照箭头指向的路径。某些路径表示的是判断，有些表示的是循环。
你可以按照以下的方式读上面的语法图：一个 term 后面可以是加号或者减号，接着可以是另一个 term，这个 term 后面又可以是一个加号或者减号，后面又是一个 term，如此循环。从字面上你就能读懂这个图片了。或许你会奇怪，“term” 是什么、对于本文来说，“term” 就是个整数。
语法图有两个主要的作用：
* 它们用图形的方式表示一个编程语言的特性（语法）。
* 它们可以用来帮你写出解析器 —— 你可以根据下列简单规则把图片转换成代码。
你已经知道，识别出记号流中的词组的过程就叫做 **解析**。解释器或者编译器执行这个任务的部分叫做 **解析器**。解析也称为 **语法分析**，并且解析器这个名字很合适，你猜的对，就是 **语法分析器**。
根据上面的语法图，下面这些表达式都是合法的：
* 3
* 3 + 4
* 7 - 3 + 2 - 1
因为算术表达式的语法规则在不同的编程语言里面是很相近的，我们可以用 Python shell 来“测试”语法图。打开 Python shell，运行下面的代码：
```
>>> 3
3
>>> 3 + 4
7
>>> 7 - 3 + 2 - 1
5
```
意料之中。
表达式 “3 + ” 不是一个有效的数学表达式，根据语法图，加号后面必须要有个 term （整数），否则就是语法错误。然后，自己在 Python shell 里面运行：
```
>>> 3 +
File "<stdin>", line 1
3 +
^
SyntaxError: invalid syntax
```
能用 Python shell 来做这样的测试非常棒，让我们把上面的语法图转换成代码，用我们自己的解释器来测试，怎么样？
从之前的文章里（[第一部分](/article-9399-1.html) 和 [第二部分](/article-9520-1.html)）你知道 `expr` 方法包含了我们的解析器和解释器。再说一遍，解析器仅仅识别出结构，确保它与某些特性对应，而解释器实际上是在解析器成功识别（解析）特性之后，就立即对表达式进行评估。
以下代码片段显示了对应于图表的解析器代码。语法图里面的矩形方框（term）变成了 term 方法，用于解析整数，expr 方法和语法图的流程一致：
```
def term(self):
self.eat(INTEGER)
def expr(self):
# 把当前标记设为从输入中拿到的第一个标记
self.current_token = self.get_next_token()
self.term()
while self.current_token.type in (PLUS, MINUS):
token = self.current_token
if token.type == PLUS:
self.eat(PLUS)
self.term()
elif token.type == MINUS:
self.eat(MINUS)
self.term()
```
你能看到 `expr` 首先调用了 `term` 方法。然后 `expr` 方法里面的 `while` 循环可以执行 0 或多次。在循环里面解析器基于标记做出判断（是加号还是减号）。花一些时间，你就知道，上述代码确实是遵循着语法图的算术表达式流程。
解析器并不解释任何东西：如果它识别出了一个表达式，它就静默着，如果没有识别出来，就会抛出一个语法错误。改一下 `expr` 方法，加入解释器的代码：
```
def term(self):
"""Return an INTEGER token value"""
token = self.current_token
self.eat(INTEGER)
return token.value
def expr(self):
"""Parser / Interpreter """
# 将输入中的第一个标记设置成当前标记
self.current_token = self.get_next_token()
result = self.term()
while self.current_token.type in (PLUS, MINUS):
token = self.current_token
if token.type == PLUS:
self.eat(PLUS)
result = result + self.term()
elif token.type == MINUS:
self.eat(MINUS)
result = result - self.term()
return result
```
因为解释器需要评估一个表达式， `term` 方法被改成返回一个整型值，`expr` 方法被改成在合适的地方执行加法或减法操作，并返回解释的结果。尽管代码很直白，我建议花点时间去理解它。
进行下一步，看看完整的解释器代码，好不？
这是新版计算器的源代码，它可以处理包含有任意多个加法和减法运算的有效的数学表达式。
```
# 标记类型
#
# EOF （end-of-file 文件末尾）标记是用来表示所有输入都解析完成
INTEGER, PLUS, MINUS, EOF = 'INTEGER', 'PLUS', 'MINUS', 'EOF'
class Token(object):
def __init__(self, type, value):
# token 类型: INTEGER, PLUS, MINUS, or EOF
self.type = type
# token 值: 非负整数值, '+', '-', 或无
self.value = value
def __str__(self):
"""String representation of the class instance.
Examples:
Token(INTEGER, 3)
Token(PLUS, '+')
"""
return 'Token({type}, {value})'.format(
type=self.type,
value=repr(self.value)
)
def __repr__(self):
return self.__str__()
class Interpreter(object):
def __init__(self, text):
# 客户端字符输入， 例如. "3 + 5", "12 - 5",
self.text = text
# self.pos is an index into self.text
self.pos = 0
# 当前标记实例
self.current_token = None
self.current_char = self.text[self.pos]
##########################################################
# Lexer code #
##########################################################
def error(self):
raise Exception('Invalid syntax')
def advance(self):
"""Advance the `pos` pointer and set the `current_char` variable."""
self.pos += 1
if self.pos > len(self.text) - 1:
self.current_char = None # Indicates end of input
else:
self.current_char = self.text[self.pos]
def skip_whitespace(self):
while self.current_char is not None and self.current_char.isspace():
self.advance()
def integer(self):
"""Return a (multidigit) integer consumed from the input."""
result = ''
while self.current_char is not None and self.current_char.isdigit():
result += self.current_char
self.advance()
return int(result)
def get_next_token(self):
"""Lexical analyzer (also known as scanner or tokenizer)
This method is responsible for breaking a sentence
apart into tokens. One token at a time.
"""
while self.current_char is not None:
if self.current_char.isspace():
self.skip_whitespace()
continue
if self.current_char.isdigit():
return Token(INTEGER, self.integer())
if self.current_char == '+':
self.advance()
return Token(PLUS, '+')
if self.current_char == '-':
self.advance()
return Token(MINUS, '-')
self.error()
return Token(EOF, None)
##########################################################
# Parser / Interpreter code #
##########################################################
def eat(self, token_type):
# 将当前的标记类型与传入的标记类型作比较，如果他们相匹配，就
# “eat” 掉当前的标记并将下一个标记赋给 self.current_token，
# 否则抛出一个异常
if self.current_token.type == token_type:
self.current_token = self.get_next_token()
else:
self.error()
def term(self):
"""Return an INTEGER token value."""
token = self.current_token
self.eat(INTEGER)
return token.value
def expr(self):
"""Arithmetic expression parser / interpreter."""
# 将输入中的第一个标记设置成当前标记
self.current_token = self.get_next_token()
result = self.term()
while self.current_token.type in (PLUS, MINUS):
token = self.current_token
if token.type == PLUS:
self.eat(PLUS)
result = result + self.term()
elif token.type == MINUS:
self.eat(MINUS)
result = result - self.term()
return result
def main():
while True:
try:
# To run under Python3 replace 'raw_input' call
# 要在 Python3 下运行，请把 ‘raw_input’ 的调用换成 ‘input’
text = raw_input('calc> ')
except EOFError:
break
if not text:
continue
interpreter = Interpreter(text)
result = interpreter.expr()
print(result)
if __name__ == '__main__':
main()
```
把上面的代码保存到 `calc3.py` 文件中，或者直接从 [GitHub](https://github.com/rspivak/lsbasi/blob/master/part3/calc3.py) 上下载。试着运行它。看看它能不能处理我之前给你看过的语法图里面派生出的数学表达式。
这是我在自己的笔记本上运行的示例：
```
$ python calc3.py
calc> 3
3
calc> 7 - 4
3
calc> 10 + 5
15
calc> 7 - 3 + 2 - 1
5
calc> 10 + 1 + 2 - 3 + 4 + 6 - 15
5
calc> 3 +
Traceback (most recent call last):
File "calc3.py", line 147, in <module>
main()
File "calc3.py", line 142, in main
result = interpreter.expr()
File "calc3.py", line 123, in expr
result = result + self.term()
File "calc3.py", line 110, in term
self.eat(INTEGER)
File "calc3.py", line 105, in eat
self.error()
File "calc3.py", line 45, in error
raise Exception('Invalid syntax')
Exception: Invalid syntax
```
记得我在文章开始时提过的练习吗：它们在这儿，我保证过的：)
* 画出只包含乘法和除法的数学表达式的语法图，比如 “7 \* 4 / 2 \* 3”。认真点，拿只钢笔或铅笔，试着画一个。 修改计算器的源代码，解释只包含乘法和除法的数学表达式。比如 “7 \* 4 / 2 \* 3”。
* 从头写一个可以处理像 “7 - 3 + 2 - 1” 这样的数学表达式的解释器。用你熟悉的编程语言，不看示例代码自己思考着写出代码。做的时候要想一想这里面包含的组件：一个词法分析器，读取输入并转换成标记流，一个解析器，从词法分析器提供的记号流中获取，并且尝试识别流中的结构，一个解释器，在解析器成功解析（识别）有效的数学表达式后产生结果。把这些要点串起来。花一点时间把你获得的知识变成一个可以运行的数学表达式的解释器。
**检验你的理解：**
1. 什么是语法图？
2. 什么是语法分析？
3. 什么是语法分析器？
嘿，看！你看完了所有内容。感谢你们坚持到今天，而且没有忘记练习。:) 下次我会带着新的文章回来，尽请期待。
---
via: <https://ruslanspivak.com/lsbasi-part3/>
作者：[Ruslan Spivak](https://ruslanspivak.com) 译者：[BriFuture](https://github.com/BriFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Ubuntu Linux 上使用 KVM 云镜像
|
Vivek Gite
|
https://www.cyberciti.biz/faq/how-to-use-kvm-cloud-images-on-ubuntu-linux/
|
如何下载并使用运行在 Ubuntu Linux 服务器上的 KVM 云镜像？如何在 Ubuntu Linux 16.04 LTS 服务器上无需完整安装即可创建虚拟机？如何在 Ubuntu Linux 上使用 KVM 云镜像？
|
/data/attachment/album/201804/07/113721yqkd8s07s80b00mv.jpg.thumb.jpg
|
/data/attachment/album/201804/07/113721yqkd8s07s80b00mv.jpg
| true | false | true |
MjSeven
| false |
[
"KVM"
] |
容器与云
|
{
"viewnum": 6443,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如何下载并使用运行在 Ubuntu Linux 服务器上的 KVM 云镜像？如何在 Ubuntu Linux 16.04 LTS 服务器上无需完整安装即可创建虚拟机？如何在 Ubuntu Linux 上使用 KVM 云镜像？
| 2018-04-07T11:37:26 | 2018-04-07T11:37:26 | 9,522 |
/article-9522-1.html
|
如何下载并使用运行在 Ubuntu Linux 服务器上的 KVM 云镜像？如何在 Ubuntu Linux 16.04 LTS 服务器上无需完整安装即可创建虚拟机？如何在 Ubuntu Linux 上使用 KVM 云镜像？
基于内核的虚拟机（KVM）是 Linux 内核的虚拟化模块，可将其转变为虚拟机管理程序。你可以在命令行使用 Ubuntu 为 libvirt 和 KVM 提供的虚拟化前端通过 KVM 创建 Ubuntu 云镜像。
这个快速教程展示了如何安装和使用 uvtool，它为 Ubuntu 云镜像下载，libvirt 和 clout\_int 提供了统一的集成虚拟机前端。
### 步骤 1 - 安装 KVM
你必须安装并配置 KVM。使用 [apt 命令](https://www.cyberciti.biz/faq/ubuntu-lts-debian-linux-apt-command-examples/ "See Linux/Unix apt command examples for more info")/[apt-get 命令](https://www.cyberciti.biz/tips/linux-debian-package-management-cheat-sheet.html "See Linux/Unix apt-get command examples for more info")，如下所示：
```
$ sudo apt install qemu-kvm libvirt-bin virtinst bridge-utils cpu-checker
$ kvm-ok
## [configure bridged networking as described here][3]
$ sudo vi /etc/network/interfaces
$ sudo systemctl restart networking
$ sudo brctl show
```
参阅[如何在 Ubuntu 16.04 LTS Headless 服务器上安装 KVM](https://www.cyberciti.biz/faq/installing-kvm-on-ubuntu-16-04-lts-server/) 以获得更多信息。（LCTT 译注：Headless 服务器是指没有本地接口的计算设备，专用于向其他计算机及其用户提供服务。）
### 步骤 2 - 安装 uvtool
键入以下 [apt 命令](https://www.cyberciti.biz/faq/ubuntu-lts-debian-linux-apt-command-examples/ "See Linux/Unix apt command examples for more info")/[apt-get 命令](https://www.cyberciti.biz/tips/linux-debian-package-management-cheat-sheet.html "See Linux/Unix apt-get command examples for more info")：
```
$ sudo apt install uvtool
```
示例输出：
```
[sudo] password for vivek:
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following packages were automatically installed and are no longer required:
gksu libgksu2-0 libqt5designer5 libqt5help5 libqt5printsupport5 libqt5sql5 libqt5sql5-sqlite libqt5xml5 python3-dbus.mainloop.pyqt5 python3-notify2 python3-pyqt5 python3-sip
Use 'sudo apt autoremove' to remove them.
The following additional packages will be installed:
cloud-image-utils distro-info python-boto python-pyinotify python-simplestreams socat ubuntu-cloudimage-keyring uvtool-libvirt
Suggested packages:
cloud-utils-euca shunit2 python-pyinotify-doc
The following NEW packages will be installed:
cloud-image-utils distro-info python-boto python-pyinotify python-simplestreams socat ubuntu-cloudimage-keyring uvtool uvtool-libvirt
0 upgraded, 9 newly installed, 0 to remove and 0 not upgraded.
Need to get 1,211 kB of archives.
After this operation, 6,876 kB of additional disk space will be used.
Get:1 http://in.archive.ubuntu.com/ubuntu artful/main amd64 distro-info amd64 0.17 [20.3 kB]
Get:2 http://in.archive.ubuntu.com/ubuntu artful/universe amd64 python-boto all 2.44.0-1ubuntu2 [740 kB]
Get:3 http://in.archive.ubuntu.com/ubuntu artful/main amd64 python-pyinotify all 0.9.6-1 [24.6 kB]
Get:4 http://in.archive.ubuntu.com/ubuntu artful/main amd64 ubuntu-cloudimage-keyring all 2013.11.11 [4,504 B]
Get:5 http://in.archive.ubuntu.com/ubuntu artful/main amd64 cloud-image-utils all 0.30-0ubuntu2 [17.2 kB]
Get:6 http://in.archive.ubuntu.com/ubuntu artful/universe amd64 python-simplestreams all 0.1.0~bzr450-0ubuntu1 [29.7 kB]
Get:7 http://in.archive.ubuntu.com/ubuntu artful/universe amd64 socat amd64 1.7.3.2-1 [342 kB]
Get:8 http://in.archive.ubuntu.com/ubuntu artful/universe amd64 uvtool all 0~git122-0ubuntu1 [6,498 B]
Get:9 http://in.archive.ubuntu.com/ubuntu artful/universe amd64 uvtool-libvirt all 0~git122-0ubuntu1 [26.9 kB]
Fetched 1,211 kB in 3s (393 kB/s)
Selecting previously unselected package distro-info.
(Reading database ... 199933 files and directories currently installed.)
Preparing to unpack .../0-distro-info_0.17_amd64.deb ...
Unpacking distro-info (0.17) ...
Selecting previously unselected package python-boto.
Preparing to unpack .../1-python-boto_2.44.0-1ubuntu2_all.deb ...
Unpacking python-boto (2.44.0-1ubuntu2) ...
Selecting previously unselected package python-pyinotify.
Preparing to unpack .../2-python-pyinotify_0.9.6-1_all.deb ...
Unpacking python-pyinotify (0.9.6-1) ...
Selecting previously unselected package ubuntu-cloudimage-keyring.
Preparing to unpack .../3-ubuntu-cloudimage-keyring_2013.11.11_all.deb ...
Unpacking ubuntu-cloudimage-keyring (2013.11.11) ...
Selecting previously unselected package cloud-image-utils.
Preparing to unpack .../4-cloud-image-utils_0.30-0ubuntu2_all.deb ...
Unpacking cloud-image-utils (0.30-0ubuntu2) ...
Selecting previously unselected package python-simplestreams.
Preparing to unpack .../5-python-simplestreams_0.1.0~bzr450-0ubuntu1_all.deb ...
Unpacking python-simplestreams (0.1.0~bzr450-0ubuntu1) ...
Selecting previously unselected package socat.
Preparing to unpack .../6-socat_1.7.3.2-1_amd64.deb ...
Unpacking socat (1.7.3.2-1) ...
Selecting previously unselected package uvtool.
Preparing to unpack .../7-uvtool_0~git122-0ubuntu1_all.deb ...
Unpacking uvtool (0~git122-0ubuntu1) ...
Selecting previously unselected package uvtool-libvirt.
Preparing to unpack .../8-uvtool-libvirt_0~git122-0ubuntu1_all.deb ...
Unpacking uvtool-libvirt (0~git122-0ubuntu1) ...
Setting up distro-info (0.17) ...
Setting up ubuntu-cloudimage-keyring (2013.11.11) ...
Setting up cloud-image-utils (0.30-0ubuntu2) ...
Setting up socat (1.7.3.2-1) ...
Setting up python-pyinotify (0.9.6-1) ...
Setting up python-boto (2.44.0-1ubuntu2) ...
Setting up python-simplestreams (0.1.0~bzr450-0ubuntu1) ...
Processing triggers for doc-base (0.10.7) ...
Processing 1 added doc-base file...
Setting up uvtool (0~git122-0ubuntu1) ...
Processing triggers for man-db (2.7.6.1-2) ...
Setting up uvtool-libvirt (0~git122-0ubuntu1) ...
```
### 步骤 3 - 下载 Ubuntu 云镜像
你需要使用 `uvt-simplestreams-libvirt` 命令。它维护一个 libvirt 容量存储池，作为一个<ruby> 简单流 <rt> simplestreams </rt></ruby>源的镜像子集的本地镜像，比如 Ubuntu 云镜像。要使用当前所有 amd64 镜像更新 uvtool 的 libvirt 容量存储池，运行：
```
$ uvt-simplestreams-libvirt sync arch=amd64
```
要更新/获取 Ubuntu 16.04 LTS (xenial/amd64) 镜像，运行：
```
$ uvt-simplestreams-libvirt --verbose sync release=xenial arch=amd64
```
示例输出：
```
Adding: com.ubuntu.cloud:server:16.04:amd64 20171121.1
```
通过 query 选项查询本地镜像：
```
$ uvt-simplestreams-libvirt query
```
示例输出：
```
release=xenial arch=amd64 label=release (20171121.1)
```
现在，我为 Ubuntu xenial 创建了一个镜像，接下来我会创建虚拟机。
### 步骤 4 - 创建 SSH 密钥
你需要使用 SSH 密钥才能登录到 KVM 虚拟机。如果你根本没有任何密钥，请使用 `ssh-keygen` 命令创建一个新的密钥。
```
$ ssh-keygen
```
参阅“[如何在 Linux / Unix 系统上设置 SSH 密钥](https://www.cyberciti.biz/faq/how-to-set-up-ssh-keys-on-linux-unix/)” 和 “[Linux / UNIX: 生成 SSH 密钥](https://www.cyberciti.biz/faq/linux-unix-generating-ssh-keys/)” 以获取更多信息。
### 步骤 5 - 创建 VM
是时候创建虚拟机了，它叫 vm1，即创建一个 Ubuntu Linux 16.04 LTS 虚拟机：
```
$ uvt-kvm create vm1
```
默认情况下 vm1 使用以下配置创建：
1. 内存：512M
2. 磁盘大小：8GiB
3. CPU：1 vCPU core
要控制内存、磁盘、CPU 和其他配置，使用以下语法：
```
$ uvt-kvm create vm1 \
--memory MEMORY \
--cpu CPU \
--disk DISK \
--bridge BRIDGE \
--ssh-public-key-file /path/to/your/SSH_PUBLIC_KEY_FILE \
--packages PACKAGES1, PACKAGES2, .. \
--run-script-once RUN_SCRIPT_ONCE \
--password PASSWORD
```
其中
1. `--password PASSWORD`：设置 ubuntu 用户的密码和允许使用 ubuntu 的用户登录（不推荐，使用 ssh 密钥）。
2. `--run-script-once RUN_SCRIPT_ONCE` : 第一次启动时，在虚拟机上以 root 身份运行 `RUN_SCRIPT_ONCE` 脚本，但再也不会运行。这里给出完整的路径。这对于在虚拟机上运行自定义任务时非常有用，例如设置安全性或其他内容。
3. `--packages PACKAGES1, PACKAGES2, ..` : 在第一次启动时安装以逗号分隔的软件包。
要获取帮助，运行：
```
$ uvt-kvm -h
$ uvt-kvm create -h
```
#### 如何删除虚拟机？
要销毁/删除名为 vm1 的虚拟机，运行（请小心使用以下命令，因为没有确认框）：
```
$ uvt-kvm destroy vm1
```
#### 获取 vm1 的 IP 地址，运行：
```
$ uvt-kvm ip vm1
192.168.122.52
```
#### 列出所有运行的虚拟机
```
$ uvt-kvm list
```
示例输出：
```
vm1
freebsd11.1
```
### 步骤 6 - 如何登录 vm1
语法是：
```
$ uvt-kvm ssh vm1
```
示例输出：
```
Welcome to Ubuntu 16.04.3 LTS (GNU/Linux 4.4.0-101-generic x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
Get cloud support with Ubuntu Advantage Cloud Guest:
http://www.ubuntu.com/business/services/cloud
0 packages can be updated.
0 updates are security updates.
Last login: Thu Dec 7 09:55:06 2017 from 192.168.122.1
```
另一个选择是从 macOS/Linux/Unix/Windows 客户端使用常规的 ssh 命令：
```
$ ssh ubuntu@192.168.122.52
$ ssh -i ~/.ssh/id_rsa ubuntu@192.168.122.52
```
示例输出：
[](https://www.cyberciti.biz/media/new/faq/2017/12/connect-to-the-running-VM-using-ssh.jpg)
一旦创建了 vim，你可以照常使用 `virsh` 命令：
```
$ virsh list
```
---
via: <https://www.cyberciti.biz/faq/how-to-use-kvm-cloud-images-on-ubuntu-linux/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
尝试 H2o 做机器学习
|
Louis-philippe Véronneau
|
https://veronneau.org/playing-with-water.html
|
我最初计划使用 R 来训练我的数据库，但老师建议我使用一个 FOSS 机器学习框架 H2o。
|
/data/attachment/album/201804/07/234425qjadmtvv9o7qacvd.png.thumb.jpg
|
/data/attachment/album/201804/07/234425qjadmtvv9o7qacvd.png
| true | false | true |
geekpi
| false |
[
"机器学习",
"ML"
] |
软件开发
|
{
"viewnum": 4752,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我最初计划使用 R 来训练我的数据库，但老师建议我使用一个 FOSS 机器学习框架 H2o。
| 2018-04-07T23:44:21 | 2018-04-07T23:44:21 | 9,523 |
/article-9523-1.html
|
我目前正在参加一个机器学习班，虽然工作量很疯狂，但我非常喜欢。我最初计划使用 [R](https://en.wikipedia.org/wiki/R_(programming_language)) 来训练我的数据库，但老师建议我使用一个 FOSS 机器学习框架 [H2o](https://www.h2o.ai)。
起初我有点怀疑，因为我已经对 R 掌握得不错了，但后来我发现你可以简单地将 H2o 作为 R 库导入。H2o 将大多数 R 函数替换为其自己的并行化函数，以减少处理时间（不再需要 `doParallel` 调用），并且使用“外部”服务端来运行，而不是直接调用 R。
直到我真正在实际中开始在 H2o 中使用 R 时，我对这种情况都非常满意。我在使用非常大的数据库时，库变得笨重，我几乎不能做任何有用得事情。大多数时候，我最后只是得到一个很长的 Java 回溯调用。
我相信正确地将 H2o 作为一个库使用将非常强大，但可惜的是，它似乎在我的 R 技能中无效。
我生了一整天的气 —— 无法实现我想做的事 —— 直到我意识到 H2o 有一个名为 Flow 的 WebUI。我通常不喜欢使用 web 来完成重要的工作，比如编写代码，但是 Flow 简直太不可思议了。
自动绘图功能，运行资源密集模型时集成 ETA（预计剩余时间），每个模型参数的描述（这些参数甚至会根据您熟悉的统计模型分成不同部分），Flow 似乎拥有所有功能。我很快就能够运行 3 种基本的机器学习模型并获得实际可解释的结果。
所以，如果你一直渴望使用最先进的机器学习模型分析非常大的数据库，我会推荐使用 H2o。首先尝试使用 Flow，而不是 Python 或 R 的钩子，来看看它能做什么。
唯一缺点是，H2o 是用 Java 编写的，并依赖 Java 1.7 来运行。并且需要警告的是：它需要非常强大的处理器和大量的内存。即使有 10 个可用的内核和 10Gb 的 RAM，我可怜的服务器也苦苦挣扎了一段时间。
---
via: <https://veronneau.org/playing-with-water.html>
作者：[Louis-Philippe Véronneau](https://veronneau.org/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 PGP 保护代码完整性（一）： 基本概念和工具
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/learn/2018/2/protecting-code-integrity-pgp-part-1-basic-pgp-concepts-and-tools
|
自由软件社区长期依赖于 PGP 确保它生产的软件产品的真实性和完整性。
|
/data/attachment/album/201804/08/002106h7kk6uchrkbobkk9.jpg.thumb.jpg
|
/data/attachment/album/201804/08/002106h7kk6uchrkbobkk9.jpg
| true | false | true |
kimii
| false |
[
"PGP",
"gpg"
] |
技术
|
{
"viewnum": 9835,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9529,
"displayorder": 0
}
] |
自由软件社区长期依赖于 PGP 确保它生产的软件产品的真实性和完整性。
| 2018-04-08T09:19:00 | 2018-04-08T09:19:00 | 9,524 |
/article-9524-1.html
|
在本系列文章中，我们将深度探讨如何使用 PGP 确保软件完整性。这些文章将为工作于自由软件项目的开发者提供实用指南，并且将包含以下主题：
1. PGP 基础和最佳实践
2. 如何用 Git 使用 PGP
3. 如何保护你的开发者账户
我们使用与“Freedom”含义相同的词项 “Free”，但这个系列中列出的指南也可以被任何其它类型的依赖于分布式团队开发者贡献的软件中。如果你编写进入公共源仓库的代码，你可以从了解和遵循这篇指南中受益。
### 结构
每节分为两个部分：
* 适用于你项目需求的清单
* 形式自由的考虑事项的列表，解释这些决定取决于什么，并伴随着配置指令
#### 清单优先级
每个清单中各项包含着优先级，用来帮助指导你的决定：
* （必要）该项一定要排在考虑事项列表的前面。如果没有这样做，它们将给提交到开源项目中的代码带来高风险。
* （推荐）包含该项将提升整体安全性，但会影响你与工作环境的交互方式，并且可能需要学习新的习惯或者放弃旧的习惯。
记住，这些只是指导。如果你感到这些优先级不能反映你项目提交的安全，你应该根据自己的需要调整它们。
### PGP 基本概念和工具
#### 清单
1. 理解 PGP 在自由软件开发中的作用 （必要）
2. 理解<ruby> 公钥密码学 <rt> Public Key Cryptography </rt></ruby>的基础知识 （必要）
3. 理解 PGP 加密和签名的不同 （必要）
4. 理解 PGP <ruby> 密钥身份 <rt> key identities </rt></ruby> （必要）
5. 理解 PGP <ruby> 密钥有效性 <rt> key validity </rt></ruby> （必要）
6. 安装 GnuPG 工具（版本 2.x） （必要）
#### 考虑事项
自由软件社区长期依赖于 PGP 确保它生产的软件产品的真实性和完整性。你可能没有注意到，但无论你是一个 Linux 、Mac 和 Windowas 用户，你都曾依赖 PGP 来确保你电脑环境的完整性：
* Linux 发行版依赖 PGP 来确保当二进制或者原代码包从被生产出来到被终端用户安装之间没被更改过
* 自由软件项目通常会伴随发行软件的存档提供分离的 PGP 签名，使得下游的项目可以在把下载的版本集成到自己的分布式下载之前，验证下载版本的完整性。
* 自由软件项目通常依赖代码本身的 PGP 签名来跟踪起源，并验证项目开发者提交的代码的完整性
这与工作于专有平台的程序员使用的开发者证书或代码签名机制非常相似。实际上，这两种技术背后的核心概念非常相似 —— 尽管它们在实现的技术层面和它们委托信任方式的大多不同。PGP 不依赖于集中式认证机构，而是让每个用户为每个证书赋予自己的信任。
我们的目标是使你的项目通过使用 PGP 来进行代码起源和完整性追踪，遵循最佳实践并遵守基本的安全预防措施。
#### 极其基本的 PGP 操作概括
你不需要知道 PGP 如何工作的具体细节 —— 理解核心概念足以成功地达到我们的目的。PGP 依赖于公钥密码学来将明文转换为密文。这个过程需要两种不同的密钥：
* 公钥，被所有人知道
* 私钥，只被拥有者知道
##### 加密
对加密来说，PGP 使用拥有者的公钥创造一条只能通过拥有者私钥解密的消息：
1. 发送者生成一个随机的加密密钥（“会话密钥”）
2. 发送者使用该会话密钥（使用对称算法）加密内容
3. 发送者使用接收者的 PGP 公钥加密会话密钥
4. 发送者向接收者发送加密后的内容和加密后的会话密钥
要解密：
1. 接收者使用他们的 PGP 私钥解密会话密钥
2. 接收者使用会话密钥解密消息的内容
##### 签名
为了创建签名，PGP 私钥或公钥会以相反的方式使用：
1. 签名者生成内容的校检和哈希
2. 签名者使用自己的 PGP 私钥来加密该校检和
3. 签名者伴随内容提供加密后的校检和
要验证签名：
1. 验证者生成自己的内容校检和哈希
2. 验证者使用签名者的 PGP 公钥来解密提供的校检和
3. 如果校检和匹配，就验证了内容的完整性
##### 结合使用
通常，加密消息也被发送者自己的 PGP 密钥签名。无论何时使用加密消息，这应当是默认的，因为没有认证的加密没有很大意义（除非你是一个告密者或秘密代理并且需要可行的可否认性）
#### 理解密钥身份
每个 PGP 密钥必须有一个或多个与之关联的身份。通常，“<ruby> 身份 <rt> Identity </rt></ruby>”指的是以下格式中的人物全名和邮件地址：
```
Alice Engineer <alice.engineer@example.com>
```
有时也会在括号中包含说明，来告诉终端用户关于该特定密钥的更多信息：
```
Bob Designer (obsolete 1024-bit key) <bob.designer@example.com>
```
由于人们可以和多个职业和个人实体相关联，因此在同一密钥上可以有多个身份：
```
Alice Engineer <alice.engineer@example.com>
Alice Engineer <aengineer@personalmail.example.org>
Alice Engineer <webmaster@girlswhocode.example.net>
```
当使用多个身份时，其中之一将被标记为“<ruby> primary identity <rt> 主要身份 </rt></ruby>”来让检索更简单。
#### 理解密钥有效性
为了能使用其他人的公钥来加密或验证，你需要确保它确实属于正确的人（Alice）而不属于冒牌的（Eve）。在 PGP 中，这被称为“密钥有效性”：
* 有效性：<ruby> 完全 <rt> full </rt></ruby> -- 意味着非常确认该密钥属于 Alice
* 有效性：<ruby> 临界 <rt> marginal </rt></ruby> -- 意味着大致确认该密钥属于 Alice
* 有效性：<ruby> 未知 <rt> unknown </rt></ruby> -- 意味着不确认该密钥是否属于 Alice
#### Web of Trust （WOT） 与 Trust on First Use (TOFU)
PGP 使用了一种信任委托机制叫“Web of Trust”。它的核心是尝试替代 HTTPS/TLS 世界中对集中式认证机构的需求。PGP 把这个责任交给了每个用户，而不是各种软件开发商来决定谁应该是你的可信认证实体。
不幸的是，很少有人理解 Web of Trust 的是如何工作的，能使用它的人更少。它仍然是 OpenPGP 规范的一个重要方面，但 GnuPG 的近期版本（2.2 及以上）已经实现了一种替代机制叫“Trust on First Use”(TOFU)。
你可以把 TOFU 当作类似 SSH 的信任方式。使用 SSH，当你第一次连接到远程系统，它的密钥指纹会被记录和保存。如果将来密钥改变，SSH 客户端将会提醒你并拒绝连接，迫使你决定是否信任已改变的的密钥。
同样，当你第一次导入某人的 PGP 密钥，它被假定可信。如果在将来的任何时候，GnuPG 碰巧发现另一同样身份的密钥，过去导入的密钥和新密钥都将被标记为无效，并且你需要手动指出保留哪个。
#### 安装 OpenPGP 软件
首先，理解 PGP、OpenPGP、GnuPG 和 gpg 之间的不同很重要：
* PGP （“Pretty Good Privacy”） 是最初商业软件的名字
* OpenPGP 是与最初 PGP 工具兼容的 IETF 标准
* GnuPG （“Gnu Privacy Guard”）是实现了 OpenPGP 标准的自由软件
* GnuPG 的命令行工具称为 “gpg”
今天，“PGP”这个词几乎被普遍用来表示开放的 OpenPGP 标准，而不是最初的商业软件，因此“PGP”和“OpenPGP”是可以互换的。“GnuPG”和“pgp”这两个词应该仅在提及工具时使用，而不用于它们产生的输出或它们实现的 OpenPGP 功能。举例：
* PGP（而非 GnuPG 或 GPG）密钥
* PGP（而非 GnuPG 或 GPG）签名
* PGP（而非 GnuPG 或 GPG）密钥服务器
理解这一点应该可以保护你免受来自你遇到的其他 PGP 用户“实际上”不可避免的迂腐。
##### 安装 GnuPG
如果你正在使用 Linux，你应该已经安装过了 GnuPG。在 Mac 上，你应该安装 [GPG-Suite](https://gpgtools.org/)，或者使用 `brew` 安装 `gnupg2`。在 Windows 上，你应该安装 [GPG4Win](https://www.gpg4win.org/)，并且为了可以工作，你可能需要调整指南中的部分命令，除非你设置了类似 Unix 的环境。对其他平台来说，你需要自行查找正确的地址来下载和安装 GnuPG。
##### GnuPG 1 vs. 2
GnuPG v.1 和 GnuPG v.2 都实现了同样的标准，但它们提供不兼容的库和命令行工具，所以许多发行版都带有了旧的版本 1 和最新的版本 2。你需要确保你总是使用 GnuPG v.2。
首先，运行：
```
$ gpg --version | head -n1
```
如果你看到 `gpg (GnuPG) 1.4.x`，说明你正使用 GnuPG v.1。尝试下 `gpg2` 命令：
```
$ gpg2 --version | head -n1
```
如果你看到 `gpg (GnuPG) 2.x.x`，说明你可以继续了。这篇指南将假设你使用 GnuPG 2.2 版本（或更新）。如果你正使用 GnuPG 的 2.0 版本，本指南中某些命令可能无效，你应该考虑安装 GnuPG 最新的 2.2 版本
##### 确保你总是使用 GnuPG v.2
如果你 `gpg` 和 `gpg2` 命令都有，你应该确保总是使用 GnuPG v.2，而不是旧的版本。你可以通过设置别名来确保这一点：
```
$ alias gpg=gpg2
```
你可以把它放在你的 `.bashrc` 中，以确保它在你使用 `gpg` 命令时总是被加载。
在本系列的第 2 部分中，我们将介绍生成和保护你的 PGP 主密钥的基本步骤。
通过 Linux 基金会和 edX 的免费[“Introduction to Linux”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 课程了解关于 Linux 的更多信息。
---
via: <https://www.linux.com/blog/learn/2018/2/protecting-code-integrity-pgp-part-1-basic-pgp-concepts-and-tools>
作者：[Konstantin Ryabitsev](https://www.linux.com/users/mricon) 译者：[kimii](https://github.com/kimii) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Facebook 的开源计划一窥
|
Justin W. Flory
|
https://opensource.com/article/18/1/inside-facebooks-open-source-program
|
Facebook 开发人员 Christine Abernathy 讨论了开源如何帮助公司分享见解并推动创新。
|
/data/attachment/album/201804/08/094719tzkvy1y1h7e6y7et.jpg.thumb.jpg
|
/data/attachment/album/201804/08/094719tzkvy1y1h7e6y7et.jpg
| true | false | true |
geekpi
| false |
[
"Facebook",
"开源"
] |
观点
|
{
"viewnum": 3949,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Facebook 开发人员 Christine Abernathy 讨论了开源如何帮助公司分享见解并推动创新。
| 2018-04-08T09:47:00 | 2018-04-08T09:47:00 | 9,525 |
/article-9525-1.html
|
>
> Facebook 开发人员 Christine Abernathy 讨论了开源如何帮助公司分享见解并推动创新。
>
>
>
开源逐年变得无处不在，从[政府直辖市](https://opensource.com/article/17/8/tirana-government-chooses-open-source)到[大学](https://opensource.com/article/16/12/2016-election-night-hackathon)都有。各种规模的公司也越来越多地转向开源软件。事实上，一些公司正在通过财务支持项目或与开发人员合作进一步推进开源。
例如，Facebook 的开源计划鼓励其他人开源发布他们的代码，同时与社区合作支持开源项目。 [Christine Abernathy](https://twitter.com/abernathyca)，是一名 Facebook 开发者、开源支持者，也是该公司开源团队成员，去年 11 月访问了罗切斯特理工学院，在 [11 月](https://www.eventbrite.com/e/fossmagic-talks-open-source-facebook-with-christine-abernathy-tickets-38955037566#) 的 FOSS 系列演讲中发表了演讲。在她的演讲中，Abernathy 解释了 Facebook 如何开源以及为什么它是公司所做工作的重要组成部分。
### Facebook 和开源
Abernathy 说，开源在 Facebook 创建社区并使世界更加紧密的使命中扮演着重要的角色。这种意识形态的匹配是 Facebook 参与开源的一个激励因素。此外，Facebook 面临着独特的基础设施和开发挑战，而开源则为公司提供了一个平台，以共享可帮助他人的解决方案。开源还提供了一种加速创新和创建更好软件的方法，帮助工程团队生产更好的软件并更透明地工作。今天，Facebook 在 GitHub 的 443 个项目有 122,000 个分支、292,000 个提交和 732,000 个关注。
*一些以开源方式发布的 Facebook 项目包括 React、GraphQL、Caffe2 等等。（图片提供：Christine Abernathy 图片，经许可使用）*
### 得到的教训
Abernathy 强调说 Facebook 已经从开源社区吸取了很多教训，并期待学到更多。她明确了三个最重要的：
* 分享有用的东西
* 突出你的英雄
* 修复常见的痛点
*Christine Abernathy 作为 FOSS 演讲系列的嘉宾一员参观了 RIT。每个月，来自开源世界的演讲嘉宾都会与对自由和开源软件感兴趣的学生分享关于开源世界智慧、见解、建议。 [FOSS @MAGIC](http://foss.rit.edu/)社区感谢 Abernathy 作为演讲嘉宾出席。*
### 关于作者
Justin 是[罗切斯特理工学院](https://www.rit.edu/)主修网络与系统管理的学生。他目前是 [Fedora Project](https://fedoraproject.org/wiki/Overview) 的贡献者。在 Fedora 中，Justin 是 [Fedora Magazine](https://fedoramagazine.org/) 的主编，[社区的领导](https://fedoraproject.org/wiki/CommOps)...
---
via: <https://opensource.com/article/18/1/inside-facebooks-open-source-program>
作者：[Justin W. Flory](https://opensource.com/users/jflory) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
防止文档陷阱的 7 条准则
|
Tanja Roth
|
https://opensource.com/article/17/12/7-rules
|
让我们了解一下如何使国外读者更容易理解你的技术文章。
|
/data/attachment/album/201804/08/101132da61z8jkz61f6tgq.png.thumb.jpg
|
/data/attachment/album/201804/08/101132da61z8jkz61f6tgq.png
| true | false | true |
lujun9972
| false |
[
"写作",
"文档"
] |
观点
|
{
"viewnum": 3928,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
让我们了解一下如何使国外读者更容易理解你的技术文章。
| 2018-04-08T10:11:29 | 2018-04-08T10:11:29 | 9,526 |
/article-9526-1.html
|
>
> 让我们了解一下如何使国外读者更容易理解你的技术文章。
>
>
>
英语是开源社区的通用语言。为了减少翻译成本，很多团队都改成用英语来写他们的文档。 但奇怪的是，为国际读者写英语并不一定就意味着以英语为母语的人就占据更多的优势。 相反， 他们往往忘记了该文档用的语言可能并不是读者的母语。
我们以下面这个简单的句子为例： “Encrypt the password using the `foo bar` command。”语法上来说，这个句子是正确的。 鉴于动名词的 “-ing” 形式在英语中很常见，大多数的母语人士都认为这是一种优雅的表达方式， 他们通常会很自然的写出这样的句子。 但是仔细观察， 这个句子存在歧义因为 “using” 可能指的宾语（“the password”）也可能指的动词(“encrypt”）。 因此这个句子有两种解读方式:
* “加密使用了 `foo bar` 命令的密码。”
* “使用命令 `foo bar` 来加密密码。”
如果你有相关的先验知识（密码加密或者 `foo bar` 命令），你可以消除这种不确定性并且明白第二种方式才是真正的意思。 但是若你没有足够深入的知识怎么办呢？ 如果你并不是这方面的专家，而只是一个拥有泛泛相关知识的翻译者而已怎么办呢？ 再或者，如果你只是个非母语人士且对像动名词这种高级语法不熟悉怎么办呢？
即使是英语为母语的人也需要经过训练才能写出清晰直接的技术文档。训练的第一步就是提高对文本可用性以及潜在问题的警觉性， 下面让我们来看一下可以帮助避免常见陷阱的 7 条规则。
### 1、了解你的目标读者并代入其中。
如果你是一名开发者，而写作的对象是最终用户， 那么你需要站在他们的角度来看这个产品。 文档的结构是否反映了用户的目标？ [<ruby> 人格面具 <rt> persona </rt></ruby> 技术](https://en.wikipedia.org/wiki/Persona_(user_experience)) 能帮你专注于目标受众并为你的读者提供合适层次的细节。
### 2、遵循 KISS 原则——保持文档简短而简单
这个原则适用于多个层次，从语法，句子到单词。 比如:
* 使用合适的最简单时态。比如， 当提到一个动作的结果时使用现在时:
+ " ~~Click 'OK.' The 'Printer Options' dialog will appear.~~ " -> "Click 'OK.' The 'Printer Options' dialog appears."
* 按经验来说，一个句子表达一个主题；然而， 短句子并不一定就容易理解（尤其当这些句子都是由名词组成时）。 有时， 将句子裁剪过度可能会引起歧义，而反过来太多单词则又难以理解。
* 不常用的以及很长的单词会降低阅读速度，而且可能成为非母语人士的障碍。 使用更简单的替代词语:
+ " ~~utilize~~ " -> "use"
+ " ~~indicate~~ " -> "show"，"tell" 或 "say"
+ " ~~prerequisite~~ " -> "requirement"
### 3、不要干扰阅读流
将虚词和较长的插入语移到句子的首部或者尾部:
* " ~~They are not, however, marked as installed.~~ " -> "However, they are not marked as installed."
将长命令放在句子的末尾可以让自动/半自动的翻译拥有更好的断句。
### 4、区别对待两种基本的信息类型
描述型信息以及任务导向型信息有必要区分开来。描述型信息的一个典型例子就是命令行参考， 而 HOWTO 则是属于基于任务的信息；（LCTT 译注：HOWTO 文档是 Linux 文档中的一种）然而， 技术写作中都会涉及这两种类型的信息。 仔细观察， 就会发现许多文本都同时包含了两种类型的信息。 然而如果能够清晰地划分这两种类型的信息那必是极好的。 为了更好地区分它们，可以对它们进行分别标记。 标题应该能够反映章节的内容以及信息的类型。 对描述性章节使用基于名词的标题（比如“Types of Frobnicators”），而对基于任务的章节使用口头表达式的标题（例如“Installing Frobnicators”）。 这可以让读者快速定位感兴趣的章节而跳过对他无用的章节。
### 5、考虑不同的阅读场景和阅读模式
有些读者在阅读产品文档时会由于自己搞不定而感到十分的沮丧。他们在一个嘈杂的环境中工作，也很难专注于阅读。 同时，不要期望你的读者会一页一页的进行阅读，很多人都是快速浏览文本，搜索关键字或者通过表格、索引以及全文搜索的方式来查找主题。 请牢记这一点， 从不同的角度来看待你的文字。 通常需要折中才能找到一种适合多种情况的文本结构。
### 6、将复杂的信息分成小块
这会让读者更容易记住和吸收信息。例如， 过程不应该超过 7 到 10 个步骤（根据认知心理学中的 [米勒法则](https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two)）。 如果需要更多的步骤， 那么就将任务分拆成不同的过程。
### 7、形式遵循功能
根据以下问题检查你的文字：某句话/段落/章节的 *目的*（功能）是什么？比如，它是一个指令呢？还是一个结果呢？还是一个警告呢？如果是指令， 使用主动语气： “Configure the system.” 被动语气可能适合于进行描述： “The system is configured automatically.” 将警告放在危险操作的 *前面* 。 专注于目的还有助于发现冗余的内容，可以清除类似 “basically” 或者 “easily” 这一类的填充词，类似 “~~already~~ existing ” 或“ ~~completely~~ new” 这一类的不必要的修饰， 以及任何与你的目标大众无关的内容。
你现在可能已经猜到了，写作就是一个不断重写的过程。 好的写作需要付出努力和练习。 即使你只是偶尔写点东西， 你也可以通过关注目标大众并遵循上述规则来显著地改善你的文字。 文字的可读性越好， 理解就越容易， 这一点对不同语言能力的读者来说都是适合的。 尤其是当进行本地化时， 高质量的原始文本至关重要：“垃圾进， 垃圾出”。 如果原始文本就有缺陷， 翻译所需要的时间就会变长， 从而导致更高的成本。 最坏的情况下， 翻译会导致缺陷成倍增加，需要在不同的语言版本中修正这个缺陷。
---
via: <https://opensource.com/article/17/12/7-rules>
作者：[Tanja Roth](https://opensource.com) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Ansible 教程：简单 Ansible 命令介绍
|
Shusain
|
http://linuxtechlab.com/ansible-tutorial-simple-commands/
|
在这个 Ansible 教程中，我们将学习一些基本的 Ansible 命令的例子，我们将用它来管理基础设施。
|
/data/attachment/album/201804/08/151839pp13hpc7o1i36joc.jpg.thumb.jpg
|
/data/attachment/album/201804/08/151839pp13hpc7o1i36joc.jpg
| true | false | true |
geekpi
| false |
[
"Ansible"
] |
系统运维
|
{
"viewnum": 12395,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这个 Ansible 教程中，我们将学习一些基本的 Ansible 命令的例子，我们将用它来管理基础设施。
| 2018-04-08T15:18:43 | 2018-04-08T15:18:43 | 9,527 |
/article-9527-1.html
|
在我们之前的 Ansible 教程中，我们讨论了 [Ansible 的安装和配置](http://linuxtechlab.com/create-first-ansible-server-automation-setup/)。在这个 Ansible 教程中，我们将学习一些基本的 Ansible 命令的例子，我们将用它来管理基础设施。所以让我们先看看一个完整的 Ansible 命令的语法：
```
$ ansible <group> -m <module> -a <arguments>
```
在这里，我们可以用单个主机或用 `<group>` 代替一组主机，`<arguments>` 是可选的参数。现在我们来看看一些 Ansible 的基本命令。
### 检查主机的连通性
我们在之前的教程中也使用了这个命令。检查主机连接的命令是：
```
$ ansible <group> -m ping
```
### 重启主机
```
$ ansible <group> -a "/sbin/reboot"
```
### 检查主机的系统信息
Ansible 收集所有连接到它主机的信息。要显示主机的信息，请运行：
```
$ ansible <group> -m setup | less
```
其次，通过传递参数来从收集的信息中检查特定的信息：
```
$ ansible <group> -m setup -a "filter=ansible_distribution"
```
### 传输文件
对于传输文件，我们使用模块 `copy` ，完整的命令是这样的：
```
$ ansible <group> -m copy -a "src=/home/dan dest=/tmp/home"
```
### 管理用户
要管理已连接主机上的用户，我们使用一个名为 `user` 的模块，并如下使用它。
#### 创建新用户
```
$ ansible <group> -m user -a "name=testuser password=<encrypted password>"
```
#### 删除用户
```
$ ansible <group> -m user -a "name=testuser state=absent"
```
**注意：** 要创建加密密码，请使用 `"mkpasswd -method=sha-512"`。
### 更改权限和所有者
要改变已连接主机文件的所有者，我们使用名为 `file` 的模块，使用如下。
#### 更改文件权限
```
$ ansible <group> -m file -a "dest=/home/dan/file1.txt mode=777"
```
#### 更改文件的所有者
```
$ ansible <group> -m file -a "dest=/home/dan/file1.txt mode=777 owner=dan group=dan"
```
### 管理软件包
我们可以通过使用 `yum` 和 `apt` 模块来管理所有已连接主机的软件包，完整的命令如下：
#### 检查包是否已安装并更新
```
$ ansible <group> -m yum -a "name=ntp state=latest"
```
#### 检查包是否已安装，但不更新
```
$ ansible <group> -m yum -a "name=ntp state=present"
```
#### 检查包是否是特定的版本
```
$ ansible <group> -m yum -a "name= ntp-1.8 state=present"
```
#### 检查包是否没有安装
```
$ ansible <group> -m yum -a "name=ntp state=absent"
```
### 管理服务
要管理服务，我们使用模块 `service` ，完整命令如下：
#### 启动服务
```
$ansible <group> -m service -a "name=httpd state=started"
```
#### 停止服务
```
$ ansible <group> -m service -a "name=httpd state=stopped"
```
#### 重启服务
```
$ ansible <group> -m service -a "name=httpd state=restarted"
```
这样我们简单的、单行 Ansible 命令的教程就完成了。此外，在未来的教程中，我们将学习创建 playbook，来帮助我们更轻松高效地管理主机。
---
via: <http://linuxtechlab.com/ansible-tutorial-simple-commands/>
作者：[SHUSAIN](http://linuxtechlab.com/author/shsuain/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
页面缓存：内存和文件之间的那些事
|
Gustavo Duarte
|
https://manybutfinite.com/post/page-cache-the-affair-between-memory-and-files/
|
这一篇文章我们将专门去讲这个重要的主题 —— 页面缓存。文件和内存之间的关系常常很不好去理解，而它们对系统性能的影响却是非常大的。
|
/data/attachment/album/201804/08/191716biaoeie8ofpmpbgg.jpg.thumb.jpg
|
/data/attachment/album/201804/08/191716biaoeie8ofpmpbgg.jpg
| true | false | true |
qhwdw
| false |
[
"缓存",
"内存管理"
] |
技术
|
{
"viewnum": 9406,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9255,
"displayorder": 0
},
{
"raid": 9393,
"displayorder": 1
}
] |
这一篇文章我们将专门去讲这个重要的主题 —— 页面缓存。文件和内存之间的关系常常很不好去理解，而它们对系统性能的影响却是非常大的。
| 2018-04-08T19:17:00 | 2018-04-08T19:17:00 | 9,528 |
/article-9528-1.html
|
上一篇文章中我们学习了内核怎么为一个用户进程 [管理虚拟内存](/article-9393-1.html)，而没有提及文件和 I/O。这一篇文章我们将专门去讲这个重要的主题 —— 页面缓存。文件和内存之间的关系常常很不好去理解，而它们对系统性能的影响却是非常大的。
在面对文件时，有两个很重要的问题需要操作系统去解决。第一个是相对内存而言，慢的让人发狂的硬盘驱动器，[尤其是磁盘寻道](https://manybutfinite.com/post/what-your-computer-does-while-you-wait)。第二个是需要将文件内容一次性地加载到物理内存中，以便程序间*共享*文件内容。如果你在 Windows 中使用 [进程浏览器](http://technet.microsoft.com/en-us/sysinternals/bb896653.aspx) 去查看它的进程，你将会看到每个进程中加载了大约 ~15MB 的公共 DLL。我的 Windows 机器上现在大约运行着 100 个进程，因此，如果不共享的话，仅这些公共的 DLL 就要使用高达 ~1.5 GB 的物理内存。如果是那样的话，那就太糟糕了。同样的，几乎所有的 Linux 进程都需要 ld.so 和 libc，加上其它的公共库，它们占用的内存数量也不是一个小数目。
幸运的是，这两个问题都用一个办法解决了：页面缓存 —— 保存在内存中的页面大小的文件块。为了用图去说明页面缓存，我捏造出一个名为 `render` 的 Linux 程序，它打开了文件 `scene.dat`，并且一次读取 512 字节，并将文件内容存储到一个分配到堆中的块上。第一次读取的过程如下：
1. `render` 请求 `scene.dat` 从位移 0 开始的 512 字节。
2. 内核搜寻页面缓存中 `scene.dat` 的 4kb 块，以满足该请求。假设该数据没有缓存。
3. 内核分配页面帧，初始化 I/O 请求，将 `scend.dat` 从位移 0 开始的 4kb 复制到分配的页面帧。
4. 内核从页面缓存复制请求的 512 字节到用户缓冲区，系统调用 `read()` 结束。
读取完 12KB 的文件内容以后，`render` 程序的堆和相关的页面帧如下图所示：
它看起来很简单，其实这一过程做了很多的事情。首先，虽然这个程序使用了普通的读取（`read`）调用，但是，已经有三个 4KB 的页面帧将文件 scene.dat 的一部分内容保存在了页面缓存中。虽然有时让人觉得很惊奇，但是，**普通的文件 I/O 就是这样通过页面缓存来进行的**。在 x86 架构的 Linux 中，内核将文件认为是一系列的 4KB 大小的块。如果你从文件中读取单个字节，包含这个字节的整个 4KB 块将被从磁盘中读入到页面缓存中。这是可以理解的，因为磁盘通常是持续吞吐的，并且程序一般也不会从磁盘区域仅仅读取几个字节。页面缓存知道文件中的每个 4KB 块的位置，在上图中用 `#0`、`#1` 等等来描述。Windows 使用 256KB 大小的<ruby> 视图 <rt> view </rt></ruby>，类似于 Linux 的页面缓存中的<ruby> 页面 <rt> page </rt></ruby>。
不幸的是，在一个普通的文件读取中，内核必须拷贝页面缓存中的内容到用户缓冲区中，它不仅花费 CPU 时间和影响 [CPU 缓存](https://manybutfinite.com/post/intel-cpu-caches)，**在复制数据时也浪费物理内存**。如前面的图示，`scene.dat` 的内存被存储了两次，并且，程序中的每个实例都用另外的时间去存储内容。我们虽然解决了从磁盘中读取文件缓慢的问题，但是在其它的方面带来了更痛苦的问题。内存映射文件是解决这种痛苦的一个方法：
当你使用文件映射时，内核直接在页面缓存上映射你的程序的虚拟页面。这样可以显著提升性能：[Windows 系统编程](http://www.amazon.com/Windows-Programming-Addison-Wesley-Microsoft-Technology/dp/0321256190/) 报告指出，在相关的普通文件读取上运行时性能提升多达 30% ，在 [Unix 环境中的高级编程](http://www.amazon.com/Programming-Environment-Addison-Wesley-Professional-Computing/dp/0321525949/) 的报告中，文件映射在 Linux 和 Solaris 也有类似的效果。这取决于你的应用程序类型的不同，通过使用文件映射，可以节约大量的物理内存。
对高性能的追求是永恒不变的目标，[测量是很重要的事情](https://manybutfinite.com/post/performance-is-a-science)，内存映射应该是程序员始终要使用的工具。这个 API 提供了非常好用的实现方式，它允许你在内存中按字节去访问一个文件，而不需要为了这种好处而牺牲代码可读性。在一个类 Unix 的系统中，可以使用 [mmap](http://www.kernel.org/doc/man-pages/online/pages/man2/mmap.2.html) 查看你的 [地址空间](https://manybutfinite.com/post/anatomy-of-a-program-in-memory)，在 Windows 中，可以使用 [CreateFileMapping](http://msdn.microsoft.com/en-us/library/aa366537(VS.85).aspx)，或者在高级编程语言中还有更多的可用封装。当你映射一个文件内容时，它并不是一次性将全部内容都映射到内存中，而是通过 [页面故障](http://lxr.linux.no/linux+v2.6.28/mm/memory.c#L2678) 来按需映射的。在 [获取](http://lxr.linux.no/linux+v2.6.28/mm/filemap.c#L1424) 需要的文件内容的页面帧后，页面故障句柄 [映射你的虚拟页面](http://lxr.linux.no/linux+v2.6.28/mm/memory.c#L2436) 到页面缓存上。如果一开始文件内容没有缓存，这还将涉及到磁盘 I/O。
现在出现一个突发的状况，假设我们的 `render` 程序的最后一个实例退出了。在页面缓存中保存着 `scene.dat` 内容的页面要立刻释放掉吗？人们通常会如此考虑，但是，那样做并不是个好主意。你应该想到，我们经常在一个程序中创建一个文件，退出程序，然后，在第二个程序去使用这个文件。页面缓存正好可以处理这种情况。如果考虑更多的情况，内核为什么要清除页面缓存的内容？请记住，磁盘读取的速度要慢于内存 5 个数量级，因此，命中一个页面缓存是一件有非常大收益的事情。因此，只要有足够大的物理内存，缓存就应该保持全满。并且，这一原则适用于所有的进程。如果你现在运行 `render` 一周后， `scene.dat` 的内容还在缓存中，那么应该恭喜你！这就是什么内核缓存越来越大，直至达到最大限制的原因。它并不是因为操作系统设计的太“垃圾”而浪费你的内存，其实这是一个非常好的行为，因为，释放物理内存才是一种“浪费”。（LCTT 译注：释放物理内存会导致页面缓存被清除，下次运行程序需要的相关数据，需要再次从磁盘上进行读取，会“浪费” CPU 和 I/O 资源）最好的做法是尽可能多的使用缓存。
由于页面缓存架构的原因，当程序调用 [write()](http://www.kernel.org/doc/man-pages/online/pages/man2/write.2.html) 时，字节只是被简单地拷贝到页面缓存中，并将这个页面标记为“脏”页面。磁盘 I/O 通常并**不会**立即发生，因此，你的程序并不会被阻塞在等待磁盘写入上。副作用是，如果这时候发生了电脑死机，你的写入将不会完成，因此，对于至关重要的文件，像数据库事务日志，要求必须进行 [fsync()](http://www.kernel.org/doc/man-pages/online/pages/man2/fsync.2.html)（仍然还需要去担心磁盘控制器的缓存失败问题），另一方面，读取将被你的程序阻塞，直到数据可用为止。内核采取预加载的方式来缓解这个矛盾，它一般提前预读取几个页面并将它加载到页面缓存中，以备你后来的读取。在你计划进行一个顺序或者随机读取时（请查看 [madvise()](http://www.kernel.org/doc/man-pages/online/pages/man2/madvise.2.html)、[readahead()](http://www.kernel.org/doc/man-pages/online/pages/man2/readahead.2.html)、[Windows 缓存提示](http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx#caching_behavior) ），你可以通过<ruby> 提示 <rt> hint </rt></ruby>帮助内核去调整这个预加载行为。Linux 会对内存映射的文件进行 [预读取](http://lxr.linux.no/linux+v2.6.28/mm/filemap.c#L1424)，但是我不确定 Windows 的行为。当然，在 Linux 中它可能会使用 [O\_DIRECT](http://www.kernel.org/doc/man-pages/online/pages/man2/open.2.html) 跳过预读取，或者，在 Windows 中使用 [NO\_BUFFERING](http://msdn.microsoft.com/en-us/library/cc644950(VS.85).aspx) 去跳过预读，一些数据库软件就经常这么做。
一个文件映射可以是私有的，也可以是共享的。当然，这只是针对内存中内容的**更新**而言：在一个私有的内存映射上，更新并不会提交到磁盘或者被其它进程可见，然而，共享的内存映射，则正好相反，它的任何更新都会提交到磁盘上，并且对其它的进程可见。内核使用<ruby> 写时复制 <rt> copy on write </rt></ruby>（CoW）机制，这是通过<ruby> 页面表条目 <rt> page table entry </rt></ruby>（PTE）来实现这种私有的映射。在下面的例子中，`render` 和另一个被称为 `render3d` 的程序都私有映射到 `scene.dat` 上。然后 `render` 去写入映射的文件的虚拟内存区域：
1. 两个程序私有地映射 `scene.dat`，内核误导它们并将它们映射到页面缓存，但是使该页面表条目只读。
2. `render` 试图写入到映射 `scene.dat` 的虚拟页面，处理器发生页面故障。
3. 内核分配页面帧，复制 `scene.dat` 的第二块内容到其中，并映射故障的页面到新的页面帧。
4. 继续执行。程序就当做什么都没发生。
上面展示的只读页面表条目并不意味着映射是只读的，它只是内核的一个用于共享物理内存的技巧，直到尽可能的最后一刻之前。你可以认为“私有”一词用的有点不太恰当，你只需要记住，这个“私有”仅用于更新的情况。这种设计的重要性在于，要想看到被映射的文件的变化，其它程序只能读取它的虚拟页面。一旦“写时复制”发生，从其它地方是看不到这种变化的。但是，内核并不能保证这种行为，因为它是在 x86 中实现的，从 API 的角度来看，这是有意义的。相比之下，一个共享的映射只是将它简单地映射到页面缓存上。更新会被所有的进程看到并被写入到磁盘上。最终，如果上面的映射是只读的，页面故障将触发一个内存段失败而不是写到一个副本。
动态加载库是通过文件映射融入到你的程序的地址空间中的。这没有什么可奇怪的，它通过普通的 API 为你提供与私有文件映射相同的效果。下面的示例展示了映射文件的 `render` 程序的两个实例运行的地址空间的一部分，以及物理内存，尝试将我们看到的许多概念综合到一起。
这是内存架构系列的第三部分的结论。我希望这个系列文章对你有帮助，对理解操作系统的这些主题提供一个很好的思维模型。
---
via:<https://manybutfinite.com/post/page-cache-the-affair-between-memory-and-files/>
作者：[Gustavo Duarte](http://duartes.org/gustavo/blog/about/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 PGP 保护代码完整性（二）：生成你的主密钥
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/learn/PGP/2018/2/protecting-code-integrity-pgp-part-2-generating-and-protecting-your-master-pgp-key
|
在本文中，我们将展示如何生成和保护你的 PGP 主密钥。
|
/data/attachment/album/201804/09/081224rr6791g97zo62917.png.thumb.jpg
|
/data/attachment/album/201804/09/081224rr6791g97zo62917.png
| true | false | true |
kimii
| false |
[
"PGP",
"GPG"
] |
技术
|
{
"viewnum": 9051,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9524,
"displayorder": 0
},
{
"raid": 9607,
"displayorder": 0
}
] |
在本文中，我们将展示如何生成和保护你的 PGP 主密钥。
| 2018-04-09T08:12:00 | 2018-04-09T08:12:00 | 9,529 |
/article-9529-1.html
|
在本系列文章中，我们将深度探讨如何使用 PGP 以及为工作于自由软件项目的开发者提供实用指南。在前一篇文章中，我们介绍了[基本工具和概念](/article-9524-1.html)。在本文中，我们将展示如何生成和保护你的 PGP 主密钥。
#### 清单
1. 生成一个 4096 位的 RSA 主密钥 （必要）
2. 使用 paperkey 备份你的 RSA 主密钥 （必要）
3. 添加所有相关的身份 （必要）
#### 考虑事项
##### 理解“主”（认证）密钥
在本节和下一节中，我们将讨论“主密钥”和“子密钥”。理解以下内容很重要：
1. 在“主密钥”和“子密钥”之间没有技术上的区别。
2. 在创建时，我们赋予每个密钥特定的能力来分配功能限制。
3. 一个 PGP 密钥有四项能力
* [S] 密钥可以用于签名
* [E] 密钥可以用于加密
* [A] 密钥可以用于身份认证
* [C] 密钥可以用于认证其他密钥
4. 一个密钥可能有多种能力
带有 [C] （认证）能力的密钥被认为是“主”密钥，因为它是唯一可以用来表明与其他密钥关系的密钥。只有 [C] 密钥可以被用于：
* 添加或撤销其他密钥（子密钥）的 S/E/A 能力
* 添加、更改或撤销密钥关联的身份（uid）
* 添加或更改本身或其他子密钥的到期时间
* 为了网络信任目的为其它密钥签名
在自由软件的世界里，[C] 密钥就是你的数字身份。一旦你创建该密钥，你应该格外小心地保护它并且防止它落入坏人的手中。
#### 在你创建主密钥前
在你创建的你的主密钥前，你需要选择你的主要身份和主密码。
##### 主要身份
身份使用邮件中发件人一栏相同格式的字符串：
```
Alice Engineer <alice.engineer@example.org>
```
你可以在任何时候创建新的身份，取消旧的，并且更改你的“主要”身份。由于主要身份在所有 GnuPG 操作中都展示，你应该选择正式的和最有可能用于 PGP 保护通信的名字和邮件地址，比如你的工作地址或者用于在项目<ruby> 提交 <rt> commit </rt></ruby>时签名的地址。
##### 密码
<ruby> 密码 <rt> passphrase </rt></ruby>专用于私钥存储在磁盘上时使用对称加密算法对其进行加密。如果你的 `.gnupg` 目录的内容被泄露，那么一个好的密码就是小偷能够在线假冒你的最后一道防线，这就是为什么设置一个好的密码很重要的原因。
一个强密码最好使用丰富或混合的词典的 3-4 个词，而不引用自流行来源（歌曲、书籍、口号）。由于你将相当频繁地使用该密码，所以它应当易于输入和记忆。
##### 算法和密钥强度
尽管现在 GnuPG 已经支持椭圆曲线加密一段时间了，但我们仍坚持使用 RSA 密钥，至少较长一段时间会这样。虽然现在就可以开始使用 ED25519 密钥，但你可能会碰到无法正确处理它们的工具和硬件设备。
在后续的指南中我们说 2048 位的密钥对 RSA 公钥加密的生命周期已经足够，你可能也会好奇主密钥为什么是 4096 位。 原因很大程度是由于社会因素而非技术上的：主密钥在密钥链上是最显眼的，如果你的主密钥位数比一些和你交互的开发者的少，他们肯定会鄙视你。
#### 生成主密钥
为了生成你的主密钥，请使用以下命令，并且将 “Alice Engineer” 替换为正确值。
```
$ gpg --quick-generate-key 'Alice Engineer <alice@example.org>' rsa4096 cert
```
这将弹出一个要求输入密码的对话框。然后，你可能需要移动鼠标或随便按一些键才能生成足够的熵，直到该命令完成。
查看命令输出，它就像这样：
```
pub rsa4096 2017-12-06 [C] [expires: 2019-12-06]
111122223333444455556666AAAABBBBCCCCDDDD
uid Alice Engineer <alice@example.org>
```
注意第二行的长字符串 —— 它是你新生成的密钥的完整指纹。密钥 ID（Key ID）可以用以下三种不同形式表达：
* <ruby> 指纹 <rt> Fingerprint </rt></ruby>，一个完整的 40 个字符的密钥标识符
* <ruby> 长密钥 ID <rt> Long </rt></ruby>，指纹的最后 16 个字符（AAAABBBBCCCCDDDD）
* <ruby> 短密钥 ID <rt> Short </rt></ruby>，指纹的最后 8 个字符（CCCCDDDD）
你应该避免使用 8 个字符的短密钥 ID，因为它们不足够唯一。
这里，我建议你打开一个文本编辑器，复制你新密钥的指纹并粘贴。你需要在接下来几步中用到它，所以将它放在旁边会很方便。
#### 备份你的主密钥
出于灾后恢复的目的 —— 同时特别的如果你试图使用 Web of Trust 并且收集来自其他项目开发者的密钥签名 —— 你应该创建你的私钥的硬拷贝备份。万一所有其它的备份机制都失败了，这应当是最后的补救措施。
创建一个你的私钥的可打印的硬拷贝的最好方法是使用为此而写的软件 `paperkey`。`paperkey` 在所有 Linux 发行版上可用，在 Mac 上也可以通过 brew 安装 `paperkey`。
运行以下命令，用你密钥的完整指纹替换 `[fpr]`：
```
$ gpg --export-secret-key [fpr] | paperkey -o /tmp/key-backup.txt
```
输出将采用易于 OCR 或手动输入的格式，以防如果你需要恢复它的话。打印出该文件，然后拿支笔，并在纸的边缘写下密钥的密码。这是必要的一步，因为密钥输出仍然使用密码加密，并且如果你更改了密钥的密码，你不会记得第一次创建的密钥是什么 —— 我保证。
将打印结果和手写密码放入信封中，并存放在一个安全且保护好的地方，最好远离你家，例如银行保险库。
**打印机注意事项** 打印机连接到计算机的并行端口的时代已经过去了。现在他们拥有完整的操作系统，硬盘驱动器和云集成。由于我们发送给打印机的关键内容将使用密码进行加密，因此这是一项相当安全的操作，但请使用您最好的偏执判断。
#### 添加相关身份
如果你有多个相关的邮件地址（个人、工作、开源项目等），你应该将其添加到主密钥中。你不需要为任何你不希望用于 PGP 的地址（例如，可能不是你的校友地址）这样做。
该命令是（用你完整的密钥指纹替换 `[fpr]`）：
```
$ gpg --quick-add-uid [fpr] 'Alice Engineer <allie@example.net>'
```
你可以查看你已经使用的 UID：
```
$ gpg --list-key [fpr] | grep ^uid
```
#### 选择主 UID
GnuPG 将会把你最近添加的 UID 作为你的主 UID，如果这与你想的不同，你应该改回来：
```
$ gpg --quick-set-primary-uid [fpr] 'Alice Engineer <alice@example.org>'
```
下次，我们将介绍如何生成 PGP 子密钥，它是你实际用于日常工作的密钥。
通过 Linux 基金会和 edX 的免费[“Introduction to Linux”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 课程了解关于 Linux 的更多信息。
---
via: <https://www.linux.com/blog/learn/PGP/2018/2/protecting-code-integrity-pgp-part-2-generating-and-protecting-your-master-pgp-key>
作者：[KONSTANTIN RYABITSEV](https://www.linux.com/users/mricon) 译者：[kimii](https://github.com/kimii) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何解决 “mount.nfs: Stale file handle”错误
|
Kerneltalks
|
https://kerneltalks.com/troubleshooting/resolve-mount-nfs-stale-file-handle-error/
|
了解如何解决 Linux 平台上的 mount.nfs: Stale file handle 错误。这个 NFS 错误可以在客户端或者服务端解决。
|
/data/attachment/album/201804/09/214625b5d8hqh1re1b1uhs.jpg.thumb.jpg
|
/data/attachment/album/201804/09/214625b5d8hqh1re1b1uhs.jpg
| true | false | true |
geekpi
| false |
[
"NFS"
] |
技术
|
{
"viewnum": 39313,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
了解如何解决 Linux 平台上的 mount.nfs: Stale file handle 错误。这个 NFS 错误可以在客户端或者服务端解决。
| 2018-04-09T21:46:31 | 2018-04-09T21:46:31 | 9,530 |
/article-9530-1.html
|
>
> 了解如何解决 Linux 平台上的 `mount.nfs: Stale file handle` 错误。这个 NFS 错误可以在客户端或者服务端解决。
>
>
>
当你在你的环境中使用网络文件系统时，你一定不时看到 `mount.nfs：Stale file handle` 错误。此错误表示 NFS 共享无法挂载，因为自上次配置后有些东西已经更改。
无论是你重启 NFS 服务器或某些 NFS 进程未在客户端或服务器上运行，或者共享未在服务器上正确输出，这些都可能是导致这个错误的原因。此外，当这个错误发生在先前挂载的 NFS 共享上时，它会令人不快。因为这意味着配置部分是正确的，因为是以前挂载的。在这种情况下，可以尝试下面的命令：
确保 NFS 服务在客户端和服务器上运行良好。
```
# service nfs status
rpc.svcgssd is stopped
rpc.mountd (pid 11993) is running...
nfsd (pid 12009 12008 12007 12006 12005 12004 12003 12002) is running...
rpc.rquotad (pid 11988) is running...
```
如果 NFS 共享目前挂载在客户端上，则强制卸载它并尝试在 NFS 客户端上重新挂载它。通过 `df` 命令检查它是否正确挂载，并更改其中的目录。
```
# umount -f /mydata_nfs
# mount -t nfs server:/nfs_share /mydata_nfs
#df -k
------ output clipped -----
server:/nfs_share 41943040 892928 41050112 3% /mydata_nfs
```
在上面的挂载命令中，服务器可以是 NFS 服务器的 IP 或[主机名](https://kerneltalks.com/linux/all-you-need-to-know-about-hostname-in-linux/)。
如果你在强制取消挂载时遇到像下面错误：
```
# umount -f /mydata_nfs
umount2: Device or resource busy
umount: /mydata_nfs: device is busy
umount2: Device or resource busy
umount: /mydata_nfs: device is busy
```
然后你可以用 `lsof` 命令来检查哪个进程或用户正在使用该挂载点，如下所示：
```
# lsof |grep mydata_nfs
lsof: WARNING: can't stat() nfs file system /mydata_nfs
Output information may be incomplete.
su 3327 root cwd unknown /mydata_nfs/dir (stat: Stale NFS file handle)
bash 3484 grid cwd unknown /mydata_nfs/MYDB (stat: Stale NFS file handle)
bash 20092 oracle11 cwd unknown /mydata_nfs/MPRP (stat: Stale NFS file handle)
bash 25040 oracle11 cwd unknown /mydata_nfs/MUYR (stat: Stale NFS file handle)
```
如果你在上面的示例中看到共有 4 个 PID 正在使用该挂载点上的某些文件。尝试杀死它们以释放挂载点。完成后，你将能够正确卸载它。
有时 `mount` 命令会有相同的错误。接着使用下面的命令在客户端重启 NFS 服务后挂载。
```
# service nfs restart
Shutting down NFS daemon: [ OK ]
Shutting down NFS mountd: [ OK ]
Shutting down NFS quotas: [ OK ]
Shutting down RPC idmapd: [ OK ]
Starting NFS services: [ OK ]
Starting NFS quotas: [ OK ]
Starting NFS mountd: [ OK ]
Starting NFS daemon: [ OK ]
```
另请阅读：[如何在 HPUX 中逐步重启 NFS](http://kerneltalks.com/hpux/restart-nfs-in-hpux/)
即使这没有解决你的问题，最后一步是在 NFS 服务器上重启服务。警告！这将断开从该 NFS 服务器输出的所有 NFS 共享。所有客户端将看到挂载点断开。这一步将 99％ 解决你的问题。如果没有，请务必检查 [NFS 配置](http://kerneltalks.com/linux/nfs-configuration-linux-hpux/)，提供你修改的配置并发布你启动时看到的错误。
上面文章中的输出来自 RHEL6.3 服务器。请将你的评论发送给我们。
---
via: <https://kerneltalks.com/troubleshooting/resolve-mount-nfs-stale-file-handle-error/>
作者：[KernelTalks](https://kerneltalks.com) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 中的 5 个 SSH 别名例子
|
Surendra Anne
|
https://www.linuxnix.com/5-ssh-alias-examples-using-ssh-config-file/
|
我们可以用 定义在你的 .bashrc 文件里的别名 或函数来大幅度缩减花在命令行界面（CLI）的时间。但这不是最佳解决之道。最佳办法是在 ssh 配置文件中使用 SSH 别名 。
|
/data/attachment/album/201804/09/224622yjn5gzaacg86mymc.png.thumb.jpg
|
/data/attachment/album/201804/09/224622yjn5gzaacg86mymc.png
| true | false | true |
ch-cn
| false |
[
"SSH",
"别名"
] |
技术
|
{
"viewnum": 7148,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们可以用 定义在你的 .bashrc 文件里的别名 或函数来大幅度缩减花在命令行界面（CLI）的时间。但这不是最佳解决之道。最佳办法是在 ssh 配置文件中使用 SSH 别名 。
| 2018-04-09T22:46:53 | 2018-04-09T22:46:53 | 9,531 |
/article-9531-1.html
|
作为一个 Linux 用户，我们常用 [ssh 命令](https://www.linuxnix.com/ssh-access-remote-linux-server/) 来登入远程机器。`ssh` 命令你用得越多，你在键入一些重要的命令上花的时间也越多。我们可以用 [定义在你的 .bashrc 文件里的别名](https://www.linuxnix.com/linux-alias-command-explained-with-examples/) 或函数来大幅度缩减花在命令行界面（CLI）的时间。但这不是最佳解决之道。最佳办法是在 `ssh` 配置文件中使用 **SSH 别名** 。
这里是我们能把 `ssh` 命令用得更好的几个例子。
ssh 登入到 AWS（译注：Amazon Web Services，亚马逊公司旗下云计算服务平台）实例的连接是一种痛。仅仅输入以下命令，每次也完全是浪费你时间。
```
ssh -p 3000 -i /home/surendra/mysshkey.pem ec2-user@ec2-54-20-184-202.us-west-2.compute.amazonaws.com
```
缩短到：
```
ssh aws1
```
调试时连接到系统。
```
ssh -vvv the_good_user@red1.taggle.abc.com.au
```
缩短到：
```
ssh xyz
```
在本篇中，我们将看到如何不使用 bash 别名或函数实现 `ssh` 命令的缩短。`ssh` 别名的主要优点是所有的 `ssh` 命令快捷方式都存储在一个单一文件，如此就易于维护。其他优点是 **对于类似于 SSH 和 SCP 的命令** 我们能用相同的别名。
在我们进入实际配置之前，我们应该知道 `/etc/ssh/ssh_config`、`/etc/ssh/sshd_config` 和 `~/.ssh/config` 文件三者的区别。以下是对这些文件的解释。
### /etc/ssh/ssh\_config 和 ~/.ssh/config 间的区别
系统级别的 SSH 配置项存放在 `/etc/ssh/ssh_config`，而用户级别的 SSH 配置项存放在 `~/.ssh/config` 文件中。
### /etc/ssh/ssh*config 和 /etc/ssh/sshd*config 间的区别
系统级别的 SSH 配置项是在 `/etc/ssh/ssh_config` 文件中，而系统级别的 SSH **服务端**配置项存放在 `/etc/ssh/sshd_config` 文件。
### 在 ~/.ssh/config 文件里配置项的语法
`~/.ssh/config` 文件内容的语法：
```
配置项 值
配置项 值1 值2
```
**例 1：** 创建主机（www.linuxnix.com）的 SSH 别名
编辑 `~/.ssh/config` 文件写入以下内容：
```
Host tlj
User root
HostName 18.197.176.13
port 22
```
保存此文件。
以上 ssh 别名用了
1. `tlj` 作为一个别名的名称
2. `root` 作为将要登入的用户
3. `18.197.176.13` 作为主机的 IP 地址
4. `22` 作为访问 SSH 服务的端口
输出：
```
sanne@Surendras-MacBook-Pro:~ > ssh tlj
Welcome to Ubuntu 16.04.3 LTS (GNU/Linux 4.4.0-93-generic x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
Get cloud support with Ubuntu Advantage Cloud Guest:
http://www.ubuntu.com/business/services/cloud
Last login: Sat Oct 14 01:00:43 2017 from 20.244.25.231
root@linuxnix:~# exit
logout
Connection to 18.197.176.13 closed.
```
**例 2：** 不用密码用 ssh 密钥登到系统要用 `IdentityFile` 。
例：
```
Host aws
User ec2-users
HostName ec2-54-200-184-202.us-west-2.compute.amazonaws.com
IdentityFile ~/Downloads/surendra.pem
port 22
```
**例 3：** 对同一主机使用不同的别名。在下例中，我们对同一 IP/主机 18.197.176.13 用了 `tlj`、 `linuxnix`、`linuxnix.com` 三个别名。
~/.ssh/config 文件内容
```
Host tlj linuxnix linuxnix.com
User root
HostName 18.197.176.13
port 22
```
**输出：**
```
sanne@Surendras-MacBook-Pro:~ > ssh tlj
Welcome to Ubuntu 16.04.3 LTS (GNU/Linux 4.4.0-93-generic x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
Get cloud support with Ubuntu Advantage Cloud Guest:
http://www.ubuntu.com/business/services/cloud
Last login: Sat Oct 14 01:00:43 2017 from 220.244.205.231
root@linuxnix:~# exit
logout
Connection to 18.197.176.13 closed.
sanne@Surendras-MacBook-Pro:~ > ssh linuxnix.com
Welcome to Ubuntu 16.04.3 LTS (GNU/Linux 4.4.0-93-generic x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
```
```
Get cloud support with Ubuntu Advantage Cloud Guest:
http://www.ubuntu.com/business/services/cloud
Last login: Sun Oct 15 20:31:08 2017 from 1.129.110.13
root@linuxnix:~# exit
logout
Connection to 138.197.176.103 closed.
[6571] sanne@Surendras-MacBook-Pro:~ > ssh linuxnix
Welcome to Ubuntu 16.04.3 LTS (GNU/Linux 4.4.0-93-generic x86_64)
* Documentation: https://help.ubuntu.com
* Management: https://landscape.canonical.com
* Support: https://ubuntu.com/advantage
Get cloud support with Ubuntu Advantage Cloud Guest:
http://www.ubuntu.com/business/services/cloud
Last login: Sun Oct 15 20:31:20 2017 from 1.129.110.13
root@linuxnix:~# exit
logout
Connection to 18.197.176.13 closed.
```
**例 4：** 用相同的 SSH 别名复制文件到远程系统
语法：
```
scp <文件名> <ssh_别名>:<位置>
```
例子：
```
sanne@Surendras-MacBook-Pro:~ > scp abc.txt tlj:/tmp
abc.txt 100% 12KB 11.7KB/s 00:01
sanne@Surendras-MacBook-Pro:~ >
```
若我们已经将 ssh 主机设置好一个别名，由于 `ssh` 和 `scp` 两者用几乎相同的语法和选项，`scp` 也可以轻易使用。
请在下面尝试从本机 `scp` 一个文件到远程机器。
**例 5：** 解决 Linux 中的 SSH 超时问题。默认情况，如果你不积极地使用终端，你的 ssh 登入就会超时
[SSH 超时问题](https://www.linuxnix.com/how-to-auto-logout/) 是一个更痛的点意味着你在一段时间后不得不重新登入到远程机器。我们能在 `~/.ssh/config` 文件里边恰当地设置 SSH 超时时间来使你的会话不管在什么时间总是激活的。我们将用 2 个能保持会话存活的 SSH 选项来实现这一目的。之一是 `ServerAliveInterval` 保持你会话存活的秒数和 `ServerAliveCountMax` 在（经历了一个）给定数值的会话之后初始化会话。
```
ServerAliveInterval A
ServerAliveCountMax B
```
**例：**
```
Host tlj linuxnix linuxnix.com
User root
HostName 18.197.176.13
port 22
ServerAliveInterval 60
ServerAliveCountMax 30
```
在下篇中我们将会看到一些其他的退出方式。
---
via: <https://www.linuxnix.com/5-ssh-alias-examples-using-ssh-config-file/>
作者：[SURENDRA ANNE](https://www.linuxnix.com) 译者：[ch-cn](https://github.com/ch-cn) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
区块链不适用的若干场景
|
Mike Bursell
|
https://opensource.com/article/18/3/3-tests-not-moving-blockchain
|
这三个问题可以帮你避开不实宣传。
|
/data/attachment/album/201804/10/160115nbh05s7q56psbzag.jpg.thumb.jpg
|
/data/attachment/album/201804/10/160115nbh05s7q56psbzag.jpg
| true | false | true |
pinewall
| false |
[
"区块链"
] |
观点
|
{
"viewnum": 4262,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
这三个问题可以帮你避开不实宣传。
| 2018-04-10T16:01:22 | 2018-04-10T16:01:22 | 9,532 |
/article-9532-1.html
|
>
> 这三个问题可以帮你避开不实宣传。
>
>
>
不错，“区块链”这个概念异常的火热。
众所周知，我一直关注区块链及相关技术的成熟度发展情况，思考我们是否对其评价过高了；但从目前的情况来看，还没有这个迹象。我在文中提到的区块链技术是广义上的，包含了狭义上不属于区块链的分布式账本技术（DLT）。我对私有链permissioned blockchain更感兴趣，其中私有链的定义可以参考我的文章《[区块链是安全性方面的话题吗？](https://opensource.com/article/17/12/blockchain-security-topic)》。简而言之，我对加密货币之外的区块链业务应用特别感兴趣<sup> <a href="#footnote1"> 注1 </a></sup> 。
我们对区块链的技术成熟度的判断应该有一部分可以得到证实<sup> <a href="#footnote2"> 注2 </a></sup> 。如果我们判断正确，未来将会出现海量的区块链应用。这很可能会变成现实，但并不是所有的应用都是优秀的区块链应用，其中一部分很可能是非常糟糕的。
但区块链所处的技术成熟度意味着，大量业务将快速拥抱新技术<sup> <a href="#footnote3"> 注3 </a></sup> ，但对于可能的前景却一知半解。促成这种情况的原因可以大致分为三种：
1. 对于涉及多用户数据存储的业务应用，在投入精力的情况下，几乎都可以改造为基于区块链的版本；
2. 很多区块链相关的会议和“专家”呼吁尽快拥抱区块链，否则可能会在半年内被淘汰<sup> <a href="#footnote4"> 注4 </a></sup> ；
3. 完全理解区块链技术是很难的，支持其在企业中落地的往往是工程师。
对于最后一条，我必须补充几句，不然很容易被引起众怒<sup> <a href="#footnote5"> 注5 </a></sup> 。作为一名工程师，我显然无意贬低工程师。但工程师的天性使然，我们对见到的新鲜事物（亮点）热情澎湃，却对业务本身<ruby> 深入 <rt> fully grok </rt></ruby><sup> <a href="#footnote6"> 注6 </a></sup> 不足，故对于新技术给业务带来的影响理解可能并不深刻。在业务领导者看来，这些影响不一定是有利的。
上面提到的三种促因可能导致一种风险，即在没有充分评估利弊的情况下，将业务改造为区块链应用。在另一文（[区块链：每个人都应该参与进来吗？](https://aliceevebob.com/2017/09/12/blockchain-should-we-all-play/)）中提到几个场景，用于判断一个业务什么情况下适合采用区块链技术。这些场景是有益的，但更进一步，我坚信人们更加需要的是，业务完全不适用区块链的几种简单的场景判定。我总结了三种场景判定，如果对于其中任何一个问题你给出了肯定的回答，那么很大概率上区块链不适合你。
### 场景判定 1：业务是否需要集中式的管控或授权？
如果你给出了肯定的回答，那么区块链不适合你。
例如，假设你是一个普通销售商，具有唯一的订单系统，那么对于何时发货你有唯一的授权，显然区块链不适合你。假设你是一个内容提供商，所有提供的内容都会经过唯一的编辑和发布过程，显然区块链不适合你。
**经验总结：只有当任务对应的执行流程及相应的认证流程是分布于众多主体时，区块链是有价值的。**
### 场景判定 2：业务使用经典数据库是否工作良好？
如果你给出了肯定的回答，那么区块链不适合你。
该场景似乎与上一个场景是强相关的，但并不总是如此。在一些应用中，处理流程是分布的，但信息存储是中心化的；在另外一些应用中，处理流程需要中心化的授权，但信息存储是分布的，即总有一个并不是分布式的。但如果业务使用经典数据库可以工作量良好的话，使用经典数据库是一个好主意。
经典数据库不仅性能良好，在设计与运营成本方面低比区块链或分布式账本，而且我们在这方面技术积累丰厚。区块链让所有人<sup> <a href="#footnote8"> 注8 </a></sup> 可以查看和持有数据，但间接成本和潜在成本都比较高昂。
### 场景判定 3：业务采用新技术是否成本高昂或对合作伙伴有负面效果？
如果你给出了肯定的回答，那么区块链不适合你。
我曾听过这种观点，即区块链会让所有人获益。但这显然是不可能的。假设你正在为某个流程设计一个应用，改变合作伙伴与你及应用的交互方式，那么你需要判断这个改变是否符合合作伙伴的想法。不论是否涉及区块链，可以很容易的设计并引入一个应用，虽然降低了你自己的业务阻力，但与此同时增加了合作伙伴的业务阻力。
假设我为汽车行业生产发动机配件，那么使用区块链追溯和管理配件会让我受益匪浅。例如，我可以查看购买的滚珠轴承的生产商、生产时间和钢铁材料供应商等。换一个角度，假设我是滚珠轴承生产商，已经为40多个客户公司建立了处理流程。为一家客户引入新的流程会涉及工作方式、系统体系、储藏和安全性标准等方面的变更，这无法让我感兴趣，相反，这会导致复杂性和高开销。
### 总结
这几个场景判定用于提纲挈领，并不是一成不变的。其中数据库相关的那个场景判定更像是技术方面的，但也是紧密结合业务定位和功能的。希望这几个判定可以为区块链技术引进促因带来的过热进行降温。
* 注 1. 请不要误解我的意思，加密货币显然是一种有趣的区块链业务应用，只是不在本文的讨论范畴而已。
* 注 2. 知道具体是哪些部分是很有意义的，如果你知道，请告诉我好吗？
* 注 3. 坦率的说，它其实更像是一大堆技术的集合体。
* 注 4. 这显然是不太可能的，如果被淘汰的主体是这些会议和“专家”本身倒十分有可能。
* 注 5. 由于比方打得有些不恰当，估计还是会引起众怒。
* 注 6. 我太喜欢 grok 这个单词了，我把它放在这里作为我的工程师标志<sup> <a href="#footnote7"> 注7 </a></sup> 。
* 注 7. 你可能已经想到了，我读过*Stranger in a Strange Land*一书，包括删减版和原版。
* 注 8. 在合理的情况下。
原文最初发表于[爱丽丝, 夏娃和鲍勃 – 一个安全性主题博客](https://aliceevebob.com/2018/02/13/3-tests-for-not-moving-to-blockchain/)，已获得转载许可。
---
via: <https://opensource.com/article/18/3/3-tests-not-moving-blockchain>
作者：[Mike Bursell](https://opensource.com/users/mikecamel) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
深度学习战争：Facebook 支持的 PyTorch 与 Google 的 TensorFlow
|
Savia Lobo
|
https://datahub.packtpub.com/deep-learning/dl-wars-pytorch-vs-tensorflow/
|
在这篇文章中，我们将 PyTorch 与 TensorFlow 进行不同方面的比较。
|
/data/attachment/album/201804/10/163647s8mxuuz8anjt8j7n.jpg.thumb.jpg
|
/data/attachment/album/201804/10/163647s8mxuuz8anjt8j7n.jpg
| true | false | true |
Wuod3n
| false |
[
"深度学习",
"TensorFlow",
"DL",
"PyTorch"
] |
技术
|
{
"viewnum": 6110,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我们将 PyTorch 与 TensorFlow 进行不同方面的比较。
| 2018-04-11T15:34:00 | 2018-04-11T15:34:00 | 9,533 |
/article-9533-1.html
|
有一个令人震惊的事实，即人工智能和机器学习的工具和技术在近期迅速兴起。深度学习，或者说“注射了激素的机器学习”，数据科学家和机器学习专家在这个领域有数不胜数等可用的库和框架。很多这样的框架都是基于 Python 的，因为 Python 是一个更通用，相对简单的语言。[Theano](https://www.packtpub.com/web-development/deep-learning-theano)、[Keras](https://www.packtpub.com/big-data-and-business-intelligence/deep-learning-keras)、 [TensorFlow](https://www.packtpub.com/big-data-and-business-intelligence/deep-learning-tensorflow) 是几个基于 Python 构建的流行的深度学习库，目的是使机器学习专家更轻松。
Google 的 TensorFlow 是一个被广泛使用的机器学习和深度学习框架。 TensorFlow 开源于 2015 年，得到了机器学习专家社区的广泛支持，TensorFlow 已经迅速成长为许多机构根据其机器学习和深度学习等需求而选择的框架。 另一方面，PyTorch 是由 Facebook 最近开发的用于训练神经网络的 Python 包，改编自基于 Lua 的深度学习库 Torch。 PyTorch 是少数可用的深度学习框架之一，它使用<ruby> 基于磁带的自动梯度系统 <rt> tape-based autograd system </rt></ruby>，以快速和灵活的方式构建动态神经网络。
在这篇文章中，我们将 PyTorch 与 TensorFlow 进行不同方面的比较。
让我们开始吧！
### 什么编程语言支持 PyTorch 和 TensorFlow？
虽然主要是用 C++ 和 CUDA 编写的，但 TensorFlow 包含一个位于核心引擎上的 Python API，使得更便于被<ruby> Python 支持者 <rt> Pythonistas </rt></ruby>使用。 除了 Python，它还包括 C++、Haskell、Java、Go 和 Rust 等其他 API，这意味着开发人员可以用他们的首选语言进行编码。
虽然 PyTorch 是一个 Python 软件包，但你也可以提供使用基本的 C/C++ 语言的 API 进行编码。 如果你习惯使用 Lua 编程语言，你也可以使用 Torch API 在 PyTorch 中编写神经网络模型。
### PyTorch 和 TensorFlow 有多么易于使用？
如果将 TensorFlow 作为一个独立的框架使用，它可能会有点复杂，并且会给深度学习模型的训练带来一些困难。 为了减少这种复杂性，可以使用位于 TensorFlow 复杂引擎之上的 Keras 封装，以简化深度学习模型的开发和训练。 TensorFlow 也支持 PyTorch 目前没有的[分布式培训](https://www.tensorflow.org/deploy/distributed)。 由于包含 Python API，TensorFlow 也可以在生产环境中使用，即可用于培训练和部署企业级深度学习模型。
PyTorch 由于 Torch 的复杂用 Python 重写。 这使得 PyTorch 对于开发人员更为原生。 它有一个易于使用的框架，提供最大化的灵活和速度。 它还允许在训练过程中快速更改代码而不妨碍其性能。 如果你已经有了一些深度学习的经验，并且以前使用过 Torch，那么基于它的速度、效率和易用性，你会更喜欢 PyTorch。 PyTorch 包含定制的 GPU 分配器，这使得深度学习模型具有更高的内存效率。 由此，训练大型深度学习模型变得更容易。 因此，Pytorch 在 Facebook、Twitter、Salesforce 等大型组织广受欢迎。
### 用 PyTorch 和 TensorFlow 训练深度学习模型
PyTorch 和 TensorFlow 都可以用来建立和训练神经网络模型。
TensorFlow 工作于 SCG（静态计算图）上，包括在模型开始执行之前定义静态图。 但是，一旦开始执行，在模型内的调整更改的唯一方法是使用 [tf.session 和 tf.placeholder 张量](https://www.tensorflow.org/versions/r0.12/get_started/basic_usage)。
PyTorch 非常适合训练 RNN（递归神经网络），因为它们在 [PyTorch](https://www.reddit.com/r/MachineLearning/comments/66rriz/d_rnns_are_much_faster_in_pytorch_than_tensorflow/) 中比在 TensorFlow 中运行得更快。 它适用于 DCG（动态计算图），可以随时在模型中定义和更改。 在 DCG 中，每个模块可以单独调试，这使得神经网络的训练更简单。
TensorFlow 最近提出了 TensorFlow Fold，这是一个旨在创建 TensorFlow 模型的库，用于处理结构化数据。 像 PyTorch 一样，它实现了 DCG，在 CPU 上提供高达 10 倍的计算速度，在 GPU 上提供超过 100 倍的计算速度！ 在 [Dynamic Batching](https://arxiv.org/abs/1702.02181) 的帮助下，你现在可以执行尺寸和结构都不相同的深度学习模型。
### GPU 和 CPU 优化的比较
TensorFlow 的编译时间比 PyTorch 短，为构建真实世界的应用程序提供了灵活性。 它可以从 CPU、GPU、TPU、移动设备到 Raspberry Pi（物联网设备）等各种处理器上运行。
另一方面，PyTorch 包括<ruby> 张量 <rt> tensor </rt></ruby>计算，可以使用 GPU 将深度神经网络模型加速到 [50 倍或更多](https://github.com/jcjohnson/pytorch-examples#pytorch-tensors)。 这些张量可以停留在 CPU 或 GPU 上。 CPU 和 GPU 都是独立的库， 无论神经网络大小如何，PyTorch 都可以高效地利用。
### 社区支持
TensorFlow 是当今最流行的深度学习框架之一，由此也给它带来了庞大的社区支持。 它有很好的文档和一套详细的在线教程。 TensorFlow 还包括许多预先训练过的模型，这些模型托管和提供于 [GitHub](https://github.com/tensorflow/models)。 这些模型提供给热衷于使用 TensorFlow 开发者和研究人员一些现成的材料来节省他们的时间和精力。
另一方面，PyTorch 的社区相对较小，因为它最近才发展起来。 与 TensorFlow 相比，文档并不是很好，代码也不是很容易获得。 然而，PyTorch 确实允许个人与他人分享他们的预训练模型。
### PyTorch 和 TensorFlow —— 力量悬殊的故事
就目前而言，由于各种原因，TensorFlow 显然比 PyTorch 更受青睐。
TensorFlow 很大，经验丰富，最适合实际应用。 是大多数机器学习和深度学习专家明显的选择，因为它提供了大量的功能，最重要的是它在市场上的成熟应用。 它具有更好的社区支持以及多语言 API 可用。 它有一个很好的文档库，由于从准备到使用的代码使之易于生产。 因此，它更适合想要开始深度学习的人，或者希望开发深度学习模型的组织。
虽然 PyTorch 相对较新，社区较小，但它速度快，效率高。 总之，它给你所有的优势在于 Python 的有用性和易用性。 由于其效率和速度，对于基于研究的小型项目来说，这是一个很好的选择。 如前所述，Facebook、Twitter 等公司正在使用 PyTorch 来训练深度学习模型。 但是，使用它尚未成为主流。 PyTorch 的潜力是显而易见的，但它还没有准备好去挑战这个 TensorFlow 野兽。 然而，考虑到它的增长，PyTorch 进一步优化并提供更多功能的日子并不遥远，直到与 TensorFlow可以 比较。
作者： Savia Lobo，非常喜欢数据科学。 喜欢更新世界各地的科技事件。 喜欢歌唱和创作歌曲。 相信才智上的艺术。
---
via: <https://datahub.packtpub.com/deep-learning/dl-wars-pytorch-vs-tensorflow/>
作者：[Savia Lobo](https://datahub.packtpub.com/author/savial/) 译者：[Wuod3n](https://github.com/Wuod3n) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Graylog 和 Prometheus 监视 Kubernetes 集群
|
Kevin Monroe
|
https://insights.ubuntu.com/2018/01/16/monitor-your-kubernetes-cluster/
|
在本文中，我将使用 Graylog （用于日志）和 Prometheus （用于指标）去打造一个 Kubernetes 集群的监视解决方案。
|
/data/attachment/album/201804/10/182842hu1toaq9hhh9uiou.png.thumb.jpg
|
/data/attachment/album/201804/10/182842hu1toaq9hhh9uiou.png
| true | false | true |
qhwdw
| false |
[
"Kubernetes",
"监控"
] |
容器与云
|
{
"viewnum": 7906,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本文中，我将使用 Graylog （用于日志）和 Prometheus （用于指标）去打造一个 Kubernetes 集群的监视解决方案。
| 2018-04-10T18:28:32 | 2018-04-10T18:28:32 | 9,534 |
/article-9534-1.html
|
这篇文章最初发表在 [Kevin Monroe 的博客](https://medium.com/@kwmonroe/monitor-your-kubernetes-cluster-a856d2603ec3) 上。
监视日志和指标状态是集群管理员的重点工作。它的好处很明显：指标能帮你设置一个合理的性能目标，而日志分析可以发现影响你工作负载的问题。然而，困难的是如何找到一个与大量运行的应用程序一起工作的监视解决方案。
在本文中，我将使用 [Graylog](https://www.graylog.org/) （用于日志）和 [Prometheus](https://prometheus.io/) （用于指标）去打造一个 Kubernetes 集群的监视解决方案。当然了，这不仅是将三个东西连接起来那么简单，实现上，最终结果看起来应该如题图所示：
正如你所了解的，Kubernetes 不是一件东西 —— 它由主控节点、工作节点、网络连接、配置管理等等组成。同样，Graylog 是一个配角（apache2、mongodb、等等），Prometheus 也一样（telegraf、grafana 等等）。在部署中连接这些点看起来似乎有些让人恐惧，但是使用合适的工具将不会那么困难。
我将使用 [conjure-up](https://conjure-up.io/) 和 [Canonical 版本的 Kubernetes](https://jujucharms.com/canonical-kubernetes) (CDK) 去探索 Kubernetes。我发现 `conjure-up` 接口对部署大型软件很有帮助，但是我知道一些人可能不喜欢 GUI、TUI 以及其它用户界面。对于这些人，我将用命令行再去部署一遍。
在开始之前需要注意的一点是，Graylog 和 Prometheus 是部署在 Kubernetes 外侧而不是集群上。像 Kubernetes 仪表盘和 Heapster 是运行的集群的非常好的信息来源，但是我的目标是为日志/指标提供一个分析机制，而不管集群运行与否。
### 开始探索
如果你的系统上没有 `conjure-up`，首先要做的第一件事情是，请先安装它，在 Linux 上，这很简单：
```
sudo snap install conjure-up --classic
```
对于 macOS 用户也提供了 brew 包：
```
brew install conjure-up
```
你需要最新的 2.5.2 版，它的好处是添加了 CDK spell，因此，如果你的系统上已经安装了旧的版本，请使用 `sudo snap refresh conjure-up` 或者 `brew update && brew upgrade conjure-up` 去更新它。
安装完成后，运行它：
```
conjure-up
```
你将发现有一个 spell 列表。选择 CDK 然后按下回车。
这个时候，你将看到 CDK spell 可用的附加组件。我们感兴趣的是 Graylog 和 Prometheus，因此选择这两个，然后点击 “Continue”。
它将引导你选择各种云，以决定你的集群部署的地方。之后，你将看到一些部署的后续步骤，接下来是回顾屏幕，让你再次确认部署内容：
除了典型的 K8s 相关的应用程序（etcd、flannel、load-balancer、master 以及 workers）之外，你将看到我们选择的日志和指标相关的额外应用程序。
Graylog 栈包含如下：
* apache2：graylog web 界面的反向代理
* elasticsearch：日志使用的文档数据库
* filebeat：从 K8s master/workers 转发日志到 graylog
* graylog：为日志收集器提供一个 api，以及提供一个日志分析界面
* mongodb：保存 graylog 元数据的数据库
Prometheus 栈包含如下：
* grafana：指标相关的仪表板的 web 界面
* prometheus：指标收集器以及时序数据库
* telegraf：发送主机的指标到 prometheus 中
你可以在回顾屏幕上微调部署，但是默认组件是必选 的。点击 “Deploy all Remaining Applications” 继续。
部署工作将花费一些时间，它将部署你的机器和配置你的云。完成后，`conjure-up` 将展示一个摘要屏幕，它包含一些链接，你可以用你的终端去浏览各种感兴趣的内容：
#### 浏览日志
现在，Graylog 已经部署和配置完成，我们可以看一下采集到的一些数据。默认情况下，filebeat 应用程序将从 Kubernetes 的 master 和 worker 中转发系统日志（ `/var/log/*.log` ）和容器日志（`/var/log/containers/*.log`）到 graylog 中。
记住如下的 apache2 的地址和 graylog 的 admin 密码：
```
juju status --format yaml apache2/0 | grep public-address
public-address: <your-apache2-ip>
juju run-action --wait graylog/0 show-admin-password
admin-password: <your-graylog-password>
```
在浏览器中输入 `http://<your-apache2-ip>` ，然后以管理员用户名（admin）和密码（<your-graylog-password>）登入。
**注意：** 如果这个界面不可用，请等待大约 5 分钟时间，以便于配置的反向代理生效。
登入后，顶部的 “Sources” 选项卡可以看到从 K8s 的 master 和 workers 中收集日志的概述：
通过点击 “System / Inputs” 选项卡深入这些日志，选择 “Show received messages” 查看 filebeat 的输入：
在这里，你可以应用各种过滤或者设置 Graylog 仪表板去帮助识别大多数比较重要的事件。查看 [Graylog Dashboard](http://docs.graylog.org/en/2.3/pages/dashboards.html) 文档，可以了解如何定制你的视图的详细资料。
#### 浏览指标
我们的部署通过 grafana 仪表板提供了两种类型的指标：系统指标，包括像 K8s master 和 worker 的 CPU /内存/磁盘使用情况，以及集群指标，包括像从 K8s cAdvisor 端点上收集的容器级指标。
记住如下的 grafana 的地址和 admin 密码：
```
juju status --format yaml grafana/0 | grep public-address
public-address: <your-grafana-ip>
juju run-action --wait grafana/0 get-admin-password
password: <your-grafana-password>
```
在浏览器中输入 `http://<your-grafana-ip>:3000`，输入管理员用户（admin）和密码（<your-grafana-password>）登入。成功登入后，点击 “Home” 下拉框，选取 “Kubernetes Metrics (via Prometheus)” 去查看集群指标仪表板：
我们也可以通过下拉框切换到 “Node Metrics (via Telegraf) ” 去查看 K8s 主机的系统指标。
### 另一种方法
正如在文章开始的介绍中提到的，我喜欢用 `conjure-up` 的向导去完成像 Kubernetes 这种复杂软件的部署。现在，我们来看一下 `conjure-up` 的另一种方法，你可能希望去看到实现相同结果的一些命令行的方法。还有其它的可能已经部署了前面的 CDK，并想去扩展使用上述的 Graylog/Prometheus 组件。不管什么原因你既然看到这了，既来之则安之，继续向下看吧。
支持 `conjure-up` 的工具是 [Juju](https://jujucharms.com/)。CDK spell 所做的一切，都可以使用 `juju` 命令行来完成。我们来看一下，如何一步步完成这些工作。
#### 从 Scratch 中启动
如果你使用的是 Linux，安装 Juju 很简单，命令如下：
```
sudo snap install juju --classic
```
对于 macOS，Juju 也可以从 brew 中安装：
```
brew install juju
```
现在为你选择的云配置一个控制器。你或许会被提示请求一个凭据（用户名密码）：
```
juju bootstrap
```
我们接下来需要基于 CDK 捆绑部署：
```
juju deploy canonical-kubernetes
```
#### 从 CDK 开始
使用我们部署的 Kubernetes 集群，我们需要去添加 Graylog 和 Prometheus 所需要的全部应用程序：
```
## deploy graylog-related applications
juju deploy xenial/apache2
juju deploy xenial/elasticsearch
juju deploy xenial/filebeat
juju deploy xenial/graylog
juju deploy xenial/mongodb
```
```
## deploy prometheus-related applications
juju deploy xenial/grafana
juju deploy xenial/prometheus
juju deploy xenial/telegraf
```
现在软件已经部署完毕，将它们连接到一起，以便于它们之间可以相互通讯：
```
## relate graylog applications
juju relate apache2:reverseproxy graylog:website
juju relate graylog:elasticsearch elasticsearch:client
juju relate graylog:mongodb mongodb:database
juju relate filebeat:beats-host kubernetes-master:juju-info
juju relate filebeat:beats-host kubernetes-worker:jujuu-info
```
```
## relate prometheus applications
juju relate prometheus:grafana-source grafana:grafana-source
juju relate telegraf:prometheus-client prometheus:target
juju relate kubernetes-master:juju-info telegraf:juju-info
juju relate kubernetes-worker:juju-info telegraf:juju-info
```
这个时候，所有的应用程序已经可以相互之间进行通讯了，但是我们还需要多做一点配置（比如，配置 apache2 反向代理、告诉 prometheus 如何从 K8s 中取数、导入到 grafana 仪表板等等）：
```
## configure graylog applications
juju config apache2 enable_modules="headers proxy_html proxy_http"
juju config apache2 vhost_http_template="$(base64 <vhost-tmpl>)"
juju config elasticsearch firewall_enabled="false"
juju config filebeat \
logpath="/var/log/*.log /var/log/containers/*.log"
juju config filebeat logstash_hosts="<graylog-ip>:5044"
juju config graylog elasticsearch_cluster_name="<es-cluster>"
```
```
## configure prometheus applications
juju config prometheus scrape-jobs="<scraper-yaml>"
juju run-action --wait grafana/0 import-dashboard \
dashboard="$(base64 <dashboard-json>)"
```
以上的步骤需要根据你的部署来指定一些值。你可以用与 `conjure-up` 相同的方法得到这些：
* `<vhost-tmpl>`： 从 github 获取我们的示例 [模板](https://raw.githubusercontent.com/conjure-up/spells/master/canonical-kubernetes/addons/graylog/steps/01_install-graylog/graylog-vhost.tmpl)
* `<graylog-ip>`： `juju run --unit graylog/0 'unit-get private-address'`
* `<es-cluster>`： `juju config elasticsearch cluster-name`
* `<scraper-yaml>`： 从 github 获取我们的示例 [scraper](https://raw.githubusercontent.com/conjure-up/spells/master/canonical-kubernetes/addons/prometheus/steps/01_install-prometheus/prometheus-scrape-k8s.yaml) ；`[K8S_PASSWORD][20]` 和 `[K8S_API_ENDPOINT][21]` [substitute](https://github.com/conjure-up/spells/blob/master/canonical-kubernetes/addons/prometheus/steps/01_install-prometheus/after-deploy#L25) 的正确值
* `<dashboard-json>`： 从 github 获取我们的 [主机](https://raw.githubusercontent.com/conjure-up/spells/master/canonical-kubernetes/addons/prometheus/steps/01_install-prometheus/grafana-telegraf.json) 和 [k8s](https://raw.githubusercontent.com/conjure-up/spells/master/canonical-kubernetes/addons/prometheus/steps/01_install-prometheus/grafana-k8s.json) 仪表板
最后，发布 apache2 和 grafana 应用程序，以便于可以通过它们的 web 界面访问：
```
## expose relevant endpoints
juju expose apache2
juju expose grafana
```
现在我们已经完成了所有的部署、配置、和发布工作，你可以使用与上面的**浏览日志**和**浏览指标**部分相同的方法去查看它们。
### 总结
我的目标是向你展示如何去部署一个 Kubernetes 集群，很方便地去监视它的日志和指标。无论你是喜欢向导的方式还是命令行的方式，我希望你清楚地看到部署一个监视系统并不复杂。关键是要搞清楚所有部分是如何工作的，并将它们连接到一起工作，通过断开/修复/重复的方式，直到它们每一个都能正常工作。
这里有一些像 conjure-up 和 Juju 一样非常好的工具。充分发挥这个生态系统贡献者的专长让管理大型软件变得更容易。从一套可靠的应用程序开始，按需定制，然后投入到工作中！
大胆去尝试吧，然后告诉我你用的如何。你可以在 Freenode IRC 的 **#conjure-up** 和 **#juju** 中找到像我这样的爱好者。感谢阅读！
### 关于作者
Kevin 在 2014 年加入 Canonical 公司，他专注于复杂软件建模。他在 Juju 大型软件团队中找到了自己的位置，他的任务是将大数据和机器学习应用程序转化成可重复的（可靠的）解决方案。
---
via: <https://insights.ubuntu.com/2018/01/16/monitor-your-kubernetes-cluster/>
作者：[Kevin Monroe](https://insights.ubuntu.com/author/kwmonroe/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
怎样用 parted 管理硬盘分区
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/how-to-manage-disk-partitions-using-parted-command/
|
parted 是一个操作硬盘分区的程序。它支持多种分区表类型，包括 MS-DOS 和 GPT。
|
/data/attachment/album/201804/10/235054e0a6p121roekakpk.jpg.thumb.jpg
|
/data/attachment/album/201804/10/235054e0a6p121roekakpk.jpg
| true | false | true |
zyk2290
| false |
[
"parted",
"fdisk",
"分区"
] |
技术
|
{
"viewnum": 18138,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
parted 是一个操作硬盘分区的程序。它支持多种分区表类型，包括 MS-DOS 和 GPT。
| 2018-04-10T23:51:07 | 2018-04-10T23:51:07 | 9,536 |
/article-9536-1.html
|
众所周知，对硬盘分区是 Linux 管理员一项最重要的管理任务之一，他们不能不知道这个。
在最糟糕的时候，你至少每周会收到一次依赖小组的请求，而在更大的环境里会更加频繁 。
你可能会问为什么我们要用 `parted` 而不是 `fdisk`？ 它们有什么区别？好问题，我会告诉你这两者的区别。
* `parted` 支持用户在大于 2TB 的硬盘上创建硬盘分区， 但 `fdisk` 命令不支持
* 对比 `fdisk` 来说，`parted` 是一个更高级的工具
* 支持更多的分区表类型，包括 GPT （LCTT 译注：全局唯一标识分区表）
* 它允许用户调整分区大小， 但当缩减分区空间的时候，它没有如我意料的工作，多数情况下我会得到错误消息。所以我会建议用户不要用 `parted` 来缩减分区大小。
### 什么是 parted
`parted` 是一个操作硬盘分区的程序。它支持多种分区表类型，包括 MS-DOS 和 GPT。
它允许用户创建、删除、调整、缩减、移动和复制分区，以及重新组织硬盘的使用，复制数据到新的硬盘上。`gparted` 是 `parted` 的图形界面前端。
### 怎样安装 parted
大部分发行版已经预安装了 `parted`。如果没有，用下列命令来安装 `parted`。
对于 Debian/Ubuntu 用户, 使用 [APT-GET 命令](https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/) 或者 [APT 命令](https://www.2daygeek.com/apt-command-examples-manage-packages-debian-ubuntu-systems/) 来安装 `parted`。
```
$ sudo apt install parted
```
对于 RHEL/CentOS 用户，用 [YUM 命令](https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/) 来安装 `parted`。
```
$ sudo yum install parted
```
对于 Fedora 用户，用 [DNF 命令](https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/) 来安装 `parted`。
```
$ sudo dnf install parted
```
对于 Arch Linux 用户，用 [Pacman 命令](https://www.2daygeek.com/pacman-command-examples-manage-packages-arch-linux-system/)来安装 `parted`。
```
$ sudo pacman -S parted
```
对于 openSUSE 用户， 用 [Zypper 命令](https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/)来安装 `parted`。
```
$ sudo zypper in parted
```
### 怎样启动 parted
下面的 `parted` 命令会自动选择 `/dev/sda` ，因为这是系统的第一个硬盘。
```
$ sudo parted
GNU parted 3.2
Using /dev/sda
Welcome to GNU parted! Type 'help' to view a list of commands.
(parted)
```
同时我们也可以用下面的命令来重新选择对应的的硬盘。
```
(parted) select /dev/sdb
Using /dev/sdb
(parted)
```
如果你想选择特定的硬盘, 用下列的格式来输入命令。 这次 ，我们将选择 `/dev/sdb`。
```
$ sudo parted [Device Name]
```
```
$ sudo parted /dev/sdb
GNU parted 3.2
Using /dev/sdb
Welcome to GNU parted! Type 'help' to view a list of commands.
(parted)
```
### 怎样用 parted 列出所有可用的硬盘
如果你不知道你的电脑上有什么硬盘，只需要运行下列命令，该命令会显示所有可用硬盘的名字，以及其它的有用信息比如储存空间、型号、扇区大小、硬盘标志以及分区信息。
```
$ sudo parted -l
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sda: 32.2GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 1049kB 32.2GB 32.2GB primary ext4 boot
Error: /dev/sdb: unrecognised disk label
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: unknown
Disk Flags:
```
上面的错误信息清晰地显示出硬盘 `/dev/sdb` 没有有效的<ruby> 磁盘标签 <rt> disk label </rt></ruby>。 它不会自动得到磁盘标签，所以， 我们便要自己设置硬盘标签。
### 怎样用 parted 创建硬盘分区
`parted` 允许用户创建主分区或者拓展分区。创建这两种类型的分区的步骤还是一样，但请确保你已经指定了需要的分区类型，比如 `primary` （主分区）或者 `extended` （扩展分区）。
为了演示这项操作 ，我们安装了一个新的 `50 GB` 的硬盘到到电脑上，挂载在 `/dev/sdb` 上。
有两种方法创建分区，第一种是更详细的方法，另一种只是一个命令。 在下面的例子中，我们将用更详细的方法添加一个主分区。提醒一下， 我们应该先设置磁盘标签，因为它不会自动设置任何标签。
在下面的例子中，我们将要创建一个 `10 GB` 的分区
```
$ sudo parted /dev/sdb
GNU parted 3.2
Using /dev/sdb
Welcome to GNU parted! Type 'help' to view a list of commands.
(parted) mklabel msdos
(parted) unit GB
(parted) mkpart
Partition type? primary/extended? primary
File system type? [ext2]? ext4
Start? 0.00GB
End? 10.00GB
(parted) print
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 0.00GB 10.0GB 10.0GB primary ext4 lba
(parted) quit
Information: You may need to update /etc/fstab.
```
同时，我们也可以使用单条 `parted` 命令
在下面的例子中，我们将在硬盘上创建一个 `10 GB` 的分区。
```
$ sudo parted [Disk Name] [mkpart] [Partition Type] [Filesystem Type] [Partition Start Size] [Partition End Size]
```
```
$ sudo parted /dev/sdb mkpart primary ext4 10.0GB 20.0GB
Information: You may need to update /etc/fstab.
```
### 怎样使用所有剩余空间创建分区
你已经创建了除了 `/home` 之外等所有要求的分区，而且你想要用硬盘上所有剩余的空间来创建 `/home` 分区，要怎样做？可以使用下面的命令来创建分区。
下面的命令创建了一个 33.7 GB 的分区，从 `20 GB` 开始到 `53 GB` 结束。 `100%` 使用率允许用户用硬盘上所有剩余的空余空间。
```
$ sudo parted [Disk Name] [mkpart] [Partition Type] [Filesystem Type] [Partition Start Size] [Partition End Size]
$ sudo parted /dev/sdb mkpart primary ext4 20.0GB 100%
Information: You may need to update /etc/fstab.
```
### 怎样用 parted 列出所有的分区
你也许注意到了，我们已经在上述步骤中创建了三个分区，如果你想要列出所有在硬盘上可用的分区，可以使用 `print` 命令。
```
$ sudo parted /dev/sdb print
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 1049kB 10.0GB 9999MB primary ext4
2 10.0GB 20.0GB 9999MB primary ext4
3 20.0GB 53.7GB 33.7GB primary ext4
```
### 怎样用 mkfs 格式化分区
用户可以用 `mkfs` 命令格式化分区。下面的步骤会用 `mkfs` 来格式化分区。
```
$ sudo mkfs.ext4 /dev/sdb1
mke2fs 1.43.4 (31-Jan-2017)
Creating filesystem with 2621440 4k blocks and 656640 inodes
Filesystem UUID: 415cf467-634c-4403-8c9f-47526bbaa381
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632
Allocating group tables: done
Writing inode tables: done
Creating journal (16384 blocks): done
Writing superblocks and filesystem accounting information: done
```
同样的。
```
$ sudo mkfs.ext4 /dev/sdb2
$ sudo mkfs.ext4 /dev/sdb3
```
创建必要的文件夹然后将这些分区挂载在上面。
```
$ sudo mkdir /par1 /par2 /par3
```
```
$ sudo mount /dev/sdb1 /par1
$ sudo mount /dev/sdb2 /par2
$ sudo mount /dev/sdb3 /par3
```
运行下列命令来检查是否成功挂载上新创建的分区。
```
$ df -h /dev/sdb[1-3]
Filesystem Size Used Avail Use% Mounted on
/dev/sdb1 9.2G 37M 8.6G 1% /par1
/dev/sdb2 9.2G 37M 8.6G 1% /par2
/dev/sdb3 31G 49M 30G 1% /par3
```
### 怎样检查硬盘空闲空间
运行下列命令来检查硬盘上的空闲空间，这块硬盘上有 `25.7 GB` 的空闲空间。
```
$ sudo parted /dev/sdb print free
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
32.3kB 1049kB 1016kB Free Space
1 1049kB 10.0GB 9999MB primary ext4
2 10.0GB 20.0GB 9999MB primary ext4
3 20.0GB 28.0GB 8001MB primary ext4
28.0GB 53.7GB 25.7GB Free Space
```
### 怎样使用 parted 命令来重新调整分区大小
`parted` 允许用户重新调整分区大小。不过我已在文章的开头说了，不要缩小分区大小，不然会有许多错误。
运行下列命令来检查硬盘分区以及所有可用空间。 可以看到硬盘上有 `25.7GB` 的可用空间。
```
$ sudo parted /dev/sdb print free
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
32.3kB 1049kB 1016kB Free Space
1 1049kB 10.0GB 9999MB primary ext4
2 10.0GB 20.0GB 9999MB primary ext4
3 20.0GB 28.0GB 8001MB primary ext4
28.0GB 53.7GB 25.7GB Free Space
```
运行下列命令来重新调整分区大小。 我们将要重新调整（增加）分区 3 的结束位置，从 `28GB` 到 `33GB`。
```
$ sudo parted [Disk Name] [resizepart] [Partition Number] [Partition New End Size]
$ sudo parted /dev/sdb resizepart 3 33.0GB
Information: You may need to update /etc/fstab.
```
运行下列命令来确认分区是否已经扩容。可以看到，分区 3 已经从 `8GB` 增加到 `13GB`。
```
$ sudo parted /dev/sdb print
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 1049kB 10.0GB 9999MB primary ext4
2 10.0GB 20.0GB 9999MB primary ext4
3 20.0GB 33.0GB 13.0GB primary ext4
```
重新调整文件系统大小。
```
$ sudo resize2fs /dev/sdb3
resize2fs 1.43.4 (31-Jan-2017)
Resizing the filesystem on /dev/sdb3 to 3173952 (4k) blocks.
The filesystem on /dev/sdb3 is now 3173952 (4k) blocks long.
```
最后，确认分区是否已经扩容。
```
$ df -h /dev/sdb[1-3]
Filesystem Size Used Avail Use% Mounted on
/dev/sdb1 9.2G 5.1G 3.6G 59% /par1
/dev/sdb2 9.2G 2.1G 6.6G 24% /par2
/dev/sdb3 12G 1.1G 11G 10% /par3
```
### 怎样用 parted 删除分区
我们用 `rm` 命令方便地删除未使用的分区（如果该分区不会再被用到了）。下列步骤中，我们将会删除分区 3 （`/dev/sdb3`）。
```
$ sudo parted [Disk Name] [rm] [Partition Number]
$ sudo parted /dev/sdb rm 3
Warning: Partition /dev/sdb3 is being used. Are you sure you want to continue?
Yes/No? Yes
Error: Partition(s) 3 on /dev/sdb have been written, but we have been unable to inform the kernel of the change, probably because it/they are in use. As a result, the old partition(s) will remain in use.
You should reboot now before making further changes.
Ignore/Cancel? Ignore
Information: You may need to update /etc/fstab.
```
我们也可以用下列的命令检查。可以看到，分区 3 已经被成功移除。
```
$ sudo parted /dev/sdb print
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 1049kB 10.0GB 9999MB primary ext4
2 10.0GB 20.0GB 9999MB primary ext4
```
### 怎样用 parted 命令设置/更改分区标志
我们可以用下列的命令来轻易更改分区的标志。 我们将对 `/dev/sdb2` 设置 `lvm` 标志。
```
$ sudo parted [Disk Name] [set] [Partition Number] [Flags Name] [Flag On/Off]
$ sudo parted /dev/sdb set 2 lvm on
Information: You may need to update /etc/fstab.
```
我们可以列出分区来验证这次的更改。
```
$ sudo parted /dev/sdb print
Model: ATA VBOX HARDDISK (scsi)
Disk /dev/sdb: 53.7GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 1049kB 10.0GB 9999MB primary ext4
2 10.0GB 20.0GB 9999MB primary ext4 lvm
```
如果你想知道可用的标志，只需要用如下的命令。
```
$ (parted) help set
set NUMBER FLAG STATE change the FLAG on partition NUMBER
NUMBER is the partition number used by Linux. On MS-DOS disk labels, the primary partitions number from 1 to 4, logical partitions from 5 onwards.
FLAG is one of: boot, root, swap, hidden, raid, lvm, lba, hp-service, palo, prep, msftres, bios_grub, atvrecv, diag, legacy_boot, msftdata, irst, esp
STATE is one of: on, off
```
如果你想知道 `parted` 的其它可用命令， 只需要去到 `help` 页面。
```
$ sudo parted
GNU parted 3.2
Using /dev/sda
Welcome to GNU parted! Type 'help' to view a list of commands.
(parted) help
align-check TYPE N check partition N for TYPE(min|opt) alignment
help [COMMAND] print general help, or help on COMMAND
mklabel,mktable LABEL-TYPE create a new disklabel (partition table)
mkpart PART-TYPE [FS-TYPE] START END make a partition
name NUMBER NAME name partition NUMBER as NAME
print [devices|free|list,all|NUMBER] display the partition table, available devices, free space, all found partitions, or a particular partition
quit exit program
rescue START END rescue a lost partition near START and END
resizepart NUMBER END resize partition NUMBER
rm NUMBER delete partition NUMBER
select DEVICE choose the device to edit
disk_set FLAG STATE change the FLAG on selected device
disk_toggle [FLAG] toggle the state of FLAG on selected device
set NUMBER FLAG STATE change the FLAG on partition NUMBER
toggle [NUMBER [FLAG]] toggle the state of FLAG on partition NUMBER
unit UNIT set the default unit to UNIT
version display the version number and copyright information of GNU parted
(parted) quit
```
---
via: <https://www.2daygeek.com/how-to-manage-disk-partitions-using-parted-command/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 译者：[zyk2290](https://github.com/zyk2290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
SQL 入门
|
Aaron Cocker
|
https://opensource.com/article/18/2/getting-started-sql
|
使用 SQL 构建一个关系数据库比你想的更容易。
|
/data/attachment/album/201804/12/083722owub5u7i75w8bw7b.jpg.thumb.jpg
|
/data/attachment/album/201804/12/083722owub5u7i75w8bw7b.jpg
| true | false | true |
MjSeven
| false |
[
"SQL",
"数据库"
] |
软件开发
|
{
"viewnum": 9440,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用 SQL 构建一个关系数据库比你想的更容易。
| 2018-04-12T08:37:27 | 2018-04-12T08:37:27 | 9,537 |
/article-9537-1.html
|
>
> 使用 SQL 构建一个关系数据库比你想的更容易。
>
>
>
使用 SQL 构建数据库比大多数人想象得要简单。实际上，你甚至不需要成为一个有经验的程序员就可以使用 SQL 创建数据库。在本文中，我将解释如何使用 MySQL 5.6 来创建简单的关系型数据库管理系统（RDMS）。在开始之前，我想顺便感谢一下 [SQL Fiddle](http://sqlfiddle.com)，这是我用来运行脚本的工具。它提供了一个用于测试简单脚本的有用的沙箱。
在本教程中，我将构建一个使用如下实体关系图（ERD）中显示的简单架构的数据库。数据库列出了学生和正在学习的课程。为了保持简单，我使用了两个实体（即表），只有一种关系和依赖。这两个实体称为 `dbo_students` 和 `dbo_courses`。
数据库的多样性是一对多的，因为每门课程可以包含很多学生，但每个学生只能学习一门课程。
关于术语的快速说明：
1. 一张表称为一个实体。
2. 一个字段称为一个属性。
3. 一条记录称为一个元组。
4. 用于构建数据库的脚本称为架构。
### 构建架构
要构建数据库，使用 `CREATE TABLE <表名>` 命令，然后定义每个字段的名称和数据类型。数据库使用 `VARCHAR(n)` （字符串）和 `INT(n)` （整数），其中 `n` 表示可以存储的值的长度。例如 `INT(2)` 可以是 `01`。
这是用于创建两个表的代码：
```
CREATE TABLE dbo_students
(
student_id INT(2) AUTO_INCREMENT NOT NULL,
student_name VARCHAR(50),
course_studied INT(2),
PRIMARY KEY (student_id)
);
CREATE TABLE dbo_courses
(
course_id INT(2) AUTO_INCREMENT NOT NULL,
course_name VARCHAR(30),
PRIMARY KEY (course_id)
);
```
`NOT NULL` 意味着字段不能为空，`AUTO_INCREMENT` 意味着当一个新的元组被添加时，ID 号将自动生成，是对先前存储的 ID 号加 1，以强化各实体之间的完整参照性。 `PRIMARY KEY` 是每个表的惟一标识符属性。这意味着每个元组都有自己的不同的标识。
### 关系作为一种约束
就目前来看，这两张表格是独立存在的，没有任何联系或关系。要连接它们，必须标识一个外键。在 `dbo_students` 中，外键是 `course_studied`，其来源在 `dbo_courses` 中，意味着该字段被引用。SQL 中的特定命令为 `CONSTRAINT`，并且将使用另一个名为 `ALTER TABLE` 的命令添加这种关系，这样即使在架构构建完毕后，也可以编辑表。
以下代码将关系添加到数据库构造脚本中：
```
ALTER TABLE dbo_students
ADD CONSTRAINT FK_course_studied
FOREIGN KEY (course_studied) REFERENCES dbo_courses(course_id);
```
使用 `CONSTRAINT` 命令实际上并不是必要的，但这是一个好习惯，因为它意味着约束可以被命名并且使维护更容易。现在数据库已经完成了，是时候添加一些数据了。
### 将数据添加到数据库
`INSERT INTO <表名>` 是用于直接选择要添加哪些属性（即字段）数据的命令。首先声明实体名称，然后声明属性，下边是添加到实体的数据，从而创建一个元组。如果指定了 `NOT NULL`，这表示该属性不能留空。以下代码将展示如何向表中添加记录：
```
INSERT INTO dbo_courses(course_id,course_name)
VALUES(001,'Software Engineering');
INSERT INTO dbo_courses(course_id,course_name)
VALUES(002,'Computer Science');
INSERT INTO dbo_courses(course_id,course_name)
VALUES(003,'Computing');
INSERT INTO dbo_students(student_id,student_name,course_studied)
VALUES(001,'student1',001);
INSERT INTO dbo_students(student_id,student_name,course_studied)
VALUES(002,'student2',002);
INSERT INTO dbo_students(student_id,student_name,course_studied)
VALUES(003,'student3',002);
INSERT INTO dbo_students(student_id,student_name,course_studied)
VALUES(004,'student4',003);
```
现在数据库架构已经完成并添加了数据，现在是时候在数据库上运行查询了。
### 查询
查询遵循使用以下命令的集合结构：
```
SELECT <attributes>
FROM <entity>
WHERE <condition>
```
要显示 `dbo_courses` 实体内的所有记录并显示课程代码和课程名称，请使用 `*` 。 这是一个通配符，它消除了键入所有属性名称的需要。（在生产数据库中不建议使用它。）此处查询的代码是：
```
SELECT *
FROM dbo_courses
```
此处查询的输出显示表中的所有元组，因此可显示所有可用课程：
```
| course_id | course_name |
|-----------|----------------------|
| 1 | Software Engineering |
| 2 | Computer Science |
| 3 | Computing |
```
在后面的文章中，我将使用三种类型的连接之一来解释更复杂的查询：内连接、外连接和交叉连接。
这是完整的脚本：
```
CREATE TABLE dbo_students
(
student_id INT(2) AUTO_INCREMENT NOT NULL,
student_name VARCHAR(50),
course_studied INT(2),
PRIMARY KEY (student_id)
);
CREATE TABLE dbo_courses
(
course_id INT(2) AUTO_INCREMENT NOT NULL,
course_name VARCHAR(30),
PRIMARY KEY (course_id)
);
ALTER TABLE dbo_students
ADD CONSTRAINT FK_course_studied
FOREIGN KEY (course_studied) REFERENCES dbo_courses(course_id);
INSERT INTO dbo_courses(course_id,course_name)
VALUES(001,'Software Engineering');
INSERT INTO dbo_courses(course_id,course_name)
VALUES(002,'Computer Science');
INSERT INTO dbo_courses(course_id,course_name)
VALUES(003,'Computing');
INSERT INTO dbo_students(student_id,student_name,course_studied)
VALUES(001,'student1',001);
INSERT INTO dbo_students(student_id,student_name,course_studied)
VALUES(002,'student2',002);
INSERT INTO dbo_students(student_id,student_name,course_studied)
VALUES(003,'student3',002);
INSERT INTO dbo_students(student_id,student_name,course_studied)
VALUES(004,'student4',003);
SELECT *
FROM dbo_courses
```
### 学习更多
SQL 并不困难；我认为它比编程简单，并且该语言对于不同的数据库系统是通用的。 请注意，实体关系图中 `dbo.<实体>` （LCTT 译注：文章中使用的是 `dbo_<实体>`）不是必需的实体命名约定；我之所以使用，仅仅是因为它是 Microsoft SQL Server 中的标准。
如果你想了解更多，在网络上这方面的最佳指南是 [W3Schools.com](https://www.w3schools.com/sql/default.asp) 中对所有数据库平台的 SQL 综合指南。
请随意使用我的数据库。另外，如果你有任何建议或疑问，请在评论中回复。
---
via: <https://opensource.com/article/18/2/getting-started-sql>
作者：[Aaron Cocker](https://opensource.com/users/aaroncocker) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
完全指南：在 Linux 中如何打印和管理打印机
|
Ian Shields
|
https://www.ibm.com/developerworks/library/l-lpic1-108-4/index.html
|
本教程将介绍在 Linux 中如何使用 CUPS 去打印。
|
/data/attachment/album/201804/12/134258mpuk2w98ot892fpk.jpg.thumb.jpg
|
/data/attachment/album/201804/12/134258mpuk2w98ot892fpk.jpg
| true | false | true |
qhwdw
| false |
[
"打印",
"CUPS"
] |
技术
|
{
"viewnum": 25397,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "119.57.114.113",
"message": "有人遇见过，不cups跨了vlan就不能使用的情况吗，还请指教，我的操作是参照http://wiki.ubuntu.org.cn/%E5%A6%82%E4%BD%95%E5%9C%A8Ubuntu%E4%B8%8A%E4%BD%BF%E7%94%A8%E7%BD%91%E7%BB%9C%E6%89%93%E5%8D%B0 这个配置的",
"username": "来自北京的 Chrome 70.0|Windows 10 用户",
"date": "2018-12-11T19:23:01"
}
] |
[] |
本教程将介绍在 Linux 中如何使用 CUPS 去打印。
| 2018-04-12T13:43:05 | 2018-04-12T13:43:05 | 9,538 |
/article-9538-1.html
|
### Linux 中的打印
虽然现在大量的沟通都是电子化和无纸化的，但是在我们的公司中还有大量的材料需要打印。银行结算单、公用事业帐单、财务和其它报告、以及收益结算单等一些东西还是需要打印的。本教程将介绍在 Linux 中如何使用 CUPS 去打印。
CUPS，是<ruby> 通用 Unix 打印系统 <rt> Common UNIX Printing System </rt></ruby>的首字母缩写，它是 Linux 中的打印机和打印任务的管理者。早期计算机上的打印机一般是在特定的字符集和字体大小下打印文本文件行。现在的图形打印机可以打印各种字体和大小的文本和图形。尽管如此，现在你所使用的一些命令，在古老的行式打印守护进程（LPD）技术的历史中仍能找到它们。
本教程将帮你了解 Linux 服务器专业考试（LPIC-1）的第 108 号主题的 108.4 目标。这个目标的权重为 2。
#### 前提条件
为了更好地学习本系列教程，你需要具备基本的 Linux 知识，和使用 Linux 系统实践本教程中的命令的能力，你应该熟悉 GNU 和 UNIX® 命令的使用。有时不同版本的程序输出可能会不同，因此，你的结果可能与本教程中的示例有所不同。
本教程中的示例使用的是 Fedora 27 的系统。
### 有关打印的一些历史
这一小部分历史并不是 LPI 目标的，但它有助于你理解这个目标的相关环境。
早期的计算机大都使用行式打印机。这些都是击打式打印机，那时，它们使用固定间距的字符和单一的字体来打印文本行。为提升整个系统性能，早期的主机要与慢速的外围设备（如读卡器、卡片穿孔机、和运行其它工作的行式打印机）交叉进行工作。因此就产生了在线的或者假脱机的同步外围操作，这一术语目前在谈到计算机打印时仍然在使用。
在 UNIX 和 Linux 系统上，打印初始化使用的是 BSD（<ruby> 伯克利软件分发版 <rt> Berkeley Software Distribution </rt></ruby>）打印子系统，它是由一个作为服务器运行的行式打印守护程序（LPD）组成，而客户端命令如 `lpr` 是用于提交打印作业。这个协议后来被 IETF 标准化为 RFC 1179 —— **行式打印机守护进程协议**。
System V 也有一个打印守护程序。它的功能与BSD 的 LPD 守护程序类似，但是它们的命令集不一样。你在后面会经常看到完成相同的任务使用不同选项的两个命令。例如，对于打印文件的命令，伯克利实现版本是 `lpr`，而 System V 实现版本是 `lp`。
随着打印机技术的进步，在一个页面上混合出现不同字体成为可能，并且可以将图片像文字一样打印。可变间距字体，以及更多先进的打印技术，比如间距和连字符，现在都已经标准化。出现了几种对基本的 lpd/lpr 方法等改进设计，比如 LPRng，下一代的 LPR，以及 CUPS。
许多可以打印图形的打印机，使用 Adobe PostScript 语言进行初始化。一个 PostScript 打印机有一个解释器引擎，它可以解释打印任务中的命令并从这些命令中生成最终的页面。PostScript 经常被用做原始文件（比如一个文本文件或者一个图像文件）和最终格式没有适合的 PostScript 功能的特定打印机之间的中间层。转换这些特定的打印任务，比如将一个 ASCII 文本文件或者一个 JPEG 图像转换为 PostScript，然后再使用过滤器转换 PostScript 到非 PostScript 打印机所需要的最终光栅格式。
现在的<ruby> 便携式文档格式 <rt> Portable Document Format </rt></ruby>（PDF），它就是基于 PostScript 的，已经替换了传统的原始 PostScript。PDF 设计为与硬件和软件无关，它封装了要打印的页面的完整描述。你可以查看 以及打印 PDF 文件。
### 管理打印队列
用户直接打印作业到一个名为<ruby> 打印队列 <rt> print queue </rt></ruby>的逻辑实体。在单用户系统中，打印队列和打印机通常是几乎相同的意思。但是，CUPS 允许系统不用连接到一个打印机上，而最终在一个远程系统上的排队打印作业，并且通过使用分类，允许将定向到一个分类的打印作业在该分类第一个可用的打印机上打印。
你可以检查和管理打印队列。对于 CUPS 来说，其中一些命令实现了一些新操作。另外的一些是源于 LPD 的兼容命令，不过现在的一些选项通常是最初的 LPD 打印系统选项的有限子集。
你可以使用 CUPS 的 `lpstat` 命令去检查队列，以了解打印系统。一些常见选项如下表 1。
| 选项 | 作用 |
| --- | --- |
| `-a` | 显示打印机状态 |
| `-c` | 显示打印分类 |
| `-p` | 显示打印状态：`enabled` 或者 `disabled` |
| `-s` | 显示默认打印机、打印机和类。相当于 `-d -c -v`。**注意：要指定多个选项，这些选项必须像值一样分隔开。** |
| `-v` | 显示打印机和它们的设备。 |
*表 1. lpstat 命令的选项*
你也可以使用 LPD 的 `lpc` 命令（它可以在 `/usr/sbin` 中找到）使用它的 `status` 选项。如果你不想指定打印机名字，将列出所有的队列。列表 1 展示了命令的一些示例。
```
[ian@atticf27 ~]$ lpstat -d
system default destination: HL-2280DW
[ian@atticf27 ~]$ lpstat -v HL-2280DW
device for HL-2280DW: dnssd://Brother%20HL-2280DW._pdl-datastream._tcp.local/
[ian@atticf27 ~]$ lpstat -s
system default destination: HL-2280DW
members of class anyprint:
HL-2280DW
XP-610
device for anyprint: ///dev/null
device for HL-2280DW: dnssd://Brother%20HL-2280DW._pdl-datastream._tcp.local/
device for XP-610: dnssd://EPSON%20XP-610%20Series._ipp._tcp.local/?uuid=cfe92100-67c4-11d4-a45f-ac18266c48aa
[ian@atticf27 ~]$ lpstat -a XP-610
XP-610 accepting requests since Thu 27 Apr 2017 05:53:59 PM EDT
[ian@atticf27 ~]$ /usr/sbin/lpc status HL-2280DW
HL-2280DW:
printer is on device 'dnssd' speed -1
queuing is disabled
printing is enabled
no entries
daemon present
```
*列表 1. 显示可用打印队列*
这个示例展示了两台打印机 —— HL-2280DW 和 XP-610，和一个分类 `anyprint`，它允许打印作业定向到这两台打印机中的第一个可用打印机。
在这个示例中，已经禁用了打印到 HL-2280DW 队列，但是打印功能是启用的，这样便于将打印机脱机维护之前可以完成打印队列中的任务。启用还是禁用队列，可以使用 `cupsaccept` 和 `cupsreject` 命令来管理。以前它们叫做 `accept` 和 `reject`，你或许可能在 `/usr/sbin` 中找到这些命令，但它们现在都是符号链接到新的命令上了。同样，启用还是禁用打印，你可以使用 `cupsenable` 和 `cupsdisable` 命令来管理。在早期版本的 CUPS 中，这些被称为 `enable` 和 `disable`，它也许会与 bash shell 内置的 `enable` 混淆。列表 2 展示了如何去启用打印机 HL-2280DW 上的队列，而禁止它的打印。CUPS 的几个命令支持使用 `-r` 选项去提供一个该操作的理由。这个理由会在你使用 `lpstat` 时显示，但是如果你使用的是 `lpc` 命令则不会显示它。
```
[ian@atticf27 ~]$ lpstat -a -p HL-2280DW
anyprint accepting requests since Mon 29 Jan 2018 01:17:09 PM EST
HL-2280DW not accepting requests since Thu 27 Apr 2017 05:52:27 PM EDT -
Maintenance scheduled
XP-610 accepting requests since Thu 27 Apr 2017 05:53:59 PM EDT
printer HL-2280DW is idle. enabled since Thu 27 Apr 2017 05:52:27 PM EDT
Maintenance scheduled
[ian@atticf27 ~]$ accept HL-2280DW
[ian@atticf27 ~]$ cupsdisable -r "waiting for toner delivery" HL-2280DW
[ian@atticf27 ~]$ lpstat -p -a
printer anyprint is idle. enabled since Mon 29 Jan 2018 01:17:09 PM EST
printer HL-2280DW disabled since Mon 29 Jan 2018 04:03:50 PM EST -
waiting for toner delivery
printer XP-610 is idle. enabled since Thu 27 Apr 2017 05:53:59 PM EDT
anyprint accepting requests since Mon 29 Jan 2018 01:17:09 PM EST
HL-2280DW accepting requests since Mon 29 Jan 2018 04:03:50 PM EST
XP-610 accepting requests since Thu 27 Apr 2017 05:53:59 PM EDT
```
*列表 2. 启用队列和禁用打印*
注意：用户执行这些任务必须经过授权。它可能要求是 root 用户或者其它的授权用户。在 `/etc/cups/cups-files.conf` 中可以看到 `SystemGroup` 的条目，`cups-files.conf` 的 man 页面有更多授权用户组的信息。
### 管理用户打印作业
现在，你已经知道了一些如何去检查打印队列和类的方法，我将给你展示如何管理打印队列上的作业。你要做的第一件事是，如何找到一个特定打印机或者全部打印机上排队的任意作业。完成上述工作要使用 `lpq` 命令。如果没有指定任何选项，`lpq` 将显示默认打印机上的队列。使用 `-P` 选项和一个打印机名字将指定打印机，或者使用 `-a` 选项去指定所有的打印机，如下面的列表 3 所示。
```
[pat@atticf27 ~]$ # As user pat (non-administrator)
[pat@atticf27 ~]$ lpq
HL-2280DW is not ready
Rank Owner Job File(s) Total Size
1st unknown 4 unknown 6144 bytes
2nd pat 6 bitlib.h 6144 bytes
3rd pat 7 bitlib.C 6144 bytes
4th unknown 8 unknown 1024 bytes
5th unknown 9 unknown 1024 bytes
[ian@atticf27 ~]$ # As user ian (administrator)
[ian@atticf27 ~]$ lpq -P xp-610
xp-610 is ready
no entries
[ian@atticf27 ~]$ lpq -a
Rank Owner Job File(s) Total Size
1st ian 4 permutation.C 6144 bytes
2nd pat 6 bitlib.h 6144 bytes
3rd pat 7 bitlib.C 6144 bytes
4th ian 8 .bashrc 1024 bytes
5th ian 9 .bashrc 1024 bytes
```
*列表 3. 使用 lpq 检查打印队列*
在这个示例中，共有五个作业，它们是 4、6、7、8、和 9，并且它是名为 HL-2280DW 的打印机的队列，而不是 XP-610 的。在这个示例中使用 `-P` 选项，可简单地显示哪个打印机已经准备好，但是没有队列任务。注意，CUPS 的打印机命名，是大小写不敏感的。还要注意的是，用户 ian 提交了同样的作业两次，当一个作业没有第一时间打印时，经常能看到用户的这种动作。
一般情况下，你可能会查看或者维护你自己的打印作业，但是，root 用户或者其它授权的用户通常会去管理其它打印作业。大多数 CUPS 命令都可以使用一个 `-E` 选项，对 CUPS 服务器与客户端之间的通讯进行加密。
使用 `lprm` 命令从队列中去删除一个 `.bashrc` 作业。如果不使用选项，将删除当前的作业。使用 `-` 选项，将删除全部的作业。要么就如列表 4 那样，指定一个要删除的作业列表。
```
[[pat@atticf27 ~]$ # As user pat (non-administrator)
[pat@atticf27 ~]$ lprm
lprm: Forbidden
[ian@atticf27 ~]$ # As user ian (administrator)
[ian@atticf27 ~]$ lprm 8
[ian@atticf27 ~]$ lpq
HL-2280DW is not ready
Rank Owner Job File(s) Total Size
1st ian 4 permutation.C 6144 bytes
2nd pat 6 bitlib.h 6144 bytes
3rd pat 7 bitlib.C 6144 bytes
4th ian 9 .bashrc 1024 bytes
```
*列表 4. 使用 lprm 删除打印作业*
注意，用户 pat 不能删除队列中的第一个作业，因为它是用户 ian 的。但是，ian 可以删除他自己的 8 号作业。
另外的可以帮你操作打印队列中的作业的命令是 `lp`。使用它可以去修改作业属性，比如打印数量或者优先级。我们假设用户 ian 希望他的作业 9 在用户 pat 的作业之前打印，并且希望打印两份。作业优先级的默认值是 50，它的优先级范围从最低的 1 到最高的 100 之间。用户 ian 可以使用 `-i`、`-n`、以及 `-q` 选项去指定一个要修改的作业，而新的打印数量和优先级可以如下面的列表 5 所示的那样去修改。注意，使用 `-l` 选项的 `lpq` 命令可以提供更详细的输出。
```
[ian@atticf27 ~]$ lpq
HL-2280DW is not ready
Rank Owner Job File(s) Total Size
1st ian 4 permutation.C 6144 bytes
2nd pat 6 bitlib.h 6144 bytes
3rd pat 7 bitlib.C 6144 bytes
4th ian 9 .bashrc 1024 bytes
[ian@atticf27 ~]$ lp -i 9 -q 60 -n 2
[ian@atticf27 ~]$ lpq
HL-2280DW is not ready
Rank Owner Job File(s) Total Size
1st ian 9 .bashrc 1024 bytes
2nd ian 4 permutation.C 6144 bytes
3rd pat 6 bitlib.h 6144 bytes
4th pat 7 bitlib.C 6144 bytes
```
*列表 5. 使用 lp 去改变打印数量和优先级*
最后，`lpmove` 命令可以允许一个作业从一个队列移动到另一个队列。例如，我们可能因为打印机 HL-2280DW 现在不能使用，而想去移动一个作业到另外的队列上。你可以指定一个作业编号，比如 9，或者你可以用一个队列名加一个连字符去限定它，比如，HL-2280DW-0。`lpmove` 命令的操作要求是授权用户。列表 6 展示了如何去从一个队列移动作业到另外的队列，先是指定打印机和作业 ID 移动，然后是移动指定打印机的所有作业。稍后我们可以去再次检查队列，其中一个作业已经在打印中了。
```
[ian@atticf27 ~]$ lpmove HL-2280DW-9 anyprint
[ian@atticf27 ~]$ lpmove HL-2280DW xp-610
[ian@atticf27 ~]$ lpq -a
Rank Owner Job File(s) Total Size
active ian 9 .bashrc 1024 bytes
1st ian 4 permutation.C 6144 bytes
2nd pat 6 bitlib.h 6144 bytes
3rd pat 7 bitlib.C 6144 bytes
[ian@atticf27 ~]$ # A few minutes later
[ian@atticf27 ~]$ lpq -a
Rank Owner Job File(s) Total Size
active pat 6 bitlib.h 6144 bytes
1st pat 7 bitlib.C 6144 bytes
```
*列表 6. 使用 lpmove 移动作业到另外一个打印队列*
如果你使用的是 CUPS 之外的打印服务器，比如 LPD 或者 LPRng，大多数的队列管理功能是由 `lpc` 命令的子命令来处理的。例如，你可以使用 `lpc topq` 去移动一个作业到队列的顶端。其它的 `lpc` 子命令包括 `disable`、`down`、`enable`、`hold`、`move`、`redirect`、`release`、和 `start`。这些子命令在 CUPS 的兼容命令中没有实现。
#### 打印文件
如何去打印创建的作业？大多数图形界面程序都提供了一个打印方法，通常是 **文件** 菜单下面的选项。这些程序为选择打印机、设置页边距、彩色或者黑白打印、打印数量、选择每张纸打印的页面数（每张纸打印两个页面，通常用于讲义）等等，都提供了图形化的工具。现在，我将为你展示如何使用命令行工具去管理这些功能，然后和图形化实现进行比较。
打印文件最简单的方法是使用 `lpr` 命令，然后提供一个文件名字。这将在默认打印机上打印这个文件。而 `lp` 命令不仅可以打印文件，也可以修改打印作业。列表 7 展示了使用这个命令的一个简单示例。注意，`lpr` 会静默处理这个作业，但是 `lp` 会显示处理后的作业的 ID。
```
[ian@atticf27 ~]$ echo "Print this text" > printexample.txt
[ian@atticf27 ~]$ lpr printexample.txt
[ian@atticf27 ~]$ lp printexample.txt
request id is HL-2280DW-12 (1 file(s))
```
*列表 7. 使用 lpr 和 lp 打印*
表 2 展示了 `lpr` 上你可以使用的一些选项。注意， `lp` 的选项和 `lpr` 的很类似，但是名字可能不一样；例如，`-#` 在 `lpr` 上是相当于 `lp` 的 `-n` 选项。查看 man 页面了解更多的信息。
| 选项 | 作用 |
| --- | --- |
| `-C`， `-J` 或 `-T` | 设置一个作业名字。 |
| `-P` | 选择一个指定的打印机。 |
| `-#` | 指定打印数量。注意这不同于 `lp` 命令的 `-n` 选项。 |
| `-m` | 在作业完成时发送电子邮件。 |
| `-l` | 表示打印文件已经为打印做好格式准备。相当于 `-o raw`。 |
| `-o` | 设置一个作业选项。 |
| `-p` | 格式化一个带有阴影标题的文本文件。相关于 `-o prettyprint`。 |
| `-q` | 暂缓（或排队）后面的打印作业。 |
| `-r` | 在文件进入打印池之后，删除文件。 |
*表 2. lpr 的选项*
列表 8 展示了一些选项。我要求打印之后给我发确认电子邮件，那个作业被暂缓执行，并且在打印之后删除文件。
```
[ian@atticf27 ~]$ lpr -P HL-2280DW -J "Ian's text file" -#2 -m -p -q -r printexample.txt
[[ian@atticf27 ~]$ lpq -l
HL-2280DW is ready
ian: 1st [job 13 localhost]
2 copies of Ian's text file 1024 bytes
[ian@atticf27 ~]$ ls printexample.txt
ls: cannot access 'printexample.txt': No such file or directory
```
*列表 8. 使用 lpr 打印*
我现在有一个在 HL-2280DW 打印队列上暂缓执行的作业。然后怎么做？`lp` 命令可以通过使用 `-H` 的各种选项来暂缓或者投放作业。列表 9 展示了如何投放被暂缓的作业。查看 `lp` 命令的 man 页面了解其它选项的信息。
```
[ian@atticf27 ~]$ lp -i 13 -H resume
```
*列表 9. 重启一个暂缓的打印作业*
并不是所有的可用打印机都支持相同的选项集。使用 `lpoptions` 命令去查看一个打印机的常用选项。添加 `-l` 选项去显示打印机专用的选项。列表 10 展示了两个示例。许多常见的选项涉及到人像/风景打印、页面大小和输出在纸张上的布局。详细信息查看 man 页面。
```
[ian@atticf27 ~]$ lpoptions -p HL-2280DW
copies=1 device-uri=dnssd://Brother%20HL-2280DW._pdl-datastream._tcp.local/
finishings=3 job-cancel-after=10800 job-hold-until=no-hold job-priority=50
job-sheets=none,none marker-change-time=1517325288 marker-colors=#000000,#000000
marker-levels=-1,92 marker-names='Black\ Toner\ Cartridge,Drum\ Unit'
marker-types=toner,opc number-up=1 printer-commands=none
printer-info='Brother HL-2280DW' printer-is-accepting-jobs=true
printer-is-shared=true printer-is-temporary=false printer-location
printer-make-and-model='Brother HL-2250DN - CUPS+Gutenprint v5.2.13 Simplified'
printer-state=3 printer-state-change-time=1517325288 printer-state-reasons=none
printer-type=135188 printer-uri-supported=ipp://localhost/printers/HL-2280DW
sides=one-sided
[ian@atticf27 ~]$ lpoptions -l -p xp-610
PageSize/Media Size: *Letter Legal Executive Statement A4
ColorModel/Color Model: *Gray Black
InputSlot/Media Source: *Standard ManualAdj Manual MultiPurposeAdj MultiPurpose
UpperAdj Upper LowerAdj Lower LargeCapacityAdj LargeCapacity
StpQuality/Print Quality: None Draft *Standard High
Resolution/Resolution: *301x300dpi 150dpi 300dpi 600dpi
Duplex/2-Sided Printing: *None DuplexNoTumble DuplexTumble
StpiShrinkOutput/Shrink Page If Necessary to Fit Borders: *Shrink Crop Expand
StpColorCorrection/Color Correction: *None Accurate Bright Hue Uncorrected
Desaturated Threshold Density Raw Predithered
StpBrightness/Brightness: 0 100 200 300 400 500 600 700 800 900 *None 1100
1200 1300 1400 1500 1600 1700 1800 1900 2000 Custom.REAL
StpContrast/Contrast: 0 100 200 300 400 500 600 700 800 900 *None 1100 1200
1300 1400 1500 1600 1700 1800 1900 2000 2100 2200 2300 2400 2500 2600 2700
2800 2900 3000 3100 3200 3300 3400 3500 3600 3700 3800 3900 4000 Custom.REAL
StpImageType/Image Type: None Text Graphics *TextGraphics Photo LineArt
```
*列表 10. 检查打印机选项*
大多数的 GUI 应用程序有一个打印对话框，通常你可以使用 **文件 >打印** 菜单去选择它。图 1 展示了在 GIMP 中的一个示例，GIMP 是一个图像处理程序。
*图 1. 在 GIMP 中打印*
到目前为止，我们所有的命令都是隐式指向到本地的 CUPS 打印服务器上。你也可以通过指定 `-h` 选项和一个端口号（如果不是 CUPS 的默认端口号 631 的话）将打印转向到另外一个系统上的服务器。
### CUPS 和 CUPS 服务器
CUPS 打印系统的核心是 `cupsd` 打印服务器，它是一个运行的守护进程。CUPS 配置文件一般位于 `/etc/cups/cupsd.conf`。`/etc/cups` 目录也有与 CUPS 相关的其它的配置文件。CUPS 一般在系统初始化期间启动，根据你的发行版不同，它也可能通过位于 `/etc/rc.d/init.d` 或者 `/etc/init.d` 目录中的 CUPS 脚本来控制。对于 最新使用 systemd 来初始化的系统，CUPS 服务脚本可能在 `/usr/lib/systemd/system/cups.service` 中。和大多数使用脚本的服务一样，你可以停止、启动、或者重启守护程序。查看我们的教程：[学习 Linux，101：运行级别、引导目标、关闭、和重启动](https://www.ibm.com/developerworks/library/l-lpic1-101-3/)，了解使用初始化脚本的更多信息。
配置文件 `/etc/cups/cupsd.conf` 包含一些管理参数，比如访问打印系统、是否允许远程打印、本地打印池文件等等。在一些系统上，第二部分单独描述了打印队列，它一般是由配置工具自动生成的。列表 11 展示了一个默认的 `cupsd.conf` 文件中的一些条目。注意，注释是以 `#` 字符开头的。默认值通常以注释的方式显示，并且可以通过删除前面的 `#` 字符去改变默认值。
```
# Only listen for connections from the local machine.
Listen localhost:631
Listen /var/run/cups/cups.sock
# Show shared printers on the local network.
Browsing On
BrowseLocalProtocols dnssd
# Default authentication type, when authentication is required...
DefaultAuthType Basic
# Web interface setting...
WebInterface Yes
# Set the default printer/job policies...
<Policy default>
# Job/subscription privacy...
JobPrivateAccess default
JobPrivateValues default
SubscriptionPrivateAccess default
SubscriptionPrivateValues default
# Job-related operations must be done by the owner or an administrator...
<Limit Create-Job Print-Job Print-URI Validate-Job>
Order deny,allow
</Limit>
```
*列表 11. 默认的 /etc/cups/cupsd.conf 文件的部分内容*
可以用在 `cupsd.conf` 中使用的文件、目录、和用户配置命令，现在都存储在作为替代的 `cups-files.conf` 中。这是为了防范某些类型的提权攻击。列表 12 展示了 `cups-files.conf` 文件中的一些条目。注意，正如在文件层次结构标准（FHS）中所期望的那样，打印池文件默认保存在文件系统的 `/var/spool` 目录中。查看 man 页面了解 `cupsd.conf` 和 `cups-files.conf` 配置文件的更多信息。
```
# Location of the file listing all of the local printers...
#Printcap /etc/printcap
# Format of the Printcap file...
#PrintcapFormat bsd
#PrintcapFormat plist
#PrintcapFormat solaris
# Location of all spool files...
#RequestRoot /var/spool/cups
# Location of helper programs...
#ServerBin /usr/lib/cups
# SSL/TLS keychain for the scheduler...
#ServerKeychain ssl
# Location of other configuration files...
#ServerRoot /etc/cups
```
*列表 12. 默认的 /etc/cups/cups-files.conf 配置文件的部分内容*
列表 12 提及了 `/etc/printcap` 文件。这是 LPD 打印服务器的配置文件的名字，并且一些应用程序仍然使用它去确定可用的打印机和它们的属性。它通常是在 CUPS 系统上自动生成的，因此，你可能没有必要去修改它。但是，如果你在诊断用户打印问题，你可能需要去检查它。列表 13 展示了一个示例。
```
# This file was automatically generated by cupsd(8) from the
# /etc/cups/printers.conf file. All changes to this file
# will be lost.
HL-2280DW|Brother HL-2280DW:rm=atticf27:rp=HL-2280DW:
anyprint|Any available printer:rm=atticf27:rp=anyprint:
XP-610|EPSON XP-610 Series:rm=atticf27:rp=XP-610:
```
*列表 13. 自动生成的 /etc/printcap*
这个文件中的每一行都有一个打印机名字、打印机描述，远程机器（`rm`）的名字、以及那个远程机器上的远程打印机（`rp`）。老的 `/etc/printcap` 文件也描述了打印机的能力。
#### 文件转换过滤器
你可以使用 CUPS 打印许多类型的文件，包括明文的文本文件、PDF、PostScript、和各种格式的图像文件，你只需要提供要打印的文件名，除此之外你再无需向 `lpr` 或 `lp` 命令提供更多的信息。这个神奇的壮举是通过使用过滤器来实现的。实际上，这些年来最流行的过滤器就就叫做 magicfilter（神奇的过滤器）。
当打印一个文件时，CUPS 使用多用途因特网邮件扩展（MIME）类型去决定合适的转换过滤器。其它的打印数据包可能使用由 `file` 命令使用的神奇数字机制。关于 `file` 或者神奇数的更多信息可以查看它们的 man 页面。
输入文件被过滤器转换成中间层的光栅格式或者 PostScript 格式。一些作业信息，比如打印数量也会被添加进去。数据最终通过一个后端发送到目标打印机。还有一些可以用手动过滤的输入文件的过滤器（如 a2ps 或 dvips）。你可以通过这些过滤器获得特殊格式的结果，或者去处理一些 CUPS 原生并不支持的文件格式。
#### 添加打印机
CUPS 支持多种打印机，包括：
* 本地连接的并行口和 USB 口打印机
* 因特网打印协议（IPP）打印机
* 远程 LPD 打印机
* 使用 SAMBA 的 Microsoft® Windows® 打印机
* 使用 NCP 的 Novell 打印机
* HP Jetdirect 打印机
当系统启动或者设备连接时，现在的大多数系统都会尝试自动检测和自动配置本地硬件。同样，许多网络打印机也可以被自动检测到。使用 CUPS 的 web 管理工具（<http://localhost:631> 或者 <http://127.0.0.1:631>）去搜索或添加打印机。许多发行版都包含它们自己的配置工具，比如，在 SUSE 系统上的 YaST。图 2 展示了使用 localhost:631 的 CUPS 界面，图 3 展示了 Fedora 27 上的 GNOME 打印机设置对话框。
*图 2. 使用 CUPS 的 web 界面*
*图 3. Fedora 27 上的打印机设置*
你也可以从命令行配置打印机。在配置打印机之前，你需要一些关于打印机和它的连接方式的基本信息。如果是一个远程系统，你还需要一个用户 ID 和密码。
你需要去知道你的打印机使用什么样的驱动程序。不是所有的打印机都支持 Linux，有些打印机在 Linux 上压根就不能使用，或者功能受限。你可以去 OpenPrinting.org 去查看是否有你的特定的打印机的驱动程序。`lpinfo` 命令也可以帮你识别有效的设备类型和驱动程序。使用 `-v` 选项去列出支持的设备，使用 `-m` 选项去列出驱动程序，如列表 14 所示。
```
[ian@atticf27 ~]$ lpinfo -m | grep -i xp-610
lsb/usr/Epson/epson-inkjet-printer-escpr/Epson-XP-610_Series-epson-escpr-en.ppd.gz
EPSON XP-610 Series, Epson Inkjet Printer Driver (ESC/P-R) for Linux
[ian@atticf27 ~]$ locate "Epson-XP-610_Series-epson-escpr-en.ppd.gz"
/usr/share/ppd/Epson/epson-inkjet-printer-escpr/Epson-XP-610_Series-epson-escpr-en.ppd.gz
[ian@atticf27 ~]$ lpinfo -v
network socket
network ipps
network lpd
network beh
network ipp
network http
network https
direct hp
serial serial:/dev/ttyS0?baud=115200
direct parallel:/dev/lp0
network smb
direct hpfax
network dnssd://Brother%20HL-2280DW._pdl-datastream._tcp.local/
network dnssd://EPSON%20XP-610%20Series._ipp._tcp.local/?uuid=cfe92100-67c4-11d4-a45f-ac18266c48aa
network lpd://BRN001BA98A1891/BINARY_P1
network lpd://192.168.1.38:515/PASSTHRU
```
*列表 14. 可用的打印机驱动程序*
这个 Epson-XP-610\_Series-epson-escpr-en.ppd.gz 驱动程序在我的系统上位于 `/usr/share/ppd/Epson/epson-inkjet-printer-escpr/` 目录中。
如果你找不到驱动程序，你可以到打印机生产商的网站看看，说不定会有专用的驱动程序。例如，在写这篇文章的时候，Brother 就有一个我的 HL-2280DW 打印机的驱动程序，但是，这个驱动程序在 OpenPrinting.org 上还没有列出来。
如果你收集齐了基本信息，你可以如列表 15 所示的那样，使用 `lpadmin` 命令去配置打印机。为此，我将为我的 HL-2280DW 打印机创建另外一个实例，以便于双面打印。
```
[ian@atticf27 ~]$ lpinfo -m | grep -i "hl.*2280"
HL2280DW.ppd Brother HL2280DW for CUPS
lsb/usr/HL2280DW.ppd Brother HL2280DW for CUPS
[ian@atticf27 ~]$ lpadmin -p HL-2280DW-duplex -E -m HL2280DW.ppd \
> -v dnssd://Brother%20HL-2280DW._pdl-datastream._tcp.local/ \
> -D "Brother 1" -o sides=two-sided-long-edge
[ian@atticf27 ~]$ lpstat -a
anyprint accepting requests since Mon 29 Jan 2018 01:17:09 PM EST
HL-2280DW accepting requests since Tue 30 Jan 2018 10:56:10 AM EST
HL-2280DW-duplex accepting requests since Wed 31 Jan 2018 11:41:16 AM EST
HXP-610 accepting requests since Mon 29 Jan 2018 10:34:49 PM EST
```
*列表 15. 配置一台打印机*
你可以使用带 `-c` 选项的 `lpadmin` 命令去创建一个仅用于双面打印的新分类，而不用为了双面打印去创建一个打印机的副本。
如果你需要删除一台打印机，使用带 `-x` 选项的 `lpadmin` 命令。
列表 16 展示了如何去删除打印机和创建一个替代类。
```
[ian@atticf27 ~]$ lpadmin -x HL-2280DW-duplex
[ian@atticf27 ~]$ lpadmin -p HL-2280DW -c duplex -E -D "Duplex printing" -o sides=two-sided-long-edge
[ian@atticf27 ~]$ cupsenable duplex
[ian@atticf27 ~]$ cupsaccept duplex
[ian@atticf27 ~]$ lpstat -a
anyprint accepting requests since Mon 29 Jan 2018 01:17:09 PM EST
duplex accepting requests since Wed 31 Jan 2018 12:12:05 PM EST
HL-2280DW accepting requests since Wed 31 Jan 2018 11:51:16 AM EST
XP-610 accepting requests since Mon 29 Jan 2018 10:34:49 PM EST
```
*列表 16. 删除一个打印机和创建一个类*
你也可以使用 `lpadmin` 或者 `lpoptions` 命令去设置各种打印机选项。详细信息请查看 man 页面。
### 排错
如果你有打印问题，尝试下列的提示：
* 确保 CUPS 服务器正在运行。你可以使用 `lpstat` 命令，如果它不能连接到 cupsd 守护程序，它将会报告一个错误。或者，你可以使用 `ps -ef` 命令在输出中去检查是否有 cupsd。
* 如果你试着排队一个打印作业而得到一个错误信息，指示打印机不接受这个作业，你可以使用 `lpstat -a` 或者 `lpc status` 去检查那个打印机是否接受作业。
* 如果一个队列中的作业没有打印，使用 `lpstat -p` 或 `lpc status` 去检查那个打印机是否接受作业。如前面所讨论的那样，你可能需要将这个作业移动到其它的打印机。
* 如果这个打印机是远程的，检查它在远程系统上是否存在，并且是可操作的。
* 检查配置文件，确保特定的用户或者远程系统允许在这个打印机上打印。
* 确保防火墙允许远程打印请求，是否允许从其它系统到你的系统，或者从你的系统到其它系统的数据包通讯。
* 验证是否有正确的驱动程序。
正如你所见，打印涉及到你的系统中的几个组件，甚至还有网络。在本教程中，基于篇幅的考虑，我们仅能给你的诊断提供了几个着手点。大多数的 CUPS 系统也有实现我们所讨论的命令行功能的图形界面。一般情况下，这个界面是从本地主机使用浏览器指向 631 端口（<http://localhost:631> 或 <http://127.0.0.1:631>）来访问的，如前面的图 2 所示。
你可以通过将 CUPS 运行在前台而不是做为一个守护进程来诊断它的问题。如果有需要，你也可以通过这种方式去测试替代的配置文件。运行 `cupsd -h` 获得更多信息，或者查看 man 页面。
CUPS 也带有一个访问日志和错误日志。你可以在 `cupsd.conf` 中使用 `LogLevel` 语句来改变日志级别。默认情况下，日志是保存在 `/var/log/cups` 目录。它们可以在浏览器界面（<http://localhost:631>）下，从 **Administration** 选项卡中查看。使用不带任何选项的 `cupsctl` 命令可以显示日志选项。也可以编辑 `cupsd.conf` 或者使用 `cupsctl` 去调整各种日志参数。查看 `cupsctl` 命令的 man 页面了解更多信息。
在 Ubuntu 的 Wiki 页面上的 [调试打印问题](https://wiki.ubuntu.com/DebuggingPrintingProblems) 页面也是一个非常好的学习的地方。
这就是关于打印和 CUPS 的介绍。
---
via: <https://www.ibm.com/developerworks/library/l-lpic1-108-4/index.html>
作者：[Ian Shields](https://www.ibm.com) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我的冒险旅程之迁移回 Windows
|
Christopher Shaw
|
https://www.chris-shaw.com/blog/my-adventure-migrating-back-to-windows
|
我已经主要使用 Linux 大约 10 年了，而且主要是 Ubuntu。但在最新发布的版本中，我决定重新回到我通常不喜欢的操作系统： Windows 10。
|
/data/attachment/album/201804/13/080909xy9kc2w3q2qeq0qb.jpg.thumb.jpg
|
/data/attachment/album/201804/13/080909xy9kc2w3q2qeq0qb.jpg
| true | false | true |
MjSeven
| false |
[
"Windows"
] |
观点
|
{
"viewnum": 8343,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "218.81.225.68",
"message": "可以尝试下deepin",
"username": "mistyos [Firefox 58.0|GNU/Linux]",
"date": "2018-04-14T00:00:59"
}
] |
[] |
我已经主要使用 Linux 大约 10 年了，而且主要是 Ubuntu。但在最新发布的版本中，我决定重新回到我通常不喜欢的操作系统： Windows 10。
| 2018-04-13T08:09:06 | 2018-04-13T08:09:06 | 9,539 |
/article-9539-1.html
|
我已经主要使用 Linux 大约 10 年了，而且主要是 Ubuntu。但在最新发布的版本中，我决定重新回到我通常不喜欢的操作系统： Windows 10。
我一直是 Linux 的粉丝，我最喜欢的两个发行版是 Debian 和 Ubuntu。现今作为一个服务器操作系统，Linux 是完美无暇的，但在桌面上一直存在不同程度的问题。
最近一系列的问题让我意识到，我不需要使用 Linux 作为我的桌面操作系统，我仍然是一个 Linux 粉丝，但基于我安装 Ubuntu 17.10 的经验，我已经决定回到 Windows。
### 什么使我选择了回归
问题是，当 Ubuntu 17.10 出来后，我像往常一样进行全新安装，但遇到了一些非常奇怪的新问题。
* Dell D3100 Dock 不再工作（包括临时规避方案也没用）
* Ubuntu 意外死机（随机）
* 双击桌面上的图标没反应
* 使用 HUD 搜索诸如“tweaks”之类的程序会尝试安装 META 桌面版本
* GUI 比标准的 GNOME 感觉更糟糕
现在我确实考虑回到使用 Ubuntu 16.04 或另一个发行版，但是我觉得 Unity 7 是最精致的桌面环境，而另外唯一一个优雅且稳定的是 Windows 10。
除此之外，使用 Linux 而不是使用 Windows 也有一些固有的问题，如：
* 大多数商用软件不可用，E.G Maya、 PhotoShop、 Microsoft Office（大多数情况下，替代品并不相同）等等。
* 大多数游戏都没有移植到 Linux 上，包括来自 EA、 Rockstar Ect. 等主要工作室的游戏。
* 对于大多数硬件来说，其 Linux 驱动程序是厂商的次要考虑。
在决定使用 Windows 之前，我确实考虑过其他发行版和操作系统。
与此同时，我看到了更多的“微软爱 Linux ”的行动，并且了解了 WSL。他们的新开发者的关注角度对我来说很有意思，于是我试了一下。
### 我在 Windows 找到了什么
我使用计算机主要是为了编程，我也使用虚拟机、git 和 ssh，并且大部分工作依赖于 bash。我偶尔也会玩游戏，观看 netflix 和一些轻松的办公室工作。
总之，我期待在 Ubuntu 中保留当前的工作流程并将其移植到 Windows 上。我也想利用 Windows 的优点。
* 所有的 PC 游戏支持 Windows
* 大多数程序是原生的
* 微软办公软件
虽然使用 Windows 有很多坑，但是我打算正确对待它，所以我不担心一般的 Windows 故障，例如病毒和恶意软件。
### Windows 的子系统 Linux（Windows 上的 Ubuntu 中的 Bash）
微软与 Canonical 的密切合作将 Ubuntu 带到了 Windows 上。在经过快速设置和启动程序之后，你将拥有非常熟悉的 bash 界面。
我一直在研究其局限性，但是在写这篇文章时我碰到的唯一真正的限制是它从硬件中抽象了出来。例如，`lsblk` 不会显示你有什么分区，因为子系统里的 Ubuntu 没有提供这些信息。
但是除了访问底层工具之外，我发现其体验非常熟悉，也很棒。
我在下面的工作流程中使用了它。
* 生成 SSH 密钥对
* 使用 Git 和 Github 来管理我的仓库
* SSH 到几个服务器，包括不用密码
* 为本地数据库运行 MySQL
* 监视系统资源
* 使用 Vim 编辑配置文件
* 运行 Bash 脚本
* 运行本地 Web 服务器
* 运行 PHP、NodeJS
到目前为止，它已经被证明是非常强大的工具。除了是在 Windows 10 用户界面之中，我的工作流程感觉和我在 Ubuntu 上几乎一样。尽管我的多数工作可以在 WSL 中处理，但我仍然打算通过虚拟机进行更深入的工作，这可能超出了 WSL 的范围。
### 不需要用 Wine
我遇到的另一个主要问题是兼容性问题。我很少使用 Wine 来使用 Windows 软件。（LCTT 译注：Wine 是可以使 Linux 上运行 Windows 应用的软件）但是有时它是必需的，尽管通常体验不是很好。
#### HeidiSQL
我首先安装的程序之一是 HeidiSQL，它是我最喜欢的数据库客户端之一。它可以在 Wine 下工作，但是感觉很不好，所以我在 Linux 下丢掉它而使用了 MySQL Workbench。回到了 Windows 中，就像一个可靠的老朋友回来了。
#### 游戏平台 / Steam
没有游戏的 Windows 电脑是无法想象的。我从 Steam 的网站上安装了它，我的 Linux 游戏，加上我的 Windows 游戏就变大了 5 倍，并且包括 GTA V （LCTT 译注： GTA V 是一款名叫侠盗飞车的游戏) 等 AAA 级游戏。而这些我在 Ubuntu 中只能梦想。
我对 SteamOS 有很大的期望，并且一直会持续如此。但是我认为在可预见的将来，它不会在任何地方的游戏市场中崭露头角。所以如果你想在 PC 上玩游戏，你确实需要 Windows。
还有一点需要注意的是， 你的 nvidia 显卡的驱动程序会得到很好的支持，这使得像 TF2 （LCTT 译注： 这是一款名叫军团要塞 2 的游戏）这样的一些 Linux 原生游戏运行的稍好一些。
**Windows 在游戏方面总是优越的，所以这并不令人感到意外。**
### 从 USB 硬盘运行，为什么
我在我的主固态硬盘上运行 Linux，但在过去，我是从 usb 棒和 usb 硬盘运行它的。我习惯了 Linux 的这种持久性，这让我可以在不丢失主要操作系统的情况下长期尝试多个版本。现在我尝试将 Windows 安装到 USB 连接的硬盘上时，它无法工作也不可能工作。所以当我将 Windows 硬盘分区的克隆作为备份时，我很惊讶我可以通过 USB 启动它。
这对我来说已经成为一个方便的选择，因为我打算将我的工作笔记本电脑迁移回 Windows，但如果不想冒险，那就把它扔在那里吧。
所以我在过去的几天里，我使用 USB 来运行它，除了一些错误的消息外，我没有通过 USB 运行发现它真正的缺点。
这样做主要的问题是：
* 较慢的启动速度
* 恼人的信息：不要拔掉你的 USB
* 无法激活它
**我可能会写一篇关于 USB 驱动器上的 Windows 的文章，这样我们可以有更详细的了解。**
### 那么结论是什么？
我使用 Windows 10 大约两周了，并没有注意到它对我的工作流程有任何的负面影响。尽管过程会有一些小问题，但我需要的所以工具都在手边，并且操作系统一般都在运行。
### 我会留在 Windows吗？
虽然现在还为时尚早，但我想在可见的未来我会坚持使用 Windows。
---
via: <https://www.chris-shaw.com/blog/my-adventure-migrating-back-to-windows>
作者：[Christopher Shaw](https://www.chris-shaw.com) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
高级 SSH 速查表
|
Ben Cotton
|
https://opensource.com/sites/default/files/gated-content/cheat_sheet_ssh_v03.pdf
|
所有人都知道 SSH 是一种远程登录工具，然而它也有许多其他用途。
|
/data/attachment/album/201804/13/083137e7pb88ll6pl7plzl.png.thumb.jpg
|
/data/attachment/album/201804/13/083137e7pb88ll6pl7plzl.png
| true | false | true |
kennethXia
| false |
[
"SSH"
] |
技术
|
{
"viewnum": 7772,
"commentnum": 0,
"favtimes": 7,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
所有人都知道 SSH 是一种远程登录工具，然而它也有许多其他用途。
| 2018-04-13T08:31:00 | 2018-04-13T08:31:00 | 9,540 |
/article-9540-1.html
|
所有人都知道 SSH 是一种远程登录工具，然而它也有许多其他用途。
创建一个 SOCKS 代理来浏览网页（也就是翻墙啦）：
>
>
> ```
> ssh -D <port> <remote_host>
>
> ```
>
> 设置 `localhost:<port>` 作为你浏览器的代理
>
>
>
连接一个堡垒机后的 Windows RDP 主机：
>
>
> ```
> ssh -L <port>:<target_host>:3389 <bastion_server>
>
> ```
>
> 让你的 RDP 客户端连接到 `localhost:<port>`
>
>
>
在不使用 VNC 端口的情况下，连接远程 VNC 主机：
>
>
> ```
> ssh -L 5901:localhost:5901 <remote_host>
>
> ```
>
> 让你的 VNC 客户端连接到 `localhost:5901`
>
>
>
按照这个思路，你可以映射任意端口：LDAP (389)、631 (CUPS)、8080 (替代的 HTTP)，等等。
产生一个新的 SSH 密钥对：
>
>
> ```
> ssh-keygen
>
> ```
>
>
更新密钥对的密码：
>
>
> ```
> ssh-keygen -p
>
> ```
>
>
把公钥复制到远程主机上：
>
>
> ```
> ssh-copy-id -i <identity file> <remote_host>
>
> ```
>
>
SSH 有一堆命令行选项，但是如果有一些是你经常使用的，你可以为它们在 SSH 配置文件 (${HOME}/.ssh/config) 里创建一个入口。比如：
>
>
> ```
> host myhouse
> User itsme
> HostName house.example.com
>
> ```
>
>
那么你就可以输入 `ssh myhouse` 来代替 `ssh itsme@house.example.com`。
以下是常用的命令行选项和他们的配置文件写法。一些是常用的简化写法。请查看 `ssh(1)` 和 `ssh_config(5)` 的手册页来获取详尽信息。
| 命令行 | 配置文件 | 描述 |
| --- | --- | --- |
| `-l <login name>` | `User <login name>` | 远程主机的登录用户名。 |
| `-i <identity file>` | `IdentityFile <identity file>` | 指定要使用的鉴权文件（SSH 密码对）。 |
| `-p <remote port>` | `Port <remote port>` | 远程 SSH 守护进程监听的端口号。 (默认为 22) |
| `-C` | `Compression <yes,no>` | 压缩往来信息。 (默认为 no) |
| `-D <port>` | `DynamicForward <port>` | 把本地端口的报文转发到远程主机。 |
| `-X` | `ForwardX11 <yes,no>` | 把 X11 的图像数据转发到远程主机的端口. (默认为 no) |
| `-A` | `ForwardAgent <yes,no>` | 把授权代理的报文转发给远程主机。如果你使用第三方主机登录，这个功能将很有用。 (默认为 no) |
| `-4`（仅使用 IPv4） `-6` （仅使用 IPv6） | `AddressFamily <any,inet4,inet6>` | 指定仅使用 IPv4 或者 IPv6。 |
| `-L <local port>:<target host>:<target port>` | `LocalForward <local port>:<target host>:<target port>` | 把本地主机指定端口的报文转发到远程主机的某个端口。 |
opensource.com Twitter @opensourceway | facebook.com/opensourceway | IRC: #opensource.com on Freenode
---
作者简介：
Ben Cotton 是业余的气象学家和职业的高性能计算工程师。Ben 是微软 Azure 的产品营销经理，专注于高性能计算。他是一个 Fedora 用户和贡献者，共同创立了一个当地的开放源码群，并且是开源促进会的成员和保护自由软件的支持者。通过以下方式联系他 Twitter (@FunnelFiasco) 或者 FunnelFiasco.com.
---
via: <https://opensource.com/sites/default/files/gated-content/cheat_sheet_ssh_v03.pdf>
作者：[BEN COTTON](https://opensource.com/users/bcotton) 译者：[kennethXia](https://github.com/kennethXia) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何创建一个 Docker 镜像
|
Swapnil Bhartiya
|
https://www.linux.com/blog/learn/intro-to-linux/2018/1/how-create-docker-image
|
在这篇文章中，我们将学习创建 Docker 镜像的基本知识。
|
/data/attachment/album/201804/13/203226wcb8i8v6zrc88ff8.jpg.thumb.jpg
|
/data/attachment/album/201804/13/203226wcb8i8v6zrc88ff8.jpg
| true | false | true |
qhwdw
| false |
[
"容器",
"Docker"
] |
容器与云
|
{
"viewnum": 15422,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "112.12.36.136",
"message": "没有登上dockerhub可以搭建apache吗",
"username": "来自浙江金华的 Chrome 63.0|Windows 10 用户",
"date": "2019-07-29T23:40:10"
}
] |
[
{
"raid": 9773,
"displayorder": 0
}
] |
在这篇文章中，我们将学习创建 Docker 镜像的基本知识。
| 2018-04-13T20:32:00 | 2018-04-13T20:32:00 | 9,541 |
/article-9541-1.html
|
在 [前面的文章](/article-9773-1.html) 中，我们学习了在 Linux、macOS、以及 Windows 上如何使用 Docker 的基础知识。在这篇文章中，我们将学习创建 Docker 镜像的基本知识。我们可以在 DockerHub 上得到可用于你自己的项目的预构建镜像，并且也可以将你自己的镜像发布到这里。
我们使用预构建镜像得到一个基本的 Linux 子系统，因为，从头开始构建需要大量的工作。你可以使用 Alpine（ Docker 版使用的官方版本）、Ubuntu、BusyBox、或者 scratch。在我们的示例中，我将使用 Ubuntu。
在我们开始构建镜像之前，让我们先“容器化”它们！我的意思是，为你的所有 Docker 镜像创建目录，这样你就可以维护不同的项目和阶段，并保持它们彼此隔离。
```
$ mkdir dockerprojects
cd dockerprojects
```
现在，在 `dockerprojects` 目录中，你可以使用自己喜欢的文本编辑器去创建一个 `Dockerfile` 文件；我喜欢使用 nano，它对新手来说很容易上手。
```
$ nano Dockerfile
```
然后添加这样的一行内容：
```
FROM Ubuntu
```
使用 `Ctrl+Exit` 然后选择 `Y` 去保存它。
现在开始创建你的新镜像，然后给它起一个名字（在刚才的目录中运行如下的命令）：
```
$ docker build -t dockp .
```
（注意命令后面的圆点）这样就创建成功了，因此，你将看到如下内容：
```
Sending build context to Docker daemon 2.048kB
Step 1/1 : FROM ubuntu
---> 2a4cca5ac898
Successfully built 2a4cca5ac898
Successfully tagged dockp:latest
```
现在去运行和测试一下你的镜像：
```
$ docker run -it Ubuntu
```
你将看到 root 提示符：
```
root@c06fcd6af0e8:/#
```
这意味着在 Linux、Windows、或者 macOS 中你可以运行一个最小的 Ubuntu 了。你可以运行所有的 Ubuntu 原生命令或者 CLI 实用程序。
我们来查看一下在你的目录下你拥有的所有 Docker 镜像：
```
$docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
dockp latest 2a4cca5ac898 1 hour ago 111MB
ubuntu latest 2a4cca5ac898 1 hour ago 111MB
hello-world latest f2a91732366c 8 weeks ago 1.85kB
```
你可以看到共有三个镜像：`dockp`、`Ubuntu`、和 `hello-world`， `hello-world` 是我在几周前创建的，这一系列的前面的文章就是在它下面工作的。构建一个完整的 LAMP 栈可能是一个挑战，因此，我们使用 Dockerfile 去创建一个简单的 Apache 服务器镜像。
从本质上说，Dockerfile 是安装所有需要的包、配置、以及拷贝文件的一套指令。在这个案例中，它是安装配置 Apache 和 Nginx。
你也可以在 DockerHub 上去创建一个帐户，然后在构建镜像之前登入到你的帐户，在这个案例中，你需要从 DockerHub 上拉取一些东西。从命令行中登入 DockerHub，运行如下所求的命令：
```
$ docker login
```
在登入时输入你的用户名和密码。
接下来，为这个 Docker 项目，在目录中创建一个 Apache 目录：
```
$ mkdir apache
```
在 Apache 目录中创建 Dockerfile 文件：
```
$ nano Dockerfile
```
然后，粘贴下列内容：
```
FROM ubuntu
MAINTAINER Kimbro Staken version: 0.1
RUN apt-get update && apt-get install -y apache2 && apt-get clean && rm -rf /var/lib/apt/lists/*
ENV APACHE_RUN_USER www-data
ENV APACHE_RUN_GROUP www-data
ENV APACHE_LOG_DIR /var/log/apache2
EXPOSE 80
CMD ["/usr/sbin/apache2", "-D", "FOREGROUND"]
```
然后，构建镜像：
```
docker build -t apache .
```
（注意命令尾部的空格和圆点）
这将花费一些时间，然后你将看到如下的构建成功的消息：
```
Successfully built e7083fd898c7
Successfully tagged ng:latest
Swapnil:apache swapnil$
```
现在，我们来运行一下这个服务器：
```
$ docker run -d apache
a189a4db0f7c245dd6c934ef7164f3ddde09e1f3018b5b90350df8be85c8dc98
```
发现了吗，你的容器镜像已经运行了。可以运行如下的命令来检查所有运行的容器：
```
$ docker ps
CONTAINER ID IMAGE COMMAND CREATED
a189a4db0f7 apache "/usr/sbin/apache2ctl" 10 seconds ago
```
你可以使用 `docker kill` 命令来杀死容器：
```
$docker kill a189a4db0f7
```
正如你所见，这个 “镜像” 它已经永久存在于你的目录中了，而不论运行与否。现在你可以根据你的需要创建很多的镜像，并且可以从这些镜像中繁衍出来更多的镜像。
这就是如何去创建镜像和运行容器。
想学习更多内容，你可以打开你的浏览器，然后找到更多的关于如何构建像 LAMP 栈这样的完整的 Docker 镜像的文档。这里有一个帮你实现它的 [Dockerfile](https://github.com/fauria/docker-lamp/blob/master/Dockerfile) 文件。在下一篇文章中，我将演示如何推送一个镜像到 DockerHub。
你可以通过来自 Linux 基金会和 edX 的 [“介绍 Linux”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 免费课程来学习更多的知识。
---
via: <https://www.linux.com/blog/learn/intro-to-linux/2018/1/how-create-docker-image>
作者：[SWAPNIL BHARTIYA](https://www.linux.com/users/arnieswap) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为初学者提供的 uniq 命令教程及示例
|
Sk
|
https://www.ostechnix.com/uniq-command-tutorial-examples-beginners/
|
该命令会帮助你轻松地从文件中找到重复的行。它不仅用于查找重复项，而且我们还可以使用它来删除重复项，显示重复项的出现次数，只显示重复的行，只显示唯一的行等。
|
/data/attachment/album/201804/13/204629q8eeab5ftiltxcmi.jpg.thumb.jpg
|
/data/attachment/album/201804/13/204629q8eeab5ftiltxcmi.jpg
| true | false | true |
MjSeven
| false |
[
"uniq"
] |
技术
|
{
"viewnum": 8396,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
该命令会帮助你轻松地从文件中找到重复的行。它不仅用于查找重复项，而且我们还可以使用它来删除重复项，显示重复项的出现次数，只显示重复的行，只显示唯一的行等。
| 2018-04-13T20:46:47 | 2018-04-13T20:46:47 | 9,542 |
/article-9542-1.html
|
如果你主要是在命令行上工作，并且每天处理大量的文本文件，那么你应该了解下 `uniq` 命令。该命令会帮助你轻松地从文件中找到重复的行。它不仅用于查找重复项，而且我们还可以使用它来删除重复项，显示重复项的出现次数，只显示重复的行，只显示唯一的行等。由于 `uniq` 命令是 GNU coreutils 包的一部分，所以它预装在大多数 Linux 发行版中，让我们不需要费心安装。来看一些实际的例子。
请注意，除非重复行是相邻的，否则 `uniq` 不会删除它们。因此，你可能需要先对它们进行排序，或将排序命令与 `uniq` 组合以获得结果。让我给你看一些例子。
首先，让我们创建一个带有一些重复行的文件：
```
vi ostechnix.txt
```
```
welcome to ostechnix
welcome to ostechnix
Linus is the creator of Linux.
Linux is secure by default
Linus is the creator of Linux.
Top 500 super computers are powered by Linux
```
正如你在上面的文件中看到的，我们有一些重复的行（第一行和第二行，第三行和第五行是重复的）。
### 1、 使用 uniq 命令删除文件中的连续重复行
如果你在不使用任何参数的情况下使用 `uniq` 命令，它将删除所有连续的重复行，只显示唯一的行。
```
uniq ostechnix.txt
```
示例输出：
如你所见， `uniq` 命令删除了给定文件中的所有连续重复行。你可能还注意到，上面的输出仍然有第二行和第四行重复了。这是因为 `uniq` 命令只有在相邻的情况下才会删除重复的行，当然，我们也可以删除非连续的重复行。请看下面的第二个例子。
### 2、 删除所有重复的行
```
sort ostechnix.txt | uniq
```
示例输出：
看到了吗？没有重复的行。换句话说，上面的命令将显示在 `ostechnix.txt` 中只出现一次的行。我们使用 `sort` 命令与 `uniq` 命令结合，因为，就像我提到的，除非重复行是相邻的，否则 `uniq` 不会删除它们。
### 3、 只显示文件中唯一的一行
为了只显示文件中唯一的一行，可以这样做：
```
sort ostechnix.txt | uniq -u
```
示例输出：
```
Linux is secure by default
Top 500 super computers are powered by Linux
```
如你所见，在给定的文件中只有两行是唯一的。
### 4、 只显示重复的行
同样的，我们也可以显示文件中重复的行，就像下面这样：
```
sort ostechnix.txt | uniq -d
```
示例输出：
```
Linus is the creator of Linux.
welcome to ostechnix
```
这两行在 `ostechnix.txt` 文件中是重复的行。请注意 `-d`（小写 `d`） 将会只打印重复的行，每组显示一个。打印所有重复的行，使用 `-D`（大写 `D`），如下所示：
```
sort ostechnix.txt | uniq -D
```
在下面的截图中看两个选项的区别：
### 5、 显示文件中每一行的出现次数
由于某种原因，你可能想要检查给定文件中每一行重复出现的次数。要做到这一点，使用 `-c` 选项，如下所示：
```
sort ostechnix.txt | uniq -c
```
示例输出：
```
2 Linus is the creator of Linux.
1 Linux is secure by default
1 Top 500 super computers are powered by Linux
2 welcome to ostechnix
```
我们还可以按照每一行的出现次数进行排序，然后显示，如下所示：
```
sort ostechnix.txt | uniq -c | sort -nr
```
示例输出：
```
2 welcome to ostechnix
2 Linus is the creator of Linux.
1 Top 500 super computers are powered by Linux
1 Linux is secure by default
```
### 6、 将比较限制为 N 个字符
我们可以使用 `-w` 选项来限制对文件中特定数量字符的比较。例如，让我们比较文件中的前四个字符，并显示重复行，如下所示：
```
uniq -d -w 4 ostechnix.txt
```
### 7、 忽略比较指定的 N 个字符
像对文件中行的前 N 个字符进行限制比较一样，我们也可以使用 `-s` 选项来忽略比较前 N 个字符。
下面的命令将忽略在文件中每行的前四个字符进行比较：
```
uniq -d -s 4 ostechnix.txt
```
为了忽略比较前 N 个字段（LCTT 译注：即前几列）而不是字符，在上面的命令中使用 `-f` 选项。
欲了解更多详情，请参考帮助部分：
```
uniq --help
```
也可以使用 `man` 命令查看：
```
man uniq
```
今天就到这里！我希望你现在对 `uniq` 命令及其目的有一个基本的了解。如果你发现我们的指南有用，请在你的社交网络上分享，并继续支持我们。更多好东西要来了，请继续关注！
干杯！
---
via: <https://www.ostechnix.com/uniq-command-tutorial-examples-beginners/>
作者：[SK](https://www.ostechnix.com) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
AI 和机器学习中暗含的算法偏见
|
Justin Sherman
|
https://opensource.com/article/18/1/how-open-source-can-fight-algorithmic-bias
|
我们又能通过开源社区做些什么？
|
/data/attachment/album/201804/13/231826m625sc7esz588586.jpg.thumb.jpg
|
/data/attachment/album/201804/13/231826m625sc7esz588586.jpg
| true | false | true |
Valoniakim
| false |
[
"AI",
"机器学习",
"人工智能"
] |
观点
|
{
"viewnum": 6333,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
我们又能通过开源社区做些什么？
| 2018-04-13T23:18:33 | 2018-04-13T23:18:33 | 9,543 |
/article-9543-1.html
|
>
> 我们又能通过开源社区做些什么？
>
>
>
在我们的世界里，算法无处不在，偏见也是一样。从社会媒体新闻的提供到流式媒体服务的推荐到线上购物，计算机算法，尤其是机器学习算法，已经渗透到我们日常生活的每一个角落。至于偏见，我们只需要参考 2016 年美国大选就可以知道，偏见是怎样在明处与暗处影响着我们的社会。
很难想像，我们经常忽略的一点是这二者的交集：计算机算法中存在的偏见。
与我们大多数人的认知相反，科技并不是客观的。 AI 算法和它们的决策程序是由它们的研发者塑造的，他们写入的代码，使用的“[训练](https://www.crowdflower.com/what-is-training-data/)”数据还有他们对算法进行[应力测试](https://medium.com/microsoft-design/how-to-recognize-exclusion-in-ai-ec2d6d89f850) 的过程，都会影响这些算法今后的选择。这意味着研发者的价值观、偏见和人类缺陷都会反映在软件上。如果我只给实验室中的人脸识别算法提供白人的照片，当遇到不是白人照片时，它[不会认为照片中的是人类](https://www.ted.com/talks/joy_buolamwini_how_i_m_fighting_bias_in_algorithms) 。这结论并不意味着 AI 是“愚蠢的”或是“天真的”，它显示的是训练数据的分布偏差：缺乏多种的脸部照片。这会引来非常严重的后果。
这样的例子并不少。全美范围内的[州法院系统](https://www.wired.com/2017/04/courts-using-ai-sentence-criminals-must-stop-now/) 都使用“黑盒”对罪犯进行宣判。由于训练数据的问题，[这些算法对黑人有偏见](https://www.propublica.org/article/machine-bias-risk-assessments-in-criminal-sentencing) ，他们对黑人罪犯会选择更长的服刑期，因此监狱中的种族差异会一直存在。而这些都发生在科技的客观性伪装下，这是“科学的”选择。
美国联邦政府使用机器学习算法来计算福利性支出和各类政府补贴。[但这些算法中的信息](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3012499)，例如它们的创造者和训练信息，都很难找到。这增加了政府工作人员进行不平等补助金分发操作的几率。
算法偏见情况还不止这些。从 Facebook 的新闻算法到医疗系统再到警用携带相机，我们作为社会的一部分极有可能对这些算法输入各式各样的偏见、性别歧视、仇外思想、社会经济地位歧视、确认偏误等等。这些被输入了偏见的机器会大量生产分配，将种种社会偏见潜藏于科技客观性的面纱之下。
这种状况绝对不能再继续下去了。
在我们对人工智能进行不断开发研究的同时，需要降低它的开发速度，小心仔细地开发。算法偏见的危害已经足够大了。
### 我们能怎样减少算法偏见？
最好的方式是从算法训练的数据开始审查，根据 [微软的研究人员](https://medium.com/microsoft-design/how-to-recognize-exclusion-in-ai-ec2d6d89f850) 所说，这方法很有效。
数据分布本身就带有一定的偏见性。编程者手中的美国公民数据分布并不均衡，本地居民的数据多于移民者，富人的数据多于穷人，这是极有可能出现的情况。这种数据的不平均会使 AI 对我们是社会组成得出错误的结论。例如机器学习算法仅仅通过统计分析，就得出“大多数美国人都是富有的白人”这个结论。
即使男性和女性的样本在训练数据中等量分布，也可能出现偏见的结果。如果训练数据中所有男性的职业都是 CEO，而所有女性的职业都是秘书（即使现实中男性 CEO 的数量要多于女性），AI 也可能得出女性天生不适合做 CEO 的结论。
同样的，大量研究表明，用于执法部门的 AI 在检测新闻中出现的罪犯照片时，结果会 [惊人地偏向](https://www.hivlawandpolicy.org/sites/default/files/Race%20and%20Punishment-%20Racial%20Perceptions%20of%20Crime%20and%20Support%20for%20Punitive%20Policies%20%282014%29.pdf) 黑人及拉丁美洲裔居民。
在训练数据中存在的偏见还有很多其他形式，不幸的是比这里提到的要多得多。但是训练数据只是审查方式的一种，通过“应力测验”找出人类存在的偏见也同样重要。
如果提供一张印度人的照片，我们自己的相机能够识别吗？在两名同样水平的应聘者中，我们的 AI 是否会倾向于推荐住在市区的应聘者呢？对于情报中本地白人恐怖分子和伊拉克籍恐怖分子，反恐算法会怎样选择呢？急诊室的相机可以调出儿童的病历吗？
这些对于 AI 来说是十分复杂的数据，但我们可以通过多项测试对它们进行定义和传达。
### 为什么开源很适合这项任务？
开源方法和开源技术都有着极大的潜力改变算法偏见。
现代人工智能已经被开源软件占领，TensorFlow、IBM Watson 还有 [scikit-learn](http://scikit-learn.org/stable/) 这类的程序包都是开源软件。开源社区已经证明它能够开发出强健的，经得住严酷测试的机器学习工具。同样的，我相信，开源社区也能开发出消除偏见的测试程序，并将其应用于这些软件中。
调试工具如哥伦比亚大学和理海大学推出的 [DeepXplore](https://arxiv.org/pdf/1705.06640.pdf)，增强了 AI 应力测试的强度，同时提高了其操控性。还有 [麻省理工学院的计算机科学和人工智能实验室](https://www.csail.mit.edu/research/understandable-deep-networks)完成的项目，它开发出敏捷快速的样机研究软件，这些应该会被开源社区采纳。
开源技术也已经证明了其在审查和分类大组数据方面的能力。最明显的体现在开源工具在数据分析市场的占有率上（Weka、Rapid Miner 等等）。应当由开源社区来设计识别数据偏见的工具，已经在网上发布的大量训练数据组比如 [Kaggle](https://www.kaggle.com/datasets) 也应当使用这种技术进行识别筛选。
开源方法本身十分适合消除偏见程序的设计。内部谈话、私人软件开发及非民主的决策制定引起了很多问题。开源社区能够进行软件公开的谈话，进行大众化，维持好与大众的关系，这对于处理以上问题是十分重要的。如果线上社团，组织和院校能够接受这些开源特质，那么由开源社区进行消除算法偏见的机器设计也会顺利很多。
### 我们怎样才能够参与其中？
教育是一个很重要的环节。我们身边有很多还没意识到算法偏见的人，但算法偏见在立法、社会公正、政策及更多领域产生的影响与他们息息相关。让这些人知道算法偏见是怎样形成的和它们带来的重要影响是很重要的，因为想要改变目前的局面，从我们自身做起是唯一的方法。
对于我们中间那些与人工智能一起工作的人来说，这种沟通尤其重要。不论是人工智能的研发者、警方或是科研人员，当他们为今后设计人工智能时，应当格外意识到现今这种偏见存在的危险性，很明显，想要消除人工智能中存在的偏见，就要从意识到偏见的存在开始。
最后，我们需要围绕 AI 伦理化建立并加强开源社区。不论是需要建立应力实验训练模型、软件工具，或是从千兆字节的训练数据中筛选，现在已经到了我们利用开源方法来应对数字化时代最大的威胁的时间了。
---
via: <https://opensource.com/article/18/1/how-open-source-can-fight-algorithmic-bias>
作者：[Justin Sherman](https://opensource.com/users/justinsherman) 译者：[Valoniakim](https://github.com/Valoniakim) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在树莓派上运行 DOS 系统
|
Jim Hall
|
https://opensource.com/article/18/3/can-you-run-dos-raspberry-pi
|
不同的 CPU 架构意味着在树莓派上运行 DOS 并非唾手可得，但其实也没多麻烦。
|
/data/attachment/album/201804/14/222850qvyvayt4dvnnndrz.jpg.thumb.jpg
|
/data/attachment/album/201804/14/222850qvyvayt4dvnnndrz.jpg
| true | false | true |
HankChow
| false |
[
"树莓派",
"DOS"
] |
树莓派
|
{
"viewnum": 10852,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
不同的 CPU 架构意味着在树莓派上运行 DOS 并非唾手可得，但其实也没多麻烦。
| 2018-04-14T22:28:46 | 2018-04-14T22:28:46 | 9,544 |
/article-9544-1.html
|
>
> 不同的 CPU 架构意味着在树莓派上运行 DOS 并非唾手可得，但其实也没多麻烦。
>
>
>
[FreeDOS](http://www.freedos.org/) 对大家来说也许并不陌生。它是一个完整、免费并且对 DOS 兼容良好的操作系统，它可以运行一些比较老旧的 DOS 游戏或者商用软件，也可以开发嵌入式的应用。只要在 MS-DOS 上能够运行的程序，在 FreeDOS 上都可以运行。
作为 FreeDOS 的发起者和项目协调人员，很多用户会把我作为内行人士进行发问。而我最常被问到的问题是：“FreeDOS 可以在树莓派上运行吗？”
这个问题并不令人意外。毕竟 Linux 在树莓派上能够很好地运行，而 FreeDOS 和 Linux 相比是一个更古老、占用资源更少的操作系统，那 FreeDOS 为啥不能树莓派上运行呢？
简单来说。由于 CPU 架构的原因，FreeDOS 并不能在树莓派中独立运行。和其它 DOS 类的系统一样，FreeDOS 需要英特尔 x86 架构 CPU 以及 BIOS 来提供基础的运行时服务。而树莓派运行在 ARM 架构的 CPU 上，与英特尔 CPU 二进制不兼容，也没有 BIOS。因此树莓派在硬件层面就不支持 FreeDOS。
不过通过 PC 模拟器还是能在树莓派上运行 FreeDOS 的，虽然这样也许稍有不足，但也不失为一个能在树莓派上运行 FreeDOS 的方法。
### DOSBox 怎么样?
有人可能会问：“为什么不用 DOSBox 呢？” DOSBox 是一个开源的跨平台 x86 模拟器，在 Linux 上也能使用，它能够为应用软件尤其是游戏软件提供了一个类 DOS 的运行环境，所以如果你只是想玩 DOS 游戏的话，DOSBox 是一个不错的选择。但在大众眼中，DOSBox 是专为 DOS 游戏而设的，而在运行一些别的 DOS 应用软件方面，DOSBox 只是表现平平。
对多数人来说，这只是个人偏好的问题，我喜欢用 FreeDOS 来运行 DOS 游戏和其它程序，完整的 DOS 系统和 DOSBox 相比能让我体验到更好的灵活性和操控性。我只用 DOSBox 来玩游戏，在其它方面还是选择完整的 FreeDOS。
### 在树莓派上安装 FreeDOS
[QEMU](https://www.qemu.org/)（Quick EMUlator）是一款能在 Linux 系统上运行 DOS 系统的开源的虚拟机软件。很多流行的 Linux 系统都自带 QEMU。QEMU 在我的树莓派上的 Raspbian 系统中也同样能够运行，下文就有一些我在树莓派 [Raspbian GNU/Linux 9 (Stretch)](https://www.raspberrypi.org/downloads/) 系统中使用 QEMU 的截图。
去年我在写了一篇关于[如何在 Linux 系统中运行 DOS 程序](/article-9014-1.html)的文章的时候就用到了 QEMU，在树莓派上使用 QEMU 来安装运行 FreeDOS 的步骤基本上和在别的基于 GNOME 的系统上没有什么太大的区别。
在 QEMU 中你需要通过添加各种组件来搭建虚拟机。先指定一个用来安装运行 DOS 的虚拟磁盘镜像，通过 `qemu-img` 命令来创建一个虚拟磁盘镜像，对于 FreeDOS 来说不需要太大的空间，所以我只创建了一个 200MB 的虚拟磁盘：
```
qemu-img create freedos.img 200M
```
和 VMware 或者 VirtualBox 这些 PC 模拟器不同，使用 QEMU 需要通过添加各种组件来搭建虚拟机，尽管有点麻烦，但是并不困难。我使用了以下这些参数来在树莓派上使用 QEMU 安装 FreeDOS 系统：
```
qemu-system-i386 -m 16 -k en-us -rtc base=localtime -soundhw sb16,adlib -device cirrus-vga -hda freedos.img -cdrom FD12CD.iso -boot order=d
```
你可以在我其它的[文章](/article-9014-1.html)中找到这些命令的完整介绍。简单来说，上面这条命令指定了一个英特尔 i386 兼容虚拟机，并且分配了 16MB 内存、一个英文输入键盘、一个基于系统时间的实时时钟、一个声卡、一个音乐卡以及一个 VGA 卡。文件 `freedos.img` 指定为第一个硬盘（`C:`），`FD12CD.iso` 镜像作为 CD-ROM （`D:`）驱动。QEMU 设定为从 `D:` 的 CD-ROM 启动。
你只需要按照提示就可以轻松安装好 FreeDOS 1.2 了。但是由于 microSD 卡在面对大量的 I/O 时速度比较慢，所以安装操作系统需要花费很长时间。
### 在树莓派上运行 FreeDOS
你的运行情况取决于使用哪一种 microSD 卡。我用的是 SanDisk Ultra 64GB microSDXC UHS-I U1A1 ，其中 U1 这种型号专用于支持 1080p 的视频录制（例如 GoPro），它的最低串行写速度能够达到 10MB/s。相比之下，V60 型号专用于 4K 视频录制，最低连续写入速度能达到 60MB/s。如果你的树莓派使用的是 V60 的 microSD 卡甚至是 V30（也能达到 30MB/s），你就能明显看到它的 I/O 性能会比我的好。
FreeDOS 安装好之后，你可以直接从 `C:` 进行启动。只需要按照下面的命令用 `-boot order=c` 来指定 QEMU 的启动顺序即可：
```
qemu-system-i386 -m 16 -k en-us -rtc base=localtime -soundhw sb16,adlib -device cirrus-vga -hda freedos.img -cdrom FD12CD.iso -boot order=c
```
只要树莓派的 QEMU 上安装了 FreeDOS，就不会出现明显的性能问题。例如游戏通常在每一关开始的时候会加载地图、怪物、声音等一系列的数据，尽管这些内容需要加载一段时间，但在正常玩的时候并没有出现性能不足的现象。
FreeDOS 1.2 自带了很多游戏以及其它应用软件，可以使用 `FDIMPLES` 包管理程序来安装它们。FreeDOS 1.2 里面我最喜欢的是一款叫 WING 的太空射击游戏，让人想起经典的街机游戏 Galaga（WING 就是 Wing Is Not Galaga 的递归缩写词）。
As-Easy-As 是我最喜欢的一个 DOS 应用程序，作为 20 世纪八九十年代流行的电子表格程序，它和当时的 Lotus 1-2-3 以及现在的 Microsoft Excel、LibreOffice Calc 一样具有强大的威力。As-Easy-As 和 Lotus 1-2-3 都将数据保存为 WKS 文件，现在新版本的 Microsoft Excel 已经无法读取这种文件了，而 LibreOffice Calc 视兼容性而定有可能支持。鉴于 As-Easy-As 的初始版本是一个共享软件，TRIUS 仍然为 As-Easy-As 5.7 免费提供[激活码](http://www.triusinc.com/forums/viewtopic.php?t=10)。
我也非常喜欢 GNU Emacs 编辑器，FreeDOS 也自带了一个叫 Freemacs 的类 Emacs 的文本编辑器。它比 FreeDOS 默认的 FreeDOS Edit 编辑器更强大，也能带来 GNU Emacs 的体验。如果你也需要，可以在 FreeDOS 1.2 中通过`FDIMPLES`包管理程序来安装。
### 是的，你或许真的可以在树莓派上运行 DOS
即使树莓派在硬件上不支持 DOS，但是在模拟器的帮助下，DOS 还是能够在树莓派上运行。得益于 QEMU PC 模拟器，一些经典的 DOS 游戏和 DOS 应用程序能够运行在树莓派上。在执行磁盘 I/O ，尤其是大量密集操作（例如写入大量数据）的时候，性能可能会受到轻微的影响。当你使用 QEMU 并且在虚拟机里安装好 FreeDOS 之后，你就可以尽情享受经典的 DOS 程序了。
---
via: <https://opensource.com/article/18/3/can-you-run-dos-raspberry-pi>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Windows 10 上开启 WSL 之旅
|
Swapnil Bhartiya
|
https://www.linux.com/blog/learn/2018/2/how-get-started-using-wsl-windows-10
|
WSL 可以让你访问 Windows 上的 Linux Bash shell。
|
/data/attachment/album/201804/15/084846nddq3j3wf41laalg.png.thumb.jpg
|
/data/attachment/album/201804/15/084846nddq3j3wf41laalg.png
| true | false | true |
CYLeft
| false |
[
"WSL"
] |
技术
|
{
"viewnum": 47857,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9566,
"displayorder": 0
}
] |
WSL 可以让你访问 Windows 上的 Linux Bash shell。
| 2018-04-15T08:48:00 | 2018-04-15T08:48:00 | 9,545 |
/article-9545-1.html
|
>
> WSL 可以让你访问 Windows 上的 Linux Bash shell。
>
>
>
在 [上一篇文章](https://www.linux.com/blog/learn/2018/2/windows-subsystem-linux-bridge-between-two-platforms) 中，我们讨论过关于 <ruby> Windows 的子系统 Linux <rt> Windows Subsystem for Linux </rt></ruby>（WSL）的目标用户。本文，我们将在 Windows 10 的设备上，开启 WSL 的旅程。
### 为 WSL 做准备
您必须使用最新版本的 Windows 10 Fall Creator Update。之后，通过在开始菜单栏搜索 “About”，检查 Windows 10 的版本。为了使用 WSL，您的版本应当为 1709 或者最新版。
这里有一张关于我的操作系统的截图。
如果您安装了之前的版本，您需要在 [这里](https://www.microsoft.com/en-us/software-download/windows10) 下载并且安装 Windows 10 Fall Creator Update (FCU)。安装完毕后，安装可用的更新（在开始菜单的搜索框中搜索 “updates”）。
前往 “启用或关闭 Windows 功能” ，然后滚动至底部，如截图所示，勾选 “适用于 Linux 的 Windows 子系统”，点击确定。它将会下载安装需要的包。
安装完成之后，系统将会询问是否重启。是的，重启设备吧。WSL 在系统重启之前不会启动，如下所示：
一旦您的系统重启，返回 “启用或关闭 Windows 功能” 页面，确认 “适用于 Linux 的 Windows 子系统” 已经被勾选。
### 在 Windows 中安装 Linux
在 Windows 中安装 Linux，有很多方式，这里我们选择一种最简单的方式。打开 Microsoft Store，搜索 Linux。您将看到下面的选项：
点击 “获取”，之后 Windows 商店将会提供三个选项：Ubuntu、openSUSE Leap 42 和 SUSE Linux Enterprise Server。您可以一并安装上述三个发行版，并且它们可以同时运行。为了能使用 SLE，您需要一份订阅。
在此，我将安装 openSUSE Leap 42 和 Ubuntu。选中您想要的发行版，点击“获得”按钮并安装。一旦安装完毕，您就可以在 Windows 中启动 openSUSE。为了方便访问，可以将其固定到开始菜单中。
### 在 Windwods 中使用 Linux
当您启动该发行版，它将会打开一个 Bash Shell 并且安装此发行版。安装完毕之后，您就可以开始使用了。您需要留意，openSUSE 中并没有（普通）用户，它直接运行在 `root` 用户下，但是 Ubuntu 会询问您是否创建用户。在 Ubuntu，您可以以 `sudo` 用户执行管理任务。
在 openSUSE 上，您可以很轻松的创建一个用户：
```
# useradd [username]
# passwd [username]
```
为此用户创建一个新的密码。例如：
```
# useradd swapnil
# passwd swapnil
```
您可以通过 `su` 命令从 root 用户切换过来。
```
su swapnil
```
您需要非根用户来执行许多任务，比如使用 `rsync` 移动文件到本地设备。
而首要任务是更新发行版。对于 openSUSE 来说，您应该：
```
zypper up
```
而对于 Ubuntu：
```
sudo apt-get update
sudo apt-get dist-upgrade
```
现在，您就在 Windows 上拥有了原生的 Linux Bash shell。想在 Windows 10 上通过 `ssh` 连接您的服务器？不需要安装 puTTY 或是 Cygwin。打开 Bash 之后，就可以通过 `ssh` 进入您的服务器。简单之至。
想通过 `rsync` 同步文件到您的服务器？直接使用 `rsync`。它切实的将我们的 Windows 设备转变得更为实用，帮助那些需要使用原生 Linux 命令和 Linux 工具的用户避开虚拟机，大开方便之门。
### Fedora 在哪里？
您可能奇怪为什么没有 Fedora。可惜，商城里并没有 Fedora。Fedora 项目发布负责人在 Twitter 上表示，“我们正在解决一些非技术性问题。现在可能提供不了更多了。”
我们并不确定这些非技术性问题是什么。当一些用户询问 WSL 团队为何不发布 Fedora，毕竟它也是一个开源项目。项目负责人 Rich Turner 在 Microsoft [回应](https://github.com/Microsoft/WSL/issues/2584)，“我们有一个不发布其他知识产权到应用商店的政策。我们相信，相较于被微软或是其他非权威人士，社区更希望看到发行版由发行版所有者发布。”
因此，微软不方便在 Windows 商店中直接发布 Debian 或是 Arch 系统。这些任务应该落在他们的官方团队中，应该由他们将发行版带给 Windows 10 的用户。
### 欲知后事，下回分解
下一篇文章，我们会讨论关于将 Windows 10 作为 Linux 设备，并且向您展示，您可能会在 Linux 系统上使用的命令行工具。
---
via: <https://www.linux.com/blog/learn/2018/2/how-get-started-using-wsl-windows-10>
作者：[SWAPNIL BHARTIYA](https://www.linux.com/users/arnieswap) 译者：[CYLeft](https://github.com/CYLeft) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 ncurses 进行颜色编程
|
Jim Hall
|
http://www.linuxjournal.com/content/programming-color-ncurses
|
Jim 给他的终端冒险游戏添加了颜色，演示了如何用 curses 操纵颜色。
|
/data/attachment/album/201804/15/093208uzo27lsnbfb1l9sn.png.thumb.jpg
|
/data/attachment/album/201804/15/093208uzo27lsnbfb1l9sn.png
| true | false | true |
leemeans
| false |
[
"ncurses"
] |
软件开发
|
{
"viewnum": 8217,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9383,
"displayorder": 0
}
] |
Jim 给他的终端冒险游戏添加了颜色，演示了如何用 curses 操纵颜色。
| 2018-04-15T09:31:00 | 2018-04-15T09:31:00 | 9,546 |
/article-9546-1.html
|
>
> Jim 给他的终端冒险游戏添加了颜色，演示了如何用 curses 操纵颜色。
>
>
>
在我的使用 ncurses 库进行编程的系列文章的[第一篇](/article-9348-1.html)和[第二篇](/article-9383-1.html)中，我已经介绍了一些 curses 函数来在屏幕上作画、从屏幕上查询和从键盘读取字符。为了搞清楚这些函数，我使用 curses 来利用简单字符绘制游戏地图和玩家角色，创建了一个简单的冒险游戏。在这篇紧接着的文章里，我展示了如何为你的 curses 程序添加颜色。
在屏幕上绘图一切都挺好的，但是如果只有黑底白字的文本，你的程序可能看起来很无趣。颜色可以帮助传递更多的信息。举个例子，如果你的程序需要报告执行成功或者执行失败时。在这样的情况下你可以使用绿色或者红色来帮助强调输出。或者，你只是简单地想要“潮艺”一下给你的程序来让它看起来更美观。
在这篇文章中，我用一个简单的例子来展示通过 curses 函数进行颜色操作。在我先前的文章中，我写了一个可以让你在一个粗糙绘制的地图上移动玩家角色的初级冒险类游戏。但是那里面的地图完全是白色和黑色的文本，通过形状来表明是水（`～`）或者山（`^`）。所以，让我们将游戏更新到使用颜色的版本吧。
### 颜色要素
在你可以使用颜色之前，你的程序需要知道它是否可以依靠终端正确地显示颜色。在现代操作系统上，此处应该永远为true。但是在经典的计算机上，一些终端是单色的，例如古老的 VT52 和 VT100 终端，一般它们提供黑底白色或者黑底绿色的文本。
可以使用 `has_colors()` 函数查询终端的颜色功能。这个函数将会在终端可以显示颜色的时候返回 `true`，否则将会返回 `false`。这个函数一般用于 `if` 块的开头，就像这样：
```
if (has_colors() == FALSE) {
endwin();
printf("Your terminal does not support color\n");
exit(1);
}
```
在知道终端可以显示颜色之后，你可以使用 `start_color()` 函数来设置 curses 使用颜色。现在是时候定义程序将要使用的颜色了。
在 curses 中，你应该按对定义颜色：一个前景色放在一个背景色上。这样允许 curses 一次性设置两个颜色属性，这也是一般你想要使用的方式。通过 `init_pair()` 函数可以定义一个前景色和背景色并关联到索引数字来设置颜色对。大致语法如下：
```
init_pair(index, foreground, background);
```
控制台支持八种基础的颜色：黑色、红色、绿色、黄色、蓝色、品红色、青色和白色。这些颜色通过下面的名称为你定义好了：
* `COLOR_BLACK`
* `COLOR_RED`
* `COLOR_GREEN`
* `COLOR_YELLOW`
* `COLOR_BLUE`
* `COLOR_MAGENTA`
* `COLOR_CYAN`
* `COLOR_WHITE`
### 应用颜色
在我的冒险游戏中，我想要让草地呈现绿色而玩家的足迹变成不易察觉的绿底黄色点迹。水应该是蓝色，那些表示波浪的 `~` 符号应该是近似青色的。我想让山（`^`）是灰色的，但是我可以用白底黑色文本做一个可用的折中方案。（LCTT 译注：意为终端预设的颜色没有灰色，使用白底黑色文本做一个折中方案）为了让玩家的角色更易见，我想要使用一个刺目的品红底红色设计。我可以像这样定义这些颜色对：
```
start_color();
init_pair(1, COLOR_YELLOW, COLOR_GREEN);
init_pair(2, COLOR_CYAN, COLOR_BLUE);
init_pair(3, COLOR_BLACK, COLOR_WHITE);
init_pair(4, COLOR_RED, COLOR_MAGENTA);
```
为了让颜色对更容易记忆，我的程序中定义了一些符号常量：
```
#define GRASS_PAIR 1
#define EMPTY_PAIR 1
#define WATER_PAIR 2
#define MOUNTAIN_PAIR 3
#define PLAYER_PAIR 4
```
有了这些常量，我的颜色定义就变成了：
```
start_color();
init_pair(GRASS_PAIR, COLOR_YELLOW, COLOR_GREEN);
init_pair(WATER_PAIR, COLOR_CYAN, COLOR_BLUE);
init_pair(MOUNTAIN_PAIR, COLOR_BLACK, COLOR_WHITE);
init_pair(PLAYER_PAIR, COLOR_RED, COLOR_MAGENTA);
```
在任何时候你想要使用颜色显示文本，你只需要告诉 curses 设置哪种颜色属性。为了更好的编程实践，你同样应该在你完成了颜色使用的时候告诉 curses 取消颜色组合。为了设置颜色，应该在调用像 `mvaddch()` 这样的函数之前使用`attron()`，然后通过 `attroff()` 关闭颜色属性。例如，在我绘制玩家角色的时候，我应该这样做：
```
attron(COLOR_PAIR(PLAYER_PAIR));
mvaddch(y, x, PLAYER);
attroff(COLOR_PAIR(PLAYER_PAIR));
```
记住将颜色应用到你的程序对你如何查询屏幕有一些微妙的影响。一般来讲，由 `mvinch()` 函数返回的值是**没有**带颜色属性的类型 `chtype`，这个值基本上是一个整型值，也可以当作整型值来用。但是，由于使用颜色添加了额外的属性到屏幕上的字符上，所以 `chtype` 按照扩展的位模式携带了额外的颜色信息。一旦你使用 `mvinch()`，返回值将会包含这些额外的颜色值。为了只提取**文本**值，例如在 `is_move_okay()` 函数中，你需要和 `A_CHARTEXT` 做 `&` 位运算：
```
int is_move_okay(int y, int x)
{
int testch;
/* return true if the space is okay to move into */
testch = mvinch(y, x);
return (((testch & A_CHARTEXT) == GRASS)
|| ((testch & A_CHARTEXT) == EMPTY));
}
```
通过这些修改，我可以用颜色更新这个冒险游戏：
```
/* quest.c */
#include <curses.h>
#include <stdlib.h>
#define GRASS ' '
#define EMPTY '.'
#define WATER '~'
#define MOUNTAIN '^'
#define PLAYER '*'
#define GRASS_PAIR 1
#define EMPTY_PAIR 1
#define WATER_PAIR 2
#define MOUNTAIN_PAIR 3
#define PLAYER_PAIR 4
int is_move_okay(int y, int x);
void draw_map(void);
int main(void)
{
int y, x;
int ch;
/* 初始化curses */
initscr();
keypad(stdscr, TRUE);
cbreak();
noecho();
/* 初始化颜色 */
if (has_colors() == FALSE) {
endwin();
printf("Your terminal does not support color\n");
exit(1);
}
start_color();
init_pair(GRASS_PAIR, COLOR_YELLOW, COLOR_GREEN);
init_pair(WATER_PAIR, COLOR_CYAN, COLOR_BLUE);
init_pair(MOUNTAIN_PAIR, COLOR_BLACK, COLOR_WHITE);
init_pair(PLAYER_PAIR, COLOR_RED, COLOR_MAGENTA);
clear();
/* 初始化探索地图 */
draw_map();
/* 在左下角创建新角色 */
y = LINES - 1;
x = 0;
do {
/* 默认情况下，你获得了一个闪烁的光标--用来指明玩家 * */
attron(COLOR_PAIR(PLAYER_PAIR));
mvaddch(y, x, PLAYER);
attroff(COLOR_PAIR(PLAYER_PAIR));
move(y, x);
refresh();
ch = getch();
/* 测试输入键值并获取方向 */
switch (ch) {
case KEY_UP:
case 'w':
case 'W':
if ((y > 0) && is_move_okay(y - 1, x)) {
attron(COLOR_PAIR(EMPTY_PAIR));
mvaddch(y, x, EMPTY);
attroff(COLOR_PAIR(EMPTY_PAIR));
y = y - 1;
}
break;
case KEY_DOWN:
case 's':
case 'S':
if ((y < LINES - 1) && is_move_okay(y + 1, x)) {
attron(COLOR_PAIR(EMPTY_PAIR));
mvaddch(y, x, EMPTY);
attroff(COLOR_PAIR(EMPTY_PAIR));
y = y + 1;
}
break;
case KEY_LEFT:
case 'a':
case 'A':
if ((x > 0) && is_move_okay(y, x - 1)) {
attron(COLOR_PAIR(EMPTY_PAIR));
mvaddch(y, x, EMPTY);
attroff(COLOR_PAIR(EMPTY_PAIR));
x = x - 1;
}
break;
case KEY_RIGHT:
case 'd':
case 'D':
if ((x < COLS - 1) && is_move_okay(y, x + 1)) {
attron(COLOR_PAIR(EMPTY_PAIR));
mvaddch(y, x, EMPTY);
attroff(COLOR_PAIR(EMPTY_PAIR));
x = x + 1;
}
break;
}
}
while ((ch != 'q') && (ch != 'Q'));
endwin();
exit(0);
}
int is_move_okay(int y, int x)
{
int testch;
/* 当空白处可以进入的时候返回true */
testch = mvinch(y, x);
return (((testch & A_CHARTEXT) == GRASS)
|| ((testch & A_CHARTEXT) == EMPTY));
}
void draw_map(void)
{
int y, x;
/* 绘制探索地图 */
/* 背景 */
attron(COLOR_PAIR(GRASS_PAIR));
for (y = 0; y < LINES; y++) {
mvhline(y, 0, GRASS, COLS);
}
attroff(COLOR_PAIR(GRASS_PAIR));
/* 山峰和山路 */
attron(COLOR_PAIR(MOUNTAIN_PAIR));
for (x = COLS / 2; x < COLS * 3 / 4; x++) {
mvvline(0, x, MOUNTAIN, LINES);
}
attroff(COLOR_PAIR(MOUNTAIN_PAIR));
attron(COLOR_PAIR(GRASS_PAIR));
mvhline(LINES / 4, 0, GRASS, COLS);
attroff(COLOR_PAIR(GRASS_PAIR));
/* 湖 */
attron(COLOR_PAIR(WATER_PAIR));
for (y = 1; y < LINES / 2; y++) {
mvhline(y, 1, WATER, COLS / 3);
}
attroff(COLOR_PAIR(WATER_PAIR));
}
```
你可能不能认出所有为了在冒险游戏里面支持颜色需要的修改，除非你目光敏锐。`diff` 工具展示了所有为了支持颜色而添加的函数或者修改的代码：
```
$ diff quest-color/quest.c quest/quest.c
12,17d11
< #define GRASS_PAIR 1
< #define EMPTY_PAIR 1
< #define WATER_PAIR 2
< #define MOUNTAIN_PAIR 3
< #define PLAYER_PAIR 4
<
33,46d26
< /* initialize colors */
<
< if (has_colors() == FALSE) {
< endwin();
< printf("Your terminal does not support color\n");
< exit(1);
< }
<
< start_color();
< init_pair(GRASS_PAIR, COLOR_YELLOW, COLOR_GREEN);
< init_pair(WATER_PAIR, COLOR_CYAN, COLOR_BLUE);
< init_pair(MOUNTAIN_PAIR, COLOR_BLACK, COLOR_WHITE);
< init_pair(PLAYER_PAIR, COLOR_RED, COLOR_MAGENTA);
<
61d40
< attron(COLOR_PAIR(PLAYER_PAIR));
63d41
< attroff(COLOR_PAIR(PLAYER_PAIR));
76d53
< attron(COLOR_PAIR(EMPTY_PAIR));
78d54
< attroff(COLOR_PAIR(EMPTY_PAIR));
86d61
< attron(COLOR_PAIR(EMPTY_PAIR));
88d62
< attroff(COLOR_PAIR(EMPTY_PAIR));
96d69
< attron(COLOR_PAIR(EMPTY_PAIR));
98d70
< attroff(COLOR_PAIR(EMPTY_PAIR));
106d77
< attron(COLOR_PAIR(EMPTY_PAIR));
108d78
< attroff(COLOR_PAIR(EMPTY_PAIR));
128,129c98
< return (((testch & A_CHARTEXT) == GRASS)
< || ((testch & A_CHARTEXT) == EMPTY));
---
> return ((testch == GRASS) || (testch == EMPTY));
140d108
< attron(COLOR_PAIR(GRASS_PAIR));
144d111
< attroff(COLOR_PAIR(GRASS_PAIR));
148d114
< attron(COLOR_PAIR(MOUNTAIN_PAIR));
152d117
< attroff(COLOR_PAIR(MOUNTAIN_PAIR));
154d118
< attron(COLOR_PAIR(GRASS_PAIR));
156d119
< attroff(COLOR_PAIR(GRASS_PAIR));
160d122
< attron(COLOR_PAIR(WATER_PAIR));
164d125
< attroff(COLOR_PAIR(WATER_PAIR));
```
### 开始玩吧--现在有颜色了
程序现在有了更舒服的颜色设计了，更匹配原来的桌游地图，有绿色的地、蓝色的湖和壮观的灰色山峰。英雄穿着红色的制服十分夺目。
*图 1. 一个简单的带湖和山的桌游地图*
*图 2. 玩家站在左下角*
*图 3. 玩家可以在游戏区域移动，比如围绕湖，通过山的通道到达未知的区域。*
通过颜色，你可以更清楚地展示信息。这个例子使用颜色指出可游戏的区域（绿色）相对着不可通过的区域（蓝色或者灰色）。我希望你可以使用这个示例游戏作为你自己的程序的一个起点或者参照。这取决于你需要你的程序做什么，你可以通过 curses 做得更多。
在下一篇文章，我计划展示 ncurses 库的其它特性，比如怎样创建窗口和边框。同时，如果你对于学习 curses 有兴趣，我建议你去读位于 [Linux 文档计划](http://www.tldp.org) 的 Pradeep Padala 写的 [NCURSES Programming HOWTO](http://tldp.org/HOWTO/NCURSES-Programming-HOWTO)。
---
via: <http://www.linuxjournal.com/content/programming-color-ncurses>
作者：[Jim Hall](http://www.linuxjournal.com/users/jim-hall) 译者：[leemeans](https://github.com/leemeans) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Google Kubernetes Engine（GKE）使用初探
|
Qhh0205
|
https://blog.csdn.net/qianghaohao/article/details/79945821
|
本文只是一个入门指南，主要指导能快速开始上手基于 Google Cloud Platform 的 GKE 服务（k8s 托管服务）。
|
/data/attachment/album/201804/15/095240l1oiz1oo1t14vjig.jpg.thumb.jpg
|
/data/attachment/album/201804/15/095240l1oiz1oo1t14vjig.jpg
| true | false | false | false |
[
"容器",
"GKE",
"k8s"
] |
容器与云
|
{
"viewnum": 11225,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文只是一个入门指南，主要指导能快速开始上手基于 Google Cloud Platform 的 GKE 服务（k8s 托管服务）。
| 2018-04-15T09:52:00 | 2018-04-15T09:52:00 | 9,547 |
/article-9547-1.html
|
### 概述
Google 的 k8s 在 2017 年已经从容器编排领域的竞争中取得主导地位，从 [Docker](https://www.docker.com/) 之前的一度排挤到最终完全拥抱 k8s，显然 k8s 已经成了目前业界的标准。
但是到目前为止能提供 k8s 完全托管服务的云服务商少之又少，即便是目前在云提供商有统治力的 AWS 也没有完全提供 k8s 托管服务，仅仅提供有限的定制服务，在这一方面并不成熟。
然而 Google 的 k8s 托管服务，即 GKE，却将 k8s 托管服务做到了极致（至少目前看来），不仅提供了全套的 k8s 托管服务，更引人注目的是 Google 已然将 Autoscaler 和 k8s 集成，实现了 k8s 节点的自动伸缩机制，能根据 pod 的需求自动化添加或删除节点，当现有节点无法承载新的服务时会自动添加节点来满足需求，当现有节点足够空闲时会启用调节机制自动化收缩节点，从某种意义上来说这几乎做到了无服务器的理念。
然而这也许只是冰山一角，更多强大的功能还需要进一步探索，本文只是一个入门指南，主要指导能快速开始上手基于 Google Cloud Platform 的 [GKE](https://cloud.google.com/kubernetes-engine/?hl=zh-cn) 服务（k8s 托管服务）。
### GKE 入门指南
接下来我们一步步指引如何使用 GKE 来部署服务，前提是对 k8s 有所了解，能简单使用 kubectl 命令。
#### 1. 安装并配置 Google Cloud SDK
Google Cloud SDK 是 访问 GCP（Google Cloud Platform）平台各种资源的命令行工具集，类似 aws 的 aws 命令行工具。
安装和配置就不多说了，点击下面链接选择相应操作系统版本的 tar 包下载，然后解压，在 PATH 环境变量中添加 `google-cloud-sdk/bin` 即可：
<https://cloud.google.com/sdk/?hl=zh-cn>
#### 2. 初始化 Google Cloud SDK
初始化 Google Cloud SDK 是将 `gcloud` 命令和 Google 账号绑定起来并设置一些其他的默认值，比如区域，代理，账号，项目（Google 账号中新建的项目）之类的。
在执行 `gcloud init` 初始化之前得先给 `gcloud` 配置 HTTP 代理（GFW 你懂得），具体配置见我之前[这篇文章](https://blog.csdn.net/qianghaohao/article/details/79942485)。然后执行 `gcloud init` 完成初始化，直接根据向导来即可。
#### 3. 到 Google Cloud Platform 控制台建一个 k8s 集群，记住名称
#### 4. 安装 gcloud kubectl 组件
```
gcloud components install kubectl
```
#### 5. 获取群集的身份验证凭据
创建群集后，您需要获取身份验证凭据以与群集进行交互。要为集群进行身份验证，请运行以下命令：
```
gcloud container clusters get-credentials <上一步创建的集群名称>
```
#### 6. 接下来部署一个简单的 hello-server 服务到 GKE
```
kubectl run hello-server --image gcr.io/google-samples/hello-app:1.0 --port 8080
```
### 相关链接
* <https://cloud.google.com/kubernetes-engine/docs/quickstart>
* <https://cloud.google.com/sdk/docs/quickstart-macos?hl=zh-cn>
### 附录
#### gloud 常用命令
```
gcloud auth login --no-launch-browser # gcloud 登录认证
gcloud config set compute/zone [COMPUTE_ZONE] # 设置默认区域
gcloud components list # 列出可安装组件
gcloud components install [组件名称] # 安装组件
gcloud components update # 更新所有已安装组件
gcloud components remove [组件名称] # 卸载已安装组件
```
#### 设置 gcloud http 代理
```
gcloud config set proxy/type http
gcloud config set proxy/address 127.0.0.1
gcloud config set proxy/port 1087
```
#### 设置集群 docker 私服认证
```
kubectl create secret docker-registry regcred --docker-server=<your-registry-server> --docker-username=<your-name> --docker-password=<your-pword> --docker-email=<your-email>
```
**注意**：设置 docker 私服后，要在 GKE 部署 k8s 服务，必须得在 k8s 资源文件（yaml 格式）中的 container
同一级指定 imagePullSecrets 键，要不然仍然无法拉取配置的私服的镜像，示例资源文件如下：
```
apiVersion: v1
kind: Pod
metadata:
name: private-reg
spec:
containers:
- name: private-reg-container
image: <your-private-image>
imagePullSecrets:
- name: regcred
```
#### 查看集群 docker 私服配置
```
kubectl get secret regcred --output=yaml #base64 格式 显示
kubectl get secret regcred --output="jsonpath={.data.\.dockerconfigjson}" | base64 -d # base64
```
|
|||
CIO 真正需要 DevOps 团队做什么？
|
John Allessio
|
https://enterprisersproject.com/article/2017/12/what-devops-teams-really-need-cio
|
DevOps 团队需要 IT 领导者关注三件事：沟通、技术债务和信任。
|
/data/attachment/album/201804/15/211756x45l7c4q9zmmyquq.png.thumb.jpg
|
/data/attachment/album/201804/15/211756x45l7c4q9zmmyquq.png
| true | false | true |
qhwdw
| false |
[
"DevOps"
] |
观点
|
{
"viewnum": 3226,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
DevOps 团队需要 IT 领导者关注三件事：沟通、技术债务和信任。
| 2018-04-16T10:17:00 | 2018-04-16T10:17:00 | 9,548 |
/article-9548-1.html
|
>
> DevOps 团队需要 IT 领导者关注三件事：沟通、技术债务和信任。
>
>
>
IT 领导者可以从大量的 [DevOps](https://enterprisersproject.com/tags/devops) 材料和 [向 DevOps 转变](https://www.redhat.com/en/insights/devops?intcmp=701f2000000tjyaAAA) 所要求的文化挑战中学习。但是，你在一个 DevOps 团队面对长期或短期的团结挑战的调整中 —— 一个 CIO 真正需要他们做的是什么呢？
在我与 DevOps 团队成员的谈话中，我听到的其中一些内容让你感到非常的意外。DevOps 专家（无论是内部团队的还是外部团队的）都希望将下列的事情放在你的 CIO 优先关注的级别。
### 1. 沟通
第一个也是最重要的一个，DevOps 专家需要面对面的沟通。一个经验丰富的 DevOps 团队是非常了解当前 DevOps 的趋势，以及成功和失败的经验，并且他们非常乐意去分享这些信息。表达 DevOps 的概念是很困难的，因此，要在这种新的工作关系中保持开放，定期（不用担心，不用每周）讨论有关你的 IT 的当前状态，如何评价你的沟通环境，以及你的整体的 IT 产业。
相反，你应该准备好与 DevOps 团队去共享当前的业务需求和目标。业务不再是独立于 IT 的东西：它们现在是驱动 IT 发展的重要因素，并且 IT 决定了你的业务需求和目标运行的效果如何。
注重参与而不是领导。在需要做决策的时候，你仍然是最终的决策者，但是，理解这些决策的最好方式是协作，这样，你的 DevOps 团队将有更多的自主权，并因此受到更多激励。
### 2. 降低技术债务
第二，力争更好地理解技术债务，并在 DevOps 中努力降低它。你的 DevOps 团队都工作于一线。这里，“技术债务”是指在一个庞大的、不可持续发展的环境之中，通过维护和增加新功能而占用的人力资源和基础设备资源（查看 Rube Goldberg）。
CIO 常见的问题包括：
* 为什么我们要用一种新方法去做这件事情？
* 为什么我们要在它上面花费时间和金钱？
* 如果这里没有新功能，只是现有组件实现了自动化，那么我们的收益是什么？
“如果没有坏，就不要去修理它”，这样的事情是可以理解的。但是，如果你正在路上好好的开车，而每个人都加速超过你，这时候，你的环境就被破坏了。持续投入宝贵的资源去支撑或扩张拼凑起来的环境。
选择妥协，并且一个接一个的打补丁，以这种方式去处理每个独立的问题，结果将从一开始就变得很糟糕 —— 在一个不能支撑建筑物的地基上，一层摞一层地往上堆。事实上，这种方法就像不断地在电脑中插入坏磁盘一样。迟早有一天，面对出现的问题你将会毫无办法。在外面持续增加的压力下，整个事情将变得一团糟，完全吞噬掉你的资源。
这种情况下，解决方案就是：自动化。使用自动化的结果是良好的可伸缩性 —— 每个维护人员在 IT 环境的维护和增长方面花费更少的努力。如果增加人力资源是实现业务增长的唯一办法，那么，可伸缩性就是白日做梦。
自动化降低了你的人力资源需求，并且对持续进行的 IT 提供了更灵活的需求。很简单，对吗？是的，但是你必须为迟到的满意做好心理准备。为了在提高生产力和效率的基础上获得后端经济效益，需要预先投入时间和精力对架构和结构进行变更。为了你的 DevOps 团队能够成功，接受这些挑战，对 IT 领导者来说是非常重要的。
### 3. 信任
最后，相信你的 DevOps 团队并且一定要理解他们。DevOps 专家也知道这个要求很难，但是他们必须得到你的强大支持和你积极参与的意愿。因为 DevOps 团队持续改进你的 IT 环境，他们自身也在不断地适应这些变化的技术，而这些变化通常正是 “你要去学习的经验”。
倾听，倾听，倾听他们，并且相信他们。DevOps 的改变是非常有价值的，而且也是值的去投入时间和金钱的。它可以提高效率、生产力、和业务响应能力。信任你的 DevOps 团队，并且给予他们更多的自由，实现更高效率的 IT 改进。
新 CIO 的底线是：将你的 DevOps 团队的潜力最大化，离开你的领导 “舒适区”，拥抱一个 “CIOps" 的转变。通过 DevOps 转变，持续地与你的 DevOps 团队共同成长，以帮助你的组织获得长期的 IT 成功。
---
via: <https://enterprisersproject.com/article/2017/12/what-devops-teams-really-need-cio>
作者：[John Allessio](https://enterprisersproject.com/user/john-allessio) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用示例讲解 Linux gunzip 命令
|
Himanshu Arora
|
https://www.howtoforge.com/linux-gunzip-command/
|
在本文中，我们会使用一些简单、易于理解的例子来解释 gunzip 命令的用法。
|
/data/attachment/album/201804/15/212640jqqkkiqqnonu2fqm.jpg.thumb.jpg
|
/data/attachment/album/201804/15/212640jqqkkiqqnonu2fqm.jpg
| true | false | true |
erialin
| false |
[
"gzip",
"gunzip"
] |
技术
|
{
"viewnum": 9307,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本文中，我们会使用一些简单、易于理解的例子来解释 gunzip 命令的用法。
| 2018-04-15T21:26:00 | 2018-04-15T21:26:00 | 9,549 |
/article-9549-1.html
|
我们已经讨论过 [Linux 下 gzip 命令的用法](https://www.howtoforge.com/linux-gzip-command/)。对于初学者来说，`gzip` 工具主要用于压缩或者展开文件。解压时，在 `gzip` 命令后添加 `-d` 选项即可，使用示例如下：
```
gzip -d [compressed-file-name]
```
不过，在解压或扩展 gzip 创建的压缩文件时，有另一款完全不同的工具可供使用。谈及的这款工具就是 `gunzip`。在本文中，我们会使用一些简单、易于理解的例子来解释 `gunzip` 命令的用法。文中所有示例及指南都在 Ubuntu 16.04 环境下测试。
### Linux gunzip 命令
我们现在知道压缩文件可以用 `gzip -d` 或 `gunzip` 命令解压。基本的 `gunzip` 语法为：
```
gunzip [compressed-file-name]
```
以下的 Q&A 例子将更清晰地展示 `gunzip` 工具如何工作：
### Q1. 如何使用 gunzip 解压压缩文件？
解压命令非常简单，仅仅需要将压缩文件名称作为参数传递到 `gunzip` 命令后。
```
gunzip [archive-name]
```
比如：
```
gunzip file1.gz
```
[](https://www.howtoforge.com/images/linux_gunzip_command/big/gunzip-basic-usage.png)
### Q2. 如何让 gunzip 不删除原始压缩文件？
正如你已注意到的那样，`gunzip` 命令解压后会删除原始压缩文件。如果你想保留原始压缩文件，可以使用 `-c` 选项。
```
gunzip -c [archive-name] > [outputfile-name]
```
比如：
```
gunzip -c file1.gz > file1
```
[](https://www.howtoforge.com/images/linux_gunzip_command/big/gunzip-c.png)
使用这种方式，原压缩文件不会被删除。
### Q3. 如何用 gunzip 解压文件到其他路径？
在 Q&A 中我们已经讨论过 `-c` 选项的用法。 使用 gunzip 解压文件到工作目录外的其他路径，仅需要在重定向操作符后添加目标目录的绝对路径即可。
```
gunzip -c [compressed-file] > [/complete/path/to/dest/dir/filename]
```
示例如下：
```
gunzip -c file1.gz > /home/himanshu/file1
```
### 更多信息
以下从 gzip/gunzip 的 man 页中摘录的细节，对于想了解更多的人会有所助益。
>
> `gunzip` 在命令行接受一系列的文件，并且将每个文件内容以正确的魔法数开始，且后缀名为 `.gz`、`-gz`、`.z`、`-z` 或 `_z` （忽略大小写）的压缩文件，用未压缩的文件替换它，并删除其原扩展名。 `gunzip` 也可识别一些特殊扩展名的压缩文件，如 `.tgz` 和 `.taz` 分别是 `.tar.gz` 和 `.tar.Z` 的缩写。在压缩时，`gzip` 在必要情况下使用 `.tgz` 作为扩展名，而不是只截取掉 `.tar` 后缀。
>
>
> `gunzip` 目前可以解压 `gzip`、`zip`、`compress`、`compress -H`（`pack`）产生的文件。`gunzip` 自动检测输入文件格式。在使用前两种压缩格式时，`gunzip` 会检验 32 位循环冗余校验码（CRC）。对于 pack 包，`gunzip` 会检验压缩长度。标准压缩格式在设计上不允许相容性检测。不过 `gunzip` 有时可以检测出坏的 `.Z` 文件。如果你解压 `.Z` 文件时出错，不要因为标准解压没报错就认为 `.Z` 文件一定是正确的。这通常意味着标准解压过程不检测它的输入，而是直接产生一个错误的输出。SCO 的 `compress -H` 格式（lzh 压缩方法）不包括 CRC 校验码，但也允许一些相容性检查。
>
>
>
### 结语
到目前为止提到的 `gunzip` 基本用法，并不需要过多的学习曲线。我们已包含了一个初学者开始使用它所必须了解的几乎全部知识。想要了解更多的用法，去看 [man 页面](https://linux.die.net/man/1/gzip) 吧。
---
via: <https://www.howtoforge.com/linux-gunzip-command/>
作者：[Himanshu Arora](https://www.howtoforge.com) 译者：[erialin](https://github.com/erialin) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 GitHub 和 Python 实现持续部署
|
Clément Verna
|
https://fedoramagazine.org/continuous-deployment-github-python/
|
这篇教程将展示如何使用 Python 和 Flask 框架来搭建一个简单的持续部署（CD）服务。
|
/data/attachment/album/201804/15/232751wtiet561e925o5io.jpg.thumb.jpg
|
/data/attachment/album/201804/15/232751wtiet561e925o5io.jpg
| true | false | true |
kimii
| false |
[
"持续集成",
"GitHub"
] |
技术
|
{
"viewnum": 10055,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
这篇教程将展示如何使用 Python 和 Flask 框架来搭建一个简单的持续部署（CD）服务。
| 2018-04-15T23:27:47 | 2018-04-15T23:27:47 | 9,550 |
/article-9550-1.html
|
借助 GitHub 的<ruby> 网络钩子 <rt> webhook </rt></ruby>，开发者可以创建很多有用的服务。从触发一个 Jenkins 实例上的 CI（持续集成） 任务到配置云中的机器，几乎有着无限的可能性。这篇教程将展示如何使用 Python 和 Flask 框架来搭建一个简单的持续部署（CD）服务。
在这个例子中的持续部署服务是一个简单的 Flask 应用，其带有接受 GitHub 的<ruby> 网络钩子 <rt> webhook </rt></ruby>请求的 REST <ruby> 端点 <rt> endpoint </rt></ruby>。在验证每个请求都来自正确的 GitHub 仓库后，服务器将<ruby> 拉取 <rt> pull </rt></ruby>更改到仓库的本地副本。这样每次一个新的<ruby> 提交 <rt> commit </rt></ruby>推送到远程 GitHub 仓库，本地仓库就会自动更新。
### Flask web 服务
用 Flask 搭建一个小的 web 服务非常简单。这里可以先看看项目的结构。
```
├── app
│ ├── __init__.py
│ └── webhooks.py
├── requirements.txt
└── wsgi.py
```
首先，创建应用。应用代码在 `app` 目录下。
两个文件（`__init__.py` 和 `webhooks.py`）构成了 Flask 应用。前者包含有创建 Flask 应用并为其添加配置的代码。后者有<ruby> 端点 <rt> endpoint </rt></ruby>逻辑。这是该应用接收 GitHub 请求数据的地方。
这里是 `app/__init__.py` 的内容：
```
import os
from flask import Flask
from .webhooks import webhook
def create_app():
""" Create, configure and return the Flask application """
app = Flask(__name__)
app.config['GITHUB_SECRET'] = os.environ.get('GITHUB_SECRET')
app.config['REPO_PATH'] = os.environ.get('REPO_PATH')
app.register_blueprint(webhook)
return(app)
```
该函数创建了两个配置变量：
* `GITHUB_SECRET` 保存一个密码，用来认证 GitHub 请求。
* `REPO_PATH` 保存了自动更新的仓库路径。
这份代码使用<ruby> <a href="http://flask.pocoo.org/docs/0.12/blueprints/"> Flask 蓝图 </a> <rt> Flask Blueprints </rt></ruby>来组织应用的<ruby> 端点 <rt> endpoint </rt></ruby>。使用蓝图可以对 API 进行逻辑分组，使应用程序更易于维护。通常认为这是一种好的做法。
这里是 `app/webhooks.py` 的内容：
```
import hmac
from flask import request, Blueprint, jsonify, current_app
from git import Repo
webhook = Blueprint('webhook', __name__, url_prefix='')
@webhook.route('/github', methods=['POST'])
def handle_github_hook():
""" Entry point for github webhook """
signature = request.headers.get('X-Hub-Signature')
sha, signature = signature.split('=')
secret = str.encode(current_app.config.get('GITHUB_SECRET'))
hashhex = hmac.new(secret, request.data, digestmod='sha1').hexdigest()
if hmac.compare_digest(hashhex, signature):
repo = Repo(current_app.config.get('REPO_PATH'))
origin = repo.remotes.origin
origin.pull('--rebase')
commit = request.json['after'][0:6]
print('Repository updated with commit {}'.format(commit))
return jsonify({}), 200
```
首先代码创建了一个新的蓝图 `webhook`。然后它使用 Flask `route` 为蓝图添加了一个端点。任何请求 `/GitHub` URL 端点的 POST 请求都将调用这个路由。
#### 验证请求
当服务在该端点上接到请求时，首先它必须验证该请求是否来自 GitHub 以及来自正确的仓库。GitHub 在请求头的 `X-Hub-Signature` 中提供了一个签名。该签名由一个密码（`GITHUB_SECRET`），请求体的 HMAC 十六进制摘要，并使用 `sha1` 哈希生成。
为了验证请求，服务需要在本地计算签名并与请求头中收到的签名做比较。这可以由 `hmac.compare_digest` 函数完成。
#### 自定义钩子逻辑
在验证请求后，现在就可以处理了。这篇教程使用 [GitPython](https://gitpython.readthedocs.io/en/stable/index.html) 模块来与 git 仓库进行交互。GitPython 模块中的 `Repo` 对象用于访问远程仓库 `origin`。该服务在本地拉取 `origin` 仓库的最新更改，还用 `--rebase` 选项来避免合并的问题。
调试打印语句显示了从请求体收到的短提交哈希。这个例子展示了如何使用请求体。更多关于请求体的可用数据的信息，请查询 [GitHub 文档](https://developer.github.com/v3/activity/events/types/#webhook-payload-example-26)。
最后该服务返回了一个空的 JSON 字符串和 200 的状态码。这用于告诉 GitHub 的网络钩子服务已经收到了请求。
### 部署服务
为了运行该服务，这个例子使用 [gunicorn](http://gunicorn.org/) web 服务器。首先安装服务依赖。在支持的 Fedora 服务器上，以 [sudo](https://fedoramagazine.org/howto-use-sudo/) 运行这条命令:
```
sudo dnf install python3-gunicorn python3-flask python3-GitPython
```
现在编辑 gunicorn 使用的 `wsgi.py` 文件来运行该服务：
```
from app import create_app
application = create_app()
```
为了部署服务，使用以下命令克隆这个 git [仓库](https://github.com/cverna/github_hook_deployment.git)或者使用你自己的 git 仓库：
```
git clone https://github.com/cverna/github_hook_deployment.git /opt/
```
下一步是配置服务所需的环境变量。运行这些命令：
```
export GITHUB_SECRET=asecretpassphraseusebygithubwebhook
export REPO_PATH=/opt/github_hook_deployment/
```
这篇教程使用网络钩子服务的 GitHub 仓库，但你可以使用你想要的不同仓库。最后，使用这些命令开启该 web 服务：
```
cd /opt/github_hook_deployment/
gunicorn --bind 0.0.0.0 wsgi:application --reload
```
这些选项中绑定了 web 服务的 IP 地址为 `0.0.0.0`，意味着它将接收来自任何的主机的请求。选项 `--reload` 确保了当代码更改时重启 web 服务。这就是持续部署的魔力所在。每次接收到 GitHub 请求时将拉取仓库的最近更新，同时 gunicore 检测这些更改并且自动重启服务。
\**注意： \**为了能接收到 GitHub 请求，web 服务必须部署到具有公有 IP 地址的服务器上。做到这点的简单方法就是使用你最喜欢的云提供商比如 DigitalOcean，AWS，Linode等。
### 配置 GitHub
这篇教程的最后一部分是配置 GitHub 来发送网络钩子请求到 web 服务上。这是持续部署的关键。
从你的 GitHub 仓库的设置中，选择 Webhook 菜单，并且点击“Add Webhook”。输入以下信息：
* “Payload URL”： 服务的 URL，比如 `<http://public_ip_address:8000/github>`
* “Content type”： 选择 “application/json”
* “Secret”： 前面定义的 `GITHUB_SECRET` 环境变量
然后点击“Add Webhook” 按钮。
现在每当该仓库发生推送事件时，GitHub 将向服务发送请求。
### 总结
这篇教程向你展示了如何写一个基于 Flask 的用于接收 GitHub 的网络钩子请求，并实现持续集成的 web 服务。现在你应该能以本教程作为起点来搭建对自己有用的服务。
---
via: <https://fedoramagazine.org/continuous-deployment-github-python/>
作者：[Clément Verna](https://fedoramagazine.org) 选题：[lujun9972](https://github.com/lujun9972) 译者：[kimii](https://github.com/kimii) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 DockerHub
|
Swapnil Bhartiya
|
https://www.linux.com/blog/learn/intro-to-linux/2018/1/how-use-dockerhub
|
在这个 Docker 系列的最后一篇文章中，我们将讲述在 DockerHub 上使用和发布镜像。
|
/data/attachment/album/201804/16/100714hydmwjmalw6j7c8d.jpg.thumb.jpg
|
/data/attachment/album/201804/16/100714hydmwjmalw6j7c8d.jpg
| true | false | true |
MjSeven
| false |
[
"DockerHub",
"Docker"
] |
容器与云
|
{
"viewnum": 13494,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这个 Docker 系列的最后一篇文章中，我们将讲述在 DockerHub 上使用和发布镜像。
| 2018-04-16T10:07:00 | 2018-04-16T10:07:00 | 9,551 |
/article-9551-1.html
|
>
> 在这个 Docker 系列的最后一篇文章中，我们将讲述在 DockerHub 上使用和发布镜像。
>
>
>
在前面的文章中，我们了解到了基本的 [Docker 术语](https://www.linux.com/blog/intro-to-linux/2017/12/container-basics-terms-you-need-know)，在 Linux 桌面、MacOS 和 Windows上 [如何安装 Docker](/article-9773-1.html)，[如何创建容器镜像](/article-9541-1.html) 并且在系统上运行它们。在本系列的最后一篇文章中，我们将讨论如何使用 DockerHub 中的镜像以及将自己的镜像发布到 DockerHub。
首先：什么是 DockerHub 以及为什么它很重要？DockerHub 是一个由 Docker 公司运行和管理的基于云的存储库。它是一个在线存储库，Docker 镜像可以由其他用户发布和使用。有两种库：公共存储库和私有存储库。如果你是一家公司，你可以在你自己的组织内拥有一个私有存储库，而公共镜像可以被任何人使用。
你也可以使用公开发布的官方 Docker 镜像。我使用了很多这样的镜像，包括我的试验 WordPress 环境、KDE plasma 应用程序等等。虽然我们上次学习了如何创建自己的 Docker 镜像，但你不必这样做。DockerHub 上发布了数千镜像供你使用。DockerHub 作为默认存储库硬编码到 Docker 中，所以当你对任何镜像运行 `docker pull` 命令时，它将从 DockerHub 下载。
### 从 Docker Hub 下载镜像并在本地运行
开始请查看本系列的前几篇文章，以便继续。然后，一旦 Docker 在你的系统上运行，你就可以打开终端并运行：
```
$ docker images
```
该命令将显示当前系统上所有的 docker 镜像。假设你想在本地机器上部署 Ubuntu，你可能会：
```
$ docker pull ubuntu
```
如果你的系统上已经存在 Ubuntu 镜像，那么该命令会自动将该系统更新到最新版本。因此，如果你想要更新现有的镜像，只需运行 `docker pull` 命令，易如反掌。这就像 `apt-get update` 一样，没有任何的混乱和麻烦。
你已经知道了如何运行镜像：
```
$ docker run -it <image name>
$ docker run -it ubuntu
```
命令提示符应该变为如下内容：
```
root@1b3ec4621737:/#
```
现在你可以运行任何属于 Ubuntu 的命令和实用程序，这些都被包含在内而且安全。你可以在 Ubuntu 上运行你想要的所有实验和测试。一旦你完成了测试，你就可以销毁镜像并下载一个新的。在虚拟机中不存在系统开销。
你可以通过运行 exit 命令退出该容器：
```
$ exit
```
现在假设你想在系统上安装 Nginx，运行 `search` 命令来找到需要的镜像：
```
$ docker search nginx
```
正如你所看到的，DockerHub 上有很多 Nginx 镜像。为什么？因为任何人都可以发布镜像，各种镜像针对不同的项目进行了优化，因此你可以选择合适的镜像。你只需要为你的需求安装合适的镜像。
假设你想要拉取 Bitnami 的 Nginx 镜像：
```
$ docker pull bitnami/nginx
```
现在运行：
```
$ docker run -it bitnami/nginx
```
### 如何发布镜像到 Docker Hub？
在此之前，[我们学习了如何创建 Docker 镜像](/article-9541-1.html)，我们可以轻松地将该镜像发布到 DockerHub 中。首先，你需要登录 DockerHub，如果没有账户，请 [创建账户](https://hub.docker.com/)。然后，你可以打开终端应用，登录：
```
$ docker login --username=<USERNAME>
```
将 “” 替换为你自己的 Docker Hub 用户名。我这里是 arnieswap：
```
$ docker login --username=arnieswap
```
输入密码，你就登录了。现在运行 `docker images` 命令来获取你上次创建的镜像的 ID。
```
$ docker images
```
现在，假设你希望将镜像 `ng` 推送到 DockerHub，首先，我们需要标记该镜像（[了解更多关于标记的信息](https://www.linux.com/blog/intro-to-linux/2017/12/container-basics-terms-you-need-know)）：
```
$ docker tag e7083fd898c7 arnieswap/my_repo:testing
```
现在推送镜像：
```
$ docker push arnieswap/my_repo
```
推送指向的是 docker.io/arnieswap/my\_repo 仓库：
```
12628b20827e: Pushed
8600ee70176b: Mounted from library/ubuntu
2bbb3cec611d: Mounted from library/ubuntu
d2bb1fc88136: Mounted from library/ubuntu
a6a01ad8b53f: Mounted from library/ubuntu
833649a3e04c: Mounted from library/ubuntu
testing: digest: sha256:286cb866f34a2aa85c9fd810ac2cedd87699c02731db1b8ca1cfad16ef17c146 size: 1569
```
哦耶！你的镜像正在上传。一旦完成，打开 DockerHub，登录到你的账户，你就能看到你的第一个 Docker 镜像。现在任何人都可以部署你的镜像。这是开发软件和发布软件最简单，最快速的方式。无论你何时更新镜像，用户都可以简单地运行：
```
$ docker run arnieswap/my_repo
```
现在你知道为什么人们喜欢 Docker 容器了。它解决了传统工作负载所面临的许多问题，并允许你在任何时候开发、测试和部署应用程序。通过遵循本系列中的步骤，你自己可以尝试以下。
---
via: <https://www.linux.com/blog/learn/intro-to-linux/2018/1/how-use-dockerhub>
作者：[Swapnil Bhartiya](https://www.linux.com/users/arnieswap) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
可怕的万圣节 Linux 命令
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3235219/linux/scary-linux-commands-for-halloween.html
|
什么命令可能会显示鬼、巫婆和僵尸的图像？哪个会鼓励“不给糖果就捣蛋”的精神？
|
/data/attachment/album/201804/17/001608igdrpdwg2drzptpf.jpg.thumb.jpg
|
/data/attachment/album/201804/17/001608igdrpdwg2drzptpf.jpg
| true | false | true |
geekpi
| false |
[
"命令",
"kill"
] |
技术
|
{
"viewnum": 8914,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
什么命令可能会显示鬼、巫婆和僵尸的图像？哪个会鼓励“不给糖果就捣蛋”的精神？
| 2018-04-17T00:16:02 | 2018-04-17T00:16:02 | 9,552 |
/article-9552-1.html
|
虽然现在不是万圣节，也可以关注一下 Linux 可怕的一面。什么命令可能会显示鬼、巫婆和僵尸的图像？哪个会鼓励“不给糖果就捣蛋”的精神？
### crypt
好吧，我们一直看到 `crypt`。尽管名称不同，crypt 不是一个地窖，也不是垃圾文件的埋葬坑，而是一个加密文件内容的命令。现在，`crypt` 通常用一个脚本实现，通过调用一个名为 `mcrypt` 的二进制文件来模拟以前的 `crypt` 命令来完成它的工作。直接使用 `mycrypt` 命令是更好的选择。
```
$ mcrypt x
Enter the passphrase (maximum of 512 characters)
Please use a combination of upper and lower case letters and numbers.
Enter passphrase:
Enter passphrase:
File x was encrypted.
```
请注意，`mcrypt` 命令会创建第二个扩展名为 `.nc` 的文件。它不会覆盖你正在加密的文件。
`mcrypt` 命令有密钥大小和加密算法的选项。你也可以再选项中指定密钥，但 `mcrypt` 命令不鼓励这样做。
### kill
还有 `kill` 命令 - 当然并不是指谋杀，而是用来强制和非强制地结束进程，这取决于正确终止它们的要求。当然，Linux 并不止于此。相反，它有各种 `kill` 命令来终止进程。我们有 `kill`、`pkill`、`killall`、`killpg`、`rfkill`、`skill`（）读作 es-kill）、`tgkill`、`tkill` 和 `xkill`。
```
$ killall runme
[1] Terminated ./runme
[2] Terminated ./runme
[3]- Terminated ./runme
[4]+ Terminated ./runme
```
### shred
Linux 系统也支持一个名为 `shred` 的命令。`shred` 命令会覆盖文件以隐藏其以前的内容，并确保使用硬盘恢复工具无法恢复它们。请记住，`rm` 命令基本上只是删除文件在目录文件中的引用，但不一定会从磁盘上删除内容或覆盖它。`shred` 命令覆盖文件的内容。
```
$ shred dupes.txt
$ more dupes.txt
▒oΛ▒▒9▒lm▒▒▒▒▒o▒1־▒▒f▒f▒▒▒i▒▒h^}&▒▒▒{▒▒
```
### 僵尸
虽然不是命令，但僵尸在 Linux 系统上是很顽固的存在。僵尸基本上是没有完全清理掉的死亡进程的遗骸。进程*不应该*这样工作 —— 让死亡进程四处游荡，而不是简单地让它们死亡并进入数字天堂，所以僵尸的存在表明了让他们遗留于此的进程有一些缺陷。
一个简单的方法来检查你的系统是否有僵尸进程遗留，看看 `top` 命令的标题行。
```
$ top
top - 18:50:38 up 6 days, 6:36, 2 users, load average: 0.00, 0.00, 0.00
Tasks: 171 total, 1 running, 167 sleeping, 0 stopped, 3 zombie `< ==`
%Cpu(s): 0.0 us, 0.0 sy, 0.0 ni, 99.9 id, 0.1 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 2003388 total, 250840 free, 545832 used, 1206716 buff/cache
KiB Swap: 9765884 total, 9765764 free, 120 used. 1156536 avail Mem
```
可怕！上面显示有三个僵尸进程。
### at midnight
有时会在万圣节这么说，死者的灵魂从日落开始游荡直到午夜。Linux 可以通过 `at midnight` 命令跟踪它们的离开。用于安排在下次到达指定时间时运行的作业，`at` 的作用类似于一次性的 cron。
```
$ at midnight
warning: commands will be executed using /bin/sh
at> echo 'the spirits of the dead have left'
at> <EOT>
job 3 at Thu Oct 31 00:00:00 2017
```
### 守护进程
Linux 系统也高度依赖守护进程 —— 在后台运行的进程，并提供系统的许多功能。许多守护进程的名称以 “d” 结尾。这个 “d” 代表<ruby> 守护进程 <rt> daemon </rt></ruby>，表明这个进程一直运行并支持一些重要功能。有的会用单词 “daemon” 。
```
$ ps -ef | grep sshd
root 1142 1 0 Oct19 ? 00:00:00 /usr/sbin/sshd -D
root 25342 1142 0 18:34 ? 00:00:00 sshd: shs [priv]
$ ps -ef | grep daemon | grep -v grep
message+ 790 1 0 Oct19 ? 00:00:01 /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation
root 836 1 0 Oct19 ? 00:00:02 /usr/lib/accountsservice/accounts-daemon
```
### 万圣节快乐！
在 [Facebook](https://www.facebook.com/NetworkWorld/) 和 [LinkedIn](https://www.linkedin.com/company/network-world) 上加入 Network World 社区来对主题进行评论。
---
via: <https://www.networkworld.com/article/3235219/linux/scary-linux-commands-for-halloween.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
面向企业的最佳 Linux 发行版
|
Matt Hartley
|
https://www.datamation.com/open-source/best-linux-distros-for-the-enterprise.html
|
所有这些可选的 Linux 具有的一个共同点是它们都是企业级 Linux 发行版 —— 所以你可以期待更高程度的功能性，当然还有支持程度。
|
/data/attachment/album/201804/17/095110szjo7ddjnog2c22o.jpg.thumb.jpg
|
/data/attachment/album/201804/17/095110szjo7ddjnog2c22o.jpg
| true | false | true |
MjSeven
| true |
[
"Linux",
"RHEL",
"SLES"
] |
观点
|
{
"viewnum": 9921,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
所有这些可选的 Linux 具有的一个共同点是它们都是企业级 Linux 发行版 —— 所以你可以期待更高程度的功能性，当然还有支持程度。
| 2018-04-17T09:51:16 | 2018-04-17T09:51:16 | 9,553 |
/article-9553-1.html
|
在这篇文章中，我将分享企业环境下顶级的 Linux 发行版。其中一些发行版用于服务器和云环境以及桌面任务。所有这些可选的 Linux 具有的一个共同点是它们都是企业级 Linux 发行版 —— 所以你可以期待更高程度的功能性，当然还有支持程度。
### 什么是企业级的 Linux 发行版？
企业级的 Linux 发行版可以归结为以下内容 —— 稳定性和支持。在企业环境中，使用的 Linux 版本必须满足这两点。稳定性意味着所提供的软件包既稳定又可用，同时仍然保持预期的安全性。
企业级的支持因素意味着有一个可靠的支持机制。有时这是单一的（官方）来源，如公司。在其他情况下，它可能是一个非营利性的治理机构，向优秀的第三方支持供应商提供可靠的建议。很明显，前者是最好的选择，但两者都可以接受。
### Red Hat 企业级 Linux（RHEL）
[Red Hat](https://www.redhat.com/en) 有很多很棒的产品，都有企业级的支持来保证可用。其核心重点如下：
* Red Hat 企业级 Linux 服务器：这是一组服务器产品，包括从容器托管到 SAP 服务的所有内容，还有其他衍生的服务器。
* Red Hat 企业级 Linux 桌面：这些是严格控制的用户环境，运行 Red Hat Linux，提供基本的桌面功能。这些功能包括访问最新的应用程序，如 web 浏览器、电子邮件、LibreOffice 等。
* Red Hat 企业级 Linux 工作站：这基本上是 Red Hat 企业级 Linux 桌面，但针对高性能任务进行了优化。它也非常适合于大型部署和持续管理。
#### 为什么选择 Red Hat 企业级 Linux？
Red Hat 是一家非常成功的大型公司，销售围绕 Linux 的服务。基本上，Red Hat 从那些想要避免供应商锁定和其他相关问题的公司赚钱。这些公司认识到聘用开源软件专家和管理他们的服务器和其他计算需求的价值。一家公司只需要购买订阅来让 Red Hat 做支持工作就行。
Red Hat 也是一个可靠的社会公民。他们赞助开源项目以及像 OpenSource.com 这样的 FoSS 支持网站（LCTT 译注：FoSS 是 Free and Open Source Software 的缩写，意为自由及开源软件），并为 Fedora 项目提供支持。Fedora 不是由 Red Hat 所有的，而是由它赞助开发的。这使 Fedora 得以发展，同时也使 Red Hat 受益匪浅。Red Hat 可以从 Fedora 项目中获得他们想要的，并将其用于他们的企业级 Linux 产品中。 就目前来看，Fedora 充当了红帽企业 Linux 的上游渠道。
### SUSE Linux 企业版本
[SUSE](https://www.suse.com/) 是一家非常棒的公司，为企业用户提供了可靠的 Linux 选择。SUSE 的产品类似于 Red Hat，桌面和服务器都是该公司所关注的。从我自己使用 SUSE 的经验来看，我相信 YaST 已经证明了，对于希望在工作场所使用 Linux 操作系统的非 Linux 管理员而言，它拥有巨大的优势。YaST 为那些需要一些基本的 Linux 命令行知识的任务提供了一个友好的 GUI。
SUSE 的核心重点如下：
* SUSE Linux 企业级服务器（SLES）：包括任务特定的解决方案，从云到 SAP，以及任务关键计算和基于软件的数据存储。
* SUSE Linux 企业级桌面：对于那些希望为员工提供可靠的 Linux 工作站的公司来说，SUSE Linux 企业级桌面是一个不错的选择。和 Red Hat 一样，SUSE 通过订阅模式来对其提供支持。你可以选择三个不同级别的支持。
#### 为什么选择 SUSE Linux 企业版？
SUSE 是一家围绕 Linux 销售服务的公司，但他们仍然通过专注于简化操作来实现这一目标。从他们的网站到其提供的 Linux 发行版，重点是易用性，而不会牺牲安全性或可靠性。尽管在美国毫无疑问 Red Hat 是服务器的标准，但 SUSE 作为公司和开源社区的贡献成员都做得很好。
我还会继续说，SUSE 不会太严肃，当你在 IT 领域建立联系的时候，这是一件很棒的事情。从他们关于 Linux 的有趣音乐视频到 SUSE 贸易展位中使用的 Gecko 以获得有趣的照片机会，SUSE 将自己描述成简单易懂和平易近人的形象。
### Ubuntu LTS Linux
[Ubuntu Long Term Release](http://releases.ubuntu.com/16.04/) （LTS） Linux 是一个简单易用的企业级 Linux 发行版。Ubuntu 看起来比上面提到的其他发行版更新更频繁（有时候也更不稳定）。但请不要误解，Ubuntu LTS 版本被认为是相当稳定的，不过，我认为一些专家可能不太同意它们是安全可靠的。
#### Ubuntu 的核心重点如下：
* Ubuntu 桌面版：毫无疑问，Ubuntu 桌面非常简单，可以快速地学习并运行。也许在高级安装选项中缺少一些东西，但这使得其更简单直白。作为额外的奖励，Ubuntu 相比其他版本有更多的软件包（除了它的父亲，Debian 发行版）。我认为 Ubuntu 真正的亮点在于，你可以在网上找到许多销售 Ubuntu 的厂商，包括服务器、台式机和笔记本电脑。
* Ubuntu 服务器版：这包括服务器、云和容器产品。Ubuntu 还提供了 Juju 云“应用商店”这样一个有趣的概念。对于任何熟悉 Ubuntu 或 Debian 的人来说，Ubuntu 服务器都很有意义。对于这些人来说，它就像手套一样，为你提供了你已经熟知并喜爱的命令行工具。
* Ubuntu IoT：最近，Ubuntu 的开发团队已经把目标瞄准了“物联网”（IoT）的创建解决方案。包括数字标识、机器人技术和物联网网关。我的猜测是，我们将在 Ubuntu 中看到大量增长的物联网用户来自企业，而不是普通家庭用户。
#### 为什么选择 Ubuntu LTS？
社区是 Ubuntu 最大的优点。除了在已经拥挤的服务器市场上的巨大增长之外，它还与普通用户在一起。Ubuntu 的开发和用户社区是坚如磐石的。因此，虽然它可能被认为比其他企业版更不稳定，但是我发现将 Ubuntu LTS 安装锁定到 “security updates only” 模式下提供了非常稳定的体验。
### CentOS 或者 Scientific Linux 怎么样呢？
首先，让我们把 [CentOS](https://www.centos.org/) 作为一个企业发行版，如果你有自己的内部支持团队来维护它，那么安装 CentOS 是一个很好的选择。毕竟，它与 Red Hat 企业级 Linux 兼容，并提供了与 Red Hat 产品相同级别的稳定性。不幸的是，它不能完全取代 Red Hat 支持订阅。
那么 [Scientific Linux](https://www.scientificlinux.org/) 呢？它的发行版怎么样？好吧，它就像 CentOS，它是基于 Red Hat Linux 的。但与 CentOS 不同的是，它与 Red Hat 没有任何隶属关系。 Scientific Linux 从一开始就有一个目标 —— 为世界各地的实验室提供一个通用的 Linux 发行版。今天，Scientific Linux 基本上是 Red Hat 减去所包含的商标资料。
这两种发行版都不能真正地与 Red Hat 互换，因为它们缺少 Red Hat 支持组件。
哪一个是顶级企业发行版？我认为这取决于你需要为自己确定的许多因素：订阅范围、可用性、成本、服务和提供的功能。这些是每个公司必须自己决定的因素。就我个人而言，我认为 Red Hat 在服务器上获胜，而 SUSE 在桌面环境中轻松获胜，但这只是我的意见 —— 你不同意？点击下面的评论部分，让我们来谈谈它。
---
via: <https://www.datamation.com/open-source/best-linux-distros-for-the-enterprise.html>
作者：[Matt Hartley](https://www.datamation.com/author/Matt-Hartley-3080.html) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
自从上个 LTS 版本之后，Ubuntu 18.04 LTS 有什么新变化？
|
Marius Nestor
|
http://news.softpedia.com/news/what-s-new-in-ubuntu-18-04-lts-bionic-beaver-since-ubuntu-16-04-lts-520726.shtml
|
让我们回顾一下 Ubuntu 这两年有什么变化。
|
/data/attachment/album/201804/17/221345uv1pcuz51ivg355g.jpg.thumb.jpg
|
/data/attachment/album/201804/17/221345uv1pcuz51ivg355g.jpg
| true | false | true |
wxy
| false |
[
"Ubuntu"
] |
新闻
|
{
"viewnum": 16114,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
让我们回顾一下 Ubuntu 这两年有什么变化。
| 2018-04-17T22:13:00 | 2018-04-17T22:13:00 | 9,554 |
/article-9554-1.html
|
>
> 让我们回顾一下 Ubuntu 这两年有什么变化。
>
>
>
Canonical 将在这个月末的 26 日发布 Ubuntu 18.04 LTS（Bionic Beaver）操作系统。这是一个 LTS 发布版本，大多数 Ubuntu 16.04 LTS（Xenial Xerus）用户应该进行升级。
2016 年 4 月 21 日发布的 Ubuntu 16.04 LTS（Xenial Xerus）系列已经是两年前的事情了，它已经更新了五个计划维护更新中的四个，而上一个更新 Ubuntu 16.04.4 LTS 发布于 2018 年 3 月 1 日。
Ubuntu 16.04.4 LTS 将会有来自 Ubuntu 17.10（Artful Aardvark）最新的内核和显卡驱动，这和 Ubuntu 16.04 LTS 初次发布相比已经有了很大变化。作为 Ubuntu 16.04 LTS 用户，我想你或许想知道是否值得升级本月底发布的 Ubuntu 18.04 LTS。
### 从 Ubuntu 16.04 LTS 到 Ubuntu 18.04 LTS 有何新变化？
从 Ubuntu 16.04 LTS 到 Ubuntu 18.04 LTS 最显著的变化是我们喜爱的 Unity 用户界面被替换为 GNOME 桌面环境了，虽然 Ubuntu 的开发者们已经尽力将其打造得看起来像 Unity 桌面一样。
GNOME 桌面环境带来了许多视觉变化。最显眼的一个变化是窗口控制按钮现在被移动到了右边。上一个在右边摆放窗口控制按钮的 Ubuntu 版本是 Ubuntu 9.10 （Karmic Koala）。
另一个视觉变化可以在 Nautilus 文件管理器中看到，它现在有个暗色风格的左边栏。LightDM 登录管理器也被替换为 GNOME 的 GDM 显示管理器，并使用了 7 号虚拟终端取代了默认的 1 号虚拟终端。
此外，Ubuntu 18.04 LTS 使用 GNOME 的屏幕虚拟键盘替代了默认的 Onboard 键盘，而预装在现场版 ISO 镜像中的应用也是完全不同的一套，Ubuntu 16.04 LTS 以来新包括在 Ubuntu 18.04 LTS 中应用是 GNOME To Do。
在另一方面，如果你要查看 systemd journal 中的日志的话，“GNOME 日志”替换了原来的系统日志应用；gconf 默认不再安装，它被替换为 gsettings；还有一个变化是从 Ubuntu 16.04 LTS 升级时，Aisleriot 卡牌游戏的记录和设置都会丢失。
其它许多来自 GNOME 家族的应用都进行了 UI 重大重新设计，这包括 “Ubuntu 软件”、“系统设置”、“磁盘用量分析（Baobab）”、Remmina，并且 “GNOME 日历”现在有了周视图和支持重复事件。那些应用现在大多在其应用菜单中有键盘快捷键弹窗。
### Ubuntu 桌面版 32 位镜像没了，Ubuntu GNOME 断篇
现在 GNOME 成为了 Ubunut 默认桌面环境，因此 Ubuntu GNOME 分支就不再继续开发了。Ubuntu GNOME 16.04 用户将自动升级到 Ubuntu 标准版本。如果你安装了 gnome-session 软件包并在登录屏幕选择了 GNOME 的话，仍然可以使用原汁原味的 GNOME 会话。
最后同样重要是的，Canonical 放弃了 Ubuntu 18.04 LTS （Bionic Beaver）版本的 32 位桌面的支持，所以，如果你使用的是 32 位 Ubuntu 16.04 LTS 操作系统，推荐你下载 64 位 Ubuntu 18.04 LTS 镜像并重新安装（当然，你得是 64 位的机器）。
在底层，现在默认安装的是 Python 3，Python 2 不再安装； GPG 二进制现在由 GnuPG2 软件包提供；全新安装的 Ubuntu 系统中用交换文件取代了交换分区；现在是默认的 DNS 解析器是 systemd-resolved；重新打造的图形化安装程序的“加密家目录”选项消失了。
Ubuntu 18.04 LTS （Bionic Beaver）是 Canonical 的第七个长期支持版本，它会得到五年的安全和软件更新支持，直到 2023 年 4 月。最终的 Ubuntu 18.04 LTS 很快就可以下载了，2018 年 4 月 26 日 Ubuntu 16.04 LTS 和 Ubuntu 17.10 用户可以准备升级了。
[](https://news-cdn.softpedia.com/images/news2/what-s-new-in-ubuntu-18-04-lts-bionic-beaver-since-ubuntu-16-04-lts-520726-5.jpg "Click to view large image")
|
||
什么是 Linux “oops”？
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3254778/linux/what-is-a-linux-oops.html
|
Linux 内核正在盯着你，当它检测到系统上运行的某些东西违反了正常内核行为时，它会关闭系统并发出一个“oops”！
|
/data/attachment/album/201804/18/222759dmq16dgxmjjrrx76.jpg.thumb.jpg
|
/data/attachment/album/201804/18/222759dmq16dgxmjjrrx76.jpg
| true | false | true |
geekpi
| false |
[
"内核",
"恐慌"
] |
技术
|
{
"viewnum": 11467,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux 内核正在盯着你，当它检测到系统上运行的某些东西违反了正常内核行为时，它会关闭系统并发出一个“oops”！
| 2018-04-18T22:28:25 | 2018-04-18T22:28:25 | 9,556 |
/article-9556-1.html
|
>
> Linux 内核正在盯着你，当它检测到系统上运行的某些东西违反了正常内核行为时，它会关闭系统并发出一个“oops”！
>
>
>
如果你检查你的 Linux 系统上运行的进程，你可能会对一个叫做 “kerneloops” 的进程感到好奇。提示一下，它是 “kernel oops”，而不是 “kerne loops”。
坦率地说，“oops” 是 Linux 内核的一部分出现了偏差行为。你有做错了什么吗？可能没有。但有一些不对劲。而那个做了错事的进程可能已经被 CPU 结束。最糟糕的是，内核可能会报错并突然关闭系统。
请注意，“oops” 不是首字母缩略词。它不代表像“<ruby> 面向对象的编程和系统 <rt> object-oriented programming and systems </rt></ruby>” 或“<ruby> 超出程序规范 <rt> out of procedural specs </rt></ruby>” 之类的东西。它实际上就是“哎呀” （oops），就像你刚掉下一杯酒或踩在你的猫身上。哎呀！ “oops” 的复数是 “oopses”。
oops 意味着系统上运行的某些东西违反了内核有关正确行为的规则。也许代码尝试采取不允许的代码路径或使用无效指针。不管它是什么，内核 —— 总是在监测进程的错误行为 —— 很可能会阻止特定进程，并将它做了什么的消息写入控制台、 `/var/log/dmesg` 或 `/var/log/kern.log` 中。
oops 可能是由内核本身引起的，也可能是某些进程试图让内核违反在系统上能做的事以及它们被允许做的事。
oops 将生成一个<ruby> 崩溃签名 <rt> crash signature </rt></ruby>，这可以帮助内核开发人员找出错误并提高代码质量。
系统上运行的 kerneloops 进程可能如下所示：
```
kernoops 881 1 0 Feb11 ? 00:00:01 /usr/sbin/kerneloops
```
你可能会注意到该进程不是由 root 运行的，而是由名为 “kernoops” 的用户运行的，并且它的运行时间极少。实际上，分配给这个特定用户的唯一任务是运行 kerneloops。
```
$ sudo grep kernoops /etc/passwd
kernoops:x:113:65534:Kernel Oops Tracking Daemon,,,:/:/bin/false
```
如果你的 Linux 系统不带有 kerneloops（比如 Debian），你可以考虑添加它。查看这个 [Debian 页面](https://packages.debian.org/stretch/kerneloops)了解更多信息。
### 什么时候应该关注 oops？
一般 oops 没什么大不了的。它在一定程度上取决于特定进程所扮演的角色。它也取决于 oops 的类别。
有些 oops 很严重，会导致<ruby> 系统恐慌 <rt> system panic </rt></ruby>。从技术上讲，系统恐慌是 oops 的一个子集（即更严重的 oops）。当内核检测到的问题足够严重以至于内核认为它（内核）必须立即停止运行以防止数据丢失或对系统造成其他损害时会出现。因此，系统需要暂停并重新启动，以防止任何不一致导致不可用或不可靠。所以系统恐慌实际上是为了保护自己免受不可挽回的损害。
总之，所有的内核恐慌都是 oops，但并不是所有的 oops 都是内核恐慌。
`/var/log/kern.log` 和相关的轮转日志（`/var/log/kern.log.1`、`/var/log/kern.log.2` 等）包含由内核生成并由 syslog 处理的日志。
kerneloops 程序收集并默认将错误信息提交到 <http://oops.kernel.org/>，在那里它会被分析并呈现给内核开发者。此进程的配置详细信息在 `/etc/kerneloops.conf` 文件中指定。你可以使用下面的命令轻松查看设置：
```
$ sudo cat /etc/kerneloops.conf | grep -v ^# | grep -v ^$
[sudo] password for shs:
allow-submit = ask
allow-pass-on = yes
submit-url = http://oops.kernel.org/submitoops.php
log-file = /var/log/kern.log
submit-pipe = /usr/share/apport/kernel_oops
```
在上面的（默认）设置中，内核问题可以被提交，但要求用户获得许可。如果设置为 `allow-submit = always`，则不会询问用户。
调试内核问题是使用 Linux 系统的更高级技巧之一。幸运的是，大多数 Linux 用户很少或从没有经历过 oops 或内核恐慌。不过，知道 kerneloops 这样的进程在系统中执行什么操作，了解可能会报告什么以及系统何时遇到严重的内核冲突也是很好的。
---
via: <https://www.networkworld.com/article/3254778/linux/what-is-a-linux-oops.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
11 个超棒的 Vi 技巧和窍门
|
Archit Modi
|
https://opensource.com/article/18/1/top-11-vi-tips-and-tricks
|
是否你刚刚接触 Vi 还是想进阶，这些技巧可以很快让你成为高级用户。
|
/data/attachment/album/201804/18/232208rfzo206de393pe3a.jpg.thumb.jpg
|
/data/attachment/album/201804/18/232208rfzo206de393pe3a.jpg
| true | false | true |
MZqk
| false |
[
"Vi",
"Vim"
] |
技术
|
{
"viewnum": 9648,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
是否你刚刚接触 Vi 还是想进阶，这些技巧可以很快让你成为高级用户。
| 2018-04-18T23:22:24 | 2018-04-18T23:22:24 | 9,557 |
/article-9557-1.html
|
>
> 是否你刚刚接触 Vi 还是想进阶，这些技巧可以很快让你成为高级用户。
>
>
>
[Vi](http://ex-vi.sourceforge.net/) 编辑器是 Unix 和像 Linux 这样的类 Unix 系统中 Linux 最流行的编辑器之一。无论您是 vi 新手还是想进阶，这里有 11 个技巧可以增强你使用的方式。
### 编辑
编辑长文本时可能很难受，特别是编辑其中某一行时，需要移动许久才能到这行。这有个很快的方法：
1、 `:set number` 这个命令可是在编辑器左边显示行号。
您可以在命令行中输入 `vi +26 samp.txt` 命令直接打开文件到达 26 行，在 vi 编辑器中也可以输入 `:26` 跳转到 26 行。
### 快速导航
2、 `i` 将工作方式从“命令模式”更改为“输入模式”，并在当前光标位置开始插入内容。
3、 `a` 除了是光标之后开始插入内容，与上面的效果是一样的。
4、 `o` 在光标的下一行位置开始插入内容。
### 删除
如果您发现错误或错别字，能快速的修正是很重要的。好在 Vi 都事先想好了。
了解 Vi 的删除功能，保证你不会意外按下某个键并永久删除一行或多段内容，这点至关重要。
5、 `x` 删除当前光标的字符。
6、 `dd` 删除当前行 （是的，整行内容！)
下面看可怕的部分：`30dd` 从当前行开始删除以下 30 行！使用此命令请慎重。
### 搜索
您可以在“命令模式”搜索关键字，而不用在大量文本内容中手动导航查找特定的单词或内容。
7、 `:/<keyword>` 搜索 `< >` 中的单词并将光标移动到第一个匹配项。
8、 导航到该单词的下一个匹配项，请输入 `n` 并继续按下， 直到找到您要找的内容。
例如，在这个图像中我要搜索包含 `ssh` 的内容， Vi 光标就会突出第一个结果的开始位置。
按下 `n` 之后， Vi 光标就会突出下一个匹配项。
### 保存并退出
开发人员 （或其他人） 可能会发现这个命令很有用。
9、 `:x` 保存您的工作并退出 Vi 。
10、 如果你想节省哪怕是纳秒，那么这有个更快的回到终端的方法。不用在键盘上按 `Shift+:` ，而是按下 `Shift+q` （或者大写字母 Q ) 来进入 [Ex 模式](https://en.wikibooks.org/wiki/Learning_the_vi_Editor/Vim/Modes#Ex-mode) 。但是如果你只是想按下 `x` 来保存退出，那就没有什么区别（如上所示）。
### 替换
如果您想将文中的某个单词全部替换为一个单词，这有个很巧妙的招式。例如，如果您想在一个大文件中将 “desktop” 替换为 “laptop” ，那么单调的搜索每个出现的 “desktop” 将其删掉，然后再输入 “laotop” ，是很浪费时间的。
11、 `:%s/desktop/laptop/g` 这个命令将在整个文件中的 “desktop” 用 “laptop” 替换，他就像 Linux 的 `sed` 命令一样。
这个例子中我用 “user” 替换了 “root” ：
这些技巧应该能帮组任何想开始学 Vi 的人。我有遗漏其他巧妙的提示吗？请在评论中分享他们。
---
via: <https://opensource.com/article/18/1/top-11-vi-tips-and-tricks>
作者：[Archit Modi](https://opensource.com/users/architmodi) 译者：[MZqk](https://github.com/MZqk) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux 中国](https://linux.cn/) 荣誉推出
|
||
如何在Linux的终端测试网速
|
Shrikant Lavhate
|
https://kerneltalks.com/tips-tricks/how-to-test-internet-speed-in-linux-terminal/
|
学习如何在 Linux 终端使用命令行工具 speedtest 测试网速，或者仅用一条 python 命令立刻获得网速的测试结果。
|
/data/attachment/album/201804/19/011651exdlvgxkssjtjhj3.png.thumb.jpg
|
/data/attachment/album/201804/19/011651exdlvgxkssjtjhj3.png
| true | false | true |
FelixYFZ
| false |
[
"测试",
"网速"
] |
技术
|
{
"viewnum": 67789,
"commentnum": 2,
"favtimes": 7,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "123.139.114.186",
"message": "直接导致机器卡死，断网也没法恢复，看来只有强制断电重启了",
"username": "来自陕西西安的 Chrome 111.0|Mac 10.15 用户",
"date": "2023-03-19T20:39:35"
},
{
"postip": "123.139.114.186",
"message": "直接导致机器卡死，断网也没法恢复，看来只有强制断电重启了",
"username": "来自陕西西安的 Chrome 111.0|Mac 10.15 用户",
"date": "2023-03-19T20:39:38"
}
] |
[] |
学习如何在 Linux 终端使用命令行工具 speedtest 测试网速，或者仅用一条 python 命令立刻获得网速的测试结果。
| 2018-04-19T01:16:00 | 2018-04-19T01:16:00 | 9,558 |
/article-9558-1.html
|
>
> 学习如何在 Linux 终端使用命令行工具 `speedtest` 测试网速，或者仅用一条 python 命令立刻获得网速的测试结果。
>
>
>
我们都会在连接到一个新的网络或者 WIFI 的时候去测试网络带宽。 为什么不用我们自己的服务器！下面将会教你如何在 Linux 终端测试网速。
我们多数都会使用 [Ookla 的 Speedtest](http://www.speedtest.net/) 来测试网速。 这在桌面上是很简单的操作，访问他们的网站点击“Go”浏览即可。它将使用最近的服务器来扫描你的本地主机来测试网速。 如果你使用的是移动设备，他们有对应的移动端 APP。但如果你使用的是只有命令行终端，界面的则会有些不同。下面让我们一起看看如何在Linux的终端来测试网速。
如果你只是想偶尔的做一次网速测试而不想去下载测试工具，那么请往下看如何使用命令完成测试。
### 第一步：下载网速测试命令行工具。
首先，你需要从 [GitHub](https://github.com/sivel/speedtest-cli) 上下载 `speedtest` 命令行工具。现在，它也被包含在许多其它的 Linux 仓库中，如果已经在你的库中，你可以直接[在你的 Linux 发行版上进行安装](https://kerneltalks.com/tools/package-installation-linux-yum-apt/)。
让我们继续下载和安装过程，安装的 git 包取决于你的 Linux 发行版。然后按照下面的方法来克隆 Github speedtest 存储库
```
[root@kerneltalks ~]# git clone https://github.com/sivel/speedtest-cli.git
Cloning into 'speedtest-cli'...
remote: Counting objects: 913, done.
remote: Total 913 (delta 0), reused 0 (delta 0), pack-reused 913
Receiving objects: 100% (913/913), 251.31 KiB | 143.00 KiB/s, done.
Resolving deltas: 100% (518/518), done.
```
它将会被克隆到你当前的工作目录，新的名为 `speedtest-cli` 的目录将会被创建，你将在新的目录下看到如下的文件。
```
[root@kerneltalks ~]# cd speedtest-cli
[root@kerneltalks speedtest-cli]# ll
total 96
-rw-r--r--. 1 root root 1671 Oct 7 16:55 CONTRIBUTING.md
-rw-r--r--. 1 root root 11358 Oct 7 16:55 LICENSE
-rw-r--r--. 1 root root 35 Oct 7 16:55 MANIFEST.in
-rw-r--r--. 1 root root 5215 Oct 7 16:55 README.rst
-rw-r--r--. 1 root root 20 Oct 7 16:55 setup.cfg
-rw-r--r--. 1 root root 3196 Oct 7 16:55 setup.py
-rw-r--r--. 1 root root 2385 Oct 7 16:55 speedtest-cli.1
-rw-r--r--. 1 root root 1200 Oct 7 16:55 speedtest_cli.py
-rwxr-xr-x. 1 root root 47228 Oct 7 16:55 speedtest.py
-rw-r--r--. 1 root root 333 Oct 7 16:55 tox.ini
```
名为 `speedtest.py` 的 Python 脚本文件就是用来测试网速的。
你可以将这个脚本链接到 `/usr/bin` 下，以便这台机器上的所有用户都能使用。或者你可以为这个脚本创建一个[命令别名](https://kerneltalks.com/commands/command-alias-in-linux-unix/)，这样就能让所有用户很容易使用它。
### 运行 Python 脚本
现在，直接运行这个脚本，不需要添加任何参数，它将会搜寻最近的服务器来测试你的网速。
```
[root@kerneltalks speedtest-cli]# python speedtest.py
Retrieving speedtest.net configuration...
Testing from Amazon (35.154.184.126)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Spectra (Mumbai) [1.15 km]: 8.174 ms
Testing download speed................................................................................
Download: 548.13 Mbit/s
Testing upload speed................................................................................................
Upload: 323.95 Mbit/s
```
Oh！ 不要被这个网速惊讶道。我在 AWE EX2 的服务器上。那是亚马逊数据中心的网速！
### 这个脚本可以添加有不同的选项。
下面的几个选项对这个脚本可能会很有用处：
**要搜寻你附近的网路测试服务器**，使用 `--list` 和 `grep` 加上地名来列出所有附近的服务器。
```
[root@kerneltalks speedtest-cli]# python speedtest.py --list | grep -i mumbai
2827) Bharti Airtel Ltd (Mumbai, India) [1.15 km]
8978) Spectra (Mumbai, India) [1.15 km]
4310) Hathway Cable and Datacom Ltd (Mumbai, India) [1.15 km]
3315) Joister Broadband (Mumbai, India) [1.15 km]
1718) Vodafone India (Mumbai, India) [1.15 km]
6454) YOU Broadband India Pvt Ltd. (Mumbai, India) [1.15 km]
9764) Railtel Corporation of india Ltd (Mumbai, India) [1.15 km]
9584) Sheng Li Telecom (Mumbai, India) [1.15 km]
7605) Idea Cellular Ltd. (Mumbai, India) [1.15 km]
8122) Sify Technologies Ltd (Mumbai, India) [1.15 km]
9049) I-ON (Mumbai, India) [1.15 km]
6403) YOU Broadband India Pvt Ltd., Mumbai (Mumbai, India) [1.15 km]
```
然后你就能从搜寻结果中看到，第一列是服务器识别号，紧接着是公司的名称和所在地，最后是离你的距离。
**如果要使用指定的服务器来测试网速**，后面跟上 `--server` 加上服务器的识别号。
```
[root@kerneltalks speedtest-cli]# python speedtest.py --server 2827
Retrieving speedtest.net configuration...
Testing from Amazon (35.154.184.126)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Bharti Airtel Ltd (Mumbai) [1.15 km]: 13.234 ms
Testing download speed................................................................................
Download: 93.47 Mbit/s
Testing upload speed................................................................................................
Upload: 69.25 Mbit/s
```
**如果想得到你的测试结果的分享链接**，使用 `--share`，你将会得到测试结果的链接。
```
[root@kerneltalks speedtest-cli]# python speedtest.py --share
Retrieving speedtest.net configuration...
Testing from Amazon (35.154.184.126)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Spectra (Mumbai) [1.15 km]: 7.471 ms
Testing download speed................................................................................
Download: 621.00 Mbit/s
Testing upload speed................................................................................................
Upload: 367.37 Mbit/s
Share results: http://www.speedtest.net/result/6687428141.png
```
输出中的最后一行就是你的测试结果的链接。下载下来的图片内容如下 :
这就是全部的过程！如果你不想了解这些技术细节，你也可以使用如下的一行命令迅速测出你的网速。
### 要想在终端使用一条命令测试网速。
我们将使用 `curl` 工具来在线抓取上面使用的 Python 脚本然后直接用 Python 执行脚本。
```
[root@kerneltalks ~]# curl -s https://raw.githubusercontent.com/sivel/speedtest-cli/master/speedtest.py | python -
```
上面的脚本将会运行脚本输出结果到屏幕上。
```
[root@kerneltalks speedtest-cli]# curl -s https://raw.githubusercontent.com/sivel/speedtest-cli/master/speedtest.py | python -
Retrieving speedtest.net configuration...
Testing from Amazon (35.154.184.126)...
Retrieving speedtest.net server list...
Selecting best server based on ping...
Hosted by Spectra (Mumbai) [1.15 km]: 12.599 ms
Testing download speed................................................................................
Download: 670.88 Mbit/s
Testing upload speed................................................................................................
Upload: 355.84 Mbit/s
```
这是在 RHEL 7 上执行的结果，在 Ubuntu、Debian、Fedora 或者 CentOS 上一样可以执行。
---
via: <https://kerneltalks.com/tips-tricks/how-to-test-internet-speed-in-linux-terminal/>
作者：[Shrikant Lavhate](https://kerneltalks.com) 译者：[FelixYFZ](https://github.com/FelixYFZ) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 系统中 sudo 命令的 10 个技巧
|
Pradeep Kumar
|
https://www.linuxtechi.com/quick-tips-sudo-command-linux-systems/
|
sudo 表示 “superuser do”。 它允许已验证的用户以其他用户的身份来运行命令。其他用户可以是普通用户或者超级用户。然而，大部分时候我们用它来以提升的权限来运行命令。
|
/data/attachment/album/201804/19/014018aaiy499x4ygca02x.jpg.thumb.jpg
|
/data/attachment/album/201804/19/014018aaiy499x4ygca02x.jpg
| true | false | true |
szcf-weiya
| false |
[
"sudo",
"su"
] |
技术
|
{
"viewnum": 12271,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
sudo 表示 “superuser do”。 它允许已验证的用户以其他用户的身份来运行命令。其他用户可以是普通用户或者超级用户。然而，大部分时候我们用它来以提升的权限来运行命令。
| 2018-04-19T14:34:00 | 2018-04-19T14:34:00 | 9,559 |
/article-9559-1.html
|
### 概览
`sudo` 表示 “**s**uper**u**ser **do**”。 它允许已验证的用户以其他用户的身份来运行命令。其他用户可以是普通用户或者超级用户。然而，大部分时候我们用它来以提升的权限来运行命令。
`sudo` 命令与安全策略配合使用，默认安全策略是 `sudoers`，可以通过文件 `/etc/sudoers` 来配置。其安全策略具有高度可拓展性。人们可以开发和分发他们自己的安全策略作为插件。
### 与 su 的区别
在 GNU/Linux 中，有两种方式可以用提升的权限来运行命令：
* 使用 `su` 命令
* 使用 `sudo` 命令
`su` 表示 “**s**witch **u**ser”。使用 `su`，我们可以切换到 root 用户并且执行命令。但是这种方式存在一些缺点：
* 我们需要与他人共享 root 的密码。
* 因为 root 用户为超级用户，我们不能授予受控的访问权限。
* 我们无法审查用户在做什么。
`sudo` 以独特的方式解决了这些问题。
1. 首先，我们不需要妥协来分享 root 用户的密码。普通用户使用他们自己的密码就可以用提升的权限来执行命令。
2. 我们可以控制 `sudo` 用户的访问，这意味着我们可以限制用户只执行某些命令。
3. 除此之外，`sudo` 用户的所有活动都会被记录下来，因此我们可以随时审查进行了哪些操作。在基于 Debian 的 GNU/Linux 中，所有活动都记录在 `/var/log/auth.log` 文件中。
本教程后面的部分阐述了这些要点。
### 实际动手操作 sudo
现在，我们对 sudo 有了大致的了解。让我们实际动手操作吧。为了演示，我使用 Ubuntu。但是，其它发行版本的操作应该是相同的。
#### 允许 sudo 权限
让我们添加普通用户为 `sudo` 用户吧。在我的情形中，用户名为 `linuxtechi`。
1) 按如下所示编辑 `/etc/sudoers` 文件：
```
$ sudo visudo
```
2) 添加以下行来允许用户 `linuxtechi` 有 sudo 权限：
```
linuxtechi ALL=(ALL) ALL
```
上述命令中：
* `linuxtechi` 表示用户名
* 第一个 `ALL` 指示允许从任何终端、机器访问 `sudo`
* 第二个 `(ALL)` 指示 `sudo` 命令被允许以任何用户身份执行
* 第三个 `ALL` 表示所有命令都可以作为 root 执行
#### 以提升的权限执行命令
要用提升的权限执行命令，只需要在命令前加上 `sudo`，如下所示：
```
$ sudo cat /etc/passwd
```
当你执行这个命令时，它会询问 `linuxtechi` 的密码，而不是 root 用户的密码。
#### 以其他用户执行命令
除此之外，我们可以使用 `sudo` 以另一个用户身份执行命令。例如，在下面的命令中，用户 `linuxtechi` 以用户 `devesh` 的身份执行命令：
```
$ sudo -u devesh whoami
[sudo] password for linuxtechi:
devesh
```
#### 内置命令行为
`sudo` 的一个限制是 —— 它无法使用 Shell 的内置命令。例如， `history` 记录是内置命令，如果你试图用 `sudo` 执行这个命令，那么会提示如下的未找到命令的错误：
```
$ sudo history
[sudo] password for linuxtechi:
sudo: history: command not found
```
**访问 root shell**
为了克服上述问题，我们可以访问 root shell，并在那里执行任何命令，包括 Shell 的内置命令。
要访问 root shell, 执行下面的命令:
```
$ sudo bash
```
执行完这个命令后——您将观察到提示符变为井号（`#`）。
### 技巧
这节我们将讨论一些有用的技巧，这将有助于提高生产力。大多数命令可用于完成日常任务。
#### 以 sudo 用户执行之前的命令
让我们假设你想用提升的权限执行之前的命令，那么下面的技巧将会很有用：
```
$ sudo !4
```
上面的命令将使用提升的权限执行历史记录中的第 4 条命令。
#### 在 Vim 里面使用 sudo 命令
很多时候，我们编辑系统的配置文件时，在保存时才意识到我们需要 root 访问权限来执行此操作。因为这个可能让我们丢失我们对文件的改动。没有必要惊慌，我们可以在 Vim 中使用下面的命令来解决这种情况：
```
:w !sudo tee %
```
上述命令中：
* 冒号 (`:`) 表明我们处于 Vim 的退出模式
* 感叹号 (`!`) 表明我们正在运行 shell 命令
* `sudo` 和 `tee` 都是 shell 命令
* 百分号 (`%`) 表明从当前行开始的所有行
#### 使用 sudo 执行多个命令
至今我们用 `sudo` 只执行了单个命令，但我们可以用它执行多个命令。只需要用分号 (`;`) 隔开命令，如下所示：
```
$ sudo -- bash -c 'pwd; hostname; whoami'
```
上述命令中
* 双连字符 (`--`) 停止命令行切换
* `bash` 表示要用于执行命令的 shell 名称
* `-c` 选项后面跟着要执行的命令
#### 无密码运行 sudo 命令
当第一次执行 `sudo` 命令时，它会提示输入密码，默认情形下密码被缓存 15 分钟。但是，我们可以避免这个操作，并使用 `NOPASSWD` 关键字禁用密码认证，如下所示：
```
linuxtechi ALL=(ALL) NOPASSWD: ALL
```
#### 限制用户执行某些命令
为了提供受控访问，我们可以限制 `sudo` 用户只执行某些命令。例如，下面的行只允许执行 `echo` 和 `ls` 命令 。
```
linuxtechi ALL=(ALL) NOPASSWD: /bin/echo /bin/ls
```
#### 深入了解 sudo
让我们进一步深入了解 `sudo` 命令。
```
$ ls -l /usr/bin/sudo
-rwsr-xr-x 1 root root 145040 Jun 13 2017 /usr/bin/sudo
```
如果仔细观察文件权限，则发现 `sudo` 上启用了 setuid 位。当任何用户运行这个二进制文件时，它将以拥有该文件的用户权限运行。在所示情形下，它是 root 用户。
为了演示这一点，我们可以使用 `id` 命令，如下所示：
```
$ id
uid=1002(linuxtechi) gid=1002(linuxtechi) groups=1002(linuxtechi)
```
当我们不使用 `sudo` 执行 `id` 命令时，将显示用户 `linuxtechi` 的 id。
```
$ sudo id
uid=0(root) gid=0(root) groups=0(root)
```
但是，如果我们使用 `sudo` 执行 `id` 命令时，则会显示 root 用户的 id。
### 结论
从这篇文章可以看出 —— `sudo` 为普通用户提供了更多受控访问。使用这些技术，多用户可以用安全的方式与 GNU/Linux 进行交互。
---
via: <https://www.linuxtechi.com/quick-tips-sudo-command-linux-systems/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 译者：[szcf-weiya](https://github.com/szcf-weiya) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
八种敏捷团队的提升方法
|
Jen Krieger
|
https://opensource.com/article/18/1/foss-tools-agile-teams
|
在这个列表中，没有项目管理软件，这里不包含清单，也没有与 GitHub 整合，只是几种组织思维和提高团队交流的方法。
|
/data/attachment/album/201804/19/213224wdzr3355oayrfr9i.png.thumb.jpg
|
/data/attachment/album/201804/19/213224wdzr3355oayrfr9i.png
| true | false | true |
Valoniakim
| false |
[
"敏捷"
] |
观点
|
{
"viewnum": 4919,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这个列表中，没有项目管理软件，这里不包含清单，也没有与 GitHub 整合，只是几种组织思维和提高团队交流的方法。
| 2018-04-19T21:32:17 | 2018-04-19T21:32:17 | 9,560 |
/article-9560-1.html
|
>
> 在这个列表中，没有项目管理软件，这里不包含清单，也没有与 GitHub 整合，只是几种组织思维和提高团队交流的方法。
>
>
>
你也许经常听说下面这句话：工具太多，时间太少。为了节约您的时间，我列出了几款我最常用的提高敏捷团队工作效率的工具。如果你也是一名敏捷主义者，你可能听说过类似的工具，但我这里提到的仅限于开源工具。
**请注意！** 这些工具和你想象的可能有点不同。它们并不是项目管理软件——这领域已经有一篇[好文章](https://opensource.com/business/16/3/top-project-management-tools-2016)了。因此这里不包含清单，也没有与 GitHub 整合，只是几种组织思维和提高团队交流的方法。
### 组建一个充满积极反馈的团队
如果在产业中大部分人都习惯了输出、接收负面消息，就很难有人对同事进行正面反馈的输出。这并不奇怪，当人们乐于给出赞美时，人们就会竞相向别人说“干得漂亮！”、“没有你我们很难完成任务。”赞美别人干的漂亮并不会使你痛苦，它通常能激励大家更好地为团队工作。下面两个软件可以帮助你向同事表达赞扬。
* 对开发团队来说，[Management 3.0](https://management30.com/) 是个有着大量[免费资源](https://management30.com/leadership-resource-hub/)的宝箱，可以尽情使用。其中 Feedback Wraps 的观念最引人注目（不仅仅是因为它让我们联想到墨西哥卷）。 [Feedback Wraps](https://management30.com/en/practice/feedback-wraps/) 是一个经过六步对用户进行反馈的程序，也许你会认为它是为了负面反馈而设计的，但我们发现它在表达积极评论方面十分有效。
* [Happiness Packets](https://happinesspackets.io/) 为用户提供了在开源社区内匿名正面反馈的服务。它尤其适合不太习惯人际交往的用户或是不知道说什么好的情况。Happiness Packets 拥有一份[公开的评论档案](https://www.happinesspackets.io/archive/)（这些评论都已经得到授权分享），你可以浏览大家的评论，从中得到灵感，对别人做出暖心的称赞。它还有个特殊功能，能够屏蔽恶意消息。
### 思考工作的意义
这很难定义。在敏捷领域中，成功的关键包括定义人物角色和产品愿景，还要向整个敏捷团队说明此项工作的意义。产品开发人员和项目负责人能够获得的开源工具数量极为有限，对于这一点我们有些失望。
在 Rat Hat 公司，最受尊敬也最为常用于训练敏捷团队的开源工具之一是 Product Vision Board 。它出自产品管理专家 Roman Pichler 之手，Roman Pichler 提供了[大量工具和模版](http://www.romanpichler.com/tools/)来帮助敏捷团队理解他们工作的意义。（你需要提供电子邮箱地址才能下载这些工具。）
* [Product Vision Board](http://www.romanpichler.com/tools/vision-board/) 的模版通过简单但有效的问题引导团队转变思考方式，将思考工作的意义置于具体工作方法之前。
* 我们也很喜欢 Roman 的 [Product Management Test](http://www.romanpichler.com/tools/romans-product-management-test/)，它能够通过简便快捷的网页表单，引领团队重新定义产品开发人员的角色，并且找出程序漏洞。我们推荐产品开发团队周期性地完成此项测试，重新分析失败原因。
### 对工作内容的直观化
你是否曾为一个大案子焦头烂额，连熟悉的步骤也在脑海中乱成一团？我们也遇到过这种情况。使用思维导图可以梳理你脑海中的想法，使其直观化。你不需要一下就想出整件事该怎么进行，你只需要你的头脑，一块白板（或者是思维导图软件）和一些思考的时间。
* 在这个领域中我们最喜欢的开源工具是 [Xmind3](https://sourceforge.net/projects/xmind3/?source=recommended)。它支持多种平台运行（Linux、MacOS 和 Windows），以便与他人共享文件。如果你对工具的要求很高，推荐使用[其更新版本](http://www.xmind.net/)，提供电子邮箱地址即可免费下载使用。
* 如果你很看重灵活性，Eduard Lucena 在 Fedora Magazine 中提供的 [三个附加选项](https://fedoramagazine.org/three-mind-mapping-tools-fedora/) 就十分适合。你可以在 Fedora 杂志上找到这些软件的获取方式，其他信息可以在它们的项目页找到。
+ [Labyrinth](https://people.gnome.org/%7Edscorgie/labyrinth.html)
+ [View Your Mind](http://www.insilmaril.de/vym/)
+ [FreeMind](http://freemind.sourceforge.net/wiki/index.php/Main_Page)
像我们开头说的一样，提高敏捷团队工作效率的工具有很多，如果你有特别喜欢的相关开源工具，请在评论中与大家分享。
### 作者简介
Jen Krieger ：Red Hat 的首席敏捷架构师，在软件开发领域已经工作超过 20 年，曾在瀑布及敏捷生命周期等领域扮演多种角色。目前在 Red Hat 负责针对 CI/CD 最佳效果的部际 DevOps 活动。最近她在与 Project Atomic & OpenShift 团队合作。她最近在引领公司向着敏捷团队改革，并增加开源项目在公司内的认知度。
---
via: <https://opensource.com/article/18/1/foss-tools-agile-teams>
作者：[Jen Krieger](https://opensource.com/users/jkrieger) 译者：[Valoniakim](https://github.com/Valoniakim) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
初识 Python： global 关键字
|
Programiz
|
https://www.programiz.com/python-programming/global-keyword
|
在 Python 中，global 关键字允许你修改当前范围之外的变量。它用于创建全局变量并在本地上下文中更改变量。
|
/data/attachment/album/201804/19/214422wfy7pvmx4c61ykvq.jpg.thumb.jpg
|
/data/attachment/album/201804/19/214422wfy7pvmx4c61ykvq.jpg
| true | false | true |
MjSeven
| false |
[
"Python"
] |
软件开发
|
{
"viewnum": 9175,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9632,
"displayorder": 0
}
] |
在 Python 中，global 关键字允许你修改当前范围之外的变量。它用于创建全局变量并在本地上下文中更改变量。
| 2018-04-19T21:44:00 | 2018-04-19T21:44:00 | 9,561 |
/article-9561-1.html
|
在读这篇文章之前，确保你对 [Python 全局、局部和非局部变量](https://www.programiz.com/python-programming/global-local-nonlocal-variables) 有一定的基础。
### global 关键字简介
在 Python 中，`global` 关键字允许你修改当前范围之外的变量。它用于创建全局变量并在本地上下文中更改变量。
### global 关键字的规则
在 Python 中，有关 `global` 关键字基本规则如下：
* 当我们在一个函数中创建一个变量时，默认情况下它是本地变量。
* 当我们在一个函数之外定义一个变量时，默认情况下它是全局变量。你不必使用 `global` 关键字。
* 我们使用 `global` 关键字在一个函数中来读写全局变量。
* 在一个函数外使用 `global` 关键字没有效果。
### 使用 global 关键字（含示例）
我们来举个例子。
#### 示例 1：从函数内部访问全局变量
```
c = 1 # 全局变量
def add():
print(c)
add()
```
运行程序，输出为：
```
1
```
但是我们可能有一些场景需要从函数内部修改全局变量。
#### 示例 2：在函数内部修改全局变量
```
c = 1 # 全局变量
def add():
c = c + 2 # 将 c 增加 2
print(c)
add()
```
运行程序，输出显示错误：
```
UnboundLocalError: local variable 'c' referenced before assignment
```
这是因为在函数中，我们只能访问全局变量但是不能修改它。
解决的办法是使用 `global` 关键字。
#### 示例 3：使用 global 在函数中改变全局变量
```
c = 0 # global variable
def add():
global c
c = c + 2 # 将 c 增加 2
print("Inside add():", c)
add()
print("In main:", c)
```
运行程序，输出为：
```
Inside add(): 2
In main: 2
```
在上面的程序中，我们在 `add()` 函数中定义了 `c` 将其作为全局关键字。
然后，我们给变量 `c` 增加 `2`，即 `c = c + 2`。之后，我们调用了 `add()` 函数。最后，打印全局变量 `c`。
正如我们所看到的，在函数外的全局变量也发生了变化，`c = 2`。
### Python 模块中的全局变量
在 Python 中，我们创建一个单独的模块 `config.py` 来保存全局变量并在同一个程序中的 Python 模块之间共享信息。
以下是如何通过 Python 模块共享全局变量。
#### 示例 4：在Python模块中共享全局变量
创建 `config.py` 文件来存储全局变量
```
a = 0
b = "empty"
```
创建 `update.py` 文件来改变全局变量
```
import config
config.a = 10
config.b = "alphabet"
```
创建 `main.py` 文件来测试其值的变化
```
import config
import update
print(config.a)
print(config.b)
```
运行 `main.py`，输出为：
```
10
alphabet
```
在上面，我们创建了三个文件： `config.py`, `update.py` 和 `main.py`。
在 `config.py` 模块中保存了全局变量 `a` 和 `b`。在 `update.py` 文件中，我们导入了 `config.py` 模块并改变了 `a` 和 `b` 的值。同样，在 `main.py` 文件，我们导入了 `config.py` 和 `update.py` 模块。最后，我们打印并测试全局变量的值，无论它们是否被改变。
### 在嵌套函数中的全局变量
以下是如何在嵌套函数中使用全局变量。
#### 示例 5：在嵌套函数中使用全局变量
```
def foo():
x = 20
def bar():
global x
x = 25
print("Before calling bar: ", x)
print("Calling bar now")
bar()
print("After calling bar: ", x)
foo()
print("x in main : ", x)
```
输出为：
```
Before calling bar: 20
Calling bar now
After calling bar: 20
x in main : 25
```
在上面的程序中，我们在一个嵌套函数 `bar()` 中声明了全局变量。在 `foo()` 函数中， 变量 `x` 没有全局关键字的作用。
调用 `bar()` 之前和之后， 变量 `x` 取本地变量的值，即 `x = 20`。在 `foo()` 函数之外，变量 `x` 会取在函数 `bar()` 中的值，即 `x = 25`。这是因为在 `bar()` 中，我们对 `x` 使用 `global` 关键字创建了一个全局变量（本地范围）。
如果我们在 `bar()` 函数内进行了任何修改，那么这些修改就会出现在本地范围之外，即 `foo()`。
---
via: <https://www.programiz.com/python-programming/global-keyword>
作者：[programiz](https://www.programiz.com) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
13 个 Git 技巧献给 Git 13 岁生日
|
John Sj Anderson
|
https://opensource.com/article/18/4/git-tips
|
这 13 个 Git 技巧将使你的版本控制技能 +1、+1、+1……
|
/data/attachment/album/201804/20/162427h1tuyumjtud0y1zz.jpg.thumb.jpg
|
/data/attachment/album/201804/20/162427h1tuyumjtud0y1zz.jpg
| true | false | true |
MjSeven
| false |
[
"版本控制",
"Git"
] |
软件开发
|
{
"viewnum": 6168,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这 13 个 Git 技巧将使你的版本控制技能 +1、+1、+1……
| 2018-04-20T16:24:00 | 2018-04-20T16:24:00 | 9,563 |
/article-9563-1.html
|
>
> 这 13 个 Git 技巧将使你的版本控制技能 +1、+1、+1……
>
>
>
[Git](https://git-scm.com/) 是一个分布式版本控制系统，它已经成为开源世界中源代码控制的默认工具，在 4 月 7 日这天，它 13 岁了。使用 Git 令人沮丧的事情之一是你需要知道更多才能有效地使用 Git。但这也可能是使用 Git 比较美妙的一件事，因为没有什么比发现一个新技巧来简化或提高你的工作流的效率更令人快乐了。
为了纪念 Git 的 13 岁生日，这里有 13 条技巧和诀窍来让你的 Git 经验更加有用和强大。从你可能忽略的一些基本知识开始，并扩展到一些真正的高级用户技巧！
### 1、 你的 ~/.gitconfig 文件
当你第一次尝试使用 `git` 命令向仓库提交一个更改时，你可能会收到这样的欢迎信息：
```
*** Please tell me who you are.
Run
git config --global user.email "you@example.com"
git config --global user.name "Your Name"
to set your account's default identity.
```
你可能没有意识到正是这些命令在修改 `~/.gitconfig` 的内容，这是 Git 存储全局配置选项的地方。你可以通过 `~/.gitconfig` 文件来做大量的事，包括定义别名、永久性打开（或关闭）特定命令选项，以及修改 Git 工作方式（例如，`git diff` 使用哪个 diff 算法，或者默认使用什么类型的合并策略）。你甚至可以根据仓库的路径有条件地包含其他配置文件！所有细节请参阅 `man git-config`。
### 2、 你仓库中的 .git/config 文件
在之前的技巧中，你可能想知道 `git config` 命令中 `--global` 标志是干什么的。它告诉 Git 更新 `~/.gitconfig` 中的“全局”配置。当然，有全局配置也意味着会有本地配置，显然，如果你省略 `--global` 标志，`git config` 将改为更新仓库特有的配置，该配置存储在 `.git/config` 中。
在 `.git/config` 文件中设置的选项将覆盖 `~/.gitconfig` 文件中的所有设置。因此，例如，如果你需要为特定仓库使用不同的电子邮件地址，则可以运行 `git config user.email "also_you@example.com"`。然后，该仓库中的任何提交都将使用你单独配置的电子邮件地址。如果你在开源项目中工作，而且希望它们显示自己的电子邮件地址，同时仍然使用自己工作邮箱作为主 Git 配置，这非常有用。
几乎任何你可以在 `~/.gitconfig` 中设置的东西，你也可以在 `.git/config` 中进行设置，以使其作用于特定的仓库。在下面的技巧中，当我提到将某些内容添加到 `~/.gitconfig` 时，只需记住你也可以在特定仓库的 `.git/config` 中添加来设置那个选项。
### 3、 别名
别名是你可以在 `~/.gitconfig` 中做的另一件事。它的工作原理就像命令行中的 shell —— 它们设定一个新的命令名称，可以调用一个或多个其他命令，通常使用一组特定的选项或标志。它们对于那些你经常使用的又长又复杂的命令来说非常有效。
你可以使用 `git config` 命令来定义别名 —— 例如，运行 `git config --global --add alias.st status` 将使运行 `git st` 与运行 `git status` 做同样的事情 —— 但是我在定义别名时发现，直接编辑 `~/.gitconfig` 文件通常更容易。
如果你选择使用这种方法，你会发现 `~/.gitconfig` 文件是一个 [INI 文件](https://en.wikipedia.org/wiki/INI_file)。INI 是一种带有特定段落的键值对文件格式。当添加一个别名时，你将改变 `[alias]` 段落。例如，定义上面相同的 `git st` 别名时，添加如下到文件：
```
[alias]
st = status
```
（如果已经有 `[alias]` 段落，只需将第二行添加到现有部分。）
### 4、 shell 命令中的别名
别名不仅仅限于运行其他 Git 子命令 —— 你还可以定义运行其他 shell 命令的别名。这是一个用来处理一个反复发生的、罕见和复杂的任务的很好方式：一旦你确定了如何完成它，就可以在别名下保存该命令。例如，我有一些<ruby> 复刻 <rt> fork </rt></ruby>的开源项目的仓库，并进行了一些本地修改。我想跟上项目正在进行的开发工作，并保存我本地的变化。为了实现这个目标，我需要定期将来自上游仓库的更改合并到我复刻的项目中 —— 我通过使用我称之为 `upstream-merge` 的别名来完成。它是这样定义的：
```
upstream-merge = !"git fetch origin -v && git fetch upstream -v && git merge upstream/master && git push"
```
别名定义开头的 `!` 告诉 Git 通过 shell 运行这个命令。这个例子涉及到运行一些 `git` 命令，但是以这种方式定义的别名可以运行任何 shell 命令。
（注意，如果你想复制我的 `upstream-merge` 别名，你需要确保你有一个名为 `upstream` 的 Git 远程仓库，指向你已经分配的上游仓库，你可以通过运行 `git remote add upstream <URL to repo>` 来添加一个。）
### 5、 可视化提交图
如果你在一个有很多分支活动的项目上开发，有时可能很难掌握所有正在发生的工作以及它们之间的相关性。各种图形用户界面工具可让你获取不同分支的图片并在所谓的“提交图表”中提交。例如，以下是我使用 [GitLab](https://gitlab.com/) 提交图表查看器可视化的我的一个仓库的一部分：
如果你是一个专注于命令行的用户或者发现分支切换工具让人分心，那么可以从命令行获得类似的提交视图。这就是 `git log` 命令的 `--graph` 参数出现的地方：
以下命令可视化相同仓库可达到相同效果：
```
git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative
```
`--graph` 选项将图添加到日志的左侧，`--abbrev-commit` 缩短提交的 [SHA](https://en.wikipedia.org/wiki/Secure_Hash_Algorithms) 值，`--date=relative` 以相对方式表示日期，以及 `--pretty` 来处理所有其他自定义格式。我有个 `git lg` 别名用于这个功能，它是我最常用的 10 个命令之一。
### 6、 更优雅的强制推送
有时，你越是想避开越避不开，你会发现你需要运行 `git push --force` 来覆盖仓库远程副本上的历史记录。你可能得到了一些反馈，需要你进行交互式<ruby> 变基 <rt> rebase </rt></ruby>，或者你可能已经搞砸了，并希望隐藏“罪证”。
当其他人在仓库的远程副本的同一分支上进行更改时，会发生强制推送的危险。当你强制推送已重写的历史记录时，这些提交将会丢失。这就是 `git push --force-with-lease` 出现的原因 -- 如果远程分支已经更新，它不会允许你强制推送，这确保你不会丢掉别人的工作。
### 7、 git add -N
你是否使用过 `git commit -a` 在一次行动中提交所有未完成的修改，但在你推送完提交后才发现 `git commit -a` 忽略了新添加的文件？你可以使用 `git add -N` (想想 “notify”) 来解决这个问题，告诉 Git 在第一次实际提交它们之前，你希望在提交中包含新增文件。
### 8、 git add -p
使用 Git 时的最佳做法是确保每次提交都只包含一个逻辑修改 —— 无论这是修复错误还是添加新功能。然而，有时当你在工作时，你的仓库中的修改最终应该使用多个提交。你怎样才能设法把事情分开，使每个提交只包含适当的修改呢？`git add --patch` 来拯救你了！
这个标志会让 `git add` 命令查看你工作副本中的所有变化，并为每个变化询问你是否想要将它提交、跳过，或者推迟决定（你可以在运行该命令后选择 `?` 来查看其他更强大的选项）。`git add -p` 是生成结构良好的提交的绝佳工具。
### 9、 git checkout -p
与 `git add -p` 类似，`git checkout` 命令也接受 `--patch` 或 `-p` 选项，这会使其在本地工作副本中显示每个“大块”的改动，并允许丢弃它 —— 简单来说就是将本地工作副本恢复到更改之前的状态。
这真的很棒。例如，当你追踪一个 bug 时引入了一堆调试日志语句，修正了这个 bug 之后，你可以先使用 `git checkout -p` 移除所有新的调试日志，然后 `git add -p` 来添加 bug 修复。没有比组合一个优雅的、结构良好的提交更令人满意！
### 10、 变基时执行命令
有些项目有一个规则，即存储库中的每个提交都必须处于可工作状态 —— 也就是说，在每次提交时，应该可以编译该代码，或者应该运行测试套件而不会失败。 当你在分支上工作时，这并不困难，但是如果你最终因为某种原因需要<ruby> 变基 <rt> rebase </rt></ruby>时，那么需要逐步完成每个变基的提交以确保你没有意外地引入一个中断，而这个过程是乏味的。
幸运的是，`git rebase` 已经覆盖了 `-x` 或 `--exec` 选项。`git rebase -x <cmd>` 将在每个提交在变基中被应用后运行该命令。因此，举个例子，如果你有一个项目，其中使用 `npm run tests` 运行你的测试套件，`git rebase -x npm run tests` 将在变基期间每次提交之后运行测试套件。这使你可以查看测试套件是否在任何变基的提交中失败，以便你可以确认测试套件在每次提交时仍能通过。
### 11、 基于时间的修订引用
很多 Git 子命令都接受一个修订参数来决定命令作用于仓库的哪个部分，可以是某次特定的提交的 SHA1 值，一个分支的名称，甚至是一个符号性的名称如 `HEAD`（代表当前检出分支最后一次的提交），除了这些简单的形式以外，你还可以附加一个指定的日期或时间作为参数，表示“这个时间的引用”。
这个功能在某些时候会变得十分有用。当你处理最新出现的 bug，自言自语道：“这个功能昨天还是好好的，到底又改了些什么”，不用盯着满屏的 `git log` 的输出试图弄清楚什么时候更改了提交，你只需运行 `git diff HEAD@{yesterday}`，看看从昨天以来的所有修改。这也适用于更长的时间段（例如 `git diff HEAD@{'2 months ago'}`），以及一个确切的日期（例如 `git diff HEAD@{'2010-01-01 12:00:00'}`）。
你也可以将这些基于日期的修订参数与使用修订参数的任何 Git 子命令一起使用。在 `gitrevisions` 手册页中有关于具体使用哪种格式的详细信息。
### 12、 全知的 reflog
你是不是试过在变基时干掉过某次提交，然后发现你需要保留那个提交中一些东西？你可能觉得这些信息已经永远找不回来了，只能重新创建。但是如果你在本地工作副本中提交了，提交就会被添加到引用日志（reflog）中 ，你仍然可以访问到。
运行 `git reflog` 将在本地工作副本中显示当前分支的所有活动的列表，并为你提供每个提交的 SHA1 值。一旦发现你变基时放弃的那个提交，你可以运行 `git checkout <SHA1>` 跳转到该提交，复制任何你需要的信息，然后再运行 `git checkout HEAD` 返回到分支最近的提交去。
### 13、 自己清理
哎呦！ 事实证明，我的基本数学技能不如我的 Git 技能。 Git 最初是在 2005 年发布的，这意味着它今年会变成 13 岁，而不是 12 岁（LCTT 译注：本文原来是以 12 岁生日为题的）。为了弥补这个错误，这里有可以让我们变成十三岁的第 13 条技巧。
如果你使用基于分支的工作流，随着在一个长期项目上的工作，除非你在每个分支合并时清理干净，否则你最终会得到一大堆分支。这使得你难于找到想要的分支，分支的森林会让你无从找起。甚至更糟糕的是，如果你有大量活跃的分支，确定一个分支是否被合并（可以被安全删除）或仍然没有被合并而应该留下会非常繁琐。幸运的是，Git 可以帮到你：只需要运行 `git branch --merged` 就可以得到已经被合并到你的当前分支的分支列表，或者 `git branch --no-merged` 找出被合并到其它分支的分支。默认情况下这会列出你本地工作副本的分支，但是如果你在命令行包括 `--remote` 或 `-r` 参数，它也会列出仅存于远程仓库的已合并分支。
重要提示：如果你计划使用 `git branch --merged` 的输出来清理那些已合并的分支，你要小心它的输出也包括了当前分支（毕竟，这个当前的分支就被合并到当前分支！）。确保你在任何销毁动作之前排除了该分支（如果你忘记了，参见第 12 条技巧来学习 reflog 怎样帮你把分支找回来，希望有用……）。
### 以上是全部内容
希望这些技巧中至少有一个能够教给你一些关于 Git 的新东西，Git 是一个有 13 年历史的项目，并且在持续创新和增加新功能中。你最喜欢的 Git 技巧是什么？
---
via: <https://opensource.com/article/18/4/git-tips>
作者：[John SJ Anderson](https://opensource.com/users/genehack) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Fedora 社区的持续集成
|
Pierre-yves Chibon
|
https://fedoramagazine.org/continuous-integration-fedora/
|
持续集成（CI） 是为项目的每一项变更运行测试的过程，如同这是新的交付项目一样。如果持续执行，这意味着软件随时可以发布。
|
/data/attachment/album/201804/20/223151pom3st3qorrbstcr.jpg.thumb.jpg
|
/data/attachment/album/201804/20/223151pom3st3qorrbstcr.jpg
| true | false | true |
geekpi
| false |
[
"CI",
"Fedora"
] |
技术
|
{
"viewnum": 4335,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
持续集成（CI） 是为项目的每一项变更运行测试的过程，如同这是新的交付项目一样。如果持续执行，这意味着软件随时可以发布。
| 2018-04-20T22:31:44 | 2018-04-20T22:31:44 | 9,564 |
/article-9564-1.html
|
<ruby> 持续集成 <rt> Continuous Integration </rt></ruby>（CI） 是为项目的每一项变更运行测试的过程，如同这是新的交付项目一样。如果持续执行，这意味着软件随时可以发布。 CI 是整个 IT 行业以及自由开源项目非常成熟的流程。Fedora 在这方面有点落后，但我们正在赶上。阅读以下内容了解进展。
### 我们为什么需要这个？
CI 将全面改善 Fedora。它通过尽早揭示 bug 提供更稳定和一致的操作系统。它让你在遇到问题时添加测试，以免再次发生（避免回归）。CI 可以运行来自上游的项目测试，还有测试集成在发行版中 Fedora 特定的测试。
最重要的是，一致的 CI 能自动化并减少手工劳动。它释放了我们宝贵的志愿者和贡献者，让他们将更多时间花在 Fedora 的新事物上。
### 它看起来如何？
对于初学者，我们将对在 Fedora 包仓库 （dist-git） 的每个提交运行测试。这些测试独立于构建时运行的每个软件包的测试。但是，它们在尽可能接近 Fedora 用户运行环境的环境中测试软件包的功能。除了特定的软件包测试外，Fedora 还运行一些发行版测试，例如从 F27 升级到 F28 或者全新安装。
软件包根据测试结果进行“控制”：测试失败会阻止将更新推送给用户。但是，有时由于各种原因，测试会失败。也许测试本身是错误的，或者不是最新的软件。或者可能发生基础架构问题，并阻止测试正常运行。维护人员能够重新触发测试或放弃测试结果，直到测试更新。
最终，当在 <https://src.fedoraproject.org> 上有合并请求或者更新时，Fedora 的 CI 将运行测试。这将使维护者了解建议的更改对包稳定性的影响，并帮助他们决定如何进行。
### 我们如今有什么？
目前，CI 管道在 Fedora Atomic Host 的部分软件包上运行测试。其他软件包可以在 dist-git 中进行测试，但它们不会自动运行。发行版特定的测试已经在我们所有的软件包上运行。这些测试结果被用于过滤测试失败的软件包。
### 我该如何参与？
最好的入门方法是阅读关于 [Fedora 持续集成](http://fedoraproject.org/wiki/CI)的文档。你应该熟悉[标准测试接口](http://fedoraproject.org/wiki/CI/Standard_Test_Interface)，它描述了很多术语以及如何编写测试和使用现有的测试。
有了这些知识，如果你是一个软件包维护者，你可以开始添加测试到你的软件包。你可以在本地或虚拟机上运行它们。 （对于破坏性测试来说后者是明智的！）
标准测试接口使测试保持一致。因此，你可以轻松地将任何测试添加到你喜欢的包中，并在 [仓库][3](https://src.fedoraproject.org) 提交合并请求给维护人员。
在 irc.freenode.net 上与 #fedora-ci 联系，提供反馈，问题或关于 CI 的一般性讨论。
---
via: <https://fedoramagazine.org/continuous-integration-fedora/>
作者：[Pierre-Yves Chibon](https://fedoramagazine.org) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
迁移到 Linux：命令行环境
|
John Bonesio
|
https://www.linux.com/blog/learn/2018/1/migrating-linux-command-line
|
刚接触 Linux？在这篇教程中将学习如何轻松地在命令行列出、移动和编辑文件。
|
/data/attachment/album/201804/20/230316yo92hnh3ng7y23c3.jpg.thumb.jpg
|
/data/attachment/album/201804/20/230316yo92hnh3ng7y23c3.jpg
| true | false | true |
CYLeft
| false |
[
"迁移"
] |
技术
|
{
"viewnum": 6915,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9293,
"displayorder": 0
},
{
"raid": 9819,
"displayorder": 0
}
] |
刚接触 Linux？在这篇教程中将学习如何轻松地在命令行列出、移动和编辑文件。
| 2018-04-20T23:03:00 | 2018-04-20T23:03:00 | 9,565 |
/article-9565-1.html
|
>
> 刚接触 Linux？在这篇教程中将学习如何轻松地在命令行列出、移动和编辑文件。
>
>
>
这是关于迁徙到 Linux 系列的第四篇文章了。如果您错过了之前的内容，可以回顾我们之前谈到的内容 [新手之 Linux](/article-9212-1.html)、[文件和文件系统](/article-9213-1.html)、和 [图形环境](/article-9293-1.html)。Linux 无处不在，它可以用于运行大部分的网络服务器，如 Web、email 和其他服务器；它同样可以在您的手机、汽车控制台和其他很多设备上使用。现在，您可能会开始好奇 Linux 系统，并对学习 Linux 的工作原理萌发兴趣。
在 Linux 下，命令行非常实用。Linux 的桌面系统中，尽管命令行只是可选操作，但是您依旧能看见很多朋友开着一个命令行窗口和其他应用窗口并肩作战。在互联网服务器上和在设备中运行 Linux 时（LCTT 译注：指 IoT），命令行通常是唯一能直接与操作系统交互的工具。因此，命令行是有必要了解的，至少应当涉猎一些基础命令。
在命令行（通常称之为 Linux shell）中，所有操作都是通过键入命令完成。您可以执行查看文件列表、移动文件位置、显示文件内容、编辑文件内容等一系列操作，通过命令行，您甚至可以查看网页中的内容。
如果您在 Windows（CMD 或者 PowerShell） 上已经熟悉关于命令行的使用，您是否想跳转到“Windows 命令行用户”的章节上去？先阅读这些内容吧。
### 导航
在命令行中，这里有一个当前工作目录（文件夹和目录是同义词，在 Linux 中它们通常都被称为目录）的概念。如果没有特别指定目录，许多命令的执行会在当前目录下生效。比如，键入 `ls` 列出文件目录，当前工作目录的文件将会被列举出来。看一个例子：
```
$ ls
Desktop Documents Downloads Music Pictures README.txt Videos
```
`ls Documents` 这条命令将会列出 `Documents` 目录下的文件：
```
$ ls Documents
report.txt todo.txt EmailHowTo.pdf
```
通过 `pwd` 命令可以显示当前您的工作目录。比如：
```
$ pwd
/home/student
```
您可以通过 `cd` 命令改变当前目录并切换到您想要抵达的目录。比如：
```
$ pwd
/home/student
$ cd Downloads
$ pwd
/home/student/Downloads
```
路径中的目录由 `/`（左斜杠）字符分隔。路径中有一个隐含的层次关系，比如 `/home/student` 目录中，home 是顶层目录，而 `student` 是 `home` 的子目录。
路径要么是绝对路径，要么是相对路径。绝对路径由一个 `/` 字符打头。
相对路径由 `.` 或者 `..` 开始。在一个路径中，一个 `.` 意味着当前目录，`..` 意味着当前目录的上级目录。比如，`ls ../Documents` 意味着在此寻找当前目录的上级名为 `Documents` 的目录：
```
$ pwd
/home/student
$ ls
Desktop Documents Downloads Music Pictures README.txt Videos
$ cd Downloads
$ pwd
/home/student/Downloads
$ ls ../Documents
report.txt todo.txt EmailHowTo.pdf
```
当您第一次打开命令行窗口时，您当前的工作目录被设置为您的家目录，通常为 `/home/<您的登录名>`。家目录专用于登录之后存储您的专属文件。
环境变量 `$HOME` 会展开为您的家目录，比如：
```
$ echo $HOME
/home/student
```
下表显示了用于目录导航和管理简单的文本文件的一些命令摘要。
### 搜索
有时我们会遗忘文件的位置，或者忘记了我要寻找的文件名。Linux 命令行有几个命令可以帮助您搜索到文件。
第一个命令是 `find`。您可以使用 `find` 命令通过文件名或其他属性搜索文件和目录。举个例子，当您遗忘了 `todo.txt` 文件的位置，我们可以执行下面的代码：
```
$ find $HOME -name todo.txt
/home/student/Documents/todo.txt
```
`find` 程序有很多功能和选项。一个简单的例子：
```
find <要寻找的目录> -name <文件名>
```
如果这里有 `todo.txt` 文件且不止一个，它将向我们列出拥有这个名字的所有文件的所有所在位置。`find` 命令有很多便于搜索的选项比如类型（文件或是目录等等）、时间、大小和其他一些选项。更多内容您可以同通过 `man find` 获取关于如何使用 `find` 命令的帮助。
您还可以使用 `grep` 命令搜索文件的特定内容，比如：
```
grep "01/02/2018" todo.txt
```
这将为您展示 `todo` 文件中 `01/02/2018` 所在行。
### 获取帮助
Linux 有很多命令，这里，我们没有办法一一列举。授人以鱼不如授人以渔，所以下一步我们将向您介绍帮助命令。
`apropos` 命令可以帮助您查找需要使用的命令。也许您想要查找能够操作目录或是获得文件列表的所有命令，但是您不知道该运行哪个命令。您可以这样尝试：
```
apropos directory
```
要在帮助文档中，得到一个于 `directiory` 关键字的相关命令列表，您可以这样操作：
```
apropos "list open files"
```
这将提供一个 `lsof` 命令给您，帮助您列出打开文件的列表。
当您明确知道您要使用的命令，但是不确定应该使用什么选项完成预期工作，您可以使用 `man` 命令，它是 manual 的缩写。您可以这样使用：
```
man ls
```
您可以在自己的设备上尝试这个命令。它会提供给您关于使用这个命令的完整信息。
通常，很多命令都能够接受 `help` 选项（比如说，`ls --help`），列出命令使用的提示。`man` 页面的内容通常太繁琐，`--help` 选项可能更适合快速浏览。
### 脚本
Linux 命令行中最贴心的功能之一是能够运行脚本文件，并且能重复运行。Linux 命令可以存储在文本文件中，您可以在文件的开头写入 `#!/bin/sh`，后面的行是命令。之后，一旦文件被存储为可执行文件，您就可以像执行命令一样运行脚本文件，比如，
```
--- contents of get_todays_todos.sh ---
#!/bin/sh
todays_date=`date +"%m/%d/%y"`
grep $todays_date $HOME/todos.txt
```
脚本可以以一套可重复的步骤自动化执行特定命令。如果需要的话，脚本也可以很复杂，能够使用循环、判断语句等。限于篇幅，这里不细述，但是您可以在网上查询到相关信息。
### Windows 命令行用户
如果您对 Windows CMD 或者 PowerShell 程序很熟悉，在命令行输入命令应该是轻车熟路的。然而，它们之间有很多差异，如果您没有理解它们之间的差异可能会为之困扰。
首先，在 Linux 下的 `PATH` 环境与 Windows 不同。在 Windows 中，当前目录被认为是该搜索路径（`PATH`）中的第一个文件夹，尽管该目录没有在环境变量中列出。而在 Linux 下，当前目录不会明确的放在搜索路径中。Linux 下设置环境变量会被认为是风险操作。在 Linux 的当前目录执行程序，您需要使用 `./`（代表当前目录的相对目录表示方式） 前缀。这可能会搞糊涂很多 CMD 用户。比如：
```
./my_program
```
而不是
```
my_program
```
另外，在 Windows 环境变量的路径中是以 `;`（分号） 分割的。在 Linux 中，由 `:` 分割环境变量。同样，在 Linux 中路径由 `/` 字符分隔，而在 Windows 目录中路径由 `\` 字符分割。因此 Windows 中典型的环境变量会像这样：
```
PATH="C:\Program Files;C:\Program Files\Firefox;"
```
而在 Linux 中看起来像这样：
```
PATH="/usr/bin:/opt/mozilla/firefox"
```
还要注意，在 Linux 中环境变量由 `$` 拓展，而在 Windows 中您需要使用百分号（就是这样： `%PATH%`）。
在 Linux 中，通过 `-` 使用命令选项，而在 Windows 中，使用选项要通过 `/` 字符。所以，在 Linux 中您应该：
```
a_prog -h
```
而不是
```
a_prog /h
```
在 Linux 下，文件拓展名并没有意义。例如，将 `myscript` 重命名为 `myscript.bat` 并不会因此而变得可执行，需要设置文件的执行权限。文件执行权限会在下次的内容中覆盖到。
在 Linux 中，如果文件或者目录名以 `.` 字符开头，意味着它们是隐藏文件。比如，如果您申请编辑 `.bashrc` 文件，您不能在家目录中找到它，但是它可能真的存在，只不过它是隐藏文件。在命令行中，您可以通过 `ls` 命令的 `-a` 选项查看隐藏文件，比如：
```
ls -a
```
在 Linux 中，普通的命令与 Windows 的命令不尽相同。下面的表格显示了常用命令中 CMD 命令和 Linux 命令行的差异。
---
via: <https://www.linux.com/blog/learn/2018/1/migrating-linux-command-line>
作者：[John Bonesio](https://www.linux.com/users/johnbonesio) 译者：[CYLeft](https://github.com/CYLeft) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何像 Linux 专家那样使用 WSL
|
Swapnil Bhartiya
|
https://www.linux.com/blog/learn/2018/2/how-use-wsl-linux-pro
|
在本 WSL 教程中了解如何执行像挂载 USB 驱动器和操作文件等任务。
|
/data/attachment/album/201804/22/010003ra74qj2aqaajqqzm.png.thumb.jpg
|
/data/attachment/album/201804/22/010003ra74qj2aqaajqqzm.png
| true | false | true |
geekpi
| false |
[
"WSL"
] |
技术
|
{
"viewnum": 8377,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9545,
"displayorder": 0
}
] |
在本 WSL 教程中了解如何执行像挂载 USB 驱动器和操作文件等任务。
| 2018-04-22T00:59:59 | 2018-04-22T00:59:59 | 9,566 |
/article-9566-1.html
|
>
> 在本 WSL 教程中了解如何执行像挂载 USB 驱动器和操作文件等任务。
>
>
>
在[之前的教程](/article-9545-1.html)中，我们学习了如何在 Windows 10 上设置 WSL。你可以在 Windows 10 中使用 WSL 执行许多 Linux 命令。无论是基于 Linux 的系统还是 macOS，它们的许多系统管理任务都是在终端内部完成的。然而，Windows 10 缺乏这样的功能。你想运行一个 cron 任务么？不行。你想 SSH 进入你的服务器，然后 `rsync` 文件么？没门。如何用强大的命令行工具管理本地文件，而不是使用缓慢和不可靠的 GUI 工具呢？
在本教程中，你将看到如何使用 WSL 执行除了管理之外的任务 —— 例如挂载 USB 驱动器和操作文件。你需要运行一个完全更新的 Windows 10 并选择一个 Linux 发行版。我在[上一篇文章](/article-9545-1.html)中介绍了这些步骤，所以如果你跟上进度，那就从那里开始。让我们开始吧。
### 保持你的 Linux 系统更新
事实上，当你通过 WSL 运行 Ubuntu 或 openSUSE 时，其底层并没有运行 Linux 内核。然而，你必须保持你的发行版完整更新，以保护你的系统免受任何新的已知漏洞的影响。由于在 Windows 应用商店中只有两个免费的社区发行版，所以教程将只覆盖以下两个：openSUSE 和 Ubuntu。
更新你的 Ubuntu 系统：
```
# sudo apt-get update
# sudo apt-get dist-upgrade
```
运行 openSUSE 的更新：
```
# zypper up
```
您还可以使用 `dup` 命令将 openSUSE 升级到最新版本。但在运行系统升级之前，请使用上一个命令运行更新。
```
# zypper dup
```
**注意：** openSUSE 默认为 root 用户。如果你想执行任何非管理员任务，请切换到非特权用户。您可以这篇[文章](/article-9545-1.html)中了解如何在 openSUSE上 创建用户。
### 管理本地文件
如果你想使用优秀的 Linux 命令行工具来管理本地文件，你可以使用 WSL 轻松完成此操作。不幸的是，WSL 还不支持像 `lsblk` 或 `mount` 这样的东西来挂载本地驱动器。但是，你可以 `cd` 到 C 盘并管理文件：
```
/mnt/c/Users/swapnil/Music
```
我现在在 C 盘的 Music 目录下。
要安装其他驱动器、分区和外部 USB 驱动器，你需要创建一个挂载点，然后挂载该驱动器。
打开文件资源管理器并检查该驱动器的挂载点。假设它在 Windows 中被挂载为 S:\。
在 Ubuntu/openSUSE 终端中，为驱动器创建一个挂载点。
```
sudo mkdir /mnt/s
```
现在挂载驱动器：
```
mount -f drvfs S: /mnt/s
```
挂载完毕后，你现在可以从发行版访问该驱动器。请记住，使用 WSL 方式运行的发行版将会看到 Windows 能看到的内容。因此，你无法挂载在 Windows 上无法原生挂载的 ext4 驱动器。
现在你可以在这里使用所有这些神奇的 Linux 命令。想要将文件从一个文件夹复制或移动到另一个文件夹？只需运行 `cp` 或 `mv` 命令。
```
cp /source-folder/source-file.txt /destination-folder/
cp /music/classical/Beethoven/symphony-2.mp3 /plex-media/music/classical/
```
如果你想移动文件夹或大文件，我会推荐 `rsync` 而不是 `cp` 命令：
```
rsync -avzP /music/classical/Beethoven/symphonies/ /plex-media/music/classical/
```
耶！
想要在 Windows 驱动器中创建新目录，只需使用 `mkdir` 命令。
想要在某个时间设置一个 cron 作业来自动执行任务吗？继续使用 `crontab -e` 创建一个 cron 作业。十分简单。
你还可以在 Linux 中挂载网络/远程文件夹，以便你可以使用更好的工具管理它们。我的所有驱动器都插在树莓派或者服务器上，因此我只需 `ssh` 进入该机器并管理硬盘。在本地计算机和远程系统之间传输文件可以再次使用 `rsync` 命令完成。
WSL 现在已经不再是测试版了，它将继续获得更多新功能。我很兴奋的两个特性是 `lsblk` 命令和 `dd` 命令，它们允许我在 Windows 中本机管理我的驱动器并创建可引导的 Linux 驱动器。如果你是 Linux 命令行的新手，[前一篇教程](https://www.linux.com/learn/how-use-linux-command-line-basics-cli)将帮助你开始使用一些最基本的命令。
---
via: <https://www.linux.com/blog/learn/2018/2/how-use-wsl-linux-pro>
作者：[SWAPNIL BHARTIYA](https://www.linux.com/users/arnieswap) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何将字体添加到 Fedora
|
Paul W. Frields
|
https://fedoramagazine.org/add-fonts-fedora/
|
Fedora 使安装字体变得简单
|
/data/attachment/album/201804/22/010626bzeetgdlugbrdeo5.jpg.thumb.jpg
|
/data/attachment/album/201804/22/010626bzeetgdlugbrdeo5.jpg
| true | false | true |
geekpi
| false |
[
"字体"
] |
桌面应用
|
{
"viewnum": 6489,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Fedora 使安装字体变得简单
| 2018-04-22T01:06:23 | 2018-04-22T01:06:23 | 9,567 |
/article-9567-1.html
|
字体可帮助你通过设计以创意的方式表达你的想法。无论给图片加标题、编写演示文稿，还是设计问候语或广告，字体都可以将你的想法提升到更高水平。很容易仅仅为了它们的审美品质而爱上它们。幸运的是，Fedora 使安装字体变得简单。以下是如何做的。
### 全系统安装
如果你在系统范围内安装字体，那么它可以让所有用户使用。此方式的最佳方法是使用官方软件库中的 RPM 软件包。
开始前打开 Fedora Workstation 中的 “Software” 工具，或者其他使用官方仓库的工具。选择横栏中选择 “Add-ons” 类别。接着在该类别中选择 “Fonts”。你会看到类似于下面截图中的可用字体：
[](https://fedoramagazine.org/wp-content/uploads/2017/11/Software-fonts.png)
当你选择一种字体时，会出现一些细节。根据几种情况，你可能能够预览字体的一些示例文本。点击 “Install” 按钮将其添加到你的系统。根据系统速度和网络带宽，完成此过程可能需要一些时间。
你还可以在字体细节中通过 “Remove” 按钮删除前面带有勾的已经安装的字体。
### 个人安装
如果你以兼容格式：.ttf、 otf 、.ttc、.pfa 、.pfb 或者 .pcf 下载了字体，则此方法效果更好。这些字体扩展名不应通过将它们放入系统文件夹来安装在系统范围内。这种类型的非打包字体不能自动更新。它们也可能会在稍后干扰一些软件操作。安装这些字体的最佳方法是安装在你自己的个人数据目录中。
打开 Fedora Workstation 中的 “Files” 应用或你选择的类似文件管理器应用。如果你使用 “Files”，那么可能需要使用 `Ctrl+H` 组合键来显示隐藏的文件和文件夹。查找 `.fonts` 文件夹并将其打开。如果你没有 `.fonts` 文件夹，请创建它。 （记住最前面的点并全部使用小写。）
将已下载的字体文件复制到 `.fonts` 文件夹中。此时你可以关闭文件管理器。打开一个终端并输入以下命令：
```
fc-cache
```
这将重建字体缓存，帮助 Fedora 可以找到并引用它。你可能还需要重新启动需要使用新字体的应用程序，例如 Inkscape 或 LibreOffice。你重新启动后，新的字体应该就可以使用了。
---
照片由 [Raphael Schaller](https://unsplash.com/photos/GkinCd2enIY?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) 发布在 [Unsplash](https://unsplash.com/search/photos/fonts?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) 中。
---
作者简介:
Paul W. Frields 自 1997 年以来一直是 Linux 用户和爱好者，并于 2003 年 Fedora 发布不久后加入项目。他是 Fedora 项目委员会的创始成员之一，并从事文档、网站发布、倡导、工具链开发和维护软件工作。他于 2008 年 2 月至 2010 年 7 月在红帽担任 Fedora 项目负责人，现任红帽公司工程部经理。他目前和他的妻子和两个孩子一起住在弗吉尼亚州。
---
via: <https://fedoramagazine.org/add-fonts-fedora/>
作者：[Paul W. Frields](https://fedoramagazine.org/author/pfrields/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开发者的最佳 GNOME 扩展
|
Shaun Assam
|
https://fedoramagazine.org/awesome-gnome-extensions-developers/
|
Fedora Magazine 已经介绍了一些很棒的桌面扩展，例如 EasyScreenCast、 gTile 和 OpenWeather ，本文接下来会重点报道这些为开发者而改变的扩展。
|
/data/attachment/album/201804/22/224233k2111a91ad1p6w21.jpg.thumb.jpg
|
/data/attachment/album/201804/22/224233k2111a91ad1p6w21.jpg
| true | false | true |
hopefully2333
| false |
[
"开发",
"扩展",
"GNOME"
] |
分享
|
{
"viewnum": 9803,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Fedora Magazine 已经介绍了一些很棒的桌面扩展，例如 EasyScreenCast、 gTile 和 OpenWeather ，本文接下来会重点报道这些为开发者而改变的扩展。
| 2018-04-22T22:42:00 | 2018-04-22T22:42:00 | 9,568 |
/article-9568-1.html
|
扩展给予 GNOME3 桌面环境以非常大的灵活性，这种灵活性赋予了用户在定制化桌面上的优势，从而使他们的工作流程变得更加舒适和有效率。Fedora Magazine 已经介绍了一些很棒的桌面扩展，例如 [EasyScreenCast](https://fedoramagazine.org/screencast-gnome-extension/)、 [gTile](https://fedoramagazine.org/must-have-gnome-extension-gtile/) 和 [OpenWeather](https://fedoramagazine.org/weather-updates-openweather-gnome-shell-extension/) ，本文接下来会重点报道这些为开发者而改变的扩展。
如果你需要帮助来安装 GNOME 扩展，那么可以参考《[如何安装一个 GNOME Shell 扩展](/article-9447-1.html)》这篇文章。
### Docker 集成（Docker Integration）
对于为自己的应用使用 Docker 的开发者而言，这个 [Docker 集成](https://extensions.gnome.org/extension/1065/docker-status/) 扩展是必不可少的。这个状态菜单提供了一个带着启动、停止、暂停、甚至删除它们的选项的 Docker 容器列表，这个列表会在新容器加入到这个系统时自动更新。
在安装完这个扩展后，Fedora 用户可能会收到这么一条消息：“Error occurred when fetching containers.（获取容器时发生错误）”。这是因为 Docker 命令默认需要 `sudo` 或 root 权限。要设置你的用户权限来运行 Docker，可以参考 [Fedora 开发者门户网站上的 Docker 安装这一页](https://developer.fedoraproject.org/tools/docker/docker-installation.html)。
你可以在该[扩展的站点](https://github.com/gpouilloux/gnome-shell-extension-docker)上找到更多的信息。
### Jenkins CI 服务器指示器（Jenkins CI Server Indicator）
[Jenkins CI 服务器指示器](https://extensions.gnome.org/extension/399/jenkins-ci-server-indicator/)这个扩展可以使开发者在 Jenkins CI 服务器建立应用很简单，它展示了一个菜单，包含有任务列表及那些任务的状态。它也包括了一些如轻松访问 Jenkins 网页前端、任务完成提示、以及触发和过滤任务等特性。
如果想要更多的信息，请去浏览[开发者站点](https://www.philipphoffmann.de/gnome-3-shell-extension-jenkins-ci-server-indicator/)。
### 安卓工具（android-tool）
[安卓工具](https://extensions.gnome.org/extension/1232/android-tool/)对于 Android 开发者来说会是一个非常有价值的扩展，它的特性包括捕获错误报告、设备截屏和屏幕录像。它可以通过 usb 和 tcp 连接两种方式来连接 Android 设备。
这个扩展需要 `adb` 的包，从 Fedora 官方仓库安装 `adb` 只需要[运行这条命令](https://fedoramagazine.org/howto-use-sudo/)：
```
sudo dnf install android-tools
```
你可以在这个[扩展的 GitHub 网页](https://github.com/naman14/gnome-android-tool)里找到更多信息。
### GnomeHub
对于自己的项目使用 GitHub 的 GNOME 用户来说，[GnomeHub](https://extensions.gnome.org/extension/1263/gnomehub/) 是一个非常好的扩展，它可以显示 GitHub 上的仓库，还可以通知用户有新提交的拉取请求。除此之外，用户可以把他们最喜欢的仓库加在这个扩展的设置里。
如果想要更多信息，可以参考一下这个[项目的 GitHub 页面](https://github.com/lagartoflojo/gnomehub)。
### gistnotes
简单地说，[gistnotes](https://extensions.gnome.org/extension/917/gistnotes/) 为 gist 用户提供了一种创建、存储和管理注释和代码片段的简单方式。如果想要更多的信息，可以参考这个[项目的网站](https://github.com/mohan43u/gistnotes)。
### Arduino 控制器（Arduino Control）
这个 [Arduino 控制器](https://extensions.gnome.org/extension/894/arduino-control/)扩展允许用户去连接或者控制他们自己的 Arduino 电路板，它同样允许用户在状态菜单里增加滑块或者开关。除此之外，开发者放在扩展目录里的脚本可以通过以太网或者 usb 来连接 Arduino 电路板。
最重要的是，这个扩展可以被定制化来适合你的项目，在器 README 文件里的提供例子是，它能够“通过网络上任意的电脑来控制你房间里的灯”。
你可以从这个[项目的 GitHub 页面](https://github.com/simonthechipmunk/arduinocontrol)上得到更多的产品信息并安装这个扩展。
### Hotel Manager
使用 Hotel 进程管理器开发网站的开发人员，应该尝试一下 [Hotel Manager](https://extensions.gnome.org/extension/1285/hotel-manager/) 这个扩展。它展示了一个增加到 Hotel 里的网页应用的列表，并给与了用户开始、停止和重启这些应用的能力。此外，还可以通过右边的电脑图标快速打开、浏览这些网页应用。这个扩展同样可以启动、停止或重启 Hotel 的后台程序。
本文发布时，GNOME 3.26 版本的 Hotel Manager 版本 4 没有在该扩展的下拉式菜单里列出网页应用。版本 4 还会在 Fedora 28 (GNOME 3.28) 上安装时报错。然而，版本 3 工作在 Fedora 27 和 Fedora 28。
如果想要更多细节，可以去看这个[项目在 GitHub 上的网页](https://github.com/hardpixel/hotel-manager)。
### VSCode 搜索插件（VSCode Search Provider）
[VSCode 搜索插件](https://extensions.gnome.org/extension/1207/vscode-search-provider/)是一个简单的扩展，它能够在 GNOME 综合搜索结果里展示 Visual Studio Code 项目。对于重度 VSCode 用户来说，这个扩展可以让用户快速连接到他们的项目，从而节省时间。你可以从这个[项目在 GitHub 上的页面](https://github.com/jomik/vscode-search-provider)来得到更多的信息。
在开发环境方面，你有没有一个最喜欢的扩展呢？发在评论区里，一起来讨论下吧。
---
via: <https://fedoramagazine.org/awesome-gnome-extensions-developers/>
作者：[Shaun Assam](https://fedoramagazine.org/author/sassam/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[hopefully2333](https://github.com/hopefully2333) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
对进程的监视
|
Andrew
|
https://etbe.coker.com.au/2017/09/28/process-monitoring/
|
对于进程监视我有一些思路。如果你对进程监视如何做的更好有任何建议，请通过评论区告诉我。
|
/data/attachment/album/201804/23/124133aokrocrc5y1fz5co.jpg.thumb.jpg
|
/data/attachment/album/201804/23/124133aokrocrc5y1fz5co.jpg
| true | false | true |
qhwdw
| false |
[
"进程",
"监视"
] |
技术
|
{
"viewnum": 5123,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
对于进程监视我有一些思路。如果你对进程监视如何做的更好有任何建议，请通过评论区告诉我。
| 2018-04-23T12:41:48 | 2018-04-23T12:41:48 | 9,569 |
/article-9569-1.html
|
由于复刻了 mon 项目到 [etbemon](https://doc.coker.com.au/projects/etbe-mon/) 中，我花了一些时间做监视脚本。事实上监视一些事情通常很容易，但是决定监视什么才是困难的部分。进程监视脚本 `ps.monitor` 是我重新设计过的一个。
对于进程监视我有一些思路。如果你对进程监视如何做的更好有任何建议，请通过评论区告诉我。
给不使用 mon 的人介绍一下，如果一切 OK 该监视脚本就返回 0，而如果有问题它会返回 1，并使用标准输出显示错误信息。虽然我并不知道有谁将 mon 脚本挂进一个不同的监视系统中，但是，那样做其实很容易实现。我计划去做的一件事情就是，将来实现 mon 和其它的监视系统如 Nagios 之间的互操作性。
### 基本监视
```
ps.monitor tor:1-1 master:1-2 auditd:1-1 cron:1-5 rsyslogd:1-1 dbus-daemon:1- sshd:1- watchdog:1-2
```
我现在计划重写该进程监视脚本的某些部分。现在的功能是在命令行上列出进程名字，它包含了要监视的进程的最小和最大实例数量。上面的示例是一个监视的配置。在这里有一些限制，在这个实例中的 `master` 进程指的是 Postfix 的主进程，但是其它的守护进程使用了相同的进程名（这是那些错误的名字之一，因为它太直白了）。一个显而易见的解决方案是，给一个指定完整路径的选项，这样，那个 `/usr/lib/postfix/sbin/master` 就可以与其它命名为 `master` 的程序区分开了。
下一个问题是那些可能以多个用户身份运行的进程。比如 `sshd`，它有一个以 root 身份运行的单独的进程去接受新的连接请求，以及在每个登入用户的 UID 下运行的进程。因此，作为 root 用户运行的 sshd 进程的数量将比 root 登录会话的数量大 1。这意味着如果一个系统管理员直接以 root 身份通过 `ssh` 登入系统（这是有争议的，但它不是本文的主题—— 只是有些人需要这样做，所以我们必须支持这种情形），然后 master 进程崩溃了（或者系统管理员意外或者故意杀死了它），这时对于该进程丢失并不会产生警报。当然正确的做法是监视 22 号端口，查找字符串 `SSH-2.0-OpenSSH_`。有时候，守护进程的多个实例运行在需要单独监视的不同 UID 下面。因此，我们需要通过 UID 监视进程的能力。
在许多情形中，进程监视可以被替换为对服务端口的监视。因此，如果在 25 号端口上监视，那么有可能意味着，Postfix 的 `master` 在运行着，不用去理会其它的 `master` 进程。但是对于我而言，我可以在方便地进行多个监视，如果我得到一个关于无法向一个服务器发送邮件的 Jabber 消息，我可以通过这个来自服务器的 Jabber 消息断定 `master` 没有运行，而不需要挨个查找才能发现问题所在。
### SE Linux
我想要的一个功能就是，监视进程的 SE Linux 上下文，就像监视 UID 一样。虽然我对为其它安全系统编写一个测试不感兴趣，但是，我很乐意将别人写好的代码包含进去。因此，不管我做什么，都希望它能与多个安全系统一起灵活地工作。
### 短暂进程
大多数守护进程在进程启动期间都有一个相同名字的<ruby> 次级进程 <rt> second process </rt></ruby>。这意味着如果你为了精确地监视一个进程的一个实例，当 `logrotate` 或者类似的守护进程重启时，你或许会收到一个警报说有两个进程运行。如果在重启期间，恰好在一个错误的时间进行检查，你也或许会收到一个警报说，有 0 个实例。我现在处理这种情况的方法是，在与 `alertafter 2` 指令一起的次级进程失败事件之前我的服务器不发出警报。当监视处于一个失败的状态时，`failure_interval` 指令允许指定检查的时间间隔，将其设置为一个较低值时，意味着在等待一个次级进程失败结果时并不会使提示延迟太多。
为处理这种情况，我考虑让 `ps.monitor` 脚本在一个指定的延迟后再次进行自动检查。我认为使用一个单个参数的监视脚本来解决这个问题比起使用两个配置指令的 mon 要好一些。
### CPU 使用
mon 现在有一个 `loadavg.monitor` 脚本，它用于检查平均负载。但是它并不能捕获一个单个进程使用了太多的 CPU 时间而没有使系统平均负载上升的情况。同样，也没有捕获一个渴望获得 CPU 的进程进入沉默（例如，SETI at Home 停止运行）（LCTT 译注：SETI，由加州大学伯克利分校创建的一项利用全球的联网计算机的空闲计算资源来搜寻地外文明的科学实验计划），而其它的进程进入一个无限循环状态的情况。解决这种问题的一个方法是，让 `ps.monitor` 脚本也配置另外的一个选项去监视 CPU 的使用，但是这也可能会让人产生迷惑。另外的选择是，使用一个独立的脚本，它用来报警任何在它的生命周期或者最后几秒中，使用 CPU 时间超过指定百分比的进程，除非它在一个豁免这种检查的进程或用户的白名单中。或者每个普通用户都应该豁免这种检查，因为你压根就不知道他们什么时候运行一个文件压缩程序。也应该有一个包含排除的守护进程（像 BOINC）和系统进程（像 gzip，有几个定时任务会运行它）的简短列表。
### 对例外的监视
一个常见的编程错误是在 `setgid()` 之前调用 `setuid()`，这意味着那个程序没有权限去调用 `setgid()`。如果没有检查返回代码（而犯这种低级错误的人往往不会去检查返回代码），那么进程会保持较高的权限。检查以 GID 0 而不是 UID 0 运行的进程是很方便的。顺利说一下，对一个 Debian/Testing 工作站运行的一个快速检查显示，一个使用 GID 0 的进程并没有获得较高的权限，但是可以使用一个 `chmod 770` 命令去改变它。
在一个 SE Linux 系统上，应该只有一个进程与 `init_t` 域一起运行。目前在运行守护进程（比如，mysqld 和 tor）的 Debian Stretch 系统中，并不会发生策略与守护进程服务文件所请求的 systemd 的最新功能不匹配的情况。这样的问题将会不断发生，我们需要对它进行自动化测试。
对配置错误的自动测试可能会影响系统安全，这是一个很大的问题，我将来或许写一篇关于这方面的单独的博客文章。
---
via: <https://etbe.coker.com.au/2017/09/28/process-monitoring/>
作者：[Andrew](https://etbe.coker.com.au) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Ubuntu 17.10 上安装 AWFFull Web 服务器日志分析应用程序
|
Ruchi
|
http://www.ubuntugeek.com/install-awffull-web-server-log-analysis-application-on-ubuntu-17-10.html
|
AWFFull 是基于 “Webalizer” 的 Web 服务器日志分析程序。AWFFull 以 HTML 格式生成使用统计信息以便用浏览器查看。结果以柱状和图形两种格式显示，这有利于解释数据。
|
/data/attachment/album/201804/23/125729f4mx8b49m98b094b.png.thumb.jpg
|
/data/attachment/album/201804/23/125729f4mx8b49m98b094b.png
| true | false | true |
geekpi
| false |
[
"AWFFull",
"日志"
] |
系统运维
|
{
"viewnum": 7460,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
AWFFull 是基于 “Webalizer” 的 Web 服务器日志分析程序。AWFFull 以 HTML 格式生成使用统计信息以便用浏览器查看。结果以柱状和图形两种格式显示，这有利于解释数据。
| 2018-04-23T12:57:28 | 2018-04-23T12:57:28 | 9,570 |
/article-9570-1.html
|
AWFFull 是基于 “Webalizer” 的 Web 服务器日志分析程序。AWFFull 以 HTML 格式生成使用统计信息以便用浏览器查看。结果以柱状和图形两种格式显示，这有利于解释数据。它提供每年、每月、每日和每小时的使用统计数据，并显示网站、URL、referrer、user agent（浏览器）、用户名、搜索字符串、进入/退出页面和国家（如果一些信息不存在于处理后日志中那么就没有）。AWFFull 支持 CLF（通用日志格式）日志文件，以及由 NCSA 等定义的组合日志格式，它还能只能地处理这些格式的变体。另外，AWFFull 还支持 wu-ftpd xferlog 格式的日志文件，它能够分析 ftp 服务器和 squid 代理日志。日志也可以通过 gzip 压缩。
如果检测到压缩日志文件，它将在读取时自动解压缩。压缩日志必须是 .gz 扩展名的标准 gzip 压缩。
### 对于 Webalizer 的修改
AWFFull 基于 Webalizer 的代码，并有许多或大或小的变化。包括：
* 不止原始统计数据：利用已发布的公式，提供额外的网站使用情况。
* GeoIP IP 地址能更准确地检测国家。
* 可缩放的图形
* 与 GNU gettext 集成，能够轻松翻译。目前支持 32 种语言。
* 在首页显示超过 12 个月的网站历史记录。
* 额外的页面计数跟踪和排序。
* 一些小的可视化调整，包括 Geolizer 用量中使用 Kb、Mb。
* 额外的用于 URL 计数、进入和退出页面、站点的饼图
* 图形上的水平线更有意义，更易于阅读。
* User Agent 和 Referral 跟踪现在通过 PAGES 而非 HITS 进行计算。
* 现在支持 GNU 风格的长命令行选项（例如 --help）。
* 可以通过排除“什么不是”以及原始的“什么是”来选择页面。
* 对被分析站点的请求以匹配的引用 URL 显示。
* 404 错误表，并且可以生成引用 URL。
* 生成的 html 可以使用外部 CSS 文件。
* POST 分析总结使得手动优化配置文件性能更简单。
* 可以将指定的 IP 和地址分配给指定的国家。
* 便于使用其他工具详细分析的转储选项。
* 支持检测并处理 Lotus Domin- v6 日志。
### 在 Ubuntu 17.10 上安装 AWFFull
```
sud- apt-get install awffull
```
### 配置 AWFFull
你必须在 `/etc/awffull/awffull.conf` 中编辑 AWFFull 配置文件。如果你在同一台计算机上运行多个虚拟站点，则可以制作多个默认配置文件的副本。
```
sud- vi /etc/awffull/awffull.conf
```
确保有下面这几行：
```
LogFile /var/log/apache2/access.log.1
OutputDir /var/www/html/awffull
```
保存并退出文件。
你可以使用以下命令运行 awffull。
```
awffull -c [your config file name]
```
这将在 `/var/www/html/awffull` 目录下创建所有必需的文件，以便你可以使用 http://serverip/awffull/ 。
你应该看到类似于下面的页面：
如果你有更多站点，你可以使用 shell 和计划任务自动化这个过程。
---
via: <http://www.ubuntugeek.com/install-awffull-web-server-log-analysis-application-on-ubuntu-17-10.html>
作者：[ruchi](http://www.ubuntugeek.com/author/ubuntufix) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何设置 GNOME 显示自定义幻灯片
|
Ken Vandine
|
https://opensource.com/article/17/12/create-your-own-wallpaper-slideshow-gnome
|
使用一个简单的 XML，你就可以设置 GNOME 能够在桌面上显示一个幻灯片。
|
/data/attachment/album/201804/23/185426i2wml624wwnsowd3.jpg.thumb.jpg
|
/data/attachment/album/201804/23/185426i2wml624wwnsowd3.jpg
| true | false | true |
Auk7F7
| false |
[
"墙纸",
"GNOME"
] |
桌面应用
|
{
"viewnum": 5078,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用一个简单的 XML，你就可以设置 GNOME 能够在桌面上显示一个幻灯片。
| 2018-04-23T18:53:00 | 2018-04-23T18:53:00 | 9,571 |
/article-9571-1.html
|
>
> 使用一个简单的 XML，你就可以设置 GNOME 能够在桌面上显示一个幻灯片。
>
>
>
在 GNOME 中，一个非常酷、但却鲜为人知的特性是它能够将幻灯片显示为墙纸。你可以从 [GNOME 控制中心](http://manpages.ubuntu.com/manpages/xenial/man1/gnome-control-center.1.html)的 “背景设置” 面板中选择墙纸幻灯片。在预览的右下角显示一个小时钟标志，可以将幻灯片的墙纸与静态墙纸区别开来。
一些发行版带有预装的幻灯片壁纸。 例如，Ubuntu 包含了库存的 GNOME 定时壁纸幻灯片，以及 Ubuntu 壁纸大赛胜出的墙纸。
如果你想创建自己的自定义幻灯片用作壁纸怎么办？虽然 GNOME 没有为此提供一个用户界面，但是在你的主目录中使用一些简单的 XML 文件来创建一个是非常容易的。 幸运的是，GNOME 控制中心的背景选择支持一些常见的目录路径，这样就可以轻松创建幻灯片，而不必编辑你的发行版所提供的任何内容。
### 开始
使用你最喜欢的文本编辑器在 `$HOME/.local/share/gnome-background-properties/` 创建一个 XML 文件。 虽然文件名不重要，但目录名称很重要（你可能需要创建该目录）。 举个例子，我创建了带有以下内容的 `/home/ken/.local/share/gnome-background-properties/osdc-wallpapers.xml`：
```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE wallpapers SYSTEM "gnome-wp-list.dtd">
<wallpapers>
<wallpaper deleted="false">
<name>Opensource.com Wallpapers</name>
<filename>/home/ken/Pictures/Wallpapers/osdc/osdc.xml</filename>
<options>zoom</options>
</wallpaper>
</wallpapers>
```
每一个你需要包含在 GNOME 控制中心的 “背景面板”中的每个幻灯片或静态壁纸，你都要在上面的 XML 文件需要为其增加一个 `<wallpaper>` 节点。
在这个例子中，我的 `osdc.xml` 文件看起来是这样的：
```
<?xml version="1.0" ?>
<background>
<static>
<!-- Duration in seconds to display the background -->
<duration>30.0</duration>
<file>/home/ken/Pictures/Wallpapers/osdc/osdc_2.png</file>
</static>
<transition>
<!-- Duration of the transition in seconds, default is 2 seconds -->
<duration>0.5</duration>
<from>/home/ken/Pictures/Wallpapers/osdc/osdc_2.png</from>
<to>/home/ken/Pictures/Wallpapers/osdc/osdc_1.png</to>
</transition>
<static>
<duration>30.0</duration>
<file>/home/ken/Pictures/Wallpapers/osdc/osdc_1.png</file>
</static>
<transition>
<duration>0.5</duration>
<from>/home/ken/Pictures/Wallpapers/osdc/osdc_1.png</from>
<to>/home/ken/Pictures/Wallpapers/osdc/osdc_2.png</to>
</transition>
</background>
```
上面的 XML 中有几个重要的部分。 XML 中的 `<background>` 节点是你的外部节点。 每个背景都支持多个 `<static>` 和 `<transition>` 节点。
`<static>` 节点定义用 `<file>` 节点要显示的图像以及用 `<duration>` 显示它的持续时间。
`<transition>` 节点定义 `<duration>`（变换时长），`<from>` 和 `<to>` 定义了起止的图像。
### 全天更换壁纸
另一个很酷的 GNOME 功能是基于时间的幻灯片。 你可以定义幻灯片的开始时间，GNOME 将根据它计算时间。 这对于根据一天中的时间设置不同的壁纸很有用。 例如，你可以将开始时间设置为 06:00，并在 12:00 之前显示一张墙纸，然后在下午和 18:00 再次更改。
这是通过在 XML 中定义 `<starttime>` 来完成的，如下所示：
```
<starttime>
<!-- A start time in the past is fine -->
<year>2017</year>
<month>11</month>
<day>21</day>
<hour>6</hour>
<minute>00</minute>
<second>00</second>
</starttime>
```
上述 XML 文件定义于 2017 年 11 月 21 日 06:00 开始动画，时长为 21,600.00，相当于六个小时。 这段时间将显示你的早晨壁纸直到 12:00，12:00 时它会更改为你的下一张壁纸。 你可以继续以这种方式每隔一段时间更换一次壁纸，但确保所有持续时间的总计为 86,400 秒（等于 24 小时）。
GNOME 将计算开始时间和当前时间之间的增量，并显示当前时间的正确墙纸。 例如，如果你在 16:00 选择新壁纸，则GNOME 将在 06:00 开始时间之后显示 36,000 秒的适当壁纸。
有关完整示例，请参阅大多数发行版中由 gnome-backgrounds 包提供的 adwaita-timed 幻灯片。 它通常位于 `/usr/share/backgrounds/gnome/adwaita-timed.xml` 中。
### 了解更多信息
希望这可以鼓励你深入了解创建自己的幻灯片壁纸。 如果你想下载本文中引用的文件的完整版本，那么你可以在 [GitHub](https://github.com/kenvandine/misc/tree/master/articles/osdc/gnome/slide-show-backgrounds/osdc) 上找到它们。
如果你对用于生成 XML 文件的实用程序脚本感兴趣，你可以在互联网上搜索 `gnome-backearth-generator`。
---
via: <https://opensource.com/article/17/12/create-your-own-wallpaper-slideshow-gnome>
作者：[Ken Vandine](https://opensource.com/users/kenvandine) 译者：[Auk7F7](https://github.com/Auk7F7) 校对： [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
给初学者的 fc 示例教程
|
Sk
|
https://www.ostechnix.com/the-fc-command-tutorial-with-examples-for-beginners/
|
fc 是个 shell 内置命令，用于在交互式 shell 里列出、编辑和执行最近输入的命令。
|
/data/attachment/album/201804/23/191012b1p8d6p8h6hhfq6b.png.thumb.jpg
|
/data/attachment/album/201804/23/191012b1p8d6p8h6hhfq6b.png
| true | false | true |
Dotcra
| false |
[
"fc",
"命令行",
"历史",
"history"
] |
技术
|
{
"viewnum": 7521,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
fc 是个 shell 内置命令，用于在交互式 shell 里列出、编辑和执行最近输入的命令。
| 2018-04-23T19:10:08 | 2018-04-23T19:10:08 | 9,572 |
/article-9572-1.html
|
`fc` （**F**ix **C**ommands 的缩写）是个 shell 内置命令，用于在交互式 shell 里列出、编辑和执行最近输入的命令。你可以用你喜欢的编辑器编辑最近的命令并再次执行，而不用把它们整个重新输入一遍。除了可以避免重复输入又长又复杂的命令，它对修正拼写错误来说也很有用。因为是 shell 内置命令，大多 shell 都包含它，比如 Bash 、 Zsh 、 Ksh 等。在这篇短文中，我们来学一学在 Linux 中使用 `fc` 命令。
### fc 命令教程及示例
#### 列出最近执行的命令
执行不带其它参数的 `fc -l` 命令，它会列出最近 16 个命令。
```
$ fc -l
507 fish
508 fc -l
509 sudo netctl restart wlp9s0sktab
510 ls -l
511 pwd
512 uname -r
513 uname -a
514 touch ostechnix.txt
515 vi ostechnix.txt
516 echo "Welcome to OSTechNix"
517 sudo apcman -Syu
518 sudo pacman -Syu
519 more ostechnix.txt
520 wc -l ostechnix.txt
521 cat ostechnix.txt
522 clear
```
`-r` 选项用于将输出反向排序。
```
$ fc -lr
```
`-n` 选项用于隐藏行号。
```
$ fc -ln
nano ~/.profile
source ~/.profile
source ~/.profile
fc -ln
fc -l
sudo netctl restart wlp9s0sktab
ls -l
pwd
uname -r
uname -a
echo "Welcome to OSTechNix"
sudo apcman -Syu
cat ostechnix.txt
wc -l ostechnix.txt
more ostechnix.txt
clear
```
这样行号就不再显示了。
如果想以某个命令开始，只需在 `-l` 选项后面加上行号即可。比如，要显示行号 520 至最近的命令，可以这样：
```
$ fc -l 520
520 ls -l
521 pwd
522 uname -r
523 uname -a
524 echo "Welcome to OSTechNix"
525 sudo apcman -Syu
526 cat ostechnix.txt
527 wc -l ostechnix.txt
528 more ostechnix.txt
529 clear
530 fc -ln
531 fc -l
```
要列出一段范围内的命令，将始、末行号作为 `fc -l` 的参数即可，比如 520 至 525：
```
$ fc -l 520 525
520 ls -l
521 pwd
522 uname -r
523 uname -a
524 echo "Welcome to OSTechNix"
525 sudo apcman -Syu
```
除了使用行号，我们还可以使用字符。比如，要列出最近一个 `pwd` 至最近一个命令之间的所有命令，只需要像下面这样使用起始字母即可：
```
$ fc -l p
521 pwd
522 uname -r
523 uname -a
524 echo "Welcome to OSTechNix"
525 sudo apcman -Syu
526 cat ostechnix.txt
527 wc -l ostechnix.txt
528 more ostechnix.txt
529 clear
530 fc -ln
531 fc -l
532 fc -l 520
533 fc -l 520 525
534 fc -l 520
535 fc -l 522
536 fc -l l
```
要列出所有 `pwd` 和 `more` 之间的命令，你可以都使用起始字母，像这样：
```
$ fc -l p m
```
或者，使用开始命令的首字母以及结束命令的行号：
```
$ fc -l p 528
```
或者都使用行号：
```
$ fc -l 521 528
```
这三个命令都显示一样的结果。
#### 编辑并执行上一个命令
我们经常敲错命令，这时你可以用默认编辑器修正拼写错误并执行而不用将命令重新再敲一遍。
编辑并执行上一个命令：
```
$ fc
```
这会在默认编辑器里载入上一个命令。
你可以看到，我上一个命令是 `fc -l`。你可以随意修改，它会在你保存退出编辑器时自动执行。这在命令或参数又长又复杂时很有用。需要注意的是，它同时也可能是**毁灭性**的。比如，如果你的上一个命令是危险的 `rm -fr <some-path>`，当它自动执行时你可能丢掉你的重要数据。所以，小心谨慎对待每一个命令。
#### 更改默认编辑器
另一个有用的选项是 `-e` ，它可以用来为 `fc` 命令选择不同的编辑器。比如，如果我们想用 `nano` 来编辑上一个命令:
```
$ fc -e nano
```
这个命令会打开 `nano` 编辑器（而不是默认编辑器）编辑上一个命令。
如果你觉得用 `-e` 选项太麻烦，你可以修改你的默认编辑器，只需要将环境变量 `FCEDIT` 设为你想要让 `fc` 使用的编辑器名称即可。
比如，要把 `nano` 设为默认编辑器，编辑你的 `~/.profile` 或其他初始化文件： （LCTT 译注：如果 `~/.profile` 不存在可自己创建；如果使用的是 bash ，可以编辑 `~/.bash_profile` ）
```
$ vi ~/.profile
```
添加下面一行：
```
FCEDIT=nano
# LCTT译注：如果在子 shell 中会用到 fc ，最好在这里 export FCEDIT
```
你也可以使用编辑器的完整路径：
```
FCEDIT=/usr/local/bin/emacs
```
输入 `:wq` 保存退出。要使改动立即生效，运行以下命令：
```
$ source ~/.profile
```
现在再输入 `fc` 就可以使用 `nano` 编辑器来编辑上一个命令了。
#### 不编辑而直接执行上一个命令
我们现在知道 `fc` 命令不带任何参数的话会将上一个命令载入编辑器。但有时你可能不想编辑，仅仅是想再次执行上一个命令。这很简单，在末尾加上连字符（`-`）就可以了：
```
$ echo "Welcome to OSTechNix"
Welcome to OSTechNix
$ fc -e -
echo "Welcome to OSTechNix"
Welcome to OSTechNix
```
如你所见，`fc` 带了 `-e` 选项，但并没有编辑上一个命令（例中的 `echo " Welcome to OSTechNix"`）。
需要注意的是，有些选项仅对指定 shell 有效。比如下面这些选项可以用在 zsh 中，但在 Bash 或 Ksh 中则不能用。
#### 显示命令的执行时间
想要知道命令是在什么时候执行的，可以用 `-d` 选项：
```
fc -ld
1 18:41 exit
2 18:41 clear
3 18:42 fc -l
4 18:42 sudo netctl restart wlp9s0sktab
5 18:42 ls -l
6 18:42 pwd
7 18:42 uname -r
8 18:43 uname -a
9 18:43 cat ostechnix.txt
10 18:43 echo "Welcome to OSTechNix"
11 18:43 more ostechnix.txt
12 18:43 wc -l ostechnix.txt
13 18:43 cat ostechnix.txt
14 18:43 clear
15 18:43 fc -l
```
这样你就可以查看最近命令的具体执行时间了。
使用选项 `-f` ，可以为每个命令显示完整的时间戳。
```
fc -lf
1 4/5/2018 18:41 exit
2 4/5/2018 18:41 clear
3 4/5/2018 18:42 fc -l
4 4/5/2018 18:42 sudo netctl restart wlp9s0sktab
5 4/5/2018 18:42 ls -l
6 4/5/2018 18:42 pwd
7 4/5/2018 18:42 uname -r
8 4/5/2018 18:43 uname -a
9 4/5/2018 18:43 cat ostechnix.txt
10 4/5/2018 18:43 echo "Welcome to OSTechNix"
11 4/5/2018 18:43 more ostechnix.txt
12 4/5/2018 18:43 wc -l ostechnix.txt
13 4/5/2018 18:43 cat ostechnix.txt
14 4/5/2018 18:43 clear
15 4/5/2018 18:43 fc -l
16 4/5/2018 18:43 fc -ld
```
当然，欧洲的老乡们还可以使用 `-E` 选项来显示欧洲时间格式。
```
fc -lE
2 5.4.2018 18:41 clear
3 5.4.2018 18:42 fc -l
4 5.4.2018 18:42 sudo netctl restart wlp9s0sktab
5 5.4.2018 18:42 ls -l
6 5.4.2018 18:42 pwd
7 5.4.2018 18:42 uname -r
8 5.4.2018 18:43 uname -a
9 5.4.2018 18:43 cat ostechnix.txt
10 5.4.2018 18:43 echo "Welcome to OSTechNix"
11 5.4.2018 18:43 more ostechnix.txt
12 5.4.2018 18:43 wc -l ostechnix.txt
13 5.4.2018 18:43 cat ostechnix.txt
14 5.4.2018 18:43 clear
15 5.4.2018 18:43 fc -l
16 5.4.2018 18:43 fc -ld
17 5.4.2018 18:49 fc -lf
```
### fc 用法总结
* 当不带任何参数时，`fc` 将上一个命令载入默认编辑器。
* 当带一个数字作为参数时，`fc` 将数字指定的命令载入默认编辑器。
* 当带一个字符作为参数时，`fc` 将最近一个以指定字符开头的命令载入默认编辑器。
* 当有两个参数时，它们分别指定需要列出的命令范围的开始和结束。
更多细节，请参考 man 手册。
```
$ man fc
```
好了，今天就这些。希望这篇文章能帮助到你。更多精彩内容，敬请期待！
---
via: <https://www.ostechnix.com/the-fc-command-tutorial-with-examples-for-beginners/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Dotcra](https://github.com/Dotcra) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Let's Encrypt 保护你的网站
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2018/3/protect-your-websites-lets-encrypt
|
未加密的 HTTP 会话暴露于滥用之中，用 Let's Encrypt 把它们保护起来。
|
/data/attachment/album/201804/23/211532baza1a15yozo60o5.jpg.thumb.jpg
|
/data/attachment/album/201804/23/211532baza1a15yozo60o5.jpg
| true | false | true |
pinewall
| false |
[
"HTTPS"
] |
技术
|
{
"viewnum": 4929,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
未加密的 HTTP 会话暴露于滥用之中，用 Let's Encrypt 把它们保护起来。
| 2018-04-23T21:15:00 | 2018-04-23T21:15:00 | 9,573 |
/article-9573-1.html
|
>
> 未加密的 HTTP 会话暴露于滥用之中，用 Let's Encrypt 把它们保护起来。
>
>
>
曾几何时，通过证书授权机构搭建基本的 HTTPS 网站需要每年花费数百美元，而且搭建的过程复杂且容易出错。现在我们免费使用 [Let's Encrypt](https://letsencrypt.org)，而且搭建过程也只需要几分钟。
### 为何进行加密？
为什么要加密网站呢？这是因为未经加密的 HTTP 会话可以被多种方式滥用：
* 窃听用户数据包
* 捕捉用户登录
* 注入[广告](https://www.thesslstore.com/blog/third-party-content-injection/)和[“重要”消息](https://blog.ryankearney.com/2013/01/comcast-caught-intercepting-and-altering-your-web-traffic/)
* 注入[木马](https://www.eff.org/deeplinks/2018/03/we-still-need-more-https-government-middleboxes-caught-injecting-spyware-ads-and)
* 注入 [SEO 垃圾邮件和链接](https://techglimpse.com/wordpress-injected-with-spam-security/)
* 注入[挖矿脚本](https://thehackernews.com/2018/03/cryptocurrency-spyware-malware.html)
网络服务提供商就是最大的代码注入者。那么如何挫败它们的非法行径呢？你最好的防御手段就是 HTTPS。让我们回顾一下 HTTPS 的工作原理。
### 信任链
你可以在你的网站和每个授权访问用户之间建立非对称加密。这是一种非常强的保护：GPG（GNU Privacy Guard， 参考[如何在 Linux 中加密邮件](https://www.linux.com/learn/how-encrypt-email-linux))和 OpenSSH 就是非对称加密的通用工具。它们依赖于公钥-私钥对，其中公钥可以任意分享，但私钥必须受到保护且不能分享。公钥用于加密，私钥用于解密。
但上述方法无法适用于随机的网页浏览，因为建立会话之前需要交换公钥，你需要生成并管理密钥对。HTTPS 会话可以自动完成公钥分发，而且购物或银行之类的敏感网站还会使用第三方证书颁发机构（CA）验证证书，例如 Comodo、 Verisign 和 Thawte。
当你访问一个 HTTPS 网站时，网站给你的网页浏览器返回了一个数字证书。这个证书说明你的会话被强加密，而且提供了该网站信息，包括组织名称、颁发证书的组织和证书颁发机构名称等。你可以点击网页浏览器地址栏的小锁头来查看这些信息（图 1），也包括了证书本身。
*图1: 点击网页浏览器地址栏上的锁头标记查看信息*
包括 Opera、 Chromium 和 Chrome 在内的主流浏览器，验证网站数字证书的合法性都依赖于证书颁发机构。小锁头标记可以让你一眼看出证书状态；绿色意味着使用强 SSL 加密且运营实体经过验证。网页浏览器还会对恶意网站、SSL 证书配置有误的网站和不被信任的自签名证书网站给出警告。
那么网页浏览器如何判断网站是否可信呢？浏览器自带根证书库，包含了一系列根证书，存储在 `/usr/share/ca-certificates/mozilla/` 之类的地方。网站证书是否可信可以通过根证书库进行检查。就像你 Linux 系统上其它软件那样，根证书库也由包管理器维护。对于 Ubuntu，对应的包是 `ca-certificates`，这个 Linux 根证书库本身是[由 Mozilla 维护](https://www.mozilla.org/en-US/about/governance/policies/security-group/certs/policy/)的。
可见，整个工作流程需要复杂的基础设施才能完成。在你进行购物或金融等敏感在线操作时，你信任了无数陌生人对你的保护。
### 无处不加密
Let's Encrypt 是一家全球证书颁发机构，类似于其它商业根证书颁发机构。Let's Encrpt 由非营利性组织<ruby> 因特网安全研究小组 <rt> Internet Security Research Group </rt></ruby>（ISRG）创立，目标是简化网站的安全加密。在我看来，出于后面我会提到的原因，该证书不足以胜任购物及银行网站的安全加密，但很适合加密博客、新闻和信息门户这类不涉及金融操作的网站。
使用 Let's Encrypt 有三种方式。推荐使用<ruby> 电子前沿基金会 <rt> Electronic Frontier Foundation </rt></ruby>（EFF）开发的 [Cerbot 客户端](https://certbot.eff.org/)。使用该客户端需要在网站服务器上执行 shell 操作。
如果你使用的是共享托管主机，你很可能无法执行 shell 操作。这种情况下，最简单的方法是使用[支持 Let's Encrpt 的托管主机](https://community.letsencrypt.org/t/web-hosting-who-support-lets-encrypt/6920)。
如果你的托管主机不支持 Let's Encrypt，但支持自定义证书，那么你可以使用 Certbot [手动创建并上传你的证书](https://community.letsencrypt.org/t/web-hosting-who-support-lets-encrypt/6920)。这是一个复杂的过程，你需要彻底地研究文档。
安装证书后，使用 [SSL 服务器测试](https://www.ssllabs.com/ssltest/)来测试你的服务器。
Let's Encrypt 的电子证书有效期为 90 天。Certbot 安装过程中添加了一个证书自动续期的计划任务，也提供了测试证书自动续期是否成功的命令。允许使用已有的私钥或<ruby> 证书签名请求 <rt> certificate signing request </rt></ruby>（CSR），允许创建通配符证书。
### 限制
Let's Encrypt 有如下限制：它只执行域名验证，即只要有域名控制权就可以获得证书。这是比较基础的 SSL。它不支持<ruby> 组织验证 <rt> Organization Validation </rt></ruby>（OV）或<ruby> 扩展验证 <rt> Extended Validation </rt></ruby>（EV），因为运营实体验证无法自动完成。我不会信任使用 Let's Encrypt 证书的购物或银行网站，它们应该购买支持运营实体验证的完整版本。
作为非营利性组织提供的免费服务，不提供商业支持，只提供不错的文档和社区支持。
因特网中恶意无处不在，一切数据都应该加密。从使用 [Let's Encrypt](https://letsencrypt.org/) 保护你的网站用户开始吧。
想要学习更多 Linux 知识，请参考 Linux 基金会和 edX 提供的免费课程 [“Linux 入门”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/3/protect-your-websites-lets-encrypt>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一个基于 Arch 的独立 Linux 发行版 MagpieOS
|
John Paul
|
https://itsfoss.com/magpieos/
|
MagpieOS 非常简单。它基本上是 GNOME3 桌面环境的 Arch。 MagpieOS 还包括一个自定义的仓库，其中包含图标和主题（据称）在其他基于 Arch 的发行版或 AUR 上都没有。
|
/data/attachment/album/201804/24/174611iid7dld2yvbklv2i.jpg.thumb.jpg
|
/data/attachment/album/201804/24/174611iid7dld2yvbklv2i.jpg
| true | false | true |
geekpi
| false |
[
"发行版",
"MagpieOS",
"Arch"
] |
分享
|
{
"viewnum": 9324,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
MagpieOS 非常简单。它基本上是 GNOME3 桌面环境的 Arch。 MagpieOS 还包括一个自定义的仓库，其中包含图标和主题（据称）在其他基于 Arch 的发行版或 AUR 上都没有。
| 2018-04-24T17:46:00 | 2018-04-24T17:46:00 | 9,574 |
/article-9574-1.html
|
目前使用的大多数 Linux 发行版都是由欧美创建和开发的。一位来自孟加拉国的年轻开发人员想要改变这一切。
### 谁是 Rizwan？
[Rizwan](https://twitter.com/Linux_Saikat) 是来自孟加拉国的计算机科学专业的学生。他目前正在学习成为一名专业的 Python 程序员。他在 2015 年开始使用 Linux。使用 Linux 启发他创建了自己的 Linux 发行版。他还希望让世界其他地方知道孟加拉国正在升级到 Linux。
他还致力于创建 [LFS 的 live 版本](https://itsfoss.com/linux-from-scratch-live-cd/)。
### 什么是 MagpieOS？
Rizwan 的新发行版被命名为 MagpieOS。 [MagpieOS](http://www.magpieos.net) 非常简单。它基本上是 GNOME3 桌面环境的 Arch。 MagpieOS 还包括一个自定义的仓库，其中包含图标和主题（据称）在其他基于 Arch 的发行版或 AUR 上都没有。
下面是 MagpieOS 包含的软件列表：Firefox、LibreOffice、Uget、Bleachbit、Notepadqq、SUSE Studio Image Writer、Pamac 软件包管理器、Gparted、Gimp、Rhythmbox、简单屏幕录像机等包括 Totem 视频播放器在内的所有默认 GNOME 软件，以及一套新的定制壁纸。
目前，MagpieOS 仅支持 GNOME 桌面环境。Rizwan 选择它是因为这是他的最爱。但是，他计划在未来添加更多的桌面环境。
不幸的是，MagpieOS 不支持孟加拉语或任何其他当地语言。它支持 GNOME 的默认语言，如英语、印地语等。
Rizwan 命名他的发行为 MagpieOS，因为<ruby> <a href="https://en.wikipedia.org/wiki/Magpie"> 喜鹊 </a> <rt> magpie </rt></ruby> 是孟加拉国的官方鸟。
### 为什么选择 Arch？
和大多数人一样，Rizwan 通过使用 [Ubuntu](https://www.ubuntu.com) 开始了他的 Linux 旅程。一开始，他对此感到满意。但是，有时他想安装的软件在仓库中没有，他不得不通过 Google 寻找正确的 PPA。他决定切换到 [Arch](https://www.archlinux.org)，因为 Arch 有许多在 Ubuntu 上没有的软件包。Rizwan 也喜欢 Arch 是一个滚动版本，并且始终是最新的。
Arch 的问题在于它的安装非常复杂和耗时。所以，Rizwan 尝试了几个基于 Arch 的发行版，并且对任何一个都不满意。他不喜欢 [Manjaro](http://manjaro.org)，因为它们没有权限使用 Arch 的仓库。此外，Arch 仓库镜像比 Manjaro 更快并且拥有更多软件。他喜欢 [Antergos](https://antergos.com)，但要安装需要一个持续的互联网连接。如果在安装过程中连接失败，则必须重新开始。
由于这些问题，Rizwan 决定创建一个简单的发行版，让他和其他人无需麻烦地安装 Arch。他还希望通过使用他的发行版让他的祖国的开发人员从 Ubuntu 切换到 Arch。
### 如何通过 MagpieOS 帮助 Rizwan
如果你有兴趣帮助 Rizwan 开发 MagpieOS，你可以通过 [MagpieOS 网站](http://www.magpieos.net)与他联系。你也可以查看该项目的 [GitHub 页面](https://github.com/Rizwan-Hasan/MagpieOS)。Rizwan 表示，他目前不寻求财政支持。
### 最后的想法
我快速地安装过一次 MagpieOS。它使用 [Calamares 安装程序](https://calamares.io)，这意味着安装它相对快速轻松。重新启动后，我听到一封欢迎我来到 MagpieOS 的音频消息。
说实话，这是我第一次听到安装后的问候。（Windows 10 可能也有，但我不确定）屏幕底部还有一个 Mac OS 风格的应用程序停靠栏。除此之外，它感觉像我用过的其他任何 GNOME 3 桌面。
考虑到这是一个刚刚起步的独立项目，我不会推荐它作为你的主要操作系统。但是，如果你是一个发行版尝试者，你一定会试试看。
话虽如此，对于一个想把自己的国家放在技术地图上的学生来说，这是一个不错的尝试。做得很好，Rizwan。
你有没有听说过 MagpieOS？你最喜欢的地区或本地制作的 Linux 发行版是什么？请在下面的评论中告诉我们。
如果你发现这篇文章有趣，请花点时间在社交媒体上分享。
---
via: <https://itsfoss.com/magpieos/>
作者：[John Paul](https://itsfoss.com/author/john/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
3 个 Linux 命令行密码管理器
|
Scott Nesbitt
|
https://opensource.com/article/18/4/3-password-managers-linux-command-line
|
给在终端窗口花费大量时间的人们的密码管理器。
|
/data/attachment/album/201804/24/180338w6kvq6h8y2db54kh.jpg.thumb.jpg
|
/data/attachment/album/201804/24/180338w6kvq6h8y2db54kh.jpg
| true | false | true |
MjSeven
| false |
[
"密码",
"密码管理器"
] |
分享
|
{
"viewnum": 7587,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
给在终端窗口花费大量时间的人们的密码管理器。
| 2018-04-24T18:03:36 | 2018-04-24T18:03:36 | 9,575 |
/article-9575-1.html
|
>
> 给在终端窗口花费大量时间的人们的密码管理器。
>
>
>
我们都希望我们的密码安全可靠。为此，许多人转向密码管理应用程序，如 [KeePassX](https://www.keepassx.org/) 和 [Bitwarden](https://opensource.com/article/18/3/managing-passwords-bitwarden)。
如果你在终端中花费了大量时间而且正在寻找更简单的解决方案，那么你需要了解下诸多的 Linux 命令行密码管理器。它们快速，易于使用且安全。
让我们来看看其中的三个。
### Titan
[Titan](https://www.titanpasswordmanager.org/) 是一个密码管理器，也可作为文件加密工具。我不确定 Titan 在加密文件方面效果有多好；我只是把它看作密码管理器，在这方面，它确实做的很好。
Titan 将你的密码存储在加密的 [SQLite 数据库](https://en.wikipedia.org/wiki/SQLite)中，你可以在第一次启动该应用程序时创建并添加主密码。告诉 Titan 增加一个密码，它需要一个用来识别它的名字、用户名、密码本身、URL 和关于密码的注释。
你可以让 Titan 为你生成一个密码，你可以通过条目名称或数字 ID、名称、注释或使用正则表达式来搜索数据库，但是，查看特定的密码可能会有点笨拙，你要么必须列出所有密码滚动查找你想要使用的密码，要么你可以通过使用其数字 ID（如果你知道）列出条目的详细信息来查看密码。
### Gopass
[Gopass](https://www.justwatch.com/gopass/) 被称为“团队密码管理器”。不要因此感到失望，它对个人的使用也很好。
Gopass 是用 Go 语言编写的经典 Unix 和 Linux [Pass](https://www.passwordstore.org/) 密码管理器的更新版本。安装纯正的 Linux 方式，你可以[编译源代码](https://github.com/justwatchcom/gopass)或[使用安装程序](https://justwatch.com/gopass/#install)以在你的计算机上使用 gopass。
在开始使用 gopass 之前，确保你的系统上有 [GNU Privacy Guard (GPG)](https://www.gnupg.org) 和 [Git](https://git-scm.com/)。前者对你的密码存储进行加密和解密，后者将提交到一个 [Git 仓库](https://git-scm.com/book/en/v2/Git-Basics-Getting-a-Git-Repository)。如果 gopass 是给个人使用，你仍然需要 Git。你不需要担心提交到仓库。如果你感兴趣，你可以[在文档中](https://github.com/justwatchcom/gopass/blob/master/docs/setup.md)了解这些依赖关系。
当你第一次启动 gopass 时，你需要创建一个密码存储库并生成一个[密钥](http://searchsecurity.techtarget.com/definition/private-key)以确保存储的安全。当你想添加一个密码（gopass 中称之为“secret”）时，gopass 会要求你提供一些信息，比如 URL、用户名和密码。你可以让 gopass 为你添加的“secret”生成密码，或者你可以自己输入密码。
根据需要，你可以编辑、查看或删除密码。你还可以查看特定的密码或将其复制到剪贴板，以将其粘贴到登录表单或窗口中。
### Kpcli
许多人选择的是开源密码管理器 [KeePass](https://keepass.info/) 和 [KeePassX](https://www.keepassx.org)。 [Kpcli](http://kpcli.sourceforge.net/) 将 KeePass 和 KeePassX 的功能带到你的终端窗口。
Kpcli 是一个键盘驱动的 shell，可以完成其图形化的表亲的大部分功能。这包括打开密码数据库、添加和编辑密码和组（组帮助你组织密码），甚至重命名或删除密码和组。
当你需要时，你可以将用户名和密码复制到剪贴板以粘贴到登录表单中。为了保证这些信息的安全，kpcli 也有清除剪贴板的命令。对于一个小终端应用程序来说还不错。
你有最喜欢的命令行密码管理器吗？何不通过发表评论来分享它？
---
via: <https://opensource.com/article/18/4/3-password-managers-linux-command-line>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 命令行上使用日历
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3265752/linux/working-with-calendars-on-linux.html
|
通过 Linux 上的日历，不仅仅可以提醒你今天是星期几。诸如 date、cal、 ncal 和 calendar 等命令可以提供很多有用信息。
|
/data/attachment/album/201804/25/101504x3na3h77h26aghhi.jpg.thumb.jpg
|
/data/attachment/album/201804/25/101504x3na3h77h26aghhi.jpg
| true | false | true |
MjSeven
| false |
[
"日历"
] |
技术
|
{
"viewnum": 9765,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过 Linux 上的日历，不仅仅可以提醒你今天是星期几。诸如 date、cal、 ncal 和 calendar 等命令可以提供很多有用信息。
| 2018-04-25T10:14:59 | 2018-04-25T10:14:59 | 9,576 |
/article-9576-1.html
|
>
> 通过 Linux 上的日历，不仅仅可以提醒你今天是星期几。诸如 date、cal、 ncal 和 calendar 等命令可以提供很多有用信息。
>
>
>
Linux 系统可以为你的日程安排提供更多帮助，而不仅仅是提醒你今天是星期几。日历显示有很多选项 —— 有些可能很有帮助，有些可能会让你大开眼界。
### 日期
首先，你可能知道可以使用 `date` 命令显示当前日期。
```
$ date
Mon Mar 26 08:01:41 EDT 2018
```
### cal 和 ncal
你可以使用 `cal` 命令显示整个月份。没有参数时，`cal` 显示当前月份，默认情况下，通过反转前景色和背景颜色来突出显示当天。
```
$ cal
March 2018
Su Mo Tu We Th Fr Sa
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31
```
如果你想以“横向”格式显示当前月份，则可以使用 `ncal` 命令。
```
$ ncal
March 2018
Su 4 11 18 25
Mo 5 12 19 26
Tu 6 13 20 27
We 7 14 21 28
Th 1 8 15 22 29
Fr 2 9 16 23 30
Sa 3 10 17 24 31
```
例如，如果你只想查看特定周几的日期，这个命令可能特别有用。
```
$ ncal | grep Th
Th 1 8 15 22 29
```
`ncal` 命令还可以以“横向”格式显示一整年，只需在命令后提供年份。
```
$ ncal 2018
2018
January February March April
Su 7 14 21 28 4 11 18 25 4 11 18 25 1 8 15 22 29
Mo 1 8 15 22 29 5 12 19 26 5 12 19 26 2 9 16 23 30
Tu 2 9 16 23 30 6 13 20 27 6 13 20 27 3 10 17 24
We 3 10 17 24 31 7 14 21 28 7 14 21 28 4 11 18 25
Th 4 11 18 25 1 8 15 22 1 8 15 22 29 5 12 19 26
Fr 5 12 19 26 2 9 16 23 2 9 16 23 30 6 13 20 27
Sa 6 13 20 27 3 10 17 24 3 10 17 24 31 7 14 21 28
...
```
你也可以使用 `cal` 命令显示一整年。请记住，你需要输入年份的四位数字。如果你输入 `cal 18`，你将获得公元 18 年的历年，而不是 2018 年。
```
$ cal 2018
2018
January February March
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 1 2 3 1 2 3
7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10
14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17
21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24
28 29 30 31 25 26 27 28 25 26 27 28 29 30 31
April May June
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7 1 2 3 4 5 1 2
8 9 10 11 12 13 14 6 7 8 9 10 11 12 3 4 5 6 7 8 9
15 16 17 18 19 20 21 13 14 15 16 17 18 19 10 11 12 13 14 15 16
22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23
29 30 27 28 29 30 31 24 25 26 27 28 29 30
July August September
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7 1 2 3 4 1
8 9 10 11 12 13 14 5 6 7 8 9 10 11 2 3 4 5 6 7 8
15 16 17 18 19 20 21 12 13 14 15 16 17 18 9 10 11 12 13 14 15
22 23 24 25 26 27 28 19 20 21 22 23 24 25 16 17 18 19 20 21 22
29 30 31 26 27 28 29 30 31 23 24 25 26 27 28 29
30
October November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 1 2 3 1
7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8
14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15
21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22
28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29
30 31
```
要指定年份和月份，使用 `-d` 选项，如下所示：
```
$ cal -d 1949-03
March 1949
Su Mo Tu We Th Fr Sa
1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31
```
另一个可能有用的日历选项是 `cal` 命令的 `-j` 选项。让我们来看看它显示的是什么。
```
$ cal -j
March 2018
Su Mo Tu We Th Fr Sa
60 61 62
63 64 65 66 67 68 69
70 71 72 73 74 75 76
77 78 79 80 81 82 83
84 85 86 87 88 89 90
```
你可能会问：“什么鬼？？？” OK， `-j` 选项显示 Julian 日期 -- 一年中从 1 到 365 年的数字日期。所以，1 是 1 月 1 日，32 是 2 月 1 日。命令 `cal -j 2018` 将显示一整年的数字，像这样：
```
$ cal -j 2018 | tail -9
November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
305 306 307 335
308 309 310 311 312 313 314 336 337 338 339 340 341 342
315 316 317 318 319 320 321 343 344 345 346 347 348 349
322 323 324 325 326 327 328 350 351 352 353 354 355 356
329 330 331 332 333 334 357 358 359 360 361 362 363
364 365
```
这种显示可能有助于提醒你，自从你做了新年计划之后，你已经有多少天没有采取行动了。
运行类似的命令，对于 2020 年，你会注意到这是一个闰年：
```
$ cal -j 2020 | tail -9
November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
306 307 308 309 310 311 312 336 337 338 339 340
313 314 315 316 317 318 319 341 342 343 344 345 346 347
320 321 322 323 324 325 326 348 349 350 351 352 353 354
327 328 329 330 331 332 333 355 356 357 358 359 360 361
334 335 362 363 364 365 366
```
### calendar
另一个有趣但潜在的令人沮丧的命令可以告诉你关于假期的事情，这个命令有很多选项，但我们这里介绍下你想看到即将到来的假期和值得注意的日历列表。日历的 `-l` 选项允许你选择今天想要查看的天数，因此 `0` 表示“仅限今天”。
```
$ calendar -l 0
Mar 26 Benjamin Thompson born, 1753, Count Rumford; physicist
Mar 26 David Packard died, 1996; age of 83
Mar 26 Popeye statue unveiled, Crystal City TX Spinach Festival, 1937
Mar 26 Independence Day in Bangladesh
Mar 26 Prince Jonah Kuhio Kalanianaole Day in Hawaii
Mar 26* Seward's Day in Alaska (last Monday)
Mar 26 Emerson, Lake, and Palmer record "Pictures at an Exhibition" live, 1971
Mar 26 Ludwig van Beethoven dies in Vienna, Austria, 1827
Mar 26 Bonne fête aux Lara !
Mar 26 Aujourd'hui, c'est la St(e) Ludger.
Mar 26 N'oubliez pas les Larissa !
Mar 26 Ludwig van Beethoven in Wien gestorben, 1827
Mar 26 Emánuel
```
对于我们大多数人来说，这庆祝活动有点多。如果你看到类似这样的内容，可以将其归咎于你的 `calendar.all` 文件，该文件告诉系统你希望包含哪些国际日历。当然，你可以通过删除此文件中包含其他文件的一些行来削减此问题。文件看起来像这样：
```
#include <calendar.world>
#include <calendar.argentina>
#include <calendar.australia>
#include <calendar.belgium>
#include <calendar.birthday>
#include <calendar.christian>
#include <calendar.computer>
```
假设我们只通过移除除上面显示的第一个 `#include` 行之外的所有行，将我们的显示切换到世界日历。 我们会看到这个：
```
$ calendar -l 0
Mar 26 Benjamin Thompson born, 1753, Count Rumford; physicist
Mar 26 David Packard died, 1996; age of 83
Mar 26 Popeye statue unveiled, Crystal City TX Spinach Festival, 1937
Mar 26 Independence Day in Bangladesh
Mar 26 Prince Jonah Kuhio Kalanianaole Day in Hawaii
Mar 26* Seward's Day in Alaska (last Monday)
Mar 26 Emerson, Lake, and Palmer record "Pictures at an Exhibition" live, 1971
Mar 26 Ludwig van Beethoven dies in Vienna, Austria, 1827
```
显然，世界日历的特殊日子非常多。但是，像这样的展示可以让你不要忘记所有重要的“大力水手雕像”揭幕日以及在庆祝“世界菠菜之都”中它所扮演的角色。
更有用的日历选择可能是将与工作相关的日历放入特殊文件中，并在 `calendar.all` 文件中使用该日历来确定在运行命令时将看到哪些事件。
```
$ cat /usr/share/calendar/calendar.all
/*
* International and national calendar files
*
* This is the calendar master file. In the standard setup, it is
* included by /etc/calendar/default, so you can make any system-wide
* changes there and they will be kept when you upgrade. If you want
* to edit this file, copy it into /etc/calendar/calendar.all and
* edit it there.
*
*/
#ifndef _calendar_all_
#define _calendar_all_
#include <calendar.usholiday>
#include <calendar.work> <==
#endif /* !_calendar_all_ */
```
日历文件的格式非常简单 - `mm/dd` 格式日期，空格和事件描述。
```
$ cat calendar.work
03/26 Describe how the cal and calendar commands work
03/27 Throw a party!
```
### 注意事项和怀旧
注意，有关日历的命令可能不适用于所有 Linux 发行版，你可能必须记住自己的“大力水手”雕像。
如果你想知道，你可以显示一个日历，远至 9999 —— 即使是预言性的 [2525](https://www.youtube.com/watch?v=izQB2-Kmiic)。
在 [Facebook](https://www.facebook.com/NetworkWorld/) 和 [LinkedIn](https://www.linkedin.com/company/network-world) 上加入网络社区，对那些重要的话题发表评论。
---
via: <https://www.networkworld.com/article/3265752/linux/working-with-calendars-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在企业中开展开源计划
|
Chris Aniszczyk
|
https://opensource.com/article/18/1/how-start-open-source-program-your-company
|
有 65% 的企业在使用开源软件，并非只有互联网企业才能受惠于开源计划。
|
/data/attachment/album/201804/25/234303oaqa86145gqhgrar.png.thumb.jpg
|
/data/attachment/album/201804/25/234303oaqa86145gqhgrar.png
| true | false | true |
Valoniakim
| false |
[
"开源计划"
] |
观点
|
{
"viewnum": 2731,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有 65% 的企业在使用开源软件，并非只有互联网企业才能受惠于开源计划。
| 2018-04-25T23:43:29 | 2018-04-25T23:43:29 | 9,577 |
/article-9577-1.html
|
>
> 有 65% 的企业在使用开源软件，并非只有互联网企业才能受惠于开源计划。
>
>
>
很多互联网企业如 Google、 Facebook、 Twitter 等，都已经正式建立了开源计划（有的公司中建立了单独的<ruby> 开源计划部门 <rt> open source program office </rt></ruby>（OSPO）），这是在公司内部消化和支持开源产品的地方。在这样一个实际的部门中，企业可以清晰透明地执行开源策略，这是企业成功开源化的一个必要过程。开源计划部门的职责包括：制定使用、分配、选择和审查代码的相关政策；培育开源社区；培训开发技术人员和确保法律合规。
互联网企业并不是唯一建立开源计划的企业，有调查发现各种行业中有 [65% 的企业](https://www.blackducksoftware.com/2016-future-of-open-source)的在使用开源和向开源贡献。在过去几年中 [VMware](http://www.cio.com/article/3095843/open-source-tools/vmware-today-has-a-strong-investment-in-open-source-dirk-hohndel.html)、 [Amazon](http://fortune.com/2016/12/01/amazon-open-source-guru/)、 [Microsoft](https://opensource.microsoft.com/) 等企业，甚至连[英国政府](https://www.linkedin.com/jobs/view/169669924)都开始聘用开源管理人员，开展开源计划。可见近年来商业领域乃至政府都十分重视开源策略，在这样的环境下，各界也需要跟上他们的步伐，建立开源计划。
### 怎样建立开源计划
虽然根据企业的需求不同，各开源计划部门会有特殊的调整，但下面几个基本步骤是建立每个公司都会经历的，它们是：
* **选定一位领导者：** 选出一位合适的领导之是建立开源计划的第一步。 [TODO Group](http://todogroup.org) 发布了一份[开源人员基础工作任务清单](https://github.com/todogroup/job-descriptions)，你可以根据这个清单筛选人员。
* **确定计划构架：** 开源计划部门可以根据其服务的企业类型的侧重点，来适应不同种类的企业需求，以在各类企业中成功运行。知识型企业可以把开源计划放在法律事务部运行，技术驱动型企业可以把开源计划放在着眼于提高企业效能的部门中，如工程部。其他类型的企业可以把开源计划放在市场部内运行，以此促进开源产品的销售。TODO Group 发布的[开源计划案例](https://github.com/todogroup/guides/tree/master/casestudies)或许可以给你些启发。
* **制定规章制度：** 开源策略的实施需要有一套规章制度，其中应当具体列出企业成员进行开源工作的标准流程，来减少失误的发生。这个流程应当简洁明了且简单易行，最好可以用设备进行自动化。如果工作人员有质疑标准流程的热情和能力，并提出改进意见，那再好不过了。许多活跃在开源领域的企业中，Google 发布的规章制度十分值得借鉴。你可以参照 [Google 发布的制度](https://opensource.google.com/docs/why/)起草适用于自己企业的规章制度，用 [TODO 提供其它开源策略](https://github.com/todogroup/policies)也可以参考。 ### 建立开源计划是企业发展中的关键一步
建立开源计划部门对很多企业来说是关键一步，尤其是对于那些软件公司或是想要转型进入软件领域的公司。不论雇员的满意度或是开发效率上，在开源计划中企业可以获得巨大的利益，这些利益远远大于对开源计划所需要的长期投资。在开源之路上有很多资源可以帮助你成功，例如 TODO Group 的[《怎样创建开源计划》](https://github.com/todogroup/guides/blob/master/creating-an-open-source-program.md)、[《开源计划的价值评估》](https://github.com/todogroup/guides/blob/master/measuring-your-open-source-program.md)和[《管理开源计划的几种工具》](https://github.com/todogroup/guides/blob/master/tools-for-managing-open-source-programs.md)都很适合初学者阅读。
随着越来越多的企业形成开源计划，开源社区自身的可持续性逐渐加强，这会对这些企业的开源计划产生积极影响，促进企业的发展，这是企业和开源间的良性循环。我希望以上这些信息能够帮到你，祝你在建立开源计划的路上一路顺风。
---
via: <https://opensource.com/article/18/1/how-start-open-source-program-your-company>
作者：[Chris Aniszczyk](https://opensource.com/users/caniszczyk) 译者：[Valoniakim](https://github.com/Valoniakim) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
FreeTube：注重隐私的开源桌面 YouTube 播放器
|
Sk
|
https://www.ostechnix.com/freetube-an-open-source-desktop-youtube-player-for-privacy-minded-people/
|
如果你不希望 Google 追踪你在 YouTube 上的行为，那么有一个名为 “FreeTube” 的开源 Youtube 播放器。
|
/data/attachment/album/201804/25/235112hpoiilwzrsyqliiz.png.thumb.jpg
|
/data/attachment/album/201804/25/235112hpoiilwzrsyqliiz.png
| true | false | true |
geekpi
| false |
[
"YouTube",
"FreeTube"
] |
分享
|
{
"viewnum": 25474,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你不希望 Google 追踪你在 YouTube 上的行为，那么有一个名为 “FreeTube” 的开源 Youtube 播放器。
| 2018-04-25T23:51:10 | 2018-04-25T23:51:10 | 9,578 |
/article-9578-1.html
|
你已经知道我们需要 Google 帐户才能订阅频道并从 YouTube 下载视频。如果你不希望 Google 追踪你在 YouTube 上的行为，那么有一个名为 **“FreeTube”** 的开源 Youtube 播放器。它能让你无需使用帐户观看、搜索和下载 Youtube 视频并订阅你喜爱的频道，这可以防止 Google 获取你的信息。它为你提供完整的无广告体验。另一个值得注意的优势是它有一个内置的基础的 HTML5 播放器来观看视频。由于我们没有使用内置的 YouTube 播放器，因此 Google 无法跟踪“观看次数”，也无法视频分析。FreeTube 只会发送你的 IP 详细信息，但这也可以通过使用 VPN 来解决。它是完全免费、开源的，可用于 GNU/Linux、Mac OS X 和 Windows。
### 功能
* 观看没有广告的视频。
* 防止 Google 使用 Cookie 或 JavaScript 跟踪你观看的内容。
* 无须帐户订阅频道。
* 本地存储订阅、历史记录和已保存的视频。
* 导入/备份订阅。
* 迷你播放器。
* 亮/暗的主题。
* 免费、开源。
* 跨平台。
### 安装 FreeTube
进入[发布页面](https://github.com/FreeTubeApp/FreeTube/releases)并根据你使用的操作系统获取版本。在本指南中，我将使用 **.tar.gz** 文件。
```
$ wget https://github.com/FreeTubeApp/FreeTube/releases/download/v0.1.3-beta/FreeTube-linux-x64.tar.xz
```
解压下载的归档：
```
$ tar xf FreeTube-linux-x64.tar.xz
```
进入 Freetube 文件夹：
```
$ cd FreeTube-linux-x64/
```
使用命令启动 Freeube：
```
$ ./FreeTub
```
这就是 FreeTube 默认界面的样子。
### 用法
FreeTube 目前使用 **YouTube API** 搜索视频。然后，它使用 **Youtube-dl HTTP API** 获取原始视频文件并在基础的 HTML5 视频播放器中播放它们。由于订阅、历史记录和已保存的视频都存储在本地系统中，因此你的详细信息将不会发送给 Google 或其他任何人。
在搜索框中输入视频名称，然后按下回车键。FreeTube 会根据你的搜索查询列出结果。
你可以点击任何视频来播放它。
如果你想更改主题或默认 API、导入/导出订阅，请进入**设置**部分。
请注意，FreeTube 仍处于 **beta** 阶段，所以仍然有 bug。如果有任何 bug，请在本指南最后给出的 GitHub 页面上报告。
干杯！
---
via: <https://www.ostechnix.com/freetube-an-open-source-desktop-youtube-player-for-privacy-minded-people/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中使用 LVM 创建和扩展交换分区
|
Ramya Nuvvula
|
https://www.2daygeek.com/how-to-create-extend-swap-partition-in-linux-using-lvm/
|
我们使用 LVM 进行灵活的卷管理，为什么我们不能将 LVM 用于交换分区呢？
|
/data/attachment/album/201804/26/000030yn7mvp87avlh1mmm.jpg.thumb.jpg
|
/data/attachment/album/201804/26/000030yn7mvp87avlh1mmm.jpg
| true | false | true |
geekpi
| false |
[
"交换分区",
"LVM"
] |
技术
|
{
"viewnum": 7098,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们使用 LVM 进行灵活的卷管理，为什么我们不能将 LVM 用于交换分区呢？
| 2018-04-26T00:00:35 | 2018-04-26T00:00:35 | 9,579 |
/article-9579-1.html
|
我们使用 LVM 进行灵活的卷管理，为什么我们不能将 LVM 用于交换分区呢？
这可以让用户在需要时增加交换分区。如果你升级系统中的内存，则需要添加更多交换空间。这有助于你管理运行需要大量内存的应用的系统。
可以通过三种方式创建交换分区
* 创建一个新的交换分区
* 创建一个新的交换文件
* 在现有逻辑卷（LVM）上扩展交换分区
建议创建专用交换分区而不是交换文件。
**建议阅读：**
* [3 种简单的方法在 Linux 中创建或扩展交换空间](https://www.2daygeek.com/add-extend-increase-swap-space-memory-file-partition-linux/)
* [使用 Shell 脚本在 Linux 中自动创建/删除和挂载交换文件](https://www.2daygeek.com/shell-script-create-add-extend-swap-space-linux/)
Linux 中推荐的交换大小是多少？
### 什么是交换空间
当物理内存 （RAM） 已满时，将使用 Linux 中的交换空间。当物理内存已满时，内存中的非活动页将移到交换空间。
这有助于系统连续运行应用程序，但它不能当做是更多内存的替代品。
交换空间位于硬盘上，因此它不能像物理内存那样处理请求。
### 如何使用 LVM 创建交换分区
由于我们已经知道如何创建逻辑卷，所以交换分区也是如此。只需按照以下过程。
创建你需要的逻辑卷。在我这里，我要创建 `5GB` 的交换分区。
```
$ sudo lvcreate -L 5G -n LogVol_swap1 vg00
Logical volume "LogVol_swap1" created.
```
格式化新的交换空间。
```
$ sudo mkswap /dev/vg00/LogVol_swap1
Setting up swapspace version 1, size = 5 GiB (5368705024 bytes)
no label, UUID=d278e9d6-4c37-4cb0-83e5-2745ca708582
```
将以下条目添加到 `/etc/fstab` 中。
```
# vi /etc/fstab
/dev/mapper/vg00-LogVol_swap1 swap swap defaults 0 0
```
启用扩展逻辑卷。
```
$ sudo swapon -va
swapon: /swapfile: already active -- ignored
swapon: /dev/mapper/vg00-LogVol_swap1: found signature [pagesize=4096, signature=swap]
swapon: /dev/mapper/vg00-LogVol_swap1: pagesize=4096, swapsize=5368709120, devsize=5368709120
swapon /dev/mapper/vg00-LogVol_swap1
```
测试交换空间是否已正确添加。
```
$ cat /proc/swaps
Filename Type Size Used Priority
/swapfile file 1459804 526336 -1
/dev/dm-0 partition 5242876 0 -2
$ free -g
total used free shared buff/cache available
Mem: 1 1 0 0 0 0
Swap: 6 0 6
```
### 如何使用 LVM 扩展交换分区
只需按照以下过程来扩展 LVM 交换逻辑卷。
禁用相关逻辑卷的交换。
```
$ sudo swapoff -v /dev/vg00/LogVol_swap1
swapoff /dev/vg00/LogVol_swap1
```
调整逻辑卷的大小。我将把交换空间从 `5GB` 增加到 `11GB`。
```
$ sudo lvresize /dev/vg00/LogVol_swap1 -L +6G
Size of logical volume vg00/LogVol_swap1 changed from 5.00 GiB (1280 extents) to 11.00 GiB (2816 extents).
Logical volume vg00/LogVol_swap1 successfully resized.
```
格式化新的交换空间。
```
$ sudo mkswap /dev/vg00/LogVol_swap1
mkswap: /dev/vg00/LogVol_swap1: warning: wiping old swap signature.
Setting up swapspace version 1, size = 11 GiB (11811155968 bytes)
no label, UUID=2e3b2ee0-ad0b-402c-bd12-5a9431b73623
```
启用扩展逻辑卷。
```
$ sudo swapon -va
swapon: /swapfile: already active -- ignored
swapon: /dev/mapper/vg00-LogVol_swap1: found signature [pagesize=4096, signature=swap]
swapon: /dev/mapper/vg00-LogVol_swap1: pagesize=4096, swapsize=11811160064, devsize=11811160064
swapon /dev/mapper/vg00-LogVol_swap1
```
测试逻辑卷是否已正确扩展。
```
$ free -g
total used free shared buff/cache available
Mem: 1 1 0 0 0 0
Swap: 12 0 12
$ cat /proc/swaps
Filename Type Size Used Priority
/swapfile file 1459804 237024 -1
/dev/dm-0 partition 11534332 0 -2
```
---
via: <https://www.2daygeek.com/how-to-create-extend-swap-partition-in-linux-using-lvm/>
作者：[Ramya Nuvvula](https://www.2daygeek.com/author/ramya/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 目录结构：/lib 分析
|
Surendra Anne
|
https://www.linuxnix.com/linux-directory-structure-lib-explained/
|
本文中，让我们来看看 /lib 目录都有些什么。
|
/data/attachment/album/201804/26/211418zpv68t7cgn6pff7m.jpg.thumb.jpg
|
/data/attachment/album/201804/26/211418zpv68t7cgn6pff7m.jpg
| true | false | true |
CYLeft
| false |
[
"目录"
] |
技术
|
{
"viewnum": 18076,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文中，让我们来看看 /lib 目录都有些什么。
| 2018-04-26T21:14:00 | 2018-04-26T21:14:00 | 9,580 |
/article-9580-1.html
|
我们在之前的文章中已经分析了其他重要系统目录，比如 `/bin`、`/boot`、`/dev`、 `/etc` 等。可以根据自己的兴趣进入下列链接了解更多信息。本文中，让我们来看看 `/lib` 目录都有些什么。
* [目录结构分析：/bin 文件夹](https://www.linuxnix.com/linux-directory-structure-explained-bin-folder/)
* [目录结构分析：/boot 文件夹](https://www.linuxnix.com/linux-directory-structure-explained-boot-folder/)
* [目录结构分析：/dev 文件夹](https://www.linuxnix.com/linux-directory-structure-explained-dev-folder/)
* [目录结构分析：/etc 文件夹](https://www.linuxnix.com/linux-directory-structure-explainedetc-folder/)
* [目录结构分析：/lost+found 文件夹](https://www.linuxnix.com/lostfound-directory-linuxunix/)
* [目录结构分析：/home 文件夹](https://www.linuxnix.com/linux-directory-structure-home-root-folders/)
### Linux 中，/lib 文件夹是什么？
`/lib` 文件夹是 **库文件目录** ，包含了所有对系统有用的库文件。简单来说，它是应用程序、命令或进程正确执行所需要的文件。在 `/bin` 或 `/sbin` 目录中的命令的动态库文件正是在此目录中。内核模块同样也在这里。
以 `pwd` 命令执行为例。执行它需要调用一些库文件。让我们来探索一下 `pwd` 命令执行时都发生了什么。我们需要使用 [strace 命令](https://www.linuxnix.com/10-strace-command-examples-linuxunix/) 找出调用的库文件。
示例：
```
root@linuxnix:~# strace -e open pwd
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
open("/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
/root
+++ exited with 0 +++
root@linuxnix:~#
```
如果你注意到的话，会发现我们使用的 `pwd` 命令的执行需要调用两个库文件。
### Linux 中 /lib 文件夹内部信息
正如之前所说，这个文件夹包含了目标文件和一些库文件，如果能了解这个文件夹的一些重要子文件，想必是极好的。下面列举的内容是基于我自己的系统，对于你的来说，可能会有所不同。
```
root@linuxnix:/lib# find . -maxdepth 1 -type d
./firmware
./modprobe.d
./xtables
./apparmor
./terminfo
./plymouth
./init
./lsb
./recovery-mode
./resolvconf
./crda
./modules
./hdparm
./udev
./ufw
./ifupdown
./systemd
./modules-load.d
```
`/lib/firmware` - 这个文件夹包含了一些硬件、<ruby> 固件 <rt> Firmware </rt></ruby>代码。
>
> **硬件和固件之间有什么不同？**
>
>
> 为了使硬件正常运行，很多设备软件由两部分软件组成。加载到实际硬件的代码部分就是固件，用于在固件和内核之间通讯的软件被称为驱动程序。这样一来，内核就可以直接与硬件通讯，并确保硬件完成内核指派的工作。
>
>
>
`/lib/modprobe.d` - modprobe 命令的配置目录。
`/lib/modules` - 所有的可加载内核模块都存储在这个目录下。如果你有多个内核，你会在这个目录下看到代表美国内核的目录。
`/lib/hdparm` - 包含 SATA/IDE 硬盘正确运行的参数。
`/lib/udev` - 用户空间 /dev 是 Linux 内核设备管理器。这个文件夹包含了所有的 udev 相关的文件和文件夹，例如 `rules.d` 包含了 udev 规范文件。
### /lib 的姊妹文件夹：/lib32 和 /lib64
这两个文件夹包含了特殊结构的库文件。它们几乎和 `/lib` 文件夹一样，除了架构级别的差异。
### Linux 其他的库文件
`/usr/lib` - 所有软件的库都安装在这里。但是不包含系统默认库文件和内核库文件。
`/usr/local/lib` - 放置额外的系统文件。这些库能够用于各种应用。
`/var/lib` - 存储动态数据的库和文件，例如 rpm/dpkg 数据和游戏记录。
---
via: <https://www.linuxnix.com/linux-directory-structure-lib-explained/>
作者：[Surendra Anne](https://www.linuxnix.com/author/surendra/) 译者：[CYLeft](https://github.com/CYLeft) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 系统中防止文件和目录被意外的删除或修改
|
Sk
|
https://www.ostechnix.com/prevent-files-folders-accidental-deletion-modification-linux/
|
有时，我会不小心的按下 SHIFT+DELETE来删除我的文件数据。是的，我是个笨蛋，没有再次确认下我实际准备要删除的东西。
|
/data/attachment/album/201804/26/214225t7lmohxomo4c34kd.jpg.thumb.jpg
|
/data/attachment/album/201804/26/214225t7lmohxomo4c34kd.jpg
| true | false | true |
yizhuoyan
| false |
[
"chattr",
"删除"
] |
技术
|
{
"viewnum": 9934,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有时，我会不小心的按下 SHIFT+DELETE来删除我的文件数据。是的，我是个笨蛋，没有再次确认下我实际准备要删除的东西。
| 2018-04-26T21:42:47 | 2018-04-26T21:42:47 | 9,581 |
/article-9581-1.html
|
有时，我会不小心的按下 `SHIFT+DELETE`来删除我的文件数据。是的，我是个笨蛋，没有再次确认下我实际准备要删除的东西。而且我太笨或者说太懒，没有备份我的文件数据。结果呢？数据丢失了！在一瞬间就丢失了。
这种事时不时就会发生在我身上。如果你和我一样，有个好消息告诉你。有个简单又有用的命令行工具叫`chattr`（**Ch**ange **Attr**ibute 的缩写），在类 Unix 等发行版中，能够用来防止文件和目录被意外的删除或修改。
通过给文件或目录添加或删除某些属性，来保证用户不能删除或修改这些文件和目录，不管是有意的还是无意的，甚至 root 用户也不行。听起来很有用，是不是？
在这篇简短的教程中，我们一起来看看怎么在实际应用中使用 `chattr` 命令，来防止文件和目录被意外删除。
### Linux中防止文件和目录被意外删除和修改
默认，`chattr` 命令在大多数现代 Linux 操作系统中是可用的。
默认语法是：
```
chattr [operator] [switch] [file]
```
`chattr` 具有如下操作符：
* 操作符 `+`，追加指定属性到文件已存在属性中
* 操作符 `-`，删除指定属性
* 操作符 `=`，直接设置文件属性为指定属性
`chattr` 提供不同的属性，也就是 `aAcCdDeijsStTu`。每个字符代表一个特定文件属性。
* `a` – 只能向文件中添加数据
* `A` – 不更新文件或目录的最后访问时间
* `c` – 将文件或目录压缩后存放
* `C` – 不适用写入时复制机制（CoW）
* `d` – 设定文件不能成为 `dump` 程序的备份目标
* `D` – 同步目录更新
* `e` – extend 格式存储
* `i` – 文件或目录不可改变
* `j` – 设定此参数使得当通过 `mount` 参数：`data=ordered` 或者 `data=writeback` 挂载的文件系统，文件在写入时会先被记录在日志中
* `P` – project 层次结构
* `s` – 安全删除文件或目录
* `S` – 即时更新文件或目录
* `t` – 不进行尾部合并
* `T` – 顶层目录层次结构
* `u` – 不可删除
在本教程中，我们将讨论两个属性的使用，即 `a`、`i` ，这个两个属性可以用于防止文件和目录的被删除。这是我们今天的主题，对吧？来开始吧！
### 防止文件被意外删除和修改
我先在我的当前目录创建一个`file.txt`文件。
```
$ touch file.txt
```
现在，我将给文件应用 `i` 属性，让文件不可改变。就是说你不能删除或修改这个文件，就算你是文件的拥有者和 root 用户也不行。
```
$ sudo chattr +i file.txt
```
使用`lsattr`命令检查文件已有属性：
```
$ lsattr file.txt
```
输出：
```
----i---------e---- file.txt
```
现在，试着用普通用户去删除文件：
```
$ rm file.txt
```
输出：
```
# 不能删除文件，非法操作
rm: cannot remove 'file.txt': Operation not permitted
```
我来试试 `sudo` 特权：
```
$ sudo rm file.txt
```
输出：
```
# 不能删除文件，非法操作
rm: cannot remove 'file.txt': Operation not permitted
```
我们试试追加写内容到这个文本文件：
```
$ echo 'Hello World!' >> file.txt
```
输出：
```
# 非法操作
bash: file.txt: Operation not permitted
```
试试 `sudo` 特权：
```
$ sudo echo 'Hello World!' >> file.txt
```
输出：
```
# 非法操作
bash: file.txt: Operation not permitted
```
你应该注意到了，我们不能删除或修改这个文件，甚至 root 用户或者文件所有者也不行。
要撤销属性，使用 `-i` 即可。
```
$ sudo chattr -i file.txt
```
现在，这不可改变属性已经被删除掉了。你现在可以删除或修改这个文件了。
```
$ rm file.txt
```
类似的，你能够限制目录被意外删除或修改，如下一节所述。
### 防止目录被意外删除和修改
创建一个 `dir1` 目录，放入文件 `file.txt`。
```
$ mkdir dir1 && touch dir1/file.txt
```
现在，让目录及其内容（`file.txt` 文件）不可改变：
```
$ sudo chattr -R +i dir1
```
命令中，
* `-R` – 递归使 `dir1` 目录及其内容不可修改
* `+i` – 使目录不可修改
现在，来试试删除这个目录，要么用普通用户，要么用 `sudo` 特权。
```
$ rm -fr dir1
$ sudo rm -fr dir1
```
你会看到如下输出：
```
# 不可删除'dir1/file.txt'：非法操作
rm: cannot remove 'dir1/file.txt': Operation not permitted
```
尝试用 `echo` 命令追加内容到文件，你成功了吗？当然，你做不到。
撤销此属性，输入：
```
$ sudo chattr -R -i dir1
```
现在你就能想平常一样删除或修改这个目录内容了。
### 防止文件和目录被意外删除，但允许追加操作
我们现已知道如何防止文件和目录被意外删除和修改了。接下来，我们将防止文件被删除但仅仅允许文件被追加内容。意思是你不可以编辑修改文件已存在的数据，或者重命名这个文件或者删除这个文件，你仅可以使用追加模式打开这个文件。
为了设置追加属性到文件或目录，我们像下面这么操作：
针对文件：
```
$ sudo chattr +a file.txt
```
针对目录：
```
$ sudo chattr -R +a dir1
```
一个文件或目录被设置了 `a` 这个属性就仅仅能够以追加模式打开进行写入。
添加些内容到这个文件以测试是否有效果。
```
$ echo 'Hello World!' >> file.txt
$ echo 'Hello World!' >> dir1/file.txt
```
查看文件内容使用cat命令
```
$ cat file.txt
$ cat dir1/file.txt
```
输出：
```
Hello World!
```
你将看到你现在可以追加内容。就表示我们可以修改这个文件或目录。
现在让我们试试删除这个文件或目录。
```
$ rm file.txt
```
输出：
```
# 不能删除文件'file.txt'：非法操作
rm: cannot remove 'file.txt': Operation not permitted
```
让我们试试删除这个目录：
```
$ rm -fr dir1/
```
输出：
```
# 不能删除文件'dir1/file.txt'：非法操作
rm: cannot remove 'dir1/file.txt': Operation not permitted
```
删除这个属性，执行下面这个命令：
针对文件：
```
$ sudo chattr -R -a file.txt
```
针对目录：
```
$ sudo chattr -R -a dir1/
```
现在，你可以想平常一样删除或修改这个文件和目录了。
更多详情，查看 man 页面。
```
man chattr
```
### 总结
保护数据是系统管理人员的主要工作之一。市场上有众多可用的免费和收费的数据保护软件。幸好，我们已经拥有这个内置命令可以帮助我们去保护数据被意外的删除和修改。在你的 Linux 系统中，`chattr` 可作为保护重要系统文件和数据的附加工具。
然后，这就是今天所有内容了。希望对大家有所帮助。接下来我将会在这提供其他有用的文章。在那之前，敬请期待。再见！
---
via: <https://www.ostechnix.com/prevent-files-folders-accidental-deletion-modification-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[yizhuoyan](https://github.com/yizhuoyan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么微服务是一个安全问题
|
Mike Bursell
|
https://opensource.com/article/17/11/microservices-are-security-issue
|
你可能并不想把所有的遗留应用全部分解为微服务，或许你可以考虑从安全功能开始。
|
/data/attachment/album/201804/27/083604ahlllhmch3p3hzsy.jpg.thumb.jpg
|
/data/attachment/album/201804/27/083604ahlllhmch3p3hzsy.jpg
| true | false | true |
erlinux
| false |
[
"微服务"
] |
观点
|
{
"viewnum": 4268,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你可能并不想把所有的遗留应用全部分解为微服务，或许你可以考虑从安全功能开始。
| 2018-04-27T08:36:14 | 2018-04-27T08:36:14 | 9,582 |
/article-9582-1.html
|
>
> 你可能并不想把所有的遗留应用全部分解为微服务，或许你可以考虑从安全功能开始。
>
>
>
我为了给这篇文章起个标题，使出 “洪荒之力”，也很担心这会变成标题党。如果你点击它，是因为它激起了你的好奇，那么我表示抱歉 <sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#1"> 注1 </a></sup> 。我当然是希望你留下来阅读的 <sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#2"> 注2 </a></sup> ：我有很多有趣的观点以及很多 <sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#3"> 注3 </a></sup> 脚注。我不是故意提出微服务会导致安全问题——尽管如同很多组件一样都有安全问题。当然，这些微服务是那些安全方面的人员的趣向所在。进一步地说，我认为对于那些担心安全的人来说，它们是优秀的架构。
为什么这样说？这是个好问题，对于我们这些有[系统安全](https://aliceevebob.com/2017/03/14/systems-security-why-it-matters/) 经验的人来说，此时这个世界才是一个有趣的地方。我们看到随着带宽便宜了并且延迟降低了，分布式系统在增长。加上部署到云愈加便利，越来越多的架构师们开始意识到应用是可以分解的，不只是分成多个层，并且层内还能分为多个组件。当然，均衡负载可以用于让一个层内的各个组件协同工作，但是将不同的服务输出为各种小组件的能力导致了微服务在设计、实施和部署方面的增长。
所以，[到底什么是微服务呢](https://opensource.com/resources/what-are-microservices)？我同意[维基百科的定义](https://en.wikipedia.org/wiki/Microservices)，尽管没有提及安全性方面的内容<sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#4"> 注4 </a></sup> 。 我喜欢微服务的一点是，经过精心设计，其符合 Peter H. Salus 描述的 [UNIX 哲学](https://en.wikipedia.org/wiki/Unix_philosophy) 的前俩点：
1. 程序应该只做一件事，并尽可能把它做好。
2. 让程序能够互相协同工作。
3. 应该让程序处理文本数据流，因为这是一个通用的接口。
三者中最后一个有点不太相关，因为 UNIX 哲学通常被用来指代独立应用，它常有一个实例化的命令。但是，它确实包含了微服务的基本要求之一：必须具有“定义明确”的接口。
这里的“定义明确”，我指的不仅仅是可外部访问的 API 的方法描述，也指正常的微服务输入输出操作——以及，如果有的话，还有其副作用。就像我之前的文章描述的，“[良好的系统架构的五个特征](https://opensource.com/article/17/10/systems-architect)”，如果你能够去设计一个系统，数据和主体描述是至关重要的。在此，在我们的微服务描述上，我们要去看看为什么这些是如此重要。因为对我来说，微服务架构的关键定义是可分解性。如果你要分解 <sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#5"> 注5 </a></sup> 你的架构，你必须非常、非常地清楚每个细节（“组件”）要做什么。
在这里，就要开始考虑安全了。特定组件的准确描述可以让你：
* 审查您的设计
* 确保您的实现符合描述
* 提出可重用测试单元来审查功能
* 跟踪实施中的错误并纠正错误
* 测试意料之外的产出
* 监视不当行为
* 审核未来可能的实际行为
现在，这些微服务能用在一个大型架构里了吗？是的。但如果实体是在更复杂的配置中彼此链接或组合在一起，它们会随之越来越难。当你让一小部分可以彼此配合工作时，确保正确的实施和行为是非常、非常容易的。并且如果你不能确定单个组件正在做它们应该作的，那么确保其衍生出来的复杂系统的正确行为及不正确行为就困难的多了。
而且还不止于此。如我已经在许多[以往场合](https://opensource.com/users/mikecamel)提过的，写足够安全的代码是困难的<sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#7"> 注7 </a></sup> ，证实它应该做的更加困难。因此，有理由限制有特定安全要求的代码——密码检测、加密、加密密钥管理、授权等等——将它们变成小而定义明确的代码块。然后你就可以执行我上面提及所有工作，以确保正确完成。
还有，我们都知道并不是每个人都擅长于编写与安全相关的代码。通过分解你的体系架构，将安全敏感的代码限制到定义明确的组件中，你就可以把你最棒的安全人员放到这方面，并限制了 J.佛系.码奴 <sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#8"> 注8 </a></sup> 绕过或降级一些关键的安全控制措施的危险。
它可以作为学习的机会：它对于设计/实现/测试/监视的兄弟们都是好的，而且给他们说：“听、读、标记、学习，并且引为己用 <sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#9"> 注9 </a></sup> 。这是应该做的。”
是否应该将所有遗留应用程序分解为微服务？ 不一定。 但是考虑到其带来的好处，你可以考虑从安全入手。
---
* 注1、有一点——有读者总是好的。
* 注2、这是我写下文章的意义。
* 注3、可能没那么有趣。
* 注4、在我写这篇文章时。我或你们中的一个可能会去编辑改变它。
* 注5、这很有趣，听起来想一个园艺术语。并不是说我很喜欢园艺，但仍然... <sup> <a href="https://opensource.com/article/17/11/microservices-are-security-issue#6"> 注6 </a></sup>
* 注6、有意思的是，我最先写的 “如果你要分解你的架构....” 听起来想是一个 IT 主题的谋杀电影标题。
* 注7、长期读者可能会记得提到的优秀电影 “The Thick of It”
* 注8、其他的什么人：请随便选择。
* 注9、不是加密<ruby> 摘要 <rt> digest </rt></ruby>：我不认同原作者的想法。
这篇文章最初出在[爱丽丝、伊娃与鲍伯](https://zh.wikipedia.org/zh-hans/%E6%84%9B%E9%BA%97%E7%B5%B2%E8%88%87%E9%AE%91%E4%BC%AF)——一个安全博客上，并被许可转载。
---
via: <https://opensource.com/article/17/11/microservices-are-security-issue>
作者：[Mike Bursell](https://opensource.com/users/mikecamel) 译者：[erlinux](https://itxdm.me) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Ubuntu 18.04 LTS（仿生河狸）发布！
|
Marius Nestor
|
https://news.softpedia.com/news/ubuntu-18-04-lts-bionic-beaver-officially-released-here-is-what-s-new-520856.shtml
|
Canonical 今天正式发布了可用于计算机、IoT 和云环境的 Ubuntu 18.04 LTS （仿生河狸 Bionic Beaver） 操作系统。
|
/data/attachment/album/201804/27/125138kcr9czpw1wzyq34w.jpg.thumb.jpg
|
/data/attachment/album/201804/27/125138kcr9czpw1wzyq34w.jpg
| true | false | true |
wxy
| false |
[
"Ubuntu"
] |
新闻
|
{
"viewnum": 12119,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Canonical 今天正式发布了可用于计算机、IoT 和云环境的 Ubuntu 18.04 LTS （仿生河狸 Bionic Beaver） 操作系统。
| 2018-04-27T12:58:00 | 2018-04-27T12:58:00 | 9,583 |
/article-9583-1.html
|
Canonical 今天正式发布了可用于计算机、IoT 和云环境的 Ubuntu 18.04 LTS （<ruby> 仿生河狸 <rp> （ </rp> <rt> Bionic Beaver </rt> <rp> ） </rp></ruby>） 操作系统。
经过六个月的努力工作，被称之为（<ruby> 仿生河狸 <rp> （ </rp> <rt> Bionic Beaver </rt> <rp> ） </rp></ruby>）的 Ubnutu 18.04 LTS 正式发布了，这也是 Ubuntu 的第七个长期支持版（LTS）。在直到 2023 年 4 月的五年内 Canonical 将为其提供安全和软件的更新，这期间将至少会有 5 个维护性更新版本，会将以后发布的 Ubuntu 中的新内核和显卡驱动更新到这个 LTS 版本当中。
正如预期的那样，Ubuntu 18.04 LTS 带来了几个新功能和变化，它开始使用 X.Org 服务器作为默认显示服务器来再次取代在 Ubuntu 17.10 中使用的 Wayland。另一方面，Canonical 计划在 Ubuntu 20.04 LTS 中再次启用 Wayland 作为默认的显示服务器，而现在它将以技术预览版的方式提供，在登录屏幕上可以选择。
另一个很酷的新功能是图形化安装器中的“[最小安装](https://news.softpedia.com/news/ubuntu-18-04-lts-will-let-users-choose-between-normal-and-minimal-installation-520640.shtml)”方式，用户可以安装一个仅有 Mozilla 浏览器和一些方便的标准功能的操作系统。说到了图形安全器，它在这个新版本中进行了重新打造，所以你可以看到它添加了一些不同的选项，也有一些被移去了。
Ubuntu 18.04 LTS 也有了由微软合作开发的新的 Hyper-V 优化镜像，它是 Windows 桌面上最快的 Ubuntu 桌面环境。对于云环境，Ubuntu 18.04 LTS 云镜像集成了 Nvidia GPU 硬件加速功能。
Canonical CEO 及 Ubuntu 的创始人 Mark Shuttleworth 说，“多云操作现在是新业态，优化了启动时间和性能的 Ubuntu 18.04 LTS 在各个主流云平台上将成为用于云计算的最快、最高效的操作系统，特别是在存储和像机器学习这样的计算密集型任务方面。”
### GNOME 3.28 作为默认桌面
同 Ubuntu 17.10 一样，仿生河使用最新的 GNOME 桌面作为默认环境。除了 Nautilus 文件管理器仍旧是 3.26 之外，GNOME 所提供的所有应用都更新到了 3.28，因为事实上当前该版本不再由 GNOME 桌面管理。另外，在 Ubuntu 18.04 LTS 当中，Nautilus 以暗色风格重新进行了装扮。
如果你从使用 GNOME 3.26 的 Ubuntu 17.10 升级的话就会发现，**[GNOME 3.28 自身也带来了许多变化](https://news.softpedia.com/news/gnome-3-28-desktop-environment-officially-released-here-s-what-s-new-520231.shtml)**。一个需要重点提出的功能是 GNOME Shell 界面现在支持雷雳 3 连接。另外，GNOME 3.28 新打造的 GNOME To Do 应用也被默认包括在 Ubuntu 18.04 LTS 当中了。
在所选用的应用当中，我们能注意到 GNOME 日历现在支持气候预报，所包括的 GNOME 字符应用替换了老的字符映射功能，GNOME Boxes 现在使用 spice-vdagent 为 Spice 客户端提供了更好的性能。LibreOffice 6.0 是默认办公套件，Mozilla FireFox 59.0.2 是默认浏览器，OpenJDK 10 是默认 JRE/JDK。
### 多个应用以 Snap 的方式提供
由于 Canonical 在推广其 Snappy 技术，它提供了更好的隔离性和安全，以及贯穿整个 LTS 生命周期的持续升级支持，毫无疑问 Ubuntu 18.04 LTS 将预装几个默认采用 Snap 统一封装包的应用。
这些应用包括 GNOME 日历、GNOME 字符、GNOME 日志和 GNOME 系统监视器等。为了使用户更易于安装 Snap 软件包，Ubuntu 软件应用现在可以让你轻松切换不同的 Snap 商店。有超过 3000 个 Snap 可以从 Snap 商店安装，包括 Firefox、Spotify、Skype 和 Slack 等流行应用。
其它值得一提的还有，在大多数应用中支持彩色 emoji 字符。触摸板支持双指右击，而无需物理按键（可以在 GNOME 设置功能中修改该设置）。鼠标和触摸板有了新的驱动，即 libinput，如果你觉得它不适合你，你仍然可以通过设置来切换回 Synapics 驱动，但是 Canonical 将在以后版本移除它。最后，如果在电池供电时 20 分钟不操作的话，Ubuntu 18.04 LTS 将会自动休眠笔记本。
### Ubuntu 18.04 LTS 底层情况
在底层，Ubuntu 18.04 LTS 使用的是 Linux 4.15 系列的内核，该系列内核最近将结束支持期。不过，我们认为 Canonical 将会继续支持它，直到今年年底发布的第一个维护版本 Ubuntu 18.04.1 LTS 为止——它将使用新的内核和图形驱动。
Canonical 在[发布公告](https://wiki.ubuntu.com/BionicBeaver/ReleaseNotes)中称，“在 Ubuntu 18.04 LTS 中，gcc 现在默认编译程序为即时绑定的<ruby> 独立定位的可执行程序 <rp> （ </rp> <rt> position independent executable </rt> <rp> ） </rp></ruby>（PIE），以更有效的利用<ruby> 地址空间布局随机化 <rp> （ </rp> <rt> Address Space Layout Randomization </rt> <rp> ） </rp></ruby>（ASLR）技术。除了几个例外之外，所有主要的软件包都将重构以获得该能力。”对于 Meltdown 和 Spectre 安全漏洞的缓解措施也已经到位。
从 Ubuntu 17.10 以来有一些新的功能，不过如果你计划从更旧的版本升级，你应该看看“[从 Ubuntu 16.04 LTS 以来的新变化](/article-9183-1.html)”这篇文章。Ubuntu 18.04 LTS 现在可以下载了，在升级前，你应该看看如何[从之前的版本升级](https://news.softpedia.com/news/how-to-upgrade-ubuntu-17-10-or-ubuntu-16-04-lts-to-ubuntu-18-04-lts-520854.shtml)。
### Ubuntu 18.04 LTS 下载
* Ubuntu 桌面版和服务器版 <http://releases.ubuntu.com/18.04/>
* 其它架构的 Ubuntu 服务器 <http://cdimage.ubuntu.com/ubuntu/releases/18.04/release/>
* Ubuntu 云镜像 <https://www.ubuntu.com/download/cloud/>
* Ubuntu 物联网 <https://www.ubuntu.com/download/iot/>
*
|
||
“开箱即用” 的 Kubernetes 集群
|
Alex Ellis
|
https://blog.alexellis.io/your-instant-kubernetes-cluster/
|
当你想在云上创建一个集群或者尽可能快地构建基础设施时，你可能会用到它。
|
/data/attachment/album/201804/28/065439yadbvnowe5wdxrew.png.thumb.jpg
|
/data/attachment/album/201804/28/065439yadbvnowe5wdxrew.png
| true | false | true |
qhwdw
| false |
[
"Kubernetes",
"K8S"
] |
容器与云
|
{
"viewnum": 6940,
"commentnum": 0,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
当你想在云上创建一个集群或者尽可能快地构建基础设施时，你可能会用到它。
| 2018-04-28T06:54:00 | 2018-04-28T06:54:00 | 9,584 |
/article-9584-1.html
|
这是我以前的 [10 分钟内配置 Kubernetes](https://www.youtube.com/watch?v=6xJwQgDnMFE) 教程的精简版和更新版。我删除了一些我认为可以去掉的内容，所以，这个指南仍然是通顺的。当你想在云上创建一个集群或者尽可能快地构建基础设施时，你可能会用到它。
### 1.0 挑选一个主机
我们在本指南中将使用 Ubuntu 16.04，这样你就可以直接拷贝/粘贴所有的指令。下面是我用本指南测试过的几种环境。根据你运行的主机，你可以从中挑选一个。
* [DigitalOcean](https://www.digitalocean.com/) - 开发者云
* [Civo](https://www.civo.com/) - UK 开发者云
* [Packet](https://packet.net/) - 裸机云
* 2x Dell Intel i7 服务器 —— 它在我家中
>
> Civo 是一个相对较新的开发者云，我比较喜欢的一点是，它开机时间只有 25 秒，我就在英国，因此，它的延迟很低。
>
>
>
### 1.1 准备机器
你可以使用一个单台主机进行测试，但是，我建议你至少使用三台机器，这样你就有一个主节点和两个工作节点。
下面是一些其他的指导原则：
* 最好选至少有 2 GB 内存的双核主机
* 在准备主机的时候，如果你可以自定义用户名，那么就不要使用 root。例如，Civo 通常让你在 `ubuntu`、`civo` 或者 `root` 中选一个。
现在，在每台机器上都运行以下的步骤。它将需要 5-10 钟时间。如果你觉得太慢了，你可以使用我[放在 Gist](https://gist.github.com/alexellis/e8bbec45c75ea38da5547746c0ca4b0c) 的脚本 ：
```
$ curl -sL https://gist.githubusercontent.com/alexellis/e8bbec45c75ea38da5547746c0ca4b0c/raw/23fc4cd13910eac646b13c4f8812bab3eeebab4c/configure.sh | sh
```
### 1.2 登入和安装 Docker
从 Ubuntu 的 apt 仓库中安装 Docker。它的版本可能有点老，但是，Kubernetes 在老版本的 Docker 中是测试过的，工作的很好。
```
$ sudo apt-get update \
&& sudo apt-get install -qy docker.io
```
### 1.3 禁用 swap 文件
这是 Kubernetes 的强制步骤。实现它很简单，编辑 `/etc/fstab` 文件，然后注释掉引用 swap 的行即可。
保存它，重启后输入 `sudo swapoff -a`。
>
> 一开始就禁用 swap 内存，你可能觉得这个要求很奇怪，如果你对这个做法感到好奇，你可以去 [这里阅读它的相关内容](https://github.com/kubernetes/kubernetes/issues/53533)。
>
>
>
### 1.4 安装 Kubernetes 包
```
$ sudo apt-get update \
&& sudo apt-get install -y apt-transport-https \
&& curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
$ echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" \
| sudo tee -a /etc/apt/sources.list.d/kubernetes.list \
&& sudo apt-get update
$ sudo apt-get update \
&& sudo apt-get install -y \
kubelet \
kubeadm \
kubernetes-cni
```
### 1.5 创建集群
这时候，我们使用 `kubeadm` 初始化主节点并创建集群。这一步仅在主节点上操作。
>
> 虽然有警告，但是 [Weaveworks](https://weave.works/) 和 Lucas（他们是维护者）向我保证，`kubeadm` 是可用于生产系统的。
>
>
>
```
$ sudo kubeadm init
```
如果你错过一个步骤或者有问题，`kubeadm` 将会及时告诉你。
我们复制一份 Kube 配置：
```
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
```
确保你一定要记下如下的加入 `token` 的命令。
```
$ sudo kubeadm join --token c30633.d178035db2b4bb9a 10.0.0.5:6443 --discovery-token-ca-cert-hash sha256:<hash>
```
### 2.0 安装网络
许多网络提供商提供了 Kubernetes 支持，但是，默认情况下 Kubernetes 都没有包括。这里我们使用来自 [Weaveworks](https://weave.works/) 的 Weave Net，它是 Kebernetes 社区中非常流行的选择之一。它近乎不需要额外配置的 “开箱即用”。
```
$ kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
```
如果在你的主机上启用了私有网络，那么，你可能需要去修改 Weavenet 使用的私有子网络，以便于为 Pod（容器）分配 IP 地址。下面是命令示例：
```
$ curl -SL "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')&env.IPALLOC_RANGE=172.16.6.64/27" \
| kubectl apply -f -
```
>
> Weave 也有很酷的称为 Weave Cloud 的可视化工具。它是免费的，你可以在它上面看到你的 Pod 之间的路径流量。[这里有一个使用 OpenFaaS 项目的示例](https://www.weave.works/blog/openfaas-gke)。
>
>
>
### 2.2 在集群中加入工作节点
现在，你可以切换到你的每一台工作节点，然后使用 1.5 节中的 `kubeadm join` 命令。运行完成后，登出那个工作节点。
### 3.0 收获
到此为止 —— 我们全部配置完成了。你现在有一个正在运行着的集群，你可以在它上面部署应用程序。如果你需要设置仪表板 UI，你可以去参考 [Kubernetes 文档](https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/)。
```
$ kubectl get nodes
NAME STATUS ROLES AGE VERSION
openfaas1 Ready master 20m v1.9.2
openfaas2 Ready <none> 19m v1.9.2
openfaas3 Ready <none> 19m v1.9.2
```
如果你想看到我一步一步创建集群并且展示 `kubectl` 如何工作的视频，你可以看下面我的视频，你可以订阅它。
你也可以在你的 Mac 电脑上，使用 Minikube 或者 Docker 的 Mac Edge 版本，安装一个 “开箱即用” 的 Kubernetes 集群。[阅读在这里的我的评估和第一印象](https://blog.alexellis.io/docker-for-mac-with-kubernetes/)。
---
via: <https://blog.alexellis.io/your-instant-kubernetes-cluster/>
作者：[Alex Ellis](https://blog.alexellis.io/author/alex/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中查找文件
|
Lewis Cowles
|
https://opensource.com/article/18/4/how-find-files-linux
|
使用简单的命令在 Linux 下基于类型、内容等快速查找文件。
|
/data/attachment/album/201804/28/070942bw8k3eoo3e37ju78.png.thumb.jpg
|
/data/attachment/album/201804/28/070942bw8k3eoo3e37ju78.png
| true | false | true |
geekpi
| false |
[
"查找",
"搜索"
] |
技术
|
{
"viewnum": 17447,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用简单的命令在 Linux 下基于类型、内容等快速查找文件。
| 2018-04-28T07:09:38 | 2018-04-28T07:09:38 | 9,585 |
/article-9585-1.html
|
>
> 使用简单的命令在 Linux 下基于类型、内容等快速查找文件。
>
>
>
如果你是 Windows 或 OSX 的非资深用户，那么可能使用 GUI 来查找文件。你也可能发现界面受限，令人沮丧，或者两者兼而有之，并学会了组织文件并记住它们的确切顺序。你也可以在 Linux 中做到这一点 —— 但你不必这样做。
Linux 的好处之一是它提供了多种方式来处理。你可以打开任何文件管理器或按下 `Ctrl+F`，你也可以使用程序手动打开文件，或者你可以开始输入字母，它会过滤当前目录列表。
*使用 Ctrl+F 在 Linux 中查找文件的截图*
但是如果你不知道你的文件在哪里，又不想搜索整个磁盘呢？对于这个以及其他各种情况，Linux 都很合适。
### 按命令名查找程序位置
如果你习惯随心所欲地放文件，Linux 文件系统看起来会让人望而生畏。对我而言，最难习惯的一件事是找到程序在哪里。
例如，`which bash` 通常会返回 `/bin/bash`，但是如果你下载了一个程序并且它没有出现在你的菜单中，那么 `which` 命令就是一个很好的工具。
一个类似的工具是 `locate` 命令，我发现它对于查找配置文件很有用。我不喜欢输入程序名称，因为像 `locate php` 这样的简单程序通常会提供很多需要进一步过滤的结果。
有关 `locate` 和 `which` 的更多信息，请参阅 `man` 页面：
* `man which`
* `man locate`
### find
`find` 工具提供了更先进的功能。以下是我安装在许多服务器上的脚本示例，我用于确保特定模式的文件（也称为 glob）仅存在五天，并且所有早于此的文件都将被删除。 （自上次修改以来，分数用于保留最多 240 分钟的偏差）
```
find ./backup/core-files*.tar.gz -mtime +4.9 -exec rm {} \;
```
`find` 工具有许多高级用法，但最常见的是对结果执行命令，而不用链式地按照类型、创建日期、修改日期过滤文件。
`find` 的另一个有趣用处是找到所有有可执行权限的文件。这有助于确保没有人在你昂贵的服务器上安装比特币挖矿程序或僵尸网络。
```
find / -perm /+x
```
有关 `find` 的更多信息，请使用 `man find` 参考 `man` 页面。
### grep
想通过内容中查找文件？ Linux 已经实现了。你可以使用许多 Linux 工具来高效搜索符合模式的文件，但是 `grep` 是我经常使用的工具。
假设你有一个程序发布代码引用和堆栈跟踪的错误消息。你要在日志中找到这些。 `grep` 不总是最好的方法，但如果文件是一个给定的值，我经常使用 `grep -R`。
越来越多的 IDE 正在实现查找功能，但是如果你正在访问远程系统或出于任何原因没有 GUI，或者如果你想在当前目录递归查找，请使用：`grep -R {searchterm}` 或在支持 `egrep` 别名的系统上，只需将 `-e` 标志添加到命令 `egrep -r {regex-pattern}`。
我在去年给 [Raspbian](https://www.raspbian.org/) 中的 `dhcpcd5` 打补丁时使用了这种技术，这样我就可以在[树莓派基金会](https://www.raspberrypi.org/)发布新的 Debian 时继续操作网络接入点了。
哪些提示可帮助你在 Linux 上更有效地搜索文件？
---
via: <https://opensource.com/article/18/4/how-find-files-linux>
作者：[Lewis Cowles](https://opensource.com/users/lewiscowles1986) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
查看 Linux 发行版名称和版本号的 8 种方法
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/check-find-linux-distribution-name-and-version/
|
如果你加入了一家新公司，要为开发团队安装所需的软件并重启服务，这个时候首先要弄清楚它们运行在什么发行版以及哪个版本的系统上，你才能正确完成后续的工作。
|
/data/attachment/album/201804/28/224918l0adwv0a6vfii1sn.jpg.thumb.jpg
|
/data/attachment/album/201804/28/224918l0adwv0a6vfii1sn.jpg
| true | false | true |
HankChow
| false |
[
"发行版",
"版本"
] |
技术
|
{
"viewnum": 157991,
"commentnum": 5,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "218.247.130.146",
"message": "能不能出一个对比 让大家能比对一下啊",
"username": "来自北京的 Chrome 91.0|Mac 10.15 用户",
"date": "2021-06-08T09:36:07"
},
{
"postip": "218.247.130.146",
"message": "能不能出一个对比 让大家能比对一下啊",
"username": "来自北京的 Chrome 91.0|Mac 10.15 用户",
"date": "2021-06-08T09:36:09"
},
{
"postip": "218.247.130.146",
"message": "能不能出一个对比 让大家能比对一下啊",
"username": "来自北京的 Chrome 91.0|Mac 10.15 用户",
"date": "2021-06-08T09:36:10"
},
{
"postip": "218.247.130.146",
"message": "能不能出一个对比 让大家能比对一下啊",
"username": "来自北京的 Chrome 91.0|Mac 10.15 用户",
"date": "2021-06-08T09:36:11"
},
{
"postip": "117.175.6.172",
"message": "收藏了",
"username": "来自四川绵阳的 Chrome Mobile 92.0|Android 用户",
"date": "2021-08-03T10:49:09"
}
] |
[] |
如果你加入了一家新公司，要为开发团队安装所需的软件并重启服务，这个时候首先要弄清楚它们运行在什么发行版以及哪个版本的系统上，你才能正确完成后续的工作。
| 2018-04-28T22:49:32 | 2018-04-28T22:49:32 | 9,586 |
/article-9586-1.html
|
如果你加入了一家新公司，要为开发团队安装所需的软件并重启服务，这个时候首先要弄清楚它们运行在什么发行版以及哪个版本的系统上，你才能正确完成后续的工作。作为系统管理员，充分了解系统信息是首要的任务。
查看 Linux 发行版名称和版本号有很多种方法。你可能会问，为什么要去了解这些基本信息呢？
因为对于诸如 RHEL、Debian、openSUSE、Arch Linux 这几种主流发行版来说，它们各自拥有不同的包管理器来管理系统上的软件包，如果不知道所使用的是哪一个发行版的系统，在软件包安装的时候就会无从下手，而且由于大多数发行版都是用 systemd 命令而不是 SysVinit 脚本，在重启服务的时候也难以执行正确的命令。
下面来看看可以使用那些基本命令来查看 Linux 发行版名称和版本号。
### 方法总览
* `lsb_release` 命令
* `/etc/*-release` 文件
* `uname` 命令
* `/proc/version` 文件
* `dmesg` 命令
* YUM 或 DNF 命令
* RPM 命令
* APT-GET 命令
### 方法 1： lsb\_release 命令
LSB（<ruby> Linux 标准库 <rt> Linux Standard Base </rt></ruby>）能够打印发行版的具体信息，包括发行版名称、版本号、代号等。
```
# lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description: Ubuntu 16.04.3 LTS
Release: 16.04
Codename: xenial
```
### 方法 2： /etc/\*-release 文件
release 文件通常被视为操作系统的标识。在 `/etc` 目录下放置了很多记录着发行版各种信息的文件，每个发行版都各自有一套这样记录着相关信息的文件。下面是一组在 Ubuntu/Debian 系统上显示出来的文件内容。
```
# cat /etc/issue
Ubuntu 16.04.3 LTS \n \l
# cat /etc/issue.net
Ubuntu 16.04.3 LTS
# cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=16.04
DISTRIB_CODENAME=xenial
DISTRIB_DESCRIPTION="Ubuntu 16.04.3 LTS"
# cat /etc/os-release
NAME="Ubuntu"
VERSION="16.04.3 LTS (Xenial Xerus)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 16.04.3 LTS"
VERSION_ID="16.04"
HOME_URL="http://www.ubuntu.com/"
SUPPORT_URL="http://help.ubuntu.com/"
BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"
VERSION_CODENAME=xenial
UBUNTU_CODENAME=xenial
# cat /etc/debian_version
9.3
```
下面这一组是在 RHEL/CentOS/Fedora 系统上显示出来的文件内容。其中 `/etc/redhat-release` 和 `/etc/system-release` 文件是指向 `/etc/[发行版名称]-release` 文件的一个连接。
```
# cat /etc/centos-release
CentOS release 6.9 (Final)
# cat /etc/fedora-release
Fedora release 27 (Twenty Seven)
# cat /etc/os-release
NAME=Fedora
VERSION="27 (Twenty Seven)"
ID=fedora
VERSION_ID=27
PRETTY_NAME="Fedora 27 (Twenty Seven)"
ANSI_COLOR="0;34"
CPE_NAME="cpe:/o:fedoraproject:fedora:27"
HOME_URL="https://fedoraproject.org/"
SUPPORT_URL="https://fedoraproject.org/wiki/Communicating_and_getting_help"
BUG_REPORT_URL="https://bugzilla.redhat.com/"
REDHAT_BUGZILLA_PRODUCT="Fedora"
REDHAT_BUGZILLA_PRODUCT_VERSION=27
REDHAT_SUPPORT_PRODUCT="Fedora"
REDHAT_SUPPORT_PRODUCT_VERSION=27
PRIVACY_POLICY_URL="https://fedoraproject.org/wiki/Legal:PrivacyPolicy"
# cat /etc/redhat-release
Fedora release 27 (Twenty Seven)
# cat /etc/system-release
Fedora release 27 (Twenty Seven)
```
### 方法 3： uname 命令
uname（unix name 的意思） 是一个打印系统信息的工具，包括内核名称、版本号、系统详细信息以及所运行的操作系统等等。
* **建议阅读：** [6种查看系统 Linux 内核的方法](https://www.2daygeek.com/check-find-determine-running-installed-linux-kernel-version/)
```
# uname -a
Linux localhost.localdomain 4.12.14-300.fc26.x86_64 #1 SMP Wed Sep 20 16:28:07 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
```
以上运行结果说明使用的操作系统版本是 Fedora 26。
### 方法 4： /proc/version 文件
这个文件记录了 Linux 内核的版本、用于编译内核的 gcc 的版本、内核编译的时间，以及内核编译者的用户名。
```
# cat /proc/version
Linux version 4.12.14-300.fc26.x86_64 ([email protected]) (gcc version 7.2.1 20170915 (Red Hat 7.2.1-2) (GCC) ) #1 SMP Wed Sep 20 16:28:07 UTC 2017
```
### 方法 5： dmesg 命令
dmesg（<ruby> 展示信息 <rt> display message </rt></ruby> 或<ruby> 驱动程序信息 <rt> driver message </rt></ruby>）是大多数类 Unix 操作系统上的一个命令，用于打印内核的消息缓冲区的信息。
```
# dmesg | grep "Linux"
[ 0.000000] Linux version 4.12.14-300.fc26.x86_64 ([email protected]) (gcc version 7.2.1 20170915 (Red Hat 7.2.1-2) (GCC) ) #1 SMP Wed Sep 20 16:28:07 UTC 2017
[ 0.001000] SELinux: Initializing.
[ 0.001000] SELinux: Starting in permissive mode
[ 0.470288] SELinux: Registering netfilter hooks
[ 0.616351] Linux agpgart interface v0.103
[ 0.630063] usb usb1: Manufacturer: Linux 4.12.14-300.fc26.x86_64 ehci_hcd
[ 0.688949] usb usb2: Manufacturer: Linux 4.12.14-300.fc26.x86_64 ohci_hcd
[ 2.564554] SELinux: Disabled at runtime.
[ 2.564584] SELinux: Unregistering netfilter hooks
```
### 方法 6： Yum/Dnf 命令
Yum（<ruby> Yellowdog 更新器修改版 <rt> Yellowdog Updater Modified </rt></ruby>）是 Linux 操作系统上的一个包管理工具，而 `yum` 命令被用于一些基于 RedHat 的 Linux 发行版上安装、更新、查找、删除软件包。
* **建议阅读：** [在 RHEL/CentOS 系统上使用 yum 命令管理软件包](https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/)
```
# yum info nano
Loaded plugins: fastestmirror, ovl
Loading mirror speeds from cached hostfile
* base: centos.zswap.net
* extras: mirror2.evolution-host.com
* updates: centos.zswap.net
Available Packages
Name : nano
Arch : x86_64
Version : 2.3.1
Release : 10.el7
Size : 440 k
Repo : base/7/x86_64
Summary : A small text editor
URL : http://www.nano-editor.org
License : GPLv3+
Description : GNU nano is a small and friendly text editor.
```
下面的 `yum repolist` 命令执行后显示了 yum 的基础源仓库、额外源仓库、更新源仓库都来自 CentOS 7 仓库。
```
# yum repolist
Loaded plugins: fastestmirror, ovl
Loading mirror speeds from cached hostfile
* base: centos.zswap.net
* extras: mirror2.evolution-host.com
* updates: centos.zswap.net
repo id repo name status
base/7/x86_64 CentOS-7 - Base 9591
extras/7/x86_64 CentOS-7 - Extras 388
updates/7/x86_64 CentOS-7 - Updates 1929
repolist: 11908
```
使用 `dnf` 命令也同样可以查看发行版名称和版本号。
* **建议阅读：** [在 Fedora 系统上使用 DNF（YUM 的一个分支）命令管理软件包](https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/)
```
# dnf info nano
Last metadata expiration check: 0:01:25 ago on Thu Feb 15 01:59:31 2018.
Installed Packages
Name : nano
Version : 2.8.7
Release : 1.fc27
Arch : x86_64
Size : 2.1 M
Source : nano-2.8.7-1.fc27.src.rpm
Repo : @System
From repo : fedora
Summary : A small text editor
URL : https://www.nano-editor.org
License : GPLv3+
Description : GNU nano is a small and friendly text editor.
```
### 方法 7： RPM 命令
RPM（<ruby> 红帽包管理器 <rt> RedHat Package Manager </rt></ruby>）是在 CentOS、Oracle Linux、Fedora 这些基于 RedHat 的操作系统上的一个强大的命令行包管理工具，同样也可以帮助我们查看系统的版本信息。
* **建议阅读：** [在基于 RHEL 的系统上使用 RPM 命令管理软件包](https://www.2daygeek.com/rpm-command-examples/)
```
# rpm -q nano
nano-2.8.7-1.fc27.x86_64
```
### 方法 8： APT-GET 命令
Apt-Get（<ruby> 高级打包工具 <rt> Advanced Packaging Tool </rt></ruby>）是一个强大的命令行工具，可以自动下载安装新软件包、更新已有的软件包、更新软件包列表索引，甚至更新整个 Debian 系统。
* **建议阅读：** [在基于 Debian 的系统上使用 Apt-Get 和 Apt-Cache 命令管理软件包](https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/)
```
# apt-cache policy nano
nano:
Installed: 2.5.3-2ubuntu2
Candidate: 2.5.3-2ubuntu2
Version table:
* 2.5.3-2ubuntu2 500
500 http://nova.clouds.archive.ubuntu.com/ubuntu xenial-updates/main amd64 Packages
100 /var/lib/dpkg/status
2.5.3-2 500
500 http://nova.clouds.archive.ubuntu.com/ubuntu xenial/main amd64 Packages
```
---
via: <https://www.2daygeek.com/check-find-linux-distribution-name-and-version/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
gdb 如何调用函数？
|
Julia Evans
|
https://jvns.ca/blog/2018/01/04/how-does-gdb-call-functions/
|
我发现我可以从 gdb 上调用 C 函数。这看起来很酷，因为在过去我认为 gdb 最多只是一个只读调试工具。
|
/data/attachment/album/201804/29/093812hpupdpdmp0dwh55u.jpg.thumb.jpg
|
/data/attachment/album/201804/29/093812hpupdpdmp0dwh55u.jpg
| true | false | true |
ucasFL
| false |
[
"gdb",
"调试"
] |
软件开发
|
{
"viewnum": 10410,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我发现我可以从 gdb 上调用 C 函数。这看起来很酷，因为在过去我认为 gdb 最多只是一个只读调试工具。
| 2018-04-29T09:38:16 | 2018-04-29T09:38:16 | 9,588 |
/article-9588-1.html
|
（之前的 gdb 系列文章：[gdb 如何工作（2016）](/article-9491-1.html) 和[三步上手 gdb（2014）](/article-9276-1.html)）
在这周，我发现我可以从 gdb 上调用 C 函数。这看起来很酷，因为在过去我认为 gdb 最多只是一个只读调试工具。
我对 gdb 能够调用函数感到很吃惊。正如往常所做的那样，我在 [Twitter](https://twitter.com/b0rk/status/948060808243765248) 上询问这是如何工作的。我得到了大量的有用答案。我最喜欢的答案是 [Evan Klitzke 的示例 C 代码](https://github.com/eklitzke/ptrace-call-userspace/blob/master/call_fprintf.c)，它展示了 gdb 如何调用函数。代码能够运行，这很令人激动！
我（通过一些跟踪和实验）认为那个示例 C 代码和 gdb 实际上如何调用函数不同。因此，在这篇文章中，我将会阐述 gdb 是如何调用函数的，以及我是如何知道的。
关于 gdb 如何调用函数，还有许多我不知道的事情，并且，在这儿我写的内容有可能是错误的。
### 从 gdb 中调用 C 函数意味着什么？
在开始讲解这是如何工作之前，我先快速的谈论一下我是如何发现这件令人惊讶的事情的。
假如，你已经在运行一个 C 程序（目标程序）。你可以运行程序中的一个函数，只需要像下面这样做：
* 暂停程序（因为它已经在运行中）
* 找到你想调用的函数的地址（使用符号表）
* 使程序（目标程序）跳转到那个地址
* 当函数返回时，恢复之前的指令指针和寄存器
通过符号表来找到想要调用的函数的地址非常容易。下面是一段非常简单但能够工作的代码，我在 Linux 上使用这段代码作为例子来讲解如何找到地址。这段代码使用 [elf crate](https://cole14.github.io/rust-elf)。如果我想找到 PID 为 2345 的进程中的 `foo` 函数的地址，那么我可以运行 `elf_symbol_value("/proc/2345/exe", "foo")`。
```
fn elf_symbol_value(file_name: &str, symbol_name: &str) -> Result<u64, Box<std::error::Error>> {
// 打开 ELF 文件
let file = elf::File::open_path(file_name).ok().ok_or("parse error")?;
// 在所有的段 & 符号中循环，直到找到正确的那个
let sections = &file.sections;
for s in sections {
for sym in file.get_symbols(&s).ok().ok_or("parse error")? {
if sym.name == symbol_name {
return Ok(sym.value);
}
}
}
None.ok_or("No symbol found")?
}
```
这并不能够真的发挥作用，你还需要找到文件的内存映射，并将符号偏移量加到文件映射的起始位置。找到内存映射并不困难，它位于 `/proc/PID/maps` 中。
总之，找到想要调用的函数地址对我来说很直接，但是其余部分（改变指令指针，恢复寄存器等）看起来就不这么明显了。
### 你不能仅仅进行跳转
我已经说过，你不能够仅仅找到你想要运行的那个函数地址，然后跳转到那儿。我在 gdb 中尝试过那样做（`jump foo`），然后程序出现了段错误。毫无意义。
### 如何从 gdb 中调用 C 函数
首先，这是可能的。我写了一个非常简洁的 C 程序，它所做的事只有 `sleep` 1000 秒，把这个文件命名为 `test.c` ：
```
#include <unistd.h>
int foo() {
return 3;
}
int main() {
sleep(1000);
}
```
接下来，编译并运行它：
```
$ gcc -o test test.c
$ ./test
```
最后，我们使用 gdb 来跟踪 `test` 这一程序：
```
$ sudo gdb -p $(pgrep -f test)
(gdb) p foo()
$1 = 3
(gdb) quit
```
我运行 `p foo()` 然后它运行了这个函数！这非常有趣。
### 这有什么用？
下面是一些可能的用途：
* 它使得你可以把 gdb 当成一个 C 应答式程序（REPL），这很有趣，我想对开发也会有用
* 在 gdb 中进行调试的时候展示/浏览复杂数据结构的功能函数（感谢 [@invalidop](https://twitter.com/invalidop/status/949161146526781440)）
* [在进程运行时设置一个任意的名字空间](https://github.com/baloo/setns/blob/master/setns.c)（我的同事 [nelhage](https://github.com/nelhage) 对此非常惊讶）
* 可能还有许多我所不知道的用途
### 它是如何工作的
当我在 Twitter 上询问从 gdb 中调用函数是如何工作的时，我得到了大量有用的回答。许多答案是“你从符号表中得到了函数的地址”，但这并不是完整的答案。
有个人告诉了我两篇关于 gdb 如何工作的系列文章：[原生调试：第一部分](https://www.cl.cam.ac.uk/%7Esrk31/blog/2016/02/25/#native-debugging-part-1)，[原生调试：第二部分](https://www.cl.cam.ac.uk/%7Esrk31/blog/2017/01/30/#native-debugging-part-2)。第一部分讲述了 gdb 是如何调用函数的（指出了 gdb 实际上完成这件事并不简单，但是我将会尽力）。
步骤列举如下：
1. 停止进程
2. 创建一个新的栈框（远离真实栈）
3. 保存所有寄存器
4. 设置你想要调用的函数的寄存器参数
5. 设置栈指针指向新的<ruby> 栈框 <rt> stack frame </rt></ruby>
6. 在内存中某个位置放置一条陷阱指令
7. 为陷阱指令设置返回地址
8. 设置指令寄存器的值为你想要调用的函数地址
9. 再次运行进程！
（LCTT 译注：如果将这个调用的函数看成一个单独的线程，gdb 实际上所做的事情就是一个简单的线程上下文切换）
我不知道 gdb 是如何完成这些所有事情的，但是今天晚上，我学到了这些所有事情中的其中几件。
#### 创建一个栈框
如果你想要运行一个 C 函数，那么你需要一个栈来存储变量。你肯定不想继续使用当前的栈。准确来说，在 gdb 调用函数之前（通过设置函数指针并跳转），它需要设置栈指针到某个地方。
这儿是 Twitter 上一些关于它如何工作的猜测：
>
> 我认为它在当前栈的栈顶上构造了一个新的栈框来进行调用！
>
>
>
以及
>
> 你确定是这样吗？它应该是分配一个伪栈，然后临时将 sp （栈指针寄存器）的值改为那个栈的地址。你可以试一试，你可以在那儿设置一个断点，然后看一看栈指针寄存器的值，它是否和当前程序寄存器的值相近？
>
>
>
我通过 gdb 做了一个试验：
```
(gdb) p $rsp
$7 = (void *) 0x7ffea3d0bca8
(gdb) break foo
Breakpoint 1 at 0x40052a
(gdb) p foo()
Breakpoint 1, 0x000000000040052a in foo ()
(gdb) p $rsp
$8 = (void *) 0x7ffea3d0bc00
```
这看起来符合“gdb 在当前栈的栈顶构造了一个新的栈框”这一理论。因为栈指针（`$rsp`）从 `0x7ffea3d0bca8` 变成了 `0x7ffea3d0bc00` —— 栈指针从高地址往低地址长。所以 `0x7ffea3d0bca8` 在 `0x7ffea3d0bc00` 的后面。真是有趣！
所以，看起来 gdb 只是在当前栈所在位置创建了一个新的栈框。这令我很惊讶！
#### 改变指令指针
让我们来看一看 gdb 是如何改变指令指针的！
```
(gdb) p $rip
$1 = (void (*)()) 0x7fae7d29a2f0 <__nanosleep_nocancel+7>
(gdb) b foo
Breakpoint 1 at 0x40052a
(gdb) p foo()
Breakpoint 1, 0x000000000040052a in foo ()
(gdb) p $rip
$3 = (void (*)()) 0x40052a <foo+4>
```
的确是！指令指针从 `0x7fae7d29a2f0` 变为了 `0x40052a`（`foo` 函数的地址）。
我盯着输出看了很久，但仍然不理解它是如何改变指令指针的，但这并不影响什么。
#### 如何设置断点
上面我写到 `break foo` 。我跟踪 gdb 运行程序的过程，但是没有任何发现。
下面是 gdb 用来设置断点的一些系统调用。它们非常简单。它把一条指令用 `cc` 代替了（这告诉我们 `int3` 意味着 `send SIGTRAP` [https://defuse.ca/online-x86-assembler.html](https://defuse.ca/online-x86-assembler.htm)），并且一旦程序被打断了，它就把指令恢复为原先的样子。
我在函数 `foo` 那儿设置了一个断点，地址为 `0x400528` 。
`PTRACE_POKEDATA` 展示了 gdb 如何改变正在运行的程序。
```
// 改变 0x400528 处的指令
25622 ptrace(PTRACE_PEEKTEXT, 25618, 0x400528, [0x5d00000003b8e589]) = 0
25622 ptrace(PTRACE_POKEDATA, 25618, 0x400528, 0x5d00000003cce589) = 0
// 开始运行程序
25622 ptrace(PTRACE_CONT, 25618, 0x1, SIG_0) = 0
// 当到达断点时获取一个信号
25622 ptrace(PTRACE_GETSIGINFO, 25618, NULL, {si_signo=SIGTRAP, si_code=SI_KERNEL, si_value={int=-1447215360, ptr=0x7ffda9bd3f00}}) = 0
// 将 0x400528 处的指令更改为之前的样子
25622 ptrace(PTRACE_PEEKTEXT, 25618, 0x400528, [0x5d00000003cce589]) = 0
25622 ptrace(PTRACE_POKEDATA, 25618, 0x400528, 0x5d00000003b8e589) = 0
```
#### 在某处放置一条陷阱指令
当 gdb 运行一个函数的时候，它也会在某个地方放置一条陷阱指令。这是其中一条。它基本上是用 `cc` 来替换一条指令（`int3`）。
```
5908 ptrace(PTRACE_PEEKTEXT, 5810, 0x7f6fa7c0b260, [0x48f389fd89485355]) = 0
5908 ptrace(PTRACE_PEEKTEXT, 5810, 0x7f6fa7c0b260, [0x48f389fd89485355]) = 0
5908 ptrace(PTRACE_POKEDATA, 5810, 0x7f6fa7c0b260, 0x48f389fd894853cc) = 0
```
`0x7f6fa7c0b260` 是什么？我查看了进程的内存映射，发现它位于 `/lib/x86_64-linux-gnu/libc-2.23.so` 中的某个位置。这很奇怪，为什么 gdb 将陷阱指令放在 libc 中？
让我们看一看里面的函数是什么，它是 `__libc_siglongjmp` 。其他 gdb 放置陷阱指令的地方的函数是 `__longjmp` 、`___longjmp_chk` 、`dl_main` 和 `_dl_close_worker` 。
为什么？我不知道！也许出于某种原因，当函数 `foo()` 返回时，它调用 `longjmp` ，从而 gdb 能够进行返回控制。我不确定。
### gdb 如何调用函数是很复杂的！
我将要在这儿停止了（现在已经凌晨 1 点），但是我知道的多一些了！
看起来“gdb 如何调用函数”这一问题的答案并不简单。我发现这很有趣并且努力找出其中一些答案，希望你也能够找到。
我依旧有很多未回答的问题，关于 gdb 是如何完成这些所有事的，但是可以了。我不需要真的知道关于 gdb 是如何工作的所有细节，但是我很开心，我有了一些进一步的理解。
---
via: <https://jvns.ca/blog/2018/01/04/how-does-gdb-call-functions/>
作者：[Julia Evans](https://jvns.ca/) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
构建开源硬件的 5 个关键点
|
Joshua Pearce
|
https://opensource.com/article/18/2/5-steps-creating-successful-open-hardware
|
最大化你的项目影响。
|
/data/attachment/album/201804/29/100925ok5byly3y4ky3b8l.png.thumb.jpg
|
/data/attachment/album/201804/29/100925ok5byly3y4ky3b8l.png
| true | false | true |
kennethXia
| false |
[
"开源硬件",
"硬件"
] |
观点
|
{
"viewnum": 4616,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
最大化你的项目影响。
| 2018-04-29T10:09:22 | 2018-04-29T10:09:22 | 9,589 |
/article-9589-1.html
|
>
> 最大化你的项目影响。
>
>
>
科学社区正在加速拥抱<ruby> 自由及开源硬件 <rt> Free and Open Source Hardware </rt></ruby>（[FOSH](https://opensource.com/business/16/4/how-calculate-open-source-hardware-return-investment)）。 研究员正忙于[改进他们自己的装备](https://opensource.com/node/16840)并创造数以百计的基于分布式数字制造模型的设备来推动他们的研究。
热衷于 FOSH 的主要原因还是钱： 有研究表明，和专用设备相比，FOSH 可以[节省 90% 到 99% 的花费](http://www.appropedia.org/Open-source_Lab)。基于[开源硬件商业模式](https://www.academia.edu/32004903/Emerging_Business_Models_for_Open_Source_Hardware)的科学 FOSH 的商业化已经推动其快速地发展为一个新的工程领域，并为此定期[举行 GOSH 年会](http://openhardware.science/)。
特别的是，不止一本，而是关于这个主题的[两本学术期刊]：[Journal of Open Hardware] （由 Ubiquity 出版，一个新的自由访问出版商，同时出版了 [Journal of Open Research Software](https://openresearchsoftware.metajnl.com/) ）以及 [HardwareX](https://www.journals.elsevier.com/hardwarex)（由 Elsevier 出版的一种[自由访问期刊](https://opensource.com/node/30041)，它是世界上最大的学术出版商之一）。
由于学术社区的支持，科学 FOSH 的开发者在获取制作乐趣并推进科学快速发展的同时获得学术声望。
### 科学 FOSH 的5个步骤
Shane Oberloier 和我在名为 Designs 的自由访问工程期刊上共同发表了一篇关于设计 FOSH 科学设备原则的[文章](https://www.academia.edu/35603319/General_Design_Procedure_for_Free_and_Open-Source_Hardware_for_Scientific_Equipment)。我们以滑动式烘干机为例，制造成本低于 20 美元，仅是专用设备价格的三百分之一。[科学](https://opensource.com/business/16/4/how-calculate-open-source-hardware-return-investment)和[医疗](https://www.academia.edu/35382852/Maximizing_Returns_for_Public_Funding_of_Medical_Research_with_Open_source_Hardware)设备往往比较复杂，开发 FOSH 替代品将带来巨大的回报。
我总结了 5 个步骤（包括 6 条设计原则），它们在 Shane Oberloier 和我发表的文章里有详细阐述。这些设计原则也可以推广到非科学设备，而且制作越复杂的设计越能带来更大的潜在收益。
如果你对科学项目的开源硬件设计感兴趣，这些步骤将使你的项目的影响最大化。
1. 评估类似现有工具的功能，你的 FOSH 设计目标应该针对实际效果而不是现有的设计（LCTT 译注：作者的意思应该是不要被现有设计缚住手脚）。必要的时候需进行概念证明。
2. 使用下列设计原则：
* 在设备生产中，仅使用自由和开源的软件工具链（比如，开源的 CAD 工具，例如 [OpenSCAD](http://www.openscad.org/)、 [FreeCAD](https://www.freecadweb.org/) 或 [Blender](https://www.blender.org/)）和开源硬件。
* 尝试减少部件的数量和类型并降低工具的复杂度
* 减少材料的数量和制造成本。
* 尽量使用能够分发的部件或使用方便易得的工具（比如 [RepRap 3D 打印机](http://reprap.org/)）进行部件的数字化生产。
* 对部件进行[参数化设计](https://en.wikipedia.org/wiki/Parametric_design)，这使他人可以对你的设计进行个性化改动。相较于特例化设计，参数化设计会更有用。在未来的项目中，使用者可以通过修改核心参数来继续利用它们。
* 所有不能使用现有的开源硬件以分布式的方式轻松且经济地制造的零件，必须选择现货产品以方便采购。
3. 验证功能设计。
4. 提供关于设计、生产、装配、校准和操作的详尽设备文档。包括原始设计文件而不仅仅是用于生产的。<ruby> 开源硬件协会 <rt> Open Source Hardware Association </rt></ruby>对于开源设计的发布和文档化有额外的[指南](https://www.oshwa.org/sharing-best-practices/)，总结如下：
* 以通用的形式分享设计文件。
* 提供详尽的材料清单，包括价格和采购信息。
* 如果涉及软件，确保代码对大众来说清晰易懂。
* 作为生产时的参考，必须提供足够的照片，以确保没有任何被遮挡的部分。
* 在描述方法的章节，整个制作过程必须被细化成简单步骤以便复制此设计。
* 在线上分享并指定许可证。这为用户提供了合理使用该设计的信息。
5. 主动分享！为了使 FOSH 发扬光大，设计必须被广泛、频繁和有效地分享以提升它们的存在感。所有的文档应该在自由访问文献中发表，并与适当的社区共享。<ruby> <a href="https://osf.io/"> 开源科学框架 </a> <rt> Open Science Framework </rt></ruby>是一个值得考虑的优雅的通用存储库，它由<ruby> 开源科学中心 <rt> Center for Open Science </rt></ruby>主办，该中心设置为接受任何类型的文件并处理大型数据集。
这篇文章得到了 [Fulbright Finland](http://www.fulbright.fi/en) 的支持，该公司赞助了芬兰 Fulbright-Aalto 大学的特聘校席 Joshua Pearce 在开源科学硬件方面的研究工作。
---
via: <https://opensource.com/article/18/2/5-steps-creating-successful-open-hardware>
作者：[Joshua Pearce](https://opensource.com/users/jmpearce) 译者：[kennethXia](https://github.com/kennethXia) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Yoda：您的 Linux 系统命令行个人助理
|
Sk
|
https://www.ostechnix.com/yoda-the-command-line-personal-assistant-for-your-linux-system/
|
Yoda 是一个命令行个人助理，可以帮助您在 Linux 中完成一些琐碎的任务。它是用 Python 编写的一个自由开源应用程序。
|
/data/attachment/album/201804/29/174213fd5p3ppx4uu3napu.png.thumb.jpg
|
/data/attachment/album/201804/29/174213fd5p3ppx4uu3napu.png
| true | false | true |
amwps290
| false |
[
"虚拟助手"
] |
分享
|
{
"viewnum": 6883,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Yoda 是一个命令行个人助理，可以帮助您在 Linux 中完成一些琐碎的任务。它是用 Python 编写的一个自由开源应用程序。
| 2018-04-29T17:42:10 | 2018-04-29T17:42:10 | 9,590 |
/article-9590-1.html
|
不久前，我们介绍了一个名为 [“Betty”](https://www.ostechnix.com/betty-siri-like-commandline-virtual-assistant-linux/) 的命令行虚拟助手。今天，我偶然发现了一个类似的实用程序，叫做 “Yoda”。Yoda 是一个命令行个人助理，可以帮助您在 Linux 中完成一些琐碎的任务。它是用 Python 编写的一个自由开源应用程序。在本指南中，我们将了解如何在 GNU/Linux 中安装和使用 Yoda。
### 安装 Yoda，命令行私人助理。
Yoda 需要 Python 2 和 PIP 。如果在您的 Linux 中没有安装 PIP，请参考下面的指南来安装它。只要确保已经安装了 python2-pip 。Yoda 可能不支持 Python 3。
* [如何使用 pip 管理 Python 包](https://www.ostechnix.com/manage-python-packages-using-pip/)
注意：我建议你在 Python 虚拟环境下试用 Yoda。 不仅仅是 Yoda，应该总在虚拟环境中尝试任何 Python 应用程序，让它们不会干扰全局安装的软件包。 您可以按照上文链接中标题为“创建虚拟环境”一节中所述设置虚拟环境。
在您的系统上安装了 `pip` 之后，使用下面的命令克隆 Yoda 库。
```
$ git clone https://github.com/yoda-pa/yoda
```
上面的命令将在当前工作目录中创建一个名为 `yoda` 的目录，并在其中克隆所有内容。转到 `yoda` 目录：
```
$ cd yoda/
```
运行以下命令安装 Yoda 应用程序。
```
$ pip install .
```
请注意最后的点（`.`）。 现在，所有必需的软件包将被下载并安装。
### 配置 Yoda
首先，设置配置以将您的信息保存在本地系统上。
运行下面的命令：
```
$ yoda setup new
```
填写下列的问题：
```
Enter your name:
Senthil Kumar
What's your email id?
[email protected]
What's your github username?
sk
Enter your github password:
Password:
Where shall your config be stored? (Default: ~/.yoda/)
A configuration file already exists. Are you sure you want to overwrite it? (y/n)
y
```
你的密码在加密后保存在配置文件中，所以不用担心。
要检查当前配置，请运行：
```
$ yoda setup check
```
你会看到如下的输出。
```
Name: Senthil Kumar
Email: sk@senthilkumar.com
Github username: sk
```
默认情况下，您的信息存储在 `~/.yoda` 目录中。
要删除现有配置，请执行以下操作：
```
$ yoda setup delete
```
### 用法
Yoda 包含一个简单的聊天机器人。您可以使用下面的聊天命令与它交互。
```
$ yoda chat who are you
```
样例输出:
```
Yoda speaks:
I'm a virtual agent
$ yoda chat how are you
Yoda speaks:
I'm doing very well. Thanks!
```
以下是我们可以用 Yoda 做的事情：
#### 测试网络速度
让我们问一下 Yoda 关于互联网速度的问题。运行：
```
$ yoda speedtest
Speed test results:
Ping: 108.45 ms
Download: 0.75 Mb/s
Upload: 1.95 Mb/s
```
#### 缩短和展开网址
Yoda 还有助于缩短任何网址：
```
$ yoda url shorten https://www.ostechnix.com/
Here's your shortened URL:
https://goo.gl/hVW6U0
```
要展开缩短的网址：
```
$ yoda url expand https://goo.gl/hVW6U0
Here's your original URL:
https://www.ostechnix.com/
```
#### 阅读 Hacker News
我是 Hacker News 网站的常客。 如果你像我一样，你可以使用 Yoda 从下面的 Hacker News 网站阅读新闻。
```
$ yoda hackernews
News-- 1/513
Title-- Show HN: a Yelp for iOS developers
Description-- I came up with this idea "a Yelp for developers" when talking with my colleagues. My hypothesis is that, it would be very helpful if we know more about a library before choosing to use it. It's similar to that we want to know more about a restaurant by checki…
url-- https://news.ycombinator.com/item?id=16636071
Continue? [press-"y"]
```
Yoda 将一次显示一个项目。 要阅读下一条新闻，只需输入 `y` 并按下回车。
#### 管理个人日记
我们也可以保留个人日记以记录重要事件。
使用命令创建一个新的日记：
```
$ yoda diary nn
Input your entry for note:
Today I learned about Yoda
```
要创建新笔记，请再次运行上述命令。
查看所有笔记：
```
$ yoda diary notes
Today's notes:
----------------
Time | Note
--------|-----
16:41:41| Today I learned about Yoda
```
不仅仅是笔记，Yoda 还可以帮助你创建任务。
要创建新任务，请运行：
```
$ yoda diary nt
Input your entry for task:
Write an article about Yoda and publish it on OSTechNix
```
要查看任务列表，请运行：
```
$ yoda diary tasks
Today's agenda:
----------------
Status | Time | Text
-------|---------|-----
O | 16:44:03: Write an article about Yoda and publish it on OSTechNix
----------------
Summary:
----------------
Incomplete tasks: 1
Completed tasks: 0
```
正如你在上面看到的，我有一个未完成的任务。 要将其标记为已完成，请运行以下命令并输入已完成的任务序列号并按下回车键：
```
$ yoda diary ct
Today's agenda:
----------------
Number | Time | Task
-------|---------|-----
1 | 16:44:03: Write an article about Yoda and publish it on OSTechNix
Enter the task number that you would like to set as completed
1
```
您可以随时使用命令分析当前月份的任务：
```
$ yoda diary analyze
Percentage of incomplete task : 0
Percentage of complete task : 100
Frequency of adding task (Task/Day) : 3
```
有时候，你可能想要记录一个关于你爱的或者敬佩的人的个人资料。
#### 记录关于爱人的笔记
首先，您需要设置配置来存储朋友的详细信息。 请运行：
```
$ yoda love setup
```
输入你的朋友的详细信息：
```
Enter their name:
Abdul Kalam
Enter sex(M/F):
M
Where do they live?
Rameswaram
```
要查看此人的详细信息，请运行：
```
$ yoda love status
{'place': 'Rameswaram', 'name': 'Abdul Kalam', 'sex': 'M'}
```
要添加你的爱人的生日：
```
$ yoda love addbirth
Enter birthday
15-10-1931
```
查看生日：
```
$ yoda love showbirth
Birthday is 15-10-1931
```
你甚至可以添加关于该人的笔记：
```
$ yoda love note
Avul Pakir Jainulabdeen Abdul Kalam better known as A. P. J. Abdul Kalam, was the 11th President of India from 2002 to 2007.
```
您可以使用命令查看笔记：
```
$ yoda love notes
Notes:
1: Avul Pakir Jainulabdeen Abdul Kalam better known as A. P. J. Abdul Kalam, was the 11th President of India from 2002 to 2007.
```
你也可以写下这个人喜欢的东西：
```
$ yoda love like
Add things they like
Physics, Aerospace
Want to add more things they like? [y/n]
n
```
要查看他们喜欢的东西，请运行：
```
$ yoda love likes
Likes:
1: Physics, Aerospace
```
#### 跟踪资金费用
您不需要单独的工具来维护您的财务支出。 Yoda 会替您处理好。
首先，使用命令设置您的金钱支出配置：
```
$ yoda money setup
```
输入您的货币代码和初始金额：
```
Enter default currency code:
INR
{u'USD': 0.015338, u'IDR': 211.06, u'BGN': 0.024436, u'ISK': 1.5305, u'ILS': 0.053402, u'GBP': 0.010959, u'DKK': 0.093063, u'CAD': 0.020041, u'MXN': 0.28748, u'HUF': 3.8873, u'RON': 0.058302, u'MYR': 0.060086, u'SEK': 0.12564, u'SGD': 0.020208, u'HKD': 0.12031, u'AUD': 0.019908, u'CHF': 0.014644, u'KRW': 16.429, u'CNY': 0.097135, u'TRY': 0.06027, u'HRK': 0.092986, u'NZD': 0.021289, u'THB': 0.47854, u'EUR': 0.012494, u'NOK': 0.11852, u'RUB': 0.88518, u'JPY': 1.6332, u'CZK': 0.31764, u'BRL': 0.050489, u'PLN': 0.052822, u'PHP': 0.79871, u'ZAR': 0.1834}
₹
Indian rupee
Enter initial amount:
10000
```
要查看金钱配置，只需运行：
```
$ yoda money status
{'initial_money': 10000, 'currency_code': 'INR'}
```
让我们假设你买了一本价值 250 卢比的书。 要添加此费用，请运行：
```
$ yoda money exp
Spend 250 INR on books
output:
```
要查看花费，请运行：
```
$ yoda money exps
2018-03-21 17:12:31 INR 250 books
```
#### 创建想法列表
创建一个新的想法：
```
$ yoda ideas add --task <task_name> --inside <project_name>
```
列出想法：
```
$ yoda ideas show
```
从任务中移除一个想法：
```
$ yoda ideas remove --task <task_name> --inside <project_name>
```
要完全删除这个想法，请运行：
```
$ yoda ideas remove --project <project_name>
```
#### 学习英语词汇
Yoda 帮助你学习随机英语单词并追踪你的学习进度。
要学习一个新单词，请输入：
```
$ yoda vocabulary word
```
它会随机显示一个单词。 按回车键显示单词的含义。 再一次，Yoda 问你是否已经知道这个词的意思。 如果您已经知道，请输入“是”。 如果您不知道，请输入“否”。 这可以帮助你跟踪你的进度。 使用以下命令来了解您的进度。
```
$ yoda vocabulary accuracy
```
此外，Yoda 可以帮助您做其他一些事情，比如找到单词的定义和创建插卡以轻松学习任何内容。 有关更多详细信息和可用选项列表，请参阅帮助部分。
```
$ yoda --help
```
更多好的东西来了。请继续关注!
干杯!
---
via: <https://www.ostechnix.com/yoda-the-command-line-personal-assistant-for-your-linux-system/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
假装很忙的三个命令行工具
|
Jason Baker
|
https://opensource.com/article/18/2/command-line-tools-productivity
|
有时候你很忙。而有时候你只是需要看起来很忙，就像电影中的黑客一样。有一些开源工具就是干这个的。
|
/data/attachment/album/201804/29/182852stve7idzo75mootz.jpg.thumb.jpg
|
/data/attachment/album/201804/29/182852stve7idzo75mootz.jpg
| true | false | true |
wyxplus
| true |
[
"黑客",
"终端"
] |
分享
|
{
"viewnum": 17432,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有时候你很忙。而有时候你只是需要看起来很忙，就像电影中的黑客一样。有一些开源工具就是干这个的。
| 2018-04-30T10:24:00 | 2018-04-30T10:24:00 | 9,591 |
/article-9591-1.html
|
>
> 有时候你很忙。而有时候你只是需要看起来很忙，就像电影中的黑客一样。有一些开源工具就是干这个的。
>
>
>
如果在你在消磨时光时看过谍战片、动作片或犯罪片，那么你就会清晰地在脑海中勾勒出黑客的电脑屏幕的样子。就像是在《黑客帝国》电影中，[代码雨](http://tvtropes.org/pmwiki/pmwiki.php/Main/MatrixRainingCode) 一样的十六进制数字流，又或是一排排快速移动的代码。
也许电影中出现一幅世界地图，其中布满了闪烁的光点和一些快速更新的图表。不可或缺的，也可能有 3D 旋转的几何形状。甚至，这一切都会显示在一些完全不符合人类习惯的数量荒谬的显示屏上。 在《剑鱼行动》电影中黑客就使用了七个显示屏。
当然，我们这些从事计算机行业的人一下子就明白这完全是胡说八道。虽然在我们中，许多人都有双显示器（或更多），但一个闪烁的数据仪表盘、刷新的数据通常和专注工作是相互矛盾的。编写代码、项目管理和系统管理与日常工作不同。我们遇到的大多数情况，为了解决问题，都需要大量的思考，与客户沟通所得到一些研究和组织的资料，然后才是少许的 [敲代码](http://tvtropes.org/pmwiki/pmwiki.php/Main/RapidFireTyping)。
然而，这与我们想追求电影中的效果并不矛盾，也许，我们只是想要看起来“忙于工作”而已。
**注：当然，我仅仅是在此胡诌。**如果您公司实际上是根据您繁忙程度来评估您的工作时，无论您是蓝领还是白领，都需要亟待解决这样的工作文化。假装工作很忙是一种有毒的文化，对公司和员工都有害无益。
这就是说，让我们找些乐子，用一些老式的、毫无意义的数据和代码片段填充我们的屏幕。（当然，数据或许有意义，但不是在这种没有上下文的环境中。）当然有一些用于此用途的有趣的图形界面程序，如 [hackertyper.net](https://hackertyper.net/) 或是 [GEEKtyper.com](http://geektyper.com) 网站（LCTT 译注：是在线假装黑客操作的网站），为什么不使用标准的 Linux 终端程序呢？对于更老派的外观，可以考虑使用 [酷炫复古终端](https://github.com/Swordfish90/cool-retro-term)，这听起来确实如此：一个酷炫的复古终端程序。我将在下面的屏幕截图中使用酷炫复古终端，因为它看起来的确很酷。
### Genact
我们来看下第一个工具——Genact。Genact 的原理很简单，就是慢慢地无尽循环播放您选择的一个序列，让您的代码在您外出休息时“编译”。由您来决定播放顺序，但是其中默认包含数字货币挖矿模拟器、Composer PHP 依赖关系管理工具、内核编译器、下载器、内存转储等工具。其中我最喜欢的是其中类似《模拟城市》加载显示。所以只要没有人仔细检查，你可以花一整个下午等待您的电脑完成进度条。
Genact [发布了](https://github.com/svenstaro/genact/releases) 支持 Linux、OS X 和 Windows 的版本。并且其 Rust [源代码](https://github.com/svenstaro/genact) 在 GitHub 上开源（遵循 [MIT 许可证](https://github.com/svenstaro/genact/blob/master/LICENSE)）。
### Hollywood
Hollywood 采取更直接的方法。它本质上是在终端中创建一个随机的数量和配置的分屏，并启动那些看起来很繁忙的应用程序，如 htop、目录树、源代码文件等，并每隔几秒将其切换。它被组织成一个 shell 脚本，所以可以非常容易地根据需求进行修改。
Hollywood的 [源代码](https://github.com/dustinkirkland/hollywood) 在 GitHub 上开源（遵循 [Apache 2.0 许可证](http://www.apache.org/licenses/LICENSE-2.0)）。
### Blessed-contrib
Blessed-contrib 是我个人最喜欢的应用，实际上并不是为了这种表演而专门设计的应用。相反地，它是一个基于 Node.js 的终端仪表盘的构建库的演示文件。与其他两个不同，实际上我已经在工作中使用 Blessed-contrib 的库，而不是用于假装忙于工作。因为它是一个相当有用的库，并且可以使用一组在命令行显示信息的小部件。与此同时填充虚拟数据也很容易，所以可以很容易实现你在计算机上模拟《战争游戏》的想法。
Blessed-contrib 的[源代码](https://github.com/yaronn/blessed-contrib)在 GitHub 上（遵循 [MIT 许可证](http://opensource.org/licenses/MIT)）。
当然，尽管这些工具很容易使用，但也有很多其他的方式使你的屏幕丰富。在你看到电影中最常用的工具之一就是Nmap，这是一个开源的网络安全扫描工具。实际上，它被广泛用作展示好莱坞电影中，黑客电脑屏幕上的工具。因此 Nmap 的开发者创建了一个 [页面](https://nmap.org/movies/)，列出了它出现在其中的一些电影，从《黑客帝国 2：重装上阵》到《谍影重重3》、《龙纹身的女孩》，甚至《虎胆龙威 4》。
当然，您可以创建自己的组合，使用终端多路复用器（如 `screen` 或 `tmux`）启动您希望使用的任何数据切分程序。
那么，您是如何使用您的屏幕的呢？
---
via: <https://opensource.com/article/18/2/command-line-tools-productivity>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 译者：[wyxplus](https://github.com/wyxplus) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Tripwire 保护 Linux 文件系统
|
Michael Kwaku Aboagye
|
https://opensource.com/article/18/1/securing-linux-filesystem-tripwire
|
Tripwire 是一个完整性检查工具，使得系统管理员、安全工程师和其他人能够检测系统文件的变更。
|
/data/attachment/album/201804/29/213125g1dis6d9gy24ggig.png.thumb.jpg
|
/data/attachment/album/201804/29/213125g1dis6d9gy24ggig.png
| true | false | true |
geekpi
| false |
[
"Tripwire"
] |
技术
|
{
"viewnum": 5654,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "116.172.134.36",
"message": "在centOS上在安装时会出现不提示你设置密钥的情况，需要使用命令tripwire-setup-keyfiles手动配置",
"username": "来自香港的 Chrome 117.0|Windows 10 用户",
"date": "2023-09-25T21:14:22"
}
] |
[] |
Tripwire 是一个完整性检查工具，使得系统管理员、安全工程师和其他人能够检测系统文件的变更。
| 2018-04-30T11:28:00 | 2018-04-30T11:28:00 | 9,592 |
/article-9592-1.html
|
>
> 如果恶意软件或其情况改变了你的文件系统，Linux 完整性检查工具会提示你。
>
>
>
尽管 Linux 被认为是最安全的操作系统（排在 Windows 和 MacOS 之前），但它仍然容易受到 rootkit 和其他恶意软件的影响。因此，Linux 用户需要知道如何保护他们的服务器或个人电脑免遭破坏，他们需要采取的第一步就是保护文件系统。
在本文中，我们将看看 [Tripwire](https://www.tripwire.com/)，这是保护 Linux 文件系统的绝佳工具。Tripwire 是一个完整性检查工具，使得系统管理员、安全工程师和其他人能够检测系统文件的变更。虽然它不是唯一的选择（[AIDE](http://aide.sourceforge.net/) 和 [Samhain](http://www.la-samhna.de/samhain/) 提供类似功能），但 Tripwire 可以说是 Linux 系统文件中最常用的完整性检查程序，并在 GPLv2 许可证下开源。
### Tripwire 如何工作
了解 Tripwire 如何运行对了解 Tripwire 在安装后会做什么有所帮助。Tripwire 主要由两个部分组成：策略和数据库。策略列出了完整性检查器应该生成快照的所有文件和目录，还创建了用于识别对目录和文件更改违规的规则。数据库由 Tripwire 生成的快照组成。
Tripwire 还有一个配置文件，它指定数据库、策略文件和 Tripwire 可执行文件的位置。它还提供两个加密密钥 —— 站点密钥和本地密钥 —— 以保护重要文件免遭篡改。站点密钥保护策略和配置文件，而本地密钥保护数据库和生成的报告。
Tripwire 会定期将目录和文件与数据库中的快照进行比较并报告所有的更改。
### 安装 Tripwire
要 Tripwire，我们需要先下载并安装它。Tripwire 适用于几乎所有的 Linux 发行版。你可以从 [Sourceforge](http://sourceforge.net/projects/tripwire) 下载一个开源版本，并如下根据你的 Linux 版本进行安装。
Debian 和 Ubuntu 用户可以使用 `apt-get` 直接从仓库安装 Tripwire。非 root 用户应该输入 `sudo` 命令通过 `apt-get` 安装 Tripwire。
```
sudo apt-get update
sudo apt-get install tripwire
```
CentOS 和其他基于 RPM 的发行版使用类似的过程。为了最佳实践，请在安装新软件包（如 Tripwire）之前更新仓库。命令 `yum install epel-release` 意思是我们想要安装额外的存储库。 （`epel` 代表 Extra Packages for Enterprise Linux。）
```
yum update
yum install epel-release
yum install tripwire
```
此命令会在安装中运行让 Tripwire 有效运行所需的配置。另外，它会在安装过程中询问你是否使用密码。你可以两个选择都选择 “Yes”。
另外，如果需要构建配置文件，请选择 “Yes”。选择并确认站点密钥和本地密钥的密码。（建议使用复杂的密码，例如 `Il0ve0pens0urce` 这样的。）
### 建立并初始化 Tripwire 数据库
接下来，按照以下步骤初始化 Tripwire 数据库：
```
tripwire --init
```
你需要提供本地密钥密码才能运行这些命令。
### 使用 Tripwire 进行基本的完整性检查
你可以使用以下命令让 Tripwire 检查你的文件或目录是否已被修改。Tripwire 将文件和目录与数据库中的初始快照进行比较的能力依赖于你在活动策略中创建的规则。
```
tripwire --check
```
你还可以将 `-check` 命令限制为特定的文件或目录，如下所示：
```
tripwire --check /usr/tmp
```
另外，如果你需要使用 Tripwire 的 `-check` 命令的更多帮助，该命令能够查阅 Tripwire 的手册：
```
tripwire --check --help
```
### 使用 Tripwire 生成报告
要轻松生成每日系统完整性报告，请使用以下命令创建一个 crontab 任务：
```
crontab -e
```
之后，你可以编辑此文件（使用你选择的文本编辑器）来引入由 cron 运行的任务。例如，你可以使用以下命令设置一个 cron 任务，在每天的 5:40 将 Tripwire 的报告发送到你的邮箱：
```
40 5 * * * usr/sbin/tripwire --check
```
无论你决定使用 Tripwire 还是其他具有类似功能的完整性检查程序，关键问题都是确保你有解决方案来保护 Linux 文件系统的安全。
---
via: <https://opensource.com/article/18/1/securing-linux-filesystem-tripwire>
作者：[Michael Kwaku Aboagye](https://opensource.com/users/revoks) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Docker 和 Elasticsearch 构建一个全文搜索应用程序
|
Patrick Triest
|
https://blog.patricktriest.com/text-search-docker-elasticsearch/
|
我们将使用 Docker 去配置我们自己的项目环境和依赖。这使我写这个教程快速又简单。
|
/data/attachment/album/201804/29/225958mstepxxzs4os5zzs.jpg.thumb.jpg
|
/data/attachment/album/201804/29/225958mstepxxzs4os5zzs.jpg
| true | false | true |
qhwdw
| false |
[
"Elasticsearch",
"全文搜索",
"搜索"
] |
技术
|
{
"viewnum": 18846,
"commentnum": 0,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们将使用 Docker 去配置我们自己的项目环境和依赖。这使我写这个教程快速又简单。
| 2018-05-01T09:56:00 | 2018-05-01T09:56:00 | 9,593 |
/article-9593-1.html
|
*如何在超过 500 万篇文章的 Wikipedia 上找到与你研究相关的文章？*
*如何在超过 20 亿用户的 Facebook 中找到你的朋友（并且还拼错了名字）？*
*谷歌如何在整个因特网上搜索你的模糊的、充满拼写错误的查询？*
在本教程中，我们将带你探索如何配置我们自己的全文搜索应用程序（与上述问题中的系统相比，它的复杂度要小很多）。我们的示例应用程序将提供一个 UI 和 API 去从 100 部经典文学（比如，《彼得·潘》 、 《弗兰肯斯坦》 和 《金银岛》）中搜索完整的文本。
你可以在这里（[https://search.patricktriest.com](https://search.patricktriest.com/)）预览该教程应用的完整版本。
这个应用程序的源代码是 100% 开源的，可以在 GitHub 仓库上找到它们 —— <https://github.com/triestpa/guttenberg-search> 。
在应用程序中添加一个快速灵活的全文搜索可能是个挑战。大多数的主流数据库，比如，[PostgreSQL](https://www.postgresql.org/) 和 [MongoDB](https://www.mongodb.com/)，由于受其查询和索引结构的限制只能提供一个非常基础的文本搜索功能。为实现高质量的全文搜索，通常的最佳选择是单独的数据存储。[Elasticsearch](https://www.elastic.co/) 是一个开源数据存储的领导者，它专门为执行灵活而快速的全文搜索进行了优化。
我们将使用 [Docker](https://www.docker.com/) 去配置我们自己的项目环境和依赖。Docker 是一个容器化引擎，它被 [Uber](https://www.uber.com/)、[Spotify](https://www.spotify.com/us/)、[ADP](https://www.adp.com/) 以及 [Paypal](https://www.paypal.com/us/home) 使用。构建容器化应用的一个主要优势是，项目的设置在 Windows、macOS、以及 Linux 上都是相同的 —— 这使我写这个教程快速又简单。如果你还没有使用过 Docker，不用担心，我们接下来将经历完整的项目配置。
我也会使用 [Node.js](https://nodejs.org/en/) （使用 [Koa](http://koajs.com/) 框架）和 [Vue.js](https://vuejs.org/)，用它们分别去构建我们自己的搜索 API 和前端 Web 应用程序。
### 1 - Elasticsearch 是什么？
全文搜索在现代应用程序中是一个有大量需求的特性。搜索也可能是最难的一项特性 —— 许多流行的网站的搜索功能都不合格，要么返回结果太慢，要么找不到精确的结果。通常，这种情况是被底层的数据库所局限：大多数标准的关系型数据库局限于基本的 `CONTAINS` 或 `LIKE` SQL 查询上，它仅提供最基本的字符串匹配功能。
我们的搜索应用程序将具备：
1. **快速** - 搜索结果将快速返回，为用户提供一个良好的体验。
2. **灵活** - 我们希望能够去修改搜索如何执行的方式，这是为了便于在不同的数据库和用户场景下进行优化。
3. **容错** - 如果所搜索的内容有拼写错误，我们将仍然会返回相关的结果，而这个结果可能正是用户希望去搜索的结果。
4. **全文** - 我们不想限制我们的搜索只能与指定的关键字或者标签相匹配 —— 我们希望它可以搜索在我们的数据存储中的任何东西（包括大的文本字段）。
为了构建一个功能强大的搜索功能，通常最理想的方法是使用一个为全文搜索任务优化过的数据存储。在这里我们使用 [Elasticsearch](https://www.elastic.co/)，Elasticsearch 是一个开源的内存中的数据存储，它是用 Java 写的，最初是在 [Apache Lucene](https://lucene.apache.org/core/) 库上构建的。
这里有一些来自 [Elastic 官方网站](https://www.elastic.co/guide/en/elasticsearch/guide/2.x/getting-started.html) 上的 Elasticsearch 真实使用案例。
* Wikipedia 使用 Elasticsearch 去提供带高亮搜索片断的全文搜索功能，并且提供按类型搜索和 “did-you-mean” 建议。
* Guardian 使用 Elasticsearch 把社交网络数据和访客日志相结合，为编辑去提供新文章的公众意见的实时反馈。
* Stack Overflow 将全文搜索和地理查询相结合，并使用 “类似” 的方法去找到相关的查询和回答。
* GitHub 使用 Elasticsearch 对 1300 亿行代码进行查询。
### 与 “普通的” 数据库相比，Elasticsearch 有什么不一样的地方？
Elasticsearch 之所以能够提供快速灵活的全文搜索，秘密在于它使用<ruby> 反转索引 <rt> inverted index </rt></ruby> 。
“索引” 是数据库中的一种数据结构，它能够以超快的速度进行数据查询和检索操作。数据库通过存储与表中行相关联的字段来生成索引。在一种可搜索的数据结构（一般是 [B 树](https://en.wikipedia.org/wiki/B-tree)）中排序索引，在优化过的查询中，数据库能够达到接近线性的时间（比如，“使用 ID=5 查找行”）。
我们可以将数据库索引想像成一个图书馆中老式的卡片式目录 —— 只要你知道书的作者和书名，它就会告诉你书的准确位置。为加速特定字段上的查询速度，数据库表一般有多个索引（比如，在 `name` 列上的索引可以加速指定名字的查询）。
反转索引本质上是不一样的。每行（或文档）的内容是分开的，并且每个独立的条目（在本案例中是单词）反向指向到包含它的任何文档上。
这种反转索引数据结构可以使我们非常快地查询到，所有出现 “football” 的文档。通过使用大量优化过的内存中的反转索引，Elasticsearch 可以让我们在存储的数据上，执行一些非常强大的和自定义的全文搜索。
### 2 - 项目设置
#### 2.0 - Docker
我们在这个项目上使用 [Docker](https://www.docker.com/) 管理环境和依赖。Docker 是个容器引擎，它允许应用程序运行在一个独立的环境中，不会受到来自主机操作系统和本地开发环境的影响。现在，许多公司将它们的大规模 Web 应用程序主要运行在容器架构上。这样将提升灵活性和容器化应用程序组件的可组构性。
对我来说，使用 Docker 的优势是，它对本教程的作者非常方便，它的本地环境设置量最小，并且跨 Windows、macOS 和 Linux 系统的一致性很好。我们只需要在 Docker 配置文件中定义这些依赖关系，而不是按安装说明分别去安装 Node.js、Elasticsearch 和 Nginx，然后，就可以使用这个配置文件在任何其它地方运行我们的应用程序。而且，因为每个应用程序组件都运行在它自己的独立容器中，它们受本地机器上的其它 “垃圾” 干扰的可能性非常小，因此，在调试问题时，像“它在我这里可以工作！”这类的问题将非常少。
#### 2.1 - 安装 Docker & Docker-Compose
这个项目只依赖 [Docker](https://www.docker.com/) 和 [docker-compose](https://docs.docker.com/compose/)，docker-compose 是 Docker 官方支持的一个工具，它用来将定义的多个容器配置 *组装* 成单一的应用程序栈。
* 安装 Docker - <https://docs.docker.com/engine/installation/>
* 安装 Docker Compose - <https://docs.docker.com/compose/install/>
#### 2.2 - 设置项目主目录
为项目创建一个主目录（名为 `guttenberg_search`）。我们的项目将工作在主目录的以下两个子目录中。
* `/public` - 保存前端 Vue.js Web 应用程序。
* `/server` - 服务器端 Node.js 源代码。
#### 2.3 - 添加 Docker-Compose 配置
接下来，我们将创建一个 `docker-compose.yml` 文件来定义我们的应用程序栈中的每个容器。
1. `gs-api` - 后端应用程序逻辑使用的 Node.js 容器
2. `gs-frontend` - 前端 Web 应用程序使用的 Ngnix 容器。
3. `gs-search` - 保存和搜索数据的 Elasticsearch 容器。
```
version: '3'
services:
api: # Node.js App
container_name: gs-api
build: .
ports:
- "3000:3000" # Expose API port
- "9229:9229" # Expose Node process debug port (disable in production)
environment: # Set ENV vars
- NODE_ENV=local
- ES_HOST=elasticsearch
- PORT=3000
volumes: # Attach local book data directory
- ./books:/usr/src/app/books
frontend: # Nginx Server For Frontend App
container_name: gs-frontend
image: nginx
volumes: # Serve local "public" dir
- ./public:/usr/share/nginx/html
ports:
- "8080:80" # Forward site to localhost:8080
elasticsearch: # Elasticsearch Instance
container_name: gs-search
image: docker.elastic.co/elasticsearch/elasticsearch:6.1.1
volumes: # Persist ES data in seperate "esdata" volume
- esdata:/usr/share/elasticsearch/data
environment:
- bootstrap.memory_lock=true
- "ES_JAVA_OPTS=-Xms512m -Xmx512m"
- discovery.type=single-node
ports: # Expose Elasticsearch ports
- "9300:9300"
- "9200:9200"
volumes: # Define seperate volume for Elasticsearch data
esdata:
```
这个文件定义了我们全部的应用程序栈 —— 不需要在你的本地系统上安装 Elasticsearch、Node 和 Nginx。每个容器都将端口转发到宿主机系统（`localhost`）上，以便于我们在宿主机上去访问和调试 Node API、Elasticsearch 实例和前端 Web 应用程序。
#### 2.4 - 添加 Dockerfile
对于 Nginx 和 Elasticsearch，我们使用了官方预构建的镜像，而 Node.js 应用程序需要我们自己去构建。
在应用程序的根目录下定义一个简单的 `Dockerfile` 配置文件。
```
# Use Node v8.9.0 LTS
FROM node:carbon
# Setup app working directory
WORKDIR /usr/src/app
# Copy package.json and package-lock.json
COPY package*.json ./
# Install app dependencies
RUN npm install
# Copy sourcecode
COPY . .
# Start app
CMD [ "npm", "start" ]
```
这个 Docker 配置扩展了官方的 Node.js 镜像、拷贝我们的应用程序源代码、以及在容器内安装 NPM 依赖。
我们也增加了一个 `.dockerignore` 文件，以防止我们不需要的文件拷贝到容器中。
```
node_modules/
npm-debug.log
books/
public/
```
>
> 请注意：我们之所以不拷贝 `node_modules` 目录到我们的容器中 —— 是因为我们要在容器构建过程里面运行 `npm install`。从宿主机系统拷贝 `node_modules` 到容器里面可能会引起错误，因为一些包需要为某些操作系统专门构建。比如说，在 macOS 上安装 `bcrypt` 包，然后尝试将这个模块直接拷贝到一个 Ubuntu 容器上将不能工作，因为 `bcyrpt` 需要为每个操作系统构建一个特定的二进制文件。
>
>
>
#### 2.5 - 添加基本文件
为了测试我们的配置，我们需要添加一些占位符文件到应用程序目录中。
在 `public/index.html` 文件中添加如下内容。
```
<html><body>Hello World From The Frontend Container</body></html>
```
接下来，在 `server/app.js` 中添加 Node.js 占位符文件。
```
const Koa = require('koa')
const app = new Koa()
app.use(async (ctx, next) => {
ctx.body = 'Hello World From the Backend Container'
})
const port = process.env.PORT || 3000
app.listen(port, err => {
if (err) console.error(err)
console.log(`App Listening on Port ${port}`)
})
```
最后，添加我们的 `package.json` Node 应用配置。
```
{
"name": "guttenberg-search",
"version": "0.0.1",
"description": "Source code for Elasticsearch tutorial using 100 classic open source books.",
"scripts": {
"start": "node --inspect=0.0.0.0:9229 server/app.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/triestpa/guttenberg-search.git"
},
"author": "patrick.triest@gmail.com",
"license": "MIT",
"bugs": {
"url": "https://github.com/triestpa/guttenberg-search/issues"
},
"homepage": "https://github.com/triestpa/guttenberg-search#readme",
"dependencies": {
"elasticsearch": "13.3.1",
"joi": "13.0.1",
"koa": "2.4.1",
"koa-joi-validate": "0.5.1",
"koa-router": "7.2.1"
}
}
```
这个文件定义了应用程序启动命令和 Node.js 包依赖。
>
> 注意：不要运行 `npm install` —— 当它构建时，依赖会在容器内安装。
>
>
>
#### 2.6 - 测试它的输出
现在一切新绪，我们来测试应用程序的每个组件的输出。从应用程序的主目录运行 `docker-compose build`，它将构建我们的 Node.js 应用程序容器。
接下来，运行 `docker-compose up` 去启动整个应用程序栈。
>
> 这一步可能需要几分钟时间，因为 Docker 要为每个容器去下载基础镜像。以后再次运行，启动应用程序会非常快，因为所需要的镜像已经下载完成了。
>
>
>
在你的浏览器中尝试访问 `localhost:8080` —— 你将看到简单的 “Hello World” Web 页面。
访问 `localhost:3000` 去验证我们的 Node 服务器，它将返回 “Hello World” 信息。
最后，访问 `localhost:9200` 去检查 Elasticsearch 运行状态。它将返回类似如下的内容。
```
{
"name" : "SLTcfpI",
"cluster_name" : "docker-cluster",
"cluster_uuid" : "iId8e0ZeS_mgh9ALlWQ7-w",
"version" : {
"number" : "6.1.1",
"build_hash" : "bd92e7f",
"build_date" : "2017-12-17T20:23:25.338Z",
"build_snapshot" : false,
"lucene_version" : "7.1.0",
"minimum_wire_compatibility_version" : "5.6.0",
"minimum_index_compatibility_version" : "5.0.0"
},
"tagline" : "You Know, for Search"
}
```
如果三个 URL 都显示成功，祝贺你！整个容器栈已经正常运行了，接下来我们进入最有趣的部分。
### 3 - 连接到 Elasticsearch
我们要做的第一件事情是，让我们的应用程序连接到我们本地的 Elasticsearch 实例上。
#### 3.0 - 添加 ES 连接模块
在新文件 `server/connection.js` 中添加如下的 Elasticsearch 初始化代码。
```
const elasticsearch = require('elasticsearch')
// Core ES variables for this project
const index = 'library'
const type = 'novel'
const port = 9200
const host = process.env.ES_HOST || 'localhost'
const client = new elasticsearch.Client({ host: { host, port } })
/** Check the ES connection status */
async function checkConnection () {
let isConnected = false
while (!isConnected) {
console.log('Connecting to ES')
try {
const health = await client.cluster.health({})
console.log(health)
isConnected = true
} catch (err) {
console.log('Connection Failed, Retrying...', err)
}
}
}
checkConnection()
```
现在，我们重新构建我们的 Node 应用程序，我们将使用 `docker-compose build` 来做一些改变。接下来，运行 `docker-compose up -d` 去启动应用程序栈，它将以守护进程的方式在后台运行。
应用程序启动之后，在命令行中运行 `docker exec gs-api "node" "server/connection.js"`，以便于在容器内运行我们的脚本。你将看到类似如下的系统输出信息。
```
{ cluster_name: 'docker-cluster',
status: 'yellow',
timed_out: false,
number_of_nodes: 1,
number_of_data_nodes: 1,
active_primary_shards: 1,
active_shards: 1,
relocating_shards: 0,
initializing_shards: 0,
unassigned_shards: 1,
delayed_unassigned_shards: 0,
number_of_pending_tasks: 0,
number_of_in_flight_fetch: 0,
task_max_waiting_in_queue_millis: 0,
active_shards_percent_as_number: 50 }
```
继续之前，我们先删除最下面的 `checkConnection()` 调用，因为，我们最终的应用程序将调用外部的连接模块。
#### 3.1 - 添加函数去重置索引
在 `server/connection.js` 中的 `checkConnection` 下面添加如下的函数，以便于重置 Elasticsearch 索引。
```
/** Clear the index, recreate it, and add mappings */
async function resetIndex (index) {
if (await client.indices.exists({ index })) {
await client.indices.delete({ index })
}
await client.indices.create({ index })
await putBookMapping()
}
```
#### 3.2 - 添加图书模式
接下来，我们将为图书的数据模式添加一个 “映射”。在 `server/connection.js` 中的 `resetIndex` 函数下面添加如下的函数。
```
/** Add book section schema mapping to ES */
async function putBookMapping () {
const schema = {
title: { type: 'keyword' },
author: { type: 'keyword' },
location: { type: 'integer' },
text: { type: 'text' }
}
return client.indices.putMapping({ index, type, body: { properties: schema } })
}
```
这是为 `book` 索引定义了一个映射。Elasticsearch 中的 `index` 大概类似于 SQL 的 `table` 或者 MongoDB 的 `collection`。我们通过添加映射来为存储的文档指定每个字段和它的数据类型。Elasticsearch 是无模式的，因此，从技术角度来看，我们是不需要添加映射的，但是，这样做，我们可以更好地控制如何处理数据。
比如，我们给 `title` 和 `author` 字段分配 `keyword` 类型，给 `text` 字段分配 `text` 类型。之所以这样做的原因是，搜索引擎可以区别处理这些字符串字段 —— 在搜索的时候，搜索引擎将在 `text` 字段中搜索可能的匹配项，而对于 `keyword` 类型字段，将对它们进行全文匹配。这看上去差别很小，但是它们对在不同的搜索上的速度和行为的影响非常大。
在文件的底部，导出对外发布的属性和函数，这样我们的应用程序中的其它模块就可以访问它们了。
```
module.exports = {
client, index, type, checkConnection, resetIndex
}
```
### 4 - 加载原始数据
我们将使用来自 [古登堡项目](https://www.gutenberg.org/) 的数据 —— 它致力于为公共提供免费的线上电子书。在这个项目中，我们将使用 100 本经典图书来充实我们的图书馆，包括《福尔摩斯探案集》、《金银岛》、《基督山复仇记》、《环游世界八十天》、《罗密欧与朱丽叶》 和《奥德赛》。
#### 4.1 - 下载图书文件
我将这 100 本书打包成一个文件，你可以从这里下载它 —— <https://cdn.patricktriest.com/data/books.zip>
将这个文件解压到你的项目的 `books/` 目录中。
你可以使用以下的命令来完成（需要在命令行下使用 [wget](https://www.gnu.org/software/wget/) 和 [The Unarchiver](https://theunarchiver.com/command-line)）。
```
wget https://cdn.patricktriest.com/data/books.zip
unar books.zip
```
#### 4.2 - 预览一本书
尝试打开其中的一本书的文件，假设打开的是 `219-0.txt`。你将注意到它开头是一个公开访问的协议，接下来是一些标识这本书的书名、作者、发行日期、语言和字符编码的行。
```
Title: Heart of Darkness
Author: Joseph Conrad
Release Date: February 1995 [EBook #219]
Last Updated: September 7, 2016
Language: English
Character set encoding: UTF-8
```
在 `*** START OF THIS PROJECT GUTENBERG EBOOK HEART OF DARKNESS ***` 这些行后面，是这本书的正式内容。
如果你滚动到本书的底部，你将看到类似 `*** END OF THIS PROJECT GUTENBERG EBOOK HEART OF DARKNESS ***` 信息，接下来是本书更详细的协议版本。
下一步，我们将使用程序从文件头部来解析书的元数据，提取 `*** START OF` 和 `***END OF` 之间的内容。
#### 4.3 - 读取数据目录
我们将写一个脚本来读取每本书的内容，并将这些数据添加到 Elasticsearch。我们将定义一个新的 Javascript 文件 `server/load_data.js` 来执行这些操作。
首先，我们将从 `books/` 目录中获取每个文件的列表。
在 `server/load_data.js` 中添加下列内容。
```
const fs = require('fs')
const path = require('path')
const esConnection = require('./connection')
/** Clear ES index, parse and index all files from the books directory */
async function readAndInsertBooks () {
try {
// Clear previous ES index
await esConnection.resetIndex()
// Read books directory
let files = fs.readdirSync('./books').filter(file => file.slice(-4) === '.txt')
console.log(`Found ${files.length} Files`)
// Read each book file, and index each paragraph in elasticsearch
for (let file of files) {
console.log(`Reading File - ${file}`)
const filePath = path.join('./books', file)
const { title, author, paragraphs } = parseBookFile(filePath)
await insertBookData(title, author, paragraphs)
}
} catch (err) {
console.error(err)
}
}
readAndInsertBooks()
```
我们将使用一个快捷命令来重构我们的 Node.js 应用程序，并更新运行的容器。
运行 `docker-compose up -d --build` 去更新应用程序。这是运行 `docker-compose build` 和 `docker-compose up -d` 的快捷命令。
为了在容器中运行我们的 `load_data` 脚本，我们运行 `docker exec gs-api "node" "server/load_data.js"` 。你将看到 Elasticsearch 的状态输出 `Found 100 Books`。
这之后，脚本发生了错误退出，原因是我们调用了一个没有定义的辅助函数（`parseBookFile`）。
#### 4.4 - 读取数据文件
接下来，我们读取元数据和每本书的内容。
在 `server/load_data.js` 中定义新函数。
```
/** Read an individual book text file, and extract the title, author, and paragraphs */
function parseBookFile (filePath) {
// Read text file
const book = fs.readFileSync(filePath, 'utf8')
// Find book title and author
const title = book.match(/^Title:\s(.+)$/m)[1]
const authorMatch = book.match(/^Author:\s(.+)$/m)
const author = (!authorMatch || authorMatch[1].trim() === '') ? 'Unknown Author' : authorMatch[1]
console.log(`Reading Book - ${title} By ${author}`)
// Find Guttenberg metadata header and footer
const startOfBookMatch = book.match(/^\*{3}\s*START OF (THIS|THE) PROJECT GUTENBERG EBOOK.+\*{3}$/m)
const startOfBookIndex = startOfBookMatch.index + startOfBookMatch[0].length
const endOfBookIndex = book.match(/^\*{3}\s*END OF (THIS|THE) PROJECT GUTENBERG EBOOK.+\*{3}$/m).index
// Clean book text and split into array of paragraphs
const paragraphs = book
.slice(startOfBookIndex, endOfBookIndex) // Remove Guttenberg header and footer
.split(/\n\s+\n/g) // Split each paragraph into it's own array entry
.map(line => line.replace(/\r\n/g, ' ').trim()) // Remove paragraph line breaks and whitespace
.map(line => line.replace(/_/g, '')) // Guttenberg uses "_" to signify italics. We'll remove it, since it makes the raw text look messy.
.filter((line) => (line && line.length !== '')) // Remove empty lines
console.log(`Parsed ${paragraphs.length} Paragraphs\n`)
return { title, author, paragraphs }
}
```
这个函数执行几个重要的任务。
1. 从文件系统中读取书的文本。
2. 使用正则表达式（关于正则表达式，请参阅 [这篇文章](https://blog.patricktriest.com/you-should-learn-regex/) ）解析书名和作者。
3. 通过匹配 “古登堡项目” 的头部和尾部，识别书的正文内容。
4. 提取书的内容文本。
5. 分割每个段落到它的数组中。
6. 清理文本并删除空白行。
它的返回值，我们将构建一个对象，这个对象包含书名、作者、以及书中各段落的数组。
再次运行 `docker-compose up -d --build` 和 `docker exec gs-api "node" "server/load_data.js"`，你将看到输出同之前一样，在输出的末尾有三个额外的行。
成功！我们的脚本从文本文件中成功解析出了书名和作者。脚本再次以错误结束，因为到现在为止，我们还没有定义辅助函数。
#### 4.5 - 在 ES 中索引数据文件
最后一步，我们将批量上传每个段落的数组到 Elasticsearch 索引中。
在 `load_data.js` 中添加新的 `insertBookData` 函数。
```
/** Bulk index the book data in Elasticsearch */
async function insertBookData (title, author, paragraphs) {
let bulkOps = [] // Array to store bulk operations
// Add an index operation for each section in the book
for (let i = 0; i < paragraphs.length; i++) {
// Describe action
bulkOps.push({ index: { _index: esConnection.index, _type: esConnection.type } })
// Add document
bulkOps.push({
author,
title,
location: i,
text: paragraphs[i]
})
if (i > 0 && i % 500 === 0) { // Do bulk insert in 500 paragraph batches
await esConnection.client.bulk({ body: bulkOps })
bulkOps = []
console.log(`Indexed Paragraphs ${i - 499} - ${i}`)
}
}
// Insert remainder of bulk ops array
await esConnection.client.bulk({ body: bulkOps })
console.log(`Indexed Paragraphs ${paragraphs.length - (bulkOps.length / 2)} - ${paragraphs.length}\n\n\n`)
}
```
这个函数将使用书名、作者和附加元数据的段落位置来索引书中的每个段落。我们通过批量操作来插入段落，它比逐个段落插入要快的多。
>
> 我们分批索引段落，而不是一次性插入全部，是为运行这个应用程序的内存稍有点小（1.7 GB）的服务器 `search.patricktriest.com` 上做的一个重要优化。如果你的机器内存还行（4 GB 以上），你或许不用分批上传。
>
>
>
运行 `docker-compose up -d --build` 和 `docker exec gs-api "node" "server/load_data.js"` 一次或多次 —— 现在你将看到前面解析的 100 本书的完整输出，并插入到了 Elasticsearch。这可能需要几分钟时间，甚至更长。
### 5 - 搜索
现在，Elasticsearch 中已经有了 100 本书了（大约有 230000 个段落），现在我们尝试搜索查询。
#### 5.0 - 简单的 HTTP 查询
首先，我们使用 Elasticsearch 的 HTTP API 对它进行直接查询。
在你的浏览器上访问这个 URL - `http://localhost:9200/library/_search?q=text:Java&pretty`
在这里，我们将执行一个极简的全文搜索，在我们的图书馆的书中查找 “Java” 这个词。
你将看到类似于下面的一个 JSON 格式的响应。
```
{
"took" : 11,
"timed_out" : false,
"_shards" : {
"total" : 5,
"successful" : 5,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : 13,
"max_score" : 14.259304,
"hits" : [
{
"_index" : "library",
"_type" : "novel",
"_id" : "p_GwFWEBaZvLlaAUdQgV",
"_score" : 14.259304,
"_source" : {
"author" : "Charles Darwin",
"title" : "On the Origin of Species",
"location" : 1080,
"text" : "Java, plants of, 375."
}
},
{
"_index" : "library",
"_type" : "novel",
"_id" : "wfKwFWEBaZvLlaAUkjfk",
"_score" : 10.186235,
"_source" : {
"author" : "Edgar Allan Poe",
"title" : "The Works of Edgar Allan Poe",
"location" : 827,
"text" : "After many years spent in foreign travel, I sailed in the year 18-- , from the port of Batavia, in the rich and populous island of Java, on a voyage to the Archipelago of the Sunda islands. I went as passenger--having no other inducement than a kind of nervous restlessness which haunted me as a fiend."
}
},
...
]
}
}
```
用 Elasticseach 的 HTTP 接口可以测试我们插入的数据是否成功，但是如果直接将这个 API 暴露给 Web 应用程序将有极大的风险。这个 API 将会暴露管理功能（比如直接添加和删除文档），最理想的情况是完全不要对外暴露它。而是写一个简单的 Node.js API 去接收来自客户端的请求，然后（在我们的本地网络中）生成一个正确的查询发送给 Elasticsearch。
#### 5.1 - 查询脚本
我们现在尝试从我们写的 Node.js 脚本中查询 Elasticsearch。
创建一个新文件，`server/search.js`。
```
const { client, index, type } = require('./connection')
module.exports = {
/** Query ES index for the provided term */
queryTerm (term, offset = 0) {
const body = {
from: offset,
query: { match: {
text: {
query: term,
operator: 'and',
fuzziness: 'auto'
} } },
highlight: { fields: { text: {} } }
}
return client.search({ index, type, body })
}
}
```
我们的搜索模块定义一个简单的 `search` 函数，它将使用输入的词 `match` 查询。
这是查询的字段分解 -
* `from` - 允许我们分页查询结果。默认每个查询返回 10 个结果，因此，指定 `from: 10` 将允许我们取回 10-20 的结果。
* `query` - 这里我们指定要查询的词。
* `operator` - 我们可以修改搜索行为；在本案例中，我们使用 `and` 操作去对查询中包含所有字元（要查询的词）的结果来确定优先顺序。
* `fuzziness` - 对拼写错误的容错调整，`auto` 的默认为 `fuzziness: 2`。模糊值越高，结果越需要更多校正。比如，`fuzziness: 1` 将允许以 `Patricc` 为关键字的查询中返回与 `Patrick` 匹配的结果。
* `highlights` - 为结果返回一个额外的字段，这个字段包含 HTML，以显示精确的文本字集和查询中匹配的关键词。
你可以去浏览 [Elastic Full-Text Query DSL](https://www.elastic.co/guide/en/elasticsearch/reference/current/full-text-queries.html)，学习如何随意调整这些参数，以进一步自定义搜索查询。
### 6 - API
为了能够从前端应用程序中访问我们的搜索功能，我们来写一个快速的 HTTP API。
#### 6.0 - API 服务器
用以下的内容替换现有的 `server/app.js` 文件。
```
const Koa = require('koa')
const Router = require('koa-router')
const joi = require('joi')
const validate = require('koa-joi-validate')
const search = require('./search')
const app = new Koa()
const router = new Router()
// Log each request to the console
app.use(async (ctx, next) => {
const start = Date.now()
await next()
const ms = Date.now() - start
console.log(`${ctx.method} ${ctx.url} - ${ms}`)
})
// Log percolated errors to the console
app.on('error', err => {
console.error('Server Error', err)
})
// Set permissive CORS header
app.use(async (ctx, next) => {
ctx.set('Access-Control-Allow-Origin', '*')
return next()
})
// ADD ENDPOINTS HERE
const port = process.env.PORT || 3000
app
.use(router.routes())
.use(router.allowedMethods())
.listen(port, err => {
if (err) throw err
console.log(`App Listening on Port ${port}`)
})
```
这些代码将为 [Koa.js](http://koajs.com/) Node API 服务器导入服务器依赖，设置简单的日志，以及错误处理。
### 6.1 - 使用查询连接端点
接下来，我们将在服务器上添加一个端点，以便于发布我们的 Elasticsearch 查询功能。
在 `server/app.js` 文件的 `// ADD ENDPOINTS HERE` 下面插入下列的代码。
```
/**
* GET /search
* Search for a term in the library
*/
router.get('/search', async (ctx, next) => {
const { term, offset } = ctx.request.query
ctx.body = await search.queryTerm(term, offset)
}
)
```
使用 `docker-compose up -d --build` 重启动应用程序。之后在你的浏览器中尝试调用这个搜索端点。比如，`http://localhost:3000/search?term=java` 这个请求将搜索整个图书馆中提到 “Java” 的内容。
结果与前面直接调用 Elasticsearch HTTP 界面的结果非常类似。
```
{
"took": 242,
"timed_out": false,
"_shards": {
"total": 5,
"successful": 5,
"skipped": 0,
"failed": 0
},
"hits": {
"total": 93,
"max_score": 13.356944,
"hits": [{
"_index": "library",
"_type": "novel",
"_id": "eHYHJmEBpQg9B4622421",
"_score": 13.356944,
"_source": {
"author": "Charles Darwin",
"title": "On the Origin of Species",
"location": 1080,
"text": "Java, plants of, 375."
},
"highlight": {
"text": ["<em>Java</em>, plants of, 375."]
}
}, {
"_index": "library",
"_type": "novel",
"_id": "2HUHJmEBpQg9B462xdNg",
"_score": 9.030668,
"_source": {
"author": "Unknown Author",
"title": "The King James Bible",
"location": 186,
"text": "10:4 And the sons of Javan; Elishah, and Tarshish, Kittim, and Dodanim."
},
"highlight": {
"text": ["10:4 And the sons of <em>Javan</em>; Elishah, and Tarshish, Kittim, and Dodanim."]
}
}
...
]
}
}
```
### 6.2 - 输入校验
这个端点现在还很脆弱 —— 我们没有对请求参数做任何的校验，因此，如果是无效的或者错误的值将使服务器出错。
我们将添加一些使用 [Joi](https://github.com/hapijs/joi) 和 [Koa-Joi-Validate](https://github.com/triestpa/koa-joi-validate) 库的中间件，以对输入做校验。
```
/**
* GET /search
* Search for a term in the library
* Query Params -
* term: string under 60 characters
* offset: positive integer
*/
router.get('/search',
validate({
query: {
term: joi.string().max(60).required(),
offset: joi.number().integer().min(0).default(0)
}
}),
async (ctx, next) => {
const { term, offset } = ctx.request.query
ctx.body = await search.queryTerm(term, offset)
}
)
```
现在，重启服务器，如果你使用一个没有搜索关键字的请求（`http://localhost:3000/search`），你将返回一个带相关消息的 HTTP 400 错误，比如像 `Invalid URL Query - child "term" fails because ["term" is required]`。
如果想从 Node 应用程序中查看实时日志，你可以运行 `docker-compose logs -f api`。
### 7 - 前端应用程序
现在我们的 `/search` 端点已经就绪，我们来连接到一个简单的 Web 应用程序来测试这个 API。
#### 7.0 - Vue.js 应用程序
我们将使用 Vue.js 去协调我们的前端。
添加一个新文件 `/public/app.js`，去控制我们的 Vue.js 应用程序代码。
```
const vm = new Vue ({
el: '#vue-instance',
data () {
return {
baseUrl: 'http://localhost:3000', // API url
searchTerm: 'Hello World', // Default search term
searchDebounce: null, // Timeout for search bar debounce
searchResults: [], // Displayed search results
numHits: null, // Total search results found
searchOffset: 0, // Search result pagination offset
selectedParagraph: null, // Selected paragraph object
bookOffset: 0, // Offset for book paragraphs being displayed
paragraphs: [] // Paragraphs being displayed in book preview window
}
},
async created () {
this.searchResults = await this.search() // Search for default term
},
methods: {
/** Debounce search input by 100 ms */
onSearchInput () {
clearTimeout(this.searchDebounce)
this.searchDebounce = setTimeout(async () => {
this.searchOffset = 0
this.searchResults = await this.search()
}, 100)
},
/** Call API to search for inputted term */
async search () {
const response = await axios.get(`${this.baseUrl}/search`, { params: { term: this.searchTerm, offset: this.searchOffset } })
this.numHits = response.data.hits.total
return response.data.hits.hits
},
/** Get next page of search results */
async nextResultsPage () {
if (this.numHits > 10) {
this.searchOffset += 10
if (this.searchOffset + 10 > this.numHits) { this.searchOffset = this.numHits - 10}
this.searchResults = await this.search()
document.documentElement.scrollTop = 0
}
},
/** Get previous page of search results */
async prevResultsPage () {
this.searchOffset -= 10
if (this.searchOffset < 0) { this.searchOffset = 0 }
this.searchResults = await this.search()
document.documentElement.scrollTop = 0
}
}
})
```
这个应用程序非常简单 —— 我们只定义了一些共享的数据属性，以及添加了检索和分页搜索结果的方法。为防止每次按键一次都调用 API，搜索输入有一个 100 毫秒的除颤功能。
解释 Vue.js 是如何工作的已经超出了本教程的范围，如果你使用过 Angular 或者 React，其实一些也不可怕。如果你完全不熟悉 Vue，想快速了解它的功能，我建议你从官方的快速指南入手 —— <https://vuejs.org/v2/guide/>
#### 7.1 - HTML
使用以下的内容替换 `/public/index.html` 文件中的占位符，以便于加载我们的 Vue.js 应用程序和设计一个基本的搜索界面。
```
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Elastic Library</title>
<meta name="description" content="Literary Classic Search Engine.">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
<link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/7.0.0/normalize.min.css" rel="stylesheet" type="text/css" />
<link href="https://cdn.muicss.com/mui-0.9.20/css/mui.min.css" rel="stylesheet" type="text/css" />
<link href="https://fonts.googleapis.com/css?family=EB+Garamond:400,700|Open+Sans" rel="stylesheet">
<link href="styles.css" rel="stylesheet" />
</head>
<body>
<div class="app-container" id="vue-instance">
<!-- Search Bar Header -->
<div class="mui-panel">
<div class="mui-textfield">
<input v-model="searchTerm" type="text" v-on:keyup="onSearchInput()">
<label>Search</label>
</div>
</div>
<!-- Search Metadata Card -->
<div class="mui-panel">
<div class="mui--text-headline">{{ numHits }} Hits</div>
<div class="mui--text-subhead">Displaying Results {{ searchOffset }} - {{ searchOffset + 9 }}</div>
</div>
<!-- Top Pagination Card -->
<div class="mui-panel pagination-panel">
<button class="mui-btn mui-btn--flat" v-on:click="prevResultsPage()">Prev Page</button>
<button class="mui-btn mui-btn--flat" v-on:click="nextResultsPage()">Next Page</button>
</div>
<!-- Search Results Card List -->
<div class="search-results" ref="searchResults">
<div class="mui-panel" v-for="hit in searchResults" v-on:click="showBookModal(hit)">
<div class="mui--text-title" v-html="hit.highlight.text[0]"></div>
<div class="mui-divider"></div>
<div class="mui--text-subhead">{{ hit._source.title }} - {{ hit._source.author }}</div>
<div class="mui--text-body2">Location {{ hit._source.location }}</div>
</div>
</div>
<!-- Bottom Pagination Card -->
<div class="mui-panel pagination-panel">
<button class="mui-btn mui-btn--flat" v-on:click="prevResultsPage()">Prev Page</button>
<button class="mui-btn mui-btn--flat" v-on:click="nextResultsPage()">Next Page</button>
</div>
<!-- INSERT BOOK MODAL HERE -->
</div>
<script src="https://cdn.muicss.com/mui-0.9.28/js/mui.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.5.3/vue.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/axios/0.17.0/axios.min.js"></script>
<script src="app.js"></script>
</body>
</html>
```
#### 7.2 - CSS
添加一个新文件 `/public/styles.css`，使用一些自定义的 UI 样式。
```
body { font-family: 'EB Garamond', serif; }
.mui-textfield > input, .mui-btn, .mui--text-subhead, .mui-panel > .mui--text-headline {
font-family: 'Open Sans', sans-serif;
}
.all-caps { text-transform: uppercase; }
.app-container { padding: 16px; }
.search-results em { font-weight: bold; }
.book-modal > button { width: 100%; }
.search-results .mui-divider { margin: 14px 0; }
.search-results {
display: flex;
flex-direction: row;
flex-wrap: wrap;
justify-content: space-around;
}
.search-results > div {
flex-basis: 45%;
box-sizing: border-box;
cursor: pointer;
}
@media (max-width: 600px) {
.search-results > div { flex-basis: 100%; }
}
.paragraphs-container {
max-width: 800px;
margin: 0 auto;
margin-bottom: 48px;
}
.paragraphs-container .mui--text-body1, .paragraphs-container .mui--text-body2 {
font-size: 1.8rem;
line-height: 35px;
}
.book-modal {
width: 100%;
height: 100%;
padding: 40px 10%;
box-sizing: border-box;
margin: 0 auto;
background-color: white;
overflow-y: scroll;
position: fixed;
top: 0;
left: 0;
}
.pagination-panel {
display: flex;
justify-content: space-between;
}
.title-row {
display: flex;
justify-content: space-between;
align-items: flex-end;
}
@media (max-width: 600px) {
.title-row{
flex-direction: column;
text-align: center;
align-items: center
}
}
.locations-label {
text-align: center;
margin: 8px;
}
.modal-footer {
position: fixed;
bottom: 0;
left: 0;
width: 100%;
display: flex;
justify-content: space-around;
background: white;
}
```
#### 7.3 - 尝试输出
在你的浏览器中打开 `localhost:8080`，你将看到一个简单的带结果分页功能的搜索界面。在顶部的搜索框中尝试输入不同的关键字来查看它们的搜索情况。
>
> 你没有必要重新运行 `docker-compose up` 命令以使更改生效。本地的 `public` 目录是装载在我们的 Nginx 文件服务器容器中，因此，在本地系统中前端的变化将在容器化应用程序中自动反映出来。
>
>
>
如果你尝试点击任何搜索结果，什么反应也没有 —— 因为我们还没有为这个应用程序添加进一步的相关功能。
### 8 - 分页预览
如果能点击每个搜索结果，然后查看到来自书中的内容，那将是非常棒的体验。
### 8.0 - 添加 Elasticsearch 查询
首先，我们需要定义一个简单的查询去从给定的书中获取段落范围。
在 `server/search.js` 文件中添加如下的函数到 `module.exports` 块中。
```
/** Get the specified range of paragraphs from a book */
getParagraphs (bookTitle, startLocation, endLocation) {
const filter = [
{ term: { title: bookTitle } },
{ range: { location: { gte: startLocation, lte: endLocation } } }
]
const body = {
size: endLocation - startLocation,
sort: { location: 'asc' },
query: { bool: { filter } }
}
return client.search({ index, type, body })
}
```
这个新函数将返回给定的书的开始位置和结束位置之间的一个排序后的段落数组。
#### 8.1 - 添加 API 端点
现在，我们将这个函数链接到 API 端点。
添加下列内容到 `server/app.js` 文件中最初的 `/search` 端点下面。
```
/**
* GET /paragraphs
* Get a range of paragraphs from the specified book
* Query Params -
* bookTitle: string under 256 characters
* start: positive integer
* end: positive integer greater than start
*/
router.get('/paragraphs',
validate({
query: {
bookTitle: joi.string().max(256).required(),
start: joi.number().integer().min(0).default(0),
end: joi.number().integer().greater(joi.ref('start')).default(10)
}
}),
async (ctx, next) => {
const { bookTitle, start, end } = ctx.request.query
ctx.body = await search.getParagraphs(bookTitle, start, end)
}
)
```
#### 8.2 - 添加 UI 功能
现在，我们的新端点已经就绪，我们为应用程序添加一些从书中查询和显示全部页面的前端功能。
在 `/public/app.js` 文件的 `methods` 块中添加如下的函数。
```
/** Call the API to get current page of paragraphs */
async getParagraphs (bookTitle, offset) {
try {
this.bookOffset = offset
const start = this.bookOffset
const end = this.bookOffset + 10
const response = await axios.get(`${this.baseUrl}/paragraphs`, { params: { bookTitle, start, end } })
return response.data.hits.hits
} catch (err) {
console.error(err)
}
},
/** Get next page (next 10 paragraphs) of selected book */
async nextBookPage () {
this.$refs.bookModal.scrollTop = 0
this.paragraphs = await this.getParagraphs(this.selectedParagraph._source.title, this.bookOffset + 10)
},
/** Get previous page (previous 10 paragraphs) of selected book */
async prevBookPage () {
this.$refs.bookModal.scrollTop = 0
this.paragraphs = await this.getParagraphs(this.selectedParagraph._source.title, this.bookOffset - 10)
},
/** Display paragraphs from selected book in modal window */
async showBookModal (searchHit) {
try {
document.body.style.overflow = 'hidden'
this.selectedParagraph = searchHit
this.paragraphs = await this.getParagraphs(searchHit._source.title, searchHit._source.location - 5)
} catch (err) {
console.error(err)
}
},
/** Close the book detail modal */
closeBookModal () {
document.body.style.overflow = 'auto'
this.selectedParagraph = null
}
```
这五个函数提供了通过页码从书中下载和分页（每次十个段落）的逻辑。
现在，我们需要添加一个 UI 去显示书的页面。在 `/public/index.html` 的 `<!-- INSERT BOOK MODAL HERE -->` 注释下面添加如下的内容。
```
<!-- Book Paragraphs Modal Window -->
<div v-if="selectedParagraph" ref="bookModal" class="book-modal">
<div class="paragraphs-container">
<!-- Book Section Metadata -->
<div class="title-row">
<div class="mui--text-display2 all-caps">{{ selectedParagraph._source.title }}</div>
<div class="mui--text-display1">{{ selectedParagraph._source.author }}</div>
</div>
<br>
<div class="mui-divider"></div>
<div class="mui--text-subhead locations-label">Locations {{ bookOffset - 5 }} to {{ bookOffset + 5 }}</div>
<div class="mui-divider"></div>
<br>
<!-- Book Paragraphs -->
<div v-for="paragraph in paragraphs">
<div v-if="paragraph._source.location === selectedParagraph._source.location" class="mui--text-body2">
<strong>{{ paragraph._source.text }}</strong>
</div>
<div v-else class="mui--text-body1">
{{ paragraph._source.text }}
</div>
<br>
</div>
</div>
<!-- Book Pagination Footer -->
<div class="modal-footer">
<button class="mui-btn mui-btn--flat" v-on:click="prevBookPage()">Prev Page</button>
<button class="mui-btn mui-btn--flat" v-on:click="closeBookModal()">Close</button>
<button class="mui-btn mui-btn--flat" v-on:click="nextBookPage()">Next Page</button>
</div>
</div>
```
再次重启应用程序服务器（`docker-compose up -d --build`），然后打开 `localhost:8080`。当你再次点击搜索结果时，你将能看到关键字附近的段落。如果你感兴趣，你现在甚至可以看这本书的剩余部分。
祝贺你！你现在已经完成了本教程的应用程序。
你可以去比较你的本地结果与托管在这里的完整示例 —— <https://search.patricktriest.com/>。
### 9 - Elasticsearch 的缺点
#### 9.0 - 耗费资源
Elasticsearch 是计算密集型的。[官方建议](https://www.elastic.co/guide/en/elasticsearch/guide/current/hardware.html) 运行 ES 的机器最好有 64 GB 的内存，强烈反对在低于 8 GB 内存的机器上运行它。Elasticsearch 是一个 *内存中* 数据库，这样使它的查询速度非常快，但这也非常占用系统内存。在生产系统中使用时，[他们强烈建议在一个集群中运行多个 Elasticsearch 节点](https://www.elastic.co/guide/en/elasticsearch/guide/2.x/distributed-cluster.html)，以实现高可用、自动分区和一个节点失败时的数据冗余。
我们的这个教程中的应用程序运行在一个 $15/月 的 GCP 计算实例中（ [search.patricktriest.com](https://search.patricktriest.com/)），它只有 1.7 GB 的内存，它勉强能运行这个 Elasticsearch 节点；有时候在进行初始的数据加载过程中，整个机器就 ”假死机“ 了。在我的经验中，Elasticsearch 比传统的那些数据库，比如，PostgreSQL 和 MongoDB 耗费的资源要多很多，这样会使托管主机的成本增加很多。
### 9.1 - 与数据库的同步
对于大多数应用程序，将数据全部保存在 Elasticsearch 并不是个好的选择。可以使用 ES 作为应用程序的主要事务数据库，但是一般不推荐这样做，因为在 Elasticsearch 中缺少 ACID，如果大量读取数据的时候，它能导致写操作丢失。在许多案例中，ES 服务器更多是一个特定的角色，比如做应用程序中的一个文本搜索功能。这种特定的用途，要求它从主数据库中复制数据到 Elasticsearch 实例中。
比如，假设我们将用户信息保存在一个 PostgreSQL 表中，但是用 Elasticsearch 去提供我们的用户搜索功能。如果一个用户，比如，“Albert”，决定将他的名字改成 “Al”，我们将需要把这个变化同时反映到我们主要的 PostgreSQL 数据库和辅助的 Elasticsearch 集群中。
正确地集成它们可能比较棘手，最好的答案将取决于你现有的应用程序栈。这有多种开源方案可选，从 [用一个进程去关注 MongoDB 操作日志](https://github.com/mongodb-labs/mongo-connector) 并自动同步检测到的变化到 ES，到使用一个 [PostgresSQL 插件](https://github.com/zombodb/zombodb) 去创建一个定制的、基于 PSQL 的索引来与 Elasticsearch 进行自动沟通。
如果没有有效的预构建选项可用，你可能需要在你的服务器代码中增加一些钩子，这样可以基于数据库的变化来手动更新 Elasticsearch 索引。最后一招，我认为是一个最后的选择，因为，使用定制的业务逻辑去保持 ES 的同步可能很复杂，这将会给应用程序引入很多的 bug。
让 Elasticsearch 与一个主数据库同步，将使它的架构更加复杂，其复杂性已经超越了 ES 的相关缺点，但是当在你的应用程序中考虑添加一个专用的搜索引擎的利弊得失时，这个问题是值的好好考虑的。
### 总结
在很多现在流行的应用程序中，全文搜索是一个非常重要的功能 —— 而且是很难实现的一个功能。对于在你的应用程序中添加一个快速而又可定制的文本搜索，Elasticsearch 是一个非常好的选择，但是，在这里也有一个替代者。[Apache Solr](https://lucene.apache.org/solr/) 是一个类似的开源搜索平台，它是基于 Apache Lucene 构建的，与 Elasticsearch 的核心库是相同的。[Algolia](https://www.algolia.com/) 是一个搜索即服务的 Web 平台，它已经很快流行了起来，并且它对新手非常友好，很易于上手（但是作为折衷，它的可定制性较小，并且使用成本较高）。
“搜索” 特性并不是 Elasticsearch 唯一功能。ES 也是日志存储和分析的常用工具，在一个 ELK（Elasticsearch、Logstash、Kibana）架构配置中通常会使用它。灵活的全文搜索功能使得 Elasticsearch 在数据量非常大的科学任务中用处很大 —— 比如，在一个数据集中正确的/标准化的条目拼写，或者为了类似的词组搜索一个文本数据集。
对于你自己的项目，这里有一些创意。
* 添加更多你喜欢的书到教程的应用程序中，然后创建你自己的私人图书馆搜索引擎。
* 利用来自 [Google Scholar](https://scholar.google.com/) 的论文索引，创建一个学术抄袭检测引擎。
* 通过将字典中的每个词索引到 Elasticsearch，创建一个拼写检查应用程序。
* 通过将 [Common Crawl Corpus](https://aws.amazon.com/public-datasets/common-crawl/) 加载到 Elasticsearch 中，构建你自己的与谷歌竞争的因特网搜索引擎（注意，它可能会超过 50 亿个页面，这是一个成本极高的数据集）。
* 在 journalism 上使用 Elasticsearch：在最近的大规模泄露的文档中搜索特定的名字和关键词，比如， [Panama Papers](https://en.wikipedia.org/wiki/Panama_Papers) 和 [Paradise Papers](https://en.wikipedia.org/wiki/Paradise_Papers)。
本教程中应用程序的源代码是 100% 公开的，你可以在 GitHub 仓库上找到它们 —— <https://github.com/triestpa/guttenberg-search>
我希望你喜欢这个教程！你可以在下面的评论区，发表任何你的想法、问题、或者评论。
---
作者简介：
全栈工程师，数据爱好者，学霸，“构建强迫症患者”，探险爱好者。
---
via: <https://blog.patricktriest.com/text-search-docker-elasticsearch/>
作者：[Patrick Triest](https://blog.patricktriest.com/author/patrick/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 KVM 中测试 IPv6 网络（第 1 部分）
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2017/11/testing-ipv6-networking-kvm-part-1
|
在这个两篇的系列当中，我们将学习关于 IPv6 私有地址的知识，以及如何在 KVM 中配置测试网络。
|
/data/attachment/album/201804/30/200734dupx99rb9bx2b922.png.thumb.jpg
|
/data/attachment/album/201804/30/200734dupx99rb9bx2b922.png
| true | false | true |
qhwdw
| false |
[
"IPv6",
"KVM"
] |
技术
|
{
"viewnum": 7394,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9652,
"displayorder": 0
}
] |
在这个两篇的系列当中，我们将学习关于 IPv6 私有地址的知识，以及如何在 KVM 中配置测试网络。
| 2018-04-30T20:07:30 | 2018-04-30T20:07:30 | 9,594 |
/article-9594-1.html
|
>
> 在这个两篇的系列当中，我们将学习关于 IPv6 私有地址的知识，以及如何在 KVM 中配置测试网络。
>
>
>
要理解 IPv6 地址是如何工作的，没有比亲自动手去实践更好的方法了，在 KVM 中配置一个小的测试实验室非常容易 —— 也很有趣。这个系列的文章共有两个部分，我们将学习关于 IPv6 私有地址的知识，以及如何在 KVM 中配置测试网络。
### QEMU/KVM/虚拟机管理器
我们先来了解什么是 KVM。在这里，我将使用 KVM 来表示 QEMU、KVM、以及虚拟机管理器的一个组合，虚拟机管理器在 Linux 发行版中一般都内置了。简单解释就是，QEMU 模拟硬件，而 KVM 是一个内核模块，它在你的 CPU 上创建一个 “访客领地”，并去管理它们对内存和 CPU 的访问。虚拟机管理器是一个涵盖虚拟化和管理程序的图形工具。
但是你不能被图形界面下 “点击” 操作的方式 “缠住” ，因为，它们也有命令行工具可以使用 —— 比如 `virsh` 和 `virt-install`。
如果你在使用 KVM 方面没有什么经验，你可以从 [在 KVM 中创建虚拟机：第 1 部分](https://www.linux.com/learn/intro-to-linux/2017/5/creating-virtual-machines-kvm-part-1) 和 [在 KVM 中创建虚拟机：第 2 部分 - 网络](https://www.linux.com/learn/intro-to-linux/2017/5/creating-virtual-machines-kvm-part-2-networking) 开始学起。
### IPv6 唯一本地地址
在 KVM 中配置 IPv6 网络与配置 IPv4 网络很类似。它们的主要不同在于这些怪异的长地址。[上一次](https://www.linux.com/learn/intro-to-linux/2017/10/calculating-ipv6-subnets-linux)，我们讨论了 IPv6 地址的不同类型。其中有一个 IPv6 单播地址类，`fc00::/7`（详细情况请查阅 [RFC 4193](https://tools.ietf.org/html/rfc4193)），它类似于 IPv4 中的私有地址 —— `10.0.0.0/8`、`172.16.0.0/12`、和 `192.168.0.0/16`。
下图解释了这个唯一本地地址空间的结构。前 48 位定义了前缀和全局 ID，随后的 16 位是子网，剩余的 64 位是接口 ID：
```
| 7 bits |1| 40 bits | 16 bits | 64 bits |
+--------+-+------------+-----------+----------------------------+
| Prefix |L| Global ID | Subnet ID | Interface ID |
+--------+-+------------+-----------+----------------------------+
```
下面是另外一种表示方法，它可能更有助于你理解这些地址是如何管理的：
```
| Prefix | Global ID | Subnet ID | Interface ID |
+--------+--------------+-------------+----------------------+
| fd | 00:0000:0000 | 0000 | 0000:0000:0000:0000 |
+--------+--------------+-------------+----------------------+
```
`fc00::/7` 共分成两个 `/8` 地址块，`fc00::/8` 和 `fd00::/8`。`fc00::/8` 是为以后使用保留的。因此，唯一本地地址通常都是以 `fd` 开头的，而剩余部分是由你使用的。`L` 位，也就是第八位，它总是设置为 `1`，这样它可以表示为 `fd00::/8`。设置为 `0` 时，它就表示为 `fc00::/8`。你可以使用 `subnetcalc` 来看到这些东西：
```
$ subnetcalc fd00::/8 -n
Address = fd00::
fd00 = 11111101 00000000
$ subnetcalc fc00::/8 -n
Address = fc00::
fc00 = 11111100 00000000
```
RFC 4193 要求地址必须随机产生。你可以用你选择的任何方法来造出个地址，只要它们以 `fd` 打头就可以，因为 IPv6 范围非常大，它不会因为地址耗尽而无法使用。当然，最佳实践还是按 RFC 的要求来做。地址不能按顺序分配或者使用众所周知的数字。RFC 4193 包含一个构建伪随机地址生成器的算法，或者你可以找到各种在线生成器。
唯一本地地址不像全局单播地址（它由你的因特网服务提供商分配）那样进行中心化管理，即使如此，发生地址冲突的可能性也是非常低的。当你需要去合并一些本地网络或者想去在不相关的私有网络之间路由时，这是一个非常好的优势。
在同一个子网中，你可以混用唯一本地地址和全局单播地址。唯一本地地址是可路由的，并且它并不会因此要求对路由器做任何调整。但是，你应该在你的边界路由器和防火墙上配置为不允许它们离开你的网络，除非是在不同位置的两个私有网络之间。
RFC4193 建议，不要混用全局单播地址的 AAAA 和 PTR 记录，因为虽然它们重复的机率非常低，但是并不能保证它们就是独一无二的。就像我们使用的 IPv4 地址一样，要保持你本地的私有名称服务和公共名称服务的独立。将本地名称服务使用的 Dnsmasq 和公共名称服务使用的 BIND 组合起来，是一个在 IPv4 网络上经过实战检验的可靠组合，这个组合也同样适用于 IPv6 网络。
### 伪随机地址生成器
在线地址生成器的一个示例是 [本地 IPv6 地址生成器](https://www.ultratools.com/tools/rangeGenerator)。你可以在线找到许多这样很酷的工具。你可以使用它来为你创建一个新地址，或者使用它在你的现有全局 ID 下为你创建子网。
下周我们将讲解如何在 KVM 中配置这些 IPv6 的地址，并现场测试它们。
通过来自 Linux 基金会和 edX 的免费在线课程 [“Linux 入门”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 学习更多的 Linux 知识。
---
via: <https://www.linux.com/learn/intro-to-linux/2017/11/testing-ipv6-networking-kvm-part-1>
作者：[Carla Schroder](https://www.linux.com/users/cschroder) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
通过扫描二维码将文件从计算机传输到移动设备
|
Sk
|
https://www.ostechnix.com/transfer-files-from-computer-to-mobile-devices-by-scanning-qr-codes/
|
它允许你通过扫描二维码通过 WiFi 将文件从计算机传输到移动设备而无须离开终端。
|
/data/attachment/album/201804/30/202107r8c828sxupfbf000.png.thumb.jpg
|
/data/attachment/album/201804/30/202107r8c828sxupfbf000.png
| true | false | true |
geekpi
| false |
[
"文件传输",
"二维码"
] |
分享
|
{
"viewnum": 11251,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "123.147.248.13",
"message": "推荐一个网站（连接世界网）2linkworld， 不需要任何工具软件，也不需要任何登陆，只需要扫码可以实现电脑手机互传文件",
"username": "来自重庆的 Chrome 63.0|Windows 7 用户",
"date": "2019-01-17T13:45:06"
}
] |
[] |
它允许你通过扫描二维码通过 WiFi 将文件从计算机传输到移动设备而无须离开终端。
| 2018-04-30T20:21:04 | 2018-04-30T20:21:04 | 9,595 |
/article-9595-1.html
|
将文件从计算机传输到智能手机并不是什么大问题。你可以使用 USB 线将手机挂载到系统上，然后从文件管理器传输文件。此外，某些第三方应用程序（例如 [KDE Connect](https://www.ostechnix.com/kde-connect-access-files-notifications-android-devices/) 和 [AirDroid](https://www.ostechnix.com/airdroid-share-files-and-folders-between-linux-and-android/)）可帮助你轻松管理和传输系统中的文件至 Android 设备。今天，我偶然发现了一个名为 “Qr-filetransfer” 的超酷工具。它允许你通过扫描二维码通过 WiFi 将文件从计算机传输到移动设备而无须离开终端。是的，你没有看错！ Qr-filetransfer 是一个使用 Go 语言编写的自由开源命令行工具。在这个简短的教程中，我们将学习如何使用 Qr-filetransfer 将文件从 Linux 传输到任何移动设备。
### 安装 Qr-filetransfer
首先，在你的系统上安装 Go 语言。
在 Arch Linux 及其衍生版上：
```
$ sudo pacman -S go
```
在基于 RPM 的系统（如 RHEL、CentOS、Fedora）上运行：
```
$ sudo yum install golang
```
或者：
```
$ sudo dnf install golang
```
在基于 DEB 的系统上，例如 Debian、Ubuntu、Linux Mint，你可以使用命令安装它：
```
$ sudo apt-get install golang
```
在 SUSE/openSUSE 上：
```
$ sudo zypper install golang
```
安装 Go 语言后，运行以下命令下载 Qr-filetransfer 应用。
```
$ go get github.com/claudiodangelis/qr-filetransfer
```
上述命令将在当前工作目录下的一个名为 `go` 的目录中下载 Qr-filetransfer GitHub 仓库的内容。
将 Qr-filetransfer 的二进制文件复制到 PATH 中，例如 `/usr/local/bin/`。
```
$ sudo cp go/bin/qr-filetransfer /usr/local/bin/
```
最后，如下使其可执行：
```
$ sudo chmod +x /usr/local/bin/qr-filetransfer
```
### 通过扫描二维码将文件从计算机传输到移动设备
确保你的智能手机已连接到与计算机相同的 WiFi 网络。
然后，使用要传输的文件的完整路径启动 `qt-filetransfer`。
比如，我要传输一个 mp3 文件。
```
$ qr-filetransfer Chill\ Study\ Beats.mp3
```
首次启动时，`qr-filetransfer` 会要求你选择使用的网络接口，如下所示。
```
Choose the network interface to use (type the number):
[0] enp5s0
[1] wlp9s0
```
我打算使用 wlp9s0 接口传输文件，因此我输入 “1”。`qr-filetransfer` 会记住这个选择，除非你通过 `-force` 参数或删除程序存储在当前用户的家目录中的 `.qr-filetransfer.json` 文件，否则永远不会再提示你。
然后，你将看到二维码，如下图所示。
打开二维码应用（如果尚未安装，请从 Play 商店安装任何一个二维码读取程序）并扫描终端中显示的二维码。
读取二维码后，系统会询问你是要复制链接还是打开链接。你可以复制链接并手动将其粘贴到移动网络浏览器上，或者选择“打开链接”以在移动浏览器中自动打开它。
共享链接打开后，该文件将下载到智能手机中。
如果文件太大，请压缩文件，然后传输它：
```
$ qr-filetransfer -zip /path/to/file.txt
```
要传输整个目录，请运行：
```
$ qr-filetransfer /path/to/directory
```
请注意，目录在传输之前会被压缩。
`qr-filetransfer` 只能将系统中的内容传输到移动设备，反之不能。这个项目非常新，所以会有 bug。如果你遇到了任何 bug，请在本指南最后给出的 GitHub 页面上报告。
干杯!
---
via: <https://www.ostechnix.com/transfer-files-from-computer-to-mobile-devices-by-scanning-qr-codes/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何将树莓派配置为打印服务器
|
Jim Hall
|
https://opensource.com/article/18/3/print-server-raspberry-pi
|
用树莓派和 CUPS 打印服务器将你的打印机变成网络打印机。
|
/data/attachment/album/201805/02/122610dca53jiv5s39hvvz.jpg.thumb.jpg
|
/data/attachment/album/201805/02/122610dca53jiv5s39hvvz.jpg
| true | false | true |
qhwdw
| false |
[
"打印机",
"树莓派"
] |
树莓派
|
{
"viewnum": 15442,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用树莓派和 CUPS 打印服务器将你的打印机变成网络打印机。
| 2018-05-02T12:26:17 | 2018-05-02T12:26:17 | 9,596 |
/article-9596-1.html
|
>
> 用树莓派和 CUPS 打印服务器将你的打印机变成网络打印机。
>
>
>
我喜欢在家做一些小项目，因此，今年我买了一个 [树莓派 3 Model B](https://www.raspberrypi.org/products/raspberry-pi-3-model-b/)，这是一个非常适合像我这样的业余爱好者的东西。使用树莓派 3 Model B 的内置无线功能，我可以不使用线缆就将树莓派连接到我的家庭网络中。这样可以很容易地将树莓派用到各种所需要的地方。
在家里，我和我的妻子都使用笔记本电脑，但是我们只有一台打印机：一台使用的并不频繁的 HP 彩色激光打印机。因为我们的打印机并不内置无线网卡，因此，它不能直接连接到无线网络中，我们一般把打印机连接到我的笔记本电脑上，因为通常是我在打印。虽然这种安排在大多数时间都没有问题，但是，有时候，我的妻子想在不 “麻烦” 我的情况下，自己去打印一些东西。
我觉得我们需要一个将打印机连接到无线网络的解决方案，以便于我们都能够随时随地打印。我本想买一个无线打印服务器将我的 USB 打印机连接到家里的无线网络上。后来，我决定使用我的树莓派，将它设置为打印服务器，这样就可以让家里的每个人都可以随时来打印。
### 基本设置
设置树莓派是非常简单的事。我下载了 [Raspbian](https://www.raspberrypi.org/downloads/) 镜像，并将它写入到我的 microSD 卡中。然后，使用它来引导一个连接了 HDMI 显示器、 USB 键盘和 USB 鼠标的树莓派。之后，我们开始对它进行设置！
这个树莓派系统自动引导到一个图形桌面，然后我做了一些基本设置：设置键盘语言、连接无线网络、设置普通用户帐户（`pi`）的密码、设置管理员用户（`root`）的密码。
我并不打算将树莓派运行在桌面环境下。我一般是通过我的普通的 Linux 计算机远程来使用它。因此，我使用树莓派的图形化管理工具，去设置将树莓派引导到控制台模式，但不以 `pi` 用户自动登入。
重新启动树莓派之后，我需要做一些其它的系统方面的小调整，以便于我在家用网络中使用树莓派做为 “服务器”。我设置它的 DHCP 客户端为使用静态 IP 地址；默认情况下，DHCP 客户端可能任选一个可用的网络地址，这样我会不知道应该用哪个地址连接到树莓派。我的家用网络使用一个私有的 A 类地址，因此，我的路由器的 IP 地址是 `10.0.0.1`，并且我的全部可用地 IP 地址是 `10.0.0.x`。在我的案例中，低位的 IP 地址是安全的，因此，我通过在 `/etc/dhcpcd.conf` 中添加如下的行，设置它的无线网络使用 `10.0.0.11` 这个静态地址。
```
interface wlan0
static ip_address=10.0.0.11/24
static routers=10.0.0.1
static domain_name_servers=8.8.8.8 8.8.4.4
```
在我再次重启之前，我需要去确认安全 shell 守护程序（SSHD）已经正常运行（你可以在 “偏好” 中设置哪些服务在引导时启动它）。这样我就可以使用 SSH 从普通的 Linux 系统上基于网络连接到树莓派中。
### 打印设置
现在，我的树莓派已经连到网络上了，我通过 SSH 从我的 Linux 电脑上远程连接它，接着做剩余的设置。在继续设置之前，确保你的打印机已经连接到树莓派上。
设置打印机很容易。现代的打印服务器被称为 CUPS，意即“通用 Unix 打印系统”。任何最新的 Unix 系统都可以通过 CUPS 打印服务器来打印。为了在树莓派上设置 CUPS 打印服务器。你需要通过几个命令去安装 CUPS 软件，并使用新的配置来重启打印服务器，这样就可以允许其它系统来打印了。
```
$ sudo apt-get install cups
$ sudo cupsctl --remote-any
$ sudo /etc/init.d/cups restart
```
在 CUPS 中设置打印机也是非常简单的，你可以通过一个 Web 界面来完成。CUPS 监听端口是 631，因此你用常用的浏览器来访问这个地址：
```
https://10.0.0.11:631/
```
你的 Web 浏览器可能会弹出警告，因为它不认可这个 Web 浏览器的 https 证书；选择 “接受它”，然后以管理员用户登入系统，你将看到如下的标准的 CUPS 面板：
这时候，导航到管理标签，选择 “Add Printer”。
如果打印机已经通过 USB 连接，你只需要简单地选择这个打印机和型号。不要忘记去勾选共享这个打印机的选择框，因为其它人也要使用它。现在，你的打印机已经在 CUPS 中设置好了。
### 客户端设置
从 Linux 中设置一台网络打印机非常简单。我的桌面环境是 GNOME，你可以从 GNOME 的“设置”应用程序中添加网络打印机。只需要导航到“设备和打印机”，然后解锁这个面板。点击 “添加” 按钮去添加打印机。
在我的系统中，GNOME 的“设置”应用程序会自动发现网络打印机并添加它。如果你的系统不是这样，你需要通过树莓派的 IP 地址，手动去添加打印机。
设置到此为止！我们现在已经可以通过家中的无线网络来使用这台打印机了。我不再需要物理连接到这台打印机了，家里的任何人都可以使用它了！
---
via: <https://opensource.com/article/18/3/print-server-raspberry-pi>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 下 9 个有用的 touch 命令示例
|
Pradeep Kumar
|
https://www.linuxtechi.com/9-useful-touch-command-examples-linux/
|
touch 命令用于创建空文件，也可以更改 Unix 和 Linux 系统上现有文件时间戳。这里所说的更改时间戳意味着更新文件和目录的访问以及修改时间。
|
/data/attachment/album/201805/02/124305fz8yyeoz58xedzzd.jpg.thumb.jpg
|
/data/attachment/album/201805/02/124305fz8yyeoz58xedzzd.jpg
| true | false | true |
MjSeven
| false |
[
"touch"
] |
技术
|
{
"viewnum": 17938,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
touch 命令用于创建空文件，也可以更改 Unix 和 Linux 系统上现有文件时间戳。这里所说的更改时间戳意味着更新文件和目录的访问以及修改时间。
| 2018-05-02T12:43:20 | 2018-05-02T12:43:20 | 9,597 |
/article-9597-1.html
|
`touch` 命令用于创建空文件，也可以更改 Unix 和 Linux 系统上现有文件时间戳。这里所说的更改时间戳意味着更新文件和目录的访问以及修改时间。
让我们来看看 `touch` 命令的语法和选项：
**语法**：
```
# touch {选项} {文件}
```
`touch` 命令中使用的选项：
在这篇文章中，我们将介绍 Linux 中 9 个有用的 `touch` 命令示例。
### 示例：1 使用 touch 创建一个空文件
要在 Linux 系统上使用 `touch` 命令创建空文件，键入 `touch`，然后输入文件名。如下所示：
```
[root@linuxtechi ~]# touch devops.txt
[root@linuxtechi ~]# ls -l devops.txt
-rw-r--r--. 1 root root 0 Mar 29 22:39 devops.txt
```
### 示例：2 使用 touch 创建批量空文件
可能会出现一些情况，我们必须为某些测试创建大量空文件，这可以使用 `touch` 命令轻松实现：
```
[root@linuxtechi ~]# touch sysadm-{1..20}.txt
```
在上面的例子中，我们创建了 20 个名为 `sysadm-1.txt` 到 `sysadm-20.txt` 的空文件，你可以根据需要更改名称和数字。
### 示例：3 改变/更新文件和目录的访问时间
假设我们想要改变名为 `devops.txt` 文件的访问时间，在 `touch` 命令中使用 `-a` 选项，然后输入文件名。如下所示：
```
[root@linuxtechi ~]# touch -a devops.txt
```
现在使用 `stat` 命令验证文件的访问时间是否已更新：
```
[root@linuxtechi ~]# stat devops.txt
File: 'devops.txt'
Size: 0 Blocks: 0 IO Block: 4096 regular empty file
Device: fd00h/64768d Inode: 67324178 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Context: unconfined_u:object_r:admin_home_t:s0
Access: 2018-03-29 23:03:10.902000000 -0400
Modify: 2018-03-29 22:39:29.365000000 -0400
Change: 2018-03-29 23:03:10.902000000 -0400
Birth: -
```
**改变目录的访问时间：**
假设我们在 `/mnt` 目录下有一个 `nfsshare` 文件夹，让我们用下面的命令改变这个文件夹的访问时间：
```
[root@linuxtechi ~]# touch -m /mnt/nfsshare/
[root@linuxtechi ~]# stat /mnt/nfsshare/
File: '/mnt/nfsshare/'
Size: 6 Blocks: 0 IO Block: 4096 directory
Device: fd00h/64768d Inode: 2258 Links: 2
Access: (0755/drwxr-xr-x) Uid: ( 0/ root) Gid: ( 0/ root)
Context: unconfined_u:object_r:mnt_t:s0
Access: 2018-03-29 23:34:38.095000000 -0400
Modify: 2018-03-03 10:42:45.194000000 -0500
Change: 2018-03-29 23:34:38.095000000 -0400
Birth: -
```
### 示例：4 更改访问时间而不用创建新文件
在某些情况下，如果文件存在，我们希望更改文件的访问时间，并避免创建文件。在 touch 命令中使用 `-c` 选项即可，如果文件存在，那么我们可以改变文件的访问时间，如果不存在，我们也可不会创建它。
```
[root@linuxtechi ~]# touch -c sysadm-20.txt
[root@linuxtechi ~]# touch -c winadm-20.txt
[root@linuxtechi ~]# ls -l winadm-20.txt
ls: cannot access winadm-20.txt: No such file or directory
```
### 示例：5 更改文件和目录的修改时间
在 `touch` 命令中使用 `-m` 选项，我们可以更改文件和目录的修改时间。
让我们更改名为 `devops.txt` 文件的更改时间：
```
[root@linuxtechi ~]# touch -m devops.txt
```
现在使用 `stat` 命令来验证修改时间是否改变：
```
[root@linuxtechi ~]# stat devops.txt
File: 'devops.txt'
Size: 0 Blocks: 0 IO Block: 4096 regular empty file
Device: fd00h/64768d Inode: 67324178 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Context: unconfined_u:object_r:admin_home_t:s0
Access: 2018-03-29 23:03:10.902000000 -0400
Modify: 2018-03-29 23:59:49.106000000 -0400
Change: 2018-03-29 23:59:49.106000000 -0400
Birth: -
```
同样的，我们可以改变一个目录的修改时间：
```
[root@linuxtechi ~]# touch -m /mnt/nfsshare/
```
使用 `stat` 交叉验证访问和修改时间：
```
[root@linuxtechi ~]# stat devops.txt
File: 'devops.txt'
Size: 0 Blocks: 0 IO Block: 4096 regular empty file
Device: fd00h/64768d Inode: 67324178 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Context: unconfined_u:object_r:admin_home_t:s0
Access: 2018-03-30 00:06:20.145000000 -0400
Modify: 2018-03-30 00:06:20.145000000 -0400
Change: 2018-03-30 00:06:20.145000000 -0400
Birth: -
```
### 示例：7 将访问和修改时间设置为特定的日期和时间
每当我们使用 `touch` 命令更改文件和目录的访问和修改时间时，它将当前时间设置为该文件或目录的访问和修改时间。
假设我们想要将特定的日期和时间设置为文件的访问和修改时间，这可以使用 `touch` 命令中的 `-c` 和 `-t` 选项来实现。
日期和时间可以使用以下格式指定：
```
{CCYY}MMDDhhmm.ss
```
其中：
* `CC` – 年份的前两位数字
* `YY` – 年份的后两位数字
* `MM` – 月份 (01-12)
* `DD` – 天 (01-31)
* `hh` – 小时 (00-23)
* `mm` – 分钟 (00-59)
让我们将 `devops.txt` 文件的访问和修改时间设置为未来的一个时间（2025 年 10 月 19 日 18 时 20 分）。
```
[root@linuxtechi ~]# touch -c -t 202510191820 devops.txt
```
使用 `stat` 命令查看更新访问和修改时间：
根据日期字符串设置访问和修改时间，在 `touch` 命令中使用 `-d` 选项，然后指定日期字符串，后面跟文件名。如下所示：
```
[root@linuxtechi ~]# touch -c -d "2010-02-07 20:15:12.000000000 +0530" sysadm-29.txt
```
使用 `stat` 命令验证文件的状态：
```
[root@linuxtechi ~]# stat sysadm-20.txt
File: ‘sysadm-20.txt’
Size: 0 Blocks: 0 IO Block: 4096 regular empty file
Device: fd00h/64768d Inode: 67324189 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
Context: unconfined_u:object_r:admin_home_t:s0
Access: 2010-02-07 20:15:12.000000000 +0530
Modify: 2010-02-07 20:15:12.000000000 +0530
Change: 2018-03-30 10:23:31.584000000 +0530
Birth: -
```
**注意：**在上述命令中，如果我们不指定 `-c`，如果系统中不存在该文件那么 `touch` 命令将创建一个新文件，并将时间戳设置为命令中给出的。
### 示例：8 使用参考文件设置时间戳（-r）
在 `touch` 命令中，我们可以使用参考文件来设置文件或目录的时间戳。假设我想在 `devops.txt` 文件上设置与文件 `sysadm-20.txt` 文件相同的时间戳，`touch` 命令中使用 `-r` 选项可以轻松实现。
**语法：**
```
# touch -r {参考文件} 真正文件
```
```
[root@linuxtechi ~]# touch -r sysadm-20.txt devops.txt
```
### 示例：9 在符号链接文件上更改访问和修改时间
默认情况下，每当我们尝试使用 `touch` 命令更改符号链接文件的时间戳时，它只会更改原始文件的时间戳。如果你想更改符号链接文件的时间戳，则可以使用 `touch` 命令中的 `-h` 选项来实现。
**语法：**
```
# touch -h {符号链接文件}
```
```
[root@linuxtechi opt]# ls -l /root/linuxgeeks.txt
lrwxrwxrwx. 1 root root 15 Mar 30 10:56 /root/linuxgeeks.txt -> linuxadmins.txt
[root@linuxtechi ~]# touch -t 203010191820 -h linuxgeeks.txt
[root@linuxtechi ~]# ls -l linuxgeeks.txt
lrwxrwxrwx. 1 root root 15 Oct 19 2030 linuxgeeks.txt -> linuxadmins.txt
```
这就是本教程的全部了。我希望这些例子能帮助你理解 `touch` 命令。请分享你的宝贵意见和评论。
---
via: <https://www.linuxtechi.com/9-useful-touch-command-examples-linux/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 rsync 通过 SSH 恢复部分传输的文件
|
Sk
|
https://www.ostechnix.com/how-to-resume-partially-downloaded-or-transferred-files-using-rsync/
|
如果你想通过 SSH 下载或传输大文件和文件夹，我建议您使用 rsync。
|
/data/attachment/album/201805/02/213612q358zdhp490d299o.png.thumb.jpg
|
/data/attachment/album/201805/02/213612q358zdhp490d299o.png
| true | false | true |
geekpi
| false |
[
"scp",
"rsync"
] |
技术
|
{
"viewnum": 6420,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你想通过 SSH 下载或传输大文件和文件夹，我建议您使用 rsync。
| 2018-05-02T21:36:09 | 2018-05-02T21:36:09 | 9,599 |
/article-9599-1.html
|
由于诸如电源故障、网络故障或用户干预等各种原因，使用 `scp` 命令通过 SSH 复制的大型文件可能会中断、取消或损坏。有一天，我将 Ubuntu 16.04 ISO 文件复制到我的远程系统。不幸的是断电了，网络连接立即断了。结果么？复制过程终止！这只是一个简单的例子。Ubuntu ISO 并不是那么大，一旦电源恢复，我就可以重新启动复制过程。但在生产环境中，当你在传输大型文件时，你可能并不希望这样做。
而且，你不能继续使用 `scp` 命令恢复被中止的进度。因为，如果你这样做，它只会覆盖现有的文件。这时你会怎么做？别担心！这是 `rsync` 派上用场的地方！`rsync` 可以帮助你恢复中断的复制或下载过程。对于那些好奇的人，`rsync` 是一个快速、多功能的文件复制程序，可用于复制和传输远程和本地系统中的文件或文件夹。
它提供了大量控制其各种行为的选项，并允许非常灵活地指定要复制的一组文件。它以增量传输算法而闻名，它通过仅发送源文件和目标中现有文件之间的差异来减少通过网络发送的数据量。 `rsync` 广泛用于备份和镜像，以及日常使用中改进的复制命令。
就像 `scp` 一样，`rsync` 也会通过 SSH 复制文件。如果你想通过 SSH 下载或传输大文件和文件夹，我建议您使用 `rsync`。请注意，应该在两边（远程和本地系统）都安装 `rsync` 来恢复部分传输的文件。
### 使用 rsync 恢复部分传输的文件
好吧，让我给你看一个例子。我将使用命令将 Ubuntu 16.04 ISO 从本地系统复制到远程系统：
```
$ scp Soft_Backup/OS\ Images/Linux/ubuntu-16.04-desktop-amd64.iso sk@192.168.43.2:/home/sk/
```
这里，
* `sk`是我的远程系统的用户名
* `192.168.43.2` 是远程机器的 IP 地址。
现在，我按下 `CTRL+C` 结束它。
示例输出：
```
sk@192.168.43.2's password:
ubuntu-16.04-desktop-amd64.iso 26% 372MB 26.2MB/s 00:39 ETA^c
```
正如你在上面的输出中看到的，当它达到 26％ 时，我终止了复制过程。
如果我重新运行上面的命令，它只会覆盖现有的文件。换句话说，复制过程不会在我断开的地方恢复。
为了恢复复制过程，我们可以使用 `rsync` 命令，如下所示。
```
$ rsync -P -rsh=ssh Soft_Backup/OS\ Images/Linux/ubuntu-16.04-desktop-amd64.iso sk@192.168.43.2:/home/sk/
```
示例输出：
```
sk@192.168.1.103's password:
sending incremental file list
ubuntu-16.04-desktop-amd64.iso
380.56M 26% 41.05MB/s 0:00:25
```
看见了吗？现在，复制过程在我们之前断开的地方恢复了。你也可以像下面那样使用 `-partial` 而不是 `-P` 参数。
```
$ rsync --partial -rsh=ssh Soft_Backup/OS\ Images/Linux/ubuntu-16.04-desktop-amd64.iso sk@192.168.43.2:/home/sk/
```
这里，参数 `-partial` 或 `-P` 告诉 `rsync` 命令保留部分下载的文件并恢复进度。
或者，我们也可以使用以下命令通过 SSH 恢复部分传输的文件。
```
$ rsync -avP Soft_Backup/OS\ Images/Linux/ubuntu-16.04-desktop-amd64.iso sk@192.168.43.2:/home/sk/
```
或者，
```
rsync -av --partial Soft_Backup/OS\ Images/Linux/ubuntu-16.04-desktop-amd64.iso sk@192.168.43.2:/home/sk/
```
就是这样了。你现在知道如何使用 `rsync` 命令恢复取消、中断和部分下载的文件。正如你所看到的，它也不是那么难。如果两个系统都安装了 `rsync`，我们可以轻松地通过上面描述的那样恢复复制的进度。
如果你觉得本教程有帮助，请在你的社交、专业网络上分享，并支持我们。还有更多的好东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/how-to-resume-partially-downloaded-or-transferred-files-using-rsync/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Pet：一个简单的命令行片段管理器
|
Sk
|
https://www.ostechnix.com/pet-simple-command-line-snippet-manager/
|
我们不可能记住所有的命令，对吧？是的。除了经常使用的命令之外，我们几乎不可能记住一些很少使用的长命令。这就是为什么需要一些外部工具来帮助我们在需要时找到命令。
|
/data/attachment/album/201805/02/215308xwpxpxrxpxxre5xa.png.thumb.jpg
|
/data/attachment/album/201805/02/215308xwpxpxrxpxxre5xa.png
| true | false | true |
MjSeven
| false |
[
"命令行"
] |
技术
|
{
"viewnum": 6207,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们不可能记住所有的命令，对吧？是的。除了经常使用的命令之外，我们几乎不可能记住一些很少使用的长命令。这就是为什么需要一些外部工具来帮助我们在需要时找到命令。
| 2018-05-02T21:53:06 | 2018-05-02T21:53:06 | 9,600 |
/article-9600-1.html
|
我们不可能记住所有的命令，对吧？是的。除了经常使用的命令之外，我们几乎不可能记住一些很少使用的长命令。这就是为什么需要一些外部工具来帮助我们在需要时找到命令。在过去，我们已经点评了两个有用的工具，名为 “Bashpast” 和 “Keep”。使用 Bashpast，我们可以轻松地为 Linux 命令添加书签，以便更轻松地重复调用。而 Keep 实用程序可以用来在终端中保留一些重要且冗长的命令，以便你可以随时使用它们。今天，我们将看到该系列中的另一个工具，以帮助你记住命令。现在让我们认识一下 “Pet”，这是一个用 Go 语言编写的简单的命令行代码管理器。
使用 Pet，你可以：
* 注册/添加你重要的、冗长和复杂的命令片段。
* 以交互方式来搜索保存的命令片段。
* 直接运行代码片段而无须一遍又一遍地输入。
* 轻松编辑保存的代码片段。
* 通过 Gist 同步片段。
* 在片段中使用变量
* 还有很多特性即将来临。
### 安装 Pet 命令行接口代码管理器
由于它是用 Go 语言编写的，所以确保你在系统中已经安装了 Go。
安装 Go 后，从 [**Pet 发布页面**](https://github.com/knqyf263/pet/releases) 获取最新的二进制文件。
```
wget https://github.com/knqyf263/pet/releases/download/v0.2.4/pet_0.2.4_linux_amd64.zip
```
对于 32 位计算机：
```
wget https://github.com/knqyf263/pet/releases/download/v0.2.4/pet_0.2.4_linux_386.zip
```
解压下载的文件：
```
unzip pet_0.2.4_linux_amd64.zip
```
对于 32 位：
```
unzip pet_0.2.4_linux_386.zip
```
将 `pet` 二进制文件复制到 PATH（即 `/usr/local/bin` 之类的）。
```
sudo cp pet /usr/local/bin/
```
最后，让它可以执行：
```
sudo chmod +x /usr/local/bin/pet
```
如果你使用的是基于 Arch 的系统，那么你可以使用任何 AUR 帮助工具从 AUR 安装它。
使用 [Pacaur](https://www.ostechnix.com/install-pacaur-arch-linux/)：
```
pacaur -S pet-git
```
使用 [Packer](https://www.ostechnix.com/install-packer-arch-linux-2/)：
```
packer -S pet-git
```
使用 [Yaourt](https://www.ostechnix.com/install-yaourt-arch-linux/)：
```
yaourt -S pet-git
```
使用 [Yay](https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/)：
```
yay -S pet-git
```
此外，你需要安装 [fzf](https://github.com/junegunn/fzf) 或 [peco](https://github.com/peco/peco) 工具以启用交互式搜索。请参阅官方 GitHub 链接了解如何安装这些工具。
### 用法
运行没有任何参数的 `pet` 来查看可用命令和常规选项的列表。
```
$ pet
pet - Simple command-line snippet manager.
Usage:
pet [command]
Available Commands:
configure Edit config file
edit Edit snippet file
exec Run the selected commands
help Help about any command
list Show all snippets
new Create a new snippet
search Search snippets
sync Sync snippets
version Print the version number
Flags:
--config string config file (default is $HOME/.config/pet/config.toml)
--debug debug mode
-h, --help help for pet
Use "pet [command] --help" for more information about a command.
```
要查看特定命令的帮助部分，运行：
```
$ pet [command] --help
```
#### 配置 Pet
默认配置其实工作的挺好。但是，你可以更改保存片段的默认目录，选择要使用的选择器（fzf 或 peco），编辑片段的默认文本编辑器，添加 GIST id 详细信息等。
要配置 Pet，运行：
```
$ pet configure
```
该命令将在默认的文本编辑器中打开默认配置（例如我是 vim），根据你的要求更改或编辑特定值。
```
[General]
snippetfile = "/home/sk/.config/pet/snippet.toml"
editor = "vim"
column = 40
selectcmd = "fzf"
[Gist]
file_name = "pet-snippet.toml"
access_token = ""
gist_id = ""
public = false
~
```
#### 创建片段
为了创建一个新的片段，运行：
```
$ pet new
```
添加命令和描述，然后按下回车键保存它。
```
Command> echo 'Hell1o, Welcome1 2to OSTechNix4' | tr -d '1-9'
Description> Remove numbers from output.
```
这是一个简单的命令，用于从 `echo` 命令输出中删除所有数字。你可以很轻松地记住它。但是，如果你很少使用它，几天后你可能会完全忘记它。当然，我们可以使用 `CTRL+R` 搜索历史记录，但 Pet 会更容易。另外，Pet 可以帮助你添加任意数量的条目。
另一个很酷的功能是我们可以轻松添加以前的命令。为此，在你的 `.bashrc` 或 `.zshrc` 文件中添加以下行。
```
function prev() {
PREV=$(fc -lrn | head -n 1)
sh -c "pet new `printf %q "$PREV"`"
}
```
执行以下命令来使保存的更改生效。
```
source .bashrc
```
或者：
```
source .zshrc
```
现在，运行任何命令，例如：
```
$ cat Documents/ostechnix.txt | tr '|' '\n' | sort | tr '\n' '|' | sed "s/.$/\\n/g"
```
要添加上述命令，你不必使用 `pet new` 命令。只需要：
```
$ prev
```
将说明添加到该命令代码片段中，然后按下回车键保存。
#### 片段列表
要查看保存的片段，运行：
```
$ pet list
```
#### 编辑片段
如果你想编辑代码片段的描述或命令，运行：
```
$ pet edit
```
这将在你的默认文本编辑器中打开所有保存的代码片段，你可以根据需要编辑或更改片段。
```
[[snippets]]
description = "Remove numbers from output."
command = "echo 'Hell1o, Welcome1 2to OSTechNix4' | tr -d '1-9'"
output = ""
[[snippets]]
description = "Alphabetically sort one line of text"
command = "\t prev"
output = ""
```
#### 在片段中使用标签
要将标签用于判断，使用下面的 `-t` 标志。
```
$ pet new -t
Command> echo 'Hell1o, Welcome1 2to OSTechNix4' | tr -d '1-9
Description> Remove numbers from output.
Tag> tr command examples
```
#### 执行片段
要执行一个保存的片段，运行：
```
$ pet exec
```
从列表中选择你要运行的代码段，然后按回车键来运行它：
记住你需要安装 fzf 或 peco 才能使用此功能。
#### 寻找片段
如果你有很多要保存的片段，你可以使用字符串或关键词如 below.qjz 轻松搜索它们。
```
$ pet search
```
输入搜索字词或关键字以缩小搜索结果范围。
#### 同步片段
首先，你需要获取访问令牌。转到此链接 <https://github.com/settings/tokens/new> 并创建访问令牌（只需要 “gist” 范围）。
使用以下命令来配置 Pet：
```
$ pet configure
```
将令牌设置到 `[Gist]` 字段中的 `access_token`。
设置完成后，你可以像下面一样将片段上传到 Gist。
```
$ pet sync -u
Gist ID: 2dfeeeg5f17e1170bf0c5612fb31a869
Upload success
```
你也可以在其他 PC 上下载片段。为此，编辑配置文件并在 `[Gist]` 中将 `gist_id` 设置为 GIST id。
之后，使用以下命令下载片段：
```
$ pet sync
Download success
```
获取更多细节，参阅帮助选项：
```
pet -h
```
或者：
```
pet [command] -h
```
这就是全部了。希望这可以帮助到你。正如你所看到的，Pet 使用相当简单易用！如果你很难记住冗长的命令，Pet 实用程序肯定会有用。
干杯！
---
via: <https://www.ostechnix.com/pet-simple-command-line-snippet-manager/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
每个 Linux 新手都应该知道的 10 个命令
|
Sam Bocetta
|
https://opensource.com/article/18/4/10-commands-new-linux-users
|
通过这 10 个基础命令开始掌握 Linux 命令行。
|
/data/attachment/album/201805/02/221728tjakfazeqfjkluj5.jpeg.thumb.jpg
|
/data/attachment/album/201805/02/221728tjakfazeqfjkluj5.jpeg
| true | false | true |
MjSeven
| false |
[
"命令行"
] |
技术
|
{
"viewnum": 9594,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过这 10 个基础命令开始掌握 Linux 命令行。
| 2018-05-02T22:17:37 | 2018-05-02T22:17:37 | 9,601 |
/article-9601-1.html
|
>
> 通过这 10 个基础命令开始掌握 Linux 命令行。
>
>
>
你可能认为你是 Linux 新手，但实际上并不是。全球互联网用户有 [3.74 亿](https://hostingcanada.org/state-of-the-internet/)，他们都以某种方式使用 Linux，因为 Linux 服务器占据了互联网的 90%。大多数现代路由器运行 Linux 或 Unix，[TOP500 超级计算机](https://www.top500.org/statistics/details/osfam/1) 也依赖于 Linux。如果你拥有一台 Android 智能手机，那么你的操作系统就是由 Linux 内核构建的。
换句话说，Linux 无处不在。
但是使用基于 Linux 的技术和使用 Linux 本身是有区别的。如果你对 Linux 感兴趣，但是一直在使用 PC 或者 Mac 桌面，你可能想知道你需要知道什么才能使用 Linux 命令行接口（CLI），那么你来到了正确的地方。
下面是你需要知道的基本的 Linux 命令。每一个都很简单，也很容易记住。换句话说，你不必成为比尔盖茨就能理解它们。
### 1、 ls
你可能会想：“这是（is）什么东西？”不，那不是一个印刷错误 —— 我真的打算输入一个小写的 l。`ls`，或者说 “list”， 是你需要知道的使用 Linux CLI 的第一个命令。这个 list 命令在 Linux 终端中运行，以显示在存放在相应文件系统下的所有主要目录。例如，这个命令：
```
ls /applications
```
显示存储在 `applications` 文件夹下的每个文件夹，你将使用它来查看文件、文件夹和目录。
显示所有隐藏的文件都可以使用命令 `ls -a`。
### 2、 cd
这个命令是你用来跳转（或“更改”）到一个目录的。它指导你如何从一个文件夹导航到另一个文件夹。假设你位于 `Downloads` 文件夹中，但你想到名为 `Gym Playlist` 的文件夹中，简单地输入 `cd Gym Playlist` 将不起作用，因为 shell 不会识别它，并会报告你正在查找的文件夹不存在（LCTT 译注：这是因为目录名中有空格）。要跳转到那个文件夹，你需要包含一个反斜杠。改命令如下所示：
```
cd Gym\ Playlist
```
要从当前文件夹返回到上一个文件夹，你可以在该文件夹输入 `cd ..`。把这两个点想象成一个后退按钮。
### 3、 mv
该命令将文件从一个文件夹转移到另一个文件夹；`mv` 代表“移动”。你可以使用这个简单的命令，就像你把一个文件拖到 PC 上的一个文件夹一样。
例如，如果我想创建一个名为 `testfile` 的文件来演示所有基本的 Linux 命令，并且我想将它移动到我的 `Documents` 文件夹中，我将输入这个命令：
```
mv /home/sam/testfile /home/sam/Documents/
```
命令的第一部分（`mv`）说我想移动一个文件，第二部分（`home/sam/testfile`）表示我想移动的文件，第三部分（`/home/sam/Documents/`）表示我希望传输文件的位置。
### 4、 快捷键
好吧，这不止一个命令，但我忍不住把它们都包括进来。为什么？因为它们能节省时间并避免经历头痛。
* `CTRL+K` 从光标处剪切文本直至本行结束
* `CTRL+Y` 粘贴文本
* `CTRL+E` 将光标移到本行的末尾
* `CTRL+A` 将光标移动到本行的开头
* `ALT+F` 跳转到下一个空格处
* `ALT+B` 回到前一个空格处
* `ALT+Backspace` 删除前一个词
* `CTRL+W` 剪切光标前一个词
* `Shift+Insert` 将文本粘贴到终端中
* `Ctrl+D` 注销
这些命令在许多方面都能派上用场。例如，假设你在命令行文本中拼错了一个单词：
```
sudo apt-get intall programname
```
你可能注意到 `install` 拼写错了，因此该命令无法工作。但是快捷键可以让你很容易回去修复它。如果我的光标在这一行的末尾，我可以按下两次 `ALT+B` 来将光标移动到下面用 `^` 符号标记的地方：
```
sudo apt-get^intall programname
```
现在，我们可以快速地添加字母 `s` 来修复 `install`，十分简单！
### 5、 mkdir
这是你用来在 Linux 环境下创建目录或文件夹的命令。例如，如果你像我一样喜欢 DIY，你可以输入 `mkdir DIY` 为你的 DIY 项目创建一个目录。
### 6、 at
如果你想在特定时间运行 Linux 命令，你可以将 `at` 添加到语句中。语法是 `at` 后面跟着你希望命令运行的日期和时间，然后命令提示符变为 `at>`，这样你就可以输入在上面指定的时间运行的命令。
例如：
```
at 4:08 PM Sat
at> cowsay 'hello'
at> CTRL+D
```
这将会在周六下午 4:08 运行 `cowsay` 程序。
### 7、 rmdir
这个命令允许你通过 Linux CLI 删除一个目录。例如：
```
rmdir testdirectory
```
请记住，这个命令不会删除里面有文件的目录。这只在删除空目录时才起作用。
### 8、 rm
如果你想删除文件，`rm` 命令就是你想要的。它可以删除文件和目录。要删除一个文件，键入 `rm testfile`，或者删除一个目录和里面的文件，键入 `rm -r`。
### 9、 touch
`touch` 命令，也就是所谓的 “make file 的命令”，允许你使用 Linux CLI 创建新的、空的文件。很像 `mkdir` 创建目录，`touch` 会创建文件。例如，`touch testfile` 将会创建一个名为 testfile 的空文件。
### 10、 locate
这个命令是你在 Linux 系统中用来查找文件的命令。就像在 Windows 中搜索一样，如果你忘了存储文件的位置或它的名字，这是非常有用的。
例如，如果你有一个关于区块链用例的文档，但是你忘了标题，你可以输入 `locate -blockchain` 或者通过用星号分隔单词来查找 "blockchain use cases"，或者星号（`*`）。例如：
```
locate -i*blockchain*use*cases*
```
还有很多其他有用的 Linux CLI 命令，比如 `pkill` 命令，如果你开始关机但是你意识到你并不想这么做，那么这条命令很棒。但是这里描述的 10 个简单而有用的命令是你开始使用 Linux 命令行所需的基本知识。
---
via: <https://opensource.com/article/18/4/10-commands-new-linux-users>
作者：[Sam Bocetta](https://opensource.com/users/sambocetta) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中快速监控多个主机
|
Sk
|
https://www.ostechnix.com/how-to-quickly-monitor-multiple-hosts-in-linux/
|
只要安装了 rwho 实用程序，它将立即快速地监控本地和远程系统。你什么都不用配置！你所要做的就是在要监视的系统上安装 “rwho” 工具。
|
/data/attachment/album/201805/03/212747f334s2935koor536.png.thumb.jpg
|
/data/attachment/album/201805/03/212747f334s2935koor536.png
| true | false | true |
MjSeven
| false |
[
"who",
"rwho"
] |
技术
|
{
"viewnum": 6134,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
只要安装了 rwho 实用程序，它将立即快速地监控本地和远程系统。你什么都不用配置！你所要做的就是在要监视的系统上安装 “rwho” 工具。
| 2018-05-03T21:27:00 | 2018-05-03T21:27:00 | 9,602 |
/article-9602-1.html
|
有很多监控工具可用来监控本地和远程 Linux 系统，一个很好的例子是 [Cockpit](https://www.ostechnix.com/cockpit-monitor-administer-linux-servers-via-web-browser/)。但是，这些工具的安装和使用比较复杂，至少对于新手管理员来说是这样。新手管理员可能需要花一些时间来弄清楚如何配置这些工具来监视系统。如果你想要以快速且粗略地在局域网中一次监控多台主机，你可能需要了解一下 “rwho” 工具。只要安装了 rwho 实用程序，它将立即快速地监控本地和远程系统。你什么都不用配置！你所要做的就是在要监视的系统上安装 “rwho” 工具。
请不要将 rwho 视为功能丰富且完整的监控工具。这只是一个简单的工具，它只监视远程系统的“正常运行时间”（`uptime`），“负载”（`load`）和**登录的用户**。使用 “rwho” 使用程序，我们可以发现谁在哪台计算机上登录；一个被监视的计算机的列表，列出了正常运行时间（自上次重新启动以来的时间）；有多少用户登录了；以及在过去的 1、5、15 分钟的平均负载。不多不少！而且，它只监视同一子网中的系统。因此，它非常适合小型和家庭办公网络。
### 在 Linux 中监控多台主机
让我来解释一下 `rwho` 是如何工作的。每个在网络上使用 `rwho` 的系统都将广播关于它自己的信息，其他计算机可以使用 `rwhod` 守护进程来访问这些信息。因此，网络上的每台计算机都必须安装 `rwho`。此外，为了分发或访问其他主机的信息，必须允许 `rwho` 端口（例如端口 `513/UDP`）通过防火墙/路由器。
好的，让我们来安装它。
我在 Ubuntu 16.04 LTS 服务器上进行了测试，`rwho` 在默认仓库中可用，所以，我们可以使用像下面这样的 APT 软件包管理器来安装它。
```
$ sudo apt-get install rwho
```
在基于 RPM 的系统如 CentOS、 Fedora、 RHEL 上，使用以下命令来安装它：
```
$ sudo yum install rwho
```
如果你在防火墙/路由器之后，确保你已经允许使用 rwhod 513 端口。另外，使用命令验证 `rwhod` 守护进程是否正在运行：
```
$ sudo systemctl status rwhod
```
如果它尚未启动，运行以下命令启用并启动 `rwhod` 服务：
```
$ sudo systemctl enable rwhod
$ sudo systemctl start rwhod
```
现在是时候来监视系统了。运行以下命令以发现谁在哪台计算机上登录：
```
$ rwho
ostechni ostechnix:pts/5 Mar 12 17:41
root server:pts/0 Mar 12 17:42
```
正如你所看到的，目前我的局域网中有两个系统。本地系统用户是 `ostechnix` （Ubuntu 16.04 LTS），远程系统的用户是 `root` （CentOS 7）。可能你已经猜到了，`rwho` 与 `who` 命令相似，但它会监视远程系统。
而且，我们可以使用以下命令找到网络上所有正在运行的系统的正常运行时间：
```
$ ruptime
ostechnix up 2:17, 1 user, load 0.09, 0.03, 0.01
server up 1:54, 1 user, load 0.00, 0.01, 0.05
```
这里，`ruptime`（类似于 `uptime` 命令）显示了我的 Ubuntu（本地） 和 CentOS（远程）系统的总运行时间。明白了吗？棒极了！以下是我的 Ubuntu 16.04 LTS 系统的示例屏幕截图：
你可以在以下位置找到有关局域网中所有其他机器的信息：
```
$ ls /var/spool/rwho/
whod.ostechnix whod.server
```
它很小，但却非常有用，可以发现谁在哪台计算机上登录，以及正常运行时间和系统负载详情。
**建议阅读：**
请注意，这种方法有一个严重的漏洞。由于有关每台计算机的信息都通过网络进行广播，因此该子网中的每个人都可能获得此信息。通常情况下可以，但另一方面，当有关网络的信息分发给非授权用户时，这可能是不必要的副作用。因此，强烈建议在受信任和受保护的局域网中使用它。
更多的信息，查找 man 手册页。
```
$ man rwho
```
好了，这就是全部了。更多好东西要来了，敬请期待！
干杯！
---
via: <https://www.ostechnix.com/how-to-quickly-monitor-multiple-hosts-in-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 Linux 防火墙隔离本地欺骗地址
|
Michael Kwaku Aboagye
|
https://opensource.com/article/18/2/block-local-spoofed-addresses-using-linux-firewall
|
如何使用 iptables 防火墙保护你的网络免遭黑客攻击。
|
/data/attachment/album/201805/04/073315i195044i74l3e5v1.png.thumb.jpg
|
/data/attachment/album/201805/04/073315i195044i74l3e5v1.png
| true | false | true |
leemeans
| false |
[
"iptables",
"防火墙"
] |
技术
|
{
"viewnum": 5027,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如何使用 iptables 防火墙保护你的网络免遭黑客攻击。
| 2018-05-04T07:33:12 | 2018-05-04T07:33:12 | 9,603 |
/article-9603-1.html
|
>
> 如何使用 iptables 防火墙保护你的网络免遭黑客攻击。
>
>
>
即便是被入侵检测和隔离系统所保护的远程网络，黑客们也在寻找各种精巧的方法入侵。IDS/IPS 不能停止或者减少那些想要接管你的网络控制权的黑客攻击。不恰当的配置允许攻击者绕过所有部署的安全措施。
在这篇文章中，我将会解释安全工程师或者系统管理员该怎样避免这些攻击。
几乎所有的 Linux 发行版都带着一个内建的防火墙来保护运行在 Linux 主机上的进程和应用程序。大多数防火墙都按照 IDS/IPS 解决方案设计，这样的设计的主要目的是检测和避免恶意包获取网络的进入权。
Linux 防火墙通常有两种接口：iptables 和 ipchains 程序（LCTT 译注：在支持 systemd 的系统上，采用的是更新的接口 firewalld）。大多数人将这些接口称作 iptables 防火墙或者 ipchains 防火墙。这两个接口都被设计成包过滤器。iptables 是有状态防火墙，其基于先前的包做出决定。ipchains 不会基于先前的包做出决定，它被设计为无状态防火墙。
在这篇文章中，我们将会专注于内核 2.4 之后出现的 iptables 防火墙。
有了 iptables 防火墙，你可以创建策略或者有序的规则集，规则集可以告诉内核该如何对待特定的数据包。在内核中的是Netfilter 框架。Netfilter 既是框架也是 iptables 防火墙的项目名称。作为一个框架，Netfilter 允许 iptables 勾连被设计来操作数据包的功能。概括地说，iptables 依靠 Netfilter 框架构筑诸如过滤数据包数据的功能。
每个 iptables 规则都被应用到一个表中的链上。一个 iptables 链就是一个比较包中相似特征的规则集合。而表（例如 `nat` 或者 `mangle`）则描述不同的功能目录。例如， `mangle` 表用于修改包数据。因此，特定的修改包数据的规则被应用到这里；而过滤规则被应用到 `filter` 表，因为 `filter` 表过滤包数据。
iptables 规则有一个匹配集，以及一个诸如 `Drop` 或者 `Deny` 的目标，这可以告诉 iptables 对一个包做什么以符合规则。因此，没有目标和匹配集，iptables 就不能有效地处理包。如果一个包匹配了一条规则，目标会指向一个将要采取的特定措施。另一方面，为了让 iptables 处理，每个数据包必须匹配才能被处理。
现在我们已经知道 iptables 防火墙如何工作，让我们着眼于如何使用 iptables 防火墙检测并拒绝或丢弃欺骗地址吧。
### 打开源地址验证
作为一个安全工程师，在处理远程的欺骗地址的时候，我采取的第一步是在内核打开源地址验证。
源地址验证是一种内核层级的特性，这种特性丢弃那些伪装成来自你的网络的包。这种特性使用反向路径过滤器方法来检查收到的包的源地址是否可以通过包到达的接口可以到达。（LCTT 译注：到达的包的源地址应该可以从它到达的网络接口反向到达，只需反转源地址和目的地址就可以达到这样的效果）
利用下面简单的脚本可以打开源地址验证而不用手工操作：
```
#!/bin/sh
#作者: Michael K Aboagye
#程序目标: 打开反向路径过滤
#日期: 7/02/18
#在屏幕上显示 “enabling source address verification”
echo -n "Enabling source address verification…"
#将值0覆盖为1来打开源地址验证
echo 1 > /proc/sys/net/ipv4/conf/default/rp_filter
echo "completed"
```
上面的脚本在执行的时候只显示了 `Enabling source address verification` 这条信息而不会换行。默认的反向路径过滤的值是 `0`，`0` 表示没有源验证。因此，第二行简单地将默认值 `0` 覆盖为 `1`。`1` 表示内核将会通过确认反向路径来验证源地址。
最后，你可以使用下面的命令通过选择 `DROP` 或者 `REJECT` 目标之一来丢弃或者拒绝来自远端主机的欺骗地址。但是，处于安全原因的考虑，我建议使用 `DROP` 目标。
像下面这样，用你自己的 IP 地址代替 `IP-address` 占位符。另外，你必须选择使用 `REJECT` 或者 `DROP` 中的一个，这两个目标不能同时使用。
```
iptables -A INPUT -i internal_interface -s IP_address -j REJECT / DROP
iptables -A INPUT -i internal_interface -s 192.168.0.0/16 -j REJECT / DROP
```
这篇文章只提供了如何使用 iptables 防火墙来避免远端欺骗攻击的基础知识。
---
via: <https://opensource.com/article/18/2/block-local-spoofed-addresses-using-linux-firewall>
作者：[Michael Kwaku Aboagye](https://opensource.com/users/revoks) 译者：[leemeans](https://github.com/leemeans) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么MIT的专利许可不讨人喜欢？
|
Scott K Peterson
|
https://opensource.com/article/18/3/patent-grant-mit-license
|
传统观点认为，Apache 许可证拥有“真正”的专利许可，那 MIT 许可证呢？
|
/data/attachment/album/201805/04/195349syg61416gsjz2ek2.png.thumb.jpg
|
/data/attachment/album/201805/04/195349syg61416gsjz2ek2.png
| true | false | true |
薛亮
| false |
[
"MIT",
"许可证",
"专利"
] |
开源智慧
|
{
"viewnum": 10530,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
传统观点认为，Apache 许可证拥有“真正”的专利许可，那 MIT 许可证呢？
| 2018-05-04T19:53:56 | 2018-05-04T19:53:56 | 9,605 |
/article-9605-1.html
|
>
> 提要：传统观点认为，Apache 许可证拥有“真正”的专利许可，那 MIT 许可证呢？
>
>
>
我经常听到说，[MIT 许可证](https://opensource.org/licenses/MIT)中没有专利许可，或者它只有一些“默示”专利许可的可能性。如果 MIT 许可证很敏感的话，那么它可能会因为大家对其较为年轻的同伴 [Apache 许可证](https://www.apache.org/licenses/LICENSE-2.0)的不断称赞而产生自卑感，传统观点认为，Apache 许可证拥有“真正”的专利许可。
这种区分经常重复出现，以至于人们认为，在许可证文本中是否出现“专利”一词具有很大的法律意义。不过，对“专利”一词的强调是错误的。1927 年，[美国最高法院表示](https://scholar.google.com/scholar_case?case=6603693344416712533)：
>
> “专利所有人使用的任何语言，或者专利所有人向其他人展示的任何行为，使得其他人可以从中合理地推断出专利所有人同意他依据专利来制造、使用或销售，便构成了许可行为，并可以作为侵权行为的辩护理由。”
>
>
>
MIT 许可证无疑拥有明示许可。该许可证不限于授予任何特定类型的知识产权。但其许可证声明里不使用“专利”或“版权”一词。您上次听到有人表示担心 MIT 许可证仅包含默示版权许可是什么时候了？
既然授予权利的文本中没有“版权”和“专利”，让我们来研究一下 MIT 许可证中的字眼，看看我们能否了解到哪些权利被授予。
| | |
| --- | --- |
| **特此授予以下权限，** | 这是授予权限的直接开始。 |
| *免费，* | 为了获得权限，不需要任何费用。 |
| *任何人获得本软件的副本和相关文档文件（本“软件”），* | 我们定义了一些基本知识：许可的主体和受益人。 |
| **无限制地处理本软件，** | 不错，这很好。现在我们正在深究此事。我们并没有因为细微差别而乱搞，“无限制”非常明确。 |
| *包括但不限于* | 对示例列表的介绍指出，该列表不是一种转弯抹角的限制，它只是一个示例列表。 |
| *使用、复制、修改、合并、发布、分发、再许可和/或销售本软件副本的权利，并允许获得本软件的人员享受同等权利，* | 我们可以对软件采取各种各样的行动。虽然有一些建议涉及[专利所有人的专有权](http://uscode.house.gov/view.xhtml?req=granuleid:USC-prelim-title35-section271&num=0&edition=prelim)和[版权所有者的专有权](https://www.copyright.gov/title17/92chap1.html#106)，但这些建议并不真正关注特定知识产权法提供的专有权的具体清单；重点是软件。 |
| *受以下条件限制：* | 权限受条件限制。 |
| *上述版权声明和权限声明应包含在本软件的所有副本或主要部分中。* | 这种情况属于所谓的<ruby> 不设限许可 <rp> （ </rp> <rt> permissive license </rt> <rp> ） </rp></ruby>。 |
| *本软件按“原样”提供，不附有任何形式的明示或暗示保证，包括但不限于对适销性、特定用途适用性和非侵权性的保证。在任何情况下，作者或版权所有者都不承担任何索赔、损害或其他责任。无论它是以合同形式、侵权或是其他方式，如由它引起，在其作用范围内、与该软件有联系、该软件的使用或者由这个软件引起的其他行为。* | 为了完整起见，我们添加免责声明。 |
没有任何信息会导致人们认为，许可人会保留对使用专利所有人创造的软件的行为起诉专利侵权的权利，并允许其他人“无限制地处理本软件”。
为什么说这是默示专利许可呢？没有充足的理由这么做。我们来看一个默示专利许可的案例。[Met-Coil Systems Corp. 诉Korners Unlimited](https://scholar.google.com/scholar_case?case=4152769754469052201) 的专利纠纷涉及专利的默示许可（[美国专利 4,466,641](https://patents.google.com/patent/US4466641)，很久以前已过期），该专利涉及用于连接供暖和空调系统中使用的金属管道段。处理该专利纠纷上诉的美国法院认定，专利权人（Met-Coil）出售其成型机（一种不属于专利保护主体的机器，但用于弯曲金属管道端部的法兰，使其作为以专利方式连接管道的一部分）授予其客户默示专利许可；因此，所谓的专利侵权者（Korners Unlimited）向这些客户出售某些与专利有关的部件（与 Met-Coil 机器弯曲产生的法兰一起使用的特殊角件）并不促成专利的侵权，因为客户被授予了许可（默示许可）。
通过销售其目的是在使用受专利保护的发明中发挥作用的金属弯曲机，专利权人向机器的购买者授予了专利许可。在 Met-Coil 案例中，可以看到需要谈论“默示”许可，因为根本不存在书面许可；法院也试图寻找由行为默示的许可。
现在，让我们回到 MIT 许可证。这是一个明示许可证。这个明示许可证授予了专利许可吗？事实上，在授予“无限制地处理软件”权限的情况下，MIT 许可证的确如此。没有比通过直接阅读授予许可的文字来得出结论更有效的办法了。
“明示专利许可”一词可以用于两种含义之一：
* 包括授予专利权利的明示许可证，或
* 明确提及专利权利的许可证。
其中第一项是与默示专利许可的对比。如果没有授予专利权利的明示许可，人们可以在分析中继续查看是否默示了专利许可。
人们经常使用第二个含义“明示专利许可”。不幸的是，这导致一些人错误地认为缺乏这样的“明示专利许可”会让人寻找默示许可。但是，第二种含义没有特别的法律意义。没有明确提及专利权利并不意味着没有授予专利权利的明示许可。因此，没有明确提及专利权利并不意味着仅受限于专利权利的默示许可。
说完这一切之后，那它究竟有多重要呢？
并没有多重要。当个人和企业根据 MIT 协议贡献软件时，他们并不希望稍后对那些使用专利所有人为之做出贡献的软件的人们主张专利权利。这是一个强有力的声明，当然，我没有直接看到贡献者的期望。但是根据 20 多年来我对依据 MIT 许可证贡献代码的观察，我没有看到任何迹象表明贡献者认为他们应该保留后续对使用其贡献的代码的行为征收专利许可费用的权利。恰恰相反，我观察到了与许可证中“无限制”这个短语一致的行为。
本讨论基于美国法律。其他司法管辖区的法律专家可以针对在其他国家的结果是否有所不同提出意见。
---
作者简介：Scott Peterson 是红帽公司（Red Hat）法律团队成员。很久以前，一位工程师就一个叫做 GPL 的奇怪文件向 Scott 征询法律建议，这个决定性的问题让 Scott 走上了探索包括技术标准和开源软件在内的协同开发法律问题的纠结之路。
译者简介：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
vrms 助你在 Debian 中查找非自由软件
|
Sk
|
https://www.ostechnix.com/the-vrms-program-helps-you-to-find-non-free-software-in-debian/
|
向 “Virtual Richard M. Stallman” 问好，这是一个在 Debian 中查找非自由软件的 Perl 脚本
|
/data/attachment/album/201805/04/200629zlzpksl8ckyv3fuf.png.thumb.jpg
|
/data/attachment/album/201805/04/200629zlzpksl8ckyv3fuf.png
| true | false | true |
geekpi
| false |
[
"自由软件",
"vrms",
"rms"
] |
分享
|
{
"viewnum": 4262,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
向 “Virtual Richard M. Stallman” 问好，这是一个在 Debian 中查找非自由软件的 Perl 脚本
| 2018-05-04T20:06:26 | 2018-05-04T20:06:26 | 9,606 |
/article-9606-1.html
|
有一天，我在 Digital ocean 上读到一篇有趣的指南，它解释了[自由和开源软件之间的区别](https://www.digitalocean.com/community/tutorials/Free-vs-Open-Source-Software)。在此之前，我认为两者都差不多。但是，我错了。它们之间有一些显著差异。在阅读那篇文章时，我想知道如何在 Linux 中找到非自由软件，因此有了这篇文章。
### 向 “Virtual Richard M. Stallman” 问好，这是一个在 Debian 中查找非自由软件的 Perl 脚本
**Virtual Richard M. Stallman** ，简称 **vrms**，是一个用 Perl 编写的程序，它在你基于 Debian 的系统上分析已安装软件的列表，并报告所有来自非自由和 contrib 树的已安装软件包。对于那些不太清楚区别的人，自由软件应该符合以下[**四项基本自由**](https://www.gnu.org/philosophy/free-sw.html)。
* **自由 0** – 不管任何目的，随意运行程序的自由。
* **自由 1** – 研究程序如何工作的自由，并根据你的需求进行调整。访问源代码是一个先决条件。
* **自由 2** – 重新分发副本的自由，这样你可以帮助别人。
* **自由 3** – 改进程序，并向公众发布改进的自由，以便整个社区获益。访问源代码是一个先决条件。
任何不满足上述四个条件的软件都不被视为自由软件。简而言之，**自由软件意味着用户有运行、复制、分发、研究、修改和改进软件的自由。**
现在让我们来看看安装的软件是自由的还是非自由的，好么？
vrms 包存在于 Debian 及其衍生版（如 Ubuntu）的默认仓库中。因此，你可以使用 `apt` 包管理器安装它，使用下面的命令。
```
$ sudo apt-get install vrms
```
安装完成后，运行以下命令，在基于 debian 的系统中查找非自由软件。
```
$ vrms
```
在我的 Ubuntu 16.04 LTS 桌面版上输出的示例。
```
Non-free packages installed on ostechnix
unrar Unarchiver for .rar files (non-free version)
1 non-free packages, 0.0% of 2103 installed packages.
```
如你在上面的截图中看到的那样，我的 Ubuntu 中安装了一个非自由软件包。
如果你的系统中没有任何非自由软件包，则应该看到以下输出。
```
No non-free or contrib packages installed on ostechnix! rms would be proud.
```
vrms 不仅可以在 Debian 上找到非自由软件包，还可以在 Ubuntu、Linux Mint 和其他基于 deb 的系统中找到非自由软件包。
**限制**
vrms 虽然有一些限制。就像我已经提到的那样，它列出了安装的非自由和 contrib 部分的软件包。但是，某些发行版并未遵循确保专有软件仅在 vrms 识别为“非自由”的仓库中存在，并且它们不努力维护这种分离。在这种情况下，vrms 将不能识别非自由软件，并且始终会报告你的系统上安装了非自由软件。如果你使用的是像 Debian 和 Ubuntu 这样的发行版，遵循将专有软件保留在非自由仓库的策略，vrms 一定会帮助你找到非自由软件包。
就是这些。希望它是有用的。还有更好的东西。敬请关注！
干杯！
---
via: <https://www.ostechnix.com/the-vrms-program-helps-you-to-find-non-free-software-in-debian/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 PGP 保护代码完整性（三）：生成 PGP 子密钥
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/learn/pgp/2018/2/protecting-code-integrity-pgp-part-3-generating-pgp-subkeys
|
在第三篇文章中，我们将解释如何生成用于日常工作的 PGP 子密钥。
|
/data/attachment/album/201805/04/202929whf9jsfizhftdpmu.jpg.thumb.jpg
|
/data/attachment/album/201805/04/202929whf9jsfizhftdpmu.jpg
| true | false | true |
geekpi
| false |
[
"PGP"
] |
技术
|
{
"viewnum": 7455,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9529,
"displayorder": 0
},
{
"raid": 10402,
"displayorder": 0
}
] |
在第三篇文章中，我们将解释如何生成用于日常工作的 PGP 子密钥。
| 2018-05-04T20:29:00 | 2018-05-04T20:29:00 | 9,607 |
/article-9607-1.html
|
>
> 在第三篇文章中，我们将解释如何生成用于日常工作的 PGP 子密钥。
>
>
>
在本系列教程中，我们提供了使用 PGP 的实用指南。在此之前，我们介绍了[基本工具和概念](/article-9524-1.html)，并介绍了如何[生成并保护您的主 PGP 密钥](/article-9529-1.html)。在第三篇文章中，我们将解释如何生成用于日常工作的 PGP 子密钥。
#### 清单
1. 生成 2048 位加密子密钥（必要）
2. 生成 2048 位签名子密钥（必要）
3. 生成一个 2048 位验证子密钥（推荐）
4. 将你的公钥上传到 PGP 密钥服务器（必要）
5. 设置一个刷新的定时任务（必要）
#### 注意事项
现在我们已经创建了主密钥，让我们创建用于日常工作的密钥。我们创建 2048 位的密钥是因为很多专用硬件（我们稍后会讨论这个）不能处理更长的密钥，但同样也是出于实用的原因。如果我们发现自己处于一个 2048 位 RSA 密钥也不够好的世界，那将是由于计算或数学有了基本突破，因此更长的 4096 位密钥不会产生太大的差别。
#### 创建子密钥
要创建子密钥，请运行：
```
$ gpg --quick-add-key [fpr] rsa2048 encr
$ gpg --quick-add-key [fpr] rsa2048 sign
```
用你密钥的完整指纹替换 `[fpr]`。
你也可以创建验证密钥，这能让你将你的 PGP 密钥用于 ssh：
```
$ gpg --quick-add-key [fpr] rsa2048 auth
```
你可以使用 `gpg --list-key [fpr]` 来查看你的密钥信息：
```
pub rsa4096 2017-12-06 [C] [expires: 2019-12-06]
111122223333444455556666AAAABBBBCCCCDDDD
uid [ultimate] Alice Engineer <alice@example.org>
uid [ultimate] Alice Engineer <allie@example.net>
sub rsa2048 2017-12-06 [E]
sub rsa2048 2017-12-06 [S]
```
#### 上传你的公钥到密钥服务器
你的密钥创建已完成，因此现在需要你将其上传到一个公共密钥服务器，使其他人能更容易找到密钥。 （如果你不打算实际使用你创建的密钥，请跳过这一步，因为这只会在密钥服务器上留下垃圾数据。）
```
$ gpg --send-key [fpr]
```
如果此命令不成功，你可以尝试指定一台密钥服务器以及端口，这很有可能成功：
```
$ gpg --keyserver hkp://pgp.mit.edu:80 --send-key [fpr]
```
大多数密钥服务器彼此进行通信，因此你的密钥信息最终将与所有其他密钥信息同步。
**关于隐私的注意事项：**密钥服务器是完全公开的，因此在设计上会泄露有关你的潜在敏感信息，例如你的全名、昵称以及个人或工作邮箱地址。如果你签名了其他人的钥匙或某人签名了你的钥匙，那么密钥服务器还会成为你的社交网络的泄密者。一旦这些个人信息发送给密钥服务器，就不可能被编辑或删除。即使你撤销签名或身份，它也不会将你的密钥记录删除，它只会将其标记为已撤消 —— 这甚至会显得更显眼。
也就是说，如果你参与公共项目的软件开发，以上所有信息都是公开记录，因此通过密钥服务器另外让这些信息可见，不会导致隐私的净损失。
#### 上传你的公钥到 GitHub
如果你在开发中使用 GitHub（谁不是呢？），则应按照他们提供的说明上传密钥：
* [添加 PGP 密钥到你的 GitHub 账户](https://help.github.com/articles/adding-a-new-gpg-key-to-your-github-account/)
要生成适合粘贴的公钥输出，只需运行：
```
$ gpg --export --armor [fpr]
```
#### 设置一个刷新定时任务
你需要定期刷新你的钥匙环，以获取其他人公钥的最新更改。你可以设置一个定时任务来做到这一点：
```
$ crontab -e
```
在新行中添加以下内容：
```
@daily /usr/bin/gpg2 --refresh >/dev/null 2>&1
```
**注意：**检查你的 `gpg` 或 `gpg2` 命令的完整路径，如果你的 `gpg` 是旧式的 GnuPG v.1，请使用 gpg2。
通过 Linux 基金会和 edX 的免费“[Introduction to Linux](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)” 课程了解关于 Linux 的更多信息。
---
via: <https://www.linux.com/blog/learn/pgp/2018/2/protecting-code-integrity-pgp-part-3-generating-pgp-subkeys>
作者：[Konstantin Ryabitsev](https://www.linux.com/users/mricon) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Caffeinated 6.828：练习 shell
|
Mit
|
https://sipb.mit.edu/iap/6.828/lab/shell/
|
Caffeinated 6.828 与标准的 MIT 6.828 课程不同，是一个快节奏的操作系统介绍。
|
/data/attachment/album/201805/06/103149p0xumfqxmmfmt500.jpg.thumb.jpg
|
/data/attachment/album/201805/06/103149p0xumfqxmmfmt500.jpg
| true | false | true |
geekpi
| false |
[
"MIT"
] |
技术
|
{
"viewnum": 4220,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9740,
"displayorder": 0
},
{
"raid": 10233,
"displayorder": 0
}
] |
Caffeinated 6.828 与标准的 MIT 6.828 课程不同，是一个快节奏的操作系统介绍。
| 2018-05-06T10:31:57 | 2018-05-06T10:31:57 | 9,608 |
/article-9608-1.html
|
通过在 shell 中实现多项功能，该作业将使你更加熟悉 Unix 系统调用接口和 shell。你可以在支持 Unix API 的任何操作系统（一台 Linux Athena 机器、装有 Linux 或 Mac OS 的笔记本电脑等）上完成此作业。请在第一次上课前将你的 shell 提交到[网站](https://exokernel.scripts.mit.edu/submit/)。
如果你在练习中遇到困难或不理解某些内容时，你不要羞于给[员工邮件列表](mailto:sipb-iap-6.828@mit.edu)发送邮件，但我们确实希望全班的人能够自行处理这级别的 C 编程。如果你对 C 不是很熟悉，可以认为这个是你对 C 熟悉程度的检查。再说一次，如果你有任何问题，鼓励你向我们寻求帮助。
下载 xv6 shell 的[框架](https://sipb.mit.edu/iap/6.828/files/sh.c)，然后查看它。框架 shell 包含两个主要部分：解析 shell 命令并实现它们。解析器只能识别简单的 shell 命令，如下所示：
```
ls > y
cat < y | sort | uniq | wc > y1
cat y1
rm y1
ls | sort | uniq | wc
rm y
```
将这些命令剪切并粘贴到 `t.sh` 中。
你可以按如下方式编译框架 shell 的代码：
```
$ gcc sh.c
```
它会生成一个名为 `a.out` 的文件，你可以运行它：
```
$ ./a.out < t.sh
```
执行会崩溃，因为你还没有实现其中的几个功能。在本作业的其余部分中，你将实现这些功能。
### 执行简单的命令
实现简单的命令，例如：
```
$ ls
```
解析器已经为你构建了一个 `execcmd`，所以你唯一需要编写的代码是 `runcmd` 中的 case ' '。要测试你可以运行 “ls”。你可能会发现查看 `exec` 的手册页是很有用的。输入 `man 3 exec`。
你不必实现引用（即将双引号之间的文本视为单个参数）。
### I/O 重定向
实现 I/O 重定向命令，这样你可以运行：
```
echo "6.828 is cool" > x.txt
cat < x.txt
```
解析器已经识别出 '>' 和 '<'，并且为你构建了一个 `redircmd`，所以你的工作就是在 `runcmd` 中为这些符号填写缺少的代码。确保你的实现在上面的测试输入中正确运行。你可能会发现 `open`（`man 2 open`） 和 `close` 的 man 手册页很有用。
请注意，此 shell 不会像 `bash`、`tcsh`、`zsh` 或其他 UNIX shell 那样处理引号，并且你的示例文件 `x.txt` 预计包含引号。
### 实现管道
实现管道，这样你可以运行命令管道，例如：
```
$ ls | sort | uniq | wc
```
解析器已经识别出 “|”，并且为你构建了一个 `pipecmd`，所以你必须编写的唯一代码是 `runcmd` 中的 case '|'。测试你可以运行上面的管道。你可能会发现 `pipe`、`fork`、`close` 和 `dup` 的 man 手册页很有用。
现在你应该可以正确地使用以下命令：
```
$ ./a.out < t.sh
```
无论是否完成挑战任务，不要忘记将你的答案提交给[网站](https://exokernel.scripts.mit.edu/submit/)。
### 挑战练习
如果你想进一步尝试，可以将所选的任何功能添加到你的 shell。你可以尝试以下建议之一：
* 实现由 `;` 分隔的命令列表
* 通过实现 `(` 和 `)` 来实现子 shell
* 通过支持 `＆` 和 `wait` 在后台执行命令
* 实现参数引用
所有这些都需要改变解析器和 `runcmd` 函数。
---
via: <https://sipb.mit.edu/iap/6.828/lab/shell/>
作者：[mit](https://sipb.mit.edu) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
递归：梦中梦
|
Gustavo Duarte
|
https://manybutfinite.com/post/recursion/
|
递归是很神奇的，但是在大多数的编程类书藉中对递归讲解的并不好。但这种建议是很糟糕的，因为在算法中，递归是一个非常强大的思想。
|
/data/attachment/album/201805/06/111413hoaqz33ez2jdtrmz.jpg.thumb.jpg
|
/data/attachment/album/201805/06/111413hoaqz33ez2jdtrmz.jpg
| true | false | true |
qhwdw
| false |
[
"递归"
] |
软件开发
|
{
"viewnum": 4517,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9746,
"displayorder": 0
}
] |
递归是很神奇的，但是在大多数的编程类书藉中对递归讲解的并不好。但这种建议是很糟糕的，因为在算法中，递归是一个非常强大的思想。
| 2018-05-06T11:15:00 | 2018-05-06T11:15:00 | 9,609 |
/article-9609-1.html
|
>
> “方其梦也，不知其梦也。梦之中又占其梦焉，觉而后知其梦也。”
>
>
> —— 《庄子·齐物论》
>
>
>
**递归**是很神奇的，但是在大多数的编程类书藉中对递归讲解的并不好。它们只是给你展示一个递归阶乘的实现，然后警告你递归运行的很慢，并且还有可能因为栈缓冲区溢出而崩溃。“你可以将头伸进微波炉中去烘干你的头发，但是需要警惕颅内高压并让你的头发生爆炸，或者你可以使用毛巾来擦干头发。”难怪人们不愿意使用递归。但这种建议是很糟糕的，因为在算法中，递归是一个非常强大的思想。
我们来看一下这个经典的递归阶乘：
```
#include <stdio.h>
int factorial(int n)
{
int previous = 0xdeadbeef;
if (n == 0 || n == 1) {
return 1;
}
previous = factorial(n-1);
return n * previous;
}
int main(int argc)
{
int answer = factorial(5);
printf("%d\n", answer);
}
```
*递归阶乘 - factorial.c*
函数调用自身的这个观点在一开始是让人很难理解的。为了让这个过程更形象具体，下图展示的是当调用 `factorial(5)` 并且达到 `n == 1`这行代码 时，[栈上](https://github.com/gduarte/blog/blob/master/code/x86-stack/factorial-gdb-output.txt) 端点的情况：
每次调用 `factorial` 都生成一个新的 [栈帧](https://manybutfinite.com/post/journey-to-the-stack)。这些栈帧的创建和 [销毁](https://manybutfinite.com/post/epilogues-canaries-buffer-overflows/) 是使得递归版本的阶乘慢于其相应的迭代版本的原因。在调用返回之前，累积的这些栈帧可能会耗尽栈空间，进而使你的程序崩溃。
而这些担心经常是存在于理论上的。例如，对于每个 `factorial` 的栈帧占用 16 字节（这可能取决于栈排列以及其它因素）。如果在你的电脑上运行着现代的 x86 的 Linux 内核，一般情况下你拥有 8 GB 的栈空间，因此，`factorial` 程序中的 `n` 最多可以达到 512,000 左右。这是一个 [巨大无比的结果](https://gist.github.com/gduarte/9944878)，它将花费 8,971,833 比特来表示这个结果，因此，栈空间根本就不是什么问题：一个极小的整数 —— 甚至是一个 64 位的整数 —— 在我们的栈空间被耗尽之前就早已经溢出了成千上万次了。
过一会儿我们再去看 CPU 的使用，现在，我们先从比特和字节回退一步，把递归看作一种通用技术。我们的阶乘算法可归结为：将整数 N、N-1、 … 1 推入到一个栈，然后将它们按相反的顺序相乘。实际上我们使用了程序调用栈来实现这一点，这是它的细节：我们在堆上分配一个栈并使用它。虽然调用栈具有特殊的特性，但是它也只是又一种数据结构而已，你可以随意使用。我希望这个示意图可以让你明白这一点。
当你将栈调用视为一种数据结构，有些事情将变得更加清晰明了：将那些整数堆积起来，然后再将它们相乘，这并不是一个好的想法。那是一种有缺陷的实现：就像你拿螺丝刀去钉钉子一样。相对更合理的是使用一个迭代过程去计算阶乘。
但是，螺丝钉太多了，我们只能挑一个。有一个经典的面试题，在迷宫里有一只老鼠，你必须帮助这只老鼠找到一个奶酪。假设老鼠能够在迷宫中向左或者向右转弯。你该怎么去建模来解决这个问题？
就像现实生活中的很多问题一样，你可以将这个老鼠找奶酪的问题简化为一个图，一个二叉树的每个结点代表在迷宫中的一个位置。然后你可以让老鼠在任何可能的地方都左转，而当它进入一个死胡同时，再回溯回去，再右转。这是一个老鼠行走的 [迷宫示例](https://github.com/gduarte/blog/blob/master/code/x86-stack/maze.h):
每到边缘（线）都让老鼠左转或者右转来到达一个新的位置。如果向哪边转都被拦住，说明相关的边缘不存在。现在，我们来讨论一下！这个过程无论你是调用栈还是其它数据结构，它都离不开一个递归的过程。而使用调用栈是非常容易的：
```
#include <stdio.h>
#include "maze.h"
int explore(maze_t *node)
{
int found = 0;
if (node == NULL)
{
return 0;
}
if (node->hasCheese){
return 1;// found cheese
}
found = explore(node->left) || explore(node->right);
return found;
}
int main(int argc)
{
int found = explore(&maze);
}
```
*递归迷宫求解 [下载](https://manybutfinite.com/code/x86-stack/maze.c)*
当我们在 `maze.c:13` 中找到奶酪时，栈的情况如下图所示。你也可以在 [GDB 输出](https://github.com/gduarte/blog/blob/master/code/x86-stack/maze-gdb-output.txt) 中看到更详细的数据，它是使用 [命令](https://github.com/gduarte/blog/blob/master/code/x86-stack/maze-gdb-commands.txt) 采集的数据。
它展示了递归的良好表现，因为这是一个适合使用递归的问题。而且这并不奇怪：当涉及到算法时，*递归是规则，而不是例外*。它出现在如下情景中——进行搜索时、进行遍历树和其它数据结构时、进行解析时、需要排序时——它无处不在。正如众所周知的 pi 或者 e，它们在数学中像“神”一样的存在，因为它们是宇宙万物的基础，而递归也和它们一样：只是它存在于计算结构中。
Steven Skienna 的优秀著作 [算法设计指南](http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693/) 的精彩之处在于，他通过 “战争故事” 作为手段来诠释工作，以此来展示解决现实世界中的问题背后的算法。这是我所知道的拓展你的算法知识的最佳资源。另一个读物是 McCarthy 的 [关于 LISP 实现的的原创论文](https://github.com/papers-we-love/papers-we-love/blob/master/comp_sci_fundamentals_and_history/recursive-functions-of-symbolic-expressions-and-their-computation-by-machine-parti.pdf)。递归在语言中既是它的名字也是它的基本原理。这篇论文既可读又有趣，在工作中能看到大师的作品是件让人兴奋的事情。
回到迷宫问题上。虽然它在这里很难离开递归，但是并不意味着必须通过调用栈的方式来实现。你可以使用像 `RRLL` 这样的字符串去跟踪转向，然后，依据这个字符串去决定老鼠下一步的动作。或者你可以分配一些其它的东西来记录追寻奶酪的整个状态。你仍然是实现了一个递归的过程，只是需要你实现一个自己的数据结构。
那样似乎更复杂一些，因为栈调用更合适。每个栈帧记录的不仅是当前节点，也记录那个节点上的计算状态（在这个案例中，我们是否只让它走左边，或者已经尝试向右）。因此，代码已经变得不重要了。然而，有时候我们因为害怕溢出和期望中的性能而放弃这种优秀的算法。那是很愚蠢的！
正如我们所见，栈空间是非常大的，在耗尽栈空间之前往往会遇到其它的限制。一方面可以通过检查问题大小来确保它能够被安全地处理。而对 CPU 的担心是由两个广为流传的有问题的示例所导致的：<ruby> 哑阶乘 <rt> dumb factorial </rt></ruby>和可怕的无记忆的 O( 2<sup> n</sup> ) [Fibonacci 递归](http://stackoverflow.com/questions/360748/computational-complexity-of-fibonacci-sequence)。它们并不是栈递归算法的正确代表。
事实上栈操作是非常快的。通常，栈对数据的偏移是非常准确的，它在 [缓存](https://manybutfinite.com/post/intel-cpu-caches/) 中是热数据，并且是由专门的指令来操作它的。同时，使用你自己定义的在堆上分配的数据结构的相关开销是很大的。经常能看到人们写的一些比栈调用递归更复杂、性能更差的实现方法。最后，现代的 CPU 的性能都是 [非常好的](https://manybutfinite.com/post/what-your-computer-does-while-you-wait/) ，并且一般 CPU 不会是性能瓶颈所在。在考虑牺牲程序的简单性时要特别注意，就像经常考虑程序的性能及性能的[测量](https://manybutfinite.com/post/performance-is-a-science)那样。
下一篇文章将是探秘栈系列的最后一篇了，我们将了解尾调用、闭包、以及其它相关概念。然后，我们就该深入我们的老朋友—— Linux 内核了。感谢你的阅读！
---
via:<https://manybutfinite.com/post/recursion/>
作者：[Gustavo Duarte](http://duartes.org/gustavo/blog/about/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[FSSlc](https://github.com/FSSlc)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 上使用 groff -me 格式化你的学术论文
|
Jim Hall
|
https://opensource.com/article/18/2/how-format-academic-papers-linux-groff-me
|
学习用简单的宏为你的课程论文添加脚注、引用、子标题及其它格式。
|
/data/attachment/album/201805/06/134922kr5v5kazkunaqr7m.jpg.thumb.jpg
|
/data/attachment/album/201805/06/134922kr5v5kazkunaqr7m.jpg
| true | false | true |
amwps290
| false |
[
"groff"
] |
技术
|
{
"viewnum": 4393,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习用简单的宏为你的课程论文添加脚注、引用、子标题及其它格式。
| 2018-05-06T13:49:28 | 2018-05-06T13:49:28 | 9,610 |
/article-9610-1.html
|
>
> 学习用简单的宏为你的课程论文添加脚注、引用、子标题及其它格式。
>
>
>
当我在 1993 年发现 Linux 时，我还是一名本科生。我很兴奋在我的宿舍里拥有 Unix 系统的强大功能，但是尽管它有很多功能，但 Linux 却缺乏应用程序。像 LibreOffice 和 OpenOffice 这样的文字处理程序还需要几年的时间才出现。如果你想使用文字处理器，你可能会将你的系统引导到 MS-DOS 中，并使用 WordPerfect、共享软件 GalaxyWrite 或类似的程序。
这就是我的方法，因为我需要为我的课程写论文，但我更喜欢呆在 Linux 中。我从我们的 “大 Unix” 校园计算机实验室得知，Unix 系统提供了一组文本格式化的程序 `nroff` 和 `troff` ，它们是同一系统的不同接口：`nroff` 生成纯文本输出，适用于屏幕或行式打印机，而 `troff` 产生非常优美的输出，通常用于在激光打印机上打印。
在 Linux 上，`nroff` 和 `troff` 被合并为 GNU troff，通常被称为 [groff](https://www.gnu.org/software/groff/)。 我很高兴看到早期的 Linux 发行版中包含了某个版本的 groff，因此我着手学习如何使用它来编写课程论文。 我学到的第一个宏集是 `-me` 宏包，一个简单易学的宏集。
关于 `groff` ，首先要了解的是它根据一组宏来处理和格式化文本。宏通常是个两个字符的命令，它自己设置在一行上，并带有一个引导点。宏可能包含一个或多个选项。当 `groff` 在处理文档时遇到这些宏中的一个时，它会自动对文本进行格式化。
下面，我将分享使用 `groff -me` 编写课程论文等简单文档的基础知识。 我不会深入细节进行讨论，比如如何创建嵌套列表，保存和显示，以及使用表格和数字。
### 段落
让我们从一个简单的例子开始，在几乎所有类型的文档中都可以看到：段落。段落可以格式化为首行缩进或不缩进（即，与左边齐平）。 包括学术论文，杂志，期刊和书籍在内的许多印刷文档都使用了这两种类型的组合，其中文档或章节中的第一个（主要）段落左侧对齐，而所有其他（常规）的段落缩进。 在 `groff -me`中，您可以使用两种段落类型：前导段落（`.lp`）和常规段落（`.pp`）。
```
.lp
This is the first paragraph.
.pp
This is a standard paragraph.
```
### 文本格式
用粗体格式化文本的宏是 `.b`，斜体格式是 `.i` 。 如果您将 `.b` 或 `.i` 放在一行上，则后面的所有文本将以粗体或斜体显示。 但更有可能你只是想用粗体或斜体来表示一个或几个词。 要将一个词加粗或斜体，将该单词放在与 `.b` 或 `.i` 相同的行上作为选项。 要用粗体或斜体格式化多个单词，请将文字用引号引起来。
```
.pp
You can do basic formatting such as
.i italics
or
.b "bold text."
```
在上面的例子中，粗体文本结尾的句点也是粗体。 在大多数情况下，这不是你想要的。 只要文字是粗体字，而不是后面的句点也是粗体字。 要获得您想要的效果，您可以向 `.b` 或 `.i` 添加第二个参数，以指示以粗体或斜体显示的文本后面跟着的任意文本以正常类型显示。 您可以这样做，以确保尾随句点不会以粗体显示。
```
.pp
You can do basic formatting such as
.i italics
or
.b "bold text" .
```
### 列表
使用 `groff -me`，您可以创建两种类型的列表：无序列表（`.bu`）和有序列表（`.np`）。
```
.pp
Bullet lists are easy to make:
.bu
Apple
.bu
Banana
.bu
Pineapple
.pp
Numbered lists are as easy as:
.np
One
.np
Two
.np
Three
.pp
Note that numbered lists will reset at the next pp or lp.
```
### 副标题
如果你正在写一篇长论文，你可能想把你的内容分成几部分。使用 `groff -me`，您可以创建编号的标题（`.sh`） 和未编号的标题 （`.uh`）。在这两种方法中，将节标题作为参数括起来。对于编号的标题，您还需要提供标题级别 `:1` 将给出一个一级标题(例如，`1`)。同样，`2` 和 `3` 将给出第二和第三级标题，如 `2.1` 或 `3.1.1`。
```
.uh Introduction
.pp
Provide one or two paragraphs to describe the work
and why it is important.
.sh 1 "Method and Tools"
.pp
Provide a few paragraphs to describe how you
did the research, including what equipment you used
```
### 智能引号和块引号
在任何学术论文中，引用他人的工作作为证据都是正常的。如果你引用一个简短的引用来突出一个关键信息，你可以在你的文本周围键入引号。但是 groff 不会自动将你的引用转换成现代文字处理系统所使用的“智能”或“卷曲”引用。要在 `groff -me` 中创建它们，插入一个内联宏来创建左引号（`\*(lq`）和右引号（`\*(rq`）。
```
.pp
Christine Peterson coined the phrase \*(lqopen source.\*(rq
```
`groff -me` 中还有一个快捷方式来创建这些引号（`.q`），我发现它更易于使用。
```
.pp
Christine Peterson coined the phrase
.q "open source."
```
如果引用的是跨越几行的较长的引用，则需要使用一个块引用。为此，在引用的开头和结尾插入块引用宏（`.(q`）。
```
.pp
Christine Peterson recently wrote about open source:
.(q
On April 7, 1998, Tim O'Reilly held a meeting of key
leaders in the field. Announced in advance as the first
.q "Freeware Summit,"
by April 14 it was referred to as the first
.q "Open Source Summit."
.)q
```
### 脚注
要插入脚注，请在脚注文本前后添加脚注宏（`.(f`），并使用内联宏（`\**`）添加脚注标记。脚注标记应出现在文本中和脚注中。
```
.pp
Christine Peterson recently wrote about open source:\**
.(f
\**Christine Peterson.
.q "How I coined the term open source."
.i "OpenSource.com."
1 Feb 2018.
.)f
.(q
On April 7, 1998, Tim O'Reilly held a meeting of key
leaders in the field. Announced in advance as the first
.q "Freeware Summit,"
by April 14 it was referred to as the first
.q "Open Source Summit."
.)q
```
### 封面
大多数课程论文都需要一个包含论文标题，姓名和日期的封面。 在 `groff -me` 中创建封面需要一些组件。 我发现最简单的方法是使用居中的文本块并在标题、名字和日期之间添加额外的行。 （我倾向于在每一行之间使用两个空行）。在文章顶部，从标题页（`.tp`）宏开始，插入五个空白行（`.sp 5`），然后添加居中文本（`.(c`） 和额外的空白行（`.sp 2`）。
```
.tp
.sp 5
.(c
.b "Writing Class Papers with groff -me"
.)c
.sp 2
.(c
Jim Hall
.)c
.sp 2
.(c
February XX, 2018
.)c
.bp
```
最后一个宏（`.bp`）告诉 groff 在标题页后添加一个分页符。
### 更多内容
这些是用 `groff-me` 写一份专业的论文非常基础的东西，包括前导和缩进段落，粗体和斜体，有序和无需列表，编号和不编号的章节标题，块引用以及脚注。
我已经包含一个[示例 groff 文件](https://opensource.com/sites/default/files/lorem-ipsum.me_.txt)来演示所有这些格式。 将 `lorem-ipsum.me` 文件保存到您的系统并通过 groff 运行。 `-Tps` 选项将输出类型设置为 `PostScript` ，以便您可以将文档发送到打印机或使用 `ps2pdf` 程序将其转换为 [PDF 文件](https://opensource.com/sites/default/files/lorem-ipsum.me_.pdf)。
```
groff -Tps -me lorem-ipsum.me > lorem-ipsum.me.ps
ps2pdf lorem-ipsum.me.ps lorem-ipsum.me.pdf
```
如果你想使用 `groff -me` 的更多高级功能，请参阅 Eric Allman 所著的 “使用 Groff -me 来写论文”，你可以在你系统的 groff 的 `doc` 目录下找到一个名叫 `meintro.me` 的文件。这份文档非常完美的说明了如何使用 `groff-me` 宏来格式化你的论文。
---
via: <https://opensource.com/article/18/2/how-format-academic-papers-linux-groff-me>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
ImageMagick 的一些高级图片查看技巧
|
Greg Pittman
|
https://opensource.com/article/17/9/imagemagick-viewing-images
|
用这些 ImageMagick 命令行图像编辑应用的技巧更好的管理你的数码照片集。
|
/data/attachment/album/201805/06/180657ij3mrhg33ggj33il.png.thumb.jpg
|
/data/attachment/album/201805/06/180657ij3mrhg33ggj33il.png
| true | false | true |
FSSlc
| false |
[
"ImageMagick"
] |
桌面应用
|
{
"viewnum": 5599,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8851,
"displayorder": 0
}
] |
用这些 ImageMagick 命令行图像编辑应用的技巧更好的管理你的数码照片集。
| 2018-05-06T18:06:52 | 2018-05-06T18:06:52 | 9,611 |
/article-9611-1.html
|
>
> 用这些 ImageMagick 命令行图像编辑应用的技巧更好的管理你的数码照片集。
>
>
>
在我先前的[ImageMagick 入门：使用命令行来编辑图片](/article-8851-1.html) 文章中，我展示了如何使用 ImageMagick 的菜单栏进行图片的编辑和变换风格。在这篇续文里，我将向你展示使用这个开源的图像编辑器来查看图片的另外方法。
### 别样的风格
在深入 ImageMagick 的高级图片查看技巧之前，我想先分享另一个使用 `convert` 达到的有趣但简单的效果，在[上一篇文章](/article-8851-1.html)中我已经详细地介绍了 `convert` 命令，这个技巧涉及这个命令的 `edge` 和 `negate` 选项：
```
convert DSC_0027.JPG -edge 3 -negate edge3+negate.jpg
```
*使用`edge` 和 `negate` 选项前后的图片对比*
这些使我更喜爱编辑后的图片：海的外观，作为前景和背景的植被，特别是太阳及其在海上的反射，最后是天空。
### 使用 display 来查看一系列图片
假如你跟我一样是个命令行用户，你就知道 shell 为复杂任务提供了更多的灵活性和快捷方法。下面我将展示一个例子来佐证这个观点。ImageMagick 的 `display` 命令可以克服我在 GNOME 桌面上使用 [Shotwell](https://wiki.gnome.org/Apps/Shotwell) 图像管理器导入图片时遇到的问题。
Shotwell 会根据每张导入图片的 [Exif](https://en.wikipedia.org/wiki/Exif) 数据，创建以图片被生成或者拍摄时的日期为名称的目录结构。最终的效果是最上层的目录以年命名，接着的子目录是以月命名 (01、 02、 03 等等)，然后是以每月的日期命名的子目录。我喜欢这种结构，因为当我想根据图片被创建或者拍摄时的日期来查找它们时将会非常方便。
但这种结构也并不是非常完美的，当我想查看最近几个月或者最近一年的所有图片时就会很麻烦。使用常规的图片查看器，我将不停地在不同层级的目录间跳转，但 ImageMagick 的 `display` 命令可以使得查看更加简单。例如，假如我想查看最近一年的图片，我便可以在命令行中键入下面的 `display` 命令：
```
display -resize 35% 2017/*/*/*.JPG
```
我可以一个月又一个月，一天又一天地遍历这一年。
现在假如我想查看某张图片，但我不确定我是在 2016 年的上半年还是在 2017 的上半年拍摄的，那么我便可以使用下面的命令来找到它：
```
display -resize 35% 201[6-7]/0[1-6]/*/*.JPG
```
这限制查看的图片拍摄于 2016 和 2017 年的一月到六月
### 使用 montage 来查看图片的缩略图
假如现在我要查找一张我想要编辑的图片，使用 `display` 的一个问题是它只会显示每张图片的文件名，而不显示其在目录结构中的位置，所以想要找到那张图片并不容易。另外，假如我很偶然地在从相机下载图片的过程中将这些图片从相机的内存里面清除了它们，结果使得下次拍摄照片的名称又从 `DSC_0001.jpg` 开始命名，那么当使用 `display` 来展示一整年的图片时，将会在这 12 个月的图片中花费很长的时间来查找它们。
这时 `montage` 命令便可以派上用场了。它可以将一系列的图片缩略图放在一张图片中，这样就会非常有用。例如可以使用下面的命令来完成上面的任务：
```
montage -label %d/%f -title 2017 -tile 5x -resize 10% -geometry +4+4 2017/0[1-4]/*/*.JPG 2017JanApr.jpg
```
从左到右，这个命令以标签开头，标签的形式是包含文件名（`%f`）和以 `/` 分割的目录（`%d`）结构，接着这个命令以目录的名称（2017）来作为标题，然后将图片排成 5 列，每个图片缩放为 10% （这个参数可以很好地匹配我的屏幕）。`geometry` 的设定将在每张图片的四周留白，最后指定那些图片要包括到这张合成图片中，以及一个合适的文件名称（`2017JanApr.jpg`）。现在图片 `2017JanApr.jpg` 便可以成为一个索引，使得我可以不时地使用它来查看这个时期的所有图片。
### 注意内存消耗
你可能会好奇为什么我在上面的合成图中只特别指定了为期 4 个月（从一月到四月）的图片。因为 `montage` 将会消耗大量内存，所以你需要多加注意。我的相机产生的图片每张大约有 2.5MB，我发现我的系统可以很轻松地处理 60 张图片。但一旦图片增加到 80 张，如果此时还有另外的程序（例如 Firefox 、Thunderbird）在后台工作，那么我的电脑将会死机，这似乎和内存使用相关，`montage`可能会占用可用 RAM 的 80% 乃至更多（你可以在此期间运行 `top` 命令来查看内存占用）。假如我关掉其他的程序，我便可以在我的系统死机前处理 80 张图片。
下面的命令可以让你知晓在你运行 `montage` 命令前你需要处理图片张数：
```
ls 2017/0[1-4/*/*.JPG > filelist; wc -l filelist
```
`ls` 命令生成我们搜索的文件的列表，然后通过重定向将这个列表保存在任意以名为 `filelist` 的文件中。接着带有 `-l` 选项的 `wc` 命令输出该列表文件共有多少行，换句话说，展示出了需要处理的文件个数。下面是我运行命令后的输出：
```
163 filelist
```
啊呀！从一月到四月我居然有 163 张图片，使用这些图片来创建一张合成图一定会使得我的系统死机的。我需要将这个列表减少点，可能只处理到 3 月份或者更早的图片。但如果我在 4 月 20 号到 30 号期间拍摄了很多照片，我想这便是问题的所在。下面的命令便可以帮助指出这个问题：
```
ls 2017/0[1-3]/*/*.JPG > filelist; ls 2017/04/0[1-9]/*.JPG >> filelist; ls 2017/04/1[0-9]/*.JPG >> filelist; wc -l filelist
```
上面一行中共有 4 个命令，它们以分号分隔。第一个命令特别指定从一月到三月期间拍摄的照片；第二个命令使用 `>>` 将拍摄于 4 月 1 日至 9 日的照片追加到这个列表文件中；第三个命令将拍摄于 4 月 10 日到 19 日的照片追加到列表中。最终它的显示结果为：
```
81 filelist
```
我知道假如我关掉其他的程序，处理 81 张图片是可行的。
使用 `montage` 来处理它们是很简单的，因为我们只需要将上面所做的处理添加到 `montage` 命令的后面即可：
```
montage -label %d/%f -title 2017 -tile 5x -resize 10% -geometry +4+4 2017/0[1-3]/*/*.JPG 2017/04/0[1-9]/*.JPG 2017/04/1[0-9]/*.JPG 2017Jan01Apr19.jpg
```
从左到右，`montage` 命令后面最后的那个文件名将会作为输出，在它之前的都是输入。这个命令将花费大约 3 分钟来运行，并生成一张大小约为 2.5MB 的图片，但我的系统只是有一点反应迟钝而已。
### 展示合成图片
当你第一次使用 `display` 查看一张巨大的合成图片时，你将看到合成图的宽度很合适，但图片的高度被压缩了，以便和屏幕相适应。不要慌，只需要左击图片，然后选择 `View > Original Size` 便会显示整个图片。再次点击图片便可以使菜单栏隐藏。
我希望这篇文章可以在你使用新方法查看图片时帮助你。在我的下一篇文章中，我将讨论更加复杂的图片操作技巧。
### 作者简介
Greg Pittman - Greg 肯塔基州路易斯维尔的一名退休的神经科医生，对计算机和程序设计有着长期的兴趣，最早可以追溯到 1960 年代的 Fortran IV 。当 Linux 和开源软件相继出现时，他开始学习更多的相关知识，并分享自己的心得。他是 Scribus 团队的成员。
---
via: <https://opensource.com/article/17/9/imagemagick-viewing-images>
作者：[Greg Pittman](https://opensource.com/users/greg-p) 译者：[FSSlc](https://github.com/FSSlc) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Gotop：另一个 TUI 图形活动监视器，使用 Go 编写
|
Sk
|
https://www.ostechnix.com/gotop-yet-another-tui-graphical-activity-monitor-written-in-go/
|
一些开发人员为 top 命令构建了图形前端，因此用户可以在图形窗口中轻松找到他们系统的活动。其中之一是 Gotop。
|
/data/attachment/album/201805/07/091937j7uj9j77q07j0t7n.png.thumb.jpg
|
/data/attachment/album/201805/07/091937j7uj9j77q07j0t7n.png
| true | false | true |
geekpi
| false |
[
"top"
] |
分享
|
{
"viewnum": 10219,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一些开发人员为 top 命令构建了图形前端，因此用户可以在图形窗口中轻松找到他们系统的活动。其中之一是 Gotop。
| 2018-05-07T09:19:34 | 2018-05-07T09:19:34 | 9,612 |
/article-9612-1.html
|
你已经知道 `top` 命令，对么？是的，它提供类 Unix 操作系统中运行中的进程的动态实时信息。一些开发人员为 `top` 命令构建了图形前端，因此用户可以在图形窗口中轻松找到他们系统的活动。其中之一是 **Gotop**。顾名思义，Gotop 是一个 TUI 图形活动监视器，使用 **Go** 语言编写。它是完全免费、开源的，受到了 [gtop](https://github.com/aksakalli/gtop) 和 [vtop](https://github.com/MrRio/vtop) 的启发。
在此简要的指南中，我们将讨论如何安装和使用 Gotop 来监视 Linux 系统的活动。
### 安装 Gotop
Gotop 是用 Go 编写的，所以我们需要先安装它。要在 Linux 中安装 Go 语言，请参阅以下指南。
安装 Go 之后，使用以下命令下载最新的 Gotop 二进制文件。
```
$ sh -c "$(curl https://raw.githubusercontent.com/cjbassi/gotop/master/download.sh)"
```
然后，将下载的二进制文件移动到您的 `$PATH` 中，例如 `/usr/local/bin/`。
```
$ cp gotop /usr/local/bin
```
最后，用下面的命令使其可执行：
```
$ chmod +x /usr/local/bin/gotop
```
如果你使用的是基于 Arch 的系统，Gotop 存在于 **AUR** 中，所以你可以使用任何 AUR 助手程序进行安装。
使用 [**Cower**](https://www.ostechnix.com/cower-simple-aur-helper-arch-linux/)：
```
$ cower -S gotop
```
使用 [**Pacaur**](https://www.ostechnix.com/install-pacaur-arch-linux/)：
```
$ pacaur -S gotop
```
使用 [**Packer**](https://www.ostechnix.com/install-packer-arch-linux-2/)：
```
$ packer -S gotop
```
使用 [**Trizen**](https://www.ostechnix.com/trizen-lightweight-aur-package-manager-arch-based-systems/)：
```
$ trizen -S gotop
```
使用 [**Yay**](https://www.ostechnix.com/yay-found-yet-another-reliable-aur-helper/)：
```
$ yay -S gotop
```
使用 [yaourt](https://www.ostechnix.com/install-yaourt-arch-linux/)：
```
$ yaourt -S gotop
```
### 用法
Gotop 的使用非常简单！你所要做的就是从终端运行以下命令。
```
$ gotop
```
这样就行了！你将在简单的 TUI 窗口中看到系统 CPU、磁盘、内存、网络、CPU温度和进程列表的使用情况。
要仅显示CPU、内存和进程组件，请使用下面的 `-m` 标志：
```
$ gotop -m
```
你可以使用以下键盘快捷键对进程表进行排序。
* `c` – CPU
* `m` – 内存
* `p` – PID
对于进程浏览，请使用以下键。
* `上/下` 箭头或者 `j/k` 键用于上移下移。
* `Ctrl-d` 和 `Ctrl-u` – 上移和下移半页。
* `Ctrl-f` 和 `Ctrl-b` – 上移和下移整页。
* `gg` 和 `G` – 跳转顶部和底部。
按下 `TAB` 切换进程分组。要杀死选定的进程或进程组，请输入 `dd`。要选择一个进程，只需点击它。要向下/向上滚动，请使用鼠标滚动按钮。要放大和缩小 CPU 和内存的图形，请使用 `h` 和 `l`。要显示帮助菜单，只需按 `?`。
就是这些了。希望这有帮助。还有更多好东西。敬请关注！
### 资源
* [Gotop GitHub Repository](https://github.com/cjbassi/gotop)
---
via: <https://www.ostechnix.com/gotop-yet-another-tui-graphical-activity-monitor-written-in-go/>
作者：[SK](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
moro：一个用于追踪工作时间的命令行生产力工具
|
Sk
|
https://www.ostechnix.com/moro-a-command-line-productivity-tool-for-tracking-work-hours/
|
通过使用 Moro，你可以找到你在完成某项特定任务时花费了多少时间。
|
/data/attachment/album/201805/07/093907n55r8r05dqzjjrjr.jpg.thumb.jpg
|
/data/attachment/album/201805/07/093907n55r8r05dqzjjrjr.jpg
| true | false | true |
leemeans
| false |
[
"moro"
] |
分享
|
{
"viewnum": 3531,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过使用 Moro，你可以找到你在完成某项特定任务时花费了多少时间。
| 2018-05-07T09:39:05 | 2018-05-07T09:39:05 | 9,613 |
/article-9613-1.html
|
保持对你的工作小时数的追踪将让你知晓在一个特定时间区间内你所完成的工作总量。在网络上有大量的基于 GUI 的生产力工具可以用来追踪工作小时数。但我却不能找到一个基于 CLI 的工具。今天我偶然发现了一个简单而奏效的叫做 Moro 的追踪工作时间数的工具。Moro 是一个芬兰词汇，意为“Hello”。通过使用 Moro，你可以找到你在完成某项特定任务时花费了多少时间。这个工具是自由开源软件，它是通过 NodeJS 编写的。
### Moro - 一个追踪工作时间的命令行生产力工具
由于 Moro 是使用 NodeJS 编写的，保证你的系统上已经安装了 NodeJS。如果你没有安装好 NodeJS，跟随下面的链接在你的 Linux 中安装 NodeJS 和 NPM。
* [如何在 Linux 上安装 NodeJS](https://www.ostechnix.com/install-node-js-linux/)
NodeJS 和NPM一旦装好，运行下面的命令来安装 Moro。
```
$ npm install -g moro
```
### 用法
Moro 的工作概念非常简单。它记录了你的工作开始时间，结束时间和在你的系统上的休息时间。在每天结束时，它将会告知你已经工作了多少时间。
当你到达办公室时，只需键入：
```
$ moro
```
示例输出：
```
Moro \o/
You clocked in at: 9:20
```
Moro 将会把这个时间注册为你的开始时间。
当你离开办公室时，再次键入：
```
$ moro
```
示例输出：
```
Moro \o/
You clocked out at: 19:22
Today looks like this so far:
┌──────────────────┬─────────────────────────┐
│ Today you worked │ 9 Hours and 72 Minutes │
├──────────────────┼─────────────────────────┤
│ Clock in │ 9:20 │
├──────────────────┼─────────────────────────┤
│ Clock out │ 19:22 │
├──────────────────┼─────────────────────────┤
│ Break duration │ 30 minutes │
├──────────────────┼─────────────────────────┤
│ Date │ 2018-03-19 │
└──────────────────┴─────────────────────────┘
Run moro --help to learn how to edit your clock in, clock out or break duration for today
```
Moro 将会把这个时间注册为你的结束时间。
现在，Moro 将会从结束时间减去开始时间，然后从总的时间减去另外的 30 分钟作为休息时间，并给你在那天总的工作时间。抱歉，我的数学计算过程解释实在糟糕。假设你在早上 10:00 来工作并在晚上 17:30 离开。所以，你总共在办公室呆了 7:30 小时（例如 17:30-10）。然后在总的时间减去休息时间（默认是 30 分钟）。因此，你的总工作时间是 7 小时。明白了？很好！
**注意：**不要像我在写这个手册的时候一样把 “moro” 和 “more” 弄混了。
查看你注册的所有小时数，运行：
```
$ moro report --all
```
以防万一，如果你忘记注册开始时间或者结束时间，你一样可以在之后指定这些值。
例如，将上午 10 点注册为开始时间，运行：
```
$ moro hi 10:00
Moro \o/
You clocked in at: 10:00
Working until 18:00 will make it a full (7.5 hours) day
```
注册 17:30 作为结束时间：
```
$ moro bye 17:30
Moro \o/
You clocked out at: 17:30
Today looks like this so far:
┌──────────────────┬───────────────────────┐
│ Today you worked │ 7 Hours and 0 Minutes │
├──────────────────┼───────────────────────┤
│ Clock in │ 10:00 │
├──────────────────┼───────────────────────┤
│ Clock out │ 17:30 │
├──────────────────┼───────────────────────┤
│ Break duration │ 30 minutes │
├──────────────────┼───────────────────────┤
│ Date │ 2018-03-19 │
└──────────────────┴───────────────────────┘
Run moro --help to learn how to edit your clock in, clock out or break duration for today
```
你已经知道 Moro 默认将会减去 30 分钟的休息时间。如果你需要设置一个自定义的休息时间，你可以简单使用以下命令：
```
$ moro break 45
```
现在，休息时间是 45 分钟了。
若要清除所有的数据：
```
$ moro clear --yes
Moro \o/
Database file deleted successfully
```
#### 添加笔记
有时候，你想要在工作时添加笔记。不必去寻找一个独立的作笔记的应用。Moro 将会帮助你添加笔记。要添加笔记，只需运行：
```
$ moro note mynotes
```
要在之后搜索所有已经注册的笔记，只需做：
```
$ moro search mynotes
```
#### 修改默认设置
默认的完整工作时间是 7.5 小时。这是因为开发者来自芬兰，这是官方的工作小时数。但是你也可以修改这个设置为你的国家的工作小时数。
举个例子，要将其设置为 7 小时，运行：
```
$ moro config --day 7
```
同样地，默认的休息时间也可以像下面这样从 30 分钟修改：
```
$ moro config --break 45
```
#### 备份你的数据
正如我已经说了的，Moro 将时间追踪信息存储在你的家目录，文件名是 `.moro-data.db`。
但是，你可以保存备份数据库到不同的位置。要这样做的话，像下面这样将 `.moro-data.db` 文件移到你选择的一个不同的位置并告知 Moro 使用那个数据库文件。
```
$ moro config --database-path /home/sk/personal/moro-data.db
```
在上面的每一个命令，我都已经把默认的数据库文件分配到了 `/home/sk/personal` 目录。
需要帮助的话，运行：
```
$ moro --help
```
正如你所见，Moro 是非常简单而又能用于追踪你完成你的工作使用了多少时间的。对于自由职业者和任何想要在一定时间范围内完成事情的人，它将会是有用的。
并且，这些只是今天的内容。希望这些内容能够有所帮助。更多的好东西将会出现。请保持关注！
干杯！
---
via: <https://www.ostechnix.com/moro-a-command-line-productivity-tool-for-tracking-work-hours/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[leemeans](https://github.com/leemeans) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 npm 管理 NodeJS 包
|
Sk
|
https://www.ostechnix.com/manage-nodejs-packages-using-npm/
|
在本指南中，我将解释使用 npm 基础知识，例如安装包（本地和全局）、安装特定版本的包、更新、删除和管理 NodeJS 包等等。
|
/data/attachment/album/201805/07/101556gyaxm33zchx3bax7.png.thumb.jpg
|
/data/attachment/album/201805/07/101556gyaxm33zchx3bax7.png
| true | false | true |
MjSeven
| false |
[
"npm",
"nodejs"
] |
技术
|
{
"viewnum": 6290,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本指南中，我将解释使用 npm 基础知识，例如安装包（本地和全局）、安装特定版本的包、更新、删除和管理 NodeJS 包等等。
| 2018-05-07T10:15:54 | 2018-05-07T10:15:54 | 9,614 |
/article-9614-1.html
|
前一段时间，我们发布了一个[使用 pip 管理 Python 包](https://docs.npmjs.com/getting-started/)的指南。今天，我们将讨论如何使用 npm 管理 NodeJS 包。npm 是最大的软件注册中心，包含 600,000 多个包。每天，世界各地的开发人员通过 npm 共享和下载软件包。在本指南中，我将解释使用 npm 基础知识，例如安装包（本地和全局）、安装特定版本的包、更新、删除和管理 NodeJS 包等等。
### 安装 npm
用于 npm 是用 NodeJS 编写的，我们需要安装 NodeJS 才能使用 npm。要在不同的 Linux 发行版上安装 NodeJS，请参考下面的链接。
* [在 Linux 上安装 NodeJS](https://www.ostechnix.com/install-node-js-linux/)
检查 node 安装的位置：
```
$ which node
/home/sk/.nvm/versions/node/v9.4.0/bin/node
```
检查它的版本：
```
$ node -v
v9.4.0
```
进入 Node 交互式解释器：
```
$ node
> .help
.break Sometimes you get stuck, this gets you out
.clear Alias for .break
.editor Enter editor mode
.exit Exit the repl
.help Print this help message
.load Load JS from a file into the REPL session
.save Save all evaluated commands in this REPL session to a file
> .exit
```
检查 npm 安装的位置：
```
$ which npm
/home/sk/.nvm/versions/node/v9.4.0/bin/npm
```
还有版本：
```
$ npm -v
5.6.0
```
棒极了！Node 和 npm 已安装好！正如你可能已经注意到，我已经在我的 `$HOME` 目录中安装了 NodeJS 和 NPM，这样是为了避免在全局模块时出现权限问题。这是 NodeJS 团队推荐的方法。
那么，让我们继续看看如何使用 npm 管理 NodeJS 模块（或包）。
### 安装 NodeJS 模块
NodeJS 模块可以安装在本地或全局（系统范围）。现在我将演示如何在本地安装包（LCTT 译注：即将包安装到一个 NodeJS 项目当中，所以下面会先创建一个空项目做演示）。
#### 在本地安装包
为了在本地管理包，我们通常使用 `package.json` 文件来管理。
首先，让我们创建我们的项目目录。
```
$ mkdir demo
$ cd demo
```
在项目目录中创建一个 `package.json` 文件。为此，运行：
```
$ npm init
```
输入你的包的详细信息，例如名称、版本、作者、GitHub 页面等等，或者按下回车键接受默认值并键入 `yes` 确认。
```
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
package name: (demo)
version: (1.0.0)
description: demo nodejs app
entry point: (index.js)
test command:
git repository:
keywords:
author:
license: (ISC)
About to write to /home/sk/demo/package.json:
{
"name": "demo",
"version": "1.0.0",
"description": "demo nodejs app",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}
Is this ok? (yes) yes
```
上面的命令初始化你的项目并创建了 `package.json` 文件。
你也可以使用命令以非交互式方式执行此操作：
```
npm init --y
```
现在让我们安装名为 [commander](https://www.npmjs.com/package/commander) 的包。
```
$ npm install commander
```
示例输出：
```
npm notice created a lockfile as package-lock.json. You should commit this file.
npm WARN demo@1.0.0 No repository field.
+ commander@2.13.0
added 1 package in 2.519s
```
这将在项目的根目录中创建一个名为 `node_modules` 的目录（如果它不存在的话），并在其中下载包。
让我们检查 `pachage.json` 文件。
```
$ cat package.json
{
"name": "demo",
"version": "1.0.0",
"description": "demo nodejs app",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC",
"dependencies": {
"commander": "^2.13.0"
}
}
```
你会看到添加了依赖文件，版本号前面的插入符号 ( `^` ) 表示在安装时，npm 将取出它可以找到的最高版本的包。
```
$ ls node_modules/
commander
```
`package.json` 文件的优点是，如果你的项目目录中有 `package.json` 文件，只需键入 `npm install`，那么 `npm` 将查看文件中列出的依赖关系并下载它们。你甚至可以与其他开发人员共享它或将其推送到你的 GitHub 仓库。因此，当他们键入 `npm install` 时，他们将获得你拥有的所有相同的包。
你也可能会注意到另一个名为 `package-lock.json` 的文件，该文件确保在项目安装的所有系统上都保持相同的依赖关系。
要在你的程序中使用已安装的包，使用实际代码在项目目录中创建一个 `index.js`（或者其他任何名称）文件，然后使用以下命令运行它：
```
$ node index.js
```
#### 在全局安装包
如果你想使用一个包作为命令行工具，那么最好在全局安装它。这样，无论你的当前目录是哪个目录，它都能正常工作。
```
$ npm install async -g
+ async@2.6.0
added 2 packages in 4.695s
```
或者
```
$ npm install async --global
```
要安装特定版本的包，我们可以：
```
$ npm install async@2.6.0 --global
```
### 更新 NodeJS 模块
要更新本地包，转到 `package.json` 所在的项目目录并运行：
```
$ npm update
```
然后，运行以下命令确保所有包都更新了。
```
$ npm outdated
```
如果没有需要更新的，那么它返回空。
要找出哪一个全局包需要更新，运行：
```
$ npm outdated -g --depth=0
```
如果没有输出，意味着所有包都已更新。
更新单个全局包，运行：
```
$ npm update -g <package-name>
```
更新所有的全局包，运行：
```
$ npm update -g
```
### 列出 NodeJS 模块
列出本地包，转到项目目录并运行：
```
$ npm list
demo@1.0.0 /home/sk/demo
└── commander@2.13.0
```
如你所见，我在本地安装了 `commander` 这个包。
要列出全局包，从任何位置都可以运行以下命令：
```
$ npm list -g
```
示例输出：
```
/home/sk/.nvm/versions/node/v9.4.0/lib
├─┬ async@2.6.0
│ └── lodash@4.17.4
└─┬ npm@5.6.0
├── abbrev@1.1.1
├── ansi-regex@3.0.0
├── ansicolors@0.3.2
├── ansistyles@0.1.3
├── aproba@1.2.0
├── archy@1.0.0
[...]
```
该命令将列出所有模块及其依赖关系。
要仅仅列出顶级模块，使用 `-depth=0` 选项：
```
$ npm list -g --depth=0
/home/sk/.nvm/versions/node/v9.4.0/lib
├── async@2.6.0
└── npm@5.6.0
```
#### 寻找 NodeJS 模块
要搜索一个模块，使用 `npm search` 命令：
```
npm search <search-string>
```
例如：
```
$ npm search request
```
该命令将显示包含搜索字符串 `request` 的所有模块。
##### 移除 NodeJS 模块
要删除本地包，转到项目目录并运行以下命令，这会从 `node_modules` 目录中删除包：
```
$ npm uninstall <package-name>
```
要从 `package.json` 文件中的依赖关系中删除它，使用如下所示的 `save` 选项：
```
$ npm uninstall --save <package-name>
```
要删除已安装的全局包，运行：
```
$ npm uninstall -g <package>
```
### 清除 npm 缓存
默认情况下，npm 在安装包时，会将其副本保存在 `$HOME` 目录中名为 `.npm` 的缓存文件夹中。所以，你可以在下次安装时不必再次下载。
查看缓存模块：
```
$ ls ~/.npm
```
随着时间的推移，缓存文件夹会充斥着大量旧的包。所以不时清理缓存会好一些。
从 npm@5 开始，npm 缓存可以从 corruption 问题中自行修复，并且保证从缓存中提取的数据有效。如果你想确保一切都一致，运行：
```
$ npm cache verify
```
清除整个缓存，运行：
```
$ npm cache clean --force
```
### 查看 npm 配置
要查看 npm 配置，键入：
```
$ npm config list
```
或者：
```
$ npm config ls
```
示例输出：
```
; cli configs
metrics-registry = "https://registry.npmjs.org/"
scope = ""
user-agent = "npm/5.6.0 node/v9.4.0 linux x64"
; node bin location = /home/sk/.nvm/versions/node/v9.4.0/bin/node
; cwd = /home/sk
; HOME = /home/sk
; "npm config ls -l" to show all defaults.
```
要显示当前的全局位置：
```
$ npm config get prefix
/home/sk/.nvm/versions/node/v9.4.0
```
好吧，这就是全部了。我们刚才介绍的只是基础知识，npm 是一个广泛话题。有关更多详细信息，参阅 [**NPM Getting Started**](https://docs.npmjs.com/getting-started/) 指南。
希望这对你有帮助。更多好东西即将来临，敬请关注！
干杯！
---
via: <https://www.ostechnix.com/manage-nodejs-packages-using-npm/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Dry：一个命令行交互式 Docker 容器管理器
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/dry-an-interactive-cli-manager-for-docker-containers/
|
Dry 可以给出容器相关的信息，包括对应镜像、容器名称、网络、容器中运行的命令及容器状态；如果运行在 Docker Swarm 中，工具还会给出 Swarm 集群的各种状态信息。
|
/data/attachment/album/201805/07/220628oam0bmtit7lolm7i.jpg.thumb.jpg
|
/data/attachment/album/201805/07/220628oam0bmtit7lolm7i.jpg
| true | false | true |
pinewall
| false |
[
"容器",
"Docker"
] |
容器与云
|
{
"viewnum": 8706,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Dry 可以给出容器相关的信息，包括对应镜像、容器名称、网络、容器中运行的命令及容器状态；如果运行在 Docker Swarm 中，工具还会给出 Swarm 集群的各种状态信息。
| 2018-05-07T22:06:33 | 2018-05-07T22:06:33 | 9,615 |
/article-9615-1.html
|
Docker 是一种所谓容器化的操作系统级的虚拟化软件。
基于 Linux 内核的 cgroup 和 namespace 等资源隔离特性，Docker 可以在单个 Linux 实例中运行多个独立的容器。
通过将应用依赖和相关库打包进容器，Docker 使得应用可以在容器中安全隔离地运行。
### Dry 是什么
[Dry](https://github.com/moncho/dry) 是一个管理并监控 Docker 容器和镜像的命令行工具。
Dry 可以给出容器相关的信息，包括对应镜像、容器名称、网络、容器中运行的命令及容器状态；如果运行在 Docker Swarm 中，工具还会给出 Swarm 集群的各种状态信息。
Dry 可以连接至本地或远程的 Docker 守护进程。如果连接本地 Docker，Docker 主机显示为 `unix:///var/run/docker.sock`。
如果连接远程 Docker，Docker 主机显示为 `tcp://IP Address:Port Number` 或 `tcp://Host Name:Port Number`。
Dry 可以提供类似 `docker ps` 的指标输出，但输出比 `docker ps` 内容详实、富有色彩。
相比 Docker，Dry 还可以手动添加一个额外的名称列，用于降低记忆难度。
**推荐阅读：**
* [Portainer – 用于 Docker 管理的简明 GUI](https://www.2daygeek.com/portainer-a-simple-docker-management-gui/)
* [Rancher – 适用于生产环境的完备容器管理平台](https://www.2daygeek.com/rancher-a-complete-container-management-platform-for-production-environment/)
* [cTop – Linux环境下容器管理与监控的命令行工具](https://www.2daygeek.com/ctop-a-command-line-tool-for-container-monitoring-and-management-in-linux/)
### 如何在 Linux 中安装 Dry
在 Linux 中，可以通过一个简单的 shell 脚本安装最新版本的 Dry 工具。Dry 不依赖外部库。对于绝大多数的 Docker 命令，Dry 提供类似样式的命令。
```
$ curl -sSf https://moncho.github.io/dry/dryup.sh | sudo sh
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 10 100 10 0 0 35 0 --:--:-- --:--:-- --:--:-- 35
dryup: downloading dry binary
######################################################################## 100.0%
dryup: Moving dry binary to its destination
dryup: dry binary was copied to /usr/local/bin, now you should 'sudo chmod 755 /usr/local/bin/dry'
```
使用如下命令将文件权限变更为 `755`：
```
$ sudo chmod 755 /usr/local/bin/dry
```
对于使用 Arch Linux 的用户，可以使用 **[Packer](https://www.2daygeek.com/install-packer-aur-helper-on-arch-linux/)** 或 **[Yaourt](https://www.2daygeek.com/install-yaourt-aur-helper-on-arch-linux/)** 包管理器，从 AUR 源安装该工具。
```
$ yaourt -S dry-bin
或者
$ packer -S dry-bin
```
如果希望在 Docker 容器中运行 dry，可以运行如下命令。前提条件是已确认在操作系统中安装了 Docker。
**推荐阅读：**
* [如何在 Linux 中安装 Docker](https://www.2daygeek.com/install-docker-on-centos-rhel-fedora-ubuntu-debian-oracle-archi-scentific-linux-mint-opensuse/)
* [如何在 Linux 中玩转 Docker 镜像](https://www.2daygeek.com/list-search-pull-download-remove-docker-images-on-linux/)
* [如何在 Linux 中玩转 Docker 容器](https://www.2daygeek.com/create-run-list-start-stop-attach-delete-interactive-daemonized-docker-containers-on-linux/)
* [如何在 Docker 容器中安装并运行应用程序](https://www.2daygeek.com/install-run-applications-inside-docker-containers/)
```
$ docker run -it -v /var/run/docker.sock:/var/run/docker.sock moncho/dry
```
### 如何启动并运行 Dry
在控制台运行 `dry` 命令即可启动该工具，其默认输出如下：
```
$ dry
```
### 如何使用 Dry 监控 Docker
你可以在 dry 的界面中按下 `m` 键打开监控模式。
### 如何使用 Dry 管理容器
在选中的容器上单击回车键，即可管理容器。Dry 提供如下操作：查看日志，查看、杀死、删除容器，停止、启动、重启容器，查看容器状态及镜像历史记录等。
### 如何监控容器资源利用率
用户可以使用 `Stats+Top` 选项查看指定容器的资源利用率。
该操作需要在容器管理界面完成（在上一步的基础上，点击 `Stats+Top` 选项）。另外，也可以按下 `s` 打开容器资源利用率界面。
### 如何查看容器、镜像及本地卷的磁盘使用情况
可以使用 `F8` 键查看容器、镜像及本地卷的磁盘使用情况。
该界面明确地给出容器、镜像和卷的总数，哪些处于使用状态，以及整体磁盘使用情况、可回收空间大小的详细信息。
### 如何查看已下载的镜像
按下 `2` 键即可列出全部的已下载镜像。
### 如何查看网络列表
按下 `3` 键即可查看全部网络及网关。
### 如何查看全部 Docker 容器
按下 `F2` 键即可列出列出全部容器，包括运行中和已关闭的容器。
### Dry 快捷键
查看帮助页面或 [dry GitHub](https://github.com/moncho/dry) 即可查看全部快捷键。
---
via: <https://www.2daygeek.com/dry-an-interactive-cli-manager-for-docker-containers/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[pinewall](https://github.com/pinewall) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 virsh 命令创建、还原和删除 KVM 虚拟机快照
|
Pradeep Kumar
|
https://www.linuxtechi.com/create-revert-delete-kvm-virtual-machine-snapshot-virsh-command/
|
如果你在使用基于 KVM 的虚拟机管理程序，那么可以使用 virsh 命令获取虚拟机或域快照。
|
/data/attachment/album/201805/07/222002g2mmtixiilftxxhh.jpg.thumb.jpg
|
/data/attachment/album/201805/07/222002g2mmtixiilftxxhh.jpg
| true | false | true |
geekpi
| false |
[
"KVM",
"virsh"
] |
容器与云
|
{
"viewnum": 5947,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你在使用基于 KVM 的虚拟机管理程序，那么可以使用 virsh 命令获取虚拟机或域快照。
| 2018-05-07T22:19:00 | 2018-05-07T22:19:00 | 9,616 |
/article-9616-1.html
|
在虚拟化平台上进行系统管理工作时，经常需要在开始重大操作比如部署补丁和代码前先设置一个虚拟机<ruby> 快照 <rt> snapshot </rt></ruby>。
虚拟机**快照**是特定时间点的虚拟机磁盘的副本。换句话说，快照保存了给定的时间点虚拟机的状态和数据。
### 我们可以在哪里使用虚拟机快照？
如果你在使用基于 **KVM** 的<ruby> 虚拟机管理程序 <rp> （ </rp> <rt> hypervisor </rt> <rp> ） </rp></ruby>，那么可以使用 `virsh` 命令获取虚拟机或域快照。快照在一种情况下变得非常有用，当你已经在虚拟机上安装或应用了最新的补丁，但是由于某些原因，虚拟机上的程序变得不稳定，开发团队想要还原所有的更改和补丁。如果你在应用补丁之前设置了虚拟机的快照，那么可以使用快照将虚拟机恢复到之前的状态。
**注意：**我们只能对磁盘格式为 **Qcow2** 的虚拟机的进行快照，并且 kvm 的 `virsh` 命令不支持 raw 磁盘格式，请使用以下命令将原始磁盘格式转换为 qcow2。
```
# qemu-img convert -f raw -O qcow2 image-name.img image-name.qcow2
```
### 创建 KVM 虚拟机（域）快照
我假设 KVM 管理程序已经在 CentOS 7 / RHEL 7 机器上配置好了，并且有虚拟机正在运行。我们可以使用下面的 `virsh` 命令列出虚拟机管理程序中的所有虚拟机，
```
[root@kvm-hypervisor ~]# virsh list --all
Id Name State
----------------------------------------------------
94 centos7.0 running
101 overcloud-controller running
102 overcloud-compute2 running
103 overcloud-compute1 running
114 webserver running
115 Test-MTN running
```
假设我们想创建 webserver 虚拟机的快照，运行下面的命令，
**语法：**
```
# virsh snapshot-create-as –domain {vm_name} –name {snapshot_name} –description “enter description here”
```
```
[root@kvm-hypervisor ~]# virsh snapshot-create-as --domain webserver --name webserver_snap --description "snap before patch on 4Feb2018"
Domain snapshot webserver_snap created
```
创建快照后，我们可以使用下面的命令列出与虚拟机相关的快照：
```
[root@kvm-hypervisor ~]# virsh snapshot-list webserver
Name Creation Time State
------------------------------------------------------------
webserver_snap 2018-02-04 15:05:05 +0530 running
[root@kvm-hypervisor ~]#
```
要列出虚拟机快照的详细信息，请运行下面的 `virsh` 命令：
```
[root@kvm-hypervisor ~]# virsh snapshot-info --domain webserver --snapshotname webserver_snap
Name: webserver_snap
Domain: webserver
Current: yes
State: running
Location: internal
Parent: -
Children: 0
Descendants: 0
Metadata: yes
```
我们可以使用下面的 `qemu-img` 命令查看快照的大小：
```
[root@kvm-hypervisor ~]# qemu-img info /var/lib/libvirt/images/snaptestvm.img
```
### 还原 KVM 虚拟机快照
假设我们想要将 webserver 虚拟机还原到我们在上述步骤中创建的快照。使用下面的 `virsh` 命令将 Webserver 虚拟机恢复到其快照 webserver\_snap 时。
**语法：**
```
# virsh snapshot-revert {vm_name} {snapshot_name}
```
```
[root@kvm-hypervisor ~]# virsh snapshot-revert webserver webserver_snap
```
### 删除 KVM 虚拟机快照
要删除 KVM 虚拟机快照，首先使用 `virsh snapshot-list` 命令获取虚拟机的快照详细信息，然后使用 `virsh snapshot-delete` 命令删除快照。如下示例所示：
```
[root@kvm-hypervisor ~]# virsh snapshot-list --domain webserver
Name Creation Time State
------------------------------------------------------------
webserver_snap 2018-02-04 15:05:05 +0530 running
[root@kvm-hypervisor ~]# virsh snapshot-delete --domain webserver --snapshotname webserver_snap
Domain snapshot webserver_snap deleted
```
这就是本文的全部内容，我希望你们能够了解如何使用 `virsh` 命令来管理 KVM 虚拟机快照。请分享你的反馈，并不要犹豫地分享给你的技术朋友
|
||
为什么我喜欢 ARM 和 PowerPC？
|
Peter Czanik
|
https://opensource.com/article/18/4/why-i-love-arm-and-powerpc
|
一个学生在搜寻强劲而节能的工作站的历程中怎样对开源系统的热情与日俱增的。
|
/data/attachment/album/201805/07/225612x088kg5dr5du15rd.jpg.thumb.jpg
|
/data/attachment/album/201805/07/225612x088kg5dr5du15rd.jpg
| true | false | true |
kennethXia
| false |
[
"ARM",
"PowerPC"
] |
观点
|
{
"viewnum": 17556,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一个学生在搜寻强劲而节能的工作站的历程中怎样对开源系统的热情与日俱增的。
| 2018-05-07T22:56:19 | 2018-05-07T22:56:19 | 9,617 |
/article-9617-1.html
|
>
> 一个学生在搜寻强劲而节能的工作站的历程中怎样对开源系统的热情与日俱增的。
>
>
>
最近我被问起为什么在博客和推特里经常提到 [ARM](https://en.wikipedia.org/wiki/ARM_architecture) 和 [PowerPC](https://en.wikipedia.org/wiki/PowerPC)。我有两个答案：一个是个人原因，另一个是技术上的。
### 个人原因
从前，我是学环境保护的。在我读博的时候，我准备买个新电脑。作为一个环保人士，我需要一台强劲且节能的电脑。这就是我开始对 PowerPC 感兴趣的原因，我找到了 [Pegasos](https://genesi.company/products/opendesktop)，这是一台 [Genesi](https://genesi.company/) 公司制造的 PowerPC 工作站。
我还用过 [RS/6000](https://en.wikipedia.org/wiki/RS/6000) （PowerPC）、 [SGI](https://en.wikipedia.org/wiki/Silicon_Graphics#Workstations) （MIPS）、 [HP-UX](https://en.wikipedia.org/wiki/HP-UX) （PA-RISC）和 [VMS](https://en.wikipedia.org/wiki/OpenVMS#Port_to_DEC_Alpha) （Alpha）的服务器和工作站，由于我的 PC 使用 Linux 而非 Windows，所以使用不同的 CPU 架构对我来说并没有什么区别。 [Pegasos](https://en.wikipedia.org/wiki/Pegasos) 是我第一台工作站，它小型而节能而且对家用来说性能足够。
很快我就开始为 Genesi 工作，为 Pegasos 移植 [openSUSE](https://www.opensuse.org/)、 Ubuntu 和其他 Linux 发行版，并提供质量保证和社区支持。继 Pegasos 之后是 [EFIKA](https://genesi.company/products/efika/5200b)，这是另一款基于 PowerPC 的开发板。在用过工作站之后，刚开始使用嵌入式系统会感觉有点奇怪。但是作为第一代普及价位的开发板，这是一场革命的开端。
我工作于一个大规模的服务器项目时，我收到 Genesi 的另一块有趣的开发板：基于 ARM 的 [Smarttop](https://genesi.company/products/efika) 和 [Smartbook](https://genesi.company/products/smartbook)。我最喜欢的 Linux 发行版——openSUSE，也收到了一打这种机器。这在当时 ARM 电脑非常稀缺的情况下，极大地促进了 ARM 版 openSUSE 项目的开发。
尽管最近我很忙，我尽量保持对 ARM 和 PowerPC 新闻的关注。这有助于我支持非 x86 平台上的 syslog-ng 用户。只要有半个小时的空，我就会去捣鼓一下 ARM 机器。我在[树莓派2](https://www.raspberrypi.org/products/raspberry-pi-2-model-b/)上做了很多 [syslog-ng](https://syslog-ng.com/open-source-log-management) 的测试，结果令人振奋。我最近在树莓派上做了个音乐播放器，用了一块 USB 声卡和[音乐播放守护进程](https://www.musicpd.org/)，我经常使用它。
### 技术方面
美好的多样性：它创造了竞争，而竞争创造了更好的产品。虽然 x86 是一款强劲的通用处理器，但 ARM 和 PowerPC （以及许多其他）这样的芯片在多种特定场景下显得更适合。
如果你有一部运行[安卓](https://www.android.com/)的移动设备或者[苹果](http://www.apple.com/)的 iPhone 或 iPad，极有可能它使用的就是基于ARM 的 SoC (片上系统)。网络存储服务器也一样。原因很简单：省电。你不会希望手机一直在充电，也不想为你的路由器付更多的电费。
ARM 亦在使用 64 位 ARMv8 芯片征战企业级服务器市场。很多任务只需要极少的计算能力，另一方面省电和快速 IO 才是关键，想想存储、静态网页服务器、电子邮件和其他网络/存储相关的功能。一个最好的例子就是 [Ceph](http://ceph.com/)，一个分布式的面向对象文件系统。[SoftIron](http://softiron.co.uk/) 就是一个基于 ARMv8 开发版，使用 CentOS 作为基准软件，运行在 Ceph 上的完整存储应用。
众所周知 PowerPC 是旧版苹果 [Mac](https://en.wikipedia.org/wiki/Power_Macintosh) 电脑上的 CPU。虽然它不再作为通用桌面电脑的 CPU ，它依然在路由器和电信设备里发挥作用。而且 [IBM](https://www.ibm.com/us-en/) 仍在为高端服务器制造芯片。几年前，随着 Power8 的引入， IBM 在 [OpenPower 基金会](http://openpowerfoundation.org/) 的支持下开放了架构。 Power8 对于关心内存带宽的设备，比如 HPC 、大数据、数据挖掘来说，是非常理想的平台。目前，Power9 也正呼之欲出。
这些都是服务器应用，但也有计划用于终端用户。猛禽工程团队正在开发一款基于 [Power9 的工作站](https://www.raptorcs.com/TALOSII/)，也有一个基于飞思卡尔/恩智浦 QORIQ E6500 芯片[制造笔记本](http://www.powerpc-notebook.org/en/)的倡议。当然，这些电脑并不适合所有人，你不能在它们上面安装 Windows 游戏或者商业应用。但它们对于 PowerPC 开发人员和爱好者，或者任何想要完全开放系统的人来说是理想的选择，因为从硬件到固件到应用程序都是开放的。
### 梦想
我的梦想是完全没有 x86 的环境，不是因为我讨厌 x86 ，而是因为我喜欢多样化而且总是希望使用最适合工作的工具。如果你看看猛禽工程网页上的[图](https://secure.raptorengineering.com/TALOS/power_advantages.php)，根据不同的使用情景， ARM 和 POWER 完全可以代替 x86 。现在，我在笔记本的 x86 虚拟机上编译、打包和测试 syslog-ng。如果能用上足够强劲的 ARMv8 或者 PowerPC 电脑，无论工作站还是服务器，我就能避免在 x86 上做这些事。
现在我正在等待下一代[菠萝本](https://www.pine64.org/?page_id=3707)的到来，就像我在二月份 [FOSDEM](https://fosdem.org/2018/) 上说的，下一代有望提供更高的性能。和 Chrome 本不同的是，这个 ARM 笔记本设计用于运行 Linux 而非仅是个客户端（LCTT 译注：Chrome 笔记本只提供基于网页的应用）。作为桌面系统，我在寻找 ARMv8 工作站级别的硬件。有些已经接近完成——就像 Avantek 公司的 [雷神 X 台式机](https://www.avantek.co.uk/store/avantek-32-core-cavium-thunderx-arm-desktop.html)——不过他们还没有装备最新最快最重要也最节能的 ARMv8 CPU。当这些都实现了，我将用我的 Pixel C 笔记本运行安卓。它不像 Linux 那样简单灵活，但它以强大的 ARM SoC 和 Linux 内核为基础。
---
via: <https://opensource.com/article/18/4/why-i-love-arm-and-powerpc>
作者：[Peter Czanik](https://opensource.com/users/czanik) 译者：[kennethXia](https://github.com/kennethXia) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
4 月 COPR 中的 4 个新酷项目
|
Dominik Turecek
|
https://fedoramagazine.org/4-try-copr-april-2018/
|
COPR 是一个个人软件仓库集合，它包含 Fedora 所没有提供的软件。
|
/data/attachment/album/201805/07/233642emfefpfwjfm7s4xe.jpg.thumb.jpg
|
/data/attachment/album/201805/07/233642emfefpfwjfm7s4xe.jpg
| true | false | true |
geekpi
| false |
[
"COPR",
"Fedora"
] |
分享
|
{
"viewnum": 4346,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
COPR 是一个个人软件仓库集合，它包含 Fedora 所没有提供的软件。
| 2018-05-07T23:36:38 | 2018-05-07T23:36:38 | 9,618 |
/article-9618-1.html
|
COPR 是一个个人软件仓库[集合](https://copr.fedorainfracloud.org/)，它包含 Fedora 所没有提供的软件。这些软件或不符合易于打包的标准，或者它可能不符合其他 Fedora 标准，尽管它是自由且开源的。COPR 可以在 Fedora 套件之外提供这些项目。COPR 中的软件并没有得到 Fedora 基础设施支持，也没有由该项目背书。但是，它可能是尝试新软件或实验软件的一种很好的方式。
这是 COPR 中一些新的和有趣的项目。
### Anki
[Anki](https://apps.ankiweb.net/) 是一个程序，它使用间隔重复帮助你学习和记忆事物。你可以创建卡片并将其组织成卡组，或下载[现有卡组](https://ankiweb.net/shared/decks/)。卡片的一面有问题，另一面有答案。它可能还包括图像、视频或音频。你对每张卡的回答好坏决定了你将来看到特定卡的频率。
虽然 Anki 已经在 Fedora 中，但这个仓库提供了一个更新的版本。
#### 安装说明
仓库目前为 Fedora 27、28 和 Rawhide 提供 Anki。要安装 Anki，请使用以下命令：
```
sudo dnf copr enable thomasfedb/anki
sudo dnf install anki
```
### Fd
[Fd](https://github.com/sharkdp/fd) 是一个命令行工具，它是简单而稍快的替代 [find](https://www.gnu.org/software/findutils/) 的方法。它可以并行地查找项目。fd 也使用彩色输出，并默认忽略隐藏文件和 `.gitignore` 中指定模式的文件。
#### 安装说明
仓库目前为 Fedora 26、27、28 和 Rawhide 提供 `fd`。要安装 fd，请使用以下命令：
```
sudo dnf copr enable keefle/fd
sudo dnf install fd
```
### KeePass
[KeePass](https://keepass.info/) 是一个密码管理器。它将所有密码保存在一个由主密钥或密钥文件锁定的端对端加密数据库中。密码可以组织成组并由程序的内置生成器生成。其他功能包括自动输入，它可以为选定的表单输入用户名和密码。
虽然 KeePass 已经在 Fedora 中，但这个仓库提供了最新版本。
#### 安装说明
仓库目前为 Fedora 26 和 27 提供 KeePass。要安装 KeePass，请使用以下命令：
```
sudo dnf copr enable mavit/keepass
sudo dnf install keepass
```
### jo
[Jo](https://github.com/jpmens/jo) 是一个将输入转换为 JSON 字符串或数组的命令行工具。它有一个简单的[语法](https://github.com/jpmens/jo/blob/master/jo.md)并识别布尔值、字符串和数字。另外，jo 支持嵌套并且可以嵌套自己的输出。
#### 安装说明
目前，仓库为 Fedora 26、27 和 Rawhide 以及 EPEL 6 和 7 提供 jo。要安装 jo，请使用以下命令：
```
sudo dnf copr enable ganto/jo
sudo dnf install jo
```
---
via: <https://fedoramagazine.org/4-try-copr-april-2018/>
作者：[Dominik Turecek](https://fedoramagazine.org) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我们可以在同一个虚拟机中运行 Python 2 和 3 代码而不需要更改代码吗？
|
Łukasz Langa
|
http://lukasz.langa.pl/13/could-we-run-python-2-and-python-3-code-same-vm/
|
从理论上来说，可以。Zed Shaw 说过一句著名的话，如果不行，那么 Python 3 一定不是图灵完备的。但在实践中，这是不现实的，我将通过给你们举几个例子来说明原因。
|
/data/attachment/album/201805/08/190544uu0ll660u6akw600.png.thumb.jpg
|
/data/attachment/album/201805/08/190544uu0ll660u6akw600.png
| true | false | true |
MjSeven
| false |
[
"Python"
] |
观点
|
{
"viewnum": 4345,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
从理论上来说，可以。Zed Shaw 说过一句著名的话，如果不行，那么 Python 3 一定不是图灵完备的。但在实践中，这是不现实的，我将通过给你们举几个例子来说明原因。
| 2018-05-08T19:07:00 | 2018-05-08T19:07:00 | 9,619 |
/article-9619-1.html
|
从理论上来说，可以。Zed Shaw 说过一句著名的话，如果不行，那么 Python 3 一定不是图灵完备的。但在实践中，这是不现实的，我将通过给你们举几个例子来说明原因。
### 对于字典（dict）来说，这意味着什么？
让我们来想象一台拥有 Python 6 的虚拟机，它可以读取 Python 3.6 编写的 `module3.py`。但是在这个模块中，它可以导入 Python 2.7 编写的 `module2.py`，并成功使用它，没有问题。这显然是实验代码，但假设 `module2.py` 包含以下的功能：
```
def update_config_from_dict(config_dict):
items = config_dict.items()
while items:
k, v = items.pop()
memcache.set(k, v)
def config_to_dict():
result = {}
for k, v in memcache.getall():
result[k] = v
return result
def update_in_place(config_dict):
for k, v in config_dict.items():
new_value = memcache.get(k)
if new_value is None:
del config_dict[k]
elif new_value != v:
config_dict[k] = v
```
现在，当我们想从 `module3` 中调用这些函数时，我们遇到了一个问题：Python 3.6 中的字典类型与 Python 2.7 中的字典类型不同。在 Python 2 中，字典是无序的，它们的 `.keys()`, `.values()`, `.items()` 方法返回了正确的序列，这意味着调用 `.items()` 会在字典中创建状态的副本。在 Python 3 中，这些方法返回字典当前状态的动态视图。
这意味着如果 `module3` 调用 `module2.update_config_from_dict(some_dictionary)`，它将无法运行，因为 Python 3 中 `dict.items()` 返回的值不是一个列表，并且没有 `.pop()` 方法。反过来也是如此。如果 `module3` 调用 `module2.config_to_dict()`，它可能会返回一个 Python 2 的字典。现在调用 `.items()` 突然返回一个列表，所以这段代码无法正常工作（这对 Python 3 字典来说工作正常）：
```
def main(cmdline_options):
d = module2.config_to_dict()
items = d.items()
for k, v in items:
print(f'Config from memcache: {k}={v}')
for k, v in cmdline_options:
d[k] = v
for k, v in items:
print(f'Config with cmdline overrides: {k}={v}')
```
最后，使用 `module2.update_in_place()` 会失败，因为 Python 3 中 `.items()` 的值现在不允许在迭代过程中改变。
对于字典来说，还有很多问题。Python 2 的字典在 Python 3 上使用 `isinstance(d, dict)` 应该返回 `True` 吗？如果是的话，这将是一个谎言。如果没有，代码将无法继续。
### Python 应该神奇地知道类型并会自动转换！
为什么我们的 Python 6 的虚拟机无法识别 Python 3 的代码，在 Python 2 中调用 `some_dict.keys()` 时，我们还有别的意思吗？好吧，Python 不知道代码的作者在编写代码时，她所认为的 `some_dict` 应该是什么。代码中没有任何内容表明它是否是一个字典。在 Python 2 中没有类型注释，因为它们是可选的，即使在 Python 3 中，大多数代码也不会使用它们。
在运行时，当你调用 `some_dict.keys()` 的时候，Python 只是简单地在对象上查找一个属性，该属性恰好隐藏在 `some_dict` 名下，并试图在该属性上运行 `__call__()`。这里有一些关于方法绑定，描述符，slots 等技术问题，但这是它的核心。我们称这种行为为“鸭子类型”。
由于鸭子类型，Python 6 的虚拟机将无法做出编译时决定，以正确转换调用和属性查找。
### 好的，让我们在运行时做出这个决定
Python 6 的虚拟机可以标记每个属性，通过查找“来自 py2 的调用”或“来自 py3 的调用”的信息来实现这一点，并使对象发送正确的属性。这会让它变得很慢，并且使用更多的内存。这将要求我们在内存中保留两种版本的代码，并通过代理来使用它们。我们需要加倍付出努力，在用户背后同步这些对象的状态。毕竟，新字典的内存表示与 Python 2 不同。
如果你已经被字典问题绕晕了，那么再想想 Python 3 中的 Unicode 字符串和 Python 2 中的字节（byte）字符串的各种问题吧。
### 没有办法了吗？Python 3 根本就不能运行旧代码吗？
不会。每天都会有项目移植到 Python 3。将 Python 2 代码移植到两个版本的 Python 上推荐方法是在你的代码上运行 [Python-Modernize](https://python-modernize.readthedocs.io/)。它会捕获那些在 Python 3 上不起作用的代码，并使用 [six](http://pypi.python.org/pypi/six) 库将其替换，以便它在 Python 2 和 Python 3 上运行。这是 `2to3` 的一个改编版本，用于生成仅针对 Python 3 代码。`Modernize` 是首选，因为它提供了更多的增量迁移路线。所有的这些在 Python 文档中的 [Porting Python 2 Code to Python 3](https://docs.python.org/3/howto/pyporting.html)文档中都有很好的概述。
但是，等一等，你不是说 Python 6 的虚拟机不能自动执行此操作吗？对。`Modernize` 查看你的代码，并试图猜测哪些是安全的。它会做出一些不必要的改变，还会错过其他必要的改变。但是，它不会帮助你处理字符串。如果你的代码没有在“来自外部的二进制数据”和“流程中的文本数据”之间保持界限，那么这种转换就不会那么轻易。
因此，大项目的迁移不能自动完成，并且需要人类进行测试，发现问题并修复它们。它工作吗？是的，我曾帮助[将一百万行代码迁移到 Python 3](https://www.youtube.com/watch?v=66XoCk79kjM)，并且这种切换没有造成事故。这一举措让我们重新获得了 1/3 的服务器内存，并使代码运行速度提高了 12％。那是在 Python 3.5 上，但是 Python 3.6 的速度要快得多，根据你的工作量，你甚至可以达到 [4 倍加速](https://twitter.com/llanga/status/963834977745022976)。
### 亲爱的 Zed
hi，伙计，我关注你已经超过 10 年了。我一直在观察，当你感到沮丧的时候，你对 Mongrel 没有任何信任，尽管 Rails 生态系统几乎全部都在上面运行。当你重新设计它并开始 Mongrel 2 项目时，我一直在观察。我一直在关注你使用 Fossil 这一令人惊讶的举动。随着你发布 “Rails 是一个贫民窟”的帖子，我看到你突然离开了 Ruby 社区。当你开始编写《笨方法学 Python》并且开始推荐它时，我感到非常兴奋。2013 年我在 [DjangoCon Europe](https://www.instagram.com/p/ZVC9CwH7G1/) 见过你，我们谈了很多关于绘画，唱歌和倦怠的内容。[你的这张照片](https://www.instagram.com/p/ZXtdtUn7Gk/)是我在 Instagram 上的第一个帖子。
你几乎把另一个“贫民区”的行动与 [“反对 Python 3” 案例](https://learnpythonthehardway.org/book/nopython3.html) 文章拉到一起。我认为你本意是好的，但是这篇文章引起了很多混淆，包括许多人觉得你认为 Python 3 不是图灵完整的。我花了好几个小时让人们相信，你是在开玩笑。但是，鉴于你对《笨方法学 Python》的重大贡献，我认为这是值得的。特别是你为 Python 3 更新了你的书。感谢你做这件事。如果我们社区中真的有人因你的帖子为由要求将你和你的书列入黑名单，而请他们出去。这是一个双输的局面，这是错误的。
说实话，没有一个核心 Python 开发人员认为 Python 2 到 Python 3 的转换过程会顺利而且计划得当，[包括 Guido van Rossum](https://www.youtube.com/watch?v=Oiw23yfqQy8)。真的，可以看那个视频，这有点事后诸葛亮的意思了。从这个意义上说，*我们实际上是积极地相互认同的*。如果我们再做一次，它会看起来不一样。但在这一点上，[在 2020 年 1 月 1 日，Python 2 将会到达终结](https://mail.python.org/pipermail/python-dev/2018-March/152348.html)。大多数第三方库已经支持 Python 3，甚至开始发布只支持 Python 3 的版本（参见 [Django](https://pypi.python.org/pypi/Django/2.0.3) 或 [科学项目关于 Python 3 的声明](http://python3statement.org/)）。
我们也积极地就另一件事达成一致。就像你于 Mongrel 一样，Python 核心开发人员是志愿者，他们的工作没有得到报酬。我们大多数人在这个项目上投入了大量的时间和精力，因此[我们自然而然敏感](https://www.youtube.com/watch?v=-Nk-8fSJM6I)于那些对他们的贡献不屑一顾和激烈的评论。特别是如果这个信息既攻击目前的事态，又要求更多的自由贡献。
我希望到 2018 年会让你忘记 2016 发布的帖子，有一堆好的反驳。[我特别喜欢 eevee](https://eev.ee/blog/2016/11/23/a-rebuttal-for-python-3/)（LCTT 译注：eevee 是一个为 Blender 设计的渲染器）。它特别针对“一起运行 Python 2 和 Python 3 ”的场景，这是不现实的，就像在同一个虚拟机中运行 Ruby 1.8 和 Ruby 2.x 一样，或者像 Lua 5.3 和 Lua 5.1 同时运行一样。你甚至不能用 libc.so.6 运行针对 libc.so.5 编译的 C 二进制文件。然而，我发现最令人惊讶的是，你声称 Python 核心开发者是“有目的地”创造诸如 2to3 之类的破坏工具，这些由 Guido 创建，其最大利益就是让每个人尽可能顺利，快速地迁移。我很高兴你在之后的帖子中放弃了这个说法，但是你必须意识到你会激怒那些阅读了原始版本的人。对蓄意伤害的指控最好有强有力的证据支持。
但看起来你仍然会这样做。[就在今天](https://twitter.com/zedshaw/status/977909970795745281)你说 Python 核心开发者“忽略”尝试解决 API 的问题，特别是 `six`。正如我上面写的那样，Python 文档中的官方移植指南涵盖了 `six`。更重要的是，`six` 是由 Python 2.7 的发布管理者 Benjamin Peterson 编写。很多人学会了编程，这要归功于你，而且由于你在网上有大量的粉丝，人们会阅读这样的推文，他们会相信它的价值，这是有害的。
我有一个建议，让我们把 “Python 3 管理不善”的争议搁置起来。Python 2 正在死亡，这个过程会很慢，并且它是丑陋而血腥的，但它是一条单行道。争论那些没有用。相反，让我们专注于我们现在可以做什么来使 Python 3.8 比其他任何 Python 版本更好。也许你更喜欢看外面的角色，但作为这个社区的成员，你会更有影响力。请说“我们”而不是“他们”。
---
via: <http://lukasz.langa.pl/13/could-we-run-python-2-and-python-3-code-same-vm/>
作者：[Łukasz Langa](http://lukasz.langa.pl) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.