title
stringlengths 5
75
| author
stringlengths 0
48
| fromurl
stringlengths 0
185
| summary
stringlengths 4
460
| pic
stringlengths 32
70
| largepic
stringlengths 0
69
| titlepic
bool 2
classes | thumb
bool 2
classes | islctt
bool 2
classes | selector
stringclasses 14
values | translator
stringlengths 0
45
| reviewer
stringclasses 27
values | editorchoice
bool 2
classes | tags
list | category
stringclasses 20
values | count
dict | comments_data
list | related
list | excerpt
stringlengths 4
460
| date
timestamp[s] | updated
timestamp[s] | id
int64 1
16.6k
| permalink
stringlengths 17
21
| content
stringlengths 116
82.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
使用 Apex 和 Compose MongoDB 开发 serverless
|
Hays Hutton
|
https://www.compose.com/articles/go-serverless-with-apex-and-composes-mongodb/
|
和大多数事物一样，Apex 和 Lambda 并不是在所有场景下都完美。 但是，在你的工具箱中增加一个完全不需要你来管理底层建设的工具完全没有坏处。
|
/data/attachment/album/201707/18/194802yb63zpb2s2pa0g3s.jpg.thumb.jpg
|
/data/attachment/album/201707/18/194802yb63zpb2s2pa0g3s.jpg
| true | false | true |
xiaow6
| false |
[
"Go",
"Lambda",
"FaaS",
"MongoDB"
] |
软件开发
|
{
"viewnum": 5262,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
和大多数事物一样，Apex 和 Lambda 并不是在所有场景下都完美。 但是，在你的工具箱中增加一个完全不需要你来管理底层建设的工具完全没有坏处。
| 2017-07-18T19:48:08 | 2017-07-18T19:48:08 | 8,705 |
/article-8705-1.html
|
Apex 是一个将开发和部署 AWS Lambda 函数的过程打包了的工具。它提供了一个本地命令行工具来创建安全上下文、部署函数，甚至追踪云端日志。由于 AWS Lambda 服务将函数看成独立的单元，Apex 提供了一个框架层将一系列函数作为一个项目。另外，它将服务拓展到不仅仅是 Java，Javascript 和 Ptyhon 语言，甚至包括 Go 语言。
两年前 Express （基本上是 NodeJS 事实标准上的网络框架层）的作者，[离开](https://medium.com/@tjholowaychuk/farewell-node-js-4ba9e7f3e52b#.dc9vkeybx)了 Node 社区，而将其注意力转向 Go （谷歌创造的后端服务语言），以及 Lambda（由 AWS 提供的函数即服务）。尽管一个开发者的行为无法引领一股潮流，但是来看看他正在做的名叫 [Apex](http://apex.run/) 项目会很有趣，因为它可能预示着未来很大一部分网络开发的改变。
### 什么是 Lambda?
如今，人们如果不能使用自己的硬件，他们会选择付费使用一些云端的虚拟服务器。在云上，他们会部署一个完整的协议栈如 Node、Express，和一个自定义应用。或者如果他们更进一步使用了诸如 Heroku 或者 Bluemix 之类的新玩意，也可能在某些已经预配置好 Node 的容器中仅仅通过部署应用代码来部署他们完整的应用。
在这个抽象的阶梯上的下一步是单独部署函数到云端而不是一个完整的应用。这些函数之后可以被一大堆外部事件触发。例如，AWS 的 API 网关服务可以将代理 HTTP 请求作为触发函数的事件，而函数即服务（FaaS）的供应方根据要求执行匹配的函数。
### Apex 起步
Apex 是一个将 AWS 命令行接口封装起来的命令行工具。因此，开始使用 Apex 的第一步就是确保你已经安装和配置了从 AWS 获取的命令行工具（详情请查看 [AWS CLI Getting Started](http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) 或者 [Apex documentation](http://apex.run/)）。
接下来，安装 Apex：
```
curl https://raw.githubusercontent.com/apex/apex/master/install.sh | sh
```
然后为你的新项目创建一个目录并运行：
```
apex init
```
这步会配置好一些必须的安全策略，并且将项目名字附在函数名后，因为 Lambda 使用扁平化的命名空间。同时它也会创建一些配置文件和默认的 “Hello World" 风格的 Javascript 函数的 functions 目录。
Apex/Lambda 一个非常友好的特性是创建函数非常直观。创建一个以你函数名为名的新目录，然后在其中创建项目。如果想要使用 Go 语言，你可以创建一个叫 `simpleGo` 的目录然后在其中创建一个小型的 `main` 函数：
```
// serverless/functions/simpleGo/main.go
package main
import (
"encoding/json"
"github.com/apex/go-apex"
"log"
)
type helloEvent struct {
Hello string `json:"hello"`
}
func main() {
apex.HandleFunc(func(event json.RawMessage, ctx *apex.Context) (interface{}, error) {
var h helloEvent
if err := json.Unmarshal(event, &h); err != nil {
return nil, err
}
log.Print("event.hello:", h.Hello)
return h, nil
})
}
```
Node 是 Lambda 所支持的运行环境，Apex 使用 NodeJS shim 来调用由上述程序产生的二进制文件。它将 `event` 传入二进制文件的 STDIN，将从二进制返回的 STDOUT 作为 `value`。通过 STDERR 来显示日志。`apex.HandleFunc` 用来为你管理所有的管道。事实上在 Unix 惯例里这是一个非常简单的解决方案。你甚至可以通过在本地命令行执行 `go run main.go` 来测试它。
通过 Apex 向云端部署稍显琐碎：
注意，这将会对你的函数指定命名空间，控制版本，甚至为其他多开发环境如 `staging` 和 `production`配置`env`。
通过 `apex invoke` 在云端执行也比较琐碎：
当然我们也可以追踪一些日志：
这些是从 AWS CloudWatch 返回的结果。它们都在 AWS 的 UI 中可见，但是当在另一个终端参照此结果来署它会更快。
### 窥探内部的秘密
来看看它内部到底部署了什么很具有指导性。Apex 将 shim 和所有需要用来运行函数的东西打包起来。另外，它会提前做好配置如入口与安全条例：
Lambda 服务实际上接受一个包含所有依赖的 zip 压缩包，它会被部署到服务器来执行指定的函数。我们可以使用 `apex build <functionName>` 在本地创建一个压缩包用来在以后解压以探索。
这里的 `_apex_index.js handle` 函数是原始的入口。它会配置好一些环境变量然后进入 `index.js`。
而 `index.js` 孕育一个 `main` Go 的二进制文件的子进程并且将所有关联联结在一起。
### 使用 `mgo` 继续深入
`mgo` 是 Go 语言的 MongoDB 驱动。使用 Apex 来创建一个函数来连接到 Compose 的 MongoDB 就如同我们已经学习过的 `simpleGo` 函数一样直观。这里我们会通过增加一个 `mgoGo` 目录和另一个 `main.go` 来创建一个新函数。
```
// serverless/functions/mgoGo/main.go
package main
import (
"crypto/tls"
"encoding/json"
"github.com/apex/go-apex"
"gopkg.in/mgo.v2"
"log"
"net"
)
type person struct {
Name string `json:"name"`
Email string `json:"email"`
}
func main() {
apex.HandleFunc(func(event json.RawMessage, ctx *apex.Context) (interface{}, error) {
tlsConfig := &tls.Config{}
tlsConfig.InsecureSkipVerify = true
//connect URL:
// "mongodb://<username>:<password>@<hostname>:<port>,<hostname>:<port>/<db-name>
dialInfo, err := mgo.ParseURL("mongodb://apex:mountain@aws-us-west-2-portal.0.dblayer.com:15188, aws-us-west-2-portal.1.dblayer.com:15188/signups")
dialInfo.DialServer = func(addr *mgo.ServerAddr) (net.Conn, error) {
conn, err := tls.Dial("tcp", addr.String(), tlsConfig)
return conn, err
}
session, err := mgo.DialWithInfo(dialInfo)
if err != nil {
log.Fatal("uh oh. bad Dial.")
panic(err)
}
defer session.Close()
log.Print("Connected!")
var p person
if err := json.Unmarshal(event, &p); err != nil {
log.Fatal(err)
}
c := session.DB("signups").C("people")
err = c.Insert(&p)
if err != nil {
log.Fatal(err)
}
log.Print("Created: ", p.Name," - ", p.Email)
return p, nil
})
}
```
发布部署，我们可以通过使用正确类型的事件来模拟调用了一个 API：
最终结果是 `insert` 到在 [Compose 之上 的 MongoDB](https://www.compose.com/articles/composes-new-primetime-mongodb/) 中。
### 还有更多……
尽管目前我们已经涉及了 Apex 的方方面面，但是仍然有很多值得我们去探索的东西。它还和 [Terraform](https://www.terraform.io/) 进行了整合。如果你真的希望，你可以发布一个多语言项目包括 Javascript、Java、Python 以及 Go。你也可以为开发、演示以及产品环境配置多种环境。你可以调整运行资源如调整存储大小和运行时间来调整成本。而且你可以把函数勾连到 API 网关上来传输一个 HTTP API 或者使用一些类似 SNS (简单通知服务)来为云端的函数创建管道。
和大多数事物一样，Apex 和 Lambda 并不是在所有场景下都完美。 但是，在你的工具箱中增加一个完全不需要你来管理底层建设的工具完全没有坏处。
---
作者简介:
Hays Hutton 喜欢写代码并写一些与其相关的东西。喜欢这篇文章？请前往[Hays Hutton’s author page](https://www.compose.com/articles/author/hays-hutton/) 继续阅读其他文章。
---
via: <https://www.compose.com/articles/go-serverless-with-apex-and-composes-mongodb/>
作者：[Hays Hutton](https://www.compose.com/articles/author/hays-hutton/) 译者：[xiaow6](https://github.com/xiaow6) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
不需要编码：树莓派上的 Node-RED
|
Surya G
|
https://opensource.com/article/17/7/nodered-raspberrypi-hardware
|
查看本教程，看看使用 Node-RED 的拖放界面设置硬件流程是多么容易。
|
/data/attachment/album/201707/19/103328du7i87dznfheebag.jpg.thumb.jpg
|
/data/attachment/album/201707/19/103328du7i87dznfheebag.jpg
| true | false | true |
geekpi
| false |
[
"树莓派",
"Node-RED"
] |
树莓派
|
{
"viewnum": 14674,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
查看本教程，看看使用 Node-RED 的拖放界面设置硬件流程是多么容易。
| 2017-07-19T10:33:00 | 2017-07-19T10:33:00 | 8,706 |
/article-8706-1.html
|
>
> 查看本教程，看看使用 Node-RED 的拖放界面设置硬件流程是多么容易。
>
>
>
Node-RED 是一个编程工具，可让你使用基于浏览器的编辑器快速连接硬件设备。它具有大量的节点，可以以拖放的方式构建流程，这大大减少了开发时间。[Node-RED](https://nodered.org/) 与树莓派的 Raspian Jessie 一起安装，你还可以独立下载 Node-RED。
为了向你展示它如何工作，我们将使用 Node-RED 构建一个简单的工具，与连接到树莓派的蜂窝调制解调器通信。使用蜂窝调制解调器，你可以通过蜂窝网络从你的树莓派发送/接收数据。你可以使用蜂窝网络提供商通常提供的 3G/4G USB 加密狗，也可以将开发板与 3G 或 4G 无线调制解调器连接。
无论你是连接 USB 加密狗还是开发板，树莓派的连接接口都是通过 USB 端口的。在本教程中，我将一块 [SIM900](http://m2msupport.net/m2msupport/simcom-sim900-gprs-2g-module/) 开发板通过一根 USB 转串行电缆连接到树莓派。
第一步是检查 SIM900 开发板是否连接到树莓派上。
USB 转串行适配器在这里被显示为连接到树莓派的 USB 设备之一。
接下来，检查 SIM900 连接的 USB 端口号。
在最后一行，你可以看到 SIM900 板（通过 USB 转串行转换器连接）连接到了树莓派上的 **ttyUSB0**。现在我们准备开始使用 Node-RED。
在树莓派上启动 Node-RED。
下载[示例流图](http://m2msupport.net/m2msupport/wp-content/themes/admired/Node-RED/modem_commands)并将其导入到 Node-RED 中。请注意，流文件是该图形 UI 的 JSON 表示形式。
在 Node-RED 中，导入的流图应该看上去像这样：
注入节点设置 [AT 命令](http://m2msupport.net/m2msupport/software-and-at-commands-for-m2m-modules/)需要查询调制解调器。**添加换行** 功能节点会在注入节点传递过来的 AT 命令后面附加 **\r\n**。**添加换行** 的输出然后被连接到**串行输出**节点，它将数据写入串行端口。来自调制解调器的 AT 命令的响应通过 **串行输入** 节点读取，该节点将响应输出到 **调试** 窗口。确认串行端口号和端口速度在 **串行输入** 和 **串行输出** 节点中的配置。
Node-RED 是一种易于使用的编程工具，可用于快速集成和测试硬件设备。从本教程可以看出，使用 Node-RED 连接和测试使用树莓派的蜂窝模式不需要编码。
有关 Node-RED 和其他可以使用的方式的更多信息，请访问[项目网站](https://nodered.org/)。
（题图： Thomas Hawk 的 [Flickr](https://www.flickr.com/photos/thomashawk/3048157616/in/photolist-5DmB4E-BzrZ4-5aUXCN-nvBWYa-qbkwAq-fEFeDm-fuZxgC-dufA8D-oi8Npd-b6FiBp-7ChGA3-aSn7xK-7NXMyh-a9bQQr-5NG9W7-agCY7E-4QD9zm-7HLTtj-4uCiHy-bYUUtG). [CC BY-NC 2.0](https://creativecommons.org/licenses/by-nc/2.0/). Opensource.com 修改）
---
作者简介：
Surya G - 我的兴趣是为物联网项目尤其是使用蜂窝调制解调器的项目做软件开发。
---
via: <https://opensource.com/article/17/7/nodered-raspberrypi-hardware>
作者：[Surya G](https://opensource.com/users/gssm2m) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
与开放社区讨论法律事宜的 7 种方式
|
Simon Phipps
|
https://opensource.com/open-organization/17/3/legal-matters-community
|
你的组织的律师准备好与开源社区打交道了么？不要让他们犯这些错。
|
/data/attachment/album/201707/19/171254chh54chh99uuh9df.png.thumb.jpg
|
/data/attachment/album/201707/19/171254chh54chh99uuh9df.png
| true | false | true |
geekpi
| false |
[
"开源",
"法律"
] |
观点
|
{
"viewnum": 3229,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你的组织的律师准备好与开源社区打交道了么？不要让他们犯这些错。
| 2017-07-19T17:12:51 | 2017-07-19T17:12:51 | 8,707 |
/article-8707-1.html
|
>
> 你的组织的律师准备好与开源社区打交道了么？不要让他们犯这些错。
>
>
>
我注意到有相当多的人尝试与[开源推进联盟的许可证评估社区](https://opensource.org/approval)以及 [Apache 软件基金会的法律事务委员会](https://www.apache.org/legal/)建立沟通，当轮到*你*与开放社区进行法律讨论时，我想提供一些成功的提示和技巧。
### 不要代理人
首先，也是最重要的是，要确保进行谈话的人员既是*有资格的*，也是*有授权的*。不要用代理人，这只会让社区沮丧，他们很快会发现你的代表总是扮演二手车推销员的角色并且要求到后面的房间交易。显然，法律讨论将涉及公司的一个团队，可能涉及产品管理、工程和内部咨询。 但代表们需要能够自己控制谈话内容，不要总是引用幕后某个匿名人物的话。
### 多边主义
开源社区就安全合作所需的确定性达成了难得一致的共识。这种共识体现在其治理中，尤其是在他们使用的开源许可证中。所以当你提出一个新的提案时，就不像是一个普通的商业交易。这些是双边谈判，以双方的自由为代价来创造一个最佳妥协的和平条约。在这个讨论中，你只是许多方面之一，你需要解释为什么你的提案对所有人都有益。写上多边之间的调整本质上是缓慢的，所以不要设置最后期限。无论你做什么，不要建议对开源许可证进行更改！
### 首先学习
现有的共识和过程其存在是有原因的。你应该了解每个元素的原因，最好连同其发生的历史一起了解，然后再提出修改。这样，你可以在进一步发展的背景下表达你的提案，这样你可以避免在社区历史中受教育（浪费社区资源，降低你机会的有效性）。回看邮件列表，并向开发人员询问历史和来龙去脉。
### 透明
开源开发人员使用一个迭代、增量修改的过程。即使需要大的变化，它几乎总是用一系列更小、更好的解释或不言而喻的正确变化来实现的，这样每个人都可以跟进并支持。你提出的更改也是如此。不要弄出新的贡献者协议或者修改过的许可证，并期望每个人都相信你是专家、一切都是对的。你需要提供一根“红线”（相当于法律文件的差异），记录每个变化，并提供一个承认任何社区影响并为其辩护的理由。如果你*只是*为了你自己的利益需要一个东西，那就承认它，而不是希望没有人会注意到。
### 谦逊
你是一个炙手可热的律师，而你认为只有程序员才使用邮件列表。很明显，对你而言他们缺乏讨论的经验，所以你安排了一个你认为是同等的代理人，简化这一切，或者提出与社区选择的律师进行一对一的讨论。 我很抱歉地说你做的全都是错的。由于社区的政策是多边协商一致的，所以他们很有可能知道他们为什么定下现在的这些决定。名单上的一些人将具有优秀的领域知识，可能会比你的更好。而且一对一这件事是终极的羞辱，就像询问是否有一个成年人可以与你说话。
### 不要秘密渠道
有可能在某种领导机构，也许你认识在公司法务工作的 VP，也许你认识社区的总法律顾问。虽然在某些情况下，询问如何操控流程的提示可能是可以接受的，但尝试通过秘密渠道讨论或协商来试图影响甚至决定结果，那么结果会很糟糕。你最终可能会被邀请进行一对一的讨论, 但你不应该要求或期待它。
### 成为一个成员
如果你一切都做得正确，那么社区就有可能尊重你。坚持这些。作为一名冷静、机智的贡献者建立你的声誉。当人们犯你犯过的错误（或者已避免的）时，帮助他们。作为邮件列表社区的值得信赖的参与者，你是项目和雇主的真正资产。继续贡献，一些项目最终会在它们的治理中为你提供一个角色。
*这个文章的早期版本[最初发表](https://meshedinsights.com/2017/02/28/engaging-communities-on-legal-matters-7-tips/)在 Meshed Insights 中。*
（题图： opensource.com）
---
作者简介：
Simon Phipps - 计算机行业和开源老手 Simon Phipps 上线了 Public Software，一个欧洲的开源项目托管，Document Foundation 的志愿者总监。他的帖子由 Patreon 赞助者赞助 - 如果你想要看更多，成为其中一个！
---
via: <https://opensource.com/open-organization/17/3/legal-matters-community>
作者：[Simon Phipps](https://opensource.com/users/simonphipps) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
成为一名软件开发者你应该学习哪种语言？
|
Brent Marinaccio
|
https://www.linuxcareer.com/do-you-have-what-it-takes-to-be-a-software-developer
|
在过去几年里，应用程序领域开始增长。在这种情况下，开发人员使用哪种语言构建这些应用程序？简而言之，要看情况，我知道这个说法没啥稀奇的。但是，通过我们拥有的数据，我们可以确定哪些语言领先。
|
/data/attachment/album/201707/19/210800whv5uuhuvs52yvau.jpg.thumb.jpg
|
/data/attachment/album/201707/19/210800whv5uuhuvs52yvau.jpg
| true | false | true |
geekpi
| false |
[
"编程语言"
] |
观点
|
{
"viewnum": 6777,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "180.168.126.246",
"message": "go语言越来越受关注了",
"username": "来自上海的 Chrome Mobile 37.0|Android 7.0 用户",
"date": "2017-07-20T12:27:00"
},
{
"postip": "58.19.56.155",
"message": "php是世界上最好的语言",
"username": "来自湖北武汉的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-07-20T21:36:45"
},
{
"postip": "45.62.100.103",
"message": "拥抱变化",
"username": "Vic [Chrome 59.0|GNU/Linux]",
"date": "2017-07-21T16:33:05"
}
] |
[] |
在过去几年里，应用程序领域开始增长。在这种情况下，开发人员使用哪种语言构建这些应用程序？简而言之，要看情况，我知道这个说法没啥稀奇的。但是，通过我们拥有的数据，我们可以确定哪些语言领先。
| 2017-07-19T21:08:09 | 2017-07-19T21:08:09 | 8,708 |
/article-8708-1.html
|
应用程序的领域在不断发展。底层的 Linux 做了很多工作，而且还在继续，但是在过去几年里，应用程序领域开始增长。在这种情况下，开发人员使用哪种语言构建这些应用程序？简而言之，要看情况，我知道这个说法没啥稀奇的。但是，通过我们拥有的数据，我们可以确定哪些语言领先。
站在山顶的语言是 Java。它已经出现在开源软件领域 15 年以上，但它并不是一直在顶峰。在早期，我们没有看到那么多对 java 开发者感兴趣的，但现在情况已经改变了。它是目前应用领域的权威领导者。虽然这个数字在过去六个季度没有明显增长，但其整体数量却令人印象深刻。平均而言，关注于开源软件的公司发布的职位中有超过 1/3 的职位要求 Java 技能。这对几年前没有在榜单上出现的语言而言是一个非凡的成就。而且，由于它在 Android 中的大量使用，未来这个数字进一步增加也并不奇怪。
在应用程序领域中使用的另一种语言是 C++。虽然它的数量不能与 Java 竞争，但它仍然在这个领域占据了很大的市场份额。而且每 3 个招聘中有一个要求 Java，C++ 则是每 4 个中有一个要求它。与 Java 非常类似，其数量在过去六个季度中保持相对稳定。C++ 一直被大量使用，即使 Java 已经取代它，它仍然是一种高度相关的语言。
进入到网络应用领域，多年来一直在城头变幻大王旗。在早期，大多数 Web 程序毫无疑问地选择使用 PHP 开发。正如之前关于脚本的文章所讨论的，这几年来已经发生了变化。在过去几年中，PHP 的使用似乎有所恶化。在过去一年半的时间里，已经急剧下降了 30％ 以上。这是一个令人震惊的数字，只有时间才能告诉我们趋势是否持续。
最初打破 PHP 领导地位的是 Ruby on Rails。多年来，我看到公司们和开发者们进行了这一转型。Ruby on Rails 经历了一段时间，在这个时期它是这个领域的首选语言。然而，从我们收集的数字来看，它的光泽似乎已经失去了一点。虽然没有像 PHP 这样的衰退，但其数量一直保持相对平稳，它曾经有过的增长似乎停滞不前。
目前在网络应用程序领域的王者似乎是 Javascript。它获得了最大的总数。虽然它的数量保持平坦，这很像 Ruby on Rails，但它已经吸引了更多的观众。平均来说，过去六个季度，公司在分析的 10,000 份工作清单中有 1,500 份需要 Javascript 技能。这比 PHP 或 Ruby on Rails 多了 70％。
随着 PHP 的衰落以及 Ruby on Rails 和 Javascript 停滞不前，是谁在 Web 程序领域保持增长呢？这个群体的突出者似乎是 Golang。它在 2007 年由 Google 内的几位开发人员创建，似乎这种语言开始获得更广泛的受众群体。虽然与我们讨论的其它三个的总数相比不多，但看起来这一年半以来增长了 50％。如果这种趋势继续下去，那将是非常有趣的。在我看来，我预计我们会继续看到 Golang 挤占 其它三个的群体份额。
如往常一样，我们会监测这些语言的各种前进方向，以观察市场趋势。而且，榜单的任何新进入者都会被密切关注。这是一个令人兴奋和动态的发展领域。一个会提供随时间不断变化的结果。
---
via: <https://www.linuxcareer.com/do-you-have-what-it-takes-to-be-a-software-developer>
作者：[Brent Marinaccio](https://www.linuxcareer.com/do-you-have-what-it-takes-to-be-a-software-developer) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 中恢复仍在活动进程中的已删除文件
|
Mhnassif
|
http://www.linuxnov.com/recover-deleted-files-still-running-active-processes-linux/
|
许多情况下，删除的文件都可以恢复，即使该文件有活动的进程在操作它，并且目前被单个或多个用户使用。
|
/data/attachment/album/201707/20/093803uq6z7hmxia1axjk7.jpg.thumb.jpg
|
/data/attachment/album/201707/20/093803uq6z7hmxia1axjk7.jpg
| true | false | true |
geekpi
| false |
[
"删除",
"恢复"
] |
技术
|
{
"viewnum": 8631,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
许多情况下，删除的文件都可以恢复，即使该文件有活动的进程在操作它，并且目前被单个或多个用户使用。
| 2017-07-20T09:38:10 | 2017-07-20T09:38:10 | 8,709 |
/article-8709-1.html
|
>
> 使用终端恢复你 Linux 系统上仍在运行进程的已删除文件的快速指南。
>
>
>
许多情况下，删除的文件都可以恢复，比如在该文件有活动的进程在操作它，并且目前被单个或多个用户使用时。在 Linux 系统中，每个当前正在运行的进程都会获得 ID，其被称之为进程标识符 “PID”，并将它们存放在 `/proc` 目录中。这正是我们恢复仍在运行的进程中（具有PID）已删除的文件所需要的东西。这里就是介绍我们如何做到这一点的。
假设你打开了一个压缩文件，之后你删除了这个文件。为了演示目的，压缩文件称为 “opengapps.zip”，这将是之后我们将打开和删除的文件。
### 计算原始文件的 MD5 哈希
删除之前，我们将计算该文件的 MD5。这样我们可以将原来的 MD5 哈希值与恢复文件的 MD5 哈希进行比较。这个过程将保证我们恢复的压缩文件的完整性是一样的，它没有被破坏。
```
md5sum opengapps.zip >> md5-opengapps.txt
```
要显示文本文件的内容。
```
cat md5-opengapps.txt
86489b68b40d144f0e00a0ea8407f7c0 opengapps.zip
```
检查压缩文件的 MD5 哈希值之后。我们将压缩文件保持打开（LCTT 译注：此处是使用 file-roller 这个图形界面的解压程序保持对该压缩文件的打开，其内置在 GNOME 环境中；在桌面环境中，使用桌面工具打开一个压缩包也能起到同样的作用。又及，本文举例不是很恰当，如果是删除了某个服务进程的已经打开的配置文件，那么这种恢复就很有意义），并将其删除。之后，我们将从文件的恢复过程开始，步骤如下：
```
rm opengapps.zip
```
### 删除文件的恢复过程
正如我们前面提到的，运行的进程在 `/proc` 目录中。我们可以使用以下命令搜索该目录中需要的进程：
由于我们已经知道文件名包括 .zip 扩展名，因此我们可以使用 .zip 扩展名进行搜索。它将限制输出结果并显示所需的进程。
```
ps -axu | grep .zip
m 13119 0.8 1.0 121788 30788 ? Sl 06:17 0:00 file-roller /home/m/Downloads/Compressed/opengapps.zip
m 13164 0.0 0.0 5108 832 pts/20 S+ 06:18 0:00 grep --color=auto .zip
```
然后我们将进入到包含 PID `13119` 的目录并打开 `fd` 子目录。
```
cd /proc/13119/fd
```
`fd` （文件描述符）目录包含多个文件，包括我们需要恢复的文件。该文件以硬链接的方式链接到原始文件。 `fd` 目录中的所有文件都以数字链接到“文件名”。因此，要确定这些文件中的哪一个链接到该原始文件，我们将用详细列表选项列出 /fd 目录。
```
ls -l
total 0
lr-x------ 1 m m 64 Jul 14 06:17 0 -> /dev/null
lrwx------ 1 m m 64 Jul 14 06:17 1 -> socket:[26161]
lrwx------ 1 m m 64 Jul 14 06:17 10 -> anon_inode:[eventfd]
lr-x------ 1 m m 64 Jul 14 06:17 11 -> anon_inode:inotify
lrwx------ 1 m m 64 Jul 14 06:17 12 -> socket:[5752671]
lr-x------ 1 m m 64 Jul 14 06:17 13 -> /home/m/Downloads/Compressed/opengapps.zip (deleted)
lrwx------ 1 m m 64 Jul 14 06:17 2 -> socket:[26161]
lrwx------ 1 m m 64 Jul 14 06:17 3 -> anon_inode:[eventfd]
lrwx------ 1 m m 64 Jul 14 06:17 4 -> anon_inode:[eventfd]
lrwx------ 1 m m 64 Jul 14 06:17 5 -> socket:[5751361]
lrwx------ 1 m m 64 Jul 14 06:17 6 -> anon_inode:[eventfd]
lrwx------ 1 m m 64 Jul 14 06:17 7 -> anon_inode:[eventfd]
lrwx------ 1 m m 64 Jul 14 06:17 8 -> socket:[5751363]
lrwx------ 1 m m 64 Jul 14 06:17 9 -> socket:[5751365]
```
正如你在终端输出中看到的，原始文件 “opengapps.zip” 已被删除，但它仍然链接到一个文件名 `13`，其进程 PID `13119`。但是，我们仍然可以通过将链接的文件复制到安全的地方来恢复它。
```
cp 13 /home/m/Downloads/Compressed
```
文件复制后。我们将返回包含恢复文件的目录，并使用以下命令重命名它。
```
mv 13 opengapps-recovered.zip
```
### 计算恢复文件的 MD5 哈希
由于我们已经恢复了该文件。让我们检查该文件的完整性，这只是为了确保文件没有损坏，并且和原来一样。早先我们保存了原始文件的 MD5 哈希值。
```
md5sum opengapps-recovered.zip >> md5-opengapps.txt
```
该命令将检查文件的 MD5 哈希值，并在文件中追加新恢复文件的 MD5 哈希值，以轻松比较两个 MD5 哈希值。
可以显示文本文件的内容来比较原始文件和恢复文件的 MD5 哈希值。
```
cat md5-opengapps.txt
86489b68b40d144f0e00a0ea8407f7c0 opengapps.zip
86489b68b40d144f0e00a0ea8407f7c0 opengapps-recovered.zip
```
恢复文件的 MD5 哈希是一样的。所以，我们成功地恢复了我们以前删除的文件，并且恢复后文件完整性一致，并且工作正常。
[](http://www.linuxnov.com/wp-content/uploads/2017/07/Recovering-a-deleted-file-using-terminal-LinuxNov.png)
**注意：** 在某些情况下，某些文件无法通过 `ps -axu` 命令看到。 所以，尝试检查运行的程序，并从中恢复文件。
假设我们有一个使用 Totem 媒体播放器播放中的以 .avi 为扩展名的视频。你需要做的就是检查 Totem 的 PID，并按照本示例中提到的相同说明进行操作。
要查找正在运行的程序的 PID，请使用以下命令，后面跟程序的名称。
```
pidof 程序名
```
通过分享支持我们。
---
via: <http://www.linuxnov.com/recover-deleted-files-still-running-active-processes-linux/>
作者：[mhnassif](http://www.linuxnov.com/author/mhnassif/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
物联网是 Linux 的未来么?
|
Matt Hartley
|
http://www.datamation.com/open-source/is-iot-the-future-of-linux.html
|
随着 Canonical 重新关注于赢利和新技术，我们中的一些人发现我们正在思考 Linux 未来将走向何方，IoT（物联网）是否是 Linux 的未来？ 本文旨在解决这两个问题。
|
/data/attachment/album/201707/20/134036ec4ww4o24jozttq3.jpg.thumb.jpg
|
/data/attachment/album/201707/20/134036ec4ww4o24jozttq3.jpg
| true | false | true |
geekpi
| false |
[
"物联网",
"IoT"
] |
观点
|
{
"viewnum": 6465,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
随着 Canonical 重新关注于赢利和新技术，我们中的一些人发现我们正在思考 Linux 未来将走向何方，IoT（物联网）是否是 Linux 的未来？ 本文旨在解决这两个问题。
| 2017-07-20T13:40:49 | 2017-07-20T13:40:49 | 8,710 |
/article-8710-1.html
|
>
> Linux 无疑将在物联网中扮演一个关键角色，但是其光彩将与其它的一些分享。
>
>
>
随着 [Canonical 重新关注于](https://insights.ubuntu.com/2017/04/05/growing-ubuntu-for-cloud-and-iot-rather-than-phone-and-convergence/)赢利和新技术，我们中的一些人发现我们正在思考 Linux 未来将走向何方，IoT（物联网）是否是 Linux 的未来？ 本文旨在解决这两个问题。
### Mycroft 运行于 Linux
对于大多数非技术世界的人来说，实际上有几个不同的 IoT 项目，它们不是我们不断在网络上看到广告的过度商业化的项目，其中最成功的就是 [Mycroft](https://mycroft.ai/) 项目。
使得 Mycroft 有趣的部分原因是你不需要在专门的硬件上得到它。这意味着你可以将其下载到 Raspberry Pi 或甚至您自己的 PC 上。这是物联网领域更常见的来自其它厂商的商业化替代品中所没有出现的自由元素。Mycroft 项目的另一个有趣的事实是，它最初是众筹的，所以从一开始它就是真正的社区驱动的项目。
那么它的技能（skill）——这个用来描述它能力的术语——怎么样？目前，我听到一些褒贬不一的评论。通过查看 Github 上列出的技能，其整个列表似乎相当令人印象深刻。更深层次挖掘的话，很容易看出，它的许多技能比使用专有的 IoT 设备要好。
值得注意的是，为物联网设备开发的官方技能与社区成员开发的功能之间存在明显的区别。Mycroft 的官方技能列表其实很薄弱。让我们面对这个情况，就像 Linux 运行在物联网设备上一样酷，让我大开眼界的是，在 [Mycroft Github](https://github.com/MycroftAI/mycroft-skills) 页面上并没有一个官方的邮件检查技能。好吧，在社区技能部分有一个 Gmail，它带有一个问号，因为它显然没有验证过是否可以工作（或不工作）。
### Google Home - 这是一个包含在谜语中的 Linux 谜题
那么 Google 的物联网产品 Google Home 呢？当然这运行在 Linux上，对吧？是的，在广义上说是这样……事实证明，Google Home [基于 Chromecast](https://www.theverge.com/circuitbreaker/2016/5/31/11822032/google-home-chromecast-android)。那 Chromecast 呢？它是基于 Google TV。我们还在 Linux 的部分么？不完全是。
显然，Chromecast 基本上运行的是 [Android 的精简版](https://www.extremetech.com/computing/162463-chromecast-hacked-its-based-on-google-tv-and-android-not-chrome-os)。而且我们大多数人都知道，Android 确实使用了 Linux 内核的定制版本。
在这一点上，我觉得我们需要问自己 - Google 是我们可以想出的最好的 Linux 物联网代表吗？我认为不是，因为我觉得他们会愿意做出隐私妥协，而这是我们在一个纯粹的 Linux 物联网环境中所不愿见的。 但这只是我个人的信仰。
假设我们愿意接受 Google Home 这种隐私方面的可疑而带来的好处，也假设有在底层有一些可辨识出来的 Linux 成分，那么与 Mycroft 的纯粹的开源体验相比如何呢？
目前，谷歌正在解决这个局面。首先，如果你愿意，你可以安装 Google Home的“大脑”（称为 Google Assistant）到树莓派上。这可以通过 [Google Assistant SDK](https://developers.google.com/assistant/sdk/) 获得。
如你猜的那样，这个 SDK 可以在 Linux 上安装。安装完 portaudio、各种库和用 pip 安装 google-assistant-sdk 之后，你可以开始用树莓派进行通话了，就像 Google Home 设备一样。
回到实际 Google Home 设备本身，你可能会想知道它的可用技能？开箱即用，它提供与 Google Play 音乐、Pandora、Spotify 和 iHeart Radio 以及其他流式音乐服务的音乐播放。Google Home 不仅拥有比 Mycroft 更多的“交流”技能，它还可以与像 Netflix 这样的服务和诸如 Philips、Nest 和 [IFTTT](https://ifttt.com/google_assistant) 等各种智能家居任务的家庭品牌一同工作。我有提到它还可以安排 Google 日历或者订购披萨么？
相比之下，Mycroft 对于想要创造自己的技能的 DIY 开发者来说更好，Google Home 现在可以就开始使用，而不是某一天。
### Amazon Echo 可以运行于 Linux
我首先要承认的是我不知道 Amazon Echo 本身是否运行在 Linux 的某些元素上。也就是说，我知道你可以将 Echo 背后的大脑安装到 Linux 驱动的树莓派上！当[第一次发布派上的版本时](https://www.raspberrypi.org/blog/amazon-echo-homebrew-version/)，有点让人失望的是，你不得不按一个按钮来激活 Echo 的聆听模式。
转眼到了现在，派上的 Echo 现在支持用可编程的“热词”来激活它。这意味着你可以运行一个安装了 Linux 的派，其操作方式与官方 Amazon Echo 相似。然后，如果你买了 Echo Dot，你可以跳过额外的工作，省去在树莓派上安装 Mycroft 的那些极客的东西。
就像 Mycroft 和 Google Home 一样，Amazon Echo 可以在派上使用很重要，因为它使任何人都可以使用物联网技术 - 而不仅仅是那些选择官方硬件的人。而且由于亚马逊已经有更多的时间来开发这项技术，因此，可以说 Echo 是超前于可编程技能竞争以及整体进度的。
所以即使 Google Home 在问题回答上做的更好，但是 Echo 支持更多的第三方物联网设备，有些人认为它比 Google Home 的声音更自然。就个人而言，我认为两台设备的声音听起来都不错。但这只是我的意见。
### 物联网是 Linux 最好的
假如我们用一点时间来继续看看这些与 Linux 兼容的物联网设备或者像 Mycroft 这样真正使用 Linux 的社区伙伴的项目，有一点是可以肯定的，Linux 仍然是等式的一部分。
我认为不使用像 Linux 这样的自由/开放源代码平台是愚蠢的。毕竟，这些设备往往会连接到其他物联网自动化组件。这意味着安全性是一个真正的考虑。在 Linux 下运行物联网意味着我们可以有一个社区确保安全，而不是希望制造商为我们做到这一点。
需要一个例子说明为什么这很重要吗？看看那些不运行开源固件的路由器，当制造商停止支持该设备时会发生什么 - 安全风险开始出现。
物联网是 Linux 的未来吗？在我看来，我认为是……但不是全部。我认为对许多人来说，这是前进的道路。但是最后，我认为在 Linux 之上将会有许多专有的“东西”，只有像 Mycroft 这样纯粹的项目才能保持 Linux。
那么你怎么看？你认为像 Mycroft 这样的开源项目现在与 Google 和 Amazon 的产品在正常竞争么？反之，你觉得还有其他基于 Linux 的产品更适合这项工作么？无论是什么，点击评论，让我们来谈谈。
---
via: <http://www.datamation.com/open-source/is-iot-the-future-of-linux.html>
作者：[Matt Hartley](http://www.datamation.com/author/Matt-Hartley-3080.html) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux Bash 提示符的一些骚操作
|
Dave Neary
|
https://opensource.com/article/17/7/bash-prompt-tips-and-tricks
|
一些能让你自定义 Bash 提示符的黑科技
|
/data/attachment/album/201707/20/214141xon81kq4qm085kk0.png.thumb.jpg
|
/data/attachment/album/201707/20/214141xon81kq4qm085kk0.png
| true | false | true |
toyijiu
| false |
[
"终端",
"命令行提示符"
] |
桌面应用
|
{
"viewnum": 17889,
"commentnum": 7,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "211.102.192.66",
"message": "Bash prompt HOWTO 这个链接找不到了",
"username": "编程浪子 [Chrome 58.0|Windows 7]",
"date": "2017-07-21T09:26:29"
},
{
"postip": "123.120.86.232",
"message": "谢谢提醒，已经更正",
"username": "linux [Chrome 59.0|Mac 10.11]",
"date": "2017-07-21T10:10:17"
},
{
"postip": "118.122.120.11",
"message": "这是我的 PS1 变量设置<br />\r\n<br />\r\n\\[\\033[0m\\]\\n[\\[\\033[0;32m\\]\\w\\[\\033[0m\\]]\\n\\[\\033[0;37m\\]\\u\\[\\033[0;35m\\]@\\[\\033[0;36m\\]\\H\\[\\033[0;37m\\]$ \\[\\033[0m\\]<br />\r\n<br />\r\n需要特别说明的是, <br />\r\n<br />\r\n首先不清楚, 评论系统是否会把某些字符转移或剔掉, 所以尝试时,选个不重要的帐户来测试.<br />\r\n<br />\r\n那些表示颜色的转义符编码, 必须要输入完整, 如果输入不完整, 虽然看起来显示正常, 但是你在输入命令后, 输出的内容会乱掉.<br />\r\n简而言之, 不要把 PS1 设置不当回事, 修改的不正确, 极端条件下会给自己带来麻烦.",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-07-21T10:56:55"
},
{
"postip": "125.79.147.240",
"message": "CentOS，只要设置了PS1，命令行过长，自动换行就出问题了。",
"username": "来自福建三明的 Chrome 59.0|Windows 7 用户",
"date": "2017-07-21T15:33:45"
},
{
"postip": "218.20.136.188",
"message": "这个仅供娱乐",
"username": "来自广东广州的 Chrome 60.0|Mac 10.12 用户",
"date": "2017-08-07T10:32:47"
},
{
"postip": "59.42.36.228",
"message": "\\e[0m 表示恢复系统终端默认颜色，原文上的是\\[\\e[0m\\]才是对的",
"username": "来自广东广州的 Chrome 60.0|Windows 10 用户",
"date": "2017-08-07T22:58:02"
},
{
"postip": "61.186.16.229",
"message": "谢谢，已修复！",
"username": "linux [Chrome 59.0|Mac 10.11]",
"date": "2017-08-08T19:56:41"
}
] |
[] |
一些能让你自定义 Bash 提示符的黑科技
| 2017-07-21T08:40:00 | 2017-07-21T08:40:00 | 8,711 |
/article-8711-1.html
|
>
> 一些能让你自定义 Bash 提示符的黑科技
>
>
>
当你在 Linux 环境下打开一个 Shell 终端时，会看到命令行中出现了类似下面的一个 Bash 提示符：
```
[user@$host ~]$
```
你知道命令行提示符其实是可以自己设置添加许多非常有用的信息的吗？在这篇文章中我就会教你如何自定义自己的 Bash 命令行提示符，想看的话就接着看吧~
### 如何设置 Bash 提示符
Bash 提示符是通过环境变量 `PS1` （<ruby> 提示符字符串 1 <rt> Prompt String 1 </rt></ruby>） 来设置的，它用于交互式 shell 提示符。当然如果你需要更多的输入才能完成一个 Bash 命令时，`PS2` 环境变量就是用来设置多行提示符的：
```
[dneary@dhcp-41-137 ~]$ export PS1="[Linux Rulez]$ "
[Linux Rulez] export PS2="... "
[Linux Rulez] if true; then
... echo "Success!"
... fi
Success!
```
### 在哪里设置 PS1 的值？
`PS1` 就是一个普通的环境变量，系统默认值设置在 `/etc/bashrc` 中，在我的系统中，默认提示符通过以下命令来设置的：
```
[ "$PS1" = "\\s-\\v\\\$ " ] && PS1="[\u@\h \W]\\$ "
```
它判断 `PS1` 是否是系统的默认值 `\s-\v$` ，如果是的话则将值设置为 `[\u@\h \W]\$`。（LCTT 译注：注意命令中用 `\` 做了转义。）
但如果你想要自定义提示符，不应该修改 `/etc/bashrc` ，而是应该在你的主目录下将自定义命令加到 `.bashrc` 文件中。
### 上面提到的 `\u`、`\h`、`\W`、`\s` 和 `\v` 是什么意思？
在 `man bash` 中的 PROMPTING 章节中，你能够找到所有 `PS1` 和 `PS2` 相关的特殊字符的描述，以下是一些比较常用的：
* `\u`：用户名
* `\h`：短主机名
* `\W`：当前你所在的目录的名称（basename），`~` 表示你的主目录
* `\s`：Shell 名字（bash 或者 sh，取决于你的 Shell 的名字是什么）
* `\v`：Shell 的版本号
### 还有哪些特殊的字符串可以用在提示符当中
除了上面这些，还有很多有用的字符串可以用在提示符当中：
* `\d`：将日期扩展成 “Tue Jun 27” 这种格式
* `\D{fmt}`：允许自定义日期格式——可通过 `man strftime` 来获得更多信息
* `\D{%c}`：获得本地化的日期和时间
* `\n`：换行（参考下面的多行提示符）
* `\w`：显示当前工作目录的完整路径
* `\H`：当前工作机器的完整主机名
除了以上这些，你还可以在 Bash 的 man 页面的 PROMPTING 部分找到更多的特殊字符和它的用处。
### 多行提示符
如果你的提示符过长（比如说你想包括 `\H` 、`\w` 或完整的日期时间时 ），想将提示符切成两行，可以使用 `\n` 将提示符切断成两行显示，比如下面的多行的例子会在第一行显示日期、时间和当前工作目录，第二行显示用户名和主机名：
```
PS1="\D{%c} \w\n[\u@\H]$ "
```
### 还能再好玩点吗？
人们偶尔也想将提示符变成彩色的。虽然我觉得彩色提示符让人分心、易怒，但是也许你很喜欢。如果我们想将日期变成红色的，目录变成青蓝色，用户名搞一个黄色背景，你可以这样做：
```
PS1="\[\e[31m\]\D{%c}\[\e[0m\]
\[\e[36m\]\w\[\e[0m\]\n[\[\e[1;43m\]\u\[\e[0m\]@\H]$ "
```
* `\[..\]` ：表示一些非打印字符
* `\e[..` ：转义字符，后面的跟着的特定的转义字符串在终端中表示颜色或者其他意思
* `31m` ：表示红色字体（`41m` 表示是红色背景）
* `36m` ：表示是青蓝色字体
* `1;43m` ：表示黄色字体（`1;33m` 表示黄色字体）
* `\[\e[0m]\]` ：它在最后将颜色恢复成系统终端默认颜色
你可以在 [Bash prompt HOWTO](http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x329.html) 这里找到更多的颜色代码，甚至可以让字符反相和闪烁！我不知道为什么地球人会有这种想法，但是你可以这么干！
所以你最喜欢的自定义提示符是什么样子的呢？有没有让你抓狂的自定义提示符呢？请在评论里告诉我吧~
（照片来源：[ajmexico](https://www.flickr.com/photos/15587432@N02/3281139507/). 修改自 [Jason Baker](https://opensource.com/users/jason-baker). [CC BY-SA 2.0](https://creativecommons.org/licenses/by/2.0/).）
---
作者简介：
Dave Neary - Dave Neary 是红帽开源和标准化团队成员，帮助开源项目对红帽的成功至关重要。自从在 1999 年为 GIMP 提交了第一个补丁以来，他一直带着各种不同的帽子，在开源的世界徜徉。
---
via: <https://opensource.com/article/17/7/bash-prompt-tips-and-tricks>
作者：[Dave Neary](https://opensource.com/users/dneary) 译者：[吴霄/toyijiu](https://github.com/toyijiu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
安卓编年史（31）：安卓 6.0 棉花糖
|
Ron Amadeo
|
http://arstechnica.com/gadgets/2016/10/building-android-a-40000-word-history-of-googles-mobile-os/31/
|
2015 年 10 月，谷歌给世界带来了安卓 6.0 棉花糖。配合这个版本的发布，谷歌委托生产了两部新的 Nexus 设备：华为 Nexus 6P 和 LG Nexus 5X。
|
/data/attachment/album/201707/21/095454aommldzasmdyr5tb.jpg.thumb.jpg
|
/data/attachment/album/201707/21/095454aommldzasmdyr5tb.jpg
| true | false | true |
alim0x
| false |
[
"Android",
"安卓编年史"
] |
观点
|
{
"viewnum": 4694,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8698,
"displayorder": 0
},
{
"raid": 8725,
"displayorder": 0
}
] |
2015 年 10 月，谷歌给世界带来了安卓 6.0 棉花糖。配合这个版本的发布，谷歌委托生产了两部新的 Nexus 设备：华为 Nexus 6P 和 LG Nexus 5X。
| 2017-07-21T10:06:47 | 2017-07-21T10:06:47 | 8,712 |
/article-8712-1.html
|
### 安卓 6.0 棉花糖
2015 年 10 月，谷歌给世界带来了安卓 6.0 棉花糖。配合这个版本的发布，谷歌委托生产了两部新的 Nexus 设备：[华为 Nexus 6P 和 LG Nexus 5X](http://arstechnica.com/gadgets/2015/10/nexus-5x-and-nexus-6p-review-the-true-flagships-of-the-android-ecosystem/)。除了常规的性能升级，新手机还带有一套关键硬件：为棉花糖的新指纹 API 准备的指纹识别器。棉花糖还引入了一个疯狂的全新搜索特性，被称作“Google Now on Tap”，用户控制的应用权限，一个全新的数据备份系统，以及许多其它的改良。
#### 新谷歌应用
棉花糖是[谷歌大标志重新设计](http://arstechnica.com/gadgets/2015/09/google-gets-a-new-logo/)后的第一个安卓版本。系统也随之升级，主要是一个新的谷歌应用，给搜索小部件，搜索页面以及应用图标添加了一个多彩的标志。
谷歌将应用抽屉从页面导航的横向布局还原回了单页竖直滚动表的形式。早期版本的安卓用的都是竖直滚动表的形式，直到谷歌在蜂巢中改成了横向页面系统。滚动单页面让人更容易从很多应用中找到目标。一项“快速滚动”的特性同样好用，它可以让你拖动滚动条来激活字母索引。新的应用抽屉布局也用到了小部件抽屉上。考虑到旧系统中小部件轻松就超过了 15 页，这是个大改进。
棉花糖应用抽屉顶部的“建议应用”栏也让查找应用变得更快。该栏显示的内容一直在变化，试图在你需要的时候为你提供你需要的应用。它使用了算法来统计应用使用，经常一起打开的应用以及每天的打开次数。
#### Google Now on Tap——一个没有完美实现的特性
棉花糖的头等新特性之一就是“Google Now on Tap”。有了 Now on Tap，你可以在安卓的任意界面长按 home 键，安卓会将整个屏幕发送给谷歌进行处理。谷歌会试着分析页面上的内容，并从屏幕底部弹出显示一个特殊的搜索结果列表。
Now on Tap 产生的结果不是通常的 10 个蓝色链接——即便那必定有一个通往谷歌搜索的链接。Now on Tap 还可以深度连接到其它使用了谷歌的应用索引功能的应用。他们的想法是你可以在 Youtube 音乐视频那里唤出 Now on tap，然后获得一个到谷歌 Play 或亚马逊“购买”页面的链接。在演员新闻文章处唤出 Now on Tap 可以链接到 IMDb 应用中该演员的页面上。
谷歌没有让这成为私有特性，而是给安卓创建了一个全新的“Assistant API（助理 API）”。用户可以挑选一个“助理应用”，它可以在长按 home 键的时候获取很多信息。助理应用会获取所有由当前应用加载的数据——不仅是直接从屏幕获取到的——连同所有这些图片还有任何开发者想要包含的元数据。这个 API 驱动了谷歌 Now on Tap，如果愿意的话，它还允许第三方打造 Now on Tap 的竞争对手。
谷歌在棉花糖的发布会上炒作了 Now on Tap，但实际上，这项特性不是很实用。谷歌搜索的价值在于你可以问它准确的问题——你输入你想要的内容，它搜索整个互联网寻找答案或网页。Now on Tap 让事情变得无限困难，因为它甚至不知道你要问的是什么。你带着特定意图打开了 Now on Tap，但你发送给谷歌的查询是很不准确的“屏幕上的所有内容”。谷歌需要猜测你查询的内容然后试着基于它给出有用的结果或操作。
在这背后，谷歌可能在疯狂处理整个页面文字和图片来强行获得你想要的结果。但往往 Now on Tap 给出的结果像是页面每个合适的名词的搜索结果列表。从结果列表中筛选多个查询就像是陷入必应的“[搜索结果过载](https://www.youtube.com/watch?v=9yfMVbaehOE)”广告里那样的情形。查询目标的缺失让 Now on Tap 感觉像是让谷歌给你读心，而它永远做不到。谷歌最终给文本选中菜单打了补丁，添加了一个“助理”按钮，给 Now on Tap 提供一些它极度需要的搜索目标。
不得不说 Now on Tap 是个失败的产物。Now on Tap 的快捷方式——长按 home 键——基本上让它成为了一个隐藏，难以发现的特性，很容易就被遗忘了。我们推测这个特性的使用率非常低。即便用户发现了 Now on Tap，它经常没法读取你的想法，在几次尝试之后，大多数用户可能会选择放弃。
随着 2016 年 Google Pixels 的发布，谷歌似乎承认了失败。它把 Now on Tap 改名成了“屏幕搜索”并把它降级成了谷歌助手的支援。谷歌助理——谷歌的新语音命令系统——接管了 Now on Tap 的 home 键手势并将它关联到了语音系统激活后的二次手势。谷歌似乎还从 Now on Tap 差劲的可发现性中学到了教训。谷歌给助理给 home 键添加了一组带动画的彩点，帮助用户发现并记住这个特性。
#### 权限
安卓 6.0 终于引入了应用权限系统，让用户可以细粒度地控制应用可以访问的数据。
应用在安装的时候不再给你一份长长的权限列表。在棉花糖中，应用安装根本不询问任何权限。当应用需要一个权限的时候——比如访问你的位置、摄像头、麦克风，或联系人列表的时候——它们会在需要用到的时候询问。在你使用应用的时候，如果需要新权限时会弹出一个“允许或拒绝”的对话框。一些应用的设置流程这么处理：在启动的时候询问获取一些关键权限，其它的等到需要用到的时候再弹出提示。这样更好地与用户沟通了需要权限是为了做什么——应用需要摄像头权限，因为你刚刚点击了摄像头按钮。
除了及时的“允许或拒绝”对话框，棉花糖还添加了一个权限设置界面。这个复选框大列表让数据敏感用户可以浏览应用拥有的权限。他们不仅可以通过应用来查询，也可以通过权限来查询。举个例子，你可以查看所有拥有访问麦克风权限的应用。
谷歌试验应用权限已经有一段时间了，这些设置界面基本就是隐藏的“[App Ops](http://www.androidpolice.com/2013/07/25/app-ops-android-4-3s-hidden-app-permission-manager-control-permissions-for-individual-apps/)”系统的重生，它是在安卓 4.3 中不小心引入并很快被移除的权限管理系统。
尽管谷歌在之前版本就试验过了，棉花糖的权限系统最大的不同是它代表了一个向权限系统的有序过渡。安卓 4.3 的 App Ops 从没有计划暴露给用户，所以开发者不了解它。在 4.3 中拒绝一个应用需要的一个权限经常导致奇怪的错误信息或一个彻底的崩溃。棉花糖的系统对开发者是缺省的——新的权限系统只适用于针对棉花糖 SDK 开发的应用，谷歌将它作为开发者已经为权限处理做好准备的信号。权限系统还允许在一项功能由于权限被拒绝无法正常工作时与用户进行沟通。应用会被告知它们的权限请求被拒绝，它们可以指导用户在需要该功能的时候去打开该权限访问。
#### 指纹 API
在棉花糖出现之前，少数厂商推出了他们自己的指纹解决方案以作为对[苹果的 Touch ID](http://arstechnica.com/apple/2014/09/ios-8-thoroughly-reviewed/10/#h3) 的回应。但在棉花糖中，谷歌终于带来了生态级别的指纹识别 API。新系统包含了指纹注册界面，指纹验证锁屏以及允许应用将内容保护在一个指纹扫描或锁屏验证之后的 API。
Play 商店是最先支持该 API 的应用之一。你可以使用你的指纹来购买应用，而不用输入你的密码。Nexus 5X 和 6P 是最先支持指纹 API 的手机，手机背面带有指纹读取硬件。
指纹 API 推出不久后时间，是罕见的安卓生态合作例子之一。所有带有指纹识别的手机都使用谷歌的 API，并且大多数银行和购物应用都很好地支持了它。
---
[Ron Amadeo](http://arstechnica.com/author/ronamadeo) / Ron 是 Ars Technica 的评论编缉，专注于安卓系统和谷歌产品。他总是在追寻新鲜事物，还喜欢拆解事物看看它们到底是怎么运作的。[@RonAmadeo](https://twitter.com/RonAmadeo)
---
via: <http://arstechnica.com/gadgets/2016/10/building-android-a-40000-word-history-of-googles-mobile-os/31/>
作者：[RON AMADEO](http://arstechnica.com/author/ronamadeo) 译者：[alim0x](https://github.com/alim0x) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Libral：一个提供资源和服务统一管理 API 的系统管理库
|
David Lutterkort
|
https://opensource.com/article/17/5/intro-libral-systems-management-library-linux
|
Libral 为系统资源和服务提供了一个统一的管理 API ，其可以作为脚本管理任务和构建配置管理系统的坚实基础。
|
/data/attachment/album/201707/22/123246fq1quubu19a93b1z.png.thumb.jpg
|
/data/attachment/album/201707/22/123246fq1quubu19a93b1z.png
| true | false | true |
stevenzdg988
| false |
[
"Libral",
"Puppet",
"Ansible"
] |
技术
|
{
"viewnum": 5984,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Libral 为系统资源和服务提供了一个统一的管理 API ，其可以作为脚本管理任务和构建配置管理系统的坚实基础。
| 2017-07-22T12:32:42 | 2017-07-22T12:32:42 | 8,714 |
/article-8714-1.html
|
>
> Libral 为系统资源和服务提供了一个统一的管理 API ，其可以作为脚本管理任务和构建配置管理系统的坚实基础。
>
>
>
作为继承了 Unix 的传统的 Linux 操作系统，其并没有一个综合的系统管理 API 接口，相反，管理操作是通过多种特定用途的工具和 API 来实现的，其每一个都有自己约定和特有的风格。这就使得编写一个哪怕是简单的系统管理任务的脚本也很困难、很脆弱。
举个例子来说，改变 “app” 用户的登录 shell 要运行 `usermod -s /sbin/nologin app`。这个命令通常没有问题，只是当系统上没有 “app” 用户时就不行了。为了解决这个例外错误，具有创新精神的脚本编写者也许要这样写：
```
grep -q app /etc/passwd \
&& usermod -s /sbin/nologin app \
|| useradd ... -s /sbin/nologin app
```
这样，当 “app” 用户存在于系统中时，会执行更改登录 shell 的操作；而当此用户不存在时，就会创建此用户。不幸的是，这种编写系统管理任务脚本的方式是不适合的：对于每一种资源来说都会有一套不同的工具，而且每个都有其不同的使用惯例；不一致性和经常出现的不完备的错误报告将会使错误的处理变得困难；再者也会因为工具自身的特性引发的故障而导致执行失败。
实际上，以上所举的例子也是不正确的：`grep` 并不是用来查找 “app” 用户的，它只能在文件 `/etc/passwd` 的一些行中简单的查找是否有字符串 “app”，在大多数情况下它或许可以工作，但是也可能会在最关键的时刻出错。
很显然，那些执行简单任务的脚本管理工具，很难成为大型管理系统的基础。认识到这一点，现有的配置管理系统，比如 Puppet、Chef 及 Ansible，围绕基本的操作系统资源的管理竭尽全力的建立其内部 API 就是明智之举。这些资源抽象是内部 API，其与所需的相应工具密切相关。但这不仅导致大量的重复性工作，也为尝试一个新创新的管理工具设置了强大的障碍。
在创建虚拟机或者容器镜像这一领域，这种障碍就变得非常明显：比如在创建镜像的过程中，就要么需要回答关于它们的简单问题，要么需要对其进行简单的更改才行。但是工具全都需要特别处理，那些所遇到的问题和更改需要用脚本逐个处理。因此，镜像构建要么依靠特定的脚本，要么需要使用（和安装）一个相当强大的配置管理系统。
[Libral](https://github.com/puppetlabs/libral) 将为管理工具和任务提供一个可靠的保证，通过对系统资源提供一个公用的管理 API，并使其可以通过命令行工具 `ralsh` 使用，它允许用户按照相同的方法查询和修改系统资源，并有可预见的错误报告。对以上的举例来说，可以通过命令 `ralsh -aq user app` 检查 “app” 用户是否存在；通过 `ralsh -aq package foo` 检查 “foo” 软件包是否已经安装；一般情况下，可以通过命令 `ralsh -aq TYPE NAME` 检查 ”NAME“ 是否是 ”TYPE“ 类型的资源。类似的，要创建或更改已存在的用户，可以运行：
```
ralsh user app home=/srv/app shell=/sbin/nologin
```
以及，要在文件 `/etc/hosts` 创建和修改条目，可以运行命令：
```
ralsh hostmyhost.example.com ip=10.0.0.1 \
host_aliases=myhost,apphost
```
以这种方式运行，“ralsh” 的使用者事实上完全隔离在那两个命令内部的不同运行工作机制之外：第一个命令需要适当的调用命令 `useradd` 或者 `usermod`，而第二个需要在 `/etc/hosts` 文件中进行编辑。而对于该用户来说，他们似乎都采取同样的模型：“确保资源处于我所需要的状态。”
### 怎样获取和使用 Libral 呢？
Libral 可以在[这个 git 仓库](https://github.com/puppetlabs/libral)找到并下载。其核心是由 C++ 编写的，构建它的说明可以[在该仓库中](https://github.com/puppetlabs/libral#building-and-installation)找到，不过只是在你想要为 Libral 的 C++ 核心做贡献的时候才需要看它。Libral 的网站上包含了一个 [预构建的 tarball](http://download.augeas.net/libral/ralsh-latest.tgz)，可以用在任何使用 “glibc 2.12” 或者更高版本的 Linux 机器上。可以使用该 “tarball” 的内容进一步探究 ralsh ，以及开发新的提供者（provider），它使得 Libral 具备了管理新类型资源的能力。
在下载解压 tarball 后，在目录 `ral/bin` 下能找到 `ralsh` 命令。运行不需要任何参数的 `ralsh` 命令就会列举出来 Libral 的所有资源类型。利用 `--help` 选项可以打印输出关于 `ralsh` 的更多说明。
### 与配置管理系统的关系
知名的配置管理系统，如 Puppet、Chef 及 Ansible，解决了一些 Libral 所解决的同样的问题。将 Libral 与它们的区分开的主要是它们所做工作和 Libral 不同。配置管理系统被构建来处理跨大量节点管理各种事物的多样性和复杂性。而另一方面 Libral 旨在提供一个定义明确的低级别的系统管理 API ，独立于任何特定的工具，可用于各种各样的编程语言。
通过消除大型配置管理系统中包含的应用程序逻辑，Libral 从前面介绍里提及的简单的脚本任务，到作为构建复杂的管理应用的构建块，它在如何使用方面是非常灵活的。专注与这些基础层面也使其保持很小，目前不到 2.5 MB，这对于资源严重受限的环境，如容器和小型设备来说是一个重要考虑因素。
### Libral API
在过去的十年里，Libral API 是在实现配置管理系统的经验下指导设计的，虽然它并没有直接绑定到它们其中任何一个应用上，但它考虑到了这些问题，并规避了它们的缺点。
在 API 设计中四个重要的原则：
* 期望的状态
* 双向性
* 轻量级抽象
* 易于扩展
基于期望状态的管理 API，举个例子来说，用户表示当操作执行后希望系统看起来是什么状态，而不是怎样进入这个状态，这一点什么争议。双向性使得使用（读、写）相同的 API 成为可能，更重要的是，相同的资源可以抽象成读取现有状态和强制修改成这种状态。轻量级抽象行为确保能容易的学习 API 并能快速的使用；过去在管理 API 上的尝试过度加重了学习建模框架的使用者的负担，其中一个重要的因素是他们的接受力缺乏。
最后，它必须易于扩展 Libral 的管理功能，这样用户可以教给 Libral 如何管理新类型的资源。这很重要，因为人们也许要管理的资源可能很多（而且 Libral 需要在适当时间进行管理），再者，因为即使是完全成熟的 Libral 也总是存在达不到用户自定义的管理需求。
目前与 Libral API 进行交互的主要方式是通过 `ralsh` 命令行工具。它也提供了底层的 C++ API ，不过其仍处在不断的演变当中，主要的还是为简单的脚本任务做准备。该项目也提供了为 CRuby 提供语言绑定，其它语言也在陆续跟进。
未来 Libral 还将提供一个提供远程 API 的守护进程，它可以做为管理系统的基础服务，而不需要在管理节点上安装额外的代理。这一点，加上对 Libral 管理功能的定制能力，可以严格控制系统的哪些方面可以管理，哪些方面要避免干扰。
举个例子来说，一个仅限于管理用户和服务的 Libral 配置会避免干扰到在节点上安装的包。当前任何现有的配置管理系统都不可能控制以这种方式管理的内容；尤其是，需要对受控节点进行任意的 SSH 访问也会将该系统暴露不必要的意外和恶意干扰。
Libral API 的基础是由两个非常简单的操作构成的：“get” 用来检索当前资源的状态，“set” 用来设置当前资源的状态。理想化地实现是这样的，通过以下步骤：
```
provider.get(names) -> List[resource]
provider.set(List[update]) -> List[change]
```
“provider” 是要知道怎样管理的一种资源的对象，就像用户、服务、软件包等等，Libral API 提供了一种查找特定资源的<ruby> 管理器 <rp> （ </rp> <rt> provider </rt> <rp> ） </rp></ruby>的方法。
“get” 操作能够接收资源名称列表（如用户名），然后产生一个资源列表，其本质来说是利用散列的方式列出每种资源的属性。这个列表必须包含所提供名称的资源，但是可以包含更多内容，因此一个简单的 “get” 的实现可以忽略名称并列出所有它知道的资源。
“set” 操作被用来设置所要求的状态，并接受一个更新列表。每个更新可以包含 “update.is”，其表示当前状态的资源，“update.should” 表示被资源所期望的状态。调用 “set” 方法将会让更新列表中所提到的资源成为 “update.should” 中指示的状态，并列出对每个资源所做的更改。
在 `ralsh` 下，利用 `ralsh user root` 能够重新获得 “root” 用户的当前状态；默认情况下，这个命令会产生一个用户可读的输出，就像 Puppet 中一样，但是 `ralsh` 支持 `--json` 选项，可以生成脚本可以使用的 JSON 输出。用户可读的输出是：
```
# ralsh user root
user::useradd { 'root':
ensure => 'present',
comment => 'root',
gid => '0',
groups => ['root'],
home => '/root',
shell => '/bin/bash',
uid => '0',
}
```
类似的，用户也可以用下面的形式修改：
```
# ralsh user root comment='The superuser'
user::useradd { 'root':
ensure => 'present',
comment => 'The superuser',
gid => '0',
groups => ['root'],
home => '/root',
shell => '/bin/bash',
uid => '0',
}
comment(root->The superuser)
```
`ralsh` 的输出列出了 “root” 用户的新状态和被改变的 `comment` 属性，以及修改了什么内容（在这种情形下单指 `comment` 属性）。下一秒运行相同的命令将产生同样的输出，但是不会提示修改，因为没有需要修改的内容。
### 编写<ruby> 管理器 <rp> （ </rp> <rt> provider </rt> <rp> ） </rp></ruby>
为 `ralsh` 编写新的管理器（provider）<ruby> <rp> （ </rp> <rt> </rt> <rp> ） </rp></ruby>是很容易的，也花费不了多少工夫，但是这一步骤是至关重要的。正因为如此，`ralsh` 提供了大量的调用约定，使得可以根据管理器所能提供的能力而调整其实现复杂性成为可能。管理器可以使用遵循特定调用约定的外部脚本，也可以以 C++ 实现并内置到 Libral 里面。到目前为止，有三种调用约定：
* [simple](https://github.com/puppetlabs/libral/blob/master/examples/providers/python.prov) 调用约定是编写 shell 脚本用为管理器。
* [JSON](https://github.com/puppetlabs/libral/blob/master/doc/invoke-json.md) 调用约定意味着可以利用 Ruby 或者 Python 脚本语言编写管理器。
* [内部 C++ API[8](https://github.com/puppetlabs/libral/blob/master/doc/invoke-native.md) 可以被用来实现原生的管理器。
强烈建议使用 “simple” 或者 “JSON” 调用约定开始开发管理器。GitHub 上的 [simple.prov](https://github.com/puppetlabs/libral/blob/master/examples/providers/simple.prov) 文件包含了一个简单的 shell 管理器框架，应该很容易的替换为你自己的管理器。[python.prov](https://github.com/puppetlabs/libral/blob/master/examples/providers/python.prov) 文件包含了利用 Python编写的 JSON 管理器框架。
利用高级脚本语言编写的管理器存在一个问题是，对于这些语言，在当前运行 Libral 的系统上需要包含所有的支持库在内运行环境。在某些情况下，这不是一个障碍；举例子来说，基于 “yum” 的包管理的管理器需要 Python 被安装在当前的系统上，因为 “yum” 就是用 Python 开发的。
然而在很多时候，无法预期一种 Bourne shell（Bash）之外的设计语言能够安装到所有的管理系统上。通常，管理器的编写者需要一个更加强大的脚本编译环境是实际需要。然而事与愿违，绑定一个完整的 Ruby 或 Python 作为解释器来运行将会增加 Libral 的大小超出了实际使用环境对资源的限制。另一方面，通常选择 Lua 或者 JavaScript 作为可嵌入的脚本编辑语言是不适应这种环境的，因为大多数的管理器的编写者不熟悉他们，通常情况下需要做大量的工作才能满足系统管理的实际需求。
Libral 绑定了一个 [mruby](http://mruby.org/) 版本，一个小的、嵌入在 Ruby 的版本，提供给管理器的编写者一个稳定的基础以及功能强大的可实现的程序设计语言。mruby 是 Ruby 语言的一个完整实现，尽管其减少了大量的标准库支持。与 Libral 绑定的 mruby 包含了 Ruby 用于脚本编辑管理任务的大多数的重要标准库，其将基于管理器编写者的需求随着时间的推移得到加强。Libral 的 mruby 绑定了 API 适配器使编写管理器更适合 JSON 约定，比如它包含了简单的工具（如编译修改结构体文件的 [Augeas](http://augeas.net/)）来解决解析和输出 JSON 的约定。[mruby.prov](https://github.com/puppetlabs/libral/blob/master/examples/providers/mruby.prov) 文件包含了利用 mruby 编写的 JSON 管理器框架实例。
### 下一步工作
Libral 最关键的是下一步要使其增加广泛的可用性——从 [预编译的 tarball](http://download.augeas.net/libral/ralsh-latest.tgz) 对于开发管理器的起步和深入是一个不错的方法，但是 Libral 也需要打包到主流的发行版上，并在上面可以找到。同样的，Libral 强大的功能取决于它附带的管理器的集合，及需要被扩展覆盖一组核心管理功能。Libral 的网站上包含了[一个 todo 列表](https://github.com/puppetlabs/libral#todo-list)列出了管理器的最迫切需求。
现在有多种方法能够提高不同用途的 Libral 的可用性：从编写更多程序语言的绑定，举例来说，Python 或者 Go；到使 `ralsh` 更容易在 shell 脚本中使用，除了现有的可读输出和 JSON 输出之外，可以很轻松的在 shell 脚本中格式化输出。在大规模的管理中使用 Libral 也能够在增加上面讨论过的远程 API 而得到改良，Libral 利用像 SSH 这样的传输工具实现更好的支持批量安装要求为各种架构提供预编译的 tarball，并且脚本基于所发现的目标系统架构选择正确的包。
Libral 和它的 API、它的性能能够不断地进化发展；一个有趣的可能性是为 API 增加提醒能力，这样做可以向系统报告资源在超出它的范围发生的变化。Libral 面临的挑战是保持小型化、轻量级和良好定义的工具，来对抗不断增加的用例和管理性能——我希望每一个读者都能成为这个挑战之旅的一部分。
如果这让你很好奇，我很想听听你的想法，可以用拉取请求的方式，也可以是增强请求方式，亦或者报告你对 ralsh 体验经验。
（题图：[Internet Archive Book Images](https://www.flickr.com/photos/internetarchivebookimages/14803082483/in/photolist-oy6EG4-pZR3NZ-i6r3NW-e1tJSX-boBtf7-oeYc7U-o6jFKK-9jNtc3-idt2G9-i7NG1m-ouKjXe-owqviF-92xFBg-ow9e4s-gVVXJN-i1K8Pw-4jybMo-i1rsBr-ouo58Y-ouPRzz-8cGJHK-85Evdk-cru4Ly-rcDWiP-gnaC5B-pAFsuf-hRFPcZ-odvBMz-hRCE7b-mZN3Kt-odHU5a-73dpPp-hUaaAi-owvUMK-otbp7Q-ouySkB-hYAgmJ-owo4UZ-giHgqu-giHpNc-idd9uQ-osAhcf-7vxk63-7vwN65-fQejmk-pTcLgA-otZcmj-fj1aSX-hRzHQk-oyeZfR)，修改：Opensource.com. CC BY-SA 4.0）
---
作者简介：
David Lutterkort - 戴维是一个 Puppet 的软件工程师，他曾经参与的项目有 Direct Puppet 和最好的供给工具 Razor。他是 Puppet 最早的编著者之一，也是配置编辑工具 Augeas 的主要作者。
---
via: <https://opensource.com/article/17/5/intro-libral-systems-management-library-linux>
作者：[David Lutterkort](https://opensource.com/users/david-lutterkort) 译者：[stevenzdg988](https://github.com/stevenzdg988) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Nylas Mail： 一个 Linux 的免费邮件客户端
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/nylas-mail-an-amazing-free-email-client-for-linux
|
Geary、Empathy、Evolution 和 Thunderbird 本身已经为很多用户提供了很好的服务，但是我发现了值得一试的东西：它被称为 Nylas Mail。
|
/data/attachment/album/201707/22/233255td8uc8ywud4r2vru.jpg.thumb.jpg
|
/data/attachment/album/201707/22/233255td8uc8ywud4r2vru.jpg
| true | false | true |
geekpi
| false |
[
"邮件"
] |
分享
|
{
"viewnum": 33095,
"commentnum": 9,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "125.84.1.14",
"message": "之前在arch里面，不能收取gmail就放弃了，改用chrome的checker plus for gmail",
"username": "龙尘飘 [Chrome 59.0|Windows 10]",
"date": "2017-07-23T21:42:03"
},
{
"postip": "182.40.131.225",
"message": "N1是今年（2017年）1月份推出的？<br />\r\n<br />\r\n我怎么记得至少1年之前我就弃用过呢？",
"username": "来自山东青岛的 Chrome 59.0|Mac 10.12 用户",
"date": "2017-07-24T08:56:39"
},
{
"postip": "119.114.75.217",
"message": "作者说的是Nylas Mail 是今年1月推出的，在那之前叫N1！",
"username": "愉欣 [Chrome 61.0|GNU/Linux]",
"date": "2017-07-24T12:04:38"
},
{
"postip": "116.31.81.182",
"message": "这么多年下来，用着最顺手的还是thunderbird。。",
"username": "来自广东广州的 Firefox 54.0|Ubuntu 用户",
"date": "2017-07-24T12:49:07"
},
{
"postip": "113.109.79.217",
"message": "nice !!!",
"username": "来自广东广州的 Chrome 50.0|Android 7.1 用户",
"date": "2017-07-24T17:13:25"
},
{
"postip": "113.87.13.216",
"message": "我已付费，但是后面还是没用起来，我每天要收5个不同邮箱发的邮件，Mac平台，这货算是我见过很漂亮的了，我就是冲着他的漂亮冲动的付了款，完后，收国外的有邮箱还行，国内有时候收不到，只能用回我的网页版收，不过，网易现在出mac版的，以前没有，所以，现在在用它",
"username": "来自广东深圳的 Chrome Mobile 40.0|Android 7.0 用户",
"date": "2017-07-24T23:16:34"
},
{
"postip": "223.104.63.45",
"message": "用thunderbird的路过",
"username": "hnsncxy [Chrome Mobile 45.0|Android 5.1]",
"date": "2017-07-25T08:15:38"
},
{
"postip": "222.76.241.20",
"message": "用不习惯！",
"username": "7th [Chrome 58.0|GNU/Linux]",
"date": "2017-07-27T14:40:20"
},
{
"postip": "117.139.251.193",
"message": "geary 简单实用 我用不惯太复杂的",
"username": "来自四川成都的 Firefox 55.0|GNU/Linux 用户",
"date": "2017-08-31T17:06:07"
}
] |
[] |
Geary、Empathy、Evolution 和 Thunderbird 本身已经为很多用户提供了很好的服务，但是我发现了值得一试的东西：它被称为 Nylas Mail。
| 2017-07-23T09:31:00 | 2017-07-23T09:31:00 | 8,715 |
/article-8715-1.html
|
[](http://www.linuxandubuntu.com/home/nylas-mail-an-amazing-free-email-client-for-linux)
有一个经常被提及的问题是 Ubuntu 是否还应该提供默认的电子邮件客户端。就个人而言，我已经很长时间没有使用 [Thunderbird](http://www.linuxandubuntu.com/home/thunderbird-release-with-several-bug-fixes) 了。我相信这不是一个第一次被问到的问题，但我相信这是一个把它解决掉的很好机会。这是因为日常用户倾向于使用基于网络的客户端，例如 Gmail 或 Outlook 来满足其邮件需求。而对于 Linux 上的经验丰富的用户而言，还有很多可供选择的选项。[Geary](http://www.linuxandubuntu.com/home/geany-a-lightweight-ide-or-code-editor-for-programmers)、Empathy、Evolution 和 Thunderbird 本身已经为很多用户提供了很好的服务，但是我发现了值得一试的东西：它被称为 Nylas Mail。
它以前被称为 [Nylas N1](http://www.linuxandubuntu.com/home/nylas-n1-a-premium-email-client-for-linux)，Nylas Mail 于今年初在 1 月份推出，同时还发布了一个免费版本；**Nylas Mail** Basic 以前是一个付费版本。此外，在 1 月份，客户端仅适用于 Mac，但现在可用于 Linux 和 Windows 用户。
（在我写此文时，它还处于活跃开发状态，但是现在已经停止开发了。）
### 为什么使用 Nylas？
很多人因为种种原因选择了 Nylas Mail。让我们来看看一些常见的原因。
**简单** - Nylas Mail 客户端管理优雅简单。用 electron 构建，应用非常漂亮，易于使用。其设计还确保了在 Nylas 中设置电子邮件非常简单直接。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/nylas-mail-an-awesome-email-client-for-linux_orig.jpg)
**兼容性** - Nylas Mail 与所有电子邮件提供商兼容。它与 Gmail、Yahoo、Exchange 和 IMAP 帐户兼容，因此你可以在任何地方收到邮件。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/nylas-compatible-with-gmail-facebook-imap_orig.jpg)
**功能强大** - Nylas 拥有大量功能。它有一个全屏模式、离线支持、多布局格式、多帐户、统一的收件箱、提醒、打盹、签名和稍后发送功能。其中一些功能随 Nylas Mail Basic 一起提供。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/nylas-email-client-powerful-features_orig.jpg)
**混合后端** - 以前，Nylas 将邮件的一个副本同步到使用 Nylas 云的服务器中，这对许多人来说就像 mehn 一样。幸运的是，在最新版本中，Nylas 采用了一个混合后端，可直接连接到 Gmail 或 Outlook 等电子邮件提供商。云同步虽然仍然可用，但仅在使用高级订阅工具（如<ruby> 打盹 <rt> snoozing </rt></ruby>和跟踪）时使用。缺点是它是一而二的。如果想要一些专业功能，你需要云同步；你不想用云同步，那你错过了这些功能。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/nylas-email-hybrid-backend_orig.jpg)
**开源和免费版** - Nylas 作为开源项目。这意味着你可以自己编写代码并自行构建。你甚至可以设置自己的服务器以回避问题。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/nylas-open-source-and-free-email-client_orig.jpg)
**跨平台** - Nylas 是在 Linux、Windows 和 Mac OS X 上提供的跨平台应用程序。因此，无论你喜欢哪种桌面操作系统，你都可以放心，因为 Nylas 都已经覆盖了。而且用法是相同的。
### 还要做些什么？
到目前为止，Nylas 邮件客户端很好，但有一些抱怨。首先是在 2016 年推出的付费选项。引入免费版本有点像是这个解决这个问题的方案，但事实上，一些功能只能以每月 $9 的价格使用让包括我在内的大部分人不快。此外，没有多少人喜欢将邮件的副本保存在某台服务器上。当然，你可以设置自己的服务器，但有些麻烦。最后，对于在后台运行的应用程序来说，它需要相当多的内存。我希望这不是因为它主要是用 electron 写的，我相信随着它的更新和改进，它会变得更好。
### 总结
**Nylas Mail** 在特性和功能方面对我来说非常棒，我相信你一定要用一下。作为一个电子邮件客户端，它是非常有效的，我真的很喜欢 Nylas Mail，并且一定会一直使用它。也许你应该也会。向开发人员的所做的工作致谢。你有其他的程序想让我们看下么？在下面的评论中指出，并分享你的想法和意见。
---
via: <http://www.linuxandubuntu.com/home/nylas-mail-an-amazing-free-email-client-for-linux>
作者：[linuxandubuntu](http://www.linuxandubuntu.com/home/nylas-mail-an-amazing-free-email-client-for-linux) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
拯救者 Linux：我是如何给我的团队引入 Linux 的
|
Jim Hall
|
https://opensource.com/article/17/7/how-introduced-organization-linux
|
在项目早期就遇到公开的失败后，一个著名大学的 IT 团队决定将他们的 web 注册系统部署到 Linux上，此举几乎将服务器的最大用户访问量提高了 3 倍
|
/data/attachment/album/201707/23/100754bg1rlmgjrii1rx0g.jpg.thumb.jpg
|
/data/attachment/album/201707/23/100754bg1rlmgjrii1rx0g.jpg
| true | false | true |
toyijiu
| false |
[
"Linux"
] |
观点
|
{
"viewnum": 4800,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "幸亏用的是 AIX，而不是 Windows，有问题的还是人，而不在于系统。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-07-24T11:14:37"
},
{
"postip": "223.65.169.47",
"message": "我想问题的原因显而易见：1998年时期的 AIX 系统比 Linux 要幼小的多，在多线程并发方面的研发尚算稚嫩。而且 IBM 是软硬通吃的，AIX 类似于服务器界的 macOS。如果放到现在的话情况要好多了。",
"username": "来自江苏南京的 Chromium 59.0|Ubuntu 用户",
"date": "2017-07-24T23:03:43"
},
{
"postip": "118.122.120.11",
"message": "AIX 最初发布于 86 年，在 98 年的是 4.x。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-07-25T08:38:15"
}
] |
[] |
在项目早期就遇到公开的失败后，一个著名大学的 IT 团队决定将他们的 web 注册系统部署到 Linux上，此举几乎将服务器的最大用户访问量提高了 3 倍
| 2017-07-24T10:03:00 | 2017-07-24T10:03:00 | 8,716 |
/article-8716-1.html
|
>
> 在项目早期就遇到公开的失败后，一个著名大学的 IT 团队决定将他们的 web 注册系统部署到 Linux上，此举几乎将服务器的最大用户访问量提高了 3 倍
>
>
>
1998年，我在明尼苏达大学为一个新的 web 团队管理他们的服务器管理组。明尼苏达大学是一个非常大的大学，个个院校拥有接近 6000 名在校大学生。当时学校是用一个上了年纪的大型机系统来做学生的档案管理系统，这种系统已经过时了，所以需要做出改变。
这个系统不是 Y2K 类型的（LCTT 译注：保存年份时只用两位数，导致记录 2000 年时计算机会记录为 1900 年，详见 [What Does Y2K Compliant Mean?](https://stackoverflow.com/questions/18200744/what-does-y2k-compliant-mean)），所以我们准备建立一个由仁科软件公司来交付的新的学生档案管理系统。这个新系统对明尼苏达大学来说有很多作用，不仅能够管理学生的档案，还能提供其他的一些功能。然而它却缺少了一项关键特性：你不能在你的浏览器上通过 web 来给你的班级进行注册。
按照今天的标准来看，这是一个重大的疏忽，但是在上世纪九十年代，互联网还是一个新生概念。亚马逊才建立不久，ebay 刚创业一年，google 呱呱坠地，Wikipedia 还没有影儿。所以 1998 年仁科公司没有支持 web 在线注册课程这个功能也就不足为奇了。但是明尼苏达大学作为 Gopher 网络的发源地，并且给之前的大型机系统开发了一套 web 功能接口，我们觉得 web 在线注册功能对于这个新的学生档案管理系统是至关重要的。
我们在这个 web 团队的任务就是去实现此管理系统的 web 在线注册功能。
幸运的是，我们并不是孤军奋战。我们联系了 IBM ，在第二年一起开始来搭建这个新的 web 在线注册系统。IBM 负责提供硬件和软件环境来运行这个 web 系统：3 个运行最新的 AIX 系统（类 UNIX 操作系统）、IBM Java 和 IBM WebSphere 平台的 SP 电脑节点，并用一个 IBM 的负载均衡器来实现 3 个节点的负载分流。
在经过一年多的开发和测试后，我们的系统终于上线了！但不幸的是失败却接踵而至。
### 负载过大
在开发过程中，我们无法准确地模拟测试真实场景下许多学生同时登录的场景。原因不是没有测试环境，明尼苏达大学有定制的 web 负载测试软件包，而且 IBM 有自己的工具做补充，但是这个 web 系统在当时对我们来说实在是太陌生了，我们没有意识到这些测试工具是不能满足要求的。
通过数月的测试，我们将此 web 系统的预期负载量调整到 240 个并发用户。但不幸的是，我们实际的使用量却是预期的两倍左右，在第一天系统上线时，超过 400 名学生马上同时登录进系统，由于负载远远超出预期值，3 台 web 服务器直接宕机了。由于持续的高负载，服务器一直崩溃，只能不断地重启。一台刚重启完，另一台又宕机重启了，这种场景居然持续了一个月。
由于不能有效地通过 web 注册，学生只能通过原来的方法来注册：来到登记员的办公室，拿着笔注册，然后再出门。当地报纸也幸灾乐祸地嘲讽道："电脑软件的失败强迫学生只能面对面地注册！"
面对失败这个事实，我们尽自己全力在下一个开发周期中来提高软件性能，在之后 6 个月的时间里，我们疯狂地想去增强这套系统的负载能力。尽管增加了更多的代码，调整了多次配置，还是不能支持更多的用户。尽力了，然而面对的还是失败。
就如所料的，在下一个迭代周期后，迎接我们的还是失败。服务器由于负载问题一次又一次地宕机。这一次新闻标题已经变成了：“web 注册系统就是垃圾”。
在开始下一个为期 6 个月的迭代前，我们已经绝望了。没有人知道服务器不停宕机的原因，我们已经预期这个问题现在是无解的。我们是要采取一些措施来搞定这个问题，但是怎么做呢？以下是我们讨论得出的方法：
### 是否需要切换新的平台?
IBM 当时引入了 Linux，给它的 Java 和 WebSphere 平台做了二次开发。所有产品都获得了红帽公司的 RHEL 认证，并且有几个产品已经在我们的桌面系统上运行了。我们意识到了现在在 Linux 上已经有了完整的生态系统来运行我们的 web 管理系统，但是它能表现的比 AIX 更好吗？
在搭建好一个测试服务器并进行基本的负载测试后，我们惊奇的发现一台 Linux 服务器能够轻松地支持之前 3 台 AIX 服务器所不能支持的负载量，在相同的 web 代码、IBM Java 和 WebSphere 平台下，单台 Linux 服务器能够支持超过 200 个用户。
我们将这个消息告诉了登记员和 CIO，他们同意将 web 注册系统切换到 Linux 平台上。虽然这是我们第一次在明尼苏达大学跑 Linux，但是失败已成习惯，反而无所畏惧了。AIX 只会失败，Linux 却是我们唯一的希望。
我们马上基于 Linux 来进行开发。另一个组的同事也提供了几台 Intel 服务器来给我们使用，我们给服务器装上红帽系统和相关的 IBM 组件，然后在新系统上进行了持续性的负载测试，令人欣喜的是，Linux 服务器没有出现任何问题。
经过两个月高强度的开发测试，我们的新系统终于上线了，而且是巨大的成功！在巨大的负载下，web 注册系统在 Linux 的表现都堪称完美。同时在线峰值甚至超过了 600 名用户。Linux 拯救了明尼苏达大学的 web 注册系统~
### 成功的经验
当我回首这个项目时，我发现你可以用以下几个点来向你的团队介绍 Linux：
1、 **解决问题, 不要自欺欺人**
当我们提议在企业中使用 Linux 时，并不是因为我们认为 Linux 很酷才使用它。当然，我们是 Linux 的爱好者并且已经在自己的环境中运行过它，但是我们在公司是为了解决问题的。能用 Linux 是因为我们的登记员和出资人同意 Linux 是解决问题的一个方法，而不仅仅是因为 Linux很酷我们想用它。
2、 **尽可能小的去做改变**
我们的成功是建立在 IBM 已经基于 Linux 做出了它的 Java 和 WebSphere 产品的基础上的。这能让我们在将 web 系统从 AIX 切换到 Linux 上不用做过多的修改适配。两者比起来只有硬件和操作系统改变了，其他系统相关的组件都保持了一致，这些都是保证平台切换成功的基石。
3、 **诚实对待风险和回报**
我们的问题很明显：web 注册系统在前两个迭代周期中都失败了，而且很可能再次失败。当我们将自己的想法（AIX 切换到 Linux）告诉出资方后，我们对其中的风险和回报是心知肚明的。如果我们什么都不做，就只有失败，如果我们尝试切换到 Linux 平台，我们可能会成功，而且从最初的测试结果分析，成功的概率是高于失败的。
而且就算在 Linux 平台下项目还是失败了，我们也可以迅速地切换回 AIX 服务器。有了这些细致的分析和措施，终于使登记员能够安心让我们试试 Linux。
4、 **言简意赅地交流**
在项目平台切换的过程中，我们做了一个整体计划。我们在一张白纸上明确地写下了我们计划做什么，为什么要这么做。这种方式的成功关键就在于计划的简短性。领导们不喜欢像看小说一样来看技术性的主意，他们不想纠缠在技术细节中。所以我们有意地在执行层面上进行计划安排，在框架层面上进行描述。
当我们在进行平台切换时，我们会定期的告诉出资人当前进展。当新系统成功完成后，我们每天都会提交更新，报告已经有多少学生成功通过此系统完成注册和遇到的问题。
尽管这个项目已经过去了接近 20 年，但是其中的经验教训在今天仍然适用。尽管 Linux 在其中起了举足轻重的作用，但是最重要的还是我们成功地将所有人的目标引导到解决共同的问题上。我认为这种经验也可以运用到很多你所面对的事情当中。
---
作者简介：
Jim Hall -我是 FreeDOS 项目的发起者和协调人，我也在 GNOME 理事会中担任董事。工作上我是明尼苏达州拉姆西县的首席信息官，空闲时间里我为开源软件的可用性做出相关的贡献，并通过 [Outreachy](https://en.wikipedia.org/wiki/Outreachy)（为女性提供帮助的一项GNOME外展服务）来指导可用性测试。
via: <https://opensource.com/article/17/7/how-introduced-organization-linux>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 译者：[吴霄/toyijiu](https://github.com/toyijiu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开发一个 Linux 调试器（四）：Elves 和 dwarves
|
Simon Brand
|
https://blog.tartanllama.xyz/c++/2017/04/05/writing-a-linux-debugger-elf-dwarf/
|
今天我们会详细介绍源码级的调试信息，作为本指南后面部分使用它的准备。
|
/data/attachment/album/201707/24/143821f1phescz20gc8thf.jpg.thumb.jpg
|
/data/attachment/album/201707/24/143821f1phescz20gc8thf.jpg
| true | false | true |
ictlyh
| false |
[
"调试器"
] |
软件开发
|
{
"viewnum": 8833,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8663,
"displayorder": 0
},
{
"raid": 8812,
"displayorder": 0
}
] |
今天我们会详细介绍源码级的调试信息，作为本指南后面部分使用它的准备。
| 2017-07-24T14:41:03 | 2017-07-24T14:41:03 | 8,719 |
/article-8719-1.html
|
到目前为止，你已经偶尔听到了关于 dwarves、调试信息、一种无需解析就可以理解源码方式。今天我们会详细介绍源码级的调试信息，作为本指南后面部分使用它的准备。
### 系列文章索引
随着后面文章的发布，这些链接会逐渐生效。
1. [准备环境](/article-8626-1.html)
2. [断点](/article-8645-1.html)
3. [寄存器和内存](/article-8663-1.html)
4. [Elves 和 dwarves](https://blog.tartanllama.xyz/c++/2017/04/05/writing-a-linux-debugger-elf-dwarf/)
5. [源码和信号](https://blog.tartanllama.xyz/c++/2017/04/24/writing-a-linux-debugger-source-signal/)
6. [源码级逐步执行](https://blog.tartanllama.xyz/c++/2017/05/06/writing-a-linux-debugger-dwarf-step/)
7. 源码级断点
8. 调用栈展开
9. 读取变量
10. 下一步
### ELF 和 DWARF 简介
ELF 和 DWARF 可能是两个你没有听说过，但可能大部分时间都在使用的组件。ELF（[Executable and Linkable Format](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format "Executable and Linkable Format")，可执行和可链接格式）是 Linux 系统中使用最广泛的目标文件格式；它指定了一种存储二进制文件的所有不同部分的方式，例如代码、静态数据、调试信息以及字符串。它还告诉加载器如何加载二进制文件并准备执行，其中包括说明二进制文件不同部分在内存中应该放置的地点，哪些位需要根据其它组件的位置固定（*重分配*）以及其它。在这些博文中我不会用太多篇幅介绍 ELF，但是如果你感兴趣的话，你可以查看[这个很好的信息图](https://github.com/corkami/pics/raw/master/binary/elf101/elf101-64.pdf)或[该标准](http://www.skyfree.org/linux/references/ELF_Format.pdf)。
[DWARF](https://en.wikipedia.org/wiki/DWARF "DWARF WIKI")是通常和 ELF 一起使用的调试信息格式。它不一定要绑定到 ELF，但它们两者是一起发展的，一起工作得很好。这种格式允许编译器告诉调试器最初的源代码如何和被执行的二进制文件相关联。这些信息分散到不同的 ELF 部分，每个部分都衔接有一份它自己的信息。下面不同部分的定义，信息取自这个稍有过时但非常重要的 [DWARF 调试格式简介](http://www.dwarfstd.org/doc/Debugging%20using%20DWARF-2012.pdf)：
* `.debug_abbrev` `.debug_info` 部分使用的缩略语
* `.debug_aranges` 内存地址和编译的映射
* `.debug_frame` 调用帧信息
* `.debug_info` 包括 <ruby> DWARF 信息条目 <rp> （ </rp> <rt> DWARF Information Entries </rt> <rp> ） </rp></ruby>（DIEs）的核心 DWARF 数据
* `.debug_line` 行号程序
* `.debug_loc` 位置描述
* `.debug_macinfo` 宏描述
* `.debug_pubnames` 全局对象和函数查找表
* `.debug_pubtypes` 全局类型查找表
* `.debug_ranges` DIEs 的引用地址范围
* `.debug_str` `.debug_info` 使用的字符串列表
* `.debug_types` 类型描述
我们最关心的是 `.debug_line` 和 `.debug_info` 部分，让我们来看一个简单程序的 DWARF 信息。
```
int main() {
long a = 3;
long b = 2;
long c = a + b;
a = 4;
}
```
### DWARF 行表
如果你用 `-g` 选项编译这个程序，然后将结果传递给 `dwarfdump` 执行，在行号部分你应该可以看到类似这样的东西：
```
.debug_line: line number info for a single cu
Source lines (from CU-DIE at .debug_info offset 0x0000000b):
NS new statement, BB new basic block, ET end of text sequence
PE prologue end, EB epilogue begin
IS=val ISA number, DI=val discriminator value
<pc> [lno,col] NS BB ET PE EB IS= DI= uri: "filepath"
0x00400670 [ 1, 0] NS uri: "/home/simon/play/MiniDbg/examples/variable.cpp"
0x00400676 [ 2,10] NS PE
0x0040067e [ 3,10] NS
0x00400686 [ 4,14] NS
0x0040068a [ 4,16]
0x0040068e [ 4,10]
0x00400692 [ 5, 7] NS
0x0040069a [ 6, 1] NS
0x0040069c [ 6, 1] NS ET
```
前面几行是一些如何理解 dump 的信息 - 主要的行号数据从以 `0x00400670` 开头的行开始。实际上这是一个代码内存地址到文件中行列号的映射。`NS` 表示地址标记一个新语句的开始，这通常用于设置断点或逐步执行。`PE` 表示函数序言（LCTT 译注：在汇编语言中，[function prologue](https://en.wikipedia.org/wiki/Function_prologue "function prologue") 是程序开始的几行代码，用于准备函数中用到的栈和寄存器）的结束，这对于设置函数断点非常有帮助。`ET` 表示转换单元的结束。信息实际上并不像这样编码；真正的编码是一种非常节省空间的排序程序，可以通过执行它来建立这些行信息。
那么，假设我们想在 `variable.cpp` 的第 4 行设置断点，我们该怎么做呢？我们查找和该文件对应的条目，然后查找对应的行条目，查找对应的地址，在那里设置一个断点。在我们的例子中，条目是：
```
0x00400686 [ 4,14] NS
```
假设我们想在地址 `0x00400686` 处设置断点。如果你想尝试的话你可以在已经编写好的调试器上手动实现。
反过来也是如此。如果我们已经有了一个内存地址 - 例如说，一个程序计数器值 - 想找到它在源码中的位置，我们只需要从行表信息中查找最接近的映射地址并从中抓取行号。
### DWARF 调试信息
`.debug_info` 部分是 DWARF 的核心。它给我们关于我们程序中存在的类型、函数、变量、希望和梦想的信息。这部分的基本单元是 DWARF 信息条目（DWARF Information Entry），我们亲切地称之为 DIEs。一个 DIE 包括能告诉你正在展现什么样的源码级实体的标签，后面跟着一系列该实体的属性。这是我上面展示的简单事例程序的 `.debug_info` 部分：
```
.debug_info
COMPILE_UNIT<header overall offset = 0x00000000>:
< 0><0x0000000b> DW_TAG_compile_unit
DW_AT_producer clang version 3.9.1 (tags/RELEASE_391/final)
DW_AT_language DW_LANG_C_plus_plus
DW_AT_name /super/secret/path/MiniDbg/examples/variable.cpp
DW_AT_stmt_list 0x00000000
DW_AT_comp_dir /super/secret/path/MiniDbg/build
DW_AT_low_pc 0x00400670
DW_AT_high_pc 0x0040069c
LOCAL_SYMBOLS:
< 1><0x0000002e> DW_TAG_subprogram
DW_AT_low_pc 0x00400670
DW_AT_high_pc 0x0040069c
DW_AT_frame_base DW_OP_reg6
DW_AT_name main
DW_AT_decl_file 0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
DW_AT_decl_line 0x00000001
DW_AT_type <0x00000077>
DW_AT_external yes(1)
< 2><0x0000004c> DW_TAG_variable
DW_AT_location DW_OP_fbreg -8
DW_AT_name a
DW_AT_decl_file 0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
DW_AT_decl_line 0x00000002
DW_AT_type <0x0000007e>
< 2><0x0000005a> DW_TAG_variable
DW_AT_location DW_OP_fbreg -16
DW_AT_name b
DW_AT_decl_file 0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
DW_AT_decl_line 0x00000003
DW_AT_type <0x0000007e>
< 2><0x00000068> DW_TAG_variable
DW_AT_location DW_OP_fbreg -24
DW_AT_name c
DW_AT_decl_file 0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
DW_AT_decl_line 0x00000004
DW_AT_type <0x0000007e>
< 1><0x00000077> DW_TAG_base_type
DW_AT_name int
DW_AT_encoding DW_ATE_signed
DW_AT_byte_size 0x00000004
< 1><0x0000007e> DW_TAG_base_type
DW_AT_name long int
DW_AT_encoding DW_ATE_signed
DW_AT_byte_size 0x00000008
```
第一个 DIE 表示一个编译单元（CU），实际上是一个包括了所有 `#includes` 和类似语句的源文件。下面是带含义注释的属性：
```
DW_AT_producer clang version 3.9.1 (tags/RELEASE_391/final) <-- 产生该二进制文件的编译器
DW_AT_language DW_LANG_C_plus_plus <-- 原编程语言
DW_AT_name /super/secret/path/MiniDbg/examples/variable.cpp <-- 该 CU 表示的文件名称
DW_AT_stmt_list 0x00000000 <-- 跟踪该 CU 的行表偏移
DW_AT_comp_dir /super/secret/path/MiniDbg/build <-- 编译目录
DW_AT_low_pc 0x00400670 <-- 该 CU 的代码起始
DW_AT_high_pc 0x0040069c <-- 该 CU 的代码结尾
```
其它的 DIEs 遵循类似的模式，你也很可能推测出不同属性的含义。
现在我们可以根据新学到的 DWARF 知识尝试和解决一些实际问题。
### 当前我在哪个函数？
假设我们有一个程序计数器值然后想找到当前我们在哪一个函数。一个解决该问题的简单算法：
```
for each compile unit:
if the pc is between DW_AT_low_pc and DW_AT_high_pc:
for each function in the compile unit:
if the pc is between DW_AT_low_pc and DW_AT_high_pc:
return function information
```
这对于很多目的都有效，但如果有成员函数或者内联（inline），就会变得更加复杂。假如有内联，一旦我们找到其范围包括我们的程序计数器（PC）的函数，我们需要递归遍历该 DIE 的所有孩子检查有没有内联函数能更好地匹配。在我的代码中，我不会为该调试器处理内联，但如果你想要的话你可以添加该功能。
### 如何在一个函数上设置断点？
再次说明，这取决于你是否想要支持成员函数、命名空间以及类似的东西。对于简单的函数你只需要迭代遍历不同编译单元中的函数直到你找到一个合适的名字。如果你的编译器能够填充 `.debug_pubnames` 部分，你可以更高效地做到这点。
一旦找到了函数，你可以在 `DW_AT_low_pc` 给定的内存地址设置一个断点。不过那会在函数序言处中断，但更合适的是在用户代码处中断。由于行表信息可以指定序言的结束的内存地址，你只需要在行表中查找 `DW_AT_low_pc` 的值，然后一直读取直到被标记为序言结束的条目。一些编译器不会输出这些信息，因此另一种方式是在该函数第二行条目指定的地址处设置断点。
假如我们想在我们示例程序中的 `main` 函数设置断点。我们查找名为 `main` 的函数，获取到它的 DIE：
```
< 1><0x0000002e> DW_TAG_subprogram
DW_AT_low_pc 0x00400670
DW_AT_high_pc 0x0040069c
DW_AT_frame_base DW_OP_reg6
DW_AT_name main
DW_AT_decl_file 0x00000001 /super/secret/path/MiniDbg/examples/variable.cpp
DW_AT_decl_line 0x00000001
DW_AT_type <0x00000077>
DW_AT_external yes(1)
```
这告诉我们函数从 `0x00400670` 开始。如果我们在行表中查找这个，我们可以获得条目：
```
0x00400670 [ 1, 0] NS uri: "/super/secret/path/MiniDbg/examples/variable.cpp"
```
我们希望跳过序言，因此我们再读取一个条目：
```
0x00400676 [ 2,10] NS PE
```
Clang 在这个条目中包括了序言结束标记，因此我们知道在这里停止，然后在地址 `0x00400676` 处设一个断点。
### 我如何读取一个变量的内容？
读取变量可能非常复杂。它们是难以捉摸的东西，可能在整个函数中移动、保存在寄存器中、被放置于内存、被优化掉、隐藏在角落里，等等。幸运的是我们的简单示例是真的很简单。如果我们想读取变量 `a` 的内容，我们需要看它的 `DW_AT_location` 属性：
```
DW_AT_location DW_OP_fbreg -8
```
这告诉我们内容被保存在以栈帧基（base of the stack frame）偏移为 `-8` 的地方。为了找到栈帧基，我们查找所在函数的 `DW_AT_frame_base` 属性。
```
DW_AT_frame_base DW_OP_reg6
```
从 [System V x86\_64 ABI](https://www.uclibc.org/docs/psABI-x86_64.pdf) 我们可以知道 `reg6` 在 x86 中是帧指针寄存器。现在我们读取帧指针的内容，从中减去 `8`，就找到了我们的变量。如果我们知道它具体是什么，我们还需要看它的类型：
```
< 2><0x0000004c> DW_TAG_variable
DW_AT_name a
DW_AT_type <0x0000007e>
```
如果我们在调试信息中查找该类型，我们得到下面的 DIE：
```
< 1><0x0000007e> DW_TAG_base_type
DW_AT_name long int
DW_AT_encoding DW_ATE_signed
DW_AT_byte_size 0x00000008
```
这告诉我们该类型是 8 字节（64 位）有符号整型，因此我们可以继续并把这些字节解析为 `int64_t` 并向用户显示。
当然，类型可能比那要复杂得多，因为它们要能够表示类似 C++ 的类型，但是这能给你它们如何工作的基本认识。
再次回到帧基（frame base），Clang 可以通过帧指针寄存器跟踪帧基。最近版本的 GCC 倾向于使用 `DW_OP_call_frame_cfa`，它包括解析 `.eh_frame` ELF 部分，那是一个我不会去写的另外一篇完全不同的文章。如果你告诉 GCC 使用 DWARF 2 而不是最近的版本，它会倾向于输出位置列表，这更便于阅读：
```
DW_AT_frame_base <loclist at offset 0x00000000 with 4 entries follows>
low-off : 0x00000000 addr 0x00400696 high-off 0x00000001 addr 0x00400697>DW_OP_breg7+8
low-off : 0x00000001 addr 0x00400697 high-off 0x00000004 addr 0x0040069a>DW_OP_breg7+16
low-off : 0x00000004 addr 0x0040069a high-off 0x00000031 addr 0x004006c7>DW_OP_breg6+16
low-off : 0x00000031 addr 0x004006c7 high-off 0x00000032 addr 0x004006c8>DW_OP_breg7+8
```
位置列表取决于程序计数器所处的位置给出不同的位置。这个例子告诉我们如果程序计数器是在 `DW_AT_low_pc` 偏移量为 `0x0` 的位置，那么帧基就在和寄存器 7 中保存的值偏移量为 8 的位置，如果它是在 `0x1` 和 `0x4` 之间，那么帧基就在和相同位置偏移量为 16 的位置，以此类推。
### 休息一会
这里有很多的信息需要你的大脑消化，但好消息是在后面的几篇文章中我们会用一个库替我们完成这些艰难的工作。理解概念仍然很有帮助，尤其是当出现错误或者你想支持一些你使用的 DWARF 库所没有实现的 DWARF 概念时。
如果你想了解更多关于 DWARF 的内容，那么你可以从[这里](http://dwarfstd.org/Download.php)获取其标准。在写这篇博客时，刚刚发布了 DWARF 5，但更普遍支持 DWARF 4。
---
via: <https://blog.tartanllama.xyz/c++/2017/04/05/writing-a-linux-debugger-elf-dwarf/>
作者：[Simon Brand](https://www.twitter.com/TartanLlama) 译者：[ictlyh](https://github.com/ictlyh) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linus Torvalds 说：谈论技术创新是愚蠢的，闭上嘴把事情做好
|
Thomas Claburn
|
http://www.theregister.co.uk/2017/02/15/think_different_shut_up_and_work_harder_says_linus_torvalds/
|
来自 Linux 内核首领的最佳生活提示。
|
/data/attachment/album/201707/24/190251gpa8syj8aqs7aawp.jpg.thumb.jpg
|
/data/attachment/album/201707/24/190251gpa8syj8aqs7aawp.jpg
| true | false | true |
geekpi
| false |
[
"创新"
] |
观点
|
{
"viewnum": 11764,
"commentnum": 14,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "223.65.169.47",
"message": "大神不是我说你，拿好你的2千万，多做实事，多把版本号跳跳级，少乱说话，不要成为 IT 界的贝利。",
"username": "来自江苏南京的 Chromium 59.0|Ubuntu 用户",
"date": "2017-07-24T23:06:52"
},
{
"postip": "222.77.22.103",
"message": "大神你好，你有什么资格说linus，万一别人采访你闭口不谈直接让ta滚蛋",
"username": "来自福建泉州的 Firefox 52.0|GNU/Linux 用户",
"date": "2017-07-25T05:33:53"
},
{
"postip": "182.50.119.82",
"message": "没毛病",
"username": "jinga50334 [BlackBerry Browser|BlackBerry Tablet OS 2.1]",
"date": "2017-07-25T10:36:01"
},
{
"postip": "113.59.15.160",
"message": "说得很对。",
"username": "来自海南海口的 Chrome 59.0|Windows 10 用户",
"date": "2017-07-25T14:44:17"
},
{
"postip": "124.95.105.75",
"message": "我是不赞成标题这种说法 创新极其重要 那1%的创新比300%的汗水都重要",
"username": "来自辽宁本溪的 Chrome Mobile 59.0|Android 5.1 用户",
"date": "2017-07-25T16:08:31"
},
{
"postip": "112.23.168.175",
"message": "能说啊，因为我有口。",
"username": "来自江苏南京的 Chromium 59.0|Ubuntu 用户",
"date": "2017-07-25T16:16:48"
},
{
"postip": "182.50.119.82",
"message": "很好",
"username": "来自北京的 Chrome 1000.0|GNU/Linux 用户",
"date": "2017-07-25T18:00:30"
},
{
"postip": "218.29.101.202",
"message": "没有对所在专业的熟悉，何来的创新",
"username": "来自河南郑州的 Maxthon 5.0|Windows 7 用户",
"date": "2017-07-25T19:31:29"
},
{
"postip": "113.59.15.160",
"message": "创新也是在汗水的基础上的。",
"username": "来自海南海口的 Chrome 59.0|Windows 10 用户",
"date": "2017-07-26T00:10:48"
},
{
"postip": "183.14.28.32",
"message": "操作系统和应用APP不相同。<br />\r\n日常APP和游戏APP也不相同。<br />\r\n不同的场景有不同的需要。<br />\r\n操作系统要的稳定。游戏APP，没有好的创意，就没有销路。",
"username": "何亮 [Chrome 59.0|Windows 7]",
"date": "2017-07-27T16:54:42"
},
{
"postip": "183.202.226.205",
"message": "脚踏实地才能有突破，空谈创新，还不如脚踏实地．",
"username": "逝水年华— [Chrome 59.0|Fedora]",
"date": "2017-07-28T08:20:54"
},
{
"postip": "124.202.179.246",
"message": "你快闭嘴吧！没Linus，你现在估计连饭碗都没有！我们感谢Linus，至少他的创新让这个世界有了Linux，让无数人有了饭碗！",
"username": "来自北京的 Chrome 60.0|Windows 10 用户",
"date": "2017-08-03T20:24:01"
},
{
"postip": "175.141.33.135",
"message": "Linus 只要没有违法, 他有嚣张的资本与资格.<br />\r\n<br />\r\n他发表的看法, 是指在内核OS开发上,<br />\r\n并不代表适合指其它情形,<br />\r\n毕竟大家的情况不同, 也不能说他是错的, 这是他的看法, 而你无法完全了解他的情况.<br />\r\n<br />\r\n所以，别人说的如果觉得可用的, 就收入脑袋中, <br />\r\n觉得没用的就没必要较真.",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-05T04:43:38"
},
{
"postip": "98.142.143.74",
"message": "站在鄙视链顶端的男人",
"username": "来自美国的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-14T21:57:04"
}
] |
[
{
"raid": 5651,
"displayorder": 0
},
{
"raid": 5793,
"displayorder": 1
},
{
"raid": 7204,
"displayorder": 2
},
{
"raid": 8498,
"displayorder": 3
},
{
"raid": 8597,
"displayorder": 4
},
{
"raid": 8638,
"displayorder": 5
},
{
"raid": 8643,
"displayorder": 6
}
] |
来自 Linux 内核首领的最佳生活提示。
| 2017-07-24T19:02:00 | 2017-07-24T19:02:00 | 8,720 |
/article-8720-1.html
|
>
> 来自 Linux 内核首领的最佳生活提示。
>
>
>
**OSLS 报道：** Linus Torvalds 认为，技术行业的创新庆祝活动是沾沾自喜，自我陶醉和自私自利的。
他所使用的艺术化术语更为直率：“行业的创新如此之多都是胡说。” 他说：“人人创新——不要做这种‘不同思考’，这是无意义的，它们有百分之九十九只是工作而已。”
周三在加利福尼亚州召开的[开源领袖峰会（OSLS）](https://www.theregister.co.uk/2017/02/14/the_government_is_coming_for_your_code/)中，Linux 基金会执行总监 Jim Zemlin 采访了 Linus，讨论了他如何管理 Linux 内核的开发和他对工作的态度。
Torvalds 说：“所有的炒作都不是真正的工作，真正的工作是在细节之中。”
Torvalds 表示赞成这样一个观点，即成功的项目是 99％ 的汗水，百分之一的创新。
作为[开源 Linux 内核](https://www.kernel.org/)的创造者和仁慈独裁者，不用提还是 Git 分布式版本控制系统的发明者，Torvalds 已经证明他的方法产生了结果。Linux 对技术行业的影响已经不用再夸大了。Linux 是服务器的主要操作系统，几乎所有的高性能计算都运行在 Linux 上，而大多数移动设备和嵌入式设备都依赖于 Linux。
Linux 内核可能是 PC 时代最成功的技术协作项目。根据 Zemlin 的说法，内核贡献者自 2005 年以来总共增加了 13500 多个，其中每天大约增加 10000 行代码，移除 8000 行代码，修改 1500 到 1800 行代码，而且这一直在继续 —— 虽然不是一直以目前的速度 —— 但这已经超过了二十五年。
Torvalds 说：“我们已经这样做了 25 年，而且我们遇到的一个常见问题是人们彼此需要磨合。所以组织代码、组织代码流、[以及]组织我们的维护关系构成了我们的历史，最终那些痛点，我说的是代码争议，基本上消失了。”
Torvalds 解释说，该项目的结构使人们能够独立工作。他说：“我们已经能够真正模块化代码和开发模式，所以我们可以并行做很多事情。”
Torvalds 说，技术起着明显的作用，但流程至少是同样重要的。
Torvalds 说：“这是一个社会化项目。这是技术层面的东西，而技术是让人们能够就问题达成一致的东西，因为……它通常有非常明确的对和错。”
但是现在 Torvalds 并没有像 20 年前一样对每一个变化进行审查，而是依靠贡献者的社交网络。他说：“这是社交网络和信任，并且我们有一个非常强大的网络，这就是为什么我们可以有一千人参与到每个发布当中。”
对信任的重视解释了参与内核开发的困难，因为人们不可以登录、提交代码然后消失不见。Torvalds 说：“你要提交很多小的补丁直到维护者信任你才行，在这一点上，你不仅仅是一个提交补丁的人，而是成为信任网络的一部分。”
十年前，Torvalds 表示，他告诉其他内核贡献者，他希望有一个八周的发布时间表，而不是可能拖延几年的发布周期。内核开发人员设法将其发布周期减少到大约两个半月。从那时起，开发工作就一直很平稳。
Torvalds 说：“说我们的流程有多么好很无聊。对于我来说，所有真正紧张的时刻都是关于流程的，它们和代码无关，当代码不工作时，这实际上是令人高兴的……流程问题是很痛苦的。你永远不会想有流程问题……尤其是当人们开始彼此生气时。”
---
via: <http://www.theregister.co.uk/2017/02/15/think_different_shut_up_and_work_harder_says_linus_torvalds/>
作者：[Thomas Claburn](http://www.theregister.co.uk/Author/3190) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
6 个学习 OpenStack 的新指南和教程
|
Jason Baker
|
https://opensource.com/article/17/6/openstack-guides-and-tutorials
|
云基础设施是一个非常需要的技能。如果你正在为你的云基础架构需求寻找开源解决方案，那么 OpenStack 就是其中之一。
|
/data/attachment/album/201707/25/001553ekf9k8it93racj8a.jpg.thumb.jpg
|
/data/attachment/album/201707/25/001553ekf9k8it93racj8a.jpg
| true | false | true |
geekpi
| false |
[
"OpenStack"
] |
分享
|
{
"viewnum": 10094,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
云基础设施是一个非常需要的技能。如果你正在为你的云基础架构需求寻找开源解决方案，那么 OpenStack 就是其中之一。
| 2017-07-25T08:11:00 | 2017-07-25T08:11:00 | 8,721 |
/article-8721-1.html
|
>
> 想了解更多关于 OpenStack 的内容？这些免费资源可能只是你所需要的。
>
>
>
云基础设施是一个非常需要的技能。如果你正在为你的云基础架构需求寻找开源解决方案，那么 [OpenStack](https://opensource.com/resources/what-is-openstack) 就是其中之一。
OpenStack 是一个巨大的项目集合，为云服务的几乎每一个部分都提供了解决方案和集成。虽然这个巨大范围使得它成为一个强大的工具，但这也意味着可能很难跟上并了解整个项目，了解如何使用它们、如何自定义它们以及如何向其提供代码。
幸运的是，有很多选择可以帮助你。除了[官方项目文档](http://docs.openstack.org/)、纸质书籍和认证培训计划外，还有大量社区创造的优秀资源。我们每个月可以在 Opensource.com 上查看它在博客和其他网站上最近发布的指南和教程，这会给你启发。我们来看看这次我们发现了什么。
* 首先在本月的这一批中，我们有一篇来自 Antony Messerli 的指南，介绍如何通过 Ansible [设置 OpenStack 云](https://www.reversengineered.com/2016/05/09/setting-up-an-openstack-cloud-using-ansible/)。Messerli 将引导我们完成实验室环境中的配置以及在集群上运行 OpenStack 所需的 playbook，还有添加镜像、设置网络等的基础知识。如果你正在考虑使用 Ansible 安装 OpenStack 小型本地测试环境，这是一篇很好的文章。
* 接下来，你有没有想过 Neutron 网络如何在 OpenStack 中的工作的？应用程序中发生的事情如何对应于底层代码？Arie Bregman 在[这篇文章](http://abregman.com/2017/05/29/openstack-neutron-service-code-deep-dive/)中提供了一段 OpenStack Neutron 代码。你需要熟悉一般的网络原理，至少有一点 OpenStack 代码基础才能跟上。
* Gerrit是 OpenStack 使用的开源代码审查项目，用于管理上传的修补程序，并允许在将更改合并到主 OpenStack 代码库之前进行反馈和测试。对于那些习惯于不同的代码审查系统（或根本没有的），Gerrit 可能会有点混乱，尽管它具有很好的仪表板功能，因此你只能看到对你很重要的信息。Dougal Matthews 在[这篇文章](http://www.dougalmatthews.com/2017/May/19/how-i-gerrit/)中带我们看了他的 Gerrit 仪表板设置，这可能会帮助你设置自己的。
* 上个月在波士顿举办的 OpenStack 峰会的[视频](https://www.openstack.org/videos/)已经发布了，无论你是否参加过上个月的活动，这都包含了技术和非技术专题的宝库。不知道从哪里开始？这有个来自 Julio Villarreal Pelegrino 关于如何规划、构建、运行一个成功的 OpenStack 云计算的[演讲](http://www.juliosblog.com/dont-fail-at-scale-how-to-plan-for-build-and-operate-a-successful-openstack-cloud-video-openstack-summit2017/)。
* 任何云管理员都应该担心安全问题。但你从哪里开始？Naveen Joy 发布了一个很好的十个安全问题的[清单](https://blogs.cisco.com/cloud/securing-openstack-networking)，用于加固你的 OpenStack 网络；你可以在上个月的同一主题演讲中查看[这个视频](https://www.openstack.org/videos/boston-2017/securing-openstack-networking)。
* OpenStack 中的内部消息服务在一个公共库中进行管理，该库存在于一个称为 Oslo 的项目中，自然它被称为 Oslo.Messenging。要了解这个库的基础知识，它在这个分为[两个](https://pigdogweb.wordpress.com/2017/05/22/intro-to-oslo-messaging/)[部分](https://pigdogweb.wordpress.com/2017/06/02/oslo-messaging-the-cloud-is-calling/)的博客中提到。
想要了解更多？可以从这三年来社区说提供的内容中找到我们完整的 [OpenStack 指南、如何做和教程](https://opensource.com/resources/openstack-tutorials)，以帮助你学习成为一名高效的 OpenStack 开发人员或管理员。
有很棒教程、指导或者如何做需要我们分享的么？在下面的评论中分享。
---
作者简介：
Jason Baker - Jason 热衷于使用技术使世界更加开放，从软件开发到阳光政府行动。Linux 桌面爱好者、地图/地理空间爱好者、树莓派工匠、数据分析和可视化极客、偶尔的码农、云本土主义者。在 Twitter 上关注他。
via: <https://opensource.com/article/17/6/openstack-guides-and-tutorials>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
教你如何比谷歌搜索更快速有效地利用 man
|
Greg Pittman
|
https://opensource.com/article/17/7/using-man-pages
|
Linux 的帮助手册其实拥有很多有用的信息，而且比你想象中更容易使用
|
/data/attachment/album/201707/25/005939nz9tlil3l5ofil54.jpg.thumb.jpg
|
/data/attachment/album/201707/25/005939nz9tlil3l5ofil54.jpg
| true | false | true |
toyijiu
| false |
[
"手册",
"帮助",
"man"
] |
技术
|
{
"viewnum": 6506,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "或许两个男人更合适。 man man<br />\r\n如果还是不行，那可能需要一直找，直到第八个。 debug",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-07-26T10:00:52"
},
{
"postip": "222.76.241.20",
"message": "nice",
"username": "7th [Chrome 60.0|GNU/Linux]",
"date": "2017-07-27T08:49:19"
}
] |
[] |
Linux 的帮助手册其实拥有很多有用的信息，而且比你想象中更容易使用
| 2017-07-26T08:53:00 | 2017-07-26T08:53:00 | 8,722 |
/article-8722-1.html
|
>
> Linux 的帮助手册其实拥有很多有用的信息，而且比你想象中更容易使用
>
>
>
我们通常通过 google 来查询 Linux 中的命令说明，但是其实还有一个更好的办法：那就是通过 Linux 自带的 **man 帮助页**来查询命令详尽完整的使用说明。
man 页面的历史本身比 Linux 还长，可以追溯到 Unix 早期那个年代。 通过[这个 Wikipedia](https://en.wikipedia.org/wiki/Man_page) 可以知道，Dennis Ritchie 和 Ken Thompson 在 1971 年写了第一个 man 帮助页，那个年代的计算器使用的还是像烤箱一样的计算机，个人电脑还未出世。man 帮助页也有它自己的一套设计精炼的语法，和 Unix 与 Linux 一样，man 帮助页也不是一成不变的，它就像 Linux 内核一样不停地发展更新。
Man 帮助页通过数字标识符来分成不同类型的内容：
1. 一般用户命令
2. 系统调用命令
3. 库函数
4. 特殊的文件和驱动程序
5. 文件格式
6. 游戏和屏保
7. 杂项
8. 系统管理命令和守护进程
尽管如此，用户一般也不需要知道他们想查询的命令是属于哪一个类型的。
这些文件格式化的方式在当今许多用户看来有点古怪。因为最开始他们是用 **trooff** 的方式，通过 PostScript 打印机来打印，所以包含了头部和布局方面的格式化信息。在 Linux 中，取而代之使用了一种叫做 [groff](https://en.wikipedia.org/wiki/Groff_(software)) 的方法。
在我的 Fedora 系统中，man 帮助页相关的文件存储在 `/usr/share/man` 下的子目录中（比如 `man1` 存储第一部分的命令），还有进一步的子目录用于存储 man 帮助页的翻译。
如果你在 Shell 中查找 `man` 命令的 man 帮助页，你时间看到将是 gzip 工具压缩的 `man.1.gz` 文件。想要查询 man 帮助页，需要输入类似如下命令：
```
man man
```
这个例子会显示 `man` 命令的 man 帮助页，这将先解压 man 帮助页文件，然后解释格式化指令并用 `less` 显示结果，所以导航操作和在 `less` 中一样。
所有的 man 帮助页都应该显示这些子段落：**Name**、 **Synopsis**、 **Description**、**Examples**、**See**、**Also**。有些还会添加一些额外的子段落，比如 **Options**、 **Exit**、**Status**、 **Environment**、**Bugs**、**Files**、**Author**、**Reporting**、**Bugs**、**History**、**Copyright**。
### 详细说明一个 man 帮助页
为了更详细地介绍一个典型的 man 帮助页，就用 ls 命令的帮助页来分析吧，在 **Name** 分段下，我们可以看到如下内容：
```
ls - list directory contents
```
它会简要地告诉我 `ls` 这条命令的作用.
在 `Synopsis` 分段下，我们可以看到如下的内容:
```
ls [OPTION]... [FILE]…
```
任何在中括号中的元素都是可选的。你可以只输入 `ls` 命令，后面不接任何参数。参数后面的省略号表示你可以添加任意多个彼此兼容的参数，以及许多文件名。对于 `[FILE]` 参数，你可以指定具体的目录名，或者可以使用通配符 `*`，比如这个例子，它会显示 `Documents` 文件夹下的 `.txt` 文件：
```
ls Documents/*.txt
```
在 **Description** 分段下, 我们可以看到关于这条命令更加详细的信息，还有关于这条命令各个参数作用的详细介绍的列表，比如说 `ls` 命令第一个选项 `-a` 参数，它的作用是显示包括隐藏文件/目录在内的所有文件：
```
-a, --all
```
如果我们想用这些参数，要么用它们的别名，比如 `-a`，要么用它们的全名，比如 `--all`（两条中划线）。然而并不是所有参数都有全名和别名（比如 `--author` 只有一种），而且两者的名字并不总是相互关联的（`-F` 和 `--classify`）。当你想用多个参数时，要么以空格隔开，要么共用一个连字符 `-`，在连字符后连续输入你需要的参数（不要添加空格）。比如下面两个等价的例子：
```
ls -a -d -l
```
```
ls -adl
```
但是 `tar` 这个命令有些例外，由于一些历史遗留原因，当参数使用别名时可以不用添加连字符 `-`，因此以下两种命令都是合法的：
```
tar -cvf filearchive.tar thisdirectory/
tar cvf filearchive.tar thisdirectory/
```
**ls** 的 **Description** 分段后是 **Author**、**Reporting Bugs**、**Copyright**、 **See Also** 等分段。
**See Also** 分段会提供一些相关的 man 帮助页，没事的话可以看看。毕竟除了命令外还有许多其他类型的 man 帮助页。
有一些命令不是系统命令，而是 Bash 特有的，比如 `alias` 和 `cd`。这些 Bash 特有的命令可以在 **BASH\_BUILTINS** man 帮助页中查看，和上面的比起来它们的描述更加精炼，不过内容都是类似的。
其实通过 man 帮助页让你可以获得大量有用的信息，特别是当你想用一个已经很久没用过的命令，需要复习下这条命令的作用时。这个时候 man 帮助页饱受非议的简洁性反而对你来说是更好的。
---
作者简介：
Greg Pittman - Greg 是住在肯塔基州路易斯维尔的一位退休神经学家，但是却对计算机和编程保持着长久的兴趣，从二十世纪六十年代就开始捣腾 Fortran IV 了。随着 Linux 和开源软件的到来，更加激起了他去学习的兴趣并投身于这项事业中，并成为 Scribus 组织的一员。
---
via: <https://opensource.com/article/17/7/using-man-pages>
作者：[Greg Pittman](https://opensource.com/users/greg-p) 译者：[吴霄/toyijiu](https://github.com/toyijiu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
那些乌央乌央的、普普通通的 Ubuntu 用户们
|
Robin "roblimo" Miller
|
http://fossforce.com/2017/01/many-humble-ubuntu-users/
|
“不要光挠自己的痒痒，也帮你女朋友解决一下啊！还有你的同事，以及那些你最喜欢的饭店的厨子们，还有你的医生。难道你不希望你的医生专注于医治病人，而是在 apt get 以及 grep 里心烦意乱？”
|
/data/attachment/album/201707/25/170648izovezsne5l55nnj.jpg.thumb.jpg
|
/data/attachment/album/201707/25/170648izovezsne5l55nnj.jpg
| true | false | true |
svtter
| false |
[
"Ubuntu"
] |
观点
|
{
"viewnum": 6239,
"commentnum": 18,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "222.77.22.103",
"message": "我确实挺cool",
"username": "来自福建泉州的 Firefox 52.0|GNU/Linux 用户",
"date": "2017-07-25T17:39:22"
},
{
"postip": "182.50.119.82",
"message": "好用",
"username": "jinga50334 [Chrome 1000.0|GNU/Linux]",
"date": "2017-07-25T17:55:25"
},
{
"postip": "115.171.79.19",
"message": "ubuntu用户来了，推荐过，被拒绝",
"username": "来自北京的 Firefox 54.0|Ubuntu 用户",
"date": "2017-07-25T18:32:43"
},
{
"postip": "116.31.81.182",
"message": "还真的不清楚到底哪个发行版用的人多，各家自己也没个统计数据",
"username": "来自广东广州的 Firefox 54.0|Ubuntu 用户",
"date": "2017-07-25T19:44:56"
},
{
"postip": "117.136.31.247",
"message": "一直在用mint，确实好用",
"username": "hnsncxy [Chrome Mobile 45.0|Android 5.1]",
"date": "2017-07-26T08:05:58"
},
{
"postip": "115.236.167.156",
"message": "我虽然是个写程序代码的，但是我也开始慢慢不再太关心操作系统层面的东西了，我用win10和ubuntu，win10为了office，ubuntu为了rstudio，其他的只要系统能够稳定的工作就可以了，我的笔记本也6年了，运行良好……老实说，unity还是gnome都无所谓，只是unity已经用习惯了，换成gnome可能会有很多迁移的问题，这是我对将来18.04最大的担忧，我可能会去KDE，毕竟我曾经用过，而且用的很好……",
"username": "来自浙江杭州的 Vivaldi 1.91|Windows 10 用户",
"date": "2017-07-26T10:29:47"
},
{
"postip": "106.38.52.74",
"message": "我一直认为哪个系统自己用的舒服就用哪个，一个系统再cool再先进再NB自己用不顺手，对自己来说就没任何意义",
"username": "青瞳 [Firefox 54.0|Ubuntu]",
"date": "2017-07-26T11:04:02"
},
{
"postip": "182.40.131.225",
"message": "mac用户路过，并向你扔了一个ubuntu",
"username": "来自山东青岛的 Chrome 59.0|Mac 10.12 用户",
"date": "2017-07-26T13:35:21"
},
{
"postip": "58.248.66.228",
"message": "对于国内的新手，觉得deepin更友好一些！",
"username": "来自广东广州的 Chrome 58.0|GNU/Linux 用户",
"date": "2017-07-27T11:10:21"
},
{
"postip": "183.14.28.32",
"message": "Deepin 的+1",
"username": "何亮 [Chrome 59.0|Windows 7]",
"date": "2017-07-27T16:58:05"
},
{
"postip": "116.31.81.182",
"message": "同感。前段时间试了下gnome，各种不爽，所以换成kde了。。kubuntu17.04，还不错。",
"username": "来自广东广州的 Firefox 56.0|GNU/Linux 用户",
"date": "2017-07-27T19:00:26"
},
{
"postip": "108.61.207.96",
"message": "fedora还是不错的",
"username": "来自美国的 Chrome 58.0|GNU/Linux 用户",
"date": "2017-07-30T10:36:45"
},
{
"postip": "60.191.123.194",
"message": "我不是一个重度依赖Linux的用户，出于兴趣尝试了各种版本。总的来说没有十全十美的版本，或多或少每个版本你都会遇到一丁点问题，有时候还难以解决，但换一个版本又很好解决了。就桌面来说，比较讨厌unity和现在的Gnome3，感觉体验简直是退步。Mint的cinnamon，还有mate、kde现在都不错。",
"username": "来自浙江杭州的 Chrome 60.0|Mac 10.12 用户",
"date": "2017-07-31T17:36:48"
},
{
"postip": "175.141.33.135",
"message": "有些专做给 unity 的 indicators 不能用了, 因在 gnome 显示会有问题<br />\r\n但可用 gnome shell extensions 取代, 一般小工具都可找到替代的,<br />\r\n所以就算 ubuntu 18.04 来临, 转用 Gnome 3 问题也不大",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-07-31T20:05:01"
},
{
"postip": "175.141.33.135",
"message": "Gnome 3 简单, 比其它界面灵活度高, 想用什么就自己加 Gnome Shell Extensions<br />\r\n<a href=\"https://extensions.gnome.org\" target=\"_blank\">https://extensions.gnome.org</a><br />\r\n资源需求也低, 这是为啥那么多 Linux 分发版选择 Gnome 的原因<br />\r\n<br />\r\nKDE Plasma 虽然也有 widgets 可用，<br />\r\n但做得不够好, 适用与实用的工具也很少.<br />\r\n<a href=\"https://store.kde.org/browse/cat/105/ord/latest/\" target=\"_blank\">https://store.kde.org/browse/cat/105/ord/latest/</a>",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-07-31T20:20:55"
},
{
"postip": "175.141.33.135",
"message": "有很多用户用了 Gnome 3,<br />\r\n可惜还是不知什么是 Gnome Shell Extensions<br />\r\n(其实就是 Gnome 上运行的 Java Script 小工具程序, 也就是插件)<br />\r\n<br />\r\n<a href=\"http://jasonmun.blogspot.my/2017/05/gnome-shell-extension-gnome-shell.html\" target=\"_blank\">http://jasonmun.blogspot.my/2017/05/gnome-shell-extension-gnome-shell.html</a>",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-01T09:10:45"
},
{
"postip": "36.110.71.29",
"message": "自从转了kde，就没再换过",
"username": "来自浙江的 Firefox 55.0|Windows 7 用户",
"date": "2017-08-22T09:46:41"
},
{
"postip": "111.127.81.91",
"message": "所以说只有我一个人注意到了题图是此方酱在打游戏么",
"username": "来自内蒙古包头的 Chrome Mobile 40.0|Android 7.1 用户",
"date": "2017-08-23T07:36:21"
}
] |
[] |
“不要光挠自己的痒痒，也帮你女朋友解决一下啊！还有你的同事，以及那些你最喜欢的饭店的厨子们，还有你的医生。难道你不希望你的医生专注于医治病人，而是在 apt get 以及 grep 里心烦意乱？”
| 2017-07-25T17:07:03 | 2017-07-25T17:07:03 | 8,723 |
/article-8723-1.html
|
>
> “更好的捕鼠器“ 并不是一个合格生物学家的专用谚语。就像 Ubuntu，它只需要好好工作，而不会让我惊着。
>
>
>
（LCTT 译注，“做个更好的捕鼠器”是个国外的谚语，意指不断有人发明更好的捕鼠器，然而其实没什么大的意义。）
### Roblimo 的藏身处
我从来就不是一个计算机极客。事实上，我在网上第一次小有名气是为 Time/Life 写一个每周专栏的时候，这个专栏的名字是“这台老电脑”。它介绍的是一台古老的设备能够做什么——通常是在上面安装 Linux——在那之后，我又在Andover.net 上开设了一个相同的专栏，名字叫做“廉价计算”，是关于如何在这个世界省钱的——而其它那些大部分在线计算机专栏都是在让你花钱花到你没饭吃（LCTT 译者注：作者的意思是“我算是一股清流了”）。
据我所知的那些大部分的 Linux 的早期使用者，都痴迷于他们的电脑，还有那些让他们电脑有用的软件。他们乐于仔细研读源代码并且做出一点小小的修改。最关键的是，他们大多是学计算机的，或者是从事 IT 行业的。他们的计算机和计算机网络迷住了他们，就像他们本该那样似的。
我过去是（现在也是）一个作者，不是一个搞计算机的。于我而言，计算机一直都只是一个工具而已。我希望它们能够老老实实的听话，我让它们做啥就做啥，最多可以出一点点小毛病。我喜欢图形化界面，因为我记不住那么长的命令行来管理我的电脑和网络。当然，我能找到它们，也能输入它们，但是我可不想费劲。
在 Linux 这个圈子里，有那么一段时间用户很少。“你什么意思？你只是想要你的电脑去写点文章，或者最多添加点 HTML 么？”开发者和管理员这样询问道，好像所有除了编写代码之外的奉献者们都不如他们所贡献的。
但是尽管面临这些讥笑和嘲讽，我在一次又一次的宣讲和谈话中提出一个像这样的主题：“不要光挠自己的痒痒，也帮你女朋友解决一下啊！还有你的同事，以及那些你最喜欢的饭店的厨子们，还有你的医生。难道你不希望你的医生专注于医治病人，而是在 `apt get` 以及 `grep` 里心烦意乱？”
所以，是的，因为我希望能够更简单的使用 Linux，我是一个[早期的曼德拉草用户](https://linux.slashdot.org/story/00/11/02/2324224/mandrake-72-in-wal-mart-a-good-idea)，而现在，我是一个快乐的 Ubuntu 使用者。
为什么是 Ubuntu？你一定是在逗我？为什么不是呢？它是 Linux 发行版中的丰田凯美瑞（或者本田思域）！平凡而卓越。它是如此的流行，你可以在 IRC、LinuxQuestion 社区、 Ubuntu 自己的论坛，以及许许多多的地方得到帮助。
当然，使用 Debian 或者 Fedora 也是很酷的，还有 Mint 也是开箱即用又华丽万分。但是我依然感兴趣于写一些文章和添加一点点 HTML，以及在浏览器中随时看点什么、在 Google Docs 为一两个公司客气写点什么，随时接收我的邮件，用一张过去或者现在的图片做这做那……基本上我就在电脑上干点这些。
当这一切都正常的时候，我的桌面是什么样子就没有意义了。我又看不见它！它整个被应用窗口覆盖了！然后我使用了两个显示器，不仅仅是一个。我有……让我数数，17 个标签页打开在两个 Chrome 窗口中。并且 GIMP 在运行中，[Bluefish](http://bluefish.openoffice.nl/index.html)，这个我刚才在使用的东西，用来书写这篇文章。
所以对我而言，Ubuntu 是我的阻力最小的道路。Mint 或许比较可爱，但是当你使用它的时候去掉它的那些边边角角的修饰，它不就是 Ubuntu 吗？所以如果我是用一个个相同的程序，并且不能看见桌面环境，所以谁还在意它长什么样子？
有些研究表明 Mint 正在变得更加流行，而有些人说 Debian 更甚。但是在他们的研究中，Ubuntu 永远都是居于最上位的，尽管这一年又一年过去了。
所以称我为大多数人吧！说我乏味吧！称我为乌央乌央的、普普通通的 Ubuntu 用户吧——至少从现在开始……
---
作者简介：
Robin "Roblimo" Miller 是一个自由职业作者，并且是开源技术集团的前主编，该公司旗下有 SourceForge、 freshmeat、Linux.com、NewForge、ThinkGeek 以及 Slashdot，并且他直到最近依然在 Slashdot 担任视频编辑。虽然他现在基本上退休了，但他仍然兼任 Grid Dynamics 的社论顾问，而且（显然）在为 FOSS Force 在写文章。
---
via: <http://fossforce.com/2017/01/many-humble-ubuntu-users/>
作者：[Robin "Roblimo" Miller](http://www.roblimo.com/) 译者：[svtter](https://github.com/svtter) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开放组织公开追踪问题的好处
|
Chad Whitacre
|
https://opensource.com/open-organization/17/2/tracking-issues-publicly
|
在开放组织中，在线追踪问题可以将客户转变成伙伴。
|
/data/attachment/album/201707/25/222600rksw4zp98nswnvnk.jpg.thumb.jpg
|
/data/attachment/album/201707/25/222600rksw4zp98nswnvnk.jpg
| true | false | true |
geekpi
| true |
[
"问题追踪器"
] |
观点
|
{
"viewnum": 2367,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在开放组织中，在线追踪问题可以将客户转变成伙伴。
| 2017-07-26T09:00:00 | 2017-07-26T09:00:00 | 8,724 |
/article-8724-1.html
|
>
> 在开放组织中，在线追踪问题可以将客户转变成伙伴。
>
>
>
一个公开的问题追踪器是开放组织的重要沟通工具，和在公开渠道中开展工作相比，没有比这种方式更[透明和包容](https://opensource.com/open-organization/resources/open-org-definition)的方式了。因此，让我们来探讨一下在开放组织中使用问题跟踪器的一些最佳实践。
在开始之前，我们先来定义“<ruby> 问题追踪器 <rt> issue tracker </rt></ruby>”的含义。简单地说，问题跟踪器是**一个共享的待办事项列表**。想象一下一张胡乱写的待办事项列表：购买面包、邮件打包、归还图书馆书籍。当你在城里开车时，把列表上的每一项划掉的感觉很好。现在，将它扩展到你需要在组织中完成的工作，并增加合适的软件协作能力。这样你就有一个问题追踪器了！
无论你使用的是 GitHub 还是其他的，如 Bitbucket、GitLab 或 Trello，问题跟踪器都是与你的伙伴进行协调的正确工具。这对将外部人员*变成*伙伴是至关重要的，这是开放组织的特征之一。那么这是如何工作的？我很高兴你问了这个问题。
### 使用问题追踪器的最佳实践
使用公共问题跟踪器将外部人员转换为伙伴的最佳实践是基于过去五年来我们在 [Gratipay](https://gratipay.com/) 的经验。我们帮助公司和其他组织为开源买单，我们喜欢使用我们的问题跟踪器与我们的社区合作。这就是我们所学到的。
**0、 隐私优先。** 在这篇文章中谈论公共问题追踪器的隐私看上去是一个奇怪的开始。但是我们必须记住，[开放本身并不是目的](https://opensource.com/open-organization/16/9/openness-means-to-what-end)，任何真诚和真正的开放是建立在安全和认可的坚实基础之上的。不要公开发布客户或其他第三方私下给你的信息，除非你明确提出了要求并且得到了他们的明确同意。采纳一个隐私政策并培训你的人员。[这篇 Gratipay 的政策](http://inside.gratipay.com/howto/seek-consent)可供参考。好的！现在这部分清楚之后，让我们继续。
**1、 默认采用公开决策。** 如果你私下做决策，你就会失去运行一个开放组织的好处，比如表达多样化的想法、招募有活力的人才、实现更大的责任感。即使你的全职员工是最初使用你的公共问题跟踪器的唯一员工，那也要这么做。 避免将你的公共问题追踪器视为二等公民。如果你在办公室进行对话，请在公共问题跟踪器上发布摘要，并在最终决策之前给你的社区留出时间来响应。这是使用问题跟踪器解锁你组织开放权力的第一步：如果它不在问题追踪器中，那就没用！
**2、 关联其他工具。** 我们许多人都喜欢 IRC 和 Slack，这并不是什么秘密。或者你的组织已经使用 Trello，但是你也想开始使用 GitHub。这没问题！在 GitHub issue 中放入 Trello 卡片的链接很容易，反之亦然。交叉关联保证了被一个或另一个问题困住的外部人员能够发现帮助它们充分理解这个问题的更多相关信息。对于聊天服务，你可能需要配置公共日志记录才能维护关联（隐私注意事项：当你这么做时，请务必在你的频道描述中宣传该事实）。也就是说，你应该在私人 Slack 或其他私人渠道中对话，就像在办公室里面对面的对话一样。换句话说，一定要总结公众问题跟踪器上的对话。看看上面说的：无论离线或在线，如果不在问题跟踪器中，那就没用！
**3、 将谈话导向追踪器中。** 社交媒体很快就能获得很多反馈，尤其是发现问题，但这不是解决问题的地方。问题跟踪器为深入的对话和分析根本原因留出了空间。更重要的是，它们是为了完成任务而优化的，而不是无限拖延。当问题解决后点击“关闭”按钮的感觉真的很好！现在将公共问题跟踪器作为你的主要工作场所，你可以开始邀请在社交媒体上与你接触的外部人员在追踪器中进一步地讨论。简单的如，“感谢您的反馈！听起来像是（某个公共问题的链接）？” ，这可以在很大程度上向外界传达你的组织没有隐藏的内容，并欢迎他们的参与。
**4、 设置一个“元”追踪器。** 在一开始，你的问题追踪器很自然聚焦在*具体产品*上。当你准备好开放到一个新的水平时，考虑设置一个关于你的*组织*本身的问题跟踪。在 Gratipay，我们有一个称之为 “Inside Gratipay”的公共问题追踪器，我们愿意在其中讨论我们组织的任何方面，从[我们的预算](https://github.com/gratipay/inside.gratipay.com/issues/928)到[我们的法律结构](https://github.com/gratipay/inside.gratipay.com/issues/72)到[我们的名字](https://github.com/gratipay/inside.gratipay.com/issues/73)。 是的，这有时有点混乱 —— 重命名组织是一个特别激烈的[争议话题](http://bikeshed.com/)！但对我们来说，在社区参与方面的好处是值得的。
**5、 将你的元追踪器用于加入过程。** 一旦你有一个元问题追踪器，就有了一个新的加入过程：邀请潜在的伙伴创建自己的入场券。如果他们以前从未使用过你的特定的问题追踪器，那么这将是他们学习的极好机会。注册帐号并提交问题应该很简单（如果不是，请考虑切换工具！）。这将让你的新伙伴尽早跨过门槛，开始分享参与感，并在组织内部拥有一席之地。当然，没有问题是愚蠢的，尤其是在某个人的入场券中更是如此。这是你的新伙伴熟悉组织工作方式时询问任何问题的地方。你需要确保快速回复他们的问题，让他们参与并帮助他们融入你的组织。这也是一个很好的方法来记录你最终授予这个人的各种系统的访问权限。至关重要的是，这可以[在雇佣他们之前](https://opensource.com/open-organization/16/5/employees-let-them-hire-themselves)开始。
**6、 雷达项目。** 大多数问题跟踪器包括一些组织和排序任务的方法。例如，GitHub 有[里程碑](https://help.github.com/articles/creating-and-editing-milestones-for-issues-and-pull-requests/)和[项目](https://help.github.com/articles/about-projects/)。这些通常旨在使组织成员的工作重点相一致。在 Gratipay，我们发现使用这些工具可以帮助协作者拥有并排序各自的工作重点。与其它的问题跟踪器通常提供的将问题分配给特定个人的做法不同，我们发现这一点提供了不同的价值。 我可能会关心别人正在积极工作的问题，或者我可能有兴趣开始某些事情，但别人先提出来我也很高兴。拥有自己的项目空间来组织我对该组织的工作的看法是与我的伙伴们沟通“我的雷达上有什么”的强大方式。
**7、 使用机器人自动化任务。** 最终，你可能会发现某些任务会一再出现。这表明自动化可以简化你的工作流程。在 Gratipay，我们[构建](https://github.com/gratipay/bot)了一个[机器人](https://github.com/gratipay-bot)帮助我们完成一些重复的任务。诚然，这是一个有点高级的用法。如果你达到了这一点，你能完全使用公共问题追踪器来开放你的组织！
如 Jim Whitehurst 所说 “吸引社区内外参与” ，这些是我们在 Gratipay 内使用我们的问题跟踪器的一些最有用的做法。也就是说，我们一直在学习。如果你有自己的经验分享，请发表评论！
---
作者简介：
Chad Whitacre - 我是 Gratipay 的创始人，Gratipay 是一个开放组织，致力于培育一个感恩、慷慨和爱的经济。我们帮助公司和其它组织为开源买单，以及赞助我们的平台。在线下，我居住在美国宾夕法尼亚州匹兹堡，在线上，我活跃在 GitHub。
---
via: <https://opensource.com/open-organization/17/2/tracking-issues-publicly>
作者：[Chad Whitacre](https://opensource.com/users/whit537) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
安卓编年史（32）：安卓 6.0 棉花糖（2）
|
Ron Amadeo
|
http://arstechnica.com/gadgets/2016/10/building-android-a-40000-word-history-of-googles-mobile-os/32/
|
Doze 就像是一个自动的飞行模式，在你手机不用的时候介入——它真的延长了电池续航。它对于整天或整夜放在桌子上的手机很有效
|
/data/attachment/album/201707/25/232427fnfexnznirnbfnni.jpg.thumb.jpg
|
/data/attachment/album/201707/25/232427fnfexnznirnbfnni.jpg
| true | false | true |
alim0x
| false |
[
"Android",
"安卓编年史"
] |
观点
|
{
"viewnum": 3958,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "123.149.109.175",
"message": "”如果不格式化的话，你没法取出存储卡 茶道 其它地方使用“此处有误",
"username": "softpaopao [Chrome 59.0|Windows 10]",
"date": "2017-07-27T21:24:00"
},
{
"postip": "123.120.68.30",
"message": "谢谢！",
"username": "linux [Chrome 59.0|Mac 10.11]",
"date": "2017-07-28T20:12:06"
}
] |
[
{
"raid": 8712,
"displayorder": 0
},
{
"raid": 8726,
"displayorder": 1
}
] |
Doze 就像是一个自动的飞行模式，在你手机不用的时候介入——它真的延长了电池续航。它对于整天或整夜放在桌子上的手机很有效
| 2017-07-26T10:23:00 | 2017-07-26T10:23:00 | 8,725 |
/article-8725-1.html
|
#### 幕后变化
棉花糖对自棒棒糖引入的节电任务调度器 API 进行了扩展。任务调度器将应用后台进程从随意唤醒设备规整成一个有组织的系统。任务调度器基本上就是一个后台进程的交通警察。
在棉花糖中，谷歌还添加了一个 “Doze（休眠）”模式来在设备闲置的时候节约更多电量。如果设备静止不动，未接入电源，并且屏幕处于关闭状态，它会慢慢进入低功耗离线模式，锁定后台进程。在一段时间之后，网络连接会被禁用。唤醒会被锁定——应用会请求唤醒手机来运行后台进程——而它会被忽略。系统警报（不含用户设置的闹钟）以及[任务调度器](http://arstechnica.com/gadgets/2014/11/android-5-0-lollipop-thoroughly-reviewed/6/#h2)也会被关闭。
如果你曾经发现把设备设置为飞行模式，并且注意到电池续航延长了许多，Doze 就像是一个自动的飞行模式，在你手机不用的时候介入——它真的延长了电池续航。它对于整天或整夜放在桌子上的手机很有效，对于平板就更好了，因为它常常被遗忘在咖啡桌上。
唯一能把设备从 Doze 模式唤醒的来自谷歌云消息推送服务的“高优先级消息”。这是为信息服务准备的，所以即使设备处于休眠状态，也能够收取信息。
“应用待机”是另一项或多或少有用的节电特性，它在后台静默运行。这背后的逻辑很简单：如果你和应用停止交互一段时间，安卓就认为它是不重要的，并取消它访问网络和后台进程的权力。
对于应用待机而言，和一个应用“交互”意味着打开一个应用，开始一项前台服务，或者生成一条通知。任何其中的一条操作就会重置该应用的待机计时器。对于每种其它边界情况，谷歌在设置里添加了一个名字意味模糊的“电池优化”界面。用户可以在这里设置应用白名单让它免疫应用待机。至于开发者，他们在开发者设置中有个“不活跃应用”选项可以手动设置应用到待机状态来测试。
应用待机主要是自动禁用你不用的应用，这是个对抗垃圾应用或被遗忘的应用消耗电量的好方法。因为它是完全静默且后台自动执行的，它还能让新手也能拥有一部精心调教过的设备。
谷歌在过去几年尝试了很多应用备份方案，在棉花糖中它又[换了个方案](http://arstechnica.com/gadgets/2015/10/android-6-0-marshmallow-thoroughly-reviewed/6/#h2)。棉花糖的暴力应用备份系统的目标是保存整个应用数据文件夹到云端。这是可能的并且在技术上是可行的，但即便是谷歌自己的应用对它的支持都不怎么好。设置好一部新安卓手机依然是个大麻烦，要处理无数的登录和弹出教程。
到界面这里，棉花糖的备份系统使用了谷歌 Drive 应用。在谷歌 Drive 的设置中有一个“管理备份”界面，不仅会显示新备份系统的应用数据，还有谷歌过去几年尝试的其它应用备份方案的数据。
藏在设置里的还有一个新的“应用关联”功能，它可以将应用“链接”到网站。在应用关联出现之前，在全新安装的机器上打开一个谷歌地图链接通常会弹出一个“使用以下方式打开”的对话框，来获知你是想在浏览器还是在谷歌地图应用中打开这个链接。
这是个愚蠢的问题，因为你当然是想用应用而不是网站——这不就是你安装这个应用的原因嘛。应用关联让网站拥有者可以将他们的应用和网页相关联。如果用户安装了应用，安卓会跳过“使用以下方式打开”直接使用应用。要激活应用关联，开发者只需要在网站放一些安卓会识别的 json 代码。
应用关联对拥有指定客户端应用的站点来说很棒，比如谷歌地图、Instagram、Facebook。对于有 API 以及多种客户端的站点，比如 Twitter，应用关联界面让用户可以设置任意地址的默认关联应用。不过默认应用关联覆盖了百分之九十的用例，在新手机上大大减少了烦人的弹窗。
可选存储是棉花糖的最佳特性之一。它将 SD 卡从一个二级存储池转换成一个完美的合并存储方案。插入 SD 卡，将它格式化，然后你就有了更多的存储空间，而这是你从来没有想过的事情。
插入 SD 卡会弹出一条设置通知，用户可以选择将卡格式化成“外置”或“内置”存储。“内置”存储选项就是新的可选存储模式，它会将存储卡格式化为 ext4 文件系统。唯一的缺点？那就是存储卡和数据都被“锁定”到你的手机上了。如果不格式化的话，你没法取出存储卡插到其它地方使用。谷歌对于内置存储的使用场景判断就是一旦设置就不再更改。
如果你强行拔出了 SD 卡，安卓会尽它最大的努力处理好。它会弹出一条消息“建议最好将 SD 卡插回”和一个“忘记”这张卡的选项。当然“忘记”这张卡将会导致各种数据丢失，建议最好不要这么做。
不幸的是实际上可以使用可选存储的设备很长时间都没有出现。Nexus 设备不支持存储卡，所以为了测试我们插上了一个 U 盘作为我们的可选存储。OEM 厂商最初抵制这项功能，[LG 和三星](http://arstechnica.com/gadgets/2016/02/the-lg-g5-and-galaxy-s7-wont-support-android-6-0s-adoptable-storage/)都在他们 2016 年初的旗舰机上禁用了它。三星说“我们相信我们的用户需要 microSD 卡是用来在手机和其它设备之间转移数据的”，一旦卡被格式化成 ext4 这就不可能了。
谷歌的实现让用户可以在外置和内置存储选项之间选择。但 OEM 厂商完全拿掉了内置存储功能，不给用户选择的机会。高级用户们对此很不高兴，并且安卓定制组们很快就重启启用了可选存储。在 Galaxy S7 上，第三方定制组甚至在官方发布的[的前一天](http://www.androidpolice.com/2016/03/10/modaco-manages-to-get-adoptable-sd-card-storage-working-on-the-galaxy-s7-and-galaxy-s7-edge-no-root-required/)解除了三星的 SD 卡锁定。
#### 音量和通知
为了更简洁的设计，谷歌将通知优先级控制从音量弹窗中移除了。按下音量键会弹出一个单独的滑动条，对应当前音源控制，还有一个下拉按钮可以展开控制面板，显示所有的三个声音控制条：通知，媒体和闹钟。所有的通知优先级控制还在——它们现在在一个“勿扰模式”的快速设置方块中。
通知控制最有用的新功能之一是允许用户控制抬头通知——现在叫“预览”通知。这项功能让通知在屏幕顶部弹出，就像 iOS 那样。谷歌认为最重要的通知应该提升到高于你普通日常通知的地位。
但是，在棒棒糖中，这项特性引入的时候，谷歌糟糕地让开发者来决定他们的应用是否“重要”。毫无疑问，所有开发者都认为他的应用是世界上最重要的东西。所以尽管最初这项特性是为你亲密联系人的即时消息设计的，最后变成了被 Facebook 的点赞通知所操控。在棉花糖中，每个应用在通知设置都有一个“设置为优先”复选框，给了用户一把大锤来收拾不守规矩的应用。
---
[Ron Amadeo](http://arstechnica.com/author/ronamadeo) / Ron 是 Ars Technica 的评论编缉，专注于安卓系统和谷歌产品。他总是在追寻新鲜事物，还喜欢拆解事物看看它们到底是怎么运作的。[@RonAmadeo](https://twitter.com/RonAmadeo)
---
via: <http://arstechnica.com/gadgets/2016/10/building-android-a-40000-word-history-of-googles-mobile-os/32/>
作者：[RON AMADEO](http://arstechnica.com/author/ronamadeo) 译者：[alim0x](https://github.com/alim0x) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
安卓编年史（33）：安卓 7.0 牛轧糖，Pixel 手机，以及未来
|
Ron Amadeo
|
http://arstechnica.com/gadgets/2016/10/building-android-a-40000-word-history-of-googles-mobile-os/33/
|
见证这这些改变，我们可能正处在安卓历史上最不确定的点上。但在安卓最近的 2016 年 10 月活动前，安卓、Chrome OS以及谷歌 Play 的 SVP Hiroshi Lockheimer 说，他相信我们将来都会动情回顾这些最新的安卓更新。
|
/data/attachment/album/201707/25/234357jg7i9lkllrmop9dh.jpg.thumb.jpg
|
/data/attachment/album/201707/25/234357jg7i9lkllrmop9dh.jpg
| true | false | true |
alim0x
| false |
[
"Android",
"安卓编年史"
] |
观点
|
{
"viewnum": 4630,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "27.223.99.130",
"message": "这个系列文章暂告一段落啦？",
"username": "绿色圣光 [Firefox 53.0|GNU/Linux]",
"date": "2017-07-27T11:15:38"
},
{
"postip": "114.242.248.100",
"message": "没错，结束了！",
"username": "linux [Chrome 59.0|Mac 10.11]",
"date": "2017-07-27T16:41:34"
}
] |
[
{
"raid": 8725,
"displayorder": 0
}
] |
见证这这些改变，我们可能正处在安卓历史上最不确定的点上。但在安卓最近的 2016 年 10 月活动前，安卓、Chrome OS以及谷歌 Play 的 SVP Hiroshi Lockheimer 说，他相信我们将来都会动情回顾这些最新的安卓更新。
| 2017-07-27T10:33:00 | 2017-07-27T10:33:00 | 8,726 |
/article-8726-1.html
|
#### 每月安全更新
在棉花糖发布的几个月前，安卓的“Stagefright”媒体服务器漏洞被披露给了公众，这个漏洞允许在旧版本安卓上远程执行代码。由于这个漏洞影响到了数十亿安卓设备，安卓受到了媒体广泛的批评。
谷歌则以开始一项月度安卓安全更新项目作为回应。每个月它都会收集 bug，修复它们，然后推送新代码给 AOSP 和 Nexus 设备。OEM 厂商——它们已经在更新的泥潭中挣扎（也许是因为不关心）——基本上就是被告知“面对现实”然后跟上步伐。每个其它的主流操作系统有经常的安全更新——这就是成为这么大的平台的代价。为了协调 OEM 厂商，谷歌让他们提前一个月可以获取到更新。30 天之后，发布安全公告并将更新推送给谷歌设备。
月度更新项目是在棉花糖发布的两个月前开始的，但在这个主要的系统更新中谷歌添加了一栏“安卓安全补丁程序级别”到关于手机界面中。这里没有使用晦涩难懂的版本号，就用了日期来表示。这让任何人都能轻松看懂手机系统过时了多久，是个很好的让动作缓慢的 OEM 厂商羞愧的方式。
文本选择菜单现在是个浮动工具条，会在你选择的时候在文本旁边弹出。这里也不止是常规的“剪切/复制/粘贴”命令。应用可以在工具栏上放置特殊选项，比如谷歌文档里的“添加链接”。
在标准的文本命令之后，一个省略号按钮会显示一个二级菜单，应用可以在这里给文本选择菜单添加额外的功能。使用新的“文本处理”API，直接给其它应用传递文本现在变得非常轻松。如果你装了谷歌翻译，在这个菜单上会显示一个“翻译”选项。谷歌搜索也在这个工具栏里为谷歌 Now on Tap 添加了一个“助理”选项。
棉花糖添加了一个隐藏的设置，叫做“系统界面调谐器”。这个部分包含了全方位的高级用户特性和试验性项目。要访问这个设置，你需要下拉通知中心，按住“设置”按钮几秒钟。设置齿轮会旋转，然后最终你会看到一条消息显示系统界面调谐器已解锁。一旦它被打开，你就可以在系统设置的底部，开发者选项附近找到它了。
在系统界面调谐器的第一部分，用户可以在快速设置面板添加自定义瓷片，这项特性后来被重制成了应用可以使用的 API。此时这项特性还很粗糙，基本就是允许用户在文本框里输入一条自定义命令。系统状态图标可以单独打开或关闭，所以如果你真的很讨厌知道你已经连接到另外无线网络，你可以把这个图标关闭。这里有一项受欢迎的电源显示新增特性，可以将电池电量百分比显示嵌入到电池图标中。还有个用来截屏的“演示”模式，它会将正常的状态栏替换成一个假的，干净的版本。
### 安卓 7.0 牛轧糖，Pixel 手机，以及未来
[安卓 7.0 牛轧糖](http://arstechnica.com/gadgets/2016/08/android-7-0-nougat-review-do-more-on-your-gigantic-smartphone/)和 [Pixel 手机](http://arstechnica.com/gadgets/2016/10/google-pixel-review-bland-pricey-but-still-best-android-phone/)几个月前刚刚发布，你可以读读我们对它们的完整评测。二者都有无数我们还没看到最终效果的特性和影响，所以我们暂且搁置，等它真正成为“历史”之后再进行评说。
牛轧糖为了 Daydream VR 对[图形和传感器](http://arstechnica.com/gadgets/2016/08/android-7-0-nougat-review-do-more-on-your-gigantic-smartphone/11/#h1)做出了很大的改动，Daydream VR 是谷歌即将来临的智能手机驱动 VR 体验，[我们已经尝试过了](http://arstechnica.com/gadgets/2016/10/daydream-vr-hands-on-googles-dumb-vr-headset-is-actually-very-clever/)但还没花时间写下点什么。从 Chrome OS 借鉴来了新的“无缝升级”功能，系统拥有两个系统分区，可以在你使用其中一个的时候，对另一个在后台进行静默升级。考虑到 Pixel 是这个功能的唯一首发设备，并且还没有收到更新，我们也不确定这个功能是什么样子的。
牛轧糖最有趣的新功能之一是改进的应用框架，它允许改变应用尺寸大小。这让谷歌可以在手机和平板上实现分屏，在安卓 TV 上实现画中画，以及一个神秘的浮动窗口模式。我们已经能够通过一些软件技巧来访问浮动窗口模式，但还没有看到谷歌在实际产品中使用它。难道它的目标是桌面计算？
安卓和 Chrome OS 则继续走在共同成长的道路上。安卓应用现在已经能够在一些 Chromebook 上[运行了](http://arstechnica.com/gadgets/2016/05/if-you-want-to-run-android-apps-on-chromebooks-youll-need-a-newer-model/)，给了这个“仅 Web”的系统 Play 商店以及一系列的应用生态。有传言称 Chrome OS 和安卓未来将会更加紧密结合成“[Andromeda](http://arstechnica.com/gadgets/2016/09/android-chrome-andromeda-merged-os-reportedly-coming-to-the-pixel-3/)”——一个“Android”和“Chrome”混合而成的词——它可能是一个融合的 Chrome/安卓系统的代号。
我们还没有看到 Pixel 手机会创造怎样的历史。谷歌最近发布了两部新旗舰机 Pixel 和 Pixel XL，加入了硬件竞争之中。谷歌之前和合作伙伴合作生产联名的 Nexus 手机，但 Pixel 产品线用的是“Google”品牌。谷歌声明这是一个完全的硬件 OEM，HTC 是合同制造商，就类似苹果把富士康作为合同制造商那样。
拥有自己的硬件改变了谷歌制造软件的方式。谷歌发布了“谷歌助理”作为未来版的“OK Google”语音命令系统。但助理是 Pixel 的独占特性，谷歌没有把它推送给所有安卓设备。谷歌对界面做了一些改变，一个定制版的“Pixel 启动器”主屏应用和一套新的系统界面，这些都是 Pixel 独占的。我们需要时间来见证未来功能点在“安卓”和“Pixel”之间的平衡。
见证这这些改变，我们可能正处在安卓历史上最不确定的点上。但在安卓最近的 2016 年 10 月活动前，安卓、Chrome OS以及谷歌 Play 的 SVP [Hiroshi Lockheimer](http://arstechnica.com/gadgets/2016/10/chatting-with-googles-hiroshi-lockheimer-about-pixel-android-oems-and-more/) 说，他相信我们将来都会动情回顾这些最新的安卓更新。Lockheimer 是现在谷歌事实上的软件统治者，他认为最新的更新会是自安卓八年前亮相以来最有意义的事件。尽管在发布会后他没有对这个观点进行详细阐述，但事实表明明年这时候我们*可能*都不会讨论安卓了——它可能已经是一个安卓/Chrome OS 结合体了！正如 2008 年以来那样，安卓历史的下一篇章一定会更加有趣。
---
[Ron Amadeo](http://arstechnica.com/author/ronamadeo) / Ron 是 Ars Technica 的评论编缉，专注于安卓系统和谷歌产品。他总是在追寻新鲜事物，还喜欢拆解事物看看它们到底是怎么运作的。[@RonAmadeo](https://twitter.com/RonAmadeo)
---
via: <http://arstechnica.com/gadgets/2016/10/building-android-a-40000-word-history-of-googles-mobile-os/33/>
作者：[RON AMADEO](http://arstechnica.com/author/ronamadeo) 译者：[alim0x](https://github.com/alim0x) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
ss：查看网络连接的另一种方法
|
Mathieu Trudel-lapierre
|
https://insights.ubuntu.com/2017/07/25/ss-another-way-to-get-socket-statistics/
|
ss，它是 iproute2 包附带的另一个工具，允许你查询 socket 的有关统计信息。可以完成 netstat 同样的任务，但是，ss 稍微快一点而且命令更简短。
|
/data/attachment/album/201707/27/143650z3odo3rem3ndoeln.jpg.thumb.jpg
|
/data/attachment/album/201707/27/143650z3odo3rem3ndoeln.jpg
| true | false | true |
Vic020
| false |
[
"ss",
"netstat"
] |
技术
|
{
"viewnum": 11388,
"commentnum": 2,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "netstat 是 BSD 的项目 net-tools，已经不适合 Linux 了。要说不好，就是 ss 也是纳粹党卫军的缩写。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-07-27T15:38:19"
},
{
"postip": "171.212.224.136",
"message": "感觉可以哦昂",
"username": "来自四川成都的 Safari 10.1|Mac 10.12 用户",
"date": "2017-08-14T13:32:24"
}
] |
[] |
ss，它是 iproute2 包附带的另一个工具，允许你查询 socket 的有关统计信息。可以完成 netstat 同样的任务，但是，ss 稍微快一点而且命令更简短。
| 2017-07-27T14:36:55 | 2017-07-27T14:36:55 | 8,727 |
/article-8727-1.html
|
在之前的文章中，我提到过 `ss`，它是 iproute2 包附带的另一个工具，允许你查询 socket 的有关统计信息。可以完成 `netstat` 同样的任务，但是，`ss` 稍微快一点而且命令更简短。
直接输入 `ss`，默认会显示与 `netstat` 同样的内容，并且输入类似的参数可以获取你想要的类似输出。例如：
```
$ ss -t
State Recv-Q Send-Q Local Address:Port Peer Address:Port
ESTAB 0 0 127.0.0.1:postgresql 127.0.0.1:48154
ESTAB 0 0 192.168.0.136:35296 192.168.0.120:8009
ESTAB 0 0 192.168.0.136:47574 173.194.74.189:https
[…]
```
`ss -t` 只显示 TCP 连接。`ss -u` 用于显示 UDP 连接，`-l` 参数只会显示监听的端口，而且可以进一步过滤到任何想要的信息。
我并没有测试所有可用参数，但是你甚至可以使用 `-K` 强制关闭 socket。
`ss` 真正耀眼的地方是其内置的过滤能力。让我们列出所有端口为 22（ssh）的连接：
```
$ ss state all sport = :ssh
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
tcp LISTEN 0 128 *:ssh *:*
tcp ESTAB 0 0 192.168.0.136:ssh 192.168.0.102:46540
tcp LISTEN 0 128 :::ssh :::*
```
如果只想看已建立的 socket（排除了 *listening* 和 *closed* ）：
```
$ ss state connected sport = :ssh
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
tcp ESTAB 0 0 192.168.0.136:ssh 192.168.0.102:46540
```
类似的，可以列出指定的 host 或者 ip 段。例如，列出到达 74.125.0.0/16 子网的连接，这个子网属于 Google：
```
$ ss state all dst 74.125.0.0/16
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
tcp ESTAB 0 0 192.168.0.136:33616 74.125.142.189:https
tcp ESTAB 0 0 192.168.0.136:42034 74.125.70.189:https
tcp ESTAB 0 0 192.168.0.136:57408 74.125.202.189:https
```
`ss`与 iptables 的语法非常相同，如果已经熟悉了其语法，`ss` 非常容易上手。也可以安装 iproute2-doc 包， 通过 `/usr/share/doc/iproute2-doc/ss.html` 获得完整文档。
还不快试试! 你就可以知道它有多棒。无论如何，让我输入的字符越少我越高兴。
---
via: <https://insights.ubuntu.com/2017/07/25/ss-another-way-to-get-socket-statistics/>
作者：[Mathieu Trudel-Lapierre](https://insights.ubuntu.com/author/mathieu-trudel-lapierre/) 译者：[VicYu](https://vicyu.com) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Neo4j 图数据库基础
|
Ruth Holloway
|
https://opensource.com/article/17/7/fundamentals-graph-databases-neo4j
|
对于海量的各种非结构化信息来说，图数据库已经成为帮助收集、管理和搜索大量数据的技术。在本文中，我将向你展示图数据库的基础知识，帮助你快速了解概念模型。
|
/data/attachment/album/201707/27/151320s28j8eep22rxee3x.jpg.thumb.jpg
|
/data/attachment/album/201707/27/151320s28j8eep22rxee3x.jpg
| true | false | true |
geekpi
| false |
[
"Neo4j",
"图数据库"
] |
软件开发
|
{
"viewnum": 7248,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9158,
"displayorder": 0
}
] |
对于海量的各种非结构化信息来说，图数据库已经成为帮助收集、管理和搜索大量数据的技术。在本文中，我将向你展示图数据库的基础知识，帮助你快速了解概念模型。
| 2017-07-27T15:13:00 | 2017-07-27T15:13:00 | 8,728 |
/article-8728-1.html
|
>
> 在这个三篇系列文章的第一篇文章中，我们将学习<ruby> 图数据库 <rp> （ </rp> <rt> graph database </rt> <rp> ） </rp></ruby>的基础知识，它支持了这地球上最大的一些数据池。
>
>
>
对于海量的各种非结构化信息来说，图数据库已经成为帮助收集、管理和搜索大量数据的技术。在这三篇系列文章中，我们将使用开源图数据库软件 [Neo4j](https://neo4j.com/) 来研究图数据库。
在本文中，我将向你展示图数据库的基础知识，帮助你快速了解概念模型。在第二篇中，我将向你展示如何启动 Neo4j 数据库，并使用内置的浏览器工具填充一些数据。而且，在本系列的最后一篇文章中，我们将探讨一些在开发工作中使用的 Neo4j 编程库。
掌握图数据库的概念模型是有用的，所以我们从那里开始。图数据库中只存储两种数据：<ruby> 节点 <rt> node </rt></ruby>和<ruby> 边 <rt> edge </rt></ruby>。
* **节点是实体：**诸如人物、发票、电影、书籍或其他具体事物。这些有些等同于关系数据库中的记录或行。
* **边名关系：**连接节点的概念、事件或事物。在关系数据库中，这些关系通常存储在具有链接字段的数据库行中。在图数据库中，它们本身就是有用的，是可以以其自己的权限搜索的对象。
节点和边都可以拥有可搜索的*属性*。例如，如果你的节点代表人，他们可能拥有名字、性别、出生日期、身高等属性。而边的属性可能描述了两个人之间的关系何时建立，见面的情况或关系的性质。
这是一个帮助你可视化的图表：
在这张图中，你知道 Jane Doe 有一个新的丈夫 John；一个女儿（来自她以前的夫妻关系）Mary Smith 和朋友 Robert 和 Rhonda Roe。Roes 有一个儿子 Ryan，他正在与 Mary Smith 约会。
看看它怎么工作？每个节点代表一个独立于其他节点的人。你需要找到关于*那个*人的一切都可以存储在节点的属性中。边描述了人们之间的关系，这与你在程序中需要的一样多。
关系是单向的，且不能是无向的，但这没有问题。由于数据库可以以相同的速度遍历两个方向，并且方向可以忽略，你只需要定义一次此关系。如果你的程序需要定向关系，则可以自由使用它们，但如果双向性是暗含的，则不需要。
另外需要注意的是，图数据库本质上是无 schema 的。这与关系数据库不同，关系数据库每行都有一组列表，并且添加新的字段会给开发和升级带来很多工作。
每个节点都可以拥有一个<ruby> 标签 <rt> label </rt></ruby>；对于大多数程序你需要“输入”这个标签，是对典型的关系数据库中的表名的模拟。标签可以让你区分不同的节点类型。如果你需要添加新的标签或属性，修改程序来用它就行！
使用图数据库，你可以直接开始使用新的属性和标签，节点将在创建或编辑时获取它们。不需要转换东西；只需在你的代码中使用它们即可。在这里的例子中，你可以看到，我们知道 Jane 和 Mary 最喜欢的颜色和 Mary 的出生日期，但是别人没有（这些属性）。这个系统不需要知道它；用户可以在正常使用程序的过程中访问节点时为其添加信息（属性）。
作为一名开发人员，这是一个有用的特性。你可以将新的标签或属性添加到由节点处理的表单中并开始使用它，而不必进行数据库 schema 的修改。对于没有该属性的节点，将不显示任何内容。你可以使用任何一种类型的数据库来为表单进行编码，但是你可以放下在关系型数据库中要进行的许多后端工作了。
让我们添加一些新的信息：
这是一个新的节点类型，它代表一个位置，以及一些相关关系。现在我们看到 John Doe 出生在加利福尼亚州的 Petaluma，而他的妻子 Jane 则出生在德克萨斯州的 Grand Prairie。 他们现在住在得克萨斯州的赛普拉斯，因为 Jane 在附近的休斯顿工作。Ryan Roe 缺乏城市关系对数据库来说没有什么大不了的事情，我们*不知道*那些信息而已。当用户输入更多数据时，数据库可以轻松获取新数据并添加新数据，并根据需要创建新的节点和关系。
了解节点和边应该足以让你开始使用图形数据库。如果你像我一样，已经在考虑如何在一个图中重组你的程序。在本系列的下一篇文章中，我将向你展示如何安装 Neo4j、插入数据，并进行一些基本的搜索。
---
via: <https://opensource.com/article/17/7/fundamentals-graph-databases-neo4j>
作者：[Ruth Holloway](https://opensource.com/users/druthb) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
热烈祝贺！LCTT 第一位达成翻译 500 篇成就的译者 geekpi ！
|
老王
|
今天，Linux 中国开源社区很高兴地宣布，我们旗下的翻译组织 LCTT 的译者 geekpi 在对社区持续贡献了 1371 天之后，胜利达成了 500 篇翻译的成就！
|
/data/attachment/album/201707/27/164802tifmlruifdad77wu.jpg.thumb.jpg
|
/data/attachment/album/201707/27/164802tifmlruifdad77wu.jpg
| true | false | false | false |
[
"LCTT"
] |
新闻
|
{
"viewnum": 6476,
"commentnum": 22,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "221.206.92.236",
"message": "默默顶一个",
"username": "jokerer123 [Firefox 54.0|Windows 10]",
"date": "2017-07-27T17:15:34"
},
{
"postip": "117.176.138.138",
"message": "强势点赞！！！！！！！！",
"username": "第7段材料 [Baidu Spark 8.7|Windows 8.1]",
"date": "2017-07-27T17:36:22"
},
{
"postip": "14.130.112.23",
"message": "thank you guys",
"username": "小刀弯弯 [Firefox 40.0|FreeBSD]",
"date": "2017-07-27T18:03:18"
},
{
"postip": "116.31.81.182",
"message": "点赞！感谢！",
"username": "来自广东广州的 Firefox 56.0|GNU/Linux 用户",
"date": "2017-07-27T19:01:44"
},
{
"postip": "1.204.19.253",
"message": "辛苦了，大侠们，有了你们在下面挖井，我们菜鸟们才有水喝。辛苦了",
"username": "张熙熙 [Firefox 54.0|Fedora]",
"date": "2017-07-27T20:56:12"
},
{
"postip": "125.71.135.196",
"message": "这就是开源精神的真正体现啊！",
"username": "龙瑀璇 [Chrome 59.0|GNU/Linux]",
"date": "2017-07-27T21:25:37"
},
{
"postip": "202.49.101.219",
"message": "谢谢贡献！",
"username": "来自新西兰的 Chrome 59.0|Windows 8.1 用户",
"date": "2017-07-28T05:37:59"
},
{
"postip": "58.240.74.98",
"message": "谢谢贡献",
"username": "来自江苏南京的 Chrome 58.0|Windows 7 用户",
"date": "2017-07-28T08:43:01"
},
{
"postip": "117.182.154.193",
"message": "非常感谢！",
"username": "来自117.182.154.193的 Chrome 59.0|Windows 7 用户",
"date": "2017-07-28T08:47:07"
},
{
"postip": "182.242.224.62",
"message": "膜拜大神，非常感谢！",
"username": "来自云南昆明的 Firefox 54.0|Windows 10 用户",
"date": "2017-07-28T11:04:00"
},
{
"postip": "113.67.159.167",
"message": "赞！6666666",
"username": "nikymaco [Chrome 59.0|Mac 10.11]",
"date": "2017-07-28T11:19:30"
},
{
"postip": "171.81.128.96",
"message": "谢谢啦～",
"username": "来自湖北武汉的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-07-28T11:36:05"
},
{
"postip": "222.92.187.131",
"message": "good job. appreciate the contributions.",
"username": "Mr_Bain [Firefox 52.0|GNU/Linux]",
"date": "2017-07-28T14:55:30"
},
{
"postip": "118.196.232.37",
"message": "这必须支持啊，辛苦了！",
"username": "Wf_talk [Chrome 59.0|GNU/Linux]",
"date": "2017-07-28T21:24:01"
},
{
"postip": "183.198.222.248",
"message": "资磁。。",
"username": "来自河北衡水的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-07-29T21:12:31"
},
{
"postip": "223.81.193.142",
"message": "感谢！",
"username": "绿色圣光 [Firefox 52.0|GNU/Linux]",
"date": "2017-07-29T22:47:50"
},
{
"postip": "180.171.72.52",
"message": "感谢",
"username": "来自上海的 Mobile Safari 10.0|iOS 10.3 用户",
"date": "2017-07-31T01:02:14"
},
{
"postip": "106.38.118.212",
"message": "为一切美好，辛苦了。",
"username": "贵在坚持 [Chrome 59.0|Windows 10]",
"date": "2017-07-31T11:17:08"
},
{
"postip": "116.7.105.44",
"message": "十分感谢",
"username": "来自广东深圳的 Chrome 59.0|Windows 7 用户",
"date": "2017-07-31T18:51:18"
},
{
"postip": "218.205.56.220",
"message": "支持",
"username": "woyuchengying [Chrome 59.0|Windows 10]",
"date": "2017-08-01T12:58:44"
},
{
"postip": "125.46.3.236",
"message": "有积极打造各种轮子的 bestony 的 vizv",
"username": "WangYueScream [Chrome 50.0|Windows 7]",
"date": "2017-08-06T15:37:46"
},
{
"postip": "114.242.250.149",
"message": ":D",
"username": "linux [Chrome 59.0|Mac 10.11]",
"date": "2017-08-07T11:11:59"
}
] |
[
{
"raid": 11096,
"displayorder": 0
}
] |
今天，Linux 中国开源社区很高兴地宣布，我们旗下的翻译组织 LCTT 的译者 geekpi 在对社区持续贡献了 1371 天之后，胜利达成了 500 篇翻译的成就！
| 2017-07-27T16:48:00 | 2017-07-27T16:48:00 | 8,729 |
/article-8729-1.html
|
**今天，Linux 中国开源社区很高兴地宣布，我们旗下的翻译组织 LCTT 的译者 geekpi 在对社区持续贡献了 1371 天之后，胜利达成了 500 篇翻译的成就！**
Linux 中国发展至今，得到了社区各界的鼎力支持，其中支持我们走到今天的一大基础就是成立于 2013 年 9 月 10 日的 LCTT。在这将近四年间，LCTT 为 Linux 中国和开源世界贡献了近 3000 篇文章，其中不乏精心打造的诚意之作，也有颇多的文章值得再三回味品读。
这期间，涌现出了许许多多的贡献者，他们其中有年轻的学生，也有从业多年的专家；有从事嵌入式开发的，也有从事系统运维的；有从事互联网工作的，也有从事医疗行业的。几年来，LCTT 像个大家庭一样，来了很多朋友，也送走了一些兄弟；有因病故去的前选题负责人 DeadFire， 也有勇接重任挑起选题工作的 oska874；有默默承担起 LFS 主要翻译的 martin2011qi 和技术支持的 vizv，也有将漫画翻译推动上线的 bestony 和 GHLandy；有积极打造各种轮子的 bestony 和 vizv，也有默默持之以恒翻译的 geekpi。
今天，我要着重向大家介绍的就是这位 geekpi ！
据 geekpi 的 [LCTT 专页](https://linux.cn/lctt/geekpi)，他于 LCTT 成立一个月后加入了我们，并一直持续活动到今天。他极少出现在我们内部沟通的 QQ 群内，甚至，几乎没有人知道他的名字、年龄、样貌和职业，甚至，连我也只知道一个可以联系到他的快递地址而已。
在 LCTT 里，他是翻译贡献遥遥领先的第一译者，其翻译数量几乎是第二名的三倍、第三名的四倍，其翻译数量是第二名到第七名的总和，占到了 LCTT 翻译总量的 1/6！
*Top 10 of LCTT Translators*
可以说，在我们每年惯例制作的 LCTT 仓库活动的视频中，他是除了作为校对、发布的我和选题 oska874 之外活动最多的人。
让我们向这位默默奉献的译者 geekpi 致敬！或许，这种不为名，不为利，才是一种纯粹的开源贡献精神吧！
这是他的 LCTT 专页成就，请大家膜拜：
*geekpi's profile of LCTT*
最后，有志于加入我们 LCTT 的朋友，[请点此了解 LCTT](https://linux.cn/lctt/)。
|
||||
在 Linux Mint 安装 Linux Kernel 4.12（稳定版）
|
Shekin
|
https://mintguide.org/system/798-install-linux-kernel-4-12-stable-on-linux-mint.html
|
Linus Torvalds 发布了 Linux 内核 4.12。你可以从这里直接下载相关的 deb 包来安装。或者，继续阅读本文，按下面的步骤安装新内核。
|
/data/attachment/album/201707/27/230446qhytdigtz2t6kfn0.jpg.thumb.jpg
|
/data/attachment/album/201707/27/230446qhytdigtz2t6kfn0.jpg
| true | false | true |
vic020
| false |
[
"内核"
] |
技术
|
{
"viewnum": 6208,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linus Torvalds 发布了 Linux 内核 4.12。你可以从这里直接下载相关的 deb 包来安装。或者，继续阅读本文，按下面的步骤安装新内核。
| 2017-07-28T08:00:00 | 2017-07-28T08:00:00 | 8,730 |
/article-8730-1.html
|
**Linus Torvalds** 发布了 **Linux 内核 4.12**。你可以从**[这里](https://mintguide.org/engine/dude/index/leech_out.php?a%3AaHR0cDovL2tlcm5lbC51YnVudHUuY29tL35rZXJuZWwtcHBhL21haW5saW5lL3Y0LjEyLw%3D%3D)**直接下载相关的 **deb** 包来安装。或者，继续阅读本文，按下面的步骤安装新内核。
**警告：Linux 内核是系统的关键元素。在某个硬件设备不正常工作时，可以尝试执行升级，新的内核可能会解决此问题。 但同样的，非必须地更新一个新的内核也可能导致不必要的回滚，例如，无网络连接， 没有声音，甚至是无法正常启动系统，所以安装一个新的内核，请正确认识风险。**
最简单的安装任意内核方法 - 在**Linux Mint** 使用 [UKUU](https://mintguide.org/tools/691-ukuu-ubuntu-kernel-upgrade-utility.html)。
```
TerminalShekin@mylinuxmintpc~$sudo apt-add-repository -y ppa:teejee2008/ppa
sudo apt-get update
sudo apt-get install ukuu
```
**提醒：所有的 Nvidia/AMD 电脑用户， 在安装内核之前，建议切换到 free 版本的驱动。**
**如果决定删除内核 4.12，**
1. 首先，重启计算机，选择 GRUB 菜单中的旧内核启动。系统引导完成之后，通过以下命令删除新的内核：
2. 然后，使用 [UKUU](https://mintguide.org/tools/691-ukuu-ubuntu-kernel-upgrade-utility.html) 程序，或者命令：`sudo apt purge linux-image-4.12-*`
3. 最后，更新 **GRUB** 或者 **[BURG](https://mintguide.org/effects/716-burg-graphical-bootloader-install-to-linux-mint.html)**：`sudo update-grub`
在启动 **GRUB** 的时候，选择**以前的 Linux 版本**即可回到以前版本的内核。
Good Luck!!!
---
via: <https://mintguide.org/system/798-install-linux-kernel-4-12-stable-on-linux-mint.html>
作者：[Shekin](https://mintguide.org/user/Shekin/) 译者：[VicYu](https://vicyu.com) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
漏洞修复八个月后，仍有超过七万台 memcached 服务器面临危险
|
Lucian Constantin
|
https://thenewstack.io/70000-memcached-servers-can-hacked-using-eight-month-old-flaws/
|
当他们对所提交的三个漏洞进行测试时，他们发现只有 200 台需要身份验证的服务器部署了 10 月的补丁，其它的所有服务器都可能通过 SASL 漏洞进行攻击。
|
/data/attachment/album/201707/28/121131nhlbbn7byalcak6k.jpg.thumb.jpg
|
/data/attachment/album/201707/28/121131nhlbbn7byalcak6k.jpg
| true | false | true |
firmianay
| false |
[
"安全漏洞",
"memcached"
] |
新闻
|
{
"viewnum": 4854,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
当他们对所提交的三个漏洞进行测试时，他们发现只有 200 台需要身份验证的服务器部署了 10 月的补丁，其它的所有服务器都可能通过 SASL 漏洞进行攻击。
| 2017-07-28T12:12:00 | 2017-07-28T12:12:00 | 8,731 |
/article-8731-1.html
|
在开源缓存软件 memcached 修复了三个关键漏洞的八个月之后，仍有超过 70000 台未打补丁的缓存服务器直接暴露在互联网上。安全研究员警告说，黑客可能会在服务器上执行恶意代码或从其缓存中窃取潜在的敏感数据。
[memcached](https://memcached.org/) 是一个实现了高性能缓存服务的软件包，用于在内存中存储从数据库和 API 调用中获取的数据块。这有助于提高动态 Web 应用程序的响应速度，使其更加适合大型网站和大数据项目。
虽然 memcached 不是数据库的替代品，但它存储在内存中的数据包括了来自数据库查询的用户会话和其他敏感信息。因此，该服务器在设计上并不能直接暴露在互联网等不受信任的环境中，其最新的版本已经支持了基本身份验证。
去年 10 月份，memcached 的开发者修复了由 [思科 Talos 部门](https://www.talosintelligence.com/) 安全研究员发现并报告的三个远程代码执行漏洞（[CVE-2016-8704](https://www.talosintelligence.com/reports/TALOS-2016-0219/)、[CVE-2016-8705](https://www.talosintelligence.com/reports/TALOS-2016-0220/) 和 [CVE-2016-8706](https://www.talosintelligence.com/reports/TALOS-2016-0221/)）。所有这些漏洞都影响到了 memcached 用于存储和检索数据的二进制协议，其中一个漏洞出现在 [Simple Authentication and Security Layer](https://tools.ietf.org/html/rfc4422) （SASL）的实现中。
在去年 12 月到今年 1 月期间，成队的攻击者从数万个公开的数据库中擦除数据，这包括 MongoDB、CouchDB、Hadoop 和 Elasticsearch 集群。在很多情况下，攻击者勒索想要恢复数据的服务器管理员，然而没有任何证据表明他们的确对所删除的数据进行了复制。
Talos 的研究人员认为， memcached 服务器可能是下一个被攻击的目标，特别是在几个月前发现了漏洞之后。所以在二月份他们决定进行一系列的互联网扫描来确定潜在的攻击面。
扫描结果显示，大约有 108000 个 memcached 服务器直接暴露在互联网上，其中只有 24000 个服务器需要身份验证。如此多的服务器在没有身份验证的情况下可以公开访问已经足够糟糕，但是当他们对所提交的三个漏洞进行测试时，他们发现只有 200 台需要身份验证的服务器部署了 10 月的补丁，其它的所有服务器都可能通过 SASL 漏洞进行攻击。
总的来说，暴露于互联网上的 memcached 服务器有大约 80%，即 85000 个都没有对 10 月份的三个关键漏洞进行安全修复。
由于补丁的采用率不佳，Talos 的研究人员决定对所有这些服务器的 IP 地址进行 whois 查询，并向其所有者发送电子邮件通知。
本月初，研究人员决定再次进行扫描。他们发现，虽然有 28500 台服务器的 IP 地址与 2 月份时的地址不同，但仍然有 106000 台 memcached 服务器暴露在因特网上。
在这 106000 台服务器中，有大约 70%，即 73400 台服务器在 10 月份修复的三个漏洞的测试中仍然受到攻击。超过 18000 个已识别的服务器需要身份验证，其中 99% 的服务器仍然存在 SASL 漏洞。
即便是发送了成千上万封电子邮件进行通知，补丁的采用率也仅仅提高了 10%。
Talos 研究人员在周一的[博客](http://blog.talosintelligence.com/2017/07/memcached-patch-failure.html)中表示：“这些漏洞的严重程度不能被低估。这些漏洞可能会影响到小型和大型企业在互联网上部署的平台，随着最近大量的蠕虫利用漏洞进行攻击，应该为全世界的服务器管理员敲响警钟。如果这些漏洞没有修复，就可能被利用，对组织和业务造成严重的影响。”
这项工作的结论表明，许多网络应用程序的所有者在保护用户数据方面做得不好。首先，大量的 Memcached 服务器直接暴露在互联网上，其中大多数都没有使用身份验证。即使没有任何漏洞，这些服务器上缓存的数据也存在着安全风险。
其次，即使提供了关键漏洞的补丁，许多服务器管理员也不会及时地进行修复。
在这种情况下，看到 memcached 服务器像 MongoDB 数据库一样被大规模攻击也并不奇怪。
---
via: <https://thenewstack.io/70000-memcached-servers-can-hacked-using-eight-month-old-flaws/>
作者：[Lucian Constantin](https://thenewstack.io/author/lucian/) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux “天气预报”
|
Jonathan Corbet
|
https://www.linux.com/news/2017/7/linux-weather-forecast
|
本页面是为了跟踪在不久的将来某个时间内有可能出现在主线内核和/或主要发行版中的 Linux 开发社区的进展情况。你的“首席气象学家”是 LWN.net 执行主编 Jonathan Corbet。
|
/data/attachment/album/201707/28/123643m3x536ztt153g0tk.jpg.thumb.jpg
|
/data/attachment/album/201707/28/123643m3x536ztt153g0tk.jpg
| true | false | true |
geekpi
| false |
[
"Linux",
"内核"
] |
新闻
|
{
"viewnum": 5284,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "117.182.147.98",
"message": "希望能报道Linux API Headers的变化",
"username": "来自117.182.147.98的 Chrome 58.0|GNU/Linux 用户",
"date": "2017-07-28T14:58:51"
}
] |
[] |
本页面是为了跟踪在不久的将来某个时间内有可能出现在主线内核和/或主要发行版中的 Linux 开发社区的进展情况。你的“首席气象学家”是 LWN.net 执行主编 Jonathan Corbet。
| 2017-07-28T12:36:00 | 2017-07-28T12:36:00 | 8,732 |
/article-8732-1.html
|
### 欢迎来到 Linux 天气预报
本页面是为了跟踪在不久的将来某个时间内有可能出现在主线内核和/或主要发行版中的 Linux 开发社区的进展情况。你的“首席气象学家”是 [LWN.net](http://www.lwn.net/) 执行主编 Jonathan Corbet。如果你有改进预测的建议（特别是如果你有一个你认为应该跟踪的项目或修补程序的情况下），请在下面补充你的意见。
### 预测摘要
**当前情况**：内核 4.12 于 7 月 2 日发布。它包含了许多新功能，包括：
* [BFQ 和 Kyber 块 I/O 调度器](https://lwn.net/Articles/720675/)。已经开发多年的 BFQ 在交互式系统上表现更好，这引起了移动设备领域的兴趣。相反，Kyber 是一个更简单的调度程序，旨在用于通常出现在企业配置中的快速设备。
* epoll\_wait() 系统调用现在可以执行网络套接字的繁忙轮询。
* 实时修补机制已经实现了[混合一致性模型](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=d83a7cb375eec21f04c83542395d08b2f6641da2)，这将可以把更复杂的补丁应用于运行中的内核。
* [可信执行框架](https://lwn.net/Articles/717125/)应该使得内核与在 ARM TrustZone 安全世界中运行的代码之间的交互更加容易。
4.12 是最繁忙的内核开发周期之一，合并了近 15000 次更新。有关这些变化来源的概述，请参阅[这里](https://lwn.net/Articles/726950/)。
**短期预测**：4.13 内核预期在 2017 年 9 月初发布。这个内核中会出现的一些变化是：
* 更好地支持非阻塞直接块 I/O 操作。
* [结构布局随机化机制](https://lwn.net/Articles/722293/)是正在进行的内核加固防攻击项目的下一步。
* 内核现在已经[原生支持 TLS 网络协议](https://lwn.net/Articles/666509/)。
* 采取[透明大页交换](https://lwn.net/Articles/717707/)，这使得有更好的内存管理性能。
* 块子系统中回写错误的处理[已经改进](https://lwn.net/Articles/724307/)，这使得错误不太可能不告知程序而写入数据。
4.13 内核现在处于稳定时期，所以在这个开发周期的剩余时间内只会接受修复补丁。
这篇[文章](http://purl.org/dc/elements/1.1/)根据[知识共享署名 - 共享 3.0 许可证](http://creativecommons.org/licenses/by-sa/3.0/)获得许可。
---
via: <https://www.linux.com/news/2017/7/linux-weather-forecast>
作者：[JONATHAN CORBET](https://www.linux.com/users/corbet) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一年之后，React.js 许可协议再起争端
|
薛亮
|
在 2016 年 7 月，Facebook 公司的 React.js 开源许可协议曾引起激烈争论。一年过后，该协议再次成为开源社区的头条新闻。
|
/data/attachment/album/201707/28/210036ozbse4fr1y1sofrb.jpg.thumb.jpg
|
/data/attachment/album/201707/28/210036ozbse4fr1y1sofrb.jpg
| true | false | false | false |
[
"Facebook",
"专利",
"许可证",
"React.js"
] |
开源智慧
|
{
"viewnum": 19327,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "124.234.46.151",
"message": "这个博客主题真是太难看了",
"username": "来自吉林吉林市的 Firefox 54.0|GNU/Linux 用户",
"date": "2017-07-30T09:38:11"
},
{
"postip": "116.31.81.182",
"message": "这很不facebook",
"username": "echoma [Firefox 56.0|GNU/Linux]",
"date": "2017-07-31T13:54:21"
},
{
"postip": "60.246.88.28",
"message": "有很多公司都開始用轉用Vue",
"username": "来自澳门的 Chrome Mobile 60.0|Android 6.0 用户",
"date": "2017-08-20T11:43:15"
}
] |
[
{
"raid": 6232,
"displayorder": 0
},
{
"raid": 8764,
"displayorder": 0
},
{
"raid": 8784,
"displayorder": 0
},
{
"raid": 8876,
"displayorder": 0
},
{
"raid": 8882,
"displayorder": 0
},
{
"raid": 8895,
"displayorder": 0
},
{
"raid": 8910,
"displayorder": 0
},
{
"raid": 6278,
"displayorder": 1
},
{
"raid": 7309,
"displayorder": 2
}
] |
在 2016 年 7 月，Facebook 公司的 React.js 开源许可协议曾引起激烈争论。一年过后，该协议再次成为开源社区的头条新闻。
| 2017-07-29T09:23:00 | 2017-07-29T09:23:00 | 8,733 |
/article-8733-1.html
|
>
> 在 2016 年 7 月，Facebook 公司的 React.js 开源许可协议曾引起激烈争论。一年过后，该协议再次成为开源社区的头条新闻。
>
>
>
### 背景介绍
React.js 是 Facebook 推出的一个用来构建用户界面的 JavaScript 库，起源于 Facebook 的内部项目，用来架设 Instagram 的网站。
* 2013 年 5 月，[Facebook 将 React.js 开源](https://code.facebook.com/projects/176988925806765/react/)。
* 2016 年 7月，React.js 开源许可协议中的附加专利条款引发争议。
* 2016 年 11 月，Facebook [发布官方问答](https://react-etc.net/entry/react-patents-facebook-license-faq-adoption-by-apple-and-microsoft)，对附加专利条款进行澄清。
* 2017 年 7 月，Apache 基金会禁止使用遵循 BSD 许可证 + 专利开源协议的 JAR 包。
### Apache 基金会的立场
2017 年 7 月，针对 Facebook 公司的 BSD 许可证 + 专利开源协议，Apache 基金会提出了如下建议：
1. 任何新项目、子项目或代码库都不允许使用遵循 Facebook 公司 “BSD 许可证 + 专利开源协议”的 jar 包。换句话说，如果你之前没有使用过，之后也不允许去使用。这种许可协议被 Apache 基金会列为 X 类别（Cat-X）。
2. 如果你一直在使用，并且在 **release** 中已经这么做了，那么在 2017 年 8 月 31 日之前，你将暂时从 X 类别中被排除。在此之后，任何和所有使用 Facebook 公司 “BSD 许可证+专利开源协议”的产品都将被 Apache 基金会禁止使用，你必须找到采用了合适许可证的替代品，或者放弃使用。这种情况没有例外。
3. 上述条款没有涵盖的任何其他情形也禁止使用。
X 类别被定义为“Apache 产品中可能不允许的许可证”，目前包括 GNU GPL、GNU LGPL、BCL、BSD-4-Clause 等许可证。有关[禁用许可证列表](https://www.apache.org/legal/resolved.html#category-x)可以在 Apache 基金会网站上[查询](https://www.apache.org/legal/resolved.html#category-x)。
### Facebook 的 “BSD 许可证 + 专利开源协议”
React 是一种流行的用于创建丰富用户界面的 JavaScript 技术，最初来源于 Facebook，并被广泛使用。该技术依据 BSD 许可证进行开源，但是，它的附加专利条款需要特别注意（以下为节选）。
>
> Facebook, Inc.（Facebook）特此授予软件的每个接收人（“你”）基于任何<ruby> “必要权利要求” <rp> （ </rp> <rt> Necessary Claims </rt> <rp> ） </rp></ruby>的永久的、全球范围的、免版税的、非排他的、不可撤销的许可（遵守以下终止条款），可以制造、曾经制造、使用、销售、许诺销售、进口以及转移软件。
>
>
> 如果您（或任何您的子公司、关联方或代理商）直接或间接地启动了专利主张，或从专利主张中直接获取经济利益，本协议授予的许可将自动终止，恕不另行通知：（i）针对 Facebook 或其任何子公司或关联方；（ii）全部或部分来自于 Facebook 或其任何子公司或关联方的任何软件、技术、产品或服务的专利主张针对任何一方；或（iii）与软件相关的任何一方。尽管如此，如果 Facebook 或其任何子公司或关联方首先对你提起专利侵权诉讼指控，你在该诉讼中针对与软件无关的一方提起专利侵权反诉，你所被授予的许可不会因反诉而在本段第（i）款的规定下终止。
>
>
>
如果你的项目中正在使用或打算使用 React，你可能需要去咨询律师了。由于专利条款的限制，你不能做任何构成与 Facebook 竞争的事情。如果你采取法律行动或者以其他方式挑战 Facebook，那么你使用 React 的许可会被立即撤销。
如果你与其他使用 React 的公司发生法律纠纷，那你使用 React 的许可也会被撤销。Aurelia 框架创建者、Angular 2 开发团队前成员 [Rob Eisenberg 表示](https://react-etc.net/entry/rob-eisenberg-compares-angularjs-angular-2-aurelia-ember-polymer-and-react)，这就是 Google 公司和 Microsoft 公司的员工在工作中不允许使用 React.js 的原因。
虽然这只是在理论上对大多数采用 React 的项目可能产生的影响，但仍然值得特别注意，并且，类似 WordPress Calypso 这种已经与 React.js 建立了深刻联系的项目，可能会受到限制。运营 WordPress 的 Automattic 公司对一些小官司并不陌生，但这次很可能成为 Facebook 这个大公司的诉讼对象。
Drupal 和 WordPress 等许多开源产品都在采用 Facebook 公司的 React.js 技术。对于 Automattic 公司这种拥有开源产品的公司来说，未来如果被 Facebook 认定与 Facebook 构成竞争，将会是一个棘手的问题。
目前 Facebook 正如日中天，以上可能性发生的几率比较小，但如同 Yahoo 公司一样，Facebook 总有一天会从神坛跌落。到那时，Facebook 公司很有可能会从竞争角度充分利用许可协议所赋予的权利。所以，如果你打算利用 React.js 创建一个有可能终结 Facebook 神话的产品，最好先咨询你的律师。
但是，美国专利法非常复杂，尤其是在知识产权相关问题上，往往难以解释。从 Google 和 Oracle 公司有关安卓使用 Java 的争议可以看出，解决此类问题往往需要好几年时间。这意味着你必须要财大气粗，即使是你最后赢了官司。
### Facebook 公司的官方问答
React 的技术优势难以挑战。从开发者构建 web 用户界面方面来说，React 引发了一场变革。Facebook 在某些方面不太清楚的许可协议（BSD 许可证+专利）在开源开发者中间引发了激烈争论。开源社区继续坚持对“邪恶公司”的抵制，而 Facebook 很容易被归为此类公司。
2016 年 11 月，Facebook 澄清了其在 React、React Native 和其他许多项目中广泛采用的开源许可协议方面的立场。与任何法律文本一样，软件许可协议非常难以解释。Facebook 提供了一个 [FAQ](https://code.facebook.com/pages/850928938376556) 来回应经常被问到的问题。其中包括：
1. 如果我创建了一个竞争性产品，那么 Facebook 公司 “BSD 许可证+专利许可协议”中的附加专利授权是否会被终止？
2. 如果我用专利侵权以外的理由起诉 Facebook，那么 Facebook 公司 “BSD许可证+专利许可协议”中的附加专利授权是否会被终止？
3. 如果 Facebook 公司首先起诉我专利侵权，而我反诉 Facebook 公司专利侵权，那么 Facebook 公司 “BSD许可证+专利许可协议”中的附加专利授权是否会被终止？
4. Facebook 公司 “BSD 许可证+专利许可协议”中的附加专利授权的终止是否也会导致版权许可的终止？
对 1、2、4 的回答是明确的“**否**”，而对于第 3 个问题，FAQ 中规定，反诉主张不得与 Facebook 任何专利相关。上述官方说法比较可靠，在这个 Facebook 即便成为专利流氓也所获甚微的时刻，Facebook 仍然坚持其对 React 许可协议的看法。
### 使用 React.js 的开发者怎么办？
Apple 和 Microsoft 等行业巨头对于采用 React 的态度令人关注。有报道称，由于担心法律纠纷，这些巨头们已经禁止在项目中使用 React UI 库。但显然这是一个引发争议的问题，因为两家巨头都发布了使用 React 的网络资源或库。
Microsoft 提供了一个用于扩展 PowerPoint 和其他 Office365 产品的 React UI 组件库。Apple 开发者网站上的 API 文档采用 React.js 构建。
以上两款产品都不是两家公司的核心产品，Apple 也不太可能发布一款利用 React Native 编写的 iOS 邮件客户端。值得注意的是，虽然两家公司都看到了利用 React 创建 web 用户界面的价值，但它们的法律部门也没有因此遇到麻烦。
所以对大多数应用案例来说，似乎专利诉讼被严格限制在使用中的具体工具上，在这种情况下无需过分担心。由于使用了宽松的 BSD 许可证，对于开发者来说，React 实际上比使用传染性的 GPL 许可证的库更为安全。
Facebook 公司的数据库引擎 RocksDB 正准备[将许可证更改为 Apache 2.0](https://github.com/facebook/rocksdb/commit/3c327ac2d0fd50bbd82fe1f1af5de909dad769e6)。但 React.js 是一个特殊的项目，Facebook 公司似乎有意继续保留专利条款。
虽然商业实体很乐意在产品中使用 React 授权代码，尽管 WordPress 等许多受欢迎的开源项目仍将继续采用 React，但开源社区对 Facebook 不断捍卫和澄清这种特殊授权感到了厌倦。
因此，如果你想找到类似 [Solr](https://lucene.apache.org/solr/) 这种采用 React UI 的 Apache 项目，可能还需要很长时间。幸运的是，React 本身并非独一无二，你的项目可以采用与 React 类似的替代品，例如 [Preact](https://preactjs.com/) 或 [Inferno](https://infernojs.org/)，而不用担心遇到 React 的专利授权问题。
### 参考来源
* <https://react-etc.net/entry/your-license-to-use-react-js-can-be-revoked-if-you-compete-with-facebook>
* <https://react-etc.net/entry/react-patents-facebook-license-faq-adoption-by-apple-and-microsoft>
* <https://react-etc.net/entry/apache-foundation-bans-use-of-facebook-bsd-patents-licensed-libraries-like-react-js>
* <https://github.com/facebook/react/blob/master/PATENTS>
（题图：facebook.github.io）
---
编译：
薛亮，北京集慧智佳知识产权管理咨询股份有限公司互联网事业部 高级咨询师，擅长专利检索，专利分析，竞争对手跟踪，FTO分析，开源软件知识产权风险分析，致力于为互联网企业，高科技公司提供知识产权咨询服务。
|
||||
GPL 没落了吗？
|
Jono Bacon
|
https://opensource.com/article/17/2/decline-gpl
|
为什么 GPL 2.0 的使用率跌的这么多但是 GPL 3.0 仅仅是涨了一丁点？为什么 MIT 协议和 Apache 协议的使用率涨了那么多?
|
/data/attachment/album/201707/29/230852j2fdf4cvjvf6fxf7.jpg.thumb.jpg
|
/data/attachment/album/201707/29/230852j2fdf4cvjvf6fxf7.jpg
| true | false | true |
name1e5s
| false |
[
"GPL",
"开源许可证"
] |
观点
|
{
"viewnum": 5724,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "117.182.154.193",
"message": "主要是GPL可以绕过去了",
"username": "来自117.182.154.193的 Chrome 60.0|Windows 7 用户",
"date": "2017-07-31T10:15:13"
},
{
"postip": "118.122.120.11",
"message": "发重了。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-07-31T10:21:13"
},
{
"postip": "218.19.206.178",
"message": "关键最大的GPL2支持者还有linux，所以不可能没落的",
"username": "Wf_talk [Chrome 59.0|GNU/Linux]",
"date": "2017-07-31T18:35:57"
}
] |
[] |
为什么 GPL 2.0 的使用率跌的这么多但是 GPL 3.0 仅仅是涨了一丁点？为什么 MIT 协议和 Apache 协议的使用率涨了那么多?
| 2017-07-31T10:00:00 | 2017-07-31T10:00:00 | 8,735 |
/article-8735-1.html
|
不久之前我看到了 RedMonk 的 Stephen O'Grady 发了一个[关于开源协议](https://twitter.com/sogrady/status/820001441733607424)的有趣的推特，那个推特里面有这张图。
这张图片显示了从 2010 到 2017 年间各种开源协议之间的使用率的变化。在这张图片里，显然 GPL 2.0 —— 最纯净的 copyleft 协议之一 —— 的使用率降低了一多半。该图表表明，开源项目中 [MIT](https://opensource.org/licenses/MIT) 协议和 [Apache](http://apache.org/licenses/) 协议开始受欢迎。[GPL 3.0](https://www.gnu.org/licenses/gpl-3.0.en.html) 的使用率也有所上涨。
这些意味着什么？
为什么 GPL 2.0 的使用率跌的这么多但是 GPL 3.0 仅仅是涨了一丁点？为什么 MIT 协议和 Apache 协议的使用率涨了那么多?
当然，有很多原因可以解释这件事情，但是我想这是因为商业开源项目的增多，以及商业社会对于 GPL 协议的担心导致的，我们细细掰扯。
### GPL 协议与商业社会
我知道我要说的可能会激怒一些 GPL 粉，所以在你们开始喷之前，我想说明的是：我支持 GPL，我也是 GPL 粉丝。
我写过的所有软件都使用的是 GPL 协议，我也是一直是积极出资支持 [自由软件基金会](http://www.fsf.org/) 以及 [软件自由保护组织](https://sfconservancy.org/) 以及他们的工作的，我支持使用 GPL 协议。我在这说的无关 GPL 的合法性或者 GPL 的巨大价值 —— 毫无疑问这是一个好协议 —— 我在这要说的是业内对于这个协议的看法。
大概四年之前，我参加了一个叫做<ruby> 开源智库 <rt> Open Source Think Tank </rt></ruby>的峰会。这个峰会是一个私人小型峰会，每年都会把各大开源企业的管理人员请到加利福尼亚的酒庄。这个峰会聚焦于建立关系、构建联盟，找到并解决行业问题。
在这个峰会上，有一个分组研究，在其中，与会者被分成小组，被要求给一个真实存在的核心的开源技术推荐一个开源协议。每个小组都给出了回应。不到十分之一的小组推荐了宽容许可证，没有人推荐 GPL 许可证。
我看到了开源行业对于 Apache 协议以及 MIT 协议的逐步认可，但是他们却对花时间理解、接受和熟悉 GPL 这件事高高挂起。
在这几年里，这种趋势仍在蔓延。除了 Black Duck 的调查之外， 2015 年 [GitHub 上的开源协议调查](https://github.com/blog/1964-open-source-license-usage-on-github-com) 也显示 MIT 是人们的首选。我还能看到，在我工作的 XPRIZE （我们为我们的 [Global Learning XPRIZE](http://learning.xprize.org/) 选择了开源协议），在我作为[社区领导顾问](http://www.jonobacon.org/consulting)的工作方面，我也能感觉到那种倾向，因为越来越多的客户觉得把他们的代码用 GPL 发布不舒服。
随着 [大约 65% 的公司对开源事业做贡献](https://opensource.com/business/16/5/2016-future-open-source-survey) ，自从 2010 年以后显然开源行业已经引来了不少商业兴趣和投资。我相信，我之前说的那些趋势，已经表明这行业不认为 GPL 适合搞开源生意。
### 连接社区和公司
说真的，GPL 的没落不太让人吃惊，因为有如下原因。
首先，开源行业已经转型升级，它要在社区发展以及……你懂的……真正能赚钱的商业模型中做出均衡，这是它们要做的最重要的决策。在开源思想发展之初，人们有种误解说，“如果你搞出来了，他们就会用”，他们确实会来使用你的软件，但是在很多情况下，都是“如果你搞出来了，他们不是一定要给你钱。”
随着历史的进程，我们看到了许多公司，比如 Red Hat、Automattic、Docker、Canonical、Digital Ocean 等等等等，探索着在开源领域中赚钱的法子。他们探索过分发模式、服务模式，核心开源模式等等。现在可以确定的是，传统的商业软件赚钱的方式已经不再适用开源软件；因此，你得选择一个能够支持你的公司的经营方式的开源协议。在赚钱和免费提供你的技术之间找到平衡在很多情况下是很困难的一件事。
这就是我们看到那些变化的原因。尽管 GPL 是一个开源协议，但是它根本上是个自由软件协议，作为自由软件协议，它的管理以及支持是由自由软件基金会提供的。
我喜欢自由软件基金会的作品，但是他们已经把观点局限于软件必须 100% 绝对自由。对于自由软件基金会没有多少可以妥协的余地，甚至很多出名的开源项目（比如很多 Linux 发行版）仅仅是因为一丁点二进制固件就被认为是 “非自由” 软件。
对于商业来说，最复杂的是它不是非黑即白的，更多的时候是两者混合的灰色，很少有公司有自由软件基金会（或者类似的组织，比如软件自由保护组织）的那种纯粹的理念，因此我想那些公司也不喜欢选择和那些理念相关的协议。
我需要说明，我不是在这是说自由软件基金会以及类似的组织（比如软件自由保护组织）的错。他们有着打造完全自由的软件的目标，对于他们来说，走它们选择的路十分合理。自由软件基金会以及软件自由保护组织做了*了不起*的工作，我将继续支持这些组织以及为他们工作的人们。我只是觉得这种对纯粹性的高要求的一个后果就是让那些公司认为自己难以达到要求，因此，他们使用了非 GPL 的其他协议。
我怀疑 GPL 的使用是随着开源软件增长而变化的。在以前，启动（开源）项目的根本原因之一是对开放性和软件自由的伦理因素的严格关注。GPL 无疑是项目的自然选择，Debian、Ubuntu、Fedora 和 Linux 内核以及很多都是例子。
近年来，尽管我们已经看到了不再那么挑剔的一代开发者的出现，但是如果我说的过激一些，他们缺少对于自由的关注。对于他们来说开源软件是构建软件的务实、实用的一部分，而无关伦理。我想，这就是为什么我们发现 MIT 和 Apache 协议的流行的原因。
### 未来 ?
这对于 GPL 意味着什么？
我的猜想是 GPL 依然将是一个主要选项，但是开发者将将之视为纯粹的自由软件协议。我想对于软件的纯粹性有高要求的项目会优先选择 GPL 协议。但是对于商业软件，为了保持我们之前讨论过的那种平衡，他们不会那么做。我猜测， MIT 以及 Apache 依然会继续流行下去。
不管怎样，好消息是开源/自由软件行业确实在增长。无论使用的协议会发生怎样的变化，技术确实变得更加开放，可以接触，人人都能使用。
---
作者简介：
Jono Bacon - Jono Bacon 是一位领袖级的社区管理者、演讲者、作者和播客主。他是 Jono Bacon 咨询公司的创始人，提供社区战略和执行、开发者流程和其它的服务。他之前任职于 GitHub、Canonical 和 XPRIZE、OpenAdvantage 的社区总监，并为大量的组织提供咨询和顾问服务。
---
via: <https://opensource.com/article/17/2/decline-gpl>
作者：[Jono Bacon](https://opensource.com/users/jonobacon) 译者：[name1e5s](https://github.com/name1e5s) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
网络分析利器：在 Ubuntu 16.04 上安装 Bro
|
Giuseppe Molica
|
https://www.unixmen.com/how-to-install-bro-ubuntu-1604/
|
Bro 是一个开源的网络分析框架，侧重于网络安全监控。这是一项长达 15 年的研究成果，被各大学、研究实验室、超级计算机中心和许多开放科学界广泛使用。
|
/data/attachment/album/201707/30/110852kjgkm5pkdygk5jep.jpg.thumb.jpg
|
/data/attachment/album/201707/30/110852kjgkm5pkdygk5jep.jpg
| true | false | true |
firmianay
| false |
[
"网络监控",
"Bro"
] |
技术
|
{
"viewnum": 8750,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Bro 是一个开源的网络分析框架，侧重于网络安全监控。这是一项长达 15 年的研究成果，被各大学、研究实验室、超级计算机中心和许多开放科学界广泛使用。
| 2017-07-30T11:08:00 | 2017-07-30T11:08:00 | 8,736 |
/article-8736-1.html
|
[](https://www.unixmen.com/wp-content/uploads/2017/07/brologo.jpg)
### 简介：Bro 网络分析框架
Bro 是一个开源的网络分析框架，侧重于网络安全监控。这是一项长达 15 年的研究成果，被各大学、研究实验室、超级计算机中心和许多开放科学界广泛使用。它主要由伯克利国际计算机科学研究所和伊利诺伊大学厄巴纳-香槟分校的国家超级计算机应用中心开发。
Bro 的功能包括：
* Bro 的脚本语言支持针对站点定制监控策略
* 针对高性能网络
* 分析器支持许多协议，可以在应用层面实现高级语义分析
* 它保留了其所监控的网络的丰富的应用层统计信息
* Bro 能够与其他应用程序接口实时地交换信息
* 它的日志全面地记录了一切信息，并提供网络活动的高级存档
本教程将介绍如何从源代码构建，并在 Ubuntu 16.04 服务器上安装 Bro。
### 准备工作
Bro 有许多依赖文件:
* Libpcap ([http://www.tcpdump.org](http://www.tcpdump.org/))
* OpenSSL 库 ([http://www.openssl.org](http://www.openssl.org/))
* BIND8 库
* Libz
* Bash (BroControl 所需要)
* Python 2.6+ (BroControl 所需要)
从源代码构建还需要：
* CMake 2.8+
* Make
* GCC 4.8+ or Clang 3.3+
* SWIG
* GNU Bison
* Flex
* Libpcap headers
* OpenSSL headers
* zlib headers
### 起步
首先，通过执行以下命令来安装所有必需的依赖项：
```
# apt-get install cmake make gcc g++ flex bison libpcap-dev libssl-dev python-dev swig zlib1g-dev
```
#### 安装定位 IP 地理位置的 GeoIP 数据库
Bro 使用 GeoIP 的定位地理位置。安装 IPv4 和 IPv6 版本：
```
$ wget http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz
$wget http://geolite.maxmind.com/download/geoip/database/GeoLiteCityv6-beta/GeoLiteCityv6.dat.gz
```
解压这两个压缩包：
```
$ gzip -d GeoLiteCity.dat.gz
$ gzip -d GeoLiteCityv6.dat.gz
```
将解压后的文件移动到 `/usr/share/GeoIP` 目录下：
```
# mvGeoLiteCity.dat /usr/share/GeoIP/GeoIPCity.dat
# mv GeoLiteCityv6.dat /usr/share/GeoIP/GeoIPCityv6.dat
```
现在，可以从源代码构建 Bro 了。
### 构建 Bro
最新的 Bro 开发版本可以通过 `git` 仓库获得。执行以下命令：
```
$ git clone --recursive git://git.bro.org/bro
```
转到克隆下来的目录，然后使用以下命令就可以简单地构建 Bro：
```
$ cd bro
$ ./configure
$ make
```
`make` 命令需要一些时间来构建一切。确切的时间取决于服务器的性能。
可以使用一些参数来执行 `configure` 脚本，以指定要构建的依赖关系，特别是 `--with-*` 选项。
### 安装 Bro
在克隆的 `bro` 目录中执行：
```
# make install
```
默认安装路径为 `/usr/local/bro`。
### 配置 Bro
Bro 的配置文件位于 `/usr/local/bro/etc` 目录下。 这里有三个文件:
* `node.cfg`，用于配置要监视的单个节点（或多个节点）。
* `broctl.cfg`，BroControl 的配置文件。
* `networks.cgf`，包含一个使用 CIDR 标记法表示的网络列表。
#### 配置邮件设置
打开 `broctl.cfg` 配置文件:
```
# $EDITOR /usr/local/bro/etc/broctl.cfg
```
查看 `Mail Options` 选项，并编辑 `MailTo` 行如下:
```
# Recipient address for emails sent out by Bro and BroControl
MailTo = admin@example.com
```
保存并关闭。还有许多其他选项，但在大多数情况下，默认值就足够好了。
#### 选择要监视的节点
开箱即用，Bro 被配置为以独立模式运行。在本教程中，我们就是做一个独立的安装，所以没有必要改变。但是，也请查看 `node.cfg` 配置文件：
```
# $EDITOR /usr/local/bro/etc/node.cfg
```
在 `[bro]` 部分，你应该看到这样的东西：
```
[bro]
type=standalone
host=localhost
interface=eth0
```
请确保 `inferface` 与 Ubuntu 16.04 服务器的公网接口相匹配。
保存并退出。
#### 配置监视节点的网络
最后一个要编辑的文件是 `network.cfg`。使用文本编辑器打开它：
```
# $EDITOR /usr/local/bro/etc/networks.cfg
```
默认情况下，你应该看到以下内容：
```
# List of local networks in CIDR notation, optionally followed by a
# descriptive tag.
# For example, "10.0.0.0/8" or "fe80::/64" are valid prefixes.
10.0.0.0/8 Private IP space
172.16.0.0/12 Private IP space
192.168.0.0/16 Private IP space
```
删除这三个条目（这只是如何使用此文件的示例），并输入服务器的公用和专用 IP 空间，格式如下：
```
X.X.X.X/X Public IP space
X.X.X.X/X Private IP space
```
保存并退出。
### 使用 BroControl 管理 Bro 的安装
管理 Bro 需要使用 BroControl，它支持交互式 shell 和命令行工具两种形式。启动该 shell：
```
# /usr/local/bro/bin/broctl
```
要想使用命令行工具，只需将参数传递给上一个命令，例如：
```
# /usr/local/bro/bin/broctl status
```
这将通过显示以下的输出来检查 Bro 的状态：
```
Name Type Host Status Pid Started
bro standalone localhost running 6807 20 Jul 12:30:50
```
### 结论
这是一篇 Bro 的安装教程。我们使用基于源代码的安装，因为它是获得可用的最新版本的最有效的方法，但是该网络分析框架也可以下载预构建的二进制格式文件。
下次见！
---
via: <https://www.unixmen.com/how-to-install-bro-ubuntu-1604/>
作者：[Giuseppe Molica](https://www.unixmen.com/author/tutan/) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Kdump 检查 Linux 内核崩溃
|
Pratyush Anand
|
https://opensource.com/article/17/6/kdump-usage-and-internals
|
让我们先看一下 kdump 的基本使用方法，和 kdump/kexec 在内核中是如何实现。
|
/data/attachment/album/201707/30/150208olgsbdcbyyzxhc50.png.thumb.jpg
|
/data/attachment/album/201707/30/150208olgsbdcbyyzxhc50.png
| true | false | true |
firmianay
| false |
[
"内核",
"kdump",
"转储"
] |
技术
|
{
"viewnum": 25775,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "218.17.160.165",
"message": "命令都是错的，"kexec -p /boot/vmlinux --initrd=/boot/initramfs-4.19.190-12.el8.x86_64kdump.img --reuse-cmdline -d" 是--reuse-cmdline，用心点啊编辑。",
"username": "来自广东深圳的 Chrome 102.0|Windows 10 用户",
"date": "2022-06-30T15:02:11"
}
] |
[] |
让我们先看一下 kdump 的基本使用方法，和 kdump/kexec 在内核中是如何实现。
| 2017-07-30T15:02:00 | 2017-07-30T15:02:00 | 8,737 |
/article-8737-1.html
|
>
> 让我们先看一下 kdump 的基本使用方法，和 kdump/kexec 在内核中是如何实现。
>
>
>
[kdump](https://www.kernel.org/doc/Documentation/kdump/kdump.txt) 是获取崩溃的 Linux 内核转储的一种方法，但是想找到解释其使用和内部结构的文档可能有点困难。在本文中，我将研究 kdump 的基本使用方法，和 kdump/kexec 在内核中是如何实现。
[kexec](https://linux.die.net/man/8/kexec) 是一个 Linux 内核到内核的引导加载程序，可以帮助从第一个内核的上下文引导到第二个内核。kexec 会关闭第一个内核，绕过 BIOS 或固件阶段，并跳转到第二个内核。因此，在没有 BIOS 阶段的情况下，重新启动变得更快。
kdump 可以与 kexec 应用程序一起使用 —— 例如，当第一个内核崩溃时第二个内核启动，第二个内核用于复制第一个内核的内存转储，可以使用 `gdb` 和 `crash` 等工具分析崩溃的原因。（在本文中，我将使用术语“第一内核”作为当前运行的内核，“第二内核” 作为使用 kexec 运行的内核，“捕获内核” 表示在当前内核崩溃时运行的内核。）
kexec 机制在内核以及用户空间中都有组件。内核提供了几个用于 kexec 重启功能的系统调用。名为 kexec-tools 的用户空间工具使用这些调用，并提供可执行文件来加载和引导“第二内核”。有的发行版还会在 kexec-tools 上添加封装器，这有助于捕获并保存各种转储目标配置的转储。在本文中，我将使用名为 distro-kexec-tools 的工具来避免上游 kexec 工具和特定于发行版的 kexec-tools 代码之间的混淆。我的例子将使用 Fedora Linux 发行版。
### Fedora kexec-tools 工具
使用 `dnf install kexec-tools` 命令在 Fedora 机器上安装 fedora-kexec-tools。在安装 fedora-kexec-tools 后可以执行 `systemctl start kdump` 命令来启动 kdump 服务。当此服务启动时，它将创建一个根文件系统（initramfs），其中包含了要挂载到目标位置的资源，以保存 vmcore，以及用来复制和转储 vmcore 到目标位置的命令。然后，该服务将内核和 initramfs 加载到崩溃内核区域内的合适位置，以便在内核崩溃时可以执行它们。
Fedora 封装器提供了两个用户配置文件：
1. `/etc/kdump.conf` 指定修改后需要重建 initramfs 的配置参数。例如，如果将转储目标从本地磁盘更改为 NFS 挂载的磁盘，则需要由“捕获内核”所加载的 NFS 相关的内核模块。
2. `/etc/sysconfig/kdump` 指定修改后不需要重新构建 initramfs 的配置参数。例如，如果只需修改传递给“捕获内核”的命令行参数，则不需要重新构建 initramfs。
如果内核在 kdump 服务启动之后出现故障，那么“捕获内核”就会执行，其将进一步执行 initramfs 中的 vmcore 保存过程，然后重新启动到稳定的内核。
### kexec-tools 工具
编译 kexec-tools 的源代码得到了一个名为 `kexec` 的可执行文件。这个同名的可执行文件可用于加载和执行“第二内核”，或加载“捕获内核”，它可以在内核崩溃时执行。
加载“第二内核”的命令：
```
# kexec -l kernel.img --initrd=initramfs-image.img –reuse-cmdline
```
`--reuse-command` 参数表示使用与“第一内核”相同的命令行。使用 `--initrd` 传递 initramfs。 `-l` 表明你正在加载“第二内核”，其可以由 `kexec` 应用程序本身执行（`kexec -e`）。使用 `-l` 加载的内核不能在内核崩溃时执行。为了加载可以在内核崩溃时执行的“捕获内核”，必须传递参数 `-p` 取代 `-l`。
加载捕获内核的命令：
```
# kexec -p kernel.img --initrd=initramfs-image.img –reuse-cmdline
```
`echo c > /pros/sysrq-trigger` 可用于使内核崩溃以进行测试。有关 kexec-tools 提供的选项的详细信息，请参阅 `man kexec`。在转到下一个部分之前，请看这个 kexec\_dump 的演示：
### kdump: 端到端流
下图展示了流程图。必须在引导“第一内核”期间为捕获内核保留 crashkernel 的内存。您可以在内核命令行中传递 `crashkernel=Y@X`，其中 `@X` 是可选的。`crashkernel=256M` 适用于大多数 x86\_64 系统；然而，为崩溃内核选择适当的内存取决于许多因素，如内核大小和 initramfs，以及 initramfs 中包含的模块和应用程序运行时的内存需求。有关传递崩溃内核参数的更多方法，请参阅 [kernel-parameters 文档](https://github.com/torvalds/linux/blob/master/Documentation/admin-guide/kernel-parameters.txt)。
您可以将内核和 initramfs 镜像传递给 `kexec` 可执行文件，如（`kexec-tools`）部分的命令所示。“捕获内核”可以与“第一内核”相同，也可以不同。通常，一样即可。Initramfs 是可选的；例如，当内核使用 `CONFIG_INITRAMFS_SOURCE` 编译时，您不需要它。通常，从第一个 initramfs 中保存一个不一样的捕获 initramfs，因为在捕获 initramfs 中自动执行 vmcore 的副本能获得更好的效果。当执行 `kexec` 时，它还加载了 `elfcorehdr` 数据和 purgatory 可执行文件（LCTT 译注：purgatory 就是一个引导加载程序，是为 kdump 定作的。它被赋予了“炼狱”这样一个古怪的名字应该只是一种调侃）。 `elfcorehdr` 具有关于系统内存组织的信息，而 purgatory 可以在“捕获内核”执行之前执行并验证第二阶段的二进制或数据是否具有正确的 SHA。purgatory 也是可选的。
当“第一内核”崩溃时，它执行必要的退出过程并切换到 purgatory（如果存在）。purgatory 验证加载二进制文件的 SHA256，如果是正确的，则将控制权传递给“捕获内核”。“捕获内核”根据从 `elfcorehdr` 接收到的系统内存信息创建 vmcore。因此，“捕获内核”启动后，您将看到 `/proc/vmcore` 中“第一内核”的转储。根据您使用的 initramfs，您现在可以分析转储，将其复制到任何磁盘，也可以是自动复制的，然后重新启动到稳定的内核。
### 内核系统调用
内核提供了两个系统调用：`kexec_load()` 和 `kexec_file_load()`，可以用于在执行 `kexec -l` 时加载“第二内核”。它还为 `reboot()` 系统调用提供了一个额外的标志，可用于使用 `kexec -e` 引导到“第二内核”。
`kexec_load()`：`kexec_load()` 系统调用加载一个可以在之后通过 `reboot()` 执行的新的内核。其原型定义如下：
```
long kexec_load(unsigned long entry, unsigned long nr_segments,
struct kexec_segment *segments, unsigned long flags);
```
用户空间需要为不同的组件传递不同的段，如内核，initramfs 等。因此，`kexec` 可执行文件有助于准备这些段。`kexec_segment` 的结构如下所示：
```
struct kexec_segment {
void *buf;
/* 用户空间缓冲区 */
size_t bufsz;
/* 用户空间中的缓冲区长度 */
void *mem;
/* 内核的物理地址 */
size_t memsz;
/* 物理地址长度 */
};
```
当使用 `LINUX_REBOOT_CMD_KEXEC` 调用 `reboot()` 时，它会引导进入由 `kexec_load` 加载的内核。如果标志 `KEXEC_ON_CRASH` 被传递给 `kexec_load()`，则加载的内核将不会使用 `reboot(LINUX_REBOOT_CMD_KEXEC)` 来启动；相反，这将在内核崩溃中执行。必须定义 `CONFIG_KEXEC` 才能使用 `kexec`，并且为 `kdump` 定义 `CONFIG_CRASH_DUMP`。
`kexec_file_load()`：作为用户，你只需传递两个参数（即 `kernel` 和 `initramfs`）到 `kexec` 可执行文件。然后，`kexec` 从 sysfs 或其他内核信息源中读取数据，并创建所有段。所以使用 `kexec_file_load()` 可以简化用户空间，只传递内核和 initramfs 的文件描述符。其余部分由内核本身完成。使用此系统调用时应该启用 `CONFIG_KEXEC_FILE`。它的原型如下：
```
long kexec_file_load(int kernel_fd, int initrd_fd, unsigned long
cmdline_len, const char __user * cmdline_ptr, unsigned long
flags);
```
请注意，`kexec_file_load` 也可以接受命令行，而 `kexec_load()` 不行。内核根据不同的系统架构来接受和执行命令行。因此，在 `kexec_load()` 的情况下，`kexec-tools` 将通过其中一个段（如在 dtb 或 ELF 引导注释等）中传递命令行。
目前，`kexec_file_load()` 仅支持 x86 和 PowerPC。
#### 当内核崩溃时会发生什么
当第一个内核崩溃时，在控制权传递给 purgatory 或“捕获内核”之前，会执行以下操作：
* 准备 CPU 寄存器（参见内核代码中的 `crash_setup_regs()`）;
* 更新 vmcoreinfo 备注（请参阅 `crash_save_vmcoreinfo()`）;
* 关闭非崩溃的 CPU 并保存准备好的寄存器（请参阅 `machine_crash_shutdown()` 和 `crash_save_cpu()`）;
* 您可能需要在此处禁用中断控制器；
* 最后，它执行 kexec 重新启动（请参阅 `machine_kexec()`），它将加载或刷新 kexec 段到内存，并将控制权传递给进入段的执行文件。输入段可以是下一个内核的 purgatory 或开始地址。
#### ELF 程序头
kdump 中涉及的大多数转储核心都是 ELF 格式。因此，理解 ELF 程序头部很重要，特别是当您想要找到 vmcore 准备的问题。每个 ELF 文件都有一个程序头：
* 由系统加载器读取，
* 描述如何将程序加载到内存中，
* 可以使用 `Objdump -p elf_file` 来查看程序头。
vmcore 的 ELF 程序头的示例如下：
```
# objdump -p vmcore
vmcore:
file format elf64-littleaarch64
Program Header:
NOTE off 0x0000000000010000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**0 filesz
0x00000000000013e8 memsz 0x00000000000013e8 flags ---
LOAD off 0x0000000000020000 vaddr 0xffff000008080000 paddr 0x0000004000280000 align 2**0 filesz
0x0000000001460000 memsz 0x0000000001460000 flags rwx
LOAD off 0x0000000001480000 vaddr 0xffff800000200000 paddr 0x0000004000200000 align 2**0 filesz
0x000000007fc00000 memsz 0x000000007fc00000 flags rwx
LOAD off 0x0000000081080000 vaddr 0xffff8000ffe00000 paddr 0x00000040ffe00000 align 2**0 filesz
0x00000002fa7a0000 memsz 0x00000002fa7a0000 flags rwx
LOAD off 0x000000037b820000 vaddr 0xffff8003fa9e0000 paddr 0x00000043fa9e0000 align 2**0 filesz
0x0000000004fc0000 memsz 0x0000000004fc0000 flags rwx
LOAD off 0x00000003807e0000 vaddr 0xffff8003ff9b0000 paddr 0x00000043ff9b0000 align 2**0 filesz
0x0000000000010000 memsz 0x0000000000010000 flags rwx
LOAD off 0x00000003807f0000 vaddr 0xffff8003ff9f0000 paddr 0x00000043ff9f0000 align 2**0 filesz
0x0000000000610000 memsz 0x0000000000610000 flags rwx
```
在这个例子中，有一个 note 段，其余的是 load 段。note 段提供了有关 CPU 信息，load 段提供了关于复制的系统内存组件的信息。
vmcore 从 `elfcorehdr` 开始，它具有与 ELF 程序头相同的结构。参见下图中 `elfcorehdr` 的表示：
`kexec-tools` 读取 `/sys/devices/system/cpu/cpu%d/crash_notes` 并准备 `CPU PT_NOTE` 的标头。同样，它读取 `/sys/kernel/vmcoreinfo` 并准备 `vmcoreinfo PT_NOTE` 的标头，从 `/proc/iomem` 读取系统内存并准备存储器 `PT_LOAD` 标头。当“捕获内核”接收到 `elfcorehdr` 时，它从标头中提到的地址中读取数据，并准备 vmcore。
#### Crash note
Crash notes 是每个 CPU 中用于在系统崩溃的情况下存储 CPU 状态的区域；它有关于当前 PID 和 CPU 寄存器的信息。
#### vmcoreinfo
该 note 段具有各种内核调试信息，如结构体大小、符号值、页面大小等。这些值由捕获内核解析并嵌入到 `/proc/vmcore` 中。 `vmcoreinfo` 主要由 `makedumpfile` 应用程序使用。在 Linux 内核，`include/linux/kexec.h` 宏定义了一个新的 `vmcoreinfo`。 一些示例宏如下所示：
* `VMCOREINFO_PAGESIZE()`
* `VMCOREINFO_SYMBOL()`
* `VMCOREINFO_SIZE()`
* `VMCOREINFO_STRUCT_SIZE()`
#### makedumpfile
vmcore 中的许多信息（如可用页面）都没有用处。`makedumpfile` 是一个用于排除不必要的页面的应用程序，如：
* 填满零的页面；
* 没有私有标志的缓存页面（非专用缓存）;
* 具有私有标志的缓存页面（专用缓存）;
* 用户进程数据页；
* 可用页面。
此外，`makedumpfile` 在复制时压缩 `/proc/vmcore` 的数据。它也可以从转储中删除敏感的符号信息； 然而，为了做到这一点，它首先需要内核的调试信息。该调试信息来自 `VMLINUX` 或 `vmcoreinfo`，其输出可以是 ELF 格式或 kdump 压缩格式。
典型用法：
```
# makedumpfile -l --message-level 1 -d 31 /proc/vmcore makedumpfilecore
```
详细信息请参阅 `man makedumpfile`。
### kdump 调试
新手在使用 kdump 时可能会遇到的问题：
#### `kexec -p kernel_image` 没有成功
* 检查是否分配了崩溃内存。
* `cat /sys/kernel/kexec_crash_size` 不应该有零值。
* `cat /proc/iomem | grep "Crash kernel"` 应该有一个分配的范围。
* 如果未分配，则在命令行中传递正确的 `crashkernel=` 参数。
* 如果没有显示，则在 `kexec` 命令中传递参数 `-d`，并将输出信息发送到 kexec-tools 邮件列表。
#### 在“第一内核”的最后一个消息之后，在控制台上看不到任何东西（比如“bye”）
* 检查 `kexec -e` 之后的 `kexec -l kernel_image` 命令是否工作。
* 可能缺少支持的体系结构或特定机器的选项。
* 可能是 purgatory 的 SHA 验证失败。如果您的体系结构不支持 purgatory 中的控制台，则很难进行调试。
* 可能是“第二内核”早已崩溃。
* 将您的系统的 `earlycon` 或 `earlyprintk` 选项传递给“第二内核”的命令行。
* 使用 kexec-tools 邮件列表共享第一个内核和捕获内核的 `dmesg` 日志。
### 资源
#### fedora-kexec-tools
* GitHub 仓库：`git://pkgs.fedoraproject.org/kexec-tools`
* 邮件列表：[kexec@lists.fedoraproject.org](mailto:kexec@lists.fedoraproject.org)
* 说明：Specs 文件和脚本提供了用户友好的命令和服务，以便 `kexec-tools` 可以在不同的用户场景下实现自动化。
#### kexec-tools
* GitHub 仓库：git://git.kernel.org/pub/scm/utils/kernel/kexec/kexec-tools.git
* 邮件列表：[kexec@lists.infradead.org](mailto:kexec@lists.infradead.org)
* 说明：使用内核系统调用并提供用户命令 `kexec`。
#### Linux kernel
* GitHub 仓库： `git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git`
* 邮件列表：[kexec@lists.infradead.org](mailto:kexec@lists.infradead.org)
* 说明：实现了 `kexec_load()`、`kexec_file_load()`、`reboot()` 系统调用和特定体系结构的代码，例如 `machine_kexec()` 和 `machine_crash_shutdown()`。
#### Makedumpfile
* GitHub 仓库： `git://git.code.sf.net/p/makedumpfile/code`
* 邮件列表：[kexec@lists.infradead.org](mailto:kexec@lists.infradead.org)
* 说明：从转储文件中压缩和过滤不必要的组件。
（题图：[Penguin](https://pixabay.com/en/penguins-emperor-antarctic-life-429136/)、 [Boot](https://pixabay.com/en/shoe-boots-home-boots-house-1519804/)，修改：Opensource.com. [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）
---
作者简介：
Pratyush Anand - Pratyush 正在以以为 Linux 内核专家的身份与 Red Hat 合作。他主要负责 Red Hat 产品和上游所面临的几个 kexec/kdump 问题。他还处理 Red Hat 支持的 ARM64 平台周围的其他内核调试、跟踪和性能问题。除了 Linux 内核，他还在上游的 kexec-tools 和 makedumpfile 项目中做出了贡献。他是一名开源爱好者，并在教育机构举办志愿者讲座，促进了 FOSS。
---
via: <https://opensource.com/article/17/6/kdump-usage-and-internals>
作者：[Pratyush Anand](https://opensource.com/users/pratyushanand) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用统一阻止列表和白名单来更新主机文件
|
Dmt
|
https://www.darrentoback.com/this-script-updates-hosts-files-using-a-multi-source-unified-block-list-with-whitelisting
|
网上有许多持续维护的含有不同垃圾域的有用列表。将这些列表复制到你的主机文件中可以轻松阻止大量的域，你的系统将根本不用去连接它们。此方法可以在不安装浏览器插件的情况下工作，并且将为系统上任何浏览器（和任何其他程序）提供阻止操作。
|
/data/attachment/album/201707/30/155717leiystiieyuu8cie.jpg.thumb.jpg
|
/data/attachment/album/201707/30/155717leiystiieyuu8cie.jpg
| true | false | true |
geekpi
| false |
[
"黑名单",
"hosts"
] |
技术
|
{
"viewnum": 3862,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "114.246.212.165",
"message": "这个机翻也是醉了 ",
"username": "nu11 [Chrome 59.0|Mac 10.12]",
"date": "2017-08-03T00:18:53"
}
] |
[] |
网上有许多持续维护的含有不同垃圾域的有用列表。将这些列表复制到你的主机文件中可以轻松阻止大量的域，你的系统将根本不用去连接它们。此方法可以在不安装浏览器插件的情况下工作，并且将为系统上任何浏览器（和任何其他程序）提供阻止操作。
| 2017-08-01T10:52:00 | 2017-08-01T10:52:00 | 8,738 |
/article-8738-1.html
|
网上有许多持续维护的含有不同垃圾域的有用列表。将这些列表复制到你的主机文件中可以轻松阻止大量的域，你的系统将根本不用去连接它们。此方法可以在不安装浏览器插件的情况下工作，并且将为系统上任何浏览器（和任何其他程序）提供阻止操作。
在本教程中，我将向你展示如何在 Linux 中启动并运行 Steven Black 的[统一主机脚本](https://github.com/StevenBlack/hosts)。该脚本将使用来自多个来源的最新已知的广告服务器、网络钓鱼网站和其他网络垃圾的地址来更新你的计算机主机文件，同时提供一个漂亮、干净的方式来管理你自己的黑名单/白名单，其分别来自于该脚本管理的各个列表。
在将 30,000 个域放入主机文件之前，需要注意两点。首先，这些巨大的列表包含可能需要解除封锁的服务器，以便进行在线购买或其他一些临时情况。如果你弄乱了你的主机文件，你要知道网上的某些东西可能会出现问题。为了解决这个问题，我将向你展示如何使用方便的打开/关闭开关，以便你可以快速禁用你的阻止列表来购买喜马拉雅盐雾灯（它是等离子灯）。我仍然认为这些列表的目的之一是将所有的一切都封锁（有点烦人，直到我想到了做一个关闭开关）。如果你经常遇到你需要的服务器被阻止的问题，只需将其添加到白名单文件中即可。
第二个问题是性能受到了轻微的影响, 因为每次调用一个域时, 系统都必须检查整个列表。只是有一点点影响, 而没有大到让我因此而放弃黑名单，让每一个连接都通过。你具体要怎么选择自己看着办。
主机文件通过将请求定向到 127.0.0.1 或 0.0.0.0（换句话说定向到空地址）来阻止请求。有人说使用 0.0.0.0 是更快，问题更少的方法。你可以将脚本配置为使用 `-ip nnn.nnn.nnn.nnn` 这样的 ip 选项来作为阻止 ip，但默认值是 0.0.0.0，这是我使用的值。
我曾经将 Steven Black 的脚本做的事每隔一段时间就手动做一遍，进到每一个站点，将他们的列表拷贝/粘贴到我的主机文件中，做一个查找替换将其中的 127 变成 0 等等。我知道整件事情可以自动化，这样做有点傻，但我从来没有花时间解决这个问题。直到我找到这个脚本，现在这事已经是一个被遗忘的杂务。
让我们先下载一份最新的 Steven Black 的代码拷贝（大约 150MB），以便我们可以进行下一步。你需要安装 git，因此如果还没安装，进入到终端输入：
```
sudo apt-get install git
```
安装完之后，输入：
```
mkdir unifiedhosts
cd unifiedhosts
git clone https://github.com/StevenBlack/hosts.git
cd hosts
```
当你打开了 Steven 的脚本时，让我们来看看有什么选项。该脚本有几个选项和扩展，但扩展我不会在这里提交，但如果你到了这一步并且你有兴趣，[readme.md](https://github.com/StevenBlack/hosts/blob/master/readme.md) 可以告诉你所有你需要知道的。
你需要安装 python 来运行此脚本，并且与版本有关。要找到你安装的 Python 版本，请输入：
```
python --version
```
如果你还没安装 Python:
```
sudo apt-get install python
```
对于 Python 2.7，如下所示，输入 `python` 来执行脚本。对于 Python 3，在命令中的 `python` 替换成 `python3`。执行后，该脚本会确保它具有每个列表的最新版本，如果没有，它会抓取一个新的副本。然后，它会写入一个新的主机文件，包括了你的黑名单/白名单中的任何内容。让我们尝试使用 `-r` 选项来替换我们的当前的主机文件，而 `-a` 选项可以脚本不会问我们任何问题。回到终端：
```
python updateHostsFile.py -r -a
```
该命令将询问你的 root 密码，以便能够写入 `/etc/`。为了使新更新的列表处于激活状态，某些系统需要清除 DNS 缓存。在同一个硬件设备上，我观察到不同的操作系统表现出非常不同的行为，在没有刷新缓存的情况下不同的服务器变为可访问/不可访问所需的时间长度都不同。我已经看到了从即时更新（Slackware）到重启更新（Windows）的各种情况。有一些命令可以刷新 DNS 缓存，但是它们在每个操作系统甚至每个发行版上都不同，所以如果没有生效，只需要重新启动就行了。
现在，只要将你的个人例外添加到黑名单/白名单中，并且只要你想要更新主机文件，运行该脚本就好。该脚本将根据你的要求调整生成的主机文件，每次运行文件时会自动追加你额外的列表。
最后，我们来创建一个打开/关闭开关，对于打开和关闭功能每个都创建一个脚本，所以回到终端输入下面的内容创建关闭开关（用你自己的文本编辑器替换 leafpad）：
```
leafpad hosts-off.sh
```
在新文件中输入下面的内容：
```
#!/bin/sh
sudo mv /etc/hosts /etc/hostsDISABLED
```
接着让它可执行：
```
chmod +x hosts-off.sh
```
相似地，对于打开开关：
```
leafpad hosts-on.sh
```
在新文件中输入下面的内容：
```
#!/bin/sh
sudo mv /etc/hostsDISABLED /etc/hosts
```
最后让它可执行：
```
chmod +x hosts-on.sh
```
你所需要做的是为每个脚本创建一个快捷方式，标记为 HOSTS-ON 和 HOSTS-OFF，放在你能找到它们的地方。
---
via: <https://www.darrentoback.com/this-script-updates-hosts-files-using-a-multi-source-unified-block-list-with-whitelisting>
作者：[dmt](https://www.darrentoback.com/about-me) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
LKU：一套在 Ubuntu/LinuxMint 上编译、安装和更新最新内核的 Shell 脚本
|
2daygeek
|
http://www.2daygeek.com/lku-linux-kernel-utilities-compile-install-update-latest-kernel-in-linux-mint-ubuntu/
|
以手动方式安装和升级最新的 Linux 内核对于每个人来说都不是一件小事，甚至包括一些有经验的人也是如此。它需要对 Linux 内核有深入的了解。
|
/data/attachment/album/201707/30/162756kpkrpmm07p1llkl8.jpg.thumb.jpg
|
/data/attachment/album/201707/30/162756kpkrpmm07p1llkl8.jpg
| true | false | true |
firmianay
| false |
[
"内核",
"升级"
] |
技术
|
{
"viewnum": 9072,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.20.112.126",
"message": "搞成通用组件才好玩！！！",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-01T16:02:55"
}
] |
[] |
以手动方式安装和升级最新的 Linux 内核对于每个人来说都不是一件小事，甚至包括一些有经验的人也是如此。它需要对 Linux 内核有深入的了解。
| 2017-08-01T13:19:00 | 2017-08-01T13:19:00 | 8,739 |
/article-8739-1.html
|
以手动方式安装和升级最新的 Linux 内核对于每个人来说都不是一件小事，甚至包括一些有经验的人也是如此。它需要对 Linux 内核有深入的了解。过去我们已经介绍了 UKUU（Ubuntu Kernel Upgrade Utility），它可以从 kernel.ubuntu.com 网站上自动检测最新的主线内核，并弹出一个不错的窗口界面进行安装。
[Linux Kernel Utilities](https://github.com/mtompkins/linux-kernel-utilities) （LKU）提供一组 shell 脚本（三个 Shell 脚本），可以帮助用户从 kernel.org 获取并编译和安装最新的 Linux 内核，也可以从 kernel.ubuntu.com 获取安装最新的预编译的 Ubuntu 内核。甚至可以根据需要选择所需的内核（手动内核选择）。
该脚本还将根据 PGP 签名文件检查下载的归档文件，并且可以选择通用和低延迟版内核。
建议阅读：[ukuu：一种在基于 Ubuntu 的系统上轻松安装升级 Linux 内核的方式](http://www.2daygeek.com/ukuu-install-upgrade-linux-kernel-in-linux-mint-ubuntu-debian-elementary-os/)
它可以删除或清除所有非活动的内核，并且不会为了安全目的留下备份的内核。强烈建议在执行此脚本之前重新启动一次。
* `compile_linux_kernel.sh` ：用户可以从 kernel.org 编译和安装所需的或最新的内核
* `update_ubuntu_kernel.sh` ：用户可以从 kernel.ubuntu.com 安装并更新所需或最新的预编译 Ubuntu 内核
* `remove_old_kernels.sh` ：这将删除或清除所有非活动内核，并且只保留当前加载的版本
kernel.org 有固定的发布周期（每三个月一次），发布的内核包括了新的功能，改进了硬件和系统性能。由于它具有标准的发布周期，除了滚动发布的版本（如 Arch Linux，openSUSE Tumbleweed 等），大多数发行版都不提供最新的内核。
### 如何安装 Linux Kernel Utilities (LKU)
正如我们在文章的开头所说的，它的 shell 脚本集只是克隆开发人员的 github 仓库并运行相应的 shell 文件来执行这个过程。
```
$ git clone https://github.com/mtompkins/linux-kernel-utilities.git && cd linux-kernel-utilities
```
### 安装指定版本内核
为了测试的目的，我们将安装 Linux v4.4.10-xenial 内核。在安装新内核之前，我们需要通过 `uanme -a` 命令检查当前安装的内核版本，以便我们可以检查新内核是否可以安装。
```
$ uname -a
Linux magi-VirtualBox 4.4.0-21-generic #37-Ubuntu SMP Mon Apr 18 18:33:37 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
```
根据上面的输出，我们的系统使用的是 4.4.0-21 通用内核。
只需运行 `update_ubuntu_kernel.sh` shell 脚本。第一次运行脚本时会检查是否满足所有的依赖关系，然后自动安装缺少的依赖项。它会检测系统使用的发行版，并检索 kernel.ubuntu.com 中可用的预编译内核。现在，从列表中选择你需要的内核并输入序号，然后按回车键，它将下载内核映像（linux-headers-4.4.10，linux-headers-4.4.10-xxx-generic 和 linux-image-4.4.10-xxx-generic）。
一旦内核镜像被下载，它将要求输入 `sudo` 密码来启动新内核的安装。
```
$ ./update_ubuntu_kernel.sh
[+] Checking Distro
\_ Distro identified as LinuxMint.
[+] Checking Dependencies
curl Found
dkms Found
git Found
sudo Found
wget Found
whiptail Found
lynx Not Found
-- Installing Dependencies --
[!] The first time this script is run missing dependencies will be installed.
For compiling a kernel this may take a bit of time. Feedback will be provided.
[+] Dependencies
\_Elevating permissions as necessary . . .
[%] Elevated
[+] Testing for previous held packages and trying to correct any found.
\_Passed
[+] Updating package cache . . .
\_Complete
[+] Installing dependencies . . .
\_Complete
curl Found
dkms Found
git Found
sudo Found
wget Found
whiptail Found
lynx Found
[+] Changing to temporary directory to work in . . .
\_ Temporary directory access granted: /tmp/tmp.97eHDsmg2K
[+] Removing any conflicting remnants . . .
\_ Done
[+] Retrieving available kernel choices . . .
\_ Precompiled kernels available from kernel.ubuntu.com:
1) Linux v4.11 2) Linux v4.11.3 3) Linux v4.11.2 4) Linux v4.11.1
5) Linux v4.10 6) Linux v4.10.17 7) Linux v4.10.16 8) Linux v4.10.15
9) Linux v4.10.14 10) Linux v4.10.13 11) Linux v4.10.12
[ 节略 ……]
249) Linux v4.0.3-wily 250) Linux v4.0.2-wily 251) Linux v4.0.1-wily 252) Linux v4.0-vivid
Select your desired kernel: 158
Do you want the lowlatency kernel? (y/[n]):
[+] Processing selection
\_ Determining CPU type: amd64
\_ Locating source of v4.4.10-xenial generic kernel packages.
\_ Done
[+] Checking AntiVirus flag and disabling if necessary
[+] Installing kernel . . .
[sudo] password for magi:
Selecting previously unselected package linux-headers-4.4.10-040410.
(Reading database ... 230647 files and directories currently installed.)
Preparing to unpack linux-headers-4.4.10-040410_4.4.10-040410.201605110631_all.deb ...
Unpacking linux-headers-4.4.10-040410 (4.4.10-040410.201605110631) ...
Selecting previously unselected package linux-headers-4.4.10-040410-generic.
Preparing to unpack linux-headers-4.4.10-040410-generic_4.4.10-040410.201605110631_amd64.deb ...
Unpacking linux-headers-4.4.10-040410-generic (4.4.10-040410.201605110631) ...
Selecting previously unselected package linux-image-4.4.10-040410-generic.
Preparing to unpack linux-image-4.4.10-040410-generic_4.4.10-040410.201605110631_amd64.deb ...
Done.
Unpacking linux-image-4.4.10-040410-generic (4.4.10-040410.201605110631) ...
Setting up linux-headers-4.4.10-040410 (4.4.10-040410.201605110631) ...
Setting up linux-headers-4.4.10-040410-generic (4.4.10-040410.201605110631) ...
Examining /etc/kernel/header_postinst.d.
run-parts: executing /etc/kernel/header_postinst.d/dkms 4.4.10-040410-generic /boot/vmlinuz-4.4.10-040410-generic
Setting up linux-image-4.4.10-040410-generic (4.4.10-040410.201605110631) ...
Running depmod.
update-initramfs: deferring update (hook will be called later)
Examining /etc/kernel/postinst.d.
run-parts: executing /etc/kernel/postinst.d/apt-auto-removal 4.4.10-040410-generic /boot/vmlinuz-4.4.10-040410-generic
run-parts: executing /etc/kernel/postinst.d/dkms 4.4.10-040410-generic /boot/vmlinuz-4.4.10-040410-generic
run-parts: executing /etc/kernel/postinst.d/initramfs-tools 4.4.10-040410-generic /boot/vmlinuz-4.4.10-040410-generic
update-initramfs: Generating /boot/initrd.img-4.4.10-040410-generic
Warning: No support for locale: en_IN
run-parts: executing /etc/kernel/postinst.d/pm-utils 4.4.10-040410-generic /boot/vmlinuz-4.4.10-040410-generic
run-parts: executing /etc/kernel/postinst.d/unattended-upgrades 4.4.10-040410-generic /boot/vmlinuz-4.4.10-040410-generic
run-parts: executing /etc/kernel/postinst.d/zz-update-grub 4.4.10-040410-generic /boot/vmlinuz-4.4.10-040410-generic
Generating grub configuration file ...
Warning: Setting GRUB_TIMEOUT to a non-zero value when GRUB_HIDDEN_TIMEOUT is set is no longer supported.
Found linux image: /boot/vmlinuz-4.4.10-040410-generic
Found initrd image: /boot/initrd.img-4.4.10-040410-generic
Found linux image: /boot/vmlinuz-4.4.9-040409-lowlatency
Found initrd image: /boot/initrd.img-4.4.9-040409-lowlatency
Found linux image: /boot/vmlinuz-4.4.0-21-generic
Found initrd image: /boot/initrd.img-4.4.0-21-generic
Found memtest86+ image: /boot/memtest86+.elf
Found memtest86+ image: /boot/memtest86+.bin
done
\_ Done
```
安装后需要重新启动以使用新安装的内核。
```
$ sudo reboot now
```
现在，你正在使用的就是新安装的 4.4.10-040410-generic 版本内核。
```
$ uname -a
Linux magi-VirtualBox 4.4.10-040410-generic #201605110631 SMP Wed May 11 10:33:23 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
```
### 安装最新版本内核
过程与上述相同，它将自动安装最新版本的内核。
```
$ ./update_ubuntu_kernel.sh --latest
[+] Checking Distro
\_ Distro identified as LinuxMint.
[+] Checking Dependencies
curl Found
dkms Found
git Found
sudo Found
wget Found
whiptail Found
lynx Found
[+] Changing to temporary directory to work in . . .
\_ Temporary directory access granted: /tmp/tmp.pLPYmCze6S
[+] Removing any conflicting remnants . . .
\_ Done
[+] Retrieving available kernel choices . . .
\_ Precompiled kernels available from kernel.ubuntu.com:
.
.
.
.
Warning: Setting GRUB_TIMEOUT to a non-zero value when GRUB_HIDDEN_TIMEOUT is set is no longer supported.
Found linux image: /boot/vmlinuz-4.11.3-041103-generic
Found initrd image: /boot/initrd.img-4.11.3-041103-generic
Found linux image: /boot/vmlinuz-4.4.10-040410-generic
Found initrd image: /boot/initrd.img-4.4.10-040410-generic
Found linux image: /boot/vmlinuz-4.4.9-040409-lowlatency
Found initrd image: /boot/initrd.img-4.4.9-040409-lowlatency
Found linux image: /boot/vmlinuz-4.4.0-21-generic
Found initrd image: /boot/initrd.img-4.4.0-21-generic
Found memtest86+ image: /boot/memtest86+.elf
Found memtest86+ image: /boot/memtest86+.bin
done
\_ Done
```
安装后需要重新启动以使用新安装的内核。
```
$ sudo reboot now
```
现在，你正在使用的就是最新版本 4.11.3-041103-generic 的内核。
```
$ uname -a
Linux magi-VirtualBox 4.11.3-041103-generic #201705251233 SMP Thu May 25 16:34:52 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
```
### 删除或清除旧内核
只需要运行 `remove_old_kernels.sh` shell 脚本即可删除或清除所有非活动状态的内核。
```
$ ./remove_old_kernels.sh
++++++++++++++++++++++++++++++++
+++ W A R N I N G +++
++++++++++++++++++++++++++++++++
A reboot is recommended before running this script to ensure the current kernel tagged
as the boot kernel is indeed registered and old kernels properly marked for removal.
If you have just installed or modified your existing kernel and do not reboot before
running this script it may render you system INOPERABLE and that would indeed suck.
You have been warned.
~the Mgmt
[?]Continue to automagically remove ALL old kernels? (y/N)y
\_ Removing ALL old kernels . . .
[sudo] password for magi:
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following packages will be REMOVED:
linux-headers-4.4.0-21* linux-headers-4.4.0-21-generic* linux-headers-4.4.10-040410*
linux-headers-4.4.10-040410-generic* linux-headers-4.4.9-040409* linux-headers-4.4.9-040409-lowlatency*
linux-image-4.4.0-21-generic* linux-image-4.4.10-040410-generic* linux-image-4.4.9-040409-lowlatency*
linux-image-extra-4.4.0-21-generic* linux-kernel-generic*
0 upgraded, 0 newly installed, 11 to remove and 547 not upgraded.
After this operation, 864 MB disk space will be freed.
(Reading database ... 296860 files and directories currently installed.)
Removing linux-kernel-generic (4.4.0-21) ...
Removing linux-headers-4.4.0-21-generic (4.4.0-21.37) ...
Removing linux-headers-4.4.0-21 (4.4.0-21.37) ...
Removing linux-headers-4.4.10-040410-generic (4.4.10-040410.201605110631) ...
Removing linux-headers-4.4.10-040410 (4.4.10-040410.201605110631) ...
Removing linux-headers-4.4.9-040409-lowlatency (4.4.9-040409.201605041832) ...
Removing linux-headers-4.4.9-040409 (4.4.9-040409.201605041832) ...
Removing linux-image-extra-4.4.0-21-generic (4.4.0-21.37) ...
.
.
.
done
Purging configuration files for linux-image-4.4.9-040409-lowlatency (4.4.9-040409.201605041832) ...
Examining /etc/kernel/postrm.d .
run-parts: executing /etc/kernel/postrm.d/initramfs-tools 4.4.9-040409-lowlatency /boot/vmlinuz-4.4.9-040409-lowlatency
run-parts: executing /etc/kernel/postrm.d/zz-update-grub 4.4.9-040409-lowlatency /boot/vmlinuz-4.4.9-040409-lowlatency
```
---
via: <http://www.2daygeek.com/lku-linux-kernel-utilities-compile-install-update-latest-kernel-in-linux-mint-ubuntu/>
作者：[2DAYGEEK](http://www.2daygeek.com/author/2daygeek/) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用开源代码构建机器人时需要考虑的事项
|
Kyle Fazzari
|
https://insights.ubuntu.com/2017/07/18/things-to-consider-when-building-a-robot-with-open-source/
|
或许你正在考虑（或正在进行）将机器人使用开源软件推向市场。这个机器人是基于 linux 构建的。也许你正在使用机器人操作系统（ROS）或任务导向操作套件（MOOS），或者是另外一个可以帮助你简化开发过程的开源中间件。
|
/data/attachment/album/201707/31/000554yitsityp1zh59ehe.jpg.thumb.jpg
|
/data/attachment/album/201707/31/000554yitsityp1zh59ehe.jpg
| true | false | true |
SunWave
| false |
[
"机器人",
"ROS",
"IoT"
] |
观点
|
{
"viewnum": 4044,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
或许你正在考虑（或正在进行）将机器人使用开源软件推向市场。这个机器人是基于 linux 构建的。也许你正在使用机器人操作系统（ROS）或任务导向操作套件（MOOS），或者是另外一个可以帮助你简化开发过程的开源中间件。
| 2017-07-31T10:04:00 | 2017-07-31T10:04:00 | 8,740 |
/article-8740-1.html
|
或许你正在考虑（或正在进行）将机器人使用开源软件推向市场。这个机器人是基于 linux 构建的。也许你正在使用[机器人操作系统](http://www.ros.org/)（ROS）或[任务导向操作套件](http://www.robots.ox.ac.uk/%7Emobile/MOOS/wiki/pmwiki.php/Main/HomePage)（MOOS），或者是另外一个可以帮助你简化开发过程的开源中间件。当开发接近实用化，对回报的期望开始给你带来一些压力。你可能会被问到“我们的产品什么时候可以开始销售？”，这时你将面临重要的抉择。
你可以做下面两件事之一：
1. 对现有的产品开始出货
2. 回过头去，把产品化当做一个全新的问题来解决，并处理新的问题
不需要看很远，就可以找到采用方式（1）的例子。事实上，在物联网设备市场上，到处都是这样的设备。由于急于将设备推向市场，这些可以在设备中找到硬编码证书、开发密钥、各种安全漏洞和没有更新方式的产品并不少见。
想想 Mirai 僵尸网络，通过该僵尸网络发起的流量超过 1Tbps 的分布式拒绝服务攻击（DDos），导致一些互联网上最大的网站停止服务。这个僵尸网络主要由物联网设备组成。这种攻破设备的防御机制进而控制设备所开发的僵尸程序，是采用了超级酷的黑魔法在一个没有窗户的实验室（或地下基地）开发的吗？不是，默认（通常是硬编码）证书而已。这些设备的制造商是否快速反应并发布所有这些设备的更新，以确保设备的安全？不，很多制造商根本没有更新方法。[他们召回设备而不是发布更新](https://krebsonsecurity.com/2016/10/iot-device-maker-vows-product-recall-legal-action-against-western-accusers/)。
不要急于将产品推向市场，而是退后一步。只要多思考几点，就可以使你自己和你所在公司避免痛苦。
例如，**你的软件如何更新？**你*必须*能回答这个问题。你的软件不是完美的。只要几个星期你就会发现，当你在加利福尼亚使用自主的高机动性多用途轮式车辆（HMMWV）时，它把小灌木识别为一棵橡树。或者你不小心在软件中包含了你的 SSH 密钥。
**基础操作系统如何更新？**也许这仍然是你的产品的一部分，也是你回答上一个问题的答案。但也许你使用的操作系统来自于另外一个供应商。你如何从供应商那里得到更新并提供给客户？这就是安全漏洞真正让你头痛的地方：从来不更新的内核，或者严重过时的 openssl。
当你解决了更新问题，**在更新过程出现问题时，机器人怎么恢复？**我的示例是对前面问题的一个常见解决方案：自动安全更新。对于服务器和台式机以及显然是计算机的东西来说，这是一个很好的做法，因为大多数人意识到有一个可接受的方法来关闭它，而*不是*按住电源按钮 5 秒钟。机器人系统（以及大多数物联网系统）有一个问题，有时它们根本不被认为是计算机。如果您的机器人表现奇怪，有可能会被强制关闭。如果你的机器人行为奇怪是因为它正在快速安装一个内核更新，那么，现在你就有一个安装了半个内核的机器人镇纸了。你需要能够处理这种情况。
最后，**你的工厂流程是什么？**你如何安装 Linux，ROS（或者你使用的中间件），以及你要安装在设备上的你自己的东西？小的工厂可能会手工操作，但这种方法不成规模，也容易出错。其他厂商可能会制作一个定制化的初始发行版 ISO，但这是个不小的任务，在更新软件时也不容易维护。还有一些厂商会使用 Chef 或者有陡峭学习曲线的自动化工具，不久你就会意识到，你把大量的工程精力投入到了本来应该很简单的工作中。
所有这些问题都很重要。针对这些问题，如果你发现自己没有任何明确的答案，你应该加入我们的[网络研讨会](https://www.brighttalk.com/webcast/6793/268763?utm_source=insights)，在研讨会上我们讨论如何使用开放源代码构建一个商业化机器人。我们会帮助你思考这些问题，并可以回答你更多问题。
---
作者简介：
Kyle 是 Snapcraft 团队的一员，也是 Canonical 公司的常驻机器人专家，他专注于 snaps 和 snap 开发实践，以及 snaps 和 Ubuntu Core 的机器人技术实现。
---
via: <https://insights.ubuntu.com/2017/07/18/things-to-consider-when-building-a-robot-with-open-source/>
作者：[Kyle Fazzari](https://insights.ubuntu.com/author/kyrofa/) 译者：[SunWave](https://github.com/SunWave) 校对：[wxy](https://github.com/wxy)
本文由 LCTT 原创编译，Linux中国 荣誉推出
|
||
NoSQL： 如何在 Ubuntu 16.04 上安装 OrientDB
|
Giuseppe Molica
|
https://www.unixmen.com/nosql-install-orientdb-ubuntu-16-04/
|
OrientDB 是一个多模式的非关系型数据库管理系统。正如开发它的公司所说的“它是一个将图形关系与文档、键值对、反应性、面向对象和地理空间模型结合在一起的可扩展的、高性能的数据库”。
|
/data/attachment/album/201707/31/222237hrpp3jzjn3f3nvpk.png.thumb.jpg
|
/data/attachment/album/201707/31/222237hrpp3jzjn3f3nvpk.png
| true | false | true |
a972667237
| false |
[
"NoSQL",
"OrientDB"
] |
技术
|
{
"viewnum": 4772,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
OrientDB 是一个多模式的非关系型数据库管理系统。正如开发它的公司所说的“它是一个将图形关系与文档、键值对、反应性、面向对象和地理空间模型结合在一起的可扩展的、高性能的数据库”。
| 2017-08-01T10:19:00 | 2017-08-01T10:19:00 | 8,742 |
/article-8742-1.html
|
### 说明 - 非关系型数据库（NoSQL）和 OrientDB
通常在我们提及数据库的时候，想到的是两个主要的分类：使用用于用户和应用程序之间进行对接的一种被称为结构化查询语言（**S**tructured **Q**uery **L**anguage ，缩写 SQL）的关系型数据库管理系统（**R**elational **D**ata **b**ase **M**anagement **S**ystem，缩写 RDBMS） 以及非关系型数据库管理系统（non-relational database management systems 或称 NoSQL 数据库）。
这两种模型在如何处理（存储）数据的方面存在着巨大的差异。
#### 关系数据库管理系统
在关系模型中（如 MySQL，或者其分支 MariaDB），一个数据库是一个表的集合，其中每个表包含一个或多个以列组织的数据分类。数据库的每行包含一个唯一的数据实例，其分类由列定义。
举个例子，想象一个包含客户的表。每一行相当于一个客户，而其中的每一列分别对应名字、地址以及其他所必须的信息。
而另一个表可能是包含订单、产品、客户、日期以及其它的种种。而这个数据库的使用者则可以获得一个满足其需要的视图，例如一个客户在一个特定的价格范围购买产品的报告。
#### 非关系型数据库管理系统
在非关系型数据库（或称为<ruby> 不仅仅是数据库 <rt> Not only SQL </rt></ruby>）管理系统中，数据库被设计为使用不同的方式存储数据，比如文档存储、键值对存储、图形关系存储以及其他方式存储。使用此种形式实现的数据库系统专门被用于大型数据库集群和大型 Web 应用。现今，非关系型数据库被用于某些大公司，如谷歌和亚马逊。
##### 文档存储数据库
文档存储数据库是将数据用文档的形式存储。这种类型的运用通常表现为 JavaScript 和 JSON，实际上，XML 和其他形式的存储也是可以被采用的。这里的一个例子就是 MongoDB。
##### 键值对存储数据库
这是一个由唯一的<ruby> 键 <rt> key </rt></ruby>配对一个<ruby> 值 <rt> value </rt></ruby>的简单模型。这个系统在高速缓存方面具有高性能和高度可扩展性。这里的例子包括 BerkeleyDB 和 MemacacheDB。
##### 图形关系数据库
正如其名，这种数据库通过使用<ruby> 图 <rt> graph </rt></ruby>模型存储数据，这意味着数据通过节点和节点之间的互连进行组织。这是一个可以随着时间的推移和使用而发展的灵活模型。这个系统应用于那些强调映射关系的地方。这里的例子有 IBM Graphs、Neo4j 以及 **OrientDB**。
### OrientDB
[OrientDB](https://orientdb.com/) 是一个多模式的非关系型数据库管理系统。正如开发它的公司所说的“*它是一个将图形关系与文档、键值对、反应性、面向对象和地理空间模型结合在一起的**可扩展的、高性能的数据库***”。
OrientDB 还支持 SQL ，经过扩展可以用来操作树和图。
### 目标
这个教程旨在教会大家如何在运行 Ubuntu 16.04 的服务器上下载并配置 OrientDB 社区版。
### 下载 OrientDB
我们可以从最新的服务端上通过输入下面的指令来下载最新版本的 OrientDB。
```
$ wget -O orientdb-community-2.2.22.tar.gz http://orientdb.com/download.php?file=orientdb-community-2.2.22.tar.gz&os=linux
```
这里下载的是一个包含预编译二进制文件的压缩包，所以我们可以使用 `tar` 指令来操作解压它：
```
$ tar -zxf orientdb-community-2.2.22.tar.gz
```
将从中提取出来的文件夹整体移动到 `/opt`：
```
# mv orientdb-community-2.2.22 /opt/orientdb
```
### 启动 OrientDB 服务器
启动 OrientDB 服务器需要运行 `orientdb/bin/` 目录下的 shell 脚本：
```
# /opt/orientdb/bin/server.sh
```
如果你是第一次开启 OrientDB 服务器，安装程序还会显示一些提示信息，以及提醒你设置 OrientDB 的 root 用户密码：
```
+---------------------------------------------------------------+
| WARNING: FIRST RUN CONFIGURATION |
+---------------------------------------------------------------+
| This is the first time the server is running. Please type a |
| password of your choice for the 'root' user or leave it blank |
| to auto-generate it. |
| |
| To avoid this message set the environment variable or JVM |
| setting ORIENTDB_ROOT_PASSWORD to the root password to use. |
+---------------------------------------------------------------+
Root password [BLANK=auto generate it]: ********
Please confirm the root password: ********
```
在完成这些后，OrientDB 数据库服务器将成功启动：
```
INFO OrientDB Server is active v2.2.22 (build fb2b7d321ea8a5a5b18a82237049804aace9e3de). [OServer]
```
从现在开始，我们需要用第二个终端来与 OrientDB 服务器进行交互。
若要强制停止 OrientDB 执行 `Ctrl+C` 即可。
### 配置守护进程
此时，我们可以认为 OrientDB 仅仅是一串 shell 脚本，可以用编辑器打开 `/opt/orientdb/bin/orientdb.sh`：
```
# $EDITOR /opt/orientdb/bin/orientdb.sh
```
在它的首段，我们可以看到：
```
#!/bin/sh
# OrientDB service script
#
# Copyright (c) OrientDB LTD (http://orientdb.com/)
# chkconfig: 2345 20 80
# description: OrientDb init script
# processname: orientdb.sh
# You have to SET the OrientDB installation directory here
ORIENTDB_DIR="YOUR_ORIENTDB_INSTALLATION_PATH"
ORIENTDB_USER="USER_YOU_WANT_ORIENTDB_RUN_WITH"
```
我们需要配置`ORIENTDB_DIR` 以及 `ORIENTDB_USER`.
然后创建一个用户，例如我们创建一个名为 `orientdb` 的用户，我们需要输入下面的指令：
```
# useradd -r orientdb -s /sbin/nologin
```
`orientdb` 就是我们在 `ORIENTDB_USER` 处输入的用户。
再更改 `/opt/orientdb` 目录的所有权：
```
# chown -R orientdb:orientdb /opt/orientdb
```
改变服务器配置文件的权限：
```
# chmod 640 /opt/orientdb/config/orientdb-server-config.xml
```
#### 下载系统守护进程服务
OrientDB 的压缩包包含一个服务文件 `/opt/orientdb/bin/orientdb.service`。我们将其复制到 `/etc/systemd/system` 文件夹下：
```
# cp /opt/orientdb/bin/orientdb.service /etc/systemd/system
```
编辑该服务文件：
```
# $EDITOR /etc/systemd/system/orientdb.service
```
其中 `[service]` 内容块看起来应该是这样的：
```
[Service]
User=ORIENTDB_USER
Group=ORIENTDB_GROUP
ExecStart=$ORIENTDB_HOME/bin/server.sh
```
将其改成如下样式：
```
[Service]
User=orientdb
Group=orientdb
ExecStart=/opt/orientdb/bin/server.sh
```
保存并退出。
重新加载系统守护进程：
```
# systemctl daemon-reload
```
启动 OrientDB 并使其开机自启动：
```
# systemctl start orientdb
# systemctl enable orientdb
```
确认 OrientDB 的状态：
```
# systemctl status orientdb
```
上述指令应该会输出：
```
● orientdb.service - OrientDB Server
Loaded: loaded (/etc/systemd/system/orientdb.service; disabled; vendor preset: enabled)
Active: active (running) ...
```
流程就是这样了！OrientDB 社区版成功安装并且正确运行在我们的服务器上了。
### 总结
在这个指导中，我们看到了一些关系型数据库管理系统（RDBMS）以及非关系型数据库管理系统（NoSQL DBMS）的简单对照。我们也安装 OrientDB 社区版的服务器端并完成了其基础的配置。
这是我们部署完全的 OrientDB 基础设施的第一步，也是我们用于管理大型系统数据的起步。
---
via: <https://www.unixmen.com/nosql-install-orientdb-ubuntu-16-04/>
作者：[Giuseppe Molica](https://www.unixmen.com/author/tutan/) 译者：[a972667237](https://github.com/a972667237) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我选择 dwm 作为窗口管理器的 4 大理由
|
Jimmy Sjölund
|
https://opensource.com/article/17/7/top-4-reasons-i-use-dwm-linux-window-manager
|
我喜欢极简。如果可能，我会尽量在一个终端下运行所有需要的程序。这避免了一些浮夸的特效占用我的资源或者分散我的注意力。而且，无论怎么调整窗口大小和位置却依旧无法使它们完美地对齐，这也让我感到厌烦。
|
/data/attachment/album/201707/31/225336rtq4f2g2iylgw4s2.jpg.thumb.jpg
|
/data/attachment/album/201707/31/225336rtq4f2g2iylgw4s2.jpg
| true | false | true |
haoqixu
| false |
[
"窗口管理器",
"dwm"
] |
观点
|
{
"viewnum": 18509,
"commentnum": 8,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "125.118.140.204",
"message": "和i3wm的主要区别是？",
"username": "来自浙江杭州的 Chrome 56.0|GNU/Linux 用户",
"date": "2017-08-01T22:13:56"
},
{
"postip": "58.49.103.186",
"message": "i3wm更好点",
"username": "来自湖北武汉的 Firefox 54.0|Windows 7 用户",
"date": "2017-08-02T10:01:24"
},
{
"postip": "171.35.167.97",
"message": "尝试了一下， 确实很棒！<br />\r\n请教一个问题， 桌面平铺方式，窗口与窗口之间留有一条空边，没有紧挨着。<br />\r\n请问楼主这样的效果是怎么实现的呢？",
"username": "zplinux [Chrome 60.0|Windows 10]",
"date": "2017-08-04T20:28:06"
},
{
"postip": "218.19.206.89",
"message": "不知道汉化了没",
"username": "Wf_talk [Chrome 59.0|GNU/Linux]",
"date": "2017-08-05T23:42:24"
},
{
"postip": "42.245.196.156",
"message": "为什么使用已经停产的仅有1G内存的EeePC做生产力工具？我总觉得花时间在选择试用各种窗口管理工具上是种浪费，就像我们经常DIY废物利用上引以为豪一样，难道花钱买更强的工具以提高效率，不比这更“理智”些么？毕竟时间是最宝贵的资源。",
"username": "来自江苏的 Firefox 54.0|Windows 10 用户",
"date": "2017-08-19T18:34:53"
},
{
"postip": "115.238.39.106",
"message": "js很炫酷，但是依然有人反对使用js，因为它让海平面上身了（逃",
"username": "来自浙江杭州的 Chrome 84.0|Windows 10 用户",
"date": "2020-07-24T17:21:06"
},
{
"postip": "222.85.160.254",
"message": "请问一下标题的背景图，那个登陆程序谁有，我特别喜欢这个极简风格，不知道能不分享给我或者给我原作者联系方式。<br />\r\n ——Mr.Chen<zggzcgy@163.com>",
"username": "来自贵州贵阳的 Firefox 92.0|GNU/Linux 用户",
"date": "2021-09-29T11:28:30"
},
{
"postip": "61.186.27.117",
"message": "https://img.linux.net.cn/data/attachment/album/201707/31/225336rtq4f2g2iylgw4s2.jpg",
"username": "linux [Chrome 94.0|Mac 10.15]",
"date": "2021-10-02T10:11:33"
}
] |
[] |
我喜欢极简。如果可能，我会尽量在一个终端下运行所有需要的程序。这避免了一些浮夸的特效占用我的资源或者分散我的注意力。而且，无论怎么调整窗口大小和位置却依旧无法使它们完美地对齐，这也让我感到厌烦。
| 2017-08-01T13:46:00 | 2017-08-01T13:46:00 | 8,743 |
/article-8743-1.html
|
>
> <ruby> 窗口管理器 <rt> window manager </rt></ruby>负责管理打开窗口的大小、布置以及其它相关的方面。
>
>
>
我喜欢极简。如果可能，我会尽量在一个终端下运行所有需要的程序。这避免了一些浮夸的特效占用我的资源或者分散我的注意力。而且，无论怎么调整窗口大小和位置却依旧无法使它们完美地对齐，这也让我感到厌烦。
出于对极简化的追求，我喜欢上了 [Xfce](https://xfce.org/) 并且把它作为我主要的 Linux [桌面环境](https://en.wikipedia.org/wiki/Desktop_environment)好几年了。直到后来我看了 [Bryan Lunduke](http://lunduke.com/) 关于他所使用的名为 [Awesome](https://awesomewm.org/) 的[窗口管理器](https://en.wikipedia.org/wiki/Window_manager)的视频。Awesome 为用户整齐地布置好他们的窗口，看起来就是我想要的效果。但在我尝试之后却发现我难以把它配置成我喜欢的样子。于是我继续搜寻，发现了 [xmonad](http://xmonad.org/)，然而我遇到了同样的问题。[xmonad](http://xmonad.org/) 可以良好运作但为了把它配置成我理想中的样子我却不得不先通过 Haskell 语言这关。（LCTT 译注： AwesomeWM 使用 lua 语言作为配置语言，而 xmonad 使用 Haskell 语言）
几年后，我无意间发现了 [suckless.org](http://suckless.org/) 和他们的窗口管理器 [dwm](http://dwm.suckless.org/)。
简而言之，一个窗口管理器，例如 KDE，Gnome 或者 Xfce，包括了许多部件，其中除了窗口管理器还有其它应用程序。窗口管理器负责管理打开窗口的大小、布置（以及其它窗口相关的方面）。不同的桌面环境使用不同的窗口管理器，KDE 使用 KWin，Gnome 2 使用 Metacity， Gnome 3 使用 Mutter， 以及 Xfce 使用 Xfwm。当然，你可以方便地替换这些桌面环境的默认窗口管理器。我已经把我的窗口管理器替换成 dwm，下面我说说我喜欢 dwm 的理因。
### 动态窗口管理
与 Awesome 及 xmonad 一样，dwm 的杀手锏是它能利用屏幕的所有空间为你自动排布好窗口。当然，在现在的大多数桌面环境中，你也可以设置相应的快捷键把你的窗口放置在屏幕的上下左右或者是全屏，但是有了 dwm 我们就不需要考虑这么多了。
dwm 把屏幕分为主区域和栈区域。它包含三种布局：平铺，单片镜（monocle）和浮动。平铺模式是我最常使用的，它把一个主要的窗口放置在主区域来获取最大关注力，而将其余窗口平铺在栈区域中。在单片镜模式中，所有窗口都会被最大化，你可以在它们之间相互切换。浮动模式允许你自由调整窗口大小（就像在大多数窗口管理器下那样），这在你使用像 Gimp 这类需要自定义窗口大小的应用时更为方便。
一般情况下，在你的桌面环境下你可以使用不同的工作空间（workspace）来分类你的窗口，把相近的应用程序放置在计划好的工作空间中。在工作时，我会使用一个工作空间来进行工作，同时使用另一个工作空间来浏览网页。dwm 有一个相似的功能叫标签。你可以使用标签给窗口分组，当你选中一个标签时，就能显示具有相应标签的窗口。
### 高效
dwm 能让你的计算机尽量地节省电量。Xfce 和其它轻量桌面环境在较旧或者较低性能的机器上很受欢迎，但是相比于 Xfce，dwm 在登录后只使用了它们 1/3 的资源（在我的例子中）。当我在使用一台 1 GB 内存的 Eee PC （LCTT 译注：华硕生产的一款上网本，已停产）时，占用 660 MB 和 230MB 的差别就很大了。这让我有足够的内存空间运行我的编辑器和浏览器。
### 极简
通常，我让我的应用程序彼此相邻：作为主窗口的终端（通常运行着 Vim）、用来查阅邮件的浏览器，和另外一个用来查阅资料或者打开 [Trello](https://opensource.com/node/22546) 的浏览器窗口。对于临时的网页浏览，我会在另一个工作空间或者说是另一个 *标签* 中开启一个 Chromium 窗口。
*来自作者的屏幕截图。*
在标准的桌面环境下，通常会有一或两个面板占据着屏幕上下或者两侧的空间。我尝试过使用自动隐藏功能，但当光标太靠近边缘导致面板弹出造成的不便实在让我很厌烦。你也可以把它们设置得更小，但我还是更喜欢 dwm 的极简状态栏。
### 速度
评判速度时，我比较看重 dwm 在登录后的加载速度和启动程序的速度。如果使用更快、更新的计算机，你可能不会在意这些细节，但是对我来说，不同的桌面环境和窗口管理器会有明显的差距。我实在不想连这种简单的操作也要等待，它们应该一下子就完成。另外，使用键盘快捷键来启动程序比起用鼠标或者触控板要快一些，而且我不想让双手离开键盘。
### 小结
即便如此，我也不会向新手用户推荐 dwm。研究如何配置它需要耗费一些时间（除非你对你的发行版提供的默认配置感到满意）。我发现要让一些你想要的补丁正常工作可能会有点棘手，而且相应的社区也比较小（其 IRC 频道明确表示不提供补丁的手把手帮助）。所以，为了得到你想要的效果，你得有些付出才行。不过，这也是值得的。
而且你看，它就像 Awesome 一样 awesome。
（题图：cinderwick.ca）
---
作者简介：
Jimmy Sjölund - 他是 Telia Company 的高级 IT 服务经理，关注团队开发、探索敏捷工作流和精益工作流的创新导师，以及可视化方向爱好者。他同时也是一名开源布道者，先前从事于 Ubuntu Studio 和 Plume Creator。
---
via: <https://opensource.com/article/17/7/top-4-reasons-i-use-dwm-linux-window-manager>
作者：[Jimmy Sjölund](https://opensource.com/users/jimmysjolund) 译者：[haoqixu](https://github.com/haoqixu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么你应该成为一名系统管理员？
|
Paul English
|
https://opensource.com/article/17/7/why-become-sysadmin
|
网络和系统管理工作工资高、岗位多。
|
/data/attachment/album/201708/02/101836qg6w6iiokqx68zfk.jpg.thumb.jpg
|
/data/attachment/album/201708/02/101836qg6w6iiokqx68zfk.jpg
| true | false | true |
sugarfillet
| false |
[
"系统管理员"
] |
观点
|
{
"viewnum": 7548,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "119.145.15.121",
"message": "薪水翻译错了，原文写的是Annual，年度而不是季度",
"username": "来自广东深圳的 Chrome 59.0|Windows 7 用户",
"date": "2017-08-02T12:26:22"
},
{
"postip": "106.38.5.68",
"message": "原文写的是7万刀一年，到你这怎么是7万刀一个季度了？<br />\r\nUS$ 70,000 annual income",
"username": "13ruc3 [Firefox 54.0|Windows 7]",
"date": "2017-08-02T12:27:18"
},
{
"postip": "114.242.250.172",
"message": "啊啊，谢谢，确实疏忽了。",
"username": "linux [Chrome 59.0|Mac 10.11]",
"date": "2017-08-02T14:35:53"
}
] |
[] |
网络和系统管理工作工资高、岗位多。
| 2017-08-02T10:18:00 | 2017-08-02T10:18:00 | 8,745 |
/article-8745-1.html
|
>
> 网络和系统管理工作工资高、岗位多。
>
>
>
我们为秩序而战，而服务器大叔则需要你成为系统管理员。
这是个很好的机会，因为你已经管理过你有的那些系统，你本可以不需酬劳地管理那些日逐一日地运行的系统。但还是有一些面试官，愿意拿一笔很不错的薪水来找一些人去管理他们的系统。目前，系统和网络管理的失业率几乎为零，但是美国劳工统计局估计到 2024 年该领域将持续 [9% 的增长](https://www.bls.gov/ooh/Computer-and-Information-Technology/Network-and-computer-systems-administrators.htm#tab-1)。
你可能会问，自动化运维怎么样？大概你已经听一些系统管理员说过，他们打算如何来自动化他们所有的工作，或者，他们如何在一个 shell 脚本里自动化完成他们前任者的工作。你听过的有多少成功的？自动化了某个任务，就会有更多的东西需要自动化。
如果你参加过系统管理者会议或观看过他们的视频，你会发现这是一个需要新鲜血液的领域。不仅仅是明显的缺少年轻人，而且相当地性别和种族不平等。虽然有点儿跑题，但是多样性已经被证明可以提高系统管理员非常感兴趣的自我恢复力、解决问题的能力，创新力和决策力。
### 我要成为一名系统管理员吗？
有人要你，但是你要做系统管理工作吗？如果你生活在一个第一世界国家，每年 70,000 美元的收入看上去是一个可以感到幸福的标准收入，或者说至少减少了大部分的与钱相关的压力。系统和网络管理员的中位年度收入是 80,000 美元，很容易达标，尽管明显有些人赚的更少或更多。
你曾经免费做过一些系统管理工作吗？我们大多数人都多多少少地管理一些设备，但是那并不代表你喜欢管理它。如果你曾经在你家的网络中添加了一些服务器，你就是一个备选的系统管理员。你想要为自己的孩子添加一个“我的世界”的游戏服务器么，所以你用树莓派搭建了一个？也许是时候来考虑通过做这样的工作来获取报酬了。
作为一份需要全面知识的工作，系统管理工作有很大的跨度。各种行业和各种规模的公司都需要系统管理员。大多数的位于市区里的公司需要一些现场上班的人员，但是远程办公也有很大的可能性。
每个人都是免费地用开源软件工作，但是，作为系统管理员，你也可以计酬工作。系统管理员经常把对开源项目做贡献、支持开源供应商、使用各种各样的有趣而强大的开源软件为他们日常工作的一部分。
最后，谈一下社区。以我多年的经验来看，找到一个欢迎新人的、鼓励参与的、气氛友好的、彼此帮助的社区是非常难的。系统管理员给人的刻板印象就是性情乖戾，但是我感觉现在这只不过是个过时的笑话。现在大多数的系统管理员积极地回应各种形式的有建设性的反馈，尤其是欢迎新手。我们总是能敏锐的察觉到各种各样的入门级问题，并且热心于解决它们。我们是一个有深度的、兴趣广泛的社区。问一下一个系统管理员在工作之余都干了些什么，你肯定会感到吃惊。
### 那么，我要从哪儿开始？
如果你被说服了，首先有个好消息。与许多技术类职业相比，从不是直接相关的四年制学历转为系统管理员是可能的。事实上，全世界有四年本科学历的系统管理员相对较少，所以不用太担心这个。对于现在的白领工作，学历确实有用，而且越相关越好。与其他的技术类职业相比，这儿有一个很自然的入门级别的职位：技术支持。
对系统管理工作的候选人来说有个坏消息是真的，在技术类领域（甚至非技术类领域）：雇主在寻找有多年经验的和有高学历的人，即便是在入门级别的岗位上。雇主是刻薄的，雇主不会花钱给你培训。不过稍嫌安慰的是，这些问题在人才市场上是非常普遍的，所以不管你找什么工作都得面对这种问题。
系统管理工作可以作为其他 IT 领域的起点。比如：网络管理、数据库管理、网站可靠性工程师（SRE），再远一些的也有，软件工程师、质量保证（QA）、IT 管理。
系统管理工作的具体情况，包括其刻板的印象和一些明显的方面以及不明显的方面，是未来我们的文章的主题。我们也会涵盖这个领域可能会改变的重要方面，提供一些方法来评估和比较系统管理职位，以及在面试中问到的一些重要问题。
如果你对加入这个领域有兴趣，可以考虑加入[专业系统管理者联盟](https://lopsa.org/)（LOPSA），我在这个组织任董事会成员。会员资格是你负担得起的（可能由您的雇主负责），而学生免费。成为 LOPSA 会员，是找到同行们和与有各种经验、各种行业和工作环境中的人员讨论职业生涯的绝佳方式。
（题图 : Jason Baker, CC BY-SA 4.0）
---
作者简介：
Paul English - 他是 PreOS 安全公司的首席执行官，也是专业系统管理员联盟的董事会成员，该专业系统管理员联盟是一个非营利性专业协会，从 2015 年至今致力于提升系统管理工作实践。 Paul 在 1998 年获得了伍斯特理工学院的计算机学士学位。自 1996 年以来，Paul 一直是 UNIX 和 Linux 系统管理员和许多场合冠以 IT 之名的那个人。最近他在管理一些系统管理员。
---
via: <https://opensource.com/article/17/7/why-become-sysadmin>
作者：[Paul English](https://opensource.com/users/penglish) 译者：[sugarfillet](https://github.com/sugarfillet) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Ubuntu 16.04 中使用 Docker Compose
|
Giuseppe Molica
|
https://www.unixmen.com/container-docker-compose-ubuntu-16-04/
|
Docker Compose 是一个运行多容器 Docker 应用的工具。Compose 通过一个配置文件来配置一个应用的服务，然后通过一个命令创建并启动所有在配置文件中指定的服务。
|
/data/attachment/album/201708/02/140524jlue8l55rlerttnn.png.thumb.jpg
|
/data/attachment/album/201708/02/140524jlue8l55rlerttnn.png
| true | false | true |
locez
| false |
[
"容器",
"Docker"
] |
容器与云
|
{
"viewnum": 6253,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "58.62.93.229",
"message": "好久没来了，文章不错",
"username": "arhool [Chrome 50.0|Windows 10]",
"date": "2017-08-04T01:39:06"
}
] |
[] |
Docker Compose 是一个运行多容器 Docker 应用的工具。Compose 通过一个配置文件来配置一个应用的服务，然后通过一个命令创建并启动所有在配置文件中指定的服务。
| 2017-08-02T14:05:00 | 2017-08-02T14:05:00 | 8,746 |
/article-8746-1.html
|
### 什么是 Docker Compose
[Docker Compose](https://docs.docker.com/compose/overview/) 是一个运行多容器 Docker 应用的工具。Compose 通过一个配置文件来配置一个应用的服务，然后通过一个命令创建并启动所有在配置文件中指定的服务。
Docker Compose 适用于许多不同的项目，如：
* **开发**：利用 Compose 命令行工具，我们可以创建一个隔离（而可交互）的环境来承载正在开发中的应用程序。通过使用 [Compose 文件](https://docs.docker.com/compose/compose-file/)，开发者可以记录和配置所有应用程序的服务依赖关系。
* **自动测试**：此用例需求一个测试运行环境。Compose 提供了一种方便的方式来管理测试套件的隔离测试环境。完整的环境在 Compose 文件中定义。
Docker Compose 是在 [Fig](http://www.fig.sh/) 的源码上构建的，这个社区项目现在已经没有使用了。
在本教程中，我们将看到如何在 Ubuntn 16.04 上安装 Docker Compose。
### 安装 Docker
我们需要安装 Docker 来安装 Docker Compose。首先为官方 Docker 仓库添加公钥。
```
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
```
接下来，添加 Docker 仓库到 `apt` 源列表：
```
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
```
更新包数据库，并使用 `apt` 安装 Docker
```
$ sudo apt-get update
$ sudo apt install docker-ce
```
在安装进程结束后，Docker 守护程序应该已经启动并设为开机自动启动。我们可以通过下面的命令来查看它的状态：
```
$ sudo systemctl status docker
---------------------------------
● docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running)
```
### 安装 Docker Compose
现在可以安装 Docker Compose 了。通过执行以下命令下载当前版本。
```
# curl -L https://github.com/docker/compose/releases/download/1.14.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
```
为二进制文件添加执行权限：
```
# chmod +x /usr/local/bin/docker-compose
```
检查 Docker Compose 版本：
```
$ docker-compose -v
```
输出应该如下：
```
docker-compose version 1.14.0, build c7bdf9e
```
### 测试 Docker Compose
Docker Hub 包含了一个用于演示的 Hello World 镜像，可以用来说明使用 Docker Compose 来运行一个容器所需的配置。
创建并打开一个目录：
```
$ mkdir hello-world
$ cd hello-world
```
创建一个新的 YAML 文件：
```
$ $EDITOR docker-compose.yml
```
在文件中粘贴如下内容：
```
unixmen-compose-test:
image: hello-world
```
***注意:** 第一行是容器名称的一部分。*
保存并退出。
### 运行容器
接下来，在 `hello-world` 目录执行以下命令：
```
$ sudo docker-compose up
```
如果一切正常，Compose 输出应该如下：
```
Pulling unixmen-compose-test (hello-world:latest)...
latest: Pulling from library/hello-world
b04784fba78d: Pull complete
Digest: sha256:f3b3b28a45160805bb16542c9531888519430e9e6d6ffc09d72261b0d26ff74f
Status: Downloaded newer image for hello-world:latest
Creating helloworld_unixmen-compose-test_1 ...
Creating helloworld_unixmen-compose-test_1 ... done
Attaching to helloworld_unixmen-compose-test_1
unixmen-compose-test_1 |
unixmen-compose-test_1 | Hello from Docker!
unixmen-compose-test_1 | This message shows that your installation appears to be working correctly.
unixmen-compose-test_1 |
unixmen-compose-test_1 | To generate this message, Docker took the following steps:
unixmen-compose-test_1 | 1\. The Docker client contacted the Docker daemon.
unixmen-compose-test_1 | 2\. The Docker daemon pulled the "hello-world" image from the Docker Hub.
unixmen-compose-test_1 | 3\. The Docker daemon created a new container from that image which runs the
unixmen-compose-test_1 | executable that produces the output you are currently reading.
unixmen-compose-test_1 | 4\. The Docker daemon streamed that output to the Docker client, which sent it
unixmen-compose-test_1 | to your terminal.
unixmen-compose-test_1 |
unixmen-compose-test_1 | To try something more ambitious, you can run an Ubuntu container with:
unixmen-compose-test_1 | $ docker run -it ubuntu bash
unixmen-compose-test_1 |
unixmen-compose-test_1 | Share images, automate workflows, and more with a free Docker ID:
unixmen-compose-test_1 | https://cloud.docker.com/
unixmen-compose-test_1 |
unixmen-compose-test_1 | For more examples and ideas, visit:
unixmen-compose-test_1 | https://docs.docker.com/engine/userguide/
unixmen-compose-test_1 |
helloworld_unixmen-compose-test_1 exited with code 0
```
Docker 容器只能在命令（LCTT 译注：此处应为容器中的命令）还处于活动状态时运行，因此当测试完成运行时，容器将停止运行。
### 结论
本文是关于在 Ubuntu 16.04 中安装 Docker Compose 的教程。我们还看到了如何通过一个 YAML 格式的 Compose 文件构建一个简单的项目。
---
via: <https://www.unixmen.com/container-docker-compose-ubuntu-16-04/>
作者：[Giuseppe Molica](https://www.unixmen.com/author/tutan/) 译者：[Locez](https://github.com/locez) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何保护 Ubuntu 16.04 上的 NGINX Web 服务器
|
Giuseppe Molica
|
https://www.unixmen.com/encryption-secure-nginx-web-server-ubuntu-16-04/
|
Let’s Encrypt 是互联网安全研究组织 （ISRG） 提供的免费证书认证机构。它提供了一种轻松自动的方式来获取免费的 SSL/TLS 证书 - 这是在 Web 服务器上启用加密和 HTTPS 流量的必要步骤。获取和安装证书的大多数步骤可以通过使用名为 Certbot 的工具进行自动化。
|
/data/attachment/album/201708/02/143330iaahap07p77wubho.png.thumb.jpg
|
/data/attachment/album/201708/02/143330iaahap07p77wubho.png
| true | false | true |
geekpi
| false |
[
"Nginx",
"SSL"
] |
系统运维
|
{
"viewnum": 7408,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Let’s Encrypt 是互联网安全研究组织 （ISRG） 提供的免费证书认证机构。它提供了一种轻松自动的方式来获取免费的 SSL/TLS 证书 - 这是在 Web 服务器上启用加密和 HTTPS 流量的必要步骤。获取和安装证书的大多数步骤可以通过使用名为 Certbot 的工具进行自动化。
| 2017-08-02T14:33:00 | 2017-08-02T14:33:00 | 8,747 |
/article-8747-1.html
|
### 什么是 Let’s Encrypt
[Let’s Encrypt](https://letsencrypt.org/) 是互联网安全研究组织 （ISRG） 提供的免费证书认证机构。它提供了一种轻松自动的方式来获取免费的 SSL/TLS 证书 - 这是在 Web 服务器上启用加密和 HTTPS 流量的必要步骤。获取和安装证书的大多数步骤可以通过使用名为 [Certbot](https://certbot.eff.org/) 的工具进行自动化。
特别地，该软件可在可以使用 shell 的服务器上使用：换句话说，它可以通过 SSH 连接使用。
在本教程中，我们将看到如何使用 `certbot` 获取免费的 SSL 证书，并在 Ubuntu 16.04 服务器上使用 Nginx。
### 安装 Certbot
第一步是安装 `certbot`，该软件客户端可以几乎自动化所有的过程。 Certbot 开发人员维护自己的 Ubuntu 仓库，其中包含比 Ubuntu 仓库中存在的软件更新的软件。
添加 Certbot 仓库：
```
# add-apt-repository ppa:certbot/certbot
```
接下来，更新 APT 源列表：
```
# apt-get update
```
此时，可以使用以下 `apt` 命令安装 `certbot`：
```
# apt-get install certbot
```
Certbot 现已安装并可使用。
### 获得证书
有各种 Certbot 插件可用于获取 SSL 证书。这些插件有助于获取证书，而证书的安装和 Web 服务器配置都留给管理员。
我们使用一个名为 **Webroot** 的插件来获取 SSL 证书。
在有能力修改正在提供的内容的情况下，建议使用此插件。在证书颁发过程中不需要停止 Web 服务器。
#### 配置 NGINX
Webroot 会在 Web 根目录下的 `.well-known` 目录中为每个域创建一个临时文件。在我们的例子中，Web 根目录是 `/var/www/html`。确保该目录在 Let’s Encrypt 验证时可访问。为此，请编辑 NGINX 配置。使用文本编辑器打开 `/etc/nginx/sites-available/default`：
```
# $EDITOR /etc/nginx/sites-available/default
```
在该文件中，在 `server` 块内，输入以下内容：
```
location ~ /.well-known {
allow all;
}
```
保存，退出并检查 NGINX 配置：
```
# nginx -t
```
没有错误的话应该会显示如下：
```
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
重启 NGINX：
```
# systemctl restart nginx
```
#### 使用 Certbot 获取证书
下一步是使用 Certbot 的 Webroot 插件获取新证书。在本教程中，我们将保护示例域 www.example.com。需要指定应由证书保护的每个域。执行以下命令：
```
# certbot certonly --webroot --webroot-path=/var/www/html -d www.example.com
```
在此过程中，Cerbot 将询问有效的电子邮件地址，用于进行通知。还会要求与 EFF 分享，但这不是必需的。在同意服务条款之后，它将获得一个新的证书。
最后，目录 `/etc/letsencrypt/archive` 将包含以下文件：
* `chain.pem`：Let’s Encrypt 加密链证书。
* `cert.pem`：域名证书。
* `fullchain.pem`：`cert.pem`和 `chain.pem` 的组合。
* `privkey.pem`：证书的私钥。
Certbot 还将创建符号链接到 `/etc/letsencrypt/live/domain_name/` 中的最新证书文件。这是我们将在服务器配置中使用的路径。
### 在 NGINX 上配置 SSL/TLS
下一步是服务器配置。在 `/etc/nginx/snippets/` 中创建一个新的代码段。 **snippet** 是指一段配置，可以包含在虚拟主机配置文件中。如下创建一个新的文件：
```
# $EDITOR /etc/nginx/snippets/secure-example.conf
```
该文件的内容将指定证书和密钥位置。粘贴以下内容：
```
ssl_certificate /etc/letsencrypt/live/domain_name/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/domain_name/privkey.pem;
```
在我们的例子中，`domain_name` 是 `example.com`。
#### 编辑 NGINX 配置
编辑默认虚拟主机文件：
```
# $EDITOR /etc/nginx/sites-available/default
```
如下：
```
server {
listen 80 default_server;
listen [::]:80 default_server;
server_name www.example.com
return 301 https://$server_name$request_uri;
# SSL configuration
#
listen 443 ssl default_server;
listen [::]:443 ssl default_server;
include snippets/secure-example.conf
#
# Note: You should disable gzip for SSL traffic.
# See: https://bugs.debian.org/773332
# ...
}
```
这将启用 NGINX 加密功能。
保存、退出并检查 NGINX 配置文件：
```
# nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```
重启 NGINX：
```
# systemctl restart nginx
```
### 总结
按照上述步骤，此时我们已经拥有了一个安全的基于 NGINX 的 Web 服务器，它由 Certbot 和 Let’s Encrypt 提供加密。这只是一个基本配置，当然你可以使用许多 NGINX 配置参数来个性化所有东西，但这取决于特定的 Web 服务器要求。
---
via: <https://www.unixmen.com/encryption-secure-nginx-web-server-ubuntu-16-04/>
作者：[Giuseppe Molica](https://www.unixmen.com/author/tutan/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
运行 Ubuntu 的 Husarion CORE2-ROS 使得机器人开发变得容易
|
Dominik Nowak
|
https://insights.ubuntu.com/2017/07/12/robot-development-made-easy-with-husarion-core2-ros-running-ubuntu/
|
过去十年，我们见证了 IT 行业的许多突破。可以说对消费者最有意义的一个方面是智能手机和移动开发的普及。接下来的大事件是什么，现在智能手机是如此常见，我们天天对着它，是不是有点无聊吗？所以，我们猜是：机器人。
|
/data/attachment/album/201708/03/181721kajottt4qsus666t.png.thumb.jpg
|
/data/attachment/album/201708/03/181721kajottt4qsus666t.png
| true | false | true |
geekpi
| false |
[
"ROS",
"RTOS"
] |
观点
|
{
"viewnum": 4848,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "219.142.188.150",
"message": "这篇整个是在做广告啊:)",
"username": "来自北京的 Chrome 59.0|Windows 10 用户",
"date": "2017-08-04T12:04:08"
}
] |
[] |
过去十年，我们见证了 IT 行业的许多突破。可以说对消费者最有意义的一个方面是智能手机和移动开发的普及。接下来的大事件是什么，现在智能手机是如此常见，我们天天对着它，是不是有点无聊吗？所以，我们猜是：机器人。
| 2017-08-03T18:17:17 | 2017-08-03T18:17:17 | 8,749 |
/article-8749-1.html
|
>
> 这是游客投稿的本系列两篇中的第一篇；作者：Dominik Nowak，Husarion 的 CEO
>
>
>
过去十年，我们见证了 IT 行业的许多突破。可以说对消费者最有意义的一个方面是智能手机和移动开发的普及。接下来的大事件是什么，现在智能手机是如此常见，我们天天对着它，是不是有点无聊吗？所以，我们猜是：机器人。
众所周知，许多生产线完全由机器人运行。但在消费者和服务方面，还没有看到巨大的突破。我们认为这是一个可达性和降低开发人员进入的门槛的问题。只需要有好的、简单的工具来快速做出原型和开发机器人。为了测试新的想法并赋予工程师们更多能力，以便他们可以解决许多人类仍然面临的问题，那些比在应用中的点按一下更棘手的问题。
构建机器人是一个具有挑战性的任务，[Husarion](https://husarion.com/) 团队正在努力使其更容易。Husarion 是一家从事于机器人快速开发平台的机器人公司。该公司的产品是 CORE2 机器人控制器和用于管理所有基于 CORE2 的机器人的云平台。CORE2 是第二代 Husarion 机器人控制器，它可在[这里](https://www.crowdsupply.com/husarion/core2)找到。
CORE2 结合了实时微控制器板和运行 Ubuntu 的单板计算机。Ubuntu 是最受欢迎的 Linux 发行版，不仅适用于[桌面](https://www.ubuntu.com/desktop)，还适用于物联网和 [机器人](https://www.ubuntu.com/internet-of-things/robotics)程序中的嵌入式硬件。
CORE2 控制器有两种配置。第一款是采用 ESP32 Wi-Fi 模块的，专用于需要低功耗和实时、安全遥控的机器人应用。第二款，称为 CORE2-ROS，基本上是将两块板子集成到了一起：
* 使用实时操作系统（RTOS）的实时微控制器并集成电机、编码器和传感器接口的电路板
* 带有 ROS（[Robot Operating System](http://www.ros.org/)）包的运行 Linux 的单板计算机（SBC）和其他软件工具。
“实时”电路板做底层工作。它包含高效的 STM32F4 系列微控制器，非常适用于驱动电机、读码器、与传感器通信，并控制整个机电或机器人系统。在大多数应用中，CPU 负载不超过几个百分点，实时操作由基于 RTOS 的专用编程框架支持。我们还保证与 Arduino 库的兼容性。大多数任务都在微控制器外设中处理，如定时器、通信接口、ADC 等，它具有中断和 DMA 通道的强大支持。简而言之，对于具有其他任务的单板计算机来说，这不是一项任务。
另一方面，很显然，现代先进的机器人程序不能仅仅基于微控制器，原因如下：
* 自动机器人需要大量的处理能力来执行导航、图像和声音识别、移动等等，
* 编写先进的软件需要标准化才能有效 - SBC 在行业中越来越受欢迎，而对于为 SBC 编写的软件也是如此，这与 PC 电脑非常相似
* SBC 每年都变得越来越便宜 – Husarion 认为，结合这两个世界在机器人技术方面是非常有益的。
CORE2-ROS 控制器有两种配置：[Raspberry Pi 3](https://www.raspberrypi.org/products/raspberry-pi-3-model-b/) 或 [ASUS Tinker Board](https://www.asus.com/uk/Single-Board-Computer/Tinker-Board/)。CORE-ROS 运行于 Ubuntu、Husarion 开发和管理工具以及 ROS 软件包上。
下篇文章将介绍为何 Husarion 决定使用 Ubuntu 。
---
via: <https://insights.ubuntu.com/2017/07/12/robot-development-made-easy-with-husarion-core2-ros-running-ubuntu/>
作者：[Dominik Nowak](https://insights.ubuntu.com/author/guest/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
LXD 2.15 中的存储管理
|
Christian Brauner
|
https://insights.ubuntu.com/2017/07/12/storage-management-in-lxd-2-15/
|
长久以来 LXD 已经支持多种存储驱动。用户可以在 zfs、btrfs、lvm 或纯目录存储池之间进行选择，但他们只能使用单个存储池。一个被频繁被提到的需求是不仅支持单个存储池，还支持多个存储池。
|
/data/attachment/album/201708/03/183727syjxl7jwmy3myzfy.jpg.thumb.jpg
|
/data/attachment/album/201708/03/183727syjxl7jwmy3myzfy.jpg
| true | false | true |
geekpi
| false |
[
"LXD",
"容器",
"存储"
] |
容器与云
|
{
"viewnum": 7188,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
长久以来 LXD 已经支持多种存储驱动。用户可以在 zfs、btrfs、lvm 或纯目录存储池之间进行选择，但他们只能使用单个存储池。一个被频繁被提到的需求是不仅支持单个存储池，还支持多个存储池。
| 2017-08-03T18:37:38 | 2017-08-03T18:37:38 | 8,750 |
/article-8750-1.html
|
长久以来 LXD 已经支持多种存储驱动。用户可以在 zfs、btrfs、lvm 或纯目录存储池之间进行选择，但他们只能使用单个存储池。一个被频繁被提到的需求是不仅支持单个存储池，还支持多个存储池。这样，用户可以维护一个由 SSD 支持的 zfs 存储池用于 I/O 密集型容器，另一个简单的基于目录的存储池用于其他容器。幸运的是，现在这是可能的，因为 LXD 在几个版本后有了自己的存储管理 API。
### 创建存储池
新安装 LXD 没有定义任何存储池。如果你运行 `lxd init` ，LXD 将提供为你创建一个存储池。由 `lxd init` 创建的存储池将是创建容器的默认存储池。
### 创建更多的存储池
我们的客户端工具使得创建额外的存储池变得非常简单。为了创建和管理新的存储池，你可以使用 `lxc storage` 命令。所以如果你想在块设备 `/dev/sdb` 上创建一个额外的 btrfs 存储池，你只需使用 `lxc storage create my-btrfs btrfs source=/dev/sdb`。让我们来看看：
### 在默认存储池上创建容器
如果你从全新安装的 LXD 开始，并通过 `lxd init` 创建了一个存储池，LXD 将使用此池作为默认存储池。这意味着如果你执行 `lxc launch images:ubuntu/xenial xen1`，LXD 将为此存储池上的容器的根文件系统创建一个存储卷。在示例中，我们使用 `my-first-zfs-pool` 作为默认存储池。
### 在特定存储池上创建容器
但是你也可以通过传递 `-s` 参数来告诉 `lxc launch` 和 `lxc init` 在特定存储池上创建一个容器。例如，如果要在 `my-btrfs` 存储池上创建一个新的容器，你可以执行 `lxc launch images:ubuntu/xenial xen-on-my-btrfs -s my-btrfs`：
### 创建自定义存储卷
如果你其中一个容器需要额外的空间存储额外的数据，那么新的存储 API 将允许你创建可以连接到容器的存储卷。只需要 `lxc storage volume create my-btrfs my-custom-volume`：
### 连接自定义卷到容器中
当然，这个功能是有用的，因为存储 API 让你把这些存储卷连接到容器。要将存储卷连接到容器，可以使用 `lxc storage volume attach my-btrfs my-custom-volume xen1 data /opt/my/data`：
### 在容器之间共享自定义存储卷
默认情况下，LXD 将使连接的存储卷由其所连接的容器写入。这意味着它会将存储卷的所有权更改为容器的 id 映射。但存储卷也可以同时连接到多个容器。这对于在多个容器之间共享数据是非常好的。但是，这有一些限制。为了将存储卷连接到多个容器，它们必须共享相同的 id 映射。让我们创建一个额外的具有一个隔离的 id 映射的容器 `xen-isolated`。这意味着它的 id 映射在这个 LXD 实例中将是唯一的，因此没有其他容器具有相同的id映射。将相同的存储卷 `my-custom-volume` 连接到此容器现在将会失败：
但是我们让 `xen-isolated` 与 `xen1` 有相同的映射，并把它重命名为 `xen2` 来反映这个变化。现在我们可以将 `my-custom-volume` 连接到 `xen1` 和 `xen2` 而不会有问题：
### 总结
存储 API 是 LXD 非常强大的补充。它提供了一组基本功能，有助于在大规模使用容器时处理各种问题。这个简短的介绍希望给你一个印象，你可以做什么。将来会有更多介绍。
本篇文章最初在 [Brauner 的博客](https://cbrauner.wordpress.com/)中发布。
---
via: <https://insights.ubuntu.com/2017/07/12/storage-management-in-lxd-2-15/>
作者：[Christian Brauner](https://cbrauner.wordpress.com/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Docker、Kubernetes 和 Apache Mesos 对比中的一些误区
|
Amr Abdelrazik
|
https://mesosphere.com/blog/docker-vs-kubernetes-vs-apache-mesos/
|
如果你只是听信了只言片语，你可能会认为这三个开源项目正为了称霸容器界而殊死搏斗。你可能还相信从他们中选出一个如宗教信仰般神圣——真正的信徒会忠于他们的信仰，而且会烧死那些敢于考虑替代方案的异教徒。
|
/data/attachment/album/201708/04/080248k1iovvt8rgzlirij.jpg.thumb.jpg
|
/data/attachment/album/201708/04/080248k1iovvt8rgzlirij.jpg
| true | false | true |
rieonke
| false |
[
"Docker",
"Kubernetes",
"Mesos",
"容器",
"编排"
] |
观点
|
{
"viewnum": 15909,
"commentnum": 1,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "58.63.60.83",
"message": "文中所说的分布式数据服务Elastic不是一个产品，应该指的是The Open Source Elastic Stack，一系列产品。",
"username": "文剑一飞 [Chrome 60.0|Windows 10]",
"date": "2017-08-04T16:13:41"
}
] |
[] |
如果你只是听信了只言片语，你可能会认为这三个开源项目正为了称霸容器界而殊死搏斗。你可能还相信从他们中选出一个如宗教信仰般神圣——真正的信徒会忠于他们的信仰，而且会烧死那些敢于考虑替代方案的异教徒。
| 2017-08-04T08:03:15 | 2017-08-04T08:03:15 | 8,751 |
/article-8751-1.html
|
有无数的文章、讨论、以及很多社区喋喋不休地比较 Docker、Kubernetes 和 Mesos。如果你只是听信了只言片语，你可能会认为这三个开源项目正为了称霸容器界而殊死搏斗。你可能还相信从他们中选出一个如宗教信仰般神圣——真正的信徒会忠于他们的信仰，而且会烧死那些敢于考虑替代方案的异教徒。
那都是废话。
虽然所有这三种技术都使得使用容器来部署、管理和伸缩应用成为可能，但实际上它们各自解决了不同的问题，并且根植于迥异的上下文环境中。事实上，这三种被广泛采用的工具链，都是有差别的。
让我们重新审视每个项目的原始任务、技术架构，以及它们是如何相互补充和交互的，而不是纠结于比较这些快速迭代的技术之间重叠的特性。
### 让我们从 Docker 开始……
Docker 公司，始于名为 dotCloud 的平台即服务（PaaS）供应商。dotCloud 团队发现，在许多应用和客户之间管理依赖和二进制文件时需要付出大量的工作。因此他们将 Linux 的 [cgroups](https://en.wikipedia.org/wiki/Cgroups) 和 namespace 的一些功能合并成一个单一且易于使用的软件包，以便于应用程序可以一致地运行在任何基础设施上。这个软件包就是所谓的 [Docker 镜像](https://docs.docker.com/engine/docker-overview/)，它提供了如下的功能：
* **将应用程序和依赖库封装在一个软件包**（即 Docker 镜像）中，因此应用可以被一致地部署在各个环境上；
* **提供类似 Git 的语义**，例如 `docker push`，`docker commit` 等命令让应用开发者可以快速接受这门新的技术，并将其融入到现有的工作流中；
* **定义 Docker 镜像为不可变的层**，支持不可变的基础设施。新提交的变更被分别保存为只读层，让复用镜像和追踪变更记录变得十分简单。层还通过只传输更新而不是整个镜像来节省磁盘空间和网络流量；
* **通过实例化不可变的镜像**和读写层来运行 Docker 容器，读写层可以临时地存储运行时变更，从而轻松部署和扩展应用程序的多个实例。
Docker 变得越来越受欢迎，开发者们开始从在笔记本电脑上运行容器转而在生产环境中运行容器。跨多个机器之间协调这些容器需要额外的工具，这称之为<ruby> 容器编排 <rt> container orchestration </rt></ruby>。有趣的是，第一个支持 Docker 镜像的容器编排工具（2014 年 6月）是 Apache Mesos 的 [Marathon](https://mesosphere.github.io/marathon/)（后面会有详细介绍) 。那年，Docker 的创始人兼首席技术官 Solomon Hykes 将 Mesos 推荐为“[生产集群的黄金标准](https://www.google.com/url?q=https://www.youtube.com/watch?v=sGWQ8WiGN8Y&feature=youtu.be&t=35m10s&sa=D&ust=1500923856666000&usg=AFQjCNFLtW96ZWnOUGFPX_XUuVOPdWrd_w)”。不久之后，除了 Mesos 的 Marathon 之外，还出现了许多的容器编排技术：[Nomad](https://www.google.com/url?q=https://www.youtube.com/watch?v=sGWQ8WiGN8Y&feature=youtu.be&t=35m10s&sa=D&ust=1500923856666000&usg=AFQjCNFLtW96ZWnOUGFPX_XUuVOPdWrd_w)、[Kubernetes](https://www.nomadproject.io/)，不出所料还有 Docker Swarm （[它如今是 Docker 引擎的一部分](https://blog.docker.com/2016/06/docker-1-12-built-in-orchestration/)）。
随着 Docker 开始商业化其开源的文件格式（LCTT 译注：指 Docker 镜像的 dockerfile 文件格式），该公司还开始引入工具来完善其核心的 Docker 文件格式和运行时引擎，包括：
* 为公开存储 Docker 镜像的而生的 Docker hub；
* 存储私有镜像的 Docker 仓库（Docker registry）；
* Docker cloud，用于构建和运行容器的管理性服务；
* Docker 数据中心作为一种商业产品体现了许多 Docker 技术；
*来源: [www.docker.com](http://www.docker.com)*
Docker 将软件及其依赖关系封装在一个软件包中的洞察力改变了软件行业的游戏规则，正如 mp3 的出现重塑了音乐行业一般。Docker 文件格式成为行业标准，领先的容器技术供应商（包括 Docker、Google、Pivotal、Mesosphere 等) 组建了 [<ruby> 云计算基金会 <rt> Cloud Native Computing Foundation </rt></ruby> (CNCF)](https://www.cncf.io/) 和 [<ruby> 开放容器推进联盟 <rt> Open Container Initiative </rt></ruby> (OCI)](https://www.opencontainers.org/)。如今，CNCF 和 OCI 旨在确保容器技术之间的互操性和标准化接口，并确保使用任何工具构建的任何 Docker 容器都可以在任何运行时或基础架构上运行。
### 进入 Kubernetes
Google 很早就认识到了 Docker 的潜力，并试图在 Google Cloud Platform （GCP）上提供容器编排“即服务”。 Google 在容器方面拥有丰富的经验（是他们在 Linux 中引入了 cgroups），但现有的内部容器和 Borg 等分布式计算工具直接与其基础架构相耦合。所以，Google 没有使用原有系统的任何代码，而是从头开始设计 Kubernetes （K8S）来编排 Docker 容器。 Kubernetes 于 2015 年 2 月发布，其目标和考虑如下：
* **为应用程序开发人员提供**编排 Docker 容器的强大工具，而无需与底层基础设施交互；
* **提供标准部署接口**和原语，以实现云端一致的应用部署体验和 API;
* **基于模块化 API 核心**，允许供应商围绕 Kubernetes 的核心技术集成其系统。
2016 年 3 月，Google [将 Kubernetes 捐赠](https://www.linuxfoundation.org/news-media/announcements/2016/03/cloud-native-computing-foundation-accepts-kubernetes-first-hosted-0)给了 CNCF，并且直到今天仍然是该项目的主要贡献者（其次是Redhat，CoreOS 等）。
*来源: wikipedia*
Kubernetes 对应用程序开发人员非常有吸引力，因为它减轻了对基础架构和运营团队的依赖程度。供应商也喜欢 Kubernetes，因为它提供了一个容易的方式来拥抱容器化运动，并为客户部署自己的 Kubernetes（这仍然是一个值得重视的挑战）提供商业解决方案。 Kubernetes 也是有吸引力的，因为它是 CNCF 旗下的开源项目，与 Docker Swarm 相反，Docker Swarm 尽管是开源的，但是被 Docker 公司紧紧地掌控着。
Kubernetes 的核心优势是为应用程序开发人员提供了用于编排无状态 Docker 容器的强大工具。 虽然有多个扩大项目范围的提议，以提供更多的功能（例如分析和有状态数据服务），但这些提议仍处于非常早期的阶段，它们能取得多大的成功还有待观察。
### Apache Mesos
Apache Mesos 始于<ruby> 加州大学伯克利分校 <rt> UC Berkeley </rt></ruby>的下一代容器集群管理器项目，并应用了从云计算级别的分布式基础架构（如 [Google 的 Borg](https://research.google.com/pubs/pub43438.html) 和 [Facebook 的 Tupperware](https://www.youtube.com/watch?v=C_WuUgTqgOc)）中习得的经验和教训。 虽然 Borg 和 Tupperware 具有单一的架构，并且是与物理基础架构紧密结合的闭源专有技术，但 Mesos 推出了一种模块化架构，一种开源的开发方法，旨在完全独立于基础架构。Mesos 迅速被 [Twitter](https://youtu.be/F1-UEIG7u5g)、[Apple（Siri 中）](http://www.businessinsider.com/apple-siri-uses-apache-mesos-2015-8)、[Yelp](https://engineeringblog.yelp.com/2015/11/introducing-paasta-an-open-platform-as-a-service.html)、[Uber](http://highscalability.com/blog/2016/9/28/how-uber-manages-a-million-writes-per-second-using-mesos-and.html)、[Netflix](https://medium.com/netflix-techblog/distributed-resource-scheduling-with-apache-mesos-32bd9eb4ca38) 和许多领先的技术公司采用，支持从微服务、大数据和实时分析到弹性扩展的一切。
作为集群管理器，Mesos 被设计用来解决一系列不同的挑战：
* **将数据中心资源抽象**为单个池来简化资源分配，同时在私有云或公有云中提供一致的应用和运维体验；
* 在相同的基础架构上**协调多个工作负载**，如分析、无状态微服务、分布式数据服务和传统应用程序，以提高利用率，降低成本和台面空间;
* 为应用程序特定的任务（如部署、自我修复、扩展和升级），**自动执行第二天的操作**；提供高度可用的容错基础设施；
* **提供持久的可扩展性**来运行新的应用程序和技术，而无需修改集群管理器或其上构建的任何现有应用程序；
* **弹性扩展**可以将应用程序和底层基础设施从少量扩展到数十到数万个节点。
Mesos 独有的独立管理各种工作负载的能力 —— 包括 Java 这样的传统应用程序、无状态 Docker 微服务、批处理作业、实时分析和有状态的分布式数据服务。Mesos 广泛的工作负载覆盖来自于其两级架构，从而实现了“应用感知”调度。通过将应用程序特定的操作逻辑封装在“Mesos 框架”（类似于操作中的运行手册）中来实现应用程序感知调度。资源管理器 Mesos Master 提供了这些框架基础架构的部分，同时保持隔离。这种方法允许每个工作负载都有自己的专门构建的应用程序调度程序，可以了解其部署、扩展和升级的特定操作要求。应用程序调度程序也是独立开发、管理和更新的，这让 Mesos 拥有高度可扩展的能力，支持新的工作负载或随着时间的推移而增加更多的操作功能。
举一个团队如何管理应用软件升级的例子。无状态应用程序可以从[“蓝/绿”](https://martinfowler.com/bliki/BlueGreenDeployment.html)部署方案中受益；当新版本的应用运行起来时，原先旧版本的软件依然还正常运转着，然后当旧应用被销毁时流量将会切换到新的应用上。但是升级数据工作负载例如 HDFS 或者 Cassandra 要求节点停机一次，此时需要持久化本地数据卷以防止数据丢失，并且按照特定的顺序执行原位升级，在升级之前和升级完成之后，都要在每一个节点类型上执行特定的检查和命令。任何这些步骤都是应用程序或服务特定的，甚至可能是版本特定的。这让使用常规容器编排调度程序来管理数据服务变得非常困难。
Mesos 以每一个工作负载所需的特定方式管理各种工作负载，使得许多公司将 Mesos 作为一个统一的平台，将微服务和数据服务结合在一起。数据密集型应用程序的通用参考架构是 [“SMACK 家族”](https://mesosphere.com/blog/2017/06/21/smack-stack-new-lamp-stack/)（LCTT 译注：SMACK 即 Spark、Mesos、Akka、Cassandra、Kafka)。
### 是时候搞清楚这些了
请注意，我们尚未对 Apache Mesos 的容器编排有任何描述。所以为什么人们会自动地将 Mesos 和容器编排联系起来呢？容器编排是可以在 Mesos 的模块化架构上运行的工作负载的一个例子，它是通过一个专门的编排“框架”来完成的，这个框架就 Marathon，一个构建于 Mesos 之上的工具。 Marathon 最初是为了在 [cgroup](https://en.wikipedia.org/wiki/Cgroups) 容器中编排应用归档（如 JAR、tarball、ZIP 文件）而开发的，是 2014 年最先支持 Docker 容器的编排工具之一。
所以当人们将 Docker 和 Kubernetes 与 Mesos 进行比较时，他们实际上是将 Kubernetes 和 Docker Swarm 与在 Mesos 上运行的 Marathon 进行比较。
为什么搞清楚这一点很重要？ 因为 Mesos 坦率地讲并不在乎它上面运行了什么。 Mesos 可以在共享的基础设施上弹性地为 Java 应用服务器提供集群服务、Docker 容器编排、Jenkins 持续集成任务、Apache Spark 分析、Apache Kafka 流，以及更多其他的服务。Mesos 甚至可以运行 Kubernetes 或者其他的容器编排工具，即使公共的集成目前还不可用。
*来源: Apache Mesos 2016 调查问卷*
Mesos 的另一个考虑因素（也是为什么它对许多企业架构师来说如此有吸引力）是运行关键任务工作负载的成熟度。 Mesos 已经在大规模生产环境下（成千上万台服务器）运行了超过 7 年的时间，这就是为什么它比市场上许多其他的容器技术更具有生产上的可行性和扩展上的可靠性。
### 我所说的这些什么意思？
总而言之，所有这三种技术都与 Docker 容器有关，可以让你在容器编排上实现应用程序的可移植性和扩展性。那么你在它们之间如何选择呢？ 归根到底是为工作选择合适的工具（也可能是为不同的工作选择不同的工具）。如果您是一个应用开发人员，正在寻找现代化的方式来构建和打包你的应用程序，或者想加速你的微服务计划，Docker 容器和开发工具就是最好的选择。
如果你们是一个开发人员或者 DevOps 的团队，并希望构建一个专门用于 Docker 容器编排的系统，而且愿意花时间折腾集成解决方案与底层基础设施（或依靠公共云基础架构，如 Google 容器引擎（GCE）或 Azure 容器服务（ACS）），Kubernetes 是一个可以考虑的好技术。
如果你们想要建立一个运行多个关键任务工作负载的可靠平台，包括 Docker 容器、传统应用程序（例如 Java）和分布式数据服务（例如 Spark、Kafka、Cassandra、Elastic），并希望所有这些可依移植到云端提供商或者数据中心，那么 Mesos（或我们自己的 Mesos 发行版，Mesosphere DC/OS）更适合你们的需求。
无论您选择什么，您都将拥抱一套可以更有效地利用服务器资源的工具，简化应用程序的可移植性，并提高开发人员的敏捷性。你的选择真的不会有错。
---
via: <https://mesosphere.com/blog/docker-vs-kubernetes-vs-apache-mesos/>
作者：[Amr Abdelrazik](https://mesosphere.com/blog/author/amr-abdelrazik/) 译者：[rieonke](https://github.com/rieonke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
3 个开源的音乐播放器：Aqulung、Lollypop 和 GogglesMM
|
Chris Hermansen
|
https://opensource.com/article/17/1/open-source-music-players
|
音乐是生活的一部分。维基百科关于音乐发展历史的文章有这样一段不错的描述说：“全世界所有的人们，包括哪怕是最孤立、与世隔绝的部落，都会有自己的特色音乐……”好吧，我们开源人就构成了一个部落。
|
/data/attachment/album/201708/04/233710vizw2xhxw4wdpow1.png.thumb.jpg
|
/data/attachment/album/201708/04/233710vizw2xhxw4wdpow1.png
| true | false | true |
WangYueScream
| false |
[
"音乐播放器"
] |
分享
|
{
"viewnum": 14205,
"commentnum": 4,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.249.61.68",
"message": "lolypop的界面风格老实说我不是很喜欢。我比较喜欢G3开箱自带的那个播放器。",
"username": "来自湖南长沙的 QQ Browser 9.6|Windows 7 用户",
"date": "2017-08-05T16:57:07"
},
{
"postip": "23.83.239.200",
"message": "说的好，我选择VLC",
"username": "来自美国的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-05T20:45:28"
},
{
"postip": "125.46.3.236",
"message": "我选择 Windows Media Player=_=",
"username": "来自河南平顶山的 Chrome 50.0|Windows 7 用户",
"date": "2017-08-06T02:39:48"
},
{
"postip": "218.19.206.89",
"message": "linux上面有吗？",
"username": "Wf_talk [Chrome 59.0|GNU/Linux]",
"date": "2017-08-06T15:38:08"
}
] |
[] |
音乐是生活的一部分。维基百科关于音乐发展历史的文章有这样一段不错的描述说：“全世界所有的人们，包括哪怕是最孤立、与世隔绝的部落，都会有自己的特色音乐……”好吧，我们开源人就构成了一个部落。
| 2017-08-05T10:35:00 | 2017-08-05T10:35:00 | 8,753 |
/article-8753-1.html
|
音乐是生活的一部分。[维基百科关于音乐发展历史的文章](https://en.wikipedia.org/wiki/History_of_music)有这样一段不错的描述说：“全世界所有的人们，包括哪怕是最孤立、与世隔绝的部落，都会有自己的特色音乐……”好吧，我们开源人就构成了一个部落。我建议我们的“音乐形式”应该包括开源音乐播放器。在过去几年里，我已经使用体验过不少我能接触到的音乐播放器；[2016 年 12 月份](https://opensource.com/article/16/12/soundtrack-open-source-music-players)我根据这六个标准来总结概括了我使用开源音乐播放器的感受：
1. 必须是能够通过设置让音乐一成不变地转换到 [ALSA](http://www.alsa-project.org/main/index.php/Main_Page)。（最高分 ５分）
2. 应该有一个不错的“智能播放列表”。（１ 分）
3. 不应该强迫用户只能通过播放列表来进行交互。（1 分）
4. 应该能够提供一个简单的方法来显示歌曲的封面图片——使用内嵌的封面图或使用在音乐目录里面 cover．jpg（或者 .png）文件替代。
5. 应该能够在音乐播放的时候显示信号级别和实际比特率。（１ 分）
6. 能够呈现出不错的整体组织，结构布局和执行性能。（１ 分）
热心的读者让告诉我有三个播放器是在我的资源仓库里没有的：[Aqualung](http://aqualung.jeremyevans.net/)、[Lollypop](https://gnumdk.github.io/lollypop-web/) 和 [GogglesMM](https://gogglesmm.github.io/)。我并不想在我办公用的电脑里面安装那些来自外面的软件，我承诺过我会配置一个“试验台”来测试这三个音乐播放器，并给出测试的细节。
### Aqualung
[Aqualung](http://aqualung.jeremyevans.net/) 有一个写的清晰明了的网站来解释它众多的特点。其上提供的说明中我发现其中一点特别有趣：
“你能够（也应该）将你的所有音乐按照艺术家／档案／声轨这样组织成一个树型结构，这样比生成一个一体化的 Winamp／XMMS 播放列表更舒服。”
这点让我有些困惑，因为我总是把我的音乐按照艺术家、专辑和声轨这样组织成树状。但这就可能解释了为什么我有时发现 XMMS 流派的播放器在浏览音乐时有一点古怪。
根据 Aqualung 官网的下载页面说明，官方发布的只有源代码。但是文档上的说明暗示了绝大多数主流的 Linux 发行版本都包括一份 Aqualung 的构建副本，但我当前用的办公电脑所使用的 Linux 发行版 Ubuntu 16.10 并不在此范围内。[Launchpad.net](https://launchpad.net/+search?field.text=aqualung+ppa) 提供有 PPA，但那些软件看起来都有些过时了，所以为什么不试试编译源码安装软件呢？
我根据官网上编译文档的建议和配置脚本的提示安装了 **pkgconf** 以及 **libasound**、**libflac**、**libmp3lame**、**libvorbis**、**libxml2**、**libglib2.0** 和 **libgtk+-2.0** 的开发库。接下来，我就能够干净利索的进行 `configure` 然后进行 `make` 和 `make install`。最终我可以执行 `/usr/local/bin/aqualung` 了。
*Aqualung，不能切换音乐播放的码率。*
一旦 Aqualung 启动运行，我就能看到相当简洁直接的两窗口界面：播放器本身和“音乐商店”。我通过右键点击播放器的音乐面板打开参数设置查看这些可设置的参数，看是否能找到 AudioQuest DragonFly 这个数模转换器，但我没有找到任何相关的迹象。然而，站点上的说明指出可以通过命令行指定输出设备。最终我用 **plughw** 设备才让 Aqualung 启动起来。
在那个时候，真正让我对 Aqualung 感到失望的是 Aqualung 似乎是需要一个固定的输出采样频率。我能够用 Aqualung 播放器的默认设置来正常播放我的 44.1 Khz 文件，但是同样的采样频率播放 96 Khz 的音乐文件时，我不得不关闭软件并重新启动。也正是因为这一点，我不会再继续对 Aqualung 进行使用测评。
**无评分。**
### Lollypop
*优美的 Lollypop 用户界面。*
[Lollypop](https://gnumdk.github.io/lollypop-web/) 有一个华丽的网站。尽管它不在我办公专用的电脑的软件仓库里面，但是有一个“针对 Ubuntu/Debian 用户的下载”链接带你跳转到 [launchpad.net 站点提供的最新的 PPA](https://launchpad.net/%7Egnumdk/+archive/ubuntu/lollypop)。这个站点还提供针对 Flatpak、Arch Linux、Fedora 和 OpenSUSE 这些系统的 Lollypop 软件包的下载。我看了下 [Fedora COPR 上针对各个 Fedora 版本的 Lollypop 下载链接](https://copr.fedorainfracloud.org/coprs/gnumdk/lollypop/)，看起来 Lollypop 更新的比较及时而且从 Fedora 版本的 23 到 26 都有对应的软件包提供下载安装。
一天内做一次源码编译就足够了，所以我决定试试从 PPA 安装这款软件。我通过命令行来执行 Lollypop 软件。设置菜单能够在 Lollypop 界面的右上方很显眼地看见。更新完我的音乐后，我开始找电脑的输出设备设置，但是在一番查看后，我不知道该怎么选择合适的输出设备。即便我在命令行通过 **-help** 也找不到有用的帮助信息。
经过一番网上搜索后我找到一个 Lollypop 的开发者的提示才知道我需要 **gstreamer libav** 来让 Lollypop 工作。通过这个说明我决定停止，因为这可能需要一个 **gstreamer** 相关配置才有能工作，但是我不太想继续尝试了。
Lollypop 有一个优美的用户交互界面和它的优美的网站相得益彰，但是我现在不会进一步对它进行测评，否则我就又多了一个进一步去学习了解 **gstreamer** 的理由。
**无评分。**
### GogglesMM
[Goggles Music Manager](https://gogglesmm.github.io/) 也有一个[在 launchpad.net 及时更新的 PPA](https://launchpad.net/%7Es.jansen/+archive/ubuntu/gogglesmm)；安装流程简单明了，我现在可以在命令行执行 **gogglesmm** 了。
GogglesMM，非常容易上手使用，看上去和 Rhythmbox 有点像。我在 GogglesMM 的设置里面的参数设置中找到了音频选项设置，能够让我选择 ALSA 和设置音频输出设备。通过查看 **/proc/asound/DragonFly/stream0** 文件和 DragonFly 自己的 LED 颜色，我确定我能够用 GogglesMM 播放 44.1-KHz／21-bit 和 96-KHz／24-bit 这两种规格的 mp3；因此，就凭 “rate/depth passthrough” 我给 GogglesMM 打 5 分。
\*GogglesMM 在播放 96/24 这种规格的音乐，显示音频输出设备选择。 \*
GogglesMM 的说明文档并没有大量的细节介绍，但是我尽可能说明的是，开发者们使用了过滤器来实现类似“智能播放列表”的功能。我在我的测试环境下使用三张专辑来尽我所能检测过滤功能，当我使用“智能播放列表”功能的时候尽管我喜欢我看到的通过过滤筛选出来的歌曲（特别是能够基于广泛的标准来针对歌曲定义筛选条件），但这并不是我认为的“智能播放列表”，对我来说我认为“智能播放列表”应该是这样的，通过借助一些社区数据库来推荐提供和你近期播放的歌曲类似的曲目。或者我该把这个叫作“自动的 DJ”而不是“智能播放列表”，但是通过测试我最终能够确定的是，这个特性并不会在近期版本的 GogglesMM 中出现，所以我给它这个所谓的“智能播放列表”打 0 分。
至于播放列表队列的操作，这款应用能够支持播放你选中的音乐，也能够随机播放音乐或者把一些音乐整合到一个播放列表里面，所以我因为“播放列表的队列选项”给它打 1 分。
同样的，它看起来也能够很好地不需要额外的干预来管理我的音乐艺术封面（每个专辑都包含一张合适的艺术封面， GogglesMM 可以自动识别），所以为“内嵌的艺术封面或者封面图片”打 1 分。
我找不到任何方法来让 GogglesMM 显示信号级别或者实际的比特率。我也不能找到显示比特率和位深度的方法；尽管这款应用能够显示一个“格式”列，但是在我的音乐栏里面除了显示音乐格式不会显示其他的信息了，所以为 GogglesMM 的“信号级别和有效比特率”打 0 分。
至于 GogglesMM 的整体结构，它的所有按钮选项都正好完全符合我的使用习惯。我能够在播放队列里面看到歌曲的时间和歌曲当前已播放的时间所占歌曲总体时间的比例，专辑封面，歌曲名，专辑名和歌唱者。可用的播放栏列表看起来相当大而有用，比如也包括了作曲者。最后，一个真正让我眼前一亮的特点是，音量控制竟然包含了 ALSA 音量。也就是如果我启动 alsamixer 的话，然后不管是在 alsamixer 还是在 GogglesMM 里面调整音量，另一个音量控制也会做相应的音量调整。这个出乎我意外之外的功能相当的酷而且这个功能在其他的音乐播放器上也不常见，因此为它的整体架构给 GogglesMM 加 1 分。
最终 GogglesMM 的这些优点共计得分 8。所表现出来的特点确实很优秀。
**评分：8**
### 到目前为止所给出的评分
我之前所提到的这几个开源音乐播放器中，我最喜欢的还是 [Guayadeque](http://www.guayadeque.org/)，根据我制定的标准来进行排名的话，我给 Guayadeque 打满分 10 分。来看下我对这三个开源音乐播放器的评分总结吧（N/R 代表“无评分”，因为我不确定如何配置这些播放器来让它们以完美的码率和贯穿模式工作，以便我的数模信号转换器在相应源的码率和位深度接收 PCM 数据）：
请注意下我用的这个排名方法并不适合每个人。特别是很多人并不清楚高品质音乐的价值，他们更喜欢专有格式的音乐能够给他们带来更好的音乐品质。
与此同时，我会继续评测一些之前向大家承诺的音乐播放器一些和评测评分无关的特性。我特别喜欢 Lollypop 的外观，我也觉得待揭秘的 **gstreamer** 有一种神秘的魅力，它能让基于 **gstreamer** 的音乐播放器不用通过转换就能传输它们的数据。
### 关于音乐的部分……
我还在保持继续购买唱片的习惯，对于唱片的购买我有些不错的推荐。
第一个就是 Nils Frahm 的专辑 [Felt](http://www.nilsfrahm.com/works/felt/)，这是我女儿送我的一份非常贴心的礼物。我真的真的很喜欢这张专辑，它的绝大部分歌曲都是在深夜用电麦录制的非常接近钢琴的弦乐，而且也有不少有趣的钢琴演奏的背景音乐，真的是很棒的音乐。至于 Nils Frahm 其他的音乐，这些唱片提供的下载链接允许你下载质量高达 96-KHz，24-bit FLAC 格式的音乐。
第二个就是 Massive Attack 的专辑 Protection 的 [Mad Professor 的重混版](https://en.wikipedia.org/wiki/No_Protection_(Massive_Attack_album))，专辑名是 No Protection。你可以[在这里了解这份专辑](https://www.youtube.com/watch?v=9TvgRb4wiB0)，并且如果你想要尝试这份专辑最原始的版本，[这里是它的所有汇总信息](https://www.youtube.com/watch?v=LCUv-hLN71c)。该专辑最初发布于 20 世纪 90 年代，这份专辑刻录在唱片上面而且听起来非常奇幻。遗憾的是，不提供下载链接。
第三个就是 Bayonne 的 [Primitives](https://musicglue.com/bayonne/products/primitives---vinyl--/)。[这是专辑要表达的想法](https://www.youtube.com/watch?v=WZ6xl6CKITE)。Guardian 报社把这份专辑称作是“新式无聊”。那么这种类型的音乐到底怎么样呢？如果这些音乐真的是非常令人乏味的，或许是时候来换份工作了，无论如何你可以试试听这些音乐；或许你会觉得它确实很乏味或者你会像我一样喜欢上这份音乐。
（图片来源：[互联网档案馆](https://www.flickr.com/photos/internetarchivebookimages/14565158187/in/photolist-ocoBRG-ocqdPM-ot9YYX-ovb7SE-oroqfj-ot8Sfi-of1HoD-oc5c28-otBk3B-foZxvq-ocoUvo-4TqEKE-otsG7t-oeYo4w-ornGMQ-orpD9y-wLDBUf-outZV7-oc26Ui-ortZpW-ocpWLH-ocoK6c-ocYDY1-od6ADb-xxAKyY-ocofDx-oc4Jr5-otyT2E-ocpUyu-xqTAb6-oc8gK1-otdsK5-ovhkz2-ocpcHj-oc8xwk-otgmZG-otr595-otnv4o-otvdRs-ovfYEt-ovDXUV-obUPJ6-oc2MuJ-oc4zLE-oruPbN-oc1P2H-ouRk93-otaGd3-otTmwB-oc5f62)书中的图片；由 Opensource.com 编辑发布。遵循 [CC BY-SA 4.0](http://creativecommons.org/licenses/by-sa/4.0/) 协议。）
---
作者简介：
Chris Hermansen - 自 1978 年毕业于 British Columbia 大学后一直从事计算机相关工作，2005 年之前是 Solaris、SunOS、UNIX System V 的忠实用户，之后是 Linux 的忠实用户。在技术方面，我的职业生涯大部分时间都是在做数据分析；特别是空间数据分析。拥有丰富的和数据分析相关的编程经验，用过的编程语言有 awk，Python、PostgreSQL、 PostGIS 和 最新的 Groovy。
---
via: <https://opensource.com/article/17/1/open-source-music-players>
作者：[Chris Hermansen](https://opensource.com/users/clhermansen) 译者：[WangYueScream](https://github.com/WangYueScream) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
值得收藏的 27 个机器学习的小抄
|
Robbie Allen
|
https://unsupervisedmethods.com/cheat-sheet-of-machine-learning-and-python-and-math-cheat-sheets-a4afe4e791b6
|
机器学习有很多方面，当我开始研究学习它时，我发现了各种各样的“小抄”，它们简明地列出了给定主题的关键知识点。最终，我汇集了超过 20 篇的机器学习相关的小抄，其中一些我经常会翻阅，而另一些我也获益匪浅。这篇文章里面包含了我在网上找到的 27 个小抄，如果你发现我有所遗漏的话，请告诉我。
|
/data/attachment/album/201708/05/110932z0qn5opx5yoq6f5j.jpg.thumb.jpg
|
/data/attachment/album/201708/05/110932z0qn5opx5yoq6f5j.jpg
| true | false | true |
wxy
| true |
[
"机器学习",
"ML"
] |
分享
|
{
"viewnum": 21361,
"commentnum": 1,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "119.123.12.222",
"message": "多谢分享",
"username": "hello_linux [Chrome 51.0|Windows 7]",
"date": "2017-08-14T22:44:45"
}
] |
[] |
机器学习有很多方面，当我开始研究学习它时，我发现了各种各样的“小抄”，它们简明地列出了给定主题的关键知识点。最终，我汇集了超过 20 篇的机器学习相关的小抄，其中一些我经常会翻阅，而另一些我也获益匪浅。这篇文章里面包含了我在网上找到的 27 个小抄，如果你发现我有所遗漏的话，请告诉我。
| 2017-08-05T11:09:00 | 2017-08-05T11:09:00 | 8,754 |
/article-8754-1.html
|
<ruby> 机器学习 <rp> （ </rp> <rt> Machine Learning </rt> <rp> ） </rp></ruby>有很多方面，当我开始研究学习它时，我发现了各种各样的“小抄”，它们简明地列出了给定主题的关键知识点。最终，我汇集了超过 20 篇的机器学习相关的小抄，其中一些我经常会翻阅，而另一些我也获益匪浅。这篇文章里面包含了我在网上找到的 27 个小抄，如果你发现我有所遗漏的话，请告诉我。
机器学习领域的变化是日新月异的，我想这些可能很快就会过时，但是至少在 2017 年 6 月 1 日时，它们还是很潮的。
如果你喜欢这篇文章，那就分享给更多人，如果你想感谢我，就到[原帖地址](https://unsupervisedmethods.com/cheat-sheet-of-machine-learning-and-python-and-math-cheat-sheets-a4afe4e791b6)点个赞吧。
### 机器学习
这里有一些有用的流程图和机器学习算法表，我只包括了我所发现的最全面的几个。
#### 神经网络架构
来源： <http://www.asimovinstitute.org/neural-network-zoo/>
*神经网络公园*
#### 微软 Azure 算法流程图
来源： <https://docs.microsoft.com/en-us/azure/machine-learning/machine-learning-algorithm-cheat-sheet>
*用于微软 Azure 机器学习工作室的机器学习算法*
#### SAS 算法流程图
来源： <http://blogs.sas.com/content/subconsciousmusings/2017/04/12/machine-learning-algorithm-use/>
*SAS：我应该使用哪个机器学习算法？*
#### 算法总结
来源： <http://machinelearningmastery.com/a-tour-of-machine-learning-algorithms/>
*机器学习算法指引*
来源： [http://thinkbigdata.in/best-known-machine-learning-algorithms-infographic/](http://thinkbigdata.in/best-known-machine-learning-algorithms-infographic/?utm_source=datafloq&utm_medium=ref&utm_campaign=datafloq)
*已知的机器学习算法哪个最好？*
#### 算法优劣
来源： <https://blog.dataiku.com/machine-learning-explained-algorithms-are-your-friend>
### Python
自然而然，也有许多在线资源是针对 Python 的，这一节中，我仅包括了我所见过的最好的那些小抄。
#### 算法
来源： <https://www.analyticsvidhya.com/blog/2015/09/full-cheatsheet-machine-learning-algorithms/>
#### **Python 基础**
来源： <http://datasciencefree.com/python.pdf>
来源： <https://www.datacamp.com/community/tutorials/python-data-science-cheat-sheet-basics#gs.0x1rxEA>
#### Numpy
来源： <https://www.dataquest.io/blog/numpy-cheat-sheet/>
来源： <http://datasciencefree.com/numpy.pdf>
来源： <https://www.datacamp.com/community/blog/python-numpy-cheat-sheet#gs.Nw3V6CE>
来源： <https://github.com/donnemartin/data-science-ipython-notebooks/blob/master/numpy/numpy.ipynb>
#### Pandas
来源： <http://datasciencefree.com/pandas.pdf>
来源： <https://www.datacamp.com/community/blog/python-pandas-cheat-sheet#gs.S4P4T=U>
来源： <https://github.com/donnemartin/data-science-ipython-notebooks/blob/master/pandas/pandas.ipynb>
#### Matplotlib
来源： <https://www.datacamp.com/community/blog/python-matplotlib-cheat-sheet>
来源： <https://github.com/donnemartin/data-science-ipython-notebooks/blob/master/matplotlib/matplotlib.ipynb>
#### Scikit Learn
来源： <https://www.datacamp.com/community/blog/scikit-learn-cheat-sheet#gs.fZ2A1Jk>
来源： <http://peekaboo-vision.blogspot.de/2013/01/machine-learning-cheat-sheet-for-scikit.html>
来源： <https://github.com/rcompton/ml_cheat_sheet/blob/master/supervised_learning.ipynb>
#### Tensorflow
来源： <https://github.com/aymericdamien/TensorFlow-Examples/blob/master/notebooks/1_Introduction/basic_operations.ipynb>
#### Pytorch
来源： <https://github.com/bfortuner/pytorch-cheatsheet>
### 数学
如果你希望了解机器学习，那你就需要彻底地理解统计学（特别是概率）、线性代数和一些微积分。我在本科时辅修了数学，但是我确实需要复习一下了。这些小抄提供了机器学习算法背后你所需要了解的大部分数学知识。
#### 概率
来源： <http://www.wzchen.com/s/probability_cheatsheet.pdf>
*概率小抄 2.0*
#### 线性代数
来源： <https://minireference.com/static/tutorials/linear_algebra_in_4_pages.pdf>
*四页内解释线性代数*
#### 统计学
来源： <http://web.mit.edu/~csvoss/Public/usabo/stats_handout.pdf>
*统计学小抄*
#### 微积分
来源： <http://tutorial.math.lamar.edu/getfile.aspx?file=B,41,N>
*微积分小抄*
|
||
lxc exec 介绍
|
Brauner
|
https://cbrauner.wordpress.com/2017/01/20/lxc-exec-vs-ssh/
|
最近，我对 lxc exec 进行了几个改进。如果你不知道它的话我介绍一下，lxc exec 是 LXD 的客户端工具，使用 LXD 客户端 api 与 LXD 守护程序通信，并执行用户想要执行的各种程序
|
/data/attachment/album/201708/06/092553aufwyyrjurjyo48c.jpg.thumb.jpg
|
/data/attachment/album/201708/06/092553aufwyyrjurjyo48c.jpg
| true | false | true |
geekpi
| false |
[
"LXD",
"lxc"
] |
技术
|
{
"viewnum": 5481,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
最近，我对 lxc exec 进行了几个改进。如果你不知道它的话我介绍一下，lxc exec 是 LXD 的客户端工具，使用 LXD 客户端 api 与 LXD 守护程序通信，并执行用户想要执行的各种程序
| 2017-08-06T09:26:00 | 2017-08-06T09:26:00 | 8,755 |
/article-8755-1.html
|
最近，我对 `lxc exec` 进行了几个改进。如果你不知道它的话我介绍一下，`lxc exec` 是 [LXD](https://github.com/lxc/lxd) 的客户端工具，使用 [LXD](https://github.com/lxc/lxd) [客户端 api](https://github.com/lxc/lxd/blob/master/client.go) 与 LXD 守护程序通信，并执行用户想要执行的各种程序，以下是你可以使用的一个例子：
我们的主要目标之一就是使 `lxc exec` 与 `ssh` 类似，因为它是交互式或非交互式远程运行命令的标准。这使得 把 `lxc exec` 做得很好变得有点棘手。
### 1、 处理后台任务
一个长期存在的问题当然是如何正确处理后台任务。这是一个关于 [LXD](https://github.com/lxc/lxd) 2.7 实例的问题的例子：
你可以看到，在后台执行任务将导致 `lxc exec` 无法退出。许多命令可以触发此问题：
```
chb@conventiont|~
> lxc exec zest1 bash
root@zest1:~# yes &
y
y
y
.
.
.
```
现在没有什么能救你了。`yes` 将会永远直接写入`stdout`。
问题的根源在于 `stdout` 是一直打开着的，但这是必要的，因为它用以确保用户所启动的进程写入的任何数据实际上都是通过我们建立的 websocket 连接读取并发回的。
假如你想这样，运行一个 shell 会话，然后在后台运行一个进程，并马上退出 shell。对不起，它并不能如预期那样。
第一种并且原始的方法是一旦你检测到前台程序（例如 shell）已经退出就直接关闭 `stdout`。但这不像想得那么好，当你运行快速执行程序时，这个问题会变得明显，比如：
```
lxc exec -- ls -al /usr/lib
```
这里 `lxc exec` 进程（和相关的 `forkexec` 进程。但现在不要考虑它，只要记住 `Go` + `setns()` 不相往来就行了……）会在 `stdout` 中所有的*缓冲*数据被读取之前退出。这种情况下将会导致截断输出，没有人想要这样。在尝试使用几个方法来解决问题之后，包括禁用 pty 缓冲（我告诉你，这不太漂亮，也没有如预期工作。）和其他奇怪的思路，我设法通过几个 `poll()` “技巧”（在某种意义上说一个“技巧”）解决了这个问题。现在你终于可以运行后台任务，并且可以完全退出了。如图：
### 2、 报告由信号引起的退出码
`ssh` 是一个很棒的工具。但有一件事，我一直以来不喜欢当 ssh 运行的命令接收到一个信号时， `ssh` 总是会报告 `-1`，也就是退出码 `255`。当你想要了解导致程序终止的信号时，这很烦人。这就是为什么我最近实施标准 shell 所使用的惯例 `128 + n` 来报告任何由信号导致的退出，其中 `n` 被定义为导致执行程序退出的信号量。例如，在 `SIGKILL` 信号上，你会看到 `128 + SIGKILL = 137`（计算其他致命信号的退出码作为读者的练习）。所以你可以这么做：
```
chb@conventiont|~
> lxc exec zest1 sleep 100
```
现在，将 `SIGKILL` 发送到执行程序（不是 `lxc exec`本身，因为 `SIGKILL` 不可转发）。
```
kill -KILL $(pidof sleep 100)
```
最后检查你程序的退出码：
```
chb@conventiont|~
> echo $?
137
```
瞧。这显然只有当 a) 退出码没有超过 `8` 位计算壁垒，b）当执行程序不使用 `137` 来表示成功（这可真……有趣？！）。这两个论点似乎对我来说都不太有说服力。前者因为致命信号量不*应该*超过这个范围。后者因为（i）这是用户问题，（ii）这些退出代码实际上是保留的（我是*这样认为*。），（iii）你在本地或其他上面运行程序时会遇到同样的问题。
我看到的主要优点是这能够回报执行程序细粒度的退出状态。注意，我们不会报告*所有*被信号杀死的程序实例。比如说，当你的程序能够处理 `SIGTERM` 并且完全退出时，[LXD](https://github.com/lxc/lxd) 没有简单的方法来检测到这个情况并报告说这个程序被信号杀死了。你只会简单地收到退出码 `0`。
### 3、 转发信号
这可能不太有趣（或者也许不是，谁知道呢），但我发现它非常有用。正如你在 `SIGKILL` 案例中看到的那样，我明确地指出，必须将 `SIGKILL` 发送到执行程序，而不是 `lxc exec`命令本身。这是因为 `SIGKILL` 在程序中无法处理。程序可以做的唯一的事情就是去死，像现在这样……像这个例子……马上（你明白了了吧……）。但是程序可以处理很多其他信号 `SIGTERM`、`SIGHUP'，当然也可以处理`SIGUSR1`和`SIGUSR2`。因此，当你发送可以被`lxc exec` 处理而不是被执行程序处理的信号时，较新版本的 [LXD](https://github.com/lxc/lxd) 会将信号转发到执行进程。这在脚本中非常方便。
无论如何，我希望你觉得这篇小小的 `lxc exec` 文章/胡言乱语有用。享受 [LXD](https://github.com/lxc/lxd) 吧，这是与一只疯狂的美丽的野兽玩耍。请试试在线实验：<https://linuxcontainers.org/lxd/try-it/>，对于开发人员看看这里：<https://github.com/lxc/lxd> 并给我们补丁。
我们不要求签署任何 CLA，我们遵循内核风格，只要其中有 “Signed-off-by” 这行就好。
---
via: <https://cbrauner.wordpress.com/2017/01/20/lxc-exec-vs-ssh/>
作者：[brauner](https://cbrauner.wordpress.com) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
CoreOS 和 OCI 揭开了容器工业标准的论战
|
Jack M. Germain
|
http://www.linuxinsider.com/story/84689.html
|
CoreOS 和 开放容器联盟（OCI） 周三（2017 年 7 月 19 日）发布的镜像和运行时标准主要参照了 Docker 的镜像格式技术。然而，OCI 决定在 Docker 的事实标准平台上建立模型引发了一些问题。一些批评者提出其他方案。
|
/data/attachment/album/201708/06/112718wbk03mjap9tlisim.jpg.thumb.jpg
|
/data/attachment/album/201708/06/112718wbk03mjap9tlisim.jpg
| true | false | true |
LHRchina
| false |
[
"Docker",
"容器",
"OCI"
] |
观点
|
{
"viewnum": 5618,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "112.10.159.216",
"message": "<script>alert("xss")</script>",
"username": "来自浙江杭州的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-06T21:22:34"
},
{
"postip": "114.242.250.149",
"message": "想什么呢？",
"username": "linux [Chrome 59.0|Mac 10.11]",
"date": "2017-08-07T11:10:55"
},
{
"postip": "111.20.112.126",
"message": "容器需要一套像BASH那样的命令管理子集来自由演进。强本地化组件和能力比云靠谱",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-08T14:49:41"
}
] |
[] |
CoreOS 和 开放容器联盟（OCI） 周三（2017 年 7 月 19 日）发布的镜像和运行时标准主要参照了 Docker 的镜像格式技术。然而，OCI 决定在 Docker 的事实标准平台上建立模型引发了一些问题。一些批评者提出其他方案。
| 2017-08-06T11:27:16 | 2017-08-06T11:27:16 | 8,756 |
/article-8756-1.html
|
[CoreOS](https://coreos.com/) 和 [开放容器联盟（OCI）](https://www.opencontainers.org/) 周三（2017 年 7 月 19 日）发布的镜像和运行时标准主要参照了 Docker 的镜像格式技术。
然而，OCI 决定在 Docker 的事实标准平台上建立模型引发了一些问题。一些批评者提出其他方案。
CoreOS 的 CTO 及 OCI 技术管理委员会主席 Brandon Philips 说， 1.0版本为应用容器提供了一个稳定标准。他说，拥有产业领导者所创造的标准，应能激发 OCI 合作伙伴进一步地发展标准和创新。Philips 补充道，OCI 完成 1.0 版本意味着 OCI 运行时规范和 OCI 镜像格式标准现在已经可以广泛使用。此外，这一成就将推动 OCI 社区稳固日益增长的可互操作的可插拔工具集市场。
产业支持的标准将提供一种信心：容器已被广泛接受，并且 Kubernetes 用户将获得更进一步的支持。
Philips 告诉 LinuxInsider，结果是相当不错的，认证流程已经开始。
### 合作挑战
Philips 说，开放标准是容器生态系统取得成功的关键，构建标准的最好方式是与社区密切协作。然而，在 1.0 版本上达成共识所花费的时间超出了预期。
“早期，最大的挑战在于如今解决项目的发布模式及如何实施该项目”，他追述道，”每个人都低估了项目所要花费的时间。“
他说，OCI 联盟成员对他们想做的事情抱有不相匹配的预期，但是在过去的一年中，该组织了解了期望程度，并且经历了更多的测试。
### 追逐标准
CoreOS 官方在几年前就开始讨论行业支持的容器镜像和运行时规范的开放标准的想法，Phillips 说，早期的探索使我们认识到：在标准镜像格式上达成一致是至关重要的。
CoreOS 和容器技术创造者 [Docker](https://www.docker.com/) 在 2015 年 6 月宣布 OCI 成立。合作起始于 21 个行业领导者制定开放容器计划（OCP）。它作为一个非营利组织，旨在建立云存储软件容器的最低通用标准。
联盟包括容器业界的领导者：Docker、微软、红帽、IBM、谷歌和 Linux 基金会。
OCI 的目的是让应用开发者相信：当新的规范出来并开发出新的工具时，部署在容器上的软件仍然能够持续运行。这种信心必须同时满足所有私有和开源软件。
工具和应用是私有还是开源的并没有什么关系。当规范开始应用，产品可以被设计成与任何容器配置相适应，Philips 说。
“你需要有意识地超越编写代码的人能力之外创建标准。它是一个额外的付出。”他补充道。
作为联盟的一部分，Docker 向 OCP（开放容器计划）捐献出它的镜像格式的事实标准技术。它包括该公司的容器格式、运行时代码和规范。建立 OCI 镜像标准的工作起始于去年。
标准的里程碑给予容器使用者开发、打包、签名应用容器的能力。他们也能够在各种容器引擎上运行容器，Philips 强调。
### 唯一选择？
[Pund-IT](http://www.pund-it.com/) 的首席分析师 Charles King 表示：联盟面临着两种实现标准的方式。第一种选择是汇集相同意向的人员来避免分歧从零开始建立标准。
但是联盟成员似乎满足于第二种方案：采用一种强大的市场领先的平台作为一个有效的标准。
“Docker 对 [Linux 基金会](http://www.linuxfoundation.org/)的贡献使 OCI 坚定的选择了第二种方案。但是那些关注于 Docker 的做法和它的市场地位的人也许感觉应该有更好的选择。”King 对 LinuxInsider 说。
事实上，有个 OCI 成员 CoreOS 在开始的时候对该组织的总体方向进行了一些强烈的批评。他说，“所以看看 V1.0 版本是否处理或不处理那些关注点将是很有趣的事情。”
### 更快之路
Docker 已经被广泛部署的运行时实现是建立开放标准的合适基础。据 [Cloud Technology Partners](https://www.cloudtp.com/) 的高级副总裁 David Linthicum 所说，Docker 已经是一个事实标准。
“我们能很快就让它们工作起来也是很重要的。但是一次次的标准会议、处理政治因素以及诸如此类的事情只是浪费时间” 。他告诉 LinuxInsider。
但是现在没有更好的选择，他补充道。
据 RedHat 公司的 Linux 容器技术高级布道者 Joe Brockmeier 所说，Docker 的运行时是 runC 。它是 OCI 运行时标准的一种实现。
“因此，runC 是一个合适的运行时标准的基础。它被广泛的接受并成为了大多数容器技术实现的基础。他说。
OCI 是比 Docker 更进一步的标准。尽管 Docker 确实提交了遵循 OCI 规范的底层代码，然而这一系列代码就此停止，并且没真正的可行替代方案存在。
### 对接问题
Pund-IT 的 King 建议：采用一种广泛使用的产业标准将简化和加速许多公司对容器技术的采纳和管理。也有可能一些关键的供应商将继续关注他们自己的专有容器技术。
“他们辩称他们的做法是一个更好的方式，但这将有效的阻止 OCI 取得市场的主导地位。”他说，“从一个大体上实现的标准开始，就像 OCI 所做的那样，也许并不能完美的使所有人满意，但是这也许能比其他方案更加快速有效的实现目标。”
容器已经标准化的部署到了云上，Docker 显然是领先的。[Semaphore](http://www.semaphoreci.com/) 联合创始人 Marko Anastasov 说。
他说，Docker 事实标准的容器代表了开发开放标准的的最佳基础。Docker 的商业利益将如何影响其参与 OCI 的规模还有待观察。
### 反对观点
开放标准并不是在云部署中采用更多的容器的最终目标。[ThoughtWorks](https://www.thoughtworks.com/) 的首席顾问 Nic Cheneweth 表示。更好的的方法是查看 IT 行业的服务器虚拟化部分的影响。
Cheneweth 对 LinuxInsider 说：“持续增长和广泛采用的主要动力不是在行业标准的声明中，而是通过使用任何竞争技术所获得的潜在的和实现的效率，比如 VMware、Xen 等。”
容器技术的某些方面，例如容器本身，可以根据标准来定义。他说，在此之前，深入开源软件参与引导的健康竞争将有助于成为一个更好的标准。
据 Cheneweth 说，容器编排标准对该领域的持续增长并不特别重要。
不过，他表示，如果行业坚持锁定容器事实标准，那么 OCI 所选择的模型是一个很好的起点。“我不知道是否有更好的选择，但肯定这不是最糟糕的选择。”
作者简介：
自 2003 年以来，Jack M.Germain一直是一个新闻网络记者。他主要关注的领域是企业 IT、Linux 和开源技术。他已经写了很多关于 Linux 发行版和其他开源软件的评论。
---
via: <http://www.linuxinsider.com/story/84689.html>
作者：[Jack M. Germain](jack.germain@newsroom.ectnews.comm) 译者：[LHRchina](https://github.com/LHRchina) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
文件系统层次标准（FHS）简介
|
Jonathan Terrasi
|
http://www.linuxinsider.com/story/84658.html
|
当你好奇地看着系统的根目录（/）的时候，可能会发现自己有点不知所措。大多数三个字母的目录名称并没有告诉你它们是做什么的，如果你需要做出一些重要的修改，那就很难知道在哪里可以查看。
|
/data/attachment/album/201708/07/181940upuau3d3uj5mj35u.png.thumb.jpg
|
/data/attachment/album/201708/07/181940upuau3d3uj5mj35u.png
| true | false | true |
firmianay
| false |
[
"FHS",
"目录"
] |
技术
|
{
"viewnum": 15166,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8887,
"displayorder": 0
}
] |
当你好奇地看着系统的根目录（/）的时候，可能会发现自己有点不知所措。大多数三个字母的目录名称并没有告诉你它们是做什么的，如果你需要做出一些重要的修改，那就很难知道在哪里可以查看。
| 2017-08-07T18:20:13 | 2017-08-07T18:20:13 | 8,757 |
/article-8757-1.html
|
当你好奇地看着系统的根目录（`/`）的时候，可能会发现自己有点不知所措。大多数三个字母的目录名称并没有告诉你它们是做什么的，如果你需要做出一些重要的修改，那就很难知道在哪里可以查看。
我想给那些没有深入了解过自己的根目录的人简单地介绍下它。
### 有用的工具
在我们开始之前，这里有几个需要熟悉的工具，它们可以让您随时挖掘那些您自己找到的有趣的东西。这些程序都不会对您的文件进行任何更改。
最有用的工具是 `ls` -- 它列出了使用完整路径或相对路径（即从当前目录开始的路径）作为参数给出的任何目录的内容。
```
$ ls 路径
```
当您进一步深入文件系统时，重复输入长路径可能会变得很麻烦，所以如果您想简化这一操作，可以用 `cd` 替换 `ls` 来更改当前的工作目录到该目录。与 `ls` 一样，只需将目录路径作为 `cd` 的参数。
```
$ cd 路径
```
如果您不确定某个文件是什么文件类型的，可以通过运行 `file` 并且将文件名作为 `file` 命令的参数。
```
$ file 文件名
```
最后，如果这个文件看起来像是适宜阅读的，那么用 `less` 来看看（不用担心文件有改变）。与最后一个工具一样，给出一个文件名作为参数来查看它。
```
$ less 文件名
```
完成文件翻阅后，点击 `q` 键退出，即可返回到您的终端。
### 根目录之旅
现在就开始我们的旅程。我将按照字母顺序介绍直接放在根目录下的目录。这里并没有介绍所有的目录，但到最后，我们会突出其中的亮点。
我们所有要遍历的目录的分类及功能都基于 Linux 的文件系统层次标准（FHS）。[Linux 基金会](http://www.linuxfoundation.org/)维护的 Linux FHS 帮助发行版和程序的设计者和开发人员来规划他们的工具的各个组件应该存放的位置。
通过将各个程序的所有文件、二进制文件和帮助手册保存在一致的组织结构中，FHS 让对它们的学习、调试或修改更加容易。想象一下，如果不是使用 `man` 命令找到使用指南，那么你就得对每个程序分别寻找其手册。
按照字母顺序和结构顺序，我们从 `/bin` 开始。该目录是存放所有核心系统二进制文件的地方，其包含的命令可以在 shell （解释终端指令的程序）中使用。没有这个目录的内容，你的系统就基本没法使用。
接下来是 `/boot` 目录，它存储了您的计算机启动所需的所有东西。其中最重要的是引导程序和内核。引导程序是一个通过初始化一些基础工具，使引导过程得以继续的程序。在初始化结束时，引导程序会加载内核，内核允许计算机与所有其它硬件和固件进行接口。从这一点看，它可以使整个操作系统工作起来。
`/dev` 目录用于存储类似文件的对象来表示被系统识别为“设备”的各种东西。这里包括许多显式的设备，如计算机的硬件组件：键盘、屏幕、硬盘驱动器等。
此外，`/dev` 还包含被系统视为“设备”的数据流的伪文件。一个例子是流入和流出您的终端的数据，可以分为三个“流”。它读取的信息被称为“标准输入”。命令或进程的输出是“标准输出”。最后，被分类为调试信息的辅助性输出指向到“标准错误”。终端本身作为文件也可以在这里找到。
`/etc`（发音类似工艺商业网站 “Etsy”，如果你想让 Linux 老用户惊艳一下的话，囧），许多程序在这里存储它们的配置文件，用于改变它们的设置。一些程序存储这里的是默认配置的副本，这些副本将在修改之前复制到另一个位置。其它的程序在这里存储配置的唯一副本，并期望用户可以直接修改。为 root 用户保留的许多程序常用一种配置模式。
`/home` 目录是用户个人文件所在的位置。对于桌面用户来说，这是您花费大部分时间的地方。对于每个非特权用户，这里都有一个具有相应名称的目录。
`/lib` 是您的系统赖以运行的许多库的所在地。许多程序都会重复使用一个或多个功能或子程序，它们经常会出现在几十上百个程序中。所以，如果每个程序在其二进制文件中重复写它需要的每一个组件，结果会是产生出一些大而无当的程序，作为更好的替代方案，我们可以通过进行“库调用”来引用这些库中的一个或多个。
在 `/media` 目录中可以访问像 USB 闪存驱动器或摄像机这样的可移动媒体。虽然它并不是所有系统上都有，但在一些专注于直观的桌面系统中还是比较普遍的，如 Ubuntu。具有存储能力的媒体在此处被“挂载”，这意味着当设备中的原始位流位于 `/dev` 目录下时，用户通常可以在这里访问那些可交互的文件对象。
`/proc` 目录是一个动态显示系统数据的虚拟文件系统。这意味着系统可以即时地创建 `/proc` 的内容，用包含运行时生成的系统信息（如硬件统计信息）的文件进行填充。
`/tmp` 正如其名字，用于放置缓存数据等临时信息。这个目录不做其他更多的事情。
现代 Linux 系统上大多数程序的二进制文件保存在 `/usr` 目录中。为了统一包含二进制文件的各种目录，`/usr` 包含 `/bin`、`/sbin` 和 `/lib` 中的所有内容的副本。
最后，`/var` 里保存“<ruby> 可变 <rt> variable </rt></ruby>”长度的数据。这里的可变长度数据的类型通常是会累积的数据，就像日志和缓存一样。一个例子是你的内核保留的日志。
为了避免硬盘空间用尽和崩溃的情况，`/var` 内置了“日志旋转”功能，可删除旧信息，为新信息腾出空间，维持固定的最大大小。
### 结尾
正如我所说，这里介绍的绝对不是您在根目录中可以找到的一切，但是确定系统核心功能所在地是一个很好的开始，而且可以更深入地研究这些功能是什么。
所以，如果你不知道要学习什么，就可能有很多的想法。如果你想得到一个更好的想法，就在这些目录中折腾自己吧！
---
作者简介：
自 2017 年以来 Jonathan Terrasi 一直是 ECT 新闻网的专栏作家。他的主要兴趣是计算机安全（特别是 Linux 桌面），加密和分析政治和时事。他是全职自由作家和音乐家。他的背景包括在芝加哥委员会发表的保卫人权法案文章中提供技术评论和分析。
---
via: <http://www.linuxinsider.com/story/84658.html>
作者：[Jonathan Terrasi](http://www.linuxinsider.com/perl/mailit/?id=84658) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Azure 中部署 Kubernetes 容器集群
|
Neilpeterson，mmacy
|
https://docs.microsoft.com/en-us/azure/container-service/kubernetes/container-service-kubernetes-walkthrough
|
在这个快速入门教程中，我们使用 Azure CLI 创建一个 Kubernetes 集群，然后在集群上部署运行由 Web 前端和 Redis 实例组成的多容器应用程序。一旦部署完成，应用程序可以通过互联网访问。
|
/data/attachment/album/201708/07/212710ujddonvcwyj459zw.jpg.thumb.jpg
|
/data/attachment/album/201708/07/212710ujddonvcwyj459zw.jpg
| true | false | true |
rieonke
| false |
[
"Kubernetes",
"Azure"
] |
系统运维
|
{
"viewnum": 6622,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8779,
"displayorder": 0
}
] |
在这个快速入门教程中，我们使用 Azure CLI 创建一个 Kubernetes 集群，然后在集群上部署运行由 Web 前端和 Redis 实例组成的多容器应用程序。一旦部署完成，应用程序可以通过互联网访问。
| 2017-08-07T21:27:53 | 2017-08-07T21:27:53 | 8,758 |
/article-8758-1.html
|
在这个快速入门教程中，我们使用 Azure CLI 创建一个 Kubernetes 集群，然后在集群上部署运行由 Web 前端和 Redis 实例组成的多容器应用程序。一旦部署完成，应用程序可以通过互联网访问。
这个快速入门教程假设你已经基本了解了 Kubernetes 的概念，有关 Kubernetes 的详细信息，请参阅 [Kubernetes 文档](https://kubernetes.io/docs/home/)。
如果您没有 Azure 账号，请在开始之前创建一个[免费帐户](https://azure.microsoft.com/free/?WT.mc_id=A261C142F)。
### 登录 Azure 云控制台
Azure 云控制台是一个免费的 Bash shell，你可以直接在 Azure 网站上运行。它已经在你的账户中预先配置好了， 单击 [Azure 门户](https://portal.azure.com/)右上角菜单上的 “Cloud Shell” 按钮；
[](https://portal.azure.com/)
该按钮会启动一个交互式 shell，您可以使用它来运行本教程中的所有操作步骤。
[](https://portal.azure.com/)
此快速入门教程所用的 Azure CLI 的版本最低要求为 2.0.4。如果您选择在本地安装和使用 CLI 工具，请运行 `az --version` 来检查已安装的版本。 如果您需要安装或升级请参阅[安装 Azure CLI 2.0](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli) 。
### 创建一个资源组
使用 [az group create](https://docs.microsoft.com/en-us/cli/azure/group#create) 命令创建一个资源组，一个 Azure 资源组是指 Azure 资源部署和管理的逻辑组。
以下示例在 *eastus* 区域中创建名为 *myResourceGroup* 的资源组。
```
az group create --name myResourceGroup --location eastus
```
输出：
```
{
"id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup",
"location": "eastus",
"managedBy": null,
"name": "myResourceGroup",
"properties": {
"provisioningState": "Succeeded"
},
"tags": null
}
```
### 创建一个 Kubernetes 集群
使用 [az acs create](https://docs.microsoft.com/en-us/cli/azure/acs#create) 命令在 Azure 容器服务中创建 Kubernetes 集群。 以下示例使用一个 Linux 主节点和三个 Linux 代理节点创建一个名为 *myK8sCluster* 的集群。
```
az acs create --orchestrator-type=kubernetes --resource-group myResourceGroup --name=myK8sCluster --generate-ssh-keys
```
几分钟后，命令将完成并返回有关该集群的 json 格式的信息。
### 连接到 Kubernetes 集群
要管理 Kubernetes 群集，可以使用 Kubernetes 命令行工具 [kubectl](https://kubernetes.io/docs/user-guide/kubectl/)。
如果您使用 Azure CloudShell ，则已经安装了 kubectl 。如果要在本地安装，可以使用 [az acs kubernetes install-cli](https://docs.microsoft.com/en-us/cli/azure/acs/kubernetes#install-cli) 命令。
要配置 kubectl 连接到您的 Kubernetes 群集，请运行 [az acs kubernetes get-credentials](https://docs.microsoft.com/en-us/cli/azure/acs/kubernetes#get-credentials) 命令下载凭据并配置 Kubernetes CLI 以使用它们。
```
az acs kubernetes get-credentials --resource-group=myResourceGroup --name=myK8sCluster
```
要验证与集群的连接，请使用 [kubectl get](https://kubernetes.io/docs/user-guide/kubectl/v1.6/#get) 命令查看集群节点的列表。
```
kubectl get nodes
```
输出：
```
NAME STATUS AGE VERSION
k8s-agent-14ad53a1-0 Ready 10m v1.6.6
k8s-agent-14ad53a1-1 Ready 10m v1.6.6
k8s-agent-14ad53a1-2 Ready 10m v1.6.6
k8s-master-14ad53a1-0 Ready,SchedulingDisabled 10m v1.6.6
```
### 运行应用程序
Kubernetes 清单文件为集群定义了一个所需的状态，包括了集群中应该运行什么样的容器镜像。 对于此示例，清单用于创建运行 Azure Vote 应用程序所需的所有对象。
创建一个名为 `azure-vote.yaml` ，将下面的内容拷贝到 YAML 中。
```
apiVersion: apps/v1beta1
kind: Deployment
metadata:
name: azure-vote-back
spec:
replicas: 1
template:
metadata:
labels:
app: azure-vote-back
spec:
containers:
- name: azure-vote-back
image: redis
ports:
- containerPort: 6379
name: redis
---
apiVersion: v1
kind: Service
metadata:
name: azure-vote-back
spec:
ports:
- port: 6379
selector:
app: azure-vote-back
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
name: azure-vote-front
spec:
replicas: 1
template:
metadata:
labels:
app: azure-vote-front
spec:
containers:
- name: azure-vote-front
image: microsoft/azure-vote-front:redis-v1
ports:
- containerPort: 80
env:
- name: REDIS
value: "azure-vote-back"
---
apiVersion: v1
kind: Service
metadata:
name: azure-vote-front
spec:
type: LoadBalancer
ports:
- port: 80
selector:
app: azure-vote-front
```
使用 [kubectl create](https://kubernetes.io/docs/user-guide/kubectl/v1.6/#create) 命令来运行该应用程序。
```
kubectl create -f azure-vote.yaml
```
输出：
```
deployment "azure-vote-back" created
service "azure-vote-back" created
deployment "azure-vote-front" created
service "azure-vote-front" created
```
### 测试应用程序
当应用程序的跑起来之后，需要创建一个 [Kubernetes 服务](https://kubernetes.io/docs/concepts/services-networking/service/)，将应用程序前端暴露在互联网上。 此过程可能需要几分钟才能完成。
要监控这个进程，使用 [kubectl get service](https://kubernetes.io/docs/user-guide/kubectl/v1.6/#get) 命令时加上 `--watch` 参数。
```
kubectl get service azure-vote-front --watch
```
最初，*azure-vote-front* 服务的 EXTERNAL-IP 显示为 *pending* 。 一旦 EXTERNAL-IP 地址从 *pending* 变成一个具体的 IP 地址，请使用 “CTRL-C” 来停止 kubectl 监视进程。
```
azure-vote-front 10.0.34.242 <pending> 80:30676/TCP 7s
azure-vote-front 10.0.34.242 52.179.23.131 80:30676/TCP 2m
```
现在你可以通过这个外网 IP 地址访问到 Azure Vote 这个应用了。
### 删除集群
当不再需要集群时，可以使用 [az group delete](https://docs.microsoft.com/en-us/cli/azure/group#delete) 命令删除资源组，容器服务和所有相关资源。
```
az group delete --name myResourceGroup --yes --no-wait
```
### 获取示例代码
在这个快速入门教程中，预先创建的容器镜像已被用于部署 Kubernetes 。相关应用程序代码 Dockerfile 和 Kubernetes 清单文件可在 GitHub 中获得。Github 仓库地址是 [https://github.com/Azure-Samples/azure-voting-app-redis](https://github.com/Azure-Samples/azure-voting-app-redis.git)
### 下一步
在这个快速入门教程中，您部署了一个 Kubernetes 集群，并部署了一个多容器应用程序。
要了解有关 Azure 容器服务的更多信息，走完一个完整的从代码到部署的全流程，请继续阅读 Kubernetes 集群教程。
---
via: <https://docs.microsoft.com/en-us/azure/container-service/kubernetes/container-service-kubernetes-walkthrough>
作者：[neilpeterson](https://github.com/neilpeterson)，[mmacy](https://github.com/mmacy) 译者：[rieonke](https://github.com/rieonke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Ubuntu 16.04 Server 上安装 Zabbix
|
Giuseppe Molica
|
https://www.unixmen.com/monitoring-server-install-zabbix-ubuntu-16-04/
|
Zabbix 是企业级开源分布式监控服务器解决方案。该软件能监控网络的不同参数以及服务器的完整性，还允许为任何事件配置基于电子邮件的警报。Zabbix 根据存储在数据库（例如 MySQL）中的数据提供报告和数据可视化功能。软件收集的每个测量指标都可以通过基于 Web 的界面访问。
|
/data/attachment/album/201708/08/184554jpycmmmppx1jzjx4.jpg.thumb.jpg
|
/data/attachment/album/201708/08/184554jpycmmmppx1jzjx4.jpg
| true | false | true |
geekpi
| false |
[
"监控",
"Zabbix"
] |
系统运维
|
{
"viewnum": 43286,
"commentnum": 2,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "180.168.134.180",
"message": "非常给力。赞一个",
"username": "来自上海的 Chrome 73.0|Mac 10.14 用户",
"date": "2019-04-02T09:49:43"
},
{
"postip": "111.163.147.229",
"message": "很不错啊",
"username": "linux狂热学者 [Firefox 68.0|Windows 10]",
"date": "2019-08-13T22:46:38"
}
] |
[] |
Zabbix 是企业级开源分布式监控服务器解决方案。该软件能监控网络的不同参数以及服务器的完整性，还允许为任何事件配置基于电子邮件的警报。Zabbix 根据存储在数据库（例如 MySQL）中的数据提供报告和数据可视化功能。软件收集的每个测量指标都可以通过基于 Web 的界面访问。
| 2017-08-08T18:45:00 | 2017-08-08T18:45:00 | 8,760 |
/article-8760-1.html
|
### 监控服务器 - 什么是 Zabbix
[Zabbix](http://www.zabbix.com/) 是企业级开源分布式监控服务器解决方案。该软件能监控网络的不同参数以及服务器的完整性，还允许为任何事件配置基于电子邮件的警报。Zabbix 根据存储在数据库（例如 MySQL）中的数据提供报告和数据可视化功能。软件收集的每个测量指标都可以通过基于 Web 的界面访问。
Zabbix 根据 GNU 通用公共许可证版本 2（GPLv2）的条款发布，完全免费。
在本教程中，我们将在运行 MySQL、Apache 和 PHP 的 Ubuntu 16.04 server 上安装 Zabbix。
### 安装 Zabbix 服务器
首先，我们需要安装 Zabbix 所需的几个 PHP 模块：
```
# apt-get install php7.0-bcmath php7.0-xml php7.0-mbstring
```
Ubuntu 仓库中提供的 Zabbix 软件包已经过时了。使用官方 Zabbix 仓库安装最新的稳定版本。
通过执行以下命令来安装仓库软件包：
```
$ wget http://repo.zabbix.com/zabbix/3.2/ubuntu/pool/main/z/zabbix-release/zabbix-release_3.2-1+xenial_all.deb
# dpkg -i zabbix-release_3.2-1+xenial_all.deb
```
然后更新 `apt` 包源：
```
# apt-get update
```
现在可以安装带有 MySQL 支持和 PHP 前端的 Zabbix 服务器。执行命令：
```
# apt-get install zabbix-server-mysql zabbix-frontend-php
```
安装 Zabbix 代理：
```
# apt-get install zabbix-agent
```
Zabbix 现已安装。下一步是配置数据库来存储数据。
### 为 Zabbix 配置 MySQL
我们需要创建一个新的 MySQL 数据库，Zabbix 将用来存储收集的数据。
启动 MySQL shell：
```
$ mysql -uroot -p
```
接下来：
```
mysql> CREATE DATABASE zabbix CHARACTER SET utf8 COLLATE utf8_bin;
Query OK, 1 row affected (0.00 sec)
mysql> GRANT ALL PRIVILEGES ON zabbix.* TO zabbix@localhost IDENTIFIED BY 'usr_strong_pwd';
Query OK, 0 rows affected, 1 warning (0.00 sec)
mysql> EXIT;
Bye
```
接下来，导入初始表和数据。
```
# zcat /usr/share/doc/zabbix-server-mysql/create.sql.gz | mysql -uzabbix -p zabbix
```
输入在 MySQL shell 中创建的 **zabbix** 用户的密码。
接下来，我们需要编辑 Zabbix 服务器配置文件，它是 `/etc/zabbix/zabbis_server.conf`：
```
# $EDITOR /etc/zabbix/zabbix_server.conf
```
搜索文件的 `DBPassword` 部分：
```
### Option: DBPassword
# Database password. Ignored for SQLite.
# Comment this line if no password is used.
#
# Mandatory: no
# Default:
# DBPassword=
```
取消注释 `DBPassword=` 这行，并添加在 MySQL 中创建的密码：
```
DBPassword=usr_strong_pwd
```
接下来，查找 `DBHost=` 这行并取消注释。
保存并退出。
### 配置 PHP
我们需要配置 PHP 来使用 Zabbix。在安装过程中，安装程序在 `/etc/zabbix` 中创建了一个名为 `apache.conf` 的配置文件。打开此文件：
```
# $EDITOR /etc/zabbix/apache.conf
```
此时，只需要取消注释 `date.timezone` 并设置正确的时区：
```
<IfModule mod_php7.c>
php_value max_execution_time 300
php_value memory_limit 128M
php_value post_max_size 16M
php_value upload_max_filesize 2M
php_value max_input_time 300
php_value always_populate_raw_post_data -1
php_value date.timezone Europe/Rome
</IfModule>
```
保存并退出。
此时，重启 Apache 并启动 Zabbix Server 服务，使其能够在开机时启动：
```
# systemctl restart apache2
# systemctl start zabbix-server
# systemctl enable zabbix-server
```
用 `systemctl` 检查 Zabbix 状态：
```
# systemctl status zabbix-server
```
这个命令应该输出：
```
â zabbix-server.service - Zabbix Server
Loaded: loaded (/lib/systemd/system/zabbix-server.service; enabled; vendor pr
Active: active (running) ...
```
此时，Zabbix 的服务器端已经正确安装和配置了。
### 配置 Zabbix Web 前端
如介绍中所述，Zabbix 有一个基于 Web 的前端，我们将用于可视化收集的数据。但是，必须配置此接口。
使用 Web 浏览器，进入 URL `http://localhost/zabbix`。
点击 **Next step**
确保所有的值都是 **Ok**，然后再次单击 **Next step** 。
输入 MySQL **zabbix** 的用户密码，然后点击 **Next step**。
单击 **Next step** ，安装程序将显示具有所有配置参数的页面。再次检查以确保一切正确。
点击 **Next step** 进入最后一页。
点击完成以完成前端安装。默认用户名为 **Admin**，密码是 **zabbix**。
### Zabbix 服务器入门
使用上述凭证登录后，我们将看到 Zabbix 面板：
前往 **Administration -> Users**，了解已启用帐户的概况：
通过点击 **Create user** 创建一个新帐户。
点击 **Groups** 中的 **Add**，然后选择一个组：
保存新用户凭证，它将显示在 **Administration -> Users** 面板中。
**请注意，在 Zabbix 中，主机的访问权限分配给用户组，而不是单个用户。**
### 总结
我们结束了 Zabbix Server 安装的教程。现在，监控基础设施已准备好完成其工作并收集有关需要在 Zabbix 配置中添加的服务器的数据。
---
via: <https://www.unixmen.com/monitoring-server-install-zabbix-ubuntu-16-04/>
作者：[Giuseppe Molica](https://www.unixmen.com/author/tutan/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GNU GPL 许可证常见问题解答（一）
|
Fsf
|
https://www.gnu.org/licenses/gpl-faq.html
|
这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
|
/data/attachment/album/201708/08/193234rwwwzi3hphww1wd4.png.thumb.jpg
|
/data/attachment/album/201708/08/193234rwwwzi3hphww1wd4.png
| true | false | true |
薛亮
| true |
[
"GPL",
"GNU",
"许可证"
] |
开源智慧
|
{
"viewnum": 11319,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "117.182.155.143",
"message": "在天朝，用GPL是打不赢官司的",
"username": "来自117.182.155.143的 Chrome 60.0|Windows 7 用户",
"date": "2017-08-08T20:15:29"
},
{
"postip": "218.58.78.203",
"message": "那个“不完整列表”的链接错了。应该是 https://www.gnu.org/licenses/license-list",
"username": "绿色圣光 [Firefox 54.0|GNU/Linux]",
"date": "2017-09-05T14:53:17"
},
{
"postip": "61.186.23.37",
"message": "谢谢，原来后面多了个空格。。。",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-09-05T15:59:03"
}
] |
[
{
"raid": 8834,
"displayorder": 0
}
] |
这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
| 2017-08-08T19:34:00 | 2017-08-08T19:34:00 | 8,761 |
/article-8761-1.html
|
本文由高级咨询师薛亮据自由软件基金会（FSF）的[英文原文](https://www.gnu.org/licenses/gpl-faq.html)翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
1. 关于 GNU 项目、自由软件基金会（FSF）及其许可证的基本问题
2. 对于 GNU 许可证的一般了解
3. 在您的程序中使用 GNU 许可证
4. 依据 GNU 许可证分发程序
5. 在编写其他程序时采用依据 GNU 许可证发布的程序
6. 将作品与依据 GNU 许可证发布的代码相结合
7. 关于违反 GNU 许可证的问题
### 1、关于 GNU 项目、自由软件基金会（FSF）及其许可证的基本问题
#### 1.1 “GPL” 代表什么意思？
“GPL” 代表“<ruby> 通用公共许可证 <rp> （ </rp> <rt> General Public License </rt> <rp> ） </rp></ruby>”。 最常见的此类许可证是 GNU 通用公共许可证，简称 GNU GPL。 如果人们能够自然而然地将其理解为 GNU GPL，可以进一步缩短为“GPL”。
#### 1.2 自由软件是否意味着必须使用 GPL？
根本不是的，还有许多其他自由软件许可证。我们有一个[不完整的列表](https://www.gnu.org/licenses/license-list.html)。任何为用户提供特定自由的许可证都是自由软件许可证。
#### 1.3 为什么我要使用 GNU GPL，而不是其他自由软件许可证？
使用 GNU GPL 将要求所有发布的改进版本都是自由软件。这意味着您可以避免与您自己作品的专有修改版本进行竞争的风险。不过，在某些特殊情况下，最好使用一个更宽松的许可证。
#### 1.4 所有 GNU 软件都使用 GNU GPL 作为其许可证吗？
大多数 GNU 软件包都使用 GNU GPL，但是有一些 GNU 程序（以及程序的一部分）使用更宽松的许可证，例如 LGPL（<ruby> 较宽松公共许可证 <rp> （ </rp> <rt> Lesser GPL </rt> <rp> ） </rp></ruby>）。我们这样做是基于战略考虑。
#### 1.5 如果一个程序使用 GPL 许可证，是否会使其成为 GNU 软件？
任何人都可以依据 GNU GPL 发布一个程序，但并不能使其成为 GNU 软件包。
让程序成为 GNU 软件包意味着将其明确地贡献给 GNU 项目。当程序的开发人员和 GNU 项目都同意这样做时，才会发生这种情况。如果您有兴趣向 GNU 项目贡献程序，请写信至 <maintainers@gnu.org> 。
#### 1.6 我可以将 GPL 应用于软件以外的其他作品吗？
您可以将 GPL 应用于任何类型的作品，只需明确该作品的“源代码”构成即可。 GPL 将“源代码”定义为作品的首选形式，以便在其中进行修改。
不过，对于手册和教科书，或更一般地，任何旨在教授某个主题的作品，我们建议使用 GFDL，而非 GPL。
#### 1.7 手册为什么不使用 GPL 许可证？
手册也可以使用 GPL 许可证，但对于手册来说，最好使用 GFDL（<ruby> 自由文本授权 <rp> （ </rp> <rt> GNU Free Documentation License </rt> <rp> ） </rp></ruby>）许可证。
GPL 是为软件程序设计的，它包含许多复杂的条款，对于程序来说至关重要；但对于图书或手册来说，这将是麻烦和不必要的。例如，任何人如果（以 GPL ）出版纸质图书，就要么必须为每份印刷版本配置该图书的机器可读形式“源代码”，或提供书面文件，表明将稍后发送“源代码”。
同时，GFDL 中包含了帮助免费手册的出版商从销售副本中获利的条款，例如，出售封面文字。<ruby> 背书 <rp> （ </rp> <rt> Endorsements </rt> <rp> ） </rp></ruby>部分的特殊规则使得 GFDL 可以作为官方标准。修改版本的手册是被允许的，但该修改版本不能被标记为“该标准”。
使用 GFDL，我们允许对手册中涵盖其技术主题的文本进行修改。能够修改技术部分非常重要，因为修改程序的人理所当然地要去修改对应的文档。人们有这样做的自由，它是一种道德责任。我们的手册还包括阐述我们对自由软件政治立场的部分。我们将它们标记为<ruby> “不变量” <rp> （ </rp> <rt> invariant </rt> <rp> ） </rp></ruby>，使得它们不被更改或删除。 GFDL 中也为这些“不变部分”做出了规定。
#### 1.8 GPL 被翻译成其他语言了吗？
将 GPL 翻译成英文以外的语言将是有用的。人们甚至进行了翻译，并将文本发送给我们。但我们不敢将翻译文本批准为正式有效。其中的风险如此之大，以至于我们不敢接受。
法律文件在某种程度上就像一个程序。翻译它就像将程序从一种语言和操作系统转换到另一种语言。只有同时熟练使用这两种语言的律师才能做到这一点——即便如此，也有引入错误的风险。
如果我们正式批准 GPL 的翻译文本，我们将不得不给予所有人许可，让他们可以去做翻译文本规定可以做的任何事情。如果这是一个完全准确的翻译，那没关系。但如果翻译错误，后果可能是我们无法解决的灾难。
如果一个程序有 bug，我们可以发布一个新的版本，最终旧版本将会逐渐消失。但是，一旦我们给予每个人去根据特定翻译文本行事的许可，如果我们稍后发现它有一个错误，我们无法收回该权限。
乐意提供帮助的人有时会为我们做翻译工作。如果问题是要找人做这个工作的话，那问题就解决了。但实际的问题是错误的风险，做翻译工作不能避免风险。我们无法授权非律师撰写的翻译文本。
因此，目前我们并不认可GPL的翻译文本是全球有效和具有约束力的。相反，我们正在做两件事情：
* 将非正式的翻译指引给人们。这意味着我们允许人们进行GPL的翻译，但是我们不认可翻译文本具有法律效力和约束力。
未经批准的翻译文本没有法律效力，应该如此明确地表述。翻译文本应标明如下：
> This translation of the GPL is informal, and not officially approved by the Free Software Foundation as valid. To be completely sure of what is permitted, refer to the original GPL (in English).
> 本 GPL 翻译文本是非正式的，没有被自由软件基金会（FSF）正式批准为有效。若要完全确定何种行为被允许，请参阅原始 GPL（英文）。
但未经批准的翻译文本可以作为如何理解英文 GPL 的参考。对于许多用户来说，这就足够了。不过，在商业活动中使用 GNU 软件的企业，以及进行公共 ftp 发行的人员，需要去核查实际的英文 GPL，以明确其允许的行为。
* 发布仅在单个国家/地区有效的翻译文本。
我们正在考虑发布仅在单个国家正式生效的翻译文本。这样一来，如果发现有错误，那么错误将局限于这个国家，破坏力不会太大。
即便是一个富有同情心和能力的律师来做翻译，仍然需要相当多的专门知识和努力，所以我们不能很快答应任何这样的翻译。
#### 1.9 为什么有一些 GNU 库依据普通 GPL 而不是 LGPL 来发布？
对于任何特定库使用 LGPL 构成了自由软件的倒退。这意味着我们部分放弃了捍卫用户自由权利的努力，对基于 GPL 软件所构建产品的分享要求也降低了。在它们自身而言，这是更糟糕的变化。
有时一个小范围的倒退是很好的策略。某种情况下，使用 LGPL 的库可能会带来该库的广泛使用，从而进一步改善该库，为自由软件带来更广泛的支持，诸如此类。如果在相当大的程度上出现这种情况，这可能对自由软件很有好处。但它发生的几率有多少呢？我们只能推测。
在每个库上用一段时间的 LGPL，看看它是否有帮助，如果 LGPL 没有帮助，再将其更改为 GPL。这种做法听起来很好，但却是不可行的。一旦我们对特定库使用了 LGPL，那就很难进行改变。因此，我们根据具体情况决定每个库使用哪个许可证。对于我们如何判断该问题，有一段[很长的解释](https://www.gnu.org/licenses/why-not-lgpl.html)。
#### 1.10 谁有权力执行 GPL 许可证？
由于 GPL 是版权许可，软件的版权所有者将是有权执行 GPL 的人。如果您发现违反 GPL 的行为，您应该向遵循GPL的该软件的开发人员通报。他们是版权所有者，或与版权所有者有关。若要详细了解如何报告 GPL 违规，请参阅“[如果发现了可能违反 GPL 许可证的行为，我该怎么办？](https://www.gnu.org/licenses/gpl-faq.html#ReportingViolation)”
#### 1.11 为什么 FSF 要求为 FSF 拥有版权的程序做出贡献的贡献者将版权<ruby> 分配 <rp> （ </rp> <rt> assign </rt> <rp> ） </rp></ruby>给 FSF？如果我持有 GPL 程序的版权，我也应该这样做吗？如果是，怎么做？
我们的律师告诉我们，为了最大限度地向法院要求违规者强制执行 GPL，我们应该让程序的版权状况尽可能简单。为了做到这一点，我们要求每个贡献者将贡献部分的版权分配给 FSF，或者放弃对贡献部分的版权要求。
我们也要求个人贡献者从雇主那里获得版权放弃声明（如果有的话），以确保雇主不会声称拥有这部分贡献的版权。
当然，如果所有的贡献者把他们的代码放在公共领域，也就没有用之来执行 GPL 许可证的版权了。所以我们鼓励人们为大规模的代码贡献分配版权，只把小规模的修改放在公共领域。
如果您想要在您的程序中执行 GPL，遵循类似的策略可能是一个好主意。如果您需要更多信息，请联系 <licensing@gnu.org>。
#### 1.12 我可以修改 GPL 并创建一个修改后的许可证吗？
您可以制作GPL的修改版本，但这往往会产生实践上的后果。
您可以在其他许可证中合法使用GPL条款（可能是修改过的），只要您以其他名称来称呼您的许可证，并且不包括 GPL 的<ruby> 引言 <rp> （ </rp> <rt> preamble </rt> <rp> ） </rp></ruby>，只要您对最后的使用说明进行了足够多的修改，使其措辞明显不同，没有提到 GNU（尽管您描述的实际过程可能与其类似）。
如果您想在修改后的许可证中使用我们的引言，请写信至 <licensing@gnu.org>，以获得许可。我们需要查看实际的许可证要求，才能决定我们是否能够批准它们。
虽然我们不会以这种方式对您修改许可证提出法律上的反对意见，但我们希望您三思而行，别去修改许可证。类似这些修改后的许可证几乎肯定[与 GNU GPL 不兼容](https://www.gnu.org/licenses/gpl-faq.html#WhatIsCompatible)，并且这种不兼容性阻碍了模块之间的有用组合。
不同自由软件许可证的扩散本身就是一个负担。请使用 GPL v3 提供的<ruby> 例外 <rp> （ </rp> <rt> exception </rt> <rp> ） </rp></ruby>机制，而不是去修改 GPL。
#### 1.13 为什么你们决定将 GNU Affero GPL v3 作为一个单独的许可证？
GPLv3 的早期草案在第 7 节中允许许可人在发布源代码时添加一个类似 Affero 的要求。但是，一些开发和依赖自由软件的公司认为这个要求太过繁重。他们希望避免使用遵循这个要求的代码，并且对检查代码是否符合这个附加要求所带来的管理成本表示担忧。通过将 GNU Affero GPL v3 作为单独的许可证发布，在该许可证以及 GPL v3 中允许遵循该许可证的代码链接到彼此，我们完成了所有最初的目标，同时更容易确定哪些源代码需要遵循发布要求。
（题图：pycom.io）
---
译者：薛亮，北京集慧智佳知识产权管理咨询股份有限公司互联网事业部高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
GNOME 默认文本编辑器 gedit 险失维护
|
Wxy
|
GNOME 桌面环境默认的文本编辑器、核心应用之一的 gedit 的开发者前几天宣布不再维护它了。庆幸的是，gedit 在“无维护”页面呆了几天后，就有两位新的维护者加入了维护行列，我们可以不用担心 gedit 就此消亡。
|
/data/attachment/album/201708/09/132604qdnsxsiz070iio44.png.thumb.jpg
|
/data/attachment/album/201708/09/132604qdnsxsiz070iio44.png
| true | false | false | false |
[
"gedit",
"GNOME"
] |
观点
|
{
"viewnum": 6148,
"commentnum": 22,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "Gnome 3 风格的 gedit 界面风格还好吧，编辑界面够大，常用的功能用快捷键就行了，毕竟是文字编辑软件。kate 相比感觉界面太老了。<br />\r\n我个人觉得 KDE Plasma 5 整体界面风格不错，但是具体到应用上，变化不大，大体还是属于 Windows XP 那种风格，个别应用我还是会用 Gnome 3 的。<br />\r\n但是不能接受其 DE。DE 自定义的话，难度不小，扩展要从网上下载，KDE 的 4, 5 都是动动鼠标就搞定了，至少对于自己来说。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-09T14:04:43"
},
{
"postip": "27.223.99.130",
"message": "<div class=\"quote\"><blockquote>要写更多的库，并在几个类似应用之间共享且一同维护它们</blockquote></div>强烈赞同！",
"username": "绿色圣光 [Firefox 53.0|GNU/Linux]",
"date": "2017-08-09T15:00:10"
},
{
"postip": "175.141.33.135",
"message": "KDE 的 widgets 你用得下吗?<br />\r\n我倒觉得 Gnome 的 extensions 做得很合需求, 而且选择也多.",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-09T15:03:20"
},
{
"postip": "118.122.120.11",
"message": "widget 我都没用。extensions 原来试过，网络问题没有下载下来过，它那个状态栏功能太少，用 Firefox 或 LibreOffice 实在是难以忍受那窄窄的屏幕空间。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-09T16:05:54"
},
{
"postip": "116.231.48.149",
"message": "我觉得没必要夸大这个问题，因为大部分软件开发团队都会有这些问题。正视它，然后慢慢解决。",
"username": "来自上海的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-09T16:54:51"
},
{
"postip": "223.104.63.36",
"message": "> 只能说是中规中矩、简单而轻量级罢了<br />\r\n<br />\r\n其实 gedit 的扩展性很强，而且用python + pygtk 来写插件非常简单，所以早几年它有很多不错的扩展，比如 markdown 编辑预览、SQL客户端什么的，几乎不逊于notepad++。只不过gedit 本来依赖就多，后面v3.x又受gnome 3.x设计思路影响而功能倒退、易用性下降、插件不兼容情况严重，于是就被抛弃了",
"username": "来自223.104.63.36的 Opera Mobile 42.7|Android 6.0 用户",
"date": "2017-08-09T17:10:37"
},
{
"postip": "221.234.156.205",
"message": "可惜了，我用Linux时文本编程器只用gedit",
"username": "lovetoheart [Firefox 54.0|Windows 10]",
"date": "2017-08-09T17:12:09"
},
{
"postip": "58.49.103.186",
"message": "重复造轮子真是浪费时间",
"username": "来自湖北武汉的 Firefox 54.0|Windows 7 用户",
"date": "2017-08-09T19:31:13"
},
{
"postip": "118.112.205.38",
"message": "Kate 有个功能不得不说，是非常棒的一个功能。就是它有 Read-Only 模式，相当于数据库里的 VIew，对于打开的文本，你只能看不能编辑。有这个功能，可以避免对文本内容无意当中进行编辑，这个功能我在 Vim 等其他文本编辑器都没有找到，对于 Vim 要么是文件本身设置为只读权限，或 -R 打开， 或由 stdin 读入，但这些方式无一例外，都允许编辑。",
"username": "来自四川成都的 Chromium 59.0|Ubuntu 用户",
"date": "2017-08-09T19:48:05"
},
{
"postip": "202.141.162.124",
"message": ":set nomodifiable<br />\r\n<br />\r\n自己vim没学会不要乱讲。",
"username": "来自安徽的 Firefox 57.0|GNU/Linux 用户",
"date": "2017-08-09T23:54:46"
},
{
"postip": "175.141.33.135",
"message": "没用 extensions, 你绝对是错过好戏了<br />\r\n<br />\r\nhttp://jasonmun.blogspot.my/2017/05/gnome-shell-extension-gnome-shell.html",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-10T01:27:32"
},
{
"postip": "118.122.120.11",
"message": "与其错过好戏，我更在意开箱即用。曾经试过多个 DE，最后剩下俩，一个是基于 GTK 的 Xfce，还有一个是基于 Qt 的 KDE Plasma，而 KDE 的整个界面风格高度统一，设置特效方便，功能完备。比如调整窗体边缘阴影，单手用鼠标即可。而 Xfce 在 4.12 没出来前，想把 taskbar 上的应用程序图标设置为 Icon-Only，只能改源代码，然后编译。当然不是说 KDE 就没有问题，KDE 的开的太多，图标会缩小，而不是像 Windows 或 Ubuntu 那样，可以滚动图标来选择。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-10T08:07:06"
},
{
"postip": "222.210.108.99",
"message": "现在看来，使用自由开源软件最害怕的就是：突然某一天，开发者就不再维护了～～～",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-10T08:38:05"
},
{
"postip": "115.175.90.77",
"message": "gnome对于非csd的软件适配简直是个笑话",
"username": "来自北京的 Chrome 59.0|Windows 10 用户",
"date": "2017-08-10T09:19:43"
},
{
"postip": "61.133.215.190",
"message": "-v 可以满足你的需求，看来你得好好重要学下vim ；）",
"username": "来自宁夏银川的 Chrome 60.0|Windows 7 用户",
"date": "2017-08-10T14:51:22"
},
{
"postip": "61.133.215.190",
"message": "想起以前没改UI的时候我有时会用，改了以后发现自己再也没用过",
"username": "来自宁夏银川的 Chrome 60.0|Windows 7 用户",
"date": "2017-08-10T14:53:17"
},
{
"postip": "118.122.120.11",
"message": "Vi Mode 没用的。还是可以编辑的。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-10T15:19:51"
},
{
"postip": "118.122.120.11",
"message": "csd: Client Side Decorations.<br />\r\n我用的那些 Gnome 软件，显示都还正常。只是 gnome-terminal 最大化有留边的问题，某个版本解决了，但是后面的版本，这个问题又出现了。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-10T15:48:27"
},
{
"postip": "118.122.120.11",
"message": "自己之前也没有怎么看 vim --help，刚才看了一下发现，vim 的 View-Only (即完全禁止编辑)实现为<br />\r\n<br />\r\nvim -RMm ${FILE}<br />\r\n<br />\r\n在该状态启用编辑<br />\r\n<br />\r\n:set noreadonly modifiable<br />\r\n<br />\r\n如果临时在一个正常打开的文件启用 View-Only 模式<br />\r\n<br />\r\n则<br />\r\n<br />\r\nset readonly nomodifiable",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-10T16:54:19"
},
{
"postip": "118.122.120.11",
"message": ":set readonly nomodifiable",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-10T16:55:07"
},
{
"postip": "58.63.60.83",
"message": "前天给老笔记本装了DEEPIN系统，里面有不少新轮子哦。深度官方的开发计划也明确了要造轮子。",
"username": "文剑一飞 [Chrome 60.0|Windows 10]",
"date": "2017-08-15T10:52:14"
},
{
"postip": "202.107.194.180",
"message": "我常用的编辑器是vim 和 vscode",
"username": "来自浙江杭州的 Firefox 54.0|Windows 10 用户",
"date": "2017-08-16T08:33:27"
}
] |
[] |
GNOME 桌面环境默认的文本编辑器、核心应用之一的 gedit 的开发者前几天宣布不再维护它了。庆幸的是，gedit 在“无维护”页面呆了几天后，就有两位新的维护者加入了维护行列，我们可以不用担心 gedit 就此消亡。
| 2017-08-09T13:26:00 | 2017-08-09T13:26:00 | 8,762 |
/article-8762-1.html
|
或许是出于疲倦，也有可能是出于对 GNOME 应用开发体系的不满，GNOME 桌面环境默认的文本编辑器、核心应用之一的 gedit 的开发者前几天宣布不再维护它了。它的最新稳定版本是 3.22。
gedit 开发者 Sébastien Wilmet [在邮件列表中说](https://mail.gnome.org/archives/gedit-list/2017-July/msg00001.html)：
>
> “gedit 不再维护，我已将其添加到此维基页面： <https://wiki.gnome.org/Apps/Unmaintained>
>
>
> 有没有感兴趣接手 gedit 维护的开发者？”
>
>
>
庆幸的是，gedit 在“无维护”页面呆了几天后，[就有两位新的维护者加入了维护行列](https://wiki.gnome.org/Apps/Gedit)，我们可以不用担心 gedit 就此消亡——虽然“当前的 GTK+ 3 已经稳定，就是不维护，不出意外的话 gedit 也可以持续工作很长时间”。
gedit 是 GNOME 的默认编辑器，但其实它在 Linux 上的编辑器家族里面并不是很出彩，只能说是中规中矩、简单而轻量级罢了。但是可能也正是因为这个原因，才让大家忽视了这些默不出声的应用也是需要人来关爱的。
gedit 初次发布于 1999 年，而今已经有 18 岁了，但是它的开发者却一直不多，功能和特性的增加也不大，而且，几年前曾经历一次 UI 的较大变更，变更后的 UI 变成非常难用，所以使用者对此也颇有腹诽。但是可能是由于下面的原因，参与维护的人很少：
>
> “另外， gedit 的核心是用 C 写的（为了支持 Mac OS X ，还有一点 Objective-C），一些插件是用 Vala 或 Python 写的。如果你要接手 gedit 的维护，你需要和这四种语言打交道（还不算构建系统）。 Python 代码是没编译的，所以如果重构 gedit 核心的话，可能需要移植所有的插件（python 代码也不如 C 代码那么便于 grep），不过至少 Vala 有个编译器，虽然我不推荐它。”
>
>
>
所以，这可能真的会让维护者头大。
此外，Sébastien Wilmet 对 GNOME 生态的开发也颇有抱怨：
>
> “如果 gedit 死了，我认为这对于所有的 GTK+ 应用都是一个教训：要写更多的库，并在几个类似应用之间共享且一同维护它们。GtkSourceView 仍在维护，但是 gedit 所用的代码要超过了 GtkSourceView。在我给 GtkSourceView 贡献代码前， gedit 里面就有 8000 行以上的代码来保存和载入文件（只是后端，不算前端）。你显然不会认为只有 gedit 需要在用 GtkSourceView 时使用载入和保存文件吧？其它的文本编辑器呢？比如 Anjuta （也有很大一个不再维护的代码库），而且现在 gnome-builder 还在犯同样的错误（在它的角落里面开发了许多文本编辑器功能；你真的认为 Vim 模式只在 gnome-builder 中有用？！）
>
>
> 这事不只是文本编辑器的事，我们造了多少个音乐播放器的轮子？照片管理器呢？IRC/聊天客户端呢？天气预报呢？等等~”
>
>
>
好吧，或许是该正视这个问题的时刻了，毕竟只有良好的开发环境，才有丰富的应用生态，只有丰富的应用生态，才能大量的使用者。
|
||||
解密开放容器计划（OCI）规范
|
Stephen
|
https://blog.docker.com/2017/07/demystifying-open-container-initiative-oci-specifications/
|
开放容器计划（OCI）宣布本周完成了容器运行时和镜像的第一版规范。两年来，为了建立这些规范已经付出了大量的努力。 由此，让我们一起来回顾过去两年中出现的一些误区。
|
/data/attachment/album/201708/09/170940b0cwm23x3au3hvsc.png.thumb.jpg
|
/data/attachment/album/201708/09/170940b0cwm23x3au3hvsc.png
| true | false | true |
rieonke
| false |
[
"容器",
"OCI",
"Docker"
] |
观点
|
{
"viewnum": 7084,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8778,
"displayorder": 0
}
] |
开放容器计划（OCI）宣布本周完成了容器运行时和镜像的第一版规范。两年来，为了建立这些规范已经付出了大量的努力。 由此，让我们一起来回顾过去两年中出现的一些误区。
| 2017-08-09T17:09:00 | 2017-08-09T17:09:00 | 8,763 |
/article-8763-1.html
|
<ruby> 开放容器计划 <rt> Open Container Initiative </rt></ruby>（OCI）宣布本周完成了容器运行时和镜像的第一版规范。OCI 在是 <ruby> Linux 基金会 <rt> Linux Foundation </rt></ruby>支持下的容器解决方案标准化的成果。两年来，为了[建立这些规范](/article-8778-1.html)已经付出了大量的努力。 由此，让我们一起来回顾过去两年中出现的一些误区。
### 误区：OCI 是 Docker 的替代品
诚然标准非常重要，但它们远非一个完整的生产平台。 以万维网为例，它 25 年来一路演进，建立在诸如 TCP/IP 、HTTP 和 HTML 等可靠的核心标准之上。再以 TCP/IP 为例，当企业将 TCP/IP 合并为一种通用协议时，它推动了路由器行业，尤其是思科的发展。 然而，思科通过专注于在其路由平台上提供差异化的功能，而成为市场的领导者。我们认为 OCI 规范和 Docker 也是类似这样并行存在的。
[Docker 是一个完整的生产平台](https://www.docker.com/)，提供了基于容器的开发、分发、安全、编排的一体化解决方案。Docker 使用了 OCI 规范，但它大约只占总代码的 5％，而且 Docker 平台只有一小部分涉及容器的运行时行为和容器镜像的布局。
### 误区：产品和项目已经通过了 OCI 规范认证
运行时和镜像规范本周刚发布 1.0 的版本。 而且 OCI 认证计划仍在开发阶段，所以企业在该认证正式推出之前（今年晚些时候），没法要求容器产品的合规性、一致性或兼容性。
OCI [认证工作组](https://github.com/opencontainers/certification)目前正在制定标准，使容器产品和开源项目能够符合规范的要求。标准和规范对于实施解决方案的工程师很重要，但正式认证是向客户保证其正在使用的技术真正符合标准的唯一方式。
### 误区：Docker 不支持 OCI 规范的工作
Docker 很早就开始为 OCI 做贡献。 我们向 OCI 贡献了大部分的代码，作为 OCI 项目的维护者，为 OCI 运行时和镜像规范定义提供了积极有益的帮助。Docker 运行时和镜像格式在 2013 年开源发布之后，便迅速成为事实上的标准，我们认为将代码捐赠给中立的管理机构，对于避免容器行业的碎片化和鼓励行业创新将是有益的。我们的目标是提供一个可靠和标准化的规范，因此 Docker 提供了一个简单的容器运行时 runc 作为运行时规范工作的基础，后来又贡献了 Docker V2 镜像规范作为 OCI 镜像规范工作的基础。
Docker 的开发人员如 Michael Crosby 和 Stephen Day 从一开始就是这项工作的关键贡献者，确保能将 Docker 的托管和运行数十亿个容器镜像的经验带给 OCI。等认证工作组完成（制定认证规范的）工作后，Docker 将通过 OCI 认证将其产品展示出来，以证明 OCI 的一致性。
### 误区：OCI 仅用于 Linux 容器技术
因为 OCI 是由 <ruby> Linux 基金会 <rt> Linux Foundation </rt></ruby> 负责制定的，所以很容易让人误解为 OCI 仅适用于 Linux 容器技术。 而实际上并非如此，尽管 Docker 技术源于 Linux 世界，但 Docker 也一直在与微软合作，将我们的容器技术、平台和工具带到 Windows Server 的世界。 此外，Docker 向 OCI 贡献的基础技术广泛适用于包括 Linux 、Windows 和 Solaris 在内的多种操作系统环境，涵盖了 x86、ARM 和 IBM zSeries 等多种架构环境。
### 误区：Docker 仅仅是 OCI 的众多贡献者之一
OCI 作为一个支持成员众多的开放组织，代表了容器行业的广度。 也就是说，它是一个小而专业的个人技术专家组，为制作初始规范的工作贡献了大量的时间和技术。 Docker 是 OCI 的创始成员，贡献了初始代码库，构成了运行时规范的基础和后来的参考实现。 同样地，Docker 也将 Docker V2 镜像规范贡献给 OCI 作为镜像规范的基础。
### 误区：CRI-O 是 OCI 项目
CRI-O 是<ruby> 云计算基金会 <rt> Cloud Native Computing Foundation </rt></ruby>（CNCF）的 Kubernetes 孵化器的开源项目 -- 它不是 OCI 项目。 它基于早期版本的 Docker 体系结构，而 containerd 是一个直接的 CNCF 项目，它是一个包括 runc 参考实现的更大的容器运行时。 containerd 负责镜像传输和存储、容器运行和监控，以及支持存储和网络附件等底层功能。 Docker 在五个最大的云提供商（阿里云、AWS、Google Cloud Platform（GCP）、IBM Softlayer 和 Microsoft Azure）的支持下，将 containerd 捐赠给了云计算基金会（CNCF），作为多个容器平台和编排系统的核心容器运行时。
### 误区：OCI 规范现在已经完成了
虽然首版容器运行时和镜像格式规范的发布是一个重要的里程碑，但还有许多工作有待完成。 OCI 一开始着眼于定义一个狭窄的规范：开发人员可以依赖于容器的运行时行为，防止容器行业碎片化，并且仍然允许在不断变化的容器域中进行创新。之后才将含容器镜像规范囊括其中。
随着工作组完成运行时行为和镜像格式的第一个稳定规范，新的工作考量也已经同步展开。未来的新特性将包括分发和签名等。 然而，OCI 的下一个最重要的工作是提供一个由测试套件支持的认证过程，因为第一个规范已经稳定了。
**在 Docker 了解更多关于 OCI 和开源的信息：**
* 阅读关于 [OCI v1.0 版本的运行时和镜像格式规范]的博文[1]
* 访问 [OCI 的网站](https://www.opencontainers.org/join)
* 访问 [Moby 项目网站](http://mobyproject.org/)
* 参加 [DockerCon Europe 2017](https://europe-2017.dockercon.com/)
* 参加 [Moby Summit LA](https://www.eventbrite.com/e/moby-summit-los-angeles-tickets-35930560273)
---
作者简介：
Stephen 是 Docker 开源项目总监。 他曾在 Hewlett-Packard Enterprise （惠普企业）担任董事和杰出技术专家。他的关于开源软件和商业的博客发布在 “再次违约”(<http://stephesblog.blogs.com>) 和网站 opensource.com 上。
---
via: <https://blog.docker.com/2017/07/demystifying-open-container-initiative-oci-specifications/>
作者：[Stephen](%5B1%5D:https://blog.docker.com/2017/07/oci-release-of-v1-0-runtime-and-image-format-specifications) 译者：[rieonke](https://github.com/rieonke) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
专利告诉你，为何 Apache 禁用 FB + PL 代码
|
付钦伟
|
关于 React.js 的开源许可证从去年 7 月份争议到现在，Apache 基金会终于确认了立场，反对使用 React.js 和 Facebook 其他使用此许可证（BSD+Patents licensed）的流行软件。
|
/data/attachment/album/201708/09/214628tu18801915dq96ju.jpg.thumb.jpg
|
/data/attachment/album/201708/09/214628tu18801915dq96ju.jpg
| true | false | false | false |
[
"Facebook",
"Apache"
] |
开源智慧
|
{
"viewnum": 7666,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.20.112.126",
"message": "双授权协议就是韭菜苔",
"username": "来自陕西西安的 Chrome Mobile 59.0|Android 7.0 用户",
"date": "2017-08-10T13:41:42"
},
{
"postip": "182.245.171.252",
"message": "如果用的只是BSD协议的项目会不会遇到什么专利问题？",
"username": "来自云南昆明的 Firefox 54.0|GNU/Linux 用户",
"date": "2017-08-11T19:06:45"
}
] |
[
{
"raid": 8733,
"displayorder": 0
},
{
"raid": 8784,
"displayorder": 0
},
{
"raid": 8876,
"displayorder": 0
},
{
"raid": 8895,
"displayorder": 0
}
] |
关于 React.js 的开源许可证从去年 7 月份争议到现在，Apache 基金会终于确认了立场，反对使用 React.js 和 Facebook 其他使用此许可证（BSD+Patents licensed）的流行软件。
| 2017-08-10T09:17:00 | 2017-08-10T09:17:00 | 8,764 |
/article-8764-1.html
|
>
> 关于 React.js 的开源许可证从去年 7 月份争议到现在，Apache 基金会终于确认了立场，反对使用 React.js 和 Facebook 其他使用此许可证（BSD+Patents licensed）的流行软件。
>
>
>
最近，随着开源运动不断壮大，这边 LC3 大会刚过去不久，人们的热情还是未曾消去，那边 Apache 和 Facebook 又搅动着整个社区。
作为本次事件焦点的 Facebook Patents license 已经不是第一次出风头了，时不时成为人们讨论的主题。
上一次挑动大众神经是在 2016 年 7 月，Facebook 给 React 应用的开源许可协议是，在 BSD3-clause 协议基础上加上旨在保护 Facebook 自身的扩展协议。而这一次依然是围绕 Facebook Patents license 展开，简单梳理此次事件：
* 2017 年 4 月，Apache Cassandra 项目正考虑增加 RocksDB 作为存储引擎，但考虑到专利授权的问题，Jeff Jirsa 向 Apache 法律社区寻求意见。
* 2017 年 6 月，Apache 法律社区开始讨论 Facebook Patents license 协议专利授权的不对称性问题，且该协议与Apache Software License（即 Apache 2.0 等）不兼容。
* 2017 年 7 月 15 日，Apache Software Foundation（以下简称 ASF）主管兼法律事务副主席 Chris Mattmann 正式发表声明称：Facebook BSD+Patents license（以下简称 **FB+PL**）已经正式被列入 “[CategoryX](https://www.apache.org/legal/resolved.html#category-x)” 列表，因此 Apache 项目中将不能够包含或依赖于 Facebook Patents license 的代码；而已经发布的代码，涉及 FB+PL 许可证的，需要在 8 月 31 号前完成替换。
这一结论一出场便自带光环，引起了整个社区的关注，包括国内著名社交论坛知乎。当然，其对 Apache 项目自身的影响不比外界的关注度低。
如，虽然 Facebook 已于本月 17 号将 RocksDB 许可证更新为 Apache 2.0 和 GPLv2 双许可，但更大的问题是 React 也是基于 FB+PL 开源，Apache 的 CouchDB 项目、Apache Superset 项目等都依赖于 React，但是要让其开发人员在一个月内摆脱对 React 的依赖似乎也不是一件简单的事情。
到底是什么原因让 ASF 对 Facebook 的 FB+PL 许可协议下禁止令？要回答这个问题，需要先分析一下 FB+PL 许可协议。
众所周知，Facebook 也算是开源社区的中坚力量，截至目前已经发布了很多开源软件技术，包括使用广泛的 React.JS 框架和键值数据库 RocksDB。
不过，Facebook 没有像其他社区一样，自定义自己的开源许可证，也没有仅采用现存的开源许可证，而是采用 “BSD+Patents license” 许可证组合授权其大部分项目，该协议组合也被称为 FB+PL 组合。
其中，BSD 是指 BSD3-clause license，是被 OSI 和 FSF 都认可的开源软件许可证，也是被业界称为“宽松型”的开源许可证。
正是这个“宽松型”的 BSD 许可证附加了专利条款的开源许可协议，已经被 ASF 列为 “Category X”，杜绝了任何以 FB+PL 授权的软件进入 Apache 项目中的可能性，等于 FB+PL 已被 Apache 明确打入冷宫。
FB+PL 协议中，BSD3-clause license 本身没有问题，问题自然就出在 Facebook Patents license，即 Facebook 开源软件组合协议 FB+PL 中的附加专利许可条款。
以下是 [Facebook Patents license 条款内容](https://github.com/facebook/react/blob/master/PATENTS)：
>
> Additional Grant of Patent Rights Version 2
>
>
> "Software" means the React software distributed by Facebook, Inc.
>
>
> Facebook, Inc. ("Facebook") hereby grants to each recipient of the Software
> ("you") a perpetual, worldwide, royalty-free, non-exclusive, irrevocable
> (subject to the termination provision below) license under any Necessary
> Claims, to make, have made, use, sell, offer to sell, import, and otherwise
> transfer the Software. For avoidance of doubt, no license is granted under
> Facebook's rights in any patent claims that are infringed by (i) modifications
> to the Software made by you or any third party or (ii) the Software in
> combination with any software or other technology.
>
>
> The license granted hereunder will terminate, automatically and without notice,
> if you (or any of your subsidiaries, corporate affiliates or agents) initiate
> directly or indirectly, or take a direct financial interest in, any Patent
> Assertion: (i) against Facebook or any of its subsidiaries or corporate
> affiliates, (ii) against any party if such Patent Assertion arises in whole or
> in part from any software, technology, product or service of Facebook or any of
> its subsidiaries or corporate affiliates, or (iii) against any party relating
> to the Software. Notwithstanding the foregoing, if Facebook or any of its
> subsidiaries or corporate affiliates files a lawsuit alleging patent
> infringement against you in the first instance, and you respond by filing a
> patent infringement counterclaim in that lawsuit against that party that is
> unrelated to the Software, the license granted hereunder will not terminate
> under section (i) of this paragraph due to such counterclaim.
>
>
> A "Necessary Claim" is a claim of a patent owned by Facebook that is
> necessarily infringed by the Software standing alone.
>
>
> A "Patent Assertion" is any lawsuit or other action alleging direct, indirect,
> or contributory infringement or inducement to infringe any patent, including a
> cross-claim or counterclaim.
>
>
>
就是以上这段不算长的附加专利授权条款，让不少开发者甚至开源社区组织顾虑重重。
对开源运动有了解的人可能都知道，开源社区对专利非常敏感，甚至有开源大佬和前辈毫不掩饰对软件专利的厌恶和痛恨。更甚者，国外有专门的反软件专利组织，但毕竟专利制度是很多国家的法律制度，不可能受某个人或某一个群体的人的意见而转移。
因此，开源社区能做的就是改变自己以及影响自己可以影响的人，所以不少开源软件许可证都有针对专利的规范条款。
不过，对于 Facebook 附加专利许可协议，开源圈内人士从一开始都不是特别待见。甚至一些反对软件专利的人认为 FB+PL 协议关于专利的授权，拥有这样的专利授权比没有这样的授权更糟糕。
究其原因，从以上 [Facebook Additional Grant of Patent Rights（附加专利授权条款）](https://github.com/facebook/react/blob/master/PATENTS)可以看出，该协议是一个单边优惠协议，授予人和被授予人的权利不平衡。
简单说就是基于 FB+PL 授权的软件使用者以及基于 FB+PL 开发衍生代码的开发者，与 Facebook 的权利不平衡。一旦被许可人对 Facebook 及其子公司甚至关联公司提出直接的或间接专利诉讼，无论该诉讼是与所涉及项目有关还是无关，亦或是硬件专利诉讼，甚至是 Facebook 主动提出的专利诉讼而被告者进行的专利反诉，该协议授予用户的专利权利即刻自动终止。
另外，2015 年 4 月 10 以前，[Facebook Additional Grant of Patent Rights 第一版](https://github.com/facebook/react/commit/dcf415c2b91ce52fd5d4dd02b70875ba9d33290f#diff-7373d27f0ea94a5b649f893e20fffeda)中，针对 Facebook 任何形式的诉讼，包括反诉、以及与专利无关的诉讼，都会导致基于该协议的专利授权自动终止。后来由于社区人员对该条款争议较大， Facebook 进行了[修改](https://github.com/facebook/react/commit/b8ba8c83f318b84e42933f6928f231dc0918f864?diff=split#diff-7373d27f0ea94a5b649f893e20fffeda)，也即是目前的[第二版](https://github.com/facebook/react/blob/b8ba8c83f318b84e42933f6928f231dc0918f864/PATENTS)。
值得一提的是，在众多的开源许可证中，有专利权利终止以及许可证权利终止条款的许可证并不少见，例如，Apache2.0 以及GPLv2/v3 都有关于权利终止的条款约束。之所以 FB+PL 会有如此强烈的反应关键有两点：
1. FB+PL 专利终止条款过于宽泛；
2. FB+PL 专利条款使得被授予者与 Facebook 之间的权利不平衡。
从另一个层面上讲，Facebook 附加专利授权条款的存在也不是全无道理，毕竟开源软件无时无刻不在承受着来自软件专利的威胁。尽管这些年软件专利没有成功将开源运动送入坟墓，反而使其不断壮大，而开源社区对专利的排斥和恐惧却已深入骨髓。
Facebook 作为开源领域一员猛将，并且已经开源了大量的代码和技术，将所有可能导致侵权的专利技术授权给用户。另一方面，为了自身防护的原因，想办法建立一种自保的机制也在情理之中，毕竟谁都不想成为被鱼肉被屠宰的一方。
整体来讲，Facebook 附加专利授权条款是一个带有严格的惩罚性措施的协议，其严厉性特别表现在其第一版，虽然在第二版中，将诉讼范围限定于专利诉讼，但在许多人看来其范围依然是过大。
Facebook 附加专利授权条款有一种过激的表现，但是如果你能想象一个刚刚崭露头角的少年，还未有可观的积蓄（专利），在群狼环嗣，个个武装到牙齿的对手面前，那种本能的警惕，也许会对 Facebook 多少有点理解。
毕竟，即便 Facebook 附加专利授权条款在严格，对于个人开发者，以及不喜欢搞专利诉讼的组织来说，大家彼此相安无事，也不失为一件好事。
就我个人来讲，我对 Facebook 之于开源的真诚性是认可的。
目前，虽然“<ruby> 开源软件 <rp> （ </rp> <rt> Open Source Software </rt> <rp> ） </rp></ruby>”和“<ruby> 自由软件 <rp> （ </rp> <rt> Free Software </rt> <rp> ） </rp></ruby>”两种哲学理念还存在分歧，但很多社区以及组织包括像 Facebook 这样自我保护略显偏激的组织，都是开源/自由软件理念真诚的践行者。还有一部分像微软一样“从良”的，也为开源做了不少贡献，像这种老牌的商业公司背负了太多的包袱，一下子转身可能性不大。
当然，浑水摸鱼以及投机的分子也肯定不少。不过，开源是软件开发的未来趋势和必然走向，开源理念不仅避免了重复开发中时间、人力和资金了浪费，更是智力共享、集体智慧的完美实践。
因此，虽然目前开源运动还存在着种种的冲突和矛盾，但就像所有的新生事物一样，从萌芽到成长再到成熟都会有一个过程，而在这个过程中磕磕绊绊在所难免。
整体上说，这次 Apache 对 Facebook 附加专利授权条款下禁止令，只是开源运动在一件小事，而开源的生命力正是在这种碰撞、冲突和磨合中逐渐显现，慢慢成熟。
（题图：react-etc.net）
---
作者简介：付钦伟，专利代理人、专利咨询师，任职于集慧智佳知识产权咨询公司。研究生选专业“误入歧途”，进入高大上的知识产权领域，目前从事专利咨询分析工作，励志为中国知识产权事业抛头颅、洒热血。
|
||||
开源情怀遭遇专利咸猪手
|
李可
|
相信社区里的人对此事并不陌生：一名开源软件作者发出求救的呼声，指出知名公司将他的开源软件 XXL-JOB 申请成了专利。我们暂且将之称为开源软件遭遇专利咸猪手吧！应当说，此事件很典型。
|
/data/attachment/album/201708/09/224622laxhaw9rlt5z9zea.png.thumb.jpg
|
/data/attachment/album/201708/09/224622laxhaw9rlt5z9zea.png
| true | false | false | false |
[
"开源",
"专利"
] |
开源智慧
|
{
"viewnum": 5703,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "117.182.152.108",
"message": "我记得龙井项目就拿wine去申请专利了",
"username": "来自117.182.152.108的 Chrome 60.0|Windows 7 用户",
"date": "2017-08-11T12:45:35"
}
] |
[
{
"raid": 8875,
"displayorder": 0
}
] |
相信社区里的人对此事并不陌生：一名开源软件作者发出求救的呼声，指出知名公司将他的开源软件 XXL-JOB 申请成了专利。我们暂且将之称为开源软件遭遇专利咸猪手吧！应当说，此事件很典型。
| 2017-08-11T09:02:00 | 2017-08-11T09:02:00 | 8,765 |
/article-8765-1.html
|
投身开源软件的人，多是有情怀的理想主义者，期望通过无私的努力，让世界更美好。这是原本专注于专利问题的笔者，偶然被牵入到开源研究项目后，对他们所产生的第一印像。
然而，即使专利人也有专利情怀，现实世界中开源与专利的碰撞依然难免丑陋。这要求投身开源的理想主义者必须比一般人更加坚强和执着，才可能推进他们的美好理想。以下，笔者从伸向开源情怀的专利咸猪手这一角度，来提示一下开源人所要面对的现实、承受的考验。
### 引子
相信社区里的人对此事并不陌生：[一名开源软件作者发出求救的呼声，指出知名公司将他的开源软件 XXL-JOB 申请成了专利](https://my.oschina.net/xuxueli/blog/918201)。
按照开源中国博客[文章](https://my.oschina.net/xuxueli/blog/918201)，[XXL-JOB](https://github.com/xuxueli/xxl-job) 作者于 2017 年 6 月在他人提醒之后，发现他的作品 XXL-JOB 被他人申请了中国专利（[CN201610843823.X](https://patents.google.com/patent/CN106648845A/zh)）。依照开源中国的另一篇博客[文章](https://my.oschina.net/javayou/blog/918941)，XXL-JOB 作者委托开源中国与专利申请人进行交涉，作者的基本诉求包括：申请人撤回专利申请并发布声明加以澄清。开源中国与作者进一步希望，如，申请人从事实和技术角度加以澄清，并提出如果专利授权，应声明其与有关开源项目的关系，并“无偿开源”等。
### 开源软件遭遇专利咸猪手
我们暂且将之称为开源软件遭遇专利咸猪手吧！应当说，此事件很典型，无论在国内还是国外都不是孤立性事件。事情的根本在于：开源软件的开发者仅对自己智力劳动成果的知识产权做了很少的保留，将软件基本开放、贡献给公众无偿使用。而开发者的无私奉献却被一些人窃取或搭便车谋利：包括但不限于通过专利咸猪手式的手段侵占公用领域开源软件的全部或一部分，或是针对某些典型应用场景设下埋伏，迫使公众在使用开源软件时有可能侵犯相关专利权而需向他们缴纳费用。
开源软件开发者的情怀在于：多少相信，免费获取和利用知识是人的权利。投身开源的人，对售卖知识的知识产权制度多少有些敌意。不得不承认，我们当今的知识产权制度并不完美，最典型的就是专利海盗现象，它给技术进步和产业发展，尤其是软件产业发展带来了巨大的负面冲击。从某种意义上讲，开源软件的产生，就是一种打破目前知识产权制度对软件行业过度禁锢的积极尝试，而且发展势头良好。
而现实世界比较复杂。从开放的眼光看，存在即为合理，开源软件所遭遇的海盗式专利咸猪手，并非一无是处。因为目前不完美的知识产权制度仍是当下最为现实的解决方案。对于智力成果给予专有保护的必要性和积极意义是毋庸质疑的。知识产权专有保护的着力点主要在限制商业应用；而对于利用知识、技术进行学习和研发，则采取支持、鼓励的态度。
专利咸猪手的法理依据是这样的：
* 在前人智力成果的基础上再进行创造性改进是每个人的权利，是利于社会进步的，即使前人智力成果也受知识产权保护。
* 创造性改进的成果也是智慧成果，可以申请成专利，它的知识产权属于做出创造性改进的人，也就是专利发明人。
应再强调，这里的发明人不应将前人的成果纳入自己的权利保护范围，仅可以就自己做出的改进部分主张权利。相信有情怀的开源人和专利人都不会反对以上两条。
而以下这两个问题，大家可以充分探讨和质疑：仅就 XXL-JOB 专利事件，专利是将 XXL-JOB 的已有技术也纳入了保护范围？还是仅对 XXL-JOB 的改进部分要求进行保护？
如果情况属于前者，该专利将不符合法定授权条件，不应获得授权。如果情况属于后者，第三方发明人获得专利保护则是完全正当的。
现实的狗血在于，想回答清楚这个问题：专利是否将 XXL-JOB 的已有技术纳入了保护范围，是技术上很复杂，成本非常高的问题。负责任地回答这个问题，需要进行非常专业的技术和法律分析，而得出的结论还不能是定论。没错，这个专业分析的成本几千元起，花几万元可能也不奇怪，即专业性强，还成本高，而且没有定论，这一点是肯定的。
为什么没有定论？简单讲，经过司法程序认定，例如，在产生了生效判决的情况下，才有司法定论。请注意，是生效判决，指不被后续司法救济程序推翻的判决。通常，有了司法定论可能还平息不了学术争议，但司法定论是现实中管事的。而要得到司法定论，成本就更高了。
这是开源作者必然会面对的局面，并且常常让人感觉悲哀无助，因为专业性问题可以先放其次，高成本是谁都难以轻易承担的。
还就 XXL-JOB 专利事件而言，即使专利说明书中包括了 XXL-JOB 的技术内容，也不能简单得出专利要求将 XXL-JOB 的已有技术内容纳入了保护范围的结论。技术改进中涉及原有技术的内容是正当的、不可避免的。专利申请人是否不恰当地将 XXL-JOB 的已有技术内容纳入了保护范围，各方各有观点，但尚无定论，第一个要正式面对和回答这一问题的就是专利局的专利审查员。
专利审查员的工作受技术条件、现实条件的制约，也并不能解决全部问题。很多问题只能留待以后产生争议时，由后续准司法和司法程序解决。这又回到了前面所提及的：问题分析专业性强，成本高。
### 开源作者未完结的悲哀无助
开源作者所受的悲哀无助还没有完。使问题更为加剧的是恶意利用制度和程序而产生的问题。简单而言，就是专利海盗式的操作。既然问题难有定论，就拦不住有人在商业利益的驱动之下，百折不挠地努力尝试打各种擦边球，而且总会有所收获。他们中的急先锋便是各类专利海盗。专利海盗充分利用了复杂的程序、高专业性、高成本形成的高门槛。专利，经过专业性的包装等手法，会给专利审查增加很高的技术难度，有可能将开源软件中的已有技术改头换面包装成改进过的新技术，变相纳入私有保护范围，从而混水摸鱼得偿所愿：例如通过专利咸猪手式的手段侵占公用领域开源软件的全部或一部分，或是针对某些典型应用场景设下埋伏，迫使公众在使用开源软件时有可能侵犯相关专利权而需向他们缴纳费用。
实际上，以这种方式做事的，不仅止是专利海盗，背后和之后还有大批正当公司，因为有商业利益驱动。有可能有些激进，但这属于合理利用法律制度和程序。这个问题，至少目前还看不到根本性的解决办法。
开源软件遭遇专利咸猪手，说开了，就是被摘了桃子。实际上，专利高手，充分利用制度和程序，合理合法地何止是摘开源软件的桃子，谁的桃子都摘。这已经属于商业经营活动中的正常专利风险，任谁都避不干净。
### 白话总结
**如果以简单直白的方式总结一下的话：任何人都有权利对开源软件中的技术方案加以改进然后去申请专利，如果做得专业老道，有可能用这些专利卡住开源软件的脖子。这种做法合理合法，其中手段高超的，还会被圈里人称赞为：专利布局水平很高!**
笔者忍不住要插一句：当年我们都不懂知识产权时，外国人没少这么搞我们。现在，我们也已经有一些高手可以这么去搞外国人了。这是有钱才玩得起的昂贵的游戏。一旦搞起来，谈不上对内对外，外国人和我们对内自然也免不了一样搞法。没办法，这就是西方人设计的知识产权制度骨子里的东西。
这是开源作者必然面对的局面，很多时候除了想开些，除了以很高的成本对簿公堂，没有现实的解决办法。笔者有把世界描写得太过黑暗吗？
我看到，投身开源软件的有情怀的理想主义者，有一些在这些黑暗和不公的打击之下，愤而退出了开源事业。笔者非常理解他们。我还看到，更多的人无视这些打击，以不变的情怀和理想，在这条道路上继续栉风沐雨，砥砺前行。笔者非常敬佩他们。人间正道是沧桑。
开源软件开发者这边的故事讲完了，而开源用户应当如何面对这些问题呢？希望以后有机会与大家讨论。
（题图：legalraasta.com）
---
作者：李可，江湖人称“可哥”，老牌专利代理人，集慧智佳知识产权咨询公司的知识产权高级咨询师。70 后文艺理工男，属牛，性子慢但踏实稳妥。
|
||||
cp 命令两个高效的用法
|
Chris Hermansen
|
https://opensource.com/article/17/7/two-great-uses-cp-command
|
Linux 中高效的备份拷贝命令
|
/data/attachment/album/201708/10/134421aa0ht46dtviz6dz4.jpg.thumb.jpg
|
/data/attachment/album/201708/10/134421aa0ht46dtviz6dz4.jpg
| true | false | true |
bigdimple
| false |
[
"cp"
] |
技术
|
{
"viewnum": 14810,
"commentnum": 4,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "210.13.56.34",
"message": "挺实用，记录一下",
"username": "来自北京的 Firefox 55.0|GNU/Linux 用户",
"date": "2017-08-10T18:11:40"
},
{
"postip": "211.102.192.66",
"message": "挺好，“都是我在 1984 年接触 System V Unix 系统时所学习的命令之一”这句牛逼。",
"username": "编程浪子 [Chrome 60.0|Windows 7]",
"date": "2017-08-11T09:35:36"
},
{
"postip": "1.82.229.25",
"message": "不错的 文章..",
"username": "万改称才 [Chrome 62.0|Windows 10]",
"date": "2017-08-21T21:00:06"
},
{
"postip": "222.76.241.20",
"message": "赞！",
"username": "7th [Chrome 60.0|GNU/Linux]",
"date": "2017-09-05T11:09:24"
}
] |
[] |
Linux 中高效的备份拷贝命令
| 2017-08-10T13:45:29 | 2017-08-10T13:45:29 | 8,766 |
/article-8766-1.html
|
>
> Linux 中高效的备份拷贝命令
>
>
>
在 Linux 上能使用鼠标点来点去的图形化界面是一件很美妙的事……但是如果你喜欢的开发交互环境和编译器是终端窗口、Bash 和 Vim，那你应该像我一样*经常*和终端打交道。
即使是不经常使用终端的人，如果对终端环境深入了解也能获益良多。举个例子—— `cp` 命令，据 [维基百科](https://en.wikipedia.org/wiki/Cp_(Unix)) 的解释，`cp` （意即 copy）命令是第一个版本的 [Unix](https://en.wikipedia.org/wiki/Unix) 系统的一部分。连同一组其它的命令 `ls`、`mv`、`cd`、`pwd`、`mkdir`、`vi`、`sh`、`sed` 和 `awk` ，还有提到的 `cp` 都是我在 1984 年接触 System V Unix 系统时所学习的命令之一。`cp` 命令最常见的用法是制作文件副本。像这样：
```
cp sourcefile destfile
```
在终端中执行此命令，上述命令将名为 `sourcefile` 的文件复制到名为 `destfile` 的文件中。如果在执行命令之前 `destfile` 文件不存在，那将会创建此文件，如果已经存在，那就会覆盖此文件。
这个命令我不知道自己用了多少次了（我也不想知道），但是我知道在我编写测试代码的时候，我经常用，为了保留当前正常的版本，而且又能继续修改，我会输入这个命令：
```
cp test1.py test1.bak
```
在过去的30多年里，我使用了无数次这个命令。另外，当我决定编写我的第二个版本的测试程序时，我会输入这个命令：
```
cp test1.py test2.py
```
这样就完成了修改程序的第一步。
我通常很少查看 `cp` 命令的参考文档，但是当我在备份我的图片文件夹的时候（在 GUI 环境下使用 “file” 应用），我开始思考“在 `cp` 命令中是否有个参数支持只复制新文件或者是修改过的文件。”果然，真的有！
### 高效用法 1：更新你的文件夹
比如说在我的电脑上有一个存放各种文件的文件夹，另外我要不时的往里面添加一些新文件，而且我会不时地修改一些文件，例如我手机里下载的照片或者是音乐。
假设我收集的这些文件对我而言都很有价值，我有时候会想做个拷贝，就像是“快照”一样将文件保存在其它媒体。当然目前有很多程序都支持备份，但是我想更为精确的将目录结构复制到可移动设备中，方便于我经常使用这些离线设备或者连接到其它电脑上。
`cp` 命令提供了一个易如反掌的方法。例子如下：
在我的 `Pictures` 文件夹下，我有这样一个文件夹名字为 `Misc`。为了方便说明，我把文件拷贝到 USB 存储设备上。让我们开始吧！
```
me@desktop:~/Pictures$ cp -r Misc /media/clh/4388-D5FE
me@desktop:~/Pictures$
```
上面的命令是我从按照终端窗口中完整复制下来的。对于有些人来说不是很适应这种环境，在我们输入命令或者执行命令之前，需要注意的是 `me@mydesktop:~/Pictures` 这个前缀，`me` 这个是当前用户，`mydesktop` 这是电脑名称，`~/Pictures` 这个是当前工作目录，是 `/home/me/Pictures` 完整路径的缩写。
我输入这个命令 `cp -r Misc /media/clh/4388-D5FE` 并执行后 ，拷贝 `Misc` 目录下所有文件（这个 `-r` 参数，全称 “recursive”，递归处理，意思为本目录下所有文件及子目录一起处理）到我的 USB 设备的挂载目录 `/media/clh/4388-D5FE`。
执行命令后回到之前的提示，大多数命令继承了 Unix 的特性，在命令执行后，如果没有任何异常什么都不显示，在任务结束之前不会显示像 “execution succeeded” 这样的提示消息。如果想获取更多的反馈，就使用 `-v` 参数让执行结果更详细。
下图中是我的 USB 设备中刚刚拷贝过来的文件夹 `Misc` ，里面总共有 9 张图片。
假设我要在原始拷贝路径下 `~/Pictures/Misc` 下添加一些新文件，就像这样：
现在我想只拷贝新的文件到我的存储设备上，我就使用 `cp` 的“更新”和“详细”选项。
```
me@desktop:~/Pictures$ cp -r -u -v Misc /media/clh/4388-D5FE
'Misc/asunder.png' -> '/media/clh/4388-D5FE/Misc/asunder.png'
'Misc/editing tags guayadeque.png' -> '/media/clh/4388-D5FE/Misc/editing tags guayadeque.png'
'Misc/misc on usb.png' -> '/media/clh/4388-D5FE/Misc/misc on usb.png'
me@desktop:~/Pictures$
```
上面的第一行中是 `cp` 命令和具体的参数（`-r` 是“递归”， `-u` 是“更新”，`-v` 是“详细”）。接下来的三行显示被复制文件的信息，最后一行显示命令行提示符。
通常来说，参数 `-r` 也可用更详细的风格 `--recursive`。但是以简短的方式，也可以这么连用 `-ruv`。
### 高效用法 2：版本备份
回到一开始的例子中，我在开发的时候定期给我的代码版本进行备份。然后我找到了另一种更好用的 `cp` 参数。
假设我正在编写一个非常有用的 Python 程序，作为一个喜欢不断修改代码的开发者，我会在一开始编写一个程序简单版本，然后不停的往里面添加各种功能直到它能成功的运行起来。比方说我的第一个版本就是用 Python 程序打印出 “hello world”。这只有一行代码的程序就像这样：
```
print 'hello world'
```
然后我将这个代码保存成文件命名为 `test1.py`。我可以这么运行它：
```
me@desktop:~/Test$ python test1.py
hello world
me@desktop:~/Test$
```
现在程序可以运行了，我想在添加新的内容之前进行备份。我决定使用带编号的备份选项，如下：
```
clh@vancouver:~/Test$ cp --force --backup=numbered test1.py test1.py
clh@vancouver:~/Test$ ls
test1.py test1.py.~1~
clh@vancouver:~/Test$
```
所以，上面的做法是什么意思呢？
第一，这个 `--backup=numbered` 参数意思为“我要做个备份，而且是带编号的连续备份”。所以一个备份就是 1 号，第二个就是 2 号，等等。
第二，如果源文件和目标文件名字是一样的。通常我们使用 `cp` 命令去拷贝成自己，会得到这样的报错信息：
```
cp: 'test1.py' and 'test1.py' are the same file
```
在特殊情况下，如果我们想备份的源文件和目标文件名字相同，我们使用 `--force` 参数。
第三，我使用 `ls` （意即 “list”）命令来显示现在目录下的文件，名字为 `test1.py` 的是原始文件，名字为 `test1.py.~1~` 的是备份文件
假如现在我要加上第二个功能，在程序里加上另一行代码，可以打印 “Kilroy was here.”。现在程序文件 `test1.py` 的内容如下：
```
print 'hello world'
print 'Kilroy was here'
```
看到 Python 编程多么简单了吗？不管怎样，如果我再次执行备份的步骤，结果如下：
```
clh@vancouver:~/Test$ cp --force --backup=numbered test1.py test1.py
clh@vancouver:~/Test$ ls
test1.py test1.py.~1~ test1.py.~2~
clh@vancouver:~/Test$
```
现在我有有两个备份文件： `test1.py.~1~` 包含了一行代码的程序，和 `test1.py.~2~` 包含两行代码的程序。
这个很好用的功能，我考虑做个 shell 函数让它变得更简单。
### 最后总结
第一，Linux 手册页，它在大多数桌面和服务器发行版都默认安装了，它提供了更为详细的使用方法和例子，对于 `cp` 命令，在终端中输入如下命令：
```
man cp
```
对于那些想学习如何使用这些命令，但不清楚如何使用的用户应该首先看一下这些说明，然后我建议创建一个测试目录和文件来尝试使用命令和选项。
第二，兴趣是最好的老师。在你最喜欢的搜索引擎中搜索 “linux shell tutorial”，你会获得很多有趣和有用的资源。
第三，你是不是在想，“为什么我要用这么麻烦的方法，图形化界面中有相同的功能，只用点击几下岂不是更简单？”，关于这个问题我有两个理由。首先，在我们工作中需要中断其他工作流程以及大量使用点击动作时，点击动作可就不简单了。其次，如果我们要完成流水线般的重复性工作，通过使用 shell 脚本和 shell 函数以及 shell 重命名等功能就能很轻松的实现。
你还知道关于 `cp` 命令其他更棒的使用方式吗？请在留言中积极回复哦～
（题图：stonemaiergames.com）
---
作者简介：
Chris Hermansen - 1978 年毕业于英国哥伦比亚大学后一直从事计算机相关职业，我从 2005 年开始一直使用 Linux、Solaris、SunOS，在那之前我就是 Unix 系统管理员了，在技术方面，我的大量的职业生涯都是在做数据分析，尤其是空间数据分析，我有大量的编程经验与数据分析经验，熟练使用 awk、Python、PostgreSQL、PostGIS 和 Groovy。
---
via: <https://opensource.com/article/17/7/two-great-uses-cp-command>
作者：[Chris Hermansen](https://opensource.com/users/clhermansen) 译者：[bigdimple](https://github.com/bigdimple) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Ubuntu Core：制作包含私有 snap 的工厂镜像
|
Kyle Fazzari
|
https://insights.ubuntu.com/2017/07/11/ubuntu-core-making-a-factory-image-with-private-snaps/
|
我收到的一个问题： “我想做一个工厂镜像，但我不想使我的 snap 公开” 在这篇帖子中，我将会通过两种方法来回答这个问题。
|
/data/attachment/album/201708/10/170808pqqpomyq49mh4omm.jpg.thumb.jpg
|
/data/attachment/album/201708/10/170808pqqpomyq49mh4omm.jpg
| true | false | true |
Snapcrafter
| false |
[
"snap",
"Snapcraft"
] |
技术
|
{
"viewnum": 6511,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我收到的一个问题： “我想做一个工厂镜像，但我不想使我的 snap 公开” 在这篇帖子中，我将会通过两种方法来回答这个问题。
| 2017-08-10T17:08:00 | 2017-08-10T17:08:00 | 8,767 |
/article-8767-1.html
|
这篇帖子是有关 [在 Ubuntu Core 开发 ROS 原型到成品](https://insights.ubuntu.com/2017/04/06/from-ros-prototype-to-production-on-ubuntu-core/) 系列的补充，用来回答我收到的一个问题： “我想做一个工厂镜像，但我不想使我的 snap 公开” 当然，这个问题和回答都不只是针对于机器人技术。在这篇帖子中，我将会通过两种方法来回答这个问题。
开始之前，你需要了解一些制作 Ubuntu Core 镜像的背景知识，如果你已经看过 [在 Ubuntu Core 开发 ROS 原型到成品[3](https://insights.ubuntu.com/2017/04/06/from-ros-prototype-to-production-on-ubuntu-core/) 系列文章（具体是第 5 部分），你就已经有了需要的背景知识，如果没有看过的话，可以查看有关 [制作你的 Ubuntu Core 镜像](https://tutorials.ubuntu.com/tutorial/create-your-own-core-image) 的教程。
如果你已经了解了最新的情况，并且当我说 “模型定义” 或者 “模型断言” 时知道我在谈论什么，那就让我们开始通过不同的方法使用私有 sanps 来制作 Ubuntu Core 镜像吧。
### 方法 1： 不要上传你的 snap 到商店
这是最简单的方法了。首先看一下这个有关模型定义的例子——`amd64-model.json`：
```
{
"type": "model",
"series": "16",
"model": "custom-amd64",
"architecture": "amd64",
"gadget": "pc",
"kernel": "pc-kernel",
"authority-id": "4tSgWHfAL1vm9l8mSiutBDKnnSQBv0c8",
"brand-id": "4tSgWHfAL1vm9l8mSiutBDKnnSQBv0c8",
"timestamp": "2017-06-23T21:03:24+00:00",
"required-snaps": ["kyrofa-test-snap"]
}
```
让我们将它转换成模型断言：
```
$ cat amd64-model.json | snap sign -k my-key-name > amd64.model
You need a passphrase to unlock the secret key for
user: "my-key-name"
4096-bit RSA key, ID 0B79B865, created 2016-01-01
...
```
获得模型断言：`amd64.model` 后，如果你现在就把它交给 `ubuntu-image` 使用，你将会碰钉子：
```
$ sudo ubuntu-image -c stable amd64.model
Fetching core
Fetching pc-kernel
Fetching pc
Fetching kyrofa-test-snap
error: cannot find snap "kyrofa-test-snap": snap not found
COMMAND FAILED: snap prepare-image --channel=stable amd64.model /tmp/tmp6p453gk9/unpack
```
实际上商店中并没有名为 `kyrofa-test-snap` 的 snap。这里需要重点说明的是：模型定义（以及转换后的断言）只包含了一系列的 snap 的名字。如果你在本地有个那个名字的 snap，即使它没有存在于商店中，你也可以通过 `--extra-snaps` 选项告诉 `ubuntu-image` 在断言中匹配这个名字来使用它：
```
$ sudo ubuntu-image -c stable \
--extra-snaps /path/to/kyrofa-test-snap_0.1_amd64.snap \
amd64.model
Fetching core
Fetching pc-kernel
Fetching pc
Copying "/path/to/kyrofa-test-snap_0.1_amd64.snap" (kyrofa-test-snap)
kyrofa-test-snap already prepared, skipping
WARNING: "kyrofa-test-snap" were installed from local snaps
disconnected from a store and cannot be refreshed subsequently!
Partition size/offset need to be a multiple of sector size (512).
The size/offset will be rounded up to the nearest sector.
```
现在，在 snap 并没有上传到商店的情况下，你已经获得一个预装了私有 snap 的 Ubuntu Core 镜像（名为 `pc.img`）。但是这样做有一个很大的问题，ubuntu-image 会提示一个警告：不通过连接商店预装 snap 意味着你没有办法在烧录了这些镜像的设备上更新它。你只能通过制作新的镜像并重新烧录到设备的方式来更新它。
### 方法 2： 使用品牌商店
当你注册了一个商店账号并访问 [dashboard.snapcraft.io](https://dashboard.snapcraft.io/dev/snaps/) 时，你其实是在标准的 Ubuntu 商店中查看你的 snap。如果你是在系统中新安装的 snapd，默认会从这个商店下载。虽然你可以在 Ubuntu 商店中发布私有的 snap，但是你[不能将它们预装到镜像中](https://forum.snapcraft.io/t/unable-to-create-an-image-that-uses-private-snaps)，因为只有你（以及你添加的合作者）才有权限去使用它。在这种情况下制作镜像的唯一方式就是公开发布你的 snap，然而这并不符合这篇帖子的目的。
对于这种用例，我们有所谓的 [品牌商店](https://docs.ubuntu.com/core/en/build-store/index?_ga=2.103787520.1269328701.1501772209-778441655.1499262639)。品牌商店仍然托管在 Ubuntu 商店里，但是它们是针对于某一特定公司或设备的一个定制的、专门的版本。品牌商店可以继承或者不继承标准的 Ubuntu 商店，品牌商店也可以选择开放给所有的开发者或者将其限制在一个特定的组内（保持私有正是我们想要的）。
请注意，这是一个付费功能。你需要 [申请一个品牌商店](https://docs.ubuntu.com/core/en/build-store/create)。请求通过后，你将可以通过访问用户名下的 “stores you can access” 看到你的新商店。
在那里你可以看到多个有权使用的商店。最少的情况下也会有两个：标准的 Ubuntu 商店以及你的新的品牌商店。选择品牌商店（红框），进去后记录下你的商店 ID（蓝框）：等下你将会用到它。
在品牌商店里注册名字或者上传 snap 和标准的商店使用的方法是一样的，只是它们现在是上传到你的品牌商店而不是标准的那个。如果你将品牌商店放在 unlisted 里面，那么这些 snap 对外部用户是不可见。但是这里需要注意的是第一次上传 snap 的时候需要通过 web 界面来操作。在那之后，你可以继续像往常一样使用 Snapcraft 来操作。
那么这些是如何改变的呢？我的 “kyrofal-store” 从 Ubuntu 商店继承了 snap，并且还包含一个发布在稳定通道中的 “kyrofa-bran-test-snap” 。这个 snap 在 Ubuntu 商店里是使用不了的，如果你去搜索它，你是找不到的：
```
$ snap find kyrofa-branded
The search "kyrofa-branded" returned 0 snaps
```
但是使用我们前面记录的商店 ID，我们可以创建一个从品牌商店而不是 Ubuntu 商店下载 snap 的模型断言。我们只需要将 “store” 键添加到 JSON 文件中，就像这样：
```
{
"type": "model",
"series": "16",
"model": "custom-amd64",
"architecture": "amd64",
"gadget": "pc",
"kernel": "pc-kernel",
"authority-id": "4tSgWHfAL1vm9l8mSiutBDKnnSQBv0c8",
"brand-id": "4tSgWHfAL1vm9l8mSiutBDKnnSQBv0c8",
"timestamp": "2017-06-23T21:03:24+00:00",
"required-snaps": ["kyrofa-branded-test-snap"],
"store": "ky<secret>ek"
}
```
使用方法 1 中的方式对它签名，然后我们就可以像这样很简单的制作一个预装有我们品牌商店私有 snap 的 Ubuntu Core 镜像：
```
$ sudo ubuntu-image -c stable amd64.model
Fetching core
Fetching pc-kernel
Fetching pc
Fetching kyrofa-branded-test-snap
Partition size/offset need to be a multiple of sector size (512).
The size/offset will be rounded up to the nearest sector.
```
现在，和方法 1 的最后一样，你获得了一个为工厂准备的 `pc.img`。并且使用这种方法制作的镜像中的所有 snap 都从商店下载的，这意味着它们将能像平常一样自动更新。
### 结论
到目前为止，做这个只有两种方法。当我开始写这篇帖子的时候，我想过可能还有第三种（将 snap 设置为私有然后使用它制作镜像），[但最后证明是不行的](https://forum.snapcraft.io/t/unable-to-create-an-image-that-uses-private-snaps/1115)。
另外，我们也收到很多内部部署或者企业商店的请求，虽然这样的产品还没有公布，但是商店团队正在从事这项工作。一旦可用，我将会写一篇有关它的文章。
希望能帮助到您！
---
关于作者
Kyle 是 Snapcraft 团队的一员，也是 Canonical 公司的常驻机器人专家，他专注于 snaps 和 snap 开发实践，以及 snaps 和 Ubuntu Core 的机器人技术实现。
---
via: <https://insights.ubuntu.com/2017/07/11/ubuntu-core-making-a-factory-image-with-private-snaps/>
作者：[Kyle Fazzari][a] 译者：[Snaplee](https://github.com/Snaplee) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
CoreOS，一款 Linux 容器发行版
|
Steven J. Vaughan-nichols
|
https://medium.com/linode-cube/the-what-why-and-wow-behind-the-coreos-container-linux-fa7ceae5593c
|
CoreOS 可以控制发行版的升级（基于 ChromeOS 代码），并结合了 Docker 和潜在的核对/修复功能，这意味着不用停止或者重启你的相关进程，就可以在线升级。
|
/data/attachment/album/201708/11/094115v4k77706788z9yvk.png.thumb.jpg
|
/data/attachment/album/201708/11/094115v4k77706788z9yvk.png
| true | false | true |
toyijiu
| false |
[
"CoreOS",
"容器"
] |
技术
|
{
"viewnum": 12215,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "120.239.13.108",
"message": "升级内核也不用重启吗？",
"username": "泽楠弟弟 [Safari 10.1|Mac 10.12]",
"date": "2017-08-11T20:39:51"
},
{
"postip": "59.41.92.179",
"message": "it's a good docker",
"username": "来自广东广州的 Chrome 56.0|Chrome OS 9000.104 用户",
"date": "2017-08-13T11:32:46"
},
{
"postip": "203.59.16.142",
"message": "CoreOS 早已改名 Container Linux 的说",
"username": "来自澳大利亚的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-08-16T12:39:22"
}
] |
[] |
CoreOS 可以控制发行版的升级（基于 ChromeOS 代码），并结合了 Docker 和潜在的核对/修复功能，这意味着不用停止或者重启你的相关进程，就可以在线升级。
| 2017-08-11T09:40:31 | 2017-08-11T09:40:31 | 8,768 |
/article-8768-1.html
|
>
> CoreOS，一款最新的 Linux 发行版本，支持自动升级内核软件，提供各集群间配置的完全控制。
>
>
>
关于使用哪个版本的 Linux 服务器系统的争论，常常是以这样的话题开始的：
>
> 你是喜欢基于 [Red Hat Enterprise Linux （RHEL）](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux) 的 [CentOS](https://www.centos.org/) 或者 [Fedora](https://getfedora.org/)，还是基于 [Debian](https://www.debian.org/) 的 [Ubuntu](https://www.ubuntu.com/)，抑或 [SUSE](https://www.suse.com/) 呢？
>
>
>
但是现在，一款名叫 [CoreOS 容器 Linux](https://coreos.com/os/docs/latest) 的 Linux 发行版加入了这场“圣战”。[这个最近在 Linode 服务器上提供的 CoreOS](https://www.linode.com/docs/platform/use-coreos-container-linux-on-linode)，和它的老前辈比起来，它使用了完全不同的实现方法。
你可能会感到不解，这里有这么多成熟的 Linux 发行版本，为什么要选择用 CoreOS ？借用 Linux 主干分支的维护者，也是 CoreOS 顾问的 Greg Kroah-Hartman 先生的一句话：
>
> CoreOS 可以控制发行版的升级（基于 ChromeOS 代码），并结合了 Docker 和潜在的核对/修复功能，这意味着不用停止或者重启你的相关进程，就可以[在线升级](https://plus.google.com/+gregkroahhartman/posts/YvWFmPa9kVf)。测试版本已经支持此功能，这是史无前例的。
>
>
>
当 Greg Kroah-Hartman 做出这段评价时，CoreOS 还处于 α 测试阶段，当时也许就是在硅谷的一个车库当中，[开发团队正在紧锣密鼓地开发此产品](https://www.wired.com/2013/08/coreos-the-new-linux/)，但 CoreOS 不像最开始的苹果或者惠普，其在过去的四年当中一直稳步发展。
当我参加在旧金山举办的 [2017 CoreOS 大会](https://coreos.com/fest/)时，CoreOS 已经支持谷歌云、IBM、AWS 和微软的相关服务。现在有超过 1000 位开发人员参与到这个项目中，并为能够成为这个伟大产品的一员而感到高兴。
究其原因，CoreOS 从开始就是为容器而设计的轻量级 Linux 发行版，其起初是作为一个 [Docker](https://www.docker.com/) 平台，随着时间的推移， CoreOS 在容器方面走出了自己的道路，除了 Docker 之外，它也支持它自己的容器 [rkt](https://coreos.com/rkt) （读作 rocket ）。
不像大多数其他的 Linux 发行版，CoreOS 没有包管理器，取而代之的是通过 Google ChromeOS 的页面自动进行软件升级，这样能提高在集群上运行的机器/容器的安全性和可靠性。不用通过系统管理员的干涉，操作系统升级组件和安全补丁可以定期推送到 CoreOS 容器。
你可以通过 [CoreUpdate 和它的 Web 界面](https://coreos.com/products/coreupdate/)上来修改推送周期，这样你就可以控制你的机器何时更新，以及更新以多快的速度滚动分发到你的集群上。
CoreOS 通过一种叫做 [etcd](https://github.com/coreos/etcd) 的分布式配置服务来进行升级，etcd 是一种基于 [YAML](http://yaml.org/) 的开源的分布式哈希存储系统，它可以为 Linux 集群容器提供配置共享和服务发现等功能。
此服务运行在集群上的每一台服务器上，当其中一台服务器需要下线升级时，它会发起领袖选举，以便服务器更新时整个Linux 系统和容器化的应用可以继续运行。
对于集群管理，CoreOS 之前采用的是 [fleet](https://github.com/coreos/fleet) 方法，这将 etcd 和 [systemd](https://www.freedesktop.org/wiki/Software/systemd/) 结合到分布式初始化系统中。虽然 fleet 仍然在使用，但 CoreOS 已经将 etcd 加入到 [Kubernetes](https://kubernetes.io/) 容器编排系统构成了一个更加强有力的管理工具。
CoreOS 也可以让你定制其它的操作系统相关规范，比如用 [cloud-config](https://coreos.com/os/docs/latest/cloud-config.html) 的方式管理网络配置、用户账号和 systemd 单元等。
综上所述，CoreOS 可以不断地自行升级到最新版本，能让你获得从单独系统到集群等各种场景的完全控制。如 CoreOS 宣称的，你再也不用为了改变一个单独的配置而在每一台机器上运行 [Chef](https://insights.hpe.com/articles/what-is-chef-a-primer-for-devops-newbies-1704.html) 了。
假如说你想进一步的扩展你的 DevOps 控制，[CoreOS 能够轻松地帮助你部署 Kubernetes](https://blogs.dxc.technology/2017/06/08/coreos-moves-in-on-cloud-devops-with-kubernetes/)。
CoreOS 从一开始就是构建来易于部署、管理和运行容器的。当然，其它的 Linux 发行版，比如 RedHat 家族的[原子项目](http://www.projectatomic.io/)也可以达到类似的效果，但是对于那些发行版而言是以附加组件的方式出现的，而 CoreOS 从它诞生的第一天就是为容器而设计的。
当前[容器和 Docker 已经逐渐成为商业系统的主流](http://www.zdnet.com/article/what-is-docker-and-why-is-it-so-darn-popular/)，如果在可预见的未来中你要在工作中使用容器，你应该考虑下 CoreOS，不管你的系统是在裸机硬件上、虚拟机还是云上。
如果有任何关于 CoreOS 的观点或者问题，还请在评论栏中留言。如果你觉得这篇博客还算有用的话，还请分享一下~
---
关于博主：Steven J. Vaughan-Nichols 是一位经验丰富的 IT 记者，许多网站中都刊登有他的文章，包括 [ZDNet.com](http://www.zdnet.com/meet-the-team/us/steven-j-vaughan-nichols/)、[PC Magazine](http://www.pcmag.com/author-bio/steven-j.-vaughan-nichols)、[InfoWorld](http://www.infoworld.com/author/Steven-J.-Vaughan_Nichols/)、[ComputerWorld](http://www.computerworld.com/author/Steven-J.-Vaughan_Nichols/)、[Linux Today](http://www.linuxtoday.com/author/Steven+J.+Vaughan-Nichols/) 和 [eWEEK](http://www.eweek.com/cp/bio/Steven-J.-Vaughan-Nichols/) 等。他拥有丰富的 IT 知识 - 而且他曾参加过智力竞赛节目 Jeopardy ！他的相关观点都是自身思考的结果，并不代表 Linode 公司，我们对他做出的贡献致以最真诚的感谢。如果想知道他更多的信息，可以关注他的 Twitter [*@sjvn*](http://www.twitter.com/sjvn)。
---
via: <https://medium.com/linode-cube/the-what-why-and-wow-behind-the-coreos-container-linux-fa7ceae5593c>
作者：[Steven J. Vaughan-Nichols](https://medium.com/linode-cube/the-what-why-and-wow-behind-the-coreos-container-linux-fa7ceae5593c) 译者：[吴霄/toyijiu](https://github.com/toyijiu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
10 个应当了解的 Unikernel 开源项目
|
Sam Dean
|
https://www.linux.com/news/open-cloud-report/2016/guide-open-cloud-age-unikernel
|
unikernel 实质上是一个缩减的操作系统，它可以与应用程序结合成为一个 unikernel 程序，它通常在虚拟机中运行。
|
/data/attachment/album/201708/11/160806zswm82ucu6ww8k60.jpg.thumb.jpg
|
/data/attachment/album/201708/11/160806zswm82ucu6ww8k60.jpg
| true | false | true |
geekpi
| false |
[
"unikernel"
] |
容器与云
|
{
"viewnum": 7528,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "58.63.60.83",
"message": "精简的内核+必要的库？",
"username": "文剑一飞 [Chrome 60.0|Windows 10]",
"date": "2017-08-12T09:16:45"
}
] |
[] |
unikernel 实质上是一个缩减的操作系统，它可以与应用程序结合成为一个 unikernel 程序，它通常在虚拟机中运行。
| 2017-08-11T16:08:01 | 2017-08-11T16:08:01 | 8,769 |
/article-8769-1.html
|
>
> unikernel 实质上是一个缩减的操作系统，它可以与应用程序结合成为一个 unikernel 程序，它通常在虚拟机中运行。下载《开放云指南》了解更多。
>
>
>
当涉及到操作系统、容器技术和 unikernel，趋势是朝着微型化发展。什么是 unikernel？unikernel 实质上是一个缩减的操作系统（特指 “unikernel”），它可以与应用程序结合成为一个 unikernel 程序, 它通常在虚拟机中运行。它们有时被称为库操作系统，因为它包含了使应用程序能够将硬件和网络协议与一组访问控制和网络层隔离的策略相结合使用的库。
在讨论云计算和 Linux 时容器常常会被提及，而 unikernel 也在做一些变革。容器和 unikernel 都不是新事物。在 20 世纪 90 年代就有类似 unikernel 的系统，如 Exokernel，而如今流行的 unikernel 系统则有 MirageOS 和 OSv。 Unikernel 程序可以独立使用并在异构环境中部署。它们可以促进专业化和隔离化服务，并被广泛用于在微服务架构中开发应用程序。
作为 unikernel 如何引起关注的一个例子，你可以看看 Docker 收购了[基于 Cambridge 的 Unikernel 系统](http://www.infoworld.com/article/3024410/application-virtualization/docker-kicks-off-unikernel-revolution.html)，并且已在许多情况下在使用 unikernel。
unikernel，就像容器技术一样, 它剥离了非必需的的部分，因此它们对应用程序的稳定性、可用性以及安全性有非常积极的影响。在开源领域，它们也吸引了许多顶级，最具创造力的开发人员。
Linux 基金会最近[宣布](https://www.linux.com/blog/linux-foundation-issues-2016-guide-open-source-cloud-projects)发布了其 2016 年度报告[开放云指南：当前趋势和开源项目指南](http://ctt.marketwire.com/?release=11G120876-001&id=10172077&type=0&url=http%3A%2F%2Fgo.linuxfoundation.org%2Frd-open-cloud-report-2016-pr)。这份第三年度的报告全面介绍了开放云计算的状况，并包含了一节关于 unikernel 的内容。你现在可以[下载该报告](http://go.linuxfoundation.org/l/6342/2016-10-31/3krbjr)。它汇总并分析研究、描述了容器、unikernel 的发展趋势，已经它们如何重塑云计算的。该报告提供了对当今开放云环境中心的各类项目的描述和链接。
在本系列文章中，我们将按类别分析指南中提到的项目，为整体类别的演变提供了额外的见解。下面, 你将看到几个重要 unikernel 项目的列表及其影响，以及它们的 GitHub 仓库的链接, 这些都是从开放云指南中收集到的：
### [ClickOS](http://cnp.neclab.eu/clickos/)
ClickOS 是 NEC 的高性能虚拟化软件中间件平台，用于构建于 MiniOS/MirageOS 之上网络功能虚拟化（NFV）
* [ClickOS 的 GitHub](https://github.com/cnplab/clickos)
### [Clive](http://lsub.org/ls/clive.html)
Clive 是用 Go 编写的一个操作系统，旨在工作于分布式和云计算环境中。
### [HaLVM](https://galois.com/project/halvm/)
Haskell 轻量级虚拟机（HaLVM）是 Glasgow Haskell 编译器工具包的移植，它使开发人员能够编写可以直接在 Xen 虚拟机管理程序上运行的高级轻量级虚拟机。
* [HaLVM 的 GitHub](https://github.com/GaloisInc/HaLVM)
### [IncludeOS](http://www.includeos.org/)
IncludeOS 是在云中运行 C++ 服务的 unikernel 操作系统。它提供了一个引导加载程序、标准库以及运行服务的构建和部署系统。在 VirtualBox 或 QEMU 中进行测试，并在 OpenStack 上部署服务。
* [IncludeOS 的 GitHub](https://github.com/hioa-cs/IncludeOS)
### [Ling](http://erlangonxen.org/)
Ling 是一个用于构建超级可扩展云的 Erlang 平台，可直接运行在 Xen 虚拟机管理程序之上。它只运行三个外部库 （没有 OpenSSL），并且文件系统是只读的，以避免大多数攻击。
* [Ling 的 GitHub](https://github.com/cloudozer/ling)
### [MirageOS](https://mirage.io/)
MirageOS 是在 Linux 基金会的 Xen 项目下孵化的库操作系统。它使用 OCaml 语言构建的 unikernel 可以用于各种云计算和移动平台上安全的高性能网络应用。代码可以在诸如 Linux 或 MacOS X 等普通的操作系统上开发，然后编译成在 Xen 虚拟机管理程序下运行的完全独立的专用 Unikernel。
* [MirageOS 的 GitHub](https://github.com/mirage/mirage)
### [OSv](http://osv.io/)
OSv 是 Cloudius Systems 为云设计的开源操作系统。它支持用 Java、Ruby（通过 JRuby）、JavaScript（通过 Rhino 和 Nashorn）、Scala 等编写程序。它运行在 VMware、VirtualBox、KVM 和 Xen 虚拟机管理程序上。
* [OSV 的 GitHub](https://github.com/cloudius-systems/osv)
### [Rumprun](http://rumpkernel.org/)
Rumprun 是一个可用于生产环境的 unikernel，它使用 rump 内核提供的驱动程序，添加了 libc 和应用程序环境，并提供了一个工具链，用于将现有的 POSIX-y 程序构建为 Rumprun unikernel。它适用于 KVM 和 Xen 虚拟机管理程序和裸机，并支持用 C、C ++、Erlang、Go、Java、JavaScript（Node.js）、Python、Ruby、Rust 等编写的程序。
* [Rumprun 的 GitHub](https://github.com/rumpkernel/rumprun)
### [Runtime.js](http://runtimejs.org/)
Runtime.js 是用于在云上运行 JavaScript 的开源库操作系统（unikernel），它可以与应用程序捆绑在一起，并部署为轻量级和不可变的 VM 镜像。它基于 V8 JavaScript 引擎，并使用受 Node.js 启发的事件驱动和非阻塞 I/O 模型。KVM 是唯一支持的虚拟机管理程序。
* [Runtime.js 的 GitHub](https://github.com/runtimejs/runtime)
### [UNIK](http://dojoblog.emc.com/unikernels/unik-build-run-unikernels-easy/)
Unik 是 EMC 推出的工具，可以将应用程序源编译为 unikernel（轻量级可引导磁盘镜像）而不是二进制文件。它允许应用程序在各种云提供商、嵌入式设备（IoT） 以及开发人员的笔记本或工作站上安全地部署，资源占用很少。它支持多种 unikernel 类型、处理器架构、管理程序和编排工具，包括 Cloud Foundry、Docker 和 Kubernetes。[Unik 的 GitHub](https://github.com/emc-advanced-dev/unik)
（题图：Pixabay）
---
via: <https://www.linux.com/news/open-cloud-report/2016/guide-open-cloud-age-unikernel>
作者：[SAM DEAN](https://www.linux.com/users/sam-dean) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：Linux 内核中的兄弟打架
|
Daniel Stori
|
http://turnoff.us/geek/brothers-conflict/
|
多线程编程中，如何处理共享的资源是个头疼的事情。
|
/data/attachment/album/201708/13/120543trm2o12c2cptvpj1.png.thumb.jpg
|
/data/attachment/album/201708/13/120543trm2o12c2cptvpj1.png.large.jpg
| false | false | true |
wxy
| false |
[
"内核",
"漫画",
"线程"
] |
极客漫画
|
{
"viewnum": 9490,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "223.81.193.135",
"message": "哈哈！",
"username": "绿色圣光 [Firefox 52.0|GNU/Linux]",
"date": "2017-08-12T16:39:25"
},
{
"postip": "218.17.194.210",
"message": "有意思！！！",
"username": "alpha [Firefox 55.0|Windows XP]",
"date": "2017-08-14T08:49:14"
},
{
"postip": "111.175.127.223",
"message": "直接打PP",
"username": "lovetoheart [Firefox 55.0|Windows 10]",
"date": "2017-08-14T19:17:45"
}
] |
[] |
多线程编程中，如何处理共享的资源是个头疼的事情。
| 2017-08-12T09:38:00 | 2017-08-12T09:38:00 | 8,770 |
/article-8770-1.html
|
多线程编程中，如何处理共享的资源是个头疼的事情。
那边那个蹦起来的就是堆栈被搞乱的，罪魁祸首显然就在这两个背手挨骂的线程当中。
---
via: <http://turnoff.us/geek/brothers-conflict/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者&校对&点评：[wxy](https://github.com/wxy) 合成：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：不要使用 SIGKILL 的原因（看哭了）
|
Daniel Stori
|
http://turnoff.us/geek/dont-sigkill/
|
或许你之前对如何杀死进程并没有感到什么不同，但是，看了这幅漫画，你不觉得那些孩子们（线程）很可怜么——虽然 温和的 SIGTERM 也是要全家干掉的。哭~
|
/data/attachment/album/201708/11/224326ic1j1jpgbkecejg8.png.thumb.jpg
|
/data/attachment/album/201708/11/224326ic1j1jpgbkecejg8.png.large.jpg
| false | false | true |
wxy
| false |
[
"漫画",
"信号"
] |
极客漫画
|
{
"viewnum": 11783,
"commentnum": 6,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "reaper 不应该是 sysadmin，应该是 kernel 才对吧。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-14T10:50:49"
},
{
"postip": "118.122.120.11",
"message": "而且我觉得它的孩子们，在图上描写的更应该是进程，而不是线程。如果是线程的话，那都应该被 KILL 才是。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-14T10:53:05"
},
{
"postip": "118.122.120.11",
"message": "没有注意到图右下角，小企鹅头上的光环。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-14T13:38:51"
},
{
"postip": "101.81.76.109",
"message": "我都是用SIGINT的，如果不起作用在SIGKILL",
"username": "来自上海的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-14T14:33:54"
},
{
"postip": "14.196.205.171",
"message": "好可怜，我以后不敢用 kill 了",
"username": "来自北京的 Chromium 60.0|Ubuntu 用户",
"date": "2017-08-16T21:42:16"
},
{
"postip": "58.63.60.83",
"message": "还以为是命令……原来是开发者技巧啊。",
"username": "文剑一飞 [Chrome 61.0|Windows 10]",
"date": "2017-09-27T23:30:57"
}
] |
[] |
或许你之前对如何杀死进程并没有感到什么不同，但是，看了这幅漫画，你不觉得那些孩子们（线程）很可怜么——虽然 温和的 SIGTERM 也是要全家干掉的。哭~
| 2017-08-14T09:40:00 | 2017-08-14T09:40:00 | 8,771 |
/article-8771-1.html
|
在 Linux 中，通常可以发送一些信号来杀死一个进程，一般用来杀死进程的信号有 SIGTERM、 SIGKILL。但是，如果希望进程合理地终止，就不要发送硬中断信号 SIGKILL，因为该信号是不能拦截的，进程接到该信号之后会马上退出，并没有机会进行现场清理——这包括对线程的关闭等操作。更好的做法是，发送 SIGTERM 信号，这样进程在接到该信号后，可以做一些退出的准备工作。
或许你之前对如何杀死进程并没有感到什么不同，但是，看了这幅漫画，你不觉得那些孩子们（线程）很可怜么——虽然 温和的 SIGTERM 也是要全家干掉的。哭~
---
via: <http://turnoff.us/geek/dont-sigkill/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者&校对&点评：[wxy](https://github.com/wxy) 合成：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
响应式编程与响应式系统
|
Jonas Bonér, Viktor Klang
|
https://www.oreilly.com/ideas/reactive-programming-vs-reactive-systems
|
在恒久的迷惑与过多期待的海洋中，登上一组简单响应式设计原则的小岛。
|
/data/attachment/album/201708/12/183025r3x6x37axwc33e63.jpg.thumb.jpg
|
/data/attachment/album/201708/12/183025r3x6x37axwc33e63.jpg
| true | false | true |
XLCYun
| true |
[
"响应式"
] |
软件开发
|
{
"viewnum": 9032,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在恒久的迷惑与过多期待的海洋中，登上一组简单响应式设计原则的小岛。
| 2017-08-12T18:30:00 | 2017-08-12T18:30:00 | 8,773 |
/article-8773-1.html
|
>
> 在恒久的迷惑与过多期待的海洋中，登上一组简单响应式设计原则的小岛。
>
>
>
>
> 下载 Konrad Malawski 的免费电子书[《为什么选择响应式？企业应用中的基本原则》](http://www.oreilly.com/programming/free/why-reactive.csp?intcmp=il-webops-free-product-na_new_site_reactive_programming_vs_reactive_systems_text_cta)，深入了解更多响应式技术的知识与好处。
>
>
>
自从 2013 年一起合作写了[《响应式宣言》](http://www.reactivemanifesto.org/)之后，我们看着响应式从一种几乎无人知晓的软件构建技术——当时只有少数几个公司的边缘项目使用了这一技术——最后成为<ruby> 中间件领域 <rt> middleware field </rt></ruby>大佬们全平台战略中的一部分。本文旨在定义和澄清响应式各个方面的概念，方法是比较在*响应式编程*风格下和把*响应式系统*视作一个紧密整体的设计方法下编写代码的不同之处。
### 响应式是一组设计原则
响应式技术目前成功的标志之一是“<ruby> 响应式 <rt> reactive </rt></ruby>”成为了一个热词，并且跟一些不同的事物与人联系在了一起——常常伴随着像“<ruby> 流 <rt> streaming </rt></ruby>”、“<ruby> 轻量级 <rt> lightweight </rt></ruby>”和“<ruby> 实时 <rt> real-time </rt></ruby>”这样的词。
举个例子：当我们看到一支运动队时（像棒球队或者篮球队），我们一般会把他们看成一个个单独个体的组合，但是当他们之间碰撞不出火花，无法像一个团队一样高效地协作时，他们就会输给一个“更差劲”的队伍。从这篇文章的角度来看，响应式是一组设计原则，一种关于系统架构与设计的思考方式，一种关于在一个分布式环境下，当<ruby> 实现技术 <rp> （ </rp> <rt> implementation techniques </rt> <rp> ） </rp></ruby>、工具和设计模式都只是一个更大系统的一部分时如何设计的思考方式。
这个例子展示了不经考虑地将一堆软件拼揍在一起——尽管单独来看，这些软件都很优秀——和响应式系统之间的不同。在一个响应式系统中，正是*不同<ruby> 组件 <rp> （ </rp> <rt> parts </rt> <rp> ） </rp></ruby>间的相互作用*让响应式系统如此不同，它使得不同组件能够独立地运作，同时又一致协作从而达到最终想要的结果。
*一个响应式系统* 是一种<ruby> 架构风格 <rp> （ </rp> <rt> architectural style </rt> <rp> ） </rp></ruby>，它允许许多独立的应用结合在一起成为一个单元，共同响应它们所处的环境，同时保留着对单元内其它应用的“感知”——这能够表现为它能够做到<ruby> 放大/缩小规模 <rp> （ </rp> <rt> scale up/down </rt> <rp> ） </rp></ruby>，负载平衡，甚至能够主动地执行这些步骤。
以响应式的风格（或者说，通过响应式编程）写一个软件是可能的；然而，那也不过是拼图中的一块罢了。虽然在上面的提到的各个方面似乎都足以称其为“响应式的”，但仅就其它们自身而言，还不足以让一个*系统*成为响应式的。
当人们在软件开发与设计的语境下谈论“响应式”时，他们的意思通常是以下三者之一：
* 响应式系统（架构与设计）
* 响应式编程（基于声明的事件的）
* 函数响应式编程（FRP）
我们将调查这些做法与技术的意思，特别是前两个。更明确地说，我们会在使用它们的时候讨论它们，例如它们是怎么联系在一起的，从它们身上又能到什么样的好处——特别是在为多核、云或移动架构搭建系统的情境下。
让我们先来说一说函数响应式编程吧，以及我们在本文后面不再讨论它的原因。
### 函数响应式编程（FRP）
<ruby> 函数响应式编程 <rt> Functional reactive programming </rt></ruby>，通常被称作 *FRP*，是最常被误解的。FRP 在二十年前就被 Conal Elliott [精确地定义过了](http://conal.net/papers/icfp97/)了。但是最近这个术语却被错误地<sup> 脚注1</sup> 用来描述一些像 Elm、Bacon.js 的技术以及其它技术中的响应式插件（RxJava、Rx.NET、 RxJS）。许多的<ruby> 库 <rp> （ </rp> <rt> libraries </rt> <rp> ） </rp></ruby>声称他们支持 FRP，事实上他们说的并非*响应式编程*，因此我们不会再进一步讨论它们。
### 响应式编程
<ruby> 响应式编程 <rt> Reactive programming </rt></ruby>，不要把它跟*函数响应式编程*混淆了，它是异步编程下的一个子集，也是一种范式，在这种范式下，由新信息的<ruby> 有效性 <rp> （ </rp> <rt> availability </rt> <rp> ） </rp></ruby>推动逻辑的前进，而不是让<ruby> 一条执行线程 <rp> （ </rp> <rt> a thread-of-execution </rt> <rp> ） </rp></ruby>去推动<ruby> 控制流 <rp> （ </rp> <rt> control flow </rt> <rp> ） </rp></ruby>。
它能够把问题分解为多个独立的步骤，这些独立的步骤可以以异步且<ruby> 非阻塞 <rp> （ </rp> <rt> non-blocking </rt> <rp> ） </rp></ruby>的方式被执行，最后再组合在一起产生一条<ruby> 工作流 <rp> （ </rp> <rt> workflow </rt> <rp> ） </rp></ruby>——它的输入和输出可能是<ruby> 非绑定的 <rp> （ </rp> <rt> unbounded </rt> <rp> ） </rp></ruby>。
<ruby> <a href="http://www.reactivemanifesto.org/glossary#Asynchronous"> “异步地” </a> <rp> （ </rp> <rt> Asynchronous </rt> <rp> ） </rp></ruby>被牛津词典定义为“不在同一时刻存在或发生”，在我们的语境下，它意味着一条消息或者一个事件可发生在任何时刻，也有可能是在未来。这在响应式编程中是非常重要的一项技术，因为响应式编程允许[<ruby> 非阻塞式 <rp> （ </rp> <rt> non-blocking </rt> <rp> ） </rp></ruby>]的执行方式——执行线程在竞争一块共享资源时不会因为<ruby> 阻塞 <rp> （ </rp> <rt> blocking </rt> <rp> ） </rp></ruby>而陷入等待（为了防止执行线程在当前的工作完成之前执行任何其它操作），而是在共享资源被占用的期间转而去做其它工作。<ruby> 阿姆达尔定律 <rp> （ </rp> <rt> Amdahl's Law </rt> <rp> ） </rp></ruby> <sup> 脚注2</sup> 告诉我们，竞争是<ruby> 可伸缩性 <rp> （ </rp> <rt> scalability </rt> <rp> ） </rp></ruby>最大的敌人，所以一个响应式系统应当在极少数的情况下才不得不做阻塞工作。
响应式编程一般是<ruby> 事件驱动 <rp> （ </rp> <rt> event-driven </rt> <rp> ） </rp></ruby>，相比之下，响应式系统则是<ruby> 消息驱动 <rp> （ </rp> <rt> message-driven </rt> <rp> ） </rp></ruby>的——事件驱动与消息驱动之间的差别会在文章后面阐明。
响应式编程库的应用程序接口（API）一般是以下二者之一：
* <ruby> 基于回调的 <rp> （ </rp> <rt> Callback-based </rt> <rp> ） </rp></ruby>—匿名的<ruby> 间接作用 <rp> （ </rp> <rt> side-effecting </rt> <rp> ） </rp></ruby>回调函数被绑定在<ruby> 事件源 <rp> （ </rp> <rt> event sources </rt> <rp> ） </rp></ruby>上，当事件被放入<ruby> 数据流 <rp> （ </rp> <rt> dataflow chain </rt> <rp> ） </rp></ruby>中时，回调函数被调用。
* <ruby> 声明式的 <rp> （ </rp> <rt> Declarative </rt> <rp> ） </rp></ruby>——通过函数的组合，通常是使用一些固定的函数，像 *map*、 *filter*、 *fold* 等等。
大部分的库会混合这两种风格，一般还带有<ruby> 基于流 <rp> （ </rp> <rt> stream-based </rt> <rp> ） </rp></ruby>的<ruby> 操作符 <rp> （ </rp> <rt> operators </rt> <rp> ） </rp></ruby>，像 windowing、 counts、 triggers。
说响应式编程跟<ruby> <a href="https://en.wikipedia.org/wiki/Dataflow_programming"> 数据流编程 </a> <rp> （ </rp> <rt> dataflow programming </rt> <rp> ） </rp></ruby>有关是很合理的，因为它强调的是*数据流*而不是*控制流*。
举几个为这种编程技术提供支持的的编程抽象概念：
* [Futures/Promises](https://en.wikipedia.org/wiki/Futures_and_promises)——一个值的容器，具有<ruby> 读共享/写独占 <rp> （ </rp> <rt> many-read/single-write </rt> <rp> ） </rp></ruby>的语义，即使变量尚不可用也能够添加异步的值转换操作。
* <ruby> 流 <rp> （ </rp> <rt> streams </rt> <rp> ） </rp></ruby> - [响应式流](http://reactive-streams.org/)——无限制的数据处理流，支持异步，非阻塞式，支持多个源与目的的<ruby> 反压转换管道 <rp> （ </rp> <rt> back-pressured transformation pipelines </rt> <rp> ） </rp></ruby>。
* [数据流变量](https://en.wikipedia.org/wiki/Oz_(programming_language)#Dataflow_variables_and_declarative_concurrency)——依赖于输入、<ruby> 过程 <rp> （ </rp> <rt> procedures </rt> <rp> ） </rp></ruby>或者其它单元的<ruby> 单赋值变量 <rp> （ </rp> <rt> single assignment variables </rt> <rp> ） </rp></ruby>（存储单元），它能够自动更新值的改变。其中一个应用例子是表格软件——一个单元的值的改变会像涟漪一样荡开，影响到所有依赖于它的函数，顺流而下地使它们产生新的值。
在 JVM 中，支持响应式编程的流行库有 Akka Streams、Ratpack、Reactor、RxJava 和 Vert.x 等等。这些库实现了响应式编程的规范，成为 JVM 上响应式编程库之间的<ruby> 互通标准 <rp> （ </rp> <rt> standard for interoperability </rt> <rp> ） </rp></ruby>，并且根据它自身的叙述是“……一个为如何处理非阻塞式反压异步流提供标准的倡议”。
响应式编程的基本好处是：提高多核和多 CPU 硬件的计算资源利用率；根据阿姆达尔定律以及引申的 <ruby> Günther 的通用可伸缩性定律 <rp> （ </rp> <rt> Günther’s Universal Scalability Law </rt> <rp> ） </rp></ruby> <sup> 脚注3</sup> ，通过减少<ruby> 序列化点 <rp> （ </rp> <rt> serialization points </rt> <rp> ） </rp></ruby>来提高性能。
另一个好处是开发者生产效率，传统的编程范式都尽力想提供一个简单直接的可持续的方法来处理异步非阻塞式计算和 I/O。在响应式编程中，因活动(active)组件之间通常不需要明确的协作，从而也就解决了其中大部分的挑战。
响应式编程真正的发光点在于组件的创建跟工作流的组合。为了在异步执行上取得最大的优势，把<ruby> <a href="http://www.reactivemanifesto.org/glossary#Back-Pressure"> 反压 </a> <rp> （ </rp> <rt> back-pressure </rt> <rp> ） </rp></ruby>加进来是很重要，这样能避免过度使用，或者确切地说，避免无限度的消耗资源。
尽管如此，响应式编程在搭建现代软件上仍然非常有用，为了在更高层次上<ruby> 理解 <rp> （ </rp> <rt> reason about </rt> <rp> ） </rp></ruby>一个系统，那么必须要使用到另一个工具：<ruby> 响应式架构 <rt> reactive architecture </rt></ruby>——设计响应式系统的方法。此外，要记住编程范式有很多，而响应式编程仅仅只是其中一个，所以如同其它工具一样，响应式编程并不是万金油，它不意图适用于任何情况。
### 事件驱动 vs. 消息驱动
如上面提到的，响应式编程——专注于短时间的数据流链条上的计算——因此倾向于*事件驱动*，而响应式系统——关注于通过分布式系统的通信和协作所得到的弹性和韧性——则是[*消息驱动的*](http://www.reactivemanifesto.org/glossary#Message-Driven) <sup> 脚注4</sup>（或者称之为 <ruby> 消息式 <rp> （ </rp> <rt> messaging </rt> <rp> ） </rp></ruby> 的）。
一个拥有<ruby> 长期存活的可寻址 <rp> （ </rp> <rt> long-lived addressable </rt> <rp> ） </rp></ruby>组件的消息驱动系统跟一个事件驱动的数据流驱动模型的不同在于，消息具有固定的导向，而事件则没有。消息会有明确的（一个）去向，而事件则只是一段等着被<ruby> 观察 <rp> （ </rp> <rt> observe </rt> <rp> ） </rp></ruby>的信息。另外，<ruby> 消息式 <rp> （ </rp> <rt> messaging </rt> <rp> ） </rp></ruby>更适用于异步，因为消息的发送与接收和发送者和接收者是分离的。
响应式宣言中的术语表定义了两者之间[概念上的不同](http://www.reactivemanifesto.org/glossary#Message-Driven)：
>
> 一条消息就是一则被送往一个明确目的地的数据。一个事件则是达到某个给定状态的组件发出的一个信号。在一个消息驱动系统中，可寻址到的接收者等待消息的到来然后响应它，否则保持休眠状态。在一个事件驱动系统中，通知的监听者被绑定到消息源上，这样当消息被发出时它就会被调用。这意味着一个事件驱动系统专注于可寻址的事件源而消息驱动系统专注于可寻址的接收者。
>
>
>
分布式系统需要通过消息在网络上传输进行交流，以实现其沟通基础，与之相反，事件的发出则是本地的。在底层通过发送包裹着事件的消息来搭建跨网络的事件驱动系统的做法很常见。这样能够维持在分布式环境下事件驱动编程模型的相对简易性，并且在某些特殊的和合理的范围内的使用案例上工作得很好。
然而，这是有利有弊的：在编程模型的抽象性和简易性上得一分，在控制上就减一分。消息强迫我们去拥抱分布式系统的真实性和一致性——像<ruby> 局部错误 <rp> （ </rp> <rt> partial failures </rt> <rp> ） </rp></ruby>，<ruby> 错误侦测 <rp> （ </rp> <rt> failure detection </rt> <rp> ） </rp></ruby>，<ruby> 丢弃/复制/重排序 <rp> （ </rp> <rt> dropped/duplicated/reordered </rt> <rp> ） </rp></ruby>消息，最后还有一致性，管理多个并发真实性等等——然后直面它们，去处理它们，而不是像过去无数次一样，藏在一个蹩脚的抽象面罩后——假装网络并不存在(例如EJB、 [RPC](https://christophermeiklejohn.com/pl/2016/04/12/rpc.html)、 [CORBA](https://queue.acm.org/detail.cfm?id=1142044) 和 [XA](https://cs.brown.edu/courses/cs227/archives/2012/papers/weaker/cidr07p15.pdf))。
这些在语义学和适用性上的不同在应用设计中有着深刻的含义，包括分布式系统的<ruby> 复杂性 <rp> （ </rp> <rt> complexity </rt> <rp> ） </rp></ruby>中的 <ruby> 弹性 <rp> （ </rp> <rt> resilience </rt> <rp> ） </rp></ruby>、 <ruby> 韧性 <rp> （ </rp> <rt> elasticity </rt> <rp> ） </rp></ruby>、<ruby> 移动性 <rp> （ </rp> <rt> mobility </rt> <rp> ） </rp></ruby>、<ruby> 位置透明性 <rp> （ </rp> <rt> location transparency </rt> <rp> ） </rp></ruby>和 <ruby> 管理 <rp> （ </rp> <rt> management </rt> <rp> ） </rp></ruby>，这些在文章后面再进行介绍。
在一个响应式系统中，特别是使用了响应式编程技术的，这样的系统中就即有事件也有消息——一个是用于沟通的强大工具（消息），而另一个则呈现现实（事件）。
### 响应式系统和架构
*响应式系统* —— 如同在《响应式宣言》中定义的那样——是一组用于搭建现代系统——已充分准备好满足如今应用程序所面对的不断增长的需求的现代系统——的架构设计原则。
响应式系统的原则决对不是什么新东西，它可以被追溯到 70 和 80 年代 Jim Gray 和 Pat Helland 在<ruby> <a href="http://www.hpl.hp.com/techreports/tandem/TR-86.2.pdf"> 串级系统 </a> <rp> （ </rp> <rt> Tandem System </rt> <rp> ） </rp></ruby>上和 Joe aomstrong 和 Robert Virding 在 [Erland](http://erlang.org/download/armstrong_thesis_2003.pdf) 上做出的重大工作。然而，这些人在当时都超越了时代，只有到了最近 5 - 10 年，技术行业才被不得不反思当前企业系统最好的开发实践活动并且学习如何将来之不易的响应式原则应用到今天这个多核、云计算和物联网的世界中。
响应式系统的基石是<ruby> 消息传递 <rp> （ </rp> <rt> message-passing </rt> <rp> ） </rp></ruby>，消息传递为两个组件之间创建一条暂时的边界，使得它们能够在 *时间* 上分离——实现并发性——和 <ruby> 空间 <rp> （ </rp> <rt> space </rt> <rp> ） </rp></ruby> ——实现<ruby> 分布式 <rp> （ </rp> <rt> distribution </rt> <rp> ） </rp></ruby>与<ruby> 移动性 <rp> （ </rp> <rt> mobility </rt> <rp> ） </rp></ruby>。这种分离是两个组件完全<ruby> <a href="http://www.reactivemanifesto.org/glossary#Isolation"> 隔离 </a> <rp> （ </rp> <rt> isolation </rt> <rp> ） </rp></ruby>以及实现<ruby> 弹性 <rp> （ </rp> <rt> resilience </rt> <rp> ） </rp></ruby>和<ruby> 韧性 <rp> （ </rp> <rt> elasticity </rt> <rp> ） </rp></ruby>基础的必需条件。
### 从程序到系统
这个世界的连通性正在变得越来越高。我们不再构建 *程序* ——为单个操作子来计算某些东西的端到端逻辑——而更多地在构建 *系统* 了。
系统从定义上来说是复杂的——每一部分都包含多个组件，每个组件的自身或其子组件也可以是一个系统——这意味着软件要正常工作已经越来越依赖于其它软件。
我们今天构建的系统会在多个计算机上操作，小型的或大型的，或少或多，相近的或远隔半个地球的。同时，由于人们的生活正变得越来越依赖于系统顺畅运行的有效性，用户的期望也变得越得越来越难以满足。
为了实现用户——和企业——能够依赖的系统，这些系统必须是 <ruby> 灵敏的 <rp> （ </rp> <rt> responsive </rt> <rp> ） </rp></ruby> ，这样无论是某个东西提供了一个正确的响应，还是当需要一个响应时响应无法使用，都不会有影响。为了达到这一点，我们必须保证在错误( *弹性* )和欠载( *韧性* )下，系统仍然能够保持灵敏性。为了实现这一点，我们把系统设计为 *消息驱动的* ，我们称其为 *响应式系统* 。
### 响应式系统的弹性
弹性是与 *错误下* 的<ruby> 灵敏性 <rp> （ </rp> <rt> responsiveness </rt> <rp> ） </rp></ruby>有关的，它是系统内在的功能特性，是需要被设计的东西，而不是能够被动的加入系统中的东西。弹性是大于容错性的——弹性无关于<ruby> 故障退化 <rp> （ </rp> <rt> graceful degradation </rt> <rp> ） </rp></ruby>——虽然故障退化对于系统来说是很有用的一种特性——与弹性相关的是与从错误中完全恢复达到 *自愈* 的能力。这就需要组件的隔离以及组件对错误的包容，以免错误散播到其相邻组件中去——否则，通常会导致灾难性的连锁故障。
因此构建一个弹性的、<ruby> 自愈 <rp> （ </rp> <rt> self-healing </rt> <rp> ） </rp></ruby>系统的关键是允许错误被：容纳、具体化为消息，发送给其他（担当<ruby> 监管者 <rp> （ </rp> <rt> supervisors </rt> <rp> ） </rp></ruby>）的组件，从而在错误组件之外修复出一个安全环境。在这，消息驱动是其促成因素：远离高度耦合的、脆弱的深层嵌套的同步调用链，大家长期要么学会忍受其煎熬或直接忽略。解决的想法是将调用链中的错误管理分离，将客户端从处理服务端错误的责任中解放出来。
### 响应式系统的韧性
<ruby> <a href="http://www.reactivemanifesto.org/glossary#Elasticity"> 韧性 </a> <rp> （ </rp> <rt> Elasticity </rt> <rp> ） </rp></ruby>是关于 *欠载下的<ruby> 灵敏性 <rp> （ </rp> <rt> responsiveness </rt> <rp> ） </rp></ruby>* 的——意味着一个系统的吞吐量在资源增加或减少时能够自动地相应<ruby> 增加或减少 <rp> （ </rp> <rt> scales up or down </rt> <rp> ） </rp></ruby>（同样能够<ruby> 向内或外扩展 <rp> （ </rp> <rt> scales in or out </rt> <rp> ） </rp></ruby>）以满足不同的需求。这是利用云计算承诺的特性所必需的因素：使系统利用资源更加有效，成本效益更佳，对环境友好以及实现按次付费。
系统必须能够在不重写甚至不重新设置的情况下，适应性地——即无需介入自动伸缩——响应状态及行为，沟通负载均衡，<ruby> 故障转移 <rp> （ </rp> <rt> failover </rt> <rp> ） </rp></ruby>，以及升级。实现这些的就是 <ruby> 位置透明性 <rp> （ </rp> <rt> location transparency </rt> <rp> ） </rp></ruby>：使用同一个方法，同样的编程抽象，同样的语义，在所有向度中<ruby> 伸缩 <rp> （ </rp> <rt> scaling </rt> <rp> ） </rp></ruby>系统的能力——从 CPU 核心到数据中心。
如同《响应式宣言》所述：
>
> 一个极大地简化问题的关键洞见在于意识到我们都在使用分布式计算。无论我们的操作系统是运行在一个单一结点上（拥有多个独立的 CPU，并通过 QPI 链接进行交流）,还是在一个<ruby> 节点集群 <rp> （ </rp> <rt> cluster of nodes </rt> <rp> ） </rp></ruby>（独立的机器，通过网络进行交流)上。拥抱这个事实意味着在垂直方向上多核的伸缩与在水平方面上集群的伸缩并无概念上的差异。在空间上的解耦 [...]，是通过异步消息传送以及运行时实例与其引用解耦从而实现的，这就是我们所说的位置透明性。
>
>
>
因此，不论接收者在哪里，我们都以同样的方式与它交流。唯一能够在语义上等同实现的方式是消息传送。
### 响应式系统的生产效率
既然大多数的系统生来即是复杂的，那么其中一个最重要的点即是保证一个系统架构在开发和维护组件时，最小程度地减低生产效率，同时将操作的 <ruby> 偶发复杂性 <rp> （ </rp> <rt> accidental complexity </rt> <rp> ） </rp></ruby>降到最低。
这一点很重要，因为在一个系统的生命周期中——如果系统的设计不正确——系统的维护会变得越来越困难，理解、定位和解决问题所需要花费时间和精力会不断地上涨。
响应式系统是我们所知的最具 *生产效率* 的系统架构（在多核、云及移动架构的背景下）：
* 错误的隔离为组件与组件之间裹上[舱壁](http://skife.org/architecture/fault-tolerance/2009/12/31/bulkheads.html)（LCTT 译注：当船遭到损坏进水时，舱壁能够防止水从损坏的船舱流入其他船舱），防止引发连锁错误，从而限制住错误的波及范围以及严重性。
* 监管者的层级制度提供了多个等级的防护，搭配以自我修复能力，避免了许多曾经在侦查(inverstigate)时引发的操作<ruby> 代价 <rp> （ </rp> <rt> cost </rt> <rp> ） </rp></ruby>——大量的<ruby> 瞬时故障 <rp> （ </rp> <rt> transient failures </rt> <rp> ） </rp></ruby>。
* 消息传送和位置透明性允许组件被卸载下线、代替或<ruby> 重新布线 <rp> （ </rp> <rt> rerouted </rt> <rp> ） </rp></ruby>同时不影响终端用户的使用体验，并降低中断的代价、它们的相对紧迫性以及诊断和修正所需的资源。
* 复制减少了数据丢失的风险，减轻了数据<ruby> 检索 <rp> （ </rp> <rt> retrieval </rt> <rp> ） </rp></ruby>和存储的有效性错误的影响。
* 韧性允许在使用率波动时保存资源，允许在负载很低时，最小化操作开销，并且允许在负载增加时，最小化<ruby> 运行中断 <rp> （ </rp> <rt> outgae </rt> <rp> ） </rp></ruby>或<ruby> 紧急投入 <rp> （ </rp> <rt> urgent investment </rt> <rp> ） </rp></ruby>伸缩性的风险。
因此，响应式系统使<ruby> 生成系统 <rp> （ </rp> <rt> creation systems </rt> <rp> ） </rp></ruby>很好的应对错误、随时间变化的负载——同时还能保持低运营成本。
### 响应式编程与响应式系统的关联
响应式编程是一种管理<ruby> 内部逻辑 <rp> （ </rp> <rt> internal logic </rt> <rp> ） </rp></ruby>和<ruby> 数据流转换 <rp> （ </rp> <rt> dataflow transformation </rt> <rp> ） </rp></ruby>的好技术，在本地的组件中，做为一种优化代码清晰度、性能以及资源利用率的方法。响应式系统，是一组架构上的原则，旨在强调分布式信息交流并为我们提供一种处理分布式系统弹性与韧性的工具。
只使用响应式编程常遇到的一个问题，是一个事件驱动的基于回调的或声明式的程序中两个计算阶段的<ruby> 高度耦合 <rp> （ </rp> <rt> tight coupling </rt> <rp> ） </rp></ruby>，使得 *弹性* 难以实现，因此时它的转换链通常存活时间短，并且它的各个阶段——回调函数或<ruby> 组合子 <rp> （ </rp> <rt> combinator </rt> <rp> ） </rp></ruby>——是匿名的，也就是不可寻址的。
这意味着，它通常在内部处理成功与错误的状态而不会向外界发送相应的信号。这种寻址能力的缺失导致单个<ruby> 阶段 <rp> （ </rp> <rt> stages </rt> <rp> ） </rp></ruby>很难恢复，因为它通常并不清楚异常应该，甚至不清楚异常可以，发送到何处去。
另一个与响应式系统方法的不同之处在于单纯的响应式编程允许 *时间* 上的<ruby> 解耦 <rp> （ </rp> <rt> decoupling </rt> <rp> ） </rp></ruby>，但不允许 *空间* 上的（除非是如上面所述的，在底层通过网络传送消息来<ruby> 分发 <rp> （ </rp> <rt> distribute </rt> <rp> ） </rp></ruby>数据流）。正如叙述的，在时间上的解耦使 *并发性* 成为可能，但是是空间上的解耦使 <ruby> 分布 <rp> （ </rp> <rt> distribution </rt> <rp> ） </rp></ruby>和<ruby> 移动性 <rp> （ </rp> <rt> mobility </rt> <rp> ） </rp></ruby> （使得不仅仅静态拓扑可用，还包括了动态拓扑）成为可能的——而这些正是 *韧性* 所必需的要素。
位置透明性的缺失使得很难以韧性方式对一个基于适应性响应式编程技术的程序进行向外扩展，因为这样就需要分附加工具，例如<ruby> 消息总线 <rp> （ </rp> <rt> message bus </rt> <rp> ） </rp></ruby>，<ruby> 数据网格 <rp> （ </rp> <rt> data grid </rt> <rp> ） </rp></ruby>或者在顶层的<ruby> 定制网络协议 <rp> （ </rp> <rt> bespoke network protocol </rt> <rp> ） </rp></ruby>。而这点正是响应式系统的消息驱动编程的闪光的地方，因为它是一个包含了其编程模型和所有伸缩向度语义的交流抽象概念，因此降低了复杂性与认知超载。
对于基于回调的编程，常会被提及的一个问题是写这样的程序或许相对来说会比较简单，但最终会引发一些真正的后果。
例如，对于基于匿名回调的系统，当你想理解它们，维护它们或最重要的是在<ruby> 生产供应中断 <rp> （ </rp> <rt> production outages </rt> <rp> ） </rp></ruby>或错误行为发生时，你想知道到底发生了什么、发生在哪以及为什么发生，但此时它们只提供极少的内部信息。
为响应式系统设计的库与平台（例如 [Akka](http://akka.io/) 项目和 [Erlang](https://www.erlang.org/) 平台）学到了这一点，它们依赖于那些更容易理解的长期存活的可寻址组件。当错误发生时，根据导致错误的消息可以找到唯一的组件。当可寻址的概念存在组件模型的核心中时，<ruby> 监控方案 <rp> （ </rp> <rt> monitoring solution </rt> <rp> ） </rp></ruby>就有了一个 *有意义* 的方式来呈现它收集的数据——利用<ruby> 传播 <rp> （ </rp> <rt> propagated </rt> <rp> ） </rp></ruby>的身份标识。
一个好的编程范式的选择，一个选择实现像可寻址能力和错误管理这些东西的范式，已经被证明在生产中是无价的，因它在设计中承认了现实并非一帆风顺，*接受并拥抱错误的出现* 而不是毫无希望地去尝试避免错误。
总而言之，响应式编程是一个非常有用的实现技术，可以用在响应式架构当中。但是记住这只能帮助管理一部分：异步且非阻塞执行下的数据流管理——通常只在单个结点或服务中。当有多个结点时，就需要开始认真地考虑像<ruby> 数据一致性 <rp> （ </rp> <rt> data consistency </rt> <rp> ） </rp></ruby>、<ruby> 跨结点沟通 <rp> （ </rp> <rt> cross-node communication </rt> <rp> ） </rp></ruby>、<ruby> 协调 <rp> （ </rp> <rt> coordination </rt> <rp> ） </rp></ruby>、<ruby> 版本控制 <rp> （ </rp> <rt> versioning </rt> <rp> ） </rp></ruby>、<ruby> 编制 <rp> （ </rp> <rt> orchestration </rt> <rp> ） </rp></ruby>、<ruby> 错误管理 <rp> （ </rp> <rt> failure management </rt> <rp> ） </rp></ruby>、<ruby> 关注与责任 <rp> （ </rp> <rt> concerns and responsibilities </rt> <rp> ） </rp></ruby>分离等等的东西——也即是：系统架构。
因此，要最大化响应式编程的价值，就把它作为构建响应式系统的工具来使用。构建一个响应式系统需要的不仅是在一个已存在的遗留下来的<ruby> 软件栈 <rp> （ </rp> <rt> software stack </rt> <rp> ） </rp></ruby>上抽象掉特定的操作系统资源和少量的异步 API 和<ruby> <a href="http://martinfowler.com/bliki/CircuitBreaker.html"> 断路器 </a> <rp> （ </rp> <rt> circuit breakers </rt> <rp> ） </rp></ruby>。此时应该拥抱你在创建一个包含多个服务的分布式系统这一事实——这意味着所有东西都要共同合作，提供一致性与灵敏的体验，而不仅仅是如预期工作，但同时还要在发生错误和不可预料的负载下正常工作。
### 总结
企业和中间件供应商在目睹了应用响应式所带来的企业利润增长后，同样开始拥抱响应式。在本文中，我们把响应式系统做为企业最终目标进行描述——假设了多核、云和移动架构的背景——而响应式编程则从中担任重要工具的角色。
响应式编程在内部逻辑及数据流转换的组件层次上为开发者提高了生产率——通过性能与资源的有效利用实现。而响应式系统在构建 <ruby> 原生云 <rp> （ </rp> <rt> cloud native </rt> <rp> ） </rp></ruby> 和其它大型分布式系统的系统层次上为架构师及 DevOps 从业者提高了生产率——通过弹性与韧性。我们建议在响应式系统设计原则中结合响应式编程技术。
### 脚注
>
> 1. 参考 Conal Elliott，FRP 的发明者，见[这个演示](https://begriffs.com/posts/2015-07-22-essence-of-frp.html)。
> 2. [Amdahl 定律](https://en.wikipedia.org/wiki/Amdahl%2527s_law)揭示了系统理论上的加速会被一系列的子部件限制，这意味着系统在新的资源加入后会出现<ruby> 收益递减 <rp> （ </rp> <rt> diminishing returns </rt> <rp> ） </rp></ruby>。
> 3. Neil Günter 的<ruby> <a href="http://www.perfdynamics.com/Manifesto/USLscalability.html"> 通用可伸缩性定律 </a> <rp> （ </rp> <rt> Universal Scalability Law </rt> <rp> ） </rp></ruby>是理解并发与分布式系统的竞争与协作的重要工具，它揭示了当新资源加入到系统中时，保持一致性的开销会导致不好的结果。
> 4. 消息可以是同步的（要求发送者和接受者同时存在），也可以是异步的（允许他们在时间上解耦）。其语义上的区别超出本文的讨论范围。
>
>
>
---
via: <https://www.oreilly.com/ideas/reactive-programming-vs-reactive-systems>
作者：[Jonas Bonér](https://www.oreilly.com/people/e0b57-jonas-boner)， [Viktor Klang](https://www.oreilly.com/people/f96106d4-4ce6-41d9-9d2b-d24590598fcd) 译者：[XLCYun](https://github.com/XLCYun) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 组织编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一篇缺失的 TypeScript 介绍
|
James Henry
|
https://toddmotto.com/typescript-the-missing-introduction
|
本文的主旨是为了介绍我们是如何看待 TypeScript 的以及它在加强 JavaScript 开发中所起的作用。
我们也将尽可能地给出那些类型和编译方面的那些时髦词汇的准确定义。
|
/data/attachment/album/201708/13/132032snqnbgkvt7spgtgb.png.thumb.jpg
|
/data/attachment/album/201708/13/132032snqnbgkvt7spgtgb.png
| true | false | true |
MonkeyDEcho
| false |
[
"JavaScript",
"TypeScript"
] |
软件开发
|
{
"viewnum": 6408,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文的主旨是为了介绍我们是如何看待 TypeScript 的以及它在加强 JavaScript 开发中所起的作用。
我们也将尽可能地给出那些类型和编译方面的那些时髦词汇的准确定义。
| 2017-08-13T13:24:07 | 2017-08-13T13:24:07 | 8,774 |
/article-8774-1.html
|
**下文是 James Henry（[@MrJamesHenry](https://twitter.com/MrJamesHenry)）所提交的内容。我是 ESLint 核心团队的一员，也是 TypeScript 布道师。我正在和 Todd 在 [UltimateAngular](https://ultimateangular.com/courses) 平台上合作发布 Angular 和 TypeScript 的精品课程。**
>
> 本文的主旨是为了介绍我们是如何看待 TypeScript 的以及它在加强 JavaScript 开发中所起的作用。
>
>
> 我们也将尽可能地给出那些类型和编译方面的那些时髦词汇的准确定义。
>
>
>
TypeScript 强大之处远远不止这些，本篇文章无法涵盖，想要了解更多请阅读[官方文档](http://www.typescriptlang.org/docs)，或者学习 [UltimateAngular 上的 TypeScript 课程](https://ultimateangular.com/courses#typescript) ，从初学者成为一位 TypeScript 高手。
### 背景
TypeScript 是个出乎意料强大的工具，而且它真的很容易掌握。
然而，TypeScript 可能比 JavaScript 要更为复杂一些，因为 TypeScript 可能向我们同时引入了一系列以前没有考虑过的 JavaScript 程序相关的技术概念。
每当我们谈论到类型、编译器等这些概念的时候，你会发现很快会变的不知所云起来。
这篇文章就是一篇为了解答你需要知道的许许多多不知所云的概念，来帮助你 TypeScript 快速入门的教程，可以让你轻松自如的应对这些概念。
### 关键知识的掌握
在 Web 浏览器中运行我们的代码这件事或许使我们对它是如何工作的产生一些误解，“它不用经过编译，是吗？”，“我敢肯定这里面是没有类型的...”
更有意思的是，上述的说法既是正确的也是不正确的，这取决于上下文环境和我们是如何定义这些概念的。
首先，我们要作的是明确这些。
#### JavaScript 是解释型语言还是编译型语言？
传统意义上，程序员经常将自己的程序编译之后运行出结果就认为这种语言是编译型语言。
>
> 从初学者的角度来说，编译的过程就是将我们自己编辑好的高级语言程序转换成机器实际运行的格式。
>
>
>
就像 Go 语言，可以使用 `go build` 的命令行工具编译 .go 的文件，将其编译成代码的低级形式，它可以直接执行、运行。
```
# We manually compile our .go file into something we can run
# using the command line tool "go build"
go build ultimate-angular.go
# ...then we execute it!
./ultimate-angular
```
作为一个 JavaScript 程序员（这一刻，请先忽略我们对新一代构建工具和模块加载程序的热爱），我们在日常的 JavaScript 开发中并没有编译的这一基本步骤，
我们写一些 JavaScript 代码，把它放在浏览器的 `<script>` 标签中，它就能运行了（或者在服务端环境运行，比如：node.js）。
**好吧，因此 JavaScript 没有进行过编译，那它一定是解释型语言了，是吗？**
实际上，我们能够确定的一点是，JavaScript 不是我们自己编译的，现在让我们简单的回顾一个简单的解释型语言的例子，再来谈 JavaScript 的编译问题。
>
> 解释型计算机语言的执行的过程就像人们看书一样，从上到下、一行一行的阅读。
>
>
>
我们所熟知的解释型语言的典型例子是 bash 脚本。我们终端中的 bash 解释器逐行读取我们的命令并且执行它。
现在我们回到 JavaScript 是解释执行还是编译执行的讨论中，我们要将逐行读取和逐行执行程序分开理解（对“解释型”的简单理解），不要混在一起。
以此代码为例：
```
hello();
function hello(){
console.log("Hello")
}
```
这是真正意义上 JavaScript 输出 Hello 单词的程序代码，但是，在 `hello()` 在我们定义它之前就已经使用了这个函数，这是简单的逐行执行办不到的，因为 `hello()` 在第一行没有任何意义的，直到我们在第二行声明了它。
像这样在 JavaScript 是存在的，因为我们的代码实际上在执行之前就被所谓的“JavaScript 引擎”或者是“特定的编译环境”编译过，这个编译的过程取决于具体的实现（比如，使用 V8 引擎的 node.js 和 Chome 就和使用 SpiderMonkey 的 FireFox 就有所不同）。
在这里，我们不会在进一步的讲解编译型执行和解释型执行微妙之处（这里的定义已经很好了）。
>
> 请务必记住，我们编写的 JavaScript 代码已经不是我们的用户实际执行的代码了，即使是我们简单地将其放在 HTML 中的 `<script>` ，也是不一样的。
>
>
>
#### 运行时间 VS 编译时间
现在我们已经正确理解了编译和运行是两个不同的阶段，那“<ruby> 运行阶段 <rt> Run Time </rt></ruby>”和“<ruby> 编译阶段 <rt> Compile Time </rt></ruby>”理解起来也就容易多了。
编译阶段，就是我们在我们的编辑器或者 IDE 当中的代码转换成其它格式的代码的阶段。
运行阶段，就是我们程序实际执行的阶段，例如：上面的 `hello()` 函数就执行在“运行阶段”。
#### TypeScript 编译器
现在我们了解了程序的生命周期中的关键阶段，接下来我们可以介绍 TypeScript 编译器了。
TypeScript 编译器是帮助我们编写代码的关键。比如，我们不需将 JavaScript 代码包含到 `<script>` 标签当中，只需要通过 TypeScript 编译器传递它，就可以在运行程序之前得到改进程序的建议。
>
> 我们可以将这个新的步骤作为我们自己的个人“编译阶段”，这将在我们的程序抵达 JavaScript 主引擎之前，确保我们的程序是以我们预期的方式编写的。
>
>
>
它与上面 Go 语言的实例类似，但是 TypeScript 编译器只是基于我们编写程序的方式提供提示信息，并不会将其转换成低级的可执行文件，它只会生成纯 JavaScript 代码。
```
# One option for passing our source .ts file through the TypeScript
# compiler is to use the command line tool "tsc"
tsc ultimate-angular.ts
# ...this will produce a .js file of the same name
# i.e. ultimate-angular.js
```
在[官方文档](http://www.typescriptlang.org/docs)中，有许多关于将 TypeScript 编译器以各种方式融入到你的现有工作流程中的文章。这些已经超出本文范围。
#### 动态类型与静态类型
就像对比编译程序与解释程序一样，动态类型与静态类型的对比在现有的资料中也是极其模棱两可的。
让我们先回顾一下我们在 JavaScript 中对于类型的理解。
我们的代码如下：
```
var name = 'James';
var sum = 1 + 2;
```
我们如何给别人描述这段代码？
“我们声明了一个变量 `name`，它被分配了一个 “James” 的**字符串**，然后我们又申请了一个变量 `sum`，它被分配了一个**数字** 1 和**数字** 2 的求和的数值结果。”
即使在这样一个简单的程序中，我们也使用了两个 JavaScript 的基本类型：`String` 和 `Number`。
就像上面我们讲编译一样，我们不会陷入编程语言类型的学术细节当中，关键是要理解在 JavaScript 中类型表示的是什么，并扩展到 TypeScript 的类型的理解上。
从每夜拜读的最新 ECMAScript 规范中我们可以学到（LOL, JK - “wat’s an ECMA?”），它大量引用了 JavaScript 的类型及其用法。
直接引自官方规范：
>
> ECMAScript 语言的类型取决于使用 ECMAScript 语言的 ECMAScript 程序员所直接操作的值。
>
>
> ECMAScript 语言的类型有 Undefined、Null、Boolean、String、Symbol、Number 和 Object。
>
>
>
我们可以看到，JavaScript 语言有 7 种正式类型，其中我们在我们现在程序中使用了 6 种（Symbol 首次在 ES2015 中引入，也就是 ES6）。
现在我们来深入一点看上面的 JavaScript 代码中的 “name 和 sum”。
我们可以把我们当前被分配了字符串“James”的变量 `name` 重新赋值为我们的第二个变量 sum 的当前值，目前是数字 3。
```
var name = 'James';
var sum = 1 + 2;
name = sum;
```
该 `name` 变量开始“存有”一个字符串，但现在它“存有”一个数字。这凸显了 JavaScript 中变量和类型的基本特性：
“James” 值一直是字符串类型，而 `name` 变量可以分配任何类型的值。和 `sum` 赋值的情况相同，1 是一个数字类型，`sum` 变量可以分配任何可能的值。
>
> 在 JavaScript 中，值是具有类型的，而变量是可以随时保存任何类型的值。
>
>
>
这也恰好是一个“动态类型语言”的定义。
相比之下，我们可以将“静态类型语言”视为我们可以（也必须）将类型信息与特定变量相关联的语言：
```
var name: string ＝ ‘James’;
```
在这段代码中，我们能够更好地显式声明我们对变量 `name` 的意图，我们希望它总是用作一个字符串。
你猜怎么着？我们刚刚看到我们的第一个 TypeScript 程序。
当我们<ruby> 反思reflect</ruby>我们自己的代码（非编程方面的双关语“反射”）时，我们可以得出的结论，即使我们使用动态语言（如 JavaScript），在几乎所有的情况下，当我们初次定义变量和函数参数时，我们应该有非常明确的使用意图。如果这些变量和参数被重新赋值为与我们原先赋值不同类型的值，那么有可能某些东西并不是我们预期的那样工作的。
>
> 作为 JavaScript 开发者，TypeScript 的静态类型注释给我们的一个巨大的帮助，它能够清楚地表达我们对变量的意图。
>
>
> 这种改进不仅有益于 TypeScript 编译器，还可以让我们的同事和将来的自己明白我们的代码。代码是用来读的。
>
>
>
### TypeScript 在我们的 JavaScript 工作流程中的作用
我们已经开始看到“为什么经常说 TypeScript 只是 JavaScript + 静态类型”的说法了。`: string` 对于我们的 `name` 变量就是我们所谓的“类型注释”，在编译时被使用（换句话说，当我们让代码通过 TypeScript 编译器时），以确保其余的代码符合我们原来的意图。
我们再来看看我们的程序，并添加显式注释，这次是我们的 `sum` 变量：
```
var name: string = 'James';
var sum: number = 1 + 2;
name = sum;
```
如果我们使用 TypeScript 编译器编译这个代码，我们现在就会收到一个在 `name = sum` 这行的错误： `Type 'number' is not assignable to type 'string'`，我们的这种“偷渡”被警告，我们执行的代码可能有问题。
>
> 重要的是，如果我们想要继续执行，我们可以选择忽略 TypeScript 编译器的错误，因为它只是在将 JavaScript 代码发送给我们的用户之前给我们反馈的工具。
>
>
>
TypeScript 编译器为我们输出的最终 JavaScript 代码将与上述原始源代码完全相同：
```
var name = 'James';
var sum = 1 + 2;
name = sum;
```
类型注释全部为我们自动删除了，现在我们可以运行我们的代码了。
>
> 注意：在此示例中，即使我们没有提供显式类型注释的 `: string` 和 `: number` ，TypeScript 编译器也可以为我们提供完全相同的错误 。
>
>
> TypeScript 通常能够从我们使用它的方式推断变量的类型！
>
>
>
#### 我们的源文件是我们的文档，TypeScript 是我们的拼写检查
对于 TypeScript 与我们的源代码的关系来说，一个很好的类比，就是拼写检查与我们在 Microsoft Word 中写的文档的关系。
这两个例子有三个关键的共同点：
1. **它能告诉我们写的东西的客观的、直接的错误：**
* *拼写检查*：“我们已经写了字典中不存在的字”
* *TypeScript*：“我们引用了一个符号（例如一个变量），它没有在我们的程序中声明”
2. **它可以提醒我们写的可能是错误的：**
* *拼写检查*：“该工具无法完全推断特定语句的含义，并建议重写”
* *TypeScript*：“该工具不能完全推断特定变量的类型，并警告不要这样使用它”
3. **我们的来源可以用于其原始目的，无论工具是否存在错误：**
* *拼写检查*：“即使您的文档有很多拼写错误，您仍然可以打印出来，并把它当成文档使用”
* *TypeScript*：“即使您的源代码具有 TypeScript 错误，它仍然会生成您可以执行的 JavaScript 代码”
### TypeScript 是一种可以启用其它工具的工具
TypeScript 编译器由几个不同的部分或阶段组成。我们将通过查看这些部分之一 The Parser（语法分析程序）来结束这篇文章，除了 TypeScript 已经为我们做的以外，它为我们提供了在其上构建其它开发工具的机会。
编译过程的“解析器步骤”的结果是所谓的抽象语法树，简称为 AST。
#### 什么是抽象语法树（AST）？
我们以普通文本形式编写我们的程序，因为这是我们人类与计算机交互的最好方式，让它们能够做我们想要的东西。我们并不是很擅长于手工编写复杂的数据结构！
然而，不管在哪种情况下，普通文本在编译器里面实际上是一个非常棘手的事情。它可能包含程序运作不必要的东西，例如空格，或者可能存在有歧义的部分。
因此，我们希望将我们的程序转换成数据结构，将数据结构全部映射为我们所使用的所谓“标记”，并将其插入到我们的程序中。
这个数据结构正是 AST！
AST 可以通过多种不同的方式表示，我使用 JSON 来看一看。
我们从这个极其简单的基本源代码来看：
```
var a = 1;
```
TypeScript 编译器的 Parser（语法分析程序）阶段的（简化后的）输出将是以下 AST：
```
{
"pos": 0,
"end": 10,
"kind": 256,
"text": "var a = 1;",
"statements": [
{
"pos": 0,
"end": 10,
"kind": 200,
"declarationList": {
"pos": 0,
"end": 9,
"kind": 219,
"declarations": [
{
"pos": 3,
"end": 9,
"kind": 218,
"name": {
"pos": 3,
"end": 5,
"text": "a"
},
"initializer": {
"pos": 7,
"end": 9,
"kind": 8,
"text": "1"
}
}
]
}
}
]
}
```
我们的 AST 中的对象称为节点。
#### 示例：在 VS Code 中重命名符号
在内部，TypeScript 编译器将使用 Parser 生成的 AST 来提供一些非常重要的事情，例如，发生在编译程序时的类型检查。
但它不止于此！
>
> 我们可以使用 AST 在 TypeScript 之上开发自己的工具，如代码美化工具、代码格式化工具和分析工具。
>
>
>
建立在这个 AST 代码之上的工具的一个很好的例子是：<ruby> 语言服务器 <rt> Language Server </rt></ruby>。
深入了解语言服务器的工作原理超出了本文的范围，但是当我们编写程序时，它能为我们提供一个绝对重量级别功能，就是“重命名符号”。
假设我们有以下源代码：
```
// The name of the author is James
var first_name = 'James';
console.log(first_name);
```
经过代码审查和对完美的适当追求，我们决定应该改换我们的变量命名惯例；使用驼峰式命名方式，而不是我们当前正在使用这种蛇式命名。
在我们的代码编辑器中，我们一直以来可以选择多个相同的文本，并使用多个光标来一次更改它们。
当我们把程序也视作文本这样继续操作时，我们已经陷入了一个典型的陷阱中。
那个注释中我们不想修改的“name”单词，在我们的手动匹配中却被误选中了。我们可以看到在现实世界的应用程序中这样更改代码是有多危险。
正如我们在上面学到的那样，像 TypeScript 这样的东西在幕后生成一个 AST 的时候，与我们的程序不再像普通文本那样可以交互，每个标记在 AST 中都有自己的位置，而且它有很清晰的映射关系。
当我们右键单击我们的 `first_name` 变量时，我们可以在 VS Code 中直接“重命名符号”（TypeScript 语言服务器插件也可用于其他编辑器）。
非常好！现在我们的 `first_name` 变量是唯一需要改变的东西，如果需要的话，这个改变甚至会发生在我们项目中的多个文件中（与导出和导入的值一样）！
### 总结
哦，我们在这篇文章中已经讲了很多的内容。
我们把有关学术方面的规避开，围绕编译器和类型还有很多专业术语给出了通俗的定义。
我们对比了编译语言与解释语言、运行阶段与编译阶段、动态类型与静态类型，以及抽象语法树（AST）如何为我们的程序构建工具提供了更为优化的方法。
重要的是，我们提供了 TypeScript 作为我们 JavaScript 开发工具的一种思路，以及如何在其上构建更棒的工具，比如说作为重构代码的一种方式的重命名符号。
快来 UltimateAngular 平台上学习从初学者到 TypeScript 高手的课程吧，开启你的学习之旅！
---
via: <https://toddmotto.com/typescript-the-missing-introduction>
作者：James Henry 译者：[MonkeyDEcho](https://github.com/MonkeyDEcho) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 CentOS 上安装 Apache Hadoop
|
Anismaj
|
https://www.unixmen.com.hijacked/setup-apache-hadoop-centos/
|
Apache Hadoop 软件库是一个框架，它允许使用简单的编程模型在计算机集群上对大型数据集进行分布式处理。Apache™ Hadoop® 是可靠、可扩展、分布式计算的开源软件。
|
/data/attachment/album/201708/13/210401f4ttrztmdrn7rxey.jpg.thumb.jpg
|
/data/attachment/album/201708/13/210401f4ttrztmdrn7rxey.jpg
| true | false | true |
geekpi
| false |
[
"Hadoop"
] |
系统运维
|
{
"viewnum": 8456,
"commentnum": 2,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "223.73.129.0",
"message": "楼主如何在ubuntu 11.04安装hadoop",
"username": "小伙子先生 [QQ Browser 9.6|Windows 7]",
"date": "2017-08-14T10:35:44"
},
{
"postip": "125.71.133.13",
"message": "跟这个完全一样",
"username": "龙瑀璇 [Chrome 62.0|Windows 10]",
"date": "2017-08-14T20:19:42"
}
] |
[] |
Apache Hadoop 软件库是一个框架，它允许使用简单的编程模型在计算机集群上对大型数据集进行分布式处理。Apache™ Hadoop® 是可靠、可扩展、分布式计算的开源软件。
| 2017-08-13T21:05:34 | 2017-08-13T21:05:34 | 8,775 |
/article-8775-1.html
|
Apache Hadoop 软件库是一个框架，它允许使用简单的编程模型在计算机集群上对大型数据集进行分布式处理。Apache™ Hadoop® 是可靠、可扩展、分布式计算的开源软件。
该项目包括以下模块：
* Hadoop Common：支持其他 Hadoop 模块的常用工具。
* Hadoop 分布式文件系统 （HDFS™）：分布式文件系统，可提供对应用程序数据的高吞吐量访问支持。
* Hadoop YARN：作业调度和集群资源管理框架。
* Hadoop MapReduce：一个基于 YARN 的大型数据集并行处理系统。
本文将帮助你逐步在 CentOS 上安装 hadoop 并配置单节点 hadoop 集群。
### 安装 Java
在安装 hadoop 之前，请确保你的系统上安装了 Java。使用此命令检查已安装 Java 的版本。
```
java -version
java version "1.7.0_75"
Java(TM) SE Runtime Environment (build 1.7.0_75-b13)
Java HotSpot(TM) 64-Bit Server VM (build 24.75-b04, mixed mode)
```
要安装或更新 Java，请参考下面逐步的说明。
第一步是从 [Oracle 官方网站](http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html)下载最新版本的 java。
```
cd /opt/
wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/7u79-b15/jdk-7u79-linux-x64.tar.gz"
tar xzf jdk-7u79-linux-x64.tar.gz
```
需要设置使用更新版本的 Java 作为替代。使用以下命令来执行此操作。
```
cd /opt/jdk1.7.0_79/
alternatives --install /usr/bin/java java /opt/jdk1.7.0_79/bin/java 2
alternatives --config java
```
```
There are 3 programs which provide 'java'.
Selection Command
-----------------------------------------------
* 1 /opt/jdk1.7.0_60/bin/java
+ 2 /opt/jdk1.7.0_72/bin/java
3 /opt/jdk1.7.0_79/bin/java
Enter to keep the current selection[+], or type selection number: 3 [Press Enter]
```
现在你可能还需要使用 `alternatives` 命令设置 `javac` 和 `jar` 命令路径。
```
alternatives --install /usr/bin/jar jar /opt/jdk1.7.0_79/bin/jar 2
alternatives --install /usr/bin/javac javac /opt/jdk1.7.0_79/bin/javac 2
alternatives --set jar /opt/jdk1.7.0_79/bin/jar
alternatives --set javac /opt/jdk1.7.0_79/bin/javac
```
下一步是配置环境变量。使用以下命令正确设置这些变量。
设置 `JAVA_HOME` 变量：
```
export JAVA_HOME=/opt/jdk1.7.0_79
```
设置 `JRE_HOME` 变量：
```
export JRE_HOME=/opt/jdk1.7.0_79/jre
```
设置 `PATH` 变量：
```
export PATH=$PATH:/opt/jdk1.7.0_79/bin:/opt/jdk1.7.0_79/jre/bin
```
### 安装 Apache Hadoop
设置好 java 环境后。开始安装 Apache Hadoop。
第一步是创建用于 hadoop 安装的系统用户帐户。
```
useradd hadoop
passwd hadoop
```
现在你需要配置用户 `hadoop` 的 ssh 密钥。使用以下命令启用无需密码的 ssh 登录。
```
su - hadoop
ssh-keygen -t rsa
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
chmod 0600 ~/.ssh/authorized_keys
exit
```
现在从官方网站 [hadoop.apache.org](https://hadoop.apache.org/) 下载 hadoop 最新的可用版本。
```
cd ~
wget http://apache.claz.org/hadoop/common/hadoop-2.6.0/hadoop-2.6.0.tar.gz
tar xzf hadoop-2.6.0.tar.gz
mv hadoop-2.6.0 hadoop
```
下一步是设置 hadoop 使用的环境变量。
编辑 `~/.bashrc`，并在文件末尾添加以下这些值。
```
export HADOOP_HOME=/home/hadoop/hadoop
export HADOOP_INSTALL=$HADOOP_HOME
export HADOOP_MAPRED_HOME=$HADOOP_HOME
export HADOOP_COMMON_HOME=$HADOOP_HOME
export HADOOP_HDFS_HOME=$HADOOP_HOME
export YARN_HOME=$HADOOP_HOME
export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native
export PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin
```
在当前运行环境中应用更改。
```
source ~/.bashrc
```
编辑 `$HADOOP_HOME/etc/hadoop/hadoop-env.sh` 并设置 `JAVA_HOME` 环境变量。
```
export JAVA_HOME=/opt/jdk1.7.0_79/
```
现在，先从配置基本的 hadoop 单节点集群开始。
首先编辑 hadoop 配置文件并进行以下更改。
```
cd /home/hadoop/hadoop/etc/hadoop
```
让我们编辑 `core-site.xml`。
```
<configuration>
<property>
<name>fs.default.name</name>
<value>hdfs://localhost:9000</value>
</property>
</configuration>
```
接着编辑 `hdfs-site.xml`：
```
<configuration>
<property>
<name>dfs.replication</name>
<value>1</value>
</property>
<property>
<name>dfs.name.dir</name>
<value>file:///home/hadoop/hadoopdata/hdfs/namenode</value>
</property>
<property>
<name>dfs.data.dir</name>
<value>file:///home/hadoop/hadoopdata/hdfs/datanode</value>
</property>
</configuration>
```
并编辑 `mapred-site.xml`：
```
<configuration>
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
</configuration>
```
最后编辑 `yarn-site.xml`：
```
<configuration>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
</configuration>
```
现在使用以下命令格式化 namenode：
```
hdfs namenode -format
```
要启动所有 hadoop 服务，请使用以下命令：
```
cd /home/hadoop/hadoop/sbin/
start-dfs.sh
start-yarn.sh
```
要检查所有服务是否正常启动，请使用 `jps` 命令：
```
jps
```
你应该看到这样的输出。
```
26049 SecondaryNameNode
25929 DataNode
26399 Jps
26129 JobTracker
26249 TaskTracker
25807 NameNode
```
现在，你可以在浏览器中访问 Hadoop 服务：http://your-ip-address:8088/ 。
[](http://www.unixmen.com/wp-content/uploads/2015/06/hadoop.png)
谢谢阅读！！！
---
via: [https://www.unixmen.com/setup-apache-hadoop-centos/](https://www.unixmen.com.hijacked/setup-apache-hadoop-centos/)
作者：[anismaj](https://www.unixmen.com/author/anis/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
4 个 Linux 桌面上的轻量级图像浏览器
|
Scott Nesbitt
|
https://opensource.com/article/17/7/4-lightweight-image-viewers-linux-desktop
|
当你需要的不仅仅是一个基本的图像浏览器，而是一个完整的图像编辑器，请查看这些程序。
|
/data/attachment/album/201708/14/114804v97eze7hd2zled7s.jpg.thumb.jpg
|
/data/attachment/album/201708/14/114804v97eze7hd2zled7s.jpg
| true | false | true |
geekpi
| false |
[
"图像"
] |
分享
|
{
"viewnum": 14477,
"commentnum": 5,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "119.137.53.231",
"message": "gthumb这么好的东西，怎么能不上。",
"username": "来自广东深圳的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-14T13:41:31"
},
{
"postip": "36.44.169.3",
"message": "并不轻量",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-14T22:22:28"
},
{
"postip": "36.44.169.3",
"message": "目前来讲，还是觉得eom（eye of mate desktop)最好用，其它的不是停止维护年久失修，就是用起来麻烦。",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-14T22:26:32"
},
{
"postip": "123.4.124.28",
"message": "xnview也很不错",
"username": "来自河南许昌的 Chrome 62.0|Windows 10 用户",
"date": "2017-08-15T11:06:13"
},
{
"postip": "14.221.96.83",
"message": "qiv 键盘控制的图像查看工具",
"username": "来自广东东莞的 Firefox 55.0|Ubuntu 用户",
"date": "2017-08-26T19:04:30"
}
] |
[] |
当你需要的不仅仅是一个基本的图像浏览器，而是一个完整的图像编辑器，请查看这些程序。
| 2017-08-14T11:48:00 | 2017-08-14T11:48:00 | 8,776 |
/article-8776-1.html
|
>
> 当你需要的不仅仅是一个基本的图像浏览器，而是一个完整的图像编辑器，请查看这些程序。
>
>
>
像大多数人一样，你计算机上可能有些照片和其他图像。而且，像大多数人一样，你可能想要经常查看那些图像和照片。
而启动一个 [GIMP](https://www.gimp.org/) 或者 [Pinta](https://pinta-project.com/pintaproject/pinta/) 这样的图片编辑器对于简单的浏览图片来说太笨重了。
另一方面，大多数 Linux 桌面环境中包含的基本图像查看器可能不足以满足你的需要。如果你想要一些更多的功能，但仍然希望它是轻量级的，那么看看这四个 Linux 桌面中的图像查看器，如果还不能满足你的需要，还有额外的选择。
### Feh
[Feh](https://feh.finalrewind.org/) 是我以前在老旧计算机上最喜欢的软件。它简单、朴实、用起来很好。
你可以从命令行启动 Feh：只将其指向图像或者包含图像的文件夹之后就行了。Feh 会快速加载，你可以通过鼠标点击或使用键盘上的向左和向右箭头键滚动图像。不能更简单了。
Feh 可能很轻量级，但它提供了一些选项。例如，你可以控制 Feh 的窗口是否具有边框，设置要查看的图像的最小和最大尺寸，并告诉 Feh 你想要从文件夹中的哪个图像开始浏览。
*Feh 的使用*
### Ristretto
如果你将 Xfce 作为桌面环境，那么你会熟悉 [Ristretto](https://docs.xfce.org/apps/ristretto/start)。它很小、简单、并且非常有用。
怎么简单？你打开包含图像的文件夹，单击左侧的缩略图之一，然后单击窗口顶部的导航键浏览图像。Ristretto 甚至有幻灯片功能。
Ristretto 也可以做更多的事情。你可以使用它来保存你正在浏览的图像的副本，将该图像设置为桌面壁纸，甚至在另一个应用程序中打开它，例如，当你需要修改一下的时候。
*在 Ristretto 中浏览照片*
### Mirage
表面上，[Mirage](http://mirageiv.sourceforge.net/)有点平常，没什么特色，但它做着和其他优秀图片浏览器一样的事：打开图像，将它们缩放到窗口的宽度，并且可以使用键盘滚动浏览图像。它甚至可以使用幻灯片。
不过，Mirage 将让需要更多功能的人感到惊喜。除了其核心功能，Mirage 还可以调整图像大小和裁剪图像、截取屏幕截图、重命名图像，甚至生成文件夹中图像的 150 像素宽的缩略图。
如果这还不够，Mirage 还可以显示 [SVG 文件](https://en.wikipedia.org/wiki/Scalable_Vector_Graphics)。你甚至可以从[命令行](http://mirageiv.sourceforge.net/docs-advanced.html#cli)中运行。
*使用 Mirage*
### Nomacs
[Nomacs](http://nomacs.org/) 显然是本文中最重量级的图像浏览器。它所呈现的那么多功能让人忽视了它的速度。它快捷而易用。
Nomacs 不仅仅可以显示图像。你还可以查看和编辑图像的[元数据](https://iptc.org/standards/photo-metadata/photo-metadata/)，向图像添加注释，并进行一些基本的编辑，包括裁剪、调整大小、并将图像转换为灰度。Nomacs 甚至可以截图。
一个有趣的功能是你可以在桌面上运行程序的两个实例，并在这些实例之间同步图像。当需要比较两个图像时，[Nomacs 文档](http://nomacs.org/synchronization/)中推荐这样做。你甚至可以通过局域网同步图像。我没有尝试通过网络进行同步，如果你做过可以分享下你的经验。
*Nomacs 中的照片及其元数据*
### 其他一些值得一看的浏览器
如果这四个图像浏览器不符合你的需求，这里还有其他一些你可能感兴趣的。
**[Viewnior](http://siyanpanayotov.com/project/viewnior/)** 自称是 “GNU/Linux 中的快速简单的图像查看器”，它很适合这个用途。它的界面干净整洁，Viewnior 甚至可以进行一些基本的图像处理。
如果你喜欢在命令行中使用，那么 **display** 可能是你需要的浏览器。 **[ImageMagick](https://www.imagemagick.org/script/display.php)** 和 **[GraphicsMagick](http://www.graphicsmagick.org/display.html)** 这两个图像处理软件包都有一个名为 display 的应用程序，这两个版本都有查看图像的基本和高级选项。
**[Geeqie](http://geeqie.org/)** 是更轻和更快的图像浏览器之一。但是，不要让它的简单误导你。它包含的功能有元数据编辑功能和其它浏览器所缺乏的查看相机 RAW 图像格式的功能。
**[Shotwell](https://wiki.gnome.org/Apps/Shotwell)** 是 GNOME 桌面的照片管理器。然而它不仅仅能浏览图像，而且 Shotwell 非常快速，并且非常适合显示照片和其他图形。
*在 Linux 桌面中你有最喜欢的一款轻量级图片浏览器么？请在评论区随意分享你的喜欢的浏览器。*
---
作者简介：
我是一名长期使用自由/开源软件的用户，并因为乐趣和收获写各种东西。我不会很严肃。你可以在这些网站上找到我：Twitter、Mastodon、GitHub。
via: <https://opensource.com/article/17/7/4-lightweight-image-viewers-linux-desktop>
作者：[Scott Nesbitt](https://opensource.com/users/scottnesbitt) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Samba 系列（十四）：在命令行中将 CentOS 7 与 Samba4 AD 集成
|
Matei Cezar
|
https://www.tecmint.com/integrate-centos-7-to-samba4-active-directory/
|
本指南将向你介绍如何使用 Authconfig 在命令行中将无图形界面的 CentOS 7 服务器集成到 Samba4 AD 域控制器中。
|
/data/attachment/album/201708/14/175556fx2zo3er3vxuumun.jpg.thumb.jpg
|
/data/attachment/album/201708/14/175556fx2zo3er3vxuumun.jpg
| true | false | true |
geekpi
| false |
[
"Samba"
] |
系统运维
|
{
"viewnum": 8244,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8700,
"displayorder": 0
},
{
"raid": 8853,
"displayorder": 0
}
] |
本指南将向你介绍如何使用 Authconfig 在命令行中将无图形界面的 CentOS 7 服务器集成到 Samba4 AD 域控制器中。
| 2017-08-14T17:58:03 | 2017-08-14T17:58:03 | 8,777 |
/article-8777-1.html
|
本指南将向你介绍如何使用 Authconfig 在命令行中将无图形界面的 CentOS 7 服务器集成到 [Samba4 AD 域控制器](/article-8065-1.html)中。
这类设置提供了由 Samba 持有的单一集中式帐户数据库，允许 AD 用户通过网络基础设施对 CentOS 服务器进行身份验证。
#### 要求
1. [在 Ubuntu 上使用 Samba4 创建 AD 基础架构](/article-8065-1.html)
2. [CentOS 7.3 安装指南](/article-8048-1.html)
### 步骤 1：为 Samba4 AD DC 配置 CentOS
1、 在开始将 CentOS 7 服务器加入 Samba4 DC 之前，你需要确保网络接口被正确配置为通过 DNS 服务查询域。
运行 `ip address` 命令列出你机器网络接口，选择要编辑的特定网卡，通过针对接口名称运行 `nmtui-edit` 命令（如本例中的 ens33），如下所示。
```
# ip address
# nmtui-edit ens33
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/List-Network-Interfaces.jpg)
*列出网络接口*
2、 打开网络接口进行编辑后，添加最适合 LAN 的静态 IPv4 配置，并确保为 DNS 服务器设置 Samba AD 域控制器 IP 地址。
另外，在搜索域中追加你的域的名称，并使用 [TAB] 键跳到确定按钮来应用更改。
当你仅对域 dns 记录使用短名称时, 已提交的搜索域保证域对应项会自动追加到 dns 解析 (FQDN) 中。
[](https://www.tecmint.com/wp-content/uploads/2017/07/Configure-Network-Interface.png)
*配置网络接口*
3、最后，重启网络守护进程以应用更改，并通过对域名和域控制器 ping 来测试 DNS 解析是否正确配置，如下所示。
```
# systemctl restart network.service
# ping -c2 tecmint.lan
# ping -c2 adc1
# ping -c2 adc2
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Verify-DNS-Resolution-on-Domain.png)
*验证域上的 DNS 解析*
4、 另外，使用下面的命令配置你的计算机主机名并重启机器应用更改。
```
# hostnamectl set-hostname your_hostname
# init 6
```
使用以下命令验证主机名是否正确配置。
```
# cat /etc/hostname
# hostname
```
5、 最后，使用 root 权限运行以下命令，与 Samba4 AD DC 同步本地时间。
```
# yum install ntpdate
# ntpdate domain.tld
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Sync-Time-with-Samba4-AD-DC.png)
*与 Samba4 AD DC 同步时间*
### 步骤 2：将 CentOS 7 服务器加入到 Samba4 AD DC
6、 要将 CentOS 7 服务器加入到 Samba4 AD 中，请先用具有 root 权限的帐户在计算机上安装以下软件包。
```
# yum install authconfig samba-winbind samba-client samba-winbind-clients
```
7、 为了将 CentOS 7 服务器与域控制器集成，可以使用 root 权限运行 `authconfig-tui`，并使用下面的配置。
```
# authconfig-tui
```
首屏选择：
* 在 User Information 中：
+ Use Winbind
* 在 Authentication 中使用[空格键]选择:
+ Use Shadow Password
+ Use Winbind Authentication
+ Local authorization is sufficient
[](https://www.tecmint.com/wp-content/uploads/2017/07/Authentication-Configuration.png)
*验证配置*
8、 点击 Next 进入 Winbind 设置界面并配置如下：
* Security Model: ads
* Domain = YOUR\_DOMAIN (use upper case)
* Domain Controllers = domain machines FQDN (comma separated if more than one)
* ADS Realm = YOUR\_DOMAIN.TLD
* Template Shell = /bin/bash
[](https://www.tecmint.com/wp-content/uploads/2017/07/Winbind-Settings.png)
*Winbind 设置*
9、 要加入域，使用 [tab] 键跳到 “Join Domain” 按钮，然后按[回车]键加入域。
在下一个页面，添加具有提升权限的 Samba4 AD 帐户的凭据，以将计算机帐户加入 AD，然后单击 “OK” 应用设置并关闭提示。
请注意，当你输入用户密码时，凭据将不会显示在屏幕中。在下面再次点击 OK，完成 CentOS 7 的域集成。
[](https://www.tecmint.com/wp-content/uploads/2017/07/Join-Domain-to-Samba4-AD-DC.png)
*加入域到 Samba4 AD DC*
[](https://www.tecmint.com/wp-content/uploads/2017/07/Confirm-Winbind-Settings.png)
*确认 Winbind 设置*
要强制将机器添加到特定的 Samba AD OU 中，请使用 hostname 命令获取计算机的完整名称，并使用机器名称在该 OU 中创建一个新的计算机对象。
将新对象添加到 Samba4 AD 中的最佳方法是已经集成到[安装了 RSAT 工具](/article-8097-1.html)的域的 Windows 机器上使用 ADUC 工具。
重要：加入域的另一种方法是使用 `authconfig` 命令行，它可以对集成过程进行广泛的控制。
但是，这种方法很容易因为其众多参数造成错误，如下所示。该命令必须输入一条长命令行。
```
# authconfig --enablewinbind --enablewinbindauth --smbsecurity ads --smbworkgroup=YOUR_DOMAIN --smbrealm YOUR_DOMAIN.TLD --smbservers=adc1.yourdomain.tld --krb5realm=YOUR_DOMAIN.TLD --enablewinbindoffline --enablewinbindkrb5 --winbindtemplateshell=/bin/bash--winbindjoin=domain_admin_user --update --enablelocauthorize --savebackup=/backups
```
10、 机器加入域后，通过使用以下命令验证 winbind 服务是否正常运行。
```
# systemctl status winbind.service
```
11、 接着检查是否在 Samba4 AD 中成功创建了 CentOS 机器对象。从安装了 RSAT 工具的 Windows 机器使用 AD 用户和计算机工具，并进入到你的域计算机容器。一个名为 CentOS 7 Server 的新 AD 计算机帐户对象应该在右边的列表中。
12、 最后，使用文本编辑器打开 samba 主配置文件（`/etc/samba/smb.conf`）来调整配置，并在 `[global]` 配置块的末尾附加以下行，如下所示：
```
winbind use default domain = true
winbind offline logon = true
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Configure-Samba.jpg)
*配置 Samba*
13、 为了在 AD 帐户首次登录时在机器上创建本地家目录，请运行以下命令：
```
# authconfig --enablemkhomedir --update
```
14、 最后，重启 Samba 守护进程使更改生效，并使用一个 AD 账户登陆验证域加入。AD 帐户的家目录应该会自动创建。
```
# systemctl restart winbind
# su - domain_account
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Verify-Domain-Joining.jpg)
*验证域加入*
15、 通过以下命令之一列出域用户或域组。
```
# wbinfo -u
# wbinfo -g
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/List-Domain-Users-and-Groups.png)
*列出域用户和组*
16、 要获取有关域用户的信息，请运行以下命令。
```
# wbinfo -i domain_user
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/List-Domain-User-Info.jpg)
*列出域用户信息*
17、 要显示域摘要信息，请使用以下命令。
```
# net ads info
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/List-Domain-Summary.jpg)
*列出域摘要*
### 步骤 3：使用 Samba4 AD DC 帐号登录CentOS
18、 要在 CentOS 中与域用户进行身份验证，请使用以下命令语法之一。
```
# su - ‘domain\domain_user’
# su - domain\\domain_user
```
或者在 samba 配置文件中设置了 `winbind use default domain = true` 参数的情况下，使用下面的语法。
```
# su - domain_user
# su - domain_user@domain.tld
```
19、 要为域用户或组添加 root 权限，请使用 `visudocommand` 编辑 `sudoers` 文件，并添加以下截图所示的行。
```
YOUR_DOMAIN\\domain_username ALL=(ALL:ALL) ALL #For domain users
%YOUR_DOMAIN\\your_domain\ group ALL=(ALL:ALL) ALL #For domain groups
```
或者在 samba 配置文件中设置了 `winbind use default domain = true` 参数的情况下，使用下面的语法。
```
domain_username ALL=(ALL:ALL) ALL #For domain users
%your_domain\ group ALL=(ALL:ALL) ALL #For domain groups
```
[](https://www.tecmint.com/wp-content/uploads/2017/07/Grant-Root-Privileges-on-Domain-Users.jpg)
*授予域用户 root 权限*
20、 针对 Samba4 AD DC 的以下一系列命令也可用于故障排除：
```
# wbinfo -p #Ping domain
# wbinfo -n domain_account #Get the SID of a domain account
# wbinfo -t #Check trust relationship
```
21、 要离开该域, 请使用具有提升权限的域帐户对你的域名运行以下命令。从 AD 中删除计算机帐户后, 重启计算机以在集成进程之前还原更改。
```
# net ads leave -w DOMAIN -U domain_admin
# init 6
```
就是这样了！尽管此过程主要集中在将 CentOS 7 服务器加入到 Samba4 AD DC 中，但这里描述的相同步骤也适用于将 CentOS 服务器集成到 Microsoft Windows Server 2012 AD 中。
---
作者简介：
Matei Cezar - 我是一个电脑上瘾的家伙，开源和基于 linux 的系统软件的粉丝，在 Linux 发行版桌面、服务器和 bash 脚本方面拥有大约 4 年的经验。
---
via: <https://www.tecmint.com/integrate-centos-7-to-samba4-active-directory/>
作者：[Matei Cezar](https://www.tecmint.com/author/cezarmatei/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
OCI 发布容器运行时和镜像格式规范 V1.0
|
Patrick Chanezon
|
https://blog.docker.com/2017/07/oci-release-of-v1-0-runtime-and-image-format-specifications/
|
7 月 19 日是开放容器计划Open Container Initiative（OCI）的一个重要里程碑，OCI 发布了容器运行时和镜像规范的 1.0 版本。
|
/data/attachment/album/201708/14/235901fx9pzduux4g9t4t5.jpg.thumb.jpg
|
/data/attachment/album/201708/14/235901fx9pzduux4g9t4t5.jpg
| true | false | true |
rieonke
| false |
[
"OCI",
"Docker"
] |
容器与云
|
{
"viewnum": 6983,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "113.201.60.142",
"message": "本地化管理命令子集才是王道！！！",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-15T11:04:16"
},
{
"postip": "113.201.60.142",
"message": "企业一定要使用标准化协议。第一异构设备对接问题少。第二避免厂家绑架。厂家吹自己的私有协议再好都是个问题。妈的生产系统大故障就是因为两个厂家的私有协议对不到一起导致网络大故障。那玩意太恐怖了。因此，各位企业IT们，倡议大家一定要首先支持和使用开放的标准协议产品。用脚投票其实是对自己权利最好的保护",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-15T18:41:57"
}
] |
[
{
"raid": 8763,
"displayorder": 0
}
] |
7 月 19 日是开放容器计划Open Container Initiative（OCI）的一个重要里程碑，OCI 发布了容器运行时和镜像规范的 1.0 版本。
| 2017-08-15T08:30:00 | 2017-08-15T08:30:00 | 8,778 |
/article-8778-1.html
|
7 月 19 日是<ruby> 开放容器计划 <rt> Open Container Initiative </rt></ruby>（OCI）的一个重要里程碑，OCI 发布了容器运行时和镜像规范的 1.0 版本，而 Docker 在这过去两年中一直充当着推动和引领的核心角色。我们的目标是为社区、客户以及更广泛的容器行业提供底层的标准。要了解这一里程碑的意义，我们先来看看 Docker 在开发容器技术行业标准方面的成长和发展历史。
### Docker 将运行时和镜像捐赠给 OCI 的历史回顾
Docker 的镜像格式和容器运行时在 2013 年作为开源项目发布后，迅速成为事实上的标准。我们认识到将其转交给中立管理机构管理，以加强创新和防止行业碎片化的重要性。我们与广泛的容器技术人员和行业领导者合作，成立了<ruby> 开放容器项目 <rt> Open Container Project </rt></ruby>来制定了一套容器标准，并在 Linux 基金会的支持下，于 2015 年 6 月在 <ruby> Docker 大会 <rp> （ </rp> <rt> DockerCon </rt> <rp> ） </rp></ruby>上推出。最终在那个夏天演变成为<ruby> 开放容器计划 <rt> Open Container Initiative </rt></ruby> (OCI）。
Docker 贡献了 runc ，这是从 Docker 员工 [Michael Crosby](https://github.com/crosbymichael) 的 libcontainer 项目中发展而来的容器运行时参考实现。 runc 是描述容器生命周期和运行时行为的运行时规范的基础。runc 被用在数千万个节点的生产环境中，这比任何其它代码库都要大一个数量级。runc 已经成为运行时规范的参考实现，并且随着项目的进展而不断发展。
在运行时规范制定工作开始近一年后，我们组建了一个新的工作组来制定镜像格式的规范。 Docker 将 Docker V2 镜像格式捐赠给 OCI 作为镜像规范的基础。通过这次捐赠，OCI 定义了构成容器镜像的数据结构（原始镜像）。定义容器镜像格式是一个至关重要的步骤，但它需要一个像 Docker 这样的平台通过定义和提供构建、管理和发布镜像的工具来实现它的价值。 例如，Dockerfile 等内容并不包括在 OCI 规范中。
### 开放容器标准化之旅
这个规范已经持续开发了两年。随着代码的重构，更小型的项目已经从 runc 参考实现中脱颖而出，并支持即将发布的认证测试工具。
有关 Docker 参与塑造 OCI 的详细信息，请参阅上面的时间轴，其中包括：创建 runc ，和社区一起更新、迭代运行时规范，创建 containerd 以便于将 runc 集成到 Docker 1.11 中，将 Docker V2 镜像格式贡献给 OCI 作为镜像格式规范的基础，并在 [containerd](https://containerd.io/) 中实现该规范，使得该核心容器运行时同时涵盖了运行时和镜像格式标准，最后将 containerd 捐赠给了<ruby> 云计算基金会 <rt> Cloud Native Computing Foundation </rt></ruby>（CNCF），并于本月发布了更新的 1.0 alpha 版本。
维护者 [Michael Crosby](https://github.com/crosbymichael) 和 [Stephen Day](https://github.com/stevvooe) 引导了这些规范的发展，并且为 v1.0 版本的实现提供了极大的帮助，另外 Alexander Morozov，Josh Hawn，Derek McGown 和 Aaron Lehmann 也贡献了代码，以及 Stephen Walli 参加了认证工作组。
Docker 仍然致力于推动容器标准化进程，在每个人都认可的层面建立起坚实的基础，使整个容器行业能够在依旧十分差异化的层面上进行创新。
### 开放标准只是一小块拼图
Docker 是一个完整的平台，用于创建、管理、保护和编排容器以及镜像。该项目的愿景始终是致力于成为支持开源组件的行业规范的基石，或着是容器解决方案的校准铅锤。Docker 平台正位于此层之上 -- 为客户提供从开发到生产的安全的容器管理解决方案。
OCI 运行时和镜像规范成为一个可靠的标准基础，允许和鼓励多样化的容器解决方案，同时它们不限制产品创新或遏制主要开发者。打一个比方，TCP/IP、HTTP 和 HTML 成为过去 25 年来建立万维网的可靠标准，其他公司可以继续通过这些标准的新工具、技术和浏览器进行创新。 OCI 规范也为容器解决方案提供了类似的规范基础。
开源项目也在为产品开发提供组件方面发挥着作用。containerd 项目就使用了 OCI 的 runc 参考实现，它负责镜像的传输和存储，容器运行和监控，以及支持存储和网络附件的等底层功能。containerd 项目已经被 Docker 捐赠给了 CNCF ，与其他重要项目一起支持云计算解决方案。
Docker 使用了 containerd 和其它自己的核心开源基础设施组件，如 LinuxKit，InfraKit 和 Notary 等项目来构建和保护 Docker 社区版容器解决方案。正在寻找一个能提供容器管理、安全性、编排、网络和更多功能的完整容器平台的用户和组织可以了解下 Docker Enterprise Edition 。
>
> 这张图强调了 OCI 规范提供了一个由容器运行时实现的标准层：containerd 和 runc。 要组装一个完整的像 Docker 这样具有完整容器生命周期和工作流程的容器平台，需要和许多其他的组件集成在一起：管理基础架构的 InfraKit，提供操作系统的 LinuxKit，交付编排的 SwarmKit，确保安全性的 Notary。
>
>
>
### OCI 下一步该干什么
随着运行时和镜像规范的发布，我们应该庆祝开发者的努力。开放容器计划的下一个关键工作是提供认证计划，以验证实现者的产品和项目确实符合运行时和镜像规范。[认证工作组](https://github.com/opencontainers/certification) 已经组织了一个程序，结合了<ruby> 开发套件 <rp> （ </rp> <rt> developing suite </rt> <rp> ） </rp></ruby>的[运行时](https://github.com/opencontainers/runtime-tools)和[镜像](https://github.com/opencontainers/image-tools)规范测试工具将展示产品应该如何参照标准进行实现。
同时，当前规范的开发者们正在考虑下一个最重要的容器技术领域。云计算基金会的通用容器网络接口开发工作已经正在进行中，支持镜像签署和分发的工作正也在 OCI 的考虑之中。
除了 OCI 及其成员，Docker 仍然致力于推进容器技术的标准化。 OCI 的使命是为用户和公司提供在开发者工具、镜像分发、容器编排、安全、监控和管理等方面进行创新的基准。Docker 将继续引领创新，不仅提供提高生产力和效率的工具，而且还通过授权用户，合作伙伴和客户进行创新。
**在 Docker 学习更过关于 OCI 和开源的信息：**
* 阅读 [OCI 规范的误区](/article-8763-1.html)
* 访问 [开放容器计划的网站](https://www.opencontainers.org/join)
* 访问 [Moby 项目网站](http://mobyproject.org/)
* 参加 [DockerCon Europe 2017](https://europe-2017.dockercon.com/)
* 参加 [Moby Summit LA](https://www.eventbrite.com/e/moby-summit-los-angeles-tickets-35930560273)
（题图：vox-cdn.com）
---
作者简介：
Patrick Chanezon 是 Docker Inc. 技术人员。他的工作是帮助构建 Docker 。一个程序员和讲故事的人 （storyller），他在 Netscape 和 Sun 工作了10年的时间，又在Google，VMware 和微软工作了10年。他的主要职业兴趣是为这些奇特的双边市场“平台”建立和推动网络效应。他曾在门户网站，广告，电商，社交，Web，分布式应用和云平台上工作过。有关更多信息，请访问 linkedin.com/in/chanezon 和他的推特 @chanezon。
---
via: <https://blog.docker.com/2017/07/oci-release-of-v1-0-runtime-and-image-format-specifications/>
作者：[Patrick Chanezon](https://blog.docker.com/author/chanezon/) 译者：[rieonke](https://github.com/rieonke) 校对：[校对者ID](https://github.com/%E6%A0%A1%E5%AF%B9%E8%80%85ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
学习用 Python 编程时要避免的 3 个错误
|
Pete Savage
|
https://opensource.com/article/17/6/3-things-i-did-wrong-learning-python
|
为了让初学 Python 的程序员避免犯同样的错误，以下列出了我学习 Python 时犯的三种错误。这些错误要么是我长期以来经常犯的，要么是造成了需要几个小时解决的麻烦。
|
/data/attachment/album/201708/16/000829y5u4wm1kou8d55z6.jpg.thumb.jpg
|
/data/attachment/album/201708/16/000829y5u4wm1kou8d55z6.jpg
| true | false | true |
polebug
| false |
[
"Python"
] |
软件开发
|
{
"viewnum": 6963,
"commentnum": 3,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "202.141.162.124",
"message": "这算是Python入门内容了，也算是Python的「坑」。",
"username": "来自安徽的 Firefox 55.0|GNU/Linux 用户",
"date": "2017-08-16T12:49:32"
},
{
"postip": "42.200.204.11",
"message": "很好, 第一個真的沒想到",
"username": "来自香港的 Chrome 59.0|Windows 10 用户",
"date": "2017-08-17T09:49:26"
},
{
"postip": "110.179.69.22",
"message": "这个和js有点像",
"username": "来自山西太原的 Chrome Mobile 39.0|Android 5.1 用户",
"date": "2017-08-29T15:45:08"
}
] |
[] |
为了让初学 Python 的程序员避免犯同样的错误，以下列出了我学习 Python 时犯的三种错误。这些错误要么是我长期以来经常犯的，要么是造成了需要几个小时解决的麻烦。
| 2017-08-16T08:58:00 | 2017-08-16T08:58:00 | 8,780 |
/article-8780-1.html
|
>
> 这些错误会造成很麻烦的问题，需要数小时才能解决。
>
>
>
当你做错事时，承认错误并不是一件容易的事，但是犯错是任何学习过程中的一部分，无论是学习走路，还是学习一种新的编程语言都是这样，比如学习 Python。
为了让初学 Python 的程序员避免犯同样的错误，以下列出了我学习 Python 时犯的三种错误。这些错误要么是我长期以来经常犯的，要么是造成了需要几个小时解决的麻烦。
年轻的程序员们可要注意了，这些错误是会浪费一下午的！
### 1、 可变数据类型作为函数定义中的默认参数
这似乎是对的？你写了一个小函数，比如，搜索当前页面上的链接，并可选将其附加到另一个提供的列表中。
```
def search_for_links(page, add_to=[]):
new_links = page.search_for_links()
add_to.extend(new_links)
return add_to
```
从表面看，这像是十分正常的 Python 代码，事实上它也是，而且是可以运行的。但是，这里有个问题。如果我们给 `add_to` 参数提供了一个列表，它将按照我们预期的那样工作。但是，如果我们让它使用默认值，就会出现一些神奇的事情。
试试下面的代码：
```
def fn(var1, var2=[]):
var2.append(var1)
print var2
fn(3)
fn(4)
fn(5)
```
可能你认为我们将看到：
```
[3]
[4]
[5]
```
但实际上，我们看到的却是：
```
[3]
[3, 4]
[3, 4, 5]
```
为什么呢？如你所见，每次都使用的是同一个列表，输出为什么会是这样？在 Python 中，当我们编写这样的函数时，这个列表被实例化为函数定义的一部分。当函数运行时，它并不是每次都被实例化。这意味着，这个函数会一直使用完全一样的列表对象，除非我们提供一个新的对象：
```
fn(3, [4])
```
```
[4, 3]
```
答案正如我们所想的那样。要想得到这种结果，正确的方法是：
```
def fn(var1, var2=None):
if not var2:
var2 = []
var2.append(var1)
```
或是在第一个例子中：
```
def search_for_links(page, add_to=None):
if not add_to:
add_to = []
new_links = page.search_for_links()
add_to.extend(new_links)
return add_to
```
这将在模块加载的时候移走实例化的内容，以便每次运行函数时都会发生列表实例化。请注意，对于不可变数据类型，比如[**元组**](https://docs.python.org/2/library/functions.html?highlight=tuple#tuple)、[**字符串**](https://docs.python.org/2/library/string.html)、[**整型**](https://docs.python.org/2/library/functions.html#int)，是不需要考虑这种情况的。这意味着，像下面这样的代码是非常可行的：
```
def func(message="my message"):
print message
```
### 2、 可变数据类型作为类变量
这和上面提到的最后一个错误很相像。思考以下代码：
```
class URLCatcher(object):
urls = []
def add_url(self, url):
self.urls.append(url)
```
这段代码看起来非常正常。我们有一个储存 URL 的对象。当我们调用 add\_url 方法时，它会添加一个给定的 URL 到存储中。看起来非常正确吧？让我们看看实际是怎样的：
```
a = URLCatcher()
a.add_url('http://www.google.com')
b = URLCatcher()
b.add_url('http://www.bbc.co.hk')
```
b.urls：
```
['http://www.google.com', 'http://www.bbc.co.uk']
```
a.urls：
```
['http://www.google.com', 'http://www.bbc.co.uk']
```
等等，怎么回事？！我们想的不是这样啊。我们实例化了两个单独的对象 `a` 和 `b`。把一个 URL 给了 `a`，另一个给了 `b`。这两个对象怎么会都有这两个 URL 呢？
这和第一个错例是同样的问题。创建类定义时，URL 列表将被实例化。该类所有的实例使用相同的列表。在有些时候这种情况是有用的，但大多数时候你并不想这样做。你希望每个对象有一个单独的储存。为此，我们修改代码为：
```
class URLCatcher(object):
def __init__(self):
self.urls = []
def add_url(self, url):
self.urls.append(url)
```
现在，当创建对象时，URL 列表被实例化。当我们实例化两个单独的对象时，它们将分别使用两个单独的列表。
### 3、 可变的分配错误
这个问题困扰了我一段时间。让我们做出一些改变，并使用另一种可变数据类型 - [**字典**](https://docs.python.org/2/library/stdtypes.html?highlight=dict#dict)。
```
a = {'1': "one", '2': 'two'}
```
现在，假设我们想把这个字典用在别的地方，且保持它的初始数据完整。
```
b = a
b['3'] = 'three'
```
简单吧？
现在，让我们看看原来那个我们不想改变的字典 `a`：
```
{'1': "one", '2': 'two', '3': 'three'}
```
哇等一下，我们再看看 **b**？
```
{'1': "one", '2': 'two', '3': 'three'}
```
等等，什么？有点乱……让我们回想一下，看看其它不可变类型在这种情况下会发生什么，例如一个**元组**：
```
c = (2, 3)
d = c
d = (4, 5)
```
现在 `c` 是 `(2, 3)`，而 `d` 是 `(4, 5)`。
这个函数结果如我们所料。那么，在之前的例子中到底发生了什么？当使用可变类型时，其行为有点像 **C** 语言的一个指针。在上面的代码中，我们令 `b = a`，我们真正表达的意思是：`b` 成为 `a` 的一个引用。它们都指向 Python 内存中的同一个对象。听起来有些熟悉？那是因为这个问题与先前的相似。其实，这篇文章应该被称为「可变引发的麻烦」。
列表也会发生同样的事吗？是的。那么我们如何解决呢？这必须非常小心。如果我们真的需要复制一个列表进行处理，我们可以这样做：
```
b = a[:]
```
这将遍历并复制列表中的每个对象的引用，并且把它放在一个新的列表中。但是要注意：如果列表中的每个对象都是可变的，我们将再次获得它们的引用，而不是完整的副本。
假设在一张纸上列清单。在原来的例子中相当于，A 某和 B 某正在看着同一张纸。如果有个人修改了这个清单，两个人都将看到相同的变化。当我们复制引用时，每个人现在有了他们自己的清单。但是，我们假设这个清单包括寻找食物的地方。如果“冰箱”是列表中的第一个，即使它被复制，两个列表中的条目也都指向同一个冰箱。所以，如果冰箱被 A 修改，吃掉了里面的大蛋糕，B 也将看到这个蛋糕的消失。这里没有简单的方法解决它。只要你记住它，并编写代码的时候，使用不会造成这个问题的方式。
字典以相同的方式工作，并且你可以通过以下方式创建一个昂贵副本：
```
b = a.copy()
```
再次说明，这只会创建一个新的字典，指向原来存在的相同的条目。因此，如果我们有两个相同的列表，并且我们修改字典 `a` 的一个键指向的可变对象，那么在字典 b 中也将看到这些变化。
可变数据类型的麻烦也是它们强大的地方。以上都不是实际中的问题；它们是一些要注意防止出现的问题。在第三个项目中使用昂贵复制操作作为解决方案在 99% 的时候是没有必要的。你的程序或许应该被改改，所以在第一个例子中，这些副本甚至是不需要的。
*编程快乐！在评论中可以随时提问。*
---
作者简介：
Pete Savage - Peter 是一位充满激情的开源爱好者，在过去十年里一直在推广和使用开源产品。他从 Ubuntu 社区开始，在许多不同的领域自愿参与音频制作领域的研究工作。在职业经历方面，他起初作为公司的系统管理员，大部分时间在管理和建立数据中心，之后在 Red Hat 担任 CloudForms 产品的主要测试工程师。
---
via: <https://opensource.com/article/17/6/3-things-i-did-wrong-learning-python>
作者：[Pete Savage](https://opensource.com/users/psav) 译者：[polebug](https://github.com/polebug) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 包管理基础：apt、yum、dnf 和 pkg
|
Brennen Bearnes
|
https://www.digitalocean.com/community/tutorials/package-management-basics-apt-yum-dnf-pkg
|
本指南旨在快速地介绍下在多种 Linux 发行版中查找、安装和升级软件包的基础知识，并帮助您将这些内容在多个系统之间进行交叉对比。
|
/data/attachment/album/201708/16/114539z1cbxu1mzsm2ssu1.png.thumb.jpg
|
/data/attachment/album/201708/16/114539z1cbxu1mzsm2ssu1.png
| true | false | true |
Snapcrafter
| false |
[
"apt",
"包管理",
"yum"
] |
技术
|
{
"viewnum": 50338,
"commentnum": 7,
"favtimes": 9,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "dpkg 若要查看最近安裝的包，不如 rpm 方便。只能查看其一个文本格式的日志文件。<br />\r\n<br />\r\nrpm --query --all --last | less",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-16T14:32:06"
},
{
"postip": "111.20.112.126",
"message": "好文要支持！！！",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-16T15:27:58"
},
{
"postip": "123.150.8.42",
"message": "或许是flatpak呢",
"username": "来自天津的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-16T17:08:59"
},
{
"postip": "223.88.133.140",
"message": "wifi页面？？？ 不是wiki吗？",
"username": "来自河南濮阳的 Firefox 55.0|Windows 10 用户",
"date": "2017-09-02T10:13:27"
},
{
"postip": "61.186.28.2",
"message": "汗~",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-09-03T11:50:06"
},
{
"postip": "113.106.88.10",
"message": "很详细！赞一个!",
"username": "来自广东深圳的 Chrome 71.0|Windows 10 用户",
"date": "2019-01-11T15:33:41"
},
{
"postip": "61.158.152.82",
"message": "test",
"username": "来自河南郑州的 Firefox 93.0|Android 10 用户",
"date": "2021-10-07T16:16:21"
}
] |
[] |
本指南旨在快速地介绍下在多种 Linux 发行版中查找、安装和升级软件包的基础知识，并帮助您将这些内容在多个系统之间进行交叉对比。
| 2017-08-16T11:45:00 | 2017-08-16T11:45:00 | 8,782 |
/article-8782-1.html
|
### 介绍
大多数现代的类 Unix 操作系统都提供了一种中心化的机制用来搜索和安装软件。软件通常都是存放在存储库中，并通过包的形式进行分发。处理包的工作被称为包管理。包提供了操作系统的基本组件，以及共享的库、应用程序、服务和文档。
包管理系统除了安装软件外，它还提供了工具来更新已经安装的包。包存储库有助于确保你的系统中使用的代码是经过审查的，并且软件的安装版本已经得到了开发人员和包维护人员的认可。
在配置服务器或开发环境时，我们最好了解下包在官方存储库之外的情况。某个发行版的稳定版本中的包有可能已经过时了，尤其是那些新的或者快速迭代的软件。然而，包管理无论对于系统管理员还是开发人员来说都是至关重要的技能，而已打包的软件对于主流 Linux 发行版来说也是一笔巨大的财富。
本指南旨在快速地介绍下在多种 Linux 发行版中查找、安装和升级软件包的基础知识，并帮助您将这些内容在多个系统之间进行交叉对比。
### 包管理系统：简要概述
大多数包系统都是围绕包文件的集合构建的。包文件通常是一个存档文件，它包含已编译的二进制文件和软件的其他资源，以及安装脚本。包文件同时也包含有价值的元数据，包括它们的依赖项，以及安装和运行它们所需的其他包的列表。
虽然这些包管理系统的功能和优点大致相同，但打包格式和工具却因平台而异：
| 操作系统 | 格式 | 工具 |
| --- | --- | --- |
| Debian | `.deb` | `apt`, `apt-cache`, `apt-get`, `dpkg` |
| Ubuntu | `.deb` | `apt`, `apt-cache`, `apt-get`, `dpkg` |
| CentOS | `.rpm` | `yum` |
| Fedora | `.rpm` | `dnf` |
| FreeBSD | Ports, `.txz` | `make`, `pkg` |
Debian 及其衍生版，如 Ubuntu、Linux Mint 和 Raspbian，它们的包格式是 `.deb`。APT 这款先进的包管理工具提供了大多数常见的操作命令：搜索存储库、安装软件包及其依赖项，并管理升级。在本地系统中，我们还可以使用 `dpkg` 程序来安装单个的 `deb` 文件，APT 命令作为底层 `dpkg` 的前端，有时也会直接调用它。
最近发布的 debian 衍生版大多数都包含了 `apt` 命令，它提供了一个简洁统一的接口，可用于通常由 `apt-get` 和 `apt-cache` 命令处理的常见操作。这个命令是可选的，但使用它可以简化一些任务。
CentOS、Fedora 和其它 Red Hat 家族成员使用 RPM 文件。在 CentOS 中，通过 `yum` 来与单独的包文件和存储库进行交互。
在最近的 Fedora 版本中，`yum` 已经被 `dnf` 取代，`dnf` 是它的一个现代化的分支，它保留了大部分 `yum` 的接口。
FreeBSD 的二进制包系统由 `pkg` 命令管理。FreeBSD 还提供了 `Ports` 集合，这是一个存在于本地的目录结构和工具，它允许用户获取源码后使用 Makefile 直接从源码编译和安装包。
### 更新包列表
大多数系统在本地都会有一个和远程存储库对应的包数据库，在安装或升级包之前最好更新一下这个数据库。另外，`yum` 和 `dnf` 在执行一些操作之前也会自动检查更新。当然你可以在任何时候对系统进行更新。
| 系统 | 命令 |
| --- | --- |
| Debian / Ubuntu | `sudo apt-get update` |
| | `sudo apt update` |
| CentOS | `yum check-update` |
| Fedora | `dnf check-update` |
| FreeBSD Packages | `sudo pkg update` |
| FreeBSD Ports | `sudo portsnap fetch update` |
### 更新已安装的包
在没有包系统的情况下，想确保机器上所有已安装的软件都保持在最新的状态是一个很艰巨的任务。你将不得不跟踪数百个不同包的上游更改和安全警报。虽然包管理器并不能解决升级软件时遇到的所有问题，但它确实使你能够使用一些命令来维护大多数系统组件。
在 FreeBSD 上，升级已安装的 ports 可能会引入破坏性的改变，有些步骤还需要进行手动配置，所以在通过 `portmaster` 更新之前最好阅读下 `/usr/ports/UPDATING` 的内容。
| 系统 | 命令 | 说明 |
| --- | --- | --- |
| Debian / Ubuntu | `sudo apt-get upgrade` | 只更新已安装的包 |
| | `sudo apt-get dist-upgrade` | 可能会增加或删除包以满足新的依赖项 |
| | `sudo apt upgrade` | 和 `apt-get upgrade` 类似 |
| | `sudo apt full-upgrade` | 和 `apt-get dist-upgrade` 类似 |
| CentOS | `sudo yum update` | |
| Fedora | `sudo dnf upgrade` | |
| FreeBSD Packages | `sudo pkg upgrade` | |
| FreeBSD Ports | `less /usr/ports/UPDATING` | 使用 `less` 来查看 ports 的更新提示（使用上下光标键滚动，按 q 退出）。 |
| | `cd /usr/ports/ports-mgmt/portmaster && sudo make install && sudo portmaster -a` | 安装 `portmaster` 然后使用它更新已安装的 ports |
### 搜索某个包
大多数发行版都提供针对包集合的图形化或菜单驱动的工具，我们可以分类浏览软件，这也是一个发现新软件的好方法。然而，查找包最快和最有效的方法是使用命令行工具进行搜索。
| 系统 | 命令 | 说明 |
| --- | --- | --- |
| Debian / Ubuntu | `apt-cache search search_string` | |
| | `apt search search_string` | |
| CentOS | `yum search search_string` | |
| | `yum search all search_string` | 搜索所有的字段，包括描述 |
| Fedora | `dnf search search_string` | |
| | `dnf search all search_string` | 搜索所有的字段，包括描述 |
| FreeBSD Packages | `pkg search search_string` | 通过名字进行搜索 |
| | `pkg search -f search_string` | 通过名字进行搜索并返回完整的描述 |
| | `pkg search -D search_string` | 搜索描述 |
| FreeBSD Ports | `cd /usr/ports && make search name=package` | 通过名字进行搜索 |
| | `cd /usr/ports && make search key=search_string` | 搜索评论、描述和依赖 |
### 查看某个软件包的信息
在安装软件包之前，我们可以通过仔细阅读包的描述来获得很多有用的信息。除了人类可读的文本之外，这些内容通常包括像版本号这样的元数据和包的依赖项列表。
| 系统 | 命令 | 说明 |
| --- | --- | --- |
| Debian / Ubuntu | `apt-cache show package` | 显示有关包的本地缓存信息 |
| | `apt show package` | |
| | `dpkg -s package` | 显示包的当前安装状态 |
| CentOS | `yum info package` | |
| | `yum deplist package` | 列出包的依赖 |
| Fedora | `dnf info package` | |
| | `dnf repoquery --requires package` | 列出包的依赖 |
| FreeBSD Packages | `pkg info package` | 显示已安装的包的信息 |
| FreeBSD Ports | `cd /usr/ports/category/port && cat pkg-descr` | |
### 从存储库安装包
知道包名后，通常可以用一个命令来安装它及其依赖。你也可以一次性安装多个包，只需将它们全部列出来即可。
| 系统 | 命令 | 说明 |
| --- | --- | --- |
| Debian / Ubuntu | `sudo apt-get install package` | |
| | `sudo apt-get install package1 package2 ...` | 安装所有列出来的包 |
| | `sudo apt-get install -y package` | 在 `apt` 提示是否继续的地方直接默认 `yes` |
| | `sudo apt install package` | 显示一个彩色的进度条 |
| CentOS | `sudo yum install package` | |
| | `sudo yum install package1 package2 ...` | 安装所有列出来的包 |
| | `sudo yum install -y package` | 在 `yum` 提示是否继续的地方直接默认 `yes` |
| Fedora | `sudo dnf install package` | |
| | `sudo dnf install package1 package2 ...` | 安装所有列出来的包 |
| | `sudo dnf install -y package` | 在 `dnf` 提示是否继续的地方直接默认 `yes` |
| FreeBSD Packages | `sudo pkg install package` | |
| | `sudo pkg install package1 package2 ...` | 安装所有列出来的包 |
| FreeBSD Ports | `cd /usr/ports/category/port && sudo make install` | 从源码构建安装一个 port |
### 从本地文件系统安装一个包
对于一个给定的操作系统，有时有些软件官方并没有提供相应的包，那么开发人员或供应商将需要提供包文件的下载。你通常可以通过 web 浏览器检索这些包，或者通过命令行 `curl` 来检索这些信息。将包下载到目标系统后，我们通常可以通过单个命令来安装它。
在 Debian 派生的系统上，`dpkg` 用来处理单个的包文件。如果一个包有未满足的依赖项，那么我们可以使用 `gdebi` 从官方存储库中检索它们。
在 CentOS 和 Fedora 系统上，`yum` 和 `dnf` 用于安装单个的文件，并且会处理需要的依赖。
| 系统 | 命令 | 说明 |
| --- | --- | --- |
| Debian / Ubuntu | `sudo dpkg -i package.deb` | |
| | `sudo apt-get install -y gdebi && sudo gdebi package.deb` | 安装 `gdebi`，然后使用 `gdebi` 安装 `package.deb` 并处理缺失的依赖 |
| CentOS | `sudo yum install package.rpm` | |
| Fedora | `sudo dnf install package.rpm` | |
| FreeBSD Packages | `sudo pkg add package.txz` | |
| | `sudo pkg add -f package.txz` | 即使已经安装的包也会重新安装 |
### 删除一个或多个已安装的包
由于包管理器知道给定的软件包提供了哪些文件，因此如果某个软件不再需要了，它通常可以干净利落地从系统中清除这些文件。
| 系统 | 命令 | 说明 |
| --- | --- | --- |
| Debian / Ubuntu | `sudo apt-get remove package` | |
| | `sudo apt remove package` | |
| | `sudo apt-get autoremove` | 删除不需要的包 |
| CentOS | `sudo yum remove package` | |
| Fedora | `sudo dnf erase package` | |
| FreeBSD Packages | `sudo pkg delete package` | |
| | `sudo pkg autoremove` | 删除不需要的包 |
| FreeBSD Ports | `sudo pkg delete package` | |
| | `cd /usr/ports/path_to_port && make deinstall` | 卸载 port |
### `apt` 命令
Debian 家族发行版的管理员通常熟悉 `apt-get` 和 `apt-cache`。较少为人所知的是简化的 `apt` 接口，它是专为交互式使用而设计的。
| 传统命令 | 等价的 `apt` 命令 |
| --- | --- |
| `apt-get update` | `apt update` |
| `apt-get dist-upgrade` | `apt full-upgrade` |
| `apt-cache search string` | `apt search string` |
| `apt-get install package` | `apt install package` |
| `apt-get remove package` | `apt remove package` |
| `apt-get purge package` | `apt purge package` |
虽然 `apt` 通常是一个特定操作的快捷方式，但它并不能完全替代传统的工具，它的接口可能会随着版本的不同而发生变化，以提高可用性。如果你在脚本或 shell 管道中使用包管理命令，那么最好还是坚持使用 `apt-get` 和 `apt-cache`。
### 获取帮助
除了基于 web 的文档，请记住我们可以通过 shell 从 Unix 手册页（通常称为 man 页面）中获得大多数的命令。比如要阅读某页，可以使用 `man`：
```
man page
```
在 `man` 中，你可以用箭头键导航。按 `/` 搜索页面内的文本，使用 `q` 退出。
| 系统 | 命令 | 说明 |
| --- | --- | --- |
| Debian / Ubuntu | `man apt-get` | 更新本地包数据库以及与包一起工作 |
| | `man apt-cache` | 在本地的包数据库中搜索 |
| | `man dpkg` | 和单独的包文件一起工作以及能查询已安装的包 |
| | `man apt` | 通过更简洁，用户友好的接口进行最基本的操作 |
| CentOS | `man yum` | |
| Fedora | `man dnf` | |
| FreeBSD Packages | `man pkg` | 和预先编译的二进制包一起工作 |
| FreeBSD Ports | `man ports` | 和 Ports 集合一起工作 |
### 结论和进一步的阅读
本指南通过对多个系统间进行交叉对比概述了一下包管理系统的基本操作，但只涉及了这个复杂主题的表面。对于特定系统更详细的信息，可以参考以下资源：
* [这份指南](https://www.digitalocean.com/community/tutorials/ubuntu-and-debian-package-management-essentials) 详细介绍了 Ubuntu 和 Debian 的软件包管理。
* 这里有一份 CentOS 官方的指南 [使用 yum 管理软件](https://www.centos.org/docs/5/html/yum/)
* 这里有一个有关 Fedora 的 `dnf` 的 [wiki 页面](https://fedoraproject.org/wiki/Dnf) 以及一份有关 `dnf` [官方的手册](https://dnf.readthedocs.org/en/latest/index.html)
* [这份指南](https://www.digitalocean.com/community/tutorials/how-to-manage-packages-on-freebsd-10-1-with-pkg) 讲述了如何使用 `pkg` 在 FreeBSD 上进行包管理
* 这本 [FreeBSD Handbook](https://www.freebsd.org/doc/handbook/) 有一节讲述了[如何使用 Ports 集合](https://www.freebsd.org/doc/handbook/ports-using.html)
---
via: <https://www.digitalocean.com/community/tutorials/package-management-basics-apt-yum-dnf-pkg>
译者后记：
从经典的 `configure` && `make` && `make install` 三部曲到 `dpkg`，从需要手处理依赖关系的 `dpkg` 到全自动化的 `apt-get`，恩~，你有没有想过接下来会是什么？译者只能说可能会是 `Snaps`，如果你还没有听过这个东东，你也许需要关注下这个公众号了：**Snapcraft**
作者：[Brennen Bearnes](https://www.digitalocean.com/community/users/bpb) 译者：[Snapcrafter](https://github.com/Snapcrafter) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何建模可以帮助你避免在 OpenStack 中遇到问题
|
Mark Baker
|
https://insights.ubuntu.com/2017/07/18/stuckstack-how-modelling-helps-you-avoid-getting-a-stuck-openstack/
|
OpenStack 部署完就是一个 “僵栈（StuckStack）”，一般出于技术原因，但有时是商业上的原因，它是无法在没有明显中断，也不花费时间和成本的情况下升级的。
|
/data/attachment/album/201708/16/141938pc5fz0eckpwpczp0.jpg.thumb.jpg
|
/data/attachment/album/201708/16/141938pc5fz0eckpwpczp0.jpg
| true | false | true |
geekpi
| false |
[
"OpenStack"
] |
观点
|
{
"viewnum": 3942,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
OpenStack 部署完就是一个 “僵栈（StuckStack）”，一般出于技术原因，但有时是商业上的原因，它是无法在没有明显中断，也不花费时间和成本的情况下升级的。
| 2017-08-16T14:19:35 | 2017-08-16T14:19:35 | 8,783 |
/article-8783-1.html
|
OpenStack 部署完就是一个 “<ruby> 僵栈 <rt> StuckStack </rt></ruby>”，一般出于技术原因，但有时是商业上的原因，它是无法在没有明显中断，也不花费时间和成本的情况下升级的。在关于这个话题的最后一篇文章中，我们讨论了这些云中有多少陷入僵局，以及当时是怎么决定的与如今的大部分常识相符。现在 OpenStack 已经有 7 年了，最近随着容器编排系统的增长以及更多企业开始利用公共和私有的云平台，OpenStack 正面临着压力。
### 没有魔法解决方案
如果你仍在寻找一个可以没有任何问题地升级你现有的 <ruby> 僵栈 <rt> StuckStack </rt></ruby> 的解决方案，那么我有坏消息给你：没有魔法解决方案，你最好集中精力建立一个标准化的平台，它可以有效地运营和轻松地升级。
廉价航空业已经表明，虽然乘客可能渴望最好的体验，可以坐在头等舱或者商务舱喝香槟，有足够的空间放松，但是大多数人会选择乘坐最便宜的，最终价值等式不要让他们付出更多的代价。工作负载是相同的。长期而言，工作负载将运行在最经济的平台上，因为在高价硬件或软件上运行的业务实际上并没有受益。
Amazon、Microsoft、Google 等大型公共云企业都知道，这就是为什么他们建立了高效的数据中心，并使用模型来构建、操作和扩展基础设施。长期以来，企业一直奉行以设计、制造、市场、定价、销售、实施为一体的最优秀的硬件和软件基础设施。现实可能并不总是符合承诺，但它现在还不重要，因为<ruby> 成本模式 <rt> cost model </rt></ruby>在当今世界无法生存。一些组织试图通过改用免费软件替代，而不改变自己的行为来解决这一问题。因此，他们发现，他们只是将成本从获取软件变到运营软件上。好消息是，那些高效运营的大型运营商使用的技术，现在可用于所有类型的组织。
### 什么是软件模型？
虽然许多年来，软件程序由许多对象、进程和服务而组成，但近年来，程序是普遍由许多单独的服务组成，它们高度分布在数据中心的不同服务器以及跨越数据中心的服务器上。
*OpenStack 服务的简单演示*
许多服务意味着许多软件需要配置、管理并跟踪许多物理机器。以成本效益的方式规模化地进行这一工作需要一个模型，即所有组件如何连接以及它们如何映射到物理资源。为了构建模型，我们需要有一个软件组件库，这是一种定义它们如何彼此连接以及将其部署到平台上的方法，无论是物理的还是虚拟的。在 Canonical 公司，我们几年前就认识到这一点，并建立了一个通用的软件建模工具 [Juju](https://www.ubuntu.com/cloud/juju)，使得运营商能够从 100 个通用软件服务目录中组合灵活的拓扑结构、架构和部署目标。
*Juju 建模 OpenStack 服务*
在 Juju 中，软件服务被定义为一种叫做 Charm 的东西。 Charms 是代码片段，它通常用 python 或 bash 编写，其中提供有关服务的信息 - 声明的接口、服务的安装方式、可连接的其他服务等。
Charms 可以简单或者复杂，具体取决于你想要赋予的功能。对于 OpenStack，Canonical 在上游 OpenStack 社区的帮助下，为主要 OpenStack 服务开发了一套完整的 Charms。Charms 代表了模型的说明，使其可以轻松地部署、操作扩展和复制。Charms 还定义了如何升级自身，包括在需要时执行升级的顺序以及如何在需要时优雅地暂停和恢复服务。通过将 Juju 连接到诸如 [裸机即服务（MAAS）](https://www.ubuntu.com/server/maas) 这样的裸机配置系统，其中 OpenStack 的逻辑模型可以部署到物理硬件上。默认情况下，Charms 将在 LXC 容器中部署服务，从而根据云行为的需要，提供更大的灵活性来重新定位服务。配置在 Charms 中定义，或者在部署时由第三方工具（如 Puppet 或 Chef）注入。
这种方法有两个不同的好处：1 - 通过创建一个模型，我们从底层硬件抽象出每个云服务。2 - 使用已知来源的标准化组件，通过迭代组合新的架构。这种一致性使我们能够使用相同的工具部署非常不同的云架构，运行和升级这些工具是安全的。
通过全面自动化的配置工具和软件程序来管理硬件库存，运营商可以比使用传统企业技术或构建偏离核心的定制系统更有效地扩展基础架构。有价值的开发资源可以集中在创新应用领域，使新的软件服务更快上线，而不是改变标准的商品基础设施，这将会导致进一步的兼容性问题。
在下一篇文章中，我将介绍部署完全建模的 OpenStack 的一些最佳实践，以及如何快速地进行操作。如果你有一个现有的 <ruby> 僵栈 <rt> StuckStack </rt></ruby>，那么虽然我们不能很容易地拯救它，但是与公有云相比，我们将能够让你走上一条完全支持的、高效的基础架构以及运营成本的道路。
### 即将举行的网络研讨会
如果你在旧版本的 OpenStack 中遇到问题，并且想要轻松升级 OpenStack 云并且无需停机，请观看我们的[在线点播研讨会](http://ubunt.eu/Bwe7kQ)，从 Newton 升级到 Ocata 的现场演示。
### 联系我们
如果你想了解有关迁移到 Canonical OpenStack 云的更多信息，请[联系这里](http://ubunt.eu/3OYs5s)。
（题图：乐高的空客 A380-800模型。空客运行 OpenStack）
---
作者简介：
专注于 Ubuntu OpenStack 的云产品经理。以前在 MySQL 和 Red Hat 工作。喜欢摩托车，遇见使用 Ubuntu 和 Openstack 做有趣事的人。
---
via: <https://insights.ubuntu.com/2017/07/18/stuckstack-how-modelling-helps-you-avoid-getting-a-stuck-openstack/>
作者：[Mark Baker](https://insights.ubuntu.com/author/markbaker/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
踢掉 FB+PL：Apache 的开源激进宣言？
|
李可
|
Apache 一脚将 FB+PL 踢出了。这是不是 Apache 在开源暴动中的激进声明？为什么这么说？
|
/data/attachment/album/201708/16/175128su68huz76c7o1uu9.jpg.thumb.jpg
|
/data/attachment/album/201708/16/175128su68huz76c7o1uu9.jpg
| true | false | false | true |
[
"专利",
"许可证"
] |
开源智慧
|
{
"viewnum": 6089,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "183.14.30.151",
"message": "这都讲了些什么",
"username": "来自广东深圳的 Chrome 60.0|Windows 10 用户",
"date": "2017-08-18T08:59:05"
},
{
"postip": "203.59.16.142",
"message": "虽然不是很明白，不过，只基于BSD的许可协议不就好了",
"username": "来自澳大利亚的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-08-19T17:58:40"
}
] |
[
{
"raid": 8733,
"displayorder": 0
},
{
"raid": 8876,
"displayorder": 0
},
{
"raid": 8882,
"displayorder": 0
},
{
"raid": 8764,
"displayorder": 1
}
] |
Apache 一脚将 FB+PL 踢出了。这是不是 Apache 在开源暴动中的激进声明？为什么这么说？
| 2017-08-16T17:53:00 | 2017-08-16T17:53:00 | 8,784 |
/article-8784-1.html
|
>
> 本文撰写参考了以下文章，并引用了该文章部分内容：[专利告诉你，为何 Apache 禁用 FB + PL 代码](/article-8764-1.html "专利告诉你，为何 Apache 禁用 FB + PL 代码")，作者：付钦伟。
>
>
>
### 哪里有压迫，哪里就有反抗
身为知识产权圈里的专利人，笔者钦佩开源情怀，并曾写道：即使专利人也有专利情怀，现实世界中开源与专利的碰撞依然难免丑陋。现在看来，这话有点轻描淡写了。
笔者未能认真发掘开源运动史，只好拍拍脑袋认定：**开源软件运动是针对知识产权制度，尤其是专利制度，对软件产业之压迫的暴动。**
“哪里有压迫，哪里就有反抗。”
这场轰轰烈烈的暴动在发展过程中，于 2017 年 7 月，“Apache Software Foundation 主管兼法律事务副主席 Chris Mattmann [正式发表声明称](https://issues.apache.org/jira/browse/LEGAL-303)：Facebook BSD+Patents license（以下简称 FB+PL）已经正式被列入 “[CategoryX](https://www.apache.org/legal/resolved.html#category-x)” 列表，因此 Apache 项目中将不能够包含或依赖于 Facebook Patents license 的代码；而已经发布的代码，涉及 FB+PL 许可证的，需要在 8 月 31 号前完成替换。”
简而言之，Apache 一脚将 FB+PL 踢出了。这是不是 Apache 在开源暴动中的激进声明？为什么这么说？
### 专利情怀
故事要从头讲起：
专利制度产生了，那时候大家并不认为这是一个万恶的吃人的制度。专利制度的根本目的还是促进技术进步，从而推动产业和经济发展。为了达成此目的，则需要合理保护发明人的积极性，具体而言，就是给予他们一定时期的专有保护为回报，在这种利益驱动下，他们会积极的做出发明，并通过申请专利，在向社会公布技术促进技术进步的同时，兑现专有保护。
>
> "Before then [the adoption of the United States Constitution], any man might instantly use what another had invented; so that the inventor had no special advantage from his own invention. The patent system changed this; secured to the inventor, for a limited time, the exclusive use of his invention; and thereby added the fuel of interest to the fire of genius, in the discovery and production of new and useful things. "
>
>
> -- Abraham Lincoln, Second lecture on discoveries and inventions, February 11, 1859
>
>
>
以上这段诠释了专利情怀的话出自美国总统林肯的演讲。只需要读懂这个短句就好了**：专利制度为天才之火添上利益之油。**
### 开源与专利的碰撞
到上世纪 90 年代，专利海盗开始大行其道，软件产业受害最深。在软件行业里，程序员和开发者需要开放、自由地交流和利用彼此的成果才利于行业发展。这一特性先天与专利制度八字不合。这个死结是一百多年的林肯总统绝对意料不到的。
从根本上，开源情怀在于：**对于自己的智力劳动成果，放弃可取得收益的专有权利，给软件松绑，从而利于成果的流通、利用，以及行业发展。**
绑在软件身上的主要知识产权绳索有两条：版权，专利。商标不起核心作用。解开版权这条绳索的方式比较成熟：版权开源许可证。而专利很微妙，最主要的原因是它的无形，主动权常常不在开源作者自己手里。**版权是属于作者的，所以作者有主动权；而专利属于申请人，申请人有主动权，申请人可以是任何第三方。**这是开源与专利之矛盾的根源。
对开源情怀的最大伤害在于：不知道是谁用专利这根无形绳索悄悄捆绑了自己的作品。这是开源人对专利的敏感和敌视的由来。开源人常常感到愤怒和难以理解的是：**为什么自己的智力成果，别人可以用专利来捆上？**
对不起，这一个很让人遗憾的回答：任何人都可以对包括已公开的开源技术在内的任何现有技术做出改进，并就改进获得专利权。而当有别人在某项开源技术比较可行的主要改进方向上都申请了专利，就相当于把主要出路都卡上了，那么这项开源技术也就被别人的专利绑上了。这种专利申请技术，在圈内有一个好听的名字：专利布局。防御性的专利布局可以用来对自己的技术成果形成严密保护。进攻性的专利布局可以用来摘别人的桃子的，包括摘开源的桃子。专利海盗就属于充分、高超地利用专利手段和法律程序，激进地玩进攻性专利布局来摘别人桃子的。有时，手法可以高超到骗过专利审查员的法眼，将与现有技术很接近的内容纳入自己的保护范围。软件行业是重灾区。
应当说，**在专利方面，对开源最大的威胁来自第三方，而不是开源的作者**、后续开发者、用户。在社区内，大家尝试在版权开源许可之外附加专利开源许可，但是因为这种附加许可的效力仅能延伸到后续开发者、用户，不能规制第三方或专利海盗，实质能达到的效果较为有限。
### Facebook 被踢的委屈
现在，我们重新梳理一下 Apache 踢 FB+PL 这件事。Apache 主要是对 Facebook Patents license，即对专利许可的条件不满意才开踢的。
Apache 的表态很干脆地捍卫了开源情怀，但是不是有些偏强硬激进了呢？
对于发展开源事业，首要的问题是什么呢？当然应当是分清谁是朋友，谁是敌人。然后，团结一切可以团结的进步力量，形成对敌统一战线。
笔者猜想，开源的敌人是第三方专利海盗，以及供专利海盗滋生的土壤。Facebook 看起来更像可以团结的朋友：Facebook 对开源有很积极的贡献和推动，其在专利许可方面的动作应当也没有越线。Facebook 如果真想以专利捆绑开源，另安排一个白手套作为第三方来布局专利，岂不干脆彻底？哪里还需要如此费事的搞 Facebook Patents license？**至少应当说，Facebook 还是出于基本善意的立场提出的专利许可。**
### 扒扒 Facebook 专利许可
再深入剖析这个问题，就要梳理 Facebook Patents license 的主要条款对开源的影响了。
[Facebook Patents license 的主要条款](https://github.com/facebook/react/blob/master/PATENTS)：
>
> Additional Grant of Patent Rights Version 2
>
>
> "Software" means the React software distributed by Facebook, Inc.
>
>
> Facebook, Inc. ("Facebook") hereby grants to each recipient of the Software
> ("you") a perpetual, worldwide, royalty-free, non-exclusive, irrevocable
> (subject to the termination provision below) license under any Necessary
> Claims, to make, have made, use, sell, offer to sell, import, and otherwise
> transfer the Software. For avoidance of doubt, no license is granted under
> Facebook's rights in any patent claims that are infringed by (i) modifications
> to the Software made by you or any third party or (ii) the Software in
> combination with any software or other technology.
>
>
> The license granted hereunder will terminate, automatically and without notice,
> if you (or any of your subsidiaries, corporate affiliates or agents) initiate
> directly or indirectly, or take a direct financial interest in, any Patent
> Assertion: (i) against Facebook or any of its subsidiaries or corporate
> affiliates, (ii) against any party if such Patent Assertion arises in whole or
> in part from any software, technology, product or service of Facebook or any of
> its subsidiaries or corporate affiliates, or (iii) against any party relating
> to the Software. Notwithstanding the foregoing, if Facebook or any of its
> subsidiaries or corporate affiliates files a lawsuit alleging patent
> infringement against you in the first instance, and you respond by filing a
> patent infringement counterclaim in that lawsuit against that party that is
> unrelated to the Software, the license granted hereunder will not terminate
> under section (i) of this paragraph due to such counterclaim.
>
>
> A "Necessary Claim" is a claim of a patent owned by Facebook that is
> necessarily infringed by the Software standing alone.
>
>
> A "Patent Assertion" is any lawsuit or other action alleging direct, indirect,
> or contributory infringement or inducement to infringe any patent, including a
> cross-claim or counterclaim.
>
>
>
简要而言，关键点有两个：
* Facebook 对免费专利许可设了限制条件：你不可以诉我知识产权侵权；
* 专利许可所涉及的专利，仅限于所涉及的开源软件本身，对于软件修改后或与其他技术共同使用而可能侵犯的专利，不在许可之列。
### 法律背景扑朔迷离
即使分析以上两个要点，也要仔细衡量，须考虑现实背景中的重要因素：
* 如果无专利许可，会如何？
* 许可不涉及实质性的对价。
* 许可涉及复杂的国际司法环境。
笔者认为，许可条款之外的上述背景中的三条因素才真正使许可的效力变得扑朔迷离。
就背景因素 1 而言，现实情况中，普遍存在开源许可证仅涉及版权而回避了专利的情况。这是社区当中大家普遍可以接受的条件。未提及专利，并不等于没有给予专利许可，尤其在许可证中没有明示“专利要另收钱”的情况下。有一个奇妙的东西，可以叫作基于诚实信用或善意公平原则的“默认许可”。
何为“默认许可”？简单讲，当你给人家什么东西去用，没有明示这个东西要收钱，人家用了之后，你向人家去收钱，这么做不太厚道吧？基于诚实信用或善意公平原则，通常法院不会支持这种像是给人下了套，然后去收钱的行为的，而会认为当你给人家东西去用，没有明示这个东西要收钱时，已经“默认许可”人家免费用了。
开源软件的作者或提供者，同时又作为相关专利的专利权人时，在提供了明确免除版权费用的许可证的情况下，如果在向用户交付产品的同时，没有明示要收取专利费，“默认许可”应当成立。从学术讨论的角度，也有将之称为“专利权权利用尽”的。但是由于未收钱，“专利权权利用尽”的成立更有困难些。笔者还是坚持“默认许可”路线。
但还是很遗憾，法律世界不同于软件世界。在软件世界里，每一段算法程序，在给定条件后，都会给你执行出一个清楚的结果。法律世界里很难如此。“默认许可”是否会得到司法完全支持？真的很难讲，各个国家，甚至一个国家在不同时期，都可能对相似的情况采取不同的思路并给出不同的分寸和方向的判决。在美国、英国、澳大利亚等海洋法系的国家，前后判例的一致性会比较高。而中国、德国等大陆法系国家，变化可能较大。以下将要讨论的诸多问题均受各国司法差异因素影响，以下不再赘述。
总之，不确定性较大。**尽管笔者对各国实际判例缺少一手研究，但从法理和情理上倾向于在专利“默认许可”成立，即利于开源免费。**
就背景因素 2 而言，许可是否涉及实质性的对价是很重要的因素。实际上，我们现在讨论的是许可证，性质又不同于协议，但一些相关因素可以类比来考虑。没有实质性对价，指没有因交易性的收获进行实质支付，比如，支付价款。在这种情形下，许可证或协议在性质上更类似于赠与，对有关方的权利义务要求未必牢固。比如，Facebook 将自己开发的软件拿出来开源，自己付出了开发成本，却没有向使用者收取费用；使用者可以较随意地拿 Facebook 的开源软件免费使用。如果由于这种免费的行为中暗藏玄机，而导致 Facebook 或使用者要承受重大的义务、付出重大代价，则是有失基本公平的，除非有特别原因。所以，各国从司法的角度，会考虑“是否涉及实质性的对价”这一因素，但仍然是会采取不同的思路并给出不同的分寸和方向的判决。简而言之，**Facebook Patents license 并不涉及实质性的对价，所以司法层面不会随便基于这种许可而使有关方承担与对价不相匹配的重大义务。**
总之，还是不确定性较大，尽管笔者还是对各国实际判例缺少一手研究，但从法理和情理上仍倾向于 Facebook Patents license 因不存在实质性对价，相关方带来重大义务或损失的可能性较低，即利于开源免费。
背景因素 3 已经融合在以上讨论之中了。
综合以上背景因素的讨论，**可知 Facebook Patents license 对开源还是比较友好的，至少不会造成重大损害。**
### Facebook，面子大于里子
再审视 Facebook Patents license 的两个关键点，其对“默认许可”是否仍能成立各有微妙影响。笔者的观点是，很可能使情形确实反而不如没有这个 Facebook Patents license，不过负面影响有限。
就关键点 1，Facebook 对免费专利许可设了限制条件：你不可以诉我知识产权侵权。
明示的效力当然优于默认的效力，所以笔者倾向认为默认许可的效力被破坏了。但以下三个因素将对开源有利：
* 用户对 Facebook 发起诉讼时，许可终止，但用户此前的使用仍享受免费许可。所以，主动权还是在用户手里，可以选择有利形势。当用户认为自己更多的知识产权为 Facebook 所使用，份量重于自己所使用的 Facebook 开源软件的知识产权时，才发起诉讼，并在诉讼前做好调整和准备；如果自己用的 Facebook 的知识产权比较多，而被 Facebook 使用的知识产权少，自己还是在赚便宜，何必去找 Facebook 麻烦呢？更应当指出，Facebook 所设的这个条件较容易做被规避：可以将专利转移给第三人，也就是白手套，由白手套去诉 Facebook。这样，即可以继续享受免费许可，又可以搞 Facebook。这在法理上是成立的。
* 对单一用户来讲，出现要诉 Facebook 而会破坏免费许可这一情况的现实可能性较低。
* Facebook 此条件有构成滥用知识产权的风险。
以上第 1 条实际上已经能够让 Facebook 的关键点 1 形同虚设，达不成实际意义了。以上第 3 条，不确定性很大。
就关键点 2，专利许可所涉及的专利，仅限于所涉及的软件本身，对于软件修改后或与其他技术共同使用而可能侵犯的专利，不在许可之列。
关键点 2 实际上暗藏杀机，比形同虚设的关键点 1 凶险些，但实际威力也还有限。重点在于：
* Facebook 明示不予许可的专利：软件修改后或与其他技术共同使用而可能侵犯的专利，实际上照样可能将开源软件捆死。这是其心机最凶险之处。
* 尽管 Facebook 明示排除了软件修改后或与其他技术共同使用而可能侵犯的专利，但只是泛泛而论。实际上，用户修改软件或将之与其他技术共同使用是必然普遍发生的情况，如果 Facebook 没有及时向用户提示这些具体专利的存在，并对收费有明确具体要求，笔者倾向于默认许可的效力仍应成立。当然，不确定性仍然较大。“及时向用户提示”指对于软件交付之前已经持有的专利，应在软件交付前明确提示；对于软件交付之后获得的专利，应在专利获得后马上提示。
综上，尽管复杂的不确定性仍较多，笔者倾向于认为 Facebook Patents license 总体上对开源较为友善，与不涉及专利的许可证相比较，没有带来实质性变劣。**对 Facebook 而言，可能象征意义更大于实质意义，即面子大于里子。**
### Apache 潜在风险
另外，还有一个潜在风险因素，使 Apache 踢掉 FB+PL 之后使自己处在更为不利的境地。
Apache的风险控制措施是：“Apache 项目中将不能够包含或依赖于 Facebook Patents license 的代码；而已经发布的代码，涉 及FB+PL 许可证的，需要在 8 月 31 号前完成替换。”这一措施理论上说说还好，但在可操作性上问题很多。笔者认为，剔除 FB+PL 版权许可证所涉及的内容比较好操作：只要剔除相关的代码，替之以其他来源或自编的代码就好了。因为其他来源或自编的代码，基本就能确保在表达方式上的不同，从而规避版权侵权。这是现实的操作方式。
而规避侵犯 Facebook 专利权，上述方式很可能并不奏效。简单而言，版权保护表达形式，专利保护构想。规避表达形式，也就是从表述方式上加以实质调整就可以做到了。而规避构想，确实很难。实际上，Facebook 到底有哪些专利与之相关恐怕也很不清晰，还要加以规避，就更是难上加难了。分析工作和代码的重新设计对专利的专业性要求非常高，工作很复杂，工作量也很大。
**这种情况下，Apache 可能面对的最坏情况是：放弃了 FB+PL 的开源代码，仍存在侵犯 Facebook 专利的高风险，又不会得到 Facebook 明示、默认许可。**
### Apache 的激进开源
所以，笔者认为，Apache 的表态很干脆地捍卫了开源情怀，踢掉 FB+PL 的行事方式有可能略偏强硬激进，尽管从规避不确定的风险而言，也不是完全没有道理。
（题图：HuffPost）
---
作者简介：
**李可**
集慧智佳知识产权咨询公司，李可。江湖人称“可哥”，老牌专利代理人，知识产权高级咨询师。70 后文艺理工男，属牛，性子慢但踏实稳妥。
|
||||
独家专访 MIT 2017 年度 TR35 吴翰清
|
老王
|
上月在北京举办的网络安全生态峰会上，我与吴翰清有过一次深入的独家专访。本文特别采用问答形式，希望还原这位最新的 TR35 获奖者在技术领域的深度思考。
|
/data/attachment/album/201708/16/221057uqfdqlb886zv8dbz.jpeg.thumb.jpg
|
/data/attachment/album/201708/16/221057uqfdqlb886zv8dbz.jpeg
| true | false | false | false |
[
"吴翰清",
"阿里云"
] |
穿山甲专访
|
{
"viewnum": 10613,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
上月在北京举办的网络安全生态峰会上，我与吴翰清有过一次深入的独家专访。本文特别采用问答形式，希望还原这位最新的 TR35 获奖者在技术领域的深度思考。
| 2017-08-16T22:11:00 | 2017-08-16T22:11:00 | 8,785 |
/article-8785-1.html
|
**先分享一个好消息：今天<ruby> 《麻省理工学院科技评论》 <rp> （ </rp> <rt> MIT Technology Review </rt> <rp> ） </rp></ruby>杂志揭晓 [2017 年全球青年科技创新人才榜（TR35）](https://www.technologyreview.com/lists/innovators-under-35/2017)评选结果，阿里巴巴人工智能实验室首席科学家王刚、[阿里云首席安全科学家吴翰清脱颖而出](https://www.technologyreview.com/lists/innovators-under-35/2017/pioneer/hanqing-wu/)，获此殊荣。**
*TR 35 获奖者 吴瀚清*
TR35 是一个针对 35 岁以下青年科技才俊，为找出最有可能改变世界的牛人而设立的奖项。
自 1999 年以来，该杂志每年会在全球 IT（计算机、通信、网络）和生物医药、商业等领域内，从影响力、创新力、进取力、未来潜力、沟通力五个维度进行评估，挖掘学术界和工业界的 35 位科技创新精英。
从以往的上榜者来看，说 TR 35 是预言人类进程的先知也不为过。Google 联合创始人拉里·佩奇（2002 年）和谢尔盖·布林（2002 年），Linux 之父林纳斯·托瓦兹（1999 年），Facebook创始人马克·扎克伯格（2007 年），Yahoo 创始人杨致远（1999 年），Apple 设计总监乔纳夫·伊森（1999 年）等，都曾是该奖的座上宾。如今，他们正在改变我们所处的世界，甚至影响人类进步的方向。
正因如此，TR35 的门槛极高。据统计，从 1999 年到 2016 年，共评选出 820 名 TR35，中国入选者仅 17 人。今年，阿里巴巴有两位科学家同时入选，创下中国互联网科技企业的先例。
非常荣幸，上月在北京举办的网络安全生态峰会上，我与吴翰清有过一次深入的独家专访。本文特别采用问答形式，希望还原吴翰清在技术领域的深度思考。
### **一、云计算终极目标：实现飞机那样的技术普惠**
**老王**：
网络攻击和渗透行为日益增多，给社会和企业带来巨大危害。但并不是每个企业都有足够的预算和技术能力来迎接安全风险的威胁。
安全服务也能像水、电、网这样的基础服务一样，可以随时购买、随时使用，而不用关心很多引擎盖下面的技术细节？
**吴瀚清**：
我自己觉得这个问题得分成两部分来看。
首先，今天整个云端团队，或者阿里云安全团队希望成为互联网安全的一种基础设施。既然它是基础设施，它对于很多的人来说，就应该是普惠的，如同今天的水、电、网一样。在这个层面上来讲，我们希望把安全服务做的更加的透明一些，更加的无感知一些。
从技术的角度来讲，有一些问题通过弹性安全网络就有可能解决掉。
但网络安全服务其实是一个研究对抗的问题，只要是人与人之间的对抗，只要还要有坏人存在，就一定有新的安全问题会涌现出来，只是会随着技术发展不断更新。
比如，过去从 PC 走向了互联网、移动互联网，再走向 IoT，所有的安全问题也是跟随着 PC 的发展，然后到互联网，再到移动互联网的安全问题，到未来是研究 IoT 的安全问题。
另一方面，其实我觉得云计算的安全方面，或者云计算本身，它非常像飞机。比如说你要造一架飞机，用到的技术是极其复杂的，但是今天我们每个人都能够用非常便宜的价格，去享受这个航班的服务。所以我觉得这就是里面的差别。
就是说，我们要重新去发明一项技术，把它做到足够成熟是需要非常专业的人，花非常大的代价去把它做出来的。但是，最后我们要把这个非常复杂的技术，做到每个人都能够用。每个人都能够用最低的成本、最低的门槛去使用。
我觉得这个就是云计算所要追求的目标。就是要让技术变的普惠。让每个人都能够非常简单的去用非常复杂的技术。
对于普通客户，他并不需要理解一架飞机的原理，它只要能乘坐就好。
### **二、安全边界将会越来越模糊**
**老王**：
怎么样才能让用户，在需要时能够感知到安全，没有遇到安全问题的时候实现隐形。这个安全边界是怎么确定比较好？
**吴瀚清**：
AWS 提出了责任共担模型，他们认为操作系统之下的都是他们来负责；操作系统之上的都是客户自己来负责的，比如客户自己写的应用，比如自己管理的一些系统，比如客户配置出现了问题，都是要客户自己来负责的。但是操作系统之下，进程本身的安全，包括底层基础设施的安全，这些都是由 AWS 来负责。他们把这个边界划在这里。
但是我觉得这个边界，也不是一成不变的，它会随着软件架构的演进而不断发生变化。
边界会越来越模糊，而且我们整个技术是在进步的，所以在我的理解里，云计算是不需要像 Windows 跟 Linux 这样的 PC 时代的操作系统的。
因为今天大量的云时代的应用，或者互联网时代的应用，实际上就是用代码直接操作数据，其实并不需要关心底层操作系统。从这个角度来讲，今天这些程序员写代码的方式将来都是需要变化的。当计算时代真正到来的时候，比如说现在 AWS 就在推 serverless 这样的一些东西，谷歌也有 GCE，类似这些东西，实际上它真正代表的是未来我们写代码操作数据的方式。
所以回到未来来看，今天你所关心的很多的软件问题，在那个时候已经不再是一个问题了。因为都被云计算公司封装到了它的责任范围之内，所以我觉得这条线、这个边界是在不断地演进的，而且它的封装是越来越完整的。
### **三、未来五年，安全看** **IoT** **和** **AI**
**老王**：
你们现在有没有考虑到三年、五年以后的安全势态会怎么样，会不会研发相应的产品和技术？
**吴瀚清**：
我觉得未来要抓的两件事情，还是相对比较明确。
在战略思考方面，第一个就是抓 IoT。可能在整个 IoT 这方面，最根本的一个东西就是认证体系，它应该是从一个硬件芯片开始，通过证书做硬件的加密和认证，然后通过信任链的传递，在整个 IoT 里面我们就会有一个可信的计算环境。我们今天在 IoT 的安全方面，已经有一些解决方案。
另外一件，我觉得 AI 是我们这个时代接下来需要重点去抓的事情，它带来的这个变化，可能会超过我们所有人的想象，它可能会像手机出现的时候，会对这个世界带来这么大的影响和变化。所以今天如何把 AI 应用在我们安全技术本身，这个是我们今天要去思考的。
### **四、对网络暴力斗争到底**
老王：
在安全圈子里，有没有攻击者和厂商互相勾结？
**吴瀚清**：
从这个行业乱象来讲，今天一定存在你刚才说的这种黑与白的互相勾结，或者收取保护费的事情。
特别在我所了解的高防这个产业，实际上有一些这样的乱象的，就是攻击者和收保护费的实际上是同一波人。但是今天从其他的一些我所了解的一些厂商来说，比如说像今天的阿里，或者我们的一些友商，他们是绝对不会做这种事情。
因为对于阿里自己来说，对我们来说每一次大的攻击的挑战，实际上都是一次磨炼我们技术的机会，如果我们不去正面迎接这种挑战，我们的技术就不会进步。错过了我们技术进步的这个机会，我觉得这才是对阿里来说更大的一个损失。所以面对这种网络暴力，实际上我们更加采取的是这种绝不宽容的这种态度，一定会去斗争到底的。
### **五、安全和开源、闭源没有关系**
**老王**：
你对开源与安全是怎么看的？它们之间有没有必然联系？有什么样的联系？
**吴瀚清**：
我觉得安全不安全，跟开源还是闭源没有直接的关系。但是它跟这个软件背后的这个运营方是有关系的。
比如就开源软件来讲，有很多很多的开源软件，确实对整个互联网作出了不可磨灭的贡献。但是也有很多开源软件，它的软件开发者是非常、非常缺乏安全意识的。
像 Linux 这种，它本身有一个非常好的基金会，它的开发者都是非常资深的软件工程师，本身又有非常好的安全意识和非常完善的机制。从这个角度来讲，Linux 本身的安全，我觉得是做的非常不错的，而且它也在持续的、不断推出一些新的安全功能。
回到闭源软件这一边，比如微软本身就建立了非常好的一个应急响应机制，它本身建立了非常大的安全团队来做安全这个事情。从这个角度来讲，微软的安全也做的不错。
在我看来，更重要的应该去关注应急响应，这应该是整个安全机制里面最重要的一些事情。甚至我觉得，应该占到整个安全工作的 50%。另外 50% 的工作就是检测，所以安全实际上就是做两件事情，就是检测和响应。
所以在这里面我们做的很多工作，都可以看成应急响应的一部分。比如说你发现问题之后，你去做这个漏洞的修补，以及定期检查之后做的加固。包括通知机制，实际上都是应急响应需要去做的。应急响应不仅仅是解决具体某一个漏洞的问题，它还包括一系列的问题，包括安全的分析，以及产品能力本身的提升，比如说这次响应没有做好，下一次你的产品是不是有更强的能力来提升？
同时这还涉及到一个对外舆情的问题。这种应急响应是不是会带来恐慌？比如说有一些安全问题，完全是炒作漏洞，很多客户就会引发恐慌，这时候你能不能通过技术分析出来拨乱反正？所以有很多这样的问题，综合起来就会变成一个体系。
我们觉得今天可能更多的东西，应该是从实践中来的。所以几乎阿里云每周都在进行安全响应，每周都在响应两到三次。所以就会把我们的一套非常高效的流程给逼出来。
在未来我们也希望在这一块能够帮到更多的企业，我们在应急响应这块，也希望能够推出更多的产品和服务。
### **六、坚持产品的使命是最根本的东西**
**老王**：
你是阿里云的初创成员之一，也是阿里云安全团队初创成员。是否可以分享一下如何规划团队的技术和发展？
**吴瀚清**：
阿里本身也是一家使命驱动的公司。所以这两点，造成我们的做事方式实际上还是有迹可循的。
今天在所有的战略思考和所有的坚持上面，我们的使命一直是建设互联网安全的基础设施。
从这个角度来讲，我们会做很多、很多的东西。我们现在的产品，不管这个产品的形态如何发生变化，可能会经历一些阶段性的失败，但是我们的产品，最终它要去的那个地方，是始终没有动摇过的。
像我们的高防产品，我们第一天就打出一个使命，就是我们要消灭互联网的 DDoS，这是我们和其他所有做高防产品厂商的区别。他们都是希望 DDoS 存在的，因为这个能带来业务收入。
但是我们今天不在乎靠这个反 DDoS 产品赚钱，虽然今天我们的主要收入确实来自这个产品。这是一个现状，但是未来我们要去的地方-------我们是希望消灭整个互联网的 DDoS 的。我也觉得，只有真正到了那一天，我们对这个互联网和对这个社会的贡献的价值足够大，才会有足够大的商业空间诞生出来。我觉得这是我对整个商业的一个理解。
所以我觉得，今天在整个使命愿景的坚持上面，是我们最根本的东西，今天经历的所有的波折，实际上都是可以根据时间随着来调整的。
### **七、给年轻从业者的建议**
**老王**：
现在有很多年轻人想从事安全服务行业。作为一个资深的网络安全专家，有什么建议？
**吴瀚清**：
我觉得主要是三件事情。第一件就是多看一些书；第二件是多去见一些真正优秀的人；第三件是多经历一些事情。
回到安全服务这个行业，我觉得除了多看书之外，动手能力是最重要的。我觉得这个对于所有从事计算机产业的年轻人，都是非常重要的一个建议。就是动手远比从书本上看东西要重要------当然看书也很重要。
再就是能够多接触一些行业里面真正优秀的顶尖人物，我觉得这是需要他自己不断去找机会去拓展的。
安全这个行业，我觉得跟其他产业不太一样的地方，就是在于今天我们是在里面有一个对抗存在，涉及到正义与邪恶的，我希望未来的年轻人不要走上邪路，要站在正义的这一方，真正成为光明的守护者，去保护我们人民财产的安全。
### **采访后记**
对吴瀚清的采访就到这里，**从和吴瀚清的交谈中，我能体会到真正纯粹的技术专家的赤子之心，也能感受到吴瀚清和他的团队对安全的热爱和社会责任感，其所一直践行的，或许就是他的“道”吧。**
采访者：老王，Linux 中国开源社区的创始人，曾任职亚信旗下的玛赛系统安全公司的华东区技术总监，中国电信系统集成公司网络安全事业部高级专家。
|
||||
Debian 庆祝 24 岁生日
|
Marius Nestor
|
http://linux.softpedia.com/blog/happy-24th-birthday-debian-517413.shtml
|
2017 年 8 月 16 日，Debian 操作系统度过了它的第 24 个生日，这个由 Linux 内核所驱动的操作系统，由其创始人 Ian Murdock 发布于 1993 年的同一天。
|
/data/attachment/album/201708/17/100307bblrl5ty5h55r9bl.jpg.thumb.jpg
|
/data/attachment/album/201708/17/100307bblrl5ty5h55r9bl.jpg
| true | false | true |
wxy
| false |
[
"Debian"
] |
新闻
|
{
"viewnum": 4876,
"commentnum": 13,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "218.26.54.134",
"message": "生日快乐",
"username": "来自山西吕梁的 Chrome Mobile 58.0|Android 5.0 用户",
"date": "2017-08-17T11:05:54"
},
{
"postip": "36.110.22.58",
"message": "Debian用戶前來報道～",
"username": "来自浙江的 Vivaldi 1.92|GNU/Linux 用户",
"date": "2017-08-17T11:14:13"
},
{
"postip": "222.210.108.99",
"message": "我是debian系用户，也来报道一个～",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-17T11:18:52"
},
{
"postip": "218.205.134.106",
"message": "Deepin 用户也来报报个到",
"username": "来自北京的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-17T16:52:30"
},
{
"postip": "222.77.20.122",
"message": "Debian用户发来贺电",
"username": "来自福建泉州的 Chrome Mobile 60.0|Android 7.1 用户",
"date": "2017-08-17T17:00:23"
},
{
"postip": "60.162.21.192",
"message": "红帽用户发来贺电",
"username": "来自浙江台州的 Firefox 54.0|Windows 10 用户",
"date": "2017-08-17T19:17:52"
},
{
"postip": "113.201.60.142",
"message": "发来贺电！！！恭贺自由开源演进的Debian Gnu/Linux",
"username": "来自陕西西安的 Chrome 47.0|Windows 7 用户",
"date": "2017-08-17T19:42:27"
},
{
"postip": "222.128.135.0",
"message": "我也来表示一下",
"username": "来自北京的 Firefox 56.0|GNU/Linux 用户",
"date": "2017-08-17T19:57:40"
},
{
"postip": "123.116.156.110",
"message": "纪念Ian",
"username": "shengwenbo [Safari 10.1|Mac 10.12]",
"date": "2017-08-17T23:05:31"
},
{
"postip": "183.14.28.226",
"message": "北方光棍 发来贺电。",
"username": "何亮 [Chrome 59.0|Windows 7]",
"date": "2017-08-18T10:38:46"
},
{
"postip": "210.75.18.197",
"message": "南方独狼，发来贺电！",
"username": "来自广东深圳的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-18T11:24:25"
},
{
"postip": "175.141.33.135",
"message": "恭喜! 没有你, <br />\r\n哪会有 Ubuntu 的诞生.",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-18T23:06:16"
},
{
"postip": "218.247.7.212",
"message": "我去，跟我同岁。",
"username": "贵在坚持 [Chrome 59.0|Windows 10]",
"date": "2017-08-21T15:18:41"
}
] |
[] |
2017 年 8 月 16 日，Debian 操作系统度过了它的第 24 个生日，这个由 Linux 内核所驱动的操作系统，由其创始人 Ian Murdock 发布于 1993 年的同一天。
| 2017-08-17T10:14:13 | 2017-08-17T10:14:13 | 8,786 |
/article-8786-1.html
|
****
2017 年 8 月 16 日，Debian 操作系统度过了它的第 24 个生日，这个由 Linux 内核所驱动的操作系统，由其创始人 Ian Murdock 发布于 1993 年的同一天。
每年的 8 月 16 日这一天，被 [Debian Project](https://www.debian.org/) 确定为 Debian 日，全世界各地的 Debian 爱好者会在这一天[举办各种庆祝活动](https://wiki.debian.org/DebianDay/2017)。
“如果你附近有城市在举办 2017 Debian 日 ，非常欢迎你前往参加，”Laura Arjona Reina 在[博文](https://bits.debian.org/2017/08/debian-turns-24.html)中说到，“如果没有的话，你来组织一个也很好！”
Debian GNU/Linux 是 Linux 社区里最受欢迎的 Linux 操作系统之一，也有大量的发行版衍生自此，这包括 Ubuntu 和 Linux Mint。
Debian GNU/Linux 的最新发布版本是 9.1.0 （Stretch），你可以从 Debian 官方网站下载安装镜像或者现场版镜像。这个操作系统支持十种之多的硬件架构。
我们对 Debian 的生日送上我们的良好祝福，我们已经迫不及待地想要看到即将来到的 Debian GNU/Linux 10 "Buster" 了。
生日快乐！ Debian！
|
||
用 R 收集和映射推特数据的初学者向导
|
Dorris Scott
|
https://opensource.com/article/17/6/collecting-and-mapping-twitter-data-using-r
|
学习使用 R 的 twitteR 和 leaflet 包, 你就可以把任何话题的推文定位画在地图上。
|
/data/attachment/album/201708/17/150211n9wjnx9pk91f4wtk.png.thumb.jpg
|
/data/attachment/album/201708/17/150211n9wjnx9pk91f4wtk.png
| true | false | true |
XYenChi
| false |
[
"R语言",
"Twitter"
] |
软件开发
|
{
"viewnum": 5311,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习使用 R 的 twitteR 和 leaflet 包, 你就可以把任何话题的推文定位画在地图上。
| 2017-08-17T15:02:07 | 2017-08-17T15:02:07 | 8,787 |
/article-8787-1.html
|
>
> 学习使用 R 的 twitteR 和 leaflet 包, 你就可以把任何话题的推文定位画在地图上。
>
>
>
当我开始学习 R ，我也需要学习如何出于研究的目的地收集推特数据并对其进行映射。尽管网上关于这个话题的信息很多，但我发觉难以理解什么与收集并映射推特数据相关。我不仅是个 R 新手，而且对各种教程中技术名词不熟悉。但尽管困难重重，我成功了！在这个教程里，我将以一种新手程序员都能看懂的方式来攻略如何收集推特数据并将至展现在地图中。
### 创建应用程序
如果你没有推特帐号，首先你需要 [注册一个](https://twitter.com/signup)。然后，到 [apps.twitter.com](https://apps.twitter.com/) 创建一个允许你收集推特数据的应用程序。别担心，创建应用程序极其简单。你创建的应用程序会与推特应用程序接口（API）相连。 想象 API 是一个多功能电子个人助手。你可以使用 API 让其它程序帮你做事。这样一来，你可以接入推特 API 令其收集数据。只需确保不要请求太多，因为推特数据请求次数是有[限制](https://dev.twitter.com/rest/public/rate-limiting) 的。
收集推文有两个可用的 API 。你若想做一次性的推文收集，那么使用 **REST API**. 若是想在特定时间内持续收集，可以用 **streaming API**。教程中我主要使用 REST API。
创建应用程序之后，前往 **Keys and Access Tokens** 标签。你需要 Consumer Key (API key)、 Consumer Secret (API secret)、 Access Token 和 Access Token Secret 才能在 R 中访问你的应用程序。
### 收集推特数据
下一步是打开 R 准备写代码。对于初学者，我推荐使用 [RStudio](https://www.rstudio.com/)，这是 R 的集成开发环境 (IDE) 。我发现 RStudio 在解决问题和测试代码时很实用。 R 有访问该 REST API 的包叫 **[twitteR](https://cran.r-project.org/web/packages/twitteR/twitteR.pdf)**。
打开 RStudio 并新建 RScript。做好这些之后，你需要安装和加载 **twitteR** 包:
```
install.packages("twitteR")
#安装 TwitteR
library (twitteR)
#载入 TwitteR
```
安装并载入 **twitteR** 包之后，你得输入上文提及的应用程序的 API 信息：
```
api_key <- ""
#在引号内放入你的 API key
api_secret <- ""
#在引号内放入你的 API secret token
token <- ""
#在引号内放入你的 token
token_secret <- ""
#在引号内放入你的 token secret
```
接下来，连接推特访问 API：
```
setup_twitter_oauth(api_key, api_secret, token, token_secret)
```
我们来试试让推特搜索有关社区花园和农夫市场：
```
tweets <- searchTwitter("community garden OR #communitygarden OR farmers market OR #farmersmarket", n = 200, lang = "en")
```
这个代码意思是搜索前 200 篇 `(n = 200)` 英文 `(lang = "en")` 的推文, 包括关键词 `community garden` 或 `farmers market` 或任何提及这些关键词的话题标签。
推特搜索完成之后，在数据框中保存你的结果：
```
tweets.df <-twListToDF(tweets)
```
为了用推文创建地图，你需要收集的导出为 **.csv** 文件:
```
write.csv(tweets.df, "C:\Users\YourName\Documents\ApptoMap\tweets.csv")
#an example of a file extension of the folder in which you want to save the .csv file.
```
运行前确保 **R** 代码已保存然后继续进行下一步。.
### 生成地图
现在你有了可以展示在地图上的数据。在此教程中，我们将用一个 R 包 **[Leaflet](https://rstudio.github.io/leaflet)** 做一个基本的应用程序，这是一个生成交互式地图的热门 JavaScript 库。 Leaflet 使用 [magrittr](https://github.com/smbache/magrittr) 管道运算符 (`%>%`)， 因为其语法自然，易于写代码。刚接触可能有点奇怪，但它确实降低了写代码的工作量。
为了清晰起见，在 RStudio 打开一个新的 R 脚本安装这些包：
```
install.packages("leaflet")
install.packages("maps")
library(leaflet)
library(maps)
```
现在需要一个路径让 Leaflet 访问你的数据：
```
read.csv("C:\Users\YourName\Documents\ApptoMap\tweets.csv", stringsAsFactors = FALSE)
```
`stringAsFactors = FALSE` 意思是保留信息，不将它转化成 factors。 (想了解 factors，读这篇文章["stringsAsFactors: An unauthorized biography"](http://simplystatistics.org/2015/07/24/stringsasfactors-an-unauthorized-biography/)， 作者 Roger Peng）
是时候制作你的 Leaflet 地图了。我们将使用 **OpenStreetMap**基本地图来做你的地图：
```
m <- leaflet(mymap) %>% addTiles()
```
我们在基本地图上加个圈。对于 `lng` 和 `lat`，输入包含推文的经纬度的列名，并在前面加个`~`。 `~longitude` 和 `~latitude` 指向你的 **.csv** 文件中与列名：
```
m %>% addCircles(lng = ~longitude, lat = ~latitude, popup = mymap$type, weight = 8, radius = 40, color = "#fb3004", stroke = TRUE, fillOpacity = 0.8)
```
运行你的代码。会弹出网页浏览器并展示你的地图。这是我前面收集的推文的地图：
带定位的推文地图，使用了 Leaflet 和 OpenStreetMap [CC-BY-SA](https://creativecommons.org/licenses/by-sa/2.0/)
虽然你可能会对地图上的图文数量如此之小感到惊奇，通常只有 1% 的推文记录了地理编码。我收集了总数为 366 的推文，但只有 10（大概总推文的 3%）是记录了地理编码的。如果你为得到记录了地理编码的推文而困扰，改变搜索关键词看看能不能得到更好的结果。
### 总结
对于初学者，把以上所有碎片结合起来，从推特数据生成一个 Leaflet 地图可能很艰难。 这个教程基于我完成这个任务的经验，我希望它能让你的学习过程变得更轻松。
（题图：[琼斯·贝克](https://opensource.com/users/jason-baker). [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). 来源: [Cloud](https://pixabay.com/en/clouds-sky-cloud-dark-clouds-1473311/), [Globe](https://pixabay.com/en/globe-planet-earth-world-1015311/). Both [CC0](https://creativecommons.org/publicdomain/zero/1.0/).）
---
作者简介：
Dorris Scott - Dorris Scott 是佐治亚大学的地理学博士生。她的研究重心是地理信息系统（GIS）、 地理数据科学、可视化和公共卫生。她的论文是在一个 GIS 系统接口将退伍军人福利医院的传统和非传统数据结合起来，帮助病人为他们的健康状况作出更为明朗的决定。
---
via: <https://opensource.com/article/17/6/collecting-and-mapping-twitter-data-using-r>
作者：[Dorris Scott](https://opensource.com/users/dorrisscott) 译者：[XYenChi](https://github.com/XYenChi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Snapcraft 构建、测试并发布 Snap 软件包
|
Ricardo Feliciano
|
https://insights.ubuntu.com/2017/06/28/build-test-and-publish-snap-packages-using-snapcraft/
|
snapcraft 是一个正在为其在 Linux 中的地位而奋斗的包管理系统，它为你重新设想了分发软件的方式。这套新的跨发行版的工具可以用来帮助你构建和发布 snap 软件包。接下来我们将会讲述怎么使用 CircleCI 2.0 来加速这个过程以及一些在这个过程中的可能遇到的问题。
|
/data/attachment/album/201708/17/222938ba28a8i27q99ifa9.jpg.thumb.jpg
|
/data/attachment/album/201708/17/222938ba28a8i27q99ifa9.jpg
| true | false | true |
Snapcrafter
| false |
[
"snap"
] |
技术
|
{
"viewnum": 8237,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "121.194.155.50",
"message": "这玩意本身不是个自由开源软件",
"username": "来自北京中央财经大学的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-20T17:40:54"
}
] |
[] |
snapcraft 是一个正在为其在 Linux 中的地位而奋斗的包管理系统，它为你重新设想了分发软件的方式。这套新的跨发行版的工具可以用来帮助你构建和发布 snap 软件包。接下来我们将会讲述怎么使用 CircleCI 2.0 来加速这个过程以及一些在这个过程中的可能遇到的问题。
| 2017-08-18T08:42:00 | 2017-08-18T08:42:00 | 8,788 |
/article-8788-1.html
|
snapcraft 是一个正在为其在 Linux 中的地位而奋斗的包管理系统，它为你重新设想了分发软件的方式。这套新的跨发行版的工具可以用来帮助你构建和发布 snap 软件包。接下来我们将会讲述怎么使用 CircleCI 2.0 来加速这个过程以及一些在这个过程中的可能遇到的问题。
### snap 软件包是什么？snapcraft 又是什么？
snap 是用于 Linux 发行版的软件包，它们在设计的时候吸取了像 Android 这样的移动平台和物联网设备上分发软件的经验教训。snapcraft 这个名字涵盖了 snap 和用来构建它们的命令行工具、这个 [snapcraft.io](https://snapcraft.io/) 网站，以及在这些技术的支撑下构建的几乎整个生态系统。
snap 软件包被设计成用来隔离并封装整个应用程序。这些概念使得 snapcraft 提高软件安全性、稳定性和可移植性的目标得以实现，其中可移植性允许单个 snap 软件包不仅可以在 Ubuntu 的多个版本中安装，而且也可以在 Debian、Fedora 和 Arch 等发行版中安装。snapcraft 网站对其的描述如下：
>
> 为每个 Linux 桌面、服务器、云端或设备打包任何应用程序，并且直接交付更新。
>
>
>
### 在 CircleCI 2.0 上构建 snap 软件包
在 CircleCI 上使用 [CircleCI 2.0 语法](https://circleci.com/docs/2.0/) 来构建 snap 和在本地机器上基本相同。在本文中，我们将会讲解一个示例配置文件。如果您对 CircleCI 还不熟悉，或者想了解更多有关 2.0 的入门知识，您可以从 [这里](https://circleci.com/docs/2.0/first-steps/) 开始。
### 基础配置
```
version: 2
jobs:
build:
machine: true
working_directory: ~/project
steps:
- checkout
- run:
command: |
sudo apt update && sudo apt install -y snapd
sudo snap install snapcraft --edge --classic
/snap/bin/snapcraft
```
这个例子使用了 `machine` 执行器来安装用于管理运行 snap 的可执行程序 `snapd` 和制作 snap 的 `snapcraft` 工具。
由于构建过程需要使用比较新的内核，所以我们使用了 `machine` 执行器而没有用 `docker` 执行器。在这里，Linux v4.4 已经足够满足我们的需求了。
### 用户空间的依赖关系
上面的例子使用了 `machine` 执行器，它实际上是一个内核为 Linux v4.4 的 [Ubuntu 14.04 (Trusty) 虚拟机](https://circleci.com/docs/1.0/differences-between-trusty-and-precise/)。如果 Trusty 仓库可以满足你的 project/snap 构建依赖，那就没问题。如果你的构建依赖需要其他版本，比如 Ubuntu 16.04 (Xenial)，我们仍然可以在 `machine` 执行器中使用 Docker 来构建我们的 snap 软件包 。
```
version: 2
jobs:
build:
machine: true
working_directory: ~/project
steps:
- checkout
- run:
command: |
sudo apt update && sudo apt install -y snapd
docker run -v $(pwd):$(pwd) -t ubuntu:xenial sh -c "apt update -qq && apt install snapcraft -y && cd $(pwd) && snapcraft"
```
这个例子中，我们再次在 `machine` 执行器的虚拟机中安装了 `snapd`，但是我们决定将 snapcraft 安装在 Ubuntu Xenial 镜像构建的 Docker 容器中，并使用它来构建我们的 snap。这样，在 `snapcraft` 运行的过程中就可以使用在 Ubuntu 16.04 中可用的所有 `apt` 包。
### 测试
在我们的[博客](https://circleci.com/blog/)、[文档](https://circleci.com/docs/)以及互联网上已经有很多讲述如何对软件代码进行单元测试的内容。搜索你的语言或者框架和单元测试或者 CI 可以找到大量相关的信息。在 CircleCI 上构建 snap 软件包，我们最终会得到一个 `.snap` 的文件，这意味着除了创造它的代码外我们还可以对它进行测试。
### 工作流
假设我们构建的 snap 软件包是一个 webapp，我们可以通过测试套件来确保构建的 snap 可以正确的安装和运行，我们也可以试着安装它或者使用 [Selenium](http://www.seleniumhq.org/) 来测试页面加载、登录等功能正常工作。但是这里有一个问题，由于 snap 是被设计成可以在多个 Linux 发行版上运行，这就需要我们的测试套件可以在 Ubuntu 16.04、Fedora 25 和 Debian 9 等发行版中可以正常运行。这个问题我们可以通过 CircleCI 2.0 的工作流来有效地解决。
工作流是在最近的 CircleCI 2.0 测试版中加入的，它允许我们通过特定的逻辑流程来运行离散的任务。这样，使用单个任务构建完 snap 后，我们就可以开始并行的运行 snap 的发行版测试任务，每个任务对应一个不同的发行版的 [Docker 镜像](https://circleci.com/docs/2.0/building-docker-images/) (或者在将来，还会有其他可用的执行器)。
这里有一个简单的例子：
```
workflows:
version: 2
build-test-and-deploy:
jobs:
- build
- acceptance_test_xenial:
requires:
- build
- acceptance_test_fedora_25:
requires:
- build
- acceptance_test_arch:
requires:
- build
- publish:
requires:
- acceptance_test_xenial
- acceptance_test_fedora_25
- acceptance_test_arch
```
在这个例子中首先构建了 snap，然后在四个不同的发行版上运行验收测试。如果所有的发行版都通过测试了，那么我们就可以运行发布 `job`，以便在将其推送到 snap 商店之前完成剩余的 snap 任务。
### 留着 .snap 包
为了测试我们在工作流示例中使用的 .snap 软件包，我们需要一种在构建的时候持久保存 snap 的方法。在这里我将提供两种方法：
1. **artifact** —— 在运行 `build` 任务的时候我们可以将 snaps 保存为一个 CircleCI 的 artifact（LCTT 译注：artifact 是 `snapcraft.yaml` 中的一个 `Plugin-specific` 关键字），然后在接下来的任务中检索它。CircleCI 工作流有自己处理共享 artifact 的方式，相关信息可以在 [这里](https://circleci.com/docs/2.0/workflows/#using-workspaces-to-share-artifacts-among-jobs) 找到。
2. **snap 商店通道** —— 当发布 snap 软件包到 snap 商店时，有多种通道可供我们选择。将 snap 的主分支发布到 edge 通道以供内部或者用户测试已经成为一种常见做法。我们可以在 `build` 任务中完成这些工作，然后接下来的的任务就可以从 edge 通道来安装构建好的 snap 软件包。
第一种方法速度更快，并且它还可以在 snap 软包上传到 snap 商店供用户甚至是测试用户使用之前对 snap 进行验收测试。第二种方法的好处是我们可以从 snap 商店安装 snap，这也是 CI 运行期间的测试项之一。
### snap 商店的身份验证
[snapcraft-config-generator.py](https://gist.github.com/3v1n0/479ad142eccdd17ad7d0445762dea755) 脚本可以生成商店证书并将其保存到 `.snapcraft/snapcraft.cfg` 中（注意：在运行公共脚本之前一定要对其进行检查）。如果觉得在你仓库中使用明文来保存这个文件不安全，你可以用 `base64` 编码该文件，并将其存储为一个[私有环境变量](https://circleci.com/docs/1.0/environment-variables/#setting-environment-variables-for-all-commands-without-adding-them-to-git)，或者你也可以对文件 [进行加密](https://github.com/circleci/encrypted-files)，并将密钥存储在一个私有环境变量中。
下面是一个示例，将商店证书放在一个加密的文件中，并在 `deploy` 环节中使用它将 snap 发布到 snap 商店中。
```
- deploy:
name: Push to Snap Store
command: |
openssl aes-256-cbc -d -in .snapcraft/snapcraft.encrypted -out .snapcraft/snapcraft.cfg -k $KEY
/snap/bin/snapcraft push *.snap
```
除了 `deploy` 任务之外，工作流示例同之前的一样， `deploy` 任务只有当验收测试任务通过时才会运行。
### 更多的信息
* Alan Pope 在 [论坛中发的帖子](https://forum.snapcraft.io/t/building-and-pushing-snaps-using-circleci/789)：“popey” 是 Canonical 的员工，他在 snapcraft 的论坛上写了这篇文章，并启发作者写了这篇博文。
* [snapcraft 网站](https://snapcraft.io/)： snapcraft 官方网站。
* [snapcraft 的 CircleCI Bug 报告](https://bugs.launchpad.net/snapcraft/+bug/1693451)：在 Launchpad 上有一个开放的 bug 报告页面，用来改善 CircleCI 对 snapcraft 的支持。同时这将使这个过程变得更简单并且更“正式”。期待您的支持。
* 怎么使用 CircleCI 构建 [Nextcloud](https://nextcloud.com/) 的 snap：这里有一篇题为 [“复杂应用的持续验收测试”](https://kyrofa.com/posts/continuous-acceptance-tests-for-complex-applications) 的博文，它同时也影响了这篇博文。
这篇客座文章的作者是 Ricardo Feliciano —— CircleCi 的开发者传道士。如果您也有兴趣投稿，请联系 [ubuntu-iot@canonical.com](mailto:ubuntu-iot@canonical.com)。原始文章可以从 [这里](https://circleci.com/blog/build-test-publish-snap-packages?utm_source=insightsubuntu&utm_medium=syndicatedblogpost) 找到。
---
via: <https://insights.ubuntu.com/2017/06/28/build-test-and-publish-snap-packages-using-snapcraft/>
译者简介：
>
> 常年混迹于 snapcraft.io，对 Ubuntu Core、snaps 和 snapcraft 有浓厚的兴趣，并致力于将这些还在快速发展的新技术通过翻译或原创的方式介绍到中文世界。有兴趣的小伙伴也可以关注译者个人的公众号： `Snapcraft`
>
>
>
作者：Ricardo Feliciano 译者：[Snapcrafter](https://github.com/Snapcrafter) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Fedora 26 助力云、服务器、工作站系统
|
Jack M. Germain
|
http://www.linuxinsider.com/story/84674.html
|
Fedora Linux 是 Red Hat Enterprise Linux（RHEL）的社区版本。Fedora 26 包含一组基础包，形成针对不同用户的三个不同版本的基础。
|
/data/attachment/album/201708/18/152112rz5lszn4l3ll73ms.png.thumb.jpg
|
/data/attachment/album/201708/18/152112rz5lszn4l3ll73ms.png
| true | false | true |
geekpi
| false |
[
"Fedora"
] |
新闻
|
{
"viewnum": 5809,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "123.139.177.160",
"message": "全组件镜像才是真正的方便用户，版本应该只要一个，在单一版本中保持软件的多样性，这点应该向Debian Gnu/Linux学习",
"username": "来自陕西西安的 Chrome Mobile 59.0|Android 7.0 用户",
"date": "2017-08-19T00:06:34"
},
{
"postip": "119.145.83.241",
"message": "已经用上了，还不错。",
"username": "来自广东广州的 Firefox 55.0|Fedora 用户",
"date": "2017-08-27T22:02:01"
}
] |
[] |
Fedora Linux 是 Red Hat Enterprise Linux（RHEL）的社区版本。Fedora 26 包含一组基础包，形成针对不同用户的三个不同版本的基础。
| 2017-08-20T10:09:31 | 2017-08-20T10:09:31 | 8,790 |
/article-8790-1.html
|
[Fedora 项目](https://getfedora.org/) 7 月份宣布推出 Fedora 26, 它是全面开放源代码的 Fedora 操作系统的最新版本。
Fedora Linux 是 Red Hat Enterprise Linux（RHEL）的社区版本。Fedora 26 包含一组基础包，形成针对不同用户的三个不同版本的基础。
Fedora <ruby> 原子主机版 <rt> Atomic Host Edition </rt></ruby> 是用于运行基于容器的工作的操作系统。Fedora <ruby> 服务器版 <rt> Server </rt></ruby>将 Fedora Server OS 安装在硬盘驱动器上。Fedora <ruby> 工作站版 <rt> Workstation </rt></ruby>是一款用于笔记本电脑和台式机的用户友好操作系统，它适用于广泛的用户 - 从业余爱好者和学生到企业环境中的专业人士。
所有这三个版本都有共同的基础和一些共同的优点。所有 Fedora 版本每年发行两次。
Fedora 项目是创新和新功能的测试基地。Fedora 项目负责人 Matthew Miller 说，有些特性将在即将发布的 RHEL 版本中实现。
他告诉 LinuxInsider：“Fedora 并没有直接参与这些产品化决策。Fedora 提供了许多想法和技术，它是 Red Hat Enterprise Linux 客户参与并提供反馈的好地方。”
### 强力的软件包
Fedora 开发人员更新和改进了所有三个版本的软件包。他们在 Fedora 26 中进行了许多错误修复和性能调整，以便在 Fedora 的用例中提供更好的用户体验。
这些安装包包括以下改进：
* 更新的编译器和语言，包括 GCC 7、Go 1.8、Python 3.6 和 Ruby 2.4；
* DNF 2.0 是 Fedora 下一代包管理系统的最新版本，它与 Yum 的向后兼容性得到改善；
* Anaconda 安装程序新的存储配置界面，可从设备和分区进行自下而上的配置；
* Fedora Media Writer 更新，使用户可以为基于 ARM 的设备（如 Raspberry Pi）创建可启动 SD 卡。
[Endpoint Technologies Associates](http://www.ndpta.com/) 的总裁 Roger L. Kay 指出，云工具对于使用云的用户必不可少，尤其是程序员。
他对 LinuxInsider 表示：“Kubernetes 对于在混合云中编程感兴趣的程序员来说是至关重要的，这可能是目前业界更重要的发展之一。云，无论是公有云、私有云还是混合云 - 都是企业计算未来的关键。”
### Fedora 26 原子主机亮相
Linux 容器和容器编排引擎一直在普及。Fedora 26 原子主机提供了一个最小占用的操作系统，专门用于在裸机到云端的环境中运行基于容器的工作任务。
Fedora 26 原子主机更新大概每两周发布一次，这个时间表可以让用户及时跟上游创新。
Fedora 26 原子主机可用于 Amazon EC2 。OpenStack、Vagrant 镜像和标准安装程序 ISO 镜像可在 [Fedora 项目](https://getfedora.org/)网站上找到。
最小化的 Fedora 原子的容器镜像也在 Fedora 26 上首次亮相。
### 云托管
最新版本为 Fedora 26 原子主机提供了新功能和特性：
* 容器化的 Kubernetes 作为内置的 Kubernetes 二进制文件的替代品，使用户更容易地运行不同版本的容器编排引擎；
* 最新版本的 rpm-ostree，其中包括支持直接 RPM 安装，重新加载命令和清理命令;
* 系统容器，它提供了一种在容器中的 Fedora 原子主机上安装系统基础设施软件（如网络或 Kubernetes）的方法；
* 更新版本的 Docker、Atomic和 Cockpit，用于增强容器构建，系统支持和负载监控。
根据 Fedora 项目的 Miller 所言，容器化的 Kubernetes 对于 Fedora 原子主机来说是重要的，有两个重要原因。
他解释说：“首先，它可以让我们从基础镜像中删除它，减小大小和复杂度。第二，在容器中提供它可以轻松地在不同版本中切换，而不会破环基础，或者为尚未准备好进行改变的人造成麻烦。”
### 服务器端服务
Fedora 26 服务器版为数据中心运营提供了一个灵活的多角色平台。它还允许用户自定义此版本的 Fedora 操作系统以满足其独特需求。
Fedora 26 服务器版的新功能包括 FreeIPA 4.5，它可以改进容器中运行的安全信息管理解决方案，以及 SSSD 文件缓存，以加快用户和组查询的速度。
Fedora 26 服务器版月底将增加称为 “Boltron” 的 Fedora 模块化技术预览。作为模块化操作系统，Boltron 使不同版本的不同应用程序能够在同一个系统上运行，这实质上允许将前沿运行时与稳定的数据库配合使用。
### 打磨工作站版
对于一般用户的新工具和功能之一是更新的 GNOME 桌面功能。开发将获得增强的生产力工具。
Fedora 26 工作站版附带 GNOME 3.24 和众多更新的功能调整。夜光根据时间细微地改变屏幕颜色，以减少对睡眠模式的影响。[LibreOffice](http://www.libreoffice.org/) 5.3 是开源办公生产力套件的最新更新。
GNOME 3.24 提供了 Builder 和 Flatpak 的成熟版本，它为开发人员提供了更好的应用程序开发工具，它可以方便地访问各种系统，包括 Rust 和 Meson。
### 不只是为了开发
根据 [Azul Systems](https://www.azul.com/) 的首席执行官 Scott Sellers 的说法，更新的云工具将纳入针对企业用户的 Linux 发行版中。
他告诉 LinuxInsider：“云是新兴公司以及地球上一些最大的企业的主要开发和生产平台。”
Sellers说：“鉴于 Fedora 社区的前沿性质，我们预计在任何 Fedora 版本中都会强烈关注云技术，Fedora 26 不会不令人失望。”
他指出，Fedora 开发人员和用户社区的另一个特点就是 Fedora 团队在模块化方面所做的工作。
Sellers 说：“我们将密切关注这些实验功能。”
### 支持的升级方式
Sellers 说 Fedora 的用户超过其他 Linux 发行版的用户，很多都有兴趣升级到 Fedora 26，即使他们不是重度云端用户。
他说：“这个发行版的主要优点之一就是能提前看到先进的生产级别技术，这些最终将被整合到 RHEL 中。Fedora 26 的早期评论表明它非常稳定，修复了许多错误以及提升了性能。”
Fedora 的 Miller 指出，有兴趣从早期 Fedora 版本升级的用户可能比擦除现有系统安装 Fedora 26 更容易。Fedora 一次维护两个版本，中间还有一个月的重叠。
他说：“所以，如果你在用 Fedora 24，你应该在下个月升级。幸运的 Fedora 25 用户可以随时升级，这是 Fedora 快速滚动版本的优势之一。”
### 更快的发布
用户可以安排自己升级，而不是在发行版制作出来时进行升级。
也就是说，Fedora 23 或更早版本的用户应该尽快升级。社区不再为这些版本发布安全更新
---
作者简介：
Jack M. Germain 自 2003 年以来一直是 ECT 新闻网记者。他的主要重点领域是企业IT、Linux、和开源技术。他撰写了许多关于 Linux 发行版和其他开源软件的评论。发邮件联系 Jack
---
via: <http://www.linuxinsider.com/story/84674.html>
作者：[Jack M. Germain](jack.germain@newsroom.ectnews.comm) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：没特别的理由，别用 SIGKILL
|
Daniel Stori
|
http://turnoff.us/geek/dont-sigkill-2/
|
为线程们想想吧，不要随便用 SIGKILL！
|
/data/attachment/album/201708/18/160842xixj4rxjdnrs4jix.png.thumb.jpg
|
/data/attachment/album/201708/18/160842xixj4rxjdnrs4jix.png.large.jpg
| false | false | true |
wxy
| false |
[
"漫画",
"SIGKILL"
] |
极客漫画
|
{
"viewnum": 9630,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "系统还没那么脆弱，试想如果服务器突然断电了啦？多数情况下，在电力恢复后，无需做太多处理，还是继续正常工作的。",
"username": "来自四川成都的 Chrome 59.0|GNU/Linux 用户",
"date": "2017-08-18T17:00:02"
},
{
"postip": "61.148.244.14",
"message": "zan赞",
"username": "来自北京的 UC Browser 11.6|Android 7.1 用户",
"date": "2017-08-20T00:16:14"
}
] |
[] |
为线程们想想吧，不要随便用 SIGKILL！
| 2017-08-18T16:08:00 | 2017-08-18T16:08:00 | 8,791 |
/article-8791-1.html
|
为线程们想想吧，不要随便用 SIGKILL！
---
via: <http://turnoff.us/geek/dont-sigkill-2/>
作者：[Daniel Stori](http://turnoff.us/about/) 点评：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
混合云的那些事
|
Amit Das
|
https://opensource.com/article/17/7/what-is-hybrid-cloud
|
了解混合云的细节，包括它是什么以及如何使用它
|
/data/attachment/album/201708/19/100305e4394gzfgb4vi3v9.jpg.thumb.jpg
|
/data/attachment/album/201708/19/100305e4394gzfgb4vi3v9.jpg
| true | false | true |
LHRchina
| true |
[
"云计算",
"混合云"
] |
容器与云
|
{
"viewnum": 5047,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9075,
"displayorder": 0
}
] |
了解混合云的细节，包括它是什么以及如何使用它
| 2017-08-19T10:03:00 | 2017-08-19T10:03:00 | 8,792 |
/article-8792-1.html
|
>
> 了解混合云的细节，包括它是什么以及如何使用它
>
>
>
在过去 10 年出现的众多技术中，云计算因其快速发展而引人注目，从一个细分领域的技术而成为了全球热点。就其本身来说，云计算已经造成了许多困惑、争论和辩论，而混合了多种类型的云计算的"混合"云计算也带来了更多的不确定性。阅读下文可以了解有关混合云的一些最常见问题的答案。
### 什么是混合云
基本上，混合云是本地基础设施、私有云和公共云（例如，第三方云服务）的灵活和集成的组合。尽管公共云和私有云服务在混合云中是绑定在一起的，但实际上，它们是独立且分开的服务实体，而可以编排在一起服务。使用公共和私有云基础设施的选择基于以下几个因素，包括成本、负载灵活性和数据安全性。
高级的特性，如<ruby> 扩展 <rt> scale-up </rt></ruby>和<ruby> 延伸scale-out</ruby>，可以快速扩展云应用程序的基础设施，使混合云成为具有季节性或其他可变资源需求的服务的流行选择。(<ruby> 扩展 <rt> scale-up </rt></ruby>意味着在特定的 Linux 实例上增加计算资源，例如 CPU 内核和内存，而<ruby> 延伸scale-out</ruby>则意味着提供具有相似配置的多个实例，并将它们分布到一个集群中)。
处于混合云解决方案中心的是开源软件，如 [OpenStack](https://opensource.com/resources/openstack)，它用于部署和管理虚拟机组成的大型网络。自 2010 年 10 月发布以来，OpenStack 一直在全球蓬勃发展。它的一些集成项目和工具处理核心的云计算服务，比如计算、网络、存储和身份识别，而其他数十个项目可以与 OpenStack 捆绑在一起，创建独特的、可部署的混合云解决方案。
### 混合云的组成部分
如下图所示，混合云由私有云、公有云注成，并通过内部网络连接，由编排系统、系统管理工具和自动化工具进行管理。
*混合云模型*
#### 公共云基础设施
* <ruby> 基础设施即服务 <rt> Infrastructure as a Service </rt></ruby>（IaaS） 从一个远程数据中心提供计算资源、存储、网络、防火墙、入侵预防服务（IPS）等。可以使用图形用户界面（GUI）或命令行接口（CLI）对这些服务进行监视和管理。公共 IaaS 用户不需要购买和构建自己的基础设施，而是根据需要使用这些服务，并根据使用情况付费。
* <ruby> 平台即服务 <rt> Platform as a Service </rt></ruby>（PaaS）允许用户在其上开发、测试、管理和运行应用程序和服务器。这些包括操作系统、中间件、web 服务器、数据库等等。公共 PaaS 以模板形式为用户提供了可以轻松部署和复制的预定义服务，而不是手动实现和配置基础设施。
* <ruby> 软件即服务 <rt> Software as a Service </rt></ruby>（SaaS）通过互联网交付软件。用户可以根据订阅或许可模型或帐户级别使用这些服务，在这些服务中，他们按活跃用户计费。SaaS 软件是低成本、低维护、无痛升级的，并且降低了购买新硬件、软件或带宽以支持增长的负担。
#### 私有云基础设施
* 私有 **IaaS** 和 **PaaS** 托管在孤立的数据中心中，并与公共云集成在一起，这些云可以使用远程数据中心中可用的基础设施和服务。这使私有云所有者能够在全球范围内利用公共云基础设施来扩展应用程序，并利用其计算、存储、网络等功能。
* **SaaS** 是由公共云提供商完全监控、管理和控制的。SaaS 一般不会在公共云和私有云基础设施之间共享，并且仍然是通过公共云提供的服务。
#### 云编排和自动化工具
要规划和协调私有云和公共云实例，云编排工具是必要的。该工具应该具有智能，包括简化流程和自动化重复性任务的能力。此外，集成的自动化工具负责在设置阈值时自动扩展和延伸，以及在发生任何部分损坏或宕机时执行自修复。
#### 系统和配置管理工具
在混合云中，系统和配置工具，如 [Foreman](https://github.com/theforeman)，管理着私有云和公共云数据中心提供的虚拟机的完整生命周期。这些工具使系统管理员能够轻松地控制用户、角色、部署、升级和实例，并及时地应用补丁、bug 修复和增强功能。包括Foreman 工具中的 [Puppet](https://github.com/theforeman/puppet-foreman)，使管理员能够管理配置，并为所有供给的和注册的主机定义一个完整的结束状态。
### 混合云的特性
对于大多数组织来说，混合云是有意义的，因为这些关键特性：
* **可扩展性：** 在混合云中，集成的私有云和公共云实例共享每个可配置的实例的计算资源池。这意味着每个实例都可以在需要时按需扩展和延伸。
* **快速响应：** 当私有云资源超过其阈值时，混合云的弹性支持公共云中的实例快速爆发增长。当需求高峰对运行中的应用程序需要显著的动态提升负载和容量时，这是特别有价值的。（例如，电商在假日购物季期间）
* **可靠性：** 组织可以根据需要的成本、效率、安全性、带宽等来选择公共云服务提供商。在混合云中，组织还可以决定存储敏感数据的位置，以及是在私有云中扩展实例，还是通过公共基础设施跨地域进行扩展。另外，混合模型在多个站点上存储数据和配置的能力提供了对备份、灾难恢复和高可用性的支持。
* **管理：** 在非集成的云环境中，管理网络、存储、实例和/或数据可能是乏味的。与混合工具相比，传统的编排工具非常有限，因此限制了决策制定和对完整的端到端进程和任务的自动化。使用混合云和有效的管理应用程序，您可以跟踪每个组件的数量增长，并通过定期优化这些组件，使年度费用最小化。
* **安全性：** 在评估是否在云中放置应用程序和数据时，安全性和隐私是至关重要的。IT 部门必须验证所有的合规性需求和部署策略。公共云的安全性正在改善，并将继续成熟。而且，在混合云模型中，组织可以将高度敏感的信息存储在私有云中，并将其与存储在公共云中的不敏感数据集成在一起。
* **定价：** 云定价通常基于所需的基础设施和服务水平协议（SLA）的要求。在混合云模型中，用户可以在计算资源(CPU/内存)、带宽、存储、网络、公共 IP 地址等粒度上进行比较，价格要么是固定的，要么是可变的，可以按月、小时、甚至每秒钟计量。因此，用户总是可以在公共云提供商中购买最好的价位，并相应地部署实例。
### 混合云如今的发展
尽管对公共云服务的需求很大且不断增长，并且从本地到公共云的迁移系统，仍然是大多数大型组织关注的问题。大多数人仍然在企业数据中心和老旧系统中保留关键的应用程序和数据。他们担心在公共基础设施中面临失去控制、安全威胁、数据隐私和数据真实性。因为混合云将这些问题最小化并使收益最大化，对于大多数大型组织来说，这是最好的解决方案。
### 预测五年后的发展
我预计混合云模型将在全球范围内被广泛接受，而公司的“无云”政策将在短短几年内变得非常罕见。这是我想我们会看到的：
* 由于混合云作为一种共担的责任，企业和公共云提供商之间将加强协作，以实施安全措施来遏制网络攻击、恶意软件、数据泄漏和其他威胁。
* 实例的爆发性增长将会很快，因此客户可以自发地满足负载需求或进行自我修复。
* 此外，编排或自动化工具（如 [Ansible](https://opensource.com/life/16/8/cloud-ansible-gateway)）将通过继承用于解决关键问题的能力来发挥重要作用。
* 计量和“量入为出”的概念对客户来说是透明的，并且工具将使用户能够通过监控价格波动，安全地销毁现有实例，并提供新的实例以获得最佳的可用定价。
---
作者简介：
Amit Das 是一名 Red Hat 的工程师，他对 Linux、云计算、DevOps 等充满热情，他坚信新的创新和技术，将以一种开放的方式的让世界更加开放，可以对社会产生积极的影响，改变许多人的生活。
---
via: <https://opensource.com/article/17/7/what-is-hybrid-cloud>
作者：[Amit Das](https://opensource.com/users/amit-das) 译者：[LHRchina](https://github.com/LHRchina) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Wireshark 中过滤数据包
|
Nick Congleton
|
https://linuxconfig.org/filtering-packets-in-wireshark-on-kali-linux
|
数据包过滤可让你专注于你感兴趣的确定数据集。如你所见，Wireshark 默认会抓取所有数据包。这可能会妨碍你寻找具体的数据。 Wireshark 提供了两个功能强大的过滤工具，让你简单而无痛地获得精确的数据。
|
/data/attachment/album/201708/19/123750v3fqtsis8v9gc3fs.jpg.thumb.jpg
|
/data/attachment/album/201708/19/123750v3fqtsis8v9gc3fs.jpg
| true | false | true |
geekpi
| false |
[
"Wireshark"
] |
系统运维
|
{
"viewnum": 8895,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
数据包过滤可让你专注于你感兴趣的确定数据集。如你所见，Wireshark 默认会抓取所有数据包。这可能会妨碍你寻找具体的数据。 Wireshark 提供了两个功能强大的过滤工具，让你简单而无痛地获得精确的数据。
| 2017-08-21T09:34:00 | 2017-08-21T09:34:00 | 8,793 |
/article-8793-1.html
|
### 介绍
数据包过滤可让你专注于你感兴趣的确定数据集。如你所见，Wireshark 默认会抓取*所有*数据包。这可能会妨碍你寻找具体的数据。 Wireshark 提供了两个功能强大的过滤工具，让你简单而无痛地获得精确的数据。
Wireshark 可以通过两种方式过滤数据包。它可以通过只收集某些数据包来过滤，或者在抓取数据包后进行过滤。当然，这些可以彼此结合使用，并且它们各自的用处取决于收集的数据和信息的多少。
### 布尔表达式和比较运算符
Wireshark 有很多很棒的内置过滤器。当开始输入任何一个过滤器字段时，你将看到它们会自动补完。这些过滤器大多数对应于用户对数据包的常见分组方式，比如仅过滤 HTTP 请求就是一个很好的例子。
对于其他的，Wireshark 使用布尔表达式和/或比较运算符。如果你曾经做过任何编程，你应该熟悉布尔表达式。他们是使用 `and`、`or`、`not` 来验证声明或表达式的真假。比较运算符要简单得多，它们只是确定两件或更多件事情是否彼此相等、大于或小于。
### 过滤抓包
在深入自定义抓包过滤器之前，请先查看 Wireshark 已经内置的内容。单击顶部菜单上的 “Capture” 选项卡，然后点击 “Options”。可用接口下面是可以编写抓包过滤器的行。直接移到左边一个标有 “Capture Filter” 的按钮上。点击它，你将看到一个新的对话框，其中包含内置的抓包过滤器列表。看看里面有些什么。
在对话框的底部，有一个用于创建并保存抓包过滤器的表单。按左边的 “New” 按钮。它将创建一个填充有默认数据的新的抓包过滤器。要保存新的过滤器，只需将实际需要的名称和表达式替换原来的默认值，然后单击“Ok”。过滤器将被保存并应用。使用此工具，你可以编写并保存多个不同的过滤器，以便它们将来可以再次使用。
抓包有自己的过滤语法。对于比较，它不使用等于号，并使用 `>` 和 `<` 来用于大于或小于。对于布尔值来说，它使用 `and`、`or` 和 `not`。
例如，如果你只想监听 80 端口的流量，你可以使用这样的表达式：`port 80`。如果你只想从特定的 IP 监听端口 80，你可以使用 `port 80 and host 192.168.1.20`。如你所见，抓包过滤器有特定的关键字。这些关键字用于告诉 Wireshark 如何监控数据包以及哪一个数据是要找的。例如，`host` 用于查看来自 IP 的所有流量。`src` 用于查看源自该 IP 的流量。与之相反，`dst` 只监听目标到这个 IP 的流量。要查看一组 IP 或网络上的流量，请使用 `net`。
### 过滤结果
界面的底部菜单栏是专门用于过滤结果的菜单栏。此过滤器不会更改 Wireshark 收集的数据，它只允许你更轻松地对其进行排序。有一个文本字段用于输入新的过滤器表达式，并带有一个下拉箭头以查看以前输入的过滤器。旁边是一个标为 “Expression” 的按钮，另外还有一些用于清除和保存当前表达式的按钮。
点击 “Expression” 按钮。你将看到一个小窗口，其中包含多个选项。左边一栏有大量的条目，每个都有附加的折叠子列表。你可以用这些来过滤所有不同的协议、字段和信息。你不可能看完所有，所以最好是大概看下。你应该注意到了一些熟悉的选项，如 HTTP、SSL 和 TCP。
子列表包含可以过滤的不同部分和请求方法。你可以看到通过 GET 和 POST 请求过滤 HTTP 请求。
你还可以在中间看到运算符列表。通过从每列中选择条目，你可以使用此窗口创建过滤器，而不用记住 Wireshark 可以过滤的每个条目。对于过滤结果，比较运算符使用一组特定的符号。 `==` 用于确定是否相等。`>` 用于确定一件东西是否大于另一个东西，`<` 找出是否小一些。 `>=` 和 `<=` 分别用于大于等于和小于等于。它们可用于确定数据包是否包含正确的值或按大小过滤。使用 `==` 仅过滤 HTTP GET 请求的示例如下：`http.request.method == "GET"`。
布尔运算符基于多个条件将小的表达式串到一起。不像是抓包所使用的单词，它使用三个基本的符号来做到这一点。`&&` 代表 “与”。当使用时，`&&` 两边的两个语句都必须为真值才行，以便 Wireshark 来过滤这些包。`||` 表示 “或”。只要两个表达式任何一个为真值，它就会被过滤。如果你正在查找所有的 GET 和 POST 请求，你可以这样使用 `||`：`(http.request.method == "GET") || (http.request.method == "POST")`。`!` 是 “非” 运算符。它会寻找除了指定的东西之外的所有东西。例如，`!http` 将展示除了 HTTP 请求之外的所有东西。
### 总结思考
过滤 Wireshark 可以让你有效监控网络流量。熟悉可以使用的选项并习惯你可以创建过滤器的强大表达式需要一些时间。然而一旦你学会了，你将能够快速收集和查找你要的网络数据，而无需梳理长长的数据包或进行大量的工作。
---
via: <https://linuxconfig.org/filtering-packets-in-wireshark-on-kali-linux>
作者：[Nick Congleton](https://linuxconfig.org/filtering-packets-in-wireshark-on-kali-linux) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
了解 7z 命令开关（一）
|
Himanshu Arora
|
https://www.howtoforge.com/tutorial/understanding-7z-command-switches/
|
7z 无疑是一个功能强大的强大的归档工具（声称提供最高的压缩比）。
|
/data/attachment/album/201708/19/143244kypyp9rln99qyl9v.png.thumb.jpg
|
/data/attachment/album/201708/19/143244kypyp9rln99qyl9v.png
| true | false | true |
geekpi
| false |
[
"7z"
] |
技术
|
{
"viewnum": 8086,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
7z 无疑是一个功能强大的强大的归档工具（声称提供最高的压缩比）。
| 2017-08-19T14:32:59 | 2017-08-19T14:32:59 | 8,795 |
/article-8795-1.html
|
7z 无疑是一个功能强大的强大的归档工具（声称提供最高的压缩比）。在 HowtoForge 中，我们已经[已经讨论过](https://www.howtoforge.com/tutorial/how-to-install-and-use-7zip-file-archiver-on-ubuntu-linux/)如何安装和使用它。但讨论仅限于你可以使用该工具提供的“功能字母”来使用基本功能。
在本教程中，我们将扩展对这个工具的说明，我们会讨论一些 7z 提供的“开关”。 但在继续之前，需要说明的是，本教程中提到的所有说明和命令都已在 Ubuntu 16.04 LTS 上进行了测试。
**注意**：我们将使用以下截图中显示的文件来执行使用 7zip 的各种操作。
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/ls.png)
### 包含文件
7z 工具允许你有选择地将文件包含在归档中。可以使用 `-i` 开关来使用此功能。
语法：
```
-i[r[-|0]]{@listfile|!wildcard}
```
比如，如果你想在归档中只包含 “.txt” 文件，你可以使用下面的命令：
```
$ 7z a ‘-i!*.txt’ include.7z
```
这是输出：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/include.png)
现在，检查新创建的归档是否只包含 “.txt” 文件，你可以使用下面的命令：
```
$ 7z l include.7z
```
这是输出：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/includelist.png)
在上面的截图中，你可以看到 “testfile.txt” 已经包含到归档中了。
### 排除文件
如果你想要，你可以排除不想要的文件。可以使用 `-x` 开关做到。
语法：
```
-x[r[-|0]]]{@listfile|!wildcard}
```
比如，如果你想在要创建的归档中排除 “abc.7z” ，你可以使用下面的命令：
```
$ 7z a ‘-x!abc.7z’ exclude.7z
```
这是输出：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/exclude.png)
要检查最后的归档是否排除了 “abc.7z”, 你可以使用下面的命令：
```
$ 7z l exclude.7z
```
这是输出：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/excludelist.png)
上面的截图中，你可以看到 “abc.7z” 已经从新的归档中排除了。
**专业提示**：假设任务是排除以 “t” 开头的所有 .7z 文件，并且包含以字母 “a” 开头的所有 .7z 文件。这可以通过以下方式组合 `-i` 和 `-x` 开关来实现：
```
$ 7z a '-x!t*.7z' '-i!a*.7z' combination.7z
```
### 设置归档密码
7z 同样也支持用密码保护你的归档文件。这个功能可以使用 `-p` 开关来实现。
```
$ 7z a [archive-filename] -p[your-password] -mhe=[on/off]
```
**注意**：`-mhe` 选项用来启用或者禁用归档头加密（默认是“off”）。
例子：
```
$ 7z a password.7z -pHTF -mhe=on
```
无需多说，当你解压密码保护的归档时，工具会向你询问密码。要解压一个密码保护的文件，使用 `e` 功能字母。下面是例子：
```
$ 7z e password.7z
```
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/password.png)
### 设置输出目录
工具同样支持解压文件到你选择的目录中。这可以使用 `-o` 开关。无需多说，这个开关只在含有 `e` 或者 `x` 功能字母的时候有用。
```
$ 7z [e/x] [existing-archive-filename] -o[path-of-directory]
```
比如，假设下面命令工作在当前的工作目录中：
```
$ 7z e output.7z -ohow/to/forge
```
如 `-o` 开关的值所指的那样，它的目标是解压文件到 ./how/to/forge 中。
这是输出：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/output.png)
在上面的截图中，你可以看到归档文件的所有内容都已经解压了。但是在哪里？要检查文件是否被解压到 ./how/to/forge，我们可以使用 `ls -R` 命令。
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/ls_-R.png)
在上面的截图中，我们可以看到 .7z 中的内容都被解压到 ./how/to/forge 中。
### 创建多个卷
借助 7z 工具，你可以为归档创建多个卷（较小的子档案）。当通过网络或 USB 传输大文件时，这是非常有用的。可以使用 `-v` 开关使用此功能。这个开关需要指定子档案的大小。
我们可以以字节（b）、千字节（k）、兆字节（m）和千兆字节（g）指定子档案大小。
```
$ 7z a [archive-filename] [files-to-archive] -v[size-of-sub-archive1] -v[size-of-sub-archive2] ....
```
让我们用一个例子来理解这个。请注意，我们将使用一个新的目录来执行 `-v` 开关的操作。
这是目录内容的截图：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/volumels.png)
现在，我们运行下面的命令来为一个归档文件创建多个卷（每个大小 100b）：
```
7z a volume.7z * -v100b
```
这是截图：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/volume.png)
现在，要查看创建的子归档，使用 `ls` 命令。
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/volumels2.png)
如下截图所示，一共创建四个卷 - volume.7z.001、volume.7z.002、volume.7z.003 和 volume.7z.004
**注意**：你可以使用 .7z.001 归档文件来解压。但是，要这么做，其他所有的卷都应该在同一个目录内。
### 设置归档的压缩级别
7z 允许你设置归档的压缩级别。这个功能可以使用 `-m` 开关。7z 中有不同的压缩级别，比如：`-mx0`、`-mx1`、`-mx3`、`-mx5`、`-mx7` 和 `-mx9`。
这是这些压缩级别的简要说明：
* `mx0` = 完全不压缩 - 只是复制文件到归档中。
* `mx1` = 消耗最少时间，但是压缩最小。
* `mx3` = 比 `-mx1` 好。
* `mx5` = 这是默认级别 （常规压缩）。
* `mx7` = 最大化压缩。
* `mx9` = 极端压缩。
**注意**：关于这些压缩级别的更多信息，阅读[这里](http://askubuntu.com/questions/491223/7z-ultra-settings-for-zip-format)。
```
$ 7z a [archive-filename] [files-to-archive] -mx=[0,1,3,5,7,9]
```
例如，我们在目录中有一堆文件和文件夹，我们每次尝试使用不同的压缩级别进行压缩。作为一个例子，这是当使用压缩级别 “0” 时创建存档时使用的命令。
```
$ 7z a compression(-mx0).7z * -mx=0
```
相似地，其他命令也这样执行。
以下是输出档案（使用 “ls” 命令生成）的列表，其名称表示其创建中使用的压缩级别，输出中的第五列显示压缩级别对其大小的影响。
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/compression.png)
### 显示归档的技术信息
如果需要，7z 还可以在标准输出中显示归档的技术信息 - 类型、物理大小、头大小等。可以使用 `-slt` 开关使用此功能。 此开关仅适用于带有 `l` 功能字母的情况下。
```
$ 7z l -slt [archive-filename]
```
比如：
```
$ 7z l -slt abc.7z
```
这是输出：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/slt.png)
### 指定创建归档的类型
如果你想要创建一个非 7z 的归档文件（这是默认的创建类型），你可以使用 `-t` 开关来指定。
```
$ 7z a -t[specify-type-of-archive] [archive-filename] [file-to-archive]
```
下面的例子展示创建了一个 .zip 文件：
```
7z a -tzip howtoforge *
```
输出的文件是 “howtoforge.zip”。要交叉验证它的类型，使用 `file` 命令：
[](https://www.howtoforge.com/images/understanding_7z_command_switches_part_i/big/type.png)
因此，howtoforge.zip 的确是一个 ZIP 文件。相似地，你可以创建其他 7z 支持的归档。
### 总结
你将会认识到， 7z 的 “功能字母” 以及 “开关” 的知识可以让你充分利用这个工具。我们还没有完成开关的部分 - 其余部分将在第 2 部分中讨论。
---
via: <https://www.howtoforge.com/tutorial/understanding-7z-command-switches/>
作者：[Himanshu Arora](https://www.howtoforge.com/tutorial/understanding-7z-command-switches/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：最大之数
|
Daniel Stori
|
http://turnoff.us/geek/big-numbers/
|
人们总是在说 Java 要完了，然后 Java 年复一年的还继续活着……
|
/data/attachment/album/201708/21/135134fespkmiv2kgivls8.png.thumb.jpg
|
/data/attachment/album/201708/21/135134fespkmiv2kgivls8.png.large.jpg
| false | false | true |
wxy
| false |
[
"漫画"
] |
极客漫画
|
{
"viewnum": 8471,
"commentnum": 13,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "222.92.187.131",
"message": "interesting",
"username": "Mr_Bain [Firefox 52.0|GNU/Linux]",
"date": "2017-08-21T10:31:46"
},
{
"postip": "221.214.221.70",
"message": "今年Java真的药丸了",
"username": "来自山东烟台的 Chrome 50.0|Windows 10 用户",
"date": "2017-08-21T14:35:05"
},
{
"postip": "116.31.81.182",
"message": "为啥？愿闻其详",
"username": "echoma [Firefox 57.0|GNU/Linux]",
"date": "2017-08-21T21:07:29"
},
{
"postip": "65.49.2.101",
"message": "2019了，java还活着。。。。。",
"username": "来自美国的 Chrome 63.0|Windows 10 用户",
"date": "2019-02-03T14:29:07"
},
{
"postip": "65.49.2.101",
"message": "2019了，java还活着。。。。。",
"username": "来自美国的 Chrome 63.0|Windows 10 用户",
"date": "2019-02-03T14:29:10"
},
{
"postip": "65.49.2.101",
"message": "2019了，java还活着。。。。。",
"username": "来自美国的 Chrome 63.0|Windows 10 用户",
"date": "2019-02-03T14:29:12"
},
{
"postip": "65.49.2.101",
"message": "2019了，java还活着。。。。。",
"username": "来自美国的 Chrome 63.0|Windows 10 用户",
"date": "2019-02-03T14:29:12"
},
{
"postip": "101.249.255.66",
"message": "9102年了. java好好的呢",
"username": "来自西藏的 Chrome 77.0|Windows 10 用户",
"date": "2019-09-21T11:55:21"
},
{
"postip": "117.136.41.102",
"message": "202了，java还活着。。。。。",
"username": "来自广东广州的 Firefox 73.0|GNU/Linux 用户",
"date": "2020-02-18T13:55:46"
},
{
"postip": "36.25.24.43",
"message": "2021了，java非常顽强。。。",
"username": "来自浙江杭州的 Chrome 95.0|Windows 10 用户",
"date": "2021-11-16T14:48:12"
},
{
"postip": "36.25.24.43",
"message": "2021了，java非常顽强。。。",
"username": "来自浙江杭州的 Chrome 95.0|Windows 10 用户",
"date": "2021-11-16T14:48:14"
},
{
"postip": "27.11.213.17",
"message": "2023了，java还没死",
"username": "来自重庆的 Chrome 116.0|Windows 10 用户",
"date": "2023-08-30T20:28:55"
},
{
"postip": "27.11.213.17",
"message": "2023了，java还没死",
"username": "来自重庆的 Chrome 116.0|Windows 10 用户",
"date": "2023-08-30T20:28:57"
}
] |
[] |
人们总是在说 Java 要完了，然后 Java 年复一年的还继续活着……
| 2017-08-21T10:15:00 | 2017-08-21T10:15:00 | 8,796 |
/article-8796-1.html
|
人们总是在说 Java 要完了，然后 Java 年复一年的还继续活着……
---
via: <http://turnoff.us/geek/big-numbers/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 容器轻松应对性能工程
|
Garima
|
https://opensource.com/article/17/2/performance-container-world
|
容器在性能方面表现出色，而即将到来的 “serverless” 计算（也称为功能即服务 - Function as a Service（FaaS））的浪潮将扩大容器的优势。
|
/data/attachment/album/201708/20/184447hw12rkwjvhwscxsw.jpg.thumb.jpg
|
/data/attachment/album/201708/20/184447hw12rkwjvhwscxsw.jpg
| true | false | true |
geekpi
| false |
[
"性能",
"容器"
] |
观点
|
{
"viewnum": 4622,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "183.51.194.64",
"message": "SaaS不是软件即服务吗？",
"username": "来自广东揭阳的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-20T22:26:51"
}
] |
[] |
容器在性能方面表现出色，而即将到来的 “serverless” 计算（也称为功能即服务 - Function as a Service（FaaS））的浪潮将扩大容器的优势。
| 2017-08-20T18:42:00 | 2017-08-20T18:42:00 | 8,797 |
/article-8797-1.html
|
应用程序的性能决定了软件能多快完成预期任务。这回答有关应用程序的几个问题，例如：
* 峰值负载下的响应时间
* 与替代方案相比，它易于使用，受支持的功能和用例
* 运营成本（CPU 使用率、内存需求、数据吞吐量、带宽等）
该性能分析的价值超出了服务负载所需的计算资源或满足峰值需求所需的应用实例数量的估计。性能显然与成功企业的基本要素挂钩。它揭示了用户的总体体验，包括确定什么会拖慢客户预期的响应时间，通过设计满足带宽要求的内容交付来提高客户粘性，选择最佳设备，最终帮助企业发展业务。
### 问题
当然，这是对业务服务的性能工程价值的过度简化。为了理解在完成我刚刚所描述事情背后的挑战，让我们把它放到一个真实的稍微有点复杂的场景中。
现实世界的应用程序可能托管在云端。应用程序可以利用非常大（或概念上是无穷大）的计算资源。在硬件和软件方面的需求将通过云来满足。从事开发工作的开发人员将使用云交付功能来实现更快的编码和部署。云托管不是免费的，但成本开销与应用程序的资源需求成正比。
除了<ruby> 搜索即服务 <rt> Search as a Service </rt></ruby>（SaaS）、<ruby> 平台即服务 <rt> Platform as a Service </rt></ruby>（PaaS）、<ruby> 基础设施即服务 <rt> Infrastructure as a Service </rt></ruby>（IaaS）以及<ruby> 负载平衡即服务 <rt> Load Balancing as a Service </rt></ruby>（LBaaS）之外，当云端管理托管程序的流量时，开发人员可能还会使用这些快速增长的云服务中的一个或多个：
* <ruby> 安全即服务 <rt> Security as a Service </rt></ruby> （SECaaS），可满足软件和用户的安全需求
* <ruby> 数据即服务 <rt> Data as a Service </rt></ruby> （DaaS），为应用提供了用户需求的数据
* <ruby> 登录即服务 <rt> Logging as a Service </rt></ruby> （LaaS），DaaS 的近亲，提供了日志传递和使用的分析指标
* <ruby> 搜索即服务 <rt> Search as a Service </rt></ruby> （SaaS），用于应用程序的分析和大数据需求
* <ruby> 网络即服务 <rt> Network as a Service </rt></ruby> （NaaS），用于通过公共网络发送和接收数据
云服务也呈指数级增长，因为它们使得开发人员更容易编写复杂的应用程序。除了软件复杂性之外，所有这些分布式组件的相互作用变得越来越多。用户群变得更加多元化。该软件的需求列表变得更长。对其他服务的依赖性变大。由于这些因素，这个生态系统的缺陷会引发性能问题的多米诺效应。
例如，假设你有一个精心编写的应用程序，它遵循安全编码实践，旨在满足不同的负载要求，并经过彻底测试。另外假设你已经将基础架构和分析工作结合起来，以支持基本的性能要求。在系统的实现、设计和架构中建立性能标准需要做些什么？软件如何跟上不断变化的市场需求和新兴技术？如何测量关键参数以调整系统以获得最佳性能？如何使系统具有弹性和自我恢复能力？你如何更快地识别任何潜在的性能问题，并尽早解决？
### 进入容器
软件[容器](https://opensource.com/resources/what-are-linux-containers)以[微服务](https://opensource.com/resources/what-are-microservices)设计或面向服务的架构（SoA）的优点为基础，提高了性能，因为包含更小的、自足的代码块的系统更容易编码，对其它系统组件有更清晰、定义良好的依赖。测试更容易，包括围绕资源利用和内存过度消耗的问题比在宏架构中更容易确定。
当扩容系统以增加负载能力时，容器应用程序的复制快速而简单。安全漏洞能更好地隔离。补丁可以独立版本化并快速部署。性能监控更有针对性，测量更可靠。你还可以重写和“改版”资源密集型代码，以满足不断变化的性能要求。
容器启动快速，停止也快速。它比虚拟机（VM）有更高效资源利用和更好的进程隔离。容器没有空闲内存和 CPU 闲置。它们允许多个应用程序共享机器，而不会丢失数据或性能。容器使应用程序可移植，因此开发人员可以构建并将应用程序发送到任何支持容器技术的 Linux 服务器上，而不必担心性能损失。容器生存在其内，并遵守其集群管理器（如 Cloud Foundry 的 Diego、[Kubernetes](https://opensource.com/resources/what-is-kubernetes)、Apache Mesos 和 Docker Swarm）所规定的配额（比如包括存储、计算和对象计数配额）。
容器在性能方面表现出色，而即将到来的 “serverless” 计算（也称为<ruby> 功能即服务 <rt> Function as a Service </rt></ruby>（FaaS））的浪潮将扩大容器的优势。在 FaaS 时代，这些临时性或短期的容器将带来超越应用程序性能的优势，直接转化为在云中托管的间接成本的节省。如果容器的工作更快，那么它的寿命就会更短，而且计算量负载纯粹是按需的。
---
作者简介：
Garima 是 Red Hat 的工程经理，专注于 OpenShift 容器平台。在加入 Red Hat 之前，Garima 帮助 Akamai Technologies＆MathWorks Inc. 开创了创新。
---
via: <https://opensource.com/article/17/2/performance-container-world>
作者：[Garima](https://opensource.com/users/garimavsharma) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何解决 VLC 视频嵌入字幕中遇到的错误
|
Dedoimedo
|
http://www.dedoimedo.com/computers/vlc-subtitles-errors.html
|
在本指南中，我想介绍几个你可能会在创作自己的媒体时会遇到的典型问题，主要是使用字幕方面，然后上传到媒体共享门户网站，特别是 Youtube 中，以及如何解决这些问题。
|
/data/attachment/album/201708/21/090014fvkplsj0av1fk521.jpg.thumb.jpg
|
/data/attachment/album/201708/21/090014fvkplsj0av1fk521.jpg
| true | false | true |
geekpi
| false |
[
"VLC",
"视频",
"字幕"
] |
桌面应用
|
{
"viewnum": 7746,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在本指南中，我想介绍几个你可能会在创作自己的媒体时会遇到的典型问题，主要是使用字幕方面，然后上传到媒体共享门户网站，特别是 Youtube 中，以及如何解决这些问题。
| 2017-08-21T09:00:12 | 2017-08-21T09:00:12 | 8,798 |
/article-8798-1.html
|
这会是一个有点奇怪的教程。背景故事如下。最近，我创作了一堆 [Risitas y las paelleras](https://www.youtube.com/watch?v=cDphUib5iG4) 素材中[sweet](https://www.youtube.com/watch?v=MpDdGOKZ3dg) [parody](https://www.youtube.com/watch?v=KHG6fXEba0A) [的片段](https://www.youtube.com/watch?v=TXw5lRi97YY)，以主角 Risitas 疯狂的笑声而闻名。和往常一样，我把它们上传到了 Youtube，但是从当我决定使用字幕起，到最终在网上可以观看时，我经历了一个漫长而曲折的历程。
在本指南中，我想介绍几个你可能会在创作自己的媒体时会遇到的典型问题，主要是使用字幕方面，然后上传到媒体共享门户网站，特别是 Youtube 中，以及如何解决这些问题。跟我来。
### 背景故事
我选择的视频编辑软件是 Kdenlive，当我创建那愚蠢的 [Frankenstein](http://www.dedoimedo.com/computers/frankenstein-media.html) 片段时开始使用这个软件，从那以后它一直是我的忠实伙伴。通常，我将文件交给带有 VP8 视频编解码器和 Vorbis 音频编解码器的 WebM 容器来渲染，因为这是 Google 所喜欢的格式。事实上，我在过去七年里上传的大约 40 个不同的片段中都没有问题。
但是，在完成了我的 Risitas＆Linux 项目之后，我遇到了一个困难。视频文件和字幕文件仍然是两个独立的实体，我需要以某种方式将它们放在一起。我最初关于字幕的文章提到了 Avidemux 和 Handbrake，这两个都是有效的选项。
但是，我对它们任何一个的输出都并不满意，而且由于种种原因，有些东西有所偏移。 Avidemux 不能很好处理视频编码，而 Handbrake 在最终输出中省略了几行字幕，而且字体是丑陋的。这个可以解决，但这不是今天的话题。
因此，我决定使用 VideoLAN（VLC） 将字幕嵌入视频。有几种方法可以做到这一点。你可以使用 “Media > Convert/Save” 选项，但这不能达到我们需要的。相反，你应该使用 “Media > Stream”，它带有一个更完整的向导，它还提供了一个我们需要的可编辑的代码转换选项 - 请参阅我的[教程](http://www.dedoimedo.com/computers/vlc-subtitles.html)关于字幕的部分。
### 错误！
嵌入字幕的过程并没那么简单的。你有可能遇到几个问题。本指南应该能帮助你解决这些问题，所以你可以专注于你的工作，而不是浪费时间调试怪异的软件错误。无论如何，在使用 VLC 中的字幕时，你将会遇到一小部分可能会遇到的问题。尝试以及出错，还有书呆子的设计。
### 没有可播放的流
你可能选择了奇怪的输出设置。你要仔细检查你是否选择了正确的视频和音频编解码器。另外，请记住，一些媒体播放器可能没有所有的编解码器。此外，确保在所有要播放的系统中都测试过了。
### 字幕叠加两次
如果在第一步的流媒体向导中选择了 “Use a subtitle file”，则可能会发生这种情况。只需选择所需的文件，然后单击 “Stream”。取消选中该框。
### 字幕没有输出
这可能是两个主要原因。一、你选择了错误的封装格式。在进行编辑之前，请确保在配置文件页面上正确标记了字幕。如果格式不支持字幕，它可能无法正常工作。
二、你可能已经在最终输出中启用了字幕编解码器渲染功能。你不需要这个。你只需要将字幕叠加到视频片段上。在单击 “Stream” 按钮之前，请检查生成的流输出字符串并删除 “scodec=” 的选项。
### 缺少编解码器的解决方法
这是一个常见的 [bug](https://trac.videolan.org/vlc/ticket/6184)，取决于编码器的实现的实验性，如果你选择以下配置文件，你将很有可能会看到它：“Video - H.264 + AAC (MP4)”。该文件将被渲染，如果你选择了字幕，它们也会被叠加上，但没有任何音频。但是，我们可以用技巧来解决这个问题。
一个可能的技巧是从命令行使用 “--sout-ffmpeg-strict=-2” 选项（可能有用）启动 VLC。另一个更安全的解决方法是采用无音频视频，但是带有字幕叠加，并将不带字幕的原始项目作为音频源用 Kdenlive 渲染。听上去很复杂，下面是详细步骤：
* 将现有片段（包含音频）从视频移动到音频。删除其余的。
* 或者，使用渲染过的 WebM 文件作为你的音频源。
* 添加新的片段 - 带有字幕，并且没有音频。
* 将片段放置为新视频。
* 再次渲染为 WebM。
使用其他类型的音频编解码器将很有可能可用（例如 MP3），你将拥有一个包含视频、音频和字幕的完整项目。如果你很高兴没有遗漏，你可以现在上传到 Youtube 上。但是之后 ...
### Youtube 视频管理器和未知格式
如果你尝试上传非 WebM 片段（例如 MP4），则可能会收到未指定的错误，你的片段不符合媒体格式要求。我不知道为什么 VLC 会生成一个不符合 YouTube 规定的文件。但是，修复很容易。使用 Kdenlive 重新创建视频，将会生成带有所有正确的元字段和 Youtube 喜欢的文件。回到我原来的故事，我有 40 多个片段使用 Kdenlive 以这种方式创建。
P.S. 如果你的片段有有效的音频，则只需通过 Kdenlive 重新运行它。如果没有，重做视频/音频。根据需要将片段静音。最终，这就像叠加一样，除了你使用的视频来自于一个片段，而音频来自于另一个片段。工作完成。
### 更多阅读
我不想用链接重复自己或垃圾信息。在“软件与安全”部分，我有 VLC 上的片段，因此你可能需要咨询。前面提到的关于 VLC 和字幕的文章已经链接到大约六个相关教程，涵盖了其他主题，如流媒体、日志记录、视频旋转、远程文件访问等等。我相信你可以像专业人员一样使用搜索引擎。
### 总结
我希望你觉得本指南有帮助。它涵盖了很多，我试图使其直接而简单，并解决流媒体爱好者和字幕爱好者在使用 VLC 时可能遇到的许多陷阱。这都与容器和编解码器相关，而且媒体世界几乎没有标准的事实，当你从一种格式转换到另一种格式时，有时你可能会遇到边际情况。
如果你遇到了一些错误，这里的提示和技巧应该可以至少帮助你解决一些，包括无法播放的流、丢失或重复的字幕、缺少编解码器和 Kdenlive 解决方法、YouTube 上传错误、隐藏的 VLC 命令行选项，还有一些其他东西。是的，这些对于一段文字来说是很多的。幸运的是，这些都是好东西。保重，互联网的孩子们。如果你有任何其他要求，我将来的 VLC 文章应该会涵盖，请随意给我发邮件。
干杯。
---
via: <http://www.dedoimedo.com/computers/vlc-subtitles-errors.html>
作者：[Dedoimedo](http://www.dedoimedo.com/faq.html) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
11 个使用 GNOME 3 桌面环境的理由
|
David Both
|
https://opensource.com/article/17/5/reasons-gnome
|
GNOME 3 桌面的设计目的是简单、易于访问和可靠。GNOME 的受欢迎程度证明达成了这些目标。
|
/data/attachment/album/201708/22/114336gms3mx5u1dppx3ze.png.thumb.jpg
|
/data/attachment/album/201708/22/114336gms3mx5u1dppx3ze.png
| true | false | true |
geekpi
| false |
[
"GNOME"
] |
观点
|
{
"viewnum": 13163,
"commentnum": 27,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "111.105.62.2",
"message": "没有介绍 GNOME Shell Extensions 是这文章一大败笔<br />\r\n<br />\r\n简单说就是扩展 GNOME 的程序或小工具.<br />\r\n没用过这个的, 哪里算用过了 GNOME<br />\r\n<br />\r\nhttps://extensions.gnome.org/",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-22T12:07:41"
},
{
"postip": "221.214.221.70",
"message": "然而我已经从gnome3转到kde plasma了，",
"username": "来自山东烟台的 Chrome 50.0|Windows 10 用户",
"date": "2017-08-22T13:34:47"
},
{
"postip": "116.31.81.182",
"message": "我也已经从gnome3转到kde plasma了。",
"username": "echoma [Firefox 57.0|GNU/Linux]",
"date": "2017-08-22T18:45:20"
},
{
"postip": "121.194.155.50",
"message": "我个人还是觉得GNOME3需要一个能上推屏幕至屏幕下黄金分割线的全键触摸键盘。搞好了应该比平板的触控键盘好一点点！！！！这是我觉得目前有触控屏幕最大的困扰！！！",
"username": "来自北京中央财经大学的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-22T21:58:06"
},
{
"postip": "175.141.33.135",
"message": "如果可以忍受<br />\r\n1) 比 GNOME 更耗电脑资源<br />\r\n2) 能用的 widgets 且满意的, 寥寥无几<br />\r\n<br />\r\n用 KDE 又何妨..",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-23T13:16:41"
},
{
"postip": "218.88.47.232",
"message": "你这就偏激了。桌面小插件我是一个没用，KDE Plasma 5 是跑在虚拟机里面的，要知道我那个笔记本还同时跑了 N 个其他的系统，虽然每个系统不一定都处在高负载。一次忘记接电源，就这样笔记本还是持续运行了几个小时，大概 4 小时吧，机器还是 4 年前的。至于内存消耗，虚拟机 RAM 总共提供 2.5 GiB, 开机进入桌面时，swap 零消耗，随着使用，最多的占用是浏览器。如果是 4GiB RAM，那 swap 最多就几十 MiB，少有达到 1NN MiB。",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-08-23T21:04:15"
},
{
"postip": "110.9.125.90",
"message": "我没说用 KDE 不好呀,<br />\r\n我只是点出它的问题而已. 而且是经证实的.<br />\r\n到底谁偏激了? <br />\r\n<br />\r\n不信你可以正式安装 Ubuntu Gnome 和 Kubuntu <br />\r\n各用一段时间才再来想想我说的对否..<br />\r\n同一台机, 不要用虚拟机. 还有安装后, 注意内存的消耗. 还要尝试各不同插件.",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-23T21:09:43"
},
{
"postip": "223.87.245.40",
"message": "我更偏向使用gnome的原因是g系列软件的风格简约，我看到kde一堆选项就头大，g系列软件呈现的是一种不打扰的姿态…… <br />\r\n找两个对应的软件，你就能感受到这一点<br />\r\n当然这是个人喜好，你爱用那个用那个",
"username": "来自四川成都的 Firefox 55.0|GNU/Linux 用户",
"date": "2017-08-23T21:56:15"
},
{
"postip": "110.9.125.90",
"message": "Gnome 有个问题, 就是应该强迫安装<br />\r\n显示系统内存消耗的插件 (显示在 panel),<br />\r\n不然内存不够用了也不知道, 很多人还以为造成系统卡的原因都是 Gnome 作怪.",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-23T22:15:36"
},
{
"postip": "125.71.67.191",
"message": "你之前的回复<br />\r\n<br />\r\n"<br />\r\n如果可以忍受<br />\r\n1) 比 GNOME 更耗电脑资源<br />\r\n2) 能用的 widgets 且满意的, 寥寥无几<br />\r\n"<br />\r\n难道这两句不是主观化，情绪化的回复？ 还没有技术支撑。<br />\r\n<br />\r\n我昨天的回复里提到的 RAM 4GiB 是台式机。在笔记本上使用虚拟机是一个非常不错的解决方案，可以让用户免去驱动适配的烦恼，Linux 运行在一个比较理想的环境，也可避免电量的过多消耗。如果我愿意，可以为运行在虚拟机里的 Linux 划分 12 GiB RAM，外加足够大的虚拟硬盘。<br />\r\n<br />\r\n笔记本附带的家庭版 Windows 能够满足我日常的需求，当初换硬盘还特地用 wim+diskpart，把原硬盘的系统迁",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-08-24T19:49:47"
},
{
"postip": "125.71.67.191",
"message": "移到新硬盘上。<br />\r\n<br />\r\n最初正式使用 Linux 系统时，花了一段时间从 Ubuntu Unity 到其他知名还是不知名的 DE，经过不断尝试评估，最终在“美德”二字里选择了‘德’，‘美’确实不对我胃口。P.S. 当初确认的版本还是 Debian 7 上的 KDE 4.x",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-08-24T19:50:18"
},
{
"postip": "1.84.114.41",
"message": "linux看似很多选择，其实真正开箱即用，稳定好用的桌面几乎没有，到最后用户还得自己依个人习惯安装各种插件，时间成本真的是太高太高了。<br />\r\ngnome3 无论用多牛X的硬件，输入用户名，密码都要等几秒进入桌面，无法关闭的shield, nautilus 搜索很慢，文件超过1W+越来越明显。估计官方gnome开发人员根本不用nautilus吧。文件管理器现在凑和用的也就thunar和nemo不过多文件选择慢的问题存在了好多年，一直反应也没人解决。nemo文件管理器目前用着还好，不过它源自gnome2 当然也继承了gnome 的缺点，那就是gnome捆绑性太高了，脱离了 gnome nemo",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-24T21:49:04"
},
{
"postip": "175.141.33.135",
"message": "不管你信不信, 我已经像要求你的那样做了, 而不是只是说而已.<br />\r\n所以说, 是经验之谈所得到的结论. 不管你喜不喜欢, 这说的是事实.<br />\r\n<br />\r\n如果你无法做到我要求的, 你跟本上就不能给予这2个平台公平的评论.<br />\r\n还虚拟机.. 做不到我说的, 就乖乖去睡觉去吧. 少废话连篇.<br />\r\n<br />\r\n在我看来你只是不敢验证别人所说的, 就否定了. 我说东,你说西.<br />\r\n身为一位学者应该以 [开明] 的态度接受事物. 你有吗?<br />\r\n一直说别人偏激的人, 我觉得应先检讨自己下吧.",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-24T21:49:28"
},
{
"postip": "175.141.33.135",
"message": "目前的 linux 安装还没有人工智能, 可以知道你要什么.. <br />\r\n看来目前也只有命令行适合阁下..<br />\r\n<br />\r\n有兴趣知道你说的 shield 是什么?",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-24T22:42:53"
},
{
"postip": "125.71.67.191",
"message": "我之前评论中内存部分，已经是对你的所谓 KDE Plasma 占用内存高的回复。KDE 最初我是 05 年开始通过 knoppix 首先接触的。无论是虚拟机，还是物理机都是属于资源有限情况下（即便我的笔记本内存多，但也不能光给一个程序用），根据日常使用的体验，确认其内存包括 CPU 消耗都是自己能接受的。别看不起虚拟机，虚拟机是现在能够在一台机器同时使用 N 个操作系统的唯一方法。而且虚拟机的性能也不是你想的那么低，它甚至能勉强（不是幻灯片那种效果）在低于 4K 原生分辨率的屏幕，回放每秒 30 hz 的视频，当然音画是不同步的，不过不影响",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-08-24T22:50:19"
},
{
"postip": "125.71.67.191",
"message": "“在我看来你只是不敢验证别人所说的, 就否定了. 我说东,你说西.<br />\r\n身为一位学者应该以 [开明] 的态度接受事物. 你有吗?<br />\r\n一直说别人偏激的人, 我觉得先检讨自己下吧.” -- 还没验证？没看我之前的回复？知道那个回复里 “美德” 二字分别指代的是那两个 DE 不？<br />\r\n<br />\r\n一没有那么多时间精力，二又没有测试农场？叫人怎么做从底层框架到上层 DE 的测试？<br />\r\n作为一个普通用户，依据自己实际使用体验那评判一个产品，不是一种很合乎情理的做法？",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-08-24T22:58:08"
},
{
"postip": "125.71.67.191",
"message": "观看。若换为 60hz 的 1080p 视频则完全没问题。",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-08-24T22:59:14"
},
{
"postip": "175.141.33.135",
"message": "少废话,<br />\r\n英雄帖已发, 内容我也写得很清楚了.<br />\r\nyes / no <br />\r\n就那么简单. 不然就睡你的觉去. 别浪费大家的时间.",
"username": "yomun [Chrome 60.0|GNU/Linux]",
"date": "2017-08-24T23:01:19"
},
{
"postip": "113.46.12.225",
"message": "+1，没有Extensions的Gnome3真心没法用。。。<br />\r\n默认的Gnome，说得好听叫简洁，说得难听叫简陋，做减法做过头了。",
"username": "枫落夜舞 [Chrome 60.0|Mac 10.12]",
"date": "2017-08-26T00:49:17"
},
{
"postip": "113.46.12.225",
"message": "其实Plasma5之后内存资源消耗没有以前那么大了，Plasma5基于KF5，基本所有组件都基于Qt5的KF5重写了。<br />\r\n反倒是Gnome3得得gtk3越来越重。<br />\r\n<br />\r\n据我在Gentoo和ArchLinux上的使用情况来看，Gnome3和Plasma5在仅安装核心组件(gnome-shell/plasma-desktop)的情况下，基本开销并没有太大差异。<br />\r\n<br />\r\n只是现阶段Plasma5的很多组件刚迁移到KF5，稳定性欠佳(经常有莫名其妙地奔溃)，跟已经迭代更新了好几年的Gnome3不能比。",
"username": "枫落夜舞 [Chrome 60.0|Mac 10.12]",
"date": "2017-08-26T01:01:46"
},
{
"postip": "182.150.144.162",
"message": "很早就尝试过GNOME3，几年后仍然没什么改进，真是最糟糕的Linux桌面环境。最喜欢Unity节省了很多可用空间而且很漂亮，但是已被官方放弃吗，根据以后支持情况准备转KDE了。KDE可配置项太多了，反而很容易把界面弄乱，倒腾很久还不如默认的(lll￢ω￢)",
"username": "来自四川成都的 Chrome 60.0|Windows 10 用户",
"date": "2017-08-31T00:07:27"
},
{
"postip": "182.150.144.162",
"message": "很早就尝试过GNOME3，几年后仍然没什么改进，真是最糟糕的Linux桌面环境。最喜欢Unity节省了很多可用空间而且很漂亮，但是已被官方放弃吗，根据以后支持情况准备转KDE了。KDE可配置项太多了，反而很容易把界面弄乱，倒腾很久还不如默认的(lll￢ω￢)",
"username": "来自四川成都的 Chrome 60.0|Windows 10 用户",
"date": "2017-08-31T00:07:34"
},
{
"postip": "182.150.144.162",
"message": "很早就尝试过GNOME3，几年后仍然没什么改进，真是最糟糕的Linux桌面环境。最喜欢Unity节省了很多可用空间而且很漂亮，但是已被官方放弃吗，根据以后支持情况准备转KDE了。KDE可配置项太多了，反而很容易把界面弄乱，倒腾很久还不如默认的(lll￢ω￢)",
"username": "来自四川成都的 Chrome 60.0|Windows 10 用户",
"date": "2017-08-31T00:07:34"
},
{
"postip": "118.122.120.11",
"message": "虽然配置项过多，但也不是非得所有都要改。Windows 的组策略设置涉及到界面的也多，但是需要改的数量，也不是很多，大部分还是用默认设置。况且 KDE 有的设置还有预览，更方便查看更改后的效果。",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-31T10:45:58"
},
{
"postip": "121.35.0.139",
"message": "我觉得elementory os 是一个不错的桌面选择",
"username": "来自广东深圳的 Chrome 60.0|Windows 7 用户",
"date": "2017-09-06T14:51:47"
},
{
"postip": "58.243.254.176",
"message": "说的 好，我选择KDE",
"username": "来自安徽合肥的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-09-16T00:29:24"
},
{
"postip": "45.63.120.129",
"message": "说的好，我选择KDE",
"username": "来自美国的 Firefox 55.0|GNU/Linux 用户",
"date": "2017-09-16T00:32:58"
}
] |
[] |
GNOME 3 桌面的设计目的是简单、易于访问和可靠。GNOME 的受欢迎程度证明达成了这些目标。
| 2017-08-22T11:43:32 | 2017-08-22T11:43:32 | 8,799 |
/article-8799-1.html
|
>
> GNOME 3 桌面的设计目的是简单、易于访问和可靠。GNOME 的受欢迎程度证明达成了这些目标。
>
>
>
去年年底，在我升级到 Fedora 25 后，新版本 [KDE](https://opensource.com/life/15/4/9-reasons-to-use-kde) Plasma 出现了一些问题，这使我难以完成任何工作。所以我决定尝试其他的 Linux 桌面环境有两个原因。首先，我需要完成我的工作。第二，多年来一直使用 KDE，我想可能是尝试一些不同的桌面的时候了。
我尝试了几个星期的第一个替代桌面是我在 1 月份文章中写到的 [Cinnamon](/article-8606-1.html)，然后我写了用了大约八个星期的[LXDE](/article-8434-1.html)，我发现这里有很多事情我都喜欢。我用了 [GNOME 3](https://www.gnome.org/gnome-3/) 几个星期来写了这篇文章。
像几乎所有的网络世界一样，GNOME 是缩写；它代表 “GNU 网络对象模型”（GNU Network Object Model）。GNOME 3 桌面设计的目的是简单、易于访问和可靠。GNOME 的受欢迎程度证明达成了这些目标。
GNOME 3 在需要大量屏幕空间的环境中非常有用。这意味着两个具有高分辨率的大屏幕，并最大限度地减少桌面小部件、面板和用来启动新程序之类任务的图标所需的空间。GNOME 项目有一套人机接口指南（HIG），用来定义人类应该如何与计算机交互的 GNOME 哲学。
### 我使用 GNOME 3 的十一个原因
1、 **诸多选择：** GNOME 以多种形式出现在我个人喜爱的 Fedora 等一些发行版上。你可以选择的桌面登录选项有 GNOME Classic、Xorg 上的 GNOME、GNOME 和 GNOME（Wayland）。从表面上看，启动后这些都是一样的，但它们使用不同的 X 服务器，或者使用不同的工具包构建。Wayland 在小细节上提供了更多的功能，例如动态滚动，拖放和中键粘贴。
2、 **入门教程：** 在用户第一次登录时会显示入门教程。它向你展示了如何执行常见任务，并提供了大量的帮助链接。教程在首次启动后关闭后也可轻松访问，以便随时访问该教程。教程非常简单直观，这为 GNOME 新用户提供了一个简单明了开始。要之后返回本教程，请点击 **Activities**，然后点击会显示程序的有九个点的正方形。然后找到并点击标为救生员图标的 **Help**。
3、 **桌面整洁：** 对桌面环境采用极简方法以减少杂乱，GNOME 设计为仅提供具备可用环境所必需的最低限度。你应该只能看到顶部栏（是的，它就叫这个），其他所有的都被隐藏，直到需要才显示。目的是允许用户专注于手头的任务，并尽量减少桌面上其他东西造成的干扰。
4、 **顶部栏：** 无论你想做什么，顶部栏总是开始的地方。你可以启动应用程序、注销、关闭电源、启动或停止网络等。不管你想做什么都很简单。除了当前应用程序之外，顶栏通常是桌面上唯一的其他对象。
5、 **dash：** 如下所示，在默认情况下, dash 包含三个图标。在开始使用应用程序时，会将它们添加到 dash 中，以便在其中显示最常用的应用程序。你也可以从应用程序查看器中将应用程序图标添加到 dash 中。
6、 **应用程序浏览器：** 我真的很喜欢这个可以从位于 GNOME 桌面左侧的垂直条上访问应用程序浏览器。除非有一个正在运行的程序，GNOME 桌面通常没有任何东西，所以你必须点击顶部栏上的 **Activities** 选区，点击 dash 底部的九个点组成的正方形，它是应用程序浏览器的图标。
如上所示，浏览器本身是一个由已安装的应用程序的图标组成的矩阵。矩阵下方有一对互斥的按钮，**Frequent** 和 **All**。默认情况下，应用程序浏览器会显示所有安装的应用。点击 **Frequent** 按钮，它会只显示最常用的应用程序。向上和向下滚动以找到要启动的应用程序。应用程序按名称按字母顺序显示。
[GNOME](https://www.gnome.org/gnome-3/) 官网和内置的帮助有更多关于浏览器的细节。
7、 **应用程序就绪通知：** 当新启动的应用程序的窗口打开并准备就绪时，GNOME 会在屏幕顶部显示一个整齐的通知。只需点击通知即可切换到该窗口。与在其他桌面上搜索新打开的应用程序窗口相比，这节省了一些时间。
8、 **应用程序显示：** 为了访问不可见的其它运行的应用程序，点击 **Activities** 菜单。这将在桌面上的矩阵中显示所有正在运行的应用程序。点击所需的应用程序将其带到前台。虽然当前应用程序显示在顶栏中，但其他正在运行的应用程序不会。
9、 **最小的窗口装饰：** 桌面上打开窗口也很简单。标题栏上唯一显示的按钮是关闭窗口的 “X”。所有其他功能，如最小化、最大化、移动到另一个桌面等，可以通过在标题栏上右键单击来访问。
10、 **自动创建的新桌面：** 在使用下一空桌面的时候将自动创建的新的空桌面。这意味着总是有一个空的桌面在需要时可以使用。我使用的所有其他的桌面系统都可以让你在桌面活动时设置桌面数量，但必须使用系统设置手动完成。
11、 **兼容性：** 与我所使用的所有其他桌面一样，为其他桌面创建的应用程序可在 GNOME 上正常工作。这功能让我有可能测试这些桌面，以便我可以写出它们。
### 最后的思考
GNOME 不像我以前用过的桌面。它的主要指导是“简单”。其他一切都要以简单易用为前提。如果你从入门教程开始，学习如何使用 GNOME 需要很少的时间。这并不意味着 GNOME 有所不足。它是一款始终保持不变的功能强大且灵活的桌面。
（题图：[Gunnar Wortmann](https://pixabay.com/en/users/karpartenhund-3077375/) 通过 [Pixabay](https://pixabay.com/en/garden-gnome-black-and-white-f%C3%B6hr-1584401/)。由 Opensource.com 修改。[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）
---
作者简介：
David Both - David Both 是位于北卡罗来纳州罗利的 Linux 和开源倡导者。他已经在 IT 行业工作了四十多年，并为 IBM 教授 OS/2 超过 20 年。在 IBM，他在 1981 年为初始的 IBM PC 写了第一个培训课程。他为红帽教授 RHCE 课程，曾在 MCI Worldcom、思科和北卡罗来纳州工作。他一直在使用 Linux 和开源软件近 20 年。
---
via: <https://opensource.com/article/17/5/reasons-gnome>
作者：[David Both](https://opensource.com/users/dboth) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一文了解 Kubernetes 是什么？
|
Kubernetes.io
|
https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/
|
这是一篇 Kubernetes 的概览。
Kubernetes 是一个自动化部署、伸缩和操作应用程序容器的开源平台。
|
/data/attachment/album/201708/22/115549zy13hgl2n33gow00.png.thumb.jpg
|
/data/attachment/album/201708/22/115549zy13hgl2n33gow00.png
| true | false | true |
songshuang00
| true |
[
"Kubernetes"
] |
容器与云
|
{
"viewnum": 8193,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8858,
"displayorder": 0
}
] |
这是一篇 Kubernetes 的概览。
Kubernetes 是一个自动化部署、伸缩和操作应用程序容器的开源平台。
| 2017-08-22T13:47:00 | 2017-08-22T13:47:00 | 8,800 |
/article-8800-1.html
|
这是一篇 Kubernetes 的概览。
Kubernetes 是一个[自动化部署、伸缩和操作应用程序容器的开源平台](http://www.slideshare.net/BrianGrant11/wso2con-us-2015-kubernetes-a-platform-for-automating-deployment-scaling-and-operations)。
使用 Kubernetes，你可以快速、高效地满足用户以下的需求：
* 快速精准地部署应用程序
* 即时伸缩你的应用程序
* 无缝展现新特征
* 限制硬件用量仅为所需资源
我们的目标是培育一个工具和组件的生态系统，以减缓在公有云或私有云中运行的程序的压力。
#### Kubernetes 的优势
* **可移动**: 公有云、私有云、混合云、多态云
* **可扩展**: 模块化、插件化、可挂载、可组合
* **自修复**: 自动部署、自动重启、自动复制、自动伸缩
Google 公司于 2014 年启动了 Kubernetes 项目。Kubernetes 是在 [Google 的长达 15 年的成规模的产品级任务的经验下](https://research.google.com/pubs/pub43438.html)构建的，结合了来自社区的最佳创意和实践经验。
### 为什么选择容器?
想要知道你为什么要选择使用 [容器](https://aucouranton.com/2014/06/13/linux-containers-parallels-lxc-openvz-docker-and-more/)?
程序部署的*传统方法*是指通过操作系统包管理器在主机上安装程序。这样做的缺点是，容易混淆程序之间以及程序和主机系统之间的可执行文件、配置文件、库、生命周期。为了达到精准展现和精准回撤，你可以搭建一台不可变的虚拟机镜像。但是虚拟机体量往往过于庞大而且不可转移。
容器部署的*新的方式*是基于操作系统级别的虚拟化，而非硬件虚拟化。容器彼此是隔离的，与宿主机也是隔离的：它们有自己的文件系统，彼此之间不能看到对方的进程，分配到的计算资源都是有限制的。它们比虚拟机更容易搭建。并且由于和基础架构、宿主机文件系统是解耦的，它们可以在不同类型的云上或操作系统上转移。
正因为容器又小又快，每一个容器镜像都可以打包装载一个程序。这种一对一的“程序 - 镜像”联系带给了容器诸多便捷。有了容器，静态容器镜像可以在编译/发布时期创建，而非部署时期。因此，每个应用不必再等待和整个应用栈其它部分进行整合，也不必和产品基础架构环境之间进行妥协。在编译/发布时期生成容器镜像建立了一个持续地把开发转化为产品的环境。相似地，容器远比虚拟机更加透明，尤其在设备监控和管理上。这一点，在容器的进程生命周期被基础架构管理而非被容器内的进程监督器隐藏掉时，尤为显著。最终，随着每个容器内都装载了单一的程序，管理容器就等于管理或部署整个应用。
容器优势总结：
* **敏捷的应用创建与部署**：相比虚拟机镜像，容器镜像的创建更简便、更高效。
* **持续的开发、集成，以及部署**：在快速回滚下提供可靠、高频的容器镜像编译和部署（基于镜像的不可变性）。
* **开发与运营的关注点分离**：由于容器镜像是在编译/发布期创建的，因此整个过程与基础架构解耦。
* **跨开发、测试、产品阶段的环境稳定性**：在笔记本电脑上的运行结果和在云上完全一致。
* **在云平台与 OS 上分发的可转移性**：可以在 Ubuntu、RHEL、CoreOS、预置系统、Google 容器引擎，乃至其它各类平台上运行。
* **以应用为核心的管理**: 从在虚拟硬件上运行系统，到在利用逻辑资源的系统上运行程序，从而提升了系统的抽象层级。
* **松散耦联、分布式、弹性、无拘束的[微服务](https://martinfowler.com/articles/microservices.html)**：整个应用被分散为更小、更独立的模块，并且这些模块可以被动态地部署和管理，而不再是存储在大型的单用途机器上的臃肿的单一应用栈。
* **资源隔离**：增加程序表现的可预见性。
* **资源利用率**：高效且密集。
#### 为什么我需要 Kubernetes，它能做什么?
至少，Kubernetes 能在实体机或虚拟机集群上调度和运行程序容器。而且，Kubernetes 也能让开发者斩断联系着实体机或虚拟机的“锁链”，从**以主机为中心**的架构跃至**以容器为中心**的架构。该架构最终提供给开发者诸多内在的优势和便利。Kubernetes 提供给基础架构以真正的**以容器为中心**的开发环境。
Kubernetes 满足了一系列产品内运行程序的普通需求，诸如：
* [协调辅助进程](https://kubernetes.io/docs/concepts/workloads/pods/pod/)，协助应用程序整合，维护一对一“程序 - 镜像”模型。
* [挂载存储系统](https://kubernetes.io/docs/concepts/storage/volumes/)
* [分布式机密信息](https://kubernetes.io/docs/concepts/configuration/secret/)
* [检查程序状态](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/)
* [复制应用实例](https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/)
* [使用横向荚式自动缩放](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/)
* [命名与发现](https://kubernetes.io/docs/concepts/services-networking/connect-applications-service/)
* [负载均衡](https://kubernetes.io/docs/concepts/services-networking/service/)
* [滚动更新](https://kubernetes.io/docs/tasks/run-application/rolling-update-replication-controller/)
* [资源监控](https://kubernetes.io/docs/tasks/debug-application-cluster/resource-usage-monitoring/)
* [访问并读取日志](https://kubernetes.io/docs/concepts/cluster-administration/logging/)
* [程序调试](https://kubernetes.io/docs/tasks/debug-application-cluster/debug-application-introspection/)
* [提供验证与授权](https://kubernetes.io/docs/admin/authorization/)
以上兼具平台即服务（PaaS）的简化和基础架构即服务（IaaS）的灵活，并促进了在平台服务提供商之间的迁移。
#### Kubernetes 是一个什么样的平台?
虽然 Kubernetes 提供了非常多的功能，总会有更多受益于新特性的新场景出现。针对特定应用的工作流程，能被流水线化以加速开发速度。特别的编排起初是可接受的，这往往需要拥有健壮的大规模自动化机制。这也是为什么 Kubernetes 也被设计为一个构建组件和工具的生态系统的平台，使其更容易地部署、缩放、管理应用程序。
<ruby> <a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/"> 标签 </a> <rp> （ </rp> <rt> label </rt> <rp> ） </rp></ruby>可以让用户按照自己的喜好组织资源。 <ruby> <a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/"> 注释 </a> <rp> （ </rp> <rt> annotation </rt> <rp> ） </rp></ruby>让用户在资源里添加客户信息，以优化工作流程，为管理工具提供一个标示调试状态的简单方法。
此外，[Kubernetes 控制面板](https://kubernetes.io/docs/concepts/overview/components/)是由开发者和用户均可使用的同样的 [API](https://kubernetes.io/docs/reference/api-overview/) 构建的。用户可以编写自己的控制器，比如 <ruby> <a href="https://git.k8s.io/community/contributors/devel/scheduler.md"> 调度器 </a> <rp> （ </rp> <rt> scheduler </rt> <rp> ） </rp></ruby>，使用可以被通用的[命令行工具](https://kubernetes.io/docs/user-guide/kubectl-overview/)识别的[他们自己的 API](https://git.k8s.io/community/contributors/design-proposals/extending-api.md)。
这种[设计](https://github.com/kubernetes/community/blob/master/contributors/design-proposals/principles.md)让大量的其它系统也能构建于 Kubernetes 之上。
#### Kubernetes 不是什么？
Kubernetes 不是传统的、全包容的平台即服务（Paas）系统。它尊重用户的选择，这很重要。
Kubernetes：
* 并不限制支持的程序类型。它并不检测程序的框架 (例如，[Wildfly](http://wildfly.org/))，也不限制运行时支持的语言集合 (比如， Java、Python、Ruby)，也不仅仅迎合 [12 因子应用程序](https://12factor.net/)，也不区分 *应用* 与 *服务* 。Kubernetes 旨在支持尽可能多种类的工作负载，包括无状态的、有状态的和处理数据的工作负载。如果某程序在容器内运行良好，它在 Kubernetes 上只可能运行地更好。
* 不提供中间件（例如消息总线）、数据处理框架（例如 Spark）、数据库（例如 mysql），也不把集群存储系统（例如 Ceph）作为内置服务。但是以上程序都可以在 Kubernetes 上运行。
* 没有“点击即部署”这类的服务市场存在。
* 不部署源代码，也不编译程序。持续集成 (CI) 工作流程是不同的用户和项目拥有其各自不同的需求和表现的地方。所以，Kubernetes 支持分层 CI 工作流程，却并不监听每层的工作状态。
* 允许用户自行选择日志、监控、预警系统。（ Kubernetes 提供一些集成工具以保证这一概念得到执行）
* 不提供也不管理一套完整的应用程序配置语言/系统（例如 [jsonnet](https://github.com/google/jsonnet)）。
* 不提供也不配合任何完整的机器配置、维护、管理、自我修复系统。
另一方面，大量的 PaaS 系统运行*在* Kubernetes 上，诸如 [Openshift](https://www.openshift.org/)、[Deis](http://deis.io/)，以及 [Eldarion](http://eldarion.cloud/)。你也可以开发你的自定义 PaaS，整合上你自选的 CI 系统，或者只在 Kubernetes 上部署容器镜像。
因为 Kubernetes 运营在应用程序层面而不是在硬件层面，它提供了一些 PaaS 所通常提供的常见的适用功能，比如部署、伸缩、负载平衡、日志和监控。然而，Kubernetes 并非铁板一块，这些默认的解决方案是可供选择，可自行增加或删除的。
而且， Kubernetes 不只是一个*编排系统* 。事实上，它满足了编排的需求。 *编排* 的技术定义是，一个定义好的工作流程的执行：先做 A，再做 B，最后做 C。相反地， Kubernetes 囊括了一系列独立、可组合的控制流程，它们持续驱动当前状态向需求的状态发展。从 A 到 C 的具体过程并不唯一。集中化控制也并不是必须的；这种方式更像是*编舞*。这将使系统更易用、更高效、更健壮、复用性、扩展性更强。
#### Kubernetes 这个单词的含义？k8s？
**Kubernetes** 这个单词来自于希腊语，含义是 *舵手* 或 *领航员* 。其词根是 *governor* 和 [cybernetic](http://www.etymonline.com/index.php?term=cybernetics)。 *K8s* 是它的缩写，用 8 字替代了“ubernete”。
---
via: <https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/>
作者：[kubernetes.io](https://kubernetes.io/) 译者：[songshuang00](https://github.com/songsuhang00) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
免费学习 Docker 的最佳方法：Play-with-docker（PWD）
|
Victor
|
https://blog.docker.com/2017/07/best-way-learn-docker-free-play-docker-pwd/
|
PWD 像是一个 Docker 游乐场，用户在几秒钟内就可以运行 Docker 命令。 还可以在浏览器中安装免费的 Alpine Linux 虚拟机，然后在虚拟机里面构建和运行 Docker 容器，甚至可以使用 Docker 集群模式创建集群。
|
/data/attachment/album/201708/22/141737c0buuo823dfyzxoz.jpg.thumb.jpg
|
/data/attachment/album/201708/22/141737c0buuo823dfyzxoz.jpg
| true | false | true |
Flowsnow
| false |
[
"Docker"
] |
容器与云
|
{
"viewnum": 11844,
"commentnum": 0,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
PWD 像是一个 Docker 游乐场，用户在几秒钟内就可以运行 Docker 命令。 还可以在浏览器中安装免费的 Alpine Linux 虚拟机，然后在虚拟机里面构建和运行 Docker 容器，甚至可以使用 Docker 集群模式创建集群。
| 2017-08-22T14:18:00 | 2017-08-22T14:18:00 | 8,801 |
/article-8801-1.html
|
去年在柏林的分布式系统峰会上，Docker 的负责人 [Marcos Nils](https://www.twitter.com/marcosnils) 和 [Jonathan Leibiusky](https://www.twitter.com/xetorthio) 宣称已经开始研究浏览器内置 Docker 的方案，帮助人们学习 Docker。 几天后，[Play-with-docker](http://play-with-docker.com/)（PWD）就诞生了。
PWD 像是一个 Docker 游乐场，用户在几秒钟内就可以运行 Docker 命令。 还可以在浏览器中安装免费的 Alpine Linux 虚拟机，然后在虚拟机里面构建和运行 Docker 容器，甚至可以使用 [Docker 集群模式](https://docs.docker.com/engine/swarm/)创建集群。 有了 Docker-in-Docker（DinD）引擎，甚至可以体验到多个虚拟机/个人电脑的效果。 除了 Docker 游乐场外，PWD 还包括一个培训站点 [training.play-with-docker.com](http://training.play-with-docker.com/)，该站点提供大量的难度各异的 Docker 实验和测验。
如果你错过了峰会，Marcos 和 Jonathan 在最后一场 DockerCon Moby Cool Hack 会议中展示了 PWD。 观看下面的视频，深入了解其基础结构和发展路线图。
在过去几个月里，Docker 团队与 Marcos、Jonathan，还有 Docker 社区的其他活跃成员展开了密切合作，为项目添加了新功能，为培训部分增加了 Docker 实验室。
### PWD: 游乐场
以下快速的概括了游乐场的新功能：
#### 1、 PWD Docker Machine 驱动和 SSH
随着 PWD 成功的成长，社区开始问他们是否可以使用 PWD 来运行自己的 Docker 研讨会和培训。 因此，对项目进行的第一次改进之一就是创建 [PWD Docker Machine 驱动](https://github.com/play-with-docker/docker-machine-driver-pwd/releases/tag/v0.0.5)，从而用户可以通过自己喜爱的终端轻松创建管理 PWD 主机，包括使用 SSH 相关命令的选项。 下面是它的工作原理：
#### 2、 支持文件上传
Marcos 和 Jonathan 还带来了另一个炫酷的功能就是可以在 PWD 实例中通过拖放文件的方式将 Dockerfile 直接上传到 PWD 窗口。
#### 3、 模板会话
除了文件上传之外，PWD 还有一个功能，可以使用预定义的模板在几秒钟内启动 5 个节点的群集。
#### 4、 一键使用 Docker 展示你的应用程序
PWD 附带的另一个很酷的功能是它的内嵌按钮，你可以在你的站点中使用它来设置 PWD 环境，并快速部署一个构建好的堆栈，另外还有一个 [chrome 扩展](https://chrome.google.com/webstore/detail/play-with-docker/kibbhpioncdhmamhflnnmfonadknnoan) ，可以将 “Try in PWD” 按钮添加 DockerHub 最流行的镜像中。 以下是扩展程序的一个简短演示：
### PWD 培训站点
[training.play-with-docker.com](http://training.play-with-docker.com/) 站点提供了大量新的实验。有一些值得注意的两点，包括两个来源于奥斯丁召开的 DockerCon 中的动手实践的实验，还有两个是 Docker 17.06CE 版本中亮眼的新功能：
* [可以动手实践的 Docker 网络实验](http://training.play-with-docker.com/docker-networking-hol/)
* [可以动手实践的 Docker 编排实验](http://training.play-with-docker.com/orchestration-hol/)
* [多阶段构建](http://training.play-with-docker.com/multi-stage/)
* [Docker 集群配置文件](http://training.play-with-docker.com/swarm-config/)
总而言之，现在有 36 个实验，而且一直在增加。 如果你想贡献实验，请从查看 [GitHub 仓库](https://github.com/play-with-docker/play-with-docker.github.io)开始。
### PWD 用例
根据网站访问量和我们收到的反馈，很可观的说，PWD 现在有很大的吸引力。下面是一些最常见的用例：
* 紧跟最新开发版本，尝试新功能。
* 快速建立集群并启动复制服务。
* 通过互动教程学习： [training.play-with-docker.com](http://training.play-with-docker.com/)。
* 在会议和集会上做演讲。
* 召开需要复杂配置的高级研讨会，例如 Jérôme’的 [Docker 编排高级研讨会](https://github.com/docker/labs/tree/master/Docker-Orchestration)。
* 和社区成员协作诊断问题检测问题。
参与 PWD：
* 通过[向 PWD 提交 PR](https://github.com/play-with-docker/) 做贡献
* 向 [PWD 培训站点](https://github.com/play-with-docker/training)贡献
---
作者简介：
Victor 是 Docker, Inc. 的高级社区营销经理。他喜欢优质的葡萄酒、象棋和足球，上述爱好不分先后顺序。 Victor 的 tweet：@vcoisne。
---
via: <https://blog.docker.com/2017/07/best-way-learn-docker-free-play-docker-pwd/>
作者：[Victor](https://blog.docker.com/author/victor_c/) 译者：[Flowsnow](https://github.com/Flowsnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
物联网助长了 Linux 恶意软件
|
John P. Mello Jr
|
http://www.linuxinsider.com/story/84652.html
|
针对 Linux 系统的恶意软件正在增长，这主要是由于连接到物联网设备的激增。“制造商对他们如何配置这些设备不屑一顾，所以他们使这些设备的利用变得非常轻易。”
|
/data/attachment/album/201708/22/233549sdvoy3kzgq9vfkkk.jpg.thumb.jpg
|
/data/attachment/album/201708/22/233549sdvoy3kzgq9vfkkk.jpg
| true | false | true |
geekpi
| false |
[
"物联网",
"恶意软件"
] |
新闻
|
{
"viewnum": 5386,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "121.194.155.50",
"message": "这些玩意都不是GPL滴！！！。所以不要和Linux混为一谈！！！GPL本身可以高效的检出恶意代码。。。还是那句名言说的好，只要有更多的人关注代码，代码的安全就会更高！！！",
"username": "来自北京中央财经大学的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-23T21:21:28"
},
{
"postip": "118.122.120.11",
"message": "“只要有更多的人关注代码，代码的安全就会更高！！！”事实证明，这只是一种非常理想化的想象，现实中没有太多的人自愿来进行代码审核。",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-24T09:59:25"
},
{
"postip": "1.119.6.206",
"message": "“只要有更多的人关注代码，代码的安全就会更高”",
"username": "来自香港的 Firefox 55.0|Windows 10 用户",
"date": "2017-08-30T16:24:02"
}
] |
[] |
针对 Linux 系统的恶意软件正在增长，这主要是由于连接到物联网设备的激增。“制造商对他们如何配置这些设备不屑一顾，所以他们使这些设备的利用变得非常轻易。”
| 2017-08-23T08:31:00 | 2017-08-23T08:31:00 | 8,802 |
/article-8802-1.html
|
针对 Linux 系统的恶意软件正在增长，这主要是由于连接到物联网设备的激增。
这是网络安全设备制造商 [WatchGuard Technologies](http://www.watchguard.com/) 上周发布的的一篇报告中所披露的。该报告分析了全球 26,000 多件设备收集到的数据，今年第一季度的前 10 名恶意软件中发现了三个针对 Linux 的恶意软件，而上一季度仅有一个。
WatchGuard 的 CTO Corey Nachreiner 和安全威胁分析师 Marc Laliberte 写道：“Linux 上的攻击和恶意软件正在兴起。我们相信这是因为 IoT 设备的系统性弱点与其快速增长相结合的结果，它正在引导僵尸网络的作者们转向 Linux 平台。”
他们建议“阻止入站的 Telnet 和 SSH，以及使用复杂的管理密码，可以防止绝大多数潜在的攻击”。
### 黑客的新大道
Laliberte 观察到，Linux 恶意软件在去年年底随着 Mirai 僵尸网络开始增长。Mirai 在九月份曾经用来攻击部分互联网的基础设施，迫使数百万用户断线。
他告诉 LinuxInsider，“现在，随着物联网设备的飞速发展，一条全新的大道正在向攻击者们开放。我们相信，随着互联网上新目标的出现，Linux 恶意软件会逐渐增多。”Laliberte 继续说，物联网设备制造商并没有对安全性表现出很大的关注。他们的目标是使他们的设备能够使用、便宜，能够快速制造。
他说：“开发过程中他们真的不关心安全。”
### 轻易捕获
[Alert Logic](http://www.alertlogic.com/) 的网络安全布道师 Paul Fletcher 说，大多数物联网制造商都使用 Linux 的裁剪版本，因为操作系统需要最少的系统资源来运行。
他告诉 LinuxInsider，“当你将大量与互联网连接的物联网设备结合在一起时，这相当于在线大量的 Linux 系统，它们可用于攻击。”
为了使设备易于使用，制造商使用的协议对黑客来说也是用户友好的。Fletcher 说：“攻击者可以访问这些易受攻击的接口，然后上传并执行他们选择的恶意代码。”
他指出，厂商经常给他们的设备很差的默认设置。Fletcher 说：“通常，管理员帐户是空密码或易于猜测的默认密码，例如 ‘password123’。”
[SANS 研究所](http://www.sans.org/) 首席研究员 Johannes B. Ullrich 表示，安全问题通常“本身不是 Linux 特有的”。他告诉 LinuxInsider，“制造商对他们如何配置这些设备不屑一顾，所以他们使这些设备的利用变得非常轻易。”
### 10 大恶意软件
这些 Linux 恶意软件在 WatchGuard 的第一季度的统计数据中占据了前 10 名的位置：
* Linux/Exploit，它使用几种木马来扫描可以加入僵尸网络的设备。
* Linux/Downloader，它使用恶意的 Linux shell 脚本。Linux 可以运行在许多不同的架构上，如 ARM、MIPS 和传统的 x86 芯片组。报告解释说，一个为某个架构编译的可执行文件不能在不同架构的设备上运行。因此，一些 Linux 攻击利用 dropper shell 脚本下载并安装适合它们所要感染的体系架构的恶意组件。
* Linux/Flooder，它使用了 Linux 分布式拒绝服务工具，如 Tsunami，用于执行 DDoS 放大攻击，以及 Linux 僵尸网络（如 Mirai）使用的 DDoS 工具。报告指出：“正如 Mirai 僵尸网络向我们展示的，基于 Linux 的物联网设备是僵尸网络军队的主要目标。
### Web 服务器战场
WatchGuard 报告指出，敌人攻击网络的方式发生了变化。
公司发现，到 2016 年底，73％ 的 Web 攻击针对客户端 - 浏览器和配套软件。今年头三个月发生了彻底改变，82％ 的 Web 攻击集中在 Web 服务器或基于 Web 的服务上。报告合著者 Nachreiner 和 Laliberte 写道：“我们不认为下载式的攻击将会消失，但似乎攻击者已经集中力量和工具来试图利用 Web 服务器攻击。”
他们也发现，自 2006 年底以来，杀毒软件的有效性有所下降。Nachreiner 和 Laliberte 报道说：“连续的第二个季度，我们看到使用传统的杀毒软件解决方案漏掉了使用我们更先进的解决方案可以捕获的大量恶意软件，实际上已经从 30％ 上升到了 38％ 漏掉了。”
他说：“如今网络犯罪分子使用许多精妙的技巧来重新包装恶意软件，从而避免了基于签名的检测。这就是为什么使用基本的杀毒软件的许多网络成为诸如赎金软件之类威胁的受害者。”
---
作者简介:
John P. Mello Jr.自 2003 年以来一直是 ECT 新闻网记者。他的重点领域包括网络安全、IT问题、隐私权、电子商务、社交媒体、人工智能、大数据和消费电子。 他撰写和编辑了众多出版物，包括“波士顿商业杂志”、“波士顿凤凰”、“Megapixel.Net” 和 “政府安全新闻”。
---
via: <http://www.linuxinsider.com/story/84652.html>
作者：[John P. Mello Jr](john.mello@newsroom.ectnews.com) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一个时代的结束：Solaris 系统的那些年，那些事
|
Michael Larabel
|
https://www.phoronix.com/scan.php?page=news_item&px=Solaris-2017-Look-Back
|
现在看来，Oracle 公司正在通过取消 Solaris 12 而终止 Solaris 的功能开发，这里我们要回顾下多年来在 Phoronix 上最受欢迎的 Solaris 重大事件和新闻。
|
/data/attachment/album/201708/23/133658b8kossou8xs63s4u.jpg.thumb.jpg
|
/data/attachment/album/201708/23/133658b8kossou8xs63s4u.jpg
| true | false | true |
MonkeyDEcho
| false |
[
"Oracle",
"Solaris"
] |
观点
|
{
"viewnum": 38551,
"commentnum": 3,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "116.31.81.182",
"message": "oracle干死太多项目了。。",
"username": "echoma [Firefox 57.0|GNU/Linux]",
"date": "2017-08-23T16:19:52"
},
{
"postip": "115.224.22.185",
"message": "我没有生在那个最好的时代，感到有点可惜呢",
"username": "来自浙江绍兴的 Chrome 85.0|Windows 10 用户",
"date": "2020-09-09T22:38:11"
},
{
"postip": "222.95.44.100",
"message": "我2009年，接触过120万用户量的DHCP服务“设计及部署，实施，运维”项目，给上海电信做IPTV机顶盒分配DHCP地址。<br />\r\n<br />\r\n那时候20多台DHCP服务器，底层系统就是5.10 的Solaris。<br />\r\n<br />\r\n整套系统，包括数据库，网络，服务器我一个人维护了3年，直到跳槽离职，中途还接了很多私活，移动一些dhcp服务器和广电的，我用的都是open Solaris架设的<br />\r\n<br />\r\n对这个系统，还是挺有感情的。",
"username": "来自江苏南京的 Chrome 109.0|Windows 10 用户",
"date": "2023-01-28T18:13:39"
}
] |
[] |
现在看来，Oracle 公司正在通过取消 Solaris 12 而终止 Solaris 的功能开发，这里我们要回顾下多年来在 Phoronix 上最受欢迎的 Solaris 重大事件和新闻。
| 2017-08-23T13:37:00 | 2017-08-23T13:37:00 | 8,803 |
/article-8803-1.html
|
现在看来，Oracle 公司正在通过取消 Solaris 12 而[终止 Solaris 的功能开发](http://www.phoronix.com/scan.php?page=news_item&px=No-Solaris-12)，这里我们要回顾下多年来在 Phoronix 上最受欢迎的 Solaris 重大事件和新闻。
这里有许多关于 Solaris 的有趣／重要的回忆。
在 Sun Microsystems 时期，我真的对 Solaris 很感兴趣。在 Phoronix 上我们一直重点关注 Linux 的同时，经常也有 Solaris 的文章出现。 Solaris 玩起来很有趣，OpenSolaris／SXCE 是伟大的产物，我将 Phoronix 测试套件移植到 Solaris 上，我们与 Sun Microsystems 人员有密切的联系，也出现在 Sun 的许多活动中。
*在那些日子里 Sun 有一些相当独特的活动...*
不幸的是，自从 Oracle 公司收购了 Sun 公司， Solaris 就如坠入深渊一样。最大的打击大概是 Oracle 结束了 OpenSolaris ，并将所有 Solaris 的工作转移到专有模式...
在 Sun 时代的 Solaris 有很多美好的回忆，所以 Oracle 在其计划中抹去了 Solaris 12 之后，我经常在 Phoronix 上翻回去看一些之前 Solaris 的经典文章，期待着能从 Oracle 听到 “Solaris 11” 下一代的消息，重启 Solaris 项目的开发。
虽然在后 Solaris 的世界中，看到 Oracle 对 ZFS 所做的事情以及他们在基于 RHEL 的 Oracle Enterprise Linux 上下的重注将会很有趣，但时间将会告诉我们一切。
无论如何，这是回顾自 2004 年以来我们最受欢迎的 Solaris 文章：
### 2016/12/1 [Oracle 或许会罐藏 Solaris](http://www.phoronix.com/scan.php?page=news_item&px=Oracle-Solaris-Demise-Rumors)
Oracle 可能正在拔掉 Solaris 的电源插头，据一些新的传闻说。
### 2013/6/9 [OpenSXCE 2013.05 拯救 Solaris 社区](http://www.phoronix.com/scan.php?page=news_item&px=MTM4Njc)
作为 Solaris 社区版的社区复兴，OpenSXCE 2013.05 出现在网上。
### 2013/2/2 [Solaris 12 可能最终带来 Radeon KMS 驱动程序](http://www.phoronix.com/scan.php?page=news_item&px=MTI5MTU)
看起来，Oracle 可能正在准备发布自己的 AMD Radeon 内核模式设置（KMS）驱动程序，并引入到 Oracle Solaris 12 中。
### 2012/10/4 [Oracle Solaris 11.1 提供 300 个以上增强功能](http://www.phoronix.com/scan.php?page=news_item&px=MTE5OTQ)
Oracle昨天在旧金山的 Oracle OpenWorld 会议上发布了 Solaris 11.1 。
### 2012/1/9 [Oracle 尚未澄清 Solaris 11 内核来源](http://www.phoronix.com/scan.php?page=news_item&px=MTAzOTc)
一个月前，Phoronix 是第一个注意到 Solaris 11 内核源代码通过 Torrent 站点泄漏到网上的信息。一个月后，甲骨文还没有正式评论这个情况。
### 2011/12/19 [Oracle Solaris 11 内核源代码泄漏](http://www.phoronix.com/scan.php?page=news_item&px=MTAzMDE)
似乎 Solaris 11的内核源代码在过去的一个周末被泄露到了网上。
### 2011/8/25 [对于 BSD，Solaris 的 GPU 驱动程序的悲惨状态](http://www.phoronix.com/scan.php?page=news_item&px=OTgzNA)
昨天在邮件列表上出现了关于干掉所有旧式 Mesa 驱动程序的讨论。这些旧驱动程序没有被积极维护，支持复古的图形处理器，并且没有更新支持新的 Mesa 功能。英特尔和其他开发人员正在努力清理 Mesa 核心，以将来增强这一开源图形库。这种清理 Mesa，对 BSD 和 Solaris 用户也有一些影响。
### 2010/8/13 [告别 OpenSolaris，Oracle 刚刚把它干掉](http://www.phoronix.com/scan.php?page=news_item&px=ODUwNQ)
Oracle 终于宣布了他们对 Solaris 操作系统和 OpenSolaris 平台的计划，而且不是好消息。OpenSolaris 将实际死亡，未来将不会有更多的 Solaris 版本出现 - 包括长期延期的 2010 年版本。Solaris 仍然会继续存在，现在 Oracle 正在忙于明年发布的 Solaris 11，但仅在 Oracle 的企业版之后才会发布 “Solaris 11 Express” 作为 OpenSolaris 的类似产品。
### 2010/2/22 [Oracle 仍然要对 OpenSolaris 进行更改](http://www.phoronix.com/scan.php?page=news_item&px=ODAwNg)
自从 Oracle 完成对 Sun Microsystems 的收购以来，已经有了许多变化，这个 Sun 最初支持的开源项目现在已经不再被 Oracle 支持，并且对其余的开源产品进行了重大改变。 Oracle 表现出并不太开放的意图的开源项目之一是 OpenSolaris 。 Solaris Express 社区版（SXCE）上个月已经关闭，并且也没有预计 3 月份发布的下一个 OpenSolaris 版本（OpenSolaris 2010.03）的信息流出。
### 2007/9/10 [Solaris Express 社区版 Build 72](http://www.phoronix.com/scan.php?page=news_item&px=NjA0Nw)
对于那些想要在 “印第安纳项目” 发布之前尝试 OpenSolaris 软件中最新最好的软件的人来说，现在可以使用 Solaris Express 社区版 Build 72。Solaris Express 社区版（SXCE）Build 72 可以从 OpenSolaris.org 下载。同时，预计将在下个月推出 Sun 的 “印第安纳项目” 项目的预览版。
### 2007/9/6 [ATI R500/600 驱动要支持 Solaris 了?](http://www.phoronix.com/scan.php?page=news_item&px=NjA0Mg)
虽然没有可用于 Solaris/OpenSolaris 或 \* BSD 的 ATI fglrx 驱动程序，现在 AMD 将向 X.Org 开发人员和开源驱动程序交付规范，但对于任何使用 ATI 的 Radeon X1000 “R500” 或者 HD 2000“R600” 系列的 Solaris 用户来说，这肯定是有希望的。将于下周发布的开源 X.Org 驱动程序距离成熟尚远，但应该能够相对容易地移植到使用 X.Org 的 Solaris 和其他操作系统上。 AMD 今天宣布的针对的是 Linux 社区，但它也可以帮助使用 ATI 硬件的 Solaris/OpenSolaris 用户。特别是随着印第安纳项目的即将推出，开源 R500/600 驱动程序移植就只是时间问题了。
### 2007/9/5 [Solaris Express 社区版 Build 71](http://www.phoronix.com/scan.php?page=news_item&px=NjAzNQ)
Solaris Express 社区版（SXCE）现已推出 Build 71。您可以在 OpenSolaris.org 中找到有关 Solaris Express 社区版 Build 71 的更多信息。另外，在 Linux 内核峰会上，AMD 将提供 GPU 规格的消息，由此产生的 X.Org 驱动程序将来可能会导致 ATI 硬件上 Solaris/OpenSolaris 有所改善。
### 2007/8/27 [Linux 的 Solaris 容器](http://www.phoronix.com/scan.php?page=news_item&px=NjAxMQ)
Sun Microsystems 已经宣布，他们将很快支持适用于 Linux 应用程序的 Solaris 容器。这样可以在 Solaris 下运行 Linux 应用程序，而无需对二进制包进行任何修改。适用于 Linux 的 Solaris 容器将允许从 Linux 到 Solaris 的平滑迁移，协助跨平台开发以及其他优势。当该支持到来时，这个时代就“快到了”。
### 2007/8/23 [OpenSolaris 开发者峰会](http://www.phoronix.com/scan.php?page=news_item&px=NjAwNA)
今天早些时候在 OpenSolaris 论坛上发布了第一次 OpenSolaris 开发人员峰会的消息。这次峰会将在十月份在加州大学圣克鲁斯分校举行。 Sara Dornsife 将这次峰会描述为“不是与演示文稿或参展商举行会议，而是一个亲自参与的协作工作会议，以计划下一期的印第安纳项目。” 伊恩·默多克（Ian Murdock） 将在这个“印第安纳项目”中进行主题演讲，但除此之外，该计划仍在计划之中。 Phoronix 可能会继续跟踪此事件，您可以在 Solaris 论坛上讨论此次峰会。
### 2007/8/18 [Solaris Express 社区版 Build 70](http://www.phoronix.com/scan.php?page=news_item&px=NTk4Nw)
名叫 "Nevada" 的 Solaris Express 社区版 Build 70 (SXCE snv\_70) 现在已经发布。有关下载链接的通知可以在 OpenSolaris 论坛中找到。还有公布了其网络存储的 Build 71 版本，包括来自 Qlogic 的光纤通道 HBA 驱动程序的源代码。
### 2007/8/16 [IBM 使用 Sun Solaris 的系统](http://www.phoronix.com/scan.php?page=news_item&px=NTk4NA)
Sun Microsystems 和 IBM正在举行电话会议，他们刚刚宣布，IBM 将开始在服务器上使用 Sun 的 Solaris 操作系统。这些 IBM 服务器包括基于 x86 的服务器系统以及 Blade Center 服务器。官方新闻稿刚刚发布，可以在 sun 新闻室阅读。
### 2007/8/9 [OpenSolaris 不会与 Linux 合并](http://www.phoronix.com/scan.php?page=news_item&px=NTk2Ng)
在旧金山的 LinuxWorld 2007 上，Andrew Morton 在主题演讲中表示， OpenSolaris 的关键组件不会出现在 Linux 内核中。事实上，莫顿甚至表示 “非常遗憾 OpenSolaris 活着”。OpenSolaris 的一些关键组件包括 Zones、ZFS 和 DTrace 。虽然印第安纳州项目有可能将这些项目转变为 GPLv3 项目... 更多信息参见 ZDNET。
### 2007/7/27 [Solaris Xen 已经更新](http://www.phoronix.com/scan.php?page=news_item&px=NTkzMQ)
已经有一段时间了，Solaris Xen 终于更新了。约翰·莱文（John Levon）表示，这一最新版本基于 Xen 3.0.4 和 Solaris “Nevada” Build 66。这一最新版本的改进包括 PAE 支持、HVM 支持、新的 virt-manager 工具、改进的调试支持以及管理域支持。可以在 Sun 的网站上找到 2007 年 7 月 Solaris Xen 更新的下载。
### 2007/7/25 [Solaris 10 7/07 HW 版本](http://www.phoronix.com/scan.php?page=news_item&px=NTkyMA)
Solaris 10 7/07 HW 版本的文档已经上线。如 Solaris 发行注记中所述，Solaris 10 7/07 仅适用于 SPARC Enterprise M4000-M9000 服务器，并且没有 x86/x64 版本可用。所有平台的最新 Solaris 更新是 Solaris 10 11/06 。您可以在 Phoronix 论坛中讨论 Solaris 7/07。
### 2007/7/16 [来自英特尔的 Solaris 电信服务器](http://www.phoronix.com/scan.php?page=news_item&px=NTg5Nw)
今天宣布推出符合 NEBS、ETSI 和 ATCA 合规性的英特尔体系的 Sun Solaris 电信机架服务器和刀片服务器。在这些新的运营商级平台中，英特尔运营商级机架式服务器 TIGW1U 支持 Linux 和 Solaris 10，而 Intel NetStructure MPCBL0050 SBC 也将支持这两种操作系统。今天的新闻稿可以在这里阅读。
然后是 Solaris 分类中最受欢迎的特色文章：
### [Ubuntu vs. OpenSolaris vs. FreeBSD 基准测试](http://www.phoronix.com/vr.php?view=13149)
在过去的几个星期里，我们提供了几篇关于 Ubuntu Linux 性能的深入文章。我们已经开始提供 Ubuntu 7.04 到 8.10 的基准测试，并且发现这款受欢迎的 Linux 发行版的性能随着时间的推移而变慢，随之而来的是 Mac OS X 10.5 对比 Ubuntu 8.10 的基准测试和其他文章。在本文中，我们正在比较 Ubuntu 8.10 的 64 位性能与 OpenSolaris 2008.11 和 FreeBSD 7.1 的最新测试版本。
### [NVIDIA 的性能：Windows vs. Linux vs. Solaris](http://www.phoronix.com/vr.php?view=11968)
本周早些时候，我们预览了 Quadro FX1700，它是 NVIDIA 的中端工作站显卡之一，基于 G84GL 内核，而 G84GL 内核又源于消费级 GeForce 8600 系列。该 PCI Express 显卡提供 512MB 的视频内存，具有两个双链路 DVI 连接，并支持 OpenGL 2.1 ，同时保持最大功耗仅为 42 瓦。正如我们在预览文章中提到的，我们将不仅在 Linux 下查看此显卡的性能，还要在 Microsoft Windows 和 Sun 的 Solaris 中测试此工作站解决方案。在今天的这篇文章中，我们正在这样做，因为我们测试了 NVIDIA Quadro FX1700 512MB 与这些操作系统及其各自的二进制显示驱动程序。
### [FreeBSD 8.0 对比 Linux、OpenSolaris](http://www.phoronix.com/vr.php?view=14407)
在 FreeBSD 8.0 的稳定版本发布的上周，我们终于可以把它放在测试台上，并用 Phoronix 测试套件进行了全面的了解。我们将 FreeBSD 8.0 的性能与早期的 FreeBSD 7.2 版本以及 Fedora 12 和 Ubuntu 9.10 还有 Sun OS 端的 OpenSolaris 2010.02 b127 快照进行了比较。
### [Fedora、Debian、FreeBSD、OpenBSD、OpenSolaris 基准测试](http://www.phoronix.com/vr.php?view=14533)
上周我们发布了第一个 Debian GNU/kFreeBSD 基准测试，将 FreeBSD 内核捆绑在 Debian GNU 用户的 Debian GNU/Linux 上，比较了这款 Debian 系统的 32 位和 64 位性能。 我们现在扩展了这个比较，使许多其他操作系统与 Debian GNU/Linux 和 Debian GNU/kFreeBSD 的 6.0 Squeeze 快照直接进行比较，如 Fedora 12，FreeBSD 7.2，FreeBSD 8.0，OpenBSD 4.6 和 OpenSolaris 2009.06 。
### [AMD 上海皓龙：Linux vs. OpenSolaris 基准测试](http://www.phoronix.com/vr.php?view=13475)
1月份，当我们研究了四款皓龙 2384 型号时，我们在 Linux 上发布了关于 AMD 上海皓龙 CPU 的综述。与早期的 AMD 巴塞罗那处理器 Ubuntu Linux 相比，这些 45nm 四核工作站服务器处理器的性能非常好，但是在运行 Sun OpenSolaris 操作系统时，性能如何？今天浏览的是 AMD 双核的基准测试，运行 OpenSolaris 2008.11、Ubuntu 8.10 和即将推出的 Ubuntu 9.04 版本。
### [OpenSolaris vs. Linux 内核基准](http://www.phoronix.com/vr.php?view=13826)
本周早些时候，我们提供了 Ubuntu 9.04 与 Mac OS X 10.5.6 的基准测试，发现 Leopard 操作系统（Mac）在大多数测试中的表现要优于 Jaunty Jackalope （Ubuntu），至少在 Ubuntu 32 位是这样的。我们今天又回过来进行更多的操作系统基准测试，但这次我们正在比较 Linux 和 Sun OpenSolaris 内核的性能。我们使用的 Nexenta Core 2 操作系统将 OpenSolaris 内核与 GNU/Ubuntu 用户界面组合在同一个 Ubuntu 软件包中，但使用了 Linux 内核的 32 位和 64 位 Ubuntu 服务器安装进行测试。
### [Netbook 性能：Ubuntu vs. OpenSolaris](http://www.phoronix.com/vr.php?view=14039)
过去，我们已经发布了 OpenSolaris vs. Linux Kernel 基准测试以及类似的文章，关注 Sun 的 OpenSolaris 与流行的 Linux 发行版的性能。我们已经看过高端 AMD 工作站的性能，但是我们从来没有比较上网本上的 OpenSolaris 和 Linux 性能。直到今天，在本文中，我们将比较戴尔 Inspiron Mini 9 上网本上的 OpenSolaris 2009.06 和 Ubuntu 9.04 的结果。
### [NVIDIA 图形：Linux vs. Solaris](http://www.phoronix.com/vr.php?view=10301)
在 Phoronix，我们不断探索 Linux 下的不同显示驱动程序，在我们评估了 Sun 的检查工具并测试了 Solaris 主板以及覆盖其他几个领域之后，我们还没有执行图形驱动程序 Linux 和 Solaris 之间的比较。直到今天。由于印第安纳州项目，我们对 Solaris 更感兴趣，我们决定终于通过 NVIDIA 专有驱动程序提供我们在 Linux 和 Solaris 之间的第一次定量图形比较。
### [OpenSolaris 2008.05 向 Solaris 提供了一个新面孔](http://www.phoronix.com/vr.php?view=12269)
2月初，Sun Microsystems 发布了印第安纳项目的第二个预览版本。对于那些人来说，印第安纳州项目是 Sun 的 Ian Murdock 领导的项目的代号，旨在通过解决 Solaris 的长期可用性问题，将 OpenSolaris 推向更多的台式机和笔记本电脑。我们没有对预览 2 留下什么深刻印象，因为它没有比普通用户感兴趣的 GNU/Linux 桌面更有优势。然而，随着 5 月份推出的 OpenSolaris 2008.05 印第安纳项目发布，Sun Microsystems 今天发布了该操作系统的最终测试副本。当最后看到项目印第安纳时， 我们对这个新的 OpenSolaris 版本的最初体验是远远优于我们不到三月前的体验的。
### [快速概览 Oracle Solaris 11](http://www.phoronix.com/vr.php?view=16681)
Solaris 11 在周三发布，是七年来这个前 Sun 操作系统的第一个主要更新。在过去七年中，Solaris 家族发生了很大变化，OpenSolaris 在那个时候已经到来，但在本文中，简要介绍了全新的 Oracle Solaris 11 版本。
### [OpenSolaris、BSD & Linux 的新基准测试](http://www.phoronix.com/vr.php?view=15476)
今天早些时候，我们对以原生的内核模块支持的 Linux 上的 ZFS 进行了基准测试，该原生模块将被公开提供，以将这个 Sun/Oracle 文件系统覆盖到更多的 Linux 用户。现在，尽管作为一个附加奖励，我们碰巧有了基于 OpenSolaris 的最新发行版的新基准，包括 OpenSolaris、OpenIndiana 和 Augustiner-Schweinshaxe，与 PC-BSD、Fedora 和 Ubuntu相比。
### [FreeBSD/PC-BSD 9.1 针对 Linux、Solaris、BSD 的基准](http://www.phoronix.com/vr.php?view=18291)
虽然 FreeBSD 9.1 尚未正式发布，但是基于 FreeBSD 的 PC-BSD 9.1 “Isotope”版本本月已经可用。本文中的性能指标是 64 位版本的 PC-BSD 9.1 与 DragonFlyBSD 3.0.3、Oracle Solaris Express 11.1、CentOS 6.3、Ubuntu 12.10 以及 Ubuntu 13.04 开发快照的比较。
---
作者简介：
Michael Larabel 是 Phoronix.com 的作者，并于 2004 年创立了该网站，该网站重点是丰富多样的 Linux 硬件体验。 Michael 撰写了超过10,000 篇文章，涵盖了 Linux 硬件支持，Linux 性能，图形驱动程序等主题。 Michael 也是 Phoronix 测试套件、 Phoromatic 和 OpenBenchmarking.org 自动化基准测试软件的主要开发人员。可以通过 Twitter 关注他或通过 MichaelLarabel.com 联系他。
---
via: <https://www.phoronix.com/scan.php?page=news_item&px=Solaris-2017-Look-Back>
作者：[Michael Larabel](http://www.michaellarabel.com/) 译者：[MonkeyDEcho](https://github.com/MonkeyDEcho) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：Deadline
|
Daniel Stori
|
http://turnoff.us/geek/deadline/
|
当期限到来时……
|
/data/attachment/album/201708/23/145201fekjepxkvv2ufxju.png.thumb.jpg
|
/data/attachment/album/201708/23/145201fekjepxkvv2ufxju.png.large.jpg
| false | false | true |
zionfuo
| false |
[
"漫画"
] |
极客漫画
|
{
"viewnum": 10946,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "211.102.192.66",
"message": "貌似穿了一件docker鲸鱼的T恤",
"username": "编程浪子 [Chrome 60.0|Windows 7]",
"date": "2017-08-25T15:44:32"
}
] |
[] |
当期限到来时……
| 2017-08-23T14:52:00 | 2017-08-23T14:52:00 | 8,806 |
/article-8806-1.html
|
DeLorean：美国经典科幻电影系列《回到未来》中的时光汽车。
Tardis：英国科幻电视剧《Doctor Who》中的时间机器和宇宙飞船，它是时间和空间的相对维度（Time And Relative Dimension(s) In Space）的缩写。
---
via: <http://turnoff.us/geek/deadline/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者：[zionfuo](https://github.com/zionfuo) 合成：[zionfuo](https://github.com/zionfuo)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 开机引导和启动过程详解
|
David Both
|
https://opensource.com/article/17/2/linux-boot-and-startup
|
你是否曾经对操作系统为何能够执行应用程序而感到疑惑？那么本文将为你揭开操作系统引导与启动的面纱。
|
/data/attachment/album/201708/24/123711cam1fjf4eaefajnz.jpg.thumb.jpg
|
/data/attachment/album/201708/24/123711cam1fjf4eaefajnz.jpg
| true | false | true |
penghuster
| true |
[
"Linux",
"启动",
"引导",
"GRUB2"
] |
技术
|
{
"viewnum": 100168,
"commentnum": 22,
"favtimes": 22,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "180.168.107.74",
"message": "赞一个",
"username": "来自上海的 Firefox 55.0|Windows 7 用户",
"date": "2017-08-24T18:49:26"
},
{
"postip": "14.106.132.242",
"message": "好文@！~",
"username": "sunriders [Firefox 55.0|Windows 10]",
"date": "2017-08-24T23:18:35"
},
{
"postip": "58.61.233.136",
"message": "粗看题图，还以为是个在流口水的吃豆人，简直吓尿",
"username": "来自广东广州的 Firefox 55.0|Ubuntu 用户",
"date": "2017-08-25T04:42:00"
},
{
"postip": "111.20.112.126",
"message": "SYSTEMD还是应该保留很多SYSV的配置方法。太激进不好",
"username": "来自陕西西安的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-28T13:25:39"
},
{
"postip": "218.18.212.96",
"message": "赞一个！",
"username": "hello_linux [Chrome 51.0|Windows 7]",
"date": "2017-08-29T07:26:12"
},
{
"postip": "1.204.12.26",
"message": "不错哦，很详细，赞一个",
"username": "张熙熙 [Firefox 55.0|Windows 10]",
"date": "2017-08-31T00:11:47"
},
{
"postip": "58.61.222.32",
"message": ""图 1 中，以 * 开头的目标态是通用的启动状态。"<br />\r\n为什么我在图1中找不到带*的内容？",
"username": "来自广东广州的 Firefox 55.0|Ubuntu 用户",
"date": "2017-08-31T08:35:45"
},
{
"postip": "61.186.26.238",
"message": "哦，这是一个疏漏，马上补上",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-08-31T15:36:24"
},
{
"postip": "59.42.210.246",
"message": "看不懂",
"username": "来自广东广州的 Sogou Explorer 2|Windows 7 用户",
"date": "2017-09-15T11:58:19"
},
{
"postip": "223.104.106.170",
"message": "牛逼",
"username": "ubuntu~ [Chrome Mobile 40.0|Android 6.0]",
"date": "2017-09-18T08:40:58"
},
{
"postip": "113.143.41.86",
"message": "zhendeniupi",
"username": "来自陕西宝鸡的 Chrome 73.0|Windows 10 用户",
"date": "2019-05-19T21:42:55"
},
{
"postip": "113.143.41.86",
"message": "zhendeniupi",
"username": "来自陕西宝鸡的 Chrome 73.0|Windows 10 用户",
"date": "2019-05-19T21:42:59"
},
{
"postip": "113.143.41.86",
"message": "zhendeniupi",
"username": "来自陕西宝鸡的 Chrome 73.0|Windows 10 用户",
"date": "2019-05-19T21:43:03"
},
{
"postip": "113.143.41.86",
"message": "zhendeniupi",
"username": "来自陕西宝鸡的 Chrome 73.0|Windows 10 用户",
"date": "2019-05-19T21:43:03"
},
{
"postip": "61.140.99.152",
"message": "写的非常好，必须赞一个",
"username": "来自广东广州的 Chrome 50.0|Windows 7 用户",
"date": "2020-04-08T14:54:28"
},
{
"postip": "121.13.130.208",
"message": "非常棒",
"username": "来自广东东莞的 Chrome 78.0|Windows 7 用户",
"date": "2020-05-20T11:12:33"
},
{
"postip": "222.92.90.170",
"message": "看不懂，但是看起来很厉害！",
"username": "来自江苏苏州的 Chrome 92.0|Windows 10 用户",
"date": "2021-07-30T13:55:09"
},
{
"postip": "220.165.252.98",
"message": "盗别人的网页资料，连话术和标题都一模一样，你咋这么优秀呢",
"username": "来自云南昆明的 Chrome 75.0|Windows 10 用户",
"date": "2021-08-17T11:18:49"
},
{
"postip": "113.98.191.137",
"message": "你看懂了吗？还非常好，漏洞百出",
"username": "来自广东佛山的 Chrome 86.0|Windows 10 用户",
"date": "2021-09-09T09:41:48"
},
{
"postip": "113.98.191.137",
"message": "你看懂了吗？还非常好，漏洞百出",
"username": "来自广东佛山的 Chrome 86.0|Windows 10 用户",
"date": "2021-09-09T09:41:50"
},
{
"postip": "223.76.241.156",
"message": "的地方",
"username": "来自湖北的 Chrome 95.0|Windows 10 用户",
"date": "2021-11-12T17:05:54"
},
{
"postip": "113.57.152.160",
"message": "感谢分享",
"username": "来自湖北武汉的 Chrome 93.0|GNU/Linux 用户",
"date": "2022-07-25T16:44:53"
}
] |
[] |
你是否曾经对操作系统为何能够执行应用程序而感到疑惑？那么本文将为你揭开操作系统引导与启动的面纱。
| 2017-08-24T12:37:00 | 2017-08-24T12:37:00 | 8,807 |
/article-8807-1.html
|
>
> 你是否曾经对操作系统为何能够执行应用程序而感到疑惑？那么本文将为你揭开操作系统引导与启动的面纱。
>
>
>
理解操作系统开机引导和启动过程对于配置操作系统和解决相关启动问题是至关重要的。该文章陈述了 [GRUB2 引导装载程序](https://en.wikipedia.org/wiki/GNU_GRUB)开机引导装载内核的过程和 [systemd 初始化系统](https://en.wikipedia.org/wiki/Systemd)执行开机启动操作系统的过程。
事实上，操作系统的启动分为两个阶段：<ruby> 引导 <rt> boot </rt></ruby>和<ruby> 启动 <rt> startup </rt></ruby>。引导阶段开始于打开电源开关，结束于内核初始化完成和 systemd 进程成功运行。启动阶段接管了剩余工作，直到操作系统进入可操作状态。
总体来说，Linux 的开机引导和启动过程是相当容易理解，下文将分节对于不同步骤进行详细说明。
* BIOS 上电自检（POST）
* 引导装载程序 (GRUB2)
* 内核初始化
* 启动 systemd，其是所有进程之父。
注意，本文以 GRUB2 和 systemd 为载体讲述操作系统的开机引导和启动过程，是因为这二者是目前主流的 linux 发行版本所使用的引导装载程序和初始化软件。当然另外一些过去使用的相关软件仍然在一些 Linux 发行版本中使用。
### 引导过程
引导过程能以两种方式之一初始化。其一，如果系统处于关机状态，那么打开电源按钮将开启系统引导过程。其二，如果操作系统已经运行在一个本地用户（该用户可以是 root 或其他非特权用户），那么用户可以借助图形界面或命令行界面通过编程方式发起一个重启操作，从而触发系统引导过程。重启包括了一个关机和重新开始的操作。
#### BIOS 上电自检（POST）
上电自检过程中其实 Linux 没有什么也没做，上电自检主要由硬件的部分来完成，这对于所有操作系统都一样。当电脑接通电源，电脑开始执行 BIOS（<ruby> 基本输入输出系统 <rt> Basic I/O System </rt></ruby>）的 POST（<ruby> 上电自检 <rt> Power On Self Test </rt></ruby>）过程。
在 1981 年，IBM 设计的第一台个人电脑中，BIOS 被设计为用来初始化硬件组件。POST 作为 BIOS 的组成部分，用于检验电脑硬件基本功能是否正常。如果 POST 失败，那么这个电脑就不能使用，引导过程也将就此中断。
BIOS 上电自检确认硬件的基本功能正常，然后产生一个 BIOS [中断](https://en.wikipedia.org/wiki/BIOS_interrupt_call) INT 13H，该中断指向某个接入的可引导设备的引导扇区。它所找到的包含有效的引导记录的第一个引导扇区将被装载到内存中，并且控制权也将从引导扇区转移到此段代码。
引导扇区是引导加载器真正的第一阶段。大多数 Linux 发行版本使用的引导加载器有三种：GRUB、GRUB2 和 LILO。GRUB2 是最新的，也是相对于其他老的同类程序使用最广泛的。
#### GRUB2
GRUB2 全称是 GRand Unified BootLoader，Version 2（第二版大一统引导装载程序）。它是目前流行的大部分 Linux 发行版本的主要引导加载程序。GRUB2 是一个用于计算机寻找操作系统内核并加载其到内存的智能程序。由于 GRUB 这个单词比 GRUB2 更易于书写和阅读，在下文中，除特殊指明以外，GRUB 将代指 GRUB2。
GRUB 被设计为兼容操作系统[多重引导规范](https://en.wikipedia.org/wiki/Multiboot_Specification)，它能够用来引导不同版本的 Linux 和其他的开源操作系统；它还能链式加载专有操作系统的引导记录。
GRUB 允许用户从任何给定的 Linux 发行版本的几个不同内核中选择一个进行引导。这个特性使得操作系统，在因为关键软件不兼容或其它某些原因升级失败时，具备引导到先前版本的内核的能力。GRUB 能够通过文件 `/boot/grub/grub.conf` 进行配置。（LCTT 译注：此处指 GRUB1）
GRUB1 现在已经逐步被弃用，在大多数现代发行版上它已经被 GRUB2 所替换，GRUB2 是在 GRUB1 的基础上重写完成。基于 Red Hat 的发行版大约是在 Fedora 15 和 CentOS/RHEL 7 时升级到 GRUB2 的。GRUB2 提供了与 GRUB1 同样的引导功能，但是 GRUB2 也是一个类似主框架（mainframe）系统上的基于命令行的前置操作系统（Pre-OS）环境，使得在预引导阶段配置更为方便和易操作。GRUB2 通过 `/boot/grub2/grub.cfg` 进行配置。
两个 GRUB 的最主要作用都是将内核加载到内存并运行。两个版本的 GRUB 的基本工作方式一致，其主要阶段也保持相同，都可分为 3 个阶段。在本文将以 GRUB2 为例进行讨论其工作过程。GRUB 或 GRUB2 的配置，以及 GRUB2 的命令使用均超过本文范围，不会在文中进行介绍。
虽然 GRUB2 并未在其三个引导阶段中正式使用这些<ruby> 阶段 <rt> stage </rt></ruby>名词，但是为了讨论方便，我们在本文中使用它们。
##### 阶段 1
如上文 POST（上电自检）阶段提到的，在 POST 阶段结束时，BIOS 将查找在接入的磁盘中查找引导记录，其通常位于 MBR（<ruby> 主引导记录 <rt> Master Boot Record </rt></ruby>），它加载它找到的第一个引导记录中到内存中，并开始执行此代码。引导代码（及阶段 1 代码）必须非常小，因为它必须连同分区表放到硬盘的第一个 512 字节的扇区中。 在[传统的常规 MBR](https://en.wikipedia.org/wiki/Master_boot_record) 中，引导代码实际所占用的空间大小为 446 字节。这个阶段 1 的 446 字节的文件通常被叫做引导镜像（boot.img），其中不包含设备的分区信息，分区是一般单独添加到引导记录中。
由于引导记录必须非常的小，它不可能非常智能，且不能理解文件系统结构。因此阶段 1 的唯一功能就是定位并加载阶段 1.5 的代码。为了完成此任务，阶段 1.5 的代码必须位于引导记录与设备第一个分区之间的位置。在加载阶段 1.5 代码进入内存后，控制权将由阶段 1 转移到阶段 1.5。
##### 阶段 1.5
如上所述，阶段 1.5 的代码必须位于引导记录与设备第一个分区之间的位置。该空间由于历史上的技术原因而空闲。第一个分区的开始位置在扇区 63 和 MBR（扇区 0）之间遗留下 62 个 512 字节的扇区（共 31744 字节），该区域用于存储阶段 1.5 的代码镜像 core.img 文件。该文件大小为 25389 字节，故此区域有足够大小的空间用来存储 core.img。
因为有更大的存储空间用于阶段 1.5，且该空间足够容纳一些通用的文件系统驱动程序，如标准的 EXT 和其它的 Linux 文件系统，如 FAT 和 NTFS 等。GRUB2 的 core.img 远比更老的 GRUB1 阶段 1.5 更复杂且更强大。这意味着 GRUB2 的阶段 2 能够放在标准的 EXT 文件系统内，但是不能放在逻辑卷内。故阶段 2 的文件可以存放于 `/boot` 文件系统中，一般在 `/boot/grub2` 目录下。
注意 `/boot` 目录必须放在一个 GRUB 所支持的文件系统（并不是所有的文件系统均可）。阶段 1.5 的功能是开始执行存放阶段 2 文件的 `/boot` 文件系统的驱动程序，并加载相关的驱动程序。
##### 阶段 2
GRUB 阶段 2 所有的文件都已存放于 `/boot/grub2` 目录及其几个子目录之下。该阶段没有一个类似于阶段 1 与阶段 1.5 的镜像文件。相应地，该阶段主要需要从 `/boot/grub2/i386-pc` 目录下加载一些内核运行时模块。
GRUB 阶段 2 的主要功能是定位和加载 Linux 内核到内存中，并转移控制权到内核。内核的相关文件位于 `/boot` 目录下，这些内核文件可以通过其文件名进行识别，其文件名均带有前缀 vmlinuz。你可以列出 `/boot` 目录中的内容来查看操作系统中当前已经安装的内核。
GRUB2 跟 GRUB1 类似，支持从 Linux 内核选择之一引导启动。Red Hat 包管理器（DNF）支持保留多个内核版本，以防最新版本内核发生问题而无法启动时，可以恢复老版本的内核。默认情况下，GRUB 提供了一个已安装内核的预引导菜单，其中包括问题诊断菜单（recuse）以及恢复菜单（如果配置已经设置恢复镜像）。
阶段 2 加载选定的内核到内存中，并转移控制权到内核代码。
#### 内核
内核文件都是以一种自解压的压缩格式存储以节省空间，它与一个初始化的内存映像和存储设备映射表都存储于 `/boot` 目录之下。
在选定的内核加载到内存中并开始执行后，在其进行任何工作之前，内核文件首先必须从压缩格式解压自身。一旦内核自解压完成，则加载 [systemd](https://en.wikipedia.org/wiki/Systemd) 进程（其是老式 System V 系统的 [init](https://en.wikipedia.org/wiki/Init#SysV-style) 程序的替代品)，并转移控制权到 systemd。
这就是引导过程的结束。此刻，Linux 内核和 systemd 处于运行状态，但是由于没有其他任何程序在执行，故其不能执行任何有关用户的功能性任务。
### 启动过程
启动过程紧随引导过程之后，启动过程使 Linux 系统进入可操作状态，并能够执行用户功能性任务。
#### systemd
systemd 是所有进程的父进程。它负责将 Linux 主机带到一个用户可操作状态（可以执行功能任务）。systemd 的一些功能远较旧式 init 程序更丰富，可以管理运行中的 Linux 主机的许多方面，包括挂载文件系统，以及开启和管理 Linux 主机的系统服务等。但是 systemd 的任何与系统启动过程无关的功能均不在此文的讨论范围。
首先，systemd 挂载在 `/etc/fstab` 中配置的文件系统，包括内存交换文件或分区。据此，systemd 必须能够访问位于 `/etc` 目录下的配置文件，包括它自己的。systemd 借助其配置文件 `/etc/systemd/system/default.target` 决定 Linux 系统应该启动达到哪个状态（或<ruby> 目标态 <rt> target </rt></ruby>）。`default.target` 是一个真实的 target 文件的符号链接。对于桌面系统，其链接到 `graphical.target`，该文件相当于旧式 systemV init 方式的 **runlevel 5**。对于一个服务器操作系统来说，`default.target` 更多是默认链接到 `multi-user.target`， 相当于 systemV 系统的 **runlevel 3**。 `emergency.target` 相当于单用户模式。
（LCTT 译注：“target” 是 systemd 新引入的概念，目前尚未发现有官方的准确译名，考虑到其作用和使用的上下文环境，我们认为翻译为“目标态”比较贴切。以及，“unit” 是指 systemd 中服务和目标态等各个对象/文件，在此依照语境译作“单元”。）
注意，所有的<ruby> 目标态 <rt> target </rt></ruby>和<ruby> 服务 <rt> service </rt></ruby>均是 systemd 的<ruby> 单元 <rt> unit </rt></ruby>。
如下表 1 是 systemd 启动的<ruby> 目标态 <rt> target </rt></ruby>和老版 systemV init 启动<ruby> 运行级别 <rt> runlevel </rt></ruby>的对比。这个 **systemd 目标态别名** 是为了 systemd 向前兼容 systemV 而提供。这个目标态别名允许系统管理员（包括我自己）用 systemV 命令（例如 `init 3`）改变运行级别。当然，该 systemV 命令是被转发到 systemd 进行解释和执行的。
| SystemV 运行级别 | systemd 目标态 | systemd 目标态别名 | 描述 |
| --- | --- | --- | --- |
| | `halt.target` | | 停止系统运行但不切断电源。 |
| 0 | `poweroff.target` | `runlevel0.target` | 停止系统运行并切断电源. |
| S | `emergency.target` | | 单用户模式，没有服务进程运行，文件系统也没挂载。这是一个最基本的运行级别，仅在主控制台上提供一个 shell 用于用户与系统进行交互。 |
| 1 | `rescue.target` | `runlevel1.target` | 挂载了文件系统，仅运行了最基本的服务进程的基本系统，并在主控制台启动了一个 shell 访问入口用于诊断。 |
| 2 | | `runlevel2.target` | 多用户，没有挂载 NFS 文件系统，但是所有的非图形界面的服务进程已经运行。 |
| 3 | `multi-user.target` | `runlevel3.target` | 所有服务都已运行，但只支持命令行接口访问。 |
| 4 | | `runlevel4.target` | 未使用。 |
| 5 | `graphical.target` | `runlevel5.target` | 多用户，且支持图形界面接口。 |
| 6 | `reboot.target` | `runlevel6.target` | 重启。 |
| | `default.target` | | 这个<ruby> 目标态 <rt> target </rt></ruby>是总是 `multi-user.target` 或 `graphical.target` 的一个符号链接的别名。systemd 总是通过 `default.target` 启动系统。`default.target` 绝不应该指向 `halt.target`、 `poweroff.target` 或 `reboot.target`。 |
*表 1 老版本 systemV 的 运行级别与 systemd 与<ruby> 目标态 <rt> target </rt></ruby>或目标态别名的比较*
每个<ruby> 目标态 <rt> target </rt></ruby>有一个在其配置文件中描述的依赖集，systemd 需要首先启动其所需依赖，这些依赖服务是 Linux 主机运行在特定的功能级别所要求的服务。当配置文件中所有的依赖服务都加载并运行后，即说明系统运行于该目标级别。
systemd 也会查看老式的 systemV init 目录中是否存在相关启动文件，若存在，则 systemd 根据这些配置文件的内容启动对应的服务。在 Fedora 系统中，过时的网络服务就是通过该方式启动的一个实例。
如下图 1 是直接从 bootup 的 man 页面拷贝而来。它展示了在 systemd 启动过程中一般的事件序列和确保成功的启动的基本的顺序要求。
`sysinit.target` 和 `basic.target` 目标态可以被视作启动过程中的状态检查点。尽管 systemd 的设计初衷是并行启动系统服务，但是部分服务或功能目标态是其它服务或目标态的启动的前提。系统将暂停于检查点直到其所要求的服务和目标态都满足为止。
`sysinit.target` 状态的到达是以其所依赖的所有资源模块都正常启动为前提的，所有其它的单元，如文件系统挂载、交换文件设置、设备管理器的启动、随机数生成器种子设置、低级别系统服务初始化、加解密服务启动（如果一个或者多个文件系统加密的话）等都必须完成，但是在 **sysinit.target** 中这些服务与模块是可以并行启动的。
`sysinit.target` 启动所有的低级别服务和系统初具功能所需的单元，这些都是进入下一阶段 basic.target 的必要前提。
*图 1：systemd 的启动流程*
在 `sysinit.target` 的条件满足以后，systemd 接下来启动 `basic.target`，启动其所要求的所有单元。 `basic.target` 通过启动下一目标态所需的单元而提供了更多的功能，这包括各种可执行文件的目录路径、通信 sockets，以及定时器等。
最后，用户级目标态（`multi-user.target` 或 `graphical.target`） 可以初始化了，应该注意的是 `multi-user.target` 必须在满足图形化目标态 `graphical.target` 的依赖项之前先达成。
图 1 中，以 `*` 开头的目标态是通用的启动状态。当到达其中的某一目标态，则说明系统已经启动完成了。如果 `multi-user.target` 是默认的目标态，则成功启动的系统将以命令行登录界面呈现于用户。如果 `graphical.target` 是默认的目标态，则成功启动的系统将以图形登录界面呈现于用户，界面的具体样式将根据系统所配置的[显示管理器](https://opensource.com/article/16/12/yearbook-best-couple-2016-display-manager-and-window-manager)而定。
### 故障讨论
最近我需要改变一台使用 GRUB2 的 Linux 电脑的默认引导内核。我发现一些 GRUB2 的命令在我的系统上不能用，也可能是我使用方法不正确。至今，我仍然不知道是何原因导致，此问题需要进一步探究。
`grub2-set-default` 命令没能在配置文件 `/etc/default/grub` 中成功地设置默认内核索引，以至于期望的替代内核并没有被引导启动。故在该配置文件中我手动更改 `GRUB_DEFAULT=saved` 为 `GRUB_DEFAULT=2`，2 是我需要引导的安装好的内核文件的索引。然后我执行命令 `grub2-mkconfig > /boot/grub2/grub.cfg` 创建了新的 GRUB 配置文件，该方法如预期的规避了问题，并成功引导了替代的内核。
### 结论
GRUB2、systemd 初始化系统是大多数现代 Linux 发行版引导和启动的关键组件。尽管在实际中，systemd 的使用还存在一些争议，但是 GRUB2 与 systemd 可以密切地配合先加载内核，然后启动一个业务系统所需要的系统服务。
尽管 GRUB2 和 systemd 都比其前任要更加复杂，但是它们更加容易学习和管理。在 man 页面有大量关于 systemd 的帮助说明，freedesktop.org 也在线收录了完整的此[帮助说明](https://www.freedesktop.org/software/systemd/man/index.html)。下面有更多相关信息链接。
### 附加资源
* [GNU GRUB](https://en.wikipedia.org/wiki/GNU_GRUB) (Wikipedia)
* [GNU GRUB Manual](https://www.gnu.org/software/grub/manual/grub.html) (GNU.org)
* [Master Boot Record](https://en.wikipedia.org/wiki/Master_boot_record) (Wikipedia)
* [Multiboot specification](https://en.wikipedia.org/wiki/Multiboot_Specification) (Wikipedia)
* [systemd](https://en.wikipedia.org/wiki/Systemd) (Wikipedia)
* [systemd bootup process](https://www.freedesktop.org/software/systemd/man/bootup.html) (Freedesktop.org)
* [systemd index of man pages](https://www.freedesktop.org/software/systemd/man/index.html) (Freedesktop.org)
---
作者简介：
David Both 居住在美国北卡罗纳州的首府罗利，是一个 Linux 开源贡献者。他已经从事 IT 行业 40 余年，在 IBM 教授 OS/2 20余年。1981 年，他在 IBM 开发了第一个关于最初的 IBM 个人电脑的培训课程。他也曾在 Red Hat 教授 RHCE 课程，也曾供职于 MCI worldcom，Cico 以及北卡罗纳州等。他已经为 Linux 开源社区工作近 20 年。
---
via: <https://opensource.com/article/17/2/linux-boot-and-startup>
作者：[David Both](https://opensource.com/users/dboth) 译者： [penghuster](https://github.com/penghuster) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
给中级 Meld 用户的有用技巧
|
Ansh
|
https://www.howtoforge.com/tutorial/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/
|
Meld 是 Linux 上功能丰富的可视化比较和合并工具。在本教程中，我们将讨论一些非常有用的技巧，这将让你使用工具的体验更好。
|
/data/attachment/album/201708/25/081212g4ub334ub4am4a04.jpg.thumb.jpg
|
/data/attachment/album/201708/25/081212g4ub334ub4am4a04.jpg
| true | false | true |
geekpi
| false |
[
"Meld"
] |
桌面应用
|
{
"viewnum": 7143,
"commentnum": 6,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "不考虑开源还是闭源，beyond compare 给我留下的映像最深。",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-25T09:45:51"
},
{
"postip": "211.102.192.66",
"message": "没有linux版本吧？windows上beyond compare还是很牛逼的",
"username": "编程浪子 [Chrome 60.0|Windows 7]",
"date": "2017-08-25T14:07:42"
},
{
"postip": "182.139.90.208",
"message": "目前即是开源又是跨平台的比较， 拆分，合并类软件，流行读最高的应该是 git 的吧？",
"username": "来自四川成都的 Chromium 60.0|Ubuntu 用户",
"date": "2017-08-25T19:03:16"
},
{
"postip": "61.186.16.238",
"message": "我觉得araxis merge 最厉害。",
"username": "linux [Chrome 60.0|Mac 10.11]",
"date": "2017-08-25T21:43:23"
},
{
"postip": "58.61.222.32",
"message": "有linux版本",
"username": "来自广东广州的 Firefox 55.0|Ubuntu 用户",
"date": "2017-08-31T09:49:31"
},
{
"postip": "211.102.192.66",
"message": "哪里下载？",
"username": "编程浪子 [Chrome 60.0|Windows 7]",
"date": "2017-08-31T09:57:42"
}
] |
[] |
Meld 是 Linux 上功能丰富的可视化比较和合并工具。在本教程中，我们将讨论一些非常有用的技巧，这将让你使用工具的体验更好。
| 2017-08-25T07:20:00 | 2017-08-25T07:20:00 | 8,808 |
/article-8808-1.html
|
Meld 是 Linux 上功能丰富的可视化比较和合并工具。如果你是第一次接触，你可以进入我们的[初学者指南](/article-8402-1.html)，了解该程序的工作原理，如果你已经阅读过或正在使用 Meld 进行基本的比较/合并任务，你将很高兴了解本教程的东西，在本教程中，我们将讨论一些非常有用的技巧，这将让你使用工具的体验更好。
*但在我们跳到安装和解释部分之前，值得一提的是，本教程中介绍的所有说明和示例已在 Ubuntu 14.04 上进行了测试，而我们使用的 Meld 版本为 3.14.2*。
### 1、 跳转
你可能已经知道（我们也在初学者指南中也提到过这一点），标准滚动不是在使用 Meld 时在更改之间跳转的唯一方法 - 你可以使用向上和向下箭头键轻松地从一个更改跳转到另一个更改位于编辑区域上方的窗格中：
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-go-next-prev-9.png)
但是，这需要你将鼠标指针移动到这些箭头，然后再次单击其中一个（取决于你要去哪里 - 向上或向下）。你会很高兴知道，存在另一种更简单的方式来跳转：只需使用鼠标的滚轮即可在鼠标指针位于中央更改栏上时进行滚动。
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-center-area-scrolling.png)
这样，你就可以在视线不离开或者分心的情况下进行跳转，
### 2、 可以对更改进行的操作
看下上一节的最后一个屏幕截图。你知道那些黑箭头做什么吧？默认情况下，它们允许你执行合并/更改操作 - 当没有冲突时进行合并，并在同一行发生冲突时进行更改。
但是你知道你可以根据需要删除个别的更改么？是的，这是可能的。为此，你需要做的是在处理更改时按下 Shift 键。你会观察到箭头被变成了十字架。
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-delete-changes.png)
只需点击其中任何一个，相应的更改将被删除。
不仅是删除，你还可以确保冲突的更改不会在合并时更改行。例如，以下是一个冲突变化的例子：
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-conflicting-change.png)
现在，如果你点击任意两个黑色箭头，箭头指向的行将被改变，并且将变得与其他文件的相应行相似。只要你想这样做，这是没问题的。但是，如果你不想要更改任何行呢？相反，目的是将更改的行在相应行的上方或下方插入到其他文件中。
我想说的是，例如，在上面的截图中，需要在 “test23” 之上或之下添加 “test 2”，而不是将 “test23” 更改为 “test2”。你会很高兴知道在 Meld 中这是可能的。就像你按下 Shift 键删除注释一样，在这种情况下，你必须按下 Ctrl 键。
你会观察到当前操作将被更改为插入 - 双箭头图标将确认这一点 。
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-ctrl-insert.png)
从箭头的方向看，此操作可帮助用户将当前更改插入到其他文件中的相应更改 (如所选择的)。
### 3、 自定义文件在 Meld 的编辑器区域中显示的方式
有时候，你希望 Meld 的编辑区域中的文字大小变大（为了更好或更舒适的浏览），或者你希望文本行被包含而不是脱离视觉区域（意味着你不要想使用底部的水平滚动条）。
Meld 在 *Editor* 选项卡（*Edit->Preferences->Editor*）的 *Preferences* 菜单中提供了一些显示和字体相关的自定义选项，你可以进行这些调整：
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-editor-tab.png)
在这里你可以看到，默认情况下，Meld 使用系统定义的字体宽度。只需取消选中 *Font* 类别下的框，你将有大量的字体类型和大小选项可供选择。
然后在 *Display* 部分，你将看到我们正在讨论的所有自定义选项：你可以设置 Tab 宽度、告诉工具是否插入空格而不是 tab、启用/禁用文本换行、使Meld显示行号和空白（在某些情况下非常有用）以及使用语法突出显示。
### 4、 过滤文本
有时候，并不是所有的修改都是对你很重要的。例如，在比较两个 C 编程文件时，你可能不希望 Meld 显示注释中的更改，因为你只想专注于与代码相关的更改。因此，在这种情况下，你可以告诉 Meld 过滤（或忽略）与注释相关的更改。
例如，这里是 Meld 中的一个比较，其中由工具高亮了注释相关更改：
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-changes-with-comments.png)
而在这种情况下，Meld 忽略了相同的变化，仅关注与代码相关的变更：
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-changes-without-comments.png)
很酷，不是吗？那么这是怎么回事？为此，我是在 “*Edit->Preferences->Text Filters*” 标签中启用了 “C comments” 文本过滤器：
[](https://www.howtoforge.com/images/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/big/meld-text-filters.png)
如你所见，除了 “C comments” 之外，你还可以过滤掉 C++ 注释、脚本注释、引导或所有的空格等。此外，你还可以为你处理的任何特定情况定义自定义文本过滤器。例如，如果你正在处理日志文件，并且不希望 Meld 高亮显示特定模式开头的行中的更改，则可以为该情况定义自定义文本过滤器。
但是，请记住，要定义一个新的文本过滤器，你需要了解 Python 语言以及如何使用该语言创建正则表达式。
### 总结
这里讨论的所有四个技巧都不是很难理解和使用（当然，除了你想立即创建自定义文本过滤器），一旦你开始使用它们，你会认为他们是真的有好处。这里的关键是要继续练习，否则你学到的任何技巧不久后都会忘记。
你还知道或者使用其他任何中级 Meld 的贴士和技巧么？如果有的话，欢迎你在下面的评论中分享。
---
via: <https://www.howtoforge.com/tutorial/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/>
作者：[Ansh](https://www.howtoforge.com/tutorial/beginners-guide-to-visual-merge-tool-meld-on-linux-part-2/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开源优先：私营公司宣言
|
Sean A Roberts
|
https://opensource.com/article/17/2/open-source-first
|
“开源优先”意味着我们在考虑供应商出品的产品以满足我们的需求之前，首先考虑开源。
|
/data/attachment/album/201708/26/090105bc7a8cpdu8jnznfu.png.thumb.jpg
|
/data/attachment/album/201708/26/090105bc7a8cpdu8jnznfu.png
| true | false | true |
geekpi
| false |
[
"开源"
] |
观点
|
{
"viewnum": 3262,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
“开源优先”意味着我们在考虑供应商出品的产品以满足我们的需求之前，首先考虑开源。
| 2017-08-26T08:59:00 | 2017-08-26T08:59:00 | 8,809 |
/article-8809-1.html
|
这是一个宣言，任何私人组织都可以用来构建其协作转型。请阅读并让我知道你的看法。
我[在 Linux TODO 小组中作了一个演讲](https://sarob.com/2017/01/todo-open-source-presentation-17-january-2017/)使用了这篇文章作为我的材料。对于那些不熟悉 TODO 小组的人，他们是在商业公司支持开源领导力的组织。相互依赖是很重要的，因为法律、安全和其他共享的知识对于开源社区向前推进是非常重要的。尤其是因为我们需要同时代表商业和公共社区的最佳利益。
“开源优先”意味着我们在考虑供应商出品的产品以满足我们的需求之前，首先考虑开源。要正确使用开源技术，你需要做的不仅仅是消费，还需要你的参与，以确保开源技术长期存在。要参与开源工作，你需要将工程师的工作时间分别分配给你的公司和开源项目。我们期望将开源贡献意图以及内部协作带到私营公司。我们需要定义、建立和维护一种贡献、协作和择优工作的文化。
### 开放花园开发
我们的私营公司致力于通过对技术界的贡献，成为技术的领导者。这不仅仅是使用开源代码，成为领导者需要参与。成为领导者还需要与公司以外的团体（社区）进行各种类型的参与。这些社区围绕一个特定的研发项目进行组织。每个社区的参与就像为公司工作一样。重大成果需要大量的参与。
### 编码更多，生活更好
我们必须对计算资源慷慨，对空间吝啬，并鼓励由此产生的凌乱而有创造力的结果。允许人们使用他们的业务的这些工具将改变他们。我们必须有自发的互动。我们必须通过协作来构建鼓励创造性的线上以及线下空间。无法实时联系对方，协作就不能进行。
### 通过精英体制创新
我们必须创建一个精英阶层。思想素质要超过群体结构和在其中的职位任期。按业绩晋升鼓励每个人都成为更好的人和雇员。当我们成为最好的坏人时, 充满激情的人之间的争论将会发生。我们的文化应该有鼓励异议的义务。强烈的意见和想法将会变成热情的职业道德。这些想法和意见可以来自而且应该来自所有人。它不应该改变你是谁，而是应该关心你做什么。随着精英体制的进行，我们会投资未经许可就能正确行事的团队。
### 项目到产品
由于我们的私营公司拥抱开源贡献，我们还必须在研发项目中的上游工作和实现最终产品之间实现明确的分离。项目是研发工作，快速失败以及开发功能是常态。产品是你投入生产，拥有 SLA，并使用研发项目的成果。分离至少需要分离项目和产品的仓库。正常的分离包含在项目和产品上工作的不同社区。每个社区都需要大量的贡献和参与。为了使这些活动保持独立，需要有一个客户功能以及项目到产品的 bug 修复请求的工作流程。
接下来，我们会强调在私营公司创建、支持和扩展开源中的主要步骤。
### 技术上有天赋的人的学校
高手必须指导没有经验的人。当你学习新技能时，你将它们传给下一个人。当你训练下一个人时，你会面临新的挑战。永远不要期待在一个位置很长时间。获得技能，变得强大，通过学习，然后继续前进。
### 找到最适合你的人
我们热爱我们的工作。我们非常喜欢它，我们想和我们的朋友一起工作。我们是一个比我们公司大的社区的一部分。我们应该永远记住招募最好的人与我们一起工作。即使不是为我们公司工作，我们将会为我们周围的人找到很棒的工作。这样的想法使雇用很棒的人成为一种生活方式。随着招聘变得普遍，那么审查和帮助新员工就会变得容易了。
### 即将写的
我将在我的博客上发布关于每个宗旨的[更多细节](https://sarob.com/2017/02/open-source-first-project-product/)，敬请关注。
*这篇文章最初发表在 [Sean Robert 的博客](https://sarob.com/2017/01/open-source-first/)上。CC BY 许可。*
（题图： opensource.com）
---
作者简介：
Sean A Roberts - -以同理心为主导，同时专注于结果。我实践精英体制。在这里发现的智慧。
---
via: <https://opensource.com/article/17/2/open-source-first>
作者：[Sean A Roberts](https://opensource.com/users/sarob) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 snapcraft 将 snap 包发布到商店
|
Sergio Schvezov
|
https://insights.ubuntu.com/2016/11/15/making-your-snaps-available-to-the-store-using-snapcraft/
|
是时候让你的 snap 包进入商店了！
|
/data/attachment/album/201708/26/100735o1ynjs4en2iykguz.jpg.thumb.jpg
|
/data/attachment/album/201708/26/100735o1ynjs4en2iykguz.jpg
| true | false | true |
Snapcrafter
| false |
[
"snapcraft"
] |
技术
|
{
"viewnum": 4423,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "119.145.83.241",
"message": "别又搞分裂。",
"username": "来自广东广州的 Firefox 55.0|Fedora 用户",
"date": "2017-08-27T22:00:13"
},
{
"postip": "124.160.153.186",
"message": "无论是Snap还是Flatpak都不可能流行的。",
"username": "来自浙江嘉兴的 Chrome 61.0|GNU/Linux 用户",
"date": "2017-08-28T10:55:40"
}
] |
[] |
是时候让你的 snap 包进入商店了！
| 2017-08-26T10:07:32 | 2017-08-26T10:07:32 | 8,810 |
/article-8810-1.html
|
Ubuntu Core 已经正式发布（LCTT 译注：指 2016 年 11 月发布的 Ubuntu Snappy Core 16 ），也许是时候让你的 snap 包进入商店了！
### 交付和商店的概念
首先回顾一下我们是怎么通过商店管理 snap 包的吧。
每次你上传 snap 包，商店都会为其分配一个修订版本号，并且商店中针对特定 snap 包 的版本号都是唯一的。
但是第一次上传 snap 包的时候，我们首先要为其注册一个还没有被使用的名字，这很容易。
商店中所有的修订版本都可以释放到多个通道中，这些通道只是概念上定义的，以便给用户一个稳定或风险等级的参照，这些通道有:
* 稳定（stable）
* 候选（candidate）
* 测试（beta）
* 边缘（edge）
理想情况下，如果我们设置了 CI/CD 过程，那么每天或在每次更新源码时都会将其推送到边缘通道。在此过程中有两件事需要考虑。
首先在开始的时候，你最好制作一个不受限制的 snap 包，因为在这种新范例下，snap 包的大部分功能都能不受限制地工作。考虑到这一点，你的项目开始时 `confinement` 将被设置为 `devmode`（LCTT 译注：这是 `snapcraft.yaml` 中的一个键及其可选值）。这使得你在开发的早期阶段，仍然可以让你的 snap 包进入商店。一旦所有的东西都得到了 snap 包运行的安全模型的充分支持，那么就可以将 `confinement` 修改为 `strict`。
好了，假设你在限制方面已经做好了，并且也开始了一个对应边缘通道的 CI/CD 过程，但是如果你也想确保在某些情况下，早期版本 master 分支新的迭代永远也不会进入稳定或候选通道，那么我们可以使用 `gadge` 设置。如果 snap 包的 `gadge` 设置为 `devel` （LCTT注：这是 `snapcraft.yaml` 中的一个键及其可选值），商店将会永远禁止你将 snap 包释放到稳定和候选通道。
在这个过程中，我们有时可能想要发布一个修订版本到测试通道，以便让有些用户更愿意去跟踪它（一个好的发布管理流程应该比一个随机的日常构建更有用）。这个阶段结束后，如果希望人们仍然能保持更新，我们可以选择关闭测试通道，从一个特定的时间点开始我们只计划发布到候选和稳定通道，通过关闭测试通道我们将使该通道跟随稳定列表中的下一个开放通道，在这里是候选通道。而如果候选通道跟随的是稳定通道后，那么最终得到是稳定通道了。
### 进入 Snapcraft
那么所有这些给定的概念是如何在 snapcraft 中配合使用的？首先我们需要登录:
```
$ snapcraft login
Enter your Ubuntu One SSO credentials.
Email: sxxxxx.sxxxxxx@canonical.com
Password: **************
Second-factor auth: 123456
```
在登录之后，我们就可以开始注册 snap 了。例如，我们想要注册一个虚构的 snap 包 awesome-database：
```
$ snapcraft register awesome-database
We always want to ensure that users get the software they expect
for a particular name.
If needed, we will rename snaps to ensure that a particular name
reflects the software most widely expected by our community.
For example, most people would expect ‘thunderbird’ to be published by
Mozilla. They would also expect to be able to get other snaps of
Thunderbird as 'thunderbird-sergiusens'.
Would you say that MOST users will expect 'a' to come from
you, and be the software you intend to publish there? [y/N]: y
You are now the publisher for 'awesome-database'
```
假设我们已经构建了 snap 包，接下来我们要做的就是把它上传到商店。我们可以在同一个命令中使用快捷方式和 `--release` 选项：
```
$ snapcraft push awesome-databse_0.1_amd64.snap --release edge
Uploading awesome-database_0.1_amd64.snap [=================] 100%
Processing....
Revision 1 of 'awesome-database' created.
Channel Version Revision
stable - -
candidate - -
beta - -
edge 0.1 1
The edge channel is now open.
```
如果我们试图将其发布到稳定通道，商店将会阻止我们：
```
$ snapcraft release awesome-database 1 stable
Revision 1 (devmode) cannot target a stable channel (stable, grade: devel)
```
这样我们不会搞砸，也不会让我们的忠实用户使用它。现在，我们将最终推出一个值得发布到稳定通道的修订版本：
```
$ snapcraft push awesome-databse_0.1_amd64.snap
Uploading awesome-database_0.1_amd64.snap [=================] 100%
Processing....
Revision 10 of 'awesome-database' created.
```
注意，<ruby> 版本号 <rt> version </rt></ruby>（LCTT 译注：这里指的是 snap 包名中 `0.1` 这个版本号）只是一个友好的标识符，真正重要的是商店为我们生成的<ruby> 修订版本号 <rt> Revision </rt></ruby>（LCTT 译注：这里生成的修订版本号为 `10`）。现在让我们把它释放到稳定通道：
```
$ snapcraft release awesome-database 10 stable
Channel Version Revision
stable 0.1 10
candidate ^ ^
beta ^ ^
edge 0.1 10
The 'stable' channel is now open.
```
在这个针对我们正在使用架构最终的通道映射视图中，可以看到边缘通道将会被固定在修订版本 10 上，并且测试和候选通道将会跟随现在修订版本为 10 的稳定通道。由于某些原因，我们决定将专注于稳定性并让我们的 CI/CD 推送到测试通道。这意味着我们的边缘通道将会略微过时，为了避免这种情况，我们可以关闭这个通道：
```
$ snapcraft close awesome-database edge
Arch Channel Version Revision
amd64 stable 0.1 10
candidate ^ ^
beta ^ ^
edge ^ ^
The edge channel is now closed.
```
在当前状态下，所有通道都跟随着稳定通道，因此订阅了候选、测试和边缘通道的人也将跟踪稳定通道的改动。比如就算修订版本 11 只发布到稳定通道，其他通道的人们也能看到它。
这个清单还提供了完整的体系结构视图，在本例中，我们只使用了 amd64。
### 获得更多的信息
有时过了一段时间，我们想知道商店中的某个 snap 包的历史记录和现在的状态是什么样的，这里有两个命令，一个是直截了当输出当前的状态，它会给我们一个熟悉的结果:
```
$ snapcraft status awesome-database
Arch Channel Version Revision
amd64 stable 0.1 10
candidate ^ ^
beta ^ ^
edge ^ ^
```
我们也可以通过下面的命令获得完整的历史记录：
```
$ snapcraft history awesome-database
Rev. Uploaded Arch Version Channels
3 2016-09-30T12:46:21Z amd64 0.1 stable*
...
...
...
2 2016-09-30T12:38:20Z amd64 0.1 -
1 2016-09-30T12:33:55Z amd64 0.1 -
```
### 结束语
希望这篇文章能让你对 Snap 商店能做的事情有一个大概的了解，并让更多的人开始使用它！
---
via: <https://insights.ubuntu.com/2016/11/15/making-your-snaps-available-to-the-store-using-snapcraft/>
*译者简介：*
>
> snapcraft.io 的钉子户，对 Ubuntu Core、Snaps 和 Snapcraft 有着浓厚的兴趣，并致力于将这些还在快速发展的新技术通过翻译或原创的方式介绍到中文世界。有兴趣的小伙伴也可以关注译者个人的公众号： `Snapcraft`，近期会在上面连载几篇有关 Core snap 发布策略、交付流程和验证流程的文章，欢迎围观 :）
>
>
>
作者：[Sergio Schvezov](https://insights.ubuntu.com/author/sergio-schvezov/) 译者：[Snapcrafter](https://github.com/Snapcrafter) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 容器演化史
|
Daniel J Walsh
|
https://opensource.com/article/17/7/how-linux-containers-evolved
|
我希望这份深入的介绍能够帮助你理解 Linux 容器的演化过程。Linux 容器曾经陷入一种各自为营的困境，Docker 建立起了镜像创建的事实标准，简化了容器的使用工具。OCI 则意味着业界在核心镜像格式与运行时方面的合作。
|
/data/attachment/album/201708/26/161009ab5ggfgbg0hb10f5.jpg.thumb.jpg
|
/data/attachment/album/201708/26/161009ab5ggfgbg0hb10f5.jpg
| true | false | true |
haoqixu
| true |
[
"容器",
"OCI",
"Docker"
] |
观点
|
{
"viewnum": 7407,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我希望这份深入的介绍能够帮助你理解 Linux 容器的演化过程。Linux 容器曾经陷入一种各自为营的困境，Docker 建立起了镜像创建的事实标准，简化了容器的使用工具。OCI 则意味着业界在核心镜像格式与运行时方面的合作。
| 2017-08-26T16:10:00 | 2017-08-26T16:10:00 | 8,811 |
/article-8811-1.html
|
>
> 容器在过去几年内取得很大的进展。现在我们来回顾它发展的时间线。
>
>
>
### Linux 容器是如何演变的
在过去几年内，容器不仅成为了开发者们热议的话题，还受到了企业的关注。持续增长的关注使得在它的安全性、可扩展性以及互用性等方面的需求也得以增长。满足这些需求需要很大的工程量，下面我们讲讲在红帽这样的企业级这些工程是如何发展的。
我在 2013 年秋季第一次遇到 Docker 公司（Docker.io）的代表，那时我们在设法使 Red Hat Enterprise Linux (RHEL) 支持 Docker 容器（现在 Docker 项目的一部分已经更名为 *Moby*）的运行。在移植过程中，我们遇到了一些问题。处理容器镜像分层所需的写时拷贝（COW）文件系统成了我们第一个重大阻碍。Red Hat 最终贡献了一些 COW 文件系统实现，包括 [Device Mapper](https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/html/Logical_Volume_Manager_Administration/device_mapper.html)、[btrf](https://btrfs.wiki.kernel.org/index.php/Main_Page)，以及 [OverlayFS](https://www.kernel.org/doc/Documentation/filesystems/overlayfs.txt) 的第一个版本。在 RHEL 上，我们默认使用 Device Mapper， 但是我们在 OverlayFS 上也已经取得了很大进展。
我们在用于启动容器的工具上遇到了第二个主要障碍。那时的上游 docker 使用 [LXC](https://linuxcontainers.org/) 工具来启动容器，然而我们不想在 RHEL 上支持 LXC 工具集。而且在与上游 docker 合作之前，我们已经与 [libvrit](https://libvirt.org/) 团队携手构建了 [virt-sandbox](http://sandbox.libvirt.org/) 工具，它使用 `libvrit-lxc` 来启动容器。
在那时，红帽里有员工提到一个好办法，换掉 LXC 工具集而添加桥接器，以便 docker 守护进程通过 `libvirt-lxc` 与 libvirt 通讯来启动容器。这个方案也有一些顾虑。考虑下面这个例子，使用 Docker 客户端（`docker-cli`）来启动容器，各层调用会在容器进程（`pid1OfContainer`）之前依次启动：
>
> **docker-cli → docker-daemon → libvirt-lxc → pid1OfContainer**
>
>
>
我不是很喜欢这个方案，因为它在启动容器的工具与最终的容器进程之间有两个守护进程。
我的团队与上游 docker 开发者合作实现了一个原生的 [Go 编程语言](https://opensource.com/article/17/6/getting-started-go) 版本的容器运行时，叫作 [libcontainer](https://github.com/opencontainers/runc/tree/master/libcontainer)。这个库作为 [OCI 运行时规范]的最初版实现与 runc 一同发布。
>
> **docker-cli → docker-daemon @ pid1OfContainer**
>
>
>
大多数人误认为当他们执行一个容器时，容器进程是作为 `docker-cli` 的子进程运行的。实际上他们执行的是一个客户端/服务端请求操作，容器进程是在一个完全单独的环境作为子进程运行的。这个客户端/服务端请求会导致不稳定性和潜在的安全问题，而且会阻碍一些实用特性的实现。举个例子，[systemd](https://opensource.com/business/15/10/lisa15-interview-alison-chaiken-mentor-graphics) 有个叫做套接字唤醒的特性，你可以将一个守护进程设置成仅当相应的套结字被连接时才启动。这意味着你的系统可以节约内存并按需执行服务。套结字唤醒的工作原理是 systemd 代为监听 TCP 套结字，并在数据包到达套结字时启动相应的服务。一旦服务启动完毕，systemd 将套结字交给新启动的守护进程。如果将守护进程运行在基于 docker 的容器中就会出现问题。systemd 的 unit 文件通过 Docker CLI 执行容器，然而这时 systemd 却无法简单地经由 Docker CLI 将套结字转交给 Docker 守护进程。
类似这样的问题让我们意识到我们需要一个运行容器的替代方案。
#### 容器编排问题
上游的 docker 项目简化了容器的使用过程，同时也是一个绝佳的 Linux 容器学习工具。你可以通过一条简单的命令快速地体验如何启动一个容器，例如运行 `docker run -ti fedora sh` 然后你就立即处于一个容器之中。
当开始把许多容器组织成一个功能更为强大的应用时，你才能体会到容器真正的能力。但是问题在于伴随多容器应用而来的高复杂度使得简单的 Docker 命令无法胜任编排工作。你要如何管理容器应用在有限资源的集群节点间的布局与编排？如何管理它们的生命周期等等？
在第一届 DockerCon，至少有 7 种不同的公司/开源项目展示了其容器的编排方案。红帽演示了 [OpenShift](https://www.openshift.com/) 的 [geard](https://openshift.github.io/geard/) 项目，它基于 OpenShift v2 的容器（叫作 gears）。红帽觉得我们需要重新审视容器编排，而且可能要与开源社区的其他人合作。
Google 则演示了 Kubernetes 容器编排工具，它来源于 Google 对其自内部架构进行编排时所积累的知识经验。OpenShift 决定放弃 Gear 项目，开始和 Google 一同开发 Kubernetes。 现在 Kubernetes 是 GitHub 上最大的社区项目之一。
#### Kubernetes
Kubernetes 原先被设计成使用 Google 的 [lmctfy](https://github.com/google/lmctfy) 容器运行时环境来完成工作。在 2014 年夏天，lmctfy 兼容了 docker。Kubernetes 还会在 kubernetes 集群的每个节点运行一个 [kubelet](https://kubernetes.io/docs/admin/kubelet/) 守护进程，这意味着原先使用 docker 1.8 的 kubernetes 工作流看起来是这样的：
>
> **kubelet → dockerdaemon @ PID1**
>
>
>
回退到了双守护进程的模式。
然而更糟糕的是，每次 docker 的新版本发布都使得 kubernetes 无法工作。Docker 1.10 切换镜像底层存储方案导致所有镜像重建。而 Docker 1.11 开始使用 `runc` 来启动镜像：
>
> **kubelet → dockerdaemon @ runc @PID1**
>
>
>
Docker 1.12 则增加了一个容器守护进程用于启动容器。其主要目的是为了支持 Docker Swarm （Kubernetes 的竞争者之一）：
>
> **kubelet → dockerdaemon → containerd @runc @ pid1**
>
>
>
如上所述，*每一次* docker 发布都破坏了 Kubernetes 的功能，这也是为什么 Kubernetes 和 OpenShift 请求我们为他们提供老版本 Docker 的原因。
现在我们有了一个三守护进程的系统，只要任何一个出现问题，整个系统都将崩溃。
### 走向容器标准化
#### CoreOS、rkt 和其它替代运行时
因为 docker 运行时带来的问题，几个组织都在寻求一个替代的运行时。CoreOS 就是其中之一。他们提供了一个 docker 容器运行时的替代品，叫 *rkt* （rocket）。他们同时还引入一个标准容器规范，称作 *appc* （App Container）。从根本上讲，他们是希望能使得所有人都使用一个标准规范来管理容器镜像中的应用。
这一行为为标准化工作树立了一面旗帜。当我第一次开始和上游 docker 合作时，我最大的担忧就是最终我们会分裂出多个标准。我不希望类似 RPM 和 DEB 之间的战争影响接下来 20 年的 Linux 软件部署。appc 的一个成果是它说服了上游 docker 与开源社区合作创建了一个称作<ruby> <a href="https://www.opencontainers.org/"> 开放容器计划 </a> <rp> （ </rp> <rt> Open Container Initiative </rt> <rp> ） </rp></ruby>(OCI) 的标准团体。
OCI 已经着手制定两个规范：
[OCI 运行时规范](https://github.com/opencontainers/runtime-spec/blob/master/spec.md)：OCI 运行时规范“旨在规范容器的配置、执行环境以及生命周期”。它定义了容器的磁盘存储，描述容器内运行的应用的 JSON 文件，容器的生成和执行方式。上游 docker 贡献了 libcontainer 并构建了 runc 作为 OCI 运行时规范的默认实现。
[OCI 镜像文件格式规范](https://github.com/opencontainers/image-spec/blob/master/spec.md)：镜像文件格式规范主要基于上游 docker 所使用的镜像格式，定义了容器仓库中实际存储的容器镜像格式。该规范使得应用开发者能为应用使用单一的标准化格式。一些 appc 中描述的概念被加入到 OCI 镜像格式规范中得以保留。这两份规范 1.0 版本的发布已经临近（LCTT 译注：[已经发布](/article-8778-1.html)）。上游 docker 已经同意在 OCI 镜像规范定案后支持该规范。Rkt 现在既支持运行 OCI 镜像也支持传统的上游 docker 镜像。
OCI 通过为工业界提供容器镜像与运行时标准化的环境，帮助在工具与编排领域解放创新的力量。
#### 抽象运行时接口
得益于标准化工作， Kubernetes 编排领域也有所创新。作为 Kubernetes 的一大支持者，CoreOS 提交了一堆补丁，使 Kubernetes 除了 docker 引擎外还能通过 rkt 运行容器并且与容器通讯。Google 和 Kubernetes 上游预见到增加这些补丁和将来可能添加的容器运行时接口将给 Kubernetes 带来的代码复杂度，他们决定实现一个叫作<ruby> 容器运行时接口 <rp> （ </rp> <rt> Container Runtime Interface </rt> <rp> ） </rp></ruby>(CRI) 的 API 协议规范。于是他们将 Kubernetes 由原来的直接调用 docker 引擎改为调用 CRI，这样任何人都可以通过实现服务器端的 CRI 来创建支持 Kubernetes 的容器运行时。Kubernetes 上游还为 CRI 开发者们创建了一个大型测试集以验证他们的运行时对 Kubernetes 的支持情况。开发者们还在努力地移除 Kubernetes 对 docker 引擎的调用并将它们隐藏在一个叫作 docker-shim 的薄抽象层后。
### 容器工具的创新
#### 伴随 skopeo 而来的容器仓库创新
几年前我们正与 Atomic 项目团队合作构建 [atomic CLI](https://github.com/projectatomic/atomic)。我们希望实现一个功能，在镜像还在镜像仓库时查看它的细节。在那时，查看仓库中的容器镜像相关 JSON 文件的唯一方法是将镜像拉取到本地服务器再通过 `docker inspect` 来查看 JSON 文件。这些镜像可能会很大，上至几个 GiB。为了允许用户在不拉取镜像的情况下查看镜像细节，我们希望在 `docker inspect` 接口添加新的 `--remote` 参数。上游 docker 拒绝了我们的代码拉取请求（PR），告知我们他们不希望将 Docker CLI 复杂化，我们可以构建我们自己的工具去实现相同的功能。
我们的团队在 [Antonio Murdaca](https://twitter.com/runc0m) 的领导下执行这个提议，构建了 [skopeo](https://github.com/projectatomic/skopeo)。Antonio 没有止步于拉取镜像相关的 JSON 文件，而是决定实现一个完整的协议，用于在容器仓库与本地主机之间拉取与推送容器镜像。
skopeo 现在被 atomic CLI 大量用于类似检查容器更新的功能以及 [atomic 扫描](https://developers.redhat.com/blog/2016/05/02/introducing-atomic-scan-container-vulnerability-detection/) 当中。Atomic 也使用 skopeo 取代上游 docker 守护进程拉取和推送镜像的功能。
#### Containers/image
我们也曾和 CoreOS 讨论过在 rkt 中使用 skopeo 的可能，然而他们表示不希望运行一个外部的协助程序，但是会考虑使用 skopeo 所使用的代码库。于是我们决定将 skopeo 分离为一个代码库和一个可执行程序，创建了 [image](https://github.com/containers/image) 代码库。
[containers/images](https://github.com/containers/image) 代码库和 skopeo 被几个其它上游项目和云基础设施工具所使用。Skopeo 和 containers/image 已经支持 docker 和多个存储后端，而且能够在容器仓库之间移动容器镜像，还拥有许多酷炫的特性。[skopeo 的一个优点](http://rhelblog.redhat.com/2017/05/11/skopeo-copy-to-the-rescue/)是它不需要任何守护进程的协助来完成任务。Containers/image 代码库的诞生使得类似[容器镜像签名](https://access.redhat.com/articles/2750891)等增强功能得以实现。
#### 镜像处理与扫描的创新
我在前文提到 atomic CLI。我们构建这个工具是为了给容器添加不适合 docker CLI 或者我们无法在上游 docker 中实现的特性。我们也希望获得足够灵活性，将其用于开发额外的容器运行时、工具和存储系统。Skopeo 就是一例。
我们想要在 atomic 实现的一个功能是 `atomic mount`。从根本上讲，我们希望从 Docker 镜像存储（上游 docker 称之为 graph driver）中获取内容，把镜像挂在到某处，以便用工具来查看该镜像。如果你使用上游的 docker，查看镜像内容的唯一方法就是启动该容器。如果其中有不可信的内容，执行容器中的代码来查看它会有潜在危险。通过启动容器查看镜像内容的另一个问题是所需的工具可能没有被包含在容器镜像当中。
大多数容器镜像扫描器遵循以下流程：它们连接到 Docker 的套结字，执行一个 `docker save` 来创建一个 tar 打包文件，然后在磁盘上分解这个打包文件，最后查看其中的内容。这是一个很慢的过程。
通过 `atomic mount`，我们希望直接使用 Docker graph driver 挂载镜像。如果 docker 守护进程使用 device mapper，我们将挂载这个设备。如果它使用 overlay，我们会挂载 overlay。这个操作很快而且满足我们的需求。现在你可以执行：
```
# atomic mount fedora /mnt
# cd /mnt
```
然后开始探查内容。你完成相应工作后，执行：
```
# atomic umount /mnt
```
我们在 `atomic scan` 中使用了这一特性，实现了一个快速的容器扫描器。
#### 工具协作的问题
其中一个严重的问题是 `atomic mount` 隐式地执行这些工作。Docker 守护进程不知道有另一个进程在使用这个镜像。这会导致一些问题（例如，如果你先挂载了 Fedora 镜像，然后某个人执行了 `docker rmi fedora` 命令，docker 守护进程移除镜像时就会产生奇怪的操作失败，同时报告说相应的资源忙碌）。Docker 守护进程可能因此进入一个奇怪的状态。
#### 容器存储系统
为了解决这个问题，我们开始尝试将从上游 docker 守护进程剥离出来的 graph driver 代码拉取到我们的代码库中。Docker 守护进程在内存中为 graph driver 完成所有锁的获取。我们想要将这些锁操作转移到文件系统中，这样我们可以支持多个不同的进程来同时操作容器的存储系统，而不用通过单一的守护进程。
我们创建了 [containers/storage](https://github.com/containers/storage) 项目，实现了容器运行、构建、存储所需的所有写时拷贝（COW）特性，同时不再需要一个单一进程来控制和监控这个过程（也就是不需要守护进程）。现在 skopeo 以及其它工具和项目可以直接利用镜像的存储系统。其它开源项目也开始使用 containers/storage，在某些时候，我们也会把这些项目合并回上游 docker 项目。
### 驶向创新
当 Kubernetes 在一个节点上使用 docker 守护进程运行容器时会发生什么？首先，Kubernetes 执行一条类似如下的命令：
```
kubelet run nginx -image=nginx
```
这个命令告诉 kubelet 在节点上运行 NGINX 应用程序。kubelet 调用 CRI 请求启动 NGINX 应用程序。在这时，实现了 CRI 规范的容器运行时必须执行以下步骤：
1. 检查本地是否存在名为 `nginx` 的容器。如果没有，容器运行时会在容器仓库中搜索标准的容器镜像。
2. 如果镜像不存在于本地，从容器仓库下载到本地系统。
3. 使用容器存储系统（通常是写时拷贝存储系统）解析下载的容器镜像并挂载它。
4. 使用标准的容器运行时执行容器。
让我们看看上述过程使用到的特性：
1. OCI 镜像格式规范定义了容器仓库存储的标准镜像格式。
2. Containers/image 代码库实现了从容器仓库拉取镜像到容器主机所需的所有特性。
3. Containers/storage 提供了在写时拷贝的存储系统上探查并处理 OCI 镜像格式的代码库。
4. OCI 运行时规范以及 `runc` 提供了执行容器的工具（同时也是 docker 守护进程用来运行容器的工具）。
这意味着我们可以利用这些工具来使用容器，而无需一个大型的容器守护进程。
在中等到大规模的基于 DevOps 的持续集成/持续交付环境下，效率、速度和安全性至关重要。只要你的工具遵循 OCI 规范，开发者和执行者就能在持续集成、持续交付到生产环境的自动化中自然地使用最佳的工具。大多数的容器工具被隐藏在容器编排或上层容器平台技术之下。我们预想着有朝一日，运行时和镜像工具的选择会变成容器平台的一个安装选项。
#### 系统（独立）容器
在 Atomic 项目中我们引入了<ruby> 原子主机 <rt> atomic host </rt></ruby>，一种新的操作系统构建方式：所有的软件可以被“原子地”升级并且大多数应用以容器的形式运行在操作系统中。这个平台的目的是证明将来所有的软件都能部署在 OCI 镜像格式中并且使用标准协议从容器仓库中拉取，然后安装到系统上。用容器镜像的形式发布软件允许你以不同的速度升级应用程序和操作系统。传统的 RPM/yum/DNF 包分发方式把应用更新锁定在操作系统的生命周期中。
在以容器部署基础设施时多数会遇到一个问题——有时一些应用必须在容器运行时执行之前启动。我们看一个使用 docker 的 Kubernetes 的例子：Kubernetes 为了将 pods 或者容器部署在独立的网络中，要求先建立一个网络。现在默认用于创建网络的守护进程是 [flanneld](https://github.com/coreos/flannel)，而它必须在 docker 守护进程之前启动，以支持 docker 网络接口来运行 Kubernetes 的 pods。而且，flanneld 使用 [etcd](https://github.com/coreos/etcd) 来存储数据，这个守护进程必须在 flanneld 启动之前运行。
如果你想把 etcd 和 flanneld 部署到容器镜像中，那就陷入了鸡与鸡蛋的困境中。我们需要容器运行时来启动容器化的应用，但这些应用又需要在容器运行时之前启动。我见过几个取巧的方法尝试解决这个问题，但这些方法都不太干净利落。而且 docker 守护进程当前没有合适的方法来配置容器启动的优先级顺序。我见过一些提议，但它们看起来和 SysVInit 所使用的启动服务的方式相似（我们知道它带来的复杂度）。
#### systemd
用 systemd 替代 SysVInit 的原因之一就是为了处理服务启动的优先级和顺序，我们为什么不充分利用这种技术呢？在 Atomic 项目中我们决定在让它在没有容器运行时的情况下也能启动容器，尤其是在系统启动早期。我们增强了 atomic CLI 的功能，让用户可以安装容器镜像。当你执行 `atomic install --system etc`，它将利用 skopeo 从外部的容器仓库拉取 etcd 的 OCI 镜像，然后把它分解（扩展）为 OSTree 底层存储。因为 etcd 运行在生产环境中，我们把镜像处理为只读。接着 `atomic` 命令抓取容器镜像中的 systemd 的 unit 文件模板，用它在磁盘上创建 unit 文件来启动镜像。这个 unit 文件实际上使用 `runc` 来在主机上启动容器（虽然 `runc` 不是必需的）。
执行 `atomic install --system flanneld` 时会进行相似的过程，但是这时 flanneld 的 unit 文件中会指明它依赖 etcd。
在系统引导时，systemd 会保证 etcd 先于 flanneld 运行，并且直到 flanneld 启动完毕后再启动容器运行时。这样我们就能把 docker 守护进程和 Kubernetes 部署到系统容器当中。这也意味着你可以启动一台原子主机或者使用传统的基于 rpm 的操作系统，让整个容器编排工具栈运行在容器中。这是一个强大的特性，因为用户往往希望改动容器主机时不受这些组件影响。而且，它保持了主机的操作系统的占用最小化。
大家甚至讨论把传统的应用程序部署到独立/系统容器或者被编排的容器中。设想一下，可以用 `atomic install --system httpd` 命令安装一个 Apache 容器，这个容器可以和用 RPM 安装的 httpd 服务以相同的方式启动（`systemctl start httpd` ，区别是这个容器 httpd 运行在一个容器中）。存储系统可以是本地的，换言之，`/var/www` 是从宿主机挂载到容器当中的，而容器监听着本地网络的 80 端口。这表明了我们可以在不使用容器守护进程的情况下将传统的负载组件部署到一个容器中。
### 构建容器镜像
在我看来，在过去 4 年来容器发展方面最让人失落的是缺少容器镜像构建机制上的创新。容器镜像不过是将一些 tar 包文件与 JSON 文件一起打包形成的文件。基础镜像则是一个 rootfs 与一个描述该基础镜像的 JSON 文件。然后当你增加镜像层时，层与层之间的差异会被打包，同时 JSON 文件会做出相应修改。这些镜像层与基础文件一起被打包，共同构成一个容器镜像。
现在几乎所有人都使用 `docker build` 与 Dockerfile 格式来构建镜像。上游 docker 已经在几年前停止了接受修改或改进 Dockerfile 格式的拉取请求（PR）了。Dockerfile 在容器的演进过程中扮演了重要角色，开发者和管理员/运维人员可以通过简单直接的方式来构建镜像；然而我觉得 Dockerfile 就像一个简陋的 bash 脚本，还带来了一些尚未解决的问题，例如：
* 使用 Dockerfile 创建容器镜像要求运行着 Docker 守护进程。
+ 没有可以独立于 docker 命令的标准工具用于创建 OCI 镜像。
+ 甚至类似 `ansible-containers` 和 OpenShift S2I (Source2Image) 的工具也在底层使用 `docker-engine`。
* Dockerfile 中的每一行都会创建一个新的镜像，这有助于创建容器的开发过程，这是因为构建工具能够识别 Dockerfile 中的未改动行，复用已经存在的镜像从而避免了未改动行的重复执行。但这个特性会产生*大量*的镜像层。
+ 因此，不少人希望构建机制能压制镜像消除这些镜像层。我猜想上游 docker 最后应该接受了一些提交满足了这个需求。
* 要从受保护的站点拉取内容到容器镜像，你往往需要某种密钥。比如你为了添加 RHEL 的内容到镜像中，就需要访问 RHEL 的证书和订阅。
+ 这些密钥最终会被以层的方式保存在镜像中。开发者要费很大工夫去移除它们。
+ 为了允许在 docker 构建过程中挂载数据卷，我们在我们维护的 projectatomic/docker 中加入了 `-v volume` 选项，但是这些修改没有被上游 docker 接受。
* 构建过程的中间产物最终会保留在容器镜像中，所以尽管 Dockerfile 易于学习，当你想要了解你要构建的镜像时甚至可以在笔记本上构建容器，但它在大规模企业环境下还不够高效。然而在自动化容器平台下，你应该不会关心用于构建 OCI 镜像的方式是否高效。
### Buildah 起航
在 DevConf.cz 2017，我让我们团队的 [Nalin Dahyabhai](https://twitter.com/nalind) 考虑构建被我称为 `containers-coreutils` 的工具，它基本上就是基于 containers/storage 和 containers/image 库构建的一系列可以使用类似 Dockerfile 语法的命令行工具。Nalin 为了取笑我的波士顿口音，决定把它叫做 [buildah](https://github.com/projectatomic/buildah)。我们只需要少量的 buildah 原语就可以构建一个容器镜像：
* 最小化 OS 镜像、消除不必要的工具是主要的安全原则之一。因为黑客在攻击应用时需要一些工具，如果类似 `gcc`，`make`，`dnf` 这样的工具根本不存在，就能阻碍攻击者的行动。
* 减小容器的体积总是有益的，因为这些镜像会通过互联网拉取与推送。
* 使用 Docker 进行构建的基本原理是在容器构建的根目录下利用命令安装或编译软件。
* 执行 `run` 命令要求所有的可执行文件都包含在容器镜像内。只是在容器镜像中使用 `dnf` 就需要完整的 Python 栈，即使在应用中从未使用到 Python。
* `ctr=$(buildah from fedora)`:
+ 使用 containers/image 从容器仓库拉取 Fedora 镜像。
+ 返回一个容器 ID （`ctr`）。
* `mnt=$(buildah mount $ctr)`:
+ 挂载新建的容器镜像（`$ctr`）.
+ 返回挂载点路径。
+ 现在你可以使用挂载点来写入内容。
* `dnf install httpd –installroot=$mnt`:
+ 你可以使用主机上的命令把内容重定向到容器中，这样你可以把密钥保留在主机而不导入到容器内，同时构建所用的工具也仅仅存在于主机上。
+ 容器内不需要包含 `dnf` 或者 Python 栈，除非你的应用用到它们。
* `cp foobar $mnt/dir`:
+ 你可以使用任何 bash 中可用的命令来构造镜像。
* `buildah commit $ctr`:
+ 你可以随时创建一个镜像层，镜像的分层由用户而不是工具来决定。
* `buildah config --env container=oci --entrypoint /usr/bin/httpd $ctr`:
+ Buildah 支持所有 Dockerfile 的命令。
* `buildah run $ctr dnf -y install httpd`:
+ Buildah 支持 `run` 命令，但它是在一个锁定的容器内利用 `runc` 执行命令，而不依赖容器运行时守护进程。
* `buildah build-using-dockerfile -f Dockerfile .`：
+ 我们希望将移植类似 `ansible-containers` 和 OpenShift S2I 这样的工具，改用 `buildah` 以去除对容器运行时守护进程的依赖。
+ 使用与生产环境相同的容器运行时构建容器镜像会遇到另一个大问题。为了保证安全性，我们需要把权限限制到支持容器构建与运行所需的最小权限。构建容器比起运行容器往往需要更多额外的权限。举个例子，我们默认允许 `mknod` 权限，这会允许进程创建设备节点。有些包的安装会尝试创建设备节点，然而在生产环境中的应用几乎都不会这么做。如果默认移除生产环境中容器的 `mknod` 特权会让系统更为安全。
+ 另一个例子是，容器镜像默认是可读写的，因为安装过程意味着向 `/usr` 存入软件包。然而在生产环境中，我强烈建议把所有容器设为只读模式，仅仅允许它们写入 tmpfs 或者是挂载了数据卷的目录。通过分离容器的构建与运行环境，我们可以更改这些默认设置，提供一个更为安全的环境。
+ 当然，buildah 可以使用 Dockerfile 构建容器镜像。
### CRI-O ：一个 Kubernetes 的运行时抽象
Kubernetes 添加了<ruby> 容器运行时接口 <rt> Container Runtime Interface </rt></ruby>（CRI）接口，使 pod 可以在任何运行时上工作。虽然我不是很喜欢在我的系统上运行太多的守护进程，然而我们还是加了一个。我的团队在 [Mrunal Patel](https://twitter.com/mrunalp) 的领导下于 2016 年后期开始构建 [CRI-O] 守护进程。这是一个用来运行 OCI 应用程序的 OCI 守护进程。理论上，将来我们能够把 CRI-O 的代码直接并入 kubelet 中从而消除这个多余的守护进程。
不像其它容器运行时，CRI-O 的唯一目的就只是为了满足 Kubernetes 的需求。记得前文描述的 Kubernetes 运行容器的条件。
Kubernetes 传递消息给 kubelet 告知其运行 NGINX 服务器：
1. kubelet 唤醒 CRI-O 并告知它运行 NGINX。
2. CRI-O 回应 CRI 请求。
3. CRI-O 在容器仓库查找 OCI 镜像。
4. CRI-O 使用 containers/image 从仓库拉取镜像到主机。
5. CRI-O 使用 containers/storage 解压镜像到本地磁盘。
6. CRI-O 按照 OCI 运行时规范（通常使用 `runc`）启动容器。如前文所述，Docker 守护进程也同样使用 `runc` 启动它的容器。
7. 按照需要，kubelet 也可以使用替代的运行时启动容器，例如 Clear Containers `runcv`。
CRI-O 旨在成为稳定的 Kubernetes 运行平台。只有通过完整的 Kubernetes 测试集后，新版本的 CRI-O 才会被推出。所有提交到 <https://github.com/Kubernetes-incubator/cri-o> 的拉取请求都会运行完整的 Kubernetes 测试集。没有通过测试集的拉取请求都不会被接受。CRI-O 是完全开放的，我们已经收到了来自 Intel、SUSE、IBM、Google、Hyper.sh 等公司的代码贡献。即使不是红帽想要的特性，只要通过一定数量维护者的同意，提交给 CRI-O 的补丁就会被接受。
### 小结
我希望这份深入的介绍能够帮助你理解 Linux 容器的演化过程。Linux 容器曾经陷入一种各自为营的困境，Docker 建立起了镜像创建的事实标准，简化了容器的使用工具。OCI 则意味着业界在核心镜像格式与运行时方面的合作，这促进了工具在自动化效率、安全性、高可扩展性、易用性方面的创新。容器使我们能够以一种新奇的方式部署软件——无论是运行于主机上的传统应用还是部署在云端的微服务。而在许多方面，这一切还仅仅是个开始。
---
作者简介：
Daniel J Walsh - Daniel 有将近 30 年的计算机安全领域工作经验。他在 2001 年 8 月加入 Red Hat。
via: <https://opensource.com/article/17/7/how-linux-containers-evolved>
作者：[Daniel J Walsh](https://opensource.com/users/rhatdan) 译者：[haoqixu](https://github.com/haoqixu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开发一个 Linux 调试器（五）：源码和信号
|
Simon Brand
|
https://blog.tartanllama.xyz/c++/2017/04/24/writing-a-linux-debugger-source-signal/
|
在这一部分，我们将进入实践，实现一些我们调试器后面会使用的 DWARF 原语。我们也会利用这个机会，使我们的调试器可以在命中一个断点时打印出当前的源码上下文。
|
/data/attachment/album/201708/26/175338u3rarihzal14s8sg.jpg.thumb.jpg
|
/data/attachment/album/201708/26/175338u3rarihzal14s8sg.jpg
| true | false | true |
ictlyh
| false |
[
"调试器"
] |
软件开发
|
{
"viewnum": 5953,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8719,
"displayorder": 0
},
{
"raid": 8813,
"displayorder": 0
}
] |
在这一部分，我们将进入实践，实现一些我们调试器后面会使用的 DWARF 原语。我们也会利用这个机会，使我们的调试器可以在命中一个断点时打印出当前的源码上下文。
| 2017-08-26T17:55:00 | 2017-08-26T17:55:00 | 8,812 |
/article-8812-1.html
|
在上一部分我们学习了关于 DWARF 的信息，以及它如何被用于读取变量和将被执行的机器码与我们的高级语言的源码联系起来。在这一部分，我们将进入实践，实现一些我们调试器后面会使用的 DWARF 原语。我们也会利用这个机会，使我们的调试器可以在命中一个断点时打印出当前的源码上下文。
### 系列文章索引
随着后面文章的发布，这些链接会逐渐生效。
1. [准备环境](/article-8626-1.html)
2. [断点](/article-8645-1.html)
3. [寄存器和内存](/article-8663-1.html)
4. [Elves 和 dwarves](/article-8719-1.html)
5. [源码和信号](https://blog.tartanllama.xyz/c++/2017/04/24/writing-a-linux-debugger-source-signal/)
6. [源码级逐步执行](https://blog.tartanllama.xyz/c++/2017/05/06/writing-a-linux-debugger-dwarf-step/)
7. 源码级断点
8. 调用栈展开
9. 读取变量
10. 下一步
### 设置我们的 DWARF 解析器
正如我在这系列文章开始时备注的，我们会使用 [libelfin](https://github.com/TartanLlama/libelfin/tree/fbreg) 来处理我们的 DWARF 信息。希望你已经在[第一部分](/article-8626-1.html)设置好了这些，如果没有的话，现在做吧，确保你使用我仓库的 `fbreg` 分支。
一旦你构建好了 `libelfin`，就可以把它添加到我们的调试器。第一步是解析我们的 ELF 可执行程序并从中提取 DWARF 信息。使用 `libelfin` 可以轻易实现，只需要对`调试器`作以下更改：
```
class debugger {
public:
debugger (std::string prog_name, pid_t pid)
: m_prog_name{std::move(prog_name)}, m_pid{pid} {
auto fd = open(m_prog_name.c_str(), O_RDONLY);
m_elf = elf::elf{elf::create_mmap_loader(fd)};
m_dwarf = dwarf::dwarf{dwarf::elf::create_loader(m_elf)};
}
//...
private:
//...
dwarf::dwarf m_dwarf;
elf::elf m_elf;
};
```
我们使用了 `open` 而不是 `std::ifstream`，因为 elf 加载器需要传递一个 UNIX 文件描述符给 `mmap`，从而可以将文件映射到内存而不是每次读取一部分。
### 调试信息原语
下一步我们可以实现从程序计数器的值中提取行条目（line entry）以及函数 DWARF 信息条目（function DIE）的函数。我们从 `get_function_from_pc` 开始：
```
dwarf::die debugger::get_function_from_pc(uint64_t pc) {
for (auto &cu : m_dwarf.compilation_units()) {
if (die_pc_range(cu.root()).contains(pc)) {
for (const auto& die : cu.root()) {
if (die.tag == dwarf::DW_TAG::subprogram) {
if (die_pc_range(die).contains(pc)) {
return die;
}
}
}
}
}
throw std::out_of_range{"Cannot find function"};
}
```
这里我采用了朴素的方法，迭代遍历编译单元直到找到一个包含程序计数器的，然后迭代遍历它的子节点直到我们找到相关函数（`DW_TAG_subprogram`）。正如我在上一篇中提到的，如果你想要的话你可以处理类似的成员函数或者内联等情况。
接下来是 `get_line_entry_from_pc`：
```
dwarf::line_table::iterator debugger::get_line_entry_from_pc(uint64_t pc) {
for (auto &cu : m_dwarf.compilation_units()) {
if (die_pc_range(cu.root()).contains(pc)) {
auto < = cu.get_line_table();
auto it = lt.find_address(pc);
if (it == lt.end()) {
throw std::out_of_range{"Cannot find line entry"};
}
else {
return it;
}
}
}
throw std::out_of_range{"Cannot find line entry"};
}
```
同样，我们可以简单地找到正确的编译单元，然后查询行表获取相关的条目。
### 打印源码
当我们命中一个断点或者逐步执行我们的代码时，我们会想知道处于源码中的什么位置。
```
void debugger::print_source(const std::string& file_name, unsigned line, unsigned n_lines_context) {
std::ifstream file {file_name};
//获得一个所需行附近的窗口
auto start_line = line <= n_lines_context ? 1 : line - n_lines_context;
auto end_line = line + n_lines_context + (line < n_lines_context ? n_lines_context - line : 0) + 1;
char c{};
auto current_line = 1u;
//跳过 start_line 之前的行
while (current_line != start_line && file.get(c)) {
if (c == '\n') {
++current_line;
}
}
//如果我们在当前行则输出光标
std::cout << (current_line==line ? "> " : " ");
//输出行直到 end_line
while (current_line <= end_line && file.get(c)) {
std::cout << c;
if (c == '\n') {
++current_line;
//如果我们在当前行则输出光标
std::cout << (current_line==line ? "> " : " ");
}
}
//输出换行确保恰当地清空了流
std::cout << std::endl;
}
```
现在我们可以打印出源码了，我们需要将这些通过钩子添加到我们的调试器。实现这个的一个好地方是当调试器从一个断点或者（最终）逐步执行得到一个信号时。到了这里，我们可能想要给我们的调试器添加一些更好的信号处理。
### 更好的信号处理
我们希望能够得知什么信号被发送给了进程，同样我们也想知道它是如何产生的。例如，我们希望能够得知是否由于命中了一个断点从而获得一个 `SIGTRAP`，还是由于逐步执行完成、或者是产生了一个新线程等等导致的。幸运的是，我们可以再一次使用 `ptrace`。可以给 `ptrace` 的一个命令是 `PTRACE_GETSIGINFO`，它会给你被发送给进程的最后一个信号的信息。我们类似这样使用它：
```
siginfo_t debugger::get_signal_info() {
siginfo_t info;
ptrace(PTRACE_GETSIGINFO, m_pid, nullptr, &info);
return info;
}
```
这会给我们一个 `siginfo_t` 对象，它能提供以下信息：
```
siginfo_t {
int si_signo; /* 信号编号 */
int si_errno; /* errno 值 */
int si_code; /* 信号代码 */
int si_trapno; /* 导致生成硬件信号的陷阱编号
（大部分架构中都没有使用） */
pid_t si_pid; /* 发送信号的进程 ID */
uid_t si_uid; /* 发送信号进程的用户 ID */
int si_status; /* 退出值或信号 */
clock_t si_utime; /* 消耗的用户时间 */
clock_t si_stime; /* 消耗的系统时间 */
sigval_t si_value; /* 信号值 */
int si_int; /* POSIX.1b 信号 */
void *si_ptr; /* POSIX.1b 信号 */
int si_overrun; /* 计时器 overrun 计数;
POSIX.1b 计时器 */
int si_timerid; /* 计时器 ID; POSIX.1b 计时器 */
void *si_addr; /* 导致错误的内存地址 */
long si_band; /* Band event (在 glibc 2.3.2 和之前版本中是 int 类型) */
int si_fd; /* 文件描述符 */
short si_addr_lsb; /* 地址的最不重要位
(自 Linux 2.6.32) */
void *si_lower; /* 出现地址违规的下限 (自 Linux 3.19) */
void *si_upper; /* 出现地址违规的上限 (自 Linux 3.19) */
int si_pkey; /* PTE 上导致错误的保护键 (自 Linux 4.6) */
void *si_call_addr; /* 系统调用指令的地址
(自 Linux 3.5) */
int si_syscall; /* 系统调用尝试次数
(自 Linux 3.5) */
unsigned int si_arch; /* 尝试系统调用的架构
(自 Linux 3.5) */
}
```
我只需要使用 `si_signo` 就可以找到被发送的信号，使用 `si_code` 来获取更多关于信号的信息。放置这些代码的最好位置是我们的 `wait_for_signal` 函数：
```
void debugger::wait_for_signal() {
int wait_status;
auto options = 0;
waitpid(m_pid, &wait_status, options);
auto siginfo = get_signal_info();
switch (siginfo.si_signo) {
case SIGTRAP:
handle_sigtrap(siginfo);
break;
case SIGSEGV:
std::cout << "Yay, segfault. Reason: " << siginfo.si_code << std::endl;
break;
default:
std::cout << "Got signal " << strsignal(siginfo.si_signo) << std::endl;
}
}
```
现在再来处理 `SIGTRAP`。知道当命中一个断点时会发送 `SI_KERNEL` 或 `TRAP_BRKPT`，而逐步执行结束时会发送 `TRAP_TRACE` 就足够了：
```
void debugger::handle_sigtrap(siginfo_t info) {
switch (info.si_code) {
//如果命中了一个断点其中的一个会被设置
case SI_KERNEL:
case TRAP_BRKPT:
{
set_pc(get_pc()-1); //将程序计数器的值设置为它应该指向的地方
std::cout << "Hit breakpoint at address 0x" << std::hex << get_pc() << std::endl;
auto line_entry = get_line_entry_from_pc(get_pc());
print_source(line_entry->file->path, line_entry->line);
return;
}
//如果信号是由逐步执行发送的，这会被设置
case TRAP_TRACE:
return;
default:
std::cout << "Unknown SIGTRAP code " << info.si_code << std::endl;
return;
}
}
```
这里有一大堆不同风格的信号你可以处理。查看 `man sigaction` 获取更多信息。
由于当我们收到 `SIGTRAP` 信号时我们已经修正了程序计数器的值，我们可以从 `step_over_breakpoint` 中移除这些代码，现在它看起来类似：
```
void debugger::step_over_breakpoint() {
if (m_breakpoints.count(get_pc())) {
auto& bp = m_breakpoints[get_pc()];
if (bp.is_enabled()) {
bp.disable();
ptrace(PTRACE_SINGLESTEP, m_pid, nullptr, nullptr);
wait_for_signal();
bp.enable();
}
}
}
```
### 测试
现在你应该可以在某个地址设置断点，运行程序然后看到打印出了源码，而且正在被执行的行被光标标记了出来。
后面我们会添加设置源码级别断点的功能。同时，你可以从[这里](https://github.com/TartanLlama/minidbg/tree/tut_source)获取该博文的代码。
---
via: <https://blog.tartanllama.xyz/c++/2017/04/24/writing-a-linux-debugger-source-signal/>
作者：[TartanLlama](https://www.twitter.com/TartanLlama) 译者：[ictlyh](https://github.com/ictlyh) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开发一个 Linux 调试器（六）：源码级逐步执行
|
Simon Brand
|
https://blog.tartanllama.xyz/c++/2017/05/06/writing-a-linux-debugger-dwarf-step/
|
在前几篇博文中我们学习了 DWARF 信息以及它如何使我们将机器码和上层源码联系起来。这一次我们通过为我们的调试器添加源码级逐步调试将该知识应用于实际。
|
/data/attachment/album/201708/26/182207drf4dydz6xpyc5jd.jpg.thumb.jpg
|
/data/attachment/album/201708/26/182207drf4dydz6xpyc5jd.jpg
| true | false | true |
ictlyh
| false |
[
"调试器"
] |
软件开发
|
{
"viewnum": 5111,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8812,
"displayorder": 0
},
{
"raid": 8890,
"displayorder": 0
}
] |
在前几篇博文中我们学习了 DWARF 信息以及它如何使我们将机器码和上层源码联系起来。这一次我们通过为我们的调试器添加源码级逐步调试将该知识应用于实际。
| 2017-08-28T10:21:00 | 2017-08-28T10:21:00 | 8,813 |
/article-8813-1.html
|
在前几篇博文中我们学习了 DWARF 信息以及它如何使我们将机器码和上层源码联系起来。这一次我们通过为我们的调试器添加源码级逐步调试将该知识应用于实际。
### 系列文章索引
随着后面文章的发布，这些链接会逐渐生效。
1. [准备环境](/article-8626-1.html)
2. [断点](/article-8645-1.html)
3. [寄存器和内存](/article-8579-1.html)
4. [Elves 和 dwarves](/article-8719-1.html)
5. [源码和信号](/article-8812-1.html)
6. [源码级逐步执行](https://blog.tartanllama.xyz/c++/2017/05/06/writing-a-linux-debugger-dwarf-step/)
7. 源码级断点
8. 调用栈展开
9. 读取变量
10. 下一步
### 揭秘指令级逐步执行
我们正在超越了自我。首先让我们通过用户接口揭秘指令级单步执行。我决定将它切分为能被其它部分代码利用的 `single_step_instruction` 和确保是否启用了某个断点的 `single_step_instruction_with_breakpoint_check` 两个函数。
```
void debugger::single_step_instruction() {
ptrace(PTRACE_SINGLESTEP, m_pid, nullptr, nullptr);
wait_for_signal();
}
void debugger::single_step_instruction_with_breakpoint_check() {
//首先，检查我们是否需要停用或者启用某个断点
if (m_breakpoints.count(get_pc())) {
step_over_breakpoint();
}
else {
single_step_instruction();
}
}
```
正如以往，另一个命令被集成到我们的 `handle_command` 函数：
```
else if(is_prefix(command, "stepi")) {
single_step_instruction_with_breakpoint_check();
auto line_entry = get_line_entry_from_pc(get_pc());
print_source(line_entry->file->path, line_entry->line);
}
```
利用新增的这些函数我们可以开始实现我们的源码级逐步执行函数。
### 实现逐步执行
我们打算编写这些函数非常简单的版本，但真正的调试器有 *thread plan* 的概念，它封装了所有的单步信息。例如，调试器可能有一些复杂的逻辑去决定断点的位置，然后有一些回调函数用于判断单步操作是否完成。这其中有非常多的基础设施，我们只采用一种朴素的方法。我们可能会意外地跳过断点，但如果你愿意的话，你可以花一些时间把所有的细节都处理好。
对于跳出 `step_out`，我们只是在函数的返回地址处设一个断点然后继续执行。我暂时还不想考虑调用栈展开的细节 - 这些都会在后面的部分介绍 - 但可以说返回地址就保存在栈帧开始的后 8 个字节中。因此我们会读取栈指针然后在内存相对应的地址读取值：
```
void debugger::step_out() {
auto frame_pointer = get_register_value(m_pid, reg::rbp);
auto return_address = read_memory(frame_pointer+8);
bool should_remove_breakpoint = false;
if (!m_breakpoints.count(return_address)) {
set_breakpoint_at_address(return_address);
should_remove_breakpoint = true;
}
continue_execution();
if (should_remove_breakpoint) {
remove_breakpoint(return_address);
}
}
```
`remove_breakpoint` 是一个小的帮助函数：
```
void debugger::remove_breakpoint(std::intptr_t addr) {
if (m_breakpoints.at(addr).is_enabled()) {
m_breakpoints.at(addr).disable();
}
m_breakpoints.erase(addr);
}
```
接下来是跳入 `step_in`。一个简单的算法是继续逐步执行指令直到新的一行。
```
void debugger::step_in() {
auto line = get_line_entry_from_pc(get_pc())->line;
while (get_line_entry_from_pc(get_pc())->line == line) {
single_step_instruction_with_breakpoint_check();
}
auto line_entry = get_line_entry_from_pc(get_pc());
print_source(line_entry->file->path, line_entry->line);
}
```
跳过 `step_over` 对于我们来说是三个中最难的。理论上，解决方法就是在下一行源码中设置一个断点，但下一行源码是什么呢？它可能不是当前行后续的那一行，因为我们可能处于一个循环、或者某种条件结构之中。真正的调试器一般会检查当前正在执行什么指令然后计算出所有可能的分支目标，然后在所有分支目标中设置断点。对于一个小的项目，我不打算实现或者集成一个 x86 指令模拟器，因此我们要想一个更简单的解决办法。有几个可怕的选择，一个是一直逐步执行直到当前函数新的一行，或者在当前函数的每一行都设置一个断点。如果我们是要跳过一个函数调用，前者将会相当的低效，因为我们需要逐步执行那个调用图中的每个指令，因此我会采用第二种方法。
```
void debugger::step_over() {
auto func = get_function_from_pc(get_pc());
auto func_entry = at_low_pc(func);
auto func_end = at_high_pc(func);
auto line = get_line_entry_from_pc(func_entry);
auto start_line = get_line_entry_from_pc(get_pc());
std::vector<std::intptr_t> to_delete{};
while (line->address < func_end) {
if (line->address != start_line->address && !m_breakpoints.count(line->address)) {
set_breakpoint_at_address(line->address);
to_delete.push_back(line->address);
}
++line;
}
auto frame_pointer = get_register_value(m_pid, reg::rbp);
auto return_address = read_memory(frame_pointer+8);
if (!m_breakpoints.count(return_address)) {
set_breakpoint_at_address(return_address);
to_delete.push_back(return_address);
}
continue_execution();
for (auto addr : to_delete) {
remove_breakpoint(addr);
}
}
```
这个函数有一点复杂，我们将它拆开来看。
```
auto func = get_function_from_pc(get_pc());
auto func_entry = at_low_pc(func);
auto func_end = at_high_pc(func);
```
`at_low_pc` 和 `at_high_pc` 是 `libelfin` 中的函数，它们能给我们指定函数 DWARF 信息条目的最小和最大程序计数器值。
```
auto line = get_line_entry_from_pc(func_entry);
auto start_line = get_line_entry_from_pc(get_pc());
std::vector<std::intptr_t> breakpoints_to_remove{};
while (line->address < func_end) {
if (line->address != start_line->address && !m_breakpoints.count(line->address)) {
set_breakpoint_at_address(line->address);
breakpoints_to_remove.push_back(line->address);
}
++line;
}
```
我们需要移除我们设置的所有断点，以便不会泄露出我们的逐步执行函数，为此我们把它们保存到一个 `std::vector` 中。为了设置所有断点，我们循环遍历行表条目直到找到一个不在我们函数范围内的。对于每一个，我们都要确保它不是我们当前所在的行，而且在这个位置还没有设置任何断点。
```
auto frame_pointer = get_register_value(m_pid, reg::rbp);
auto return_address = read_memory(frame_pointer+8);
if (!m_breakpoints.count(return_address)) {
set_breakpoint_at_address(return_address);
to_delete.push_back(return_address);
}
```
这里我们在函数的返回地址处设置一个断点，正如跳出 `step_out`。
```
continue_execution();
for (auto addr : to_delete) {
remove_breakpoint(addr);
}
```
最后，我们继续执行直到命中它们中的其中一个断点，然后移除所有我们设置的临时断点。
它并不美观，但暂时先这样吧。
当然，我们还需要将这个新功能添加到用户界面：
```
else if(is_prefix(command, "step")) {
step_in();
}
else if(is_prefix(command, "next")) {
step_over();
}
else if(is_prefix(command, "finish")) {
step_out();
}
```
### 测试
我通过实现一个调用一系列不同函数的简单函数来进行测试：
```
void a() {
int foo = 1;
}
void b() {
int foo = 2;
a();
}
void c() {
int foo = 3;
b();
}
void d() {
int foo = 4;
c();
}
void e() {
int foo = 5;
d();
}
void f() {
int foo = 6;
e();
}
int main() {
f();
}
```
你应该可以在 `main` 地址处设置一个断点，然后在整个程序中跳入、跳过、跳出函数。如果你尝试跳出 `main` 函数或者跳入任何动态链接库，就会出现意料之外的事情。
你可以在[这里](https://github.com/TartanLlama/minidbg/tree/tut_dwarf_step)找到这篇博文的相关代码。下次我们会利用我们新的 DWARF 技巧来实现源码级断点。
---
via: <https://blog.tartanllama.xyz/c++/2017/05/06/writing-a-linux-debugger-dwarf-step/>
作者：[Simon Brand](https://www.twitter.com/TartanLlama) 译者：[ictlyh](https://github.com/ictlyh) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GitHub 简易入门指南
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/getting-started-with-github
|
GitHub 是一个在线平台，旨在促进在一个共同项目上工作的个人之间的代码托管、版本控制和协作。通过该平台，无论何时何地，都可以对项目进行操作
|
/data/attachment/album/201708/28/054321c219m21a12fd12ki.jpg.thumb.jpg
|
/data/attachment/album/201708/28/054321c219m21a12fd12ki.jpg
| true | false | true |
firmianay
| false |
[
"GitHub"
] |
技术
|
{
"viewnum": 7985,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
GitHub 是一个在线平台，旨在促进在一个共同项目上工作的个人之间的代码托管、版本控制和协作。通过该平台，无论何时何地，都可以对项目进行操作
| 2017-08-28T08:00:00 | 2017-08-28T08:00:00 | 8,814 |
/article-8814-1.html
|
[](http://www.linuxandubuntu.com/home/getting-started-with-github)
[GitHub](https://github.com/) 是一个在线平台，旨在促进在一个共同项目上工作的个人之间的代码托管、版本控制和协作。通过该平台，无论何时何地，都可以对项目进行操作（托管和审查代码，管理项目和与世界各地的其他开发者共同开发软件）。**GitHub 平台**为开源项目和私人项目都提供了项目处理功能。
关于团队项目处理的功能包括：GitHub <ruby> 流 <rt> Flow> </rt></ruby>和 GitHub <ruby> 页 <rt> Pages </rt></ruby>。这些功能可以让需要定期部署的团队轻松处理工作流程。另一方面，GitHub 页提供了页面用于展示开源项目、展示简历、托管博客等。
GitHub 也为个人项目提供了必要的工具，使得个人项目可以轻松地处理。它也使得个人可以更轻松地与世界分享他们的项目。
### 注册 GitHub 并启动一个项目
在 GitHub 上启动新项目时，您必须先使用您的电子邮件地址创建一个帐户。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/github-homepage_orig.jpg)
然后，在验证邮箱的时候，用户将自动登录到他们的 GitHub 帐户。
#### 1、 创建仓库
之后，我们会被带到一个用于创建<ruby> 仓库 <rt> repository </rt></ruby>的页面。仓库存储着包括修订历史记录在内的所有项目文件。仓库可以是公开的或者是私有的。公开的仓库可以被任何人查看，但是，只有项目所有者授予权限的人才可以提交修改到这个仓库。另一方面，私有仓库提供了额外的控制，可以将项目设置为对谁可见。因此，公开仓库适用于开源软件项目，而私有仓库主要适用于私有或闭源项目。
* 填写 “<ruby> 仓库名称 <rt> Repository Name </rt></ruby>” 和 “<ruby> 简短描述 <rt> Short Description </rt></ruby>”。
* 选中 “<ruby> 以一个 README 文件初始化 <rt> Initialize this repository with a README </rt></ruby>”。
* 最后，点击底部的 “<ruby> 创建仓库 <rt> Create Repository </rt></ruby>” 按钮。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/create-a-github-repository_orig.jpg)
#### 2、 添加分支
在 GitHub 中，<ruby> 分支 <rt> branch </rt></ruby>是一种同时操作单个仓库的各种版本的方式。默认情况下，任何创建的单个仓库都会被分配一个名为 “MASTER” 的分支，它被认为是最后一个分支。在 GitHub 中，分支在被合并到<ruby> 主干 <rt> master </rt></ruby>（最后的分支）之前，可以在对仓库进行实验和编辑中发挥作用。
为了使项目适合每一个人的需求，通常情况下，总是需要添加几个格外的分支来匹配不同的项目。在主分支上创建一个分支和复制主分支时的当前状态是一样的。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/add-a-branch-to-github-repository_orig.jpg)
创建分支与在不同版本中保存单个文件是类似的。它通过在特定仓库上执行的任务重命名来实现。
分支在保持错误修复和功能添加工作中同样被证明是有效。在进行必要的修改后，这些分支会被合并到主分支中。
在创建仓库后创建一个分支：
* 在这个例子中，点击仓库名称 “Hello-World” 跳转到你的新仓库。
* 点击顶部的 “Branch:Master” 按钮，会看到一个下拉菜单，菜单里有填写分支名称的空白字段。
* 输入分支名称，在这个例子中我们输入 “readme-edits“。
* 按下回车键或者点击蓝色的 “<ruby> 创建分支 <rt> create branch </rt></ruby>” 框。
这样就成功创建了两个分支：master 和 readme-edits。
#### 3、 修改项目文件并提交
此步骤提供了关于如何更改仓库并保存修改的指导。在 GitHub 上，<ruby> 提交 <rt> commit </rt></ruby>被定义为保存的修改的意思。每一次提交都与一个<ruby> 提交信息 <rt> commit message </rt></ruby>相关联，该提交信息包含了保存的修改的历史记录，以及为何进行这些更改。这使得其他贡献者可以很轻松地知道你做出的更改以及更改的原因。
要对仓库进行更改和提交更改，请执行以下步骤：
* 点击仓库名称 “Hello-World”。
* 点击右上角的铅笔图标查看和编辑文件。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/commit-changes-to-github-repository_orig.jpg)
* 在编辑器中，写一些东西来确定你可以进行更改。
* 在<ruby> 提交消息 <rt> commit message </rt></ruby>字段中做简要的总结，以解释为什么以及如何进行更改。
* 点击<ruby> 提交更改 <rt> commit changes </rt></ruby>按钮保存更改。
请注意，这些更改仅仅影响到 readme-edits 分支，而不影响主分支。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/commit-branch-to-master_orig.jpg)
#### 4、 开启一个拉取请求
<ruby> 拉取请求 <rt> pull request </rt></ruby>是一个允许贡献者提出并请求某人审查和合并某些更改到他们的分支的功能。拉取请求还显示了几个分支的差异（diffs）。更改、添加和删减通常以红色和绿色来表示。一旦提交完成就可以开启拉取请求，即使代码还未完成。
开启一个拉取请求：
* 点击<ruby> 拉取请求 <rt> pull requests </rt></ruby>选项卡。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/github-pull-request_orig.jpg)
* 点击<ruby> 新建拉取请求 <rt> new pull requests </rt></ruby>按钮。
* 选择 readme-edits 分支与 master 分支进行比较。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/compare-commit-changes-github_orig.jpg)
* 确定请求，并确定这是您要提交的内容。
* 点击创建拉取请求绿色按钮并输入一个标题。 [](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/open-a-pull-request-in-github-repository_orig.jpg)
* 按下回车键。
用户可以通过尝试创建并保存拉取请求来证实这些操作。
#### 5、 合并拉取请求
最后一步是将 readme-edits 分支和 master 分支合并到一起。如果 readme-edits 分支和 master 分支不会产生冲突，则会显示<ruby> merge pull request <rt> 合并拉取请求 </rt></ruby>的按钮。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/merge-the-pull-request-github_orig.jpg)
当合并拉取时，有必要确保<ruby> 评论 <rt> comment </rt></ruby>和其他字段被正确填写。合并拉取：
* 点击<ruby> merge pull request <rt> 合并拉取请求 </rt></ruby>的按钮。
* 确认合并。
* 按下紫色的删除分支按钮，删除 readme-edits 分支，因为它已经被包含在 master 分支中。（LCTT 译注：如果是合并他人提交的拉取请求，则无需也无法删除合并过来的他人的分支。）
本文提供了 GitHub 平台从注册到使用的基本操作，接下来由大家尽情探索吧。
---
via: <http://www.linuxandubuntu.com/home/getting-started-with-github>
作者：[LinuxAndUbuntu](http://www.linuxandubuntu.com) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Snap 中玩转 OpenStack
|
Corey Bryant
|
https://insights.ubuntu.com/2017/07/06/openstack-in-a-snap/
|
OpenStack 非常复杂，许多社区成员都在努力使 OpenStack 的部署和操作更加容易。其中大部分时间都用来改善相关工具。但是，如果我们降低一下标准，并且还能使包的体验更加简单，将会怎样呢？
|
/data/attachment/album/201708/28/060748zgz5vzfzggfogf02.png.thumb.jpg
|
/data/attachment/album/201708/28/060748zgz5vzfzggfogf02.png
| true | false | true |
Snapcrafter
| false |
[
"Snapcraft",
"snap"
] |
技术
|
{
"viewnum": 6030,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
OpenStack 非常复杂，许多社区成员都在努力使 OpenStack 的部署和操作更加容易。其中大部分时间都用来改善相关工具。但是，如果我们降低一下标准，并且还能使包的体验更加简单，将会怎样呢？
| 2017-08-28T08:30:00 | 2017-08-28T08:30:00 | 8,816 |
/article-8816-1.html
|
OpenStack 非常复杂，许多社区成员都在努力使 OpenStack 的部署和操作更加容易。其中大部分时间都用来改善相关工具，如：Ansible、Puppet、Kolla、Juju、Triple-O 和 Chef (仅举几例)。但是，如果我们降低一下标准，并且还能使包的体验更加简单，将会怎样呢？
我们正在努力通过 snap 包来实现这一点。snap 包是一种新兴的软件分发方式，这段来自 [snapcraft.io](http://snapcraft.io/) 的介绍很好的总结了它的主要优点：*snap 包可以快速安装、易于创建、安全运行而且能自动地事务化更新，因此你的应用程序总是能保持最新的状态并且永远不会被破坏。*
### 捆绑软件
单个 snap 包可以内嵌多个不同来源的软件，从而提供一个能够快速启动和运行的解决方案。当你安装 snap 包时，你会发现安装速度是很快的，这是因为单个 snap 包捆绑了所有它需要的依赖。这和安装 deb 包有些不同，因为它需要下载所有的依赖然后分别进行安装。
### Snap 包制作简单
在 Ubuntu 工作的时候，我花了很多时间为 Debian 制作 OpenStack 的安装包。这是一种很特殊技能，需要花很长时间才能理解其中的细微差别。与 snap 包相比，deb 包和 snap 包在复杂性上的差异有天壤之别。snap 包简单易行，并且相当有趣。
### Snap 包的其它特性
* 每个 snap 包都安装在其独有的只读 squashfs 文件系统中。
* 每个 snap 包都运行在一个由 AppArmor 和 seccomp 策略构建的严格沙箱环境中。
* snap 包能事务更新。新版本的 snap 包会安装到一个新的只读 squashfs 文件系统中。如果升级失败，它将回滚到旧版本。
* 当有新版本可用时，snap 包将自动更新。
* OpenStack 的 snap 包能保证与 OpenStack 的上游约束保持一致。打包的人不需要再为 OpenStack 依赖链维护单独的包。这真是太爽了!
### OpenStack snap 包介绍
现在，下面这些项目已经有了相应的 snap 包：
* `Keystone` —— 这个 snap 包为 OpenStack 提供了身份鉴证服务。
* `Glance` —— 这个 snap 包为 OpenStack 提供了镜像服务。
* `Neutron` —— 这个 snap 包专门提供了 neutron-server 过程，作为 OpenStack 部署过程的一个 snap 包。
* `Nova` —— 这个 snap 包提供 OpenStack 部署过程中的 Nova 控制器组件。
* `Nova-hypervisor` —— 这个 snap 包提供 OpenStack 部署过程中的 hypervisor 组件，并且配置使用通过 deb 包安装的 Libvirt/KVM + Open vSwitch 组合。这个 snap 包同时也包含 nava-lxd，这允许我们使用 nova-lxd 而不用 KVM。
这些 snpa 包已经能让我们部署一个简单可工作的 OpenStack 云。你可以在 [github](https://github.com/openstack?utf8=%E2%9C%93&q=snap-&type=&language=) 上找到所有这些 OpenStack snap 包的源码。有关 OpenStack snap 包更多的细节，请参考上游存储库中各自的 README。在那里，你可以找到更多有关管理 snap 包的信息，比如覆盖默认配置、重启服务、设置别名等等。
### 想要创建自己的 OpenStack snap 包吗?
查看 [snap cookie 工具](https://github.com/openstack-snaps/snap-cookiecutter/blob/master/README.rst)。我很快就会写一篇博文，告诉你如何使用 snap cookie 工具。它非常简单，并且能帮助你在任何时候创建一个新的 OpenStack snap 包。
### 测试 OpenStack snap 包
我们已经用简单的脚本初步测试了 OpenStack snap 包。这个脚本会在单个节点上安装 sanp 包，还会在安装后提供额外的配置服务。来尝试下吧：
```
git clone https://github.com/openstack-snaps/snap-test
cd snap-test
./snap-deploy
```
这样，我们就已经在 Ubuntu Xenial（16.04） 上做了所有的测试。要注意的是，这将在你的系统上安装和配置相当多的软件，因此你最好在可自由使用的机器上运行它。
### 追踪 OpenStack
现在，你可以从 snap 商店的边缘通道来安装 snap 包，比如：
```
sudo snap install --edge keystone
```
OpenStack 团队正在努力使 CI/CD 配置到位，以便让 snap 包的发布能够交叉追踪 OpenStack 的发布（比如一个追踪 Ocata，另一个追踪 Pike 等）。每个<ruby> 轨道 <rt> track </rt></ruby>都有 4 个不同的通道。每个轨道的边缘通道将包含 OpenStack 项目对应分支最近的内容，测试、候选和稳定通道被保留用于已发布的版本。这样我们将看到如下的用法：
```
sudo snap install --channel=ocata/stable keystone
sudo snap install --channel=pike/edge keystone
```
### 其它
我们可以使用多个环境变量来简化 snap 包的制作。[这里](https://snapcraft.io/docs/reference/env) 有相关的说明。实际上，你无需深入的研究他们，但是在安装完 snap 包后，你也许会想要了解这些位置：
#### `$SNAP == /snap/<snap-name>/current`
这是 snap 包和它所有的文件挂载的位置。所有东西都是只读的。比如我当前安装的 keystone，$SNAP 就是 `/snap/keystone/91`。幸好，你不需要知道当前版本号，因为在 `/snap/keystone/` 中有一个软链接（LCTT 译注：`/snap/keystone/current/`）指向当前正在使用版本对应的文件夹。
```
$ ls /snap/keystone/current/
bin etc pysqlite2-doc usr
command-manage.wrapper include snap var
command-nginx.wrapper lib snap-openstack.yaml
command-uwsgi.wrapper meta templates
$ ls /snap/keystone/current/bin/
alembic oslo-messaging-send-notification
convert-json oslo-messaging-zmq-broker
jsonschema oslo-messaging-zmq-proxy
keystone-manage oslopolicy-checker
keystone-wsgi-admin oslopolicy-list-redundant
keystone-wsgi-public oslopolicy-policy-generator
lockutils-wrapper oslopolicy-sample-generator
make_metadata.py osprofiler
mako-render parse_xsd2.py
mdexport.py pbr
merge_metadata.py pybabel
migrate snap-openstack
migrate-repository sqlformat
netaddr uwsgi
oslo-config-generator
$ ls /snap/keystone/current/usr/bin/
2to3 idle pycompile python2.7-config
2to3-2.7 pdb pydoc python2-config
cautious-launcher pdb2.7 pydoc2.7 python-config
compose pip pygettext pyversions
dh_python2 pip2 pygettext2.7 run-mailcap
easy_install pip2.7 python see
easy_install-2.7 print python2 smtpd.py
edit pyclean python2.7
$ ls /snap/keystone/current/lib/python2.7/site-packages/
...
```
#### `$SNAP_COMMON == /var/snap/<snap-name>/common`
这个目录用于存放系统数据，对于 snap 包的多个修订版本这些数据是共用的。在这里，你可以覆盖默认配置文件和访问日志文件。
```
$ ls /var/snap/keystone/common/
etc fernet-keys lib lock log run
$ sudo ls /var/snap/keystone/common/etc/
keystone nginx uwsgi
$ ls /var/snap/keystone/common/log/
keystone.log nginx-access.log nginx-error.log uwsgi.log
```
### 严格限制
每个 snap 包都是在一个由 seccomp 和 AppArmor 策略构建的严格限制的环境中运行的。更多关于 snap 约束的细节可以在 [这里](https://snapcraft.io/docs/reference/confinement) 查看。
### snap 包即将到来的新特性和更新
我正在期待 snap 包一些即将到来的新特性和更新（LCTT 译注：此文发表于 7 月 6 日）：
* 我们正在致力于实现 libvirt AppArmor 策略，这样 nova-hypervisor 的 snap 包就能够访问 qcow2 的<ruby> 支持文件 <rt> backing files </rt></ruby>。
+ 现在，作为一种变通方法，你可以将 virt-aa-helper 放在 complain 模式下：`sudo aa-complain /usr/lib/libvirt/virt-aa-helper`。
* 我们还在为 snapd 开发额外的接口策略，以便为部署的实例启用网络连接。
+ 现在你可以在 devmode 模式下安装 nova-hypervisor snap 包，它会禁用安全限制：`snap install -devmode -edge nova-hypervisor`。
* 自动连接 nova-hypervisor 的接口。我们正在努力实现在安装时自动定义 nova-hypervisor 接口。
+ 定义 AppArmor 和 seccomp 策略的接口可以允许 snap 包访问系统的资源。
+ 现在，你可以手动连接需要接口，在 nova-hypervisor snap 包的 README 中有相关的描述。
* 命令自动定义别名。我们正在努力实现 snap 包在安装时为命令自动定义别名。
+ 这使得我们可以使用传统的命令名。安装 snap 包后，你将可以使用 `nova-manage db sync` 而无需再用 `nova.manage db sync`。
+ 现在，你可以在安装 snap 包后手动设置别名，比如：`snap alias nova.manage nova-manage`。如想获取更多细节请查看 snap 包的 README 。
* 守护进程自动定义别名。当前 snappy 仅支持为命令（非守护进程）定义别名。一旦针对守护进程的别名可用了，我们将设置它们在安装的时候自动配置。
+ 这使得我们可以使用额外的单元文件名。我们可以使用 `systemctl restart nova-compute` 而无需再用 `systemctl restart snap.nova.nova-compute`。
* snap 包资产跟踪。这使得我们可以追踪用来构建 snap 包的版本以便在将来构建时重复使用。
如果你想多聊一些关于 snap 包的内容，你可以在 freenode 的 #openstack-snaps 这样的 IRC 上找到我们。我们欢迎你的反馈和贡献！感谢并祝你玩得开心！Corey
---
作者简介：
Corey Bryant 是 Ubuntu 的核心开发者和 Canonical 公司 OpenStack 工程团队的软件工程师，他主要专注于为 Ubuntu 提供 OpenStack 的安装包以及为 Juju 进行 OpenStack 的魅力开发。他对开源软件充满热情，喜欢与来自世界各地的人一起工作。
译者简介：
>
> snapcraft.io 的钉子户，对 Ubuntu Core、Snaps 和 Snapcraft 有着浓厚的兴趣，并致力于将这些还在快速发展的新技术通过翻译或原创的方式介绍到中文世界。有兴趣的小伙伴也可以关注译者个人的公众号： `Snapcraft`，最近会在上面连载几篇有关 Core snap 发布策略、交付流程和验证流程的文章，欢迎围观 :）
>
>
>
---
via: <https://insights.ubuntu.com/2017/07/06/openstack-in-a-snap/>
作者：[Corey Bryant](https://insights.ubuntu.com/author/corey-bryant/) 译者：[Snapcrafter](https://github.com/Snapcrafter) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
公钥加密之外
|
Matthew Green
|
https://blog.cryptographyengineering.com/2017/07/02/beyond-public-key-encryption/
|
关于应用密码学最令人扼腕也最引人入胜的一件事就是我们在现实中实际使用的密码学是多么的少。这并不是指密码学在业界没有被广泛的应用————事实上它的应用很广泛。我想指出的是，迄今为止密码学研究人员开发了如此多实用的技术，但工业界平常使用的却少之又少。实际上，除了少数个别情况，我们现今使用的绝大部分密码学技术是在 21 世纪初（注1） 就已经存在的技术。
|
/data/attachment/album/201708/28/110440n9c88r9cchni9e6r.jpg.thumb.jpg
|
/data/attachment/album/201708/28/110440n9c88r9cchni9e6r.jpg
| true | false | true |
JanzenLiu
| false |
[
"加密",
"密码学"
] |
技术
|
{
"viewnum": 5788,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
关于应用密码学最令人扼腕也最引人入胜的一件事就是我们在现实中实际使用的密码学是多么的少。这并不是指密码学在业界没有被广泛的应用————事实上它的应用很广泛。我想指出的是，迄今为止密码学研究人员开发了如此多实用的技术，但工业界平常使用的却少之又少。实际上，除了少数个别情况，我们现今使用的绝大部分密码学技术是在 21 世纪初（注1） 就已经存在的技术。
| 2017-08-28T11:10:00 | 2017-08-28T11:10:00 | 8,817 |
/article-8817-1.html
|
关于应用密码学最令人扼腕也最引人入胜的一件事就是*我们在现实中实际使用的密码学是多么的少*。这并不是指密码学在业界没有被广泛的应用————事实上它的应用很广泛。我想指出的是，迄今为止密码学研究人员开发了如此多实用的技术，但工业界平常使用的却少之又少。实际上，除了少数个别情况，我们现今使用的绝大部分密码学技术是在 21 世纪初<sup> （注1）</sup> 就已经存在的技术。
大多数人并不在意这点，但作为一个工作在研究与应用交汇领域的密码学家，这让我感到不开心。我不能完全解决这个问题，我*能*做的，就是谈论一部分这些新的技术。在这个夏天里，这就是我想要做的：谈论。具体来说，在接下来的几个星期里，我将会写一系列讲述这些没有被看到广泛使用的前沿密码学技术的文章。
今天我要从一个非常简单的问题开始：在公钥加密之外还有什么（可用的加密技术）？具体地说，我将讨论几个过去 20 年里开发出的技术，它们可以让我们走出传统的公钥加密的概念的局限。
这是一篇专业的技术文章，但是不会有太困难的数学内容。对于涉及方案的实际定义，我会提供一些原论文的链接，以及一些背景知识的参考资料。在这里，我们的关注点是解释这些方案在做什么————以及它们在现实中可以怎样被应用。
### 基于身份的加密
在 20 世纪 80 年代中期，一位名叫<ruby> 阿迪·萨莫尔 <rt> Adi Shamir </rt></ruby>的密码学家提出了一个 [全新的想法](https://discovery.csc.ncsu.edu/Courses/csc774-S08/reading-assignments/shamir84.pdf) 。这个想法，简单来说，就是*摒弃公钥*。
为了理解 萨莫尔 的想法从何而来，我们最好先了解一些关于公钥加密的东西。在公钥加密的发明之前，所有的加密技术都牵涉到密钥。处理这样的密钥是相当累赘的工作。在你可以安全地通信之前，你需要和你的伙伴交换密钥。这一过程非常的困难，而且当通信规模增大时不能很好地运作。
公钥加密（由 [Diffie-Hellman](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange) 和萨莫尔的 [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem)) 密码系统发展而来的）通过极大地简化密钥分配的过程给密码学带来了革命性的改变。比起分享密钥，用户现在只要将他们的*公共*密钥发送给其他使用者。有了公钥，公钥的接收者可以加密给你的信息（或者验证你的数字签名），但是又不能用该公钥来进行解密（或者产生数字签名）。这一部分要通过你自己保存的私有密钥来完成。
尽管公钥的使用改进了密码学应用的许多方面，它也带来了一系列新的挑战。从实践中的情况来看，拥有公钥往往只是成功的一半————人们通常还需要安全地分发这些公钥。
举一个例子，想象一下我想要给你发送一封 PGP 加密的电子邮件。在我可以这么做之前，我需要获得一份你的公钥的拷贝。我要怎么获得呢？显然我们可以亲自会面，然后当面交换这个密钥————但（由于面基的麻烦）没有人会愿意这样做。通过电子的方式获得你的公钥会更理想。在现实中，这意味着要么（1）我们必须通过电子邮件交换公钥， 要么（2）我必须通过某个第三方基础设施，比如一个 [网站](https://keybase.io/) 或者 [密钥服务器](https://pgp.mit.edu/) ，来获得你的密钥。现在我们面临这样的问题：如果电子邮件或密钥服务器是*不值得信赖的*（或者简单的来说允许任何人以 [你的名义](https://motherboard.vice.com/en_us/article/bmvdwd/wave-of-spoofed-encryption-keys-shows-weakness-in-pgp) [上传密钥](https://motherboard.vice.com/en_us/article/bmvdwd/wave-of-spoofed-encryption-keys-shows-weakness-in-pgp) ），我就可能会意外下载到恶意用户的密钥。当我给“你”发送一条消息的时候，也许我实际上正在将消息加密发送给 Mallory.
*Mallory*
解决这个问题——关于交换公钥和验证它们的来源的问题——激励了*大量的*实践密码工程，包括整个 [web PKI](https://en.wikipedia.org/wiki/Certificate_authority) （网络公钥基础设施）。在大部分情况下，这些系统非常奏效。但是萨莫尔并不满意。如果，他这样问道，我们能做得更好吗？更具体地说，他这样思考：*我们是否可以用一些更好的技术去替换那些麻烦的公钥？*
萨莫尔的想法非常令人激动。他提出的是一个新的公钥加密形式，在这个方案中用户的“公钥”可以就是他们的*身份*。这个身份可以是一个名字（比如 “Matt Green”）或者某些诸如电子邮箱地址这样更准确的信息。事实上，“身份”是什么并不重要。重要的是这个公钥可以是一个任意的字符串————而*不是*一大串诸如“ 7cN5K4pspQy3ExZV43F6pQ6nEKiQVg6sBkYPg1FG56Not ”这样无意义的字符组合。
当然，使用任意字符串作为公钥会造成一个严重的问题。有意义的身份听起来很棒————但我们无法拥有它们。如果我的公钥是 “Matt Green” ，我要怎么得到的对应的私钥？如果*我*能获得那个私钥，又有谁来阻止*其他的某些 Matt Green* 获得同样的私钥，进而读取我的消息。进而考虑一下这个，谁来阻止任意的某个*不是*名为 Matt Green 的人来获得它。啊，我们现在陷入了 [Zooko 三难困境](https://en.wikipedia.org/wiki/Zooko%27s_triangle) 。
萨莫尔的想法因此要求稍微更多一点的手段。相比期望身份可以全世界范围使用，他提出了一个名为“<ruby> 密钥生成机构 <rt> key generation authority </rt></ruby>”的特殊服务器，负责产生私钥。在设立初期，这个机构会产生一个<ruby> 最高公共密钥 <rt> master public key </rt></ruby>（MPK），这个公钥将会向全世界公布。如果你想要加密一条消息给“Matt Green”（或者验证我的签名），你可以用我的身份和我们达成一致使用的权威机构的唯一 MPK 来加密。要*解密*这则消息（或者制作签名），我需要访问同一个密钥机构，然后请求一份我的密钥的拷贝。密钥机构将会基于一个秘密保存的<ruby> 最高私有密钥 <rt> master secret key </rt></ruby>（MSK）来计算我的密钥。
加上上述所有的算法和参与者，整个系统看起来是这样的：
*一个<ruby> 基于身份加密 <rt> Identity-Based Encryption </rt></ruby>（IBE）系统的概览。<ruby> 密钥生成机构 <rt> Key Generation Authority </rt></ruby>的 Setup 算法产生最高公共密钥（MPK）和最高私有密钥（MSK）。该机构可以使用 Extract 算法来根据指定的 ID 生成对应的私钥。加密器（左）仅使用身份和 MPK 来加密。消息的接受者请求对应她身份的私钥，然后用这个私钥解密。（图标由 [Eugen Belyakoff](https://thenounproject.com/eugen.belyakoff/) 制作）*
这个设计有一些重要的优点————并且胜过少数明显的缺点。在好的方面，它*完全*摆脱了任何和你发送消息的对象进行密钥交换的必要。一旦你选择了一个主密钥机构（然后下载了它的 MPK），你就可以加密给整个世界上任何一个人的消息。甚至更酷炫地，在你加密的时候，*你的通讯对象甚至还不需要联系密钥机构*。她可以在你给她发送消息*之后*再取得她的私钥。
当然，这个“特性”也同时是一个漏洞。因为密钥机构产生所有的私钥，它拥有相当大权力。一个不诚实的机构可以轻易生成你的私钥然后解密你的消息。用更得体的方式来说就是标准的 IBE 系统有效地“包含” [密钥托管机制](https://en.wikipedia.org/wiki/Key_escrow)。<sup> （注2）</sup>
### 基于身份加密（IBE）中的“加密（E）”
所有这些想法和额外的思考都是萨莫尔在他 1984 年的论文中提出来的。其中有一个小问题：萨莫尔只能解决问题的一半。
具体地说，萨莫尔提出了一个<ruby> 基于身份签名 <rt> identity-based signature </rt></ruby>（IBS）的方案—— 一个公共验证密钥是身份、而签名密钥由密钥机构生成的签名方案。他尽力尝试了，但仍然不能找到一个建立基于身份*加密*的解决方案。这成为了一个悬而未决的问题。<sup> （注3）</sup>
到有人能解决萨莫尔的难题等了 16 年。令人惊讶的是，当解答出现的时候，它出现了不只一次，*而是三次*。
第一个，或许也是最负盛名的 IBE 的实现，是由<ruby> 丹·博奈 <rt> Dan Boneh </rt></ruby>和<ruby> 马太·富兰克林Matthew Franklin</ruby>在多年以后开发的。博奈和富兰克林的发现的时机十分有意义。<ruby> 博奈富兰克林方案 <rt> Boneh-Franklin scheme </rt></ruby> 根本上依赖于能支持有效的 “<ruby> <a href="http://people.csail.mit.edu/alinush/6.857-spring-2015/papers/bilinear-maps.pdf"> 双线性映射 </a> <rt> bilinear map </rt></ruby>” （或者“<ruby> 配对 <rt> pairing </rt></ruby>”）<sup> （注4）</sup> 的椭圆曲线。需要计算这些配对的该类 [算法](https://crypto.stanford.edu/miller/) 在萨莫尔撰写他的那篇论文是还不被人知晓，因此没有被*建设性地*使用——即被作为比起 [一种攻击](http://ieeexplore.ieee.org/document/259647/) 更有用的东西使用——直至 [2000年](https://pdfs.semanticscholar.org/845e/96c20e5a5ff3b03f4caf72c3cb817a7fa542.pdf)。
*（关于博奈富兰克林 IBE 方案的简短教学，请查看 [这个页面](https://blog.cryptographyengineering.com/boneh-franklin-ibe/)）*
第二个被称为 [Sakai-Kasahara](https://en.wikipedia.org/wiki/Sakai%E2%80%93Kasahara_scheme) 的方案的情况也大抵类似，这个方案将在与第一个大约同一时间被另外一组学者独立发现。
第三个 IBE 的实现并不如前二者有效，但却更令人吃惊得多。[这个方案](https://pdfs.semanticscholar.org/8289/821325781e2f0ce83cfbfc1b62c44be799ee.pdf) 由<ruby> 克利福德·柯克斯 <rt> Clifford Cocks </rt></ruby>，一位英国国家通信总局的资深密码学家开发。它因为两个原因而引人注目。第一，柯克斯的 IBE 方案完全不需要用到双线性映射——都是建立在以往的 RSA 的基础上的，这意味着*原则上*这个算法这么多年来仅仅是没有被人们发现（而非在等待相应的理论基础）而已。第二，柯克斯本人近期因为一些甚至更令人惊奇的东西而闻名：在 RSA 算法被提出之前将近 5 年 [发现 RSA 加密系统](https://cryptome.org/jya/ellisdoc.htm)（LCTT 译注：即公钥加密算法）。用再一个在公钥加密领域的重要成就来结束这一成就，实在堪称令人印象深刻的创举。
自 2001 年起，许多另外的 IBE 构造涌现出来，用到了各种各样的密码学背景知识。尽管如此，博奈和富兰克林早期的实现仍然是这些算法之中最为简单和有效的。
即使你并不因为 IBE 自身而对它感兴趣，事实证明它的基本元素对密码学家来说在许许多多单纯地加密之外的领域都十分有用。事实上，如果我们把 IBE 看作是一种由单一的主公/私钥对来产生数以亿计的相关联的密钥对的方式，它将会显得意义非凡。这让 IBE 对于诸如<ruby> <a href="https://www.cs.umd.edu/%7Ejkatz/papers/id-cca.pdf"> 选择密文攻击 </a> <rt> chosen ciphertext attacks </rt></ruby>， <ruby> <a href="https://eprint.iacr.org/2003/083.pdf"> 前向安全的公钥加密 </a> <rt> forward-secure public key encryption </rt></ruby> 和<ruby> <a href="https://en.wikipedia.org/wiki/Boneh%E2%80%93Lynn%E2%80%93Shacham"> 短签名方案 </a> <rt> short signature schemes </rt></ruby> 这样各种各样的应用来说非常有用。
### 基于特征加密
当然，如果你给密码学家以一个类似 IBE 的工具，那么首先他们要做的将是找到一种~~让事情更复杂~~改进它的方法。
最大的改进之一要归功于 [<ruby> 阿密特·萨海 <rt> Amit Sahai </rt></ruby>和<ruby> 布伦特·沃特世 <rt> Brent Waters </rt></ruby>](https://eprint.iacr.org/2004/086.pdf)。我们称之为<ruby> 基于特征加密 <rt> Attribute-Based Encryption </rt></ruby>，或者 ABE。
这个想法最初并不是为了用特征来加密。相反，萨海和沃特世试图开发一种使用生物辨识特征来加密的*基于身份的*加密方案。为了理解这个问题，想象一下我决定使用某种生物辨识特征，比如你的 [虹膜扫描影像](https://en.wikipedia.org/wiki/Iris_recognition)，来作为你的“身份”来加密一则给你的密文。然后你将向权威机构请求一个对应你的虹膜的解密密钥————如果一切都匹配得上，你就可以解密信息了。
问题就在于这几乎不能奏效。
*告诉我这不会给你带来噩梦*
因为生物辨识特征的读取（比如虹膜扫描或者指纹模板）本来就是易出错的。这意味着每一次的读取通常都是十分接近的，但却总是会几个对不上的比特。在标准的 IBE 系统中这是灾难性的：如果加密使用的身份和你的密钥身份有哪怕是一个比特的不同，解密都会失效。你就不走运了。
萨海和沃特世决定通过开发一种包含“阈值门”的 IBE 形式来解决这个问题。在这个背景下，一个身份的每一个字节都被表示为一个不同的“特征”。把每一个这种特征看作是你用于加密的一个元件——譬如“你的虹膜扫描的 5 号字节是 1”和“你的虹膜扫描的 23 号字节是 0”。加密的一方罗列出所有这些字节，然后将它们中的每一个都用于加密中。权威机构生成的解密密钥也嵌入了一连串相似的字节值。根据这个方案的定义，当且仅当（你的身份密钥与密文解密密钥之间）配对的特征数量超过某个预先定义的阈值时，才能顺利解密：*比如*为了能解密，2048 个字节中的（至少） 2024 个要是对应相同的。
这个想法的优美之处不在于模糊 IBE，而在于一旦你有了一个阈值门和一个“特征”的概念，你就能做更有趣的事情。[主要的观察结论](https://eprint.iacr.org/2006/309.pdf) 是阈值门可以拥有实现布尔逻辑的 AND 门和 OR 门（LCTT 译注：译者认为此处应为用 AND 门和 OR 门实现， 原文： a threshold gate can be used to implement the boolean AND and OR gates），就像这样:
甚至你还可以将这些逻辑闸门*堆叠*起来，一些在另一些之上，来表示一些相当复杂的布尔表达式——这些表达式本身就用于判定在什么情况下你的密文可以被解密。举个例子，考虑一组更为现实的特征，你可以这样加密一份医学记录，使医院的儿科医生*或者*保险理算员都可以阅读它。你所需要做的只不过是保证人们可以得到正确描述*他们的*特征的密钥（就是一些任意的字符串，如同身份那样）。
*一个简单的“密文规定”。在这个规定中当且仅当一个密钥与一组特定的特征匹配时，密文才能被解密。在这个案例中，密钥满足该公式的条件，因此密文将被解密。其余用不到的特征在这里忽略掉。*
其他的条件判断也能实现。通过一长串特征，比如文件创建时间、文件名，甚至指示文件创建位置的 GPS 坐标， 来加密密文也是有可能的。于是你可以让权威机构分发一部分对应你的数据集的非常精确的密钥————比如说，“该密钥用于解密所有在 11 月 3 号和 12 月 12 号之间在芝加哥被加密的包含‘小儿科’或者‘肿瘤科’标记的放射科文件”。
### 函数式加密
一旦拥有一个相关的基础工具，像 IBE 和 ABE，研究人员的本能是去扩充和一般化它。为什么要止步于简单的布尔表达式？我们能不能制作嵌入了*任意的计算机程序*的<ruby> 密钥 <rt> key </rt></ruby>（或者<ruby> 密文 <rt> ciphertext </rt></ruby>）？答案被证明是肯定的——尽管不是非常高效。一组 [近几年的](https://eprint.iacr.org/2013/337.pdf) [研究](https://arxiv.org/abs/1210.5287) 显示可以根据各种各样的<ruby> 基于格 <rt> lattice-based </rt></ruby>的密码假设，构建在<ruby> 任意多项式大小线路 <rt> arbitrary polynomial-size circuits </rt></ruby>运作的 ABE。所以这一方向毫无疑问非常有发展潜力。
这一潜力启发了研究人员将所有以上的想法一般化成为单独一类被称作 <ruby> <a href="https://eprint.iacr.org/2010/543.pdf"> “函数式加密” </a> <rt> functional encryption </rt></ruby> 的加密方式。函数式加密更多是一种抽象的概念而没有具体所指——它不过是一种将所有这些系统看作是一个特定的类的实例的方式。它基本的想法是，用一种依赖于（1）明文，和（2）嵌入在密钥中的数据 的任意函数 F 的算法来代表解密过程。
（LCTT 译注：上面函数 F 的 （1） 原文是“the plaintext inside of a ciphertext”，但译者认为应该是密文，其下的公式同。）
这个函数大概是这样的：
```
输出 = F（密钥数据，密文数据）
```
在这一模型中，IBE 可以表达为有一个加密算法 *加密（身份，明文）*并定义了一个这样的函数 F：如果“*密钥输入 == 身份*”，则输出对应明文，否则输出空字符串的系统。相似地，ABE 可以表达为一个稍微更复杂的函数。依照这一范式，我们可以展望在将来，各类有趣的功能都可以由计算不同的函数得到，并在未来的方案中被实现。
但这些都必须要等到以后了。今天我们谈的已经足够多了。
### 所以这一切的重点是什么？
对于我来说，重点不过是证明密码学可以做到一些十分优美惊人的事。当谈及工业与“应用”密码学时，我们鲜有见到这些出现在日常应用中，但我们都可以等待着它们被广泛使用的一天的到来。
也许完美的应用就在某个地方，也许有一天我们会发现它。
*注：*
* 注 1：最初在这片博文里我写的是 “20 世纪 90 年代中期”。在文章的评论里，Tom Ristenpart 提出了异议，并且非常好地论证了很多重要的发展都是在这个时间之后发生的。所以我把时间再推进了大约 5 年，而我也在考虑怎样将这表达得更好一些。
* 注 2：我们知道有一种叫作 [“无证书加密”](http://eprint.iacr.org/2003/126.pdf) 的加密的中间形式。这个想法由 Al-Riyami 和 Paterson 提出，并且使用到标准公钥加密和 IBE 的结合。基本的思路是用一个（消息接受者生成的）传统密钥和一个 IBE 身份*共同*加密每则消息。然后接受者必须从 IBE 权威机构处获得一份私钥的拷贝来解密。这种方案的优点是两方面的：（1）IBE 密钥机构不能独自解密消息，因为它没有对应的（接受者）私钥，这就解决了“托管”问题（即权威机构完全具备解密消息的能力）；（2）发送者不必验证公钥的确属于接收者（LCTT 译注：原文为 sender,但译者认为应该是笔误，应为 recipient），因为 IBE 方面会防止伪装者解密这则消息。但不幸的是，这个系统更像是传统的公钥加密系统，而缺少 IBE 简洁的实用特性。
* 注 3：开发 IBE 的一部分挑战在于构建一个面临不同密钥持有者的“勾结”安全的系统。譬如说，想象一个非常简单的只有 2 比特的身份鉴定系统。这个系统只提供四个可能的身份：“00”，“01”，“10”，“11”。如果我分配给你对应 “01” 身份的密钥，分配给 Bob 对应 “10” 的密钥，我需要保证你们不能合谋生成对应 “00” 和 “11” 身份的密钥。一些早期提出的解决方法尝试通过用不同方式将标准公共加密密钥拼接到一起来解决这个问题（比如，为身份的每一个字节保留一个独立的公钥，然后将对应的多个私钥合并成一个分发）。但是，当仅仅只有少量用户合谋（或者他们的密钥被盗）时，这些系统就往往会出现灾难性的失败。因而基本上这个问题的解决就是真正的 IBE 与它的仿造近亲之间的区别。
* 注 4： 博奈和富兰克林方案的完整描述可以在 [这里](https://en.wikipedia.org/wiki/Boneh%E2%80%93Franklin_scheme) 看到，或者在他们的 [原版论文](https://crypto.stanford.edu/%7Edabo/papers/bfibe.pdf) 中。[这里](http://go-search.org/view?id=github.com%2Fvanadium%2Fgo.lib%2Fibe)、[这里](https://github.com/relic-toolkit/relic) 和 [这里](https://github.com/JHUISI/charm) 有一部分代码。除了指出这个方案十分高效之外，我不希望在这上面花太多的篇幅。它由 [Voltage Security](https://www.voltage.com/)（现属于惠普） 实现并占有专利。
---
via: <https://blog.cryptographyengineering.com/2017/07/02/beyond-public-key-encryption/>
作者：[Matthew Green](https://blog.cryptographyengineering.com/author/matthewdgreen/) 译者：[Janzen\_Liu](https://github.com/JanzenLiu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 中分割和重组文件
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2017/8/splitting-and-re-assembling-files-linux
|
csplit 是这些有趣的小命令中的一个，它永远伴你左右，一旦开始用它就离不开了。
|
/data/attachment/album/201708/29/075907u54worafhr14m7yt.jpg.thumb.jpg
|
/data/attachment/album/201708/29/075907u54worafhr14m7yt.jpg
| true | false | true |
firmianay
| false |
[
"csplit",
"split"
] |
技术
|
{
"viewnum": 9113,
"commentnum": 2,
"favtimes": 1,
"sharetimes": 2,
"likes": 0
}
|
[
{
"postip": "211.102.192.66",
"message": "mark一下",
"username": "编程浪子 [Chrome 60.0|Windows 7]",
"date": "2017-08-29T11:21:59"
},
{
"postip": "210.77.180.38",
"message": "感觉很有用，有些系统日志文件不进行分割，出现故障后发现日志文件太大不好查看，应该可以用这个命令对日志文件进行分割吧",
"username": "学健 [Sogou Explorer 2|Windows 7]",
"date": "2017-08-31T16:31:15"
}
] |
[] |
csplit 是这些有趣的小命令中的一个，它永远伴你左右，一旦开始用它就离不开了。
| 2017-08-29T07:59:14 | 2017-08-29T07:59:14 | 8,818 |
/article-8818-1.html
|
>
> 非常有用的 `csplit` 命令可以将单个文件分割成多个文件。Carla Schroder 解释说。
>
>
>
Linux 有几个用于分割文件的工具程序。那么你为什么要分割文件呢？一个用例是将大文件分割成更小的尺寸，以便它适用于比较小的存储介质，比如 U 盘。当您遇到 FAT32（最大文件大小为 4GB），且您的文件大于此时，通过 U 盘传输文件也是一个很好的技巧。另一个用例是加速网络文件传输，因为小文件的并行传输通常更快。
我们将学习如何使用 `csplit`，`split` 和 `cat` 来重新整理文件，然后再将文件合并在一起。这些操作在任何文件类型下都有用：文本、图片、音频文件、ISO 镜像文件等。
### 使用 csplit 分割文件
`csplit` 是这些有趣的小命令中的一个，它永远伴你左右，一旦开始用它就离不开了。`csplit` 将单个文件分割成多个文件。这个示例演示了最简单的使用方法，它将文件 foo.txt 分为三个文件，以行号 17 和 33 作为分割点：
```
$ csplit foo.txt 17 33
2591
3889
2359
```
`csplit` 在当前目录下创建了三个新文件，并以字节为单位打印出新文件的大小。默认情况下，每个新文件名为 `xx_nn`：
```
$ ls
xx00
xx01
xx02
```
您可以使用 `head` 命令查看每个新文件的前十行：
```
$ head xx*
==> xx00 <==
Foo File
by Carla Schroder
Foo text
Foo subheading
More foo text
==> xx01 <==
Foo text
Foo subheading
More foo text
==> xx02 <==
Foo text
Foo subheading
More foo text
```
如果要将文件分割成包含相同行数的多个文件怎么办？可以指定行数，然后将重复次数放在在花括号中。此示例重复分割 4 次，并将剩下的转储到最后一个文件中：
```
$ csplit foo.txt 5 {4}
57
1488
249
1866
3798
```
您可以使用星号通配符来告诉 `csplit` 尽可能多地重复分割。这听起来很酷，但是如果文件不能等分，则可能会失败（LCTT 译注：低版本的 `csplit` 不支持此参数）：
```
$ csplit foo.txt 10 {*}
1545
2115
1848
1901
csplit: '10': line number out of range on repetition 4
1430
```
默认的行为是删除发生错误时的输出文件。你可以用 `-k` 选项来解决这个问题，当有错误时，它就不会删除输出文件。另一个行为是每次运行 `csplit` 时，它将覆盖之前创建的文件，所以你需要使用新的文件名来分别保存它们。使用 `--prefix= _prefix_` 来设置一个不同的文件前缀：
```
$ csplit -k --prefix=mine foo.txt 5 {*}
57
1488
249
1866
993
csplit: '5': line number out of range on repetition 9
437
$ ls
mine00
mine01
mine02
mine03
mine04
mine05
```
选项 `-n` 可用于改变对文件进行编号的数字位数（默认是 2 位）：
```
$ csplit -n 3 --prefix=mine foo.txt 5 {4}
57
1488
249
1866
1381
3798
$ ls
mine000
mine001
mine002
mine003
mine004
mine005
```
`csplit` 中的 “c” 是上下文（context）的意思。这意味着你可以根据任意匹配的方式或者巧妙的正则表达式来分割文件。下面的例子将文件分为两部分。第一个文件在包含第一次出现 “fie” 的前一行处结束，第二个文件则以包含 “fie” 的行开头。
```
$ csplit foo.txt /fie/
```
在每次出现 “fie” 时分割文件：
```
$ csplit foo.txt /fie/ {*}
```
在 “fie” 前五次出现的地方分割文件：
```
$ csplit foo.txt /fie/ {5}
```
仅当内容以包含 “fie” 的行开始时才复制，并且省略前面的所有内容：
```
$ csplit myfile %fie%
```
### 将文件分割成不同大小
`split` 与 `csplit` 类似。它将文件分割成特定的大小，当您将大文件分割成小的多媒体文件或者使用网络传送时，这就非常棒了。默认的大小为 1000 行：
```
$ split foo.mv
$ ls -hl
266K Aug 21 16:58 xaa
267K Aug 21 16:58 xab
315K Aug 21 16:58 xac
[...]
```
它们分割出来的大小相似，但你可以指定任何你想要的大小。这个例子中是 20M 字节：
```
$ split -b 20M foo.mv
```
尺寸单位缩写为 K，M，G，T，P，E，Z，Y（1024 的幂）或者 KB，MB，GB 等等（1000 的幂）。
为文件名选择你自己的前缀和后缀：
```
$ split -a 3 --numeric-suffixes=9 --additional-suffix=mine foo.mv SB
240K Aug 21 17:44 SB009mine
214K Aug 21 17:44 SB010mine
220K Aug 21 17:44 SB011mine
```
`-a` 选项控制编号的数字位置。`--numeric-suffixes` 设置编号的开始值。默认前缀为 `x`，你也可以通过在文件名后输入它来设置一个不同的前缀。
### 将分割后的文件合并
你可能想在某个时候重组你的文件。常用的 `cat` 命令就用在这里：
```
$ cat SB0* > foo2.txt
```
示例中的星号通配符将匹配到所有以 SB0 开头的文件，这可能不会得到您想要的结果。您可以使用问号通配符进行更精确的匹配，每个字符使用一个问号：
```
$ cat SB0?????? > foo2.txt
```
和往常一样，请查阅相关的手册和信息页面以获取完整的命令选项。
---
via: <https://www.linux.com/learn/intro-to-linux/2017/8/splitting-and-re-assembling-files-linux>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何恢复丢弃的 git stash 数据
|
Jose Guilherme Vanz
|
https://opensource.com/article/17/8/recover-dropped-data-stash
|
不要让 git 命令中的错误抹去你数天的工作
|
/data/attachment/album/201708/29/081540gi5br5ma5tt5urud.png.thumb.jpg
|
/data/attachment/album/201708/29/081540gi5br5ma5tt5urud.png
| true | false | true |
firmianay
| false |
[
"git"
] |
软件开发
|
{
"viewnum": 8928,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
不要让 git 命令中的错误抹去你数天的工作
| 2017-08-29T08:15:00 | 2017-08-29T08:15:00 | 8,819 |
/article-8819-1.html
|
>
> 不要让 git 命令中的错误抹去你数天的工作
>
>
>
今天我的同事几乎失去了他在四天工作中所做的一切。由于不正确的 `git` 命令，他把保存在 [stash](https://www.git-scm.com/docs/git-stash) 中的更改删除了。在这悲伤的情节之后，我们试图寻找一种恢复他所做工作的方法，而且我们做到了！
首先警告一下：当你在实现一个大功能时，请将它分成小块并定期提交。长时间工作而不做提交并不是一个好主意。
现在我们已经搞定了那个错误，下面就演示一下怎样从 stash 中恢复误删的更改。
我用作示例的仓库中，只有一个源文件 “main.c”，如下所示：
它只有一次提交，即 “Initial commit”：
该文件的第一个版本是：
我将在文件中写一些代码。对于这个例子，我并不需要做什么大的改动，只需要有什么东西放进 stash 中即可，所以我们仅仅增加一行。“git diff” 的输出如下：
现在，假设我想从远程仓库中拉取一些新的更改，当时还不打算提交我自己的更改。于是，我决定先 stash 它，等拉取远程仓库中的更改后，再把我的更改恢复应用到主分支上。我执行下面的命令将我的更改移动到 stash 中：
```
git stash
```
使用命令 `git stash list` 查看 stash，在这里能看到我的更改：
我的代码已经在一个安全的地方，而且主分支目前是干净的（使用命令 `git status` 检查）。现在我只需要拉取远程仓库的更改，然后把我的更改恢复应用到主分支上，而且我也应该是这么做的。
但是我错误地执行了命令：
```
git stash drop
```
它删除了 stash，而不是执行了下面的命令：
```
git stash pop
```
这条命令会在从栈中删除 stash 之前应用它。如果我再次执行命令 `git stash list`，就能看到在没有从栈中将更改恢复到主分支的之前，我就删除了它。OMG！接下来怎么办？
好消息是：`git` 并没有删除包含了我的更改的对象，它只是移除了对它的引用。为了证明这一点，我使用命令 `git fsck`，它会验证数据库中对象的连接和有效性。这是我对该仓库执行了 `git fsck` 之后的输出：
由于使用了参数 `--unreachable`，我让 `git-fsck` 显示出所有不可访问的对象。正如你看到的，它显示并没有不可访问的对象。而当我从 stash 中删除了我的更改之后，再次执行相同的指令，得到了一个不一样的输出：
现在有三个不可访问对象。那么哪一个才是我的更改呢？实际上，我不知道。我需要通过执行命令 `git show` 来搜索每一个对象。
就是它！ID 号 `95ccbd927ad4cd413ee2a28014c81454f4ede82c` 对应了我的更改。现在我已经找到了丢失的更改，我可以恢复它。其中一种方法是将此 ID 取出来放进一个新的分支，或者直接提交它。如果你得到了你的更改对象的 ID 号，就可以决定以最好的方式，将更改再次恢复应用到主分支上。对于这个例子，我使用 `git stash` 将更改恢复到我的主分支上。
```
git stash apply 95ccbd927ad4cd413ee2a28014c81454f4ede82c
```
另外需要重点记住的是 `git` 会周期性地执行它的垃圾回收程序（`gc`），它执行之后，使用 `git fsck` 就不能再看到不可访问对象了。
*本文[最初发表](http://jvanz.com/recovering-missed-data-from-stash.html#recovering-missed-data-from-stash)于作者的博客，并得到了转载授权。*
（题图：opensource.com，附图：José Guilherme Vanz, [CC BY](https://creativecommons.org/licenses/by/4.0/)）
---
via: <https://opensource.com/article/17/8/recover-dropped-data-stash>
作者：[Jose Guilherme Vanz](https://opensource.com/users/jvanz) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
六个优雅的 Linux 命令行技巧
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3219684/linux/half-a-dozen-clever-linux-command-line-tricks.html
|
使用 Linux 命令工作可以获得许多乐趣，但是如果您使用一些命令，它们可以减少您的工作或以有趣的方式显示信息时，您将获得更多的乐趣。
|
/data/attachment/album/201708/29/231508v5fzz98954s9ffd4.jpg.thumb.jpg
|
/data/attachment/album/201708/29/231508v5fzz98954s9ffd4.jpg
| true | false | true |
firmianay
| false |
[
"命令行"
] |
技术
|
{
"viewnum": 15126,
"commentnum": 2,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "118.122.120.11",
"message": "建议还是依照原标题进行翻译（六个灵巧的），感觉现在“优雅”这个词有用滥的趋势，其含义已经偏向于“自我沉浸，自我陶醉”。",
"username": "来自四川成都的 Chrome 60.0|GNU/Linux 用户",
"date": "2017-08-30T09:06:47"
},
{
"postip": "183.14.135.31",
"message": "灵巧的 watch",
"username": "何亮 [Chrome 59.0|Windows 7]",
"date": "2017-08-30T18:27:29"
}
] |
[] |
使用 Linux 命令工作可以获得许多乐趣，但是如果您使用一些命令，它们可以减少您的工作或以有趣的方式显示信息时，您将获得更多的乐趣。
| 2017-08-30T08:13:00 | 2017-08-30T08:13:00 | 8,820 |
/article-8820-1.html
|
>
> 一些非常有用的命令能让命令行的生活更满足
>
>
>
使用 Linux 命令工作可以获得许多乐趣，但是如果您使用一些命令，它们可以减少您的工作或以有趣的方式显示信息时，您将获得更多的乐趣。在今天的文章中，我们将介绍六个命令，它们可能会使你用在命令行上的时间更加值当。
### watch
`watch` 命令会重复运行您给出的任何命令，并显示输出。默认情况下，它每两秒运行一次命令。命令的每次运行都将覆盖上一次运行时显示的内容，因此您始终可以看到最新的数据。
您可能会在等待某人登录时使用它。在这种情况下，您可以使用 `watch who` 命令或者 `watch -n 15 who` 命令使每 15 秒运行一次，而不是两秒一次。另外终端窗口的右上角会显示日期和时间。
```
$ watch -n 5 who
Every 5.0s: who stinkbug: Wed Aug 23 14:52:15 2017
shs pts/0 2017-08-23 14:45 (192.168.0.11)
zoe pts/1 2017-08-23 08:15 (192.168.0.19)
```
您也可以使用它来查看日志文件。如果您显示的数据没有任何变化，则只有窗口角落里的日期和时间会发生变化。
```
$ watch tail /var/log/syslog
Every 2.0s: tail /var/log/syslog stinkbug: Wed Aug 23 15:16:37 2017
Aug 23 14:45:01 stinkbug CRON[7214]: (root) CMD (command -v debian-sa1 > /dev/nu
ll && debian-sa1 1 1)
Aug 23 14:45:17 stinkbug systemd[1]: Started Session 179 of user shs.
Aug 23 14:55:01 stinkbug CRON[7577]: (root) CMD (command -v debian-sa1 > /dev/nu
ll && debian-sa1 1 1)
Aug 23 15:05:01 stinkbug CRON[7582]: (root) CMD (command -v debian-sa1 > /dev/nu
ll && debian-sa1 1 1)
Aug 23 15:08:48 stinkbug systemd[1]: Starting Cleanup of Temporary Directories...
Aug 23 15:08:48 stinkbug systemd-tmpfiles[7584]: [/usr/lib/tmpfiles.d/var.conf:1
4] Duplicate line for path "/var/log", ignoring.
Aug 23 15:08:48 stinkbug systemd[1]: Started Cleanup of Temporary Directories.
Aug 23 15:13:41 stinkbug systemd[1]: Started Session 182 of user shs.
Aug 23 15:14:29 stinkbug systemd[1]: Started Session 183 of user shs.
Aug 23 15:15:01 stinkbug CRON[7828]: (root) CMD (command -v debian-sa1 > /dev/nu
ll && debian-sa1 1 1)
```
这里的输出和使用命令 `tail -f /var/log/syslog` 的输出相似。
### look
这个命令的名字 `look` 可能会让我们以为它和 `watch` 做类似的事情，但其实是不同的。`look` 命令用于搜索以某个特定字符串开头的单词。
```
$ look ecl
eclectic
eclectic's
eclectically
eclecticism
eclecticism's
eclectics
eclipse
eclipse's
eclipsed
eclipses
eclipsing
ecliptic
ecliptic's
```
`look` 命令通常有助于单词的拼写，它使用 `/usr/share/dict/words` 文件，除非你使用如下的命令指定了文件名：
```
$ look esac .bashrc
esac
esac
esac
```
在这种情况下，它的作用就像跟在一个 `awk` 命令后面的 `grep` ，只打印匹配行上的第一个单词。
### man -k
`man -k` 命令列出包含指定单词的手册页。它的工作基本上和 `apropos` 命令一样。
```
$ man -k logrotate
dh_installlogrotate (1) - install logrotate config files
logrotate (8) - rotates, compresses, and mails system logs
logrotate.conf (5) - rotates, compresses, and mails system logs
```
### help
当你完全绝望的时候，您可能会试图使用此命令，`help` 命令实际上是显示一个 shell 内置命令的列表。最令人惊讶的是它有相当多的参数变量。你可能会看到这样的东西，然后开始想知道这些内置功能可以为你做些什么：
```
$ help
GNU bash, version 4.4.7(1)-release (i686-pc-linux-gnu)
These shell commands are defined internally. Type `help' to see this list.
Type `help name' to find out more about the function `name'.
Use `info bash' to find out more about the shell in general.
Use `man -k' or `info' to find out more about commands not in this list.
A star (*) next to a name means that the command is disabled.
job_spec [&] history [-c] [-d offset] [n] or hist>
(( expression )) if COMMANDS; then COMMANDS; [ elif C>
. filename [arguments] jobs [-lnprs] [jobspec ...] or jobs >
: kill [-s sigspec | -n signum | -sigs>
[ arg... ] let arg [arg ...]
[[ expression ]] local [option] name[=value] ...
alias [-p] [name[=value] ... ] logout [n]
bg [job_spec ...] mapfile [-d delim] [-n count] [-O or>
bind [-lpsvPSVX] [-m keymap] [-f file> popd [-n] [+N | -N]
break [n] printf [-v var] format [arguments]
builtin [shell-builtin [arg ...]] pushd [-n] [+N | -N | dir]
caller [expr] pwd [-LP]
case WORD in [PATTERN [| PATTERN]...)> read [-ers] [-a array] [-d delim] [->
cd [-L|[-P [-e]] [-@]] [dir] readarray [-n count] [-O origin] [-s>
command [-pVv] command [arg ...] readonly [-aAf] [name[=value] ...] o>
compgen [-abcdefgjksuv] [-o option] [> return [n]
complete [-abcdefgjksuv] [-pr] [-DE] > select NAME [in WORDS ... ;] do COMM>
compopt [-o|+o option] [-DE] [name ..> set [-abefhkmnptuvxBCHP] [-o option->
continue [n] shift [n]
coproc [NAME] command [redirections] shopt [-pqsu] [-o] [optname ...]
declare [-aAfFgilnrtux] [-p] [name[=v> source filename [arguments]
dirs [-clpv] [+N] [-N] suspend [-f]
disown [-h] [-ar] [jobspec ... | pid > test [expr]
echo [-neE] [arg ...] time [-p] pipeline
enable [-a] [-dnps] [-f filename] [na> times
eval [arg ...] trap [-lp] [[arg] signal_spec ...]
exec [-cl] [-a name] [command [argume> true
exit [n] type [-afptP] name [name ...]
export [-fn] [name[=value] ...] or ex> typeset [-aAfFgilnrtux] [-p] name[=v>
false ulimit [-SHabcdefiklmnpqrstuvxPT] [l>
fc [-e ename] [-lnr] [first] [last] o> umask [-p] [-S] [mode]
fg [job_spec] unalias [-a] name [name ...]
for NAME [in WORDS ... ] ; do COMMAND> unset [-f] [-v] [-n] [name ...]
for (( exp1; exp2; exp3 )); do COMMAN> until COMMANDS; do COMMANDS; done
function name { COMMANDS ; } or name > variables - Names and meanings of so>
getopts optstring name [arg] wait [-n] [id ...]
hash [-lr] [-p pathname] [-dt] [name > while COMMANDS; do COMMANDS; done
help [-dms] [pattern ...] { COMMANDS ; }
```
### stat -c
`stat` 命令用于显示文件的大小、所有者、用户组、索引节点号、权限、修改和访问时间等重要的统计信息。这是一个非常有用的命令，可以显示比 `ls -l` 更多的细节。
```
$ stat .bashrc
File: .bashrc
Size: 4048 Blocks: 8 IO Block: 4096 regular file
Device: 806h/2054d Inode: 421481 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 1000/ shs) Gid: ( 1000/ shs)
Access: 2017-08-23 15:13:41.781809933 -0400
Modify: 2017-06-21 17:37:11.875157790 -0400
Change: 2017-06-21 17:37:11.899157791 -0400
Birth: -
```
使用 `-c` 选项，您可以指定要查看的字段。例如，如果您只想查看一个文件或一系列文件的文件名和访问权限，则可以这样做：
```
$ stat -c '%n %a' .bashrc
.bashrc 644
```
在此命令中， `%n` 表示每个文件的名称，而 `%a` 表示访问权限。`%u` 表示数字类型的 UID，而 `%U` 表示用户名。
```
$ stat -c '%n %a' bin/*
bin/loop 700
bin/move2nohup 700
bin/nohup.out 600
bin/show_release 700
$ stat -c '%n %a %U' bin/*
bin/loop 700 shs
bin/move2nohup 700 shs
bin/nohup.out 600 root
bin/show_release 700 shs
```
### TAB
如果你没有使用过 tab 键来补全文件名，你真的错过了一个非常有用的命令行技巧。tab 键提供文件名补全功能（包括使用 `cd` 时的目录）。它在出现歧义之前尽可能多的填充文件名（多个文件以相同的字母开头。如果您有一个名为 `bigplans` 的文件，另一个名为 `bigplans2017` 的文件会发生歧义，你将听到一个声音，然后需要决定是按下回车键还是输入 `2` 之后再按下 tab 键选择第二个文件。
（题图：[Micah Elizabeth Scott](https://www.flickr.com/photos/micahdowty/4630801442/in/photolist-84d4Wb-p29iHU-dscgLx-pXKT7a-pXKT7v-azMz3V-azMz7M-4Amp2h-6iyQ51-4nf4VF-5C1gt6-6P4PwG-po6JEA-p6C5Wg-6RcRbH-7GAmbK-dCkRnT-7ETcBp-4Xbhrw-dXrN8w-dXm83Z-dXrNvQ-dXrMZC-dXrMPN-pY4GdS-azMz8X-bfNoF4-azQe61-p1iUtm-87i3vj-7enNsv-6sqvJy-dXm8aD-6smkyX-5CFfGm-dXm8dD-6sqviw-6sqvVU-dXrMVd-6smkXc-dXm7Ug-deuxUg-6smker-Hd15p-6squyf-aGtnxn-6smjRX-5YtTUN-nynqYm-ea5o3c) [(CC BY 2.0)](https://creativecommons.org/licenses/by/2.0/legalcode)）
---
via: <https://www.networkworld.com/article/3219684/linux/half-a-dozen-clever-linux-command-line-tricks.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 译者：[firmianay](https://github.com/firmianay) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
通过开源书籍学习 Ruby 编程
|
Steve Emms
|
https://www.ossblog.org/study-ruby-programming-with-open-source-books/
|
这篇文章有 9 本很优秀的推荐书籍，有针对包括初学者、中级程序员和高级程序员的书籍。当然，所有的书籍都是在开源许可下发布的。
|
/data/attachment/album/201708/29/235444vzj5tdym77o0dmc6.jpg.thumb.jpg
|
/data/attachment/album/201708/29/235444vzj5tdym77o0dmc6.jpg
| true | false | true |
ucasFL
| false |
[
"Ruby",
"书籍"
] |
分享
|
{
"viewnum": 6969,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这篇文章有 9 本很优秀的推荐书籍，有针对包括初学者、中级程序员和高级程序员的书籍。当然，所有的书籍都是在开源许可下发布的。
| 2017-08-30T09:52:00 | 2017-08-30T09:52:00 | 8,821 |
/article-8821-1.html
|
### 开源的 Ruby 书籍
Ruby 是由 Yukihiro “Matz” Matsumoto 开发的一门通用目的、脚本化、结构化、灵活且完全面向对象的编程语言。它具有一个完全动态类型系统，这意味着它的大多数类型检查是在运行的时候进行，而非编译的时候。因此程序员不必过分担心是整数类型还是字符串类型。Ruby 会自动进行内存管理，它具有许多和 Python、Perl、Lisp、Ada、Eiffel 和 Smalltalk 相同的特性。
Ruby on Rails 框架对于 Ruby 的流行起到了重要作用，它是一个全栈 Web 框架，目前已被用来创建许多受欢迎的应用，包括 Basecamp、GitHub、Shopify、Airbnb、Twitch、SoundCloud、Hulu、Zendesk、Square 和 Highise 。
Ruby 具有很高的可移植性性，在 Linux、Windows、Mac OS X、Cygwin、FreeBSD、NetBSD、OpenBSD、BSD/OS、Solaris、Tru64 UNIX、HP-UX 以及其他许多系统上均可运行。目前，Ruby 在 TIOBE 编程社区排名 12 。
这篇文章有 9 本很优秀的推荐书籍，有针对包括初学者、中级程序员和高级程序员的书籍。当然，所有的书籍都是在开源许可下发布的。
这篇文章是 [OSSBlog 的系列文章开源编程书籍](https://www.ossblog.org/opensourcebooks/)的一部分。
### 《[Ruby Best Practices](https://github.com/practicingruby/rbp-book/tree/gh-pages/pdfs)》
作者： Gregory Brown (328 页)
《Ruby Best Practices》适合那些希望像有经验的 Ruby 专家一样使用 Ruby 的程序员。本书是由 Ruby 项目 Prawn 的开发者所撰写的，它阐述了如何使用 Ruby 设计美丽的 API 和特定领域语言，以及如何利用函数式编程想法和技术，从而简化代码，提高效率。
《Ruby Best Practices》 更多的内容是关于如何使用 Ruby 来解决问题，它阐述的是你应该使用的最佳解决方案。这本书不是针对 Ruby 初学者的，所以对于编程新手也不会有太多帮助。这本书的假想读者应该对 Ruby 的相应技术有一定理解，并且拥有一些使用 Ruby 来开发软件的经验。
这本书分为两部分，前八章组成本书的核心部分，后三章附录作为补充材料。
这本书提供了大量的信息：
* 通过测试驱动代码 - 涉及了大量的测试哲学和技术。使用 mocks 和 stubs
* 通过利用 Ruby 神秘的力量来设计漂亮的 API：灵活的参数处理和代码块
* 利用动态工具包向开发者展示如何构建灵活的界面，实现单对象行为，扩展和修改已有代码，以及程序化地构建类和模块
* 文本处理和文件管理集中于正则表达式，文件、临时文件标准库以及文本处理策略实战
* 函数式编程技术优化了模块代码组织、存储、无穷目录以及更高顺序程序。
* 理解代码如何出错以及为什么会出错，阐述如何处理日志记录
* 通过利用 Ruby 的多语言能力削弱文化屏障
* 熟练的项目维护
本书为开源书籍，在 CC NC-SA 许可证下发布。
[在此下载《Ruby Best Practices》](https://github.com/practicingruby/rbp-book/tree/gh-pages/pdfs)。
### 《[I Love Ruby](https://mindaslab.github.io/I-Love-Ruby/)》
作者： Karthikeyan A K (246 页)
《I Love Ruby》以比传统的介绍更高的深度阐述了基本概念和技术。该方法为编写有用、正确、易维护和高效的 Ruby 代码提供了一个坚实的基础。
章节内容涵盖：
* 变量
* 字符串
* 比较和逻辑
* 循环
* 数组
* 哈希和符号
* Ranges
* 函数
* 变量作用域
* 类 & 对象
* Rdoc
* 模块和 Mixins
* 日期和时间
* 文件
* Proc、匿名 和 块
* 多线程
* 异常处理
* 正则表达式
* Gems
* 元编程
在 GNU 自由文档许可证之下，你可以复制、发布和修改本书，1.3 或任何之后版本由自由软件基金会发布。
[点此下载《I Love Ruby》](https://mindaslab.github.io/I-Love-Ruby/)。
### [Programming Ruby – The Pragmatic Programmer’s Guide](http://ruby-doc.com/docs/ProgrammingRuby/)
作者： David Thomas, Andrew Hunt (HTML)
《Programming Ruby – The Pragmatic Programmer’s Guide》是一本 Ruby 编程语言的教程和参考书。使用 Ruby，你将能够写出更好的代码，更加有效率，并且使编程变成更加享受的体验。
内容涵盖以下部分：
* 类、对象和变量
* 容器、块和迭代器
* 标准类型
* 更多方法
* 表达式
* 异常、捕获和抛出
* 模块
* 基本输入和输出
* 线程和进程
* 何时抓取问题
* Ruby 和它的世界、Web、Tk 和 微软 Windows
* 扩展 Ruby
* 映像、对象空间和分布式 Ruby
* 标准库
* 面向对象设计库
* 网络和 Web 库
* 嵌入式文件
* 交互式 Ruby shell
这本书的第一版在开放发布许可证 1.0 版或更新版的许可下发布。本书更新后的第二版涉及 Ruby 1.8 ，并且包括所有可用新库的描述，但是它不是在免费发行许可证下发布的。
[点此下载《Programming Ruby – The Pragmatic Programmer’s Guide》](http://ruby-doc.com/docs/ProgrammingRuby/)。
### 《[Why’s (Poignant) Guide to Ruby](http://poignant.guide/)》
作者：why the lucky stiff (176 页)
《Why’s (poignant) Guide to Ruby》是一本 Ruby 编程语言的介绍书籍。该书包含一些冷幽默，偶尔也会出现一些和主题无关的内容。本书包含的笑话在 Ruby 社区和卡通角色中都很出名。
本书的内容包括：
* 关于本书
* Kon’nichi wa, Ruby
* 一个快速（希望是无痛苦的）的 Ruby 浏览（伴随卡通角色）：Ruby 核心概念的基本介绍
* 代码浮动小叶：评估和值，哈希和列表
* 组成规则的核心部分：case/when、while/until、变量作用域、块、方法、类定义、类属性、对象、模块、IRB 中的内省、dup、self 和 rbconfig 模块
* 中心：元编程、正则表达式
* 当你打算靠近胡须时：在已存在类中发送一个新方法
* 天堂演奏
本书在 CC-SA 许可证许可下可用。
[点此下载《Why’s (poignant) Guide to Ruby》](http://poignant.guide/)。
### 《[Ruby Hacking Guide](http://ruby-hacking-guide.github.io/)》
作者： Minero Aoki ，翻译自 Vincent Isambart 和 Clifford Escobar Caoille (HTML)
通过阅读本书可以达成下面的目标：
* 拥有关于 Ruby 结构的知识
* 掌握一般语言处理的知识
* 收获阅读源代码的技能
本书分为四个部分：
* 对象
* 动态分析
* 评估
* 外部评估
要想从本书中收获最多的东西，需要具备一定 C 语言的知识和基本的面向对象编程知识。本书在 CC-NC-SA 许可证许可下发布。
原书的官方支持网站为 [i.loveruby.net/ja/rhg/](http://i.loveruby.net/ja/rhg/)
[点此下载《Ruby Hacking Guide》](http://ruby-hacking-guide.github.io/)
### 《[The Book Of Ruby](http://www.sapphiresteel.com/ruby-programming/The-Book-Of-Ruby.html)》
作者： How Collingbourne (425 页)
《The Book Of Ruby》是一本免费的 Ruby 编程高级教程。
《The Book Of Ruby》以 PDF 文件格式提供，并且每一个章节的所有例子都伴有可运行的源代码。同时，也有一个介绍来阐述如何在 Steel 或其他任何你喜欢的编辑器/IDE 中运行这些 Ruby 代码。它主要集中于 Ruby 语言的 1.8.x 版本。
本书被分成很小的块。每一个章节介绍一个主题，并且分成几个不同的子话题。每一个编程主题由一个或多个小的自包含、可运行的 Ruby 程序构成。
* 字符串、数字、类和对象 - 获取输入和输出、字符串和外部评估、数字和条件测试：if ... then、局部变量和全局变量、类和对象、实例变量、消息、方法、多态性、构造器和检属性和类变量 - 超类和子类，超类传参，访问器方法，’set‘ 访问器，属性读写器、超类的方法调用，以及类变量
* 类等级、属性和类变量 - 超类和子类，超类传参，访问器方法，’set‘ 访问器，属性读写器、超类的方法调用，以及类变量
* 字符串和 Ranges - 用户自定义字符串定界符、引号等更多
* 数组和哈希 - 展示如何创建一系列对象
* 循环和迭代器 - for 循环、代码块、while 循环、while 修改器以及 until 循环
* 条件语句 - If..Then..Else、And..Or..Not、If..Elsif、unless、if 和 unless 修改器、以及 case 语句
* 方法 - 类方法、类变量、类方法是用来干什么的、Ruby 构造器、单例方法、单例类、重载方法以及更多
* 传递参数和返回值 - 实例方法、类方法、单例方法、返回值、返回多重值、默认参数和多重参数、赋值和常量传递以及更多
* 异常处理 - 涉及 rescue、ensure、else、错误数量、retry 和 raise
* 块、Procs 和 匿名 - 阐述为什么它们对 Ruby 来说很特殊
* 符号 - 符号和字符串、符号和变量以及为什么应该使用符号
* 模块和 Mixins
* 文件和 IO - 打开和关闭文件、文件和目录、复制文件、目录询问、一个关于递归的讨论以及按大小排序
* YAML - 包括嵌套序列，保存 YAML 数据以及更多
* Marshal - 提供一个保存和加载数据的可选择方式
* 正则表达式 - 进行匹配、匹配群组以及更多
* 线程 - 向你展示如何同时运行多个任务
* 调试和测试 - 涉及交互式 Ruby shell（IRB.exe）、debugging 和 单元测试
* Ruby on Rails - 浏览一个创建博客的实践指南
* 动态编程 - 自修改程序、重运算魔法、特殊类型的运算、添加变量和方法以及更多
本书由 SapphireSteel Software 发布，SapphireSteel Software 是用于 Visual Studio 的 Ruby In Steel 集成开发环境的开发者。读者可以复制和发布本书的文本和代码（免费版）
[点此下载《The Book Of Ruby》](http://www.sapphiresteel.com/ruby-programming/The-Book-Of-Ruby.html)
### 《[The Little Book Of Ruby](http://www.sapphiresteel.com/ruby-programming/The-Book-Of-Ruby.html)》
作者： Huw Collingbourne (87 页)
《The Little Book of Ruby》是一本一步接一步的 Ruby 编程教程。它指导读者浏览 Ruby 的基础。另外，它分享了《The Book of Ruby》一书的内容，但是它旨在作为一个简化的教程来阐述 Ruby 的主要特性。
章节内容涵盖：
* 字符串和方法 - 包括外部评估。详细描述了 Ruby 方法的语法
* 类和对象 - 阐述如何创建一个新类型的对象
* 类等级 - 一个特殊类型的类，其为一些其他类的简化并且继承了其他一些类的特性
* 访问器、属性、类变量 - 访问器方法，属性读写器，属性创建变量，调用超类方法以及类变量探索
* 数组 - 学习如何创建一系列对象：数组包括多维数组
* 哈希 - 涉及创建哈希表，为哈希表建立索引以及哈希操作等
* 循环和迭代器 - for 循环、块、while 循环、while 修饰器以及 until 循环
* 条件语句 - If..Then..Else、And..Or..Not、If..Elsif、unless、if 和 unless 修饰器以及 case 语句
* 模块和 Mixins - 包括模块方法、模块作为名字空间模块实例方法、模块或 'mixins'、来自文件的模块和预定义模块
* 保存文件以及更多内容
本书可免费复制和发布，只需保留原始文本且注明版权信息。
[点此下载《The Little Book of Ruby》](http://www.sapphiresteel.com/ruby-programming/The-Book-Of-Ruby.html)
### 《[Kestrels, Quirky Birds, and Hopeless Egocentricity](https://leanpub.com/combinators)》
作者： Reg “raganwald” Braithwaite (123 页)
《Kestrels, Quirky Birds, and Hopeless Egocentricity》是通过收集 “Raganwald” Braithwaite 的关于组合逻辑、Method Combinators 以及 Ruby 元编程的系列文章而形成的一本方便的电子书。
本书提供了通过使用 Ruby 编程语言来应用组合逻辑的一个基本介绍。组合逻辑是一种数学表示方法，它足够强大，从而用于解决集合论问题以及计算中的问题。
在这本书中，读者会会探讨到一些标准的 Combinators，并且对于每一个 Combinators，书中都用 Ruby 编程语言写程序探讨了它的一些结果。在组合逻辑上，Combinators 之间组合并相互改变，书中的 Ruby 例子注重组合和修改 Ruby 代码。通过像 K Combinator 和 .tap 方法这样的简单例子，本书阐述了元编程的理念和递归 Combinators 。
本书在 MIT 许可证许可下发布。
[点此下载《Kestrels, Quirky Birds, and Hopeless Egocentricity》](https://leanpub.com/combinators)
### 《[Ruby Programming](https://en.wikibooks.org/wiki/Ruby_Programming)》
作者： Wikibooks.org (261 页)
Ruby 是一种解释性、面向对象的编程语言。
本书被分为几个部分，从而方便按顺序阅读。
* 开始 - 向读者展示如何在其中一个操作系统环境中安装并开始使用 Ruby
* Ruby 基础 - 阐述 Ruby 语法的主要特性。它涵盖了字符串、编码、写方法、类和对象以及异常等内容
* Ruby 语义参考
* 内建类
* 可用模块，涵盖一些标准库
* 中级 Ruby 涉及一些稍微高级的话题
本书在 CC-SA 3.0 本地化许可证许可下发布。
[点此下载《Ruby Programming》](https://en.wikibooks.org/wiki/Ruby_Programming)
---
无特定顺序，我将在结束前推荐一些没有在开源许可证下发布但可以免费下载的 Ruby 编程书籍。
* [Mr. Neighborly 的 Humble Little Ruby Book](http://www.humblelittlerubybook.com/) – 一个易读易学的 Ruby 完全指南。
* [Introduction to Programming with Ruby](https://launchschool.com/books/ruby) – 学习编程的基础知识，一切从零开始。
* [Object Oriented Programming with Ruby](https://launchschool.com/books/oo_ruby) – 学习编程的基础知识，一切从零开始。
* [Core Ruby Tools](https://launchschool.com/books/core_ruby_tools) – 对 Ruby 的四个核心工具 Gems、Ruby Version Managers、Bundler 和 Rake 进行了简短的概述。
* [Learn Ruby the Hard Way, 3rd Edition](https://learnrubythehardway.org/book/) – 一本适合初学者的入门书籍。
* [Learn to Program](https://pine.fm/LearnToProgram) – 来自 Chris Pine。
* [Ruby Essentials](http://www.techotopia.com/index.php/Ruby_Essentials) – 一个准确且简单易学的 Ruby 学习指南。
---
via: <https://www.ossblog.org/study-ruby-programming-with-open-source-books/>
作者：[Steve Emms](https://www.ossblog.org/author/steve/) 译者：[ucasFL](https://github.com/ucasFL) 校对：[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.