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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
如何统计 Linux 中文件和文件夹/目录的数量
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/how-to-count-the-number-of-files-and-folders-directories-in-linux/
|
今天我们再次带来一系列可以多方面帮助到你的复杂的命令。 通过操作命令，可以帮助您计数当前目录中的文件和目录、递归计数，统计特定用户创建的文件列表等。
|
/data/attachment/album/201802/03/202516ai28uur2pipxkfud.jpg.thumb.jpg
|
/data/attachment/album/201802/03/202516ai28uur2pipxkfud.jpg
| true | false | true |
Flowsnow
| false |
[
"目录",
"统计"
] |
技术
|
{
"viewnum": 12937,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
今天我们再次带来一系列可以多方面帮助到你的复杂的命令。 通过操作命令，可以帮助您计数当前目录中的文件和目录、递归计数，统计特定用户创建的文件列表等。
| 2018-02-03T20:25:23 | 2018-02-03T20:25:23 | 9,307 |
/article-9307-1.html
|
嗨，伙计们，今天我们再次带来一系列可以多方面帮助到你的复杂的命令。 通过操作命令，可以帮助您计数当前目录中的文件和目录、递归计数，统计特定用户创建的文件列表等。
在本教程中，我们将向您展示如何使用多个命令，并使用 `ls`、`egrep`、`wc` 和 `find` 命令执行一些高级操作。 下面的命令将可用在多个方面。
为了实验，我打算总共创建 7 个文件和 2 个文件夹（5 个常规文件和 2 个隐藏文件）。 下面的 `tree` 命令的输出清楚的展示了文件和文件夹列表。
```
# tree -a /opt
/opt
├── magi
│ └── 2g
│ ├── test5.txt
│ └── .test6.txt
├── test1.txt
├── test2.txt
├── test3.txt
├── .test4.txt
└── test.txt
2 directories, 7 files
```
### 示例-1
统计当前目录的文件（不包括隐藏文件）。 运行以下命令以确定当前目录中有多少个文件，并且不计算点文件（LCTT 译注：点文件即以“.” 开头的文件，它们在 Linux 默认是隐藏的）。
```
# ls -l . | egrep -c '^-'
4
```
**细节：**
* `ls` ： 列出目录内容
* `-l` ： 使用长列表格式
* `.` ： 列出有关文件的信息（默认为当前目录）
* `|` ： 将一个程序的输出发送到另一个程序进行进一步处理的控制操作符
* `egrep` ： 打印符合模式的行
* `-c` ： 通用输出控制
* `'^-'` ： 以“-”开头的行（`ls -l` 列出长列表时，行首的 “-” 代表普通文件）
### 示例-2
统计当前目录包含隐藏文件在内的文件。 包括当前目录中的点文件。
```
# ls -la . | egrep -c '^-'
5
```
### 示例-3
运行以下命令来计数当前目录的文件和文件夹。 它会计算所有的文件和目录。
```
# ls -l | wc -l
5
```
**细节：**
* `ls` ： 列出目录内容
* `-l` ： 使用长列表格式
* `|` ： 将一个程序的输出发送到另一个程序进行进一步处理的控制操作符
* `wc` ： 这是一个统计每个文件的换行符、单词和字节数的命令
* `-l` ： 输出换行符的数量
### 示例-4
统计当前目录包含隐藏文件和目录在内的文件和文件夹。
```
# ls -la | wc -l
8
```
### 示例-5
递归计算当前目录的文件，包括隐藏文件。
```
# find . -type f | wc -l
7
```
**细节 ：**
* `find` ： 搜索目录结构中的文件
* `-type` ： 文件类型
* `f` ： 常规文件
* `wc` ： 这是一个统计每个文件的换行符、单词和字节数的命令
* `-l` ： 输出换行符的数量
### 示例-6
使用 `tree` 命令输出目录和文件数（不包括隐藏文件）。
```
# tree | tail -1
2 directories, 5 files
```
### 示例-7
使用包含隐藏文件的 `tree` 命令输出目录和文件计数。
```
# tree -a | tail -1
2 directories, 7 files
```
### 示例-8
运行下面的命令递归计算包含隐藏目录在内的目录数。
```
# find . -type d | wc -l
3
```
### 示例-9
根据文件扩展名计数文件数量。 这里我们要计算 `.txt` 文件。
```
# find . -name "*.txt" | wc -l
7
```
### 示例-10
组合使用 `echo` 命令和 `wc` 命令统计当前目录中的所有文件。 `4` 表示当前目录中的文件数量。
```
# echo *.* | wc
1 4 39
```
### 示例-11
组合使用 `echo` 命令和 `wc` 命令来统计当前目录中的所有目录。 第二个 `1` 表示当前目录中的目录数量。
```
# echo */ | wc
1 1 6
```
### 示例-12
组合使用 `echo` 命令和 `wc` 命令来统计当前目录中的所有文件和目录。 `5` 表示当前目录中的目录和文件的数量。
```
# echo * | wc
1 5 44
```
### 示例-13
统计系统（整个系统）中的文件数。
```
# find / -type f | wc -l
69769
```
### 示例-14
统计系统（整个系统）中的文件夹数。
```
# find / -type d | wc -l
8819
```
### 示例-15
运行以下命令来计算系统（整个系统）中的文件、文件夹、硬链接和符号链接数。
```
# find / -type d -exec echo dirs \; -o -type l -exec echo symlinks \; -o -type f -links +1 -exec echo hardlinks \; -o -type f -exec echo files \; | sort | uniq -c
8779 dirs
69343 files
20 hardlinks
11646 symlinks
```
---
via: <https://www.2daygeek.com/how-to-count-the-number-of-files-and-folders-directories-in-linux/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 译者：[Flowsnow](https://github.com/Flowsnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么 Kubernetes 很酷
|
Julia Evans
|
https://jvns.ca/blog/2017/10/05/reasons-kubernetes-is-cool/
|
在我刚开始学习 Kubernetes（大约是一年半以前吧？）时，我真的不明白为什么应该去关注它。
在我使用 Kubernetes 全职工作了三个多月后，我才逐渐明白了为什么我应该使用它。
|
/data/attachment/album/201802/03/234107htpn7qntr02q6qos.jpg.thumb.jpg
|
/data/attachment/album/201802/03/234107htpn7qntr02q6qos.jpg
| true | false | true |
qhwdw
| false |
[
"Kubernetes",
"容器"
] |
容器与云
|
{
"viewnum": 4260,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在我刚开始学习 Kubernetes（大约是一年半以前吧？）时，我真的不明白为什么应该去关注它。
在我使用 Kubernetes 全职工作了三个多月后，我才逐渐明白了为什么我应该使用它。
| 2018-02-03T23:41:21 | 2018-02-03T23:41:21 | 9,308 |
/article-9308-1.html
|
在我刚开始学习 Kubernetes（大约是一年半以前吧？）时，我真的不明白为什么应该去关注它。
在我使用 Kubernetes 全职工作了三个多月后，我才逐渐明白了为什么我应该使用它。（我距离成为一个 Kubernetes 专家还很远！）希望这篇文章对你理解 Kubernetes 能做什么会有帮助！
我将尝试去解释我对 Kubernetes 感兴趣的一些原因，而不去使用 “<ruby> 原生云 <rt> cloud native </rt></ruby>”、“<ruby> 编排系统 <rt> orchestration </rt></ruby>”、“<ruby> 容器 <rt> container </rt></ruby>”，或者任何 Kubernetes 专用的术语 :)。我去解释的这些观点主要来自一位 Kubernetes 操作者/基础设施工程师，因为，我现在的工作就是去配置 Kubernetes 和让它工作的更好。
我不会去尝试解决一些如 “你应该在你的生产系统中使用 Kubernetes 吗？”这样的问题。那是非常复杂的问题。（不仅是因为“生产系统”根据你的用途而总是有不同的要求）
### Kubernetes 可以让你无需设置一台新的服务器即可在生产系统中运行代码
我首次被说教使用 Kubernetes 是与我的伙伴 Kamal 的下面的谈话：
大致是这样的：
* Kamal： 使用 Kubernetes 你可以通过一条命令就能设置一台新的服务器。
* Julia： 我觉得不太可能吧。
* Kamal： 像这样，你写一个配置文件，然后应用它，这时候，你就在生产系统中运行了一个 HTTP 服务。
* Julia： 但是，现在我需要去创建一个新的 AWS 实例，明确地写一个 Puppet 清单，设置服务发现，配置负载均衡，配置我们的部署软件，并且确保 DNS 正常工作，如果没有什么问题的话，至少在 4 小时后才能投入使用。
* Kamal: 是的，使用 Kubernetes 你不需要做那么多事情，你可以在 5 分钟内设置一台新的 HTTP 服务，并且它将自动运行。只要你的集群中有空闲的资源它就能正常工作！
* Julia: 这儿一定是一个“坑”。
这里有一种陷阱，设置一个生产用 Kubernetes 集群（在我的经险中）确实并不容易。（查看 [Kubernetes 艰难之旅](https://github.com/kelseyhightower/kubernetes-the-hard-way) 中去开始使用时有哪些复杂的东西）但是，我们现在并不深入讨论它。
因此，Kubernetes 第一个很酷的事情是，它可能使那些想在生产系统中部署新开发的软件的方式变得更容易。那是很酷的事，而且它真的是这样，因此，一旦你使用一个运作中的 Kubernetes 集群，你真的可以仅使用一个配置文件就在生产系统中设置一台 HTTP 服务（在 5 分钟内运行这个应用程序，设置一个负载均衡，给它一个 DNS 名字，等等）。看起来真的很有趣。
### 对于运行在生产系统中的代码，Kubernetes 可以提供更好的可见性和可管理性
在我看来，在理解 etcd 之前，你可能不会理解 Kubernetes 的。因此，让我们先讨论 etcd！
想像一下，如果现在我这样问你，“告诉我你运行在生产系统中的每个应用程序，它运行在哪台主机上？它是否状态很好？是否为它分配了一个 DNS 名字？”我并不知道这些，但是，我可能需要到很多不同的地方去查询来回答这些问题，并且，我需要花很长的时间才能搞定。我现在可以很确定地说不需要查询，仅一个 API 就可以搞定它们。
在 Kubernetes 中，你的集群的所有状态 – 运行中的应用程序 (“pod”)、节点、DNS 名字、 cron 任务、 等等 —— 都保存在一个单一的数据库中（etcd）。每个 Kubernetes 组件是无状态的，并且基本是通过下列方式工作的：
* 从 etcd 中读取状态（比如，“分配给节点 1 的 pod 列表”）
* 产生变化（比如，“在节点 1 上运行 pod A”）
* 更新 etcd 中的状态（比如，“设置 pod A 的状态为 ‘running’”）
这意味着，如果你想去回答诸如 “在那个可用区中有多少台运行着 nginx 的 pod？” 这样的问题时，你可以通过查询一个统一的 API（Kubernetes API）去回答它。并且，你可以在每个其它 Kubernetes 组件上运行那个 API 去进行同样的访问。
这也意味着，你可以很容易地去管理每个运行在 Kubernetes 中的任何东西。比如说，如果你想要：
* 部署实现一个复杂的定制的部署策略（部署一个东西，等待 2 分钟，部署 5 个以上，等待 3.7 分钟，等等）
* 每当推送到 github 上一个分支，自动化 [启动一个新的 web 服务器](https://github.com/kamalmarhubi/kubereview)
* 监视所有你的运行的应用程序，确保它们有一个合理的内存使用限制。
这些你只需要写一个程序与 Kubernetes API（“controller”）通讯就可以了。
另一个关于 Kubernetes API 的令人激动的事情是，你不会局限于 Kubernetes 所提供的现有功能！如果对于你要部署/创建/监视的软件有你自己的方案，那么，你可以使用 Kubernetes API 去写一些代码去达到你的目的！它可以让你做到你想做的任何事情。
### 即便每个 Kubernetes 组件都“挂了”，你的代码将仍然保持运行
关于 Kubernetes 我（在各种博客文章中 :)）承诺的一件事情是，“如果 Kubernetes API 服务和其它组件‘挂了’也没事，你的代码将一直保持运行状态”。我认为理论上这听起来很酷，但是我不确定它是否真是这样的。
到目前为止，这似乎是真的！
我已经断开了一些正在运行的 etcd，发生了这些情况：
1. 所有的代码继续保持运行状态
2. 不能做 *新的* 事情（你不能部署新的代码或者生成变更，cron 作业将停止工作）
3. 当它恢复时，集群将赶上这期间它错过的内容
这样做意味着如果 etcd 宕掉，并且你的应用程序的其中之一崩溃或者发生其它事情，在 etcd 恢复之前，它不能够恢复。
### Kubernetes 的设计对 bug 很有弹性
与任何软件一样，Kubernetes 也会有 bug。例如，到目前为止，我们的集群控制管理器有内存泄漏，并且，调度器经常崩溃。bug 当然不好，但是，我发现 Kubernetes 的设计可以帮助减轻它的许多核心组件中的错误的影响。
如果你重启动任何组件，将会发生：
* 从 etcd 中读取所有的与它相关的状态
* 基于那些状态（调度 pod、回收完成的 pod、调度 cron 作业、按需部署等等），它会去做那些它认为必须要做的事情
因为，所有的组件并不会在内存中保持状态，你在任何时候都可以重启它们，这可以帮助你减轻各种 bug 的影响。
例如，如果在你的控制管理器中有内存泄露。因为，控制管理器是无状态的，你可以每小时定期去重启它，或者，在感觉到可能导致任何不一致的问题发生时重启它。又或者，在调度器中遇到了一个 bug，它有时忘记了某个 pod，从来不去调度它们。你可以每隔 10 分钟来重启调度器来缓减这种情况。（我们并不会这么做，而是去修复这个 bug，但是，你*可以这样做* :））
因此，我觉得即使在它的核心组件中有 bug，我仍然可以信任 Kubernetes 的设计可以让我确保集群状态的一致性。并且，总在来说，随着时间的推移软件质量会提高。唯一你必须去操作的有状态的东西就是 etcd。
不用过多地讨论“状态”这个东西 —— 而我认为在 Kubernetes 中很酷的一件事情是，唯一需要去做备份/恢复计划的东西是 etcd （除非为你的 pod 使用了持久化存储的卷）。我认为这样可以使 Kubernetes 运维比你想的更容易一些。
### 在 Kubernetes 之上实现新的分布式系统是非常容易的
假设你想去实现一个分布式 cron 作业调度系统！从零开始做工作量非常大。但是，在 Kubernetes 里面实现一个分布式 cron 作业调度系统是非常容易的！（仍然没那么简单，毕竟它是一个分布式系统）
我第一次读到 Kubernetes 的 cron 作业控制器的代码时，我对它是如此的简单感到由衷高兴。去读读看，其主要的逻辑大约是 400 行的 Go 代码。去读它吧！ => [cronjob\_controller.go](https://github.com/kubernetes/kubernetes/blob/e4551d50e57c089aab6f67333412d3ca64bc09ae/pkg/controller/cronjob/cronjob_controller.go) <=
cron 作业控制器基本上做的是：
* 每 10 秒钟：
+ 列出所有已存在的 cron 作业
+ 检查是否有需要现在去运行的任务
+ 如果有，创建一个新的作业对象去调度，并通过其它的 Kubernetes 控制器实际运行它
+ 清理已完成的作业
+ 重复以上工作
Kubernetes 模型是很受限制的（它有定义在 etcd 中的资源模式，控制器读取这个资源并更新 etcd），我认为这种相关的固有的/受限制的模型，可以使它更容易地在 Kubernetes 框架中开发你自己的分布式系统。
Kamal 给我说的是 “Kubernetes 是一个写你自己的分布式系统的很好的平台” ，而不是“ Kubernetes 是一个你可以使用的分布式系统”，并且，我觉得它真的很有意思。他做了一个 [为你推送到 GitHub 的每个分支运行一个 HTTP 服务的系统](https://github.com/kamalmarhubi/kubereview) 的原型。这花了他一个周末的时间，大约 800 行 Go 代码，我认为它真不可思议！
### Kubernetes 可以使你做一些非常神奇的事情（但并不容易）
我一开始就说 “kubernetes 可以让你做一些很神奇的事情，你可以用一个配置文件来做这么多的基础设施，它太神奇了”。这是真的！
为什么说 “Kubernetes 并不容易”呢？是因为 Kubernetes 有很多部分，学习怎么去成功地运营一个高可用的 Kubernetes 集群要做很多的工作。就像我发现它给我了许多抽象的东西，我需要去理解这些抽象的东西才能调试问题和正确地配置它们。我喜欢学习新东西，因此，它并不会使我发狂或者生气，但是我认为了解这一点很重要 :）
对于 “我不能仅依靠抽象概念” 的一个具体的例子是，我努力学习了许多 [Linux 上网络是如何工作的](https://jvns.ca/blog/2016/12/22/container-networking/)，才让我对设置 Kubernetes 网络稍有信心，这比我以前学过的关于网络的知识要多很多。这种方式很有意思但是非常费时间。在以后的某个时间，我或许写更多的关于设置 Kubernetes 网络的困难/有趣的事情。
或者，为了成功设置我的 Kubernetes CA，我写了一篇 [2000 字的博客文章](https://jvns.ca/blog/2017/08/05/how-kubernetes-certificates-work/)，述及了我不得不学习 Kubernetes 不同方式的 CA 的各种细节。
我觉得，像 GKE （Google 的 Kubernetes 产品) 这样的一些监管的 Kubernetes 的系统可能更简单，因为，他们为你做了许多的决定，但是，我没有尝试过它们。
---
via: <https://jvns.ca/blog/2017/10/05/reasons-kubernetes-is-cool/>
作者：[Julia Evans](https://jvns.ca/about) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
创建局域网内的离线 YUM 仓库
|
Shusain
|
http://linuxtechlab.com/offline-yum-repository-for-lan/
|
为了节省数据量，我们可以创建个离线 yum 源并将之分享到本地网络中。网络中的其他 Linux 机器就可以直接从本地 yum 上获取系统更新，从而节省数据量，而且传输速度也会很好。
|
/data/attachment/album/201802/04/000335adp4ph6whg6i9vc3.jpg.thumb.jpg
|
/data/attachment/album/201802/04/000335adp4ph6whg6i9vc3.jpg
| true | false | true |
lujun9972
| false |
[
"Yum",
"RPM"
] |
系统运维
|
{
"viewnum": 8074,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9296,
"displayorder": 0
}
] |
为了节省数据量，我们可以创建个离线 yum 源并将之分享到本地网络中。网络中的其他 Linux 机器就可以直接从本地 yum 上获取系统更新，从而节省数据量，而且传输速度也会很好。
| 2018-02-04T00:03:42 | 2018-02-04T00:03:42 | 9,309 |
/article-9309-1.html
|
在早先的教程中，我们讨论了[如何使用 ISO 镜像和在线 Yum 仓库的方式来创建自己的 Yum 仓库](/article-9296-1.html) 。创建自己的 Yum 仓库是一个不错的想法，但若网络中只有 2-3 台 Linux 机器那就没啥必要了。不过若你的网络中有大量的 Linux 服务器，而且这些服务器还需要定时进行升级，或者你有大量服务器无法直接访问互联网，那么创建自己的 Yum 仓库就很有必要了。
当我们有大量的 Linux 服务器，而每个服务器都直接从互联网上升级系统时，数据消耗会很可观。为了节省数据量，我们可以创建个离线 Yum 源并将之分享到本地网络中。网络中的其他 Linux 机器就可以直接从本地 Yum 上获取系统更新，从而节省数据量，而且传输速度也会很好。
我们可以使用下面两种方法来分享 Yum 仓库：
* 使用 Web 服务器（Apache）
* 使用 FTP 服务器（VSFTPD）
在开始讲解这两个方法之前，我们需要先根据[之前的教程](/article-9296-1.html)创建一个 Yum 仓库。
### 使用 Web 服务器
首先在 Yum 服务器上安装 Web 服务器（Apache），我们假设服务器 IP 是 `192.168.1.100`。我们已经在这台系统上配置好了 Yum 仓库，现在我们来使用 `yum` 命令安装 Apache Web 服务器，
```
$ yum install httpd
```
下一步，拷贝所有的 rpm 包到默认的 Apache 根目录下，即 `/var/www/html`，由于我们已经将包都拷贝到了 `/YUM` 下，我们也可以创建一个软连接来从 `/var/www/html` 指向 `/YUM`。
```
$ ln -s /var/www/html/Centos /YUM
```
重启 Web 服务器应用改变：
```
$ systemctl restart httpd
```
#### 配置客户端机器
服务端的配置就完成了，现在需要配置下客户端来从我们创建的离线 Yum 中获取升级包，这里假设客户端 IP 为 `192.168.1.101`。
在 `/etc/yum.repos.d` 目录中创建 `offline-yum.repo` 文件，输入如下信息，
```
$ vi /etc/yum.repos.d/offline-yum.repo
```
```
name=Local YUM
baseurl=http://192.168.1.100/CentOS/7
gpgcheck=0
enabled=1
```
客户端也配置完了。试一下用 `yum` 来安装/升级软件包来确认仓库是正常工作的。
### 使用 FTP 服务器
在 FTP 上分享 Yum，首先需要安装所需要的软件包，即 vsftpd。
```
$ yum install vsftpd
```
vsftp 的默认根目录为 `/var/ftp/pub`，因此你可以拷贝 rpm 包到这个目录，或者为它创建一个软连接：
```
$ ln -s /var/ftp/pub /YUM
```
重启服务应用改变：
```
$ systemctl restart vsftpd
```
#### 配置客户端机器
像上面一样，在 `/etc/yum.repos.d` 中创建 `offline-yum.repo` 文件，并输入下面信息，
```
$ vi /etc/yum.repos.d/offline-yum.repo
```
```
[Offline YUM]
name=Local YUM
baseurl=ftp://192.168.1.100/pub/CentOS/7
gpgcheck=0
enabled=1
```
现在客户机可以通过 ftp 接收升级了。要配置 vsftpd 服务器为其他 Linux 系统分享文件，请[阅读这篇指南](http://linuxtechlab.com/ftp-secure-installation-configuration/)。
这两种方法都很不错，你可以任意选择其中一种方法。有任何疑问或这想说的话，欢迎在下面留言框中留言。
---
via: <http://linuxtechlab.com/offline-yum-repository-for-lan/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 Apache 服务器模块保护您的网站免受应用层 DOS 攻击
|
Elliot Cooper
|
https://bash-prompt.net/guides/mod_proxy/
|
通过配置普通的网页服务器，可以保护网页免受应用层攻击，至少是适度的防护。防止这种形式的攻击是非常重要的，因为 Cloudflare 最近 报告称 网络层攻击的数量正在减少，而应用层攻击的数量则在增加。
|
/data/attachment/album/201802/04/211129wijnojhizpucof8u.jpg.thumb.jpg
|
/data/attachment/album/201802/04/211129wijnojhizpucof8u.jpg
| true | false | true |
jessie-pang
| false |
[
"DOS",
"攻击"
] |
系统运维
|
{
"viewnum": 5675,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通过配置普通的网页服务器，可以保护网页免受应用层攻击，至少是适度的防护。防止这种形式的攻击是非常重要的，因为 Cloudflare 最近 报告称 网络层攻击的数量正在减少，而应用层攻击的数量则在增加。
| 2018-02-04T21:11:57 | 2018-02-04T21:11:57 | 9,310 |
/article-9310-1.html
|
有多种可以导致网站下线的攻击方法，比较复杂的方法要涉及数据库和编程方面的技术知识。一个更简单的方法被称为“<ruby> 拒绝服务 <rt> Denial Of Service </rt></ruby>”（DOS）攻击。这个攻击方法的名字来源于它的意图：使普通客户或网站访问者的正常服务请求被拒绝。
一般来说，有两种形式的 DOS 攻击：
1. OSI 模型的三、四层，即网络层攻击
2. OSI 模型的七层，即应用层攻击
第一种类型的 DOS 攻击——网络层，发生于当大量的垃圾流量流向网页服务器时。当垃圾流量超过网络的处理能力时，网站就会宕机。
第二种类型的 DOS 攻击是在应用层，是利用合法的服务请求，而不是垃圾流量。当页面请求数量超过网页服务器能承受的容量时，即使是合法访问者也将无法使用该网站。
本文将着眼于缓解应用层攻击，因为减轻网络层攻击需要大量的可用带宽和上游提供商的合作，这通常不是通过配置网络服务器就可以做到的。
通过配置普通的网页服务器，可以保护网页免受应用层攻击，至少是适度的防护。防止这种形式的攻击是非常重要的，因为 [Cloudflare](https://www.cloudflare.com) 最近 [报告称](https://blog.cloudflare.com/the-new-ddos-landscape/) 网络层攻击的数量正在减少，而应用层攻击的数量则在增加。
本文将介绍如何使用 [zdziarski](https://www.zdziarski.com/blog/) 开发的 Apache2 的模块 [mod\_evasive](https://github.com/jzdziarski/mod_evasive)。
另外，mod\_evasive 会阻止攻击者通过尝试数百个用户名和密码的组合来进行猜测（即暴力攻击）的企图。
mod\_evasive 会记录来自每个 IP 地址的请求的数量。当这个数字超过相应 IP 地址的几个阈值之一时，会出现一个错误页面。错误页面所需的资源要比一个能够响应合法访问的在线网站少得多。
### 在 Ubuntu 16.04 上安装 mod\_evasive
Ubuntu 16.04 默认的软件库中包含了 mod\_evasive，名称为 “libapache2-mod-evasive”。您可以使用 `apt-get` 来完成安装：
```
apt-get update
apt-get upgrade
apt-get install libapache2-mod-evasive
```
现在我们需要配置 mod\_evasive。
它的配置文件位于 `/etc/apache2/mods-available/evasive.conf`。默认情况下，所有模块的设置在安装后都会被注释掉。因此，在修改配置文件之前，模块不会干扰到网站流量。
```
<IfModule mod_evasive20.c>
#DOSHashTableSize 3097
#DOSPageCount 2
#DOSSiteCount 50
#DOSPageInterval 1
#DOSSiteInterval 1
#DOSBlockingPeriod 10
#DOSEmailNotify you@yourdomain.com
#DOSSystemCommand "su - someuser -c '/sbin/... %s ...'"
#DOSLogDir "/var/log/mod_evasive"
</IfModule>
```
第一部分的参数的含义如下：
* `DOSHashTableSize` - 正在访问网站的 IP 地址列表及其请求数的当前列表。
* `DOSPageCount` - 在一定的时间间隔内，每个页面的请求次数。时间间隔由 DOSPageInterval 定义。
* `DOSPageInterval` - mod\_evasive 统计页面请求次数的时间间隔。
* `DOSSiteCount` - 与 `DOSPageCount` 相同，但统计的是来自相同 IP 地址对网站内任何页面的请求数量。
* `DOSSiteInterval` - mod\_evasive 统计网站请求次数的时间间隔。
* `DOSBlockingPeriod` - 某个 IP 地址被加入黑名单的时长（以秒为单位）。
如果使用上面显示的默认配置，则在如下情况下，一个 IP 地址会被加入黑名单：
* 每秒请求同一页面超过两次。
* 每秒请求 50 个以上不同页面。
如果某个 IP 地址超过了这些阈值，则被加入黑名单 10 秒钟。
这看起来可能不算久，但是，mod\_evasive 将一直监视页面请求，包括在黑名单中的 IP 地址，并重置其加入黑名单的起始时间。只要一个 IP 地址一直尝试使用 DOS 攻击该网站，它将始终在黑名单中。
其余的参数是：
* `DOSEmailNotify` - 用于接收 DOS 攻击信息和 IP 地址黑名单的电子邮件地址。
* `DOSSystemCommand` - 检测到 DOS 攻击时运行的命令。
* `DOSLogDir` - 用于存放 mod\_evasive 的临时文件的目录。
### 配置 mod\_evasive
默认的配置是一个很好的开始，因为它不会阻塞任何合法的用户。取消配置文件中的所有参数（`DOSSystemCommand` 除外）的注释，如下所示：
```
<IfModule mod_evasive20.c>
DOSHashTableSize 3097
DOSPageCount 2
DOSSiteCount 50
DOSPageInterval 1
DOSSiteInterval 1
DOSBlockingPeriod 10
DOSEmailNotify JohnW@example.com
#DOSSystemCommand "su - someuser -c '/sbin/... %s ...'"
DOSLogDir "/var/log/mod_evasive"
</IfModule>
```
必须要创建日志目录并且要赋予其与 apache 进程相同的所有者。这里创建的目录是 `/var/log/mod_evasive` ，并且在 Ubuntu 上将该目录的所有者和组设置为 `www-data` ，与 Apache 服务器相同：
```
mkdir /var/log/mod_evasive
chown www-data:www-data /var/log/mod_evasive
```
在编辑了 Apache 的配置之后，特别是在正在运行的网站上，在重新启动或重新加载之前，最好检查一下语法，因为语法错误将影响 Apache 的启动从而使网站宕机。
Apache 包含一个辅助命令，是一个配置语法检查器。只需运行以下命令来检查您的语法：
```
apachectl configtest
```
如果您的配置是正确的，会得到如下结果：
```
Syntax OK
```
但是，如果出现问题，您会被告知在哪部分发生了什么错误，例如：
```
AH00526: Syntax error on line 6 of /etc/apache2/mods-enabled/evasive.conf:
DOSSiteInterval takes one argument, Set site interval
Action 'configtest' failed.
The Apache error log may have more information.
```
如果您的配置通过了 configtest 的测试，那么这个模块可以安全地被启用并且 Apache 可以重新加载：
```
a2enmod evasive
systemctl reload apache2.service
```
mod\_evasive 现在已配置好并正在运行了。
### 测试
为了测试 mod\_evasive，我们只需要向服务器提出足够的网页访问请求，以使其超出阈值，并记录来自 Apache 的响应代码。
一个正常并成功的页面请求将收到如下响应：
```
HTTP/1.1 200 OK
```
但是，被 mod\_evasive 拒绝的将返回以下内容：
```
HTTP/1.1 403 Forbidden
```
以下脚本会尽可能迅速地向本地主机（127.0.0.1，localhost）的 80 端口发送 HTTP 请求，并打印出每个请求的响应代码。
你所要做的就是把下面的 bash 脚本复制到一个文件中，例如 `mod_evasive_test.sh`：
```
#!/bin/bash
set -e
for i in {1..50}; do
curl -s -I 127.0.0.1 | head -n 1
done
```
这个脚本的部分含义如下：
* `curl` - 这是一个发出网络请求的命令。
+ `-s` - 隐藏进度表。
+ `-I` - 仅显示响应头部信息。
* `head` - 打印文件的第一部分。
+ `-n 1` - 只显示第一行。
然后赋予其执行权限：
```
chmod 755 mod_evasive_test.sh
```
在启用 mod\_evasive **之前**，脚本运行时，将会看到 50 行 “HTTP / 1.1 200 OK” 的返回值。
但是，启用 mod\_evasive 后，您将看到以下内容：
```
HTTP/1.1 200 OK
HTTP/1.1 200 OK
HTTP/1.1 403 Forbidden
HTTP/1.1 403 Forbidden
HTTP/1.1 403 Forbidden
HTTP/1.1 403 Forbidden
HTTP/1.1 403 Forbidden
...
```
前两个请求被允许，但是在同一秒内第三个请求发出时，mod\_evasive 拒绝了任何进一步的请求。您还将收到一封电子邮件（邮件地址在选项 `DOSEmailNotify` 中设置），通知您有 DOS 攻击被检测到。
mod\_evasive 现在已经在保护您的网站啦！
---
via: <https://bash-prompt.net/guides/mod_proxy/>
作者：[Elliot Cooper](https://bash-prompt.net/about/) 译者：[jessie-pang](https://github.com/jessie-pang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
循序渐进学习如何在 MariaDB 中配置主从复制
|
Shusain
|
http://linuxtechlab.com/creating-master-slave-replication-mariadb/
|
复制是用于为我们的数据库创建多个副本，这些副本可以在其它数据库上用于运行查询，像一些非常繁重的查询可能会影响主数据库服务器的性能，或者我们可以使用它来做数据冗余，或者兼具以上两个目的。我们可以将这个过程自动化，即主服务器到从服务器的复制过程自动进行。执行备份而不影响在主服务器上的写操作。
|
/data/attachment/album/201802/04/221301ve5vvocwioceiz5t.jpg.thumb.jpg
|
/data/attachment/album/201802/04/221301ve5vvocwioceiz5t.jpg
| true | false | true |
qhwdw
| false |
[
"MariaDB",
"数据库",
"主从复制"
] |
系统运维
|
{
"viewnum": 5343,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8320,
"displayorder": 0
},
{
"raid": 9306,
"displayorder": 1
}
] |
复制是用于为我们的数据库创建多个副本，这些副本可以在其它数据库上用于运行查询，像一些非常繁重的查询可能会影响主数据库服务器的性能，或者我们可以使用它来做数据冗余，或者兼具以上两个目的。我们可以将这个过程自动化，即主服务器到从服务器的复制过程自动进行。执行备份而不影响在主服务器上的写操作。
| 2018-02-04T22:13:00 | 2018-02-04T22:13:00 | 9,311 |
/article-9311-1.html
|
在我们前面的教程中，我们已经学习了 [如何安装和配置 MariaDB](/article-8320-1.html)，也学习了 [管理 MariaDB 的一些基础命令](/article-9306-1.html)。现在我们来学习，如何在 MariaDB 服务器上配置一个主从复制。
复制是用于为我们的数据库创建多个副本，这些副本可以在其它数据库上用于运行查询，像一些非常繁重的查询可能会影响主数据库服务器的性能，或者我们可以使用它来做数据冗余，或者兼具以上两个目的。我们可以将这个过程自动化，即主服务器到从服务器的复制过程自动进行。执行备份而不影响在主服务器上的写操作。
因此，我们现在去配置我们的主-从复制，它需要两台安装了 MariaDB 的机器。它们的 IP 地址如下：
* **主服务器 -** 192.168.1.120 **主机名 -** master.ltechlab.com
* **从服务器 -** 192.168.1.130 **主机名 -** slave.ltechlab.com
MariaDB 安装到这些机器上之后，我们继续进行本教程。如果你需要安装和配置 MariaDB 的教程，请查看[**这个教程**](/article-8320-1.html)。
### 第 1 步 - 主服务器配置
我们现在进入到 MariaDB 中的一个命名为 `important` 的数据库，它将被复制到我们的从服务器。为开始这个过程，我们编辑名为 `/etc/my.cnf` 的文件，它是 MariaDB 的配置文件。
```
$ vi /etc/my.cnf
```
在这个文件中找到 `[mysqld]` 节，然后输入如下内容：
```
[mysqld]
log-bin
server_id=1
replicate-do-db=important
bind-address=192.168.1.120
```
保存并退出这个文件。完成之后，需要重启 MariaDB 服务。
```
$ systemctl restart mariadb
```
接下来，我们登入我们的主服务器上的 Mariadb 实例。
```
$ mysql -u root -p
```
在它上面创建一个命名为 `slaveuser` 的为主从复制使用的新用户，然后运行如下的命令为它分配所需要的权限：
```
STOP SLAVE;
GRANT REPLICATION SLAVE ON *.* TO 'slaveuser'@'%' IDENTIFIED BY 'iamslave';
FLUSH PRIVILEGES;
FLUSH TABLES WITH READ LOCK;
SHOW MASTER STATUS;
```
**注意：** 我们配置主从复制需要 `MASTER_LOG_FILE` 和 `MASTER_LOG_POS` 的值，它可以通过 `show master status` 来获得，因此，你一定要确保你记下了它们的值。
这些命令运行完成之后，输入 `exit` 退出这个会话。
### 第 2 步 - 创建一个数据库备份，并将它移动到从服务器上
现在，我们需要去为我们的数据库 `important` 创建一个备份，可以使用 `mysqldump` 命令去备份。
```
$ mysqldump -u root -p important > important_backup.sql
```
备份完成后，我们需要重新登录到 MariaDB 数据库，并解锁我们的表。
```
$ mysql -u root -p
$ UNLOCK TABLES;
```
然后退出这个会话。现在，我们移动我们刚才的备份到从服务器上，它的 IP 地址是：192.168.1.130。
在主服务器上的配置已经完成了，现在，我们开始配置从服务器。
### 第 3 步：配置从服务器
我们再次去编辑（从服务器上的） `/etc/my.cnf` 文件，找到配置文件中的 `[mysqld]` 节，然后输入如下内容：
```
[mysqld]
server-id = 2
replicate-do-db=important
[ …]
```
现在，我们恢复我们主数据库的备份到从服务器的 MariaDB 上，运行如下命令：
```
$ mysql -u root -p < /data/ important_backup.sql
```
当这个恢复过程结束之后，我们将通过登入到从服务器上的 MariaDB，为数据库 `important` 上的用户 'slaveuser' 授权。
```
$ mysql -u root -p
```
```
GRANT ALL PRIVILEGES ON important.* TO 'slaveuser'@'localhost' WITH GRANT OPTION;
FLUSH PRIVILEGES;
```
接下来，为了这个变化生效，重启 MariaDB。
```
$ systemctl restart mariadb
```
### 第 4 步：启动复制
记住，我们需要 `MASTER_LOG_FILE` 和 `MASTER_LOG_POS` 变量的值，它可以通过在主服务器上运行 `SHOW MASTER STATUS` 获得。现在登入到从服务器上的 MariaDB，然后通过运行下列命令，告诉我们的从服务器它应该去哪里找主服务器。
```
STOP SLAVE;
CHANGE MASTER TO MASTER_HOST= '192.168.1.110′, MASTER_USER='slaveuser', MASTER_PASSWORD='iamslave', MASTER_LOG_FILE='mariadb-bin.000001′, MASTER_LOG_POS=460;
SLAVE START;
SHOW SLAVE STATUS\G;
```
**注意：** 请根据你的机器的具体情况来改变主服务器的配置。
### 第 5 步：测试复制
我们将在我们的主服务器上创建一个新表来测试主从复制是否正常工作。因此，登入到主服务器上的 MariaDB。
```
$ mysql -u root -p
```
选择数据库为 `important`：
```
use important;
```
在这个数据库上创建一个名为 `test` 的表：
```
create table test (c int);
```
然后在这个表中插入一些数据：
```
insert into test (c) value (1);
```
检索刚才插入的值是否存在：
```
select * from test;
```
你将会看到刚才你插入的值已经在这个新建的表中了。
现在，我们登入到从服务器的数据库中，查看主从复制是否正常工作。
```
$ mysql -u root -p
$ use important;
$ select * from test;
```
你可以看到与前面在主服务器上的命令输出是一样的。因此，说明我们的主从服务工作正常，没有发生任何问题。
我们的教程结束了，请在下面的评论框中留下你的查询/问题。
---
via: <http://linuxtechlab.com/creating-master-slave-replication-mariadb/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 与 Unix 之差异
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/linux-vs-unix
|
在计算机时代，相当一部分的人错误地认为 Unix 和 Linux 操作系统是一样的。然而，事实恰好相反。让我们仔细看看。
|
/data/attachment/album/201802/04/232043iar4qacg04g5gbqq.jpg.thumb.jpg
|
/data/attachment/album/201802/04/232043iar4qacg04g5gbqq.jpg
| true | false | true |
HardworkFish
| false |
[
"Linux",
"Unix"
] |
技术
|
{
"viewnum": 26395,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在计算机时代，相当一部分的人错误地认为 Unix 和 Linux 操作系统是一样的。然而，事实恰好相反。让我们仔细看看。
| 2018-02-04T23:20:00 | 2018-02-04T23:20:00 | 9,312 |
/article-9312-1.html
|
[](http://www.linuxandubuntu.com/home/linux-vs-unix)
在计算机时代，相当一部分的人错误地认为 **Unix** 和 **Linux** 操作系统是一样的。然而，事实恰好相反。让我们仔细看看。
### 什么是 Unix？
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/unix_orig.png)
在 IT 领域，以操作系统而为人所知的 Unix，是 1969 年 AT&T 公司在美国新泽西所开发的（目前它的商标权由国际开放标准组织所拥有）。大多数的操作系统都受到了 Unix 的启发，而 Unix 也受到了未完成的 Multics 系统的启发。Unix 的另一版本是来自贝尔实验室的 Plan 9。
#### Unix 被用于哪里？
作为一个操作系统，Unix 大多被用在服务器、工作站，现在也有用在个人计算机上。它在创建互联网、计算机网络或客户端/服务器模型方面发挥着非常重要的作用。
#### Unix 系统的特点
* 支持多任务
* 相比 Multics 操作更加简单
* 所有数据以纯文本形式存储
* 采用单一根文件的树状存储
* 能够同时访问多用户账户
#### Unix 操作系统的组成
**a)** 单核操作系统，负责低级操作以及由用户发起的操作，内核之间的通信通过系统调用进行。 **b)** 系统工具 **c)** 其他应用程序
### 什么是 Linux？
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/linux_orig.png)
这是一个基于 Unix 操作系统原理的开源操作系统。正如开源的含义一样，它是一个可以自由下载的系统。它也可以通过编辑、添加及扩充其源代码而定制该系统。这是它最大的好处之一，而不像今天的其它操作系统（Windows、Mac OS X 等）需要付费。Unix 系统不是创建新系统的唯一模版，另外一个重要的因素是 MINIX 系统，不像 Linus，此版本被其缔造者（Andrew Tanenbaum）用于商业系统。
Linux 由 Linus Torvalds 开发于 1991 年，这是一个其作为个人兴趣的操作系统。为什么 Linux 借鉴 Unix 的一个主要原因是因为其简洁性。Linux 第一个官方版本（0.01）发布于 1991 年 9 月 17 日。虽然这个系统并不是很完美和完善，但 Linus 对它产生很大的兴趣，并在几天内，Linus 发出了一些关于 Linux 源代码扩展以及其他想法的电子邮件。
#### Linux 的特点
Linux 的基石是 Unix 内核，其基于 Unix 的基本特点以及 **POSIX** 和单独的 **UNIX 规范标准**。看起来，该操作系统官方名字取自于 **Linus**，其中其操作系统名称的尾部的 “x” 和 **Unix 系统**相联系。
#### 主要功能
* 同时运行多任务（多任务）
* 程序可以包含一个或多个进程（多用途系统），且每个进程可能有一个或多个线程。
* 多用户，因此它可以运行多个用户程序。
* 个人帐户受适当授权的保护。
* 因此账户准确地定义了系统控制权。
**企鹅 Tux** 的 Logo 作者是 Larry Ewing，他选择这个企鹅作为他的开源 **Linux 操作系统**的吉祥物。**Linux Torvalds** 最初提出这个新的操作系统的名字为 “Freax” ，即为 “自由（free）” + “奇异（freak）” + x（UNIX 系统）的结合字，而不像存放它的首个版本的 FTP 服务器上所起的名字（Linux）。
---
via: <http://www.linuxandubuntu.com/home/linux-vs-unix>
作者：[linuxandubuntu](http://www.linuxandubuntu.com) 译者：[HardworkFish](https://github.com/HardworkFish) 校对：[imquanquan](https://github.com/imquanquan), [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我在 Twitch 平台直播编程的经验
|
Suz Hinton
|
https://medium.freecodecamp.org/lessons-from-my-first-year-of-live-coding-on-twitch-41a32e2f41c1
|
最近几个开发者问我怎么开始自己的直播，因此我在这里想大家展示我给他们的建议！
|
/data/attachment/album/201802/05/215410rqq4npcoarqqnylz.png.thumb.jpg
|
/data/attachment/album/201802/05/215410rqq4npcoarqqnylz.png
| true | false | true |
lonaparte
| false |
[
"编程",
"直播"
] |
桌面应用
|
{
"viewnum": 7237,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
最近几个开发者问我怎么开始自己的直播，因此我在这里想大家展示我给他们的建议！
| 2018-02-05T21:54:00 | 2018-02-05T21:54:00 | 9,313 |
/article-9313-1.html
|
去年 7 月我进行了第一次直播。不像大多数人那样在 Twitch 上进行游戏直播，我想直播的内容是我利用个人时间进行的开源工作。我对 NodeJS 硬件库有一定的研究（其中大部分是靠我自学的）。考虑到我已经在 Twitch 上有了一个直播间，为什么不再建一个更小更专业的直播间，比如 <ruby> 由 JavaScript 驱动的硬件 <rt> JavaScript powered hardware </rt></ruby> ;) 我注册了 [我自己的频道](https://www.twitch.tv/noopkat) ，从那以后我就开始定期直播。
我当然不是第一个这么做的人。[Handmade Hero](https://www.twitch.tv/handmade_hero) 是我最早看到的几个在线直播编程的程序员之一。很快这种直播方式被 Vlambeer 发扬光大，他在 Twitch 的 [Nuclear Throne live](http://nuclearthrone.com/twitch/) 直播间进行直播。我对 Vlambeer 尤其着迷。
我的朋友 [Nolan Lawson](https://twitter.com/nolanlawson) 让我 *真正开始做* 这件事，而不只是单纯地 *想要做* 。我看了他 [在周末直播开源工作](https://www.youtube.com/watch?v=9FBvpKllTQQ) ，做得棒极了。他解释了他当时做的每一件事。是的，每一件事，包括回复 GitHub 上的 <ruby> 问题 <rt> issues </rt></ruby> ，鉴别 bug ，在 <ruby> 分支 <rt> branches </rt></ruby> 中调试程序，你知道的。这令我着迷，因为 Nolan 使他的开源库得到了广泛的使用。他的开源生活和我的完全不一样。
你甚至可以看到我在他视频下的评论：
我大约在一周或更久之后建好了自己的 Twitch 频道，并摸清了 OBS 的使用方法，随后开始了自己的直播。我当时用的是 [Avrgirl-Arduino](https://github.com/noopkat/avrgirl-arduino) ，现在我依然经常用它直播。第一次直播十分粗糙。我前一天晚上排练得很晚，但直播时我依然很紧张。
那个星期六我极少的几个听众给了我很大的鼓舞，因此我坚持了下去。现在我有了超过一千个听众，他们中的一些人形成了一个可爱的小团体，他们会定期观看我的直播，我称呼他们为 “noopkat 家庭” 。
我们很开心。我想称呼这个即时编程部分为“多玩家在线组队编程”。我真的被他们每个人的热情和才能触动了。一次，一个团体成员指出我的 Arduino 开发板不能随同我的软件工作，因为板子上的芯片丢了。这真是最有趣的时刻之一。
我经常暂停直播，检查我的收件箱，看看有没有人对我提及过但没有时间完成的工作发起 <ruby> 拉取请求 <rt> pull request </rt></ruby> 。感谢我 Twitch 社区对我的帮助和鼓励。
我很想聊聊 Twitch 直播给我带来的好处，但它的内容太多了，我应该会在我下一篇博客里介绍。我在这里想要分享的，是我学习的关于如何自己实现直播编程的课程。最近几个开发者问我怎么开始自己的直播，因此我在这里想大家展示我给他们的建议！
首先，我在这里贴出一个给过我很大帮助的教程 [“Streaming and Finding Success on Twitch”](https://www.reddit.com/r/Twitch/comments/4eyva6/a_guide_to_streaming_and_finding_success_on_twitch/) 。它专注于 Twitch 与游戏直播，但也有很多和我们要做的东西相关的部分。我建议首先阅读这个教程，然后再考虑一些建立直播频道的细节（比如如何选择设备和软件）。
下面我列出我自己的配置。这些配置是从我多次的错误经验中总结出来的，其中要感谢我的直播同行的智慧与建议。（对，你们知道就是你们！）
### 软件
有很多免费的直播软件。我用的是 [Open Broadcaster Software (OBS)](https://obsproject.com/) 。它适用于大多数的平台。我觉得它十分直观且易于入门，但掌握其他的进阶功能则需要一段时间的学习。学好它你会获得很多好处！这是今天我直播时 OBS 的桌面截图（题图）。
你直播时需要在不用的“<ruby> 场景 <rt> scenes </rt></ruby>”中进行切换。一个“场景”是多个“<ruby> 素材 <rt> sources </rt></ruby>”通过堆叠和组合产生的集合。一个“素材”可以是照相机、麦克风、你的桌面、网页、动态文本、图片等等。 OBS 是一个很强大的软件。
最上方的桌面场景是我编程的环境，我直播的时候主要停留在这里。我使用 iTerm 和 vim ，同时打开一个可以切换的浏览器窗口来查阅文献或在 GitHub 上分类检索资料。
底部的黑色长方形是我的网络摄像头，人们可以通过这种更个人化的连接方式来观看我工作。
我的场景中有一些“标签”，很多都与状态或者顶栏信息有关。顶栏只是添加了个性化信息，它在直播时是一个很好的连续性素材。这是我在 [GIMP](https://www.gimp.org/) 里制作的图片，在你的场景里它会作为一个素材来加载。一些标签是从文本文件里添加的动态内容（例如最新粉丝）。另一个标签是一个 [custom one I made](https://github.com/noopkat/study-temp) ，它可以展示我直播的房间的动态温度与湿度。
我还在我的场景里设置了“闹钟”，当有人粉了我或者给了打赏，它会显示在最前方。我使用 [Stream Labs](https://streamlabs.com/) 网络服务来实现它，将它作为一个浏览器网页素材引进我的场景。 Stream Labs 也会在顶栏里给出我最新粉丝的动态信息。
我直播的时候，也会使用一个备用场景：
当我输入密码和 API keys 的时候，我另外需要一个场景。它会在网络摄像头里展示我，但是将我的桌面用一个娱乐页面隐藏起来，这样我可以做一些私密的工作：
正如你看到的，我直播的时候没有把窗口填的太满，但我让我的观众尽可能多地看到我的内容。
但现在有一个现实的秘密：我使用 OBS 来安排我屏幕的底部和右侧，同时视频保持了 Twitch 要求的长宽比。这让我有了空间在底部查看我的事件（订阅数等），同时在右侧观看和回复我的频道聊天室。 Twitch 允许新窗口“弹出”聊天室，这很有用。
这是我完整的桌面看起来的样子：
我几个月前开始做这个，还没有回顾过。我甚至不确定我的观众们有没有意识到我进行的这些精心的设置。我想他们可能会把“我可以看到每个东西”视作理所应当，而事实上我常常忙于敲代码，而看不到正在直播的东西！
你可能想知道为什么我只用一个显示器。这是因为两个显示器在我直播的时候太难以管理了。我很快意识到这一点，并且恢复了单屏。
### 硬件
我从使用便宜的器材开始，当我意识到我会长期坚持直播之后，才将它们逐渐换成更好的。开始的时候尽量使用你现有的器材，即使是只用电脑内置的摄像头与麦克风。
现在我使用 Logitech Pro C920 网络摄像头，和一个固定有支架的 Blue Yeti 麦克风。花费是值得的。我直播的质量完全不同了。
我使用大屏显示器（27"），因为我之前说的，使用两个屏幕对我来说不方便。我常常错过聊天，因为我经常不检查我的第二屏幕。你可能觉得使用两个屏幕很方便，但对我来说，把所有东西放在一个屏幕上有利于我对所有事情保持注意力。
这基本上就是硬件部分的大部分内容了。我没有使用复杂的设置。
如果你感兴趣，我的桌面看起来不错，除了刺眼的麦克风：
### 建议
最后这里有一些我通过实践得出的一般性建议，这使我的直播从整体来看变得更好，更有趣。
#### 布告板
花点时间建立一个好的布告版。布告板是位于每个人频道底部的小内容框。我把它们看作新的个人空间窗口（真的）。理想的布告板可以有类似于聊天规则，有关直播内容的信息，你使用的电脑和设备，你最喜欢的猫的种类，等等这样的东西。任何关于个人形象的内容都可以。我们可以看看其他人（尤其是热播播主）的理想的布告板是什么样的！
一个我的布告板的例子：
#### 聊天
聊天真的很重要。你可能会被中途观看你直播的人一遍又一遍地问同样的问题，如果可以像现实生活中那样聊天那样会很方便。“你正在做什么？”是我敲代码的时候别人最常问我的问题。我用 [Nightbot](https://beta.nightbot.tv/) 设置了一个聊天快捷命令。当你输入一些像 *whatamidoing*（我正在做什么） 这样的单词时，会自动给出我事先设好的解释。
当人们问问题或者给出一些有趣的评论时，要回复他们！和他们说谢谢，说他们的 Twitch 用的很好，他们会感谢你的关心和认可。一开始的时候很难对这些都保持注意力，但你做得多了之后，你会发现同时做这几件事变得更容易了。尝试着每两分钟就花几秒去关注聊天室。
当你编程的时候，*解释你正在做的事* 。多说点。开开玩笑。即使我碰到了麻烦，我也会说：“哦，糟糕，我忘了这个方法怎么用了，我 Google 一下看看”。人们一般都很友好，有时他们还会和你一起寻找解决的办法。这很有趣，让人们一直看着你。
如果播主一直安静地坐在那敲代码，不去聊天，也不管他新粉丝的信息，我会很快对他失去兴趣。
很可能你 99% 的观众都很友好，并且都有好奇心。我偶尔还是会碰到挑衅的人，但 Twitch 提供的检查工具可以有效避免这种情况。
#### 准备时间
尽量将你的配置“自动化”。我的终端是 iTerm ，它可以让你保存窗口排列和字体大小的配置，这样你以后就可以再现这些配置。我有一个直播时的配置和一个不直播时的配置，这非常省事。我输入一个命令，所有东西就都在合适的位置并保持最完美的尺寸，并可以使用了。
还有其他的应用可以用来自动化你的窗口位置，看看有没有对你有用的。
让你的字体在终端和编辑器中尽可能的大，这样所有人都能看清。
#### 定期直播
让你的日程表更有规律。我一周只直播一次，但总是在同一时间。如果你临时有事不能在你平常直播的时间直播，要让人们知道。这让我保持了一些固定观众。一些人喜欢固定的时间，这就像和朋友在一起一样。你和你的社区在一个社交圈子里，所以要像对待朋友一样对待他们。
我想要提高我更新直播的频率，但我知道因为旅游的缘故我不能适应超过一周一次的直播频率。我正在尝试找到一种可以让我在路上也能高质量地直播的方法。或许可以临时将我聊天和写代码的过程保存起来，周末直播的时候再放出来。我仍然在探索这些办法！
#### 紧张心理
当你即将开始的时候，你会感觉很奇怪，不适应。你会在人们看着你写代码的时候感到紧张。这很正常！尽管我之前有过公共演说的经历，我一开始的时候还是感到陌生而不适应。我感觉我无处可藏，这令我害怕。我想：“大家可能都觉得我的代码很糟糕，我是一个糟糕的开发者。”这是一个困扰了我 *整个职业生涯* 的想法，对我来说不新鲜了。我知道带着这些想法，我不能在发布到 GitHub 之前仔细地再检查一遍代码，而这样做更有利于我保持我作为开发者的声誉。
我从 Twitch 直播中发现了很多关于我代码风格的东西。我知道我的风格绝对是“先让它跑起来，然后再考虑可读性，然后再考虑运行速度”。我不再在前一天晚上提前排练好直播的内容（一开始的三、四次直播我都是这么做的），所以我在 Twitch 上写的代码是相当粗糙的，我还得保证它们运行起来没问题。当我不看别人的聊天和讨论的时候，我可以写出我最好的代码，这样是没问题的。但我总会忘记我使用过无数遍的方法的名字，而且每次直播的时候都会犯“愚蠢的”错误。一般来说，这不是一个让你能达到你最好状态的生产环境。
我的 Twitch 社区从来不会因为这个苛求我，反而是他们帮了我很多。他们理解我正同时做着几件事，而且真的给了很多务实的意见和建议。有时是他们帮我找到了解决方法，有时是我要向他们解释为什么他们的建议不适合解决这个问题。这真的很像一般意义的组队编程！
我想这种“不管重要不重要，什么都说”的情况对于直播这种媒介来说是一种优势，而不是劣势。它让我想的更多。理解一个观念很重要，那就是没有完美的程序员，也没有完美的代码。对于一个新手程序员来说这是令人耳目一新的经历，对我这个老手来说却是微不足道的。
### 总结
如果你想过在 Twitch 上直播，我希望你试一下！如果你想知道怎么迈出第一步，我希望这篇博客可以帮的到你。
如果你周日想要加入我的直播，你可以 [订阅我的 Twitch 频道](https://www.twitch.tv/noopkat) :)
最后我想说一下，我自己十分感谢 [Mattias Johansson](https://twitter.com/mpjme) 在我早期开始直播的时候给我的建议和鼓励。他的 [FunFunFunction YouTube channel](https://www.youtube.com/channel/UCO1cgjhGzsSYb1rsB4bFe4Q) 也是一个令人激动的定期直播频道。
另：许多人问过我的键盘和其他工作设备是什么样的， [这是我使用的器材的完整列表](https://gist.github.com/noopkat/5de56cb2c5917175c5af3831a274a2c8) 。感谢关注！
---
via: <https://medium.freecodecamp.org/lessons-from-my-first-year-of-live-coding-on-twitch-41a32e2f41c1>
作者：[Suz Hinton](https://medium.freecodecamp.org/@suzhinton) 译者：[lonaparte](https://github.com/lonaparte) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么应该在 Linux 上使用命名管道
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3251853/linux/why-use-named-pipes-on-linux.html
|
命名管道并不常用，但是它们为进程间通讯提供了一些有趣的特性。
|
/data/attachment/album/201802/05/225813e9cvc9gscgz7mzgw.jpg.thumb.jpg
|
/data/attachment/album/201802/05/225813e9cvc9gscgz7mzgw.jpg
| true | false | true |
YPBlib
| false |
[
"管道",
"命名管道",
"mkfifo"
] |
技术
|
{
"viewnum": 5777,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
命名管道并不常用，但是它们为进程间通讯提供了一些有趣的特性。
| 2018-02-05T22:58:08 | 2018-02-05T22:58:08 | 9,314 |
/article-9314-1.html
|
>
> 命名管道并不常用，但是它们为进程间通讯提供了一些有趣的特性。
>
>
>
估计每一位 Linux 使用者都熟悉使用 “|” 符号将数据从一个进程传输到另一个进程的操作。它使用户能简便地从一个命令输出数据到另一个命令，并筛选出想要的数据而无须写脚本进行选择、重新格式化等操作。
还有另一种管道， 虽然也叫“管道”这个名字却有着非常不同的性质。即您可能尚未使用甚至尚未知晓的——命名管道。
普通管道与命名管道的一个主要区别就是命名管道是以文件形式实实在在地存在于文件系统中的，没错，它们表现出来就是文件。但是与其它文件不同的是，命名管道文件似乎从来没有文件内容。即使用户往命名管道中写入大量数据，该文件看起来还是空的。
### 如何在 Linux 上创建命名管道
在我们研究这些空空如也的命名管道之前，先追根溯源来看看命名管道是如何被创建的。您应该使用名为 `mkfifo` 的命令来创建它们。为什么提及“FIFO”？是因为命名管道也被认为是一种 FIFO 特殊文件。术语 “FIFO” 指的是它的<ruby> 先进先出 <rt> first-in, first-out </rt></ruby>特性。如果你将冰淇淋盛放到碟子中，然后可以品尝它，那么你执行的就是一个LIFO（<ruby> 后进先出 <rt> last-in, first-out </rt></ruby>操作。如果你通过吸管喝奶昔，那你就在执行一个 FIFO 操作。好，接下来是一个创建命名管道的例子。
```
$ mkfifo mypipe
$ ls -l mypipe
prw-r-----. 1 shs staff 0 Jan 31 13:59 mypipe
```
注意一下特殊的文件类型标记 “p” 以及该文件大小为 0。您可以将重定向数据写入命名管道文件，而文件大小依然为 0。
```
$ echo "Can you read this?" > mypipe
```
正如上面所说，敲击回车后似乎什么都没有发生（LCTT 译注：没有返回命令行提示符）。
另外再开一个终端，查看该命名管道的大小，依旧是 0：
```
$ ls -l mypipe
prw-r-----. 1 shs staff 0 Jan 31 13:59 mypipe
```
也许这有违直觉，用户输入的文本已经进入该命名管道，而你仍然卡在输入端。你或者其他人应该等在输出端，并准备读取放入管道的数据。现在让我们读取看看。
```
$ cat mypipe
Can you read this?
```
一旦被读取之后，管道中的内容就没有了。
另一种研究命名管道如何工作的方式是通过将放入数据的操作置入后台来执行两个操作（将数据放入管道，而在另外一段读取它）。
```
$ echo "Can you read this?" > mypipe &
[1] 79302
$ cat mypipe
Can you read this?
[1]+ Done echo "Can you read this?" > mypipe
```
一旦管道被读取或“耗干”，该管道就清空了，尽管我们还能看见它并再次使用。可为什么要费此周折呢？
### 为何要使用命名管道？
命名管道很少被使用的理由似乎很充分。毕竟在 Unix 系统上，总有多种不同的方式完成同样的操作。有多种方式写文件、读文件、清空文件，尽管命名管道比它们来得更高效。
值得注意的是，命名管道的内容驻留在内存中而不是被写到硬盘上。数据内容只有在输入输出端都打开时才会传送。用户可以在管道的输出端打开之前向管道多次写入。通过使用命名管道，用户可以创建一个进程写入管道并且另外一个进程读取管道的流程，而不用关心协调二者时间上的同步。
用户可以创建一个单纯等待数据出现在管道输出端的进程，并在拿到输出数据后对其进行操作。下列命令我们采用 `tail` 来等待数据出现。
```
$ tail -f mypipe
```
一旦供给管道数据的进程结束了，我们就可以看到一些输出。
```
$ tail -f mypipe
Uranus replicated to WCDC7
Saturn replicated to WCDC8
Pluto replicated to WCDC9
Server replication operation completed
```
如果研究一下向命名管道写入的进程，用户也许会惊讶于它的资源消耗之少。在下面的 `ps` 命令输出中，唯一显著的资源消耗是虚拟内存（VSZ 那一列）。
```
ps u -P 80038
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
shs 80038 0.0 0.0 108488 764 pts/4 S 15:25 0:00 -bash
```
命名管道与 Unix/Linux 系统上更常用的管道相比足以不同到拥有另一个名号，但是“管道”确实能反映出它们如何在进程间传送数据的形象，故将称其为“命名管道”还真是恰如其分。也许您在执行操作时就能从这个聪明的 Unix/Linux 特性中获益匪浅呢。
---
via: <https://www.networkworld.com/article/3251853/linux/why-use-named-pipes-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 译者：[YPBlib](https://github.com/YPBlib) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 系统查询机器最近重启时间
|
Vivek Gite
|
https://www.cyberciti.biz/tips/linux-last-reboot-time-and-date-find-out.html
|
要查看 Linux 或类 UNIX 系统重启和关机的时间和日期，可以使用下面的命令：last 命令、who 命令、uptime 命令。
|
/data/attachment/album/201802/06/002508sxtqeyxmetsjgeul.jpg.thumb.jpg
|
/data/attachment/album/201802/06/002508sxtqeyxmetsjgeul.jpg
| true | false | true |
amwps290
| false |
[
"重启",
"时间"
] |
技术
|
{
"viewnum": 12473,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
要查看 Linux 或类 UNIX 系统重启和关机的时间和日期，可以使用下面的命令：last 命令、who 命令、uptime 命令。
| 2018-02-06T00:25:24 | 2018-02-06T00:25:24 | 9,315 |
/article-9315-1.html
|
在你的 Linux 或类 UNIX 系统中，你是如何查询系统上次重新启动的日期和时间？怎样显示系统关机的日期和时间？ `last` 命令不仅可以按照时间从近到远的顺序列出该会话的特定用户、终端和主机名，而且还可以列出指定日期和时间登录的用户。输出到终端的每一行都包括用户名、会话终端、主机名、会话开始和结束的时间、会话持续的时间。要查看 Linux 或类 UNIX 系统重启和关机的时间和日期，可以使用下面的命令。
* `last` 命令
* `who` 命令
### 使用 who 命令来查看系统重新启动的时间/日期
你需要在终端使用 [who](https://www.cyberciti.biz/faq/unix-linux-who-command-examples-syntax-usage/ "See Linux/Unix who command examples for more info") 命令来打印有哪些人登录了系统，`who` 命令同时也会显示上次系统启动的时间。使用 `last` 命令来查看系统重启和关机的日期和时间，运行：
```
$ who -b
```
示例输出：
```
system boot 2017-06-20 17:41
```
使用 `last` 命令来查询最近登录到系统的用户和系统重启的时间和日期。输入：
```
$ last reboot | less
```
示例输出：
[](https://www.cyberciti.biz/tips/wp-content/uploads/2006/04/last-reboot.jpg)
或者，尝试输入：
```
$ last reboot | head -1
```
示例输出：
```
reboot system boot 4.9.0-3-amd64 Sat Jul 15 19:19 still running
```
`last` 命令通过查看文件 `/var/log/wtmp` 来显示自 wtmp 文件被创建时的所有登录（和登出）的用户。每当系统重新启动时，这个伪用户 `reboot` 就会登录。因此，`last reboot` 命令将会显示自该日志文件被创建以来的所有重启信息。
### 查看系统上次关机的时间和日期
可以使用下面的命令来显示上次关机的日期和时间：
```
$ last -x|grep shutdown | head -1
```
示例输出：
```
shutdown system down 2.6.15.4 Sun Apr 30 13:31 - 15:08 (01:37)
```
命令中，
* `-x`：显示系统关机和运行等级改变信息
这里是 `last` 命令的其它的一些选项：
```
$ last
$ last -x
$ last -x reboot
$ last -x shutdown
```
示例输出：
### 查看系统正常的运行时间
评论区的读者建议的另一个命令如下：
```
$ uptime -s
```
示例输出：
```
2017-06-20 17:41:51
```
### OS X/Unix/FreeBSD 查看最近重启和关机时间的命令示例
在终端输入下面的命令：
```
$ last reboot
```
在 OS X 示例输出结果如下：
```
reboot ~ Fri Dec 18 23:58
reboot ~ Mon Dec 14 09:54
reboot ~ Wed Dec 9 23:21
reboot ~ Tue Nov 17 21:52
reboot ~ Tue Nov 17 06:01
reboot ~ Wed Nov 11 12:14
reboot ~ Sat Oct 31 13:40
reboot ~ Wed Oct 28 15:56
reboot ~ Wed Oct 28 11:35
reboot ~ Tue Oct 27 00:00
reboot ~ Sun Oct 18 17:28
reboot ~ Sun Oct 18 17:11
reboot ~ Mon Oct 5 09:35
reboot ~ Sat Oct 3 18:57
wtmp begins Sat Oct 3 18:57
```
查看关机日期和时间，输入：
```
$ last shutdown
```
示例输出：
```
shutdown ~ Fri Dec 18 23:57
shutdown ~ Mon Dec 14 09:53
shutdown ~ Wed Dec 9 23:20
shutdown ~ Tue Nov 17 14:24
shutdown ~ Mon Nov 16 21:15
shutdown ~ Tue Nov 10 13:15
shutdown ~ Sat Oct 31 13:40
shutdown ~ Wed Oct 28 03:10
shutdown ~ Sun Oct 18 17:27
shutdown ~ Mon Oct 5 09:23
wtmp begins Sat Oct 3 18:57
```
### 如何查看是谁重启和关闭机器？
你需要[启用 psacct 服务然后运行下面的命令](https://www.cyberciti.biz/tips/howto-log-user-activity-using-process-accounting.html)来查看执行过的命令（包括用户名），在终端输入 [lastcomm](https://www.cyberciti.biz/faq/linux-unix-lastcomm-command-examples-usage-syntax/ "See Linux/Unix lastcomm command examples for more info") 命令查看信息
```
# lastcomm userNameHere
# lastcomm commandNameHere
# lastcomm | more
# lastcomm reboot
# lastcomm shutdown
### 或者查看重启和关机时间
# lastcomm | egrep 'reboot|shutdown'
```
示例输出：
```
reboot S X root pts/0 0.00 secs Sun Dec 27 23:49
shutdown S root pts/1 0.00 secs Sun Dec 27 23:45
```
我们可以看到 root 用户在当地时间 12 月 27 日星期二 23:49 在 pts/0 重新启动了机器。
### 参见
* 更多信息可以查看 man 手册（`man last`）和参考文章 [如何在 Linux 服务器上使用 tuptime 命令查看历史和统计的正常的运行时间](https://www.cyberciti.biz/hardware/howto-see-historical-statistical-uptime-on-linux-server/)。
### 关于作者
作者是 nixCraft 的创立者，同时也是一名经验丰富的系统管理员，也是 Linux，类 Unix 操作系统 shell 脚本的培训师。他曾与全球各行各业的客户工作过，包括 IT，教育，国防和空间研究以及非营利部门等等。你可以在 [Twitter](https://twitter.com/nixcraft)、[Facebook](https://facebook.com/nixcraft)、[Google+](https://plus.google.com/+CybercitiBiz) 关注他。
---
via: <https://www.cyberciti.biz/tips/linux-last-reboot-time-and-date-find-out.html>
作者：[Vivek Gite](https://www.cyberciti.biz/) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
容器、GPL 与左版：无需过度担忧
|
Richard Fontana
|
https://opensource.com/article/18/1/containers-gpl-and-copyleft
|
想要知道开源许可证对 Linux 容器有什么影响吗？以下问题您需要了解。
|
/data/attachment/album/201802/06/184358sadosnlnarp9ybqr.png.thumb.jpg
|
/data/attachment/album/201802/06/184358sadosnlnarp9ybqr.png
| true | false | true |
薛亮
| false |
[
"许可证",
"容器"
] |
开源智慧
|
{
"viewnum": 4093,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
想要知道开源许可证对 Linux 容器有什么影响吗？以下问题您需要了解。
| 2018-02-06T18:43:00 | 2018-02-06T18:43:00 | 9,316 |
/article-9316-1.html
|
>
> 提要：想要知道开源许可证对 Linux 容器有什么影响吗？以下问题您需要了解。
>
>
>
尽管目前开源软件已经成为主流，但是不断涌现的软件新技术以及重新流行的旧技术有时也会引发对开源许可证的强烈担忧。大多数情况下，大家关注的焦点是 GPL 许可证，特别是经常（有时是误导性的）被描述为 GPL 衍生作品问题的<ruby> 左版 <rp> （ </rp> <rt> copyleft </rt> <rp> ） </rp></ruby>范围问题。
将该问题结构化的一个不完美方式是：遵循 GPL 许可证的代码在某种意义上与专有代码相结合，形成一个单独的修改后作品，是否可以解释为该专有代码受到 GPL 许可证的约束？虽然我们还没有看到很多针对 Linux 容器的问题，但随着容器的采用持续增长，我们预计会有更多的问题提出来。不过，有相当简单的方式可以表明，容器不会引发新的或有关 GPL 范围的问题。
法规和判例在解释类似 GPL 这样的许可证方面几乎没有什么帮助。另一方面，即使是在自由软件基金会（FSF）不是相关软件版权持有者的典型情况下，我们中的许多人也重视 FSF 作为 GPL 起草者和管理者的解释性观点。除了作为许可证文本的作者之外，FSF 多年来一直致力于向社区提供有关许可证的评论和指导。基于自由软件政策的公共利益使命和领导力，FSF 的观点具有特殊的可信度和影响力。
FSF 关于 GPL 解释的现有指导，有助于理解在容器中将 GPL 代码和非 GPL 代码包含在内所产生的效果。FSF 在界定左版范围时重点考虑了进程的边界，以及多个软件组件之间的通信机制和语义，以确定它们的紧密集成程度是否足以被视为 GPL 意义下的单个程序。例如，[GNU 许可证常见问题解答](https://www.gnu.org/licenses/gpl-faq.en.html#MereAggregation)认为，在没有足够<ruby> “密切” <rp> （ </rp> <rt> intimate </rt> <rp> ） </rp></ruby>通信的情况下，**管道、套接字和命令行参数通常可以被隐含认为是具备独立性的机制**。
考虑容器中有 GPL 代码和专有代码可能共存并执行的情况，实际上，容器是一个孤立的用户空间栈。在 [OCI 容器映像格式](https://github.com/opencontainers/image-spec/blob/master/spec.md)中，代码被打包为一组文件系统的变更层，基本层通常是一个没有内核的精简传统 Linux 发行版。与非容器化的 Linux 发行版的用户空间一样，这些基本层包括许多遵循 GPL 许可证（GPL v2 以及 GPL v3）的软件包，以及许多遵循被认为与 GPL 不兼容许可证的软件包，并且通常作为专有以及开源应用的运行环境。GPL v2 中“<ruby> <a href="https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html#section2"> 单纯聚合 </a> <rp> （ </rp> <rt> mere aggregation </rt> <rp> ） </rp></ruby>”条款（以及 GPL v3 中有关“[聚合](https://www.gnu.org/licenses/gpl.html#section5)”的条款）表明，这种组合通常是可以被接受的，在 GPL 中进行了特别考虑，如果不兼容的被许可组件是分离和独立的，就不会影响两个程序的许可。
当然，在特定情况下，两个组件之间的关系可能不是“单纯聚合”，但是在 Linux 系统上的非容器化用户空间中运行的软件也是如此。容器或容器映像的技术构成中没有任何暗示表明需要应用特殊形式的左版范围分析。
因此，当考察运行在容器中的代码和运行在容器外面的代码之间的关系时，几乎肯定会满足“分离和独立”的标准。代码将作为单独的进程运行，使用容器的整个技术要点是与运行在系统上的其他软件隔离。
现在考虑两个组件的情况，其中一个遵循 GPL 许可证，另一个为专有软件，它们运行在分离但可能交互的容器中，也许作为使用[微服务](https://www.redhat.com/en/topics/microservices)体系结构设计的应用程序的一部分。在没有特别不寻常事实的情况下，我们不应该期望看到左版的范围跨越多个容器。分离的容器涉及分离的进程。通过网络接口在容器之间进行通信类似于管道、套接字等机制，多容器微服务场景似乎排除了 FSF 所定义的“[密切](https://www.gnu.org/licenses/gpl-faq.en.html#GPLPlugins)”通信。使用多个容器的应用程序的组成可能不是 GPL 范围问题的决定因素，但它使组件之间的技术边界更加明显，并为争论“分离性”提供了强有力的基础。这其中也没有容器的技术特征暗示对左版的范围分析应用不同或更严格的方法。
过度关心分发 GPL 代码潜在影响的企业可能会试图禁止其开发人员将任何此类代码添加到计划分发的容器映像中，目的就是为了避免依据 GPL 许可证分发代码，但这是一个容易受到质疑的策略。如上所述，常规容器映像的基础层将包含多个遵循 GPL 的组件。如果该公司将容器映像推送到注册表中，通常无法保证这其中不包含基础层，即使它被广泛共享。
另一方面，通过隔离 GPL 代码和专有代码，企业可能会决定采用容器化作为减少左版范围影响的一种手段，虽然人们希望基于技术上的益处，而不是莫须有的对 GPL 焦虑所带来的法律担忧来推动该决策。而在非容器化环境中，两个相互作用的软件组件之间的关系往往是单纯聚合，容器化所提供的“分离性”证据可能让那些担心 GPL 范围的人们感到安慰。
共享容器映像时，可能会出现开源许可证合规义务问题。但是，对于容器来说，没有什么技术上的不同或独一无二的东西可以改变这些义务的性质，或者使它们更难满足。关于左版的范围，容器化应该能够缓解过度的担忧。
---
作者简介：Richard Fontana 是红帽公司法律部门产品和技术团队的高级商业顾问。 他的大部分工作都集中在开源相关的法律问题上。
译者简介：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
在 Linux 上检测 IDE/SATA SSD 硬盘的传输速度
|
Vivek Gite
|
https://www.cyberciti.biz/tips/how-fast-is-linux-sata-hard-disk.html
|
你知道你的硬盘在 Linux 下传输有多快吗？不打开电脑的机箱或者机柜，你知道它运行在 SATA I (150 MB/s) 、 SATA II (300 MB/s) 还是 SATA III (6.0Gb/s) 呢？
|
/data/attachment/album/201802/06/192251yo898kcvcc24cqhp.jpg.thumb.jpg
|
/data/attachment/album/201802/06/192251yo898kcvcc24cqhp.jpg
| true | false | true |
MonkeyDEcho
| false |
[
"磁盘",
"测试"
] |
技术
|
{
"viewnum": 13898,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你知道你的硬盘在 Linux 下传输有多快吗？不打开电脑的机箱或者机柜，你知道它运行在 SATA I (150 MB/s) 、 SATA II (300 MB/s) 还是 SATA III (6.0Gb/s) 呢？
| 2018-02-06T19:22:56 | 2018-02-06T19:22:56 | 9,317 |
/article-9317-1.html
|
你知道你的硬盘在 Linux 下传输有多快吗？不打开电脑的机箱或者机柜，你知道它运行在 SATA I (150 MB/s) 、 SATA II (300 MB/s) 还是 SATA III (6.0Gb/s) 呢？
你能够使用 `hdparm` 和 `dd` 命令来检测你的硬盘速度。它为各种硬盘的 ioctls 提供了命令行界面，这是由 Linux 系统的 ATA / IDE / SATA 设备驱动程序子系统所支持的。有些选项只能用最新的内核才能正常工作（请确保安装了最新的内核）。我也推荐使用最新的内核源代码的包含头文件来编译 `hdparm` 命令。
### 如何使用 hdparm 命令来检测硬盘的传输速度
以 root 管理员权限登录并执行命令：
```
$ sudo hdparm -tT /dev/sda
```
或者，
```
$ sudo hdparm -tT /dev/hda
```
输出：
```
/dev/sda:
Timing cached reads: 7864 MB in 2.00 seconds = 3935.41 MB/sec
Timing buffered disk reads: 204 MB in 3.00 seconds = 67.98 MB/sec
```
为了检测更精准，这个操作应该**重复2-3次** 。这显示了无需访问磁盘，直接从 Linux 缓冲区缓存中读取的速度。这个测量实际上是被测系统的处理器、高速缓存和存储器的吞吐量的指标。这是一个 [for 循环的例子](https://www.cyberciti.biz/faq/bash-for-loop/)，连续运行测试 3 次：
```
for i in 1 2 3; do hdparm -tT /dev/hda; done
```
这里，
* `-t` ：执行设备读取时序
* `-T` ：执行缓存读取时间
* `/dev/sda` ：硬盘设备文件
要 [找出 SATA 硬盘的连接速度](https://www.cyberciti.biz/faq/linux-command-to-find-sata-harddisk-link-speed/) ，请输入：
```
sudo hdparm -I /dev/sda | grep -i speed
```
输出：
```
* Gen1 signaling speed (1.5Gb/s)
* Gen2 signaling speed (3.0Gb/s)
* Gen3 signaling speed (6.0Gb/s)
```
以上输出表明我的硬盘可以使用 1.5Gb/s、3.0Gb/s 或 6.0Gb/s 的速度。请注意，您的 BIOS/主板必须支持 SATA-II/III 才行：
```
$ dmesg | grep -i sata | grep 'link up'
```
[](https://www.cyberciti.biz/tips/wp-content/uploads/2007/10/Linux-Check-IDE-SATA-SSD-Hard-Disk-Transfer-Speed.jpg)
### dd 命令
你使用 `dd` 命令也可以获取到相应的速度信息：
```
dd if=/dev/zero of=/tmp/output.img bs=8k count=256k
rm /tmp/output.img
```
输出：
```
262144+0 records in
262144+0 records out
2147483648 bytes (2.1 GB) copied, 23.6472 seconds, `90.8 MB/s`
```
下面是 [推荐的 dd 命令参数](https://www.cyberciti.biz/faq/howto-linux-unix-test-disk-performance-with-dd-command/)：
```
dd if=/dev/input.file of=/path/to/output.file bs=block-size count=number-of-blocks oflag=dsync
## GNU dd syntax ##
dd if=/dev/zero of=/tmp/test1.img bs=1G count=1 oflag=dsync
## OR alternate syntax for GNU/dd ##
dd if=/dev/zero of=/tmp/testALT.img bs=1G count=1 conv=fdatasync
```
这是上面命令的第三个命令的输出结果：
```
1+0 records in
1+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 4.23889 s, 253 MB/s
```
### “磁盘与存储” - GUI 工具
您还可以使用位于“系统>管理>磁盘实用程序”菜单中的磁盘实用程序。请注意，在最新版本的 Gnome 中，它简称为“磁盘”。
#### 如何使用 Linux 上的“磁盘”测试我的硬盘的性能？
要测试硬盘的速度：
1. 从“活动概览”中打开“磁盘”（按键盘上的 super 键并键入“disks”）
2. 从“左侧窗格”的列表中选择“磁盘”
3. 选择菜单按钮并从菜单中选择“测试磁盘性能……”
4. 单击“开始性能测试……”并根据需要调整传输速率和访问时间参数。
5. 选择“开始性能测试”来测试从磁盘读取数据的速度。需要管理权限请输入密码。
以上操作的快速视频演示：
<https://www.cyberciti.biz/tips/wp-content/uploads/2007/10/disks-performance.mp4>
#### 只读 Benchmark (安全模式下)
然后，选择 > 只读:
上述选项不会销毁任何数据。
#### 读写的 Benchmark（所有数据将丢失，所以要小心）
访问“系统>管理>磁盘实用程序菜单>单击性能测试>单击开始读/写性能测试按钮：
### 作者
作者是 nixCraft 的创造者，是经验丰富的系统管理员，也是 Linux 操作系统/ Unix shell 脚本的培训师。他曾与全球客户以及 IT，教育，国防和空间研究以及非营利部门等多个行业合作。在Twitter，Facebook和Google+上关注他。
---
via: <https://www.cyberciti.biz/tips/how-fast-is-linux-sata-hard-disk.html>
作者：[Vivek Gite](https://www.cyberciti.biz/) 译者：[MonkeyDEcho](https://github.com/MonkeyDEcho) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
八种在 Linux 上生成随机密码的方法
|
Kerneltalks
|
https://kerneltalks.com/tips-tricks/8-ways-to-generate-random-password-in-linux/
|
学习使用 8 种 Linux 原生命令或第三方实用程序来生成随机密码。
|
/data/attachment/album/201802/06/235820hjcj4fw6mmxw6fzw.png.thumb.jpg
|
/data/attachment/album/201802/06/235820hjcj4fw6mmxw6fzw.png
| true | false | true |
heart4lor
| false |
[
"密码"
] |
技术
|
{
"viewnum": 21957,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习使用 8 种 Linux 原生命令或第三方实用程序来生成随机密码。
| 2018-02-06T23:58:14 | 2018-02-06T23:58:14 | 9,318 |
/article-9318-1.html
|
>
> 学习使用 8 种 Linux 原生命令或第三方实用程序来生成随机密码。
>
>
>
在这篇文章中，我们将引导你通过几种不同的方式在 Linux 终端中生成随机密码。其中几种利用原生 Linux 命令，另外几种则利用极易在 Linux 机器上安装的第三方工具或实用程序实现。在这里我们利用像 `openssl`, [dd](https://kerneltalks.com/commands/learn-dd-command-with-examples/), `md5sum`, `tr`, `urandom` 这样的原生命令和 mkpasswd，randpw，pwgen，spw，gpg，xkcdpass，diceware，revelation，keepaasx，passwordmaker 这样的第三方工具。
其实这些方法就是生成一些能被用作密码的随机字母字符串。随机密码可以用于新用户的密码，不管用户基数有多大，这些密码都是独一无二的。话不多说，让我们来看看 8 种不同的在 Linux 上生成随机密码的方法吧。
### 使用 mkpasswd 实用程序生成密码
`mkpasswd` 在基于 RHEL 的系统上随 `expect` 软件包一起安装。在基于 Debian 的系统上 `mkpasswd` 则在软件包 `whois` 中。直接安装 `mkpasswd` 软件包将会导致错误：
* RHEL 系统：软件包 mkpasswd 不可用。
* Debian 系统：错误：无法定位软件包 mkpasswd。
所以按照上面所述安装他们的父软件包，就没问题了。
运行 `mkpasswd` 来获得密码
```
root@kerneltalks# mkpasswd << on RHEL
zt*hGW65c
root@kerneltalks# mkpasswd teststring << on Ubuntu
XnlrKxYOJ3vik
```
这个命令在不同的系统上表现得不一样，所以工作方式各异。你也可以通过参数来控制长度等选项，可以查阅 man 手册来探索。
### 使用 openssl 生成密码
几乎所有 Linux 发行版都包含 openssl。我们可以利用它的随机功能来生成可以用作密码的随机字母字符串。
```
root@kerneltalks # openssl rand -base64 10
nU9LlHO5nsuUvw==
```
这里我们使用 `base64` 编码随机函数，最后一个数字参数表示长度。
### 使用 urandom 生成密码
设备文件 `/dev/urandom` 是另一个获得随机字符串的方法。我们使用 `tr` 功能并裁剪输出来获得随机字符串，并把它作为密码。
```
root@kerneltalks # strings /dev/urandom |tr -dc A-Za-z0-9 | head -c20; echo
UiXtr0NAOSIkqtjK4c0X
```
### 使用 dd 命令生成密码
我们甚至可以使用 `/dev/urandom` 设备配合 [dd 命令](https://kerneltalks.com/commands/learn-dd-command-with-examples/) 来获取随机字符串。
```
root@kerneltalks# dd if=/dev/urandom bs=1 count=15|base64 -w 0
15+0 records in
15+0 records out
15 bytes (15 B) copied, 5.5484e-05 s, 270 kB/s
QMsbe2XbrqAc2NmXp8D0
```
我们需要将结果通过 `base64` 编码使它能被人类可读。你可以使用数值来获取想要的长度。想要获得更简洁的输出的话，可以将“标准错误输出”重定向到 `/dev/null`。简洁输出的命令是：
```
root@kerneltalks # dd if=/dev/urandom bs=1 count=15 2>/dev/null|base64 -w 0
F8c3a4joS+a3BdPN9C++
```
### 使用 md5sum 生成密码
另一种获取可用作密码的随机字符串的方法是计算 MD5 校验值！校验值看起来确实像是随机字符串组合在一起，我们可以用作密码。确保你的计算源是个变量，这样的话每次运行命令时生成的校验值都不一样。比如 `date` ！[date 命令](https://kerneltalks.com/commands/date-time-management-using-timedatectl-command/) 总会生成不同的输出。
```
root@kerneltalks # date |md5sum
4d8ce5c42073c7e9ca4aeffd3d157102 -
```
在这里我们将 `date` 命令的输出通过 `md5sum` 得到了校验和！你也可以用 [cut 命令](https://kerneltalks.com/linux/cut-command-examples/) 裁剪你需要的长度。
### 使用 pwgen 生成密码
`pwgen` 软件包在类似 [EPEL 软件仓库](https://kerneltalks.com/package/how-to-install-epel-repository/)（LCTT 译注：企业版 Linux 附加软件包）中。`pwgen` 更专注于生成可发音的密码，但它们不在英语词典中，也不是纯英文的。标准发行版仓库中可能并不包含这个工具。安装这个软件包然后运行 `pwgen` 命令行。Boom !
```
root@kerneltalks # pwgen
thu8Iox7 ahDeeQu8 Eexoh0ai oD8oozie ooPaeD9t meeNeiW2 Eip6ieph Ooh1tiet
cootad7O Gohci0vo wah9Thoh Ohh3Ziur Ao1thoma ojoo6aeW Oochai4v ialaiLo5
aic2OaDa iexieQu8 Aesoh4Ie Eixou9ph ShiKoh0i uThohth7 taaN3fuu Iege0aeZ
cah3zaiW Eephei0m AhTh8guo xah1Shoo uh8Iengo aifeev4E zoo4ohHa fieDei6c
aorieP7k ahna9AKe uveeX7Hi Ohji5pho AigheV7u Akee9fae aeWeiW4a tiex8Oht
```
你的终端会呈现出一个密码列表！你还想要什么呢？好吧。你还想再仔细探索的话， `pwgen` 还有很多自定义选项，这些都可以在 man 手册里查阅到。
### 使用 gpg 工具生成密码
GPG 是一个遵循 OpenPGP 标准的加密及签名工具。大部分 gpg 工具都预先被安装好了（至少在我的 RHEL7 上是这样）。但如果没有的话你可以寻找 `gpg` 或 `gpg2` 软件包并[安装](https://kerneltalks.com/tools/package-installation-linux-yum-apt/)它。
使用下面的命令以从 gpg 工具生成密码。
```
root@kerneltalks # gpg --gen-random --armor 1 12
mL8i+PKZ3IuN6a7a
```
这里我们传了生成随机字节序列选项（`--gen-random`），质量为 1（第一个参数），次数 12 （第二个参数）。选项 `--armor` 保证以 `base64` 编码输出。
### 使用 xkcdpass 生成密码
著名的极客幽默网站 [xkcd](https://xkcd.com/)，发表了一篇非常有趣的文章，是关于好记但又复杂的密码的。你可以在[这里](https://xkcd.com/936/)阅读。所以 `xkcdpass` 工具就受这篇文章启发，做了这样的工作！这是一个 Python 软件包，可以在[这里](https://pypi.python.org/pypi/xkcdpass/)的 Python 的官网上找到它。
所有的安装使用说明都在上面那个页面提及了。这里是安装步骤和我的测试 RHEL 服务器的输出，以供参考。
```
root@kerneltalks # wget https://pypi.python.org/packages/b4/d7/3253bd2964390e034cf0bba227db96d94de361454530dc056d8c1c096abc/xkcdpass-1.14.3.tar.gz#md5=5f15d52f1d36207b07391f7a25c7965f
--2018-01-23 19:09:17-- https://pypi.python.org/packages/b4/d7/3253bd2964390e034cf0bba227db96d94de361454530dc056d8c1c096abc/xkcdpass-1.14.3.tar.gz
Resolving pypi.python.org (pypi.python.org)... 151.101.32.223, 2a04:4e42:8::223
Connecting to pypi.python.org (pypi.python.org)|151.101.32.223|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 871848 (851K) [binary/octet-stream]
Saving to: ‘xkcdpass-1.14.3.tar.gz’
100%[==============================================================================================================================>] 871,848 --.-K/s in 0.01s
2018-01-23 19:09:17 (63.9 MB/s) - ‘xkcdpass-1.14.3.tar.gz’ saved [871848/871848]
root@kerneltalks # tar -xvf xkcdpass-1.14.3.tar.gz
xkcdpass-1.14.3/
xkcdpass-1.14.3/examples/
xkcdpass-1.14.3/examples/example_import.py
xkcdpass-1.14.3/examples/example_json.py
xkcdpass-1.14.3/examples/example_postprocess.py
xkcdpass-1.14.3/LICENSE.BSD
xkcdpass-1.14.3/MANIFEST.in
xkcdpass-1.14.3/PKG-INFO
xkcdpass-1.14.3/README.rst
xkcdpass-1.14.3/setup.cfg
xkcdpass-1.14.3/setup.py
xkcdpass-1.14.3/tests/
xkcdpass-1.14.3/tests/test_list.txt
xkcdpass-1.14.3/tests/test_xkcdpass.py
xkcdpass-1.14.3/tests/__init__.py
xkcdpass-1.14.3/xkcdpass/
xkcdpass-1.14.3/xkcdpass/static/
xkcdpass-1.14.3/xkcdpass/static/eff-long
xkcdpass-1.14.3/xkcdpass/static/eff-short
xkcdpass-1.14.3/xkcdpass/static/eff-special
xkcdpass-1.14.3/xkcdpass/static/fin-kotus
xkcdpass-1.14.3/xkcdpass/static/ita-wiki
xkcdpass-1.14.3/xkcdpass/static/legacy
xkcdpass-1.14.3/xkcdpass/static/spa-mich
xkcdpass-1.14.3/xkcdpass/xkcd_password.py
xkcdpass-1.14.3/xkcdpass/__init__.py
xkcdpass-1.14.3/xkcdpass.1
xkcdpass-1.14.3/xkcdpass.egg-info/
xkcdpass-1.14.3/xkcdpass.egg-info/dependency_links.txt
xkcdpass-1.14.3/xkcdpass.egg-info/entry_points.txt
xkcdpass-1.14.3/xkcdpass.egg-info/not-zip-safe
xkcdpass-1.14.3/xkcdpass.egg-info/PKG-INFO
xkcdpass-1.14.3/xkcdpass.egg-info/SOURCES.txt
xkcdpass-1.14.3/xkcdpass.egg-info/top_level.txt
root@kerneltalks # cd xkcdpass-1.14.3
root@kerneltalks # python setup.py install
running install
running bdist_egg
running egg_info
writing xkcdpass.egg-info/PKG-INFO
writing top-level names to xkcdpass.egg-info/top_level.txt
writing dependency_links to xkcdpass.egg-info/dependency_links.txt
writing entry points to xkcdpass.egg-info/entry_points.txt
reading manifest file 'xkcdpass.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
writing manifest file 'xkcdpass.egg-info/SOURCES.txt'
installing library code to build/bdist.linux-x86_64/egg
running install_lib
running build_py
creating build
creating build/lib
creating build/lib/xkcdpass
copying xkcdpass/xkcd_password.py -> build/lib/xkcdpass
copying xkcdpass/__init__.py -> build/lib/xkcdpass
creating build/lib/xkcdpass/static
copying xkcdpass/static/eff-long -> build/lib/xkcdpass/static
copying xkcdpass/static/eff-short -> build/lib/xkcdpass/static
copying xkcdpass/static/eff-special -> build/lib/xkcdpass/static
copying xkcdpass/static/fin-kotus -> build/lib/xkcdpass/static
copying xkcdpass/static/ita-wiki -> build/lib/xkcdpass/static
copying xkcdpass/static/legacy -> build/lib/xkcdpass/static
copying xkcdpass/static/spa-mich -> build/lib/xkcdpass/static
creating build/bdist.linux-x86_64
creating build/bdist.linux-x86_64/egg
creating build/bdist.linux-x86_64/egg/xkcdpass
copying build/lib/xkcdpass/xkcd_password.py -> build/bdist.linux-x86_64/egg/xkcdpass
copying build/lib/xkcdpass/__init__.py -> build/bdist.linux-x86_64/egg/xkcdpass
creating build/bdist.linux-x86_64/egg/xkcdpass/static
copying build/lib/xkcdpass/static/eff-long -> build/bdist.linux-x86_64/egg/xkcdpass/static
copying build/lib/xkcdpass/static/eff-short -> build/bdist.linux-x86_64/egg/xkcdpass/static
copying build/lib/xkcdpass/static/eff-special -> build/bdist.linux-x86_64/egg/xkcdpass/static
copying build/lib/xkcdpass/static/fin-kotus -> build/bdist.linux-x86_64/egg/xkcdpass/static
copying build/lib/xkcdpass/static/ita-wiki -> build/bdist.linux-x86_64/egg/xkcdpass/static
copying build/lib/xkcdpass/static/legacy -> build/bdist.linux-x86_64/egg/xkcdpass/static
copying build/lib/xkcdpass/static/spa-mich -> build/bdist.linux-x86_64/egg/xkcdpass/static
byte-compiling build/bdist.linux-x86_64/egg/xkcdpass/xkcd_password.py to xkcd_password.pyc
byte-compiling build/bdist.linux-x86_64/egg/xkcdpass/__init__.py to __init__.pyc
creating build/bdist.linux-x86_64/egg/EGG-INFO
copying xkcdpass.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO
copying xkcdpass.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying xkcdpass.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying xkcdpass.egg-info/entry_points.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying xkcdpass.egg-info/not-zip-safe -> build/bdist.linux-x86_64/egg/EGG-INFO
copying xkcdpass.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
creating dist
creating 'dist/xkcdpass-1.14.3-py2.7.egg' and adding 'build/bdist.linux-x86_64/egg' to it
removing 'build/bdist.linux-x86_64/egg' (and everything under it)
Processing xkcdpass-1.14.3-py2.7.egg
creating /usr/lib/python2.7/site-packages/xkcdpass-1.14.3-py2.7.egg
Extracting xkcdpass-1.14.3-py2.7.egg to /usr/lib/python2.7/site-packages
Adding xkcdpass 1.14.3 to easy-install.pth file
Installing xkcdpass script to /usr/bin
Installed /usr/lib/python2.7/site-packages/xkcdpass-1.14.3-py2.7.egg
Processing dependencies for xkcdpass==1.14.3
Finished processing dependencies for xkcdpass==1.14.3
```
现在运行 `xkcdpass` 命令，将会随机给出你几个像下面这样的字典单词：
```
root@kerneltalks # xkcdpass
broadside unpadded osmosis statistic cosmetics lugged
```
你可以用这些单词作为其他命令，比如 `md5sum` 的输入，来获取随机密码（就像下面这样），甚至你也可以用每个单词的第 N 个字母来生成你的密码！
```
root@kerneltalks # xkcdpass |md5sum
45f2ec9b3ca980c7afbd100268c74819 -
root@kerneltalks # xkcdpass |md5sum
ad79546e8350744845c001d8836f2ff2 -
```
或者你甚至可以把所有单词串在一起作为一个超长的密码，不仅非常好记，也不容易被电脑程序攻破。
Linux 上还有像 [Diceware](http://world.std.com/%7Ereinhold/diceware.html)、 [KeePassX](https://www.keepassx.org/)、 [Revelation](https://packages.debian.org/sid/gnome/revelation)、 [PasswordMaker](https://passwordmaker.org/) 这样的工具，也可以考虑用来生成强随机密码。
---
via: <https://kerneltalks.com/tips-tricks/8-ways-to-generate-random-password-in-linux/>
作者：[kerneltalks](https://kerneltalks.com) 译者：[heart4lor](https://github.com/heart4lor) 校对：[Locez](https://github.com/locez)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
手把手指导您使用 Git
|
Kedar Vijay Kulkarni
|
https://opensource.com/article/18/1/step-step-guide-git
|
如果您从未使用过 Git，甚至可能从未听说过它。莫慌张，只需要一步步地跟着这篇入门教程，很快您就会在 GitHub 上拥有一个全新的 Git 仓库。
|
/data/attachment/album/201802/07/095020f7a0abz7xpp0u328.png.thumb.jpg
|
/data/attachment/album/201802/07/095020f7a0abz7xpp0u328.png
| true | false | true |
CYLeft
| false |
[
"Git",
"GitHub"
] |
技术
|
{
"viewnum": 7921,
"commentnum": 5,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "112.10.180.155",
"message": "谢谢您的翻译！",
"username": "来自浙江杭州的 Chrome 71.0|Windows 10 用户",
"date": "2018-12-27T22:35:34"
},
{
"postip": "123.115.203.45",
"message": "写的不错",
"username": "来自北京的 Chrome 100.0|Windows 10 用户",
"date": "2022-04-20T14:45:38"
},
{
"postip": "123.115.203.45",
"message": "写的不错",
"username": "来自北京的 Chrome 100.0|Windows 10 用户",
"date": "2022-04-20T14:45:40"
},
{
"postip": "123.115.203.45",
"message": "写的不错",
"username": "来自北京的 Chrome 100.0|Windows 10 用户",
"date": "2022-04-20T14:45:41"
},
{
"postip": "123.115.203.45",
"message": "写的不错",
"username": "来自北京的 Chrome 100.0|Windows 10 用户",
"date": "2022-04-20T14:45:41"
}
] |
[
{
"raid": 9517,
"displayorder": 0
}
] |
如果您从未使用过 Git，甚至可能从未听说过它。莫慌张，只需要一步步地跟着这篇入门教程，很快您就会在 GitHub 上拥有一个全新的 Git 仓库。
| 2018-02-07T09:50:15 | 2018-02-07T09:50:15 | 9,319 |
/article-9319-1.html
|
如果您从未使用过 [Git](https://opensource.com/resources/what-is-git)，甚至可能从未听说过它。莫慌张，只需要一步步地跟着这篇入门教程，很快您就会在 [GitHub](https://opensource.com/life/15/11/short-introduction-github) 上拥有一个全新的 Git 仓库。
在开始之前，让我们先理清一个常见的误解：Git 并不是 GitHub。Git 是一套版本控制系统（或者说是一款软件），能够协助您跟踪计算机程序和文件在任何时间的更改。它同样允许您在程序、代码和文件操作上与同事协作。GitHub 以及类似服务（包括 GitLab 和 BitBucket）都属于部署了 Git 程序的网站，能够托管您的代码。
### 步骤 1：申请一个 GitHub 账户
在 [GitHub.com](https://github.com/) 网站上（免费）创建一个账户是最简单的方式。
选择一个用户名（比如说，octocat123），输入您的邮箱地址和密码，然后点击 **Sign up for GitHub**。进入之后，您将看到下方插图的界面：
### 步骤 2：创建一个新的仓库
一个仓库（ repository），类似于能储存物品的场所或是容器；在这里，我们创建仓库存储代码。在 `+` 符号（在插图的右上角，我已经选中它了） 的下拉菜单中选择 **New Repository**。
给您的仓库命名（比如说，Demo）然后点击 **Create Repository**。无需考虑本页面的其他选项。
恭喜！您已经在 GitHub.com 中建立了您的第一个仓库。
### 步骤 3: 创建文件
当仓库创建完毕后，界面将和下方一致：
不必惊慌，它比看上去简单。跟紧步骤。忽略其他内容，注意截图上的 “...or create a new repository on the command line,”。
在您的计算机中打开终端。
键入 `git` 然后回车。如果命令行显示 `bash: git: command not found`，在您的操作系统或发行版 [安装 Git](https://www.linuxbabe.com/linux-server/install-git-verion-control-on-linux-debianubuntufedoraarchlinux#crt-2) 命令。键入 `git` 并回车检查是否成功安装；如果安装成功，您将看见大量关于使用该命令的说明信息。
在终端内输入：
```
mkdir Demo
```
这个命令将会创建一个名为 Demo 的目录（文件夹）。
如下命令将会切换终端目录，跳转到 Demo 目录：
```
cd Demo
```
然后输入：
```
echo "#Demo" >> README.md
```
创建一个名为 `README.md` 的文件，并写入 `#Demo`。检查文件是否创建成功，请输入：
```
cat README.md
```
这将会为您显示 `README.md` 文件的内容，如果文件创建成功，您的终端会有如下显示：
使用 Git 程序告诉您的电脑，Demo 是一个被 Git 管理的目录，请输入：
```
git init
```
然后，告诉 Git 程序您关心的文件并且想在此刻起跟踪它的任何改变，请输入：
```
git add README.md
```
### 步骤 4：创建一次提交
目前为止，您已经创建了一个文件，并且已经通知了 Git，现在，是时候创建一次<ruby> 提交 <rt> commit </rt></ruby>了。提交可以看作是一个里程碑。每当完成一些工作之时，您都可以创建一次提交，保存文件当前版本，这样一来，您可以返回之前的版本，并且查看那时候的文件内容。无论何时您修改了文件，都可以对文件创建一个上一次的不一样的新版本。
创建一次提交，请输入：
```
git commit -m "first commit"
```
就是这样！刚才您创建了包含一条注释为 “first commit” 的 Git 提交。每次提交，您都必须编辑注释信息；它不仅能协助您识别提交，而且能让您理解此时您对文件做了什么修改。这样到了明天，如果您在文件中添加新的代码，您可以写一句提交信息：“添加了新的代码”，然后当您一个月后回来查看提交记录或者 Git 日志（即提交列表），您还能知道当时的您在文件夹里做了什么。
### 步骤 5: 将您的计算机与 GitHub 仓库相连接
现在，是时候用如下命令将您的计算机连接到 GitHub 仓库了：
```
git remote add origin https://github.com/<your_username>/Demo.git
```
让我们一步步的分析这行命令。我们通知 Git 去添加一个叫做 `origin` （起源）的，拥有地址为 `https://github.com/<your_username>/Demo.git`（它也是您的仓库的 GitHub 地址） 的 `remote` （远程仓库）。当您提交代码时，这允许您在 GitHub.com 和 Git 仓库交互时使用 `origin` 这个名称而不是完整的 Git 地址。为什么叫做 `origin`？当然，您可以叫点别的，只要您喜欢（惯例而已）。
现在，我们已经将本地 Demo 仓库副本连接到了其在 GitHub.com 远程副本上。您的终端看起来如下：
此刻我们已经连接到远程仓库，可以推送我们的代码 到 GitHub.com（例如上传 `README.md` 文件）。
执行完毕后，您的终端会显示如下信息：
然后，如果您访问 `https://github.com/<your_username>/Demo`，您会看到截图内显示的情况：
就是这么回事！您已经创建了您的第一个 GitHub 仓库，连接到了您的电脑，并且从你的计算机推送（或者称：上传）一个文件到 GitHub.com 名叫 Demo 的远程仓库上了。下一次，我将编写关于 Git 复制（从 GitHub 上下载文件到你的计算机上）、添加新文件、修改现存文件、推送（上传）文件到 GitHub。
---
via: <https://opensource.com/article/18/1/step-step-guide-git>
作者：[Kedar Vijay Kulkarni](https://opensource.com/users/kkulkarn) 译者：[CYLeft](https://github.com/CYLeft) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 终端下的多媒体应用
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2018/1/multimedia-apps-linux-console
|
Linux 终端是支持多媒体的，所以你可以在终端里听音乐，看电影，看图片，甚至是阅读 PDF。
|
/data/attachment/album/201802/07/123559ud6bj12jkjjg2kks.jpg.thumb.jpg
|
/data/attachment/album/201802/07/123559ud6bj12jkjjg2kks.jpg
| true | false | true |
Yinr
| false |
[
"终端",
"多媒体"
] |
分享
|
{
"viewnum": 8420,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux 终端是支持多媒体的，所以你可以在终端里听音乐，看电影，看图片，甚至是阅读 PDF。
| 2018-02-07T12:35:55 | 2018-02-07T12:35:55 | 9,320 |
/article-9320-1.html
|
>
> Linux 终端是支持多媒体的，所以你可以在终端里听音乐，看电影，看图片，甚至是阅读 PDF。
>
>
>
在我的上一篇文章里，我们了解到 Linux 终端是可以支持多媒体的。是的，这是真的！你可以使用 Mplayer、fbi 和 fbgs 来实现不打开 X 会话就听音乐、看电影、看照片，甚至阅读 PDF。此外，你还可以通过 CMatrix 来体验黑客帝国（Matrix）风格的屏幕保护。
不过你可能需要对系统进行一些修改才能达到前面这些目的。下文的操作都是在 Ubuntu 16.04 上进行的。
### MPlayer
你可能会比较熟悉功能丰富的 MPlayer。它支持几乎所有格式的视频与音频，并且能在绝大部分现有的平台上运行，像 Linux、Android、Windows、Mac、Kindle、OS/2 甚至是 AmigaOS。不过，要在你的终端运行 MPlayer 可能需要多做一点工作，这些工作与你使用的 Linux 发行版有关。来，我们先试着播放一个视频：
```
$ mplayer [视频文件名]
```
如果上面的命令正常执行了，那么很好，接下来你可以把时间放在了解 MPlayer 的常用选项上了，譬如设定视频大小等。但是，有些 Linux 发行版在对<ruby> 帧缓冲 <rt> framebuffer </rt></ruby>的处理方式上与早期的不同，那么你就需要进行一些额外的设置才能让其正常工作了。下面是在最近的 Ubuntu 发行版上需要做的一些操作。
首先，将你自己添加到 `video` 用户组。
其次，确认 `/etc/modprobe.d/blacklist-framebuffer.conf` 文件中包含这样一行：`#blacklist vesafb`。这一行应该默认被注释掉了，如果不是的话，那就手动把它注释掉。此外的其他模块行需要确认没有被注释，这样设置才能保证其他那些模块不会被载入。注：如果你想要更深入的利用<ruby> 帧缓冲 <rt> framebuffer </rt></ruby>，这些针对你的显卡的模块可以使你获得更好的性能。
然后，在 `/etc/initramfs-tools/modules` 的结尾增加两个模块：`vesafb` 和 `fbcon`，并且更新 iniramfs 镜像：
```
$ sudo nano /etc/initramfs-tools/modules
# List of modules that you want to include in your initramfs.
# They will be loaded at boot time in the order below.
fbcon
vesafb
$ sudo update-initramfs -u
```
[fbcon](https://www.mjmwired.net/kernel/Documentation/fb/fbcon.txt) 是 Linux <ruby> 帧缓冲 <rt> framebuffer </rt></ruby>终端，它运行在<ruby> 帧缓冲 <rt> framebuffer </rt></ruby>之上并为其增加图形功能。而它需要一个<ruby> 帧缓冲 <rt> framebuffer </rt></ruby>设备，这则是由 `vesafb` 模块来提供的。
接下来，你需要修改你的 GRUB2 配置。在 `/etc/default/grub` 中你将会看到类似下面的一行：
```
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"
```
它也可能还会有一些别的参数，不用管它，在其后加上 `vga=789`：
```
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash vga=789"
```
重启之后进入你的终端（`Ctrl+Alt+F1`）（LCTT 译注：在某些发行版中 `Ctrl+Alt+F1` 默认为图形界面，可以尝试 `Ctrl+Alt+F2`），然后就可以尝试播放一个视频了。下面的命令指定了 `fbdev2` 为视频输出设备，虽然我还没弄明白如何去选择用哪个输入设备，但是我用它成功过。默认的视频大小是 320x240，在此我给缩放到了 960：
```
$ mplayer -vo fbdev2 -vf scale -zoom -xy 960 AlienSong_mp4.mov
```
来看图 1。粗糙的画面是由于我原视频的质量不高，而不是 MPlayer 的显示问题。
MPlayer 可以播放 CD、DVD 以及网络视频流，并且还有一系列的回放选项，这些将作为作业留给大家自己去发现。
### fbi 图片查看器
`fbi` 是一个帧缓冲图片查看器。在大部分的 Linux 发行版中，它被包含在 [fbida](https://www.kraxel.org/blog/linux/fbida/) 包里。它原生支持一些常见的图片格式，而如果你安装了 `convert`（来自于 Image Magick），那么它还能借此打开一些其他格式。最简单的用法是用来查看一个图片文件：
```
$ fbi 文件名
```
你可以使用方向键来在大图片中移动视野，使用 `+` 和 `-` 来缩放，或者使用 `r` 或 `l` 来向右或向左旋转 90 度。`Escape` 键则可以关闭查看的图片。此外，你还可以给 `fbi` 一个文件列表来实现幻灯播放：
```
$ fbi --list 文件列表.txt
```
`fbi` 还支持自动缩放。还可以使用 `-a` 选项来控制缩放比例。`--autoup` 和 `--autodown` 则是用于告知 `fbi` 只进行放大或者缩小。要调整图片切换时淡入淡出的时间则可以使用 `--blend [时间]` 来指定一个以毫秒为单位的时间长度。使用 `k` 和 `j` 键则可以切换文件列表中的上一张或下一张图片。
`fbi` 还提供了命令来为你浏览过的文件创建文件列表，或者将你的命令导出到文件中，以及一系列其它很棒的选项。你可以通过 `man fbi` 来查阅完整的选项列表。
### CMatrix 终端屏保
<ruby> 黑客帝国 <rt> The Matrix </rt></ruby>屏保仍然是我非常喜欢的屏保之一（如图 2），仅次于<ruby> 弹跳牛 <rt> bouncing cow </rt></ruby>。[CMatrix](http://www.asty.org/cmatrix/) 可以在终端运行。要运行它只需输入 `cmatrix`，然后可以用 `Ctrl+C` 来停止运行。执行 `cmatrix -s` 则会启动屏保模式，这样的话，按任意键都会直接退出。`-C` 参数可以设定颜色，譬如绿色（`green`）、红色（`red`）、蓝色（`blue`）、黄色（`yellow`）、白色（`white`）、紫色（`magenta`）、青色（`cyan`）或者黑色（`black`）。
CMatrix 还支持异步按键，这意味着你可以在它运行的时候改变设置选项。
`-B` 设置全部使用粗体，而 `-b`（LCTT 译注：原文误为 `-B`）则可以设置部分字体加粗。
### fbgs PDF 阅读器
看起来，PDF 文档是普遍流行且无法避免的，而且 PDF 比它之前的功能好了很多，譬如超链接、复制粘贴以及更好的文本搜索功能等。`fbgs` 是 `fbida` 包中提供的一个 PDF 阅读器。它可以设置页面大小、分辨率、指定页码以及绝大部分 `fbi` 所提供的选项，当然除了一些在 `man fbgs` 中列举出来的不可用选项。我主要用到的选项是页面大小，你可以选择 `-l`、`xl` 或者 `xxl`：
```
$ fbgs -xl annoyingpdf.pdf
```
欢迎通过 Linux 基金会与 edX 免费提供的[“Linux 入门”](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)课程学习更多 Linux 知识。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/1/multimedia-apps-linux-console>
作者：[Carla Schroder](https://www.linux.com/users/cschroder) 译者：[Yinr](https://github.com/Yinr) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
8 个你不一定全都了解的 rm 命令示例
|
Himanshu Arora
|
https://www.howtoforge.com/linux-rm-command/
|
删除文件和复制/移动文件一样，都是很基础的操作。在 Linux 中，有一个专门的命令 rm，可用于完成所有删除相关的操作。在本文中，我们将用些容易理解的例子来讨论这个命令的基本使用。
|
/data/attachment/album/201802/07/203619n9bb3pdwmmpqxwfw.jpg.thumb.jpg
|
/data/attachment/album/201802/07/203619n9bb3pdwmmpqxwfw.jpg
| true | false | true |
yizhuoyan
| false |
[
"rm",
"删除"
] |
技术
|
{
"viewnum": 84133,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
删除文件和复制/移动文件一样，都是很基础的操作。在 Linux 中，有一个专门的命令 rm，可用于完成所有删除相关的操作。在本文中，我们将用些容易理解的例子来讨论这个命令的基本使用。
| 2018-02-07T20:36:47 | 2018-02-07T20:36:47 | 9,321 |
/article-9321-1.html
|
删除文件和复制/移动文件一样，都是很基础的操作。在 Linux 中，有一个专门的命令 `rm`，可用于完成所有删除相关的操作。在本文中，我们将用些容易理解的例子来讨论这个命令的基本使用。
但在我们开始前，值得指出的是本文所有示例都在 Ubuntu 16.04 LTS 中测试过。
### Linux rm 命令概述
通俗的讲，我们可以认为 `rm` 命令是用于删除文件和目录的。下面是此命令的语法：
```
rm [选项]... [要删除的文件/目录]...
```
下面是命令使用说明：
>
> GUN 版本 `rm` 命令的手册文档。`rm` 删除每个指定的文件，默认情况下不删除目录。
>
>
> 当删除的文件超过三个或者提供了选项 `-r`、`-R` 或 `--recursive`（LCTT 译注：表示递归删除目录中的文件）时，如果给出 `-I`（LCTT 译注：大写的 I）或 `--interactive=once` 选项（LCTT 译注：表示开启交互一次），则 `rm` 命令会提示用户是否继续整个删除操作，如果用户回应不是确认（LCTT 译注：即没有回复 `y`），则整个命令立刻终止。
>
>
> 另外，如果被删除文件是不可写的，标准输入是终端，这时如果没有提供 `-f` 或 `--force` 选项，或者提供了 `-i`（LCTT 译注：小写的 i） 或 `--interactive=always` 选项，`rm` 会提示用户是否要删除此文件，如果用户回应不是确认（LCTT 译注：即没有回复 `y`），则跳过此文件。
>
>
>
下面这些问答式例子会让你更好的理解这个命令的使用。
### Q1. 如何用 rm 命令删除文件？
这是非常简单和直观的。你只需要把文件名（如果文件不是在当前目录中，则还需要添加文件路径）传入给 `rm` 命令即可。
（LCTT 译注：可以用空格隔开传入多个文件名称。）
```
rm 文件1 文件2 ...
```
如：
```
rm testfile.txt
```
[](https://www.howtoforge.com/images/command-tutorial/big/rm-basic-usage.png)
### Q2. 如何用 `rm` 命令删除目录?
如果你试图删除一个目录，你需要提供 `-r` 选项。否则 `rm` 会抛出一个错误告诉你正试图删除一个目录。
（LCTT 译注：`-r` 表示递归地删除目录下的所有文件和目录。）
```
rm -r [目录名称]
```
如：
```
rm -r testdir
```
[](https://www.howtoforge.com/images/command-tutorial/big/rm-r.png)
### Q3. 如何让删除操作前有确认提示?
如果你希望在每个删除操作完成前都有确认提示，可以使用 `-i` 选项。
```
rm -i [文件/目录]
```
比如，你想要删除一个目录“testdir”，但需要每个删除操作都有确认提示，你可以这么做：
```
rm -r -i testdir
```
[](https://www.howtoforge.com/images/command-tutorial/big/rm-i-option.png)
### Q4. 如何让 rm 忽略不存在的文件或目录?
如果你删除一个不存在的文件或目录时，`rm` 命令会抛出一个错误，如：
[](https://www.howtoforge.com/images/command-tutorial/big/rm-non-ext-error.png)
然而，如果你愿意，你可以使用 `-f` 选项（LCTT 译注：即 “force”）让此次操作强制执行，忽略错误提示。
```
rm -f [文件...]
```
[](https://www.howtoforge.com/images/command-tutorial/big/rm-f-option.png)
### Q5. 如何让 rm 仅在某些场景下确认删除？
选项 `-I`，可保证在删除超过 3 个文件时或递归删除时（LCTT 译注： 如删除目录）仅提示一次确认。
比如，下面的截图展示了 `-I` 选项的作用——当两个文件被删除时没有提示，当超过 3 个文件时会有提示。
[](https://www.howtoforge.com/images/command-tutorial/big/rm-I-option.png)
### Q6. 当删除根目录是 rm 是如何工作的?
当然，删除根目录（`/`）是 Linux 用户最不想要的操作。这也就是为什么默认 `rm` 命令不支持在根目录上执行递归删除操作。（LCTT 译注：早期的 `rm` 命令并无此预防行为。）
[](https://www.howtoforge.com/images/command-tutorial/big/rm-root-default.png)
然而，如果你非得完成这个操作，你需要使用 `--no-preserve-root` 选项。当提供此选项，`rm` 就不会特殊处理根目录（`/`）了。
假如你想知道在哪些场景下 Linux 用户会删除他们的根目录，点击[这里](https://superuser.com/questions/742334/is-there-a-scenario-where-rm-rf-no-preserve-root-is-needed)。
### Q7. 如何让 rm 仅删除空目录？
假如你需要 `rm` 在删除目录时仅删除空目录，你可以使用 `-d` 选项。
```
rm -d [目录]
```
下面的截图展示 `-d` 选项的用途——仅空目录被删除了。
[](https://www.howtoforge.com/images/command-tutorial/big/rm-d-option.png)
### Q8. 如何让 rm 显示当前删除操作的详情?
如果你想 rm 显示当前操作完成时的详细情况，使用 `-v` 选项可以做到。
```
rm -v [文件/目录]
```
如：
[](https://www.howtoforge.com/images/command-tutorial/big/rm-v-option.png)
### 结论
考虑到 `rm` 命令提供的功能，可以说其是 Linux 中使用频率最高的命令之一了（就像 [cp](https://www.howtoforge.com/linux-cp-command/) 和 `mv` 一样）。在本文中，我们涉及到了其提供的几乎所有主要选项。`rm` 命令有些学习曲线，因此在你日常工作中开始使用此命令之前 你将需要花费些时间去练习它的选项。更多的信息，请点击此命令的 [man 手册页](https://linux.die.net/man/1/rm)。
---
via: <https://www.howtoforge.com/linux-rm-command/>
作者：[Himanshu Arora](https://www.howtoforge.com) 译者：[yizhuoyan](https://github.com/yizhuoyan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
MapSCII：在终端显示世界地图
|
Sk
|
https://www.ostechnix.com/mapscii-world-map-terminal/
|
我原以为它只不过是一个在 GitHub 上托管的项目而已，但是我错了！他们做的事令人印象深刻。我们可以使用我们的鼠标指针在世界地图的任何地方拖拽放大和缩小。
|
/data/attachment/album/201802/07/223442p37po74lby3uum6p.png.thumb.jpg
|
/data/attachment/album/201802/07/223442p37po74lby3uum6p.png
| true | false | true |
geekpi
| false |
[
"地图",
"终端"
] |
分享
|
{
"viewnum": 9014,
"commentnum": 0,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我原以为它只不过是一个在 GitHub 上托管的项目而已，但是我错了！他们做的事令人印象深刻。我们可以使用我们的鼠标指针在世界地图的任何地方拖拽放大和缩小。
| 2018-02-07T22:34:38 | 2018-02-07T22:34:38 | 9,322 |
/article-9322-1.html
|
我偶然发现了一个有趣的工具。在终端里的世界地图！是的，这太酷了。给 `MapSCII` 打 call，这是可在 xterm 兼容终端上渲染的布莱叶盲文和 ASCII 世界地图。它支持 GNU/Linux、Mac OS 和 Windows。我原以为它只不过是一个在 GitHub 上托管的项目而已，但是我错了！他们做的事令人印象深刻。我们可以使用我们的鼠标指针在世界地图的任何地方拖拽放大和缩小。其他显著的特性是：
* 发现任何特定地点周围的兴趣点
* 高度可定制的图层样式，支持 [Mapbox 样式](https://www.mapbox.com/mapbox-gl-style-spec/)
* 可连接到任何公共或私有的矢量贴片服务器
* 或者使用已经提供并已优化的基于 [OSM2VectorTiles](https://github.com/osm2vectortiles) 服务器
* 可以离线工作并发现本地的 [VectorTile](https://github.com/mapbox/vector-tile-spec)/[MBTiles](https://github.com/mapbox/mbtiles-spec)
* 兼容大多数 Linux 和 OSX 终端
* 高度优化算法的流畅体验
### 使用 MapSCII 在终端中显示世界地图
要打开地图，只需从终端运行以下命令：
```
telnet mapscii.me
```
这是我终端上的世界地图。
很酷，是吗？
要切换到布莱叶盲文视图，请按 `c`。
再次输入 `c` 切回以前的格式。
要滚动地图，请使用“向上”、“向下”、“向左”、“向右”箭头键。要放大/缩小位置，请使用 `a` 和 `z` 键。另外，你可以使用鼠标的滚轮进行放大或缩小。要退出地图，请按 `q`。
就像我已经说过的，不要认为这是一个简单的项目。点击地图上的任何位置，然后按 `a` 放大。
放大后，下面是一些示例截图。
我可以放大查看我的国家（印度）的州。
和州内的地区（Tamilnadu）：
甚至是地区内的镇 [Taluks](https://en.wikipedia.org/wiki/Tehsils_of_India)：
还有，我完成学业的地方：
即使它只是一个最小的城镇，MapSCII 也能准确地显示出来。 MapSCII 使用 [OpenStreetMap](https://www.openstreetmap.org/) 来收集数据。
### 在本地安装 MapSCII
喜欢它吗？很好！你可以安装在你自己的系统上。
确保你的系统上已经安装了 Node.js。如果还没有，请参阅以下链接。
* [在 Linux 上安装 NodeJS](https://www.ostechnix.com/install-node-js-linux/)
然后，运行以下命令来安装它。
```
sudo npm install -g mapscii
```
要启动 MapSCII，请运行：
```
mapscii
```
玩的开心！会有更好的东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/mapscii-world-map-terminal/>
作者：[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/) 荣誉推出
|
||
使用 Vi/Vim 编辑器：基础篇
|
Shusain
|
http://linuxtechlab.com/working-vi-editor-basics/
|
VI 编辑器是一个基于命令行的、功能强大的文本编辑器，最早为 Unix 系统开发，后来也被移植到许多的 Unix 和 Linux 发行版上。
|
/data/attachment/album/201802/08/191332xx3uhxhek3kk0g3f.png.thumb.jpg
|
/data/attachment/album/201802/08/191332xx3uhxhek3kk0g3f.png
| true | false | true |
ljgibbslf
| false |
[
"Vim",
"Vi"
] |
技术
|
{
"viewnum": 6825,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9274,
"displayorder": 0
}
] |
VI 编辑器是一个基于命令行的、功能强大的文本编辑器，最早为 Unix 系统开发，后来也被移植到许多的 Unix 和 Linux 发行版上。
| 2018-02-08T19:13:00 | 2018-02-08T19:13:00 | 9,323 |
/article-9323-1.html
|
VI 编辑器是一个基于命令行的、功能强大的文本编辑器，最早为 Unix 系统开发，后来也被移植到许多的 Unix 和 Linux 发行版上。
在 Linux 上还存在着另一个 VI 编辑器的高阶版本 —— VIM（也被称作 VI IMproved）。VIM 只是在 VI 已经很强的功能上添加了更多的功能，这些功能有：
* 支持更多 Linux 发行版，
* 支持多种编程语言，包括 python、c++、perl 等语言的代码块折叠，语法高亮，
* 支持通过多种网络协议，包括 http、ssh 等编辑文件，
* 支持编辑压缩归档中的文件，
* 支持分屏同时编辑多个文件。
接下来我们会讨论 VI/VIM 的命令以及选项。本文出于教学的目的，我们使用 VI 来举例，但所有的命令都可以被用于 VIM。首先我们先介绍 VI 编辑器的两种模式。
### 命令模式
命令模式下，我们可以执行保存文件、在 VI 内运行命令、复制/剪切/粘贴操作，以及查找/替换等任务。当我们处于插入模式时，我们可以按下 `Escape`（`Esc`）键返回命令模式
### 插入模式
在插入模式下，我们可以键入文件内容。在命令模式下按下 `i` 进入插入模式。
### 创建文件
我们可以通过下述命令建立一个文件（LCTT 译注：如果该文件存在，则编辑已有文件）：
```
$ vi filename
```
一旦该文件被创建或者打开，我们首先进入命令模式，我们需要进入输入模式以在文件中输入内容。我们通过前文已经大致上了解这两种模式。
### 退出 Vi
如果是想从插入模式中退出，我们首先需要按下 `Esc` 键进入命令模式。接下来我们可以根据不同的需要分别使用两种命令退出 Vi。
1. 不保存退出 - 在命令模式中输入 `:q!`
2. 保存并退出 - 在命令模式中输入 `:wq`
### 移动光标
下面我们来讨论下那些在命令模式中移动光标的命令和选项：
1. `k` 将光标上移一行
2. `j` 将光标下移一行
3. `h` 将光标左移一个字母
4. `l` 将光标右移一个字母
注意：如果你想通过一个命令上移或下移多行，或者左移、右移多个字母，你可以使用 `4k` 或者 `5l`，这两条命令会分别上移 4 行或者右移 5 个字母。
5. `0` 将光标移动到该行行首
6. `$` 将光标移动到该行行尾
7. `nG` 将光标移动到第 n 行
8. `G` 将光标移动到文件的最后一行
9. `{` 将光标移动到上一段
10. `}` 将光标移动到下一段
除此之外还有一些命令可以用于控制光标的移动，但上述列出的这些命令应该就能应付日常工作所需。
### 编辑文本
这部分会列出一些用于命令模式的命令，可以进入插入模式来编辑当前文件
1. `i` 在当前光标位置之前插入内容
2. `I` 在光标所在行的行首插入内容
3. `a` 在当前光标位置之后插入内容
4. `A` 在光标所在行的行尾插入内容
5. `o` 在当前光标所在行之后添加一行
6. `O` 在当前光标所在行之前添加一行
### 删除文本
以下的这些命令都只能在命令模式下使用，所以首先需要按下 `Esc` 进入命令模式，如果你正处于插入模式：
1. `dd` 删除光标所在的整行内容，可以在 `dd` 前增加数字，比如 `2dd` 可以删除从光标所在行开始的两行
2. `d$` 删除从光标所在位置直到行尾
3. `d^` 删除从光标所在位置直到行首
4. `dw` 删除从光标所在位置直到下一个词开始的所有内容
### 复制与黏贴
1. `yy` 复制当前行，在 `yy` 前添加数字可以复制多行
2. `p` 在光标之后粘贴复制行
3. `P` 在光标之前粘贴复制行
上述就是可以在 VI/VIM 编辑器上使用的一些基本命令。在未来的教程中还会继续教授一些更高级的命令。如果有任何疑问和建议，请在下方评论区留言。
---
via: <http://linuxtechlab.com/working-vi-editor-basics/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[ljgibbslf](https://github.com/ljgibbslf) 校对：[wxy](https://github.com/wxy)
本文由 LCTT 原创编译，Linux中国 荣誉推出
|
||
定制嵌入式 Linux 发行版
|
Michael J.hammel
|
http://www.linuxjournal.com/content/custom-embedded-linux-distributions
|
如何构建一个针对特定用途的交叉编译应用程序的自定义发行版呢？ 正如 Michael J. Hammel 在这里解释的那样，它并不像你想象的那么难。
|
/data/attachment/album/201802/08/230216ozk2ks8swoy77gkk.jpg.thumb.jpg
|
/data/attachment/album/201802/08/230216ozk2ks8swoy77gkk.jpg
| true | false | true |
qhwdw
| false |
[
"嵌入式",
"发行版"
] |
技术
|
{
"viewnum": 9945,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如何构建一个针对特定用途的交叉编译应用程序的自定义发行版呢？ 正如 Michael J. Hammel 在这里解释的那样，它并不像你想象的那么难。
| 2018-02-08T23:02:44 | 2018-02-08T23:02:44 | 9,324 |
/article-9324-1.html
|
便宜的物联网板的普及意味着它不仅会控制应用程序，还会控制整个软件平台。 那么，如何构建一个针对特定用途的交叉编译应用程序的自定义发行版呢？ 正如 Michael J. Hammel 在这里解释的那样，它并不像你想象的那么难。
### 为什么要定制？
以前，许多嵌入式项目都使用现成的发行版，然后出于种种原因，再将它们剥离到只剩下基本的必需的东西。首先，移除不需要的包以减少占用的存储空间。在启动时，嵌入式系统一般不需要大量的存储空间以及可用存储空间。在嵌入式系统运行时，可能从非易失性内存中拷贝大量的操作系统文件到内存中。第二，移除用不到的包可以降低可能的攻击面。如果你不需要它们就没有必要把这些可能有漏洞的包挂在上面。最后，移除用不到包可以降低发行版管理的开销。如果在包之间有依赖关系，意味着任何一个包请求从上游更新，那么它们都必须保持同步。那样可能就会出现验证噩梦。
然而，从一个现有的发行版中去移除包并不像说的那样容易。移除一个包可能会打破与其它包保持的各种依赖关系，以及可能在上游的发行版管理中改变依赖。另外，由于一些包原生集成在引导或者运行时进程中，它们并不能轻易地简单地移除。所有这些都是项目之外的平台的管理，并且有可能会导致意外的开发延迟。
一个流行的选择是使用上游发行版供应商提供的构建工具去构建一个定制的发行版。无论是 Gentoo 还是 Debian 都提供这种自下而上的构建方式。这些构建工具中最为流行的可能是 Debian 的 debootstrap 实用程序。它取出预构建的核心组件并允许用户去精选出它们感兴趣的包来构建用户自己的平台。但是，debootstrap 最初仅在 x86 平台上可用，虽然，现在有了 ARM（也有可能会有其它的平台）选项。debootstrap 和 Gentoo 的 catalyst 仍然需要从本地项目中将依赖管理移除。
一些人认为让别人去管理平台软件（像 Android 一样）要比自己亲自管理容易的多。但是，那些发行版都是多用途的，当你在一个轻量级的、资源有限的物联网设备上使用它时，你可能会再三考虑从你手中被拿走的任何资源。
### 系统引导的基石
一个定制的 Linux 发行版要求许多软件组件。其中第一个就是<ruby> 工具链 <rt> toolchain </rt></ruby>。工具链是用于编译软件的一套工具集。包括（但不限于）一个编译器、链接器、二进制操作工具以及标准的 C 库。工具链是为一个特定的目标硬件设备专门构建的。如果一个构建在 x86 系统上的工具链想要用于树莓派，那么这个工具链就被称为交叉编译工具链。当在内存和存储都十分有限的小型嵌入式设备上工作时，最好是使用一个交叉编译工具链。需要注意的是，即便是使用像 JavaScript 这样的需要运行在特定平台的脚本语言为特定用途编写的应用程序，也需要使用交叉编译工具链编译。
*图 1. 编译依赖和引导顺序*
交叉编译工具链用于为目标硬件构建软件组件。需要的第一个组件是<ruby> 引导加载程序 <rt> bootloader </rt></ruby>。当计算机主板加电之后，处理器（可能有差异，取决于设计）尝试去跳转到一个特定的内存位置去开始运行软件。那个内存位置就是保存引导加载程序的地方。硬件可能有内置的引导加载程序，它可能直接从它的存储位置或者可能在它运行前首先拷贝到内存中。也可能会有多个引导加载程序。例如，第一阶段的引导加载程序可能位于硬件的 NAND 或者 NOR 闪存中。它唯一的功能是设置硬件以便于执行第二阶段的引导加载程序——比如，存储在 SD 卡中的可以被加载并运行的引导加载程序。
引导加载程序能够从硬件中取得足够的信息，将 Linux 加载到内存中并跳转到正确的位置，将控制权有效地移交到 Linux。Linux 是一个操作系统。这意味着，在这种设计中，它除了监控硬件和向上层软件（也就是应用程序）提供服务外，它实际上什么都不做。[Linux 内核](https://www.kernel.org) 中通常是各种各样的固件块。那些预编译的软件对象，通常包含硬件平台使用的设备的专用 IP（知识资产）。当构建一个定制发行版时，在开始编译内核之前，它可能会要求获得一些 Linux 内核源代码树没有提供的必需的固件块。
应用程序保存在根文件系统中，这个根文件系统是通过编译构建的，它集合了各种软件库、工具、脚本以及配置文件。总的来说，它们都提供各种服务，比如，网络配置和 USB 设备挂载，这些都是将要运行的项目应用程序所需要的。
总的来说，一个完整的系统构建要求下列的组件：
1. 一个交叉编译工具链
2. 一个或多个引导加载程序
3. Linux 内核和相关的固件块
4. 一个包含库、工具以及实用程序的根文件系统
5. 定制的应用程序
### 使用适当的工具开始构建
交叉编译工具链的组件可以手工构建，但这是一个很复杂的过程。幸运的是，现有的工具可以很容易地完成这一过程。构建交叉编译工具链的最好工具可能是 [Crosstool-NG](http://crosstool-ng.github.io)，这个工具使用了与 Linux 内核相同的 kconfig 菜单系统来构建工具链的每个细节和方面。使用这个工具的关键是，为目标平台找到正确的配置项。配置项通常包含下列内容：
1. 目标架构，比如，是 ARM 还是 x86。
2. 字节顺序：小端字节顺序（一般情况下，Intel 采用这种顺序）还是大端字节顺序（一般情况下，ARM 或者其它的平台采用这种顺序）。
3. 编译器已知的 CPU 类型，比如，GCC 可以使用 `-mcpu` 或 `--with-cpu`。
4. 支持的浮点类型，如果有的话，比如，GCC 可以使用 `-mfpu` 或 `--with-fpu`。
5. <ruby> 二进制实用工具 <rt> binutils </rt></ruby>、C 库以及 C 编译器的特定版本信息。
*图 2. Crosstool-NG 配置菜单*
前四个一般情况下可以从处理器制造商的文档中获得。对于较新的处理器，它们可能不容易找到，但是，像树莓派或者 BeagleBoards（以及它们的后代和分支），你可以在像 [嵌入式 Linux Wiki](https://elinux.org/Main_Page) 这样的地方找到相关信息。
二进制实用工具、C 库、以及 C 编译器的版本，将与任何第三方提供的其它工具链分开。首先，它们中的每一个都有多个提供者。Linaro 为最新的处理器类型提供了最先进的版本，同时致力于将该支持合并到像 GNU C 库这样的上游项目中。尽管你可以使用各种提供者的工具，你可能依然想去使用现成的 GNU 工具链或者相同的 Linaro 版本。
在 Crosstool-NG 中的另外的重要选择是 Linux 内核的版本。这个选择将得到用于各种工具链组件的<ruby> 头文件 <rt> headers </rt></ruby>，但是它没有必要一定与你在目标硬件上将要引导的 Linux 内核相同。选择一个不比目标硬件的内核更新的 Linux 内核是很重要的。如果可能的话，尽量选择一个比目标硬件使用的内核更老的长周期支持（LTS）的内核。
对于大多数不熟悉构建定制发行版的开发者来说，工具链的构建是最为复杂的过程。幸运的是，大多数硬件平台的二进制工具链都可以想办法得到。如果构建一个定制的工具链有问题，可以在线搜索像 [嵌入式 Linux Wiki](https://elinux.org/Main_Page) 这样的地方去查找预构建工具链。
### 引导选项
在构建完工具链之后，接下来的工作是引导加载程序。引导加载程序用于设置硬件，以便于越来越复杂的软件能够使用这些硬件。第一阶段的引导加载程序通常由目标平台制造商提供，它通常被烧录到类似于 EEPROM 或者 NOR 闪存这类的在硬件上的存储中。第一阶段的引导加载程序将使设备从这里（比如，一个 SD 存储卡）开始引导。树莓派的引导加载程序就是这样的，它样做也就没有必要再去创建一个定制引导加载程序。
尽管如此，许多项目还是增加了第二阶段的引导加载程序，以便于去执行一个多样化的任务。在无需使用 Linux 内核或者像 plymouth 这样的用户空间工具的情况下提供一个启动动画，就是其中一个这样的任务。一个更常见的第二阶段引导加载程序的任务是去提供基于网络的引导或者使连接到 PCI 上的磁盘可用。在那种情况下，一个第三阶段的引导加载程序，比如 GRUB，可能才是让系统运行起来所必需的。
最重要的是，引导加载程序加载 Linux 内核并使它开始运行。如果第一阶段引导加载程序没有提供一个在启动时传递内核参数的机制，那么，在第二阶段的引导加载程序中就必须要提供。
有许多的开源引导加载程序可以使用。[U-Boot 项目](https://www.denx.de/wiki/U-Boot) 通常用于像树莓派这样的 ARM 平台。CoreBoot 一般是用于像 Chromebook 这样的 x86 平台。引导加载程序是特定于目标硬件专用的。引导加载程序的选择总体上取决于项目的需求以及目标硬件（可以去网络上在线搜索开源引导加载程序的列表）。
### 现在到了 Linux 登场的时候
引导加载程序将加载 Linux 内核到内存中，然后去运行它。Linux 就像一个扩展的引导加载程序：它进行进行硬件设置以及准备加载高级软件。内核的核心将设置和提供在应用程序和硬件之间共享使用的内存；提供任务管理器以允许多个应用程序同时运行；初始化没有被引导加载程序配置的或者是已经配置了但是没有完成的硬件组件；以及开启人机交互界面。内核也许不会配置为在自身完成这些工作，但是，它可以包含一个嵌入的、轻量级的文件系统，这类文件系统大家熟知的有 initramfs 或者 initrd，它们可以独立于内核而创建，用于去辅助设置硬件。
内核操作的另外的事情是去下载二进制块（通常称为固件）到硬件设备。固件是用特定格式预编译的对象文件，用于在引导加载程序或者内核不能访问的地方去初始化特定硬件。许多这种固件对象可以从 Linux 内核源仓库中获取，但是，还有很多其它的固件只能从特定的硬件供应商处获得。例如，经常由它们自己提供固件的设备有数字电视调谐器或者 WiFi 网卡等。
固件可以从 initramfs 中加载，也或者是在内核从根文件系统中启动 init 进程之后加载。但是，当你去创建一个定制的 Linux 发行版时，创建内核的过程常常就是获取各种固件的过程。
### 轻量级核心平台
Linux 内核做的最后一件事情是尝试去运行一个被称为 init 进程的专用程序。这个专用程序的名字可能是 init 或者 linuxrc 或者是由加载程序传递给内核的名字。init 进程保存在一个能够被内核访问的文件系统中。在 initramfs 这种情况下，这个文件系统保存在内存中（它可能是被内核自己放置到那里，也可能是被引导加载程序放置在那里）。但是，对于运行更复杂的应用程序，initramfs 通常并不够完整。因此需要另外一个文件系统，这就是众所周知的根文件系统。
*图 3. 构建 root 配置菜单*
initramfs 文件系统可以使用 Linux 内核自身构建，但是更常用的作法是，使用一个被称为 [BusyBox](https://busybox.net) 的项目去创建。BusyBox 组合许多 GNU 实用程序（比如，grep 或者 awk）到一个单个的二进制文件中，以便于减小文件系统自身的大小。BusyBox 通常用于去启动根文件系统的创建过程。
但是，BusyBox 是特意轻量化设计的。它并不打算提供目标平台所需要的所有工具，甚至提供的工具也是经过功能简化的。BusyBox 有一个“姊妹”项目叫做 [Buildroot](https://buildroot.org)，它可以用于去得到一个完整的根文件系统，提供了各种库、实用程序，以及脚本语言。像 Crosstool-NG 和 Linux 内核一样，BusyBox 和 Buildroot 也都允许使用 kconfig 菜单系统去定制配置。更重要的是，Buildroot 系统自动处理依赖关系，因此，选定的实用程序将会保证该程序所需要的软件也会被构建并安装到 root 文件系统。
Buildroot 可以用多种格式去生成一个根文件系统包。但是，需要重点注意的是，这个文件系统是被归档的。单个的实用程序和库并不是以 Debian 或者 RPM 格式打包进去的。使用 Buildroot 将生成一个根文件系统镜像，但是它的内容不是单独的包。即使如此，Buildroot 还是提供了对 opkg 和 rpm 包管理器的支持的。这意味着，虽然根文件系统自身并不支持包管理，但是，安装在根文件系统上的定制应用程序能够进行包管理。
### 交叉编译和脚本化
Buildroot 的其中一个特性是能够生成一个临时树。这个目录包含库和实用程序，它可以被用于去交叉编译其它应用程序。使用临时树和交叉编译工具链，使得在主机系统上而不是目标平台上对 Buildroot 之外的其它应用程序编译成为可能。使用 rpm 或者 opkg 包管理软件之后，这些应用程序可以在运行时使用包管理软件安装在目标平台的根文件系统上。
大多数定制系统的构建都是围绕着用脚本语言构建应用程序的想法去构建的。如果需要在目标平台上运行脚本，在 Buildroot 上有多种可用的选择，包括 Python、PHP、Lua 以及基于 Node.js 的 JavaScript。对于需要使用 OpenSSL 加密的应用程序也提供支持。
### 接下来做什么
Linux 内核和引导加载程序的编译过程与大多数应用程序是一样的。它们的构建系统被设计为去构建一个专用的软件位。Crosstool-NG 和 Buildroot 是<ruby> 元构建 <rt> metabuild </rt></ruby>。元构建是将一系列有自己构建系统的软件集合封装为一个构建系统。可靠的元构建包括 [Yocto](https://www.yoctoproject.org) 和 [OpenEmbedded](https://www.openembedded.org/wiki/Main_Page)。Buildroot 的好处是可以将更高级别的元构建进行轻松的封装，以便于将定制 Linux 发行版的构建过程自动化。这样做之后，将会打开 Buildroot 指向到项目专用的缓存仓库的选项。使用缓存仓库可以加速开发过程，并且可以在无需担心上游仓库变化的情况下提供构建快照。
一个实现高级构建系统的示例是 [PiBox](https://www.piboxproject.com)。PiBox 就是封装了在本文中讨论的各种工具的一个元构建。它的目的是围绕所有工具去增加一个通用的 GNU Make 目标架构，以生成一个核心平台，这个平台可以构建或分发其它软件。PiBox 媒体中心和 kiosk 项目是安装在核心平台之上的应用层软件的实现，目的是用于去产生一个构建平台。[Iron Man 项目](http://redmine.graphics-muse.org/projects/ironman/wiki/Getting_Started) 是为了家庭自动化的目的而扩展了这种应用程序，它集成了语音管理和物联网设备的管理。
但是，PiBox 如果没有这些核心的软件工具，它什么也做不了。并且，如果不去深入了解一个完整的定制发行版的构建过程，那么你将无法正确运行 PiBox。而且，如果没有 PiBox 开发团队对这个项目的长期奉献，也就没有 PiBox 项目，它完成了定制发行版构建中的大量任务。
---
via: <http://www.linuxjournal.com/content/custom-embedded-linux-distributions>
作者：[Michael J.Hammel](http://www.linuxjournal.com/user/1000879) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
优化 MySQL： 3 个简单的小调整
|
Rich Barrett
|
https://medium.com/@richb_/tuning-mysql-3-simple-tweaks-6356768f9b90
|
我并不期望成为一个专家级的 DBA，但是，在我优化 MySQL 时，我推崇 80/20 原则，明确说就是通过简单的调整一些配置，你可以压榨出高达 80% 的性能提升。尤其是在服务器资源越来越便宜的当下。
|
/data/attachment/album/201802/09/123814odzby7s38od8u48h.png.thumb.jpg
|
/data/attachment/album/201802/09/123814odzby7s38od8u48h.png
| true | false | true |
qhwdw
| false |
[
"MySQL",
"优化"
] |
技术
|
{
"viewnum": 5841,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我并不期望成为一个专家级的 DBA，但是，在我优化 MySQL 时，我推崇 80/20 原则，明确说就是通过简单的调整一些配置，你可以压榨出高达 80% 的性能提升。尤其是在服务器资源越来越便宜的当下。
| 2018-02-09T12:38:11 | 2018-02-09T12:38:11 | 9,325 |
/article-9325-1.html
|
如果你不改变 MySQL 的缺省配置，你的服务器的性能就像题图的坏在一档的法拉利一样 “虎落平阳被犬欺” …
我并不期望成为一个专家级的 DBA，但是，在我优化 MySQL 时，我推崇 80/20 原则，明确说就是通过简单的调整一些配置，你可以压榨出高达 80% 的性能提升。尤其是在服务器资源越来越便宜的当下。
### 警告
1. 没有两个数据库或者应用程序是完全相同的。这里假设我们要调整的数据库是为一个“典型”的 Web 网站服务的，优先考虑的是快速查询、良好的用户体验以及处理大量的流量。
2. 在你对服务器进行优化之前，请做好数据库备份！
### 1、 使用 InnoDB 存储引擎
如果你还在使用 MyISAM 存储引擎，那么是时候转换到 InnoDB 了。有很多的理由都表明 InnoDB 比 MyISAM 更有优势，如果你关注性能，那么，我们来看一下它们是如何利用物理内存的：
* MyISAM：仅在内存中保存索引。
* InnoDB：在内存中保存索引**和**数据。
结论：保存在内存的内容访问速度要比磁盘上的更快。
下面是如何在你的表上去转换存储引擎的命令：
```
ALTER TABLE table_name ENGINE=InnoDB;
```
*注意：你已经创建了所有合适的索引，对吗？为了更好的性能，创建索引永远是第一优先考虑的事情。*
### 2、 让 InnoDB 使用所有的内存
你可以在 `my.cnf` 文件中编辑你的 MySQL 配置。使用 `innodb_buffer_pool_size` 参数去配置在你的服务器上允许 InnoDB 使用物理内存数量。
对此（假设你的服务器*仅仅*运行 MySQL），公认的“经验法则”是设置为你的服务器物理内存的 80%。在保证操作系统不使用交换分区而正常运行所需要的足够内存之后 ，尽可能多地为 MySQL 分配物理内存。
因此，如果你的服务器物理内存是 32 GB，可以将那个参数设置为多达 25 GB。
```
innodb_buffer_pool_size = 25600M
```
\*注意：（1）如果你的服务器内存较小并且小于 1 GB。为了适用本文的方法，你应该去升级你的服务器。 （2） 如果你的服务器内存特别大，比如，它有 200 GB，那么，根据一般常识，你也没有必要为操作系统保留多达 40 GB 的内存。 \*
### 3、 让 InnoDB 多任务运行
如果服务器上的参数 `innodb_buffer_pool_size` 的配置是大于 1 GB，将根据参数 `innodb_buffer_pool_instances` 的设置， 将 InnoDB 的缓冲池划分为多个。
拥有多于一个的缓冲池的好处有：
>
> 在多线程同时访问缓冲池时可能会遇到瓶颈。你可以通过启用多缓冲池来最小化这种争用情况：
>
>
>
对于缓冲池数量的官方建议是：
>
> 为了实现最佳的效果，要综合考虑 `innodb_buffer_pool_instances` 和 `innodb_buffer_pool_size` 的设置，以确保每个实例至少有不小于 1 GB 的缓冲池。
>
>
>
因此，在我们的示例中，将参数 `innodb_buffer_pool_size` 设置为 25 GB 的拥有 32 GB 物理内存的服务器上。一个合适的设置为 25600M / 24 = 1.06 GB
```
innodb_buffer_pool_instances = 24
```
### 注意！
在修改了 `my.cnf` 文件后需要重启 MySQL 才能生效：
```
sudo service mysql restart
```
还有更多更科学的方法来优化这些参数，但是这几点可以作为一个通用准则来应用，将使你的 MySQL 服务器性能更好。
---
作者简介:
我喜欢商业技术以及跑车 | 集团 CTO @ Parcel Monkey， Cloud Fulfilment & Kong。
---
via: <https://medium.com/@richb_/tuning-mysql-3-simple-tweaks-6356768f9b90>
作者：[Rich Barrett](https://medium.com/@richb_) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Gerg：Meltdown 和 Spectre 影响下的 Linux 内核状况
|
Greg Kroah-hartman
|
http://kroah.com/log/blog/2018/01/06/meltdown-status/
|
再次说一遍，更新你的内核，不要耽搁，不要止步。更新会在很长的一段时间里持续地解决这些问题。同样的，稳定和长期支持内核发行版里仍然有很多其它的 bug 和安全问题，它们和问题的类型无关，所以一直保持更新始终是一个好主意。
|
/data/attachment/album/201802/09/211831lzys5xy9p0nxylxx.png.thumb.jpg
|
/data/attachment/album/201802/09/211831lzys5xy9p0nxylxx.png
| true | false | true |
hopefully2333
| false |
[
"KPTI",
"Meltdown",
"Spectre"
] |
技术
|
{
"viewnum": 3386,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
再次说一遍，更新你的内核，不要耽搁，不要止步。更新会在很长的一段时间里持续地解决这些问题。同样的，稳定和长期支持内核发行版里仍然有很多其它的 bug 和安全问题，它们和问题的类型无关，所以一直保持更新始终是一个好主意。
| 2018-02-09T21:18:37 | 2018-02-09T21:18:37 | 9,326 |
/article-9326-1.html
|
现在（LCTT 译注：本文发表于 1 月初），每个人都知道一件关乎电脑安全的“大事”发生了，真见鬼，等[每日邮报报道](http://www.dailymail.co.uk/sciencetech/article-5238789/Intel-says-security-updates-fix-Meltdown-Spectre.html)的时候，你就知道什么是糟糕了...
不管怎样，除了告诉你这篇写的及其出色的[披露该问题的 Zero 项目的论文](https://googleprojectzero.blogspot.fr/2018/01/reading-privileged-memory-with-side.html)之外，我不打算去跟进这个问题已经被报道出来的细节。他们应该现在就直接颁布 2018 年的 [Pwnie](https://pwnies.com/) 奖，干的太棒了。
如果你想了解我们如何在内核中解决这些问题的技术细节，你可以保持关注了不起的 [lwn.net](https://lwn.net/Articles/743265/)，他们会把这些细节写成文章。
此外，这有一条很好的关于[这些公告](https://lwn.net/Articles/742999/)的摘要，包括了各个厂商的公告。
至于这些涉及的公司是如何处理这些问题的，这可以说是如何**不**与 Linux 内核社区保持沟通的教科书般的例子。这件事涉及到的人和公司都知道发生了什么，我确定这件事最终会出现，但是目前我需要去关注的是如何修复这些涉及到的问题，然后不去点名指责，不管我有多么的想去这么做。
### 你现在能做什么
如果你的 Linux 系统正在运行一个正常的 Linux 发行版，那么升级你的内核。它们都应该已经更新了，然后在接下来的几个星期里保持更新。我们会统计大量在极端情况下出现的 bug ，这里涉及的测试很复杂，包括庞大的受影响的各种各样的系统和工作任务。如果你的 Linux 发行版没有升级内核，我强烈的建议你马上更换一个 Linux 发行版。
然而有很多的系统因为各种各样的原因（听说它们比起“传统”的企业发行版更多）不是在运行“正常的” Linux 发行版上。它们依靠长期支持版本（LTS）的内核升级，或者是正常的稳定内核升级，或者是内部的某人打造版本的内核。对于这部分人，这篇介绍了你能使用的上游内核中发生的混乱是怎么回事。
### Meltdown – x86
现在，Linus 的内核树包含了我们当前所知的为 x86 架构解决 meltdown 漏洞的所有修复。开启 `CONFIG_PAGE_TABLE_ISOLATION` 这个内核构建选项，然后进行重构和重启，所有的设备应该就安全了。
然而，Linus 的内核树当前处于 4.15-rc6 这个版本加上一些未完成的补丁。4.15-rc7 版本要明天才会推出，里面的一些补丁会解决一些问题。但是大部分的人不会在一个“正常”的环境里运行 -rc 内核。
因为这个原因，x86 内核开发者在<ruby> 页表隔离 <rt> page table isolation </rt></ruby>代码的开发过程中做了一个非常好的工作，好到要反向移植到最新推出的稳定内核 4.14 的话，我们只需要做一些微不足道的工作。这意味着最新的 4.14 版本（本文发表时是 4.14.12 版本），就是你应该运行的版本。4.14.13 会在接下来的几天里推出，这个更新里有一些额外的修复补丁，这些补丁是一些运行 4.14.12 内核且有启动时间问题的系统所需要的（这是一个显而易见的问题，如果它不启动，就把这些补丁加入更新排队中）。
我个人要感谢 Andy Lutomirski、Thomas Gleixner、Ingo Molnar、 Borislav Petkov、 Dave Hansen、 Peter Zijlstra、 Josh Poimboeuf、 Juergen Gross 和 Linus Torvalds。他们开发出了这些修复补丁，并且为了让我能轻松地使稳定版本能够正常工作，还把这些补丁以一种形式融合到了上游分支里。没有这些工作，我甚至不敢想会发生什么。
对于老的长期支持内核（LTS），我主要依靠 Hugh Dickins、 Dave Hansen、 Jiri Kosina 和 Borislav Petkov 优秀的工作，来为 4.4 到 4.9 的稳定内核代码树分支带去相同的功能。我同样在追踪讨厌的 bug 和缺失的补丁方面从 Guenter Roeck、 Kees Cook、 Jamie Iles 以及其他很多人那里得到了极大的帮助。我要感谢 David Woodhouse、 Eduardo Valentin、 Laura Abbott 和 Rik van Riel 在反向移植和集成方面的帮助，他们的帮助在许多棘手的地方是必不可少的。
这些长期支持版本的内核同样有 `CONFIG_PAGE_TABLE_ISOLATION` 这个内核构建选项，你应该开启它来获得全方面的保护。
从主线版本 4.14 和 4.15 的反向移植是非常不一样的，它们会出现不同的 bug，我们现在知道了一些在工作中遇见的 VDSO 问题。一些特殊的虚拟机安装的时候会报一些奇怪的错，但这是只是现在出现的少数情况，这种情况不应该阻止你进行升级。如果你在这些版本中遇到了问题，请让我们在稳定内核邮件列表中知道这件事。
如果你依赖于 4.4 和 4.9 或是现在的 4.14 以外的内核代码树分支，并且没有发行版支持你的话，你就太不幸了。比起你当前版本内核包含的上百个已知的漏洞和 bug，缺少补丁去解决 meltdown 问题算是一个小问题了。你现在最需要考虑的就是马上把你的系统升级到最新。
与此同时，臭骂那些强迫你运行一个已被废弃且不安全的内核版本的人，他们是那些需要知道这是完全不顾后果的行为的人中的一份子。
### Meltdown – ARM64
现在 ARM64 为解决 Meltdown 问题而开发的补丁还没有并入 Linus 的代码树，一旦 4.15 在接下来的几周里成功发布，他们就准备[阶段式地并入](https://git.kernel.org/pub/scm/linux/kernel/git/arm64/linux.git/log/?h=kpti) 4.16-rc1，因为这些补丁还没有在一个 Linus 发布的内核中，我不能把它们反向移植进一个稳定的内核版本里（额……我们有这个[规矩](https://www.kernel.org/doc/html/latest/process/stable-kernel-rules.html)是有原因的）
由于它们还没有在一个已发布的内核版本中，如果你的系统是用的 ARM64 的芯片（例如 Android ），我建议你选择 [Android 公共内核代码树](https://android.googlesource.com/kernel/common/)，现在，所有的 ARM64 补丁都并入 [3.18](https://android.googlesource.com/kernel/common/+/android-3.18)、[4.4](https://android.googlesource.com/kernel/common/+/android-4.4) 和 [4.9](https://android.googlesource.com/kernel/common/+/android-4.9) 分支 中。
我强烈建议你关注这些分支，看随着时间的过去，由于测试了已并入补丁的已发布的上游内核版本，会不会有更多的修复补丁被补充进来，特别是我不知道这些补丁会在什么时候加进稳定的长期支持内核版本里。
对于 4.4 到 4.9 的长期支持内核版本，这些补丁有很大概率永远不会并入它们，因为需要大量的先决补丁。而所有的这些先决补丁长期以来都一直在 Android 公共内核版本中测试和合并，所以我认为现在对于 ARM 系统来说，仅仅依赖这些内核分支而不是长期支持版本是一个更好的主意。
同样需要注意的是，我合并所有的长期支持内核版本的更新到这些分支后通常会在一天之内或者这个时间点左右进行发布，所以你无论如何都要关注这些分支，来确保你的 ARM 系统是最新且安全的。
### Spectre
现在，事情变得“有趣”了……
再一次，如果你正在运行一个发行版的内核，一些内核融入了各种各样的声称能缓解目前大部分问题的补丁，你的内核*可能*就被包含在其中。如果你担心这一类的攻击的话，我建议你更新并测试看看。
对于上游来说，很好，现状就是仍然没有任何的上游代码树分支合并了这些类型的问题相关的修复补丁。有很多的邮件列表在讨论如何去解决这些问题的解决方案，大量的补丁在这些邮件列表中广为流传，但是它们尚处于开发前期，一些补丁系列甚至没有被构建或者应用到任何已知的代码树，这些补丁系列彼此之间相互冲突，这是常见的混乱。
这是由于 Spectre 问题是最近被内核开发者解决的。我们所有人都在 Meltdown 问题上工作，我们没有精确的 Spectre 问题全部的真实信息，而四处散乱的补丁甚至比公开发布的补丁还要糟糕。
因为所有的这些原因，我们打算在内核社区里花上几个星期去解决这些问题并把它们合并到上游去。修复补丁会进入到所有内核的各种各样的子系统中，而且在它们被合并后，会集成并在稳定内核的更新中发布，所以再次提醒，无论你使用的是发行版的内核还是长期支持的稳定内核版本，你最好并保持更新到最新版。
这不是好消息，我知道，但是这就是现实。如果有所安慰的话，似乎没有任何其它的操作系统完全地解决了这些问题，现在整个产业都在同一条船上，我们只需要等待，并让开发者尽快地解决这些问题。
提出的解决方案并非毫不重要，但是它们中的一些还是非常好的。一些新概念会被创造出来来帮助解决这些问题，Paul Turner 提出的 Retpoline 方法就是其中的一个例子。这将是未来大量研究的一个领域，想出方法去减轻硬件中涉及的潜在问题，希望在它发生前就去预见它。
### 其他架构的芯片
现在，我没有看见任何 x86 和 arm64 架构以外的芯片架构的补丁，听说在一些企业发行版中有一些用于其他类型的处理器的补丁，希望他们在这几周里能浮出水面，合并到合适的上游那里。我不知道什么时候会发生，如果你使用着一个特殊的架构，我建议在 arch-specific 邮件列表上问这件事来得到一个直接的回答。
### 结论
再次说一遍，更新你的内核，不要耽搁，不要止步。更新会在很长的一段时间里持续地解决这些问题。同样的，稳定和长期支持内核发行版里仍然有很多其它的 bug 和安全问题，它们和问题的类型无关，所以一直保持更新始终是一个好主意。
现在，有很多非常劳累、坏脾气、缺少睡眠的人，他们通常会生气地让内核开发人员竭尽全力地解决这些问题，即使这些问题完全不是开发人员自己造成的。请关爱这些可怜的程序猿。他们需要爱、支持，我们可以为他们免费提供的他们最爱的饮料，以此来确保我们都可以尽可能快地结束修补系统。
---
via: <http://kroah.com/log/blog/2018/01/06/meltdown-status/>
作者：[Greg Kroah-Hartman](http://kroah.com) 译者：[hopefully2333](https://github.com/hopefully2333) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为 Linux 初学者讲解 wc 命令
|
Himanshu Arora
|
https://www.howtoforge.com/linux-wc-command-explained-for-beginners-6-examples/
|
在命令行工作时，有时您可能想要知道一个文件中的单词数量、字节数、甚至换行数量。
|
/data/attachment/album/201802/09/232919mj5ahh8apsuepydt.jpg.thumb.jpg
|
/data/attachment/album/201802/09/232919mj5ahh8apsuepydt.jpg
| true | false | true |
stevenzdg988
| false |
[
"wc"
] |
技术
|
{
"viewnum": 38209,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在命令行工作时，有时您可能想要知道一个文件中的单词数量、字节数、甚至换行数量。
| 2018-02-09T23:29:30 | 2018-02-09T23:29:30 | 9,327 |
/article-9327-1.html
|
在命令行工作时，有时您可能想要知道一个文件中的单词数量、字节数、甚至换行数量。如果您正在寻找这样做的工具，您会很高兴地知道，在 Linux 中，存在一个命令行实用程序，它被称为 `wc` ，它为您完成所有这些工作。在本文中，我们将通过简单易懂的例子来讨论这个工具。
但是在我们开始之前，值得一提的是，本教程中提供的所有示例都在 Ubuntu 16.04 上进行了测试。
### Linux wc 命令
`wc` 命令打印每个输入文件的新行、单词和字节数。以下是该命令行工具的语法:
```
wc [OPTION]... [FILE]...
```
以下是 `wc` 的 man 文档的解释：
```
为每个文件打印新行、单词和字节数，如果指定多于一个文件，也列出总的行数。单词是由空格分隔的非零长度的字符序列。如果没有指定文件，或当文件为 `-`，则读取标准输入。
```
下面的 Q&A 样式的示例将会让您更好地了解 `wc` 命令的基本用法。
注意：在所有示例中我们将使用一个名为 `file.txt` 的文件作为输入文件。以下是该文件包含的内容：
```
hi
hello
how are you
thanks.
```
### Q1. 如何打印字节数
使用 `-c` 命令选项打印字节数.
```
wc -c file.txt
```
下面是这个命令在我们的系统上产生的输出：
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/wc-c-option.png)
文件包含 29 个字节。
### Q2. 如何打印字符数
要打印字符数，请使用 `-m` 命令行选项。
```
wc -m file.txt
```
下面是这个命令在我们的系统上产生的输出：
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/wc-m-option.png)
文件包含 29 个字符。
### Q3. 如何打印换行数
使用 `-l` 命令选项来打印文件中的新行数：
```
wc -l file.txt
```
这里是我们的例子的输出：
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/wc-l-option.png)
### Q4. 如何打印单词数
要打印文件中的单词数量，请使用 `-w` 命令选项。
```
wc -w file.txt
```
在我们的例子中命令的输出如下：
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/wc-w-option.png)
这显示文件中有 6 个单词。
### Q5. 如何打印最长行的显示宽度或长度
如果您想要打印输入文件中最长行的长度，请使用 `-l` 命令行选项。
```
wc -L file.txt
```
下面是在我们的案例中命令产生的结果：
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/wc-L-option.png)
所以文件中最长的行长度是 11。
### Q6. 如何从文件读取输入文件名
如果您有多个文件名，并且您希望 `wc` 从一个文件中读取它们，那么使用`-files0-from` 选项。
```
wc --files0-from=names.txt
```
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/wc-file0-from-option.png)
如你所见 `wc` 命令，在这个例子中，输出了文件 `file.txt` 的行、单词和字符计数。文件名为 `file.txt` 的文件在 `name.txt` 文件中提及。值得一提的是，要成功地使用这个选项，文件中的文件名应该用 NUL 终止——您可以通过键入`Ctrl + v` 然后按 `Ctrl + Shift + @` 来生成这个字符。
### 结论
正如您所认同的一样，从理解和使用目的来看， `wc` 是一个简单的命令。我们已经介绍了几乎所有的命令行选项，所以一旦你练习了我们这里介绍的内容，您就可以随时在日常工作中使用该工具了。想了解更多关于 `wc` 的信息，请参考它的 [man 文档](https://linux.die.net/man/1/wc)。
---
via: <https://www.howtoforge.com/linux-wc-command-explained-for-beginners-6-examples/>
作者：[Himanshu Arora](https://www.howtoforge.com) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 内核 4.15：“一个不同寻常的发布周期”
|
Paul Brown
|
https://www.linux.com/blog/intro-to-linux/2018/1/linux-kernel-415-unusual-release-cycle
|
Linus Torvalds 在周日（1 月 28 日）发布了 Linux 的 4.15 版内核，比原计划发布时间晚了一周。了解这次发行版的关键更新。
|
/data/attachment/album/201802/10/095011cuxjqpmf7pyxkvh3.png.thumb.jpg
|
/data/attachment/album/201802/10/095011cuxjqpmf7pyxkvh3.png
| true | false | true |
qhwdw
| false |
[
"Linux",
"内核",
"KPTI"
] |
新闻
|
{
"viewnum": 7854,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Linus Torvalds 在周日（1 月 28 日）发布了 Linux 的 4.15 版内核，比原计划发布时间晚了一周。了解这次发行版的关键更新。
| 2018-02-10T09:50:08 | 2018-02-10T09:50:08 | 9,328 |
/article-9328-1.html
|
>
> Linus Torvalds 在周日发布了 Linux 的 4.15 版内核，比原计划发布时间晚了一周。了解这次发行版的关键更新。
>
>
>
Linus Torvalds 在周日（1 月 28 日）[发布了 Linux 内核的 4.15 版](https://lkml.org/lkml/2018/1/28/173)，再一次比原计划晚了一周。延迟发布的罪魁祸首是 “Meltdown” 和 “Spectre” bug，由于这两个漏洞，使开发者不得不在这最后的周期中提交重大补丁。Torvalds 不愿意“赶工”，因此，他又给了一周时间去制作这个发行版本。
不出意外的话，这第一批补丁将是去修补前面提及的 [Meltdown 和 Spectre](https://meltdownattack.com/) 漏洞。为防范 Meltdown —— 这个影响 Intel 芯片的问题，在 x86 架构上[开发者实现了页表隔离（PTI）](https://git.kernel.org/linus/5aa90a84589282b87666f92b6c3c917c8080a9bf)。不论什么理由你如果想去关闭它，你可以使用内核引导选项 `pti=off` 去关闭这个特性。
Spectre v2 漏洞对 Intel 和 AMD 芯片都有影响，为防范它，[内核现在带来了 retpoline 机制](https://git.kernel.org/linus/76b043848fd22dbf7f8bf3a1452f8c70d557b860)。Retpoline 要求 GCC 的版本支持 `-mindirect-branch=thunk-extern` 功能。由于使用了 PTI，Spectre 抑制机制可以被关闭，如果需要去关闭它，在引导时使用 `spectre_v2=off` 选项。尽管开发者努力去解决 Spectre v1，但是，到目前为止还没有一个解决方案，因此，在 4.15 的内核版本中并没有这个 bug 的修补程序。
对于在 ARM 上的 Meltdown 解决方案也将在下一个开发周期中推送。但是，[对于 PowerPC 上的 bug，在这个发行版中包含了一个补救措施，那就是使用 L1-D 缓存的 RFI 冲刷特性](https://git.kernel.org/linus/aa8a5e0062ac940f7659394f4817c948dc8c0667)。
一个有趣的事情是，上面提及的所有受影响的新内核中，都带有一个 `/sys/devices/system/cpu/vulnerabilities/` 虚拟目录。这个目录显示了影响你的 CPU 的漏洞以及当前应用的补救措施。
芯片带 bug （以及保守秘密的制造商）的问题重新唤起了开发可行的开源替代品的呼声。这使得已经合并到主线版本的内核提供了对 [RISC-V](https://riscv.org/) 芯片的部分支持。RISC-V 是一个开源的指令集架构，它允许制造商去设计他们自己的基于 RISC-V 芯片的实现。并且因此也有了几个开源的芯片。虽然 RISC-V 芯片目前主要用于嵌入式设备，它能够去做像智能硬盘或者像 Arduino 这样的开发板，RISC-V 的支持者认为这个架构也可以用于个人电脑甚至是多节点的超级计算机上。
正如在上面提到的，[对 RISC-V 的支持](https://git.kernel.org/torvalds/c/b293fca43be544483b6488d33ad4b3ed55881064)，仍然没有全部完成，它虽然包含了架构代码，但是没有设备驱动。这意味着，虽然 Linux 内核可以在 RISC-V 芯片上运行，但是没有可行的方式与底层的硬件进行实质的交互。也就是说，RISC-V 不会受到其它闭源架构上的任何 bug 的影响，并且对它的支持的开发工作也在加速进行，因为，[RISC-V 基金会已经得到了一些行业巨头的支持](https://riscv.org/membership/)。
### 4.15 版新内核中的其它新特性
Torvalds 经常说他喜欢的事情是很无聊的。对他来说，幸运的是，除了 Spectre 和 Meltdown 引发的混乱之外，在 4.15 内核中的大部分其它东西都很普通，比如，对驱动的进一步改进、对新设备的支持等等。但是，还有几点需要重点指出，它们是：
* [AMD 对虚拟化安全加密的支持](https://git.kernel.org/linus/33e63acc119d15c2fac3e3775f32d1ce7a01021b)。它允许内核通过加密来实现对虚拟机内存的保护。加密的内存仅能够被使用它的虚拟机所解密。就算是 hypervisor 也不能看到它内部的数据。这意味着在云中虚拟机正在处理的数据，在虚拟机外的任何进程都看不到。
* 由于 [包含了*显示代码*](https://git.kernel.org/torvalds/c/f6705bf959efac87bca76d40050d342f1d212587)， AMD GPU 得到了极大的提升，这使得 Radeon RX Vega 和 Raven Ridge 显卡得到了内核主线版本的支持，并且也在 AMD 显卡中实现了 HDMI/DP 音频。
* 树莓派的爱好者应该很高兴，因为在新内核中， [7" 触摸屏现在已经得到原生支持](https://git.kernel.org/linus/2f733d6194bd58b26b705698f96b0f0bd9225369)，这将产生成百上千的有趣的项目。
要发现更多的特性，你可以去查看在 [Kernel Newbies](https://kernelnewbies.org/Linux_4.15) 和 [Phoronix](https://www.phoronix.com/scan.php?page=search&q=Linux+4.15) 上的内容。
---
via: <https://www.linux.com/blog/intro-to-linux/2018/1/linux-kernel-415-unusual-release-cycle>
作者：[PAUL BROWN](https://www.linux.com/users/bro66) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何启动进入 Linux 命令行
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/how-to-boot-into-linux-command-line
|
直接启动进入 Linux 命令行非常简单。它需要在其他内核选项之后对引导参数进行简单的更改。
|
/data/attachment/album/201802/10/112026pnx0castr7l1ksvk.jpg.thumb.jpg
|
/data/attachment/album/201802/10/112026pnx0castr7l1ksvk.jpg
| true | false | true |
geekpi
| false |
[
"命令行"
] |
技术
|
{
"viewnum": 33948,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "219.134.117.201",
"message": "<a href=\"http://ubuntuhandbook.org/index.php/2014/01/boot-into-text-console-ubuntu-linux-14-04/\" target=\"_blank\">http://ubuntuhandbook.org/index.php/2014/01/boot-into-text-console-ubuntu-linux-14-04/</a>",
"username": "kashu [Chrome 66.0|Xubuntu 14.04]",
"date": "2018-02-11T17:44:53"
}
] |
[] |
直接启动进入 Linux 命令行非常简单。它需要在其他内核选项之后对引导参数进行简单的更改。
| 2018-02-10T11:20:25 | 2018-02-10T11:20:25 | 9,329 |
/article-9329-1.html
|
可能有时候你启动 Linux 时需要或者希望不使用 GUI（图形用户界面），也就是没有 X，而是选择命令行。不管是什么原因，幸运的是，直接启动进入 Linux 命令行非常简单。它需要在其他内核选项之后对引导参数进行简单的更改。此更改将系统引导到指定的运行级别。
### 为什么要这样做？
如果你的系统由于无效配置或者显示管理器损坏或任何可能导致 GUI 无法正常启动的情况而无法运行 Xorg，那么启动到命令行将允许你通过登录到终端进行故障排除（假设你知道要怎么做），并能做任何你需要做的东西。引导到命令行也是一个很好的熟悉终端的方式，不然，你也可以为了好玩这么做。
### 访问 GRUB 菜单
在启动时，你需要访问 GRUB 启动菜单。如果在每次启动计算机时菜单未设置为显示，那么可能需要在系统启动之前按住 `SHIFT` 键。在菜单中，需要选择 Linux 发行版条目。高亮显示后该条目，按下 `e` 编辑引导参数。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/gnu-grub_orig.png)
较老的 GRUB 版本遵循类似的机制。启动管理器应提供有关如何编辑启动参数的说明。
### 指定运行级别
会出现一个编辑器，你将看到 GRUB 会解析给内核的选项。移动到以 `linux` 开头的行（旧的 GRUB 版本可能是 `kernel`，选择它并按照说明操作）。这指定了要解析给内核的参数。在该行的末尾（可能会出现跨越多行，具体取决于你的终端分辨率），只需指定要引导的运行级别，即 `3`（多用户模式，纯文本）。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/runlevel_orig.png)
按下 `Ctrl-X` 或 `F10` 将使用这些参数启动系统。开机和以前一样。唯一改变的是启动的运行级别。
这是启动后的页面：
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/runlevel_1_orig.png)
### 运行级别
你可以指定不同的运行级别，默认运行级别是 `5` （多用户图形界面）。`1` 启动到“单用户”模式，它会启动进入 root shell。`3` 提供了一个多用户命令行系统。
### 从命令行切换
在某个时候，你可能想要运行显示管理器来再次使用 GUI，最快的方法是运行这个：
```
$ sudo init 5
```
就这么简单。就我个人而言，我发现命令行比使用 GUI 工具更令人兴奋和上手。不过，这只是我的个人偏好。
---
via: <http://www.linuxandubuntu.com/home/how-to-boot-into-linux-command-line>
作者：[LinuxAndUbuntu](http://www.linuxandubuntu.com) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
cURL 与 wget：你应该选用哪一个？
|
Nick Congleton
|
https://www.maketecheasier.com/curl-vs-wget/
|
虽然它们有一些相似的特征，但它们并不是完全一样。这两个程序适用与不同的场合，在特定场合下，都拥有各自的特性。
|
/data/attachment/album/201802/10/113214z991g8h9g99zfd4h.jpg.thumb.jpg
|
/data/attachment/album/201802/10/113214z991g8h9g99zfd4h.jpg
| true | false | true |
CYLeft
| false |
[
"curl",
"wget",
"下载"
] |
技术
|
{
"viewnum": 25453,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
虽然它们有一些相似的特征，但它们并不是完全一样。这两个程序适用与不同的场合，在特定场合下，都拥有各自的特性。
| 2018-02-10T11:32:09 | 2018-02-10T11:32:09 | 9,330 |
/article-9330-1.html
|
当想要直接通过 Linux 命令行下载文件，马上就能想到两个工具：wget 和 cURL。它们有很多一样的特征，可以很轻易的完成一些相同的任务。
虽然它们有一些相似的特征，但它们并不是完全一样。这两个程序适用与不同的场合，在特定场合下，都拥有各自的特性。
### cURL vs wget： 相似之处
wget 和 cURL 都可以下载内容。它们的核心就是这么设计的。它们都可以向互联网发送请求并返回请求项。这可以是文件、图片或者是其他诸如网站的原始 HTML 之类。
这两个程序都可以进行 HTTP POST 请求。这意味着它们都可以向网站发送数据，比如说填充表单什么的。
由于这两者都是命令行工具，它们都被设计成可脚本化。wget 和 cURL 都可以写进你的 [Bash 脚本](https://www.maketecheasier.com/beginners-guide-scripting-linux/) ，自动与新内容交互，下载所需内容。
### wget 的优势
wget 简单直接。这意味着你能享受它超凡的下载速度。wget 是一个独立的程序，无需额外的资源库，更不会做其范畴之外的事情。
wget 是专业的直接下载程序，支持递归下载。同时，它也允许你下载网页中或是 FTP 目录中的任何内容。
wget 拥有智能的默认设置。它规定了很多在常规浏览器里的事物处理方式，比如 cookies 和重定向，这都不需要额外的配置。可以说，wget 简直就是无需说明，开罐即食！
### cURL 优势
cURL是一个多功能工具。当然，它可以下载网络内容，但同时它也能做更多别的事情。
cURL 技术支持库是：libcurl。这就意味着你可以基于 cURL 编写整个程序，允许你基于 libcurl 库中编写图形环境的下载程序，访问它所有的功能。
cURL 宽泛的网络协议支持可能是其最大的卖点。cURL 支持访问 HTTP 和 HTTPS 协议，能够处理 FTP 传输。它支持 LDAP 协议，甚至支持 Samba 分享。实际上，你还可以用 cURL 收发邮件。
cURL 也有一些简洁的安全特性。cURL 支持安装许多 SSL/TLS 库，也支持通过网络代理访问，包括 SOCKS。这意味着，你可以越过 Tor 来使用cURL。
cURL 同样支持让数据发送变得更容易的 gzip 压缩技术。
### 思考总结
那你应该使用 cURL 还是使用 wget？这个比较得看实际用途。如果你想快速下载并且没有担心参数标识的需求，那你应该使用轻便有效的 wget。如果你想做一些更复杂的使用，直觉告诉你，你应该选择 cRUL。
cURL 支持你做很多事情。你可以把 cURL 想象成一个精简的命令行网页浏览器。它支持几乎你能想到的所有协议，可以交互访问几乎所有在线内容。唯一和浏览器不同的是，cURL 不会渲染接收到的相应信息。
---
via: <https://www.maketecheasier.com/curl-vs-wget/>
作者：[Nick Congleton](https://www.maketecheasier.com/author/nickcongleton/) 译者：[CYLeft](https://github.com/CYLeft) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Ansible 让你的系统管理自动化
|
Steve Ovens
|
https://opensource.com/article/17/7/automate-sysadmin-ansible
|
远程管理工具有很多，SaltStack、Puppet、Chef，以及 Ansible 都是很流行的选择。在本文中，我将重点放在 Ansible 上并会解释它是如何帮到你的，不管你是有 5 台还是 1000 台虚拟机。
|
/data/attachment/album/201802/10/121144exxulb5xlxeb5lau.jpg.thumb.jpg
|
/data/attachment/album/201802/10/121144exxulb5xlxeb5lau.jpg
| true | false | true |
lujun9972
| false |
[
"ansible"
] |
系统运维
|
{
"viewnum": 11405,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
远程管理工具有很多，SaltStack、Puppet、Chef，以及 Ansible 都是很流行的选择。在本文中，我将重点放在 Ansible 上并会解释它是如何帮到你的，不管你是有 5 台还是 1000 台虚拟机。
| 2018-02-10T12:11:00 | 2018-02-10T12:11:00 | 9,331 |
/article-9331-1.html
|
>
> 精进你的系统管理能力和 Linux 技能，学习如何设置工具来简化管理多台机器。
>
>
>
你是否想精进你的系统管理能力和 Linux 技能？也许你的本地局域网上跑了一些东西，而你又想让生活更轻松一点--那该怎么办呢？在本文中，我会向你演示如何设置工具来简化管理多台机器。
远程管理工具有很多，SaltStack、Puppet、Chef，以及 Ansible 都是很流行的选择。在本文中，我将重点放在 Ansible 上并会解释它是如何帮到你的，不管你是有 5 台还是 1000 台虚拟机。
让我们从多机（不管这些机器是虚拟的还是物理的）的基本管理开始。我假设你知道要做什么，有基础的 Linux 管理技能（至少要有能找出执行每个任务具体步骤的能力）。我会向你演示如何使用这一工具，而是否使用它由你自己决定。
### 什么是 Ansible？
Ansible 的网站上将之解释为 “一个超级简单的 IT 自动化引擎，可以自动进行云供给、配置管理、应用部署、服务内部编排，以及其他很多 IT 需求。” 通过在一个集中的位置定义好服务器集合，Ansible 可以在多个服务器上执行相同的任务。
如果你对 Bash 的 `for` 循环很熟悉，你会发现 Ansible 操作跟这很类似。区别在于 Ansible 是<ruby> 幕等的 <rt> idempotent </rt></ruby>。通俗来说就是 Ansible 一般只有在确实会发生改变时才执行所请求的动作。比如，假设你执行一个 Bash 的 for 循环来为多个机器创建用户，像这样子：
```
for server in serverA serverB serverC; do ssh ${server} "useradd myuser"; done
```
这会在 serverA、serverB，以及 serverC 上创建 myuser 用户；然而不管这个用户是否存在，每次运行这个 for 循环时都会执行 `useradd` 命令。一个幕等的系统会首先检查用户是否存在，只有在不存在的情况下才会去创建它。当然，这个例子很简单，但是幕等工具的好处将会随着时间的推移变得越发明显。
#### Ansible 是如何工作的？
Ansible 会将 Ansible playbooks 转换成通过 SSH 运行的命令，这在管理类 UNIX 环境时有很多优势：
1. 绝大多数类 UNIX 机器默认都开了 SSH。
2. 依赖 SSH 意味着远程主机不需要有代理。
3. 大多数情况下都无需安装额外的软件，Ansible 需要 2.6 或更新版本的 Python。而绝大多数 Linux 发行版默认都安装了这一版本（或者更新版本）的 Python。
4. Ansible 无需主节点。他可以在任何安装有 Ansible 并能通过 SSH 访问的主机上运行。
5. 虽然可以在 cron 中运行 Ansible，但默认情况下，Ansible 只会在你明确要求的情况下运行。
#### 配置 SSH 密钥认证
使用 Ansible 的一种常用方法是配置无需密码的 SSH 密钥登录以方便管理。（可以使用 Ansible Vault 来为密码等敏感信息提供保护，但这不在本文的讨论范围之内）。现在只需要使用下面命令来生成一个 SSH 密钥，如示例 1 所示。
```
[09:44 user ~]$ ssh-keygen
Generating public/private rsa key pair。
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Created directory '/home/user/.ssh'。
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_rsa。
Your public key has been saved in /home/user/.ssh/id_rsa.pub。
The key fingerprint is:
SHA256:TpMyzf4qGqXmx3aqZijVv7vO9zGnVXsh6dPbXAZ+LUQ user@user-fedora
The key's randomart image is:
+---[RSA 2048]----+
| |
| |
| E |
| o . .。|
| . + S o+。|
| . .o * . .+ooo|
| . .+o o o oo+。*|
|。.ooo* o。* .*+|
| . o+*BO.o+ .o|
+----[SHA256]-----+
```
*示例 1 ：生成一个 SSH 密钥*
在示例 1 中，直接按下回车键来接受默认值。任何非特权用户都能生成 SSH 密钥，也能安装到远程系统中任何用户的 SSH 的 `authorized_keys` 文件中。生成密钥后，还需要将之拷贝到远程主机上去，运行下面命令：
```
ssh-copy-id root@servera
```
注意：运行 Ansible 本身无需 root 权限；然而如果你使用非 root 用户，你*需要*为要执行的任务配置合适的 sudo 权限。
输入 servera 的 root 密码，这条命令会将你的 SSH 密钥安装到远程主机上去。安装好 SSH 密钥后，再通过 SSH 登录远程主机就不再需要输入 root 密码了。
### 安装 Ansible
只需要在示例 1 中生成 SSH 密钥的那台主机上安装 Ansible。若你使用的是 Fedora，输入下面命令：
```
sudo dnf install ansible -y
```
若运行的是 CentOS，你需要为 EPEL 仓库配置额外的包：
```
sudo yum install epel-release -y
```
然后再使用 yum 来安装 Ansible：
```
sudo yum install ansible -y
```
对于基于 Ubuntu 的系统，可以从 PPA 上安装 Ansible：
```
sudo apt-get install software-properties-common -y
sudo apt-add-repository ppa:ansible/ansible
sudo apt-get update
sudo apt-get install ansible -y
```
若你使用的是 macOS，那么推荐通过 Python PIP 来安装：
```
sudo pip install ansible
```
对于其他发行版，请参见 [Ansible 安装文档](http://docs.ansible.com/ansible/intro_installation.html) 。
### Ansible Inventory
Ansible 使用一个 INI 风格的文件来追踪要管理的服务器，这种文件被称之为<ruby> 库存清单 <rt> Inventory </rt></ruby>。默认情况下该文件位于 `/etc/ansible/hosts`。本文中，我使用示例 2 中所示的 Ansible 库存清单来对所需的主机进行操作（为了简洁起见已经进行了裁剪）：
```
[arch]
nextcloud
prometheus
desktop1
desktop2
vm-host15
[fedora]
netflix
[centos]
conan
confluence
7-repo
vm-server1
gitlab
[ubuntu]
trusty-mirror
nwn
kids-tv
media-centre
nas
[satellite]
satellite
[ocp]
lb00
ocp_dns
master01
app01
infra01
```
*示例 2 ： Ansible 主机文件*
每个分组由中括号和组名标识（像这样 `[group1]` )，是应用于一组服务器的任意组名。一台服务器可以存在于多个组中，没有任何问题。在这个案例中，我有根据操作系统进行的分组（`arch`、`ubuntu`、`centos`、`fedora`），也有根据服务器功能进行的分组（`ocp`、`satellite`）。Ansible 主机文件可以处理比这复杂的多的情况。详细内容，请参阅 [库存清单文档](http://docs.ansible.com/ansible/intro_inventory.html)。
### 运行命令
将你的 SSH 密钥拷贝到库存清单中所有服务器上后，你就可以开始使用 Ansible 了。Ansible 的一项基本功能就是运行特定命令。语法为：
```
ansible -a "some command"
```
例如，假设你想升级所有的 CentOS 服务器，可以运行：
```
ansible centos -a 'yum update -y'
```
*注意：不是必须要根据服务器操作系统来进行分组的。我下面会提到，[Ansible Facts](http://docs.ansible.com/ansible/playbooks_variables.html#information-discovered-from-systems-facts) 可以用来收集这一信息；然而，若使用 Facts 的话，则运行特定命令会变得很复杂，因此，如果你在管理异构环境的话，那么为了方便起见，我推荐创建一些根据操作系统来划分的组。*
这会遍历 `centos` 组中的所有服务器并安装所有的更新。一个更加有用的命令应该是 Ansible 的 `ping` 模块了，可以用来验证服务器是否准备好接受命令了：
```
ansible all -m ping
```
这会让 Ansible 尝试通过 SSH 登录库存清单中的所有服务器。在示例 3 中可以看到 `ping` 命令的部分输出结果。
```
nwn | SUCCESS => {
"changed":false，
"ping":"pong"
}
media-centre | SUCCESS => {
"changed":false，
"ping":"pong"
}
nas | SUCCESS => {
"changed":false，
"ping":"pong"
}
kids-tv | SUCCESS => {
"changed":false，
"ping":"pong"
}
...
```
*示例 3 ：Ansible ping 命令输出*
运行指定命令的能力有助于完成快速任务（LCTT 译注：应该指的那种一次性任务），但是如果我想在以后也能以同样的方式运行同样的任务那该怎么办呢？Ansible [playbooks](http://docs.ansible.com/ansible/playbooks.html) 就是用来做这个的。
### 复杂任务使用 Ansible playbooks
Ansible <ruby> 剧本 <rt> playbook </rt> <rt> </rt></ruby> 就是包含 Ansible 指令的 YAML 格式的文件。我这里不打算讲解类似 Roles 和 Templates 这些比较高深的内容。有兴趣的话，请阅读 [Ansible 文档](http://docs.ansible.com/ansible/playbooks_roles.html)。
在前一章节，我推荐你使用 `ssh-copy-id` 命令来传递你的 SSH 密钥；然而，本文关注于如何以一种一致的、可重复性的方式来完成任务。示例 4 演示了一种以冥等的方式，即使 SSH 密钥已经存在于目标主机上也能保证正确性的实现方法。
```
---
- hosts:all
gather_facts:false
vars:
ssh_key:'/root/playbooks/files/laptop_ssh_key'
tasks:
- name:copy ssh key
authorized_key:
key:"{{ lookup('file'，ssh_key) }}"
user:root
```
*示例 4：Ansible 剧本 “push ssh keys.yaml”*
`- hosts:` 行标识了这个剧本应该在那个主机组上执行。在这个例子中，它会检查库存清单里的所有主机。
`gather_facts:` 行指明 Ansible 是否去搜索每个主机的详细信息。我稍后会做一次更详细的检查。现在为了节省时间，我们设置 `gather_facts` 为 `false`。
`vars:` 部分，顾名思义，就是用来定义剧本中所用变量的。在示例 4 的这个简短剧本中其实不是必要的，但是按惯例我们还是设置了一个变量。
最后由 `tasks:` 标注的这个部分，是存放主体指令的地方。每个任务都有一个 `-name:`。Ansbile 在运行剧本时会显示这个名字。
`authorized_key:` 是剧本所使用 Ansible 模块的名字。可以通过命令 `ansible-doc -a` 来查询 Ansible 模块的相关信息； 不过通过网络浏览器查看 [文档](http://docs.ansible.com/ansible/modules_by_category.html) 可能更方便一些。[authorized\_key 模块](http://docs.ansible.com/ansible/authorized_key_module.html) 有很多很好的例子可以参考。要运行示例 4 中的剧本，只要运行 `ansible-playbook` 命令就行了：
```
ansible-playbook push_ssh_keys.yaml
```
如果是第一次添加 SSH 密钥，SSH 会提示你输入 root 用户的密码。
现在 SSH 密钥已经传输到服务器中去了，可以来做点有趣的事了。
### 使用 Ansible 收集信息
Ansible 能够收集目标系统的各种信息。如果你的主机数量很多，那它会特别的耗时。按我的经验，每台主机大概要花个 1 到 2 秒钟，甚至更长时间；然而有时收集信息是有好处的。考虑下面这个剧本，它会禁止 root 用户通过密码远程登录系统：
```
---
- hosts:all
gather_facts:true
vars:
tasks:
- name:Enabling ssh-key only root access
lineinfile:
dest:/etc/ssh/sshd_config
regexp:'^PermitRootLogin'
line:'PermitRootLogin without-password'
notify:
- restart_sshd
- restart_ssh
handlers:
- name:restart_sshd
service:
name:sshd
state:restarted
enabled:true
when:ansible_distribution == 'RedHat'
- name:restart_ssh
service:
name:ssh
state:restarted
enabled:true
when:ansible_distribution == 'Debian'
```
*示例 5：锁定 root 的 SSH 访问*
在示例 5 中 `sshd_config` 文件的修改是有[条件](http://docs.ansible.com/ansible/lineinfile_module.html) 的，只有在找到匹配的发行版的情况下才会执行。在这个案例中，基于 Red Hat 的发行版与基于 Debian 的发行版对 SSH 服务的命名是不一样的，这也是使用条件语句的目的所在。虽然也有其他的方法可以达到相同的效果，但这个例子很好演示了 Ansible 信息的作用。若你想查看 Ansible 默认收集的所有信息，可以在本地运行 `setup` 模块：
```
ansible localhost -m setup |less
```
Ansible 收集的所有信息都能用来做判断，就跟示例 4 中 `vars:` 部分所演示的一样。所不同的是，Ansible 信息被看成是**内置** 变量，无需由系统管理员定义。
### 更近一步
现在可以开始探索 Ansible 并创建自己的基本了。Ansible 是一个富有深度、复杂性和灵活性的工具，只靠一篇文章不可能就把它讲透。希望本文能够激发你的兴趣，鼓励你去探索 Ansible 的功能。在下一篇文章中，我会再聊聊 `Copy`、`systemd`、`service`、`apt`、`yum`、`virt`，以及 `user` 模块。我们可以在剧本中组合使用这些模块，还可以创建一个简单的 Git 服务器来存储这些所有剧本。
---
via: <https://opensource.com/article/17/7/automate-sysadmin-ansible>
作者：[Steve Ovens](https://opensource.com/users/stratusss) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Arch Linux 中设置日语环境
|
Sk
|
https://www.ostechnix.com/setup-japanese-language-environment-arch-linux/
|
在 Arch Linux 下有点困难，ArchWiki 中没有合适的文档。如果你正在使用 Arch Linux 和/或其衍生产品如 Antergos、Manajaro Linux，请遵循本指南以在 Arch Linux 及其衍生系统中使用日语。
|
/data/attachment/album/201802/10/223727juvyib53zbvlllo3.jpg.thumb.jpg
|
/data/attachment/album/201802/10/223727juvyib53zbvlllo3.jpg
| true | false | true |
geekpi
| false |
[
"日语",
"Arch"
] |
桌面应用
|
{
"viewnum": 5890,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 Arch Linux 下有点困难，ArchWiki 中没有合适的文档。如果你正在使用 Arch Linux 和/或其衍生产品如 Antergos、Manajaro Linux，请遵循本指南以在 Arch Linux 及其衍生系统中使用日语。
| 2018-02-12T10:36:00 | 2018-02-12T10:36:00 | 9,332 |
/article-9332-1.html
|
在本教程中，我们将讨论如何在 Arch Linux 中设置日语环境。在其他类 Unix 操作系统中，设置日文布局并不是什么大不了的事情。你可以从设置中轻松选择日文键盘布局。然而，在 Arch Linux 下有点困难，ArchWiki 中没有合适的文档。如果你正在使用 Arch Linux 和/或其衍生产品如 Antergos、Manajaro Linux，请遵循本指南以在 Arch Linux 及其衍生系统中使用日语。
### 在 Arch Linux 中设置日语环境
首先，为了正确查看日语字符，先安装必要的日语字体：
```
sudo pacman -S adobe-source-han-sans-jp-fonts otf-ipafont
pacaur -S ttf-monapo
```
如果你尚未安装 `pacaur`，请参阅[此链接](https://www.ostechnix.com/install-pacaur-arch-linux/)。
确保你在 `/etc/locale.gen` 中注释掉了（添加 `#` 注释）下面的行。
```
#ja_JP.UTF-8
```
然后，安装 iBus 和 ibus-anthy。对于那些想知道原因的，iBus 是类 Unix 系统的输入法（IM）框架，而 ibus-anthy 是 iBus 的日语输入法。
```
sudo pacman -S ibus ibus-anthy
```
在 `~/.xprofile` 中添加以下几行（如果不存在，创建一个）：
```
# Settings for Japanese input
export GTK_IM_MODULE='ibus'
export QT_IM_MODULE='ibus'
export XMODIFIERS=@im='ibus'
#Toolbar for anthy
ibus-daemon -drx
```
`~/.xprofile` 允许我们在 X 用户会话开始时且在窗口管理器启动之前执行命令。
保存并关闭文件。重启 Arch Linux 系统以使更改生效。
登录到系统后，右键单击任务栏中的 iBus 图标，然后选择 “Preferences”。如果不存在，请从终端运行以下命令来启动 iBus 并打开偏好设置窗口。
```
ibus-setup
```
选择 “Yes” 来启动 iBus。你会看到一个像下面的页面。点击 Ok 关闭它。
现在，你将看到 iBus 偏好设置窗口。进入 “Input Method” 选项卡，然后单击 “Add” 按钮。
在列表中选择 “Japanese”：
然后，选择 “Anthy” 并点击添加：
就是这样了。你现在将在输入法栏看到 “Japanese - Anthy”：
根据你的需求在偏好设置中更改日语输入法的选项（点击 “Japanese-Anthy” -> “Preferences”）。
你还可以在键盘绑定中编辑默认的快捷键。完成所有更改后，点击应用并确定。就是这样。从任务栏中的 iBus 图标中选择日语，或者按下 `SUPER + 空格键”（LCTT 译注：SUPER 键通常为`Command`或`Window` 键）来在日语和英语（或者系统中的其他默认语言）之间切换。你可以从 iBus 首选项窗口更改键盘快捷键。
现在你知道如何在 Arch Linux 及其衍生版中使用日语了。如果你发现我们的指南很有用，那么请您在社交、专业网络上分享，并支持我们。
---
via: <https://www.ostechnix.com/setup-japanese-language-environment-arch-linux/>
作者：[SK](https://www.ostechnix.com) 译者：[geekpi](https://github.com/geekpi) 校对：[Locez](https://github.com/locez)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 TLS 加密保护 VNC 服务器的简单指南
|
Shusain
|
http://linuxtechlab.com/secure-vnc-server-tls-encryption/
|
在本教程中，我们将学习安装 VNC 服务器并使用 TLS 加密保护 VNC 会话。
|
/data/attachment/album/201802/10/225325rqxd5dk3334zi2hx.jpg.thumb.jpg
|
/data/attachment/album/201802/10/225325rqxd5dk3334zi2hx.jpg
| true | false | true |
geekpi
| false |
[
"VNC",
"TLS"
] |
技术
|
{
"viewnum": 11306,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本教程中，我们将学习安装 VNC 服务器并使用 TLS 加密保护 VNC 会话。
| 2018-02-13T09:45:00 | 2018-02-13T09:45:00 | 9,333 |
/article-9333-1.html
|
在本教程中，我们将学习安装 VNC 服务器并使用 TLS 加密保护 VNC 会话。
此方法已经在 CentOS 6＆7 上测试过了，但是也可以在其它的版本/操作系统上运行（RHEL、Scientific Linux 等）。
**（推荐阅读：[保护 SSH 会话终极指南](http://linuxtechlab.com/ultimate-guide-to-securing-ssh-sessions/)）**
### 安装 VNC 服务器
在机器上安装 VNC 服务器之前，请确保我们有一个可用的 GUI（图形用户界面）。如果机器上还没有安装 GUI，我们可以通过执行以下命令来安装：
```
yum groupinstall "GNOME Desktop"
```
现在我们将 tigervnc 作为我们的 VNC 服务器，运行下面的命令运行：
```
# yum install tigervnc-server
```
安装完成后，我们将创建一个新的用户访问服务器：
```
# useradd vncuser
```
并使用以下命令为其分配访问 VNC 的密码：
```
# vncpasswd vncuser
```
我们在 CentOS 6&7 上配置会有一点改变，我们首先看 CentOS 6 的配置。
#### CentOS 6
现在我们需要编辑 VNC 配置文件：
```
# vim /etc/sysconfig/vncservers
```
并添加下面这几行：
```
[ …]
VNCSERVERS= "1:vncuser"
VNCSERVERARGS[1]= "-geometry 1024×768″
```
保存文件并退出。接下来重启 vnc 服务使改动生效：
```
# service vncserver restart
```
并在启动时启用它：
```
# chkconfig vncserver on
```
#### CentOS 7
在 CentOS 7 上，`/etc/sysconfig/vncservers` 已经改为 `/lib/systemd/system/vncserver@.service`。我们将使用这个配置文件作为参考，所以创建一个文件的副本，
```
# cp /lib/systemd/system/vncserver@.service /etc/systemd/system/vncserver@:1.service
```
接下来，我们将编辑文件以包含我们创建的用户：
```
# vim /etc/systemd/system/vncserver@:1.service
```
编辑下面 2 行中的用户：
```
ExecStart=/sbin/runuser -l vncuser -c "/usr/bin/vncserver %i"
PIDFile=/home/vncuser/.vnc/%H%i.pid
```
保存文件并退出。接下来重启服务并在启动时启用它：
```
# systemctl restart vncserver@:1.service
# systemctl enable vncserver@:1.service
```
现在我们已经设置好了 VNC 服务器，并且可以使用 VNC 服务器的 IP 地址从客户机连接到它。但是，在此之前，我们将使用 TLS 加密保护我们的连接。
### 保护 VNC 会话
要保护 VNC 会话，我们将首先配置加密方法。我们将使用 TLS 加密，但也可以使用 SSL 加密。执行以下命令在 VNC 服务器上使用 TLS 加密：
```
# vncserver -SecurityTypes=VeNCrypt,TLSVnc
```
你将被要求输入密码来访问 VNC（如果使用其他用户，而不是上述用户）。
现在，我们可以使用客户机上的 VNC 浏览器访问服务器，使用以下命令以安全连接启动 vnc 浏览器：
```
# vncviewer -SecurityTypes=VeNCrypt,TLSVnc 192.168.1.45:1
```
这里，192.168.1.45 是 VNC 服务器的 IP 地址。
输入密码，我们可以远程访问服务器，并且也是 TLS 加密的。
这篇教程就完了，欢迎随时使用下面的评论栏提交你的建议或疑问。
---
via: <http://linuxtechlab.com/secure-vnc-server-tls-encryption/>
作者：[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/) 荣誉推出
|
||
TensorFlow 的简单例子
|
Likegeeks
|
https://www.codementor.io/likegeeks/define-and-use-tensors-using-simple-tensorflow-examples-ggdgwoy4u
|
在本文中，我们将看一些 TensorFlow 的例子，并从中感受到在定义张量和使用张量做数学计算方面有多么容易，我还会举些别的机器学习相关的例子。
|
/data/attachment/album/201802/11/231211xv52948zv3sf242f.png.thumb.jpg
|
/data/attachment/album/201802/11/231211xv52948zv3sf242f.png
| true | false | true |
ghsgz
| false |
[
"TensorFlow"
] |
软件开发
|
{
"viewnum": 6473,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本文中，我们将看一些 TensorFlow 的例子，并从中感受到在定义张量和使用张量做数学计算方面有多么容易，我还会举些别的机器学习相关的例子。
| 2018-02-11T23:12:08 | 2018-02-11T23:12:08 | 9,335 |
/article-9335-1.html
|
在本文中，我们将看一些 TensorFlow 的例子，并从中感受到在定义<ruby> 张量 <rt> tensor </rt></ruby>和使用张量做数学计算方面有多么容易，我还会举些别的机器学习相关的例子。
### TensorFlow 是什么?
TensorFlow 是 Google 为了解决复杂的数学计算耗时过久的问题而开发的一个库。
事实上，TensorFlow 能干许多事。比如：
* 求解复杂数学表达式
* 机器学习技术。你往其中输入一组数据样本用以训练，接着给出另一组数据样本基于训练的数据而预测结果。这就是人工智能了！
* 支持 GPU 。你可以使用 GPU（图像处理单元）替代 CPU 以更快的运算。TensorFlow 有两个版本： CPU 版本和 GPU 版本。
开始写例子前，需要了解一些基本知识。
### 什么是张量？
<ruby> 张量 <rt> tensor </rt></ruby>是 TensorFlow 使用的主要的数据块，它类似于变量，TensorFlow 使用它来处理数据。张量拥有维度和类型的属性。
维度指张量的行和列数，读到后面你就知道了，我们可以定义一维张量、二维张量和三维张量。
类型指张量元素的数据类型。
### 定义一维张量
可以这样来定义一个张量：创建一个 NumPy 数组（LCTT 译注：NumPy 系统是 Python 的一种开源数字扩展，包含一个强大的 N 维数组对象 Array，用来存储和处理大型矩阵 ）或者一个 [Python 列表](https://likegeeks.com/python-list-functions/) ，然后使用 `tf_convert_to_tensor` 函数将其转化成张量。
可以像下面这样，使用 NumPy 创建一个数组：
```
import numpy as np arr = np.array([1, 5.5, 3, 15, 20])
arr = np.array([1, 5.5, 3, 15, 20])
```
运行结果显示了这个数组的维度和形状。
```
import numpy as np
arr = np.array([1, 5.5, 3, 15, 20])
print(arr)
print(arr.ndim)
print(arr.shape)
print(arr.dtype)
```
它和 Python 列表很像，但是在这里，元素之间没有逗号。
现在使用 `tf_convert_to_tensor` 函数把这个数组转化为张量。
```
import numpy as np
import tensorflow as tf
arr = np.array([1, 5.5, 3, 15, 20])
tensor = tf.convert_to_tensor(arr,tf.float64)
print(tensor)
```
这次的运行结果显示了张量具体的含义，但是不会展示出张量元素。
要想看到张量元素，需要像下面这样，运行一个会话：
```
import numpy as np
import tensorflow as tf
arr = np.array([1, 5.5, 3, 15, 20])
tensor = tf.convert_to_tensor(arr,tf.float64)
sess = tf.Session()
print(sess.run(tensor))
print(sess.run(tensor[1]))
```
### 定义二维张量
定义二维张量，其方法和定义一维张量是一样的，但要这样来定义数组：
```
arr = np.array([(1, 5.5, 3, 15, 20),(10, 20, 30, 40, 50), (60, 70, 80, 90, 100)])
```
接着转化为张量：
```
import numpy as np
import tensorflow as tf
arr = np.array([(1, 5.5, 3, 15, 20),(10, 20, 30, 40, 50), (60, 70, 80, 90, 100)])
tensor = tf.convert_to_tensor(arr)
sess = tf.Session()
print(sess.run(tensor))
```
现在你应该知道怎么定义张量了，那么，怎么在张量之间跑数学运算呢？
### 在张量上进行数学运算
假设我们有以下两个数组：
```
arr1 = np.array([(1,2,3),(4,5,6)])
arr2 = np.array([(7,8,9),(10,11,12)])
```
利用 TenserFlow ，你能做许多数学运算。现在我们需要对这两个数组求和。
使用加法函数来求和：
```
import numpy as np
import tensorflow as tf
arr1 = np.array([(1,2,3),(4,5,6)])
arr2 = np.array([(7,8,9),(10,11,12)])
arr3 = tf.add(arr1,arr2)
sess = tf.Session()
tensor = sess.run(arr3)
print(tensor)
```
也可以把数组相乘：
```
import numpy as np
import tensorflow as tf
arr1 = np.array([(1,2,3),(4,5,6)])
arr2 = np.array([(7,8,9),(10,11,12)])
arr3 = tf.multiply(arr1,arr2)
sess = tf.Session()
tensor = sess.run(arr3)
print(tensor)
```
现在你知道了吧。
三维张量
----
我们已经知道了怎么使用一维张量和二维张量，现在，来看一下三维张量吧，不过这次我们不用数字了，而是用一张 RGB 图片。在这张图片上，每一块像素都由 x、y、z 组合表示。
这些组合形成了图片的宽度、高度以及颜色深度。
首先使用 matplotlib 库导入一张图片。如果你的系统中没有 matplotlib ，可以 [使用 pip](https://likegeeks.com/import-create-install-reload-alias-python-modules/#Install-Python-Modules-Using-pip)来安装它。
将图片放在 Python 文件的同一目录下，接着使用 matplotlib 导入图片：
```
import matplotlib.image as img
myfile = "likegeeks.png"
myimage = img.imread(myfile)
print(myimage.ndim)
print(myimage.shape)
```
从运行结果中，你应该能看到，这张三维图片的宽为 150 、高为 150 、颜色深度为 3 。
你还可以查看这张图片：
```
import matplotlib.image as img
import matplotlib.pyplot as plot
myfile = "likegeeks.png"
myimage = img.imread(myfile)
plot.imshow(myimage)
plot.show()
```
真酷！
那怎么使用 TensorFlow 处理图片呢？超级容易。
### 使用 TensorFlow 生成或裁剪图片
首先，向一个占位符赋值：
```
myimage = tf.placeholder("int32",[None,None,3])
```
使用裁剪操作来裁剪图像：
```
cropped = tf.slice(myimage,[10,0,0],[16,-1,-1])
```
最后，运行这个会话：
```
result = sess.run(cropped, feed\_dict={slice: myimage})
```
然后，你就能看到使用 matplotlib 处理过的图像了。
这是整段代码：
```
import tensorflow as tf
import matplotlib.image as img
import matplotlib.pyplot as plot
myfile = "likegeeks.png"
myimage = img.imread(myfile)
slice = tf.placeholder("int32",[None,None,3])
cropped = tf.slice(myimage,[10,0,0],[16,-1,-1])
sess = tf.Session()
result = sess.run(cropped, feed_dict={slice: myimage})
plot.imshow(result)
plot.show()
```
是不是很神奇？
### 使用 TensorFlow 改变图像
在本例中，我们会使用 TensorFlow 做一下简单的转换。
首先，指定待处理的图像，并初始化 TensorFlow 变量值：
```
myfile = "likegeeks.png"
myimage = img.imread(myfile)
image = tf.Variable(myimage,name='image')
vars = tf.global_variables_initializer()
```
然后调用 transpose 函数转换，这个函数用来翻转输入网格的 0 轴和 1 轴。
```
sess = tf.Session()
flipped = tf.transpose(image, perm=[1,0,2])
sess.run(vars)
result=sess.run(flipped)
```
接着你就能看到使用 matplotlib 处理过的图像了。
```
import tensorflow as tf
import matplotlib.image as img
import matplotlib.pyplot as plot
myfile = "likegeeks.png"
myimage = img.imread(myfile)
image = tf.Variable(myimage,name='image')
vars = tf.global_variables_initializer()
sess = tf.Session()
flipped = tf.transpose(image, perm=[1,0,2])
sess.run(vars)
result=sess.run(flipped)
plot.imshow(result)
plot.show()
```
以上例子都向你表明了使用 TensorFlow 有多么容易。
---
via: <https://www.codementor.io/likegeeks/define-and-use-tensors-using-simple-tensorflow-examples-ggdgwoy4u>
作者：[LikeGeeks](https://www.codementor.io/likegeeks) 译者：[ghsgz](https://github.com/ghsgz) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
通过案例学习 xfs 文件系统相关命令
|
Kerneltalks
|
https://kerneltalks.com/commands/xfs-file-system-commands-with-examples/
|
本文我们来看一些常用的 xfs 管理命令。我们将会通过几个例子来讲解如何创建 xfs 文件系统，如何对 xfs 文件系统进行扩容，如何检测并修复 xfs 文件系统。
|
/data/attachment/album/201802/11/232306zk2462tz72sgl77l.png.thumb.jpg
|
/data/attachment/album/201802/11/232306zk2462tz72sgl77l.png
| true | false | true |
lujun9972
| false |
[
"xfs"
] |
技术
|
{
"viewnum": 6811,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文我们来看一些常用的 xfs 管理命令。我们将会通过几个例子来讲解如何创建 xfs 文件系统，如何对 xfs 文件系统进行扩容，如何检测并修复 xfs 文件系统。
| 2018-02-11T23:23:02 | 2018-02-11T23:23:02 | 9,336 |
/article-9336-1.html
|
在我们另一篇文章中，我带您领略了一下[什么是 xfs，xfs 的相关特性等内容](https://kerneltalks.com/disk-management/xfs-filesystem-in-linux/)。本文我们来看一些常用的 xfs 管理命令。我们将会通过几个例子来讲解如何创建 xfs 文件系统，如何对 xfs 文件系统进行扩容，如何检测并修复 xfs 文件系统。
### 创建 XFS 文件系统
`mkfs.xfs` 命令用来创建 xfs 文件系统。无需任何特别的参数，其输出如下：
```
root@kerneltalks # mkfs.xfs /dev/xvdf
meta-data=/dev/xvdf isize=512 agcount=4, agsize=1310720 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=0, sparse=0
data = bsize=4096 blocks=5242880, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0 ftype=1
log =internal log bsize=4096 blocks=2560, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
```
>
> 注意：一旦 XFS 文件系统创建完毕就不能在缩容而只能进行扩容了。
>
>
>
### 调整 XFS 文件系统容量
你只能对 XFS 进行扩容而不能缩容。我们使用 `xfs_growfs` 来进行扩容。你需要使用 `-D` 参数指定挂载点的新容量。`-D` 接受一个数字的参数，指定文件系统块的数量。若你没有提供 `-D` 参数，则 `xfs_growfs` 会将文件系统扩到最大。
```
root@kerneltalks # xfs_growfs /dev/xvdf -D 256
meta-data=/dev/xvdf isize=512 agcount=4, agsize=720896 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=0 spinodes=0
data = bsize=4096 blocks=2883584, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0 ftype=1
log =internal bsize=4096 blocks=2560, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
data size 256 too small, old size is 2883584
```
观察上面的输出中的最后一行。由于我分配的容量要小于现在的容量。它告诉你不能缩减 XFS 文件系统。你只能对它进行扩展。
```
root@kerneltalks # xfs_growfs /dev/xvdf -D 2883840
meta-data=/dev/xvdf isize=512 agcount=4, agsize=720896 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=0 spinodes=0
data = bsize=4096 blocks=2883584, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0 ftype=1
log =internal bsize=4096 blocks=2560, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
data blocks changed from 2883584 to 2883840
```
现在我多分配了 1GB 的空间，而且也成功地扩增了容量。
**1GB 块的计算方式：**
当前文件系统 bsize 为 4096，意思是块的大小为 4MB。我们需要 1GB，也就是 256 个块。因此在当前块数，2883584 上加上 256 得到 2883840。因此我为 `-D` 传递参数 2883840。
### 修复 XFS 文件系统
可以使用 `xfs_repair` 命令进行文件系统一致性检查和修复。使用 `-n` 参数则并不对文件系统做出什么实质性的修改。它只会搜索并报告要做哪些修改。若不带 `-n` 参数，则会修改文件系统以保证文件系统的纯净。
请注意，在检查之前，你需要先卸载 XFS 文件系统。否则会报错。
```
root@kerneltalks # xfs_repair -n /dev/xvdf
xfs_repair: /dev/xvdf contains a mounted filesystem
xfs_repair: /dev/xvdf contains a mounted and writable filesystem
fatal error -- couldn't initialize XFS library
```
卸载后运行检查命令。
```
root@kerneltalks # xfs_repair -n /dev/xvdf
Phase 1 - find and verify superblock...
Phase 2 - using internal log
- zero log...
- scan filesystem freespace and inode maps...
- found root inode chunk
Phase 3 - for each AG...
- scan (but don't clear) agi unlinked lists...
- process known inodes and perform inode discovery...
- agno = 0
- agno = 1
- agno = 2
- agno = 3
- agno = 4
- process newly discovered inodes...
Phase 4 - check for duplicate blocks...
- setting up duplicate extent list...
- check for inodes claiming duplicate blocks...
- agno = 0
- agno = 1
- agno = 2
- agno = 3
- agno = 4
No modify flag set, skipping phase 5
Phase 6 - check inode connectivity...
- traversing filesystem ...
- traversal finished ...
- moving disconnected inodes to lost+found ...
Phase 7 - verify link counts...
No modify flag set, skipping filesystem flush and exiting.
```
你可以看到，命令在每个阶段都显示出了为了文件系统变得健康可能做出的修改。若你希望命令在扫描时实际应用这些修改，则不带任何参数运行命令即可。
```
root @ kerneltalks # xfs_repair /dev/xvdf
Phase 1 - find and verify superblock . . .
Phase 2 - using internal log
- zero log . . .
- scan filesystem freespace and inode maps . . .
- found root inode chunk
Phase 3 - for each AG . . .
- scan and clear agi unlinked lists . . .
- process known inodes and perform inode discovery . . .
- agno = 0
- agno = 1
- agno = 2
- agno = 3
- agno = 4
- process newly discovered inodes . . .
Phase 4 - check for duplicate blocks . . .
- setting up duplicate extent list . . .
- check for inodes claiming duplicate blocks . . .
- agno = 0
- agno = 1
- agno = 2
- agno = 3
- agno = 4
Phase 5 - rebuild AG headers and trees . . .
- reset superblock . . .
Phase 6 - check inode connectivity . . .
- resetting contents of realtime bitmap and summary inodes
- traversing filesystem . . .
- traversal finished . . .
- moving disconnected inodes to lost + found . . .
Phase 7 - verify and correct link counts . . .
done
```
你会发现 `xfs_repair` 命令对文件系统做出了修改让其变得健康。
### 查看 XFS 版本以及它的详细信息
查看 xfs 文件系统版本很简单。使用 `-V` 参数运行 `xfs_info` 再加上挂载点就行了。
```
root@kerneltalks # xfs_info -V /shrikant
xfs_info version 4.5.0
```
若要查看 XFS 文件系统的详细信息，比如想计算扩容 XFS 文件系统时要新增多少个块，需要了解块大小，块的个数等信息，则不带任何选项运行 `xfs_info` 加上挂载点。
```
root@kerneltalks # xfs_info /shrikant
meta-data=/dev/xvdf isize=512 agcount=5, agsize=720896 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=0 spinodes=0
data = bsize=4096 blocks=2883840, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0 ftype=1
log =internal bsize=4096 blocks=2560, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
```
则会显示 XFS 文件系统的所有详细信息，就跟创建 XFS 文件系统时显示的信息一样。
此外还有一些 XFS 文件系统管理命令可以修改并管理 XFS 的元数据。我们将在另一篇文章中来讲解。
---
via: <https://kerneltalks.com/commands/xfs-file-system-commands-with-examples/>
作者：[kerneltalks](https://kerneltalks.com) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何更改 Linux 控制台上的字体
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2018/1/how-change-your-linux-console-fonts
|
我尝试尽可能的保持心灵祥和，然而总有一些事情让我意难平，比如控制台字体太小了。记住我的话，朋友，有一天你的眼睛会退化，无法再看清你编码时用的那些细小字体，到那时你就后悔莫及了。
|
/data/attachment/album/201802/12/001611jt67znuetzupntja.jpg.thumb.jpg
|
/data/attachment/album/201802/12/001611jt67znuetzupntja.jpg
| true | false | true |
lujun9972
| false |
[
"终端",
"字体"
] |
桌面应用
|
{
"viewnum": 7198,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我尝试尽可能的保持心灵祥和，然而总有一些事情让我意难平，比如控制台字体太小了。记住我的话，朋友，有一天你的眼睛会退化，无法再看清你编码时用的那些细小字体，到那时你就后悔莫及了。
| 2018-02-14T09:12:00 | 2018-02-14T09:12:00 | 9,337 |
/article-9337-1.html
|
我尝试尽可能的保持心灵祥和，然而总有一些事情让我意难平，比如控制台字体太小了。记住我的话，朋友，有一天你的眼睛会退化，无法再看清你编码时用的那些细小字体，到那时你就后悔莫及了。
幸好，Linux 死忠们，你可以更改控制台的字体。按照 Linux 一贯的尿性，不断变化的 Linux 环境使得这个问题变得不太简单明了，而 Linux 上也没有字体管理这么个东西，这使得我们很容易就被搞晕了。本文，我将会向你展示，我找到的更改字体的最简方法。
### Linux 控制台是个什么鬼？
首先让我们来澄清一下我们说的到底是个什么东西。当我提到 Linux 控制台，我指的是 TTY1-6，即你从图形环境用 `Ctrl-Alt-F1` 到 `F6` 切换到的虚拟终端。按下 `Ctrl+Alt+F7` 会切回图形环境。(不过这些热键已经不再通用，你的 Linux 发行版可能有不同的键映射。你的 TTY 的数量也可能不同，你图形环境会话也可能不在 `F7`。比如，Fedora 的默认图形会话是 `F2`，它只有一个额外的终端在 `F1`。) 我觉得能同时拥有 X 会话和终端会话实在是太酷了。
Linux 控制台是内核的一部分，而且并不运行在 X 会话中。它和你在没有图形环境的<ruby> 无头 <rt> headless </rt></ruby>服务器中用的控制台是一样的。我称呼在图形会话中的 X 终端为终端，而将控制台和 X 终端统称为终端模拟器。
但这还没完。Linux 终端从早期的 ANSI 时代开始已经经历了长久的发展，多亏了 Linux framebuffer，它现在支持 Unicode 并且对图形也有了有限的一些支持。而且出现了很多在控制台下运行的[多媒体应用](/article-9320-1.html)，这些我们在以后的文章中会提到。
### 控制台截屏
获取控制台截屏的最简单方法是让控制台跑在虚拟机内部。然后你可以在宿主系统上使用中意的截屏软件来抓取。不过借助 [fbcat](http://jwilk.net/software/fbcat) 和 [fbgrab](https://github.com/jwilk/fbcat/blob/master/fbgrab) 你也可以直接在控制台上截屏。`fbcat` 会创建一个可移植的像素映射格式（PPM）的图像； 这是一个高度可移植的未压缩图像格式，可以在所有的操作系统上读取，当然你也可以把它转换成任何喜欢的其他格式。`fbgrab` 则是 `fbcat` 的一个封装脚本，用来生成一个 PNG 文件。很多人写过多个版本的 `fbgrab`。每个版本的选项都有限而且只能创建截取全屏。
`fbcat` 的执行需要 root 权限，而且它的输出需要重定向到文件中。你无需指定文件扩展名，只需要输入文件名就行了：
```
$ sudo fbcat > Pictures/myfile
```
在 GIMP 中裁剪后，就得到了图 1。
*图 1 ： 裁剪后查看*
如果能在左边空白处有一点填充就好了，如果有读者知道如何实现请在留言框中告诉我。
`fbgrab` 还有一些选项，你可以通过 `man fbgrab` 来查看，这些选项包括对另一个控制台进行截屏，以及延时截屏等。在下面的例子中可以看到，`fbgrab` 截屏跟 `fbcat` 截屏类似，只是你无需明确进行输出重定性了：
```
$ sudo fbgrab Pictures/myOtherfile
```
### 查找字体
就我所知，除了查看字体存储目录 `/usr/share/consolefonts/`（Debian 等），`/lib/kbd/consolefonts/` （Fedora），`/usr/share/kbd/consolefonts` （openSUSE）外没有其他方法可以列出已安装的字体了。
### 更改字体
可读字体不是什么新概念。我们应该尊重以前的经验！可读性是很重要的。可配置性也很重要，然而现如今却不怎么看重了。
在 Debian/Ubuntu 等系统上，可以运行 `sudo dpkg-reconfigure console-setup` 来设置控制台字体，然后在控制台运行 `setupcon` 命令来让变更生效。`setupcon` 属于 `console-setup` 软件包中的一部分。若你的 Linux 发行版中不包含该工具，可以在 [openSUSE](https://software.opensuse.org/package/console-setup) 中下载到它。
你也可以直接编辑 `/etc/default/console-setup` 文件。下面这个例子中设置字体为 32 点大小的 Terminus Bold 字体，这是我的最爱，并且严格限制控制台宽度为 80 列。
```
ACTIVE_CONSOLES="/dev/tty[1-6]"
CHARMAP="UTF-8"
CODESET="guess"
FONTFACE="TerminusBold"
FONTSIZE="16x32"
SCREEN_WIDTH="80"
```
这里的 `FONTFACE` 和 `FONTSIZE` 的值来自于字体的文件名 `TerminusBold32x16.psf.gz`。是的，你需要反转 `FONTSIZE` 中值的顺序。计算机就是这么搞笑。然后再运行 `setupcon` 来让新配置生效。可以使用 `showconsolefont` 来查看当前所用字体的所有字符集。要查看完整的选项说明请参考 `man console-setup`。
### Systemd
Systemd 与 `console-setup` 不太一样，除了字体之外，你无需安装任何东西。你只需要编辑 `/etc/vconsole.conf` 然后重启就行了。我在 Fedora 和 openSUSE 系统中安装了一些额外的大字号的 Terminus 字体包，因为默认安装的字体最大只有 16 点而我想要的是 32 点。然后将 `/etc/vconsole.conf` 的内容修改为：
```
KEYMAP="us"
FONT="ter-v32b"
```
下周我们还将学习一些更加酷的控制台小技巧，以及一些在控制台上运行的[多媒体应用](/article-9320-1.html)。
---
via: <https://www.linux.com/learn/intro-to-linux/2018/1/how-change-your-linux-console-fonts>
作者：[Carla Schroder](https://www.linux.com/users/cschroder) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 iftop 命令监控网络带宽
|
Shusain
|
http://linuxtechlab.com/monitoring-network-bandwidth-iftop-command/
|
iftop 是网络监控工具，它提供实时带宽监控。 iftop 测量进出各个套接字连接的总数据量，即它捕获通过网络适配器收到或发出的数据包，然后将这些数据相加以得到使用的带宽。
|
/data/attachment/album/201802/12/164336kzmi1m13swrwqdss.jpg.thumb.jpg
|
/data/attachment/album/201802/12/164336kzmi1m13swrwqdss.jpg
| true | false | true |
geekpi
| false |
[
"iftop"
] |
系统运维
|
{
"viewnum": 7347,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
iftop 是网络监控工具，它提供实时带宽监控。 iftop 测量进出各个套接字连接的总数据量，即它捕获通过网络适配器收到或发出的数据包，然后将这些数据相加以得到使用的带宽。
| 2018-02-12T16:43:41 | 2018-02-12T16:43:41 | 9,338 |
/article-9338-1.html
|
系统管理员需要监控 IT 基础设施来确保一切正常运行。我们需要监控硬件，也就是内存、硬盘和 CPU 等的性能，我们也必须监控我们的网络。我们需要确保我们的网络不被过度使用，否则我们的程序，网站可能无法正常工作。在本教程中，我们将学习使用 `iftop`。
（**推荐阅读**：[**使用 Nagios** 进行资源监控](http://linuxtechlab.com/installing-configuring-nagios-server/)、[**用于检查系统信息的工具**](http://linuxtechlab.com/commands-system-hardware-info/) 、[**要监控的重要日志**](http://linuxtechlab.com/important-logs-monitor-identify-issues/) ）
`iftop` 是网络监控工具，它提供实时带宽监控。 `iftop` 测量进出各个套接字连接的总数据量，即它捕获通过网络适配器收到或发出的数据包，然后将这些数据相加以得到使用的带宽。
### 在 Debian/Ubuntu 上安装
iftop 存在于 Debian/Ubuntu 的默认仓库中，可以使用下面的命令安装：
```
$ sudo apt-get install iftop
```
### 使用 yum 在 RHEL/Centos 上安装
要在 CentOS 或 RHEL 上安装 iftop，我们需要启用 EPEL 仓库。要启用仓库，请在终端上运行以下命令：
**RHEL/CentOS 7：**
```
$ rpm -Uvh https://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-10.noarch.rpm
```
**RHEL/CentOS 6（64 位）：**
```
$ rpm -Uvh http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
```
**RHEL/CentOS 6 （32 位）：**
```
$ rpm -Uvh http://dl.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm
```
EPEL 仓库安装完成后，我们可以用下面的命令安装 `iftop`：
```
$ yum install iftop
```
这将在你的系统上安装 `iftop`。我们现在将用它来监控我们的网络。
### 使用 iftop
可以打开终端窗口，并输入下面的命令使用 `iftop`：
```
$ iftop
```
现在你将看到计算机上发生的网络活动。你也可以使用：
```
$ iftop -n
```
这将在屏幕上显示网络信息，但使用 `-n`，则不会显示与 IP 地址相关的名称，只会显示 IP 地址。这个选项能节省一些将 IP 地址解析为名称的带宽。
我们也可以看到 `iftop` 可以使用的所有命令。运行 `iftop` 后，按下键盘上的 `h` 查看 `iftop` 可以使用的所有命令。
要监控特定的网络接口，我们可以在 `iftop` 后加上接口名：
```
$ iftop -I enp0s3
```
如上所述，你可以使用帮助来查看 `iftop` 可以使用的更多选项。但是这些提到的例子只是可能只是监控网络。
---
via: <http://linuxtechlab.com/monitoring-network-bandwidth-iftop-command/>
作者：[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/) 荣誉推出
|
||
开源软件二十年 —— 过去，现在，未来
|
Simon Phipps
|
https://opensource.com/article/18/2/open-source-20-years-and-counting
|
谨以此文纪念 “开源软件” 这个名词的二十周年纪念日，开源软件是怎么占有软件的主导地位的？以后会如何发展？
|
/data/attachment/album/201802/12/171853octilrlvccr6tbff.png.thumb.jpg
|
/data/attachment/album/201802/12/171853octilrlvccr6tbff.png
| true | false | true |
name1e5s
| true |
[
"开源"
] |
观点
|
{
"viewnum": 4911,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
谨以此文纪念 “开源软件” 这个名词的二十周年纪念日，开源软件是怎么占有软件的主导地位的？以后会如何发展？
| 2018-02-12T17:18:48 | 2018-02-12T17:18:48 | 9,339 |
/article-9339-1.html
|
>
> 谨以此文纪念 “<ruby> 开源软件 <rt> open source software </rt></ruby>” 这个名词的二十周年纪念日，开源软件是怎么占有软件的主导地位的？以后会如何发展？
>
>
>
二十年以前，在 1998 年 2 月，“<ruby> 开源 <rt> open source </rt></ruby>” 这个词汇第一次出现在“软件”这一名词之前。不久之后，<ruby> 开源的定义 <rt> Open Source Definition </rt></ruby>（OSD） 这一文档被创建，并成为了撒播 <ruby> 开放源代码促进会 <rt> Open Source Initiative </rt></ruby>（OSI）的种子。正如 OSD 的作者 [Bruce Perens 所说](https://perens.com/2017/09/26/on-usage-of-the-phrase-open-source/)：
>
> “开源”是这场宣传自由软件的既有概念到商业软件，并将许可证化为一系列规则的运动的正式名称。
>
>
>
二十年后，我们能看到这一运动是非常成功的，甚至超出了当时参与这一活动的任何人的想象。 如今，开源软件无处不在。它是互联网和网络的基础。它为我们所有使用的电脑和移动设备，以及它们所连接的网络提供动力。没有它，云计算和新兴的物联网将不可能发展，甚至不可能出现。它使新的业务方式可以被测试和验证，还可以让像谷歌和 Facebook 这样的大公司在已有的基础之上继续攀登。
如任何人类的造物一样，它也有黑暗的一面。它也让反乌托邦的监视和必然导致的专制控制的出现成为了可能。它为犯罪分子提供了欺骗受害者的新的途径，还让匿名且大规模的欺凌得以存在。它让有破环性的狂热分子可以暗中组织而不会感到有何不便。这些都是开源的能力之下的黑暗投影。所有的人类工具都是如此，既可以养育人类，亦可以有害于人类。我们需要帮助下一代，让他们能争取无可取代的创新。就如 [费曼所说](https://www.brainpickings.org/2013/07/19/richard-feynman-science-morality-poem/)：
>
> 每个人都掌握着一把开启天堂之门的钥匙，但这把钥匙亦能打开地狱之门。
>
>
>
开源运动已经渐渐成熟。我们讨论和理解它的方式也渐渐的成熟。如果说第一个十年是拥护与非议对立的十年，那么第二个十年就是接纳和适应并存的十年。
1. 在第一个十年里面，关键问题就是商业模型 —— “我怎样才能自由的贡献代码，且从中受益？” —— 之后，还有更多的人提出了有关管理的难题—— “我怎么才能参与进来，且不受控制 ?”
2. 第一个十年的开源项目主要是替代现有的产品；而在第二个十年中，它们更多地是作为更大的解决方案的组成部分。
3. 第一个十年的项目往往由非正式的个人组织进行；而在第二个十年中，它们经常由创建于各个项目上的机构经营。
4. 第一个十年的开源开发者经常是投入于单一的项目，并经常在业余时间工作。 在第二个十年里，他们越来越多地受雇从事于一个专门的技术 —— 他们成了专业人员。
5. 尽管开源一直被认为是提升软件自由度的一种方式，但在第一个十年中，这个运动与那些更喜欢使用“<ruby> 自由软件 <rt> free software </rt></ruby>”的人产生了冲突。在第二个十年里，随着开源运动的加速发展，这个冲突基本上被忽略了。
第三个十年会带来什么？
1. *更复杂的商业模式* —— 主要的商业模式涉及到将很多开源组件整合而产生的复杂性的解决方案，特别是部署和扩展方面。 开源治理的需求将反映这一点。
2. *开源拼图* —— 开源项目将主要是一系列组件，彼此衔接构成组件堆栈。由此产生的解决方案将是开源组件的拼图。
3. *项目族* —— 越来越多的项目将由诸如 Linux Foundation 和 OpenStack 等联盟/行业协会以及 Apache 和 Software Freedom Conservancy 等机构主办。
4. *专业通才* —— 开源开发人员将越来越多地被雇来将诸多技术集成到复杂的解决方案里，这将有助于一系列的项目的开发。
5. *软件自由度降低* —— 随着新问题的出现，软件自由（将四项自由应用于用户和开发人员之间的灵活性）将越来越多地应用于识别解决方案是否适用于协作社区和独立部署人员。
2018 年，我将在全球各地的主题演讲中阐述这些内容。欢迎观看 [OSI 20 周年纪念全球巡演](https://opensource.org/node/905)！
*本文最初发表于 [Meshed Insights Ltd.](https://meshedinsights.com/2017/12/21/20-years-and-counting/) ， 已获转载授权，本文，以及我在 OSI 的工作，由 [Patreon patrons](https://patreon.com/webmink) 支持*
### 关于作者
Simon Phipps - 计算机工业和开源软件专家 Simon Phipps 创办了[公共软件公司](https://publicsoftware.eu/)，这是一个欧洲开源项目的托管公司，以志愿者身份成为 OSI 的总裁，还是 The Document Foundation 的一名总监。 他的作品是由 [Patreon patrons](https://patreon.com/webmink) 赞助 —— 如果你想看更多的话，来做赞助人吧！ 在超过 30 年的职业生涯中，他一直在参与世界领先的战略层面的开发 ... [关于 Simon Phipps](https://opensource.com/users/simonphipps)
---
via: <https://opensource.com/article/18/2/open-source-20-years-and-counting>
作者：[Simon Phipps](https://opensource.com/users/simonphipps) 译者：[name1e5s](https://github.com/name1e5s) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Manjaro Gaming：当 Manjaro 的才华遇上 Linux 游戏
|
Munif Tanjim
|
https://itsfoss.com/manjaro-gaming-linux/
|
Manjaro Gaming 是一个专门为游戏人群设计的，带有 Manjaro 所有才能的发行版。之前用过 Manjaro Linux 的人一定知道为什么这对于游戏人群来说是一个如此好的一个消息。
|
/data/attachment/album/201802/12/173728u5gp47pg25e9gp51.jpg.thumb.jpg
|
/data/attachment/album/201802/12/173728u5gp47pg25e9gp51.jpg
| true | false | true |
XLCYun
| false |
[
"Manjaro",
"游戏"
] |
分享
|
{
"viewnum": 9937,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "222.76.241.20",
"message": "唉！现在玩游戏都是在手机上了！",
"username": "7th [Chrome 64.0|GNU/Linux]",
"date": "2018-02-13T09:30:46"
}
] |
[] |
Manjaro Gaming 是一个专门为游戏人群设计的，带有 Manjaro 所有才能的发行版。之前用过 Manjaro Linux 的人一定知道为什么这对于游戏人群来说是一个如此好的一个消息。
| 2018-02-12T17:37:25 | 2018-02-12T17:37:25 | 9,340 |
/article-9340-1.html
|
[](https://itsfoss.com/wp-content/uploads/2016/06/Manjaro-Gaming.jpg)
[在 Linux 上玩转游戏](/article-7316-1.html)? 没错，这是非常可行的，我们正致力于为游戏人群打造一个新的 Linux 发行版。
Manjaro Gaming 是一个专门为游戏人群设计的，带有 Manjaro 所有才能的发行版。之前用过 Manjaro Linux 的人一定知道为什么这对于游戏人群来说是一个如此好的一个消息。
[Manjaro](https://manjaro.github.io/) 是一个 Linux 发行版，它基于最流行的 Linux 发行版之一 —— [Arch Linux](https://www.archlinux.org/)。 Arch Linux 因它的前沿性所带来的轻量、强大、高度定制和最新的体验而闻名于世。尽管这些都非常赞，但是也正是因为 Arch Linux 提倡这种 DIY （do it yourself）方式，导致一个主要的缺点，那就是用户想用好它，需要处理一定的技术问题。
Manjaro 把这些要求全都剥离开去，让 Arch 对新手更亲切，同时也为老手提供了 Arch 所有的高端与强大功能。总之，Manjaro 是一个用户友好型的 Linux 发行版，工作起来行云流水。
Manjaro 会成为一个强大并且极度适用于游戏的原因：
* Manjaro 自动检测计算的硬件（例如，显卡）
* 自动安装必要的驱动和软件（例如，显示驱动）
* 预安装播放媒体文件的编码器
* 专用的软件库提供完整测试过的稳定软件包。
Manjaro Gaming 打包了 Manjaro 的所有强大特性以及各种小工具和软件包，以使得在 Linux 上做游戏即顺畅又享受。
### 优化
Manjaro Gaming 做了一些优化：
* Manjaro Gaming 使用高度定制化的 XFCE 桌面环境，拥有一个黑暗风格主题。
* 禁用睡眠模式，防止用手柄上玩游戏或者观看一个长过场动画时计算机自动休眠。
### 软件
维持 Manjaro 工作起来行云流水的传统，Manjaro Gaming 打包了各种开源软件包，提供游戏人群经常需要用到的功能。其中一部分软件有：
* [KdenLIVE](https://kdenlive.org/)：用于编辑游戏视频的视频编辑软件
* [Mumble](https://www.mumble.info)：给游戏人群使用的视频聊天软件
* [OBS Studio](https://obsproject.com/)：用于录制视频或在 [Twitch](https://www.twitch.tv/) 上直播游戏用的软件
* [OpenShot](http://www.openshot.org/)：Linux 上强大的视频编辑器
* [PlayOnLinux](https://www.playonlinux.com)：使用 [Wine](https://www.winehq.org/) 作为后端，在 Linux 上运行 Windows 游戏的软件
* [Shutter](http://shutter-project.org/)：多种功能的截图工具
### 模拟器
Manjaro Gaming 自带很多的游戏模拟器：
* [DeSmuME](http://desmume.org/)：Nintendo DS 任天堂 DS 模拟器
* [Dolphin Emulator](https://dolphin-emu.org)：GameCube 和 Wii 模拟器
* [DOSBox](https://www.dosbox.com/)：DOS 游戏模拟器
* [FCEUX](http://www.fceux.com/)：任天堂娱乐系统（NES）、 红白机（FC）和 FC 磁盘系统（FDS）模拟器
* Gens/GS：世嘉模拟器
* [PCSXR](https://pcsxr.codeplex.com)：PlayStation 模拟器
* [PCSX2](http://pcsx2.net/)：Playstation 2 模拟器
* [PPSSPP](http://www.ppsspp.org/)：PSP 模拟器
* [Stella](http://stella.sourceforge.net/)：Atari 2600 VCS （雅达利）模拟器
* [VBA-M](http://vba-m.com/)：Gameboy 和 GameboyAdvance 模拟器
* [Yabause](https://yabause.org/)：世嘉土星模拟器
* [ZSNES](http://www.zsnes.com/)：超级任天堂模拟器
### 其它
还有一些终端插件 —— Color、ILoveCandy 和 Screenfetch。也包括带有 Retro Conky（LCTT 译注：复古 Conky）风格的 [Conky 管理器](https://itsfoss.com/conky-gui-ubuntu-1304/)。
注意：上面提到的所有功能并没有全部包含在 Manjaro Gaming 的现行发行版中（版本 16.03）。部分功能计划将在下一版本中纳入 —— Manjaro Gaming 16.06（LCTT 译注：本文发表于 2016 年 5 月）。
### 下载
Manjaro Gaming 16.06 将会是 Manjaro Gaming 的第一个正式版本。如果你现在就有兴趣尝试，你可以在 Sourceforge 的[项目页面](https://sourceforge.net/projects/mgame/)中下载。去那里然后下载它的 ISO 文件吧。
你觉得 Gaming Linux 发行版怎么样？想尝试吗？告诉我们！
---
via: <https://itsfoss.com/manjaro-gaming-linux/>
作者：[Munif Tanjim](https://itsfoss.com/author/munif/) 译者：[XLCYun](https://github.com/XLCYun) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux/Unix 的 Bash 中打开或关闭 ls 命令颜色显示
|
Vivek Gite
|
https://www.cyberciti.biz/faq/how-to-turn-on-or-off-colors-in-bash/
|
大多数现代 Linux 发行版和 Unix 系统都有一个定义了文件名称颜色的别名。然后，ls 命令负责在屏幕上显示文件、目录和其他文件系统对象的颜色。
|
/data/attachment/album/201802/13/001317dzxfxxe0k6xlfxu6.jpg.thumb.jpg
|
/data/attachment/album/201802/13/001317dzxfxxe0k6xlfxu6.jpg
| true | false | true |
geekpi
| false |
[
"ls"
] |
技术
|
{
"viewnum": 9004,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
大多数现代 Linux 发行版和 Unix 系统都有一个定义了文件名称颜色的别名。然后，ls 命令负责在屏幕上显示文件、目录和其他文件系统对象的颜色。
| 2018-02-16T09:09:00 | 2018-02-16T09:09:00 | 9,341 |
/article-9341-1.html
|
如何在 Linux 或类 Unix 操作系统上的 bash shell 中打开或关闭文件名称颜色（`ls` 命令颜色）？
大多数现代 Linux 发行版和 Unix 系统都有一个定义了文件名称颜色的别名。然后，`ls` 命令负责在屏幕上显示文件、目录和其他文件系统对象的颜色。
默认情况下，文件类型不会用颜色区分。你需要在 Linux 上将 `--color` 选项传递给 `ls` 命令。如果你正在使用基于 OS X 或 BSD 的系统，请将 `-G` 选项传递给 `ls` 命令。打开或关闭颜色的语法如下。
### 如何关闭 ls 命令的颜色
输入以下命令：
```
$ ls --color=none
```
或者用 `unalias` 命令删除别名：
```
$ unalias ls
```
请注意，下面的 bash shell 别名被定义为用 `ls` 命令显示颜色。这个组合使用 [alias 命令](https://www.cyberciti.biz/tips/bash-aliases-mac-centos-linux-unix.html "See Linux/Unix alias command examples for more info")和 [grep 命令](https://www.cyberciti.biz/faq/howto-use-grep-command-in-linux-unix/ "See Linux/Unix grep command examples for more info")：
```
$ alias | grep ls
```
示例输出：
```
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -alF'
alias ls='ls --color=auto'
```
### 如何打开 ls 命令的颜色
使用以下任何一个命令：
```
$ ls --color=auto
$ ls --color=tty
```
如果你想要的话，[可以定义 bash shell 别名](https://www.cyberciti.biz/tips/bash-aliases-mac-centos-linux-unix.html)：
```
alias ls='ls --color=auto'
```
你可以在 `~/.bash_profile` 或 [~/.bashrc 文件](https://bash.cyberciti.biz/guide/%7E/.bashrc) 中添加或删除 `ls` 别名 。使用文本编辑器（如 vi）编辑文件：
```
$ vi ~/.bashrc
```
追加下面的代码：
```
# my ls command aliases #
alias ls = 'ls --color=auto'
```
[在 Vi/Vim 文本编辑器中保存并关闭文件即可](https://www.cyberciti.biz/faq/linux-unix-vim-save-and-quit-command/)。
### 关于 \*BSD/macOS/Apple OS X 中 ls 命令的注意点
将 `-G` 选项传递给 `ls` 命令以在 {Free、Net、Open} BSD 或 macOS 和 Apple OS X Unix 操作系统家族上启用彩色输出：
```
$ ls -G
```
示例输出：
[](https://www.cyberciti.biz/faq/apple-mac-osx-terminal-color-ls-output-option/)
*如何在 Mac OS X 终端中为 ls 命令启用彩色输出*
### 如何临时跳过 ls 命令彩色输出？
你可以使用以下任何一种语法[暂时禁用 bash shell 别名](https://www.cyberciti.biz/faq/bash-shell-temporarily-disable-an-alias/)：
```
\ls
/bin/ls
command ls
'ls'
```
#### 关于作者
作者是 nixCraft 的创建者，经验丰富的系统管理员，也是 Linux 操作系统/Unix shell 脚本的培训师。他曾与全球客户以及IT、教育、国防和太空研究以及非营利部门等多个行业合作。在 [Twitter](https://twitter.com/nixcraft)、[Facebook](https://facebook.com/nixcraft)、[Google +](https://plus.google.com/+CybercitiBiz) 上关注他。
---
via: <https://www.cyberciti.biz/faq/how-to-turn-on-or-off-colors-in-bash/>
作者：[Vivek Gite](https://www.cyberciti.biz/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何为数字货币定价
|
John Biggs
|
https://techcrunch.com/2018/01/22/how-to-price-cryptocurrencies/
|
预测数字货币价格是一场愚人游戏，然而我想试试。为了理解当前数字货币的快速发展，您必须回到 Linux 悄然兴起的时候。
|
/data/attachment/album/201802/13/004800a4z6vmd529jbjmmy.jpg.thumb.jpg
|
/data/attachment/album/201802/13/004800a4z6vmd529jbjmmy.jpg
| true | false | true |
wyxplus
| false |
[
"比特币",
"数字货币"
] |
观点
|
{
"viewnum": 4607,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
预测数字货币价格是一场愚人游戏，然而我想试试。为了理解当前数字货币的快速发展，您必须回到 Linux 悄然兴起的时候。
| 2018-02-13T00:47:57 | 2018-02-13T00:47:57 | 9,342 |
/article-9342-1.html
|
预测数字货币价格是一场愚人游戏，然而我想试试。单一数字货币价值的驱动因素目前太多，而且含糊不清，无法根据任何一点进行评估。或许新闻正报道说比特币呈上升趋势，但与此同时，有黑客攻击或是交易所 API 错误，就让比特币的价格下跌。以太坊看起来不够智能？谁知道呢，也许第二天就建立一个新的更智能的 DAO（LCTT 译注：区块链上，基于激励的经济协调机制，以代码作为表达，通过互联网进行传输，允许人们参与数字企业的风险&回报（即分配），代币创建了 DAO 参与者之间的经济链接）将吸引大量参与者。
那么，您该如何投资呢？又或是更准确的讲，您下注在哪种数字货币上呢？
理解什么时候买卖和持有数字货币，关键是使用与评估开源项目价值的相关工具。这已经一次又一次地被提及了，但是为了理解当前数字货币的快速发展，您必须回到 Linux 悄然兴起的时候。
互联网泡沫期间，Linux 出现在大众视野中。那时候，如果您想建立一个 Web 服务器，您必须将一台 Windows 服务器或者 Sun Sparc 工作站运送到一个服务器托管机房，在那里它将为传送 Pets.com（LCTT 译注：一个在线宠物商店，借着互联网繁荣的机会崛起，在互联网泡沫破裂时倒闭）的 HTML 页面而做出努力。与此同时，Linux 就像运行在微软和 Sun 公司平行路径上的货运列车一样，可以让开发人员使用日新月异的操作系统和工具集，快速、轻松地构建一次性项目。相比之下，解决方案提供商的花费比软硬件支出少得多，很快，所有科技巨头的业务由软件转向了服务提供，例如 Sun 公司。
Linux 的萌发促使整个开源市场蓬勃发展起来。但是有一个关键的问题，您无法从开源软件中赚钱。您可以提供服务，也可以销售使用开源组件的产品，但早期开源者主要是为了提升自我，而不是为了赚钱。
数字货币几乎完全遵循 Linux 的老路，但数字货币具有一定货币价值。因此，当您在为一个区块链项目工作时，您不是为了公共利益，也不是为了编写自由软件的乐趣，而是您写它的时候期望得到一大笔钱。因此，这掩盖了许多程序员的价值判断。那些给您带来了 Python、PHP、Django 和 Node.js 的人们回来了……而现在他们正在通过编程赚钱。
### 审查代码库
今年将是代币销售和数字货币领域大清算的一年。虽然许多公司已经能够摆脱糟糕的或不可用的代码库，但我怀疑开发人员是否能让未来的公司摆脱如此云山雾罩的东西。可以肯定地说，我们可以期待[像这样详细描述 Storj 代码库不足之处的文章成为规范](https://shitcoin.com/storj-not-a-dropbox-killer-1a9f27983d70)，这些评论会让许多所谓的“ICO” 们（LCTT 译注：代币首次发行融资）陷入困境。虽然规模巨大，但 ICO 的资金渠道是有限的，在某种程度上不完整的项目会被更严格的审查。
这是什么意思呢？这意味着要了解数字货币，您必须像对待创业公司那样对待它。您要看它是否有一个好团队？它是否是一个好产品？是否能运作？会有人想要使用它吗？现在评估整个数字货币的价值还为时过早，但如果我们假设代币将成为未来计算机互相支付的方式，这就让我们摆脱了许多疑问。毕竟，2000 年没有多少人知道 Apache 会在一个竞争激烈的市场上，几乎击败其他所有的 Web 服务器，或者像 Ubuntu 一样常见以至于可以随时可以搭建和拆毁它们。
理解数字货币价值的关键是忽视泡沫、炒作、恐惧、迷惑和怀疑心理，而是关注其真正的效用。您认为有一天您的手机会为另外一个手机付款，比如游戏内的额外费用吗？ 您是否认为信用卡系统会在互联网出现后消失？您是否期望有一天，在生活中花费一点点钱，让自己过得更加舒适？然后，通过一切手段，购买并持有您认为将来可能会使您的生活过得更舒适的东西。如果您认为通过 TCP/IP 互联网的方式并不能够改善您的生活（或是您对其没有足够的了解），那么您可能就不会关注这些。纳斯达克总是开放的，至少在银行的营业时间。
好的，下面是我的预测。
### 预测
以下是我在考虑加密货币的“投资”时应该考虑的事项评估。在我们开始之前，先讲下注意事项：
* 数字货币不是真正的货币投资，而是投资在未来的技术。这就好比：当您购买数字货币时，我们像是在<ruby> 进取号星舰 <rt> Starship Enterprise </rt></ruby>的甲板上交换“<ruby> 星际信用 <rt> Galactic Credit </rt></ruby>”（LCTT 译注:《星球大战》电影中的一种货币）一般。 这是数字货币的唯一不可避免的未来。虽然您可以强制将数字货币附加到各种经济模式中，对其抱有乐观的态度，整个平台是技术乌托邦，并假设各种令人兴奋和不可能的事情将在未来几年来到。如果您有多余的现金，您喜欢《星球大战》，那么您就可以投资这些“黄金”。如果您的兄弟告诉您相关信息，结果您用信用卡买了比特币，那么您可能会要度过一段啃馒头的时间。
* 不要相信任何人。没有担保，除了提供不是投资建议的免责声明，而且这绝不是对任何特定数字货币的背书，甚至是普遍概念，但我们必须明白，我在这里写的任何东西都可能是错误的。事实上，任何关于数字货币的文章都可能是错误的，任何试图卖给您吹得天花乱坠的代币的人，几乎肯定是骗子。总之，每个人都是错的，每个人都想要得到您的钱，所以要非常、非常小心。
* 您也可以持有。如果您是在 18000 美元的价位买的比特币，您最好还是继续持有下去。 现在您就好像正处于帕斯卡赌注。（LCTT 译注：论述——我不知道上帝是否存在，如果他不存在，作为无神论者没有任何好处，但是如果他存在，作为无神论者我将有很大的坏处。所以，宁愿相信上帝存在）是的，也许您因为数字货币让您赔钱而生气，但也许您只是因为您的愚蠢和自大，但现在您不妨保持信仰，因为没有什么是必然的，或者您可以承认您是有点过于热切。虽然现在您被惩罚，但要相信有比特币之神在注视着您。最终您需要深吸一口气，同意这一切都相当怪异，并坚持下去。
现在回过头来评估数字货币。
**比特币** —— 预计明年的涨幅将超过目前的低点。此外，[世界各地的证券交易委员会和其他联邦机构](http://www.businessinsider.com/bitcoin-price-cryptocurrency-warning-from-sec-cftc-2018-1)也会开始以实际行动调整加密货币的买卖。现在银行开玩笑说，他们想要降低数字货币的风险。因此，比特币将成为数字黄金，成为投机者稳定，乏味但充满波动的避风港。尽管所有都不能用作真正的货币，但对于我们所需要的东西来说，这已经足够了，我们也可以期待量子计算的产品去改变最古老，最熟悉的加密货币的面貌。
**以太坊** —— 只要创造者 Vitalik Buterin 不再继续泼冷水，以太坊在价格上可以维持在上千美元。像一个懊悔的<ruby> 维克多·弗兰肯斯坦 <rt> Victor Frankenstein </rt></ruby>（LCTT 译注：来自《维克多·弗兰肯斯坦》电影的一名角色），Buterin 倾向于做出惊人的事情，然后在网上诋毁他们，这种自我鞭策在充满泡沫和谎言的空间中实际上是非常有用的。以太坊是最接近我们有用的加密货币，但它本质上仍然是分布式应用。这是一个很有用，很聪明的方法，可以很容易地进行实验，但是，没有人用新的分布式数据存储或应用程序取代旧系统。总之，这是一个非常令人兴奋的技术，但是还没有人知道该用它做什么。
以太坊的价格将何去何从？它将徘徊在 1000 美元左右，今年可能高达 1500 美元，但这是一个原则性的科技项目，但却不是一个保值产品。
**竞争币**（LCTT 译注：除比特币，以太币之外的所有的数字币，亦称之为山寨币） —— 泡沫的标志之一是当普通人说“我买不起比特币，所以我买了莱特币”这样的话时。这正是我从许多人那里听到的，就好像说“我买不起汉堡，所以我买了一斤木屑，我想孩子们会吃的，对不对？”那您要自担风险。竞争币对于很多人来说是一个风险非常低游戏，就好比您根据一个算法创造出某个竞争币，在市值达到一定水平时卖出，那么您可以赚取一笔不错的利润。况且，大多数竞争币不会在一夜之间消失。 我诚实地推荐以太坊而不是竞争币，但是如果您死磕竞争币，那祝您玩得开心。
**代币** —— 这是数字货币变得有趣的地方。代币需要研究机构和高校对技术有深入的了解，才能真正的评估。我见过的许多代币都是一场赌博，价格暴涨暴跌。我不会给其命名，但是经验法则是，如果您在公开市场上买了一个代币，那么您可能已经错过了赚钱的机会。截至 2018 年 1 月，代币销售，庄家开始投资一个代币几美分，最后得到百倍的回报。虽然许多创始人谈论他们的产品的神奇之处和他们的团队的强大，但是就是为了单车变摩托，把价值 4 美分一个的代币升值为 20 美分，再升值成一美元。您将收益乘以数百万，就能看到它的吸引力了。
答案很简单：找到您喜欢的几个项目并潜藏在他们的社区中。评估团队是否有实力，并且很早就知道该如何进入。将钱投入后就当扔掉几个月或几年。但无法保证，因为代币理念太过超前，以至于无法对其评估。
您正在阅读这篇文章，是因为您希望在这错综复杂的环境下得到一个方向。没关系，我已经跟许多数字货币创始人交谈，知道现在许多人不知道的事情，并且知道合谋和肮脏交易的准则。因此，像我们这样的人，要慢慢地分批购买，就会开始明白这究竟是怎么一回事，也许会从数字货币投资中获利。当数字货币的潜力被完全发掘，我们会得到一个像 Linux 一样的时代。
---
via: <https://techcrunch.com/2018/01/22/how-to-price-cryptocurrencies/>
作者：[John Biggs](https://techcrunch.com/author/john-biggs/) 译者：[wyxplus](https://github.com/wyxplus) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何列出所有的 Bash Shell 内置命令
|
Vivek Gite
|
https://www.cyberciti.biz/faq/linux-unix-bash-shell-list-all-builtin-commands/
|
shell 内置命令就是一个命令或一个函数，从 shell 中调用，它直接在 shell 中执行。 bash shell 直接执行该命令而无需调用其他程序。
|
/data/attachment/album/201802/13/012025cjjsb4449jus4u6j.jpg.thumb.jpg
|
/data/attachment/album/201802/13/012025cjjsb4449jus4u6j.jpg
| true | false | true |
KarenMrzhang
| false |
[
"命令",
"内置",
"shell"
] |
技术
|
{
"viewnum": 7301,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
shell 内置命令就是一个命令或一个函数，从 shell 中调用，它直接在 shell 中执行。 bash shell 直接执行该命令而无需调用其他程序。
| 2018-02-13T10:17:00 | 2018-02-13T10:17:00 | 9,343 |
/article-9343-1.html
|
内置命令包含在 bash shell 本身里面。我该如何在 Linux / Apple OS X / \*BSD / Unix 类操作系统列出所有的内置 bash 命令，而不用去读大篇的 bash 操作说明页？
shell 内置命令就是一个命令或一个函数，从 shell 中调用，它直接在 shell 中执行。 bash shell 直接执行该命令而无需调用其他程序。你可以使用 `help` 命令查看 Bash 内置命令的信息。以下是几种不同类型的内置命令。
### 内置命令的类型
1. Bourne Shell 内置命令：内置命令继承自 Bourne Shell。
2. Bash 内置命令：特定于 Bash 的内置命令表。
3. 修改 Shell 行为：修改 shell 属性和可选行为的内置命令。
4. 特别的内置命令：由 POSIX 特别分类的内置命令。
### 如何查看所有 bash 内置命令
有以下的命令：
```
$ help
$ help | less
$ help | grep read
```
样例输出：
```
GNU bash, version 4.1.5(1)-release (x86_64-pc-linux-gnu)
These shell commands are defined internally. Type `help' to see this list.
Type `help name' to find out more about the function `name'.
Use `info bash' to find out more about the shell in general.
Use `man -k' or `info' to find out more about commands not in this list.
A star (*) next to a name means that the command is disabled.
job_spec [&] history [-c] [-d offset] [n] or hist>
(( expression )) if COMMANDS; then COMMANDS; [ elif C>
. filename [arguments] jobs [-lnprs] [jobspec ...] or jobs >
: kill [-s sigspec | -n signum | -sigs>
[ arg... ] let arg [arg ...]
[[ expression ]] local [option] name[=value] ...
alias [-p] [name[=value] ... ] logout [n]
bg [job_spec ...] mapfile [-n count] [-O origin] [-s c>
bind [-lpvsPVS] [-m keymap] [-f filen> popd [-n] [+N | -N]
break [n] printf [-v var] format [arguments]
builtin [shell-builtin [arg ...]] pushd [-n] [+N | -N | dir]
caller [expr] pwd [-LP]
case WORD in [PATTERN [| PATTERN]...)> read [-ers] [-a array] [-d delim] [->
cd [-L|-P] [dir] readarray [-n count] [-O origin] [-s>
command [-pVv] command [arg ...] readonly [-af] [name[=value] ...] or>
compgen [-abcdefgjksuv] [-o option] > return [n]
complete [-abcdefgjksuv] [-pr] [-DE] > select NAME [in WORDS ... ;] do COMM>
compopt [-o|+o option] [-DE] [name ..> set [--abefhkmnptuvxBCHP] [-o option>
continue [n] shift [n]
coproc [NAME] command [redirections] shopt [-pqsu] [-o] [optname ...]
declare [-aAfFilrtux] [-p] [name[=val> source filename [arguments]
dirs [-clpv] [+N] [-N] suspend [-f]
disown [-h] [-ar] [jobspec ...] test [expr]
echo [-neE] [arg ...] time [-p] pipeline
enable [-a] [-dnps] [-f filename] [na> times
eval [arg ...] trap [-lp] [[arg] signal_spec ...]
exec [-cl] [-a name] [command [argume> true
exit [n] type [-afptP] name [name ...]
export [-fn] [name[=value] ...] or ex> typeset [-aAfFilrtux] [-p] name[=val>
false ulimit [-SHacdefilmnpqrstuvx] [limit>
fc [-e ename] [-lnr] [first] [last] o> umask [-p] [-S] [mode]
fg [job_spec] unalias [-a] name [name ...]
for NAME [in WORDS ... ] ; do COMMAND> unset [-f] [-v] [name ...]
for (( exp1; exp2; exp3 )); do COMMAN> until COMMANDS; do COMMANDS; done
function name { COMMANDS ; } or name > variables - Names and meanings of so>
getopts optstring name [arg] wait [id]
hash [-lr] [-p pathname] [-dt] [name > while COMMANDS; do COMMANDS; done
help [-dms] [pattern ...] { COMMANDS ; }
```
另外一种选择是使用下列命令：
```
compgen -b
compgen -b | more
```
### 查看 Bash 的内置命令信息
运行以下得到详细信息：
```
help command
help read
```
要仅得到所有带简短描述的内置命令的列表，执行如下:
```
$ help -d
```
### 查找内置命令的语法和其他选项
使用下列语法去找出更多的相关内置命令：
```
help name
help cd
help fg
help for
help read
help :
```
样例输出：
```
:: :
Null command.
No effect; the command does nothing.
Exit Status:
Always succeeds
```
### 找出一个命令是内部的（内置）还是外部的
使用 `type` 命令或 `command` 命令：
```
type -a command-name-here
type -a cd
type -a uname
type -a :
type -a ls
```
或者：
```
type -a cd uname : ls uname
```
样例输出：
```
cd is a shell builtin
uname is /bin/uname
: is a shell builtin
ls is aliased to `ls --color=auto'
ls is /bin/ls
l is a function
l ()
{
ls --color=auto
}
```
或者：
```
command -V ls
command -V cd
command -V foo
```
[](https://www.cyberciti.biz/media/new/faq/2013/03/View-list-bash-built-ins-command-info-on-Linux-or-Unix.jpg)
### 关于作者
作者是 nixCraft 网站的发起人和经验丰富的系统管理员，以及 Linux 操作系统/Unix shell 脚本编程培训师。他与全球客户以及包括 IT、教育、国防和空间研究以及非营利部门在内的各个行业合作。可以在 [Twitter](https://twitter.com/nixcraft)、[Facebook](https://facebook.com/nixcraft)、 [Google+](https://plus.google.com/+CybercitiBiz) 上关注他。
---
via: <https://www.cyberciti.biz/faq/linux-unix-bash-shell-list-all-builtin-commands/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[KarenMrzhang](https://github.com/KarenMrzhang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 中 4 个简单的找出进程 ID（PID）的方法
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/how-to-check-find-the-process-id-pid-ppid-of-a-running-program-in-linux/
|
每个人都知道 PID，究竟什么是 PID？为什么你想要 PID？你打算用 PID 做什么？你脑子里有同样的问题吗？如果是这样，你就找对地方了解这些细节了。
|
/data/attachment/album/201802/13/185715w7awbfirhr7bb4i8.jpg.thumb.jpg
|
/data/attachment/album/201802/13/185715w7awbfirhr7bb4i8.jpg
| true | false | true |
geekpi
| false |
[
"PID",
"进程"
] |
技术
|
{
"viewnum": 38599,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
每个人都知道 PID，究竟什么是 PID？为什么你想要 PID？你打算用 PID 做什么？你脑子里有同样的问题吗？如果是这样，你就找对地方了解这些细节了。
| 2018-02-13T18:57:21 | 2018-02-13T18:57:21 | 9,344 |
/article-9344-1.html
|
每个人都知道 PID，究竟什么是 PID？为什么你想要 PID？你打算用 PID 做什么？你脑子里有同样的问题吗？如果是这样，你就找对地方了解这些细节了。
我们查询 PID 主要是用来杀死一个没有响应的程序，它类似于 Windows 任务管理器一样。 Linux GUI 也提供相同的功能，但 CLI 是执行 `kill` 操作的有效方法。
### 什么是进程 ID?
PID 代表<ruby> 进程标识号 <rt> process identification </rt></ruby>，它在大多数操作系统内核（如 Linux、Unix、macOS 和 Windows）中使用。它是在操作系统中创建时自动分配给每个进程的唯一标识号。一个进程是一个正在运行的程序实例。
**建议阅读：** [如何查看 Apache Web 服务器在 Linux 中的运行时间](https://www.2daygeek.com/check-find-apache-httpd-web-server-uptime-linux/)
除了 init 进程外其他所有的进程 ID 每次都会改变，因为 init 始终是系统上的第一个进程，并且是所有其他进程的父进程。它的 PID 是 1。
PID 默认的最大值是 `32768`。可以在你的系统上运行 `cat /proc/sys/kernel/pid_max` 来验证。在 32 位系统上，`32768` 是最大值，但是我们可以在 64 位系统上将其设置为最大 2<sup> 22（约</sup> 4 百万）内的任何值。
你可能会问，为什么我们需要这么多的 PID？因为我们不能立即重用 PID，这就是为什么。另外为了防止可能的错误。
系统正在运行的进程的 PID 可以通过使用 `pidof`、`pgrep`、`ps` 和 `pstree` 命令找到。
### 方法 1：使用 pidof 命令
`pidof` 用于查找正在运行的程序的进程 ID。它在标准输出上打印这些 id。为了演示，我们将在 Debian 9（stretch）系统中找出 Apache2 的进程 ID。
```
# pidof apache2
3754 2594 2365 2364 2363 2362 2361
```
从上面的输出中，你可能会遇到难以识别进程 ID 的问题，因为它通过进程名称显示了所有的 PID（包括父进程和子进程）。因此，我们需要找出父 PID（PPID），这是我们要查找的。它可能是第一个数字。在本例中，它是 `3754`，并按降序排列。
### 方法 2：使用 pgrep 命令
`pgrep` 遍历当前正在运行的进程，并将符合选择条件的进程 ID 列到标准输出中。
```
# pgrep apache2
2361
2362
2363
2364
2365
2594
3754
```
这也与上面的输出类似，但是它将结果从小到大排序，这清楚地说明父 PID 是最后一个。在本例中，它是 `3754`。
**注意：** 如果你有多个进程的进程 ID，那么在使用 `pidof` 和 `pgrep` 识别父进程 ID 时就可能不会很顺利。
### 方法 3：使用 pstree 命令
`pstree` 将运行的进程显示为一棵树。树的根是某个 pid，如果省略了 pid 参数，那么就是 init。如果在 `pstree` 命令中指定了用户名，则显示相应用户拥有的所有进程。
`pstree` 会将相同的分支放在方括号中，并添加重复计数的前缀来可视化地合并到一起。
```
# pstree -p | grep "apache2"
|- apache2(3754) -|-apache2(2361)
| |-apache2(2362)
| |-apache2(2363)
| |-apache2(2364)
| |-apache2(2365)
| `-apache2(2594)
```
要单独获取父进程，请使用以下格式。
```
# pstree -p | grep "apache2" | head -1
|- apache2(3754) -|-apache2(2361)
```
`pstree` 命令非常简单，因为它分别隔离了父进程和子进程，但这在使用 `pidof` 和 `pgrep` 时命令不容易做到。
### 方法 4：使用 ps 命令
`ps` 显示活动进程的选择信息。它显示进程 ID（`pid`=PID）、与进程关联的终端（`tname`=TTY）、以 `[DD-]hh:mm:ss` 格式（`time`=TIME）显示的累计 CPU 时间、以及执行名（`ucmd` = CMD）。输出默认是未排序的。
```
# ps aux | grep "apache2"
www-data 2361 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start
www-data 2362 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start
www-data 2363 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start
www-data 2364 0.0 0.4 302652 9732 ? S 06:25 0:00 /usr/sbin/apache2 -k start
www-data 2365 0.0 0.4 302652 8400 ? S 06:25 0:00 /usr/sbin/apache2 -k start
www-data 2594 0.0 0.4 302652 8400 ? S 06:55 0:00 /usr/sbin/apache2 -k start
root 3754 0.0 1.4 302580 29324 ? Ss Dec11 0:23 /usr/sbin/apache2 -k start
root 5648 0.0 0.0 12784 940 pts/0 S+ 21:32 0:00 grep apache2
```
从上面的输出中，我们可以根据进程的启动日期轻松地识别父进程 ID（PPID）。在此例中，apache2 启动于 `Dec 11`，它是父进程，其他的是子进程。apache2 的 PID 是 `3754`。
---
via: <https://www.2daygeek.com/how-to-check-find-the-process-id-pid-ppid-of-a-running-program-in-linux/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么说 Python 和 Pygame 最适合编程初学者
|
Craig Oda
|
https://opensource.com/article/17/11/pygame
|
我们有三个理由来说明 Pygame 对初学编程者是最好的选择。
|
/data/attachment/album/201802/13/200646ffjgf8fhl8lf1oon.png.thumb.jpg
|
/data/attachment/album/201802/13/200646ffjgf8fhl8lf1oon.png
| true | false | true |
runningwater
| false |
[
"Pygame",
"Python",
"编程"
] |
观点
|
{
"viewnum": 9739,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
我们有三个理由来说明 Pygame 对初学编程者是最好的选择。
| 2018-02-16T10:05:00 | 2018-02-16T10:05:00 | 9,345 |
/article-9345-1.html
|
>
> 我们有三个理由来说明 Pygame 对初学编程者是最好的选择。
>
>
>
上个月，[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 发表了一篇标题为 [Mozilla 支出 50 万美元来支持开源项目](https://opensource.com/article/17/10/news-october-14)的文章。其中一个基于 HTML/JavaScript 的游戏平台项目 Phaser 获得了 50,000 美元的奖励。整整一年里，我都在使用 Phaser 平台来教我的小女儿，用来学习的话，它是最简单也是最好的 HTML 游戏开发平台。然而，对于初学者来说，使用 [Pygame](https://www.pygame.org/news) 也许效果更好。原因如下：
### 1、 小段代码块
Pygame，基于[计算机课程中最流行的语言](https://cacm.acm.org/blogs/blog-cacm/176450-python-is-now-the-most-popular-introductory-teaching-language-at-top-u-s-universities/fulltext) Python。Python 非常适合用一小段代码来实现我们的想法，孩子们可以从单个文件和单个代码块起开始学习，在掌握函数（function）或类（class）对象之前，就可以写出意大利面条似的代码。 很像手指画，所想即所得。
以这样的方式来学习，当编写的代码越来越难于管理的时候，孩子们很自然的就会把代码分解成函数模块和类模块。在学习函数之前就学习了 Python 语言的语法，学生将掌握基本的编程知识，对了解全局作用域和局部作用域起到更好的作用。
大多数 HTML 游戏在一定程度上会将结构、样式和编程逻辑分为 HTML、CSS 和 JavaScript，并且需要 CSS 和 HTML 的知识。从长远来看，虽然拆分更好，但对初学者来说是个障碍。一旦孩子们发现他们可以用 HTML 和 CSS 快速构建网页，很有可能就会被颜色、字体和图形的视觉刺激分散注意力。即使仅仅只专注于 JavaScript 代码，也需要学习基本的文档结构模型（DOM），以使 JavaScript 代码能够嵌入进去。
### 2、 全局变量更清晰
Python 和 JavaScript 都使用动态类型变量，这意味着变量只有在赋值才能确定其类型是一个字符串、一个整数还是一个浮点数，然而在 JavaScript 更容易出错。类似于类型变量，JavaScript 和 Python 都有全局变量和局部变量之分。Python 中，如果在函数块内要使用全局变量，就会以 `global` 关键字区分出来。
要理解在 Phaser 上教授编程初学者所面临的挑战的话，让我们以基本的[制作您的第一个 Phaser 游戏教程](http://phaser.io/tutorials/making-your-first-phaser-game)为例子，它是由 Alvin Ourrad 和 Richard Davey 开发制作的。在 JavaScript 中，程序中任何地方都可以访问的全局变量很难追踪调试，常常引起 Bug 且很难解决。因为 Richard 和 Alvin 是专业程序员，所以在这儿特意使用全局变量以使程序简洁。
```
var game = new Phaser.Game(800, 600, Phaser.AUTO, '', { preload: preload, create: create, update: update });
function preload() {
game.load.image('sky', 'assets/sky.png');
}
var player;
var platforms;
function create() {
game.physics.startSystem(Phaser.Physics.ARCADE);
...
```
在他们的 Phaser 编程手册 [《Interphase》](https://phaser.io/interphase) 中，Richard Davey 和 Ilija Melentijevic 解释说：在很多 Phaser 项目中通常都会使用全局变量，原因是使用它们完成任务更容易、更快捷。
>
> “如果您开发过游戏，只要代码量到一定规模，那么（使用全局变量）这种做法会使您陷入困境的，可是我们为什么还要这样做？原因很简单，仅仅只是要使我们的 Phaser 项目容易完成，更简单而已。”
>
>
>
针对一个 Phaser 应用程序，虽然可以使用局部变量和拆分代码块来达到关注点隔离这些手段来重构代码，但要使第一次学习编程的小孩能理解，显然很有难度的。
如果您想教你的孩子学习 JavaScript，或者如果他们已经知道怎样使用像 Python 来编程的话，有个好的 Phaser 课程推荐： [完整的手机游戏开发课程](https://academy.zenva.com/product/the-complete-mobile-game-development-course-platinum-edition/)，是由 [Pablo Farias Navarro](https://gamedevacademy.org/author/fariazz/) 开发制作的。虽然标题看着是移动游戏，但实际是关于 JavaScript 和 Phaser 的。JavaScript 和 Phaser 移动应用开发已经转移到 [PhoneGap](https://phonegap.com/) 话题去了。
### 3、 Pygame 无依赖要求
由于 [Python Wheels](https://pythonwheels.com/) 的出现，Pygame 超级[容易安装](https://pypi.python.org/pypi/Pygame)。在 Fedora/Red Hat 系统下也可使用 `yum` 包管理器来安装：
```
sudo yum install python3-pygame
```
更多信息请参考官网 [Pygame 安装说明文档](http://www.pygame.org/wiki/GettingStarted#Pygame%20Installation)。
相比来说，虽然 Phaser 本身更容易安装，但需要掌握更多的知识。前面提到的，学生需要在 HTML 文档中组装他们的 JavaScript 代码，同时还需要些 CSS。除了这三种语言（HTML、CSS、JavaScript），还需要使用火狐或谷歌开发工具和编辑器。JavaScript 最常用的编辑器有 Sublime、Atom、VS Code（按使用多少排序）等。
由于[浏览器同源策略](https://blog.chromium.org/2008/12/security-in-depth-local-web-pages.html)的原因，如果您直接在浏览器中打开 HTML 文件的话，Phaser 应用是不会运行的。您必须运行 Web 服务，并通过服务访问这些文件。还好，对于大多数工程项目，可以不用在本地运行 Apache 服务，只需要运行一些轻量级的服务就可以，比如 [httpster](https://simbco.github.io/httpster/)。
### Phaser 和 JavaScript 的优势
JavaScript 和 Phaser 有着种种的不好，为什么我还继续教授他们？老实说，我考虑了很长一段时间，我在担心着学生学习<ruby> 变量申明提升 <rt> variable hoisting </rt></ruby>和变量作用域的揪心。我开发出基于 Pygame 和 Python 的课程，随后也开发出一涛基于 Phaser 的。最终，我决定使用 Pablo 预先制定的课程作为起点。
我转用 JavaScript 有两个原因。首先，JavaScript 已经成为正式应用的正式语言。除了 Web 应用外，也可使用于移动和服务应用方面。JavaScript 无处不在，其广泛应用于孩子们每天都能看到的应用中。如果他们的朋友使用 Javascript 来编程，他们很可能也会受影响而使用之。正如我看到了 JavaScript 背后的动力，所以深入研究了可编译成 JavaScript 的替代语言，主要是 Dart 和 TypeScript 两种。虽然我不介意额外的转换步骤，但还是最喜欢 JavaScript。
最后，我选择使用 Phaser 和 JavaScript 的组合，是因为我意识到上面那些问题在 JavaScript 可以被解决，仅仅只是一些工作量而已。高质量的调试工具和一些大牛们的工作使得 JavaScript 成为教育孩子编码的可用和有用的语言。
### 最后话题: Python 对垒 JavaScript
当家长问我使用的什么语言作为孩子的入门语言时，我会立即推荐 Python 和 Pygame。因为有成千上万的课程可选，而且大多数都是免费的。我为我的儿子选择了 Al Sweigart 的 [使用 Python 和 Pygame 开发游戏](https://inventwithpython.com/makinggames.pdf) 课程，同时也在使用 Allen B. Downey 的 [Python 编程思想：如何像计算机科学家一样思考](http://greenteapress.com/thinkpython/html/index.html)。在 Android 手机上可以使用 [Tom Rothame](https://github.com/renpytom) 的 [PAPT Pyame](https://github.com/renpytom/rapt-pygame-example) 来安装 Pygame 游戏。
尽管有我的建议, 我总是怀疑孩子们很快就会搬到 JavaScript。这没关系 —— JavaScript 是一门成熟的编程语言，有很多很多辅助工具。但有多年的帮助大儿子使用 Python 创建炫酷游戏经历的我，依然钟情于 Python 和 Pygame。
### 关于作者
Craig Oda —— 东京 Linux 用户组的首位总裁和共同创始人，奥莱理日本出版的《Linux 日文环境》的共同作者。在亚洲建立了第一个 ISP 的核心团队成员之一。一个大型 Linux 公司的产品管理及市场的前任副总裁。硅谷开发者关系咨询公司 Oppkey 的合作方。[更多](https://opensource.com/users/codetricity)
---
via: <https://opensource.com/article/17/11/pygame>
作者：[Craig Oda](https://opensource.com/users/codetricity) 译者：[runningwater](https://github.com/runningwater) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Ubuntu 上使用 ZFS 文件系统
|
Nick Congleton
|
https://www.maketecheasier.com/use-zfs-filesystem-ubuntu-linux/
|
在 Linux 系统上，有大量的文件系统可以使用，那么我们为什么还要尝试一个新的文件系统？它们都工作的很好，不是吗？但是它们并不完全相同，其中的一些文件系统具有非常突出的优点，例如 ZFS。
|
/data/attachment/album/201802/14/005211baxhkm3vax7a5h75.jpg.thumb.jpg
|
/data/attachment/album/201802/14/005211baxhkm3vax7a5h75.jpg
| true | false | true |
amwps290
| false |
[
"ZFS",
"RAID"
] |
技术
|
{
"viewnum": 13954,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 Linux 系统上，有大量的文件系统可以使用，那么我们为什么还要尝试一个新的文件系统？它们都工作的很好，不是吗？但是它们并不完全相同，其中的一些文件系统具有非常突出的优点，例如 ZFS。
| 2018-02-14T00:52:07 | 2018-02-14T00:52:07 | 9,346 |
/article-9346-1.html
|
在 Linux 系统上，有大量的[文件系统](https://www.maketecheasier.com/best-linux-filesystem-for-ssd/)可以使用，那么我们为什么还要尝试一个新的文件系统？它们都工作的很好，不是吗？但是它们并不完全相同，其中的一些文件系统具有非常突出的优点，例如 ZFS。
### 为什么选择 ZFS
ZFS 非常的优秀。这是一个真正现代的文件系统，内置的功能对于处理大量的数据很有意义。
现在，如果您正在考虑将 ZFS 用于您的超高速 NVMe SSD，这可能不是一个最佳选择。 它比别的文件系统要慢，不过，这完全没有问题， 它旨在存储大量的数据并保持安全。
ZFS 消除了建立传统 RAID 阵列（LCTT 译注：独立磁盘冗余阵列）的需要。 相反，您可以创建 ZFS 池，甚至可以随时将驱动器添加到这些池中。 ZFS 池的行为操作与 RAID 几乎完全相同，但功能内置于文件系统中。
ZFS 也可以替代 LVM （LCTT 译注：逻辑盘卷管理），使您能够动态地进行分区和管理分区，而无需处理底层的细节，也不必担心相关的风险。
这也是一个 CoW （LCTT 译注：写时复制）文件系统。 这里不会提及太多的技术性，这意味着 ZFS 可以保护您的数据免受逐渐损坏的影响。 ZFS 会创建文件的校验和，并允许您将这些文件回滚到以前的工作版本。
### 安装 ZFS
在 Ubuntu 上安装 ZFS 非常简单，但对于 Ubuntu LTS （LCTT 译注：长时间支持版本）和最新版本来说，这个过程稍有不同。
**Ubuntu 16.04 LTS**
```
sudo apt install zfs
```
**Ubuntu 17.04 及以后**
```
sudo apt install zfsutils
```
当你安装好程序后，可以使用 ZFS 提供的工具创建 ZFS 驱动器和分区。
### 创建池
在 ZFS 中，池大致相当于 RAID 。 它们很灵活且易于操作。
#### RAID0
RAID0 只是把你的硬盘集中到一个池子里面，就像一个巨大的驱动器一样。 它可以提高你的驱动器速度，（LCTT 译注：数据条带化后，并行访问，可以提高文件读取速度）但是如果你的驱动器有损坏，你可能会失丢失数据。
要使用 ZFS 实现 RAID0，只需创建一个普通的池。
```
sudo zpool create your-pool /dev/sdc /dev/sdd
```
#### RAID1（镜像）
您可以在 ZFS 中使用 `mirror` 关键字来实现 RAID1 功能。 RAID1 会创建一个一对一的驱动器副本。 这意味着您的数据一直在备份。 它也提高了性能。 当然，你将一半的存储空间用于了复制。
```
sudo zpool create your-pool mirror /dev/sdc /dev/sdd
```
#### RAID5/RAIDZ1
ZFS 将 RAID5 功能实现为 RAIDZ1。 RAID5 要求驱动器至少是 3 个。并允许您通过将备份奇偶校验数据写入驱动器空间的 1/n（n 是驱动器数），留下的是可用的存储空间。 如果一个驱动器发生故障，阵列仍将保持联机状态，但应尽快更换发生故障的驱动器（LCTT 译注：与原文翻译略有不同，原文是驱动器的数目是三的倍数，根据 wiki， RAID5 至少需要 3 块驱动器，也可以从下面的命令中猜测)。
```
sudo zpool create your-pool raidz1 /dev/sdc /dev/sdd /dev/sde
```
#### RAID6/RAIDZ2
RAID6 与 RAID5 几乎完全相同，但它至少需要四个驱动器。 它将奇偶校验数据加倍，最多允许两个驱动器损坏，而不会导致阵列关闭（LCTT 译注：这里也与原文略有出入，原文是驱动器的数目是四的倍数，根据 wiki ，RAID6 至少需要四个驱动器)。
```
sudo zpool create your-pool raidz2 /dev/sdc /dev/sdd /dev/sde /dev/sdf
```
#### RAID10（条带化镜像）
RAID10 旨在通过数据条带化提高存取速度和数据冗余来成为一个两全其美的解决方案。 你至少需要四个驱动器，但只能使用一半的空间。 您可以通过在同一个池中创建两个镜像来创建 RAID10 中的池（LCTT 译注：这里也与原文略有出入，原文是驱动器的数目是四的倍数，根据 wiki， RAID10 至少需要四个驱动器）。
```
sudo zpool create your-pool mirror /dev/sdc /dev/sdd mirror /dev/sde /dev/sdf
```
### 池的操作
还有一些管理工具，一旦你创建了你的池，你就必须使用它们来操作。 首先，检查你的池的状态。
```
sudo zpool status
```
#### 更新
当你更新 ZFS 时，你也需要更新你的池。 当您检查它们的状态时，您的池会通知您任何更新。 要更新池，请运行以下命令。
```
sudo zpool upgrade your-pool
```
你也可以更新全部池。
```
sudo zpool upgrade -a
```
#### 添加驱动器
您也可以随时将驱动器添加到池中。 告诉 `zpool` 池的名称和驱动器的位置，它会处理好一切。
```
sudo zpool add your-pool /dev/sdx
```
### 其它的一些想法
ZFS 会在您的池的根文件系统中创建一个目录。 您可以使用 GUI 文件管理器或 CLI 按名称浏览它们。
ZFS 非常强大，还有很多其它的东西可以用它来做，但这些都是基础。 这是一个优秀的存储负载文件系统，即使它只是一个用于文件的硬盘驱动器的 RAID 阵列。 ZFS 在 NAS 系统上也非常出色。
无论 ZFS 的稳定性和可靠性如何，在您的硬盘上实施新的功能时，最好备份您的数据。
---
via: <https://www.maketecheasier.com/use-zfs-filesystem-ubuntu-linux/>
作者：[Nick Congleton](https://www.maketecheasier.com/author/nickcongleton/) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
哪个 Linux 内核版本是 “稳定的”？
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/learn/2018/2/which-linux-kernel-version-stable
|
每次 Linus Torvalds 发布 一个新 Linux 内核的主线版本，几乎都会引起这种困惑，那就是到底哪个内核版本才是最新的“稳定版”？是新的那个 X.Y，还是前面的那个 X.Y-1.Z ？最新的内核版本是不是太“新”了？你是不是应该坚持使用以前的版本？
|
/data/attachment/album/201802/14/215211tx038x3zccrs3crx.jpg.thumb.jpg
|
/data/attachment/album/201802/14/215211tx038x3zccrs3crx.jpg
| true | false | true |
qhwdw
| false |
[
"内核",
"更新"
] |
技术
|
{
"viewnum": 22236,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
每次 Linus Torvalds 发布 一个新 Linux 内核的主线版本，几乎都会引起这种困惑，那就是到底哪个内核版本才是最新的“稳定版”？是新的那个 X.Y，还是前面的那个 X.Y-1.Z ？最新的内核版本是不是太“新”了？你是不是应该坚持使用以前的版本？
| 2018-02-14T21:52:00 | 2018-02-14T21:52:00 | 9,347 |
/article-9347-1.html
|
>
> Konstantin Ryabitsev 为你讲解哪个 Linux 内核版本可以被视作“稳定版”，以及你应该如何选择一个适用你的内核版本。
>
>
>
每次 Linus Torvalds 发布 [一个新 Linux 内核的主线版本](/article-9328-1.html)，几乎都会引起这种困惑，那就是到底哪个内核版本才是最新的“稳定版”？是新的那个 X.Y，还是前面的那个 X.Y-1.Z ？最新的内核版本是不是太“新”了？你是不是应该坚持使用以前的版本？
[kernel.org](https://www.kernel.org/) 网页上的信息并不会帮你解开这个困惑。目前，在该页面的最顶部，我们看到是最新稳定版内核是 4.15 — 但是在这个表格的下面，4.14.16 也被列为“<ruby> 稳定版 <rt> stable </rt></ruby>”，而 4.15 被列为“<ruby> 主线版本 <rt> mainline </rt></ruby>”，很困惑，是吧？
不幸的是，这个问题并不好回答。我们在这里使用“稳定”这个词有两个不同的意思：一是，作为最初发布的 Git 树的名字，二是，表示这个内核可以被视作“稳定版”，用在“生产系统”。
由于 Git 的分布式特性，Linux 的开发工作在许多 [不同的分叉仓库中](https://git.kernel.org/pub/scm/linux/kernel/git/) 进行。所有的 bug 修复和新特性也是首先由各个子系统维护者收集和准备的，然后提交给 Linus Torvalds，由 Linus Torvalds 包含进 [他自己的 Linux 树](https://git.kernel.org/torvalds/c/v4.15) 中，他的 Git 树被认为是 Git 仓库的 “master”。我们称这个树为 “主线” Linux 树。
### 候选发布版（RC）
在每个新的内核版本发布之前，它都要经过几轮的“候选发布”，它由开发者进行测试并“打磨”所有的这些很酷的新特性。基于他们这几轮测试的反馈，Linus 决定最终版本是否已经准备就绪。通常有 7 个每周预发布版本，但是，这个数字经常走到 -rc8，并且有时候甚至达到 -rc9 及以上。当 Linus 确信那个新内核已经没有问题了，他就制作最终发行版，我们称这个版本为“稳定版”，表示它不再是一个“候选发布版”。
### Bug 修复
就像任何一个由不是十全十美的人所写的复杂软件一样，任何一个 Linux 内核的新版本都包含 bug，并且这些 bug 必须被修复。Linux 内核的 bug 修复规则非常简单：所有修复必须首先进入到 Linus 的树。一旦主线仓库中的 bug 被修复后，它接着会被应用到内核开发社区仍在维护的已发布内核中。在它们被考虑回迁到已发布的稳定版本之前，所有的 bug 修复必须满足 [一套重要的标准](https://www.kernel.org/doc/html/latest/process/stable-kernel-rules.html) — 标准的其中之一是，它们 “必须已经存在于 Linus 的树中”。这是一个 [独立的 Git 仓库](https://git.kernel.org/stable/linux-stable/c/v4.14.16)，维护它的用途是回迁 bug 修复，而它也被称为“稳定”树 —— 因为它用于跟踪以前发布的稳定内核。这个树由 Greg Kroah-Hartman 策划和维护。
### 最新的稳定内核
因此，无论在什么时候，为了查看最新的稳定内核而访问 kernel.org 网站时，你应该去使用那个在大黄色按钮所说的“最新的稳定内核”。
但是，你可能会惊奇地发现 —— 4.15 和 4.14.16 都是稳定版本，那么到底哪一个更“稳定”呢？有些人不愿意使用 “.0” 的内核发行版，因为他们认为这个版本并不足够“稳定”，直到最新的是 ".1" 的为止。很难证明或者反驳这种观点的对与错，并且这两种观点都有赞成或者反对的理由，因此，具体选择哪一个取决于你的喜好。
一方面，任何一个进入到稳定树的发行版都必须首先被接受进入主线内核版本中，并且随后会被回迁到已发行版本中。这意味着内核的主线版本相比稳定树中的发行版本来说，总包含有最新的 bug 修复，因此，如果你想使用的发行版包含的“**已知 bug**”最少，那么使用 “.0” 的主线发行版是最佳选择。
另一方面，主线版本增加了所有很酷的新特性 —— 而新特性也给它们带来了**数量未知的“新 bug”**，而这些“新 bug”在老的稳定版中是**不会存在**的。而新的、未知的 bug 是否比旧的、已知的但尚未修复的 bug 更加令人担心呢？ —— 这取决于你的选择。不过需要说明的一点是，许多 bug 修复只对内核的主线版本进行了彻底的测试。当补丁回迁到旧内核时，它们**可能**会工作的很好，但是它们**很少**做与旧内核的集成测试工作。通常都假定，“以前的稳定版本”足够接近当前的确信可用于生产系统的主线版本。而实际上也确实是这样的，当然，这也更加说明了为什么选择“哪个内核版本更稳定”是件**非常困难**的事情了。
因此，从根本上说，我们并没有定量的或者定性的手段去明确的告诉你哪个内核版本更加稳定 —— 4.15 还是 4.14.16？我们能够做到的只是告诉你，它们具有“**不同的**稳定性”，（这个答案可能没有帮到你，但是，至少你明白了这些版本的差别是什么？）。
*学习更多的 Linux 的知识，可以通过来自 Linux 基金会和 edX 的免费课程 ["认识 Linux"](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 。*
---
via: <https://www.linux.com/blog/learn/2018/2/which-linux-kernel-version-stable>
作者：[KONSTANTIN RYABITSEV](https://www.linux.com/users/mricon) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
ncurses 入门指南
|
Jim Hall
|
http://www.linuxjournal.com/content/getting-started-ncurses
|
怎样使用 curses 来绘制终端屏幕？
|
/data/attachment/album/201802/14/232431itpppd60pa60ps4w.jpg.thumb.jpg
|
/data/attachment/album/201802/14/232431itpppd60pa60ps4w.jpg
| true | false | true |
leemeans
| false |
[
"curses",
"ncurses"
] |
软件开发
|
{
"viewnum": 22415,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9383,
"displayorder": 0
}
] |
怎样使用 curses 来绘制终端屏幕？
| 2018-02-16T00:20:00 | 2018-02-16T00:20:00 | 9,348 |
/article-9348-1.html
|
>
> 怎样使用 curses 来绘制终端屏幕？
>
>
>
虽然图形界面非常酷，但是不是所有的程序都需要点击式的界面。例如，令人尊敬的 Vi 编辑器在第一个 GUI 出现之前在纯文本终端运行了很久。
Vi 编辑器是一个在“文本”模式下绘制的<ruby> 面向屏幕 <rt> screen-oriented </rt></ruby>程序的例子。它使用了一个叫 curses 的库。这个库提供了一系列的编程接口来操纵终端屏幕。curses 库产生于 BSD UNIX，但是 Linux 系统通过 ncurses 库提供这个功能。
[要了解 ncurses “过去曾引起的风暴”，参见 [ncurses: Portable Screen-Handling for Linux](http://www.linuxjournal.com/article/1124), September 1, 1995, by Eric S. Raymond.]
使用 curses 创建程序实际上非常简单。在这个文章中，我展示了一个利用 curses 来在终端屏幕上绘图的示例程序。
### 谢尔宾斯基三角形
简单展示一些 curses 函数的一个方法是生成<ruby> 谢尔宾斯基三角形 <rt> Sierpinski's Triangle </rt></ruby>。如果你对生成谢尔宾斯基三角形的这种方法不熟悉的话，这里是一些产生谢尔宾斯基三角形的规则：
1. 设置定义三角形的三个点。
2. 随机选择任意的一个点 `(x,y)`。
然后：
1. 在三角形的顶点中随机选择一个点。
2. 将新的 `x,y` 设置为先前的 `x,y` 和三角顶点的中间点。
3. 重复（上述步骤）。
所以我按照这些指令写了这个程序，程序使用 curses 函数来向终端屏幕绘制谢尔宾斯基三角形：
```
/* triangle.c */
#include <curses.h>
#include <stdlib.h>
#include "getrandom_int.h"
#define ITERMAX 10000
int main(void)
{
long iter;
int yi, xi;
int y[3], x[3];
int index;
int maxlines, maxcols;
/* initialize curses */
initscr();
cbreak();
noecho();
clear();
/* initialize triangle */
maxlines = LINES - 1;
maxcols = COLS - 1;
y[0] = 0;
x[0] = 0;
y[1] = maxlines;
x[1] = maxcols / 2;
y[2] = 0;
x[2] = maxcols;
mvaddch(y[0], x[0], '0');
mvaddch(y[1], x[1], '1');
mvaddch(y[2], x[2], '2');
/* initialize yi,xi with random values */
yi = getrandom_int() % maxlines;
xi = getrandom_int() % maxcols;
mvaddch(yi, xi, '.');
/* iterate the triangle */
for (iter = 0; iter < ITERMAX; iter++) {
index = getrandom_int() % 3;
yi = (yi + y[index]) / 2;
xi = (xi + x[index]) / 2;
mvaddch(yi, xi, '*');
refresh();
}
/* done */
mvaddstr(maxlines, 0, "Press any key to quit");
refresh();
getch();
endwin();
exit(0);
}
```
让我一边解释一边浏览这个程序。首先，`getrandom_int()` 函数是我对 Linux 系统调用 `getrandom()` 的包装器。它保证返回一个正整数（`int`）值。（LCTT 译注：`getrandom()` 系统调用按照字节返回随机值到一个变量中，值是随机的，不保证正负，使用 `stdlib.h` 的 `random()` 函数可以达到同样的效果）另外，按照上面的规则，你应该能够辨认出初始化和迭代谢尔宾斯基三角形的代码。除此之外，我们来看看我用来在终端上绘制三角形的 curses 函数。
大多数 curses 程序以这四条指令开头。 `initscr()` 函数获取包括大小和特征在内的终端类型，并设置终端支持的 curses 环境。`cbreak()` 函数禁用行缓冲并设置 curses 每次只接受一个字符。`noecho()` 函数告诉 curses 不要把输入回显到屏幕上。而 `clear()` 函数清空了屏幕：
```
initscr();
cbreak();
noecho();
clear();
```
之后程序设置了三个定义三角的顶点。注意这里使用的 `LINES` 和 `COLS`，它们是由 `initscr()` 来设置的。这些值告诉程序在终端的行数和列数。屏幕坐标从 `0` 开始，所以屏幕左上角是 `0` 行 `0` 列。屏幕右下角是 `LINES - 1` 行，`COLS - 1` 列。为了便于记忆，我的程序里把这些值分别设为了变量 `maxlines` 和 `maxcols`。
在屏幕上绘制文字的两个简单方法是 `addch()` 和 `addstr()` 函数。也可以使用相关的 `mvaddch()` 和 `mvaddstr()` 函数可以将字符放到一个特定的屏幕位置。我的程序在很多地方都用到了这些函数。首先程序绘制三个定义三角的点并标记为 `'0'`，`'1'` 和 `'2'`：
```
mvaddch(y[0], x[0], '0');
mvaddch(y[1], x[1], '1');
mvaddch(y[2], x[2], '2');
```
为了绘制任意的一个初始点，程序做了类似的一个调用：
```
mvaddch(yi, xi, '.');
```
还有为了在谢尔宾斯基三角形递归中绘制连续的点：
```
mvaddch(yi, xi, '*');
```
当程序完成之后，将会在屏幕左下角（在 `maxlines` 行，`0` 列）显示一个帮助信息：
```
mvaddstr(maxlines, 0, "Press any key to quit");
```
注意 curses 在内存中维护了一个版本的屏幕显示，并且只有在你要求的时候才会更新这个屏幕，这很重要。特别是当你想要向屏幕显示大量的文字的时候，这样程序会有更好的性能表现。这是因为 curses 只能更新在上次更新之后改变的这部分屏幕。想要让 curses 更新终端屏幕，请使用 `refresh()` 函数。
在我的示例程序中，我选择在“绘制”每个谢尔宾斯基三角形中的连续点时更新屏幕。通过这样做，用户可以观察三角形中的每次迭代。（LCTT 译注：由于 CPU 太快，迭代过程执行就太快了，所以其实很难直接看到迭代过程）
在退出之前，我使用 `getch()` 函数等待用户按下一个键。然后我调用 `endwin()` 函数退出 curses 环境并返回终端程序到一般控制。
```
getch();
endwin();
```
### 编译和示例输出
现在你已经有了你的第一个 curses 示例程序，是时候编译运行它了。记住 Linux 操作系统通过 ncurses 库来实现 curses 功能，所以你需要在编译的时候通过 `-lncurses`来链接——例如：
```
$ ls
getrandom_int.c getrandom_int.h triangle.c
$ gcc -Wall -lncurses -o triangle triangle.c getrandom_int.c
```
（LCTT 译注：此处命令行有问题，`-lncurses` 选项在我的 Ubuntu 16.04 系统 + gcc 4.9.3 环境下，必须放在命令行最后，否则找不到库文件，链接时会出现未定义的引用。）
在标准的 80x24 终端运行这个 `triangle` 程序并没什么意思。在那样的分辨率下你不能看见谢尔宾斯基三角形的很多细节。如果你运行终端窗口并设置非常小的字体大小，你可以更加容易地看到谢尔宾斯基三角形的不规则性质。在我的系统上，输出如图 1。
*图 1. triangle 程序的输出*
虽然迭代具有随机性，但是每次谢尔宾斯基三角形的运行看起来都会很一致。唯一的不同是最初绘制到屏幕的一些点的位置不同。在这个例子中，你可以看到三角形开始的一个小圆点，在点 1 附近。看起来程序接下来选择了点 2，然后你可以看到在圆点和“2”之间的星号。并且看起来程序随机选择了点 2 作为下一个随机数，因为你可以看到在第一个星号和“2”之间的星号。从这里开始，就不能继续分辨三角形是怎样被画出来的了，因为所有的连续点都属于三角形区域。
### 开始学习 ncurses
这个程序是一个怎样使用 curses 函数绘制字符到屏幕的简单例子。按照你的程序的需要，你可以通过 curses 做得更多。在下一篇文章中，我将会展示怎样使用 curses 让用户和屏幕交互。如果你对于学习 curses 有兴趣，我建议你去读位于 <ruby> <a href="http://www.tldp.org"> Linux 文档计划 </a> <rt> Linux Documentation Project </rt></ruby>的 Pradeep Padala 写的 [NCURSES Programming HOWTO](http://tldp.org/HOWTO/NCURSES-Programming-HOWTO)。
### 关于作者
Jim Hall 是一个自由及开源软件的倡议者，他最有名的工作是 FreeDOS 计划，也同样致力于开源软件的可用性。Jim 是在明尼苏达州的拉姆齐县的首席信息官。
---
via: <http://www.linuxjournal.com/content/getting-started-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/) 荣誉推出
|
||
TLP 帮助我们的 Linux 机器节能省电
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/save-some-battery-on-our-linux-machines-with-tlp
|
TLP - Linux 高级电源管理 是一个小巧的命令行工具，它通过对 Linux 系统执行一些调整来真正帮助延长电池的使用寿命。
|
/data/attachment/album/201802/15/092727g08uuxsxz6exn0ll.jpg.thumb.jpg
|
/data/attachment/album/201802/15/092727g08uuxsxz6exn0ll.jpg
| true | false | true |
lujun9972
| false |
[
"电池",
"节能"
] |
分享
|
{
"viewnum": 16509,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "42.90.143.195",
"message": "我想问一下tlp和acpid冲突吗<br />\r\n以及他们有什么关系吗",
"username": "来自甘肃兰州的 Mobile Safari 14.0|iOS 14.3 用户",
"date": "2021-12-29T02:36:44"
}
] |
[] |
TLP - Linux 高级电源管理 是一个小巧的命令行工具，它通过对 Linux 系统执行一些调整来真正帮助延长电池的使用寿命。
| 2018-02-15T09:27:00 | 2018-02-15T09:27:00 | 9,349 |
/article-9349-1.html
|
我发现 Linux 下电池的寿命普遍要比 Windows 下要短。尽管如此，这可是 Linux，我们总会有有办法的。
现在来讲一下这个名叫 TLP 的小工具，它能帮你的设备省点电。
**TLP - Linux 高级电源管理** 是一个小巧的命令行工具，它通过对 Linux 系统执行一些调整来真正帮助延长电池的使用寿命。
```
sudo apt install tlp
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/install-tlp-in-linux.jpeg)
对于其他的发行版，你可以阅读其[官方网站](http://linrunner.de/en/tlp/docs/tlp-linux-advanced-power-management.html)上的指南。
安装完成之后，你只有在第一次的时候需要运行下面命令来启动 tlp。TLP 会在下次启动系统时自动运行。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/start-tlp-on-linux.jpeg)
现在 TLP 已经被启动起来了，而且已经设置好了节省电池所需要的默认配置。我们可以查看该配置文件。文件路径为 `/etc/default/tlp`。我们需要编辑该文件来修改各项配置。
配置文件中有很多选项，要启用某个选项的话只需要删除行首的 `#` 就行了。每个选项能够赋予什么值都有说明。下面是你可能会用到的选项：
* 自动休眠 USB 设备
* 设定启动时启用/禁用无线设备
* 降低硬盘转速
* 关闭无线设备
* 设置 CPU 以性能优先还是节能优先
### 结论
TLP 是一个超棒的工具，可以延长 Linux 系统的电池使用寿命。我个人的经验是使用 TLP 能延长至少 30-40% 的电池使用寿命。
---
via: <http://www.linuxandubuntu.com/home/save-some-battery-on-our-linux-machines-with-tlp>
作者：[LinuxAndUbuntu](http://www.linuxandubuntu.com) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
详解 Ubuntu 和 Arch Linux 双启动
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/dual-boot-ubuntu-and-arch-linux
|
Ubuntu 和 Arch Linux 双启动不像听起来那么容易，然而，我将使这个过程尽可能地简单明了。首先，我们需要安装 Ubuntu，然后安装 Arch Linux，因为配置 Ubuntu grub 更容易实现 Ubuntu 和 Arch Linux 双启动。
|
/data/attachment/album/201802/15/101149ye1nggmi9qy3rh4e.jpg.thumb.jpg
|
/data/attachment/album/201802/15/101149ye1nggmi9qy3rh4e.jpg
| true | false | true |
stevenzdg988
| false |
[
"双启动",
"Arch",
"Ubuntu"
] |
桌面应用
|
{
"viewnum": 10655,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Ubuntu 和 Arch Linux 双启动不像听起来那么容易，然而，我将使这个过程尽可能地简单明了。首先，我们需要安装 Ubuntu，然后安装 Arch Linux，因为配置 Ubuntu grub 更容易实现 Ubuntu 和 Arch Linux 双启动。
| 2018-02-15T10:11:48 | 2018-02-15T10:11:48 | 9,350 |
/article-9350-1.html
|
Ubuntu 和 Arch Linux 双启动不像听起来那么容易，然而，我将使这个过程尽可能地简单明了。首先，我们需要安装 Ubuntu，然后安装 Arch Linux，因为配置 Ubuntu grub 更容易实现 Ubuntu 和 Arch Linux 双启动。
### Ubuntu 和 Arch Linux 双启动
你需要准备好以下内容：
1、你需要准备你所选择的 Ubuntu 的特色版本，在这个例子中，我将使用 Ubuntu 17.10 ISO 2、两个优盘 3、Windows 或者 Linux 操作系统的 PC 机 4、Arch Linux ISO 5、基于 Windows 的 Rufus 或是基于 Linux 发行版的 etcher 的两款软件中的一种，要根据自己的系统类型来选择哦。
### 安装 Ubuntu
首先, 利用 Rufus 为 Ubuntu 和 Arch Linux [创建可启动的闪存驱动器](http://www.linuxandubuntu.com/home/etcher-burn-images-to-sd-card-make-bootable-usb)。另外，也可以使用 `etcher` 创建 Ubuntu 和 Arch Linux 的可启动闪存驱动器。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/bootable-ubuntu-usb-etcher-image-writer_orig.jpg)
为 Ubuntu 选择 ISO 映像文件，然后选择闪存驱动器，然后单击 `Flash!` 创建可引导的闪存驱动器。等到它完成，瞧！你的可启动闪存驱动器已经准备好使用了。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/make-ubuntu-usb-bootable-in-linux_orig.jpg)
打开你的机器并使用载有 Ubuntu 安装媒体的可启动闪存驱动器进行启动。确保引导到 UEFI 或 BIOS 兼容模式，这取决于您所使用的 PC 的类型。我更喜欢使用 UEFI 来构建新的 PC。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/live-ubuntu-boot_orig.jpg)
在成功启动后，您将看到如上图显示，要求您尝试 Ubuntu 或安装 Ubuntu，选择安装 Ubuntu。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/install-usb-from-live-usb_orig.jpg)
然后检查安装第三方软件的图形和 WiFi 硬件、MP3 和其他媒体。如果你有一个互联网连接，你可以选择在安装 Ubuntu 的时候下载更新，因为它会节省安装时间，并且确保安装的是最新更新。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/custom-partition-hd-install-ubuntu_orig.jpg)
然后选择点击“Something else”，这样我们就可以对硬盘进行分区，并预留出 Ubuntu 和 Archlinux 的分区以及它们的交换分区的空间。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/create-swap-partition-ubuntu_orig.jpg)
创建一个交换分区。最好是内存的一半大小。在我的例子中，我有 1 GB 的内存，因此创建一个 512 MB 的交换空间。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/install-ubuntu-root-partition_orig.jpg)
然后创建挂载点为 `/` 的分区，并且点击“Install Now”按钮。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/select-ubuntu-timezone_orig.jpg)
接下来选择你的位置以选择语言和键盘设置。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/install-ubuntu-select-location-keyboard-layout_orig.jpg)
然后创建新用户的用户凭据。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/create-username-system-name-ubuntu-install_orig.jpg)
点击“Next”开始安装。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/ubuntu-installation-finishing_orig.jpg)
当安装完成后点击“Restart Now”重启 PC。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/ubuntu-installation-finished_orig.jpg)
移除安装媒介，按下回车继续。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/remove-installation-media-after-ubuntu_orig.jpg)
在确认成功安装后，重新启动并利用 Arch Linux 安装媒介引导。
### 安装 Arch Linux
在引导到 Arch Linux 安装媒体时，您应该看到如下所示的初始屏幕。选择 “Boot Arch Linux(x86\_64)”。注意 Arch Linux 更类似于一种 [DIY](http://www.linuxandubuntu.com/home/arch-linux-take-your-linux-knowledge-to-next-level-review)（自我定制）的操作系统。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/arch-linux-installation-boot-menu_orig.jpg)
选择之后，它将打开一个`tty1`终端，您将使用它来安装操作系统。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/arch-linux-tty1-linux_orig.png)
注意：为了成功安装 Arch Linux，您需要一个互联网连接来下载一些必须的系统安装包。所以我们需要检查一下互联网是否运行正常。输入以下命令到终端以检查网络连接。
```
ping linuxandubuntu.com -c 4
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/arch-linux-ping-check-internet-connection_orig.png)
如果互联网运行正常，你应该得到一个回显，显示发送和接收的数据包的数量。在这种情况下，我们发送了 4 个包，并得到了 4 个反馈，这意味着连接是正常的。
如果想在 Arch Linux 中设置 Wifi，请阅读[本文](http://www.linuxandubuntu.com/home/how-to-setup-a-wifi-in-arch-linux-using-terminal)以在 Arch Linux 中配置 Wifi。 接下来，我们需要选择之前在安装 Ubuntu 时预留出的空闲分区。
```
fdisk -l
```
上面的命令应该显示可用的磁盘分区在哪里。您应该能看到 Ubuntu 分区以及预留的空闲空间。我们将使用 `cfdisk`命令进行分区。
```
cfdisk
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/install-arch-partition-disk-with-cfdisk_orig.png)
执行命令后将看到分区情况。选择其它已分配分区下面的空闲空间。
您需要选择 “New”，然后输入分区大小。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/partition-free-space-swap-arch-linux_orig.png)
例如，9.3G - G 表示千兆字节。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/install-arch-linux-partition_orig.png)
如下图所示，选择“primary”进行分区
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/make-arch-linux-root-as-primary-partition_orig.png)
然后选择写分区条目。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/select-partition-to-install-arch_orig.png)
键入“yes”，以确认写入分区表。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/install-arch-linux-confirm-create-partition_orig.png)
然后选择 “Quit”（退出）选项。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/quit-cfdisk-arch-linux_orig.png) 然后键入：
```
fdisk -l
```
确认修改。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/confirm-partition-changes_orig.png)
然后使用磁盘分区命令：
```
mkfs.ext4 /dev/sda3
```
确保您选择的分区是我们创建的最后一个分区，这样我们就不会破坏 Ubuntu 分区。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/complete-arch-linux-installation-partition_orig.png)
然后使用以下命令安装这个分区：
```
mount /dev/sda3 /mnt
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/mount-base-partition-in-arch-linux.png)
用下面命令创建“home”目录：
```
mkdir .mnt/home
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/mount-home-partition-arch-linux.png)
用以下命令安装“home”目录到这个分区上：
```
mount /dev/sda3 /mnt/home
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/make-mount-home-directory.png)
现在使用以下命令安装 Archlinux 的基本系统：
```
pacstrap /mnt base
```
请确保网络连接正常。
接下来开始下载和配置安装所用时间取决于你的网速。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/install-arch-linux-base.png)
这一步骤完成后，将完成 Archlinux 基本安装。
Arch Linux 基础系统安装完成后，使用以下命令创建一个 `fstab` 文件：
```
genfstab -U /mnt >> /mnt/etc/fstab
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/create-fstab-file-in-arch-linux.png)
在此之后，您需要验证`fstab`文件，使用下面命令:
```
cat /mnt/etc/fstab
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/cat-fstab-file-data-terminal.png)
### 配置 Arch Linux 的基础配置
您将需要在安装时配置以下内容：
1. 系统语言和系统语言环境
2. 系统时区
3. Root 用户密码
4. 设置主机名
首先，您需要使用以下命令将`root`切换为新安装的基础系统用户：
```
arch-chroot /mnt
```
#### 1. 系统语言和系统语言环境
然后必须配置系统语言。必须取消对 en\_Utf-8 UTF-8的注释，并加载到文件 `/etc/local.gen` 中。
键入：
```
nano /etc/local.gen
```
然后将 en\_UTF-8 UTF-8 取消注释。
键入命令：
```
locale-gen
```
生成本地化设置如下：
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/generate-localization-arch-linux.png)
相应的需要在 `locale.conf` 文件中配置 LANG 变量。例如：
```
nano /etc/locale.conf
```
修改为：
```
LANG=en_US.UTF-8
```
配置键盘布局，则在文件 `vconsole.conf` 中进行更改，如下操作：
```
nano /etc/vconsole.conf
```
修改为：
```
KEYMAP=us-eng
```
#### 2. 系统时区
配置时区需要利用以下命令实现：
```
ln -sf /usr/share/zoneinfo/Region/City /etc/localtime
```
要查看可用时区，可以在终端使用以下命令：
注意可选时区在屏幕截图中显示为蓝色：
```
ls /usr/share/zoneinfo
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/setup-zonefile-in-arch-linux.png)
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/setup-country-zonefile_orig.png)
运行 `hwclock` 命令来生成 `/etc/adjtime`（假设硬件时钟被设置为 UTC）：
```
# hwclock --systohc
```
#### 3. 配置 root 用户密码
要为 Arch Linux 系统用户 root 设置密码，请使用：
```
passwd
```
为 root 用户提供一个新的密码并确认密码使其生效。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/setup-arch-linux-root-password.png)
#### 4. 配置主机名和网络
需要创建主机名文件：
```
nano /etc/hostname
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/set-arch-linux-hostname.png)
将名字更改为您的用户名:
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/set-arch-linux-username.png)
然后向主机添加一个匹配的条目：
```
nano /etc/hosts
```
```
127.0.0.1 localhost.localdomain localhost
::1 localhost.localdomain localhost
127.0.1.1 LinuxandUbuntu.localdomain LinuxandUbuntu
```
您需要使网络保持连接，然后使用：
```
systemctl enable dhcpd
```
#### 配置 Grub
然后重启机器，进入 Ubuntu 配置 grub。
你可以键入：
```
reboot
```
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/reboot-system-after-arch-linux-installation.png)
Arch Linux 仍然没有出现，因此我们需要在 Ubuntu 中使用 `update-grub` 来安装它。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/ubuntu-grub-menu.png)
在Ubuntu中打开终端，输入:
```
sudo update-grub
```
这将更新 grub，添加 Arch Linux 记录。
### 小结
祝贺您成功地将 Ubuntu 和 Arch Linux 设置为双引导。Ubuntu 安装很简单，但是 Arch Linux 安装对新的 Linux 用户来说是一个挑战。我试着让这个教程变得简单。但是如果你对这篇文章有任何疑问，请在评论部分告诉我。还可以与您的朋友分享这篇文章，并帮助他们学习 Linux。
---
via: <http://www.linuxandubuntu.com/home/dual-boot-ubuntu-and-arch-linux>
作者：[LinuxAndUbuntu](http://www.linuxandubuntu.com) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
谨慎使用 Linux find 命令
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3233305/linux/using-the-linux-find-command-with-caution.html
|
当使用 Linux 下的 find 命令时，请使用 -ok 选项来避免文件被意外删除，这个选项会在移除任何文件之前都会请求你的许可。
|
/data/attachment/album/201802/15/184844iwhl7fwuph7zlvwv.jpg.thumb.jpg
|
/data/attachment/album/201802/15/184844iwhl7fwuph7zlvwv.jpg
| true | false | true |
geekpi
| false |
[
"find"
] |
技术
|
{
"viewnum": 11546,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
当使用 Linux 下的 find 命令时，请使用 -ok 选项来避免文件被意外删除，这个选项会在移除任何文件之前都会请求你的许可。
| 2018-02-15T18:48:41 | 2018-02-15T18:48:41 | 9,351 |
/article-9351-1.html
|
>
> 当使用 Linux 下的 find 命令时，请使用 -ok 选项来避免文件被意外删除，这个选项会在移除任何文件之前都会请求你的许可。
>
>
>
最近有朋友提醒我有一个有用的选项来更加谨慎地运行 `find` 命令，它就是 `-ok`。除了一个重要的区别之外，它的工作方式与 `-exec` 相似，它使 `find` 命令在执行指定的操作之前请求权限。
这有一个例子。如果你使用 `find` 命令查找文件并删除它们，你可能使用的是下面的命令：
```
$ find . -name runme -exec rm {} \;
```
在当前目录及其子目录中中任何名为 “runme” 的文件都将被立即删除 —— 当然，你要有权限删除它们。改用 `-ok` 选项，你会看到类似这样的东西，但 `find` 命令将在删除文件之前会请求权限。回答 `y` 代表 “yes” 将允许 `find` 命令继续并逐个删除文件。
```
$ find . -name runme -ok rm {} \;
< rm ... ./bin/runme > ?
```
### -execdir 命令也是一个选择
另一个可以用来修改 `find` 命令行为，并可能使其更可控的选项是 `-execdir` 。`-exec` 会运行指定的任何命令，而 `-execdir 则从文件所在的目录运行指定的命令，而不是在运行`find` 命令的目录运行指定的命令。这是两个它的例子：
```
$ pwd
/home/shs
$ find . -name runme -execdir pwd \;
/home/shs/bin
```
```
$ find . -name runme -execdir ls \;
ls rm runme
```
到现在为止还挺好。但要记住的是，`-execdir` 也会在匹配文件的目录中执行该命令。如果运行下面的命令，并且目录包含一个名为 “ls” 的文件，那么即使该文件*没有*执行权限，它也将运行该文件。使用 `-exec` 或 `-execdir` 类似于通过 `source` 来运行命令。
```
$ find . -name runme -execdir ls \;
Running the /home/shs/bin/ls file
```
```
$ find . -name runme -execdir rm {} \;
This is an imposter rm command
```
```
$ ls -l bin
total 12
-r-x------ 1 shs shs 25 Oct 13 18:12 ls
-rwxr-x--- 1 shs shs 36 Oct 13 18:29 rm
-rw-rw-r-- 1 shs shs 28 Oct 13 18:55 runme
```
```
$ cat bin/ls
echo Running the $0 file
$ cat bin/rm
echo This is an imposter rm command
```
### -okdir 选项也会请求权限
要更谨慎，可以使用 `-okdir` 选项。类似 `-ok`，该选项将请求权限来运行该命令。
```
$ find . -name runme -okdir rm {} \;
< rm ... ./bin/runme > ?
```
你也可以小心地指定你想用的命令的完整路径，以避免像上面那样的冒牌命令出现的任何问题。
```
$ find . -name runme -execdir /bin/rm {} \;
```
`find` 命令除了默认打印之外还有很多选项，有些可以使你的文件搜索更精确，但谨慎一点总是好的。
在 [Facebook](https://www.facebook.com/NetworkWorld/) 和 [LinkedIn](https://www.linkedin.com/company/network-world) 上加入 Network World 社区来进行评论。
---
via: <https://www.networkworld.com/article/3233305/linux/using-the-linux-find-command-with-caution.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 译者：[geekpi](https://github.com/geekpi) 校对：[Locez](https://github.com/locez)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 上安装和使用 Docker
|
Jack Wallen
|
https://www.linux.com/learn/intro-to-linux/2017/11/how-install-and-use-docker-linux
|
Docker 使得创建、部署，和管理容器变得特别简单。更好的是，安装和使用 Docker 在 Linux 平台上特别的方便。
|
/data/attachment/album/201802/15/190609ee2ru2cduc5puinu.jpg.thumb.jpg
|
/data/attachment/album/201802/15/190609ee2ru2cduc5puinu.jpg
| true | false | true |
lujun9972
| false |
[
"Docker"
] |
系统运维
|
{
"viewnum": 22355,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Docker 使得创建、部署，和管理容器变得特别简单。更好的是，安装和使用 Docker 在 Linux 平台上特别的方便。
| 2018-02-15T19:06:07 | 2018-02-15T19:06:07 | 9,352 |
/article-9352-1.html
|
容器现在风靡于 IT 界 —— 这很好理解。容器是轻量级的，包含应用运行所需所有东西（代码、库、运行时环境、系统设置，以及依赖关系）的独立的包。每个容器都部署于它自己的 CPU、内存、块 I/O，以及网络资源上，所有这些都不依赖于某个内核和操作系统。这也是容器与虚拟机之间最大的不同；相比之下，虚拟机是一个运行于宿主机操作系统上的完整的操作系统平台，而容器不是。
容器允许你以一种前所未有的方式扩展交付能力（不管内部还是外部的）。例如，你可以快速部署多个 NGINX 实例（甚至可以应用于多个不同的阶段 —— 比如开发和生产阶段）。跟虚拟机不同，容器不会消耗太多系统资源。
[Docker](https://www.docker.com/) 使得创建、部署，和管理容器变得特别简单。更好的是，安装和使用 Docker 在 Linux 平台上特别的方便。
我将会向你演示在 Linux 上安装 Docker 是多么方便，同时带你入门 Docker。我的演示平台是 [Ubuntu 16.04 Server](http://releases.ubuntu.com/16.04/)，但流程在大多数其它 Linux 平台都差不多。
我这里假设你已经启动了 Ubuntu Server 16.04。
### 安装
由于 Ubuntu Server 16.04 缺少图形界面，我会完全通过命令行来安装和使用 Docker。在你安装前，你需要更新 `apt` 然后进行必要的升级。一定要注意，若系统内核升级了，你会需要重启系统。因此最好挑个服务器能重启的时间进行。
运行下面命令更新 `apt`：
```
sudo apt update
```
完成后，使用命令升级系统：
```
sudo apt upgrade
```
若内核升级了，你需要用下面命令重启服务器：
```
sudo reboot
```
若内核没有升级，你就可以安装 Docker 了（无需重启）。安装 Docker 的命令为：
```
sudo apt install docker.io
```
若你使用的是其它 Linux 发行版，当尝试用相应的包管理器来安装时却发现没有 `docker.io` 包，则你应该安装 `docker` 包。例如，在 [Fedora](https://getfedora.org/) 上安装应该用命令：
```
sudo dnf install docker
```
若你使用的是 CentOS 7，那么最好使用安装脚本来安装 docker。首先使用命令 `sudo yum check-update` 更新系统。升级完后，输入下面命令来下载并运行所需的脚本：
```
curl -fsSL https://get.docker.com/ | sh
```
默认情况下，只有管理员权限能够运行 docker 命令。考虑到安全问题，你不会想用 root 用户或使用 `sudo` 来运行 Docker 的。要解决这个问题，你需要将自己的用户加入到 docker 组中。命令如下：
```
sudo usermod -a -G docker $USER
```
完成操作后，登出系统然后再重新登录，应该就搞定了。不过若你的平台是 Fedora，则添加用户到 docker 组时会发现这个组是不存在的。那该怎么办呢？你需要首先创建这个组。命令如下：
```
sudo groupadd docker && sudo gpasswd -a ${USER} docker && sudo systemctl restart docker
newgrp docker
```
登出后再登录。就可以开始用 Docker 了。
### 启动，暂停以及启用 Docker
安装好 Docker 后，你可以让系统在启动时自动启动 Docker 守护进程。使用下面两个命令来实现这一点：
```
sudo systemctl start docker
sudo systemctl enable docker
```
若需要暂停或重启 Docker 守护进程，则命令为：
```
sudo systemctl stop docker
sudo systemctl restart docker
```
现在可以用 Docker 来部署容器了。
### 拉取镜像
对 Docker 来说，镜像是构建容器的基石。你可以拉下一个镜像（比如 [NGINX](https://www.nginx.com/)）然后根据这个镜像部署任意多个容器出来。使用镜像前，你首先需要把镜像拉取到系统中。镜像从注册仓库中拉取，默认情况下安装好的 Docker 包含了一个默认的注册仓库 [Docker Hub](https://hub.docker.com/) —— 这个注册仓库包含了大量别人所贡献的镜像（既包括官方的镜像，也包括用户自己贡献的镜像）。
假设你想要拉取一个 Nginx Web 服务器相关的镜像。在开始拉取前，先检查一下系统中已经有了哪些镜像。输入 `docker images` 命令你会发现现在还没有镜像存在（图 1）。
*图 1：还没有镜像。*
让我们来拉取一个镜像。使用下面命令可以从 Docker Hub 中下载 Nginx 镜像：
```
docker pull nginx
```
上面命令会从 Docker Hub 下载最新的（官方的） Nginx 镜像。现在再运行 `docker images` 命令就能看到有列出镜像了（图 2）。
*图 2：NGINX 镜像已经被拉取下来了。*
注意到我这里说的是“官方” Nginx 镜像了吗？在 Docker Hub 上有很多的非官方 Nginx 镜像。这些非官方镜像都是基于各种不同的目的而创建出来的。你可以使用下面过命令来搜索 Docker Hub 中的所有 Nginx 镜像：
```
docker search nginx
```
你会发现（图 3 中），有很多基于不同目的所创建的 Nginx 镜像（反向代理、PHP-FPM（LCTT 译注：<ruby> FastCGI 进程管理器 <rt> FastCGI Process Manager </rt></ruby>是一个 PHPFastCGI 管理器，旨在将 FastCGI 进程管理整合进 PHP 包中）功能、LetsEncrypt（LCTT 译注：由 ISRG 提供的免费 SSL 项目），Bitnami，在树莓派上使用的 Nginx 和 Drupal，等等很多很多)。
*图 3：Docker Hub 上找到的各种 NGINX 镜像。*
假设，你想要下载内建有反向代理功能的 Nginx 镜像，有个非官方的镜像 jwilder/nginx-proxy。因此输入下面命令来拉取这个镜像：
```
docker pull jwilder/nginx-proxy
```
再输入 `docker images` 命令来查看新拉下来的这个镜像（图 4）。
*图 4：已经有了两种不同的 NGINX 镜像了。*
处于谨慎考虑，我建议只使用官方镜像，毕竟你无法确定非官方镜像是否包含了恶意代码。
有了镜像后就可以用它来部署容器了。下次我们再聊聊如何通过这些 Nginx 镜像来发布容器。
Docker 是一个超级强力的系统可以让你的工作更简单，让你的公司更具有伸缩性，也更灵活。想知道 Docker 还能做什么，运行 `man docker` 然后阅读它的帮助文档吧。
---
via: <https://www.linux.com/learn/intro-to-linux/2017/11/how-install-and-use-docker-linux>
作者：[Jack Wallen](https://www.linux.com/users/jlwallen) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我是被 “root@notty” 黑了吗？
|
Sysadminworld
|
http://www.sysadminworld.com/2011/ps-aux-shows-sshd-rootnotty/
|
当你在 ps aux 的输出中看到 sshd：root@notty 时会觉得很奇怪吧，notty 算是哪门子的主机，是不是黑客计算机的名字啊。
|
/data/attachment/album/201802/16/201244lhzdhhc99jtjn90n.jpg.thumb.jpg
|
/data/attachment/album/201802/16/201244lhzdhhc99jtjn90n.jpg
| true | false | true |
lujun9972
| false |
[
"tty",
"ps"
] |
技术
|
{
"viewnum": 14133,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
当你在 ps aux 的输出中看到 sshd：root@notty 时会觉得很奇怪吧，notty 算是哪门子的主机，是不是黑客计算机的名字啊。
| 2018-02-16T20:12:50 | 2018-02-16T20:12:50 | 9,353 |
/article-9353-1.html
|
当你在 `ps aux` 的输出中看到 `sshd：root@notty` 时会觉得很奇怪吧，`notty` 算是哪门子的主机，是不是黑客计算机的名字啊。不过不用担心；`notty` 仅仅是表示 没有 tty 而已。
当你在本地登录 Linux 机器时，登录终端会在进程列表中显示为 `tty`（ 比如，tty7）。若你通过 ssh 登录一台远程服务器，则会看到类似 `root@pts/0` 这样的东西。
而若某个连接是由 sftp 或者是由 scp 拷贝文件而创建的，则该连接会会显示成没有 tty （notty）。
如果你仍然想知道服务器上发生了什么事情，可以检查 `ps auxf` 的输出来查看进程树，或者运行 `netstat -vatn` 来检查所有的 TCP 连接。
---
via: <http://www.sysadminworld.com/2011/ps-aux-shows-sshd-rootnotty/>
作者：[sysadminworld](http://www.sysadminworld.com) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux/Unix 之上绑定 ntpd 到特定的 IP 地址
|
Vivek Gite
|
https://www.cyberciti.biz/faq/how-to-bind-ntpd-to-specific-ip-addresses-on-linuxunix/
|
NTP 是网络时间协议的首字母简写，这是一个用来同步两台电脑之间时间的协议。ntpd 是一个操作系统守护进程，可以设置并且保证系统的时间与互联网标准时间服务器同步。
|
/data/attachment/album/201802/16/205909z7iy3yhnfineelif.jpg.thumb.jpg
|
/data/attachment/album/201802/16/205909z7iy3yhnfineelif.jpg
| true | false | true |
Drshu
| false |
[
"ntp"
] |
技术
|
{
"viewnum": 8220,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
NTP 是网络时间协议的首字母简写，这是一个用来同步两台电脑之间时间的协议。ntpd 是一个操作系统守护进程，可以设置并且保证系统的时间与互联网标准时间服务器同步。
| 2018-02-16T20:59:16 | 2018-02-16T20:59:16 | 9,354 |
/article-9354-1.html
|
默认的情况下，我们的 ntpd/NTP 服务器会监听所有的端口或者 IP 地址，也就是：`0.0.0.0:123`。 怎么才可以在一个 Linux 或是 FreeBSD Unix 服务器上，确保只监听特定的 IP 地址，比如 `localhost` 或者是 `192.168.1.1:123` ？
NTP 是<ruby> 网络时间协议 <rt> Network Time Protocol </rt></ruby>的首字母简写，这是一个用来同步两台电脑之间时间的协议。ntpd 是一个操作系统守护进程，可以设置并且保证系统的时间与互联网标准时间服务器同步。
NTP 使用 `/etc/directory` 之下的 `ntp.conf` 作为配置文件。
### /etc/ntp.conf 之中的端口指令
你可以通过设置端口命令来防止 ntpd 监听 `0.0.0.0:123`，语法如下：
```
interface listen IPv4|IPv6|all
interface ignore IPv4|IPv6|all
interface drop IPv4|IPv6|all
```
上面的配置可以使 `ntpd` 监听那个地址或者不出来任何请求而直接丢弃。`ignore` 会防止打开匹配的地址，`drop` 会导致 ntpd 打开该地址并丢弃所有接收到的包，而不做任何检查。举个例子，如果要忽略所有端口之上的监听，加入下面的语句到 `/etc/ntp.conf`：
```
interface ignore wildcard
```
如果只监听 127.0.0.1 和 192.168.1.1 则是这样：
```
interface listen 127.0.0.1
interface listen 192.168.1.1
```
这是我 FreeBSD 云服务器上的样例 `/etc/ntp.conf` 文件：
```
$ egrep -v '^#|$^' /etc/ntp.conf
```
样例输出为：
```
tos minclock 3 maxclock 6
pool 0.freebsd.pool.ntp.org iburst
restrict default limited kod nomodify notrap noquery nopeer
restrict -6 default limited kod nomodify notrap noquery nopeer
restrict source limited kod nomodify notrap noquery
restrict 127.0.0.1
restrict -6 ::1
leapfile "/var/db/ntpd.leap-seconds.list"
interface ignore wildcard
interface listen 172.16.3.1
interface listen 10.105.28.1
```
### 重启 ntpd
在 FreeBSD Unix 之上重新加载/重启 ntpd：
```
$ sudo /etc/rc.d/ntpd restart
```
或者 [在 Debian 和 Ubuntu Linux 之上使用下面的命令](https://www.cyberciti.biz/faq/restarting-ntp-service-on-linux/)：
```
$ sudo systemctl restart ntp
```
或者 [在 CentOS/RHEL 7/Fedora Linux 之上使用下面的命令](https://www.cyberciti.biz/faq/restarting-ntp-service-on-linux/)：
```
$ sudo systemctl restart ntpd
```
### 校验
使用 `netstat` 和 `ss` 命令来检查 ntpd 只绑定到了特定的 IP 地址：
```
$ netstat -tulpn | grep :123
```
或是：
```
$ ss -tulpn | grep :123
```
样例输出：
```
udp 0 0 10.105.28.1:123 0.0.0.0:* -
udp 0 0 172.16.3.1:123 0.0.0.0:* -
```
[在 FreeBSD Unix 服务器上使用 sockstat 命令](https://www.cyberciti.biz/faq/freebsd-unix-find-the-process-pid-listening-on-a-certain-port-commands/)：
```
$ sudo sockstat
$ sudo sockstat -4
$ sudo sockstat -4 | grep :123
```
样例输出：
```
root ntpd 59914 22 udp4 127.0.0.1:123 *:*
root ntpd 59914 24 udp4 127.0.1.1:123 *:*
```
---
作者是 nixCraft 的创始人并且是一位经验丰富的系统管理员、DevOps 工程师，也是一名 Linux 操作系统和 Unix shell 脚本的训练师。他为全球不同行业，包括 IT、教育业、安全防护、空间研究和非营利性组织的客户工作。关注他的 [Twitter](https://twitter.com/nixcraft), [Facebook](https://facebook.com/nixcraft), [Google+](https://plus.google.com/+CybercitiBiz)。
---
via: <https://www.cyberciti.biz/faq/how-to-bind-ntpd-to-specific-ip-addresses-on-linuxunix/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[Drshu](https://github.com/Drshu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用特殊权限：setuid、setgid 和 sticky 位
|
Egidio Docile
|
https://linuxconfig.org/how-to-use-special-permissions-the-setuid-setgid-and-sticky-bits
|
在某些情况下，使用特殊权限会非常有用。但如果使用不当，可能会引入严重的漏洞，因此使用之前请三思。
|
/data/attachment/album/201802/16/211924c1psmdn0b8szk19m.jpg.thumb.jpg
|
/data/attachment/album/201802/16/211924c1psmdn0b8szk19m.jpg
| true | false | true |
jessie-pang
| false |
[
"权限"
] |
技术
|
{
"viewnum": 10622,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 7460,
"displayorder": 0
},
{
"raid": 9200,
"displayorder": 1
}
] |
在某些情况下，使用特殊权限会非常有用。但如果使用不当，可能会引入严重的漏洞，因此使用之前请三思。
| 2018-02-16T21:19:38 | 2018-02-16T21:19:38 | 9,355 |
/article-9355-1.html
|
### 目标
了解特殊权限的工作原理，以及如何识别和设置它们。
### 要求
* [了解标准的 Unix / Linux 权限系统](/article-7460-1.html)
### 难度
简单
### 约定
* `#` - 要求直接以 root 用户或使用 `sudo` 命令执行指定的命令
* `$` - 用普通的非特权用户来执行指定的命令
### 介绍
通常，在类 Unix 操作系统上，文件和目录的所有权是基于文件创建者的默认 `uid`（user-id）和 `gid`（group-id）的。启动一个进程时也是同样的情况：它以启动它的用户的 `uid` 和 `gid` 运行，并具有相应的权限。这种行为可以通过使用特殊的权限进行改变。
### setuid 位
当使用 setuid （设置用户 ID）位时，之前描述的行为会有所变化，所以当一个可执行文件启动时，它不会以启动它的用户的权限运行，而是**以该文件所有者的权限运行**。所以，如果在一个可执行文件上设置了 setuid 位，并且该文件由 root 拥有，当一个普通用户启动它时，它将以 root 权限运行。显然，如果 setuid 位使用不当的话，会带来潜在的安全风险。
使用 setuid 权限的可执行文件的例子是 `passwd`，我们可以使用该程序更改登录密码。我们可以通过使用 `ls` 命令来验证：
```
ls -l /bin/passwd
-rwsr-xr-x. 1 root root 27768 Feb 11 2017 /bin/passwd
```
如何识别 `setuid` 位呢？相信您在上面命令的输出已经注意到，`setuid` 位是用 `s` 来表示的，代替了可执行位的 `x`。小写的 `s` 意味着可执行位已经被设置，否则你会看到一个大写的 `S`。大写的 `S` 发生于当设置了 `setuid` 或 `setgid` 位、但没有设置可执行位 `x` 时。它用于提醒用户这个矛盾的设置：如果可执行位未设置，则 `setuid` 和 `setgid` 位均不起作用。setuid 位对目录没有影响。
### setgid 位
与 `setuid` 位不同，`setgid` （设置组 ID）位对文件和目录都有影响。在第一个例子中，具有 `setgid` 位设置的文件在执行时，不是以启动它的用户所属组的权限运行，而是**以拥有该文件的组运行**。换句话说，进程的 `gid` 与文件的 `gid` 相同。
当在一个目录上使用时，`setgid` 位与一般的行为不同，它使得在所述目录内创建的文件，不属于创建者所属的组，而是属于父目录所属的组。这个功能通常用于文件共享（目录所属组中的所有用户都可以修改文件）。就像 setuid 一样，setgid 位很容易识别（我们用 test 目录举例）：
```
ls -ld test
drwxrwsr-x. 2 egdoc egdoc 4096 Nov 1 17:25 test
```
这次 `s` 出现在组权限的可执行位上。
### sticky 位
sticky （粘连）位的工作方式有所不同：它对文件没有影响，但当它在目录上使用时，所述目录中的所有文件只能由其所有者删除或移动。一个典型的例子是 `/tmp` 目录，通常系统中的所有用户都对这个目录有写权限。所以，设置 sticky 位使用户不能删除其他用户的文件：
```
$ ls -ld /tmp
drwxrwxrwt. 14 root root 300 Nov 1 16:48 /tmp
```
在上面的例子中，目录所有者、组和其他用户对该目录具有完全的权限（读、写和执行）。sticky 位在可执行位上用 `t` 来标识。同样，小写的 `t` 表示可执行权限 `x`也被设置了，否则你会看到一个大写字母 `T`。
### 如何设置特殊权限位
就像普通的权限一样，特殊权限位可以用 `chmod` 命令设置，使用数字或者 `ugo/rwx` 格式。在前一种情况下，`setuid`、`setgid` 和 `sticky` 位分别由数值 4、2 和 1 表示。例如，如果我们要在目录上设置 `setgid` 位，我们可以运行：
```
$ chmod 2775 test
```
通过这个命令，我们在目录上设置了 `setgid` 位（由四个数字中的第一个数字标识），并给它的所有者和该目录所属组的所有用户赋予全部权限，对其他用户赋予读和执行的权限（目录上的执行位意味着用户可以 `cd` 进入该目录或使用 `ls` 列出其内容）。
另一种设置特殊权限位的方法是使用 `ugo/rwx` 语法：
```
$ chmod g+s test
```
要将 `setuid` 位应用于一个文件，我们可以运行：
```
$ chmod u+s file
```
要设置 sticky 位，可运行：
```
$ chmod o+t test
```
在某些情况下，使用特殊权限会非常有用。但如果使用不当，可能会引入严重的漏洞，因此使用之前请三思。
---
via: <https://linuxconfig.org/how-to-use-special-permissions-the-setuid-setgid-and-sticky-bits>
作者：[Egidio Docile](https://linuxconfig.org) 译者：[jessie-pang](https://github.com/jessie-pang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux mkdir 命令的初学者教程
|
Himanshu Arora
|
https://www.howtoforge.com/linux-mkdir-command/
|
在这篇教程中，我将使用一些易于理解的例子来讲解这个工具的基本用法。
|
/data/attachment/album/201802/17/124700v1sssrbsovwoe18y.jpg.thumb.jpg
|
/data/attachment/album/201802/17/124700v1sssrbsovwoe18y.jpg
| true | false | true |
ucasFL
| false |
[
"mkdir",
"目录"
] |
技术
|
{
"viewnum": 21394,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇教程中，我将使用一些易于理解的例子来讲解这个工具的基本用法。
| 2018-02-17T12:47:08 | 2018-02-17T12:47:08 | 9,356 |
/article-9356-1.html
|
当你使用命令行的时候，无论什么时候，你都位于一个目录中，它告诉了命令行当前所位于的完整目录。在 Linux 中，你可以使用 [rm](/article-9321-1.html) 命令删除目录，但是首先，你需要使用 `mkdir` 命令来创建目录。在这篇教程中，我将使用一些易于理解的例子来讲解这个工具的基本用法。
在开始之前，值得一提的是，这篇教程中的所有例子都已经在 Ubuntu 16.04 LTS 中测试过。
### Linux mkdir 命令
正如上面所提到的，用户可以使用 `mkdir` 命令来创建目录。它的语法如下：
```
mkdir [OPTION]... DIRECTORY...
```
下面的内容是 man 手册对这个工具的描述：
>
> 如果目录还不存在，则创建之。
>
>
>
下面这些 Q&A 式的例子将能够帮助你更好的理解 `mkdir` 这个命令是如何工作的。
### Q1. 如何使用 `mkdir` 命令创建目录？
创建目录非常简单，你唯一需要做的就是把你想创建的目录的名字跟在 `mkdir` 命令的后面作为参数。
```
mkdir [dir-name]
```
下面是一个简单例子：
```
mkdir test-dir
```
### Q2. 如何确保当父目录不存在的时候，同时创建父目录？
有时候，我们需要使用一条 `mkdir` 命令来创建一个完整的目录结构，这时候，你只需要使用 `-p` 这个命令行选项即可。
比如，你想创建目录 `dir1/dir2/dir3`，但是，该目录的父目录都不存在，这时候，你可以像下面这样做：
```
mkdir -p dir1/dir2/dir3
```
[](https://www.howtoforge.com/images/command-tutorial/big/mkdir-p.png)
### Q3. 如何在创建目录时自定义权限？
默认情况下，`mkdir` 命令创建目录时会把权限设置为 `rwx, rwx, r-x` 。
[](https://www.howtoforge.com/images/command-tutorial/big/mkdir-def-perm.png)
但是，如果你想自定义权限，那么你可以使用 `-m` 这一命令行选项。
[](https://www.howtoforge.com/images/command-tutorial/big/mkdir-custom-perm.png)
### Q4. 如何使 `mkdir` 命令显示操作细节？
如果你希望 `mkdir` 命令显示它所执行的操作的完整细节，那么你可以使用 `-v` 这一命令行选项。
```
mkdir -v [dir]
```
下面是一个例子：
[](https://www.howtoforge.com/images/command-tutorial/big/mkdir-verbose.png)
### 结论
你已经看到，`mkdir` 是一个非常简单，易于理解和使用的命令。学习这一命令不会遇到任何屏障。在这篇教程中，我们讨论到了它的绝大部分命令行选项。记得练习这些命令，并在日复一日的工作中使用这些命令。如果你想了解关于这一命令的更过内容，请查看它的 [man](https://linux.die.net/man/1/mkdir) 手册。
---
via: <https://www.howtoforge.com/linux-mkdir-command/>
作者：[Himanshu Arora](https://www.howtoforge.com) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为初学者准备的 Linux rmdir 命令案例教程
|
Himanshu Arora
|
https://www.howtoforge.com/linux-rmdir-command/
|
在 Linux 命令行上删除文件和目录，我们已经讨论过 rm 命令 的使用。然而，这里有另一个相关的命令行工具，专门针对目录的删除。这是所指的工具就是 rmdir，本教程中，我们将根据一些简单的实例来讨论它。
|
/data/attachment/album/201802/17/125918w3uwdp9b9sebabdi.jpg.thumb.jpg
|
/data/attachment/album/201802/17/125918w3uwdp9b9sebabdi.jpg
| true | false | true |
CYLeft
| false |
[
"rmdir",
"目录"
] |
技术
|
{
"viewnum": 6817,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 Linux 命令行上删除文件和目录，我们已经讨论过 rm 命令 的使用。然而，这里有另一个相关的命令行工具，专门针对目录的删除。这是所指的工具就是 rmdir，本教程中，我们将根据一些简单的实例来讨论它。
| 2018-02-18T09:50:00 | 2018-02-18T09:50:00 | 9,357 |
/article-9357-1.html
|
在 Linux 命令行上删除文件和目录，我们已经讨论过 [rm 命令](/article-9321-1.html) 的使用。然而，这里有另一个相关的命令行工具，专门针对目录的删除。这是所指的工具就是 `rmdir`，本教程中，我们将根据一些简单的实例来讨论它。
### Linux rmdir 命令
见名知意，`rmdir`（remove directory） 命令专门针对删除目录，不过通常目录内空空如也。如下是它的语法：
```
rmdir [OPTION]... DIRECTORY...
```
下面是 man 文档的说明：
>
> 如目录为空，则删除之。
>
>
>
在理解此程序如何工作，下面的 Q&A 风格的案例可能会给您带来更好的灵感。
### Q1. rmdir 命令如何工作？
这非常直接，只需将目录名作为输入参数传递给它。
比如：
```
rmdir test-dir
```
[](https://www.howtoforge.com/images/command-tutorial/big/rm-basic-usage1.png)
### Q2. 如何让 rmdir 忽略非空目录？
通常情况下，`rmdir` 命令会在您删除非空目录时抛出一个错误。然而，如果需要的话，您可以使用 `--ignore-fail-on-non-empty` 选项，忽略它。
比如说：
[](https://www.howtoforge.com/images/command-tutorial/big/rmdir-ignore-nonempty.png)
### Q3. 如何让 rmdir 命令移除父目录？
和 [mkdir](/article-9356-1.html) 一样，您可以通过要求 `rmdir` 命令在其父目录执行操作。这意味着，您可以一次性删除目录和目录的上级目录。这个功能可以通过 `-p` 命令选项实现。
比如，下面的命令将会删除 “test” 和 “test-dir” 目录。
```
rmdir -p test/test-dir/
```
注意： 欲此操作生效，所有被删除的父目录都不应该包含要被删除的空目录之外的任何目录。
### Q4. rmdir 和 rm -r 有何区别？
如果还有印象，您还可以通过提供 `-r` 选项的 `rm` 命令删除目录。那 `rmdir` 和 `rm -r` 区别何在？`rmdir` 仅对空目录生效 —— 您没有办法使用 rmdir 删除非空目录。
因此，`rmdir` 在删除需要检测目录是否为空的情况下，是一个有效的工具。
### 总结
相信您会认同，`rmdir` 并不是一个难以理解和使用的复杂命令。除此之外，它仅提供少量命令行选项。在此，我们几乎讨论了所有的选项，如果您想掌握的更好，练习在本教程提到的案例即可。关于 `rmdir`，[这里另有 man 文档](https://linux.die.net/man/1/rmdir)，备您不时之需。
---
via: <https://www.howtoforge.com/linux-rmdir-command/>
作者：[Himanshu Arora](https://www.howtoforge.com) 译者：[CYLeft](https://github.com/CYLeft) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 上检查网络连接的更多方法
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3233306/linux/more-ways-to-examine-network-connections-on-linux.html
|
有几个命令可以帮助你在 Linux 系统上看到网络状况，这些包括 ip、ethtool、traceroute、tcptraceroute 和 tcpdump。
|
/data/attachment/album/201802/17/132109q2w28zeu9m43me9w.jpg.thumb.jpg
|
/data/attachment/album/201802/17/132109q2w28zeu9m43me9w.jpg
| true | false | true |
kimii
| false |
[
"ip",
"ethtool",
"traceroute"
] |
技术
|
{
"viewnum": 13549,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有几个命令可以帮助你在 Linux 系统上看到网络状况，这些包括 ip、ethtool、traceroute、tcptraceroute 和 tcpdump。
| 2018-02-17T13:21:04 | 2018-02-17T13:21:04 | 9,358 |
/article-9358-1.html
|
>
> 有几个命令可以帮助你在 Linux 系统上看到网络状况，这些包括 ip、ethtool、traceroute、tcptraceroute 和 tcpdump。
>
>
>
`ifconfig` 和 `netstat` 命令当然非常有用，但还有很多其它命令能帮你查看 Linux 系统上的网络状况。本文探索了一些检查网络连接的非常简便的命令。
### ip 命令
`ip` 命令显示了许多与你使用 `ifconfig` 命令时的一样信息。其中一些信息以不同的格式呈现，比如显示 `192.168.0.6/24`，而不是 `inet addr:192.168.0.6 Bcast:192.168.0.255`，尽管 `ifconfig` 更适合数据包计数，但 `ip` 命令有许多有用的选项。
首先，`ip a` 命令可以列出所有网络接口的信息。
```
$ ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 00:1e:4f:c8:43:fc brd ff:ff:ff:ff:ff:ff
inet 192.168.0.6/24 brd 192.168.0.255 scope global eth0
valid_lft forever preferred_lft forever
inet6 fe80::21e:4fff:fec8:43fc/64 scope link
valid_lft forever preferred_lft forever
```
如果你只想看到简单的网络接口列表，你可以用 `grep` 限制它的输出。
```
$ ip a | grep inet
inet 127.0.0.1/8 scope host lo
inet6 ::1/128 scope host
inet 192.168.0.6/24 brd 192.168.0.255 scope global eth0
inet6 fe80::21e:4fff:fec8:43fc/64 scope link
```
使用如下面的命令，你可以看到你的默认路由：
```
$ ip route show
default via 192.168.0.1 dev eth0
192.168.0.0/24 dev eth0 proto kernel scope link src 192.168.0.6
```
在这个输出中，你可以看到通过 `eth0` 的默认网关是 `192.168.0.1`，并且本地网络是相当标准的 `192.168.0.0/24`。
你也可以使用 `ip` 命令来启用和禁用网络接口。
```
$ sudo ip link set eth1 up
$ sudo ip link set eth1 down
```
### ethtool 命令
另一个检查网络非常有用的工具是 `ethtool`。这个命令提供了网络接口上的许多描述性的数据。
```
$ ethtool eth0
Settings for eth0:
Supported ports: [ TP ]
Supported link modes: 10baseT/Half 10baseT/Full
100baseT/Half 100baseT/Full
1000baseT/Full
Supported pause frame use: No
Supports auto-negotiation: Yes
Advertised link modes: 10baseT/Half 10baseT/Full
100baseT/Half 100baseT/Full
1000baseT/Full
Advertised pause frame use: No
Advertised auto-negotiation: Yes
Speed: 100Mb/s
Duplex: Full
Port: Twisted Pair
PHYAD: 1
Transceiver: internal
Auto-negotiation: on
MDI-X: on (auto)
Cannot get wake-on-lan settings: Operation not permitted
Current message level: 0x00000007 (7)
drv probe link
Link detected: yes
```
你也可以使用 `ethtool` 命令来检查以太网驱动程序的设置。
```
$ ethtool -i eth0
driver: e1000e
version: 3.2.6-k
firmware-version: 1.4-0
expansion-rom-version:
bus-info: 0000:00:19.0
supports-statistics: yes
supports-test: yes
supports-eeprom-access: yes
supports-register-dump: yes
supports-priv-flags: no
```
自动协商的详细信息可以用这样的命令来显示：
```
$ ethtool -a eth0
Pause parameters for eth0:
Autonegotiate: on
RX: on
TX: on
```
### traceroute 命令
`traceroute` 命令用于显示路由路径。它通过在一系列数据包中设置数据包头的 TTL（生存时间）字段来捕获数据包所经过的路径，以及数据包从一跳到下一跳需要的时间。`traceroute` 的输出有助于评估网络连接的健康状况，因为某些路由可能需要花费更长的时间才能到达最终的目的地。
```
$ sudo traceroute world.std.com
traceroute to world.std.com (192.74.137.5), 30 hops max, 60 byte packets
1 192.168.0.1 (192.168.0.1) 3.691 ms 3.678 ms 3.665 ms
2 10.224.64.1 (10.224.64.1) 26.273 ms 27.354 ms 28.574 ms
3 10.20.0.33 (10.20.0.33) 28.293 ms 30.625 ms 33.959 ms
4 10.20.0.226 (10.20.0.226) 36.807 ms 37.868 ms 37.857 ms
5 204.111.0.132 (204.111.0.132) 38.256 ms 39.091 ms 40.429 ms
6 ash-b1-link.telia.net (80.239.161.69) 41.612 ms 28.214 ms 29.573 ms
7 xe-1-3-1.er1.iad10.us.zip.zayo.com (64.125.13.157) 30.429 ms 27.915 ms 29.065 ms
8 ae6.cr1.dca2.us.zip.zayo.com (64.125.20.117) 31.353 ms 32.413 ms 33.821 ms
9 ae27.cs1.dca2.us.eth.zayo.com (64.125.30.246) 43.474 ms 44.519 ms 46.037 ms
10 ae4.cs1.lga5.us.eth.zayo.com (64.125.29.202) 48.107 ms 48.960 ms 50.024 ms
11 ae8.mpr3.bos2.us.zip.zayo.com (64.125.30.139) 51.626 ms 51.200 ms 39.283 ms
12 64.124.51.229.t495-rtr.towerstream.com (64.124.51.229) 40.233 ms 41.295 ms 39.651 ms
13 69.38.149.18 (69.38.149.18) 44.955 ms 46.210 ms 55.673 ms
14 64.119.137.154 (64.119.137.154) 56.076 ms 56.064 ms 56.052 ms
15 world.std.com (192.74.137.5) 63.440 ms 63.886 ms 63.870 ms
```
### tcptraceroute 命令
`tcptraceroute` 命令与 `traceroute` 基本上是一样的，只是它能够绕过最常见的防火墙的过滤。正如该命令的手册页所述，`tcptraceroute` 发送 TCP SYN 数据包而不是 UDP 或 ICMP ECHO 数据包，所以其不易被阻塞。
### tcpdump 命令
`tcpdump` 命令允许你捕获网络数据包来进一步分析。使用 `-D` 选项列出可用的网络接口。
```
$ tcpdump -D
1.eth0 [Up, Running]
2.any (Pseudo-device that captures on all interfaces) [Up, Running]
3.lo [Up, Running, Loopback]
4.nflog (Linux netfilter log (NFLOG) interface)
5.nfqueue (Linux netfilter queue (NFQUEUE) interface)
6.usbmon1 (USB bus number 1)
7.usbmon2 (USB bus number 2)
8.usbmon3 (USB bus number 3)
9.usbmon4 (USB bus number 4)
10.usbmon5 (USB bus number 5)
11.usbmon6 (USB bus number 6)
12.usbmon7 (USB bus number 7)
```
`-v` 选项控制你看到的细节程度——越多的 `v`，越详细，但超过 3 个 `v` 不会有更多意义。
```
$ sudo tcpdump -vv host 192.168.0.32
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 262144 bytes
20:26:31.321816 IP (tos 0x10, ttl 64, id 22411, offset 0, flags [DF], proto TCP (6), length 184)
192.168.0.6.ssh > 192.168.0.32.57294: Flags [P.], cksum 0x8221 (incorrect -> 0x0254), seq 3891093411:3891093555, ack 2388988308, win 329, length 144
20:26:31.321984 IP (tos 0x10, ttl 64, id 22412, offset 0, flags [DF], proto TCP (6), length 200)
192.168.0.6.ssh > 192.168.0.32.57294: Flags [P.], cksum 0x8231 (incorrect -> 0x3db0), seq 144:304, ack 1, win 329, length 160
20:26:31.323791 IP (tos 0x0, ttl 128, id 20259, offset 0, flags [DF], proto TCP (6), length 40)
192.168.0.32.57294 > 192.168.0.6.ssh: Flags [.], cksum 0x643d (correct), seq 1, ack 304, win 385, length 0
20:26:31.383954 IP (tos 0x10, ttl 64, id 22413, offset 0, flags [DF], proto TCP (6), length 248)
...
```
当你运行像这样的命令时，会看到**非常多**的输出。
这个命令捕获来自特定主机和 `eth0` 上的 `11` 个数据包。`-w` 选项标识保存捕获包的文件。在这个示例命令中，我们只要求捕获 `11` 个数据包。
```
$ sudo tcpdump -c 11 -i eth0 src 192.168.0.32 -w packets.pcap
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 262144 bytes
11 packets captured
11 packets received by filter
0 packets dropped by kernel
```
### arp 命令
`arp` 命令将 IPv4 地址映射到硬件地址。它所提供的信息也可以在一定程度上用于识别系统，因为网络适配器可以告诉你使用它们的系统的一些信息。下面的第二个 MAC 地址，以 `f8:8e:85` 开头，很容易被识别出是 Comtrend 路由器。
```
$ arp -a
? (192.168.0.12) at b0:c0:90:3f:10:15 [ether] on eth0
? (192.168.0.1) at f8:8e:85:35:7f:b9 [ether] on eth0
```
上面的第一行显示了系统本身的网络适配器的 MAC 地址。该网络适配器似乎已由台湾 Chicony 电子公司制造。你可以很容易地在网上查找 MAC 地址关联，例如来自 Wireshark 的这个工具 —— <https://www.wireshark.org/tools/oui-lookup.html> 。
---
via: <https://www.networkworld.com/article/3233306/linux/more-ways-to-examine-network-connections-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 译者：[kimii](https://github.com/kimii) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
25 个学习 Linux 的免费资源（英文）
|
Abhishek Prakash
|
https://itsfoss.com/learn-linux-for-free/
|
在这篇文章中，我将与你分享免费学习 Linux 的最佳资源。这个集合包括了网站、在线视频课程和免费电子书。
|
/data/attachment/album/201802/17/195021c14bpthi1qqqy4cb.png.thumb.jpg
|
/data/attachment/album/201802/17/195021c14bpthi1qqqy4cb.png
| true | false | true |
yyyfor
| false |
[
"电子书",
"资源"
] |
分享
|
{
"viewnum": 14454,
"commentnum": 0,
"favtimes": 8,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我将与你分享免费学习 Linux 的最佳资源。这个集合包括了网站、在线视频课程和免费电子书。
| 2018-02-17T19:46:00 | 2018-02-17T19:46:00 | 9,359 |
/article-9359-1.html
|
>
> 在这篇文章中，我将与你分享免费学习 Linux 的最佳资源。这个集合包括了网站、在线视频课程和免费电子书。
>
>
>
**如何学习 Linux ？**
这可能是 Facebook Linux 用户组中最常见的问题。
“如何学习 Linux”这个看起来简单的问题的答案并不简单。
问题在于不同的人对于学习 Linux 有不同的意义。
* 比如有人从来没有使用过 Linux，无论是命令行还是桌面版本，那个人可能只是想知道更多关于它的信息。
* 比如有人使用 Windows 作为桌面，但必须在工作中使用 Linux 命令行，那个人可能对学习 Linux 命令感兴趣。
* 比如有人已经使用过一段时间的 Linux，而且懂得一些基础，但他/她可能想要更上一层楼。
* 比如有人只是对 Linux 特定的发行版本感兴趣。
* 比如有人想要提升或学习几乎与 Linux 命令行差不多的 Bash 脚本。
* 比如有人想要从事一个 Linux 系统管理员的职业，或者想提高他/她的系统管理技能。
你看，“我如何学习 Linux”的答案取决于你追求什么样的 Linux 知识。为此，我收集了大量能用来学习 Linux 的资源。
这些免费的资源包括电子书、视频课程、网站等。这些资源分成几个子类别，以便当你试图学习 Linux 时可以很容易地找到你想要的东西。
再者，这里没有学习 Linux 的最好方式。这完全取决于你如何去学习 Linux，通过在线门户网站、下载电子书、视频课程或者其他。
让我们看看你能如何学习 Linux。
**免责声明** : 这里列举的所有书都可以合法的下载。 据我所知，这里提到的资源都是官方的资源。但是，如果你发现它不是，请让我知道以便我可以采取适当的措施。
### 1. 对于完全新手学习 Linux 的免费资料
也许你刚刚从朋友那里或者从网上的讨论中听到了 Linux。关于 Linux 的炒作让你对 Linux 很感兴趣，你被互联网上的大量信息所淹没，不知道在哪里寻找更多的关于 Linux 的知识。
不用担心，我们中的大多数，即使不是全部，都经过过这个阶段。
#### Linux 基金会关于 Linux 的介绍 [视频课程]
如果你对于什么是 Linux 和如何开始学习 Linux 完全没有概念的话，我建议你从学习 [Linux 基金会](https://www.linuxfoundation.org/)在 [edX](https://www.edx.org) 上提供的免费的视频课程开始。它可以看做“维护” Linux 的组织的一个官方课程——是的，这个组织是由 Linux 之父 [Linus Torvalds](https://www.youtube.com/watch?v=eE-ovSOQK0Y) 所背书的。
* [Introduction To Linux](https://www.edx.org/course/introduction-linux-linuxfoundationx-lfs101x-0)
#### Linux 旅程 [网站]
不是官方的，也许不是很受欢迎。但是这个小网站对于初学者来说是一个 Linux 学习的完美场所。
该网站设计精美，并根据主题组织得很好。它给你提供了能够在阅读完一个片段或章节后的进行的互动式测验。我的建议是收藏这个网站：
* [Linux Journey](https://linuxjourney.com/)
#### 《5 天学习 Linux》 [电子书]
这本出色的书针对 FOSS 读者来说完全的免费，这完全得感谢 [Linux Training Academy](https://www.linuxtrainingacademy.com/)。
为完全的新手而写，这本免费的 Linux 电子书给了你一个关于 Linux 的概述、常用的 Linux 指令和你开始学习 Linux 所需要的其他东西。
你能够从下面的网页下载该书：
* [Learn Linux In 5 Days](https://courses.linuxtrainingacademy.com/itsfoss-ll5d/)
#### 《Linux 新手终极指南》 [电子书]
这是一本面向 Linux 初学者的免费下载的电子书。该电子书从解释什么是 Linux 开始，并提供了将 Linux 作为桌面的更多实际使用经验。
您可以从下面的链接下载最新版本的电子书：
* [The Ultimate Linux Newbie Guide](https://linuxnewbieguide.org/ulngebook/)
### 2. 初学者进阶的免费书籍
本节列出了那些已经“完成”的 Linux 电子书。
我的意思是，这些之中的大部分就像是专注于 Linux 的每个方面的学术教科书。你可以作为一个绝对的新手阅读这些书，或者你也可以作为一个中级的 Linux 用户来深入学习。即使你已经是专家级，你也可以把它们作为参考。
#### 《Linux 介绍》 [电子书]
《Linux 介绍》是 [Linux 文档计划](http://www.tldp.org/index.html)的免费电子书，而且它是最热门的 Linux 免费电子书之一。即使我认为其中的部分段落需要更新，它仍然是一本非常好的电子书，可以教你 Linux、Linux 的文件系统、命令行、网络和其他相关的东西。
* [Introduction To Linux](http://tldp.org/LDP/intro-linux/intro-linux.pdf)
#### 《Linux 基础》 [电子书]
这本由 Paul Cobbaut 编写的免费的电子书可以教你关于 Linux 的历史、安装和你需要知道的基本的 Linux 命令。你能够从下列链接上得到这本书：
* [Linux Fundamentals](http://linux-training.be/linuxfun.pdf)
#### 《Linux 高级编程》 [电子书]
顾名思义，这是一本面向想要或者正在开发 Linux 软件的高级用户的书。它阐释了那些复杂的功能，比如多进程、多线程、进程间通信以及和硬件设备的交互。
跟着这本书学习会帮你开发一个更快速、更可靠、更安全的使用 GNU/Linux 系统全部功能的项目。
* [Advanced Linux Programming](http://advancedlinuxprogramming.com/alp-folder/advanced-linux-programming.pdf)
#### 《LFS》 [电子书]
如果你认为自己对 Linux 有足够的了解，并且你是一个专业人士，那么为什么不创建自己的 Linux 版本呢？ Linux From Scratch（LFS）是一个完全基于源代码，为你构建你自定义的 Linux 系统提供手把手的指导。
可以把它叫做 DIY Linux ，它是一个把你的 Linux 专业知识提高到新的高度的方法。
这里有许多的关于这个项目的子项目，你能够在这个网站上查看和下载。
* [Linux From Scratch](http://www.linuxfromscratch.org/)
### 3. 学习 Linux 命令和 Shell 脚本的免费电子书
Linux 的真正强大在于命令行，如果你想要征服 Linux，你必须学习命令行和shell。
事实上，如果你必须在你的工作中使用 Linux 终端，那么熟悉 Linux 命令行实际上会帮助你完成任务，也有可能帮助你提高你的职业生涯（因为你会更有效率）。
在本节中，我们将看到各种 Linux 命令方面的免费电子书。
#### 《GNU/Linux 命令行工具总览》 [电子书]
这本 Linux 文档项目中的电子书是接触 Linux 命令行并开始熟悉 Shell 脚本的好地方。
* [GNU/Linux Command−Line Tools Summary](http://tldp.org/LDP/GNU-Linux-Tools-Summary/GNU-Linux-Tools-Summary.pdf)
#### 《GNU Bash 参考手册》 [电子书]
这是一本可以从 [GNU](https://www.gnu.org/home.en.html) 网站下载的免费电子书。 就像名字暗示的那样, 它涉及 Bash Shell （如果我能这么叫的话）。这本书超过了 175 页，而且它包括了许多在 Bash 里和 Linux 有关的主题。
你能够从下面的链接中获取：
* [Bash Reference Manual](https://www.gnu.org/software/bash/manual/bash.pdf)
#### 《Linux 命令行》 [电子书]
这本 500 多页的由 William Shotts 编写的免费电子书，对于那些认真学习 Linux 命令行的人来说，是一本必须拥有的书。
即使你认为你已经了解了 Linux，你还是会惊讶于这本书能教你很多东西。
它涵盖了从初学者到高级的东西。我敢打赌读完这本书之后你会成为一个更好的 Linux 用户。请下载这本书并且随时携带它。
* [The Linux Command Line](http://linuxcommand.org/tlcl.php)
#### 《Bash 入门指南》 [电子书]
如果你想从 Bash 脚本开始，这可能对于你来说是一个很好的助手。 这本电子书也是基于 Linux 文档项目的，它是编写 《Linux 介绍》的电子书的作者（本文前面讨论过）。
* [Bash Guide for Beginners](http://www.tldp.org/LDP/Bash-Beginners-Guide/Bash-Beginners-Guide.pdf)
#### 《Bash 脚本高级指南》 [电子书]
如果你认为你已经了解了基本的 Bash 脚本知识，并且你想把你的技能提高到一个新的水平，这本书就是你所需要的。这本书有超过 900 页的各种高级命令和举例。
* [Advanced Bash-Scripting Guide](http://www.tldp.org/LDP/abs/abs-guide.pdf)
#### 《AWK 编程语言》 [电子书]
这不是一本很美观的书，但是如果你真的想要深入学习脚本，这本虽旧但是依然很棒的书会很有帮助。
* [The AWK Programming Language](https://ia802309.us.archive.org/25/items/pdfy-MgN0H1joIoDVoIC7/The_AWK_Programming_Language.pdf)
#### 《Linux 101 技巧》 [电子书]
这本 270 多页的书来自“The Geek Stuff”，通过易于跟踪学习的例子教给你 Linux 命令行基础。你能够从下列的链接获取:
* [Linux 101 Hacks](http://www.thegeekstuff.com/linux-101-hacks-ebook/)
### 4. 特定发行版的免费学习资料
这个章节专注于特定 Linux 发行版的材料。到目前为止，我们看到的都是以常规的方式学习 Linux，更多的关注于文件系统、命令和其他的核心内容。
这些书，在另一方面，可以被认为是用户手册或者开始学习各种各样的 Linux 发行版的指南。所以如果你正在使用或准备使用一个特定的 Linux 发行版，你可以参考这些资源。是的，这些书更加关注 Linux 桌面。
我还想补充的是，大部分的 Linux 发行版有它们自己的大量的 wiki 或者文档。你能够从网上随时找到它们。
#### 《Ubuntu 用户指南》 [电子书]
不用说，这本书是针对 Ubuntu 用户的。这是一个独立的项目，以免费电子书的形式提供 Ubuntu 的用户指南。它对于每个版本的 Ubuntu 都有更新。
这本书被叫做用户指南因为它是由一步步的指导组成的，而且受众目标是对于 Ubuntu 完全新手的。所以，你会了解到 Unity 桌面，以及怎样逐渐使用它而且查找应用等等。
如果你从来没有使用过 Ubuntu Unity ，那么这是一本你必须拥有的书，因为它帮助你理解怎样在日常中使用 Ubuntu。
* [Ubuntu Manual](https://ubuntu-manual.org/)
#### 《面向 Linux Mint：直接告诉我就行！》 [电子书]
一本非常基本的关于 Linux Mint 的电子书。它告诉你怎么样在虚拟机中安装 Linux Mint，怎么样去查找软件，安装更新和自定义 Linux Mint 桌面。
你能够在下面的链接下载电子书：
* [Just Tell Me Damnit!](http://downtoearthlinux.com/resources/just-tell-me-damnit/)
#### 《Solus Linux 用户指南》 [电子书]
注意！这本书过去是 Solus Linux 的官方用户指南，但是我找不到 Solux 项目的网站上在哪里有提到它。我不知道它是不是已经过时了。尽管如此，反正不要钱，多少学习一点 Solus Linux。
* [Solus Linux User Guide](https://drive.google.com/file/d/0B5Ymf8oYXx-PWTVJR0pmM3daZUE/view)
### 5. 面向系统管理员的免费电子书
这个章节主要关注于系统管理员——开发者的超级英雄。我已经列了一部分会真正帮助那些已经是系统管理者或者想要成为系统管理者的免费的电子书。我还得说，你必须要关注基本的 Linux 命令行，因为它会使你的工作更加简单。
#### 《The Debian 管理手册》 [电子书]
如果你使用 Debian Linux 作为你的服务器，这本书就是你的圣经。这本书从 Debian 的历史、安装、包管理等等开始，接着覆盖一些主题，比如说 [LAMP](https://en.wikipedia.org/wiki/LAMP_(software_bundle))、虚拟机、存储管理和其他核心系统管理。
* [The Debian Administration's Handbook](https://debian-handbook.info/about-the-book/)
#### 《高级 Linux 系统管理》 [电子书]
如果在准备 [LPI 认证](https://www.lpi.org/our-certifications/getting-started)，那么这本书是一本理想的书。这本书的涉及系统管理员必要的主题，所以了解 Linux 命令行是前置条件。
* [Advanced Linux System Administration](http://www.nongnu.org/lpi-manuals/manual/pdf/GNU-FDL-OO-LPI-201-0.1.pdf)
#### 《Linux 系统管理》 [电子书]
Paul Cobbaut 编写的另一本免费的电子书。370 页长的的书包括了网络、磁盘管理、用户管理、内核管理、库管理等等。
* [Linux System Administration](http://linux-training.be/linuxsys.pdf)
#### 《Linux 服务器》 [电子书]
又一本来自 [linux-training.be](http://linux-training.be/) 的 Paul Cobbaut 编写的电子书。这本书包括了 Web 服务器、MySQL、DHCP、DNS、Samba 和其他文件服务器。
* [Linux Servers](http://linux-training.be/linuxsrv.pdf)
#### 《Linux 网络》 [电子书]
网络是系统管理者的面包和黄油，这本也是由 Paul Cobbaut 编写的书是一本好的参考资料。
* [Linux Networking](http://linux-training.be/linuxnet.pdf)
#### 《Linux 存储》 [电子书]
这本由 Paul Cobbaut（对，还是他）编写的书详细解释了 Linux 的磁盘管理，而且介绍了许多其他的和存储相关的技术。
* [Linux Storage](http://linux-training.be/linuxsto.pdf)
#### 《Linux 安全》 [电子书]
这是这个书单里最后一本由 Paul Cobbaut 编写的书。安全是系统管理员最重要的工作之一。这本书关注文件权限、ACL、SELinux、用户和密码等等。
* [Linux Security](http://linux-training.be/linuxsec.pdf)
### 你有什么最喜爱的 Linux 资料吗？
我知道这是一个不错的免费 Linux 电子书集合，但是它可以做的更好。
如果你有学习 Linux 方面有更大帮助的其它资料，请务必和我们共享。请注意只共享合法的下载资料，以便我可以根据你的建议更新这篇文章而不会有任何问题。
我希望你觉得这篇文章在学习 Linux 时有帮助，欢迎你的反馈。
---
via: <https://itsfoss.com/learn-linux-for-free/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 译者：[yyyfor](https://github.com/yyyfor) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
2018 年度最佳 Linux 笔记本电脑：来自一位 RHCE 的选购指南
|
Gayan
|
https://www.hecticgeek.com/2017/12/best-linux-laptop/
|
如果你不具备相关的知识和经验，挑选出最适合 Linux 的笔记本电脑，可能是件很困难的事。并且，看上去你买了一台配置、功能、性能都很棒的电脑，但是，却疲于处理各种 Linux 的问题，太难堪了！
|
/data/attachment/album/201802/18/224641tx51k5224x4twxvw.png.thumb.jpg
|
/data/attachment/album/201802/18/224641tx51k5224x4twxvw.png
| true | false | true |
qhwdw
| true |
[
"笔记本"
] |
观点
|
{
"viewnum": 71178,
"commentnum": 1,
"favtimes": 4,
"sharetimes": 4,
"likes": 0
}
|
[
{
"postip": "120.35.33.27",
"message": "博主 红帽的系统好吗，可能我需要搭建单节点kubernetes rhel7.0对已经入门两年的人来说合适吗",
"username": "来自福建福州的 Chrome 74.0|Windows 10 用户",
"date": "2019-05-25T16:02:01"
}
] |
[] |
如果你不具备相关的知识和经验，挑选出最适合 Linux 的笔记本电脑，可能是件很困难的事。并且，看上去你买了一台配置、功能、性能都很棒的电脑，但是，却疲于处理各种 Linux 的问题，太难堪了！
| 2018-02-18T22:41:00 | 2018-02-18T22:41:00 | 9,360 |
/article-9360-1.html
|
如果你不具备相关的知识和经验，挑选出最适合 Linux 的笔记本电脑，可能是件很困难的事。并且，看上去你买了一台配置、功能、性能都很棒的电脑，但是，却疲于处理各种 Linux 的问题，太难堪了！因此，作为一个 **RedHat 认证工程师**，这篇文章的作者兼博主，也是一个 **有 14 年以上 Linux 使用经验的用户**，我用我掌握的一些知识去为你推荐一些笔记本电脑，我可以保证我推荐的这些电脑，Linux 在它上面会跑的很好。我研究了 20 多个小时之后（通过认真了解硬件详细情况和用户反馈），我选择 [Dell XP S9360-3591-SLV](https://www.amazon.com/gp/product/B01LQTXED8?ie=UTF8&tag=flooclea01-20&camp=1789&linkCode=xm2&creativeASIN=B01LQTXED8) 作为我的首选推荐。如果你希望笔记本电脑装备最新的功能特性，并且 **能够在使用 Linux 工作** 时有极好的性能，那么，这台笔记本电脑将是你的最佳选择。
它使用铝合金机身，很轻（2.7 磅重），有强劲的硬件性能，待机时间较长，使用康宁大猩猩玻璃的 QHD 显示屏，分辨率为 3200×1800、并且还具备触控功能，可以为你带来清晰的图像表现，即便是很小的细节也可以很好的展现出来，有一个带橡皮掌托的、面积很大的并且非常好用的触摸板（早期版本上触摸板有几个小问题，但是，最新的机器已经修复了），并且也有一个很好用的带背光的键盘（按键的行程很短，这一点有些像 Thinkpad 笔记本），两个 USB 3.0 端口。最重要的是，两个最让 Linux 用户头痛的问题，无线网卡和 GPU （Intel HD Graphics 620 **播放 4K 视频可以达到 60 fps**），在这台 Dell 电脑上，它们都 **超级兼容 Linux**。
有一个缺点是，它没有 HDMI 端口。在这个位置，Dell 增加了一个 Thunderbolt 3 端口。因此，你唯一的选择是使用一个 Thunderbolt 到 HDMI 的转换器（它很便宜）。第二，在购买之后，你不能升级它的 8GB 的内存（在采购之前你可以改变硬件配置 —— CPU、RAM & SSD），但是，在我的选择中，8GB 的内存运行任何 Linux 发行版做任何工作都足够了。我有一台 Asus 笔记本电脑（它是我收到的一份礼物）使用第五代的 Core i7 的 CPU，4GB 内存，它是我主要使用的计算机。使用 Chrome 可以打开 15-20 个标签，在后台运行 VLC ，打开文件管理和一个代码编辑器，这种情况下，它工作的很好。如果我减少一些浏览器标签（减少到 4-5 个），然后，即便是其它的应用程序都打开的情况下，我都可以在 Virtualbox 上使用虚拟机工作。这些都是在 4GB 内存的情况下，因此，有 8GB 内存和其它更强劲的硬件的情况下，它绝对会工作的非常好。
>
> **注意：** 虽然我为你选择了一套非常可靠的 [硬件](https://www.amazon.com/gp/product/B01LQTXED8?ie=UTF8&tag=flooclea01-20&camp=1789&linkCode=xm2&creativeASIN=B01LQTXED8)，但是，如果你愿意，你仍然可以进一步去定制它。即便你不去选择 ‘8GB RAM/128GB SSD’ 这个选项。因为，那个版本也提供 1920×1080 的 FHD 显示屏，并且，在 13.3″ 的显示屏上让菜单看起来更小一些，看起来稍微有点困难。
>
>
>
### 最便宜的 Linux 笔记本电脑
如果你觉得这台 Dell 笔记本电脑有点贵，买不起，但是还想拥有类似的非常好的性能，并且与 Linux 的兼容性很好，那么，第二个最佳选择是这台 [Acer Aspire E 15 E5-575G-57D4](https://www.amazon.com/gp/product/B01LD4MGY4?ie=UTF8&tag=flooclea01-20&camp=1789&linkCode=xm2&creativeASIN=B01LD4MGY4)。它 15.6″ 的显示屏，无疑能提供像前面的 Dell 笔记本一样的显示表现，但是，在 15.6” 上的 1920×1080 的全高清分辨率显示屏，也可以让任何细节都显示的非常清晰。其它的硬件与前面介绍的很贵的 Dell 笔记本电脑很相似，但是，**因此它的电池很重，整机重达 5.2 磅。**
你实际上可以去做一些定制。基本的配置包括一个第七代 Core i5 CPU，15.6“ 的全高清显示屏（1920 x 1080），8GB DDR4 内存，256GB 固态硬盘，Intel HD Graphics 620 GPU 和一个独立的 Nvidia 940 MX GPU，端口方面：HDMI 2 USB 3.0，1 x USB 2.0 & 1 USB 3.1。对于 $549 的售价，它竟然 **包含一个 DVD 刻录机** … [**它是一个特价商品**](https://www.amazon.com/gp/product/B01LD4MGY4?ie=UTF8&tag=flooclea01-20&camp=1789&linkCode=xm2&creativeASIN=B01LD4MGY4)。
至于 Linux 的兼容性，它真的很好。虽然它不像顶级的 Dell XPS，但是，至少在我看来，如果它能够解决 Nvidia GPU 的问题，它就是一个很好的选择。除了一个用户以外，所有其它的用户都反馈，它的 Linux 兼容性非常好。唯一的一个用户抱怨说，在 Linux Mint 上安装了 Nvidia 的专用驱动以后，出现了一个小问题，并且他说，他决对不是故意 “抹黑” 它。这个反馈与我在使用移动版的 Nvidia GPU 所遇到的情况一样。
例如，现在我使用一台 Asus 笔记本电脑，并且它除了集成的 Intel GPU 以外，它也有一个独立的 Nvidia 920M GPU。这台笔记本电脑我大概已经用了一年半时间了。[我在它上面运行了一些 Linux 发行版](https://www.hecticgeek.com/gnu-linux/)，并且，遇到的唯一的问题是，[在 Ubuntu 17.10 上](https://www.hecticgeek.com/2017/11/ubuntu-17-10-review/) 安装完它的专用驱动程序后，如果激活 Nvidia 作为默认的 GPU，自动用户登入功能会停止工作。因此，每次进入桌面我都要输入我的登录凭据。这虽然不是一个大问题，但是，我确信，它可以通过编辑一些登录管理器的配置设定来修复它，但是，我根本就没有去理它，因为我很少使用 Nvidia GPU。因此，我只是简单地改变默认 GPU 为 Intel，所有的一切就会正常。因此，前段时间，我在 [Ubuntu 16.04 LTS](https://www.hecticgeek.com/2016/04/ubuntu-16-04-lts-review/) 上 [的同一个 Nvidia GPU 上启用了‘运动插值’](https://www.hecticgeek.com/2016/06/motion-interpolation-linux-svp/)，并且它处理的非常好！
我想说的是，GPU 驱动，比如 Nvidia & AMD/ATI 提供的，给用户带来困扰只是在过去的 Linux 上，但是，现在随着进一步的处理，已经不是什么困难的事情了，或者说，至少没有像以前那样困难了。除非你使用的是一个非常新的高端 GPU，Linux 的运行不遇到大的问题还是很有可能的。
### Linux 游戏笔记本
很多时候，玩游戏的笔记本电脑，你需要去手动调整一些东西。并且，这些 “东西” 大部分都是与 GPU 相关的。它可能只是简单地安装一些专用的驱动程序，去处理一个拒绝引导到 CD/USB 中的系统。但是，如果有足够的耐心，大多数情况下，它们都是可以修复的。如果你的游戏笔记本有一个非常新的 Nvidia/AMD GPU 驱动，并且，这个驱动有问题，那么，修复它意味着只需要等待它更新驱动程序。有时候，可能需要等待很长的时间。但是，如果你买了一台安装有几个月前发布的 GPU 的笔记本电脑，那么，仅此一点，就大大增加你解决现有问题的机会。
因此，考虑到这一点，我选择了 [Dell Inspiron i5577-7342BLK-PUS](https://www.amazon.com/gp/product/B06XFC44CL?ie=UTF8&tag=flooclea01-20&camp=1789&linkCode=xm2&creativeASIN=B06XFC44CL)，作为一个游戏笔记本电脑的最佳选择。它是一台强大的游戏笔记本电脑，售价低于 1000 美元。主要原因是它有一个 15.6″ 的全高清（1920 x 1080）显示屏。因为，在你查看其它配置的时候你会发现（也可以进一步定制它），它包含一个第七代 Core i7 CPU（四核心），16GB DDR4 内存（最高可到 32GB），512GB SSD 驱动器，并且有一块 Nvidia GTX 1050 GPU，它有很多积极的评价。你只可以在 QHD 或者 4K 下，使用外接显示器去玩高端游戏，尽管如此，它也可以在 15.6″ 的全高清分辨率下玩一些游戏。
我选择 Dell 的另外原因是，大多数的 Dell 笔记本电脑（或者一般用途的计算机）都是非常兼容 Linux 系统的。我在 Dell 网站上手工检查了硬件配置的详细情况，虽然我不能保证使用 Nvidia GPU 不会有任何问题，其它的硬件在主流的 Linux 发行版上都工作的很好（比如 Ubuntu）。
### 哪个才是你需要的？
实际上，我相信越少越好。
我可以在这里给你 ‘推荐’ 很多很多的笔记本电脑，但是，那样的话，我需要写一系列的博客文章。因此，我并不打算 ‘推荐’ 10-12 台笔记本电脑，除非我确信它们都在 Linux 上运行的非常好。而目前为止，这个推荐清单上只有 3 台。我能确信它们在 Linux 上运行的非常好（而且，甚至是游戏笔记本电脑，除了 Nvidia GPU，其它的硬件部分应该工作的很好），再加上，这三个型号都有很多的可选项。换句话说就是，随着时间的推移，如果我从其它的制造商的产品中找到一些笔记本电脑，我相信它们在 Linux 上也运行的很好，然后，我也会推荐它们。但是，现在，就这三台笔记本电脑是我所推荐的。你可能不喜欢这些推荐的电脑，那么，下面我告诉你如何去查找你心仪的笔记本电脑。一旦你有了基本的概念，你可以非常容易地去预测，一台笔记本电脑是否能够运行 Linux 而不会出现问题。上面我已经提到了大部分，但是，我还在这里再说一下。
#### 查找关于硬件的更多信息
当你拿到一个笔记本电脑时，记下它的型号。现在，在大多数的网站上，都提供硬件的详细情况，比如，无线网卡或者声卡芯片的制造商。在大多数的情况下，使用一些简单的技巧就可以拿到这些信息。我通常是这样做的。
如果你知道笔记本电脑的制造商和型号，可以在 Google 中搜索它的驱动程序。我以前面的 Dell 游戏笔记本电脑为例。如果你知道它的名字，然后在 Google 上去搜索它的驱动程序（`Dell Inspiron i5577-7342BLK-PUS drivers`），Google 并不会显示一个 Dell 的官方的驱动程序页面。这并不奇怪，因为 Dell （以及其它制造商）在一个通用的型号名字下面，销售很多种装有各种不同的（2 到 3 种）硬件的笔记本电脑。因此，要缩小搜索目标，从左侧开始，我们首先来使用名字的前三个字段，并且用它在 Google（`Dell Inspiron i5577 drivers`）中搜索驱动程序，然后，如下所显示，并且，Google 也列出了不同的所属网站，对于 Inspiron 5577（没有 ‘i’），列出了一个 Dell 的官方驱动程序页面。
如果你进入这个页面，去查看各种我们感兴趣的型号的驱动程序和硬件列表，那么，你将看到在 ‘Dell Inspiron i5577-7342BLK-PUS’ 中的硬件也在这里列出来了。我通常只喜欢查看 ‘audio’ 和 ‘network’ 下面列出的内容，因为从购买网站上去获得这些芯片的准确的型号名一般很困难，其它的一些硬件如 GPU、CPU 等等也列了出来。因此，如果你查看在 ‘network’ 下显示的内容，你将看到 Dell 提供的一些驱动程序。其中一个就是 Realtek 以太网适配器（以太网适配器通常都支持 Linux ），Qualcomm QCA61x4A-QCA9377 无线网络适配器（如果你进一步研究，需要对 `QCA61x4A` 和 `QCA9377` 分别进行，因为它们之间用 ‘-’ 分隔，你就会发现，它们实际上是来自高通的两种不同的无线芯片。这个关键字表示，Dell 在一个包中包含了两种驱动程序），和一组 Intel 无线网络适配器（Intel 硬件在 Linux 中也支持的非常好）。
但是，高通的设备有时候可能会有些问题。我遇到过一两个，但是，它们都不是什么严重的问题。也就是说，当有问题时，去查找就是解决的一个好办法。因此，使用 `Qualcomm QCA61x4A-QCA9377` 做为关键字（使用一个适配器或者使用一个芯片名字的组合去查询这并不重要），并且增加一个像 `linux` 或者 `ubuntu` 这样的关键字在 Google 中去搜索它。如果像 `Qualcomm QCA61x4A-QCA9377 ubuntu` 这样去搜索，然后，Google 会列出很多结果。我收到的第一个结果是自来 [AskUbuntu](https://askubuntu.com/)（一个社区驱动的网站，专门回答终端用户提出的问题，是一个解决 Ubuntu 相关问题的极好的资源）。
如果你去看那个页面，你可以看到有用户报怨 Qualcomm QCA9377 无线网络适配器在它的 Ubuntu 15.10 不能正常工作。幸运的是，那个问题已经被回答了。这个问题看起来似乎是 Ubuntu 15.10 的问题，它发布于 2015 年 10 月，因此，这是两年前的问题了。所以，这个问题很可能在最新的 Ubuntu 发行版中已经修复了。我还记得，这个问题好像与 Qualcomm QCA9377 无线芯片有关，而不是 QCA61x4A。因此，如果我们的 Linux 游戏笔记本电脑使用的是后面型号的无线芯片，那么很有可能你不会遇到这个问题。
我希望我不要遇到上面报怨的所有事情。我只是想给你提供一个指南，告诉你如何去找到你希望去运行 Linux 的笔记本电脑上的关于硬件的详细情况，这样你就可以很好地去评估它。使用一些常识性的技巧和经验，你的工作效率将会更高。
#### 不要止步于 GPU 和网络适配器上
虽然，在你购买了一台笔记本电脑来运行 Linux 时，GPU 和网络适配器是大多数人遇到的最容易出现问题的硬件设备，但是，去研究音频、触控板、和键盘在 Linux 中的兼容性和它们相关的特性（例如，我的老 Dell 的背光键盘在 Linux 中也有一个小问题），也是一个很好的实践。
**搜索‘用户评论’（当你准备购买时）**
在诸如 Amazon.com 这样的网站上，你实际上可以搜索某些关键字的用户反馈 (‘审阅’)。这是非常有用的，因为你可以很容易地用几秒钟内在包括数以百计甚至数以千计的用户反馈中搜索一两个关键字。我建议你使用的关键字，如 `Linux` 或 `ubuntu` 或 `linux mint` 或任何其他 Linux 发行版，只要它是流行的发行版。如果已经购买了笔记本电脑的人试图在它上运行 Linux 发行版，使用此方法你总能找出发生了什么事。
在亚马逊这样的网站搜索用户反馈是很容易。一旦您访问了您感兴趣的产品页面，只需单击“客户评论”链接并向下滚动, 直到看到一个搜索框 (通常位于右下角)。
#### 如果它是一个 ‘热门’ 硬件，等待 2-3 个月
正如，计算机终端用户所担心的那样，Linux 的市场份额是非常小的。因此，硬件制造商并不会把 Linux 看的很重。因此，他们修复最新发布的硬件设备中已存在的主要问题需要很长的一段时间。即便是开源驱动程序，也是如此，当然，在我的经验中，开源的驱动程序的问题修复比专属的驱动程序要快。因此，如果你买的笔记本电脑的特色硬件设备（主要指 CPU 和 GPU）是最新发布的，那么，它通常需要等待 2 或 3 个月才能去修复在 Linux 上的主要的问题。并且，但愿在那个时候，你可以找到一个修复，或者，至少可以预测什么时候可以被修复。
#### 关于屏幕和 HiDPI 在 Linux 上支持的怎么样？
‘像素密度’ 或者 ‘高像素密度’ 显示是最近非常流行的术语。并且大多数人都认定，更高的像素意味着更好的质量。虽然在一般的认知和技术角度上，它可能是正确的，但是，它并不准确。这个主题理解起来很复杂，因此，我将只讲一些基本的概念，对于你理解这个主题已经足够了，以避免不必要的混乱。
任何显示在你的屏幕上的东西，比如文本或者图标，都被设计为某些固定的大小。而这些大小是通过被称为 “每英寸显示的像素点数” 或者简称为 DPI 来描述的。它基本上定义了每英寸应该显示多少个点（像素）才能正确显示这个东西。每英寸显示 72 个点是由 Apple 公司制定的标准，这是很重要的。我相信，你可能听说过，Windows 使用了一个不同的标准，每英寸 96 个点，但是，它不完全正确。我不去深入其中的细节，但是，如果你想进一步了解更多的内容，[阅读 Wikipedia](https://en.wikipedia.org/wiki/Dots_per_inch#Computer_monitor_DPI_standards)。在任何情况下，要确保显示在你的 Linux 笔记本电脑的屏幕上的内容看起来清晰可读，如果你想了解，按以下的内容去做。首先，确定它的显示大小（13.3″、15.6″、17″…）和分辨率。然后到 [PXCALC.com](http://pxcalc.com/) 网站，它提供一个非常好用的每英寸点数计算器。接着在上面输入正确的内容。计算完成后，它告诉你一个 DPI 的计算结果（在它的右上角，如下图所示）。然后将那个值简单地除以 72，这就是最重要的部分。
如果你得到的结果是一个类似于整形增量，比如 2、3、4（+0.2 到 —0.2 的偏差还不错，最好是 +0.1 到 —0.1，最完美的是接近 0.0 的偏差及更大的整数—— 3 或更大，比如 iMac 27 5K），然后，你就没有什么可担心的了。整形增量越高（只要偏差保持在范围之内），屏幕越清晰。为了更好理解，我们举一个例子。
我以推荐给你的第一个笔记本电脑（使用 13.3″ 的 QHD 分辨率的 Dell XPS）为例。如果你使用这个计算器去计算，它的结果是 ‘3.83’，把它粗算为 ‘3.8’，它不是我们前面所说的那样一个整数，但是，它在偏差范围以内（-0.2），是安全的。如果你拿我推荐的 Acer 笔记本电脑做同样的计算，它得到的结果是 ‘1.95’，把它粗算为 ‘2.0’。因此，在不考虑它的其它特性（亮度，可视角度，等等）的情况下，Dell 笔记本电脑上的显示清晰度要好于 Acer 几乎两倍（相信我，这个显示效果已经看起来非常清晰了。但是，它相比分辨率为1366 x 768 的无论是 13.3″ 还是 15.6″ 的屏幕，看起来显示效果更好）。
#### 关于内存大小？
KDE 和 GNOME 是在 Linux 上的两种主流的桌面环境。虽然还有很多其它的选择，我建议你坚持使用其中的一个。目前来说，我比较偏爱 KDE。据我所知，KDE plasma 比 GNOME 更加轻量化，并且效果更好。如果你希望了解它们之间的比较数据，它在 [我的 Ubuntu 16.10 特点评估](https://www.hecticgeek.com/2016/11/ubuntu-16-10-flavors-comparison/) 中（它大概是在一年前做的），在 Ubuntu 上 KDE plasma 占用大约 369 MiB 内存，而 GNOME 大概占用了 781 MiB！减少了 **112% ！**
现在我使用 Kubuntu 17.10，虽然我没有评估它，但是我可以告诉你，它的内存占用大约在 380-400 MiB左右。重新回到这个话题上，我建议你在为你的 Linux 笔记本电脑的内存选择上，**不要低于 8GB**。那样，我可以很自信地保证，在未来 4 年内你的笔记本电脑都运行的很好，而不用担心它会变慢，并且可以去很好的使用各种发行版和满足大多数终端用户的需求。
如果你是在寻找一台 **在 Linux 上玩游戏的笔记本电脑**，那么内存选择应该是 **使用 12GB 或者更多**。 除比之外，8GB 内存对于大多数终端用户来说是足够的。
#### 关于 SSD
不管你使用的是什么操作系统，增加一块 SSD 将能提升你的笔记本电脑的整体性能和反应速度，因为它比起普通的机械硬盘来说速度快很多，就这么简单。也就是说，在我的经验中，即便是高效和轻量化的 KDE 发行版，相比 GNOME 要花更多的启用时间。一些 Linux 发行版，比如 Ubuntu 和 Kubuntu 带着一个特别设计的被称为 'ureadahead' 的实用程序，它可以改善启动时间（有时可以达到 **30%** 甚至更多），不幸的是，并不是所有的发行版都有这类工具。在有些时候，**安装在 SATA 驱动器上的 KDE 的启动时间可能长达 50 秒以上**。[Manjaro 17.0.2 KDE](https://www.hecticgeek.com/2017/07/manjaro-17-0-2-kde-review/) 就是其中一个这样的例子（显示在上面的图表中）。
因此，最简单的方法就是购买一台带有 SSD 的笔记本电脑，它可以帮助改善启动时间。**我的 Kubuntu 17.10 上是一个小的 SSD 驱动器（20GB），它的启动时间在 13-15 秒内**。
#### 关于 GPU ？
正如上面多次提到过的，如果可能，尽量使用一个 Intel GPU。正如众所周知的那样，Dell 的产品在硬件上都是 ‘Linux 友好的’， Intel 也在开源项目上大量进行投资，并且，其中它的一些硬件也如此。选择它你不会后悔的。
#### 如何进行自动 GPU 切换（比如： Nvidia Optimus），它能正常工作吗？
如果你希望购买的笔记本电脑，显卡在各方面都考虑的比较周全，那么，在 Windows 中，Nvidia 有一个叫做 ‘Optimus’ 的特性，它自动在集成 GPU（性能较弱） 和独立 GPU（性能更强）之间切换。ATI 也有这个功能。在 Linux 中这个功能并没有被官方支持，但是，在那方面有一个创新性的工作，比如 [Bumblebee 项目](https://bumblebee-project.org/)。不过它并不总是按预期工作。我比较喜欢去安装专用的 GPU 驱动程序，并且在我需要的时候去手动切换它们。值得称赞的是，Fedora 团队已经做出了它们的解决方案，我并不知道他们做的怎么样，[最好问问 Christian 吧](https://blogs.gnome.org/uraeus/2016/11/01/discrete-graphics-and-fedora-workstation-25/)。
#### Linux 能给你更长的电池使用时间吗？
当然可以！只要你的硬件设备配置正确，我建议你安装电源使用优化器。现在有几个这方面的应用程序，但是，我建议使用 ‘[TLP](http://linrunner.de/en/tlp/docs/tlp-linux-advanced-power-management.html)’。它很容易安装，在我的经验中它可以使功耗降低，而且结果令人影响深刻，它不需要手动去调整什么就可以正常工作。
下面有两张我的最新的 Ubuntu 17.10 的评估截屏。第一张截屏展示了在安装 ‘tlp’ 之前的电源使用情况，而第二张展示了安装之后的（图片已经说明了一切）：
‘tlp’ 可以在主要的 Linux 发行版上使用。在 Ubuntu 上，你可以通过执行下面的命令去安装它：
```
sudo apt update
sudo apt install tlp
```
现在重启动计算机，就可以了！
#### 在 Linux 中能测量电源使用了多少吗？
很高兴你能这样问！它的名字叫 ‘[powerstat](https://www.hecticgeek.com/2012/02/powerstat-power-calculator-ubuntu-linux/)’。它是非常神奇的一个小实用程序（由 Colin King 设计，它是一位 Ubuntu 开发者），它采集电源消耗（和诊断）相关的使用数据，并将它们表示在屏幕上。在基于 Ubuntu 的系统上，输入下面的命令可以去安装它：
```
sudo apt update
sudo apt install powerstat
```
在大多数主流的 Linux 发行版上，它们的软件仓库中都有这个软件。
#### 你推荐的 Linux 操作系统是哪个？
很好的问题，到目前为止，我主要使用的操作系统是 Kubuntu 17.10。我没有评估过它，但是，长话短说，我喜欢它！它非常易于安装，并且对新手比较友好，稳定，漂亮，高效并且易于使用。到目前为止我不喜欢 GNOME！因此，如果你刚开始使用 Linux，那么，我建议你去尝试 [Kubuntu](https://kubuntu.org/) 或者 [Linux Mint](https://linuxmint.com/)，首先，（‘Mint’ 可以有很多的桌面环境选择。要么使用 KDE，要么使用 ‘Cinnamon’）。
然后，在你掌握使用技巧后，你就可以转移到其它的发行版上了，这是 Linux 新手最好的方法。
### 结束语
记住我一开始说的话，如果你在寻找一台能够轻松运行 Linux 的笔记本电脑，那么，[Dell XP S9360-3591-SLV](https://www.amazon.com/gp/product/B01LQTXED8?ie=UTF8&tag=flooclea01-20&camp=1789&linkCode=xm2&creativeASIN=B01LQTXED8) 将是你的最佳选择。它外观漂亮、功能强大、非常流行、超便携，不仅能够很轻松地运行 Linux，而且它还有一个非常棒的，并且得到很多人赞扬的显示屏。
如果，你希望有一个更便宜的选择，那么，[Acer Aspire E 15 E5-575G-57D4](https://www.amazon.com/gp/product/B01LD4MGY4?ie=UTF8&tag=flooclea01-20&camp=1789&linkCode=xm2&creativeASIN=B01LD4MGY4) 会满足你的要求。它也像前面的 Dell 一样，可以很好地兼容 Linux，再加上它的性价比，它也是一个非常好的选择。
第三，如果你在寻找一台能够在 Linux 上运行游戏的笔记本电脑，那么，[Dell Inspiron i5577-7342BLK-PUS](https://www.amazon.com/gp/product/B06XFC44CL?ie=UTF8&tag=flooclea01-20&camp=1789&linkCode=xm2&creativeASIN=B06XFC44CL) 看起来非常适合你。当然，还有许多其它的游戏笔记本，但是，我特别选择这一款的原因是，它的硬件特性与 Linux 兼容，虽然我不能保证它与 Nvidia GTX 1050 一样。换句话说，你不应该去买一台 Linux 笔记本去玩游戏，那样会“玷污”你的游戏水平。如果是那样的话，它的硬件性能（它的性能很强大了）并不会让你满意，如果你愿意去研究并找到其它的选择，那就去做吧。
祝你采购顺利，并感谢阅读！
---
via: <https://www.hecticgeek.com/2017/12/best-linux-laptop/>
作者：[Gayan](https://www.hecticgeek.com/author/gayan/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Ubuntu 16.04 LTS 上用 Tomb 加密文件
|
Dan Fries
|
https://www.howtoforge.com/tutorial/how-to-install-and-use-tomb-file-encryption-on-ubuntu-1604/
|
如今，大多数人都认为文件加密是必要的，甚至在 Linux 系统上也是如此。
|
/data/attachment/album/201802/18/234345rz1g9a15v97go1fg.png.thumb.jpg
|
/data/attachment/album/201802/18/234345rz1g9a15v97go1fg.png
| true | false | true |
Auk7F7
| false |
[
"加密",
"Tomb",
"Veracrypt"
] |
技术
|
{
"viewnum": 7824,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如今，大多数人都认为文件加密是必要的，甚至在 Linux 系统上也是如此。
| 2018-02-18T23:43:00 | 2018-02-18T23:43:00 | 9,361 |
/article-9361-1.html
|
如今，大多数人都认为文件加密是必要的，甚至在 Linux 系统上也是如此。 如果你和我一样, 最初被 Ubuntu 所吸引是因为 Linux 系统强化的安全性，恐怕我有个坏消息要告诉你：Linux 已经成为它自身“成功”的受害者。 近年来，用户数量的大幅度增加导致了这类系统的攻击和盗窃活动呈指数级增长。
曾经有一个非常简单的解决方案来在像 Ubuntu 这样的 Linux 系统上加密文件：它叫做 [Truecrypt](https://www.fossmint.com/secure-encrypt-files-folders-with-truecrypt-in-linux/)。 直到 2015 年，它提供了不同程度的军事级别的加密，并且在大多数 Linux 系统中运行良好。不幸的是, 它已经停止开发了, 因此变得相当不安全。
### 替代品
幸运的是，除了 Truecrypt，还有一些选择。 Truecrypt 的直接继承者是 [Veracrypt](https://www.fossmint.com/veracrypt-is-a-secure-alternative-encryption-tool-to-truecrypt-for-linux/) ，它由一群开发者从 Truecrypt 获取源代码并保持更新的。
该项目已经发展成为令人印象深刻的独立系统，但现在渐已老迈。旧系统，尤其是那些处理安全问题的系统，只能更新多次而才不会引入漏洞。
出于这个原因，在其他许多方面，应该寻找一个更外围一些的加密软件。我选择的是 Tomb。
### 为什么是 Tomb
在某些方面，Tomb 与其他加密软件非常相似。它将加密文件存储在专用的“Tomb 文件夹”中，可以让你快速查看您已加密的文件。
它还使用与 Veracrypt 类似的 [AES-256](https://www.dyne.org/software/tomb/) 加密标准。这个标准适用于 NSA 、微软和 Apple，并被认为是最安全的加密算法之一。如果你不熟悉加密技术，则应该阅读一点[技术背景知识](https://thebestvpn.com/advanced-encryption-standard-aes/)，但如果你只想快速、安全地加密，请不要担心， Tomb 将不负所望。
Tomb 也有一些很大的不同之处。首先，它是专门为 GNU/Linux 系统开发的，可以解决一些更广泛的加密软件的兼容性问题。
第二，尽管 Tomb 是开源的，但它使用的是静态链接库，以至于其源代码难以审计。 这意味着一些操作系统发行版开发者并不认为它是自由的，但是当涉及到安全软件时，这实际上是一件好事：这意味着与完全“自由”软件相比, Tomb 被黑客攻击的可能性更小。
最后，它有几个先进的功能，如<ruby> 隐写术 <rt> steganography </rt></ruby>，这使你可以将你的关键文件隐藏在其他文件中。 尽管 Tomb 主要是一个命令行工具，它也带有 GUI 界面—— gtomb，它允许初学者用图形化的方式使用它。
这是推销么? 好吧，在我告诉你如何使用 Tomb 之前，值得注意的是，没有一个加密软件能提供完全的保护。 Tomb 不会让你的计算机隐藏于你 ISP，也不会保护存储在云中的文件。如果你想对云存储进行完全加密，您需要使用 Tor 浏览器和零日志 VPN 登录到你喜欢的存储服务中。 这里有很多选项，但是 [Trust Zone](https://privacyaustralia.org/trust-zone-vpn-review/) 是一个很好的浏览器，而 [Tinc](https://www.howtoforge.com/tutorial/how-to-properly-set-up-tinc-vpn-on-ubuntu-linux/) 是一个很好的 VPN 工具。
说了这么多，如果你正在寻找 Ubuntu 16.04 上的快速、简单、安全的加密，Tomb 无疑是一条可行的路。让我们开始吧。
### 在 Ubuntu 16.04 上安装 Tomb
因为 Tomb 是专门为 Linux 设计的, 所以安装非常简单。
几年前，SparkyLinux （它本身就是一个非常好的 Debian 衍生产品）的开发者们将 “Tomb” 添加到他们的官方存储库中。 你可以通过在 Ubuntu 系统上添加这些存储库来安装它。
要做到这一点， 打开一个终端并添加一个存储库文件：
```
sudo vi /etc/apt/sources.list.d/sparky-repo.list
```
然后在文件中添加以下行：
```
deb https://sparkylinux.org/repo stable main
deb-src https://sparkylinux.org/repo stable main
deb https://sparkylinux.org/repo testing main
deb-src https://sparkylinux.org/repo testing main
```
保存并关闭该文件。
你现在需要安装 Sparky 公钥，使用下列步骤：
```
sudo apt-get install sparky-keyring
```
或者：
```
wget -O - https://sparkylinux.org/repo/sparkylinux.gpg.key | sudo apt-key add -
```
然后你需要使用标准的命令来更新你的存储库：
```
sudo apt-get update
```
然后简单地使用 `apt` 安装 Tomb：
```
sudo apt-get install tomb
```
如果你想要带有 GUI 的 Tomb，安装同样简单。只需使用 `apt` 来安装 gtomb：
```
sudo apt-get install gtomb
```
就是这样，你现在应该安装好了一个可以工作的 Tomb。 让我们看看如何使用它。
### 使用 Tomb
#### 通过命令行使用 Tomb
Tomb 主要是一个命令行工具，所以我将首先介绍这个用法。 如果你不喜欢使用终端，你可以跳过这节并查看下一部分。
实际上，不用说了。 如果你以前从来没有使用过命令行，那么 Tomb 是一个很好的开始，因为它使用简单的命令，只要你小心，那么你很少有机会把事情搞砸。
Tomb 实际上使用了一组以墓地为主题的非常有趣的命令集。 每个加密文件夹都被称为“tomb”（墓碑） ，而且（我很快就会讲到) ，它们可以使用类似的哥特式命令。
首先，让我们创造（挖）一个新的 tomb。你可以指定你的新 tomb 的名称和大小，所以让我们使用 “Tomb1”这个名称并指定大小为 100 MB。
你需要 root 权限，所以打开终端并键入（或复制） ：
```
sudo tomb dig -s 100 Tomb1.tomb
```
你应该会得到类似这样的输出：
```
tomb . Commanded to dig tomb Tomb1.tomb
tomb (*) Creating a new tomb in Tomb1.tomb
tomb . Generating Tomb1.tomb of 100MiB
100 blocks (100Mb) written.
100+0 records in
100+0 records out
-rw------- 1 Tomb1 Tomb1 100M Jul 4 18:53 Tomb1.tomb
tomb (*) Done digging Tomb1
tomb . Your tomb is not yet ready, you need to forge a key and lock it:
tomb . tomb forge Tomb1.tomb.key
tomb . tomb lock Tomb1.tomb -k Tomb1.tomb.key
```
正如输出的帮助说明，你现在需要创建（打造）一个密钥文件来锁定你的 tomb：
```
sudo tomb forge Tomb1.tomb.key
```
如果在此时出现提及“活动交换分区”的错误，则需要停用所有活动交换分区:
```
sudo swapoff -a
```
然后再运行上面的 keyfile 命令。
生成密钥文件可能需要几分钟时间，这具体取决于系统的速度。然而，在完成后系统会要求你输入新密码以确保密钥的安全：
[](https://www.howtoforge.com/images/how_to_setup_and_install_tomb_on_ubuntu_1604/big/tomb1.png)
输入两次，然后你的新密钥文件就会被制作出来。
你现在需要用你的新密钥来锁定你的 tomb。你可以这样做：
```
sudo tomb lock Tomb1.tomb -k Tomb1.tomb.key
```
你将被要求输入你的密码。 这样做, 你应该会得到如下的输出：
```
tomb . Commanded to lock tomb Tomb1.tomb
[sudo] Enter password for user Tomb1 to gain superuser privileges
tomb . Checking if the tomb is empty (we never step on somebody else's bones).
tomb . Fine, this tomb seems empty.
tomb . Key is valid.
tomb . Locking using cipher: aes-xts-plain64:sha256
tomb . A password is required to use key Tomb1.tomb.key
tomb . Password OK.
tomb (*) Locking Tomb1.tomb with Tomb1.tomb.key
tomb . Formatting Luks mapped device.
tomb . Formatting your Tomb with Ext3/Ext4 filesystem.
tomb . Done locking Tomb1 using Luks dm-crypt aes-xts-plain64:sha256
tomb (*) Your tomb is ready in Tomb1.tomb and secured with key Tomb1.tomb.key
```
现在一切都安排好了，你可以开始使用你的新 tomb 了。
这里有一个注意事项：因为我只是在告诉你该怎么做，所以我把我的密钥文件和 tomb 存放在同一个目录中（在这里是 `$HOME`）。 你不应该这样做——把你的密钥存放在别的地方，最好是在除了你之外没有人能找到的地方。
然而，你需要记住你把它放在哪里，因为你需要用它来打开你的 tomb。 要做到这一点, 请输入：
```
sudo tomb open Tomb1.tomb -k path/to/your/Tomb1.tomb.key
```
输入你的密码，然后你就可以进去了。 tomb 会输出一些类似以下的内容:
```
tomb (*) Success unlocking tomb Tomb1
tomb . Checking filesystem via /dev/loop0
fsck from util-linux 2.27.1
Tomb1: clean, 11/25168 files, 8831/100352 blocks
tomb (*) Success opening Tomb1.tomb on /media/Tomb1
```
然后你应该看到你的新 tomb 挂载在了 finder 窗口。
你现在可以从 tomb 中保存和打开文件，但是请注意，你需要 root权限才能这样做。
在你使用完之后需要用以下方法卸载你的 tomb：
```
sudo tomb close
```
或者，如果你想强制关闭所有的打开的 tomb, 你可以使用：
```
sudo tomb slam all
```
#### 使用带 GUI 的 Tomb
如果你不喜欢使用命令行，或者只是想要一个图形界面，你可以使用 gtomb。与许多图形用户界面包装器不同， gtomb 使用起来很容易。
让我们来看看如何使用 gtomb 建立一个新的 tomb。 首先，从菜单中启动 gtomb。 它可能会是这 样的：
[](https://www.howtoforge.com/images/how_to_setup_and_install_tomb_on_ubuntu_1604/big/tomb2.png)
所有的事情都是一目了然的，但为了完整起见，我将详细介绍如何建立你的第一个 tomb。
首先，点击第一个选项“dig”。 点击确定，然后选择一个位置。
接下来，输入你的 tomb 的大小：
[](https://www.howtoforge.com/images/how_to_setup_and_install_tomb_on_ubuntu_1604/big/tomb3.png)
你现在有了一个新的 tomb，但是你需要在使用它之前做一把钥匙。 要做到这一点, 请在主菜单中 单击“forge”：
[](https://www.howtoforge.com/images/how_to_setup_and_install_tomb_on_ubuntu_1604/big/tomb4.png)
Tomb 会要求你输入两次密码，那就这样做。
然后通过点击来使用密钥锁定你的 tomb，你已经猜到了，“lock”。 要打开它, 请单击“open”并再次输入您的密码。
从上面的截图中你可以看到，使用 gtomb 是非常容易的，你不应该遇到任何问题。 大多数常见的任务都可以通过点击来完成，对于任何更复杂的事情，你可以使用命令行。
### 最后的想法
就是这样！你现在应该准备好你的第一个 tomb 了，并存储任何你想在 tomb 中保密和安全的信息，这些信息会更加安全。
你可以同时使用多个 tomb，并将它们中的文件绑定到你的 `$HOME` 目录，这样你的程序就不会感到困惑。
我希望这本指南能帮助你开始。 就像使用一个标准的文件夹一样使用你的 Tomb，但是对于更复杂的命令，你总是可以查看 [Tomb 官方指南](https://www.dyne.org/software/tomb/)。
---
via: <https://www.howtoforge.com/tutorial/how-to-install-and-use-tomb-file-encryption-on-ubuntu-1604/>
作者： [Dan Fries](https://www.howtoforge.com/) 选题： [lujun9972](https://github.com/lujun9972) 译者： [Auk7F7](https://github.com/Auk7F7) 校对： [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
脚本编程之骰子游戏
|
Dave Taylor
|
http://www.linuxjournal.com/content/shell-scripting-bunco-game
|
Bunco：一个使你的“快艇”游戏看起来更复杂的掷骰子游戏。
|
/data/attachment/album/201802/20/132105bq9fgubptg9011yu.jpg.thumb.jpg
|
/data/attachment/album/201802/20/132105bq9fgubptg9011yu.jpg
| true | false | true |
wenwensnow
| false |
[
"骰子",
"游戏"
] |
软件开发
|
{
"viewnum": 4915,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9071,
"displayorder": 0
}
] |
Bunco：一个使你的“快艇”游戏看起来更复杂的掷骰子游戏。
| 2018-02-20T13:21:00 | 2018-02-20T13:21:00 | 9,362 |
/article-9362-1.html
|
>
> Bunco：一个使你的“快艇”游戏看起来更复杂的掷骰子游戏。
>
>
>
我已经有段时间没有编写游戏了，所以我觉得现在正是做一些这方面事情的时候。起初，我想“用脚本编一个 Halo游戏？”（LCTT 译注：Halo，光晕系列游戏），但我后来意识到这不太可能。来编一个叫 Bunco 的简单骰子游戏吧。你也许没有听说过，不过你母亲绝对知道 —— 当一群年轻女孩聚在当地的酒吧或者小酒馆的时候，这是个很受欢迎的游戏。
游戏一共六轮，有三个骰子，规则很简单。每次投三个骰子，投出的点数要和当前的轮数数字一致。如果三个骰子都和当前的轮数一致，(比如，在第三轮三个骰子都是 3)，你这一轮的分数就是 21。 如果三个骰子点数都相同但和轮数数字不同，你会得到最低的 Bunco 分数，只有 5 分。如果你投出的点数两者都不是，每一个和当前轮数相同的骰子得 1 分。
要想玩这个游戏，它还涉及到团队合作，每一队（包括赢的那队），每人付 5 美元现金，或赢家得到其他类似现金奖励，并规定什么样的情况下才是赢家，例如“最多 Buncos” 或“最大点数”的情况下胜利。在这里我会跳过这些，而只关注投骰子这一部分。
### 关于数学逻辑部分
在专注于编程这方面的事之前，我先简单说说游戏背后的数学逻辑。要是有一个适当重量的骰子投骰子会变得很容易，任意一个值出现概率都是 1/6。
完全随机小提示：不确定你的骰子是否每个面都是一样重量? 把它们扔进盐水里然后掷一下。YouTube 上有一些有趣的 D&D 世界的视频向你展示了怎么来做这个测试。
所以三个骰子点数一样的几率有多大? 第一个骰子 100% 会有一个值 (这儿没什么可说的)，所以很简单。第二个则有 16.66% 的概率和第一个骰子的值一样，接下来第三个骰子也是一样。 但当然，总概率是三个概率相乘的结果，所以最后，三个骰子值相等的概率是 2.7%。
接下来，每个骰子和当前轮数数字相同的概率都是 16.66%。从数学角度来说：0.166 \* 0.166 \* 0.166 = 0.00462 。
换句话说，你有 0.46% 的可能性投出 Bunco，比 200 次中出现一次的可能性还小一点。
实际上还可以更难。如果你有 5 个骰子，投出 Mini Bunco (也可以叫做 Yahtzee “快艇”) 的概率为 0.077%，如果你想所有的骰子的值都相同，假设都是 6，那概率就是 0.00012%，那就基本上没什么可能了。
### 开始编程吧
和所有游戏一样，最难的部分是有一个能生成真正的随机数的随机数发生器。这一部分在 shell 脚本中还是很难实现的，所以我需要先回避这个问题，并假设 shell 内置的随机数发生器就够用了。
不过好在内置的随机数发生器很好用。用 `$RANDOM` 就能得到一个 `0` 到 `MAXINT(32767)` 之间的随机值：
```
$ echo $RANDOM $RANDOM $RANDOM
10252 22142 14863
```
为了确保产生的值一定是 `1` - `6` 之中的某个值，使用取余函数：
```
$ echo $(( $RANDOM % 6 ))
3
$ echo $(( $RANDOM % 6 ))
0
```
哦！我忘了要加 `1`，下面是另一次尝试：
```
$ echo $(( ( $RANDOM % 6 ) + 1 ))
6
```
下面要实现投骰子这一功能。这个函数中你可以声明一个局部变量来存储生成的随机值：
```
rolldie()
{
local result=$1
rolled=$(( ( $RANDOM % 6 ) + 1 ))
eval $result=$rolled
}
```
使用 `eval` 确保生成的随机数被实际存储在变量中。这一部分也很容易：
```
rolldie die1
```
这会为第一个骰子生成一个 `1` - `6` 之间的随机值存储到 `die1` 中。要掷 3 个骰子，很简单：
```
rolldie die1 ; rolldie die2 ; rolldie die3
```
现在判断下生成的值。首先，判断是不是 Bunco（3 个骰子值相同），然后是不是和当前轮数值也相同：
```
if [ $die1 -eq $die2 ] && [ $die2 -eq $die3 ] ; then
if [ $die1 -eq $round ] ; then
echo "BUNCO!"
score=25
else
echo "Mini Bunco!"
score=5
fi
```
这可能是所有判断语句中最难的部分了，注意第一个条件语句中这种不常用的写法 ： `[ cond1 ] && [ cond2 ]`。如果你想写成 `cond1 -a cond2` ，这样也可以。在 shell 编程中，解决问题的方法往往不止一种。
代码剩下的部分很直白，你只需要判断每个骰子的值是不是和本轮数字相同：
```
if [ $die1 -eq $round ] ; then
score=1
fi
if [ $die2 -eq $round ] ; then
score=$(( $score + 1 ))
fi
if [ $die3 -eq $round ] ; then
score=$(( $score + 1 ))
fi
```
唯一要注意的是当出现 Bunco/Mini Bunco 就不需要再统计本轮分数了。所以整个第二部分的判断语句都要写在第一个条件语句的 `else` 中（为了判断 3 个骰子值是否都相同）。
把所有的综合起来，然后在命令行中输入轮数，下面是现在的脚本执行后的结果：
```
$ sh bunco.sh 5
You rolled: 1 1 5
score = 1
$ sh bunco.sh 2
You rolled: 6 4 3
score = 0
$ sh bunco.sh 1
You rolled: 1 1 1
BUNCO!
score = 25
```
竟然这么快就出现 Bunco 了? 好吧，就像我说的，shell 内置的随机数发生器在随机数产生这方面可能有些问题。
你可以再写个脚本测试一下，去运行上述脚本几百次，然后看看 Bunco/Mini Bunco 出现次数所占的百分比。但是我想把这部分作为练习，留给亲爱的读者你们。不过，也许我下次会抽时间完成剩下的部分。
让我们完成这一脚本吧，还有分数统计和一次性执行 6 次投骰子（这次不用再在命令行中手动输入当前轮数了）这两个功能。这也很容易，因为只是将上面的内容整个嵌套在里面，换句话说，就是将一个复杂的条件嵌套结构全部写在了一个函数中：
```
BuncoRound()
{
# roll, display, and score a round of bunco!
# round is specified when invoked, score added to totalscore
local score=0 ; local round=$1 ; local hidescore=0
rolldie die1 ; rolldie die2 ; rolldie die3
echo Round $round. You rolled: $die1 $die2 $die3
if [ $die1 -eq $die2 ] && [ $die2 -eq $die3 ] ; then
if [ $die1 -eq $round ] ; then
echo " BUNCO!"
score=25
hidescore=1
else
echo " Mini Bunco!"
score=5
hidescore=1
fi
else
if [ $die1 -eq $round ] ; then
score=1
fi
if [ $die2 -eq $round ] ; then
score=$(( $score + 1 ))
fi
if [ $die3 -eq $round ] ; then
score=$(( $score + 1 ))
fi
fi
if [ $hidescore -eq 0 ] ; then
echo " score this round: $score"
fi
totalscore=$(( $totalscore + $score ))
}
```
我承认，我忍不住自己做了一点改进，包括判断当前是 Bunco、Mini Bunco 还是其他需要计算分数的情况这一部分 （这就是 `$hidescore` 这一变量的作用）。
实现这个简直是小菜一碟，只要一个循环就好了：
```
for round in {1..6} ; do
BuncoRound $round
done
```
这就是现在所写的整个程序。让我们执行一下看看结果：
```
$ sh bunco.sh 1
Round 1\. You rolled: 2 3 3
score this round: 0
Round 2\. You rolled: 2 6 6
score this round: 1
Round 3\. You rolled: 1 2 4
score this round: 0
Round 4\. You rolled: 2 1 4
score this round: 1
Round 5\. You rolled: 5 5 6
score this round: 2
Round 6\. You rolled: 2 1 3
score this round: 0
Game over. Your total score was 4
```
嗯。并不是很令人满意，可能是因为它只是游戏的一次完整执行。不过，你可以将脚本执行几百几千次，记下“Game over”出现的位置，然后用一些快速分析工具来看看你在每 6 轮中有几次得分超过 3 分。（要让 3 个骰子值相同，这个概率大概在 50% 左右）。
无论怎么说，这都不是一个复杂的游戏，但是它是一个很有意思的小程序项目。现在，如果有一个 20 面的骰子，每一轮游戏有好几十轮，每轮都掷同一个骰子，情况又会发生什么变化呢?
---
via: <http://www.linuxjournal.com/content/shell-scripting-bunco-game>
作者：[Dave Taylor](http://www.linuxjournal.com/users/dave-taylor) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
菜鸟们，通过这几个例子，包你学会 uptime 命令的用法
|
Himanshu Arora
|
https://www.howtoforge.com/linux-uptime-command/
|
望名生义，uptime 命令告诉你系统启动了（运行了）多长时间。这是语法：
|
/data/attachment/album/201802/20/143517d5vkxnsiziu5lqbu.jpg.thumb.jpg
|
/data/attachment/album/201802/20/143517d5vkxnsiziu5lqbu.jpg
| true | false | true |
lujun9972
| false |
[
"uptime",
"启动"
] |
技术
|
{
"viewnum": 4218,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
望名生义，uptime 命令告诉你系统启动了（运行了）多长时间。这是语法：
| 2018-02-20T14:35:23 | 2018-02-20T14:35:23 | 9,363 |
/article-9363-1.html
|
Linux 小白，若对系统管理有兴趣，或想成为资深用户，就需要对命令行有扎实的功底。你需要知道很多命令，其中一个就是 `uptime`。文本我们会通过一些容易理解的案例来讲解一下这个命令的基本用法。
再开始前有必要说一下，文中的所有案例都在 Ubuntu 16.04 上测试过了。
### Linux uptime 命令
望名生义，`uptime` 命令告诉你系统<ruby> 启动 <rt> up </rt></ruby>了（运行了）多长时间。这是语法：
```
uptime [options]
```
这个工具的 man 页是这么说的：
>
> `uptime`会在一行中显示下列信息：当前时间、系统运行了多久时间、当前登录的用户有多少，以及前 1、5 和 15 分钟系统的平均负载。
>
>
>
下面这些问答形式的案例应该会让你对 `uptime` 命令有更好的了解。
### Q1、如何使用 uptime 命令
`uptime` 的基础用法很简单 —— 只需要输入命令名称然后按下回车就行。
```
uptime
```
这是输出：
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/uptime-basic-usage1.png)
这里，第一项是当前时间，`up` 表示系统正在运行，`5:53` 是系统启动的总时间，最后是系统的<ruby> 负载 <rt> load </rt></ruby>信息。若你想深入了解，这里是 uptime man 页中关于最后一项信息的说明：
>
> 系统负载是处于<ruby> 可运行 <rt> runnable </rt></ruby>或<ruby> 不可中断 <rt> uninterruptable </rt></ruby>状态的进程的平均数。可运行状态的进程要么正在使用 CPU 要么在等待使用 CPU。 不可中断状态的进程则正在等待某些 I/O 访问，例如等待磁盘 IO。
>
>
> 有三个时间间隔的平均值。负载均值的意义根据系统中 CPU 的数量不同而不同，负载为 1 对于一个只有单 CPU 的系统来说意味着负载满了，而对于一个拥有 4 CPU 的系统来说则意味着 75% 的时间里都是空闲的。
>
>
>
### Q2、如何以更人性化的格式现实时间
若你只想知道系统运行了多长时间，而且希望以更人性化的格式来显示，那么可以使用 `-p` 项。
```
uptime -p
```
这是输出：
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/uptime-p-option.png)
### Q3、如何让 uptime 显示系统启动的日期/时间
你也可以指定 `uptme` 显示系统开始运行的时间和日期。方法是使用 `-s` 命令项。
```
uptime -s
```
这是输出：
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/uptime-s.png)
### Q4、如何获取版本信息和帮助信息
`-V` 获取版本信息，`-h` 获取帮助信息。
```
uptime -V
uptime -h
```
[](https://www.howtoforge.com/images/usage_of_pfsense_to_block_dos_attack_/big/uptime-v-h.png)
### 结论
你可以看到，uptime 命令很容易理解也很容易使用。它没有提供很多的功能（命令选项也很少）。这里已经覆盖了它的所有功能了。因此只需要练习一下这些选项你就能在日常工作中使用它了。如果需要的话，你也可以查看它的 [man 页](https://linux.die.net/man/1/uptime)。
---
via: <https://www.howtoforge.com/linux-uptime-command/>
作者：[Himanshu Arora](https://www.howtoforge.com) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
什么是网络爬虫？网络爬虫如何工作？
|
Rishabh Kandari
|
http://www.theitstuff.com/web-crawler-web-crawlers-work
|
作为一个狂热的互联网人，你在生活中一定遇到过网络爬虫（Web Crawler）这个词。那么什么是网络爬虫，谁使用网络爬虫？它是如何工作的？让我们在本文中讨论这些。
|
/data/attachment/album/201802/20/144220dz8isfp9ebsede8d.jpg.thumb.jpg
|
/data/attachment/album/201802/20/144220dz8isfp9ebsede8d.jpg
| true | false | true |
geekpi
| false |
[
"爬虫",
"蜘蛛"
] |
技术
|
{
"viewnum": 4349,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
作为一个狂热的互联网人，你在生活中一定遇到过网络爬虫（Web Crawler）这个词。那么什么是网络爬虫，谁使用网络爬虫？它是如何工作的？让我们在本文中讨论这些。
| 2018-02-20T14:42:16 | 2018-02-20T14:42:16 | 9,364 |
/article-9364-1.html
|
作为一个狂热的互联网人，你在生活中一定遇到过<ruby> 网络爬虫 <rt> Web Crawler </rt></ruby>这个词。那么什么是网络爬虫，谁使用网络爬虫？它是如何工作的？让我们在本文中讨论这些。
### 什么是网络爬虫？
[](http://www.theitstuff.com/wp-content/uploads/2017/12/crawler.jpeg)
<ruby> 网络爬虫 <rt> Web Crawler </rt></ruby>也被称为<ruby> 网络蜘蛛 <rt> web-spider </rt></ruby>是一个在互联网中访问不同网站的各个页面的互联网软件或者机器人。网络爬虫从这些网页中检索各种信息并将其存储在其记录中。这些抓取工具主要用于从网站收集内容以改善搜索引擎的搜索。
### 谁使用网络爬虫？
大多数搜索引擎使用爬虫来收集来自公共网站的越来越多的内容，以便它们可以向用户提供更多相关内容。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/sengine.png)
许多商业机构使用网络爬虫专门搜索人们的电子邮件地址和电话号码，以便他们可以向你发送促销优惠和其他方案。这基本上是垃圾邮件，但这是大多数公司创建邮件列表的方式。
黑客使用网络爬虫来查找网站文件夹中的所有文件，主要是 HTML 和 Javascript。然后他们尝试通过使用 XSS 来攻击网站。
### 网络爬虫如何工作？
网络爬虫是一个自动化脚本，它所有行为都是预定义的。爬虫首先从要访问的 URL 的初始列表开始，这些 URL 称为种子。然后它从初始的种子页面确定所有其他页面的超链接。网络爬虫然后将这些网页以 HTML 文档的形式保存，这些 HTML 文档稍后由搜索引擎处理并创建一个索引。
### 网络爬虫和 SEO
网络爬虫对 SEO，也就是<ruby> 搜索引擎优化 <rt> Search Engine Optimization </rt></ruby>有很大的影响。由于许多用户使用 Google，让 Google 爬虫为你的大部分网站建立索引非常重要。这可以通过许多方式来完成，包括不使用重复的内容，并在其他网站上具有尽可能多的反向链接。许多网站被认为是滥用这些技巧，最终被引擎列入黑名单。
### robots.txt
`robots.txt` 是爬虫在抓取你的网站时寻找的一种非常特殊的文件。该文件通常包含有关如何抓取你的网站的信息。一些网站管理员故意不希望他们的网站被索引也可以通过使用 `robots.txt` 文件阻止爬虫。
### 总结
爬虫是一个小的软件机器人，可以用来浏览很多网站，并帮助搜索引擎从网上获得最相关的数据。
---
via: <http://www.theitstuff.com/web-crawler-web-crawlers-work>
作者：[Rishabh Kandari](http://www.theitstuff.com/author/reevkandari) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 中如何编写基本的 udev 规则
|
Egidio Docile
|
https://linuxconfig.org/tutorial-on-how-to-write-basic-udev-rules-in-linux
|
理解 udev 背后的基本概念，学习如何写简单的规则。
|
/data/attachment/album/201802/20/150625yjhjrmmrzvsmmy6e.jpg.thumb.jpg
|
/data/attachment/album/201802/20/150625yjhjrmmrzvsmmy6e.jpg
| true | false | true |
qhwdw
| false |
[
"udev"
] |
技术
|
{
"viewnum": 9001,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
理解 udev 背后的基本概念，学习如何写简单的规则。
| 2018-02-20T15:06:32 | 2018-02-20T15:06:32 | 9,365 |
/article-9365-1.html
|
### 读者对象
理解 udev 背后的基本概念，学习如何写简单的规则。
### 要求
* root 权限
### 难度
中等
### 约定
* `#` - 要求给定的命令使用 root 权限或者直接以一个 root 用户或者使用 `sudo` 命令去运行。
* `$` - 要求给定的命令以一个普通的非特权用户运行。
### 介绍
在 GNU/Linux 系统中，虽然设备的底层支持是在内核层面处理的，但是，它们相关的事件管理是在用户空间中通过 `udev` 来管理的。确切地说是由 `udevd` 守护进程来完成的。学习如何去写规则，并应用到发生的这些事件上，将有助于我们修改系统的行为并使它适合我们的需要。
### 规则如何组织
udev 规则是定义在一个以 `.rules` 为扩展名的文件中。那些文件主要放在两个位置：`/usr/lib/udev/rules.d`，这个目录用于存放系统安装的规则；`/etc/udev/rules.d/` 这个目录是保留给自定义规则的。
定义那些规则的文件的命名惯例是使用一个数字作为前缀（比如，`50-udev-default.rules`），并且以它们在目录中的词汇顺序进行处理的。在 `/etc/udev/rules.d` 中安装的文件，会覆盖安装在系统默认路径中的同名文件。
### 规则语法
如果你理解了 udev 规则的行为逻辑，它的语法并不复杂。一个规则由两个主要的节构成：`match` 部分，它使用一系列用逗号分隔的键定义了规则应用的条件，而 `action` 部分，是当条件满足时，我们执行一些动作。
### 测试案例
讲解可能的选项的最好方法莫过于配置一个真实的案例，因此，我们去定义一个规则作为演示，当鼠标被连接时禁用触摸板。显然，在该规则定义中提供的属性将反映我的硬件。
我们将在 `/etc/udev/rules.d/99-togglemouse.rules` 文件中用我们喜欢的文本编辑器来写我们的规则。一条规则定义允许跨多个行，但是，如果是这种情况，必须在一个换行字符之前使用一个反斜线（`\`）表示行的延续，就和 shell 脚本一样。这是我们的规则：
```
ACTION=="add" \
, ATTRS{idProduct}=="c52f" \
, ATTRS{idVendor}=="046d" \
, ENV{DISPLAY}=":0" \
, ENV{XAUTHORITY}="/run/user/1000/gdm/Xauthority" \
, RUN+="/usr/bin/xinput --disable 16"
```
我们来分析一下这个规则。
### 操作符
首先，对已经使用以及将要使用的操作符解释如下：
#### == 和 != 操作符
`==` 是相等操作符，而 `!=` 是不等于操作符。通过使用它们，我们可以确认规则上应用的键是否匹配各自的值。
#### 分配操作符 = 和 :=
`=` 是赋值操作符，是用于为一个键赋值。当我们想要赋值，并且想确保它不会被其它规则所覆盖，我们就需要使用 `:=` 操作符来代替，使用这个操作符分配的值，它就不能被改变。
#### += 和 -= 操作符
`+=` 和 `-=` 操作符各自用于从一个指定的键定义的值列表中增加或者移除一个值。
### 我们使用的键
现在，来分析一下在这个规则中我们使用的键。首先，我们有一个 `ACTION` 键：通过使用它，当在一个设备上发生了特定的事件，我们将指定我们要应用的规则的具体内容。有效的值有 `add`、`remove` 以及 `change`。
然后，我们使用 `ATTRS` 关键字去指定一个属性去匹配。我们可以使用 `udevadm info` 命令去列出一个设备属性，提供它的名字或者 `sysfs` 路径即可：
```
udevadm info -ap /devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.2/2-1.2:1.1/0003:046D:C52F.0010/input/input39
Udevadm info starts with the device specified by the devpath and then
walks up the chain of parent devices. It prints for every device
found, all possible attributes in the udev rules key format.
A rule to match, can be composed by the attributes of the device
and the attributes from one single parent device.
looking at device '/devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.2/2-1.2:1.1/0003:046D:C52F.0010/input/input39':
KERNEL=="input39"
SUBSYSTEM=="input"
DRIVER==""
ATTR{name}=="Logitech USB Receiver"
ATTR{phys}=="usb-0000:00:1d.0-1.2/input1"
ATTR{properties}=="0"
ATTR{uniq}==""
looking at parent device '/devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.2/2-1.2:1.1/0003:046D:C52F.0010':
KERNELS=="0003:046D:C52F.0010"
SUBSYSTEMS=="hid"
DRIVERS=="hid-generic"
ATTRS{country}=="00"
looking at parent device '/devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.2/2-1.2:1.1':
KERNELS=="2-1.2:1.1"
SUBSYSTEMS=="usb"
DRIVERS=="usbhid"
ATTRS{authorized}=="1"
ATTRS{bAlternateSetting}==" 0"
ATTRS{bInterfaceClass}=="03"
ATTRS{bInterfaceNumber}=="01"
ATTRS{bInterfaceProtocol}=="00"
ATTRS{bInterfaceSubClass}=="00"
ATTRS{bNumEndpoints}=="01"
ATTRS{supports_autosuspend}=="1"
looking at parent device '/devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.2':
KERNELS=="2-1.2"
SUBSYSTEMS=="usb"
DRIVERS=="usb"
ATTRS{authorized}=="1"
ATTRS{avoid_reset_quirk}=="0"
ATTRS{bConfigurationValue}=="1"
ATTRS{bDeviceClass}=="00"
ATTRS{bDeviceProtocol}=="00"
ATTRS{bDeviceSubClass}=="00"
ATTRS{bMaxPacketSize0}=="8"
ATTRS{bMaxPower}=="98mA"
ATTRS{bNumConfigurations}=="1"
ATTRS{bNumInterfaces}==" 2"
ATTRS{bcdDevice}=="3000"
ATTRS{bmAttributes}=="a0"
ATTRS{busnum}=="2"
ATTRS{configuration}=="RQR30.00_B0009"
ATTRS{devnum}=="12"
ATTRS{devpath}=="1.2"
ATTRS{idProduct}=="c52f"
ATTRS{idVendor}=="046d"
ATTRS{ltm_capable}=="no"
ATTRS{manufacturer}=="Logitech"
ATTRS{maxchild}=="0"
ATTRS{product}=="USB Receiver"
ATTRS{quirks}=="0x0"
ATTRS{removable}=="removable"
ATTRS{speed}=="12"
ATTRS{urbnum}=="1401"
ATTRS{version}==" 2.00"
[...]
```
上面截取了运行这个命令之后的输出的一部分。正如你从它的输出中看到的那样，`udevadm` 从我们提供的指定路径开始，并且提供了所有父级设备的信息。注意设备的属性都是以单数的形式报告的（比如，`KERNEL`），而它的父级是以复数形式出现的（比如，`KERNELS`）。父级信息可以做为规则的一部分，但是同一时间只能有一个父级可以被引用：不同父级设备的属性混合在一起是不能工作的。在上面我们定义的规则中，我们使用了一个父级设备属性：`idProduct` 和 `idVendor`。
在我们的规则中接下来做的事情是，去使用 `ENV` 关键字：它既可以用于设置也可以用于去匹配环境变量。我们给 `DISPLAY` 和 `XAUTHORITY` 分配值。当我们使用 X 服务器程序进行交互去设置一些需要的信息时，这些变量是非常必要的：使用 `DISPLAY` 变量，我们指定服务器运行在哪个机器上，用的是哪个显示和屏幕；使用 `XAUTHORITY` 提供了一个文件路径，其包含了 Xorg 认证和授权信息。这个文件一般位于用户的家目录中。
最后，我们使用了 `RUN` 字：它用于运行外部程序。非常重要：这里没有立即运行，但是一旦所有的规则被解析，将运行各种动作。在这个案例中，我们使用 `xinput` 实用程序去改变触摸板的状态。我不想解释这里的 `xinput` 的语法，它超出了本文的范围，只需要注意这个触摸板的 ID 是 `16`。
规则设置完成之后，我们可以通过使用 `udevadm test` 命令去调试它。这个命令对调试非常有用，它并不真实去运行 `RUN` 指定的命令：
```
$ udevadm test --action="add" /devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.2/2-1.2:1.1/0003:046D:C52F.0010/input/input39
```
我们提供给命令的是使用 `--action` 选项，以及设备的 sysfs 路径的模拟动作。如果没有报告错误，说明我们的规则运行的很好。要在真实的环境中去使用它，我们需要重新加载规则：
```
# udevadm control --reload
```
这个命令将重新加载规则文件，但是，它只对重新加载之后发生的事件有效果。
我们通过创建一个 udev 规则了解了基本的概念和逻辑，这只是 udev 规则中众多的选项和可能的设置中的一小部分。udev 手册页提供了一个详尽的列表，如果你想深入了解，请参考它。
---
via: <https://linuxconfig.org/tutorial-on-how-to-write-basic-udev-rules-in-linux>
作者：[Egidio Docile](https://disqus.com/by/egidiodocile/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用一些超酷的功能使 Vim 变得更强大
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/making-vim-even-more-awesome-with-these-cool-features
|
我认为，Vim 应该从一开始就以我们想要的方式运作，而其它编辑器让我们按照已经设计好的方式工作，实际上不是我们想要的工作方式。
|
/data/attachment/album/201802/21/092153sxdxup1o8xoxqlks.jpg.thumb.jpg
|
/data/attachment/album/201802/21/092153sxdxup1o8xoxqlks.jpg
| true | false | true |
stevenzdg988
| false |
[
"Vim"
] |
技术
|
{
"viewnum": 5541,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我认为，Vim 应该从一开始就以我们想要的方式运作，而其它编辑器让我们按照已经设计好的方式工作，实际上不是我们想要的工作方式。
| 2018-02-21T09:21:00 | 2018-02-21T09:21:00 | 9,366 |
/article-9366-1.html
|
Vim 是每个 Linux 发行版]中不可或缺的一部分，也是 Linux 用户最常用的工具（当然是基于终端的）。至少，这个说法对我来说是成立的。人们可能会在利用什么工具进行程序设计更好方面产生争议，的确 Vim 可能不是一个好的选择，因为有很多不同的 IDE 或其它类似于 Sublime Text 3，Atom 等使程序设计变得更加容易的成熟的文本编辑器。
### 我的感想
但我认为，Vim 应该从一开始就以我们想要的方式运作，而其它编辑器让我们按照已经设计好的方式工作，实际上不是我们想要的工作方式。我不会过多地谈论其它编辑器，因为我没有过多地使用过它们（我对 Vim 情有独钟）。
不管怎样，让我们用 Vim 来做一些事情吧，它完全可以胜任。
### 利用 Vim 进行程序设计
#### 执行代码
考虑一个场景，当我们使用 Vim 设计 C++ 代码并需要编译和运行它时，该怎么做呢。
(a). 我们通过 `Ctrl + Z` 返回到终端，或者利用 `:wq` 保存并退出。
(b). 但是任务还没有结束，接下来需要在终端上输入类似于 `g++ fileName.cxx` 的命令进行编译。
(c). 接下来需要键入 `./a.out` 执行它。
为了让我们的 C++ 代码在 shell 中运行，需要做很多事情。但这似乎并不是利用 Vim 操作的方法（ Vim 总是倾向于把几乎所有操作方法利用一两个按键实现）。那么，做这些事情的 Vim 的方式究竟是什么?
#### Vim 方式
Vim 不仅仅是一个文本编辑器，它是一种编辑文本的编程语言。这种帮助我们扩展 Vim 功能的编程语言是 “VimScript”（LCTT 译注： Vim 脚本）。
因此，在 VimScript 的帮助下，我们可以只需一个按键轻松地将编译和运行代码的任务自动化。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/vim_orig.png)
以上是在我的 `.vimrc` 配置文件里创建的一个名为 `CPP()` 函数的片段。
#### 利用 VimScript 创建函数
在 VimScript 中创建函数的语法非常简单。它以关键字 `func` 开头，然后是函数名（在 VimScript 中函数名必须以大写字母开头，否则 Vim 将提示错误）。在函数的结尾用关键词 `endfunc`。
在函数的主体中，可以看到 `exec` 语句，无论您在 `exec` 关键字之后写什么，都会在 Vim 的命令模式上执行（记住，就是在 Vim 窗口的底部以 `:` 开始的命令）。现在，传递给 `exec` 的字符串是（LCTT 译注：`:!clear && g++ % && ./a.out`） -
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/vim_1_orig.png)
当这个函数被调用时，它首先清除终端屏幕，因此只能看到输出，接着执行 `g++` 处理你工作的文件，然后运行由前一步编译而形成的 `a.out` 文件。
#### 将 ctrl+r 映射为运行 C++ 代码
我将语句 `call CPP()` 映射到键组合 `Ctrl+r`，以便我现在可以按 `Ctrl+r` 来执行我的 C++ 代码，无需手动输入 `:call CPP()`，然后按 `Enter` 键。
#### 最终结果
我们终于找到了 Vim 方式的操作方法。现在，你只需按一个（组合）键，你编写的 C++ 代码就输出在你的屏幕上，你不需要键入所有冗长的命令了。这也节省了你的时间。
我们也可以为其他语言实现这类功能。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/vim_2_orig.png)
对于Python：您可以按下 `Ctrl+e` 解释执行您的代码。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/vim_3_orig.png)
对于Java：您现在可以按下 `Ctrl+j`，它将首先编译您的 Java 代码，然后执行您的 Java 类文件并显示输出。
### 进一步提高
所以，这就是如何在 Vim 中操作的方法。现在，我们来看看如何在 Vim 中实现所有这些。我们可以直接在 Vim 中使用这些代码片段，而另一种方法是使用 Vim 中的自动命令 `autocmd`。`autocmd` 的优点是这些命令无需用户调用，它们在用户所提供的任何特定条件下自动执行。
我想用 autocmd 实现这个，而不是对每种语言使用不同的映射，执行不同程序设计语言编译出的代码。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/vim_4_orig.png)
在这里做的是，为所有的定义了执行相应文件类型代码的函数编写了自动命令。
会发生什么？当我打开任何上述提到的文件类型的缓冲区， Vim 会自动将 `Ctrl + r` 映射到函数调用，而 `<CR>` 表示回车键，这样就不需要每完成一个独立的任务就按一次回车键了。
为了实现这个功能，您只需将函数片段添加到 `.vimrc` 文件中，然后将所有这些 `autocmd` 也一并添加进去。这样，当您下一次打开 Vim 时，Vim 将拥有所有相应的功能来执行所有具有相同绑定键的代码。
### 总结
就这些了。希望这些能让你更爱 Vim 。我目前正在探究 Vim 中的一些内容，正阅读文档，补充 `.vimrc` 文件，当我研究出一些成果后我会再次与你分享。
如果你想看一下我现在的 `.vimrc` 文件，这是我的 Github 账户的链接: [MyVimrc](https://github.com/phenomenal-ab/VIm-Configurations/blob/master/.vimrc)。
期待你的好评。
---
via: <http://www.linuxandubuntu.com/home/making-vim-even-more-awesome-with-these-cool-features>
作者：[LINUXANDUBUNTU](http://www.linuxandubuntu.com) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
会话与 Cookie：用户登录的原理是什么?
|
Rishabh Kandari
|
http://www.theitstuff.com/sessions-cookies-user-login-work
|
登录的原理是什么？网站是如何认证的？它怎么知道是哪个用户从哪儿登录进来的？下面我们来对这些问题进行一一解答。
|
/data/attachment/album/201802/21/115419r2ix9xosmaqminbx.jpg.thumb.jpg
|
/data/attachment/album/201802/21/115419r2ix9xosmaqminbx.jpg
| true | false | true |
lujun9972
| false |
[
"会话",
"登录",
"cookie"
] |
软件开发
|
{
"viewnum": 6572,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
登录的原理是什么？网站是如何认证的？它怎么知道是哪个用户从哪儿登录进来的？下面我们来对这些问题进行一一解答。
| 2018-02-21T11:54:00 | 2018-02-21T11:54:00 | 9,367 |
/article-9367-1.html
|
Facebook、 Gmail、 Twitter 是我们每天都会用的网站（LCTT 译注：才不是呢）。它们的共同点在于都需要你登录进去后才能做进一步的操作。只有你通过认证并登录后才能在 twitter 发推，在 Facebook 上评论，以及在 Gmail上处理电子邮件。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/Untitled-design-1.jpg)
那么登录的原理是什么？网站是如何认证的？它怎么知道是哪个用户从哪儿登录进来的？下面我们来对这些问题进行一一解答。
### 用户登录的原理是什么?
每次你在网站的登录页面中输入用户名和密码时，这些信息都会发送到服务器。服务器随后会将你的密码与服务器中的密码进行验证。如果两者不匹配，则你会得到一个错误密码的提示。如果两者匹配，则成功登录。
### 登录时发生了什么?
登录后，web 服务器会初始化一个<ruby> 会话 <rt> session </rt></ruby>并在你的浏览器中设置一个 cookie 变量。该 cookie 变量用于作为新建会话的一个引用。搞晕了？让我们说的再简单一点。
### 会话的原理是什么?
服务器在用户名和密码都正确的情况下会初始化一个会话。会话的定义很复杂，你可以把它理解为“关系的开始”。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/pasted-image-0-9.png)
认证通过后，服务器就开始跟你展开一段关系了。由于服务器不能象我们人类一样看东西，它会在我们的浏览器中设置一个 cookie 来将我们的关系从其他人与服务器的关系标识出来。
### 什么是 Cookie?
cookie 是网站在你的浏览器中存储的一小段数据。你应该已经见过他们了。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/pasted-image-0-1-4.png)
当你登录后，服务器为你创建一段关系或者说一个会话，然后将唯一标识这个会话的会话 id 以 cookie 的形式存储在你的浏览器中。
### 什么意思?
所有这些东西存在的原因在于识别出你来，这样当你写评论或者发推时，服务器能知道是谁在发评论，是谁在发推。
当你登录后，会产生一个包含会话 id 的 cookie。这样，这个会话 id 就被赋予了那个输入正确用户名和密码的人了。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/pasted-image-0-2-3-e1508926255472.png)
也就是说，会话 id 被赋予给了拥有这个账户的人了。之后，所有在网站上产生的行为，服务器都能通过他们的会话 id 来判断是由谁发起的。
### 如何让我保持登录状态?
会话有一定的时间限制。这一点与现实生活中不一样，现实生活中的关系可以在不见面的情况下持续很长一段时间，而会话具有时间限制。你必须要不断地通过一些动作来告诉服务器你还在线。否则的话，服务器会关掉这个会话，而你会被登出。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/pasted-image-0-3-3-e1508926314117.png)
不过在某些网站上可以启用“保持登录”功能，这样服务器会将另一个唯一变量以 cookie 的形式保存到我们的浏览器中。这个唯一变量会通过与服务器上的变量进行对比来实现自动登录。若有人盗取了这个唯一标识（我们称之为 cookie stealing），他们就能访问你的账户了。
### 结论
我们讨论了登录系统的工作原理以及网站是如何进行认证的。我们还学到了什么是会话和 cookies，以及它们在登录机制中的作用。
我们希望你们以及理解了用户登录的工作原理，如有疑问，欢迎提问。
---
via: <http://www.theitstuff.com/sessions-cookies-user-login-work>
作者：[Rishabh Kandari](http://www.theitstuff.com/author/reevkandari) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何 Docker 化编译的软件
|
Tianon Gravi
|
https://tianon.github.io/post/2017/12/26/dockerize-compiled-software.html
|
我写了一个中等篇幅的评论解释了我如何用常规的方式为我想要的软件进行 Docker 化的。
|
/data/attachment/album/201802/21/121232xxx3wsf642xwv62m.jpg.thumb.jpg
|
/data/attachment/album/201802/21/121232xxx3wsf642xwv62m.jpg
| true | false | true |
geekpi
| false |
[
"编译",
"Docker"
] |
容器与云
|
{
"viewnum": 4354,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我写了一个中等篇幅的评论解释了我如何用常规的方式为我想要的软件进行 Docker 化的。
| 2018-02-21T12:12:36 | 2018-02-21T12:12:36 | 9,368 |
/article-9368-1.html
|
我最近在 [docker-library/php](https://github.com/docker-library/php) 仓库中关闭了大量问题，最老的（并且是最长的）讨论之一是关于安装编译扩展的依赖关系，我写了一个[中等篇幅的评论](https://github.com/docker-library/php/issues/75#issuecomment-353673374)解释了我如何用常规的方式为我想要的软件进行 Docker 化的。
我要在这里复制大部分的评论内容，或许扩展一点点，以便有一个更好的/更干净的链接！
我第一步是编写 `Dockerfile` 的原始版本：下载源码，运行 `./configure && make` 等，清理。然后我尝试构建我的原始版本，并希望在这过程中看到错误消息。（对，真的！）
错误信息通常以 `error: could not find "xyz.h"` 或 `error: libxyz development headers not found` 的形式出现。
如果我在 Debian 中构建，我会输入 `https://packages.debian.org/file:xyz.h`（用错误信息中头文件的名称替换 “xyz.h”），或者在谷歌中搜索像 “xyz.h debian” 这样的东西，找出我需要的包的名称。
如果我在 Alpine 中构建，我将使用 <https://pkgs.alpinelinux.org/contents> 进行类似的搜索。
“libxyz development headers” 在某种程度上也是一样的，但是根据我的经验，对于这些用 Google 对开发者来说效果更好，因为不同的发行版和项目会以不同的名字来调用这些开发包，所以有时候更难确切的知道哪一个是“正确”的。
当我得到包名后，我将这个包名称添加到我的 `Dockerfile` 中，清理之后，然后重复操作。最终通常会构建成功。偶尔我发现某些库不在 Debian 或 Alpine 中，或者是不够新的，由此我必须从源码构建它，但这些情况在我的经验中很少见 —— 因人而异。
我还会经常查看 Debian（通过 <https://sources.debian.org>）或 Alpine（通过 <https://git.alpinelinux.org/cgit/aports/tree>）我要编译的软件包源码，特别关注 `Build-Depends`（如 [`php7.0=7.0.26-1` 的 `debian/control` 文件](https://sources.debian.org/src/php7.0/7.0.26-1/debian/control/)）以及/或者 `makedepends` （如 [`php7` 的 `APKBUILD` 文件](https://git.alpinelinux.org/cgit/aports/tree/community/php7/APKBUILD?id=d0ca197f031f96d4664cafaa618aeccf94640a1e)）用于包名线索。
就我个人而言，我觉得这种侦探工作很有趣，也很有收获，但我意识到我可能是一个独特的生物。我偶尔使用的另一个技术是看是否有人已经 Docker 化了我想要的东西，这样我可以直接从他们的 `Dockerfile` 中知道我需要安装的东西。
对于特定的 PHP 扩展，几乎总是有人已经想出对于这个或那个模块需要的依赖，而我所要做的就是做一些轻量的工作找出它们。
不管怎样，这就是我的方法！希望这个有帮助，玩得愉快！
---
via: <https://tianon.github.io/post/2017/12/26/dockerize-compiled-software.html>
作者：[Tianon Gravi](https://tianon.github.io) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Telnet，爱一直在
|
Elliot Cooper
|
https://bash-prompt.net/guides/telnet/
|
登录远程服务器，你可能不会也从未考虑过它。但这并不意味着 telnet 命令在调试远程连接问题时不是一个实用的工具。
|
/data/attachment/album/201802/22/105938exdcxkgw6hccg772.jpg.thumb.jpg
|
/data/attachment/album/201802/22/105938exdcxkgw6hccg772.jpg
| true | false | true |
XYenChi
| false |
[
"telnet"
] |
系统运维
|
{
"viewnum": 20824,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "58.247.66.187",
"message": "厉害了",
"username": "来自上海的 Chrome 74.0|Windows 10 用户",
"date": "2019-05-15T16:30:24"
}
] |
[] |
登录远程服务器，你可能不会也从未考虑过它。但这并不意味着 telnet 命令在调试远程连接问题时不是一个实用的工具。
| 2018-02-22T10:59:32 | 2018-02-22T10:59:32 | 9,369 |
/article-9369-1.html
|
Telnet，是系统管理员登录远程服务器的一种协议和工具。然而，由于所有的通信都没有加密，包括密码，都是明文发送的。Telnet 在 SSH 被开发出来之后就基本弃用了。
登录远程服务器，你可能不会也从未考虑过它。但这并不意味着 `telnet` 命令在调试远程连接问题时不是一个实用的工具。
本教程中，我们将探索使用 `telnet` 解决所有常见问题：“我怎么又连不上啦？”
这种讨厌的问题通常会在安装了像 Web服务器、邮件服务器、ssh 服务器、Samba 服务器等诸如此类的事之后遇到，用户无法连接服务器。
`telnet` 不会解决问题但可以很快缩小问题的范围。
`telnet` 用来调试网络问题的简单命令和语法：
```
telnet <hostname or IP> <port>
```
因为 `telnet` 最初通过端口建立连接不会发送任何数据，适用于任何协议，包括加密协议。
连接问题服务器有四个可能会遇到的主要问题。我们会研究这四个问题，研究它们意味着什么以及如何解决。
本教程默认已经在 `samba.example.com` 安装了 [Samba](https://www.samba.org/) 服务器而且本地客户无法连上服务器。
### Error 1 - 连接挂起
首先，我们需要试着用 `telnet` 连接 Samba 服务器。使用下列命令 (Samba 监听端口445)：
```
telnet samba.example.com 445
```
有时连接会莫名停止：
```
telnet samba.example.com 445
Trying 172.31.25.31...
```
这意味着 `telnet` 没有收到任何回应来建立连接。有两个可能的原因：
1. 你和服务器之间有个路由器宕掉了。
2. 防火墙拦截了你的请求。
为了排除第 1 点，对服务器上进行一个快速 [`mtr samba.example.com`](https://www.systutorials.com/docs/linux/man/8-mtr/) 。如果服务器是可达的，那么便是防火墙（注意：防火墙总是存在的）。
首先用 `iptables -L -v -n` 命令检查服务器本身有没有防火墙，没有的话你能看到以下内容：
```
iptables -L -v -n
Chain INPUT (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
```
如果你看到其他东西那可能就是问题所在了。为了检验，停止 `iptables` 一下并再次运行 `telnet samba.example.com 445` 看看你是否能连接。如果你还是不能连接看看你的提供商或企业有没有防火墙拦截你。
### Error 2 - DNS 问题
DNS 问题通常发生在你正使用的主机名没有解析到 IP 地址。错误如下：
```
telnet samba.example.com 445
Server lookup failure: samba.example.com:445, Name or service not known
```
第一步是把主机名替换成服务器的 IP 地址。如果你可以连上那么就是主机名的问题。
有很多发生的原因（以下是我见过的）：
1. 域名注册了吗？用 `whois` 来检验。
2. 域名过期了吗？用 `whois` 来检验。
3. 是否使用正确的主机名？用 `dig` 或 `host` 来确保你使用的主机名解析到正确的 IP。
4. 你的 **A** 记录正确吗？确保你没有偶然创建类似 `smaba.example.com` 的 **A** 记录。
一定要多检查几次拼写和主机名是否正确（是 `samba.example.com` 还是 `samba1.example.com`）？这些经常会困扰你，特别是比较长、难记或其它国家的主机名。
### Error 3 - 服务器没有侦听端口
这种错误发生在 `telnet` 可达服务器但是指定端口没有监听。就像这样：
```
telnet samba.example.com 445
Trying 172.31.25.31...
telnet: Unable to connect to remote host: Connection refused
```
有这些原因：
1. 你 **确定** 连接的是正确的服务器？
2. 你的应用服务器没有侦听预期的端口。在服务器上运行 `netstat -plunt` 来查看它究竟在干什么并看哪个端口才是对的，实际正在监听中的。
3. 应用服务器没有运行。这可能突然而又悄悄地发生在你启动应用服务器之后。启动服务器运行 `ps auxf` 或 `systemctl status application.service` 查看运行。
### Error 4 - 连接被服务器关闭
这种错误发生在连接成功建立但是应用服务器建立的安全措施一连上就将其结束。错误如下：
```
telnet samba.example.com 445
Trying 172.31.25.31...
Connected to samba.example.com.
Escape character is '^]'.
Connection closed by foreign host.
```
最后一行 `Connection closed by foreign host.` 意味着连接被服务器主动终止。为了修复这个问题，需要看看应用服务器的安全设置确保你的 IP 或用户允许连接。
### 成功连接
成功的 `telnet` 连接如下：
```
telnet samba.example.com 445
Trying 172.31.25.31...
Connected to samba.example.com.
Escape character is '^]'.
```
连接会保持一段时间只要你连接的应用服务器时限没到。
输入 `CTRL+]` 中止连接，然后当你看到 `telnet>` 提示，输入 `quit` 并按回车：
```
telnet samba.example.com 445
Trying 172.31.25.31...
Connected to samba.example.com.
Escape character is '^]'.
^]
telnet> quit
Connection closed.
```
### 总结
客户程序连不上服务器的原因有很多。确切原因很难确定，特别是当客户是图形用户界面提供很少或没有错误信息。用 `telnet` 并观察输出可以让你很快确定问题所在节约很多时间。
---
via: <https://bash-prompt.net/guides/telnet/>
作者：[Elliot Cooper](https://bash-prompt.net) 译者：[XYenChi](https://github.com/XYenChi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
containerd 1.0 探索之旅
|
Michael Crosby
|
https://blog.docker.com/2017/12/containerd-ga-features-2/
|
containerd 被用于 Docker、Kubernetes CRI、以及一些其它的项目，在这些平台中事实上都使用了 containerd，而许多人并不知道 containerd 存在于这些平台之中，这篇文章就是为这些人所写的。
|
/data/attachment/album/201802/22/124722gibtz0ag72azo442.jpg.thumb.jpg
|
/data/attachment/album/201802/22/124722gibtz0ag72azo442.jpg
| true | false | true |
qhwdw
| false |
[] |
容器与云
|
{
"viewnum": 5133,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
containerd 被用于 Docker、Kubernetes CRI、以及一些其它的项目，在这些平台中事实上都使用了 containerd，而许多人并不知道 containerd 存在于这些平台之中，这篇文章就是为这些人所写的。
| 2018-02-22T12:47:00 | 2018-02-22T12:47:00 | 9,370 |
/article-9370-1.html
|
我们在过去的文章中讨论了一些 containerd 的不同特性，它是如何设计的，以及随着时间推移已经修复的一些问题。containerd 被用于 Docker、Kubernetes CRI、以及一些其它的项目，在这些平台中事实上都使用了 containerd，而许多人并不知道 containerd 存在于这些平台之中，这篇文章就是为这些人所写的。我将来会写更多的关于 containerd 的设计以及特性集方面的文章，但是现在，让我们从它的基础知识开始。
我认为容器生态系统有时候可能很复杂。尤其是我们所使用的术语。它是什么？一个运行时，还是别的？一个运行时 … containerd（它的发音是 “container-dee”）正如它的名字，它是一个容器守护进程，而不是一些人忽悠我的“<ruby> 收集 <rt> contain </rt></ruby><ruby> 迷 <rt> nerd </rt></ruby>”。它最初是作为 OCI 运行时（就像 runc 一样）的集成点而构建的，在过去的六个月中它增加了许多特性，使其达到了像 Docker 这样的现代容器平台以及像 Kubernetes 这样的编排平台的需求。
那么，你使用 containerd 能去做些什么呢？你可以拥有推送或拉取功能以及镜像管理。可以拥有容器生命周期 API 去创建、运行、以及管理容器和它们的任务。一个完整的专门用于快照管理的 API，以及一个其所依赖的开放治理的项目。如果你需要去构建一个容器平台，基本上你不需要去处理任何底层操作系统细节方面的事情。我认为关于 containerd 中最重要的部分是，它有一个版本化的并且有 bug 修复和安全补丁的稳定 API。
由于在内核中没有一个 Linux 容器这样的东西，因此容器是多种内核特性捆绑在一起而成的，当你构建一个大型平台或者分布式系统时，你需要在你的管理代码和系统调用之间构建一个抽象层，然后将这些特性捆绑粘接在一起去运行一个容器。而这个抽象层就是 containerd 的所在之处。它为稳定类型的平台层提供了一个客户端，这样平台可以构建在顶部而无需进入到内核级。因此，可以让使用容器、任务、和快照类型的工作相比通过管理调用去 clone() 或者 mount() 要友好的多。与灵活性相平衡，直接与运行时或者宿主机交互，这些对象避免了常规的高级抽象所带来的性能牺牲。结果是简单的任务很容易完成，而困难的任务也变得更有可能完成。
containerd 被设计用于 Docker 和 Kubernetes、以及想去抽象出系统调用或者在 Linux、Windows、Solaris 以及其它的操作系统上特定的功能去运行容器的其它容器系统。考虑到这些用户的想法，我们希望确保 containerd 只拥有它们所需要的东西，而没有它们不希望的东西。事实上这是不太可能的，但是至少我们想去尝试一下。虽然网络不在 containerd 的范围之内，它并不能做成让高级系统可以完全控制的东西。原因是，当你构建一个分布式系统时，网络是非常中心的地方。现在，对于 SDN 和服务发现，相比于在 Linux 上抽象出 netlink 调用，网络是更特殊的平台。大多数新的网络都是基于路由的，并且每次一个新的容器被创建或者删除时，都会请求更新路由表。服务发现、DNS 等等都需要及时被通知到这些改变。如果在 containerd 中添加对网络的管理，为了能够支持不同的网络接口、钩子、以及集成点，将会在 containerd 中增加很大的一块代码。而我们的选择是，在 containerd 中做一个健壮的事件系统，以便于多个消费者可以去订阅它们所关心的事件。我们也公开发布了一个 [任务 API](https://github.com/containerd/containerd/blob/master/api/services/tasks/v1/tasks.proto)，它可以让用户去创建一个运行任务，也可以在一个容器的网络命名空间中添加一个接口，以及在一个容器的生命周期中的任何时候，无需复杂的钩子来启用容器的进程。
在过去的几个月中另一个添加到 containerd 中的领域是完整的存储，以及支持 OCI 和 Docker 镜像格式的分布式系统。有了一个跨 containerd API 的完整的目录地址存储系统，它不仅适用于镜像，也适用于元数据、检查点、以及附加到容器的任何数据。
我们也花时间去 [重新考虑如何使用 “图驱动” 工作](https://blog.mobyproject.org/where-are-containerds-graph-drivers-145fc9b7255)。这些是叠加的或者允许镜像分层的块级文件系统，可以使你执行的构建更加高效。当我们添加对 devicemapper 的支持时，<ruby> 图驱动 <rt> graphdrivers </rt></ruby>最初是由 Solomon 和我写的。Docker 在那个时候仅支持 AUFS，因此我们在叠加文件系统之后，对图驱动进行了建模。但是，做一个像 devicemapper/lvm 这样的块级文件系统，就如同一个堆叠文件系统一样，从长远来看是非常困难的。这些接口必须基于时间的推移进行扩展，以支持我们最初认为并不需要的那些不同的特性。对于 containerd，我们使用了一个不同的方法，像快照一样做一个堆叠文件系统而不是相反。这样做起来更容易，因为堆叠文件系统比起像 BTRFS、ZFS 以及 devicemapper 这样的快照文件系统提供了更好的灵活性。因为这些文件系统没有严格的父/子关系。这有助于我们去构建出 [快照的一个小型接口](https://github.com/containerd/containerd/blob/master/api/services/snapshots/v1/snapshots.proto)，同时还能满足 [构建者](https://blog.mobyproject.org/introducing-buildkit-17e056cc5317) 的要求，还能减少了需要的代码数量，从长远来看这样更易于维护。
你可以在 [Stephen Day 2017/12/7 在 KubeCon SIG Node 上的演讲](https://speakerdeck.com/stevvooe/whats-happening-with-containerd-and-the-cri)找到更多关于 containerd 的架构方面的详细资料。
除了在 1.0 代码库中的技术和设计上的更改之外，我们也将 [containerd 管理模式从长期 BDFL 模式转换为技术委员会](https://github.com/containerd/containerd/pull/1748)，为社区提供一个独立的可信任的第三方资源。
---
via: <https://blog.docker.com/2017/12/containerd-ga-features-2/>
作者：[Michael Crosby](https://blog.docker.com/author/michael/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 Ansible 创建 AWS ec2 密钥
|
Vivek Gite
|
https://www.cyberciti.biz/faq/how-to-create-aws-ec2-key-using-ansible/
|
你需要使用 Ansible 的 ec2_key 模块。
|
/data/attachment/album/201802/22/134813ljp54nphdoucnldd.jpg.thumb.jpg
|
/data/attachment/album/201802/22/134813ljp54nphdoucnldd.jpg
| true | false | true |
qianghaohao
| false |
[
"Ansible"
] |
系统运维
|
{
"viewnum": 5160,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你需要使用 Ansible 的 ec2_key 模块。
| 2018-02-22T13:48:09 | 2018-02-22T13:48:09 | 9,371 |
/article-9371-1.html
|
**我想使用 Ansible 工具创建 Amazon EC2 密钥对。不想使用 AWS CLI 来创建。可以使用 Ansible 来创建 AWS ec2 密钥吗？**
你需要使用 Ansible 的 ec2\_key 模块。这个模块依赖于 python-boto 2.5 版本或者更高版本。 boto 是亚马逊 Web 服务的一个 Python API。你可以将 boto 用于 Amazon S3、Amazon EC2 等其他服务。简而言之，你需要安装 Ansible 和 boto 模块。我们一起来看下如何安装 boto 并结合 Ansible 使用。
### 第一步 - 在 Ubuntu 上安装最新版本的 Ansible
你必须[给你的系统配置 PPA 来安装最新版的 Ansible](https://www.cyberciti.biz/faq/ubuntu-sudo-add-apt-repository-command-not-found-error/)。为了管理你从各种 PPA（Personal Package Archives）安装软件的仓库，你可以上传 Ubuntu 源码包并编译，然后通过 Launchpad 以 apt 仓库的形式发布。键入如下命令 [apt-get 命令](https://www.cyberciti.biz/tips/linux-debian-package-management-cheat-sheet.html "See Linux/Unix apt-get command examples for more info")或者 [apt 命令](https://www.cyberciti.biz/faq/ubuntu-lts-debian-linux-apt-command-examples/ "See Linux/Unix apt command examples for more info")：
```
$ sudo apt update
$ sudo apt upgrade
$ sudo apt install software-properties-common
```
接下来给你的系统的软件源中添加 `ppa:ansible/ansible`。
```
$ sudo apt-add-repository ppa:ansible/ansible
```
更新你的仓库并安装 Ansible：
```
$ sudo apt update
$ sudo apt install ansible
```
安装 boto：
```
$ pip3 install boto3
```
#### 关于在CentOS/RHEL 7.x上安装 Ansible 的注意事项
你[需要在 CentOS 和 RHEL 7.x 上配置 EPEL 源](https://www.cyberciti.biz/faq/installing-rhel-epel-repo-on-centos-redhat-7-x/)和 [yum命令](https://www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/ "See Linux/Unix yum command examples for more info")
```
$ cd /tmp
$ wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
$ ls *.rpm
$ sudo yum install epel-release-latest-7.noarch.rpm
$ sudo yum install ansible
```
安装 boto：
```
$ pip install boto3
```
### 第二步 2 – 配置 boto
你需要配置 AWS credentials/API 密钥。参考 “[AWS Security Credentials](https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html)” 文档如何创建 API key。用 `mkdir` 命令创建一个名为 `~/.aws` 的目录，然后配置 API key：
```
$ mkdir -pv ~/.aws/
$ vi ~/.aws/credentials
```
```
[default]
aws_access_key_id = YOUR-ACCESS-KEY-HERE
aws_secret_access_key = YOUR-SECRET-ACCESS-KEY-HERE
```
还需要配置默认 [AWS 区域](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html)：
```
$ vi ~/.aws/config
```
输出样例如下：
```
[default]
region = us-west-1
```
通过创建一个简单的名为 `test-boto.py` 的 Python 程序来测试你的 boto 配置是否正确：
```
#!/usr/bin/python3
# A simple program to test boto and print s3 bucket names
import boto3
t = boto3.resource('s3')
for b in t.buckets.all():
print(b.name)
```
按下面方式来运行该程序：
```
$ python3 test-boto.py
```
输出样例：
```
nixcraft-images
nixcraft-backups-cbz
nixcraft-backups-forum
```
上面输出可以确定 Python-boto 可以使用 AWS API 正常工作。
### 步骤 3 - 使用 Ansible 创建 AWS ec2 密钥
创建一个名为 `ec2.key.yml` 的剧本，如下所示：
```
---
- hosts: local
connection: local
gather_facts: no
tasks:
- name: Create a new EC2 key
ec2_key:
name: nixcraft-key
region: us-west-1
register: ec2_key_result
- name: Save private key
copy: content="{{ ec2_key_result.key.private_key }}" dest="./aws.nixcraft.pem" mode=0600
when: ec2_key_result.changed
```
其中，
* `ec2_key:` – ec2 密钥对。
* `name: nixcraft_key` – 密钥对的名称。
* `region: us-west-1` – 使用的 AWS 区域。
* `register: ec2_key_result` – 保存生成的密钥到 ec2*key*result 变量。
* `copy: content="{{ ec2_key_result.key.private_key }}" dest="./aws.nixcraft.pem" mode=0600` – 将 `ec2_key_result.key.private_key` 的内容保存到当前目录的一个名为 `aws.nixcraft.pem` 的文件中。设置该文件的权限为 `0600` （unix 文件权限）。
* `when: ec2_key_result.changed` – 仅仅在 `ec2_key_result` 改变时才保存。我们不想覆盖你的密钥文件。
你还必须创建如下 `hosts` 文件：
```
[local]
localhost
```
如下运行你的剧本：
```
$ ansible-playbook -i hosts ec2.key.yml
```
最后你应该有一个名为 `aws.nixcraft.pem 私钥，该私钥可以和 AWS EC2 一起使用。使用 [cat 命令](https://www.cyberciti.biz/faq/linux-unix-appleosx-bsd-cat-command-examples/ "See Linux/Unix cat command examples for more info")查看你的密钥：
```
$ cat aws.nixcraft.pem
```
如果你有 EC2 虚拟机，请按如下方式使用：
```
$ ssh -i aws.nixcraft.pem user@ec2-vm-dns-name
```
**查看有关 python 数据结构变量名的信息，比如 ec2*key*result.changed 和 ec2*key*result.key.private\_key**
你一定在想我是如何使用变量名的，比如 `ec2_key_result.changed` 和 `ec2_key_result.key.private_key`。它们在哪里定义过吗？变量的值是通过 API 调用返回的。简单地使用 `-v` 选项运行 `ansible-playbook` 命令来查看这样的信息：
```
$ ansible-playbook -v -i hosts ec2.key.yml
```
### 我该如何删除一个密钥？
使用如下 `ec2-key-delete.yml`：
```
---
- hosts: local
connection: local
gather_facts: no
tasks:
- name: Delete a EC2 key
ec2_key:
name: nixcraft-key
region: us-west-1
# absent means delete keypair
state: absent
```
按照如下方式运行：
```
$ ansible-playbook -i hosts ec2-key-delete.yml
```
### 关于作者
作者是 nixCraft 的创始人，是一个经验丰富的系统管理员，DevOps 工程师，同时是一个 Linux 操作系统/Unix shell 脚本培训师。**通过 [RSS/XML 提要](https://www.cyberciti.biz/atom/atom.xml)或[每周邮件简讯](https://www.cyberciti.biz/subscribe-to-weekly-linux-unix-newsletter-for-sysadmin/)获得关于系统管理，Linux/Unix和开放源码主题的最新教程。**
---
via: <https://www.cyberciti.biz/faq/how-to-create-aws-ec2-key-using-ansible/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[qianghaohao](https://github.com/qianghaohao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Python 的 urllib.parse 库解析 URL
|
Darksun
|
https://github.com/lujun9972/lujun9972.github.com/blob/source/%E7%BC%96%E7%A8%8B%E4%B9%8B%E6%97%85/%E4%BD%BF%E7%94%A8urlliib.parse%E5%BA%93%E8%A7%A3%E6%9E%90url.org
|
Python 中的 urllib.parse 模块提供了很多解析和组建 URL 的函数。
|
/data/attachment/album/201802/22/235511q1pbibaabi5cx6xf.jpg.thumb.jpg
|
/data/attachment/album/201802/22/235511q1pbibaabi5cx6xf.jpg
| true | false | false | false |
[
"Python",
"URL"
] |
软件开发
|
{
"viewnum": 8299,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Python 中的 urllib.parse 模块提供了很多解析和组建 URL 的函数。
| 2018-02-22T23:51:00 | 2018-02-22T23:51:00 | 9,372 |
/article-9372-1.html
|
Python 中的 `urllib.parse` 模块提供了很多解析和组建 URL 的函数。
### 解析url
`urlparse()` 函数可以将 URL 解析成 `ParseResult` 对象。对象中包含了六个元素，分别为：
* 协议（scheme）
* 域名（netloc）
* 路径（path）
* 路径参数（params）
* 查询参数（query）
* 片段（fragment）
```
from urllib.parse import urlparse
url='http://user:pwd@domain:80/path;params?query=queryarg#fragment'
parsed_result=urlparse(url)
print('parsed_result 包含了',len(parsed_result),'个元素')
print(parsed_result)
```
结果为:
```
parsed_result 包含了 6 个元素
ParseResult(scheme='http', netloc='user:pwd@domain:80', path='/path', params='params', query='query=queryarg', fragment='fragment')
```
`ParseResult` 继承于 `namedtuple`，因此可以同时通过索引和命名属性来获取 URL 中各部分的值。
为了方便起见， `ParseResult` 还提供了 `username`、 `password`、 `hostname`、 `port` 对 `netloc` 进一步进行拆分。
```
print('scheme :', parsed_result.scheme)
print('netloc :', parsed_result.netloc)
print('path :', parsed_result.path)
print('params :', parsed_result.params)
print('query :', parsed_result.query)
print('fragment:', parsed_result.fragment)
print('username:', parsed_result.username)
print('password:', parsed_result.password)
print('hostname:', parsed_result.hostname)
print('port :', parsed_result.port)
```
结果为：
```
scheme : http
netloc : user:pwd@domain:80
path : /path
params : params
query : query=queryarg
fragment: fragment
username: user
password: pwd
hostname: domain
port : 80
```
除了 `urlparse()` 之外，还有一个类似的 `urlsplit()` 函数也能对 URL 进行拆分，所不同的是， `urlsplit()` 并不会把 `路径参数(params)` 从 `路径(path)` 中分离出来。
当 URL 中路径部分包含多个参数时，使用 `urlparse()` 解析是有问题的：
```
url='http://user:pwd@domain:80/path1;params1/path2;params2?query=queryarg#fragment'
parsed_result=urlparse(url)
print(parsed_result)
print('parsed.path :', parsed_result.path)
print('parsed.params :', parsed_result.params)
```
结果为：
```
ParseResult(scheme='http', netloc='user:pwd@domain:80', path='/path1;params1/path2', params='params2', query='query=queryarg', fragment='fragment')
parsed.path : /path1;params1/path2
parsed.params : params2
```
这时可以使用 `urlsplit()` 来解析：
```
from urllib.parse import urlsplit
split_result=urlsplit(url)
print(split_result)
print('split.path :', split_result.path)
# SplitResult 没有 params 属性
```
结果为：
```
SplitResult(scheme='http', netloc='user:pwd@domain:80', path='/path1;params1/path2;params2', query='query=queryarg', fragment='fragment')
split.path : /path1;params1/path2;params2
```
若只是要将 URL 后的 `fragment` 标识拆分出来，可以使用 `urldefrag()` 函数：
```
from urllib.parse import urldefrag
url = 'http://user:pwd@domain:80/path1;params1/path2;params2?query=queryarg#fragment'
d = urldefrag(url)
print(d)
print('url :', d.url)
print('fragment:', d.fragment)
```
结果为：
```
DefragResult(url='http://user:pwd@domain:80/path1;params1/path2;params2?query=queryarg', fragment='fragment')
url : http://user:pwd@domain:80/path1;params1/path2;params2?query=queryarg
fragment: fragment
```
### 组建URL
`ParsedResult` 对象和 `SplitResult` 对象都有一个 `geturl()` 方法，可以返回一个完整的 URL 字符串。
```
print(parsed_result.geturl())
print(split_result.geturl())
```
结果为：
```
http://user:pwd@domain:80/path1;params1/path2;params2?query=queryarg#fragment
http://user:pwd@domain:80/path1;params1/path2;params2?query=queryarg#fragment
```
但是 `geturl()` 只在 `ParsedResult` 和 `SplitResult` 对象中有，若想将一个普通的元组组成 URL，则需要使用 `urlunparse()` 函数：
```
from urllib.parse import urlunparse
url_compos = ('http', 'user:pwd@domain:80', '/path1;params1/path2', 'params2', 'query=queryarg', 'fragment')
print(urlunparse(url_compos))
```
结果为：
```
http://user:pwd@domain:80/path1;params1/path2;params2?query=queryarg#fragment
```
### 相对路径转换绝对路径
除此之外，`urllib.parse` 还提供了一个 `urljoin()` 函数，来将相对路径转换成绝对路径的 URL。
```
from urllib.parse import urljoin
print(urljoin('http://www.example.com/path/file.html', 'anotherfile.html'))
print(urljoin('http://www.example.com/path/', 'anotherfile.html'))
print(urljoin('http://www.example.com/path/file.html', '../anotherfile.html'))
print(urljoin('http://www.example.com/path/file.html', '/anotherfile.html'))
```
结果为：
```
http://www.example.com/path/anotherfile.html
http://www.example.com/path/anotherfile.html
http://www.example.com/anotherfile.html
http://www.example.com/anotherfile.html
```
### 查询参数的构造和解析
使用 `urlencode()` 函数可以将一个 dict 转换成合法的查询参数：
```
from urllib.parse import urlencode
query_args = {
'name': 'dark sun',
'country': '中国'
}
query_args = urlencode(query_args)
print(query_args)
```
结果为：
```
name=dark+sun&country=%E4%B8%AD%E5%9B%BD
```
可以看到特殊字符也被正确地转义了。
相对的，可以使用 `parse_qs()` 来将查询参数解析成 dict。
```
from urllib.parse import parse_qs
print(parse_qs(query_args))
```
结果为：
```
{'name': ['dark sun'], 'country': ['中国']}
```
如果只是希望对特殊字符进行转义，那么可以使用 `quote` 或 `quote_plus` 函数，其中 `quote_plus` 比 `quote` 更激进一些，会把 `:`、`/` 一类的符号也给转义了。
```
from urllib.parse import quote, quote_plus, urlencode
url = 'http://localhost:1080/~hello!/'
print('urlencode :', urlencode({'url': url}))
print('quote :', quote(url))
print('quote_plus:', quote_plus(url))
```
结果为：
```
urlencode : url=http%3A%2F%2Flocalhost%3A1080%2F%7Ehello%21%2F
quote : http%3A//localhost%3A1080/%7Ehello%21/
quote_plus: http%3A%2F%2Flocalhost%3A1080%2F%7Ehello%21%2F
```
可以看到 `urlencode` 中应该是调用 `quote_plus` 来进行转义的。
逆向操作则使用 `unquote` 或 `unquote_plus` 函数：
```
from urllib.parse import unquote, unquote_plus
encoded_url = 'http%3A%2F%2Flocalhost%3A1080%2F%7Ehello%21%2F'
print(unquote(encoded_url))
print(unquote_plus(encoded_url))
```
结果为：
```
http://localhost:1080/~hello!/
http://localhost:1080/~hello!/
```
你会发现 `unquote` 函数居然能正确地将 `quote_plus` 的结果转换回来。
|
|||
每个系统管理员都要知道的 30 个 Linux 系统监控工具
|
Vivek Gite
|
https://www.cyberciti.biz/tips/top-linux-monitoring-tools.html
|
您需要监控 Linux 服务器的性能吗？试试用这些内置命令和附加工具吧！大多数 Linux 发行版都附带了大量的监控工具。这些工具提供了获取系统活动的相关指标。您可以使用这些工具来查找性能问题的可能原因。
|
/data/attachment/album/201802/23/003604wd2215mdgd5i1g2y.jpg.thumb.jpg
|
/data/attachment/album/201802/23/003604wd2215mdgd5i1g2y.jpg
| true | false | true |
jessie-pang
| false |
[
"监控"
] |
分享
|
{
"viewnum": 20078,
"commentnum": 0,
"favtimes": 9,
"sharetimes": 2,
"likes": 0
}
|
[] |
[] |
您需要监控 Linux 服务器的性能吗？试试用这些内置命令和附加工具吧！大多数 Linux 发行版都附带了大量的监控工具。这些工具提供了获取系统活动的相关指标。您可以使用这些工具来查找性能问题的可能原因。
| 2018-02-23T00:36:00 | 2018-02-23T00:36:00 | 9,373 |
/article-9373-1.html
|
您需要监控 Linux 服务器的性能吗？试试用这些内置命令和附加工具吧！大多数 Linux 发行版都附带了大量的监控工具。这些工具提供了获取系统活动的相关指标。您可以使用这些工具来查找性能问题的可能原因。本文提到的是一些基本的命令，用于系统分析和服务器调试等，例如：
1. 找出系统瓶颈
2. 磁盘（存储）瓶颈
3. CPU 和内存瓶颈
4. 网络瓶颈
### 1. top - 进程活动监控命令
`top` 命令会显示 Linux 的进程。它提供了一个运行中系统的实时动态视图，即实际的进程活动。默认情况下，它显示在服务器上运行的 CPU 占用率最高的任务，并且每五秒更新一次。
*图 01：Linux top 命令*
#### top 的常用快捷键
常用快捷键列表：
| 快捷键 | 用法 |
| --- | --- |
| `t` | 是否显示汇总信息 |
| `m` | 是否显示内存信息 |
| `A` | 根据各种系统资源的利用率对进程进行排序，有助于快速识别系统中性能不佳的任务。 |
| `f` | 进入 `top` 的交互式配置屏幕，用于根据特定的需求而设置 `top` 的显示。 |
| `o` | 交互式地调整 `top` 每一列的顺序。 |
| `r` | 调整优先级（`renice`） |
| `k` | 杀掉进程（`kill`） |
| `z` | 切换彩色或黑白模式 |
相关链接：[Linux 如何查看 CPU 利用率？](https://www.cyberciti.biz/tips/how-do-i-find-out-linux-cpu-utilization.html)
### 2. vmstat - 虚拟内存统计
`vmstat` 命令报告有关进程、内存、分页、块 IO、中断和 CPU 活动等信息。
```
# vmstat 3
```
输出示例：
```
procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu------
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 0 2540988 522188 5130400 0 0 2 32 4 2 4 1 96 0 0
1 0 0 2540988 522188 5130400 0 0 0 720 1199 665 1 0 99 0 0
0 0 0 2540956 522188 5130400 0 0 0 0 1151 1569 4 1 95 0 0
0 0 0 2540956 522188 5130500 0 0 0 6 1117 439 1 0 99 0 0
0 0 0 2540940 522188 5130512 0 0 0 536 1189 932 1 0 98 0 0
0 0 0 2538444 522188 5130588 0 0 0 0 1187 1417 4 1 96 0 0
0 0 0 2490060 522188 5130640 0 0 0 18 1253 1123 5 1 94 0 0
```
#### 显示 Slab 缓存的利用率
```
# vmstat -m
```
#### 获取有关活动和非活动内存页面的信息
```
# vmstat -a
```
相关链接：[如何查看 Linux 的资源利用率从而找到系统瓶颈？](https://www.cyberciti.biz/tips/linux-resource-utilization-to-detect-system-bottlenecks.html)
### 3. w - 找出登录的用户以及他们在做什么
[w 命令](https://www.cyberciti.biz/faq/unix-linux-w-command-examples-syntax-usage-2/ "See Linux/Unix w command examples for more info") 显示了当前登录在该系统上的用户及其进程。
```
# w username
# w vivek
```
输出示例：
```
17:58:47 up 5 days, 20:28, 2 users, load average: 0.36, 0.26, 0.24
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
root pts/0 10.1.3.145 14:55 5.00s 0.04s 0.02s vim /etc/resolv.conf
root pts/1 10.1.3.145 17:43 0.00s 0.03s 0.00s w
```
### 4. uptime - Linux 系统运行了多久
`uptime` 命令可以用来查看服务器运行了多长时间：当前时间、已运行的时间、当前登录的用户连接数，以及过去 1 分钟、5 分钟和 15 分钟的系统负载平均值。
```
# uptime
```
输出示例：
```
18:02:41 up 41 days, 23:42, 1 user, load average: 0.00, 0.00, 0.00
```
`1` 可以被认为是最佳负载值。不同的系统会有不同的负载：对于单核 CPU 系统来说，`1` 到 `3` 的负载值是可以接受的；而对于 SMP（对称多处理）系统来说，负载可以是 `6` 到 `10`。
### 5. ps - 显示系统进程
`ps` 命令显示当前运行的进程。要显示所有的进程，请使用 `-A` 或 `-e` 选项：
```
# ps -A
```
输出示例：
```
PID TTY TIME CMD
1 ? 00:00:02 init
2 ? 00:00:02 migration/0
3 ? 00:00:01 ksoftirqd/0
4 ? 00:00:00 watchdog/0
5 ? 00:00:00 migration/1
6 ? 00:00:15 ksoftirqd/1
....
.....
4881 ? 00:53:28 java
4885 tty1 00:00:00 mingetty
4886 tty2 00:00:00 mingetty
4887 tty3 00:00:00 mingetty
4888 tty4 00:00:00 mingetty
4891 tty5 00:00:00 mingetty
4892 tty6 00:00:00 mingetty
4893 ttyS1 00:00:00 agetty
12853 ? 00:00:00 cifsoplockd
12854 ? 00:00:00 cifsdnotifyd
14231 ? 00:10:34 lighttpd
14232 ? 00:00:00 php-cgi
54981 pts/0 00:00:00 vim
55465 ? 00:00:00 php-cgi
55546 ? 00:00:00 bind9-snmp-stat
55704 pts/1 00:00:00 ps
```
`ps` 与 `top` 类似，但它提供了更多的信息。
#### 显示长输出格式
```
# ps -Al
```
显示完整输出格式（它将显示传递给进程的命令行参数）：
```
# ps -AlF
```
#### 显示线程（轻量级进程（LWP）和线程的数量（NLWP））
```
# ps -AlFH
```
#### 在进程后显示线程
```
# ps -AlLm
```
#### 显示系统上所有的进程
```
# ps ax
# ps axu
```
#### 显示进程树
```
# ps -ejH
# ps axjf
# pstree
```
#### 显示进程的安全信息
```
# ps -eo euser,ruser,suser,fuser,f,comm,label
# ps axZ
# ps -eM
```
#### 显示指定用户（如 vivek）运行的进程
```
# ps -U vivek -u vivek u
```
#### 设置用户自定义的输出格式
```
# ps -eo pid,tid,class,rtprio,ni,pri,psr,pcpu,stat,wchan:14,comm
# ps axo stat,euid,ruid,tty,tpgid,sess,pgrp,ppid,pid,pcpu,comm
# ps -eopid,tt,user,fname,tmout,f,wchan
```
#### 显示某进程（如 lighttpd）的 PID
```
# ps -C lighttpd -o pid=
```
或
```
# pgrep lighttpd
```
或
```
# pgrep -u vivek php-cgi
```
#### 显示指定 PID（如 55977）的进程名称
```
# ps -p 55977 -o comm=
```
#### 找出占用内存资源最多的前 10 个进程
```
# ps -auxf | sort -nr -k 4 | head -10
```
#### 找出占用 CPU 资源最多的前 10 个进程
```
# ps -auxf | sort -nr -k 3 | head -10
```
相关链接：[显示 Linux 上所有运行的进程](https://www.cyberciti.biz/faq/show-all-running-processes-in-linux/)
### 6. free - 内存使用情况
`free` 命令显示了系统的可用和已用的物理内存及交换内存的总量，以及内核用到的缓存空间。
```
# free
```
输出示例：
```
total used free shared buffers cached
Mem: 12302896 9739664 2563232 0 523124 5154740
-/+ buffers/cache: 4061800 8241096
Swap: 1052248 0 1052248
```
相关链接： 1. [获取 Linux 的虚拟内存的内存页大小（PAGESIZE）](https://www.cyberciti.biz/faq/linux-check-the-size-of-pagesize/) 2. [限制 Linux 每个进程的 CPU 使用率](https://www.cyberciti.biz/faq/cpu-usage-limiter-for-linux/) 3. [我的 Ubuntu 或 Fedora Linux 系统有多少内存？](https://www.cyberciti.biz/tips/how-much-ram-does-my-linux-system.html)
### 7. iostat - CPU 平均负载和磁盘活动
`iostat` 命令用于汇报 CPU 的使用情况，以及设备、分区和网络文件系统（NFS）的 IO 统计信息。
```
# iostat
```
输出示例：
```
Linux 2.6.18-128.1.14.el5 (www03.nixcraft.in) 06/26/2009
avg-cpu: %user %nice %system %iowait %steal %idle
3.50 0.09 0.51 0.03 0.00 95.86
Device: tps Blk_read/s Blk_wrtn/s Blk_read Blk_wrtn
sda 22.04 31.88 512.03 16193351 260102868
sda1 0.00 0.00 0.00 2166 180
sda2 22.04 31.87 512.03 16189010 260102688
sda3 0.00 0.00 0.00 1615 0
```
相关链接：[如何跟踪 Linux 系统的 NFS 目录或磁盘的 IO 负载情况](https://www.cyberciti.biz/faq/howto-linux-track-nfs-client-disk-metrics/)
### 8. sar - 监控、收集和汇报系统活动
`sar` 命令用于收集、汇报和保存系统活动信息。要查看网络统计，请输入：
```
# sar -n DEV | more
```
显示 24 日的网络统计：
`# sar -n DEV -f /var/log/sa/sa24 | more`
您还可以使用 `sar` 显示实时使用情况：
```
# sar 4 5
```
输出示例：
```
Linux 2.6.18-128.1.14.el5 (www03.nixcraft.in) 06/26/2009
06:45:12 PM CPU %user %nice %system %iowait %steal %idle
06:45:16 PM all 2.00 0.00 0.22 0.00 0.00 97.78
06:45:20 PM all 2.07 0.00 0.38 0.03 0.00 97.52
06:45:24 PM all 0.94 0.00 0.28 0.00 0.00 98.78
06:45:28 PM all 1.56 0.00 0.22 0.00 0.00 98.22
06:45:32 PM all 3.53 0.00 0.25 0.03 0.00 96.19
Average: all 2.02 0.00 0.27 0.01 0.00 97.70
```
相关链接：
* [如何将 Linux 系统资源利用率的数据写入文件中](https://www.cyberciti.biz/tips/howto-write-system-utilization-data-to-file.html)
* [如何使用 kSar 创建 sar 性能图以找出系统瓶颈](https://www.cyberciti.biz/tips/identifying-linux-bottlenecks-sar-graphs-with-ksar.html)
### 9. mpstat - 监控多处理器的使用情况
`mpstat` 命令显示每个可用处理器的使用情况，编号从 0 开始。命令 `mpstat -P ALL` 显示了每个处理器的平均使用率：
```
# mpstat -P ALL
```
输出示例：
```
Linux 2.6.18-128.1.14.el5 (www03.nixcraft.in) 06/26/2009
06:48:11 PM CPU %user %nice %sys %iowait %irq %soft %steal %idle intr/s
06:48:11 PM all 3.50 0.09 0.34 0.03 0.01 0.17 0.00 95.86 1218.04
06:48:11 PM 0 3.44 0.08 0.31 0.02 0.00 0.12 0.00 96.04 1000.31
06:48:11 PM 1 3.10 0.08 0.32 0.09 0.02 0.11 0.00 96.28 34.93
06:48:11 PM 2 4.16 0.11 0.36 0.02 0.00 0.11 0.00 95.25 0.00
06:48:11 PM 3 3.77 0.11 0.38 0.03 0.01 0.24 0.00 95.46 44.80
06:48:11 PM 4 2.96 0.07 0.29 0.04 0.02 0.10 0.00 96.52 25.91
06:48:11 PM 5 3.26 0.08 0.28 0.03 0.01 0.10 0.00 96.23 14.98
06:48:11 PM 6 4.00 0.10 0.34 0.01 0.00 0.13 0.00 95.42 3.75
06:48:11 PM 7 3.30 0.11 0.39 0.03 0.01 0.46 0.00 95.69 76.89
```
相关链接：[多处理器的 Linux 上单独显示每个 CPU 的使用率](https://www.cyberciti.biz/faq/linux-mpstat-command-report-processors-related-statistics/).
### 10. pmap - 监控进程的内存使用情况
`pmap` 命令用以显示进程的内存映射，使用此命令可以查找内存瓶颈。
```
# pmap -d PID
```
显示 PID 为 47394 的进程的内存信息，请输入：
```
# pmap -d 47394
```
输出示例：
```
47394: /usr/bin/php-cgi
Address Kbytes Mode Offset Device Mapping
0000000000400000 2584 r-x-- 0000000000000000 008:00002 php-cgi
0000000000886000 140 rw--- 0000000000286000 008:00002 php-cgi
00000000008a9000 52 rw--- 00000000008a9000 000:00000 [ anon ]
0000000000aa8000 76 rw--- 00000000002a8000 008:00002 php-cgi
000000000f678000 1980 rw--- 000000000f678000 000:00000 [ anon ]
000000314a600000 112 r-x-- 0000000000000000 008:00002 ld-2.5.so
000000314a81b000 4 r---- 000000000001b000 008:00002 ld-2.5.so
000000314a81c000 4 rw--- 000000000001c000 008:00002 ld-2.5.so
000000314aa00000 1328 r-x-- 0000000000000000 008:00002 libc-2.5.so
000000314ab4c000 2048 ----- 000000000014c000 008:00002 libc-2.5.so
.....
......
..
00002af8d48fd000 4 rw--- 0000000000006000 008:00002 xsl.so
00002af8d490c000 40 r-x-- 0000000000000000 008:00002 libnss_files-2.5.so
00002af8d4916000 2044 ----- 000000000000a000 008:00002 libnss_files-2.5.so
00002af8d4b15000 4 r---- 0000000000009000 008:00002 libnss_files-2.5.so
00002af8d4b16000 4 rw--- 000000000000a000 008:00002 libnss_files-2.5.so
00002af8d4b17000 768000 rw-s- 0000000000000000 000:00009 zero (deleted)
00007fffc95fe000 84 rw--- 00007ffffffea000 000:00000 [ stack ]
ffffffffff600000 8192 ----- 0000000000000000 000:00000 [ anon ]
mapped: 933712K writeable/private: 4304K shared: 768000K
```
最后一行非常重要：
* `mapped: 933712K` 映射到文件的内存量
* `writeable/private: 4304K` 私有地址空间
* `shared: 768000K` 此进程与其他进程共享的地址空间
相关链接：[使用 pmap 命令查看 Linux 上单个程序或进程使用的内存](https://www.cyberciti.biz/tips/howto-find-memory-used-by-program.html)
### 11. netstat - Linux 网络统计监控工具
`netstat` 命令显示网络连接、路由表、接口统计、伪装连接和多播连接等信息。
```
# netstat -tulpn
# netstat -nat
```
### 12. ss - 网络统计
`ss` 命令用于获取套接字统计信息。它可以显示类似于 `netstat` 的信息。不过 `netstat` 几乎要过时了，`ss` 命令更具优势。要显示所有 TCP 或 UDP 套接字：
```
# ss -t -a
```
或
```
# ss -u -a
```
显示所有带有 SELinux <ruby> 安全上下文 <rt> Security Context </rt></ruby>的 TCP 套接字：
```
# ss -t -a -Z
```
请参阅以下关于 `ss` 和 `netstat` 命令的资料：
* [ss：显示 Linux TCP / UDP 网络套接字信息](https://www.cyberciti.biz/tips/linux-investigate-sockets-network-connections.html)
* [使用 netstat 命令获取有关特定 IP 地址连接的详细信息](https://www.cyberciti.biz/tips/netstat-command-tutorial-examples.html)
### 13. iptraf - 获取实时网络统计信息
`iptraf` 命令是一个基于 ncurses 的交互式 IP 网络监控工具。它可以生成多种网络统计信息，包括 TCP 信息、UDP 计数、ICMP 和 OSPF 信息、以太网负载信息、节点统计信息、IP 校验错误等。它以简单的格式提供了以下信息：
* 基于 TCP 连接的网络流量统计
* 基于网络接口的 IP 流量统计
* 基于协议的网络流量统计
* 基于 TCP/UDP 端口和数据包大小的网络流量统计
* 基于二层地址的网络流量统计
*图 02：常规接口统计：基于网络接口的 IP 流量统计*
*图 03：基于 TCP 连接的网络流量统计*
相关链接：[在 Centos / RHEL / Fedora Linux 上安装 IPTraf 以获取网络统计信息](https://www.cyberciti.biz/faq/install-iptraf-centos-redhat-fedora-linux/)
### 14. tcpdump - 详细的网络流量分析
`tcpdump` 命令是简单的分析网络通信的命令。您需要充分了解 TCP/IP 协议才便于使用此工具。例如，要显示有关 DNS 的流量信息，请输入：
```
# tcpdump -i eth1 'udp port 53'
```
查看所有去往和来自端口 80 的 IPv4 HTTP 数据包，仅打印真正包含数据的包，而不是像 SYN、FIN 和仅含 ACK 这类的数据包，请输入：
```
# tcpdump 'tcp port 80 and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)'
```
显示所有目标地址为 202.54.1.5 的 FTP 会话，请输入：
```
# tcpdump -i eth1 'dst 202.54.1.5 and (port 21 or 20'
```
打印所有目标地址为 192.168.1.5 的 HTTP 会话：
```
# tcpdump -ni eth0 'dst 192.168.1.5 and tcp and port http'
```
使用 [wireshark](https://www.cyberciti.biz/faq/linux-unix-bsd-apache-tcpdump-http-packets-sniffing/) 查看文件的详细内容，请输入：
```
# tcpdump -n -i eth1 -s 0 -w output.txt src or dst port 80
```
### 15. iotop - I/O 监控
`iotop` 命令利用 Linux 内核监控 I/O 使用情况，它按进程或线程的顺序显示 I/O 使用情况。
```
$ sudo iotop
```
输出示例：
相关链接：[Linux iotop：什么进程在增加硬盘负载](https://www.cyberciti.biz/hardware/linux-iotop-simple-top-like-io-monitor/)
### 16. htop - 交互式的进程查看器
`htop` 是一款免费并开源的基于 ncurses 的 Linux 进程查看器。它比 `top` 命令更简单易用。您无需使用 PID、无需离开 `htop` 界面，便可以杀掉进程或调整其调度优先级。
```
$ htop
```
输出示例：
相关链接：[CentOS / RHEL：安装 htop——交互式文本模式进程查看器](https://www.cyberciti.biz/faq/centos-redhat-linux-install-htop-command-using-yum/)
### 17. atop - 高级版系统与进程监控工具
`atop` 是一个非常强大的交互式 Linux 系统负载监控器，它从性能的角度显示最关键的硬件资源信息。您可以快速查看 CPU、内存、磁盘和网络性能。它还可以从进程的级别显示哪些进程造成了相关 CPU 和内存的负载。
```
$ atop
```
相关链接：[CentOS / RHEL：安装 atop 工具——高级系统和进程监控器](https://www.cyberciti.biz/faq/centos-redhat-linux-install-atop-command-using-yum/)
### 18. ac 和 lastcomm
您一定需要监控 Linux 服务器上的进程和登录活动吧。`psacct` 或 `acct` 软件包中包含了多个用于监控进程活动的工具，包括：
1. `ac` 命令：显示有关用户连接时间的统计信息
2. [lastcomm 命令](https://www.cyberciti.biz/faq/linux-unix-lastcomm-command-examples-usage-syntax/ "See Linux/Unix lastcomm command examples for more info")：显示已执行过的命令
3. `accton` 命令：打开或关闭进程账号记录功能
4. `sa` 命令：进程账号记录信息的摘要
相关链接：[如何对 Linux 系统的活动做详细的跟踪记录](https://www.cyberciti.biz/tips/howto-log-user-activity-using-process-accounting.html)
### 19. monit - 进程监控器
`monit` 是一个免费且开源的进程监控软件，它可以自动重启停掉的服务。您也可以使用 Systemd、daemontools 或其他类似工具来达到同样的目的。[本教程演示如何在 Debian 或 Ubuntu Linux 上安装和配置 monit 作为进程监控器](https://www.cyberciti.biz/faq/how-to-install-and-use-monit-on-ubuntudebian-linux-server/)。
### 20. NetHogs - 找出占用带宽的进程
NetHogs 是一个轻便的网络监控工具，它按照进程名称（如 Firefox、wget 等）对带宽进行分组。如果网络流量突然爆发，启动 NetHogs，您将看到哪个进程（PID）导致了带宽激增。
```
$ sudo nethogs
```
相关链接：[Linux：使用 Nethogs 工具查看每个进程的带宽使用情况](https://www.cyberciti.biz/faq/linux-find-out-what-process-is-using-bandwidth/)
### 21. iftop - 显示主机上网络接口的带宽使用情况
`iftop` 命令监听指定接口（如 eth0）上的网络通信情况。[它显示了一对主机的带宽使用情况](https://www.cyberciti.biz/tips/linux-display-bandwidth-usage-on-network-interface-by-host.html)。
```
$ sudo iftop
```
### 22. vnstat - 基于控制台的网络流量监控工具
`vnstat` 是一个简单易用的基于控制台的网络流量监视器，它为指定网络接口保留每小时、每天和每月网络流量日志。
```
$ vnstat
```
相关链接：
* [为 ADSL 或专用远程 Linux 服务器保留日常网络流量日志](https://www.cyberciti.biz/tips/linux-display-bandwidth-usage-on-network-interface-by-host.html)
* [CentOS / RHEL：安装 vnStat 网络流量监控器以保留日常网络流量日志](https://www.cyberciti.biz/faq/centos-redhat-fedora-linux-install-vnstat-bandwidth-monitor/)
* [CentOS / RHEL：使用 PHP 网页前端接口查看 Vnstat 图表](https://www.cyberciti.biz/faq/centos-redhat-fedora-linux-vnstat-php-webinterface-frontend-config/)
### 23. nmon - Linux 系统管理员的调优和基准测量工具
`nmon` 是 Linux 系统管理员用于性能调优的利器，它在命令行显示 CPU、内存、网络、磁盘、文件系统、NFS、消耗资源最多的进程和分区信息。
```
$ nmon
```
相关链接：[安装并使用 nmon 工具来监控 Linux 系统的性能](https://www.cyberciti.biz/faq/nmon-performance-analyzer-linux-server-tool/)
### 24. glances - 密切关注 Linux 系统
`glances` 是一款开源的跨平台监控工具。它在小小的屏幕上提供了大量的信息，还可以工作于客户端-服务器模式下。
```
$ glances
```
相关链接：[Linux：通过 Glances 监控器密切关注您的系统](https://www.cyberciti.biz/faq/linux-install-glances-monitoring-tool/)
### 25. strace - 查看系统调用
想要跟踪 Linux 系统的调用和信号吗？试试 `strace` 命令吧。它对于调试网页服务器和其他服务器问题很有用。了解如何利用其 [追踪进程](https://www.cyberciti.biz/tips/linux-strace-command-examples.html) 并查看它在做什么。
### 26. /proc 文件系统 - 各种内核信息
`/proc` 文件系统提供了不同硬件设备和 Linux 内核的详细信息。更多详细信息，请参阅 [Linux 内核 /proc](https://www.cyberciti.biz/files/linux-kernel/Documentation/filesystems/proc.txt) 文档。常见的 `/proc` 例子：
```
# cat /proc/cpuinfo
# cat /proc/meminfo
# cat /proc/zoneinfo
# cat /proc/mounts
```
### 27. Nagios - Linux 服务器和网络监控
[Nagios](http://www.nagios.org/) 是一款普遍使用的开源系统和网络监控软件。您可以轻松地监控所有主机、网络设备和服务，当状态异常和恢复正常时它都会发出警报通知。[FAN](http://fannagioscd.sourceforge.net/drupal/) 是“全自动 Nagios”的缩写。FAN 的目标是提供包含由 Nagios 社区提供的大多数工具包的 Nagios 安装。FAN 提供了标准 ISO 格式的 CD-Rom 镜像，使安装变得更加容易。除此之外，为了改善 Nagios 的用户体验，发行版还包含了大量的工具。
### 28. Cacti - 基于 Web 的 Linux 监控工具
Cacti 是一个完整的网络图形化解决方案，旨在充分利用 RRDTool 的数据存储和图形功能。Cacti 提供了快速轮询器、高级图形模板、多种数据采集方法和用户管理功能。这些功能被包装在一个直观易用的界面中，确保可以实现从局域网到拥有数百台设备的复杂网络上的安装。它可以提供有关网络、CPU、内存、登录用户、Apache、DNS 服务器等的数据。了解如何在 CentOS / RHEL 下 [安装和配置 Cacti 网络图形化工具](https://www.cyberciti.biz/faq/fedora-rhel-install-cacti-monitoring-rrd-software/)。
### 29. KDE 系统监控器 - 实时系统报告和图形化显示
KSysguard 是 KDE 桌面的网络化系统监控程序。这个工具可以通过 ssh 会话运行。它提供了许多功能，比如可以监控本地和远程主机的客户端-服务器模式。前端图形界面使用传感器来检索信息。传感器可以返回简单的值或更复杂的信息，如表格。每种类型的信息都有一个或多个显示界面，并被组织成工作表的形式，这些工作表可以分别保存和加载。所以，KSysguard 不仅是一个简单的任务管理器，还是一个控制大型服务器平台的强大工具。
*图 05：KDE System Guard {图片来源：维基百科}*
详细用法，请参阅 [KSysguard 手册](https://docs.kde.org/stable5/en/kde-workspace/ksysguard/index.html)。
### 30. GNOME 系统监控器
系统监控程序能够显示系统基本信息，并监控系统进程、系统资源使用情况和文件系统。您还可以用其修改系统行为。虽然不如 KDE System Guard 强大，但它提供的基本信息对新用户还是有用的：
* 显示关于计算机硬件和软件的各种基本信息
* Linux 内核版本
* GNOME 版本
* 硬件
* 安装的内存
* 处理器和速度
* 系统状况
* 可用磁盘空间
* 进程
* 内存和交换空间
* 网络使用情况
* 文件系统
* 列出所有挂载的文件系统及其基本信息
*图 06：Gnome 系统监控程序*
### 福利：其他工具
更多工具：
* [nmap](https://www.cyberciti.biz/tips/linux-scanning-network-for-open-ports.html) - 扫描服务器的开放端口
* [lsof](https://www.cyberciti.biz/tips/tag/lsof-command) - 列出打开的文件和网络连接等
* [ntop](https://www.cyberciti.biz/faq/debian-ubuntu-install-ntop-network-traffic-monitoring-software/ "Debian / Ubuntu Linux Install ntop To See Network Usage / Network Status") 基于网页的工具 - `ntop` 是查看网络使用情况的最佳工具，与 `top` 命令之于进程的方式类似，即网络流量监控工具。您可以查看网络状态和 UDP、TCP、DNS、HTTP 等协议的流量分发。
* [Conky](https://github.com/brndnmtthws/conky) - X Window 系统下的另一个很好的监控工具。它具有很高的可配置性，能够监视许多系统变量，包括 CPU 状态、内存、交换空间、磁盘存储、温度、进程、网络接口、电池、系统消息和电子邮件等。
* [GKrellM](http://gkrellm.srcbox.net/) - 它可以用来监控 CPU 状态、主内存、硬盘、网络接口、本地和远程邮箱及其他信息。
* [mtr](https://www.cyberciti.biz/tips/finding-out-a-bad-or-simply-overloaded-network-link-with-linuxunix-oses.html) - `mtr` 将 `traceroute` 和 `ping` 程序的功能结合在一个网络诊断工具中。
* [vtop](https://www.cyberciti.biz/faq/how-to-install-and-use-vtop-graphical-terminal-activity-monitor-on-linux/) - 图形化活动监控终端
如果您有其他推荐的系统监控工具，欢迎在评论区分享。
### 关于作者
作者 Vivek Gite 是 nixCraft 的创建者，也是经验丰富的系统管理员，以及 Linux 操作系统和 Unix shell 脚本的培训师。他的客户遍布全球，行业涉及 IT、教育、国防航天研究以及非营利部门等。您可以在 [Twitter](https://twitter.com/nixcraft)、[Facebook](https://facebook.com/nixcraft) 和 [Google+](https://plus.google.com/+CybercitiBiz) 上关注他。
---
via: <https://www.cyberciti.biz/tips/top-linux-monitoring-tools.html>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[jessie-pang](https://github.com/jessie-pang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
你的 Github 仓库被 DMCA Takedown 后怎么办？
|
Bestony
|
我们的开源项目放在 GitHub 上的仓库由于收到了 DMCA Takedown 投诉被封禁，仓库处于不可访问状态。在解决了这个惊魂事件之后，我们将此中得到的教训和经验分享给大家。
|
/data/attachment/album/201802/23/021721tniukydfunnyikai.jpg.thumb.jpg
|
/data/attachment/album/201802/23/021721tniukydfunnyikai.jpg
| true | false | false | false |
[
"GitHub",
"DMCA"
] |
技术
|
{
"viewnum": 18576,
"commentnum": 4,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "218.20.4.82",
"message": "很好奇是什么文件侵犯了版权",
"username": "来自广东广州的 QQ Browser 10.5|Windows 7 用户",
"date": "2020-04-06T23:33:06"
},
{
"postip": "223.88.96.20",
"message": "<script>alert('XSS Inject Test')</script>",
"username": "来自河南郑州的 Firefox 108.0|Windows 10 用户",
"date": "2023-01-18T18:42:26"
},
{
"postip": "118.249.42.191",
"message": "都什么年代 还在进行传统XSS注入？",
"username": "来自湖南长沙的 Chrome 109.0|Windows 10 用户",
"date": "2023-02-09T09:13:27"
},
{
"postip": "91.199.84.73",
"message": "应该是误用某个有版权的图标之类",
"username": "来自荷兰的 Chrome Mobile 120.0|Android 10 用户",
"date": "2024-02-04T07:56:37"
}
] |
[] |
我们的开源项目放在 GitHub 上的仓库由于收到了 DMCA Takedown 投诉被封禁，仓库处于不可访问状态。在解决了这个惊魂事件之后，我们将此中得到的教训和经验分享给大家。
| 2018-02-23T02:17:00 | 2018-02-23T02:17:00 | 9,374 |
/article-9374-1.html
|
### 仓库被封禁
在 2018 年 2 月 20 日，我们的开源项目放在 GitHub 上的仓库由于收到了 DMCA Takedown 投诉被封禁，仓库处于不可访问状态。此时在 GitHub 上访问该仓库时，会显示一个公开消息，表明该仓库被封禁的原因。
按照 GitHub DMCA 的规则，GitHub 在确认投诉有效后，会给该仓库的管理员发送一封邮件，提示该仓库需要在 24 小时内清理被投诉的内容，并**回复** GitHub 才行——否则，该仓库会被封禁，禁止任何访问和数据导出。
我们在收到该 Takedown 投诉后，会有 24 小时的时间来响应，但由于过年期间，仓库拥有者没有及时看到邮件，未能及时发现这么严重的通知。因此，在过了 24 小时后， Github 按照 DMCA 的规则，进行了仓库的封禁。
仓库被封禁后，我们发现无法访问。根据封禁消息的提示，发现原来之前仓库内的某个文件出了问题，侵犯了原作者的版权。原作者向 Github 发送了 DMCA 投诉。而由于我们的未及时处理，导致了仓库的最终被封。当我们发现被封时，已经是深夜了。
### 紧急商讨方案
在被封禁后，由于已经超过了 24 小时时限，在这个阶段下， GitHub 的文档中给出的解决方案仅有请求 GitHub 来删除该仓库并根据自己手里的仓库数据重建的方案。但对我们来说，这种方案是不可接受的，因为这种方案会导致丢失所有的 issue、PR、Wiki，以及你本地的仓库和远程的仓库之间的版本差异。
我们在群内先找了更新最全的 fork，找到了一个群友提供的，和上游只差 2 个提交的版本，并将其保存下来，作为最后的自救手段。
此外，在查询 DMCA 的过程中，我了解到 DMCA 除了有 DMCA Takedown 以外，还有一个 DMCA Counter Notice，用于反向解除 DMCA 封禁。
>
> **DMCA Counter Notice**
>
>
> DMCA Counter Notice 用于向服务商发起申诉，说明 DMCA Takedown 投诉为恶意投诉且并无版权问题。
>
>
> **延展阅读**
>
>
> <https://www.plagiarismtoday.com/2010/06/03/7-common-questions-about-dmca-counter-notices/>
>
>
> <https://help.github.com/articles/guide-to-submitting-a-dmca-counter-notice/>
>
>
>
当时考虑到我们已经错过了窗口期，没办法删除 GitHub 上仓库中的特定文件，所以想通过 DMCA Counter Notice 来解除封禁。
为此，我通过 Github 发给我们的邮件，找到了那份侵权文件，并在他的网站中找到了版权拥有者的邮件，发送邮件说明情况，看看能否通过付费获得授权。但其是挪威人，存在时差，所以我们只能边等待，边想办法。
### 山重水复疑无路，柳暗花明又一村
在准备 DMCA Counter Notice 时，我们又向 Github 发送了邮件，说明了中国春节的特殊情况，导致我们没有来得及处理文件，请求给我们一个机会让我们处理这些文件。但是迟迟没有回应，无奈之下，多位成员又以成员身份向 GitHub 发送邮件，请求给予帮助。
令人惊奇的是，经过大约 9 个小时的等待，仓库拥有者的请求邮件似乎开小差了，而各位成员的请求邮件得到了响应。Github 回信给大家说，根据其规则，给出了额外的 24 小时窗口期，让我们处理这些文件（后来经过仔细查阅 GitHub 的 DMCA Takedown 规则，对这种错过了第一次窗口期的情况，可以给予第二个，也是最后一个窗口期）。但是这个开启额外的窗口期，需要仓库的拥有者向 GitHub 发送邮件请求。
然后，我们就以仓库拥有者的身份再次向 GitHub 发送了请求，可能是由于时差的原因，又是几个小时没有回应。
与此同时，我们也收到了版权拥有者的回复。很遗憾，原作者不愿意授权，也不打算收费。好在 Github 给的额外窗口期，让我们有了改正错误的机会。
还好，在焦急的等待之中，我们终于收到了 GitHub 的回复，并同时恢复了仓库的访问——宝贵的 24 小时窗口期。
### 使用 BFG 处理文件
得到了窗口期后，我们开始处理仓库内的文件。
首先，你得清除了现在还在仓库里面的文件，然后再使用下面的方面来清除提交历史中的数据。
>
> **推荐阅读**
>
>
> 以下文章建议按顺序阅读
>
>
> <https://help.github.com/articles/removing-sensitive-data-from-a-repository/>
>
>
> <https://rtyley.github.io/bfg-repo-cleaner/>
>
>
>
删除 Git 仓库的历史数据有多种方法，一种是使用 `git filter-branch`来处理，但是速度极慢。另外一种就是使用 BFG 来处理，我们采用的是 BFG 来处理（BFG 是`git filter-branch` 首字母的逆转）。
>
> BFG 需要 Java 的运行环境，如果无法运行，请检查你的本地 Java 环境是否安装，或高于 Java 7 。
>
>
> Java 6 需要使用 bfg v1.12.3版本
>
>
>
BFG 的处理过程比较简单，首先，你需要下载 BFG。
```
wget http://repo1.maven.org/maven2/com/madgag/bfg/1.13.0/bfg-1.13.0.jar
```
然后克隆你的仓库到本地，比如 `bestony/test`。
```
git clone --mirror git://github.com/bestony/test.git
```
克隆时用不用 `--mirror` 模式都可以，但是后续命令上会有所差距，所以我还是推荐大家使用镜像模式，毕竟按照官方的文档走，出现了问题也好搜索。（镜像模式克隆的仓库和远程仓库完全一样，但是不能直接看到仓库里面的文件，而且也不能允许 `git` 的各种命令）
克隆到本地后，执行 BFG 命令来处理文件。
```
cd test.git
java -jar bfg.jar --delete-files "filename"
```
>
> 这里需要注意的是，`filename` 不支持目录路径，只能是文件名，而不能是 `dir/filename` 这样的形式，所以添加参数时你要注意这个。对于有同样名字的文件却想只删除某个目录的情况，可能就没有办法了。
>
>
> 此外，默认情况下， BFG 不会处理最新的提交，它认为你的最新提交应该是干净的（不包含需要删除的敏感数据），如果你要删除的文件是最新的提交（比如你最新的一个提交是删除那些敏感数据），可以加入`--no-blob-protection`参数来强制清除，也可以再添加一个提交，使包含了要被删除文件的提交不是最新的提交。
>
>
>
> ```
> java -jar bfg.jar --delete-files "filename" --no-blob-protection
>
> ```
>
>
BFG 处理完成后，会提示你使用 `git` 命令进行垃圾回收，你需要执行如下命令来操作：
```
cd test.git # 进入目标目录
git reflog expire --expire=now --all && git gc --prune=now --aggressive # 垃圾回收
```
>
> 这里需要注意的是，如果你删除多个文件，每次删除后执行和多个文件都删除后效果一样，所以建议你删除多个文件后再进行垃圾回收，会更省时一些。
>
>
>
处理完成后，将数据推送到远端即可（需要关闭 GitHub 上仓库设置里面对强制推送的防护）：
```
git push
```
执行完成后，就可以到远端上去看了，你的文件会被删除，相关的提交不会被删除，但是提交里面不包含该文件了。
>
> 在推送时，可能会提示你有些更改被拒绝了，这些更改如果是和 Pull Request 有关的，你可以不需要在意，这是 GitHub 自身的问题。Github 设定 Pull Request 是只读不可改的。所以我们无法修改这些信息。
>
>
> 具体可以参考 <https://github.com/rtyley/bfg-repo-cleaner/issues/36>
>
>
>
至此，我们将文件进行了删除处理，并清除了相关的数据。
### 后续处理
在完成文件及历史数据的删除后，我们将我们的删除结果回复了 Github ，等待 Github 的确认。GitHub 会在 24 小时收到该回复后，会通知投诉方进行确认。如果投诉方无异议，此事就此结束，不会再有下一步动作。如果有异议，则会重新进行此流程。
此外，由于 GitHub 存在垃圾缓存回收的时间差，所以你推送到 GitHub 上的数据虽然并无需要被删除的文件，但是依旧在一定时间内可以看到。这种缓存只能请 GitHub 自行操作删除。此外，与要删除的文件相关的 Pull Request 也需要 GitHub 来删除——因为用户是没有权限删除 Pull Request 的。这些请求也可以一并发给 GitHub 来操作（但似乎 GitHub 并不热衷执行这些请求，只要被投诉的文件访问不到即可，也就是说，如果没有被投诉历史数据，其实或许并不用大动干戈清理历史……）。
这种清除操作还有一个副作用就是，所有之前 fork 的仓库，由于主仓库被封禁而导致各个 fork 仓库的 remote 意外地变为另外一个仓库（该仓库是最早的一个 fork 仓库）。而主仓库恢复之后，我们并没有找到好的办法将 remote 恢复回原来的主仓库。因此，需要所有成员重新 fork 主仓库并从缓慢的 GitHub 克隆到本地。
### 余思
这个惊魂事件当中，我们首先要反思的是，我们对版权问题的认识不足，这是一切问题的根源。因此，这之后，我们对既有数据进行了排查。
其次，GitHub 在这种事件的处置上，我们认为也并不够好。这么严重的处置（整个库封禁），仅仅通过一份普通的邮件通知，而且仅仅给出 24 小时的时间窗口。而 GitHub 其实掌握了仓库拥有者的更可靠、更及时的联系方式，比如说手机短信，也完全可以在 GitHub 的网页界面上以显目的方式提醒。另外，虽然 DMCA 规则中提到了可以容情第二个时间窗口，但是似乎这个附加窗口期是后来才改变的政策，在前面的流程说明中并未提及，很容易忽视。
其三，由于封禁会导致对该仓库的所有访问均不可进行，这不仅包括了提交数据，也包括了并没有存在于 Git 仓库中的 issue、PR 和 Wiki 等数据，而 GitHub 不会让你在封禁的情况下有机会导出这些数据。所以，有机会的话，各种数据还是有个备份的好。
最后，感谢在这个事件中，所有不离不弃支持我们的成员，感谢小白进行的仓库清理工作。
### 相关阅读
* <https://blog.kongfanjian.com/2015/03/02/%E6%B0%B8%E4%B9%85%E5%88%A0%E9%99%A4git%E4%BB%93%E5%BA%93%E4%B8%AD%E7%9A%84%E6%96%87%E4%BB%B6%E4%B8%8E%E5%8E%86%E5%8F%B2%E8%AE%B0%E5%BD%95/>
* <https://changkun.us/archives/2017/11/239/>
* <http://debugtalk.com/post/clean-sensitive-data-from-git-history-commits/>
* <http://www.voidcn.com/article/p-njmjnwov-bgk.html>
* <http://www.vicviz.com/githubshang-de-min-gan-shu-ju-de-shan-chu/>
* <https://lightless.me/archives/remove-sensitive-data-on-github.html>
* <http://blog.csdn.net/duandianR/article/details/78843582>
* <https://www.clock.co.uk/insight/deleting-a-git-commit>
* <https://www.jacoballred.com/web-dev/use-bfg-to-completely-remove-a-file-from-your-git-repo/>
* <https://community.atlassian.com/t5/Questions/BFG-for-a-Noob/qaq-p/350944>
* <https://w3guy.com/remove-git-commit-history/>
|
||||
Kali Linux 是什么，你需要它吗？
|
Nick Congleton
|
https://www.maketecheasier.com/what-is-kali-linux-and-do-you-need-it/
|
如果你听到一个 13 岁的黑客吹嘘他是多么的牛逼，是有可能的，因为有 Kali Linux 的存在。尽管有可能会被称为“脚本小子”，但是事实上，Kali 仍旧是安全专家手头的重要工具（或工具集）。
|
/data/attachment/album/201802/23/184821kb93jm96a6d3a31m.jpg.thumb.jpg
|
/data/attachment/album/201802/23/184821kb93jm96a6d3a31m.jpg
| true | false | true |
qhwdw
| false |
[
"Kali",
"黑客"
] |
观点
|
{
"viewnum": 22668,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
如果你听到一个 13 岁的黑客吹嘘他是多么的牛逼，是有可能的，因为有 Kali Linux 的存在。尽管有可能会被称为“脚本小子”，但是事实上，Kali 仍旧是安全专家手头的重要工具（或工具集）。
| 2018-02-23T18:48:18 | 2018-02-23T18:48:18 | 9,375 |
/article-9375-1.html
|
如果你听到一个 13 岁的黑客吹嘘他是多么的牛逼，是有可能的，因为有 Kali Linux 的存在。尽管有可能会被称为“脚本小子”，但是事实上，Kali 仍旧是安全专家手头的重要工具（或工具集）。
Kali 是一个基于 Debian 的 Linux 发行版。它的目标就是为了简单：在一个实用的工具包里尽可能多的包含渗透和审计工具。Kali 实现了这个目标。大多数做安全测试的开源工具都被囊括在内。
**相关** ： [4 个极好的为隐私和安全设计的 Linux 发行版](https://www.maketecheasier.com/linux-distros-designed-for-privacy-security/ "4 Great Linux Distros Designed for Privacy and Security")
### 为什么是 Kali？
[Kali](https://www.offensive-security.com/kali-linux-vmware-virtualbox-image-download/) 是由 [Offensive Security](https://www.offensive-security.com/) 公司开发和维护的。它在安全领域是一家知名的、值得信赖的公司，它甚至还有一些受人尊敬的认证，来对安全从业人员做资格认证。
Kali 也是一个简便的安全解决方案。Kali 并不要求你自己去维护一个 Linux 系统，或者你自己去收集软件和依赖项。它是一个“交钥匙工程”。所有这些繁杂的工作都不需要你去考虑，因此，你只需要专注于要审计的真实工作上，而不需要去考虑准备测试系统。
### 如何使用它？
Kali 是一个 Linux 发行版。与任何一个其它的 Linux 发行版一样，你可以将它永久安装到一个硬盘上。那样它会工作的更好，但是你不能将它作为一个日常使用的操作系统。因为它是为渗透测试构建的，这就是你使用它的全部理由。
最好是将 Kali 制作为自启动发行版。你可以将 Kali 刻录到一张 DVD 或者是制作到一个自启动 U 盘上来运行它。你没有必要在一个 Kali 上安装任何软件或者保存任何文件。你可以在需要测试一个系统时随时来启动它。它也有非常好的灵活性，可以让运行 Kali 的机器随时运行在想要测试的网络上。
### Kali 可以做什么？
Kali 里面有很多的安全工具而不是别的。这就是它能做的事。不管怎么说，Kali 就是一个安全工具。
它有像 NMap 和 Wireskark 这样的经典信息采集工具。
Kali 也有面向 WiFi 的工具，像 Aircrack-ng、Kismet、以及 Pixie。
对于破解密码，它也有像 Hydra、Crunch、Hashcat、以及 John the Ripper 这样的工具。
还有更多的成套工具，包括 Metasploit 和 Burp Suite。
这些只是 Kali 缺省内置的一小部分安全工具。完整的了解这些工具需要很多的时间，但是，你可以清楚地看到许多非常流行的工具它都有。
### Kali 是为你准备的吗？
Kali 并不是为普通用户准备的。它并不是一个运行在你的笔记本电脑上的普通 Linux 发行版，而是一个很酷的“黑客操作系统“。如果你使用这个操作系统，那么你将会运行着一个缺乏安全保障的系统，因为 Kali 被设计为以 root 权限运行。它自身并不安全，并且它的配置也与普通的 Linux 发行版不一样。它是一个攻击型工具，而不是一个防御型工具。
Kali 并不是个玩具。你可以使用它内置的工具去做一些会产生真实伤害的危险的事（你懂的），那将给你带来很多真实的麻烦。对于一个未受到严格教育的用户来说，做一些严重违法的事情是很容易的，并且之后你就会发现自己被陷入很无助的境地。
说了这么多，但是，Kali 对于一个专业用户来说，它是一个极好的工具。如果你是一个网络管理员，想对你的网络做一个真实的测试，Kali 可以做到你所希望的一切事情。Kali 也有一些优秀的开发工具，用于去实时审计它们的应用程序。
当然，如果你正好有兴趣学习关于安全的知识，你可以在某些受控环境中去使用 Kali，它可以教你学习很多的非常优秀的知识。
Kali Linux 是许多优秀的安全工具的集合。对于专业用户来说，它有难以置信的好处，但是对于一些不怀好意的人来说，也可以产生很多大麻烦。小心地使用 Kali，充分利用它的巨大优势。如果不这样的话，你将在某个地方（你懂的）度过你的余生。
---
via: <https://www.maketecheasier.com/what-is-kali-linux-and-do-you-need-it/>
作者：[Nick Congleton](https://www.maketecheasier.com/author/nickcongleton/) 译者：[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/display-asterisks-type-password-terminal/
|
如果你对在终端输入密码时看不到密码感到不舒服，那么这个小技巧会有帮助。
|
/data/attachment/album/201802/23/191336nsn3g23xsm20gi3g.png.thumb.jpg
|
/data/attachment/album/201802/23/191336nsn3g23xsm20gi3g.png
| true | false | true |
geekpi
| false |
[
"密码",
"星号"
] |
技术
|
{
"viewnum": 8558,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你对在终端输入密码时看不到密码感到不舒服，那么这个小技巧会有帮助。
| 2018-02-23T19:13:34 | 2018-02-23T19:13:34 | 9,376 |
/article-9376-1.html
|
当你在 Web 浏览器或任何 GUI 登录中输入密码时，密码会被标记成星号 `********` 或圆点符号 `•••••••••••••` 。这是内置的安全机制，以防止你附近的用户看到你的密码。但是当你在终端输入密码来执行任何 `sudo` 或 `su` 的管理任务时，你不会在输入密码的时候看见星号或者圆点符号。它不会有任何输入密码的视觉指示，也不会有任何光标移动，什么也没有。你不知道你是否输入了所有的字符。你只会看到一个空白的屏幕！
看看下面的截图。
正如你在上面的图片中看到的，我已经输入了密码，但没有任何指示（星号或圆点符号）。现在，我不确定我是否输入了所有密码。这个安全机制也可以防止你附近的人猜测密码长度。当然，这种行为可以改变。这是本指南要说的。这并不困难。请继续阅读。
### 当你在终端输入密码时显示星号
要在终端输入密码时显示星号，我们需要在 `/etc/sudoers` 中做一些小修改。在做任何更改之前，最好备份这个文件。为此，只需运行：
```
sudo cp /etc/sudoers{,.bak}
```
上述命令将 `/etc/sudoers` 备份成名为 `/etc/sudoers.bak`。你可以恢复它，以防万一在编辑文件后出错。
接下来，使用下面的命令编辑 `/etc/sudoers`：
```
sudo visudo
```
找到下面这行：
```
Defaults env_reset
```
在该行的末尾添加一个额外的单词 `,pwfeedback`，如下所示。
```
Defaults env_reset,pwfeedback
```
然后，按下 `CTRL + x` 和 `y` 保存并关闭文件。重新启动终端以使更改生效。
现在，当你在终端输入密码时，你会看到星号。
如果你对在终端输入密码时看不到密码感到不舒服，那么这个小技巧会有帮助。请注意，当你输入输入密码时其他用户就可以预测你的密码长度。如果你不介意，请按照上述方法进行更改，以使你的密码可见（当然，显示为星号！）。
现在就是这样了。还有更好的东西。敬请关注！
干杯!
---
via: <https://www.ostechnix.com/display-asterisks-type-password-terminal/>
作者：[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/) 荣誉推出
|
||
如何在 Ubuntu 16.04 上安装和使用 Encryptpad
|
Hitesh Jethva
|
https://www.howtoforge.com/tutorial/how-to-install-and-use-encryptpad-on-ubuntu-1604/
|
EncryptPad 是一个自由开源软件，它通过简单方便的图形界面和命令行接口来查看和修改加密的文本，它使用 OpenPGP RFC 4880 文件格式。
|
/data/attachment/album/201802/24/111516b0a0arbn8b4bbir7.jpg.thumb.jpg
|
/data/attachment/album/201802/24/111516b0a0arbn8b4bbir7.jpg
| true | false | true |
singledo
| false |
[
"EncryptPad",
"加密",
"PGP"
] |
桌面应用
|
{
"viewnum": 4729,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
EncryptPad 是一个自由开源软件，它通过简单方便的图形界面和命令行接口来查看和修改加密的文本，它使用 OpenPGP RFC 4880 文件格式。
| 2018-02-24T11:15:21 | 2018-02-24T11:15:21 | 9,377 |
/article-9377-1.html
|
EncryptPad 是一个自由开源软件，它通过简单方便的图形界面和命令行接口来查看和修改加密的文本，它使用 OpenPGP RFC 4880 文件格式。通过 EncryptPad，你可以很容易的加密或者解密文件。你能够像保存密码、信用卡信息等私人信息，并使用密码或者密钥文件来访问。
### 特性
* 支持 windows、Linux 和 Max OS。
* 可定制的密码生成器，可生成健壮的密码。
* 随机的密钥文件和密码生成器。
* 支持 GPG 和 EPD 文件格式。
* 能够通过 CURL 自动从远程远程仓库下载密钥。
* 密钥文件的路径能够存储在加密的文件中。如果这样做的话，你不需要每次打开文件都指定密钥文件。
* 提供只读模式来防止文件被修改。
* 可加密二进制文件，例如图片、视频、归档等。
在这份教程中，我们将学习如何在 Ubuntu 16.04 中安装和使用 EncryptPad。
### 环境要求
* 在系统上安装了 Ubuntu 16.04 桌面版本。
* 在系统上有 `sudo` 的权限的普通用户。
### 安装 EncryptPad
在默认情况下，EncryPad 在 Ubuntu 16.04 的默认仓库是不存在的。你需要安装一个额外的仓库。你能够通过下面的命令来添加它 ：
```
sudo apt-add-repository ppa:nilaimogard/webupd8
```
下一步，用下面的命令来更新仓库：
```
sudo apt-get update -y
```
最后一步，通过下面命令安装 EncryptPad：
```
sudo apt-get install encryptpad encryptcli -y
```
当 EncryptPad 安装完成后，你可以在 Ubuntu 的 Dash 上找到它。
### 使用 EncryptPad 生成密钥和密码
现在，在 Ubunntu Dash 上输入 `encryptpad`，你能够在你的屏幕上看到下面的图片 ：
[](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/big/Screenshot-of-encryptpad-dash.png)
下一步，点击 EncryptPad 的图标。你能够看到 EncryptPad 的界面，它是一个简单的文本编辑器，带有顶部菜单栏。
[](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/big/Screenshot-of-encryptpad-dashboard.png)
首先，你需要生成一个密钥文件和密码用于加密/解密任务。点击顶部菜单栏中的 “Encryption->Generate Key”，你会看见下面的界面：
[](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/big/Screenshot-of-encryptpad-generate-key.png)
选择文件保存的路径，点击 “OK” 按钮，你将看到下面的界面：
[](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/big/Screenshot-of-encryptpad-generate-passphrase.png)
输入密钥文件的密码，点击 “OK” 按钮 ，你将看到下面的界面：
[](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/big/Screenshot-of-encryptpad-use-key-file.png)
点击 “yes” 按钮来完成该过程。
### 加密和解密文件
现在，密钥文件和密码都已经生成了。可以执行加密和解密操作了。在这个文件编辑器中打开一个文件文件，点击 “encryption” 图标 ，你会看见下面的界面：
[](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/big/Screenshot-of-encryptpad-start-encryption.png)
提供需要加密的文件和指定输出的文件，提供密码和前面产生的密钥文件。点击 “Start” 按钮来开始加密的进程。当文件被成功的加密，会出现下面的界面：
[](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/big/Screenshot-of-encryptpad-file-encrypted-successfully.png)
文件已经被该密码和密钥文件加密了。
如果你想解密被加密后的文件，打开 EncryptPad ，点击 “File Encryption” ，选择 “Decryption” 操作，提供加密文件的位置和你要保存输出的解密文件的位置，然后提供密钥文件地址，点击 “Start” 按钮，它将要求你输入密码，输入你先前加密使用的密码，点击 “OK” 按钮开始解密过程。当该过程成功完成，你会看到 “File has been decrypted successfully” 的消息 。
[](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/Screenshot-of-encryptpad-decryption-passphrase.png) [](https://www.howtoforge.com/images/how_to_install_and_use_encryptpad_on_ubuntu_1604/big/Screenshot-of-encryptpad-decryption-passphrase.png) []
**注意：**
如果你遗忘了你的密码或者丢失了密钥文件，就没有其他的方法可以打开你的加密信息了。对于 EncrypePad 所支持的格式是没有后门的。
---
via: <https://www.howtoforge.com/tutorial/how-to-install-and-use-encryptpad-on-ubuntu-1604/>
作者：[Hitesh Jethva](https://www.howtoforge.com) 译者：[singledo](https://github.com/singledo) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Torrent 提速为什么总是无济于事
|
Rishabh Kandari
|
http://www.theitstuff.com/increase-torrent-speed-will-never-work
|
相信我，从小到大我就没发现哪个技巧有用过。因此本文我们就就来看看，为什么尝试提高 torrent 速度是行不通的。
|
/data/attachment/album/201802/24/113610t63c21c660hpz0df.jpg.thumb.jpg
|
/data/attachment/album/201802/24/113610t63c21c660hpz0df.jpg
| true | false | true |
lujun9972
| false |
[
"BT",
"网络"
] |
技术
|
{
"viewnum": 5876,
"commentnum": 3,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "60.209.105.170",
"message": "我觉得，最关键的还是做种者的上传速度。",
"username": "绿色圣光 [Firefox 58.0|GNU/Linux]",
"date": "2018-02-28T14:38:11"
},
{
"postip": "115.57.141.29",
"message": "QS",
"username": "来自河南郑州的 Chrome 94.0|Windows 10 用户",
"date": "2021-10-08T16:21:51"
},
{
"postip": "115.57.141.29",
"message": "QS",
"username": "来自河南郑州的 Chrome 94.0|Windows 10 用户",
"date": "2021-10-08T16:21:54"
}
] |
[
{
"raid": 9388,
"displayorder": 0
}
] |
相信我，从小到大我就没发现哪个技巧有用过。因此本文我们就就来看看，为什么尝试提高 torrent 速度是行不通的。
| 2018-02-24T11:36:08 | 2018-02-24T11:36:08 | 9,378 |
/article-9378-1.html
|
是不是总是想要 **更快的 torrent 速度**？不管现在的速度有多块，但总是无法对此满足。我们对 torrent 速度的痴迷使我们经常从包括 YouTube 视频在内的许多网站上寻找并应用各种所谓的技巧。但是相信我，从小到大我就没发现哪个技巧有用过。因此本文我们就就来看看，为什么尝试提高 torrent 速度是行不通的。
### 影响速度的因素
#### 本地因素
从下图中可以看到 3 台电脑分别对应的 A、B、C 三个用户。A 和 B 本地相连，而 C 的位置则比较远，它与本地之间有 1、2、3 三个连接点。
[](http://www.theitstuff.com/wp-content/uploads/2017/11/A.png)
若用户 A 和用户 B 之间要分享文件，他们之间直接分享就能达到最大速度了而无需使用 torrent。这个速度跟互联网什么的都没有关系。
* 网线的性能
* 网卡的性能
* 路由器的性能
当谈到 torrent 的时候，人们都是在说一些很复杂的东西，但是却总是不得要点。
[](http://www.theitstuff.com/wp-content/uploads/2017/11/A-1-e1509773618549.png)
现在我们谈论的是本地文件分享，目前较新一点的网卡速率大约 1 Gigabit 左右。常见的路由器大约 300 Megabits 而网线大概能达到 100 Megabits。当然具体的配置可能不一样，我这里只是给一个一般性的例子。
由于你有一个 1 Gigabit 的网卡，你可能会觉得你的下载速度应该达到 125 Megabytes。但是路由器只允许传输 300 Megabits 也就是 30 Megabyte。
即使你把目标降到 30 Megabytes，然而你连接到路由器的电缆/网线的性能最多只有 100 megabits 也就是 10 MegaBytes。这是一个纯粹的瓶颈问题，由一个薄弱的环节影响到了其他强健部分，也就是说这个传输速率只能达到 10 Megabytes，即电缆的极限速度。现在想象有一个 torrent 即使能够用最大速度进行下载，那也会由于你的硬件不够强大而导致瓶颈。
#### 外部因素
现在再来看一下这幅图。用户 C 在很遥远的某个地方。甚至可能在另一个国家。
[](http://www.theitstuff.com/wp-content/uploads/2017/11/A.png)
假设这个用户创建了一个 torrent 而你想去下载它。第一个问题就是我们刚才讨论过的，你不可能跨越 10 Megabyte 这道坎。
第二，由于 C 与本地之间多个有连接点，其中一个点就有可能成为瓶颈所在，可能由于繁重的流量和相对薄弱的硬件导致了缓慢的速度。
#### 做种者与吸血者
关于此已经有了太多的讨论，总的想法就是搜索更多的种子，但要注意上面的那些因素，有一个很好的种子提供者，但是跟我之间的连接不好的话那也是无济于事的。通常，这不可能发生，因为我们也不是唯一下载这个资源的人，一般都会有一些在本地的人已经下载好了这个文件并已经在做种了。
### 结论
我们尝试搞清楚哪些因素影响了 torrent 速度的好坏。不管我们如何用软件进行优化，大多数时候是这是由于物理瓶颈导致的。我从来不关心那些软件，使用默认配置对我来说就够了。
希望你会喜欢这篇文章，有什么想法敬请留言。
---
via: <http://www.theitstuff.com/increase-torrent-speed-will-never-work>
作者：[Rishabh Kandari](http://www.theitstuff.com/author/reevkandari) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
6 个 Linux 平台下最好的替代 MS Office 的开源办公软件
|
Abhishek Prakash
|
https://itsfoss.com/best-free-open-source-alternatives-microsoft-office/
|
还在 Linux 中寻找 Microsoft Office 吗? 这里有一些最好的在 Linux 平台下替代 Microsoft Office 的开源软件。
|
/data/attachment/album/201802/24/210910ry1c2pcv4vssm6sm.jpg.thumb.jpg
|
/data/attachment/album/201802/24/210910ry1c2pcv4vssm6sm.jpg
| true | false | true |
amwps290
| false |
[
"Office"
] |
分享
|
{
"viewnum": 51115,
"commentnum": 5,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.35.18.234",
"message": "其实，WPS OFFICE也是不错的办公软件，它不但支持MS OFFICE的功能，兼容文件同时它还符合中国人的习惯，我觉得应该算上WPS。",
"username": "来自山东潍坊的 Firefox 66.0|Ubuntu 用户",
"date": "2019-05-06T16:16:32"
},
{
"postip": "222.216.94.138",
"message": "译文吧，连WPS都不知道",
"username": "来自广西南宁的 Chrome 87.0|Mac 10.14 用户",
"date": "2020-12-17T12:45:57"
},
{
"postip": "122.190.208.102",
"message": "注意审题，开源，wps不开源",
"username": "来自湖北武汉的 Chrome 87.0|Windows 10 用户",
"date": "2020-12-27T13:11:24"
},
{
"postip": "1.56.213.191",
"message": "wps不开源",
"username": "来自黑龙江牡丹江的 Firefox 78.0|GNU/Linux 用户",
"date": "2021-02-08T20:16:30"
},
{
"postip": "36.142.159.242",
"message": "WPS其实可以做得更好。虽然不支持MS OFFICE的很多功能是个遗憾，但WPS本可以另辟蹊径，通过支持大量的第三方插件或某编程工具，让自己变的比MS OFFICE更强大，但WPS的开发者似乎自始就抱着打酱油的态度，一方面喊着国产-安全的口号，另一方面却只把目光盯在云、H5等并不常用的功能上，忽视了让WPS练基本功。长此以往，WPS将一直在专业办公软件的边缘当小三，无法扶正。",
"username": "来自36.142.159.242的 Chrome 86.0|Windows 10 用户",
"date": "2021-08-16T19:33:59"
}
] |
[] |
还在 Linux 中寻找 Microsoft Office 吗? 这里有一些最好的在 Linux 平台下替代 Microsoft Office 的开源软件。
| 2018-02-24T21:09:00 | 2018-02-24T21:09:00 | 9,379 |
/article-9379-1.html
|
>
> 概要：还在 Linux 中寻找 Microsoft Office 吗? 这里有一些最好的在 Linux 平台下替代 Microsoft Office 的开源软件。
>
>
>
办公套件是任何操作系统的必备品。很难想象没有 Office 软件的桌面操作系统。虽然 Windows 有 MS Office 套件，Mac OS X 也有它自己的 iWork，但其他很多办公套件都是专门针对这些操作系统的，Linux 也有自己的办公套件。
在本文中，我会列举一些在 Linux 平台替代 Microsoft Office 的办公软件。
### Linux 最好的 MS Office 开源替代软件
在我们看 MS Office 的替代软件之前，我们先来看看在一个像样的办公套件中有一些什么:
* 文字处理器
* 电子表格
* 演示功能
我知道 Microsoft Office 提供了比上述三种工具更多的工具，但事实上，您主要使用这三个工具。开源办公套件并不限于只有这三种产品。其中有一些套件提供了一些额外的工具，但我们的重点将放在上述工具上。
让我们看看在 Linux 上有什么办公套件:
#### 6. Apache OpenOffice
[Apache OpenOffice](http://www.openoffice.org/) 或简单的称为 OpenOffice 有一段名称/所有者变更的历史。 它于 1999 年由 Sun Microsystems 公司开发，后来改名为 OpenOffice，将它作为一个与 MS Office 对抗的自由开源的替代软件。 当 Oracle 在 2010 年收购 Sun 公司后，一年之后便停止开发 OpenOffice。 最后是 Apache 支持它，现在被称为 Apache OpenOffice。
Apache OpenOffice 可用于多种平台，包括 Linux、Windows、Mac OS X、Unix、BSD。 除了 OpenDocument 格式外，它还支持 MS Office 文件。 办公套件包含以下应用程序：Writer、Calc、Impress、Base、Draw、Math。
安装 OpenOffice 是一件痛苦的事，因为它没有提供一个友好的安装程序。另外，有传言说 OpenOffice 开发可能已经停滞。 这是我不推荐的两个主要原因。 出于历史目的，我在这里列出它。
#### 5. Feng Office
[Feng Office](http://www.fengoffice.com/web/index.php?lang=en) 以前被称为 OpenGoo。 这不是一个常规的办公套件。 它完全专注于在线办公，如 Google 文档一样。 换句话说，这是一个开源[协作平台](https://en.wikipedia.org/wiki/Collaborative_software)。
Feng Office 不支持桌面使用，因此如果您想在单个 Linux 桌面上使用它，这个可能无法实现。 另一方面，如果你有一个小企业、一个机构或其他组织，你可以尝试将其部署在本地服务器上。
#### 4. Siag Office
[Siag](http://siag.nu/) 是一个非常轻量级的办公套件，适用于类 Unix 系统，可以在 16MB 的系统上运行。 由于它非常轻便，因此缺少标准办公套件中的许多功能。 但小即是美，不是吗？ 它具有办公套件的所有必要功能，可以在[轻量级 Linux 发行版](https://itsfoss.com/lightweight-linux-beginners/)上“正常工作”。它是 [Damn Small Linux](http://www.damnsmalllinux.org/) 默认安装软件。（LCTT 译注：根据官网，现已不是默认安装软件）
#### 3. Calligra Suite
[Calligra](http://www.calligra.org/)，以前被称为 KOffice，是 KDE 中默认的 Office 套件。 它支持 Mac OS X、Windows、Linux、FreeBSD 系统。 它也曾经推出 Android 版本。 但不幸的是，后续没有继续支持 Android。 它拥有办公套件所需的必要应用程序以及一些额外的应用程序，如用于绘制流程图的 Flow 和用于项目管理的 Plane。
Calligra 最近的发展产生了相当大的影响，很有可能成为 [LibreOffice 的替代品](http://maketecheasier.com/is-calligra-a-great-alternative-to-libreoffice/2012/06/18)。
#### 2. ONLYOFFICE
[ONLYOFFICE](https://www.onlyoffice.com/) 是办公套件市场上的新玩家，它更专注于协作部分。 企业（甚至个人）可以将其部署到自己的服务器上，以获得类似 Google Docs 之类的协作办公套件。
别担心，您不是必须将其安装在服务器上。有一个免费的开源[桌面版本](https://itsfoss.com/review-onlyoffice-desktop-editors-linux/) ONLYOFFICE。 您甚至可以获取 .deb 和 .rpm 二进制文件，以便将其安装在 Linux 桌面系统上。
#### 1. LibreOffice
当 Oracle 决定停止 OpenOffice 的开发时，是[文档基金会](http://www.documentfoundation.org/)将其复制分发，这就是我们所熟知的 [Libre-Office](http://www.libreoffice.org/)。从那时起，许多 Linux 发行版都将 OpenOffice 替换为 LibreOffice 作为它们的默认办公应用程序。
它适用于 Linux，Windows 和 Mac OS X，这使得在跨平台环境中易于使用。 和 Apache OpenOffice 一样，这也包括了除了 OpenDocument 格式以外的对 MS Office 文件的支持。 它还包含与 Apache OpenOffice 相同的应用程序。
您还可以使用 LibreOffice 作为 [Collabora Online](https://www.collaboraoffice.com/collabora-online/) 的协作平台。 基本上，LibreOffice 是一个完整的软件包，无疑是 Linux、Windows 和 MacOS 的**最佳 Microsoft Office 替代品**。
### 你认为呢？
我希望 Microsoft Office 的这些开源替代软件可以节省您的资金。 您会使用哪种开源生产力办公套件？
---
via: <https://itsfoss.com/best-free-open-source-alternatives-microsoft-office/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 lftp 来加速 ftp/https 下载速度
|
Vivek Gite
|
https://www.cyberciti.biz/tips/linux-unix-download-accelerator.html
|
lftp 是一个文件传输程序。它可以用于复杂的 FTP、 HTTP/HTTPS 和其他连接。
|
/data/attachment/album/201802/24/212144zq1cldcoqrcl1eqe.jpg.thumb.jpg
|
/data/attachment/album/201802/24/212144zq1cldcoqrcl1eqe.jpg
| true | false | true |
geekpi
| false |
[
"lftp"
] |
技术
|
{
"viewnum": 6350,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
lftp 是一个文件传输程序。它可以用于复杂的 FTP、 HTTP/HTTPS 和其他连接。
| 2018-02-26T09:11:00 | 2018-02-26T09:11:00 | 9,380 |
/article-9380-1.html
|
`lftp` 是一个文件传输程序。它可以用于复杂的 FTP、 HTTP/HTTPS 和其他连接。如果指定了站点 URL，那么 `lftp` 将连接到该站点，否则会使用 `open` 命令建立连接。它是所有 Linux/Unix 命令行用户的必备工具。我目前写了一些关于 [Linux 下超快命令行下载加速器](https://www.cyberciti.biz/tips/download-accelerator-for-linux-command-line-tools.html)，比如 Axel 和 prozilla。`lftp` 是另一个能做相同的事，但有更多功能的工具。`lftp` 可以处理几种文件访问方式：
1. ftp
2. ftps
3. http
4. https
5. hftp
6. fish
7. sftp
8. file
### 那么 lftp 的独特之处是什么？
* `lftp` 中的每个操作都是可靠的，即任何非致命错误都被忽略，并且重复进行操作。所以如果下载中断，它会自动重新启动。即使 FTP 服务器不支持 `REST` 命令，lftp 也会尝试从开头检索文件，直到文件传输完成。
* `lftp` 具有类似 shell 的命令语法，允许你在后台并行启动多个命令。
* `lftp` 有一个内置的镜像功能，可以下载或更新整个目录树。还有一个反向镜像功能（`mirror -R`），它可以上传或更新服务器上的目录树。镜像也可以在两个远程服务器之间同步目录，如果可用的话会使用 FXP。
### 如何使用 lftp 作为下载加速器
`lftp` 有 `pget` 命令。它能让你并行下载。语法是：
```
lftp -e 'pget -n NUM -c url; exit'
```
例如，使用 `pget` 分 5个部分下载 <http://kernel.org/pub/linux/kernel/v2.6/linux-2.6.22.2.tar.bz2>：
```
$ cd /tmp
$ lftp -e 'pget -n 5 -c http://kernel.org/pub/linux/kernel/v2.6/linux-2.6.22.2.tar.bz2'
```
示例输出：
```
45108964 bytes transferred in 57 seconds (775.3K/s)
lftp :~>quit
```
这里：
1. `pget` - 并行下载文件
2. `-n 5` - 将最大连接数设置为 5
3. `-c` - 如果当前目录存在 `lfile.lftp-pget-status`，则继续中断的传输
### 如何在 Linux/Unix 中使用 lftp 来加速 ftp/https下载
再尝试添加 `exit` 命令：
```
$ lftp -e 'pget -n 10 -c https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.15.tar.xz; exit'
```
### 关于并行下载的说明
请注意，通过使用下载加速器，你将增加远程服务器负载。另请注意，`lftp` 可能无法在不支持多点下载的站点上工作，或者防火墙阻止了此类请求。
其它的命令提供了更多功能。有关更多信息，请参考 [lftp](https://lftp.yar.ru/) 的 man 页面：
```
man lftp
```
### 关于作者
作者是 nixCraft 的创建者，经验丰富的系统管理员，也是 Linux 操作系统/Unix shell 脚本的培训师。他曾与全球客户以及IT、教育、国防和太空研究以及非营利部门等多个行业合作。在 [Twitter][9]、[Facebook][10]、[Google +][11] 上关注他。通过 [RSS/XML 订阅](https://plus.google.com/+CybercitiBiz)获取最新的系统管理、Linux/Unix 以及开源主题教程。
---
via: <https://www.cyberciti.biz/tips/linux-unix-download-accelerator.html>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 cloud-init 来预配置 LXD 容器
|
Simos Xenitellis
|
https://blog.simos.info/how-to-preconfigure-lxd-containers-with-cloud-init/
|
当你正在创建 LXD 容器的时候，你希望它们能被预先配置好。例如在容器一启动就自动执行 apt update来安装一些软件包，或者运行一些命令。
|
/data/attachment/album/201802/24/212520cj6y0lj9jj49nvz4.jpg.thumb.jpg
|
/data/attachment/album/201802/24/212520cj6y0lj9jj49nvz4.jpg
| true | false | true |
kaneg
| false |
[
"LXD",
"容器"
] |
容器与云
|
{
"viewnum": 4021,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
当你正在创建 LXD 容器的时候，你希望它们能被预先配置好。例如在容器一启动就自动执行 apt update来安装一些软件包，或者运行一些命令。
| 2018-02-24T21:25:37 | 2018-02-24T21:25:37 | 9,381 |
/article-9381-1.html
|
当你正在创建 LXD 容器的时候，你希望它们能被预先配置好。例如在容器一启动就自动执行 `apt update`来安装一些软件包，或者运行一些命令。
这篇文章将讲述如何用 [cloud-init](http://cloudinit.readthedocs.io/en/latest/index.html) 来对 [LXD 容器进行进行早期初始化](https://github.com/lxc/lxd/blob/master/doc/cloud-init.md)。
接下来，我们将创建一个包含cloud-init指令的LXD profile，然后启动一个新的容器来使用这个profile。
### 如何创建一个新的 LXD profile
查看已经存在的 profile：
```
$ lxc profile list
+---------|---------+
| NAME | USED BY |
+---------|---------+
| default | 11 |
+---------|---------+
```
我们把名叫 `default` 的 profile 复制一份，然后在其内添加新的指令：
```
$ lxc profile copy default devprofile
$ lxc profile list
+------------|---------+
| NAME | USED BY |
+------------|---------+
| default | 11 |
+------------|---------+
| devprofile | 0 |
+------------|---------+
```
我们就得到了一个新的 profile： `devprofile`。下面是它的详情：
```
$ lxc profile show devprofile
config:
environment.TZ: ""
description: Default LXD profile
devices:
eth0:
nictype: bridged
parent: lxdbr0
type: nic
root:
path: /
pool: default
type: disk
name: devprofile
used_by: []
```
注意这几个部分： `config:` 、 `description:` 、 `devices:` 、 `name:` 和 `used_by:`，当你修改这些内容的时候注意不要搞错缩进。（LCTT 译注：因为这些内容是 YAML 格式的，缩进是语法的一部分）
### 如何把 cloud-init 添加到 LXD profile 里
[cloud-init](http://cloudinit.readthedocs.io/en/latest/index.html) 可以添加到 LXD profile 的 `config` 里。当这些指令将被传递给容器后，会在容器第一次启动的时候执行。
下面是用在示例中的指令：
```
package_upgrade: true
packages:
- build-essential
locale: es_ES.UTF-8
timezone: Europe/Madrid
runcmd:
- [touch, /tmp/simos_was_here]
```
`package_upgrade: true` 是指当容器第一次被启动时，我们想要 `cloud-init` 运行 `sudo apt upgrade`。`packages:` 列出了我们想要自动安装的软件。然后我们设置了 `locale` 和 `timezone`。在 Ubuntu 容器的镜像里，root 用户默认的 `locale` 是 `C.UTF-8`，而 `ubuntu` 用户则是 `en_US.UTF-8`。此外，我们把时区设置为 `Etc/UTC`。最后，我们展示了[如何使用 runcmd 来运行一个 Unix 命令](http://cloudinit.readthedocs.io/en/latest/topics/modules.html#runcmd)。
我们需要关注如何将 `cloud-init` 指令插入 LXD profile。
我首选的方法是：
```
$ lxc profile edit devprofile
```
它会打开一个文本编辑器，以便你将指令粘贴进去。[结果应该是这样的](https://paste.ubuntu.com/26313399/)：
```
$ lxc profile show devprofile
config:
environment.TZ: ""
user.user-data: |
#cloud-config
package_upgrade: true
packages:
- build-essential
locale: es_ES.UTF-8
timezone: Europe/Madrid
runcmd:
- [touch, /tmp/simos_was_here]
description: Default LXD profile
devices:
eth0:
nictype: bridged
parent: lxdbr0
type: nic
root:
path: /
pool: default
type: disk
name: devprofile
used_by: []
```
### 如何使用 LXD profile 启动一个容器
使用 profile `devprofile` 来启动一个新容器：
```
$ lxc launch --profile devprofile ubuntu:x mydev
```
然后访问该容器来查看我们的指令是否生效：
```
$ lxc exec mydev bash
root@mydev:~# ps ax
PID TTY STAT TIME COMMAND
1 ? Ss 0:00 /sbin/init
...
427 ? Ss 0:00 /usr/bin/python3 /usr/bin/cloud-init modules --mode=f
430 ? S 0:00 /bin/sh -c tee -a /var/log/cloud-init-output.log
431 ? S 0:00 tee -a /var/log/cloud-init-output.log
432 ? S 0:00 /usr/bin/apt-get --option=Dpkg::Options::=--force-con
437 ? S 0:00 /usr/lib/apt/methods/http
438 ? S 0:00 /usr/lib/apt/methods/http
440 ? S 0:00 /usr/lib/apt/methods/gpgv
570 ? Ss 0:00 bash
624 ? S 0:00 /usr/lib/apt/methods/store
625 ? R+ 0:00 ps ax
root@mydev:~#
```
如果我们连接得够快，通过 `ps ax` 将能够看到系统正在更新软件。我们可以从 `/var/log/cloud-init-output.log` 看到完整的日志：
```
Generating locales (this might take a while)...
es_ES.UTF-8... done
Generation complete.
```
以上可以看出 `locale` 已经被更改了。root 用户还是保持默认的 `C.UTF-8`，只有非 root 用户 `ubuntu` 使用了新的`locale` 设置。
```
Hit:1 http://archive.ubuntu.com/ubuntu xenial InRelease
Get:2 http://archive.ubuntu.com/ubuntu xenial-updates InRelease [102 kB]
Get:3 http://security.ubuntu.com/ubuntu xenial-security InRelease [102 kB]
```
以上是安装软件包之前执行的 `apt update`。
```
The following packages will be upgraded:
libdrm2 libseccomp2 squashfs-tools unattended-upgrades
4 upgraded, 1 newly installed, 0 to remove and 0 not upgraded.
Need to get 211 kB of archives.
```
以上是在执行 `package_upgrade: true` 和安装软件包。
```
The following NEW packages will be installed:
binutils build-essential cpp cpp-5 dpkg-dev fakeroot g++ g++-5 gcc gcc-5
libalgorithm-diff-perl libalgorithm-diff-xs-perl libalgorithm-merge-perl
```
以上是我们安装 `build-essential` 软件包的指令。
`runcmd` 执行的结果如何？
```
root@mydev:~# ls -l /tmp/
total 1
-rw-r--r-- 1 root root 0 Jan 3 15:23 simos_was_here
root@mydev:~#
```
可见它已经生效了！
### 结论
当我们启动 LXD 容器的时候，我们常常需要默认启用一些配置，并且希望能够避免重复工作。通常解决这个问题的方法是创建 LXD profile，然后把需要的配置添加进去。最后，当我们启动新的容器时，只需要应用该 LXD profile 即可。
---
via: <https://blog.simos.info/how-to-preconfigure-lxd-containers-with-cloud-init/>
作者：[Simos Xenitellis](https://blog.simos.info/author/simos/) 译者：[kaneg](https://github.com/kaneg) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Python 中最快解压 zip 文件的方法
|
Peterbe
|
https://www.peterbe.com/plog/fastest-way-to-unzip-a-zip-file-in-python
|
一步一步地做这个任务的这个过程感觉挺好的。
|
/data/attachment/album/201802/24/213511kqgmemzlqmcbw15n.jpg.thumb.jpg
|
/data/attachment/album/201802/24/213511kqgmemzlqmcbw15n.jpg
| true | false | true |
leemeans
| false |
[
"zip"
] |
软件开发
|
{
"viewnum": 6162,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一步一步地做这个任务的这个过程感觉挺好的。
| 2018-02-28T09:27:00 | 2018-02-28T09:27:00 | 9,382 |
/article-9382-1.html
|
假设现在的上下文（LCTT 译注：context，计算机术语，此处意为业务情景）是这样的：一个 zip 文件被上传到一个[Web 服务](https://symbols.mozilla.org)中，然后 Python 需要解压这个 zip 文件然后分析和处理其中的每个文件。这个特殊的应用查看每个文件各自的名称和大小，并和已经上传到 AWS S3 上的文件进行比较，如果文件（和 AWS S3 上的相比）有所不同或者文件本身更新，那么就将它上传到 AWS S3。
[](https://cdn-2916.kxcdn.com/cache/e6/dc/e6dc20acd37d94239edbbc0727721e4a.png)
挑战在于这些 zip 文件太大了。它们的平均大小是 560MB 但是其中一些大于 1GB。这些文件中大多数是文本文件，但是其中同样也有一些巨大的二进制文件。不同寻常的是，每个 zip 文件包含 100 个文件但是其中 1-3 个文件却占据了多达 95% 的 zip 文件大小。
最开始我尝试在内存中解压文件，并且每次只处理一个文件。在各种内存爆炸和 EC2 耗尽内存的情况下，这个方法壮烈失败了。我觉得这个原因是这样的。最开始你有 1GB 文件在内存中，然后你现在解压每个文件，在内存中大约就要占用 2-3GB。所以，在很多次测试之后，解决方案是将这些 zip 文件复制到磁盘上（在临时目录 `/tmp` 中），然后遍历这些文件。这次情况好多了但是我仍然注意到了整个解压过程花费了巨量的时间。**是否可能有方法优化呢？**
### 原始函数
首先是下面这些模拟对 zip 文件中文件实际操作的普通函数：
```
def _count_file(fn):
with open(fn, 'rb') as f:
return _count_file_object(f)
def _count_file_object(f):
# Note that this iterates on 'f'.
# You *could* do 'return len(f.read())'
# which would be faster but potentially memory
# inefficient and unrealistic in terms of this
# benchmark experiment.
total = 0
for line in f:
total += len(line)
return total
```
这里是可能最简单的另一个函数：
```
def f1(fn, dest):
with open(fn, 'rb') as f:
zf = zipfile.ZipFile(f)
zf.extractall(dest)
total = 0
for root, dirs, files in os.walk(dest):
for file_ in files:
fn = os.path.join(root, file_)
total += _count_file(fn)
return total
```
如果我更仔细地分析一下，我将会发现这个函数花费时间 40% 运行 `extractall`，60% 的时间在遍历各个文件并读取其长度。
### 第一步尝试
我的第一步尝试是使用线程。先创建一个 `zipfile.ZipFile` 的实例，展开其中的每个文件名，然后为每一个文件开始一个线程。每个线程都给它一个函数来做“实质工作”（在这个基准测试中，就是遍历每个文件然后获取它的名称）。实际业务中的函数进行的工作是复杂的 S3、Redis 和 PostgreSQL 操作，但是在我的基准测试中我只需要制作一个可以找出文件长度的函数就好了。线程池函数：
```
def f2(fn, dest):
def unzip_member(zf, member, dest):
zf.extract(member, dest)
fn = os.path.join(dest, member.filename)
return _count_file(fn)
with open(fn, 'rb') as f:
zf = zipfile.ZipFile(f)
futures = []
with concurrent.futures.ThreadPoolExecutor() as executor:
for member in zf.infolist():
futures.append(
executor.submit(
unzip_member,
zf,
member,
dest,
)
)
total = 0
for future in concurrent.futures.as_completed(futures):
total += future.result()
return total
```
**结果：加速 ~10%**
### 第二步尝试
所以可能是 GIL（LCTT 译注：Global Interpreter Lock，一种全局锁，CPython 中的一个概念）阻碍了我。最自然的想法是尝试使用多线程在多个 CPU 上分配工作。但是这样做有缺点，那就是你不能传递一个非可 pickle 序列化的对象（LCTT 译注：意为只有可 pickle 序列化的对象可以被传递），所以你只能发送文件名到之后的函数中：
```
def unzip_member_f3(zip_filepath, filename, dest):
with open(zip_filepath, 'rb') as f:
zf = zipfile.ZipFile(f)
zf.extract(filename, dest)
fn = os.path.join(dest, filename)
return _count_file(fn)
def f3(fn, dest):
with open(fn, 'rb') as f:
zf = zipfile.ZipFile(f)
futures = []
with concurrent.futures.ProcessPoolExecutor() as executor:
for member in zf.infolist():
futures.append(
executor.submit(
unzip_member_f3,
fn,
member.filename,
dest,
)
)
total = 0
for future in concurrent.futures.as_completed(futures):
total += future.result()
return total
```
**结果: 加速 ~300%**
### 这是作弊
使用处理器池的问题是这样需要存储在磁盘上的原始 `.zip` 文件。所以为了在我的 web 服务器上使用这个解决方案，我首先得要将内存中的 zip 文件保存到磁盘，然后调用这个函数。这样做的代价我不是很清楚但是应该不低。
好吧，再翻翻看又没有损失。可能，解压过程加速到足以弥补这样做的损失了吧。
但是一定记住！这个优化取决于使用所有可用的 CPU。如果一些其它的 CPU 需要执行在 `gunicorn` 中的其它事务呢？这时，这些其它进程必须等待，直到有 CPU 可用。由于在这个服务器上有其他的事务正在进行，我不是很确定我想要在进程中接管所有其他 CPU。
### 结论
一步一步地做这个任务的这个过程感觉挺好的。你被限制在一个 CPU 上但是表现仍然特别好。同样地，一定要看看在`f1` 和 `f2` 两段代码之间的不同之处！利用 `concurrent.futures` 池类你可以获取到允许使用的 CPU 的个数，但是这样做同样给人感觉不是很好。如果你在虚拟环境中获取的个数是错的呢？或者可用的个数太低以致无法从负载分配获取好处并且现在你仅仅是为了移动负载而支付营运开支呢？
我将会继续使用 `zipfile.ZipFile(file_buffer).extractall(temp_dir)`。这个工作这样做已经足够好了。
### 想试试手吗？
我使用一个 `c5.4xlarge` EC2 服务器来进行我的基准测试。文件可以从此处下载：
```
wget https://www.peterbe.com/unzip-in-parallel/hack.unzip-in-parallel.py
wget https://www.peterbe.com/unzip-in-parallel/symbols-2017-11-27T14_15_30.zip
```
这里的 `.zip` 文件有 34MB。和在服务器上的相比已经小了很多。
`hack.unzip-in-parallel.py` 文件里是一团糟。它包含了大量可怕的修正和丑陋的代码，但是这只是一个开始。
---
via: <https://www.peterbe.com/plog/fastest-way-to-unzip-a-zip-file-in-python>
作者：[Peterbe](https://www.peterbe.com/) 译者：[Leemeans](https://github.com/leemeans) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
通过 ncurses 在终端创建一个冒险游戏
|
Jim Hall
|
http://www.linuxjournal.com/content/creating-adventure-game-terminal-ncurses
|
怎样使用 curses 函数读取键盘并操作屏幕。
|
/data/attachment/album/201802/25/100828w9xu9oaiyptt8oah.jpg.thumb.jpg
|
/data/attachment/album/201802/25/100828w9xu9oaiyptt8oah.jpg
| true | false | true |
leemeans
| false |
[
"ncurses"
] |
软件开发
|
{
"viewnum": 6225,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9348,
"displayorder": 0
},
{
"raid": 9546,
"displayorder": 0
}
] |
怎样使用 curses 函数读取键盘并操作屏幕。
| 2018-02-25T09:38:00 | 2018-02-25T09:38:00 | 9,383 |
/article-9383-1.html
|
>
> 怎样使用 curses 函数读取键盘并操作屏幕。
>
>
>
我[之前的文章](/article-9348-1.html)介绍了 ncurses 库，并提供了一个简单的程序展示了一些将文本放到屏幕上的 curses 函数。在接下来的文章中，我将介绍如何使用其它的 curses 函数。
### 探险
当我逐渐长大，家里有了一台苹果 II 电脑。我和我兄弟正是在这台电脑上自学了如何用 AppleSoft BASIC 写程序。我在写了一些数学智力游戏之后，继续创造游戏。作为 80 年代的人，我已经是龙与地下城桌游的粉丝，在游戏中角色扮演一个追求打败怪物并在陌生土地上抢掠的战士或者男巫，所以我创建一个基本的冒险游戏也在情理之中。
AppleSoft BASIC 支持一种简洁的特性：在标准分辨率图形模式（GR 模式）下，你可以检测屏幕上特定点的颜色。这为创建一个冒险游戏提供了捷径。比起创建并更新周期性传送到屏幕的内存地图，我现在可以依赖 GR 模式为我维护地图，我的程序还可以在玩家的角色（LCTT 译注：此处 character 双关一个代表玩家的角色，同时也是一个字符）在屏幕四处移动的时候查询屏幕。通过这种方式，我让电脑完成了大部分艰难的工作。因此，我的自顶向下的冒险游戏使用了块状的 GR 模式图形来展示我的游戏地图。
我的冒险游戏使用了一张简单的地图，上面有一大片绿地伴着山脉从中间蔓延向下和一个在左上方的大湖。我要粗略地为桌游战役绘制这个地图，其中包含一个允许玩家穿过到远处的狭窄通道。
*图 1. 一个有湖和山的简单桌游地图*
你可以用 curses 绘制这个地图，并用字符代表草地、山脉和水。接下来，我描述怎样使用 curses 那样做，以及如何在 Linux 终端创建和进行类似的一个冒险游戏。
### 构建程序
在我的上一篇文章，我提到了大多数 curses 程序以相同的一组指令获取终端类型和设置 curses 环境：
```
initscr();
cbreak();
noecho();
```
在这个程序，我添加了另外的语句：
```
keypad(stdscr, TRUE);
```
这里的 `TRUE` 标志允许 curses 从用户终端读取小键盘和功能键。如果你想要在你的程序中使用上下左右方向键，你需要使用这里的 `keypad(stdscr, TRUE)`。
这样做了之后，你现在可以开始在终端屏幕上绘图了。curses 函数包括了一系列在屏幕上绘制文本的方法。在我之前的文章中，我展示了 `addch()` 和 `addstr()` 函数以及在添加文本之前先移动到指定屏幕位置的对应函数 `mvaddch()` 和 `mvaddstr()`。为了在终端上创建这个冒险游戏的地图，你可以使用另外一组函数：`vline()` 和 `hline()`，以及它们对应的函数 `mvvline()` 和 `mvhline()`。这些 mv 函数接受屏幕坐标、一个要绘制的字符和要重复此字符的次数的参数。例如，`mvhline(1, 2, '-', 20)` 将会绘制一条开始于第一行第二列并由 20 个横线组成的线段。
为了以编程方式绘制地图到终端屏幕上，让我们先定义这个 `draw_map()` 函数：
```
#define GRASS ' '
#define EMPTY '.'
#define WATER '~'
#define MOUNTAIN '^'
#define PLAYER '*'
void draw_map(void)
{
int y, x;
/* 绘制探索地图 */
/* 背景 */
for (y = 0; y < LINES; y++) {
mvhline(y, 0, GRASS, COLS);
}
/* 山和山道 */
for (x = COLS / 2; x < COLS * 3 / 4; x++) {
mvvline(0, x, MOUNTAIN, LINES);
}
mvhline(LINES / 4, 0, GRASS, COLS);
/* 湖 */
for (y = 1; y < LINES / 2; y++) {
mvhline(y, 1, WATER, COLS / 3);
}
}
```
在绘制这副地图时，记住填充大块字符到屏幕所使用的 `mvvline()` 和 `mvhline()` 函数。我绘制从 0 列开始的字符水平线（`mvhline`）以创建草地区域，直到占满整个屏幕的高度和宽度。我绘制从 0 行开始的多条垂直线（`mvvline`）在此上添加了山脉，绘制单行水平线添加了一条山道（`mvhline`）。并且，我通过绘制一系列短水平线（`mvhline`）创建了湖。这种绘制重叠方块的方式看起来似乎并没有效率，但是记住在我们调用 `refresh()` 函数之前 curses 并不会真正更新屏幕。
绘制完地图，创建游戏就还剩下进入循环让程序等待用户按下上下左右方向键中的一个然后让玩家图标正确移动了。如果玩家想要移动的地方是空的，就应该允许玩家到那里。
你可以把 curses 当做捷径使用。比起在程序中实例化一个版本的地图并复制到屏幕这么复杂，你可以让屏幕为你跟踪所有东西。`inch()` 函数和相关联的 `mvinch()` 函数允许你探测屏幕的内容。这让你可以查询 curses 以了解玩家想要移动到的位置是否被水填满或者被山阻挡。这样做你需要一个之后会用到的一个帮助函数：
```
int is_move_okay(int y, int x)
{
int testch;
/* 如果要进入的位置可以进入，返回 true */
testch = mvinch(y, x);
return ((testch == GRASS) || (testch == EMPTY));
}
```
如你所见，这个函数探测行 `x`、列 `y` 并在空间未被占据的时候返回 `true`，否则返回 `false`。
这样我们写移动循环就很容易了：从键盘获取一个键值然后根据是上下左右键移动用户字符。这里是一个这种循环的简单版本：
```
do {
ch = getch();
/* 测试输入的值并获取方向 */
switch (ch) {
case KEY_UP:
if ((y > 0) && is_move_okay(y - 1, x)) {
y = y - 1;
}
break;
case KEY_DOWN:
if ((y < LINES - 1) && is_move_okay(y + 1, x)) {
y = y + 1;
}
break;
case KEY_LEFT:
if ((x > 0) && is_move_okay(y, x - 1)) {
x = x - 1;
}
break;
case KEY_RIGHT
if ((x < COLS - 1) && is_move_okay(y, x + 1)) {
x = x + 1;
}
break;
}
}
while (1);
```
为了在游戏中使用这个循环，你需要在循环里添加一些代码来启用其它的键（例如传统的移动键 WASD），以提供让用户退出游戏和在屏幕上四处移动的方法。这里是完整的程序：
```
/* quest.c */
#include
#include
#define GRASS ' '
#define EMPTY '.'
#define WATER '~'
#define MOUNTAIN '^'
#define PLAYER '*'
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();
clear();
/* 初始化探索地图 */
draw_map();
/* 在左下角初始化玩家 */
y = LINES - 1;
x = 0;
do {
/* 默认获得一个闪烁的光标--表示玩家字符 */
mvaddch(y, x, PLAYER);
move(y, x);
refresh();
ch = getch();
/* 测试输入的键并获取方向 */
switch (ch) {
case KEY_UP:
case 'w':
case 'W':
if ((y > 0) && is_move_okay(y - 1, x)) {
mvaddch(y, x, EMPTY);
y = y - 1;
}
break;
case KEY_DOWN:
case 's':
case 'S':
if ((y < LINES - 1) && is_move_okay(y + 1, x)) {
mvaddch(y, x, EMPTY);
y = y + 1;
}
break;
case KEY_LEFT:
case 'a':
case 'A':
if ((x > 0) && is_move_okay(y, x - 1)) {
mvaddch(y, x, EMPTY);
x = x - 1;
}
break;
case KEY_RIGHT:
case 'd':
case 'D':
if ((x < COLS - 1) && is_move_okay(y, x + 1)) {
mvaddch(y, x, EMPTY);
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 == GRASS) || (testch == EMPTY));
}
void draw_map(void)
{
int y, x;
/* 绘制探索地图 */
/* 背景 */
for (y = 0; y < LINES; y++) {
mvhline(y, 0, GRASS, COLS);
}
/* 山脉和山道 */
for (x = COLS / 2; x < COLS * 3 / 4; x++) {
mvvline(0, x, MOUNTAIN, LINES);
}
mvhline(LINES / 4, 0, GRASS, COLS);
/* 湖 */
for (y = 1; y < LINES / 2; y++) {
mvhline(y, 1, WATER, COLS / 3);
}
}
```
在完整的程序清单中，你可以看见使用 curses 函数创建游戏的完整布置：
1. 初始化 curses 环境。
2. 绘制地图。
3. 初始化玩家坐标（左下角）
4. 循环：
* 绘制玩家的角色。
* 从键盘获取键值。
* 对应地上下左右调整玩家坐标。
* 重复。
5. 完成时关闭curses环境并退出。
### 开始玩
当你运行游戏时，玩家的字符在左下角初始化。当玩家在游戏区域四处移动的时候，程序创建了“一串”点。这样可以展示玩家经过了的点，让玩家避免经过不必要的路径。
*图 2. 初始化在左下角的玩家*
*图 3. 玩家可以在游戏区域四处移动，例如湖周围和山的通道*
为了创建上面这样的完整冒险游戏，你可能需要在他/她的角色在游戏区域四处移动的时候随机创建不同的怪物。你也可以创建玩家可以发现在打败敌人后可以掠夺的特殊道具，这些道具应能提高玩家的能力。
但是作为起点，这是一个展示如何使用 curses 函数读取键盘和操纵屏幕的好程序。
### 下一步
这是一个如何使用 curses 函数更新和读取屏幕和键盘的简单例子。按照你的程序需要做什么，curses 可以做得更多。在下一篇文章中，我计划展示如何更新这个简单程序以使用颜色。同时，如果你想要学习更多 curses，我鼓励你去读位于 Linux 文档计划的 Pradeep Padala 写的[如何使用 NCURSES 编程](http://tldp.org/HOWTO/NCURSES-Programming-HOWTO)。
---
via: <http://www.linuxjournal.com/content/creating-adventure-game-terminal-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/) 荣誉推出
|
||
为初学者介绍 Linux whereis 命令（5个例子）
|
Himanshu Arora
|
https://www.howtoforge.com/linux-whereis-command/
|
有时，在使用命令行的时候，我们需要快速找到某一个命令的二进制文件所在位置。这种情况下可以选择 find 命令，但使用它会耗费时间，可能也会出现意料之外的情况。有一个专门为这种情况设计的命令：whereis。
|
/data/attachment/album/201802/25/132156q2n3h3be03tn33ax.jpg.thumb.jpg
|
/data/attachment/album/201802/25/132156q2n3h3be03tn33ax.jpg
| true | false | true |
wenwensnow
| false |
[
"whereis",
"find"
] |
技术
|
{
"viewnum": 8658,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
有时，在使用命令行的时候，我们需要快速找到某一个命令的二进制文件所在位置。这种情况下可以选择 find 命令，但使用它会耗费时间，可能也会出现意料之外的情况。有一个专门为这种情况设计的命令：whereis。
| 2018-02-25T13:22:09 | 2018-02-25T13:22:09 | 9,384 |
/article-9384-1.html
|
有时，在使用命令行的时候，我们需要快速找到某一个命令的二进制文件所在位置。这种情况下可以选择 [find](https://www.howtoforge.com/tutorial/linux-find-command/) 命令，但使用它会耗费时间，可能也会出现意料之外的情况。有一个专门为这种情况设计的命令：`whereis`。
在这篇文章里，我们会通过一些便于理解的例子来解释这一命令的基础内容。但在这之前，值得说明的一点是，下面出现的所有例子都在 Ubuntu 16.04 LTS 下测试过。
### Linux whereis 命令
`whereis` 命令可以帮助用户寻找某一命令的二进制文件，源码以及帮助页面。下面是它的格式：
```
whereis [options] [-BMS directory... -f] name...
```
这是这一命令的 man 页面给出的解释：
>
> `whereis` 可以查找指定命令的二进制文件、源文件和帮助文件。 被找到的文件在显示时，会去掉主路径名，然后再去掉文件的（单个）尾部扩展名 (如: `.c`)，来源于源代码控制的 `s.` 前缀也会被去掉。接下来，`whereis` 会尝试在标准的 Linux 位置里寻找具体程序，也会在由 `$PATH` 和 `$MANPATH` 指定的路径中寻找。
>
>
>
下面这些以 Q&A 形式出现的例子，可以给你一个关于如何使用 whereis 命令的直观感受。
### Q1. 如何用 whereis 命令寻找二进制文件所在位置?
假设你想找，比如说，`whereis` 命令自己所在位置。下面是你具体的操作：
```
whereis whereis
```
[](https://www.howtoforge.com/images/command-tutorial/big/whereis-basic-usage.png)
需要注意的是，输出的第一个路径才是你想要的结果。使用 `whereis` 命令，同时也会显示帮助页面和源码所在路径。（如果能找到的情况下会显示，但是在这一例中没有找到）所以你在输出中看见的第二个路径就是帮助页面文件所在位置。
### Q2. 怎么在搜索时规定只搜索二进制文件、帮助页面，还是源代码呢？
如果你想只搜索，假设说，二进制文件，你可以使用 `-b` 这一命令行选项。例如：
```
whereis -b cp
```
[](https://www.howtoforge.com/images/command-tutorial/big/whereis-b-option.png)
类似的， `-m` 和 `-s` 这两个 选项分别对应 帮助页面和源码。
### Q3.如何限制 whereis 命令搜索位置？
默认情况下，`whereis` 是从由匹配符所定义的硬编码路径来寻找文件的。但如果你想的话，你可以用命令行选项来限制搜索。例如，如果你只想在 `/usr/bin` 寻找二进制文件，你可以用 `-B` 这一选项来实现。
```
whereis -B /usr/bin/ -f cp
```
注意：使用这种方式时可以给出多个路径。使用 `-f` 这一选项来明确分隔目录列表和要搜索的文件名。
类似的，如果你想只搜索帮助文件或源码，你可以对应使用 `-M` 和 `-S` 这两个选项。
### Q4. 如何查看 whereis 的搜索路径?
与此相对应的也有一个选项。只要在 `whereis` 后加上 `-l`。
```
whereis -l
```
这是例子的部分输出结果：
[](https://www.howtoforge.com/images/command-tutorial/big/whereis-l.png)
### Q5. 如何找到一个有异常条目的命令?
对于 `whereis` 命令来说，如果一个命令对每个显式的请求类型都不止一项，则该命令被视为异常。例如，没有可用文档的命令，或者对应文档分散在各处的命令都可以算作异常命令。 当使用 `-u` 这一选项，`whereis` 就会显示那些有异常条目的命令。
例如，下面这一例子就显示，在当前目录中，没有对应文档或有多个文档的命令。
```
whereis -m -u *
```
### 总结
我觉得，`whereis` 不是那种你需要经常使用的命令行工具。但在遇到某些特殊情况时，它绝对会让你的生活变得轻松。我们已经涉及了这一工具提供的一些重要命令行选项，所以要注意练习。想了解更多信息，直接去看它的 [man](https://linux.die.net/man/1/whereis) 页面吧。
---
via: <https://www.howtoforge.com/linux-whereis-command/>
作者：[Himanshu Arora](https://www.howtoforge.com) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Opensource.com 的 2017 年最佳开源教程
|
Scott Nesbitt
|
https://opensource.com/article/18/1/best-tutorials
|
2017 年，Opensource.com 发布一些有关各种主题的优秀教程。这些教程不只是针对专家们的，它们是针对各种技能水平和经验的用户的。
|
/data/attachment/album/201802/26/122704kdfp9g9coq9fp227.png.thumb.jpg
|
/data/attachment/album/201802/26/122704kdfp9g9coq9fp227.png
| true | false | true |
zjon
| false |
[
"教程",
"开源"
] |
分享
|
{
"viewnum": 3931,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
2017 年，Opensource.com 发布一些有关各种主题的优秀教程。这些教程不只是针对专家们的，它们是针对各种技能水平和经验的用户的。
| 2018-02-26T12:27:00 | 2018-02-26T12:27:00 | 9,385 |
/article-9385-1.html
|
2017 年，Opensource.com 发布了一系列用于帮助从初学者到专家的教程。让我们看看哪些最好。
精心编写的教程对于任何软件的官方文档来说都是一个很好的补充。如果官方文件写得不好，不完整或根本没有，那么这些教程也可以是个有效的替代品。
2017 年，Opensource.com 发布一些有关各种主题的优秀教程。这些教程不只是针对专家们的，它们是针对各种技能水平和经验的用户的。
让我们来看看其中最好的教程。
### 关于代码
对许多人来说，他们第一次涉足开源是为一个项目或另一个项目贡献代码。你在哪里学习编码或编程的？以下两篇文章是很好的起点。
严格来说，VM Brasseur 的[如何开始学习编程](/article-8694-1.html)是新手程序员的一个很好的起点，而不是一个教程。它不仅指出了一些有助于你开始学习的优秀资源，而且还提供了了解你的学习方式和如何选择语言的重要建议。
如果您已经在一个 [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) 或文本编辑器中敲击了几个小时，那么您可能需要学习更多关于编码的不同方法。Fraser Tweedale 的[函数式编程简介](/article-8869-1.html)很好地介绍了可以应用到许多广泛使用的编程语言的范式。
### 踏足 Linux
Linux 是开源的典范。它运行了大量的 Web 站点，为世界顶级的超级计算机提供了动力。它让任何人都可以替代台式机上的专有操作系统。
如果你有兴趣深入 Linux，这里有三个教程供你参考。
Jason Baker 告诉你[设置 Linux $PATH 变量](https://opensource.com/article/17/6/set-path-linux)。他引导你掌握这一“任何 Linux 初学者的重要技巧”，使您能够告知系统包含了程序和脚本的目录。
感谢 David Both 的[建立一个 DNS 域名服务器](https://opensource.com/article/17/4/build-your-own-name-server)指南。他详细地记录了如何设置和运行服务器，包括要编辑的配置文件以及如何编辑它们。
想在你的电脑上更复古一点吗？Jim Hall 告诉你如何使用 [FreeDOS](http://www.freedos.org/)和 [qemu](https://www.qemu.org) [在 Linux 下运行 DOS 程序](/article-9014-1.html)。Hall 的文章着重于运行 DOS 生产力工具，但并不全是严肃的——他也谈到了运行他最喜欢的 DOS 游戏。
### 3 片（篇）树莓派
廉价的单板计算机使硬件再次变得有趣，这并不是秘密。不仅如此，它们使更多的人更容易接近，无论他们的年龄或技术水平如何。
其中，[树莓派](https://en.wikipedia.org/wiki/Raspberry_Pi)可能是最广泛使用的单板计算机。Ben Nuttall 带我们一起[在树莓派上安装和设置 Postgres 数据库](/article-9056-1.html)。这样，你可以在任何你想要的项目中使用它。
如果你的品味包括文学和技术，你可能会对 Don Watkins 的[如何将树莓派变成电子书服务器](/article-8684-1.html)感兴趣。稍微付出一点努力和一份 [Calibre 电子书管理软件](https://calibre-ebook.com/)副本，你就可以得到你最喜欢的电子书，无论你在哪里。
树莓派并不是其中唯一有特点的。还有 [Orange Pi Pc Plus](http://www.orangepi.org/)，这是一种开源的单板机。David Egts 告诉你[如何开始使用这个可编程的迷你电脑](/article-8308-1.html)。
### 日常的计算机使用
开源并不仅针对技术专家，更多的普通人用它来做日常工作，而且更加效率。这里有三篇文章，可以使我们这些笨手笨脚的人（你可能不是）做任何事情变得优雅。
当你想到微博客的时候，你可能会想到 Twitter。但是 Twitter 的问题很多。[Mastodon](https://joinmastodon.org/) 是 Twitter 的开放的替代方案，它在 2016 年首次亮相。从此， Mastodon 就获得相当大的用户基数。Seth Kenlon 说明[如何加入和使用 Mastodon](https://opensource.com/article/17/4/guide-to-mastodon)，甚至告诉你如何在 Mastodon 和 Twitter 间交替使用。
你需要一点帮助来维持开支吗？你所需要的只是一个电子表格和正确的模板。我关于[要控制你的财政状况](/article-8831-1.html)的文章，向你展示了如何用 [LibreOffice Calc](https://www.libreoffice.org/discover/calc/) （或任何其他电子表格编辑器）创建一个简单而有吸引力的财务跟踪。
ImageMagick 是强大的图形处理工具。但是，很多人不经常使用。这意味着他们在最需要它们时忘记了命令。如果你也是这样，Greg Pittman 的 [ImageMagick 入门教程](/article-8851-1.html)能在你需要一些帮助时候能派上用场。
你有最喜欢的 2017 Opensource.com 发布的教程吗？请随意留言与社区分享。
---
via: <https://opensource.com/article/18/1/best-tutorials>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 译者：[zjon](https://github.com/zjon) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
五个值得现在安装的火狐插件
|
Jeremy Garcia
|
https://opensource.com/article/18/1/top-5-firefox-extensions
|
合适的插件能大大增强你浏览器的功能，但仔细挑选插件很重要。本文有五个值得一看的插件。
|
/data/attachment/album/201802/26/232926k17f4y9owc1h5hwo.jpg.thumb.jpg
|
/data/attachment/album/201802/26/232926k17f4y9owc1h5hwo.jpg
| true | false | true |
ypingcn
| false |
[
"FireFox",
"插件"
] |
分享
|
{
"viewnum": 11575,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
合适的插件能大大增强你浏览器的功能，但仔细挑选插件很重要。本文有五个值得一看的插件。
| 2018-02-26T23:29:21 | 2018-02-26T23:29:21 | 9,386 |
/article-9386-1.html
|
>
> 合适的插件能大大增强你浏览器的功能，但仔细挑选插件很重要。本文有五个值得一看的插件。
>
>
>
对于很多用户来说，网页浏览器已经成为电脑使用体验的重要环节。现代浏览器已经发展成强大、可拓展的平台。作为平台的一部分，*插件*能添加或修改浏览器的功能。火狐插件的构建使用了 WebExtensions API ，这是一个跨浏览器的开发系统。
你应该安装哪一个插件？一般而言，这个问题的答案取决于你如何使用你的浏览器、你对于隐私的看法、你信任插件开发者多少以及其他个人喜好。
首先，我想指出浏览器插件通常需要读取和（或者）修改你浏览的网页上的每项内容。你应该*非常*仔细地考虑这件事的后果。如果一个插件有修改所有你访问过的网页的权限，那么它可能记录你的按键、拦截信用卡信息、在线跟踪你、插入广告，以及其他各种各样邪恶的行为。
并不是每个插件都偷偷摸摸地做这些事，但是在你安装任何插件之前，你要慎重考虑下插件安装来源、涉及的权限、你的风险数据和其他因素。记住，你可以从个人数据的角度来管理一个插件如何影响你的攻击面（ LCTT 译注：攻击面是指入侵者能尝试获取或提取数据的途径总和）——例如使用特定的配置、不使用插件来完成例如网上银行的操作。
考虑到这一点，这里有你或许想要考虑的五个火狐插件
### uBlock Origin
*ublock Origin 可以拦截广告和恶意网页，还允许用户定义自己的内容过滤器。*
[uBlock Origin](https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/) 是一款快速、内存占用低、适用范围广的拦截器，它不仅能屏蔽广告，还能让你执行你自己定制的内容过滤。uBlock Origin 默认使用多份预定义好的过滤名单来拦截广告、跟踪器和恶意网页。它允许你任意地添加列表和规则，或者锁定在一个默认拒绝的模式。除了强大之外，这个插件已被证明是效率高、性能好。
### Privacy Badger
*Privacy Badger 运用了算法来无缝地屏蔽侵犯用户准则的广告和跟踪器。*
正如它名字所表明，[Privacy Badger](https://www.eff.org/privacybadger) 是一款专注于隐私的插件，它屏蔽广告和第三方跟踪器。EFF （LCTT 译注：EFF 全称是<ruby> 电子前哨基金会 <rt> Electronic Frontier Foundation </rt></ruby>，旨在宣传互联网版权和监督执法机构）说：“我们想要推荐一款能自动分析并屏蔽任何侵犯用户准则的跟踪器和广告，而 Privacy Badger 诞生于此目的；它不用任何设置、知识或者用户的配置，就能运行得很好；它是由一个明显为用户服务而不是为广告主服务的组织出品；它使用算法来确定正在跟踪什么，而没有跟踪什么。”
为什么 Privacy Badger 出现在这列表上的原因跟 uBlock Origin 如此相似？其中一个原因是 Privacy Badger 从根本上跟 uBlock Origin 的工作不同。另一个原因是纵深防御的做法是个可以遵循的合理策略。
### LastPass
*LastPass 是一款用户友好的密码管理插件，支持双因子认证。*
这个插件对于很多人来说是个有争议的补充。你是否应该使用密码管理器——如果你用了，你是否应该选择一个浏览器插件——这都是个热议的话题，而答案取决于你的风险资料。我想说大部分不关心的电脑用户应该用一个，因为这比起常见的选择：每一处使用相同的弱密码，都好太多了。
[LastPass](https://addons.mozilla.org/en-US/firefox/addon/lastpass-password-manager/) 对于用户很友好，支持双因子认证，相当安全。这家公司过去出过点安全事故，但是都处理得当，而且资金充足。记住使用密码管理器不是非此即彼的命题。很多用户选择使用密码管理器管理绝大部分密码，但是保持了一点复杂性，为例如银行这样重要的网页采用了精心设计的密码和多因子认证。
### Xmarks Sync
[Xmarks Sync](https://addons.mozilla.org/en-US/firefox/addon/xmarks-sync/) 是一款方便的插件，能跨实例同步你的书签、打开的标签页、配置项和浏览器历史。如果你有多台机器，想要在桌面设备和移动设备之间同步、或者在同一台设备使用不同的浏览器，那来看看 Xmarks Sync 。（注意这款插件最近被 LastPass 收购）
### Awesome Screenshot Plus
[Awesome Screenshot Plus](https://addons.mozilla.org/en-US/firefox/addon/screenshot-capture-annotate/) 允许你很容易捕获任意网页的全部或部分区域，也能添加注释、评论、使敏感信息模糊等。你还能用一个可选的在线服务来分享图片。我发现这工具在网页调试时截图、讨论设计和分享信息上很棒。这是一款比你预期中发现自己使用得多的工具。
*Awesome Screenshot Plus 允许你容易地截下任何网页的部分或全部内容。*
我发现这五款插件有用，我把它们推荐给其他人。这就是说，还有很多浏览器插件。我很感兴趣社区用户们正在使用哪些插件，请在评论中让我知道。
---
via: <https://opensource.com/article/18/1/top-5-firefox-extensions>
作者：[Jeremy Garcia](https://opensource.com/users/jeremy-garcia) 译者：[ypingcn](https://github.com/ypingcn) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Intel 设计缺陷背后的原因是什么？
|
Peter Bright
|
https://arstechnica.com/gadgets/2018/01/whats-behind-the-intel-design-flaw-forcing-numerous-patches/
|
我们知道有问题，但是并不知道问题的详细情况。
|
/data/attachment/album/201802/26/235324a324tj1htn23dpw2.jpg.thumb.jpg
|
/data/attachment/album/201802/26/235324a324tj1htn23dpw2.jpg
| true | false | true |
qhwdw
| false |
[
"KPTI",
"Intel",
"CPU"
] |
技术
|
{
"viewnum": 5190,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们知道有问题，但是并不知道问题的详细情况。
| 2018-02-26T23:53:21 | 2018-02-26T23:53:21 | 9,387 |
/article-9387-1.html
|
>
> 我们知道有问题，但是并不知道问题的详细情况。
>
>
>
（本文发表于 1 月份）最近 Windows 和 Linux 都发送了重大安全更新，为防范这个尚未完全公开的问题，在最坏的情况下，它可能会导致性能下降多达一半。
在过去的几周，Linux 内核陆续打了几个补丁。Microsoft [自 11 月份开始也内部测试了 Windows 更新](https://twitter.com/aionescu/status/930412525111296000)，并且它预计在下周二的例行补丁中将这个改进推送到主流 Windows 构建版中。Microsoft 的 Azure 也在下周的维护窗口中做好了安排，而 Amazon 的 AWS 也安排在周五对相关的设施进行维护。
自从 Linux 第一个补丁 （参见 [KPTI：内核页表隔离的当前的发展](/article-9201-1.html)） 明确描绘了出现的错误以后。虽然 Linux 和 Windows 基于不同的考虑，对此持有不同的看法，但是这两个操作系统 —— 当然还有其它的 x86 操作系统，比如 FreeBSD 和 [macOS](https://twitter.com/aionescu/status/948609809540046849) — 对系统内存的处理采用了相同的方式，因为对于操作系统在这一部分特性是与底层的处理器高度耦合的。
### 保持地址跟踪
在一个系统中的每个内存字节都是隐性编码的，这些编码数字是每个字节的地址。早期的操作系统使用物理内存地址，但是，物理内存地址由于各种原因，它并不很合适。例如，在地址中经常会有空隙，并且（尤其是 32 位的系统上）物理地址很难操作，需要 36 位数字，甚至更多。
因此，现在操作系统完全依赖一个叫虚拟内存的概念。虚拟内存系统允许程序和内核一起在一个简单、清晰、统一的环境中各自去操作。而不是使用空隙和其它奇怪的东西的物理内存，每个程序和内核自身都使用虚拟地址去访问内存。这些虚拟地址是连续的 —— 不用担心有空隙 —— 并且合适的大小也更便于操作。32 位的程序仅可以看到 32 位的地址，而不用管物理地址是 36 位还是更多位。
虽然虚拟地址对每个软件几乎是透明的，但是，处理器最终还是需要知道虚拟地址引用的物理地址是哪个。因此，有一个虚拟地址到物理地址的映射，它保存在一个被称为页面表的数据结构中。操作系统构建页面表，使用一个由处理器决定的布局，并且处理器和操作系统在虚拟地址和物理地址之间进行转换时就需要用到页面表。
这个映射过程是非常重要的，它也是现代操作系统和处理器的重要基础，处理器有专用的缓存 — Translation Lookaside Buffer（简称 TLB）—— 它保存了一定数量的虚拟地址到物理地址的映射，这样就不需要每次都使用全部页面。
虚拟内存的使用为我们提供了很多除了简单寻址之外的有用的特性。其中最主要的是，每个程序都有了自己独立的一组虚拟地址，有了它自己的一组虚拟地址到物理地址的映射。这就是用于提供“内存保护”的关键技术，一个程序不能破坏或者篡改其它程序使用的内存，因为其它程序的内存并不在它的地址映射范围之内。
由于每个进程使用一个单独的映射，因此每个程序也就有了一个额外的页面表，这就使得 TLB 缓存很拥挤。TLB 并不大 —— 一般情况下总共可以容纳几百个映射 —— 而系统使用的页面表越多，TLB 能够包含的任何特定的虚拟地址到物理地址的映射就越少。
### 一半一半
为了更好地使用 TLB，每个主流的操作系统都将虚拟地址范围一分为二。一半用于程序；另一半用于内核。当进程切换时，仅有一半的页面表条目发生变化 —— 仅属于程序的那一半。内核的那一半是每个程序公用的（因为只有一个内核）并且因此它可以为每个进程使用相同的页面表映射。这对 TLB 的帮助非常大；虽然它仍然会丢弃属于进程的那一半内存地址映射；但是它还保持着另一半属于内核的映射。
这种设计并不是一成不变的。在 Linux 上做了一项工作，使它可以为一个 32 位的进程提供整个地址范围，而不用在内核页面表和每个进程之间共享。虽然这样为程序提供了更多的地址空间，但这是以牺牲性能为代价的，因为每次内核代码需要运行时，TLB 重新加载内核的页面表条目。因此，这种方法并没有广泛应用到 x86 的系统上。
在内核和每个程序之间分割虚拟地址的这种做法的一个负面影响是，内存保护被削弱了。如果内核有它自己的一组页面表和虚拟地址，它将在不同的程序之间提供相同的保护；内核内存将是简单的不可见。但是使用地址分割之后，用户程序和内核使用了相同的地址范围，并且从原理上来说，一个用户程序有可能去读写内核内存。
为避免这种明显不好的情况，处理器和虚拟地址系统有一个 “Ring” 或者 “模式”的概念。x86 处理器有许多 Ring，但是对于这个问题，仅有两个是相关的：“user” （Ring 3）和 “supervisor”（ring 0）。当运行普通的用户程序时，处理器将置为用户模式 （Ring 3）。当运行内核代码时，处理器将处于 Ring 0 —— supervisor 模式，也称为内核模式。
这些 Ring 也用于从用户程序中保护内核内存。页面表并不仅仅有虚拟地址到物理地址的映射；它也包含关于这些地址的元数据，包含哪个 Ring 可能访问哪个地址的信息。内核页面表条目被标记为仅有 Ring 0 可以访问；程序的条目被标记为任何 Ring 都可以访问。如果一个处于 Ring 3 中的进程去尝试访问标记为 Ring 0 的内存，处理器将阻止这个访问并生成一个意外错误信息。运行在 Ring 3 中的用户程序不能得到内核以及运行在 Ring 0 内存中的任何东西。
至少理论上是这样的。大量的补丁和更新表明，这个地方已经被突破了。这就是最大的谜团所在。
### Ring 间迁移
这就是我们所知道的。每个现代处理器都执行一定数量的推测运行。例如，给一些指令，让两个数加起来，然后将结果保存在内存中，在查明内存中的目标是否可访问和可写入之前，一个处理器可能已经推测性地做了加法。在一些常见案例中，在地址可写入的地方，处理器节省了一些时间，因为它以并行方式计算出内存中的目标是什么。如果它发现目标位置不可写入 —— 例如，一个程序尝试去写入到一个没有映射的地址或压根就不存在的物理位置 —— 然后它将产生一个意外错误，而推测运行就白做了。
Intel 处理器，尤其是（[虽然不是 AMD 的](https://lkml.org/lkml/2017/12/27/2)）允许对 Ring 3 代码进行推测运行并写入到 Ring 0 内存中的处理器上。处理器并不完全阻止这种写入，但是推测运行轻微扰乱了处理器状态，因为，为了查明目标位置是否可写入，某些数据已经被加载到缓存和 TLB 中。这又意味着一些操作可能快几个周期，或者慢几个周期，这取决于它们所需要的数据是否仍然在缓存中。除此之外，Intel 的处理器还有一些特殊的功能，比如，在 Skylake 处理器上引入的软件保护扩展（SGX）指令，它改变了一点点访问内存的方式。同样的，处理器仍然是保护 Ring 0 的内存不被来自 Ring 3 的程序所访问，但是同样的，它的缓存和其它内部状态已经发生了变化，产生了可测量的差异。
我们至今仍然并不知道具体的情况，到底有多少内核的内存信息泄露给了用户程序，或者信息泄露的情况有多容易发生。以及有哪些 Intel 处理器会受到影响？也或者并不完全清楚，但是，有迹象表明每个 Intel 芯片都使用了推测运行（是自 1995 年 Pentium Pro 以来的所有主流处理器吗？），它们都可能会因此而泄露信息。
这个问题第一次被披露是由来自 [奥地利的 Graz Technical University](https://gruss.cc/files/kaiser.pdf) 的研究者。他们披露的信息表明这个问题已经足够破坏内核模式地址空间布局随机化（内核 ASLR，或称 KASLR）。ASLR 是防范 [缓冲区溢出](https://arstechnica.com/information-technology/2015/08/how-security-flaws-work-the-buffer-overflow/) 漏洞利用的最后一道防线。启用 ASLR 之后，程序和它们的数据被置于随机的内存地址中，它将使一些安全漏洞利用更加困难。KASLR 将这种随机化应用到内核中，这样就使内核的数据（包括页面表）和代码也随机化分布。
Graz 的研究者开发了 [KAISER](https://github.com/IAIK/KAISER)，一组防范这个问题的 Linux 内核补丁。
如果这个问题正好使 ASLR 的随机化被破坏了，这或许将成为一个巨大的灾难。ASLR 是一个非常强大的保护措施，但是它并不是完美的，这意味着对于黑客来说将是一个很大的障碍，一个无法逾越的障碍。整个行业对此的反应是 —— Windows 和 Linux 都有一个非常重要的变化，秘密开发 —— 这表明不仅是 ASLR 被破坏了，而且从内核泄露出信息的更普遍的技术被开发出来了。确实是这样的，研究者已经 [在 Twitter 上发布信息](https://twitter.com/brainsmoke/status/948561799875502080)，他们已经可以随意泄露和读取内核数据了。另一种可能是，漏洞可能被用于从虚拟机中“越狱”，并可能会危及 hypervisor。
Windows 和 Linux 选择的解决方案是非常相似的，将 KAISER 分为两个区域：内核页面表的条目不再是由每个进程共享。在 Linux 中，这被称为内核页面表隔离（KPTI）。
应用补丁后，内存地址仍然被一分为二：这样使内核的那一半几乎是空的。当然它并不是非常的空，因为一些内核片断需要永久映射，不论进程是运行在 Ring 3 还是 Ring 0 中，它都几乎是空的。这意味着如果恶意用户程序尝试去探测内核内存以及泄露信息，它将会失败 —— 因为那里几乎没有信息。而真正的内核页面中只有当内核自身运行的时刻它才能被用到。
这样做就破坏了最初将地址空间分割的理由。现在，每次切换到用户程序时，TLB 需要实时去清除与内核页面表相关的所有条目，这样就失去了启用分割带来的性能提升。
影响的具体大小取决于工作负载。每当一个程序被调入到内核 —— 从磁盘读入、发送数据到网络、打开一个文件等等 —— 这种调用的成本可能会增加一点点，因为它强制 TLB 清除了缓存并实时加载内核页面表。不使用内核的程序可能会观测到 2 - 3 个百分点的性能影响 —— 这里仍然有一些开销，因为内核仍然是偶尔会运行去处理一些事情，比如多任务等等。
但是大量调用进入到内核的工作负载将观测到很大的性能损失。在一个基准测试中，一个除了调入到内核之外什么都不做的程序，观察到 [它的性能下降大约为 50%](https://twitter.com/grsecurity/status/947257569906757638)；换句话说就是，打补丁后每次对内核的调用的时间要比不打补丁调用内核的时间增加一倍。基准测试使用的 Linux 的网络回环（loopback）也观测到一个很大的影响，比如，在 Postgres 的基准测试中大约是 [17%](https://www.postgresql.org/message-id/20180102222354.qikjmf7dvnjgbkxe@alap3.anarazel.de)。真实的数据库负载使用了实时网络可能观测到的影响要低一些，因为使用实时网络时，内核调用的开销基本是使用真实网络的开销。
虽然对 Intel 系统的影响是众所周知的，但是它们可能并不是唯一受影响的。其它的一些平台，比如 SPARC 和 IBM 的 S390，是不受这个问题影响的，因为它们的处理器的内存管理并不需要分割地址空间和共享内核页面表；在这些平台上的操作系统一直就是将它们的内核页面表从用户模式中隔离出来的。但是其它的，比如 ARM，可能就没有这么幸运了；[适用于 ARM Linux 的类似补丁](https://lwn.net/Articles/740393/) 正在开发中。
---
[PETER BRIGHT](https://arstechnica.com/author/peter-bright) 是 Ars 的一位技术编辑。他涉及微软、编程及软件开发、Web 技术和浏览器、以及安全方面。它居住在纽约的布鲁克林。
---
via: <https://arstechnica.com/gadgets/2018/01/whats-behind-the-intel-design-flaw-forcing-numerous-patches/>
作者：[PETER BRIGHT](https://arstechnica.com/author/peter-bright/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Torrents（种子）：你需要知道的一切事情
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/torrents-everything-you-need-to-know
|
，在 Torrents 中涉及到各种概念。因此，通过这篇文章我们从技术的角度来了解 torrenting 是什么。
|
/data/attachment/album/201802/27/000941ymcm66mwceweetpe.jpg.thumb.jpg
|
/data/attachment/album/201802/27/000941ymcm66mwceweetpe.jpg
| true | false | true |
qhwdw
| false |
[
"Torrent",
"种子"
] |
技术
|
{
"viewnum": 7328,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9378,
"displayorder": 0
}
] |
，在 Torrents 中涉及到各种概念。因此，通过这篇文章我们从技术的角度来了解 torrenting 是什么。
| 2018-03-01T09:00:00 | 2018-03-01T09:00:00 | 9,388 |
/article-9388-1.html
|
Torrents（种子）：你需要知道的一切事情
=======================
**Torrents（种子）** — 每次听到这个词时，在我的脑海里想到的唯一的事情就是免费的电影、游戏、和被破解的软件。但是我们并不知道它们是如何工作的，在“种子”中涉及到各种概念。因此，通过这篇文章我们从技术的角度来了解**种子下载**是什么。
### “种子”是什么？
“种子”是一个到因特网上文件位置的链接。它们不是一个文件，它们仅仅是动态指向到你想去下载的原始文件上。
例如：如果你点击 [Google Chrome](https://www.google.com/chrome/)，你可以从谷歌的服务器上下载 Google Chrome 浏览器。
如果你明天、或者下周、或者下个月再去点击那个链接，这个文件仍然可以从谷歌服务器上去下载。
但是当我们使用“种子”下载时，它并没有固定的服务器。文件是从以前使用“种子”下载的其它人的个人电脑上下载的。
### Torrents 是如何工作的？
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/torrent_orig.png)
假设 ‘A’ 上有一些视频，它希望以“种子”方式去下载。因此，他创建了一个“种子”，并将这个链接发送给 ‘B’，这个链接包含了那个视频在因特网上的准确 IP 地址的信息。因此，当 ‘B’ 开始下载那个文件的时候，‘B’ 连接到 ‘A’ 的计算机。在 ‘B’ 下载完成这个视频之后，‘B’ 将开始做为种子，也就是 ‘B’ 将允许其它的 ‘C’ 或者 ‘D’ 从 ‘B’ 的计算机上下载它。
因此每个人先下载文件然后会上传，下载的人越多，下载的速度也越快。并且在任何情况下，如果想停止上传，也没有问题，随时可以。这样做并不会成为什么问题，除非很多的人下载而上传的人很少。
### 播种者和索取者
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/seeders_orig.png)
下载完成特定文件的用户将会即刻做为上传者，因此，可以被新用户下载的已下载者称为播种者。
而一些还没有完成特定文件的下载者，并且还正在下载的用户称为索取者。
### 块
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/peers_orig.png)
所有的“种子”文件都独立分割成固定大小的数据包，因此，它们可以非线性顺序和随机顺序下载。每个块都有唯一的标识，因此，一旦所有的块下载完成之后，它们会被拼接出原始文件。
正是因为这种机制，如果你正在从某人处下载一个文件，假如这个时候因某些原因他停止了上传，你可以继续从其它的播种者处继续下载，而不需要从头开始重新下载。
### 对端
对端是指当前连接到你的索取者。一个正在上传的索取者，不论它下载了多少块，它就是一个对端。
**例如：**
一个已经下载了文件的前 50 个块的用户就是一个索取者，但是，他又同时上传这些文件，而你只有前 10 个块，因此，你可以从他那里下载最多 50 个块。这时候他就成了你的对端。
### 最佳实践
当你下载一个“种子”时，总是选择最大的播种者。这就是最佳经验。
这里并没有最小的标准，但是只要确保你选择的是最大的那一个播种者就可以了。
### “种子”相关的法律
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/torrent-laws_orig.png)
“种子”相关的法律和其它的法律并没有什么区别，对受版权保护的其它任何东西一样，侵权行为会受到法律的制裁。大多数的政府都拦截“种子”站点和协议，但是“种子”下载本身并不是有害的东西。
“种子”对快速分享文件是非常有用的，并且它们被用来共享开源社区的软件，因为它们能节约大量的服务器资源。但是，许多人却因为盗版而使用它们。
### 结束语
Torrenting 是降低服务器上负载的一个非常完美的技术。“种子”下载可以使我们将下载速度提升到网卡的极限，这是非常好的。但是，在这种非中心化的服务器上，盗版成为一种必然发生的事。限制我们分享的内容，从不去下载盗版的东西，这是我们的道德责任。
请在下面的评论中分享你使用“种子”的心得，分享你喜欢的、法律许可下载的“种子”网站。
---
via: <http://www.linuxandubuntu.com/home/torrents-everything-you-need-to-know>
作者：[LINUXANDUBUNTU](http://www.linuxandubuntu.com) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
关于处理器你所需要知道的一切
|
Rishabh Kandari
|
http://www.theitstuff.com/processors-everything-need-know
|
在应用和软件的帮助下，处理器执行许多任务。我们是否曾经想过是什么给了这些软件这样的能力？它们是如何执行它们的逻辑的？它们的大脑在哪？
|
/data/attachment/album/201802/27/064657x0oagcol2fs101fc.jpg.thumb.jpg
|
/data/attachment/album/201802/27/064657x0oagcol2fs101fc.jpg
| true | false | true |
singledo
| false |
[
"CPU",
"处理器"
] |
技术
|
{
"viewnum": 4082,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在应用和软件的帮助下，处理器执行许多任务。我们是否曾经想过是什么给了这些软件这样的能力？它们是如何执行它们的逻辑的？它们的大脑在哪？
| 2018-02-27T06:46:55 | 2018-02-27T06:46:55 | 9,389 |
/article-9389-1.html
|
[](http://www.theitstuff.com/wp-content/uploads/2017/10/processors-all-you-need-to-know.jpg)
我们的手机、主机以及笔记本电脑这样的数字设备已经变得如此成熟，以至于它们进化成为我们的一部分，而不只是一种设备。
在应用和软件的帮助下，处理器执行许多任务。我们是否曾经想过是什么给了这些软件这样的能力？它们是如何执行它们的逻辑的？它们的大脑在哪？
我们知道 CPU （或称处理器）是那些需要处理数据和执行逻辑任务的设备的大脑。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/download.jpg)
在处理器的深处有那些不一样的概念呢？它们是如何演化的？一些处理器是如何做到比其它处理器更快的？让我们来看看关于处理器的主要术语，以及它们是如何影响处速度的。
### 架构
处理器有不同的架构，你一定遇到过不同类型的程序说它们是 64 位或 32 位的，这其中的意思就是程序支持特定的处理器架构。
如果一颗处理器是 32 位的架构，这意味着这颗处理器能够在一个处理周期内处理一个 32 位的数据。
同理可得，64 位的处理器能够在一个周期内处理一个 64 位的数据。
同时，你可以使用的内存大小决定于处理器的架构，你可以使用的内存总量为 2 的处理器架构的幂次方（如：`2^64`）。
16 位架构的处理器，仅仅有 64 kb 的内存使用。32 位架构的处理器，最大可使用的 RAM 是 4 GB，64 位架构的处理器的可用内存是 16 EB。
### 核心
在电脑上，核心是基本的处理单元。核心接收指令并且执行它。越多的核心带来越快的速度。把核心比作工厂里的工人，越多的工人使工作能够越快的完成。另一方面，工人越多，你所付出的薪水也就越多，工厂也会越拥挤；相对于核心来说，越多的核心消耗更多的能量，比核心少的 CPU 更容易发热。
### 时钟速度
[](http://www.theitstuff.com/wp-content/uploads/2017/10/download-1.jpg)
GHz 是 GigaHertz 的简写，Giga 意思是 10 亿次，Hertz （赫兹）意思是一秒有几个周期，2 GHz 的处理器意味着处理器一秒能够执行 20 亿个周期 。
它也以“频率”或者“时钟速度”而熟知。这项数值越高，CPU 的性能越好。
### CPU 缓存
CPU 缓存是处理器内部的一块小的存储单元，用来存储一些内存。不管如何，我们需要执行一些任务时，数据需要从内存传递到 CPU，CPU 的工作速度远快于内存，CPU 在大多数时间是在等待从内存传递过来的数据，而此时 CPU 是处于空闲状态的。为了解决这个问题，内存持续的向 CPU 缓存发送数据。
一般的处理器会有 2 ~ 3 Mb 的 CPU 缓存。高端的处理器会有 6 Mb 的 CPU 缓存，越大的缓存，意味着处理器更好。
### 印刷工艺
晶体管的大小就是处理器平板印刷的大小，尺寸通常是纳米，更小的尺寸意味者更紧凑。这可以让你有更多的核心，更小的面积，更小的能量消耗。
最新的 Intel 处理器有 14 nm 的印刷工艺。
### 热功耗设计（TDP）
代表着平均功耗，单位是瓦特，是在全核心激活以基础频率来处理 Intel 定义的高复杂度的负载时，处理器所散失的功耗。
所以，越低的热功耗设计对你越好。一个低的热功耗设计不仅可以更好的利用能量，而且产生更少的热量。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/download-2.jpg)
桌面版的处理器通常消耗更多的能量，热功耗消耗的能量能在 40% 以上，相对应的移动版本只有不到桌面版本的 1/3。
### 内存支持
我们已经提到了处理器的架构是如何影响到我们能够使用的内存总量，但这只是理论上而已。在实际的应用中，我们所能够使用的内存的总量对于处理器的规格来说是足够的，它通常是由处理器规格详细规定的。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/images.jpg)
它也指出了内存所支持的 DDR 的版本号。
### 超频
前面我们讲过时钟频率，超频是程序强迫 CPU 执行更多的周期。游戏玩家经常会使他们的处理器超频，以此来获得更好的性能。这样确实会增加速度，但也会增加消耗的能量，产生更多的热量。
一些高端的处理器允许超频，如果我们想让一个不支持超频的处理器超频，我们需要在主板上安装一个新的 BIOS 。 这样通常会成功，但这种情况是不安全的，也是不建议的。
### 超线程（HT）
如果不能添加核心以满足特定的处理需要，那么超线程是建立一个虚拟核心的方式。
如果一个双核处理器有超线程，那么这个双核处理器就有两个物理核心和两个虚拟核心，在技术上讲，一个双核处理器拥有四个核心。
### 结论
处理器有许多相关的数据，这些对数字设备来说是最重要的部分。我们在选择设备时，我们应该在脑海中仔细的检查处理器在上面提到的数据。
时钟速度、核心数、CPU 缓存，以及架构是最重要的数据。印刷尺寸以及热功耗设计重要性差一些 。
仍然有疑惑？ 欢迎评论，我会尽快回复的。
---
via: <http://www.theitstuff.com/processors-everything-need-know>
作者：[Rishabh Kandari](http://www.theitstuff.com/author/reevkandari) 译者：[singledo](https://github.com/singledo) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
学习用工具来驾驭 Git 历史
|
Ilija Eftimov
|
https://ieftimov.com/learn-your-tools-navigating-git-history
|
现在，我们来深入了解怎么去使用 git 的历史以及如何很轻松地去浏览它的历史。
|
/data/attachment/album/201802/27/170304t4tk9oogkronnint.jpg.thumb.jpg
|
/data/attachment/album/201802/27/170304t4tk9oogkronnint.jpg
| true | false | true |
qhwdw
| false |
[
"git",
"历史"
] |
软件开发
|
{
"viewnum": 5515,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
现在，我们来深入了解怎么去使用 git 的历史以及如何很轻松地去浏览它的历史。
| 2018-02-27T17:03:11 | 2018-02-27T17:03:11 | 9,390 |
/article-9390-1.html
|
在你的日常工作中，不可能每天都从头开始去开发一个新的应用程序。而真实的情况是，在日常工作中，我们大多数时候所面对的都是遗留下来的一个代码库，去修改一些特性的内容或者现存的一些代码行，这是我们在日常工作中很重要的一部分。而这也就是分布式版本控制系统 `git` 的价值所在。现在，我们来深入了解怎么去使用 `git` 的历史以及如何很轻松地去浏览它的历史。
### Git 历史
首先和最重要的事是，什么是 `git` 历史？正如其名字一样，它是一个 `git` 仓库的提交历史。它包含一堆提交信息，其中有它们的作者的名字、该提交的哈希值以及提交日期。查看一个 `git` 仓库历史的方法很简单，就是一个 `git log` 命令。
>
> *旁注：为便于本文的演示，我们使用 Ruby on Rails 的仓库的 `master` 分支。之所以选择它的理由是因为，Rails 有良好的 `git` 历史，漂亮的提交信息、引用以及对每个变更的解释。如果考虑到代码库的大小、维护者的年龄和数量，Rails 肯定是我见过的最好的仓库。当然了，我并不是说其它的 `git` 仓库做的不好，它只是我见过的比较好的一个仓库。*
>
>
>
那么，回到 Rails 仓库。如果你在 Ralis 仓库上运行 `git log`。你将看到如下所示的输出：
```
commit 66ebbc4952f6cfb37d719f63036441ef98149418
Author: Arthur Neves <foo@bar.com>
Date: Fri Jun 3 17:17:38 2016 -0400
Dont re-define class SQLite3Adapter on test
We were declaring in a few tests, which depending of the order load will cause an error, as the super class could change.
see https://github.com/rails/rails/commit/ac1c4e141b20c1067af2c2703db6e1b463b985da#commitcomment-17731383
commit 755f6bf3d3d568bc0af2c636be2f6df16c651eb1
Merge: 4e85538 f7b850e
Author: Eileen M. Uchitelle <foo@bar.com>
Date: Fri Jun 3 10:21:49 2016 -0400
Merge pull request #25263 from abhishekjain16/doc_accessor_thread
[skip ci] Fix grammar
commit f7b850ec9f6036802339e965c8ce74494f731b4a
Author: Abhishek Jain <foo@bar.com>
Date: Fri Jun 3 16:49:21 2016 +0530
[skip ci] Fix grammar
commit 4e85538dddf47877cacc65cea6c050e349af0405
Merge: 082a515 cf2158c
Author: Vijay Dev <foo@bar.com>
Date: Fri Jun 3 14:00:47 2016 +0000
Merge branch 'master' of github.com:rails/docrails
Conflicts:
guides/source/action_cable_overview.md
commit 082a5158251c6578714132e5c4f71bd39f462d71
Merge: 4bd11d4 3bd30d9
Author: Yves Senn <foo@bar.com>
Date: Fri Jun 3 11:30:19 2016 +0200
Merge pull request #25243 from sukesan1984/add_i18n_validation_test
Add i18n_validation_test
commit 4bd11d46de892676830bca51d3040f29200abbfa
Merge: 99d8d45 e98caf8
Author: Arthur Nogueira Neves <foo@bar.com>
Date: Thu Jun 2 22:55:52 2016 -0400
Merge pull request #25258 from alexcameron89/master
[skip ci] Make header bullets consistent in engines.md
commit e98caf81fef54746126d31076c6d346c48ae8e1b
Author: Alex Kitchens <foo@bar.com>
Date: Thu Jun 2 21:26:53 2016 -0500
[skip ci] Make header bullets consistent in engines.md
```
正如你所见，`git log` 展示了提交的哈希、作者及其 email 以及该提交创建的日期。当然，`git` 输出的可定制性很强大，它允许你去定制 `git log` 命令的输出格式。比如说，我们只想看提交信息的第一行，我们可以运行 `git log --oneline`，它将输出一个更紧凑的日志：
```
66ebbc4 Dont re-define class SQLite3Adapter on test
755f6bf Merge pull request #25263 from abhishekjain16/doc_accessor_thread
f7b850e [skip ci] Fix grammar4e85538 Merge branch 'master' of github.com:rails/docrails
082a515 Merge pull request #25243 from sukesan1984/add_i18n_validation_test
4bd11d4 Merge pull request #25258 from alexcameron89/master
e98caf8 [skip ci] Make header bullets consistent in engines.md
99d8d45 Merge pull request #25254 from kamipo/fix_debug_helper_test
818397c Merge pull request #25240 from matthewd/reloadable-channels
2c5a8ba Don't blank pad day of the month when formatting dates
14ff8e7 Fix debug helper test
```
如果你想看 `git log` 的全部选项，我建议你去查阅 `git log` 的 man 页面，你可以在一个终端中输入 `man git-log` 或者 `git help log` 来获得。
>
> *小提示：如果你觉得 `git log` 看起来太恐怖或者过于复杂，或者你觉得看它太无聊了，我建议你去寻找一些 `git` 的 GUI 或命令行工具。在之前，我使用过 [GitX](http://gitx.frim.nl/) ，我觉得它很不错，但是，由于我看命令行更“亲切”一些，在我尝试了 [tig](https://github.com/jonas/tig) 之后，就再也没有去用过它。*
>
>
>
### 寻找尼莫
现在，我们已经知道了关于 `git log` 命令的一些很基础的知识之后，我们来看一下，在我们的日常工作中如何使用它更加高效地浏览历史。
假如，我们怀疑在 `String#classify` 方法中有一个预期之外的行为，我们希望能够找出原因，并且定位出实现它的代码行。
为达到上述目的，你可以使用的第一个命令是 `git grep`，通过它可以找到这个方法定义在什么地方。简单来说，这个命令输出了匹配特定模式的那些行。现在，我们来找出定义它的方法，它非常简单 —— 我们对 `def classify` 运行 grep，然后看到的输出如下：
```
➜ git grep 'def classify'
activesupport/lib/active_support/core_ext/string/inflections.rb: def classifyactivesupport/lib/active_support/inflector/methods.rb: def classify(table_name)tools/profile: def classify
```
现在，虽然我们已经看到这个方法是在哪里创建的，但是，并不能够确定它是哪一行。如果，我们在 `git grep` 命令上增加 `-n` 标志，`git` 将提供匹配的行号：
```
➜ git grep -n 'def classify'
activesupport/lib/active_support/core_ext/string/inflections.rb:205: def classifyactivesupport/lib/active_support/inflector/methods.rb:186: def classify(table_name)tools/profile:112: def classify
```
更好看了，是吧？考虑到上下文，我们可以很轻松地找到，这个方法在 `activesupport/lib/active_support/core_ext/string/inflections.rb` 的第 205 行的 `classify` 方法，它看起来像这样，是不是很容易？
```
# Creates a class name from a plural table name like Rails does for table names to models.
# Note that this returns a string and not a class. (To convert to an actual class
# follow +classify+ with +constantize+.)
#
# 'ham_and_eggs'.classify # => "HamAndEgg"
# 'posts'.classify # => "Post"
def classify
ActiveSupport::Inflector.classify(self)
end
```
尽管我们找到的这个方法是在 `String` 上的一个常见的调用，它调用了 `ActiveSupport::Inflector` 上的另一个同名的方法。根据之前的 `git grep` 的结果，我们可以很轻松地发现结果的第二行， `activesupport/lib/active_support/inflector/methods.rb` 在 186 行上。我们正在寻找的方法是这样的：
```
# Creates a class name from a plural table name like Rails does for table
# names to models. Note that this returns a string and not a Class (To
# convert to an actual class follow +classify+ with constantize).
#
# classify('ham_and_eggs') # => "HamAndEgg"
# classify('posts') # => "Post"
#
# Singular names are not handled correctly:
#
# classify('calculus') # => "Calculus"
def classify(table_name)
# strip out any leading schema name
camelize(singularize(table_name.to_s.sub(/.*\./, ''.freeze)))
end
```
酷！考虑到 Rails 仓库的大小，我们借助 `git grep` 找到它，用时都没有超越 30 秒。
### 那么，最后的变更是什么？
现在，我们已经找到了所要找的方法，现在，我们需要搞清楚这个文件所经历的变更。由于我们已经知道了正确的文件名和行数，我们可以使用 `git blame`。这个命令展示了一个文件中每一行的最后修订者和修订的内容。我们来看一下这个文件最后的修订都做了什么：
```
git blame activesupport/lib/active_support/inflector/methods.rb
```
虽然我们得到了这个文件每一行的最后的变更，但是，我们更感兴趣的是对特定方法（176 到 189 行）的最后变更。让我们在 `git blame` 命令上增加一个选项，让它只显示那些行的变化。此外，我们将在命令上增加一个 `-s` （忽略）选项，去跳过那一行变更时的作者名字和修订（提交）的时间戳：
```
git blame -L 176,189 -s activesupport/lib/active_support/inflector/methods.rb
9fe8e19a 176) #Creates a class name from a plural table name like Rails does for table
5ea3f284 177) # names to models. Note that this returns a string and not a Class (To
9fe8e19a 178) # convert to an actual class follow +classify+ with #constantize).
51cd6bb8 179) #
6d077205 180) # classify('ham_and_eggs') # => "HamAndEgg"
9fe8e19a 181) # classify('posts') # => "Post"
51cd6bb8 182) #
51cd6bb8 183) # Singular names are not handled correctly:
5ea3f284 184) #
66d6e7be 185) # classify('calculus') # => "Calculus"
51cd6bb8 186) def classify(table_name)
51cd6bb8 187) # strip out any leading schema name
5bb1d4d2 188) camelize(singularize(table_name.to_s.sub(/.*\./, ''.freeze)))
51cd6bb8 189) end
```
现在，`git blame` 命令的输出展示了指定行的全部内容以及它们各自的修订。让我们来看一下指定的修订，换句话说就是，每个变更都修订了什么，我们可以使用 `git show` 命令。当指定一个修订哈希（像 `66d6e7be`）作为一个参数时，它将展示这个修订的全部内容。包括作者名字、时间戳以及完整的修订内容。我们来看一下 188 行最后的修订都做了什么？
```
git show 5bb1d4d2
```
你亲自做实验了吗？如果没有做，我直接告诉你结果，这个令人惊叹的 [提交](https://github.com/rails/rails/commit/5bb1d4d288d019e276335465d0389fd2f5246bfd) 是由 [Schneems](https://twitter.com/schneems) 完成的，他通过使用 frozen 字符串做了一个非常有趣的性能优化，这在我们当前的场景中是非常有意义的。但是，由于我们在这个假设的调试会话中，这样做并不能告诉我们当前问题所在。因此，我们怎么样才能够通过研究来发现，我们选定的方法经过了哪些变更？
### 搜索日志
现在，我们回到 `git` 日志，现在的问题是，怎么能够看到 `classify` 方法经历了哪些修订？
`git log` 命令非常强大，因此它提供了非常多的列表选项。我们尝试使用 `-p` 选项去看一下保存了这个文件的 `git` 日志内容，这个选项的意思是在 `git` 日志中显示这个文件的完整补丁:
```
git log -p activesupport/lib/active_support/inflector/methods.rb
```
这将给我们展示一个很长的修订列表，显示了对这个文件的每个修订。但是，正如下面所显示的，我们感兴趣的是对指定行的修订。对命令做一个小的修改，只显示我们希望的内容：
```
git log -L 176,189:activesupport/lib/active_support/inflector/methods.rb
```
`git log` 命令接受 `-L` 选项，它用一个行的范围和文件名做为参数。它的格式可能有点奇怪，格式解释如下：
```
git log -L <start-line>,<end-line>:<path-to-file>
```
当我们运行这个命令之后，我们可以看到对这些行的一个修订列表，它将带我们找到创建这个方法的第一个修订：
```
commit 51xd6bb829c418c5fbf75de1dfbb177233b1b154
Author: Foo Bar <foo@bar.com>
Date: Tue Jun 7 19:05:09 2011 -0700
Refactor
diff--git a/activesupport/lib/active_support/inflector/methods.rb b/activesupport/lib/active_support/inflector/methods.rb
--- a/activesupport/lib/active_support/inflector/methods.rb
+++ b/activesupport/lib/active_support/inflector/methods.rb
@@ -58,0 +135,14 @@
+ # Create a class name from a plural table name like Rails does for table names to models.
+ # Note that this returns a string and not a Class. (To convert to an actual class
+ # follow +classify+ with +constantize+.)
+ #
+ # Examples:
+ # "egg_and_hams".classify # => "EggAndHam"
+ # "posts".classify # => "Post"
+ #
+ # Singular names are not handled correctly:
+ # "business".classify # => "Busines"
+ def classify(table_name)
+ # strip out any leading schema name
+ camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+ end
```
现在，我们再来看一下 —— 它是在 2011 年提交的。`git` 可以让我们重回到这个时间。这是一个很好的例子，它充分说明了足够的提交信息对于重新了解当时的上下文环境是多么的重要，因为从这个提交信息中，我们并不能获得足够的信息来重新理解当时的创建这个方法的上下文环境，但是，话说回来，你**不应该**对此感到恼怒，因为，你看到的这些项目，它们的作者都是无偿提供他们的工作时间和精力来做开源工作的。（向开源项目贡献者致敬！）
回到我们的正题，我们并不能确认 `classify` 方法最初实现是怎么回事，考虑到这个第一次的提交只是一个重构。现在，如果你认为，“或许、有可能、这个方法不在 176 行到 189 行的范围之内，那么就你应该在这个文件中扩大搜索范围”，这样想是对的。我们看到在它的修订提交的信息中提到了“重构”这个词，它意味着这个方法可能在那个文件中是真实存在的，而且是在重构之后它才存在于那个行的范围内。
但是，我们如何去确认这一点呢？不管你信不信，`git` 可以再次帮助你。`git log` 命令有一个 `-S` 选项，它可以传递一个特定的字符串作为参数，然后去查找代码变更（添加或者删除）。也就是说，如果我们执行 `git log -S classify` 这样的命令，我们可以看到所有包含 `classify` 字符串的变更行的提交。
如果你在 Ralis 仓库上运行上述命令，首先你会发现这个命令运行有点慢。但是，你应该会发现 `git` 实际上解析了在那个仓库中的所有修订来匹配这个字符串，其实它的运行速度是非常快的。在你的指尖下 `git` 再次展示了它的强大之处。因此，如果去找关于 `classify` 方法的第一个修订，我们可以运行如下的命令：
```
git log -S 'def classify'
```
它将返回所有这个方法的引用和修改的地方。如果你一直往下看，你将看到日志中它的最后的提交：
```
commit db045dbbf60b53dbe013ef25554fd013baf88134
Author: David Heinemeier Hansson <foo@bar.com>
Date: Wed Nov 24 01:04:44 2004 +0000
Initial
git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@4 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
```
很酷！是吧？它初次被提交到 Rails，是由 DHH 在一个 `svn` 仓库上做的！这意味着 `classify` 大概在一开始就被提交到了 Rails 仓库。现在，我们去看一下这个提交的所有变更信息，我们运行如下的命令：
```
git show db045dbbf60b53dbe013ef25554fd013baf88134
```
非常好！我们终于找到它的根源了。现在，我们使用 `git log -S 'def classify'` 的输出，结合 `git log -L` 命令来跟踪这个方法都发生了哪些变更。
### 下次见
当然，我们并没有真的去修改任何 bug，因为我们只是去尝试使用一些 `git` 命令，来演示如何查看 `classify` 方法的演变历史。但是不管怎样，`git` 是一个非常强大的工具，我们必须学好它、用好它。我希望这篇文章可以帮助你掌握更多的关于如何使用 `git` 的知识。
你喜欢这些内容吗？
---
作者简介：
后端工程师，对 Ruby、Go、微服务、构建弹性架构来解决大规模部署带来的挑战很感兴趣。我在阿姆斯特丹的 Rails Girls 担任顾问，维护着一个小而精的列表，并且经常为开源做贡献。
那个列表是我写的关于软件开发、编程语言以及任何我感兴趣的东西。
---
via: <https://ieftimov.com/learn-your-tools-navigating-git-history>
作者：[Ilija Eftimov](https://ieftimov.com/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Ubuntu 安装 Go 语言编写的 Git 服务器 Gogs
|
Muhammad Arul
|
https://www.howtoforge.com/tutorial/how-to-install-gogs-go-git-service-on-ubuntu-1604/
|
Gogs 的网页界面和 GitHub 十分相近，且提供 MySQL、PostgreSQL 和 SQLite 数据库支持。
|
/data/attachment/album/201802/27/223159q909jj7vij99pv37.png.thumb.jpg
|
/data/attachment/album/201802/27/223159q909jj7vij99pv37.png
| true | false | true |
CYLeft
| false |
[
"Gogs",
"Go",
"Git"
] |
技术
|
{
"viewnum": 5528,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Gogs 的网页界面和 GitHub 十分相近，且提供 MySQL、PostgreSQL 和 SQLite 数据库支持。
| 2018-02-27T22:31:57 | 2018-02-27T22:31:57 | 9,391 |
/article-9391-1.html
|
Gogs 是由 Go 语言编写的，自由开源的 Git 服务。Gogs 是一款无痛式自托管的 Git 服务器，能在尽可能小的硬件资源开销上搭建并运行您的私有 Git 服务器。Gogs 的网页界面和 GitHub 十分相近，且提供 MySQL、PostgreSQL 和 SQLite 数据库支持。
在本教程中，我们将使用 Gogs 在 Ununtu 16.04 上按步骤指导您安装和配置您的私有 Git 服务器。这篇教程中涵盖了如何在 Ubuntu 上安装 Go 语言、PostgreSQL 和安装并且配置 Nginx 网页服务器作为 Go 应用的反向代理的细节内容。
### 搭建环境
* Ubuntu 16.04
* Root 权限
### 我们将会接触到的事物
1. 更新和升级系统
2. 安装和配置 PostgreSQL
3. 安装 Go 和 Git
4. 安装 Gogs
5. 配置 Gogs
6. 运行 Gogs 服务器
7. 安装和配置 Nginx 反向代理
8. 测试
### 步骤 1 - 更新和升级系统
继续之前，更新 Ubuntu 所有的库，升级所有包。
运行下面的 `apt` 命令：
```
sudo apt update
sudo apt upgrade
```
### 步骤 2 - 安装和配置 PostgreSQL
Gogs 提供 MySQL、PostgreSQL、SQLite 和 TiDB 数据库系统支持。
此步骤中，我们将使用 PostgreSQL 作为 Gogs 程序的数据库。
使用下面的 `apt` 命令安装 PostgreSQL。
```
sudo apt install -y postgresql postgresql-client libpq-dev
```
安装完成之后，启动 PostgreSQL 服务并设置为开机启动。
```
systemctl start postgresql
systemctl enable postgresql
```
此时 PostgreSQL 数据库在 Ubuntu 系统上完成安装了。
之后，我们需要为 Gogs 创建数据库和用户。
使用 `postgres` 用户登录并运行 `psql` 命令以访问 PostgreSQL 操作界面。
```
su - postgres
psql
```
创建一个名为 `git` 的新用户，给予此用户 `CREATEDB` 权限。
```
CREATE USER git CREATEDB;
\password git
```
创建名为 `gogs_production` 的数据库，设置 `git` 用户作为其所有者。
```
CREATE DATABASE gogs_production OWNER git;
```
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/1.png)
用于 Gogs 的 `gogs_production` PostgreSQL 数据库和 `git` 用户已经创建完毕。
### 步骤 3 - 安装 Go 和 Git
使用下面的 `apt` 命令从库中安装 Git。
```
sudo apt install git
```
此时，为系统创建名为 `git` 的新用户。
```
sudo adduser --disabled-login --gecos 'Gogs' git
```
登录 `git` 账户并且创建名为 `local` 的目录。
```
su - git
mkdir -p /home/git/local
```
切换到 `local` 目录，依照下方所展示的内容，使用 `wget` 命令下载 Go（最新版）。
```
cd ~/local
wget https://dl.google.com/go/go1.9.2.linux-amd64.tar.gz
```
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/2.png)
解压并且删除 go 的压缩文件。
```
tar -xf go1.9.2.linux-amd64.tar.gz
rm -f go1.9.2.linux-amd64.tar.gz
```
Go 二进制文件已经被下载到 `~/local/go` 目录。此时我们需要设置环境变量 - 设置 `GOROOT` 和 `GOPATH` 目录到系统环境，这样，我们就可以在 `git` 用户下执行 `go` 命令。
执行下方的命令。
```
cd ~/
echo 'export GOROOT=$HOME/local/go' >> $HOME/.bashrc
echo 'export GOPATH=$HOME/go' >> $HOME/.bashrc
echo 'export PATH=$PATH:$GOROOT/bin:$GOPATH/bin' >> $HOME/.bashrc
```
之后通过运行 `source ~/.bashrc` 重载 Bash，如下：
```
source ~/.bashrc
```
确定您使用的 Bash 是默认的 shell。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/3.png)
现在运行 `go` 的版本查看命令。
```
go version
```
之后确保您得到下图所示的结果。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/4.png)
现在，Go 已经安装在系统的 `git` 用户下了。
### 步骤 4 - 使用 Gogs 安装 Git 服务
使用 `git` 用户登录并且使用 `go` 命令从 GitHub 下载 Gogs。
```
su - git
go get -u github.com/gogits/gogs
```
此命令将在 `GOPATH/src` 目录下载 Gogs 的所有源代码。
切换至 `$GOPATH/src/github.com/gogits/gogs` 目录，并且使用下列命令搭建 Gogs。
```
cd $GOPATH/src/github.com/gogits/gogs
go build
```
确保您没有遇到错误。
现在使用下面的命令运行 Gogs Go Git 服务器。
```
./gogs web
```
此命令将会默认运行 Gogs 在 3000 端口上。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/5.png)
打开网页浏览器，键入您的 IP 地址和端口号，我的是 <http://192.168.33.10:3000/> 。
您应该会得到与下方一致的反馈。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/6.png)
Gogs 已经在您的 Ubuntu 系统上安装完毕。现在返回到您的终端，并且键入 `Ctrl + C` 中止服务。
### 步骤 5 - 配置 Gogs Go Git 服务器
本步骤中，我们将为 Gogs 创建惯例配置。
进入 Gogs 安装目录并新建 `custom/conf` 目录。
```
cd $GOPATH/src/github.com/gogits/gogs
mkdir -p custom/conf/
```
复制默认的配置文件到 `custom` 目录，并使用 [vim](https://www.howtoforge.com/vim-basics) 修改。
```
cp conf/app.ini custom/conf/app.ini
vim custom/conf/app.ini
```
在 `[server]` 小节中，修改 `HOST_ADDR` 为 `127.0.0.1`。
```
[server]
PROTOCOL = http
DOMAIN = localhost
ROOT_URL = %(PROTOCOL)s://%(DOMAIN)s:%(HTTP_PORT)s/
HTTP_ADDR = 127.0.0.1
HTTP_PORT = 3000
```
在 `[database]` 选项中，按照您的数据库信息修改。
```
[database]
DB_TYPE = postgres
HOST = 127.0.0.1:5432
NAME = gogs_production
USER = git
PASSWD = aqwe123@#
```
保存并退出。
运行下面的命令验证配置项。
```
./gogs web
```
并且确保您得到如下的结果。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/7.png)
Gogs 现在已经按照自定义配置下运行在 `localhost` 的 3000 端口上了。
### 步骤 6 - 运行 Gogs 服务器
这一步，我们将在 Ubuntu 系统上配置 Gogs 服务器。我们会在 `/etc/systemd/system` 目录下创建一个新的服务器配置文件 `gogs.service`。
切换到 `/etc/systemd/system` 目录，使用 [vim](https://www.howtoforge.com/vim-basics) 创建服务器配置文件 `gogs.service`。
```
cd /etc/systemd/system
vim gogs.service
```
粘贴下面的代码到 Gogs 服务器配置文件中。
```
[Unit]
Description=Gogs
After=syslog.target
After=network.target
After=mariadb.service mysqld.service postgresql.service memcached.service redis.service
[Service]
# Modify these two values and uncomment them if you have
# repos with lots of files and get an HTTP error 500 because
# of that
###
#LimitMEMLOCK=infinity
#LimitNOFILE=65535
Type=simple
User=git
Group=git
WorkingDirectory=/home/git/go/src/github.com/gogits/gogs
ExecStart=/home/git/go/src/github.com/gogits/gogs/gogs web
Restart=always
Environment=USER=git HOME=/home/git
[Install]
WantedBy=multi-user.target
```
之后保存并且退出。
现在可以重载系统服务器。
```
systemctl daemon-reload
```
使用下面的命令开启 Gogs 服务器并设置为开机启动。
```
systemctl start gogs
systemctl enable gogs
```
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/8.png)
Gogs 服务器现在已经运行在 Ubuntu 系统上了。
使用下面的命令检测：
```
netstat -plntu
systemctl status gogs
```
您应该会得到下图所示的结果。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/9.png)
### 步骤 7 - 为 Gogs 安装和配置 Nginx 反向代理
在本步中，我们将为 Gogs 安装和配置 Nginx 反向代理。我们会在自己的库中调用 Nginx 包。
使用下面的命令添加 Nginx 库。
```
sudo add-apt-repository -y ppa:nginx/stable
```
此时更新所有的库并且使用下面的命令安装 Nginx。
```
sudo apt update
sudo apt install nginx -y
```
之后，进入 `/etc/nginx/sites-available` 目录并且创建虚拟主机文件 `gogs`。
```
cd /etc/nginx/sites-available
vim gogs
```
粘贴下面的代码到配置文件。
```
server {
listen 80;
server_name git.hakase-labs.co;
location / {
proxy_pass http://localhost:3000;
}
}
```
保存退出。
**注意:** 请使用您的域名修改 `server_name` 项。
现在激活虚拟主机并且测试 nginx 配置。
```
ln -s /etc/nginx/sites-available/gogs /etc/nginx/sites-enabled/
nginx -t
```
确保没有遇到错误，重启 Nginx 服务器。
```
systemctl restart nginx
```
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/10.png)
### 步骤 8 - 测试
打开您的网页浏览器并且输入您的 Gogs URL，我的是 <http://git.hakase-labs.co>
现在您将进入安装界面。在页面的顶部，输入您所有的 PostgreSQL 数据库信息。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/11.png)
之后，滚动到底部，点击 “Admin account settings” 下拉选项。
输入您的管理者用户名和邮箱。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/12.png)
之后点击 “Install Gogs” 按钮。
然后您将会被重定向到下图显示的 Gogs 用户面板。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/13.png)
下面是 Gogs 的 “Admin Dashboard（管理员面板）”。
[](https://www.howtoforge.com/images/how_to_install_gogs_go_git_service_on_ubuntu_1604/big/14.png)
现在，Gogs 已经通过 PostgreSQL 数据库和 Nginx 网页服务器在您的 Ubuntu 16.04 上完成安装。
---
via: <https://www.howtoforge.com/tutorial/how-to-install-gogs-go-git-service-on-ubuntu-1604/>
作者：[Muhammad Arul](https://www.howtoforge.com/tutorial/server-monitoring-with-shinken-on-ubuntu-16-04/) 译者：[CYLeft](https://github.com/CYLeft) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux/Unix 中不重启 Vim 而重新加载 .vimrc 文件
|
Vivek Gite
|
https://www.cyberciti.biz/faq/how-to-reload-vimrc-file-without-restarting-vim-on-linux-unix/
|
我通常使用 :vs ~/.vimrc 来加载 ~/.vimrc 配置。而当编辑 .vimrc 时，我需要不重启 Vim 会话而重新加载它。
|
/data/attachment/album/201802/27/231519ti0ryai29050ra5a.jpg.thumb.jpg
|
/data/attachment/album/201802/27/231519ti0ryai29050ra5a.jpg
| true | false | true |
geekpi
| false |
[
"Vim"
] |
技术
|
{
"viewnum": 13346,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我通常使用 :vs ~/.vimrc 来加载 ~/.vimrc 配置。而当编辑 .vimrc 时，我需要不重启 Vim 会话而重新加载它。
| 2018-02-27T23:15:26 | 2018-02-27T23:15:26 | 9,392 |
/article-9392-1.html
|
我是一位新的 Vim 编辑器用户。我通常使用 `:vs ~/.vimrc` 来加载 `~/.vimrc` 配置。而当编辑 `.vimrc` 时，我需要不重启 Vim 会话而重新加载它。在 Linux 或者类 Unix 系统中，如何在编辑 `.vimrc` 后，重新加载它而不用重启 Vim 呢？
Vim 是自由开源并且向上兼容 Vi 的编辑器。它可以用来编辑各种文本。它在编辑用 C/Perl/Python 编写的程序时特别有用。可以用它来编辑 Linux/Unix 配置文件。`~/.vimrc` 是你个人的 Vim 初始化和自定义文件。
### 如何在不重启 Vim 会话的情况下重新加载 .vimrc
在 Vim 中重新加载 `.vimrc` 而不重新启动的流程：
1. 输入 `vim filename` 启动 vim
2. 按下 `Esc` 接着输入 `:vs ~/.vimrc` 来加载 vim 配置
3. 像这样添加自定义配置：
```
filetype indent plugin on
set number
syntax on
```
4. 使用 `:wq` 保存文件，并从 `~/.vimrc` 窗口退出
5. 输入下面任一命令重载 `~/.vimrc`：`:so $MYVIMRC` 或者 `:source ~/.vimrc`。
[](https://www.cyberciti.biz/media/new/faq/2018/02/How-to-reload-.vimrc-file-without-restarting-vim.jpg)
*图1：编辑 ~/.vimrc 并在需要时重载它而不用退出 vim，这样你就可以继续编辑程序了*
`:so[urce]! {file}` 这个 vim 命令会从给定的文件比如 `~/.vimrc` 读取配置。就像你输入的一样，这些命令是在普通模式下执行的。当你在 `:global`、:`argdo`、 `:windo`、`:bufdo` 之后、循环中或者跟着另一个命令时，显示不会再在执行命令时更新。
### 如何设置按键来编辑并重载 ~/.vimrc
在你的 `~/.vimrc` 后面跟上这些：
```
" Edit vimr configuration file
nnoremap confe :e $MYVIMRC<CR>
" Reload vims configuration file
nnoremap confr :source $MYVIMRC<CR>
```
现在只要按下 `Esc` 接着输入 `confe` 就可以编辑 `~/.vimrc`。按下 `Esc` ，接着输入 `confr` 以重新加载。一些人喜欢在 `.vimrc` 中使用 `<Leader>` 键。因此上面的映射变成：
```
" Edit vimr configuration file
nnoremap <Leader>ve :e $MYVIMRC<CR>
" Reload vimr configuration file
nnoremap <Leader>vr :source $MYVIMRC<CR>
```
`<Leader>` 键默认映射成 `\` 键。因此只要输入 `\` 接着 `ve` 就能编辑文件。按下 `\` 接着 `vr` 就能重载 `~/vimrc`。
这就完成了，你可以不用再重启 Vim 就能重新加载 `.vimrc` 了。
### 关于作者
作者是 nixCraft 的创建者，经验丰富的系统管理员，也是 Linux / Unix shell 脚本的培训师。他曾与全球客户以及IT、教育、国防和太空研究以及非营利部门等多个行业合作。在 [Twitter][9]、[Facebook][10]、[Google +][11] 上关注他。通过[RSS/XML 订阅](https://www.cyberciti.biz/atom/atom.xml)获取最新的系统管理、Linux/Unix 以及开源主题教程。
---
via: <https://www.cyberciti.biz/faq/how-to-reload-vimrc-file-without-restarting-vim-on-linux-unix/>
作者：[Vivek Gite](https://www.cyberciti.biz/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
内核如何管理内存
|
Gustavo Duarte
|
http://duartes.org/gustavo/blog/post/how-the-kernel-manages-your-memory/
|
在学习了进程的 虚拟地址布局 之后，让我们回到内核，来学习它管理用户内存的机制。
|
/data/attachment/album/201802/28/002510zfsruzezb6b46oib.jpg.thumb.jpg
|
/data/attachment/album/201802/28/002510zfsruzezb6b46oib.jpg
| true | false | true |
qhwdw
| false |
[
"内存"
] |
技术
|
{
"viewnum": 8829,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9255,
"displayorder": 0
},
{
"raid": 9528,
"displayorder": 0
}
] |
在学习了进程的 虚拟地址布局 之后，让我们回到内核，来学习它管理用户内存的机制。
| 2018-03-01T09:16:00 | 2018-03-01T09:16:00 | 9,393 |
/article-9393-1.html
|
在学习了进程的 [虚拟地址布局](/article-9255-1.html) 之后，让我们回到内核，来学习它管理用户内存的机制。这里再次使用 Gonzo：
Linux 进程在内核中是作为进程描述符 [task\_struct](http://lxr.linux.no/linux+v2.6.28.1/include/linux/sched.h#L1075) （LCTT 译注：它是在 Linux 中描述进程完整信息的一种数据结构）的实例来实现的。在 task\_struct 中的 [mm](http://lxr.linux.no/linux+v2.6.28.1/include/linux/sched.h#L1129) 域指向到**内存描述符**，[mm\_struct](http://lxr.linux.no/linux+v2.6.28.1/include/linux/mm_types.h#L173) 是一个程序在内存中的执行摘要。如上图所示，它保存了起始和结束内存段，进程使用的物理内存页面的 [数量](http://lxr.linux.no/linux+v2.6.28.1/include/linux/mm_types.h#L197)（RSS <ruby> 常驻内存大小 <rt> Resident Set Size </rt></ruby> ）、虚拟地址空间使用的 [总数量](http://lxr.linux.no/linux+v2.6.28.1/include/linux/mm_types.h#L206)、以及其它片断。 在内存描述符中，我们可以获悉它有两种管理内存的方式：**虚拟内存区域**集和**页面表**。Gonzo 的内存区域如下所示：
每个虚拟内存区域（VMA）是一个连续的虚拟地址范围；这些区域绝对不会重叠。一个 [vm\_area\_struct](http://lxr.linux.no/linux+v2.6.28.1/include/linux/mm_types.h#L99) 的实例完整地描述了一个内存区域，包括它的起始和结束地址，[flags](http://lxr.linux.no/linux+v2.6.28/include/linux/mm.h#L76) 决定了访问权限和行为，并且 [vm\_file](http://lxr.linux.no/linux+v2.6.28.1/include/linux/mm_types.h#L150) 域指定了映射到这个区域的文件（如果有的话）。（除了内存映射段的例外情况之外，）一个 VMA 是不能**匿名**映射文件的。上面的每个内存段（比如，堆、栈）都对应一个单个的 VMA。虽然它通常都使用在 x86 的机器上，但它并不是必需的。VMA 也不关心它们在哪个段中。
一个程序的 VMA 在内存描述符中是作为 [mmap](http://lxr.linux.no/linux+v2.6.28.1/include/linux/mm_types.h#L174) 域的一个链接列表保存的，以起始虚拟地址为序进行排列，并且在 [mm\_rb](http://lxr.linux.no/linux+v2.6.28.1/include/linux/mm_types.h#L175) 域中作为一个 [红黑树](http://en.wikipedia.org/wiki/Red_black_tree) 的根。红黑树允许内核通过给定的虚拟地址去快速搜索内存区域。在你读取文件 `/proc/pid_of_process/maps` 时，内核只是简单地读取每个进程的 VMA 的链接列表并[显示它们](http://lxr.linux.no/linux+v2.6.28.1/fs/proc/task_mmu.c#L201)。
在 Windows 中，[EPROCESS](http://www.nirsoft.net/kernel_struct/vista/EPROCESS.html) 块大致类似于一个 task\_struct 和 mm\_struct 的结合。在 Windows 中模拟一个 VMA 的是虚拟地址描述符，或称为 [VAD](http://www.nirsoft.net/kernel_struct/vista/MMVAD.html)；它保存在一个 [AVL 树](http://en.wikipedia.org/wiki/AVL_tree) 中。你知道关于 Windows 和 Linux 之间最有趣的事情是什么吗？其实它们只有一点小差别。
4GB 虚拟地址空间被分配到**页面**中。在 32 位模式中的 x86 处理器中支持 4KB、2MB、以及 4MB 大小的页面。Linux 和 Windows 都使用大小为 4KB 的页面去映射用户的一部分虚拟地址空间。字节 0-4095 在页面 0 中，字节 4096-8191 在页面 1 中，依次类推。VMA 的大小 *必须是页面大小的倍数* 。下图是使用 4KB 大小页面的总数量为 3GB 的用户空间：
处理器通过查看**页面表**去转换一个虚拟内存地址到一个真实的物理内存地址。每个进程都有它自己的一组页面表；每当发生进程切换时，用户空间的页面表也同时切换。Linux 在内存描述符的 [pgd](http://lxr.linux.no/linux+v2.6.28.1/include/linux/mm_types.h#L185) 域中保存了一个指向进程的页面表的指针。对于每个虚拟页面，页面表中都有一个相应的**页面表条目**（PTE），在常规的 x86 页面表中，它是一个简单的如下所示的大小为 4 字节的记录：
Linux 通过函数去 [读取](http://lxr.linux.no/linux+v2.6.28.1/arch/x86/include/asm/pgtable.h#L173) 和 [设置](http://lxr.linux.no/linux+v2.6.28.1/arch/x86/include/asm/pgtable.h#L230) PTE 条目中的每个标志位。标志位 P 告诉处理器这个虚拟页面是否**在**物理内存中。如果该位被清除（设置为 0），访问这个页面将触发一个页面故障。请记住，当这个标志位为 0 时，内核可以在剩余的域上**做任何想做的事**。R/W 标志位是读/写标志；如果被清除，这个页面将变成只读的。U/S 标志位表示用户/超级用户；如果被清除，这个页面将仅被内核访问。这些标志都是用于实现我们在前面看到的只读内存和内核空间保护。
标志位 D 和 A 用于标识页面是否是“**脏的**”或者是已**被访问过**。一个脏页面表示已经被写入，而一个被访问过的页面则表示有一个写入或者读取发生过。这两个标志位都是粘滞位：处理器只能设置它们，而清除则是由内核来完成的。最终，PTE 保存了这个页面相应的起始物理地址，它们按 4KB 进行整齐排列。这个看起来不起眼的域是一些痛苦的根源，因为它限制了物理内存最大为 [4 GB](http://www.google.com/search?hl=en&amp;amp;amp;amp;q=2%5E20+*+2%5E12+bytes+in+GB)。其它的 PTE 域留到下次再讲，因为它是涉及了物理地址扩展的知识。
由于在一个虚拟页面上的所有字节都共享一个 U/S 和 R/W 标志位，所以内存保护的最小单元是一个虚拟页面。但是，同一个物理内存可能被映射到不同的虚拟页面，这样就有可能会出现相同的物理内存出现不同的保护标志位的情况。请注意，在 PTE 中是看不到运行权限的。这就是为什么经典的 x86 页面上允许代码在栈上被执行的原因，这样会很容易导致挖掘出栈缓冲溢出漏洞（可能会通过使用 [return-to-libc](http://en.wikipedia.org/wiki/Return-to-libc_attack) 和其它技术来找出非可执行栈）。由于 PTE 缺少禁止运行标志位说明了一个更广泛的事实：在 VMA 中的权限标志位有可能或可能不完全转换为硬件保护。内核只能做它能做到的，但是，最终的架构限制了它能做的事情。
虚拟内存不保存任何东西，它只是简单地 *映射* 一个程序的地址空间到底层的物理内存上。物理内存被当作一个称之为**物理地址空间**的巨大块而由处理器访问。虽然内存的操作[涉及到某些](http://duartes.org/gustavo/blog/post/getting-physical-with-memory)总线，我们在这里先忽略它，并假设物理地址范围从 0 到可用的最大值按字节递增。物理地址空间被内核进一步分解为**页面帧**。处理器并不会关心帧的具体情况，这一点对内核也是至关重要的，因为，**页面帧是物理内存管理的最小单元**。Linux 和 Windows 在 32 位模式下都使用 4KB 大小的页面帧；下图是一个有 2 GB 内存的机器的例子：
在 Linux 上每个页面帧是被一个 [描述符](http://lxr.linux.no/linux+v2.6.28/include/linux/mm_types.h#L32) 和 [几个标志](http://lxr.linux.no/linux+v2.6.28/include/linux/page-flags.h#L14) 来跟踪的。通过这些描述符和标志，实现了对机器上整个物理内存的跟踪；每个页面帧的具体状态是公开的。物理内存是通过使用 [Buddy 内存分配](http://en.wikipedia.org/wiki/Buddy_memory_allocation) （LCTT 译注：一种内存分配算法）技术来管理的，因此，如果一个页面帧可以通过 Buddy 系统分配，那么它是**未分配的**（free）。一个被分配的页面帧可以是**匿名的**、持有程序数据的、或者它可能处于页面缓存中、持有数据保存在一个文件或者块设备中。还有其它的异形页面帧，但是这些异形页面帧现在已经不怎么使用了。Windows 有一个类似的页面帧号（Page Frame Number (PFN)）数据库去跟踪物理内存。
我们把虚拟内存区域（VMA）、页面表条目（PTE），以及页面帧放在一起来理解它们是如何工作的。下面是一个用户堆的示例：
蓝色的矩形框表示在 VMA 范围内的页面，而箭头表示页面表条目映射页面到页面帧。一些缺少箭头的虚拟页面，表示它们对应的 PTE 的当前标志位被清除（置为 0）。这可能是因为这个页面从来没有被使用过，或者是它的内容已经被交换出去了。在这两种情况下，即便这些页面在 VMA 中，访问它们也将导致产生一个页面故障。对于这种 VMA 和页面表的不一致的情况，看上去似乎很奇怪，但是这种情况却经常发生。
一个 VMA 像一个在你的程序和内核之间的合约。你请求它做一些事情（分配内存、文件映射、等等），内核会回应“收到”，然后去创建或者更新相应的 VMA。 但是，它 *并不立刻* 去“兑现”对你的承诺，而是它会等待到发生一个页面故障时才去 *真正* 做这个工作。内核是个“懒惰的家伙”、“不诚实的人渣”；这就是虚拟内存的基本原理。它适用于大多数的情况，有一些类似情况和有一些意外的情况，但是，它是规则是，VMA 记录 *约定的* 内容，而 PTE 才反映这个“懒惰的内核” *真正做了什么*。通过这两种数据结构共同来管理程序的内存；它们共同来完成解决页面故障、释放内存、从内存中交换出数据、等等。下图是内存分配的一个简单案例：
当程序通过 [brk()](http://www.kernel.org/doc/man-pages/online/pages/man2/brk.2.html) 系统调用来请求一些内存时，内核只是简单地 [更新](http://lxr.linux.no/linux+v2.6.28.1/mm/mmap.c#L2050) 堆的 VMA 并给程序回复“已搞定”。而在这个时候并没有真正地分配页面帧，并且新的页面也没有映射到物理内存上。一旦程序尝试去访问这个页面时，处理器将发生页面故障，然后调用 [do\_page\_fault()](http://lxr.linux.no/linux+v2.6.28/arch/x86/mm/fault.c#L583)。这个函数将使用 [find\_vma()](http://lxr.linux.no/linux+v2.6.28/mm/mmap.c#L1466) 去 [搜索](http://lxr.linux.no/linux+v2.6.28/arch/x86/mm/fault.c#L692) 发生页面故障的 VMA。如果找到了，然后在 VMA 上进行权限检查以防范恶意访问（读取或者写入）。如果没有合适的 VMA，也没有所尝试访问的内存的“合约”，将会给进程返回段故障。
当[找到](http://lxr.linux.no/linux+v2.6.28/arch/x86/mm/fault.c#L711)了一个合适的 VMA，内核必须通过查找 PTE 的内容和 VMA 的类型去[处理](http://lxr.linux.no/linux+v2.6.28/mm/memory.c#L2653)故障。在我们的案例中，PTE 显示这个页面是 [不存在的](http://lxr.linux.no/linux+v2.6.28/mm/memory.c#L2674)。事实上，我们的 PTE 是全部空白的（全部都是 0），在 Linux 中这表示虚拟内存还没有被映射。由于这是匿名 VMA，我们有一个完全的 RAM 事务，它必须被 [do\_anonymous\_page()](http://lxr.linux.no/linux+v2.6.28/mm/memory.c#L2681) 来处理，它分配页面帧，并且用一个 PTE 去映射故障虚拟页面到一个新分配的帧。
有时候，事情可能会有所不同。例如，对于被交换出内存的页面的 PTE，在当前（Present）标志位上是 0，但它并不是空白的。而是在交换位置仍有页面内容，它必须从磁盘上读取并且通过 [do\_swap\_page()](http://lxr.linux.no/linux+v2.6.28/mm/memory.c#L2280) 来加载到一个被称为 [major fault](http://lxr.linux.no/linux+v2.6.28/mm/memory.c#L2316) 的页面帧上。
这是我们通过探查内核的用户内存管理得出的前半部分的结论。在下一篇文章中，我们通过将文件加载到内存中，来构建一个完整的内存框架图，以及对性能的影响。
---
via: <http://duartes.org/gustavo/blog/post/how-the-kernel-manages-your-memory/>
作者：[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/) 荣誉推出
|
||
20 个 OpenSSH 最佳安全实践
|
Vivek Gite
|
https://www.cyberciti.biz/tips/linux-unix-bsd-openssh-server-best-practices.html
|
时不时会出现关于 OpenSSH 零日漏洞的传言。本文将描述如何设置你的 Linux 或类 Unix 系统以提高 sshd 的安全性。
|
/data/attachment/album/201802/28/154506wnfo36ipba3fxfya.jpg.thumb.jpg
|
/data/attachment/album/201802/28/154506wnfo36ipba3fxfya.jpg
| true | false | true |
shipsw
| true |
[
"SSH",
"OpenSSH"
] |
技术
|
{
"viewnum": 11847,
"commentnum": 0,
"favtimes": 9,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
时不时会出现关于 OpenSSH 零日漏洞的传言。本文将描述如何设置你的 Linux 或类 Unix 系统以提高 sshd 的安全性。
| 2018-02-28T15:45:00 | 2018-02-28T15:45:00 | 9,394 |
/article-9394-1.html
|
OpenSSH 是 SSH 协议的一个实现。一般通过 `scp` 或 `sftp` 用于远程登录、备份、远程文件传输等功能。SSH能够完美保障两个网络或系统间数据传输的保密性和完整性。尽管如此，它最大的优势是使用公匙加密来进行服务器验证。时不时会出现关于 OpenSSH 零日漏洞的[传言](https://isc.sans.edu/diary/OpenSSH+Rumors/6742)。本文将描述如何设置你的 Linux 或类 Unix 系统以提高 sshd 的安全性。
### OpenSSH 默认设置
* TCP 端口 - 22
* OpenSSH 服务配置文件 - `sshd_config` (位于 `/etc/ssh/`）
### 1、 基于公匙的登录
OpenSSH 服务支持各种验证方式。推荐使用公匙加密验证。首先，使用以下 `ssh-keygen` 命令在本地电脑上创建密匙对：
>
> 1024 位或低于它的 DSA 和 RSA 加密是很弱的，请不要使用。当考虑 ssh 客户端向后兼容性的时候，请使用 RSA密匙代替 ECDSA 密匙。所有的 ssh 密钥要么使用 ED25519 ，要么使用 RSA，不要使用其它类型。
>
>
>
```
$ ssh-keygen -t key_type -b bits -C "comment"
```
示例：
```
$ ssh-keygen -t ed25519 -C "Login to production cluster at xyz corp"
或
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa_aws_$(date +%Y-%m-%d) -C "AWS key for abc corp clients"
```
下一步，使用 `ssh-copy-id` 命令安装公匙：
```
$ ssh-copy-id -i /path/to/public-key-file user@host
或
$ ssh-copy-id user@remote-server-ip-or-dns-name
```
示例：
```
$ ssh-copy-id vivek@rhel7-aws-server
```
提示输入用户名和密码的时候，确认基于 ssh 公匙的登录是否工作：
```
$ ssh vivek@rhel7-aws-server
```
[](https://www.cyberciti.biz/tips/wp-content/uploads/2009/07/OpenSSH-server-security-best-practices.png)
更多有关 ssh 公匙的信息，参照以下文章：
* [为备份脚本设置无密码安全登录](https://www.cyberciti.biz/faq/ssh-passwordless-login-with-keychain-for-scripts/)
* [sshpass：使用脚本密码登录 SSH 服务器](/article-8086-1.html)
* [如何为一个 Linux/类 Unix 系统设置 SSH 登录密匙](https://www.cyberciti.biz/faq/how-to-set-up-ssh-keys-on-linux-unix/)
* [如何使用 Ansible 工具上传 ssh 登录授权公匙](https://www.cyberciti.biz/faq/how-to-upload-ssh-public-key-to-as-authorized_key-using-ansible/)
### 2、 禁用 root 用户登录
禁用 root 用户登录前，确认普通用户可以以 root 身份登录。例如，允许用户 vivek 使用 `sudo` 命令以 root 身份登录。
#### 在 Debian/Ubuntu 系统中如何将用户 vivek 添加到 sudo 组中
允许 sudo 组中的用户执行任何命令。 [将用户 vivek 添加到 sudo 组中](https://www.cyberciti.biz/faq/how-to-create-a-sudo-user-on-ubuntu-linux-server/)：
```
$ sudo adduser vivek sudo
```
使用 [id 命令](https://www.cyberciti.biz/faq/unix-linux-id-command-examples-usage-syntax/ "See Linux/Unix id command examples for more info") 验证用户组。
```
$ id vivek
```
#### 在 CentOS/RHEL 系统中如何将用户 vivek 添加到 sudo 组中
在 CentOS/RHEL 和 Fedora 系统中允许 wheel 组中的用户执行所有的命令。使用 `usermod` 命令将用户 vivek 添加到 wheel 组中：
```
$ sudo usermod -aG wheel vivek
$ id vivek
```
#### 测试 sudo 权限并禁用 ssh root 登录
测试并确保用户 vivek 可以以 root 身份登录执行以下命令：
```
$ sudo -i
$ sudo /etc/init.d/sshd status
$ sudo systemctl status httpd
```
添加以下内容到 `sshd_config` 文件中来禁用 root 登录：
```
PermitRootLogin no
ChallengeResponseAuthentication no
PasswordAuthentication no
UsePAM no
```
更多信息参见“[如何通过禁用 Linux 的 ssh 密码登录来增强系统安全](https://www.cyberciti.biz/faq/how-to-disable-ssh-password-login-on-linux/)” 。
### 3、 禁用密码登录
所有的密码登录都应该禁用，仅留下公匙登录。添加以下内容到 `sshd_config` 文件中：
```
AuthenticationMethods publickey
PubkeyAuthentication yes
```
CentOS 6.x/RHEL 6.x 系统中老版本的 sshd 用户可以使用以下设置：
```
PubkeyAuthentication yes
```
### 4、 限制用户的 ssh 访问
默认状态下，所有的系统用户都可以使用密码或公匙登录。但是有些时候需要为 FTP 或者 email 服务创建 UNIX/Linux 用户。然而，这些用户也可以使用 ssh 登录系统。他们将获得访问系统工具的完整权限，包括编译器和诸如 Perl、Python（可以打开网络端口干很多疯狂的事情）等的脚本语言。通过添加以下内容到 `sshd_config` 文件中来仅允许用户 root、vivek 和 jerry 通过 SSH 登录系统：
```
AllowUsers vivek jerry
```
当然，你也可以添加以下内容到 `sshd_config` 文件中来达到仅拒绝一部分用户通过 SSH 登录系统的效果。
```
DenyUsers root saroj anjali foo
```
你也可以通过[配置 Linux PAM](https://www.cyberciti.biz/tips/linux-pam-configuration-that-allows-or-deny-login-via-the-sshd-server.html) 来禁用或允许用户通过 sshd 登录。也可以允许或禁止一个[用户组列表](https://www.cyberciti.biz/tips/openssh-deny-or-restrict-access-to-users-and-groups.html)通过 ssh 登录系统。
### 5、 禁用空密码
你需要明确禁止空密码账户远程登录系统，更新 `sshd_config` 文件的以下内容：
```
PermitEmptyPasswords no
```
### 6、 为 ssh 用户或者密匙使用强密码
为密匙使用强密码和短语的重要性再怎么强调都不过分。暴力破解可以起作用就是因为用户使用了基于字典的密码。你可以强制用户避开[字典密码](https://www.cyberciti.biz/tips/linux-check-passwords-against-a-dictionary-attack.html)并使用[约翰的开膛手工具](https://www.cyberciti.biz/faq/unix-linux-password-cracking-john-the-ripper/)来检测弱密码。以下是一个随机密码生成器（放到你的 `~/.bashrc` 下）：
```
genpasswd() {
local l=$1
[ "$l" == "" ] && l=20
tr -dc A-Za-z0-9_ < /dev/urandom | head -c ${l} | xargs
}
```
运行：
```
genpasswd 16
```
输出：
```
uw8CnDVMwC6vOKgW
```
* [使用 mkpasswd / makepasswd / pwgen 生成随机密码](https://www.cyberciti.biz/faq/generating-random-password/)
* [Linux / UNIX: 生成密码](https://www.cyberciti.biz/faq/linux-unix-generating-passwords-command/)
* [Linux 随机密码生成命令](https://www.cyberciti.biz/faq/linux-random-password-generator/)
### 7、 为 SSH 的 22端口配置防火墙
你需要更新 `iptables`/`ufw`/`firewall-cmd` 或 pf 防火墙配置来为 ssh 的 TCP 端口 22 配置防火墙。一般来说，OpenSSH 服务应该仅允许本地或者其他的远端地址访问。
#### Netfilter（Iptables） 配置
更新 [/etc/sysconfig/iptables （Redhat 和其派生系统特有文件）](https://www.cyberciti.biz/faq/rhel-fedorta-linux-iptables-firewall-configuration-tutorial/) 实现仅接受来自于 192.168.1.0/24 和 202.54.1.5/29 的连接，输入：
```
-A RH-Firewall-1-INPUT -s 192.168.1.0/24 -m state --state NEW -p tcp --dport 22 -j ACCEPT
-A RH-Firewall-1-INPUT -s 202.54.1.5/29 -m state --state NEW -p tcp --dport 22 -j ACCEPT
```
如果同时使用 IPv6 的话，可以编辑 `/etc/sysconfig/ip6tables` （Redhat 和其派生系统特有文件），输入：
```
-A RH-Firewall-1-INPUT -s ipv6network::/ipv6mask -m tcp -p tcp --dport 22 -j ACCEPT
```
将 `ipv6network::/ipv6mask` 替换为实际的 IPv6 网段。
#### Debian/Ubuntu Linux 下的 UFW
[UFW 是 Uncomplicated FireWall 的首字母缩写，主要用来管理 Linux 防火墙](https://www.cyberciti.biz/faq/howto-configure-setup-firewall-with-ufw-on-ubuntu-linux/)，目的是提供一种用户友好的界面。输入[以下命令使得系统仅允许网段 202.54.1.5/29 接入端口 22](https://www.cyberciti.biz/faq/ufw-allow-incoming-ssh-connections-from-a-specific-ip-address-subnet-on-ubuntu-debian/)：
```
$ sudo ufw allow from 202.54.1.5/29 to any port 22
```
更多信息请参见 “[Linux：菜鸟管理员的 25 个 Iptables Netfilter 命令](https://www.cyberciti.biz/tips/linux-iptables-examples.html)”。
#### \*BSD PF 防火墙配置
如果使用 PF 防火墙 [/etc/pf.conf](https://bash.cyberciti.biz/firewall/pf-firewall-script/) 配置如下：
```
pass in on $ext_if inet proto tcp from {192.168.1.0/24, 202.54.1.5/29} to $ssh_server_ip port ssh flags S/SA synproxy state
```
### 8、 修改 SSH 端口和绑定 IP
ssh 默认监听系统中所有可用的网卡。修改并绑定 ssh 端口有助于避免暴力脚本的连接（许多暴力脚本只尝试端口 22）。更新文件 `sshd_config` 的以下内容来绑定端口 300 到 IP 192.168.1.5 和 202.54.1.5：
```
Port 300
ListenAddress 192.168.1.5
ListenAddress 202.54.1.5
```
当需要接受动态广域网地址的连接时，使用主动脚本是个不错的选择，比如 fail2ban 或 denyhosts。
### 9、 使用 TCP wrappers （可选的）
TCP wrapper 是一个基于主机的访问控制系统，用来过滤来自互联网的网络访问。OpenSSH 支持 TCP wrappers。只需要更新文件 `/etc/hosts.allow` 中的以下内容就可以使得 SSH 只接受来自于 192.168.1.2 和 172.16.23.12 的连接：
```
sshd : 192.168.1.2 172.16.23.12
```
在 Linux/Mac OS X 和类 UNIX 系统中参见 [TCP wrappers 设置和使用的常见问题](https://www.cyberciti.biz/faq/tcp-wrappers-hosts-allow-deny-tutorial/)。
### 10、 阻止 SSH 破解或暴力攻击
暴力破解是一种在单一或者分布式网络中使用大量（用户名和密码的）组合来尝试连接一个加密系统的方法。可以使用以下软件来应对暴力攻击：
* [DenyHosts](https://www.cyberciti.biz/faq/block-ssh-attacks-with-denyhosts/) 是一个基于 Python SSH 安全工具。该工具通过监控授权日志中的非法登录日志并封禁原始 IP 的方式来应对暴力攻击。
+ RHEL / Fedora 和 CentOS Linux 下如何设置 [DenyHosts](https://www.cyberciti.biz/faq/rhel-linux-block-ssh-dictionary-brute-force-attacks/)。
* [Fail2ban](https://www.fail2ban.org) 是另一个类似的用来预防针对 SSH 攻击的工具。
* [sshguard](https://sshguard.sourceforge.net/) 是一个使用 pf 来预防针对 SSH 和其他服务攻击的工具。
* [security/sshblock](http://www.bsdconsulting.no/tools/) 阻止滥用 SSH 尝试登录。
* [IPQ BDB filter](https://savannah.nongnu.org/projects/ipqbdb/) 可以看做是 fail2ban 的一个简化版。
### 11、 限制 TCP 端口 22 的传入速率（可选的）
netfilter 和 pf 都提供速率限制选项可以对端口 22 的传入速率进行简单的限制。
#### Iptables 示例
以下脚本将会阻止 60 秒内尝试登录 5 次以上的客户端的连入。
```
#!/bin/bash
inet_if=eth1
ssh_port=22
$IPT -I INPUT -p tcp --dport ${ssh_port} -i ${inet_if} -m state --state NEW -m recent --set
$IPT -I INPUT -p tcp --dport ${ssh_port} -i ${inet_if} -m state --state NEW -m recent --update --seconds 60 --hitcount 5
```
在你的 iptables 脚本中调用以上脚本。其他配置选项：
```
$IPT -A INPUT -i ${inet_if} -p tcp --dport ${ssh_port} -m state --state NEW -m limit --limit 3/min --limit-burst 3 -j ACCEPT
$IPT -A INPUT -i ${inet_if} -p tcp --dport ${ssh_port} -m state --state ESTABLISHED -j ACCEPT
$IPT -A OUTPUT -o ${inet_if} -p tcp --sport ${ssh_port} -m state --state ESTABLISHED -j ACCEPT
# another one line example
# $IPT -A INPUT -i ${inet_if} -m state --state NEW,ESTABLISHED,RELATED -p tcp --dport 22 -m limit --limit 5/minute --limit-burst 5-j ACCEPT
```
其他细节参见 iptables 用户手册。
#### \*BSD PF 示例
以下脚本将限制每个客户端的连入数量为 20，并且 5 秒内的连接不超过 15 个。如果客户端触发此规则，则将其加入 abusive\_ips 表并限制该客户端连入。最后 flush 关键词杀死所有触发规则的客户端的连接。
```
sshd_server_ip = "202.54.1.5"
table <abusive_ips> persist
block in quick from <abusive_ips>
pass in on $ext_if proto tcp to $sshd_server_ip port ssh flags S/SA keep state (max-src-conn 20, max-src-conn-rate 15/5, overload <abusive_ips> flush)
```
### 12、 使用端口敲门（可选的）
[端口敲门](https://en.wikipedia.org/wiki/Port_knocking)是通过在一组预先指定的封闭端口上生成连接尝试，以便从外部打开防火墙上的端口的方法。一旦指定的端口连接顺序被触发，防火墙规则就被动态修改以允许发送连接的主机连入指定的端口。以下是一个使用 iptables 实现的端口敲门的示例：
```
$IPT -N stage1
$IPT -A stage1 -m recent --remove --name knock
$IPT -A stage1 -p tcp --dport 3456 -m recent --set --name knock2
$IPT -N stage2
$IPT -A stage2 -m recent --remove --name knock2
$IPT -A stage2 -p tcp --dport 2345 -m recent --set --name heaven
$IPT -N door
$IPT -A door -m recent --rcheck --seconds 5 --name knock2 -j stage2
$IPT -A door -m recent --rcheck --seconds 5 --name knock -j stage1
$IPT -A door -p tcp --dport 1234 -m recent --set --name knock
$IPT -A INPUT -m --state ESTABLISHED,RELATED -j ACCEPT
$IPT -A INPUT -p tcp --dport 22 -m recent --rcheck --seconds 5 --name heaven -j ACCEPT
$IPT -A INPUT -p tcp --syn -j door
```
更多信息请参见：
[Debian / Ubuntu: 使用 Knockd and Iptables 设置端口敲门](https://www.cyberciti.biz/faq/debian-ubuntu-linux-iptables-knockd-port-knocking-tutorial/)
### 13、 配置空闲超时注销时长
用户可以通过 ssh 连入服务器，可以配置一个超时时间间隔来避免无人值守的 ssh 会话。 打开 `sshd_config` 并确保配置以下值：
```
ClientAliveInterval 300
ClientAliveCountMax 0
```
以秒为单位设置一个空闲超时时间（300秒 = 5分钟）。一旦空闲时间超过这个值，空闲用户就会被踢出会话。更多细节参见[如何自动注销空闲超时的 BASH / TCSH / SSH 用户](https://www.cyberciti.biz/faq/linux-unix-login-bash-shell-force-time-outs/)。
### 14、 为 ssh 用户启用警示标语
更新 `sshd_config` 文件如下行来设置用户的警示标语：
```
Banner /etc/issue
```
`/etc/issue 示例文件：
```
----------------------------------------------------------------------------------------------
You are accessing a XYZ Government (XYZG) Information System (IS) that is provided for authorized use only.
By using this IS (which includes any device attached to this IS), you consent to the following conditions:
+ The XYZG routinely intercepts and monitors communications on this IS for purposes including, but not limited to,
penetration testing, COMSEC monitoring, network operations and defense, personnel misconduct (PM),
law enforcement (LE), and counterintelligence (CI) investigations.
+ At any time, the XYZG may inspect and seize data stored on this IS.
+ Communications using, or data stored on, this IS are not private, are subject to routine monitoring,
interception, and search, and may be disclosed or used for any XYZG authorized purpose.
+ This IS includes security measures (e.g., authentication and access controls) to protect XYZG interests--not
for your personal benefit or privacy.
+ Notwithstanding the above, using this IS does not constitute consent to PM, LE or CI investigative searching
or monitoring of the content of privileged communications, or work product, related to personal representation
or services by attorneys, psychotherapists, or clergy, and their assistants. Such communications and work
product are private and confidential. See User Agreement for details.
----------------------------------------------------------------------------------------------
```
以上是一个标准的示例，更多的用户协议和法律细节请咨询你的律师团队。
### 15、 禁用 .rhosts 文件（需核实）
禁止读取用户的 `~/.rhosts` 和 `~/.shosts` 文件。更新 `sshd_config` 文件中的以下内容：
```
IgnoreRhosts yes
```
SSH 可以模拟过时的 rsh 命令，所以应该禁用不安全的 RSH 连接。
### 16、 禁用基于主机的授权（需核实）
禁用基于主机的授权，更新 `sshd_config` 文件的以下选项：
```
HostbasedAuthentication no
```
### 17、 为 OpenSSH 和操作系统打补丁
推荐你使用类似 [yum](https://www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/)、[apt-get](https://www.cyberciti.biz/tips/linux-debian-package-management-cheat-sheet.html) 和 [freebsd-update](https://www.cyberciti.biz/tips/howto-keep-freebsd-system-upto-date.html) 等工具保持系统安装了最新的安全补丁。
### 18、 Chroot OpenSSH （将用户锁定在主目录）
默认设置下用户可以浏览诸如 `/etc`、`/bin` 等目录。可以使用 chroot 或者其他专有工具如 [rssh](https://www.cyberciti.biz/tips/rhel-centos-linux-install-configure-rssh-shell.html) 来保护 ssh 连接。从版本 4.8p1 或 4.9p1 起，OpenSSH 不再需要依赖诸如 rssh 或复杂的 chroot(1) 等第三方工具来将用户锁定在主目录中。可以使用新的 `ChrootDirectory` 指令将用户锁定在其主目录，参见[这篇博文](https://www.debian-administration.org/articles/590)。
### 19. 禁用客户端的 OpenSSH 服务
工作站和笔记本不需要 OpenSSH 服务。如果不需要提供 ssh 远程登录和文件传输功能的话，可以禁用 sshd 服务。CentOS / RHEL 用户可以使用 [yum 命令](https://www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/ "See Linux/Unix yum command examples for more info") 禁用或删除 openssh-server：
```
$ sudo yum erase openssh-server
```
Debian / Ubuntu 用户可以使用 [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") 删除 openssh-server：
```
$ sudo apt-get remove openssh-server
```
有可能需要更新 iptables 脚本来移除 ssh 的例外规则。CentOS / RHEL / Fedora 系统可以编辑文件 `/etc/sysconfig/iptables` 和 `/etc/sysconfig/ip6tables`。最后[重启 iptables](https://www.cyberciti.biz/faq/howto-rhel-linux-open-port-using-iptables/) 服务：
```
# service iptables restart
# service ip6tables restart
```
### 20. 来自 Mozilla 的额外提示
如果使用 6.7+ 版本的 OpenSSH，可以尝试下[以下设置](https://wiki.mozilla.org/Security/Guidelines/OpenSSH)：
```
#################[ WARNING ]########################
# Do not use any setting blindly. Read sshd_config #
# man page. You must understand cryptography to #
# tweak following settings. Otherwise use defaults #
####################################################
# Supported HostKey algorithms by order of preference.
HostKey /etc/ssh/ssh_host_ed25519_key
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key
# Specifies the available KEX (Key Exchange) algorithms.
KexAlgorithms curve25519-sha256@libssh.org,ecdh-sha2-nistp521,ecdh-sha2-nistp384,ecdh-sha2-nistp256,diffie-hellman-group-exchange-sha256
# Specifies the ciphers allowed
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com,aes256-ctr,aes192-ctr,aes128-ctr
#Specifies the available MAC (message authentication code) algorithms
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512,hmac-sha2-256,umac-128@openssh.com
# LogLevel VERBOSE logs user's key fingerprint on login. Needed to have a clear audit track of which key was using to log in.
LogLevel VERBOSE
# Log sftp level file access (read/write/etc.) that would not be easily logged otherwise.
Subsystem sftp /usr/lib/ssh/sftp-server -f AUTHPRIV -l INFO
```
使用以下命令获取 OpenSSH 支持的加密方法：
```
$ ssh -Q cipher
$ ssh -Q cipher-auth
$ ssh -Q mac
$ ssh -Q kex
$ ssh -Q key
```
[](https://www.cyberciti.biz/tips/wp-content/uploads/2009/07/OpenSSH-Security-Tutorial-Query-Ciphers-and-algorithms-choice.jpg)
### 如何测试 sshd\_config 文件并重启/重新加载 SSH 服务？
在重启 sshd 前检查配置文件的有效性和密匙的完整性，运行：
```
$ sudo sshd -t
```
扩展测试模式：
```
$ sudo sshd -T
```
最后，根据系统的的版本[重启 Linux 或类 Unix 系统中的 sshd 服务](https://www.cyberciti.biz/faq/howto-restart-ssh/)：
```
$ [sudo systemctl start ssh][38] ## Debian/Ubunt Linux##
$ [sudo systemctl restart sshd.service][39] ## CentOS/RHEL/Fedora Linux##
$ doas /etc/rc.d/sshd restart ## OpenBSD##
$ sudo service sshd restart ## FreeBSD##
```
### 其他建议
1. [使用 2FA 加强 SSH 的安全性](https://www.cyberciti.biz/open-source/howto-protect-linux-ssh-login-with-google-authenticator/) - 可以使用 [OATH Toolkit](http://www.nongnu.org/oath-toolkit/) 或 [DuoSecurity](https://duo.com) 启用多重身份验证。
2. [基于密匙链的身份验证](https://www.cyberciti.biz/faq/ssh-passwordless-login-with-keychain-for-scripts/) - 密匙链是一个 bash 脚本，可以使得基于密匙的验证非常的灵活方便。相对于无密码密匙，它提供更好的安全性。
### 更多信息
* [OpenSSH 官方](https://www.openssh.com/) 项目。
* 用户手册: sshd(8)、ssh(1)、ssh-add(1)、ssh-agent(1)。
如果知道这里没用提及的方便的软件或者技术，请在下面的评论中分享，以帮助读者保持 OpenSSH 的安全。
### 关于作者
作者是 nixCraft 的创始人，一个经验丰富的系统管理员和 Linux/Unix 脚本培训师。他曾与全球客户合作，领域涉及 IT，教育，国防和空间研究以及非营利部门等多个行业。请在 [Twitter](https://twitter.com/nixcraft)、[Facebook](https://facebook.com/nixcraft)、[Google+](https://plus.google.com/+CybercitiBiz) 上关注他。
---
via: <https://www.cyberciti.biz/tips/linux-unix-bsd-openssh-server-best-practices.html>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[shipsw](https://github.com/shipsw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 上安装必应桌面墙纸更换器
|
2daygeek
|
https://www.2daygeek.com/bing-desktop-wallpaper-changer-linux-bing-photo-of-the-day/
|
你是否厌倦了 Linux 桌面背景，想要设置好看的壁纸，但是不知道在哪里可以找到？别担心，我们在这里会帮助你。
|
/data/attachment/album/201803/01/084118qz64v2k494vs0ynn.jpg.thumb.jpg
|
/data/attachment/album/201803/01/084118qz64v2k494vs0ynn.jpg
| true | false | true |
MjSeven
| false |
[
"墙纸",
"bing"
] |
桌面应用
|
{
"viewnum": 11345,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你是否厌倦了 Linux 桌面背景，想要设置好看的壁纸，但是不知道在哪里可以找到？别担心，我们在这里会帮助你。
| 2018-02-28T23:16:00 | 2018-02-28T23:16:00 | 9,395 |
/article-9395-1.html
|
你是否厌倦了 Linux 桌面背景，想要设置好看的壁纸，但是不知道在哪里可以找到？别担心，我们在这里会帮助你。
我们都知道必应搜索引擎，但是由于一些原因很少有人使用它，每个人都喜欢必应网站的背景壁纸，它是非常漂亮和惊人的高分辨率图像。
如果你想使用这些图片作为你的桌面壁纸，你可以手动下载它，但是很难去每天下载一个新的图片，然后把它设置为壁纸。这就是自动壁纸改变的地方。
[必应桌面墙纸更换器](https://github.com/UtkarshGpta/bing-desktop-wallpaper-changer)会自动下载并将桌面壁纸更改为当天的必应照片。所有的壁纸都储存在 `/home/[user]/Pictures/BingWallpapers/`。
### 方法 1: 使用 Utkarsh Gupta Shell 脚本
这个小型 Python 脚本会自动下载并将桌面壁纸更改为当天的必应照片。该脚本在机器启动时自动运行，并工作于 GNU/Linux 上的 Gnome 或 Cinnamon 环境。它不需要手动工作，安装程序会为你做所有事情。
从 2.0+ 版本开始，该脚本的安装程序就可以像普通的 Linux 二进制命令一样工作，它会为某些任务请求 sudo 权限。
只需克隆仓库并切换到项目目录，然后运行 shell 脚本即可安装必应桌面墙纸更换器。
```
$ curl https://github.com/UtkarshGpta/bing-desktop-wallpaper-changer/archive/master.zip
$ unzip master
$ cd bing-desktop-wallpaper-changer-master
```
运行 `installer.sh` 使用 `--install` 选项来安装必应桌面墙纸更换器。它会下载并设置必应照片为你的 Linux 桌面。
```
$ ./installer.sh --install
Bing-Desktop-Wallpaper-Changer
BDWC Installer v3_beta2
GitHub:
Contributors:
.
.
[sudo] password for daygeek: ******
.
Where do you want to install Bing-Desktop-Wallpaper-Changer?
Entering 'opt' or leaving input blank will install in /opt/bing-desktop-wallpaper-changer
Entering 'home' will install in /home/daygeek/bing-desktop-wallpaper-changer
Install Bing-Desktop-Wallpaper-Changer in (opt/home)? :Press Enter
Should we create bing-desktop-wallpaper-changer symlink to /usr/bin/bingwallpaper so you could easily execute it?
Create symlink for easy execution, e.g. in Terminal (y/n)? : y
Should bing-desktop-wallpaper-changer needs to autostart when you log in? (Add in Startup Application)
Add in Startup Application (y/n)? : y
.
.
Executing bing-desktop-wallpaper-changer...
Finished!!
```
要卸载该脚本：
```
$ ./installer.sh --uninstall
```
使用帮助页面了解更多关于此脚本的选项。
```
$ ./installer.sh --help
```
### 方法 2: 使用 GNOME Shell 扩展
这个轻量级 [GNOME shell 扩展](https://github.com/neffo/bing-wallpaper-gnome-extension)，可将你的壁纸每天更改为微软必应的壁纸。它还会显示一个包含图像标题和解释的通知。
该扩展大部分基于 Elinvention 的 NASA APOD 扩展，受到了 Utkarsh Gupta 的 Bing Desktop WallpaperChanger 启发。
#### 特点
* 获取当天的必应壁纸并设置为锁屏和桌面墙纸（这两者都是用户可选的）
* 可强制选择某个特定区域（即地区）
* 为多个显示器自动选择最高分辨率（和最合适的墙纸）
* 可以选择在 1 到 7 天之后清理墙纸目录（删除最旧的）
* 只有当它们被更新时，才会尝试下载壁纸
* 不会持续进行更新 - 每天只进行一次，启动时也要进行一次（更新是在必应更新时进行的）
#### 如何安装
访问 [extenisons.gnome.org](https://extensions.gnome.org/extension/1262/bing-wallpaper-changer/) 网站并将切换按钮拖到 “ON”，然后点击 “Install” 按钮安装必应壁纸 GNOME 扩展。（LCTT 译注：页面上并没有发现 ON 按钮，但是有 Download 按钮）
安装必应壁纸 GNOME 扩展后，它会自动下载并为你的 Linux 桌面设置当天的必应照片，并显示关于壁纸的通知。
托盘指示器将帮助你执行少量操作，也可以打开设置。
根据你的要求自定义设置。
---
via: <https://www.2daygeek.com/bing-desktop-wallpaper-changer-linux-bing-photo-of-the-day/>
作者：[2daygeek](https://www.2daygeek.com/author/2daygeek/) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何提供有帮助的回答
|
Julia Evans
|
https://jvns.ca/blog/answer-questions-well/
|
如果你的同事问你一个不太清晰的问题，你会怎么回答？我认为提问题是一种技巧（可以看 如何提出有意义的问题) ，同时，合理地回答问题也是一种技巧，它们都是非常实用的。
|
/data/attachment/album/201803/01/221013ne4xe2wc4lc8g1le.jpg.thumb.jpg
|
/data/attachment/album/201803/01/221013ne4xe2wc4lc8g1le.jpg
| true | false | true |
HardworkFish
| false |
[
"提问",
"回答"
] |
观点
|
{
"viewnum": 2870,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
如果你的同事问你一个不太清晰的问题，你会怎么回答？我认为提问题是一种技巧（可以看 如何提出有意义的问题) ，同时，合理地回答问题也是一种技巧，它们都是非常实用的。
| 2018-03-01T22:10:18 | 2018-03-01T22:10:18 | 9,396 |
/article-9396-1.html
|
如果你的同事问你一个不太清晰的问题，你会怎么回答？我认为提问题是一种技巧（可以看 [如何提出有意义的问题](https://jvns.ca/blog/good-questions/)) ，同时，合理地回答问题也是一种技巧，它们都是非常实用的。
一开始 —— 有时向你提问的人不尊重你的时间，这很糟糕。理想情况下，我们假设问你问题的人是一个理性的人并且正在尽力解决问题，而你想帮助他们。和我一起工作的人是这样，我所生活的世界也是这样。当然，现实生活并不是这样。
下面是有助于回答问题的一些方法！
### 如果他们的提问不清楚，帮他们澄清
通常初学者不会提出很清晰的问题，或者问一些对回答问题没有必要信息的问题。你可以尝试以下方法 澄清问题：
* **重述为一个更明确的问题**来回复他们（“你是想问 X 吗？”)
* **向他们了解更具体的他们并没有提供的信息** （“你使用 IPv6 ?”）
* **问是什么导致了他们的问题**。例如，有时有些人会进入我的团队频道，询问我们的<ruby> 服务发现 <rt> service discovery </rt></ruby>如何工作的。这通常是因为他们试图设置/重新配置服务。在这种情况下，如果问“你正在使用哪种服务？可以给我看看你正在处理的‘拉取请求’吗？”是有帮助的。
这些方法很多来自[如何提出有意义的问题](https://jvns.ca/blog/good-questions/)中的要点。（尽管我永远不会对某人说“噢，你得先看完《如何提出有意义的问题》这篇文章后再来向我提问）
### 弄清楚他们已经知道了什么
在回答问题之前，知道对方已经知道什么是非常有用的！
Harold Treen 给了我一个很好的例子：
>
> 前几天，有人请我解释 “Redux-Sagas”。与其深入解释，不如说 “它们就像监听 action 的工人线程，并可以让你更新 Redux store。
>
>
> 我开始搞清楚他们对 Redux、action、store 以及其他基本概念了解多少。将这些概念都联系在一起再来解释会容易得多。
>
>
>
弄清楚问你问题的人已经知道什么是非常重要的。因为有时他们可能会对基础概念感到疑惑（“Redux 是什么？”），或者他们可能是专家，但是恰巧遇到了微妙的<ruby> 极端情况 <rt> corner case </rt></ruby>。如果答案建立在他们不知道的概念上会令他们困惑，但如果重述他们已经知道的的又会是乏味的。
这里有一个很实用的技巧来了解他们已经知道什么 - 比如可以尝试用“你对 X 了解多少？”而不是问“你知道 X 吗？”。
### 给他们一个文档
“RTFM” （<ruby> “去读那些他妈的手册” <rt> Read The Fucking Manual </rt></ruby>）是一个典型的无用的回答，但事实上如果向他们指明一个特定的文档会是非常有用的！当我提问题的时候，我当然很乐意翻看那些能实际解决我的问题的文档，因为它也可能解决其他我想问的问题。
我认为明确你所给的文档的确能够解决问题是非常重要的，或者至少经过查阅后确认它对解决问题有帮助。否则，你可能将以下面这种情形结束对话（非常常见）：
* Ali：我应该如何处理 X ？
* Jada：<文档链接>
* Ali: 这个没有实际解释如何处理 X ，它仅仅解释了如何处理 Y !
如果我所给的文档特别长，我会指明文档中那个我将会谈及的特定部分。[bash 手册](https://linux.die.net/man/1/bash) 有 44000 个字（真的！），所以如果只说“它在 bash 手册中有说明”是没有帮助的 :)
### 告诉他们一个有用的搜索
在工作中，我经常发现我可以利用我所知道的关键字进行搜索来找到能够解决我的问题的答案。对于初学者来说，这些关键字往往不是那么明显。所以说“这是我用来寻找这个答案的搜索”可能有用些。再次说明，回答时请经检查后以确保搜索能够得到他们所需要的答案 :)
### 写新文档
人们经常一次又一次地问我的团队同样的问题。很显然这并不是他们的错（他们怎么能够知道在他们之前已经有 10 个人问了这个问题，且知道答案是什么呢？）因此，我们会尝试写新文档，而不是直接回答回答问题。
1. 马上写新文档
2. 给他们我们刚刚写好的新文档
3. 公示
写文档有时往往比回答问题需要花很多时间，但这是值得的。写文档尤其重要，如果：
a. 这个问题被问了一遍又一遍 b. 随着时间的推移，这个答案不会变化太大（如果这个答案每一个星期或者一个月就会变化，文档就会过时并且令人受挫）
### 解释你做了什么
对于一个话题，作为初学者来说，这样的交流会真让人沮丧：
* 新人：“嗨！你如何处理 X ？”
* 有经验的人：“我已经处理过了，而且它已经完美解决了”
* 新人：”...... 但是你做了什么？！“
如果问你问题的人想知道事情是如何进行的，这样是有帮助的：
* 让他们去完成任务而不是自己做
* 告诉他们你是如何得到你给他们的答案的。
这可能比你自己做的时间还要长，但对于被问的人来说这是一个学习机会，因为那样做使得他们将来能够更好地解决问题。
这样，你可以进行更好的交流，像这：
* 新人：“这个网站出现了错误，发生了什么？”
* 有经验的人：（2分钟后）“oh 这是因为发生了数据库故障转移”
* 新人： “你是怎么知道的？？！？！？”
* 有经验的人：“以下是我所做的！”：
1. 通常这些错误是因为服务器 Y 被关闭了。我查看了一下 `$PLACE` 但它表明服务器 Y 开着。所以，并不是这个原因导致的。
2. 然后我查看 X 的仪表盘 ，仪表盘的这个部分显示这里发生了数据库故障转移。
3. 然后我在日志中找到了相应服务器，并且它显示连接数据库错误，看起来错误就是这里。
如果你正在解释你是如何调试一个问题，解释你是如何发现问题，以及如何找出问题的。尽管看起来你好像已经得到正确答案，但感觉更好的是能够帮助他们提高学习和诊断能力，并了解可用的资源。
### 解决根本问题
这一点有点棘手。有时候人们认为他们依旧找到了解决问题的正确途径，且他们只要再多一点信息就可以解决问题。但他们可能并不是走在正确的道路上！比如：
* George：“我在处理 X 的时候遇到了错误，我该如何修复它？”
* Jasminda：“你是正在尝试解决 Y 吗？如果是这样，你不应该处理 X ，反而你应该处理 Z 。”
* George：“噢，你是对的！！！谢谢你！我回反过来处理 Z 的。”
Jasminda 一点都没有回答 George 的问题！反而，她猜测 George 并不想处理 X ，并且她是猜对了。这是非常有用的！
如果你这样做可能会产生高高在上的感觉：
* George：“我在处理 X 的时候遇到了错误，我该如何修复它？”
* Jasminda：“不要这样做，如果你想处理 Y ，你应该反过来完成 Z 。”
* George：“好吧，我并不是想处理 Y 。实际上我想处理 X 因为某些原因（REASONS）。所以我该如何处理 X 。”
所以不要高高在上，且要记住有时有些提问者可能已经偏离根本问题很远了。同时回答提问者提出的问题以及他们本该提出的问题都是合理的：“嗯，如果你想处理 X ，那么你可能需要这么做，但如果你想用这个解决 Y 问题，可能通过处理其他事情你可以更好地解决这个问题，这就是为什么可以做得更好的原因。”
### 询问“那个回答可以解决您的问题吗？”
我总是喜欢在我回答了问题之后核实是否真的已经解决了问题：“这个回答解决了您的问题吗？您还有其他问题吗？”在问完这个之后最好等待一会，因为人们通常需要一两分钟来知道他们是否已经找到了答案。
我发现尤其是问“这个回答解决了您的问题吗”这个额外的步骤在写完文档后是非常有用的。通常，在写关于我熟悉的东西的文档时，我会忽略掉重要的东西而不会意识到它。
### 结对编程和面对面交谈
我是远程工作的，所以我的很多对话都是基于文本的。我认为这是沟通的默认方式。
今天，我们生活在一个方便进行小视频会议和屏幕共享的世界！在工作时候，在任何时间我都可以点击一个按钮并快速加入与他人的视频对话或者屏幕共享的对话中！
例如，最近有人问如何自动调节他们的服务容量规划。我告诉他们我们有几样东西需要清理，但我还不太确定他们要清理的是什么。然后我们进行了一个简短的视频会话并在 5 分钟后，我们解决了他们问题。
我认为，特别是如果有人真的被困在该如何开始一项任务时，开启视频进行结对编程几分钟真的比电子邮件或者一些即时通信更有效。
### 不要表现得过于惊讶
这是源自 Recurse Center 的一则法则：[不要故作惊讶](https://jvns.ca/blog/2017/04/27/no-feigning-surprise/)。这里有一个常见的情景：
* 某甲：“什么是 Linux 内核”
* 某乙：“你竟然不知道什么是 Linux 内核？！！！！？！！！？？？？”
某乙的表现（无论他们是否真的如此惊讶）是没有帮助的。这大部分只会让某甲不好受，因为他们确实不知道什么是 Linux 内核。
我一直在假装不惊讶，即使我事实上确实有点惊讶那个人不知道这种东西。
### 回答问题真的很棒
显然并不是所有方法都是合适的，但希望你能够发现这里有些是有帮助的！我发现花时间去回答问题并教导人们是其实是很有收获的。
特别感谢 Josh Triplett 的一些建议并做了很多有益的补充，以及感谢 Harold Treen、Vaibhav Sagar、Peter Bhat Hatkins、Wesley Aptekar Cassels 和 Paul Gowder 的阅读或评论。
---
via: <https://jvns.ca/blog/answer-questions-well/>
作者：[Julia Evans](https://jvns.ca/about) 译者：[HardworkFish](https://github.com/HardworkFish) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
并发服务器（四）：libuv
|
Eli Bendersky
|
https://eli.thegreenplace.net/2017/concurrent-servers-part-4-libuv/
|
在这一部分中，我们将使用 libuv 再次重写我们的服务器，并且也会讨论关于使用一个线程池在回调中去处理耗时任务。
|
/data/attachment/album/201803/02/012014luutflxu75l56ffn.jpg.thumb.jpg
|
/data/attachment/album/201803/02/012014luutflxu75l56ffn.jpg
| true | false | true |
qhwdw
| false |
[
"并发"
] |
软件开发
|
{
"viewnum": 14522,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "123.161.208.16",
"message": ""当所有回调运行时，除了 main，其它的都运行在栈上" 翻译错了吧",
"username": "来自河南郑州的 Chrome 90.0|Mac 10.15 用户",
"date": "2021-04-20T16:03:59"
}
] |
[
{
"raid": 9117,
"displayorder": 0
},
{
"raid": 9417,
"displayorder": 0
}
] |
在这一部分中，我们将使用 libuv 再次重写我们的服务器，并且也会讨论关于使用一个线程池在回调中去处理耗时任务。
| 2018-03-02T01:20:53 | 2018-03-02T01:20:53 | 9,397 |
/article-9397-1.html
|
这是并发网络服务器系列文章的第四部分。在这一部分中，我们将使用 libuv 再次重写我们的服务器，并且也会讨论关于使用一个线程池在回调中去处理耗时任务。最终，我们去看一下底层的 libuv，花一点时间去学习如何用异步 API 对文件系统阻塞操作进行封装。
本系列的所有文章：
* [第一节 - 简介](/article-8993-1.html)
* [第二节 - 线程](/article-9002-1.html)
* [第三节 - 事件驱动](/article-9117-1.html)
* [第四节 - libuv](http://eli.thegreenplace.net/2017/concurrent-servers-part-4-libuv/)
### 使用 libuv 抽象出事件驱动循环
在 [第三节](/article-9117-1.html) 中，我们看到了基于 `select` 和 `epoll` 的服务器的相似之处，并且，我说过，在它们之间抽象出细微的差别是件很有吸引力的事。许多库已经做到了这些，所以在这一部分中我将去选一个并使用它。我选的这个库是 [libuv](http://libuv.org/)，它最初设计用于 Node.js 底层的可移植平台层，并且，后来发现在其它的项目中也有使用。libuv 是用 C 写的，因此，它具有很高的可移植性，非常适用嵌入到像 JavaScript 和 Python 这样的高级语言中。
虽然 libuv 为了抽象出底层平台细节已经变成了一个相当大的框架，但它仍然是以 *事件循环* 思想为中心的。在我们第三部分的事件驱动服务器中，事件循环是显式定义在 `main` 函数中的；当使用 libuv 时，该循环通常隐藏在库自身中，而用户代码仅需要注册事件句柄（作为一个回调函数）和运行这个循环。此外，libuv 会在给定的平台上使用更快的事件循环实现，对于 Linux 它是 `epoll`，等等。
libuv 支持多路事件循环，因此事件循环在库中是非常重要的；它有一个句柄 —— `uv_loop_t`，以及创建/杀死/启动/停止循环的函数。也就是说，在这篇文章中，我将仅需要使用 “默认的” 循环，libuv 可通过 `uv_default_loop()` 提供它；多路循环大多用于多线程事件驱动的服务器，这是一个更高级别的话题，我将留在这一系列文章的以后部分。
### 使用 libuv 的并发服务器
为了对 libuv 有一个更深的印象，让我们跳转到我们的可靠协议的服务器，它通过我们的这个系列已经有了一个强大的重新实现。这个服务器的结构与第三部分中的基于 `select` 和 `epoll` 的服务器有一些相似之处，因为，它也依赖回调。完整的 [示例代码在这里](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/uv-server.c)；我们开始设置这个服务器的套接字绑定到一个本地端口：
```
int portnum = 9090;
if (argc >= 2) {
portnum = atoi(argv[1]);
}
printf("Serving on port %d\n", portnum);
int rc;
uv_tcp_t server_stream;
if ((rc = uv_tcp_init(uv_default_loop(), &server_stream)) < 0) {
die("uv_tcp_init failed: %s", uv_strerror(rc));
}
struct sockaddr_in server_address;
if ((rc = uv_ip4_addr("0.0.0.0", portnum, &server_address)) < 0) {
die("uv_ip4_addr failed: %s", uv_strerror(rc));
}
if ((rc = uv_tcp_bind(&server_stream, (const struct sockaddr*)&server_address, 0)) < 0) {
die("uv_tcp_bind failed: %s", uv_strerror(rc));
}
```
除了它被封装进 libuv API 中之外，你看到的是一个相当标准的套接字。在它的返回中，我们取得了一个可工作于任何 libuv 支持的平台上的可移植接口。
这些代码也展示了很认真负责的错误处理；多数的 libuv 函数返回一个整数状态，返回一个负数意味着出现了一个错误。在我们的服务器中，我们把这些错误看做致命问题进行处理，但也可以设想一个更优雅的错误恢复。
现在，那个套接字已经绑定，是时候去监听它了。这里我们运行首个回调注册：
```
// Listen on the socket for new peers to connect. When a new peer connects,
// the on_peer_connected callback will be invoked.
if ((rc = uv_listen((uv_stream_t*)&server_stream, N_BACKLOG, on_peer_connected)) < 0) {
die("uv_listen failed: %s", uv_strerror(rc));
}
```
`uv_listen` 注册一个事件回调，当新的对端连接到这个套接字时将会调用事件循环。我们的回调在这里被称为 `on_peer_connected`，我们一会儿将去查看它。
最终，`main` 运行这个 libuv 循环，直到它被停止（`uv_run` 仅在循环被停止或者发生错误时返回）。
```
// Run the libuv event loop.
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
// If uv_run returned, close the default loop before exiting.
return uv_loop_close(uv_default_loop());
```
注意，在运行事件循环之前，只有一个回调是通过 `main` 注册的；我们稍后将看到怎么去添加更多的回调。在事件循环的整个运行过程中，添加和删除回调并不是一个问题 —— 事实上，大多数服务器就是这么写的。
这是一个 `on_peer_connected`，它处理到服务器的新的客户端连接：
```
void on_peer_connected(uv_stream_t* server_stream, int status) {
if (status < 0) {
fprintf(stderr, "Peer connection error: %s\n", uv_strerror(status));
return;
}
// client will represent this peer; it's allocated on the heap and only
// released when the client disconnects. The client holds a pointer to
// peer_state_t in its data field; this peer state tracks the protocol state
// with this client throughout interaction.
uv_tcp_t* client = (uv_tcp_t*)xmalloc(sizeof(*client));
int rc;
if ((rc = uv_tcp_init(uv_default_loop(), client)) < 0) {
die("uv_tcp_init failed: %s", uv_strerror(rc));
}
client->data = NULL;
if (uv_accept(server_stream, (uv_stream_t*)client) == 0) {
struct sockaddr_storage peername;
int namelen = sizeof(peername);
if ((rc = uv_tcp_getpeername(client, (struct sockaddr*)&peername,
&namelen)) < 0) {
die("uv_tcp_getpeername failed: %s", uv_strerror(rc));
}
report_peer_connected((const struct sockaddr_in*)&peername, namelen);
// Initialize the peer state for a new client: we start by sending the peer
// the initial '*' ack.
peer_state_t* peerstate = (peer_state_t*)xmalloc(sizeof(*peerstate));
peerstate->state = INITIAL_ACK;
peerstate->sendbuf[0] = '*';
peerstate->sendbuf_end = 1;
peerstate->client = client;
client->data = peerstate;
// Enqueue the write request to send the ack; when it's done,
// on_wrote_init_ack will be called. The peer state is passed to the write
// request via the data pointer; the write request does not own this peer
// state - it's owned by the client handle.
uv_buf_t writebuf = uv_buf_init(peerstate->sendbuf, peerstate->sendbuf_end);
uv_write_t* req = (uv_write_t*)xmalloc(sizeof(*req));
req->data = peerstate;
if ((rc = uv_write(req, (uv_stream_t*)client, &writebuf, 1,
on_wrote_init_ack)) < 0) {
die("uv_write failed: %s", uv_strerror(rc));
}
} else {
uv_close((uv_handle_t*)client, on_client_closed);
}
}
```
这些代码都有很好的注释，但是，这里有一些重要的 libuv 语法我想去强调一下：
* 传入自定义数据到回调中：因为 C 语言还没有闭包，这可能是个挑战，libuv 在它的所有的处理类型中有一个 `void* data` 字段；这些字段可以被用于传递用户数据。例如，注意 `client->data` 是如何指向到一个 `peer_state_t` 结构上，以便于 `uv_write` 和 `uv_read_start` 注册的回调可以知道它们正在处理的是哪个客户端的数据。
* 内存管理：在带有垃圾回收的语言中进行事件驱动编程是非常容易的，因为，回调通常运行在一个与它们注册的地方完全不同的栈帧中，使得基于栈的内存管理很困难。它总是需要传递堆分配的数据到 libuv 回调中（当所有回调运行时，除了 `main`，其它的都运行在栈上），并且，为了避免泄漏，许多情况下都要求这些数据去安全释放（`free()`）。这些都是些需要实践的内容 <sup> 注1</sup> 。
这个服务器上对端的状态如下：
```
typedef struct {
ProcessingState state;
char sendbuf[SENDBUF_SIZE];
int sendbuf_end;
uv_tcp_t* client;
} peer_state_t;
```
它与第三部分中的状态非常类似；我们不再需要 `sendptr`，因为，在调用 “done writing” 回调之前，`uv_write` 将确保发送它提供的整个缓冲。我们也为其它的回调使用保持了一个到客户端的指针。这里是 `on_wrote_init_ack`：
```
void on_wrote_init_ack(uv_write_t* req, int status) {
if (status) {
die("Write error: %s\n", uv_strerror(status));
}
peer_state_t* peerstate = (peer_state_t*)req->data;
// Flip the peer state to WAIT_FOR_MSG, and start listening for incoming data
// from this peer.
peerstate->state = WAIT_FOR_MSG;
peerstate->sendbuf_end = 0;
int rc;
if ((rc = uv_read_start((uv_stream_t*)peerstate->client, on_alloc_buffer,
on_peer_read)) < 0) {
die("uv_read_start failed: %s", uv_strerror(rc));
}
// Note: the write request doesn't own the peer state, hence we only free the
// request itself, not the state.
free(req);
}
```
然后，我们确信知道了这个初始的 `'*'` 已经被发送到对端，我们通过调用 `uv_read_start` 去监听从这个对端来的入站数据，它注册一个将被事件循环调用的回调（`on_peer_read`），不论什么时候，事件循环都在套接字上接收来自客户端的调用：
```
void on_peer_read(uv_stream_t* client, ssize_t nread, const uv_buf_t* buf) {
if (nread < 0) {
if (nread != uv_eof) {
fprintf(stderr, "read error: %s\n", uv_strerror(nread));
}
uv_close((uv_handle_t*)client, on_client_closed);
} else if (nread == 0) {
// from the documentation of uv_read_cb: nread might be 0, which does not
// indicate an error or eof. this is equivalent to eagain or ewouldblock
// under read(2).
} else {
// nread > 0
assert(buf->len >= nread);
peer_state_t* peerstate = (peer_state_t*)client->data;
if (peerstate->state == initial_ack) {
// if the initial ack hasn't been sent for some reason, ignore whatever
// the client sends in.
free(buf->base);
return;
}
// run the protocol state machine.
for (int i = 0; i < nread; ++i) {
switch (peerstate->state) {
case initial_ack:
assert(0 && "can't reach here");
break;
case wait_for_msg:
if (buf->base[i] == '^') {
peerstate->state = in_msg;
}
break;
case in_msg:
if (buf->base[i] == '$') {
peerstate->state = wait_for_msg;
} else {
assert(peerstate->sendbuf_end < sendbuf_size);
peerstate->sendbuf[peerstate->sendbuf_end++] = buf->base[i] + 1;
}
break;
}
}
if (peerstate->sendbuf_end > 0) {
// we have data to send. the write buffer will point to the buffer stored
// in the peer state for this client.
uv_buf_t writebuf =
uv_buf_init(peerstate->sendbuf, peerstate->sendbuf_end);
uv_write_t* writereq = (uv_write_t*)xmalloc(sizeof(*writereq));
writereq->data = peerstate;
int rc;
if ((rc = uv_write(writereq, (uv_stream_t*)client, &writebuf, 1,
on_wrote_buf)) < 0) {
die("uv_write failed: %s", uv_strerror(rc));
}
}
}
free(buf->base);
}
```
这个服务器的运行时行为非常类似于第三部分的事件驱动服务器：所有的客户端都在一个单个的线程中并发处理。并且类似的，一些特定的行为必须在服务器代码中维护：服务器的逻辑实现为一个集成的回调，并且长周期运行是禁止的，因为它会阻塞事件循环。这一点也很类似。让我们进一步探索这个问题。
### 在事件驱动循环中的长周期运行的操作
单线程的事件驱动代码使它先天就容易受到一些常见问题的影响：长周期运行的代码会阻塞整个循环。参见如下的程序：
```
void on_timer(uv_timer_t* timer) {
uint64_t timestamp = uv_hrtime();
printf("on_timer [%" PRIu64 " ms]\n", (timestamp / 1000000) % 100000);
// "Work"
if (random() % 5 == 0) {
printf("Sleeping...\n");
sleep(3);
}
}
int main(int argc, const char** argv) {
uv_timer_t timer;
uv_timer_init(uv_default_loop(), &timer);
uv_timer_start(&timer, on_timer, 0, 1000);
return uv_run(uv_default_loop(), UV_RUN_DEFAULT);
}
```
它用一个单个注册的回调运行一个 libuv 事件循环：`on_timer`，它被每秒钟循环调用一次。回调报告一个时间戳，并且，偶尔通过睡眠 3 秒去模拟一个长周期运行。这是运行示例：
```
$ ./uv-timer-sleep-demo
on_timer [4840 ms]
on_timer [5842 ms]
on_timer [6843 ms]
on_timer [7844 ms]
Sleeping...
on_timer [11845 ms]
on_timer [12846 ms]
Sleeping...
on_timer [16847 ms]
on_timer [17849 ms]
on_timer [18850 ms]
...
```
`on_timer` 忠实地每秒执行一次，直到随机出现的睡眠为止。在那个时间点，`on_timer` 不再被调用，直到睡眠时间结束；事实上，*没有其它的回调* 会在这个时间帧中被调用。这个睡眠调用阻塞了当前线程，它正是被调用的线程，并且也是事件循环使用的线程。当这个线程被阻塞后，事件循环也被阻塞。
这个示例演示了在事件驱动的调用中为什么回调不能被阻塞是多少的重要。并且，同样适用于 Node.js 服务器、客户端侧的 Javascript、大多数的 GUI 编程框架、以及许多其它的异步编程模型。
但是，有时候运行耗时的任务是不可避免的。并不是所有任务都有一个异步 API；例如，我们可能使用一些仅有同步 API 的库去处理，或者，正在执行一个可能的长周期计算。我们如何用事件驱动编程去结合这些代码？线程可以帮到你！
### “转换” 阻塞调用为异步调用的线程
一个线程池可以用于转换阻塞调用为异步调用，通过与事件循环并行运行，并且当任务完成时去由它去公布事件。以阻塞函数 `do_work()` 为例，这里介绍了它是怎么运行的：
1. 不在一个回调中直接调用 `do_work()` ，而是将它打包进一个 “任务”，让线程池去运行这个任务。当任务完成时，我们也为循环去调用它注册一个回调；我们称它为 `on_work_done()`。
2. 在这个时间点，我们的回调就可以返回了，而事件循环保持运行；在同一时间点，线程池中的有一个线程运行这个任务。
3. 一旦任务运行完成，通知主线程（指正在运行事件循环的线程），并且事件循环调用 `on_work_done()`。
让我们看一下，使用 libuv 的工作调度 API，是怎么去解决我们前面的计时器/睡眠示例中展示的问题的：
```
void on_after_work(uv_work_t* req, int status) {
free(req);
}
void on_work(uv_work_t* req) {
// "Work"
if (random() % 5 == 0) {
printf("Sleeping...\n");
sleep(3);
}
}
void on_timer(uv_timer_t* timer) {
uint64_t timestamp = uv_hrtime();
printf("on_timer [%" PRIu64 " ms]\n", (timestamp / 1000000) % 100000);
uv_work_t* work_req = (uv_work_t*)malloc(sizeof(*work_req));
uv_queue_work(uv_default_loop(), work_req, on_work, on_after_work);
}
int main(int argc, const char** argv) {
uv_timer_t timer;
uv_timer_init(uv_default_loop(), &timer);
uv_timer_start(&timer, on_timer, 0, 1000);
return uv_run(uv_default_loop(), UV_RUN_DEFAULT);
}
```
通过一个 `work_req` <sup> 注2</sup> 类型的句柄，我们进入一个任务队列，代替在 `on_timer` 上直接调用 sleep，这个函数在任务中（`on_work`）运行，并且，一旦任务完成（`on_after_work`），这个函数被调用一次。`on_work` 是指 “work”（阻塞中的/耗时的操作）进行的地方。注意在这两个回调传递到 `uv_queue_work` 时的一个关键区别：`on_work` 运行在线程池中，而 `on_after_work` 运行在事件循环中的主线程上 —— 就好像是其它的回调一样。
让我们看一下这种方式的运行：
```
$ ./uv-timer-work-demo
on_timer [89571 ms]
on_timer [90572 ms]
on_timer [91573 ms]
on_timer [92575 ms]
Sleeping...
on_timer [93576 ms]
on_timer [94577 ms]
Sleeping...
on_timer [95577 ms]
on_timer [96578 ms]
on_timer [97578 ms]
...
```
即便在 sleep 函数被调用时，定时器也每秒钟滴答一下，睡眠现在运行在一个单独的线程中，并且不会阻塞事件循环。
### 一个用于练习的素数测试服务器
因为通过睡眠去模拟工作并不是件让人兴奋的事，我有一个事先准备好的更综合的一个示例 —— 一个基于套接字接受来自客户端的数字的服务器，检查这个数字是否是素数，然后去返回一个 “prime" 或者 “composite”。完整的 [服务器代码在这里](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/uv-isprime-server.c) —— 我不在这里粘贴了，因为它太长了，更希望读者在一些自己的练习中去体会它。
这个服务器使用了一个原生的素数测试算法，因此，对于大的素数可能花很长时间才返回一个回答。在我的机器中，对于 2305843009213693951，它花了 ~5 秒钟去计算，但是，你的方法可能不同。
练习 1：服务器有一个设置（通过一个名为 `MODE` 的环境变量）要么在套接字回调（意味着在主线程上）中运行素数测试，要么在 libuv 工作队列中。当多个客户端同时连接时，使用这个设置来观察服务器的行为。当它计算一个大的任务时，在阻塞模式中，服务器将不回复其它客户端，而在非阻塞模式中，它会回复。
练习 2：libuv 有一个缺省大小的线程池，并且线程池的大小可以通过环境变量配置。你可以通过使用多个客户端去实验找出它的缺省值是多少？找到线程池缺省值后，使用不同的设置去看一下，在重负载下怎么去影响服务器的响应能力。
### 在非阻塞文件系统中使用工作队列
对于只是呆板的演示和 CPU 密集型的计算来说，将可能的阻塞操作委托给一个线程池并不是明智的；libuv 在它的文件系统 API 中本身就大量使用了这种能力。通过这种方式，libuv 使用一个异步 API，以一个轻便的方式显示出它强大的文件系统的处理能力。
让我们使用 `uv_fs_read()`，例如，这个函数从一个文件中（表示为一个 `uv_fs_t` 句柄）读取一个文件到一个缓冲中 <sup> 注3，并且当读取完成后调用一个回调。换句话说， <code> uv_fs_read() </code> 总是立即返回，即使是文件在一个类似</sup> NFS 的系统上，而数据到达缓冲区可能需要一些时间。换句话说，这个 API 与这种方式中其它的 libuv API 是异步的。这是怎么工作的呢？
在这一点上，我们看一下 libuv 的底层；内部实际上非常简单，并且它是一个很好的练习。作为一个可移植的库，libuv 对于 Windows 和 Unix 系统在它的许多函数上有不同的实现。我们去看一下在 libuv 源树中的 `src/unix/fs.c`。
这是 `uv_fs_read` 的代码：
```
int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,
uv_file file,
const uv_buf_t bufs[],
unsigned int nbufs,
int64_t off,
uv_fs_cb cb) {
if (bufs == NULL || nbufs == 0)
return -EINVAL;
INIT(READ);
req->file = file;
req->nbufs = nbufs;
req->bufs = req->bufsml;
if (nbufs > ARRAY_SIZE(req->bufsml))
req->bufs = uv__malloc(nbufs * sizeof(*bufs));
if (req->bufs == NULL) {
if (cb != NULL)
uv__req_unregister(loop, req);
return -ENOMEM;
}
memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
req->off = off;
POST;
}
```
第一次看可能觉得很困难，因为它延缓真实的工作到 `INIT` 和 `POST` 宏中，以及为 `POST` 设置了一些本地变量。这样做可以避免了文件中的许多重复代码。
这是 `INIT` 宏：
```
#define INIT(subtype) \
do { \
req->type = UV_FS; \
if (cb != NULL) \
uv__req_init(loop, req, UV_FS); \
req->fs_type = UV_FS_ ## subtype; \
req->result = 0; \
req->ptr = NULL; \
req->loop = loop; \
req->path = NULL; \
req->new_path = NULL; \
req->cb = cb; \
} \
while (0)
```
它设置了请求，并且更重要的是，设置 `req->fs_type` 域为真实的 FS 请求类型。因为 `uv_fs_read` 调用 `INIT(READ)`，它意味着 `req->fs_type` 被分配一个常数 `UV_FS_READ`。
这是 `POST` 宏：
```
#define POST \
do { \
if (cb != NULL) { \
uv__work_submit(loop, &req->work_req, uv__fs_work, uv__fs_done); \
return 0; \
} \
else { \
uv__fs_work(&req->work_req); \
return req->result; \
} \
} \
while (0)
```
它做什么取决于回调是否为 `NULL`。在 libuv 文件系统 API 中，一个 `NULL` 回调意味着我们真实地希望去执行一个 *同步* 操作。在这种情况下，`POST` 直接调用 `uv__fs_work`（我们需要了解一下这个函数的功能），而对于一个非 `NULL` 回调，它把 `uv__fs_work` 作为一个工作项提交到工作队列（指的是线程池），然后，注册 `uv__fs_done` 作为回调；该函数执行一些登记并调用用户提供的回调。
如果我们去看 `uv__fs_work` 的代码，我们将看到它使用很多宏按照需求将工作分发到实际的文件系统调用。在我们的案例中，对于 `UV_FS_READ` 这个调用将被 `uv__fs_read` 生成，它（最终）使用普通的 POSIX API 去读取。这个函数可以在一个 *阻塞* 方式中很安全地实现。因为，它通过异步 API 调用时被置于一个线程池中。
在 Node.js 中，`fs.readFile` 函数是映射到 `uv_fs_read` 上。因此，可以在一个非阻塞模式中读取文件，甚至是当底层文件系统 API 是阻塞方式时。
---
* 注1： 为确保服务器不泄露内存，我在一个启用泄露检查的 Valgrind 中运行它。因为服务器经常是被设计为永久运行，这是一个挑战；为克服这个问题，我在服务器上添加了一个 “kill 开关” —— 一个从客户端接收的特定序列，以使它可以停止事件循环并退出。这个代码在 `theon_wrote_buf` 句柄中。
* 注2： 在这里我们不过多地使用 `work_req`；讨论的素数测试服务器接下来将展示怎么被用于去传递上下文信息到回调中。
* 注3： `uv_fs_read()` 提供了一个类似于 `preadv` Linux 系统调用的通用 API：它使用多缓冲区用于排序，并且支持一个到文件中的偏移。基于我们讨论的目的可以忽略这些特性。
---
via: <https://eli.thegreenplace.net/2017/concurrent-servers-part-4-libuv/>
作者：[Eli Bendersky](https://eli.thegreenplace.net/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 sar 和 kSar 来发现 Linux 性能瓶颈
|
Vivek Gite
|
https://www.cyberciti.biz/tips/identifying-linux-bottlenecks-sar-graphs-with-ksar.html
|
sar 命令的输出能够用于识别服务器瓶颈。但是，分析 sar 命令提供的信息可能比较困难，所以要使用 kSar 工具。kSar 工具可以将 sar 命令的输出绘制成基于时间周期的、易于理解的图表。
|
/data/attachment/album/201803/02/202721zt4b9ketlf0tpt3t.jpg.thumb.jpg
|
/data/attachment/album/201803/02/202721zt4b9ketlf0tpt3t.jpg
| true | false | true |
qhwdw
| false |
[
"sar",
"kSar"
] |
系统运维
|
{
"viewnum": 12716,
"commentnum": 0,
"favtimes": 6,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
sar 命令的输出能够用于识别服务器瓶颈。但是，分析 sar 命令提供的信息可能比较困难，所以要使用 kSar 工具。kSar 工具可以将 sar 命令的输出绘制成基于时间周期的、易于理解的图表。
| 2018-03-02T20:27:35 | 2018-03-02T20:27:35 | 9,398 |
/article-9398-1.html
|
`sar` 命令用用收集、报告、或者保存 UNIX / Linux 系统的活动信息。它保存选择的计数器到操作系统的 `/var/log/sa/sadd` 文件中。从收集的数据中，你可以得到许多关于你的服务器的信息：
1. CPU 使用率
2. 内存页面和使用率
3. 网络 I/O 和传输统计
4. 进程创建活动
5. 所有的块设备活动
6. 每秒中断数等等
`sar` 命令的输出能够用于识别服务器瓶颈。但是，分析 `sar` 命令提供的信息可能比较困难，所以要使用 kSar 工具。kSar 工具可以将 `sar` 命令的输出绘制成基于时间周期的、易于理解的图表。
### sysstat 包
`sar`、`sa1`、和 `sa2` 命令都是 sysstat 包的一部分。它是 Linux 包含的性能监视工具集合。
1. `sar`：显示数据
2. `sa1` 和 `sa2`：收集和保存数据用于以后分析。`sa2` shell 脚本在 `/var/log/sa` 目录中每日写入一个报告。`sa1` shell 脚本将每日的系统活动信息以二进制数据的形式写入到文件中。
3. sadc —— 系统活动数据收集器。你可以通过修改 `sa1` 和 `sa2` 脚本去配置各种选项。它们位于以下的目录：
* `/usr/lib64/sa/sa1` （64 位）或者 `/usr/lib/sa/sa1` （32 位） —— 它调用 `sadc` 去记录报告到 `/var/log/sa/sadX` 格式。
* `/usr/lib64/sa/sa2` （64 位）或者 `/usr/lib/sa/sa2` （32 位） —— 它调用 `sar` 去记录报告到 `/var/log/sa/sarX` 格式。
#### 如何在我的系统上安装 sar？
在一个基于 CentOS/RHEL 的系统上，输入如下的 [yum 命令](https://www.cyberciti.biz/faq/rhel-centos-fedora-linux-yum-command-howto/ "See Linux/Unix yum command examples for more info") 去安装 sysstat：
```
# yum install sysstat
```
示例输出如下：
```
Loaded plugins: downloadonly, fastestmirror, priorities,
: protectbase, security
Loading mirror speeds from cached hostfile
* addons: mirror.cs.vt.edu
* base: mirror.ash.fastserv.com
* epel: serverbeach1.fedoraproject.org
* extras: mirror.cogentco.com
* updates: centos.mirror.nac.net
0 packages excluded due to repository protections
Setting up Install Process
Resolving Dependencies
--> Running transaction check
---> Package sysstat.x86_64 0:7.0.2-3.el5 set to be updated
--> Finished Dependency Resolution
Dependencies Resolved
====================================================================
Package Arch Version Repository Size
====================================================================
Installing:
sysstat x86_64 7.0.2-3.el5 base 173 k
Transaction Summary
====================================================================
Install 1 Package(s)
Update 0 Package(s)
Remove 0 Package(s)
Total download size: 173 k
Is this ok [y/N]: y
Downloading Packages:
sysstat-7.0.2-3.el5.x86_64.rpm | 173 kB 00:00
Running rpm_check_debug
Running Transaction Test
Finished Transaction Test
Transaction Test Succeeded
Running Transaction
Installing : sysstat 1/1
Installed:
sysstat.x86_64 0:7.0.2-3.el5
Complete!
```
#### 为 sysstat 配置文件
编辑 `/etc/sysconfig/sysstat` 文件去指定日志文件保存多少天（最长为一个月）：
```
# vi /etc/sysconfig/sysstat
```
示例输出如下 ：
```
# keep log for 28 days
# the default is 7
HISTORY=28
```
保存并关闭这个文件。
### 找到 sar 默认的 cron 作业
[默认的 cron 作业位于](https://www.cyberciti.biz/faq/how-do-i-add-jobs-to-cron-under-linux-or-unix-oses/) `/etc/cron.d/sysstat`：
```
# cat /etc/cron.d/sysstat
```
示例输出如下：
```
# run system activity accounting tool every 10 minutes
*/10 * * * * root /usr/lib64/sa/sa1 1 1
# generate a daily summary of process accounting at 23:53
53 23 * * * root /usr/lib64/sa/sa2 -A
```
#### 告诉 sadc 去报告磁盘的统计数据
使用一个文本编辑器去编辑 `/etc/cron.d/sysstat` 文件，比如使用 `vim` 命令，输入如下：
```
# vi /etc/cron.d/sysstat
```
像下面的示例那样更新这个文件，以记录所有的硬盘统计数据（`-d` 选项强制记录每个块设备的统计数据，而 `-I` 选项强制记录所有系统中断的统计数据）：
```
# run system activity accounting tool every 10 minutes
*/10 * * * * root /usr/lib64/sa/sa1 -I -d 1 1
# generate a daily summary of process accounting at 23:53
53 23 * * * root /usr/lib64/sa/sa2 -A
```
在 CentOS/RHEL 7.x 系统上你需要传递 `-S DISK` 选项去收集块设备的数据。传递 `-S XALL` 选项去采集如下所列的数据：
1. 磁盘
2. 分区
3. 系统中断
4. SNMP
5. IPv6
```
# Run system activity accounting tool every 10 minutes
*/10 * * * * root /usr/lib64/sa/sa1 -S DISK 1 1
# 0 * * * * root /usr/lib64/sa/sa1 600 6 &
# Generate a daily summary of process accounting at 23:53
53 23 * * * root /usr/lib64/sa/sa2 -A
# Run system activity accounting tool every 10 minutes
```
保存并关闭这个文件。
#### 打开 CentOS/RHEL 版本 5.x/6.x 的服务
输入如下命令:
```
chkconfig sysstat on
service sysstat start
```
示例输出如下：
```
Calling the system activity data collector (sadc):
```
对于 CentOS/RHEL 7.x，运行如下的命令：
```
# systemctl enable sysstat
# systemctl start sysstat.service
# systemctl status sysstat.service
```
示例输出：
```
● sysstat.service - Resets System Activity Logs
Loaded: loaded (/usr/lib/systemd/system/sysstat.service; enabled; vendor preset: enabled)
Active: active (exited) since Sat 2018-01-06 16:33:19 IST; 3s ago
Process: 28297 ExecStart=/usr/lib64/sa/sa1 --boot (code=exited, status=0/SUCCESS)
Main PID: 28297 (code=exited, status=0/SUCCESS)
Jan 06 16:33:19 centos7-box systemd[1]: Starting Resets System Activity Logs...
Jan 06 16:33:19 centos7-box systemd[1]: Started Resets System Activity Logs.
```
### 如何使用 sar？如何查看统计数据？
使用 `sar` 命令去显示操作系统中选定的累积活动计数器输出。在这个示例中，运行 `sar` 命令行，去实时获得 CPU 使用率的报告：
```
# sar -u 3 10
```
示例输出：
```
Linux 2.6.18-164.2.1.el5 (www-03.nixcraft.in) 12/14/2009
09:49:47 PM CPU %user %nice %system %iowait %steal %idle
09:49:50 PM all 5.66 0.00 1.22 0.04 0.00 93.08
09:49:53 PM all 12.29 0.00 1.93 0.04 0.00 85.74
09:49:56 PM all 9.30 0.00 1.61 0.00 0.00 89.10
09:49:59 PM all 10.86 0.00 1.51 0.04 0.00 87.58
09:50:02 PM all 14.21 0.00 3.27 0.04 0.00 82.47
09:50:05 PM all 13.98 0.00 4.04 0.04 0.00 81.93
09:50:08 PM all 6.60 6.89 1.26 0.00 0.00 85.25
09:50:11 PM all 7.25 0.00 1.55 0.04 0.00 91.15
09:50:14 PM all 6.61 0.00 1.09 0.00 0.00 92.31
09:50:17 PM all 5.71 0.00 0.96 0.00 0.00 93.33
Average: all 9.24 0.69 1.84 0.03 0.00 88.20
```
其中：
* 3 表示间隔时间
* 10 表示次数
查看进程创建的统计数据，输入：
```
# sar -c 3 10
```
查看 I/O 和传输率统计数据，输入：
```
# sar -b 3 10
```
查看内存页面统计数据，输入：
```
# sar -B 3 10
```
查看块设备统计数据，输入：
```
# sar -d 3 10
```
查看所有中断的统计数据，输入：
```
# sar -I XALL 3 10
```
查看网络设备特定的统计数据，输入：
```
# sar -n DEV 3 10
# sar -n EDEV 3 10
```
查看 CPU 特定的统计数据，输入：
```
# sar -P ALL
# Only 1st CPU stats
# sar -P 1 3 10
```
查看队列长度和平均负载的统计数据，输入：
```
# sar -q 3 10
```
查看内存和交换空间的使用统计数据，输入：
```
# sar -r 3 10
# sar -R 3 10
```
查看 inode、文件、和其它内核表统计数据状态，输入：
```
# sar -v 3 10
```
查看系统切换活动统计数据，输入：
```
# sar -w 3 10
```
查看交换统计数据，输入：
```
# sar -W 3 10
```
查看一个 PID 为 3256 的 Apache 进程，输入：
```
# sar -x 3256 3 10
```
### kSar 介绍
`sar` 和 `sadf` 提供了基于命令行界面的输出。这种输出可能会使新手用户/系统管理员感到无从下手。因此，你需要使用 kSar，它是一个图形化显示你的 `sar` 数据的 Java 应用程序。它也允许你以 PDF/JPG/PNG/CSV 格式导出数据。你可以用三种方式去加载数据：本地文件、运行本地命令、以及通过 SSH 远程运行的命令。kSar 可以处理下列操作系统的 `sar` 输出：
1. Solaris 8, 9 和 10
2. Mac OS/X 10.4+
3. Linux (Systat Version >= 5.0.5)
4. AIX (4.3 & 5.3)
5. HPUX 11.00+
#### 下载和安装 kSar
访问 [官方](https://github.com/vlsi/ksar) 网站去获得最新版本的源代码。使用 [wget](https://www.cyberciti.biz/tips/linux-wget-your-ultimate-command-line-downloader.html) 去下载源代码，输入：
```
$ wget https://github.com/vlsi/ksar/releases/download/v5.2.4-snapshot-652bf16/ksar-5.2.4-SNAPSHOT-all.jar
```
#### 如何运行 kSar？
首先要确保你的机器上 [JAVA jdk](https://www.cyberciti.biz/faq/howto-ubuntu-linux-install-configure-jdk-jre/) 已安装并能够正常工作。输入下列命令去启动 kSar：
```
$ java -jar ksar-5.2.4-SNAPSHOT-all.jar
```
接下来你将看到 kSar 的主窗口，和有两个菜单的面板。
左侧有一个列表，是 kSar 根据数据已经解析出的可用图表的列表。右侧窗口将展示你选定的图表。
#### 如何使用 kSar 去生成 sar 图表？
首先，你需要从命名为 server1 的服务器上采集 `sar` 命令的统计数据。输入如下的命令：
```
[ server1 ]# LC_ALL=C sar -A > /tmp/sar.data.txt
```
接下来，使用 `scp` 命令从本地桌面拷贝到远程电脑上：
```
[ desktop ]$ scp user@server1.nixcraft.com:/tmp/sar.data.txt /tmp/
```
切换到 kSar 窗口，点击 “Data” > “Load data from text file” > 从 `/tmp/` 中选择 `sar.data.txt` > 点击 “Open” 按钮。
现在，图表类型树已经出现在左侧面板中并选定了一个图形：
##### 放大和缩小
通过移动你可以交互式缩放图像的一部分。在要缩放的图像的左上角点击并按下鼠标，移动到要缩放区域的右下角，可以选定要缩放的区域。返回到未缩放状态，点击并拖动鼠标到除了右下角外的任意位置，你也可以点击并选择 zoom 选项。
##### 了解 kSar 图像和 sar 数据
我强烈建议你去阅读 `sar` 和 `sadf` 命令的 man 页面：
```
$ man sar
$ man sadf
```
### 案例学习：识别 Linux 服务器的 CPU 瓶颈
使用 `sar` 命令和 kSar 工具，可以得到内存、CPU、以及其它子系统的详细快照。例如，如果 CPU 使用率在一个很长的时间内持续高于 80%，有可能就是出现了一个 CPU 瓶颈。使用 `sar -x ALL` 你可以找到大量消耗 CPU 的进程。
[mpstat 命令](https://www.cyberciti.biz/tips/how-do-i-find-out-linux-cpu-utilization.html) 的输出（sysstat 包的一部分）也会帮你去了解 CPU 的使用率。但你可以使用 kSar 很容易地去分析这些信息。
#### 找出 CPU 瓶颈后 …
对 CPU 执行如下的调整：
1. 确保没有不需要的进程在后台运行。关闭 [Linux 上所有不需要的服务](https://www.cyberciti.biz/faq/check-running-services-in-rhel-redhat-fedora-centoslinux/)。
2. 使用 [cron](https://www.cyberciti.biz/faq/how-do-i-add-jobs-to-cron-under-linux-or-unix-oses/) 在一个非高峰时刻运行任务（比如，备份）。
3. 使用 [top 和 ps 命令](https://www.cyberciti.biz/faq/show-all-running-processes-in-linux/) 去找出所有非关键的后台作业/服务。使用 [renice 命令](https://www.cyberciti.biz/faq/howto-change-unix-linux-process-priority/) 去调整低优先级作业。
4. 使用 [taskset 命令去设置进程使用的 CPU](https://www.cyberciti.biz/faq/taskset-cpu-affinity-command/) （卸载所使用的 CPU），即，绑定进程到不同的 CPU 上。例如，在 2# CPU 上运行 MySQL 数据库，而在 3# CPU 上运行 Apache。
5. 确保你的系统使用了最新的驱动程序和固件。
6. 如有可能在系统上增加额外的 CPU。
7. 为单线程应用程序使用更快的 CPU（比如，Lighttpd web 服务器应用程序）。
8. 为多线程应用程序使用多个 CPU（比如，MySQL 数据库服务器应用程序）。
9. 为一个 web 应用程序使用多个计算节点并设置一个 [负载均衡器](https://www.cyberciti.biz/tips/load-balancer-open-source-software.html)。
### isag —— 交互式系统活动记录器（替代工具）
`isag` 命令图形化显示了以前运行 `sar` 命令时存储在二进制文件中的系统活动数据。`isag` 命令引用 `sar` 并提取出它的数据来绘制图形。与 kSar 相比，`isag` 的选项比较少。
### 关于作者
本文作者是 nixCraft 的创始人和一位经验丰富的 Linux 操作系统/Unix shell 脚本培训师。他与包括 IT、教育、国防和空间研究、以及非营利组织等全球各行业客户一起合作。可以在 [Twitter](https://twitter.com/nixcraft)、[Facebook](https://facebook.com/nixcraft)、[Google+](https://plus.google.com/+CybercitiBiz) 上关注他。
---
via: <https://www.cyberciti.biz/tips/identifying-linux-bottlenecks-sar-graphs-with-ksar.html>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
让我们做个简单的解释器（一）
|
Ruslan Spivak
|
https://ruslanspivak.com/lsbasi-part1/
|
“如果你不知道编译器是怎么工作的，那你就不知道电脑是怎么工作的。如果你不能百分百确定，那就是不知道它们是如何工作的。”
|
/data/attachment/album/201803/02/214643pynf6qfpbbjn2u24.jpg.thumb.jpg
|
/data/attachment/album/201803/02/214643pynf6qfpbbjn2u24.jpg
| true | false | true |
BriFuture
| false |
[
"解释器",
"编译器"
] |
软件开发
|
{
"viewnum": 12816,
"commentnum": 2,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "58.221.145.98",
"message": "简单易懂，非常棒。",
"username": "来自江苏南通的 Chrome 63.0|Windows 8.1 用户",
"date": "2019-03-05T15:50:35"
},
{
"postip": "59.49.36.231",
"message": "666",
"username": "来自山西太原的 Chrome 105.0|Windows 10 用户",
"date": "2022-10-19T15:39:42"
}
] |
[
{
"raid": 9520,
"displayorder": 0
}
] |
“如果你不知道编译器是怎么工作的，那你就不知道电脑是怎么工作的。如果你不能百分百确定，那就是不知道它们是如何工作的。”
| 2018-03-04T09:41:00 | 2018-03-04T09:41:00 | 9,399 |
/article-9399-1.html
|
>
> “如果你不知道编译器是怎么工作的，那你就不知道电脑是怎么工作的。如果你不能百分百确定，那就是不知道它们是如何工作的。” --Steve Yegge
>
>
>
就是这样。想一想。你是萌新还是一个资深的软件开发者实际上都无关紧要：如果你不知道<ruby> 编译器 <rt> compiler </rt></ruby>和<ruby> 解释器 <rt> interpreter </rt></ruby>是怎么工作的，那么你就不知道电脑是怎么工作的。就这么简单。
所以，你知道编译器和解释器是怎么工作的吗？我是说，你百分百确定自己知道他们怎么工作吗？如果不知道。
或者如果你不知道但你非常想要了解它。
不用担心。如果你能坚持跟着这个系列做下去，和我一起构建一个解释器和编译器，最后你将会知道他们是怎么工作的。并且你会变成一个自信满满的快乐的人。至少我希望如此。
为什么要学习编译器和解释器？有三点理由。
1. 要写出一个解释器或编译器，你需要有很多的专业知识，并能融会贯通。写一个解释器或编译器能帮你加强这些能力，成为一个更厉害的软件开发者。而且，你要学的技能对编写软件非常有用，而不是仅仅局限于解释器或编译器。
2. 你确实想要了解电脑是怎么工作的。通常解释器和编译器看上去很魔幻。你或许不习惯这种魔力。你会想去揭开构建解释器和编译器那层神秘的面纱，了解它们的原理，把事情做好。
3. 你想要创建自己的编程语言或者特定领域的语言。如果你创建了一个，你还要为它创建一个解释器或者编译器。最近，兴起了对新的编程语言的兴趣。你能看到几乎每天都有一门新的编程语言横空出世：Elixir，Go，Rust，还有很多。
好，但什么是解释器和编译器？
**解释器** 和 **编译器** 的任务是把用高级语言写的源程序翻译成其他的格式。很奇怪，是不是？忍一忍，稍后你会在这个系列学到到底把源程序翻译成什么东西。
这时你可能会奇怪解释器和编译器之间有什么区别。为了实现这个系列的目的，我们规定一下，如果有个翻译器把源程序翻译成机器语言，那它就是 **编译器**。如果一个翻译器可以处理并执行源程序，却不用把它翻译器机器语言，那它就是 **解释器**。直观上它看起来像这样：
我希望你现在确信你很想学习构建一个编译器和解释器。你期望在这个教程里学习解释器的哪些知识呢？
你看这样如何。你和我一起为 [Pascal](https://en.wikipedia.org/wiki/Pascal_%28programming_language%29) 语言的一个大子集做一个简单的解释器。在这个系列结束的时候你能做出一个可以运行的 Pascal 解释器和一个像 Python 的 [pdb](https://docs.python.org/2/library/pdb.html) 那样的源代码级别的调试器。
你或许会问，为什么是 Pascal？一方面，它不是我为了这个系列而提出的一个虚构的语言：它是真实存在的一门编程语言，有很多重要的语言结构。有些陈旧但有用的计算机书籍使用 Pascal 编程语言作为示例（我知道对于选择一门语言来构建解释器，这个理由并不令人信服，但我认为学一门非主流的语言也不错 :））。
这有个 Pascal 中的阶乘函数示例，你将能用自己的解释器解释代码，还能够用可交互的源码级调试器进行调试，你可以这样创造：
```
program factorial;
function factorial(n: integer): longint;
begin
if n = 0 then
factorial := 1
else
factorial := n * factorial(n - 1);
end;
var
n: integer;
begin
for n := 0 to 16 do
writeln(n, '! = ', factorial(n));
end.
```
这个 Pascal 解释器的实现语言会使用 Python，但你也可以用其他任何语言，因为这里展示的思想不依赖任何特殊的实现语言。好，让我们开始干活。准备好了，出发！
你会从编写一个简单的算术表达式解析器，也就是常说的计算器，开始学习解释器和编译器。今天的目标非常简单：让你的计算器能处理两个个位数相加，比如 `3+5`。下面是你的计算器的源代码——不好意思，是解释器：
```
# 标记类型
#
# EOF （end-of-file 文件末尾）标记是用来表示所有输入都解析完成
INTEGER, PLUS, EOF = 'INTEGER', 'PLUS', 'EOF'
class Token(object):
def __init__(self, type, value):
# token 类型: INTEGER, PLUS, MINUS, or EOF
self.type = type
# token 值: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, '+', 或 None
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"
self.text = text
# self.pos 是 self.text 的索引
self.pos = 0
# 当前标记实例
self.current_token = None
def error(self):
raise Exception('Error parsing input')
def get_next_token(self):
"""词法分析器（也说成扫描器或者标记器）
该方法负责把一个句子分成若干个标记。每次处理一个标记
"""
text = self.text
# self.pos 索引到达了 self.text 的末尾吗？
# 如果到了，就返回 EOF 标记，因为没有更多的
# 能转换成标记的输入了
if self.pos > len(text) - 1:
return Token(EOF, None)
# 从 self.pos 位置获取当前的字符，
# 基于单个字符判断要生成哪种标记
current_char = text[self.pos]
# 如果字符是一个数字，就把他转换成一个整数，生成一个 INTEGER # 标记，累加 self.pos 索引，指向数字后面的下一个字符，
# 并返回 INTEGER 标记
if current_char.isdigit():
token = Token(INTEGER, int(current_char))
self.pos += 1
return token
if current_char == '+':
token = Token(PLUS, current_char)
self.pos += 1
return token
self.error()
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):
"""expr -> INTEGER PLUS INTEGER"""
# 将输入中的第一个标记设置成当前标记
self.current_token = self.get_next_token()
# 我们期望当前标记是个位数。
left = self.current_token
self.eat(INTEGER)
# 期望当前标记是 ‘+’ 号
op = self.current_token
self.eat(PLUS)
# 我们期望当前标记是个位数。
right = self.current_token
self.eat(INTEGER)
# 上述操作完成后，self.current_token 被设成 EOF 标记
# 这时成功找到 INTEGER PLUS INTEGER 标记序列
# 这个方法就可以返回两个整数相加的结果了，
# 即高效的解释了用户输入
result = left.value + right.value
return result
def main():
while True:
try:
# 要在 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()
```
把上面的代码保存到 `calc1.py` 文件，或者直接从 [GitHub](https://github.com/rspivak/lsbasi/blob/master/part1/calc1.py) 上下载。在你深入研究代码前，在命令行里面运行它看看效果。试一试！这是我笔记本上的示例会话（如果你想在 Python3 下运行，你要把 `raw_input` 换成 `input`）：
```
$ python calc1.py
calc> 3+4
7
calc> 3+5
8
calc> 3+9
12
calc>
```
要让你的简易计算器正常工作，不抛出异常，你的输入要遵守以下几个规则：
* 只允许输入个位数
* 此时支持的唯一一个运算符是加法
* 输入中不允许有任何的空格符号
要让计算器变得简单，这些限制非常必要。不用担心，你很快就会让它变得很复杂。
好，现在让我们深入它，看看解释器是怎么工作，它是怎么评估出算术表达式的。
当你在命令行中输入一个表达式 `3+5`，解释器就获得了字符串 “3+5”。为了让解释器能够真正理解要用这个字符串做什么，它首先要把输入 “3+5” 分到叫做 `token`（标记）的容器里。<ruby> 标记 <rt> token </rt></ruby> 是一个拥有类型和值的对象。比如说，对字符 “3” 而言，标记的类型是 INTEGER 整数，对应的值是 3。
把输入字符串分成标记的过程叫<ruby> 词法分析 <rt> lexical analysis </rt></ruby>。因此解释器的需要做的第一步是读取输入字符，并将其转换成标记流。解释器中的这一部分叫做<ruby> 词法分析器 <rt> lexical analyzer </rt></ruby>，或者简短点叫 **lexer**。你也可以给它起别的名字，诸如<ruby> 扫描器 <rt> scanner </rt></ruby>或者<ruby> 标记器 <rt> tokenizer </rt></ruby>。它们指的都是同一个东西：解释器或编译器中将输入字符转换成标记流的那部分。
`Interpreter` 类中的 `get_next_token` 方法就是词法分析器。每次调用它的时候，你都能从传入解释器的输入字符中获得创建的下一个标记。仔细看看这个方法，看看它是如何完成把字符转换成标记的任务的。输入被存在可变文本中，它保存了输入的字符串和关于该字符串的索引（把字符串想象成字符数组）。`pos` 开始时设为 0，指向字符 ‘3’。这个方法一开始检查字符是不是数字，如果是，就将 `pos` 加 1，并返回一个 INTEGER 类型的标记实例，并把字符 ‘3’ 的值设为整数，也就是整数 3：
现在 `pos` 指向文本中的 ‘+’ 号。下次调用这个方法的时候，它会测试 `pos` 位置的字符是不是个数字，然后检测下一个字符是不是个加号，就是这样。结果这个方法把 `pos` 加 1，返回一个新创建的标记，类型是 PLUS，值为 ‘+’。
`pos` 现在指向字符 ‘5’。当你再调用 `get_next_token` 方法时，该方法会检查这是不是个数字，就是这样，然后它把 `pos` 加 1，返回一个新的 INTEGER 标记，该标记的值被设为整数 5：
因为 `pos` 索引现在到了字符串 “3+5” 的末尾，你每次调用 `get_next_token` 方法时，它将会返回 EOF 标记：
自己试一试，看看计算器里的词法分析器的运行：
```
>>> from calc1 import Interpreter
>>>
>>> interpreter = Interpreter('3+5')
>>> interpreter.get_next_token()
Token(INTEGER, 3)
>>>
>>> interpreter.get_next_token()
Token(PLUS, '+')
>>>
>>> interpreter.get_next_token()
Token(INTEGER, 5)
>>>
>>> interpreter.get_next_token()
Token(EOF, None)
>>>
```
既然你的解释器能够从输入字符中获取标记流，解释器需要对它做点什么：它需要在词法分析器 `get_next_token` 中获取的标记流中找出相应的结构。你的解释器应该能够找到流中的结构：INTEGER -> PLUS -> INTEGER。就是这样，它尝试找出标记的序列：整数后面要跟着加号，加号后面要跟着整数。
负责找出并解释结构的方法就是 `expr`。该方法检验标记序列确实与期望的标记序列是对应的，比如 INTEGER -> PLUS -> INTEGER。成功确认了这个结构后，就会生成加号左右两边的标记的值相加的结果，这样就成功解释你输入到解释器中的算术表达式了。
`expr` 方法用了一个助手方法 `eat` 来检验传入的标记类型是否与当前的标记类型相匹配。在匹配到传入的标记类型后，`eat` 方法会获取下一个标记，并将其赋给 `current_token` 变量，然后高效地 “吃掉” 当前匹配的标记，并将标记流的虚拟指针向后移动。如果标记流的结构与期望的 INTEGER -> PLUS -> INTEGER 标记序列不对应，`eat` 方法就抛出一个异常。
让我们回顾下解释器做了什么来对算术表达式进行评估的：
* 解释器接受输入字符串，比如说 “3+5”
* 解释器调用 `expr` 方法，在词法分析器 `get_next_token` 返回的标记流中找出结构。这个结构就是 INTEGER -> PLUS -> INTEGER 这样的格式。在确认了格式后，它就通过把两个整型标记相加来解释输入，因为此时对于解释器来说很清楚，它要做的就是把两个整数 3 和 5 进行相加。
恭喜。你刚刚学习了怎么构建自己的第一个解释器！
现在是时候做练习了。
看了这篇文章，你肯定觉得不够，是吗？好，准备好做这些练习：
1. 修改代码，允许输入多位数，比如 “12+3”
2. 添加一个方法忽略空格符，让你的计算器能够处理带有空白的输入，比如 “12 + 3”
3. 修改代码，用 ‘-’ 号而非 ‘+’ 号去执行减法比如 “7-5”
**检验你的理解**
1. 什么是解释器？
2. 什么是编译器
3. 解释器和编译器有什么差别？
4. 什么是标记?
5. 将输入分隔成若干个标记的过程叫什么？
6. 解释器中进行词法分析的部分叫什么？
7. 解释器或编译器中进行词法分析的部分有哪些其他的常见名字？
在结束本文前，我衷心希望你能留下学习解释器和编译器的承诺。并且现在就开始做。不要把它留到以后。不要拖延。如果你已经看完了本文，就开始吧。如果已经仔细看完了但是还没做什么练习 —— 现在就开始做吧。如果已经开始做练习了，那就把剩下的做完。你懂得。而且你知道吗？签下承诺书，今天就开始学习解释器和编译器！
>
> 本人， \_\_\_\_\_\_，身体健全，思想正常，在此承诺从今天开始学习解释器和编译器，直到我百分百了解它们是怎么工作的！
>
>
> 签字人:
>
>
> 日期:
>
>
>
签字，写上日期，把它放在你每天都能看到的地方，确保你能坚守承诺。谨记你的承诺：
>
> “承诺就是，你说自己会去做的事，在你说完就一直陪着你的东西。” —— Darren Hardy
>
>
>
好，今天的就结束了。这个系列的下一篇文章里，你将会扩展自己的计算器，让它能够处理更复杂的算术表达式。敬请期待。
---
via: <https://ruslanspivak.com/lsbasi-part1/>
作者：[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/) 荣誉推出
|
||
4 种绕过 Linux/Unix 命令别名的方法
|
Vivek Gite
|
https://www.cyberciti.biz/faq/bash-bypass-alias-command-on-linux-macos-unix/
|
我如何在 Linux、*BSD、macOS 或者类 Unix 系统上临时禁用或者绕过 bash shell 呢？
|
/data/attachment/album/201803/02/224554oeovr4ya6u1om6ka.png.thumb.jpg
|
/data/attachment/album/201803/02/224554oeovr4ya6u1om6ka.png
| true | false | true |
geekpi
| false |
[
"别名",
"alias"
] |
技术
|
{
"viewnum": 5273,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我如何在 Linux、*BSD、macOS 或者类 Unix 系统上临时禁用或者绕过 bash shell 呢？
| 2018-03-02T22:45:00 | 2018-03-02T22:45:00 | 9,400 |
/article-9400-1.html
|
我在我的 Linux 系统上定义了如下 `mount` 别名：
```
alias mount='mount | column -t'
```
但是我需要在挂载文件系统和其他用途时绕过这个 bash 别名。我如何在 Linux、\*BSD、macOS 或者类 Unix 系统上临时禁用或者绕过 bash shell 呢？
你可以使用 `alias` 命令定义或显示 bash shell 别名。一旦创建了 bash shell 别名，它们将优先于外部或内部命令。本文将展示如何暂时绕过 bash 别名，以便你可以运行实际的内部或外部命令。
### 4 种绕过 bash 别名的方法
尝试以下任意一种方法来运行被 bash shell 别名绕过的命令。让我们[如下定义一个别名](https://bash.cyberciti.biz/guide/Create_and_use_aliases)：
```
alias mount='mount | column -t'
```
运行如下：
```
mount
```
示例输出：
```
sysfs on /sys type sysfs (rw,nosuid,nodev,noexec,relatime)
proc on /proc type proc (rw,nosuid,nodev,noexec,relatime)
udev on /dev type devtmpfs (rw,nosuid,relatime,size=8023572k,nr_inodes=2005893,mode=755)
devpts on /dev/pts type devpts (rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000)
tmpfs on /run type tmpfs (rw,nosuid,noexec,relatime,size=1610240k,mode=755)
/dev/mapper/ubuntu--vg-root on / type ext4 (rw,relatime,errors=remount-ro,data=ordered)
/dev/sda1 on /boot type ext4 (rw,relatime,data=ordered)
binfmt_misc on /proc/sys/fs/binfmt_misc type binfmt_misc (rw,relatime)
lxcfs on /var/lib/lxcfs type fuse.lxcfs (rw,nosuid,nodev,relatime,user_id=0,group_id=0,allow_other)
```
#### 方法 1 - 使用 `\command`
输入以下命令暂时绕过名为 `mount` 的 bash 别名：
```
\mount
```
#### 方法 2 - 使用 `"command"` 或 `'command'`
如下引用 `mount` 命令调用实际的 `/bin/mount`：
```
"mount"
```
或者
```
'mount'
```
#### 方法 3 - 使用命令的完全路径
使用完整的二进制路径，如 `/bin/mount`：
```
/bin/mount
/bin/mount /dev/sda1 /mnt/sda
```
#### 方法 4 - 使用内部命令 `command`
语法是：
```
command cmd
command cmd arg1 arg2
```
要覆盖 `.bash_aliases` 中设置的别名，例如 `mount`：
```
command mount
command mount /dev/sdc /mnt/pendrive/
```
[“command” 直接运行命令或显示](https://bash.cyberciti.biz/guide/Command)关于命令的信息。它带参数运行命令会抑制 shell 函数查询或者别名，或者显示有关给定命令的信息。
### 关于 unalias 命令的说明
要从当前会话的已定义别名列表中移除别名，请使用 `unalias` 命令：
```
unalias mount
```
要从当前 bash 会话中删除所有别名定义：
```
unalias -a
```
确保你更新你的 `~/.bashrc` 或 `$HOME/.bash_aliases`。如果要永久删除定义的别名，则必须删除定义的别名：
```
vi ~/.bashrc
```
或者
```
joe $HOME/.bash_aliases
```
想了解更多信息，参考[这里](https://www.gnu.org/software/bash/manual/bash.html)的在线手册，或者输入下面的命令查看：
```
man bash
help command
help unalias
help alias
```
---
via: <https://www.cyberciti.biz/faq/bash-bypass-alias-command-on-linux-macos-unix/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Google 计划在 Chromebook 中增加容器化的 Linux 应用
|
Marius Nestor
|
http://news.softpedia.com/news/google-plans-to-add-support-for-containerized-linux-apps-to-chromebooks-519950.shtml
|
虽然大多数 Chromebook 已经能够运行 Android 应用程序，但似乎 Google 希望在其 Chrome OS 上增加在容器或虚拟机上运行 Linux 应用程序的支持。
|
/data/attachment/album/201803/04/002935soh2ejoow0zei6jw.jpg.thumb.jpg
|
/data/attachment/album/201803/04/002935soh2ejoow0zei6jw.jpg
| true | false | true |
wxy
| false |
[
"Linux",
"容器",
"Chromebook"
] |
新闻
|
{
"viewnum": 4567,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
虽然大多数 Chromebook 已经能够运行 Android 应用程序，但似乎 Google 希望在其 Chrome OS 上增加在容器或虚拟机上运行 Linux 应用程序的支持。
| 2018-03-04T00:29:00 | 2018-03-04T00:29:00 | 9,401 |
/article-9401-1.html
|
虽然大多数 Chromebook 已经能够运行 Android 应用程序，但似乎 Google 希望在其 Chrome OS 上增加在容器或虚拟机上运行 Linux 应用程序的支持。
据[一则 Reddit 消息](https://www.reddit.com/r/chromeos/comments/7ytpb1/project_crostini_linux_vms_on_chrome_os/)，谷歌显然正在开发 Chrome OS 的 Crostini 项目，以在 Chrome OS 上支持 Linux 的虚拟机。这条消息指出，最近的 [Chromium 提交](https://chromium-review.googlesource.com/c/chromium/src/+/899767) 会解释一条新的设备策略，如果其设置为真，那么将允许在 Chrome OS 上运行 Linux 虚拟机。
>
> “如果该策略未设置或设置为真，那么在 Chrome OS 上运行 Linux 虚拟机是允许的。未设置也是允许的意味着非管理的设备是允许运行 Linux 虚拟机的。此时，要让 Linux 虚拟机运行起来，也需要启用 Finch 试验性特性，当该特性完全启用后，Finch 控制逻辑将被移除。”
>
>
>
### 在 Chrome OS 上运行 Linux 应用将让多少人梦想成真
这表明在你的 Chromebook 上运行 Linux 应用的梦想终于要变成了真的。不会让你等待太久，当这个新策略逐步经历 Chrome OS 的 Dev、Beta 和 Stable 等频道之后，你就可以在 Chrome OS 上尝鲜 Linux 应用了。
据 [ChromeUnboxed](https://chromeunboxed.com/news/chromebook-containers-virtual-machine-crostini-google-io) 的消息，该特性或许出现在五月份早一些的时候 Chrome OS 66 发布时。显然这是首次在 Chrome OS 上支持容器化的 Linux 应用，我们对此功能表示无比的高兴，而这也将进一步让更多的人去使用 Chrome OS。
Chromebook 操作系统的当前版本是 Google 上个月发布的 Chrome OS 64，它[支持并行运行 Android 应用](http://news.softpedia.com/news/chromebooks-will-soon-support-parallel-android-apps-with-the-chrome-os-64-update-519154.shtml)，以及一些其它的核心功能，而且这个补丁也[为 Chromebook 解决了 Meltdown 和 Spectre 安全缺陷影响](http://news.softpedia.com/news/google-patches-chromebooks-against-meltdown-spectre-adds-new-chrome-os-features-519763.shtml)。
|
||
如何理解Apache 2.0许可证中的专利许可条款？
|
Jeffrey Robert Kaufman
|
https://opensource.com/article/18/2/how-make-sense-apache-2-patent-license
|
Apache 2.0许可证中的专利许可条款使得开源代码可以安全使用，但它经常被误解。
|
/data/attachment/album/201803/04/084004nqrsu0wgrgrzrq5r.png.thumb.jpg
|
/data/attachment/album/201803/04/084004nqrsu0wgrgrzrq5r.png
| true | false | true |
薛亮
| false |
[
"专利",
"许可证"
] |
开源智慧
|
{
"viewnum": 9897,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Apache 2.0许可证中的专利许可条款使得开源代码可以安全使用，但它经常被误解。
| 2018-03-04T08:36:00 | 2018-03-04T08:36:00 | 9,402 |
/article-9402-1.html
|
>
> 提要：Apache 2.0许可证中的专利许可条款使得开源代码可以安全使用，但它经常被误解。
>
>
>
Apache 2.0 许可证包含许多关键条款，其中也包括根据我的经验经常被误解的<ruby> 专利许可 <rp> （ </rp> <rt> patent grant </rt> <rp> ） </rp></ruby>条款。专利许可对于开源代码的安全使用具有重大影响。我通过分析 Apache 2.0 许可证第 3 部分的其中一段来具体解释：
>
> 3.<ruby> 专利许可的授予 <rp> （ </rp> <rt> Grant of Patent License </rt> <rp> ） </rp></ruby>。根据本许可证的条款和条件，每个<ruby> 贡献者 <rp> （ </rp> <rt> Contributor </rt> <rp> ） </rp></ruby>特此授予您永久的、全球性的、非独占的、免费的、免版税的、不可撤销的（本节所述除外）专利许可，从而制作、委托制作、使用、许诺销售、销售、进口和以其他方式转移<ruby> 作品 <rp> （ </rp> <rt> the Work </rt> <rp> ） </rp></ruby>，该专利许可仅适用于贡献者提供的满足以下条件的专利权利要求：贡献者的<ruby> 贡献 <rp> （ </rp> <rt> Contribution </rt> <rp> ） </rp></ruby>单独对该权利要求必然构成侵权，或贡献者的贡献与贡献者提交此类贡献的作品之间的结合对该权利要求必然构成侵权。
>
>
>
实质上，当软件开发人员为项目（即 Apache 2.0 许可证中的“作品”）贡献代码，他/她就成为贡献者。在上述条款中，贡献者授予了使用任何可能与其贡献相关的专利的许可。这让用户感到安心，因为贡献者可能会被禁止向任何使用包含该贡献的软件的用户收取专利许可费。
但当软件开发人员贡献的代码仅其自身来说没有被贡献者的任何专利所覆盖，而只有与贡献者提交此类贡献的遵循 Apache 2.0 许可证的开源项目相结合才能被相关专利覆盖时，问题就变得复杂了。因此，拥有相关专利的贡献者可以向使用修订版作品的用户收取专利许可费。Apache 2.0 许可证的作者进行了前瞻性思考，对这种情况也进行了说明。第 3 条规定，该许可证适用于“贡献者提供的满足以下条件的专利权利要求：……贡献者的贡献与贡献者提交此类贡献的作品之间的结合对该权利要求必然构成侵权。”
一些贡献者可能担心他们的贡献会导致广泛的专利许可。例如，您向遵循 Apache 2.0 许可证的开源项目贡献代码，在您提交贡献的时候，无论是您的贡献自身还是其与开源项目的结合都没有对您的专利构成侵权，但后续该作品通过其他人而非您的贡献在功能上进行了扩展，从而被您的专利所覆盖，这种情况该怎么办呢？您的专利会被自动许可吗？按照 Apache 软件基金会的常见问题解答，情况并非如此。
这个结果似乎以一种开放/合作的方式，在向 Apache 2.0 开源项目贡献代码的专利所有者与保证相关专利不会针对依据 Apache 2.0 许可证享有权益的作品用户主张专利权的必要性之间，达成了一种明智的平衡。
关于依据 Apache 2.0 许可证向 Apache 软件基金会提交贡献的专利许可范围的相关问题和答案，可以在 Apache 软件基金会有关许可的[常见问题解答](http://www.apache.org/foundation/license-faq.html)里找到。
请记住，这是 Apache 软件基金会对 Apache 2.0 许可证的解释。使用 Apache 2.0 许可证的其他许可人可能会以不同的方式解释该许可证中专利许可条款的范围，但我认为那似乎不太可能会成功，Apache 软件基金会的常见问题解答对专利许可条款的解释看起来合情合理。
---
作者简介：Jeffrey R. Kaufman 是全球领先的开源软件解决方案供应商 Red Hat 公司的开源知识产权律师，还担任<ruby> 托马斯杰斐逊法学院 <rp> （ </rp> <rt> Thomas Jefferson School of Law </rt> <rp> ） </rp></ruby>的兼职教授。在任职 Red Hat 之前，Jeffrey曾担任<ruby> 高通公司 <rp> （ </rp> <rt> Qualcomm Incorporated </rt> <rp> ） </rp></ruby>的专利顾问，为<ruby> 首席科学家办公室 <rp> （ </rp> <rt> Office of the Chief Scientist </rt> <rp> ） </rp></ruby>提供开源事务咨询。
译者简介：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
纪事：Linux 中国 2018 首次线下联合沙龙
|
Lc 团队
|
新年伊始，Linux 中国的 2018 年第一次线下沙龙于昨天在北上广杭四个城市成功召集。一如既往，由于超出了预计规模，这次的沙龙我们也是提前关闭了各地的报名通道。
|
/data/attachment/album/201803/04/145346gltck1ljc9zckltj.jpg.thumb.jpg
|
/data/attachment/album/201803/04/145346gltck1ljc9zckltj.jpg
| true | false | false | false |
[
"沙龙"
] |
新闻
|
{
"viewnum": 4084,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "124.205.131.210",
"message": "总算是通过实名认证了：<br />\r\n本人的PPT下载地址:https://pan.baidu.com/s/1tNf8eGh3RuCpQEGpANnFcA 密码:8ype",
"username": "Fine.Fan [Firefox 58.0|Mac 10.13]",
"date": "2018-03-12T09:57:20"
},
{
"postip": "61.157.97.83",
"message": "怎么才能实名认证啊",
"username": "XiaoJake [Chrome 78.0|Windows 10]",
"date": "2019-12-03T04:51:03"
},
{
"postip": "61.186.27.58",
"message": "已经取消这个环节了，并且……现在已经停止公开注册了。",
"username": "linux [Chrome 78.0|Mac 10.14]",
"date": "2019-12-11T08:03:07"
}
] |
[] |
新年伊始，Linux 中国的 2018 年第一次线下沙龙于昨天在北上广杭四个城市成功召集。一如既往，由于超出了预计规模，这次的沙龙我们也是提前关闭了各地的报名通道。
| 2018-03-04T14:51:00 | 2018-03-04T14:51:00 | 9,403 |
/article-9403-1.html
|
新年伊始，Linux 中国的 2018 年第一次线下沙龙于昨天在北上广杭四个城市成功召集。一如既往，由于超出了预计规模，这次的沙龙我们也是提前关闭了各地的报名通道。
本次沙龙是在北京、上海、广州和杭州举办的，以下是各地的一些沙龙花絮，分享给大家：
### 北京：最国际范的沙龙
北京依旧是在时光漫步咖啡厅举办的。此次沙龙活动邀请到了 BLUG（Beijing Linux User Group）召集人 Martin 和来自韩国的 GNOME Foundation 成员成大炫（DaeHyun Sung） 作为特邀嘉宾参加。
*从左往右，依次是北京站召集人宋贺、鬼谷子、Martin、成大炫*
这次沙龙由 Linux中国核心成员 Fine 分享了 《Use OpenSCAP to Scan CVE》。
本着自由的开源精神，Fine已经把 PPT 贡献出来，大家可以无偿自由下载。另外这里提一个小插曲，因为有国际友人在场， Fine 的分享是中英双语交替进行的。Martin 和成大炫也不断与在场小伙伴互动交流。
特邀的运维大咖「鬼谷子」也给现场的几位在校生和刚入职场的年轻人分享了运维人的职业规划经验。
*左一是著名 IT 专家鬼谷子，正在分享职业生涯*
分享之后，是抽奖和“书籍交换”环节。从 Python 入门到 Git 技巧，再到AI 人工智能，大家各自都交换到了心仪的书籍。
### 上海：最切实的分享
本次活动上海分站我们选在了中国共产党发源地——上海新天地附近的一家咖啡馆，为了能够占够位置，一叶、瑾萱、ONLY 暴露了他们脸皮的厚度，这三位小伙伴提前一小时来到咖啡馆，经过激烈研究最终采用了瑾萱妹子在大学图书馆占位策略，他们无视了无数人的横眉冷对并占位成功。
下午 2 点时分大家陆续到达，经过一番相互嘘寒问暖，会议开始了。会议由美丽大方的瑾萱妹子主持，会议第一个主题是《我们如何办好 Linux 中国线下沙龙》，大家针对每次会议主题选定、场所选址、活动形式等展开了 360 度无死角讨论。
会议第二个主题是由 LCTT 核心成员昀为大家分享的《Information Open Source》，这位欧洲生活了五六年的集帅与才华的男子的分享将大家对开源的激情带到了最高点，他诚恳的提出了 LCTT 在翻译中的几个问题，并且利用自己在国外生活多年的生活经验为大家一一给出了详实的解决办法。
接下来是我们程序猿大牛一叶为大家分享的《矿池原理》，我只想说一句，我应该早日加入 Linux 中国，我是不是就应该是白富美了？
最后一个环节是我们的图书交换，大家将自己的精神食粮拿来交换，我想这也是一种开源的精神吧。最后特别感谢我们的马丁同学——我们的专职摄影，他无私的奉献记录着我们 Linux 中国的每一步发展脚印。
### 广州：最苗条的聚会
广州站依然以交流为主，分享为辅助，主要由 Locez 分享了 Yubikey 的基本知识，比较接地气。
大家说话也比较实在，而且比较有趣的是大家在本次活动对抽书环节很谦让，抽中资格的小伙伴都纷纷谦让给别人，只取自己有用的，大家对于以后的活动更加倾向于聚会闲聊，或者可以进行户外活动。
### 杭州：技术含量最高的聚会
杭州是第一次加入到 Linux 中国线下沙龙中的，报名小伙伴热情都很高大部分都提前到达聚会地点。
沙龙在佛性主持 penghuster 的开场白下，一片欢声笑语中开始。
首先进行了自我介绍，其中初中生大牛 OriginCode 震惊全场，还有第二代程序猿技术大咖捧场。接着进行了核心主题分享环节，首先初中生大牛为我们带来了《一个初中生的 Linux 养成记》，在分享中，初中生大牛口中蹦出的各种在下闻所未闻专业名词让我近距离感受到差距，而且成绩常年年级前三，写代码对他来说就是娱乐、就是享受、就是放松，我也有幸亲眼目睹了别人家的小孩长得原来就是这个样子。
*前排从左往右：OriginCode、朱晴、茹丹*
接着一位爬虫高手鲁金达为我们带来《爬虫那些看不见的坑》，还现场演示如何避免踩坑。
最后特邀出席的技术大咖杨小浩本以为是一个讲座类的分享准备了一个长达 85 页 ppt 的《容器安全》，但由于时间有限，临时变更为分享其多年程序猿道路的心路历程，让我们见识到其从服务器做到云计算，再到容器，现在到智能硬件如何总是走在浪潮的最顶端。
最后进行旧书交换的环节，本来是准备有偿交换，但本着"互助、贡献、共享"的开源精神，我提议免费交换旧书，得到小伙伴们的积极响应，在场的小伙伴都挑选到自己感兴趣的书籍，发挥出书籍最大的价值。
### 总结
作为 Linux 中国线下化的重要举措，以后我们每个月都会在各个城市举办沙龙，希望大家不仅仅是网上的朋友，也能在线下成为好友。下一步，我们还将扩大城市范围，比如深圳就有很多同学举手报名了。
|
||||
如何修复 WordPress 中的 HTTP 错误
|
Rosehosting
|
https://www.rosehosting.com/blog/http-error-wordpress/
|
下面列出了 WordPress 用户遇到的最常见的 HTTP 错误，我们的建议侧重于如何发现错误原因以及解决方法。
|
/data/attachment/album/201803/04/231839m452773kvkq2qcg5.jpg.thumb.jpg
|
/data/attachment/album/201803/04/231839m452773kvkq2qcg5.jpg
| true | false | true |
wenwensnow
| false |
[
"WordPress"
] |
技术
|
{
"viewnum": 10586,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
下面列出了 WordPress 用户遇到的最常见的 HTTP 错误，我们的建议侧重于如何发现错误原因以及解决方法。
| 2018-03-04T23:18:45 | 2018-03-04T23:18:45 | 9,404 |
/article-9404-1.html
|
我们会向你介绍，如何在 Linux VPS 上修复 WordPress 中的 HTTP 错误。 下面列出了 WordPress 用户遇到的最常见的 HTTP 错误，我们的建议侧重于如何发现错误原因以及解决方法。
### 1、 修复在上传图像时出现的 HTTP 错误
如果你在基于 WordPress 的网页中上传图像时出现错误，这也许是因为服务器上 PHP 的配置，例如存储空间不足或者其他配置问题造成的。
用如下命令查找 php 配置文件：
```
php -i | grep php.ini
Configuration File (php.ini) Path => /etc
Loaded Configuration File => /etc/php.ini
```
根据输出结果，php 配置文件位于 `/etc` 文件夹下。编辑 `/etc/php.ini` 文件，找出下列行，并按照下面的例子修改其中相对应的值：
```
vi /etc/php.ini
```
```
upload_max_filesize = 64M
post_max_size = 32M
max_execution_time = 300
max_input_time 300
memory_limit = 128M
```
当然，如果你不习惯使用 vi 文本编辑器，你可以选用自己喜欢的。
不要忘记重启你的网页服务器来让改动生效。
如果你安装的网页服务器是 Apache，你也可以使用 `.htaccess` 文件。首先，找到 `.htaccess` 文件。它位于 WordPress 安装路径的根文件夹下。如果没有找到 `.htaccess` 文件，需要自己手动创建一个，然后加入如下内容：
```
vi /www/html/path_to_wordpress/.htaccess
```
```
php_value upload_max_filesize 64M
php_value post_max_size 32M
php_value max_execution_time 180
php_value max_input_time 180
# BEGIN WordPress
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>
# END WordPress
```
如果你使用的网页服务器是 nginx，在 nginx 的 `server` 配置块中配置你的 WordPress 实例。详细配置和下面的例子相似：
```
server {
listen 80;
client_max_body_size 128m;
client_body_timeout 300;
server_name your-domain.com www.your-domain.com;
root /var/www/html/wordpress;
index index.php;
location = /favicon.ico {
log_not_found off;
access_log off;
}
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
location / {
try_files $uri $uri/ /index.php?$args;
}
location ~ \.php$ {
include fastcgi_params;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}
location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
expires max;
log_not_found off;
}
}
```
根据自己的 PHP 配置，你需要将 `fastcgi_pass 127.0.0.1:9000;` 用类似于 `fastcgi_pass unix:/var/run/php7-fpm.sock;` 替换掉（依照实际连接方式）
重启 nginx 服务来使改动生效。
### 2、 修复因为不恰当的文件权限而产生的 HTTP 错误
如果你在 WordPress 中出现一个意外错误，也许是因为不恰当的文件权限导致的，所以需要给 WordPress 文件和文件夹设置一个正确的权限：
```
chown www-data:www-data -R /var/www/html/path_to_wordpress/
```
将 `www-data` 替换成实际的网页服务器用户，将 `/var/www/html/path_to_wordpress` 换成 WordPress 的实际安装路径。
### 3、 修复因为内存不足而产生的 HTTP 错误
你可以通过在 `wp-config.php` 中添加如下内容来设置 PHP 的最大内存限制：
```
define('WP_MEMORY_LIMIT', '128MB');
```
### 4、 修复因为 php.ini 文件错误配置而产生的 HTTP 错误
编辑 PHP 配置主文件，然后找到 `cgi.fix_pathinfo` 这一行。 这一行内容默认情况下是被注释掉的，默认值为 `1`。取消这一行的注释（删掉这一行最前面的分号），然后将 `1` 改为 `0` 。同时需要修改 `date.timezone` 这一 PHP 设置，再次编辑 PHP 配置文件并将这一选项改成 `date.timezone = Asia/Shanghai` （或者将等号后内容改为你所在的时区）。
```
vi /etc/php.ini
```
```
cgi.fix_pathinfo=0
date.timezone = Asia/Shanghai
```
### 5、 修复因为 Apache mod\_security 模块而产生的 HTTP 错误
如果你在使用 Apache mod\_security 模块，这可能也会引起问题。试着禁用这一模块，确认是否因为在 `.htaccess` 文件中加入如下内容而引起了问题：
```
<IfModule mod_security.c>
SecFilterEngine Off
SecFilterScanPOST Off
</IfModule>
```
### 6、 修复因为有问题的插件/主题而产生的 HTTP 错误
一些插件或主题也会导致 HTTP 错误以及其他问题。你可以首先禁用有问题的插件/主题，或暂时禁用所有 WordPress 插件。如果你有 phpMyAdmin，使用它来禁用所有插件：在其中找到 `wp_options` 数据表，在 `option_name` 这一列中找到 `active_plugins` 这一记录，然后将 `option_value` 改为 ：`a:0:{}`。
或者用以下命令通过SSH重命名插件所在文件夹：
```
mv /www/html/path_to_wordpress/wp-content/plugins /www/html/path_to_wordpress/wp-content/plugins.old
```
通常情况下，HTTP 错误会被记录在网页服务器的日志文件中，所以寻找错误时一个很好的切入点就是查看服务器日志。
---
via: <https://www.rosehosting.com/blog/http-error-wordpress/>
作者：[rosehosting](https://www.rosehosting.com) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
fold 命令入门示例教程
|
Sk
|
https://www.ostechnix.com/fold-command-tutorial-examples-beginners/
|
你有没有发现自己在某种情况下想要折叠或中断命令的输出，以适应特定的宽度？
|
/data/attachment/album/201803/04/233523lt0e7ysyxsee7pyj.png.thumb.jpg
|
/data/attachment/album/201803/04/233523lt0e7ysyxsee7pyj.png
| true | false | true |
Flowsnow
| false |
[
"fold"
] |
技术
|
{
"viewnum": 3954,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你有没有发现自己在某种情况下想要折叠或中断命令的输出，以适应特定的宽度？
| 2018-03-04T23:35:00 | 2018-03-04T23:35:00 | 9,405 |
/article-9405-1.html
|
你有没有发现自己在某种情况下想要折叠或中断命令的输出，以适应特定的宽度？在运行虚拟机的时候，我遇到了几次这种的情况，特别是没有 GUI 的服务器。 以防万一，如果你想限制一个命令的输出为一个特定的宽度，现在看看这里！ `fold` 命令在这里就能派的上用场了！ `fold` 命令会以适合指定的宽度调整输入文件中的每一行，并将其打印到标准输出。
在这个简短的教程中，我们将看到 `fold` 命令的用法，带有实例。
### fold 命令示例教程
`fold` 命令是 GNU coreutils 包的一部分，所以我们不用为安装的事情烦恼。
`fold` 命令的典型语法：
```
fold [OPTION]... [FILE]...
```
请允许我向您展示一些示例，以便您更好地了解 `fold` 命令。 我有一个名为 `linux.txt` 文件，内容是随机的。
要将上述文件中的每一行换行为默认宽度，请运行：
```
fold linux.txt
```
每行 80 列是默认的宽度。 这里是上述命令的输出：
正如你在上面的输出中看到的，`fold` 命令已经将输出限制为 80 个字符的宽度。
当然，我们可以指定您的首选宽度，例如 50，如下所示：
```
fold -w50 linux.txt
```
示例输出：
我们也可以将输出写入一个新的文件，如下所示：
```
fold -w50 linux.txt > linux1.txt
```
以上命令将把 `linux.txt` 的行宽度改为 50 个字符，并将输出写入到名为 `linux1.txt` 的新文件中。
让我们检查一下新文件的内容：
```
cat linux1.txt
```
你有没有注意到前面的命令的输出？ 有些词在行之间被中断。 为了解决这个问题，我们可以使用 `-s` 标志来在空格处换行。
以下命令将给定文件中的每行调整为宽度 50，并在空格处换到新行：
```
fold -w50 -s linux.txt
```
示例输出：
看清楚了吗？ 现在，输出很清楚。 换到新行中的单词都是用空格隔开的，所在行单词的长度大于 50 的时候就会被调整到下一行。
在所有上面的例子中，我们用列来限制输出宽度。 但是，我们可以使用 `-b` 选项将输出的宽度强制为指定的字节数。 以下命令以 20 个字节中断输出。
```
fold -b20 linux.txt
```
示例输出：
另请阅读：
* [Uniq 命令入门级示例教程](https://www.ostechnix.com/uniq-command-tutorial-examples-beginners/)
有关更多详细信息，请参阅 man 手册页。
```
man fold
```
这些就是所有的内容了。 您现在知道如何使用 `fold` 命令以适应特定的宽度来限制命令的输出。 我希望这是有用的。 我们将每天发布更多有用的指南。 敬请关注！
干杯!
---
via: <https://www.ostechnix.com/fold-command-tutorial-examples-beginners/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[Flowsnow](https://github.com/Flowsnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
什么是 CGManager？
|
Canonical Ltd.
|
https://linuxcontainers.org/cgmanager/introduction/
|
CGManager 是一个核心的特权守护进程，通过一个简单的 D-Bus API 管理你所有的 cgroup。它被设计用来处理嵌套的 LXC 容器以及接受无特权的请求，包括解析用户名称空间的 UID/GID。
|
/data/attachment/album/201803/05/002752zegdnjo88vnnjmag.jpg.thumb.jpg
|
/data/attachment/album/201803/05/002752zegdnjo88vnnjmag.jpg
| true | false | true |
geekpi
| false |
[
"容器",
"LXC",
"CGManager"
] |
容器与云
|
{
"viewnum": 4309,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
CGManager 是一个核心的特权守护进程，通过一个简单的 D-Bus API 管理你所有的 cgroup。它被设计用来处理嵌套的 LXC 容器以及接受无特权的请求，包括解析用户名称空间的 UID/GID。
| 2018-03-05T00:28:00 | 2018-03-05T00:28:00 | 9,406 |
/article-9406-1.html
|
CGManager 是一个核心的特权守护进程，通过一个简单的 D-Bus API 管理你所有的 cgroup。它被设计用来处理嵌套的 LXC 容器以及接受无特权的请求，包括解析用户名称空间的 UID/GID。
### 组件
#### cgmanager
这个守护进程在宿主机上运行，将 cgroupfs 挂载到一个独立的挂载名称空间（所以它不能从宿主机上看到），绑定 `/sys/fs/cgroup/cgmanager/sock` 用于传入的 D-Bus 查询，并通常处理宿主机上直接运行的所有客户端。
cgmanager 既接受使用 D-Bus + SCM 凭证的身份验证请求，用于在命名空间之间转换 uid、gid 和 pid，也可以使用简单的 “unauthenticated”（只是初始的 ucred）D-Bus 来查询来自宿主机级别的查询。
#### cgproxy
你可能会在两种情况下看到这个守护进程运行。在宿主机上，如果你的内核老于 3.8（没有 pidns 连接支持）或处于容器中（只有 cgproxy 运行）。
cgproxy 本身并不做任何 cgroup 配置更改，而是如其名称所示，代理请求给主 cgmanager 进程。
这是必要的，所以一个进程可以直接使用 D-Bus（例如使用 dbus-send）与 `/sys/fs/cgroup/cgmanager/sock` 进行通信。
之后 cgproxy 将从该查询中得到 ucred，并对真正的 cgmanager 套接字进行身份验证的 SCM 查询，并通过 ucred 结构体传递参数，使它们能够正确地转换为 cgmanager 可以理解的宿主机命名空间 。
#### cgm
一个简单的命令行工具，与 D-Bus 服务通信，并允许你从命令行执行所有常见的 cgroup 操作。
### 通信协议
如上所述，cgmanager 和 cgproxy 使用 D-Bus。建议外部客户端（所以不要是 cgproxy）使用标准的 D-Bus API，不要试图实现 SCM creds 协议，因为它是不必要的，并且容易出错。
相反，只要简单假设与 `/sys/fs/cgroup/cgmanager/sock` 的通信总是正确的。
cgmanager API 仅在独立的 D-Bus 套接字上可用，cgmanager 本身不连接到系统总线，所以 cgmanager/cgproxy 不要求有运行中的 dbus 守护进程。
你可以在[这里](https://linuxcontainers.org/cgmanager/dbus-api/)阅读更多关于 D-Bus API。
### 许可证
CGManager 是免费软件，大部分代码是根据 GNU LGPLv2.1+ 许可条款发布的，一些二进制文件是在 GNU GPLv2 许可下发布的。
该项目的默认许可证是 GNU LGPLv2.1+
### 支持
CGManager 的稳定版本支持依赖于 Linux 发行版以及它们自己承诺推出稳定修复和安全更新。
你可以从 [Canonical Ltd](http://www.canonical.com/) 获得对 Ubuntu LTS 版本的 CGManager 的商业支持。
---
via: <https://linuxcontainers.org/cgmanager/introduction/>
作者：[Canonical Ltd.](http://www.canonical.com/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 pass 密码管理器管理你的密码
|
Egidio Docile
|
https://linuxconfig.org/how-to-organize-your-passwords-using-pass-password-manager
|
学习在 Linux 上使用 pass 密码管理器来管理你的密码
|
/data/attachment/album/201803/05/005753heq3yv8dz8d5dspl.jpg.thumb.jpg
|
/data/attachment/album/201803/05/005753heq3yv8dz8d5dspl.jpg
| true | false | true |
lujun9972
| false |
[
"密码",
"pass",
"密码管理器"
] |
桌面应用
|
{
"viewnum": 6796,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习在 Linux 上使用 pass 密码管理器来管理你的密码
| 2018-03-05T00:58:06 | 2018-03-05T00:58:06 | 9,407 |
/article-9407-1.html
|
### 目标
学习在 Linux 上使用 pass 密码管理器来管理你的密码
### 条件
* 需要 root 权限来安装需要的包
### 难度
简单
### 约定
* `#` - 执行指定命令需要 root 权限，可以是直接使用 root 用户来执行或者使用 `sudo` 命令来执行
* `$` - 使用普通的非特权用户执行指定命令
### 介绍
如果你有根据不同的意图设置不同密码的好习惯，你可能已经感受到需要一个密码管理器的必要性了。在 Linux 上有很多选择，可以是专有软件（如果你敢用的话）也可以是开源软件。如果你跟我一样喜欢简洁的话，你可能会对 `pass` 感兴趣。
### 第一步
pass 作为一个密码管理器，其实际上是一些你可能早已每天使用的、可信赖且实用的工具的一种封装，比如 `gpg` 和 `git` 。虽然它也有图形界面，但它专门设计能成在命令行下工作的：因此它也可以在 headless 机器上工作（LCTT 译注：根据 wikipedia 的说法，所谓 headless 是指没有显示器、键盘和鼠标的机器，一般通过网络链接来控制）。
### 安装
pass 在主流的 Linux 发行版中都是可用的，你可以通过包管理器安装：
#### Fedora
```
# dnf install pass
```
#### RHEL 和 CentOS
pass 不在官方仓库中，但你可以从 `epel` 中获取道它。要在 CentOS7 上启用后面这个源，只需要执行：
```
# yum install epel-release
```
然而在 Red Hat 企业版的 Linux 上，这个额外的源是不可用的；你需要从 EPEL 官方网站上下载它。
#### Debian 和 Ubuntu
```
# apt-get install pass
```
#### Arch Linux
```
# pacman -S pass
```
### 初始化密码仓库
安装好 `pass` 后，就可以开始使用和配置它了。首先，由于 `pass` 依赖于 `gpg` 来对我们的密码进行加密并以安全的方式进行存储，我们必须准备好一个 gpg 密钥对。
首先我们要初始化密码仓库：这就是一个用来存放 gpg 加密后的密码的目录。默认情况下它会在你的 `$HOME` 创建一个隐藏目录，不过你也可以通过使用 `PASSWORD_STORE_DIR` 这一环境变量来指定另一个路径。让我们运行：
```
$ pass init
```
然后 `password-store` 目录就创建好了。现在，让我们来存储我们第一个密码：
```
$ pass edit mysite
```
这会打开默认文本编辑器，我么只需要输入密码就可以了。输入的内容会用 gpg 加密并存储为密码仓库目录中的 `mysite.gpg` 文件。
`pass` 以目录树的形式存储加密后的文件，也就是说我们可以在逻辑上将多个文件放在子目录中以实现更好的组织形式，我们只需要在创建文件时指定存在哪个目录下就行了，像这样：
```
$ pass edit foo/bar
```
跟上面的命令一样，它也会让你输入密码，但是创建的文件是放在密码仓库目录下的 `foo` 子目录中的。要查看文件组织结构，只需要不带任何参数运行 `pass` 命令即可：
```
$ pass
Password Store
├── foo
│ └── bar
└── mysite
```
若想修改密码，只需要重复创建密码的操作就行了。
### 获取密码
有两种方法可以获取密码：第一种会显示密码到终端上，方法是运行：
```
pass mysite
```
然而更好的方法是使用 `-c` 选项让 `pass` 将密码直接拷贝到剪切板上：
```
pass -c mysite
```
这种情况下剪切板中的内容会在 `45` 秒后自动清除。两种方法都会要求你输入 gpg 密码。
### 生成密码
`pass` 也可以为我们自动生成（并自动存储）安全密码。假设我们想要生成一个由 15 个字符组成的密码：包含字母，数字和特殊符号，其命令如下：
```
pass generate mysite 15
```
若希望密码只包含字母和数字则可以是使用 `--no-symbols` 选项。生成的密码会显示在屏幕上。也可以通过 `--clip` 或 `-c` 选项让 `pass` 把密码直接拷贝到剪切板中。通过使用 `-q` 或 `--qrcode` 选项来生成二维码：
从上面的截屏中可看出，生成了一个二维码，不过由于运行该命令时 `mysite` 的密码已经存在了，`pass` 会提示我们确认是否要覆盖原密码。
`pass` 使用 `/dev/urandom` 设备作为（伪）随机数据生成器来生成密码，同时它使用 `xclip` 工具来将密码拷贝到粘帖板中，而使用 `qrencode` 来将密码以二维码的形式显示出来。在我看来，这种模块化的设计正是它最大的优势：它并不重复造轮子，而只是将常用的工具包装起来完成任务。
你也可以使用 `pass mv`、`pass cp` 和 `pass rm` 来重命名、拷贝和删除密码仓库中的文件。
### 将密码仓库变成 git 仓库
`pass` 另一个很棒的功能就是可以将密码仓库当成 git 仓库来用：通过版本管理系统能让我们管理密码更方便。
```
pass git init
```
这会创建 git 仓库，并自动提交所有已存在的文件。下一步就是指定跟踪的远程仓库了：
```
pass git remote add <name> <url>
```
我们可以把这个密码仓库当成普通仓库来用。唯一的不同点在于每次我们新增或修改一个密码，`pass` 都会自动将该文件加入索引并创建一个提交。
`pass` 有一个叫做 `qtpass` 的图形界面，而且也支持 Windows 和 MacOs。通过使用 `PassFF` 插件，它还能获取 firefox 中存储的密码。在它的项目网站上可以查看更多详细信息。试一下 `pass` 吧，你不会失望的！
---
via: <https://linuxconfig.org/how-to-organize-your-passwords-using-pass-password-manager>
作者：[Egidio Docile](https://linuxconfig.org) 译者：[lujun9972](https://github.com/lujun9972) 校对：[Locez](https://github.com/locez)
本文由 [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.