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
sequence | 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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
如何在 Ubuntu 上安装和使用 R 语言 | Sergiu | https://itsfoss.com/install-r-ubuntu/ | 这个教程指导你如何在 Ubuntu 上安装 R 语言。你也将同时学习到如何在 Ubuntu 上用不同方法运行简单的 R 语言程序。 | /data/attachment/album/201909/11/115259umnrin57vlrrhixl.jpg.thumb.jpg | /data/attachment/album/201909/11/115259umnrin57vlrrhixl.jpg | true | false | true | lujun9972 | guevaraya | wxy | false | [
"R语言"
] | 技术 | {
"viewnum": 15406,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "117.89.3.38",
"message": "请问怎么在manjaro上安装 R 语言？",
"username": "cdercder [Firefox 69.0|GNU/Linux]",
"date": "2019-09-13T20:23:22"
},
{
"postip": "111.18.93.166",
"message": "https://forum.manjaro.org/t/using-the-statistical-package-r-in-manjaro-with-rstudio/484 <br />\r\n希望能帮到你",
"username": "styl_007 [Chrome 76.0|Windows 7]",
"date": "2019-09-16T23:42:15"
},
{
"postip": "117.89.3.38",
"message": "谢谢，特别感谢",
"username": "cdercder [Firefox 69.0|GNU/Linux]",
"date": "2019-09-17T13:33:24"
}
] | [] | 这个教程指导你如何在 Ubuntu 上安装 R 语言。你也将同时学习到如何在 Ubuntu 上用不同方法运行简单的 R 语言程序。 | 2019-09-11T11:52:57 | 2019-09-11T11:52:57 | 11,331 | /article-11331-1.html |
>
> 这个教程指导你如何在 Ubuntu 上安装 R 语言。你也将同时学习到如何在 Ubuntu 上用不同方法运行简单的 R 语言程序。
>
>
>
[R](https://www.r-project.org/)，和 Python 一样，它是在统计计算和图形处理上最常用的编程语言，易于处理数据。随着数据分析、数据可视化、数据科学（机器学习热）的火热化，对于想深入这一领域的人来说，它是一个很好的工具。
R 语言的优点是它的语法非常简练，你可以找到它的很多实际使用的教程或指南。
本文将介绍包含如何在 Ubuntu 下安装 R 语言，也会介绍在 Linux 下如何运行第一个 R 程序。
### 如何在 Ubuntu 上安装 R 语言
R 默认在 Ubuntu 的软件库里。用以下命令很容易安装：
```
sudo apt install r-base
```
请注意这可能会安装一个较老的版本。在我写这篇文字的时候，Ubuntu 提供的是 3.4，但是最新的是3.6。
*我建议除非你必须使用最新版本，否则直接使用 Ubuntu 的配套版本。*
#### 如何在 Ubuntu 上安装最新 3.6 版本的 R 环境
如果想安装最新的版本（或特殊情况指定版本），你必须用 [CRAN](https://cran.r-project.org/)（Comprehensive R Archive Network）。这个是 R 最新版本的镜像列表。
如需获取 3.6 的版本，需要添加镜像到你的源索引里。我已经简化其命令如下：
```
sudo add-apt-repository "deb https://cloud.r-project.org/bin/linux/ubuntu $(lsb_release -cs)-cran35/"
```
下面你需要添加密钥到服务器中：
```
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9
```
然后更新服务器信息并安装R环境：
```
sudo apt update
sudo apt install r-base
```
就这样安装完成。
### 如何在 Ubuntu 下使用 R 语言编程
R 的用法多样，我将介绍运行多个运行 R 语言的方式。
#### R 语言的交互模式
安装了 R 语言后，你可以在控制台上直接运行：
```
R
```
这样会打开交互模式：
R 语言的控制台与 Python 和 Haskell 的交互模式很类似。你可以输入 R 命令做一些基本的数学运算，例如：
```
> 20+40
[1] 60
> print ("Hello World!")
[1] "Hello World!"
```
你可以测试绘图：
如果想退出可以用 `q()`或按下 `CTRL+c`键。接着你会被提示是否保存工作空间镜像；工作空间是创建变量的环境。
#### 用 R 脚本运行程序
第二种运行 R 程序的方式是直接在 Linux 命令行下运行。你可以用 `RScript` 执行，它是一个包含 `r-base` 软件包的工具。
首先，你需要用你在 [Linux 下常用的编辑器](https://itsfoss.com/best-modern-open-source-code-editors-for-linux/)保存 R 程序到文件。文件的扩展名必须是 `.r`。
下面是一个打印 “Hello World” 的 R 程序。你可以保存其为 `hello.r`。
```
print("Hello World!")
a <- rnorm(100)
plot(a)
```
用下面命令运行 R 程序：
```
Rscript hello.r
```
你会得到如下输出结果：
```
[1] "Hello World!"
```
结果将会保存到当前工作目录，文件名为 `Rplots.pdf`：
小提示：`Rscript` 默认不会加载 `methods` 包。确保在脚本中[显式加载](https://www.dummies.com/programming/r/how-to-install-load-and-unload-packages-in-r/)它。
#### 在 Ubuntu 下用 RStudio 运行 R 语言
最常见的 R 环境是 [RStudio](https://www.rstudio.com/)，这是一个强大的跨平台的开源 IDE。你可以用 deb 文件在 Ubuntu 上安装它。下载 deb 文件的链接如下。你需要向下滚动找到 Ubuntu 下的 DEB 文件。
* [下载 Ubuntu 的 Rstudio](https://www.rstudio.com/products/rstudio/download/#download)
下载了 DEB 文件后，直接点击安装。
下载后从菜单搜索启动它。程序主界面会弹出如下：
现在可以看到和 R 命令终端一样的工作台。
创建一个文件：点击顶栏 “File” 然后选择 “New File > Rscript”（或 `CTRL+Shift+n`）：
按下 `CTRL+s` 保存文件选择路径和命名：
这样做了后，点击 “Session > Set Working Directory > To Source File Location” 修改工作目录为你的脚本路径：
现在一切准备就绪！编写代码然后点击运行。你可以在控制台和图形窗口看到结果：
### 结束语
这篇文章中展示了如何在 Ubuntu 下使用 R 语言。包含了以下几个方面：R 控制台 —— 可用于测试，Rscript —— 终端达人操作，RStudio —— 你想要的 IDE。
无论你正在从事数据科学或只是热爱数据统计，作为一个数据分析的完美工具，R 都是一个比较好的编程装备。
你想使用 R 吗？你入门了吗？让我们了解你是如何学习 R 的以及为什么要学习 R!
---
via: <https://itsfoss.com/install-r-ubuntu/>
作者：[Sergiu](https://itsfoss.com/author/sergiu/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[guevaraya](https://github.com/guevaraya) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 HTTPie 进行 API 测试 | Moshe Zadka | https://opensource.com/article/19/8/getting-started-httpie | 使用 HTTPie 调试 API，这是一个用 Python 写的易用的命令行工具。 | /data/attachment/album/201909/12/102919ry1ute1y9h991ftz.jpg.thumb.jpg | /data/attachment/album/201909/12/102919ry1ute1y9h991ftz.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"HTTPie"
] | 软件开发 | {
"viewnum": 6131,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 使用 HTTPie 调试 API，这是一个用 Python 写的易用的命令行工具。 | 2019-09-12T10:29:59 | 2019-09-12T10:29:59 | 11,333 | /article-11333-1.html |
>
> 使用 HTTPie 调试 API，这是一个用 Python 写的易用的命令行工具。
>
>
>
[HTTPie](https://httpie.org/) 是一个非常易用、易于升级的 HTTP 客户端。它的发音为 “aitch-tee-tee-pie” 并以 `http` 命令运行，它是一个用 Python 编写的来用于访问 Web 的命令行工具。
由于这是一篇关于 HTTP 客户端的指导文章，因此你需要一个 HTTP 服务器来试用它。在这里，访问 [httpbin.org](https://github.com/postmanlabs/httpbin)，它是一个简单的开源 HTTP 请求和响应服务。httpbin.org 网站是一种测试 Web API 的强大方式，并能仔细管理并显示请求和响应内容，不过现在让我们专注于 HTTPie 的强大功能。
### Wget 和 cURL 的替代品
你可能听说过古老的 [Wget](https://en.wikipedia.org/wiki/Wget) 或稍微新一些的 [cURL](https://en.wikipedia.org/wiki/CURL) 工具，它们允许你从命令行访问 Web。它们是为访问网站而编写的，而 HTTPie 则用于访问 Web API。
网站请求发生在计算机和正在阅读并响应它所看到的内容的最终用户之间，这并不太依赖于结构化的响应。但是，API 请求会在两台计算机之间进行*结构化*调用，人并不是该流程内的一部分，像 HTTPie 这样的命令行工具的参数可以有效地处理这个问题。
### 安装 HTTPie
有几种方法可以安装 HTTPie。你可以通过包管理器安装，无论你使用的是 `brew`、`apt`、`yum` 还是 `dnf`。但是，如果你已配置 [virtualenvwrapper](https://opensource.com/article/19/6/virtual-environments-python-macos)，那么你可以用自己的方式安装：
```
$ mkvirtualenv httpie
...
(httpie) $ pip install httpie
...
(httpie) $ deactivate
$ alias http=~/.virtualenvs/httpie/bin/http
$ http -b GET https://httpbin.org/get
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "HTTPie/1.0.2"
},
"origin": "104.220.242.210, 104.220.242.210",
"url": "https://httpbin.org/get"
}
```
通过将 `http` 别名指向为虚拟环境中的命令，即使虚拟环境在非活动状态，你也可以运行它。你可以将 `alias` 命令放在 `.bash_profile` 或 `.bashrc` 中，这样你就可以使用以下命令升级 HTTPie：
```
$ ~/.virtualenvs/httpie/bin/pip install -U pip
```
### 使用 HTTPie 查询网站
HTTPie 可以简化查询和测试 API。上面使用了一个选项，`-b`（即 `--body`）。没有它，HTTPie 将默认打印整个响应，包括响应头：
```
$ http GET https://httpbin.org/get
HTTP/1.1 200 OK
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Connection: keep-alive
Content-Encoding: gzip
Content-Length: 177
Content-Type: application/json
Date: Fri, 09 Aug 2019 20:19:47 GMT
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "HTTPie/1.0.2"
},
"origin": "104.220.242.210, 104.220.242.210",
"url": "https://httpbin.org/get"
}
```
这在调试 API 服务时非常重要，因为大量信息在响应头中发送。例如，查看发送的 cookie 通常很重要。httpbin.org 提供了通过 URL 路径设置 cookie（用于测试目的）的方式。以下设置一个标题为 `opensource`， 值为 `awesome` 的 cookie：
```
$ http GET https://httpbin.org/cookies/set/opensource/awesome
HTTP/1.1 302 FOUND
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Connection: keep-alive
Content-Length: 223
Content-Type: text/html; charset=utf-8
Date: Fri, 09 Aug 2019 20:22:39 GMT
Location: /cookies
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
Set-Cookie: opensource=awesome; Path=/
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<title>Redirecting...</title>
<h1>Redirecting...</h1>
<p>You should be redirected automatically to target URL:
<a href="/cookies">/cookies</a>. If not click the link.
```
注意 `Set-Cookie: opensource=awesome; Path=/` 的响应头。这表明你预期设置的 cookie 已正确设置，路径为 `/`。另请注意，即使你得到了 `302` 重定向，`http` 也不会遵循它。如果你想要遵循重定向，则需要明确使用 `--follow` 标志请求：
```
$ http --follow GET https://httpbin.org/cookies/set/opensource/awesome
HTTP/1.1 200 OK
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Connection: keep-alive
Content-Encoding: gzip
Content-Length: 66
Content-Type: application/json
Date: Sat, 10 Aug 2019 01:33:34 GMT
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
{
"cookies": {
"opensource": "awesome"
}
}
```
但此时你无法看到原来的 `Set-Cookie` 头。为了看到中间响应，你需要使用 `--all`：
```
$ http --headers --all --follow GET https://httpbin.org/cookies/set/opensource/awesome
HTTP/1.1 302 FOUND
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Content-Type: text/html; charset=utf-8
Date: Sat, 10 Aug 2019 01:38:40 GMT
Location: /cookies
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
Set-Cookie: opensource=awesome; Path=/
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
Content-Length: 223
Connection: keep-alive
HTTP/1.1 200 OK
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Content-Encoding: gzip
Content-Type: application/json
Date: Sat, 10 Aug 2019 01:38:41 GMT
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
Content-Length: 66
Connection: keep-alive
```
打印响应体并不有趣，因为你大多数时候只关心 cookie。如果你想看到中间请求的响应头，而不是最终请求中的响应体，你可以使用：
```
$ http --print hb --history-print h --all --follow GET https://httpbin.org/cookies/set/opensource/awesome
HTTP/1.1 302 FOUND
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Content-Type: text/html; charset=utf-8
Date: Sat, 10 Aug 2019 01:40:56 GMT
Location: /cookies
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
Set-Cookie: opensource=awesome; Path=/
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
Content-Length: 223
Connection: keep-alive
HTTP/1.1 200 OK
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Content-Encoding: gzip
Content-Type: application/json
Date: Sat, 10 Aug 2019 01:40:56 GMT
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
Content-Length: 66
Connection: keep-alive
{
"cookies": {
"opensource": "awesome"
}
}
```
你可以使用 `--print` 精确控制打印的内容（`h`：响应头；`b`：响应体），并使用 `--history-print` 覆盖中间请求的打印内容设置。
### 使用 HTTPie 下载二进制文件
有时响应体并不是文本形式，它需要发送到可被不同应用打开的文件：
```
$ http GET https://httpbin.org/image/jpeg
HTTP/1.1 200 OK
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Connection: keep-alive
Content-Length: 35588
Content-Type: image/jpeg
Date: Fri, 09 Aug 2019 20:25:49 GMT
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
+-----------------------------------------+
| NOTE: binary data not shown in terminal |
+-----------------------------------------+
```
要得到正确的图片，你需要保存到文件：
```
$ http --download GET https://httpbin.org/image/jpeg
HTTP/1.1 200 OK
Access-Control-Allow-Credentials: true
Access-Control-Allow-Origin: *
Connection: keep-alive
Content-Length: 35588
Content-Type: image/jpeg
Date: Fri, 09 Aug 2019 20:28:13 GMT
Referrer-Policy: no-referrer-when-downgrade
Server: nginx
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
Downloading 34.75 kB to "jpeg.jpe"
Done. 34.75 kB in 0.00068s (50.05 MB/s)
```
试一下！图片很可爱。
### 使用 HTTPie 发送自定义请求
你可以发送指定的请求头。这对于需要非标准头的自定义 Web API 很有用：
```
$ http GET https://httpbin.org/headers X-Open-Source-Com:Awesome
{
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "HTTPie/1.0.2",
"X-Open-Source-Com": "Awesome"
}
}
```
最后，如果要发送 JSON 字段（尽管可以指定确切的内容），对于许多嵌套较少的输入，你可以使用快捷方式：
```
$ http --body PUT https://httpbin.org/anything open-source=awesome author=moshez
{
"args": {},
"data": "{\"open-source\": \"awesome\", \"author\": \"moshez\"}",
"files": {},
"form": {},
"headers": {
"Accept": "application/json, */*",
"Accept-Encoding": "gzip, deflate",
"Content-Length": "46",
"Content-Type": "application/json",
"Host": "httpbin.org",
"User-Agent": "HTTPie/1.0.2"
},
"json": {
"author": "moshez",
"open-source": "awesome"
},
"method": "PUT",
"origin": "73.162.254.113, 73.162.254.113",
"url": "https://httpbin.org/anything"
}
```
下次在调试 Web API 时，无论是你自己的还是别人的，记得放下 cURL，试试 HTTPie 这个命令行工具。
---
via: <https://opensource.com/article/19/8/getting-started-httpie>
作者：[Moshe Zadka](https://opensource.com/users/moshezhttps://opensource.com/users/mkalindepauleduhttps://opensource.com/users/jamesf) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Ubuntu 19.04 中安装 Shutter 截图工具 | Abhishek Prakash | https://itsfoss.com/install-shutter-ubuntu/ | 虽然 Shutter 一直是一款很棒的工具，但它的开发却停滞了。也许你也是像我这样的 Shutter 粉丝，并且想要使用它。 | /data/attachment/album/201909/12/113136ccx3h3xu8uimnme0.jpg.thumb.jpg | /data/attachment/album/201909/12/113136ccx3h3xu8uimnme0.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Shutter",
"截屏"
] | 分享 | {
"viewnum": 4919,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 虽然 Shutter 一直是一款很棒的工具，但它的开发却停滞了。也许你也是像我这样的 Shutter 粉丝，并且想要使用它。 | 2019-09-12T11:31:33 | 2019-09-12T11:31:33 | 11,335 | /article-11335-1.html | Shutter 是我在 [Linux 中最喜欢的截图工具](https://itsfoss.com/take-screenshot-linux/)。你可以使用它截图，还可以用它编辑截图或其他图像。它是一个在图像上添加箭头和文本的不错的工具。你也可以使用它在 Ubuntu 或其它你使用的发行版中[调整图像大小](https://itsfoss.com/resize-images-with-right-click/)。FOSS 上大多数截图教程都使用 Shutter 编辑。
虽然 [Shutter](http://shutter-project.org/) 一直是一款很棒的工具，但它的开发却停滞了。这几年来一直没有新版本的 Shutter。甚至像 [Shutter 中编辑模式被禁用](https://itsfoss.com/shutter-edit-button-disabled/)这样的简单 bug 也没有修复。根本没有开发者的消息。
也许这就是为什么新版本的 Ubuntu 放弃它的原因。在 Ubuntu 18.04 LTS 之前，你可以在软件中心，或者[启用 universe 仓库](https://itsfoss.com/ubuntu-repositories/)来[使用 apt-get 命令](https://itsfoss.com/apt-get-linux-guide/)安装它。但是从 Ubuntu 18.10 及更高版本开始，你就不能再这样做了。
抛开这些缺点，Shutter 是一个很好的工具，我想继续使用它。也许你也是像我这样的 Shutter 粉丝，并且想要使用它。好的方面是你仍然可以在 Ubuntu 19.04 中安装 Shutter，这要归功于非官方 PPA。
### 在 Ubuntu 19.04 上安装 Shutter
我希望你了解 PPA 的概念。如果不了解，我强烈建议阅读我的指南，以了解更多关于[什么是 PPA 以及如何使用它](https://itsfoss.com/ppa-guide/)。
现在，打开终端并使用以下命令添加新仓库：
```
sudo add-apt-repository -y ppa:linuxuprising/shutter
```
不需要再使用 `apt update`，因为从 Ubuntu 18.04 开始，仓库会在添加新条目后自动更新。
现在使用 `apt` 命令安装 Shutter：
```
sudo apt install shutter
```
完成。你应该已经安装 Shutter 截图工具。你可从菜单搜索并启动它。
### 删除通过非官方 PPA 安装的 Shutter
最后我以卸载 Shutter 以及删除添加的仓库来结束教程。
首先，从系统中删除 Shutter：
```
sudo apt remove shutter
```
接下来，从你的仓库列表中删除 PPA：
```
sudo add-apt-repository --remove ppa:linuxuprising/shutter
```
你或许还想了解 [Y PPA Manager](https://itsfoss.com/y-ppa-manager/)，这是一款 PPA 图形管理工具。
Shutter 是一个很好的工具，我希望它能被积极开发。我希望它的开发人员没问题，他/她可以找一些时间来处理它。或者是时候让其他人分叉并继续让它变得更棒。
---
via: <https://itsfoss.com/install-shutter-ubuntu/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Linux 中管理日志 | Sandra Henry-stocker | https://www.networkworld.com/article/3428361/how-to-manage-logs-in-linux.html | Linux 系统上的日志文件包含了很多信息——比你有时间查看的还要多。以下是一些建议，告诉你如何正确的使用它们……而不是淹没在其中。 | /data/attachment/album/201909/13/161842c83egb236wwfe6g4.jpg.thumb.jpg | /data/attachment/album/201909/13/161842c83egb236wwfe6g4.jpg | true | false | true | lujun9972 | heguangzhi | wxy | false | [
"日志"
] | 系统运维 | {
"viewnum": 9771,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [] | [] | Linux 系统上的日志文件包含了很多信息——比你有时间查看的还要多。以下是一些建议，告诉你如何正确的使用它们……而不是淹没在其中。 | 2019-09-13T16:17:57 | 2019-09-13T16:17:57 | 11,336 | /article-11336-1.html |
>
> Linux 系统上的日志文件包含了**很多**信息——比你有时间查看的还要多。以下是一些建议，告诉你如何正确的使用它们……而不是淹没在其中。
>
>
>
在 Linux 系统上管理日志文件可能非常容易，也可能非常痛苦。这完全取决于你所认为的日志管理是什么。
如果你认为是如何确保日志文件不会耗尽你的 Linux 服务器上的所有磁盘空间，那么这个问题通常很简单。Linux 系统上的日志文件会自动翻转，系统将只维护固定数量的翻转日志。即便如此，一眼看去一组上百个文件可能会让人不知所措。在这篇文章中，我们将看看日志轮换是如何工作的，以及一些最相关的日志文件。
### 自动日志轮换
日志文件是经常轮转的。当前的日志会获得稍微不同的文件名，并建立一个新的日志文件。以系统日志文件为例。对于许多正常的系统 messages 文件来说，这个文件是一个包罗万象的东西。如果你 `cd` 转到 `/var/log` 并查看一下，你可能会看到一系列系统日志文件，如下所示:
```
$ ls -l syslog*
-rw-r----- 1 syslog adm 28996 Jul 30 07:40 syslog
-rw-r----- 1 syslog adm 71212 Jul 30 00:00 syslog.1
-rw-r----- 1 syslog adm 5449 Jul 29 00:00 syslog.2.gz
-rw-r----- 1 syslog adm 6152 Jul 28 00:00 syslog.3.gz
-rw-r----- 1 syslog adm 7031 Jul 27 00:00 syslog.4.gz
-rw-r----- 1 syslog adm 5602 Jul 26 00:00 syslog.5.gz
-rw-r----- 1 syslog adm 5995 Jul 25 00:00 syslog.6.gz
-rw-r----- 1 syslog adm 32924 Jul 24 00:00 syslog.7.gz
```
轮换发生在每天午夜，旧的日志文件会保留一周，然后删除最早的系统日志文件。`syslog.7.gz` 文件将被从系统中删除，`syslog.6.gz` 将被重命名为 `syslog.7.gz`。日志文件的其余部分将依次改名，直到 `syslog` 变成 `syslog.1` 并创建一个新的 `syslog` 文件。有些系统日志文件会比其他文件大，但是一般来说，没有一个文件可能会变得非常大，并且你永远不会看到超过八个的文件。这给了你一个多星期的时间来回顾它们收集的任何数据。
某种特定日志文件维护的文件数量取决于日志文件本身。有些文件可能有 13 个。请注意 `syslog` 和 `dpkg` 的旧文件是如何压缩以节省空间的。这里的考虑是你对最近的日志最感兴趣，而更旧的日志可以根据需要用 `gunzip` 解压。
```
# ls -t dpkg*
dpkg.log dpkg.log.3.gz dpkg.log.6.gz dpkg.log.9.gz dpkg.log.12.gz
dpkg.log.1 dpkg.log.4.gz dpkg.log.7.gz dpkg.log.10.gz
dpkg.log.2.gz dpkg.log.5.gz dpkg.log.8.gz dpkg.log.11.gz
```
日志文件可以根据时间和大小进行轮换。检查日志文件时请记住这一点。
尽管默认值适用于大多数 Linux 系统管理员，但如果你愿意，可以对日志文件轮换进行不同的配置。查看这些文件，如 `/etc/rsyslog.conf` 和 `/etc/logrotate.conf`。
### 使用日志文件
对日志文件的管理也包括时不时的使用它们。使用日志文件的第一步可能包括：习惯每个日志文件可以告诉你有关系统如何工作以及系统可能会遇到哪些问题。从头到尾读取日志文件几乎不是一个好的选择，但是当你想了解你的系统运行的情况或者需要跟踪一个问题时，知道如何从日志文件中获取信息会是有很大的好处。这也表明你对每个文件中存储的信息有一个大致的了解了。例如:
```
$ who wtmp | tail -10 显示最近的登录信息
$ who wtmp | grep shark 显示特定用户的最近登录信息
$ grep "sudo:" auth.log 查看谁在使用 sudo
$ tail dmesg 查看（最近的）内核日志
$ tail dpkg.log 查看最近安装和更新的软件包
$ more ufw.log 查看防火墙活动（假如你使用 ufw）
```
你运行的一些命令也会从日志文件中提取信息。例如，如果你想查看系统重新启动的列表，可以使用如下命令:
```
$ last reboot
reboot system boot 5.0.0-20-generic Tue Jul 16 13:19 still running
reboot system boot 5.0.0-15-generic Sat May 18 17:26 - 15:19 (21+21:52)
reboot system boot 5.0.0-13-generic Mon Apr 29 10:55 - 15:34 (18+04:39)
```
### 使用更高级的日志管理器
虽然你可以编写脚本来更容易地在日志文件中找到感兴趣的信息，但是你也应该知道有一些非常复杂的工具可用于日志文件分析。一些可以把来自多个来源的信息联系起来，以便更全面地了解你的网络上发生了什么。它们也可以提供实时监控。这些工具，如 [Solarwinds Log & Event Manager](https://www.esecurityplanet.com/products/solarwinds-log-event-manager-siem.html) 和 [PRTG 网络监视器](https://www.paessler.com/prtg)（包括日志监视）浮现在脑海中。
还有一些免费工具可以帮助分析日志文件。其中包括:
* Logwatch — 用于扫描系统日志中感兴趣的日志行的程序
* Logcheck — 系统日志分析器和报告器
在接下来的文章中，我将提供一些关于这些工具的见解和帮助。
---
via: <https://www.networkworld.com/article/3428361/how-to-manage-logs-in-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
我为什么使用 Java | Chris Hermansen | https://opensource.com/article/19/9/why-i-use-java | 根据你的工作需要，可能有比 Java 更好的语言，但是我还没有看到任何能把我拉走的语言。 | /data/attachment/album/201909/13/171223bf7noo4bbnkxbkdk.jpg.thumb.jpg | /data/attachment/album/201909/13/171223bf7noo4bbnkxbkdk.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Java"
] | 观点 | {
"viewnum": 3476,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 根据你的工作需要，可能有比 Java 更好的语言，但是我还没有看到任何能把我拉走的语言。 | 2019-09-13T17:12:37 | 2019-09-13T17:12:37 | 11,337 | /article-11337-1.html |
>
> 根据你的工作需要，可能有比 Java 更好的语言，但是我还没有看到任何能把我拉走的语言。
>
>
>
我记得我是从 1997 年开始使用 Java 的，就在 [Java 1.1 刚刚发布](https://en.wikipedia.org/wiki/Java_version_history)不久之后。从那时起，总的来说，我非常喜欢用 Java 编程；虽然我得承认，这些日子我经常像在 Java 中编写“严肃的代码”一样编写 [Groovy](https://en.wikipedia.org/wiki/Apache_Groovy) 脚本。
来自 [FORTRAN](https://en.wikipedia.org/wiki/Fortran)、[PL/1](https://en.wikipedia.org/wiki/PL/I)、[Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) 以及最后的 [C 语言](https://en.wikipedia.org/wiki/C_(programming_language)) 背景，我发现了许多让我喜欢 Java 的东西。Java 是我[面向对象编程](https://en.wikipedia.org/wiki/Object-oriented_programming)的第一次重要实践经验。到那时，我已经编程了大约 20 年，而且可以说我对什么重要、什么不重要有了一些看法。
### 调试是一个关键的语言特性
我真的很讨厌浪费时间追踪由我的代码不小心迭代到数组末尾而导致的模糊错误，特别是在 IBM 大型机上的 FORTRAN 编程时代。另一个不时出现的隐晦问题是调用一个子程序时，该子程序带有一个四字节整数参数，而预期有两个字节；在小端架构上，这通常是一个良性的错误，但在大端机器上，前两个字节的值通常并不总是为零。
在那种批处理环境中进行调试也非常不便，通过核心转储或插入打印语句进行调试，这些语句本身会移动错误的位置甚至使它们消失。
所以我使用 Pascal 的早期体验，先是在 [MTS](https://en.wikipedia.org/wiki/Michigan_Terminal_System) 上，然后是在 [IBM OS/VS1](https://en.wikipedia.org/wiki/OS/VS1) 上使用相同的 MTS 编译器，让我的生活变得更加轻松。Pascal 的[强类型和静态类型](https://stackoverflow.com/questions/11889602/difference-between-strong-vs-static-typing-and-weak-vs-dynamic-typing)是取得这种胜利的重要组成部分，我使用的每个 Pascal 编译器都会在数组的边界和范围上插入运行时检查，因此错误可以在发生时检测到。当我们在 20 世纪 80 年代早期将大部分工作转移到 Unix 系统时，移植 Pascal 代码是一项简单的任务。
### 适量的语法
但是对于我所喜欢的 Pascal 来说，我的代码很冗长，而且语法似乎要比代码还要多；例如，使用：
```
if ... then begin ... end else ... end
```
而不是 C 或类似语言中的：
```
if (...) { ... } else { ... }
```
另外，有些事情在 Pascal 中很难完成，在 C 中更容易。但是，当我开始越来越多地使用 C 时，我发现自己遇到了我曾经在 FORTRAN 中遇到的同样类型的错误，例如，超出数组边界。在原始的错误点未检测到数组结束，而仅在程序执行后期才会检测到它们的不利影响。幸运的是，我不再生活在那种批处理环境中，并且手头有很好的调试工具。不过，C 对于我来说有点太灵活了。
当我遇到 [awk](https://en.wikipedia.org/wiki/AWK) 时，我发现它与 C 相比又是另外一种样子。那时，我的很多工作都涉及转换字段数据并创建报告。我发现用 `awk` 加上其他 Unix 命令行工具，如 `sort`、`sed`、`cut`、`join`、`paste`、`comm` 等等，可以做到事情令人吃惊。从本质上讲，这些工具给了我一个像是基于文本文件的关系数据库管理器，这种文本文件具有列式结构，是我们很多字段数据的保存方式。或者，即便不是这种格式，大部分时候也可以从关系数据库或某种二进制格式导出到列式结构中。
`awk` 支持的字符串处理、[正则表达式](https://en.wikipedia.org/wiki/Regular_expression)和[关联数组](https://en.wikipedia.org/wiki/Associative_array)，以及 `awk` 的基本特性（它实际上是一个数据转换管道），非常符合我的需求。当面对二进制数据文件、复杂的数据结构和关键性能需求时，我仍然会转回到 C；但随着我越来越多地使用 `awk`，我发现 C 的非常基础的字符串支持越来越令人沮丧。随着时间的推移，更多的时候我只会在必须时才使用 C，并且在其余的时候里大量使用 `awk`。
### Java 的抽象层级合适
然后是 Java。它看起来相当不错 —— 相对简洁的语法，让人联想到 C，或者这种相似性至少要比 Pascal 或其他任何早期的语言更为明显。它是强类型的，因此很多编程错误会在编译时被捕获。它似乎并不需要过多的面向对象的知识就能起步，这是一件好事，因为我当时对 [OOP 设计模式](https://opensource.com/article/19/7/understanding-software-design-patterns)毫不熟悉。但即使在刚刚开始，我也喜欢它的简化[继承模型](https://www.w3schools.com/java/java_inheritance.asp)背后的思想。（Java 允许使用提供的接口进行单继承，以在某种程度上丰富范例。）
它似乎带有丰富的功能库（即“自备电池”的概念），在适当的水平上直接满足了我的需求。最后，我发现自己很快就会想到将数据和行为在对象中组合在一起的想法。这似乎是明确控制数据之间交互的好方法 —— 比大量的参数列表或对全局变量的不受控制的访问要好得多。
从那以后，Java 在我的编程工具箱中成为了 Helvetic 军刀。我仍然偶尔会在 `awk` 中编写程序，或者使用 Linux 命令行实用程序（如 `cut`、`sort` 或 `sed`），因为它们显然是解决手头问题的直接方法。我怀疑过去 20 年我可能没写过 50 行的 C 语言代码；Java 完全满足了我的需求。
此外，Java 一直在不断改进。首先，它变得更加高效。并且它添加了一些非常有用的功能，例如[可以用 try 来测试资源](https://www.baeldung.com/java-try-with-resources)，它可以很好地清理在文件 I/O 期间冗长而有点混乱的错误处理代码；或 [lambda](https://www.baeldung.com/java-8-lambda-expressions-tips)，它提供了声明函数并将其作为参数传递的能力，而旧方法需要创建类或接口来“托管”这些函数；或[流](https://www.tutorialspoint.com/java8/java8_streams)，它在函数中封装了迭代行为，可以创建以链式函数调用形式实现的高效数据转换管道。
### Java 越来越好
许多语言设计者研究了从根本上改善 Java 体验的方法。对我来说，其中大部分没有引起我的太多兴趣；再次，这更多地反映了我的典型工作流程，并且（更多地）减少了这些语言带来的功能。但其中一个演化步骤已经成为我的编程工具中不可或缺的一部分：[Groovy](https://groovy-lang.org/)。当我遇到一个小问题，需要一个简单的解决方案时，Groovy 已经成为了我的首选。而且，它与 Java 高度兼容。对我来说，Groovy 填补了 Python 为许多其他人所提供的相同用处 —— 它紧凑、DRY（不要重复自己）和具有表达性（列表和词典有完整的语言支持）。我还使用了 [Grails](https://grails.org/)，它使用 Groovy 为非常高性能和有用的 Java Web 应用程序提供简化的 Web 框架。
### Java 仍然开源吗？
最近，对 [OpenJDK](https://openjdk.java.net/) 越来越多的支持进一步提高了我对 Java 的舒适度。许多公司以各种方式支持 OpenJDK，包括 [AdoptOpenJDK、Amazon 和 Red Hat](https://en.wikipedia.org/wiki/OpenJDK)。在我的一个更大、更长期的项目中，我们使用 AdoptOpenJDK [来在几个桌面平台上生成自定义的运行时环境](https://opensource.com/article/19/4/java-se-11-removing-jnlp)。
有没有比 Java 更好的语言？我确信有，这取决于你的工作需要。但我一直对 Java 非常满意，我还没有遇到任何可能会让我失望的东西。
---
via: <https://opensource.com/article/19/9/why-i-use-java>
作者：[Chris Hermansen](https://opensource.com/users/clhermansen) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
为什么 const 无法让 C 代码跑得更快？ | Simon Arneaud | https://theartofmachinery.com/2019/08/12/c_const_isnt_for_performance.html | 我曾说过“有个一个流行的传言，const 有助于编译器优化 C 和 C++ 代码”。我觉得我需要解释一下，尤其是曾经我自己也以为这是显然对的。 | /data/attachment/album/201909/14/181535lsrt9t93k1c1n0mt.jpg.thumb.jpg | /data/attachment/album/201909/14/181535lsrt9t93k1c1n0mt.jpg | true | false | true | lujun9972 | LazyWolfLin | wxy | false | [
"常量"
] | 软件开发 | {
"viewnum": 8562,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "119.8.243.20",
"message": "“我不明白为什么会有不了解 const 的人让这些变量加上 static。”这句话翻译不对。原文是：“I don’t see why anyone who didn’t care about const would make those variables static.”。<br />\r\n意思应该是如果去掉了const，我看不出这些变量还有是static的必要。<br />\r\n事实上static const和const局部变量在gcc中的处理是完全不同的。gcc会在栈里面为const局部变量分配空间（就和普通局部变量一样），并在使用前初始化，但是static const是一个放在rodata只读数据段中的变量，不占用栈空间也不需要初始化。",
"username": "来自119.8.243.20的 Chrome 97.0|Windows 10 用户",
"date": "2022-01-25T09:47:40"
}
] | [] | 我曾说过“有个一个流行的传言，const 有助于编译器优化 C 和 C++ 代码”。我觉得我需要解释一下，尤其是曾经我自己也以为这是显然对的。 | 2019-09-14T18:16:34 | 2019-09-14T18:16:34 | 11,339 | /article-11339-1.html | 
在几个月前的一篇文章里，我曾说过“[有个一个流行的传言，`const` 有助于编译器优化 C 和 C++ 代码](https://theartofmachinery.com/2019/04/05/d_as_c_replacement.html#const-and-immutable)”。我觉得我需要解释一下，尤其是曾经我自己也以为这是显然对的。我将会用一些理论并构造一些例子来论证，然后在一个真实的代码库 `Sqlite` 上做一些实验和基准测试。
### 一个简单的测试
让我们从一个最简单、最明显的例子开始，以前认为这是一个 `const` 让 C 代码跑得更快的例子。首先，假设我们有如下两个函数声明：
```
void func(int *x);
void constFunc(const int *x);
```
然后假设我们如下两份代码：
```
void byArg(int *x)
{
printf("%d\n", *x);
func(x);
printf("%d\n", *x);
}
void constByArg(const int *x)
{
printf("%d\n", *x);
constFunc(x);
printf("%d\n", *x);
}
```
调用 `printf()` 时，CPU 会通过指针从 RAM 中取得 `*x` 的值。很显然，`constByArg()` 会稍微快一点，因为编译器知道 `*x` 是常量，因此不需要在调用 `constFunc()` 之后再次获取它的值。它仅是打印相同的东西。没问题吧？让我们来看下 GCC 在如下编译选项下生成的汇编代码：
```
$ gcc -S -Wall -O3 test.c
$ view test.s
```
以下是函数 `byArg()` 的完整汇编代码：
```
byArg:
.LFB23:
.cfi_startproc
pushq %rbx
.cfi_def_cfa_offset 16
.cfi_offset 3, -16
movl (%rdi), %edx
movq %rdi, %rbx
leaq .LC0(%rip), %rsi
movl $1, %edi
xorl %eax, %eax
call __printf_chk@PLT
movq %rbx, %rdi
call func@PLT # constFoo 中唯一不同的指令
movl (%rbx), %edx
leaq .LC0(%rip), %rsi
xorl %eax, %eax
movl $1, %edi
popq %rbx
.cfi_def_cfa_offset 8
jmp __printf_chk@PLT
.cfi_endproc
```
函数 `byArg()` 和函数 `constByArg()` 生成的汇编代码中唯一的不同之处是 `constByArg()` 有一句汇编代码 `call constFunc@PLT`，这正是源代码中的调用。关键字 `const` 本身并没有造成任何字面上的不同。
好了，这是 GCC 的结果。或许我们需要一个更聪明的编译器。Clang 会有更好的表现吗？
```
$ clang -S -Wall -O3 -emit-llvm test.c
$ view test.ll
```
这是 `IR` 代码（LCTT 译注：LLVM 的中间语言）。它比汇编代码更加紧凑，所以我可以把两个函数都导出来，让你可以看清楚我所说的“除了调用外，没有任何字面上的不同”是什么意思：
```
; Function Attrs: nounwind uwtable
define dso_local void @byArg(i32*) local_unnamed_addr #0 {
%2 = load i32, i32* %0, align 4, !tbaa !2
%3 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %2)
tail call void @func(i32* %0) #4
%4 = load i32, i32* %0, align 4, !tbaa !2
%5 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %4)
ret void
}
; Function Attrs: nounwind uwtable
define dso_local void @constByArg(i32*) local_unnamed_addr #0 {
%2 = load i32, i32* %0, align 4, !tbaa !2
%3 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %2)
tail call void @constFunc(i32* %0) #4
%4 = load i32, i32* %0, align 4, !tbaa !2
%5 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %4)
ret void
}
```
### 某些有作用的东西
接下来是一组 `const` 能够真正产生作用的代码：
```
void localVar()
{
int x = 42;
printf("%d\n", x);
constFunc(&x);
printf("%d\n", x);
}
void constLocalVar()
{
const int x = 42; // 对本地变量使用 const
printf("%d\n", x);
constFunc(&x);
printf("%d\n", x);
}
```
下面是 `localVar()` 的汇编代码，其中有两条指令在 `constLocalVar()` 中会被优化掉：
```
localVar:
.LFB25:
.cfi_startproc
subq $24, %rsp
.cfi_def_cfa_offset 32
movl $42, %edx
movl $1, %edi
movq %fs:40, %rax
movq %rax, 8(%rsp)
xorl %eax, %eax
leaq .LC0(%rip), %rsi
movl $42, 4(%rsp)
call __printf_chk@PLT
leaq 4(%rsp), %rdi
call constFunc@PLT
movl 4(%rsp), %edx # 在 constLocalVar() 中没有
xorl %eax, %eax
movl $1, %edi
leaq .LC0(%rip), %rsi # 在 constLocalVar() 中没有
call __printf_chk@PLT
movq 8(%rsp), %rax
xorq %fs:40, %rax
jne .L9
addq $24, %rsp
.cfi_remember_state
.cfi_def_cfa_offset 8
ret
.L9:
.cfi_restore_state
call __stack_chk_fail@PLT
.cfi_endproc
```
在 LLVM 生成的 `IR` 代码中更明显一点。在 `constLocalVar()` 中，第二次调用 `printf()` 之前的 `load` 会被优化掉：
```
; Function Attrs: nounwind uwtable
define dso_local void @localVar() local_unnamed_addr #0 {
%1 = alloca i32, align 4
%2 = bitcast i32* %1 to i8*
call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %2) #4
store i32 42, i32* %1, align 4, !tbaa !2
%3 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 42)
call void @constFunc(i32* nonnull %1) #4
%4 = load i32, i32* %1, align 4, !tbaa !2
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %4)
call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %2) #4
ret void
}
```
好吧，现在，`constLocalVar()` 成功的省略了对 `*x` 的重新读取，但是可能你已经注意到一些问题：`localVar()` 和 `constLocalVar()` 在函数体中做了同样的 `constFunc()` 调用。如果编译器能够推断出 `constFunc()` 没有修改 `constLocalVar()` 中的 `*x`，那为什么不能推断出完全一样的函数调用也没有修改 `localVar()` 中的 `*x`？
这个解释更贴近于为什么 C 语言的 `const` 不能作为优化手段的核心原因。C 语言的 `const` 有两个有效的含义：它可以表示这个变量是某个可能是常数也可能不是常数的数据的一个只读别名，或者它可以表示该变量是真正的常量。如果你移除了一个指向常量的指针的 `const` 属性并写入数据，那结果将是一个未定义行为。另一方面，如果是一个指向非常量值的 `const` 指针，将就没问题。
这份 `constFunc()` 的可能实现揭示了这意味着什么：
```
// x 是一个指向某个可能是常数也可能不是常数的数据的只读指针
void constFunc(const int *x)
{
// local_var 是一个真正的常数
const int local_var = 42;
// C 语言规定的未定义行为
doubleIt((int*)&local_var);
// 谁知道这是不是一个未定义行为呢？
doubleIt((int*)x);
}
void doubleIt(int *x)
{
*x *= 2;
}
```
`localVar()` 传递给 `constFunc()` 一个指向非 `const` 变量的 `const` 指针。因为这个变量并非常量，`constFunc()` 可以撒个谎并强行修改它而不触发未定义行为。所以，编译器不能断定变量在调用 `constFunc()` 后仍是同样的值。在 `constLocalVar()` 中的变量是真正的常量，因此，编译器可以断定它不会改变 —— 因为在 `constFunc()` 去除变量的 `const` 属性并写入它*将*会是一个未定义行为。
第一个例子中的函数 `byArg()` 和 `constByArg()` 是没有可能优化的，因为编译器没有任何方法能知道 `*x` 是否真的是 `const` 常量。
>
> 补充（和题外话）：相当多的读者已经正确地指出，使用 `const int *x`，该指针本身不是限定的常量，只是该数据被加个了别名，而 `const int * const extra_const` 是一个“双向”限定为常量的指针。但是因为指针本身的常量与别名数据的常量无关，所以结果是相同的。仅在 `extra_const` 指向使用 `const` 定义的对象时，`*(int*const)extra_const = 0` 才是未定义行为。（实际上，`*(int*)extra_const = 0` 也不会更糟。）因为它们之间的区别可以一句话说明白，一个是完全的 `const` 指针，另外一个可能是也可能不是常量本身的指针，而是一个可能是也可能不是常量的对象的只读别名，我将继续不严谨地引用“常量指针”。（题外话结束）
>
>
>
但是为什么不一致呢？如果编译器能够推断出 `constLocalVar()` 中调用的 `constFunc()` 不会修改它的参数，那么肯定也能继续在其他 `constFunc()` 的调用上实施相同的优化，是吗？并不。编译器不能假设 `constLocalVar()` 根本没有运行。如果不是这样（例如，它只是代码生成器或者宏的一些未使用的额外输出），`constFunc()` 就能偷偷地修改数据而不触发未定义行为。
你可能需要重复阅读几次上述说明和示例，但不要担心，它听起来很荒谬，它确实是正确的。不幸的是，对 `const` 变量进行写入是最糟糕的未定义行为：大多数情况下，编译器无法知道它是否将会是未定义行为。所以，大多数情况下，编译器看见 `const` 时必须假设它未来可能会被移除掉，这意味着编译器不能使用它进行优化。这在实践中是正确的，因为真实的 C 代码会在“深思熟虑”后移除 `const`。
简而言之，很多事情都可以阻止编译器使用 `const` 进行优化，包括使用指针从另一内存空间接受数据，或者在堆空间上分配数据。更糟糕的是，在大部分编译器能够使用 `const` 进行优化的情况，它都不是必须的。例如，任何像样的编译器都能推断出下面代码中的 `x` 是一个常量，甚至都不需要 `const`：
```
int x = 42, y = 0;
printf("%d %d\n", x, y);
y += x;
printf("%d %d\n", x, y);
```
总结，`const` 对优化而言几乎无用，因为：
1. 除了特殊情况，编译器需要忽略它，因为其他代码可能合法地移除它
2. 在 #1 以外的大多数例外中，编译器无论如何都能推断出该变量是常量
### C++
如果你在使用 C++ 那么有另外一个方法让 `const` 能够影响到代码的生成：函数重载。你可以用 `const` 和非 `const` 的参数重载同一个函数，而非 `const` 版本的代码可能可以被优化（由程序员优化而不是编译器），减少某些拷贝或者其他事情。
```
void foo(int *p)
{
// 需要做更多的数据拷贝
}
void foo(const int *p)
{
// 不需要保护性的拷贝副本
}
int main()
{
const int x = 42;
// const 影响被调用的是哪一个版本的重载函数
foo(&x);
return 0;
}
```
一方面，我不认为这会在实际的 C++ 代码中大量使用。另一方面，为了导致差异，程序员需要假设编译器无法做出，因为它们不受语言保护。
### 用 Sqlite3 进行实验
有了足够的理论和例子。那么 `const` 在一个真正的代码库中有多大的影响呢？我将会在代码库 `Sqlite`（版本：3.30.0）上做一个测试，因为：
* 它真正地使用了 `const`
* 它不是一个简单的代码库（超过 20 万行代码）
* 作为一个数据库，它包括了字符串处理、数学计算、日期处理等一系列内容
* 它能够在绑定 CPU 的情况下进行负载测试
此外，作者和贡献者们已经进行了多年的性能优化工作，因此我能确定他们没有错过任何有显著效果的优化。
#### 配置
我做了两份[源码](https://sqlite.org/src/doc/trunk/README.md)拷贝，并且正常编译其中一份。而对于另一份拷贝，我插入了这个特殊的预处理代码段，将 `const` 变成一个空操作：
```
#define const
```
(GNU) `sed` 可以将一些东西添加到每个文件的顶端，比如 `sed -i '1i#define const' *.c *.h`。
在编译期间使用脚本生成 `Sqlite` 代码稍微有点复杂。幸运的是当 `const` 代码和非 `const` 代码混合时，编译器会产生了大量的提醒，因此很容易发现它并调整脚本来包含我的反 `const` 代码段。
直接比较编译结果毫无意义，因为任意微小的改变就会影响整个内存布局，这可能会改变整个代码中的指针和函数调用。因此，我用每个指令的二进制大小和汇编代码作为识别码（`objdump -d libsqlite3.so.0.8.6`）。举个例子，这个函数：
```
000000000005d570 <sqlite3_blob_read>:
5d570: 4c 8d 05 59 a2 ff ff lea -0x5da7(%rip),%r8 # 577d0 <sqlite3BtreePayloadChecked>
5d577: e9 04 fe ff ff jmpq 5d380 <blobReadWrite>
5d57c: 0f 1f 40 00 nopl 0x0(%rax)
```
将会变成这样：
```
sqlite3_blob_read 7lea 5jmpq 4nopl
```
在编译时，我保留了所有 `Sqlite` 的编译设置。
#### 分析编译结果
`const` 版本的 `libsqlite3.so` 的大小是 4,740,704 字节，大约比 4,736,712 字节的非 `const` 版本大了 0.1% 。在全部 1374 个导出函数（不包括类似 PLT 里的底层辅助函数）中，一共有 13 个函数的识别码不一致。
其中的一些改变是由于插入的预处理代码。举个例子，这里有一个发生了更改的函数（已经删去一些 `Sqlite` 特有的定义）：
```
#define LARGEST_INT64 (0xffffffff|(((int64_t)0x7fffffff)<<32))
#define SMALLEST_INT64 (((int64_t)-1) - LARGEST_INT64)
static int64_t doubleToInt64(double r){
/*
** Many compilers we encounter do not define constants for the
** minimum and maximum 64-bit integers, or they define them
** inconsistently. And many do not understand the "LL" notation.
** So we define our own static constants here using nothing
** larger than a 32-bit integer constant.
*/
static const int64_t maxInt = LARGEST_INT64;
static const int64_t minInt = SMALLEST_INT64;
if( r<=(double)minInt ){
return minInt;
}else if( r>=(double)maxInt ){
return maxInt;
}else{
return (int64_t)r;
}
}
```
删去 `const` 使得这些常量变成了 `static` 变量。我不明白为什么会有不了解 `const` 的人让这些变量加上 `static`。同时删去 `static` 和 `const` 会让 GCC 再次认为它们是常量，而我们将得到同样的编译输出。由于类似这样的局部的 `static const` 变量，使得 13 个函数中有 3 个函数产生假的变化，但我一个都不打算修复它们。
`Sqlite` 使用了很多全局变量，而这正是大多数真正的 `const` 优化产生的地方。通常情况下，它们类似于将一个变量比较代替成一个常量比较，或者一个循环在部分展开的一步。（[Radare toolkit](https://rada.re/r/) 可以很方便的找出这些优化措施。）一些变化则令人失望。`sqlite3ParseUri()` 有 487 个指令，但 `const` 产生的唯一区别是进行了这个比较：
```
test %al, %al
je <sqlite3ParseUri+0x717>
cmp $0x23, %al
je <sqlite3ParseUri+0x717>
```
并交换了它们的顺序：
```
cmp $0x23, %al
je <sqlite3ParseUri+0x717>
test %al, %al
je <sqlite3ParseUri+0x717>
```
#### 基准测试
`Sqlite` 自带了一个性能回归测试，因此我尝试每个版本的代码执行一百次，仍然使用默认的 `Sqlite` 编译设置。以秒为单位的测试结果如下：
| | const | 非 const |
| --- | --- | --- |
| 最小值 | 10.658s | 10.803s |
| 中间值 | 11.571s | 11.519s |
| 最大值 | 11.832s | 11.658s |
| 平均值 | 11.531s | 11.492s |
就我个人看来，我没有发现足够的证据来说明这个差异值得关注。我是说，我从整个程序中删去 `const`，所以如果它有明显的差别，那么我希望它是显而易见的。但也许你关心任何微小的差异，因为你正在做一些绝对性能非常重要的事。那让我们试一下统计分析。
我喜欢使用类似 Mann-Whitney U 检验这样的东西。它类似于更著名的 T 检验，但对你在机器上计时时产生的复杂随机变量（由于不可预测的上下文切换、页错误等）更加健壮。以下是结果：
| | const | 非 const |
| --- | --- | --- |
| N | 100 | 100 |
| Mean rank | 121.38 | 79.62 |
| | |
| --- | --- |
| Mann-Whitney U | 2912 |
| Z | -5.10 |
| 2-sided p value | <10-6 |
| HL median difference | -0.056s |
| 95% confidence interval | -0.077s – -0.038s |
U 检验已经发现统计意义上具有显著的性能差异。但是，令人惊讶的是，实际上是非 `const` 版本更快——大约 60ms，0.5%。似乎 `const` 启用的少量“优化”不值得额外代码的开销。这不像是 `const` 启用了任何类似于自动矢量化的重要的优化。当然，你的结果可能因为编译器配置、编译器版本或者代码库等等而有所不同，但是我觉得这已经说明了 `const` 是否能够有效地提高 `C` 的性能，我们现在已经看到答案了。
### 那么，const 有什么用呢？
尽管存在缺陷，C/C++ 的 `const` 仍有助于类型安全。特别是，结合 C++ 的移动语义和 `std::unique_pointer`，`const` 可以使指针所有权显式化。在超过十万行代码的 C++ 旧代码库里，指针所有权模糊是一个大难题，我对此深有感触。
但是，我以前常常使用 `const` 来实现有意义的类型安全。我曾听说过基于性能上的原因，最好是尽可能多地使用 `const`。我曾听说过当性能很重要时，重构代码并添加更多的 `const` 非常重要，即使以降低代码可读性的方式。**当时觉得这没问题，但后来我才知道这并不对。**
---
via: <https://theartofmachinery.com/2019/08/12/c_const_isnt_for_performance.html>
作者：[Simon Arneaud](https://theartofmachinery.com) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LazyWolfLin](https://github.com/LazyWolfLin) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Linux 上创建和使用交换文件 | Abhishek Prakash | https://itsfoss.com/create-swap-file-linux/ | 本教程讨论了 Linux 中交换文件的概念，为什么使用它以及它相对于传统交换分区的优势。你将学习如何创建交换文件和调整其大小。 | /data/attachment/album/201909/14/190637uggjgsjoogxg3vh0.jpg.thumb.jpg | /data/attachment/album/201909/14/190637uggjgsjoogxg3vh0.jpg | true | false | true | lujun9972 | heguangzhi | wxy | false | [] | 技术 | {
"viewnum": 4328,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 本教程讨论了 Linux 中交换文件的概念，为什么使用它以及它相对于传统交换分区的优势。你将学习如何创建交换文件和调整其大小。 | 2019-09-14T19:07:00 | 2019-09-14T19:07:00 | 11,341 | /article-11341-1.html | 
本教程讨论了 Linux 中交换文件的概念，为什么使用它以及它相对于传统交换分区的优势。你将学习如何创建交换文件和调整其大小。
### 什么是 Linux 的交换文件？
交换文件允许 Linux 将磁盘空间模拟为内存。当你的系统开始耗尽内存时，它会使用交换空间将内存的一些内容交换到磁盘空间上。这样释放了内存，为更重要的进程服务。当内存再次空闲时，它会从磁盘交换回数据。我建议[阅读这篇文章，了解 Linux 上的交换空间的更多内容](https://itsfoss.com/swap-size/)。
传统上，交换空间是磁盘上的一个独立分区。安装 Linux 时，只需创建一个单独的分区进行交换。但是这种趋势在最近几年发生了变化。
使用交换文件，你不再需要单独的分区。你会根目录下创建一个文件，并告诉你的系统将其用作交换空间就行了。
使用专用的交换分区，在许多情况下，调整交换空间的大小是一个可怕而不可能的任务。但是有了交换文件，你可以随意调整它们的大小。
最新版本的 Ubuntu 和其他一些 Linux 发行版已经开始 [默认使用交换文件](https://help.ubuntu.com/community/SwapFaq)。甚至如果你没有创建交换分区，Ubuntu 也会自己创建一个 1GB 左右的交换文件。
让我们看看交换文件的更多信息。
### 检查 Linux 的交换空间
在你开始添加交换空间之前，最好检查一下你的系统中是否已经有了交换空间。
你可以用[Linux 上的 free 命令](https://linuxhandbook.com/free-command/)检查它。就我而言，我的[戴尔 XPS](https://itsfoss.com/dell-xps-13-ubuntu-review/)有 14GB 的交换容量。
```
free -h
total used free shared buff/cache available
Mem: 7.5G 4.1G 267M 971M 3.1G 2.2G
Swap: 14G 0B 14G
```
`free` 命令给出了交换空间的大小，但它并没有告诉你它是真实的交换分区还是交换文件。`swapon` 命令在这方面会更好。
```
swapon --show
NAME TYPE SIZE USED PRIO
/dev/nvme0n1p4 partition 14.9G 0B -2
```
如你所见，我有 14.9GB 的交换空间，它在一个单独的分区上。如果是交换文件，类型应该是 `file` 而不是 `partition`。
```
swapon --show
NAME TYPE SIZE USED PRIO
/swapfile file 2G 0B -2
```
如果你的系统上没有交换空间，它应该显示如下内容：
```
free -h
total used free shared buff/cache available
Mem: 7.5G 4.1G 267M 971M 3.1G 2.2G
Swap: 0B 0B 0B
```
而 `swapon` 命令不会显示任何输出。
### 在 Linux 上创建交换文件
如果你的系统没有交换空间，或者你认为交换空间不足，你可以在 Linux 上创建交换文件。你也可以创建多个交换文件。
让我们看看如何在 Linux 上创建交换文件。我在本教程中使用 Ubuntu 18.04，但它也应该适用于其他 Linux 发行版本。
#### 步骤 1：创建一个新的交换文件
首先，创建一个具有所需交换空间大小的文件。假设我想给我的系统增加 1GB 的交换空间。使用`fallocate` 命令创建大小为 1GB 的文件。
```
sudo fallocate -l 1G /swapfile
```
建议只允许 `root` 用户读写该交换文件。当你尝试将此文件用于交换区域时，你甚至会看到类似“不安全权限 0644，建议 0600”的警告。
```
sudo chmod 600 /swapfile
```
请注意，交换文件的名称可以是任意的。如果你需要多个交换空间，你可以给它任何合适的名称，如 `swap_file_1`、`swap_file_2` 等。它们只是一个预定义大小的文件。
#### 步骤 2：将新文件标记为交换空间
你需要告诉 Linux 系统该文件将被用作交换空间。你可以用 [mkswap](http://man7.org/linux/man-pages/man8/mkswap.8.html) 工具做到这一点。
```
sudo mkswap /swapfile
```
你应该会看到这样的输出：
```
Setting up swapspace version 1, size = 1024 MiB (1073737728 bytes)
no label, UUID=7e1faacb-ea93-4c49-a53d-fb40f3ce016a
```
#### 步骤 3：启用交换文件
现在，你的系统知道文件 `swapfile` 可以用作交换空间。但是还没有完成。你需要启用该交换文件，以便系统可以开始使用该文件作为交换。
```
sudo swapon /swapfile
```
现在，如果你检查交换空间，你应该会看到你的 Linux 系统会识别并使用它作为交换空间：
```
swapon --show
NAME TYPE SIZE USED PRIO
/swapfile file 1024M 0B -2
```
#### 步骤 4：让改变持久化
迄今为止你所做的一切都是暂时的。重新启动系统，所有更改都将消失。
你可以通过将新创建的交换文件添加到 `/etc/fstab` 文件来使更改持久化。
对 `/etc/fstab` 文件进行任何更改之前，最好先进行备份。
```
sudo cp /etc/fstab /etc/fstab.back
```
现在将以下行添加到 `/etc/fstab` 文件的末尾：
```
/swapfile none swap sw 0 0
```
你可以使用[命令行文本编辑器](https://itsfoss.com/command-line-text-editors-linux/)手动操作，或者使用以下命令：
```
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
```
现在一切都准备好了。即使在重新启动你的 Linux 系统后，你的交换文件也会被使用。
### 调整 swappiness 参数
`swappiness` 参数决定了交换空间的使用频率。`swappiness` 值的范围从 0 到 100。较高的值意味着交换空间将被更频繁地使用。
Ubuntu 桌面的默认的 `swappiness` 是 60，而服务器的默认 `swappiness` 是 1。你可以使用以下命令检查 `swappiness`：
```
cat /proc/sys/vm/swappiness
```
为什么服务器应该使用低的 `swappiness` 值？因为交换空间比内存慢，为了获得更好的性能，应该尽可能多地使用内存。在服务器上，性能因素至关重要，因此 `swappiness` 应该尽可能低。
你可以使用以下系统命令动态更改 `swappiness`：
```
sudo sysctl vm.swappiness=25
```
这种改变只是暂时的。如果要使其永久化，可以编辑 `/etc/sysctl.conf` 文件，并在文件末尾添加`swappiness` 值:
```
vm.swappiness=25
```
### 在 Linux 上调整交换空间的大小
在 Linux 上有几种方法可以调整交换空间的大小。但是在你看到这一点之前，你应该了解一些关于它的事情。
当你要求系统停止将交换文件用于交换空间时，它会将所有数据（确切地说是内存页）传输回内存。所以你应该有足够的空闲内存，然后再停止交换。
这就是为什么创建和启用另一个临时交换文件是一个好的做法的原因。这样，当你关闭原来的交换空间时，你的系统将使用临时交换文件。现在你可以调整原来的交换空间的大小。你可以手动删除临时交换文件或留在那里，下次启动时会自动删除（LCTT 译注：存疑？）。
如果你有足够的可用内存或者创建了临时交换空间，那就关闭你原来的交换文件。
```
sudo swapoff /swapfile
```
现在你可以使用 `fallocate` 命令来更改文件的大小。比方说，你将其大小更改为 2GB:
```
sudo fallocate -l 2G /swapfile
```
现在再次将文件标记为交换空间：
```
sudo mkswap /swapfile
```
并再次启用交换文件：
```
sudo swapon /swapfile
```
你也可以选择同时拥有多个交换文件。
### 删除 Linux 中的交换文件
你可能有不在 Linux 上使用交换文件的原因。如果你想删除它，该过程类似于你刚才看到的调整交换大小的过程。
首先，确保你有足够的空闲内存。现在关闭交换文件：
```
sudo swapoff /swapfile
```
下一步是从 `/etc/fstab` 文件中删除相应的条目。
最后，你可以删除该文件来释放空间：
```
sudo rm /swapfile
```
### 你用了交换空间了吗？
我想你现在已经很好地理解了 Linux 中的交换文件概念。现在，你可以根据需要轻松创建交换文件或调整它们的大小。
如果你对这个话题有什么要补充的或者有任何疑问，请在下面留下评论。
---
via: <https://itsfoss.com/create-swap-file-linux/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 Git 作为聊天应用的后端 | Seth Kenlon | https://opensource.com/article/19/4/git-based-chat | GIC 是一个聊天应用程序的原型，展示了一种使用 Git 的新方法。 | /data/attachment/album/201909/15/100905euzi3l5xgslsgx7i.png.thumb.jpg | /data/attachment/album/201909/15/100905euzi3l5xgslsgx7i.png | true | false | true | lujun9972 | wxy | wxy | false | [
"Git",
"聊天"
] | 技术 | {
"viewnum": 5682,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11320,
"displayorder": 0
},
{
"raid": 11499,
"displayorder": 0
}
] | GIC 是一个聊天应用程序的原型，展示了一种使用 Git 的新方法。 | 2019-09-15T10:09:00 | 2019-09-15T10:09:00 | 11,342 | /article-11342-1.html |
>
> GIC 是一个聊天应用程序的原型，展示了一种使用 Git 的新方法。
>
>
>
[Git](https://git-scm.com/) 是一个少有的能将如此多的现代计算封装到一个程序之中的应用程序，它可以用作许多其他应用程序的计算引擎。虽然它以跟踪软件开发中的源代码更改而闻名，但它还有许多其他用途，可以让你的生活更轻松、更有条理。在这个 Git 系列中，我们将分享七种鲜为人知的使用 Git 的方法。
今天我们来看看 GIC，它是一个基于 Git 的聊天应用。
### 初识 GIC
虽然 Git 的作者们可能期望会为 Git 创建前端，但毫无疑问他们从未预料到 Git 会成为某种后端，如聊天客户端的后端。然而，这正是开发人员 Ephi Gabay 用他的实验性的概念验证应用 [GIC](https://github.com/ephigabay/GIC) 所做的事情：用 [Node.js](https://nodejs.org/en/) 编写的聊天客户端，使用 Git 作为其后端数据库。
GIC 并没有打算用于生产用途。这纯粹是一种编程练习，但它证明了开源技术的灵活性。令人惊讶的是，除了 Node 库和 Git 本身，该客户端只包含 300 行代码。这是这个聊天客户端和开源所反映出来的最好的地方之一：建立在现有工作基础上的能力。眼见为实，你应该自己亲自来了解一下 GIC。
### 架设起来
GIC 使用 Git 作为引擎，因此你需要一个空的 Git 存储库为聊天室和记录器提供服务。存储库可以托管在任何地方，只要你和需要访问聊天服务的人可以访问该存储库就行。例如，你可以在 GitLab 等免费 Git 托管服务上设置 Git 存储库，并授予聊天用户对该 Git 存储库的贡献者访问权限。（他们必须能够提交到存储库，因为每个聊天消息都是一个文本的提交。）
如果你自己托管，请创建一个中心化的裸存储库。聊天中的每个用户必须在裸存储库所在的服务器上拥有一个帐户。你可以使用如 [Gitolite](http://gitolite.com) 或 [Gitea](http://gitea.io) 这样的 Git 托管软件创建特定于 Git 的帐户，或者你可以在服务器上为他们提供个人用户帐户，可以使用 `git-shell` 来限制他们只能访问 Git。
自托管实例的性能最好。无论你是自己托管还是使用托管服务，你创建的 Git 存储库都必须具有一个活跃分支，否则 GIC 将无法在用户聊天时进行提交，因为没有 Git HEAD。确保分支初始化和活跃的最简单方法是在创建存储库时提交 `README` 或许可证文件。如果你没有这样做，你可以在事后创建并提交一个：
```
$ echo "chat logs" > README
$ git add README
$ git commit -m 'just creating a HEAD ref'
$ git push -u origin HEAD
```
### 安装 GIC
由于 GIC 基于 Git 并使用 Node.js 编写，因此必须首先安装 Git、Node.js 和 Node 包管理器npm（它应该与 Node 捆绑在一起）。安装它们的命令因 Linux 或 BSD 发行版而异，这是 Fedora 上的一个示例命令：
```
$ sudo dnf install git nodejs
```
如果你没有运行 Linux 或 BSD，请按照 [git-scm.com](http://git-scm.com) 和 [nodejs.org](http://nodejs.org) 上的安装说明进行操作。
因此，GIC 没有安装过程。每个用户（在此示例中为 Alice 和 Bob）必须将存储库克隆到其硬盘驱动器：
```
$ git clone https://github.com/ephigabay/GIC GIC
```
将目录更改为 GIC 目录并使用 `npm` 安装 Node.js 依赖项：
```
$ cd GIC
$ npm install
```
等待 Node 模块下载并安装。
### 配置 GIC
GIC 唯一需要的配置是 Git 聊天存储库的位置。编辑 `config.js` 文件：
```
module.exports = {
gitRepo: '[email protected]:/home/gitchat/chatdemo.git',
messageCheckInterval: 500,
branchesCheckInterval: 5000
};
```
在尝试 GIC 之前测试你与 Git 存储库的连接，以确保你的配置是正确的：
```
$ git clone --quiet [email protected]:/home/gitchat/chatdemo.git > /dev/null
```
假设你没有收到任何错误，就可以开始聊天了。
### 用 Git 聊天
在 GIC 目录中启动聊天客户端：
```
$ npm start
```
客户端首次启动时，必须克隆聊天存储库。由于它几乎是一个空的存储库，因此不会花费很长时间。输入你的消息，然后按回车键发送消息。
*基于 Git 的聊天客户端。 他们接下来会怎么想？*
正如问候消息所说，Git 中的分支在 GIC 中就是聊天室或频道。无法在 GIC 的 UI 中创建新分支，但如果你在另一个终端会话或 Web UI 中创建一个分支，它将立即显示在 GIC 中。将一些 IRC 式的命令加到 GIC 中并不需要太多工作。
聊了一会儿之后，可以看看你的 Git 存储库。由于聊天发生在 Git 中，因此存储库本身也是聊天日志：
```
$ git log --pretty=format:"%p %cn %s"
4387984 Seth Kenlon Hey Chani, did you submit a talk for All Things Open this year?
36369bb Chani No I didn't get a chance. Did you?
[...]
```
### 退出 GIC
Vim 以来，还没有一个应用程序像 GIC 那么难以退出。你看，没有办法停止 GIC。它会一直运行，直到它被杀死。当你准备停止 GIC 时，打开另一个终端选项卡或窗口并发出以下命令：
```
$ kill `pgrep npm`
```
GIC 是一个新奇的事物。这是一个很好的例子，说明开源生态系统如何鼓励和促进创造力和探索，并挑战我们从不同角度审视应用程序。尝试下 GIC，也许它会给你一些思路。至少，它可以让你与 Git 度过一个下午。
---
via: <https://opensource.com/article/19/4/git-based-chat>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 中使用变量 | Sandra Henry-stocker | https://www.networkworld.com/article/3387154/working-with-variables-on-linux.html | 让我们来看看所有这些 $ 值可以告诉你什么。 | /data/attachment/album/201909/15/105140faf2jzyybubu1d0c.jpg.thumb.jpg | /data/attachment/album/201909/15/105140faf2jzyybubu1d0c.jpg | true | false | true | lujun9972 | MjSeven | wxy | false | [
"变量"
] | 技术 | {
"viewnum": 10663,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 10916,
"displayorder": 0
}
] | 让我们来看看所有这些 $ 值可以告诉你什么。 | 2019-09-15T10:51:00 | 2019-09-15T10:51:00 | 11,344 | /article-11344-1.html |
>
> 变量通常看起来像 $var 这样，但它们也有 $1、$\*、$? 和 $$ 这种形式。让我们来看看所有这些 $ 值可以告诉你什么。
>
>
>
有许多重要的值都存储在 Linux 系统中，我们称为“变量”，但实际上变量有几种类型，并且一些有趣的命令可以帮助你使用它们。在上一篇文章中，我们研究了[环境变量](/article-10916-1.html)以及它们定义在何处。在本文中，我们来看一看在命令行和脚本中使用的变量。
### 用户变量
虽然在命令行中设置变量非常容易，但是有一些有趣的技巧。要设置变量，你只需这样做：
```
$ myvar=11
$ myvar2="eleven"
```
要显示这些值，只需这样做：
```
$ echo $myvar
11
$ echo $myvar2
eleven
```
你也可以使用这些变量。例如，要递增一个数字变量，使用以下任意一个命令：
```
$ myvar=$((myvar+1))
$ echo $myvar
12
$ ((myvar=myvar+1))
$ echo $myvar
13
$ ((myvar+=1))
$ echo $myvar
14
$ ((myvar++))
$ echo $myvar
15
$ let "myvar=myvar+1"
$ echo $myvar
16
$ let "myvar+=1"
$ echo $myvar
17
$ let "myvar++"
$ echo $myvar
18
```
使用其中的一些，你可以增加一个变量的值。例如：
```
$ myvar0=0
$ ((myvar0++))
$ echo $myvar0
1
$ ((myvar0+=10))
$ echo $myvar0
11
```
通过这些选项，你可能会发现它们是容易记忆、使用方便的。
你也可以*删除*一个变量 – 这意味着没有定义它。
```
$ unset myvar
$ echo $myvar
```
另一个有趣的选项是，你可以设置一个变量并将其设为**只读**。换句话说，变量一旦设置为只读，它的值就不能改变（除非一些非常复杂的命令行魔法才可以）。这意味着你也不能删除它。
```
$ readonly myvar3=1
$ echo $myvar3
1
$ ((myvar3++))
-bash: myvar3: readonly variable
$ unset myvar3
-bash: unset: myvar3: cannot unset: readonly variable
```
你可以使用这些设置和递增选项中来赋值和操作脚本中的变量，但也有一些非常有用的*内部变量*可以用于在脚本中。注意，你无法重新赋值或增加它们的值。
### 内部变量
在脚本中可以使用很多变量来计算参数并显示有关脚本本身的信息。
* `$1`、`$2`、`$3` 等表示脚本的第一个、第二个、第三个等参数。
* `$#` 表示参数的数量。
* `$*` 表示所有参数。
* `$0` 表示脚本的名称。
* `$?` 表示先前运行的命令的返回码（0 代表成功）。
* `$$` 显示脚本的进程 ID。
* `$PPID` 显示 shell 的进程 ID（脚本的父进程）。
其中一些变量也适用于命令行，但显示相关信息：
* `$0` 显示你正在使用的 shell 的名称（例如，-bash）。
* `$$` 显示 shell 的进程 ID。
* `$PPID` 显示 shell 的父进程的进程 ID（对我来说，是 sshd）。
为了查看它们的结果，如果我们将所有这些变量都放入一个脚本中，比如：
```
#!/bin/bash
echo $0
echo $1
echo $2
echo $#
echo $*
echo $?
echo $$
echo $PPID
```
当我们调用这个脚本时，我们会看到如下内容：
```
$ tryme one two three
/home/shs/bin/tryme <== 脚本名称
one <== 第一个参数
two <== 第二个参数
3 <== 参数的个数
one two three <== 所有的参数
0 <== 上一条 echo 命令的返回码
10410 <== 脚本的进程 ID
10109 <== 父进程 ID
```
如果我们在脚本运行完毕后检查 shell 的进程 ID，我们可以看到它与脚本中显示的 PPID 相匹配：
```
$ echo $$
10109 <== shell 的进程 ID
```
当然，比起简单地显示它们的值，更有用的方式是使用它们。我们来看一看它们可能的用处。
检查是否已提供参数：
```
if [ $# == 0 ]; then
echo "$0 filename"
exit 1
fi
```
检查特定进程是否正在运行：
```
ps -ef | grep apache2 > /dev/null
if [ $? != 0 ]; then
echo Apache is not running
exit
fi
```
在尝试访问文件之前验证文件是否存在：
```
if [ $# -lt 2 ]; then
echo "Usage: $0 lines filename"
exit 1
fi
if [ ! -f $2 ]; then
echo "Error: File $2 not found"
exit 2
else
head -$1 $2
fi
```
在下面的小脚本中，我们检查是否提供了正确数量的参数、第一个参数是否为数字，以及第二个参数代表的文件是否存在。
```
#!/bin/bash
if [ $# -lt 2 ]; then
echo "Usage: $0 lines filename"
exit 1
fi
if [[ $1 != [0-9]* ]]; then
echo "Error: $1 is not numeric"
exit 2
fi
if [ ! -f $2 ]; then
echo "Error: File $2 not found"
exit 3
else
echo top of file
head -$1 $2
fi
```
### 重命名变量
在编写复杂的脚本时，为脚本的参数指定名称通常很有用，而不是继续将它们称为 `$1`、`$2` 等。等到第 35 行，阅读你脚本的人可能已经忘了 `$2` 表示什么。如果你将一个重要参数的值赋给 `$filename` 或 `$numlines`，那么他就不容易忘记。
```
#!/bin/bash
if [ $# -lt 2 ]; then
echo "Usage: $0 lines filename"
exit 1
else
numlines=$1
filename=$2
fi
if [[ $numlines != [0-9]* ]]; then
echo "Error: $numlines is not numeric"
exit 2
fi
if [ ! -f $ filename]; then
echo "Error: File $filename not found"
exit 3
else
echo top of file
head -$numlines $filename
fi
```
当然，这个示例脚本只是运行 `head` 命令来显示文件中的前 x 行，但它的目的是显示如何在脚本中使用内部参数来帮助确保脚本运行良好，或在失败时清晰地知道失败原因。
---
via: <https://www.networkworld.com/article/3387154/working-with-variables-on-linux.html#tk.rss_all>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[MjSeven](https://github.com/MjSeven) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
GNOME 3.34 发布 | Ankush Das | https://itsfoss.com/gnome-3-34-release/ | 最新版本的 GNOME 代号为“塞萨洛尼基”。考虑到这个版本经过了 6 个月的开发，这应该是对 GNOME 3.32 的一次令人印象深刻的升级。 | /data/attachment/album/201909/15/113154i3bcp9p3md3mc3bk.jpg.thumb.jpg | /data/attachment/album/201909/15/113154i3bcp9p3md3mc3bk.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"GNOME"
] | 新闻 | {
"viewnum": 3837,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 最新版本的 GNOME 代号为“塞萨洛尼基”。考虑到这个版本经过了 6 个月的开发，这应该是对 GNOME 3.32 的一次令人印象深刻的升级。 | 2019-09-15T11:33:18 | 2019-09-15T11:33:18 | 11,345 | /article-11345-1.html | 
最新版本的 GNOME 代号为“<ruby> 塞萨洛尼基 <rt> Thessaloniki </rt></ruby>”。考虑到这个版本经过了 6 个月的开发，这应该是对 [GNOME 3.32](https://www.gnome.org/news/2019/03/gnome-3-32-released/) 的一次令人印象深刻的升级。
在此版本中，有许多新功能和显著的性能改进。除了新功能外，可定制的程度也得到了提升。
以下是新的变化：
### GNOME 3.34 的关键改进
你可以观看此视频，了解 GNOME 3.34 中的新功能：
#### 拖放图标到文件夹
新的 shell 主题允许你拖放应用程序抽屉中的图标以重新排列它们，或将它们组合到一个文件夹中。你可能已经在 Android 或 iOS 智能手机中使用过此类功能。
#### 改进的日历管理器
改进的日历管理器可以轻松地与第三方服务集成，使你能够直接从 Linux 系统管理日程安排，而无需单独使用其他应用程序。
#### 背景选择的设置
现在，更容易为主屏幕和锁定屏幕选择自定义背景，因为它在同一屏幕中显示所有可用背景。为你节省至少一次鼠标点击。
#### 重新排列搜索选项
搜索选项和结果可以手动重新排列。因此，当你要搜索某些内容时，可以决定哪些内容先出现。
#### 响应式设计的“设置”应用
设置菜单 UI 现在具有响应性，因此无论你使用何种类型（或尺寸）的设备，都可以轻松访问所有选项。这肯定对 [Linux 智能手机（如 Librem 5）](https://itsfoss.com/librem-linux-phone/) 上的 GNOME 有所帮助。
除了所有这些之外，[官方公告](https://www.gnome.org/press/2019/09/gnome-3-34-released/)还提到到开发人员的有用补充（增加了系统分析器和虚拟化改进）：
>
> 对于开发人员，GNOME 3.34 在 Sysprof 中包含更多数据源，使应用程序的性能分析更加容易。对 Builder 的多项改进中包括集成的 D-Bus 检查器。
>
>
>
### 如何获得GNOME 3.34？
虽然新版本已经发布，但它还没有进入 Linux 发行版的官方存储库。所以，我们建议等待它，并在它作为更新包提供时进行升级。不管怎么说，如果你想构建它，你都可以在这里找到[源代码](https://download.gnome.org/)。
嗯，就是这样。如果你感兴趣，可以查看[完整版本说明](https://help.gnome.org/misc/release-notes/3.34/)以了解技术细节。
你如何看待新的 GNOME 3.34？
---
via: <https://itsfoss.com/gnome-3-34-release/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Firefox 69 默认阻拦第三方 Cookie、自动播放的视频和加密矿工 | Ankush Das | https://itsfoss.com/firefox-69/ | 如果你使用的是 Mozilla Firefox 并且尚未更新到最新版本，那么你将错过许多新的重要功能。 | /data/attachment/album/201909/15/212659s3p37i4i4qb366tf.jpg.thumb.jpg | /data/attachment/album/201909/15/212659s3p37i4i4qb366tf.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Firefox"
] | 新闻 | {
"viewnum": 2964,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 如果你使用的是 Mozilla Firefox 并且尚未更新到最新版本，那么你将错过许多新的重要功能。 | 2019-09-15T21:27:46 | 2019-09-15T21:27:46 | 11,346 | /article-11346-1.html | 
如果你使用的是 [Mozilla Firefox](https://itsfoss.com/why-firefox/) 并且尚未更新到最新版本，那么你将错过许多新的重要功能。
### Firefox 69 版本中的一些新功能
首先，Mozilla Firefox 69 会默认强制执行更强大的安全和隐私选项。以下是新版本的一些主要亮点。
#### Firefox 69 阻拦视频自动播放
现在很多网站都提供了自动播放视频。无论是弹出视频还是嵌入在文章中设置为自动播放的视频，默认情况下，Firefox 69 都会阻止它（或者可能会提示你）。
这个[阻拦自动播放](https://support.mozilla.org/en-US/kb/block-autoplay)功能可让用户自动阻止任何视频播放。
#### 禁止第三方跟踪 cookie
默认情况下，作为<ruby> 增强型跟踪保护 <rt> Enhanced Tracking Protection </rt></ruby>功能的一部分，它现在将阻止第三方跟踪 Cookie 和加密矿工。这是 Mozilla Firefox 的增强隐私保护功能的非常有用的改变。
Cookie 有两种：第一方的和第三方的。第一方 cookie 由网站本身拥有。这些是“好的 cookie”，可以让你保持登录、记住你的密码或输入字段等来改善浏览体验。第三方 cookie 由你访问的网站以外的域所有。广告服务器使用这些 Cookie 来跟踪你，并在你访问的所有网站上跟踪广告。Firefox 69 旨在阻止这些。
当它发挥作用时，你将在地址栏中看到盾牌图标。你可以选择为特定网站禁用它。
#### 禁止加密矿工消耗你的 CPU
对加密货币的欲望一直困扰着这个世界。GPU 的价格已经高企，因为专业的加密矿工们使用它们来挖掘加密货币。
人们使用工作场所的计算机秘密挖掘加密货币。当我说工作场所时，我不一定是指 IT 公司。就在今年，[人们在乌克兰的一家核电站抓住了偷挖加密货币的活动](https://thenextweb.com/hardfork/2019/08/22/ukrainian-nuclear-powerplant-mine-cryptocurrency-state-secrets/)。
不仅如此。如果你访问某些网站，他们会运行脚本并使用你的计算机的 CPU 来挖掘加密货币。这在 IT 术语中被称为 <ruby> <a href="https://hackernoon.com/cryptojacking-in-2019-is-not-dead-its-evolving-984b97346d16"> 挖矿攻击 </a> <rt> cryptojacking </rt></ruby>。
好消息是 Firefox 69 会自动阻止这些加密矿工脚本。因此，网站不再能利用你的系统资源进行挖矿攻击了。
#### Firefox 69 带来的更强隐私保护
如果你把隐私保护设置得更严格，那么它也会阻止指纹。因此，当你在 Firefox 69 中选择严格的隐私设置时，你不必担心通过[指纹](https://clearcode.cc/blog/device-fingerprinting/)共享计算机的配置信息。
在[关于这次发布的官方博客文章](https://blog.mozilla.org/blog/2019/09/03/todays-firefox-blocks-third-party-tracking-cookies-and-cryptomining-by-default/)中，Mozilla 提到，在此版本中，他们希望默认情况下为 100％ 的用户提供保护。
#### 性能改进
尽管在更新日志中没有提及 Linux，但它提到了在 Windows 10/mac OS 上运行性能、UI 和电池寿命有所改进。如果你发现任何性能改进，请在评论中提及。
### 总结
除了所有这些之外，还有很多底层的改进。你可以查看[发行说明](https://www.mozilla.org/en-US/firefox/69.0/releasenotes/)中的详细信息。
Firefox 69 对于关注其隐私的用户来说是一个令人印象深刻的更新。与我们最近对某些[安全电子邮件服务](https://itsfoss.com/secure-private-email-services/)的建议类似，我们建议你更新浏览器以充分受益。新版本已在大多数 Linux 发行版中提供，你只需要更新你的系统即可。
如果你对阻止广告和跟踪 Cookie 的浏览器感兴趣，请尝试[开源的 Brave 浏览器](https://itsfoss.com/brave-web-browser/)，他们甚至给你提供了加密货币以让你使用他们的浏览器，你可以使用这些加密货币来奖励你最喜爱的发布商。
你觉得这个版本怎么样？请在下面的评论中告诉我们你的想法。
---
via: <https://itsfoss.com/firefox-69/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
区块链能如何补充开源 | Bilgin Lbryam | https://opensource.com/article/18/9/barter-currency-system | 了解区块链如何成为去中心化的开源补贴模型。 | /data/attachment/album/201909/16/111521od1yn9r1nr1eii9o.jpg.thumb.jpg | /data/attachment/album/201909/16/111521od1yn9r1nr1eii9o.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"区块链",
"开源"
] | 观点 | {
"viewnum": 4133,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 了解区块链如何成为去中心化的开源补贴模型。 | 2019-09-16T11:15:42 | 2019-09-16T11:15:42 | 11,348 | /article-11348-1.html |
>
> 了解区块链如何成为去中心化的开源补贴模型。
>
>
>
《<ruby> <a href="http://catb.org/"> 大教堂与集市 </a> <rt> The Cathedral and The Bazaar </rt></ruby>》是 20 年前由<ruby> 埃里克·史蒂文·雷蒙德 <rt> Eric Steven Raymond </rt> <rt> </rt></ruby>（ESR）撰写的经典开源故事。在这个故事中，ESR 描述了一种新的革命性的软件开发模型，其中复杂的软件项目是在没有（或者很少的）集中管理的情况下构建的。这个新模型就是<ruby> 开源 <rt> open source </rt></ruby>。
ESR 的故事比较了两种模式：
* 经典模型（由“大教堂”所代表），其中软件由一小群人在封闭和受控的环境中通过缓慢而稳定的发布制作而成。
* 以及新模式（由“集市”所代表），其中软件是在开放的环境中制作的，个人可以自由参与，但仍然可以产生一个稳定和连贯的系统。 开源如此成功的一些原因可以追溯到 ESR 所描述的创始原则。尽早发布、经常发布，并接受许多头脑必然比一个更好的事实，让开源项目进入全世界的人才库（很少有公司能够使用闭源模式与之匹敌）。
在 ESR 对黑客社区的反思分析 20 年后，我们看到开源成为占据主导地位的的模式。它不再仅仅是为了满足开发人员的个人喜好，而是创新发生的地方。甚至是全球[最大](http://oss.cash/)软件公司也正在转向这种模式，以便继续占据主导地位。
### 易货系统
如果我们仔细研究开源模型在实践中的运作方式，我们就会意识到它是一个封闭系统，只对开源开发者和技术人员开放。影响项目方向的唯一方法是加入开源社区，了解成文和不成文的规则，学习如何贡献、编码标准等，并自己亲力完成。
这就是集市的运作方式，也是这个易货系统类比的来源。易货系统是一种交换服务和货物以换取其他服务和货物的方法。在市场中（即软件的构建地）这意味着为了获取某些东西，你必须自己也是一个生产者并回馈一些东西——那就是通过交换你的时间和知识来完成任务。集市是开源开发者与其他开源开发者交互并以开源方式生成开源软件的地方。
易货系统向前迈出了一大步，从自给自足的状态演变而来，而在自给自足的状态下，每个人都必须成为所有行业的杰出人选。使用易货系统的集市（开源模式）允许具有共同兴趣和不同技能的人们收集、协作和创造个人无法自行创造的东西。易货系统简单，没有现代货币系统那么复杂，但也有一些局限性，例如：
* 缺乏可分性：在没有共同的交换媒介的情况下，不能将较大的不可分割的商品/价值兑换成较小的商品/价值。例如，如果你想在开源项目中进行一些哪怕是小的更改，有时你可能仍需要经历一个高进入门槛。
* 存储价值：如果一个项目对贵公司很重要，你可能需要投入大量投资/承诺。但由于它是开源开发者之间的易货系统，因此拥有强大发言权的唯一方法是雇佣许多开源贡献者，但这并非总是可行的。
* 转移价值：如果你投资了一个项目（受过培训的员工、雇用开源开发者）并希望将重点转移到另一个项目，却不可能快速转移（你在上一个项目中拥有的）专业知识、声誉和影响力。
* 时间脱钩：易货系统没有为延期或提前承诺提供良好的机制。在开源世界中，这意味着用户无法提前或在未来期间以可衡量的方式表达对项目的承诺或兴趣。 下面，我们将探讨如何使用集市的后门解决这些限制。
### 货币系统
人们因为不同的原因勾连于集市上：有些人在那里学习，有些是出于满足开发者个人的喜好，有些人为大型软件工厂工作。因为在集市中拥有发言权的唯一方法是成为开源社区的一份子并加入这个易货系统，为了在开源世界获得信誉，许多大型软件公司雇用这些开发者并以货币方式支付薪酬。这代表可以使用货币系统来影响集市，开源不再只是为了满足开发者个人的喜好，它也占据全球整体软件生产的重要部分，并且有许多人想要施加影响。
开源设定了开发人员交互的指导原则，并以分布式方式构建一致的系统。它决定了项目的治理方式、软件的构建方式以及其成果如何分发给用户。它是分散的实体共同构建高质量软件的开放共识模型。但是开源模型并没有包括如何补贴开源的部分，无论是直接还是间接地，通过内在或外在动机的赞助，都与集市无关。
目前，没有相当于以补贴为目的的去中心化式开源开发模型。大多数开源补贴都是集中式的，通常一家公司通过雇用该项目的主要开源开发者来主导该项目。说实话，这是目前最好的状况，因为它保证了开发人员将长期获得报酬，项目也将继续蓬勃发展。
项目垄断情景也有例外情况：例如，一些云原生计算基金会（CNCF）项目是由大量的竞争公司开发的。此外，Apache 软件基金会（ASF）旨在通过鼓励不同的贡献者来使他们管理的项目不被单一供应商所主导，但实际上大多数受欢迎的项目仍然是单一供应商项目。
我们缺少的是一个开放的、去中心化的模式，就像一个没有集中协调和所有权的集市一样，消费者（开源用户）和生产者（开源开发者）在市场力量和开源价值的驱动下相互作用。为了补充开源，这样的模型也必须是开放和去中心化的，这就是为什么我认为区块链技术[最适合](https://opensource.com/article/18/8/open-source-tokenomics)的原因。
旨在补贴开源开发的大多数现有区块链（和非区块链）平台主要针对的是漏洞赏金、小型和零碎的任务。少数人还专注于资助新的开源项目。但并没有多少平台旨在提供维持开源项目持续开发的机制 —— 基本上，这个系统可以模仿开源服务提供商公司或开放核心、基于开源的 SaaS 产品公司的行为：确保开发人员可以获得持续和可预测的激励，并根据激励者（即用户）的优先事项指导项目开发。这种模型将解决上面列出的易货系统的局限性：
* 允许可分性：如果你想要一些小的修复，你可以支付少量费用，而不是成为项目的开源开发者的全部费用。
* 存储价值：你可以在项目中投入大量资金，并确保其持续发展和你的发言权。
* 转移价值：在任何时候，你都可以停止投资项目并将资金转移到其他项目中。
* 时间脱钩：允许定期定期付款和订阅。
还有其他好处，纯粹是因为这种基于区块链的系统是透明和去中心化的：根据用户的承诺、开放的路线图承诺、去中心化决策等来量化项目的价值/实用性。
### 总结
一方面，我们看到大公司雇用开源开发者并收购开源初创公司甚至基础平台（例如微软收购 GitHub）。许多（甚至大多数）能够长期成功运行的开源项目都集中在单个供应商周围。开源的重要性及其集中化是一个事实。
另一方面，[维持开源软件](https://www.youtube.com/watch?v=VS6IpvTWwkQ)的挑战正变得越来越明显，许多人正在更深入地研究这个领域及其基本问题。有一些项目具有很高的知名度和大量的贡献者，但还有许多其他也重要的项目缺乏足够的贡献者和维护者。
有[许多努力](https://opensource.com/article/18/8/open-source-tokenomics)试图通过区块链来解决开源的挑战。这些项目应提高透明度、去中心化和补贴，并在开源用户和开发人员之间建立直接联系。这个领域还很年轻，但是进展很快，随着时间的推移，集市将会有一个加密货币系统。
如果有足够的时间和足够的技术，去中心化就会发生在很多层面：
* 互联网是一种去中心化的媒介，它释放了全球分享和获取知识的潜力。
* 开源是一种去中心化的协作模式，它释放了全球的创新潜力。
* 同样，区块链可以补充开源，成为去中心化的开源补贴模式。
请在[推特](http://twitter.com/bibryam)上关注我在这个领域的其他帖子。
---
via: <https://opensource.com/article/18/9/barter-currency-system>
作者：[Bilgin lbryam](https://opensource.com/users/bibryam) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Manjaro Linux 从业余爱好项目成长为专业项目 | Ankush Das | https://itsfoss.com/manjaro-linux-business-formation/ | Manjaro 正在走专业化路线。虽然 Manjaro 社区将负责项目的开发和其他相关活动，但该团队已成立了一家公司作为其法人实体处理商业协议和专业服务。 | /data/attachment/album/201909/16/182749ic43iw3cxiiw2t11.jpg.thumb.jpg | /data/attachment/album/201909/16/182749ic43iw3cxiiw2t11.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Manjaro"
] | 观点 | {
"viewnum": 4633,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Manjaro 正在走专业化路线。虽然 Manjaro 社区将负责项目的开发和其他相关活动，但该团队已成立了一家公司作为其法人实体处理商业协议和专业服务。 | 2019-09-16T18:27:46 | 2019-09-16T18:27:46 | 11,349 | /article-11349-1.html |
>
> Manjaro 正在走专业化路线。虽然 Manjaro 社区将负责项目的开发和其他相关活动，但该团队已成立了一家公司作为其法人实体处理商业协议和专业服务。
>
>
>
Manjaro 是一个相当流行的 Linux 发行版，而它只是由三个人（Bernhard、Jonathan 和 Phili）于 2011 年激情之下创建的项目。现在，它是目前[最好的 Linux 发行版](https://itsfoss.com/best-linux-distributions/)之一，所以它不能真的一直还只是个业余爱好项目了，对吧。
嗯，现在有个好消息：Manjaro 已经建立了一家新公司“[Manjaro GmbH & Co. KG]”，以 [Blue Systems](https://www.blue-systems.com/) 为顾问，以便能够全职雇佣维护人员，并探索未来的商业机会。
### 具体有什么变化？
根据[官方公告](https://forum.manjaro.org/t/manjaro-is-taking-the-next-step/102105)，Manjaro 项目将保持不变。但是，成立了一家新公司来保护该项目，以允许他们制定法律合同、官方协议和进行其他潜在的商业活动。因此，这使得这个“业余爱好项目”成为了一项专业工作。
除此之外，捐赠资金将转给非营利性的[财政托管](https://en.wikipedia.org/wiki/Fiscal_sponsorship)（[CommunityBridge](https://communitybridge.org/) 和 [OpenCollective](https://opencollective.com/)），让他们来代表项目接受和管理资金。请注意，这些捐赠没有被用于创建这个公司，因此，将资金转移给非营利的财务托管将在确保捐赠的同时也确保透明度。
### 这会有何改善？
随着这个公司的成立，（如开发者所述）新结构将以下列方式帮助 Manjaro：
* 使开发人员能够全职投入 Manjaro 及其相关项目；
* 在 Linux 相关的比赛和活动中与其他开发人员进行互动；
* 保护 Manjaro 作为一个社区驱动项目的独立性，并保护其品牌；
* 提供更快的安全更新，更有效地响应用户需求；
* 提供在专业层面上作为公司行事的手段。
Manjaro 团队还阐明了它将如何继续致力于社区：
>
> Manjaro 的使命和目标将与以前一样 —— 支持 Manjaro 的协作开发及其广泛使用。这项工作将继续通过捐赠和赞助来支持，这些捐赠和赞助在任何情况下都不会被这个成立的公司使用。
>
>
>
### 关于 Manjaro 公司的更多信息
尽管他们提到该项目将独立于公司，但并非所有人都清楚当有了一家具有商业利益的公司时 Manjaro 与“社区”的关系。因此，该团队还在公告中澄清了他们作为一家公司的计划。
>
> Manjaro GmbH ＆ Co.KG 的成立旨在有效地参与商业协议、建立合作伙伴关系并提供专业服务。有了这个，Manjaro 开发者 Bernhard 和 Philip 现在可以全职工作投入到 Manjaro，而 Blue Systems 将担任顾问。
>
>
> 公司将能够正式签署合同并承担职责和保障，而社区不能承担或承担责任。
>
>
>
### 总结
因此，通过这一举措以及商业机会，他们计划全职工作并聘请贡献者。
当然，现在他们的意思是“业务”（我希望不是作为坏人）。对此公告的大多数反应都是积极的，我们都祝他们好运。虽然有些人可能对具有“商业”利益的“社区”项目持怀疑态度（还记得 [FreeOffice 和 Manjaro 的挫败](https://itsfoss.com/libreoffice-freeoffice-manjaro-linux/)吗？），但我认为这是一个有趣的举措。
你怎么看？请在下面的评论中告诉我们你的想法。
---
via: <https://itsfoss.com/manjaro-linux-business-formation/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
开源新闻综述：五角大楼、好莱坞和 Sandboxie 的开源 | Lauren Maffeo | https://opensource.com/article/19/9/news-september-15 | 不要错过两周以来最大的开源头条新闻。 | /data/attachment/album/201909/17/122416ry11111hiy11bt4x.png.thumb.jpg | /data/attachment/album/201909/17/122416ry11111hiy11bt4x.png | true | false | true | lujun9972 | wxy | wxy | false | [
"开源"
] | 新闻 | {
"viewnum": 3030,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11291,
"displayorder": 0
}
] | 不要错过两周以来最大的开源头条新闻。 | 2019-09-17T12:23:00 | 2019-09-17T12:23:00 | 11,351 | /article-11351-1.html |
>
> 不要错过两周以来最大的开源头条新闻。
>
>
>
在本期我们的开源新闻综述中有 Sandboxie 的开源之路、五角大楼开源计划的进一步变化、好莱坞开源等等！
### 五角大楼不符合白宫对开源软件的要求
2016 年，美国白宫要求每个美国政府机构必须在三年内开放至少 20％ 的定制软件。2017 年有一篇关于这一倡议的[有趣文章](https://medium.com/@DefenseDigitalService/code-mil-an-open-source-initiative-at-the-pentagon-5ae4986b79bc)，其中列出了一些令人激动的事情和面临的挑战。
根据美国政府问责局（GAO）的说法，[美国五角大楼做的还远远不足](https://www.nextgov.com/analytics-data/2019/09/pentagon-needs-make-more-software-open-source-watchdog-says/159832/)。
在一篇关于 Nextgov 的文章中，Jack Corrigan 写道，截至 2019 年 7 月，美国五角大楼仅发布了 10％ 的代码为开源代码。他们还没有实施的其它白宫任务包括要求制定开源软件政策和定制代码的清单。
根据该报告，一些美国政府官员告诉 GAO，他们担心美国政府部门间共享代码的安全风险。他们还承认没有创建衡量开源工作成功的指标。美国五角大楼的首席技术官将五角大楼的规模列为不执行白宫的开源任务的原因。在周二发布的一份报告中，GAO 表示，“在（美国国防部）完全实施其试点计划并确定完成行政管理和预算局（OMB）要求的里程碑之前，该部门将无法达成显著的成本节约和效率的目的。”
### Sandboxie 在开源的过程中变成了免费软件
一家英国安全公司 Sophos Group plc 发布了[其流行的 Sandboxie 工具的免费版本](https://www.sandboxie.com/DownloadSandboxie)，它用作Windows 的隔离操作环境（[可在此下载](https://www.sandboxie.com/DownloadSandboxie)）。
Sophos 表示，由于 Sandboxie 不是其业务的核心，因此更容易做出的决定就是关闭它。但 Sandboxie 因为无需让用户的操作系统冒风险就可以在安全的环境中运行未知软件而[广受赞誉](https://betanews.com/2019/09/13/sandboxie-free-open-source/)，因此该团队正在投入额外的工作将其作为开源软件发布。这个免费但非开源的中间阶段似乎与当前的系统设计有关，因为它需要激活密钥：
>
> Sandboxie 目前使用许可证密钥来激活和授予仅针对付费客户开放的高级功能的访问权限（与使用免费版本的用户相比）。我们修改了代码，并发布了一个不限制任何功能的免费版本的更新版。换句话说，新的免费许可证将可以访问之前仅供付费客户使用的所有功能。
>
>
>
受此工具的社区影响，Sophos 的高级领导人宣布发布 Sandboxie 版本 5.31.4，这个不受限制的程序版本将保持免费，直到该工具完全开源。
>
> “Sandboxie 用户群代表了一些最热情、前瞻性和知识渊博的安全社区成员，我们不想让你失望，”[Sophos 的博文说到](https://community.sophos.com/products/sandboxie/f/forum/115109/major-sandboxie-news-sandboxie-is-now-a-free-tool-with-plans-to-transition-it-to-an-open-source-tool/414522)。“经过深思熟虑后，我们认为让 Sandboxie 走下去的最佳方式是将其交还给用户，将其转换为开源工具。”
>
>
>
### 志愿者团队致力于查找和数字化无版权书籍
1924 年以前在美国出版的所有书籍都是[公有的、可以自由使用/复制的](https://www.vice.com/en_us/article/a3534j/libraries-and-archivists-are-scanning-and-uploading-books-that-are-secretly-in-the-public-domain)。1964 年及之后出版的图书在出版日期后将保留 95 年的版权。但由于版权漏洞，1923 年至 1964 年间出版的书籍中有高达 75％ 可以免费阅读和复制。现在只需要耗时确认那些书是什么。
因此，一些图书馆、志愿者和档案管理员们联合起来了解哪些图书没有版权，然后将其数字化并上传到互联网。由于版权续约记录已经数字化，因此很容易判断 1923 年至 1964 年间出版的书籍是否更新了其版权。但是，由于试图提供的是反证，因此寻找缺乏版权更新的难度要大得多。
参与者包括纽约公共图书馆（NYPL），它[最近解释了](https://www.nypl.org/blog/2019/09/01/historical-copyright-records-transparency)为什么这个耗时的项目是值得的。为了帮助更快地找到更多书籍，NYPL 将许多记录转换为 XML 格式。这样可以更轻松地自动执行查找可以将哪些书籍添加到公共域的过程。
### 好莱坞的学院软件基金会获得新成员
微软和苹果公司宣布计划以<ruby> 学院软件基金会 <rt> Academy Software Foundation </rt></ruby>（ASWF）的高级会员做出贡献。他们将加入[创始董事会成员](https://variety.com/2019/digital/news/microsoft-apple-academy-software-foundation-1203334675/)，其它成员还包括 Netflix、Google Cloud、Disney Studios 和 Sony Pictures。
学院软件基金会于 2018 年作为[电影艺术与科学学院](https://www.oscars.org/)和[Linux 基金会](http://www.linuxfoundation.org/)的联合项目而启动。
>
> 学院软件基金会（ASWF）的使命是提高贡献到内容创作行业的开源软件库的质量和数量；提供一个中立的论坛来协调跨项目的工作；提供通用的构建和测试基础架构；并为个人和组织提供参与推进我们的开源生态系统的明确途径。
>
>
>
在第一年内，该基金会构建了 [OpenTimelineIO](https://github.com/PixarAnimationStudios/OpenTimelineIO)，这是一种开源 API 和交换格式，可帮助工作室团队跨部门协作。OpenTImelineIO 被该[基金会技术咨询委员会](https://www.linuxfoundation.org/press-release/2019/07/opentimelineio-joins-aswf/)去年 7 月正式接受为第五个托管项目。他们现在将它与 [OpenColorIO](https://opencolorio.org/)、[OpenCue](https://www.opencue.io/)、[OpenEXR](https://www.openexr.com/) 和 [OpenVDB](https://www.openvdb.org/) 并列维护。
### 其它新闻
* [Comcast 将开源网络软件投入生产环境](https://www.fiercetelecom.com/operators/comcast-puts-open-source-networking-software-into-production)
* [SD Times 本周开源项目：Ballerina](https://sdtimes.com/os/sd-times-open-source-project-of-the-week-ballerina/)
* [美国国防部努力实施开源计划](https://www.fedscoop.com/open-source-software-dod-struggles/)
* [Kong 开源通用服务网格 Kuma](https://sdtimes.com/micro/kong-open-sources-universal-service-mesh-kuma/)
* [Eclipse 推出 Jakarta EE 8](https://devclass.com/2019/09/11/hey-were-open-source-again-eclipse-unveils-jakarta-ee-8/)
一如既往地感谢 Opensource.com 的工作人员和主持人本周的帮助。
---
via: <https://opensource.com/article/19/9/news-september-15>
作者：[Lauren Maffeo](https://opensource.com/users/lmaffeo) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何使用 Bash 脚本从 SAR 报告中获取 CPU 和内存使用情况 | Magesh Maruthamuthu | https://www.2daygeek.com/linux-get-average-cpu-memory-utilization-from-sar-data-report/ | 在本文中，我们添加了三个 bash 脚本，它们可以帮助你在一个地方轻松查看每个数据文件的平均值。 | /data/attachment/album/201909/17/125134fm0vsssppybnnmvp.jpg.thumb.jpg | /data/attachment/album/201909/17/125134fm0vsssppybnnmvp.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"sar"
] | 系统运维 | {
"viewnum": 6462,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 在本文中，我们添加了三个 bash 脚本，它们可以帮助你在一个地方轻松查看每个数据文件的平均值。 | 2019-09-17T12:51:47 | 2019-09-17T12:51:47 | 11,352 | /article-11352-1.html | 
大多数 Linux 管理员使用 [SAR 报告](https://www.2daygeek.com/sar-system-performance-monitoring-command-tool-linux/)监控系统性能，因为它会收集一周的性能数据。但是，你可以通过更改 `/etc/sysconfig/sysstat` 文件轻松地将其延长到四周。同样，这段时间可以延长一个月以上。如果超过 28，那么日志文件将放在多个目录中，每月一个。
要将覆盖期延长至 28 天，请对 `/etc/sysconfig/sysstat` 文件做以下更改。
编辑 `sysstat` 文件并将 `HISTORY=7` 更改为 `HISTORY=28`。
在本文中，我们添加了三个 bash 脚本，它们可以帮助你在一个地方轻松查看每个数据文件的平均值。
我们过去加过许多有用的 shell 脚本。如果你想查看它们，请进入下面的链接。
* [如何使用 shell 脚本自动化日常操作](https://www.2daygeek.com/category/shell-script/)
这些脚本简单明了。出于测试目的，我们仅包括两个性能指标，即 CPU 和内存。你可以修改脚本中的其他性能指标以满足你的需求。
### 脚本 1：从 SAR 报告中获取平均 CPU 利用率的 Bash 脚本
该 bash 脚本从每个数据文件中收集 CPU 平均值并将其显示在一个页面上。
由于是月末，它显示了 2019 年 8 月的 28 天数据。
```
# vi /opt/scripts/sar-cpu-avg.sh
#!/bin/sh
echo "+----------------------------------------------------------------------------------+"
echo "|Average: CPU %user %nice %system %iowait %steal %idle |"
echo "+----------------------------------------------------------------------------------+"
for file in `ls -tr /var/log/sa/sa* | grep -v sar`
do
dat=`sar -f $file | head -n 1 | awk '{print $4}'`
echo -n $dat
sar -f $file | grep -i Average | sed "s/Average://"
done
echo "+----------------------------------------------------------------------------------+"
```
运行脚本后，你将看到如下输出。
```
# sh /opt/scripts/sar-cpu-avg.sh
+----------------------------------------------------------------------------------+
|Average: CPU %user %nice %system %iowait %steal %idle |
+----------------------------------------------------------------------------------+
08/01/2019 all 0.70 0.00 1.19 0.00 0.00 98.10
08/02/2019 all 1.73 0.00 3.16 0.01 0.00 95.10
08/03/2019 all 1.73 0.00 3.16 0.01 0.00 95.11
08/04/2019 all 1.02 0.00 1.80 0.00 0.00 97.18
08/05/2019 all 0.68 0.00 1.08 0.01 0.00 98.24
08/06/2019 all 0.71 0.00 1.17 0.00 0.00 98.12
08/07/2019 all 1.79 0.00 3.17 0.01 0.00 95.03
08/08/2019 all 1.78 0.00 3.14 0.01 0.00 95.08
08/09/2019 all 1.07 0.00 1.82 0.00 0.00 97.10
08/10/2019 all 0.38 0.00 0.50 0.00 0.00 99.12
.
.
.
08/29/2019 all 1.50 0.00 2.33 0.00 0.00 96.17
08/30/2019 all 2.32 0.00 3.47 0.01 0.00 94.20
+----------------------------------------------------------------------------------+
```
### 脚本 2：从 SAR 报告中获取平均内存利用率的 Bash 脚本
该 bash 脚本从每个数据文件中收集内存平均值并将其显示在一个页面上。
由于是月末，它显示了 2019 年 8 月的 28 天数据。
```
# vi /opt/scripts/sar-memory-avg.sh
#!/bin/sh
echo "+-------------------------------------------------------------------------------------------------------------------+"
echo "|Average: kbmemfree kbmemused %memused kbbuffers kbcached kbcommit %commit kbactive kbinact kbdirty |"
echo "+-------------------------------------------------------------------------------------------------------------------+"
for file in `ls -tr /var/log/sa/sa* | grep -v sar`
do
dat=`sar -f $file | head -n 1 | awk '{print $4}'`
echo -n $dat
sar -r -f $file | grep -i Average | sed "s/Average://"
done
echo "+-------------------------------------------------------------------------------------------------------------------+"
```
运行脚本后，你将看到如下输出。
```
# sh /opt/scripts/sar-memory-avg.sh
+--------------------------------------------------------------------------------------------------------------------+
|Average: kbmemfree kbmemused %memused kbbuffers kbcached kbcommit %commit kbactive kbinact kbdirty |
+--------------------------------------------------------------------------------------------------------------------+
08/01/2019 1492331 2388461 61.55 29888 1152142 1560615 12.72 1693031 380472 6
08/02/2019 1493126 2387666 61.53 29888 1147811 1569624 12.79 1696387 373346 3
08/03/2019 1489582 2391210 61.62 29888 1147076 1581711 12.89 1701480 370325 3
08/04/2019 1490403 2390389 61.60 29888 1148206 1569671 12.79 1697654 373484 4
08/05/2019 1484506 2396286 61.75 29888 1152409 1563804 12.75 1702424 374628 4
08/06/2019 1473593 2407199 62.03 29888 1151137 1577491 12.86 1715426 371000 8
08/07/2019 1467150 2413642 62.19 29888 1155639 1596653 13.01 1716900 372574 13
08/08/2019 1451366 2429426 62.60 29888 1162253 1604672 13.08 1725931 376998 5
08/09/2019 1451191 2429601 62.61 29888 1158696 1582192 12.90 1728819 371025 4
08/10/2019 1450050 2430742 62.64 29888 1160916 1579888 12.88 1729975 370844 5
.
.
.
08/29/2019 1365699 2515093 64.81 29888 1198832 1593567 12.99 1781733 376157 15
08/30/2019 1361920 2518872 64.91 29888 1200785 1595105 13.00 1784556 375641 8
+-------------------------------------------------------------------------------------------------------------------+
```
### 脚本 3：从 SAR 报告中获取 CPU 和内存平均利用率的 Bash 脚本
该 bash 脚本从每个数据文件中收集 CPU 和内存平均值并将其显示在一个页面上。
该脚本与上面相比稍微不同。它在同一位置同时显示两者（CPU 和内存）平均值，而不是其他数据。
```
# vi /opt/scripts/sar-cpu-mem-avg.sh
#!/bin/bash
for file in `ls -tr /var/log/sa/sa* | grep -v sar`
do
sar -f $file | head -n 1 | awk '{print $4}'
echo "-----------"
sar -u -f $file | awk '/Average:/{printf("CPU Average: %.2f%\n"), 100 - $8}'
sar -r -f $file | awk '/Average:/{printf("Memory Average: %.2f%\n"),(($3-$5-$6)/($2+$3)) * 100 }'
printf "\n"
done
```
运行脚本后，你将看到如下输出。
```
# sh /opt/scripts/sar-cpu-mem-avg.sh
08/01/2019
-----------
CPU Average: 1.90%
Memory Average: 31.09%
08/02/2019
-----------
CPU Average: 4.90%
Memory Average: 31.18%
08/03/2019
-----------
CPU Average: 4.89%
Memory Average: 31.29%
08/04/2019
-----------
CPU Average: 2.82%
Memory Average: 31.24%
08/05/2019
-----------
CPU Average: 1.76%
Memory Average: 31.28%
.
.
.
08/29/2019
-----------
CPU Average: 3.83%
Memory Average: 33.15%
08/30/2019
-----------
CPU Average: 5.80%
Memory Average: 33.19%
```
---
via: <https://www.2daygeek.com/linux-get-average-cpu-memory-utilization-from-sar-data-report/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Firefox 69 已可在 Fedora 中获取 | Paul W. Frields | https://fedoramagazine.org/firefox-69-available-in-fedora/ | 开发者社区不断改进和增强 Firefox。最新版本 Firefox 69 于最近发布 | /data/attachment/album/201909/18/095421jv602uqkrwlrwu53.jpg.thumb.jpg | /data/attachment/album/201909/18/095421jv602uqkrwlrwu53.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Firefox"
] | 桌面应用 | {
"viewnum": 3565,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 开发者社区不断改进和增强 Firefox。最新版本 Firefox 69 于最近发布 | 2019-09-18T09:54:18 | 2019-09-18T09:54:18 | 11,354 | /article-11354-1.html | 
当你安装 Fedora Workstation 时，你会发现它包括了世界知名的 Firefox 浏览器。Mozilla 基金会以开发 Firefox 以及其他促进开放、安全和隐私的互联网项目为己任。Firefox 有快速的浏览引擎和大量的隐私功能。
开发者社区不断改进和增强 Firefox。最新版本 Firefox 69 于最近发布，你可在稳定版 Fedora 系统（30 及更高版本）中获取它。继续阅读以获得更多详情。
### Firefox 69 中的新功能
最新版本的 Firefox 包括<ruby> <a href="https://blog.mozilla.org/blog/2019/09/03/todays-firefox-blocks-third-party-tracking-cookies-and-cryptomining-by-default/"> 增强跟踪保护 </a> <rt> Enhanced Tracking Protection </rt></ruby>（ETP）。当你使用带有新（或重置）配置文件的 Firefox 69 时，浏览器会使网站更难以跟踪你的信息或滥用你的计算机资源。
例如，不太正直的网站使用脚本让你的系统进行大量计算来产生加密货币，这称为<ruby> <a href="https://www.webopedia.com/TERM/C/cryptocurrency-mining.html"> 加密挖矿 </a> <rt> cryptomining </rt></ruby>。加密挖矿在你不知情或未经许可的情况下发生，因此是对你的系统的滥用。Firefox 69 中的新标准设置可防止网站遭受此类滥用。
Firefox 69 还有其他设置，可防止识别或记录你的浏览器指纹，以供日后使用。这些改进为你提供了额外的保护，免于你的活动被在线追踪。
另一个常见的烦恼是在没有提示的情况下播放视频。视频播放也会占用更多的 CPU，你可能不希望未经许可就在你的笔记本上发生这种情况。Firefox 使用<ruby> <a href="https://support.mozilla.org/kb/block-autoplay"> 阻止自动播放 </a> <rt> Block Autoplay </rt></ruby>这个功能阻止了这种情况的发生。而 Firefox 69 还允许你停止静默开始播放的视频。此功能可防止不必要的突然的噪音。它还解决了更多真正的问题 —— 未经许可使用计算机资源。
新版本中还有许多其他新功能。在 [Firefox 发行说明](https://www.mozilla.org/en-US/firefox/69.0/releasenotes/)中阅读有关它们的更多信息。
### 如何获得更新
Firefox 69 存在于稳定版 Fedora 30、预发布版 Fedora 31 和 Rawhide 仓库中。该更新由 Fedora 的 Firefox 包维护者提供。维护人员还确保更新了 Mozilla 的网络安全服务（nss 包）。我们感谢 Mozilla 项目和 Firefox 社区在提供此新版本方面的辛勤工作。
如果你使用的是 Fedora 30 或更高版本，请在 Fedora Workstation 上使用*软件中心*，或在任何 Fedora 系统上运行以下命令：
```
$ sudo dnf --refresh upgrade firefox
```
如果你使用的是 Fedora 29，请[帮助测试更新](https://bodhi.fedoraproject.org/updates/FEDORA-2019-89ae5bb576)，这样它可以变得稳定，让所有用户可以轻松使用。
Firefox 可能会提示你升级个人设置以使用新设置。要使用新功能，你应该这样做。
---
via: <https://fedoramagazine.org/firefox-69-available-in-fedora/>
作者：[Paul W. Frields](https://fedoramagazine.org/author/pfrields/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
每周开源点评：Linux Plumbers、Appwrite | Tim Hildred | https://opensource.com/article/19/9/conferences-industry-trends | 了解每周的开源社区和行业趋势。 | /data/attachment/album/201909/18/113440ao2ox4rqpxlz7o4o.png.thumb.jpg | /data/attachment/album/201909/18/113440ao2ox4rqpxlz7o4o.png | true | false | true | lujun9972 | wxy | wxy | false | [
"Linux"
] | 观点 | {
"viewnum": 3573,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 了解每周的开源社区和行业趋势。 | 2019-09-18T11:34:36 | 2019-09-18T11:34:36 | 11,355 | /article-11355-1.html |
>
> 了解每周的开源社区和行业趋势。
>
>
>
作为采用开源开发模式的企业软件公司的高级产品营销经理，这是我为产品营销人员、经理和其他相关人员发布的有关开源社区、市场和行业趋势的定期更新。以下是本次更新中我最喜欢的五篇文章。
### 《在 Linux Plumbers 会议上解决 Linux 具体细节》
* [文章地址](https://www.zdnet.com/article/working-on-linuxs-nuts-and-bolts-at-linux-plumbers/)
>
> Linux 的创建者 Linus Torvalds 告诉我，<ruby> 内核维护者峰会 <rt> Kernel Maintainers Summit </rt></ruby>是顶级 Linux 内核开发人员的邀请制聚会。但是，虽然你可能认为这是关于规划 Linux 内核的未来的会议，但事实并非如此。“这个维护者峰会真的与众不同，因为它甚至不谈论技术问题。”相反，“全都谈的是关于创建和维护 Linux 内核的过程。”
>
>
>
**影响**：这就像技术版的 Bilderberg 会议：你们举办的都是各种华丽的流行语会议，而在这里我们做出的才是真正的决定。不过我觉得，可能不太会涉及到私人飞机吧。（LCTT 译注：有关 Bilderberg 请自行搜索）
### 《微软主办第一个 WSL 会议》
* [文章地址](https://www.zdnet.com/article/microsoft-hosts-first-windows-subsystem-for-linux-conference/)
>
> [Whitewater Foundry](https://github.com/WhitewaterFoundry) 是一家专注于 [Windows 的 Linux 子系统（WSL）](https://docs.microsoft.com/en-us/windows/wsl/install-win10)的创业公司，它的创始人 Hayden Barnes [宣布举办 WSLconf 1](https://www.linkedin.com/feed/update/urn:li:activity:6574754435518599168/)，这是 WSL 的第一次社区会议。该活动将于 2020 年 3 月 10 日至 11 日在华盛顿州雷德蒙市的微软总部 20 号楼举行。会议是合办的。我们已经知道将有来自[Pengwin（Whitewater 的 Linux for Windows）](https://www.zdnet.com/article/pengwin-a-linux-specifically-for-windows-subsystem-for-linux/)、微软 WSL 和 Canonical 的 Ubuntu on WSL 开发人员的演讲和研讨会。
>
>
>
**影响**：微软正在培育社区成长的种子，围绕它越来越多地采用开源软件并作出贡献。这足以让我眼前一亮。
### 《Appwrite 简介：面向移动和 Web 开发人员的开源后端服务器》
* [文章链接](https://medium.com/@eldadfux/introducing-appwrite-an-open-source-backend-server-for-mobile-web-developers-4be70731575d)
>
> [Appwrite](https://appwrite.io) 是一个新的[开源软件](https://github.com/appwrite/appwrite)，用于前端和移动开发人员的端到端的后端服务器，可以让你更快地构建应用程序。[Appwrite](https://medium.com/@eldadfux/introducing-appwrite-an-open-source-backend-server-for-mobile-web-developers-4be70731575d?source=friends_link&sk=b6a2be384aafd1fa5b1b6ff12906082c) 的目标是抽象和简化 REST API 和工具背后的常见开发任务，以帮助开发人员更快地构建高级应用程序。
>
>
> 在这篇文章中，我将简要介绍一些主要的 [Appwrite](https://appwrite.io/) 服务，并解释它们的主要功能以及它们的设计方式，相比从头开始编写所有后端 API，这可以帮助你更快地构建下一个项目。
>
>
>
**影响**：随着更多开源中间件变得更易于使用，软件开发越来越容易。Appwrite 声称可将开发时间和成本降低 70％。想象一下这对小型移动开发机构或个人开发者意味着什么。我很好奇他们将如何通过这种方式赚钱。
### 《“不只是 IT”：开源技术专家说协作文化是政府转型的关键》
* [文章链接](https://medium.com/agile-government-leadership/more-than-just-it-open-source-technologist-says-collaborative-culture-is-key-to-government-c46d1489f822)
>
> AGL（<ruby> 敏捷的政府领导 <rt> agile government leadership </rt></ruby>）正在为那些帮助政府更好地为公众工作的人们提供价值支持网络。该组织专注于我非常热衷的事情：DevOps、数字化转型、开源以及许多政府 IT 领导者首选的类似主题。AGL 为我提供了一个社区，可以了解当今最优秀和最聪明的人所做的事情，并与整个行业的同行分享这些知识。
>
>
>
**影响**：不管你的政治信仰如何，对政府都很容易愤世嫉俗。我发现令人耳目一新的是，政府也是由一个个实际的人组成的，他们大多在尽力将相关技术应用于公益事业。特别是当该技术是开源的！
### 《彭博社如何通过 Kubernetes 实现接近 90-95% 的硬件利用率》
* [文章链接](https://www.cncf.io/blog/2019/09/12/how-bloomberg-achieves-close-to-90-95-hardware-utilization-with-kubernetes/)
>
> 2016 年，彭博社采用了 Kubernetes（当时仍处于 alpha 阶段中），自使用该项目的上游代码以来，取得了显著成果。Rybka 说：“借助 Kubernetes，我们能够非常高效地使用我们的硬件，使利用率接近 90% 到 95%。”Kubernetes 中的自动缩放使系统能够更快地满足需求。此外，Kubernetes “为我们提供了标准化我们构建和管理服务的方法的能力，这意味着我们可以花费更多时间专注于实际使用我们支持的开源工具，”数据和分析基础架构主管 Steven Bower 说，“如果我们想要在世界的另一个位置建立一个新的集群，那么这样做真的非常简单。一切都只是代码。配置就是代码。”
>
>
>
**影响**：没有什么能像利用率统计那样穿过营销的迷雾。我听说过关于 Kube 的一件事是，当人们运行它时，他们不知道用它做什么。像这样的用例可以给他们（和你）一些想要的东西。
*我希望你喜欢这个上周重要内容的清单，请下周回来了解有关开源社区、市场和行业趋势的更多信息。*
---
via: <https://opensource.com/article/19/9/conferences-industry-trends>
作者：[Tim Hildred](https://opensource.com/users/thildred) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Conda 管理 MacOS 上的 Ansible 环境 | James Farrell | https://opensource.com/article/19/8/using-conda-ansible-administration-macos | Conda 将 Ansible 所需的一切都收集到虚拟环境中并将其与其他项目分开。 | /data/attachment/album/201909/18/123838m1bcmke570kl6kzm.jpg.thumb.jpg | /data/attachment/album/201909/18/123838m1bcmke570kl6kzm.jpg | true | false | true | lujun9972 | heguangzhi | wxy | false | [
"Conda",
"Ansible"
] | 技术 | {
"viewnum": 3871,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Conda 将 Ansible 所需的一切都收集到虚拟环境中并将其与其他项目分开。 | 2019-09-18T12:39:11 | 2019-09-18T12:39:11 | 11,356 | /article-11356-1.html |
>
> Conda 将 Ansible 所需的一切都收集到虚拟环境中并将其与其他项目分开。
>
>
>
如果你是一名使用 MacOS 并涉及到 Ansible 管理的 Python 开发人员，你可能希望使用 Conda 包管理器将 Ansible 的工作内容与核心操作系统和其他本地项目分开。
Ansible 基于 Python。要让 Ansible 在 MacOS 上工作，Conda 并不是必须要的，但是它确实让你管理 Python 版本和包依赖变得更加容易。这允许你在 MacOS 上使用升级的 Python 版本，并在你的系统中、Ansible 和其他编程项目之间保持 Python 包的依赖性相互独立。
在 MacOS 上安装 Ansible 还有其他方法。你可以使用 [Homebrew](https://brew.sh/)，但是如果你对 Python 开发（或 Ansible 开发）感兴趣，你可能会发现在一个独立 Python 虚拟环境中管理 Ansible 可以减少一些混乱。我觉得这更简单；与其试图将 Python 版本和依赖项加载到系统或 `/usr/local` 目录中 ，还不如使用 Conda 帮助我将 Ansible 所需的一切都收集到一个虚拟环境中，并将其与其他项目完全分开。
本文着重于使用 Conda 作为 Python 项目来管理 Ansible，以保持它的干净并与其他项目分开。请继续阅读，并了解如何安装 Conda、创建新的虚拟环境、安装 Ansible 并对其进行测试。
### 序幕
最近，我想学习 [Ansible](https://docs.ansible.com/?extIdCarryOver=true&sc_cid=701f2000001OH6uAAG)，所以我需要找到安装它的最佳方法。
我通常对在我的日常工作站上安装东西很谨慎。我尤其不喜欢对供应商的默认操作系统安装应用手动更新（这是我多年作为 Unix 系统管理的习惯）。我真的很想使用 Python 3.7，但是 MacOS 的 Python 包是旧的 2.7，我不会安装任何可能干扰核心 MacOS 系统的全局 Python 包。
所以，我使用本地 Ubuntu 18.04 虚拟机上开始了我的 Ansible 工作。这提供了真正意义上的的安全隔离，但我很快发现管理它是非常乏味的。所以我着手研究如何在本机 MacOS 上获得一个灵活但独立的 Ansible 系统。
由于 Ansible 基于 Python，Conda 似乎是理想的解决方案。
### 安装 Conda
Conda 是一个开源软件，它提供方便的包和环境管理功能。它可以帮助你管理多个版本的 Python、安装软件包依赖关系、执行升级和维护项目隔离。如果你手动管理 Python 虚拟环境，Conda 将有助于简化和管理你的工作。浏览 [Conda 文档](https://conda.io/projects/conda/en/latest/index.html)可以了解更多细节。
我选择了 [Miniconda](https://docs.conda.io/en/latest/miniconda.html) Python 3.7 安装在我的工作站中，因为我想要最新的 Python 版本。无论选择哪个版本，你都可以使用其他版本的 Python 安装新的虚拟环境。
要安装 Conda，请下载 PKG 格式的文件，进行通常的双击，并选择 “Install for me only” 选项。安装在我的系统上占用了大约 158 兆的空间。
安装完成后，调出一个终端来查看你有什么了。你应该看到：
* 在你的家目录中的 `miniconda3` 目录
* shell 提示符被修改为 `(base)`
* `.bash_profile` 文件更新了一些 Conda 特有的设置内容
现在基础已经安装好了，你有了第一个 Python 虚拟环境。运行 Python 版本检查可以证明这一点，你的 `PATH` 将指向新的位置：
```
(base) $ which python
/Users/jfarrell/miniconda3/bin/python
(base) $ python --version
Python 3.7.1
```
现在安装了 Conda，下一步是建立一个虚拟环境，然后安装 Ansible 并运行。
### 为 Ansible 创建虚拟环境
我想将 Ansible 与我的其他 Python 项目分开，所以我创建了一个新的虚拟环境并切换到它:
```
(base) $ conda create --name ansible-env --clone base
(base) $ conda activate ansible-env
(ansible-env) $ conda env list
```
第一个命令将 Conda 库克隆到一个名为 `ansible-env` 的新虚拟环境中。克隆引入了 Python 3.7 版本和一系列默认的 Python 模块，你可以根据需要添加、删除或升级这些模块。
第二个命令将 shell 上下文更改为这个新的环境。它为 Python 及其包含的模块设置了正确的路径。请注意，在 `conda activate ansible-env` 命令后，你的 shell 提示符会发生变化。
第三个命令不是必须的；它列出了安装了哪些 Python 模块及其版本和其他数据。
你可以随时使用 Conda 的 `activate` 命令切换到另一个虚拟环境。这将带你回到基本环境：`conda base`。
### 安装 Ansible
安装 Ansible 有多种方法，但是使用 Conda 可以将 Ansible 版本和所有需要的依赖项打包在一个地方。Conda 提供了灵活性，既可以将所有内容分开，又可以根据需要添加其他新环境（我将在后面演示）。
要安装 Ansible 的相对较新版本，请使用:
```
(base) $ conda activate ansible-env
(ansible-env) $ conda install -c conda-forge ansible
```
由于 Ansible 不是 Conda 默认通道的一部分，因此 `-c` 用于从备用通道搜索和安装。Ansible 现已安装到 `ansible-env` 虚拟环境中，可以使用了。
### 使用 Ansible
既然你已经安装了 Conda 虚拟环境，就可以使用它了。首先，确保要控制的节点已将工作站的 SSH 密钥安装到正确的用户帐户。
调出一个新的 shell 并运行一些基本的 Ansible 命令：
```
(base) $ conda activate ansible-env
(ansible-env) $ ansible --version
ansible 2.8.1
config file = None
configured module search path = ['/Users/jfarrell/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
ansible python module location = /Users/jfarrell/miniconda3/envs/ansibleTest/lib/python3.7/site-packages/ansible
executable location = /Users/jfarrell/miniconda3/envs/ansibleTest/bin/ansible
python version = 3.7.1 (default, Dec 14 2018, 13:28:58) [Clang 4.0.1 (tags/RELEASE_401/final)]
(ansible-env) $ ansible all -m ping -u ansible
192.168.99.200 | SUCCESS => {
"ansible_facts": {
"discovered_interpreter_python": "/usr/bin/python"
},
"changed": false,
"ping": "pong"
}
```
现在 Ansible 工作了，你可以在控制台中抽身，并从你的 MacOS 工作站中使用它们。
### 克隆新的 Ansible 进行 Ansible 开发
这部分完全是可选的；只有当你想要额外的虚拟环境来修改 Ansible 或者安全地使用有问题的 Python 模块时，才需要它。你可以通过以下方式将主 Ansible 环境克隆到开发副本中:
```
(ansible-env) $ conda create --name ansible-dev --clone ansible-env
(ansible-env) $ conda activte ansible-dev
(ansible-dev) $
```
### 需要注意的问题
偶尔你可能遇到使用 Conda 的麻烦。你通常可以通过以下方式删除不良环境：
```
$ conda activate base
$ conda remove --name ansible-dev --all
```
如果出现无法解决的错误，通常可以通过在 `~/miniconda3/envs` 中找到该环境并删除整个目录来直接删除环境。如果基础环境损坏了，你可以删除整个 `~/miniconda3`，然后从 PKG 文件中重新安装。只要确保保留 `~/miniconda3/envs` ，或使用 Conda 工具导出环境配置并在以后重新创建即可。
MacOS 上不包括 `sshpass` 程序。只有当你的 Ansible 工作要求你向 Ansible 提供 SSH 登录密码时，才需要它。你可以在 SourceForge 上找到当前的 [sshpass 源代码](https://sourceforge.net/projects/sshpass/)。
最后，基础的 Conda Python 模块列表可能缺少你工作所需的一些 Python 模块。如果你需要安装一个模块，首选命令是 `conda install package`，但是需要的话也可以使用 `pip`，Conda 会识别安装的模块。
### 结论
Ansible 是一个强大的自动化工具，值得我们去学习。Conda 是一个简单有效的 Python 虚拟环境管理工具。
在你的 MacOS 环境中保持软件安装分离是保持日常工作环境的稳定性和健全性的谨慎方法。Conda 尤其有助于升级你的 Python 版本，将 Ansible 从其他项目中分离出来，并安全地使用 Ansible。
---
via: <https://opensource.com/article/19/8/using-conda-ansible-administration-macos>
作者：[James Farrell](https://opensource.com/users/jamesf) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Richard Stallman 被迫辞去 FSF 主席的职务 | Abhishek Prakash | https://itsfoss.com/richard-stallman-controversy/ | Richard Stallman，自由软件基金会的创建者以及主席，已经辞去主席及董事会职务。 | /data/attachment/album/201909/19/093929osnl5488ns1x8ehb.png.thumb.jpg | /data/attachment/album/201909/19/093929osnl5488ns1x8ehb.png | true | false | true | lujun9972 | name1e5s | wxy | false | [
"FSF",
"RMS"
] | 观点 | {
"viewnum": 5680,
"commentnum": 6,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "171.210.230.137",
"message": "Hmmm",
"username": "来自四川成都的 Firefox 68.0|Android 用户",
"date": "2019-09-19T14:33:04"
},
{
"postip": "183.48.20.12",
"message": "无语了，激进主义真是太。。",
"username": "来自广东广州的 Chrome 45.0|Android 5.0 用户",
"date": "2019-09-20T00:23:37"
},
{
"postip": "116.27.4.158",
"message": "清除别人总是比建立一个胜于他的组织更容易。所以才有那么多人喜欢当政客",
"username": "来自广东茂名的 Chrome Mobile 57.0|Android 用户",
"date": "2019-09-20T03:21:35"
},
{
"postip": "59.173.55.202",
"message": "这就是当一个政客的后果，斯托曼同志早就不写代码，专门从事软件政治运动去了。很明确的说，那些女政客也不是什么好鸟，女权主义冲昏头脑，睚眦必报。",
"username": "来自湖北武汉的 Chrome Mobile 57.0|Android 8.1 用户",
"date": "2019-09-20T07:45:35"
},
{
"postip": "1.30.69.72",
"message": "我同意原文作者最后的观点，理查德·斯托曼不应该这样被对待",
"username": "qlk [Chrome 76.0|Windows 10]",
"date": "2019-09-20T21:25:39"
},
{
"postip": "101.93.81.21",
"message": "那个要把mit夷为平地的女人怎么就没事？难道不是恐怖主义分子吗？",
"username": "来自上海的 Firefox 69.0|Windows 10 用户",
"date": "2019-09-22T21:39:38"
}
] | [] | Richard Stallman，自由软件基金会的创建者以及主席，已经辞去主席及董事会职务。 | 2019-09-19T09:39:24 | 2019-09-19T09:39:24 | 11,358 | /article-11358-1.html |
>
> Richard Stallman，自由软件基金会的创建者以及主席，已经辞去主席及董事会职务。此前，因为 Stallman 对于爱泼斯坦事件中的受害者的观点，一小撮活动家以及媒体人发起了清除 Stallman 的运动。这份声明就是在这些活动后发生的。阅读全文以获得更多信息。
>
>
>
### Stallman 事件的背景概述
如果你不知道这次事件发生的前因后果，请看本段的详细信息。
[Richard Stallman](https://en.wikipedia.org/wiki/Richard_Stallman)，66岁，是就职于 [MIT](https://en.wikipedia.org/wiki/Massachusetts_Institute_of_Technology) 的计算机科学家。他最著名的成就就是在 1983 年发起了[自由软件运动](https://en.wikipedia.org/wiki/Free_software_movement)。他也开发了 GNU 项目旗下的部分软件，比如 GCC 和 Emacs。受自由软件运动影响选择使用 GPL 开源协议的项目不计其数。Linux 是其中最出名的项目之一。
[Jeffrey Epstein](https://en.wikipedia.org/wiki/Jeffrey_Epstein)（爱泼斯坦），美国亿万富翁，金融大佬。其涉嫌为社会上流精英提供性交易服务（其中有未成年少女）而被指控成为性犯罪者。在受审期间，爱泼斯坦在监狱中自杀身亡。
[Marvin Lee Minsky](https://en.wikipedia.org/wiki/Marvin_Minsky)，MIT 知名计算机科学家。他在 MIT 建立了人工智能实验室。2016 年，88 岁的 Minsky 逝世。在 Minsky 逝世后，一位名为 Misky 的爱泼斯坦事件受害者声称其在未成年时曾被“诱导”到爱泼斯坦的私人岛屿，与之发生性关系。
但是这些与 Richard Stallman 有什么关系？这要从 Stallman 发给 MIT 计算机科学与人工智能实验室（CSAIL）的学生以及附属机构就爱泼斯坦的捐款提出抗议的邮件列表的邮件说起。邮件全文翻译如下：
>
> 周五事件的公告对 Marvin Minsky 来说是不公正的。
>
>
> “已故的人工智能 ‘先锋’ Marvin Minsky （被控告侵害了爱泼斯坦事件的受害者之一[2]）”
>
>
> 不公正之处在于 “<ruby> 侵害 <rt> assulting </rt></ruby>” 这个用语。“<ruby> 性侵犯 <rt> sexual assault </rt></ruby>” 这个用语非常的糢糊，夸大了指控的严重性：宣称某人做了 X 但误导别人，让别人觉得这个人做了 Y，Y 远远比 X 严重。
>
>
> 上面引用的指控显然就是夸大。报导声称 Minksy 与爱泼斯坦的<ruby> 女眷 <rt> harem </rt></ruby>之一发生了性关系（详见 <https://www.theverge.com/2019/8/9/20798900/marvin-minsky-jeffrey-epstein-sex-trafficking-island-court-records-unsealed>）。我们假设这是真的（我找不到理由不相信）。
>
>
> “<ruby> 侵害 <rt> assulting </rt></ruby>” 这个词，意味着他使用了某种暴力。但那篇报道并没有提到这个，只说了他们发生了性关系。
>
>
> 我们可以想像很多种情况，但最合理的情况是，她在 Marvin 面前表现的像是完全自愿的。假设她是被爱泼斯坦强迫的，那爱泼斯坦有充足的理由让她对大多数人守口如瓶。
>
>
> 从各种的指控夸大事例中，我总结出，在指控时使用“<ruby> 性侵犯 <rt> sexual assault </rt></ruby>”是绝对错误的。
>
>
> 无论你想要批判什么行为，你都应该使用特定的词汇来描述，以此避免批判的本质的道德模糊性。
>
>
>
### “清除 Stallman” 的呼吁
‘爱泼斯坦’在美国是颇具争议的‘话题’。Stallman 对该敏感事件做出如此鲁莽的 “知识陈述” 不会有好结果，事实也是如此。
一位机器人学工程师从她的朋友那里收到了转发的邮件并发起了一个[清除 Stallman 的活动](https://medium.com/@selamie/remove-richard-stallman-fec6ec210794)。她要的不是澄清或者道歉，她只想要清除斯托曼，就算这意味着 “将 MIT 夷为平地” 也在所不惜。
>
> 是，至少 Stallman 没有被控强奸任何人。但这就是我们的最高标准吗？这所声望极高的学院坚持的标准就是这样的吗？如果这是麻省理工学院想要捍卫的、想要代表的标准的话，还不如把这破学校夷为平地…
>
>
> 如果有必要的话，就把所有人都清除出去，之后从废墟中建立出更好的秩序。
>
>
> —— Salem，发起“清除 Stallman“运动的机器人学专业学生
>
>
>
Salem 的声讨最初没有被主流媒体重视。但它还是被反对软件行业内的精英崇拜以及性别偏见的积极分子发现了。
>
> [#epstein](https://twitter.com/hashtag/epstein?src=hash&ref_src=twsrc%5Etfw) [#MIT](https://twitter.com/hashtag/MIT?src=hash&ref_src=twsrc%5Etfw) 嗨 记者没有回复我我很生气就自己写了这么个故事。作为 MIT 的校友我还真是高兴啊? <https://t.co/D4V5L5NzPA>
>
>
> — SZJG (@selamjie) [September 12, 2019](https://twitter.com/selamjie/status/1172244207978897408?ref_src=twsrc%5Etfw)
>
>
>
>
> 是不是对于性侵儿童的 “杰出混蛋” 我们也可以辩护说 “万一这是你情我愿的” <https://t.co/gSYPJ3WOfp>
>
>
> — Tracy Chou ??? (@triketora) [September 13, 2019](https://twitter.com/triketora/status/1172443389536555009?ref_src=twsrc%5Etfw)
>
>
>
>
> 多年来我就一直发推说 Richard RMS Stallman 这人有多恶心 —— 恋童癖、厌女症、还残障歧视
>
>
> 不可避免的是，每次我这样做，都会有老哥检查我的数据来源，然后说 “这都是几年前的事了！他现在变了！”
>
>
> 变个屁。 <https://t.co/ti2SrlKObp>
>
>
> — Sarah Mei (@sarahmei) [September 12, 2019](https://twitter.com/sarahmei/status/1172283772428906496?ref_src=twsrc%5Etfw)
>
>
>
下面是 Sage Sharp 开头的一篇关于 Stallman 的行为如何对科技人员产生负面影响的帖子：
>
> ?大家说下 Richard Stallman 对科技从业者的影响吧，尤其是女性。 [例如: 强奸、乱伦、残障歧视、性交易]
>
>
> [@fsf](https://twitter.com/fsf?ref_src=twsrc%5Etfw) 有必要永久禁止 Richard Stallman 担任自由软件基金会董事会主席。
>
>
> — Sage Sharp (@\_sagesharp\_) [September 16, 2019](https://twitter.com/_sagesharp_/status/1173637138413318144?ref_src=twsrc%5Etfw)
>
>
>
Stallman 一直以来也不是一个圣人。他粗暴，不合时宜、多年来一直在开带有性别歧视的笑话。你可以在[这里](https://geekfeminism.wikia.org/wiki/Richard_Stallman)和[这里](https://medium.com/@selamie/remove-richard-stallman-appendix-a-a7e41e784f88)读到。
很快这个消息就被 [The Vice](https://www.vice.com/en_us/article/9ke3ke/famed-computer-scientist-richard-stallman-described-epstein-victims-as-entirely-willing)、[每日野兽](https://www.thedailybeast.com/famed-mit-computer-scientist-richard-stallman-defends-epstein-victims-were-entirely-willing)，[未来主义](https://futurism.com/richard-stallman-epstein-scandal)等大媒体采访。他们把 Stallman 描绘成爱泼斯坦的捍卫者。在强烈的抗议声中，[GNOME 执行董事威胁要结束 GNOME 和 FSF 之间的关系](https://blog.halon.org.uk/2019/09/gnome-foundation-relationship-gnu-fsf/)。
最后，Stallman 先是从 MIT 辞职，现在又从 [自由软件基金会](https://www.fsf.org/news/richard-m-stallman-resigns) 辞职。
### 危险的特权？
我们见识到了，把一个人从他创建并为之工作了三十多年的组织中驱逐出去仅仅需要五天。这甚至还是在 Stallman 没有参与性交易丑闻的情况下。
其中一些 “活动家” 过去也曾[针对过 Linux 的作者 Linus Torvalds](https://www.newyorker.com/science/elements/after-years-of-abusive-e-mails-the-creator-of-linux-steps-aside)。Linux 基金会背后的管理层预见到了科技行业激进主义的增长趋势，因此他们制定了[适用于 Linux 内核开发的行为准则](https://itsfoss.com/linux-code-of-conduct/)并[强制 Torvalds 接受培训以改善他的行为](https://itsfoss.com/torvalds-takes-a-break-from-linux/)。如果他们没有采取纠正措施，可能 Torvalds 也已经被批倒批臭了。
忽视技术支持者的鲁莽行为和性别歧视是不可接受的，但是对于那些遇到不同意某种流行观点的人就进行声讨，施以私刑也是不道德的做法。我不支持 Stallman 和他过去的言论，但我也不能接受他以这种方式（被迫？）辞职。
Techrights 对此有一些有趣的评论，你可以在[这里](http://techrights.org/2019/09/15/media-attention-has-been-shifted/)和[这里](http://techrights.org/2019/09/16/stallman-removed/)看到。
*你对此事有何看法？请文明分享你的观点和意见。过激评论将不会公布。*
---
via: <https://itsfoss.com/richard-stallman-controversy/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[name1e5s](https://github.com/name1e5s) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Linux Mint 中更换主题 | It's Foss | https://itsfoss.com/install-themes-linux-mint/ | 一直以来，使用 Cinnamon 桌面环境的 Linux Mint 都是一种卓越的体验。这也是为何我喜爱 Linux Mint的主要原因之一。 | /data/attachment/album/201909/19/100317ixxp3y1l7lljl47a.jpg.thumb.jpg | /data/attachment/album/201909/19/100317ixxp3y1l7lljl47a.jpg | true | false | true | lujun9972 | qfzy1233 | wxy | false | [
"Cinnamon"
] | 桌面应用 | {
"viewnum": 9140,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 一直以来，使用 Cinnamon 桌面环境的 Linux Mint 都是一种卓越的体验。这也是为何我喜爱 Linux Mint的主要原因之一。 | 2019-09-19T10:03:56 | 2019-09-19T10:03:56 | 11,359 | /article-11359-1.html | 
一直以来，使用 Cinnamon 桌面环境的 Linux Mint 都是一种卓越的体验。这也是[为何我喜爱 Linux Mint](https://itsfoss.com/tiny-features-linux-mint-cinnamon/)的主要原因之一。
自从 Mint 的开发团队[开始更为严肃的对待设计](https://itsfoss.com/linux-mint-new-design/), “桌面主题” 应用便成为了更换新主题、图标、按钮样式、窗口边框以及鼠标指针的重要方式，当然你也可以直接通过它安装新的主题。感兴趣么？让我们开始吧。
### 如何在 Linux Mint 中更换主题
在菜单中搜索主题并打开主题应用。
在应用中有一个“添加/删除”按钮，非常简单吧。点击它，我们可以看到按流行程度排序的 Cinnamon Spices（Cinnamon 的官方插件库）的主题。
要安装主题，你所要做的就是点击你喜欢的主题，然后等待它下载。之后，主题将在应用第一页的“Desktop”选项中显示可用。只需双击已安装的主题之一就可以开始使用它。
下面是默认的 Linux Mint 外观：
这是在我更换主题之后：
所有的主题都可以在 Cinnamon Spices 网站上获得更多的信息和更大的截图，这样你就可以更好地了解你的系统的外观。
* [浏览 Cinnamon 主题](https://cinnamon-spices.linuxmint.com/themes)
### 在 Linux Mint 中安装第三方主题
>
> “我在另一个网站上看到了这个优异的主题，但 Cinnamon Spices 网站上没有……”
>
>
>
Cinnamon Spices 集成了许多优秀的主题，但你仍然会发现，你看到的主题并没有被 Cinnamon Spices 官方网站收录。
这时你可能会想：如果有别的办法就好了，对么？你可能会认为有（我的意思是……当然啦）。首先，我们可以在其他网站上找到一些很酷的主题。
我推荐你去 Cinnamon Look 浏览一下那儿的主题。如果你喜欢什么，就下载吧。
* [在 Cinnamon Look 中获取更多主题](https://www.cinnamon-look.org/)
下载了首选主题之后，你现在将得到一个压缩文件，其中包含安装所需的所有内容。提取它并保存到 `~/.themes`。迷糊么? `~` 代表了你的家目录的对应路径：`/home/{YOURUSER}/.themes`。
然后跳转到你的家目录。按 `Ctrl+H` 来[显示 Linux 中的隐藏文件](https://itsfoss.com/hide-folders-and-show-hidden-files-in-ubuntu-beginner-trick/)。如果没有看到 `.themes` 文件夹，创建一个新文件夹并命名为 `.themes`。记住，文件夹名称开头的点很重要。
将提取的主题文件夹从下载目录复制到你的家目录中的 `.themes` 文件夹中。
最后，在上面提到的应用中查找已安装的主题。
>
> 注记
>
>
> 请记住，主题必须是 Cinnamon 相对应的，即使它是一个从 GNOME 复刻的系统也不行，并不是所有的 GNOME 主题都适用于 Cinnamon。
>
>
>
改变主题是 Cinnamon 定制工作的一部分。你还可以[通过更改图标来更改 Linux Mint 的外观](https://itsfoss.com/install-icon-linux-mint/)。
我希望你现在已经知道如何在 Linux Mint 中更改主题了。快去选取你喜欢的主题吧。
---
via: <https://itsfoss.com/install-themes-linux-mint/>
作者：[It’s FOSS](https://itsfoss.com/author/itsfoss/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qfzy1233](https://github.com/qfzy1233) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何查看 Linux Mint 版本号和代号 | Sergiu | https://itsfoss.com/check-linux-mint-version/ | 了解 Linux Mint 版本号可以帮助你确定某个特定软件是否适用于你的系统，或者检查你的系统是否已达到使用寿命。 | /data/attachment/album/201909/19/103049kgb34obr4sggy06l.png.thumb.jpg | /data/attachment/album/201909/19/103049kgb34obr4sggy06l.png | true | false | true | lujun9972 | Morisun029 | wxy | false | [
"Mint",
"版本"
] | 技术 | {
"viewnum": 10508,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "101.224.73.173",
"message": "sudo apt install screenfetch -y<br />\r\nscreenfetch<br />\r\n<br />\r\n不用谢",
"username": "来自上海的 Chrome 77.0|Mac 10.14 用户",
"date": "2019-10-03T13:10:13"
}
] | [] | 了解 Linux Mint 版本号可以帮助你确定某个特定软件是否适用于你的系统，或者检查你的系统是否已达到使用寿命。 | 2019-09-19T10:30:48 | 2019-09-19T10:30:48 | 11,360 | /article-11360-1.html | Linux Mint 每两年发布一次主版本（如 Mint 19），每六个月左右发布一次次版本（如 Mint 19.1、19.2 等）。 你可以自己升级 Linux Mint 版本，而次版本也会自动更新。
在所有这些版本中，你可能想知道你正在使用的是哪个版本。了解 Linux Mint 版本号可以帮助你确定某个特定软件是否适用于你的系统，或者检查你的系统是否已达到使用寿命。
你可能需要 Linux Mint 版本号有多种原因，你也有多种方法可以获取此信息。让我向你展示用图形和命令行的方式获取 Mint 版本信息。
* [使用命令行查看 Linux Mint 版本信息](tmp.pL5Hg3N6Qt#terminal)
* [使用 GUI（图形用户界面）查看 Linux Mint 版本信息](tmp.pL5Hg3N6Qt#GUI)
### 使用终端查看 Linux Mint 版本号的方法
我将介绍几种使用非常简单的命令查看 Linux Mint 版本号和代号的方法。 你可以从 “菜单” 中打开终端，或按 `CTRL+ALT+T`（默认热键）打开。
本文中的最后两个命令还会输出你当前的 Linux Mint 版本所基于的 Ubuntu 版本。
#### 1、/etc/issue
从最简单的 CLI 方法开始，你可以打印出 `/etc/issue` 的内容来检查你的版本号和代号：
```
[email protected]:~$ cat /etc/issue
Linux Mint 19.2 Tina \n \l
```
#### 2、hostnamectl
这一个命令（`hostnamectl`）打印的信息几乎与“系统信息”中的信息相同。 你可以看到你的操作系统（带有版本号）以及你的内核版本。
#### 3、lsb\_release
`lsb_release` 是一个非常简单的 Linux 实用程序，用于查看有关你的发行版本的基本信息：
```
[email protected]:~$ lsb_release -a
No LSB modules are available.
Distributor ID: LinuxMint
Description: Linux Mint 19.2 Tina
Release: 19.2
Codename: tina
```
**注：** 我使用 `–a` 标签打印所有参数, 但你也可以使用 `-s` 作为简写格式，`-d` 用于描述等 （用 `man lsb_release` 查看所有选项）
#### 4、/etc/linuxmint/info
这不是命令，而是 Linux Mint 系统上的文件。只需使用 `cat` 命令将其内容打印到终端，然后查看你的版本号和代号。
#### 5、使用 /etc/os-release 命令也可以获取到 Ubuntu 代号
Linux Mint 基于 Ubuntu。每个 Linux Mint 版本都基于不同的 Ubuntu 版本。了解你的 Linux Mint 版本所基于的 Ubuntu 版本有助你在必须要使用 Ubuntu 版本号的情况下使用（比如你需要在 [Linux Mint 中安装最新的 Virtual Box](https://itsfoss.com/install-virtualbox-ubuntu/)添加仓库时）。
`os-release` 则是另一个类似于 `info` 的文件，向你展示 Linux Mint 所基于的 Ubuntu 版本代号。
#### 6、使用 /etc/upstream-release/lsb-release 只获取 Ubuntu 的基本信息
如果你只想要查看有关 Ubuntu 的基本信息，请输出 `/etc/upstream-release/lsb-release`：
```
[email protected]:~$ cat /etc/upstream-release/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=18.04
DISTRIB_CODENAME=bionic
DISTRIB_DESCRIPTION="Ubuntu 18.04 LTS"
```
特别提示：[你可以使用 uname 命令查看 Linux 内核版本](https://itsfoss.com/find-which-kernel-version-is-running-in-ubuntu/)。
```
[email protected]:~$ uname -r
4.15.0-54-generic
```
**注：** `-r` 代表 release，你可以使用 `man uname` 查看其他信息。
### 使用 GUI 查看 Linux Mint 版本信息
如果你对终端和命令行不满意，可以使用图形方法。如你所料，这个非常明了。
打开“菜单” (左下角)，然后转到“偏好设置 > 系统信息”：
或者，在菜单中，你可以搜索“System Info”：
在这里，你可以看到你的操作系统（包括版本号），内核和桌面环境的版本号：
### 总结
我已经介绍了一些不同的方法，用这些方法你可以快速查看你正在使用的 Linux Mint 的版本和代号（以及所基于的 Ubuntu 版本和内核）。我希望这个初学者教程对你有所帮助。请在评论中告诉我们你最喜欢哪个方法！
---
via: <https://itsfoss.com/check-linux-mint-version/>
作者：[Sergiu](https://itsfoss.com/author/sergiu/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Morisun029](https://github.com/Morisun029) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 Bash 脚本发送新用户帐户创建的邮件 | Magesh Maruthamuthu | https://www.2daygeek.com/linux-shell-script-to-monitor-user-creation-send-email/ | 出于某些原因，你可能需要跟踪 Linux 上的新用户创建信息。同时，你可能需要通过邮件发送详细信息。这或许是审计目标的一部分，或者安全团队出于跟踪目的可能希望对此进行监控。 | /data/attachment/album/201909/20/093308a615tcuiopctvp5t.jpg.thumb.jpg | /data/attachment/album/201909/20/093308a615tcuiopctvp5t.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"用户"
] | 技术 | {
"viewnum": 5173,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 出于某些原因，你可能需要跟踪 Linux 上的新用户创建信息。同时，你可能需要通过邮件发送详细信息。这或许是审计目标的一部分，或者安全团队出于跟踪目的可能希望对此进行监控。 | 2019-09-20T09:33:33 | 2019-09-20T09:33:33 | 11,362 | /article-11362-1.html | 
出于某些原因，你可能需要跟踪 Linux 上的新用户创建信息。同时，你可能需要通过邮件发送详细信息。这或许是审计目标的一部分，或者安全团队出于跟踪目的可能希望对此进行监控。
我们可以通过其他方式进行此操作，正如我们在上一篇文章中已经描述的那样。
* [在系统中创建新用户帐户时发送邮件的 Bash 脚本](https://www.2daygeek.com/linux-bash-script-to-monitor-user-creation-send-email/)
Linux 有许多开源监控工具可以使用。但我不认为他们有办法跟踪新用户创建过程，并在发生时提醒管理员。
那么我们怎样才能做到这一点？
我们可以编写自己的 Bash 脚本来实现这一目标。我们过去写过许多有用的 shell 脚本。如果你想了解，请进入下面的链接。
* [如何使用 shell 脚本自动化日常活动？](https://www.2daygeek.com/category/shell-script/)
### 这个脚本做了什么？
这将每天两次（一天的开始和结束）备份 `/etc/passwd` 文件，这将使你能够获取指定日期的新用户创建详细信息。
我们需要添加以下两个 cron 任务来复制 `/etc/passwd` 文件。
```
# crontab -e
1 0 * * * cp /etc/passwd /opt/scripts/passwd-start-$(date +"%Y-%m-%d")
59 23 * * * cp /etc/passwd /opt/scripts/passwd-end-$(date +"%Y-%m-%d")
```
它使用 `diff` 命令来检测文件之间的差异，如果发现与昨日有任何差异，脚本将向指定 email 发送新用户详细信息。
我们不用经常运行此脚本，因为用户创建不经常发生。但是，我们计划每天运行一次此脚本。
这样，你可以获得有关新用户创建的综合报告。
**注意：**我们在脚本中使用了我们的电子邮件地址进行演示。因此，我们要求你用自己的电子邮件地址。
```
# vi /opt/scripts/new-user-detail.sh
#!/bin/bash
mv /opt/scripts/passwd-start-$(date --date='yesterday' '+%Y-%m-%d') /opt/scripts/passwd-start
mv /opt/scripts/passwd-end-$(date --date='yesterday' '+%Y-%m-%d') /opt/scripts/passwd-end
ucount=$(diff /opt/scripts/passwd-start /opt/scripts/passwd-end | grep ">" | cut -d":" -f6 | cut -d"/" -f3 | wc -l)
if [ $ucount -gt 0 ]
then
SUBJECT="ATTENTION: New User Account is created on server : `date --date='yesterday' '+%b %e'`"
MESSAGE="/tmp/new-user-logs.txt"
TO="[email protected]"
echo "Hostname: `hostname`" >> $MESSAGE
echo -e "\n" >> $MESSAGE
echo "The New User Details are below." >> $MESSAGE
echo "+------------------------------+" >> $MESSAGE
diff /opt/scripts/passwd-start /opt/scripts/passwd-end | grep ">" | cut -d":" -f6 | cut -d"/" -f3 >> $MESSAGE
echo "+------------------------------+" >> $MESSAGE
mail -s "$SUBJECT" "$TO" < $MESSAGE
rm $MESSAGE
fi
```
给 `new-user-detail.sh` 文件添加可执行权限。
```
$ chmod +x /opt/scripts/new-user-detail.sh
```
最后添加一个 cron 任务来自动执行此操作。它在每天早上 7 点运行。
```
# crontab -e
0 7 * * * /bin/bash /opt/scripts/new-user.sh
```
**注意：**你会在每天早上 7 点都会收到一封关于昨日详情的邮件提醒。
**输出：**输出与下面的输出相同。
```
# cat /tmp/new-user-logs.txt
Hostname: CentOS.2daygeek.com
The New User Details are below.
+------------------------------+
tuser3
+------------------------------+
```
---
via: <https://www.2daygeek.com/linux-shell-script-to-monitor-user-creation-send-email/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
我们想换个徽标，大家看怎么样？ | 老王 | 为 Linux 中国设计制作一个新的徽标 | /data/attachment/album/201909/20/104249ei82ijm8umpxl2xv.jpg.thumb.jpg | /data/attachment/album/201909/20/104249ei82ijm8umpxl2xv.jpg | true | false | false | false | [
"logo"
] | 新闻 | {
"viewnum": 5440,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "60.28.138.62",
"message": "前面CN艺术化，后面Linux字母拼写",
"username": "来自天津的 Firefox 69.0|GNU/Linux 用户",
"date": "2019-09-20T12:04:54"
},
{
"postip": "183.48.22.205",
"message": "记得合并分支啊(◦˙▽˙◦)",
"username": "来自广东广州的 Chrome 68.0|Android 5.0 用户",
"date": "2019-10-06T23:18:37"
},
{
"postip": "60.12.240.218",
"message": "原来的 Logo 就很好看啊，新 logo 感觉含义太丰富了，但是整个图形体现不出来寓意，仅代表个人意见",
"username": "NebulaGraph [Chrome 77.0|Mac 10.13]",
"date": "2019-10-14T17:34:37"
}
] | [
{
"raid": 11407,
"displayorder": 0
},
{
"raid": 11488,
"displayorder": 0
}
] | 为 Linux 中国设计制作一个新的徽标 | 2019-09-20T10:48:34 | 2019-09-20T10:48:34 | 11,363 | /article-11363-1.html | 
几年前，当我和 DeadFire 想拿手里的域名 linux.cn 建立一个 Linux 方面的社区时，我们在想该叫个什么名字。讨论之下，就不揣浅陋叫了 “Linux 中国”这个名称，那个时候其实也没多想到会做多久、多大，却不料一直做了这么多年，仅仅是从 LCTT 算起，也有 6 年了。
有了网站（论坛），那就得有个徽标（Logo）啊。作为非艺术战线的工科男，我觉得简洁就好，于是就采用了“L”作为基本创意，请朋友（兴航）帮忙设计制作了徽标。后来虽然有过一些小的演变，不过基本上没有大的变化。
这是我们当前的徽标：
由于我的画蛇添足，这个徽标上加了很多自以为得意的小零件，但是在很多场合看起来并不清晰和大方，比如说，经常有合作伙伴和我要徽标放到展板和印刷品上去，其实往往显得比较另类——倒是比较好找到。
所以，换个徽标的想法我也是由来已久。于是，就有了这个新的徽标——不瞒你说，完全是我自己制作出来的（言外之意，专业性方面肯定不够了）。
这个徽标背后的思路是这样的：
* 灵感来自于俄罗斯方块游戏
* 配色的蓝绿：绿色一直是我们主题色，蓝色比较搭配，当然要是给它赋予专业、自由的寓意也无不可
* 主体是一个 4x4 的离散格子，其中由两个字母组成，分别“L”和“c”，这是我们的简写
* 更多的寓意——那就是在胡扯了
所以，大家觉得怎么样？欢迎给出意见和建议。
当然，这是我们抛出的砖头，也欢迎大家投稿——要不，我们做一次徽标征集活动？
### 徽标征集活动
活动目标：为 Linux 中国设计制作一个新的徽标
活动时间：2019 年 9 月 20 日 — 2019 年 10 月 31 日
时间节点：
* 2019 年 9 月 20 日 — 2019 年 10 月 20 日：徽标征集及点评
* 2019 年 9 月 21 日 — 2019 年 10 月 30 日：官方评选
* 2019 年 10 月 31 日 评选结果发布
参与方式：本活动完全在 GitHub 上进行，因此投稿、点评、建议都采用 GitHub 相应机制来完成。
仓库地址： <https://github.com/LCTT/logo>
* 投稿：通过 GitHub 的 PR 提交你的徽标设计展示图和设计说明。格式要求：
+ 每个投稿一个自行命名的文件夹，不当命名我们会予以修改。文件夹内包括：
+ 名为 logo.png 的 png 格式的徽标，尺寸为 500px X 500px，评选阶段无需投递原稿
+ 一个名为 README.md 的说明文件，说明创意构思
* 点评：对提交徽标的 PR 发表评论
* 建议：通过 GitHub 的<ruby> 议题 <rp> （ </rp> <rt> issue </rt> <rp> ） </rp></ruby>发起
最后，既然是征集评选活动，那就该有奖品：
* 一等奖（获选）一名，奖金 3000 元
* 二等奖两名，各奖 500 元
* 三等奖五名，各奖 100 元
此外，一等奖作品的作者需同样将该的完整版权授予 Linux 中国，但作品作者的相关信息会在 Linux 中国官方予以记录和致谢。
|
||||
虚拟机管理器（Virtual Machine Manager）简介 | Alan Formy-duval | https://opensource.com/article/19/9/introduction-virtual-machine-manager | virt-manager 为 Linux 虚拟化提供了全方位的选择。 | /data/attachment/album/201909/20/113434dxbbp3ttmxbhmnnm.jpg.thumb.jpg | /data/attachment/album/201909/20/113434dxbbp3ttmxbhmnnm.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"虚拟机"
] | 技术 | {
"viewnum": 12630,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | virt-manager 为 Linux 虚拟化提供了全方位的选择。 | 2019-09-20T11:34:00 | 2019-09-20T11:34:00 | 11,364 | /article-11364-1.html |
>
> virt-manager 为 Linux 虚拟化提供了全方位的选择。
>
>
>
在我关于 [GNOME Boxes](https://wiki.gnome.org/Apps/Boxes) 的[系列文章](https://opensource.com/sitewide-search?search_api_views_fulltext=GNOME%20Box)中，我已经解释了 Linux 用户如何能够在他们的桌面上快速启动虚拟机。当你只需要简单的配置时，Box 可以轻而易举地创建虚拟机。
但是，如果你需要在虚拟机中配置更多详细信息，那么你就需要一个工具，为磁盘、网卡（NIC）和其他硬件提供全面的选项。这时就需要 [虚拟机管理器（Virtual Machine Manager）](https://virt-manager.org/)（virt-manager）了。如果在应用菜单中没有看到它，你可以从包管理器或命令行安装它：
* 在 Fedora 上：`sudo dnf install virt-manager`
* 在 Ubuntu 上：`sudo apt install virt-manager`
安装完成后，你可以从应用菜单或在命令行中输入 `virt-manager` 启动。
为了演示如何使用 virt-manager 创建虚拟机，我将设置一个 Red Hat Enterprise Linux 8 虚拟机。
首先，单击 “<ruby> 文件 <rt> File </rt></ruby>” 然后点击 “<ruby> 新建虚拟机 <rt> New Virtual Machine </rt></ruby>”。Virt-manager 的开发者已经标记好了每一步（例如，“<ruby> 第 1 步，共 5 步 <rt> Step 1 of 5 </rt></ruby>”）来使其变得简单。单击 “<ruby> 本地安装介质 <rt> Local install media </rt></ruby>” 和 “<ruby> 下一步 <rt> Forward </rt></ruby>”。
在下个页面中，选择要安装的操作系统的 ISO 文件。（RHEL 8 镜像位于我的下载目录中。）Virt-manager 自动检测操作系统。
在步骤 3 中，你可以指定虚拟机的内存和 CPU。默认值为内存 1,024MB 和一个 CPU。
我想给 RHEL 充足的配置来运行，我使用的硬件配置也充足，所以我将它们（分别）增加到 4,096MB 和两个 CPU。
下一步为虚拟机配置存储。默认设置是 10GB 硬盘。（我保留此设置，但你可以根据需要进行调整。）你还可以选择现有磁盘镜像或在自定义位置创建一个磁盘镜像。
步骤 5 是命名虚拟机并单击“<ruby> 完成 <rt> Finish </rt></ruby>”。这相当于创建了一台虚拟机，也就是 GNOME Boxes 中的一个 Box。虽然技术上讲是最后一步，但你有几个选择（如下面的截图所示）。由于 virt-manager 的优点是能够自定义虚拟机，因此在单击“<ruby> 完成 <rt> Finish </rt></ruby>”之前，我将选中“<ruby> 在安装前定制配置 <rt> Customize configuration before install </rt></ruby>”的复选框。
因为我选择了自定义配置，virt-manager 打开了一个有一组设备和设置的页面。这里是重点！
这里你也可以命名该虚拟机。在左侧列表中，你可以查看各个方面的详细信息，例如 CPU、内存、磁盘、控制器和许多其他项目。例如，我可以单击 “CPU” 来验证我在步骤 3 中所做的更改。
我也可以确认我设置的内存量。
当虚拟机作为服务器运行时，我通常会禁用或删除声卡。为此，请选择 “<ruby> 声卡 <rt> Sound </rt></ruby>” 并单击 “<ruby> 移除 <rp> （ </rp> <rt> Remove </rt> <rp> ） </rp></ruby>” 或右键单击 “<ruby> 声卡 <rt> Sound </rt></ruby>” 并选择 “<ruby> 移除硬件 <rp> （ </rp> <rt> Remove Hardware </rt> <rp> ） </rp></ruby>”。
你还可以使用底部的 “<ruby> 添加硬件 <rp> （ </rp> <rt> Add Hardware </rt> <rp> ） </rp></ruby>” 按钮添加硬件。这会打开 “<ruby> 添加新的虚拟硬件 <rp> （ </rp> <rt> Add New Virtual Hardware </rt> <rp> ） </rp></ruby>” 页面，你可以在其中添加其他存储设备、内存、声卡等。这就像可以访问一个库存充足的（虚拟）计算机硬件仓库。
对 VM 配置感到满意后，单击 “<ruby> 开始安装 <rt> Begin Installation </rt></ruby>”，系统将启动并开始从 ISO 安装指定的操作系统。
完成后，它会重新启动，你的新虚拟机就可以使用了。
Virtual Machine Manager 是桌面 Linux 用户的强大工具。它是开源的，是专有和封闭虚拟化产品的绝佳替代品。
---
via: <https://opensource.com/article/19/9/introduction-virtual-machine-manager>
作者：[Alan Formy-Duval](https://opensource.com/users/alanfdoss) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Oracle 发布全球最快的数据库机器 Exadata X8M | Longjam Dineshwori | https://opensourceforu.com/2019/09/oracle-unleashes-worlds-fastest-database-machine-exadata-x8m/ | Exadata X8M 是第一台具有集成持久内存和 RoCE 的数据库机器。Oracle 还宣布推出 Oracle 零数据丢失恢复设备 X8M（ZDLRA）。 | /data/attachment/album/201909/20/191530qiyvvxl8qqcov8xq.jpg.thumb.jpg | /data/attachment/album/201909/20/191530qiyvvxl8qqcov8xq.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"数据库"
] | 新闻 | {
"viewnum": 4453,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Exadata X8M 是第一台具有集成持久内存和 RoCE 的数据库机器。Oracle 还宣布推出 Oracle 零数据丢失恢复设备 X8M（ZDLRA）。 | 2019-09-20T19:16:03 | 2019-09-20T19:16:03 | 11,366 | /article-11366-1.html |
>
> Exadata X8M 是第一台具有集成持久内存和 RoCE 的数据库机器。Oracle 还宣布推出 Oracle 零数据丢失恢复设备 X8M（ZDLRA）。
>
>
>
Oracle 发布了新的 Exadata 数据库机器 X8M，旨在为数据库基础架构市场树立新的标杆。
Exadata X8M 结合了英特尔 Optane DC 持久存储器和通过融合以太网（RoCE）的 100 千兆的远程直接内存访问（RDMA）来消除存储瓶颈，并显著提高性能，其适用于最苛刻的工作负载，如在线事务处理（OLTP）、分析、物联网、欺诈检测和高频交易。
“借助 Exadata X8M，我们可以提供内存级的性能，同时为 OLTP 和分析提供共享存储的所有优势，”Oracle 任务关键型数据库技术执行副总裁 Juan Loaiza 说。
“使用对共享持久存储器的直接数据库访问将响应时间减少一个数量级，可加速每个 OLTP 应用程序，它是需要实时访问大量数据的应用程序的游戏规则改变者，例如欺诈检测和个性化购物，”官方补充。
### 它有什么独特之处？
Oracle Exadata X8M 使用 RDMA 让数据库直接访问智能存储服务器中的持久内存，从而绕过整个操作系统、IO 和网络软件堆栈。这导致更低的延迟和更高的吞吐量。使用 RDMA 绕过软件堆栈还可以释放存储服务器上的 CPU 资源，以执行更多智能扫描查询来支持分析工作负载。
### 更少的存储瓶颈
“高性能 OLTP 应用需要高的每秒输入/输出操作（IOPS）和低延迟。直接数据库访问共享持久性内存可将SQL 读取的峰值性能提升至 1600 万 IOPS，比行业领先的 Exadata X8 高出 2.5 倍，“Oracle 在一份声明中表示。
此外，Exadata X8M 通过使远程 IO 延迟低于 19 微秒，大大减少了关键数据库 IO 的延迟 —— 这比 Exadata X8 快 10 倍以上。即使对于每秒需要数百万 IO 的工作负载，也可实现这些超低延迟。
### 比 AWS 和 Azure 更高效
该公司声称，与 Oracle 最快的 Amazon RDS 存储相比，Exadata X8M 的延迟降低了 50 倍，IOPS 提高了 200 倍，容量提高了 15 倍。
与 Azure SQL 数据库服务存储相比，Exadata X8M 的延迟降低了 100 倍，IOPS 提高了 150 倍，容量提高了 300 倍。
据 Oracle 称，单机架 Exadata X8M 可提供高达 2 倍的 OLTP 读取 IOPS，3 倍的吞吐量和比具有持久性内存的共享存储系统（如 Dell EMC PowerMax 8000 的单机架）低 5 倍的延迟。
“通过同时支持更快的 OLTP 查询和更高的分析工作负载吞吐量，Exadata X8M 是融合混合工作负载环境以降低 IT 成本和复杂性的理想平台，”该公司说。
### Oracle 零数据丢失恢复设备 X8
Oracle 当天还宣布推出 Oracle 零数据丢失恢复设备 X8M（ZDLRA），它使用新的 100Gb RoCE，用于计算和存储服务器之间的高吞吐量内部数据传输。
Exadata 和 ZDLRA 客户现在可以在 RoCE 或基于 InfiniBand 的工程系统之间进行选择，以在其架构部署中实现最佳灵活性。
---
via: <https://opensourceforu.com/2019/09/oracle-unleashes-worlds-fastest-database-machine-exadata-x8m/>
作者：[Longjam Dineshwori](https://opensourceforu.com/author/dineshwori-longjam/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 sed 命令查找和替换文件中的字符串的 16 个示例 | Magesh Maruthamuthu | https://www.2daygeek.com/linux-sed-to-find-and-replace-string-in-files/ | sed 命令主要用于替换一个文件中的文本。 | /data/attachment/album/201909/20/210723xf884pafyzf9zf4a.jpg.thumb.jpg | /data/attachment/album/201909/20/210723xf884pafyzf9zf4a.jpg | true | false | true | lujun9972 | asche910 | wxy | false | [
"sed"
] | 技术 | {
"viewnum": 71464,
"commentnum": 17,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "113.140.11.140",
"message": "怎么替换匹配到一行的一部分字符串？<br />\r\n比如 "key_buffer_size= 11M" 替换 11M 为 123kb ，前面的都不动。",
"username": "来自陕西西安的 Chrome 78.0|Windows 7 用户",
"date": "2019-11-18T19:44:43"
},
{
"postip": "113.140.11.140",
"message": "怎么替换匹配到一行的一部分字符串？<br />\r\n比如 "key_buffer_size= 11M" 替换 11M 为 123kb ，前面的都不动。",
"username": "来自陕西西安的 Chrome 78.0|Windows 7 用户",
"date": "2019-11-18T19:44:46"
},
{
"postip": "113.140.11.140",
"message": "怎么替换匹配到一行的一部分字符串？<br />\r\n比如 "key_buffer_size= 11M" 替换 11M 为 123kb ，前面的都不动。",
"username": "来自陕西西安的 Chrome 78.0|Windows 7 用户",
"date": "2019-11-18T19:44:47"
},
{
"postip": "113.140.11.140",
"message": "怎么替换匹配到一行的一部分字符串？<br />\r\n比如 "key_buffer_size= 11M" 替换 11M 为 123kb ，前面的都不动。",
"username": "来自陕西西安的 Chrome 78.0|Windows 7 用户",
"date": "2019-11-18T19:45:03"
},
{
"postip": "113.140.11.140",
"message": "怎么替换匹配到一行的一部分字符串？<br />\r\n比如 "key_buffer_size= 11M" 替换 11M 为 123kb ，前面的都不动。",
"username": "来自陕西西安的 Chrome 78.0|Windows 7 用户",
"date": "2019-11-18T19:45:04"
},
{
"postip": "113.140.11.140",
"message": "怎么替换匹配到一行的一部分字符串？<br />\r\n比如 "key_buffer_size= 11M" 替换 11M 为 123kb ，前面的都不动。",
"username": "来自陕西西安的 Chrome 78.0|Windows 7 用户",
"date": "2019-11-18T19:45:05"
},
{
"postip": "113.140.11.140",
"message": "怎么替换匹配到一行的一部分字符串？<br />\r\n比如 "key_buffer_size= 11M" 替换 11M 为 123kb ，前面的都不动。",
"username": "来自陕西西安的 Chrome 78.0|Windows 7 用户",
"date": "2019-11-18T19:45:05"
},
{
"postip": "111.206.145.10",
"message": "sed 'n s/11M/123kb/' 文件名 其中n是你这个的行数 应该就可以了",
"username": "来自北京的 Chrome 78.0|Windows 10 用户",
"date": "2019-11-28T11:47:01"
},
{
"postip": "121.32.54.208",
"message": "cool",
"username": "seqwait [Chrome 79.0|Mac 10.15]",
"date": "2020-01-02T18:24:04"
},
{
"postip": "182.46.2.34",
"message": "这也需要问吗？",
"username": "来自山东济南的 Firefox 80.0|Ubuntu 用户",
"date": "2020-09-29T12:43:18"
},
{
"postip": "27.17.177.142",
"message": "echo 'key_buffer_size=11M'|sed -r '/key_buffer_size=/ s/11M/123kb/g'",
"username": "来自湖北武汉的 Chrome 78.0|Windows 10 用户",
"date": "2020-12-12T23:10:07"
},
{
"postip": "119.28.77.28",
"message": "666",
"username": "来自119.28.77.28的 Chrome 87.0|Windows 10 用户",
"date": "2020-12-22T13:59:34"
},
{
"postip": "59.72.114.157",
"message": "文章写的详细易懂,帮助我学会了sed的简单应用，还不太费脑子。为作者和翻译点赞！",
"username": "来自吉林长春吉林大学的 Firefox 78.0|Windows 10 用户",
"date": "2021-03-12T09:21:16"
},
{
"postip": "183.3.155.199",
"message": "11M不是固定内容的时候呢 怎么替换？",
"username": "来自广东广州的 Chrome 100.0|Windows 10 用户",
"date": "2022-04-24T16:55:12"
},
{
"postip": "36.44.166.175",
"message": "s替换模式中 &指代匹配的字符串 sed 's/xxx/&123/' test.txt 会把xxx换为xxx123 利用这一点 匹配=后面的内容 然后进行替换",
"username": "来自陕西西安的 Chrome 101.0|Windows 10 用户",
"date": "2022-05-12T16:32:22"
},
{
"postip": "36.44.166.175",
"message": "sed -i 's/[0-9]\\+.*$/你想填入的内容/' test.txt",
"username": "来自陕西西安的 Chrome 101.0|Windows 10 用户",
"date": "2022-05-12T16:50:22"
},
{
"postip": "183.46.207.130",
"message": "sed -i "s/11M/123kb"",
"username": "来自广东汕头的 Chrome 55.0|Windows 10 用户",
"date": "2022-08-02T16:05:03"
}
] | [] | sed 命令主要用于替换一个文件中的文本。 | 2019-09-20T21:07:35 | 2019-09-20T21:07:35 | 11,367 | /article-11367-1.html | 
当你在使用文本文件时，很可能需要查找和替换文件中的字符串。`sed` 命令主要用于替换一个文件中的文本。在 Linux 中这可以通过使用 `sed` 命令和 `awk` 命令来完成。
在本教程中，我们将告诉你使用 `sed` 命令如何做到这一点，然后讨论讨论 `awk` 命令相关的。
### sed 命令是什么
`sed` 命令表示 Stream Editor（流编辑器），用来在 Linux 上执行基本的文本操作。它可以执行各种功能，如搜索、查找、修改、插入或删除文件。
此外，它也可以执行复杂的正则表达式匹配。
它可用于以下目的：
* 查找和替换匹配给定的格式的内容。
* 在指定行查找和替换匹配给定的格式的内容。
* 在所有行查找和替换匹配给定的格式的内容。
* 搜索并同时替换两种不同的模式。
本文列出的十五个例子可以帮助你掌握 `sed` 命令。
如果要使用 `sed` 命令删除文件中的行，去下面的文章。
注意：由于这是一篇演示文章，我们使用不带 `-i` 选项的 `sed` 命令，该选项会在 Linux 终端中删除行并打印文件内容。
但是，在实际环境中如果你想删除源文件中的行，使用带 `-i` 选项的 `sed` 命令。
常见的 `sed` 替换字符串的语法。
```
sed -i 's/Search_String/Replacement_String/g' Input_File
```
首先我们需要了解 `sed` 语法来做到这一点。请参阅有关的细节。
* `sed`：这是一个 Linux 命令。
* `-i`：这是 `sed` 命令的一个选项，它有什么作用？默认情况下，`sed` 打印结果到标准输出。当你使用 `sed` 添加这个选项时，那么它会在适当的位置修改文件。当你添加一个后缀（比如，`-i.bak`）时，就会创建原始文件的备份。
* `s`：字母 `s` 是一个替换命令。
* `Search_String`：搜索一个给定的字符串或正则表达式。
* `Replacement_String`：替换的字符串。
* `g`：全局替换标志。默认情况下，`sed` 命令替换每一行第一次出现的模式，它不会替换行中的其他的匹配结果。但是，提供了该替换标志时，所有匹配都将被替换。
* `/`：分界符。
* `Input_File`：要执行操作的文件名。
让我们来看看文件中用sed命令来搜索和转换文本的一些常用例子。
我们已经创建了用于演示的以下文件。
```
# cat sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 linuxunix UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 1) 如何查找和替换一行中“第一次”模式匹配
下面的 `sed` 命令用 `linux` 替换文件中的 `unix`。这仅仅改变了每一行模式的第一个实例。
```
# sed 's/unix/linux/' sed-test.txt
1 Unix linux unix 23
2 linux Linux 34
3 linuxlinux UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 2) 如何查找和替换每一行中“第 N 次”出现的模式
在行中使用`/1`、`/2`……`/n` 等标志来代替相应的匹配。
下面的 `sed` 命令在一行中用 `linux` 来替换 `unix` 模式的第二个实例。
```
# sed 's/unix/linux/2' sed-test.txt
1 Unix unix linux 23
2 linux Linux 34
3 linuxunix UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 3) 如何搜索和替换一行中所有的模式实例
下面的 `sed` 命令用 `linux` 替换 `unix` 格式的所有实例，因为 `g` 是一个全局替换标志。
```
# sed 's/unix/linux/g' sed-test.txt
1 Unix linux linux 23
2 linux Linux 34
3 linuxlinux UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 4) 如何查找和替换一行中从“第 N 个”开始的所有匹配的模式实例
下面的 `sed` 命令在一行中替换从模式的“第 N 个”开始的匹配实例。
```
# sed 's/unix/linux/2g' sed-test.txt
1 Unix unix linux 23
2 linux Linux 34
3 linuxunix UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 5) 在特定的行号搜索和替换模式
你可以替换特定行号中的字符串。下面的 `sed` 命令用 `linux` 仅替换第三行的 `unix` 模式。
```
# sed '3 s/unix/linux/' sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 linuxlinux UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 6) 在特定范围行号间搜索和替换模式
你可以指定行号的范围，以替换字符串。
下面的 `sed` 命令在 1 到 3 行间用 `linux` 替换 `Unix` 模式。
```
# sed '1,3 s/unix/linux/' sed-test.txt
1 Unix linux unix 23
2 linux Linux 34
3 linuxlinux UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 7) 如何查找和修改最后一行的模式
下面的 sed 命令允许你只在最后一行替换匹配的字符串。
下面的 `sed` 命令只在最后一行用 `Unix` 替换 `Linux` 模式。
```
# sed '$ s/Linux/Unix/' sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 linuxunix UnixLinux
linux /bin/bash CentOS Linux OS
Unix is free and opensource operating system
```
### 8) 在一行中如何只查找和替换正确的模式匹配
你可能已经注意到，子串 `linuxunix` 被替换为在第 6 个示例中的 `linuxlinux`。如果你只想更改正确的匹配词，在搜索串的两端用这个边界符 `\b`。
```
# sed '1,3 s/\bunix\b/linux/' sed-test.txt
1 Unix linux unix 23
2 linux Linux 34
3 linuxunix UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 9) 如何以不区分大小写来搜索与替换模式
大家都知道，Linux 是区分大小写的。为了与不区分大小写的模式匹配，使用 `I` 标志。
```
# sed 's/unix/linux/gI' sed-test.txt
1 linux linux linux 23
2 linux Linux 34
3 linuxlinux linuxLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 10) 如何查找和替换包含分隔符的字符串
当你搜索和替换含分隔符的字符串时，我们需要用反斜杠 `\` 来取消转义。
在这个例子中，我们将用 `/usr/bin/fish` 来替换 `/bin/bash`。
```
# sed 's/\/bin\/bash/\/usr\/bin\/fish/g' sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 linuxunix UnixLinux
linux /usr/bin/fish CentOS Linux OS
Linux is free and opensource operating system
```
上述 `sed` 命令按预期工作，但它看起来来很糟糕。 为了简化，大部分的人会用竖线 `|` 作为正则表达式的定位符。 所以，我建议你用它。
```
# sed 's|/bin/bash|/usr/bin/fish/|g' sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 linuxunix UnixLinux
linux /usr/bin/fish/ CentOS Linux OS
Linux is free and opensource operating system
```
### 11) 如何以给定的模式来查找和替换数字
类似地，数字可以用模式来代替。下面的 `sed` 命令以 `[0-9]` 替换所有数字为 `number`。
```
# sed 's/[0-9]/number/g' sed-test.txt
number Unix unix unix numbernumber
number linux Linux numbernumber
number linuxunix UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 12) 如何用模式仅查找和替换两个数字
如果你想用模式来代替两位数字，使用下面的 `sed` 命令。
```
# sed 's/\b[0-9]\{2\}\b/number/g' sed-test.txt
1 Unix unix unix number
2 linux Linux number
3 linuxunix UnixLinux
linux /bin/bash CentOS Linux OS
Linux is free and opensource operating system
```
### 13) 如何用 sed 命令仅打印被替换的行
如果你想显示仅更改的行，使用下面的 `sed` 命令。
* `p` - 它在终端上输出替换的行两次。
* `-n` - 它抑制由 `p` 标志所产生的重复行。
```
# sed -n 's/Unix/Linux/p' sed-test.txt
1 Linux unix unix 23
3 linuxunix LinuxLinux
```
### 14) 如何同时运行多个 sed 命令
以下 `sed` 命令同时检测和置换两个不同的模式。
下面的 `sed` 命令搜索 `linuxunix` 和 `CentOS` 模式，用 `LINUXUNIX` 和 `RHEL8` 一次性更换它们。
```
# sed -e 's/linuxunix/LINUXUNIX/g' -e 's/CentOS/RHEL8/g' sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 LINUXUNIX UnixLinux
linux /bin/bash RHEL8 Linux OS
Linux is free and opensource operating system
```
下面的 `sed` 命令搜索替换两个不同的模式，并一次性替换为一个字符串。
以下 `sed` 的命令搜索 `linuxunix` 和 `CentOS` 模式，用 `Fedora30` 替换它们。
```
# sed -e 's/\(linuxunix\|CentOS\)/Fedora30/g' sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 Fedora30 UnixLinux
linux /bin/bash Fedora30 Linux OS
Linux is free and opensource operating system
```
### 15) 如果给定的模式匹配，如何查找和替换整个行
如果模式匹配，可以使用 `sed` 命令用新行来代替整行。这可以通过使用 `c` 标志来完成。
```
# sed '/OS/ c\
New Line
' sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 linuxunix UnixLinux
New Line
Linux is free and opensource operating system
```
### 16) 如何搜索和替换相匹配的模式行
在 `sed` 命令中你可以为行指定适合的模式。在匹配该模式的情况下，`sed` 命令搜索要被替换的字符串。
下面的 `sed` 命令首先查找具有 `OS` 模式的行，然后用 `ArchLinux` 替换单词 `Linux`。
```
# sed '/OS/ s/Linux/ArchLinux/' sed-test.txt
1 Unix unix unix 23
2 linux Linux 34
3 linuxunix UnixLinux
linux /bin/bash CentOS ArchLinux OS
Linux is free and opensource operating system
```
---
via: <https://www.2daygeek.com/linux-sed-to-find-and-replace-string-in-files/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Asche910](https://github.com/asche910) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 内核的五大创新 | Seth Kenlon | https://opensource.com/article/19/8/linux-kernel-top-5-innovations | 想知道什么是 Linux 内核上真正的（不是那种时髦的）创新吗？ | /data/attachment/album/201909/21/093858no01oh78v111r3zt.jpg.thumb.jpg | /data/attachment/album/201909/21/093858no01oh78v111r3zt.jpg | true | false | true | lujun9972 | heguangzhi | wxy | false | [
"Linux"
] | 观点 | {
"viewnum": 6932,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 想知道什么是 Linux 内核上真正的（不是那种时髦的）创新吗？ | 2019-09-21T09:39:15 | 2019-09-21T09:39:15 | 11,368 | /article-11368-1.html |
>
> 想知道什么是 Linux 内核上真正的（不是那种时髦的）创新吗？
>
>
>
在科技行业，*创新*这个词几乎和*革命*一样到处泛滥，所以很难将那些夸张的东西与真正令人振奋的东西区分开来。Linux 内核被称为创新，但它又被称为现代计算中最大的奇迹，一个微观世界中的庞然大物。
撇开营销和模式不谈，Linux 可以说是开源世界中最受欢迎的内核，它在近 30 年的生命时光当中引入了一些真正的规则改变者。
### Cgroups（2.6.24）
早在 2007 年，Paul Menage 和 Rohit Seth 就在内核中添加了深奥的[控制组（cgroups）](https://en.wikipedia.org/wiki/Cgroups)功能（cgroups 的当前实现是由 Tejun Heo 重写的）。这种新技术最初被用作一种方法，从本质上来说，是为了确保一组特定任务的服务质量。
例如，你可以为与你的 WEB 服务相关联的所有任务创建一个控制组定义（cgroup），为例行备份创建另一个 cgroup ，再为一般操作系统需求创建另一个 cgroup。然后，你可以控制每个组的资源百分比，这样你的操作系统和 WEB 服务就可以获得大部分系统资源，而你的备份进程可以访问剩余的资源。
然而，cgroups 如今变得这么著名是因其作为驱动云技术的角色：容器。事实上，cgroups 最初被命名为[进程容器](https://lkml.org/lkml/2006/10/20/251)。当它们被 [LXC](https://linuxcontainers.org)、[CoreOS](https://coreos.com/) 和 Docker 等项目采用时，这并不奇怪。
就像闸门打开后一样，“容器” 一词就像成为了 Linux 的同义词一样，微服务风格的基于云的“应用”概念很快成为了规范。如今，已经很难摆脱 cgroups 了，它们是如此普遍。每一个大规模的基础设施（如果你运行 Linux 的话，可能还有你的笔记本电脑）都以一种合理的方式使用了 cgroups，这使得你的计算体验比以往任何时候都更加易于管理和灵活。
例如，你可能已经在电脑上安装了 [Flathub](http://flathub.org) 或 [Flatpak](http://flatpak.org)，或者你已经在工作中使用 [Kubernetes](http://kubernetes.io) 和/或 [OpenShift](https://www.redhat.com/sysadmin/learn-openshift-minishift)。不管怎样，如果“容器”这个术语对你来说仍然模糊不清，则可以 [通过 Linux 容器从背后](https://opensource.com/article/18/11/behind-scenes-linux-containers)获得对容器的实际理解。
### LKMM（4.17）
2018 年，Jade Alglave、Alan Stern、Andrea Parri、Luc Maranget、Paul McKenney 以及其他几个人的辛勤工作的成果被合并到主线 Linux 内核中，以提供正式的内存模型。Linux 内核内存[一致性]模型（LKMM）子系统是一套描述 Linux 内存一致性模型的工具，同时也产生用于测试的用例（特别命名为 klitmus）。
随着系统在物理设计上变得越来越复杂（增加了更多的中央处理器内核，高速缓存和内存增长，等等)，它们就越难知道哪个中央处理器需要哪个地址空间，以及何时需要。例如，如果 CPU0 需要将数据写入内存中的共享变量，并且 CPU1 需要读取该值，那么 CPU0 必须在 CPU1 尝试读取之前写入。类似地，如果值是以一种顺序方式写入内存的，那么期望它们也以同样的顺序被读取，而不管哪个或哪些 CPU 正在读取。
即使在单个处理器上，内存管理也需要特定的任务顺序。像 `x = y` 这样的简单操作需要处理器从内存中加载 `y` 的值，然后将该值存储在 `x` 中。在处理器从内存中读取值之前，是不能将存储在 `y` 中的值放入 `x` 变量的。此外还有地址依赖：`x[n] = 6` 要求在处理器能够存储值 `6` 之前加载 `n`。
LKMM 可以帮助识别和跟踪代码中的这些内存模式。它部分是通过一个名为 `herd` 的工具来实现的，该工具（以逻辑公式的形式）定义了内存模型施加的约束，然后列举了与这些约束一致性的所有可能的结果。
### 低延迟补丁（2.6.38）
很久以前，在 2011 年之前，如果你想[在 Linux 上进行多媒体工作](http://slackermedia.info)，你必须得有一个低延迟内核。这主要适用于[录音](https://opensource.com/article/17/6/qtractor-audio)时添加了许多实时效果（如对着麦克风唱歌和添加混音，以及在耳机中无延迟地听到你的声音）。有些发行版，如 [Ubuntu Studio](http://ubuntustudio.org)，可靠地提供了这样一个内核，所以实际上这没有什么障碍，这只不过是当艺术家选择发行版时的一个重要提醒。
然而，如果你没有使用 Ubuntu Studio，或者你需要在你的发行版提供之前更新你的内核，你必须跳转到 rt-patches 网页，下载内核补丁，将它们应用到你的内核源代码，编译，然后手动安装。
后来，随着内核版本 2.6.38 的发布，这个过程结束了。Linux 内核突然像变魔术一样默认内置了低延迟代码（根据基准测试，延迟至少降低了 10 倍)。不再需要下载补丁，不用编译。一切都很顺利，这都是因为 Mike Galbraith 编写了一个 200 行的小补丁。
对于全世界的开源多媒体艺术家来说，这是一个规则改变者。从 2011 年开始事情变得如此美好，到 2016 年我自己做了一个挑战，[在树莓派 v1（型号 B）上建造一个数字音频工作站（DAW）](https://opensource.com/life/16/3/make-music-raspberry-pi-milkytracker)，结果发现它运行得出奇地好。
### RCU（2.5）
RCU，即<ruby> 读-拷贝-更新 <rt> Read-Copy-Update </rt></ruby>，是计算机科学中定义的一个系统，它允许多个处理器线程从共享内存中读取数据。它通过延迟更新但也将它们标记为已更新来做到这一点，以确保数据读取为最新内容。实际上，这意味着读取与更新同时发生。
典型的 RCU 循环有点像这样：
1. 删除指向数据的指针，以防止其他读操作引用它。
2. 等待读操作完成它们的关键处理。
3. 回收内存空间。
将更新阶段划分为删除和回收阶段意味着更新程序会立即执行删除，同时推迟回收直到所有活动读取完成（通过阻止它们或注册一个回调以便在完成时调用）。
虽然 RCU 的概念不是为 Linux 内核发明的，但它在 Linux 中的实现是该技术的一个定义性的例子。
### 合作（0.01）
对于 Linux 内核创新的问题的最终答案永远是协作。你可以说这是一个好时机，也可以称之为技术优势，称之为黑客能力，或者仅仅称之为开源，但 Linux 内核及其支持的许多项目是协作与合作的光辉范例。
它远远超出了内核范畴。各行各业的人都对开源做出了贡献，可以说都是因为 Linux 内核。Linux 曾经是，现在仍然是[自由软件](http://fsf.org)的主要力量，激励人们把他们的代码、艺术、想法或者仅仅是他们自己带到一个全球化的、有生产力的、多样化的人类社区中。
### 你最喜欢的创新是什么？
这个列表偏向于我自己的兴趣：容器、非统一内存访问（NUMA）和多媒体。无疑，列表中肯定缺少你最喜欢的内核创新。在评论中告诉我。
---
via: <https://opensource.com/article/19/8/linux-kernel-top-5-innovations>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Oracle Autonomous Linux：用于云计算的自我更新、自我修补的 Linux 发行版 | John Paul | https://itsfoss.com/oracle-autonomous-linux/ | 自动化是 IT 行业的增长趋势，其目的是消除重复任务中的手动干扰。 | /data/attachment/album/201909/22/093857pn9k69e9fn5x9969.png.thumb.jpg | /data/attachment/album/201909/22/093857pn9k69e9fn5x9969.png | true | false | true | lujun9972 | wxy | wxy | false | [
"Oracle"
] | 新闻 | {
"viewnum": 3628,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "36.23.214.68",
"message": "好吧，我们离天网更近了一步。",
"username": "来自浙江的 Firefox 69.0|Windows 10 用户",
"date": "2019-09-22T15:37:53"
}
] | [] | 自动化是 IT 行业的增长趋势，其目的是消除重复任务中的手动干扰。 | 2019-09-22T09:38:52 | 2019-09-22T09:38:52 | 11,370 | /article-11370-1.html | 自动化是 IT 行业的增长趋势，其目的是消除重复任务中的手动干扰。Oracle 通过推出 Oracle Autonomous Linux 向自动化世界迈出了又一步，这无疑将使 IoT 和云计算行业受益。
### Oracle Autonomous Linux：减少人工干扰，增多自动化
周一，Oracle 联合创始人<ruby> 拉里·埃里森 <rt> Larry Ellison </rt></ruby>参加了在旧金山举行的Oracle OpenWorld 全球大会。[他宣布了](https://www.zdnet.com/article/oracle-announces-oracle-autonomous-linux/)一个新产品：世界上第一个自治 Linux。这是 Oracle 向第二代云迈进的第二步。第一步是两年前发布的 [Autonomous Database](https://www.oracle.com/in/database/what-is-autonomous-database.html)。
Oracle Autonomous Linux 的最大特性是降低了维护成本。根据 [Oracle 网站](https://www.oracle.com/corporate/pressrelease/oow19-oracle-autonomous-linux-091619.html) 所述，Autonomous Linux “使用先进的机器学习和自治功能来提供前所未有的成本节省、安全性和可用性，并释放关键的 IT 资源来应对更多的战略计划”。
Autonomous Linux 可以无需人工干预就安装更新和补丁。这些自动更新包括 “Linux 内核和关键用户空间库”的补丁。“不需要停机，而且可以免受外部攻击和内部恶意用户的攻击。”它们也可以在系统运行时进行，以减少停机时间。Autonomous Linux 还会自动处理伸缩，以确保满足所有计算需求。
埃里森强调了新的自治系统将如何提高安全性。他特别提到了 [Capitol One 数据泄露](https://www.zdnet.com/article/100-million-americans-and-6-million-canadians-caught-up-in-capital-one-breach/)是由于配置错误而发生的。他说：“一个防止数据被盗的简单规则：将数据放入自治系统。没有人为错误，没有数据丢失。 那是我们与 AWS 之间的最大区别。”
有趣的是，Oracle 还瞄准了这一新产品以与 IBM 竞争。埃里森说：“如果你付钱给 IBM，可以停了。”所有 Red Hat 应用程序都应该能够在 Autonomous Linux 上运行而无需修改。有趣的是，Oracle Linux 是从 Red Hat Enterprise Linux 的源代码中[构建](https://distrowatch.com/table.php?distribution=oracle)的。
看起来，Oracle Autonomous Linux 不会用于企业市场以外。
### 关于 Oracle Autonomous Linux 的思考
Oracle 是云服务市场的重要参与者。这种新的 Linux 产品将使其能够与 IBM 竞争。让人感兴趣的是 IBM 的反应会是如何，特别是当他们有来自 Red Hat 的新一批开源智能软件。
如果你看一下市场数字，那么对于 IBM 或 Oracle 来说情况都不好。大多数云业务由 [Amazon Web Services、Microsoft Azure 和 Google Cloud Platform](https://www.zdnet.com/article/top-cloud-providers-2019-aws-microsoft-azure-google-cloud-ibm-makes-hybrid-move-salesforce-dominates-saas/) 所占据。IBM 和 Oracle 落后于他们。[IBM 收购 Red Hat](https://itsfoss.com/ibm-red-hat-acquisition/) 试图获得发展。这项新的自主云计划是 Oracle 争取统治地位（或至少试图获得更大的市场份额）的举动。让人感兴趣的是，到底有多少公司因为购买了 Oracle 的系统而在互联网的狂野西部变得更加安全？
我必须简单提一下：当我第一次阅读该公告时，我的第一反应就是“好吧，我们离天网更近了一步。”如果我们技术性地考虑一下，我们就像是要进入了机器人末日。如果你打算帮我，我计划去购买一些罐头食品。
你对 Oracle 的新产品感兴趣吗？你会帮助他们赢得云战争吗？在下面的评论中让我们知道。
如果你觉得这篇文章有趣，请花一点时间在社交媒体、Hacker News 或 [Reddit](https://reddit.com/r/linuxusersgroup) 上分享。
---
via: <https://itsfoss.com/oracle-autonomous-linux/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Fedora 上建立一个 TFTP 服务器 | Curt Warfield | https://fedoramagazine.org/how-to-set-up-a-tftp-server-on-fedora/ | TFTP 即简单文本传输协议，允许用户通过 UDP 协议在系统之间传输文件。 | /data/attachment/album/201909/22/111433ar23l5gp2igsz2d3.jpg.thumb.jpg | /data/attachment/album/201909/22/111433ar23l5gp2igsz2d3.jpg | true | false | true | lujun9972 | amwps290 | wxy | false | [
"tftp"
] | 技术 | {
"viewnum": 3800,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | TFTP 即简单文本传输协议，允许用户通过 UDP 协议在系统之间传输文件。 | 2019-09-22T11:14:41 | 2019-09-22T11:14:41 | 11,371 | /article-11371-1.html | 
TFTP 即<ruby> 简单文本传输协议 <rt> Trivial File Transfer Protocol </rt></ruby>，允许用户通过 [UDP](https://en.wikipedia.org/wiki/User_Datagram_Protocol) 协议在系统之间传输文件。默认情况下，协议使用的是 UDP 的 69 号端口。TFTP 协议广泛用于无盘设备的远程启动。因此，在你的本地网络建立一个 TFTP 服务器，这样你就可以对 [安装好的 Fedora](https://docs.fedoraproject.org/en-US/fedora/f30/install-guide/advanced/Network_based_Installations/) 和其他无盘设备做一些操作，这将非常有趣。
TFTP 仅仅能够从远端系统读取数据或者向远端系统写入数据，而没有列出远端服务器上文件的能力。它也没提供用户身份验证。由于安全隐患和缺乏高级功能，TFTP 通常仅用于局域网内部（LAN）。
### 安装 TFTP 服务器
首先你要做的事就是安装 TFTP 客户端和 TFTP 服务器：
```
dnf install tftp-server tftp -y
```
上述的这条命令会在 `/usr/lib/systemd/system` 目录下为 [systemd](https://fedoramagazine.org/systemd-getting-a-grip-on-units/) 创建 `tftp.service` 和 `tftp.socket` 文件。
```
/usr/lib/systemd/system/tftp.service
/usr/lib/systemd/system/tftp.socket
```
接下来，将这两个文件复制到 `/etc/systemd/system` 目录下，并重新命名。
```
cp /usr/lib/systemd/system/tftp.service /etc/systemd/system/tftp-server.service
cp /usr/lib/systemd/system/tftp.socket /etc/systemd/system/tftp-server.socket
```
### 修改文件
当你把这些文件复制和重命名后，你就可以去添加一些额外的参数，下面是 `tftp-server.service` 刚开始的样子：
```
[Unit]
Description=Tftp Server
Requires=tftp.socket
Documentation=man:in.tftpd
[Service]
ExecStart=/usr/sbin/in.tftpd -s /var/lib/tftpboot
StandardInput=socket
[Install]
Also=tftp.socket
```
在 `[Unit]` 部分添加如下内容：
```
Requires=tftp-server.socket
```
修改 `[ExecStart]` 行：
```
ExecStart=/usr/sbin/in.tftpd -c -p -s /var/lib/tftpboot
```
下面是这些选项的意思：
* `-c` 选项允许创建新的文件
* `-p` 选项用于指明在正常系统提供的权限检查之上没有其他额外的权限检查
* `-s` 建议使用该选项以确保安全性以及与某些引导 ROM 的兼容性，这些引导 ROM 在其请求中不容易包含目录名。
默认的上传和下载位置位于 `/var/lib/tftpboot`。
下一步，修改 `[Install]` 部分的内容
```
[Install]
WantedBy=multi-user.target
Also=tftp-server.socket
```
不要忘记保存你的修改。
下面是 `/etc/systemd/system/tftp-server.service` 文件的完整内容：
```
[Unit]
Description=Tftp Server
Requires=tftp-server.socket
Documentation=man:in.tftpd
[Service]
ExecStart=/usr/sbin/in.tftpd -c -p -s /var/lib/tftpboot
StandardInput=socket
[Install]
WantedBy=multi-user.target
Also=tftp-server.socket
```
### 启动 TFTP 服务器
重新启动 systemd 守护进程：
```
systemctl daemon-reload
```
启动服务器：
```
systemctl enable --now tftp-server
```
要更改 TFTP 服务器允许上传和下载的权限，请使用此命令。注意 TFTP 是一种固有的不安全协议，因此不建议你在与其他人共享的网络上这样做。
```
chmod 777 /var/lib/tftpboot
```
配置防火墙让 TFTP 能够使用：
```
firewall-cmd --add-service=tftp --perm
firewall-cmd --reload
```
### 客户端配置
安装 TFTP 客户端
```
yum install tftp -y
```
运行 `tftp` 命令连接服务器。下面是一个启用详细信息选项的例子：
```
[client@thinclient:~ ]$ tftp 192.168.1.164
tftp> verbose
Verbose mode on.
tftp> get server.logs
getting from 192.168.1.164:server.logs to server.logs [netascii]
Received 7 bytes in 0.0 seconds [inf bits/sec]
tftp> quit
[client@thinclient:~ ]$
```
记住，因为 TFTP 没有列出服务器上文件的能力，因此，在你使用 `get` 命令之前需要知道文件的具体名称。
---
via: <https://fedoramagazine.org/how-to-set-up-a-tftp-server-on-fedora/>
作者：[Curt Warfield](https://fedoramagazine.org/author/rcurtiswarfield/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 Java 框架 Scipio ERP 创建一个在线商店 | Paul Piper | https://opensource.com/article/19/1/scipio-erp | Scipio ERP 具有包罗万象的应用程序和功能。 | /data/attachment/album/201909/22/133258hqvwax5w1zvq5ffa.jpg.thumb.jpg | /data/attachment/album/201909/22/133258hqvwax5w1zvq5ffa.jpg | true | false | true | lujun9972 | laingke | wxy | false | [
"在线商店"
] | 技术 | {
"viewnum": 3338,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Scipio ERP 具有包罗万象的应用程序和功能。 | 2019-09-22T13:33:08 | 2019-09-22T13:33:08 | 11,373 | /article-11373-1.html |
>
> Scipio ERP 具有包罗万象的应用程序和功能。
>
>
>
如果，你想在网上销售产品或服务，但要么找不到合适的软件，要么觉得定制成本太高？那么，[Scipio ERP](https://www.scipioerp.com) 也许正是你想要的。
Scipio ERP 是一个基于 Java 的开源的电子商务框架，具有包罗万象的应用程序和功能。这个项目于 2014 年从 [Apache OFBiz](https://ofbiz.apache.org/) 分叉而来，侧重于更好的定制和更现代的吸引力。这个电子商务组件非常丰富，可以在多商店环境中工作，同时支持国际化，具有琳琅满目的产品配置，而且它还兼容现代 HTML 框架。该软件还为许多其他业务场景提供标准应用程序，例如会计、仓库管理或销售团队自动化。它都是高度标准化的，因此易于定制，如果你想要的不仅仅是一个虚拟购物车，这是非常棒的。
该系统也使得跟上现代 Web 标准变得非常容易。所有界面都是使用系统的“[模板工具包](https://www.scipioerp.com/community/developer/freemarker-macros/)”构建的，这是一个易于学习的宏集，可以将 HTML 与所有应用程序分开。正因为如此，每个应用程序都已经标准化到核心。听起来令人困惑？它真的不是 HTML——它看起来很像 HTML，但你写的内容少了很多。
### 初始安装
在你开始之前，请确保你已经安装了 Java 1.8（或更高版本）的 SDK 以及一个 Git 客户端。完成了？太棒了！接下来，切换到 Github 上的主分支：
```
git clone https://github.com/ilscipio/scipio-erp.git
cd scipio-erp
git checkout master
```
要安装该系统，只需要运行 `./install.sh` 并从命令行中选择任一选项。在开发过程中，最好一直使用 “installation for development”（选项 1），它还将安装一系列演示数据。对于专业安装，你可以修改初始配置数据（“种子数据”），以便自动为你设置公司和目录数据。默认情况下，系统将使用内部数据库运行，但是它[也可以配置](https://www.scipioerp.com/community/developer/installation-configuration/configuration/#database-configuration)使用各种关系数据库，比如 PostgreSQL 和 MariaDB 等。
*按照安装向导完成初始配置*
通过命令 `./start.sh` 启动系统然后打开链接 <https://localhost:8443/setup/> 完成配置。如果你安装了演示数据, 你可以使用用户名 `admin` 和密码 `scipio` 进行登录。在安装向导中，你可以设置公司简介、会计、仓库、产品目录、在线商店和额外的用户配置信息。暂时在产品商店配置界面上跳过网站实体的配置。系统允许你使用不同的底层代码运行多个在线商店；除非你想这样做，一直选择默认值是最简单的。
祝贺你，你刚刚安装了 Scipio ERP！在界面上操作一两分钟，感受一下它的功能。
### 捷径
在你进入自定义之前，这里有一些方便的命令可以帮助你：
* 创建一个 shop-override：`./ant create-component-shop-override`
* 创建一个新组件：`./ant create-component`
* 创建一个新主题组件：`./ant create-theme`
* 创建管理员用户：`./ant create-admin-user-login`
* 各种其他实用功能：`./ant -p`
* 用于安装和更新插件的实用程序：`./git-addons help`
另外，请记下以下位置：
* 将 Scipio 作为服务运行的脚本：`/tools/scripts/`
* 日志输出目录：`/runtime/logs`
* 管理应用程序：`<https://localhost:8443/admin/>`
* 电子商务应用程序：`<https://localhost:8443/shop/>`
最后，Scipio ERP 在以下五个主要目录中构建了所有代码：
* `framework`: 框架相关的源，应用程序服务器，通用界面和配置
* `applications`: 核心应用程序
* `addons`: 第三方扩展
* `themes`: 修改界面外观
* `hot-deploy`: 你自己的组件
除了一些配置，你将在 `hot-deploy` 和 `themes` 目录中进行开发。
### 在线商店定制
要真正使系统成为你自己的系统，请开始考虑使用[组件](https://www.scipioerp.com/community/developer/architecture/components/)。组件是一种模块化方法，可以覆盖、扩展和添加到系统中。你可以将组件视为独立 Web 模块，可以捕获有关数据库（[实体](https://www.scipioerp.com/community/developer/entities/)）、功能（[服务](https://www.scipioerp.com/community/developer/services/)）、界面（[视图](https://www.scipioerp.com/community/developer/views-requests/)）、[事件和操作](https://www.scipioerp.com/community/developer/events-actions/)和 Web 应用程序等的信息。由于组件功能，你可以添加自己的代码，同时保持与原始源兼容。
运行命令 `./ant create-component-shop-override` 并按照步骤创建你的在线商店组件。该操作将会在 `hot-deploy` 目录内创建一个新目录，该目录将扩展并覆盖原始的电子商务应用程序。
*一个典型的组件目录结构。*
你的组件将具有以下目录结构：
* `config`: 配置
* `data`: 种子数据
* `entitydef`: 数据库表定义
* `script`: Groovy 脚本的位置
* `servicedef`: 服务定义
* `src`: Java 类
* `webapp`: 你的 web 应用程序
* `widget`: 界面定义
此外，`ivy.xml` 文件允许你将 Maven 库添加到构建过程中，`ofbiz-component.xml` 文件定义整个组件和 Web 应用程序结构。除了一些在当前目录所能够看到的，你还可以在 Web 应用程序的 `WEB-INF` 目录中找到 `controller.xml` 文件。这允许你定义请求实体并将它们连接到事件和界面。仅对于界面来说，你还可以使用内置的 CMS 功能，但优先要坚持使用核心机制。在引入更改之前，请熟悉 `/applications/shop/`。
#### 添加自定义界面
还记得[模板工具包](https://www.scipioerp.com/community/developer/freemarker-macros/)吗？你会发现它在每个界面都有使用到。你可以将其视为一组易于学习的宏，它用来构建所有内容。下面是一个例子：
```
<@section title="Title">
<@heading id="slider">Slider</@heading>
<@row>
<@cell columns=6>
<@slider id="" class="" controls=true indicator=true>
<@slide link="#" image="https://placehold.it/800x300">Just some content…</@slide>
<@slide title="This is a title" link="#" image="https://placehold.it/800x300"></@slide>
</@slider>
</@cell>
<@cell columns=6>Second column</@cell>
</@row>
</@section>
```
不是很难，对吧？同时，主题包含 HTML 定义和样式。这将权力交给你的前端开发人员，他们可以定义每个宏的输出，并坚持使用自己的构建工具进行开发。
我们快点试试吧。首先，在你自己的在线商店上定义一个请求。你将修改此代码。一个内置的 CMS 系统也可以通过 <https://localhost:8443/cms/> 进行访问，它允许你以更有效的方式创建新模板和界面。它与模板工具包完全兼容，并附带可根据你的喜好采用的示例模板。但是既然我们试图在这里理解系统，那么首先让我们采用更复杂的方法。
打开你商店 `webapp` 目录中的 [controller.xml](https://www.scipioerp.com/community/developer/views-requests/request-controller/) 文件。控制器会跟踪请求事件并相应地执行操作。下面的操作将会在 `/shop/test` 下创建一个新的请求:
```
<!-- Request Mappings -->
<request-map uri="test">
<security https="true" auth="false"/>
<response name="success" type="view" value="test"/>
</request-map>
```
你可以定义多个响应，如果需要，可以在请求中使用事件或服务调用来确定你可能要使用的响应。我选择了“视图”类型的响应。视图是渲染的响应；其他类型是请求重定向、转发等。系统附带各种渲染器，可让你稍后确定输出；为此，请添加以下内容：
```
<!-- View Mappings -->
<view-map name="test" type="screen" page="component://mycomponent/widget/CommonScreens.xml#test"/>
```
用你自己的组件名称替换 `my-component`。然后，你可以通过在 `widget/CommonScreens.xml` 文件的标签内添加以下内容来定义你的第一个界面：
```
<screen name="test">
<section>
<actions>
</actions>
<widgets>
<decorator-screen name="CommonShopAppDecorator" location="component://shop/widget/CommonScreens.xml">
<decorator-section name="body">
<platform-specific><html><html-template location="component://mycomponent/webapp/mycomponent/test/test.ftl"/></html></platform-specific>
</decorator-section>
</decorator-screen>
</widgets>
</section>
</screen>
```
商店界面实际上非常模块化，由多个元素组成（[小部件、动作和装饰器](https://www.scipioerp.com/community/developer/views-requests/screen-widgets-decorators/)）。为简单起见，请暂时保留原样，并通过添加第一个模板工具包文件来完成新网页。为此，创建一个新的 `webapp/mycomponent/test/test.ftl` 文件并添加以下内容：
```
<@alert type="info">Success!</@alert>
```
*一个自定义的界面。*
打开 <https://localhost:8443/shop/control/test/> 并惊叹于你自己的成就。
#### 自定义主题
通过创建自己的主题来修改商店的界面外观。所有主题都可以作为组件在 `themes` 文件夹中找到。运行命令 `./ant create-theme` 来创建你自己的主题。
*一个典型的主题组件布局。*
以下是最重要的目录和文件列表：
* 主题配置：`data/*ThemeData.xml`
* 特定主题封装的 HTML：`includes/*.ftl`
* 模板工具包 HTML 定义：`includes/themeTemplate.ftl`
* CSS 类定义：`includes/themeStyles.ftl`
* CSS 框架: `webapp/theme-title/`
快速浏览工具包中的 Metro 主题；它使用 Foundation CSS 框架并且充分利用了这个框架。然后，然后，在新构建的 `webapp/theme-title` 目录中设置自己的主题并开始开发。Foundation-shop 主题是一个非常简单的特定于商店的主题实现，你可以将其用作你自己工作的基础。
瞧！你已经建立了自己的在线商店，准备个性化定制吧！
*一个搭建完成的基于 Scipio ERP的在线商店。*
### 接下来是什么？
Scipio ERP 是一个功能强大的框架，可简化复杂的电子商务应用程序的开发。为了更完整的理解，请查看项目[文档](https://www.scipioerp.com/community/developer/architecture/components/)，尝试[在线演示](https://www.scipioerp.com/demo/)，或者[加入社区](https://forum.scipioerp.com/).
---
via: <https://opensource.com/article/19/1/scipio-erp>
作者：[Paul Piper](https://opensource.com/users/madppiper) 选题：[lujun9972](https://github.com/lujun9972) 译者：[laingke](https://github.com/laingke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在互联网放置 HTML 页面 | Julia Evans | https://jvns.ca/blog/2019/09/06/how-to-put-an-html-page-on-the-internet/ | 我喜欢互联网的一点是在互联网放置静态页面是如此简单。今天有人问我该怎么做，所以我想我会快速地写下来！ | /data/attachment/album/201909/22/234957mmzoie1imufsuwea.jpg.thumb.jpg | /data/attachment/album/201909/22/234957mmzoie1imufsuwea.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"网站"
] | 技术 | {
"viewnum": 4310,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 我喜欢互联网的一点是在互联网放置静态页面是如此简单。今天有人问我该怎么做，所以我想我会快速地写下来！ | 2019-09-22T23:50:49 | 2019-09-22T23:50:49 | 11,374 | /article-11374-1.html | 
我喜欢互联网的一点是在互联网放置静态页面是如此简单。今天有人问我该怎么做，所以我想我会快速地写下来！
### 只是一个 HTML 页面
我的所有网站都只是静态 HTML 和 CSS。我的网页设计技巧相对不高（<https://wizardzines.com> 是我自己开发的最复杂的网站），因此保持我所有的网站相对简单意味着我可以做一些改变/修复，而不会花费大量时间。
因此，我们将在此文章中采用尽可能简单的方式 —— 只需一个 HTML 页面。
### HTML 页面
我们要放在互联网上的网站只是一个名为 `index.html` 的文件。你可以在 <https://github.com/jvns/website-example> 找到它，它是一个 Github 仓库，其中只包含一个文件。
HTML 文件中包含一些 CSS，使其看起来不那么无聊，部分复制自 <https://example.com>。
### 如何将 HTML 页面放在互联网上
有以下几步：
1. 注册 [Neocities](https://neocities.org/) 帐户
2. 将 index.html 复制到你自己 neocities 站点的 index.html 中
3. 完成
上面的 `index.html` 页面位于 [julia-example-website.neocities.com](https://julia-example-website.neocities.org/) 中，如果你查看源代码，你将看到它与 github 仓库中的 HTML 相同。
我认为这可能是将 HTML 页面放在互联网上的最简单的方法（这是一次回归 Geocities，它是我在 2003 年制作我的第一个网站的方式）:)。我也喜欢 Neocities （像 [glitch](https://glitch.com)，我也喜欢）它能实验、学习，并有乐趣。
### 其他选择
这绝不是唯一简单的方式，在你推送 Git 仓库时，Github pages 和 Gitlab pages 以及 Netlify 都将会自动发布站点，并且它们都非常易于使用（只需将它们连接到你的 GitHub 仓库即可）。我个人使用 Git 仓库的方式，因为 Git 不会让我感到紧张，我想知道我实际推送的页面发生了什么更改。但我想你如果第一次只想将 HTML/CSS 制作的站点放到互联网上，那么 Neocities 就是一个非常好的方法。
如果你不只是玩，而是要将网站用于真实用途，那么你或许会需要买一个域名，以便你将来可以更改托管服务提供商，但这有点不那么简单。
### 这是学习 HTML 的一个很好的起点
如果你熟悉在 Git 中编辑文件，同时想练习 HTML/CSS 的话，我认为将它放在网站中是一个有趣的方式！我真的很喜欢它的简单性 —— 实际上这只有一个文件，所以没有其他花哨的东西需要去理解。
还有很多方法可以复杂化/扩展它，比如这个博客实际上是用 [Hugo](https://gohugo.io/) 生成的，它生成了一堆 HTML 文件并放在网络中，但从基础开始总是不错的。
---
via: <https://jvns.ca/blog/2019/09/06/how-to-put-an-html-page-on-the-internet/>
作者：[Julia Evans](https://jvns.ca/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Skytap 和微软将 IBM 机器搬到了 Azure | Andy Patrizio | https://www.networkworld.com/article/3438904/microsoft-brings-ibm-iron-to-azure-for-on-premises-migrations.html | 微软再次证明了其摒弃了“非我发明”这一态度来支持客户。 | /data/attachment/album/201909/23/005251s2z9exdlyk9k9t93.jpg.thumb.jpg | /data/attachment/album/201909/23/005251s2z9exdlyk9k9t93.jpg | true | false | true | lujun9972 | Morisun029 | wxy | false | [
"IBM",
"微软"
] | 新闻 | {
"viewnum": 3531,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 微软再次证明了其摒弃了“非我发明”这一态度来支持客户。 | 2019-09-23T00:52:40 | 2019-09-23T00:52:40 | 11,375 | /article-11375-1.html |
>
> 微软再次证明了其摒弃了“非我发明”这一态度来支持客户。
>
>
>
当微软将 Azure 作为其 Windows 服务器操作系统的云计算版本发布时，它并没有使其成为仅支持 Windows 系统的版本，它还支持 Linux 系统，并且在短短几年内[其 Linux 实例的数量现在已经超过了Windows 实例的数量](https://www.openwall.com/lists/oss-security/2019/06/27/7)。
很高兴看到微软终于摆脱了这种长期以来非常有害的“非我发明”态度，该公司的最新举动确实令人惊讶。
微软与一家名为 Skytap 的公司合作，以在 Azure 云服务上提供 IBM Power9 实例，可以在 Azure 云内运行基于 Power 的系统，该系统将与其已有的 Xeon 和 Epyc 实例一同作为 Azure 的虚拟机（VM）。
Skytap 是一家有趣的公司。它由华盛顿大学的三位教授创立，专门研究本地遗留硬件的云迁移，如 IBM System I 或 Sparc 的云迁移。该公司在西雅图拥有一个数据中心，以 IBM 的硬件运行 IBM 的 PowerVM 管理程序，并且对在美国和英格兰的 IBM 数据中心提供主机托管。
该公司的座右铭是快速迁移，然后按照自己的节奏进行现代化。因此，它专注于帮助一些企业将遗留系统迁移到云，然后实现应用程序的现代化，这也是它与微软合作的目的。Azure 将通过为企业提供平台来提高传统应用程序的价值，而无需花费巨额费用重写一个新平台。
Skytap 提供了预览，可以看到使用 Skytap 上的 DB2 提升和扩展原有的 IBM i 应用程序以及通过 Azure 的物联网中心进行扩展时可能发生的情况。该应用程序无缝衔接新旧架构，并证明了不需要完全重写可靠的 IBM i 应用程序即可从现代云功能中受益。
### 迁移到 Azure
根据协议，微软将把 IBM 的 Power S922 服务器部署在一个未声明的 Azure 区域。这些机器可以运行 PowerVM 管理程序，这些管理程序支持老式 IBM 操作系统以及 Linux 系统。
Skytap 首席执行官<ruby> 布拉德·希克 <rt> Brad Schick </rt></ruby>在一份声明中说道：“通过先替换旧技术来迁移上云既耗时又冒险。……Skytap 的愿景一直是通过一些小小的改变和较低的风险实现企业系统到云平台的迁移。与微软合作，我们将为各种遗留应用程序迁移到 Azure 提供本地支持，包括那些在 IBM i、AIX 和 Power Linux 上运行的程序。这将使企业能够通过使用 Azure 服务进行现代化来延长传统系统的寿命并增加其价值。”
随着基于 Power 应用程序的现代化，Skytap 随后将引入 DevOps CI/CD 工具链来加快软件的交付。迁移到 Azure 的 Skytap 上后，客户将能够集成 Azure DevOps，以及 Power 的 CI/CD 工具链，例如 Eradani 和 UrbanCode。
这些听起来像是迈出了第一步，但这意味着以后将会实现更多，尤其是在应用程序迁移方面。如果它仅在一个 Azure 区域中，听起来好像它们正在对该项目进行测试和验证，并可能在今年晚些时候或明年进行扩展。
---
via: <https://www.networkworld.com/article/3438904/microsoft-brings-ibm-iron-to-azure-for-on-premises-migrations.html>
作者：[Andy Patrizio](https://www.networkworld.com/author/Andy-Patrizio/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Morisun029](https://github.com/Morisun029) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
从 IaaS 到 HaaS：京东云的新“硬盒” | 老王 | 京东云下一代服务器是比裸金属和异构计算更底层的基础设施服务。 | /data/attachment/album/201909/23/155428pzmqeiacd337wic3.jpg.thumb.jpg | /data/attachment/album/201909/23/155428pzmqeiacd337wic3.jpg | true | false | false | false | [
"京东云"
] | 观点 | {
"viewnum": 3473,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 京东云下一代服务器是比裸金属和异构计算更底层的基础设施服务。 | 2019-09-23T15:27:00 | 2019-09-23T15:27:00 | 11,377 | /article-11377-1.html | 
作为一个曾经亲自扛着 2U 服务器进长安街长话机房的系统工程师，我对服务器的感情是深厚的，当抚摸着冰冷的裸金属，感受着机房内嗡嗡的背景噪音时，似乎能感觉到数据的流动。因此，当得知我的采访对象是国内第一个服务器硬件开源项目的总架构师陈国峰先生时，我还是有点小激动的。
国峰是一个十分低调的人，现任京东云硬件研发总监，他曾在百度工作，负责过百度硬件架构设计的相关工作，如百度的“北极”整机柜服务器、百度网盘用的冰山服务器、百度 AI 所使用的 X-MAN 异构计算服务器等就是其带领团队研发的成果，他也曾任开放数据中心委员会“天蝎”项目的总架构设计师。这十来年的硬件设计经历，让这个行业“老兵”对于互联网的基础设施——服务器，有着独到的见解。
### 演进：从复杂到简单的服务器
我最早接触过的服务器是 Sun 微系统的 Sparc 小型服务器，并没有见识过最早的<ruby> 大型机 <rp> （ </rp> <rt> MainFrame </rt> <rp> ） </rp></ruby>。随着互联网的发展，作为互联网迅猛发展的重要基础设施，服务器的形态也逐渐演变，从塔式服务器、刀片式服务器，再到机架式服务器，我们可以看到服务器的发展从高成本向低成本演进，由复杂变简单，由高技术壁垒向无技术壁垒演进。
就好比手机的演进过程，从一开始使用模拟网的大哥大，到后来使用数字网的手机（现在我们称之为功能机），再到现在的智能机，可以看到，手机的技术在急速进步，技术壁垒在迅速降低，生产成本也以不可思议的速度降低。而在服务器硬件方面，我们同样发现，现在的机架式服务器与原来的大型机相比，亦是如此。
从另外一个角度来看，随着市场需求的不断加大，我们对于服务器硬件的看法也逐渐发生了变化。从过去每个互联网公司最重要的硬件资产就是昂贵的服务器，到如今服务器已经成为了基本的生产资料一样普遍和随处可见。
以前对大机和小机追求的高可靠性、高稳定性，以及由此产生的高成本，随着云计算技术的普及，对单个服务器基础设施的稳定性和可靠性也在降低。互联网应用系统可以通过软件、集群的方式，来提升可靠性和稳定性，通过软件上的容忍度，对集群的容忍度会变高，通过这些上层的手段来避免对于底层基础设施的过度追求。相应的，随着对于基础设施的要求的不断降低，硬件设计的成本自然而然的也就降了下来。
### 变化：源自真实场景的需求
京东云的下一代服务器也并非完全凭空诞生，而是源自于实际需求的变化。
在过去，使用机架式服务器依然有大量的工作需要在机房内由人工完成，比如一个月可以在一个机房内交付 1 万台机器，一年 10 万台左右的规模。在过去的产业模式下，这种机制尚可持续，但如今的 HyperScale 模式下，这样的交付效率显然无法满足业务对于大规模数据中心的部署要求。
另外，随着云计算的兴起，云的场景也开始多元化，传统的公有云开始衍生出混合云、私有云……这样就会诞生另外一个场景，私有化的部署，包括边缘部署。这种部署是很分散的，不是集中式的。对于这种分散式的部署，我们更需要的是一体化集成的整机柜服务器，避免把很多部署的技术资源分散到各个地域和零散的点上面去。然而云用户，特别是私有云和混合云用户对硬件的稳定和配合功能往往也会有不同的诉求，这给传统的整机柜服务器提出了新的挑战。
为此，国峰带领他的团队，设计出了京东云下一代服务器。
在他看来，下一代服务器必须具备以下几个特性：
1. **高稳定性**。在过去私有云的时代，总拥有成本（TCO）是服务器定制的核心诉求，而在云的时代，为用户提供高可靠的基础设施是京东云的基本服务宗旨，所以，我们把高稳定性放在第一位，而不再是简单的将成本放在第一位。
2. **高灵活性**。公有云就意味着你的客户也是千人千面，不同于传统自用私有云，公有云客户需求的多元化是不可避免的，因此，基础服务就必须有足够的灵活性，以适配这种来自需求的灵活性。这也是为什么京东云下一代服务器要采用模块化设计的概念。
3. **高效率**。对于当前复杂的云市场，公有云，私有云，混合云多种场景并存的市场下，提供一体化交付，并且快速响应客户的资源需求也是产品竞争力的一项重要指标；高效另外一个层面的含义是高能效，能效是数据中心技术中的又一项重要指标，直接影响基础设施的运营成本；因此高效率也成为硬件基础设施的重要特性。
4. **低成本**。任何产品都避不开成本，成本是产品市场的核心因素，影响到产品的核心竞争力，但是，在云的场景下成本管控应当是在为客户提供了高稳定性、高灵活性、高效率之后考虑的事情。
### HaaS ：Hardware as a Service
和我们所熟知的裸金属、异构计算不同，京东云下一代服务器是比裸金属和异构计算更底层的基础设施服务。确切地说，不管是裸金属还是异构计算，包括上层的 IaaS、PaaS、SaaS 等服务都可以在京东云下一代服务器上呈现。
京东云将会围绕着下一代服务器打造公有云、私有云、混合云、全方位的云产品。一方面，这些底层的硬件服务会服务于京东集团内部的自用私有云，同时也会服务于集团的公有云业务。另一方面，针对私有云和混合云，也可以对外提供私有化交付。如果客户有需求，京东云可以将这些定制的硬件结合京东云的 Iaas、Paas、SaaS 相关技术和产品做成整体解决方案，交付给客户。针对不同的客户需求，京东云可以围绕定制化服务器硬件和MDC（整合IT，供电，制冷一体方案）提供租、售产品服务。这就是我们所谓的 HaaS 的理念和概念。
### 挑战：技术的进步
当然，下一代服务器并非一蹴而就，所面临的挑战主要分为三个方面：
第一、设计理念——高灵活性，因为用户的需求不可预测，用户场景复杂，租用机房较多，每个机房基础设施条件不一样，同时业务类型复杂，资源调配迁移需求比较多，而目前主流的整机柜与通用机相比，无论从 21 英寸的尺寸还是集中的散热方式都有很大的差异，造成了整机柜部署的局限性，很难实现灵活迁移，混合部署。京东云的下一代服务器通过“标准化，模块化，弹性化”，极大地提高了多场景支撑的灵活性。首先我们采用 42U 19 英寸标准机柜为设计单位，节点独立散热，通用性强，实现了整机柜和标准机架服务器任意切换。其次，节点前 IO 设计，机柜后部无任何线缆，所有运维工作均可在冷通道进行，单边维护效率更高，环境更友好。同时通过模块化设计，可实现前后 IO 灵活切换，集中供电和单机供电模式灵活切换。
第二、也是这个行业面临的通用性技术挑战——高功率密度问题。因为现在芯片行业已经进入到后摩尔定律时代了，意味着计算力的提升也会带来功耗的不断提升。功耗的上升，对于系统散热设计的挑战就会越来越大，风冷已经不足以满足目前的制冷需求，甚至散热某种程度上已经制约了服务器和数据中心的发展。所以，在新的架构设计上，我们会通过一些新的散热手段，比如通过风液混合散热的方式解决功率密度的问题。
第三，功率密度提高之后，风扇转速就会更高。同时由于硬盘的存储密度不断上升，对于外部环境的振动、噪声的敏感度就越来越高。所以我们在设计上对于硬盘和风扇振动需要考虑得更多，我们采用了“硬盘前置，风扇后置”的系统架构，最大程度的拉开风扇和硬盘之间的距离，有效的降低了震动对硬盘的影响。
### 开源：硬件开源任重道远
软件是开源领域的主力，虽然已经有一些开源硬件的出现，但是，仍然算不上主流，绝大多数团队在硬件方面依然采用传统的闭源方式。
在这个方面，我专门请教了国峰。在他看来，首先，必须承认硬件开源的发展远不如软件开源。硬件开源是最近几年兴起的，国际上比较知名的组织就是 OCP（[Open Compute Project](https://www.opencompute.org/)），以及国内比较知名的 ODCC ，其前身是 BAT 三家发起的天蝎项目。
他认为，之所以过去大家不做硬件开源，主要是两个原因：
一方面，原来硬件的技术壁垒相对较高，大家希望通过这些技术壁垒来创造价值，来实现商业变现，所以，之前市场上一直没有硬件开源的社区和项目。
另一方面，硬件跟软件有一个很大的不同点，软件的代码一旦写好，在机器上直接运行就能知道是否可以工作，硬件不一样，要验证一个硬件系统的设计，首先要从原理图上设计出来，然后在工厂生产出来，最后进行验证。它的周期长，同时需要大量实物的投入，投入成本相对比较大。此外，还需要有很多专业设备做测试，调试，所以，它的验证成本也非常高。这也是为什么硬件开源难以发展起来的原因。
但是，随着时代的变化，市场的不断变大，技术的开放力度也在不断的增强，技术壁垒也相应在不断降低，成本也越来越低。众人拾柴火焰高，一个新的硬件出来之后有更多的人参与进来，它的上下游的生态就会建得更快一点，普及周期就会变得更短。
这也是为什么京东云下一代服务器要做硬件开源的原因，我们希望建立和维护这样的生态，把大家拉到一起共同推动新生态的演进。
当然，开源也并非易事，要开源首先必须得做好充分的准备来接受市场以及行业专业人士的检验。目前京东云正在为下一代服务器的开源做准备。接下来，京东云也会围绕其新的硬件设计建立一些开源的渠道，比如 OCP、ODCC 等。
京东云希望通过硬件开源，让行业里面更多相关经验的从业者参与到下一代服务器的硬件设计中来，共同围绕新的服务器架构营造一个合作共赢的生态。
|
||||
Zsh 入门 | Seth Kenlon | https://opensource.com/article/19/9/getting-started-zsh | 从 Bash 进阶到 Z-shell，改进你的 shell 体验。 | /data/attachment/album/201909/23/163910imr1z1qw1ruo9uqs.jpg.thumb.jpg | /data/attachment/album/201909/23/163910imr1z1qw1ruo9uqs.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"zsh"
] | 技术 | {
"viewnum": 20095,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11426,
"displayorder": 0
}
] | 从 Bash 进阶到 Z-shell，改进你的 shell 体验。 | 2019-09-23T16:40:00 | 2019-09-23T16:40:00 | 11,378 | /article-11378-1.html |
>
> 从 Bash 进阶到 Z-shell，改进你的 shell 体验。
>
>
>
Z-shell（Zsh）是一种 Bourne 式的交互式 POSIX shell，以其丰富的创新功能而著称。Z-Shell 用户经常会提及它的许多便利之处，赞誉它对效率的提高和丰富的自定义支持。
如果你刚接触 Linux 或 Unix，但你的经验足以让你可以打开终端并运行一些命令的话，那么你可能使用的就是 Bash shell。Bash 可能是最具有代表意义的自由软件 shell，部分是因为它具有的先进的功能，部分是因为它是大多数流行的 Linux 和 Unix 操作系统上的默认 shell。但是，随着使用的次数越多，你可能会开始发现一些细节可能能够做的更好。开源有一个众所周知的地方，那就是选择。所以，许多人选择从 Bash “毕业”到 Z。
### Zsh 介绍
Shell 只是操作系统的接口。交互式 shell 程序允许你通过称为*标准输入*（stdin）的某个东西键入命令，并通过*标准输出*（stdout）和*标准错误*（stderr）获取输出。有很多种 shell，如 Bash、Csh、Ksh、Tcsh、Dash 和 Zsh。每个都有其开发者所认为最适合于 Shell 的功能。而这些功能的好坏，则取决于最终用户。
Zsh 具有交互式制表符补全、自动文件搜索、支持正则表达式、用于定义命令范围的高级速记符，以及丰富的主题引擎等功能。这些功能也包含在你所熟悉的其它 Bourne 式 shell 环境中，这意味着，如果你已经了解并喜欢 Bash，那么你也会熟悉 Zsh，除此以外，它还有更多的功能。你可能会认为它是一种 Bash++。
### 安装 Zsh
用你的包管理器安装 Zsh。
在 Fedora、RHEL 和 CentOS 上：
```
$ sudo dnf install zsh
```
在 Ubuntu 和 Debian 上：
```
$ sudo apt install zsh
```
在 MacOS 上你可以使用 MacPorts 安装它：
```
$ sudo port install zsh
```
或使用 Homebrew：
```
$ brew install zsh
```
在 Windows 上也可以运行 Zsh，但是只能在 Linux 层或类似 Linux 的层之上运行，例如 [Windows 的 Linux 子系统](https://devblogs.microsoft.com/commandline/category/bash-on-ubuntu-on-windows/)（WSL）或 [Cygwin](https://www.cygwin.com/)。这类安装超出了本文的范围，因此请参考微软的文档。
### 设置 Zsh
Zsh 不是终端模拟器。它是在终端仿真器中运行的 shell。因此，要启动 Zsh，必须首先启动一个终端窗口，例如 GNOME Terminal、Konsole、Terminal、iTerm2、rxvt 或你喜欢的其它终端。然后，你可以通过键入以下命令启动 Zsh：
```
$ zsh
```
首次启动 Zsh 时，会要求你选择一些配置选项。这些都可以在以后更改，因此请按 `1` 继续。
```
This is the Z Shell configuration function for new users, zsh-newuser-install.
(q) Quit and do nothing.
(0) Exit, creating the file ~/.zshrc
(1) Continue to the main menu.
```
偏好设置分为四类，因此请从顶部开始。
1. 第一个类使你可以选择在 shell 历史记录文件中保留多少个命令。默认情况下，它设置为 1,000 行。
2. Zsh 补全是其最令人兴奋的功能之一。为了简单起见，请考虑使用其默认选项激活它，直到你习惯了它的工作方式。按 `1` 使用默认选项，按 `2` 手动设置选项。
3. 选择 Emacs 式键绑定或 Vi 式键绑定。Bash 使用 Emacs 式绑定，因此你可能已经习惯了。
4. 最后，你可以了解（以及设置或取消设置）Zsh 的一些精妙的功能。例如，当你提供不带命令的非可执行路径时，可以通过让 Zsh 来改变目录而无需你使用 `cd` 命令。要激活这些额外选项之一，请输入选项号并输入 `s` 进行设置。请尝试打开所有选项以获得完整的 Zsh 体验。你可以稍后通过编辑 `~/.zshrc` 取消设置它们。
要完成配置，请按 `0`。
### 使用 Zsh
刚开始，Zsh 的使用感受就像使用 Bash 一样，这无疑是其众多功能之一。例如，Bash 和 Tcsh 之间就存在严重的差异，因此如果你必须在工作中或在服务器上使用 Bash，而 Zsh 就可以在家里轻松尝试和使用，这样在 Bash 和 Zsh 之间轻松切换就是一种便利。
#### 在 Zsh 中改变目录
正是这些微小的差异使 Zsh 变得好用。首先，尝试在没有 `cd` 命令的情况下，将目录更改为 `Documents` 文件夹。简直太棒了，难以置信。如果你输入的是目录路径而没有进一步的指令，Zsh 会更改为该目录：
```
% Documents
% pwd
/home/seth/Documents
```
而这会在 Bash 或任何其他普通 shell 中导致错误。但是 Zsh 却根本不是普通的 shell，而这仅仅才是开始。
#### 在 Zsh 中搜索
当你想使用普通 shell 程序查找文件时，可以使用 `find` 或 `locate` 命令。最起码，你可以使用 `ls -R` 来递归地列出一组目录。Zsh 内置有允许它在当前目录或任何其他子目录中查找文件的功能。
例如，假设你有两个名为 `foo.txt` 的文件。一个位于你的当前目录中，另一个位于名为 `foo` 的子目录中。在 Bash Shell 中，你可以使用以下命令列出当前目录中的文件：
```
$ ls
foo.txt
```
你可以通过明确指明子目录的路径来列出另一个目录：
```
$ ls foo
foo.txt
```
要同时列出这两者，你必须使用 `-R` 开关，并结合使用 `grep`：
```
$ ls -R | grep foo.txt
foo.txt
foo.txt
```
但是在 Zsh 中，你可以使用 `**` 速记符号：
```
% ls **/foo.txt
foo.txt
foo.txt
```
你可以在任何命令中使用此语法，而不仅限于 `ls`。想象一下在这样的场景中提高的效率：将特定文件类型从一组目录中移动到单个位置、将文本片段串联到一个文件中，或对日志进行抽取。
### 使用 Zsh 的制表符补全
制表符补全是 Bash 和其他一些 Shell 中的高级用户功能，它变得司空见惯，席卷了 Unix 世界。Unix 用户不再需要在输入冗长而乏味的路径时使用通配符（例如输入 `/h*/s*h/V*/SCS/sc*/comp*/t*/a*/*9/04/LS*boat*v`，比输入 `/home/seth/Videos/SCS/scenes/composite/takes/approved/109/04/LS_boat-port-cargo-mover.mkv` 要容易得多）。相反，他们只要输入足够的唯一字符串即可按 `Tab` 键。例如，如果你知道在系统的根目录下只有一个以 `h` 开头的目录，则可以键入 `/h`，然后单击 `Tab`。快速、简单、高效。它还会确认路径存在；如果 `Tab` 无法完成任何操作，则说明你在错误的位置或输入了错误的路径部分。
但是，如果你有许多目录有五个或更多相同的首字母，`Tab` 会坚决拒绝进行补全。尽管在大多数现代终端中，它将（至少会）显示阻止其进行猜测你的意思的文件，但通常需要按两次 `Tab` 键才能显示它们。因此，制表符补全通常会变成来回按下键盘上字母和制表符，以至于你好像在接受钢琴独奏会的训练。
Zsh 通过循环可能的补全来解决这个小问题。如果键入 `ls ~/D` 并按 `Tab`，则 Zsh 首先使用 `Documents` 来完成命令；如果再次按 `Tab`，它将提供 `Downloads`，依此类推，直到找到所需的选项。
### Zsh 中的通配符
在 Zsh 中，通配符的行为不同于 Bash 中用户所习惯的行为。首先，可以对其进行修改。例如，如果要列出当前目录中的所有文件夹，则可以使用修改后的通配符：
```
% ls
dir0 dir1 dir2 file0 file1
% ls *(/)
dir0 dir1 dir2
```
在此示例中，`(/)` 限定了通配符的结果，因此 Zsh 仅显示目录。要仅列出文件，请使用 `(.)`。要列出符号链接，请使用 `(@)`。要列出可执行文件，请使用 `(*)`。
```
% ls ~/bin/*(*)
fop exify tt
```
Zsh 不仅仅知道文件类型。它也可以使用相同的通配符修饰符约定根据修改时间列出。例如，如果要查找在过去八个小时内修改的文件，请使用 `mh` 修饰符（即 “modified hours” 的缩写）和小时的负整数：
```
% ls ~/Documents/*(mh-8)
cal.org game.org home.org
```
要查找超过（例如）两天前修改过的文件，修饰符更改为 `md`（即 “modified day” 的缩写），并带上天数的正整数：
```
% ls ~/Documents/*(+2)
holiday.org
```
通配符修饰符和限定符还可以做很多事情，因此，请阅读 [Zsh 手册页](https://linux.die.net/man/1/zsh)，以获取全部详细信息。
#### 通配符的副作用
要像在 Bash 中使用通配符一样使用它，有时必须在 Zsh 中对通配符进行转义。例如，如果要在 Bash 中将某些文件复制到服务器上，则可以使用如下通配符：
```
$ scp IMG_*.JPG [email protected]:~/www/ph*/*19/09/14
```
这在 Bash 中有效，但是在 Zsh 中会返回错误，因为它在发出 `scp` 命令之前尝试在远程端扩展该变量（通配符）。为避免这种情况，必须转义远程变量（通配符）：
```
% scp IMG_*.JPG [email protected]:~/www/ph\*/\*19/09/14
```
当你切换到新的 shell 时，这些小异常可能会使你感到沮丧。使用 Zsh 时会遇到的问题不多（体验过 Zsh 后切换回 Bash 的可能遇到更多），但是当它们发生时，请保持镇定且坦率。严格遵守 POSIX 的情况很少会出错，但是如果失败了，请查找问题以解决并继续。对于许多在工作中困在一个 shell 上而在家中困在另一个 shell 上的用户来说，[hyperpolyglot.org](http://hyperpolyglot.org/unix-shells) 已被证明其是无价的。
在我的下一篇 Zsh 文章中，我将向你展示如何安装主题和插件以定制你的 Z-Shell 甚至 Z-ier。
---
via: <https://opensource.com/article/19/9/getting-started-zsh>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Git 练习：存储库导航 | Julia Evans | https://jvns.ca/blog/2019/08/30/git-exercises--navigate-a-repository/ | Git 是一大块需要学习的技能，可能要花几个小时才能学会，所以我分解练习的第一个思路是从“导航”一个存储库开始的。 | /data/attachment/album/201909/23/224146fo79str9bxs8wb6s.jpg.thumb.jpg | /data/attachment/album/201909/23/224146fo79str9bxs8wb6s.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Git"
] | 技术 | {
"viewnum": 3462,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | Git 是一大块需要学习的技能，可能要花几个小时才能学会，所以我分解练习的第一个思路是从“导航”一个存储库开始的。 | 2019-09-23T22:42:05 | 2019-09-23T22:42:05 | 11,379 | /article-11379-1.html | 
我觉得前几天的 [curl 练习](https://jvns.ca/blog/2019/08/27/curl-exercises/)进展顺利，所以今天我醒来后，想尝试编写一些 Git 练习。Git 是一大块需要学习的技能，可能要花几个小时才能学会，所以我分解练习的第一个思路是从“导航”一个存储库开始的。
我本来打算使用一个玩具测试库，但后来我想，为什么不使用真正的存储库呢？这样更有趣！因此，我们将浏览 Ruby 编程语言的存储库。你无需了解任何 C 即可完成此练习，只需熟悉一下存储库中的文件随时间变化的方式即可。
### 克隆存储库
开始之前，需要克隆存储库：
```
git clone https://github.com/ruby/ruby
```
与实际使用的大多数存储库相比，该存储库的最大不同之处在于它没有分支，但是它有很多标签，它们与分支相似，因为它们都只是指向一个提交的指针而已。因此，我们将使用标签而不是分支进行练习。*改变*标签的方式和分支非常不同，但*查看*标签和分支的方式完全相同。
### Git SHA 总是引用同一个代码
执行这些练习时要记住的最重要的一点是，如本页面所述，像`9e3d9a2a009d2a0281802a84e1c5cc1c887edc71` 这样的 Git SHA 始终引用同一个的代码。下图摘自我与凯蒂·西勒·米勒撰写的一本杂志，名为《[Oh shit, git!](https://wizardzines.com/zines/oh-shit-git/)》。（她还有一个名为 <https://ohshitgit.com/> 的很棒的网站，启发了该杂志。）
我们将在练习中大量使用 Git SHA，以使你习惯于使用它们，并帮助你了解它们与标签和分支的对应关系。
### 我们将要使用的 Git 子命令
所有这些练习仅使用这 5 个 Git 子命令：
```
git checkout
git log (--oneline, --author, and -S will be useful)
git diff (--stat will be useful)
git show
git status
```
### 练习
1. 查看 matz 从 1998 年开始的 Ruby 提交。提交 ID 为 `3db12e8b236ac8f88db8eb4690d10e4a3b8dbcd4`。找出当时 Ruby 的代码行数。
2. 检出当前的 master 分支。
3. 查看文件 `hash.c` 的历史记录。更改该文件的最后一个提交 ID 是什么？
4. 了解最近 20 年来 `hash.c` 的变化：将 master 分支上的文件与提交 `3db12e8b236ac8f88db8eb4690d10e4a3b8dbcd4` 的文件进行比较。
5. 查找最近更改了 `hash.c` 的提交，并查看该提交的差异。
6. 对于每个 Ruby 版本，该存储库都有一堆**标签**。获取所有标签的列表。
7. 找出在标签 `v1_8_6_187` 和标签 `v1_8_6_188` 之间更改了多少文件。
8. 查找 2015 年的提交（任何一个提交）并将其检出，简单地查看一下文件，然后返回 master 分支。
9. 找出标签 `v1_8_6_187` 对应的提交。
10. 列出目录 `.git/refs/tags`。运行 `cat .git/refs/tags/v1_8_6_187` 来查看其中一个文件的内容。
11. 找出当前 `HEAD` 对应的提交 ID。
12. 找出已经对 `test/` 目录进行了多少次提交。
13. 提交 `65a5162550f58047974793cdc8067a970b2435c0` 和 `9e3d9a2a009d2a0281802a84e1c5cc1c887edc71` 之间的 `lib/telnet.rb` 的差异。该文件更改了几行？
14. 在 Ruby 2.5.1 和 2.5.2 之间进行了多少次提交（标记为 `v2_5_1` 和 `v2_5_3`）（这一步有点棘手，步骤不只一步）
15. “matz”（Ruby 的创建者）作了多少提交？
16. 最近包含 “tkutil” 一词的提交是什么？
17. 检出提交 `e51dca2596db9567bd4d698b18b4d300575d3881` 并创建一个指向该提交的新分支。
18. 运行 `git reflog` 以查看你到目前为止完成的所有存储库导航操作。 ——————————————————————————–
via: [https://jvns.ca/blog/2019/08/30/git-exercises–navigate-a-repository/](https://jvns.ca/blog/2019/08/30/git-exercises--navigate-a-repository/)
作者：[Julia Evans](https://jvns.ca/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 中如何移动文件 | Seth Kenlon | https://opensource.com/article/19/8/moving-files-linux-depth | 无论你是刚接触 Linux 的文件移动的新手还是已有丰富的经验，你都可以通过此深入的文章中学到一些东西。 | /data/attachment/album/201909/24/162919ygppgeevgrj0ppgv.jpg.thumb.jpg | /data/attachment/album/201909/24/162919ygppgeevgrj0ppgv.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"移动"
] | 技术 | {
"viewnum": 32046,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11300,
"displayorder": 0
}
] | 无论你是刚接触 Linux 的文件移动的新手还是已有丰富的经验，你都可以通过此深入的文章中学到一些东西。 | 2019-09-24T16:29:38 | 2019-09-24T16:29:38 | 11,380 | /article-11380-1.html |
>
> 无论你是刚接触 Linux 的文件移动的新手还是已有丰富的经验，你都可以通过此深入的文章中学到一些东西。
>
>
>
在 Linux 中移动文件看似比较简单，但是可用的选项却比大多数人想象的要多。本文介绍了初学者如何在 GUI 和命令行中移动文件，还介绍了底层实际上发生了什么，并介绍了许多有一定经验的用户也很少使用的命令行选项。
### 移动什么？
在研究移动文件之前，有必要仔细研究*移动*文件系统对象时实际发生的情况。当文件创建后，会将其分配给一个<ruby> 索引节点 <rt> inode </rt></ruby>，这是文件系统中用于数据存储的固定点。你可以使用 [ls](https://opensource.com/article/19/7/master-ls-command) 命令看到文件对应的索引节点：
```
$ ls --inode example.txt
7344977 example.txt
```
移动文件时，实际上并没有将数据从一个索引节点移动到另一个索引节点，只是给文件对象分配了新的名称或文件路径而已。实际上，文件在移动时会保留其权限，因为移动文件不会更改或重新创建文件。（LCTT 译注：在不跨卷、分区和存储器时，移动文件是不会重新创建文件的；反之亦然）
文件和目录的索引节点并没有暗示这种继承关系，而是由文件系统本身决定的。索引节点的分配是基于文件创建时的顺序分配的，并且完全独立于你组织计算机文件的方式。一个目录“内”的文件的索引节点号可能比其父目录的索引节点号更低或更高。例如：
```
$ mkdir foo
$ mv example.txt foo
$ ls --inode
7476865 foo
$ ls --inode foo
7344977 example.txt
```
但是，将文件从一个硬盘驱动器移动到另一个硬盘驱动器时，索引节点基本上会更改。发生这种情况是因为必须将新数据写入新文件系统。因此，在 Linux 中，移动和重命名文件的操作实际上是相同的操作。无论你将文件移动到另一个目录还是在同一目录使用新名称，这两个操作均由同一个底层程序执行。
本文重点介绍将文件从一个目录移动到另一个目录。
### 用鼠标移动文件
图形用户界面是大多数人都熟悉的友好的抽象层，位于复杂的二进制数据集合之上。这也是在 Linux 桌面上移动文件的首选方法，也是最直观的方法。从一般意义上来说，如果你习惯使用台式机，那么你可能已经知道如何在硬盘驱动器上移动文件。例如，在 GNOME 桌面上，将文件从一个窗口拖放到另一个窗口时的默认操作是移动文件而不是复制文件，因此这可能是该桌面上最直观的操作之一：
而 KDE Plasma 桌面中的 Dolphin 文件管理器默认情况下会提示用户以执行不同的操作。拖动文件时按住 `Shift` 键可强制执行移动操作：
### 在命令行移动文件
用于在 Linux、BSD、Illumos、Solaris 和 MacOS 上移动文件的 shell 命令是 `mv`。不言自明，简单的命令 `mv <source> <destination>` 会将源文件移动到指定的目标，源和目标都由[绝对](https://opensource.com/article/19/7/understanding-file-paths-and-how-use-them)或[相对](https://opensource.com/article/19/7/navigating-filesystem-relative-paths)文件路径定义。如前所述，`mv` 是 [POSIX](https://opensource.com/article/19/7/what-posix-richard-stallman-explains) 用户的常用命令，其有很多不为人知的附加选项，因此，无论你是新手还是有经验的人，本文都会为你带来一些有用的选项。
但是，不是所有 `mv` 命令都是由同一个人编写的，因此取决于你的操作系统，你可能拥有 GNU `mv`、BSD `mv` 或 Sun `mv`。命令的选项因其实现而异（BSD `mv` 根本没有长选项），因此请参阅你的 `mv` 手册页以查看支持的内容，或安装你的首选版本（这是开源的奢侈之处）。
#### 移动文件
要使用 `mv` 将文件从一个文件夹移动到另一个文件夹，请记住语法 `mv <source> <destination>`。 例如，要将文件 `example.txt` 移到你的 `Documents` 目录中：
```
$ touch example.txt
$ mv example.txt ~/Documents
$ ls ~/Documents
example.txt
```
就像你通过将文件拖放到文件夹图标上来移动文件一样，此命令不会将 `Documents` 替换为 `example.txt`。相反，`mv` 会检测到 `Documents` 是一个文件夹，并将 `example.txt` 文件放入其中。
你还可以方便地在移动文件时重命名该文件：
```
$ touch example.txt
$ mv example.txt ~/Documents/foo.txt
$ ls ~/Documents
foo.txt
```
这很重要，这使你不用将文件移动到另一个位置，也可以重命名文件，例如：
```
$ touch example.txt
$ mv example.txt foo2.txt
$ ls foo2.txt`
```
#### 移动目录
不像 [cp](https://opensource.com/article/19/7/copying-files-linux) 命令，`mv` 命令处理文件和目录没有什么不同，你可以用同样的格式移动目录或文件：
```
$ touch file.txt
$ mkdir foo_directory
$ mv file.txt foo_directory
$ mv foo_directory ~/Documents
```
#### 安全地移动文件
如果你移动一个文件到一个已有同名文件的地方，默认情况下，`mv` 会用你移动的文件替换目标文件。这种行为被称为<ruby> 清除 <rt> clobbering </rt></ruby>，有时候这就是你想要的结果，而有时则不是。
一些发行版将 `mv` 别名定义为 `mv --interactive`（你也可以[自己写一个](https://opensource.com/article/19/7/bash-aliases)），这会提醒你确认是否覆盖。而另外一些发行版没有这样做，那么你可以使用 `--interactive` 或 `-i` 选项来确保当两个文件有一样的名字而发生冲突时让 `mv` 请你来确认。
```
$ mv --interactive example.txt ~/Documents
mv: overwrite '~/Documents/example.txt'?
```
如果你不想手动干预，那么可以使用 `--no-clobber` 或 `-n`。该选项会在发生冲突时静默拒绝移动操作。在这个例子当中，一个名为 `example.txt` 的文件以及存在于 `~/Documents`，所以它不会如命令要求从当前目录移走。
```
$ mv --no-clobber example.txt ~/Documents
$ ls
example.txt
```
#### 带备份的移动
如果你使用 GNU `mv`，有一个备份选项提供了另外一种安全移动的方式。要为任何冲突的目标文件创建备份文件，可以使用 `-b` 选项。
```
$ mv -b example.txt ~/Documents
$ ls ~/Documents
example.txt example.txt~
```
这个选项可以确保 `mv` 完成移动操作，但是也会保护目录位置的已有文件。
另外的 GNU 备份选项是 `--backup`，它带有一个定义了备份文件如何命名的参数。
* `existing`：如果在目标位置已经存在了编号备份文件，那么会创建编号备份。否则，会使用 `simple` 方式。
* `none`：即使设置了 `--backup`，也不会创建备份。当 `mv` 被别名定义为带有备份选项时，这个选项可以覆盖这种行为。
* `numbered`：给目标文件名附加一个编号。
* `simple`：给目标文件附加一个 `~`，当你日常使用带有 `--ignore-backups` 选项的 [ls](https://opensource.com/article/19/7/master-ls-command) 时，这些文件可以很方便地隐藏起来。
简单来说：
```
$ mv --backup=numbered example.txt ~/Documents
$ ls ~/Documents
-rw-rw-r--. 1 seth users 128 Aug 1 17:23 example.txt
-rw-rw-r--. 1 seth users 128 Aug 1 17:20 example.txt.~1~
```
可以使用环境变量 `VERSION_CONTROL` 设置默认的备份方案。你可以在 `~/.bashrc` 文件中设置该环境变量，也可以在命令前动态设置：
```
$ VERSION_CONTROL=numbered mv --backup example.txt ~/Documents
$ ls ~/Documents
-rw-rw-r--. 1 seth users 128 Aug 1 17:23 example.txt
-rw-rw-r--. 1 seth users 128 Aug 1 17:20 example.txt.~1~
-rw-rw-r--. 1 seth users 128 Aug 1 17:22 example.txt.~2~
```
`--backup` 选项仍然遵循 `--interactive` 或 `-i` 选项，因此即使它在执行备份之前创建了备份，它仍会提示你覆盖目标文件：
```
$ mv --backup=numbered example.txt ~/Documents
mv: overwrite '~/Documents/example.txt'? y
$ ls ~/Documents
-rw-rw-r--. 1 seth users 128 Aug 1 17:24 example.txt
-rw-rw-r--. 1 seth users 128 Aug 1 17:20 example.txt.~1~
-rw-rw-r--. 1 seth users 128 Aug 1 17:22 example.txt.~2~
-rw-rw-r--. 1 seth users 128 Aug 1 17:23 example.txt.~3~
```
你可以使用 `--force` 或 `-f` 选项覆盖 `-i`。
```
$ mv --backup=numbered --force example.txt ~/Documents
$ ls ~/Documents
-rw-rw-r--. 1 seth users 128 Aug 1 17:26 example.txt
-rw-rw-r--. 1 seth users 128 Aug 1 17:20 example.txt.~1~
-rw-rw-r--. 1 seth users 128 Aug 1 17:22 example.txt.~2~
-rw-rw-r--. 1 seth users 128 Aug 1 17:24 example.txt.~3~
-rw-rw-r--. 1 seth users 128 Aug 1 17:25 example.txt.~4~
```
`--backup` 选项在 BSD `mv` 中不可用。
#### 一次性移动多个文件
移动多个文件时，`mv` 会将最终目录视为目标：
```
$ mv foo bar baz ~/Documents
$ ls ~/Documents
foo bar baz
```
如果最后一个项目不是目录，则 `mv` 返回错误：
```
$ mv foo bar baz
mv: target 'baz' is not a directory
```
GNU `mv` 的语法相当灵活。如果无法把目标目录作为提供给 `mv` 命令的最终参数，请使用 `--target-directory` 或 `-t` 选项：
```
$ mv --target-directory=~/Documents foo bar baz
$ ls ~/Documents
foo bar baz
```
当从某些其他命令的输出构造 `mv` 命令时（例如 `find` 命令、`xargs` 或 [GNU Parallel](https://opensource.com/article/18/5/gnu-parallel)），这特别有用。
#### 基于修改时间移动
使用 GNU `mv`，你可以根据要移动的文件是否比要替换的目标文件新来定义移动动作。该方式可以通过 `--update` 或 `-u` 选项使用，在BSD `mv` 中不可用：
```
$ ls -l ~/Documents
-rw-rw-r--. 1 seth users 128 Aug 1 17:32 example.txt
$ ls -l
-rw-rw-r--. 1 seth users 128 Aug 1 17:42 example.txt
$ mv --update example.txt ~/Documents
$ ls -l ~/Documents
-rw-rw-r--. 1 seth users 128 Aug 1 17:42 example.txt
$ ls -l
```
此结果仅基于文件的修改时间，而不是两个文件的差异，因此请谨慎使用。只需使用 `touch` 命令即可愚弄 `mv`：
```
$ cat example.txt
one
$ cat ~/Documents/example.txt
one
two
$ touch example.txt
$ mv --update example.txt ~/Documents
$ cat ~/Documents/example.txt
one
```
显然，这不是最智能的更新功能，但是它提供了防止覆盖最新数据的基本保护。
### 移动
除了 `mv` 命令以外，还有更多的移动数据的方法，但是作为这项任务的默认程序，`mv` 是一个很好的通用选择。现在你知道了有哪些可以使用的选项，可以比以前更智能地使用 `mv` 了。
---
via: <https://opensource.com/article/19/8/moving-files-linux-depth>
作者：[Seth Kenlon](https://opensource.com/users/sethhttps://opensource.com/users/doni08521059) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 中怎样移除（删除）符号链接 | Magesh Maruthamuthu | https://www.2daygeek.com/remove-delete-symbolic-link-softlink-linux/ | 你可能有时需要在 Linux 上创建或者删除符号链接。如果有，你知道该怎样做吗？之前你做过吗？你踩坑没有？如果你踩过坑，那没什么问题。如果还没有，别担心，我们将在这里帮助你。 | /data/attachment/album/201909/24/170625no4babjqq7jmm3qb.jpg.thumb.jpg | /data/attachment/album/201909/24/170625no4babjqq7jmm3qb.jpg | true | false | true | lujun9972 | arrowfeng | false | [
"符号链接"
] | 技术 | {
"viewnum": 6612,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 你可能有时需要在 Linux 上创建或者删除符号链接。如果有，你知道该怎样做吗？之前你做过吗？你踩坑没有？如果你踩过坑，那没什么问题。如果还没有，别担心，我们将在这里帮助你。 | 2019-09-24T17:07:00 | 2019-09-24T17:07:00 | 11,382 | /article-11382-1.html | 
你可能有时需要在 Linux 上创建或者删除符号链接。如果有，你知道该怎样做吗？之前你做过吗？你踩坑没有？如果你踩过坑，那没什么问题。如果还没有，别担心，我们将在这里帮助你。
使用 `rm` 和 `unlink` 命令就能完成移除（删除）符号链接的操作。
### 什么是符号链接？
符号链接（symlink）又称软链接，它是一种特殊的文件类型，在 Linux 中该文件指向另一个文件或者目录。它类似于 Windows 中的快捷方式。它能在相同或者不同的文件系统或分区中指向一个文件或着目录。
符号链接通常用来链接库文件。它也可用于链接日志文件和挂载的 NFS（网络文件系统）上的文件夹。
### 什么是 rm 命令？
[rm 命令](https://www.2daygeek.com/linux-remove-files-directories-folders-rm-command/) 被用来移除文件和目录。它非常危险，你每次使用 `rm` 命令的时候要非常小心。
### 什么是 unlink 命令？
`unlink` 命令被用来移除特殊的文件。它被作为 GNU Gorutils 的一部分安装了。
### 1) 使用 rm 命令怎样移除符号链接文件
`rm` 命令是在 Linux 中使用最频繁的命令，它允许我们像下列描述那样去移除符号链接。
```
# rm symlinkfile
```
始终将 `rm` 命令与 `-i` 一起使用以了解正在执行的操作。
```
# rm -i symlinkfile1
rm: remove symbolic link ‘symlinkfile1’? y
```
它允许我们一次移除多个符号链接：
```
# rm -i symlinkfile2 symlinkfile3
rm: remove symbolic link ‘symlinkfile2’? y
rm: remove symbolic link ‘symlinkfile3’? y
```
#### 1a) 使用 rm 命令怎样移除符号链接目录
这像移除符号链接文件那样。使用下列命令移除符号链接目录。
```
# rm -i symlinkdir
rm: remove symbolic link ‘symlinkdir’? y
```
使用下列命令移除多个符号链接目录。
```
# rm -i symlinkdir1 symlinkdir2
rm: remove symbolic link ‘symlinkdir1’? y
rm: remove symbolic link ‘symlinkdir2’? y
```
如果你在结尾增加 `/`，这个符号链接目录将不会被删除。如果你加了，你将得到一个错误。
```
# rm -i symlinkdir/
rm: cannot remove ‘symlinkdir/’: Is a directory
```
你可以增加 `-r` 去处理上述问题。**但如果你增加这个参数，它将会删除目标目录下的内容，并且它不会删除这个符号链接文件。**（LCTT 译注：这可能不是你的原意。）
```
# rm -ri symlinkdir/
rm: descend into directory ‘symlinkdir/’? y
rm: remove regular file ‘symlinkdir/file4.txt’? y
rm: remove directory ‘symlinkdir/’? y
rm: cannot remove ‘symlinkdir/’: Not a directory
```
### 2) 使用 unlink 命令怎样移除符号链接
`unlink` 命令删除指定文件。它一次仅接受一个文件。
删除符号链接文件：
```
# unlink symlinkfile
```
删除符号链接目录：
```
# unlink symlinkdir2
```
如果你在结尾增加 `/`，你不能使用 `unlink` 命令删除符号链接目录。
```
# unlink symlinkdir3/
unlink: cannot unlink ‘symlinkdir3/’: Not a directory
```
---
via: <https://www.2daygeek.com/remove-delete-symbolic-link-softlink-linux/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[arrowfeng](https://github.com/arrowfeng) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Go 语言在极小硬件上的运用（一） | Michał Derkacz | https://ziutek.github.io/2018/03/30/go_on_very_small_hardware.html | Go 语言，能在多低下的配置上运行并发挥作用呢？ | /data/attachment/album/201909/24/210256yihkuy8kcigugr2h.png.thumb.jpg | /data/attachment/album/201909/24/210256yihkuy8kcigugr2h.png | true | false | true | wenwensnow | wxy | false | [
"Go"
] | 软件开发 | {
"viewnum": 10976,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "222.65.171.235",
"message": "这个和 tiny-go 有啥异同",
"username": "march1993 [Chrome 76.0|Windows 10]",
"date": "2019-09-25T17:28:45"
}
] | [
{
"raid": 12747,
"displayorder": 0
}
] | Go 语言，能在多低下的配置上运行并发挥作用呢？ | 2019-09-24T21:03:09 | 2019-09-24T21:03:09 | 11,383 | /article-11383-1.html | 
Go 语言，能在多低下的配置上运行并发挥作用呢？
我最近购买了一个特别便宜的开发板：
我购买它的理由有三个。首先，我（作为程序员）从未接触过 STM320 系列的开发板。其次，STM32F10x 系列使用也有点少了。STM320 系列的 MCU 很便宜，有更新一些的外设，对系列产品进行了改进，问题修复也做得更好了。最后，为了这篇文章，我选用了这一系列中最低配置的开发板，整件事情就变得有趣起来了。
### 硬件部分
[STM32F030F4P6](http://www.st.com/content/st_com/en/products/microcontrollers/stm32-32-bit-arm-cortex-mcus/stm32-mainstream-mcus/stm32f0-series/stm32f0x0-value-line/stm32f030f4.html) 给人留下了很深的印象：
* CPU: [Cortex M0](https://en.wikipedia.org/wiki/ARM_Cortex-M#Cortex-M0) 48 MHz（最低配置，只有 12000 个逻辑门电路）
* RAM: 4 KB，
* Flash: 16 KB，
* ADC、SPI、I2C、USART 和几个定时器
以上这些采用了 TSSOP20 封装。正如你所见，这是一个很小的 32 位系统。
### 软件部分
如果你想知道如何在这块开发板上使用 [Go](https://golang.org/) 编程，你需要反复阅读硬件规范手册。你必须面对这样的真实情况：在 Go 编译器中给 Cortex-M0 提供支持的可能性很小。而且，这还仅仅只是第一个要解决的问题。
我会使用 [Emgo](https://github.com/ziutek/emgo)，但别担心，之后你会看到，它如何让 Go 在如此小的系统上尽可能发挥作用。
在我拿到这块开发板之前，对 [stm32/hal](https://github.com/ziutek/emgo/tree/master/egpath/src/stm32/hal) 系列下的 F0 MCU 没有任何支持。在简单研究[参考手册](http://www.st.com/resource/en/reference_manual/dm00091010.pdf)后，我发现 STM32F0 系列是 STM32F3 削减版，这让在新端口上开发的工作变得容易了一些。
如果你想接着本文的步骤做下去，需要先安装 Emgo
```
cd $HOME
git clone https://github.com/ziutek/emgo/
cd emgo/egc
go install
```
然后设置一下环境变量
```
export EGCC=path_to_arm_gcc # eg. /usr/local/arm/bin/arm-none-eabi-gcc
export EGLD=path_to_arm_linker # eg. /usr/local/arm/bin/arm-none-eabi-ld
export EGAR=path_to_arm_archiver # eg. /usr/local/arm/bin/arm-none-eabi-ar
export EGROOT=$HOME/emgo/egroot
export EGPATH=$HOME/emgo/egpath
export EGARCH=cortexm0
export EGOS=noos
export EGTARGET=f030x6
```
更详细的说明可以在 [Emgo](https://github.com/ziutek/emgo) 官网上找到。
要确保 `egc` 在你的 `PATH` 中。 你可以使用 `go build` 来代替 `go install`，然后把 `egc` 复制到你的 `$HOME/bin` 或 `/usr/local/bin` 中。
现在，为你的第一个 Emgo 程序创建一个新文件夹，随后把示例中链接器脚本复制过来：
```
mkdir $HOME/firstemgo
cd $HOME/firstemgo
cp $EGPATH/src/stm32/examples/f030-demo-board/blinky/script.ld .
```
### 最基本程序
在 `main.go` 文件中创建一个最基本的程序：
```
package main
func main() {
}
```
文件编译没有出现任何问题：
```
$ egc
$ arm-none-eabi-size cortexm0.elf
text data bss dec hex filename
7452 172 104 7728 1e30 cortexm0.elf
```
第一次编译可能会花点时间。编译后产生的二进制占用了 7624 个字节的 Flash 空间（文本 + 数据）。对于一个什么都没做的程序来说，占用的空间有些大。还剩下 8760 字节，可以用来做些有用的事。
不妨试试传统的 “Hello, World!” 程序：
```
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
```
不幸的是，这次结果有些糟糕：
```
$ egc
/usr/local/arm/bin/arm-none-eabi-ld: /home/michal/P/go/src/github.com/ziutek/emgo/egpath/src/stm32/examples/f030-demo-board/blog/cortexm0.elf section `.text' will not fit in region `Flash'
/usr/local/arm/bin/arm-none-eabi-ld: region `Flash' overflowed by 10880 bytes
exit status 1
```
“Hello, World!” 需要 STM32F030x6 上至少 32KB 的 Flash 空间。
`fmt` 包强制包含整个 `strconv` 和 `reflect` 包。这三个包，即使在精简版本中的 Emgo 中，占用空间也很大。我们不能使用这个例子了。有很多的应用不需要好看的文本输出。通常，一个或多个 LED，或者七段数码管显示就足够了。不过，在第二部分，我会尝试使用 `strconv` 包来格式化，并在 UART 上显示一些数字和文本。
### 闪烁
我们的开发板上有一个与 PA4 引脚和 VCC 相连的 LED。这次我们的代码稍稍长了一些：
```
package main
import (
"delay"
"stm32/hal/gpio"
"stm32/hal/system"
"stm32/hal/system/timer/systick"
)
var led gpio.Pin
func init() {
system.SetupPLL(8, 1, 48/8)
systick.Setup(2e6)
gpio.A.EnableClock(false)
led = gpio.A.Pin(4)
cfg := &gpio.Config{Mode: gpio.Out, Driver: gpio.OpenDrain}
led.Setup(cfg)
}
func main() {
for {
led.Clear()
delay.Millisec(100)
led.Set()
delay.Millisec(900)
}
}
```
按照惯例，`init` 函数用来初始化和配置外设。
`system.SetupPLL(8, 1, 48/8)` 用来配置 RCC，将外部的 8 MHz 振荡器的 PLL 作为系统时钟源。PLL 分频器设置为 1，倍频数设置为 48/8 =6，这样系统时钟频率为 48MHz。
`systick.Setup(2e6)` 将 Cortex-M SYSTICK 时钟作为系统时钟，每隔 2e6 次纳秒运行一次（每秒钟 500 次）。
`gpio.A.EnableClock(false)` 开启了 GPIO A 口的时钟。`False` 意味着这一时钟在低功耗模式下会被禁用，但在 STM32F0 系列中并未实现这一功能。
`led.Setup(cfg)` 设置 PA4 引脚为开漏输出。
`led.Clear()` 将 PA4 引脚设为低，在开漏设置中，打开 LED。
`led.Set()` 将 PA4 设为高电平状态，关掉LED。
编译这个代码：
```
$ egc
$ arm-none-eabi-size cortexm0.elf
text data bss dec hex filename
9772 172 168 10112 2780 cortexm0.elf
```
正如你所看到的，这个闪烁程序占用了 2320 字节，比最基本程序占用空间要大。还有 6440 字节的剩余空间。
看看代码是否能运行：
```
$ openocd -d0 -f interface/stlink.cfg -f target/stm32f0x.cfg -c 'init; program cortexm0.elf; reset run; exit'
Open On-Chip Debugger 0.10.0+dev-00319-g8f1f912a (2018-03-07-19:20)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
debug_level: 0
adapter speed: 1000 kHz
adapter_nsrst_delay: 100
none separate
adapter speed: 950 kHz
target halted due to debug-request, current mode: Thread
xPSR: 0xc1000000 pc: 0x0800119c msp: 0x20000da0
adapter speed: 4000 kHz
** Programming Started **
auto erase enabled
target halted due to breakpoint, current mode: Thread
xPSR: 0x61000000 pc: 0x2000003a msp: 0x20000da0
wrote 10240 bytes from file cortexm0.elf in 0.817425s (12.234 KiB/s)
** Programming Finished **
adapter speed: 950 kHz
```
在这篇文章中，这是我第一次，将一个短视频转换成[动画 PNG](https://en.wikipedia.org/wiki/APNG)。我对此印象很深，再见了 YouTube。 对于 IE 用户，我很抱歉，更多信息请看 [apngasm](http://apngasm.sourceforge.net/)。我本应该学习 HTML5，但现在，APNG 是我最喜欢的，用来播放循环短视频的方法了。
### 更多的 Go 语言编程
如果你不是一个 Go 程序员，但你已经听说过一些关于 Go 语言的事情，你可能会说：“Go 语法很好，但跟 C 比起来，并没有明显的提升。让我看看 Go 语言的通道和协程！”
接下来我会一一展示:
```
import (
"delay"
"stm32/hal/gpio"
"stm32/hal/system"
"stm32/hal/system/timer/systick"
)
var led1, led2 gpio.Pin
func init() {
system.SetupPLL(8, 1, 48/8)
systick.Setup(2e6)
gpio.A.EnableClock(false)
led1 = gpio.A.Pin(4)
led2 = gpio.A.Pin(5)
cfg := &gpio.Config{Mode: gpio.Out, Driver: gpio.OpenDrain}
led1.Setup(cfg)
led2.Setup(cfg)
}
func blinky(led gpio.Pin, period int) {
for {
led.Clear()
delay.Millisec(100)
led.Set()
delay.Millisec(period - 100)
}
}
func main() {
go blinky(led1, 500)
blinky(led2, 1000)
}
```
代码改动很小: 添加了第二个 LED，上一个例子中的 `main` 函数被重命名为 `blinky` 并且需要提供两个参数。 `main` 在新的协程中先调用 `blinky`，所以两个 LED 灯在并行使用。值得一提的是，`gpio.Pin` 可以同时访问同一 GPIO 口的不同引脚。
Emgo 还有很多不足。其中之一就是你需要提前规定 `goroutines(tasks)` 的最大执行数量。是时候修改 `script.ld` 了:
```
ISRStack = 1024;
MainStack = 1024;
TaskStack = 1024;
MaxTasks = 2;
INCLUDE stm32/f030x4
INCLUDE stm32/loadflash
INCLUDE noos-cortexm
```
栈的大小需要靠猜，现在还不用关心这一点。
```
$ egc
$ arm-none-eabi-size cortexm0.elf
text data bss dec hex filename
10020 172 172 10364 287c cortexm0.elf
```
另一个 LED 和协程一共占用了 248 字节的 Flash 空间。
### 通道
通道是 Go 语言中协程之间相互通信的一种[推荐方式](https://blog.golang.org/share-memory-by-communicating)。Emgo 甚至能允许通过*中断处理*来使用缓冲通道。下一个例子就展示了这种情况。
```
package main
import (
"delay"
"rtos"
"stm32/hal/gpio"
"stm32/hal/irq"
"stm32/hal/system"
"stm32/hal/system/timer/systick"
"stm32/hal/tim"
)
var (
leds [3]gpio.Pin
timer *tim.Periph
ch = make(chan int, 1)
)
func init() {
system.SetupPLL(8, 1, 48/8)
systick.Setup(2e6)
gpio.A.EnableClock(false)
leds[0] = gpio.A.Pin(4)
leds[1] = gpio.A.Pin(5)
leds[2] = gpio.A.Pin(9)
cfg := &gpio.Config{Mode: gpio.Out, Driver: gpio.OpenDrain}
for _, led := range leds {
led.Set()
led.Setup(cfg)
}
timer = tim.TIM3
pclk := timer.Bus().Clock()
if pclk < system.AHB.Clock() {
pclk *= 2
}
freq := uint(1e3) // Hz
timer.EnableClock(true)
timer.PSC.Store(tim.PSC(pclk/freq - 1))
timer.ARR.Store(700) // ms
timer.DIER.Store(tim.UIE)
timer.CR1.Store(tim.CEN)
rtos.IRQ(irq.TIM3).Enable()
}
func blinky(led gpio.Pin, period int) {
for range ch {
led.Clear()
delay.Millisec(100)
led.Set()
delay.Millisec(period - 100)
}
}
func main() {
go blinky(leds[1], 500)
blinky(leds[2], 500)
}
func timerISR() {
timer.SR.Store(0)
leds[0].Set()
select {
case ch <- 0:
// Success
default:
leds[0].Clear()
}
}
//c:__attribute__((section(".ISRs")))
var ISRs = [...]func(){
irq.TIM3: timerISR,
}
```
与之前例子相比较下的不同:
1. 添加了第三个 LED，并连接到 PA9 引脚（UART 头的 TXD 引脚）。
2. 时钟（`TIM3`）作为中断源。
3. 新函数 `timerISR` 用来处理 `irq.TIM3` 的中断。
4. 新增容量为 1 的缓冲通道是为了 `timerISR` 和 `blinky` 协程之间的通信。
5. `ISRs` 数组作为*中断向量表*，是更大的*异常向量表*的一部分。
6. `blinky` 中的 `for` 语句被替换成 `range` 语句。
为了方便起见，所有的 LED，或者说它们的引脚，都被放在 `leds` 这个数组里。另外，所有引脚在被配置为输出之前，都设置为一种已知的初始状态（高电平状态）。
在这个例子里，我们想让时钟以 1 kHz 的频率运行。为了配置 TIM3 预分频器，我们需要知道它的输入时钟频率。通过参考手册我们知道，输入时钟频率在 `APBCLK = AHBCLK` 时，与 `APBCLK` 相同，反之等于 2 倍的 `APBCLK`。
如果 CNT 寄存器增加 1 kHz，那么 ARR 寄存器的值等于*更新事件*（重载事件）在毫秒中的计数周期。 为了让更新事件产生中断，必须要设置 DIER 寄存器中的 UIE 位。CEN 位能启动时钟。
时钟外设在低功耗模式下必须启用，为了自身能在 CPU 处于休眠时保持运行: `timer.EnableClock(true)`。这在 STM32F0 中无关紧要，但对代码可移植性却十分重要。
`timerISR` 函数处理 `irq.TIM3` 的中断请求。`timer.SR.Store(0)` 会清除 SR 寄存器里的所有事件标志，无效化向 [NVIC](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0432c/Cihbecee.html) 发出的所有中断请求。凭借经验，由于中断请求无效的延时性，需要在程序一开始马上清除所有的中断标志。这避免了无意间再次调用处理。为了确保万无一失，需要先清除标志，再读取，但是在我们的例子中，清除标志就已经足够了。
下面的这几行代码：
```
select {
case ch <- 0:
// Success
default:
leds[0].Clear()
}
```
是 Go 语言中，如何在通道上非阻塞地发送消息的方法。中断处理程序无法一直等待通道中的空余空间。如果通道已满，则执行 `default`，开发板上的LED就会开启，直到下一次中断。
`ISRs` 数组包含了中断向量表。`//c:__attribute__((section(".ISRs")))` 会导致链接器将数组插入到 `.ISRs` 节中。
`blinky` 的 `for` 循环的新写法：
```
for range ch {
led.Clear()
delay.Millisec(100)
led.Set()
delay.Millisec(period - 100)
}
```
等价于：
```
for {
_, ok := <-ch
if !ok {
break // Channel closed.
}
led.Clear()
delay.Millisec(100)
led.Set()
delay.Millisec(period - 100)
}
```
注意，在这个例子中，我们不在意通道中收到的值，我们只对其接受到的消息感兴趣。我们可以在声明时，将通道元素类型中的 `int` 用空结构体 `struct{}` 来代替，发送消息时，用 `struct{}{}` 结构体的值代替 0，但这部分对新手来说可能会有些陌生。
让我们来编译一下代码:
```
$ egc
$ arm-none-eabi-size cortexm0.elf
text data bss dec hex filename
11096 228 188 11512 2cf8 cortexm0.elf
```
新的例子占用了 11324 字节的 Flash 空间，比上一个例子多占用了 1132 字节。
采用现在的时序，两个闪烁协程从通道中获取数据的速度，比 `timerISR` 发送数据的速度要快。所以它们在同时等待新数据，你还能观察到 `select` 的随机性，这也是 [Go 规范](https://golang.org/ref/spec#Select_statements)所要求的。
开发板上的 LED 一直没有亮起，说明通道从未出现过溢出。
我们可以加快消息发送的速度，将 `timer.ARR.Store(700)` 改为 `timer.ARR.Store(200)`。 现在 `timerISR` 每秒钟发送 5 条消息，但是两个接收者加起来，每秒也只能接受 4 条消息。
正如你所看到的，`timerISR` 开启黄色 LED 灯，意味着通道上已经没有剩余空间了。
第一部分到这里就结束了。你应该知道，这一部分并未展示 Go 中最重要的部分，接口。
协程和通道只是一些方便好用的语法。你可以用自己的代码来替换它们，这并不容易，但也可以实现。接口是Go 语言的基础。这是文章中 [第二部分](https://ziutek.github.io/2018/04/14/go_on_very_small_hardware2.html)所要提到的.
在 Flash 上我们还有些剩余空间。
---
via: <https://ziutek.github.io/2018/03/30/go_on_very_small_hardware.html>
作者：[Michał Derkacz](https://ziutek.github.io/) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
如何冻结和锁定你的 Linux 系统 | Sandra Henry-stocker | https://www.networkworld.com/article/3438818/how-to-freeze-and-lock-your-linux-system-and-why-you-would-want-to.html | 冻结终端窗口并锁定屏幕意味着什么 - 以及如何在 Linux 系统上管理这些活动。 | /data/attachment/album/201909/24/230938vgxzv3nrakk0wxnw.jpg.thumb.jpg | /data/attachment/album/201909/24/230938vgxzv3nrakk0wxnw.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"冻结",
"锁定"
] | 桌面应用 | {
"viewnum": 9899,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 冻结终端窗口并锁定屏幕意味着什么 - 以及如何在 Linux 系统上管理这些活动。 | 2019-09-24T23:10:13 | 2019-09-24T23:10:13 | 11,384 | /article-11384-1.html |
>
> 冻结终端窗口并锁定屏幕意味着什么 - 以及如何在 Linux 系统上管理这些活动。
>
>
>
如何在 Linux 系统上冻结和“解冻”屏幕，很大程度上取决于这些术语的含义。有时“冻结屏幕”可能意味着冻结终端窗口，以便该窗口内的活动停止。有时它意味着锁定屏幕，这样就没人可以在你去拿一杯咖啡时，走到你的系统旁边代替你输入命令了。
在这篇文章中，我们将研究如何使用和控制这些操作。
### 如何在 Linux 上冻结终端窗口
你可以输入 `Ctrl+S`（按住 `Ctrl` 键和 `s` 键）冻结 Linux 系统上的终端窗口。把 `s` 想象成“<ruby> 开始冻结 <rt> start the freeze </rt></ruby>”。如果在此操作后继续输入命令，那么你不会看到输入的命令或你希望看到的输出。实际上，命令将堆积在一个队列中，并且只有在通过输入 `Ctrl+Q` 解冻时才会运行。把它想象成“<ruby> 退出冻结 <rt> quit the freeze </rt></ruby>”。
查看其工作的一种简单方式是使用 `date` 命令，然后输入 `Ctrl+S`。接着再次输入 `date` 命令并等待几分钟后再次输入 `Ctrl+Q`。你会看到这样的情景：
```
$ date
Mon 16 Sep 2019 06:47:34 PM EDT
$ date
Mon 16 Sep 2019 06:49:49 PM EDT
```
这两次时间显示的差距表示第二次的 `date` 命令直到你解冻窗口时才运行。
无论你是坐在计算机屏幕前还是使用 PuTTY 等工具远程运行，终端窗口都可以冻结和解冻。
这有一个可以派上用场的小技巧。如果你发现终端窗口似乎处于非活动状态，那么可能是你或其他人无意中输入了 `Ctrl+S`。那么，输入 `Ctrl+Q` 来尝试解决不妨是个不错的办法。
### 如何锁定屏幕
要在离开办公桌前锁定屏幕，请按住 `Ctrl+Alt+L` 或 `Super+L`（即按住 `Windows` 键和 `L` 键）。屏幕锁定后，你必须输入密码才能重新登录。
### Linux 系统上的自动屏幕锁定
虽然最佳做法建议你在即将离开办公桌时锁定屏幕，但 Linux 系统通常会在一段时间没有活动后自动锁定。 “消隐”屏幕（使其变暗）并实际锁定屏幕（需要登录才能再次使用）的时间取决于你个人首选项中的设置。
要更改使用 GNOME 屏幕保护程序时屏幕变暗所需的时间，请打开设置窗口并选择 “Power” 然后 “Blank screen”。你可以选择 1 到 15 分钟或从不变暗。要选择屏幕变暗后锁定所需时间，请进入设置，选择 “Privacy”，然后选择 “Blank screen”。设置应包括 1、2、3、5 和 30 分钟或一小时。
### 如何在命令行锁定屏幕
如果你使用的是 GNOME 屏幕保护程序，你还可以使用以下命令从命令行锁定屏幕：
```
gnome-screensaver-command -l
```
这里是小写的 L，代表“锁定”。
### 如何检查锁屏状态
你还可以使用 `gnome-screensaver` 命令检查屏幕是否已锁定。使用 `--query` 选项，该命令会告诉你屏幕当前是否已锁定（即处于活动状态）。使用 `--time` 选项，它会告诉你锁定生效的时间。这是一个示例脚本：
```
#!/bin/bash
gnome-screensaver-command --query
gnome-screensaver-command --time
```
运行脚本将会输出：
```
$ ./check_lockscreen
The screensaver is active
The screensaver has been active for 1013 seconds.
```
#### 总结
如果你记住了正确的控制方式，那么锁定终端窗口是很简单的。对于屏幕锁定，它的效果取决于你自己的设置，或者你是否习惯使用默认设置。
---
via: <https://www.networkworld.com/article/3438818/how-to-freeze-and-lock-your-linux-system-and-why-you-would-want-to.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
ML in Google：回望 Google 开发者大会 2019 | Bestony | Google 的技术不如从前了么？显然不是，从今年的 Tensorflow Dev Summit ，到 Google I/O 2019 ，Google 给我们的惊艳从未少过。 | /data/attachment/album/201909/25/082041ridgi177sccsd0nd.jpg.thumb.jpg | /data/attachment/album/201909/25/082041ridgi177sccsd0nd.jpg | true | false | false | false | [
"Google"
] | 观点 | {
"viewnum": 3618,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Google 的技术不如从前了么？显然不是，从今年的 Tensorflow Dev Summit ，到 Google I/O 2019 ，Google 给我们的惊艳从未少过。 | 2019-09-25T08:24:47 | 2019-09-25T08:24:47 | 11,385 | /article-11385-1.html | 
Google 开发者大会已经结束一周有余，我的心情也从参会两天的跌宕起伏变得平稳了一些，便趁着这个机会，写一篇会后评论，在摆脱了体验的层面上，重看 Google 开发者大会 2019。
### 四年来的变与不变
Google 开发者大会在上海举办，这已经是连续的第四年了，从 2016 年，一直到 2019 年，四年过去了，我们不妨看看， Google 开发者大会发生了哪些变化。
在 2016 年，Google 开发者大会的 Keywords 是 Android 、Firebase、Angular、Mobile Web、Google Play 、Ads 和 What‘s next。
在 2017 年，Google 开发者大会的 Keywords 变成了 PWA & AMP、Tensorflow、Firebase、Kotlin、Android ，此外，2017 年，Flutter 有了自己的第一场演讲：「Rapidly build beautiful mobile apps with Flutter」， AR Core 也在这一年的 Google 开发者大会上，崭露头角。
到了 2018 年，Google 开发者大会的 Keywords 是 Tensorflow、Firebase、ARCore、Flutter。
而今年的 2019 年，主角只有一个，那就是 Tensorflow ，其他的诸如 Firebase、ARCore、Flutter 虽然也占据了不小的篇幅，但和 Tensorflow 相比，差距还是不小。
**四年来， Google 开发者大会的关键词变得越来越简单，技术也变得越来越专业。但演讲的标题，却看起来越来越接地气**。以往的大会往往讨论的是技术实现的细节，如今的大会，分享的更多是 Google 能力如何与产品、业界所结合。过去的内容往往是通过跑分来对比，如今的内容则更多是介绍能力是如何被企业所使用，改变了企业的工作模式。四年来，Google 开发者大会的内容从纯英文，到如今的中文 Topic 层出不穷，曾经傲娇的 Google 也变得越来越亲近中国开发者。
**Google 的技术不如从前了么？显然不是，从今年的 Tensorflow Dev Summit ，到 Google I/O 2019 ，Google 给我们的惊艳从未少过**，只是不同的是，如今的 Google 不再是那个强调自己的技术多么先进的技术公司了，而是一个更加强调 Google 如何改变世界，如何帮助企业获得成长的产品型公司了，显然， Google 更加成熟了，它明白，**技术本身只是工具，技术的出现，是为了改变我们的生活，让我们的生活、工作变得更加美好**。
### 2019 in 机器学习
如果说今年的大会最核心的是什么，那莫过于 机器学习 了，从无处不在的 机器学习 产品，到第二天数十场的 Tensorflow 专场演讲，无一不表明了本次大会的主角，就是 Tensorflow。
Google 在本次大会中，投注了大量的精力去分享和介绍，如何使用 Tensorflow ，如何应用 Tensorflow ，还介绍了一些国内的企业对于 Tensorflow 的应用，以启发开发者使用 Tensorflow 。针对国内所独有的微信小程序业态， Google 的 Tensorflow.js 也提供了相关的适配，帮助开发者更低成本的使用 Tensorflow ，在自己的应用中接入和应用机器学习。
除了技术，在会场中还可以看到大量的体验性质的项目，这些体验性质的项目看似是创意，背后却是来自 TensorFlow 机器学习能力的产品化，这些体验项目不再是简简单单的介绍 TensorFlow 到底有多么强大，而是用产品告诉你，机器学习、TensorFlow 能够为你的产品赋能多少。这种思路的转变，也正是机器学习不断落地到应用场景的实例。在过去，我们没有足够的产品时，不得不以应用跑分来做对比，但当应用已经足够好的时候，应用已经足以说明一切。
除了基础的 机器学习 能力，我们也看到， 机器学习与 Google 的其他服务是如何一同对外提供服务，在 Google 的 Analytics 服务、Firebase 服务等产品中，看似与 机器学习 无关的应用，背后却都是隐含着 机器学习 的逻辑，借助 机器学习 来帮助 Google 提高服务的水平和水准，让用户可以与 Google 共同前进，取得双赢。
**在 2019 年， 机器学习已经不再是一个热词，取而代之的，是各企业默默的将机器学习的能力引入到自己的产品中，默默的为用户提供着服务。在 2019 年，技术不再是 机器学习 的核心，如何将技术产品的价值，迁移到产品上，转换成用户触手可及的产品，才是真正的核心。这里， Google 为大家做了榜样。**
### Grow 、Grow 、Grow
在本次大会中，最令我惊喜的，莫过于 Grow With Google 这个项目。身处一个日新月异的行业，学习成为我们永恒的话题，但是，学什么、如何学，却是我们一直都没有搞清楚的问题。
在竞争日益白热化的中国，我们恐惧自己被甩下，却因为没有合适的内容，日复一日的学习着技术内容。但是我一直认为，社会是复杂的，生活是复杂的，工作是复杂的，我们凭什么认为我们掌握的简单技能，能够解决一个复杂问题呢？
Grow With Google 并不是一个简单的在线课程的项目，而是一个新的可能，在 Grow With Google 中，它提供了针对教师、个体户、学生和求职者、开发者、初创公司等不同角色下的教育内容，帮助你以最快的方式，完成角色的转变，这种改变自己人生的机会并不多，如今 Google 又提供了一种新的可能，对于焦虑的我们来说，这获取是一剂良药。
**让我们自己变得更复杂，拥有更多的可能，或许能够帮助我们，走出知识焦虑的怪圈**。
### 总结
Google 开发者大会值得去么？当然值得，去大会并不是为了去看技术的细节，实际上，这些内容在官方文档中，你可能找到更加细致的内容。大会真正带给你的价值，是帮助你拥有一个全新的视角，以不同的视角，来看待这个世界、看待你所遇见的问题。以一种 Google 范的方式，帮助你解决你自己的问题，更好的看清这个世界。
|
||||
用于测量磁盘活动的 Linux 命令 | Sandra Henry-stocker | https://www.networkworld.com/article/3330497/linux/linux-commands-for-measuring-disk-activity.html | Linux 发行版提供了几个度量磁盘活动的有用命令。让我们了解一下其中的几个。 | /data/attachment/album/201909/25/092250rlzdj83cjbddvoud.jpg.thumb.jpg | /data/attachment/album/201909/25/092250rlzdj83cjbddvoud.jpg | true | false | true | lujun9972 | laingke | wxy | false | [
"磁盘"
] | 技术 | {
"viewnum": 6792,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | Linux 发行版提供了几个度量磁盘活动的有用命令。让我们了解一下其中的几个。 | 2019-09-25T09:21:00 | 2019-09-25T09:21:00 | 11,387 | /article-11387-1.html |
>
> Linux 发行版提供了几个度量磁盘活动的有用命令。让我们了解一下其中的几个。
>
>
>
Linux 系统提供了一套方便的命令，帮助你查看磁盘有多忙，而不仅仅是磁盘有多满。在本文中，我们将研究五个非常有用的命令，用于查看磁盘活动。其中两个命令（`iostat` 和 `ioping`）可能必须添加到你的系统中，这两个命令一样要求你使用 sudo 特权，所有这五个命令都提供了查看磁盘活动的有用方法。
这些命令中最简单、最直观的一个可能是 `dstat` 了。
### dtstat
尽管 `dstat` 命令以字母 “d” 开头，但它提供的统计信息远远不止磁盘活动。如果你只想查看磁盘活动，可以使用 `-d` 选项。如下所示，你将得到一个磁盘读/写测量值的连续列表，直到使用 `CTRL-c` 停止显示为止。注意，在第一个报告信息之后，显示中的每个后续行将在接下来的时间间隔内报告磁盘活动，缺省值仅为一秒。
```
$ dstat -d
-dsk/total-
read writ
949B 73k
65k 0 <== first second
0 24k <== second second
0 16k
0 0 ^C
```
在 `-d` 选项后面包含一个数字将把间隔设置为该秒数。
```
$ dstat -d 10
-dsk/total-
read writ
949B 73k
65k 81M <== first five seconds
0 21k <== second five second
0 9011B ^C
```
请注意，报告的数据可能以许多不同的单位显示——例如，M（Mb）、K（Kb）和 B（字节）。
如果没有选项，`dstat` 命令还将显示许多其他信息——指示 CPU 如何使用时间、显示网络和分页活动、报告中断和上下文切换。
```
$ dstat
You did not select any stats, using -cdngy by default.
--total-cpu-usage-- -dsk/total- -net/total- ---paging-- ---system--
usr sys idl wai stl| read writ| recv send| in out | int csw
0 0 100 0 0| 949B 73k| 0 0 | 0 3B| 38 65
0 0 100 0 0| 0 0 | 218B 932B| 0 0 | 53 68
0 1 99 0 0| 0 16k| 64B 468B| 0 0 | 64 81 ^C
```
`dstat` 命令提供了关于整个 Linux 系统性能的有价值的见解，几乎可以用它灵活而功能强大的命令来代替 `vmstat`、`netstat`、`iostat` 和 `ifstat` 等较旧的工具集合，该命令结合了这些旧工具的功能。要深入了解 `dstat` 命令可以提供的其它信息，请参阅这篇关于 [dstat](https://www.networkworld.com/article/3291616/linux/examining-linux-system-performance-with-dstat.html) 命令的文章。
### iostat
`iostat` 命令通过观察设备活动的时间与其平均传输速率之间的关系，帮助监视系统输入/输出设备的加载情况。它有时用于评估磁盘之间的活动平衡。
```
$ iostat
Linux 4.18.0-041800-generic (butterfly) 12/26/2018 _x86_64_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
0.07 0.01 0.03 0.05 0.00 99.85
Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn
loop0 0.00 0.00 0.00 1048 0
loop1 0.00 0.00 0.00 365 0
loop2 0.00 0.00 0.00 1056 0
loop3 0.00 0.01 0.00 16169 0
loop4 0.00 0.00 0.00 413 0
loop5 0.00 0.00 0.00 1184 0
loop6 0.00 0.00 0.00 1062 0
loop7 0.00 0.00 0.00 5261 0
sda 1.06 0.89 72.66 2837453 232735080
sdb 0.00 0.02 0.00 48669 40
loop8 0.00 0.00 0.00 1053 0
loop9 0.01 0.01 0.00 18949 0
loop10 0.00 0.00 0.00 56 0
loop11 0.00 0.00 0.00 7090 0
loop12 0.00 0.00 0.00 1160 0
loop13 0.00 0.00 0.00 108 0
loop14 0.00 0.00 0.00 3572 0
loop15 0.01 0.01 0.00 20026 0
loop16 0.00 0.00 0.00 24 0
```
当然，当你只想关注磁盘时，Linux 回环设备上提供的所有统计信息都会使结果显得杂乱无章。不过，该命令也确实提供了 `-p` 选项，该选项使你可以仅查看磁盘——如以下命令所示。
```
$ iostat -p sda
Linux 4.18.0-041800-generic (butterfly) 12/26/2018 _x86_64_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
0.07 0.01 0.03 0.05 0.00 99.85
Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn
sda 1.06 0.89 72.54 2843737 232815784
sda1 1.04 0.88 72.54 2821733 232815784
```
请注意 `tps` 是指每秒的传输量。
你还可以让 `iostat` 提供重复的报告。在下面的示例中，我们使用 `-d` 选项每五秒钟进行一次测量。
```
$ iostat -p sda -d 5
Linux 4.18.0-041800-generic (butterfly) 12/26/2018 _x86_64_ (2 CPU)
Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn
sda 1.06 0.89 72.51 2843749 232834048
sda1 1.04 0.88 72.51 2821745 232834048
Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn
sda 0.80 0.00 11.20 0 56
sda1 0.80 0.00 11.20 0 56
```
如果你希望省略第一个（自启动以来的统计信息）报告，请在命令中添加 `-y`。
```
$ iostat -p sda -d 5 -y
Linux 4.18.0-041800-generic (butterfly) 12/26/2018 _x86_64_ (2 CPU)
Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn
sda 0.80 0.00 11.20 0 56
sda1 0.80 0.00 11.20 0 56
```
接下来，我们看第二个磁盘驱动器。
```
$ iostat -p sdb
Linux 4.18.0-041800-generic (butterfly) 12/26/2018 _x86_64_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
0.07 0.01 0.03 0.05 0.00 99.85
Device tps kB_read/s kB_wrtn/s kB_read kB_wrtn
sdb 0.00 0.02 0.00 48669 40
sdb2 0.00 0.00 0.00 4861 40
sdb1 0.00 0.01 0.00 35344 0
```
### iotop
`iotop` 命令是类似 `top` 的实用程序，用于查看磁盘 I/O。它收集 Linux 内核提供的 I/O 使用信息，以便你了解哪些进程在磁盘 I/O 方面的要求最高。在下面的示例中，循环时间被设置为 5 秒。显示将自动更新，覆盖前面的输出。
```
$ sudo iotop -d 5
Total DISK READ: 0.00 B/s | Total DISK WRITE: 1585.31 B/s
Current DISK READ: 0.00 B/s | Current DISK WRITE: 12.39 K/s
TID PRIO USER DISK READ DISK WRITE SWAPIN IO> COMMAND
32492 be/4 root 0.00 B/s 0.00 B/s 0.00 % 0.12 % [kworker/u8:1-ev~_power_efficient]
208 be/3 root 0.00 B/s 1585.31 B/s 0.00 % 0.11 % [jbd2/sda1-8]
1 be/4 root 0.00 B/s 0.00 B/s 0.00 % 0.00 % init splash
2 be/4 root 0.00 B/s 0.00 B/s 0.00 % 0.00 % [kthreadd]
3 be/0 root 0.00 B/s 0.00 B/s 0.00 % 0.00 % [rcu_gp]
4 be/0 root 0.00 B/s 0.00 B/s 0.00 % 0.00 % [rcu_par_gp]
8 be/0 root 0.00 B/s 0.00 B/s 0.00 % 0.00 % [mm_percpu_wq]
```
### ioping
`ioping` 命令是一种完全不同的工具，但是它可以报告磁盘延迟——也就是磁盘响应请求需要多长时间，而这有助于诊断磁盘问题。
```
$ sudo ioping /dev/sda1
4 KiB <<< /dev/sda1 (block device 111.8 GiB): request=1 time=960.2 us (warmup)
4 KiB <<< /dev/sda1 (block device 111.8 GiB): request=2 time=841.5 us
4 KiB <<< /dev/sda1 (block device 111.8 GiB): request=3 time=831.0 us
4 KiB <<< /dev/sda1 (block device 111.8 GiB): request=4 time=1.17 ms
^C
--- /dev/sda1 (block device 111.8 GiB) ioping statistics ---
3 requests completed in 2.84 ms, 12 KiB read, 1.05 k iops, 4.12 MiB/s
generated 4 requests in 3.37 s, 16 KiB, 1 iops, 4.75 KiB/s
min/avg/max/mdev = 831.0 us / 947.9 us / 1.17 ms / 158.0 us
```
### atop
`atop` 命令，像 `top` 一样提供了大量有关系统性能的信息，包括有关磁盘活动的一些统计信息。
```
ATOP - butterfly 2018/12/26 17:24:19 37d3h13m------ 10ed
PRC | sys 0.03s | user 0.01s | #proc 179 | #zombie 0 | #exit 6 |
CPU | sys 1% | user 0% | irq 0% | idle 199% | wait 0% |
cpu | sys 1% | user 0% | irq 0% | idle 99% | cpu000 w 0% |
CPL | avg1 0.00 | avg5 0.00 | avg15 0.00 | csw 677 | intr 470 |
MEM | tot 5.8G | free 223.4M | cache 4.6G | buff 253.2M | slab 394.4M |
SWP | tot 2.0G | free 2.0G | | vmcom 1.9G | vmlim 4.9G |
DSK | sda | busy 0% | read 0 | write 7 | avio 1.14 ms |
NET | transport | tcpi 4 | tcpo stall 8 | udpi 1 | udpo 0swout 2255 |
NET | network | ipi 10 | ipo 7 | ipfrw 0 | deliv 60.67 ms |
NET | enp0s25 0% | pcki 10 | pcko 8 | si 1 Kbps | so 3 Kbp0.73 ms |
PID SYSCPU USRCPU VGROW RGROW ST EXC THR S CPUNR CPU CMD 1/1673e4 |
3357 0.01s 0.00s 672K 824K -- - 1 R 0 0% atop
3359 0.01s 0.00s 0K 0K NE 0 0 E - 0% <ps>
3361 0.00s 0.01s 0K 0K NE 0 0 E - 0% <ps>
3363 0.01s 0.00s 0K 0K NE 0 0 E - 0% <ps>
31357 0.00s 0.00s 0K 0K -- - 1 S 1 0% bash
3364 0.00s 0.00s 8032K 756K N- - 1 S 1 0% sleep
2931 0.00s 0.00s 0K 0K -- - 1 I 1 0% kworker/u8:2-e
3356 0.00s 0.00s 0K 0K -E 0 0 E - 0% <sleep>
3360 0.00s 0.00s 0K 0K NE 0 0 E - 0% <sleep>
3362 0.00s 0.00s 0K 0K NE 0 0 E - 0% <sleep>
```
如果你*只*想查看磁盘统计信息，则可以使用以下命令轻松进行管理：
```
$ atop | grep DSK
DSK | sda | busy 0% | read 122901 | write 3318e3 | avio 0.67 ms |
DSK | sdb | busy 0% | read 1168 | write 103 | avio 0.73 ms |
DSK | sda | busy 2% | read 0 | write 92 | avio 2.39 ms |
DSK | sda | busy 2% | read 0 | write 94 | avio 2.47 ms |
DSK | sda | busy 2% | read 0 | write 99 | avio 2.26 ms |
DSK | sda | busy 2% | read 0 | write 94 | avio 2.43 ms |
DSK | sda | busy 2% | read 0 | write 94 | avio 2.43 ms |
DSK | sda | busy 2% | read 0 | write 92 | avio 2.43 ms |
^C
```
### 了解磁盘 I/O
Linux 提供了足够的命令，可以让你很好地了解磁盘的工作强度，并帮助你关注潜在的问题或减缓。希望这些命令中的一个可以告诉你何时需要质疑磁盘性能。偶尔使用这些命令将有助于确保当你需要检查磁盘，特别是忙碌或缓慢的磁盘时可以显而易见地发现它们。
---
via: <https://www.networkworld.com/article/3330497/linux/linux-commands-for-measuring-disk-activity.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[laingke](https://github.com/laingke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
阿里巴巴发布第一颗自研芯片，全球最强 AI 芯片含光 800 | 阿里巴巴 | 阿里巴巴第一颗自研芯片正式问世。 | /data/attachment/album/201909/25/111206kiljinfzf9c6virc.jpg.thumb.jpg | /data/attachment/album/201909/25/111206kiljinfzf9c6virc.jpg | true | false | false | false | [
"阿里巴巴",
"芯片"
] | 新闻 | {
"viewnum": 3961,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 阿里巴巴第一颗自研芯片正式问世。 | 2019-09-25T11:18:10 | 2019-09-25T11:18:10 | 11,388 | /article-11388-1.html |
>
> 阿里巴巴第一颗自研芯片正式问世。
>
>
>
9 月 25 日的杭州云栖大会上，达摩院院长张建锋现场展示了这款全球最强的 AI 芯片——含光 800。在业界标准的 ResNet-50 测试中，含光 800 推理性能达到 78563 IPS，比目前业界最好的 AI 芯片性能高 4 倍；能效比 500 IPS/W，是第二名的 3.3 倍。
张建锋说：“在全球芯片领域，阿里巴巴是一个新人，玄铁和含光 800 是平头哥的万里长征第一步，我们还有很长的路要走。”
含光为上古三大神剑之一，该剑含而不露，光而不耀，正如含光 800 带来的无形却强劲的算力。在杭州城市大脑的业务测试中，1 颗含光 800 的算力相当于 10 颗 GPU。
含光 800 性能的突破得益于软硬件的协同创新：硬件层面采用自研芯片架构，通过推理加速等技术有效解决芯片性能瓶颈问题；软件层面集成了达摩院先进算法，针对 CNN 及视觉类算法深度优化计算、存储密度，可实现大网络模型在一颗 NPU 上完成计算。
含光 800 已开始应用在阿里巴巴内部核心业务中。根据云栖大会的现场演示，在城市大脑中实时处理杭州主城区交通视频，需要 40 颗传统 GPU，延时为 300ms，使用含光 800 仅需 4 颗，延时降至 150ms。拍立淘商品库每天新增 10 亿商品图片，使用传统 GPU 算力识别需要 1 小时，使用含光 800 后可缩减至 5 分钟。
含光 800 将通过阿里云对外输出 AI 算力。基于含光 800 的 AI 云服务当天正式上线，相比传统 GPU 算力，性价比提升 100%。
过去半年，平头哥先后发布玄铁 910、无剑 SoC 平台。随着含光 800 的发布，平头哥端云一体全栈产品系列初步成型，涵盖处理器IP、一站式芯片设计平台和 AI 芯片，实现了芯片设计链路的全覆盖。
|
||||
如何在 Linux 中删除文本中的回车字符 | Sandra Henry-stocker | https://www.networkworld.com/article/3438857/how-to-remove-carriage-returns-from-text-files-on-linux.html | 当回车字符（Ctrl+M）让你紧张时，别担心。有几种简单的方法消除它们。 | /data/attachment/album/201909/25/214211xenk2dqfepx3xemm.jpg.thumb.jpg | /data/attachment/album/201909/25/214211xenk2dqfepx3xemm.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"回车"
] | 技术 | {
"viewnum": 10493,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 当回车字符（Ctrl+M）让你紧张时，别担心。有几种简单的方法消除它们。 | 2019-09-25T21:42:38 | 2019-09-25T21:42:38 | 11,389 | /article-11389-1.html |
>
> 当回车字符（`Ctrl+M`）让你紧张时，别担心。有几种简单的方法消除它们。
>
>
>
“回车”字符可以往回追溯很长一段时间 —— 早在打字机上就有一个机械装置或杠杆将承载纸滚筒的机架移到右边，以便可以重新在左侧输入字母。他们在 Windows 上的文本文件上保留了它，但从未在 Linux 系统上使用过。当你尝试在 Linux 上处理在 Windows 上创建的文件时，这种不兼容性有时会导致问题，但这是一个非常容易解决的问题。
如果你使用 `od`（<ruby> 八进制转储 <rt> octal dump </rt></ruby>）命令查看文件，那么回车（也用 `Ctrl+M` 代表）字符将显示为八进制的 15。字符 `CRLF` 通常用于表示 Windows 文本文件中的一行结束的回车符和换行符序列。那些注意看八进制转储的会看到 `\r\n`。相比之下，Linux 文本仅以换行符结束。
这有一个 `od` 输出的示例，高亮显示了行中的 `CRLF` 字符，以及它的八进制。
```
$ od -bc testfile.txt
0000000 124 150 151 163 040 151 163 040 141 040 164 145 163 164 040 146
T h i s i s a t e s t f
0000020 151 154 145 040 146 162 157 155 040 127 151 156 144 157 167 163
i l e f r o m W i n d o w s
0000040 056 015 012 111 164 047 163 040 144 151 146 146 145 162 145 156 <==
. \r \n I t ' s d i f f e r e n <==
0000060 164 040 164 150 141 156 040 141 040 125 156 151 170 040 164 145
t t h a n a U n i x t e
0000100 170 164 040 146 151 154 145 015 012 167 157 165 154 144 040 142 <==
x t f i l e \r \n w o u l d b <==
```
虽然这些字符不是大问题，但是当你想要以某种方式解析文本，并且不希望就它们是否存在进行编码时，这有时候会产生干扰。
### 3 种从文本中删除回车符的方法
幸运的是，有几种方法可以轻松删除回车符。这有三个选择：
#### dos2unix
你可能会在安装时遇到麻烦，但 `dos2unix` 可能是将 Windows 文本转换为 Unix/Linux 文本的最简单方法。一个命令带上一个参数就行了。不需要第二个文件名。该文件会被直接更改。
```
$ dos2unix testfile.txt
dos2unix: converting file testfile.txt to Unix format...
```
你应该会发现文件长度减少，具体取决于它包含的行数。包含 100 行的文件可能会缩小 99 个字符，因为只有最后一行不会以 `CRLF` 字符结尾。
之前：
```
-rw-rw-r-- 1 shs shs 121 Sep 14 19:11 testfile.txt
```
之后：
```
-rw-rw-r-- 1 shs shs 118 Sep 14 19:12 testfile.txt
```
如果你需要转换大量文件，不用每次修复一个。相反，将它们全部放在一个目录中并运行如下命令：
```
$ find . -type f -exec dos2unix {} \;
```
在此命令中，我们使用 `find` 查找常规文件，然后运行 `dos2unix` 命令一次转换一个。命令中的 `{}` 将被替换为文件名。运行时，你应该处于包含文件的目录中。此命令可能会损坏其他类型的文件，例如除了文本文件外在上下文中包含八进制 15 的文件（如，镜像文件中的字节）。
#### sed
你还可以使用流编辑器 `sed` 来删除回车符。但是，你必须提供第二个文件名。以下是例子：
```
$ sed -e “s/^M//” before.txt > after.txt
```
一件需要注意的重要的事情是，请不要输入你看到的字符。你必须按下 `Ctrl+V` 后跟 `Ctrl+M` 来输入 `^M`。`s` 是替换命令。斜杠将我们要查找的文本（`Ctrl + M`）和要替换的文本（这里为空）分开。
#### vi
你甚至可以使用 `vi` 删除回车符（`Ctrl+M`），但这里假设你没有打开数百个文件，或许也在做一些其他的修改。你可以键入 `:` 进入命令行，然后输入下面的字符串。与 `sed` 一样，命令中 `^M` 需要通过 `Ctrl+V` 输入 `^`，然后 `Ctrl+M` 插入 `M`。`%s` 是替换操作，斜杠再次将我们要删除的字符和我们想要替换它的文本（空）分开。 `g`（全局）意味在所有行上执行。
```
:%s/^M//g
```
### 总结
`dos2unix` 命令可能是最容易记住的，也是从文本中删除回车的最可靠的方法。其他选择使用起来有点困难，但它们提供相同的基本功能。
---
via: <https://www.networkworld.com/article/3438857/how-to-remove-carriage-returns-from-text-files-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 RHEL8 配置静态 IP 地址的不同方法 | Pradeep Kumar | https://www.linuxtechi.com/configure-static-ip-address-rhel8/ | 在 Linux 服务器上工作时，在网卡/以太网卡上分配静态 IP 地址是每个 Linux 工程师的常见任务之一。 | /data/attachment/album/201909/25/222737dx94bbl9qbhzlfe4.jpg.thumb.jpg | /data/attachment/album/201909/25/222737dx94bbl9qbhzlfe4.jpg | true | false | true | lujun9972 | heguangzhi | wxy | false | [
"IP"
] | 系统运维 | {
"viewnum": 12756,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 在 Linux 服务器上工作时，在网卡/以太网卡上分配静态 IP 地址是每个 Linux 工程师的常见任务之一。 | 2019-09-25T22:28:00 | 2019-09-25T22:28:00 | 11,390 | /article-11390-1.html | 在 Linux 服务器上工作时，在网卡/以太网卡上分配静态 IP 地址是每个 Linux 工程师的常见任务之一。如果一个人在 Linux 服务器上正确配置了静态地址，那么他/她就可以通过网络远程访问它。在本文中，我们将演示在 RHEL 8 服务器网卡上配置静态 IP 地址的不同方法。
以下是在网卡上配置静态IP的方法：
* `nmcli`（命令行工具）
* 网络脚本文件（`ifcfg-*`）
* `nmtui`（基于文本的用户界面）
### 使用 nmcli 命令行工具配置静态 IP 地址
每当我们安装 RHEL 8 服务器时，就会自动安装命令行工具 `nmcli`，它是由网络管理器使用的，可以让我们在以太网卡上配置静态 IP 地址。
运行下面的 `ip addr` 命令，列出 RHEL 8 服务器上的以太网卡
```
[root@linuxtechi ~]# ip addr
```
正如我们在上面的命令输出中看到的，我们有两个网卡 `enp0s3` 和 `enp0s8`。当前分配给网卡的 IP 地址是通过 DHCP 服务器获得的。
假设我们希望在第一个网卡 (`enp0s3`) 上分配静态 IP 地址，具体内容如下:
* IP 地址 = 192.168.1.4
* 网络掩码 = 255.255.255.0
* 网关 = 192.168.1.1
* DNS = 8.8.8.8
依次运行以下 `nmcli` 命令来配置静态 IP，
使用 `nmcli connection` 命令列出当前活动的以太网卡，
```
[root@linuxtechi ~]# nmcli connection
NAME UUID TYPE DEVICE
enp0s3 7c1b8444-cb65-440d-9bf6-ea0ad5e60bae ethernet enp0s3
virbr0 3020c41f-6b21-4d80-a1a6-7c1bd5867e6c bridge virbr0
[root@linuxtechi ~]#
```
使用下面的 `nmcli` 给 enp0s3 分配静态 IP。
**命令语法：**
```
# nmcli connection modify <interface_name> ipv4.address <ip/prefix>
```
**注意:** 为了简化语句，在 `nmcli` 命令中，我们通常用 `con` 关键字替换 `connection`，并用 `mod` 关键字替换 `modify`。
将 IPv4 地址 (192.168.1.4) 分配给 `enp0s3` 网卡上，
```
[root@linuxtechi ~]# nmcli con mod enp0s3 ipv4.addresses 192.168.1.4/24
```
使用下面的 `nmcli` 命令设置网关，
```
[root@linuxtechi ~]# nmcli con mod enp0s3 ipv4.gateway 192.168.1.1
```
设置手动配置（从 dhcp 到 static），
```
[root@linuxtechi ~]# nmcli con mod enp0s3 ipv4.method manual
```
设置 DNS 值为 “8.8.8.8”，
```
[root@linuxtechi ~]# nmcli con mod enp0s3 ipv4.dns "8.8.8.8"
[root@linuxtechi ~]#
```
要保存上述更改并重新加载，请执行如下 `nmcli` 命令，
```
[root@linuxtechi ~]# nmcli con up enp0s3
Connection successfully activated (D-Bus active path: /org/freedesktop/NetworkManager/ActiveConnection/4)
```
以上命令显示网卡 `enp0s3` 已成功配置。我们使用 `nmcli` 命令做的那些更改都将永久保存在文件 `etc/sysconfig/network-scripts/ifcfg-enp0s3` 里。
```
[root@linuxtechi ~]# cat /etc/sysconfig/network-scripts/ifcfg-enp0s3
```
要确认 IP 地址是否分配给了 `enp0s3` 网卡了，请使用以下 IP 命令查看，
```
[root@linuxtechi ~]#ip addr show enp0s3
```
### 使用网络脚本文件（ifcfg-\*）手动配置静态 IP 地址
我们可以使用配置以太网卡的网络脚本或 `ifcfg-*` 文件来配置以太网卡的静态 IP 地址。假设我们想在第二个以太网卡 `enp0s8` 上分配静态 IP 地址：
* IP 地址 = 192.168.1.91
* 前缀 = 24
* 网关 =192.168.1.1
* DNS1 =4.2.2.2
转到目录 `/etc/sysconfig/network-scripts`，查找文件 `ifcfg-enp0s8`，如果它不存在，则使用以下内容创建它，
```
[root@linuxtechi ~]# cd /etc/sysconfig/network-scripts/
[root@linuxtechi network-scripts]# vi ifcfg-enp0s8
TYPE="Ethernet"
DEVICE="enp0s8"
BOOTPROTO="static"
ONBOOT="yes"
NAME="enp0s8"
IPADDR="192.168.1.91"
PREFIX="24"
GATEWAY="192.168.1.1"
DNS1="4.2.2.2"
```
保存并退出文件，然后重新启动网络管理器服务以使上述更改生效，
```
[root@linuxtechi network-scripts]# systemctl restart NetworkManager
```
现在使用下面的 `ip` 命令来验证 IP 地址是否分配给网卡，
```
[root@linuxtechi ~]# ip add show enp0s8
3: enp0s8: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 08:00:27:7c:bb:cb brd ff:ff:ff:ff:ff:ff
inet 192.168.1.91/24 brd 192.168.1.255 scope global noprefixroute enp0s8
valid_lft forever preferred_lft forever
inet6 fe80::a00:27ff:fe7c:bbcb/64 scope link
valid_lft forever preferred_lft forever
[root@linuxtechi ~]#
```
以上输出内容确认静态 IP 地址已在网卡 `enp0s8` 上成功配置了。
### 使用 nmtui 实用程序配置静态 IP 地址
`nmtui` 是一个基于文本用户界面的，用于控制网络的管理器，当我们执行 `nmtui` 时，它将打开一个基于文本的用户界面，通过它我们可以添加、修改和删除连接。除此之外，`nmtui` 还可以用来设置系统的主机名。
假设我们希望通过以下细节将静态 IP 地址分配给网卡 `enp0s3` ，
* IP 地址 = 10.20.0.72
* 前缀 = 24
* 网关 = 10.20.0.1
* DNS1 =4.2.2.2
运行 `nmtui` 并按照屏幕说明操作，示例如下所示，
```
[root@linuxtechi ~]# nmtui
```
选择第一个选项 “Edit a connection”，然后选择接口为 “enp0s3”，
选择 “Edit”，然后指定 IP 地址、前缀、网关和域名系统服务器 IP，
选择确定，然后点击回车。在下一个窗口中，选择 “Activate a connection”，
选择 “enp0s3”，选择 “Deactivate” 并点击回车，
现在选择 “Activate” 并点击回车，
选择 “Back”，然后选择 “Quit”，
使用下面的 `ip` 命令验证 IP 地址是否已分配给接口 `enp0s3`，
```
[root@linuxtechi ~]# ip add show enp0s3
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 08:00:27:53:39:4d brd ff:ff:ff:ff:ff:ff
inet 10.20.0.72/24 brd 10.20.0.255 scope global noprefixroute enp0s3
valid_lft forever preferred_lft forever
inet6 fe80::421d:5abf:58bd:c47e/64 scope link noprefixroute
valid_lft forever preferred_lft forever
[root@linuxtechi ~]#
```
以上输出内容显示我们已经使用 `nmtui` 实用程序成功地将静态 IP 地址分配给接口 `enp0s3`。
以上就是本教程的全部内容，我们已经介绍了在 RHEL 8 系统上为以太网卡配置 IPv4 地址的三种不同方法。请在下面的评论部分分享反馈和评论。
---
via: <https://www.linuxtechi.com/configure-static-ip-address-rhel8/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
技术如何改变敏捷的规则 | Matt Hicks | https://enterprisersproject.com/article/2018/1/how-technology-changes-rules-doing-agile | 当我们开始推行敏捷时，还没有容器和 Kubernetes。但是它们改变了过去最困难的部分：将敏捷性从小团队应用到整个组织。 | /data/attachment/album/201909/26/113910ytmoosx5tt79gan5.jpg.thumb.jpg | /data/attachment/album/201909/26/113910ytmoosx5tt79gan5.jpg | true | false | true | JayFrank | wxy | false | [
"容器"
] | 观点 | {
"viewnum": 2512,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 当我们开始推行敏捷时，还没有容器和 Kubernetes。但是它们改变了过去最困难的部分：将敏捷性从小团队应用到整个组织。 | 2019-09-26T11:39:40 | 2019-09-26T11:39:40 | 11,392 | /article-11392-1.html |
>
> 当我们开始推行敏捷时，还没有容器和 Kubernetes。但是它们改变了过去最困难的部分：将敏捷性从小团队应用到整个组织。
>
>
>
越来越多的企业正因为一个非常明显的原因开始尝试敏捷和 [DevOps](https://enterprisersproject.com/tags/devops): 企业需要通过更快的速度和更多的实验为创新和竞争性提供优势。而 DevOps 将帮助我们得到所需的创新速度。但是，在小团队或初创企业中实践 DevOps 与进行大规模实践完全是两码事。我们都明白这样的一个事实，那就是在十个人的跨职能团队中能够很好地解决问题的方案，当将相同的模式应用到一百个人的团队中时就可能无法奏效。这条道路是如此艰难，以至于 IT 领导者最简单的应对就是将敏捷方法的推行再推迟一年。
但那样的时代已经结束了。如果你已经尝试过，但是没有成功，那么现在是时候重新开始了。
到目前为止，DevOps 需要为许多组织提供个性化的解决方案，因此往往需要进行大量的调整以及付出额外的工作。但在今天，[Linux 容器](https://www.redhat.com/en/topics/containers?intcmp=701f2000000tjyaAAA)和 Kubernetes 正在推动 DevOps 工具和过程的标准化。而这样的标准化将会加速整个软件开发过程。因此，我们用来实践 DevOps 工作方式的技术最终能够满足我们加快软件开发速度的愿望。
Linux 容器和 [Kubernetes](https://www.redhat.com/en/topics/containers/what-is-kubernetes?intcmp=701f2000000tjyaAAA) 正在改变团队交互的方式。此外，你可以在 Kubernetes 平台上运行任何能够在 Linux 运行的应用程序。这意味着什么呢？你可以运行大量的企业及应用程序（甚至可以解决以前令人烦恼的 Windows 和 Linux 之间的协调问题）。最后，容器和 Kubernetes 能够满足你未来将要运行的几乎所有工作。它们正在经受着未来的考验，以应对机器学习、人工智能和分析工作等下一代解决问题工具。
让我们以机器学习为例来思考一下。今天，人们可以在大量的企业数据中找到一些模式。当机器发现这些模式时（想想机器学习），你的员工就能更快地采取行动。随着人工智能的加入，机器不仅可以发现模式，还可以对模式进行操作。如今，一个积极的软件开发冲刺周期也就是三个星期而已。有了人工智能，机器每秒可以多次修改代码。创业公司会利用这种能力来“打扰你”。
考虑一下你需要多快才能参与到竞争当中。如果你对于无法对于 DevOps 和每周一个迭代周期充满信心，那么考虑一下当那个创业公司将 AI 驱动的过程指向你时会发生什么？现在是时候转向 DevOps 的工作方式了，否则就会像你的竞争对手一样被甩在后面。
### 容器技术如何改变团队的工作？
DevOps 使得许多试图将这种工作方式扩展到更大范围的团队感到沮丧。即使许多 IT（和业务）人员之前都听说过敏捷相关的语言、框架、模型（如 DevOps），而这些都有望彻底应用程序开发和 IT 流程，但他们还是对此持怀疑态度。
向你的受众“推销”快速开发冲刺也不是一件容易的事情。想象一下，如果你以这种方式买了一栋房子 —— 你将不再需要向开发商支付固定的金额，而是会得到这样的信息：“我们将在 4 周内浇筑完地基，其成本是 X，之后再搭建房屋框架和铺设电路，但是我们现在只能够知道地基完成的时间表。”人们已经习惯了买房子的时候有一个预先的价格和交付时间表。
挑战在于构建软件与构建房屋不同。同一个建筑商往往建造了成千上万个完全相同的房子，而软件项目从来都各不相同。这是你要克服的第一个障碍。
开发和运维团队的工作方式确实不同，我之所以知道这一点是因为我曾经从事过这两方面的工作。企业往往会用不同的方式来激励他们，开发人员会因为更改和创建而获得奖励，而运维专家则会因降低成本和确保安全性而获得奖励。我们会把他们分成不同的小组，并且尽量减少互动。而这些角色通常会吸引那些思维方式完全不同的技术人员。但是这样的解决方案注定会失败，你必须打破横亘在开发和运维之间的藩篱。
想想传统情况下会发生什么。业务会把需求扔过墙，这是因为他们在“买房”模式下运作，并且说上一句“我们 9 个月后见。”开发人员根据这些需求进行开发，并根据技术约束的需要进行更改。然后，他们把它扔过墙传递给运维人员，并说一句“搞清楚如何运行这个软件”。然后，运维人员勤就会勤奋地进行大量更改，使软件与基础设施保持一致。然而，最终的结果是什么呢？
通常情况下，当业务人员看到需求实现的最终结果时甚至根本辨认不出。在过去 20 年的大部分时间里，我们一次又一次地目睹了这种模式在软件行业中上演。而现在，是时候改变了。
Linux 容器能够真正地解决这样的问题，这是因为容器弥合开发和运维之间的鸿沟。容器技术允许两个团队共同理解和设计所有的关键需求，但仍然独立地履行各自团队的职责。基本上，我们去掉了开发人员和运维人员之间的电话游戏。
有了容器技术，我们可以使得运维团队的规模更小，但依旧能够承担起数百万应用程序的运维工作，并且能够使得开发团队可以更加快速地根据需要更改软件。(在较大的组织中，所需的速度可能比运维人员的响应速度更快。)
有了容器技术，你可以将所需要交付的内容与它运行的位置分开。你的运维团队只需要负责运行容器的主机和安全的内存占用，仅此而已。这意味着什么呢？
首先，这意味着你现在可以和团队一起实践 DevOps 了。没错，只需要让团队专注于他们已经拥有的专业知识，而对于容器，只需让团队了解所需集成依赖关系的必要知识即可。
如果你想要重新训练每个人，没有人会精通所有事情。容器技术允许团队之间进行交互，但同时也会为每个团队提供一个围绕该团队优势而构建的强大边界。开发人员会知道需要消耗什么资源，但不需要知道如何使其大规模运行。运维团队了解核心基础设施，但不需要了解应用程序的细节。此外，运维团队也可以通过更新应用程序来解决新的安全问题，以免你成为下一个数据泄露的热门话题。
想要为一个大型 IT 组织，比如 30000 人的团队教授运维和开发技能？那或许需要花费你十年的时间，而你可能并没有那么多时间。
当人们谈论“构建新的云原生应用程序将帮助我们摆脱这个问题”时，请批判性地进行思考。你可以在 10 个人的团队中构建云原生应用程序，但这对《财富》杂志前 1000 强的企业而言或许并不适用。除非你不再需要依赖现有的团队，否则你无法一个接一个地构建新的微服务：你最终将成为一个孤立的组织。这是一个诱人的想法，但你不能指望这些应用程序来重新定义你的业务。我还没见过哪家公司能在如此大规模的并行开发中获得成功。IT 预算已经受到限制；在很长时间内，将预算翻倍甚至三倍是不现实的。
### 当奇迹发生时：你好，速度
Linux 容器就是为扩容而生的。一旦你开始这样做，[Kubernetes 之类的编制工具就会发挥作用](https://enterprisersproject.com/article/2017/11/how-enterprise-it-uses-kubernetes-tame-container-complexity)，这是因为你将需要运行数千个容器。应用程序将不仅仅由一个容器组成，它们将依赖于许多不同的部分，所有的部分都会作为一个单元运行在容器上。如果不这样做，你的应用程序将无法在生产环境中很好地运行。
思考一下有多少小滑轮和杠杆组合在一起来支撑你的业务，对于任何应用程序都是如此。开发人员负责应用程序中的所有滑轮和杠杆。（如果开发人员没有这些组件，你可能会在集成时做噩梦。）与此同时，无论是在线下还是在云上，运维团队都会负责构成基础设施的所有滑轮和杠杆。做一个较为抽象的比喻，使用Kubernetes，你的运维团队就可以为应用程序提供运行所需的燃料，但又不必成为所有方面的专家。
开发人员进行实验，运维团队则保持基础设施的安全和可靠。这样的组合使得企业敢于承担小风险，从而实现创新。不同于打几个孤注一掷的赌，公司中真正的实验往往是循序渐进的和快速的。
从个人经验来看，这就是组织内部发生的显著变化：因为人们说：“我们如何通过改变计划来真正地利用这种实验能力？”它会强制执行敏捷计划。
举个例子，使用 DevOps 模型、容器和 Kubernetes 的 KeyBank 如今每天都会部署代码。（观看[视频](https://www.redhat.com/en/about/videos/john-rzeszotarski-keybank-red-hat-summit-2017?intcmp=701f2000000tjyaAAA)，其中主导了 KeyBank 持续交付和反馈的 John Rzeszotarski 将解释这一变化。）类似地，Macquarie 银行也借助 DevOps 和容器技术每天将一些东西投入生产环境。
一旦你每天都推出软件，它就会改变你计划的每一个方面，并且会[加速业务的变化速度](https://enterprisersproject.com/article/2017/11/dear-cios-stop-beating-yourselves-being-behind-transformation)。Macquarie 银行和金融服务集团的 CDO，Luis Uguina 表示：“创意可以在一天内触达客户。”(参见对 Red Hat 与 Macquarie 银行合作的[案例研究](https://www.redhat.com/en/resources/macquarie-bank-case-study?intcmp=701f2000000tjyaAAA))。
### 是时候去创造一些伟大的东西了
Macquarie 的例子说明了速度的力量。这将如何改变你的经营方式？记住，Macquarie 不是一家初创企业。这是 CIO 们所面临的颠覆性力量，它不仅来自新的市场进入者，也来自老牌同行。
开发人员的自由还改变了运营敏捷商店的 CIO 们的人才方程式。突然之间，大公司里的个体（即使不是在最热门的行业或地区）也可以产生巨大的影响。Macquarie 利用这一变动作为招聘工具，并向开发人员承诺，所有新招聘的员工将会在第一周内推出新产品。
与此同时，在这个基于云的计算和存储能力的时代，我们比以往任何时候都拥有更多可用的基础设施。考虑到[机器学习和人工智能工具将很快实现的飞跃](https://enterprisersproject.com/article/2018/1/4-ai-trends-watch)，这是幸运的。
所有这些都说明现在正是打造伟大事业的好时机。考虑到市场创新的速度，你需要不断地创造伟大的东西来保持客户的忠诚度。因此，如果你一直在等待将赌注押在 DevOps 上，那么现在就是正确的时机。容器技术和 Kubernetes 改变了规则，并且对你有利。
---
via: <https://enterprisersproject.com/article/2018/1/how-technology-changes-rules-doing-agile>
作者：[Matt Hicks](https://enterprisersproject.com/user/matt-hicks) 译者：[JayFrank](https://github.com/JayFrank) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Elvish Shell 速览 | John Paul | https://itsfoss.com/elvish-shell/ | 过去这些年已经有一些新的 shell 出现来解决 Bash 中的一些缺点。Elvish 就是其中之一，我们将在今天讨论它。 | /data/attachment/album/201909/26/202622wefefhfrfr75i5ws.jpg.thumb.jpg | /data/attachment/album/201909/26/202622wefefhfrfr75i5ws.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"shell"
] | 技术 | {
"viewnum": 6983,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 过去这些年已经有一些新的 shell 出现来解决 Bash 中的一些缺点。Elvish 就是其中之一，我们将在今天讨论它。 | 2019-09-26T20:26:48 | 2019-09-26T20:26:48 | 11,393 | /article-11393-1.html | 
每个来到这里的人都会对许多系统中默认 Bash shell 有所了解（无论多少）。过去这些年已经有一些新的 shell 出现来解决 Bash 中的一些缺点。Elvish 就是其中之一，我们将在今天讨论它。
### 什么是 Elvish Shell？
[Elvish](https://elv.sh/) 不仅仅是一个 shell。它[也是](https://github.com/elves/elvish)“一种表达性编程语言”。它有许多有趣的特性，包括：
* 它是由 Go 语言编写的
* 内置文件管理器，灵感来自 [Ranger 文件管理器](https://ranger.github.io/)（`Ctrl + N`）
* 可搜索的命令历史记录（`Ctrl + R`）
* 访问的目录的历史记录（`Ctrl + L`）
* 支持结构化数据，例如列表、字典和函数的强大的管道
* 包含“一组标准的控制结构：有 `if` 条件控制、`for` 和 `while` 循环，还有 `try` 的异常处理”
* 通过包管理器支持[第三方模块扩展 Elvish](https://github.com/elves/awesome-elvish)
* BSD 两句版许可证
你肯定在喊，“为什么叫 Elvish？”。好吧，根据[他们的网站](https://elv.sh/ref/name.html)，他们之所以选择当前的名字，是因为：
>
> 在 Roguelike 游戏中，精灵制造的物品质量很高。它们通常被称为“精灵物品”。但是之所以选择 “elvish” 是因为它以 “sh” 结尾，这是 Unix shell 的久远传统。这个与 fish 押韵，它是影响 Elvish 哲学的 shell 之一。
>
>
>
### 如何安装 Elvish Shell
Elvish 在几种主流发行版中都有。
请注意，该软件还很年轻。最新版本是 0.12。根据该项目的 [GitHub 页面](https://github.com/elves/elvish)：“尽管还处在 1.0 之前，但它已经适合大多数日常交互使用。”
#### Debian 和 Ubuntu
Elvish 包已引入 Debian Buster 和 Ubuntu 17.10。不幸的是，这些包已经过时，你需要使用 [PPA](https://launchpad.net/%7Ezhsj/+archive/ubuntu/elvish) 安装最新版本。你需要使用以下命令：
```
sudo add-apt-repository ppa:zhsj/elvish
sudo apt update
sudo apt install elvish
```
#### Fedora
Elvish 在 Fedora 的主仓库中没有。你需要添加 [FZUG 仓库](https://github.com/FZUG/repo/wiki/Add-FZUG-Repository)安装 Evlish。为此，你需要使用以下命令：
```
sudo dnf config-manager --add-repo=http://repo.fdzh.org/FZUG/FZUG.repol
sudo dnf install elvish
```
#### Arch
Elvish 在 [Arch 用户仓库](https://aur.archlinux.org/packages/elvish/)中可用。
我相信你知道该[如何在 Linux 中更改 Shell](https://linuxhandbook.com/change-shell-linux/)，因此安装后可以切换到 Elvish 来使用它。
### 对 Elvish Shell 的想法
就个人而言，我没有理由在任何系统上安装 Elvish。我可以通过安装几个小的命令行程序或使用已经安装的程序来获得它的大多数功能。
例如，Bash 中已经存在“搜索历史命令”功能，并且效果很好。如果要提高历史命令的能力，我建议安装 [fzf](https://github.com/junegunn/fzf)。`fzf` 使用模糊搜索，因此你无需记住要查找的确切命令。`fzf` 还允许你预览和打开文件。
我认为 Elvish 作为一种编程语言是不错的，但是我会坚持使用 Bash shell 脚本，直到 Elvish 变得更成熟。
你们都有用过 Elvish 么？你认为安装 Elvish 是否值得？你最喜欢的 Bash 替代品是什么？请在下面的评论中告诉我们。
如果你发现这篇文章有趣，请花一点时间在社交媒体、Hacker News 或 Reddit 上分享它。
---
via: <https://itsfoss.com/elvish-shell/>
作者：[John Paul](https://itsfoss.com/author/john/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 RHEL8 /CentOS8 上建立多节点 Elastic stack 集群 | Pradeep Kumar | https://www.linuxtechi.com/setup-multinode-elastic-stack-cluster-rhel8-centos8/ | Elastic stack 俗称 ELK stack，是一组包括 Elasticsearch、Logstash 和 Kibana 在内的开源产品。 | /data/attachment/album/201909/26/212420byaf0zyrv9z8ak8r.jpg.thumb.jpg | /data/attachment/album/201909/26/212420byaf0zyrv9z8ak8r.jpg | true | false | true | lujun9972 | heguangzhi | wxy | false | [
"Elastic"
] | 技术 | {
"viewnum": 6397,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Elastic stack 俗称 ELK stack，是一组包括 Elasticsearch、Logstash 和 Kibana 在内的开源产品。 | 2019-09-26T21:24:00 | 2019-09-26T21:24:00 | 11,394 | /article-11394-1.html | Elastic stack 俗称 ELK stack，是一组包括 Elasticsearch、Logstash 和 Kibana 在内的开源产品。Elastic Stack 由 Elastic 公司开发和维护。使用 Elastic stack，可以将系统日志发送到 Logstash，它是一个数据收集引擎，接受来自可能任何来源的日志或数据，并对日志进行归一化，然后将日志转发到 Elasticsearch，用于分析、索引、搜索和存储，最后使用 Kibana 表示为可视化数据，使用 Kibana，我们还可以基于用户的查询创建交互式图表。
在本文中，我们将演示如何在 RHEL 8 / CentOS 8 服务器上设置多节点 elastic stack 集群。以下是我的 Elastic Stack 集群的详细信息:
**Elasticsearch：**
* 三台服务器，最小化安装 RHEL 8 / CentOS 8
* IP & 主机名 – 192.168.56.40（`elasticsearch1.linuxtechi.local`）、192.168.56.50 （`elasticsearch2.linuxtechi.local`）、192.168.56.60（elasticsearch3.linuxtechi.local`）
Logstash：\*\*
* 两台服务器，最小化安装 RHEL 8 / CentOS 8
* IP & 主机 – 192.168.56.20（`logstash1.linuxtechi.local`）、192.168.56.30（`logstash2.linuxtechi.local`）
**Kibana：**
* 一台服务器，最小化安装 RHEL 8 / CentOS 8
* IP & 主机名 – 192.168.56.10（`kibana.linuxtechi.local`）
**Filebeat：**
* 一台服务器，最小化安装 CentOS 7
* IP & 主机名 – 192.168.56.70（`web-server`）
让我们从设置 Elasticsearch 集群开始，
### 设置3个节点 Elasticsearch 集群
正如我已经说过的，设置 Elasticsearch 集群的节点，登录到每个节点，设置主机名并配置 yum/dnf 库。
使用命令 `hostnamectl` 设置各个节点上的主机名：
```
[root@linuxtechi ~]# hostnamectl set-hostname "elasticsearch1.linuxtechi. local"
[root@linuxtechi ~]# exec bash
[root@linuxtechi ~]#
[root@linuxtechi ~]# hostnamectl set-hostname "elasticsearch2.linuxtechi. local"
[root@linuxtechi ~]# exec bash
[root@linuxtechi ~]#
[root@linuxtechi ~]# hostnamectl set-hostname "elasticsearch3.linuxtechi. local"
[root@linuxtechi ~]# exec bash
[root@linuxtechi ~]#
```
对于 CentOS 8 系统，我们不需要配置任何操作系统包库，对于 RHEL 8 服务器，如果你有有效订阅，那么用红帽订阅以获得包存储库就可以了。如果你想为操作系统包配置本地 yum/dnf 存储库，请参考以下网址：
* [如何使用 DVD 或 ISO 文件在 RHEL 8 服务器上设置本地 Yum / DNF 存储库](https://www.linuxtechi.com/setup-local-yum-dnf-repository-rhel-8/)
在所有节点上配置 Elasticsearch 包存储库，在 `/etc/yum.repo.d/` 文件夹下创建一个包含以下内容的 `elastic.repo` 文件：
```
~]# vi /etc/yum.repos.d/elastic.repo
[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
```
保存文件并退出。
在所有三个节点上使用 `rpm` 命令导入 Elastic 公共签名密钥。
```
~]# rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
```
在所有三个节点的 `/etc/hosts` 文件中添加以下行:
```
192.168.56.40 elasticsearch1.linuxtechi.local
192.168.56.50 elasticsearch2.linuxtechi.local
192.168.56.60 elasticsearch3.linuxtechi.local
```
使用 `yum`/`dnf` 命令在所有三个节点上安装 Java：
```
[root@linuxtechi ~]# dnf install java-openjdk -y
[root@linuxtechi ~]# dnf install java-openjdk -y
[root@linuxtechi ~]# dnf install java-openjdk -y
```
使用 `yum`/`dnf` 命令在所有三个节点上安装 Elasticsearch：
```
[root@linuxtechi ~]# dnf install elasticsearch -y
[root@linuxtechi ~]# dnf install elasticsearch -y
[root@linuxtechi ~]# dnf install elasticsearch -y
```
**注意：** 如果操作系统防火墙已启用并在每个 Elasticsearch 节点中运行，则使用 `firewall-cmd` 命令允许以下端口开放：
```
~]# firewall-cmd --permanent --add-port=9300/tcp
~]# firewall-cmd --permanent --add-port=9200/tcp
~]# firewall-cmd --reload
```
配置 Elasticsearch, 在所有节点上编辑文件 `/etc/elasticsearch/elasticsearch.yml` 并加入以下内容：
```
~]# vim /etc/elasticsearch/elasticsearch.yml
cluster.name: opn-cluster
node.name: elasticsearch1.linuxtechi.local
network.host: 192.168.56.40
http.port: 9200
discovery.seed_hosts: ["elasticsearch1.linuxtechi.local", "elasticsearch2.linuxtechi.local", "elasticsearch3.linuxtechi.local"]
cluster.initial_master_nodes: ["elasticsearch1.linuxtechi.local", "elasticsearch2.linuxtechi.local", "elasticsearch3.linuxtechi.local"]
```
**注意：** 在每个节点上，在 `node.name` 中填写正确的主机名，在 `network.host` 中填写正确的 IP 地址，其他参数保持不变。
现在使用 `systemctl` 命令在所有三个节点上启动并启用 Elasticsearch 服务：
```
~]# systemctl daemon-reload
~]# systemctl enable elasticsearch.service
~]# systemctl start elasticsearch.service
```
使用下面 `ss` 命令验证 elasticsearch 节点是否开始监听 9200 端口：
```
[root@linuxtechi ~]# ss -tunlp | grep 9200
tcp LISTEN 0 128 [::ffff:192.168.56.40]:9200 *:* users:(("java",pid=2734,fd=256))
[root@linuxtechi ~]#
```
使用以下 `curl` 命令验证 Elasticsearch 群集状态：
```
[root@linuxtechi ~]# curl http://elasticsearch1.linuxtechi.local:9200
[root@linuxtechi ~]# curl -X GET http://elasticsearch2.linuxtechi.local:9200/_cluster/health?pretty
```
命令的输出如下所示：
以上输出表明我们已经成功创建了 3 节点的 Elasticsearch 集群，集群的状态也是绿色的。
**注意：** 如果你想修改 JVM 堆大小，那么你可以编辑了文件 `/etc/elasticsearch/jvm.options`，并根据你的环境更改以下参数：
* `-Xms1g`
* `-Xmx1g`
现在让我们转到 Logstash 节点。
### 安装和配置 Logstash
在两个 Logstash 节点上执行以下步骤。
登录到两个节点使用 `hostnamectl` 命令设置主机名：
```
[root@linuxtechi ~]# hostnamectl set-hostname "logstash1.linuxtechi.local"
[root@linuxtechi ~]# exec bash
[root@linuxtechi ~]#
[root@linuxtechi ~]# hostnamectl set-hostname "logstash2.linuxtechi.local"
[root@linuxtechi ~]# exec bash
[root@linuxtechi ~]#
```
在两个 logstash 节点的 `/etc/hosts` 文件中添加以下条目：
```
~]# vi /etc/hosts
192.168.56.40 elasticsearch1.linuxtechi.local
192.168.56.50 elasticsearch2.linuxtechi.local
192.168.56.60 elasticsearch3.linuxtechi.local
```
保存文件并退出。
在两个节点上配置 Logstash 存储库，在文件夹 `/ete/yum.repo.d/` 下创建一个包含以下内容的文件 `logstash.repo`：
```
~]# vi /etc/yum.repos.d/logstash.repo
[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
```
保存并退出文件，运行 `rpm` 命令导入签名密钥：
```
~]# rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
```
使用 `yum`/`dnf` 命令在两个节点上安装 Java OpenJDK：
```
~]# dnf install java-openjdk -y
```
从两个节点运行 `yum`/`dnf` 命令来安装 logstash：
```
[root@linuxtechi ~]# dnf install logstash -y
[root@linuxtechi ~]# dnf install logstash -y
```
现在配置 logstash，在两个 logstash 节点上执行以下步骤，创建一个 logstash 配置文件，首先我们在 `/etc/logstash/conf.d/` 下复制 logstash 示例文件：
```
# cd /etc/logstash/
# cp logstash-sample.conf conf.d/logstash.conf
```
编辑配置文件并更新以下内容：
```
# vi conf.d/logstash.conf
input {
beats {
port => 5044
}
}
output {
elasticsearch {
hosts => ["http://elasticsearch1.linuxtechi.local:9200", "http://elasticsearch2.linuxtechi.local:9200", "http://elasticsearch3.linuxtechi.local:9200"]
index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
#user => "elastic"
#password => "changeme"
}
}
```
在 `output` 部分之下，在 `hosts` 参数中指定所有三个 Elasticsearch 节点的 FQDN，其他参数保持不变。
使用 `firewall-cmd` 命令在操作系统防火墙中允许 logstash 端口 “5044”：
```
~ # firewall-cmd --permanent --add-port=5044/tcp
~ # firewall-cmd –reload
```
现在，在每个节点上运行以下 `systemctl` 命令，启动并启用 Logstash 服务：
```
~]# systemctl start logstash
~]# systemctl eanble logstash
```
使用 `ss` 命令验证 logstash 服务是否开始监听 5044 端口：
```
[root@linuxtechi ~]# ss -tunlp | grep 5044
tcp LISTEN 0 128 *:5044 *:* users:(("java",pid=2416,fd=96))
[root@linuxtechi ~]#
```
以上输出表明 logstash 已成功安装和配置。让我们转到 Kibana 安装。
### 安装和配置 Kibana
登录 Kibana 节点，使用 `hostnamectl` 命令设置主机名：
```
[root@linuxtechi ~]# hostnamectl set-hostname "kibana.linuxtechi.local"
[root@linuxtechi ~]# exec bash
[root@linuxtechi ~]#
```
编辑 `/etc/hosts` 文件并添加以下行：
```
192.168.56.40 elasticsearch1.linuxtechi.local
192.168.56.50 elasticsearch2.linuxtechi.local
192.168.56.60 elasticsearch3.linuxtechi.local
```
使用以下命令设置 Kibana 存储库：
```
[root@linuxtechi ~]# vi /etc/yum.repos.d/kibana.repo
[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
[root@linuxtechi ~]# rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
```
执行 `yum`/`dnf` 命令安装 kibana：
```
[root@linuxtechi ~]# yum install kibana -y
```
通过编辑 `/etc/kibana/kibana.yml` 文件，配置 Kibana：
```
[root@linuxtechi ~]# vim /etc/kibana/kibana.yml
…………
server.host: "kibana.linuxtechi.local"
server.name: "kibana.linuxtechi.local"
elasticsearch.hosts: ["http://elasticsearch1.linuxtechi.local:9200", "http://elasticsearch2.linuxtechi.local:9200", "http://elasticsearch3.linuxtechi.local:9200"]
…………
```
启用并启动 kibana 服务：
```
[root@linuxtechi ~]# systemctl start kibana
[root@linuxtechi ~]# systemctl enable kibana
```
在系统防火墙上允许 Kibana 端口 “5601”：
```
[root@linuxtechi ~]# firewall-cmd --permanent --add-port=5601/tcp
success
[root@linuxtechi ~]# firewall-cmd --reload
success
[root@linuxtechi ~]#
```
使用以下 URL 访问 Kibana 界面：<http://kibana.linuxtechi.local:5601>
从面板上，我们可以检查 Elastic Stack 集群的状态。
这证明我们已经在 RHEL 8 /CentOS 8 上成功地安装并设置了多节点 Elastic Stack 集群。
现在让我们通过 `filebeat` 从其他 Linux 服务器发送一些日志到 logstash 节点中，在我的例子中，我有一个 CentOS 7服务器，我将通过 `filebeat` 将该服务器的所有重要日志推送到 logstash。
登录到 CentOS 7 服务器使用 yum/rpm 命令安装 filebeat 包：
```
[root@linuxtechi ~]# rpm -ivh https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.3.1-x86_64.rpm
Retrieving https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.3.1-x86_64.rpm
Preparing... ################################# [100%]
Updating / installing...
1:filebeat-7.3.1-1 ################################# [100%]
[root@linuxtechi ~]#
```
编辑 `/etc/hosts` 文件并添加以下内容：
```
192.168.56.20 logstash1.linuxtechi.local
192.168.56.30 logstash2.linuxtechi.local
```
现在配置 `filebeat`，以便它可以使用负载平衡技术向 logstash 节点发送日志，编辑文件 `/etc/filebeat/filebeat.yml`，并添加以下参数：
在 `filebeat.inputs:` 部分将 `enabled: false` 更改为 `enabled: true`，并在 `paths` 参数下指定我们可以发送到 logstash 的日志文件的位置；注释掉 `output.elasticsearch` 和 `host` 参数；删除 `output.logstash:` 和 `hosts:` 的注释，并在 `hosts` 参数添加两个 logstash 节点，以及设置 `loadbalance: true`。
```
[root@linuxtechi ~]# vi /etc/filebeat/filebeat.yml
filebeat.inputs:
- type: log
enabled: true
paths:
- /var/log/messages
- /var/log/dmesg
- /var/log/maillog
- /var/log/boot.log
#output.elasticsearch:
# hosts: ["localhost:9200"]
output.logstash:
hosts: ["logstash1.linuxtechi.local:5044", "logstash2.linuxtechi.local:5044"]
loadbalance: true
```
使用下面的 2 个 `systemctl` 命令 启动并启用 `filebeat` 服务：
```
[root@linuxtechi ~]# systemctl start filebeat
[root@linuxtechi ~]# systemctl enable filebeat
```
现在转到 Kibana 用户界面，验证新索引是否可见。
从左侧栏中选择管理选项，然后单击 Elasticsearch 下的索引管理：
正如我们上面看到的，索引现在是可见的，让我们现在创建索引模型。
点击 Kibana 部分的 “Index Patterns”，它将提示我们创建一个新模型，点击 “Create Index Pattern” ，并将模式名称指定为 “filebeat”：
点击下一步。
选择 “Timestamp” 作为索引模型的时间过滤器，然后单击 “Create index pattern”：
现在单击查看实时 filebeat 索引模型：
这表明 Filebeat 代理已配置成功，我们能够在 Kibana 仪表盘上看到实时日志。
以上就是本文的全部内容，对这些帮助你在 RHEL 8 / CentOS 8 系统上设置 Elastic Stack 集群的步骤，请不要犹豫分享你的反馈和意见。
---
via: <https://www.linuxtechi.com/setup-multinode-elastic-stack-cluster-rhel8-centos8/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
构建一个即时消息应用（一）：模式 | Nicolás Parada | https://nicolasparada.netlify.com/posts/go-messenger-schema/ | 这是一系列关于构建“即时消息”应用的新帖子。 | /data/attachment/album/201909/27/211458n44f7jvp77lfxxm0.jpg.thumb.jpg | /data/attachment/album/201909/27/211458n44f7jvp77lfxxm0.jpg | true | false | true | lujun9972 | PsiACE | wxy | false | [] | 软件开发 | {
"viewnum": 4109,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11510,
"displayorder": 0
}
] | 这是一系列关于构建“即时消息”应用的新帖子。 | 2019-09-27T21:15:15 | 2019-09-27T21:15:15 | 11,396 | /article-11396-1.html | 
这是一系列关于构建“即时消息”应用的新帖子。你应该对这类应用并不陌生。有了它们的帮助，我们才可以与朋友畅聊无忌。[Facebook Messenger](https://www.messenger.com/)、[WhatsApp](https://www.whatsapp.com/) 和 [Skype](https://www.skype.com/) 就是其中的几个例子。正如你所看到的那样，这些应用允许我们发送图片、传输视频、录制音频、以及和一大帮子人聊天等等。当然，我们的教程应用将会尽量保持简单，只在两个用户之间发送文本消息。
我们将会用 [CockroachDB](https://www.cockroachlabs.com/) 作为 SQL 数据库，用 [Go](https://golang.org/) 作为后端语言，并且用 JavaScript 来制作 web 应用。
这是第一篇帖子，我们将会讲述数据库的设计。
```
CREATE TABLE users (
id SERIAL NOT NULL PRIMARY KEY,
username STRING NOT NULL UNIQUE,
avatar_url STRING,
github_id INT NOT NULL UNIQUE
);
```
显然，这个应用需要一些用户。我们这里采用社交登录的形式。由于我选用了 [GitHub](https://github.com/)，所以这里需要保存一个对 GitHub 用户 ID 的引用。
```
CREATE TABLE conversations (
id SERIAL NOT NULL PRIMARY KEY,
last_message_id INT,
INDEX (last_message_id DESC)
);
```
每个对话都会引用最近一条消息。每当我们输入一条新消息时，我们都会更新这个字段。我会在后面添加外键约束。
… 你可能会想，我们可以先对对话进行分组，然后再通过这样的方式获取最近一条消息。但这样做会使查询变得更加复杂。
```
CREATE TABLE participants (
user_id INT NOT NULL REFERENCES users ON DELETE CASCADE,
conversation_id INT NOT NULL REFERENCES conversations ON DELETE CASCADE,
messages_read_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, conversation_id)
);
```
尽管之前我提到过对话只会在两个用户之间进行，但我们还是采用了允许向对话中添加多个参与者的设计。因此，在对话和用户之间有一个参与者表。
为了知道用户是否有未读消息，我们在消息表中添加了“读取时间”（`messages_read_at`）字段。每当用户在对话中读取消息时，我们都会更新它的值，这样一来，我们就可以将它与对话中最后一条消息的“创建时间”（`created_at`）字段进行比较。
```
CREATE TABLE messages (
id SERIAL NOT NULL PRIMARY KEY,
content STRING NOT NULL,
user_id INT NOT NULL REFERENCES users ON DELETE CASCADE,
conversation_id INT NOT NULL REFERENCES conversations ON DELETE CASCADE,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
INDEX(created_at DESC)
);
```
尽管我们将消息表放在最后，但它在应用中相当重要。我们用它来保存对创建它的用户以及它所出现的对话的引用。而且还可以根据“创建时间”（`created_at`）来创建索引以完成对消息的排序。
```
ALTER TABLE conversations
ADD CONSTRAINT fk_last_message_id_ref_messages
FOREIGN KEY (last_message_id) REFERENCES messages ON DELETE SET NULL;
```
我在前面已经提到过这个外键约束了，不是吗:D
有这四张表就足够了。你也可以将这些查询保存到一个文件中，并将其通过管道传送到 Cockroach CLI。
首先，我们需要启动一个新节点：
```
cockroach start --insecure --host 127.0.0.1
```
然后创建数据库和这些表：
```
cockroach sql --insecure -e "CREATE DATABASE messenger"
cat schema.sql | cockroach sql --insecure -d messenger
```
这篇帖子就到这里。在接下来的部分中，我们将会介绍「登录」，敬请期待。
* [源代码](https://github.com/nicolasparada/go-messenger-demo)
---
via: <https://nicolasparada.netlify.com/posts/go-messenger-schema/>
作者：[Nicolás Parada](https://nicolasparada.netlify.com/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[PsiACE](https://github.com/PsiACE) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux 中国](https://linux.cn/) 荣誉推出
|
如何在 Linux/Windows/MacOS 上使用 .NET 进行开发 | Seth Kenlon | https://opensource.com/article/19/9/getting-started-net | 了解 .NET 开发平台启动和运行的基础知识。 | /data/attachment/album/201909/28/111101n3i43c38tv3j9im4.jpg.thumb.jpg | /data/attachment/album/201909/28/111101n3i43c38tv3j9im4.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
".NET"
] | 技术 | {
"viewnum": 4553,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 了解 .NET 开发平台启动和运行的基础知识。 | 2019-09-28T11:11:12 | 2019-09-28T11:11:12 | 11,397 | /article-11397-1.html |
>
> 了解 .NET 开发平台启动和运行的基础知识。
>
>
>
.NET 框架由 Microsoft 于 2000 年发布。该平台的开源实现 [Mono](https://www.monodevelop.com/) 在 21 世纪初成为了争议的焦点，因为微软拥有 .NET 技术的多项专利，并且可能使用这些专利来终止 Mono 项目。幸运的是，在 2014 年，微软宣布 .NET 开发平台从此成为 MIT 许可下的开源平台，并在 2016 年收购了开发 Mono 的 Xamarin 公司。
.NET 和 Mono 已经同时可用于 C#、F#、GTK+、Visual Basic、Vala 等的跨平台编程环境。使用 .NET 和 Mono 创建的程序已经应用于 Linux、BSD、Windows、MacOS、Android，甚至一些游戏机。你可以使用 .NET 或 Mono 来开发 .NET 应用。这两个都是开源的，并且都有活跃和充满活力的社区。本文重点介绍微软的 .NET 环境。
### 如何安装 .NET
.NET 下载被分为多个包：一个仅包含 .NET 运行时，另一个 .NET SDK 包含了 .NET Core 和运行时。根据架构和操作系统版本，这些包可能有多个版本。要开始使用 .NET 进行开发，你必须[安装该 SDK](https://dotnet.microsoft.com/download)。它为你提供了 [dotnet](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet?tabs=netcore21) 终端或 PowerShell 命令，你可以使用它们来创建和生成项目。
#### Linux
要在 Linux 上安装 .NET，首先将微软 Linux 软件仓库添加到你的计算机。
在 Fedora 上：
```
$ sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
$ sudo wget -q -O /etc/yum.repos.d/microsoft-prod.repo https://packages.microsoft.com/config/fedora/27/prod.repo
```
在 Ubuntu 上：
```
$ wget -q https://packages.microsoft.com/config/ubuntu/19.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
$ sudo dpkg -i packages-microsoft-prod.deb
```
接下来，使用包管理器安装 SDK，将 `<X.Y>` 替换为当前版本的 .NET 版本：
在 Fedora 上：
```
$ sudo dnf install dotnet-sdk-<X.Y>
```
在 Ubuntu 上：
```
$ sudo apt install apt-transport-https
$ sudo apt update
$ sudo apt install dotnet-sdk-<X.Y>
```
下载并安装所有包后，打开终端并输入下面命令确认安装：
```
$ dotnet --version
X.Y.Z
```
#### Windows
如果你使用的是微软 Windows，那么你可能已经安装了 .NET 运行时。但是，要开发 .NET 应用，你还必须安装 .NET Core SDK。
首先，[下载安装程序](https://dotnet.microsoft.com/download)。请认准下载 .NET Core 进行跨平台开发（.NET Framework 仅适用于 Windows）。下载 .exe 文件后，双击该文件启动安装向导，然后单击两下进行安装：接受许可证并允许安装继续。
然后，从左下角的“应用程序”菜单中打开 PowerShell。在 PowerShell 中，输入测试命令：
```
PS C:\Users\osdc> dotnet
```
如果你看到有关 dotnet 安装的信息，那么说明 .NET 已正确安装。
#### MacOS
如果你使用的是 Apple Mac，请下载 .pkg 形式的 [Mac 安装程序](https://dotnet.microsoft.com/download)。下载并双击该 .pkg 文件，然后单击安装程序。你可能需要授予安装程序权限，因为该软件包并非来自 App Store。
下载并安装所有软件包后，请打开终端并输入以下命令来确认安装：
```
$ dotnet --version
X.Y.Z
```
### Hello .NET
`dotnet` 命令提供了一个用 .NET 编写的 “hello world” 示例程序。或者，更准确地说，该命令提供了示例应用。
首先，使用 `dotnet` 命令以及 `new` 和 `console` 参数创建一个控制台应用的项目目录及所需的代码基础结构。使用 `-o` 选项指定项目名称：
```
$ dotnet new console -o hellodotnet
```
这将在当前目录中创建一个名为 `hellodotnet` 的目录。进入你的项目目录并看一下：
```
$ cd hellodotnet
$ dir
hellodotnet.csproj obj Program.cs
```
`Program.cs` 是一个空的 C＃ 文件，它包含了一个简单的 Hello World 程序。在文本编辑器中打开查看它。微软的 Visual Studio Code 是一个使用 dotnet 编写的跨平台的开源应用，虽然它不是一个糟糕的文本编辑器，但它会收集用户的大量数据（在它的二进制发行版的许可证中授予了自己权限）。如果要尝试使用 Visual Studio Code，请考虑使用 [VSCodium](https://vscodium.com/)，它是使用 Visual Studio Code 的 MIT 许可的源码构建的版本，而*没有*远程收集（请阅读[此文档](https://github.com/VSCodium/vscodium/blob/master/DOCS.md)来禁止此构建中的其他形式追踪）。或者，只需使用现有的你最喜欢的文本编辑器或 IDE。
新控制台应用中的样板代码为：
```
using System;
namespace hellodotnet
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
```
要运行该程序，请使用 `dotnet run` 命令：
```
$ dotnet run
Hello World!
```
这是 .NET 和 `dotnet` 命令的基本工作流程。这里有完整的 [.NET C＃ 指南](https://docs.microsoft.com/en-us/dotnet/csharp/tutorials/intro-to-csharp/)，并且都是与 .NET 相关的内容。关于 .NET 实战示例，请关注 [Alex Bunardzic](https://opensource.com/users/alex-bunardzic "View user profile.") 在 opensource.com 中的变异测试文章。
---
via: <https://opensource.com/article/19/9/getting-started-net>
作者：[Seth Kenlon](https://opensource.com/users/sethhttps://opensource.com/users/alex-bunardzichttps://opensource.com/users/alex-bunardzic) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
chgrp 和 newgrp 命令简介 | Alan Formy-duval | https://opensource.com/article/19/9/linux-chgrp-and-newgrp-commands | chgrp 和 newgrp 命令可帮助你管理需要维护组所有权的文件。 | /data/attachment/album/201909/28/155554aezllilzbedetm43.jpg.thumb.jpg | /data/attachment/album/201909/28/155554aezllilzbedetm43.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"chgrp"
] | 技术 | {
"viewnum": 3339,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11416,
"displayorder": 0
}
] | chgrp 和 newgrp 命令可帮助你管理需要维护组所有权的文件。 | 2019-09-28T16:02:00 | 2019-09-28T16:02:00 | 11,399 | /article-11399-1.html |
>
> chgrp 和 newgrp 命令可帮助你管理需要维护组所有权的文件。
>
>
>
在最近的一篇文章中，我介绍了 [chown](/article-11416-1.html) 命令，它用于修改系统上的文件所有权。回想一下，所有权是分配给一个对象的用户和组的组合。`chgrp` 和 `newgrp` 命令为管理需要维护组所有权的文件提供了帮助。
### 使用 chgrp
`chgrp` 只是更改文件的组所有权。这与 `chown :<group>` 命令相同。你可以使用：
```
$chown :alan mynotes
```
或者：
```
$chgrp alan mynotes
```
#### 递归
`chgrp` 和它的一些参数可以用在命令行和脚本中。就像许多其他 Linux 命令一样，`chgrp` 有一个递归参数 `-R`。如下所示，你需要它来对文件夹及其内容进行递归操作。我加了 `-v`（详细）参数，因此 `chgrp` 会告诉我它在做什么：
```
$ ls -l . conf
.:
drwxrwxr-x 2 alan alan 4096 Aug 5 15:33 conf
conf:
-rw-rw-r-- 1 alan alan 0 Aug 5 15:33 conf.xml
# chgrp -vR delta conf
changed group of 'conf/conf.xml' from alan to delta
changed group of 'conf' from alan to delta
```
#### 参考
当你要更改文件的组以匹配特定的配置，或者当你不知道具体的组时（比如你运行一个脚本时），可使用参考文件 （`--reference=RFILE`）。你可以复制另外一个作为参考的文件（RFILE）的组。比如，为了撤销上面的更改 （请注意，点 `.` 代表当前工作目录）：
```
$ chgrp -vR --reference=. conf
```
#### 报告更改
大多数命令都有用于控制其输出的参数。最常见的是 `-v` 来启用详细信息，而且 `chgrp` 命令也拥有详细模式。它还具有 `-c`（`--changes`）参数，指示 `chgrp` 仅在进行了更改时报告。`chgrp` 还会报告其他内容，例如是操作不被允许时。
参数 `-f`（`--silent`、`--quiet`）用于禁止显示大部分错误消息。我将在下一节中使用此参数和 `-c` 来显示实际更改。
#### 保持根目录
Linux 文件系统的根目录（`/`）应该受到高度重视。如果命令在此层级犯了一个错误，那么后果可能是可怕的，并会让系统无法使用。尤其是在运行一个会递归修改甚至删除的命令时。`chgrp` 命令有一个可用于保护和保持根目录的参数。它是 `--preserve-root`。如果在根目录中将此参数和递归一起使用，那么什么也不会发生，而是会出现一条消息：
```
[root@localhost /]# chgrp -cfR --preserve-root a+w /
chgrp: it is dangerous to operate recursively on '/'
chgrp: use --no-preserve-root to override this failsafe
```
不与递归（-R）结合使用时，该选项无效。但是，如果该命令由 `root` 用户运行，那么 `/` 的权限将会更改，但其下的其他文件或目录的权限则不会被更改：
```
[alan@localhost /]$ chgrp -c --preserve-root alan /
chgrp: changing group of '/': Operation not permitted
[root@localhost /]# chgrp -c --preserve-root alan /
changed group of '/' from root to alan
```
令人惊讶的是，它似乎不是默认参数。而选项 `--no-preserve-root` 是默认的。如果你在不带“保持”选项的情况下运行上述命令，那么它将默认为“无保持”模式，并可能会更改不应更改的文件的权限：
```
[alan@localhost /]$ chgrp -cfR alan /
changed group of '/dev/pts/0' from tty to alan
changed group of '/dev/tty2' from tty to alan
changed group of '/var/spool/mail/alan' from mail to alan
```
### 关于 newgrp
`newgrp` 命令允许用户覆盖当前的主要组。当你在所有文件必须有相同的组所有权的目录中操作时，`newgrp` 会很方便。假设你的内网服务器上有一个名为 `share` 的目录，不同的团队在其中存储市场活动照片。组名为 `share`。当不同的用户将文件放入目录时，文件的主要组可能会变得混乱。每当添加新文件时，你都可以运行 `chgrp` 将错乱的组纠正为 `share`：
```
$ cd share
ls -l
-rw-r--r--. 1 alan share 0 Aug 7 15:35 pic13
-rw-r--r--. 1 alan alan 0 Aug 7 15:35 pic1
-rw-r--r--. 1 susan delta 0 Aug 7 15:35 pic2
-rw-r--r--. 1 james gamma 0 Aug 7 15:35 pic3
-rw-rw-r--. 1 bill contract 0 Aug 7 15:36 pic4
```
我在 [chmod 命令](https://opensource.com/article/19/8/linux-chmod-command)的文章中介绍了 `setgid` 模式。它是解决此问题的一种方法。但是，假设由于某种原因未设置 `setgid` 位。`newgrp` 命令在此时很有用。在任何用户将文件放入 `share` 目录之前，他们可以运行命令 `newgrp share`。这会将其主要组切换为 `share`，因此他们放入目录中的所有文件都将有 `share` 组，而不是用户自己的主要组。完成后，用户可以使用以下命令切换回常规主要组（举例）：
```
newgrp alan
```
### 总结
了解如何管理用户、组和权限非常重要。最好知道一些替代方法来解决可能遇到的问题，因为并非所有环境都以相同的方式设置。
---
via: <https://opensource.com/article/19/9/linux-chgrp-and-newgrp-commands>
作者：[Alan Formy-Duval](https://opensource.com/users/alanfdosshttps://opensource.com/users/sethhttps://opensource.com/users/alanfdosshttps://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
每周开源点评：云原生 Java、开源安全以及更多行业趋势 | Tim Hildred | https://opensource.com/article/19/8/cloud-native-java-and-more | 开源社区和行业趋势的每周总览。 | /data/attachment/album/201909/29/103316pxhxlh5l9qag7mth.png.thumb.jpg | /data/attachment/album/201909/29/103316pxhxlh5l9qag7mth.png | true | false | true | lujun9972 | laingke | wxy | false | [
"开源"
] | 观点 | {
"viewnum": 2838,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11453,
"displayorder": 0
}
] | 开源社区和行业趋势的每周总览。 | 2019-09-29T10:32:57 | 2019-09-29T10:32:57 | 11,400 | /article-11400-1.html |
>
> 开源社区和行业趋势的每周总览。
>
>
>
作为我在具有开源开发模型的企业软件公司担任高级产品营销经理的角色的一部分，我为产品营销人员、经理和其他影响者定期发布有关开源社区，市场和行业趋势的定期更新。 以下是该更新中我和他们最喜欢的五篇文章。
### 《为什么现代 web 开发如此复杂？》
* [文章地址](https://www.vrk.dev/2019/07/11/why-is-modern-web-development-so-complicated-a-long-yet-hasty-explanation-part-1/)
>
> 现代前端 web 开发带来了一种两极分化的体验：许多人喜欢它，而其他人则鄙视它。
>
>
> 我是现代Web开发的忠实拥护者，尽管我将其描述为“魔法”——而魔法也有其优点和缺点……。最近，我一直在向那些只具有粗略的原始 web 开发工作流程的人们讲解“现代 web 开发工作流程”……，但我发现需要解释的内容实在是太多了！甚至笼统的解释最终都会变得冗长。因此，在我努力写下更多解释的过程中，这里是对 web 开发演变的一个长期而笼统的解释的开始……
>
>
>
**影响**：足够具体，对前端开发人员非常有用（特别是对新开发人员），且足够简单，解释得足够好，可以帮助非开发人员更好地理解前端开发人员的一些问题。到最后，你将（有点）了解 Javascript 和 WebAPI 之间的区别，以及 2019 年的 Javascript 与 2006 年的 Javascript 有何不同。
### 开源 Kubernetes 安全审计
* [文章链接](https://www.cncf.io/blog/2019/08/06/open-sourcing-the-kubernetes-security-audit/)
>
> 去年，云原生计算基金会（CNCF）开始为其项目执行并开源第三方安全审计，以提高我们生态系统的整体安全性。这个想法是从一些项目开始，并从 CNCF 社区收集了关于这个试点项目是否有用的反馈。第一批经历这个过程的项目是 [CoreDNS](https://coredns.io/2018/03/15/cure53-security-assessment/)、[Envoy](https://github.com/envoyproxy/envoy/blob/master/docs/SECURITY_AUDIT.pdf) 和 [Prometheus](https://cure53.de/pentest-report_prometheus.pdf)。这些首次公开审计发现了从一般漏洞到严重漏洞的安全问题。有了这些结果，CoreDNS、Envoy 和 Prometheus 的项目维护者就能够解决已发现的漏洞，并添加文档来帮助用户。
>
>
> 从这些初始审计中得出的主要结论是，公开安全审计是测试开源项目的质量及其漏洞管理过程的一个很好的方法，更重要的是，测试开源项目的安全实践有多大的弹性。特别是 CNCF 的[毕业项目](https://www.cncf.io/projects/)，它们被世界上一些最大的公司广泛应用于生产中，它们必须坚持最高级别的安全最佳实践。
>
>
>
**影响**：就像 Linux 之于数据中心一样，很多公司都把云计算押宝在 Kubernetes 上。从安全的角度来看，看到其中 4 家公司以确保项目正在做应该做的事情，这激发了人们的信心。共享这项研究表明，开源远远不止是仓库中的代码；它是以一种有益于整个社区而不是少数人利益的方式获取和分享专家意见。
### Quarkus——这个轻量级 Java 框架的下一步是什么？
* [文章链接](https://jaxenter.com/quarkus-whats-next-for-the-lightweight-java-framework-160793.html)
>
> “容器优先”是什么意思？Quarkus 有哪些优势？0.20.0 版本有什么新功能？未来我们可以期待哪些功能？1.0.0 版什么时候发布？我们对 Quarkus 有很多问题，而 Alex Soto 也很耐心地回答了所有问题。 随着 Quarkus 0.20.0 的发布，我们和 [JAX 伦敦演讲者](https://jaxlondon.com/cloud-kubernetes-serverless/java-particle-acceleration-using-quarkus/)，Java 拥护者和红帽的开发人员体验总监 Alex Soto 进行了接触。他很好地回答了我们关于 Quarkus 的过去、现在和未来的所有问题。看起来我们对这个令人兴奋的轻量级框架有很多期待！
>
>
>
**影响**：最近有个聪明的人告诉我，Quarkus 有潜力使 Java “可能成为容器和无服务器环境的最佳语言之一”。不禁使我多看了一眼。尽管 Java 是最流行的编程语言之一（[如果不是最流行的](https://opensource.com/article/19/8/possibly%20one%20of%20the%20best%20languages%20for%20containers%20and%20serverless%20environments.)），但当你听到“云原生”一词时，它可能并不是第一个想到的语言。Quarkus 可以通过让开发人员将他们的经验应用到新的挑战中，从而扩展和提高他们所拥有的技能的价值。
### Julia 编程语言：用户批露他们最喜欢和最讨厌它的地方
* [文章链接](https://www.zdnet.com/article/julia-programming-language-users-reveal-what-they-love-and-hate-the-most-about-it/#ftag=RSSbaffb68)
>
> Julia 最受欢迎的技术特性是速度和性能，其次是易用性，而最受欢迎的非技术特性是使用者无需付费即可使用它。
>
>
> 用户还报告了他们对该语言最大的不满。排在首位的是附加功能的包不够成熟，或者维护得不够好，无法满足他们的需求。
>
>
>
**影响**：Julia 1.0 版本已经发布了一年，并且在一系列相关指标（下载、GitHub 星级等）中取得了令人瞩目的增长。它是一种直接针对我们当前和未来最大挑战（“科学计算、机器学习、数据挖掘、大规模线性代数、分布式和并行计算”）的语言，因此，了解用户对它的感受，就可以间接看到有关这些挑战的应对情况。
### 多云数据解读：11 个有趣的统计数据
* [文章链接](https://enterprisersproject.com/article/2019/8/multi-cloud-statistics)
>
> 如果你把我们最近对 [Kubernetes 的有趣数据](https://enterprisersproject.com/article/2019/7/kubernetes-statistics-13-compelling)的深入研究归结最基本的一条，它看起来是这样的：[Kubernetes](https://www.redhat.com/en/topics/containers/what-is-kubernetes?intcmp=701f2000000tjyaAAA) 的受欢迎程度在可预见的未来将持续下去。
>
>
> 剧透警报：当你挖掘有关[多云](https://www.redhat.com/en/topics/cloud-computing/what-is-multicloud?intcmp=701f2000000tjyaAAA)使用情况的最新数据时，他们告诉你一个类似的描述：使用率正在飙升。
>
>
> 这种一致性是有道理的。也许不是每个组织都将使用 Kubernetes 来管理其多云和/或[混合云](https://enterprisersproject.com/hybrid-cloud)基础架构，但是两者越来越紧密地联系在一起。即使不这样做，它们都反映了向更分散和异构 IT 环境的普遍转变，以及[云原生开发](https://enterprisersproject.com/article/2018/10/how-explain-cloud-native-apps-plain-english)和其他重叠趋势。
>
>
>
**影响**：越来越多地采用“多云战略”的另一种解释是，它们将组织中单独部分未经协商而作出的决策追溯为“战略”，从而使决策合法化。“等等，所以你从谁那里买了几个小时？又从另一个人那里买了几个小时？为什么在会议纪要中没有呢？我想我们现在是一家多云公司！”。当然，我在开玩笑，我敢肯定大多数大公司的协调能力远胜于此，对吗？
*我希望你喜欢这张上周让我印象深刻的列表，并在下周一回来了解更多的开放源码社区、市场和行业趋势。*
---
via: <https://opensource.com/article/19/8/cloud-native-java-and-more>
作者：[Tim Hildred](https://opensource.com/users/thildred) 选题：[lujun9972](https://github.com/lujun9972) 译者：[laingke](https://github.com/laingke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 strace 查找 Emacs 启动阻塞的原因 | Darksun | https://www.lujun9972.win/blog/2019/09/26/%E4%BD%BF%E7%94%A8strace%E6%9F%A5%E6%89%BEemacs%E5%90%AF%E5%8A%A8%E9%98%BB%E5%A1%9E%E7%9A%84%E5%8E%9F%E5%9B%A0(exec-path-from-shell)/index.html | 刚好最近在学习使用 strace 工具，因此决定使用 strace 来看看 Emacs 到底卡在哪里。 | /data/attachment/album/201909/29/115250bgndkvezdds7q24j.jpg.thumb.jpg | /data/attachment/album/201909/29/115250bgndkvezdds7q24j.jpg | true | false | false | false | [
"Emacs",
"strace"
] | 技术 | {
"viewnum": 3802,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "61.140.133.64",
"message": "用esup包就能看，exec-path-from-shell确实占用了90%以上的启动时间。",
"username": "来自广东广州的 Chrome Mobile 119.0|Android 10 用户",
"date": "2024-01-05T07:44:39"
}
] | [] | 刚好最近在学习使用 strace 工具，因此决定使用 strace 来看看 Emacs 到底卡在哪里。 | 2019-09-29T11:53:24 | 2019-09-29T11:53:24 | 11,401 | /article-11401-1.html | 
之前就觉得我的 Emacs 启动好慢，查看启动日志会发现启动到一般的时候会有一个比较长时间的卡顿。 之前一直没有理会它，今天花了点时间探索了一下，发现罪魁祸首居然是 exec-path-from-shell 这个包。
现将探索的过程记录如下： 由于使用了 spacemacs 的配置，配置上比较复杂，不太想通过实验缩减配置的方式来摸索出问题的地方。刚好最近在学习使用 `strace` 工具，因此决定使用 `strace` 来看看 Emacs 到底卡在哪里。
```
strace emacs --fg-daemon
```
输出的内容特别多，这里只截取卡顿前的部分内容
```
readlinkat(AT_FDCWD, "/home", 0x7ffd1d3abb50, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972", 0x7ffd1d3abf00, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972/.emacs.d", 0x7ffd1d3ac2b0, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972/.emacs.d/elpa", 0x7ffd1d3ac660, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972/.emacs.d/elpa/exec-path-from-shell-20180323.1904", 0x7ffd1d3aca10, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972/.emacs.d/elpa/exec-path-from-shell-20180323.1904/exec-path-from-shell.elc", 0x7ffd1d3acdc0, 1024) = -1 EINVAL (无效的参数)
lseek(7, -2655, SEEK_CUR) = 1441
read(7, "\n(defvar exec-path-from-shell-de"..., 4096) = 4096
lseek(7, 5537, SEEK_SET) = 5537
lseek(7, 5537, SEEK_SET) = 5537
lseek(7, 5537, SEEK_SET) = 5537
lseek(7, 5537, SEEK_SET) = 5537
lseek(7, 5537, SEEK_SET) = 5537
lseek(7, 5537, SEEK_SET) = 5537
brk(0x7507000) = 0x7507000
lseek(7, 5537, SEEK_SET) = 5537
lseek(7, 5537, SEEK_SET) = 5537
lseek(7, 5537, SEEK_SET) = 5537
read(7, "230\\205\26\0\t\22\\307\\310\t!\vC\\\"\\211\24\\2"..., 4096) = 2430
lseek(7, 7967, SEEK_SET) = 7967
lseek(7, 7967, SEEK_SET) = 7967
lseek(7, 7967, SEEK_SET) = 7967
lseek(7, 7967, SEEK_SET) = 7967
read(7, "", 4096) = 0
close(7) = 0
getpid() = 10818
faccessat(AT_FDCWD, "/home/lujun9972/bin/printf", X_OK) = -1 ENOENT (没有那个文件或目录)
faccessat(AT_FDCWD, "/usr/local/sbin/printf", X_OK) = -1 ENOENT (没有那个文件或目录)
faccessat(AT_FDCWD, "/usr/local/bin/printf", X_OK) = -1 ENOENT (没有那个文件或目录)
faccessat(AT_FDCWD, "/usr/bin/printf", X_OK) = 0
stat("/usr/bin/printf", {st_mode=S_IFREG|0755, st_size=51176, ...}) = 0
openat(AT_FDCWD, "/dev/null", O_RDONLY|O_CLOEXEC) = 7
faccessat(AT_FDCWD, "/proc/5070/fd/.", F_OK) = 0
faccessat(AT_FDCWD, "/proc/5070/fd/.", F_OK) = 0
faccessat(AT_FDCWD, "/bin/bash", X_OK) = 0
stat("/bin/bash", {st_mode=S_IFREG|0755, st_size=903440, ...}) = 0
pipe2([8, 9], O_CLOEXEC) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
vfork() = 10949
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
close(9) = 0
close(7) = 0
read(8, "bash: \346\227\240\346\263\225\350\256\276\345\256\232\347\273\210\347\253\257\350\277\233\347\250\213\347\273"..., 16384) = 74
read(8, "bash: \346\255\244 shell \344\270\255\346\227\240\344\273\273\345\212\241\346\216\247\345"..., 16310) = 35
read(8, "setterm: \347\273\210\347\253\257 xterm-256color \344"..., 16275) = 51
read(8, "Couldn't get a file descriptor r"..., 16224) = 56
read(8, "bash: [: \357\274\232\351\234\200\350\246\201\346\225\264\346\225\260\350\241\250\350\276\276\345\274"..., 16168) = 34
read(8, "Your display number is 0\n", 16134) = 25
read(8, "Test whether fcitx is running co"..., 16109) = 53
read(8, "Fcitx is running correctly.\n\n==="..., 16056) = 87
read(8, "Launch fbterm...\n", 15969) = 17
read(8, "stdin isn't a tty!\n", 15952) = 19
read(8, "__RESULT\0/home/lujun9972/bin:/ho"..., 15933) = 298
read(8, 0x7ffd1d39ce9d, 15635) = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=10949, si_uid=1000, si_status=0, si_utime=10, si_stime=7} ---
rt_sigreturn({mask=[]}) = -1 EINTR (被中断的系统调用)
read(8, "", 15635) = 0
wait4(10949, [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 10949
close(8) = 0
getpid() = 10818
faccessat(AT_FDCWD, "/home/lujun9972/bin/printf", X_OK) = -1 ENOENT (没有那个文件或目录)
faccessat(AT_FDCWD, "/usr/local/sbin/printf", X_OK) = -1 ENOENT (没有那个文件或目录)
faccessat(AT_FDCWD, "/usr/local/bin/printf", X_OK) = -1 ENOENT (没有那个文件或目录)
faccessat(AT_FDCWD, "/usr/bin/printf", X_OK) = 0
stat("/usr/bin/printf", {st_mode=S_IFREG|0755, st_size=51176, ...}) = 0
openat(AT_FDCWD, "/dev/null", O_RDONLY|O_CLOEXEC) = 7
faccessat(AT_FDCWD, "/proc/5070/fd/.", F_OK) = 0
faccessat(AT_FDCWD, "/proc/5070/fd/.", F_OK) = 0
faccessat(AT_FDCWD, "/bin/bash", X_OK) = 0
stat("/bin/bash", {st_mode=S_IFREG|0755, st_size=903440, ...}) = 0
pipe2([8, 9], O_CLOEXEC) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
vfork() = 11679
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
close(9) = 0
close(7) = 0
read(8, "setterm: \347\273\210\347\253\257 xterm-256color \344"..., 16384) = 51
read(8, "Couldn't get a file descriptor r"..., 16333) = 56
read(8, "/home/lujun9972/.bash_profile: \347"..., 16277) = 72
read(8, "Your display number is 0\nTest wh"..., 16205) = 78
read(8, "Fcitx is running correctly.\n\n==="..., 16127) = 104
read(8, "stdin isn't a tty!\n", 16023) = 19
read(8, "__RESULT\0b269cd09e7ec4e8a115188c"..., 16004) = 298
read(8, 0x7ffd1d39cba6, 15706) = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=11679, si_uid=1000, si_status=0, si_utime=1, si_stime=1} ---
rt_sigreturn({mask=[]}) = -1 EINTR (被中断的系统调用)
read(8,
```
很容易就可以看出，当 Emacs 卡顿时，它在尝试从 8 号文件句柄中读取内容。
那么 8 号文件句柄在哪里定义的呢？往前看可以看到：
```
pipe2([8, 9], O_CLOEXEC) = 0
rt_sigprocmask(SIG_BLOCK, [INT CHLD], [], 8) = 0
vfork() = 11679
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
close(9) = 0
```
可以推测出，Emacs 主进程 `fork` 出一个子进程（进程号为 11679），并通过管道读取子进程的内容。
然而，从
```
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=11679, si_uid=1000, si_status=0, si_utime=1, si_stime=1} ---
rt_sigreturn({mask=[]}) = -1 EINTR (被中断的系统调用)
read(8,
```
可以看出，实际上子进程已经退出了（父进程收到 SIGCHLD 信号），父进程确依然在尝试从管道中读取内容，导致的阻塞。
而且从
```
read(8, "setterm: \347\273\210\347\253\257 xterm-256color \344"..., 16384) = 51
read(8, "Couldn't get a file descriptor r"..., 16333) = 56
read(8, "/home/lujun9972/.bash_profile: \347"..., 16277) = 72
read(8, "Your display number is 0\nTest wh"..., 16205) = 78
read(8, "Fcitx is running correctly.\n\n==="..., 16127) = 104
read(8, "stdin isn't a tty!\n", 16023) = 19
read(8, "__RESULT\0b269cd09e7ec4e8a115188c"..., 16004) = 298
read(8, 0x7ffd1d39cba6, 15706) = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
```
看到，子进程的输出似乎是我的交互式登录 bash 启动时的输出（加载了 `.bash_profile`）
在往前翻发现这么一段信息：
```
readlinkat(AT_FDCWD, "/home", 0x7ffd1d3abb50, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972", 0x7ffd1d3abf00, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972/.emacs.d", 0x7ffd1d3ac2b0, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972/.emacs.d/elpa", 0x7ffd1d3ac660, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972/.emacs.d/elpa/exec-path-from-shell-20180323.1904", 0x7ffd1d3aca10, 1024) = -1 EINVAL (无效的参数)
readlinkat(AT_FDCWD, "/home/lujun9972/.emacs.d/elpa/exec-path-from-shell-20180323.1904/exec-path-from-shell.elc", 0x7ffd1d3acdc0, 1024) = -1 EINVAL (无效的参数)
lseek(7, -2655, SEEK_CUR) = 1441
read(7, "\n(defvar exec-path-from-shell-de"..., 4096) = 4096
```
这很明显是跟 `exec-path-from-shell` 有关啊。
通过查看 `exec-path-from-shell` 的实现，发现 `exec-path-from-shell` 的实现原理是通过实际调启一个 shell，然后输出 `PATH` 和 `MANPATH` 的值的。 而且对于 `bash` 来说，默认的启动参数为 `-i -l`（可以通过`exec-path-from-shell-arguments`来设置）。也就是说 `bash` 会作为交互式的登录shell来启动的，因此会加载 `.bash_profile` 和 `.bashrc`。
既然发现跟 `exec-path-from-shell` 这个包有关，而且据说这个包对 Linux 其实意义不大，那不如直接禁用掉好了。
```
dotspacemacs-excluded-packages '(exec-path-from-shell)
```
再次重启Emacs，发现这次启动速度明显快了许多了。
|
|||
一份 Markdown 简介 | Juan Islas | https://opensource.com/article/19/9/introduction-markdown | 一次编辑便可将文本转换为多种格式。下面是如何开始使用 Markdown。 | /data/attachment/album/201909/29/123226bjte253n2h44cjjj.jpg.thumb.jpg | /data/attachment/album/201909/29/123226bjte253n2h44cjjj.jpg | true | false | true | lujun9972 | qfzy1233 | wxy | false | [
"Markdown"
] | 技术 | {
"viewnum": 4342,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 一次编辑便可将文本转换为多种格式。下面是如何开始使用 Markdown。 | 2019-09-29T12:32:44 | 2019-09-29T12:32:44 | 11,402 | /article-11402-1.html |
>
> 一次编辑便可将文本转换为多种格式。下面是如何开始使用 Markdown。
>
>
>
在很长一段时间里，我发现我在 GitLab 和 GitHub 上看到的所有文件都带有 **.md** 扩展名，这是专门为开发人员编写的文件类型。几周前，当我开始使用 Markdown 时，我的观念发生了变化。它很快成为我日常工作中最重要的工具。
Markdown 使我的生活更简易。我只需要在已经编写的代码中添加一些符号，并且在浏览器扩展或开源程序的帮助下，即可将文本转换为各种常用格式，如 ODT、电子邮件（稍后将详细介绍）、PDF 和 EPUB。
### 什么是 Markdown?
来自 [维基百科](https://en.wikipedia.org/wiki/Markdown)的友情提示:
>
> Markdown 是一种轻量级标记语言，具有纯文本格式语法。
>
>
>
这意味着通过在文本中使用一些额外的符号，Markdown 可以帮助你创建具有特定结构和格式的文档。当你以纯文本（例如，在记事本应用程序中）做笔记时，没有任何东西表明哪个文本应该是粗体或斜体。在普通文本中，你在写链接时需要将一个链接写为 “<http://example.com> ”，或者写为 “example.com”，又或“访问网站（example.com）”。这样没有内在的一致性。
但是如果你按照 Markdown 的方式编写，你的文本就有了内在的一致性。计算机喜欢一致性，因为这使得它们能够遵循严格的指令而不用担心异常。
相信我；一旦你学会使用 Markdown，每一项写作任务在某种程度上都会比以前更容易、更好。让我们开始吧。
### Markdown 基础
以下是使用 Markdown 的基础语法。
1、创建一个以 **.md** 扩展名结尾的文本文件（例如，`example.md`）。你可以使用任何文本编辑器（甚至像 LibreOffice 或 Microsoft word 这样的文字处理程序亦可），只要记住将其保存为*文本*文件。
2、想写什么就写什么，就像往常一样:
```
Lorem ipsum
Consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
De Finibus Bonorum et Malorum
Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.
Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt.
Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem.
```
（LCTT 译注：上述这段“Lorem ipsum”，中文又称“乱数假文”，是一篇常用于排版设计领域的拉丁文文章，主要目的为测试文章或文字在不同字型、版型下看起来的效果。）
3、确保在段落之间留有空行。如果你习惯写商务信函或传统散文，这可能会觉得不自然，因为那里段落只有一行，甚至在第一个单词前还有一个缩进。对于 Markdown，空行（一些文字处理程序使用 `¶`，称为Pilcrow 符号）保证在创建一个新段落应用另一种格式（如 HTML）。
4、指定标题和副标题。对于文档的标题，在文本前面添加一个井号或散列符号（`#`）和一个空格（例如 `# Lorem ipsum`）。第一个副标题级别使用两个（`## De Finibus Bonorum et Malorum`），下一个级别使用三个（`### 第三个副标题`），以此类推。注意，在井号和第一个单词之间有一个空格。
```
# Lorem ipsum
Consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
## De Finibus Bonorum et Malorum
Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.
Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt.
Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem.
```
5、如果你想使用**粗体**字符，只需将字母放在两个星号之间，没有空格：`**对应的文本将以粗体显示**`。
6、对于**斜体**，将文本放在没有空格的下划线符号之间：`_我希望这个本文以斜体显示_`。（LCTT 译注：有的 Markdown 流派会将用下划线引起来的字符串视作下划线文本，而单个星号 `*` 引用起来的才视作斜体。从兼容性的角度看，使用星号比较兼容。）
7、要插入一个链接（像 [Markdown Tutorial](https://www.markdowntutorial.com/)），把你想链接的文本放在括号里，URL 放在括号里，中间没有空格：`[Markdown Tutorial](<https://www.markdowntutorial.com/>)`。
8、块引用是用大于号编写的（`>`）在你要引用的文本前加上大于符号和空格: `> 名言引用`。
### Markdown 教程和技巧
这些技巧可以帮助你上手 Markdown ，但它涵盖了很多功能，不仅仅是粗体、斜体和链接。学习 Markdown 的最好方法是使用它，但是我建议你花 15 分钟来学习这篇简单的 [Markdown 教程](https://www.markdowntutorial.com/)，学以致用，勤加练习。
由于现代 Markdown 是对结构化文本概念的许多不同解释的融合，[CommonMark](https://commonmark.org/help/) 项目定义了一个规范，其中包含一组严格的规则，以使 Markdown 更加清晰。在编辑时手边准备一份[符合 CommonMark 的快捷键列表](https://opensource.com/downloads/cheat-sheet-markdown)可能会有帮助。
### 你能用 Markdown 做什么
Markdown 可以让你写任何你想写的东西，仅需一次编辑，就可以把它转换成几乎任何你想使用的格式。下面的示例演示如何将用 MD 编写简单的文本并转换为不同的格式。你不需要多种格式的文档-你可以仅仅编辑一次…然后拥有无限可能。
1、**简单的笔记**：你可以用 Markdown 编写你的笔记，并且在保存笔记时，开源笔记应用程序 [Turtl](https://turtlapp.com/) 将解释你的文本文件并显示为对应的格式。你可以把笔记存储在任何地方!
2、**PDF 文件**：使用 [Pandoc](https://opensource.com/article/19/5/convert-markdown-to-word-pandoc) 应用程序，你可以使用一个简单的命令将 Markdown 文件转换为 PDF：
```
pandoc <file.md> -o <file.pdf>
```
3、**Email**：你还可以通过安装浏览器扩展 [Markdown Here](https://markdown-here.com/) 将 Markdown 文本转换为 html 格式的电子邮件。要使用它，只需选择你的 Markdown 文本，在这里使用 Markdown 将其转换为 HTML，并使用你喜欢的电子邮件客户端发送消息。
### 现在就开始上手吧
你不需要一个特殊的应用程序来使用 Markdown，你只需要一个文本编辑器和上面的技巧。它与你已有的写作方式兼容；你所需要做的就是使用它，所以试试吧。
---
via: <https://opensource.com/article/19/9/introduction-markdown>
作者：[Juan Islas](https://opensource.com/users/xislas) 选题：[lujun9972](https://github.com/lujun9972) 译者：[qfzy1233](https://github.com/qfzy1233) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
区块链 2.0 ：以太坊（九） | Ostechnix | https://www.ostechnix.com/blockchain-2-0-what-is-ethereum/ | 以太坊系统经常被误认为就是加密货币以太币，但是，必须重申，以太坊是一个用于开发和执行应用程序的全栈平台，自成立以来一直如此，而比特币则不是。 | /data/attachment/album/201909/29/174151e7apavuw77b3so4a.png.thumb.jpg | /data/attachment/album/201909/29/174151e7apavuw77b3so4a.png | true | false | true | lujun9972 | wxy | wxy | false | [
"区块链",
"以太坊"
] | 区块链 | {
"viewnum": 10155,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11275,
"displayorder": 0
},
{
"raid": 11461,
"displayorder": 0
}
] | 以太坊系统经常被误认为就是加密货币以太币，但是，必须重申，以太坊是一个用于开发和执行应用程序的全栈平台，自成立以来一直如此，而比特币则不是。 | 2019-09-29T17:41:00 | 2019-09-29T17:41:00 | 11,404 | /article-11404-1.html | 
在本系列的上一指南中，我们讨论了 [Hyperledger 项目（HLP）](/article-11275-1.html)，这是一个由 Linux 基金会开发的增长最快的产品。在本指南中，我们将详细讨论什么是“<ruby> 以太坊 <rt> Ethereum </rt></ruby>”及其功能。许多研究人员认为，互联网的未来将基于<ruby> 去中心化计算 <rt> decentralized computing </rt></ruby>的原理。实际上，去中心化计算是互联网放在首位的更广泛目标之一。但是，由于可用的计算能力不同，互联网发生了转折。尽管现代服务器功能使得服务器端处理和执行成为可能，但在世界上大部分地区缺乏像样的移动网络使得客户端也是如此。现在，现代智能手机具有 SoC（片上系统），在客户端本身上也能够处理许多此类操作，但是，由于安全地检索和存储数据而受到的限制仍然迫使开发人员需要在服务器端进行计算和数据管理。因此，当前可以观察到数据传输能力方面存在瓶颈。
由于分布式数据存储和程序执行平台的进步，所有这些可能很快就会改变。[区块链](/article-10650-1.html)允许在分布式用户网络（而不是中央服务器）上进行安全的数据管理和程序执行，这在互联网历史上基本上是第一次。
以太坊就是一个这样的区块链平台，使开发人员可以访问用于在这样的去中心化网络上构建和运行应用程序的框架和工具。尽管它以其加密货币而广为人知，以太坊不只是<ruby> 以太币 <rt> ether </rt></ruby>（加密货币）。这是一种完整的<ruby> 图灵完备 <rt> Turing complete </rt></ruby>编程语言，旨在开发和部署 DApp（即<ruby> 分布式应用 <rt> Distributed APPlication </rt></ruby>） <sup id="fnref1"> <a href="#fn1" rel="footnote"> 1 </a></sup>。我们会在接下来的一篇文章中详细介绍 DApp。
以太坊是开源的，默认情况下是一个公共（非许可）区块链，并具有一个大范围的智能合约平台底层（Solidity）。以太坊提供了一个称为“<ruby> 以太坊虚拟机 <rt> Ethereum virtual machine </rt></ruby>（EVM）”的虚拟计算环境，以运行应用程序和[智能合约](/article-10956-1.html) <sup id="fnref2"> <a href="#fn2" rel="footnote"> 2 </a></sup>。以太坊虚拟机运行在世界各地的成千上万个参与节点上，这意味着应用程序数据在保证安全的同时，几乎不可能被篡改或丢失。
### 以太坊的背后：什么使之不同
在 2017 年，为了推广对以太坊区块链的功能的利用，技术和金融领域的 30 多个团队汇聚一堂。因此，“<ruby> 以太坊企业联盟 <rt> Ethereum Enterprise Alliance </rt></ruby>”（EEA）由众多支持成员组成，包括微软、摩根大通、思科、德勤和埃森哲。摩根大通已经拥有 Quorum，这是一个基于以太坊的去中心化金融服务计算平台，目前已经投入运行；而微软拥有基于以太坊的云服务，通过其 Azure 云业务销售 <sup id="fnref3"> <a href="#fn3" rel="footnote"> 3 </a></sup>。
### 什么是以太币，它和以太坊有什么关系
以太坊的创建者<ruby> 维塔利克·布特林 <rt> Vitalik Buterin </rt></ruby>深谙去中心化处理平台的真正价值以及为比特币提供动力的底层区块链技术。他提议比特币应该开发以支持运行分布式应用程序（DApp）和程序（现在称为智能合约）的想法，未能获得多数同意。
因此，他在 2013 年发表的白皮书中提出了以太坊的想法。原始白皮书仍然保留，[可供](https://github.com/ethereum/wiki/wiki/White-Paper)读者阅读。其理念是开发一个基于区块链的平台来运行智能合约和应用程序，这些合约和应用程序设计为在节点和用户设备上运行，而非服务器上运行。
以太坊系统经常被误认为就是加密货币以太币，但是，必须重申，以太坊是一个用于开发和执行应用程序的全栈平台，自成立以来一直如此，而比特币则不是。**以太网目前是按市值计算的第二大加密货币**，在撰写本文时，其平均交易价格为每个以太币 170 美元 <sup id="fnref4"> <a href="#fn4" rel="footnote"> 4 </a></sup>。
### 该平台的功能和技术特性 <sup id="fnref5"> <a href="#fn5" rel="footnote"> 5 </a></sup>
* 正如我们已经提到的，称为以太币的加密货币只是该平台功能之一。该系统的目的不仅仅是处理金融交易。 实际上，以太坊平台和比特币之间的主要区别在于它们的脚本能力。以太坊是以图灵完备的编程语言开发的，这意味着它具有类似于其他主要编程语言的脚本编程和应用程序功能。开发人员需要此功能才能在平台上创建 DApp 和复杂的智能合约，而该功能是比特币缺失的。
* 以太币的“挖矿”过程更加严格和复杂。尽管可以使用专用的 ASIC 来开采比特币，但以太坊使用的基本哈希算法（EThash）降低了 ASIC 在这方面的优势。
* 为激励矿工和节点运营者运行网络而支付的交易费用本身是使用称为 “<ruby> 燃料 <rt> Gas </rt></ruby>”的计算令牌来计算的。通过要求交易的发起者支付与执行交易所需的计算资源数量成比例的以太币，燃料提高了系统的弹性以及对外部黑客和攻击的抵抗力。这与其他平台（例如比特币）相反，在该平台上，交易费用与交易规模一并衡量。因此，以太坊的平均交易成本从根本上低于比特币。这也意味着在以太坊虚拟机上运行的应用程序需要付费，具体取决于应用程序要解决的计算问题。基本上，执行越复杂，费用就越高。
* 以太坊的出块时间估计约为 10 - 15 秒。出块时间是在区块链网络上打时间戳和创建区块所需的平均时间。与将在比特币网络上进行同样的交易要花费 10 分钟以上的时间相比，很明显，就交易和区块验证而言，以太坊要快得多。
* *有趣的是，对可开采的以太币数量或开采速度没有硬性限制，这导致其系统设计不像比特币那么激进*。
### 总结
尽管与以太坊相比，它远远超过了类似的平台，但在以太坊企业联盟开始推动之前，该平台本身尚缺乏明确的发展道路。虽然以太坊平台确实推动了企业发展，但必须注意，以太坊还可以满足小型开发商和个人的需求。 这样一来，为最终用户和企业开发的平台就为以太坊遗漏了许多特定功能。另外，以太坊基金会提出和开发的区块链模型是一种公共模型，而 Hyperledger 项目等项目提出的模型是私有的和需要许可的。
虽然只有时间才能证明以太坊、Hyperledger 和 R3 Corda 等平台中，哪一个平台会在现实场景中找到最多粉丝，但此类系统确实证明了以区块链为动力的未来主张背后的有效性。
---
1. [Gabriel Nicholas, “Ethereum Is Coding’s New Wild West | WIRED,” Wired , 2017](https://www.wired.com/story/ethereum-is-codings-new-wild-west/). [↩](#fnref1)
2. [What is Ethereum? — Ethereum Homestead 0.1 documentation](http://www.ethdocs.org/en/latest/introduction/what-is-ethereum.html#ethereum-virtual-machine). [↩](#fnref2)
3. [Ethereum, a Virtual Currency, Enables Transactions That Rival Bitcoin’s – The New York Times](https://www.nytimes.com/2016/03/28/business/dealbook/ethereum-a-virtual-currency-enables-transactions-that-rival-bitcoins.html). [↩](#fnref3)
4. [Cryptocurrency Market Capitalizations | CoinMarketCap](https://coinmarketcap.com/). [↩](#fnref4)
5. [Introduction — Ethereum Homestead 0.1 documentation](http://www.ethdocs.org/en/latest/introduction/index.html). [↩](#fnref5)
---
via: <https://www.ostechnix.com/blockchain-2-0-what-is-ethereum/>
作者：[ostechnix](https://www.ostechnix.com/author/editor/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
IBM 将区块链引入红帽 OpenShift；为混合云客户添加了Apache CouchDB | Michael Cooney | https://www.networkworld.com/article/3441362/ibm-brings-blockchain-to-red-hat-openshift-adds-apache-couchdb-for-hybrid-cloud-customers.html | IBM 在其区块链平台上增加了红帽 OpenShift 支持，并将用于 Apache CouchDB 的 Kubernetes Operator 引入其混合云服务中。 | /data/attachment/album/201909/29/220234zc6zk6i66nt66kk1.jpg.thumb.jpg | /data/attachment/album/201909/29/220234zc6zk6i66nt66kk1.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"IBM",
"区块链"
] | 新闻 | {
"viewnum": 3810,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | IBM 在其区块链平台上增加了红帽 OpenShift 支持，并将用于 Apache CouchDB 的 Kubernetes Operator 引入其混合云服务中。 | 2019-09-29T22:02:11 | 2019-09-29T22:02:11 | 11,405 | /article-11405-1.html |
>
> IBM 在其区块链平台上增加了红帽 OpenShift 支持，并将用于 Apache CouchDB 的 Kubernetes Operator 引入其混合云服务中。
>
>
>
IBM 本周继续推进其红帽和开源集成工作，在其[区块链](https://www.networkworld.com/article/3330937/how-blockchain-will-transform-the-iot.html)平台上添加了红帽 OpenShift 支持，并在其[混合云](https://www.networkworld.com/article/3268448/what-is-hybrid-cloud-really-and-whats-the-best-strategy.html)服务产品之外为 Apache CouchDB 引入了 Kubernetes Operator。
在该公司的旗舰级企业 Kubernetes 平台 [红帽 OpenShift 上部署 IBM 区块链](https://www.ibm.com/blogs/blockchain/2019/09/ibm-blockchain-platform-meets-red-hat-openshift/) 的能力，意味着 IBM 区块链的开发人员将能够在本地、公共云或混合云架构中部署安全软件。
区块链是一个分布式数据库，维护着一个不断增长的记录列表，可以使用哈希技术对其进行验证，并且 IBM 区块链平台包括用于构建、操作、治理和发展受保护的区块链网络的工具。
IBM 表示，其区块链 / OpenShift 组合的目标客户面对的公司客户是：希望保留区块链分类帐副本并在自己的基础设施上运行工作负载以实现安全性，降低风险或合规性；需要将数据存储在特定位置以满足数据驻留要求；需要在多个云或混合云架构中部署区块链组件。
自 7 月份完成对红帽的收购以来，IBM 一直在围绕红帽基于 Kubernetes 的 OpenShift 容器平台构建云开发生态系统。最近，这位蓝色巨人将其[新 z15 大型机与 IBM 的红帽](https://www.networkworld.com/article/3438542/ibm-z15-mainframe-amps-up-cloud-security-features.html)技术融合在一起，称它将为红帽 OpenShift 容器平台提供 IBM z/OS 云代理。该产品将通过连接到 Kubernetes 容器为用户提供 z/OS 计算资源的直接自助访问。
IBM 表示，打算在 IBM z 系列和 LinuxONE 产品上向 Linux 提供 IBM [Cloud Pak 产品](https://www.networkworld.com/article/3429596/ibm-fuses-its-software-with-red-hats-to-launch-hybrid-cloud-juggernaut.html)。Cloud Paks 是由 OpenShift 与 100 多种其他 IBM 软件产品组成的捆绑包。LinuxONE 是 IBM 专为支持 Linux 环境而设计的非常成功的大型机系统。
IBM 表示，愿景是使支持 OpenShift 的 IBM 软件成为客户用来转变其组织的基础构建组件。
IBM 表示：“我们的大多数客户都需要支持混合云工作负载以及可在任何地方运行这些工作负载的灵活性的解决方案，而用于红帽的 z/OS 云代理将成为我们在平台上启用云原生的关键。”
在相关新闻中，IBM 宣布支持开源 Apache CouchDB，这是 [Apache CouchDB](https://www.ibm.com/cloud/learn/couchdb) 的 Kubernetes Operator，并且该 Operator 已通过认证可与红帽 OpenShift 一起使用。Operator 可以自动部署、管理和维护 Apache CouchDB 部署。Apache CouchDB 是非关系型开源 NoSQL 数据库。
在最近的 [Forrester Wave 报告](https://reprints.forrester.com/#/assets/2/363/RES136481/reports)中，研究人员说：“企业喜欢 NoSQL 这样的能力，可以使用低成本服务器和可以存储、处理和访问任何类型的业务数据的灵活的无模式模型进行横向扩展。NoSQL 平台为企业基础设施专业人士提供了对数据存储和处理的更好控制，并提供了可加速应用程序部署的配置。当许多组织使用 NoSQL 来补充其关系数据库时，一些组织已开始替换它们以支持更好的性能、扩展规模并降低其数据库成本。”
当前，IBM 云使用 Cloudant Db 服务作为其针对新的云原生应用程序的标准数据库。IBM 表示，对 CouchDB 的强大支持为用户提供了替代方案和后备选项。IBM 表示，能够将它们全部绑定到红帽 OpenShift Kubernetes 部署中，可以使客户在部署应用程序并在多个云环境中移动数据时使用数据库本地复制功能来维持对数据的低延迟访问。
“我们的客户正在转向基于容器化和[微服务](https://www.networkworld.com/article/3137250/what-you-need-to-know-about-microservices.html)的架构，以提高速度、敏捷性和运营能力。在云原生应用程序开发中，应用程序需要具有支持可伸缩性、可移植性和弹性的数据层。”IBM 院士兼云数据库副总裁 Adam Kocoloski 写道，“我们相信数据可移植性和 CouchDB 可以大大改善多云架构的功能，使客户能够构建真正可在私有云、公共云和边缘位置之间移植的解决方案。”
---
via: <https://www.networkworld.com/article/3441362/ibm-brings-blockchain-to-red-hat-openshift-adds-apache-couchdb-for-hybrid-cloud-customers.html>
作者：[Michael Cooney](https://www.networkworld.com/author/Michael-Cooney/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 Python 入门数据科学 | Seth Kenlon | https://opensource.com/article/19/9/get-started-data-science-python | 使用 Python 开展数据科学为你提供了无限的潜力，使你能够以有意义和启发性的方式解析、解释和组织数据。 | /data/attachment/album/201909/30/001853sfkm07j7wfp94dzp.jpg.thumb.jpg | /data/attachment/album/201909/30/001853sfkm07j7wfp94dzp.jpg | true | false | true | lujun9972 | GraveAccent | wxy | false | [
"Python",
"数据科学"
] | 软件开发 | {
"viewnum": 6523,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 使用 Python 开展数据科学为你提供了无限的潜力，使你能够以有意义和启发性的方式解析、解释和组织数据。 | 2019-09-30T00:19:00 | 2019-09-30T00:19:00 | 11,406 | /article-11406-1.html |
>
> 使用 Python 开展数据科学为你提供了无限的潜力，使你能够以有意义和启发性的方式解析、解释和组织数据。
>
>
>
数据科学是计算领域一个令人兴奋的新领域，它围绕分析、可视化和关联以解释我们的计算机收集的有关世界的无限信息而建立。当然，称其为“新”领域有点不诚实，因为该学科是统计学、数据分析和普通而古老的科学观察派生而来的。
但是数据科学是这些学科的形式化分支，拥有自己的流程和工具，并且可以广泛应用于以前从未产生过大量不可管理数据的学科（例如视觉效果）。数据科学是一个新的机会，可以重新审视海洋学、气象学、地理学、制图学、生物学、医学和健康以及娱乐行业的数据，并更好地了解其中的模式、影响和因果关系。
像其他看似包罗万象的大型领域一样，知道从哪里开始探索数据科学可能会令人生畏。有很多资源可以帮助数据科学家使用自己喜欢的编程语言来实现其目标，其中包括最流行的编程语言之一：Python。使用 [Pandas](https://pandas.pydata.org/)、[Matplotlib](https://matplotlib.org/) 和 [Seaborn](https://seaborn.pydata.org/index.html) 这些库，你可以学习数据科学的基本工具集。
如果你对 Python 的基本用法不是很熟悉，请在继续之前先阅读我的 [Python 介绍](https://opensource.com/article/17/10/python-101)。
### 创建 Python 虚拟环境
程序员有时会忘记在开发计算机上安装了哪些库，这可能导致他们提供了在自己计算机上可以运行，但由于缺少库而无法在所有其它电脑上运行的代码。Python 有一个系统旨在避免这种令人不快的意外：虚拟环境。虚拟环境会故意忽略你已安装的所有 Python 库，从而有效地迫使你一开始使用通常的 Python 进行开发。
为了用 `venv` 激活虚拟环境, 为你的环境取个名字 (我会用 `example`) 并且用下面的指令创建它:
```
$ python3 -m venv example
```
<ruby> 导入 <rt> source </rt></ruby>该环境的 `bin` 目录里的 `activate` 文件以激活它：
```
$ source ./example/bin/activate
(example) $
```
你现在“位于”你的虚拟环境中。这是一个干净的状态，你可以在其中构建针对该问题的自定义解决方案，但是额外增加了需要有意识地安装依赖库的负担。
### 安装 Pandas 和 NumPy
你必须在新环境中首先安装的库是 Pandas 和 NumPy。这些库在数据科学中很常见，因此你肯定要时不时安装它们。它们也不是你在数据科学中唯一需要的库，但是它们是一个好的开始。
Pandas 是使用 BSD 许可证的开源库，可轻松处理数据结构以进行分析。它依赖于 NumPy，这是一个提供多维数组、线性代数和傅立叶变换等等的科学库。使用 `pip3` 安装两者：
```
(example) $ pip3 install pandas
```
安装 Pandas 还会安装 NumPy，因此你无需同时指定两者。一旦将它们安装到虚拟环境中，安装包就会被缓存，这样，当你再次安装它们时，就不必从互联网上下载它们。
这些是你现在仅需的库。接下来，你需要一些样本数据。
### 生成样本数据集
数据科学都是关于数据的，幸运的是，科学、计算和政府组织可以提供许多免费和开放的数据集。虽然这些数据集是用于教育的重要资源，但它们具有比这个简单示例所需的数据更多的数据。你可以使用 Python 快速创建示例和可管理的数据集：
```
#!/usr/bin/env python3
import random
def rgb():
NUMBER=random.randint(0,255)/255
return NUMBER
FILE = open('sample.csv','w')
FILE.write('"red","green","blue"')
for COUNT in range(10):
FILE.write('\n{:0.2f},{:0.2f},{:0.2f}'.format(rgb(),rgb(),rgb()))
```
这将生成一个名为 `sample.csv` 的文件，该文件由随机生成的浮点数组成，这些浮点数在本示例中表示 RGB 值（在视觉效果中通常是数百个跟踪值）。你可以将 CSV 文件用作 Pandas 的数据源。
### 使用 Pandas 提取数据
Pandas 的基本功能之一是可以提取数据和处理数据，而无需程序员编写仅用于解析输入的新函数。如果你习惯于自动执行此操作的应用程序，那么这似乎不是很特别，但请想象一下在 [LibreOffice](http://libreoffice.org) 中打开 CSV 并且必须编写公式以在每个逗号处拆分值。Pandas 可以让你免受此类低级操作的影响。以下是一些简单的代码，可用于提取和打印以逗号分隔的值的文件：
```
#!/usr/bin/env python3
from pandas import read_csv, DataFrame
import pandas as pd
FILE = open('sample.csv','r')
DATAFRAME = pd.read_csv(FILE)
print(DATAFRAME)
```
一开始的几行导入 Pandas 库的组件。Pandas 库功能丰富，因此在寻找除本文中基本功能以外的功能时，你会经常参考它的文档。
接下来，通过打开你创建的 `sample.csv` 文件创建变量 `FILE`。Pandas 模块 `read_csv`（在第二行中导入）使用该变量来创建<ruby> 数据帧 <rt> dataframe </rt></ruby>。在 Pandas 中，数据帧是二维数组，通常可以认为是表格。数据放入数据帧中后，你可以按列和行进行操作，查询其范围，然后执行更多操作。目前，示例代码仅将该数据帧输出到终端。
运行代码。你的输出会和下面的输出有些许不同，因为这些数字都是随机生成的，但是格式都是一样的。
```
(example) $ python3 ./parse.py
red green blue
0 0.31 0.96 0.47
1 0.95 0.17 0.64
2 0.00 0.23 0.59
3 0.22 0.16 0.42
4 0.53 0.52 0.18
5 0.76 0.80 0.28
6 0.68 0.69 0.46
7 0.75 0.52 0.27
8 0.53 0.76 0.96
9 0.01 0.81 0.79
```
假设你只需要数据集中的红色值（`red`），你可以通过声明数据帧的列名称并有选择地仅打印你感兴趣的列来做到这一点：
```
from pandas import read_csv, DataFrame
import pandas as pd
FILE = open('sample.csv','r')
DATAFRAME = pd.read_csv(FILE)
# define columns
DATAFRAME.columns = [ 'red','green','blue' ]
print(DATAFRAME['red'])
```
现在运行代码，你只会得到红色列：
```
(example) $ python3 ./parse.py
0 0.31
1 0.95
2 0.00
3 0.22
4 0.53
5 0.76
6 0.68
7 0.75
8 0.53
9 0.01
Name: red, dtype: float64
```
处理数据表是经常使用 Pandas 解析数据的好方法。从数据帧中选择数据的方法有很多，你尝试的次数越多就越习惯。
### 可视化你的数据
很多人偏爱可视化信息已不是什么秘密，这是图表和图形成为与高层管理人员开会的主要内容的原因，也是“信息图”在新闻界如此流行的原因。数据科学家的工作之一是帮助其他人理解大量数据样本，并且有一些库可以帮助你完成这项任务。将 Pandas 与可视化库结合使用可以对数据进行可视化解释。一个流行的可视化开源库是 [Seaborn](https://seaborn.pydata.org/)，它基于开源的 [Matplotlib](https://matplotlib.org/)。
#### 安装 Seaborn 和 Matplotlib
你的 Python 虚拟环境还没有 Seaborn 和 Matplotlib，所以用 `pip3` 安装它们。安装 Seaborn 的时候，也会安装 Matplotlib 和很多其它的库。
```
(example) $ pip3 install seaborn
```
为了使 Matplotlib 显示图形，你还必须安装 [PyGObject](https://pygobject.readthedocs.io/en/latest/getting_started.html) 和 [Pycairo](https://pycairo.readthedocs.io/en/latest/)。这涉及到编译代码，只要你安装了必需的头文件和库，`pip3` 便可以为你执行此操作。你的 Python 虚拟环境不了解这些依赖库，因此你可以在环境内部或外部执行安装命令。
在 Fedora 和 CentOS 上：
```
(example) $ sudo dnf install -y gcc zlib-devel bzip2 bzip2-devel readline-devel \
sqlite sqlite-devel openssl-devel tk-devel git python3-cairo-devel \
cairo-gobject-devel gobject-introspection-devel
```
在 Ubuntu 和 Debian 上：
```
(example) $ sudo apt install -y libgirepository1.0-dev build-essential \
libbz2-dev libreadline-dev libssl-dev zlib1g-dev libsqlite3-dev wget \
curl llvm libncurses5-dev libncursesw5-dev xz-utils tk-dev libcairo2-dev
```
一旦它们安装好了，你可以安装 Matplotlib 需要的 GUI 组件。
```
(example) $ pip3 install PyGObject pycairo
```
### 用 Seaborn 和 Matplotlib 显示图形
在你最喜欢的文本编辑器新建一个叫 `vizualize.py` 的文件。要创建数据的线形图可视化，首先，你必须导入必要的 Python 模块 —— 先前代码示例中使用的 Pandas 模块：
```
#!/usr/bin/env python3
from pandas import read_csv, DataFrame
import pandas as pd
```
接下来，导入 Seaborn、Matplotlib 和 Matplotlib 的几个组件，以便你可以配置生成的图形：
```
import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt
from matplotlib import rcParams
```
Matplotlib 可以将其输出导出为多种格式，包括 PDF、SVG 和桌面上的 GUI 窗口。对于此示例，将输出发送到桌面很有意义，因此必须将 Matplotlib 后端设置为 `GTK3Agg`。如果你不使用 Linux，则可能需要使用 `TkAgg` 后端。
设置完 GUI 窗口以后，设置窗口大小和 Seaborn 预设样式：
```
matplotlib.use('GTK3Agg')
rcParams['figure.figsize'] = 11,8
sns.set_style('darkgrid')
```
现在，你的显示已配置完毕，代码已经很熟悉了。使用 Pandas 导入 `sample.csv` 文件，并定义数据帧的列：
```
FILE = open('sample.csv','r')
DATAFRAME = pd.read_csv(FILE)
DATAFRAME.columns = [ 'red','green','blue' ]
```
有了适当格式的数据，你可以将其绘制在图形中。将每一列用作绘图的输入，然后使用 `plt.show()` 在 GUI 窗口中绘制图形。`plt.legend()` 参数将列标题与图形上的每一行关联（`loc` 参数将图例放置在图表之外而不是在图表上方）：
```
for i in DATAFRAME.columns:
DATAFRAME[i].plot()
plt.legend(bbox_to_anchor=(1, 1), loc=2, borderaxespad=1)
plt.show()
```
运行代码以获得结果。
你的图形可以准确显示 CSV 文件中包含的所有信息：值在 Y 轴上，索引号在 X 轴上，并且图形中的线也被标识出来了，以便你知道它们代表什么。然而，由于此代码正在跟踪颜色值（至少是假装），所以线条的颜色不仅不直观，而且违反直觉。如果你永远不需要分析颜色数据，则可能永远不会遇到此问题，但是你一定会遇到类似的问题。在可视化数据时，你必须考虑呈现数据的最佳方法，以防止观看者从你呈现的内容中推断出虚假信息。
为了解决此问题（并展示一些可用的自定义设置），以下代码为每条绘制的线分配了特定的颜色：
```
import matplotlib
from pandas import read_csv, DataFrame
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib import rcParams
matplotlib.use('GTK3Agg')
rcParams['figure.figsize'] = 11,8
sns.set_style('whitegrid')
FILE = open('sample.csv','r')
DATAFRAME = pd.read_csv(FILE)
DATAFRAME.columns = [ 'red','green','blue' ]
plt.plot(DATAFRAME['red'],'r-')
plt.plot(DATAFRAME['green'],'g-')
plt.plot(DATAFRAME['blue'],'b-')
plt.plot(DATAFRAME['red'],'ro')
plt.plot(DATAFRAME['green'],'go')
plt.plot(DATAFRAME['blue'],'bo')
plt.show()
```
这使用特殊的 Matplotlib 表示法为每列创建两个图。每列的初始图分配有一种颜色（红色为 `r`，绿色为 `g`，蓝色为 `b`）。这些是内置的 Matplotlib 设置。 `-` 表示实线（双破折号，例如 `r--`，将创建虚线）。为每个具有相同颜色的列创建第二个图，但是使用 `o` 表示点或节点。为了演示内置的 Seaborn 主题，请将 `sns.set_style` 的值更改为 `whitegrid`。
### 停用你的虚拟环境
探索完 Pandas 和绘图后，可以使用 `deactivate` 命令停用 Python 虚拟环境：
```
(example) $ deactivate
$
```
当你想重新使用它时，只需像在本文开始时一样重新激活它即可。重新激活虚拟环境时，你必须重新安装模块，但是它们是从缓存安装的，而不是从互联网下载的，因此你不必联网。
### 无尽的可能性
Pandas、Matplotlib、Seaborn 和数据科学的真正力量是无穷的潜力，使你能够以有意义和启发性的方式解析、解释和组织数据。下一步是使用你在本文中学到的新工具探索简单的数据集。Matplotlib 和 Seaborn 不仅有折线图，还有很多其他功能，因此，请尝试创建条形图或饼图或完全不一样的东西。
一旦你了解了你的工具集并对如何关联数据有了一些想法，则可能性是无限的。数据科学是寻找隐藏在数据中的故事的新方法。让开源成为你的媒介。
---
via: <https://opensource.com/article/19/9/get-started-data-science-python>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[GraveAccent](https://github.com/GraveAccent) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 中国徽标征集活动进展汇报 | 老王 | 以下是我们当前收到的设计展示及设计理念，我们共收到了 9 位贡献者提交的 12 份设计。 | /data/attachment/album/201909/30/072922u5vvh1pu7cl1t61i.jpg.thumb.jpg | /data/attachment/album/201909/30/072922u5vvh1pu7cl1t61i.jpg | true | false | false | false | [
"徽标"
] | 新闻 | {
"viewnum": 3448,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "183.48.21.26",
"message": "不会用Github怎么办QAQ",
"username": "来自广东广州的 Chrome 45.0|Android 5.0 用户",
"date": "2019-10-03T21:04:17"
},
{
"postip": "202.118.96.177",
"message": "研究下，这里只涉及到了最简单的部分内容。先fork，自己修改，在pull即可。",
"username": "来自辽宁大连大连理工大学的 Chrome 77.0|GNU/Linux 用户",
"date": "2019-10-04T21:06:36"
},
{
"postip": "183.48.22.205",
"message": "会了，谢谢!",
"username": "来自广东广州的 Chrome 68.0|Android 5.0 用户",
"date": "2019-10-06T23:27:47"
}
] | [
{
"raid": 11363,
"displayorder": 0
},
{
"raid": 11488,
"displayorder": 0
}
] | 以下是我们当前收到的设计展示及设计理念，我们共收到了 9 位贡献者提交的 12 份设计。 | 2019-09-30T07:58:50 | 2019-09-30T07:58:50 | 11,407 | /article-11407-1.html | 
自从 10 天前，我们发起了[徽标征集活动](/article-11363-1.html)，得到了大家的踊跃支持。虽然有相当多朋友表示原来的徽标就挺好，是的修改下就可以，但是也有很多朋友给我们提交了新的徽标设计及其设计理念。以下，我将这些设计展示给大家，大家可以发表意见。当然，也欢迎更多朋友来提交你们的徽标设计。
### 当前已经收到的徽标设计
以下是我们当前收到的设计展示及设计理念，我们共收到了 9 位贡献者提交的 12 份设计。以下按名字排序列出：
#### 1466587594
地址：<https://github.com/LCTT/logo/tree/master/1466587594>
设计者：1466587594
设计理念：
* 徽标呈箭头状,代表回车键
* 蓝绿配色,完全照搬样例,外加了一个两者的混合色
* 主体是稍带圆角又显锐利的字母 L 与 C 的结合,要说带有一些含义的话不免有些强行了
#### alim0x
地址：<https://github.com/LCTT/logo/tree/master/alim0x>
设计者：alim0x
设计理念：
* 扁平化图标，符合当下趋势
* 主体风格延续原有徽标，减轻徽标更换对受众印象认知的影响
* 中间为原徽标风格的 “L”，小圆点增加徽标活泼感
* 外圈为 “C” 抽象而来，代表 “CN”、“Community”
* 配色上绿色作为主题色，同时中环使用浅绿色作为过渡，使徽标更清新且饱满
#### flag-1
地址：<https://github.com/LCTT/logo/tree/master/flag-1>
设计者：ullpdq
设计理念：
* 一直觉得国旗设计得很美
#### flag-2
地址：<https://github.com/LCTT/logo/tree/master/flag-2>
设计者：ullpdq
设计理念：
* 国旗方案的变种
### logo0281
地址：<https://github.com/LCTT/logo/tree/master/logo0281>
设计者：liujiacode
设计理念：
* 该徽标保留了旧徽标的配色 (绿, 白, 灰) 和一些元素 (如中间的 "L"). 在旧徽标的基础上, 本徽标**更强调社区与社区成员之间的联系**. Linux 社区如同一张复杂而有序的网络, 紧紧地将成员联系在一起.
* 徽标背景由深灰色方块和浅灰色中国版图构成, 表示 Linux.CN 主要是面向全国的 Linux 技术社区.
* 图中四个角落分别有朝向不同方向的 "C" ("C" 代表 "Community"), 表示参与到社区中的开源爱好者们专业技能不同, 目标也不同.
* 图正中有一个 "L" ("L" 代表 "Linux", 是旧徽标中的关键元素之一), 代表 Linux 社区.
* 四个 "C" 的开口方向都朝向中间的 "L" , 表示开源爱好者们相互交流与合作, 共同构建起整个社区. "C" 与 "L" 通过一张复杂而又有序的网络连接在一起, 表示开源爱好者们之间并不是相互孤立的, 而是通过社区网络稳定而有序地结合在一起.
* "C" 也可以代表 "Component", 表示 Linux 系统是由多个组件构成的. 这些组件之间并不是相互孤立的, 这些组件的协同作用使得 Linux 能够正常运行.
* 图案下方写有社区名称, 即 "Linux.CN".
#### logo0964
地址：<https://github.com/LCTT/logo/tree/master/logo0964>
设计者：liujiacode
设计理念：
* 徽标背景由深灰色方块和浅灰色中国版图构成, 表示 Linux.CN 主要是面向全国的 Linux 技术社区.
* 图中绿色方框代表 Linux 终端, 终端内有命令提示符 "LC:~$\_". 其中 "LC" 是 "Linux.CN" 的缩写.
* 绿色方框叠加在一起, 表示使用 Linux 的开源爱好者们相互交流与合作, 共同构建起整个社区.
* 图案下方写有社区名称, 即 "Linux.CN".
#### long
地址：<https://github.com/LCTT/logo/tree/master/long>
设计者：lujun9972
设计理念：
* 巨龙,毛笔,石砚,玉佩,筷子.尽显中国气息.
备注：此设计稿规格不符合要求（500x500 的正方形）。
#### RedInLinux
地址：<https://github.com/LCTT/logo/tree/master/RedInLinux>
设计者：Marksteinsong
设计理念：
* 为表示对“Linux中国的支持”，特地来凑个数。
备注：此设计稿规格不符合要求（500x500 的正方形）。
#### tinnx
地址：<https://github.com/LCTT/logo/tree/master/tinnx>
设计者：AntonVanke
设计理念：
* 主体是LC
* 下面一行Linux.cn
#### WSJ
地址：<https://github.com/LCTT/logo/tree/master/WSJ>
设计者：wangshijun-shexian
设计理念：
* 尽量保留原logo元素，以维持用户记忆，减少突兀感；
* 保留的元素有①灰黑色背景色调②大写字母L③网址④整体造型；
* 改变的元素有①底部绿色改成更新的苹果绿②绿色范围减小，去掉网址，可与圆形内接等边三角形贴合，增加图形稳定性，给放大主logo元素让出空间③大写字母L放大，去掉隔断，填充网址④L东侧是大写字母C，颜色与底部颜色相同，可以凸显原logo架构，主体形状与L相似，东北部加等腰直角三角形，与L共同组成正方形，该正方形可联想成向东怒吼的雄狮侧面部，寓意Linux中国在中国大地孔武有力，大有作为；
* 新logo可方可圆，黑白阴阳稿也一样简洁醒目，可用于各类应用场合。
#### wxy
地址：<https://github.com/LCTT/logo/tree/master/wxy>
设计者：wxy
设计理念：
* 本徽标的灵感来自于俄罗斯方块游戏。
* 配色的蓝绿：绿色一直是我们主题色，蓝色比较搭配，当然要是给它赋予专业、自由的寓意也无不可。
* 主体是一个 4x4 的离散格子，其中由两个字母组成，分别“L”和“c”，这是我们的简写。
#### yue-1
地址：<https://github.com/LCTT/logo/tree/master/yue-1>
设计者：ullpdq
设计理念：
* 这个方案是钺，配色什么的就随意了，回头可以再调整
### 徽标征集活动
活动目标：为 Linux 中国设计制作一个新的徽标
活动时间：2019 年 9 月 20 日 — 2019 年 10 月 31 日
时间节点：
* 2019 年 9 月 20 日 — 2019 年 10 月 20 日：徽标征集及点评
* 2019 年 9 月 21 日 — 2019 年 10 月 30 日：官方评选
* 2019 年 10 月 31 日 评选结果发布
参与方式：本活动完全在 GitHub 上进行，因此投稿、点评、建议都采用 GitHub 相应机制来完成。
仓库地址： <https://github.com/LCTT/logo>
* 投稿：通过 GitHub 的 PR 提交你的徽标设计展示图和设计说明。格式要求：
+ 每个投稿一个自行命名的文件夹，不当命名我们会予以修改。文件夹内包括：
+ 名为 logo.png 的 png 格式的徽标，尺寸为 500px X 500px，评选阶段无需投递原稿
+ 一个名为 README.md 的说明文件，说明创意构思
* 点评：对提交徽标的 PR 发表评论
* 建议：通过 GitHub 的<ruby> 议题 <rt> issue </rt></ruby>发起
最后，既然是征集评选活动，那就该有奖品：
* 一等奖（获选）一名，奖金 3000 元
* 二等奖两名，各奖 500 元
* 三等奖五名，各奖 100 元
此外，一等奖作品的作者需同样将该的完整版权授予 Linux 中国，但作品作者的相关信息会在 Linux 中国官方予以记录和致谢。
|
||||
使用 Terminator 在一个窗口中运行多个终端 | Sandra Henry-stocker | https://www.networkworld.com/article/3436784/how-to-use-terminator-on-linux-to-run-multiple-terminals-in-one-window.html | Terminator 为在单窗口中运行多个 GNOME 终端提供了一个选择，让你可以灵活地调整工作空间来适应你的需求。 | /data/attachment/album/201909/30/233732j9jjx3xxuujopiuu.jpg.thumb.jpg | /data/attachment/album/201909/30/233732j9jjx3xxuujopiuu.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"终端",
"Terminator"
] | 分享 | {
"viewnum": 9282,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Terminator 为在单窗口中运行多个 GNOME 终端提供了一个选择，让你可以灵活地调整工作空间来适应你的需求。 | 2019-09-30T23:38:00 | 2019-09-30T23:38:00 | 11,409 | /article-11409-1.html | 
>
> Terminator 为在单窗口中运行多个 GNOME 终端提供了一个选择，让你可以灵活地调整工作空间来适应你的需求。
>
>
>
如果你曾经希望可以排列多个终端并将它们组织在一个窗口中，那么我们可能会给你带来一个好消息。 Linux 的 Terminator 可以为你做到这一点。没有问题！
### 分割窗口
Terminator 最初打开像是一个单一窗口的终端窗口一样。但是，一旦在该窗口中单击鼠标，它将弹出一个选项，让你可以灵活地进行更改。你可以选择“水平分割”或“垂直分割”，将你当前所在的窗口分为两个较小的窗口。实际上，菜单旁会有小的分割结果图示（类似于 `=` and `||`），你可以根据需要重复拆分窗口。当然，你如果将整个窗口分为六个或九个以上，那么你可能会发现它们太小而无法有效使用。
使用 ASCII 艺术来说明分割窗口的过程，你可能会看到类似以下的样子：
```
+-------------------+ +-------------------+ +-------------------+
| | | | | |
| | | | | |
| | ==> |-------------------| ==> |-------------------|
| | | | | | |
| | | | | | |
+-------------------+ +-------------------+ +-------------------+
原始终端 水平分割 垂直分割
```
另一种拆分窗口的方法是使用控制键组合，例如，使用 `Ctrl+Shift+e` 垂直分割窗口，使用 `Ctrl+Shift+o`（“o” 表示“打开”）水平分割窗口。
在 Terminator 分割完成后，你可以点击任意窗口使用，并根据工作需求在窗口间移动。
### 最大化窗口
如果你想暂时忽略除了一个窗口外的其他窗口而只关注一个，你可以单击该窗口，然后从菜单中选择“最大化”选项。接着该窗口会撑满所有空间。再次单击并选择“还原所有终端”可以返回到多窗口显示。使用 `Ctrl+Shift+x` 将在正常和最大化设置之间切换。
窗口标签上的窗口大小指示（例如 80x15）显示了每行的字符数以及每个窗口的行数。
### 关闭窗口
要关闭任何窗口，请打开 Terminator 菜单，然后选择“关闭”。其他窗口将自行调整占用空间，直到你关闭最后一个窗口。
### 保存你的自定义设置
将窗口分为多个部分后，将自定义的 Terminator 设置设置为默认非常容易。从弹出菜单中选择“首选项”，然后从打开的窗口顶部的选项卡中选择“布局”。接着你应该看到列出了“新布局”。只需单击底部的“保存”，然后单击右下角的“关闭”。Terminator 会将你的设置保存在 `~/.config/terminator/config` 中，然后每次使用到时都会使用该文件。
你也可以通过使用鼠标拉伸来扩大整个窗口。再说一次，如果要保留更改，请从菜单中选择“首选项”，“布局”，接着选择“保存”和“关闭”。
### 在保存的配置之间进行选择
如果愿意，你可以通过维护多个配置文件来设置多种 Terminator 窗口布局，重命名每个配置文件（如 `config-1`、`config-2`），接着在你想使用它时将它移动到 `~/.config/terminator/config`。这有一个类似执行此任务的脚本。它让你在 3 个预配置的窗口布局之间进行选择。
```
#!/bin/bash
PS3='Terminator options: '
options=("Split 1" "Split 2" "Split 3" "Quit")
select opt in "${options[@]}"
do
case $opt in
"Split 1")
config=config-1
break
;;
"Split 2")
config=config-2
break
;;
"Split 3")
config=config-3
break
;;
*)
exit
;;
esac
done
cd ~/.config/terminator
cp config config-
cp $config config
cd
terminator &
```
如果有用的话，你可以给选项一个比 `config-1` 更有意义的名称。
### 总结
Terminator 是设置多窗口处理相关任务的不错选择。如果你从未使用过它，那么可能需要先使用 `sudo apt install terminator` 或 `sudo yum install -y terminator` 之类的命令进行安装。
希望你喜欢使用 Terminator。还有，如另一个同名角色所说，“我会回来的！”
---
via: <https://www.networkworld.com/article/3436784/how-to-use-terminator-on-linux-to-run-multiple-terminals-in-one-window.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
2019 年最好的 Linux 发行版 | Ankush Das | https://itsfoss.com/best-linux-distributions/ | 哪个是最好的 Linux 发行版呢？这个问题是没有明确的答案的。这就是为什么我们按各种分类汇编了这个最佳 Linux 列表的原因。 | /data/attachment/album/201910/01/140807rlo3cz2l99tdoc6d.jpg.thumb.jpg | /data/attachment/album/201910/01/140807rlo3cz2l99tdoc6d.jpg | true | false | true | lujun9972 | heguangzhi | wxy | true | [
"发行版"
] | 观点 | {
"viewnum": 41553,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "101.224.73.173",
"message": "稿费好拿系列。",
"username": "来自上海的 Chrome 77.0|Mac 10.14 用户",
"date": "2019-10-01T15:53:43"
},
{
"postip": "182.53.196.214",
"message": "作者很厉害，知道我们有些人想说deepin linux,哈哈",
"username": "来自泰国的 Chrome 79.0|Windows 10 用户",
"date": "2019-12-20T10:41:59"
}
] | [
{
"raid": 10146,
"displayorder": 0
}
] | 哪个是最好的 Linux 发行版呢？这个问题是没有明确的答案的。这就是为什么我们按各种分类汇编了这个最佳 Linux 列表的原因。 | 2019-10-01T14:08:00 | 2019-10-01T14:08:00 | 11,411 | /article-11411-1.html |
>
> 哪个是最好的 Linux 发行版呢？这个问题是没有明确的答案的。这就是为什么我们按各种分类汇编了这个最佳 Linux 列表的原因。
>
>
>
有许多 Linux 发行版，我甚至想不出一个确切的数量，因为你会发现很多不同的 Linux 发行版。
其中有些只是另外一个的复制品，而有些往往是独一无二的。这虽然有点混乱——但这也是 Linux 的优点。
不用担心，尽管有成千上万的发行版，在这篇文章中，我已经列出了目前最好的 Linux 发行版。当然，这个列表是主观的。但是，在这里，我们试图对发行版进行分类——每个发行版本都有自己的特点的。
* 面向初学者的 Linux 用户的最佳发行版
* 最佳 Linux 服务器发行版
* 可以在旧计算机上运行的最佳 Linux 发行版
* 面向高级 Linux 用户的最佳发行版
* 最佳常青树 Linux 发行版
**注：** 该列表没有特定的排名顺序。
### 面向初学者的最佳 Linux 发行版
在这个分类中，我们的目标是列出开箱即用的易用发行版。你不需要深度学习，你可以在安装后马上开始使用，不需要知道任何命令或技巧。
#### Ubuntu
Ubuntu 无疑是最流行的 Linux 发行版之一。你甚至可以发现它已经预装在很多笔记本电脑上了。
用户界面很容易适应。如果你愿意，你可以根据自己的要求轻松定制它的外观。无论哪种情况，你都可以选择安装一个主题。你可以从了解更多关于[如何在 Ubuntu 安装主题的](https://itsfoss.com/install-themes-ubuntu/)的信息来起步。
除了它本身提供的功能外，你会发现一个巨大的 Ubuntu 用户在线社区。因此，如果你有问题——可以去任何论坛（或版块）寻求帮助。如果你想直接寻找解决方案，你应该看看我们对 [Ubuntu](https://itsfoss.com/tag/ubuntu/) 的报道（我们有很多关于 Ubuntu 的教程和建议）。
* [Ubuntu](https://ubuntu.com/download/desktop)
#### Linux Mint
Linux Mint Cinnamon 是另一个受初学者欢迎的 Linux 发行版。默认的 Cinnamon 桌面类似于 Windows XP，这就是为什么当 Windows XP 停止维护时许多用户选择它的原因。
Linux Mint 基于 Ubuntu，因此它具有适用于 Ubuntu 的所有应用程序。简单易用是它成为 Linux 新用户首选的原因。
* [Linux Mint](https://www.linuxmint.com/)
#### elementary OS
elementary OS 是我用过的最漂亮的 Linux 发行版之一。用户界面类似于苹果操作系统——所以如果你已经使用了苹果系统，则很容易适应。
该发行版基于 Ubuntu，致力于提供一个用户友好的 Linux 环境，该环境在考虑性能的同时尽可能美观。如果你选择安装 elementary OS，这份[在安装 elementary OS 后要做的 11 件事的清单](https://itsfoss.com/things-to-do-after-installing-elementary-os-5-juno/)会派上用场。
* [elementary OS](https://elementary.io/)
#### MX Linux
大约一年前，MX Linux 成为众人瞩目的焦点。现在（在发表这篇文章的时候），它是 [DistroWatch.com](https://distrowatch.com/) 上最受欢迎的 Linux 发行版。如果你还没有使用过它，那么当你开始使用它时，你会感到惊讶。
与 Ubuntu 不同，MX Linux 是一个基于 Debian 的日益流行的发行版，采用 Xfce 作为其桌面环境。除了无与伦比的稳定性之外，它还配备了许多图形用户界面工具，这使得任何习惯了 Windows/Mac 的用户易于使用它。
此外，软件包管理器还专门针对一键安装进行了量身定制。你甚至可以搜索 [Flatpak](https://flatpak.org/) 软件包并立即安装它（默认情况下，Flathub 在软件包管理器中是可用的来源之一）。
* [MX Linux](https://mxlinux.org/)
#### Zorin OS
Zorin OS 是又一个基于 Ubuntu 的发行版，它又是桌面上最漂亮、最直观的操作系统之一。尤其是在[Zorin OS 15 发布](https://itsfoss.com/zorin-os-15-release/)之后——我绝对会向没有任何 Linux 经验的用户推荐它。它也引入了许多基于图形用户界面的应用程序。
你也可以将其安装在旧电脑上，但是，请确保选择“Lite”版本。此外，你还有“Core”、“Education”和 “Ultimate”版本可以选择。你可以选择免费安装 Core 版，但是如果你想支持开发人员并帮助改进 Zorin，请考虑获得 Ultimate 版。
Zorin OS 是由两名爱尔兰的青少年创建的。你可以[在这里阅读他们的故事](https://itsfoss.com/zorin-os-interview/)。
* [Zorin OS](https://zorinos.com/)
#### Pop!\_OS
Sytem76 的 Pop!\_OS 是开发人员或计算机科学专业人员的理想选择。当然，不仅限于编码人员，如果你刚开始使用 Linux，这也是一个很好的选择。它基于 Ubuntu，但是其 UI 感觉更加直观和流畅。除了 UI 外，它还强制执行全盘加密。
你可以通过文章下面的评论看到，我们的许多读者似乎都喜欢（并坚持使用）它。如果你对此感到好奇，也应该查看一下我们关于 Phillip Prado 的 [Pop!\_OS 的动手实践](https://itsfoss.com/pop-os-linux-review/)的文章。
（LCTT 译注：这段推荐是原文后来补充的，因为原文下面很多人在评论推荐。）
* [Pop!\_OS](https://system76.com/pop)
#### 其他选择
[深度操作系统](https://www.deepin.org/en/) 和其他的 Ubuntu 变种（如 Kubuntu、Xubuntu）也是初学者的首选。如果你想寻求更多的选择，你可以看看。（LCTT 译注：我知道你们肯定对将深度操作系统列入其它不满意——这个锅归原作者。）
如果你想要挑战自己，你可以试试 Ubuntu 之外的 Fedora —— 但是一定要看看我们关于 [Ubuntu 和 Fedora 对比](https://itsfoss.com/ubuntu-vs-fedora/)的文章，从桌面的角度做出更好的选择。
### 最好的服务器发行版
对于服务器来说，选择 Linux 发行版取决于稳定性、性能和企业级支持。如果你只是尝试，则可以尝试任何你想要的发行版。
但是，如果你要为 Web 服务器或任何重要的组件安装它，你应该看看我们的一些建议。
#### Ubuntu 服务器
根据你的需要，Ubuntu 为你的服务器提供了不同的选项。如果你正在寻找运行在 AWS、Azure、谷歌云平台等平台上的优化解决方案，[Ubuntu Cloud](https://ubuntu.com/download/cloud) 是一个很好的选择。
无论是哪种情况，你都可以选择 Ubuntu 服务器包，并将其安装在你的服务器上。然而，Ubuntu 在云上部署时也是最受欢迎的 Linux 发行版（根据数字判断——[来源1](https://w3techs.com/technologies/details/os-linux/all/all)、[来源2](https://thecloudmarket.com/stats)）。
请注意，除非你有特殊要求，我们建议你选择 LTS 版。
* [Ubuntu Server](https://ubuntu.com/download/server)
#### 红帽企业版 Linux（RHEL）
红帽企业版 Linux（RHEL）是面向企业和组织的顶级 Linux 平台。如果我们按数字来看，红帽可能不是服务器领域最受欢迎的。但是，有相当一部分企业用户依赖于 RHEL (比如联想)。
从技术上讲，Fedora 和红帽企业版是相关联的。无论红帽要支持什么——在出现在 RHEL 之前，都要在 Fedora 上进行测试。我不是定制需求的服务器发行版专家，所以你一定要查看他们的[官方文档](https://developers.redhat.com/products/rhel/docs-and-apis)以了解它是否适合你。
* [RHEL](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux)
#### SUSE Linux 企业服务器（SLES）
别担心，不要把这和 OpenSUSE 混淆。一切都以一个共同的品牌 “SUSE” 命名 —— 但是 OpenSUSE 是一个开源发行版，目标是社区，并且由社区维护。
SUSE Linux 企业服务器（SLES）是基于云的服务器最受欢迎的解决方案之一。为了获得管理开源解决方案的优先支持和帮助，你必须选择订阅。
* [SLES](https://www.suse.com/products/server/)
#### CentOS
正如我提到的，对于 RHEL 你需要订阅。而 CentOS 更像是 RHEL 的社区版，因为它是从 RHEL 的源代码中派生出来的。而且，它是开源的，也是免费的。尽管与过去几年相比，使用 CentOS 的托管提供商数量明显减少，但这仍然是一个很好的选择。
CentOS 可能没有加载最新的软件包，但它被认为是最稳定的发行版之一，你可以在各种云平台上找到 CentOS 镜像。如果没有，你可以选择 CentOS 提供的自托管镜像。
* [CentOS](https://www.centos.org/)
#### 其他选择
你也可以尝试 [Fedora Server](https://getfedora.org/en/server/)或[Debian](https://www.debian.org/distrib/)作为上述发行版的替代品。
### 旧电脑的最佳 Linux 发行版
如果你有一台旧电脑，或者你真的不需要升级你的系统，你仍然可以尝试一些最好的 Linux 发行版。
我们已经详细讨论了一些[最好的轻量级 Linux 发行版](https://itsfoss.com/lightweight-linux-beginners/)。在这里，我们将只提到那些真正突出的东西（以及一些新的补充）。
#### Puppy Linux
Puppy Linux 实际上是最小的发行版本之一。刚开始使用 Linux 时，我的朋友建议我尝试一下 Puppy Linux，因为它可以轻松地在较旧的硬件配置上运行。
如果你想在你的旧电脑上享受一次爽快的体验，那就值得去看看。多年来，随着一些新的有用特性的增加，用户体验得到了改善。
* [Puppy Linux](http://puppylinux.com/)
#### Solus Budgie
在最近的一个主要版本——[Solus 4 Fortitude](https://itsfoss.com/solus-4-release/) 之后，它是一个令人印象深刻的轻量级桌面操作系统。你可以选择像 GNOME 或 MATE 这样的桌面环境。然而，Solus Budgie 恰好是我的最爱之一，它是一款适合初学者的功能齐全的 Linux发行版，同时对系统资源要求很少。
* [Solus](https://getsol.us/home/)
#### Bodhi
Bodhi Linux 构建于 Ubuntu 之上。然而，与Ubuntu不同，它在较旧的配置上运行良好。
这个发行版的主要亮点是它的 [Moksha 桌面](http://www.bodhilinux.com/moksha-desktop/)（这是 Enlightenment 17 桌面的延续）。用户体验直观且反应极快。即使我个人不用它，你也应该在你的旧系统上试一试。
* [Bodhi Linux](http://www.bodhilinux.com/)
#### antiX
antiX 部分担起了 MX Linux 的责任，它是一个轻量级的 Linux 发行版，为新的或旧的计算机量身定制。其用户界面并不令人印象深刻——但它可以像预期的那样工作。
它基于 Debian，可以作为一个现场版 CD 发行版使用，而不需要安装它。antiX 还提供现场版引导加载程序。与其他发行版相比，你可以保存设置，这样就不会在每次重新启动时丢失设置。不仅如此，你还可以通过其“持久保留”功能将更改保存到根目录中。
因此，如果你正在寻找一个可以在旧硬件上提供快速用户体验的现场版 USB 发行版，antiX 是一个不错的选择。
* [antiX](https://antixlinux.com/)
#### Sparky Linux
Sparky Linux 基于 Debian，它是理想的低端系统 Linux 发行版。伴随着超快的用户体验，Sparky Linux 为不同的用户提供了几个特殊版本（或变种）。
例如，它提供了针对一组用户的稳定版本（和变种）和滚动版本。Sparky Linux GameOver 版非常受游戏玩家欢迎，因为它包含了一堆预装的游戏。你可以查看我们的[最佳 Linux 游戏发行版](https://itsfoss.com/linux-gaming-distributions/) —— 如果你也想在你的系统上玩游戏。
#### 其他选择
你也可以尝试 [Linux Lite](https://www.linuxliteos.com/)、[Lubuntu](https://lubuntu.me/)、[Peppermint](https://peppermintos.com/) 等轻量级 Linux 发行版。
### 面向高级用户的最佳 Linux 发行版
一旦你习惯了各种软件包管理器和命令来帮助你解决任何问题，你就可以开始找寻只为高级用户量身定制的 Linux 发行版。
当然，如果你是专业人士，你会有一套具体的要求。然而，如果你已经作为普通用户使用了一段时间——以下发行版值得一试。
#### Arch Linux
Arch Linux 本身是一个简单而强大的发行版，具有陡峭的学习曲线。不像其系统，你不会一次就把所有东西都预先安装好。你必须配置系统并根据需要添加软件包。
此外，在安装 Arch Linux 时，必须按照一组命令来进行（没有图形用户界面）。要了解更多信息，你可以按照我们关于[如何安装 Arch Linux](https://itsfoss.com/install-arch-linux/) 的指南进行操作。如果你要安装它，你还应该知道在[安装 Arch Linux 后需要做的一些基本事情](https://itsfoss.com/things-to-do-after-installing-arch-linux/)。这会帮助你快速入门。
除了多才多艺和简便性之外，值得一提的是 Arch Linux 背后的社区非常活跃。所以，如果你遇到问题，你不用担心。
* [Arch Linux](https://www.archlinux.org)
#### Gentoo
如果你知道如何编译源代码，Gentoo Linux 是你必须尝试的版本。这也是一个轻量级的发行版，但是，你需要具备必要的技术知识才能使它发挥作用。
当然，[官方手册](https://wiki.gentoo.org/wiki/Handbook:Main_Page)提供了许多你需要知道的信息。但是，如果你不确定自己在做什么——你需要花很多时间去想如何充分利用它。
* [Gentoo Linux](https://www.gentoo.org)
#### Slackware
Slackware 是仍然重要的最古老的 Linux 发行版之一。如果你愿意编译或开发软件来为自己建立一个完美的环境 —— Slackware 是一个不错的选择。
如果你对一些最古老的 Linux 发行版感到好奇，我们有一篇关于[最早的 Linux 发行版](https://itsfoss.com/earliest-linux-distros/)可以去看看。
尽管使用它的用户/开发人员的数量已经显著减少，但对于高级用户来说，它仍然是一个极好的选择。此外，最近有个新闻是 [Slackware 有了一个 Patreon 捐赠页面](https://distrowatch.com/dwres.php?resource=showheadline&story=8743)，我们希望 Slackware 继续作为最好的 Linux 发行版之一存在。
* [Slackware](http://www.slackware.com/)
### 最佳多用途 Linux 发行版
有些 Linux 发行版既可以作为初学者友好的桌面又可以作为高级操作系统的服务器。因此，我们考虑为这样的发行版编辑一个单独的部分。
如果你不同意我们的观点（或者有建议要补充），请在评论中告诉我们。我们认为，这对于每个用户都可以派上用场：
#### Fedora
Fedora 提供两个独立的版本：一个用于台式机/笔记本电脑（Fedora 工作站），另一个用于服务器（Fedora 服务器)。
因此，如果你正在寻找一款时髦的桌面操作系统，有点学习曲线，又对用户友好，那么 Fedora 是一个选择。无论是哪种情况，如果你正在为你的服务器寻找一个 Linux 操作系统，这也是一个不错的选择。
* [Fedora](https://getfedora.org/)
#### Manjaro
Manjaro 基于 [Arch Linux](https://www.archlinux.org/)。不用担心，虽然 Arch Linux 是为高级用户量身定制的，但Manjaro 让新手更容易上手。这是一个简单且对初学者友好的 Linux 发行版。用户界面足够好，并且内置了一系列有用的图形用户界面应用程序。
下载时，你可以为 Manjaro 选择[桌面环境](https://itsfoss.com/glossary/desktop-environment/)。就个人而言，我喜欢 Manjaro 的 KDE 桌面。
* [Manjaro Linux](https://manjaro.org/)
#### Debian
嗯，Ubuntu 是基于 Debian 的——所以它本身是一个非常好的发行版本。Debian 是台式机和服务器的理想选择。
这可能不是对初学者最友好的操作系统——但你可以通过阅读[官方文档](https://www.debian.org/releases/stable/installmanual)轻松开始。[Debian 10 Buster](https://itsfoss.com/debian-10-buster/) 的最新版本引入了许多变化和必要的改进。所以，你必须试一试！
### 总结
总的来说，这些是我们推荐你去尝试的最好的 Linux 发行版。是的，还有许多其他的 Linux 发行版值得一提，但是根据个人喜好，对每个发行版来说，取决于个人喜好，这种选择是主观的。
但是，我们也为 [Windows 用户](https://itsfoss.com/windows-like-linux-distributions/)、[黑客和脆弱性测试人员](https://itsfoss.com/linux-hacking-penetration-testing/)、[游戏玩家](https://itsfoss.com/linux-gaming-distributions/)、[程序员](https://itsfoss.com/best-linux-distributions-progammers/)和[偏重隐私者](https://itsfoss.com/privacy-focused-linux-distributions/)提供了单独的发行版列表所以，如果你感兴趣的话请仔细阅读。
如果你认为我们遗漏了你最喜欢的 Linux 发行版，请在下面的评论中告诉我们你的想法，我们将更新这篇文章。
---
via: <https://itsfoss.com/best-linux-distributions/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
滚动版 CentOS Stream 和 Fedora 的关系 | Matthew Miller | https://fedoramagazine.org/fedora-and-centos-stream/ | 如果 CentOS 现在位于 RHEL 的上游，那么 Fedora 会发生什么？那不是 Fedora 在 Red Hat 生态系统中的角色吗？ | /data/attachment/album/201910/02/093523xigcv6mx7ximcmzc.jpg.thumb.jpg | /data/attachment/album/201910/02/093523xigcv6mx7ximcmzc.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"RHEL",
"CentOS",
"Fedora"
] | 观点 | {
"viewnum": 10992,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 如果 CentOS 现在位于 RHEL 的上游，那么 Fedora 会发生什么？那不是 Fedora 在 Red Hat 生态系统中的角色吗？ | 2019-10-02T09:35:00 | 2019-10-02T09:35:00 | 11,412 | /article-11412-1.html | 
*一封来自 Fedora 项目负责人办公室的信件：*
（LCTT 译注：背景介绍 —— 红帽宣布与 CentOS 同步构建一个 CentOS Stream 滚动构建版。我们知道 Fedora 是红帽企业版 Linux [RHEL] 的上游，经过 Fedora 验证的特性才会放入 RHEL；而 RHEL 发布后，其源代码开放出来形成了 CentOS。而新的 CentOS Stream 则位于 Fedora 和 RHEL 之间，会滚动添加新的实验特性、更新的软件包等。）
嗨，大家好！你可能已经看到有关 [CentOS 项目变更](https://wiki.centos.org/Manuals/ReleaseNotes/CentOSStream)的[公告](http://redhat.com/en/blog/transforming-development-experience-within-centos)。（如果没有，请花一些时间阅读它，我等你看完回来！）现在你可能想知道：如果 CentOS 现在位于 RHEL 的上游，那么 Fedora 会发生什么？那不是 Fedora 在 Red Hat 生态系统中的角色吗？
首先，不用担心。整体有一些变化，但是一切都变得更好。
如果你一直在关注 RHEL 领导者关于 Fedora、CentOS 和 RHEL 之间关系的会议讨论，那么你就听说过 “<ruby> <a href="https://www.youtube.com/watch?v=1JmgOkEznjw"> 彭罗斯三角 </a> <rt> Penrose Triangle </rt></ruby>”。形状就像 M. C. Escher 绘图中的形状：在现实生活中这是不可能的！
我们已经思考了一段时间，*也许*几何不可能实际上是最好的模型。
一方面，想象中的流向最终的贡献会流回 Fedora 并以“良性循环”增长，但这种流从来没有真正起作用过。 真可惜，因为有一个庞大而强大的 CentOS 社区，并且有很多伟大的人在为此工作，而且 Fedora 社区也有很多重叠之处。我们错失了。
但是，这个缺口并不是唯一的空隙：在该项目与产品之间并没有真正一致的流程。到目前为止，该过程如下：
1. 在上一版 RHEL 发布之后的某个时间，红帽突然会比以往更加关注 Fedora。
2. 几个月后，红帽将分拆出一个内部开发的 RHEL 新版本。
3. 几个月后，它便被带到了世界各地，成为所有包括 CentOS 在内的下游发行版的来源。
4. 这些源持续向下更新，有时这些更新包括 Fedora 中的修补程序，但没有明确的路径。
这里的每个步骤都有其问题：间歇性注意力、闭门开发、盲目下发以及几乎没有持续的透明度。但是现在红帽和 CentOS 项目正在解决此问题，这对 Fedora 也是个好消息。
**Fedora 仍将是 RHEL 的[第一个](https://docs.fedoraproject.org/en-US/project/#_first)上游**。这是每个 RHEL 的来源，也是 RHEL 9 的来源。但是在 RHEL 分支之后，*CentOS* 将成为上游，以继续进行那些 RHEL 版本的工作。我喜欢称其为“中游”，但营销人员却不这样称呼，因此将其称为 “CentOS Stream”。
我们（Fedora、CentOS 和红帽）仍需要解决各种技术细节，但是我们的想法是这些分支将存在于同一软件包源存储库中。（目前的计划是制作一个 “src.centos.org”，它具有与 [src.fedoraproject.org](https://src.fedoraproject.org/) 相同数据的并行视图）。这项更改使公众可以看到已经发布的 RHEL 上正在进行的工作，并为开发人员和红帽合作伙伴在该级别进行协作提供了场所。
[CentOS SIG](https://wiki.centos.org/SpecialInterestGroup)（虚拟化、存储、配置管理等特殊兴趣小组）将在 Fedora 分支旁边的共享空间中开展工作。这将使项目之间的协作和共享更加容易，我希望我们甚至能够合并一些类似的 SIG，以直接协同工作。在有用的情况下，可以将 Fedora 软件包中的修补程序挑选到 CentOS “中游”中，反之亦然。
最终，Fedora、CentOS 和 RHEL 属于同一大型项目家族。这种新的、更自然的流程为协作提供了可能性，这些协作被锁定在人为（和超维度！）障碍的后面。我们现在可以一起做，我感到非常兴奋！
*—— Matthew Miller, Fedora 项目负责人*
---
via: <https://fedoramagazine.org/fedora-and-centos-stream/>
作者：[Matthew Miller](https://fedoramagazine.org/author/mattdm/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
CutiePi：正在开发中的基于树莓派的开源平板 | Ankush Das | https://itsfoss.com/cutiepi-open-source-tab/ | CutiePi 是一款 8 英寸的构建在树莓派上的开源平板。他们在树莓派论坛上宣布：现在，它只是一台原型机。 | /data/attachment/album/201910/02/125301wkbvgz1n7zv7j55e.jpg.thumb.jpg | /data/attachment/album/201910/02/125301wkbvgz1n7zv7j55e.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"树莓派"
] | 新闻 | {
"viewnum": 4022,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | CutiePi 是一款 8 英寸的构建在树莓派上的开源平板。他们在树莓派论坛上宣布：现在，它只是一台原型机。 | 2019-10-02T12:53:30 | 2019-10-02T12:53:30 | 11,414 | /article-11414-1.html | 
CutiePi 是一款 8 英寸的构建在树莓派上的开源平板。他们在[树莓派论坛](https://www.raspberrypi.org/forums/viewtopic.php?t=247380)上宣布：现在，它只是一台原型机。
在本文中，你将了解有关 CutiePi 的规格、价格和可用性的更多详细信息。
它们使用一款定制的计算模块载版（CM3）来制造平板。[官网](https://cutiepi.io/)提到使用定制 CM3 载板的目的是：
>
> 定制 CM3/CM3+ 载板是专为便携使用而设计，拥有增强的电源管理和锂聚合物电池电量监控功能。还可与指定的 HDMI 或 MIPI DSI 显示器配合使用。
>
>
>
因此，这使得该平板足够薄而且便携。
### CutiePi 规格
我惊讶地了解到它有 8 英寸的 IPS LCD 显示屏，这对新手而言是个好事。然而，你不会有一个真正高清的屏幕，因为官方宣称它的分辨率是 1280×800。
它还计划配备 4800 mAh 锂电池（原型机的电池为 5000 mAh）。嗯，对于平板来说，这不算坏。
连接性上包括支持 Wi-Fi 和蓝牙 4.0。此外，还有一个 USB Type-A 插口、6 个 GPIO 引脚和 microSD 卡插槽。
硬件与 [Raspbian OS](https://itsfoss.com/raspberry-pi-os-desktop/) 官方兼容，用户界面采用 [Qt](https://en.wikipedia.org/wiki/Qt_%28software%29) 构建，以获得快速直观的用户体验。此外，除了内置应用外，它还将通过 XWayland 支持 Raspbian PIXEL 应用。
### CutiePi 源码
你可以通过分析所用材料的清单来猜测此平板的定价。CutiePi 遵循 100% 的开源硬件设计。因此，如果你觉得好奇，可以查看它的 [GitHub 页面](https://github.com/cutiepi-io/cutiepi-board)，了解有关硬件设计和内容的详细信息。
### CutiePi 价格、发布日期和可用性
CutiePi 计划在 8 月进行[设计验证测试](https://en.wikipedia.org/wiki/Engineering_validation_test#Design_verification_test)批量 PCB。他们的目标是在 2019 年底推出最终产品。
官方预计，发售价大约在 $150-$250 左右。这只是一个近似的范围，还应该保有怀疑。
显然，即使产品听上去挺有希望，但价格将是它成功的一个主要因素。
### 总结
CutiePi 并不是第一个使用[像树莓派这样的单板计算机](https://itsfoss.com/raspberry-pi-alternatives/)来制作平板的项目。我们有即将推出的 [PineTab](https://www.pine64.org/pinetab/)，它基于 Pine64 单板电脑。Pine 还有一种笔记本电脑，名为 [Pinebook](https://itsfoss.com/pinebook-pro/)。
从原型来看，它确实是一个我们可以期望使用的产品。但是，预安装的应用和它将支持的应用可能会扭转局面。此外，考虑到价格估计，这听起来很有希望。
你觉得怎么样？让我们在下面的评论中知道你的想法，或者投个票。
---
via: <https://itsfoss.com/cutiepi-open-source-tab/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 rsync 复制大文件的一些误解 | Daniel Leite De Abreu | https://fedoramagazine.org/copying-large-files-with-rsync-and-some-misconceptions/ | 这位朋友认为 rsync 是一个神奇的工具，应该仅“同步”文件本身。但是，我们大多数人所忘记的是了解 rsync 的真正含义、用法，以及我认为最重要的是它原本是用来做什么的。 | /data/attachment/album/201910/02/134003xeowu3qppvl6fz3j.jpg.thumb.jpg | /data/attachment/album/201910/02/134003xeowu3qppvl6fz3j.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"rsync"
] | 技术 | {
"viewnum": 8068,
"commentnum": 1,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "117.136.79.139",
"message": "rsync（remote synchronize），目前由 http://rsync.samba.org 维护。<br />\r\n该软件主要是用在Linux系统中，但在 windows 平台下也有相应的版本，如 cwrsync 和DeltaCopy 等。",
"username": "phoenix_wangxd [Chrome 77.0|Mac 10.14]",
"date": "2019-10-06T18:02:52"
}
] | [] | 这位朋友认为 rsync 是一个神奇的工具，应该仅“同步”文件本身。但是，我们大多数人所忘记的是了解 rsync 的真正含义、用法，以及我认为最重要的是它原本是用来做什么的。 | 2019-10-02T13:40:00 | 2019-10-02T13:40:00 | 11,415 | /article-11415-1.html | 
有一种观点认为，在 IT 行业工作的许多人经常从网络帖子里复制和粘贴。我们都干过，复制粘贴本身不是问题。问题是当我们在不理解它们的情况下这样干。
几年前，一个曾经在我团队中工作的朋友需要将虚拟机模板从站点 A 复制到站点 B。他们无法理解为什么复制的文件在站点 A 上为 10GB，但是在站点 B 上却变为 100GB。
这位朋友认为 `rsync` 是一个神奇的工具，应该仅“同步”文件本身。但是，我们大多数人所忘记的是了解 `rsync` 的真正含义、用法，以及我认为最重要的是它原本是用来做什么的。本文提供了有关 `rsync` 的更多信息，并解释了那件事中发生了什么。
### 关于 rsync
`rsync` 是由 Andrew Tridgell 和 Paul Mackerras 创建的工具，其动机是以下问题：
假设你有两个文件，`file_A` 和 `file_B`。你希望将 `file_B` 更新为与 `file_A` 相同。显而易见的方法是将 `file_A` 复制到 `file_B`。
现在，假设这两个文件位于通过慢速通信链接（例如，拨号 IP 链接）连接的两个不同的服务器上。如果`file_A` 大，将其复制到 `file_B` 将会很慢，有时甚至是不可能完成的。为了提高效率，你可以在发送前压缩 `file_A`，但这通常只会获得 2 到 4 倍的效率提升。
现在假设 `file_A` 和 `file_B` 非常相似，并且为了加快处理速度，你可以利用这种相似性。一种常见的方法是仅通过链接发送 `file_A` 和 `file_B` 之间的差异，然后使用这个差异列表在远程端重建文件。
问题在于，用于在两个文件之间创建一组差异的常规方法依赖于能够读取两个文件。因此，它们要求链接的一端预先提供两个文件。如果它们在同一台计算机上不是同时可用的，则无法使用这些算法。（一旦将文件复制过来，就不需要做对比差异了）。而这是 `rsync` 解决的问题。
`rsync` 算法有效地计算源文件的哪些部分与现有目标文件的部分匹配。这样，匹配的部分就不需要通过链接发送了；所需要的只是对目标文件部分的引用。只有源文件中不匹配的部分才需要发送。
然后，接收者可以使用对现有目标文件各个部分的引用和原始素材来构造源文件的副本。
另外，可以使用一系列常用压缩算法中的任何一种来压缩发送到接收器的数据，以进一步提高速度。
我们都知道，`rsync` 算法以一种漂亮的方式解决了这个问题。
在 `rsync` 的介绍之后，回到那件事！
### 问题 1：自动精简配置
有两件事可以帮助那个朋友了解正在发生的事情。
该文件在其他地方的大小变得越来越大的问题是由源系统上启用了<ruby> 自动精简配置 <rt> Thin Provisioning </rt></ruby>（TP）引起的，这是一种优化存储区域网络（SAN）或网络连接存储（NAS）中可用空间效率的方法。
由于启用了 TP，源文件只有 10GB，并且在不使用任何其他配置的情况下使用 `rsync` 进行传输时，目标位置将接收到全部 100GB 的大小。`rsync` 无法自动完成该（TP）操作，必须对其进行配置。
进行此工作的选项是 `-S`（或 `–sparse`），它告诉 `rsync` 有效地处理稀疏文件。它会按照它说的做！它只会发送该稀疏数据，因此源和目标将有一个 10GB 的文件。
### 问题 2：更新文件
当发送一个更新的文件时会出现第二个问题。现在目标仅接收 10GB 了，但始终传输的是整个文件（包含虚拟磁盘），即使只是在该虚拟磁盘上更改了一个配置文件。换句话说，只是该文件的一小部分发生了更改。
用于此传输的命令是：
```
rsync -avS vmdk_file syncuser@host1:/destination
```
同样，了解 `rsync` 的工作方式也将有助于解决此问题。
上面是关于 `rsync` 的最大误解。我们许多人认为 `rsync` 只会发送文件的增量更新，并且只会自动更新需要更新的内容。**但这不是 `rsync` 的默认行为**。
如手册页所述，`rsync` 的默认行为是在目标位置创建文件的新副本，并在传输完成后将其移动到正确的位置。
要更改 `rsync` 的默认行为，你必须设置以下标志，然后 `rsync` 将仅发送增量：
```
--inplace 原地更新目标文件
--partial 保留部分传输的文件
--append 附加数据到更短的文件
--progress 在传输时显示进度条
```
因此，可以确切地执行我那个朋友想要的功能的完整命令是：
```
rsync -av --partial --inplace --append --progress vmdk_file syncuser@host1:/destination
```
注意，出于两个原因，这里必须删除稀疏选项 `-S`。首先是通过网络发送文件时，不能同时使用 `–sparse` 和 `–inplace`。其次，当你以前使用过 `–sparse` 发送文件时，就无法再使用 `–inplace` 进行更新。请注意，低于 3.1.3 的 `rsync` 版本将拒绝 `–sparse` 和 `–inplace` 的组合。
因此，即使那个朋友最终通过网络复制了 100GB，那也只需发生一次。以下所有更新仅复制差异，从而使复制非常高效。
---
via: <https://fedoramagazine.org/copying-large-files-with-rsync-and-some-misconceptions/>
作者：[Daniel Leite de Abreu](https://fedoramagazine.org/author/dabreu/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
chown 命令简介 | Alan Formy-duval | https://opensource.com/article/19/8/linux-chown-command | 学习如何使用 chown 命令更改文件或目录的所有权。 | /data/attachment/album/201910/03/000014mfrxrxi5rej75mjs.jpg.thumb.jpg | /data/attachment/album/201910/03/000014mfrxrxi5rej75mjs.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"chown"
] | 技术 | {
"viewnum": 8333,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11399,
"displayorder": 0
}
] | 学习如何使用 chown 命令更改文件或目录的所有权。 | 2019-10-03T00:01:11 | 2019-10-03T00:01:11 | 11,416 | /article-11416-1.html |
>
> 学习如何使用 chown 命令更改文件或目录的所有权。
>
>
>
Linux 系统上的每个文件和目录均由某个人拥有，拥有者可以完全控制更改或删除他们拥有的文件。除了有一个*拥有用户*外，文件还有一个*拥有组*。
你可以使用 `ls -l` 命令查看文件的所有权：
```
[pablo@workstation Downloads]$ ls -l
total 2454732
-rw-r--r--. 1 pablo pablo 1934753792 Jul 25 18:49 Fedora-Workstation-Live-x86_64-30-1.2.iso
```
该输出的第三和第四列是拥有用户和组，它们一起称为*所有权*。上面的那个 ISO 文件这两者都是 `pablo`。
所有权设置由 [chmod 命令](https://opensource.com/article/19/8/introduction-linux-chmod-command)进行设置，控制允许谁可以执行读取、写入或运行的操作。你可以使用 `chown` 命令更改所有权（一个或两者）。
所有权经常需要更改。文件和目录一直存在在系统中，但用户不断变来变去。当文件和目录在系统中移动时，或从一个系统移动到另一个系统时，所有权也可能需要更改。
我的主目录中的文件和目录的所有权是我的用户和我的主要组，以 `user:group` 的形式表示。假设 Susan 正在管理 Delta 组，该组需要编辑一个名为 `mynotes` 的文件。你可以使用 `chown` 命令将该文件的用户更改为 `susan`，组更改为 `delta`：
```
$ chown susan:delta mynotes
ls -l
-rw-rw-r--. 1 susan delta 0 Aug 1 12:04 mynotes
```
当给该文件设置好了 Delta 组时，它可以分配回给我：
```
$ chown alan mynotes
$ ls -l mynotes
-rw-rw-r--. 1 alan delta 0 Aug 1 12:04 mynotes
```
给用户后添加冒号（`:`），可以将用户和组都分配回给我：
```
$ chown alan: mynotes
$ ls -l mynotes
-rw-rw-r--. 1 alan alan 0 Aug 1 12:04 mynotes
```
通过在组前面加一个冒号，可以只更改组。现在，`gamma` 组的成员可以编辑该文件：
```
$ chown :gamma mynotes
$ ls -l
-rw-rw-r--. 1 alan gamma 0 Aug 1 12:04 mynotes
```
`chown` 的一些附加参数都能用在命令行和脚本中。就像许多其他 Linux 命令一样，`chown` 有一个递归参数（`-R`），它告诉该命令进入目录以对其中的所有文件进行操作。没有 `-R` 标志，你就只能更改文件夹的权限，而不会更改其中的文件。在此示例中，假定目的是更改目录及其所有内容的权限。这里我添加了 `-v`（详细）参数，以便 `chown` 报告其工作情况：
```
$ ls -l . conf
.:
drwxrwxr-x 2 alan alan 4096 Aug 5 15:33 conf
conf:
-rw-rw-r-- 1 alan alan 0 Aug 5 15:33 conf.xml
$ chown -vR susan:delta conf
changed ownership of 'conf/conf.xml' from alan:alan to susan:delta
changed ownership of 'conf' from alan:alan to susan:delta
```
根据你的角色，你可能需要使用 `sudo` 来更改文件的所有权。
在更改文件的所有权以匹配特定配置时，或者在你不知道所有权时（例如运行脚本时），可以使用参考文件（`--reference=RFILE`）。例如，你可以复制另一个文件（`RFILE`，称为参考文件）的用户和组，以撤消上面所做的更改。回想一下，点（`.`）表示当前的工作目录。
```
$ chown -vR --reference=. conf
```
### 报告更改
大多数命令都有用于控制其输出的参数。最常见的是 `-v`（`--verbose`）以启用详细信息，但是 `chown` 还具有 `-c`（`--changes`）参数来指示 `chown` 仅在进行更改时报告。`chown` 还会报告其他情况，例如不允许进行的操作。
参数 `-f`（`--silent`、`--quiet`）用于禁止显示大多数错误消息。在下一节中，我将使用 `-f` 和 `-c`，以便仅显示实际更改。
### 保持根目录
Linux 文件系统的根目录（`/`）应该受到高度重视。如果命令在此层级上犯了一个错误，则后果可能会使系统完全无用。尤其是在运行一个会递归修改甚至删除的命令时。`chown` 命令具有一个可用于保护和保持根目录的参数，它是 `--preserve-root`。如果在根目录中将此参数和递归一起使用，那么什么也不会发生，而是会出现一条消息：
```
$ chown -cfR --preserve-root alan /
chown: it is dangerous to operate recursively on '/'
chown: use --no-preserve-root to override this failsafe
```
如果不与 `--recursive` 结合使用，则该选项无效。但是，如果该命令由 `root` 用户运行，则 `/` 本身的权限将被更改，但其下的其他文件或目录的权限则不会更改：
```
$ chown -c --preserve-root alan /
chown: changing ownership of '/': Operation not permitted
[root@localhost /]# chown -c --preserve-root alan /
changed ownership of '/' from root to alan
```
### 所有权即安全
文件和目录所有权是良好的信息安全性的一部分，因此，偶尔检查和维护文件所有权以防止不必要的访问非常重要。`chown` 命令是 Linux 安全命令集中最常见和最重要的命令之一。
---
via: <https://opensource.com/article/19/8/linux-chown-command>
作者：[Alan Formy-Duval](https://opensource.com/users/alanfdosshttps://opensource.com/users/sethhttps://opensource.com/users/alanfdosshttps://opensource.com/users/sethhttps://opensource.com/users/greg-phttps://opensource.com/users/alanfdoss) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Shell 点文件可以为你做点什么 | H.waldo Grunenwald | https://opensource.com/article/18/9/shell-dotfile | 了解如何使用配置文件来改善你的工作环境。 | /data/attachment/album/201910/03/123528x3skwqwb8sz8qo8s.jpg.thumb.jpg | /data/attachment/album/201910/03/123528x3skwqwb8sz8qo8s.jpg | true | false | true | lujun9972 | wxy | wxy | true | [
"点文件"
] | 技术 | {
"viewnum": 6769,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11419,
"displayorder": 0
}
] | 了解如何使用配置文件来改善你的工作环境。 | 2019-10-03T12:35:39 | 2019-10-03T12:35:39 | 11,417 | /article-11417-1.html |
>
> 了解如何使用配置文件来改善你的工作环境。
>
>
>
不要问你可以为你的 shell <ruby> 点文件 <rt> dotfile </rt></ruby>做什么，而是要问一个 shell 点文件可以为你做什么！
我一直在操作系统领域里面打转，但是在过去的几年中，我的日常使用的一直是 Mac。很长一段时间，我都在使用 Bash，但是当几个朋友开始把 [zsh](http://www.zsh.org/) 当成宗教信仰时，我也试试了它。我没用太长时间就喜欢上了它，几年后，我越发喜欢它做的许多小事情。
我一直在使用 zsh（通过 [Homebrew](https://brew.sh/) 提供，而不是由操作系统安装的）和 [Oh My Zsh 增强功能](https://github.com/robbyrussell/oh-my-zsh)。
本文中的示例是我的个人 `.zshrc`。大多数都可以直接用在 Bash 中，我觉得不是每个人都依赖于 Oh My Zsh，但是如果不用的话你的工作量可能会有所不同。曾经有一段时间，我同时为 zsh 和 Bash 维护一个 shell 点文件，但是最终我还是放弃了我的 `.bashrc`。
### 不偏执不行
如果你希望在各个操作系统上使用相同的点文件，则需要让你的点文件聪明点。
```
### Mac 专用
if [[ "$OSTYPE" == "darwin"* ]]; then
# Mac 专用内容在此
```
例如，我希望 `Alt + 箭头键` 将光标按单词移动而不是单个空格。为了在 [iTerm2](https://www.iterm2.com/)（我的首选终端）中实现这一目标，我将此代码段添加到了 `.zshrc` 的 Mac 专用部分：
```
### Mac 专用
if [[ "$OSTYPE" == "darwin"* ]]; then
### Mac 用于 iTerm2 的光标命令；映射 ctrl+arrows 或 alt+arrows 来快速移动
bindkey -e
bindkey '^[[1;9C' forward-word
bindkey '^[[1;9D' backward-word
bindkey '\e\e[D' backward-word
bindkey '\e\e[C' forward-word
fi
```
（LCTT 译注：标题 “We’re all mad here” 是电影《爱丽丝梦游仙境》中，微笑猫对爱丽丝讲的一句话：“我们这儿全都是疯的”。）
### 在家不工作
虽然我开始喜欢我的 Shell 点文件了，但我并不总是想要家用计算机上的东西与工作的计算机上的东西一样。解决此问题的一种方法是让补充的点文件在家中使用，而不是在工作中使用。以下是我的实现方式：
```
if [[ `egrep 'dnssuffix1|dnssuffix2' /etc/resolv.conf` ]]; then
if [ -e $HOME/.work ]
source $HOME/.work
else
echo "This looks like a work machine, but I can't find the ~/.work file"
fi
fi
```
在这种情况下，我根据我的工作 dns 后缀（或多个后缀，具体取决于你的情况）来提供（`source`）一个可以使我的工作环境更好的单独文件。
（LCTT 译注：标题 “What about Bob?” 是 1991 年的美国电影《天才也疯狂》。）
### 你该这么做
现在可能是放弃使用波浪号（`~`）表示编写脚本时的主目录的好时机。你会发现在某些上下文中无法识别它。养成使用环境变量 `$HOME` 的习惯，这将为你节省大量的故障排除时间和以后的工作。
如果你愿意，合乎逻辑的扩展是应该包括特定于操作系统的点文件。
（LCTT 译注：标题 “That thing you do” 是 1996 年由汤姆·汉克斯执导的喜剧片《挡不住的奇迹》。）
### 别指望记忆
我写了那么多 shell 脚本，我真的再也不想写脚本了。并不是说 shell 脚本不能满足我大部分时间的需求，而是我发现写 shell 脚本，可能只是拼凑了一个胶带式解决方案，而不是永久地解决问题。
同样，我讨厌记住事情，在我的整个职业生涯中，我经常不得不在一天之中就彻彻底底地改换环境。实际的结果是这些年来，我不得不一再重新学习很多东西。（“等等……这种语言使用哪种 for 循环结构？”）
因此，每隔一段时间我就会觉得自己厌倦了再次寻找做某事的方法。我改善生活的一种方法是添加别名。
对于任何一个使用操作系统的人来说，一个常见的情况是找出占用了所有磁盘的内容。不幸的是，我从来没有记住过这个咒语，所以我做了一个 shell 别名，创造性地叫做 `bigdirs`：
```
alias bigdirs='du --max-depth=1 2> /dev/null | sort -n -r | head -n20'
```
虽然我可能不那么懒惰，并实际记住了它，但是，那不太 Unix ……
（LCTT 译注：标题 “Memory, all alone in the moonlight” 是一手英文老歌。）
### 输错的人们
使用 shell 别名改善我的生活的另一种方法是使我免于输入错误。我不知道为什么，但是我已经养成了这种讨厌的习惯，在序列 `ea` 之后输入 `w`，所以如果我想清除终端，我经常会输入 `cleawr`。不幸的是，这对我的 shell 没有任何意义。直到我添加了这个小东西：
```
alias cleawr='clear'
```
在 Windows 中有一个等效但更好的命令 `cls`，但我发现自己会在 Shell 也输入它。看到你的 shell 表示抗议真令人沮丧，因此我添加：
```
alias cls='clear'
```
是的，我知道 `ctrl + l`，但是我从不使用它。
（LCTT 译注：标题 “Typos, and the people who love them” 可能来自某部电影。）
### 要自娱自乐
工作压力很大。有时你需要找点乐子。如果你的 shell 不知道它显然应该执行的命令，则可能你想直接让它耸耸肩！你可以使用以下功能执行此操作：
```
shrug() { echo "¯\_(ツ)_/¯"; }
```
如果还不行，也许你需要掀桌不干了：
```
fliptable() { echo "（╯°□°）╯ ┻━┻"; } # 掀桌，用法示例: fsck -y /dev/sdb1 || fliptable
```
想想看，当我想掀桌子时而我不记得我给它起了个什么名字，我会有多沮丧和失望，所以我添加了更多的 shell 别名：
```
alias flipdesk='fliptable'
alias deskflip='fliptable'
alias tableflip='fliptable'
```
而有时你需要庆祝一下：
```
disco() {
echo "(•_•)"
echo "<) )╯"
echo " / \ "
echo ""
echo "\(•_•)"
echo " ( (>"
echo " / \ "
echo ""
echo " (•_•)"
echo "<) )>"
echo " / \ "
}
```
通常，我会将这些命令的输出通过管道传递到 `pbcopy`，并将其粘贴到我正在使用的相关聊天工具中。
我从一个我关注的一个叫 “Command Line Magic” [@ climagic](https://twitter.com/climagic) 的 Twitter 帐户得到了下面这个有趣的函数。自从我现在住在佛罗里达州以来，我很高兴看到我这一生中唯一的一次下雪：
```
snow() {
clear;while :;do echo $LINES $COLUMNS $(($RANDOM%$COLUMNS));sleep 0.1;done|gawk '{a[$3]=0;for(x in a) {o=a[x];a[x]=a[x]+1;printf "\033[%s;%sH ",o,x;printf "\033[%s;%sH*\033[0;0H",a[x],x;}}'
}
```
（LCTT 译注：标题 “Amuse yourself” 是 1936 年的美国电影《自娱自乐》）
### 函数的乐趣
我们已经看到了一些我使用的函数示例。由于这些示例中几乎不需要参数，因此可以将它们作为别名来完成。 当比一个短句更长时，我出于个人喜好使用函数。
在我职业生涯的很多时期我都运行过 [Graphite](https://github.com/graphite-project/)，这是一个开源、可扩展的时间序列指标解决方案。 在很多的情况下，我需要将度量路径（用句点表示）转换到文件系统路径（用斜杠表示），反之亦然，拥有专用于这些任务的函数就变得很有用：
```
# 在 Graphite 指标和文件路径之间转换很有用
function dottoslash() {
echo $1 | sed 's/\./\//g'
}
function slashtodot() {
echo $1 | sed 's/\//\./g'
}
```
在我的另外一段职业生涯里，我运行了很多 Kubernetes。如果你对运行 Kubernetes 不熟悉，你需要编写很多 YAML。不幸的是，一不小心就会编写了无效的 YAML。更糟糕的是，Kubernetes 不会在尝试应用 YAML 之前对其进行验证，因此，除非你应用它，否则你不会发现它是无效的。除非你先进行验证：
```
function yamllint() {
for i in $(find . -name '*.yml' -o -name '*.yaml'); do echo $i; ruby -e "require 'yaml';YAML.load_file(\"$i\")"; done
}
```
因为我厌倦了偶尔破坏客户的设置而让自己感到尴尬，所以我写了这个小片段并将其作为提交前挂钩添加到我所有相关的存储库中。在持续集成过程中，类似的内容将非常有帮助，尤其是在你作为团队成员的情况下。
（LCTT 译注：哦抱歉，我不知道这个标题的出处。）
### 手指不听话
我曾经是一位出色的盲打打字员。但那些日子已经一去不回。我的打字错误超出了我的想象。
在各种时期，我多次用过 Chef 或 Kubernetes。对我来说幸运的是，我从未同时使用过这两者。
Chef 生态系统的一部分是 Test Kitchen，它是加快测试的一组工具，可通过命令 `kitchen test` 来调用。Kubernetes 使用 CLI 工具 `kubectl` 进行管理。这两个命令都需要几个子命令，并且这两者都不会特别顺畅地移动手指。
我没有创建一堆“输错别名”，而是将这两个命令别名为 `k`：
```
alias k='kitchen test $@'
```
或
```
alias k='kubectl $@'
```
（LCTT 译注：标题 “Oh, fingers, where art thou?” 演绎自《O Brother, Where Art Thou?》，这是 2000 年美国的一部电影《逃狱三王》。）
### 分裂与合并
我职业生涯的后半截涉及与其他人一起编写更多代码。我曾在许多环境中工作过，在这些环境中，我们在帐户中复刻了存储库副本，并将拉取请求用作审核过程的一部分。当我想确保给定存储库的复刻与父版本保持最新时，我使用 `fetchupstream`：
```
alias fetchupstream='git fetch upstream && git checkout master && git merge upstream/master && git push'
```
（LCTT 译注：标题 “Timesplitters” 是一款视频游戏《时空分裂者》。）
### 颜色之荣耀
我喜欢颜色。它可以使 `diff` 之类的东西更易于使用。
```
alias diff='colordiff'
```
我觉得彩色的手册页是个巧妙的技巧，因此我合并了以下函数：
```
# 彩色化手册页，来自：
# http://boredzo.org/blog/archives/2016-08-15/colorized-man-pages-understood-and-customized
man() {
env \
LESS_TERMCAP_md=$(printf "\e[1;36m") \
LESS_TERMCAP_me=$(printf "\e[0m") \
LESS_TERMCAP_se=$(printf "\e[0m") \
LESS_TERMCAP_so=$(printf "\e[1;44;33m") \
LESS_TERMCAP_ue=$(printf "\e[0m") \
LESS_TERMCAP_us=$(printf "\e[1;32m") \
man "$@"
}
```
我喜欢命令 `which`，但它只是告诉你正在运行的命令在文件系统中的位置，除非它是 Shell 函数才能告诉你更多。在多个级联的点文件之后，有时会不清楚函数的定义位置或作用。事实证明，`whence` 和 `type` 命令可以帮助解决这一问题。
```
# 函数定义在哪里？
whichfunc() {
whence -v $1
type -a $1
}
```
（LCTT 译注：标题“Mine eyes have seen the glory of the coming of color” 演绎自歌曲 《Mine Eyes Have Seen The Glory Of The Coming Of The Lord》）
### 总结
希望本文对你有所帮助，并能激发你找到改善日常使用 Shell 的方法。这些方法不必庞大、新颖或复杂。它们可能会解决一些微小但频繁的摩擦、创建捷径，甚至提供减少常见输入错误的解决方案。
欢迎你浏览我的 [dotfiles 存储库](https://github.com/gwaldo/dotfiles)，但我要警示你，这样做可能会花费很多时间。请随意使用你认为有帮助的任何东西，并互相取长补短。
---
via: <https://opensource.com/article/18/9/shell-dotfile>
作者：[H.Waldo Grunenwald](https://opensource.com/users/gwaldo) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
把“点文件”放到版本控制中 | Matthew Broberg | https://opensource.com/article/19/3/move-your-dotfiles-version-control | 通过在 GitLab 或 GitHub 上分享你的点文件，可以在整个系统上备份或同步你的自定义配置。 | /data/attachment/album/201910/03/205222yzo1rbck6accccvo.jpg.thumb.jpg | /data/attachment/album/201910/03/205222yzo1rbck6accccvo.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"点文件"
] | 技术 | {
"viewnum": 5605,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11417,
"displayorder": 0
}
] | 通过在 GitLab 或 GitHub 上分享你的点文件，可以在整个系统上备份或同步你的自定义配置。 | 2019-10-03T20:52:42 | 2019-10-03T20:52:42 | 11,419 | /article-11419-1.html |
>
> 通过在 GitLab 或 GitHub 上分享你的点文件，可以在整个系统上备份或同步你的自定义配置。
>
>
>
通过隐藏文件集（称为<ruby> 点文件 <rt> dotfile </rt></ruby>）来定制操作系统是个非常棒的想法。在这篇 [Shell 点文件可以为你做点什么](/article-11417-1.html)中，H. Waldo Grunenwald 详细介绍了为什么以及如何设置点文件的细节。现在让我们深入探讨分享它们的原因和方式。
### 什么是点文件？
“<ruby> 点文件 <rt> dotfile </rt></ruby>”是指我们计算机中四处漂泊的配置文件。这些文件通常在文件名的开头以 `.` 开头，例如 `.gitconfig`，并且操作系统通常在默认情况下将其隐藏。例如，当我在 MacOS 上使用 `ls -a` 时，它才会显示所有可爱的点文件，否则就不会显示这些点文件。
```
dotfiles on master
➜ ls
README.md Rakefile bin misc profiles zsh-custom
dotfiles on master
➜ ls -a
. .gitignore .oh-my-zsh README.md zsh-custom
.. .gitmodules .tmux Rakefile
.gemrc .global_ignore .vimrc bin
.git .gvimrc .zlogin misc
.gitconfig .maid .zshrc profiles
```
如果看一下用于 Git 配置的 `.gitconfig`，我能看到大量的自定义配置。我设置了帐户信息、终端颜色首选项和大量别名，这些别名可以使我的命令行界面看起来就像我的一样。这是 `[alias]` 块的摘录：
```
87 # Show the diff between the latest commit and the current state
88 d = !"git diff-index --quiet HEAD -- || clear; git --no-pager diff --patch-with-stat"
89
90 # `git di $number` shows the diff between the state `$number` revisions ago and the current state
91 di = !"d() { git diff --patch-with-stat HEAD~$1; }; git diff-index --quiet HEAD -- || clear; d"
92
93 # Pull in remote changes for the current repository and all its submodules
94 p = !"git pull; git submodule foreach git pull origin master"
95
96 # Checkout a pull request from origin (of a github repository)
97 pr = !"pr() { git fetch origin pull/$1/head:pr-$1; git checkout pr-$1; }; pr"
```
由于我的 `.gitconfig` 有 200 多行的自定义设置，我无意于在我使用的每一台新计算机或系统上重写它，其他人肯定也不想这样。这是分享点文件变得越来越流行的原因之一，尤其是随着社交编码网站 GitHub 的兴起。正式提倡分享点文件的文章是 Zach Holman 在 2008 年发表的《[点文件意味着被复刻](https://zachholman.com/2010/08/dotfiles-are-meant-to-be-forked/)》。其前提到今天依然如此：我想与我自己、与点文件新手，以及那些分享了他们的自定义配置从而教会了我很多知识的人分享它们。
### 分享点文件
我们中的许多人拥有多个系统，或者知道硬盘变化无常，因此我们希望备份我们精心策划的自定义设置。那么我们如何在环境之间同步这些精彩的文件？
我最喜欢的答案是分布式版本控制，最好是可以为我处理繁重任务的服务。我经常使用 GitHub，随着我对 GitLab 的使用经验越来越丰富，我肯定会一如既往地继续喜欢它。任何一个这样的服务都是共享你的信息的理想场所。要自己设置的话可以这样做：
1. 登录到你首选的基于 Git 的服务。
2. 创建一个名为 `dotfiles` 的存储库。（将其设置为公开！分享即关爱。）
3. 将其克隆到你的本地环境。（你可能需要设置 Git 配置命令来克隆存储库。GitHub 和 GitLab 都会提示你需要运行的命令。）
4. 将你的点文件复制到该文件夹中。
5. 将它们符号链接回到其目标文件夹（最常见的是 `$HOME`）。
6. 将它们推送到远程存储库。
上面的步骤 4 是这项工作的关键，可能有些棘手。无论是使用脚本还是手动执行，工作流程都是从 `dotfiles` 文件夹符号链接到点文件的目标位置，以便对点文件的任何更新都可以轻松地推送到远程存储库。要对我的 `.gitconfig` 文件执行此操作，我要输入：
```
$ cd dotfiles/
$ ln -nfs .gitconfig $HOME/.gitconfig
```
添加到符号链接命令的标志还具有其他一些用处：
* `-s` 创建符号链接而不是硬链接。
* `-f` 在发生错误时继续做其他符号链接（此处不需要，但在循环中很有用）
* `-n` 避免符号链接到一个符号链接文件（等同于其他版本的 `ln` 的 `-h` 标志）
如果要更深入地研究可用参数，可以查看 IEEE 和开放小组的 [ln 规范](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/ln.html)以及 [MacOS 10.14.3](https://www.unix.com/man-page/FreeBSD/1/ln/) 上的版本。自从其他人的点文件中拉取出这些标志以来，我才发现了这些标志。
你还可以使用一些其他代码来简化更新，例如我从 [Brad Parbs](https://github.com/bradp/dotfiles) 复刻的 [Rakefile](https://github.com/mbbroberg/dotfiles/blob/master/Rakefile)。另外，你也可以像 Jeff Geerling [在其点文件中](https://github.com/geerlingguy/dotfiles)那样，使它保持极其简单的状态。他使用[此 Ansible 剧本](https://github.com/geerlingguy/mac-dev-playbook)对文件进行符号链接。这样使所有内容保持同步很容易：你可以从点文件的文件夹中进行 cron 作业或偶尔进行 `git push`。
### 简单旁注：什么不能分享
在继续之前，值得注意的是你不应该添加到共享的点文件存储库中的内容 —— 即使它以点开头。任何有安全风险的东西，例如 `.ssh/` 文件夹中的文件，都不是使用此方法分享的好选择。确保在在线发布配置文件之前仔细检查配置文件，并再三检查文件中没有 API 令牌。
### 我应该从哪里开始？
如果你不熟悉 Git，那么我[有关 Git 术语的文章](https://opensource.com/article/19/2/git-terminology)和常用命令[备忘清单](https://opensource.com/downloads/cheat-sheet-git)将会帮助你继续前进。
还有其他超棒的资源可帮助你开始使用点文件。多年前，我就发现了 [dotfiles.github.io](http://dotfiles.github.io/)，并继续使用它来更广泛地了解人们在做什么。在其他人的点文件中隐藏了许多秘传知识。花时间浏览一些，大胆地将它们添加到自己的内容中。
我希望这是让你在计算机上拥有一致的点文件的快乐开端。
你最喜欢的点文件技巧是什么？添加评论或在 Twitter 上找我 [@mbbroberg](https://twitter.com/mbbroberg?lang=en)。
---
via: <https://opensource.com/article/19/3/move-your-dotfiles-version-control>
作者：[Matthew Broberg](https://opensource.com/users/mbbroberg) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
主流发行版之前的那些最早的 Linux 发行版 | Avimanyu Bandyopadhyay | https://itsfoss.com/earliest-linux-distros/ | 在这篇回溯历史的文章中，我们尝试回顾一些最早的 Linux 发行版是如何演变的，并形成我们今天所知道的发行版的。 | /data/attachment/album/201910/04/100019oc79ftxhuw91x7rc.png.thumb.jpg | /data/attachment/album/201910/04/100019oc79ftxhuw91x7rc.png | true | false | true | lujun9972 | wxy | wxy | false | [
"发行版"
] | 观点 | {
"viewnum": 6194,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 在这篇回溯历史的文章中，我们尝试回顾一些最早的 Linux 发行版是如何演变的，并形成我们今天所知道的发行版的。 | 2019-10-04T10:00:00 | 2019-10-04T10:00:00 | 11,420 | /article-11420-1.html |
>
> 在这篇回溯历史的文章中，我们尝试回顾一些最早的 Linux 发行版是如何演变的，并形成我们今天所知道的发行版的。
>
>
>
在这里，我们尝试探讨了第一个 Linux 内核问世后，诸如 Red Hat、Debian、Slackware、SUSE、Ubuntu 等诸多流行的发行版的想法是如何产生的。
随着 1991 年 Linux 最初以内核的形式发布，今天我们所知道的发行版在世界各地众多合作者的帮助下得以创建 shell、库、编译器和相关软件包，从而使其成为一个完整的操作系统。
### 1、第一个已知的“发行版”是由 HJ Lu 创建的
Linux 发行版这种方式可以追溯到 1992 年，当时可以用来访问 Linux 的第一个已知的类似发行版的工具是由 HJ Lu 发布的。它由两个 5.25 英寸软盘组成：
* LINUX 0.12 BOOT DISK：“启动”磁盘用来先启动系统。
* LINUX 0.12 ROOT DISK：第二个“根”磁盘，用于在启动后获取命令提示符以访问 Linux 文件系统。
要在硬盘上安装 LINUX 0.12，必须使用十六进制编辑器来编辑其主启动记录（MBR），这是一个非常复杂的过程，尤其是在那个时代。
>
> 感觉太怀旧了？
>
>
> 你可以[安装 cool-retro-term 应用程序](https://itsfoss.com/cool-retro-term/)，它可以为你提供 90 年代计算机的复古外观的 Linux 终端。
>
>
>
### 2、MCC Interim Linux
MCC Interim Linux 最初由英格兰曼彻斯特计算中心的 Owen Le Blanc 与 “LINUX 0.12” 同年发布，它是针对普通用户的第一个 Linux 发行版，它具有菜单驱动的安装程序和最终用户/编程工具。它也是以软盘集的形式，可以将其安装在系统上以提供基于文本的基本环境。
MCC Interim Linux 比 0.12 更加易于使用，并且在硬盘驱动器上的安装过程更加轻松和类似于现代方式。它不需要使用十六进制编辑器来编辑 MBR。
尽管它于 1992 年 2 月首次发布，但自当年 11 月以来也可以通过 FTP 下载。
### 3、TAMU Linux
TAMU Linux 由 Texas A＆M 的 Aggies 与 Texas A＆M Unix ＆ Linux 用户组于 1992 年 5 月开发，被称为 TAMU 1.0A。它是第一个提供 X Window System 的 Linux 发行版，而不仅仅是基于文本的操作系统。
### 4、Softlanding Linux System (SLS)
他们的口号是“DOS 伞降的温柔救援”！SLS 由 Peter McDonald 于 1992 年 5 月发布。SLS 在其时代得到了广泛的使用和流行，并极大地推广了 Linux 的思想。但是由于开发人员决定更改发行版中的可执行格式，因此用户停止使用它。
当今社区最熟悉的许多流行发行版是通过 SLS 演变而成的。其中两个是：
* Slackware：它是最早的 Linux 发行版之一，由 Patrick Volkerding 于 1993 年创建。Slackware 基于 SLS，是最早的 Linux 发行版之一。
* Debian：由 Ian Murdock 发起，Debian 在从 SLS 模型继续发展之后于 1993 年发布。我们今天知道的非常流行的 Ubuntu 发行版基于 Debian。
### 5、Yggdrasil
Yggdrasil 于 1992 年 12 月发行，是第一个产生 Live Linux CD 想法的发行版。它是由 Yggdrasil 计算公司开发的，该公司由位于加利福尼亚州伯克利的 Adam J. Richter 创立。它可以在系统硬件上自动配置自身，即“即插即用”功能，这是当今非常普遍且众所周知的功能。Yggdrasil 后来的版本包括一个用于在 Linux 中运行任何专有 MS-DOS CD-ROM 驱动程序的黑科技。
他们的座右铭是“<ruby> 我们其余人的自由软件 <rp> （ </rp> <rt> Free Software For The Rest of Us </rt> <rp> ） </rp></ruby>”。
### 6、Mandriva
在 90 年代后期，有一个非常受欢迎的发行版 [Mandriva](https://en.wikipedia.org/wiki/Mandriva_Linux)，该发行版于 1998 年首次发行，是通过将法国的 Mandrake Linux 发行版与巴西的 Conectiva Linux 发行版统一起来形成的。它的发布寿命为 18 个月，会对 Linux 和系统软件进行更新，并且每年都会发布基于桌面的更新。它还有带有 5 年支持的服务器版本。现在是 [Open Mandriva](https://www.openmandriva.org/)。
如果你在 Linux 发行之初就用过更多的怀旧发行版，请在下面的评论中与我们分享。
---
via: <https://itsfoss.com/earliest-linux-distros/>
作者：[Avimanyu Bandyopadhyay](https://itsfoss.com/author/avimanyu/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
用 Linux 命令显示硬件信息 | Howard Fosdick | https://opensource.com/article/19/9/linux-commands-hardware-information | 通过命令行获取计算机硬件详细信息。 | /data/attachment/album/201910/04/120618q2k1fflrsy1bgbwp.jpg.thumb.jpg | /data/attachment/album/201910/04/120618q2k1fflrsy1bgbwp.jpg | true | false | true | lujun9972 | way-ww | wxy | false | [
"硬件"
] | 技术 | {
"viewnum": 11915,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [] | [] | 通过命令行获取计算机硬件详细信息。 | 2019-10-04T12:06:00 | 2019-10-04T12:06:00 | 11,422 | /article-11422-1.html |
>
> 通过命令行获取计算机硬件详细信息。
>
>
>
你可能会有很多的原因需要查清计算机硬件的详细信息。例如，你需要修复某些问题并在论坛上发出请求，人们可能会立即询问你的计算机具体的信息。或者当你想要升级计算机配置时，你需要知道现有的硬件型号和能够升级的型号。这些都需要查询你的计算机具体规格信息。
最简单的方法是使用标准的 Linux GUI 程序之一:
* [i-nex](http://sourceforge.net/projects/i-nex/) 收集硬件信息，并且类似于 Windows 下流行的 [CPU-Z](https://www.cpuid.com/softwares/cpu-z.html) 的显示。
* [HardInfo](http://sourceforge.net/projects/hardinfo.berlios/) 显示硬件具体信息，甚至包括一组八个的流行的性能基准程序，你可以用它们评估你的系统性能。
* [KInfoCenter](https://userbase.kde.org/KInfoCenter) 和 [Lshw](http://www.binarytides.com/linux-lshw-command/) 也能够显示硬件的详细信息，并且可以从许多软件仓库中获取。
或者，你也可以拆开计算机机箱去查看硬盘、内存和其他设备上的标签信息。或者你可以在系统启动时，按下[相应的按键](http://www.disk-image.com/faq-bootmenu.htm)进入 UEFI 和 BIOS 界面获得信息。这两种方式都会向你显示硬件信息但省略软件信息。
你也可以使用命令行获取硬件信息。等一下… 这听起来有些困难。为什么你会要这样做？
有时候通过使用一条针对性强的命令可以很轻松的找到特定信息。也可能你没有可用的 GUI 程序或者只是不想安装这样的程序。
使用命令行的主要原因可能是编写脚本。无论你是使用 Linux shell 还是其他编程语言来编写脚本通常都需要使用命令行。
很多检测硬件信息的命令行都需要使用 root 权限。所以要么切换到 root 用户，要么使用 `sudo` 在普通用户状态下发出命令：
```
sudo <the_line_command>
```
并按提示输入你的密码。
这篇文章介绍了很多用于发现系统信息的有用命令。文章最后的快速查询表对它们作出了总结。
### 硬件概述
下面几条命令可以全面概述计算机硬件信息。
`inxi` 命令能够列出包括 CPU、图形、音频、网络、驱动、分区、传感器等详细信息。当论坛里的人尝试帮助其他人解决问题的时候，他们常常询问此命令的输出。这是解决问题的标准诊断程序：
```
inxi -Fxz
```
`-F` 参数意味着你将得到完整的输出，`x` 增加细节信息，`z` 参数隐藏像 MAC 和 IP 等私人身份信息。
`hwinfo` 和 `lshw` 命令以不同的格式显示大量相同的信息：
```
hwinfo --short
```
或
```
lshw -short
```
这两条命令的长格式输出非常详细，但也有点难以阅读：
```
hwinfo
```
或
```
lshw
```
### CPU 详细信息
通过命令你可以了解关于你的 CPU 的任何信息。使用 `lscpu` 命令或与它相近的 `lshw` 命令查看 CPU 的详细信息：
```
lscpu
```
或
```
lshw -C cpu
```
在这两个例子中，输出的最后几行都列出了所有 CPU 的功能。你可以查看你的处理器是否支持特定的功能。
使用这些命令的时候，你可以通过使用 `grep` 命令过滤复杂的信息，并缩小所需信息范围。例如，只查看 CPU 品牌和型号:
```
lshw -C cpu | grep -i product
```
仅查看 CPU 的速度（兆赫兹）:
```
lscpu | grep -i mhz
```
或其 [BogoMips](https://en.wikipedia.org/wiki/BogoMips) 额定功率:
```
lscpu | grep -i bogo
```
`grep` 命令的 `-i` 参数代表搜索结果忽略大小写。
### 内存
Linux 命令行使你能够收集关于你的计算机内存的所有可能的详细信息。你甚至可以不拆开计算机机箱就能确定是否可以为计算机添加额外的内存条。
使用 `dmidecode` 命令列出每根内存条和其容量：
```
dmidecode -t memory | grep -i size
```
使用以下命令获取系统内存更多的信息，包括类型、容量、速度和电压：
```
lshw -short -C memory
```
你肯定想知道的一件事是你的计算机可以安装的最大内存：
```
dmidecode -t memory | grep -i max
```
现在检查一下计算机是否有空闲的插槽可以插入额外的内存条。你可以通过使用命令在不打开计算机机箱的情况下就做到：
```
lshw -short -C memory | grep -i empty
```
输出为空则意味着所有的插槽都在使用中。
确定你的计算机拥有多少显卡内存需要下面的命令。首先使用 `lspci` 列出所有设备信息然后过滤出你想要的显卡设备信息:
```
lspci | grep -i vga
```
视频控制器的设备号输出信息通常如下：
```
00:02.0 VGA compatible controller: Intel Corporation 82Q35 Express Integrated Graphics Controller (rev 02)
```
现在再加上视频设备号重新运行 `lspci` 命令：
```
lspci -v -s 00:02.0
```
输出信息中 `prefetchable` 那一行显示了系统中的显卡内存大小:
```
...
Memory at f0100000 (32-bit, non-prefetchable) [size=512K]
I/O ports at 1230 [size=8]
Memory at e0000000 (32-bit, prefetchable) [size=256M]
Memory at f0000000 (32-bit, non-prefetchable) [size=1M]
...
```
最后使用下面的命令展示当前内存使用量（兆字节）：
```
free -m
```
这条命令告诉你多少内存是空闲的，多少命令正在使用中以及交换内存的大小和是否正在使用。例如，输出信息如下：
```
total used free shared buff/cache available
Mem: 11891 1326 8877 212 1687 10077
Swap: 1999 0 1999
```
`top` 命令为你提供内存使用更加详细的信息。它显示了当前全部内存和 CPU 使用情况并按照进程 ID、用户 ID 及正在运行的命令细分。同时这条命令也是全屏输出:
```
top
```
### 磁盘文件系统和设备
你可以轻松确定有关磁盘、分区、文件系统和其他设备信息。
显示每个磁盘设备的描述信息：
```
lshw -short -C disk
```
通过以下命令获取任何指定的 SATA 磁盘详细信息，例如其型号、序列号以及支持的模式和扇区数量等：
```
hdparm -i /dev/sda
```
当然，如果需要的话你应该将 `sda` 替换成 `sdb` 或者其他设备号。
要列出所有磁盘及其分区和大小，请使用以下命令：
```
lsblk
```
使用以下命令获取更多有关扇区数量、大小、文件系统 ID 和 类型以及分区开始和结束扇区：
```
fdisk -l
```
要启动 Linux，你需要确定 [GRUB](https://www.dedoimedo.com/computers/grub.html) 引导程序的可挂载分区。你可以使用 `blkid` 命令找到此信息。它列出了每个分区的唯一标识符（UUID）及其文件系统类型（例如 ext3 或 ext4）：
```
blkid
```
使用以下命令列出已挂载的文件系统和它们的挂载点，以及已用的空间和可用的空间（兆字节为单位）：
```
df -m
```
最后，你可以列出所有的 USB 和 PCI 总线以及其他设备的详细信息：
```
lsusb
```
或
```
lspci
```
### 网络
Linux 提供大量的网络相关命令，下面只是几个例子。
查看你的网卡硬件详细信息:
```
lshw -C network
```
`ifconfig` 是显示网络接口的传统命令：
```
ifconfig -a
```
但是现在很多人们使用：
```
ip link show
```
或
```
netstat -i
```
在阅读输出时，了解常见的网络缩写十分有用：
| 缩写 | 含义 |
| --- | --- |
| `lo` | 回环接口 |
| `eth0` 或 `enp*` | 以太网接口 |
| `wlan0` | 无线网接口 |
| `ppp0` | 点对点协议接口（由拨号调制解调器、PPTP VPN 连接或者 USB 调制解调器使用） |
| `vboxnet0` 或 `vmnet*` | 虚拟机网络接口 |
表中的星号是通配符，代表不同系统的任意字符。
使用以下命令显示默认网关和路由表：
```
ip route | column -t
```
或
```
netstat -r
```
### 软件
让我们以显示最底层软件详细信息的两条命令来结束。例如，如果你想知道是否安装了最新的固件该怎么办？这条命令显示了 UEFI 或 BIOS 的日期和版本:
```
dmidecode -t bios
```
内核版本是多少，以及它是 64 位的吗？网络主机名是什么？使用下面的命令查出结果：
```
uname -a
```
### 快速查询表
| 用途 | 命令 |
| --- | --- |
| 显示所有硬件信息 | `inxi -Fxz` 或 `hwinfo --short` 或 `lshw -short` |
| CPU 信息 | `lscpu` 或 `lshw -C cpu` |
| 显示 CPU 功能（例如 PAE、SSE2） | `lshw -C cpu | grep -i capabilities` |
| 报告 CPU 位数 | `lshw -C cpu | grep -i width` |
| 显示当前内存大小和配置 | `dmidecode -t memory | grep -i size` 或 `lshw -short -C memory` |
| 显示硬件支持的最大内存 | `dmidecode -t memory | grep -i max` |
| 确定是否有空闲内存插槽 | `lshw -short -C memory | grep -i empty`（输出为空表示没有可用插槽） |
| 确定显卡内存数量 | `lspci | grep -i vga` 然后指定设备号再次使用；例如：`lspci -v -s 00:02.0` 显卡内存数量就是 `prefetchable` 的值 |
| 显示当前内存使用情况 | `free -m` 或 `top` |
| 列出磁盘驱动器 | `lshw -short -C disk` |
| 显示指定磁盘驱动器的详细信息 | `hdparm -i /dev/sda`（需要的话替换掉 `sda`） |
| 列出磁盘和分区信息 | `lsblk`（简单） 或 `fdisk -l`（详细） |
| 列出分区 ID（UUID） | `blkid` |
| 列出已挂载文件系统挂载点以及已用和可用空间 | `df -m` |
| 列出 USB 设备 | `lsusb` |
| 列出 PCI 设备 | `lspci` |
| 显示网卡详细信息 | `lshw -C network` |
| 显示网络接口 | `ifconfig -a` 或 `ip link show` 或 `netstat -i` |
| 显示路由表 | `ip route | column -t` 或 `netstat -r` |
| 显示 UEFI/BIOS 信息 | `dmidecode -t bios` |
| 显示内核版本网络主机名等 | `uname -a` |
你有喜欢的命令被我忽略掉的吗？请添加评论分享给大家。
---
via: <https://opensource.com/article/19/9/linux-commands-hardware-information>
作者：[Howard Fosdick](https://opensource.com/users/howtechhttps://opensource.com/users/sethhttps://opensource.com/users/sethhttps://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[way-ww](https://github.com/way-ww) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
数码文件与文件夹收纳术（以照片为例） | Karl Voit | http://karl-voit.at/managing-digital-photographs/ | 这篇文章中我会介绍我是如何避免供应商锁定造成受限于那些临时性的解决方案及数据丢失。相反，我更倾向于使用那些可以让我投入时间和精力打理，并能长久使用的解决方案。 | /data/attachment/album/201910/05/000950xsxopomsrs55rrb5.jpg.thumb.jpg | /data/attachment/album/201910/05/000950xsxopomsrs55rrb5.jpg | true | false | true | qfzy1233 | wxy | false | [
"照片",
"相片"
] | 技术 | {
"viewnum": 4808,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 这篇文章中我会介绍我是如何避免供应商锁定造成受限于那些临时性的解决方案及数据丢失。相反，我更倾向于使用那些可以让我投入时间和精力打理，并能长久使用的解决方案。 | 2019-10-05T00:10:00 | 2019-10-05T00:10:00 | 11,423 | /article-11423-1.html | 
* 更新 2014-05-14：增加了一些具体实例
* 更新 2015-03-16：根据照片的 GPS 坐标过滤图片
* 更新 2016-08-29：以新的 `filetags --filter` 替换已经过时的 `show-sel.sh` 脚本
* 更新 2017-08-28: geeqier 视频缩略图的邮件评论
* 更新 2018-03-06：增加了 Julian Kahnert 的链接
* 更新 2018-05-06：增加了作者在 2018 Linuxtage Graz 大会上 45 分钟演讲的视频
* 更新 2018-06-05：关于 metadata 的邮件回复
* 更新 2018-07-22：移动文件夹结构的解释到一篇它自己的文章中
* 更新 2019-07-09：关于在文件名中避免使用系谱和字符的邮件回复
每当度假或去哪游玩时我就会化身为一个富有激情的摄影师。所以，过去的几年中我积累了许多的 [JPEG](https://en.wikipedia.org/wiki/Jpeg) 文件。这篇文章中我会介绍我是如何避免 [供应商锁定](http://en.wikipedia.org/wiki/Vendor_lock-in)（LCTT 译注：<ruby> 供应商锁定 <rt> vendor lock-in </rt></ruby>，原为经济学术语，这里引申为避免过于依赖某一服务平台）造成受限于那些临时性的解决方案及数据丢失。相反，我更倾向于使用那些可以让我**投入时间和精力打理，并能长久使用**的解决方案。
这一（相当长的）攻略 **并不仅仅适用于图像文件**：我将进一步阐述像是文件夹结构、文件的命名规则等等许多领域的事情。因此，这些规范适用于我所能接触到的所有类型的文件。
在我开始传授我的方法之前，我们应该先就我将要介绍方法的达成一个共识，那就是我们是否有相同的需求。如果你对 [raw 图像格式](https://en.wikipedia.org/wiki/Raw_image_format)十分推崇，将照片存储在云端或其他你信赖的地方（对我而言可能不会），那么你可能不会认同这篇文章将要描述的方式了。请根据你的情况来灵活做出选择。
### 我的需求
对于 **将照片（或视频）从我的数码相机中导出到电脑里**，我只需要将 SD 卡插到我的电脑里并调用 `fetch-workflow` 软件。这一步也完成了**图像软件的预处理**以适用于我的文件命名规范（下文会具体论述），同时也可以将图片旋转至正常的方向（而不是横着）。
这些文件将会被存入到我的摄影收藏文件夹 `$HOME/tmp/digicam/`。在这一文件夹中我希望能**遍历我的图像和视频文件**，以便于**整理/删除、重命名、添加/移除标签，以及将一系列相关的文件移动到相应的文件夹中**。
在完成这些以后，我将会**浏览包含图像/电影文件集的文件夹**。在极少数情况下，我希望**在独立的图像处理工具**（比如 [GIMP](http://www.gimp.org/)）中打开一个图像文件。如果仅是为了**旋转 JPEG 文件**，我想找到一个快速的方法，不需要图像处理工具，并且是[以无损的方式](http://petapixel.com/2012/08/14/why-you-should-always-rotate-original-jpeg-photos-losslessly/)旋转 JPEG 图像。
我的数码相机支持用 [GPS](https://en.wikipedia.org/wiki/Gps) 坐标标记图像。因此，我需要一个方法来**对单个文件或一组文件可视化 GPS 坐标**来显示我走过的路径。
我想拥有的另一个好功能是：假设你在威尼斯度假时拍了几百张照片。每一个都很漂亮，所以你每张都舍不得删除。另一方面，你可能想把一组更少的照片送给家里的朋友。而且，在他们嫉妒的爆炸之前，他们可能只希望看到 20 多张照片。因此，我希望能够**定义并显示一组特定的照片子集**。
就独立性和**避免锁定效应**而言，我不想使用那种一旦公司停止产品或服务就无法使用的工具。出于同样的原因，由于我是一个注重隐私的人，**我不想使用任何基于云的服务**。为了让自己对新的可能性保持开放的心态，我不希望只在一个特定的操作系统平台才可行的方案上倾注全部的精力。**基本的东西必须在任何平台上可用**（查看、导航、……），而**全套需求必须可以在 GNU/Linux 上运行**，对我而言，我选择 Debian GNU/Linux。
在我传授当前针对上述大量需求的解决方案之前，我必须解释一下我的一般文件夹结构和文件命名约定，我也使用它来命名数码照片。但首先，你必须认清一个重要的事实：
#### iPhoto、Picasa，诸如此类应被认为是有害的
管理照片集的软件工具确实提供了相当酷的功能。它们提供了一个良好的用户界面，并试图为你提供满足各种需求的舒适的工作流程。
对它们我确实遇到了很多大问题。它们几乎对所有东西都使用专有的存储格式：图像文件、元数据等等。当你打算在几年内换一个不同的软件，这是一个大问题。相信我：总有一天你会因为多种原因而**更换软件**。
如果你现在正打算更换相应的工具，你会意识到 iPhoto 或 Picasa 是分别存储原始图像文件和你对它们所做的所有操作的（旋转图像、向图像文件添加描述/标签、裁剪等等）。如果你不能导出并重新导入到新工具，那么**所有的东西都将永远丢失**。而无损的进行转换和迁移几乎是不可能的。
我不想在一个会锁住我工作的工具上投入任何精力。**我也拒绝把自己绑定在任何专有工具上**。我是一个过来人，希望你们吸取我的经验。
这就是我在文件名中保留时间戳、图像描述或标记的原因。文件名是永久性的，除非我手动更改它们。当我把照片备份或复制到 U 盘或其他操作系统时，它们不会丢失。每个人都能读懂。任何未来的系统都能够处理它们。
### 我的文件命名规范
这里有一个我在 [2018 Linuxtage Graz 大会](https://glt18.linuxtage.at)上做的[演讲](https://glt18-programm.linuxtage.at/events/321.html),其中详细阐述了我的在本文中提到的想法和工作流程。
* [Grazer Linuxtage 2018 - The Advantages of File Name Conventions and Tagging](https://youtu.be/rckSVmYCH90)
* [备份视频托管在 media.CCC.de](https://media.ccc.de/v/GLT18_-_321_-_en_-_g_ap147_004_-_201804281550_-_the_advantages_of_file_name_conventions_and_tagging_-_karl_voit)
我所有的文件都与一个特定的日期或时间有关，根据所采用的 [ISO 8601](https://en.wikipedia.org/wiki/Iso_date) 规范，我采用的是**日期戳**或**时间戳**
带有日期戳和两个标签的示例文件名：`2014-05-09 Budget export for project 42 -- finance company.csv`。
带有时间戳（甚至包括可选秒）和两个标签的示例文件名：`2014-05-09T22.19.58 Susan presenting her new shoes -- family clothing.jpg`。
由于我使用的 ISO 时间戳冒号不适用于 Windows [NTFS 文件系统](https://en.wikipedia.org/wiki/Ntfs)，因此，我用点代替冒号，以便将小时与分钟（以及可选的秒）区别开来。
如果是**持续的一段日期或时间**，我会将两个日期戳或时间戳用两个减号分开：`2014-05-09--2014-05-13 Jazz festival Graz -- folder tourism music.pdf`。
文件名中的时间/日期戳的优点是，除非我手动更改它们，否则它们保持不变。当通过某些不处理这些元数据的软件进行处理时，包含在文件内容本身中的元数据（如 [Exif](https://en.wikipedia.org/wiki/Exif)）往往会丢失。此外，使用这样的日期/时间戳开始的文件名可以确保文件按时间顺序显示，而不是按字母顺序显示。字母表是一种[完全人工的排序顺序](http://www.isisinform.com/reinventing-knowledge-the-medieval-controversy-of-alphabetical-order/)，对于用户定位文件通常不太实用。
当我想将**标签**关联到文件名时，我将它们放在原始文件名和[文件名扩展名](https://en.wikipedia.org/wiki/File_name_extension)之间，中间用空格、两个减号和两端额外的空格分隔 `--`。我的标签是小写的英文单词，不包含空格或特殊字符。有时，我可能会使用 `quantifiedself` 或 `usergenerated` 这样的连接词。我[倾向于选择一般类别](http://karl-voit.at/tagstore/en/papers.shtml)，而不是太过具体的描述标签。我在 Twitter [hashtags](https://en.wikipedia.org/wiki/Hashtag)、文件名、文件夹名、书签、诸如此类的博文等诸如此类地地方重用这些标签。
标签作为文件名的一部分有几个优点。通过使用常用的桌面搜索引擎，你可以在标签的帮助下定位文件。文件名称中的标签不会因为复制到不同的存储介质上而丢失。当系统使用与文件名之外的存储位置（如：元数据数据库、[点文件](https://en.wikipedia.org/wiki/Dot-file)、[备用数据流](https://en.wikipedia.org/wiki/NTFS#Alternate_data_streams_.28ADS.29)等）存储元信息通常会发生丢失。
当然，通常在文件和文件夹名称中，**请避免使用特殊字符**、变音符、冒号等。尤其是在不同操作系统平台之间同步文件时。
我的**文件夹名命名约定**与文件的相应规范相同。
注意：由于 [Memacs](https://github.com/novoid/Memacs) 的 [filenametimestamp](https://github.com/novoid/Memacs/blob/master/docs/memacs_filenametimestamps.org) 模块的聪明之处，所有带有日期/时间戳的文件和文件夹都出现在我的 Org 模式的日历（日程）上的同一天/同一时间。这样，我就能很好地了解当天发生了什么，包括我拍的所有照片。
### 我的一般文件夹结构
在本节中，我将描述我的主文件夹中最重要的文件夹。注意：这可能在将来的被移动到一个独立的页面。或许不是。让我们等着瞧 :-) （LCTT 译注：后来这一节已被作者扩展并移动到另外一篇[文章](https://karl-voit.at/folder-hierarchy/)。）
很多东西只有在一定的时间内才会引起人们的兴趣。这些内容包括快速浏览其内容的下载、解压缩文件以检查包含的文件、一些有趣的小内容等等。对于**临时的东西**，我有 `$HOME/tmp/` 子层次结构。新照片放在 `$HOME/tmp/digicam/` 中。我从 CD、DVD 或 USB 记忆棒临时复制的东西放在 `$HOME/tmp/fromcd/` 中。每当软件工具需要用户文件夹层次结构中的临时数据时，我就使用 `$HOME/tmp/Tools/`作为起点。我经常使用的文件夹是 `$HOME/tmp/2del/`：`2del` 的意思是“随时可以删除”。例如，我所有的浏览器都使用这个文件夹作为默认的下载文件夹。如果我需要在机器上腾出空间，我首先查看这个 `2del` 文件夹，用于删除内容。
与上面描述的临时文件相比，我当然也想将文件**保存更长的时间**。这些文件被移动到我的 `$HOME/archive/` 子层次结构中。它有几个子文件夹用于备份、我想保留的 web 下载类、我要存档的二进制文件、可移动媒体（CD、DVD、记忆棒、外部硬盘驱动器）的索引文件，和一个稍后（寻找一个合适的的目标文件夹）存档的文件夹。有时，我太忙或没有耐心的时候将文件妥善整理。是的，那就是我，我甚至有一个名为“现在不要烦我”的文件夹。这对你而言是否很怪？:-)
我的归档中最重要的子层次结构是 `$HOME/archive/events_memories/` 及其子文件夹 `2014/`、`2013/`、`2012/` 等等。正如你可能已经猜到的，每个年份有一个**子文件夹**。其中每个文件中都有单个文件和文件夹。这些文件是根据我在前一节中描述的文件名约定命名的。文件夹名称以 [ISO 8601](https://en.wikipedia.org/wiki/Iso_date) 日期标签 “YYYY-MM-DD” 开头，后面跟着一个具有描述性的名称，如 `$HOME/archive/events_memories/2014/2014-05-08 Business marathon with/`。在这些与日期相关的文件夹中，我保存着各种与特定事件相关的文件：照片、（扫描的）pdf 文件、文本文件等等。
对于**共享数据**，我设置一个 `$HOME/share/` 子层次结构。这是我的 Dropbox 文件夹，我用各种各样的方法（比如 [unison](http://www.cis.upenn.edu/%7Ebcpierce/unison/)）来分享数据。我也在我的设备之间共享数据：家里的 Mac Mini、家里的 GNU/Linux 笔记本、Android 手机，root-server（我的个人云），工作用的 Windows 笔记本。我不想在这里详细说明我的同步设置。如果你想了解相关的设置，可以参考另一篇相关的文章。:-)
在我的 `$HOME/templates_tags/` 子层次结构中，我保存了各种**模板文件**（[LaTeX](https://github.com/novoid/LaTeX-KOMA-template)、脚本、…），插图和**徽标**，等等。
我的 **Org 模式** 文件，主要是保存在 `$HOME/org/`。我练习记忆力，不会解释我有多喜欢 [Emacs/Org 模式](http://orgmode.org/) 以及我从中获益多少。你可能读过或听过我详细描述我用它做的很棒的事情。具体可以在我的博客上查找 [我的 Emacs 标签](http://karl-voit.at/tags/emacs)，在 Twitter 上查找 [hashtag #orgmode](https://twitter.com/search?q%3D%2523orgmode&src%3Dtypd)。
以上就是我最重要的文件夹子层次结构设置方式。
### 我的工作流程
哒哒哒，在你了解了我的文件夹结构和文件名约定之后，下面是我当前的工作流程和工具，我使用它们来满足我前面描述的需求。
请注意，**你必须知道你在做什么**。我这里的示例及文件夹路径和更多**只适用我的机器或我的环境**。**你必须采用相应的**路径、文件名等来满足你的需求!
#### 工作流程：将文件从 SD 卡移动到笔记本电脑、旋转人像图像，并重命名文件
当我想把数据从我的数码相机移到我的 GNU/Linux 笔记本上时，我拿出它的 mini SD 存储卡，把它放在我的笔记本上。然后它会自动挂载在 `/media/digicam` 上。
然后，调用 [getdigicamdata](https://github.com/novoid/getdigicamdata.sh)。它做了如下几件事：它将文件从 SD 卡移动到一个临时文件夹中进行处理。原始文件名会转换为小写字符。所有的人像照片会使用 [jhead](http://www.sentex.net/%3Ccode%3Emwandel/jhead/) 旋转。同样使用 jhead，我从 Exif 头的时间戳中生成文件名称中的时间戳。使用 [date2name](https://github.com/novoid/date2name)，我也将时间戳添加到电影文件中。处理完所有这些文件后，它们将被移动到新的数码相机文件的目标文件夹: `$HOME/tmp/digicam/tmp/`。
#### 工作流程：文件夹索引、查看、重命名、删除图像文件
为了快速浏览我的图像和电影文件，我喜欢使用 GNU/Linux 上的 [geeqie](http://geeqie.sourceforge.net/)。这是一个相当轻量级的图像浏览器，它具有其他文件浏览器所缺少的一大优势：我可以添加通过键盘快捷方式调用的外部脚本/工具。通过这种方式，我可以通过任意外部命令扩展这个图像浏览器的特性。
基本的图像管理功能是内置在 geeqie：浏览我的文件夹层次结构、以窗口模式或全屏查看图像（快捷键 `f`）、重命名文件名、删除文件、显示 Exif 元数据（快捷键 `Ctrl-e`）。
在 OS X 上，我使用 [Xee](http://xee.c3.cx/)。与 geeqie 不同，它不能通过外部命令进行扩展。不过，基本的浏览、查看和重命名功能也是可用的。
#### 工作流程：添加和删除标签
我创建了一个名为 [filetags](https://github.com/novoid/filetag) 的 Python 脚本，用于向单个文件以及一组文件添加和删除标记。
对于数码照片，我使用标签，例如，`specialL` 用于我认为适合桌面背景的风景图片，`specialP` 用于我想展示给其他人的人像照片，`sel` 用于筛选，等等。
##### 使用 geeqie 初始设置 filetags
向 geeqie 添加 `filetags` 是一个手动步骤：“Edit > Preferences > Configure Editors …”，然后创建一个附加条目 `New`。在这里，你可以定义一个新的桌面文件，如下所示:
```
[Desktop Entry]
Name=filetags
GenericName=filetags
Comment=
Exec=/home/vk/src/misc/vk-filetags-interactive-adding-wrapper-with-gnome-terminal.sh %F
Icon=
Terminal=true
Type=Application
Categories=Application;Graphics;
hidden=false
MimeType=image/*;video/*;image/mpo;image/thm
Categories=X-Geeqie;
```
*add-tags.desktop*
封装脚本 `vk-filetags-interactive-adding-wrapper-with-gnome-terminal.sh` 是必须的，因为我想要弹出一个新的终端，以便添加标签到我的文件:
```
#!/bin/sh
/usr/bin/gnome-terminal \
--geometry=85x15+330+5 \
--tab-with-profile=big \
--hide-menubar \
-x /home/vk/src/filetags/filetags.py --interactive "${@}"
#end
```
*vk-filetags-interactive-adding-wrapper-with-gnome-terminal.sh*
在 geeqie 中，你可以在 “Edit > Preferences > Preferences … > Keyboard”。我将 `t` 与 `filetags` 命令相关联。
这个 `filetags` 脚本还能够从单个文件或一组文件中删除标记。它基本上使用与上面相同的方法。唯一的区别是 `filetags` 脚本额外的 `--remove` 参数：
```
[Desktop Entry]
Name=filetags-remove
GenericName=filetags-remove
Comment=
Exec=/home/vk/src/misc/vk-filetags-interactive-removing-wrapper-with-gnome-terminal.sh %F
Icon=
Terminal=true
Type=Application
Categories=Application;Graphics;
hidden=false
MimeType=image/*;video/*;image/mpo;image/thm
Categories=X-Geeqie;
```
*remove-tags.desktop*
```
#!/bin/sh
/usr/bin/gnome-terminal \
--geometry=85x15+330+5 \
--tab-with-profile=big \
--hide-menubar \
-x /home/vk/src/filetags/filetags.py --interactive --remove "${@}"
#end
```
*vk-filetags-interactive-removing-wrapper-with-gnome-terminal.sh*
为了删除标签，我创建了一个键盘快捷方式 `T`。
##### 在 geeqie 中使用 filetags
当我在 geeqie 文件浏览器中浏览图像文件时，我选择要标记的文件（一到多个）并按 `t`。然后，一个小窗口弹出，要求我提供一个或多个标签。用回车确认后，这些标签被添加到文件名中。
删除标签也是一样：选择多个文件，按下 `T`，输入要删除的标签，然后按回车确认。就是这样。几乎没有[给文件添加或删除标签的更简单的方法了](http://karl-voit.at/tagstore/)。
#### 工作流程：改进的使用 appendfilename 重命名文件
##### 不使用 appendfilename
重命名一组大型文件可能是一个冗长乏味的过程。对于 `2014-04-20T17.09.11_p1100386.jpg` 这样的原始文件名，在文件名中添加描述的过程相当烦人。你将按 `Ctrl-r` （重命名）在 geeqie 中打开文件重命名对话框。默认情况下，原始名称（没有文件扩展名的文件名称）被标记。因此，如果不希望删除/覆盖文件名（但要追加），则必须按下光标键 `→`。然后，光标放在基本名称和扩展名之间。输入你的描述（不要忘记以空格字符开始），并用回车进行确认。
##### 在 geeqie 使中用 appendfilename
使用 [appendfilename](https://github.com/novoid/appendfilename)，我的过程得到了简化，可以获得将文本附加到文件名的最佳用户体验：当我在 geeqie 中按下 `a`（附加）时，会弹出一个对话框窗口，询问文本。在回车确认后，输入的文本将放置在时间戳和可选标记之间。
例如，当我在 `2014-04-20T17.09.11_p1100386.jpg` 上按下 `a`，然后键入`Pick-nick in Graz` 时，文件名变为 `2014-04-20T17.09.11_p1100386 Pick-nick in Graz.jpg`。当我再次按下 `a` 并输入 `with Susan` 时，文件名变为 `2014-04-20T17.09.11_p1100386 Pick-nick in Graz with Susan.jpg`。当文件名添加标记时，附加的文本前将附加标记分隔符。
这样，我就不必担心覆盖时间戳或标记。重命名的过程对我来说变得更加有趣!
最好的部分是：当我想要将相同的文本添加到多个选定的文件中时，也可以使用 `appendfilename`。
##### 在 geeqie 中初始设置 appendfilename
添加一个额外的编辑器到 geeqie: “Edit > Preferences > Configure Editors … > New”。然后输入桌面文件定义：
```
[Desktop Entry]
Name=appendfilename
GenericName=appendfilename
Comment=
Exec=/home/vk/src/misc/vk-appendfilename-interactive-wrapper-with-gnome-terminal.sh %F
Icon=
Terminal=true
Type=Application
Categories=Application;Graphics;
hidden=false
MimeType=image/*;video/*;image/mpo;image/thm
Categories=X-Geeqie;
```
*appendfilename.desktop*
同样，我也使用了一个封装脚本，它将为我打开一个新的终端：
```
#!/bin/sh
/usr/bin/gnome-terminal \
--geometry=90x5+330+5 \
--tab-with-profile=big \
--hide-menubar \
-x /home/vk/src/appendfilename/appendfilename.py "${@}"
#end
```
*vk-appendfilename-interactive-wrapper-with-gnome-terminal.sh*
#### 工作流程：播放电影文件
在 GNU/Linux 上，我使用 [mplayer](http://www.mplayerhq.hu) 回放视频文件。由于 geeqie 本身不播放电影文件，所以我必须创建一个设置，以便在 mplayer 中打开电影文件。
##### 在 geeqie 中初始设置 mplayer
我已经使用 [xdg-open](https://wiki.archlinux.org/index.php/xdg-open) 将电影文件扩展名关联到 mplayer。因此，我只需要为 geeqie 创建一个通用的“open”命令，让它使用 `xdg-open` 打开任何文件及其关联的应用程序。
在 geeqie 中，再次访问 “Edit > Preferences > Configure Editors …” 添加“open”的条目：
```
[Desktop Entry]
Name=open
GenericName=open
Comment=
Exec=/usr/bin/xdg-open %F
Icon=
Terminal=true
Type=Application
hidden=false
NOMimeType=*;
MimeType=image/*;video/*
Categories=X-Geeqie;
```
*open.desktop*
当你也将快捷方式 `o` （见上文）与 geeqie 关联时，你就能够打开与其关联的应用程序的视频文件（和其他文件）。
##### 使用 xdg-open 打开电影文件（和其他文件）
在上面的设置过程之后，当你的 geeqie 光标位于文件上方时，你只需按下 `o` 即可。就是如此简洁。
#### 工作流程：在外部图像编辑器中打开
我不太希望能够在 GIMP 中快速编辑图像文件。因此，我添加了一个快捷方式 `g`，并将其与外部编辑器 “GNU Image Manipulation Program (GIMP)” 关联起来，geeqie 已经默认创建了该外部编辑器。
这样，只需按下 `g` 就可以在 GIMP 中打开当前图像。
#### 工作流程：移动到存档文件夹
现在我已经在我的文件名中添加了注释，我想将单个文件移动到 `$HOME/archive/events_memories/2014/`，或者将一组文件移动到这个文件夹中的新文件夹中，如 `$HOME/archive/events_memories/2014/2014-05-08 business marathon after show - party`。
通常的方法是选择一个或多个文件，并用快捷方式 `Ctrl-m` 将它们移动到文件夹中。
何等繁复无趣之至！
因此，我（再次）编写了一个 Python 脚本，它为我完成了这项工作：[move2archive](https://github.com/novoid/move2archive)（简写为：`m2a`），需要一个或多个文件作为命令行参数。然后，出现一个对话框，我可以在其中输入一个可选文件夹名。当我不输入任何东西而是按回车，文件被移动到相应年份的文件夹。当我输入一个类似 `Business-Marathon After-Show-Party` 的文件夹名称时，第一个图像文件的日期戳被附加到该文件夹（`$HOME/archive/events_memories/2014/2014-05-08 Business-Marathon After-Show-Party`），然后创建该文件夹，并移动文件。
再一次，我在 geeqie 中选择一个或多个文件，按 `m`（移动），或者只按回车（没有特殊的子文件夹），或者输入一个描述性文本，这是要创建的子文件夹的名称（可选不带日期戳）。
**没有一个图像管理工具像我的带有 appendfilename 和 move2archive 的 geeqie 一样可以通过快捷键快速且有趣的完成工作。**
##### 在 geeqie 里初始化 m2a 的相关设置
同样，向 geeqie 添加 `m2a` 是一个手动步骤：“Edit > Preferences > Configure Editors …”，然后创建一个附加条目“New”。在这里，你可以定义一个新的桌面文件，如下所示:
```
[Desktop Entry]
Name=move2archive
GenericName=move2archive
Comment=Moving one or more files to my archive folder
Exec=/home/vk/src/misc/vk-m2a-interactive-wrapper-with-gnome-terminal.sh %F
Icon=
Terminal=true
Type=Application
Categories=Application;Graphics;
hidden=false
MimeType=image/*;video/*;image/mpo;image/thm
Categories=X-Geeqie;
```
*m2a.desktop*
封装脚本 `vk-m2a-interactive-wrapper-with-gnome-terminal.sh` 是必要的，因为我想要弹出一个新的终端窗口，以便我的文件进入我指定的目标文件夹：
```
#!/bin/sh
/usr/bin/gnome-terminal \
--geometry=157x56+330+5 \
--tab-with-profile=big \
--hide-menubar \
-x /home/vk/src/m2a/m2a.py --pauseonexit "${@}"
#end
```
*vk-m2a-interactive-wrapper-with-gnome-terminal.sh*
在 geeqie 中，你可以在 “Edit > Preferences > Preferences … > Keyboard” 将 `m` 与 `m2a` 命令相关联。
#### 工作流程：旋转图像（无损）
通常，我的数码相机会自动将人像照片标记为人像照片。然而，在某些特定的情况下（比如从装饰图案上方拍照），我的相机会出错。在那些**罕见的情况下**，我必须手动修正方向。
你必须知道，JPEG 文件格式是一种有损格式，应该只用于照片，而不是计算机生成的东西，如屏幕截图或图表。以傻瓜方式旋转 JPEG 图像文件通常会解压/可视化图像文件、旋转生成新的图像，然后重新编码结果。这将导致生成的图像[比原始图像质量差得多](http://petapixel.com/2012/08/14/why-you-should-always-rotate-original-jpeg-photos-losslessly/)。
因此，你应该使用无损方法来旋转 JPEG 图像文件。
再一次，我添加了一个“外部编辑器”到 geeqie：“Edit > Preferences > Configure Editors … > New”。在这里，我添加了两个条目：使用 [exiftran](http://manpages.ubuntu.com/manpages/raring/man1/exiftran.1.html)，一个用于旋转 270 度（即逆时针旋转 90 度），另一个用于旋转 90 度（顺时针旋转 90 度）：
```
[Desktop Entry]
Version=1.0
Type=Application
Name=Losslessly rotate JPEG image counterclockwise
# call the helper script
TryExec=exiftran
Exec=exiftran -p -2 -i -g %f
# Desktop files that are usable only in Geeqie should be marked like this:
Categories=X-Geeqie;
OnlyShowIn=X-Geeqie;
# Show in menu "Edit/Orientation"
X-Geeqie-Menu-Path=EditMenu/OrientationMenu
MimeType=image/jpeg;
```
*rotate-270.desktop*
```
[Desktop Entry]
Version=1.0
Type=Application
Name=Losslessly rotate JPEG image clockwise
# call the helper script
TryExec=exiftran
Exec=exiftran -p -9 -i -g %f
# Desktop files that are usable only in Geeqie should be marked like this:
Categories=X-Geeqie;
OnlyShowIn=X-Geeqie;
# Show in menu "Edit/Orientation"
X-Geeqie-Menu-Path=EditMenu/OrientationMenu
# It can be made verbose
# X-Geeqie-Verbose=true
MimeType=image/jpeg;
```
*rotate-90.desktop*
我创建了 geeqie 快捷键 `[`（逆时针方向）和 `]`（顺时针方向）。
#### 工作流程：可视化 GPS 坐标
我的数码相机有一个 GPS 传感器，它在 JPEG 文件的 Exif 元数据中存储当前的地理位置。位置数据以 [WGS 84](https://en.wikipedia.org/wiki/WGS84#A_new_World_Geodetic_System:_WGS_84) 格式存储，如 `47, 58, 26.73; 16, 23, 55.51`（纬度；经度）。这一方式可读性较差，我期望：要么是地图，要么是位置名称。因此，我向 geeqie 添加了一些功能，这样我就可以在 [OpenStreetMap](http://www.openstreetmap.org/) 上看到单个图像文件的位置: `Edit > Preferences > Configure Editors ... > New`。
```
[Desktop Entry]
Name=vkphotolocation
GenericName=vkphotolocation
Comment=
Exec=/home/vk/src/misc/vkphotolocation.sh %F
Icon=
Terminal=true
Type=Application
Categories=Application;Graphics;
hidden=false
MimeType=image/bmp;image/gif;image/jpeg;image/jpg;image/pjpeg;image/png;image/tiff;image/x-bmp;image/x-gray;image/x-icb;image/x-ico;image/x-png;image/x-portable-anymap;image/x-portable-bitmap;image/x-portable-graymap;image/x-portable-pixmap;image/x-xbitmap;image/x-xpixmap;image/x-pcx;image/svg+xml;image/svg+xml-compressed;image/vnd.wap.wbmp;
```
*photolocation.desktop*
这调用了我的名为 `vkphotolocation.sh` 的封装脚本，它使用 [ExifTool](http://www.sno.phy.queensu.ca/%7Ephil/exiftool/) 以 [Marble](http://userbase.kde.org/Marble/Tracking) 能够读取和可视化的适当格式提取该坐标:
```
#!/bin/sh
IMAGEFILE="${1}"
IMAGEFILEBASENAME=`basename ${IMAGEFILE}`
COORDINATES=`exiftool -c %.6f "${IMAGEFILE}" | awk '/GPS Position/ { print $4 " " $6 }'`
if [ "x${COORDINATES}" = "x" ]; then
zenity --info --title="${IMAGEFILEBASENAME}" --text="No GPS-location found in the image file."
else
/usr/bin/marble --latlon "${COORDINATES}" --distance 0.5
fi
#end
```
*vkphotolocation.sh*
映射到键盘快捷键 `G`，我可以快速地得到**单个图像文件的位置的地图定位**。
当我想将多个 JPEG 图像文件的**位置可视化为路径**时，我使用 [GpsPrune](http://activityworkshop.net/software/gpsprune/)。我无法挖掘出 GpsPrune 将一组文件作为命令行参数的方法。正因为如此，我必须手动启动 GpsPrune，用 “File > Add photos”选择一组文件或一个文件夹。
通过这种方式，我可以为每个 JPEG 位置在 OpenStreetMap 地图上获得一个点（如果配置为这样）。通过单击这样一个点，我可以得到相应图像的详细信息。
如果你恰好在国外拍摄照片，可视化 GPS 位置对**在文件名中添加描述**大有帮助!
#### 工作流程：根据 GPS 坐标过滤照片
这并非我的工作流程。为了完整起见，我列出该工作流对应工具的特性。我想做的就是从一大堆图片中寻找那些在一定区域内（范围或点 + 距离）的照片。
到目前为止，我只找到了 [DigiKam](https://en.wikipedia.org/wiki/DigiKam)，它能够[根据矩形区域进行过滤](https://docs.kde.org/development/en/extragear-graphics/digikam/using-kapp.html#idp7659904)。如果你知道其他工具，请将其添加到下面的评论或给我写一封电子邮件。
#### 工作流程：显示给定集合的子集
如上面的需求所述，我希望能够对一个文件夹中的文件定义一个子集，以便将这个小集合呈现给其他人。
工作流程非常简单：我向选择的文件添加一个标记（通过 `t`/`filetags`）。为此，我使用标记 `sel`，它是 “selection” 的缩写。在标记了一组文件之后，我可以按下 `s`，它与一个脚本相关联，该脚本只显示标记为 `sel` 的文件。
当然，这也适用于任何标签或标签组合。因此，用同样的方法，你可以得到一个适当的概述，你的婚礼上的所有照片都标记着“教堂”和“戒指”。
很棒的功能，不是吗?:-)
##### 初始设置 filetags 以根据标签和 geeqie 过滤
你必须定义一个额外的“外部编辑器”，“ Edit > Preferences > Configure Editors … > New”：
```
[Desktop Entry]
Name=filetag-filter
GenericName=filetag-filter
Comment=
Exec=/home/vk/src/misc/vk-filetag-filter-wrapper-with-gnome-terminal.sh
Icon=
Terminal=true
Type=Application
Categories=Application;Graphics;
hidden=false
MimeType=image/*;video/*;image/mpo;image/thm
Categories=X-Geeqie;
```
*filter-tags.desktop*
再次调用我编写的封装脚本：
```
#!/bin/sh
/usr/bin/gnome-terminal \
--geometry=85x15+330+5 \
--hide-menubar \
-x /home/vk/src/filetags/filetags.py --filter
#end
```
*vk-filetag-filter-wrapper-with-gnome-terminal.sh*
带有参数 `--filter` 的 `filetags` 基本上完成的是：用户被要求输入一个或多个标签。然后，当前文件夹中所有匹配的文件都使用[符号链接](https://en.wikipedia.org/wiki/Symbolic_link)链接到 `$HOME/.filetags_tagfilter/`。然后，启动了一个新的 geeqie 实例，显示链接的文件。
在退出这个新的 geeqie 实例之后，你会看到进行选择的旧的 geeqie 实例。
#### 用一个真实的案例来总结
哇哦, 这是一篇很长的博客文章。你可能已经忘了之前的概述。总结一下我在（扩展了标准功能集的） geeqie 中可以做的事情，我有一个很酷的总结：
| 快捷键 | 功能 |
| --- | --- |
| `m` | 移到归档（m2a） |
| `o` | 打开（针对非图像文件） |
| `a` | 在文件名里添加字段 |
| `t` | 文件标签（添加） |
| `T` | 文件标签（删除） |
| `s` | 文件标签（排序） |
| `g` | gimp |
| `G` | 显示 GPS 信息 |
| `[` | 无损的逆时针旋转 |
| `]` | 无损的顺时针旋转 |
| `Ctrl-e` | EXIF 图像信息 |
| `f` | 全屏显示 |
文件名（包括它的路径）的部分及我用来操作该部分的相应工具：
```
/this/is/a/folder/2014-04-20T17.09 Picknick in Graz -- food graz.jpg
[ move2archive ] [ date2name ] [appendfilename] [ filetags ]
```
在实践中，我按照以下步骤将照片从相机保存到存档：我将 SD 存储卡放入计算机的 SD 读卡器中。然后我运行 [getdigicamdata.sh](https://github.com/novoid/getdigicamdata.sh)。完成之后，我在 geeqie 中打开 `$HOME/tmp/digicam/tmp/`。我浏览了一下照片，把那些不成功的删除了。如果有一个图像的方向错误，我用 `[` 或 `]` 纠正它。
在第二步中，我向我认为值得评论的文件添加描述 （`a`）。每当我想添加标签时，我也这样做：我快速地标记所有应该共享相同标签的文件（`Ctrl + 鼠标点击`），并使用 [filetags](https://github.com/novoid/filetag)（`t`）进行标记。
要合并来自给定事件的文件，我选中相应的文件，将它们移动到年度归档文件夹中的 `event-folder`，并通过在 [move2archive](https://github.com/novoid/move2archive)（`m`）中键入事件描述，其余的（非特殊的文件夹）无需声明事件描述由 `move2archive` （`m`）直接移动到年度归档中。
结束我的工作流程，我删除了 SD 卡上的所有文件，把它从操作系统上弹出，然后把它放回我的数码相机里。
以上。
因为这种工作流程几乎不需要任何开销，所以评论、标记和归档照片不再是一项乏味的工作。
### 最后
所以，这是一个详细描述我关于照片和电影的工作流程的叙述。你可能已经发现了我可能感兴趣的其他东西。所以请不要犹豫，请使用下面的链接留下评论或电子邮件。
我也希望得到反馈，如果我的工作流程适用于你。并且，如果你已经发布了你的工作流程或者找到了其他人工作流程的描述，也请留下评论!
及时行乐，莫让错误的工具或低效的方法浪费了我们的人生！
### 其他工具
阅读关于[本文中关于 gThumb 的部分](http://karl-voit.at/2017/02/19/gthumb)。
当你觉得你以上文中所叙述的符合你的需求时，请根据相关的建议来选择对应的工具。
---
via: <http://karl-voit.at/managing-digital-photographs/>
作者：[Karl Voit](http://karl-voit.at) 译者：[qfzy1233](https://github.com/qfzy1233) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
Fedora 31 将放弃 32 位 i686 支持 | Justin Forbes | https://fedoramagazine.org/in-fedora-31-32-bit-i686-is-86ed/ | Fedora 31 中丢弃了 32 位 i686 内核及其可启动镜像。 | /data/attachment/album/201910/05/111602sofdze38czrnf58z.jpg.thumb.jpg | /data/attachment/album/201910/05/111602sofdze38czrnf58z.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Fedora",
"32位"
] | 新闻 | {
"viewnum": 3891,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | Fedora 31 中丢弃了 32 位 i686 内核及其可启动镜像。 | 2019-10-05T11:15:59 | 2019-10-05T11:15:59 | 11,424 | /article-11424-1.html | 
Fedora 31 中[丢弃了](https://fedoraproject.org/wiki/Changes/Stop_Building_i686_Kernels) 32 位 i686 内核及其可启动镜像。虽然可能有一些用户仍然拥有无法与 64 位 x86\_64 内核一起使用的硬件，但数量很少。本文为你提供了这次更改背后的整个事情，以及在 Fedora 31 中仍然可以找到的 32 位元素。
### 发生了什么？
i686 架构实质上从 [Fedora 27 版本](https://fedoramagazine.org/announcing-fedora-27/)就进入了社区支持阶段（LCTT 译注：不再由官方支持）。不幸的是，社区中没有足够的成员愿意做维护该体系结构的工作。不过请放心，Fedora 不会删除所有 32 位软件包，仍在构建许多 i686 软件包，以确保诸如 multilib、wine 和 Steam 之类的东西可以继续工作。
尽管该存储库不再构建和镜像输出，但存在一个 koji i686 存储库，该库可与 mock 一起使用以构建 32 位程序包，并且可以在紧要关头安装不属于 x86\_64 multilib 存储库的 32 位版本。当然，维护人员希望这样做解决有限的使用场景。只是需要运行一个 32 位应用程序的用户应该可以在 64 位系统上使用 multilib 来运行。
### 如果你要运行 32 位应用需要做什么？
如果你仍在运行 32 位 i686 系统，则会在 Fedora 30 生命周期中继续收到受支持的 Fedora 更新。直到大约 2020 年 5 月或 6 月。到那时，如果硬件支持，你可以将其重新安装为 64 位 x86\_64，或者如果可能的话，将其替换为支持 64 位的硬件。
社区中有一个用户已经成功地从 32 位 Fedora “升级” 到了 64 位 x86 Fedora。虽然这不是预期或受支持的升级路径，但应该也可行。该项目希望可以为具有 64 位功能的硬件的用户提供一些文档，以在 Fedora 30 使用寿命终止之前说明该升级过程。
如果有 64 位的 CPU，但由于内存不足而运行 32 位 Fedora，请尝试[备用桌面流派](https://spins.fedoraproject.org)之一。LXDE 和其他产品在内存受限的环境中往往表现良好。对于仅在旧的可以扔掉的 32 位硬件上运行简单服务器的用户，请考虑使用较新的 ARM 板之一。在许多情况下，仅节能一项就可以支付新硬件的费用。如果以上皆不可行，[CentOS 7](https://centos.org) 提供了一个 32 位镜像，并对该平台提供长期支持。
### 安全与你
尽管有些用户可能会在生命周期结束后继续运行旧版本的 Fedora，但强烈建议不要这样做。人们不断研究软件的安全问题。通常，他们发现这些问题已经存在多年了。
一旦 Fedora 维护人员知道了此类问题，他们通常会为它们打补丁，并为支持的发行版提供更新，而不会给使用寿命已终止的发行版提供。当然，一旦这些漏洞公开，就会有人尝试利用它们。如果你在生命周期结束时运行了较旧的发行版，则安全风险会随着时间的推移而增加，从而使你的系统面临不断增长的风险。
---
via: <https://fedoramagazine.org/in-fedora-31-32-bit-i686-is-86ed/>
作者：[Justin Forbes](https://fedoramagazine.org/author/jforbes/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
给 Zsh 添加主题和插件 | Seth Kenlon | https://opensource.com/article/19/9/adding-plugins-zsh | 通过 Oh My Zsh 安装的主题和插件来扩展 Zsh 的功能。 | /data/attachment/album/201910/05/120457r49mk2l9oelv94bi.jpg.thumb.jpg | /data/attachment/album/201910/05/120457r49mk2l9oelv94bi.jpg | true | false | true | lujun9972 | amwps290 | wxy | false | [
"Zsh"
] | 技术 | {
"viewnum": 15501,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11378,
"displayorder": 0
}
] | 通过 Oh My Zsh 安装的主题和插件来扩展 Zsh 的功能。 | 2019-10-05T12:05:32 | 2019-10-05T12:05:32 | 11,426 | /article-11426-1.html |
>
> 通过 Oh My Zsh 安装的主题和插件来扩展 Zsh 的功能。
>
>
>
在我的[前文](/article-11378-1.html)中，我向大家展示了如何安装并使用 [Z-Shell](/article-11378-1.html) (Zsh)。对于某些用户来说，Zsh 最令人激动的是它可以安装主题。Zsh 安装主题非常容易，一方面是因为有非常活跃的社区为 Z-Shell 设计主题，另一方面是因为有 [Oh My Zsh](https://ohmyz.sh/) 这个项目。这使得安装主题变得轻而易举。
主题的变化可能会立刻吸引你的注意力，因此如果你安装了 Zsh 并且将默认的 Shell 替换为 Zsh 时，你可能不喜欢 Shell 默认主题的样子，那么你可以立即更换 Oh My Zsh 自带的 100 多个主题。Oh My Zsh 不仅拥有大量精美的主题，同时还有数以百计的扩展 Zsh 功能的插件。
### 安装 Oh My Zsh
Oh My Zsh 的[官网](https://ohmyz.sh/)建议你使用一个脚本在有网络的情况下来安装这个包。尽管 Oh My Zsh 项目几乎是可以令人信服的，但是盲目地在你的电脑上运行一个脚本这是一个糟糕的建议。如果你想运行这个脚本，你可以把它下载下来，看一下它实现了什么功能，在你确信你已经了解了它的所作所为之后，你就可以运行它了。
如果你下载了脚本并且阅读了它，你就会发现安装过程仅仅只有三步：
#### 1、克隆 oh-my-zsh
第一步，克隆 oh-my-zsh 库到 `~/.oh-my-zsh` 目录：
```
% git clone http://github.com/robbyrussell/oh-my-zsh ~/.oh-my-zsh
```
#### 2、切换配置文件
下一步，备份你已有的 `.zshrc` 文件，然后将 oh-my-zsh 自带的配置文件移动到这个地方。这两步操作可以一步完成，只需要你的 `mv` 命令支持 `-b` 这个选项。
```
% mv -b \
~/.oh-my-zsh/templates/zshrc.zsh-template ~/.zshrc
```
#### 3、编辑配置文件
默认情况下，Oh My Zsh 自带的配置文件是非常简陋的。如果你想将你自己的 `~/.zshrc` 文件合并到 `.oh-my-zsh` 的配置文件中。你可以使用 [cat](https://opensource.com/article/19/2/getting-started-cat-command) 命令将你的旧的配置文件添加到新文件的末尾。
```
% cat ~/.zshrc~ >> ~/.zshrc
```
看一下默认的配置文件以及它提供的一些选项。用你最喜欢的编辑器打开 `~/.zshrc` 文件。这个文件有非常良好的注释。这是了解它的一个非常好的方法。
例如，你可以更改 `.oh-my-zsh` 目录的位置。在安装的时候，它默认是位于你的家目录。但是，根据 [Free Desktop](http://freedesktop.org) 所定义的现代 Linux 规范。这个目录应当放置于 `~/.local/share` 。你可以在配置文件中进行修改。如下所示：
```
# Path to your oh-my-zsh installation.
export ZSH=$HOME/.local/share/oh-my-zsh
```
然后将 .oh-my-zsh 目录移动到你新配置的目录下：
```
% mv ~/.oh-my-zsh $HOME/.local/share/oh-my-zsh
```
如果你使用的是 MacOS，这个目录可能会有点含糊不清，但是最合适的位置可能是在 `$HOME/Library/Application\ Support`。
### 重新启动 Zsh
编辑配置文件之后，你必须重新启动你的 Shell。在这之前，你必须确定你的任何操作都已正确完成。例如，在你修改了 `.oh-my-zsh` 目录的路径之后。不要忘记将目录移动到新的位置。如果你不想重新启动你的 Shell。你可以使用 `source` 命令来使你的配置文件生效。
```
% source ~/.zshrc
➜ .oh-my-zsh git:(master) ✗
```
你可以忽略任何丢失更新文件的警告；他们将会在重启的时候再次进行解析。
### 更换你的主题
安装好 oh-my-zsh 之后。你可以将你的 Zsh 的主题设置为 `robbyrussell`，这是一个该项目维护者的主题。这个主题的更改是非常小的，仅仅是改变了提示符的颜色。
你可以通过列出 `.oh-my-zsh` 目录下的所有文件来查看所有安装的主题：
```
➜ .oh-my-zsh git:(master) ✗ ls ~/.local/share/oh-my-zsh/themes
3den.zsh-theme
adben.zsh-theme
af-magic.zsh-theme
afowler.zsh-theme
agnoster.zsh-theme
[...]
```
想在切换主题之前查看一下它的样子，你可以查看 Oh My Zsh 的 [wiki](https://github.com/robbyrussell/oh-my-zsh/wiki/Themes) 页面。要查看更多主题，可以查看 [外部主题](https://github.com/robbyrussell/oh-my-zsh/wiki/External-themes) wiki 页面。
大部分的主题是非常易于安装和使用的，仅仅需要改变 `.zshrc` 文件中的配置选项然后重新载入配置文件。
```
➜ ~ sed -i 's/_THEME=\"robbyrussel\"/_THEME=\"linuxonly\"/g' ~/.zshrc
➜ ~ source ~/.zshrc
seth@darkstar:pts/0->/home/skenlon (0) ➜
```
其他的主题可能需要一些额外的配置。例如，为了使用 `agnoster` 主题，你必须先安装 Powerline 字体。这是一个开源字体，如果你使用 Linux 操作系统的话，这个字体很可能在你的软件库中存在。使用下面的命令安装这个字体：
```
➜ ~ sudo dnf install powerline-fonts
```
在配置文件中更改你的主题：
```
➜ ~ sed -i 's/_THEME=\"linuxonly\"/_THEME=\"agnoster\"/g' ~/.zshrc
```
重新启动你的 Sehll（一个简单的 `source` 命令并不会起作用）。一旦重启，你就可以看到新的主题：
### 安装插件
Oh My Zsh 有超过 200 的插件，你可以在 `.oh-my-zsh/plugins` 中看到它们。每一个扩展目录下都有一个 `README` 文件解释了这个插件的作用。
一些插件相当简单。例如，`dnf`、`ubuntu`、`brew` 和 `macports` 插件仅仅是为了简化与 DNF、Apt、Homebres 和 MacPorts 的交互操作而定义的一些别名。
而其他的一些插件则较为复杂，`git` 插件默认是被激活使用的。当你的目录是一个 git 仓库的时候，这个扩展就会更新你的 Shell 提示符，以显示当前的分支和是否有未合并的更改。
为了激活这个扩展，你可以将这个扩展添加到你的配置文件 `~/.zshrc` 中。例如，你可以添加 `dnf` 和 `pass` 插件，按照如下的方式更改：
```
plugins=(git dnf pass)
```
保存修改，重新启动你的 Shell。
```
% source ~/.zshrc
```
这个扩展现在就可以使用了。你可以通过使用 `dnf` 提供的别名来测试一下：
```
% dnfs fop
====== Name Exactly Matched: fop ======
fop.noarch : XSL-driven print formatter
```
不同的插件做不同的事，因此你可以一次安装一两个插件来帮你学习新的特性和功能。
### 兼容性
一些 Oh My Zsh 插件具有通用性。如果你看到一个插件声称它可以与 Bash 兼容，那么它就可以在你自己的 Bash 中使用。另一些插件需要 Zsh 提供的特定功能。因此，它们并不是所有都能工作。但是你可以添加一些其他的插件，例如 `dnf`、`ubuntu`、`firewalld`，以及其他的一些插件。你可以使用 `source` 使你的选择生效。例如：
```
if [ -d $HOME/.local/share/oh-my-zsh/plugins ]; then
source $HOME/.local/share/oh-my-zsh/plugins/dnf/dnf.plugin.zsh
fi
```
### 选择或者不选择 Zsh
Z-shell 的内置功能和它由社区贡献的扩展功能都非常强大。你可以把它当成你的主 Shell 使用，你也可以在你休闲娱乐的时候尝试一下。这取决于你的爱好。
什么是你最喜爱的主题和扩展可以在下方的评论告诉我们！
---
via: <https://opensource.com/article/19/9/adding-plugins-zsh>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 21 世纪该怎样编译 Linux 内核 | Seth Kenlon | https://opensource.com/article/19/8/linux-kernel-21st-century | 也许你并不需要编译 Linux 内核，但你能通过这篇教程快速上手。 | /data/attachment/album/201910/06/113927vrs6rurljyuza8cy.jpg.thumb.jpg | /data/attachment/album/201910/06/113927vrs6rurljyuza8cy.jpg | true | false | true | lujun9972 | LuuMing | wxy | false | [
"内核"
] | 技术 | {
"viewnum": 5923,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11464,
"displayorder": 0
}
] | 也许你并不需要编译 Linux 内核，但你能通过这篇教程快速上手。 | 2019-10-06T11:40:05 | 2019-10-06T11:40:05 | 11,427 | /article-11427-1.html |
>
> 也许你并不需要编译 Linux 内核，但你能通过这篇教程快速上手。
>
>
>
在计算机世界里，<ruby> 内核 <rt> kernel </rt></ruby>是处理硬件与一般系统之间通信的<ruby> 低阶软件 <rt> low-level software </rt></ruby>。除过一些烧录进计算机主板的初始固件，当你启动计算机时，内核让系统意识到它有一个硬盘驱动器、屏幕、键盘以及网卡。分配给每个部件相等时间（或多或少）使得图像、音频、文件系统和网络可以流畅甚至并行地运行。
然而，对于硬件的需求是源源不断的，随着发布的硬件越多，内核就必须纳入更多代码来保证那些硬件正常工作。得到具体的数字很困难，但是 Linux 内核无疑是硬件兼容性方面的顶级内核之一。Linux 操作着无数的计算机和移动电话、工业用途和爱好者使用的板级嵌入式系统（SoC）、RAID 卡、缝纫机等等。
回到 20 世纪（甚至是 21 世纪初期），对于 Linux 用户来说，在刚买到新的硬件后就需要下载最新的内核代码并编译安装才能使用这是不可理喻的。而现在你也很难见到 Linux 用户为了好玩而编译内核或通过高度专业化定制的硬件的方式赚钱。现在，通常已经不需要再编译 Linux 内核了。
这里列出了一些原因以及快速编译内核的教程。
### 更新当前的内核
无论你买了配备新显卡或 Wifi 芯片集的新品牌电脑还是给家里配备一个新的打印机，你的操作系统（称为 GNU+Linux 或 Linux，它也是该内核的名字）需要一个驱动程序来打开新部件（显卡、芯片集、打印机和其他任何东西）的信道。有时候当你插入某些新的设备时而你的电脑表示发现了它，这具有一定的欺骗性。别被骗到了，有时候那就够了，但更多的情况是你的操作系统仅仅是使用了通用的协议检测到安装了新的设备。
例如，你的计算机也许能够鉴别出新的网络打印机，但有时候那仅仅是因为打印机的网卡被设计成为了获得 DHCP 地址而在网络上标识自己。它并不意味着你的计算机知道如何发送文档给打印机进行打印。事实上，你可以认为计算机甚至不“知道”那台设备是一个打印机。它也许仅仅是显示网络有个设备在一个特定的地址上，并且该设备以一系列字符 “p-r-i-n-t-e-r” 标识自己而已。人类语言的便利性对于计算机毫无意义。计算机需要的是一个驱动程序。
内核开发者、硬件制造商、技术支持和爱好者都知道新的硬件会不断地发布。它们大多数都会贡献驱动程序，直接提交给内核开发团队以包含在 Linux 中。例如，英伟达显卡驱动程序通常都会写入 [Nouveau](https://nouveau.freedesktop.org/wiki/) 内核模块中，并且因为英伟达显卡很常用，它的代码都包含在任一个日常使用的发行版内核中（例如当下载 [Fedora](http://fedoraproject.org) 或 [Ubuntu](http://ubuntu.com) 得到的内核）。英伟达也有不常用的地方，例如嵌入式系统中 Nouveau 模块通常被移除。对其他设备来说也有类似的模块：打印机得益于 [Foomatic](https://wiki.linuxfoundation.org/openprinting/database/foomatic) 和 [CUPS](https://www.cups.org/)，无线网卡有 [b43、ath9k、wl](https://wireless.wiki.kernel.org/en/users/drivers) 模块等等。
发行版往往会在它们 Linux 内核的构建中包含尽可能多合理的驱动程序，因为他们想让你在接入新设备时不用安装驱动程序能够立即使用。对于大多数情况来说就是这样的，尤其是现在很多设备厂商都在资助自己售卖硬件的 Linux 驱动程序开发，并且直接将这些驱动程序提交给内核团队以用在通常的发行版上。
有时候，或许你正在运行六个月之前安装的内核，并配备了上周刚刚上市令人兴奋的新设备。在这种情况下，你的内核也许没有那款设备的驱动程序。好消息是经常会出现那款设备的驱动程序已经存在于最近版本的内核中，意味着你只要更新运行的内核就可以了。
通常，这些都是通过安装包管理软件完成的。例如在 RHEL、CentOS 和 Fedora 上：
```
$ sudo dnf update kernel
```
在 Debian 和 Ubuntu 上，首先获取你当前内核的版本：
```
$ uname -r
4.4.186
```
搜索新的版本：
```
$ sudo apt update
$ sudo apt search linux-image
```
安装找到的最新版本。在这个例子中，最新的版本是 5.2.4：
```
$ sudo apt install linux-image-5.2.4
```
内核更新后，你必须 [reboot](https://opensource.com/article/19/7/reboot-linux) （除非你使用 kpatch 或 kgraft）。这时，如果你需要的设备驱动程序包含在最新的内核中，你的硬件就会正常工作。
### 安装内核模块
有时候一个发行版没有预计到用户会使用某个设备（或者该设备的驱动程序至少不足以包含在 Linux 内核中）。Linux 对于驱动程序采用模块化方式，因此尽管驱动程序没有编译进内核，但发行版可以推送单独的驱动程序包让内核去加载。尽管有些复杂但是非常有用，尤其是当驱动程序没有包含进内核中而是在引导过程中加载，或是内核中的驱动程序相比模块化的驱动程序过期时。第一个问题可以用 “initrd” 解决（初始化 RAM 磁盘），这一点超出了本文的讨论范围，第二点通过 “kmod” 系统解决。
kmod 系统保证了当内核更新后，所有与之安装的模块化驱动程序也得到更新。如果你手动安装一个驱动程序，你就体验不到 kmod 提供的自动化，因此只要能用 kmod 安装包，就应该选择它。例如，尽管英伟达驱动程序以 Nouveau 模块构建在内核中，但官方的驱动程序仅由英伟达发布。你可以去网站上手动安装英伟达旗下的驱动程序，下载 “.run” 文件，并运行提供的 shell 脚本，但在安装了新的内核之后你必须重复相同的过程，因为没有任何东西告诉包管理软件你手动安装了一个内核驱动程序。英伟达驱动着你的显卡，手动更新英伟达驱动程序通常意味着你需要通过终端来执行更新，因为没有显卡驱动程序将无法显示。
然而，如果你通过 kmod 包安装英伟达驱动程序，更新你的内核也会更新你的英伟达驱动程序。在 Fedora 和相关的发行版中：
```
$ sudo dnf install kmod-nvidia
```
在 Debian 和相关发行版上：
```
$ sudo apt update
$ sudo apt install nvidia-kernel-common nvidia-kernel-dkms nvidia-glx nvidia-xconfig nvidia-settings nvidia-vdpau-driver vdpau-va-driver
```
这仅仅是一个例子，但是如果你真的要安装英伟达驱动程序，你也必须屏蔽掉 Nouveau 驱动程序。参考你使用发行版的文档获取最佳的步骤吧。
### 下载并安装驱动程序
不是所有的东西都包含在内核中，也不是所有的东西都可以作为内核模块使用。在某些情况下，你需要下载一个由供应商编写并绑定好的特殊驱动程序，还有一些情况，你有驱动程序，但是没有配置驱动程序的前端界面。
有两个常见的例子是 HP 打印机和 [Wacom](https://linuxwacom.github.io) 数位板。如果你有一台 HP 打印机，你可能有能够和打印机通信的通用的驱动程序，甚至能够打印出东西。但是通用的驱动程序却不能为特定型号的打印机提供定制化的选项，例如双面打印、校对、纸盒选择等等。[HPLIP](https://developers.hp.com/hp-linux-imaging-and-printing)（HP Linux 成像和打印系统）提供了选项来进行任务管理、调整打印设置、选择可用的纸盒等等。
HPLIP 通常包含在包管理软件中；只要搜索“hplip”就行了。
同样的，电子艺术家主要使用的数位板 Wacom 的驱动程序通常也包含在内核中，但是例如调整压感和按键功能等设置只能通过默认包含在 GNOME 的图形控制面板访问。但也可以作为 KDE 上额外的程序包“kde-config-tablet”来访问。
这里也有几个类似的个别例子，例如内核中没有驱动程序，但是以 RPM 或 DEB 文件提供了可供下载并且通过包管理软件安装的 kmod 版本的驱动程序。
### 打上补丁并编译你的内核
即使在 21 世纪的未来主义乌托邦里，仍有厂商不够了解开源，没有提供可安装的驱动程序。有时候，一些公司为驱动程序提供开源代码，而需要你下载代码、修补内核、编译并手动安装。
这种发布方式和在 kmod 系统之外安装打包的驱动程序拥有同样的缺点：对内核的更新会破坏驱动程序，因为每次更换新的内核时都必须手动将其重新集成到内核中。
令人高兴的是，这种事情变得少见了，因为 Linux 内核团队在呼吁公司们与他们交流方面做得很好，并且公司们最终接受了开源不会很快消失的事实。但仍有新奇的或高度专业的设备仅提供了内核补丁。
官方上，对于你如何编译内核以使包管理器参与到升级系统如此重要的部分中，发行版有特定的习惯。这里有太多的包管理器，所以无法一一涵盖。举一个例子，当你使用 Fedora 上的工具例如 `rpmdev` 或 `build-essential`，Debian 上的 `devscripts`。
首先，像通常那样，找到你正在运行内核的版本：
```
$ uname -r
```
在大多数情况下，如果你还没有升级过内核那么可以试试升级一下内核。搞定之后，也许你的问题就会在最新发布的内核中解决。如果你尝试后发现不起作用，那么你应该下载正在运行内核的源码。大多数发行版提供了特定的命令来完成这件事，但是手动操作的话，可以在 [kernel.org](https://www.kernel.org/) 上找到它的源代码。
你必须下载内核所需的任何补丁。有时候，这些补丁对应具体的内核版本，因此请谨慎选择。
通常，或至少在人们习惯于编译内核的那时，都是拿到源代码并对 `/usr/src/linux` 打上补丁。
解压内核源码并打上需要的补丁：
```
$ cd /usr/src/linux
$ bzip2 --decompress linux-5.2.4.tar.bz2
$ cd linux-5.2.4
$ bzip2 -d ../patch*bz2
```
补丁文件也许包含如何使用的教程，但通常它们都设计成在内核源码树的顶层可用来执行。
```
$ patch -p1 < patch*example.patch
```
当内核代码打上补丁后，你可以继续使用旧的配置来对打了补丁的内核进行配置。
```
$ make oldconfig
```
`make oldconfig` 命令有两个作用：它继承了当前的内核配置，并且允许你配置补丁带来的新的选项。
你或许需要运行 `make menuconfig` 命令，它启动了一个基于 ncurses 的菜单界面，列出了新的内核所有可能的选项。整个菜单可能看不过来，但是它是以旧的内核配置为基础的，你可以遍历菜单并且禁用掉你没有或不需要的硬件模块。另外，如果你知道自己有一些硬件没有包含在当前的配置中，你可以选择构建它，当作模块或者直接嵌入内核中。理论上，这些并不是必要的，因为你可以猜想，当前的内核运行良好只是缺少了补丁，当使用补丁的时候可能已经激活了所有设备所必要的选项。
下一步，编译内核和它的模块：
```
$ make bzImage
$ make modules
```
这会产生一个叫作 `vmlinuz` 的文件，它是你的可引导内核的压缩版本。保存旧的版本并在 `/boot` 文件夹下替换为新的。
```
$ sudo mv /boot/vmlinuz /boot/vmlinuz.nopatch
$ sudo cat arch/x86_64/boot/bzImage > /boot/vmlinuz
$ sudo mv /boot/System.map /boot/System.map.stock
$ sudo cp System.map /boot/System.map
```
到目前为止，你已经打上了补丁并且编译了内核和它的模块，你安装了内核，但你并没有安装任何模块。那就是最后的步骤：
```
$ sudo make modules_install
```
新的内核已经就位，并且它的模块也已经安装。
最后一步是更新你的引导程序，为了让你的计算机在加载 Linux 内核之前知道它的位置。GRUB 引导程序使这一过程变得相当简单：
```
$ sudo grub2-mkconfig
```
### 现实生活中的编译
当然，现在没有人手动执行这些命令。相反的，参考你的发行版，寻找发行版维护人员使用的开发者工具集修改内核的说明。这些工具集可能会创建一个集成所有补丁的可安装软件包，告诉你的包管理器来升级并更新你的引导程序。
### 内核
操作系统和内核都是玄学，但要理解构成它们的组件并不难。下一次你看到某个技术无法应用在 Linux 上时，深呼吸，调查可用的驱动程序，寻找一条捷径。Linux 比以前简单多了——包括内核。
---
via: <https://opensource.com/article/19/8/linux-kernel-21st-century>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[LuMing](https://github.com/LuuMing) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 上记录和重放终端会话活动 | Pradeep Kumar | https://www.linuxtechi.com/record-replay-linux-terminal-sessions-activity/ | 在某些情况下，我们要检查上一个会话的命令输出，并希望将其与当前会话进行比较。因此在这种情况下，script 命令就变得很方便。 | /data/attachment/album/201910/06/122659mmi64z8ryr4z2n8a.jpg.thumb.jpg | /data/attachment/album/201910/06/122659mmi64z8ryr4z2n8a.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"记录"
] | 技术 | {
"viewnum": 10797,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "117.136.79.139",
"message": "【script】是一个简单实用的命令，与别人交流或者是想保存重要的命令串时候很有用。",
"username": "phoenix_wangxd [Chrome 77.0|Mac 10.14]",
"date": "2019-10-06T16:57:10"
}
] | [] | 在某些情况下，我们要检查上一个会话的命令输出，并希望将其与当前会话进行比较。因此在这种情况下，script 命令就变得很方便。 | 2019-10-06T12:27:00 | 2019-10-06T12:27:00 | 11,429 | /article-11429-1.html | 通常，Linux 管理员们都使用 `history` 命令来跟踪在先前的会话中执行过哪些命令，但是 `history` 命令的局限性在于它不存储命令的输出。在某些情况下，我们要检查上一个会话的命令输出，并希望将其与当前会话进行比较。除此之外，在某些情况下，我们正在对 Linux 生产环境中的问题进行故障排除，并希望保存所有终端会话活动以供将来参考，因此在这种情况下，`script` 命令就变得很方便。
`script` 是一个命令行工具，用于捕获/记录你的 Linux 服务器终端会话活动，以后可以使用 `scriptreplay` 命令重放记录的会话。在本文中，我们将演示如何安装 `script` 命令行工具以及如何记录 Linux 服务器终端会话活动，然后，我们将看到如何使用 `scriptreplay` 命令来重放记录的会话。
### 安装 script 工具
#### 在 RHEL 7/ CentOS 7 上安装 script 工具
`script` 命令由 RPM 包 `util-linux` 提供，如果你没有在你的 CentOS 7 / RHEL 7 系统上安装它，运行下面的 `yum` 安装它：
```
[root@linuxtechi ~]# yum install util-linux -y
```
#### 在 RHEL 8 / CentOS 8 上安装 script 工具
运行下面的 `dnf` 命令来在 RHEL 8 / CentOS 8 上安装 `script` 工具：
```
[root@linuxtechi ~]# dnf install util-linux -y
```
#### 在基于 Debian 的系统（Ubuntu / Linux Mint）上安装 script 工具
运行下面的 `apt-get` 命令来安装 `script` 工具：
```
root@linuxtechi ~]# apt-get install util-linux -y
```
### 如何使用 script 工具
直接使用 `script` 命令，在终端上键入 `script` 命令，然后按回车，它将开始在名为 `typescript` 的文件中捕获当前的终端会话活动。
```
[root@linuxtechi ~]# script
Script started, file is typescript
[root@linuxtechi ~]#
```
要停止记录会话活动，请键入 `exit` 命令，然后按回车：
```
[root@linuxtechi ~]# exit
exit
Script done, file is typescript
[root@linuxtechi ~]#
```
`script` 命令的语法格式：
```
~] # script {options} {file_name}
```
能在 `script` 命令中使用的不同选项：
让我们开始通过执行 `script` 命令来记录 Linux 终端会话，然后执行诸如 `w`，`route -n`，`df -h` 和 `free -h`，示例如下所示：
正如我们在上面看到的，终端会话日志保存在文件 `typescript` 中：
现在使用 `cat` / `vi` 命令查看 `typescript` 文件的内容，
```
[root@linuxtechi ~]# ls -l typescript
-rw-r--r--. 1 root root 1861 Jun 21 00:50 typescript
[root@linuxtechi ~]#
```
以上内容确认了我们在终端上执行的所有命令都已保存在 `typescript` 文件中。
### 在 script 命令中使用定制文件名
假设我们要使用自定义文件名来执行 `script` 命令，可以在 `script` 命令后指定文件名。在下面的示例中，我们使用的文件名为 `session-log-(当前日期时间).txt`。
```
[root@linuxtechi ~]# script sessions-log-$(date +%d-%m-%Y-%T).txt
Script started, file is sessions-log-21-06-2019-01:37:39.txt
[root@linuxtechi ~]#
```
现在运行该命令并输入 `exit`：
```
[root@linuxtechi ~]# exit
exit
Script done, file is sessions-log-21-06-2019-01:37:39.txt
[root@linuxtechi ~]#
```
### 附加命令输出到 script 记录文件
假设 `script` 命令已经将命令输出记录到名为 `session-log.txt` 的文件中，现在我们想将新会话命令的输出附加到该文件中，那么可以在 `script` 命令中使用 `-a` 选项。
```
[root@linuxtechi ~]# script -a sessions-log.txt
Script started, file is sessions-log.txt
[root@linuxtechi ~]# xfs_info /dev/mapper/centos-root
meta-data=/dev/mapper/centos-root isize=512 agcount=4, agsize=2746624 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=0 spinodes=0
data = bsize=4096 blocks=10986496, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0 ftype=1
log =internal bsize=4096 blocks=5364, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
[root@linuxtechi ~]# exit
exit
Script done, file is sessions-log.txt
[root@linuxtechi ~]#
```
要查看更新的会话记录，使用 `cat session-log.txt` 命令。
### 无需 shell 交互而捕获命令输出到 script 记录文件
假设我们要捕获命令的输出到会话记录文件，那么使用 `-c` 选项，示例如下所示：
```
[root@linuxtechi ~]# script -c "uptime && hostname && date" root-session.txt
Script started, file is root-session.txt
01:57:40 up 2:30, 3 users, load average: 0.00, 0.01, 0.05
linuxtechi
Fri Jun 21 01:57:40 EDT 2019
Script done, file is root-session.txt
[root@linuxtechi ~]#
```
### 以静默模式运行 script 命令
要以静默模式运行 `script` 命令，请使用 `-q` 选项，该选项将禁止 `script` 的启动和完成消息，示例如下所示：
```
[root@linuxtechi ~]# script -c "uptime && date" -q root-session.txt
02:01:10 up 2:33, 3 users, load average: 0.00, 0.01, 0.05
Fri Jun 21 02:01:10 EDT 2019
[root@linuxtechi ~]#
```
要将时序信息记录到文件中并捕获命令输出到单独的文件中，这可以通过在 `script` 命令中传递时序文件（`-timing`）实现，示例如下所示：
语法格式：
```
~ ]# script -t <timing-file-name> {file_name}
```
```
[root@linuxtechi ~]# script --timing=timing.txt session.log
Script started, file is session.log
[root@linuxtechi ~]# uptime
02:27:59 up 3:00, 3 users, load average: 0.00, 0.01, 0.05
[root@linuxtechi ~]# date
Fri Jun 21 02:28:02 EDT 2019
[root@linuxtechi ~]# free -h
total used free shared buff/cache available
Mem: 3.9G 171M 2.0G 8.6M 1.7G 3.3G
Swap: 3.9G 0B 3.9G
[root@linuxtechi ~]# whoami
root
[root@linuxtechi ~]# exit
exit
Script done, file is session.log
[root@linuxtechi ~]#
[root@linuxtechi ~]# ls -l session.log timing.txt
-rw-r--r--. 1 root root 673 Jun 21 02:28 session.log
-rw-r--r--. 1 root root 414 Jun 21 02:28 timing.txt
[root@linuxtechi ~]#
```
### 重放记录的 Linux 终端会话活动
现在，使用 `scriptreplay` 命令重放录制的终端会话活动。
注意：`scriptreplay` 也由 RPM 包 `util-linux` 提供。`scriptreplay` 命令需要时序文件才能工作。
```
[root@linuxtechi ~]# scriptreplay --timing=timing.txt session.log
```
上面命令的输出将如下所示，
### 记录所有用户的 Linux 终端会话活动
在某些关键业务的 Linux 服务器上，我们希望跟踪所有用户的活动，这可以使用 `script` 命令来完成，将以下内容放在 `/etc/profile` 文件中，
```
[root@linuxtechi ~]# vi /etc/profile
……………………………………………………
if [ "x$SESSION_RECORD" = "x" ]
then
timestamp=$(date +%d-%m-%Y-%T)
session_log=/var/log/session/session.$USER.$$.$timestamp
SESSION_RECORD=started
export SESSION_RECORD
script -t -f -q 2>${session_log}.timing $session_log
exit
fi
……………………………………………………
```
保存文件并退出。
在 `/var/log` 文件夹下创建 `session` 目录：
```
[root@linuxtechi ~]# mkdir /var/log/session
```
给该文件夹指定权限：
```
[root@linuxtechi ~]# chmod 777 /var/log/session/
[root@linuxtechi ~]#
```
现在，验证以上代码是否有效。在我正在使用 `pkumar` 用户的情况下，登录普通用户到 Linux 服务器：
```
~ ] # ssh root@linuxtechi
root@linuxtechi's password:
[root@linuxtechi ~]$ uptime
04:34:09 up 5:06, 3 users, load average: 0.00, 0.01, 0.05
[root@linuxtechi ~]$ date
Fri Jun 21 04:34:11 EDT 2019
[root@linuxtechi ~]$ free -h
total used free shared buff/cache available
Mem: 3.9G 172M 2.0G 8.6M 1.7G 3.3G
Swap: 3.9G 0B 3.9G
[root@linuxtechi ~]$ id
uid=1001(pkumar) gid=1002(pkumar) groups=1002(pkumar) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
[root@linuxtechi ~]$ whoami
pkumar
[root@linuxtechi ~]$ exit
Login as root and view user’s linux terminal session activity
[root@linuxtechi ~]# cd /var/log/session/
[root@linuxtechi session]# ls -l | grep pkumar
-rw-rw-r--. 1 pkumar pkumar 870 Jun 21 04:34 session.pkumar.19785.21-06-2019-04:34:05
-rw-rw-r--. 1 pkumar pkumar 494 Jun 21 04:34 session.pkumar.19785.21-06-2019-04:34:05.timing
[root@linuxtechi session]#
```
我们还可以使用 `scriptreplay` 命令来重放用户的终端会话活动：
```
[root@linuxtechi session]# scriptreplay --timing session.pkumar.19785.21-06-2019-04\:34\:05.timing session.pkumar.19785.21-06-2019-04\:34\:05
```
以上就是本教程的全部内容，请在下面的评论部分中分享你的反馈和评论。
---
via: <https://www.linuxtechi.com/record-replay-linux-terminal-sessions-activity/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
通过编写扫雷游戏提高你的 Bash 技巧 | Abhishek Tamrakar | https://opensource.com/article/19/9/advanced-bash-building-minesweeper | 那些令人怀念的经典游戏可是提高编程能力的好素材。今天就让我们仔细探索一番，怎么用 Bash 编写一个扫雷程序。 | /data/attachment/album/201910/07/115136p51t04j584m4o18z.jpg.thumb.jpg | /data/attachment/album/201910/07/115136p51t04j584m4o18z.jpg | true | false | true | lujun9972 | wenwensnow | wxy | false | [
"扫雷"
] | 软件开发 | {
"viewnum": 7412,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11448,
"displayorder": 0
}
] | 那些令人怀念的经典游戏可是提高编程能力的好素材。今天就让我们仔细探索一番，怎么用 Bash 编写一个扫雷程序。 | 2019-10-07T11:51:53 | 2019-10-07T11:51:53 | 11,430 | /article-11430-1.html |
>
> 那些令人怀念的经典游戏可是提高编程能力的好素材。今天就让我们仔细探索一番，怎么用 Bash 编写一个扫雷程序。
>
>
>
我在编程教学方面不是专家，但当我想更好掌握某一样东西时，会试着找出让自己乐在其中的方法。比方说，当我想在 shell 编程方面更进一步时，我决定用 Bash 编写一个[扫雷](https://en.wikipedia.org/wiki/Minesweeper_(video_game))游戏来加以练习。
如果你是一个有经验的 Bash 程序员，希望在提高技巧的同时乐在其中，那么请跟着我编写一个你的运行在终端中的扫雷游戏。完整代码可以在这个 [GitHub 存储库](https://github.com/abhiTamrakar/playground/tree/master/bash_games)中找到。
### 做好准备
在我编写任何代码之前，我列出了该游戏所必须的几个部分：
1. 显示雷区
2. 创建游戏逻辑
3. 创建判断单元格是否可选的逻辑
4. 记录可用和已查明（已排雷）单元格的个数
5. 创建游戏结束逻辑
### 显示雷区
在扫雷中，游戏界面是一个由 2D 数组（列和行）组成的不透明小方格。每一格下都有可能藏有地雷。玩家的任务就是找到那些不含雷的方格，并且在这一过程中，不能点到地雷。这个 Bash 版本的扫雷使用 10x10 的矩阵，实际逻辑则由一个简单的 Bash 数组来完成。
首先，我先生成了一些随机数字。这将是地雷在雷区里的位置。控制地雷的数量，在开始编写代码之前，这么做会容易一些。实现这一功能的逻辑可以更好，但我这么做，是为了让游戏实现保持简洁，并有改进空间。（我编写这个游戏纯属娱乐，但如果你能将它修改的更好，我也是很乐意的。）
下面这些变量在整个过程中是不变的，声明它们是为了随机生成数字。就像下面的 `a` - `g` 的变量，它们会被用来计算可排除的地雷的值：
```
# 变量
score=0 # 会用来存放游戏分数
# 下面这些变量，用来随机生成可排除地雷的实际值
a="1 10 -10 -1"
b="-1 0 1"
c="0 1"
d="-1 0 1 -2 -3"
e="1 2 20 21 10 0 -10 -20 -23 -2 -1"
f="1 2 3 35 30 20 22 10 0 -10 -20 -25 -30 -35 -3 -2 -1"
g="1 4 6 9 10 15 20 25 30 -30 -24 -11 -10 -9 -8 -7"
#
# 声明
declare -a room # 声明一个 room 数组，它用来表示雷区的每一格。
```
接下来，我会用列（0-9）和行（a-j）显示出游戏界面，并且使用一个 10x10 矩阵作为雷区。（`M[10][10]` 是一个索引从 0-99，有 100 个值的数组。） 如想了解更多关于 Bash 数组的内容，请阅读这本书[那些关于 Bash 你所不了解的事: Bash 数组简介](https://opensource.com/article/18/5/you-dont-know-bash-intro-bash-arrays)。
创建一个叫 `plough` 的函数，我们先将标题显示出来：两个空行、列头，和一行 `-`，以示意往下是游戏界面:
```
printf '\n\n'
printf '%s' " a b c d e f g h i j"
printf '\n %s\n' "-----------------------------------------"
```
然后，我初始化一个计数器变量，叫 `r`，它会用来记录已显示多少横行。注意，稍后在游戏代码中，我们会用同一个变量 `r`，作为我们的数组索引。 在 [Bash for 循环](https://opensource.com/article/19/6/how-write-loop-bash)中，用 `seq` 命令从 0 增加到 9。我用数字（`d%`）占位，来显示行号（`$row`，由 `seq` 定义）：
```
r=0 # 计数器
for row in $(seq 0 9); do
printf '%d ' "$row" # 显示 行数 0-9
```
在我们接着往下做之前，让我们看看到现在都做了什么。我们先横着显示 `[a-j]` 然后再将 `[0-9]` 的行号显示出来，我们会用这两个范围，来确定用户排雷的确切位置。
接着，在每行中，插入列，所以是时候写一个新的 `for` 循环了。这一循环管理着每一列，也就是说，实际上是生成游戏界面的每一格。我添加了一些辅助函数，你能在源码中看到它的完整实现。 对每一格来说，我们需要一些让它看起来像地雷的东西，所以我们先用一个点（`.`）来初始化空格。为了实现这一想法，我们用的是一个叫 [`is_null_field`](https://github.com/abhiTamrakar/playground/blob/28143053ced699c80569666f25268e8b96c38c46/bash_games/minesweeper.sh#L114-L120) 的自定义函数。 同时，我们需要一个存储每一格具体值的数组，这儿会用到之前已定义的全局数组 [`room`](https://github.com/abhiTamrakar/playground/blob/28143053ced699c80569666f25268e8b96c38c46/bash_games/minesweeper.sh#L41) , 并用 [变量 `r`](https://github.com/abhiTamrakar/playground/blob/28143053ced699c80569666f25268e8b96c38c46/bash_games/minesweeper.sh#L74)作为索引。随着 `r` 的增加，遍历所有单元格，并随机部署地雷。
```
for col in $(seq 0 9); do
((r+=1)) # 循环完一列行数加一
is_null_field $r # 假设这里有个函数，它会检查单元格是否为空，为真，则此单元格初始值为点（.）
printf '%s \e[33m%s\e[0m ' "|" "${room[$r]}" # 最后显示分隔符，注意，${room[$r]} 的第一个值为 '.'，等于其初始值。
#结束 col 循环
done
```
最后，为了保持游戏界面整齐好看，我会在每行用一个竖线作为结尾，并在最后结束行循环：
```
printf '%s\n' "|" # 显示出行分隔符
printf ' %s\n' "-----------------------------------------"
# 结束行循环
done
printf '\n\n'
```
完整的 `plough` 代码如下：
```
plough()
{
r=0
printf '\n\n'
printf '%s' " a b c d e f g h i j"
printf '\n %s\n' "-----------------------------------------"
for row in $(seq 0 9); do
printf '%d ' "$row"
for col in $(seq 0 9); do
((r+=1))
is_null_field $r
printf '%s \e[33m%s\e[0m ' "|" "${room[$r]}"
done
printf '%s\n' "|"
printf ' %s\n' "-----------------------------------------"
done
printf '\n\n'
}
```
我花了点时间来思考，`is_null_field` 的具体功能是什么。让我们来看看，它到底能做些什么。在最开始，我们需要游戏有一个固定的状态。你可以随便选择个初始值，可以是一个数字或者任意字符。我最后决定，所有单元格的初始值为一个点（`.`），因为我觉得，这样会让游戏界面更好看。下面就是这一函数的完整代码：
```
is_null_field()
{
local e=$1 # 在数组 room 中，我们已经用过循环变量 'r' 了，这次我们用 'e'
if [[ -z "${room[$e]}" ]];then
room[$r]="." #这里用点（.）来初始化每一个单元格
fi
}
```
现在，我已经初始化了所有的格子，现在只要用一个很简单的函数就能得出当前游戏中还有多少单元格可以操作：
```
get_free_fields()
{
free_fields=0 # 初始化变量
for n in $(seq 1 ${#room[@]}); do
if [[ "${room[$n]}" = "." ]]; then # 检查当前单元格是否等于初始值（.），结果为真，则记为空余格子。
((free_fields+=1))
fi
done
}
```
这是显示出来的游戏界面，`[a-j]` 为列，`[0-9]` 为行。
### 创建玩家逻辑
玩家操作背后的逻辑在于，先从 [stdin](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)) 中读取数据作为坐标，然后再找出对应位置实际包含的值。这里用到了 Bash 的[参数扩展](https://www.gnu.org/software/bash/manual/html_node/Shell-Parameter-Expansion.html)，来设法得到行列数。然后将代表列数的字母传给分支语句，从而得到其对应的列数。为了更好地理解这一过程，可以看看下面这段代码中，变量 `o` 所对应的值。 举个例子，玩家输入了 `c3`，这时 Bash 将其分成两个字符：`c` 和 `3`。为了简单起见，我跳过了如何处理无效输入的部分。
```
colm=${opt:0:1} # 得到第一个字符，一个字母
ro=${opt:1:1} # 得到第二个字符，一个整数
case $colm in
a ) o=1;; # 最后，通过字母得到对应列数。
b ) o=2;;
c ) o=3;;
d ) o=4;;
e ) o=5;;
f ) o=6;;
g ) o=7;;
h ) o=8;;
i ) o=9;;
j ) o=10;;
esac
```
下面的代码会计算用户所选单元格实际对应的数字，然后将结果储存在变量中。
这里也用到了很多的 `shuf` 命令，`shuf` 是一个专门用来生成随机序列的 [Linux 命令](https://linux.die.net/man/1/shuf)。`-i` 选项后面需要提供需要打乱的数或者范围，`-n` 选项则规定输出结果最多需要返回几个值。Bash 中，可以在两个圆括号内进行[数学计算](https://www.tldp.org/LDP/abs/html/dblparens.html)，这里我们会多次用到。
还是沿用之前的例子，玩家输入了 `c3`。 接着，它被转化成了 `ro=3` 和 `o=3`。 之后，通过上面的分支语句代码， 将 `c` 转化为对应的整数，带进公式，以得到最终结果 `i` 的值。
```
i=$(((ro*10)+o)) # 遵循运算规则，算出最终值
is_free_field $i $(shuf -i 0-5 -n 1) # 调用自定义函数，判断其指向空/可选择单元格。
```
仔细观察这个计算过程，看看最终结果 `i` 是如何计算出来的：
```
i=$(((ro*10)+o))
i=$(((3*10)+3))=$((30+3))=33
```
最后结果是 33。在我们的游戏界面显示出来，玩家输入坐标指向了第 33 个单元格，也就是在第 3 行（从 0 开始，否则这里变成 4），第 3 列。
### 创建判断单元格是否可选的逻辑
为了找到地雷，在将坐标转化，并找到实际位置之后，程序会检查这一单元格是否可选。如不可选，程序会显示一条警告信息，并要求玩家重新输入坐标。
在这段代码中，单元格是否可选，是由数组里对应的值是否为点（`.`）决定的。如果可选，则重置单元格对应的值，并更新分数。反之，因为其对应值不为点，则设置变量 `not_allowed`。为简单起见，游戏中[警告消息](https://github.com/abhiTamrakar/playground/blob/28143053ced699c80569666f25268e8b96c38c46/bash_games/minesweeper.sh#L143-L177)这部分源码，我会留给读者们自己去探索。
```
is_free_field()
{
local f=$1
local val=$2
not_allowed=0
if [[ "${room[$f]}" = "." ]]; then
room[$f]=$val
score=$((score+val))
else
not_allowed=1
fi
}
```
如输入坐标有效，且对应位置为地雷，如下图所示。玩家输入 `h6`，游戏界面会出现一些随机生成的值。在发现地雷后，这些值会被加入用户得分。
还记得我们开头定义的变量，`a` - `g` 吗，我会用它们来确定随机生成地雷的具体值。所以，根据玩家输入坐标，程序会根据（`m`）中随机生成的数，来生成周围其他单元格的值（如上图所示）。之后将所有值和初始输入坐标相加，最后结果放在 `i`（计算结果如上）中。
请注意下面代码中的 `X`，它是我们唯一的游戏结束标志。我们将它添加到随机列表中。在 `shuf` 命令的魔力下，`X` 可以在任意情况下出现，但如果你足够幸运的话，也可能一直不会出现。
```
m=$(shuf -e a b c d e f g X -n 1) # 将 X 添加到随机列表中，当 m=X，游戏结束
if [[ "$m" != "X" ]]; then # X 将会是我们爆炸地雷（游戏结束）的触发标志
for limit in ${!m}; do # !m 代表 m 变量的值
field=$(shuf -i 0-5 -n 1) # 然后再次获得一个随机数字
index=$((i+limit)) # 将 m 中的每一个值和 index 加起来，直到列表结尾
is_free_field $index $field
done
```
我想要游戏界面中，所有随机显示出来的单元格，都靠近玩家选择的单元格。
### 记录已选择和可用单元格的个数
这个程序需要记录游戏界面中哪些单元格是可选择的。否则，程序会一直让用户输入数据，即使所有单元格都被选中过。为了实现这一功能，我创建了一个叫 `free_fields` 的变量，初始值为 `0`。用一个 `for` 循环，记录下游戏界面中可选择单元格的数量。 如果单元格所对应的值为点（`.`），则 `free_fields` 加一。
```
get_free_fields()
{
free_fields=0
for n in $(seq 1 ${#room[@]}); do
if [[ "${room[$n]}" = "." ]]; then
((free_fields+=1))
fi
done
}
```
等下，如果 `free_fields=0` 呢？ 这意味着，玩家已选择过所有单元格。如果想更好理解这一部分，可以看看这里的[源代码](https://github.com/abhiTamrakar/playground/blob/28143053ced699c80569666f25268e8b96c38c46/bash_games/minesweeper.sh#L91)。
```
if [[ $free_fields -eq 0 ]]; then # 这意味着你已选择过所有格子
printf '\n\n\t%s: %s %d\n\n' "You Win" "you scored" "$score"
exit 0
fi
```
### 创建游戏结束逻辑
对于游戏结束这种情况，我们这里使用了一些很[巧妙的技巧](https://github.com/abhiTamrakar/playground/blob/28143053ced699c80569666f25268e8b96c38c46/bash_games/minesweeper.sh#L131-L141)，将结果在屏幕中央显示出来。我把这部分留给读者朋友们自己去探索。
```
if [[ "$m" = "X" ]]; then
g=0 # 为了在参数扩展中使用它
room[$i]=X # 覆盖此位置原有的值，并将其赋值为X
for j in {42..49}; do # 在游戏界面中央，
out="gameover"
k=${out:$g:1} # 在每一格中显示一个字母
room[$j]=${k^^}
((g+=1))
done
fi
```
最后，我们显示出玩家最关心的两行。
```
if [[ "$m" = "X" ]]; then
printf '\n\n\t%s: %s %d\n' "GAMEOVER" "you scored" "$score"
printf '\n\n\t%s\n\n' "You were just $free_fields mines away."
exit 0
fi
```
文章到这里就结束了，朋友们！如果你想了解更多，具体可以查看我的 [GitHub 存储库](https://github.com/abhiTamrakar/playground/tree/master/bash_games)，那儿有这个扫雷游戏的源代码，并且你还能找到更多用 Bash 编写的游戏。 我希望，这篇文章能激起你学习 Bash 的兴趣，并乐在其中。
---
via: <https://opensource.com/article/19/9/advanced-bash-building-minesweeper>
作者：[Abhishek Tamrakar](https://opensource.com/users/tamrakar) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
4 种开源云安全工具 | Alison Naylor,anderson Silva | 查找并排除你存储在 AWS 和 GitHub 中的数据里的漏洞。 | /data/attachment/album/201910/07/140417vhywycwwdoakzyqi.jpg.thumb.jpg | /data/attachment/album/201910/07/140417vhywycwwdoakzyqi.jpg | true | false | true | lujun9972 | hopefully2333 | wxy | false | [
"云安全"
] | 系统运维 | {
"viewnum": 5666,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 查找并排除你存储在 AWS 和 GitHub 中的数据里的漏洞。 | 2019-10-07T14:04:45 | 2019-10-07T14:04:45 | 11,432 | /article-11432-1.html |
>
> 查找并排除你存储在 AWS 和 GitHub 中的数据里的漏洞。
>
>
>
如果你的日常工作是开发者、系统管理员、全栈工程师或者是网站可靠性工程师（SRE），工作内容包括使用 Git 从 GitHub 上推送、提交和拉取，并部署到亚马逊 Web 服务上（AWS），安全性就是一个需要持续考虑的一个点。幸运的是，开源工具能帮助你的团队避免犯常见错误，这些常见错误会导致你的组织损失数千美元。
本文介绍了四种开源工具，当你在 GitHub 和 AWS 上进行开发时，这些工具能帮助你提升项目的安全性。同样的，本着开源的精神，我会与三位安全专家——[Travis McPeak](https://twitter.com/travismcpeak?lang=en)，奈飞高级云安全工程师；[Rich Monk](https://github.com/rmonk)，红帽首席高级信息安全分析师；以及 [Alison Naylor](https://www.linkedin.com/in/alperkins/)，红帽首席信息安全分析师——共同为本文做出贡献。
我们已经按场景对每个工具都做了区分，但是它们并不是相互排斥的。
### 1、使用 gitrob 发现敏感数据
你需要发现任何出现于你们团队的 Git 仓库中的敏感信息，以便你能将其删除。借助专注于攻击应用程序或者操作系统的工具以使用红/蓝队模型，这样可能会更有意义，在这个模型中，一个信息安全团队会划分为两块，一个是攻击团队（又名红队），以及一个防守团队（又名蓝队）。有一个红队来尝试渗透你的系统和应用要远远好于等待一个攻击者来实际攻击你。你的红队可能会尝试使用 [Gitrob](https://github.com/michenriksen/gitrob)，该工具可以克隆和爬取你的 Git 仓库，以此来寻找凭证和敏感信息。
即使像 Gitrob 这样的工具可以被用来造成破坏，但这里的目的是让你的信息安全团队使用它来发现无意间泄露的属于你的组织的敏感信息（比如 AWS 的密钥对或者是其他被失误提交上去的凭证）。这样，你可以修整你的仓库并清除敏感数据——希望能赶在攻击者发现它们之前。记住不光要修改受影响的文件，还要[删除它们的历史记录](https://help.github.com/en/articles/removing-sensitive-data-from-a-repository)。
### 2、使用 git-secrets 来避免合并敏感数据
虽然在你的 Git 仓库里发现并移除敏感信息很重要，但在一开始就避免合并这些敏感信息岂不是更好？即使错误地提交了敏感信息，使用 [git-secrets](https://github.com/awslabs/git-secrets) 可以避免你陷入公开的困境。这款工具可以帮助你设置钩子，以此来扫描你的提交、提交信息和合并信息，寻找常见的敏感信息模式。注意你选择的模式要匹配你的团队使用的凭证，比如 AWS 访问密钥和秘密密钥。如果发现了一个匹配项，你的提交就会被拒绝，一个潜在的危机就此得到避免。
为你已有的仓库设置 git-secrets 是很简单的，而且你可以使用一个全局设置来保护所有你以后要创建或克隆的仓库。你同样可以在公开你的仓库之前，使用 git-secrets 来扫描它们（包括之前所有的历史版本）。
### 3、使用 Key Conjurer 创建临时凭证
有一点额外的保险来防止无意间公开了存储的敏感信息，这是很好的事，但我们还可以做得更好，就完全不存储任何凭证。追踪凭证，谁访问了它，存储到了哪里，上次更新是什么时候——太麻烦了。然而，以编程的方式生成的临时凭证就可以避免大量的此类问题，从而巧妙地避开了在 Git 仓库里存储敏感信息这一问题。使用 [Key Conjurer](https://github.com/RiotGames/key-conjurer)，它就是为解决这一需求而被创建出来的。有关更多 Riot Games 为什么创建 Key Conjurer，以及 Riot Games 如何开发的 Key Conjurer，请阅读 [Key Conjurer：我们最低权限的策略](https://technology.riotgames.com/news/key-conjurer-our-policy-least-privilege)。
### 4、使用 Repokid 自动化地提供最小权限
任何一个参加过基本安全课程的人都知道，设置最小权限是基于角色的访问控制的最佳实现。难过的是，离开校门，会发现手动运用最低权限策略会变得如此艰难。一个应用的访问需求会随着时间的流逝而变化，开发人员又太忙了没时间去手动削减他们的权限。[Repokid](https://github.com/Netflix/repokid) 使用 AWS 提供提供的有关身份和访问管理（IAM）的数据来自动化地调整访问策略。Repokid 甚至可以在 AWS 中为超大型组织提供自动化地最小权限设置。
### 工具而已，又不是大招
这些工具并不是什么灵丹妙药，它们只是工具！所以，在尝试使用这些工具或其他的控件之前，请和你的组织里一起工作的其他人确保你们已经理解了你的云服务的使用情况和用法模式。
应该严肃对待你的云服务和代码仓库服务，并熟悉最佳实现的做法。下面的文章将帮助你做到这一点。
**对于 AWS：**
* [管理 AWS 访问密钥的最佳实现](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html)
* [AWS 安全审计指南](https://docs.aws.amazon.com/general/latest/gr/aws-security-audit-guide.html)
**对于 GitHub：**
* [介绍一种新方法来让你的代码保持安全](https://github.blog/2019-05-23-introducing-new-ways-to-keep-your-code-secure/)
* [GitHub 企业版最佳安全实现](https://github.blog/2015-10-09-github-enterprise-security-best-practices/)
同样重要的一点是，和你的安全团队保持联系；他们应该可以为你团队的成功提供想法、建议和指南。永远记住：安全是每个人的责任，而不仅仅是他们的。
---
via: <https://opensource.com/article/19/9/open-source-cloud-security>
作者：[Alison Naylor](https://opensource.com/users/asnaylor),[Anderson Silva](https://opensource.com/users/ansilva) 选题：[lujun9972](https://github.com/lujun9972) 译者：[hopefully2333](https://github.com/hopefully2333) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
现在你可以借助 Insync 在 Linux 中原生使用 OneDrive | Ankush Das | https://itsfoss.com/use-onedrive-on-linux/ | 当 Insync 在 Linux 上支持 Google Drive 时，它变成了 Linux 上非常流行的高级第三方同步工具。我们有篇对 Insync 支持 Google Drive 的详细点评文章。而最近发布的 Insync 3 支持了 OneDrive。 | /data/attachment/album/201910/08/115426ho4nonbbn8nbxgbn.png.thumb.jpg | /data/attachment/album/201910/08/115426ho4nonbbn8nbxgbn.png | true | false | true | lujun9972 | geekpi | wxy | false | [
"Insync",
"OneDrive"
] | 技术 | {
"viewnum": 9421,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "175.155.58.168",
"message": "国内我还是选择坚果云",
"username": "来自四川绵阳的 Chromium 77.0|Ubuntu 用户",
"date": "2019-10-08T12:41:18"
},
{
"postip": "113.110.225.125",
"message": "ubuntu 也可以吗？",
"username": "来自广东深圳的 Chrome 91.0|Windows 10 用户",
"date": "2021-07-08T14:47:22"
},
{
"postip": "113.110.225.125",
"message": "ubuntu 也可以吗？",
"username": "来自广东深圳的 Chrome 91.0|Windows 10 用户",
"date": "2021-07-08T14:47:25"
}
] | [] | 当 Insync 在 Linux 上支持 Google Drive 时，它变成了 Linux 上非常流行的高级第三方同步工具。我们有篇对 Insync 支持 Google Drive 的详细点评文章。而最近发布的 Insync 3 支持了 OneDrive。 | 2019-10-08T11:54:22 | 2019-10-08T11:54:22 | 11,433 | /article-11433-1.html | [OneDrive](https://onedrive.live.com) 是微软的一项云存储服务，它为每个用户提供 5GB 的免费存储空间。它已与微软帐户集成，如果你使用 Windows，那么已在其中预安装了 OneDrive。
OneDrive 无法在 Linux 中作为桌面应用使用。你可以通过网页访问已存储的文件，但无法像在文件管理器中那样使用云存储。
好消息是，你现在可以使用一个非官方工具，它可让你在 Ubuntu 或其他 Linux 发行版中使用 OneDrive。
当 [Insync](https://www.insynchq.com) 在 Linux 上支持 Google Drive 时，它变成了 Linux 上非常流行的高级第三方同步工具。我们有篇对 [Insync 支持 Google Drive](https://itsfoss.com/insync-linux-review/) 的详细点评文章。
而最近[发布的 Insync 3](https://www.insynchq.com/blog/insync-3/) 支持了 OneDrive。因此在本文中，我们将看下如何在 Insync 中使用 OneDrive 以及它的新功能。
>
> 非 FOSS 警告
>
>
> 少数开发者会对非 FOSS 软件引入 Linux 感到痛苦。作为专注于桌面 Linux 的门户，即使不是 FOSS，我们也会在此介绍此类软件。
>
>
> Insync 3 既不是开源软件，也不免费使用。你只有 15 天的试用期进行测试。如果你喜欢它，那么可以按每个帐户终生 29.99 美元的费用购买。
>
>
> 我们不会拿钱来推广它们（以防你这么想）。我们不会在这里这么做。
>
>
>
### 在 Linux 中通过 Insync 获得原生 OneDrive 体验
尽管它是一个付费工具，但依赖 OneDrive 的用户或许希望在他们的 Linux 系统中获得同步 OneDrive 的无缝体验。
首先，你需要从[官方页面](https://www.insynchq.com/downloads?start=true)下载适合你 Linux 发行版的软件包。
* [下载 Insync](https://www.insynchq.com/downloads)
你也可以选择添加仓库并进行安装。你将在 Insync 的[官方网站](https://www.insynchq.com/downloads)看到说明。
安装完成后，只需启动并选择 OneDrive 选项。
另外，要注意的是，你添加的每个 OneDrive 或 Google Drive 帐户都需要单独的许可证。
现在，在授权 OneDrive 帐户后，你必须选择一个用于同步所有内容的基础文件夹，这是 Insync 3 中的一项新功能。
除此之外，设置完成后，你还可以选择性地同步本地或云端的文件/文件夹。
你还可以通过添加自己的规则来自定义同步选项，以忽略/同步所需的文件夹和文件，这完全是可选的。
最后，就这样完成了。
你现在可以在包括带有 Insync 的 Linux 桌面在内的多个平台使用 OneDrive 开始同步文件/文件夹。除了上面所有新功能/更改之外，你还可以在 Insync 上获得更快/更流畅的体验。
此外，借助 Insync 3，你可以查看同步进度：
### 总结
总的来说，对于希望在 Linux 系统上同步 OneDrive 的用户而言，Insync 3 是令人印象深刻的升级。如果你不想付款，你可以尝试其他 [Linux 的免费云服务](https://itsfoss.com/cloud-services-linux/)。
你如何看待 Insync？如果你已经在使用它，到目前为止的体验如何？在下面的评论中让我们知道你的想法。
---
via: <https://itsfoss.com/use-onedrive-on-linux/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
使用 guiscrcpy 将你的安卓手机的屏幕投射到你的电脑 | Seth Kenlon | https://opensource.com/article/19/9/mirror-android-screen-guiscrcpy | 使用这个基于 scrcpy 的开源应用从你的电脑上访问你的安卓设备。 | /data/attachment/album/201910/08/123143nlz718152v5nf5n8.png.thumb.jpg | /data/attachment/album/201910/08/123143nlz718152v5nf5n8.png | true | false | true | lujun9972 | amwps290 | wxy | false | [
"安卓"
] | 桌面应用 | {
"viewnum": 7969,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 使用这个基于 scrcpy 的开源应用从你的电脑上访问你的安卓设备。 | 2019-10-08T12:32:23 | 2019-10-08T12:32:23 | 11,434 | /article-11434-1.html |
>
> 使用这个基于 scrcpy 的开源应用从你的电脑上访问你的安卓设备。
>
>
>
在未来，你所需的一切信息皆触手可及，并且全部会以全息的形式出现在空中，即使你在驾驶汽车时也可以与之交互。不过，那是未来，在那一刻到来之前，我们所有人都只能将信息分散在笔记本电脑、手机、平板电脑和智能冰箱上。不幸的是，这意味着当我们需要来自该设备的信息时，我们通常必须查看该设备。
虽然不完全是像全息终端或飞行汽车那样酷炫，但 [srevin saju](http://opensource.com/users/srevinsaju) 开发的 [guiscrcpy](https://github.com/srevinsaju/guiscrcpy) 是一个可以在一个地方整合多个屏幕，让你有一点未来感觉的应用程序。
Guiscrcpy 是一个基于屡获殊荣的一个开源引擎 [scrcpy](https://github.com/Genymobile/scrcpy) 的一个开源项目（GUN GPLv3 许可证）。使用 Guiscrcpy 可以将你的安卓手机的屏幕投射到你的电脑，这样你就可以查看手机上的一切东西。Guiscrcpy 支持 Linux、Windows 和 MacOS。
不像其他 scrcpy 的替代软件一样，Guiscrcpy 并不仅仅是 scrcpy 的一个简单的复制品。该项目优先考虑了与其他开源项目的协作。因此，Guiscrcpy 对 scrcpy 来说是一个扩展，或者说是一个用户界面层。将 Python 3 GUI 与 scrcpy 分开可以确保没有任何东西干扰 scrcpy 后端的效率。你可以投射到 1080P 分辨率的屏幕，因为它的超快的渲染速度和超低的 CPU 使用，即使在低端的电脑上也可以运行的很顺畅。
Scrcpy 是 Guiscrcpy 项目的基石。它是一个基于命令行的应用，因此它没有处理你的手势操作的用户界面。它也没有提供返回按钮和主页按钮，而且它需要你对 [Linux 终端](https://www.redhat.com/sysadmin/navigating-filesystem-linux-terminal)比较熟悉。Guiscrcpy 给 scrcpy 添加了图形面板。因此，任何用户都可以使用它，而且不需要通过网络发送任何信息就可以投射和控制他的设备。Guiscrcpy 同时也为 Windows 用户和 Linux 用户提供了编译好的二进制文件，以方便你的使用。
### 安装 Guiscrcpy
在你安装 Guiscrcpy 之前，你需要先安装它的依赖包。尤其是要安装 scrcpy。安装 scrcpy 最简单的方式可能就是使用对于大部分 Linux 发行版都安装了的 [snap](https://snapcraft.io/) 工具。如果你的电脑上安装并使用了 snap，那么你就可以使用下面的命令来一步安装 scrcpy。
```
$ sudo snap install scrcpy
```
当你安装完 scrcpy，你就可以安装其他的依赖包了。[Simple DirectMedia Layer](https://www.libsdl.org/)（SDL 2.0） 是一个显示和控制你设备屏幕的工具包。[Android Debug Bridge](https://developer.android.com/studio/command-line/adb) (ADB) 命令可以连接你的安卓手机到电脑。
在 Fedora 或者 CentOS：
```
$ sudo dnf install SDL2 android-tools
```
在 Ubuntu 或者 Debian：
```
$ sudo apt install SDL2 android-tools-adb
```
在另一个终端中，安装 Python 依赖项：
```
$ python3 -m pip install -r requirements.txt --user
```
### 设置你的手机
为了能够让你的手机接受 adb 连接。必须让你的手机开启开发者选项。为了打开开发者选项，打开“设置”，然后选择“关于手机”，找到“版本号”（它也可能位于“软件信息”面板中）。不敢置信，只要你连续点击“版本号”七次，你就可以打开开发者选项。（LCTT 译注：显然这里是以 Google 原生的 Android 作为说明的，你的不同品牌的安卓手机打开开发者选项的方式或有不同。）
更多更全面的连接手机的方式，请参考[安卓开发者文档](https://developer.android.com/studio/debug/dev-options)。
一旦你设置好了你的手机，将你的手机通过 USB 线插入到你的电脑中（或者通过无线的方式进行连接，确保你已经配置好了无线连接）。
### 使用 Guiscrcpy
当你启动 guiscrcpy 的时候，你就能看到一个主控制窗口。点击窗口里的 “Start scrcpy” 按钮。只要你设置好了开发者模式并且通过 USB 或者 WiFi 将你的手机连接到电脑。guiscrcpy 就会连接你的手机。
它还包括一个可写入的配置系统，你可以将你的配置文件写入到 `~/.config` 目录。可以在使用前保存你的首选项。
guiscrcpy 底部的面板是一个浮动的窗口，可以帮助你执行一些基本的控制动作。它包括了主页按钮、返回按钮、电源按钮以及一些其他的按键。这些按键在安卓手机上都非常常用。值得注意的是，这个模块并不是与 scrcpy 的 SDL 进行交互。因此，它可以毫无延迟的执行。换句话说，这个操作窗口是直接通过 adb 与你的手机进行交互而不是通过 scrcpy。
这个项目目前十分活跃，不断地有新的特性加入其中。最新版本的具有了手势操作和通知界面。
有了这个 guiscrcpy，你不仅仅可以在你的电脑屏幕上看到你的手机，你还可以就像操作你的实体手机一样点击 SDL 窗口，或者使用浮动窗口上的按钮与之进行交互。
Guiscrcpy 是一个有趣且实用的应用程序，它提供的功能应该是任何现代设备（尤其是 Android 之类的平台）的正式功能。自己尝试一下，为当今的数字生活增添一些未来主义的感觉。
---
via: <https://opensource.com/article/19/9/mirror-android-screen-guiscrcpy>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[amwps290](https://github.com/amwps290) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
我买了一台 Linux 笔记本 | Ricardo Berlasso | https://opensource.com/article/19/7/linux-laptop | 如果你想要一台使用自由软件的强大系统，请毫不犹豫地支持这些公司：他们所提供的物有所值。 | /data/attachment/album/201910/08/133924vnmbklqh5jkshkmj.jpg.thumb.jpg | /data/attachment/album/201910/08/133924vnmbklqh5jkshkmj.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Linux",
"笔记本"
] | 观点 | {
"viewnum": 13836,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "183.212.249.177",
"message": "IBM T410，改光驱为硬盘托架启动，使用FEDORA。",
"username": "来自江苏南京的 Microsoft Edge 18.18362|Windows 10 用户",
"date": "2019-10-10T11:31:12"
},
{
"postip": "183.212.249.177",
"message": "IBM T410，改光驱为硬盘托架启动，使用FEDORA。",
"username": "来自江苏南京的 Microsoft Edge 18.18362|Windows 10 用户",
"date": "2019-10-10T11:31:19"
},
{
"postip": "183.93.114.224",
"message": "邮寄，海关，售后这块是怎么解决的？",
"username": "零度九天 [Chrome 67.0|GNU/Linux]",
"date": "2019-10-11T14:39:23"
}
] | [] | 如果你想要一台使用自由软件的强大系统，请毫不犹豫地支持这些公司：他们所提供的物有所值。 | 2019-10-08T13:40:00 | 2019-10-08T13:40:00 | 11,436 | /article-11436-1.html |
>
> Tuxedo 让买一台开箱即用的 Linux 笔记本变得容易。
>
>
>
最近，我开始使用我买的 Linux 笔记本计算机 Tuxedo Book BC1507。十年前，如果有人告诉我，十年后我可以从 [System76](https://system76.com/)、[Slimbook](https://slimbook.es/en/) 和 [Tuxedo](https://www.tuxedocomputers.com/) 等公司购买到高质量的“企鹅就绪”的笔记本电脑。我可能会发笑。好吧，现在我也在笑，但是很开心！
除了为免费/自由开源软件（FLOSS）设计计算机之外，这三家公司最近[宣布](https://www.tuxedocomputers.com/en/Infos/News/Tuxedo-Computers-stands-for-Free-Software-and-Security-.tuxedo)都试图通过切换到[Coreboot](https://coreboot.org/)来消除专有的 BIOS 软件。
### 买一台
Tuxedo Computers 是一家德国公司，生产支持 Linux 的笔记本电脑。实际上，如果你要使用其他的操作系统，则它的价格会更高。
购买他们的计算机非常容易。Tuxedo 提供了许多付款方式：不仅包括信用卡，而且还包括 PayPal 甚至银行转帐（LCTT 译注：我们需要支付宝和微信支付……此外，要国际配送，还需要支付运输费和清关费用等）。只需在 Tuxedo 的网页上填写银行转帐表格，公司就会给你发送银行信息。
Tuxedo 可以按需构建每台计算机，只需选择基本模型并浏览下拉菜单以选择不同的组件，即可轻松准确地选择所需内容。页面上有很多信息可以指导你进行购买。
如果你选择的 Linux 发行版与推荐的发行版不同，则 Tuxedo 会进行“网络安装”，因此请准备好网络电缆以完成安装，也可以将你首选的镜像文件刻录到 USB 盘上。我通过外部 DVD 阅读器来安装刻录了 openSUSE Leap 15.1 安装程序的 DVD，但是你可用你自己的方式。
我选择的型号最多可以容纳两个磁盘：一个 SSD，另一个可以是 SSD 或常规硬盘。由于已经超出了我的预算，因此我决定选择传统的 1TB 磁盘并将 RAM 增加到 16GB。该处理器是具有四个内核的第八代 i5。我选择了背光西班牙语键盘、1920×1080/96dpi 屏幕和 SD 卡读卡器。总而言之，这是一个很棒的系统。
如果你对默认的英语或德语键盘感觉满意，甚至可以要求在 Meta 键上印上一个企鹅图标！我需要的西班牙语键盘则不提供此选项。
### 收货并开箱使用
付款完成后仅六个工作日，完好包装的计算机就十分安全地到达了我家。打开计算机包装并解锁电池后，我准备好开始浪了。
*我的（物理）桌面上的新玩具。*
该电脑的设计确实很棒，而且感觉扎实。即使此型号的外壳不是铝制的（LCTT 译注：他们有更好看的铝制外壳的型号），也可以保持凉爽。风扇真的很安静，气流像许多其他笔记本电脑一样导向后边缘，而不是流向侧面。电池可提供数小时的续航时间。BIOS 中的一个名为 FlexiCharger 的选项会在达到一定百分比后停止为电池充电，因此在插入电源长时间工作时，无需卸下电池。
键盘真的很舒适，而且非常安静。甚至触摸板按键也很安静！另外，你可以轻松调整背光键盘上的光强度。
最后，很容易访问笔记本电脑中的每个组件，因此可以毫无问题地对计算机进行更新或维修。Tuxedo 甚至送了几个备用螺丝！
### 结语
经过一个月的频繁使用，我对该系统感到非常满意。它完全满足了我的要求，并且一切都很完美。
因为它们通常是高端系统，所以包含 Linux 的计算机往往比较昂贵。如果你将 Tuxedo 或 Slimbook 电脑的价格与更知名品牌的类似规格的价格进行比较，价格相差无几。如果你想要一台使用自由软件的强大系统，请毫不犹豫地支持这些公司：他们所提供的物有所值。
请在评论中让我们知道你在 Tuxedo 和其他“企鹅友好”公司的经历。
---
本文基于 Ricardo 的博客 [From Mind to Type](https://frommindtotype.wordpress.com/) 上发表的“ [我的新企鹅笔记本电脑：Tuxedo-Book-BC1507](https://frommindtotype.wordpress.com/2019/06/17/my-new-penguin-ready-laptop-tuxedo-book-bc1507/)”。
---
via: <https://opensource.com/article/19/7/linux-laptop>
作者：[Ricardo Berlasso](https://opensource.com/users/rgb-es) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
大势已来：阿里云梭哈云原生 | 老王 | 阿里云正在云原生的路上狂奔，将各个产品、服务都押宝在元原生的领域上。 | /data/attachment/album/201910/09/081514u0qs7mz0kjk5gtmk.jpg.thumb.jpg | /data/attachment/album/201910/09/081514u0qs7mz0kjk5gtmk.jpg | true | false | false | false | [
"阿里云",
"云原生"
] | 观点 | {
"viewnum": 5093,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 阿里云正在云原生的路上狂奔，将各个产品、服务都押宝在元原生的领域上。 | 2019-10-09T08:19:00 | 2019-10-09T08:19:00 | 11,437 | /article-11437-1.html | 
### 云原生是什么？
技术圈总是在不停地蹦各种新名词。也不知道从什么时候开始，人们慢慢不怎么提“云计算”这个名词了，而是频繁提到一个新名词“云原生”，好像不这么提就不足以体现云计算原住民的身份。不过，要真的问什么是“云原生”，其实很多人都说不太清楚。随着云原生生态如火如荼的发展，甚至连 CNCF 官方都觉得有必要专门做个定义出来：
前一段时间，我在云栖大会上见到了阿里云的李响，就有人问他，“怎么理解‘云原生’？”作为 CNCF 的技术监督委员会成员的李响，以他的角度对此作了阐释：
“我觉得云原生本身实际上就是比较泛的概念，它最终的目标就是利用云上的资源、云上的服务来重构软件开发以及运行时的生命周期。简而言之就是怎么更好利用云。……随着云的发展，云原生本身也会有一些变化，大家接受云原生的理念和实现云原生的情况也会有变化。……我觉得不用太把云原生本身在一个框框里圈定，它更多还是一个核心的概念——更好地利用云释放云的红利，产生相关的技术让大家去实践。”
在我看来，虽然现在云原生的概念的内涵和外延都在不断的变化当中，但是不可否认的是，云计算生态已经从最初的巨石应用、刚性的分布式计算逐渐演变到原生地基于云计算环境进行设计、开发、部署、运维和弹性伸缩。可以说，云原生重新定义了云计算。
借助于云原生技术，一个计算系统可以很便捷的从一个环境中迁移至另外一个环境当中，而这在之前几年，几乎还是不可想象的。就这个场景，阿里云举了一个例子：比如像三维家，他们在上海云栖大会上宣布了全站上云的消息，因为他们已经应用了云原生的方式，仅花了三天把全部业务迁到阿里云上。而在迁移之后，三维家现在可以利用云原生的方式可以充分发挥云计算的弹性，三分钟之内就可以创建 100 个神龙节点去应对突发的业务需求，极大提升企业 IT 的灵活性，并且降低了 IT 成本。三维家表示，“阿里云的容器生态系统打造得非常完善，从监控、日志、服务暴露、应用拓扑、伸缩扩容方面能够做的更加灵活；基础设施的建设和维护稳定性交给阿里云，目前没有出现过问题。”
### 云原生进化
今年我参加云栖大会，有一个明显的感受就是，阿里云在不断的大声谈论云原生。事实上阿里云早已是云原生计算基金会的成员（现在是白金成员），也在这个领域耕耘良久，但是今年，无论是多到你参加不过来的各种主题演讲，还是各种产品和服务的消息，都在不断的讲，云原生、云原生……
在过去大家更多是把互联网和移动互联网的应用，大部分是无状态应用部署在容器平台之上，今年越来越多的企业开始把有状态的应用、交易类的应用以原生化的方式进行交付，进行自动化的运维。
这次云栖大会上阿里云还发布了 ACK 2.0。ACK 是阿里云容器服务 Kubernetes 版，它提供了高性能可伸缩的容器应用管理能力，支持企业级 Kubernetes 容器化应用的全生命周期管理，简化了集群的搭建和扩容等工作，整合了阿里云虚拟化、存储、网络和安全能力，以打造云端最佳的 Kubernetes 容器化应用运行环境。
关于阿里云容器服务，阿里云的易立说，从 2015 年底公测、2016 年中正式上线到现在的 4 年时间发展非常快，现在已经覆盖了阿里云全球 20 个地域，支撑了国内外数千家客户的生态系统。同时容器产品在持续保持增长，过去 3 年都能保持 400% 以上的增长速度，现在一个月下载次数超过 3 亿次。今年在 Forrester 全球公共云容器平台的评测里面，阿里云是国内排名第一，在 Gartner 报告也唯一入选公共云容器平台竞争格局。
阿里云容器服务优化整合了阿里云整体的计算、存储、网络、安全等核心能力。
比如说计算，不但能够支持强大虚拟机，像神龙这样的裸金属服务，还有异构计算的 CPU、GPU，未来也会包括云栖大会当天发布的含光芯片，通过容器的高效调度能够让 GPU 的利用率提升了 5 倍，而且容器产品能充分把计算资源弹性发挥出来，可以实现分钟级千节点的弹性伸缩，这对客户来说是非常重要的。
而在容器网络方面，它和阿里云的虚拟化网络进行了优化集成，可以实现原生网络一样的性能，与社区的 VXLAN 实现相比提升了 20% 性能。
在存储方面支持阿里云所有的存储产品，包括块存储、网络存储、对象存储等。针对容器场景进行了很多创新，比如说容器高密度部署时容器之间会对 I/O 进行争抢，通过跟操作系统团队进行深入合作，实现了更好的存储 I/O 隔离。另外，还实现了透明、高效的存储缓存，可以低成本支持像高性能计算和AI场景下大数据吞吐量的需求。
本次云栖大会上阿里云发布的 ACK 2.0 面向云原生进化，最重要的是它为整个企业上云奠定了一个新的基石。首先是容器服务全球化的部署，利用在阿里巴巴集团的大规模生产实践沉淀，建立了这样的基础设施。其次，云边端一体化可以实现边缘节点极大降低访问的延迟降低 75%。第三，可以让客户把他的私有云和云端利用 Kubernetes 进行统一管理，应用发布效率可以提升三倍，另外，还提供了全链路的安全架构，对安全风险进行监控。
对于云原生的发展，作为阿里云内部基础设施负责人的李响，在帮助阿里经济体以更为云原生的方式上云，在推动阿里经济体采用 Kubernetes、Service Mesh、Serverless 这些技术。他谈到：
>
> “阿里和蚂蚁有着最大的 Kubernetes 集群，我们对 Kubernetes 上游拓展性、功能性是最大的贡献者之一，我们今年尝试落地Service Mesh，之前大家对 Service Mesh 的疑问是，它能不能应对一个复杂的场景，尤其和传统的微服务体系对接的场景。在阿里巴巴内部要验证这件事情，我们要告诉大家可以做到，而且我们要告诉大家怎么做到，后续会提供解决方案让大家去做这件事情。
>
>
> 第二，大家会思考 Service Mesh 的规模性是不是足够，阿里巴巴其实有巨大规模性的挑战，我们也会解决 Service Mesh 规模性的问题。我们认为阿里巴巴能够使用 Service Mesh，我想世界上 99% 的公司都可以使用 Service Mesh， 而不会遇到它的规模性问题。
>
>
> 第三，Service Mesh 是不是会影响核心链路上的性能问题，会不会影响在核心时刻的性能。我们也会在双 11 这种洪峰流量，对流量要求极高的情况下去验证 Service Mesh，使用 Service Mesh，去打磨 Service Mesh，所有打磨的东西会反馈到上流，让用户、开发者享受到这种红利。
>
>
> 第四，阿里巴巴通过这些事情培养出一批靠谱的工程师，我们有非常强的兜底能力，当用户遇到任何问题，阿里巴巴都能帮你解决问题，阿里巴巴真的是运营这套体系的，有这个生产实践的经验。
>
>
> 阿里巴巴真正把‘云原生’新的概念，在我们认为正确的方向进行落地、进行打磨，最后交付给客户。所有这些东西，当我们说阿里巴巴云上有这样的产品，一定是可靠的，一定是稳定的。”
>
>
>
### 容器安全是重点
当然我们也看到企业客户在使用云原生技术过程中面对几个挑战，第一个挑战就是安全。
安全是企业上云的首要关注。云原生加剧了这个挑战，云原生平台高密度、高动态部署使得遭受攻击可能性增加，而且一旦遭受攻击，用户不知道是谁受到攻击，也没有办法实时应对。
安全是体系性的东西，永远在最弱的一环去攻破整个企业的安全体系。阿里云容器服务实现了非常全面的端到端的云原生安全的架构，包括基础设施的安全，跟阿里云的云安全基础设施紧密基础，利用 RAM 进行认证、鉴权和审计，支持存储的 BYOK 加密等，提供了一个安全的云基础设施。
同时，在应用的生命周期里面用了安全的镜像检测，上线之前要进行扫描，上线之后会进行实时的安全检测。还有运行时的安全，因为安全的风险无处不在，一旦出现了安全问题必须第一时间对它进行监控、报警。
对于企业来讲，大量采用容器之后面临的挑战之一就是安全隔离。比如说一台机器上要混布多种类型的应用，但是有些像金融交易的应用，安全级别敏感性会很高，不希望受到其他应用的攻击和干扰。另外企业除了自己的应用还要部署第三方应用，这个过程中对一些不可信的应用要进行安全的隔离，阿里云引入了安全沙箱一系列的技术。传统的容器 RunC 用是共享内核的机制，很高效，但是安全隔离做得不好，现在可以利用安全沙箱可以进行安全隔离。
在这方面阿里云有一些差异化的优势：首先就是对它进行大量的性能优化，比如说它的网络跟原生的进程没有任何区别，网络性能非常好。整体能够达到 90% 的原生性能，对用户来讲可以获得非常好的安全性，同时对性能损耗是可以接受的。另外，能够让用户自主选择是 RunC 还是安全沙箱，两种容器运行时用户体验是完全一致的，用户可以根据自己对业务需求来选择合适的容器应用技术。
在安全容器领域有几个重要的项目，如 Google 的 gVisor，以及已经属于蚂蚁金服旗下的 Kata 容器项目等，不过和易立的沟通当中，我了解到阿里云容器服务的安全容器所采用的技术并非照搬 Kata 容器技术，而是集成了目前主流的安全容器项目，加以自身的创新而成的。阿里经济体实际上在容器安全方面投入非常大，包括 Kata，还有其他几种技术。他们与蚂蚁金服、阿里的操作系统团队合作一起来提供这样商业化安全容器的实现。这次发布的安全沙箱容器底层技术针对阿里云进行了大量优化，跟 Kata 技术有些类似，但是里面有很多部分不同，性能也做了大量的优化。
现在提供的是基于虚拟化隔离的安全技术，后续会陆续提供其他的技术能力，它们的隔离级别和适用场景是不同的，用户只要去选择就好了，在保证用户体验是一致的基础上，对用户是透明的。
### 结语
我们看到，阿里云正在云原生的路上狂奔，将各个产品、服务都押宝在元原生的领域上。最后，让我们用李响的一段话来结束这篇文章：“新兴的应用，或者是新兴的领域，我们建议你使用容器轻量级自动化平台，现在我们阿里云、ACK 都是朝着这种模式跟大家宣导的。我们要去帮助开发者，引导开发者从非原生的体系向云原生体系去转移，我觉得这条道路非常重要，这也是阿里云的责任，带动整个国内的基础设施，带动国内云原生体系发展，我们要去承担这件事情。”
|
||||
CentOS 8 安装图解 | Pradeep Kumar | https://www.linuxtechi.com/centos-8-installation-guide-screenshots/ | 在这篇文章中，我们会使用图解的方式演示 CentOS 8 的安装方法。 | /data/attachment/album/201910/09/121153tj05o5t2ee79jl63.png.thumb.jpg | /data/attachment/album/201910/09/121153tj05o5t2ee79jl63.png | true | false | true | lujun9972 | HankChow | wxy | false | [
"CentOS"
] | 技术 | {
"viewnum": 152545,
"commentnum": 8,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "14.23.168.10",
"message": "新手入门",
"username": "来自广东广州的 Firefox 69.0|Windows 10 用户",
"date": "2019-10-09T18:20:43"
},
{
"postip": "183.11.68.224",
"message": "很详细！！！<br />\r\n很贴心",
"username": "来自广东深圳的 Chrome 78.0|Windows 10 用户",
"date": "2019-10-27T23:09:05"
},
{
"postip": "183.11.68.224",
"message": "很详细！！！<br />\r\n很贴心",
"username": "来自广东深圳的 Chrome 78.0|Windows 10 用户",
"date": "2019-10-27T23:09:08"
},
{
"postip": "183.11.68.224",
"message": "很详细！！！<br />\r\n很贴心",
"username": "来自广东深圳的 Chrome 78.0|Windows 10 用户",
"date": "2019-10-27T23:09:10"
},
{
"postip": "183.11.68.224",
"message": "很详细！！！<br />\r\n很贴心",
"username": "来自广东深圳的 Chrome 78.0|Windows 10 用户",
"date": "2019-10-27T23:09:10"
},
{
"postip": "221.238.72.154",
"message": "安装完成之后重启开机有三个选项是怎么回事呢？",
"username": "来自天津的 Chrome 79.0|Windows 7 用户",
"date": "2019-12-24T10:19:08"
},
{
"postip": "222.66.149.82",
"message": "有咩有针对“带GUI图形界面的安装”子菜单中，各个选项的讲解和安装推荐 ？？",
"username": "来自上海的 Chrome 78.0|Windows 10 用户",
"date": "2020-03-12T09:18:23"
},
{
"postip": "58.213.189.20",
"message": "写的很详细，优秀的",
"username": "来自江苏南京的 Chrome 92.0|Windows 10 用户",
"date": "2021-08-28T13:42:33"
}
] | [] | 在这篇文章中，我们会使用图解的方式演示 CentOS 8 的安装方法。 | 2019-10-09T12:12:00 | 2019-10-09T12:12:00 | 11,438 | /article-11438-1.html | 
继 RHEL 8 发布之后，CentOS 社区也发布了让人期待已久的 CentOS 8，并发布了两种模式：
* CentOS stream：滚动发布的 Linux 发行版，适用于需要频繁更新的开发者
* CentOS：类似 RHEL 8 的稳定操作系统，系统管理员可以用其部署或配置服务和应用
在这篇文章中，我们会使用图解的方式演示 CentOS 8 的安装方法。
### CentOS 8 的新特性
* DNF 成为了默认的软件包管理器，同时 yum 仍然是可用的
* 使用网络管理器（`nmcli` 和 `nmtui`）进行网络配置，移除了网络脚本
* 使用 Podman 进行容器管理
* 引入了两个新的包仓库：BaseOS 和 AppStream
* 使用 Cockpit 作为默认的系统管理工具
* 默认使用 Wayland 作为显示服务器
* `iptables` 将被 `nftables` 取代
* 使用 Linux 内核 4.18
* 提供 PHP 7.2、Python 3.6、Ansible 2.8、VIM 8.0 和 Squid 4
### CentOS 8 所需的最低硬件配置:
* 2 GB RAM
* 64 位 x86 架构、2 GHz 或以上的 CPU
* 20 GB 硬盘空间
### CentOS 8 安装图解
#### 第一步：下载 CentOS 8 ISO 文件
在 CentOS 官方网站 <https://www.centos.org/download/> 下载 CentOS 8 ISO 文件。
#### 第二步： 创建 CentOS 8 启动介质（USB 或 DVD）
下载 CentOS 8 ISO 文件之后，将 ISO 文件烧录到 USB 移动硬盘或 DVD 光盘中，作为启动介质。
然后重启系统，在 BIOS 中设置为从上面烧录好的启动介质启动。
#### 第三步：选择“安装 CentOS Linux 8.0”选项
当系统从 CentOS 8 ISO 启动介质启动之后，就可以看到以下这个界面。选择“Install CentOS Linux 8.0”（安装 CentOS Linux 8.0）选项并按回车。
#### 第四步：选择偏好语言
选择想要在 CentOS 8 **安装过程**中使用的语言，然后继续。
#### 第五步：准备安装 CentOS 8
这一步我们会配置以下内容：
* 键盘布局
* 日期和时间
* 安装来源
* 软件选择
* 安装目标
* Kdump
如上图所示，安装向导已经自动提供了“<ruby> 键盘布局 <rt> Keyboard </rt></ruby>”、“<ruby> 时间和日期 <rt> Time & Date </rt></ruby>”、“<ruby> 安装来源 <rt> Installation Source </rt></ruby>”和“<ruby> 软件选择 <rt> Software Selection </rt></ruby>”的选项。
如果你需要修改以上设置，点击对应的图标就可以了。例如修改系统的时间和日期，只需要点击“<ruby> 时间和日期 <rt> Time & Date </rt></ruby>”，选择正确的时区，然后点击“<ruby> 完成 <rt> Done </rt></ruby>”即可。
在软件选择选项中选择安装的模式。例如“<ruby> 包含图形界面 <rt> Server with GUI </rt></ruby>”选项会在安装后的系统中提供图形界面，而如果想安装尽可能少的额外软件，可以选择“<ruby> 最小化安装 <rt> Minimal Install </rt></ruby>”。
这里我们选择“<ruby> 包含图形界面 <rt> Server with GUI </rt></ruby>”，点击“<ruby> 完成 <rt> Done </rt></ruby>”。
Kdump 功能默认是开启的。尽管这是一个强烈建议开启的功能，但也可以点击对应的图标将其关闭。
如果想要在安装过程中对网络进行配置，可以点击“<ruby> 网络与主机名 <rt> Network & Host Name </rt></ruby>”选项。
如果系统连接到启用了 DHCP 功能的调制解调器上，就会在启动网络接口的时候自动获取一个 IP 地址。如果需要配置静态 IP，点击“<ruby> 配置 <rt> Configure </rt></ruby>”并指定 IP 的相关信息。除此以外我们还将主机名设置为 “linuxtechi.com”。
完成网络配置后，点击“<ruby> 完成 <rt> Done </rt></ruby>”。
最后我们要配置“<ruby> 安装目标 <rt> Installation Destination </rt></ruby>”，指定 CentOS 8 将要安装到哪一个硬盘，以及相关的分区方式。
点击“<ruby> 完成 <rt> Done </rt></ruby>”。
如图所示，我为 CentOS 8 分配了 40 GB 的硬盘空间。有两种分区方案可供选择：如果由安装向导进行自动分区，可以从“<ruby> 存储配置 <rt> Storage Configuration </rt></ruby>”中选择“<ruby> 自动 <rt> Automatic </rt></ruby>”选项；如果想要自己手动进行分区，可以选择“<ruby> 自定义 <rt> Custom </rt></ruby>”选项。
在这里我们选择“<ruby> 自定义 <rt> Custom </rt></ruby>”选项，并按照以下的方式创建基于 LVM 的分区：
* `/boot` – 2 GB (ext4 文件系统)
* `/` – 12 GB (xfs 文件系统)
* `/home` – 20 GB (xfs 文件系统)
* `/tmp` – 5 GB (xfs 文件系统)
* Swap – 1 GB (xfs 文件系统)
首先创建 `/boot` 标准分区，设置大小为 2GB，如下图所示：
点击“<ruby> 添加挂载点 <rt> Add mount point </rt></ruby>”。
再创建第二个分区 `/`，并设置大小为 12GB。点击加号，指定挂载点和分区大小，点击“<ruby> 添加挂载点 <rt> Add mount point </rt></ruby>”即可。
然后在页面上将 `/` 分区的分区类型从标准更改为 LVM，并点击“<ruby> 更新设置 <rt> Update Settings </rt></ruby>”。
如上图所示，安装向导已经自动创建了一个卷组。如果想要更改卷组的名称，只需要点击“<ruby> 卷组 <rt> Volume Group </rt></ruby>”标签页中的“<ruby> 修改 <rt> Modify </rt></ruby>”选项。
同样地，创建 `/home` 分区和 `/tmp` 分区，分别将大小设置为 20GB 和 5GB，并设置分区类型为 LVM。
最后创建<ruby> 交换分区 <rt> Swap Partition </rt></ruby>。
点击“<ruby> 添加挂载点 <rt> Add mount point </rt></ruby>”。
在完成所有分区设置后，点击“<ruby> 完成 <rt> Done </rt></ruby>”。
在下一个界面，点击“<ruby> 应用更改 <rt> Accept changes </rt></ruby>”，以上做的更改就会写入到硬盘中。
#### 第六步：选择“开始安装”
完成上述的所有更改后，回到先前的安装概览界面，点击“<ruby> 开始安装 <rt> Begin Installation </rt></ruby>”以开始安装 CentOS 8。
下面这个界面表示安装过程正在进行中。
要设置 root 用户的口令，只需要点击 “<ruby> root 口令 <rt> Root Password </rt></ruby>”选项，输入一个口令，然后点击“<ruby> 创建用户 <rt> User Creation </rt></ruby>”选项创建一个本地用户。
填写新创建的用户的详细信息。
在安装完成后，安装向导会提示重启系统。
#### 第七步：完成安装并重启系统
安装完成后要重启系统。只需点击“<ruby> 重启 <rt> Reboot </rt></ruby>”按钮。
注意：重启完成后，记得要把安装介质断开，并将 BIOS 的启动介质设置为硬盘。
#### 第八步：启动新安装的 CentOS 8 并接受许可协议
在 GRUB 引导菜单中，选择 CentOS 8 进行启动。
同意 CentOS 8 的许可证，点击“<ruby> 完成 <rt> Done </rt></ruby>”。
在下一个界面，点击“<ruby> 完成配置 <rt> Finish Configuration </rt></ruby>”。
#### 第九步：配置完成后登录
同意 CentOS 8 的许可证以及完成配置之后，会来到登录界面。
使用刚才创建的用户以及对应的口令登录，按照提示进行操作，就可以看到以下界面。
点击“<ruby> 开始使用 CentOS Linux <rt> Start Using CentOS Linux </rt></ruby>”。
以上就是 CentOS 8 的安装过程，至此我们已经完成了 CentOS 8 的安装。
欢迎给我们发送评论。
---
via: <https://www.linuxtechi.com/centos-8-installation-guide-screenshots/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何通过 SSH 在远程 Linux 系统上运行命令 | Magesh Maruthamuthu | https://www.2daygeek.com/execute-run-linux-commands-remote-system-over-ssh/ | 我们有时可能需要在远程机器上运行一些命令。如果只是偶尔进行的操作，要实现这个目的，可以登录到远程系统上直接执行命令。但是每次都这么做的话，就有点烦人了。既然如此，有没有摆脱这种麻烦操作的更佳方案？ | /data/attachment/album/201910/09/125518dcrqxqr5zb1q1qhf.jpg.thumb.jpg | /data/attachment/album/201910/09/125518dcrqxqr5zb1q1qhf.jpg | true | false | true | lujun9972 | alim0x | wxy | false | [
"SSH"
] | 技术 | {
"viewnum": 10930,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 我们有时可能需要在远程机器上运行一些命令。如果只是偶尔进行的操作，要实现这个目的，可以登录到远程系统上直接执行命令。但是每次都这么做的话，就有点烦人了。既然如此，有没有摆脱这种麻烦操作的更佳方案？ | 2019-10-09T12:55:00 | 2019-10-09T12:55:00 | 11,440 | /article-11440-1.html | 
我们有时可能需要在远程机器上运行一些命令。如果只是偶尔进行的操作，要实现这个目的，可以登录到远程系统上直接执行命令。但是每次都这么做的话，就有点烦人了。既然如此，有没有摆脱这种麻烦操作的更佳方案？
是的，你可以从你本地系统上执行这些操作，而不用登录到远程系统上。这有什么好处吗？毫无疑问。这会为你节省很多好时光。
这是怎么实现的？SSH 允许你无需登录到远程计算机就可以在它上面运行命令。
**通用语法如下所示：**
```
$ ssh [用户名]@[远程主机名或 IP] [命令或脚本]
```
### 1) 如何通过 SSH 在远程 Linux 系统上运行命令
下面的例子允许用户通过 ssh 在远程 Linux 机器上运行 [df 命令](https://www.2daygeek.com/linux-check-disk-space-usage-df-command/)。
```
$ ssh [email protected] df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/centos-root 27G 4.4G 23G 17% /
devtmpfs 903M 0 903M 0% /dev
tmpfs 920M 0 920M 0% /dev/shm
tmpfs 920M 9.3M 910M 2% /run
tmpfs 920M 0 920M 0% /sys/fs/cgroup
/dev/sda1 1014M 179M 836M 18% /boot
tmpfs 184M 8.0K 184M 1% /run/user/42
tmpfs 184M 0 184M 0% /run/user/1000
```
### 2) 如何通过 SSH 在远程 Linux 系统上运行多条命令
下面的例子允许用户通过 ssh 在远程 Linux 机器上一次运行多条命令。
同时在远程 Linux 系统上运行 `uptime` 命令和 `free` 命令。
```
$ ssh [email protected] "uptime && free -m"
23:05:10 up 10 min, 0 users, load average: 0.00, 0.03, 0.03
total used free shared buffers cached
Mem: 1878 432 1445 1 100 134
-/+ buffers/cache: 197 1680
Swap: 3071 0 3071
```
### 3) 如何通过 SSH 在远程 Linux 系统上运行带 sudo 权限的命令
下面的例子允许用户通过 ssh 在远程 Linux 机器上运行带有 [sudo 权限](https://www.2daygeek.com/how-to-configure-sudo-access-in-linux/) 的 `fdisk` 命令。
普通用户不允许执行系统二进制（`/usr/sbin/`）目录下提供的命令。用户需要 root 权限来运行它。
所以你需要 root 权限，好在 Linux 系统上运行 [fdisk 命令](https://www.2daygeek.com/linux-fdisk-command-to-manage-disk-partitions/)。`which` 命令返回给定命令的完整可执行路径。
```
$ which fdisk
/usr/sbin/fdisk
```
```
$ ssh -t [email protected] "sudo fdisk -l"
[sudo] password for daygeek:
Disk /dev/sda: 32.2 GB, 32212254720 bytes, 62914560 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk label type: dos
Disk identifier: 0x000bf685
Device Boot Start End Blocks Id System
/dev/sda1 * 2048 2099199 1048576 83 Linux
/dev/sda2 2099200 62914559 30407680 8e Linux LVM
Disk /dev/sdb: 10.7 GB, 10737418240 bytes, 20971520 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk /dev/mapper/centos-root: 29.0 GB, 28982640640 bytes, 56606720 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk /dev/mapper/centos-swap: 2147 MB, 2147483648 bytes, 4194304 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Connection to centos7.2daygeek.com closed.
```
### 4) 如何通过 SSH 在远程 Linux 系统上运行带 sudo 权限的服务控制命令
下面的例子允许用户通过 ssh 在远程 Linux 机器上运行带有 sudo 权限的服务控制命令。
```
$ ssh -t [email protected] "sudo systemctl restart httpd"
[sudo] password for daygeek:
Connection to centos7.2daygeek.com closed.
```
### 5) 如何通过非标准端口 SSH 在远程 Linux 系统上运行命令
下面的例子允许用户通过 ssh 在使用了非标准端口的远程 Linux 机器上运行 [hostnamectl 命令](https://www.2daygeek.com/four-methods-to-change-the-hostname-in-linux/)。
```
$ ssh -p 2200 [email protected] hostnamectl
Static hostname: Ubuntu18.2daygeek.com
Icon name: computer-vm
Chassis: vm
Machine ID: 27f6c2febda84dc881f28fd145077187
Boot ID: bbeccdf932be41ddb5deae9e5f15183d
Virtualization: oracle
Operating System: Ubuntu 18.04.2 LTS
Kernel: Linux 4.15.0-60-generic
Architecture: x86-64
```
### 6) 如何将远程系统的输出保存到本地系统
下面的例子允许用户通过 ssh 在远程 Linux 机器上运行 [top 命令](https://www.2daygeek.com/understanding-linux-top-command-output-usage/)，并将输出保存到本地系统。
```
$ ssh [email protected] "top -bc | head -n 35" > /tmp/top-output.txt
```
```
cat /tmp/top-output.txt
top - 01:13:11 up 18 min, 1 user, load average: 0.01, 0.05, 0.10
Tasks: 168 total, 1 running, 167 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.0 us, 6.2 sy, 0.0 ni, 93.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 1882300 total, 1176324 free, 342392 used, 363584 buff/cache
KiB Swap: 2097148 total, 2097148 free, 0 used. 1348140 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
4943 daygeek 20 0 162052 2248 1612 R 10.0 0.1 0:00.07 top -bc
1 root 20 0 128276 6936 4204 S 0.0 0.4 0:03.08 /usr/lib/sy+
2 root 20 0 0 0 0 S 0.0 0.0 0:00.00 [kthreadd]
3 root 20 0 0 0 0 S 0.0 0.0 0:00.25 [ksoftirqd/+
4 root 20 0 0 0 0 S 0.0 0.0 0:00.00 [kworker/0:+
5 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kworker/0:+
7 root rt 0 0 0 0 S 0.0 0.0 0:00.00 [migration/+
8 root 20 0 0 0 0 S 0.0 0.0 0:00.00 [rcu_bh]
9 root 20 0 0 0 0 S 0.0 0.0 0:00.77 [rcu_sched]
10 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [lru-add-dr+
11 root rt 0 0 0 0 S 0.0 0.0 0:00.01 [watchdog/0]
13 root 20 0 0 0 0 S 0.0 0.0 0:00.00 [kdevtmpfs]
14 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [netns]
15 root 20 0 0 0 0 S 0.0 0.0 0:00.00 [khungtaskd]
16 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [writeback]
17 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [kintegrity+
18 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [bioset]
19 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [bioset]
20 root 0 -20 0 0 0 S 0.0 0.0 0:00.00 [bioset]
```
或者你也可以使用以下格式在远程系统上运行多条命令：
```
$ ssh [email protected] << EOF
hostnamectl
free -m
grep daygeek /etc/passwd
EOF
```
上面命令的输出如下：
```
Pseudo-terminal will not be allocated because stdin is not a terminal.
Static hostname: CentOS7.2daygeek.com
Icon name: computer-vm
Chassis: vm
Machine ID: 002f47b82af248f5be1d67b67e03514c
Boot ID: dca9a1ba06374d7d96678f9461752482
Virtualization: kvm
Operating System: CentOS Linux 7 (Core)
CPE OS Name: cpe:/o:centos:centos:7
Kernel: Linux 3.10.0-957.el7.x86_64
Architecture: x86-64
total used free shared buff/cache available
Mem: 1838 335 1146 11 355 1314
Swap: 2047 0 2047
daygeek:x:1000:1000:2daygeek:/home/daygeek:/bin/bash
```
### 7) 如何在远程系统上运行本地 Bash 脚本
下面的例子允许用户通过 ssh 在远程 Linux 机器上运行本地 [bash 脚本](https://www.2daygeek.com/understanding-linux-top-command-output-usage/) `remote-test.sh`。
创建一个 shell 脚本并执行它。
```
$ vi /tmp/remote-test.sh
#!/bin/bash
#Name: remote-test.sh
#--------------------
uptime
free -m
df -h
uname -a
hostnamectl
```
上面命令的输出如下：
```
$ ssh [email protected] 'bash -s' < /tmp/remote-test.sh
01:17:09 up 22 min, 1 user, load average: 0.00, 0.02, 0.08
total used free shared buff/cache available
Mem: 1838 333 1148 11 355 1316
Swap: 2047 0 2047
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/centos-root 27G 4.4G 23G 17% /
devtmpfs 903M 0 903M 0% /dev
tmpfs 920M 0 920M 0% /dev/shm
tmpfs 920M 9.3M 910M 2% /run
tmpfs 920M 0 920M 0% /sys/fs/cgroup
/dev/sda1 1014M 179M 836M 18% /boot
tmpfs 184M 12K 184M 1% /run/user/42
tmpfs 184M 0 184M 0% /run/user/1000
Linux CentOS7.2daygeek.com 3.10.0-957.el7.x86_64 #1 SMP Thu Nov 8 23:39:32 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
Static hostname: CentOS7.2daygeek.com
Icon name: computer-vm
Chassis: vm
Machine ID: 002f47b82af248f5be1d67b67e03514c
Boot ID: dca9a1ba06374d7d96678f9461752482
Virtualization: kvm
Operating System: CentOS Linux 7 (Core)
CPE OS Name: cpe:/o:centos:centos:7
Kernel: Linux 3.10.0-957.el7.x86_64
Architecture: x86-64
```
或者也可以使用管道。如果你觉得输出不太好看，再做点修改让它更优雅些。
```
$ vi /tmp/remote-test-1.sh
#!/bin/bash
#Name: remote-test.sh
echo "---------System Uptime--------------------------------------------"
uptime
echo -e "\n"
echo "---------Memory Usage---------------------------------------------"
free -m
echo -e "\n"
echo "---------Disk Usage-----------------------------------------------"
df -h
echo -e "\n"
echo "---------Kernel Version-------------------------------------------"
uname -a
echo -e "\n"
echo "---------HostName Info--------------------------------------------"
hostnamectl
echo "------------------------------------------------------------------"
```
上面脚本的输出如下：
```
$ cat /tmp/remote-test.sh | ssh [email protected]
Pseudo-terminal will not be allocated because stdin is not a terminal.
---------System Uptime--------------------------------------------
03:14:09 up 2:19, 1 user, load average: 0.00, 0.01, 0.05
---------Memory Usage---------------------------------------------
total used free shared buff/cache available
Mem: 1838 376 1063 11 398 1253
Swap: 2047 0 2047
---------Disk Usage-----------------------------------------------
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/centos-root 27G 4.4G 23G 17% /
devtmpfs 903M 0 903M 0% /dev
tmpfs 920M 0 920M 0% /dev/shm
tmpfs 920M 9.3M 910M 2% /run
tmpfs 920M 0 920M 0% /sys/fs/cgroup
/dev/sda1 1014M 179M 836M 18% /boot
tmpfs 184M 12K 184M 1% /run/user/42
tmpfs 184M 0 184M 0% /run/user/1000
tmpfs 184M 0 184M 0% /run/user/0
---------Kernel Version-------------------------------------------
Linux CentOS7.2daygeek.com 3.10.0-957.el7.x86_64 #1 SMP Thu Nov 8 23:39:32 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
---------HostName Info--------------------------------------------
Static hostname: CentOS7.2daygeek.com
Icon name: computer-vm
Chassis: vm
Machine ID: 002f47b82af248f5be1d67b67e03514c
Boot ID: dca9a1ba06374d7d96678f9461752482
Virtualization: kvm
Operating System: CentOS Linux 7 (Core)
CPE OS Name: cpe:/o:centos:centos:7
Kernel: Linux 3.10.0-957.el7.x86_64
Architecture: x86-64
```
### 8) 如何同时在多个远程系统上运行多条指令
下面的 bash 脚本允许用户同时在多个远程系统上运行多条指令。使用简单的 `for` 循环实现。
为了实现这个目的，你可以尝试 [PSSH 命令](https://www.2daygeek.com/pssh-parallel-ssh-run-execute-commands-on-multiple-linux-servers/) 或 [ClusterShell 命令](https://www.2daygeek.com/clustershell-clush-run-commands-on-cluster-nodes-remote-system-in-parallel-linux/) 或 [DSH 命令](https://www.2daygeek.com/dsh-run-execute-shell-commands-on-multiple-linux-servers-at-once/)。
```
$ vi /tmp/multiple-host.sh
for host in CentOS7.2daygeek.com CentOS6.2daygeek.com
do
ssh daygeek@${host} "uname -a;uptime;date;w"
done
```
上面脚本的输出如下：
```
$ sh multiple-host.sh
Linux CentOS7.2daygeek.com 3.10.0-957.el7.x86_64 #1 SMP Thu Nov 8 23:39:32 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
01:33:57 up 39 min, 1 user, load average: 0.07, 0.06, 0.06
Wed Sep 25 01:33:57 CDT 2019
01:33:57 up 39 min, 1 user, load average: 0.07, 0.06, 0.06
USER TTY FROM [email protected] IDLE JCPU PCPU WHAT
daygeek pts/0 192.168.1.6 01:08 23:25 0.06s 0.06s -bash
Linux CentOS6.2daygeek.com 2.6.32-754.el6.x86_64 #1 SMP Tue Jun 19 21:26:04 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
23:33:58 up 39 min, 0 users, load average: 0.00, 0.00, 0.00
Tue Sep 24 23:33:58 MST 2019
23:33:58 up 39 min, 0 users, load average: 0.00, 0.00, 0.00
USER TTY FROM [email protected] IDLE JCPU PCPU WHAT
```
### 9) 如何使用 sshpass 命令添加一个密码
如果你觉得每次输入密码很麻烦，我建议你视你的需求选择以下方法中的一项来解决这个问题。
如果你经常进行类似的操作，我建议你设置 [免密码认证](https://www.2daygeek.com/configure-setup-passwordless-ssh-key-based-authentication-linux/)，因为它是标准且永久的解决方案。
如果你一个月只是执行几次这些任务，我推荐你使用 `sshpass` 工具。只需要使用 `-p` 参数选项提供你的密码即可。
```
$ sshpass -p '在这里输入你的密码' ssh -p 2200 [email protected] ip a
1: lo: 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: mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 08:00:27:18:90:7f brd ff:ff:ff:ff:ff:ff
inet 192.168.1.12/24 brd 192.168.1.255 scope global dynamic eth0
valid_lft 86145sec preferred_lft 86145sec
inet6 fe80::a00:27ff:fe18:907f/64 scope link tentative dadfailed
valid_lft forever preferred_lft forever
```
---
via: <https://www.2daygeek.com/execute-run-linux-commands-remote-system-over-ssh/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[alim0x](https://github.com/alim0x) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
GNU binutils 里的九种武器 | Gaurav Kamathe | https://opensource.com/article/19/10/gnu-binutils | 二进制分析是计算机行业中最被低估的技能。 | /data/attachment/album/201910/10/115409g9nkdm2omutduw7u.jpg.thumb.jpg | /data/attachment/album/201910/10/115409g9nkdm2omutduw7u.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"二进制"
] | 软件开发 | {
"viewnum": 8094,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "58.63.0.209",
"message": "不错，很详细。解答了我的一些问题",
"username": "来自广东广州的 Chrome 100.0|GNU/Linux 用户",
"date": "2022-04-22T23:33:07"
},
{
"postip": "58.63.0.209",
"message": "不错，很详细。解答了我的一些问题",
"username": "来自广东广州的 Chrome 100.0|GNU/Linux 用户",
"date": "2022-04-22T23:33:10"
}
] | [] | 二进制分析是计算机行业中最被低估的技能。 | 2019-10-10T11:54:54 | 2019-10-10T11:54:54 | 11,441 | /article-11441-1.html |
>
> 二进制分析是计算机行业中最被低估的技能。
>
>
>
想象一下，在无法访问软件的源代码时，但仍然能够理解软件的实现方式，在其中找到漏洞，并且更厉害的是还能修复错误。所有这些都是在只有二进制文件时做到的。这听起来就像是超能力，对吧？
你也可以拥有这样的超能力，GNU 二进制实用程序（binutils）就是一个很好的起点。[GNU binutils](https://en.wikipedia.org/wiki/GNU_Binutils) 是一个二进制工具集，默认情况下所有 Linux 发行版中都会安装这些二进制工具。
二进制分析是计算机行业中最被低估的技能。它主要由恶意软件分析师、反向工程师和使用底层软件的人使用。
本文探讨了 binutils 可用的一些工具。我使用的是 RHEL，但是这些示例应该在任何 Linux 发行版上可以运行。
```
[~]# cat /etc/redhat-release
Red Hat Enterprise Linux Server release 7.6 (Maipo)
[~]#
[~]# uname -r
3.10.0-957.el7.x86_64
[~]#
```
请注意，某些打包命令（例如 `rpm`）在基于 Debian 的发行版中可能不可用，因此请使用等效的 `dpkg` 命令替代。
### 软件开发的基础知识
在开源世界中，我们很多人都专注于源代码形式的软件。当软件的源代码随时可用时，很容易获得源代码的副本，打开喜欢的编辑器，喝杯咖啡，然后就可以开始探索了。
但是源代码不是在 CPU 上执行的代码，在 CPU 上执行的是二进制或者说是机器语言指令。二进制或可执行文件是编译源代码时获得的。熟练的调试人员深谙通常这种差异。
### 编译的基础知识
在深入研究 binutils 软件包本身之前，最好先了解编译的基础知识。
编译是将程序从某种编程语言（如 C/C++）的源代码（文本形式）转换为机器代码的过程。
机器代码是 CPU（或一般而言，硬件）可以理解的 1 和 0 的序列，因此可以由 CPU 执行或运行。该机器码以特定格式保存到文件，通常称为可执行文件或二进制文件。在 Linux（和使用 [Linux 兼容二进制](https://www.freebsd.org/doc/handbook/linuxemu.html)的 BSD）上，这称为 [ELF](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format)（<ruby> 可执行和可链接格式 <rt> Executable and Linkable Format </rt></ruby>）。
在生成给定的源文件的可执行文件或二进制文件之前，编译过程将经历一系列复杂的步骤。以这个源程序（C 代码）为例。打开你喜欢的编辑器，然后键入以下程序：
```
#include <stdio.h>
int main(void)
{
printf("Hello World\n");
return 0;
}
```
#### 步骤 1：用 cpp 预处理
[C 预处理程序（cpp）](https://en.wikipedia.org/wiki/C_preprocessor)用于扩展所有宏并将头文件包含进来。在此示例中，头文件 `stdio.h` 将被包含在源代码中。`stdio.h` 是一个头文件，其中包含有关程序内使用的 `printf` 函数的信息。对源代码运行 `cpp`，其结果指令保存在名为 `hello.i` 的文件中。可以使用文本编辑器打开该文件以查看其内容。打印 “hello world” 的源代码在该文件的底部。
```
[testdir]# cat hello.c
#include <stdio.h>
int main(void)
{
printf("Hello World\n");
return 0;
}
[testdir]#
[testdir]# cpp hello.c > hello.i
[testdir]#
[testdir]# ls -lrt
total 24
-rw-r--r--. 1 root root 76 Sep 13 03:20 hello.c
-rw-r--r--. 1 root root 16877 Sep 13 03:22 hello.i
[testdir]#
```
#### 步骤 2：用 gcc 编译
在此阶段，无需创建目标文件就将步骤 1 中生成的预处理源代码转换为汇编语言指令。这个阶段使用 [GNU 编译器集合（gcc）](https://gcc.gnu.org/onlinedocs/gcc/)。对 `hello.i` 文件运行带有 `-S` 选项的 `gcc` 命令后，它将创建一个名为 `hello.s` 的新文件。该文件包含该 C 程序的汇编语言指令。
你可以使用任何编辑器或 `cat` 命令查看其内容。
```
[testdir]#
[testdir]# gcc -Wall -S hello.i
[testdir]#
[testdir]# ls -l
total 28
-rw-r--r--. 1 root root 76 Sep 13 03:20 hello.c
-rw-r--r--. 1 root root 16877 Sep 13 03:22 hello.i
-rw-r--r--. 1 root root 448 Sep 13 03:25 hello.s
[testdir]#
[testdir]# cat hello.s
.file "hello.c"
.section .rodata
.LC0:
.string "Hello World"
.text
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl $.LC0, %edi
call puts
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (GNU) 4.8.5 20150623 (Red Hat 4.8.5-36)"
.section .note.GNU-stack,"",@progbits
[testdir]#
```
#### 步骤 3：用 as 汇编
汇编器的目的是将汇编语言指令转换为机器语言代码，并生成扩展名为 `.o` 的目标文件。此阶段使用默认情况下在所有 Linux 平台上都可用的 GNU 汇编器。
```
testdir]# as hello.s -o hello.o
[testdir]#
[testdir]# ls -l
total 32
-rw-r--r--. 1 root root 76 Sep 13 03:20 hello.c
-rw-r--r--. 1 root root 16877 Sep 13 03:22 hello.i
-rw-r--r--. 1 root root 1496 Sep 13 03:39 hello.o
-rw-r--r--. 1 root root 448 Sep 13 03:25 hello.s
[testdir]#
```
现在，你有了第一个 ELF 格式的文件；但是，还不能执行它。稍后，你将看到“<ruby> 目标文件 <rt> object file </rt></ruby>”和“<ruby> 可执行文件 <rt> executable file </rt></ruby>”之间的区别。
```
[testdir]# file hello.o
hello.o: ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped
```
#### 步骤 4：用 ld 链接
这是编译的最后阶段，将目标文件链接以创建可执行文件。可执行文件通常需要外部函数，这些外部函数通常来自系统库（`libc`）。
你可以使用 `ld` 命令直接调用链接器；但是，此命令有些复杂。相反，你可以使用带有 `-v`（详细）标志的 `gcc` 编译器，以了解链接是如何发生的。（使用 `ld` 命令进行链接作为一个练习，你可以自行探索。）
```
[testdir]# gcc -v hello.o
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/lto-wrapper
Target: x86_64-redhat-linux
Configured with: ../configure --prefix=/usr --mandir=/usr/share/man [...] --build=x86_64-redhat-linux
Thread model: posix
gcc version 4.8.5 20150623 (Red Hat 4.8.5-36) (GCC)
COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/:/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/:[...]:/usr/lib/gcc/x86_64-redhat-linux/
LIBRARY_PATH=/usr/lib/gcc/x86_64-redhat-linux/4.8.5/:/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../:/lib/:/usr/lib/
COLLECT_GCC_OPTIONS='-v' '-mtune=generic' '-march=x86-64'
/usr/libexec/gcc/x86_64-redhat-linux/4.8.5/collect2 --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu [...]/../../../../lib64/crtn.o
[testdir]#
```
运行此命令后，你应该看到一个名为 `a.out` 的可执行文件：
```
[testdir]# ls -l
total 44
-rwxr-xr-x. 1 root root 8440 Sep 13 03:45 a.out
-rw-r--r--. 1 root root 76 Sep 13 03:20 hello.c
-rw-r--r--. 1 root root 16877 Sep 13 03:22 hello.i
-rw-r--r--. 1 root root 1496 Sep 13 03:39 hello.o
-rw-r--r--. 1 root root 448 Sep 13 03:25 hello.s
```
对 `a.out` 运行 `file` 命令，结果表明它确实是 ELF 可执行文件：
```
[testdir]# file a.out
a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=48e4c11901d54d4bf1b6e3826baf18215e4255e5, not stripped
```
运行该可执行文件，看看它是否如源代码所示工作：
```
[testdir]# ./a.out Hello World
```
工作了！在幕后发生了很多事情它才在屏幕上打印了 “Hello World”。想象一下在更复杂的程序中会发生什么。
### 探索 binutils 工具
上面这个练习为使用 binutils 软件包中的工具提供了良好的背景。我的系统带有 binutils 版本 2.27-34；你的 Linux 发行版上的版本可能有所不同。
```
[~]# rpm -qa | grep binutils
binutils-2.27-34.base.el7.x86_64
```
binutils 软件包中提供了以下工具：
```
[~]# rpm -ql binutils-2.27-34.base.el7.x86_64 | grep bin/
/usr/bin/addr2line
/usr/bin/ar
/usr/bin/as
/usr/bin/c++filt
/usr/bin/dwp
/usr/bin/elfedit
/usr/bin/gprof
/usr/bin/ld
/usr/bin/ld.bfd
/usr/bin/ld.gold
/usr/bin/nm
/usr/bin/objcopy
/usr/bin/objdump
/usr/bin/ranlib
/usr/bin/readelf
/usr/bin/size
/usr/bin/strings
/usr/bin/strip
```
上面的编译练习已经探索了其中的两个工具：用作汇编器的 `as` 命令，用作链接器的 `ld` 命令。继续阅读以了解上述 GNU binutils 软件包工具中的其他七个。
#### readelf：显示 ELF 文件信息
上面的练习提到了术语“目标文件”和“可执行文件”。使用该练习中的文件，通过带有 `-h`（标题）选项的 `readelf` 命令，以将文件的 ELF 标题转储到屏幕上。请注意，以 `.o` 扩展名结尾的目标文件显示为 `Type: REL (Relocatable file)`（可重定位文件）：
```
[testdir]# readelf -h hello.o
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 [...]
[...]
Type: REL (Relocatable file)
[...]
```
如果尝试执行此目标文件，会收到一条错误消息，指出无法执行。这仅表示它尚不具备在 CPU 上执行所需的信息。
请记住，你首先需要使用 `chmod` 命令在对象文件上添加 `x`（可执行位），否则你将得到“权限被拒绝”的错误。
```
[testdir]# ./hello.o
bash: ./hello.o: Permission denied
[testdir]# chmod +x ./hello.o
[testdir]#
[testdir]# ./hello.o
bash: ./hello.o: cannot execute binary file
```
如果对 `a.out` 文件尝试相同的命令，则会看到其类型为 `EXEC (Executable file)`（可执行文件）。
```
[testdir]# readelf -h a.out
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
[...] Type: EXEC (Executable file)
```
如上所示，该文件可以直接由 CPU 执行：
```
[testdir]# ./a.out Hello World
```
`readelf` 命令可提供有关二进制文件的大量信息。在这里，它会告诉你它是 ELF 64 位格式，这意味着它只能在 64 位 CPU 上执行，而不能在 32 位 CPU 上运行。它还告诉你它应在 X86-64（Intel/AMD）架构上执行。该二进制文件的入口点是地址 `0x400430`，它就是 C 源程序中 `main` 函数的地址。
在你知道的其他系统二进制文件上尝试一下 `readelf` 命令，例如 `ls`。请注意，在 RHEL 8 或 Fedora 30 及更高版本的系统上，由于安全原因改用了<ruby> 位置无关可执行文件 <rt> position independent executable </rt></ruby>（[PIE](https://en.wikipedia.org/wiki/Position-independent_code#Position-independent_executables)），因此你的输出（尤其是 `Type:`）可能会有所不同。
```
[testdir]# readelf -h /bin/ls
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: EXEC (Executable file)
```
使用 `ldd` 命令了解 `ls` 命令所依赖的系统库，如下所示：
```
[testdir]# ldd /bin/ls
linux-vdso.so.1 => (0x00007ffd7d746000)
libselinux.so.1 => /lib64/libselinux.so.1 (0x00007f060daca000)
libcap.so.2 => /lib64/libcap.so.2 (0x00007f060d8c5000)
libacl.so.1 => /lib64/libacl.so.1 (0x00007f060d6bc000)
libc.so.6 => /lib64/libc.so.6 (0x00007f060d2ef000)
libpcre.so.1 => /lib64/libpcre.so.1 (0x00007f060d08d000)
libdl.so.2 => /lib64/libdl.so.2 (0x00007f060ce89000)
/lib64/ld-linux-x86-64.so.2 (0x00007f060dcf1000)
libattr.so.1 => /lib64/libattr.so.1 (0x00007f060cc84000)
libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f060ca68000)
```
对 `libc` 库文件运行 `readelf` 以查看它是哪种文件。正如它指出的那样，它是一个 `DYN (Shared object file)`（共享对象文件），这意味着它不能直接执行；必须由内部使用了该库提供的任何函数的可执行文件使用它。
```
[testdir]# readelf -h /lib64/libc.so.6
ELF Header:
Magic: 7f 45 4c 46 02 01 01 03 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - GNU
ABI Version: 0
Type: DYN (Shared object file)
```
#### size：列出节的大小和全部大小
`size` 命令仅适用于目标文件和可执行文件，因此，如果尝试在简单的 ASCII 文件上运行它，则会抛出错误，提示“文件格式无法识别”。
```
[testdir]# echo "test" > file1
[testdir]# cat file1
test
[testdir]# file file1
file1: ASCII text
[testdir]# size file1
size: file1: File format not recognized
```
现在，在上面的练习中，对目标文件和可执行文件运行 `size` 命令。请注意，根据 `size` 命令的输出可以看出，可执行文件（`a.out`）的信息要比目标文件（`hello.o`）多得多：
```
[testdir]# size hello.o
text data bss dec hex filename
89 0 0 89 59 hello.o
[testdir]# size a.out
text data bss dec hex filename
1194 540 4 1738 6ca a.out
```
但是这里的 `text`、`data` 和 `bss` 节是什么意思？
`text` 节是指二进制文件的代码部分，其中包含所有可执行指令。`data` 节是所有初始化数据所在的位置，`bss` 节是所有未初始化数据的存储位置。（LCTT 译注：一般来说，在静态的映像文件中，各个部分称之为<ruby> 节 <rt> section </rt></ruby>，而在运行时的各个部分称之为<ruby> 段 <rt> segment </rt></ruby>，有时统称为段。）
比较其他一些可用的系统二进制文件的 `size` 结果。
对于 `ls` 命令：
```
[testdir]# size /bin/ls
text data bss dec hex filename
103119 4768 3360 111247 1b28f /bin/ls
```
只需查看 `size` 命令的输出，你就可以看到 `gcc` 和 `gdb` 是比 `ls` 大得多的程序：
```
[testdir]# size /bin/gcc
text data bss dec hex filename
755549 8464 81856 845869 ce82d /bin/gcc
[testdir]# size /bin/gdb
text data bss dec hex filename
6650433 90842 152280 6893555 692ff3 /bin/gdb
```
#### strings：打印文件中的可打印字符串
在 `strings` 命令中添加 `-d` 标志以仅显示 `data` 节中的可打印字符通常很有用。
`hello.o` 是一个目标文件，其中包含打印出 `Hello World` 文本的指令。因此，`strings` 命令的唯一输出是 `Hello World`。
```
[testdir]# strings -d hello.o
Hello World
```
另一方面，在 `a.out`（可执行文件）上运行 `strings` 会显示在链接阶段该二进制文件中包含的其他信息：
```
[testdir]# strings -d a.out
/lib64/ld-linux-x86-64.so.2
!^BU
libc.so.6
puts
__libc_start_main
__gmon_start__
GLIBC_2.2.5
UH-0
UH-0
=(
[]A\A]A^A_
Hello World
;*3$"
```
#### objdump：显示目标文件信息
另一个可以从二进制文件中转储机器语言指令的 binutils 工具称为 `objdump`。使用 `-d` 选项，可从二进制文件中反汇编出所有汇编指令。
回想一下，编译是将源代码指令转换为机器代码的过程。机器代码仅由 1 和 0 组成，人类难以阅读。因此，它有助于将机器代码表示为汇编语言指令。汇编语言是什么样的？请记住，汇编语言是特定于体系结构的；由于我使用的是 Intel（x86-64）架构，因此如果你使用 ARM 架构编译相同的程序，指令将有所不同。
```
[testdir]# objdump -d hello.o
hello.o: file format elf64-x86-64
Disassembly of section .text:
0000000000000000
:
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: bf 00 00 00 00 mov $0x0,%edi
9: e8 00 00 00 00 callq e
e: b8 00 00 00 00 mov $0x0,%eax
13: 5d pop %rbp
14: c3 retq
```
该输出乍一看似乎令人生畏，但请花一点时间来理解它，然后再继续。回想一下，`.text` 节包含所有的机器代码指令。汇编指令可以在第四列中看到（即 `push`、`mov`、`callq`、`pop`、`retq` 等）。这些指令作用于寄存器，寄存器是 CPU 内置的存储器位置。本示例中的寄存器是 `rbp`、`rsp`、`edi`、`eax` 等，并且每个寄存器都有特殊的含义。
现在对可执行文件（`a.out`）运行 `objdump` 并查看得到的内容。可执行文件的 `objdump` 的输出可能很大，因此我使用 `grep` 命令将其缩小到 `main` 函数：
```
[testdir]# objdump -d a.out | grep -A 9 main\>
000000000040051d
:
40051d: 55 push %rbp
40051e: 48 89 e5 mov %rsp,%rbp
400521: bf d0 05 40 00 mov $0x4005d0,%edi
400526: e8 d5 fe ff ff callq 400400
40052b: b8 00 00 00 00 mov $0x0,%eax
400530: 5d pop %rbp
400531: c3 retq
```
请注意，这些指令与目标文件 `hello.o` 相似，但是其中包含一些其他信息：
* 目标文件 `hello.o` 具有以下指令：`callq e`
* 可执行文件 `a.out` 由以下指令组成，该指令带有一个地址和函数：`callq 400400 <puts@plt>` 上面的汇编指令正在调用 `puts` 函数。请记住，你在源代码中使用了一个 `printf` 函数。编译器插入了对 `puts` 库函数的调用，以将 `Hello World` 输出到屏幕。
查看 `put` 上方一行的说明：
* 目标文件 `hello.o` 有个指令 `mov`：`mov $0x0,%edi`
* 可执行文件 `a.out` 的 `mov` 指令带有实际地址（`$0x4005d0`）而不是 `$0x0`：`mov $0x4005d0,%edi`
该指令将二进制文件中地址 `$0x4005d0` 处存在的内容移动到名为 `edi` 的寄存器中。
这个存储位置的内容中还能是别的什么吗？是的，你猜对了：它就是文本 `Hello, World`。你是如何确定的？
`readelf` 命令使你可以将二进制文件（`a.out`）的任何节转储到屏幕上。以下要求它将 `.rodata`（这是只读数据）转储到屏幕上：
```
[testdir]# readelf -x .rodata a.out
Hex dump of section '.rodata':
0x004005c0 01000200 00000000 00000000 00000000 ....
0x004005d0 48656c6c 6f20576f 726c6400 Hello World.
```
你可以在右侧看到文本 `Hello World`，在左侧可以看到其二进制格式的地址。它是否与你在上面的 `mov` 指令中看到的地址匹配？是的，确实匹配。
#### strip：从目标文件中剥离符号
该命令通常用于在将二进制文件交付给客户之前减小二进制文件的大小。
请记住，由于重要信息已从二进制文件中删除，因此它会妨碍调试。但是，这个二进制文件可以完美地执行。
对 `a.out` 可执行文件运行该命令，并注意会发生什么。首先，通过运行以下命令确保二进制文件没有被剥离（`not stripped`）：
```
[testdir]# file a.out
a.out: ELF 64-bit LSB executable, x86-64, [......] not stripped
```
另外，在运行 `strip` 命令之前，请记下二进制文件中最初的字节数：
```
[testdir]# du -b a.out
8440 a.out
```
现在对该可执行文件运行 `strip` 命令，并使用 `file` 命令以确保正常完成：
```
[testdir]# strip a.out
[testdir]# file a.out a.out: ELF 64-bit LSB executable, x86-64, [......] stripped
```
剥离该二进制文件后，此小程序的大小从之前的 `8440` 字节减小为 `6296` 字节。对于这样小的一个程序都能有这么大的空间节省，难怪大型程序经常被剥离。
```
[testdir]# du -b a.out
6296 a.out
```
#### addr2line：转换地址到文件名和行号
`addr2line` 工具只是在二进制文件中查找地址，并将其与 C 源代码程序中的行进行匹配。很酷，不是吗？
为此编写另一个测试程序；只是这一次确保使用 `gcc` 的 `-g` 标志进行编译，这将为二进制文件添加其它调试信息，并包含有助于调试的行号（由源代码中提供）：
```
[testdir]# cat -n atest.c
1 #include <stdio.h>
2
3 int globalvar = 100;
4
5 int function1(void)
6 {
7 printf("Within function1\n");
8 return 0;
9 }
10
11 int function2(void)
12 {
13 printf("Within function2\n");
14 return 0;
15 }
16
17 int main(void)
18 {
19 function1();
20 function2();
21 printf("Within main\n");
22 return 0;
23 }
```
用 `-g` 标志编译并执行它。正如预期：
```
[testdir]# gcc -g atest.c
[testdir]# ./a.out
Within function1
Within function2
Within main
```
现在使用 `objdump` 来标识函数开始的内存地址。你可以使用 `grep` 命令来过滤出所需的特定行。函数的地址在下面突出显示（`55 push %rbp` 前的地址）：
```
[testdir]# objdump -d a.out | grep -A 2 -E 'main>:|function1>:|function2>:'
000000000040051d :
40051d: 55 push %rbp
40051e: 48 89 e5 mov %rsp,%rbp
--
0000000000400532 :
400532: 55 push %rbp
400533: 48 89 e5 mov %rsp,%rbp
--
0000000000400547
:
400547: 55 push %rbp
400548: 48 89 e5 mov %rsp,%rbp
```
现在，使用 `addr2line` 工具从二进制文件中的这些地址映射到 C 源代码匹配的地址：
```
[testdir]# addr2line -e a.out 40051d
/tmp/testdir/atest.c:6
[testdir]#
[testdir]# addr2line -e a.out 400532
/tmp/testdir/atest.c:12
[testdir]#
[testdir]# addr2line -e a.out 400547
/tmp/testdir/atest.c:18
```
它说 `40051d` 从源文件 `atest.c` 中的第 `6` 行开始，这是 `function1` 的起始大括号（`{`）开始的行。`function2` 和 `main` 的输出也匹配。
#### nm：列出目标文件的符号
使用上面的 C 程序测试 `nm` 工具。使用 `gcc` 快速编译并执行它。
```
[testdir]# gcc atest.c
[testdir]# ./a.out
Within function1
Within function2
Within main
```
现在运行 `nm` 和 `grep` 获取有关函数和变量的信息：
```
[testdir]# nm a.out | grep -Ei 'function|main|globalvar'
000000000040051d T function1
0000000000400532 T function2
000000000060102c D globalvar
U __libc_start_main@@GLIBC_2.2.5
0000000000400547 T main
```
你可以看到函数被标记为 `T`，它表示 `text` 节中的符号，而变量标记为 `D`，表示初始化的 `data` 节中的符号。
想象一下在没有源代码的二进制文件上运行此命令有多大用处？这使你可以窥视内部并了解使用了哪些函数和变量。当然，除非二进制文件已被剥离，这种情况下它们将不包含任何符号，因此 `nm` 就命令不会很有用，如你在此处看到的：
```
[testdir]# strip a.out
[testdir]# nm a.out | grep -Ei 'function|main|globalvar'
nm: a.out: no symbols
```
### 结论
GNU binutils 工具为有兴趣分析二进制文件的人提供了许多选项，这只是它们可以为你做的事情的冰山一角。请阅读每种工具的手册页，以了解有关它们以及如何使用它们的更多信息。
---
via: <https://opensource.com/article/19/10/gnu-binutils>
作者：[Gaurav Kamathe](https://opensource.com/users/gkamathe) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
IceWM：一个非常酷的桌面 | Tdawson | https://fedoramagazine.org/icewm-a-really-cool-desktop/ | IceWM 是一款非常轻量的桌面。它已经出现 20 多年了，它今天的目标仍然与当时相同：速度、简单性以及不妨碍用户。 | /data/attachment/album/201910/10/123525yb1vombkfb3uo6uk.jpg.thumb.jpg | /data/attachment/album/201910/10/123525yb1vombkfb3uo6uk.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"IceWM"
] | 桌面应用 | {
"viewnum": 8705,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | IceWM 是一款非常轻量的桌面。它已经出现 20 多年了，它今天的目标仍然与当时相同：速度、简单性以及不妨碍用户。 | 2019-10-10T12:25:00 | 2019-10-10T12:25:00 | 11,443 | /article-11443-1.html | 
IceWM 是一款非常轻量的桌面。它已经出现 20 多年了，它今天的目标仍然与当时相同：速度、简单性以及不妨碍用户。
我曾经将 IceWM 添加到 Scientific Linux 中作为轻量级桌面。当时它只是 0.5 兆的 rpm 包。运行时，它仅使用 5 兆的内存。这些年来，IceWM 有所增长。rpm 包现在为 1 兆。运行时，IceWM 现在使用 10 兆的内存。尽管在过去十年中它的大小增加了一倍，但它仍然非常小。
这么小的包，你能得到什么？确切地说，就是一个窗口管理器。没有其他东西。你有一个带有菜单或图标的工具栏来启动程序。速度很快。最后，还有主题和选项。除了工具栏中的一些小东西，就只有这些了。
### 安装
因为 IceWM 很小，你只需安装主软件包。
```
$ sudo dnf install icewm
```
如果要节省磁盘空间，许多依赖项都是可选的。没有它们，IceWM 也可以正常工作。
```
$ sudo dnf install icewm --setopt install_weak_deps=false
```
### 选项
IceWM 默认已经设置完毕，以使普通的 Windows 用户也能感到舒适。这是一件好事，因为选项是通过配置文件手动完成的。
我希望你不会因此而止步，因为它并没有听起来那么糟糕。它只有 8 个配置文件，大多数人只使用其中几个。主要的三个配置文件是 `keys`（键绑定），`preferences`（总体首选项）和 `toolbar`（工具栏上显示的内容）。默认配置文件位于 `/usr/share/icewm/`。
要进行更改，请将默认配置复制到 IceWM 家目录（`~/.icewm`），编辑文件，然后重新启动 IceWM。第一次做可能会有点害怕，因为在 “Logout” 菜单项下可以找到 “Restart Icewm”。但是，当你重启 IceWM 时，你只会看到闪烁一下，更改就生效了。任何打开的程序均不受影响，并保持原样。
### 主题
如果安装 icewm-themes 包，那么会得到很多主题。与常规选项不同，你无需重启 IceWM 即可更改为新主题。通常我不会谈论主题，但是由于其他功能很少，因此我想提下。
### 工具栏
工具栏是为 IceWM 添加了更多的功能的地方。你可以看到它可以切换不同的工作区。工作区有时称为虚拟桌面。单击工作区图标以移动到它。右键单击一个窗口的任务栏项目，可以在工作区之间移动它。如果你喜欢工作区，它拥有你想要的所有功能。如果你不喜欢工作区，那么可以选择关闭它。
工具栏还有网络/内存/CPU 监控图。将鼠标悬停在图标上可获得详细信息。单击图标可以打开一个拥有完整监控功能的窗口。这些小图形曾经出现在每个窗口管理器上。但是，随着桌面环境的成熟，它们都将这些图形去除了。我很高兴 IceWM 留下了这个不错的功能。
### 总结
如果你想要轻量但功能强大的桌面，IceWM 适合你。它已经设置好了，因此新的 Linux 用户也可以立即使用它。它是灵活的，因此 Unix 用户可以根据自己的喜好进行调整。最重要的是，IceWM 可以让你的程序不受阻碍地运行。
---
via: <https://fedoramagazine.org/icewm-a-really-cool-desktop/>
作者：[tdawson](https://fedoramagazine.org/author/tdawson/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
安全强化你的 Linux 服务器的七个步骤 | Patrick H. Mullins | https://opensource.com/article/19/10/linux-server-security | 通过七个简单的步骤来加固你的 Linux 服务器。 | /data/attachment/album/201910/11/094107k8skl8wwxq62pzld.jpg.thumb.jpg | /data/attachment/album/201910/11/094107k8skl8wwxq62pzld.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"安全"
] | 系统运维 | {
"viewnum": 9054,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
} | [] | [] | 通过七个简单的步骤来加固你的 Linux 服务器。 | 2019-10-11T09:41:21 | 2019-10-11T09:41:21 | 11,444 | /article-11444-1.html |
>
> 通过七个简单的步骤来加固你的 Linux 服务器。
>
>
>
这篇入门文章将向你介绍基本的 Linux 服务器安全知识。虽然主要针对 Debian/Ubuntu，但是你可以将此处介绍的所有内容应用于其他 Linux 发行版。我也鼓励你研究这份材料，并在适用的情况下进行扩展。
### 1、更新你的服务器
保护服务器安全的第一件事是更新本地存储库，并通过应用最新的修补程序来升级操作系统和已安装的应用程序。
在 Ubuntu 和 Debian 上：
```
$ sudo apt update && sudo apt upgrade -y
```
在 Fedora、CentOS 或 RHEL：
```
$ sudo dnf upgrade
```
### 2、创建一个新的特权用户
接下来，创建一个新的用户帐户。永远不要以 root 身份登录服务器，而是创建你自己的帐户（用户），赋予它 `sudo` 权限，然后使用它登录你的服务器。
首先创建一个新用户：
```
$ adduser <username>
```
通过将 `sudo` 组（`-G`）附加（`-a`）到用户的组成员身份里，从而授予新用户帐户 `sudo` 权限：
```
$ usermod -a -G sudo <username>
```
### 3、上传你的 SSH 密钥
你应该使用 SSH 密钥登录到新服务器。你可以使用 `ssh-copy-id` 命令将[预生成的 SSH 密钥](https://opensource.com/article/19/4/ssh-keys-seahorse)上传到你的新服务器：
```
$ ssh-copy-id <username>@ip_address
```
现在，你无需输入密码即可登录到新服务器。
### 4、安全强化 SSH
接下来，进行以下三个更改：
* 禁用 SSH 密码认证
* 限制 root 远程登录
* 限制对 IPv4 或 IPv6 的访问
使用你选择的文本编辑器打开 `/etc/ssh/sshd_config` 并确保以下行：
```
PasswordAuthentication yes
PermitRootLogin yes
```
改成这样：
```
PasswordAuthentication no
PermitRootLogin no
```
接下来，通过修改 `AddressFamily` 选项将 SSH 服务限制为 IPv4 或 IPv6。要将其更改为仅使用 IPv4（对大多数人来说应该没问题），请进行以下更改：
```
AddressFamily inet
```
重新启动 SSH 服务以启用你的更改。请注意，在重新启动 SSH 服务之前，与服务器建立两个活动连接是一个好主意。有了这些额外的连接，你可以在重新启动 SSH 服务出错的情况下修复所有问题。
在 Ubuntu 上：
```
$ sudo service sshd restart
```
在 Fedora 或 CentOS 或任何使用 Systemd 的系统上：
```
$ sudo systemctl restart sshd
```
### 5、启用防火墙
现在，你需要安装防火墙、启用防火墙并对其进行配置，以仅允许你指定的网络流量通过。（Ubuntu 上的）[简单的防火墙](https://launchpad.net/ufw)（UFW）是一个易用的 iptables 界面，可大大简化防火墙的配置过程。
你可以通过以下方式安装 UFW：
```
$ sudo apt install ufw
```
默认情况下，UFW 拒绝所有传入连接，并允许所有传出连接。这意味着服务器上的任何应用程序都可以访问互联网，但是任何尝试访问服务器的内容都无法连接。
首先，确保你可以通过启用对 SSH、HTTP 和 HTTPS 的访问来登录：
```
$ sudo ufw allow ssh
$ sudo ufw allow http
$ sudo ufw allow https
```
然后启用 UFW：
```
$ sudo ufw enable
```
你可以通过以下方式查看允许和拒绝了哪些服务：
```
$ sudo ufw status
```
如果你想禁用 UFW，可以通过键入以下命令来禁用：
```
$ sudo ufw disable
```
你还可以（在 RHEL/CentOS 上）使用 [firewall-cmd](https://www.redhat.com/sysadmin/secure-linux-network-firewall-cmd)，它已经安装并集成到某些发行版中。
### 6、安装 Fail2ban
[Fail2ban](https://www.fail2ban.org/wiki/index.php/Main_Page) 是一种用于检查服务器日志以查找重复或自动攻击的应用程序。如果找到任何攻击，它会更改防火墙以永久地或在指定的时间内阻止攻击者的 IP 地址。
你可以通过键入以下命令来安装 Fail2ban：
```
$ sudo apt install fail2ban -y
```
然后复制随附的配置文件：
```
$ sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
```
重启 Fail2ban：
```
$ sudo service fail2ban restart
```
这样就行了。该软件将不断检查日志文件以查找攻击。一段时间后，该应用程序将建立相当多的封禁的 IP 地址列表。你可以通过以下方法查询 SSH 服务的当前状态来查看此列表：
```
$ sudo fail2ban-client status ssh
```
### 7、移除无用的网络服务
几乎所有 Linux 服务器操作系统都启用了一些面向网络的服务。你可能希望保留其中大多数，然而，有一些你或许希望删除。你可以使用 `ss` 命令查看所有正在运行的网络服务：（LCTT 译注：应该是只保留少部分，而所有确认无关的、无用的服务都应该停用或删除。）
```
$ sudo ss -atpu
```
`ss` 的输出取决于你的操作系统。下面是一个示例，它显示 SSH（`sshd`）和 Ngnix（`nginx`）服务正在侦听网络并准备连接：
```
tcp LISTEN 0 128 *:http *:* users:(("nginx",pid=22563,fd=7))
tcp LISTEN 0 128 *:ssh *:* users:(("sshd",pid=685,fd=3))
```
删除未使用的服务的方式因你的操作系统及其使用的程序包管理器而异。
要在 Debian / Ubuntu 上删除未使用的服务：
```
$ sudo apt purge <service_name>
```
要在 Red Hat/CentOS 上删除未使用的服务：
```
$ sudo yum remove <service_name>
```
再次运行 `ss -atup` 以确认这些未使用的服务没有安装和运行。
### 总结
本教程介绍了加固 Linux 服务器所需的最起码的措施。你应该根据服务器的使用方式启用其他安全层。这些安全层可以包括诸如各个应用程序配置、入侵检测软件（IDS）以及启用访问控制（例如，双因素身份验证）之类的东西。
---
via: <https://opensource.com/article/19/10/linux-server-security>
作者：[Patrick H. Mullins](https://opensource.com/users/pmullins) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
处理 Linux 文件的 3 个技巧 | Sandra Henry-stocker | https://www.networkworld.com/article/3440035/3-quick-tips-for-working-with-linux-files.html | Linux 提供了许多用于查找、计数和重命名文件的命令。这有一些有用的选择。 | /data/attachment/album/201910/11/101136ei4sslezne7esyis.jpg.thumb.jpg | /data/attachment/album/201910/11/101136ei4sslezne7esyis.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"文件"
] | 技术 | {
"viewnum": 4424,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | Linux 提供了许多用于查找、计数和重命名文件的命令。这有一些有用的选择。 | 2019-10-11T10:11:51 | 2019-10-11T10:11:51 | 11,445 | /article-11445-1.html |
>
> Linux 提供了许多用于查找、计数和重命名文件的命令。这有一些有用的选择。
>
>
>
Linux 提供了多种用于处理文件的命令，这些命令可以节省你的时间，并使你的工作不那么繁琐。
### 查找文件
当你查找文件时，`find` 可能会是第一个想到的命令，但是有时精心设计的 `ls` 命令会更好。想知道你昨天离开办公室回家前调用的脚本么？简单！使用 `ls` 命令并加上 `-ltr` 选项。最后一个列出的将是最近创建或更新的文件。
```
$ ls -ltr ~/bin | tail -3
-rwx------ 1 shs shs 229 Sep 22 19:37 checkCPU
-rwx------ 1 shs shs 285 Sep 22 19:37 ff
-rwxrw-r-- 1 shs shs 1629 Sep 22 19:37 test2
```
像这样的命令将仅列出今天更新的文件：
```
$ ls -al --time-style=+%D | grep `date +%D`
drwxr-xr-x 60 shs shs 69632 09/23/19 .
drwxrwxr-x 2 shs shs 8052736 09/23/19 bin
-rw-rw-r-- 1 shs shs 506 09/23/19 stats
```
如果你要查找的文件可能不在当前目录中，那么 `find` 将比 `ls` 提供更好的选项，但它可能会输出比你想要的更多结果。在下面的命令中，我们*不*搜索以点开头的目录（它们很多一直在更新），指定我们要查找的是文件（即不是目录），并要求仅显示最近一天 （`-mtime -1`）更新过的文件。
```
$ find . -not -path '*/\.*' -type f -mtime -1 -ls
917517 0 -rwxrw-r-- 1 shs shs 683 Sep 23 11:00 ./newscript
```
注意 `-not` 选项反转了 `-path` 的行为，因此我们不会搜索以点开头的子目录。
如果只想查找最大的文件和目录，那么可以使用类似 `du` 这样的命令，它会按大小列出当前目录的内容。将输出通过管道传输到 `tail`，仅查看最大的几个。
```
$ du -kx | egrep -v "\./.+/" | sort -n | tail -5
918984 ./reports
1053980 ./notes
1217932 ./.cache
31470204 ./photos
39771212 .
```
`-k` 选项让 `du` 以块列出文件大小，而 `x` 可防止其遍历其他文件系统上的目录（例如，通过符号链接引用）。事实上，`du` 会先列出文件大小，这样可以按照大小排序（`sort -n`）。
### 文件计数
使用 `find` 命令可以很容易地计数任何特定目录中的文件。你只需要记住，`find` 会递归到子目录中，并将这些子目录中的文件与当前目录中的文件一起计数。在此命令中，我们计数一个特定用户（`username`）的家目录中的文件。根据家目录的权限，这可能需要使用 `sudo`。请记住，第一个参数是搜索的起点。这里指定的是用户的家目录。
```
$ find ~username -type f 2>/dev/null | wc -l
35624
```
请注意，我们正在将上面 `find` 命令的错误输出发送到 `/dev/null`，以避免搜索类似 `~username/.cache` 这类无法搜索并且对它的内容也不感兴趣的文件夹。
必要时，你可以使用 `maxdepth 1` 选项将 `find` 限制在单个目录中：
```
$ find /home/shs -maxdepth 1 -type f | wc -l
387
```
### 重命名文件
使用 `mv` 命令可以很容易地重命名文件，但是有时你会想重命名大量文件，并且不想花费大量时间。例如，要将你在当前目录的文件名中找到的所有空格更改为下划线，你可以使用如下命令：
```
$ rename 's/ /_/g' *
```
如你怀疑的那样，此命令中的 `g` 表示“全局”。这意味着该命令会将文件名中的*所有*空格更改为下划线，而不仅仅是第一个。
要从文本文件中删除 .txt 扩展名，可以使用如下命令：
```
$ rename 's/.txt//g' *
```
### 总结
Linux 命令行提供了许多用于处理文件的有用选择。请提出你认为特别有用的其他命令。
---
via: <https://www.networkworld.com/article/3440035/3-quick-tips-for-working-with-linux-files.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何用 GVM 管理 Go 项目 | Chris Collins | https://opensource.com/article/19/10/introduction-gvm | 使用 Go 版本管理器管理多个版本的 Go 语言环境及其模块。 | /data/attachment/album/201910/11/112215m48u4zocc7p48okn.png.thumb.jpg | /data/attachment/album/201910/11/112215m48u4zocc7p48okn.png | true | false | true | lujun9972 | heguangzhi | wxy | false | [
"Go"
] | 软件开发 | {
"viewnum": 4899,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 使用 Go 版本管理器管理多个版本的 Go 语言环境及其模块。 | 2019-10-11T11:22:41 | 2019-10-11T11:22:41 | 11,447 | /article-11447-1.html |
>
> 使用 Go 版本管理器管理多个版本的 Go 语言环境及其模块。
>
>
>
Go 语言版本管理器（[GVM](https://github.com/moovweb/gvm)）是管理 Go 语言环境的开源工具。GVM “pkgsets” 支持安装多个版本的 Go 并管理每个项目的模块。它最初由 [Josh Bussdieker](https://github.com/jbussdieker) 开发，GVM（像它的对手 Ruby RVM 一样）允许你为每个项目或一组项目创建一个开发环境，分离不同的 Go 版本和包依赖关系，以提供更大的灵活性，防止不同版本造成的问题。
有几种管理 Go 包的方式，包括内置于 Go 中的 Go 1.11 的 Modules。我发现 GVM 简单直观，即使我不用它来管理包，我还是会用它来管理 Go 不同的版本的。
### 安装 GVM
安装 GVM 很简单。[GVM 存储库](https://github.com/moovweb/gvm#installing)安装文档指示你下载安装程序脚本并将其传送到 Bash 来安装:
```
bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
```
尽管越来越多的人采用这种安装方法，但是在安装之前先看看安装程序在做什么仍然是一个很好的想法。以 GVM 为例，该安装程序脚本:
1. 检查一些相关依赖性
2. 克隆 GVM 存储库
3. 使用 shell 脚本：
* 安装 Go 语言
* 管理 `GOPATH` 环境变量
* 向 `bashrc`、`zshrc` 或配置文件中添加一行内容
如果你想确认它在做什么，你可以克隆该存储库并查看 shell 脚本，然后运行 `./binscripts/gvm-installer` 这个本地脚本进行设置。
`注意：` 因为 GVM 可以用来下载和编译新的 Go 版本，所以有一些预期的依赖关系，如 Make、Git 和 Curl。你可以在 [GVM 的自述文件](https://github.com/moovweb/gvm/blob/master/README.md)中找到完整的发行版列表。
### 使用 GVM 安装和管理 GO 版本
一旦安装了 GVM，你就可以使用它来安装和管理不同版本的 Go。`gvm listall` 命令显示可下载和编译的可用版本的 Go：
```
[chris@marvin ]$ gvm listall
gvm gos (available)
go1
go1.0.1
go1.0.2
go1.0.3
<输出截断>
```
安装特定的 Go 版本就像 `gvm install <版本>` 一样简单，其中 `<版本>` 是 `gvm listall` 命令返回的版本之一。
假设你正在进行一个使用 Go1.12.8 版本的项目。你可以使用 `gvm install go1.12.8` 安装这个版本:
```
[chris@marvin]$ gvm install go1.12.8
Installing go1.12.8...
* Compiling...
go1.12.8 successfully installed!
```
输入 `gvm list`，你会看到 Go 版本 1.12.8 与系统 Go 版本（使用操作系统的软件包管理器打包的版本）一起并存：
```
[chris@marvin]$ gvm list
gvm gos (installed)
go1.12.8
=> system
```
GVM 仍在使用系统版本的 Go ，由 `=>` 符号表示。你可以使用 `gvm use` 命令切换你的环境以使用新安装的 go1.12.8：
```
[chris@marvin]$ gvm use go1.12.8
Now using version go1.12.8
[chris@marvin]$ go version
go version go1.12.8 linux/amd64
```
GVM 使管理已安装版本的 Go 变得极其简单，但它不止于此！
### 使用 GVM pkgset
开箱即用，Go 有一种出色而令人沮丧的管理包和模块的方式。默认情况下，如果你 `go get` 获取一个包，它将被下载到 `$GOPATH` 目录中的 `src` 和 `pkg` 目录下，然后可以使用 `import` 将其包含在你的 Go 程序中。这使得获得软件包变得很容易，特别是对于非特权用户，而不需要 `sudo` 或 root 特权（很像 Python 中的 `pip install --user`）。然而，在不同的项目中管理相同包的不同版本是非常困难的。
有许多方法可以尝试修复或缓解这个问题，包括实验性 Go Modules（Go 1.11 版中增加了初步支持）和 [Go dep](https://golang.github.io/dep/)（Go Modules 的“官方实验”并且持续迭代）。在我发现 GVM 之前，我会在一个 Go 项目自己的 Docker 容器中构建和测试它，以确保分离。
GVM 通过使用 “pkgsets” 将项目的新目录附加到安装的 Go 版本的默认 `$GOPATH` 上，很好地实现了项目之间包的管理和隔离，就像 `$PATH` 在 Unix/Linux 系统上工作一样。
想象它如何运行的。首先，安装新版 Go 1.12.9：
```
[chris@marvin]$ echo $GOPATH
/home/chris/.gvm/pkgsets/go1.12.8/global
[chris@marvin]$ gvm install go1.12.9
Installing go1.12.9...
* Compiling...
go1.12.9 successfully installed
[chris@marvin]$ gvm use go1.12.9
Now using version go1.12.9
```
当 GVM 被告知使用新版本时，它会更改为新的 `$GOPATH`，默认 `gloabl` pkgset 应用于该版本:
```
[chris@marvin]$ echo $GOPATH
/home/chris/.gvm/pkgsets/go1.12.9/global
[chris@marvin]$ gvm pkgset list
gvm go package sets (go1.12.9)
=> global
```
尽管默认情况下没有安装额外的包，但是全局 pkgset 中的包对于使用该特定版本的 Go 的任何项目都是可用的。
现在，假设你正在启用一个新项目，它需要一个特定的包。首先，使用 GVM 创建一个新的 pkgset，名为 `introToGvm`:
```
[chris@marvin]$ gvm pkgset create introToGvm
[chris@marvin]$ gvm pkgset use introToGvm
Now using version go1.12.9@introToGvm
[chris@marvin]$ gvm pkgset list
gvm go package sets (go1.12.9)
global
=> introToGvm
```
如上所述，pkgset 的一个新目录被添加到 `$GOPATH`：
```
[chris@marvin]$ echo $GOPATH
/home/chris/.gvm/pkgsets/go1.12.9/introToGvm:/home/chris/.gvm/pkgsets/go1.12.9/global
```
将目录更改为预先设置的 `introToGvm` 路径，检查目录结构，这里使用 `awk` 和 `bash` 完成。
```
[chris@marvin]$ cd $( awk -F':' '{print $1}' <<< $GOPATH )
[chris@marvin]$ pwd
/home/chris/.gvm/pkgsets/go1.12.9/introToGvm
[chris@marvin]$ ls
overlay pkg src
```
请注意，新目录看起来很像普通的 `$GOPATH`。新的 Go 包使用同样的 `go get` 命令下载并正常使用，且添加到 pkgset 中。
例如，使用以下命令获取 `gorilla/mux` 包，然后检查 pkgset 的目录结构：
```
[chris@marvin]$ go get github.com/gorilla/mux
[chris@marvin]$ tree
[chris@marvin introToGvm ]$ tree
.
├── overlay
│ ├── bin
│ └── lib
│ └── pkgconfig
├── pkg
│ └── linux_amd64
│ └── github.com
│ └── gorilla
│ └── mux.a
src/
└── github.com
└── gorilla
└── mux
├── AUTHORS
├── bench_test.go
├── context.go
├── context_test.go
├── doc.go
├── example_authentication_middleware_test.go
├── example_cors_method_middleware_test.go
├── example_route_test.go
├── go.mod
├── LICENSE
├── middleware.go
├── middleware_test.go
├── mux.go
├── mux_test.go
├── old_test.go
├── README.md
├── regexp.go
├── route.go
└── test_helpers.go
```
如你所见，`gorilla/mux` 已按预期添加到 pkgset `$GOPATH` 目录中，现在可用于使用此 pkgset 项目了。
### GVM 让 Go 管理变得轻而易举
GVM 是一种直观且非侵入性的管理 Go 版本和包的方式。它可以单独使用，也可以与其他 Go 模块管理技术结合使用并利用 GVM Go 版本管理功能。按 Go 版本和包依赖来分离项目使得开发更加容易，并且减少了管理版本冲突的复杂性，GVM 让这变得轻而易举。
---
via: <https://opensource.com/article/19/10/introduction-gvm>
作者：[Chris Collins](https://opensource.com/users/clcollins) 选题：[lujun9972](https://github.com/lujun9972) 译者：[heguangzhi](https://github.com/heguangzhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Bash 学习的快乐之旅：3 个命令行游戏 | Seth Kenlon | https://opensource.com/article/19/10/learn-bash-command-line-games | 通过这些命令行游戏，学习有用的 Bash 技能也是一件乐事。 | /data/attachment/album/201910/12/090304jdb7u6yi1p202v61.jpg.thumb.jpg | /data/attachment/album/201910/12/090304jdb7u6yi1p202v61.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Bash",
"游戏"
] | 技术 | {
"viewnum": 5227,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11430,
"displayorder": 0
}
] | 通过这些命令行游戏，学习有用的 Bash 技能也是一件乐事。 | 2019-10-12T09:03:00 | 2019-10-12T09:03:00 | 11,448 | /article-11448-1.html |
>
> 通过这些命令行游戏，学习有用的 Bash 技能也是一件乐事。
>
>
>
学习是件艰苦的工作，然而没有人喜欢工作。这意味着无论学习 Bash 多么容易，它仍然对你来说就像工作一样。当然，除非你通过游戏来学习。
你不会觉得会有很多游戏可以教你如何使用 Bash 终端吧，这是对的。严肃的 PC 游戏玩家知道，《<ruby> 辐射 <rt> Fallout </rt></ruby>》系列在金库中配备了基于终端的计算机，这可以帮你理解通过文本与计算机进行交互是什么样子，但是尽管其功能或多或少地类似于 [Alpine](https://opensource.com/article/17/10/alpine-email-client) 或 [Emacs](http://www.gnu.org/software/emacs)，可是玩《辐射》并不会教给你可以在现实生活中使用的命令或应用程序。《辐射》系列从未直接移植到Linux（尽管可以通过 Steam 的开源的 [Proton](https://github.com/ValveSoftware/Proton/) 来玩。）曾是《辐射》的前身的《<ruby> <a href="https://www.gog.com/game/wasteland_the_classic_original"> 废土 </a> <rt> Wasteland </rt></ruby>》系列的最新作品倒是面向 Linux 的，因此，如果你想体验游戏中的终端，可以在你的 Linux 游戏计算机上玩《[废土 2](https://www.inxile-entertainment.com/wasteland2)》和《[废土 3](https://www.inxile-entertainment.com/wasteland3)》。《<ruby> <a href="http://harebrained-schemes.com/games/"> 暗影狂奔 </a> <rt> Shadowrun </rt></ruby>》系列也有面向 Linux 的版本，它有许多基于终端的交互，尽管公认 [hot sim](https://forums.shadowruntabletop.com/index.php?topic=21804.0) 序列常常使它黯然失色。
虽然这些游戏中采用了有趣的操作计算机终端的方式，并且可以在开源的系统上运行，但它们本身都不是开源的。不过，至少有两个游戏采用了严肃且非常有趣的方法来教人们如何通过文本命令与系统进行交互。最重要的是，它们是开源的。
### Bashcrawl
你可能听说过《<ruby> <a href="https://opensource.com/article/18/12/linux-toy-adventure"> 巨洞探险 </a> <rt> Colossal Cave Adventure </rt></ruby>》游戏，这是一款古老的基于文本的交互式游戏，其风格为“自由冒险”类。早期的计算机爱好者们在 DOS 或 ProDOS 命令行上痴迷地玩这些游戏，他们努力寻找有效语法和（如一个讽刺黑客所解释的）滑稽幻想逻辑的正确组合来击败游戏。想象一下，如果除了探索虚拟的中世纪地下城之外，挑战还在于回忆起有效的 Bash 命令，那么这样的挑战会多么有成效。这就是 [Bashcrawl](https://gitlab.com/slackermedia/bashcrawl) 的基调，这是一个基于 Bash 的地下城探险游戏，你可以通过学习和使用 Bash 命令来玩这个游戏。
在 Bashcrawl 中，“地下城”是以目录和文件的形式创建在你的计算机上的。你可以通过使用 `cd` 命令更改目录进入地下城的每个房间来探索它。当你[穿行目录](https://opensource.com/article/19/8/understanding-file-paths-linux)时，你可以用 [ls -F](https://opensource.com/article/19/7/master-ls-command) 来查看文件，用 [cat](https://opensource.com/article/19/2/getting-started-cat-command) 读取文件，[设置变量](https://opensource.com/article/19/8/using-variables-bash)来收集宝藏，并运行脚本来与怪物战斗。你在游戏中所做的一切操作都是有效的 Bash 命令，你可以稍后在现实生活中使用它，玩这个游戏提供了 Bash 体验，因为这个“游戏”是由计算机上的实际目录和文件组成的。
```
$ cd entrance/
$ ls
cellar scroll
$ cat scroll
It is pitch black in these catacombs.
You have a magical spell that lists all items in a room.
To see in the dark, type: ls
To move around, type: cd <directory>
Try looking around this room.
Then move into one of the next rooms.
EXAMPLE:
$ ls
$ cd cellar
Remember to cast ``ls`` when you get into the next room!
$
```
#### 安装 Bashcrawl
在玩 Bashcrawl 之前，你的系统上必须有 Bash 或 [Zsh](https://opensource.com/article/19/9/getting-started-zsh)。Linux、BSD 和 MacOS 都附带了 Bash。Windows 用户可以下载并安装 [Cygwin](https://www.cygwin.com/) 或 [WSL](https://docs.microsoft.com/en-us/windows/wsl/wsl2-about) 或[试试 Linux](https://opensource.com/article/19/7/ways-get-started-linux)。
要安装 Bashcrawl，请在 Firefox 或你选择的 Web 浏览器中导航到这个 [GitLab 存储库](https://gitlab.com/slackermedia/bashcrawl)。在页面的右侧，单击“下载”图标（位于“Find file”按钮右侧）。在“下载”弹出菜单中，单击“zip”按钮以下载最新版本的游戏。
下载完成后，解压缩该存档文件。
另外，如果你想从终端中开始安装，则可以使用 [Git](https://opensource.com/life/16/7/stumbling-git) 命令：
```
$ git clone https://gitlab.com/slackermedia/bashcrawl.git bashcrawl
```
#### 游戏入门
与你下载的几乎所有新的软件包一样，你必须做的第一件事是阅读 README 文件。你可以通过双击`bashcrawl` 目录中的 `README.md` 文件来阅读。在 Mac 上，你的计算机可能不知道要使用哪个应用程序打开该文件；你也可以使用任何文本编辑器或 LibreOffice 打开它。`README.md` 这个文件会具体告诉你如何开始玩游戏，包括如何在终端上进入游戏以及要开始游戏必须发出的第一条命令。如果你无法阅读 README 文件，那游戏就不战自胜了（尽管由于你没有玩而无法告诉你）。
Bashcrawl 并不意味着是给比较聪明或高级用户玩的。相反，为了对新用户透明，它尽可能地简单。理想情况下，新的 Bash 用户可以从游戏中学习 Bash 的一些基础知识，然后会偶然发现一些游戏机制，包括使游戏运行起来的简单脚本，并学习到更多的 Bash 知识。此外，新的 Bash 用户可以按照 Bashcrawl 现有内容的示例设计自己的地下城，没有比编写游戏更好的学习编码的方法了。
### 命令行英雄：BASH
Bashcrawl 适用于绝对初学者。如果你经常使用 Bash，则很有可能会尝试通过以初学者尚不了解的方式查看 Bashcrawl 的文件，从而找到胜过它的秘径。如果你是中高级的 Bash 用户，则应尝试一下 [命令行英雄：BASH](https://www.redhat.com/en/command-line-heroes/bash/index.html?extIdCarryOver=true&sc_cid=701f2000001OH79AAG)。
这个游戏很简单：在给定的时间内输入尽可能多的有效命令（LCTT 译注：BASH 也有“猛击”的意思）。听起来很简单。作为 Bash 用户，你每天都会使用许多命令。对于 Linux 用户来说，你知道在哪里可以找到命令列表。仅 util-linux 软件包就包含一百多个命令！问题是，在倒计时的压力下，你的指尖是否忙的过来输入这些命令？
这个游戏听起来很简单，它确实也很简单！原则上，它与<ruby> 闪卡 <rt> flashcard </rt></ruby>相似，只是反过来而已。在实践中，这是测试你的知识和回忆的一种有趣方式。当然，它是开源的，是由 [Open Jam](http://openjam.io/) 的开发者开发的。
#### 安装
你可以[在线](https://www.redhat.com/en/command-line-heroes/bash/index.html)玩“命令行英雄：BASH”，或者你也可以从 [GitHub](https://github.com/CommandLineHeroes/clh-bash/) 下载它的源代码。
这个游戏是用 Node.js 编写的，因此除非你想帮助开发该游戏，否则在线进行游戏就够了。
### 在 Bash 中扫雷
如果你是高级 Bash 用户，并且已经编写了多个 Bash 脚本，那么你可能不仅仅想学习 Bash。你可以尝试编写游戏而不是玩游戏，这才是真的挑战。稍加思考，用上一个下午或几个小时，便可以在 Bash 中实现流行的游戏《扫雷》。你可以先尝试自己编写这个游戏，然后参阅 Abhishek Tamrakar 的[文章](/article-11430-1.html)，以了解他如何完成该游戏的。
有时编程没有什么目的而是为了教育。在 Bash 中编写的游戏可能不是可以让你在网上赢得声誉的项目，但是该过程可能会很有趣且很有启发性。面对一个你从未想到的问题，这是学习新技巧的好方法。
### 学习 Bash，玩得开心
不管你如何学习它，Bash 都是一个功能强大的界面，因为它使你能够指示计算机执行所需的操作，而无需通过图形界面的应用程序的“中间人”界面。有时，图形界面很有帮助，但有时你想离开那些已经非常了解的东西，然后转向可以快速或通过自动化来完成的事情。由于 Bash 基于文本，因此易于编写脚本，使其成为自动化作业的理想起点。
了解 Bash 以开始走向高级用户之路，但是请确保你乐在其中。
---
via: <https://opensource.com/article/19/10/learn-bash-command-line-games>
作者：[Seth Kenlon](https://opensource.com/users/seth) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 CentOS 8/RHEL 8 上安装和使用 Cockpit | Pradeep Kumar | https://www.linuxtechi.com/install-use-cockpit-tool-centos8-rhel8/ | Cockpit 是一个有用的基于 Web 的 GUI 工具，系统管理员可以通过该工具监控和管理 Linux 服务器，它还可用于管理服务器、容器、虚拟机中的网络和存储，以及检查系统和应用的日志。 | /data/attachment/album/201910/12/093405gb8hv3exdbsdyfda.jpg.thumb.jpg | /data/attachment/album/201910/12/093405gb8hv3exdbsdyfda.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"Cockpit"
] | 技术 | {
"viewnum": 7596,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "120.204.231.78",
"message": "ss -tunlp | grep cockpit<br />\r\n无返回<br />\r\nps auxf|grep cockpit<br />\r\n返回<br />\r\nroot 2679 0.0 0.0 221900 1088 pts/1 S+ 17:09 0:00 | \\_ grep --color=auto cockpit",
"username": "来自上海的 Chrome 111.0|Windows 10 用户",
"date": "2023-03-23T17:10:58"
}
] | [] | Cockpit 是一个有用的基于 Web 的 GUI 工具，系统管理员可以通过该工具监控和管理 Linux 服务器，它还可用于管理服务器、容器、虚拟机中的网络和存储，以及检查系统和应用的日志。 | 2019-10-12T09:34:27 | 2019-10-12T09:34:27 | 11,449 | /article-11449-1.html | 
Cockpit 是一个基于 Web 的服务器管理工具，可用于 CentOS 和 RHEL 系统。最近发布的 CentOS 8 和 RHEL 8，其中 cockpit 是默认的服务器管理工具。它的软件包在默认的 CentOS 8 和 RHEL 8 仓库中就有。Cockpit 是一个有用的基于 Web 的 GUI 工具，系统管理员可以通过该工具监控和管理 Linux 服务器，它还可用于管理服务器、容器、虚拟机中的网络和存储，以及检查系统和应用的日志。
在本文中，我们将演示如何在 CentOS 8 和 RHEL 8 中安装和设置 Cockpit。
### 在 CentOS 8/RHEL 8 上安装和设置Cockpit
登录你的 CentOS 8/RHEL 8，打开终端并执行以下 `dnf` 命令：
```
[root@linuxtechi ~]# dnf install cockpit -y
```
运行以下命令启用并启动 cockpit 服务：
```
[root@linuxtechi ~]# systemctl start cockpit.socket
[root@linuxtechi ~]# systemctl enable cockpit.socket
```
使用以下命令在系统防火墙中允许 Cockpit 端口：
```
[root@linuxtechi ~]# firewall-cmd --permanent --add-service=cockpit
[root@linuxtechi ~]# firewall-cmd --reload
```
验证 cockpit 服务是否已启动和运行，执行以下命令：
```
[root@linuxtechi ~]# systemctl status cockpit.socket
[root@linuxtechi ~]# ss -tunlp | grep cockpit
[root@linuxtechi ~]# ps auxf|grep cockpit
```
### 在 CentOS 8/RHEL 8 上访问 Cockpit
正如我们在上面命令的输出中看到的，cockpit 正在监听 tcp 9090 端口，打开你的 Web 浏览器并输入 url：`https://<Your-CentOS8/RHEL8-System-IP>:9090`。
RHEL 8 中的 Cockpit 登录页面：
使用有管理员权限的用户名，或者我们也可以使用 root 用户的密码登录。如果要将管理员权限分配给任何本地用户，请执行以下命令：
```
[root@linuxtechi ~]# usermod -G wheel pkumar
```
这里 `pkumar` 是我的本地用户，
在输入用户密码后，选择 “Reuse my password for privileged tasks”，然后单击 “Log In”，然后我们看到以下页面：
在左侧栏上，我们可以看到可以通过 cockpit GUI 监控和配置的内容，
假设你要检查 CentOS 8/RHEL 8 中是否有任何可用更新，请单击 “System Updates”：
要安装所有更新，点击 “Install All Updates”：
如果想要修改网络并要添加 Bond 接口和网桥，请单击 “Networking”：
如上所见，我们有创建 Bond 接口、网桥和 VLAN 标记接口的选项。
假设我们想创建一个 `br0` 网桥，并要为它添加 `enp0s3` 端口，单击 “Add Bridge”：
将网桥名称指定为 `br0`，将端口指定为 `enp0s3`，然后单击“Apply”。
在下个页面，我们将看到该网桥处于活动状态，并且获得了与 enp0s3 接口相同的 IP：
如果你想检查系统日志，单击 “Logs”，我们可以根据严重性查看日志：
本文就是这些了，类似地，系统管理员可以使用 cockpit 的其他功能来监控和管理 CentOS 8 和 RHEL 8 服务器。如果这些步骤可以帮助你在 Linux 服务器上设置 cockpit，请在下面的评论栏分享你的反馈和意见。
---
via: <https://www.linuxtechi.com/install-use-cockpit-tool-centos8-rhel8/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
RPM 包初窥 | Ankur Sinha | https://fedoramagazine.org/rpm-packages-explained/ | 这篇文章总结了这些软件是如何“打包”的，以及使之成为可能的基础工具，如 rpm 之类。 | /data/attachment/album/201910/13/102247leuu032pxggy17gz.jpg.thumb.jpg | /data/attachment/album/201910/13/102247leuu032pxggy17gz.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"RPM"
] | 技术 | {
"viewnum": 6622,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "175.102.15.232",
"message": "现在已经忘记RPM怎么打包了。上学那会儿，还用 openSUSE Build Service 打包呢。",
"username": "绿色圣光 [Firefox 60.0|GNU/Linux]",
"date": "2019-10-21T16:44:58"
}
] | [
{
"raid": 11527,
"displayorder": 0
}
] | 这篇文章总结了这些软件是如何“打包”的，以及使之成为可能的基础工具，如 rpm 之类。 | 2019-10-13T10:22:44 | 2019-10-13T10:22:44 | 11,452 | /article-11452-1.html | 
也许，Fedora 社区追求其[促进自由和开源的软件及内容的使命](https://docs.fedoraproject.org/en-US/project/#_what_is_fedora_all_about)的最著名的方式就是开发 [Fedora 软件发行版](https://getfedora.org)了。因此，我们将很大一部分的社区资源用于此任务也就不足为奇了。这篇文章总结了这些软件是如何“打包”的，以及使之成为可能的基础工具，如 `rpm` 之类。
### RPM：最小的软件单元
可供用户选择的“版本”和“风味版”（[spins](https://spins.fedoraproject.org/) / [labs](https://labs.fedoraproject.org/) / [silverblue](https://silverblue.fedoraproject.org/)）其实非常相似。它们都是由各种软件组成的，这些软件经过混合和搭配，可以很好地协同工作。它们之间的不同之处在于放入其中的具体工具不同。这种选择取决于它们所针对的用例。所有这些的“版本”和“风味版”基本组成单位都是 RPM 软件包文件。
RPM 文件是类似于 ZIP 文件或 tarball 的存档文件。实际上，它们使用了压缩来减小存档文件的大小。但是，除了文件之外，RPM 存档中还包含有关软件包的元数据。可以使用 `rpm` 工具查询：
```
$ rpm -q fpaste
fpaste-0.3.9.2-2.fc30.noarch
$ rpm -qi fpaste
Name : fpaste
Version : 0.3.9.2
Release : 2.fc30
Architecture: noarch
Install Date: Tue 26 Mar 2019 08:49:10 GMT
Group : Unspecified
Size : 64144
License : GPLv3+
Signature : RSA/SHA256, Thu 07 Feb 2019 15:46:11 GMT, Key ID ef3c111fcfc659b9
Source RPM : fpaste-0.3.9.2-2.fc30.src.rpm
Build Date : Thu 31 Jan 2019 20:06:01 GMT
Build Host : buildhw-07.phx2.fedoraproject.org
Relocations : (not relocatable)
Packager : Fedora Project
Vendor : Fedora Project
URL : https://pagure.io/fpaste
Bug URL : https://bugz.fedoraproject.org/fpaste
Summary : A simple tool for pasting info onto sticky notes instances
Description :
It is often useful to be able to easily paste text to the Fedora
Pastebin at http://paste.fedoraproject.org and this simple script
will do that and return the resulting URL so that people may
examine the output. This can hopefully help folks who are for
some reason stuck without X, working remotely, or any other
reason they may be unable to paste something into the pastebin
$ rpm -ql fpaste
/usr/bin/fpaste
/usr/share/doc/fpaste
/usr/share/doc/fpaste/README.rst
/usr/share/doc/fpaste/TODO
/usr/share/licenses/fpaste
/usr/share/licenses/fpaste/COPYING
/usr/share/man/man1/fpaste.1.gz
```
安装 RPM 软件包后，`rpm` 工具可以知道具体哪些文件被添加到了系统中。因此，删除该软件包也会删除这些文件，并使系统保持一致状态。这就是为什么要尽可能地使用 `rpm` 安装软件，而不是从源代码安装软件的原因。
### 依赖关系
如今，完全独立的软件已经非常罕见。甚至 [fpaste](https://src.fedoraproject.org/rpms/fpaste)，连这样一个简单的单个文件的 Python 脚本，都需要安装 Python 解释器。因此，如果系统未安装 Python（几乎不可能，但有可能），则无法使用 `fpaste`。用打包者的术语来说，“Python 是 `fpaste` 的**运行时依赖项**。”
构建 RPM 软件包时（本文不讨论构建 RPM 的过程），生成的归档文件中包括了所有这些元数据。这样，与 RPM 软件包归档文件交互的工具就知道必须要安装其它的什么东西，以便 `fpaste` 可以正常工作：
```
$ rpm -q --requires fpaste
/usr/bin/python3
python3
rpmlib(CompressedFileNames) <= 3.0.4-1
rpmlib(FileDigests) <= 4.6.0-1
rpmlib(PayloadFilesHavePrefix) <= 4.0-1
rpmlib(PayloadIsXz) <= 5.2-1
$ rpm -q --provides fpaste
fpaste = 0.3.9.2-2.fc30
$ rpm -qi python3
Name : python3
Version : 3.7.3
Release : 3.fc30
Architecture: x86_64
Install Date: Thu 16 May 2019 18:51:41 BST
Group : Unspecified
Size : 46139
License : Python
Signature : RSA/SHA256, Sat 11 May 2019 17:02:44 BST, Key ID ef3c111fcfc659b9
Source RPM : python3-3.7.3-3.fc30.src.rpm
Build Date : Sat 11 May 2019 01:47:35 BST
Build Host : buildhw-05.phx2.fedoraproject.org
Relocations : (not relocatable)
Packager : Fedora Project
Vendor : Fedora Project
URL : https://www.python.org/
Bug URL : https://bugz.fedoraproject.org/python3
Summary : Interpreter of the Python programming language
Description :
Python is an accessible, high-level, dynamically typed, interpreted programming
language, designed with an emphasis on code readability.
It includes an extensive standard library, and has a vast ecosystem of
third-party libraries.
The python3 package provides the "python3" executable: the reference
interpreter for the Python language, version 3.
The majority of its standard library is provided in the python3-libs package,
which should be installed automatically along with python3.
The remaining parts of the Python standard library are broken out into the
python3-tkinter and python3-test packages, which may need to be installed
separately.
Documentation for Python is provided in the python3-docs package.
Packages containing additional libraries for Python are generally named with
the "python3-" prefix.
$ rpm -q --provides python3
python(abi) = 3.7
python3 = 3.7.3-3.fc30
python3(x86-64) = 3.7.3-3.fc30
python3.7 = 3.7.3-3.fc30
python37 = 3.7.3-3.fc30
```
### 解决 RPM 依赖关系
虽然 `rpm` 知道每个归档文件所需的依赖关系，但不知道在哪里找到它们。这是设计使然：`rpm` 仅适用于本地文件，必须具体告知它们的位置。因此，如果你尝试安装单个 RPM 软件包，则 `rpm` 找不到该软件包的运行时依赖项时就会出错。本示例尝试安装从 Fedora 软件包集中下载的软件包：
```
$ ls
python3-elephant-0.6.2-3.fc30.noarch.rpm
$ rpm -qpi python3-elephant-0.6.2-3.fc30.noarch.rpm
Name : python3-elephant
Version : 0.6.2
Release : 3.fc30
Architecture: noarch
Install Date: (not installed)
Group : Unspecified
Size : 2574456
License : BSD
Signature : (none)
Source RPM : python-elephant-0.6.2-3.fc30.src.rpm
Build Date : Fri 14 Jun 2019 17:23:48 BST
Build Host : buildhw-02.phx2.fedoraproject.org
Relocations : (not relocatable)
Packager : Fedora Project
Vendor : Fedora Project
URL : http://neuralensemble.org/elephant
Bug URL : https://bugz.fedoraproject.org/python-elephant
Summary : Elephant is a package for analysis of electrophysiology data in Python
Description :
Elephant - Electrophysiology Analysis Toolkit Elephant is a package for the
analysis of neurophysiology data, based on Neo.
$ rpm -qp --requires python3-elephant-0.6.2-3.fc30.noarch.rpm
python(abi) = 3.7
python3.7dist(neo) >= 0.7.1
python3.7dist(numpy) >= 1.8.2
python3.7dist(quantities) >= 0.10.1
python3.7dist(scipy) >= 0.14.0
python3.7dist(six) >= 1.10.0
rpmlib(CompressedFileNames) <= 3.0.4-1
rpmlib(FileDigests) <= 4.6.0-1
rpmlib(PartialHardlinkSets) <= 4.0.4-1
rpmlib(PayloadFilesHavePrefix) <= 4.0-1
rpmlib(PayloadIsXz) <= 5.2-1
$ sudo rpm -i ./python3-elephant-0.6.2-3.fc30.noarch.rpm
error: Failed dependencies:
python3.7dist(neo) >= 0.7.1 is needed by python3-elephant-0.6.2-3.fc30.noarch
python3.7dist(quantities) >= 0.10.1 is needed by python3-elephant-0.6.2-3.fc30.noarch
```
理论上，你可以下载 `python3-elephant` 所需的所有软件包，并告诉 `rpm` 它们都在哪里，但这并不方便。如果 `python3-neo` 和 `python3-quantities` 还有其它的运行时要求怎么办？很快，这种“依赖链”就会变得相当复杂。
#### 存储库
幸运的是，有了 `dnf` 和它的朋友们，可以帮助解决此问题。与 `rpm` 不同，`dnf` 能感知到**存储库**。存储库是程序包的集合，带有告诉 `dnf` 这些存储库包含什么内容的元数据。所有 Fedora 系统都带有默认启用的默认 Fedora 存储库：
```
$ sudo dnf repolist
repo id repo name status
fedora Fedora 30 - x86_64 56,582
fedora-modular Fedora Modular 30 - x86_64 135
updates Fedora 30 - x86_64 - Updates 8,573
updates-modular Fedora Modular 30 - x86_64 - Updates 138
updates-testing Fedora 30 - x86_64 - Test Updates 8,458
```
在 Fedora 快速文档中有[这些存储库](https://docs.fedoraproject.org/en-US/quick-docs/repositories/)以及[如何管理](https://docs.fedoraproject.org/en-US/quick-docs/adding-or-removing-software-repositories-in-fedora/)它们的更多信息。
`dnf` 可用于查询存储库以获取有关它们包含的软件包信息。它还可以在这些存储库中搜索软件，或从中安装/卸载/升级软件包：
```
$ sudo dnf search elephant
Last metadata expiration check: 0:05:21 ago on Sun 23 Jun 2019 14:33:38 BST.
============================================================================== Name & Summary Matched: elephant ==============================================================================
python3-elephant.noarch : Elephant is a package for analysis of electrophysiology data in Python
python3-elephant.noarch : Elephant is a package for analysis of electrophysiology data in Python
$ sudo dnf list \*elephant\*
Last metadata expiration check: 0:05:26 ago on Sun 23 Jun 2019 14:33:38 BST.
Available Packages
python3-elephant.noarch 0.6.2-3.fc30 updates-testing
python3-elephant.noarch 0.6.2-3.fc30 updates
```
#### 安装依赖项
现在使用 `dnf` 安装软件包时，它将*解决*所有必需的依赖项，然后调用 `rpm` 执行该事务操作：
```
$ sudo dnf install python3-elephant
Last metadata expiration check: 0:06:17 ago on Sun 23 Jun 2019 14:33:38 BST.
Dependencies resolved.
==============================================================================================================================================================================================
Package Architecture Version Repository Size
==============================================================================================================================================================================================
Installing:
python3-elephant noarch 0.6.2-3.fc30 updates-testing 456 k
Installing dependencies:
python3-neo noarch 0.8.0-0.1.20190215git49b6041.fc30 fedora 753 k
python3-quantities noarch 0.12.2-4.fc30 fedora 163 k
Installing weak dependencies:
python3-igor noarch 0.3-5.20150408git2c2a79d.fc30 fedora 63 k
Transaction Summary
==============================================================================================================================================================================================
Install 4 Packages
Total download size: 1.4 M
Installed size: 7.0 M
Is this ok [y/N]: y
Downloading Packages:
(1/4): python3-igor-0.3-5.20150408git2c2a79d.fc30.noarch.rpm 222 kB/s | 63 kB 00:00
(2/4): python3-elephant-0.6.2-3.fc30.noarch.rpm 681 kB/s | 456 kB 00:00
(3/4): python3-quantities-0.12.2-4.fc30.noarch.rpm 421 kB/s | 163 kB 00:00
(4/4): python3-neo-0.8.0-0.1.20190215git49b6041.fc30.noarch.rpm 840 kB/s | 753 kB 00:00
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Total 884 kB/s | 1.4 MB 00:01
Running transaction check
Transaction check succeeded.
Running transaction test
Transaction test succeeded.
Running transaction
Preparing : 1/1
Installing : python3-quantities-0.12.2-4.fc30.noarch 1/4
Installing : python3-igor-0.3-5.20150408git2c2a79d.fc30.noarch 2/4
Installing : python3-neo-0.8.0-0.1.20190215git49b6041.fc30.noarch 3/4
Installing : python3-elephant-0.6.2-3.fc30.noarch 4/4
Running scriptlet: python3-elephant-0.6.2-3.fc30.noarch 4/4
Verifying : python3-elephant-0.6.2-3.fc30.noarch 1/4
Verifying : python3-igor-0.3-5.20150408git2c2a79d.fc30.noarch 2/4
Verifying : python3-neo-0.8.0-0.1.20190215git49b6041.fc30.noarch 3/4
Verifying : python3-quantities-0.12.2-4.fc30.noarch 4/4
Installed:
python3-elephant-0.6.2-3.fc30.noarch python3-igor-0.3-5.20150408git2c2a79d.fc30.noarch python3-neo-0.8.0-0.1.20190215git49b6041.fc30.noarch python3-quantities-0.12.2-4.fc30.noarch
Complete!
```
请注意，`dnf` 甚至还安装了`python3-igor`，而它不是 `python3-elephant` 的直接依赖项。
### DnfDragora：DNF 的一个图形界面
尽管技术用户可能会发现 `dnf` 易于使用，但并非所有人都这样认为。[Dnfdragora](https://src.fedoraproject.org/rpms/dnfdragora) 通过为 `dnf` 提供图形化前端来解决此问题。
从上面可以看到，dnfdragora 似乎提供了 `dnf` 的所有主要功能。
Fedora 中还有其他工具也可以管理软件包，GNOME 的“<ruby> 软件 <rt> Software </rt></ruby>”和“<ruby> 发现 <rt> Discover </rt></ruby>”就是其中两个。GNOME “软件”仅专注于图形应用程序。你无法使用这个图形化前端来安装命令行或终端工具，例如 `htop` 或 `weechat`。但是，GNOME “软件”支持安装 `dnf` 所不支持的 [Flatpak](https://fedoramagazine.org/getting-started-flatpak/) 和 Snap 应用程序。它们是针对不同目标受众的不同工具，因此提供了不同的功能。
这篇文章仅触及到了 Fedora 软件的生命周期的冰山一角。本文介绍了什么是 RPM 软件包，以及使用 `rpm` 和 `dnf` 的主要区别。
在以后的文章中，我们将详细介绍：
* 创建这些程序包所需的过程
* 社区如何测试它们以确保它们正确构建
* 社区用来将其给到社区用户的基础设施
---
via: <https://fedoramagazine.org/rpm-packages-explained/>
作者：[Ankur Sinha FranciscoD](https://fedoramagazine.org/author/ankursinha/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
每周开源点评：Java 还有用吗、Linux 桌面以及更多的行业趋势 | Tim Hildred | https://opensource.com/article/19/9/java-relevant-and-more-industry-trends | 开源社区和行业趋势的每周总览。 | /data/attachment/album/201910/13/111738qz4h2tqt44tim43h.png.thumb.jpg | /data/attachment/album/201910/13/111738qz4h2tqt44tim43h.png | true | false | true | lujun9972 | laingke | wxy | false | [
"Java"
] | 观点 | {
"viewnum": 4032,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11400,
"displayorder": 0
}
] | 开源社区和行业趋势的每周总览。 | 2019-10-13T11:17:00 | 2019-10-13T11:17:00 | 11,453 | /article-11453-1.html |
>
> 开源社区和行业趋势的每周总览。
>
>
>
作为我在具有开源开发模型的企业软件公司担任高级产品营销经理的角色的一部分，我为产品营销人员、经理和其他影响者定期发布有关开源社区，市场和行业趋势的定期更新。以下是该更新中我和他们最喜欢的五篇文章。
### 《Java 还有用吗？》
* [文章地址](https://sdtimes.com/java/is-java-still-relevant/)
>
> 负责 Java Enterprise Edition（现为 Jakarta EE）的 Eclipse 基金会执行董事 Mike Milinkovich 也认为 Java 本身将不断发展以支持这些技术。“我认为 Java 将从 JVM 一直到 Java 本身都将发生变化，”Milinkovich 表示，“因此，JVM 中任何有助于将 JVM 与 Docker 容器集成在一起，以及能够更好地在 Kubernetes 中对 Docker 容器进行检测的新特性，都将是一个巨大的帮助。因此，我们将期待 Java SE 朝着这个方向发展。”
>
>
>
**影响**：Jakarta EE 是 Java Enterprise Edition 的完全开源版本，奠定了 Java 未来发展的基础。一些 Java 有用论来自于在用 Java 开发中花费的令人难以置信的成本，以及软件开发人员在用它解决问题方面的多年经验。将其与生态系统中的创新相结合（例如，请参见 [Quarkus](https://github.com/quarkusio/quarkus) 或 GraalVM），答案必须是“是”。
### 《GraalVM：多语言 JVM 的圣杯？》
* [文章地址](https://www.transposit.com/blog/2019.01.02-graalvm-holy/?c=hn)
>
> 虽然大多数关于 GraalVM 的宣传都是围绕着将 JVM 项目编译成原生的程序，但是我们仍可以发现它的 Polyglot API 有很多价值。GraalVM 是一个引人注目的、已经完全可以用来替代 Nashorn 的选择，尽管迁移的路径仍然有一些困难，主要原因是缺乏文档。希望这篇文章能帮助其他人找到离开 Nashorn 通往圣杯之路。
>
>
>
**影响**：对于开放源码项目来说，最好的事情之一就是用户开始对一些新奇的应用程序赞不绝口，即使这些应用程序不是主要用例。“是的，听起来不错，我们甚至没有使用过那个功能（指在 JVM 上运行本地语言）……，（都可以感受得到它的优势，）然而我们使用了它的另一个功能（指 Polyglot API）！”
### 《你可以说我疯了，但 Windows 11 或可以在 Linux 上运行》
* [文章链接](https://www.computerworld.com/article/3438856/call-me-crazy-but-windows-11-could-run-on-linux.html#tk.rss_operatingsystems)
>
> 微软已经做了一些必要的工作。[Windows 的 Linux 子系统](https://blogs.msdn.microsoft.com/wsl/)（WSL）的开发人员一直在致力于将 Linux API 调用映射到 Windows 中，反之亦然。在 WSL 的第一个版本中, 微软将 Windows 本地库、程序以及 Linux 之间的关键点连接起来了。当时，[Carmen Crincoli 发推文称](https://twitter.com/CarmenCrincoli/status/862714516257226752)：“2017 年归根结底还是 Linux 桌面年。只不过这个桌面是 Windows。”Carmen Crincoli 是什么人？微软与存储和独立硬件供应商的合作伙伴经理。
>
>
>
**影响**：[Hieroglyph 项目](https://hieroglyph.asu.edu/2016/04/what-is-the-purpose-of-science-fiction-stories/) 的前提是“一部好的科幻小说都有一个对未来的愿景……是建立在现实主义的基础上的……（而这）引发我们思考自己的选择和互动对创造未来做出贡献的复杂方式。”微软的选择以及与更广泛的开源社区的互动是否可以导致科幻的未来？敬请关注！
### 《Python 正在吞噬世界：一个开发人员的业余项目如何成为地球上最热门的编程语言》
* [文章链接](https://www.techrepublic.com/article/python-is-eating-the-world-how-one-developers-side-project-became-the-hottest-programming-language-on-the-planet/)
>
> 还有一个问题是，监督语言开发的机构“Python 核心开发人员和 Python 指导委员会”的组成是否能更好地反映 2019 年 Python 用户群的多样性。
>
>
> Wijaya 称：“我希望看到在所有不同指标上都有更好的代表，不仅在性别平衡方面，而且在种族和其它所有方面。”
>
>
> “在 PyCon 上，我与来自印度和非洲的 [PyLadies](https://www.pyladies.com/) 成员进行了交谈。他们评论说：‘当我们听说 Python 或 PyLadies 时，我们想到的是北美或加拿大的人，而实际上，世界其它地区的用户群很大。为什么我们看不到更多？’我认为这很有意义。因此，我绝对希望看到这种情况发生，我认为我们都需要尽自己的一份力量。”
>
>
>
**影响**: 在这个动荡的时代，谁不想听到一位仁慈独裁者（指 Python 创始人）把他们项目的统治权移交给最经常使用它的人呢？
*我希望你喜欢这张上周让我印象深刻的列表，并在下周一回来了解更多的开放源码社区、市场和行业趋势。*
---
via: <https://opensource.com/article/19/9/java-relevant-and-more-industry-trends>
作者：[Tim Hildred](https://opensource.com/users/thildred) 选题：[lujun9972](https://github.com/lujun9972) 译者：[laingke](https://github.com/laingke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
生成 Linux 运行时间报告的 Bash 脚本 | Magesh Maruthamuthu | https://www.2daygeek.com/bash-script-generate-linux-system-uptime-reports/ | 出于一些原因，你可能需要每月收集一次 Linux 系统运行时间报告。 | /data/attachment/album/201910/13/114727no80y3hzg3og2rhg.jpg.thumb.jpg | /data/attachment/album/201910/13/114727no80y3hzg3og2rhg.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"运行时间"
] | 技术 | {
"viewnum": 7019,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "218.91.27.19",
"message": "非常详细的教程，请问需要输入邮箱账号密码吗？",
"username": "来自江苏扬州的 Chrome 77.0|Windows 10 用户",
"date": "2019-10-20T21:01:28"
}
] | [] | 出于一些原因，你可能需要每月收集一次 Linux 系统运行时间报告。 | 2019-10-13T11:47:35 | 2019-10-13T11:47:35 | 11,455 | /article-11455-1.html | 
出于一些原因，你可能需要每月收集一次 [Linux 系统运行时间](https://www.2daygeek.com/linux-system-server-uptime-check/)报告。如果是这样，你可以根据需要使用以下 [bash 脚本](https://www.2daygeek.com/category/shell-script/) 之一。
我们为什么要收集这份报告？在一段时间后重启 Linux 服务器是解决某些未解决问题的好方法。（LCTT 译注：本文这些观点值得商榷，很多服务器可以稳定运行几千天，尤其是有了内核热补丁之后，启动并不是必须的。）
建议每 180 天重新启动一次。但时间段也许取决于你公司的政策。如果你已经长时间运行服务器而没有重启。这可能导致服务器上出现一些性能或内存问题，我在许多服务器上都注意到了这一点。
这些脚本一次性提供了所有系统运行报告。
### 什么是 uptime 命令
`uptime` 命令将告诉你系统已经运行了多长时间。它在一行中显示以下信息：当前时间、系统运行了多长时间、当前登录了多少用户以及过去 1、5 和 15 分钟的平均系统负载。
### 什么是 tuptime?
[tuptime](https://www.2daygeek.com/linux-tuptime-check-historical-uptime/) 是用于报告系统的历史和统计运行时间的工具，可在重启之间保存。它类似于 `uptime` 命令，但输出更有趣。
### 1）检查 Linux 系统运行时间的 Bash 脚本
该 bash 脚本将收集所有服务器正常运行时间，并将报告发送到给定的电子邮箱地址。
请替换为你的电子邮箱地址，而不是用我们的，否则你将不会收到邮件。
```
# vi /opt/scripts/system-uptime-script.sh
#!/bin/bash
> /tmp/uptime-report.out
for host in cat /tmp/servers.txt
do
echo -n "$host: "
ssh $host uptime | awk '{print $3,$4}' | sed 's/,//'
done | column -t >> /tmp/uptime-report.out
cat /tmp/uptime-report.out | mail -s "Linux Servers Uptime Report" "[email protected]"
```
给 `system-uptime-script.sh` 设置可执行权限。
```
$ chmod +x /opt/scripts/system-uptime-script.sh
```
最后运行 bash 脚本获取输出。
```
# sh /opt/scripts/system-uptime-script.sh
```
你将收到类似以下的报告。
```
# cat /tmp/uptime-report.out
192.168.1.5: 2 days
192.168.1.6: 15 days
192.168.1.7: 30 days
192.168.1.8: 7 days
192.168.1.9: 67 days
192.168.1.10: 130 days
192.168.1.11: 23 days
```
### 2）检查 Linux 系统是否运行了 30 天以上的 Bash 脚本
此 bash 脚本会收集运行 30 天以上的服务器，并将报告发送到指定的邮箱地址。你可以根据需要更改天数。
```
# vi /opt/scripts/system-uptime-script-1.sh
#!/bin/bash
> /tmp/uptime-report-1.out
for host in cat /tmp/servers.txt
do
echo -n "$host: "
ssh $host uptime | awk '{print $3,$4}' | sed 's/,//'
done | column -t >> /tmp/uptime-report-1.out
cat /tmp/uptime-report-1.out | awk ' $2 >= 30' > /tmp/uptime-report-2.out
cat /tmp/uptime-report-2.out | mail -s "Linux Servers Uptime Report" "[email protected]"
```
给 `system-uptime-script-1.sh` 设置可执行权限。
```
$ chmod +x /opt/scripts/system-uptime-script-1.sh
```
最后添加一条 [cronjob](https://www.2daygeek.com/crontab-cronjob-to-schedule-jobs-in-linux/) 来自动执行。它会在每天早上 7 点运行。
```
# crontab -e
0 7 * * * /bin/bash /opt/scripts/system-uptime-script-1.sh
```
**注意：** 你会在每天早上 7 点会收到一封电子邮件提醒，它是昨天的详情。
你将收到类似下面的报告。
```
# cat /tmp/uptime-report-2.out
192.168.1.7: 30 days
192.168.1.9: 67 days
192.168.1.10: 130 days
```
---
via: <https://www.2daygeek.com/bash-script-generate-linux-system-uptime-reports/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
7 个实用的操作 Bash 历史记录的快捷方式 | Ian Miell | https://opensource.com/article/19/10/bash-history-shortcuts | 这些必不可少的 Bash 快捷键可在命令行上节省时间。 | /data/attachment/album/201910/14/111601gdu73c29o283acs1.jpg.thumb.jpg | /data/attachment/album/201910/14/111601gdu73c29o283acs1.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"Bash",
"历史记录"
] | 技术 | {
"viewnum": 6821,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "223.71.1.114",
"message": "touch !$!-3:$ !! !$.txt 这个命令有什么效果? 运行以后出来<br />\r\ntouch /tmp!-3:$ cd /tmp /tmp.txt",
"username": "来自北京的 Firefox 69.0|Windows 10 用户",
"date": "2019-10-14T14:58:55"
},
{
"postip": "116.19.92.23",
"message": "我感觉应该把【sudo !!】、【!*】、【!$】这三个命令放在一起进行说明，因为这三个命令可以说是最常用的了。<br />\r\n【sudo !!】---重复上一个命令<br />\r\n【!*】---重复上一个命令的全部参数<br />\r\n【!$】--重复上一个命令的最后一个参数<br />\r\n其他命令，太难记得住了，其实也没必要记住与使用。",
"username": "phoenix_wangxd [Chrome 77.0|Mac 10.15]",
"date": "2019-10-16T21:29:28"
}
] | [] | 这些必不可少的 Bash 快捷键可在命令行上节省时间。 | 2019-10-14T11:16:27 | 2019-10-14T11:16:27 | 11,456 | /article-11456-1.html |
>
> 这些必不可少的 Bash 快捷键可在命令行上节省时间。
>
>
>
大多数介绍 Bash 历史记录的指南都详尽地列出了全部可用的快捷方式。这样做的问题是，你会对每个快捷方式都浅尝辄止，然后在尝试了那么多的快捷方式后就搞得目不暇接。而在开始工作时它们就全被丢在脑后，只记住了刚开始使用 Bash 时学到的 [!! 技巧](https://opensource.com/article/18/5/bash-tricks)。这些技巧大多数从未进入记忆当中。
本文概述了我每天实际使用的快捷方式。它基于我的书《[Bash 学习，艰难之旅](https://leanpub.com/learnbashthehardway)》中的某些内容（你可以阅读其中的[样章](https://leanpub.com/learnbashthehardway/read_sample)以了解更多信息）。
当人们看到我使用这些快捷方式时，他们经常问我：“你做了什么！？” 学习它们只需付出很少的精力或智力，但是要真正的学习它们，我建议每周用一天学一个，然后下次再继续学习一个。值得花时间让它们落在你的指尖下，因为从长远来看，节省的时间将很重要。
### 1、最后一个参数：`!$`
如果你仅想从本文中学习一种快捷方式，那就是这个。它会将最后一个命令的最后一个参数替换到你的命令行中。
看看这种情况：
```
$ mv /path/to/wrongfile /some/other/place
mv: cannot stat '/path/to/wrongfile': No such file or directory
```
啊哈，我在命令中写了错误的文件名 “wrongfile”，我应该用正确的文件名 “rightfile” 代替。
你可以重新键入上一个命令，并用 “rightfile” 完全替换 “wrongfile”。但是，你也可以键入：
```
$ mv /path/to/rightfile !$
mv /path/to/rightfile /some/other/place
```
这个命令也可以奏效。
在 Bash 中还有其他方法可以通过快捷方式实现相同的目的，但是重用上一个命令的最后一个参数的这种技巧是我最常使用的。
### 2、第 n 个参数：`!:2`
是不是干过像这样的事情：
```
$ tar -cvf afolder afolder.tar
tar: failed to open
```
像许多其他人一样，我也经常搞错 `tar`（和 `ln`）的参数顺序。
当你搞混了参数，你可以这样：
```
$ !:0 !:1 !:3 !:2
tar -cvf afolder.tar afolder
```
这样就不会出丑了。
上一个命令的各个参数的索引是从零开始的，并且可以用 `!:` 之后跟上该索引数字代表各个参数。
显然，你也可以使用它来重用上一个命令中的特定参数，而不是所有参数。
### 3、全部参数：`!:1-$`
假设我运行了类似这样的命令：
```
$ grep '(ping|pong)' afile
```
参数是正确的。然而，我想在文件中匹配 “ping” 或 “pong”，但我使用的是 `grep` 而不是 `egrep`。
我开始输入 `egrep`，但是我不想重新输入其他参数。因此，我可以使用 `!:1-$` 快捷方式来调取上一个命令的所有参数，从第二个（记住它们的索引从零开始，因此是 `1`）到最后一个（由 `$` 表示）。
```
$ egrep !:1-$
egrep '(ping|pong)' afile
ping
```
你不用必须用 `1-$` 选择全部参数；你也可以选择一个子集，例如 `1-2` 或 `3-9` （如果上一个命令中有那么多参数的话）。
### 4、倒数第 n 行的最后一个参数：`!-2:$`
当我输错之后马上就知道该如何更正我的命令时，上面的快捷键非常有用，但是我经常在原来的命令之后运行别的命令，这意味着上一个命令不再是我所要引用的命令。
例如，还是用之前的 `mv` 例子，如果我通过 `ls` 检查文件夹的内容来纠正我的错误：
```
$ mv /path/to/wrongfile /some/other/place
mv: cannot stat '/path/to/wrongfile': No such file or directory
$ ls /path/to/
rightfile
```
我就不能再使用 `!$` 快捷方式了。
在这些情况下，我可以在 `!` 之后插入 `-n`：（其中 `n` 是要在历史记录中回溯的命令条数），以从较旧的命令取得最后的参数：
```
$ mv /path/to/rightfile !-2:$
mv /path/to/rightfile /some/other/place
```
同样，一旦你学会了它，你可能会惊讶于你需要使用它的频率。
### 5、进入文件夹：`!$:h`
从表面上看，这个看起来不太有用，但我每天要用它几十次。
想象一下，我运行的命令如下所示：
```
$ tar -cvf system.tar /etc/system
tar: /etc/system: Cannot stat: No such file or directory
tar: Error exit delayed from previous errors.
```
我可能要做的第一件事是转到 `/etc` 文件夹，查看其中的内容并找出我做错了什么。
我可以通过以下方法来做到这一点：
```
$ cd !$:h
cd /etc
```
这是说：“获取上一个命令的最后一个参数（`/etc/system`），并删除其最后的文件名部分，仅保留 `/ etc`。”
### 6、当前行：`!#:1`
多年以来，在我最终找到并学会之前，我有时候想知道是否可以在当前行引用一个参数。我多希望我能早早学会这个快捷方式。我经常常使用它制作备份文件：
```
$ cp /path/to/some/file !#:1.bak
cp /path/to/some/file /path/to/some/file.bak
```
但当我学会之后，它很快就被下面的快捷方式替代了……
### 7、搜索并替换：`!!:gs`
这将搜索所引用的命令，并将前两个 `/` 之间的字符替换为后两个 `/` 之间的字符。
假设我想告诉别人我的 `s` 键不起作用，而是输出了 `f`：
```
$ echo my f key doef not work
my f key doef not work
```
然后我意识到这里出现的 `f` 键都是错的。要将所有 `f` 替换为 `s`，我可以输入：
```
$ !!:gs/f /s /
echo my s key does not work
my s key does not work
```
它不只对单个字符起作用。我也可以替换单词或句子：
```
$ !!:gs/does/did/
echo my s key did not work
my s key did not work
```
### 测试一下
为了向你展示如何组合这些快捷方式，你知道这些命令片段将输出什么吗？
```
$ ping !#:0:gs/i/o
$ vi /tmp/!:0.txt
$ ls !$:h
$ cd !-2:$:h
$ touch !$!-3:$ !! !$.txt
$ cat !:1-$
```
### 总结
对于日常的命令行用户，Bash 可以作为快捷方式的优雅来源。虽然有成千上万的技巧要学习，但这些是我经常使用的最喜欢的技巧。
如果你想更深入地了解 Bash 可以教给你的全部知识，请买本我的书，《[Bash 学习，艰难之旅](https://leanpub.com/learnbashthehardway)》，或查看我的在线课程《[精通 Bash shell](https://www.educative.io/courses/master-the-bash-shell)》。
---
本文最初发布在 Ian 的博客 [Zwischenzugs.com](https://zwischenzugs.com/2019/08/25/seven-god-like-bash-history-shortcuts-you-will-actually-use/) 上，并经允许重复发布。
---
via: <https://opensource.com/article/19/10/bash-history-shortcuts>
作者：[Ian Miell](https://opensource.com/users/ianmiell) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
如何在 Centos 8 / RHEL 8 上安装和配置 VNC 服务器 | Pradeep Kumar | https://www.linuxtechi.com/install-configure-vnc-server-centos8-rhel8/ | 在 Centos 8 和 RHEL 8 系统中，默认未安装 VNC 服务器，它需要手动安装。在本文中，我们将通过简单的分步指南，介绍如何在 Centos 8 / RHEL 8 上安装 VNC 服务器。 | /data/attachment/album/201910/14/120057n9t849m3uzswhkg8.jpg.thumb.jpg | /data/attachment/album/201910/14/120057n9t849m3uzswhkg8.jpg | true | false | true | lujun9972 | geekpi | wxy | false | [
"VNC"
] | 技术 | {
"viewnum": 30873,
"commentnum": 24,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "101.86.189.202",
"message": "在执行systemctl start vncserver@:1.service命令之后，提示出错，用systemctl status vncserver@:1.service查看后提示：<br />\r\n● vncserver@:1.service - Remote Desktop VNC Service<br />\r\n Loaded: loaded (/etc/systemd/system/[email protected]; enabled; vendor preset: disabled)<br />\r\n Active: failed (Result: exit-code) since Thu 2020-01-02 10:05:37 CST; 7s ago<br />\r\n Process: 108612 ExecStartPre=/bin/sh -c /usr/bin/vncserver -kill :1 > /dev/null 2>&1 || : (code=exited, status=200/CHDIR)<br />\r\n1月 02 10:05:37 centos8 systemd[1]:",
"username": "来自上海的 Chrome 69.0|Windows 7 用户",
"date": "2020-01-02T10:11:01"
},
{
"postip": "183.197.22.98",
"message": "不要用Root帐户",
"username": "来自河北唐山的 Firefox 68.0|Windows 10 用户",
"date": "2020-02-04T12:55:38"
},
{
"postip": "113.89.97.124",
"message": "vnc连接后黑屏是为什么",
"username": "来自广东深圳的 Chrome 75.0|Windows 10 用户",
"date": "2020-03-08T00:18:40"
},
{
"postip": "223.77.115.93",
"message": "同样是黑屏",
"username": "来自湖北的 Chrome 80.0|Windows 10 用户",
"date": "2020-03-08T23:47:00"
},
{
"postip": "223.77.115.93",
"message": "换个端口试一试。[email protected]",
"username": "来自湖北的 Chrome 80.0|Windows 10 用户",
"date": "2020-03-08T23:47:53"
},
{
"postip": "101.249.30.32",
"message": "黑屏<br />\r\n```<br />\r\n-- Unit vncserver@:1.service has finished shutting down.<br />\r\nMar 17 14:51:45 octave.sh su[14532]: (to vnc_user) root on pts/0<br />\r\nMar 17 14:51:45 octave.sh su[14532]: pam_systemd(su-l:session): Cannot create session: Already running in a session or user slice<br />\r\nMar 17 14:51:45 octave.sh su[14532]: pam_unix(su-l:session): session opened for user vnc_user by root(uid=0)<br />\r\nMar 17 14:52:11 octave.sh polkitd[753]: Registered Authentication Agent for unix-process:14567:1448779 (system bus name :1.2191 [/",
"username": "来自西藏的 Chrome Mobile 58.0|Android 5.1 用户",
"date": "2020-03-17T15:34:15"
},
{
"postip": "101.249.30.32",
"message": "[14532]: pam_systemd(su-l:session): Cannot create session: Already running in a session or user slice<br />\r\nMar 17 14:51:45 octave.sh su[14532]: pam_unix(su-l:session): session opened for user vnc_user by root(uid=0)<br />\r\nMar 17 14:52:11 octave.sh polkitd[753]: Registered Authentication Agent for unix-process:14567:1448779 (system bus name :1.2191 [/usr/bin/pkttyagent --notify-fd 5 --fallback], object path /org/freedesktop/PolicyKit1/AuthenticationAgent, locale zh_CN.UTF-8)<br />\r\nMar 17 14:52:36 octave.sh polkit",
"username": "来自西藏的 Chrome Mobile 58.0|Android 5.1 用户",
"date": "2020-03-17T15:36:56"
},
{
"postip": "101.249.30.32",
"message": "session opened for user vnc_user by root(uid=0)<br />\r\nMar 17 14:52:11 octave.sh polkitd[753]: Registered Authentication Agent for unix-process:14567:1448779 (system bus name :1.2191 [/usr/bin/pkttyagent --notify-fd 5 --fallback], object path /org/freedesktop/PolicyKit1/AuthenticationAgent, locale zh_CN.UTF-8)<br />\r\nMar 17 14:52:36 octave.sh polkit-agent-helper-1[14585]: pam_unix(polkit-1:auth): authentication failure; logname= uid=1000 euid=0 tty= ruser=root rhost= user=root<br />\r\nMar 17 14:52:36 octave.sh polki",
"username": "来自西藏的 Chrome 58.0|GNU/Linux 用户",
"date": "2020-03-17T15:41:06"
},
{
"postip": "101.249.30.32",
"message": "用户下直接运行vncserver :1 -xstartup ~/.vnc/xstartup，可以进到桌面。",
"username": "来自西藏的 Chrome 58.0|GNU/Linux 用户",
"date": "2020-03-17T15:45:53"
},
{
"postip": "182.139.148.248",
"message": "VMware 下安装的 CentOS 8.1，装完后VNC连黑屏？？？",
"username": "来自四川成都的 Chrome 78.0|Windows 10 用户",
"date": "2020-03-31T22:32:49"
},
{
"postip": "113.68.252.151",
"message": "黑屏",
"username": "来自广东广州的 Chrome 80.0|Windows 10 用户",
"date": "2020-04-09T14:05:33"
},
{
"postip": "58.221.177.190",
"message": "普通用户还是黑屏",
"username": "来自江苏南通的 Chrome 81.0|Windows 10 用户",
"date": "2020-05-17T14:24:02"
},
{
"postip": "171.221.225.16",
"message": "VMware下黑屏的，我贡献一下我的配置解决了黑屏，直接服务器安装的，直接用lib的配置也不会黑屏。<br />\r\n<br />\r\n<br />\r\n------------------------------------------------------------------------<br />\r\n<br />\r\n[Unit]<br />\r\nDescription=Remote desktop service (VNC)<br />\r\nAfter=syslog.target network.target<br />\r\n<br />\r\n[Service]<br />\r\nType=forking<br />\r\nUser=root<br />\r\n<br />\r\n# Clean any existing files in /tmp/.X11-unix environment<br />\r\nExecStartPre=/bin/sh -c '/usr/bin/vncserver -kill %i > /dev/null 2>&1 || :'<br />\r\nExecStart=/sbin/runuser -l root -c "/usr/bin/vncserver %i"<br />\r\nPIDFile=/root/.vnc/%H%",
"username": "来自四川成都的 Chrome 78.0|Windows 10 用户",
"date": "2020-08-18T11:12:37"
},
{
"postip": "171.221.225.16",
"message": "PIDFile=/root/.vnc/%H%i.pid<br />\r\nExecStop=/bin/sh -c '/usr/bin/vncserver -kill %i > /dev/null 2>&1 || :'<br />\r\n<br />\r\n[Install]<br />\r\nWantedBy=multi-user.target",
"username": "来自四川成都的 Chrome 78.0|Windows 10 用户",
"date": "2020-08-18T11:13:48"
},
{
"postip": "171.221.225.16",
"message": "另外上面作者的命令顺序反了，折腾半天。应该是先启用，再启动。。。<br />\r\n<br />\r\nsystemctl enable vncserver@:1.service<br />\r\nsystemctl start vncserver@:1.service",
"username": "来自四川成都的 Chrome 78.0|Windows 10 用户",
"date": "2020-08-18T11:16:01"
},
{
"postip": "171.221.225.16",
"message": "by ayurep",
"username": "来自四川成都的 Chrome 78.0|Windows 10 用户",
"date": "2020-08-18T11:16:46"
},
{
"postip": "58.214.36.212",
"message": "你好，我按照你的方法能解决黑屏问题了，但是又遇到了终端打开不了的问题，vnc连接的activities下面点击terminal无效果，但是终端实际在vmware里面被打开了，不知道是怎么回事",
"username": "来自江苏无锡的 Chrome 86.0|Windows 10 用户",
"date": "2020-11-15T11:31:35"
},
{
"postip": "124.160.94.202",
"message": "enable 表示设置开机自启动<br />\r\nstart 表示开启服务<br />\r\n<br />\r\n所以你说的"启用"是错误的...",
"username": "来自浙江宁波的 Firefox 87.0|Windows 10 用户",
"date": "2021-04-19T15:25:46"
},
{
"postip": "211.143.174.133",
"message": "# systemctl status vncserver@:1.service<br />\r\n● vncserver@:1.service - Remote Desktop VNC Service<br />\r\n Loaded: loaded (/etc/systemd/system/[email protected]; enabled; vendor preset: disabled)<br />\r\n Active: inactive (dead) since Thu 2021-05-20 18:51:18 CST; 6s ago<br />\r\n Process: 37048 ExecStop=/usr/bin/vncserver -kill :1 (code=exited, status=0/SUCCESS)<br />\r\n Process: 37046 ExecStart=/usr/bin/vncserver -autokill :1 (code=exited, status=0/SUCCESS)<br />\r\n Process: 37043 ExecStartPre=/bin/sh -c /usr/bin/vncserver -kill :1",
"username": "来自福建龙岩的 Chrome 90.0|Windows 10 用户",
"date": "2021-05-20T18:53:10"
},
{
"postip": "211.143.174.133",
"message": "Process: 37043 ExecStartPre=/bin/sh -c /usr/bin/vncserver -kill :1 > /dev/null 2>&1 || : (code=exited, status=0/SUCCESS)<br />\r\n<br />\r\n5月 20 18:51:18 systemd[1]: Starting Remote Desktop VNC Service...<br />\r\n5月 20 18:51:18 systemd[1]: vncserver@:1.service: Succeeded.<br />\r\n5月 20 18:51:18 systemd[1]: Started Remote Desktop VNC Service.<br />\r\n<br />\r\n服务起不来，不知道什么原因",
"username": "来自福建龙岩的 Chrome 90.0|Windows 10 用户",
"date": "2021-05-20T18:54:15"
},
{
"postip": "211.143.174.133",
"message": "这两条命令顺序无所谓的吧",
"username": "来自福建龙岩的 Chrome 90.0|Windows 10 用户",
"date": "2021-05-20T18:55:08"
},
{
"postip": "61.128.161.154",
"message": "1、这篇文章vnc在写systemd 服务单元配置时原理上有问题，vnc提供提供两种启动机制，一种是直接vncserver <:display> 一种是vncsession user <:display> ，前者是用于用户手动启动，后者用于服务方式启动。<br />\r\n2、vnc安装后已经生成了服务单元模板文件 [email protected] . 路径为：/usr/lib/systemd/system/[email protected] ，可直接使用此文件或者拷贝此文件到 /etc/systemd/system/目录下进行自定义修改<br />\r\n3、man vncsession 可以查看用法和使用文档。",
"username": "来自重庆的 Firefox 97.0|Windows 10 用户",
"date": "2022-02-22T16:48:57"
},
{
"postip": "61.128.161.154",
"message": "此种配置方法，针对普通用户用 systemd user unit 方式倒是推荐使用，但是直接配置成系统服务不建议如此使用。",
"username": "来自重庆的 Firefox 97.0|Windows 10 用户",
"date": "2022-02-22T16:55:57"
},
{
"postip": "222.247.225.137",
"message": "为什么连接成功后无法输入锁屏密码呢？输入密码后自动消失了",
"username": "来自湖南长沙的 Chrome 100.0|Windows 10 用户",
"date": "2022-04-22T21:56:01"
}
] | [] | 在 Centos 8 和 RHEL 8 系统中，默认未安装 VNC 服务器，它需要手动安装。在本文中，我们将通过简单的分步指南，介绍如何在 Centos 8 / RHEL 8 上安装 VNC 服务器。 | 2019-10-14T12:02:00 | 2019-10-14T12:02:00 | 11,458 | /article-11458-1.html | 
VNC（<ruby> 虚拟网络计算 <rt> Virtual Network Computing </rt></ruby>）服务器是基于 GUI 的桌面共享平台，它可让你访问远程桌面计算机。在 Centos 8 和 RHEL 8 系统中，默认未安装 VNC 服务器，它需要手动安装。在本文中，我们将通过简单的分步指南，介绍如何在 Centos 8 / RHEL 8 上安装 VNC 服务器。
### 在 Centos 8 / RHEL 8 上安装 VNC 服务器的先决要求
要在你的系统中安装 VNC 服务器，请确保你的系统满足以下要求：
* CentOS 8 / RHEL 8
* GNOME 桌面环境
* root 用户权限
* DNF / YUM 软件包仓库
### 在 Centos 8 / RHEL 8 上安装 VNC 服务器的分步指导
#### 步骤 1）安装 GNOME 桌面环境
在 CentOS 8 / RHEL 8 中安装 VNC 服务器之前，请确保已安装了桌面环境（DE）。如果已经安装了 GNOME 桌面或安装了 GUI 支持，那么可以跳过此步骤。
在 CentOS 8 / RHEL 8 中，GNOME 是默认的桌面环境。如果你的系统中没有它，请使用以下命令进行安装：
```
[root@linuxtechi ~]# dnf groupinstall "workstation"
或者
[root@linuxtechi ~]# dnf groupinstall "Server with GUI
```
成功安装上面的包后，请运行以下命令启用图形模式：
```
[root@linuxtechi ~]# systemctl set-default graphical
```
现在重启系统，进入 GNOME 登录页面（LCTT 译注：你可以通过切换运行态来进入图形界面）。
```
[root@linuxtechi ~]# reboot
```
重启后，请取消注释 `/etc/gdm/custom.conf` 中的 `WaylandEnable=false`，以使通过 vnc 进行的远程桌面会话请求由 GNOME 桌面的 xorg 处理，来代替 Wayland 显示管理器。
注意： Wayland 是 GNOME 中的默认显示管理器 （GDM），并且未配置用于处理 X.org 等远程渲染的 API。
#### 步骤 2）安装 VNC 服务器（tigervnc-server）
接下来，我们将安装 VNC 服务器，有很多 VNC 服务器可以选择，出于安装目的，我们将安装 `TigerVNC 服务器`。它是最受欢迎的 VNC 服务器之一，并且高性能还独立于平台，它使用户可以轻松地与远程计算机进行交互。
现在，使用以下命令安装 TigerVNC 服务器：
```
[root@linuxtechi ~]# dnf install tigervnc-server tigervnc-server-module -y
```
#### 步骤 3）为本地用户设置 VNC 密码
假设我们希望用户 `pkumar` 使用 VNC 进行远程桌面会话，然后切换到该用户并使用 `vncpasswd` 命令设置其密码，
```
[root@linuxtechi ~]# su - pkumar
[root@linuxtechi ~]$ vncpasswd
Password:
Verify:
Would you like to enter a view-only password (y/n)? n
A view-only password is not used
[root@linuxtechi ~]$
[root@linuxtechi ~]$ exit
logout
[root@linuxtechi ~]#
```
#### 步骤 4）设置 VNC 服务器配置文件
下一步是配置 VNC 服务器配置文件。创建含以下内容的 `/etc/systemd/system/[email protected]`，以便为上面的本地用户 `pkumar` 启动 tigervnc-server 的服务。
```
[root@linuxtechi ~]# vim /etc/systemd/system/[email protected]
[Unit]
Description=Remote Desktop VNC Service
After=syslog.target network.target
[Service]
Type=forking
WorkingDirectory=/home/pkumar
User=pkumar
Group=pkumar
ExecStartPre=/bin/sh -c '/usr/bin/vncserver -kill %i > /dev/null 2>&1 || :'
ExecStart=/usr/bin/vncserver -autokill %i
ExecStop=/usr/bin/vncserver -kill %i
[Install]
WantedBy=multi-user.target
```
保存并退出文件，
注意：替换上面文件中的用户名为你自己的。
默认情况下，VNC 服务器在 tcp 端口 5900+n 上监听，其中 n 是显示端口号，如果显示端口号为 “1”，那么 VNC 服务器将在 TCP 端口 5901 上监听其请求。
#### 步骤 5）启动 VNC 服务并允许防火墙中的端口
我将显示端口号设置为 1，因此请使用以下命令在显示端口号 “1” 上启动并启用 vnc 服务，
```
[root@linuxtechi ~]# systemctl daemon-reload
[root@linuxtechi ~]# systemctl start vncserver@:1.service
[root@linuxtechi ~]# systemctl enable vncserver@:1.service
Created symlink /etc/systemd/system/multi-user.target.wants/vncserver@:1.service → /etc/systemd/system/[email protected].
[root@linuxtechi ~]#
```
使用下面的 `netstat` 或 `ss` 命令来验证 VNC 服务器是否开始监听 5901 上的请求，
```
[root@linuxtechi ~]# netstat -tunlp | grep 5901
tcp 0 0 0.0.0.0:5901 0.0.0.0:* LISTEN 8169/Xvnc
tcp6 0 0 :::5901 :::* LISTEN 8169/Xvnc
[root@linuxtechi ~]# ss -tunlp | grep -i 5901
tcp LISTEN 0 5 0.0.0.0:5901 0.0.0.0:* users:(("Xvnc",pid=8169,fd=6))
tcp LISTEN 0 5 [::]:5901 [::]:* users:(("Xvnc",pid=8169,fd=7))
[root@linuxtechi ~]#
```
使用下面的 `systemctl` 命令验证 VNC 服务器的状态，
```
[root@linuxtechi ~]# systemctl status vncserver@:1.service
```
上面命令的输出确认在 tcp 端口 5901 上成功启动了 VNC。使用以下命令在系统防火墙中允许 VNC 服务器端口 “5901”，
```
[root@linuxtechi ~]# firewall-cmd --permanent --add-port=5901/tcp
success
[root@linuxtechi ~]# firewall-cmd --reload
success
[root@linuxtechi ~]#
```
#### 步骤 6）连接到远程桌面会话
现在，我们已经准备就绪，可以查看远程桌面连接是否正常工作。要访问远程桌面，请在 Windows / Linux 工作站中启动 VNC Viewer，然后输入 VNC 服务器的 IP 地址和端口号，然后按回车。
接下来，它将询问你的 VNC 密码。输入你先前为本地用户创建的密码，然后单击 “OK” 继续。
现在你可以看到远程桌面，
就是这样，你已经在 Centos 8 / RHEL 8 中成功安装了 VNC 服务器。
### 总结
希望这篇在 Centos 8 / RHEL 8 上安装 VNC 服务器的分步指南为你提供了轻松设置 VNC 服务器并访问远程桌面的所有信息。请在下面的评论栏中提供你的意见和建议。下篇文章再见。谢谢再见！！！
---
via: <https://www.linuxtechi.com/install-configure-vnc-server-centos8-rhel8/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Google Analytics 的一些用法介绍 | Ashwin Sathian | https://opensourceforu.com/2019/10/all-that-you-can-do-with-google-analytics-and-more/ | 这篇文章源自这样一个问题：如何对单页应用中的页面访问进行跟踪？ | /data/attachment/album/201910/14/174956mb745lssk2fg4clg.jpg.thumb.jpg | /data/attachment/album/201910/14/174956mb745lssk2fg4clg.jpg | true | false | true | lujun9972 | HankChow | wxy | false | [
"跟踪"
] | 软件开发 | {
"viewnum": 4809,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 这篇文章源自这样一个问题：如何对单页应用中的页面访问进行跟踪？ | 2019-10-14T17:49:51 | 2019-10-14T17:49:51 | 11,460 | /article-11460-1.html | 
Google Analytics （GA）这个最流行的用户活动追踪工具我们或多或少都听说过甚至使用过，但它的用途并不仅仅限于对页面访问的追踪。作为一个既实用又流行的工具，它已经受到了广泛的欢迎，因此我们将要在下文中介绍如何在各种 Angular 和 React 单页应用中使用 Google Analytics。
这篇文章源自这样一个问题：如何对单页应用中的页面访问进行跟踪？
通常来说，有很多的方法可以解决这个问题，在这里我们只讨论其中的一种方法。下面我会使用 Angular 来写出对应的实现，如果你使用的是 React，相关的用法和概念也不会有太大的差别。接下来就开始吧。
### 准备好应用程序
首先需要有一个<ruby> 追踪 ID <rt> tracking ID </rt></ruby>。在开始编写业务代码之前，要先准备好一个追踪 ID，通过这个唯一的标识，Google Analytics 才能识别出某个点击或者某个页面访问是来自于哪一个应用。
按照以下的步骤：
1. 访问 <https://analytics.google.com>；
2. 提交指定信息以完成注册，并确保可用于 Web 应用，因为我们要开发的正是一个 Web 应用；
3. 同意相关的条款，生成一个追踪 ID；
4. 保存好追踪 ID。
追踪 ID 拿到了，就可以开始编写业务代码了。
### 添加 analytics.js 脚本
Google 已经帮我们做好了接入之前需要做的所有事情，接下来就是我们的工作了。不过我们要做的也很简单，只需要把下面这段脚本添加到应用的 `index.html` 里，就可以了：
```
<script>
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
</script>
```
现在我们来看一下 Google Analytics 是如何在应用程序中初始化的。
### 创建追踪器
首先创建一个应用程序的追踪器。在 `app.component.ts` 中执行以下两个步骤：
1. 声明一个名为 `ga`，类型为 `any` 的全局变量（在 Typescript 中需要制定变量类型）；
2. 将下面一行代码加入到 `ngInInit()` 中。
```
ga('create', <你的追踪 ID>, 'auto');
```
这样就已经成功地在应用程序中初始化了一个 Google Analytics 的追踪器了。由于追踪器的初始化是在 `OnInit()` 函数中执行的，因此每当应用程序启动，追踪器就会启动。
### 在单页应用中记录页面访问情况
我们需要实现的是记录<ruby> 访问路由 <rt> route-visits </rt></ruby>。
如何记录用户在一个应用中不同部分的访问，这是一个难点。从功能上来看，单页应用中的路由对应了传统多页面应用中各个页面之间的跳转，因此我们需要记录访问路由。要做到这一点尽管不算简单，但仍然是可以实现的。在 `app.component.ts` 的 `ngOnInit()` 函数中添加以下的代码片段：
```
import { Router, NavigationEnd } from '@angular/router';
...
constructor(public router: Router) {}
...
this.router.events.subscribe(
event => {
if (event instanceof NavigationEnd) {
ga('set', 'page', event.urlAfterRedirects);
ga('send', { hitType: 'pageview', hitCallback: () => { this.pageViewSent = true; }});
}
}
);
```
神奇的是，只需要这么几行代码，就实现了 Angular 应用中记录页面访问情况的功能。
这段代码实际上做了以下几件事情：
1. 从 Angular Router 中导入了 `Router`、`NavigationEnd`；
2. 通过构造函数中将 `Router` 添加到组件中；
3. 然后订阅 `router` 事件，也就是由 Angular Router 发出的所有事件；
4. 只要产生了一个 `NavigationEnd` 事件实例，就将路由和目标作为一个页面访问进行记录。
这样，只要使用到了页面路由，就会向 Google Analytics 发送一条页面访问记录，在 Google Analytics 的在线控制台中可以看到这些记录。
类似地，我们可以用相同的方式来记录除了页面访问之外的活动，例如某个界面的查看次数或者时长等等。只要像上面的代码那样使用 `hitCallBack()` 就可以在有需要收集的数据的时候让应用程序作出反应，这里我们做的事情仅仅是把一个变量的值设为 `true`，但实际上 `hitCallBack()` 中可以执行任何代码。
### 追踪用户交互活动
除了页面访问记录之外，Google Analytics 还经常被用于追踪用户的交互活动，例如某个按钮的点击情况。“提交按钮被用户点击了多少次？”，“产品手册会被经常查阅吗？”这些都是 Web 应用程序的产品评审会议上的常见问题。这一节我们将会介绍如何实现这些数据的统计。
#### 按钮点击
设想这样一种场景，需要统计到应用程序中某个按钮或链接被点击的次数，这是一个和注册之类的关键动作关系最密切的数据指标。下面我们来举一个例子：
假设应用程序中有一个“感兴趣”按钮，用于显示即将推出的活动，你希望通过统计这个按钮被点击的次数来推测有多少用户对此感兴趣。那么我们可以使用以下的代码来实现这个功能：
```
...
params = {
eventCategory:
'Button'
,
eventAction:
'Click'
,
eventLabel:
'Show interest'
,
eventValue:
1
};
showInterest() {
ga('send', 'event', this.params);
}
...
```
现在看下这段代码实际上做了什么。正如前面说到，当我们向 Google Analytics 发送数据的时候，Google Analytics 就会记录下来。因此我们可以向 `send()` 方法传递不同的参数，以区分不同的事件，例如两个不同按钮的点击记录。
1、首先我们定义了一个 `params` 对象，这个对象包含了以下几个字段：
1. `eventCategory` – 交互发生的对象，这里对应的是按钮（button）
2. `eventAction` – 发生的交互的类型，这里对应的是点击（click）
3. `eventLabel` – 交互动作的标识，这里对应的是这个按钮的内容，也就是“感兴趣”
4. `eventValue` – 与每个发生的事件实例相关联的值
由于这个例子中是要统计点击了“感兴趣”按钮的用户数，因此我们把 `eventValue` 的值定为 1。
2、对象构造完成之后，下一步就是将 `params` 对象作为请求负载发送到 Google Analytics，而这一步是通过事件绑定将 `showInterest()` 绑定在按钮上实现的。这也是使用 Google Analytics 追踪中最常用的发送事件方法。
至此，Google Analytics 就可以通过记录按钮的点击次数来统计感兴趣的用户数了。
#### 追踪社交活动
Google Analytics 还可以通过应用程序追踪用户在社交媒体上的互动。其中一种场景就是在应用中放置类似 Facebook 的点赞按钮，下面我们来看看如何使用 Google Analytics 来追踪这一行为。
```
...
fbLikeParams = {
socialNetwork:
'Facebook',
socialAction:
'Like',
socialTarget:
'https://facebook.com/mypage'
};
...
fbLike() {
ga('send', 'social', this.fbLikeParams);
}
```
如果你觉得这段代码似曾相识，那是因为它确实跟上面统计“感兴趣”按钮点击次数的代码非常相似。下面我们继续看其中每一步的内容：
1、构造发送的数据负载，其中包括以下字段：
1. `socialNetwork` – 交互发生的社交媒体，例如 Facebook、Twitter 等等
2. `socialAction` – 发生的交互类型，例如点赞、发表推文、分享等等
3. `socialTarget` – 交互的目标 URL，一般是社交媒体账号的主页
2、下一步是增加一个函数来发送整个交互记录。和统计按钮点击数量时相比，这里使用 `send()` 的方式有所不同。另外，我们还需要把这个函数绑定到已有的点赞按钮上。
在追踪用户交互方面，Google Analytics 还可以做更多的事情，其中最重要的一种是针对异常的追踪，这让我们可以通过 Google Analytics 来追踪应用程序中出现的错误和异常。在本文中我们就不赘述这一点了，但我们鼓励读者自行探索。
### 用户识别
#### 隐私是一项权利，而不是奢侈品
Google Analytics 除了可以记录很多用户的操作和交互活动之外，这一节还将介绍一个不太常见的功能，就是可以控制是否对用户的身份进行追踪。
#### Cookies
Google Analytics 追踪用户活动的方式是基于 Cookies 的，因此我们可以自定义 Cookies 的名称以及一些其它的内容，请看下面这段代码：
```
trackingID =
'UA-139883813-1'
;
cookieParams = {
cookieName: 'myGACookie',
cookieDomain: window.location.hostname,
cookieExpires: 604800
};
...
ngOnInit() {
ga('create', this.trackingID, this.cookieParams);
...
}
```
在上面这段代码中，我们设置了 Google Analytics Cookies 的名称、域以及过期时间，这就让我们能够将不同网站或 Web 应用的 Cookies 区分开来。因此我们需要为我们自己的应用程序的 Google Analytics 追踪器的 Cookies 设置一个自定义的标识1，而不是一个自动生成的随机标识。
#### IP 匿名
在某些场景下，我们可能不需要知道应用程序的流量来自哪里。例如对于一个按钮点击的追踪器，我们只需要关心按钮的点击量，而不需要关心点击者的地理位置。在这种场景下，Google Analytics 允许我们只追踪用户的操作行为，而不获取到用户的 IP 地址。
```
ipParams = {
anonymizeIp: true
};
...
ngOnInit() {
...
ga('set', this.ipParams);
...
}
```
在上面这段代码中，我们将 Google Analytics 追踪器的 `abibymizeIp` 参数设置为 `true`。这样用户的 IP 地址就不会被 Google Analytics 所追踪，这可以让用户知道自己的隐私正在被保护。
#### 不被跟踪
还有些时候用户可能不希望自己的行为受到追踪，而 Google Analytics 也允许这样的需求。因此也存在让用户不被追踪的选项。
```
...
optOut() {
window['ga-disable-UA-139883813-1'] = true;
}
...
```
`optOut()` 是一个自定义函数，它可以禁用页面中的 Google Analytics 追踪，我们可以使用按钮或复选框上得事件绑定来使用这一个功能，这样用户就可以选择是否会被 Google Analytics 追踪。
在本文中，我们讨论了 Google Analytics 集成到单页应用时的难点，并探索出了一种相关的解决方法。我们还了解到了如何在单页应用中追踪页面访问和用户交互，例如按钮点击、社交媒体活动等。
最后，我们还了解到 Google Analytics 为用户提供了保护隐私的功能，尤其是用户的一些隐私数据并不需要参与到统计当中的时候。而用户也可以选择完全不受到 Google Analytics 的追踪。除此以外，Google Analytics 还可以做到很多其它的事情，这就需要我们继续不断探索了。
---
via: <https://opensourceforu.com/2019/10/all-that-you-can-do-with-google-analytics-and-more/>
作者：[Ashwin Sathian](https://opensourceforu.com/author/ashwin-sathian/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[HankChow](https://github.com/HankChow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
区块链 2.0：Hyperledger Fabric 介绍（十） | Sk | https://www.ostechnix.com/blockchain-2-0-introduction-to-hyperledger-fabric/ | Fabric 明确用于封闭和许可区块链。它们的核心目标是开发一套工具，这些工具将帮助区块链开发人员创建定制的解决方案，而不是创建独立的生态系统或产品。 | /data/attachment/album/201910/15/084146enrcnuhzr89r1uuc.png.thumb.jpg | /data/attachment/album/201910/15/084146enrcnuhzr89r1uuc.png | true | false | true | lujun9972 | wxy | wxy | false | [
"Fabric"
] | 区块链 | {
"viewnum": 9852,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11404,
"displayorder": 0
}
] | Fabric 明确用于封闭和许可区块链。它们的核心目标是开发一套工具，这些工具将帮助区块链开发人员创建定制的解决方案，而不是创建独立的生态系统或产品。 | 2019-10-15T08:41:42 | 2019-10-15T08:41:42 | 11,461 | /article-11461-1.html | 
### Hyperledger Fabric
[Hyperledger 项目](https://www.ostechnix.com/blockchain-2-0-an-introduction-to-hyperledger-project-hlp/) 是一个伞形组织，包括许多正在开发的不同模块和系统。在这些子项目中，最受欢迎的是 “Hyperledger Fabric”。这篇博文将探讨一旦区块链系统开始大量使用到主流，将使 Fabric 在不久的将来成为几乎不可或缺的功能。最后，我们还将快速了解开发人员和爱好者们需要了解的有关 Hyperledger Fabric 技术的知识。
### 起源
按照 Hyperledger 项目的常规方式，Fabric 由其核心成员之一 IBM “捐赠”给该组织，而 IBM 以前是该组织的主要开发者。由 IBM 共享的这个技术平台在 Hyperledger 项目中进行了联合开发，来自 100 多个成员公司和机构为之做出了贡献。
目前，Fabric 正处于 LTS 版本的 v1.4，该版本已经发展很长一段时间，并且被视为企业管理业务数据的解决方案。Hyperledger 项目的核心愿景也必然会渗透到 Fabric 中。Hyperledger Fabric 系统继承了所有企业级的可扩展功能，这些功能已深深地刻入到 Hyperledger 组织旗下所有的项目当中。
### Hyperledger Fabric 的亮点
Hyperledger Fabric 提供了多种功能和标准，这些功能和标准围绕着支持快速开发和模块化体系结构的使命而构建。此外，与竞争对手（主要是瑞波和[以太坊](https://www.ostechnix.com/blockchain-2-0-what-is-ethereum/)）相比，Fabric 明确用于封闭和[许可区块链](https://www.ostechnix.com/blockchain-2-0-public-vs-private-blockchain-comparison/)。它们的核心目标是开发一套工具，这些工具将帮助区块链开发人员创建定制的解决方案，而不是创建独立的生态系统或产品。
Hyperledger Fabric 的一些亮点如下：
#### 许可区块链系统
这是一个 Hyperledger Fabric 与其他平台（如以太坊和瑞波）差异很大的地方。默认情况下，Fabric 是一种旨在实现私有许可的区块链的工具。此类区块链不能被所有人访问，并且其中致力于达成共识或验证交易的节点将由中央机构进行选择。这对于某些应用（例如银行和保险）可能很重要，在这些应用中，交易必须由中央机构而不是参与者来验证。
#### 机密和受控的信息流
Fabric 内置了权限系统，该权限系统将视情况限制特定组或某些个人中的信息流。与公有区块链不同，在公有区块链中，任何运行节点的人都可以对存储在区块链中的数据进行复制和选择性访问，而 Fabric 系统的管理员可以选择谁能访问共享的信息，以及访问的方式。与现有竞争产品相比，它还有以更好的安全性标准对存储的数据进行加密的子系统。
#### 即插即用架构
Hyperledger Fabric 具有即插即用类型的体系结构。可以选择实施系统的各个组件，而开发人员看不到用处的系统组件可能会被废弃。Fabric 采取高度模块化和可定制的方式进行开发，而不是一种与其竞争对手采用的“一种方法适应所有需求”的方式。对于希望快速构建精益系统的公司和公司而言，这尤其有吸引力。这与 Fabric 和其它 Hyperledger 组件的互操作性相结合，意味着开发人员和设计人员现在可以使用各种标准化工具，而不必从其他来源提取代码并随后进行集成。它还提供了一种相当可靠的方式来构建健壮的模块化系统。
#### 智能合约和链码
运行在区块链上的分布式应用程序称为[智能合约](https://www.ostechnix.com/blockchain-2-0-explaining-smart-contracts-and-its-types/)。虽然智能合约这个术语或多或少与以太坊平台相关联，但<ruby> 链码 <rt> chaincode </rt></ruby>是 Hyperledger 阵营中为其赋予的名称。链码应用程序除了拥有 DApp 中有的所有优点之外，使 Hyperledger 与众不同的是，该应用程序的代码可以用多种高级编程语言编写。它本身支持 [Go](https://www.ostechnix.com/install-go-language-linux/) 和 JavaScript，并且在与适当的编译器模块集成后还支持许多其它编程语言。尽管这一事实在此时可能并不代表什么，但这意味着，如果可以将现有人才用于正在进行的涉及区块链的项目，从长远来看，这有可能为公司节省数十亿美元的人员培训和管理费用。开发人员可以使用自己喜欢的语言进行编码，从而在 Hyperledger Fabric 上开始构建应用程序，而无需学习或培训平台特定的语言和语法。这提供了 Hyperledger Fabric 当前竞争对手无法提供的灵活性。
### 总结
* Hyperledger Fabric 是一个后端驱动程序平台，是一个主要针对需要区块链或其它分布式账本技术的集成项目。因此，除了次要的脚本功能外，它不提供任何面向用户的服务。（认可以为它更像是一种脚本语言。）
* Hyperledger Fabric 支持针对特定用例构建侧链。如果开发人员希望将一组用户或参与者隔离到应用程序的特定部分或功能，则可以通过侧链来实现。侧链是衍生自主要父代的区块链，但在其初始块之后形成不同的链。产生新链的块将不受新链进一步变化的影响，即使将新信息添加到原始链中，新链也将保持不变。此功能将有助于扩展正在开发的平台，并引入用户特定的和案例特定的处理功能。
* 前面的功能还意味着并非所有用户都会像通常对公有链所期望的那样拥有区块链中所有数据的“精确”副本。参与节点将具有仅与之相关的数据副本。例如，假设有一个类似于印度的 PayTM 的应用程序，该应用程序具有钱包功能以及电子商务功能。但是，并非所有的钱包用户都使用 PayTM 在线购物。在这种情况下，只有活跃的购物者将在 PayTM 电子商务网站上拥有相应的交易链，而钱包用户将仅拥有存储钱包交易的链的副本。这种灵活的数据存储和检索体系结构在扩展时非常重要，因为大量的单链区块链已经显示出会增加处理交易的前置时间。这样可以保持链的精简和分类。
我们将在以后的文章中详细介绍 Hyperledger Project 下的其他模块。
---
via: <https://www.ostechnix.com/blockchain-2-0-introduction-to-hyperledger-fabric/>
作者：[sk](https://www.ostechnix.com/author/sk/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 上以树状查看文件和进程 | Sandra Henry-stocker | https://www.networkworld.com/article/3444589/viewing-files-and-processes-as-trees-on-linux.html | 介绍三个 Linux 命令：ps、pstree 和 tree 以类似树的格式查看文件和进程。 | /data/attachment/album/201910/15/093202rwm5k9pnpntgbtpr.jpg.thumb.jpg | /data/attachment/album/201910/15/093202rwm5k9pnpntgbtpr.jpg | true | false | true | lujun9972 | laingke | wxy | false | [
"树状"
] | 技术 | {
"viewnum": 8568,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [] | [] | 介绍三个 Linux 命令：ps、pstree 和 tree 以类似树的格式查看文件和进程。 | 2019-10-15T09:32:22 | 2019-10-15T09:32:22 | 11,462 | /article-11462-1.html |
>
> 介绍三个 Linux 命令：ps、pstree 和 tree 以类似树的格式查看文件和进程。
>
>
>
[Linux](https://www.networkworld.com/article/3215226/what-is-linux-uses-featres-products-operating-systems.html) 提供了一些方便的命令，用于以树状分支形式查看文件和进程，从而易于查看它们之间的关系。在本文中，我们将介绍 `ps`、`pstree` 和 `tree` 命令以及它们提供的一些选项，这些选项可帮助你将注意力集中在要查看的内容上。
### ps
我们用来列出进程的 `ps` 命令有一些有趣的选项，但是很多人从来没有利用过。虽然常用的 `ps -ef` 提供了正在运行的进程的完整列表，但是 `ps -ejH` 命令增加了一个不错的效果。它缩进了相关的进程以使这些进程之间的关系在视觉上更加清晰——就像这个片段：
```
$ ps -ejH
PID PGID SID TTY TIME CMD
...
1396 1396 1396 ? 00:00:00 sshd
28281 28281 28281 ? 00:00:00 sshd
28409 28281 28281 ? 00:00:00 sshd
28410 28410 28410 pts/0 00:00:00 bash
30968 30968 28410 pts/0 00:00:00 ps
```
可以看到，正在运行的 `ps` 进程是在 `bash` 中运行的，而 `bash` 是在 ssh 会话中运行的。
`-exjf` 选项字符串提供了类似的视图，但是带有一些其它细节和符号以突出显示进程的层次结构性质：
```
$ ps -exjf
PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
...
1 1396 1396 1396 ? -1 Ss 0 0:00 /usr/sbin/sshd -D
1396 28281 28281 28281 ? -1 Ss 0 0:00 \_ sshd: shs [priv]
28281 28409 28281 28281 ? -1 S 1000 0:00 \_ sshd: shs@pts/0
28409 28410 28410 28410 pts/0 31028 Ss 1000 0:00 \_ -bash
28410 31028 31028 28410 pts/0 31028 R+ 1000 0:00 \_ ps axjf
```
命令中使用的这些选项表示：
```
-e 选择所有进程
-j 使用工作格式
-f 提供完整格式列表
-H 分层显示进程（如，树状格式）
-x 取消“必须与 tty 相关联”的限制
```
同时，该命令也有一个 `--forest` 选项提供了类似的视图。
```
$ ps -ef --forest
UID PID PPID C STIME TTY TIME CMD
...
root 1396 1 0 Oct08 ? 00:00:00 /usr/sbin/sshd -D
root 28281 1396 0 12:55 ? 00:00:00 \_ sshd: shs [priv]
shs 28409 28281 0 12:56 ? 00:00:00 \_ sshd: shs@pts/0
shs 28410 28409 0 12:56 pts/0 00:00:00 \_ -bash
shs 32351 28410 0 14:39 pts/0 00:00:00 \_ ps -ef --forest
```
注意，这些示例只是这些命令如何使用的示例。你可以选择最适合你的进程视图的任何选项组合。
### pstree
使用 `pstree` 命令可以获得类似的进程视图。尽管 `pstree` 具备了许多选项，但是该命令本身就提供了非常有用的显示。注意，许多父子进程关系显示在单行而不是后续行上。
```
$ pstree
...
├─sshd───sshd───sshd───bash───pstree
├─systemd─┬─(sd-pam)
│ ├─at-spi-bus-laun─┬─dbus-daemon
│ │ └─3*[{at-spi-bus-laun}]
│ ├─at-spi2-registr───2*[{at-spi2-registr}]
│ ├─dbus-daemon
│ ├─ibus-portal───2*[{ibus-portal}]
│ ├─pulseaudio───2*[{pulseaudio}]
│ └─xdg-permission-───2*[{xdg-permission-}]
```
通过 `-n` 选项，`pstree` 以数值（按进程 ID）顺序显示进程：
```
$ pstree -n
systemd─┬─systemd-journal
├─systemd-udevd
├─systemd-timesyn───{systemd-timesyn}
├─systemd-resolve
├─systemd-logind
├─dbus-daemon
├─atopacctd
├─irqbalance───{irqbalance}
├─accounts-daemon───2*[{accounts-daemon}]
├─acpid
├─rsyslogd───3*[{rsyslogd}]
├─freshclam
├─udisksd───4*[{udisksd}]
├─networkd-dispat
├─ModemManager───2*[{ModemManager}]
├─snapd───10*[{snapd}]
├─avahi-daemon───avahi-daemon
├─NetworkManager───2*[{NetworkManager}]
├─wpa_supplicant
├─cron
├─atd
├─polkitd───2*[{polkitd}]
├─colord───2*[{colord}]
├─unattended-upgr───{unattended-upgr}
├─sshd───sshd───sshd───bash───pstree
```
使用 `pstree` 时可以考虑的一些选项包括 `-a`（包括命令行参数）和 `-g`（包括进程组）。
以下是一些简单的示例（片段）。
命令 `pstree -a` 的输出内容：
```
└─wpa_supplicant -u -s -O /run/wpa_supplicant
```
命令 `pstree -g` 的输出内容：
```
├─sshd(1396)───sshd(28281)───sshd(28281)───bash(28410)───pstree(1115)
```
### tree
虽然 `tree` 命令听起来与 `pstree` 非常相似，但这是用于查看文件而非进程的命令。它提供了一个漂亮的树状目录和文件视图。
如果你使用 `tree` 命令查看 `/proc` 目录，你显示的开头部分将类似于这个：
```
$ tree /proc
/proc
├── 1
│ ├── attr
│ │ ├── apparmor
│ │ │ ├── current
│ │ │ ├── exec
│ │ │ └── prev
│ │ ├── current
│ │ ├── display
│ │ ├── exec
│ │ ├── fscreate
│ │ ├── keycreate
│ │ ├── prev
│ │ ├── smack
│ │ │ └── current
│ │ └── sockcreate
│ ├── autogroup
│ ├── auxv
│ ├── cgroup
│ ├── clear_refs
│ ├── cmdline
...
```
如果以 root 权限运行这条命令（`sudo tree /proc`），你将会看到更多详细信息，因为 `/proc` 目录的许多内容对于普通用户而言是无法访问的。
命令 `tree -d` 将会限制仅显示目录。
```
$ tree -d /proc
/proc
├── 1
│ ├── attr
│ │ ├── apparmor
│ │ └── smack
│ ├── fd [error opening dir]
│ ├── fdinfo [error opening dir]
│ ├── map_files [error opening dir]
│ ├── net
│ │ ├── dev_snmp6
│ │ ├── netfilter
│ │ └── stat
│ ├── ns [error opening dir]
│ └── task
│ └── 1
│ ├── attr
│ │ ├── apparmor
│ │ └── smack
...
```
使用 `-f` 选项，`tree` 命令会显示完整的路径。
```
$ tree -f /proc
/proc
├── /proc/1
│ ├── /proc/1/attr
│ │ ├── /proc/1/attr/apparmor
│ │ │ ├── /proc/1/attr/apparmor/current
│ │ │ ├── /proc/1/attr/apparmor/exec
│ │ │ └── /proc/1/attr/apparmor/prev
│ │ ├── /proc/1/attr/current
│ │ ├── /proc/1/attr/display
│ │ ├── /proc/1/attr/exec
│ │ ├── /proc/1/attr/fscreate
│ │ ├── /proc/1/attr/keycreate
│ │ ├── /proc/1/attr/prev
│ │ ├── /proc/1/attr/smack
│ │ │ └── /proc/1/attr/smack/current
│ │ └── /proc/1/attr/sockcreate
...
```
分层显示通常可以使进程和文件之间的关系更容易理解。可用选项的数量很多，而你总可以找到一些视图，帮助你查看所需的内容。
---
via: <https://www.networkworld.com/article/3444589/viewing-files-and-processes-as-trees-on-linux.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[laingke](https://github.com/laingke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Linux 内核测试的生命周期 | Major Hayden | https://opensource.com/article/19/8/linux-kernel-testing | 内核持续集成（CKI）项目旨在防止错误进入 Linux 内核。 | /data/attachment/album/201910/16/101933nexzccpea9sjxcq9.jpg.thumb.jpg | /data/attachment/album/201910/16/101933nexzccpea9sjxcq9.jpg | true | false | true | lujun9972 | wxy | wxy | false | [
"内核"
] | 软件开发 | {
"viewnum": 2839,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11176,
"displayorder": 0
},
{
"raid": 11427,
"displayorder": 1
}
] | 内核持续集成（CKI）项目旨在防止错误进入 Linux 内核。 | 2019-10-16T10:19:43 | 2019-10-16T10:19:43 | 11,464 | /article-11464-1.html |
>
> 内核持续集成（CKI）项目旨在防止错误进入 Linux 内核。
>
>
>
在 [Linux 内核的持续集成测试](https://opensource.com/article/19/6/continuous-kernel-integration-linux) 一文中，我介绍了 <ruby> <a href="https://cki-project.org/"> 内核持续集成 </a> <rt> Continuous Kernel Integration </rt></ruby>（CKI）项目及其使命：改变内核开发人员和维护人员的工作方式。本文深入探讨了该项目的某些技术方面，以及这所有的部分是如何组合在一起的。
### 从一次更改开始
内核中每一项令人兴奋的功能、改进和错误都始于开发人员提出的更改。这些更改出现在各个内核存储库的大量邮件列表中。一些存储库关注内核中的某些子系统，例如存储或网络，而其它存储库关注内核的更多方面。 当开发人员向内核提出更改或补丁集时，或者维护者在存储库本身中进行更改时，CKI 项目就会付诸行动。
CKI 项目维护的触发器用于监视这些补丁集并采取措施。诸如 [Patchwork](https://github.com/getpatchwork/patchwork) 之类的软件项目通过将多个补丁贡献整合为单个补丁系列，使此过程变得更加容易。补丁系列作为一个整体历经 CKI 系统，并可以针对该系列发布单个报告。
其他触发器可以监视存储库中的更改。当内核维护人员合并补丁集、还原补丁或创建新标签时，就会触发。测试这些关键的更改可确保开发人员始终具有坚实的基线，可以用作编写新补丁的基础。
所有这些更改都会进入 GitLab CI 管道，并历经多个阶段和多个系统。
### 准备构建
首先要准备好要编译的源代码。这需要克隆存储库、打上开发人员建议的补丁集，并生成内核配置文件。这些配置文件具有成千上万个用于打开或关闭功能的选项，并且配置文件在不同的系统体系结构之间差异非常大。 例如，一个相当标准的 x86\_64 系统在其配置文件中可能有很多可用选项，但是 s390x 系统（IBM zSeries 大型机）的选项可能要少得多。在该大型机上，某些选项可能有意义，但在消费类笔记本电脑上没有任何作用。
内核进一步转换为源代码工件。该工件包含整个存储库（已打上补丁）以及编译所需的所有内核配置文件。 上游内核会打包成压缩包，而 Red Hat 的内核会生成下一步所用的源代码 RPM 包。
### 成堆的编译
编译内核会将源代码转换为计算机可以启动和使用的代码。配置文件描述了要构建的内容，内核中的脚本描述了如何构建它，系统上的工具（例如 GCC 和 glibc）完成构建。此过程需要一段时间才能完成，但是 CKI 项目需要针对四种体系结构快速完成：aarch64（64 位 ARM）、ppc64le（POWER）、s390x（IBM zSeries）和 x86\_64。重要的是，我们必须快速编译内核，以便使工作任务不会积压，而开发人员可以及时收到反馈。
添加更多的 CPU 可以大大提高速度，但是每个系统都有其局限性。CKI 项目在 OpenShift 的部署环境中的容器内编译内核；尽管 OpenShift 可以实现高伸缩性，但在部署环境中的可用 CPU 仍然是数量有限的。CKI 团队分配了 20 个虚拟 CPU 来编译每个内核。涉及到四个体系结构，这就涨到了 80 个 CPU！
另一个速度的提高来自 [ccache](https://ccache.dev/) 工具。内核开发进展迅速，但是即使在多个发布版本之间，内核的大部分仍保持不变。ccache 工具进行编译期间会在磁盘上缓存已构建的对象（整个内核的一小部分）。稍后再进行另一个内核编译时，ccache 会查找以前看到的内核的未更改部分。ccache 会从磁盘中提取缓存的对象并重新使用它。这样可以加快编译速度并降低总体 CPU 使用率。现在，耗时 20 分钟编译的内核在不到几分钟的时间内就完成了。
### 测试时间
内核进入最后一步：在真实硬件上进行测试。每个内核都使用 Beaker 在其原生体系结构上启动，并且开始无数次的测试以发现问题。一些测试会寻找简单的问题，例如容器问题或启动时的错误消息。其他测试则深入到各种内核子系统中，以查找系统调用、内存分配和线程中的回归问题。
大型测试框架，例如 [Linux Test Project](https://linux-test-project.github.io)（LTP），包含了大量测试，这些测试在内核中寻找麻烦的回归问题。其中一些回归问题可能会回滚关键的安全修复程序，并且进行测试以确保这些改进仍保留在内核中。
测试完成后，关键的一步仍然是：报告。内核开发人员和维护人员需要一份简明的报告，准确地告诉他们哪些有效、哪些无效以及如何获取更多信息。每个 CKI 报告都包含所用源代码、编译参数和测试输出的详细信息。该信息可帮助开发人员知道从哪里开始寻找解决问题的方法。此外，它还可以帮助维护人员在漏洞进入内核存储库之前知道何时需要保留补丁集以进行其他查看。
### 总结
CKI 项目团队通过向内核开发人员和维护人员提供及时、自动的反馈，努力防止错误进入 Linux 内核。这项工作通过发现导致内核错误、安全性问题和性能问题等易于找到的问题，使他们的工作更加轻松。
---
via: <https://opensource.com/article/19/8/linux-kernel-testing>
作者：[Major Hayden](https://opensource.com/users/mhaydenhttps://opensource.com/users/mhaydenhttps://opensource.com/users/marcobravohttps://opensource.com/users/mhayden) 选题：[lujun9972](https://github.com/lujun9972) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
在 Linux 上安装 VMware 工具 | Ankush Das | https://itsfoss.com/install-vmware-tools-linux | VMware 工具通过允许你共享剪贴板和文件夹以及其他东西来提升你的虚拟机体验。 | /data/attachment/album/201910/16/120700ery85c55lcr5x28y.png.thumb.jpg | /data/attachment/album/201910/16/120700ery85c55lcr5x28y.png | true | false | true | lujun9972 | tomjlw | wxy | false | [
"VMware"
] | 技术 | {
"viewnum": 34996,
"commentnum": 5,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
} | [
{
"postip": "123.189.103.136",
"message": "“Windows 和 Ubuntu 不支持 Esay Install”？？？胡说！英文原文说的是支持，怎么翻译成不支持了？",
"username": "愉欣 [Chrome 77.0|GNU/Linux]",
"date": "2019-10-16T17:56:29"
},
{
"postip": "101.224.73.173",
"message": "大哥，拼错了是easy，不是esay",
"username": "来自上海的 Chrome 77.0|Mac 10.15 用户",
"date": "2019-10-17T09:41:30"
},
{
"postip": "61.186.19.28",
"message": "谢谢弄错了。does 看成 dont 了。。。",
"username": "linux [Chrome 77.0|Mac 10.14]",
"date": "2019-10-17T11:57:17"
},
{
"postip": "175.174.113.120",
"message": "我记得我是复制粘贴的。",
"username": "愉欣 [Chrome 78.0|GNU/Linux]",
"date": "2019-10-25T11:28:26"
},
{
"postip": "113.116.60.173",
"message": "非foss警告!",
"username": "来自广东深圳的 Firefox 74.0|Ubuntu 用户",
"date": "2020-04-06T17:26:02"
}
] | [] | VMware 工具通过允许你共享剪贴板和文件夹以及其他东西来提升你的虚拟机体验。 | 2019-10-16T12:06:00 | 2019-10-16T12:06:00 | 11,467 | /article-11467-1.html |
>
> VMware 工具通过允许你共享剪贴板和文件夹以及其他东西来提升你的虚拟机体验。了解如何在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具。
>
>
>
在先前的教程中，你学习了[在 Ubuntu 上安装 VMware 工作站](https://itsfoss.com/install-vmware-player-ubuntu-1310/)。你还可以通过安装 VMware 工具进一步提升你的虚拟机功能。
如果你已经在 VMware 上安装了一个访客机系统，你必须要注意 [VMware 工具](https://kb.vmware.com/s/article/340)的要求 —— 尽管并不完全清楚到底有什么要求。
在本文中，我们将要强调 VMware 工具的重要性、所提供的特性，以及在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具的方法。
### VMware 工具：概览及特性
出于显而易见的理由，虚拟机（你的访客机系统）并不能做到与宿主机上的表现完全一致。在其性能和操作上会有特定的限制。那就是为什么引入 VMware 工具的原因。
VMware 工具以一种高效的形式在提升了其性能的同时，也可以帮助管理访客机系统。
#### VMware 工具到底负责什么？
你大致知道它可以做什么，但让我们探讨一下细节：
* 同步访客机系统与宿主机系统间的时间以简化操作
* 提供从宿主机系统向访客机系统传递消息的能力。比如说，你可以复制文字到剪贴板，并将它轻松粘贴到你的访客机系统
* 在访客机系统上启用声音
* 提升访客机视频分辨率
* 修正错误的网络速度数据
* 减少不合适的色深
在访客机系统上安装了 VMware 工具会给它带来显著改变，但是它到底包含了什么特性才解锁或提升这些功能的呢？让我们来看看……
#### VMware 工具：核心特性细节
如果你不想知道它包含什么来启用这些功能的话，你可以跳过这部分。但是为了好奇的读者，让我们简短地讨论它一下：
**VMware 设备驱动：** 它具体取决于操作系统。大多数主流操作系统都默认包含了设备驱动，因此你不必另外安装它。这主要涉及到内存控制驱动、鼠标驱动、音频驱动、网卡驱动、VGA 驱动以及其它。
**VMware 用户进程：** 这是这里真正有意思的地方。通过它你获得了在访客机和宿主机间复制粘贴和拖拽的能力。基本上，你可以从宿主机复制粘贴文本到虚拟机，反之亦然。
你同样也可以拖拽文件。此外，在你未安装 SVGA 驱动时它会启用鼠标指针的释放/锁定。
**VMware 工具生命周期管理：** 嗯，我们会在下面看看如何安装 VMware 工具，但是这个特性帮你在虚拟机中轻松安装/升级 VMware 工具。
**共享文件夹**：除了这些。VMware 工具同样允许你在访客机与宿主机系统间共享文件夹。
当然，它的效果同样取决于访客机系统。例如在 Windows 上你通过 Unity 模式运行虚拟机上的程序并从宿主机系统上操作它。
### 如何在 Ubuntu 和其它 Linux 发行版上安装 VMware 工具
**注意：** 对于 Linux 操作系统，你应该已经安装好了“Open VM 工具”，大多数情况下免除了额外安装 VMware 工具的需要。
大部分时候，当你安装了访客机系统时，如果操作系统支持 [Easy Install](https://docs.vmware.com/en/VMware-Workstation-Player-for-Linux/15.0/com.vmware.player.linux.using.doc/GUID-3F6B9D0E-6CFC-4627-B80B-9A68A5960F60.html) 的话你会收到软件更新或弹窗告诉你要安装 VMware 工具。
Windows 和 Ubuntu 都支持 Easy Install。因此如果你使用 Windows 作为你的宿主机或尝试在 Ubuntu 上安装 VMware 工具，你应该会看到一个和弹窗消息差不多的选项来轻松安装 VMware 工具。这是它应该看起来的样子：
这是搞定它最简便的办法。因此当你配置虚拟机时确保你有一个通畅的网络连接。
如果你没收到任何弹窗或者选项来轻松安装 VMware 工具。你需要手动安装它。以下是如何去做：
1. 运行 VMware Workstation Player。
2. 从菜单导航至 “Virtual Machine -> Install VMware tools”。如果你已经安装了它并想修复安装，你会看到 “Re-install VMware tools” 这一选项出现。
3. 一旦你点击了，你就会看到一个虚拟 CD/DVD 挂载在访客机系统上。
4. 打开该 CD/DVD，并复制粘贴那个 tar.gz 文件到任何你选择的区域并解压，这里我们选择“桌面”作为解压目的地。
5. 在解压后，运行终端并通过输入以下命令导航至里面的文件夹：
```
cd Desktop/VMwareTools-10.3.2-9925305/vmware-tools-distrib
```
你需要检查文件夹与路径名，这取决于版本与解压目的地，名字可能会改变。
用你的存储位置（如“下载”）替换“桌面”，如果你安装的也是 10.3.2 版本，其它的保持一样即可。
6. 现在仅需输入以下命令开始安装：
```
sudo ./vmware-install.pl -d
```
你会被询问密码以获得安装权限，输入密码然后应当一切都搞定了。
到此为止了，你搞定了。这系列步骤应当适用于几乎大部分基于 Ubuntu 的访客机系统。如果你想要在 Ubuntu 服务器上或其它系统安装 VMware 工具，步骤应该类似。
### 总结
在 Ubuntu Linux 上安装 VMware 工具应该挺简单。除了简单办法，我们也详述了手动安装的方法。如果你仍需帮助或者对安装有任何建议，在评论区评论让我们知道。
---
via: <https://itsfoss.com/install-vmware-tools-linux>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[tomjlw](https://github.com/tomjlw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
变异测试是测试驱动开发（TDD）的演变 | Alex Bunardzic | https://opensource.com/article/19/8/mutation-testing-evolution-tdd | 测试驱动开发技术是根据大自然的运作规律创建的，变异测试自然成为 DevOps 演变的下一步。 | /data/attachment/album/201910/17/094428dhrrjgbm2pmhpj4j.jpg.thumb.jpg | /data/attachment/album/201910/17/094428dhrrjgbm2pmhpj4j.jpg | true | false | true | lujun9972 | Morisun029 | wxy | false | [
"TDD",
"DevOps"
] | 观点 | {
"viewnum": 5096,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [
{
"raid": 11483,
"displayorder": 0
}
] | 测试驱动开发技术是根据大自然的运作规律创建的，变异测试自然成为 DevOps 演变的下一步。 | 2019-10-17T09:44:35 | 2019-10-17T09:44:35 | 11,468 | /article-11468-1.html |
>
> 测试驱动开发技术是根据大自然的运作规律创建的，变异测试自然成为 DevOps 演变的下一步。
>
>
>
在 “[故障是无懈可击的开发运维中的一个特点](https://opensource.com/article/19/7/failure-feature-blameless-devops)”，我讨论了故障在通过征求反馈来交付优质产品的过程中所起到的重要作用。敏捷 DevOps 团队就是用故障来指导他们并推动开发进程的。<ruby> <a href="https://en.wikipedia.org/wiki/Test-driven_development"> 测试驱动开发 </a> <rt> Test-driven development </rt></ruby>（TDD）是任何敏捷 DevOps 团队评估产品交付的[必要条件](https://www.merriam-webster.com/dictionary/conditio%20sine%20qua%20non)。以故障为中心的 TDD 方法仅在与可量化的测试配合使用时才有效。
TDD 方法仿照大自然是如何运作的以及自然界在进化博弈中是如何产生赢家和输家为模型而建立的。
### 自然选择
1859 年，<ruby> <a href="https://en.wikipedia.org/wiki/Charles_Darwin"> 查尔斯·达尔文 </a> <rt> Charles Darwin </rt></ruby>在他的《<ruby> <a href="https://en.wikipedia.org/wiki/On_the_Origin_of_Species"> 物种起源 </a> <rt> On the Origin of Species </rt></ruby>》一书中提出了进化论学说。达尔文的论点是，自然变异是由生物个体的自发突变和环境压力共同造成的。环境压力淘汰了适应性较差的生物体，而有利于其他适应性强的生物的发展。每个生物体的染色体都会发生变异，而这些自发的变异会携带给下一代（后代）。然后在自然选择下测试新出现的变异性 —— 当下存在的环境压力是由变异性的环境条件所导致的。
这张简图说明了调整适应环境条件的过程。
*图1. 不同的环境压力导致自然选择下的不同结果。图片截图来源于[理查德·道金斯的一个视频](https://www.youtube.com/watch?v=MgK5Rf7qFaU)。*
该图显示了一群生活在自己栖息地的鱼。栖息地各不相同（海底或河床底部的砾石颜色有深有浅），每条鱼长的也各不相同（鱼身图案和颜色也有深有浅）。
这张图还显示了两种情况（即环境压力的两种变化）：
1. 捕食者在场
2. 捕食者不在场
在第一种情况下，在砾石颜色衬托下容易凸显出来的鱼被捕食者捕获的风险更高。当砾石颜色较深时，浅色鱼的数量会更少一些。反之亦然，当砾石颜色较浅时，深色鱼的数量会更少。
在第二种情况下，鱼完全放松下来进行交配。在没有捕食者和没有交配仪式的情况下，可以预料到相反的结果：在砾石背景下显眼的鱼会有更大的机会被选来交配并将其特性传递给后代。
### 选择标准
变异性在进行选择时，绝不是任意的、反复无常的、异想天开的或随机的。选择过程中的决定性因素通常是可以度量的。该决定性因素通常称为测试或目标。
一个简单的数学例子可以说明这一决策过程。（在该示例中，这种选择不是由自然选择决定的，而是由人为选择决定。）假设有人要求你构建一个小函数，该函数将接受一个正数，然后计算该数的平方根。你将怎么做？
敏捷 DevOps 团队的方法是快速验证失败。谦虚一点，先承认自己并不真的知道如何开发该函数。这时，你所知道的就是如何描述你想做的事情。从技术上讲，你已准备好进行单元测试。
“<ruby> 单元测试 <rt> unit test </rt></ruby>”描述了你的具体期望结果是什么。它可以简单地表述为“给定数字 16，我希望平方根函数返回数字 4”。你可能知道 16 的平方根是 4。但是，你不知道一些较大数字（例如 533）的平方根。
但至少，你已经制定了选择标准，即你的测试或你的期望值。
### 进行故障测试
[.NET Core](https://dotnet.microsoft.com/) 平台可以演示该测试。.NET 通常使用 xUnit.net 作为单元测试框架。（要跟随进行这个代码示例，请安装 .NET Core 和 xUnit.net。）
打开命令行并创建一个文件夹，在该文件夹实现平方根解决方案。例如，输入：
```
mkdir square_root
```
再输入：
```
cd square_root
```
为单元测试创建一个单独的文件夹：
```
mkdir unit_tests
```
进入 `unit_tests` 文件夹下（`cd unit_tests`），初始化 xUnit 框架：
```
dotnet new xunit
```
现在，转到 `square_root` 下, 创建 `app` 文件夹:
```
mkdir app
cd app
```
如果有必要的话，为你的代码创建一个脚手架：
```
dotnet new classlib
```
现在打开你最喜欢的编辑器开始编码！
在你的代码编辑器中，导航到 `unit_tests` 文件夹，打开 `UnitTest1.cs`。
将 `UnitTest1.cs` 中自动生成的代码替换为：
```
using System;
using Xunit;
using app;
namespace unit_tests{
public class UnitTest1{
Calculator calculator = new Calculator();
[Fact]
public void GivenPositiveNumberCalculateSquareRoot(){
var expected = 4;
var actual = calculator.CalculateSquareRoot(16);
Assert.Equal(expected, actual);
}
}
}
```
该单元测试描述了变量的**期望值**应该为 4。下一行描述了**实际值**。建议通过将输入值发送到称为`calculator` 的组件来计算**实际值**。对该组件的描述是通过接收数值来处理`CalculateSquareRoot` 信息。该组件尚未开发。但这并不重要，我们在此只是描述期望值。
最后，描述了触发消息发送时发生的情况。此时，判断**期望值**是否等于**实际值**。如果是，则测试通过，目标达成。如果**期望值**不等于**实际值**，则测试失败。
接下来，要实现称为 `calculator` 的组件，在 `app` 文件夹中创建一个新文件，并将其命名为`Calculator.cs`。要实现计算平方根的函数，请在此新文件中添加以下代码：
```
namespace app {
public class Calculator {
public double CalculateSquareRoot(double number) {
double bestGuess = number;
return bestGuess;
}
}
}
```
在测试之前，你需要通知单元测试如何找到该新组件（`Calculator`）。导航至 `unit_tests` 文件夹，打开 `unit_tests.csproj` 文件。在 `<ItemGroup>` 代码块中添加以下代码：
```
<ProjectReference Include="../app/app.csproj" />
```
保存 `unit_test.csproj` 文件。现在，你可以运行第一个测试了。
切换到命令行，进入 `unit_tests` 文件夹。运行以下命令：
```
dotnet test
```
运行单元测试，会输出以下内容：
*图2. 单元测试失败后 xUnit 的输出结果*
正如你所看到的，单元测试失败了。期望将数字 16 发送到 `calculator` 组件后会输出数字 4，但是输出（`Actual`）的是 16。
恭喜你！创建了第一个故障。单元测试为你提供了强有力的反馈机制，敦促你修复故障。
### 修复故障
要修复故障，你必须要改进 `bestGuess`。当下，`bestGuess` 仅获取函数接收的数字并返回。这不够好。
但是，如何找到一种计算平方根值的方法呢？ 我有一个主意 —— 看一下大自然母亲是如何解决问题的。
### 效仿大自然的迭代
在第一次（也是唯一的）尝试中要得出正确值是非常难的（几乎不可能）。你必须允许自己进行多次尝试猜测，以增加解决问题的机会。允许多次尝试的一种方法是进行迭代。
要迭代，就要将 `bestGuess` 值存储在 `previousGuess` 变量中，转换 `bestGuess` 的值，然后比较两个值之间的差。如果差为 0，则说明问题已解决。否则，继续迭代。
这是生成任何正数的平方根的函数体：
```
double bestGuess = number;
double previousGuess;
do {
previousGuess = bestGuess;
bestGuess = (previousGuess + (number/previousGuess))/2;
} while((bestGuess - previousGuess) != 0);
return bestGuess;
```
该循环（迭代）将 `bestGuess` 值集中到设想的解决方案。现在，你精心设计的单元测试通过了！
*图 3. 单元测试通过了。*
### 迭代解决了问题
正如大自然母亲解决问题的方法，在本练习中，迭代解决了问题。增量方法与逐步改进相结合是获得满意解决方案的有效方法。该示例中的决定性因素是具有可衡量的目标和测试。一旦有了这些，就可以继续迭代直到达到目标。
### 关键点!
好的，这是一个有趣的试验，但是更有趣的发现来自于使用这种新创建的解决方案。到目前为止，`bestGuess` 从开始一直把函数接收到的数字作为输入参数。如果更改 `bestGuess` 的初始值会怎样？
为了测试这一点，你可以测试几种情况。 首先，在迭代多次尝试计算 25 的平方根时，要逐步细化观察结果：
*图 4. 通过迭代来计算 25 的平方根。*
以 25 作为 `bestGuess` 的初始值，该函数需要八次迭代才能计算出 25 的平方根。但是，如果在设计 `bestGuess` 初始值上犯下荒谬的错误，那将怎么办？ 尝试第二次，那 100 万可能是 25 的平方根吗？ 在这种明显错误的情况下会发生什么？你写的函数是否能够处理这种低级错误。
直接来吧。回到测试中来，这次以一百万开始：
*图 5. 在计算 25 的平方根时，运用逐步求精法，以 100 万作为 bestGuess 的初始值。*
哇！ 以一个荒谬的数字开始，迭代次数仅增加了两倍（从八次迭代到 23 次）。增长幅度没有你直觉中预期的那么大。
### 故事的寓意
啊哈！ 当你意识到，迭代不仅能够保证解决问题，而且与你的解决方案的初始猜测值是好是坏也没有关系。 不论你最初理解得多么不正确，迭代过程以及可衡量的测试/目标，都可以使你走上正确的道路并得到解决方案。
图 4 和 5 显示了陡峭而戏剧性的燃尽图。一个非常错误的开始，迭代很快就产生了一个绝对正确的解决方案。
简而言之，这种神奇的方法就是敏捷 DevOps 的本质。
### 回到一些更深层次的观察
敏捷 DevOps 的实践源于人们对所生活的世界的认知。我们生活的世界存在不确定性、不完整性以及充满太多的困惑。从科学/哲学的角度来看，这些特征得到了<ruby> <a href="https://en.wikipedia.org/wiki/Uncertainty_principle"> 海森堡的不确定性原理 </a> <rt> Heisenberg’s Uncertainty Principle </rt></ruby>（涵盖不确定性部分），<ruby> <a href="https://en.wikipedia.org/wiki/Tractatus_Logico-Philosophicus"> 维特根斯坦的逻辑论哲学 </a> <rt> Wittgenstein’s Tractatus Logico-Philosophicus </rt></ruby>（歧义性部分），<ruby> <a href="https://en.wikipedia.org/wiki/G%C3%B6del%27s_incompleteness_theorems"> 哥德尔的不完全性定理 </a> <rt> Gödel’s incompleteness theorems </rt></ruby>（不完全性方面）以及<ruby> <a href="https://en.wikipedia.org/wiki/Second_law_of_thermodynamics"> 热力学第二定律 </a> <rt> Second Law of Thermodynamics </rt></ruby>（无情的熵引起的混乱）的充分证明和支持。
简而言之，无论你多么努力，在尝试解决任何问题时都无法获得完整的信息。因此，放下傲慢的姿态，采取更为谦虚的方法来解决问题对我们会更有帮助。谦卑会给为你带来巨大的回报，这个回报不仅是你期望的一个解决方案，还会有它的副产品。
### 总结
大自然在不停地运作，这是一个持续不断的过程。大自然没有总体规划。一切都是对先前发生的事情的回应。 反馈循环是非常紧密的，明显的进步/倒退都是逐步实现的。大自然中随处可见，任何事物的都在以一种或多种形式逐步完善。
敏捷 DevOps 是工程模型逐渐成熟的一个非常有趣的结果。DevOps 基于这样的认识，即你所拥有的信息总是不完整的，因此你最好谨慎进行。获得可衡量的测试（例如，假设、可测量的期望结果），进行简单的尝试，大多数情况下可能失败，然后收集反馈，修复故障并继续测试。除了同意每个步骤都必须要有可衡量的假设/测试之外，没有其他方法。
在本系列的下一篇文章中，我将仔细研究变异测试是如何提供及时反馈来推动实现结果的。
---
via: <https://opensource.com/article/19/8/mutation-testing-evolution-tdd>
作者：[Alex Bunardzic](https://opensource.com/users/alex-bunardzic) 选题：[lujun9972](https://github.com/lujun9972) 译者：[Morisun029](https://github.com/Morisun029) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
命令行技巧：使用 find 和 xargs 查找和处理文件 | Ben Cotton | https://fedoramagazine.org/command-line-quick-tips-locate-and-process-files-with-find-and-xargs/ | 在命令行提示系列的这一期中，你将会看到 find 命令的介绍，并学习如何使用内置命令或使用 xargs 命令处理文件。 | /data/attachment/album/201910/17/121131sprgtzy5gvtzyzv5.jpg.thumb.jpg | /data/attachment/album/201910/17/121131sprgtzy5gvtzyzv5.jpg | true | false | false | geekpi | false | [
"find",
"xargs"
] | 技术 | {
"viewnum": 9722,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 在命令行提示系列的这一期中，你将会看到 find 命令的介绍，并学习如何使用内置命令或使用 xargs 命令处理文件。 | 2019-10-17T13:00:00 | 2019-10-17T13:00:00 | 11,469 | /article-11469-1.html | 
`find` 是日常工具箱中功能强大、灵活的命令行程序之一。它如它名字所暗示的：查找符合你指定条件的文件和目录。借助 `-exec` 或 `-delete` 之类的参数，你可以让它对找到的文件进行操作。
在[命令行提示](https://fedoramagazine.org/?s=command+line+quick+tips)系列的这一期中，你将会看到 `find` 命令的介绍，并学习如何使用内置命令或使用 `xargs` 命令处理文件。
### 查找文件
`find` 至少要加上查找的路径。例如，此命令将查找（并打印）系统上的每个文件：
```
find /
```
由于一切皆文件，因此你会看到大量的输出。这可能无法帮助你找到所需的内容。你可以更改路径参数缩小范围，但这实际上并没有比使用 `ls` 命令更好。因此，你需要考虑要查找的内容。
也许你想在家目录中查找所有 JPEG 文件。 `-name` 参数允许你将结果限制为与给定模式匹配的文件。
```
find ~ -name '*jpg'
```
但是等等！如果其中一些扩展名是大写怎么办？ `-iname` 类似于 `-name`，但不区分大小写：
```
find ~ -iname '*jpg'
```
很好！但是 8.3 命名方案出自 1985 年。某些图片的扩展名可能是 .jpeg。幸运的是，我们可以将模式使用“或”（`-o`）进行组合。括号需要转义，以便使 `find` 命令而不是 shell 程序尝试解释它们。
```
find ~ \( -iname 'jpeg' -o -iname 'jpg' \)
```
更进一步。如果你有一些以 `jpg` 结尾的目录怎么办？（我不懂你为什么将目录命名为 `bucketofjpg` 而不是 `pictures`？）我们可以加上 `-type` 参数来仅查找文件：
```
find ~ \( -iname '*jpeg' -o -iname '*jpg' \) -type f
```
或者，也许你想找到那些名字奇怪的目录，以便之后可以重命名它们：
```
find ~ \( -iname '*jpeg' -o -iname '*jpg' \) -type d
```
最近你拍摄了很多照片，因此使用 `-mtime`（修改时间）将范围缩小到最近一周修改过的文件。 `-7` 表示 7 天或更短时间内修改的所有文件。
```
find ~ \( -iname '*jpeg' -o -iname '*jpg' \) -type f -mtime -7
```
### 使用 xargs 进行操作
`xargs` 命令从标准输入流中获取参数，并基于它们执行命令。继续使用上一节中的示例，假设你要将上周修改过的家目录中的所有 JPEG 文件复制到 U 盘，以便插到电子相册上。假设你已经将 U 盘挂载到 `/media/photo_display`。
```
find ~ \( -iname '*jpeg' -o -iname '*jpg' \) -type f -mtime -7 -print0 | xargs -0 cp -t /media/photo_display
```
这里的 `find` 命令与以前的版本略有不同。`-print0` 命令让输出有一些更改：它不使用换行符，而是添加了一个 `null` 字符。`xargs` 的 `-0`（零）选项可调整解析以达到预期效果。这很重要，不然对包含空格、引号或其他特殊字符的文件名执行操作可能无法按预期进行。对文件采取任何操作时，都应使用这些选项。
`cp` 命令的 `-t` 参数很重要，因为 `cp` 通常要求目的地址在最后。你可以不使用 `xargs` 而使用 `find` 的 `-exec` 执行此操作，但是 `xargs` 的方式会更快，尤其是对于大量文件，因为它会单次调用 `cp`。
### 了解更多
这篇文章仅仅是 `find` 可以做的事情的表面。 `find` 支持基于权限、所有者、访问时间等的测试。它甚至可以将搜索路径中的文件与其他文件进行比较。将测试与布尔逻辑相结合，可以为你提供惊人的灵活性，以精确地找到你要查找的文件。使用内置命令或管道传递给 `xargs`，你可以快速处理大量文件。
---
via: <https://fedoramagazine.org/command-line-quick-tips-locate-and-process-files-with-find-and-xargs/>
作者：[Ben Cotton](https://fedoramagazine.org/author/bcotton/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
新手教程：如何在 Linux 下解压 Zip 文件 | Abhishek Prakash | https://itsfoss.com/unzip-linux/ | 本文将会向你展示如何在 Ubuntu 和其他 Linux 发行版本上解压文件。终端和图形界面的方法都会讨论。 | /data/attachment/album/201910/17/125115p59tcxxjdzq35dow.jpg.thumb.jpg | /data/attachment/album/201910/17/125115p59tcxxjdzq35dow.jpg | true | false | false | singledo | false | [
"unzip",
"zip"
] | 技术 | {
"viewnum": 13776,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
} | [] | [] | 本文将会向你展示如何在 Ubuntu 和其他 Linux 发行版本上解压文件。终端和图形界面的方法都会讨论。 | 2019-10-17T13:05:00 | 2019-10-17T13:05:00 | 11,470 | /article-11470-1.html |
>
> 本文将会向你展示如何在 Ubuntu 和其他 Linux 发行版本上解压文件。终端和图形界面的方法都会讨论。
>
>
>
[Zip](https://en.wikipedia.org/wiki/Zip_(file_format)) 是一种创建压缩存档文件的最普通、最流行的方法。它也是一种古老的文件归档文件格式，这种格式创建于 1989 年。由于它的广泛使用，你会经常遇见 zip 文件。
在更早的一份教程里，我介绍了[如何在 Linux 上用 zip 压缩一个文件夹](https://itsfoss.com/linux-zip-folder/)。在这篇面向初学者的快速教程中，我会介绍如何在 Linux 上解压文件。
先决条件：检查你是否安装了 `unzip`。
为了解压 zip 归档文件，你必须在你的系统上安装了 unzip 软件包。大多数现代的的 Linux 发行版本提供了解压 zip 文件的支持，但是对这些 zip 文件进行校验以避免以后出现损坏总是没有坏处的。
在基于 [Unbutu](https://ubuntu.com/) 和 [Debian](https://www.debian.org/) 的发行版上，你能够使用下面的命令来安装 `unzip`。如果你已经安装了，你会被告知已经被安装。
```
sudo apt install unzip
```
一旦你能够确认你的系统中安装了 `unzip`，你就可以通过 `unzip` 来解压 zip 归档文件。
你也能够使用命令行或者图形工具来达到目的，我会向你展示两种方法：
### 使用命令行解压文件
在 Linux 下使用 `unzip` 命令是非常简单的。在你放 zip 文件的目录，用下面的命令:
```
unzip zipped_file.zip
```
你可以给 zip 文件提供解压路径而不是解压到当前所在路径。你会在终端输出中看到提取的文件:
```
unzip metallic-container.zip -d my_zip
Archive: metallic-container.zip
inflating: my_zip/625993-PNZP34-678.jpg
inflating: my_zip/License free.txt
inflating: my_zip/License premium.txt
```
上面的命令有一个小问题。它会提取 zip 文件中所有的内容到现在的文件夹。你会在当前文件夹下留下一堆没有组织的文件，这不是一件很好的事情。
#### 解压到文件夹下
在 Linux 命令行下，对于把文件解压到一个文件夹下是一个好的做法。这种方式下，所有的提取文件都会被存储到你所指定的文件夹下。如果文件夹不存在，会创建该文件夹。
```
unzip zipped_file.zip -d unzipped_directory
```
现在 `zipped_file.zip` 中所有的内容都会被提取到 `unzipped_directory` 中。
由于我们在讨论好的做法，这里有另一个注意点，我们可以查看压缩文件中的内容而不用实际解压。
#### 查看压缩文件中的内容而不解压压缩文件
```
unzip -l zipped_file.zip
```
下面是该命令的输出:
```
unzip -l metallic-container.zip
Archive: metallic-container.zip
Length Date Time Name
--------- ---------- ----- ----
6576010 2019-03-07 10:30 625993-PNZP34-678.jpg
1462 2019-03-07 13:39 License free.txt
1116 2019-03-07 13:39 License premium.txt
--------- -------
6578588 3 files
```
在 Linux 下，还有些 `unzip` 的其它用法，但我想你现在已经对在 Linux 下使用解压文件有了足够的了解。
### 使用图形界面来解压文件
如果你使用桌面版 Linux，那你就不必总是使用终端。在图形化的界面下，我们又要如何解压文件呢? 我使用的是 [GNOME 桌面](https://gnome.org/)，不过其它桌面版 Linux 发行版也大致相同。
打开文件管理器，然后跳转到 zip 文件所在的文件夹下。在文件上点击鼠标右键，你会在弹出的窗口中看到 “提取到这里”，选择它。
与 `unzip` 命令不同，这个提取选项会创建一个和压缩文件名相同的文件夹（LCTT 译注：文件夹没有 `.zip` 扩展名），并且把压缩文件中的所有内容存储到创建的文件夹下。相对于 `unzip` 命令的默认行为是将压缩文件提取到当前所在的文件下，图形界面的解压对于我来说是一件非常好的事情。
这里还有一个选项“提取到……”，你可以选择特定的文件夹来存储提取的文件。
你现在知道如何在 Linux 解压文件了。你也许还对学习[在 Linux 下使用 7zip](https://itsfoss.com/use-7zip-ubuntu-linux/) 感兴趣？
---
via: <https://itsfoss.com/unzip-linux/>
作者：[Abhishek Prakash](https://itsfoss.com/author/abhishek/) 选题：[lujun9972](https://github.com/lujun9972) 译者：[octopus](https://github.com/singledo) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.