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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
介绍 Flashback，一个互联网模拟工具
|
Shangshang Feng
|
https://opensource.com/article/17/4/flashback-internet-mocking-tool
|
Flashback 用于测试目的来模拟 HTTP 和 HTTPS 资源，如 Web 服务和 REST API。
|
/data/attachment/album/201710/15/215549qf6816w11zwjpkwz.jpeg.thumb.jpg
|
/data/attachment/album/201710/15/215549qf6816w11zwjpkwz.jpeg
| true
| false
| true
|
geekpi
| false
|
[
"Flashback",
"测试"
] |
技术
|
{
"viewnum": 6844,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Flashback 用于测试目的来模拟 HTTP 和 HTTPS 资源，如 Web 服务和 REST API。
| 2017-10-15T21:56:00
| 2017-10-15T21:56:00
| 8,963
|
/article-8963-1.html
|
>
> Flashback 用于测试目的来模拟 HTTP 和 HTTPS 资源，如 Web 服务和 REST API。
>
>
>
在 LinkedIn，我们经常开发需要与第三方网站交互的 Web 应用程序。我们还采用自动测试，以确保我们的软件在发布到生产环境之前的质量。然而，测试只是在它可靠时才有用。
考虑到这一点，有外部依赖关系的测试是有很大的问题的，例如在第三方网站上。这些外部网站可能会没有通知地发生改变、遭受停机，或者由于互联网的不可靠性暂时无法访问。
如果我们的一个测试依赖于能够与第三方网站通信，那么任何故障的原因都很难确定。失败可能是因为 LinkedIn 的内部变更、第三方网站的维护人员进行的外部变更，或网络基础设施的问题。你可以想像，与第三方网站的交互可能会有很多失败的原因，因此你可能想要知道，我将如何处理这个问题？
好消息是有许多互联网模拟工具可以帮助。其中一个是 [Betamax](https://github.com/betamaxteam/betamax)。它通过拦截 Web 应用程序发起的 HTTP 连接，之后进行重放的方式来工作。对于测试，Betamax 可以用以前记录的响应替换 HTTP 上的任何交互，它可以非常可靠地提供这个服务。
最初，我们选择在 LinkedIn 的自动化测试中使用 Betamax。它工作得很好，但我们遇到了一些问题：
* 出于安全考虑，我们的测试环境没有接入互联网。然而，与大多数代理一样，Betamax 需要 Internet 连接才能正常运行。
* 我们有许多需要使用身份验证协议的情况，例如 OAuth 和 OpenId。其中一些协议需要通过 HTTP 进行复杂的交互。为了模拟它们，我们需要一个复杂的模型来捕获和重放请求。
为了应对这些挑战，我们决定基于 Betamax 的思路，构建我们自己的互联网模拟工具，名为 Flashback。我们也很自豪地宣布 Flashback 现在是开源的。
### 什么是 Flashback?
Flashback 用于测试目的来模拟 HTTP 和 HTTPS 资源，如 Web 服务和 [REST](https://en.wikipedia.org/wiki/Representational_state_transfer) API。它记录 HTTP/HTTPS 请求并重放以前记录的 HTTP 事务 - 我们称之为“<ruby> 场景 <rt> scene </rt></ruby>”，这样就不需要连接到 Internet 才能完成测试。
Flashback 也可以根据请求的部分匹配重放场景。它使用的是“匹配规则”。匹配规则将传入请求与先前记录的请求相关联，然后将其用于生成响应。例如，以下代码片段实现了一个基本匹配规则，其中测试方法“匹配”[此 URL](https://gist.github.com/anonymous/91637854364287b38897c0970aad7451)的传入请求。
HTTP 请求通常包含 URL、方法、标头和正文。Flashback 允许为这些组件的任意组合定义匹配规则。Flashback 还允许用户向 URL 查询参数，标头和正文添加白名单或黑名单标签。
例如，在 OAuth 授权流程中，请求查询参数可能如下所示：
```
oauth_consumer_key="jskdjfljsdklfjlsjdfs",
oauth_nonce="ajskldfjalksjdflkajsdlfjasldfja;lsdkj",
oauth_signature="asdfjaklsdjflasjdflkajsdklf",
oauth_signature_method="HMAC-SHA1",
oauth_timestamp="1318622958",
oauth_token="asdjfkasjdlfajsdklfjalsdjfalksdjflajsdlfa",
oauth_version="1.0"
```
这些值许多将随着每个请求而改变，因为 OAuth 要求客户端每次为 `oauth_nonce` 生成一个新值。在我们的测试中，我们需要验证 `oauth_consumer_key`、`oauth_signature_method` 和 `oauth_version` 的值，同时确保 `oauth_nonce`、`oauth_signature`、`oauth_timestamp` 和 `oauth_token` 存在于请求中。Flashback 使我们有能力创建我们自己的匹配规则来实现这一目标。此功能允许我们测试随时间变化的数据、签名、令牌等的请求，而客户端没有任何更改。
这种灵活的匹配和在不连接互联网的情况下运行的功能是 Flashback 与其他模拟解决方案不同的特性。其他一些显著特点包括：
* Flashback 是一种跨平台和跨语言解决方案，能够测试 JVM（Java虚拟机）和非 JVM（C++、Python 等）应用程序。
* Flashback 可以随时生成 SSL/TLS 证书，以模拟 HTTPS 请求的安全通道。
### 如何记录 HTTP 事务
使用 Flashback 记录 HTTP 事务以便稍后重放是一个比较简单的过程。在我们深入了解流程之前，我们首先列出一些术语：
* `Scene` ：场景存储以前记录的 HTTP 事务 (以 JSON 格式)，它可以在以后重放。例如，这里是一个[Flashback 场景](https://gist.github.com/anonymous/17d226050d8a9b79746a78eda9292382)示例。
* `Root Path` ：根路径是包含 Flashback 场景数据的目录的文件路径。
* `Scene Name` ：场景名称是给定场景的名称。
* `Scene Mode` ：场景模式是使用场景的模式, 即“录制”或“重放”。
* `Match Rule` ：匹配规则确定传入的客户端请求是否与给定场景的内容匹配的规则。
* `Flashback Proxy` ：Flashback 代理是一个 HTTP 代理，共有录制和重放两种操作模式。
* `Host` 和 `Port` ：代理主机和端口。
为了录制场景，你必须向目的地址发出真实的外部请求，然后 HTTPS 请求和响应将使用你指定的匹配规则存储在场景中。在录制时，Flashback 的行为与典型的 MITM（中间人）代理完全相同 - 只有在重放模式下，连接流和数据流仅限于客户端和代理之间。
要实际看下 Flashback，让我们创建一个场景，通过执行以下操作捕获与 example.org 的交互：
1、 取回 Flashback 的源码：
```
git clone https://github.com/linkedin/flashback.git
```
2、 启动 Flashback 管理服务器：
```
./startAdminServer.sh -port 1234
```
3、 注意上面的 Flashback 将在本地端口 5555 上启动录制模式。匹配规则需要完全匹配（匹配 HTTP 正文、标题和 URL）。场景将存储在 `/tmp/test1` 下。
4、 Flashback 现在可以记录了，所以用它来代理对 example.org 的请求：
```
curl http://www.example.org -x localhost:5555 -X GET
```
5、 Flashback 可以（可选）在一个记录中记录多个请求。要完成录制，[关闭 Flashback](https://gist.github.com/anonymous/f899ebe7c4246904bc764b4e1b93c783)。
6、 要验证已记录的内容，我们可以在输出目录（`/tmp/test1`）中查看场景的内容。它应该[包含以下内容](https://gist.github.com/sf1152/c91d6d62518fe62cc87157c9ce0e60cf)。
[在 Java 代码中使用 Flashback](https://gist.github.com/anonymous/fdd972f1dfc7363f4f683a825879ce19)也很容易。
### 如何重放 HTTP 事务
要重放先前存储的场景，请使用与录制时使用的相同的基本设置。唯一的区别是[将“场景模式”设置为上述步骤 3 中的“播放”](https://gist.github.com/anonymous/ae1c519a974c3bc7de2a925254b6550e)。
验证响应来自场景而不是外部源的一种方法，是在你执行步骤 1 到 6 时临时禁用 Internet 连接。另一种方法是修改场景文件，看看响应是否与文件中的相同。
这是 [Java 中的一个例子](https://gist.github.com/anonymous/edcc1d60847d51b159c8fd8a8d0a5f8b)。
### 如何记录并重播 HTTPS 事务
使用 Flashback 记录并重放 HTTPS 事务的过程非常类似于 HTTP 事务的过程。但是，需要特别注意用于 HTTPS SSL 组件的安全证书。为了使 Flashback 作为 MITM 代理，必须创建证书颁发机构（CA）证书。在客户端和 Flashback 之间创建安全通道时将使用此证书，并允许 Flashback 检查其代理的 HTTPS 请求中的数据。然后将此证书存储为受信任的源，以便客户端在进行调用时能够对 Flashback 进行身份验证。有关如何创建证书的说明，有很多[类似这样](https://jamielinux.com/docs/openssl-certificate-authority/introduction.html)的资源是非常有帮助的。大多数公司都有自己的管理和获取证书的内部策略 - 请务必用你们自己的方法。
这里值得一提的是，Flashback 仅用于测试目的。你可以随时随地将 Flashback 与你的服务集成在一起，但需要注意的是，Flashback 的记录功能将需要存储所有的数据，然后在重放模式下使用它。我们建议你特别注意确保不会无意中记录或存储敏感成员数据。任何可能违反贵公司数据保护或隐私政策的行为都是你的责任。
一旦涉及安全证书，HTTP 和 HTTPS 之间在记录设置方面的唯一区别是添加了一些其他参数。
* `RootCertificateInputStream`： 表示 CA 证书文件路径或流。
* `RootCertificatePassphrase`： 为 CA 证书创建的密码。
* `CertificateAuthority`： CA 证书的属性
[查看 Flashback 中用于记录 HTTPS 事务的代码](https://gist.github.com/anonymous/091d13179377c765f63d7bf4275acc11)，它包括上述条目。
用 Flashback 重放 HTTPS 事务的过程与录制相同。唯一的区别是场景模式设置为“播放”。这在[此代码](https://gist.github.com/anonymous/ec6a0fd07aab63b7369bf8fde69c1f16)中演示。
### 支持动态修改
为了测试灵活性，Flashback 允许你动态地更改场景和匹配规则。动态更改场景允许使用不同的响应（如 `success`、`time_out`、`rate_limit` 等）测试相同的请求。[场景更改](https://gist.github.com/anonymous/1f1660280acb41277fbe2c257bab2217)仅适用于我们已经 POST 更新外部资源的场景。以下图为例。
能够动态[更改匹配规则](https://gist.github.com/anonymous/0683c43f31bd916b76aff348ff87f51b)可以使我们测试复杂的场景。例如，我们有一个使用情况，要求我们测试 Twitter 的公共和私有资源的 HTTP 调用。对于公共资源，HTTP 请求是不变的，所以我们可以使用 “MatchAll” 规则。然而，对于私人资源，我们需要使用 OAuth 消费者密码和 OAuth 访问令牌来签名请求。这些请求包含大量具有不可预测值的参数，因此静态 MatchAll 规则将无法正常工作。
### 使用案例
在 LinkedIn，Flashback 主要用于在集成测试中模拟不同的互联网提供商，如下图所示。第一张图展示了 LinkedIn 生产数据中心内的一个内部服务，通过代理层，与互联网提供商（如 Google）进行交互。我们想在测试环境中测试这个内部服务。
第二和第三张图表展示了我们如何在不同的环境中录制和重放场景。记录发生在我们的开发环境中，用户在代理启动的同一端口上启动 Flashback。从内部服务到提供商的所有外部请求将通过 Flashback 而不是我们的代理层。在必要场景得到记录后，我们可以将其部署到我们的测试环境中。
在测试环境（隔离并且没有 Internet 访问）中，Flashback 在与开发环境相同的端口上启动。所有 HTTP 请求仍然来自内部服务，但响应将来自 Flashback 而不是 Internet 提供商。
### 未来方向
我们希望将来可以支持非 HTTP 协议（如 FTP 或 JDBC），甚至可以让用户使用 MITM 代理框架来自行注入自己的定制协议。我们将继续改进 Flashback 设置 API，使其更容易支持非 Java 语言。
### 现在为一个开源项目
我们很幸运能够在 GTAC 2015 上发布 Flashback。在展会上，有几名观众询问是否将 Flashback 作为开源项目发布，以便他们可以将其用于自己的测试工作。
### Google TechTalks：GATC 2015 - 模拟互联网
我们很高兴地宣布，Flashback 现在以 BSD 两句版许可证开源。要开始使用，请访问 [Flashback GitHub 仓库](https://github.com/linkedin/flashback)。
*该文原始发表在[LinkedIn 工程博客上](https://engineering.linkedin.com/blog/2017/03/flashback-mocking-tool)。获得转载许可*
### 致谢
Flashback 由 [Shangshang Feng](https://www.linkedin.com/in/shangshangfeng)、[Yabin Kang](https://www.linkedin.com/in/benykang) 和 [Dan Vinegrad](https://www.linkedin.com/in/danvinegrad/) 创建，并受到 [Betamax](https://github.com/betamaxteam/betamax) 启发。特别感谢 [Hwansoo Lee](https://www.linkedin.com/in/hwansoo/)、[Eran Leshem](https://www.linkedin.com/in/eranl/)、[Kunal Kandekar](https://www.linkedin.com/in/kunalkandekar/)、[Keith Dsouza](https://www.linkedin.com/in/dsouzakeith/) 和 [Kang Wang](https://www.linkedin.com/in/kang-wang-44960b4/) 帮助审阅代码。同样感谢我们的管理层 - [Byron Ma](https://www.linkedin.com/in/byronma/)、[Yaz Shimizu](https://www.linkedin.com/in/yazshimizu/)、[Yuliya Averbukh](https://www.linkedin.com/in/yuliya-averbukh-818a41/)、[Christopher Hazlett](https://www.linkedin.com/in/chazlett/) 和 [Brandon Duncan](https://www.linkedin.com/in/dudcat/) - 感谢他们在开发和开源 Flashback 中的支持。
---
作者简介：
Shangshang Feng - Shangshang 是 LinkedIn 纽约市办公室的高级软件工程师。在 LinkedIn 他从事了三年半的网关平台工作。在加入 LinkedIn 之前，他曾在 Thomson Reuters 和 ViewTrade 证券的基础设施团队工作。
---
via: <https://opensource.com/article/17/4/flashback-internet-mocking-tool>
作者： [Shangshang Feng](https://opensource.com/users/shangshangfeng) 译者：[geekpi](https://github.com/geekpi) 校对：[jasminepeng](https://github.com/jasminepeng)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
见多识广的人工智能比你认识更多的 XXX 明星
|
Mix
|
https://thenextweb.com/artificial-intelligence/2017/10/11/pornhub-ai-watch-tag/
|
你有没有想过，之所以能够根据自己不同兴趣的组合搜索到需要的视频，是因为有那些每日浏览无数视频内容且对它们进行分类和标记的可怜人存在，然而这些看不见的英雄们却在人工智能面前变得英雄无用武之地。
|
/data/attachment/album/201710/15/225517vmzpzkf3efpuifsz.jpeg.thumb.jpg
|
/data/attachment/album/201710/15/225517vmzpzkf3efpuifsz.jpeg
| true
| false
| true
|
dongfengweixiao
| false
|
[
"视频",
"人工智能",
"AI"
] |
新闻
|
{
"viewnum": 25672,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
你有没有想过，之所以能够根据自己不同兴趣的组合搜索到需要的视频，是因为有那些每日浏览无数视频内容且对它们进行分类和标记的可怜人存在，然而这些看不见的英雄们却在人工智能面前变得英雄无用武之地。
| 2017-10-15T22:56:00
| 2017-10-15T22:56:00
| 8,964
|
/article-8964-1.html
|
你有没有想过，之所以能够根据自己不同兴趣的组合搜索到需要的视频，是因为有那些每日浏览无数视频内容且对它们进行分类和标记的可怜人存在，然而这些看不见的英雄们却在人工智能面前变得英雄无用武之地。
世界上最大的 XXX 电影分享网站 Pornhub 宣布，它将推出新的 AI 模型，利用计算机视觉技术自动检测和识别 XXX 明星的名字。
根据 X-rated 网站的消息，目前该算法经过训练后已经通过简单的扫描和对镜头的理解，可以识别超过 1 万名 XXX 明星。Pornhub 说，通过向此 AI 模型输入数千个视频和 XXX 明星的正式照片，以让它学习如何返回准确的名字。
为了减小错误，这个成人网站将向用户求证由 AI 提供的标签和分类是否合适。用户可以根据结果的准确度，提出支持或是反对。这将会让算法变得更加智能。
“现在，用户可以根据自身喜好寻找指定的 XXX 明星，我们也能够返回给用户尽可能精确的搜索结果，” PornHub 副总裁 Corey Price 说。“毫无疑问，我们的模型也将在未来的发展中扮演关键角色，尤其是考虑到每天有超过 1 万个的视频添加到网站上。”
“事实上，在过去的一个月里，我们测试了这个模型的测试版本，它（每天）可以扫描 5 万段视频，并且向视频添加或者移除标签。”
除了识别表演者，该算法还能区分不同类别的内容：比如在 “Public” 类别下的是户外拍摄的视频，以及 “Blonde” 类别下的视频应该至少有名金发女郎。
XXX 公司计划明年在 AI 模型的帮助下，对全部 500 万个视频编目，希望能让用户更容易找到与他们的期望最接近的视频片段。
早先就有研究人员借助计算机视觉算法对 XXX 电影进行描述。之前就有一名开发者使用微软的人工智能技术来构建这个机器人，它可以整天[观察和解读](https://thenextweb.com/shareables/2017/03/03/porn-bot-microsoft-ai-pornhub/)各种内容。
Pornhub 似乎让这一想法更进一步，这些那些遍布全球的视频审看员的噩梦。
虽然人工智能被发展到这个方面可能会让你感觉有些不可思议，但 XXX 业因其对搜索引擎优化技术的狂热追求而[闻名](https://moz.com/ugc/yes-dear-there-is-porn-seo-and-we-can-learn-a-lot-from-it)。
事实上，成人内容服务一直以来都有广泛市场，且受众不分年龄，这也是这些公司盈利的重要组成部分。
但是，这些每日阅片无数、兢兢业业为其分类的人们可能很快就会成为自动化威胁的牺牲品。但从好的一面看，他们终于有机会坐下来[让自动化为他们工作](https://thenextweb.com/gear/2017/07/07/fleshlight-launch-review-masturbation/)。
---
via: <https://thenextweb.com/artificial-intelligence/2017/10/11/pornhub-ai-watch-tag/>
作者：[MIX](https://thenextweb.com/author/dimitarmihov/) 译者：[东风唯笑](https://github.com/dongfengweixiao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
混合云的变化
|
Gordon Haff (red Hat)
|
https://opensource.com/article/17/7/hybrid-cloud
|
围绕云计算的概念和术语仍然很新，但是也在不断的改进。
|
/data/attachment/album/201710/16/220451s9fc07mrjq9sf39s.jpeg.thumb.jpg
|
/data/attachment/album/201710/16/220451s9fc07mrjq9sf39s.jpeg
| true
| false
| true
|
ZH1122
| false
|
[
"混合云"
] |
观点
|
{
"viewnum": 3430,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
围绕云计算的概念和术语仍然很新，但是也在不断的改进。
| 2017-10-16T22:02:00
| 2017-10-16T22:02:00
| 8,965
|
/article-8965-1.html
|
>
> 围绕云计算的概念和术语仍然很新，但是也在不断的改进。
>
>
>
不管怎么看，云计算也只有十多年的发展时间。一些我们习以为常的云计算的概念和术语仍然很新。美国国家标准与技术研究所（NIST）文档显示，一些已经被熟悉的术语定义在 2011 年才被发布，例如基础设施即服务（IaaS），而在此之前它就以草案的形式广泛流传。
在该文档中其它定义中，有一个叫做<ruby> 混合云 <rt> hybrid cloud </rt></ruby>。让我们回溯一下该术语在这段期间的变化是很有启发性的。云基础设施已经超越了相对简单的分类。此外，它还强调了开源软件的使用者所熟悉的优先级，例如灵活性、可移植性、选择性，已经被运用到了混合云上。
NIST 对混合云最初的定义主要集中于<ruby> 云爆发 <rt> cloud bursting </rt></ruby>，你能使用内部的基础设施去处理一个基本的计算负荷，但是如果你的负荷量暴涨，可以将多出来的转为使用公有云。与之密切联系的是加强私有云与公有云之间 API 的兼容性，甚至是创造一个现货市场来提供最便宜的容量。
Nick Carr 在 [The Big Switch](http://www.nicholascarr.com/?page_id=21) 一书中提出一个概念，云是一种计算单元，其与输电网类似。这个故事不错，但是即使在早期，[这种类比的局限性也变得很明显](https://www.cnet.com/news/there-is-no-big-switch-for-cloud-computing/)。计算不是以电流方式呈现的一种物品。需要关注的是，公有云提供商以及 OpenStack 一类的开源云软件激增的新功能，可见许多用户并不仅仅是寻找最便宜的通用计算能力。
云爆发的概念基本上忽略了计算是与数据相联系的现实，你不可能只移动洪水般突如其来的数据而不承担巨大的带宽费用，以及不用为转移需要花费的时间而操作。Dave McCrory 发明了 “<ruby> 数据引力 <rt> data gravity </rt></ruby>”一词去描述这个限制。
那么既然混合云有如此负面的情况，为什么我们现在还要再讨论混合云？
正如我说的，混合云的最初的构想是在云爆发的背景下诞生的。云爆发强调的是快速甚至是即时的将工作环境从一个云转移到另一个云上；然而，混合云也意味着应用和数据的移植性。确实，如之前 [2011 年我在 CNET 的文章](https://www.cnet.com/news/cloudbursting-or-just-portable-clouds/)中写到：“我认为过度关注于全自动的工作转换给我们自己造成了困扰，我们真正应该关心的是，如果供应商不能满意我们的需求或者尝试将我们锁定在其平台上时，我们是否有将数据从一个地方到另一个地方的迁移能力。”
从那以后，探索云之间的移植性有了进一步的进展。
Linux 是云移植性的关键，因为它能运行在各种地方，无论是从裸机到内部虚拟基础设施，还是从私有云到公有云。Linux 提供了一个完整、可靠的平台，其具有稳定的 API 接口，且可以依靠这些接口编写程序。
被广泛采纳的容器进一步加强了 Linux 提供应用在云之间移植的能力。通过提供一个包含了应用的基础配置环境的镜像，应用在开发、测试和最终运行环境之间移动时容器提供了可移植性和兼容性。
Linux 容器被应用到要求可移植性、可配置性以及独立性的许多方面上。不管是预置的云，还是公有云，以及混合云都是如此。
容器使用的是基于镜像的部署模式，这让在不同环境中分享一个应用或者具有全部基础环境的服务集变得容易了。
在 OCI 支持下开发的规范定义了容器镜像的内容及其所依赖、环境、参数和一些镜像正确运行所必须的要求。在标准化的作用下，OCI 为许多其它工具提供了一个机会，它们现在可以依靠稳定的运行环境和镜像规范了。
同时，通过 Gluster 和 Ceph 这类的开源技术，分布式存储能提供数据在云上的可移植性。 物理约束限制了如何快速简单地把数据从一个地方移动到另一个地方；然而，随着组织部署和使用不同类型的基础架构，他们越来越渴望一个不受物理、虚拟和云资源限制的开放的软件定义储存平台。
尤其是在数据存储需求飞速增长的情况下，由于预测分析，物联网和实时监控的趋势。[2016 年的一项研究表明](https://www.redhat.com/en/technologies/storage/vansonbourne)，98% 的 IT 决策者认为一个更敏捷的存储解决方案对他们的组织是有利的。在同一个研究中，他们列举出不恰当的存储基础设施是最令他们组织受挫的事情之一。
混合云表现出的是提供在不同计算能力和资源之间合适的移植性和兼容性。其不仅仅是将私有云和公有云同时运用在一个应用中。它是一套多种类型的服务，其中的一部分可能是你们 IT 部门建立和操作的，而另一部分可能来源于外部。
它们可能是软件即服务（SaaS）应用的混合，例如邮件和客户关系管理（CRM）。被 Kubernetes 这类开源软件协调在一起的容器平台越来越受新开发应用的欢迎。你的组织可能正在运用某一家大型云服务提供商来做一些事情。同时你也能在私有云或更加传统的内部基础设施上操作一些你自己的基础设施。
这就是现在混合云的现状，它能被归纳为两个选择，选择最合适的基础设施和服务，以及选择把应用和数据从一个地方移动到另一个你想的地方。
**相关阅读: [多重云和混合云有什么不同？](https://enterprisersproject.com/article/2017/7/multi-cloud-vs-hybrid-cloud-whats-difference)**
---
作者简介：
Gordon Haff 是红帽云的布道者，常受到业内和客户的高度赞赏，帮助红帽云组合方案的发展。他是《Computing Next: How the Cloud Opens the Future》的作者，除此之外他还有许多出版物。在红帽之前，Gordon 写了大量的研究简报，经常被纽约时报等出版物在 IT 类话题上引用，在产品和市场策略上给予客户建议。他职业生涯的早期，在 Data General 他负责将各种不同的计算机系统，从微型计算机到大型的 UNIX 服务器，引入市场。他有麻省理工学院和达特茅斯学院的工程学位，还是康奈尔大学约翰逊商学院的工商管理学硕士。
---
via: <https://opensource.com/article/17/7/hybrid-cloud>
作者：[Gordon Haff (Red Hat)](https://opensource.com/users/ghaff) 译者：[ZH1122](https://github.com/ZH1122) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何让网站不下线而从 Redis 2 迁移到 Redis 3
|
Craig Stewart
|
http://engineering.skybettingandgaming.com/2017/09/25/redis-2-to-redis-3/
|
我们最近着手升级 Redis 服务器，此升级旨在使用 Redis 3.2 提供的原生集群功能。这篇博客希望解释为什么我们要使用集群、我们遇到的问题以及我们的解决方案。
|
/data/attachment/album/201710/17/124529kghyhkcyhalsvhd3.jpg.thumb.jpg
|
/data/attachment/album/201710/17/124529kghyhkcyhalsvhd3.jpg
| true
| false
| true
|
geekpi
| false
|
[
"Redis"
] |
系统运维
|
{
"viewnum": 5461,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们最近着手升级 Redis 服务器，此升级旨在使用 Redis 3.2 提供的原生集群功能。这篇博客希望解释为什么我们要使用集群、我们遇到的问题以及我们的解决方案。
| 2017-10-17T12:45:35
| 2017-10-17T12:45:35
| 8,968
|
/article-8968-1.html
|
我们在 Sky Betting＆Gaming 中使用 [Redis](https://redis.io/) 作为共享内存缓存，用于那些需要跨 API 服务器或者 Web 服务器鉴别令牌之类的操作。在 Core Tribe 内，它用来帮助处理日益庞大的登录数量，特别是在繁忙的时候，我们在一分钟内登录数量会超过 20,000 人。这在很大程度上适用于数据存放在大量服务器的情况下（在 SSO 令牌用于 70 台 Apache HTTPD 服务器的情况下）。我们最近着手升级 Redis 服务器，此升级旨在使用 Redis 3.2 提供的原生集群功能。这篇博客希望解释为什么我们要使用集群、我们遇到的问题以及我们的解决方案。
### 在开始阶段（或至少在升级之前）
我们的传统缓存中每个缓存都包括一对 Redis 服务器，使用 keepalive 确保始终有一个主节点监听<ruby> 浮动 IP <rt> floating IP </rt></ruby>地址。当出现问题时，这些服务器对需要很大的精力来进行管理，而故障模式有时是非常各种各样的。有时，只允许读取它所持有的数据，而不允许写入的从属节点却会得到浮动 IP 地址，这种问题是相对容易诊断的，但会让无论哪个程序试图使用该缓存时都很麻烦。
### 新的应用程序
因此，这种情况下，我们需要构建一个新的应用程序，一个使用<ruby> 共享内存缓存 <rt> shared in-memory cache </rt></ruby>的应用程序，但是我们不希望对该缓存进行迂回的故障切换过程。因此，我们的要求是共享的内存缓存，没有单点故障，可以使用尽可能少的人为干预来应对多种不同的故障模式，并且在事件恢复之后也能够在很少的人为干预下恢复，一个额外的要求是提高缓存的安全性，以减少数据泄露的范围（稍后再说）。当时 Redis Sentinel 看起来很有希望，并且有许多程序支持代理 Redis 连接，比如 [twemproxy](https://github.com/twitter/twemproxy)。这会导致还要安装其它很多组件，它应该有效，并且人际交互最少，但它复杂而需要运行大量的服务器和服务，并且相互通信。
将会有大量的应用服务器与 twemproxy 进行通信，这会将它们的调用路由到合适的 Redis 主节点，twemproxy 将从 sentinal 集群获取主节点的信息，它将控制哪台 Redis 实例是主，哪台是从。这个设置是复杂的，而且仍有单点故障，它依赖于 twemproxy 来处理分片，来连接到正确的 Redis 实例。它具有对应用程序透明的优点，所以我们可以在理论上做到将现有的应用程序转移到这个 Redis 配置，而不用改变应用程序。但是我们要从头开始构建一个应用程序，所以迁移应用程序不是一个必需条件。
幸运的是，这个时候，Redis 3.2 出来了，而且内置了原生集群，消除了对单一 sentinel 集群需要。
它有一个更简单的设置，但 twemproxy 不支持 Redis 集群分片，它能为你分片数据，但是如果尝试在与分片不一致的集群中这样做会导致问题。有参考的指南可以使其匹配，但是集群可以自动改变形式，并改变分片的设置方式。它仍然有单点故障。正是在这一点上，我将永远感谢我的一位同事发现了一个 Node.js 的 Redis 的集群发现驱动程序，让我们完全放弃了 twemproxy。
因此，我们能够自动分片数据，故障转移和故障恢复基本上是自动的。应用程序知道哪些节点存在，并且在写入数据时，如果写入错误的节点，集群将自动重定向该写入。这是被选的配置，这让我们共享的内存缓存相当健壮，可以没有干预地应付基本的故障模式。在测试期间，我们的确发现了一些缺陷。复制是在一个接一个节点的基础上进行的，因此如果我们丢失了一个主节点，那么它的从节点会成为一个单点故障，直到死去的节点恢复服务，也只有主节点对集群健康投票，所以如果我们一下失去太多主节点，那么集群无法自我恢复。但这比我们过去的好。
### 向前进
随着使用集群 Redis 配置的新程序，我们对于老式 Redis 实例的状态变得越来越不适应，但是新程序与现有程序的规模并不相同（超过 30GB 的内存专用于我们最大的老式 Redis 实例数据库）。因此，随着 Redis 集群在底层得到了证实，我们决定迁移老式的 Redis 实例到新的 Redis 集群中。
由于我们有一个原生支持 Redis 集群的 Node.js Redis 驱动程序，因此我们开始将 Node.js 程序迁移到 Redis 集群。但是，如何将数十亿字节的数据从一个地方移动到另一个地方，而不会造成重大问题？特别是考虑到这些数据是认证令牌，所以如果它们错了，我们的终端用户将会被登出。一个选择是要求网站完全下线，将所有内容都指向新的 Redis 群集，并将数据迁移到其中，以希望获得最佳效果。另一个选择是切换到新集群，并强制所有用户再次登录。由于显而易见的原因，这些都不是非常合适的。我们决定采取的替代方法是将数据同时写入老式 Redis 实例和正在替换它的集群，同时随着时间的推移，我们将逐渐更多地向该集群读取。由于数据的有效期有限（令牌在几个小时后到期），这种方法可以导致零停机，并且不会有数据丢失的风险。所以我们这么做了。迁移是成功的。
剩下的就是服务于我们的 PHP 代码（其中还有一个项目是有用的，其它的最终是没必要的）的 Redis 的实例了，我们在这过程中遇到了一个困难，实际上是两个。首先，也是最紧迫的是找到在 PHP 中使用的 Redis 集群发现驱动程序，还要是我们正在使用的 PHP 版本。这被证明是可行的，因为我们升级到了最新版本的 PHP。我们选择的驱动程序不喜欢使用 Redis 的授权方式，因此我们决定使用 Redis 集群作为一个额外的安全步骤 （我告诉你，这将有更多的安全性）。当我们用 Redis 集群替换每个老式 Redis 实例时，修复似乎很直接，将 Redis 授权关闭，这样它将会响应所有的请求。然而，这并不是真的，由于某些原因，Redis 集群不会接受来自 Web 服务器的连接。 Redis 在版本 3 中引入的称为“保护模式”的新安全功能将在 Redis 绑定到任何接口时将停止监听来自外部 IP 地址的连接，并无需配置 Redis 授权密码。这被证明相当容易修复，但让我们保持警惕。
### 现在？
这就是我们现在的情况。我们已经迁移了我们的一些老式 Redis 实例，并且正在迁移其余的。我们通过这样做解决了我们的一些技术债务，并提高了我们的平台的稳定性。使用 Redis 集群，我们还可以扩展内存数据库并扩展它们。 Redis 是单线程的，所以只要在单个实例中留出更多的内存就会可以得到这么多的增长，而且我们已经紧跟在这个限制后面。我们期待着从新的集群中获得改进的性能，同时也为我们提供了扩展和负载均衡的更多选择。
### 未来怎么样？
我们解决了一些技术性债务，这使我们的服务更容易支持，更加稳定。但这并不意味着这项工作完成了，Redis 4 似乎有一些我们可能想要研究的功能。而且 Redis 并不是我们使用的唯一软件。我们将继续努力改进平台，缩短处理技术债务的时间，但随着客户群体的扩大，我们力求提供更丰富的服务，我们总是会遇到需要改进的事情。下一个挑战可能与每分钟超过 20,000次 登录到超过 40,000 次甚至更高的扩展有关。
---
via: <http://engineering.skybettingandgaming.com/2017/09/25/redis-2-to-redis-3/>
作者：[Craig Stewart](http://engineering.skybettingandgaming.com/authors#craig_stewart) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
OpenGL 与 Go 教程（三）实现游戏
|
Kylewbanks
|
https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-3-implementing-the-game
|
到目前为止，你应该懂得如何创建网格系统以及创建代表方格中每一个单元的格子阵列。现在可以开始把网格当作游戏面板实现康威生命游戏。
|
/data/attachment/album/201710/17/154427lifqhohyri5frun0.jpg.thumb.jpg
|
/data/attachment/album/201710/17/154427lifqhohyri5frun0.jpg
| true
| false
| true
|
BriFuture
| false
|
[
"OpenGL",
"Golang"
] |
软件开发
|
{
"viewnum": 5948,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8937,
"displayorder": 0
}
] |
到目前为止，你应该懂得如何创建网格系统以及创建代表方格中每一个单元的格子阵列。现在可以开始把网格当作游戏面板实现康威生命游戏。
| 2017-10-18T09:43:00
| 2017-10-18T09:43:00
| 8,969
|
/article-8969-1.html
|
* [第一节: Hello, OpenGL](/article-8933-1.html)
* [第二节: 绘制游戏面板](/article-8937-1.html)
* [第三节：实现游戏功能](/article-8969-1.html)
该教程的完整源代码可以从 [GitHub](https://github.com/KyleBanks/conways-gol) 上找到。
欢迎回到《OpenGL 与 Go 教程》！如果你还没有看过 [第一节](/article-8933-1.html) 和 [第二节](https://kylewbanks.com/blog/%5BPart%202:%20Drawing%20the%20Game%20Board%5D(/blog/tutorial-opengl-with-golang-part-2-drawing-the-game-board))，那就要回过头去看一看。
到目前为止，你应该懂得如何创建网格系统以及创建代表方格中每一个单元的格子阵列。现在可以开始把网格当作游戏面板实现<ruby> 康威生命游戏 <rt> Conway's Game of Life </rt></ruby>。
开始吧！
### 实现康威生命游戏
康威生命游戏的其中一个要点是所有<ruby> 细胞 <rt> cell </rt></ruby>必须同时基于当前细胞在面板中的状态确定下一个细胞的状态。也就是说如果细胞 `(X=3,Y=4)` 在计算过程中状态发生了改变，那么邻近的细胞 `(X=4,Y=4)` 必须基于 `(X=3,Y=4)` 的状态决定自己的状态变化，而不是基于自己现在的状态。简单的讲，这意味着我们必须遍历细胞，确定下一个细胞的状态，而在绘制之前不改变他们的当前状态，然后在下一次循环中我们将新状态应用到游戏里，依此循环往复。
为了完成这个功能，我们需要在 `cell` 结构体中添加两个布尔型变量：
```
type cell struct {
drawable uint32
alive bool
aliveNext bool
x int
y int
}
```
这里我们添加了 `alive` 和 `aliveNext`，前一个是细胞当前的专题，后一个是经过计算后下一回合的状态。
现在添加两个函数，我们会用它们来确定 cell 的状态：
```
// checkState 函数决定下一次游戏循环时的 cell 状态
func (c *cell) checkState(cells [][]*cell) {
c.alive = c.aliveNext
c.aliveNext = c.alive
liveCount := c.liveNeighbors(cells)
if c.alive {
// 1. 当任何一个存活的 cell 的附近少于 2 个存活的 cell 时，该 cell 将会消亡，就像人口过少所导致的结果一样
if liveCount < 2 {
c.aliveNext = false
}
// 2. 当任何一个存活的 cell 的附近有 2 至 3 个存活的 cell 时，该 cell 在下一代中仍然存活。
if liveCount == 2 || liveCount == 3 {
c.aliveNext = true
}
// 3. 当任何一个存活的 cell 的附近多于 3 个存活的 cell 时，该 cell 将会消亡，就像人口过多所导致的结果一样
if liveCount > 3 {
c.aliveNext = false
}
} else {
// 4. 任何一个消亡的 cell 附近刚好有 3 个存活的 cell，该 cell 会变为存活的状态，就像重生一样。
if liveCount == 3 {
c.aliveNext = true
}
}
}
// liveNeighbors 函数返回当前 cell 附近存活的 cell 数
func (c *cell) liveNeighbors(cells [][]*cell) int {
var liveCount int
add := func(x, y int) {
// If we're at an edge, check the other side of the board.
if x == len(cells) {
x = 0
} else if x == -1 {
x = len(cells) - 1
}
if y == len(cells[x]) {
y = 0
} else if y == -1 {
y = len(cells[x]) - 1
}
if cells[x][y].alive {
liveCount++
}
}
add(c.x-1, c.y) // To the left
add(c.x+1, c.y) // To the right
add(c.x, c.y+1) // up
add(c.x, c.y-1) // down
add(c.x-1, c.y+1) // top-left
add(c.x+1, c.y+1) // top-right
add(c.x-1, c.y-1) // bottom-left
add(c.x+1, c.y-1) // bottom-right
return liveCount
}
```
在 `checkState` 中我们设置当前状态（`alive`） 等于我们最近迭代结果（`aliveNext`）。接下来我们计数邻居数量，并根据游戏的规则来决定 `aliveNext` 状态。该规则是比较清晰的，而且我们在上面的代码当中也有说明，所以这里不再赘述。
更加值得注意的是 `liveNeighbors` 函数里，我们返回的是当前处于存活（`alive`）状态的细胞的邻居个数。我们定义了一个叫做 `add` 的内嵌函数，它会对 `X` 和 `Y` 坐标做一些重复性的验证。它所做的事情是检查我们传递的数字是否超出了范围——比如说，如果细胞 `(X=0,Y=5)` 想要验证它左边的细胞，它就得验证面板另一边的细胞 `(X=9,Y=5)`，Y 轴与之类似。
在 `add` 内嵌函数后面，我们给当前细胞附近的八个细胞分别调用 `add` 函数，示意如下：
```
[
[-, -, -],
[N, N, N],
[N, C, N],
[N, N, N],
[-, -, -]
]
```
在该示意中，每一个叫做 N 的细胞是 C 的邻居。
现在是我们的 `main` 函数，这里我们执行核心游戏循环，调用每个细胞的 `checkState` 函数进行绘制：
```
func main() {
...
for !window.ShouldClose() {
for x := range cells {
for _, c := range cells[x] {
c.checkState(cells)
}
}
draw(cells, window, program)
}
}
```
现在我们的游戏逻辑全都设置好了，我们需要修改细胞绘制函数来跳过绘制不存活的细胞：
```
func (c *cell) draw() {
if !c.alive {
return
}
gl.BindVertexArray(c.drawable)
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(square)/3))
}
```
如果我们现在运行这个游戏，你将看到一个纯黑的屏幕，而不是我们辛苦工作后应该看到生命模拟。为什么呢？其实这正是模拟在工作。因为我们没有活着的细胞，所以就一个都不会绘制出来。
现在完善这个函数。回到 `makeCells` 函数，我们用 `0.0` 到 `1.0` 之间的一个随机数来设置游戏的初始状态。我们会定义一个大小为 `0.15` 的常量阈值，也就是说每个细胞都有 15% 的几率处于存活状态。
```
import (
"math/rand"
"time"
...
)
const (
...
threshold = 0.15
)
func makeCells() [][]*cell {
rand.Seed(time.Now().UnixNano())
cells := make([][]*cell, rows, rows)
for x := 0; x < rows; x++ {
for y := 0; y < columns; y++ {
c := newCell(x, y)
c.alive = rand.Float64() < threshold
c.aliveNext = c.alive
cells[x] = append(cells[x], c)
}
}
return cells
}
```
我们首先增加两个引入：随机（`math/rand`）和时间（`time`），并定义我们的常量阈值。然后在 `makeCells` 中我们使用当前时间作为随机种子，给每个游戏一个独特的起始状态。你也可也指定一个特定的种子值，来始终得到一个相同的游戏，这在你想重放某个有趣的模拟时很有用。
接下来在循环中，在用 `newCell` 函数创造一个新的细胞时，我们根据随机浮点数的大小设置它的存活状态，随机数在 `0.0` 到 `1.0` 之间，如果比阈值（`0.15`）小，就是存活状态。再次强调，这意味着每个细胞在开始时都有 15% 的几率是存活的。你可以修改数值大小，增加或者减少当前游戏中存活的细胞。我们还把 `aliveNext` 设成 `alive` 状态，否则在第一次迭代之后我们会发现一大片细胞消亡了，这是因为 `aliveNext` 将永远是 `false`。
现在继续运行它，你很有可能看到细胞们一闪而过，但你却无法理解这是为什么。原因可能在于你的电脑太快了，在你能够看清楚之前就运行了（甚至完成了）模拟过程。
让我们降低游戏速度，在主循环中引入一个帧率（FPS）限制：
```
const (
...
fps = 2
)
func main() {
...
for !window.ShouldClose() {
t := time.Now()
for x := range cells {
for _, c := range cells[x] {
c.checkState(cells)
}
}
if err := draw(prog, window, cells); err != nil {
panic(err)
}
time.Sleep(time.Second/time.Duration(fps) - time.Since(t))
}
}
```
现在你能给看出一些图案了，尽管它变换的很慢。把 FPS 加到 10，把方格的尺寸加到 100x100，你就能看到更真实的模拟：
```
const (
...
rows = 100
columns = 100
fps = 10
...
)
```
试着修改常量，看看它们是怎么影响模拟过程的 —— 这是你用 Go 语言写的第一个 OpenGL 程序，很酷吧？
### 进阶内容？
这是《OpenGL 与 Go 教程》的最后一节，但是这不意味着到此而止。这里有些新的挑战，能够增进你对 OpenGL （以及 Go）的理解。
1. 给每个细胞一种不同的颜色。
2. 让用户能够通过命令行参数指定格子尺寸、帧率、种子和阈值。在 GitHub 上的 [github.com/KyleBanks/conways-gol](https://github.com/KyleBanks/conways-gol) 里你可以看到一个已经实现的程序。
3. 把格子的形状变成其它更有意思的，比如六边形。
4. 用颜色表示细胞的状态 —— 比如，在第一帧把存活状态的格子设成绿色，如果它们存活了超过三帧的时间，就变成黄色。
5. 如果模拟过程结束了，就自动关闭窗口，也就是说所有细胞都消亡了，或者是最后两帧里没有格子的状态有改变。
6. 将着色器源代码放到单独的文件中，而不是把它们用字符串的形式放在 Go 的源代码中。
### 总结
希望这篇教程对想要入门 OpenGL （或者是 Go）的人有所帮助！这很有趣，因此我也希望理解学习它也很有趣。
正如我所说的，OpenGL 可能是非常恐怖的，但只要你开始着手了就不会太差。你只用制定一个个可达成的小目标，然后享受每一次成功，因为尽管 OpenGL 不会总像它看上去的那么难，但也肯定有些难懂的东西。我发现，当遇到一个难于理解用 go-gl 生成的代码的 OpenGL 问题时，你总是可以参考一下在网上更流行的当作教程的 C 语言代码，这很有用。通常 C 语言和 Go 语言的唯一区别是在 Go 中，gl 函数的前缀是 `gl.` 而不是 `gl`，常量的前缀是 `gl` 而不是 `GL_`。这可以极大地增加了你的绘制知识！
该教程的完整源代码可从 [GitHub](https://github.com/KyleBanks/conways-gol) 上获得。
### 回顾
这是 main.go 文件最终的内容：
```
package main
import (
"fmt"
"log"
"math/rand"
"runtime"
"strings"
"time"
"github.com/go-gl/gl/v4.1-core/gl" // OR: github.com/go-gl/gl/v2.1/gl
"github.com/go-gl/glfw/v3.2/glfw"
)
const (
width = 500
height = 500
vertexShaderSource = `
#version 410
in vec3 vp;
void main() {
gl_Position = vec4(vp, 1.0);
}
` + "\x00"
fragmentShaderSource = `
#version 410
out vec4 frag_colour;
void main() {
frag_colour = vec4(1, 1, 1, 1.0);
}
` + "\x00"
rows = 100
columns = 100
threshold = 0.15
fps = 10
)
var (
square = []float32{
-0.5, 0.5, 0,
-0.5, -0.5, 0,
0.5, -0.5, 0,
-0.5, 0.5, 0,
0.5, 0.5, 0,
0.5, -0.5, 0,
}
)
type cell struct {
drawable uint32
alive bool
aliveNext bool
x int
y int
}
func main() {
runtime.LockOSThread()
window := initGlfw()
defer glfw.Terminate()
program := initOpenGL()
cells := makeCells()
for !window.ShouldClose() {
t := time.Now()
for x := range cells {
for _, c := range cells[x] {
c.checkState(cells)
}
}
draw(cells, window, program)
time.Sleep(time.Second/time.Duration(fps) - time.Since(t))
}
}
func draw(cells [][]*cell, window *glfw.Window, program uint32) {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.UseProgram(program)
for x := range cells {
for _, c := range cells[x] {
c.draw()
}
}
glfw.PollEvents()
window.SwapBuffers()
}
func makeCells() [][]*cell {
rand.Seed(time.Now().UnixNano())
cells := make([][]*cell, rows, rows)
for x := 0; x < rows; x++ {
for y := 0; y < columns; y++ {
c := newCell(x, y)
c.alive = rand.Float64() < threshold
c.aliveNext = c.alive
cells[x] = append(cells[x], c)
}
}
return cells
}
func newCell(x, y int) *cell {
points := make([]float32, len(square), len(square))
copy(points, square)
for i := 0; i < len(points); i++ {
var position float32
var size float32
switch i % 3 {
case 0:
size = 1.0 / float32(columns)
position = float32(x) * size
case 1:
size = 1.0 / float32(rows)
position = float32(y) * size
default:
continue
}
if points[i] < 0 {
points[i] = (position * 2) - 1
} else {
points[i] = ((position + size) * 2) - 1
}
}
return &cell{
drawable: makeVao(points),
x: x,
y: y,
}
}
func (c *cell) draw() {
if !c.alive {
return
}
gl.BindVertexArray(c.drawable)
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(square)/3))
}
// checkState 函数决定下一次游戏循环时的 cell 状态
func (c *cell) checkState(cells [][]*cell) {
c.alive = c.aliveNext
c.aliveNext = c.alive
liveCount := c.liveNeighbors(cells)
if c.alive {
// 1. 当任何一个存活的 cell 的附近少于 2 个存活的 cell 时，该 cell 将会消亡，就像人口过少所导致的结果一样
if liveCount < 2 {
c.aliveNext = false
}
// 2. 当任何一个存活的 cell 的附近有 2 至 3 个存活的 cell 时，该 cell 在下一代中仍然存活。
if liveCount == 2 || liveCount == 3 {
c.aliveNext = true
}
// 3. 当任何一个存活的 cell 的附近多于 3 个存活的 cell 时，该 cell 将会消亡，就像人口过多所导致的结果一样
if liveCount > 3 {
c.aliveNext = false
}
} else {
// 4. 任何一个消亡的 cell 附近刚好有 3 个存活的 cell，该 cell 会变为存活的状态，就像重生一样。
if liveCount == 3 {
c.aliveNext = true
}
}
}
// liveNeighbors 函数返回当前 cell 附近存活的 cell 数
func (c *cell) liveNeighbors(cells [][]*cell) int {
var liveCount int
add := func(x, y int) {
// If we're at an edge, check the other side of the board.
if x == len(cells) {
x = 0
} else if x == -1 {
x = len(cells) - 1
}
if y == len(cells[x]) {
y = 0
} else if y == -1 {
y = len(cells[x]) - 1
}
if cells[x][y].alive {
liveCount++
}
}
add(c.x-1, c.y) // To the left
add(c.x+1, c.y) // To the right
add(c.x, c.y+1) // up
add(c.x, c.y-1) // down
add(c.x-1, c.y+1) // top-left
add(c.x+1, c.y+1) // top-right
add(c.x-1, c.y-1) // bottom-left
add(c.x+1, c.y-1) // bottom-right
return liveCount
}
// initGlfw 初始化 glfw，返回一个可用的 Window
func initGlfw() *glfw.Window {
if err := glfw.Init(); err != nil {
panic(err)
}
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.ContextVersionMajor, 4)
glfw.WindowHint(glfw.ContextVersionMinor, 1)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(width, height, "Conway's Game of Life", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
return window
}
// initOpenGL 初始化 OpenGL 并返回一个已经编译好的着色器程序
func initOpenGL() uint32 {
if err := gl.Init(); err != nil {
panic(err)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
log.Println("OpenGL version", version)
vertexShader, err := compileShader(vertexShaderSource, gl.VERTEX_SHADER)
if err != nil {
panic(err)
}
fragmentShader, err := compileShader(fragmentShaderSource, gl.FRAGMENT_SHADER)
if err != nil {
panic(err)
}
prog := gl.CreateProgram()
gl.AttachShader(prog, vertexShader)
gl.AttachShader(prog, fragmentShader)
gl.LinkProgram(prog)
return prog
}
// makeVao 初始化并从提供的点里面返回一个顶点数组
func makeVao(points []float32) uint32 {
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, 4*len(points), gl.Ptr(points), gl.STATIC_DRAW)
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
gl.EnableVertexAttribArray(0)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, nil)
return vao
}
func compileShader(source string, shaderType uint32) (uint32, error) {
shader := gl.CreateShader(shaderType)
csources, free := gl.Strs(source)
gl.ShaderSource(shader, 1, csources, nil)
free()
gl.CompileShader(shader)
var status int32
gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
if status == gl.FALSE {
var logLength int32
gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
log := strings.Repeat("\x00", int(logLength+1))
gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
return 0, fmt.Errorf("failed to compile %v: %v", source, log)
}
return shader, nil
}
```
请在 Twitter [@kylewbanks](https://twitter.com/kylewbanks) 告诉我这篇文章对你是否有帮助，或者在 Twitter 下方关注我以便及时获取最新文章！
---
via: <https://kylewbanks.com/blog/tutorial-opengl-with-golang-part-3-implementing-the-game>
作者：[kylewbanks](https://twitter.com/kylewbanks) 译者：[GitFuture](https://github.com/GitFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Up：在几秒钟内部署无服务器应用程序
|
Tj Holowaychuk
|
https://medium.freecodecamp.org/up-b3db1ca930ee
|
为什么关注无服务器（serverless）？对于初学者来说，它可以节省成本，因为你可以按需付费，且只为你使用的付费。无服务器方式是自愈的，因为每个请求被隔离并被视作“无状态的”。最后，它可以无限轻松地扩展 —— 没有机器或集群要管理。部署你的代码就行了。
|
/data/attachment/album/201710/17/222344ghhnihphli9phphk.png.thumb.jpg
|
/data/attachment/album/201710/17/222344ghhnihphli9phphk.png
| true
| false
| true
|
geekpi
| false
|
[
"serverless",
"无服务器"
] |
容器与云
|
{
"viewnum": 6092,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
为什么关注无服务器（serverless）？对于初学者来说，它可以节省成本，因为你可以按需付费，且只为你使用的付费。无服务器方式是自愈的，因为每个请求被隔离并被视作“无状态的”。最后，它可以无限轻松地扩展 —— 没有机器或集群要管理。部署你的代码就行了。
| 2017-10-17T22:23:42
| 2017-10-17T22:23:42
| 8,970
|
/article-8970-1.html
|
去年，我[为 Up 规划了一份蓝图](https://medium.com/@tjholowaychuk/blueprints-for-up-1-5f8197179275)，其中描述了如何以最小的成本在 AWS 上为大多数构建块创建一个很棒的无服务器环境。这篇文章则是讨论了 [Up](https://github.com/apex/up) 的初始 alpha 版本。
为什么关注<ruby> 无服务器 <rt> serverless </rt></ruby>？对于初学者来说，它可以节省成本，因为你可以按需付费，且只为你使用的付费。无服务器方式是自愈的，因为每个请求被隔离并被视作“无状态的”。最后，它可以无限轻松地扩展 —— 没有机器或集群要管理。部署你的代码就行了。
大约一个月前，我决定开始在 [apex/up](https://github.com/apex/up) 上开发它，并为动态 SVG 版本的 GitHub 用户投票功能写了第一个小型无服务器示例程序 [tj/gh-polls](https://github.com/tj/gh-polls)。它运行良好，成本低于每月 1 美元即可为数百万次投票服务，因此我会继续这个项目，看看我是否可以提供开源版本及商业的变体版本。
其长期的目标是提供“你自己的 Heroku” 的版本，支持许多平台。虽然平台即服务（PaaS）并不新鲜，但无服务器生态系统正在使这种方案日益萎缩。据说，AWS 和其他的供应商经常由于他们提供的灵活性而被人诟病用户体验。Up 将复杂性抽象出来，同时为你提供一个几乎无需运维的解决方案。
### 安装
你可以使用以下命令安装 Up，查看这篇[临时文档](https://github.com/apex/up/tree/master/docs)开始使用。或者如果你使用安装脚本，请下载[二进制版本](https://github.com/apex/up/releases)。（请记住，这个项目还在早期。）
```
curl -sfL https://raw.githubusercontent.com/apex/up/master/install.sh | sh
```
只需运行以下命令随时升级到最新版本：
```
up upgrade
```
你也可以通过 NPM 进行安装：
```
npm install -g up
```
### 功能
这个早期 alpha 版本提供什么功能？让我们来看看！请记住，Up 不是托管服务，因此你需要一个 AWS 帐户和 [AWS 凭证](https://github.com/apex/up/blob/master/docs/aws-credentials.md)。如果你对 AWS 不熟悉，你可能需要先停下来，直到熟悉流程。
我遇到的第一个问题是：up(1) 与 [apex(1)](https://github.com/apex/apex) 有何不同？Apex 专注于部署功能，用于管道和事件处理，而 Up 则侧重于应用程序、API 和静态站点，也就是单个可部署单元。Apex 不为你提供 API 网关、SSL 证书或 DNS，也不提供 URL 重写，脚本注入等。
#### 单命令无服务器应用程序
Up 可以让你使用单条命令部署应用程序、API 和静态站点。要创建一个应用程序，你只需要一个文件，在 Node.js 的情况下，`./app.js` 监听由 Up 提供的 `PORT'。请注意，如果你使用的是`package.json`，则会检测并使用`start`和`build` 脚本。
```
const http = require('http')
const { PORT = 3000 } = process.env
```
```
http.createServer((req, res) => {
res.end('Hello World\n')
}).listen(PORT)
```
额外的[运行时环境](https://github.com/apex/up/blob/master/docs/runtimes.md)也支持开箱可用，例如用于 Golang 的 “main.go”，所以你可以在几秒钟内部署 Golang、Python、Crystal 或 Node.js 应用程序。
```
package main
import (
"fmt"
"log"
"net/http"
"os"
)
func main() {
addr := ":" + os.Getenv("PORT")
http.HandleFunc("/", hello)
log.Fatal(http.ListenAndServe(addr, nil))
}
func hello(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "Hello World from Go")
}
```
要部署应用程序输入 `up` 来创建所需的资源并部署应用程序本身。这里没有模糊不清的地方，一旦它说“完成”了那就完成了，该应用程序立即可用 —— 没有远程构建过程。
后续的部署将会更快，因为栈已被配置：
使用 `up url --open` 测试你的程序，以在浏览器中浏览它，`up url --copy` 可以将 URL 保存到剪贴板，或者可以尝试使用 curl：
```
curl `up url`
Hello World
```
要删除应用程序及其资源，只需输入 `up stack delete`：
例如，使用 `up staging` 或 `up production` 和 `up url --open production` 部署到预发布或生产环境。请注意，自定义域名尚不可用，[它们将很快可用](https://github.com/apex/up/issues/166)。之后，你还可以将版本“推广”到其他环境。
#### 反向代理
Up 的一个独特的功能是，它不仅仅是简单地部署代码，它将一个 Golang 反向代理放在应用程序的前面。这提供了许多功能，如 URL 重写、重定向、脚本注入等等，我们将在后面进一步介绍。
#### 基础设施即代码
在配置方面，Up 遵循现代最佳实践，因此对基础设施的更改都可以在部署之前预览，并且 IAM 策略的使用还可以限制开发人员访问以防止事故发生。一个附带的好处是它有助于自动记录你的基础设施。
以下是使用 Let's Encrypt 通过 AWS ACM 配置一些（虚拟）DNS 记录和免费 SSL 证书的示例。
```
{
"name": "app",
"dns": {
"myapp.com": [
{
"name": "myapp.com",
"type": "A",
"ttl": 300,
"value": ["35.161.83.243"]
},
{
"name": "blog.myapp.com",
"type": "CNAME",
"ttl": 300,
"value": ["34.209.172.67"]
},
{
"name": "api.myapp.com",
"type": "A",
"ttl": 300,
"value": ["54.187.185.18"]
}
]
},
"certs": [
{
"domains": ["myapp.com", "*.myapp.com"]
}
]
}
```
当你首次通过 `up` 部署应用程序时，需要所有的权限，它为你创建 API 网关、Lambda 函数、ACM 证书、Route53 DNS 记录等。
[ChangeSets](https://github.com/apex/up/issues/115) 尚未实现，但你能使用 `up stack plan` 预览进一步的更改，并使用 `up stack apply` 提交，这与 Terraform 非常相似。
详细信息请参阅[配置文档](https://github.com/apex/up/blob/master/docs/configuration.md)。
#### 全球部署
`regions` 数组可以指定应用程序的目标区域。例如，如果你只对单个地区感兴趣，请使用：
```
{
"regions": ["us-west-2"]
}
```
如果你的客户集中在北美，你可能需要使用美国和加拿大所有地区：
```
{
"regions": ["us-*", "ca-*"]
}
```
最后，你可以使用 AWS 目前支持的所有 14 个地区：
```
{
"regions": ["*"]
}
```
多区域支持仍然是一个正在进行的工作，因为需要一些新的 AWS 功能来将它们结合在一起。
#### 静态文件服务
Up 默认支持静态文件服务，并带有 HTTP 缓存支持，因此你可以在应用程序前使用 CloudFront 或任何其他 CDN 来大大减少延迟。
当 `type` 为 `static` 时，默认情况下的工作目录是 `.`，但是你也可以提供一个 `static.dir`：
```
{
"name": "app",
"type": "static",
"static": {
"dir": "public"
}
}
```
#### 构建钩子
构建钩子允许你在部署或执行其他操作时定义自定义操作。一个常见的例子是使用 Webpack 或 Browserify 捆绑 Node.js 应用程序，这大大减少了文件大小，因为 node 模块是*很大*的。
```
{
"name": "app",
"hooks": {
"build": "browserify --node server.js > app.js",
"clean": "rm app.js"
}
}
```
#### 脚本和样式表插入
Up 允许你插入脚本和样式，无论是内联方式或声明路径。它甚至支持一些“罐头”脚本，用于 Google Analytics（分析）和 [Segment](https://segment.com/)，只需复制并粘贴你的写入密钥即可。
```
{
"name": "site",
"type": "static",
"inject": {
"head": [
{
"type": "segment",
"value": "API_KEY"
},
{
"type": "inline style",
"file": "/css/primer.css"
}
],
"body": [
{
"type": "script",
"value": "/app.js"
}
]
}
}
```
#### 重写和重定向
Up 通过 `redirects` 对象支持重定向和 URL 重写，该对象将路径模式映射到新位置。如果省略 `status` 参数（或值为 200），那么它是重写，否则是重定向。
```
{
"name": "app",
"type": "static",
"redirects": {
"/blog": {
"location": "https://blog.apex.sh/",
"status": 301
},
"/docs/:section/guides/:guide": {
"location": "/help/:section/:guide",
"status": 302
},
"/store/*": {
"location": "/shop/:splat"
}
}
}
```
用于重写的常见情况是 SPA（单页面应用程序），你希望不管路径如何都提供 `index.html`，当然除非文件存在。
```
{
"name": "app",
"type": "static",
"redirects": {
"/*": {
"location": "/",
"status": 200
}
}
}
```
如果要强制实施该规则，无论文件是否存在，只需添加 `"force": true` 。
#### 环境变量
密码将在下一个版本中有，但是现在支持纯文本环境变量：
```
{
"name": "api",
"environment": {
"API_FEATURE_FOO": "1",
"API_FEATURE_BAR": "0"
}
}
```
#### CORS 支持
[CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS) 支持允许你指定哪些（如果有的话）域可以从浏览器访问你的 API。如果你希望允许任何网站访问你的 API，只需启用它：
```
{
"cors": {
"enable": true
}
}
```
你还可以自定义访问，例如仅将 API 访问限制为你的前端或 SPA。
```
{
"cors": {
"allowed_origins": ["https://myapp.com"],
"allowed_methods": ["HEAD", "GET", "POST", "PUT", "DELETE"],
"allowed_headers": ["Content-Type", "Authorization"]
}
}
```
#### 日志
对于 $0.5/GB 的低价格，你可以使用 CloudWatch 日志进行结构化日志查询和跟踪。Up 实现了一种用于改进 CloudWatch 提供的自定义[查询语言](https://github.com/apex/up/blob/master/internal/logs/parser/grammar.peg)，专门用于查询结构化 JSON 日志。
你可以查询现有日志：
```
up logs
```
跟踪在线日志：
```
up logs -f
```
或者对其中任一个进行过滤，例如只显示耗时超过 5 毫秒的 200 个 GET/HEAD 请求：
```
up logs 'method in ("GET", "HEAD") status = 200 duration >= 5'
```
查询语言是非常灵活的，这里有更多来自于 `up help logs` 的例子
```
### 显示过去 5 分钟的日志
$ up logs
### 显示过去 30 分钟的日志
$ up logs -s 30m
### 显示过去 5 小时的日志
$ up logs -s 5h
### 实时显示日志
$ up logs -f
### 显示错误日志
$ up logs error
### 显示错误和致命错误日志
$ up logs 'error or fatal'
### 显示非 info 日志
$ up logs 'not info'
### 显示特定消息的日志
$ up logs 'message = "user login"'
### 显示超时 150ms 的 200 响应
$ up logs 'status = 200 duration > 150'
### 显示 4xx 和 5xx 响应
$ up logs 'status >= 400'
### 显示用户邮件包含 @apex.sh 的日志
$ up logs 'user.email contains "@apex.sh"'
### 显示用户邮件以 @apex.sh 结尾的日志
$ up logs 'user.email = "*@apex.sh"'
### 显示用户邮件以 tj@ 开始的日志
$ up logs 'user.email = "tj@*"'
### 显示路径 /tobi 和 /loki 下的错误日志
$ up logs 'error and (path = "/tobi" or path = "/loki")'
### 和上面一样，用 in 显示
$ up logs 'error and path in ("/tobi", "/loki")'
### 更复杂的查询方式
$ up logs 'method in ("POST", "PUT") ip = "207.*" status = 200 duration >= 50'
### 将 JSON 格式的错误日志发送给 jq 工具
$ up logs error | jq
```
请注意，`and` 关键字是暗含的，虽然你也可以使用它。
#### 冷启动时间
这是 AWS Lambda 平台的特性，但冷启动时间通常远远低于 1 秒，在未来，我计划提供一个选项来保持它们在线。
#### 配置验证
`up config` 命令输出解析后的配置，有默认值和推断的运行时设置 - 它也起到验证配置的双重目的，因为任何错误都会导致退出状态 > 0。
#### 崩溃恢复
使用 Up 作为反向代理的另一个好处是执行崩溃恢复 —— 在崩溃后重新启动服务器，并在将错误的响应发送给客户端之前重新尝试该请求。
例如，假设你的 Node.js 程序由于间歇性数据库问题而导致未捕获的异常崩溃，Up 可以在响应客户端之前重试该请求。之后这个行为会更加可定制。
#### 适合持续集成
很难说这是一个功能，但是感谢 Golang 相对较小和独立的二进制文件，你可以在一两秒中在 CI 中安装 Up。
#### HTTP/2
Up 通过 API 网关支持 HTTP/2，对于服务很多资源的应用和站点可以减少延迟。我将来会对许多平台进行更全面的测试，但是 Up 的延迟已经很好了：
#### 错误页面
Up 提供了一个默认错误页面，如果你要提供支持电子邮件或调整颜色，你可以使用 `error_pages` 自定义。
```
{
"name": "site",
"type": "static",
"error_pages": {
"variables": {
"support_email": "support@apex.sh",
"color": "#228ae6"
}
}
}
```
默认情况下，它看上去像这样：
如果你想提供自定义模板，你可以创建以下一个或多个文件。特定文件优先。
* `error.html` – 匹配任何 4xx 或 5xx
* `5xx.html` – 匹配任何 5xx 错误
* `4xx.html` – 匹配任何 4xx 错误
* `CODE.html` – 匹配一个特定的代码，如 404.html
查看[文档](https://github.com/apex/up/blob/master/docs/configuration.md#error-pages)阅读更多有关模板的信息。
### 伸缩和成本
你已经做了这么多，但是 Up 怎么伸缩？目前，API 网关和 AWS 是目标平台，因此你无需进行任何更改即可扩展，只需部署代码即可完成。你只需按需支付实际使用的数量并且无需人工干预。
AWS 每月免费提供 1,000,000 个请求，但你可以使用 [http://serverlesscalc.com](http://serverlesscalc.com/) 来插入预期流量。在未来 Up 将提供更多的平台，所以如果一个成本过高，你可以迁移到另一个！
### 未来
目前为止就这样了！它可能看起来不是很多，但它已经超过 10,000 行代码，并且我刚刚开始开发。看看这个问题队列，假设项目可持续发展，看看未来会有什么期待。
如果你发现这个免费版本有用，请考虑在 [OpenCollective](https://opencollective.com/apex-up) 上捐赠我，因为我没有任何工作。我将在短期内开发早期专业版，对早期用户有年费优惠。专业或企业版也将提供源码，因此可以进行内部修复和自定义。
---
via: <https://medium.freecodecamp.org/up-b3db1ca930ee>
作者：[TJ Holowaychuk](https://medium.freecodecamp.org/@tjholowaychuk?source=post_header_lockup) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
违反 GPL 究竟算不算合同违约，法官表示需要仔细审理……
|
Donald Robertson
|
http://www.fsf.org/blogs/licensing/update-on-artifex-v-hancom-gnu-gpl-compliance-case-1
|
正在进行中的 GPL 合规案件 Artifex v. Hancom 近日产生了新的裁决，一项旨在提请简易判决的动议被法院驳回。FSF 表示，随着简易判决动议被否，本案继续向前推进，并将变得更为有趣。
|
/data/attachment/album/201710/17/231500t3ssjj1c3jr3ztkm.jpeg.thumb.jpg
|
/data/attachment/album/201710/17/231500t3ssjj1c3jr3ztkm.jpeg
| true
| false
| true
|
薛亮
| false
|
[
"GPL",
"Ghostscript"
] |
开源智慧
|
{
"viewnum": 4524,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9494,
"displayorder": 0
}
] |
正在进行中的 GPL 合规案件 Artifex v. Hancom 近日产生了新的裁决，一项旨在提请简易判决的动议被法院驳回。FSF 表示，随着简易判决动议被否，本案继续向前推进，并将变得更为有趣。
| 2017-10-17T23:15:00
| 2017-10-17T23:15:00
| 8,971
|
/article-8971-1.html
|
据自由软件基金会（FSF）报道，正在进行中的 GPL 合规案件 Artifex v. Hancom 近日产生了新的裁决，一项旨在提请简易判决的动议被法院驳回。
该案涉及一款遵循 GPL v3 及之后版本许可证的名为 Ghostscript 的软件，其来源于 Artifex 公司一个用于处理 PostScript、PDF 以及打印机的项目（GNU Ghostscript 是该项目的一个单独版本，并未涉及或牵连该案）。
FSF在之前的报道中[表示](https://www.fsf.org/blogs/licensing/motion-to-dismiss-denied-in-recent-gnu-gpl-case)：
>
> 在该诉讼中，基于 Hancom 公司对 Ghostscript 的使用情况，Artifex 公司提出了两项指控：（1）侵犯版权；以及（2）违反基于GPL许可证的合同。……虽然违反自由软件许可证将导致侵犯版权已经成为老生常谈，但是，违反 GPL 等许可证是否可以被视为违反合同，长期以来一直是许可专家们的讨论话题。
>
>
>
在之前的裁决中，本案的法官驳回了 Hancom 的撤案动议，让案件得以继续进行。现在诉讼已经到了下一步，其中包括一个主张 GPL 构成合同的<ruby> <a href="https://docs.justia.com/cases/federal/district-courts/california/candce/3:2016cv06982/305835/54"> 简易判决动议 </a> <rp> （ </rp> <rt> Motion for summary judgment </rt> <rp> ） </rp></ruby>，但是该动议日前也被法官驳回。在撤案动议中，法院假定所涉指控真实存在，并对所述指控是否真正提出了有效的合法权利主张做出了裁决。在简易判决动议中，法院会被要求去审视无可争议的事实，并确定该案件的结果是否如此明显，以至于不需要经过全面审判。类似动议虽然是例行的，但是如果通过了简易判决，意味着本案中合同理论的复苏问题依然存在（LCTT 译注：指是否被视为违法合同）。
Hancom 公司提出了一些否认 GPL 许可证构成合同的证据，其中一个特别有意思。Hancom 公司认为，如果 GPL 许可证构成合同的说法被接受，则只能考虑他们在初始违规日之前的损害赔偿。他们认为，由于违规造成了许可终止，合同也因此结束。法官指出：
>
> GPL 许可证表明，在使用 Ghostscript 传播软件的权利被终止后，被告的义务依然存在，……因为每次传递“<ruby> 被覆盖作品 <rp> （ </rp> <rt> covered work </rt> <rp> ） </rp></ruby>”，都需要提供源代码或承诺提供源代码，每次被告分发使用 Ghostscript 的产品，可以说随之而来的义务就是提供源代码或承诺提供源代码。
>
>
>
法官还发现，在这一点上没有足够的证据来对该问题做出裁决。所以，FSF 表示，目前还无法进行过多的解读。但是，法官对于违规行为之后 GPL 在什么条件下继续存在的看法，是随着本案进行，该问题如何发展的重要线索。虽然，为了保护用户自由， GPL 许可证并不需要作为合同进行维护（它作为版权许可已经成功运行了几十年）。不过，类似的程序性裁决显示了有更多的证据表明，GPL 许可证作为合同的主张在法院不容易站住脚或者容易被击败的说法并非毫无根据的造谣。
FSF 表示，随着简易判决动议被否，本案继续向前推进，并将变得更为有趣。
---
译者简介：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO 分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
密码修改最佳实践
|
Bruce Schneier
|
https://www.schneier.com/blog/archives/2017/10/changes_in_pass.html
|
NIST 最近发表了四卷 SP800-63b 数字身份指南。除此之外，它还对密码提供三个重要的建议
|
/data/attachment/album/201710/18/094012qnxe6erzko5y55no.jpg.thumb.jpg
|
/data/attachment/album/201710/18/094012qnxe6erzko5y55no.jpg
| true
| false
| true
|
geekpi
| false
|
[
"密码",
"NIST",
"安全"
] |
技术
|
{
"viewnum": 4542,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
NIST 最近发表了四卷 SP800-63b 数字身份指南。除此之外，它还对密码提供三个重要的建议
| 2017-10-18T09:40:34
| 2017-10-18T09:40:34
| 8,973
|
/article-8973-1.html
|
NIST 最近发表了四卷 [SP800-63b 数字身份指南](http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-63b.pdf)。除此之外，它还对密码提供三个重要的建议：
1. 不要再纠结于复杂的密码规则。它们使密码难以记住。因为人为的复杂密码很难输入，因此增加了错误。它们[也没有很大帮助](https://www.wsj.com/articles/the-man-who-wrote-those-password-rules-has-a-new-tip-n3v-r-m1-d-1502124118)。最好让人们使用密码短语。
2. 停止密码到期。这是[我们以前使用计算机的一个老的想法](https://securingthehuman.sans.org/blog/2017/03/23/time-for-password-expiration-to-die)。如今不要让人改变密码，除非有泄密的迹象。
3. 让人们使用密码管理器。这就是处理我们所有密码的方式。
这些密码规则不能[让用户安全](http://ieeexplore.ieee.org/document/7676198/?reload=true)。让系统安全才是最重要的。
---
作者简介：
自从 2004 年以来，我一直在博客上写关于安全的文章，以及从 1998 年以来我的每月订阅中也有。我写书、文章和学术论文。目前我是 IBM Resilient 的首席技术官，哈佛伯克曼中心的研究员，EFF 的董事会成员。
---
via: <https://www.schneier.com/blog/archives/2017/10/changes_in_pass.html>
作者：[Bruce Schneier](https://www.schneier.com/blog/about/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Android 在物联网方面能否像在移动终端一样成功？
|
Carl Whalley
|
https://medium.com/@carl.whalley/will-android-do-for-iot-what-it-did-for-mobile-c9ac79d06c#.hxva5aqi2
|
谷歌发布 “Android Things” 及其 SDK 的时候，我马上闭门谢客，全身心地去研究了……
|
/data/attachment/album/201710/18/121752v0bllg0r7xa9mbvu.jpg.thumb.jpg
|
/data/attachment/album/201710/18/121752v0bllg0r7xa9mbvu.jpg
| true
| false
| true
|
firstadream
| false
|
[
"Android",
"IoT"
] |
观点
|
{
"viewnum": 5839,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
谷歌发布 “Android Things” 及其 SDK 的时候，我马上闭门谢客，全身心地去研究了……
| 2017-10-18T12:17:51
| 2017-10-18T12:17:51
| 8,974
|
/article-8974-1.html
|
### 我在 Android Things 上的最初 24 小时
正当我在开发一个基于 Android 的运行在树莓派 3 的物联网商业项目时，一些令人惊喜的事情发生了。谷歌发布了[Android Things](https://developer.android.com/things/index.html) 的第一个预览版本，他们的 SDK 专门（目前）针对 3 个 SBC（单板计算机） —— 树莓派 3、英特尔 Edison 和恩智浦 Pico。说我一直在挣扎似乎有些轻描淡写 —— 树莓派上甚至没有一个成功的 Android 移植版本，我们在理想丰满，但是实践漏洞百出的内测版本上叫苦不迭。其中一个问题，同时也是不可原谅的问题是，它不支持触摸屏，甚至连 [Element14](https://www.element14.com/community/docs/DOC-78156/l/raspberry-pi-7-touchscreen-display) 官方销售的也不支持。曾经我认为 Android 已经支持树莓派，更早时候 “[谷歌向 AOSP 项目发起提交](http://www.androidpolice.com/2016/05/24/google-is-preparing-to-add-the-raspberry-pi-3-to-aosp-it-will-apparently-become-an-officially-supported-device/)” 中提到过树莓派曾让所有人兴奋不已。所以当 2016 年 12 月 12 日谷歌发布 “Android Things” 及其 SDK 的时候，我马上闭门谢客，全身心地去研究了……
### 问题？
关于树莓派上的谷歌 Android 我遇到很多问题，我以前用 Android 做过许多开发，也做过一些树莓派项目，包括之前提到过的一个真正参与的。未来我会尝试解决这些问题，但是首先最重要的问题得到了解决 —— 有完整的 Android Studio 支持，树莓派成为你手里的另一个常规的 ADB 可寻址设备。好极了。Android Studio 强大而便利、十分易用的功能包括布局预览、调试系统、源码检查器、自动化测试等都可以真正的应用在 IoT 硬件上。这些好处怎么说都不过分。到目前为止，我在树莓派上的大部分工作都是通过 SSH 使用运行在树莓派上的编辑器（MC，如果你真的想知道）借助 Python 完成的。这是有效的，毫无疑问铁杆的 Pi/Python 粉丝或许会有更好的工作方式，而不是当前这种像极了 80 年代码农的软件开发模式。我的项目需要在控制树莓派的手机上编写 Android 软件，这真有点痛不欲生 —— 我使用 Android Studio 做“真正的” Android 开发，借助 SSH 做剩下的。但是有了“Android Things”之后，一切都结束了。
所有的示例代码都适用于这三种 SBC，树莓派只是其中之一。 `Build.DEVICE` 常量可以在运行时确定是哪一个，所以你会看到很多如下代码：
```
public static String getGPIOForButton() {
switch (Build.DEVICE) {
case DEVICE_EDISON_ARDUINO:
return "IO12";
case DEVICE_EDISON:
return "GP44";
case DEVICE_RPI3:
return "BCM21";
case DEVICE_NXP:
return "GPIO4_IO20";
default:
throw new IllegalStateException(“Unknown Build.DEVICE “ + Build.DEVICE);
}
}
```
我对 GPIO 处理有浓厚的兴趣。 由于我只熟悉树莓派，我只能假定其它 SBC 工作方式相同，GPIO 只是一组引脚，可以定义为输入/输出，是连接物理外部世界的主要接口。 基于 Linux 的树莓派操作系统通过 Python 中的读取和写入方法提供了完整和便捷的支持，但对于 Android，您必须使用 NDK 编写 C++ 驱动程序，并通过 JNI 在 Java 中与这些驱动程序对接。 不是那么困难，但需要在你的构建链中维护额外的一些东西。 树莓派还为 I2C 指定了 2 个引脚：时钟和数据，因此需要额外的工作来处理它们。I2C 是真正酷的总线寻址系统，它通过串行化将许多独立的数据引脚转换成一个。 所以这里的优势是 —— Android Things 已经帮你完成了所有这一切。 你只需要 `read()` 和 `write()` 你需要的任何 GPIO 引脚，I2C 同样容易：
```
public class HomeActivity extends Activity {
// I2C Device Name
private static final String I2C_DEVICE_NAME = ...;
// I2C Slave Address
private static final int I2C_ADDRESS = ...;
private I2cDevice mDevice;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Attempt to access the I2C device
try {
PeripheralManagerService manager = new PeripheralManagerService();
mDevice = manager.openI2cDevice(I2C_DEVICE_NAME, I2C_ADDRESS)
} catch (IOException e) {
Log.w(TAG, "Unable to access I2C device", e);
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (mDevice != null) {
try {
mDevice.close();
mDevice = null;
} catch (IOException e) {
Log.w(TAG, "Unable to close I2C device", e);
}
}
}
}
```
### Android Things 基于 Android 的哪个版本？
看起来是 Android 7.0，这样很好，因为我们可以继承 Android 所有以前版本的平板设计 UI、优化，安全加固等。它也带来了一个有趣的问题 —— 与应用程序必须单独管理不同，未来的平台应如何更新升级？请记住，这些设备可能无法连接到互联网。我们可能不便于连接蜂窝 / WiFi ，即便之前这些连接能用，但是有时不那么可靠。
另一个担心是，Android Things 仅仅是一个名字不同的 Android 分支版本，大部分都是一样的，和已经发布的 Arduino 一样，更像是为了市场营销而出现，而不是作为操作系统。不过可以放心，实际上通过[样例](https://github.com/androidthings/sample-simpleui/blob/master/app/src/main/res/drawable/pinout_board_vert.xml)可以看到，其中一些样例甚至使用了 SVG 图形作为资源，而不是传统的基于位图的图形（当然也能轻松处理） —— 这是一个非常新的 Android 创新。
不可避免地，与 Android Things 相比，普通的 Android 会有些不同。例如，权限问题。因为 Android Things 为固定硬件设计，在构建好之后，用户通常不会在这种设备上安装应用，所以在一定程序上减轻了这个问题，尽管当设备要求权限时是个问题 —— 因为它们没有 UI。解决方案是当应用在安装时给予所有需要的权限。 通常，这些设备只有一个应用，并且该应用从设备上电的那一刻就开始运行。
### Brillo 怎么了？
Brillo 是谷歌以前的 IoT 操作系统的代号，听起来很像 Android Things 的前身。 实际上现在你仍然能看到很多提及 Brillo 的地方，特别是在 GitHub Android Things 源码的文件夹名字中。 然而，它已经不复存在了。新王已经登基！
### UI 指南？
谷歌针对 Android 智能手机和平板电脑应用发布了大量指南，例如屏幕按钮间距等。 当然，你最好在可行的情况下遵循这些，但这已经不是本文应该考虑的范畴了。 缺省情况下什么也没有 —— 应用程序作者决定一切，这包括顶部状态栏，底部导航栏 —— 绝对是一切。 多年来谷歌一直在告诉 Android 应用程序的作者们绝不要在屏幕上放置返回按钮，因为平台将提供一个，因为 Android Things [可能甚至没有 UI！](https://developer.android.com/things/sdk/index.html)。
### 智能手机上会有多少谷歌服务？
有一些，但不是所有。第一个预览版本没有蓝牙支持、没有 NFC，这两者都对物联网革命有重大贡献。 SBC 支持它们，所以我们应该不会等待太久。由于没有通知栏，因此不支持任何通知。没有地图。缺省没有软键盘，你必须自己安装一个键盘。由于没有 Play 商店，你只能艰难地通过 ADB 做这个和许多其他操作。
当为 Android Things 开发时，我试图为运行在手机上和树莓派上使用同一个 APK。这引发了一个错误，阻止它安装在除 Android Things 设备之外的任何设备：`com.google.android.things` 库不存在。 这有点用，因为只有 Android Things 设备需要这个，但它似乎是个限制，因为不仅智能手机或平板电脑上没有，连模拟器上也没有。似乎只能在物理 Android Things 设备上运行和测试您的 Android Things 应用程序……直到谷歌在 [G+ 谷歌的 IoT 开发人员社区](https://plus.google.com/+CarlWhalley/posts/4tF76pWEs1D)组中回答了我的问题，并提供了规避方案。但是，躲过初一，躲不过十五。
### 可以期待 Android Thing 生态演进到什么程度？
我期望看到移植更多传统的基于 Linux 服务器的应用程序，将 Android 限制在智能手机和平板电脑上没有意义。例如，Web 服务器突然变得非常有用。已经有一些了，但没有像重量级的 Apache 或 Nginx 的。物联网设备可以没有本地 UI，但通过浏览器管理它们当然是可行的，因此需要用这种方式呈现 Web 面板。类似的那些如雷贯耳的通讯应用程序 —— 它需要的仅是一个麦克风和扬声器，而且在理论上任何视频通话应用程序，如 Duo、Skype、FB 等都可行。这个演变能走多远目前只能猜测。会有 Play 商店吗？它们会展示广告吗？我们能够确保它们不会窥探我们，或被黑客控制它们么？从消费者的角度来看，物联网应该是具有触摸屏的网络连接设备，因为每个人都已经习惯于通过智能手机工作。
我还期望看到硬件的迅速发展 —— 特别是有更多的 SBC 拥有更低的成本。看看惊人的 5 美元树莓派 Zero，不幸的是，由于其有限的 CPU 和内存，几乎可以肯定不能运行 Android Things。多久之后像这样的设备才能运行 Android Things？这是很明显的，标杆已经设定，任何有追求的 SBC 制造商将瞄准 Android Things 的兼容性，规模经济也将波及到外围设备，如 23 美元的触摸屏。没人会购买不会播放 YouTube 的微波炉，你的洗碗机会在 eBay 上购买更多的清洁粉，因为它注意到你很少使用它……
然而，我不认为我们会过于冲昏头脑。了解一点 Android 架构有助于将其视为一个包罗万象的物联网操作系统。它仍然使用 Java，其垃圾回收机制导致的所有时序问题在过去几乎把它搞死。这仅仅是问题最少的部分。真正的实时操作系统依赖于可预测、准确和坚如磐石的时序，要么它就不能被用于“关键任务”。想想医疗应用、安全监视器，工业控制器等。使用 Android，如果宿主操作系统认为它需要，理论上可以在任何时候杀死您的活动/服务。这在手机上没那么糟糕 —— 用户可以重新启动应用程序，杀死其他应用程序，或重新启动手机。但心脏监视器就完全是另一码事。如果前台的活动/服务正在监视一个 GPIO 引脚，而这个信号没有被准确地处理，我们就完了。必须要做一些相当根本的改变让 Android 来支持这一点，到目前为止还没有迹象表明它已经在计划之中了。
### 这 24 小时
所以，回到我的项目。 我认为我会接管我已经完成和尽力能为的工作，等待不可避免的路障，并向 G+ 社区寻求帮助。 除了一些在非 Android Things 设备上如何运行程序的问题之外，没有其他问题。它运行得很好！ 这个项目也使用了一些奇怪的东西，如自定义字体、高精定时器 —— 所有这些都在 Android Studio 中完美地展现。对我而言，可以打满分 —— 至少我能够开始做出实际原型，而不只是视频和截图。
### 蓝图
今天的物联网操作系统环境看起来非常零碎。 显然没有市场领导者，尽管炒作之声沸反连天，物联网仍然在草创阶段。 谷歌 Android 物联网能否像它在移动端那样取得成功？现在 Android 在移动方面的主导地位几近达到 90％。我相信如果真的如此，Android Things 的推出正是重要的一步。
记住所有的关于开放和封闭软件的战争，它们主要发生在从不授权的苹果和一直担心免费还不够充分的谷歌之间。那个老梗又来了，因为让苹果推出一个免费的物联网操作系统的构想就像让他们免费赠送下一代 iPhone 一样遥不可及。
物联网操作系统游戏是开放的，大家机遇共享，不过这个时候，封闭派甚至不会公布它们的开发工具箱……
前往 [Developer Preview](https://developer.android.com/things/preview/index.html)网站，立即获取 Android Things SDK 的副本。
---
via: <https://medium.com/@carl.whalley/will-android-do-for-iot-what-it-did-for-mobile-c9ac79d06c#.hxva5aqi2>
作者：[Carl Whalley](https://medium.com/@carl.whalley) 译者：[firstadream](https://github.com/firstadream) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
NixOS Linux： 先配置后安装的 Linux
|
Jack Wallen
|
https://www.linux.com/learn/intro-to-linux/2017/10/nixos-linux-lets-you-configure-your-os-installing
|
配置是成功安装 NixOS 的关键。
|
/data/attachment/album/201710/18/232958ljxtr0rooxo77x4g.png.thumb.jpg
|
/data/attachment/album/201710/18/232958ljxtr0rooxo77x4g.png
| true
| false
| true
|
martin2011qi
| false
|
[
"NixOS"
] |
技术
|
{
"viewnum": 9649,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
配置是成功安装 NixOS 的关键。
| 2017-10-19T08:26:00
| 2017-10-19T08:26:00
| 8,976
|
/article-8976-1.html
|
>
> 配置是成功安装 NixOS 的关键。
>
>
>
我用 Linux 有些年头了。在这些年里我很有幸见证了开源的发展。各色各样的发行版在安装方面的努力，也是其中的一个比较独特的部分。以前，安装 Linux 是个最好让有技术的人来干的任务。现在，只要你会装软件，你就会安装 Linux。简单，并且，不是我吹，在吸引新用户方面效果拔群。事实上安装整个 Linux 操作系统都要比 Windows 用户安装个更新看起来要快一点。
但每一次，我都喜欢看到一些不同的东西——那些可以让我体验新鲜的东西。[NixOS](https://nixos.org/) 在这方面就做的别具一格。讲真，我原来也就把它当作另一个提供标准特性和 KDE Plasma 5 界面的 Linux 发行版。
好像也没什么不对。
[下载 ISO 映像](https://nixos.org/nixos/download.html)后，我启动了 [VirtualBox](https://www.virtualbox.org/wiki/Downloads) 并用下载的镜像创建了个新的虚拟机。VM 启动后，出来的是 Bash 的登录界面，界面上指导我用空密码去登录 root 账号，以及我该如何启动 GUI 显示管理器（图 1）。
*图 1： 与 NixOS 的初次接触可能不是太和谐。*
“好吧”我这样想着，“打开看看吧！”
GUI 启动和运行时（KDE Plasma 5），我没找到喜闻乐见的“安装”按钮。原来，NixOS 是一个在安装前需要你配置的发行版，真有趣。那就让我们瞧瞧它是如何做到的吧！
### 安装前配置
你需要做的第一件事是建分区。由于 NixOS 安装程序不包含分区工具，你得用自带的 GParted （图 2）来创建一个 EXT4 分区。
*图 2： 安装前对磁盘分区。*
创建好分区，然后用命令 `mount /dev/sdX /mnt` 挂载。（请自行替换 `sdX` 为你新创建的分区）。
你现在需要创建一个配置文件。命令如下：
```
nixos-generate-config --root /mnt
```
上面的命令会创建两个文件（存放在目录 `/mnt/etc/nixos` 中）：
* `configuration.nix` — 默认配置文件。
* `hardware-configuration.nix` — 硬件配置（无法编辑）
通过命令 `nano /mnt/etc/nixos/configuration.nix` 打开文件。其中有一些需要编辑的地方得注意。第一个改动便是设置启动选项。找到行：
```
# boot.loader.grub.device = "/dev/sda"; # 或 efi 时用 "nodev"
```
删除行首的 `#` 使该选项生效（确保 `/dev/sda` 与你新建的分区）。
通过配置文件，你可以设置时区和追加要安装的软件包。来看一个被注释掉的安装包的示例：
```
# List packages installed in system profile. To search by name, run:
# nix-env -aqP | grep wget
# environment.systemPackages = with pkgs; [
# wget vim
# ];
```
如果你想要添加软件包，并在安装时安装它们，那就取消掉这段注释，并添加你需要的软件包。举个例子，比方说你要把 LibreOffice 加进去。示例详见下方：
```
# List packages installed in system profile. To search by name, run:
nix-env -aqP | grep wget
environment.systemPackages = with pkgs; [
libreoffice wget vim
];
```
你可以通过输入命令 `nix-env -aqP | grep PACKAGENAME` 来寻找确切的包名（`PACKAGENAME` 为你想要找的软件包）。如果你不想输命令，你也可以检索 [NixOS 的软件包数据库](https://nixos.org/nixos/packages.html)。
在你把所有的软件包都添加完后，你还有件事儿需要做（如果你想要登录到桌面的话，我觉得你还得折腾下 KDE Plasma 5 桌面）。翻到配置文件的末尾并在最后的 `}` 符号前，追加如下内容：
```
services.xserver = {
enable = true;
displayManager.sddm.enable = true;
desktopManager.plasma5.enable = true;
};
```
在 [NixOS 官方文件](https://nixos.org/nixos/manual/index.html#ch-configuration) 中，你能找到配置文件中更多的选项。保存并关掉配置文件。
### 安装
在你按照自己的需求完善好配置之后，使用命令（需要 root 权限） `nixos-install`。完成安装所需要的时间，会随着你加入的软件包多少有所区别。安装结束后，你可以使用命令重启系统，（重启之后）迎接你的就是 KDE Plasma 5 的登录管理界面了（图 3）。
*图 3： KDE Plasma 5 登录管理界面*
### 安装后
你要首先要做的两件事之一便是给 root 用户设个密码（通过输入命令 `passwd` 来修改默认的密码），以及添加一个标准用户。做法和其它的 Linux 发行版无二。用 root 用户登录，然后在终端输入命令：
```
useradd -m USER
```
将 `USER` 替换成你想要添加的用户名。然后通过下面的命令给用户设上密码：
```
passwd USER
```
同样的将 `USER` 替换成你添加的用户。
然后会有提示引导你填写并验证新密码。然后，你就能用标准用户登录 NixOS 啦。
NixOS 在你安装并运行后，你可以为系统添加新的软件包，但并非通过寻常的方式。如果你发现你需要安装些新东西，你得回到配置文件（位置就是 `/etc/nixos/` ），找到之前安装时添加软件包的位置，运行以下命令（需要 root 权限）：
```
nixos-rebuild switch
```
命令执行结束后，你就能使用新安装的软件包了。
### Enjoy NixOS
现在，NixOS 已经带着所有你想安装的软件和 KDE Plasma 5 桌面运行起来了。要知道，你所做的不仅仅只是安装了个 Linux 发行版，关键是你自定义出来的发行版非常符合你的需求。所以好好享受你的 NixOS 吧！
---
via: <https://www.linux.com/learn/intro-to-linux/2017/10/nixos-linux-lets-you-configure-your-os-installing>
作者：[JACK WALLEN](https://www.linux.com/users/jlwallen) 译者：[martin2011qi](https://github.com/martin2011qi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：谁杀死了 MySQL? - 后记
|
Daniel Stori
|
http://turnoff.us/geek/who-killed-mysql-epilogue/
|
这篇漫画意在讽刺 Oracle 收购太阳微系统公司之后，对收购来的资产一个个杀死，比如 MySQL，导致大多数发行版已经不使用 MySQL ，转向它的分支 MariaDB，在此之后，Oracle 还放弃了“不赚钱的” Java EE。
|
/data/attachment/album/201710/19/100254adq477kzbdlldbko.png.thumb.jpg
|
/data/attachment/album/201710/19/100254adq477kzbdlldbko.png.large.jpg
| false
| false
| true
|
ItsLucas
| false
|
[
"MySQL",
"漫画"
] |
极客漫画
|
{
"viewnum": 12710,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "116.19.93.10",
"message": "不错不错，很有趣。",
"username": "phoenix_wangxd [Chrome 76.0|Mac 10.14]",
"date": "2019-09-02T20:57:49"
}
] |
[] |
这篇漫画意在讽刺 Oracle 收购太阳微系统公司之后，对收购来的资产一个个杀死，比如 MySQL，导致大多数发行版已经不使用 MySQL ，转向它的分支 MariaDB，在此之后，Oracle 还放弃了“不赚钱的” Java EE。
| 2017-10-19T10:02:00
| 2017-10-19T10:02:00
| 8,977
|
/article-8977-1.html
|
这篇漫画意在讽刺 Oracle 收购太阳微系统公司之后，对收购来的资产一个个杀死，比如 MySQL，导致大多数发行版已经不使用 MySQL ，转向它的分支 MariaDB，在此之后，Oracle 还放弃了“不赚钱的” Java EE。
然后之后，是以对开源不友善而著名的微软前总裁巴尔默——虽然现在新总裁纳德拉上台之后，微软公司乃至巴尔默都对开源的态度发生了一百八十度大转弯。
本篇漫画中涉及的一些技术方面的隐喻有：
* SIGKILL，是一种 UNIX/Posix 信号，用于结束一个进程，不可捕获。关于 SIGKILL ，可以看看[这篇漫画](/article-8791-1.html)。
* PIPE，是 UNIX/Posix 中的一种进程通讯机制，数据可以通过管道进行传输，进行进程间通讯。此处引申为一个管道、通道，从漫画中可以看到， Java 439 进程感觉不妙的时候，其脚下已经有些塌陷的痕迹，而接着变成了一个通道——然后它就掉进去死了。
* ulimit，是 UNIX/Linux 中用于限制资源分配的命令，可以设置系统可以分配的文件句柄数等，像 Apache 之类的服务需要足够的句柄数才能提供更高的连接数。此处，头上顶着羽毛的 Apache 表示，它要占用一些 ulimit 分配的资源（去工作了）。
---
via: <http://turnoff.us/geek/who-killed-mysql-epilogue/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者&点评：[ItsLucas](https://github.com/ItsLucas) 校对&合成：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
OpenMessaging：构建一个分布式消息分发的开放标准
|
Mike Dolan
|
https://www.linuxfoundation.org/blog/building-open-standard-distributed-messaging-introducing-openmessaging/
|
OpenMessaging 社区的目标是为分布式消息分发创建全球采用的、供应商中立的和开放标准，可以部署在云端、内部和混合云情景中。
|
/data/attachment/album/201710/19/185250rw8xo3kmtp5bb323.jpg.thumb.jpg
|
/data/attachment/album/201710/19/185250rw8xo3kmtp5bb323.jpg
| true
| false
| true
|
geekpi
| false
|
[
"OpenMessaging",
"消息",
"MQ"
] |
新闻
|
{
"viewnum": 5685,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
OpenMessaging 社区的目标是为分布式消息分发创建全球采用的、供应商中立的和开放标准，可以部署在云端、内部和混合云情景中。
| 2017-10-19T18:51:00
| 2017-10-19T18:51:00
| 8,978
|
/article-8978-1.html
|
通过在云计算、大数据和标准 API 上的企业及社区的协作，我很高兴 OpenMessaging 项目进入 Linux 基金会。OpenMessaging 社区的目标是为分布式消息分发创建全球采用的、供应商中立的和开放标准，可以部署在云端、内部和混合云情景中。
阿里巴巴、雅虎、滴滴和 Streamlio 是该项目的创始贡献者。Linux 基金会已与这个初始项目社区合作来建立一个治理模式和结构，以实现运作在消息 API 标准上的生态系统的长期受益。
由于越来越多的公司和开发者迈向<ruby> 云原生应用 <rt> cloud native application </rt></ruby>，消息式应用和流式应用的扩展面临的挑战也在不断发展。这包括平台之间的互操作性问题，<ruby> <a href="https://en.wikipedia.org/wiki/Wire_protocol"> 线路级协议 </a> <rt> wire-level protocol </rt></ruby>之间缺乏兼容性以及系统间缺乏标准的基准测试。
特别是当数据跨不同的消息平台和流平台进行传输时会出现兼容性问题，这意味着额外的工作和维护成本。现有解决方案缺乏负载平衡、容错、管理、安全性和流功能的标准化指南。目前的系统不能满足现代面向云的消息应用和流应用的需求。这可能导致开发人员额外的工作，并且难以或不可能满足物联网、边缘计算、智能城市等方面的尖端业务需求。
OpenMessaging 的贡献者正在寻求通过以下方式改进分布式消息分发：
* 为分布式消息分发创建一个面向全球、面向云、供应商中立的行业标准
* 促进用于测试应用程序的标准基准发展
* 支持平台独立
* 以可伸缩性、灵活性、隔离和安全性为目标的云数据的流和消息分发要求
* 培育不断发展的开发贡献者社区
你可以在这了解有关新项目的更多信息以及如何参与： [http://openmessaging.cloud](http://openmessaging.cloud/)。
这些是支持 OpenMessaging 的一些组织：
>
> “我们多年来一直专注于消息分发和流领域，在此期间，我们探索了 Corba 通知、JMS 和其它标准，来试图解决我们最严格的业务需求。阿里巴巴在评估了可用的替代品后，选择创建一个新的面向云的消息分发标准 OpenMessaging，这是一个供应商中立，且语言无关的标准，并为金融、电子商务、物联网和大数据等领域提供了行业指南。此外，它目地在于跨异构系统和平台间开发消息分发和流应用。我们希望它可以是开放、简单、可扩展和可互操作的。另外，我们要根据这个标准建立一个生态系统，如基准测试、计算和各种连接器。我们希望有新的贡献，并希望大家能够共同努力，推动 OpenMessaging 标准的发展。”
>
>
> ——阿里巴巴高级架构师，Apache RocketMQ 的联合创始人，以及 OpenMessaging 的原始发起人 Von Gosling
>
>
>
>
> “随着应用程序消息的复杂性和规模的不断扩大，缺乏标准的接口为开发人员和组织带来了复杂性和灵活性的障碍。Streamlio 很高兴与其他领导者合作推出 OpenMessaging 标准倡议来给客户一个轻松使用高性能、低延迟的消息传递解决方案，如 Apache Pulsar，它提供了企业所需的耐用性、一致性和可用性。“
>
>
> —— Streamlio 的软件工程师、Apache Pulsar 的联合创始人以及 Apache BookKeeper PMC 的成员 Matteo Merli
>
>
>
>
> “Oath（Verizon 旗下领先的媒体和技术品牌，包括雅虎和 AOL）支持开放，协作的举措，并且很乐意加入 OpenMessaging 项目。”
>
>
> —— Joe Francis，核心平台总监
>
>
>
>
> “在滴滴中，我们定义了一组私有的生产者 API 和消费者 API 来隐藏开源的 MQ（如 Apache Kafka、Apache RocketMQ 等）之间的差异，并提供额外的自定义功能。我们计划将这些发布到开源社区。到目前为止，我们已经积累了很多关于 MQ 和 API 统一的经验，并愿意在 OpenMessaging 中与其它 API 一起构建 API 的共同标准。我们真诚地认为，统一和广泛接受的 API 标准可以使 MQ 技术和依赖于它的应用程序受益。”
>
>
> —— 滴滴的架构师 Neil Qi
>
>
>
>
> “有许多不同的开源消息分发解决方案，包括 Apache ActiveMQ、Apache RocketMQ、Apache Pulsar 和 Apache Kafka。缺乏行业级的可扩展消息分发标准使得评估合适的解决方案变得困难。我们很高兴能够与多个开源项目共同努力，共同确定可扩展的开放消息规范。 Apache BookKeeper 已成功在雅虎（通过 Apache Pulsar）和 Twitter（通过 Apache DistributedLog）的生产环境中部署，它作为其企业级消息系统的持久化、高性能、低延迟存储基础。我们很高兴加入 OpenMessaging 帮助其它项目解决诸如低延迟持久化、一致性和可用性等在消息分发方案中的常见问题。”
>
>
> —— Streamlio 的联合创始人、Apache BookKeeper 的 PMC 主席、Apache DistributedLog 的联合创造者， Sijie Guo
>
>
>
---
via: <https://www.linuxfoundation.org/blog/building-open-standard-distributed-messaging-introducing-openmessaging/>
作者：[Mike Dolan](https://www.linuxfoundation.org/author/mdolan/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Ubuntu 17.10（AA）发布
|
Wxy
|
今天，Canonical 公司发布了 Ubuntu 17.10，这个版本不是 LTS 版本，因此其支持期只有 9 个月，支持到 2018 年 7 月。
|
/data/attachment/album/201710/19/231242bhki55gchkis1cv5.png.thumb.jpg
|
/data/attachment/album/201710/19/231242bhki55gchkis1cv5.png
| true
| false
| false
| false
|
[
"Ubuntu"
] |
新闻
|
{
"viewnum": 8537,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 9045,
"displayorder": 0
}
] |
今天，Canonical 公司发布了 Ubuntu 17.10，这个版本不是 LTS 版本，因此其支持期只有 9 个月，支持到 2018 年 7 月。
| 2017-10-20T00:46:00
| 2017-10-20T00:46:00
| 8,980
|
/article-8980-1.html
|
今天，Canonical 公司发布了 Ubuntu 17.10，这个版本不是 LTS 版本，因此其支持期只有 9 个月，支持到 2018 年 7 月。
Ubuntu 17.10 的代号是 Artful Aardvark （巧豚）。正如大家知道的，Ubuntu 发行版的代号是由两个单词组成的，分别是一个形容词和一个濒危动物名。从第四个版本开始，就按照字母顺序，从 D 开始逐个使用。这是 Ubnutu 发布了 26 个主版本以来，唯二剩下没用过的字母（另外一个是 C，最开始的三个版本没有按字母顺序来，分别是 W、H、B）。
### 重大变化
这次的 Ubuntu 17.10 虽然不是重要的 LTS 版本，连 Ubuntu 官网的介绍中都将其视作是明年的 Ubuntu 18.04 LTS 的前奏，但是这个版本其实还是有几个处女式创新：
* 这是第一个放弃 32 位支持的主版本，不过 17.10 的官方风味版本还会继续支持 32 位。
* 这是七年来 Ubuntu 主版本第一次放弃 Unity 用户界面，改投 GNOME 怀抱，目前采用的是最新的 GNOME 3.26.1。
* 这是第一次默认使用 Wayland 显示服务器，而 X.Org 显示服务器则是可选的。当然如果你的机器不支持 Wayland ，会自动回退到 X.Org。
* 默认不再安装 Python 2，Python 3 更新到了 3.6。
我们可以先看一下官方的宣传视频：
### 新的变化
除了上述重大改变之外，Ubuntu 17.10 还有这些新改变：
**桌面版**
* 新的由 GNOME 带来的 Caribou 屏幕键盘替代了原来的 Onboard，铺平了将来的触摸屏体验之路。
* 相同的用户体验。虽然更换了 GNOME，但是从桌面布局到键盘快捷键均保持了一致，这要感谢那些主题和扩展。
* 熟悉的 dock。从 11.04 开始，dock 就是 Ubuntu 发行版的特色，在这个版本中，它还继续在那里，不增不减——不过现在它可以随意移动到左边、右边和底部。
* Ubuntu 17.10 使用 Linux kernel 4.13。
* 交换分区现在改成了交换文件，这便于你随时根据系统需求伸缩，也可以很方便的安装到各种机器上。
* 由于默认使用 GNOME 桌面系统，GDM 也替换 LightDM 成为了默认的显示管理器。并且现在登录屏使用 1 号虚拟终端，而不是之前的 7 号虚拟终端。
* 七年来，窗口控制按钮首次从左边回到了右边。
* 免驱动打印现在支持 [IPP Everywhere](http://www.pwg.org/dynamo/eveprinters.php)、 [Apple AirPrint](https://support.apple.com/en-us/HT201311)、 [Wi-Fi Direct](https://www.wi-fi.org/discover-wi-fi/wi-fi-direct) 和 [Mopria](http://mopria.org/) 设备。
* “设置”应用重新进行了设计。
* “系统日志” 被替换为“日志”，这是来自 systemd journal 的日志查看器。
* 官方风味版的 Ubuntu GNOME 停止更新，因为现在 Ubuntu 使用的就是 GNOME 。
* 但是如果你想试试更上游的 GNOME，你可以安装 gnome-session，并从登录屏幕选择 GNOME 。如果你喜欢的话，也可以安装 vanilla-gnome-desktop 基础包来获得更多的 GNOME 核心应用。
**服务器版**
* qemu 从 2.8 更新到了 2.10。需要注意的是，默认增加并启用了镜像锁定功能，一般来说它会更安全，但是在有些旧场景下会有问题。
* libvirt 更新到了 3.6。
* DPDK 更新到了最新的稳定版本 17.05.2，这使得它可以与 Open vSwitch 2.8 集成。Open vSwitch 更新到了 2.8，需要注意是的，从 2.7 开始，你就需要通过 dpdk-devargs 指定 dpdk 设备了。
* DNS 服务器 Bind9 更新包括了 2017 年 7 月 11 日新发布的<ruby> 密钥签名密钥 <rp> （ </rp> <rt> Key Signing Key </rt> <rp> ） </rp></ruby>（KSK），从 2017 年 10 月 11 日开始，该密钥将用于签名根区密钥，根区密钥用于签名实际的根区。已运行的 Bind 9 会根据 RFC 5011 自动更新其锚点密钥，而 [2017 年 10 月 11 日回滚事件](https://www.icann.org/resources/pages/ksk-rollover/)之后新安装的 Bind 9 将需要这个包或手动更新密钥。
更多变化，可以参考[发行公告](https://wiki.ubuntu.com/ArtfulAardvark/ReleaseNotes)。
### 下载
* Ubuntu 桌面版和服务器版 <http://releases.ubuntu.com/17.10/>
* 其它架构的 Ubuntu 服务器 <http://cdimage.ubuntu.com/ubuntu/releases/17.10/release/>
* Ubuntu 云镜像 <http://cloud-images.ubuntu.com/daily/server/artful/current/>
* Ubuntu Netboot <http://cdimage.ubuntu.com/netboot/17.10/>
* Kubuntu <http://cdimage.ubuntu.com/kubuntu/releases/17.10/release/>
* Lubuntu <http://cdimage.ubuntu.com/lubuntu/releases/17.10/release/>
* Ubuntu Budgie <http://cdimage.ubuntu.com/ubuntu-budgie/releases/17.10/release/>
* 优麒麟 <http://cdimage.ubuntu.com/ubuntukylin/releases/17.10/release/>
* Ubuntu MATE <https://ubuntu-mate.org/download/>
* Ubuntu Studio <http://cdimage.ubuntu.com/ubuntustudio/releases/17.10/release/>
* Xubuntu <http://cdimage.ubuntu.com/xubuntu/releases/17.10/release/>
### 从 17.04 升级
如果你希望使用长期支持版本，建议你安装 Ubuntu 16.04 LTS。如果你在使用 Ubuntu 17.04，你可以按以下方式升级到最新版本。
桌面系统升级：
* 在系统设置中打开“软件与更新”。
* 选择“更新”选项卡。
* 设置下拉菜单“有新的 Ubuntu 版本时提醒我”为“任何新版本”。
* 按下 `Alt+F2`快捷键，并在命令行窗口输入 `update-manager -c`。
* 更新管理器将打开并提示你“新的发行版 17.10 已经可用”。如果不工作，你可以运行 `/usr/lib/ubuntu-release-upgrader/check-new-release-gtk`。
* 点击“升级”并按屏幕提示进行。
服务器系统升级：
* 如果没有安装的话，请先安装 `update-manager-core` 软件包。
* 确保 `/etc/update-manager/release-upgrades` 中的 `Prompt` 设置为 `normal`。
* 在命令行运行 `sudo do-release-upgrade` 启动升级管理器。
* 按屏幕提示进行。
|
||||
Docker 快速入门之 Dockerfile
|
Locez
|
http://locez.com/linux/docker/dockerfile/
|
本文从一个具体的例子出发，讲述了如何利用 Dockerfile 构建镜像，然后解释了 Dockerfile 文件中的指令的语法，有关更多内容可访问官方文档。
|
/data/attachment/album/201710/20/222828ouudmzdmouzrfmyd.jpg.thumb.jpg
|
/data/attachment/album/201710/20/222828ouudmzdmouzrfmyd.jpg
| true
| false
| false
| false
|
[
"容器",
"Docker"
] |
容器与云
|
{
"viewnum": 5285,
"commentnum": 0,
"favtimes": 7,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8932,
"displayorder": 0
}
] |
本文从一个具体的例子出发，讲述了如何利用 Dockerfile 构建镜像，然后解释了 Dockerfile 文件中的指令的语法，有关更多内容可访问官方文档。
| 2017-10-20T22:28:00
| 2017-10-20T22:28:00
| 8,982
|
/article-8982-1.html
|
在[之前的文章](/article-8932-1.html)中我们提到可以通过容器创建一个我们自定义过的镜像，那么我们是否可以直接通过基础的镜像直接自定义镜像呢？答案当然是可以的，在 Docker 中我们可以从名为 `Dockerfile` 的文件中读取指令并且自动构建镜像。在本文中，将介绍 Dockerfile 的基本语法以及基本知识。
### 1、Dockerfile 是什么？
Dockerfile 其实是一份文本文档，里面包含了用户可以用来操作镜像的一些指令。通过顺序执行这些指令，最后得到一个自定义的镜像，这有点类似于我们的 shell 脚本。
### 2、Dockerfile 示例
接下来先看一个 Dockerfile 示例：
```
FROM centos
LABEL maintainer="Locez <locez@locez.com>"
ENV TEST="This is a test env"
COPY nginx.repo /etc/yum.repos.d/nginx.repo
RUN yum update -y && \
yum install -y nginx
COPY nginx.conf /etc/nginx/nginx.conf
COPY index.html /usr/share/nginx/html/index.html
COPY index_files/ /usr/share/nginx/html/index_files/
EXPOSE 80
CMD ["/usr/sbin/nginx","-g","daemon off;"]
```
在上面我们可以看到 Dockerfile 中的一些指令，通过名称我们也可以猜到这些指令大概是干嘛的，其中有一些对文件的操作，因此我们先来看看用于存放 Dockerfile 的这个目录的目录结构:
```
# tree .
.
├── Dockerfile
├── index_files
│ ├── 145049z4og8xyjhx4xy8go.jpg
│ ├── 222746e5vh38d7ey3leyps.jpg
│ ├── 88x31.png
│ ├── archlinux-splash.png
│ ├── bdshare.css
│ ├── Best-Linux-Markdown-Editors.png
│ ├── core.js
│ ├── docker-icon.jpg
│ ├── hadoop-pic1.png
│ ├── jquery_002.js
│ ├── jquery.css
│ ├── jquery.js
│ ├── MathJax.js
│ ├── pic.gif
│ ├── raspberrypiraspberry-pi-logo.jpg
│ ├── script.js
│ ├── scrollup.png
│ ├── share.js
│ ├── style.css
│ └── z_stat.js
├── index.html
├── nginx.conf
└── nginx.repo
1 directory, 24 files
```
### 构建镜像
在当前目录下执行以下命令构建镜像:
```
# docker build -t locez/nginx .
Sending build context to Docker daemon 1.851 MB
Step 1/10 : FROM centos
---> 196e0ce0c9fb
Step 2/10 : LABEL maintainer "Locez <locez@locez.com>"
---> Using cache
---> 9bba3042bcdb
Step 3/10 : ENV TEST "This is a test env"
---> Using cache
---> c0ffe95ea0c5
Step 4/10 : COPY nginx.repo /etc/yum.repos.d/nginx.repo
---> Using cache
---> bb6ee4c30d56
Step 5/10 : RUN yum update -y && yum install -y nginx
---> Using cache
---> 6d46b41099c3
Step 6/10 : COPY nginx.conf /etc/nginx/nginx.conf
---> Using cache
---> cfe908390aae
Step 7/10 : COPY index.html /usr/share/nginx/html/index.html
---> Using cache
---> 21729476079d
Step 8/10 : COPY index_files/ /usr/share/nginx/html/index_files/
---> Using cache
---> 662f06ec7b46
Step 9/10 : EXPOSE 80
---> Using cache
---> 30db5a889d0a
Step 10/10 : CMD /usr/sbin/nginx -g daemon off;
---> Using cache
---> d29b9d4036d2
Successfully built d29b9d4036d2
```
然后用该镜像启动容器：
```
# docker run -d -it --rm --name test-nginx -p 8080:80 locez/nginx
e06fd991ca1b202e08cf1578f8046355fcbba10dd9a90e11d43282f3a1e36d29
```
用浏览器访问 `http://localhost:8080/` 即可看到部署的内容。
### 3 Dockerfile 指令解释
Dockerfile 支持 `FROM`、 `RUN`、 `CMD`、 `LABEL`、 `EXPOSE`、 `ENV`、 `ADD`、 `COPY`、 `ENTRYPOINT`、 `VOLUME`、 `USER`、 `WORKDIR`、 `ARG`、 `ONBUILD`、 `SHELL` 等指令，这里只选择常用的几个进行讲解，可结合上面的示例进行理解。其它的请自行查阅官方文档。
#### 3.1 FROM
`FROM` 指令用于指定要操作的基础镜像，因为在我们构建我们自己的镜像的时候需要一个基础镜像。 语法：
```
FROM <image> [AS <name>]
FROM <image>[:<tag>] [AS <name>]
```
其中 `[AS <name>]` 为指定一个名称，在一个 Dockerfile 中多次使用 `FROM` 时如有需要，可用 `COPY --from=<name|index>` 语法进行复制。
#### 3.2 RUN
`RUN` 指令用于执行命令，并且是在新的一层上执行，并把执行后的结果提交，也就是生成新的一层。基于这个问题，我们在使用 `RUN` 指令时应该尽可能的把要执行的命令一次写完，以减少最后生成的镜像的层数。 语法：
```
RUN <command>
RUN ["executable", "param1", "param2"]
```
#### 3.3 CMD
`CMD` 指令用于给容器启动时指定一个用于执行的命令，例如上例中的 nginx 启动命令。 语法：
```
CMD ["executable","param1","param2"]
CMD ["param1","param2"] ### 用于给 ENTRYPOINT 指令提供默认参数
CMD command param1 param2
```
#### 3.4 LABEL
`LABEL` 指令用于为镜像指定标签，可用 `docker inspect` 命令查看。可用来代替被舍弃的 `MAINTAINER` 命令。 语法：
```
LABEL <key>=<value> <key>=<value> <key>=<value> ...
```
#### 3.5 EXPOSE
`EXPOSE` 指令用于告诉 Docker 容器监听的特殊端口，但是此时端口还没有暴露给 host ，只有当在运行一个容器显式用参数 `-p` 或者 `-P` 的时候才会暴露端口。 语法：
```
EXPOSE <port> [<port>/<protocol>...]
```
#### 3.6 ENV
`ENV` 指令用于设定环境变量。 语法：
```
ENV <key> <value>
ENV <key>=<value> ...
```
#### 3.7 ADD
`ADD` 指令用于复制新文件，目录，远程文件到容器中。其中 `<src>` 可以为文件，目录，URL，若为可解压文件，在复制后会解压。 语法：
```
ADD <src>... <dest>
ADD ["<src>",... "<dest>"]
```
#### 3.8 COPY
`COPY` 指令与 `ADD` 指令非常相似，但 `COPY` 比较直观且简单，它只支持本地的文件以及目录的复制，不像 `ADD` 指令可以远程获取文件并解压。 语法：
```
COPY <src>... <dest>
COPY ["<src>",... "<dest>"]
```
#### 3.9 ENTRYPOINT
`ENTRYPOINT` 指令也跟 `CMD` 指令相似，用于指定容器启动时执行的命令。当使用 `ENTRYPOINT` 指令时，可用 `CMD` 命令配合，这样在启动容器时，可以对 `CMD` 指令写入的参数进行覆盖。 语法：
```
ENTRYPOINT ["executable", "param1", "param2"]
```
例子：
```
ENTRYPOINT ["top","-b"]
CMD ["-c"]
```
上面的 `-c` 参数可以在启动时覆盖 `docker run -it --rm --name test top -H`。 如果要覆盖 `ENTRYPOINT` 指令则用 `--entrypoint` 参数启动容器。
#### 3.10 VOLUME
`VOLUME` 指令用于为容器创建一个挂载点，这个挂载点可以用来挂载 `本地文件/文件夹` 也可以用来挂载 `数据卷`。其中若在启动一个新容器时没有指定挂载目录，则会自动创建一个数据卷，当容器被销毁时，数据卷如果没有被其它容器引用则会被删除。 语法：
```
VOLUME ["/data1","/data2"]
```
#### 3.11 USER
`USER` 指令用于设置执行 `RUN`, `CMD`, `ENTRYPOINT` 等指令的用户以及用户组。默认为 `root` 用户。 语法：
```
USER <user>[:<group>]
```
#### 3.12 WORKDIR
`WORKDIR` 指令用于设置 `RUN`, `CMD`, `ENTRYPOINT`, `COPY`, `ADD` 等指令的工作目录。 语法：
```
WORKDIR /path/to/workdir
```
### 4 总结
---
本文从一个具体的例子出发，讲述了如何利用 Dockerfile 构建镜像，然后解释了 Dockerfile 文件中的指令的语法，有关更多内容可访问官方文档。
### 5 参考资料
---
* [Dockerfile reference](https://docs.docker.com/engine/reference/builder/)
|
|||
Ciao：云集成高级编排器
|
Ciao
|
https://clearlinux.org/ciao
|
Ciao 是一个新的负载调度程序，用来解决当前云操作系统项目的局限性
|
/data/attachment/album/201710/20/233813xercyqzsgylylufj.jpeg.thumb.jpg
|
/data/attachment/album/201710/20/233813xercyqzsgylylufj.jpeg
| true
| false
| true
|
geekpi
| false
|
[
"编排",
"OpenStack"
] |
容器与云
|
{
"viewnum": 4954,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Ciao 是一个新的负载调度程序，用来解决当前云操作系统项目的局限性
| 2017-10-20T23:38:30
| 2017-10-20T23:38:30
| 8,983
|
/article-8983-1.html
|
<ruby> 云集成高级编排器 <rt> Cloud Integrated Advanced Orchestrator </rt></ruby> （Ciao） 是一个新的负载调度程序，用来解决当前云操作系统项目的局限性。Ciao 提供了一个轻量级，完全基于 TLS 的最小配置。它是 工作量无关的、易于更新、具有优化速度的调度程序，目前已针对 OpenStack 进行了优化。
其设计决策和创新方法在对安全性、可扩展性、可用性和可部署性的要求下进行：
* **可扩展性：** 初始设计目标是伸缩超过 5,000 个节点。因此，调度器架构用新的形式实现：
+ 在 ciao 中，决策制定是去中心化的。它基于拉取模型，允许计算节点从调度代理请求作业。调度程序总能知道启动器的容量，而不要求进行数据更新，并且将调度决策时间保持在最小。启动器异步向调度程序发送容量。
+ 持久化状态跟踪与调度程序决策制定相分离，它让调度程序保持轻量级。这种分离增加了可靠性、可扩展性和性能。结果是调度程序让出了权限并且这不是瓶颈。
* **可用性：** 虚拟机、容器和裸机集成到一个调度器中。所有的负载都被视为平等公民。为了更易于使用，网络通过一个组件间最小化的异步协议进行简化，只需要最少的配置。Ciao 还包括一个新的、简单的 UI。所有的这些功能都集成到一起来简化安装、配置、维护和操作。
* **轻松部署：** 升级应该是预期操作，而不是例外情况。这种新的去中心化状态的体系结构能够无缝升级。为了确保基础设施（例如 OpenStack）始终是最新的，它实现了持续集成/持续交付（CI/CD）模型。Ciao 的设计使得它可以立即杀死任何 Ciao 组件，更换它，并重新启动它，对可用性影响最小。
* **安全性是必需的：** 与调度程序的连接总是加密的：默认情况下 SSL 是打开的，而不是关闭的。加密是从端到端：所有外部连接都需要 HTTPS，组件之间的内部通信是基于 TLS 的。网络支持的一体化保障了租户分离。
初步结果证明是显著的：在 65 秒内启动一万个 Docker 容器和五千个虚拟机。进一步优化还在进行。
* 文档：<https://clearlinux.org/documentation/ciao/ciao.html>
* Github 链接： [https://github.com/01org/ciao(link is external)](https://github.com/01org/ciao)
* 邮件列表链接： <https://lists.clearlinux.org/mailman/listinfo/ciao-devel>
---
via: <https://clearlinux.org/ciao>
作者：[ciao](https://clearlinux.org/ciao) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何像 NASA 顶级程序员一样编程 —— 10 条重要原则
|
Adarsh Verma
|
https://fossbytes.com/nasa-coding-programming-rules-critical/
|
你知道 NASA 顶级程序员如何编写关键任务代码么？为了确保代码更清楚、更安全、且更容易理解，NASA 的喷气推进实验室制定了 10 条编码规则。
|
/data/attachment/album/201710/21/232332dxjaxwomx2xjmxbt.png.thumb.jpg
|
/data/attachment/album/201710/21/232332dxjaxwomx2xjmxbt.png
| true
| false
| true
|
penghuster
| true
|
[
"编程",
"NASA"
] |
软件开发
|
{
"viewnum": 7937,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你知道 NASA 顶级程序员如何编写关键任务代码么？为了确保代码更清楚、更安全、且更容易理解，NASA 的喷气推进实验室制定了 10 条编码规则。
| 2017-10-21T23:23:00
| 2017-10-21T23:23:00
| 8,984
|
/article-8984-1.html
|
>
> 引言： 你知道 NASA 顶级程序员如何编写关键任务代码么？为了确保代码更清楚、更安全、且更容易理解，NASA 的喷气推进实验室制定了 10 条编码规则。
>
>
>
NASA 的开发者是编程界最有挑战性的工作之一。他们编写代码并将开发安全的关键任务应用程序作为其主要关注点。
在这种情形下，遵守一些严格的编码规则是重要的。这些规则覆盖软件开发的多个方面，例如软件应该如何编码、应该使用哪些语言特性等。
尽管很难就一个好的编码标准达成共识，NASA 的喷气推进实验室（JPL）遵守一个[编码规则](http://pixelscommander.com/wp-content/uploads/2014/12/P10.pdf)，其名为“十的次方：开发安全的关键代码的规则”。
由于 JPL 长期使用 C 语言，这个规则主要是针对于 C 程序语言编写。但是这些规则也可以很容地应用到其它的程序语言。
该规则由 JPL 的首席科学家 Gerard J. Holzmann 制定，这些严格的编码规则主要是聚焦于安全。
NASA 的 10 条编写关键任务代码的规则：
1. 限制所有代码为极为简单的控制流结构 — 不用 `goto` 语句、`setjmp` 或 `longjmp` 结构，不用间接或直接的递归调用。
2. 所有循环必须有一个固定的上限值。必须可以被某个检测工具静态证实，该循环不能达到预置的迭代上限值。如果该上限值不能被静态证实，那么可以认为违背该原则。
3. 在初始化后不要使用动态内存分配。
4. 如果一个语句一行、一个声明一行的标准格式来参考，那么函数的长度不应该比超过一张纸。通常这意味着每个函数的代码行不能超过 60。
5. 代码中断言的密度平均低至每个函数 2 个断言。断言被用于检测那些在实际执行中不可能发生的情况。断言必须没有副作用，并应该定义为布尔测试。当一个断言失败时，应该执行一个明确的恢复动作，例如，把错误情况返回给执行该断言失败的函数调用者。对于静态工具来说，任何能被静态工具证实其永远不会失败或永远不能触发的断言违反了该规则（例如，通过增加无用的 `assert(true)` 语句是不可能满足这个规则的）。
6. 必须在最小的范围内声明数据对象。
7. 非 void 函数的返回值在每次函数调用时都必须检查，且在每个函数内其参数的有效性必须进行检查。
8. 预处理器的使用仅限制于包含头文件和简单的宏定义。符号拼接、可变参数列表（省略号）和递归宏调用都是不允许的。所有的宏必须能够扩展为完整的语法单元。条件编译指令的使用通常是晦涩的，但也不总是能够避免。这意味着即使在一个大的软件开发中超过一两个条件编译指令也要有充足的理由，这超出了避免多次包含头文件的标准做法。每次在代码中这样做的时候必须有基于工具的检查器进行标记，并有充足的理由。
9. 应该限制指针的使用。特别是不应该有超过一级的解除指针引用。解除指针引用操作不可以隐含在宏定义或类型声明中。还有，不允许使用函数指针。
10. 从开发的第一天起，必须在编译器开启最高级别警告选项的条件下对代码进行编译。在此设置之下，代码必须零警告编译通过。代码必须利用源代码静态分析工具每天至少检查一次或更多次，且零警告通过。
关于这些规则，NASA 是这么评价的：
>
> 这些规则就像汽车中的安全带一样，刚开始你可能感到有一点不适，但是一段时间后就会养成习惯，你会无法想象不使用它们的日子。
>
>
>
此文是否对你有帮助？不要忘了在下面的评论区写下你的反馈。
---
作者简介：
Adarsh Verma 是 Fossbytes 的共同创始人，他是一个令人尊敬的企业家，他一直对开源、技术突破和完全保持密切关注。可以通过邮件联系他 — [adarsh.verma@fossbytes.com](mailto:adarsh.verma@fossbytes.com)
---
via: <https://fossbytes.com/nasa-coding-programming-rules-critical/>
作者：[Adarsh Verma](https://fossbytes.com/author/adarsh/) 译者：[penghuster](https://github.com/penghuster) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Grafeas：旨在更好地审计容器
|
Serdar Yegulalp
|
https://www.infoworld.com/article/3230462/security/what-is-grafeas-better-auditing-for-containers.html
|
Google 的 Grafeas 为容器的元数据提供了一个从镜像、构建细节到安全漏洞的通用 API。
|
/data/attachment/album/201710/22/102612x2u8zq2jcewttuwu.jpeg.thumb.jpg
|
/data/attachment/album/201710/22/102612x2u8zq2jcewttuwu.jpeg
| true
| false
| true
|
geekpi
| false
|
[
"容器",
"审计"
] |
容器与云
|
{
"viewnum": 5083,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Google 的 Grafeas 为容器的元数据提供了一个从镜像、构建细节到安全漏洞的通用 API。
| 2017-10-22T10:26:21
| 2017-10-22T10:26:21
| 8,985
|
/article-8985-1.html
|
>
> Google 的 Grafeas 为容器的元数据提供了一个从镜像、构建细节到安全漏洞的通用 API。
>
>
>
我们运行的软件从来没有比今天更难获得。它分散在本地部署和云服务之间，由不知到有多少的开源组件构建而成，以快速的时间表交付，因此保证安全和质量变成了一个挑战。
最终的结果是软件难以审计、推断、安全化和管理。困难的不只是知道 VM 或容器是用什么构建的, 而是由谁来添加、删除或更改的。[Grafeas](http://grafeas.io/) 最初由 Google 设计，旨在使这些问题更容易解决。
### 什么是 Grafeas?
Grafeas 是一个定义软件组件的元数据 API 的开源项目。旨在提供一个统一的元数据模式，允许 VM、容器、JAR 文件和其他软件<ruby> 工件 <rt> artifact </rt></ruby>描述自己的运行环境以及管理它们的用户。目标是允许像在给定环境中使用的软件一样的审计，以及对该软件所做的更改的审计，并以一致和可靠的方式进行。
Grafeas提供两种格式的元数据 API —— 备注和事件：
* <ruby> 备注 <rt> note </rt></ruby>是有关软件工件的某些方面的细节。可以是已知软件漏洞的描述，有关如何构建软件的详细信息（构建器版本、校验和等），部署历史等。
* <ruby> 事件 <rt> occurrence </rt></ruby>是备注的实例，包含了它们创建的地方和方式的细节。例如，已知软件漏洞的详细信息可能会有描述哪个漏洞扫描程序检测到它的情况、何时被检测到的事件信息，以及该漏洞是否被解决。
备注和事件都存储在仓库中。每个备注和事件都使用标识符进行跟踪，该标识符区分它并使其唯一。
Grafeas 规范包括备注类型的几个基本模式。例如，软件包漏洞模式描述了如何存储 CVE 或漏洞描述的备注信息。现在没有接受新模式类型的正式流程，但是[这已经在计划](https://github.com/Grafeas/Grafeas/issues/38)创建这样一个流程。
### Grafeas 客户端和第三方支持
现在，Grafeas 主要作为规范和参考形式存在，它在 [GitHub 上提供](https://github.com/grafeas/grafeas)。 [Go](https://github.com/Grafeas/client-go)、[Python](https://github.com/Grafeas/client-python) 和 [Java](https://github.com/Grafeas/client-java) 的客户端都可以[用 Swagger 生成](https://www.infoworld.com/article/2902750/application-development/manage-apis-with-swagger.html)，所以其他语言的客户端也应该不难写出来。
Google 计划让 Grafeas 广泛使用的主要方式是通过 Kubernetes。 Kubernetes 的一个名为 Kritis 的策略引擎，可以根据 Grafeas 元数据对容器采取措施。
除 Google 之外的几家公司已经宣布计划将 Grafeas 的支持添加到现有产品中。例如，CoreOS 正在考察 Grafeas 如何与 Tectonic 集成，[Red Hat](https://www.redhat.com/en/blog/red-hat-google-cloud-and-other-industry-leaders-join-together-standardize-kubernetes-service-component-auditing-and-policy-enforcement) 和 [IBM](https://developer.ibm.com/dwblog/2017/grafeas/) 都计划在其容器产品和服务中添加 Grafeas 集成。
---
via: <https://www.infoworld.com/article/3230462/security/what-is-grafeas-better-auditing-for-containers.html>
作者：[Serdar Yegulalp](https://www.infoworld.com/author/Serdar-Yegulalp/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Genymotion vs Android 模拟器
|
Sumit Gupta
|
https://www.plightofbyte.com/android/2017/09/03/genymotion-vs-android-emulator/
|
一直以来有关于选择 android 模拟器或者 Genymotion 的争论，我看到很多讨论最后以赞成 Genymotion 而告终。我根据我周围最常见的情况收集了一些数据，基于此，我将连同 Genymotion 全面评估 android 模拟器。
|
/data/attachment/album/201710/22/110139c2uu85s5dgusbdkc.jpg.thumb.jpg
|
/data/attachment/album/201710/22/110139c2uu85s5dgusbdkc.jpg
| true
| false
| true
|
geekpi
| false
|
[
"Android",
"Genymotion"
] |
技术
|
{
"viewnum": 8794,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一直以来有关于选择 android 模拟器或者 Genymotion 的争论，我看到很多讨论最后以赞成 Genymotion 而告终。我根据我周围最常见的情况收集了一些数据，基于此，我将连同 Genymotion 全面评估 android 模拟器。
| 2017-10-23T09:56:00
| 2017-10-23T09:56:00
| 8,986
|
/article-8986-1.html
|
>
> Android 模拟器是否改善到足以取代 Genymotion
>
>
>
一直以来有关于选择 android 模拟器或者 Genymotion 的争论，我看到很多讨论最后以赞成 Genymotion 而告终。我根据我周围最常见的情况收集了一些数据，基于此，我将连同 Genymotion 全面评估 android 模拟器。
结论剧透：**配置正确时，Android 模拟器比 Genymotion 快。**
使用带 Google API 的 x86（32位）镜像、3GB RAM、四核CPU。
>
> * 哈，很高兴我们知道了最终结果
> * 现在，让我们深入
>
>
>
免责声明：我已经测试了我看到的一般情况，即运行测试。所有的基准测试都是在 2015 年中期的 MacBook Pro 上完成的。无论何时我提及 Genymotion 指的都是 Genymotion Desktop。他们还有其他产品，如 Genymotion on Cloud＆Genymotion on Demand，但这里没有考虑。我不是说 Genymotion 是不合适的，但运行测试比某些 Android 模拟器慢。
关于这个问题的一点背景，然后我们将转到具体内容上去。
*过去：我有一些基准测试，继续下去。*
很久以前，Android 模拟器是唯一的选择。但是它们太慢了，这是架构改变的原因。对于在 x86 机器上运行的 ARM 模拟器，你能期待什么？每个指令都必须从 ARM 转换为 x86 架构，这使得它的速度非常慢。
随之而来的是 Android 的 x86 镜像，随着它们摆脱了 ARM 到 x86 平台转化，速度更快了。现在，你可以在 x86 机器上运行 x86 Android 模拟器。
>
> * *问题解决了！！！*
> * 没有！
>
>
>
Android 模拟器仍然比人们想要的慢。随后出现了 Genymotion，这是一个在 virtual box 中运行的 Android 虚拟机。与在 qemu 上运行的普通老式 android 模拟器相比，它相当稳定和快速。
我们来看看今天的情况。
我在持续集成的基础设施上和我的开发机器上使用 Genymotion。我手头的任务是摆脱持续集成基础设施和开发机器上使用 Genymotion。
>
> * 你问为什么？
> * 授权费钱。
>
>
>
在快速看了一下以后，这似乎是一个愚蠢的举动，因为 Android 模拟器的速度很慢而且有 bug，它们看起来适得其反，但是当你深入的时候，你会发现 Android 模拟器是优越的。
我们的情况是对它们进行集成测试（主要是 espresso）。我们的应用程序中只有 1100 多个测试，Genymotion 需要大约 23 分钟才能运行所有测试。
在 Genymotion 中我们面临的另一些问题是：
* 有限的命令行工具（[GMTool](https://docs.genymotion.com/Content/04_Tools/GMTool/GMTool.htm)）。
* 由于内存问题，它们需要定期重新启动。这是一个手动任务，想象在配有许多机器的持续集成基础设施上进行这些会怎样。
**进入 Android 模拟器**
首先是尝试在它给你这么多的选择中设置一个，这会让你会觉得你在赛百味餐厅一样。最大的问题是 x86 或 x86\_64 以及是否有 Google API。
我用这些组合做了一些研究和基准测试，这是我们所想到的。
鼓声……
>
> * 比赛的获胜者是带 Google API 的 x86
> * 但是如何胜利的？为什么？
>
>
>
嗯，我会告诉你每一个问题。
x86\_64 比 x86 慢
>
> * 你问慢多少。
> * 28.2% 多！！！
>
>
>
使用 Google API 的模拟器更加稳定，没有它们容易崩溃。
这使我们得出结论：最好的是带 Google API 的x86。
在我们抛弃 Genymotion 开始使用模拟器之前。有下面几点重要的细节。
* 我使用的是带 Google API 的 Nexus 5 镜像。
* 我注意到，给模拟器较少的内存会造成了很多 Google API 崩溃。所以为模拟器设定了 3GB 的 RAM。
* 模拟器有四核。
* HAXM 安装在主机上。
**基准测试的时候到了**
从基准测试上你可以看到除了 Geekbench4，Android 模拟器都击败了 Genymotion，我感觉更像是virtual box 击败了 qemu。
>
> 欢呼模拟器之王
>
>
>
我们现在有更快的测试执行时间、更好的命令行工具。最新的 [Android 模拟器](https://developer.android.com/studio/releases/emulator.html)创下的新的记录。更快的启动时间之类。
Goolgle 一直努力让
>
> Android 模拟器变得更好
>
>
>
如果你没有在使用 Android 模拟器。我建议你重新试下，可以节省一些钱。
我尝试的另一个但是没有成功的方案是在 AWS 上运行 [Android-x86](http://www.android-x86.org/) 镜像。我能够在 vSphere ESXi Hypervisor 中运行它，但不能在 AWS 或任何其他云平台上运行它。如果有人知道原因，请在下面评论。
PS：[VMWare 现在可以在 AWS 上使用](https://aws.amazon.com/vmware/)，在 AWS 上使用 [Android-x86](http://www.android-x86.org/) 毕竟是有可能的。
---
作者简介：
嗨，我的名字是 Sumit Gupta。我是来自印度古尔冈的软件/应用/网页开发人员。我做这个是因为我喜欢技术，并且一直迷恋它。我已经工作了 3 年以上，但我还是有很多要学习。他们不是说如果你有知识，让别人点亮他们的蜡烛。
当在编译时，我阅读很多文章，或者听音乐。
如果你想联系，下面是我的社交信息和 [email](thesumitgupta@outlook.com)。
---
via: <https://www.plightofbyte.com/android/2017/09/03/genymotion-vs-android-emulator/>
作者：[Sumit Gupta](https://www.plightofbyte.com/about-me) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
构建你的数据科学作品集：用数据讲故事
|
Vik Paruchuri
|
https://www.dataquest.io/blog/data-science-portfolio-project/
|
数据科学公司们在决定雇佣一个人时越来越看重其作品集。其中一个原因就是作品集是分析一个人真实技能的最好方式。
|
/data/attachment/album/201710/22/205831m4we17ipgm7e66us.jpg.thumb.jpg
|
/data/attachment/album/201710/22/205831m4we17ipgm7e66us.jpg
| true
| false
| true
|
Yoo-4x
| false
|
[
"数据科学"
] |
软件开发
|
{
"viewnum": 10501,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "61.186.29.61",
"message": "好长的文章，不过可以慢慢跟着做，要是有国内的数据源就好了",
"username": "海南老王 [Safari 11.0|Mac 10.11]",
"date": "2017-10-23T00:04:13"
}
] |
[
{
"raid": 7907,
"displayorder": 0
}
] |
数据科学公司们在决定雇佣一个人时越来越看重其作品集。其中一个原因就是作品集是分析一个人真实技能的最好方式。
| 2017-10-22T21:01:00
| 2017-10-22T21:01:00
| 8,987
|
/article-8987-1.html
|
>
> 这是如何建立<ruby> 数据科学作品集 <rt> Data Science Portfolio </rt></ruby>系列文章中的第一篇。如果你喜欢这篇文章并且想知道此系列的下一篇文章何时发表，你可以[在页面底部订阅](https://www.dataquest.io/blog/data-science-portfolio-project/#email-signup)。
>
>
>
数据科学公司们在决定雇佣一个人时越来越看重其作品集。其中一个原因就是<ruby> 作品集 <rt> portfolio </rt></ruby>是分析一个人真实技能的最好方式。好消息是，作品集是完全可以被你掌控的。如果你在其上投入了一些工作，你就能够做出一个令那些公司印象深刻的作品集结果。
建立一个高质量作品集的第一步就是知道展示什么技能。那些公司们主要希望数据科学工作者拥有的技能，或者说他们主要希望作品集所展示的技能是：
* 表达能力
* 合作能力
* 专业技能
* 解释数据的能力
* 有目标和有积极性的
任何一个好的作品集都由多个工程构成，每一个工程都会展示 1-2 个上面所说的点。这是涵盖了“如何完成一个完整的数据科学作品集”系列文章的第一篇。在这篇文章中，我们将会涵括如何完成你的第一项数据科学作品集工程，并且对此进行有效的解释。在最后，你将会得到一个帮助展示你表达能力和解释数据能力的工程。
### 用数据讲故事
数据科学是表达的基础。你将会在数据中发现一些观点，并且找出一个高效的方式来向他人表达这些，之后向他们展示你所开展的课题。数据科学最关键的手法之一就是能够用数据讲述一个清晰的故事。一个清晰的故事能够使你的观点更加引人注目，并且能使别人理解你的想法。
数据科学中的故事是一个讲述你发现了什么，你怎么发现它的，并且它意味着什么的故事。例如假使发现你公司的收入相对去年减少了百分之二十。这并不能够确定原因，你可能需要和其它人沟通为什么收入会减少，并且在尝试修复它。
用数据讲故事主要包含：
* 理解并确定上下文
* 从多角度发掘
* 使用有趣的表示方法
* 使用多种数据来源
* 一致的表述
用来讲述数据的故事最有效率的工具就是 [Jupyter notebook](http://www.jupyter.org/)。如果你不熟悉，[此处](https://www.dataquest.io/blog/python-data-science/)有一个好的教程。Jupyter notebook 允许你交互式的发掘数据，并且将你的结果分享到多个网站，包括 Github。分享你的结果有助于合作研究和其他人拓展你的分析。
在这篇文章中，我们将使用 Jupyter notebook，以及 Pandas 和 matplotlib 这样的 Python 库。
### 为你的数据科学工程选择一个主题
建立一个工程的第一步就是决定你的主题。你要让你的主题是你兴趣所在，有动力去挖掘。进行数据挖掘时，为了完成而完成和有兴趣完成的区别是很明显的。这个步骤是值得花费时间的，所以确保你找到了你真正感兴趣的东西。
一个寻找主题的好方法就是浏览不同的数据集并且寻找感兴趣的部分。这里有一些作为起点的好的网站：
* [Data.gov](https://www.data.gov/) - 包含了政府数据。
* [/r/datasets](https://reddit.com/r/datasets) – 一个有着上百个有趣数据集的 reddit 板块。
* [Awesome datasets](https://github.com/caesar0301/awesome-public-datasets) – 一个数据集的列表，位于 Github 上。
* [17 个找到数据集的地方](https://www.dataquest.io/blog/free-datasets-for-projects/) – 这篇博文列出了 17 个数据集，每个都包含了示例数据集。
真实世界中的数据科学，你经常无法找到可以浏览的合适的单个数据集。你可能需要聚合多个独立的数据源，或者做数量庞大的数据清理。如果该主题非常吸引你，这是值得这样做的，并且也能更好的展示你的技能。
关于这篇文章的主题，我们将使用纽约市公立学校的数据，我们可以在[这里](https://data.cityofnewyork.us/data?cat=education)找到它。
### 选择主题
这对于项目全程来说是十分重要的。因为主题能很好的限制项目的范围，并且它能够使我们知道它可以被完成。比起一个没有足够动力完成的工程来说，添加到一个完成的工程更加容易。
所以，我们将关注高中的[学术评估测试](https://en.wikipedia.org/wiki/SAT)，伴随着多种人口统计和它们的其它数据。关于学习评估测试， 或者说 SAT，是美国高中生申请大学前的测试。大学在做判定时将考虑该成绩，所以高分是十分重要的。考试分为三个阶段，每个阶段总分为 800。全部分数为 2400（即使这个前后更改了几次，在数据中总分还是 2400）。高中经常通过平均 SAT分数进行排名，并且 SAT 是评判高中有多好的标准。
因为由关于 SAT 分数对于美国中某些种族群体是不公平的，所以对纽约市这个数据做分析能够对 SAT 的公平性有些许帮助。
我们在[这里](https://data.cityofnewyork.us/Education/SAT-Results/f9bf-2cp4)有 SAT 成绩的数据集，并且在[这里](https://data.cityofnewyork.us/Education/DOE-High-School-Directory-2014-2015/n3p6-zve2)有包含了每所高中的信息的数据集。这些将构成我们的工程的基础，但是我们将加入更多的信息来创建有趣的分析。
### 补充数据
如果你已经有了一个很好的主题，拓展其它可以提升主题或者更深入挖掘数据的的数据集是一个好的选择。在前期十分适合做这些工作，你将会有尽可能多的数据来构建你的工程。数据越少意味着你会太早的放弃了你的工程。
在本项目中，在包含人口统计信息和测试成绩的网站上有一些相关的数据集。
这些是我们将会用到的所有数据集：
* [学校 SAT 成绩](https://data.cityofnewyork.us/Education/SAT-Results/f9bf-2cp4) – 纽约市每所高中的 SAT 成绩。
* [学校出勤情况](https://data.cityofnewyork.us/Education/School-Attendance-and-Enrollment-Statistics-by-Dis/7z8d-msnt) – 纽约市每所学校的出勤信息。
* [数学成绩](https://data.cityofnewyork.us/Education/NYS-Math-Test-Results-By-Grade-2006-2011-School-Le/jufi-gzgp) – 纽约市每所学校的数学成绩。
* [班级规模](https://data.cityofnewyork.us/Education/2010-2011-Class-Size-School-level-detail/urz7-pzb3) - 纽约市每所学校课堂人数信息。
* [AP 成绩](https://data.cityofnewyork.us/Education/AP-College-Board-2010-School-Level-Results/itfs-ms3e) - 高阶位考试，在美国，通过 AP 测试就能获得大学学分。
* [毕业去向](https://data.cityofnewyork.us/Education/Graduation-Outcomes-Classes-Of-2005-2010-School-Le/vh2h-md7a) – 由百分之几的学生毕业了，和其它去向信息。
* [人口统计](https://data.cityofnewyork.us/Education/School-Demographics-and-Accountability-Snapshot-20/ihfw-zy9j) – 每个学校的人口统计信息。
* [学校问卷](https://data.cityofnewyork.us/Education/NYC-School-Survey-2011/mnz3-dyi8) – 学校的家长、教师，学生的问卷。
* [学校分布地图](https://data.cityofnewyork.us/Education/School-Districts/r8nu-ymqj) – 包含学校的区域布局信息，因此我们能将它们在地图上标出。
（LCTT 译注：高阶位考试（AP）是美国和加拿大的一个由大学委员会创建的计划，该计划为高中学生提供大学水平的课程和考试。 美国学院和大学可以授予在考试中获得高分的学生的就学和课程学分。）
这些数据作品集之间是相互关联的，并且我们能够在开始分析之前进行合并。
### 获取背景信息
在开始分析数据之前，搜索一些背景信息是有必要的。我们知道这些有用的信息：
* 纽约市被分为五个不同的辖区
* 纽约市的学校被分配到几个学区，每个学区都可能包含数十所学校。
* 数据集中的学校并不全是高中，所以我们需要对数据进行一些清理工作。
* 纽约市的每所学校都有自己单独的编码，被称为‘DBN’，即区域行政编号。
* 为了通过区域进行数据聚合，我们可以使用地图区域信息来绘制逐区差异。
### 理解数据
为了真正的理解数据信息，你需要花费时间来挖掘和阅读数据。因此，每个数据链接都有数据的描述信息，并伴随着相关列。就像是我们拥有的高中 SAT 成绩信息，也包含图像和其它信息的数据集。
我们可以运行一些代码来读取数据。我们将使用 [Jupyter notebook](http://jupyter.org/) 来挖掘数据。下面的代码将会执行以下操作：
* 循环遍历我们下载的所有数据文件。
* 将文件读取到 [Pandas DataFrame](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html)。
* 将所有数据框架导入 Python 数据库中。
In [100]:
```
import pandas
import numpy as np
files = ["ap_2010.csv", "class_size.csv", "demographics.csv", "graduation.csv", "hs_directory.csv", "math_test_results.csv", "sat_results.csv"]
data = {}
for f in files:
d = pandas.read_csv("schools/{0}".format(f))
data[f.replace(".csv", "")] = d
```
一旦我们将数据读入，我们就可以使用 DataFrames 的 [head](https://www.dataquest.io/blog/data-science-portfolio-project/) 方法打印每个 DataFrame 的前五行。
In [103]:
```
for k,v in data.items():
print("\n" + k + "\n")
print(v.head())
```
```
math_test_results
DBN Grade Year Category Number Tested Mean Scale Score Level 1 # \
0 01M015 3 2006 All Students 39 667 2
1 01M015 3 2007 All Students 31 672 2
2 01M015 3 2008 All Students 37 668 0
3 01M015 3 2009 All Students 33 668 0
4 01M015 3 2010 All Students 26 677 6
Level 1 % Level 2 # Level 2 % Level 3 # Level 3 % Level 4 # Level 4 % \
0 5.1% 11 28.2% 20 51.3% 6 15.4%
1 6.5% 3 9.7% 22 71% 4 12.9%
2 0% 6 16.2% 29 78.4% 2 5.4%
3 0% 4 12.1% 28 84.8% 1 3%
4 23.1% 12 46.2% 6 23.1% 2 7.7%
Level 3+4 # Level 3+4 %
0 26 66.7%
1 26 83.9%
2 31 83.8%
3 29 87.9%
4 8 30.8%
ap_2010
DBN SchoolName AP Test Takers \
0 01M448 UNIVERSITY NEIGHBORHOOD H.S. 39
1 01M450 EAST SIDE COMMUNITY HS 19
2 01M515 LOWER EASTSIDE PREP 24
3 01M539 NEW EXPLORATIONS SCI,TECH,MATH 255
4 02M296 High School of Hospitality Management s
Total Exams Taken Number of Exams with scores 3 4 or 5
0 49 10
1 21 s
2 26 24
3 377 191
4 s s
sat_results
DBN SCHOOL NAME \
0 01M292 HENRY STREET SCHOOL FOR INTERNATIONAL STUDIES
1 01M448 UNIVERSITY NEIGHBORHOOD HIGH SCHOOL
2 01M450 EAST SIDE COMMUNITY SCHOOL
3 01M458 FORSYTH SATELLITE ACADEMY
4 01M509 MARTA VALLE HIGH SCHOOL
Num of SAT Test Takers SAT Critical Reading Avg. Score SAT Math Avg. Score \
0 29 355 404
1 91 383 423
2 70 377 402
3 7 414 401
4 44 390 433
SAT Writing Avg. Score
0 363
1 366
2 370
3 359
4 384
class_size
CSD BOROUGH SCHOOL CODE SCHOOL NAME GRADE PROGRAM TYPE \
0 1 M M015 P.S. 015 Roberto Clemente 0K GEN ED
1 1 M M015 P.S. 015 Roberto Clemente 0K CTT
2 1 M M015 P.S. 015 Roberto Clemente 01 GEN ED
3 1 M M015 P.S. 015 Roberto Clemente 01 CTT
4 1 M M015 P.S. 015 Roberto Clemente 02 GEN ED
CORE SUBJECT (MS CORE and 9-12 ONLY) CORE COURSE (MS CORE and 9-12 ONLY) \
0 - -
1 - -
2 - -
3 - -
4 - -
SERVICE CATEGORY(K-9* ONLY) NUMBER OF STUDENTS / SEATS FILLED \
0 - 19.0
1 - 21.0
2 - 17.0
3 - 17.0
4 - 15.0
NUMBER OF SECTIONS AVERAGE CLASS SIZE SIZE OF SMALLEST CLASS \
0 1.0 19.0 19.0
1 1.0 21.0 21.0
2 1.0 17.0 17.0
3 1.0 17.0 17.0
4 1.0 15.0 15.0
SIZE OF LARGEST CLASS DATA SOURCE SCHOOLWIDE PUPIL-TEACHER RATIO
0 19.0 ATS NaN
1 21.0 ATS NaN
2 17.0 ATS NaN
3 17.0 ATS NaN
4 15.0 ATS NaN
demographics
DBN Name schoolyear fl_percent frl_percent \
0 01M015 P.S. 015 ROBERTO CLEMENTE 20052006 89.4 NaN
1 01M015 P.S. 015 ROBERTO CLEMENTE 20062007 89.4 NaN
2 01M015 P.S. 015 ROBERTO CLEMENTE 20072008 89.4 NaN
3 01M015 P.S. 015 ROBERTO CLEMENTE 20082009 89.4 NaN
4 01M015 P.S. 015 ROBERTO CLEMENTE 20092010 96.5
total_enrollment prek k grade1 grade2 ... black_num black_per \
0 281 15 36 40 33 ... 74 26.3
1 243 15 29 39 38 ... 68 28.0
2 261 18 43 39 36 ... 77 29.5
3 252 17 37 44 32 ... 75 29.8
4 208 16 40 28 32 ... 67 32.2
hispanic_num hispanic_per white_num white_per male_num male_per female_num \
0 189 67.3 5 1.8 158.0 56.2 123.0
1 153 63.0 4 1.6 140.0 57.6 103.0
2 157 60.2 7 2.7 143.0 54.8 118.0
3 149 59.1 7 2.8 149.0 59.1 103.0
4 118 56.7 6 2.9 124.0 59.6 84.0
female_per
0 43.8
1 42.4
2 45.2
3 40.9
4 40.4
[5 rows x 38 columns]
graduation
Demographic DBN School Name Cohort \
0 Total Cohort 01M292 HENRY STREET SCHOOL FOR INTERNATIONAL 2003
1 Total Cohort 01M292 HENRY STREET SCHOOL FOR INTERNATIONAL 2004
2 Total Cohort 01M292 HENRY STREET SCHOOL FOR INTERNATIONAL 2005
3 Total Cohort 01M292 HENRY STREET SCHOOL FOR INTERNATIONAL 2006
4 Total Cohort 01M292 HENRY STREET SCHOOL FOR INTERNATIONAL 2006 Aug
Total Cohort Total Grads - n Total Grads - % of cohort Total Regents - n \
0 5 s s s
1 55 37 67.3% 17
2 64 43 67.2% 27
3 78 43 55.1% 36
4 78 44 56.4% 37
Total Regents - % of cohort Total Regents - % of grads \
0 s s
1 30.9% 45.9%
2 42.2% 62.8%
3 46.2% 83.7%
4 47.4% 84.1%
... Regents w/o Advanced - n \
0 ... s
1 ... 17
2 ... 27
3 ... 36
4 ... 37
Regents w/o Advanced - % of cohort Regents w/o Advanced - % of grads \
0 s s
1 30.9% 45.9%
2 42.2% 62.8%
3 46.2% 83.7%
4 47.4% 84.1%
Local - n Local - % of cohort Local - % of grads Still Enrolled - n \
0 s s s s
1 20 36.4% 54.1% 15
2 16 25% 37.200000000000003% 9
3 7 9% 16.3% 16
4 7 9% 15.9% 15
Still Enrolled - % of cohort Dropped Out - n Dropped Out - % of cohort
0 s s s
1 27.3% 3 5.5%
2 14.1% 9 14.1%
3 20.5% 11 14.1%
4 19.2% 11 14.1%
[5 rows x 23 columns]
hs_directory
dbn school_name boro \
0 17K548 Brooklyn School for Music & Theatre Brooklyn
1 09X543 High School for Violin and Dance Bronx
2 09X327 Comprehensive Model School Project M.S. 327 Bronx
3 02M280 Manhattan Early College School for Advertising Manhattan
4 28Q680 Queens Gateway to Health Sciences Secondary Sc... Queens
building_code phone_number fax_number grade_span_min grade_span_max \
0 K440 718-230-6250 718-230-6262 9 12
1 X400 718-842-0687 718-589-9849 9 12
2 X240 718-294-8111 718-294-8109 6 12
3 M520 718-935-3477 NaN 9 10
4 Q695 718-969-3155 718-969-3552 6 12
expgrade_span_min expgrade_span_max \
0 NaN NaN
1 NaN NaN
2 NaN NaN
3 9 14.0
4 NaN NaN
... \
0 ...
1 ...
2 ...
3 ...
4 ...
priority02 \
0 Then to New York City residents
1 Then to New York City residents who attend an ...
2 Then to Bronx students or residents who attend...
3 Then to New York City residents who attend an ...
4 Then to Districts 28 and 29 students or residents
priority03 \
0 NaN
1 Then to Bronx students or residents
2 Then to New York City residents who attend an ...
3 Then to Manhattan students or residents
4 Then to Queens students or residents
priority04 priority05 \
0 NaN NaN
1 Then to New York City residents NaN
2 Then to Bronx students or residents Then to New York City residents
3 Then to New York City residents NaN
4 Then to New York City residents NaN
priority06 priority07 priority08 priority09 priority10 \
0 NaN NaN NaN NaN NaN
1 NaN NaN NaN NaN NaN
2 NaN NaN NaN NaN NaN
3 NaN NaN NaN NaN NaN
4 NaN NaN NaN NaN NaN
Location 1
0 883 Classon Avenue\nBrooklyn, NY 11225\n(40.67...
1 1110 Boston Road\nBronx, NY 10456\n(40.8276026...
2 1501 Jerome Avenue\nBronx, NY 10452\n(40.84241...
3 411 Pearl Street\nNew York, NY 10038\n(40.7106...
4 160-20 Goethals Avenue\nJamaica, NY 11432\n(40...
[5 rows x 58 columns]
```
我们可以开始在数据作品集中观察有用的部分：
* 大部分数据集包含 DBN 列。
* 一些条目看起来在地图上标出会很有趣，特别是 `Location 1`，这列在一个很长的字符串里面包含了位置信息。
* 有些数据集会出现每所学校对应多行数据（DBN 数据重复），这意味着我们要进行预处理。
### 统一数据
为了使工作更简单，我们将需要将全部零散的数据集统一为一个。这将使我们能够快速跨数据集对比数据列。因此，我们需要找到相同的列将它们统一起来。请查看上面的输出数据， DBN 出现在多个数据集中，它看起来可以作为共同列。
如果我们用 google 搜索 `DBN New York City Schools`，我们[在此](https://developer.cityofnewyork.us/api/doe-school-choice)得到了结果。它解释了 DBN 是每个学校独特的编码。我们将挖掘数据集，特别是政府数据集。这通常需要做一些工作来找出每列的含义，或者每个数据集的意图。
现在主要的问题是这两个数据集 `class_size` 和 `hs_directory`，没有 `DBN` 列。在 `hs_directory` 数据中是 `dbn`，那么我们只需重命名即可，或者将它复制到新的名为 DBN 的列中。在 `class_size` 数据中，我们将需要尝试不同的方法。
DBN 列：
In [5]:
```
data["demographics"]["DBN"].head()
```
Out[5]:
```
0 01M015
1 01M015
2 01M015
3 01M015
4 01M015
Name: DBN, dtype: object
```
如果我们查看 `class_size`数据，我们将看到前五行如下：
In [4]:
```
data["class_size"].head()
```
Out[4]:
| | CSD | BOROUGH | SCHOOL CODE | SCHOOL NAME | GRADE | PROGRAM TYPE | CORE SUBJECT (MS CORE and 9-12 ONLY) | CORE COURSE (MS CORE and 9-12 ONLY) | SERVICE CATEGORY(K-9\* ONLY) | NUMBER OF STUDENTS / SEATS FILLED | NUMBER OF SECTIONS | AVERAGE CLASS SIZE | SIZE OF SMALLEST CLASS | SIZE OF LARGEST CLASS | DATA SOURCE | SCHOOLWIDE PUPIL-TEACHER RATIO |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | GEN ED | - | - | - | 19.0 | 1.0 | 19.0 | 19.0 | 19.0 | ATS | NaN |
| 1 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | CTT | - | - | - | 21.0 | 1.0 | 21.0 | 21.0 | 21.0 | ATS | NaN |
| 2 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | GEN ED | - | - | - | 17.0 | 1.0 | 17.0 | 17.0 | 17.0 | ATS | NaN |
| 3 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | CTT | - | - | - | 17.0 | 1.0 | 17.0 | 17.0 | 17.0 | ATS | NaN |
| 4 | 1 | M | M015 | P.S. 015 Roberto Clemente | 02 | GEN ED | - | - | - | 15.0 | 1.0 | 15.0 | 15.0 | 15.0 | ATS | NaN |
正如上面所见，DBN 实际上是 `CSD`、 `BOROUGH` 和 `SCHOOL CODE` 的组合。对那些不熟悉纽约市的人来说，纽约由五个行政区组成。每个行政区是一个组织单位，并且有着相当于美国大城市一样的面积。DBN 全称为行政区域编号。看起来就像 CSD 是区域，BOROUGH 是行政区，并且当与 SCHOOL CODE 合并时就组成了 DBN。这里并没有寻找像这个数据这样的内在规律的系统方法，这需要一些探索和努力来发现。
现在我们已经知道了 DBN 的组成，那么我们就可以将它加入到 `class_size` 和 `hs_directory` 数据集中了：
In [ ]:
```
data["class_size"]["DBN"] = data["class_size"].apply(lambda x: "{0:02d}{1}".format(x["CSD"], x["SCHOOL CODE"]), axis=1)
data["hs_directory"]["DBN"] = data["hs_directory"]["dbn"]
```
#### 加入问卷
最可能值得一看的数据集之一就是学生、家长和老师关于学校质量的问卷了。这些问卷包含了每所学校的安全程度、教学水平等。在我们合并数据集之前，让我们添加问卷数据。在真实世界的数据科学工程中，你经常会在分析过程中碰到有趣的数据，并且希望合并它。使用像 Jupyter notebook 一样灵活的工具将允许你快速添加一些新的代码，并且重新开始你的分析。
因此，我们将添加问卷数据到我们的 data 文件夹，并且合并所有之前的数据。问卷数据分为两个文件，一个包含所有的学校，一个包含 75 学区。我们将需要写一些代码来合并它们。之后的代码我们将：
* 使用 windows-1252 编码读取所有学校的问卷。
* 使用 windows-1252 编码读取所有 75 号学区的问卷。
* 添加指示每个数据集所在学区的标志。
* 使用 DataFrame 的 [concat](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.concat.html) 方法将数据集合并为一个。
In [66]:
```
survey1 = pandas.read_csv("schools/survey_all.txt", delimiter="\t", encoding='windows-1252')
survey2 = pandas.read_csv("schools/survey_d75.txt", delimiter="\t", encoding='windows-1252')
survey1["d75"] = False
survey2["d75"] = True
survey = pandas.concat([survey1, survey2], axis=0)
```
一旦我们将问卷合并，这里将会有一些混乱。我们希望我们合并的数据集列数最少，那么我们将可以轻易的进行列之间的对比并找出其间的关联。不幸的是，问卷数据有很多列并不是很有用：
In [16]:
```
survey.head()
```
Out[16]:
| | N\_p | N\_s | N\_t | aca*p*11 | aca*s*11 | aca*t*11 | aca*tot*11 | bn | com*p*11 | com*s*11 | ... | t*q8c*1 | t*q8c*2 | t*q8c*3 | t*q8c*4 | t\_q9 | t*q9*1 | t*q9*2 | t*q9*3 | t*q9*4 | t*q9*5 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 90.0 | NaN | 22.0 | 7.8 | NaN | 7.9 | 7.9 | M015 | 7.6 | NaN | ... | 29.0 | 67.0 | 5.0 | 0.0 | NaN | 5.0 | 14.0 | 52.0 | 24.0 | 5.0 |
| 1 | 161.0 | NaN | 34.0 | 7.8 | NaN | 9.1 | 8.4 | M019 | 7.6 | NaN | ... | 74.0 | 21.0 | 6.0 | 0.0 | NaN | 3.0 | 6.0 | 3.0 | 78.0 | 9.0 |
| 2 | 367.0 | NaN | 42.0 | 8.6 | NaN | 7.5 | 8.0 | M020 | 8.3 | NaN | ... | 33.0 | 35.0 | 20.0 | 13.0 | NaN | 3.0 | 5.0 | 16.0 | 70.0 | 5.0 |
| 3 | 151.0 | 145.0 | 29.0 | 8.5 | 7.4 | 7.8 | 7.9 | M034 | 8.2 | 5.9 | ... | 21.0 | 45.0 | 28.0 | 7.0 | NaN | 0.0 | 18.0 | 32.0 | 39.0 | 11.0 |
| 4 | 90.0 | NaN | 23.0 | 7.9 | NaN | 8.1 | 8.0 | M063 | 7.9 | NaN | ... | 59.0 | 36.0 | 5.0 | 0.0 | NaN | 10.0 | 5.0 | 10.0 | 60.0 | 15.0 |
5 rows × 2773 columns
我们可以通过查看数据文件夹中伴随问卷数据下载下来的文件来解决这个问题。它告诉我们们数据中重要的部分是哪些：
我们可以去除 `survey` 数据集中多余的列：
In [17]:
```
survey["DBN"] = survey["dbn"]
survey_fields = ["DBN", "rr_s", "rr_t", "rr_p", "N_s", "N_t", "N_p", "saf_p_11", "com_p_11", "eng_p_11", "aca_p_11", "saf_t_11", "com_t_11", "eng_t_10", "aca_t_11", "saf_s_11", "com_s_11", "eng_s_11", "aca_s_11", "saf_tot_11", "com_tot_11", "eng_tot_11", "aca_tot_11",]
survey = survey.loc[:,survey_fields]
data["survey"] = survey
survey.shape
```
Out[17]:
```
(1702, 23)
```
请确保理你已经了解了每个数据集的内容和相关联的列，这能节约你之后大量的时间和精力：
### 精简数据集
如果我们查看某些数据集，包括 `class_size`，我们将立刻发现问题：
In [18]:
```
data["class_size"].head()
```
Out[18]:
| | CSD | BOROUGH | SCHOOL CODE | SCHOOL NAME | GRADE | PROGRAM TYPE | CORE SUBJECT (MS CORE and 9-12 ONLY) | CORE COURSE (MS CORE and 9-12 ONLY) | SERVICE CATEGORY(K-9\* ONLY) | NUMBER OF STUDENTS / SEATS FILLED | NUMBER OF SECTIONS | AVERAGE CLASS SIZE | SIZE OF SMALLEST CLASS | SIZE OF LARGEST CLASS | DATA SOURCE | SCHOOLWIDE PUPIL-TEACHER RATIO | DBN |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | GEN ED | - | - | - | 19.0 | 1.0 | 19.0 | 19.0 | 19.0 | ATS | NaN | 01M015 |
| 1 | 1 | M | M015 | P.S. 015 Roberto Clemente | 0K | CTT | - | - | - | 21.0 | 1.0 | 21.0 | 21.0 | 21.0 | ATS | NaN | 01M015 |
| 2 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | GEN ED | - | - | - | 17.0 | 1.0 | 17.0 | 17.0 | 17.0 | ATS | NaN | 01M015 |
| 3 | 1 | M | M015 | P.S. 015 Roberto Clemente | 01 | CTT | - | - | - | 17.0 | 1.0 | 17.0 | 17.0 | 17.0 | ATS | NaN | 01M015 |
| 4 | 1 | M | M015 | P.S. 015 Roberto Clemente | 02 | GEN ED | - | - | - | 15.0 | 1.0 | 15.0 | 15.0 | 15.0 | ATS | NaN | 01M015 |
每所高中都有许多行（正如你所见的重复的 `DBN` 和 `SCHOOL NAME`）。然而，如果我们看向 `sat_result` 数据集，每所高中只有一行：
In [21]:
```
data["sat_results"].head()
```
Out[21]:
| | DBN | SCHOOL NAME | Num of SAT Test Takers | SAT Critical Reading Avg. Score | SAT Math Avg. Score | SAT Writing Avg. Score |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 01M292 | HENRY STREET SCHOOL FOR INTERNATIONAL STUDIES | 29 | 355 | 404 | 363 |
| 1 | 01M448 | UNIVERSITY NEIGHBORHOOD HIGH SCHOOL | 91 | 383 | 423 | 366 |
| 2 | 01M450 | EAST SIDE COMMUNITY SCHOOL | 70 | 377 | 402 | 370 |
| 3 | 01M458 | FORSYTH SATELLITE ACADEMY | 7 | 414 | 401 | 359 |
| 4 | 01M509 | MARTA VALLE HIGH SCHOOL | 44 | 390 | 433 | 384 |
为了合并这些数据集，我们将需要找到方法将数据集精简到如 `class_size` 般一行对应一所高中。否则，我们将不能将 SAT 成绩与班级大小进行比较。我们通过首先更好的理解数据，然后做一些合并来完成。`class_size` 数据集像 `GRADE` 和 `PROGRAM TYPE`，每个学校有多个数据对应。为了将每个范围内的数据变为一个数据，我们将大部分重复行过滤掉，在下面的代码中我们将会：
* 只从 `class_size` 中选择 `GRADE` 范围为 `09-12` 的行。
* 只从 `class_size` 中选择 `PROGRAM TYPE` 是 `GEN ED` 的行。
* 将 `class_size` 以 `DBN` 分组，然后取每列的平均值。重要的是，我们将找到每所学校班级大小（`class_size`）平均值。
* 重置索引，将 `DBN` 重新加到列中。
In [68]:
```
class_size = data["class_size"]
class_size = class_size[class_size["GRADE "] == "09-12"]
class_size = class_size[class_size["PROGRAM TYPE"] == "GEN ED"]
class_size = class_size.groupby("DBN").agg(np.mean)
class_size.reset_index(inplace=True)
data["class_size"] = class_size
```
#### 精简其它数据集
接下来，我们将需要精简 `demographic` 数据集。这里有每个学校收集多年的数据，所以这里每所学校有许多重复的行。我们将只选取 `schoolyear` 最近的可用行：
In [69]:
```
demographics = data["demographics"]
demographics = demographics[demographics["schoolyear"] == 20112012]
data["demographics"] = demographics
```
我们需要精简 `math_test_results` 数据集。这个数据集被 `Grade` 和 `Year` 划分。我们将只选取单一学年的一个年级。
In [70]:
```
data["math_test_results"] = data["math_test_results"][data["math_test_results"]["Year"] == 2011]
data["math_test_results"] = data["math_test_results"][data["math_test_results"]["Grade"] == '8']
```
最后，`graduation`需要被精简：
In [71]:
```
data["graduation"] = data["graduation"][data["graduation"]["Cohort"] == "2006"]
data["graduation"] = data["graduation"][data["graduation"]["Demographic"] == "Total Cohort"]
```
在完成工程的主要部分之前数据清理和挖掘是十分重要的。有一个高质量的，一致的数据集将会使你的分析更加快速。
### 计算变量
计算变量可以通过使我们的比较更加快速来加快分析速度，并且能使我们做到本无法做到的比较。我们能做的第一件事就是从分开的列 `SAT Math Avg. Score`，`SAT Critical Reading Avg. Score` 和 `SAT Writing Avg. Score` 计算 SAT 成绩：
* 将 SAT 列数值从字符转化为数字。
* 将所有列相加以得到 `sat_score`，即 SAT 成绩。
In [72]:
```
cols = ['SAT Math Avg. Score', 'SAT Critical Reading Avg. Score', 'SAT Writing Avg. Score']
for c in cols:
data["sat_results"][c] = data["sat_results"][c].convert_objects(convert_numeric=True)
data['sat_results']['sat_score'] = data['sat_results'][cols[0]] + data['sat_results'][cols[1]] + data['sat_results'][cols[2]]
```
接下来，我们将需要进行每所学校的坐标位置分析，以便我们制作地图。这将使我们画出每所学校的位置。在下面的代码中，我们将会：
* 从 `Location 1` 列分析出经度和维度。
* 转化 `lat`（经度）和 `lon`（维度）为数字。
In [73]:
```
data["hs_directory"]['lat'] = data["hs_directory"]['Location 1'].apply(lambda x: x.split("\n")[-1].replace("(", "").replace(")", "").split(", ")[0])
data["hs_directory"]['lon'] = data["hs_directory"]['Location 1'].apply(lambda x: x.split("\n")[-1].replace("(", "").replace(")", "").split(", ")[1])
for c in ['lat', 'lon']:
data["hs_directory"][c] = data["hs_directory"][c].convert_objects(convert_numeric=True)
```
现在，我们将输出每个数据集来查看我们有了什么数据：
In [74]:
```
for k,v in data.items():
print(k)
print(v.head())
```
```
math_test_results
DBN Grade Year Category Number Tested Mean Scale Score \
111 01M034 8 2011 All Students 48 646
280 01M140 8 2011 All Students 61 665
346 01M184 8 2011 All Students 49 727
388 01M188 8 2011 All Students 49 658
411 01M292 8 2011 All Students 49 650
Level 1 # Level 1 % Level 2 # Level 2 % Level 3 # Level 3 % Level 4 # \
111 15 31.3% 22 45.8% 11 22.9% 0
280 1 1.6% 43 70.5% 17 27.9% 0
346 0 0% 0 0% 5 10.2% 44
388 10 20.4% 26 53.1% 10 20.4% 3
411 15 30.6% 25 51% 7 14.3% 2
Level 4 % Level 3+4 # Level 3+4 %
111 0% 11 22.9%
280 0% 17 27.9%
346 89.8% 49 100%
388 6.1% 13 26.5%
411 4.1% 9 18.4%
survey
DBN rr_s rr_t rr_p N_s N_t N_p saf_p_11 com_p_11 eng_p_11 \
0 01M015 NaN 88 60 NaN 22.0 90.0 8.5 7.6 7.5
1 01M019 NaN 100 60 NaN 34.0 161.0 8.4 7.6 7.6
2 01M020 NaN 88 73 NaN 42.0 367.0 8.9 8.3 8.3
3 01M034 89.0 73 50 145.0 29.0 151.0 8.8 8.2 8.0
4 01M063 NaN 100 60 NaN 23.0 90.0 8.7 7.9 8.1
... eng_t_10 aca_t_11 saf_s_11 com_s_11 eng_s_11 aca_s_11 \
0 ... NaN 7.9 NaN NaN NaN NaN
1 ... NaN 9.1 NaN NaN NaN NaN
2 ... NaN 7.5 NaN NaN NaN NaN
3 ... NaN 7.8 6.2 5.9 6.5 7.4
4 ... NaN 8.1 NaN NaN NaN NaN
saf_tot_11 com_tot_11 eng_tot_11 aca_tot_11
0 8.0 7.7 7.5 7.9
1 8.5 8.1 8.2 8.4
2 8.2 7.3 7.5 8.0
3 7.3 6.7 7.1 7.9
4 8.5 7.6 7.9 8.0
[5 rows x 23 columns]
ap_2010
DBN SchoolName AP Test Takers \
0 01M448 UNIVERSITY NEIGHBORHOOD H.S. 39
1 01M450 EAST SIDE COMMUNITY HS 19
2 01M515 LOWER EASTSIDE PREP 24
3 01M539 NEW EXPLORATIONS SCI,TECH,MATH 255
4 02M296 High School of Hospitality Management s
Total Exams Taken Number of Exams with scores 3 4 or 5
0 49 10
1 21 s
2 26 24
3 377 191
4 s s
sat_results
DBN SCHOOL NAME \
0 01M292 HENRY STREET SCHOOL FOR INTERNATIONAL STUDIES
1 01M448 UNIVERSITY NEIGHBORHOOD HIGH SCHOOL
2 01M450 EAST SIDE COMMUNITY SCHOOL
3 01M458 FORSYTH SATELLITE ACADEMY
4 01M509 MARTA VALLE HIGH SCHOOL
Num of SAT Test Takers SAT Critical Reading Avg. Score \
0 29 355.0
1 91 383.0
2 70 377.0
3 7 414.0
4 44 390.0
SAT Math Avg. Score SAT Writing Avg. Score sat_score
0 404.0 363.0 1122.0
1 423.0 366.0 1172.0
2 402.0 370.0 1149.0
3 401.0 359.0 1174.0
4 433.0 384.0 1207.0
class_size
DBN CSD NUMBER OF STUDENTS / SEATS FILLED NUMBER OF SECTIONS \
0 01M292 1 88.0000 4.000000
1 01M332 1 46.0000 2.000000
2 01M378 1 33.0000 1.000000
3 01M448 1 105.6875 4.750000
4 01M450 1 57.6000 2.733333
AVERAGE CLASS SIZE SIZE OF SMALLEST CLASS SIZE OF LARGEST CLASS \
0 22.564286 18.50 26.571429
1 22.000000 21.00 23.500000
2 33.000000 33.00 33.000000
3 22.231250 18.25 27.062500
4 21.200000 19.40 22.866667
SCHOOLWIDE PUPIL-TEACHER RATIO
0 NaN
1 NaN
2 NaN
3 NaN
4 NaN
demographics
DBN Name schoolyear \
6 01M015 P.S. 015 ROBERTO CLEMENTE 20112012
13 01M019 P.S. 019 ASHER LEVY 20112012
20 01M020 PS 020 ANNA SILVER 20112012
27 01M034 PS 034 FRANKLIN D ROOSEVELT 20112012
35 01M063 PS 063 WILLIAM MCKINLEY 20112012
fl_percent frl_percent total_enrollment prek k grade1 grade2 \
6 NaN 89.4 189 13 31 35 28
13 NaN 61.5 328 32 46 52 54
20 NaN 92.5 626 52 102 121 87
27 NaN 99.7 401 14 34 38 36
35 NaN 78.9 176 18 20 30 21
... black_num black_per hispanic_num hispanic_per white_num \
6 ... 63 33.3 109 57.7 4
13 ... 81 24.7 158 48.2 28
20 ... 55 8.8 357 57.0 16
27 ... 90 22.4 275 68.6 8
35 ... 41 23.3 110 62.5 15
white_per male_num male_per female_num female_per
6 2.1 97.0 51.3 92.0 48.7
13 8.5 147.0 44.8 181.0 55.2
20 2.6 330.0 52.7 296.0 47.3
27 2.0 204.0 50.9 197.0 49.1
35 8.5 97.0 55.1 79.0 44.9
[5 rows x 38 columns]
graduation
Demographic DBN School Name Cohort \
3 Total Cohort 01M292 HENRY STREET SCHOOL FOR INTERNATIONAL 2006
10 Total Cohort 01M448 UNIVERSITY NEIGHBORHOOD HIGH SCHOOL 2006
17 Total Cohort 01M450 EAST SIDE COMMUNITY SCHOOL 2006
24 Total Cohort 01M509 MARTA VALLE HIGH SCHOOL 2006
31 Total Cohort 01M515 LOWER EAST SIDE PREPARATORY HIGH SCHO 2006
Total Cohort Total Grads - n Total Grads - % of cohort Total Regents - n \
3 78 43 55.1% 36
10 124 53 42.7% 42
17 90 70 77.8% 67
24 84 47 56% 40
31 193 105 54.4% 91
Total Regents - % of cohort Total Regents - % of grads \
3 46.2% 83.7%
10 33.9% 79.2%
17 74.400000000000006% 95.7%
24 47.6% 85.1%
31 47.2% 86.7%
... Regents w/o Advanced - n \
3 ... 36
10 ... 34
17 ... 67
24 ... 23
31 ... 22
Regents w/o Advanced - % of cohort Regents w/o Advanced - % of grads \
3 46.2% 83.7%
10 27.4% 64.2%
17 74.400000000000006% 95.7%
24 27.4% 48.9%
31 11.4% 21%
Local - n Local - % of cohort Local - % of grads Still Enrolled - n \
3 7 9% 16.3% 16
10 11 8.9% 20.8% 46
17 3 3.3% 4.3% 15
24 7 8.300000000000001% 14.9% 25
31 14 7.3% 13.3% 53
Still Enrolled - % of cohort Dropped Out - n Dropped Out - % of cohort
3 20.5% 11 14.1%
10 37.1% 20 16.100000000000001%
17 16.7% 5 5.6%
24 29.8% 5 6%
31 27.5% 35 18.100000000000001%
[5 rows x 23 columns]
hs_directory
dbn school_name boro \
0 17K548 Brooklyn School for Music & Theatre Brooklyn
1 09X543 High School for Violin and Dance Bronx
2 09X327 Comprehensive Model School Project M.S. 327 Bronx
3 02M280 Manhattan Early College School for Advertising Manhattan
4 28Q680 Queens Gateway to Health Sciences Secondary Sc... Queens
building_code phone_number fax_number grade_span_min grade_span_max \
0 K440 718-230-6250 718-230-6262 9 12
1 X400 718-842-0687 718-589-9849 9 12
2 X240 718-294-8111 718-294-8109 6 12
3 M520 718-935-3477 NaN 9 10
4 Q695 718-969-3155 718-969-3552 6 12
expgrade_span_min expgrade_span_max ... \
0 NaN NaN ...
1 NaN NaN ...
2 NaN NaN ...
3 9 14.0 ...
4 NaN NaN ...
priority05 priority06 priority07 priority08 \
0 NaN NaN NaN NaN
1 NaN NaN NaN NaN
2 Then to New York City residents NaN NaN NaN
3 NaN NaN NaN NaN
4 NaN NaN NaN NaN
priority09 priority10 Location 1 \
0 NaN NaN 883 Classon Avenue\nBrooklyn, NY 11225\n(40.67...
1 NaN NaN 1110 Boston Road\nBronx, NY 10456\n(40.8276026...
2 NaN NaN 1501 Jerome Avenue\nBronx, NY 10452\n(40.84241...
3 NaN NaN 411 Pearl Street\nNew York, NY 10038\n(40.7106...
4 NaN NaN 160-20 Goethals Avenue\nJamaica, NY 11432\n(40...
DBN lat lon
0 17K548 40.670299 -73.961648
1 09X543 40.827603 -73.904475
2 09X327 40.842414 -73.916162
3 02M280 40.710679 -74.000807
4 28Q680 40.718810 -73.806500
[5 rows x 61 columns]
```
### 合并数据集
现在我们已经完成了全部准备工作，我们可以用 `DBN` 列将数据组合在一起了。最终，我们将会从原始数据集得到一个有着上百列的数据集。当我们合并它们，请注意有些数据集中会丢失了 `sat_result` 中出现的高中。为了解决这个问题，我们需要使用 `outer` 方法来合并缺少行的数据集，这样我们就不会丢失数据。在实际分析中，缺少数据是很常见的。能够展示解释和解决数据缺失的能力是构建一个作品集的重要部分。
你可以在[此](http://pandas.pydata.org/pandas-docs/stable/merging.html)阅读关于不同类型的合并。
接下来的代码，我们将会：
* 循环遍历 `data` 文件夹中的每一个条目。
* 输出条目中的非唯一的 DBN 码数量。
* 决定合并策略 - `inner` 或 `outer`。
* 使用 `DBN` 列将条目合并到 DataFrame `full` 中。
In [75]:
```
flat_data_names = [k for k,v in data.items()]
flat_data = [data[k] for k in flat_data_names]
full = flat_data[0]
for i, f in enumerate(flat_data[1:]):
name = flat_data_names[i+1]
print(name)
print(len(f["DBN"]) - len(f["DBN"].unique()))
join_type = "inner"
if name in ["sat_results", "ap_2010", "graduation"]:
join_type = "outer"
if name not in ["math_test_results"]:
full = full.merge(f, on="DBN", how=join_type)
full.shape
```
```
survey
0
ap_2010
1
sat_results
0
class_size
0
demographics
0
graduation
0
hs_directory
0
```
Out[75]:
```
(374, 174)
```
### 添加值
现在我们有了我们的 `full` 数据框架，我们几乎拥有分析需要的所有数据。虽然这里有一些缺少的部分。我们可能将[AP](https://apstudent.collegeboard.org/home) 考试结果与 SAT 成绩相关联，但是我们首先需要将这些列转化为数字，然后填充缺失的数据。
In [76]:
```
cols = ['AP Test Takers ', 'Total Exams Taken', 'Number of Exams with scores 3 4 or 5']
for col in cols:
full[col] = full[col].convert_objects(convert_numeric=True)
full[cols] = full[cols].fillna(value=0)
```
然后我们将需要计算表示学校所在学区的 `school_dist`列。这将是我们匹配学区并且使用我们之前下载的区域地图画出地区级别的地图。
In [77]:
```
full["school_dist"] = full["DBN"].apply(lambda x: x[:2])
```
最终，我们将需要用该列的平均值填充缺失的数据到 `full` 中。那么我们就可以计算关联了：
In [79]:
```
full = full.fillna(full.mean())
```
### 计算关联
一个挖掘数据并查看哪些列与你所关心的问题有联系的好方法来就是计算关联。这将告诉你哪列与你所关心的列更加有关联。你可以通过 Pandas DataFrames 的 [corr](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.corr.html) 方法来完成。越接近 0 则关联越小。越接近 1 则正相关越强，越接近 -1 则负关联越强：
In [80]:
```
full.corr()['sat_score']
```
Out[80]:
```
Year NaN
Number Tested 8.127817e-02
rr_s 8.484298e-02
rr_t -6.604290e-02
rr_p 3.432778e-02
N_s 1.399443e-01
N_t 9.654314e-03
N_p 1.397405e-01
saf_p_11 1.050653e-01
com_p_11 2.107343e-02
eng_p_11 5.094925e-02
aca_p_11 5.822715e-02
saf_t_11 1.206710e-01
com_t_11 3.875666e-02
eng_t_10 NaN
aca_t_11 5.250357e-02
saf_s_11 1.054050e-01
com_s_11 4.576521e-02
eng_s_11 6.303699e-02
aca_s_11 8.015700e-02
saf_tot_11 1.266955e-01
com_tot_11 4.340710e-02
eng_tot_11 5.028588e-02
aca_tot_11 7.229584e-02
AP Test Takers 5.687940e-01
Total Exams Taken 5.585421e-01
Number of Exams with scores 3 4 or 5 5.619043e-01
SAT Critical Reading Avg. Score 9.868201e-01
SAT Math Avg. Score 9.726430e-01
SAT Writing Avg. Score 9.877708e-01
...
SIZE OF SMALLEST CLASS 2.440690e-01
SIZE OF LARGEST CLASS 3.052551e-01
SCHOOLWIDE PUPIL-TEACHER RATIO NaN
schoolyear NaN
frl_percent -7.018217e-01
total_enrollment 3.668201e-01
ell_num -1.535745e-01
ell_percent -3.981643e-01
sped_num 3.486852e-02
sped_percent -4.413665e-01
asian_num 4.748801e-01
asian_per 5.686267e-01
black_num 2.788331e-02
black_per -2.827907e-01
hispanic_num 2.568811e-02
hispanic_per -3.926373e-01
white_num 4.490835e-01
white_per 6.100860e-01
male_num 3.245320e-01
male_per -1.101484e-01
female_num 3.876979e-01
female_per 1.101928e-01
Total Cohort 3.244785e-01
grade_span_max -2.495359e-17
expgrade_span_max NaN
zip -6.312962e-02
total_students 4.066081e-01
number_programs 1.166234e-01
lat -1.198662e-01
lon -1.315241e-01
Name: sat_score, dtype: float64
```
这给了我们一些我们需要探索的内在规律：
* `total_enrollment` 与 `sat_score` 强相关，这是令人惊讶的，因为你曾经认为越小的学校越专注于学生就会取得更高的成绩。
* 女生所占学校的比例（`female_per`） 与 SAT 成绩呈正相关，而男生所占学生比例（`male_per`）成负相关。
* 没有问卷与 SAT 成绩成正相关。
* SAT 成绩有明显的种族不平等（`white_per`、`asian_per`、`black_per`、`hispanic_per`）。
* `ell_percent` 与 SAT 成绩明显负相关。
每一个条目都是一个挖掘和讲述数据故事的潜在角度。
### 设置上下文
在我们开始数据挖掘之前，我们将希望设置上下文，不仅为了我们自己，也是为了其它阅读我们分析的人。一个好的方法就是建立挖掘图表或者地图。因此，我们将在地图标出所有学校的位置，这将有助于读者理解我们所探索的问题。
在下面的代码中，我们将会：
* 建立纽约市为中心的地图。
* 为城市里的每所高中添加一个标记。
* 显示地图。
In [82]:
```
import folium
from folium import plugins
schools_map = folium.Map(location=[full['lat'].mean(), full['lon'].mean()], zoom_start=10)
marker_cluster = folium.MarkerCluster().add_to(schools_map)
for name, row in full.iterrows():
folium.Marker([row["lat"], row["lon"]], popup="{0}: {1}".format(row["DBN"], row["school_name"])).add_to(marker_cluster)
schools_map.create_map('schools.html')
schools_map
```
Out[82]:
这个地图十分有用，但是不容易查看纽约哪里学校最多。因此，我们将用热力图来代替它：
In [84]:
```
schools_heatmap = folium.Map(location=[full['lat'].mean(), full['lon'].mean()], zoom_start=10)
schools_heatmap.add_children(plugins.HeatMap([[row["lat"], row["lon"]] for name, row in full.iterrows()]))
schools_heatmap.save("heatmap.html")
schools_heatmap
```
Out[84]:
### 区域级别映射
热力图能够很好的标出梯度，但是我们将需要更结构化的画出不同城市之间的 SAT 分数差距。学区是一个图形化这个信息的很好的方式，就像每个区域都有自己的管理者。纽约市有数十个学区，并且每个区域都是一个小的地理区域。
我们可以通过学区来计算 SAT 分数，然后将它们画在地图上。在下面的代码中，我们将会：
* 通过学区对 `full` 进行分组。
* 计算每个学区的每列的平均值。
* 去掉 `school_dist` 字段头部的 0，然后我们就可以匹配地理数据了。
In [ ]:
```
district_data = full.groupby("school_dist").agg(np.mean)
district_data.reset_index(inplace=True)
district_data["school_dist"] = district_data["school_dist"].apply(lambda x: str(int(x)))
```
我们现在将可以画出 SAT 在每个学区的平均值了。因此，我们将会读取 [GeoJSON](http://geojson.org/) 中的数据，转化为每个区域的形状，然后通过 `school_dist` 列对每个区域图形和 SAT 成绩进行匹配。最终我们将创建一个图形：
In [85]:
```
def show_district_map(col):
geo_path = 'schools/districts.geojson'
districts = folium.Map(location=[full['lat'].mean(), full['lon'].mean()], zoom_start=10)
districts.geo_json(
geo_path=geo_path,
data=district_data,
columns=['school_dist', col],
key_on='feature.properties.school_dist',
fill_color='YlGn',
fill_opacity=0.7,
line_opacity=0.2,
)
districts.save("districts.html")
return districts
show_district_map("sat_score")
```
Out[85]:
### 挖掘注册学生数与SAT分数
现在我们已经依地区画出学校位置和 SAT 成绩确定了上下文，浏览我们分析的人将会对数据的上下文有更好的理解。现在我们已经完成了基础工作，我们可以开始从我们上面寻找关联时所提到的角度分析了。第一个分析角度是学校注册学生人数与 SAT 成绩。
我们可以通过所有学校的注册学生与 SAT 成绩的散点图来分析。
In [87]:
```
%matplotlib inline
full.plot.scatter(x='total_enrollment', y='sat_score')
```
Out[87]:
```
<matplotlib.axes._subplots.AxesSubplot at 0x10fe79978>
```
如你所见，底下角注册人数较低的部分有个较低 SAT 成绩的聚集。这个集群以外，SAT 成绩与全部注册人数只有轻微正相关。这个画出的关联显示了意想不到的图形.
我们可以通过获取低注册人数且低SAT成绩的学校的名字进行进一步的分析。
In [88]:
```
full[(full["total_enrollment"] < 1000) & (full["sat_score"] < 1000)]["School Name"]
```
Out[88]:
```
34 INTERNATIONAL SCHOOL FOR LIBERAL ARTS
143 NaN
148 KINGSBRIDGE INTERNATIONAL HIGH SCHOOL
203 MULTICULTURAL HIGH SCHOOL
294 INTERNATIONAL COMMUNITY HIGH SCHOOL
304 BRONX INTERNATIONAL HIGH SCHOOL
314 NaN
317 HIGH SCHOOL OF WORLD CULTURES
320 BROOKLYN INTERNATIONAL HIGH SCHOOL
329 INTERNATIONAL HIGH SCHOOL AT PROSPECT
331 IT TAKES A VILLAGE ACADEMY
351 PAN AMERICAN INTERNATIONAL HIGH SCHOO
Name: School Name, dtype: object
```
在 Google 上进行了一些搜索确定了这些学校大多数是为了正在学习英语而开设的，所以有这么低注册人数（规模）。这个挖掘向我们展示了并不是所有的注册人数都与 SAT 成绩有关联 - 而是与是否将英语作为第二语言学习的学生有关。
### 挖掘英语学习者和 SAT 成绩
现在我们知道英语学习者所占学校学生比例与低的 SAT 成绩有关联，我们可以探索其中的规律。`ell_percent` 列表示一个学校英语学习者所占的比例。我们可以制作关于这个关联的散点图。
In [89]:
```
full.plot.scatter(x='ell_percent', y='sat_score')
```
Out[89]:
```
<matplotlib.axes._subplots.AxesSubplot at 0x10fe824e0>
```
看起来这里有一组学校有着高的 `ell_percentage` 值并且有着低的 SAT 成绩。我们可以在学区层面调查这个关系，通过找出每个学区英语学习者所占的比例，并且查看是否与我们的学区层面的 SAT 地图所匹配：
In [90]:
```
show_district_map("ell_percent")
```
Out[90]:
我们可通过两个区域层面地图来查看，一个低 ELL（English-language）学习者比例的地区更倾向有高 SAT 成绩，反之亦然。
### 关联问卷分数和 SAT 分数
学生、家长和老师的问卷结果如果与 SAT 分数有很大的关联的假设是合理的。就例如具有高学术期望的学校倾向于有着更高的 SAT 分数是合理的。为了测这个理论，让我们画出 SAT 分数和多种问卷指标：
In [91]:
```
full.corr()["sat_score"][["rr_s", "rr_t", "rr_p", "N_s", "N_t", "N_p", "saf_tot_11", "com_tot_11", "aca_tot_11", "eng_tot_11"]].plot.bar()
```
Out[91]:
```
<matplotlib.axes._subplots.AxesSubplot at 0x114652400>
```
惊人的是，关联最大的两个因子是 `N_p` 和 `N_s`，它们分别是家长和学生回应的问卷。都与注册人数有着强关联，所以很可能偏离了 `ell_learner`。此外指标关联最强的就是 `saf_t_11`，这是学生、家长和老师对学校安全程度的感知。这说明了，越安全的学校，更能让学生在环境里安心学习。然而其它因子，像互动、交流和学术水平都与 SAT 分数无关，这也许表明了纽约在问卷中问了不理想的问题或者想错了因子（如果他们的目的是提高 SAT 分数的话）。
### 挖掘种族和 SAT 分数
其中一个角度就是调查种族和 SAT 分数的联系。这是一个大相关微分，将其画出来帮助我们理解到底发生了什么：
In [92]:
```
full.corr()["sat_score"][["white_per", "asian_per", "black_per", "hispanic_per"]].plot.bar()
```
Out[92]:
```
<matplotlib.axes._subplots.AxesSubplot at 0x108166ba8>
```
看起来更高比例的白种和亚洲学生与更高的 SAT 分数有关联，而更高比例的黑人和西班牙裔与更低的 SAT 分数有关联。对于西班牙学生，这可能因为近年的移民还是英语学习者的事实。我们可以标出学区层面的西班牙裔的比例并观察联系。
In [93]:
```
show_district_map("hispanic_per")
```
Out[93]:
看起来这里与英语学习者比例有关联，但是有必要对这种和其它种族在 SAT 分数上的差异进行挖掘。
### SAT 分数上的性别差异
挖掘性别与 SAT 分数之间的关系是最后一个角度。我们注意更高的女生比例的学校倾向于与更高的 SAT 分数有关联。我们可以可视化为一个条形图：
In [94]:
```
full.corr()["sat_score"][["male_per", "female_per"]].plot.bar()
```
Out[94]:
```
<matplotlib.axes._subplots.AxesSubplot at 0x10774d0f0>
```
为了挖掘更多的关联性，我们可以制作一个 `female_per` 和 `sat_score` 的散点图：
In [95]:
```
full.plot.scatter(x='female_per', y='sat_score')
```
Out[95]:
```
<matplotlib.axes._subplots.AxesSubplot at 0x104715160>
```
看起来这里有一个高女生比例、高 SAT 成绩的簇（右上角）（LCTT 译注：此处散点图并未有如此迹象，可能数据图有误）。我们可以获取簇中学校的名字：
In [96]:
```
full[(full["female_per"] > 65) & (full["sat_score"] > 1400)]["School Name"]
```
Out[96]:
```
3 PROFESSIONAL PERFORMING ARTS HIGH SCH
92 ELEANOR ROOSEVELT HIGH SCHOOL
100 TALENT UNLIMITED HIGH SCHOOL
111 FIORELLO H. LAGUARDIA HIGH SCHOOL OF
229 TOWNSEND HARRIS HIGH SCHOOL
250 FRANK SINATRA SCHOOL OF THE ARTS HIGH SCHOOL
265 BARD HIGH SCHOOL EARLY COLLEGE
Name: School Name, dtype: object
```
使用 Google 进行搜索可以知道这些是专注于表演艺术的精英学校。这些学校有着更高比例的女生和更高的 SAT 分数。这可能解释了更高的女生比例和 SAT 分数的关联，并且相反的更高的男生比例与更低的 SAT 分数。
### AP 成绩
至今，我们关注的是人口统计角度。还有一个角度是我们通过数据来看参加高阶测试（AP）的学生和 SAT 分数。因为高学术成绩获得者倾向于有着高的 SAT 分数说明了它们是有关联的。
In [98]:
```
full["ap_avg"] = full["AP Test Takers "] / full["total_enrollment"]
full.plot.scatter(x='ap_avg', y='sat_score')
```
Out[98]:
```
<matplotlib.axes._subplots.AxesSubplot at 0x11463a908>
```
看起来它们之间确实有着很强的关联。有趣的是右上角高 SAT 分数的学校有着高的 AP 测试通过比例：
In [99]:
```
full[(full["ap_avg"] > .3) & (full["sat_score"] > 1700)]["School Name"]
```
Out[99]:
```
92 ELEANOR ROOSEVELT HIGH SCHOOL
98 STUYVESANT HIGH SCHOOL
157 BRONX HIGH SCHOOL OF SCIENCE
161 HIGH SCHOOL OF AMERICAN STUDIES AT LE
176 BROOKLYN TECHNICAL HIGH SCHOOL
229 TOWNSEND HARRIS HIGH SCHOOL
243 QUEENS HIGH SCHOOL FOR THE SCIENCES A
260 STATEN ISLAND TECHNICAL HIGH SCHOOL
Name: School Name, dtype: object
```
通过 google 搜索解释了那些大多是高选择性的学校，你需要经过测试才能进入。这就说明了为什么这些学校会有高的 AP 通过人数。
### 包装故事
在数据科学中，故事不可能真正完结。通过向其他人发布分析，你可以让他们拓展并且运用你的分析到他们所感兴趣的方向。比如在本文中，这里有一些角度我们没有完成，并且可以探索更加深入。
一个开始讲述故事的最好方式就是尝试拓展或者复制别人已经完成的分析。如果你觉得采取这个方式，欢迎你拓展这篇文章的分析，并看看你能发现什么。如果你确实这么做了，请在下面评论，那么我就可以看到了。
### 下一步
如果你做的足够多，你看起来已经对用数据讲故事和构建你的第一个数据科学作品集有了很好的理解。一旦你完成了你的数据科学工程，发表在 [Github](https://github.com/) 上是一个好的想法，这样别人就能够与你一起合作。
如果你喜欢这篇文章，你可能希望阅读我们‘Build a Data Science Portfolio’系列文章的其它部分：
* [如何搭建一个数据科学博客](https://www.dataquest.io/blog/how-to-setup-a-data-science-blog/)
* [建立一个机器学习工程](/article-7907-1.html)
* [构建一个将帮助你找到工作的数据科学作品集的关键](https://www.dataquest.io/blog/build-a-data-science-portfolio/)
* [17 个你能找到其它数据科学工程数据集的地方](https://www.dataquest.io/blog/free-datasets-for-projects)
* [怎样在 GitHub 上展示你的数据科学作品集](https://www.dataquest.io/blog/how-to-share-data-science-portfolio/)
---
via: <https://www.dataquest.io/blog/data-science-portfolio-project/>
作者：[Vik Paruchuri](http://twitter.com/vikparuchuri) 译者：[Yoo-4x] 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linus Torvalds 说针对性的模糊测试正提升 Linux 安全性
|
Liam Tung
|
http://www.zdnet.com/article/linus-torvalds-says-targeted-fuzzing-is-improving-linux-security/
|
模糊测试通过产生随机代码来引发错误来对系统进行压力测试，从而有助于识别潜在的安全漏洞。模糊测试可以帮助软件开发人员在向用户发布软件之前捕获错误。
|
/data/attachment/album/201710/23/144908tmjc3qpntw11xtpz.jpg.thumb.jpg
|
/data/attachment/album/201710/23/144908tmjc3qpntw11xtpz.jpg
| true
| false
| true
|
geekpi
| false
|
[
"测试",
"内核"
] |
观点
|
{
"viewnum": 4161,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
模糊测试通过产生随机代码来引发错误来对系统进行压力测试，从而有助于识别潜在的安全漏洞。模糊测试可以帮助软件开发人员在向用户发布软件之前捕获错误。
| 2017-10-23T14:49:04
| 2017-10-23T14:49:04
| 8,989
|
/article-8989-1.html
|
Linux 4.14 发布候选第五版已经出来。Linus Torvalds 说：“可以去测试了。”
随着宣布推出 Linux 内核 4.14 的第五个候选版本，Linus Torvalds 表示<ruby> 模糊测试 <rt> fuzzing </rt></ruby>正产生一系列稳定的安全更新。
模糊测试通过产生随机代码来引发错误来对系统进行压力测试，从而有助于识别潜在的安全漏洞。模糊测试可以帮助软件开发人员在向用户发布软件之前捕获错误。
Google 使用各种模糊测试工具来查找它及其它供应商软件中的错误。微软推出了 [Project Springfield](http://www.zdnet.com/article/microsoft-seeks-testers-for-project-springfield-bug-detection-service/) 模糊测试服务，它能让企业客户测试自己的软件。
正如 Torvalds 指出的那样，Linux 内核开发人员从一开始就一直在使用模糊测试流程，例如 1991 年发布的工具 “crashme”，它在近 20 年后被 [Google 安全研究员 Tavis Ormandy](http://taviso.decsystem.org/virtsec.pdf) 用来测试在虚拟机中处理不受信任的数据时，宿主机是否受到良好保护。
Torvalds [说](http://lkml.iu.edu/hypermail/linux/kernel/1710.1/06454.html)：“另外值得一提的是人们做了多少随机化模糊测试，而且这正在发现东西。”
“我们一直在做模糊测试（谁还记得只是生成随机代码，并跳转过去的老 “crashme” 程序？我们过去很早就这样做），人们在驱动子系统等方面做了一些很好的针对性模糊测试，而且已经有了各种各样的修复（不仅仅是上周的这些）。很高兴可以看到。”
Torvalds 提到，到目前为止，4.14 的发展“比预想的要麻烦一些”，但现在已经好了，并且在这个版本已经跑通了一些针对 x86 系统以及 AMD 芯片系统的修复。还有几个驱动程序、核心内核组件和工具的更新。
如前[所述](http://www.zdnet.com/article/first-linux-4-14-release-adds-very-core-features-arrives-in-time-for-kernels-26th-birthday/)，Linux 4.14 是 2017 年的长期稳定版本，迄今为止，它引入了核心内存管理功能、设备驱动程序更新以及文档、架构、文件系统、网络和工具的修改。
---
via: <http://www.zdnet.com/article/linus-torvalds-says-targeted-fuzzing-is-improving-linux-security/>
作者：[Liam Tung](http://www.zdnet.com/meet-the-team/eu/liam-tung/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：谁杀死了 MySQL
|
Daniel Stori
|
http://turnoff.us/geek/who-killed-mysql/
|
在这里 MySQL 意外被 SIGKILL 杀死了，没有留下任何遗言和痕迹（日志）。
|
/data/attachment/album/201710/23/164740ha3o4899iai7qg98.png.thumb.jpg
|
/data/attachment/album/201710/23/164740ha3o4899iai7qg98.png.large.jpg
| false
| false
| true
|
wxy
| false
|
[
"LAMP",
"MySQL",
"漫画",
"SIGKILL"
] |
极客漫画
|
{
"viewnum": 13165,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "116.19.93.10",
"message": "那到底是谁杀死了Mysql呢？",
"username": "phoenix_wangxd [Chrome 76.0|Mac 10.14]",
"date": "2019-09-02T20:54:40"
}
] |
[] |
在这里 MySQL 意外被 SIGKILL 杀死了，没有留下任何遗言和痕迹（日志）。
| 2017-10-23T16:47:21
| 2017-10-23T16:47:21
| 8,990
|
/article-8990-1.html
|
LAMP 架构，指 Linux + Apache + MySQL + PHP 组合构成的一个完整的 Web 服务架构。这是一个经典而有点过时的架构，适合于小型的 Web 服务。
在这里 MySQL 意外被 [SIGKILL](/article-8791-1.html) [杀死](/article-8771-1.html)了，没有留下任何遗言和痕迹（日志）。
---
via: <http://turnoff.us/geek/who-killed-mysql/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
回顾 Steam Machines 与 SteamOS
|
Calvin
|
https://www.gamingonlinux.com/articles/user-editorial-steam-machines-steamos-after-a-year-in-the-wild.8474
|
即使是在 Linux 桌面环境对于游戏的支持大步进步的今天，Steam Machines 作为一个平台依然没有飞跃，而 SteamOS 似乎也止步不前。这些由 Valve 发起的项目究竟怎么了？这些项目为何被发起，又是如何失败的？一些改进又是否曾有机会挽救这些项目的成败？
|
/data/attachment/album/201710/23/183038dcylwi4spln99qyq.jpg.thumb.jpg
|
/data/attachment/album/201710/23/183038dcylwi4spln99qyq.jpg
| true
| false
| true
|
Moelf
| false
|
[
"SteamOS",
"游戏"
] |
观点
|
{
"viewnum": 6242,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
即使是在 Linux 桌面环境对于游戏的支持大步进步的今天，Steam Machines 作为一个平台依然没有飞跃，而 SteamOS 似乎也止步不前。这些由 Valve 发起的项目究竟怎么了？这些项目为何被发起，又是如何失败的？一些改进又是否曾有机会挽救这些项目的成败？
| 2017-10-25T10:26:00
| 2017-10-25T10:26:00
| 8,991
|
/article-8991-1.html
|
去年今日（LCTT 译注：本文发表于 2016 年），在非常符合 Valve 风格的跳票之后，大众迎来了 [Steam Machines 的发布](https://www.gamingonlinux.com/articles/steam-machines-steam-link-steam-controller-officially-released-steamos-sale.6201)。即使是在 Linux 桌面环境对于游戏的支持大步进步的今天，Steam Machines 作为一个平台依然没有飞跃，而 SteamOS 似乎也止步不前。这些由 Valve 发起的项目究竟怎么了？这些项目为何被发起，又是如何失败的？一些改进又是否曾有机会挽救这些项目的成败？
### 行业环境
在 2012 年 Windows 8 发布的时候，微软像 iOS 与 Android 那样，为 Windows 集成了一个应用商店。在微软试图推广对触摸体验友好的界面时，为了更好的提供 “Metro” UI 语言指导下的沉浸式触摸体验，他们同时推出了一系列叫做 “WinRT” 的 API。然而为了能够使用这套 API，应用开发者们必须把应用程序通过 Windows 应用商城发布，并且正如其它应用商城那样，微软从中抽成 30%。对于 Valve 的 CEO，Gabe Newell (G 胖) 而言，这种限制发布平台和抽成行为是让人无法接受的，而且他前瞻地看到了微软利用行业龙头地位来推广 Windows 商店和 Metro 应用对于 Valve 潜在的危险，正如当年微软用 IE 浏览器击垮 Netscape 浏览器一样。
对于 Valve 来说，运行 Windows 的 PC 的优势在于任何人都可以不受操作系统和硬件方的限制运行各种软件。当像 Windows 这样的专有平台对像 Steam 这样的第三方软件限制越来越严格时，应用开发者们自然会想要寻找一个对任何人都更开放和自由的替代品，他们很自然的会想到 Linux 。Linux 本质上只是一套内核，但你可以轻易地使用 GNU 组件、Gnome 等软件在这套内核上开发出一个操作系统，比如 Ubuntu 就是这么来的。推行 Ubuntu 或者其他 Linux 发行版自然可以为 Valve 提供一个无拘无束的平台，以防止微软或者苹果变成 Valve 作为第三方平台之路上的的敌人，但 Linux 甚至给了 Valve 一个创造新的操作系统平台的机会。
### 概念化
如果我们把 Steam Machines 叫做主机的话，Valve 当时似乎认定了主机平台是一个机会。为了迎合用户对于电视主机平台用户界面的审美期待，同时也为了让玩家更好地从稍远的距离上在电视上玩游戏，Valve 为 Steam 推出了 Big Picture 模式。Steam Machines 的核心要点是开放性；比方说所有的软件都被设计成可以脱离 Windows 工作，又比如说 Steam Machines 手柄的 CAD 图纸也被公布出来以便支持玩家二次创作。
原初计划中，Valve 打算设计一款官方的 Steam Machine 作为旗舰机型。但最终，这些机型只在 2013 年的时候作为原型机给与了部分测试者用于测试。Valve 后来也允许像戴尔这样的 OEM 厂商们制造 Steam Machines，并且也赋予了他们制定价格和配置规格的权利。有一家叫做 “Xi3” 的公司展示了他们设计的 Steam Machine 小型机型，那款机型小到可以放在手掌上，这一新闻创造了围绕 Steam Machines 的更多热烈讨论。最终，Valve 决定不自己设计制造 Steam Machines，而全权交给 OEM 合作厂商们。
这一过程中还有很多天马行空的创意被列入考量，比如在手柄上加入生物识别技术、眼球追踪以及动作控制等。在这些最初的想法里，陀螺仪被加入了 Steam Controller 手柄，HTC Vive 的手柄也有各种动作追踪仪器；这些想法可能最初都来源于 Steam 手柄的设计过程中。手柄最初还有些更激进的设计，比如在中心放置一块可定制化并且会随着游戏内容变化的触摸屏。但最后的最后，发布会上的手柄偏向保守了许多，但也有诸如双触摸板和内置软件等黑科技。Valve 也考虑过制作面向笔记本类型硬件的 Steam Machines 和 SteamOS。这个企划最终没有任何成果，但也许 “Smach Z” 手持游戏机会是发展的方向之一。
在 [2013 年九月](https://www.gamingonlinux.com/articles/valve-announces-steam-machines-you-can-win-one-too.2469)，Valve 对外界宣布了 Steam Machines 和 SteamOS， 并且预告会在 2014 年中发布。前述的 300 台原型机在当年 12 月分发给了测试者们，随后次年 1 月，又分发给了开发者们 2000 台原型机。SteamOS 也在那段时间分发给有 Linux 经验的测试者们试用。根据当时的测试反馈，Valve 最终决定把产品发布延期到 2015 年 11 月。
SteamOS 的延期跳票给合作伙伴带来了问题；戴尔的 Steam Machine 由于早发售了一年，结果不得不改为搭配了额外软件、甚至运行着 Windows 操作系统的 Alienware Alpha。
### 正式发布
在最终的正式发布会上，Valve 和 OEM 合作商们发布了 Steam Machines，同时 Valve 还推出了 Steam Controller 手柄和 Steam Link 串流游戏设备。Valve 也在线下零售行业比如 GameStop 里开辟了货架空间。在发布会前，有几家 OEM 合作商退出了与 Valve 的合作；比如 Origin PC 和 Falcon Northwest 这两家高端精品主机设计商。他们宣称 Steam 生态的性能问题和一些限制迫使他们决定弃用 SteamOS。
Steam Machines 在发布后收到了褒贬不一的评价。另一方面 Steam Link 则普遍受到好评，很多人表示愿意在客厅电视旁为他们已有的 PC 系统购买 Steam Link， 而不是购置一台全新的 Steam Machine。Steam Controller 手柄则受到其丰富功能伴随而来的陡峭学习曲线影响，评价一败涂地。然而针对 Steam Machines 的批评则是最猛烈的。诸如 LinusTechTips 这样的评测团体 （LCTT 译注：YouTube 硬件界老大，个人也经常看他们节目）注意到了主机的明显的不足，其中甚至不乏性能为题。很多厂商的 Machines 都被批评为性价比极低，特别是经过和玩家们自己组装的同配置机器或者电视主机做对比之后。SteamOS 而被批评为兼容性有问题，Bug 太多，以及性能不及 Windows。在所有 Machines 里，戴尔的 Alienware Alpha 被评价为最有意思的一款，主要是由于品牌价值和机型外观极小的缘故。
通过把 Debian Linux 操作系统作为开发基础，Valve 得以为 SteamOS 平台找到很多原本就存在与 Steam 平台上的 Linux 兼容游戏来作为“首发游戏”。所以起初大家认为在“首发游戏”上 Steam Machines 对比其他新发布的主机优势明显。然而，很多宣称会在新平台上发布的游戏要么跳票要么被中断了。Rocket League 和 Mad Max 在宣布支持新平台整整一年后才真正发布，而《巫师 3》和《蝙蝠侠：阿克汉姆骑士》甚至从来没有发布在新平台上。就《巫师 3》的情况而言，他们的开发者 CD Projekt Red 拒绝承认他们曾经说过要支持新平台；然而他们的游戏曾在宣布支持 Linux 和 SteamOS 的游戏列表里赫然醒目。雪上加霜的是，很多 AAA 级的大作甚至没宣布移植，虽然最近这种情况稍有所好转了。
### 被忽视的
在 Stame Machines 发售后，Valve 的开发者们很快转移到了其他项目的工作中去了。在当时，VR 项目最为内部所重视，6 月份的时候大约有 1/3 的员工都在相关项目上工作。Valve 把 VR 视为亟待开发的一片领域，而他们的 Steam 则应该作为分发 VR 内容的生态环境。通过与 HTC 合作生产，Valve 设计并制造出了他们自己的 VR 头戴和手柄，并计划在将来更新换代。然而与此同时，Linux 和 Steam Machines 都渐渐淡出了视野。SteamVR 甚至直到最近才刚刚支持 Linux （其实还没对普通消费者开放使用，只在 SteamDevDays 上展示过对 Linux 的支持），而这一点则让我们怀疑 Valve 在 Stame Machines 和 Linux 的开发上是否下定了足够的决心。
SteamOS 自发布以来几乎止步不前。SteamOS 2.0 作为上一个大版本号更新，几乎只是同步了 Debian 上游的变化，而且还需要用户重新安装整个系统，而之后的小补丁也只是在做些上游更新的配合。当 Valve 在其他事关性能和用户体验的项目（例如 Mesa）上进步匪浅的时候，针对 Steam Machines 的相关项目则少有顾及。
很多原本应有的功能都从未完成。Steam 的内置功能，例如聊天和直播，都依然处于较弱的状态，而且这种落后会影响所有平台上的 Steam 用户体验。更具体来说，Steam 没有像其他主流主机平台一样把诸如 Netflix、Twitch 和 Spotify 之类的服务集成到客户端里，而通过 Steam 内置的浏览器使用这些服务则体验极差，甚至无法使用；而如果要使用第三方软件则需要开启 Terminal，而且很多软件甚至无法支持控制手柄 —— 无论从哪方面讲这样的用户界面体验都糟糕透顶。
Valve 同时也几乎没有花任何力气去推广他们的新平台，而选择把一切都交由 OEM 厂商们去做。然而，几乎所有 OEM 合作商们要么是高端主机定制商，要么是电脑生产商，要么是廉价电脑公司（LCTT 译注：简而言之没有一家有大型宣传渠道）。在所有 OEM 中，只有戴尔是 PC 市场的大碗，也只有他们真正给 Steam Machines 做了广告宣传。
最终销量也不尽人意。截至 2016 年 6 月，7 个月间 Steam Controller 手柄的销量在包括捆绑销售的情况下仅销售 500,000 件。这让 Steam Machines 的零售情况差到只能被归类到十万俱乐部的最底部。对比已经存在的巨大 PC 和主机游戏平台，可以说销量极低。
### 事后诸葛亮
既然知道了 Steam Machines 的历史，我们又能否总结出失败的原因以及可能存在的翻身改进呢？
#### 视野与目标
Steam Machines 从来没搞清楚他们在市场里的定位究竟是什么，也从来没说清楚他们具体有何优势。从 PC 市场的角度来说，自己搭建台式机已经非常普及，并且往往可以让电脑可以匹配玩家自己的目标，同时升级性也非常好。从主机平台的角度来说，Steam Machines 又被主机本身的相对廉价所打败，虽然算上游戏可能稍微便宜一些，但主机上的用户体验也直白很多。
PC 用户会把多功能性看得很重，他们不仅能用电脑打游戏，也一样能办公和做各种各样的事情。即使 Steam Machines 也是跑着的 SteamOS 操作系统的自由的 Linux 电脑，但操作系统和市场宣传加深了 PC 玩家们对 Steam Machines 是不可定制的硬件、低价的、更接近主机的印象。即使这些 PC 用户能接受在客厅里购置一台 Steam Machines，他们也有 Steam Link 可以选择，而且很多更小型机比如 NUC 和 Mini-ITX 主板定制机可以让他们搭建更适合放在客厅里的电脑。SteamOS 软件也允许把这些硬件转变为 Steam Machines，但寻求灵活性和兼容性的用户通常都会使用一般 Linux 发行版或者 Windows。何况最近的 Windows 和 Linux 桌面环境都让维护一般用户的操作系统变得自动化和简单了。
电视主机用户们则把易用性放在第一。虽然近年来主机的功能也逐渐扩展，比如可以播放视频或者串流，但总体而言用户还是把即插即用即玩、不用担心兼容性和性能问题和低门槛放在第一。主机的使用寿命也往往较长，一般在 4-7 年左右，而统一固定的硬件也让游戏开发者们能针对其更好的优化和调试软件。现在刚刚兴起的中生代升级，例如天蝎和 PS 4 Pro 则可能会打破这样统一的游戏体验，但无论如何厂商还是会要求开发者们需要保证游戏在原机型上的体验。为了提高用户粘性，主机也会有自己的社交系统和独占游戏。而主机上的游戏也有实体版，以便将来重用或者二手转卖，这对零售商和用户都是好事儿。Steam Machines 则完全没有这方面的保证；即使长的像一台客厅主机，他们却有 PC 高昂的价格和复杂的硬件情况。
#### 妥协
综上所述，Steam Machines 可以说是“集大成者”，吸取了两边的缺点，又没有自己明确的定位。更糟糕的是 Steam Machines 还展现了 PC 和主机都没有的毛病，比如没有 AAA 大作，又没有 Netflix 这样的客户端。抛开这些不说，Valve 在提高他们产品这件事上几乎没有出力，甚至没有尝试着解决 PC 和主机两头定位矛盾这一点。
然而在有些事情上也许原本 PC 和主机就没法折中妥协。像图像设定和 Mod 等内容的加入会无法保证“傻瓜机”一般的可靠，而且系统下层的复杂性也会逐渐暴露。
而最复杂的是 Steam Machines 多变的硬件情况，这使得用户不仅要考虑价格还要考虑配置，还要考虑这个价格下和别的系统（PC 和主机）比起来划算与否。更关键的是，Valve 无论如何也应该做出某种自动硬件检测机制，这样玩家才能知道是否能玩某个游戏，而且这个测试既得简单明了，又要能支持 Steam 上几乎所有游戏。同时，Valve 还要操心未来游戏对配置需求的变化，比如2016 年的 "A" 等主机三年后该给什么评分呢？
#### Valve, 个人努力与公司结构
尽管 Valve 在 Steam 上创造了辉煌，但其公司的内部结构可能对于开发一个像 Steam Machines 一样的平台是有害的。他们几乎没有领导的自由办公结构，以及所有人都可以自由移动到想要工作的项目组里决定了他们具有极大的创新，研发，甚至开发能力。据说 Valve 只愿意招他们眼中的的 “顶尖人才”，通过极其严格的筛选标准，并通过让他们在自己认为“有意义”的项目里工作以保持热情。然而这种思路很可能是错误的；拉帮结派总是存在，而 G胖的话或许比公司手册上写的还管用，而又有人时不时会由于特殊原因被雇佣或解雇。
正因为如此，很多虽不闪闪发光甚至维护起来有些无聊但又需要大量时间的项目很容易枯萎。Valve 的客服已是被人诟病已久的毛病，玩家经常觉得被无视了，而 Valve 则经常不到万不得已、法律要求的情况下绝不行动：例如自动退款系统，就是在澳大利亚和欧盟法律的要求下才被加入的；更有目前还没结案的华盛顿州 CS:GO 物品在线赌博网站一案。
各种因素最后也反映在 Steam Machines 这一项目上。Valve 方面的跳票迫使一些合作方做出了尴尬的决定，比如戴尔提前一年发布了 Alienware Alpha 外观的 Steam Machine 就在一年后的正式发布时显得硬件状况落后了。跳票很可能也导致了游戏数量上的问题。开发者和硬件合作商的对跳票和最终毫无轰动的发布也不明朗。Valve 的 VR 平台干脆直接不支持 Linux，而直到最近，SteamVR 都风风火火迭代了好几次之后，SteamOS 和 Linux 依然不支持 VR。
#### “长线钓鱼”
尽管 Valve 方面对未来的规划毫无透露，有些人依然认为 Valve 在 Steam Machine 和 SteamOS 上是放长线钓大鱼。他们论点是 Steam 本身也是这样的项目 —— 一开始作为游戏补丁平台出现，到现在无敌的游戏零售和玩家社交网络。虽然 Valve 的独占游戏比如《半条命 2》和 《CS》 也帮助了 Steam 平台的传播。但现今我们完全无法看到 Valve 像当初对 Steam 那样上心 Steam Machines。同时现在 Steam Machines 也面临着 Steam 从没碰到过的激烈竞争。而这些竞争里自然也包含 Valve 自己的那些把 Windows 作为平台的 Steam 客户端。
#### 真正目的
鉴于投入在 Steam Machines 上的努力如此之少，有些人怀疑整个产品平台是不是仅仅作为某种博弈的筹码才被开发出来。原初 Steam Machines 就发家于担心微软和苹果通过自己的应用市场垄断游戏的反制手段当中，Valve 寄希望于 Steam Machines 可以在不备之时脱离那些操作系统的支持而运行，同时也是提醒开发者们，也许有一日整个 Steam 平台会独立出来。而当微软和苹果等方面的风口没有继续收紧的情况下，Valve 自然就放慢了开发进度。然而我不这样认为；Valve 其实已经花了不少精力与硬件商和游戏开发者们共同推行这件事，不可能仅仅是为了吓吓他人就终止项目。你可以把这件事想成，微软和 Valve 都在吓唬对方 —— 微软推出了突然收紧的 Windows 8 ，而 Valve 则展示了一下可以独立门户的能力。
但即使如此，谁能保证开发者不会愿意跟着微软的封闭环境跑了呢？万一微软最后能提供更好的待遇和用户群体呢？更何况，微软现在正大力推行 Xbox 和 Windows 的交叉和整合，甚至 Xbox 独占游戏也出现在 Windows 上，这一切都没有损害 Windows 原本的平台性定位 —— 谁还能说微软方面不是 Steam 的直接竞争对手呢？
还会有人说这一切一切都是为了推进 Linux 生态环境尽快接纳 PC 游戏，而 Steam Machines 只是想为此大力推一把。但如果是这样，那这个目的实在是性价比极低，因为本愿意支持 Linux 的自然会开发，而 Steam Machines 这一出甚至会让开发者对平台期待额落空从而伤害到他们。
### 大家眼中 Valve 曾经的机会
我认为 Steam Machines 的创意还是很有趣的，而也有一个与之匹配的市场，但就结果而言 Valve 投入的创意和努力还不够多，而定位模糊也伤害了这个产品。我认为 Steam Machines 的优势在于能砍掉 PC 游戏传统的复杂性，比如硬件问题、整机寿命和维护等；但又能拥有游戏便宜，可以打 Mod 等好处，而且也可以做各种定制化以满足用户需求。但他们必须要让产品的核心内容：价格、市场营销、机型产品线还有软件的质量有所保证才行。
我认为 Steam Machines 可以做出一点妥协，比如硬件升级性（尽管这一点还是有可能被保留下来的 —— 但也要极为小心整个过程对用户体验的影响）和产品选择性，来减少摩擦成本。PC 一直会是一个并列的选项。想给用户产品可选性带来的只有一个困境，成吨的质量低下的 Steam Machines 根本不能解决。Valve 得自己造一台旗舰机型来指明 Steam Machines 的方向。毫无疑问，Alienware 的产品是最接近理想目标的，但它说到底也不是 Valve 的官方之作。Valve 内部不乏优秀的工业设计人才，如果他们愿意投入足够多的重视，我认为结果也许会值得他们努力。而像戴尔和 HTC 这样的公司则可以用他们丰富的经验帮 Valve 制造成品。直接钦定 Steam Machines 的硬件周期，并且在期间只推出 1-2 台机型也有助于帮助解决问题，更不用说他们还可以依次和开发商们确立性能的基准线。我不知道 OEM 合作商们该怎么办；如果 Valve 专注于自己的几台设备里，OEM 们很可能会变得多余甚至拖平台后腿。
我觉得修复软件问题是最关键的。很多问题在严重拖着 Steam Machines 的后腿，比如缺少主机上遍地都是、又能轻易安装在 PC 上的的 Netflix 和 Twitch，那么即使做好了客厅体验问题依然是严重的败笔。即使 Valve 已经在逐步购买电影的版权以便在 Steam 上发售，我觉得用户还是会倾向于去使用已经在市场上建立口碑的一些流媒体服务。这些问题需要被严肃地对待，因为玩家日益倾向于把主机作为家庭影院系统的一部分。同时，修复 Steam 客户端和平台的问题也很重要，和更多第三方服务商合作增加内容应该会是个好主意。性能问题和 Linux 下的显卡问题也很严重，不过好在他们最近在慢慢进步。移植游戏也是个问题。类似 Feral Interactive 或者 Aspyr Media 这样的游戏移植商可以帮助扩展 Steam 的商店游戏数量，但联系开发者和出版社可能会有问题，而且这两家移植商经常在移植的容器上搞自己的花样。Valve 已经在帮助游戏工作室自己移植游戏了，比如 Rocket League，不过这种情况很少见，而且就算 Valve 去帮忙了，也是非常符合 Valve 拖拉的风格。而 AAA 大作这一块内容也绝不应该被忽略 —— 近来这方面的情况已经有极大好转了，虽然 Linux 平台的支持好了很多，但在玩家数量不够以及 Valve 为 Steam Machines 提供的开发帮助甚少的情况下，Bethesda 这样的开发商依然不愿意移植游戏；同时，也有像 Denuvo 一样缺乏数字版权管理的公司难以向 Steam Machines 移植游戏。
在我看来 Valve 需要在除了软件和硬件的地方也多花些功夫。如果他们只有一个机型的话，他们可以很方便的在硬件生产上贴点钱。这样 Steam Machines 的价格就能跻身主机的行列，而且还能比自己组装 PC 要便宜。针对正确的市场群体做营销也很关键，即便我们还不知道目标玩家应该是谁（我个人会对这样的 Steam Machines 感兴趣，而且我有一整堆已经在 Steam 上以相当便宜的价格买下的游戏）。最后，我觉得零售商们其实不会对 Valve 的计划很感冒，毕竟他们要靠卖和倒卖实体游戏赚钱。
就算 Valve 在产品和平台上采纳过这些改进，我也不知道怎样才能激活 Steam Machines 的全市场潜力。总的来说，Valve 不仅得学习自己的经验教训，还应该参考曾经有过类似尝试的厂商们，比如尝试依靠开放平台的 3DO 和 Pippin；又或者那些从台式机体验的竞争力退赛的那些公司，其实 Valve 如今的情况和他们也有几分相似。亦或者他们也可以观察一下任天堂 Switch —— 毕竟任天堂也在尝试跨界的创新。
*注解: 上述点子由 liamdawe 整理，所有的想法都由用户提交。*
本文是被一位访客提交的，我们欢迎大家前来[提交文章](https://www.gamingonlinux.com/submit-article/)。
---
via: <https://www.gamingonlinux.com/articles/user-editorial-steam-machines-steamos-after-a-year-in-the-wild.8474>
作者：[calvin](https://www.gamingonlinux.com/profiles/5163) 译者：[Moelf](https://github.com/Moelf) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
JavaScript 函数式编程介绍
|
Matt Banz
|
https://opensource.com/article/17/6/functional-javascript
|
探索函数式编程，通过它让你的程序更具有可读性和易于调试
|
/data/attachment/album/201710/23/233346q2rwp5pozbopfgij.png.thumb.jpg
|
/data/attachment/album/201710/23/233346q2rwp5pozbopfgij.png
| true
| false
| true
|
trnhoe
| false
|
[
"函数式编程",
"JavaScript"
] |
软件开发
|
{
"viewnum": 6678,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 7842,
"displayorder": 0
},
{
"raid": 8869,
"displayorder": 1
}
] |
探索函数式编程，通过它让你的程序更具有可读性和易于调试
| 2017-10-26T08:30:00
| 2017-10-26T08:30:00
| 8,992
|
/article-8992-1.html
|
>
> 探索函数式编程，通过它让你的程序更具有可读性和易于调试
>
>
>
当 Brendan Eich 在 1995 年创造 JavaScript 时，他原本打算[将 Scheme 移植到浏览器里](https://brendaneich.com/2008/04/popularity/) 。Scheme 作为 Lisp 的方言，是一种函数式编程语言。而当 Eich 被告知新的语言应该是一种可以与 Java 相比的脚本语言后，他最终确立了一种拥有 C 风格语法的语言（也和 Java 一样），但将函数视作一等公民。而 Java 直到版本 8 才从技术上将函数视为一等公民，虽然你可以用匿名类来模拟它。这个特性允许 JavaScript 通过函数式范式编程。
JavaScript 是一个多范式语言，允许你自由地混合和使用面向对象式、过程式和函数式的编程范式。最近，函数式编程越来越火热。在诸如 [Angular](https://angular-2-training-book.rangle.io/handout/change-detection/change_detection_strategy_onpush.html) 和 [React](https://facebook.github.io/react/docs/optimizing-performance.html#the-power-of-not-mutating-data) 这样的框架中，通过使用不可变数据结构可以切实提高性能。不可变是函数式编程的核心原则，它以及纯函数使得编写和调试程序变得更加容易。使用函数来代替程序的循环可以提高程序的可读性并使它更加优雅。总之，函数式编程拥有很多优点。
### 什么不是函数式编程
在讨论什么是函数式编程前，让我们先排除那些不属于函数式编程的东西。实际上它们是你需要丢弃的语言组件（再见，老朋友）：
* 循环：
+ `while`
+ `do...while`
+ `for`
+ `for...of`
+ `for...in`
* 用 `var` 或者 `let` 来声明变量
* 没有返回值的函数
* 改变对象的属性 (比如: `o.x = 5;`)
* 改变数组本身的方法：
+ `copyWithin`
+ `fill`
+ `pop`
+ `push`
+ `reverse`
+ `shift`
+ `sort`
+ `splice`
+ `unshift`
* 改变映射本身的方法：
+ `clear`
+ `delete`
+ `set`
* 改变集合本身的方法：
+ `add`
+ `clear`
+ `delete`
脱离这些特性应该如何编写程序呢？这是我们将在后面探索的问题。
### 纯函数
你的程序中包含函数不一定意味着你正在进行函数式编程。函数式范式将<ruby> 纯函数 <rt> pure function </rt></ruby>和<ruby> 非纯函数 <rt> impure function </rt></ruby>区分开。鼓励你编写纯函数。纯函数必须满足下面的两个属性：
* 引用透明：函数在传入相同的参数后永远返回相同的返回值。这意味着该函数不依赖于任何可变状态。
* 无副作用：函数不能导致任何副作用。副作用可能包括 I/O（比如向终端或者日志文件写入），改变一个不可变的对象，对变量重新赋值等等。
我们来看一些例子。首先，`multiply` 就是一个纯函数的例子，它在传入相同的参数后永远返回相同的返回值，并且不会导致副作用。
```
function multiply(a, b) {
return a * b;
}
```
下面是非纯函数的例子。`canRide` 函数依赖捕获的 `heightRequirement` 变量。被捕获的变量不一定导致一个函数是非纯函数，除非它是一个可变的变量（或者可以被重新赋值）。这种情况下使用 `let` 来声明这个变量，意味着可以对它重新赋值。`multiply` 函数是非纯函数，因为它会导致在 console 上输出。
```
let heightRequirement = 46;
// Impure because it relies on a mutable (reassignable) variable.
function canRide(height) {
return height >= heightRequirement;
}
// Impure because it causes a side-effect by logging to the console.
function multiply(a, b) {
console.log('Arguments: ', a, b);
return a * b;
}
```
下面的列表包含着 JavaScript 内置的非纯函数。你可以指出它们不满足两个属性中的哪个吗？
* `console.log`
* `element.addEventListener`
* `Math.random`
* `Date.now`
* `$.ajax` (这里 `$` 代表你使用的 Ajax 库)
理想的程序中所有的函数都是纯函数，但是从上面的函数列表可以看出，任何有意义的程序都将包含非纯函数。大多时候我们需要进行 AJAX 调用，检查当前日期或者获取一个随机数。一个好的经验法则是遵循 80/20 规则：函数中有 80％ 应该是纯函数，剩下的 20％ 的必要性将不可避免地是非纯函数。
使用纯函数有几个优点：
* 它们很容易导出和调试，因为它们不依赖于可变的状态。
* 返回值可以被缓存或者“记忆”来避免以后重复计算。
* 它们很容易测试，因为没有需要模拟（mock）的依赖（比如日志，AJAX，数据库等等）。
你编写或者使用的函数返回空（换句话说它没有返回值），那代表它是非纯函数。
### 不变性
让我们回到捕获变量的概念上。来看看 `canRide` 函数。我们认为它是一个非纯函数，因为 `heightRequirement` 变量可以被重新赋值。下面是一个构造出来的例子来说明如何用不可预测的值来对它重新赋值。
```
let heightRequirement = 46;
function canRide(height) {
return height >= heightRequirement;
}
// Every half second, set heightRequirement to a random number between 0 and 200.
setInterval(() => heightRequirement = Math.floor(Math.random() * 201), 500);
const mySonsHeight = 47;
// Every half second, check if my son can ride.
// Sometimes it will be true and sometimes it will be false.
setInterval(() => console.log(canRide(mySonsHeight)), 500);
```
我要再次强调被捕获的变量不一定会使函数成为非纯函数。我们可以通过只是简单地改变 `heightRequirement` 的声明方式来使 `canRide` 函数成为纯函数。
```
const heightRequirement = 46;
function canRide(height) {
return height >= heightRequirement;
}
```
通过用 `const` 来声明变量意味着它不能被再次赋值。如果尝试对它重新赋值，运行时引擎将抛出错误；那么，如果用对象来代替数字来存储所有的“常量”怎么样？
```
const constants = {
heightRequirement: 46,
// ... other constants go here
};
function canRide(height) {
return height >= constants.heightRequirement;
}
```
我们用了 `const` ，所以这个变量不能被重新赋值，但是还有一个问题：这个对象可以被改变。下面的代码展示了，为了真正使其不可变，你不仅需要防止它被重新赋值，你也需要不可变的数据结构。JavaScript 语言提供了 `Object.freeze` 方法来阻止对象被改变。
```
'use strict';
// CASE 1: 对象的属性是可变的，并且变量可以被再次赋值。
let o1 = { foo: 'bar' };
// 改变对象的属性
o1.foo = 'something different';
// 对变量再次赋值
o1 = { message: "I'm a completely new object" };
// CASE 2: 对象的属性还是可变的，但是变量不能被再次赋值。
const o2 = { foo: 'baz' };
// 仍然能改变对象
o2.foo = 'Something different, yet again';
// 不能对变量再次赋值
// o2 = { message: 'I will cause an error if you uncomment me' }; // Error!
// CASE 3: 对象的属性是不可变的，但是变量可以被再次赋值。
let o3 = Object.freeze({ foo: "Can't mutate me" });
// 不能改变对象的属性
// o3.foo = 'Come on, uncomment me. I dare ya!'; // Error!
// 还是可以对变量再次赋值
o3 = { message: "I'm some other object, and I'm even mutable -- so take that!" };
// CASE 4: 对象的属性是不可变的，并且变量不能被再次赋值。这是我们想要的！！！！！！！！
const o4 = Object.freeze({ foo: 'never going to change me' });
// 不能改变对象的属性
// o4.foo = 'talk to the hand' // Error!
// 不能对变量再次赋值
// o4 = { message: "ain't gonna happen, sorry" }; // Error
```
不变性适用于所有的数据结构，包括数组、映射和集合。它意味着不能调用例如 `Array.prototype.push` 等会导致本身改变的方法，因为它会改变已经存在的数组。可以通过创建一个含有原来元素和新加元素的新数组，而不是将新元素加入一个已经存在的数组。其实所有会导致数组本身被修改的方法都可以通过一个返回修改好的新数组的函数代替。
```
'use strict';
const a = Object.freeze([4, 5, 6]);
// Instead of: a.push(7, 8, 9);
const b = a.concat(7, 8, 9);
// Instead of: a.pop();
const c = a.slice(0, -1);
// Instead of: a.unshift(1, 2, 3);
const d = [1, 2, 3].concat(a);
// Instead of: a.shift();
const e = a.slice(1);
// Instead of: a.sort(myCompareFunction);
const f = R.sort(myCompareFunction, a); // R = Ramda
// Instead of: a.reverse();
const g = R.reverse(a); // R = Ramda
// 留给读者的练习:
// copyWithin
// fill
// splice
```
[映射](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) 和 [集合](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) 也很相似。可以通过返回一个新的修改好的映射或者集合来代替使用会修改其本身的函数。
```
const map = new Map([
[1, 'one'],
[2, 'two'],
[3, 'three']
]);
// Instead of: map.set(4, 'four');
const map2 = new Map([...map, [4, 'four']]);
// Instead of: map.delete(1);
const map3 = new Map([...map].filter(([key]) => key !== 1));
// Instead of: map.clear();
const map4 = new Map();
```
```
const set = new Set(['A', 'B', 'C']);
// Instead of: set.add('D');
const set2 = new Set([...set, 'D']);
// Instead of: set.delete('B');
const set3 = new Set([...set].filter(key => key !== 'B'));
// Instead of: set.clear();
const set4 = new Set();
```
我想提一句如果你在使用 TypeScript（我非常喜欢 TypeScript），你可以用 `Readonly<T>`、`ReadonlyArray<T>`、`ReadonlyMap<K, V>` 和 `ReadonlySet<T>` 接口来在编译期检查你是否尝试更改这些对象，有则抛出编译错误。如果在对一个对象字面量或者数组调用 `Object.freeze`，编译器会自动推断它是只读的。由于映射和集合在其内部表达，所以在这些数据结构上调用 `Object.freeze` 不起作用。但是你可以轻松地告诉编译器它们是只读的变量。
*TypeScript 只读接口*
好，所以我们可以通过创建新的对象来代替修改原来的对象，但是这样不会导致性能损失吗？当然会。确保在你自己的应用中做了性能测试。如果你需要提高性能，可以考虑使用 [Immutable.js](https://facebook.github.io/immutable-js/)。Immutable.js 用[持久的数据结构](https://en.wikipedia.org/wiki/Persistent_data_structure) 实现了[链表](https://facebook.github.io/immutable-js/docs/#/List)、[堆栈](https://facebook.github.io/immutable-js/docs/#/Stack)、[映射](https://facebook.github.io/immutable-js/docs/#/Map)、[集合](https://facebook.github.io/immutable-js/docs/#/Set)和其他数据结构。使用了如同 Clojure 和 Scala 这样的函数式语言中相同的技术。
```
// Use in place of `[]`.
const list1 = Immutable.List(['A', 'B', 'C']);
const list2 = list1.push('D', 'E');
console.log([...list1]); // ['A', 'B', 'C']
console.log([...list2]); // ['A', 'B', 'C', 'D', 'E']
// Use in place of `new Map()`
const map1 = Immutable.Map([
['one', 1],
['two', 2],
['three', 3]
]);
const map2 = map1.set('four', 4);
console.log([...map1]); // [['one', 1], ['two', 2], ['three', 3]]
console.log([...map2]); // [['one', 1], ['two', 2], ['three', 3], ['four', 4]]
// Use in place of `new Set()`
const set1 = Immutable.Set([1, 2, 3, 3, 3, 3, 3, 4]);
const set2 = set1.add(5);
console.log([...set1]); // [1, 2, 3, 4]
console.log([...set2]); // [1, 2, 3, 4, 5]
```
### 函数组合
记不记得在中学时我们学过一些像 `(f ∘ g)(x)` 的东西？你那时可能想，“我什么时候会用到这些？”，好了，现在就用到了。你准备好了吗？`f ∘ g`读作 “函数 f 和函数 g 组合”。对它的理解有两种等价的方式，如等式所示： `(f ∘ g)(x) = f(g(x))`。你可以认为 `f ∘ g` 是一个单独的函数，或者视作将调用函数 `g` 的结果作为参数传给函数 `f`。注意这些函数是从右向左依次调用的，先执行 `g`，接下来执行 `f`。
关于函数组合的几个要点:
1. 我们可以组合任意数量的函数（不仅限于 2 个）。
2. 组合函数的一个方式是简单地把一个函数的输出作为下一个函数的输入（比如 `f(g(x))`）。
```
// h(x) = x + 1
// number -> number
function h(x) {
return x + 1;
}
// g(x) = x^2
// number -> number
function g(x) {
return x * x;
}
// f(x) = convert x to string
// number -> string
function f(x) {
return x.toString();
}
// y = (f ∘ g ∘ h)(1)
const y = f(g(h(1)));
console.log(y); // '4'
```
[Ramda](http://ramdajs.com/) 和 [lodash](https://github.com/lodash/lodash/wiki/FP-Guide) 之类的库提供了更优雅的方式来组合函数。我们可以在更多的在数学意义上处理函数组合，而不是简单地将一个函数的返回值传递给下一个函数。我们可以创建一个由这些函数组成的单一复合函数(就是 `(f ∘ g)(x)`)。
```
// h(x) = x + 1
// number -> number
function h(x) {
return x + 1;
}
// g(x) = x^2
// number -> number
function g(x) {
return x * x;
}
// f(x) = convert x to string
// number -> string
function f(x) {
return x.toString();
}
// R = Ramda
// composite = (f ∘ g ∘ h)
const composite = R.compose(f, g, h);
// Execute single function to get the result.
const y = composite(1);
console.log(y); // '4'
```
好了，我们可以在 JavaScript 中组合函数了。接下来呢？好，如果你已经入门了函数式编程，理想中你的程序将只有函数的组合。代码里没有循环（`for`, `for...of`, `for...in`, `while`, `do`），基本没有。你可能觉得那是不可能的。并不是这样。我们下面的两个话题是：递归和高阶函数。
### 递归
假设你想实现一个计算数字的阶乘的函数。 让我们回顾一下数学中阶乘的定义：
`n! = n * (n-1) * (n-2) * ... * 1`.
`n!` 是从 `n` 到 `1` 的所有整数的乘积。我们可以编写一个循环轻松地计算出结果。
```
function iterativeFactorial(n) {
let product = 1;
for (let i = 1; i <= n; i++) {
product *= i;
}
return product;
}
```
注意 `product` 和 `i` 都在循环中被反复重新赋值。这是解决这个问题的标准过程式方法。如何用函数式的方法解决这个问题呢？我们需要消除循环，确保没有变量被重新赋值。递归是函数式程序员的最有力的工具之一。递归需要我们将整体问题分解为类似整体问题的子问题。
计算阶乘是一个很好的例子，为了计算 `n!` 我们需要将 n 乘以所有比它小的正整数。它的意思就相当于：
`n! = n * (n-1)!`
啊哈！我们发现了一个解决 `(n-1)!` 的子问题，它类似于整个问题 `n!`。还有一个需要注意的地方就是基础条件。基础条件告诉我们何时停止递归。 如果我们没有基础条件，那么递归将永远持续。 实际上，如果有太多的递归调用，程序会抛出一个堆栈溢出错误。啊哈！
```
function recursiveFactorial(n) {
// Base case -- stop the recursion
if (n === 0) {
return 1; // 0! is defined to be 1.
}
return n * recursiveFactorial(n - 1);
}
```
然后我们来计算 `recursiveFactorial(20000)` 因为……，为什么不呢？当我们这样做的时候，我们得到了这个结果：
*堆栈溢出错误*
这里发生了什么？我们得到一个堆栈溢出错误！这不是无穷的递归导致的。我们已经处理了基础条件(`n === 0` 的情况)。那是因为浏览器的堆栈大小是有限的，而我们的代码使用了越过了这个大小的堆栈。每次对 `recursiveFactorial` 的调用导致了新的帧被压入堆栈中，就像一个盒子压在另一个盒子上。每当 `recursiveFactorial` 被调用，一个新的盒子被放在最上面。下图展示了在计算 `recursiveFactorial(3)` 时堆栈的样子。注意在真实的堆栈中，堆栈顶部的帧将存储在执行完成后应该返回的内存地址，但是我选择用变量 `r` 来表示返回值，因为 JavaScript 开发者一般不需要考虑内存地址。
*递归计算 3! 的堆栈（三次乘法）*
你可能会想象当计算 `n = 20000` 时堆栈会更高。我们可以做些什么优化它吗？当然可以。作为 ES2015 (又名 ES6) 标准的一部分，有一个优化用来解决这个问题。它被称作<ruby> 尾调用优化 <rt> proper tail calls optimization </rt></ruby>（PTC）。当递归函数做的最后一件事是调用自己并返回结果的时候，它使得浏览器删除或者忽略堆栈帧。实际上，这个优化对于相互递归函数也是有效的，但是为了简单起见，我们还是来看单一递归函数。
你可能会注意到，在递归函数调用之后，还要进行一次额外的计算（`n * r`）。那意味着浏览器不能通过 PTC 来优化递归；然而，我们可以通过重写函数使最后一步变成递归调用以便优化。一个窍门是将中间结果（在这里是 `product`）作为参数传递给函数。
```
'use strict';
// Optimized for tail call optimization.
function factorial(n, product = 1) {
if (n === 0) {
return product;
}
return factorial(n - 1, product * n)
}
```
让我们来看看优化后的计算 `factorial(3)` 时的堆栈。如下图所示，堆栈不会增长到超过两层。原因是我们把必要的信息都传到了递归函数中（比如 `product`）。所以，在 `product` 被更新后，浏览器可以丢弃掉堆栈中原先的帧。你可以在图中看到每次最上面的帧下沉变成了底部的帧，原先底部的帧被丢弃，因为不再需要它了。
*递归计算 3! 的堆栈（三次乘法）使用 PTC*
现在选一个浏览器运行吧，假设你在使用 Safari，你会得到 `Infinity`（它是比在 JavaScript 中能表达的最大值更大的数）。但是我们没有得到堆栈溢出错误，那很不错！现在在其他的浏览器中呢怎么样呢？Safari 可能现在乃至将来是实现 PTC 的唯一一个浏览器。看看下面的兼容性表格：
*PTC 兼容性*
其他浏览器提出了一种被称作<ruby> <a href="https://github.com/tc39/proposal-ptc-syntax#syntactic-tail-calls-stc"> 语法级尾调用 </a> <rt> syntactic tail calls </rt></ruby>（STC）的竞争标准。“语法级”意味着你需要用新的语法来标识你想要执行尾递归优化的函数。即使浏览器还没有广泛支持，但是把你的递归函数写成支持尾递归优化的样子还是一个好主意。
### 高阶函数
我们已经知道 JavaScript 将函数视作一等公民，可以把函数像其他值一样传递。所以，把一个函数传给另一个函数也很常见。我们也可以让函数返回一个函数。就是它！我们有高阶函数。你可能已经很熟悉几个在 `Array.prototype` 中的高阶函数。比如 `filter`、`map` 和 `reduce` 就在其中。对高阶函数的一种理解是：它是接受（一般会调用）一个回调函数参数的函数。让我们来看看一些内置的高阶函数的例子：
```
const vehicles = [
{ make: 'Honda', model: 'CR-V', type: 'suv', price: 24045 },
{ make: 'Honda', model: 'Accord', type: 'sedan', price: 22455 },
{ make: 'Mazda', model: 'Mazda 6', type: 'sedan', price: 24195 },
{ make: 'Mazda', model: 'CX-9', type: 'suv', price: 31520 },
{ make: 'Toyota', model: '4Runner', type: 'suv', price: 34210 },
{ make: 'Toyota', model: 'Sequoia', type: 'suv', price: 45560 },
{ make: 'Toyota', model: 'Tacoma', type: 'truck', price: 24320 },
{ make: 'Ford', model: 'F-150', type: 'truck', price: 27110 },
{ make: 'Ford', model: 'Fusion', type: 'sedan', price: 22120 },
{ make: 'Ford', model: 'Explorer', type: 'suv', price: 31660 }
];
const averageSUVPrice = vehicles
.filter(v => v.type === 'suv')
.map(v => v.price)
.reduce((sum, price, i, array) => sum + price / array.length, 0);
console.log(averageSUVPrice); // 33399
```
注意我们在一个数组对象上调用其方法，这是面向对象编程的特性。如果我们想要更函数式一些，我们可以用 Rmmda 或者 lodash/fp 提供的函数。注意如果我们使用 `R.compose` 的话，需要倒转函数的顺序，因为它从右向左依次调用函数（从底向上）；然而，如果我们想从左向右调用函数就像上面的例子，我们可以用 `R.pipe`。下面两个例子用了 Rmmda。注意 Rmmda 有一个 `mean` 函数用来代替 `reduce` 。
```
const vehicles = [
{ make: 'Honda', model: 'CR-V', type: 'suv', price: 24045 },
{ make: 'Honda', model: 'Accord', type: 'sedan', price: 22455 },
{ make: 'Mazda', model: 'Mazda 6', type: 'sedan', price: 24195 },
{ make: 'Mazda', model: 'CX-9', type: 'suv', price: 31520 },
{ make: 'Toyota', model: '4Runner', type: 'suv', price: 34210 },
{ make: 'Toyota', model: 'Sequoia', type: 'suv', price: 45560 },
{ make: 'Toyota', model: 'Tacoma', type: 'truck', price: 24320 },
{ make: 'Ford', model: 'F-150', type: 'truck', price: 27110 },
{ make: 'Ford', model: 'Fusion', type: 'sedan', price: 22120 },
{ make: 'Ford', model: 'Explorer', type: 'suv', price: 31660 }
];
// Using `pipe` executes the functions from top-to-bottom.
const averageSUVPrice1 = R.pipe(
R.filter(v => v.type === 'suv'),
R.map(v => v.price),
R.mean
)(vehicles);
console.log(averageSUVPrice1); // 33399
// Using `compose` executes the functions from bottom-to-top.
const averageSUVPrice2 = R.compose(
R.mean,
R.map(v => v.price),
R.filter(v => v.type === 'suv')
)(vehicles);
console.log(averageSUVPrice2); // 33399
```
使用函数式方法的优点是清楚地分开了数据（`vehicles`）和逻辑（函数 `filter`，`map` 和 `reduce`）。面向对象的代码相比之下把数据和函数用以方法的对象的形式混合在了一起。
### 柯里化
不规范地说，<ruby> 柯里化 <rt> currying </rt></ruby>是把一个接受 `n` 个参数的函数变成 `n` 个每个接受单个参数的函数的过程。函数的 `arity` 是它接受参数的个数。接受一个参数的函数是 `unary`，两个的是 `binary`，三个的是 `ternary`，`n` 个的是 `n-ary`。那么，我们可以把柯里化定义成将一个 `n-ary` 函数转换成 `n` 个 `unary` 函数的过程。让我们通过简单的例子开始，一个计算两个向量点积的函数。回忆一下线性代数，两个向量 `[a, b, c]` 和 `[x, y, z]` 的点积是 `ax + by + cz`。
```
function dot(vector1, vector2) {
return vector1.reduce((sum, element, index) => sum += element * vector2[index], 0);
}
const v1 = [1, 3, -5];
const v2 = [4, -2, -1];
console.log(dot(v1, v2)); // 1(4) + 3(-2) + (-5)(-1) = 4 - 6 + 5 = 3
```
`dot` 函数是 binary，因为它接受两个参数；然而我们可以将它手动转换成两个 unary 函数，就像下面的例子。注意 `curriedDot` 是一个 unary 函数，它接受一个向量并返回另一个接受第二个向量的 unary 函数。
```
function curriedDot(vector1) {
return function(vector2) {
return vector1.reduce((sum, element, index) => sum += element * vector2[index], 0);
}
}
// Taking the dot product of any vector with [1, 1, 1]
// is equivalent to summing up the elements of the other vector.
const sumElements = curriedDot([1, 1, 1]);
console.log(sumElements([1, 3, -5])); // -1
console.log(sumElements([4, -2, -1])); // 1
```
很幸运，我们不需要把每一个函数都手动转换成柯里化以后的形式。[Ramda](http://ramdajs.com/docs/#curry) 和 [lodash](https://lodash.com/docs/4.17.4#curry) 等库可以为我们做这些工作。实际上，它们是柯里化的混合形式。你既可以每次传递一个参数，也可以像原来一样一次传递所有参数。
```
function dot(vector1, vector2) {
return vector1.reduce((sum, element, index) => sum += element * vector2[index], 0);
}
const v1 = [1, 3, -5];
const v2 = [4, -2, -1];
// Use Ramda to do the currying for us!
const curriedDot = R.curry(dot);
const sumElements = curriedDot([1, 1, 1]);
console.log(sumElements(v1)); // -1
console.log(sumElements(v2)); // 1
// This works! You can still call the curried function with two arguments.
console.log(curriedDot(v1, v2)); // 3
```
Ramda 和 lodash 都允许你“跳过”一些变量之后再指定它们。它们使用置位符来做这些工作。因为点积的计算可以交换两项。传入向量的顺序不影响结果。让我们换一个例子来阐述如何使用一个置位符。Ramda 使用双下划线作为其置位符。
```
const giveMe3 = R.curry(function(item1, item2, item3) {
return `
1: ${item1}
2: ${item2}
3: ${item3}
`;
});
const giveMe2 = giveMe3(R.__, R.__, 'French Hens'); // Specify the third argument.
const giveMe1 = giveMe2('Partridge in a Pear Tree'); // This will go in the first slot.
const result = giveMe1('Turtle Doves'); // Finally fill in the second argument.
console.log(result);
// 1: Partridge in a Pear Tree
// 2: Turtle Doves
// 3: French Hens
```
在我们结束探讨柯里化之前最后的议题是<ruby> 偏函数应用 <rt> partial application </rt></ruby>。偏函数应用和柯里化经常同时出场，尽管它们实际上是不同的概念。一个柯里化的函数还是柯里化的函数，即使没有给它任何参数。偏函数应用，另一方面是仅仅给一个函数传递部分参数而不是所有参数。柯里化是偏函数应用常用的方法之一，但是不是唯一的。
JavaScript 拥有一个内置机制可以不依靠柯里化来做偏函数应用。那就是 [function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) 方法。这个方法的一个特殊之处在于，它要求你将 `this` 作为第一个参数传入。 如果你不进行面向对象编程，那么你可以通过传入 `null` 来忽略 `this`。
```
1function giveMe3(item1, item2, item3) {
return `
1: ${item1}
2: ${item2}
3: ${item3}
`;
}
const giveMe2 = giveMe3.bind(null, 'rock');
const giveMe1 = giveMe2.bind(null, 'paper');
const result = giveMe1('scissors');
console.log(result);
// 1: rock
// 2: paper
// 3: scissors
```
### 总结
我希望你享受探索 JavaScript 中函数式编程的过程。对一些人来说，它可能是一个全新的编程范式，但我希望你能尝试它。你会发现你的程序更易于阅读和调试。不变性还将允许你优化 Angular 和 React 的性能。
*这篇文章基于 Matt 在 OpenWest 的演讲 [JavaScript the Good-er Parts](https://www.openwest.org/schedule/#talk-5). [OpenWest](https://www.openwest.org/) ~~将~~在 6/12-15 ,2017 在 Salt Lake City, Utah 举行。*
---
作者简介：
Matt Banz - Matt 于 2008 年五月在犹他大学获得了数学学位毕业。一个月后他得到了一份 web 开发者的工作，他从那时起就爱上了它！在 2013 年，他在北卡罗莱纳州立大学获得了计算机科学硕士学位。他在 LDS 商学院和戴维斯学区社区教育计划教授 Web 课程。他现在是就职于 Motorola Solutions 公司的高级前端开发者。
---
via: <https://opensource.com/article/17/6/functional-javascript>
作者：[Matt Banz](https://opensource.com/users/battmanz) 译者：[trnhoe](https://github.com/trnhoe) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
并发服务器（一）：简介
|
Eli Bendersky
|
https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/
|
这是关于并发网络服务器编程的第一篇教程。我计划测试几个主流的、可以同时处理多个客户端请求的服务器并发模型，基于可扩展性和易实现性对这些模型进行评判。所有的服务器都会监听套接字连接，并且实现一些简单的协议用于与客户端进行通讯。
|
/data/attachment/album/201710/24/115622i0oaajarc8aaryn6.jpg.thumb.jpg
|
/data/attachment/album/201710/24/115622i0oaajarc8aaryn6.jpg
| true
| false
| true
|
BriFuture
| false
|
[
"并发"
] |
软件开发
|
{
"viewnum": 9233,
"commentnum": 0,
"favtimes": 8,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9002,
"displayorder": 0
}
] |
这是关于并发网络服务器编程的第一篇教程。我计划测试几个主流的、可以同时处理多个客户端请求的服务器并发模型，基于可扩展性和易实现性对这些模型进行评判。所有的服务器都会监听套接字连接，并且实现一些简单的协议用于与客户端进行通讯。
| 2017-10-25T09:46:00
| 2017-10-25T09:46:00
| 8,993
|
/article-8993-1.html
|
这是关于并发网络服务器编程的第一篇教程。我计划测试几个主流的、可以同时处理多个客户端请求的服务器并发模型，基于可扩展性和易实现性对这些模型进行评判。所有的服务器都会监听套接字连接，并且实现一些简单的协议用于与客户端进行通讯。
该系列的所有文章：
* [第一节 - 简介](http://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/)
* [第二节 - 线程](http://eli.thegreenplace.net/2017/concurrent-servers-part-2-threads/)
* [第三节 - 事件驱动](http://eli.thegreenplace.net/2017/concurrent-servers-part-3-event-driven/)
### 协议
该系列教程所用的协议都非常简单，但足以展示并发服务器设计的许多有趣层面。而且这个协议是 *有状态的* —— 服务器根据客户端发送的数据改变内部状态，然后根据内部状态产生相应的行为。并非所有的协议都是有状态的 —— 实际上，基于 HTTP 的许多协议是无状态的，但是有状态的协议也是很常见，值得认真讨论。
在服务器端看来，这个协议的视图是这样的：
总之：服务器等待新客户端的连接；当一个客户端连接的时候，服务器会向该客户端发送一个 `*` 字符，进入“等待消息”的状态。在该状态下，服务器会忽略客户端发送的所有字符，除非它看到了一个 `^` 字符，这表示一个新消息的开始。这个时候服务器就会转变为“正在通信”的状态，这时它会向客户端回送数据，把收到的所有字符的每个字节加 1 回送给客户端<sup> 注1</sup> 。当客户端发送了 `$` 字符，服务器就会退回到等待新消息的状态。`^` 和 `$` 字符仅仅用于分隔消息 —— 它们不会被服务器回送。
每个状态之后都有个隐藏的箭头指向 “等待客户端” 状态，用于客户端断开连接。因此，客户端要表示“我已经结束”的方法很简单，关掉它那一端的连接就好。
显然，这个协议是真实协议的简化版，真实使用的协议一般包含复杂的报文头、转义字符序列（例如让消息体中可以出现 `$` 符号），额外的状态变化。但是我们这个协议足以完成期望。
另一点：这个系列是介绍性的，并假设客户端都工作的很好（虽然可能运行很慢）；因此没有设置超时，也没有设置特殊的规则来确保服务器不会因为客户端的恶意行为（或是故障）而出现阻塞，导致不能正常结束。
### 顺序服务器
这个系列中我们的第一个服务端程序是一个简单的“顺序”服务器，用 C 进行编写，除了标准的 POSIX 中用于套接字的内容以外没有使用其它库。服务器程序是顺序，因为它一次只能处理一个客户端的请求；当有客户端连接时，像之前所说的那样，服务器会进入到状态机中，并且不再监听套接字接受新的客户端连接，直到当前的客户端结束连接。显然这不是并发的，而且即便在很少的负载下也不能服务多个客户端，但它对于我们的讨论很有用，因为我们需要的是一个易于理解的基础。
这个服务器的完整代码在[这里](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/sequential-server.c)；接下来，我会着重于一些重点的部分。`main` 函数里面的外层循环用于监听套接字，以便接受新客户端的连接。一旦有客户端进行连接，就会调用 `serve_connection`，这个函数中的代码会一直运行，直到客户端断开连接。
顺序服务器在循环里调用 `accept` 用来监听套接字，并接受新连接：
```
while (1) {
struct sockaddr_in peer_addr;
socklen_t peer_addr_len = sizeof(peer_addr);
int newsockfd =
accept(sockfd, (struct sockaddr*)&peer_addr, &peer_addr_len);
if (newsockfd < 0) {
perror_die("ERROR on accept");
}
report_peer_connected(&peer_addr, peer_addr_len);
serve_connection(newsockfd);
printf("peer done\n");
}
```
`accept` 函数每次都会返回一个新的已连接的套接字，然后服务器调用 `serve_connection`；注意这是一个 *阻塞式* 的调用 —— 在 `serve_connection` 返回前，`accept` 函数都不会再被调用了；服务器会被阻塞，直到客户端结束连接才能接受新的连接。换句话说，客户端按 *顺序* 得到响应。
这是 `serve_connection` 函数：
```
typedef enum { WAIT_FOR_MSG, IN_MSG } ProcessingState;
void serve_connection(int sockfd) {
if (send(sockfd, "*", 1, 0) < 1) {
perror_die("send");
}
ProcessingState state = WAIT_FOR_MSG;
while (1) {
uint8_t buf[1024];
int len = recv(sockfd, buf, sizeof buf, 0);
if (len < 0) {
perror_die("recv");
} else if (len == 0) {
break;
}
for (int i = 0; i < len; ++i) {
switch (state) {
case WAIT_FOR_MSG:
if (buf[i] == '^') {
state = IN_MSG;
}
break;
case IN_MSG:
if (buf[i] == '$') {
state = WAIT_FOR_MSG;
} else {
buf[i] += 1;
if (send(sockfd, &buf[i], 1, 0) < 1) {
perror("send error");
close(sockfd);
return;
}
}
break;
}
}
}
close(sockfd);
}
```
它完全是按照状态机协议进行编写的。每次循环的时候，服务器尝试接收客户端的数据。收到 0 字节意味着客户端断开连接，然后循环就会退出。否则，会逐字节检查接收缓存，每一个字节都可能会触发一个状态。
`recv` 函数返回接收到的字节数与客户端发送消息的数量完全无关（`^...$` 闭合序列的字节）。因此，在保持状态的循环中遍历整个缓冲区很重要。而且，每一个接收到的缓冲中可能包含多条信息，但也有可能开始了一个新消息，却没有显式的结束字符；而这个结束字符可能在下一个缓冲中才能收到，这就是处理状态在循环迭代中进行维护的原因。
例如，试想主循环中的 `recv` 函数在某次连接中返回了三个非空的缓冲：
1. `^abc$de^abte$f`
2. `xyz^123`
3. `25$^ab$abab`
服务端返回的是哪些数据？追踪代码对于理解状态转变很有用。（答案见<sup> 注 <a href="https://en.wikipedia.org/wiki/Mealy_machine"> 2 </a></sup> ）
### 多个并发客户端
如果多个客户端在同一时刻向顺序服务器发起连接会发生什么事情？
服务器端的代码（以及它的名字 “顺序服务器”）已经说的很清楚了，一次只能处理 *一个* 客户端的请求。只要服务器在 `serve_connection` 函数中忙于处理客户端的请求，就不会接受别的客户端的连接。只有当前的客户端断开了连接，`serve_connection` 才会返回，然后最外层的循环才能继续执行接受其他客户端的连接。
为了演示这个行为，[该系列教程的示例代码](https://github.com/eliben/code-for-blog/tree/master/2017/async-socket-server) 包含了一个 Python 脚本，用于模拟几个想要同时连接服务器的客户端。每一个客户端发送类似之前那样的三个数据缓冲 <sup> 注3</sup> ，不过每次发送数据之间会有一定延迟。
客户端脚本在不同的线程中并发地模拟客户端行为。这是我们的序列化服务器与客户端交互的信息记录：
```
$ python3.6 simple-client.py -n 3 localhost 9090
INFO:2017-09-16 14:14:17,763:conn1 connected...
INFO:2017-09-16 14:14:17,763:conn1 sending b'^abc$de^abte$f'
INFO:2017-09-16 14:14:17,763:conn1 received b'b'
INFO:2017-09-16 14:14:17,802:conn1 received b'cdbcuf'
INFO:2017-09-16 14:14:18,764:conn1 sending b'xyz^123'
INFO:2017-09-16 14:14:18,764:conn1 received b'234'
INFO:2017-09-16 14:14:19,764:conn1 sending b'25$^ab0000$abab'
INFO:2017-09-16 14:14:19,765:conn1 received b'36bc1111'
INFO:2017-09-16 14:14:19,965:conn1 disconnecting
INFO:2017-09-16 14:14:19,966:conn2 connected...
INFO:2017-09-16 14:14:19,967:conn2 sending b'^abc$de^abte$f'
INFO:2017-09-16 14:14:19,967:conn2 received b'b'
INFO:2017-09-16 14:14:20,006:conn2 received b'cdbcuf'
INFO:2017-09-16 14:14:20,968:conn2 sending b'xyz^123'
INFO:2017-09-16 14:14:20,969:conn2 received b'234'
INFO:2017-09-16 14:14:21,970:conn2 sending b'25$^ab0000$abab'
INFO:2017-09-16 14:14:21,970:conn2 received b'36bc1111'
INFO:2017-09-16 14:14:22,171:conn2 disconnecting
INFO:2017-09-16 14:14:22,171:conn0 connected...
INFO:2017-09-16 14:14:22,172:conn0 sending b'^abc$de^abte$f'
INFO:2017-09-16 14:14:22,172:conn0 received b'b'
INFO:2017-09-16 14:14:22,210:conn0 received b'cdbcuf'
INFO:2017-09-16 14:14:23,173:conn0 sending b'xyz^123'
INFO:2017-09-16 14:14:23,174:conn0 received b'234'
INFO:2017-09-16 14:14:24,175:conn0 sending b'25$^ab0000$abab'
INFO:2017-09-16 14:14:24,176:conn0 received b'36bc1111'
INFO:2017-09-16 14:14:24,376:conn0 disconnecting
```
这里要注意连接名：`conn1` 是第一个连接到服务器的，先跟服务器交互了一段时间。接下来的连接 `conn2` —— 在第一个断开连接后，连接到了服务器，然后第三个连接也是一样。就像日志显示的那样，每一个连接让服务器变得繁忙，持续了大约 2.2 秒的时间（这实际上是人为地在客户端代码中加入的延迟），在这段时间里别的客户端都不能连接。
显然，这不是一个可扩展的策略。这个例子中，客户端中加入了延迟，让服务器不能处理别的交互动作。一个智能服务器应该能处理一堆客户端的请求，而这个原始的服务器在结束连接之前一直繁忙（我们将会在之后的章节中看到如何实现智能的服务器）。尽管服务端有延迟，但这不会过度占用 CPU；例如，从数据库中查找信息（时间基本上是花在连接到数据库服务器上，或者是花在硬盘中的本地数据库）。
### 总结及期望
这个示例服务器达成了两个预期目标：
1. 首先是介绍了问题范畴和贯彻该系列文章的套接字编程基础。
2. 对于并发服务器编程的抛砖引玉 —— 就像之前的部分所说，顺序服务器还不能在非常轻微的负载下进行扩展，而且没有高效的利用资源。
在看下一篇文章前，确保你已经理解了这里所讲的服务器/客户端协议，还有顺序服务器的代码。我之前介绍过了这个简单的协议；例如 [串行通信分帧](http://eli.thegreenplace.net/2009/08/12/framing-in-serial-communications/) 和 [用协程来替代状态机](http://eli.thegreenplace.net/2009/08/29/co-routines-as-an-alternative-to-state-machines)。要学习套接字网络编程的基础，[Beej 的教程](http://beej.us/guide/bgnet/) 用来入门很不错，但是要深入理解我推荐你还是看本书。
如果有什么不清楚的，请在评论区下进行评论或者向我发送邮件。深入理解并发服务器！
---
* 注1：状态转变中的 In/Out 记号是指 [Mealy machine](https://en.wikipedia.org/wiki/Mealy_machine)。
* 注2：回应的是 `bcdbcuf23436bc`。
* 注3：这里在结尾处有一点小区别，加了字符串 `0000` —— 服务器回应这个序列，告诉客户端让其断开连接；这是一个简单的握手协议，确保客户端有足够的时间接收到服务器发送的所有回复。
---
via: <https://eli.thegreenplace.net/2017/concurrent-servers-part-1-introduction/>
作者：[Eli Bendersky](https://eli.thegreenplace.net/pages/about) 译者：[GitFuture](https://github.com/GitFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何成规模地部署多云的无服务器程序和 Cloud Foundry API
|
Superuser
|
http://superuser.openstack.org/articles/deploy-multi-cloud-serverless-cloud-foundry-apis-scale/
|
IBM 的 Ken Parmelee 说：“微服务和 API 是产品，我们需要以这种方式思考。”
|
/data/attachment/album/201710/24/121629hlwc8l2fh66h2x56.png.thumb.jpg
|
/data/attachment/album/201710/24/121629hlwc8l2fh66h2x56.png
| true
| false
| true
|
geekpi
| false
|
[
"无服务器"
] |
容器与云
|
{
"viewnum": 3297,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
IBM 的 Ken Parmelee 说：“微服务和 API 是产品，我们需要以这种方式思考。”
| 2017-10-24T12:16:25
| 2017-10-24T12:16:25
| 8,994
|
/article-8994-1.html
|
>
> IBM 的 Ken Parmelee 说：“微服务和 API 是产品，我们需要以这种方式思考。”
>
>
>
领导 IBM 的 API 网关和 Big Blue 开源项目的的 Ken Parmelee 对以开源方式 “进攻” API 以及如何创建微服务和使其伸缩有一些思考。
Parmelee 说：“微服务和 API 是产品，我们需要以这种方式思考这些问题。当你开始这么做，人们依赖它作为它们业务的一部分。这是你在这个领域所做的关键方面。”
他在最近的[北欧 APIs 2017 平台峰会](https://nordicapis.com/events/the-2017-api-platform-summit/)登上讲台，并挑战了一些流行的观念。
“快速失败不是一个很好的概念。你想在第一场比赛中获得一些非常棒的东西。这并不意味着你需要花费大量的时间，而是应该让它变得非常棒，然后不断的发展和改进。如果一开始真的很糟糕，人们就不会想要用你。”
他谈及包括 [OpenWhisk](https://developer.ibm.com/openwhisk/) 在内的 IBM 现代无服务器架构，这是一个 IBM 和 Apache 之间的开源伙伴关系。 云优先的基于分布式事件的编程服务是这两年多来重点关注这个领域的成果；IBM 是该领域领先的贡献者，它是 IBM 云服务的基础。它提供基础设施即服务（IaaS）、自动缩放、为多种语言提供支持、用户只需支付实际使用费用即可。这次旅程充满了挑战，因为他们发现服务器操作需要安全、并且需要轻松 —— 匿名访问、缺少使用路径、固定的 URL 格式等。
任何人都可以在 30 秒内在 <https://console.bluemix.net/openwhisk/> 上尝试这些无服务器 API。“这听起来很有噱头，但这是很容易做到的。我们正在结合 [Cloud Foundry 中完成的工作](https://cloudfoundry.org/the-foundry/ibm-cloud/)，并在 OpenWhisk 下的 Bluemix 中发布了它们，以提供安全性和可扩展性。”
他说：“灵活性对于微服务也是非常重要的。 当你使用 API 在现实世界中工作时，你开始需要跨云进行扩展。”这意味着从你的内部云走向公共云，并且“对你要怎么做有一个实在的概念很重要”。
在思考“任何云概念”的时候，他警告说，不是“将其放入一个 Docker 容器，并到处运行。这很棒，但需要在这些环境中有效运行。Docker 和 Kubernetes 有提供了很多帮助，但是你想要你的操作方式付诸实施。” 提前考虑 API 的使用，无论是在内部运行还是扩展到公有云并可以公开调用 - 你需要有这样的“架构观”，他补充道。
Parmelee 说：“我们都希望我们所创造的有价值，并被广泛使用。” API 越成功，将其提升到更高水平的挑战就越大。
*API 是微服务或“服务间”的组成部分。*
他说，API 的未来是原生云的 - 无论你从哪里开始。关键因素是可扩展性，简化后端管理，降低成本，避免厂商锁定。
你可以在下面或在 [YouTube](https://www.youtube.com/jA25Kmxr6fU) 观看他整整 23 分钟的演讲。
---
via: <http://superuser.openstack.org/articles/deploy-multi-cloud-serverless-cloud-foundry-apis-scale/>
作者：[Superuser](http://superuser.openstack.org/articles/author/superuser/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么要切换到 Linux 系统？我该怎么做？
|
David Nield
|
https://www.popsci.com/switch-to-linux-operating-system
|
不管你是完全不了解 Linux，或是已经尝试过一两次，我们希望你考虑一下在你的下一台笔记本或台式机上运行 Linux，或者可以和现存系统做个双启动。请继续阅读下去，看是不是时候该切换了。
|
/data/attachment/album/201710/24/233252mrfrprplezuem1rg.jpg.thumb.jpg
|
/data/attachment/album/201710/24/233252mrfrprplezuem1rg.jpg
| true
| false
| true
|
zpl1025
| false
|
[
"Linux"
] |
观点
|
{
"viewnum": 6829,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[] |
[] |
不管你是完全不了解 Linux，或是已经尝试过一两次，我们希望你考虑一下在你的下一台笔记本或台式机上运行 Linux，或者可以和现存系统做个双启动。请继续阅读下去，看是不是时候该切换了。
| 2017-10-25T08:31:00
| 2017-10-25T08:31:00
| 8,999
|
/article-8999-1.html
|
>
> 是时候做出改变了。
>
>
>
当你在选购电脑的时候，你可能会在 [Windows](https://www.popsci.com/windows-tweaks-improve-performance) 和 [macOS](https://www.popsci.com/macos-tweaks-improve-performance) 之间犹豫，但是可能基本不会想到 Linux。尽管如此，这个名气没那么大的操作系统仍然拥有庞大而忠诚的粉丝。因为它相对于它的竞争者，有很大的优势。
不管你是完全不了解 Linux，或是已经尝试过一两次，我们希望你考虑一下在你的下一台笔记本或台式机上运行 Linux，或者可以和现存系统做个双启动。请继续阅读下去，看是不是时候该切换了。
### 什么是 Linux?
如果你已经非常熟悉 Linux，可以跳过这个部分。对于不熟悉的其他人，Linux 是一个免费的开源操作系统，所有人都可以去探索它的代码。技术上来说，术语“Linux”说的只是内核，或者核心代码。不过，人们一般用这个名字统称整个操作系统，包括界面和集成的应用。
因为所有人都可以修改它，Linux 有非常自由的可定制性，这鼓舞了很多程序员制作并发布了自己的系统——常称为<ruby> 发行版 <rt> distro </rt></ruby>。这些不同口味的系统，每一个都有自己特色的软件和界面。一些比较有名的发行版，模仿了熟悉的 Windows 或 macOS 操作系统，比如 [Ubuntu](https://www.ubuntu.com/)、 [Linux Mint](https://linuxmint.com/) 和 [Zorin OS](https://zorinos.com/)。当你准备选择一个发行版时，可以去它们官网看一下，试试看是不是适合自己。
为了制作和维护这些 Linux 发行版，大量的开发者无偿地贡献了自己的时间。有时候，利润主导的公司为了拓展自己的软件销售领域，也会主导开发带有独特特性的 Linux 版本。比如 Android（它虽然不能当作一个完整的 Linux 操作系统）就是以基于 Linux 内核的，这也是为什么它有很多[不同变种](https://lineageos.org/)的原因。另外，很多服务器和数据中心也运行了 Linux，所以很有可能这个操作系统托管着你正在看的网页。
### 有什么好处？
首先，Linux 是免费而且开源的，意味着你可以将它安装到你现有的电脑或笔记本上，或者你自己组装的机器，而不用支付任何费用。系统会自带一些常用软件，包括网页浏览器、媒体播放器、[图像编辑器](https://www.gimp.org/)和[办公软件](https://www.libreoffice.org/)，所以你也不用为了查看图片或处理文档再支付其他额外费用。而且，以后还可以免费升级。
Linux 比其他系统能更好的防御恶意软件，强大到你都不需要运行杀毒软件。开发者们在最早构建时就考虑了安全性，比如说，操作系统只运行可信的软件。而且，很少有恶意软件针对这个系统，对于黑客来说，这样做没有价值。Linux 也并不是完全没有任何漏洞，只不过对于一般只运行已验证软件的家庭用户来说，并不用太担心安全性。
这个操作系统对硬件资源的要求比起数据臃肿的 Windows 或 macOS 来说也更少。一些发行版不像它们名气更大的表兄弟，默认集成了更少的组件，开发者特别开发了一些，比如 [Puppy Linux](http://puppylinux.org/main/Overview%20and%20Getting%20Started.htm) 和 [Linux Lite](https://www.linuxliteos.com/)，让系统尽可能地轻量。这让 Linux 非常适合那些家里有很老的电脑的人。如果你的远古笔记本正在原装操作系统的重压下喘息，试试装一个 Linux，应该会快很多。如果不愿意的话，你也不用抛弃旧系统，我们会在后面的部分里解释怎么做。
尽管你可能会需要一点时间来适应新系统，不过不用太久，你就会发现 Linux 界面很容易使用。任何年龄和任何技术水平的人都可以掌握这个软件。而且在线的 Linux 社区提供了大量的帮助和支持。说到社区，下载 Linux 也是对开源软件运动的支持：这些开发者一起工作，并不收取任何费用，为全球用户开发更优秀的软件。
### 我该从哪儿开始？
Linux 据说只有专家才能安装。不过比起前几年，现在安装并运行操作系统已经非常简单了。
首先，打开你喜欢的发行版的网站，按照上面的安装指南操作。一般会需要烧录一张 DVD 或者制作一个带有必要程序的 U 盘，然后重启你的电脑，执行这段程序。实际上，这个操作系统的一个好处是，你可以将它直接安装在可插拔的 U 盘上，我们有一个[如何把电脑装在 U 盘里](https://www.popsci.com/portable-computer-usb-stick)的完整指南。
如果你想在不影响原来旧系统的情况下运行 Linux，你可以选择从 DVD 或 U 盘或者电脑硬盘的某个分区（分成不同的区来独立运行不同的操作系统）单独启动。有些 Linux 发行版在安装过程中会帮你自动处理磁盘分区。或者你可以用[磁盘管理器](https://www.disk-partition.com/windows-10/windows-10-disk-management-0528.html) （Windows）或者[磁盘工具](https://support.apple.com/kb/PH22240?locale=en_US) （macOS）自己调整分区。
这些安装说明可能看上去很模糊，但是不要担心：每个发行版都会提供详细的安装指引，虽然大多数情况下过程都差不多。比如，如果你想安装 Ubuntu（最流行的家用 Linux 发行版中的一个），可以[参考这里的指引](https://tutorials.ubuntu.com/tutorial/tutorial-install-ubuntu-desktop?backURL=%2F#0)。（在安装之前，你也可以[尝试运行一下](https://tutorials.ubuntu.com/tutorial/try-ubuntu-before-you-install?backURL=%2F#0)）你需要下载最新的版本，烧录到 DVD 或是 U 盘里，然后再用光盘或 U 盘引导开机，然后跟随安装向导里的指引操作。安装完成时提示安装额外软件时，Ubuntu 会引导你打开合适的工具。
如果你要在一台全新的电脑上安装 Linux，那没什么需要特别留意的。不过如果你要保留旧系统的情况下安装新系统，我们建议你首先[备份自己的数据](https://www.popsci.com/back-up-and-protect-your-data)。在安装过程中，也要注意选择双启动选项，避免擦除现有的系统和文件。你选好的发行版的介绍里会有更详细的说明：你可以在[这里](https://zorinos.com/help/install-zorin-os/)查看 Zorin OS 的完整介绍，[这里](https://linuxmint.com/documentation.php)有 Linux Mint的，其他发行版的介绍在他们各自的网站上也都会有。
就这些了！那么，你准备好试试 Linux 了吗？
---
via: <https://www.popsci.com/switch-to-linux-operating-system>
作者：[David Nield](https://www.popsci.com/authors/david-nield) 译者：[zpl1025](https://github.com/zpl1025) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Ubuntu 18.04 LTS 定名为“仿生河狸”，将于明年 4 月 26 日发布
|
Marius Nestor
|
http://news.softpedia.com/news/ubuntu-18-04-lts-dubbed-as-the-bionic-beaver-launches-april-26-2018-518186.shtml
|
“为纪念这一孜孜不倦的辛劳，这次我们的吉祥物是一个以其精力充沛的态度、勤劳的天性和工程能力而闻名的哺乳动物。同时，我们给它赋予 21 世纪的新精神，以纪念永不停息的 Ubuntu Core 机器人们。女士们、先生们，让我们欢迎 18.04 LTS —— 仿生河狸。”
|
/data/attachment/album/201710/25/003510yue4yc1i4y7yzmfh.jpeg.thumb.jpg
|
/data/attachment/album/201710/25/003510yue4yc1i4y7yzmfh.jpeg
| true
| false
| true
|
wxy
| false
|
[
"Ubuntu"
] |
新闻
|
{
"viewnum": 7226,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
“为纪念这一孜孜不倦的辛劳，这次我们的吉祥物是一个以其精力充沛的态度、勤劳的天性和工程能力而闻名的哺乳动物。同时，我们给它赋予 21 世纪的新精神，以纪念永不停息的 Ubuntu Core 机器人们。女士们、先生们，让我们欢迎 18.04 LTS —— 仿生河狸。”
| 2017-10-25T00:37:00
| 2017-10-25T00:37:00
| 9,000
|
/article-9000-1.html
|
Ubuntu 母公司 Canonical 的 CEO， Mark Shuttleworth 刚刚披露，Ubuntu 操作系统的下一个长期支持版本（LTS）的代号定为 “Bionic Beaver”，意即“仿生河狸”，。它将于明年的 4 月发布。
按照 Ubuntu 系列的命名传统，Mark Shuttleworth 今天写的一篇[博文](http://www.markshuttleworth.com/archives/1518)对 Ubuntu 17.10（AA）“巧豚”的发布表示祝贺，并宣布了下一个版本的代号：
>
> “为纪念这一孜孜不倦的辛劳，这次我们的吉祥物是一个以其精力充沛的态度、勤劳的天性和工程能力而闻名的哺乳动物。同时，我们给它赋予 21 世纪的新精神，以纪念永不停息的 Ubuntu Core 机器人们。女士们、先生们，让我们欢迎 18.04 LTS —— 仿生河狸。”
>
>
>
### Ubuntu 18.04 LTS 将发布于 2018 年 4 月
虽然 Mark 并没有实际披露 Ubuntu 18.04 LTS 的计划，但是由于事实上他们将把更多的工作放在面向物联网设备的 Ubuntu Snappy Core 系统上，因此看起来其发布周期将会定在 2018 年 4 月 26 日。
Ubuntu 18.04 LTS 的开发工作会在两天后开始，当工具链上传到归档时， Ubuntu 18.04 LTS （BB）会和其前代一样，在六个月内发布两个 Alpha 和两个 Beta 版本之后正式发布。
据其[发布计划](https://wiki.ubuntu.com/BionicBeaver/ReleaseSchedule)，其第一个 Alpha 里程碑将在 2018 年 1 月 4 号发布，第二个在 2 月 1 日——但只有部分风味版本会发布 Alpha 版本，并且这些风味版会在 3 月 8 日发布第一个 Beta 版本，而发布前的最后一个 Beta 版本将于 2018 年 4 月 5 日发布。
|
||
并发服务器（二）：线程
|
Eli Bendersky
|
https://eli.thegreenplace.net/2017/concurrent-servers-part-2-threads/
|
这一节里，我们来看看怎么用多线程来实现并发，用 C 实现一个最简单的多线程服务器，和用 Python 实现的线程池。
|
/data/attachment/album/201710/25/222024zb32ugz3j6zb83p1.jpg.thumb.jpg
|
/data/attachment/album/201710/25/222024zb32ugz3j6zb83p1.jpg
| true
| false
| true
|
BriFuture
| false
|
[
"并发"
] |
软件开发
|
{
"viewnum": 8694,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8993,
"displayorder": 0
},
{
"raid": 9117,
"displayorder": 0
}
] |
这一节里，我们来看看怎么用多线程来实现并发，用 C 实现一个最简单的多线程服务器，和用 Python 实现的线程池。
| 2017-10-26T08:19:00
| 2017-10-26T08:19:00
| 9,002
|
/article-9002-1.html
|
这是并发网络服务器系列的第二节。[第一节](/article-8993-1.html) 提出了服务端实现的协议，还有简单的顺序服务器的代码，是这整个系列的基础。
这一节里，我们来看看怎么用多线程来实现并发，用 C 实现一个最简单的多线程服务器，和用 Python 实现的线程池。
该系列的所有文章：
* [第一节 - 简介](/article-8993-1.html)
* [第二节 - 线程](http://eli.thegreenplace.net/2017/concurrent-servers-part-2-threads/)
* [第三节 - 事件驱动](http://eli.thegreenplace.net/2017/concurrent-servers-part-3-event-driven/)
### 多线程的方法设计并发服务器
说起第一节里的顺序服务器的性能，最显而易见的，是在服务器处理客户端连接时，计算机的很多资源都被浪费掉了。尽管假定客户端快速发送完消息，不做任何等待，仍然需要考虑网络通信的开销；网络要比现在的 CPU 慢上百万倍还不止，因此 CPU 运行服务器时会等待接收套接字的流量，而大量的时间都花在完全不必要的等待中。
这里是一份示意图，表明顺序时客户端的运行过程：
这个图片上有 3 个客户端程序。棱形表示客户端的“到达时间”（即客户端尝试连接服务器的时间）。黑色线条表示“等待时间”（客户端等待服务器真正接受连接所用的时间），有色矩形表示“处理时间”（服务器和客户端使用协议进行交互所用的时间）。有色矩形的末端表示客户端断开连接。
上图中，绿色和橘色的客户端尽管紧跟在蓝色客户端之后到达服务器，也要等到服务器处理完蓝色客户端的请求。这时绿色客户端得到响应，橘色的还要等待一段时间。
多线程服务器会开启多个控制线程，让操作系统管理 CPU 的并发（使用多个 CPU 核心）。当客户端连接的时候，创建一个线程与之交互，而在主线程中，服务器能够接受其他的客户端连接。下图是该模式的时间轴：
### 每个客户端一个线程，在 C 语言里要用 pthread
这篇文章的 [第一个示例代码](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/threaded-server.c) 是一个简单的 “每个客户端一个线程” 的服务器，用 C 语言编写，使用了 [phtreads API](http://eli.thegreenplace.net/2010/04/05/pthreads-as-a-case-study-of-good-api-design) 用于实现多线程。这里是主循环代码：
```
while (1) {
struct sockaddr_in peer_addr;
socklen_t peer_addr_len = sizeof(peer_addr);
int newsockfd =
accept(sockfd, (struct sockaddr*)&peer_addr, &peer_addr_len);
if (newsockfd < 0) {
perror_die("ERROR on accept");
}
report_peer_connected(&peer_addr, peer_addr_len);
pthread_t the_thread;
thread_config_t* config = (thread_config_t*)malloc(sizeof(*config));
if (!config) {
die("OOM");
}
config->sockfd = newsockfd;
pthread_create(&the_thread, NULL, server_thread, config);
// 回收线程 —— 在线程结束的时候，它占用的资源会被回收
// 因为主线程在一直运行，所以它比服务线程存活更久。
pthread_detach(the_thread);
}
```
这是 `server_thread` 函数：
```
void* server_thread(void* arg) {
thread_config_t* config = (thread_config_t*)arg;
int sockfd = config->sockfd;
free(config);
// This cast will work for Linux, but in general casting pthread_id to an 这个类型转换在 Linux 中可以正常运行，但是一般来说将 pthread_id 类型转换成整形不便于移植代码
// integral type isn't portable.
unsigned long id = (unsigned long)pthread_self();
printf("Thread %lu created to handle connection with socket %d\n", id,
sockfd);
serve_connection(sockfd);
printf("Thread %lu done\n", id);
return 0;
}
```
线程 “configuration” 是作为 `thread_config_t` 结构体进行传递的：
```
typedef struct { int sockfd; } thread_config_t;
```
主循环中调用的 `pthread_create` 产生一个新线程，然后运行 `server_thread` 函数。这个线程会在 `server_thread` 返回的时候结束。而在 `serve_connection` 返回的时候 `server_thread` 才会返回。`serve_connection` 和第一节完全一样。
第一节中我们用脚本生成了多个并发访问的客户端，观察服务器是怎么处理的。现在来看看多线程服务器的处理结果：
```
$ python3.6 simple-client.py -n 3 localhost 9090
INFO:2017-09-20 06:31:56,632:conn1 connected...
INFO:2017-09-20 06:31:56,632:conn2 connected...
INFO:2017-09-20 06:31:56,632:conn0 connected...
INFO:2017-09-20 06:31:56,632:conn1 sending b'^abc$de^abte$f'
INFO:2017-09-20 06:31:56,632:conn2 sending b'^abc$de^abte$f'
INFO:2017-09-20 06:31:56,632:conn0 sending b'^abc$de^abte$f'
INFO:2017-09-20 06:31:56,633:conn1 received b'b'
INFO:2017-09-20 06:31:56,633:conn2 received b'b'
INFO:2017-09-20 06:31:56,633:conn0 received b'b'
INFO:2017-09-20 06:31:56,670:conn1 received b'cdbcuf'
INFO:2017-09-20 06:31:56,671:conn0 received b'cdbcuf'
INFO:2017-09-20 06:31:56,671:conn2 received b'cdbcuf'
INFO:2017-09-20 06:31:57,634:conn1 sending b'xyz^123'
INFO:2017-09-20 06:31:57,634:conn2 sending b'xyz^123'
INFO:2017-09-20 06:31:57,634:conn1 received b'234'
INFO:2017-09-20 06:31:57,634:conn0 sending b'xyz^123'
INFO:2017-09-20 06:31:57,634:conn2 received b'234'
INFO:2017-09-20 06:31:57,634:conn0 received b'234'
INFO:2017-09-20 06:31:58,635:conn1 sending b'25$^ab0000$abab'
INFO:2017-09-20 06:31:58,635:conn2 sending b'25$^ab0000$abab'
INFO:2017-09-20 06:31:58,636:conn1 received b'36bc1111'
INFO:2017-09-20 06:31:58,636:conn2 received b'36bc1111'
INFO:2017-09-20 06:31:58,637:conn0 sending b'25$^ab0000$abab'
INFO:2017-09-20 06:31:58,637:conn0 received b'36bc1111'
INFO:2017-09-20 06:31:58,836:conn2 disconnecting
INFO:2017-09-20 06:31:58,836:conn1 disconnecting
INFO:2017-09-20 06:31:58,837:conn0 disconnecting
```
实际上，所有客户端同时连接，它们与服务器的通信是同时发生的。
### 每个客户端一个线程的难点
尽管在现代操作系统中就资源利用率方面来看，线程相当的高效，但前一节中讲到的方法在高负载时却会出现纰漏。
想象一下这样的情景：很多客户端同时进行连接，某些会话持续的时间长。这意味着某个时刻服务器上有很多活跃的线程。太多的线程会消耗掉大量的内存和 CPU 资源，而仅仅是用于上下文切换<sup> 注1</sup> 。另外其也可视为安全问题：因为这样的设计容易让服务器成为 [DoS 攻击](https://en.wikipedia.org/wiki/Denial-of-service_attack) 的目标 —— 上百万个客户端同时连接，并且客户端都处于闲置状态，这样耗尽了所有资源就可能让服务器宕机。
当服务器要与每个客户端通信，CPU 进行大量计算时，就会出现更严重的问题。这种情况下，容易想到的方法是减少服务器的响应能力 —— 只有其中一些客户端能得到服务器的响应。
因此，对多线程服务器所能够处理的并发客户端数做一些 *速率限制* 就是个明智的选择。有很多方法可以实现。最容易想到的是计数当前已经连接上的客户端，把连接数限制在某个范围内（需要通过仔细的测试后决定）。另一种流行的多线程应用设计是使用 *线程池*。
### 线程池
[线程池](https://en.wikipedia.org/wiki/Thread_pool) 很简单，也很有用。服务器创建几个任务线程，这些线程从某些队列中获取任务。这就是“池”。然后每一个客户端的连接被当成任务分发到池中。只要池中有空闲的线程，它就会去处理任务。如果当前池中所有线程都是繁忙状态，那么服务器就会阻塞，直到线程池可以接受任务（某个繁忙状态的线程处理完当前任务后，变回空闲的状态）。
这里有个 4 线程的线程池处理任务的图。任务（这里就是客户端的连接）要等到线程池中的某个线程可以接受新任务。
非常明显，线程池的定义就是一种按比例限制的机制。我们可以提前设定服务器所能拥有的线程数。那么这就是并发连接的最多的客户端数 —— 其它的客户端就要等到线程空闲。如果我们的池中有 8 个线程，那么 8 就是服务器可以处理的最多的客户端并发连接数，哪怕上千个客户端想要同时连接。
那么怎么确定池中需要有多少个线程呢？通过对问题范畴进行细致的分析、评估、实验以及根据我们拥有的硬件配置。如果是单核的云服务器，答案只有一个；如果是 100 核心的多套接字的服务器，那么答案就有很多种。也可以在运行时根据负载动态选择池的大小 —— 我会在这个系列之后的文章中谈到这个东西。
使用线程池的服务器在高负载情况下表现出 *性能退化* —— 客户端能够以稳定的速率进行连接，可能会比其它时刻得到响应的用时稍微久一点；也就是说，无论多少个客户端同时进行连接，服务器总能保持响应，尽最大能力响应等待的客户端。与之相反，每个客户端一个线程的服务器，会接收多个客户端的连接直到过载，这时它更容易崩溃或者因为要处理*所有*客户端而变得缓慢，因为资源都被耗尽了（比如虚拟内存的占用）。
### 在服务器上使用线程池
为了[改变服务器的实现](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/threadpool-server.py)，我用了 Python，在 Python 的标准库中带有一个已经实现好的稳定的线程池。（`concurrent.futures` 模块里的 `ThreadPoolExecutor`） <sup> 注2</sup> 。
服务器创建一个线程池，然后进入循环，监听套接字接收客户端的连接。用 `submit` 把每一个连接的客户端分配到池中：
```
pool = ThreadPoolExecutor(args.n)
sockobj = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sockobj.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sockobj.bind(('localhost', args.port))
sockobj.listen(15)
try:
while True:
client_socket, client_address = sockobj.accept()
pool.submit(serve_connection, client_socket, client_address)
except KeyboardInterrupt as e:
print(e)
sockobj.close()
```
`serve_connection` 函数和 C 的那部分很像，与一个客户端交互，直到其断开连接，并且遵循我们的协议：
```
ProcessingState = Enum('ProcessingState', 'WAIT_FOR_MSG IN_MSG')
def serve_connection(sockobj, client_address):
print('{0} connected'.format(client_address))
sockobj.sendall(b'*')
state = ProcessingState.WAIT_FOR_MSG
while True:
try:
buf = sockobj.recv(1024)
if not buf:
break
except IOError as e:
break
for b in buf:
if state == ProcessingState.WAIT_FOR_MSG:
if b == ord(b'^'):
state = ProcessingState.IN_MSG
elif state == ProcessingState.IN_MSG:
if b == ord(b'$'):
state = ProcessingState.WAIT_FOR_MSG
else:
sockobj.send(bytes([b + 1]))
else:
assert False
print('{0} done'.format(client_address))
sys.stdout.flush()
sockobj.close()
```
来看看线程池的大小对并行访问的客户端的阻塞行为有什么样的影响。为了演示，我会运行一个池大小为 2 的线程池服务器（只生成两个线程用于响应客户端）。
```
$ python3.6 threadpool-server.py -n 2
```
在另外一个终端里，运行客户端模拟器，产生 3 个并发访问的客户端：
```
$ python3.6 simple-client.py -n 3 localhost 9090
INFO:2017-09-22 05:58:52,815:conn1 connected...
INFO:2017-09-22 05:58:52,827:conn0 connected...
INFO:2017-09-22 05:58:52,828:conn1 sending b'^abc$de^abte$f'
INFO:2017-09-22 05:58:52,828:conn0 sending b'^abc$de^abte$f'
INFO:2017-09-22 05:58:52,828:conn1 received b'b'
INFO:2017-09-22 05:58:52,828:conn0 received b'b'
INFO:2017-09-22 05:58:52,867:conn1 received b'cdbcuf'
INFO:2017-09-22 05:58:52,867:conn0 received b'cdbcuf'
INFO:2017-09-22 05:58:53,829:conn1 sending b'xyz^123'
INFO:2017-09-22 05:58:53,829:conn0 sending b'xyz^123'
INFO:2017-09-22 05:58:53,830:conn1 received b'234'
INFO:2017-09-22 05:58:53,831:conn0 received b'2'
INFO:2017-09-22 05:58:53,831:conn0 received b'34'
INFO:2017-09-22 05:58:54,831:conn1 sending b'25$^ab0000$abab'
INFO:2017-09-22 05:58:54,832:conn1 received b'36bc1111'
INFO:2017-09-22 05:58:54,832:conn0 sending b'25$^ab0000$abab'
INFO:2017-09-22 05:58:54,833:conn0 received b'36bc1111'
INFO:2017-09-22 05:58:55,032:conn1 disconnecting
INFO:2017-09-22 05:58:55,032:conn2 connected...
INFO:2017-09-22 05:58:55,033:conn2 sending b'^abc$de^abte$f'
INFO:2017-09-22 05:58:55,033:conn0 disconnecting
INFO:2017-09-22 05:58:55,034:conn2 received b'b'
INFO:2017-09-22 05:58:55,071:conn2 received b'cdbcuf'
INFO:2017-09-22 05:58:56,036:conn2 sending b'xyz^123'
INFO:2017-09-22 05:58:56,036:conn2 received b'234'
INFO:2017-09-22 05:58:57,037:conn2 sending b'25$^ab0000$abab'
INFO:2017-09-22 05:58:57,038:conn2 received b'36bc1111'
INFO:2017-09-22 05:58:57,238:conn2 disconnecting
```
回顾之前讨论的服务器行为：
1. 在顺序服务器中，所有的连接都是串行的。一个连接结束后，下一个连接才能开始。
2. 前面讲到的每个客户端一个线程的服务器中，所有连接都被同时接受并得到服务。
这里可以看到一种可能的情况：两个连接同时得到服务，只有其中一个结束连接后第三个才能连接上。这就是把线程池大小设置成 2 的结果。真实用例中我们会把线程池设置的更大些，取决于机器和实际的协议。线程池的缓冲机制就能很好理解了 —— 我 [几个月前](http://eli.thegreenplace.net/2017/clojure-concurrency-and-blocking-with-coreasync/) 更详细的介绍过这种机制，关于 Clojure 的 `core.async` 模块。
### 总结与展望
这篇文章讨论了在服务器中，用多线程作并发的方法。每个客户端一个线程的方法最早提出来，但是实际上却不常用，因为它并不安全。
线程池就常见多了，最受欢迎的几个编程语言有良好的实现（某些编程语言，像 Python，就是在标准库中实现）。这里说的使用线程池的服务器，不会受到每个客户端一个线程的弊端。
然而，线程不是处理多个客户端并行访问的唯一方法。下一节中我们会看看其它的解决方案，可以使用*异步处理*，或者*事件驱动*的编程。
---
* 注1：老实说，现代 Linux 内核可以承受足够多的并发线程 —— 只要这些线程主要在 I/O 上被阻塞。[这里有个示例程序](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/threadspammer.c)，它产生可配置数量的线程，线程在循环体中是休眠的，每 50 ms 唤醒一次。我在 4 核的 Linux 机器上可以轻松的产生 10000 个线程；哪怕这些线程大多数时间都在睡眠，它们仍然消耗一到两个核心，以便实现上下文切换。而且，它们占用了 80 GB 的虚拟内存（Linux 上每个线程的栈大小默认是 8MB）。实际使用中，线程会使用内存并且不会在循环体中休眠，因此它可以非常快的占用完一个机器的内存。
* 注2：自己动手实现一个线程池是个有意思的练习，但我现在还不想做。我曾写过用来练手的 [针对特殊任务的线程池](http://eli.thegreenplace.net/2011/12/27/python-threads-communication-and-stopping)。是用 Python 写的；用 C 重写的话有些难度，但对于经验丰富的程序员，几个小时就够了。
---
via: <https://eli.thegreenplace.net/2017/concurrent-servers-part-2-threads/>
作者：[Eli Bendersky](https://eli.thegreenplace.net/pages/about) 译者：[GitFuture](https://github.com/GitFuture) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
PingCAP 推出 TiDB 1.0
|
Pingcap
|
https://pingcap.github.io/blog/2017/10/17/announcement/
|
TiDB 是一个开源的分布式混合事务/分析处理 （HTAP） 数据库，它使企业能够使用单个数据库来满足这两个负载。
|
/data/attachment/album/201710/26/221117lwwl5h9h80kyxgwk.jpg.thumb.jpg
|
/data/attachment/album/201710/26/221117lwwl5h9h80kyxgwk.jpg
| true
| false
| true
|
geekpi
| false
|
[
"TiDB",
"数据库"
] |
新闻
|
{
"viewnum": 4324,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
TiDB 是一个开源的分布式混合事务/分析处理 （HTAP） 数据库，它使企业能够使用单个数据库来满足这两个负载。
| 2017-10-27T08:09:00
| 2017-10-27T08:09:00
| 9,004
|
/article-9004-1.html
|
>
> PingCAP 推出了 TiDB 1.0，一个可扩展的混合数据库解决方案
>
>
>
2017 年 10 月 16 日， 一家尖端的分布式数据库技术公司 PingCAP Inc. 正式宣布发布 [TiDB](https://github.com/pingcap/tidb) 1.0。TiDB 是一个开源的分布式混合事务/分析处理 （HTAP） 数据库，它使企业能够使用单个数据库来满足这两个负载。
在当前的数据库环境中，基础架构工程师通常要使用一个数据库进行在线事务处理（OLTP），另一个用于在线分析处理（OLAP）。TiDB 旨在通过构建一个基于实时事务数据的实时业务分析的 HTAP 数据库来打破这种分离。有了 TiDB，工程师现在可以花更少的时间来管理多个数据库解决方案，并有更多的时间为他们的公司提供业务价值。TiDB 的一个金融证券公司的用户正在利用这项技术为财富管理和用户角色的应用提供支持。借助 TiDB，该公司可以轻松处理 web 量级的计费记录，并进行关键任务时间敏感的数据分析。
PingCAP 联合创始人兼 CEO 刘奇（Max Liu）说：
>
> “两年半前，Edward、Dylan 和我开始这个旅程，为长期困扰基础设施软件业的老问题建立一个新的数据库。今天，我们很自豪地宣布，这个数据库 TiDB 可以面向生产环境了。亚伯拉罕·林肯曾经说过，‘预测未来的最好办法就是创造’，我们在 771 天前预测的未来，现在我们已经创造了，这不仅是我们团队的每一个成员，也是我们的开源社区的每个贡献者、用户和合作伙伴的努力工作和奉献。今天，我们庆祝和感谢开源精神的力量。明天，我们将继续创造我们相信的未来。”
>
>
>
TiDB 已经在亚太地区 30 多家公司投入生产环境，其中包括 [摩拜](https://en.wikipedia.org/wiki/Mobike)、[Gaea](http://www.gaea.com/en/) 和 [YOUZU](http://www.yoozoo.com/aboutEn) 等快速增长的互联网公司。使用案例涵盖从在线市场和游戏到金融科技、媒体和旅游的多个行业。
### TiDB 功能
**水平可扩展性**
TiDB 随着你的业务发展而增长。你可以通过添加更多机器来增加存储和计算能力。
**兼容 MySQL 协议**
像用 MySQL 一样使用 TiDB。你可以用 TiDB 替换 MySQL 来增强你的应用，且在大多数情况下不用更改一行代码，也几乎没有迁移成本。
**自动故障切换和高可用性**
你的数据和程序始终处于在线状态。TiDB 自动处理故障并保护你的应用免受整个数据中心的机器故障甚至停机。
**一致的分布式事务**
TiDB 类似于单机关系型数据库系统（RDBMS）。你可以启动跨多台机器的事务，而不用担心一致性。TiDB 使你的应用程序代码简单而强大。
**在线 DDL**
根据你的要求更改 TiDB 模式。你可以添加新的列和索引，而不会停止或影响你正在进行的操作。
[现在尝试TiDB！](https://pingcap.com/doc-QUICKSTART)
### 使用案例
* [yuanfudao.com 中 TiDB 如何处理快速的数据增长和复杂查询](https://pingcap.github.io/blog/2017/08/08/tidbforyuanfudao/)
* [从 MySQL 迁移到 TiDB 以每天处理数千万行数据](https://pingcap.github.io/blog/2017/05/22/Comparison-between-MySQL-and-TiDB-with-tens-of-millions-of-data-per-day/)
### 更多信息：
TiDB 内部：
* [数据存储](https://pingcap.github.io/blog/2017/07/11/tidbinternal1/)
* [计算](https://pingcap.github.io/blog/2017/07/11/tidbinternal2/)
* [调度](https://pingcap.github.io/blog/2017/07/20/tidbinternal3/)
---
via: <https://pingcap.github.io/blog/2017/10/17/announcement/>
作者：[PingCAP](https://pingcap.github.io/blog/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何应对开源软件的版权牟利者？ 开源律师说这样做！
|
Heather Meeker
|
https://opensource.com/article/17/8/patrick-mchardy-and-copyright-profiteering
|
Linux 社区的许多开发人员对 GPL 许可证牟利者 Patrick McHardy 的行为表示担忧，美国资深开源律师对一些常见问题进行解答，并对如何应对版权牟利行为提出了建议。
|
/data/attachment/album/201710/27/225931pu50abnqariq00g5.png.thumb.jpg
|
/data/attachment/album/201710/27/225931pu50abnqariq00g5.png
| true
| false
| true
|
张琳
| false
|
[
"GPL",
"专利"
] |
开源智慧
|
{
"viewnum": 6739,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[] |
[
{
"raid": 9092,
"displayorder": 0
}
] |
Linux 社区的许多开发人员对 GPL 许可证牟利者 Patrick McHardy 的行为表示担忧，美国资深开源律师对一些常见问题进行解答，并对如何应对版权牟利行为提出了建议。
| 2017-10-27T22:59:00
| 2017-10-27T22:59:00
| 9,005
|
/article-9005-1.html
|
>
> 提要：Linux 社区的许多开发人员对 GPL 许可证牟利者 Patrick McHardy 的行为表示担忧，美国资深开源律师对一些常见问题进行解答，并对如何应对版权牟利行为提出了建议。
>
>
>
针对 Patrick McHardy 强制要求 Linux 分发者遵循 GPL 许可证的举动，开源社区许多人士表示了担忧。基于与 McHardy 行动相关的公开信息，以及开源合规维权的一些法律原则，美国资深开源律师对一些常见问题进行了解答。
Patrick Mchardy 是谁？ McHardy 是 Netfilter 核心开发团队的前任负责人。 Netfilter 是 Linux 内核中的一个实用程序，可以执行各种网络功能，例如改善网络地址转换（NAT），NAT 是将 Internet 协议地址转换为另一个 IP 地址的过程。对于维护 Linux 系统的安全性来说，控制网络流量至关重要。
### McHardy 对 Linux 有多少贡献？
这不是一个容易回答的问题。首先，评估贡献的重要性并不容易；我们能做的就是查看<ruby> 提交 <rp> （ </rp> <rt> commit </rt> <rp> ） </rp></ruby>的数量和大小。其次，即使去跟踪提交，跟踪机制也不完美。 Git 有一个 blame 功能，跟踪谁在名义上向 Git 数据库提交了哪些代码行。Git 的 blame 功能可以使用诸如 [cregit](https://cregit.linuxsources.org/) 这样的工具，以更具细粒度的水平来报告提交，从而在文件级别上对贡献度有一个更准确的认知。Git 的 blame 机制和 cregit 是非常实用的，因为它们都使用公开易得的信息，而信息只需要被正确解释。
结合 cregit 和 blame 进行分析可以帮助评估 McHardy 的潜在贡献。例如：
* 他的大部分贡献似乎是在 2006 年到 2008 年和 2012 年期间。
* 在 McHardy 包含其版权声明的大约 135 个文件中，只有 1/3 的文件是 McHardy 贡献了该文件代码的 50％ 或以上。
* 他的贡献看起来不到内核代码的 0.25％。
McHardy 的大部分贡献似乎都给了 Netfilter；然而，blame 机制可能并不总能还原全貌。例如，提交者可以<ruby> 签入 <rp> （ </rp> <rt> check in </rt> <rp> ） </rp></ruby>许多行代码，但只进行细微修改，也可以签入其他人编写或拥有的代码。由于这些原因，提交者的作者身份可能被过低或过多报告。
在 2002 年之前对内核贡献的记录对于识别贡献者来说不是特别有用，因为在当时，Linus Torvalds 签入了所有代码。 McHardy 的贡献直到 2004 年才开始。
[Hellwig 诉 VMware 一案](https://www.theregister.co.uk/2016/08/15/vmware_survives_gpl_breach_case_but_plaintiff_promises_appeal/)中出现了使用开发存储库的元数据确认版权所有权的困难。法院可能不愿意接受这样的信息来作为证明作者身份的证据。
### McHardy 在 Linux 内核中拥有哪些版权？
大型项目（如 Linux 内核）的版权归属复杂。这就像一个拼凑的被子。当开发者对内核做出贡献时，他们不签署任何贡献协议或版权转让协议。GPL 涵盖了他们的贡献，软件副本的接收人根据 GPL 直接从所有作者获得许可。内核项目使用一个名为<ruby> “原始开发者证书” <rp> （ </rp> <rt> Developer Certificate of Origin </rt> <rp> ） </rp></ruby>的文件，该文件不授予任何版权许可。贡献者的个人权利与在项目中的权利作为整体并存。 所以，像 McHardy 这样的作者一般都会拥有他所创作的作品的版权，但并不享有整个内核的版权。
### 什么是<ruby> “社区维权” <rp> （ </rp> <rt> community enforcement </rt> <rp> ） </rp></ruby>？
由于大型项目（如 Linux 内核）的所有权常常分散在许多作者手中，所以个体所有者可以采取不符合社区目标的维权行动。虽然社区可能会对如何以最好的方式来鼓励遵守 GPL 条款有很多看法，但大多数人认为维权应该是非正式的（不是通过诉讼），而且主要目标应该是合规（而不是惩罚）。例如，<ruby> <a href="https://sfconservancy.org/"> 软件自由保护组织 </a> <rp> （ </rp> <rt> Software Freedom Conservancy </rt> <rp> ） </rp></ruby>（SFC）已经颁布了一些[社区维权原则](https://sfconservancy.org/copyleft-compliance/principles.html)，其中优选合规，而不是寻求诉讼或赔偿金。对于非正式行为何时应该成为诉讼，或维权者应该要求赔偿多少钱，没有明确的规定。然而，Linux 社区的大多数开发人员将诉讼视为最后的手段，并不愿意采取法律行动，而与真正希望合规的用户进行合作。
### 为什么这么多的开源诉讼在德国提交？
一些寻求进行开源许可证维权的原告已经向德国法院提交权利主张。在德国有一些在美国或其他<ruby> 普通法 <rp> （ </rp> <rt> common law </rt> <rp> ） </rp></ruby>国家没有能够确切与之类比的寻求法律诉讼的手段。
* [**Abmahnung**](https://en.wikipedia.org/wiki/Abmahnung)**（<ruby> “警告” <rp> （ </rp> <rt> warning </rt> <rp> ） </rp></ruby>****）**：“警告”是索赔人要求被告停止做某事的要求。在版权语境下，这是版权所有者发出的一封信函，要求所述侵权人停止侵权。这些信件是由律师而不是法庭签发的，通常是德国版权维权行动的第一步。在美国，最接近的方式应该是<ruby> 警告信 <rt> cease and desist letter </rt></ruby>。
* [**Unterlassungserklaerung**](https://de.wikipedia.org/wiki/Unterlassungserkl%C3%A4rung)**（<ruby> “停止声明” <rt> cease and desist declaration </rt></ruby>****或<ruby> “禁止声明” <rt> declaration of injunction </rt></ruby>****）**：“警告”通常会附有“停止声明”。这种“声明”就像合同一样，签署的话会要求被告人承担其它并不存在的法律义务。特别是，该声明可能包含 GPL 本身并不要求的义务。在德国，这样一份文件通常包含针对不合规进行惩罚的内容。在美国，类似的做法是和解协议，但和解协议很少规定违约的处罚方式，事实上在美国，合同中的“处罚”可能无法强制执行。“声明”不是法院命令，但如果被告签字，可以获得法院命令的法定效力。**所以，在征求律师法律意见之前签字往往不是一个好主意。**在考虑如何应对寄出停止声明的原告时，还有其他方法，包括提出修改后的处罚或义务较少的声明。此外，由于停止声明可能包含不公开的要求，签署这些文件也可能产生额外的困难，例如限制原告寻求其他被告支持或向社区公开索赔人的权利主张。
更多详情参见：[abmahnung.org/unterlassungserklaerung/](http://www.abmahnung.org/unterlassungserklaerung/) 。
* [**Einstweilige Verf****ü****gung**](https://de.wikipedia.org/wiki/Vorl%C3%A4ufiger_Rechtsschutz#Einstweilige_Verf.C3.BCgung)**（“<ruby> 临时禁令 <rt> interim injunction </rt></ruby>****”或“<ruby> 初步禁令 <rt> preliminary injunction </rt></ruby>****”）**：“临时禁令”是一项类似美国临时禁令的法院命令。虽然没有要求原告在向法院提出“临时禁令”之前发出“警告”，但在被告对“警告”或“声明”不作出回应时，鼓励原告寻求“临时禁令”。侵犯版权的临时禁令可以处以 25 万欧元罚款或 6 个月的监禁。相比之下，在美国，侵犯版权的刑事处罚极为罕见，必须由政府而不是私人机构追究。此外，在美国，法院也没有为未来的侵权行为提供补救措施，它们只是要求被告停止现行的侵权行为或者支付损害赔偿金。在德国，<ruby> 单方 <rt> ex parte </rt></ruby>也可以提出临时禁令，这意味着原告可以在没有被告听证的情况下向法院提出申请，而且可以在没有被告参与的情况下发出临时禁令。如果您收到“警告”，并怀疑原告可能会随之提出 “临时禁令”，可以向法院抢先提出<ruby> “异议” <rt> opposition </rt></ruby>。
更多详情参见：[Abmahnung.org](http://www.abmahnung.org/einstweilige-verfuegung/) 。
* [**Widerspruch**](https://de.wikipedia.org/wiki/Widerspruch_%28Recht%29#Zivilprozessrecht)**（<ruby> “异议” <rt> opposition </rt></ruby>****或<ruby> “反驳” <rt> contradiction </rt></ruby>****）**：“异议”是被告向法院提出否决“临时禁令”的机会。
更多详情参见：[这篇德国法院命令的英文翻译](http://www.jbb.de/Docs/LG_Halle_GPL3.pdf) 。
### McHardy 发起了多少权利主张？
由于许多德国法庭案件缺乏公开记录，因此很难确定 McHardy 的确切行动数量。据说 McHardy 已经接触了超过 50 个维权目标。有关详细信息，请参阅<ruby> <a href="https://sourcecodecontrol.co/gpl/"> “源码控制” </a> <rp> （ </rp> <rt> Source Code Control </rt> <rp> ） </rp></ruby>和<ruby> <a href="https://opensource.com/article/17/1/yearbook-7-notable-legal-developments-2016"> 《2016 年开源社区 7 个显著的法律进展》 </a> <rp> （ </rp> <rt> 7 Notable Legal Developments in Open Source in 2016 </rt> <rp> ） </rp></ruby>。这并不一定意味着有 50 起诉讼，而是可能意味着 50 起威胁要提起诉讼的要求。但是，很难用公开信息来核实这个说法。有关详细信息，请参阅<ruby> <a href="https://www.slideshare.net/blackducksoftware/litigation-and-compliance-in-the-open-source-ecosystem"> 《开源生态系统的诉讼和合规》 </a> <rp> （ </rp> <rt> Litigation and Compliance in the Open Source Ecosystem </rt> <rp> ） </rp></ruby>。
### 为什么社区没有去阻止 McHardy？
包括软件自由保护组织在内的各种社区成员已经开始试图说服 McHardy 改变策略，但到目前为止还没有成功。 Netfilter 项目最近发布了一个[许可问答](http://www.netfilter.org/licensing.html)，解决大家对 McHardy 行为担忧的问题。
### 我们可以做些什么来阻止 McHardy 和其他版权牟利者？
这个问题没有确定的答案，也许没有办法能完全阻止他们。但是，这些建议可能会减少版权牟利者的数量。
* **尽可能遵守开源许可证。**目前有足够的资源来学习如何遵守许可证，以及如何在贵公司设立开源合规计划。例如：
+ Linux基金会发布了<ruby> <a href="https://www.linuxfoundation.org/news-media/research/practical-gpl-compliance"> 《实用 GPL 合规手册》 </a> <rp> （ </rp> <rt> Practical GPL Compliance </rt> <rp> ） </rp></ruby>。
+ 软件自由法律中心发布了<ruby> <a href="https://www.softwarefreedom.org/resources/2014/SFLC-Guide_to_GPL_Compliance_2d_ed.html"> 《GPL 合规实用指南” （第二版） 》 </a> <rp> （ </rp> <rt> A Practical Guide to GPL Compliance </rt> <rp> ） </rp></ruby>。
+ [OpenChain 项目](https://www.openchainproject.org/)发布了开源管理内部流程规范。
* **在寻求法律意见之前不要签署<ruby> “停止声明” <rp> （ </rp> <rt> Unterlassungserklärung </rt> <rp> ） </rp></ruby>****。**如上所述，停止声明可能让您承担 GPL 身没有的义务和处罚。不要与版权牟利者合作。你可以使自己成为一个更难攻克的目标，并争取社区其他目标的帮助。
* **支持开源开发。**作者不应该诉诸投机来谋生。使用开源软件的公司不应该期望开源开发人员免费开发软件，他们应该筹集资金支持重要项目。
* **学会识别版权牟利者。**了解社区导向的 GPL 维权与版权勒索之间的一般差异。面向社区的维权一般旨在通过教育和帮助实现 GPL 合规，同时尊重用户的自由。相比之下，牟利行为可能侧重以不加考究和漫无目的的权力主张和威胁要提起法律诉讼来获得经济利益。注意确认优先考虑经济利益的权利主张，警惕不合理的损害赔偿金。
* **公开权利主张。**如果你是一个牟利者的目标，并且可以选择公开其权利主张，那就公开它，通过阻碍对方的行动来帮助你和其他人。作为开源社区的成员，我们都有义务向那些企图以诉讼拖垮社区的牟利者们提出反对，因为问题能够以更恰当和更少争议的方式解决。
---
作者简介：Heather Meeker 是 O’Melveny & Myers 硅谷办公室的合伙人，为客户提供技术交易和知识产权方面的建议，是国际知名的开源软件许可专家。Heather 于 2016 年获得加州律师协会知识产权先锋奖。<ruby> 《最佳律师》 <rp> （ </rp> <rt> Best Lawyers </rt> <rp> ） </rp></ruby>将她提名为 2018 年年度 IT 律师。
译者简介：张琳，集慧智佳知识产权咨询公司分析师，专业德语，辅修法律。
|
||
使用 Docker 构建你的 Serverless 树莓派集群
|
Alex Ellis
|
https://blog.alexellis.io/your-serverless-raspberry-pi-cluster/
|
这篇博文将向你展示如何使用 Docker 和 OpenFaaS 框架构建你自己的 Serverless 树莓派集群。大家常常问我能用他们的集群来做些什么？而这个应用完美匹配卡片尺寸的设备——只需添加更多的树莓派就能获取更强的计算能力。
|
/data/attachment/album/201710/28/223210p2s4am8lj55amy5j.jpg.thumb.jpg
|
/data/attachment/album/201710/28/223210p2s4am8lj55amy5j.jpg
| true
| false
| true
|
haoqixu
| false
|
[
"树莓派",
"OpenFaaS",
"Docker"
] |
树莓派
|
{
"viewnum": 35930,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这篇博文将向你展示如何使用 Docker 和 OpenFaaS 框架构建你自己的 Serverless 树莓派集群。大家常常问我能用他们的集群来做些什么？而这个应用完美匹配卡片尺寸的设备——只需添加更多的树莓派就能获取更强的计算能力。
| 2017-10-28T22:32:00
| 2017-10-28T22:32:00
| 9,007
|
/article-9007-1.html
|
这篇博文将向你展示如何使用 Docker 和 [OpenFaaS](https://github.com/alexellis/faas) 框架构建你自己的 Serverless 树莓派集群。大家常常问我能用他们的集群来做些什么？而这个应用完美匹配卡片尺寸的设备——只需添加更多的树莓派就能获取更强的计算能力。
>
> “Serverless” （无服务器）是事件驱动架构的一种设计模式，与“桥接模式”、“外观模式”、“工厂模式”和“云”这些名词一样，都是一种抽象概念。
>
>
>
*图片：3 个 Raspberry Pi Zero*
这是我在本文中描述的集群，用黄铜支架分隔每个设备。
### Serverless 是什么？它为何重要？
行业对于 “serverless” 这个术语的含义有几种解释。在这篇博文中，我们就把它理解为一种事件驱动的架构模式，它能让你用自己喜欢的任何语言编写轻量可复用的功能。[更多关于 Serverless 的资料](https://blog.alexellis.io/introducing-functions-as-a-service/)。
*Serverless 架构也引出了“功能即服务服务”模式，简称 FaaS*
Serverless 的“功能”可以做任何事，但通常用于处理给定的输入——例如来自 GitHub、Twitter、PayPal、Slack、Jenkins CI pipeline 的事件；或者以树莓派为例，处理像红外运动传感器、激光绊网、温度计等真实世界的传感器的输入。
Serverless 功能能够更好地结合第三方的后端服务，使系统整体的能力大于各部分之和。
了解更多背景信息，可以阅读我最近一偏博文：[功能即服务（FaaS）简介](https://blog.alexellis.io/introducing-functions-as-a-service/)。
### 概述
我们将使用 [OpenFaaS](https://github.com/alexellis/faas)，它能够让主机或者集群作为支撑 Serverless 功能运行的后端。任何能够使用 Docker 部署的可执行二进制文件、脚本或者编程语言都能在 [OpenFaaS](https://github.com/alexellis/faas) 上运作，你可以根据速度和伸缩性选择部署的规模。另一个优点是，它还内建了用户界面和监控系统。
这是我们要执行的步骤：
* 在一个或多个主机上配置 Docker （树莓派 2 或者 3）；
* 利用 Docker Swarm 将它们连接；
* 部署 [OpenFaaS](https://github.com/alexellis/faas)；
* 使用 Python 编写我们的第一个功能。
### Docker Swarm
Docker 是一项打包和部署应用的技术，支持集群上运行，有着安全的默认设置，而且在搭建集群时只需要一条命令。OpenFaaS 使用 Docker 和 Swarm 在你的可用树莓派上传递你的 Serverless 功能。
我推荐你在这个项目中使用带树莓派 2 或者 3，以太网交换机和[强大的 USB 多端口电源适配器](https://www.amazon.co.uk/Anker-PowerPort-Family-Sized-Technology-Smartphones/dp/B00PK1IIJY)。
### 准备 Raspbian
把 [Raspbian Jessie Lite](http://downloads.raspberrypi.org/raspbian/images/raspbian-2017-07-05/) 写入 SD 卡（8GB 容量就正常工作了，但还是推荐使用 16GB 的 SD 卡）。
*注意：不要下载成 Raspbian Stretch 了*
>
> 社区在努力让 Docker 支持 Raspbian Stretch，但是还未能做到完美运行。请从[树莓派基金会网站](http://downloads.raspberrypi.org/raspbian_lite/images/raspbian_lite-2017-07-05/)下载 Jessie Lite 镜像。
>
>
>
我推荐使用 [Etcher.io](https://etcher.io/) 烧写镜像。
>
> 在引导树莓派之前，你需要在引导分区创建名为 `ssh` 的空白文件。这样才能允许远程登录。
>
>
>
#### 接通电源，然后修改主机名
现在启动树莓派的电源并且使用 `ssh` 连接：
```
$ ssh pi@raspberrypi.local
```
>
> 默认密码是 `raspberry`
>
>
>
使用 `raspi-config` 工具把主机名改为 `swarm-1` 或者类似的名字，然后重启。
当你到了这一步，你还可以把划分给 GPU （显卡）的内存设置为 16MB。
#### 现在安装 Docker
我们可以使用通用脚本来安装：
```
$ curl -sSL https://get.docker.com | sh
```
>
> 这个安装方式在将来可能会发生变化。如上文所说，你的系统需要是 Jessie，这样才能得到一个确定的配置。
>
>
>
你可能会看到类似下面的警告，不过你可以安全地忽略它并且成功安装上 Docker CE 17.05：
```
WARNING: raspbian is no longer updated @ https://get.docker.com/
Installing the legacy docker-engine package...
```
之后，用下面这个命令确保你的用户帐号可以访问 Docker 客户端：
```
$ usermod pi -aG docker
```
>
> 如果你的用户名不是 `pi`，那就把它替换成你的用户名。
>
>
>
#### 修改默认密码
输入 `$sudo passwd pi`，然后设置一个新密码，请不要跳过这一步！
#### 重复以上步骤
现在为其它的树莓派重复上述步骤。
### 创建你的 Swarm 集群
登录你的第一个树莓派，然后输入下面的命令：
```
$ docker swarm init
Swarm initialized: current node (3ra7i5ldijsffjnmubmsfh767) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join \
--token SWMTKN-1-496mv9itb7584pzcddzj4zvzzfltgud8k75rvujopw15n3ehzu-af445b08359golnzhncbdj9o3 \
192.168.0.79:2377
```
你会看到它显示了一个口令，以及其它节点加入集群的命令。接下来使用 `ssh` 登录每个树莓派，运行这个加入集群的命令。
等待连接完成后，在第一个树莓派上查看集群的节点：
```
$ docker node ls
ID HOSTNAME STATUS AVAILABILITY MANAGER STATUS
3ra7i5ldijsffjnmubmsfh767 * swarm1 Ready Active Leader
k9mom28s2kqxocfq1fo6ywu63 swarm3 Ready Active
y2p089bs174vmrlx30gc77h4o swarm4 Ready Active
```
恭喜你！你现在拥有一个树莓派集群了！
#### 更多关于集群的内容
你可以看到三个节点启动运行。这时只有一个节点是集群管理者。如果我们的管理节点*死机*了，集群就进入了不可修复的状态。我们可以通过添加冗余的管理节点解决这个问题。而且它们依然会运行工作负载，除非你明确设置了让你的服务只运作在工作节点上。
要把一个工作节点升级为管理节点，只需要在其中一个管理节点上运行 `docker node promote <node_name>` 命令。
>
> 注意： Swarm 命令，例如 `docker service ls` 或者 `docker node ls` 只能在管理节点上运行。
>
>
>
想深入了解管理节点与工作节点如何保持一致性，可以查阅 [Docker Swarm 管理指南](https://docs.docker.com/engine/swarm/admin_guide/)。
### OpenFaaS
现在我们继续部署程序，让我们的集群能够运行 Serverless 功能。[OpenFaaS](https://github.com/alexellis/faas) 是一个利用 Docker 在任何硬件或者云上让任何进程或者容器成为一个 Serverless 功能的框架。因为 Docker 和 Golang 的可移植性，它也能很好地运行在树莓派上。
>
> 如果你支持 [OpenFaaS](https://github.com/alexellis/faas)，希望你能 **星标** [OpenFaaS](https://github.com/alexellis/faas) 的 GitHub 仓库。
>
>
>
登录你的第一个树莓派（你运行 `docker swarm init` 的节点），然后部署这个项目：
```
$ git clone https://github.com/alexellis/faas/
$ cd faas
$ ./deploy_stack.armhf.sh
Creating network func_functions
Creating service func_gateway
Creating service func_prometheus
Creating service func_alertmanager
Creating service func_nodeinfo
Creating service func_markdown
Creating service func_wordcount
Creating service func_echoit
```
你的其它树莓派会收到 Docer Swarm 的指令，开始从网上拉取这个 Docker 镜像，并且解压到 SD 卡上。这些工作会分布到各个节点上，所以没有哪个节点产生过高的负载。
这个过程会持续几分钟，你可以用下面指令查看它的完成状况：
```
$ watch 'docker service ls'
ID NAME MODE REPLICAS IMAGE PORTS
57ine9c10xhp func_wordcount replicated 1/1 functions/alpine:latest-armhf
d979zipx1gld func_prometheus replicated 1/1 alexellis2/prometheus-armhf:1.5.2 *:9090->9090/tcp
f9yvm0dddn47 func_echoit replicated 1/1 functions/alpine:latest-armhf
lhbk1fc2lobq func_markdown replicated 1/1 functions/markdownrender:latest-armhf
pj814yluzyyo func_alertmanager replicated 1/1 alexellis2/alertmanager-armhf:0.5.1 *:9093->9093/tcp
q4bet4xs10pk func_gateway replicated 1/1 functions/gateway-armhf:0.6.0 *:8080->8080/tcp
v9vsvx73pszz func_nodeinfo replicated 1/1 functions/nodeinfo:latest-armhf
```
我们希望看到每个服务都显示 “1/1”。
你可以根据服务名查看该服务被调度到哪个树莓派上：
```
$ docker service ps func_markdown
ID IMAGE NODE STATE
func_markdown.1 functions/markdownrender:latest-armhf swarm4 Running
```
状态一项应该显示 `Running`，如果它是 `Pending`，那么镜像可能还在下载中。
在这时，查看树莓派的 IP 地址，然后在浏览器中访问它的 8080 端口：
```
$ ifconfig
```
例如，如果你的 IP 地址是 192.168.0.100，那就访问 <http://192.168.0.100:8080> 。
这是你会看到 FaaS UI（也叫 API 网关）。这是你定义、测试、调用功能的地方。
点击名称为 “func\_markdown” 的 Markdown 转换功能，输入一些 Markdown（这是 Wikipedia 用来组织内容的语言）文本。
然后点击 “invoke”。你会看到调用计数增加，屏幕下方显示功能调用的结果。
### 部署你的第一个 Serverless 功能：
这一节的内容已经有相关的教程，但是我们需要几个步骤来配置树莓派。
#### 获取 FaaS-CLI
```
$ curl -sSL cli.openfaas.com | sudo sh
armv7l
Getting package https://github.com/alexellis/faas-cli/releases/download/0.4.5-b/faas-cli-armhf
```
#### 下载样例
```
$ git clone https://github.com/alexellis/faas-cli
$ cd faas-cli
```
#### 为树莓派修补样例模版
我们临时修改我们的模版，让它们能在树莓派上工作：
```
$ cp template/node-armhf/Dockerfile template/node/
$ cp template/python-armhf/Dockerfile template/python/
```
这么做是因为树莓派和我们平时关注的大多数计算机使用不一样的处理器架构。
>
> 了解 Docker 在树莓派上的最新状况，请查阅： [你需要了解的五件事](https://blog.alexellis.io/5-things-docker-rpi/)。
>
>
>
现在你可以跟着下面为 PC、笔记本和云端所写的教程操作，但我们在树莓派上要先运行一些命令。
* [使用 OpenFaaS 运行你的第一个 Serverless Python 功能](https://blog.alexellis.io/first-faas-python-function)
注意第 3 步：
* 把你的功能放到先前从 GitHub 下载的 `faas-cli` 文件夹中，而不是 `~/functinos/hello-python` 里。
* 同时，在 `stack.yml` 文件中把 `localhost` 替换成第一个树莓派的 IP 地址。
集群可能会花费几分钟把 Serverless 功能下载到相关的树莓派上。你可以用下面的命令查看你的服务，确保副本一项显示 “1/1”：
```
$ watch 'docker service ls'
pv27thj5lftz hello-python replicated 1/1 alexellis2/faas-hello-python-armhf:latest
```
**继续阅读教程：** [使用 OpenFaaS 运行你的第一个 Serverless Python 功能](https://blog.alexellis.io/first-faas-python-function)
关于 Node.js 或者其它语言的更多信息，可以进一步访问 [FaaS 仓库](https://github.com/alexellis/faas)。
### 检查功能的指标
既然使用 Serverless，你也不想花时间监控你的功能。幸运的是，OpenFaaS 内建了 [Prometheus](https://prometheus.io/) 指标检测，这意味着你可以追踪每个功能的运行时长和调用频率。
#### 指标驱动自动伸缩
如果你给一个功能生成足够的负载，OpenFaaS 将自动扩展你的功能；当需求消失时，你又会回到单一副本的状态。
这个请求样例你可以复制到浏览器中：
只要把 IP 地址改成你的即可。
```
http://192.168.0.25:9090/graph?g0.range_input=15m&g0.stacked=1&g0.expr=rate(gateway_function_invocation_total%5B20s%5D)&g0.tab=0&g1.range_input=1h&g1.expr=gateway_service_count&g1.tab=0
```
这些请求使用 PromQL（Prometheus 请求语言）编写。第一个请求返回功能调用的频率：
```
rate(gateway_function_invocation_total[20s])
```
第二个请求显示每个功能的副本数量，最开始应该是每个功能只有一个副本。
```
gateway_service_count
```
如果你想触发自动扩展，你可以在树莓派上尝试下面指令：
```
$ while [ true ]; do curl -4 localhost:8080/function/func_echoit --data "hello world" ; done
```
查看 Prometheus 的 “alerts” 页面，可以知道你是否产生足够的负载来触发自动扩展。如果没有，你可以尝试在多个终端同时运行上面的指令。
当你降低负载，副本数量显示在你的第二个图表中，并且 `gateway_service_count` 指标再次降回 1。
### 结束演讲
我们现在配置好了 Docker、Swarm， 并且让 OpenFaaS 运行代码，把树莓派像大型计算机一样使用。
>
> 希望大家支持这个项目，**星标** [FaaS 的 GitHub 仓库](https://github.com/alexellis/faas)。
>
>
>
你是如何搭建好了自己的 Docker Swarm 集群并且运行 OpenFaaS 的呢？在 Twitter [@alexellisuk](https://twitter.com/alexellisuk) 上分享你的照片或推文吧。
**观看我在 Dockercon 上关于 OpenFaaS 的视频**
我在 [Austin 的 Dockercon](https://blog.alexellis.io/dockercon-2017-captains-log/) 上展示了 OpenFaaS。——观看介绍和互动例子的视频： <https://www.youtube.com/embed/-h2VTE9WnZs>
有问题？在下面的评论中提出，或者给我发邮件，邀请我进入你和志同道合者讨论树莓派、Docker、Serverless 的 Slack channel。
**想要学习更多关于树莓派上运行 Docker 的内容？**
我建议从 [你需要了解的五件事](https://blog.alexellis.io/5-things-docker-rpi/) 开始，它包含了安全性、树莓派和普通 PC 间微妙差别等话题。
* [Dockercon tips: Docker & Raspberry Pi](https://blog.alexellis.io/dockercon-tips-docker-raspberry-pi/)
* [Control GPIO with Docker Swarm](https://blog.alexellis.io/gpio-on-swarm/)
* [Is that a Docker Engine in your pocket??](https://blog.alexellis.io/docker-engine-in-your-pocket/)
---
via: <https://blog.alexellis.io/your-serverless-raspberry-pi-cluster/>
作者：[Alex Ellis](https://twitter.com/alexellisuk) 译者：[haoqixu](https://github.com/haoqixu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
每个安卓开发初学者应该了解的 12 个技巧
|
Nilesh Singh
|
https://android.jlelse.eu/12-practices-every-android-beginner-should-know-cd43c3710027
|
在这篇文章里，我们将介绍一些初学者以及中级开发人员都应该掌握的技巧，以帮助更好地理解安卓框架。
|
/data/attachment/album/201710/29/221744os0mqqlovvv0gdlm.jpg.thumb.jpg
|
/data/attachment/album/201710/29/221744os0mqqlovvv0gdlm.jpg
| true
| false
| true
|
zpl1025
| false
|
[
"Android"
] |
软件开发
|
{
"viewnum": 5880,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章里，我们将介绍一些初学者以及中级开发人员都应该掌握的技巧，以帮助更好地理解安卓框架。
| 2017-10-29T22:17:43
| 2017-10-29T22:17:43
| 9,008
|
/article-9008-1.html
|
>
> 一次掌握一个技巧，更好地学习安卓
>
>
>
距离安迪·鲁宾和他的团队着手开发一个希望颠覆传统手机操作模式的操作系统已经过去 12 年了，这套系统有可能让手机或者智能机给消费者以及软件开发人员带来全新的体验。之前的智能机仅限于收发短信和查看电子邮件（当然还可以打电话），给用户和开发者带来很大的限制。
安卓，作为打破这个枷锁的系统，拥有非常优秀的框架设计，给大家提供的不仅仅是一组有限的功能，更多的是自由的探索。有人会说 iPhone 才是手机产业的颠覆产品，不过我们说的不是 iPhone 有多么酷（或者多么贵，是吧？），它还是有限制的，而这是我们从来都不希望有的。
不过，就像本大叔说的，能力越大责任越大，我们也需要更加认真对待安卓应用的设计方式。我看到很多教程都忽略了向初学者传递这个理念，在动手之前请先充分理解系统架构。他们只是把一堆的概念和代码丢给读者，却没有解释清楚相关的优缺点，它们对系统的影响，以及该用什么不该用什么等等。
在这篇文章里，我们将介绍一些初学者以及中级开发人员都应该掌握的技巧，以帮助更好地理解安卓框架。后续我们还会在这个系列里写更多这样的关于实用技巧的文章。我们开始吧。
### 1、 `@+id` 和 `@id` 的区别
要在 Java 代码里访问一个图形控件（或组件），或者是要让它成为其他控件的依赖，我们需要一个唯一的值来引用它。这个唯一值用 `android:id` 属性来定义，本质上就是把用户提供的 id 附加到 `@+id/` 后面，写入到 *id 资源文件*，供其他控件使用。一个 Toolbar 的 id 可以这样定义，
```
android:id="@+id/toolbar"
```
然后这个 id 值就能被 `findViewById(…)` 识别，这个函数会在资源文件里查找 id，或者直接从 R.id 路径引用，然后返回所查找的 View 的类型。
而另一种，`@id`，和 `findViewById(…)` 行为一样 - 也会根据提供的 id 查找组件，不过仅限于布局时使用。一般用来布置相关控件。
```
android:layout_below="@id/toolbar"
```
### 2、 使用 `@string` 资源为 XML 提供字符串
简单来说，就是不要在 XML 里直接用字符串。原因很简单。当我们在 XML 里直接使用了字符串，我们一般会在其它地方再次用到同样的字符串。想像一下当我们需要在不同的地方调整同一个字符串的噩梦，而如果使用字符串资源就只改一个地方就够了。另一个好处是，使用资源文件可以提供多国语言支持，因为可以为不同的语言创建相应的字符串资源文件。
```
android:text="My Awesome Application"
```
当你直接使用字符串时，你会在 Android Studio 里收到警告，提示说应该把写死的字符串改成字符串资源。可以点击这个提示，然后按下 `ALT + ENTER` 打开字符串编辑。你也可以直接打开 `res` 目录下的 `values` 目录里的 `strings.xml` 文件，然后像下面这样声明一个字符串资源。
```
<string name="app_name">My Awesome Application</string>
```
然后用它来替换写死的字符串，
```
android:text="@string/app_name"
```
### 3、 使用 `@android` 和 `?attr` 常量
尽量使用系统预先定义的常量而不是重新声明。举个例子，在布局中有几个地方要用白色或者 #ffffff 颜色值。不要每次都直接用 #ffffff 数值，也不要自己为白色重新声明资源，我们可以直接用这个，
```
@android:color/white
```
安卓预先定义了很多常用的颜色常量，比如白色，黑色或粉色。最经典的应用场景是透明色：
```
@android:color/transparent
```
另一个引用常量的方式是 `?attr`，用来将预先定义的属性值赋值给不同的属性。举个自定义 Toolbar 的例子。这个 Toolbar 需要定义宽度和高度。宽度通常可以设置为 `MATCH_PARENT`，但高度呢？我们大多数人都没有注意设计指导，只是简单地随便设置一个看上去差不多的值。这样做不对。不应该随便自定义高度，而应该这样做，
```
android:layout_height="?attr/actionBarSize"
```
`?attr` 的另一个应用是点击视图时画水波纹效果。`SelectableItemBackground` 是一个预定义的 drawable，任何视图需要增加波纹效果时可以将它设为背景：
```
android:background="?attr/selectableItemBackground"
```
也可以用这个：
```
android:background="?attr/selectableItemBackgroundBorderless"
```
来显示无边框波纹。
### 4、 SP 和 DP 的区别
虽然这两个没有本质上的区别，但知道它们是什么以及在什么地方适合用哪个很重要。
SP 的意思是缩放无关像素，一般建议用于 TextView，首先文字不会因为显示密度不同而显示效果不一样，另外 TextView 的内容还需要根据用户设定做拉伸，或者只调整字体大小。
其他需要定义尺寸和位置的地方，可以使用 DP，也就是密度无关像素。之前说过，DP 和 SP 的性质是一样的，只是 DP 会根据显示密度自动拉伸，因为安卓系统会动态计算实际显示的像素，这样就可以让使用 DP 的组件在不同显示密度的设备上都可以拥有相同的显示效果。
### 5、 Drawable 和 Mipmap 的应用
这两个最让人困惑的是 - drawable 和 mipmap 有多少差异？
虽然这两个好像有同样的用途，但它们设计目的不一样。mipmap 是用来储存图标的，而 drawable 用于任何其他格式。我们可以看一下系统内部是如何使用它们的，就知道为什么不能混用了。
你可以看到你的应用里有几个 mipmap 和 drawable 目录，每一个分别代表不同的显示分辨率。当系统从 drawable 目录读取资源时，只会根据当前设备的显示密度选择确定的目录。然而，在读取 mipmap 时，系统会根据需要选择合适的目录，而不仅限于当前显示密度，主要是因为有些启动器会故意显示较大的图标，所以系统会使用较大分辨率的资源。
总之，用 mipmap 来存放图标或标记图片，可以在不同显示密度的设备上看到分辨率变化，而其它根据需要显示的图片资源都用 drawable。
比如说，Nexus 5 的显示分辨率是 xxhdpi。当我们把图标放到 `mipmap` 目录里时，所有 `mipmap` 目录都将读入内存。而如果放到 drawable 里，只有 `drawable-xxhdpi` 目录会被读取，其他目录都会被忽略。
### 6、 使用矢量图形
为了支持不同显示密度的屏幕，将同一个资源的多个版本（大小）添加到项目里是一个很常见的技巧。这种方式确实有用，不过它也会带来一定的性能开支，比如更大的 apk 文件以及额外的开发工作。为了消除这种影响，谷歌的安卓团队发布了新增的矢量图形。
矢量图形是用 XML 描述的 SVG（可拉伸矢量图形），是用点、直线和曲线组合以及填充颜色绘制出的图形。正因为矢量图形是由点和线动态画出来的，在不同显示密度下拉伸也不会损失分辨率。而矢量图形带来的另一个好处是更容易做动画。往一个 AnimatedVectorDrawable 文件里添加多个矢量图形就可以做出动画，而不用添加多张图片然后再分别处理。
```
<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:width="24dp"
android:height="24dp"
android:viewportWidth="24.0"
android:viewportHeight="24.0">
<path android:fillColor="#69cdff" android:pathData="M3,18h18v-2L3,16v2zM3,13h18v-2L3,11v2zM3,6v2h18L21,6L3,6z"/>
</vector>
```
上面的向量定义可以画出下面的图形，
要在你的安卓项目里添加矢量图形，可以右键点击你项目里的应用模块，然后选择 New >> Vector Assets。然后会打开 Assets Studio，你可以有两种方式添加矢量图形。第一种是从 Material 图标里选择，另一种是选择本地的 SVG 或 PSD 文件。
谷歌建议与应用相关都使用 Material 图标，来保持安卓的连贯性和统一体验。[这里](https://material.io/icons/)有全部图标，记得看一下。
### 7、 设定边界的开始和结束
这是人们最容易忽略的地方之一。边界！增加边界当然很简单，但是如果要考虑支持很旧的平台呢？
边界的“开始”和“结束”分别是“左”和“右”的超集，所以如果应用的 `minSdkVersion` 是 17 或更低，边界和填充的“开始”和“结束”定义是旧的“左”/“右”所需要的。在那些没有定义“开始”和“结束”的系统上，这两个定义可以被安全地忽略。可以像下面这样声明：
```
android:layout_marginEnd="20dp"
android:paddingStart="20dp"
```
### 8、 使用 Getter/Setter 生成工具
在创建一个容器类（只是用来简单的存放一些变量数据）时很烦的一件事情是写多个 getter 和 setter，复制/粘贴该方法的主体再为每个变量重命名。
幸运的是，Android Studio 有一个解决方法。可以这样做，在类里声明你需要的所有变量，然后打开 Toolbar >> Code。快捷方式是 `ALT + Insert`。点击 Code 会显示 Generate，点击它会出来很多选项，里面有 Getter 和 Setter 选项。在保持焦点在你的类页面然后点击，就会为当前类添加所有的 getter 和 setter（有需要的话可以再去之前的窗口操作）。很爽吧。
### 9、 使用 Override/Implement 生成工具
这是另一个很好用的生成工具。自定义一个类然后再扩展很容易，但是如果要扩展你不熟悉的类呢。比如说 PagerAdapter，你希望用 ViewPager 来展示一些页面，那就需要定制一个 PagerAdapter 并实现它的重载方法。但是具体有哪些方法呢？Android Studio 非常贴心地为自定义类强行添加了一个构造函数，或者可以用快捷键（`ALT + Enter`），但是父类 PagerAdapter 里的其他（虚拟）方法需要自己手动添加，我估计大多数人都觉得烦。
要列出所有可以重载的方法，可以点击 Code >> Generate and Override methods 或者 Implement methods，根据你的需要。你还可以为你的类选择多个方法，只要按住 Ctrl 再选择方法，然后点击 OK。
### 10、 正确理解 Context
Context 有点恐怖，我估计许多初学者从没有认真理解过 Context 类的结构 - 它是什么，为什么到处都要用到它。
简单地说，它将你能从屏幕上看到的所有内容都整合在一起。所有的视图（或者它们的扩展）都通过 Context 绑定到当前的环境。Context 用来管理应用层次的资源，比如说显示密度，或者当前的关联活动。活动、服务和应用都实现了 Context 类的接口来为其他关联组件提供内部资源。举个添加到 MainActivity 的 TextView 的例子。你应该注意到了，在创建一个对象的时候，TextView 的构造函数需要 Context 参数。这是为了获取 TextView 里定义到的资源。比如说，TextView 需要在内部用到 Roboto 字体。这样的话，TextView 需要 Context。而且在我们将 Context（或者 `this`）传递给 TextView 的时候，也就是告诉它绑定当前活动的生命周期。
另一个 Context 的关键应用是初始化应用层次的操作，比如初始化一个库。库的生命周期和应用是不相关的，所以它需要用 `getApplicationContext()` 来初始化，而不是用 `getContext` 或 `this` 或 `getActivity()`。掌握正确使用不同 Context 类型非常重要，可以避免内存泄漏。另外，要用到 Context 来启动一个活动或服务。还记得 `startActivity(…)` 吗？当你需要在一个非活动类里切换活动时，你需要一个 Context 对象来调用 `startActivity` 方法，因为它是 Context 类的方法，而不是 Activity 类。
```
getContext().startActivity(getContext(), SecondActivity.class);
```
如果你想了解更多 Context 的行为，可以看看[这里](https://blog.mindorks.com/understanding-context-in-android-application-330913e32514)或[这里](https://developer.android.com/reference/android/content/Context.html)。第一个是一篇关于 Context 的很好的文章，介绍了在哪些地方要用到它。而另一个是安卓关于 Context 的文档，全面介绍了所有的功能 - 方法，静态标识以及更多。
### 奖励 #1: 格式化代码
有人会不喜欢整齐，统一格式的代码吗？好吧，几乎我们每一个人，在写一个超过 1000 行的类的时候，都希望我们的代码能有合适的结构。而且，并不仅仅大的类才需要格式化，每一个小模块类也需要让代码保持可读性。
使用 Android Studio，或者任何 JetBrains IDE，你都不需要自己手动整理你的代码，像增加缩进或者 = 之前的空格。就按自己希望的方式写代码，在想要格式化的时候，如果是 Windows 系统可以按下 `ALT + CTRL + L`，Linux 系统按下 `ALT + CTRL + SHIFT + L`。*代码就自动格式化好了*
### 奖励 #2: 使用库
面向对象编程的一个重要原则是增加代码的可重用性，或者说减少重新发明轮子的习惯。很多初学者错误地遵循了这个原则。这条路有两个方向，
* 不用任何库，自己写所有的代码。
* 用库来处理所有事情。
不管哪个方向走到底都是不对的。如果你彻底选择第一个方向，你将消耗大量的资源，仅仅是为了满足自己拥有一切的骄傲。很可能你的代码没有做过替代库那么多的测试，从而增加模块出问题的可能。如果资源有限，不要重复发明轮子。直接用经过测试的库，在有了明确目标以及充分的资源后，可以用自己的可靠代码来替换这个库。
而彻底走向另一个方向，问题更严重 - 别人代码的可靠性。不要习惯于所有事情都依赖于别人的代码。在不用太多资源或者自己能掌控的情况下尽量自己写代码。你不需要用库来自定义一个 TypeFaces（字体），你可以自己写一个。
所以要记住，在这两个极端中间平衡一下 - 不要重新创造所有事情，也不要过分依赖外部代码。保持中立，根据自己的能力写代码。
这篇文章最早发布在 [What’s That Lambda](https://www.whatsthatlambda.com/android/android-dev-101-things-every-beginner-must-know) 上。请访问网站阅读更多关于 Android、Node.js、Angular.js 等等类似文章。
---
via: <https://android.jlelse.eu/12-practices-every-android-beginner-should-know-cd43c3710027>
作者：[Nilesh Singh](https://android.jlelse.eu/@nileshsingh?source=post_header_lockup) 译者：[zpl1025](https://github.com/zpl1025) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
IoT 网络安全：后备计划是什么？
|
Bruce Schneier
|
https://www.schneier.com/blog/archives/2017/10/iot_cybersecuri.html
|
互联网是危险的 - 物联网不仅给了眼睛和耳朵，而且还给手脚。一旦有影响到位和字节的安全漏洞、利用和攻击现在将会影响到其血肉。
|
/data/attachment/album/201710/29/234049f29ve82598vlerym.jpg.thumb.jpg
|
/data/attachment/album/201710/29/234049f29ve82598vlerym.jpg
| true
| false
| true
|
geekpi
| false
|
[
"安全",
"物联网",
"IoT"
] |
观点
|
{
"viewnum": 4697,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
互联网是危险的 - 物联网不仅给了眼睛和耳朵，而且还给手脚。一旦有影响到位和字节的安全漏洞、利用和攻击现在将会影响到其血肉。
| 2017-10-29T23:40:46
| 2017-10-29T23:40:46
| 9,009
|
/article-9009-1.html
|
八月份，四名美国参议员提出了一项旨在改善物联网（IoT）安全性的法案。2017 年的 “物联网网络安全改进法” 是一项小幅的立法。它没有规范物联网市场。它没有任何特别关注的行业，或强制任何公司做任何事情。甚至没有修改嵌入式软件的法律责任。无论安全多么糟糕，公司可以继续销售物联网设备。
法案的做法是利用政府的购买力推动市场：政府购买的任何物联网产品都必须符合最低安全标准。它要求供应商确保设备不仅可以打补丁，而且是以认证和及时的方式进行修补，没有不可更改的默认密码，并且没有已知的漏洞。这是一个你可以达到的低安全值，并且将大大提高安全性，可以说明关于物联网安全性的当前状态。（全面披露：我帮助起草了一些法案的安全性要求。）
该法案还将修改“计算机欺诈和滥用”和“数字千年版权”法案，以便安全研究人员研究政府购买的物联网设备的安全性。这比我们的行业需求要窄得多。但这是一个很好的第一步，这可能是对这个立法最好的事。
不过，这一步甚至不可能施行。我在八月份写这个专栏，毫无疑问，这个法案你在十月份或以后读的时候会没有了。如果听证会举行，它们无关紧要。该法案不会被任何委员会投票，不会在任何立法日程上。这个法案成为法律的可能性是零。这不仅仅是因为目前的政治 - 我在奥巴马政府下同样悲观。
但情况很严重。互联网是危险的 - 物联网不仅给了眼睛和耳朵，而且还给手脚。一旦有影响到位和字节的安全漏洞、利用和攻击现在将会影响到其血肉。
正如我们在过去一个世纪一再学到的那样，市场是改善产品和服务安全的可怕机制。汽车、食品、餐厅、飞机、火灾和金融仪器安全都是如此。原因很复杂，但基本上卖家不会在安全方面进行竞争，因为买方无法根据安全考虑有效区分产品。市场使用的竞相降低门槛的机制价格降到最低的同时也将质量降至最低。没有政府干预，物联网仍然会很不安全。
美国政府对干预没有兴趣，所以我们不会看到严肃的安全和保障法规、新的联邦机构或更好的责任法。我们可能在欧盟有更好的机会。根据“通用数据保护条例”在数据隐私的规定，欧盟可能会在 5 年内通过类似的安全法。没有其他国家有足够的市场份额来做改变。
有时我们可以选择不使用物联网，但是这个选择变得越来越少见了。去年，我试着不连接网络来购买新车但是失败了。再过几年, 就几乎不可能不连接到物联网。我们最大的安全风险将不会来自我们与之有市场关系的设备，而是来自其他人的汽车、照相机、路由器、无人机等等。
我们可以尝试为理想买单，并要求更多的安全性，但企业不会在物联网安全方面进行竞争 - 而且我们的安全专家不是一个可以产生影响的足够大的市场力量。
我们需要一个后备计划，虽然我不知道是什么。如果你有任何想法请评论。
这篇文章以前出现在 9/10 月的 《IEEE安全与隐私》上。
---
作者简介：
自从 2004 年以来，我一直在博客上写关于安全的文章，以及从 1998 年以来我的每月订阅中也有。我写书、文章和学术论文。目前我是 IBM Resilient 的首席技术官，哈佛伯克曼中心的研究员，EFF 的董事会成员。
---
via: <https://www.schneier.com/blog/archives/2017/10/iot_cybersecuri.html>
作者：[Bruce Schneier](https://www.schneier.com/blog/about/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
服务端 I/O 性能：Node、PHP、Java、Go 的对比
|
Brad Peabody
|
https://www.toptal.com/back-end/server-side-io-performance-node-php-java-go
|
了解应用程序的输入/输出（I/O）模型意味着理解应用程序处理其数据的载入差异，并揭示其在真实环境中表现。或许你的应用程序很小，在不承受很大的负载时，这并不是个严重的问题；但随着应用程序的流量负载增加，可能因为使用了低效的 I/O 模型导致承受不了而崩溃。
|
/data/attachment/album/201710/31/094307myjfkfnjzjxtfhox.jpg.thumb.jpg
|
/data/attachment/album/201710/31/094307myjfkfnjzjxtfhox.jpg
| true
| false
| true
|
MonkeyDEcho
| false
|
[
"性能"
] |
技术
|
{
"viewnum": 10053,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
了解应用程序的输入/输出（I/O）模型意味着理解应用程序处理其数据的载入差异，并揭示其在真实环境中表现。或许你的应用程序很小，在不承受很大的负载时，这并不是个严重的问题；但随着应用程序的流量负载增加，可能因为使用了低效的 I/O 模型导致承受不了而崩溃。
| 2017-10-31T09:42:59
| 2017-10-31T09:42:59
| 9,010
|
/article-9010-1.html
|
了解应用程序的输入/输出（I/O）模型意味着理解应用程序处理其数据的载入差异，并揭示其在真实环境中表现。或许你的应用程序很小，在不承受很大的负载时，这并不是个严重的问题；但随着应用程序的流量负载增加，可能因为使用了低效的 I/O 模型导致承受不了而崩溃。
和大多数情况一样，处理这种问题的方法有多种方式，这不仅仅是一个择优的问题，而是对权衡的理解问题。 接下来我们来看看 I/O 到底是什么。
在本文中，我们将对 Node、Java、Go 和 PHP + Apache 进行对比，讨论不同语言如何构造其 I/O ，每个模型的优缺点，并总结一些基本的规律。如果你担心你的下一个 Web 应用程序的 I/O 性能，本文将给你最优的解答。
### I/O 基础知识: 快速复习
要了解 I/O 所涉及的因素，我们首先深入到操作系统层面复习这些概念。虽然看起来并不与这些概念直接打交道，但你会一直通过应用程序的运行时环境与它们间接接触。了解细节很重要。
#### 系统调用
首先是系统调用，其被描述如下：
* 程序（所谓“<ruby> 用户端 <rt> user land </rt></ruby>”）必须请求操作系统内核代表它执行 I/O 操作。
* “<ruby> 系统调用 <rt> syscall </rt></ruby>”是你的程序要求内核执行某些操作的方法。这些实现的细节在操作系统之间有所不同，但基本概念是相同的。有一些具体的指令会将控制权从你的程序转移到内核（类似函数调用，但是使用专门用于处理这种情况的专用方式）。一般来说，系统调用会被阻塞，这意味着你的程序会等待内核返回（控制权到）你的代码。
* 内核在所需的物理设备（ 磁盘、网卡等 ）上执行底层 I/O 操作，并回应系统调用。在实际情况中，内核可能需要做许多事情来满足你的要求，包括等待设备准备就绪、更新其内部状态等，但作为应用程序开发人员，你不需要关心这些。这是内核的工作。
#### 阻塞与非阻塞
上面我们提到过，系统调用是阻塞的，一般来说是这样的。然而，一些调用被归类为“非阻塞”，这意味着内核会接收你的请求，将其放在队列或缓冲区之类的地方，然后立即返回而不等待实际的 I/O 发生。所以它只是在很短的时间内“阻塞”，只需要排队你的请求即可。
举一些 Linux 系统调用的例子可能有助于理解：
* `read()` 是一个阻塞调用 - 你传递一个句柄，指出哪个文件和缓冲区在哪里传送它所读取的数据，当数据就绪时，该调用返回。这种方式的优点是简单友好。
* 分别调用 `epoll_create()`、`epoll_ctl()` 和 `epoll_wait()` ，你可以创建一组句柄来侦听、添加/删除该组中的处理程序、然后阻塞直到有任何事件发生。这允许你通过单个线程有效地控制大量的 I/O 操作，但是现在谈这个还太早。如果你需要这个功能当然好，但须知道它使用起来是比较复杂的。
了解这里的时间差异的数量级是很重要的。假设 CPU 内核运行在 3GHz，在没有进行 CPU 优化的情况下，那么它每秒执行 30 亿次<ruby> 周期 <rt> cycle </rt></ruby>（即每纳秒 3 个周期）。非阻塞系统调用可能需要几十个周期来完成，或者说 “相对少的纳秒” 时间完成。而一个被跨网络接收信息所阻塞的系统调用可能需要更长的时间 - 例如 200 毫秒（1/5 秒）。这就是说，如果非阻塞调用需要 20 纳秒，阻塞调用需要 2 亿纳秒。你的进程因阻塞调用而等待了 1000 万倍的时长！
内核既提供了阻塞 I/O （“从网络连接读取并给出数据”），也提供了非阻塞 I/O （“告知我何时这些网络连接具有新数据”）的方法。使用的是哪种机制对调用进程的阻塞时长有截然不同的影响。
#### 调度
关键的第三件事是当你有很多线程或进程开始阻塞时会发生什么。
根据我们的理解，线程和进程之间没有很大的区别。在现实生活中，最显著的性能相关的差异在于，由于线程共享相同的内存，而进程每个都有自己的内存空间，使得单独的进程往往占用更多的内存。但是当我们谈论<ruby> 调度 <rt> Scheduling </rt></ruby>时，它真正归结为一类事情（线程和进程类同），每个都需要在可用的 CPU 内核上获得一段执行时间。如果你有 300 个线程运行在 8 个内核上，则必须将时间分成几份，以便每个线程和进程都能分享它，每个运行一段时间，然后交给下一个。这是通过 “<ruby> 上下文切换 <rt> context switch </rt></ruby>” 完成的，可以使 CPU 从运行到一个线程/进程到切换下一个。
这些上下文切换也有相关的成本 - 它们需要一些时间。在某些快速的情况下，它可能小于 100 纳秒，但根据实际情况、处理器速度/体系结构、CPU 缓存等，偶见花费 1000 纳秒或更长时间。
而线程（或进程）越多，上下文切换就越多。当我们涉及数以千计的线程时，每个线程花费数百纳秒，就会变得很慢。
然而，非阻塞调用实质上是告诉内核“仅在这些连接之一有新的数据或事件时再叫我”。这些非阻塞调用旨在有效地处理大量 I/O 负载并减少上下文交换。
这些你明白了么？现在来到了真正有趣的部分：我们来看看一些流行的语言对那些工具的使用，并得出关于易用性和性能之间权衡的结论，以及一些其他有趣小东西。
声明，本文中显示的示例是零碎的（片面的，只能体现相关的信息）; 数据库访问、外部缓存系统（ memcache 等等）以及任何需要 I/O 的东西都将执行某种类型的 I/O 调用，其实质与上面所示的简单示例效果相同。此外，对于将 I/O 描述为“阻塞”（ PHP、Java ）的情况，HTTP 请求和响应读取和写入本身就是阻塞调用：系统中隐藏着更多 I/O 及其伴生的性能问题需要考虑。
为一个项目选择编程语言要考虑很多因素。甚至当你只考虑效率时，也有很多因素。但是，如果你担心你的程序将主要受到 I/O 的限制，如果 I/O 性能影响到项目的成败，那么这些是你需要了解的。
### “保持简单”方法：PHP
早在 90 年代，很多人都穿着 [Converse](https://www.pinterest.com/pin/414401603185852181/) 鞋，用 Perl 写着 CGI 脚本。然后 PHP 来了，就像一些人喜欢咒骂的一样，它使得动态网页更容易。
PHP 使用的模型相当简单。虽有一些出入，但你的 PHP 服务器基本上是这样：
HTTP 请求来自用户的浏览器，并访问你的 Apache Web 服务器。Apache 为每个请求创建一个单独的进程，有一些优化方式可以重新使用它们，以最大限度地减少创建次数（ 相对而言，创建进程较慢 ）。Apache 调用 PHP 并告诉它运行磁盘上合适的 `.php` 文件。PHP 代码执行并阻塞 I/O 调用。你在 PHP 中调用 `file_get_contents()` ，其底层会调用 `read()` 系统调用并等待结果。
当然，实际的代码是直接嵌入到你的页面，并且该操作被阻塞：
```
<?php
// blocking file I/O
$file_data = file_get_contents(‘/path/to/file.dat’);
// blocking network I/O
$curl = curl_init('http://example.com/example-microservice');
$result = curl_exec($curl);
// some more blocking network I/O
$result = $db->query('SELECT id, data FROM examples ORDER BY id DESC limit 100');
?>
```
关于如何与系统集成，就像这样：
很简单：每个请求一个进程。 I/O 调用就阻塞。优点是简单可工作，缺点是，同时与 20,000 个客户端连接，你的服务器将会崩溃。这种方法不能很好地扩展，因为内核提供的用于处理大容量 I/O （epoll 等） 的工具没有被使用。 雪上加霜的是，为每个请求运行一个单独的进程往往会使用大量的系统资源，特别是内存，这通常是你在这样的场景中遇到的第一个问题。
*注意：Ruby 使用的方法与 PHP 非常相似，在大致的方面上，它们可以被认为是相同的。*
### 多线程方法： Java
就在你购买你的第一个域名，在某个句子后很酷地随机说出 “dot com” 的那个时候，Java 来了。而 Java 具有内置于该语言中的多线程功能，它非常棒（特别是在创建时）。
大多数 Java Web 服务器通过为每个请求启动一个新的执行线程，然后在该线程中最终调用你（作为应用程序开发人员）编写的函数。
在 Java Servlet 中执行 I/O 往往看起来像：
```
public void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException
{
// blocking file I/O
InputStream fileIs = new FileInputStream("/path/to/file");
// blocking network I/O
URLConnection urlConnection = (new URL("http://example.com/example-microservice")).openConnection();
InputStream netIs = urlConnection.getInputStream();
// some more blocking network I/O
out.println("...");
}
```
由于我们上面的 `doGet` 方法对应于一个请求，并且在其自己的线程中运行，而不是每个请求一个单独的进程，申请自己的内存。这样有一些好处，比如在线程之间共享状态、缓存数据等，因为它们可以访问彼此的内存，但是它与调度的交互影响与之前的 PHP 的例子几乎相同。每个请求获得一个新线程，该线程内的各种 I/O 操作阻塞在线程内，直到请求被完全处理为止。线程被池化以最小化创建和销毁它们的成本，但是数千个连接仍然意味着数千个线程，这对调度程序是不利的。
重要的里程碑出现在 Java 1.4 版本（以及 1.7 的重要升级）中，它获得了执行非阻塞 I/O 调用的能力。大多数应用程序、web 应用和其它用途不会使用它，但至少它是可用的。一些 Java Web 服务器尝试以各种方式利用这一点；然而，绝大多数部署的 Java 应用程序仍然如上所述工作。
肯定有一些很好的开箱即用的 I/O 功能，Java 让我们更接近，但它仍然没有真正解决当你有一个大量的 I/O 绑定的应用程序被数千个阻塞线程所压垮的问题。
### 无阻塞 I/O 作为一等公民： Node
当更好的 I/O 模式来到 Node.js，阻塞才真正被解决。任何一个曾听过 Node 简单介绍的人都被告知这是“非阻塞”，可以有效地处理 I/O。这在一般意义上是正确的。但在细节中则不尽然，而且当在进行性能工程时，这种巫术遇到了问题。
Node 实现的范例基本上不是说 “在这里写代码来处理请求”，而是说 “在这里写代码来**开始**处理请求”。每次你需要做一些涉及到 I/O 的操作，你会创建一个请求并给出一个回调函数，Node 将在完成之后调用该函数。
在请求中执行 I/O 操作的典型 Node 代码如下所示：
```
http.createServer(function(request, response) {
fs.readFile('/path/to/file', 'utf8', function(err, data) {
response.end(data);
});
});
```
你可以看到，这里有两个回调函数。当请求开始时，第一个被调用，当文件数据可用时，第二个被调用。
这样做的基本原理是让 Node 有机会有效地处理这些回调之间的 I/O 。一个更加密切相关的场景是在 Node 中进行数据库调用，但是我不会在这个例子中啰嗦，因为它遵循完全相同的原则：启动数据库调用，并给 Node 一个回调函数，它使用非阻塞调用单独执行 I/O 操作，然后在你要求的数据可用时调用回调函数。排队 I/O 调用和让 Node 处理它然后获取回调的机制称为“事件循环”。它工作的很好。
然而，这个模型有一个陷阱，究其原因，很多是与 V8 JavaScript 引擎（Node 用的是 Chrome 浏览器的 JS 引擎）如何实现的有关<sup> 注1</sup> 。你编写的所有 JS 代码都运行在单个线程中。你可以想想，这意味着当使用高效的非阻塞技术执行 I/O 时，你的 JS 可以在单个线程中运行计算密集型的操作，每个代码块都会阻塞下一个。可能出现这种情况的一个常见例子是以某种方式遍历数据库记录，然后再将其输出到客户端。这是一个示例，展示了其是如何工作：
```
var handler = function(request, response) {
connection.query('SELECT ...', function (err, rows) {
if (err) { throw err };
for (var i = 0; i < rows.length; i++) {
// do processing on each row
}
response.end(...); // write out the results
})
};
```
虽然 Node 确实有效地处理了 I/O ，但是上面的例子中 `for` 循环是在你的唯一的一个主线程中占用 CPU 周期。这意味着如果你有 10,000 个连接，则该循环可能会使你的整个应用程序像爬行般缓慢，具体取决于其会持续多久。每个请求必须在主线程中分享一段时间，一次一段。
这整个概念的前提是 I/O 操作是最慢的部分，因此最重要的是要有效地处理这些操作，即使这意味着要连续进行其他处理。这在某些情况下是正确的，但不是全部。
另一点是，虽然这只是一个观点，但是写一堆嵌套的回调可能是相当令人讨厌的，有些则认为它使代码更难以追踪。在 Node 代码中看到回调嵌套 4 层、5 层甚至更多层并不罕见。
我们再次来权衡一下。如果你的主要性能问题是 I/O，则 Node 模型工作正常。然而，它的关键是，你可以在一个处理 HTTP 请求的函数里面放置 CPU 密集型的代码，而且不小心的话会导致每个连接都很慢。
### 最自然的非阻塞：Go
在我进入 Go 部分之前，我应该披露我是一个 Go 的粉丝。我已经在许多项目中使用过它，我是一个其生产力优势的公开支持者，我在我的工作中使用它。
那么，让我们来看看它是如何处理 I/O 的。Go 语言的一个关键特征是它包含自己的调度程序。在 Go 中，不是每个执行线程对应于一个单一的 OS 线程，其通过一种叫做 “<ruby> 协程 <rt> goroutine </rt></ruby>” 的概念来工作。而 Go 的运行时可以将一个协程分配给一个 OS 线程，使其执行或暂停它，并且它不与一个 OS 线程相关联——这要基于那个协程正在做什么。来自 Go 的 HTTP 服务器的每个请求都在单独的协程中处理。
调度程序的工作原理如图所示：
在底层，这是通过 Go 运行时中的各个部分实现的，它通过对请求的写入/读取/连接等操作来实现 I/O 调用，将当前协程休眠，并当采取进一步动作时唤醒该协程。
从效果上看，Go 运行时做的一些事情与 Node 做的没有太大不同，除了回调机制是内置到 I/O 调用的实现中，并自动与调度程序交互。它也不会受到必须让所有处理程序代码在同一个线程中运行的限制，Go 将根据其调度程序中的逻辑自动将协程映射到其认为适当的 OS 线程。结果是这样的代码：
```
func ServeHTTP(w http.ResponseWriter, r *http.Request) {
// the underlying network call here is non-blocking
rows, err := db.Query("SELECT ...")
for _, row := range rows {
// do something with the rows,
// each request in its own goroutine
}
w.Write(...) // write the response, also non-blocking
}
```
如上所述，我们重构基本的代码结构为更简化的方式，并在底层仍然实现了非阻塞 I/O。
在大多数情况下，最终是“两全其美”的。非阻塞 I/O 用于所有重要的事情，但是你的代码看起来像是阻塞，因此更容易理解和维护。Go 调度程序和 OS 调度程序之间的交互处理其余部分。这不是完整的魔法，如果你建立一个大型系统，那么值得我们来看看有关它的工作原理的更多细节；但与此同时，你获得的“开箱即用”的环境可以很好地工作和扩展。
Go 可能有其缺点，但一般来说，它处理 I/O 的方式不在其中。
### 谎言，可恶的谎言和基准
对这些各种模式的上下文切换进行准确的定时是很困难的。我也可以认为这对你来说不太有用。相反，我会给出一些比较这些服务器环境的整个 HTTP 服务器性能的基本基准。请记住，影响整个端到端 HTTP 请求/响应路径的性能有很多因素，这里提供的数字只是我将一些样本放在一起进行基本比较的结果。
对于这些环境中的每一个，我写了适当的代码在一个 64k 文件中读取随机字节，在其上运行了一个 SHA-256 哈希 N 次（ N 在 URL 的查询字符串中指定，例如 .../test.php?n=100），并打印出结果十六进制散列。我选择这样做，是因为使用一些一致的 I/O 和受控的方式来运行相同的基准测试是一个增加 CPU 使用率的非常简单的方法。
有关使用的环境的更多细节，请参阅 [基准说明](https://peabody.io/post/server-env-benchmarks/) 。
首先，我们来看一些低并发的例子。运行 2000 次迭代，300 个并发请求，每个请求只有一个散列（N = 1），结果如下：
*时间是在所有并发请求中完成请求的平均毫秒数。越低越好。*
仅从一张图很难得出结论，但是对我来说，似乎在大量的连接和计算量上，我们看到时间更多地与语言本身的一般执行有关，对于 I/O 更是如此。请注意，那些被视为“脚本语言”的语言（松散类型，动态解释）执行速度最慢。
但是，如果我们将 N 增加到 1000，仍然有 300 个并发请求，相同的任务，但是哈希迭代是 1000 倍（显着增加了 CPU 负载）：
*时间是在所有并发请求中完成请求的平均毫秒数。越低越好。*
突然间， Node 性能显著下降，因为每个请求中的 CPU 密集型操作都相互阻塞。有趣的是，在这个测试中，PHP 的性能要好得多（相对于其他的），并且打败了 Java。（值得注意的是，在 PHP 中，SHA-256 实现是用 C 编写的，在那个循环中执行路径花费了更多的时间，因为现在我们正在进行 1000 个哈希迭代）。
现在让我们尝试 5000 个并发连接（N = 1） - 或者是我可以发起的最大连接。不幸的是，对于大多数这些环境，故障率并不显着。对于这个图表，我们来看每秒的请求总数。 *越高越好* :
*每秒请求数。越高越好。*
这个图看起来有很大的不同。我猜测，但是看起来像在高连接量时，产生新进程所涉及的每连接开销以及与 PHP + Apache 相关联的附加内存似乎成为主要因素，并阻止了 PHP 的性能。显然，Go 是这里的赢家，其次是 Java，Node，最后是 PHP。
虽然与你的整体吞吐量相关的因素很多，并且在应用程序之间也有很大的差异，但是你对底层发生什么的事情以及所涉及的权衡了解更多，你将会得到更好的结果。
### 总结
以上所有这一切，很显然，随着语言的发展，处理大量 I/O 的大型应用程序的解决方案也随之发展。
为了公平起见，PHP 和 Java，尽管这篇文章中的描述，确实 [实现了](http://reactphp.org/) 在 [web 应用程序](https://netty.io/) 中 [可使用的](http://undertow.io/) [非阻塞 I/O](http://amphp.org/) 。但是这些方法并不像上述方法那么常见，并且需要考虑使用这种方法来维护服务器的随之而来的操作开销。更不用说你的代码必须以与这些环境相适应的方式进行结构化；你的 “正常” PHP 或 Java Web 应用程序通常不会在这样的环境中进行重大修改。
作为比较，如果我们考虑影响性能和易用性的几个重要因素，我们得出以下结论：
| 语言 | 线程与进程 | 非阻塞 I/O | 使用便捷性 |
| --- | --- | --- | --- |
| PHP | 进程 | 否 | |
| Java | 线程 | 可用 | 需要回调 |
| Node.js | 线程 | 是 | 需要回调 |
| Go | 线程 （协程） | 是 | 不需要回调 |
线程通常要比进程有更高的内存效率，因为它们共享相同的内存空间，而进程则没有。结合与非阻塞 I/O 相关的因素，我们可以看到，至少考虑到上述因素，当我们从列表往下看时，与 I/O 相关的一般设置得到改善。所以如果我不得不在上面的比赛中选择一个赢家，那肯定会是 Go。
即使如此，在实践中，选择构建应用程序的环境与你的团队对所述环境的熟悉程度以及你可以实现的总体生产力密切相关。因此，每个团队都深入并开始在 Node 或 Go 中开发 Web 应用程序和服务可能就没有意义。事实上，寻找开发人员或你内部团队的熟悉度通常被认为是不使用不同语言和/或环境的主要原因。也就是说，过去十五年来，时代已经发生了变化。
希望以上内容可以帮助你更清楚地了解底层发生的情况，并为你提供如何处理应用程序的现实可扩展性的一些想法。
---
via: <https://www.toptal.com/back-end/server-side-io-performance-node-php-java-go>
作者：[BRAD PEABODY](https://www.toptal.com/resume/brad-peabody) 译者：[MonkeyDEcho](https://github.com/MonkeyDEcho) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
怎么在 Linux 中运行 DOS 程序
|
Jim Hall
|
https://opensource.com/article/17/10/run-dos-applications-linux
|
QEMU 和 FreeDOS 使得很容易在 Linux 中运行老的 DOS 程序
|
/data/attachment/album/201710/31/214631f37i3qb0ics4c4ss.jpg.thumb.jpg
|
/data/attachment/album/201710/31/214631f37i3qb0ics4c4ss.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"FreeDOS",
"DOS",
"QEMU"
] |
技术
|
{
"viewnum": 10150,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
QEMU 和 FreeDOS 使得很容易在 Linux 中运行老的 DOS 程序
| 2017-10-31T21:46:37
| 2017-10-31T21:46:37
| 9,014
|
/article-9014-1.html
|
>
> QEMU 和 FreeDOS 使得很容易在 Linux 中运行老的 DOS 程序
>
>
>
传统的 DOS 操作系统支持的许多非常优秀的应用程序： 文字处理，电子表格，游戏和其它的程序。但是一个应用程序太老了，并不意味着它没用了。
如今有很多理由去运行一个旧的 DOS 应用程序。或许是从一个遗留的业务应用程序中提取一个报告，或者是想玩一个经典的 DOS 游戏，或者只是因为你对“传统计算机”很好奇。你不需要去双引导你的系统去运行 DOS 程序。取而代之的是，你可以在 Linux 中在一个 PC 仿真程序和 [FreeDOS](http://www.freedos.org/) 的帮助下去正确地运行它们。
FreeDOS 是一个完整的、免费的、DOS 兼容的操作系统，你可以用它来玩经典的游戏、运行旧式业务软件，或者开发嵌入式系统。任何工作在 MS-DOS 中的程序也可以运行在 FreeDOS 中。
在那些“过去的时光”里，你安装的 DOS 是作为一台计算机上的独占操作系统。 而现今，它可以很容易地安装到 Linux 上运行的一台虚拟机中。 [QEMU](https://www.qemu.org/) （<ruby> 快速仿真程序 <rt> Quick EMUlator </rt></ruby>的缩写） 是一个开源的虚拟机软件，它可以在 Linux 中以一个“<ruby> 访客 <rt> guest </rt></ruby>”操作系统来运行 DOS。许多流行的 Linux 系统都默认包含了 QEMU 。
通过以下四步，很容易地在 Linux 下通过使用 QEMU 和 FreeDOS 去运行一个老的 DOS 程序。
### 第 1 步：设置一个虚拟磁盘
你需要一个地方来在 QEMU 中安装 FreeDOS，为此你需要一个虚拟的 C: 驱动器。在 DOS 中，字母`A:` 和 `B:` 是分配给第一和第二个软盘驱动器的，而 `C:` 是第一个硬盘驱动器。其它介质，包括其它硬盘驱动器和 CD-ROM 驱动器，依次分配 `D:`、`E:` 等等。
在 QEMU 中，虚拟磁盘是一个镜像文件。要初始化一个用做虚拟 `C:` 驱动器的文件，使用 `qemu-img` 命令。要创建一个大约 200 MB 的镜像文件，可以这样输入：
```
qemu-img create dos.img 200M
```
与现代计算机相比， 200MB 看起来非常小，但是早在 1990 年代， 200MB 是非常大的。它足够安装和运行 DOS。
### 第 2 步： QEMU 选项
与 PC 仿真系统 VMware 或 VirtualBox 不同，你需要通过 QEMU 命令去增加每个虚拟机的组件来 “构建” 你的虚拟系统 。虽然，这可能看起来很费力，但它实际并不困难。这些是我们在 QEMU 中用于去引导 FreeDOS 的参数：
| | |
| --- | --- |
| `qemu-system-i386` | QEMU 可以仿真几种不同的系统，但是要引导到 DOS，我们需要有一个 Intel 兼容的 CPU。 为此，使用 i386 命令启动 QEMU。 |
| `-m 16` | 我喜欢定义一个使用 16MB 内存的虚拟机。它看起来很小，但是 DOS 工作不需要很多的内存。在 DOS 时代，计算机使用 16MB 或者 8MB 内存是非常普遍的。 |
| `-k en-us` | 从技术上说，这个 `-k` 选项是不需要的，因为 QEMU 会设置虚拟键盘去匹配你的真实键盘（在我的例子中， 它是标准的 US 布局的英语键盘）。但是我还是喜欢去指定它。 |
| `-rtc base=localtime` | 每个传统的 PC 设备有一个实时时钟 (RTC) 以便于系统可以保持跟踪时间。我发现它是设置虚拟 RTC 匹配你的本地时间的最简单的方法。 |
| `-soundhw sb16,adlib,pcspk` | 如果你需要声音，尤其是为了玩游戏时，我更喜欢定义 QEMU 支持 SoundBlaster 16 声音硬件和 AdLib 音乐。SoundBlaster 16 和 AdLib 是在 DOS 时代非常常见的声音硬件。一些老的程序也许使用 PC 喇叭发声； QEMU 也可以仿真这个。 |
| `-device cirrus-vga` | 要使用图像，我喜欢去仿真一个简单的 VGA 视频卡。Cirrus VGA 卡是那时比较常见的图形卡, QEMU 可以仿真它。 |
| `-display gtk` | 对于虚拟显示，我设置 QEMU 去使用 GTK toolkit，它可以将虚拟系统放到它自己的窗口内，并且提供一个简单的菜单去控制虚拟机。 |
| `-boot order=` | 你可以告诉 QEMU 从多个引导源来引导虚拟机。从软盘驱动器引导（在 DOS 机器中一般情况下是 `A:` ）指定 `order=a`。 从第一个硬盘驱动器引导（一般称为 `C:`） 使用 `order=c`。 或者去从一个 CD-ROM 驱动器（在 DOS 中经常分配为 `D:` ） 使用 `order=d`。 你可以使用组合字母去指定一个特定的引导顺序， 比如 `order=dc` 去第一个使用 CD-ROM 驱动器，如果 CD-ROM 驱动器中没有引导介质，然后使用硬盘驱动器。 |
### 第 3 步： 引导和安装 FreeDOS
现在 QEMU 已经设置好运行虚拟机，我们需要一个 DOS 系统来在那台虚拟机中安装和引导。 FreeDOS 做这个很容易。它的最新版本是 FreeDOS 1.2， 发行于 2016 年 12 月。
从 [FreeDOS 网站](http://www.freedos.org/)上下载 FreeDOS 1.2 的发行版。 FreeDOS 1.2 CD-ROM “standard” 安装器 （`FD12CD.iso`） 可以很好地在 QEMU 上运行，因此，我推荐使用这个版本。
安装 FreeDOS 很简单。首先，告诉 QEMU 使用 CD-ROM 镜像并从其引导。 记住，第一个硬盘驱动器是 `C:` 驱动器，因此， CD-ROM 将以 `D:` 驱动器出现。
```
qemu-system-i386 -m 16 -k en-us -rtc base=localtime -soundhw sb16,adlib -device cirrus-vga -display gtk -hda dos.img -cdrom FD12CD.iso -boot order=d
```
正如下面的提示，你将在几分钟内安装完成 FreeDOS 。
在你安装完成之后，关闭窗口退出 QEMU。
### 第 4 步：安装并运行你的 DOS 应用程序
一旦安装完 FreeDOS，你可以在 QEMU 中运行各种 DOS 应用程序。你可以在线上通过各种档案文件或其它[网站](http://www.freedos.org/links/)找到老的 DOS 程序。
QEMU 提供了一个在 Linux 上访问本地文件的简单方法。比如说，想去用 QEMU 共享 `dosfiles/` 文件夹。 通过使用 `-drive` 选项，简单地告诉 QEMU 去使用这个文件夹作为虚拟的 FAT 驱动器。 QEMU 将像一个硬盘驱动器一样访问这个文件夹。
```
-drive file=fat:rw:dosfiles/
```
现在，你可以使用合适的选项去启动 QEMU，加上一个外部的虚拟 FAT 驱动器：
```
qemu-system-i386 -m 16 -k en-us -rtc base=localtime -soundhw sb16,adlib -device cirrus-vga -display gtk -hda dos.img -drive file=fat:rw:dosfiles/ -boot order=c
```
一旦你引导进入 FreeDOS，你保存在 `D:` 驱动器中的任何文件将被保存到 Linux 上的 `dosfiles/` 文件夹中。可以从 Linux 上很容易地直接去读取该文件；然而，必须注意的是，启动 QEMU 后，不能从 Linux 中去改变 `dosfiles/` 这个文件夹。 当你启动 QEMU 时，QEMU 一次性构建一个虚拟的 FAT 表，如果你在启动 QEMU 之后，在 `dosfiles/` 文件夹中增加或删除文件，仿真程序可能会很困惑。
我使用 QEMU 像这样运行一些我收藏的 DOS 程序， 比如 As-Easy-As 电子表格程序。这是一个在上世纪八九十年代非常流行的电子表格程序，它和现在的 Microsoft Excel 和 LibreOffice Calc 或和以前更昂贵的 Lotus 1-2-3 电子表格程序完成的工作是一样的。 As-Easy-As 和 Lotus 1-2-3 都保存数据为 WKS 文件，最新版本的 Microsoft Excel 不能读取它，但是，根据兼容性， LibreOffice Calc 可以支持它。
*As-Easy-As 电子表格程序*
我也喜欢在 QEMU中引导 FreeDOS 去玩一些收藏的 DOS 游戏，比如原版的 Doom。这些老的 DOS 游戏玩起来仍然非常有趣， 并且它们现在在 QEMU 上运行的非常好。
*Doom*
*Heretic*
*Jill of the Jungle*
*Commander Keen*
QEMU 和 FreeDOS 使得在 Linux 上运行老的 DOS 程序变得很容易。你一旦设置好了 QEMU 作为虚拟机仿真程序并安装了 FreeDOS，你将可以在 Linux 上运行你收藏的经典的 DOS 程序。
*所有图片要致谢 [FreeDOS.org](http://www.freedos.org/)。*
---
作者简介：
Jim Hall 是一位开源软件的开发者和支持者，可能最广为人知的是他是 FreeDOS 的创始人和项目协调者。 Jim 也非常活跃于开源软件适用性领域，作为 GNOME Outreachy 适用性测试的导师，同时也作为一名兼职教授，教授一些开源软件适用性的课程，从 2016 到 2017， Jim 在 GNOME 基金会的董事会担任董事，在工作中， Jim 是本地政府部门的 CIO。
---
via: <https://opensource.com/article/17/10/run-dos-applications-linux>
作者：[Jim Hall](https://opensource.com/users/jim-hall) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
CRI-O 1.0 简介
|
Joe Brockmeier
|
https://www.redhat.com/en/blog/introducing-cri-o-10
|
去年，Kubernetes 项目推出了容器运行时接口（CRI）：这是一个插件接口，它让 kubelet 有使用不同的兼容 OCI 的容器运行时的能力，而不需要重新编译 Kubernetes。在这项工作的基础上，CRI-O 项目（原名 OCID）准备为 Kubernetes 提供轻量级的运行时。
|
/data/attachment/album/201710/31/234936q6dom9robz9poc9f.jpg.thumb.jpg
|
/data/attachment/album/201710/31/234936q6dom9robz9poc9f.jpg
| true
| false
| true
|
geekpi
| false
|
[
"容器",
"Kubernetes",
"CRI"
] |
容器与云
|
{
"viewnum": 10995,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
去年，Kubernetes 项目推出了容器运行时接口（CRI）：这是一个插件接口，它让 kubelet 有使用不同的兼容 OCI 的容器运行时的能力，而不需要重新编译 Kubernetes。在这项工作的基础上，CRI-O 项目（原名 OCID）准备为 Kubernetes 提供轻量级的运行时。
| 2017-10-31T23:49:43
| 2017-10-31T23:49:43
| 9,015
|
/article-9015-1.html
|
去年，Kubernetes 项目推出了<ruby> <a href="https://github.com/kubernetes/kubernetes/blob/242a97307b34076d5d8f5bbeb154fa4d97c9ef1d/docs/devel/container-runtime-interface.md"> 容器运行时接口 </a> <rt> Container Runtime Interface </rt></ruby>（CRI）：这是一个插件接口，它让 kubelet（用于创建 pod 和启动容器的集群节点代理）有使用不同的兼容 OCI 的容器运行时的能力，而不需要重新编译 Kubernetes。在这项工作的基础上，[CRI-O](http://cri-o.io/) 项目（[原名 OCID](https://www.redhat.com/en/blog/running-production-applications-containers-introducing-ocid)）准备为 Kubernetes 提供轻量级的运行时。
那么这个**真正的**是什么意思？
CRI-O 允许你直接从 Kubernetes 运行容器，而不需要任何不必要的代码或工具。只要容器符合 OCI 标准，CRI-O 就可以运行它，去除外来的工具，并让容器做其擅长的事情：加速你的新一代原生云程序。
在引入 CRI 之前，Kubernetes 通过“[一个内部的](http://blog.kubernetes.io/2016/12/container-runtime-interface-cri-in-kubernetes.html)[易失性](http://blog.kubernetes.io/2016/12/container-runtime-interface-cri-in-kubernetes.html)[接口](http://blog.kubernetes.io/2016/12/container-runtime-interface-cri-in-kubernetes.html)”与特定的容器运行时相关联。这导致了上游 Kubernetes 社区以及在编排平台之上构建解决方案的供应商的大量维护开销。
使用 CRI，Kubernetes 可以与容器运行时无关。容器运行时的提供者不需要实现 Kubernetes 已经提供的功能。这是社区的胜利，因为它让项目独立进行，同时仍然可以共同工作。
在大多数情况下，我们不认为 Kubernetes 的用户（或 Kubernetes 的发行版，如 OpenShift）真的关心容器运行时。他们希望它工作，但他们不希望考虑太多。就像你（通常）不关心机器上是否有 GNU Bash、Korn、Zsh 或其它符合 POSIX 标准 shell。你只是要一个标准的方式来运行你的脚本或程序而已。
### CRI-O：Kubernetes 的轻量级容器运行时
这就是 CRI-O 提供的。该名称来自 CRI 和开放容器计划（OCI），因为 CRI-O 严格关注兼容 OCI 的运行时和容器镜像。
现在，CRI-O 支持 runc 和 Clear Container 运行时，尽管它应该支持任何遵循 OCI 的运行时。它可以从任何容器仓库中拉取镜像，并使用<ruby> <a href="https://github.com/containernetworking/cni"> 容器网络接口 </a> <rt> Container Network Interface </rt></ruby>（CNI）处理网络，以便任何兼容 CNI 的网络插件可与该项目一起使用。
当 Kubernetes 需要运行容器时，它会与 CRI-O 进行通信，CRI-O 守护程序与 runc（或另一个符合 OCI 标准的运行时）一起启动容器。当 Kubernetes 需要停止容器时，CRI-O 会来处理。这没什么令人兴奋的，它只是在幕后管理 Linux 容器，以便用户不需要担心这个关键的容器编排。
### CRI-O 不是什么
值得花一点时间了解下 CRI-O *不是*什么。CRI-O 的范围是与 Kubernetes 一起工作来管理和运行 OCI 容器。这不是一个面向开发人员的工具，尽管该项目确实有一些面向用户的工具进行故障排除。
例如，构建镜像超出了 CRI-O 的范围，这些留给像 Docker 的构建命令、 [Buildah](https://github.com/projectatomic/buildah) 或 [OpenShift 的 Source-to-Image](https://github.com/openshift/source-to-image)（S2I）这样的工具。一旦构建完镜像，CRI-O 将乐意运行它，但构建镜像留给其他工具。
虽然 CRI-O 包含命令行界面 （CLI），但它主要用于测试 CRI-O，而不是真正用于在生产环境中管理容器的方法。
### 下一步
现在 CRI-O 1.0 发布了，我们希望看到它作为一个稳定功能在下一个 Kubernetes 版本中发布。1.0 版本将与 Kubernetes 1.7.x 系列一起使用，即将发布的 CRI-O 1.8-rc1 适合 Kubernetes 1.8.x。
我们邀请您加入我们，以促进开源 CRI-O 项目的开发，并感谢我们目前的贡献者为达成这一里程碑而提供的帮助。如果你想贡献或者关注开发，就去 [CRI-O 项目的 GitHub 仓库](https://github.com/kubernetes-incubator/cri-o)，然后关注 [CRI-O 博客](https://medium.com/cri-o)。
---
via: <https://www.redhat.com/en/blog/introducing-cri-o-10>
作者：[Joe Brockmeier](https://www.redhat.com/en/blog/authors/joe-brockmeier) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：消沉的程序员 17
|
Daniel Stori
|
http://turnoff.us/geek/the-depressed-developer-17/
|
如果在写代码的人仅为可运行而编码，那么在后边会出现一系列的连锁反应，任何没有经过真构思之后书写的代码，都会带来巨大的维护成本吧。
|
/data/attachment/album/201711/01/083932jn41vvczvjkhwry1.png.thumb.jpg
|
/data/attachment/album/201711/01/083932jn41vvczvjkhwry1.png.large.jpg
| false
| false
| true
|
GHLandy
| false
|
[
"漫画",
"程序员"
] |
极客漫画
|
{
"viewnum": 12017,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "218.58.78.203",
"message": "是这样！",
"username": "绿色圣光 [Firefox 57.0|Windows 7]",
"date": "2017-11-01T16:31:18"
}
] |
[] |
如果在写代码的人仅为可运行而编码，那么在后边会出现一系列的连锁反应，任何没有经过真构思之后书写的代码，都会带来巨大的维护成本吧。
| 2017-11-01T08:39:28
| 2017-11-01T08:39:28
| 9,016
|
/article-9016-1.html
|
<ruby> 测试覆盖 <rp> （ </rp> <rt> Testing coverage </rt> <rp> ） </rp></ruby>，指测试系统覆盖被测试系统的程度，一项给定测试或一组测试对某个给定系统或构件的所有指定测试用例进行处理所达到的程度。 如果在写代码的人仅为可运行而编码，那么在后边会出现一系列的连锁反应，任何没有经过真构思之后书写的代码，都会带来巨大的维护成本吧。昨天 (2017.09.05) 刚刚读到一篇 为什么你的前段工作经验不值钱，不同的人对这里边的那个题的考虑程度是不同的。但我们在每次开始编码之前，都应该以 “代码可用 - 代码健壮 - 代码可靠 - 对需求的宽容” 为规格来约束自己。
---
译者简介：
[GHLandy](http://ghlandy.com/) —— 生活中所有欢乐与苦闷都应藏在心中，有些事儿注定无人知晓，自己也无从说起。
---
via: <http://turnoff.us/geek/the-depressed-developer-17/>
作者：[Daniel Stori](http://turnoff.us/about/) 译者：[GHLandy](https://github.com/GHLandy) 校对：[wxy](https://github.com/wxy) 合成：[GHLandy](https://github.com/GHLandy) 点评：[GHLandy](https://github.com/GHLandy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
对 DBA 最重要的 PostgreSQL 10 新亮点
|
Kaarel Moppel
|
http://www.cybertec.at/best-of-postgresql-10-for-the-dba/
|
像往常一样，已经有相当多的博客覆盖了所有新的东西，但我猜每个人都有自己认为重要的角度，所以与 9.6 版一样我再次在这里列出我印象中最有趣/相关的功能。
|
/data/attachment/album/201711/01/124522ywn9z22vvce11wf5.jpg.thumb.jpg
|
/data/attachment/album/201711/01/124522ywn9z22vvce11wf5.jpg
| true
| false
| true
|
geekpi
| false
|
[
"PostgreSQL",
"数据库"
] |
系统运维
|
{
"viewnum": 7405,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "113.137.58.77",
"message": "PostgreSQL 10 版本说明<br />\r\n <a href=\"https://www.rockdata.net/zh-cn/docs/10/release.html\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/10/release.html</a><br />\r\nPostgreSQL 11 版本说明<br />\r\n <a href=\"https://www.rockdata.net/zh-cn/docs/11/release.html\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/11/release.html</a><br />\r\nPostgreSQL 12 版本说明<br />\r\n <a href=\"https://www.rockdata.net/zh-cn/docs/12/release.html\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/12/release.html</a><br />\r\nPostgreSQL 13 版本说明<br />\r\n <a href=\"https://www.rockdata.net/zh-cn/docs/13/release.html\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/13/release.html</a><br />\r\nPostgreSQL 14 版本说明<br />\r\n <a href=\"https://www.rockdata.net/zh-cn/docs/14/release.html\" target=\"_blank\">https://www.rockdata.net/zh-cn/docs/14/release.html</a>",
"username": "来自陕西咸阳的 Chrome 114.0|Windows 10 用户",
"date": "2023-07-07T16:23:24"
}
] |
[] |
像往常一样，已经有相当多的博客覆盖了所有新的东西，但我猜每个人都有自己认为重要的角度，所以与 9.6 版一样我再次在这里列出我印象中最有趣/相关的功能。
| 2017-11-01T12:45:15
| 2017-11-01T12:45:15
| 9,019
|
/article-9019-1.html
|
前段时间新的重大版本的 PostgreSQL 10 发布了！ 强烈建议阅读[公告](https://www.postgresql.org/about/news/1786/)、[发布说明](https://www.postgresql.org/docs/current/static/release-10.html)和“[新功能](https://wiki.postgresql.org/wiki/New_in_postgres_10)”概述可以在[这里](https://www.postgresql.org/about/news/1786/)、[这里](https://www.postgresql.org/docs/current/static/release-10.html)和[这里](https://wiki.postgresql.org/wiki/New_in_postgres_10)。像往常一样，已经有相当多的博客覆盖了所有新的东西，但我猜每个人都有自己认为重要的角度，所以与 9.6 版一样我再次在这里列出我印象中最有趣/相关的功能。
与往常一样，升级或初始化一个新集群的用户将获得更好的性能（例如，更好的并行索引扫描、合并 join 和不相关的子查询，更快的聚合、远程服务器上更加智能的 join 和聚合），这些都开箱即用，但本文中我想讲一些不能开箱即用，实际上你需要采取一些步骤才能从中获益的内容。下面重点展示的功能是从 DBA 的角度来汇编的，很快也有一篇文章从开发者的角度讲述更改。
### 升级注意事项
首先有些从现有设置升级的提示 - 有一些小的事情会导致从 9.6 或更旧的版本迁移时引起问题，所以在真正的升级之前，一定要在单独的副本上测试升级，并遍历发行说明中所有可能的问题。最值得注意的缺陷是：
* 所有包含 “xlog” 的函数都被重命名为使用 “wal” 而不是 “xlog”。
后一个命名可能与正常的服务器日志混淆，因此这是一个“以防万一”的更改。如果使用任何第三方备份/复制/HA 工具，请检查它们是否为最新版本。
* 存放服务器日志（错误消息/警告等）的 pg\_log 文件夹已重命名为 “log”。
确保验证你的日志解析或 grep 脚本（如果有）可以工作。
* 默认情况下，查询将最多使用 2 个后台进程。
如果在 CPU 数量较少的机器上在 `postgresql.conf` 设置中使用默认值 `10`，则可能会看到资源使用率峰值，因为默认情况下并行处理已启用 - 这是一件好事，因为它应该意味着更快的查询。如果需要旧的行为，请将 `max_parallel_workers_per_gather` 设置为 `0`。
* 默认情况下，本地主机的复制连接已启用。
为了简化测试等工作，本地主机和本地 Unix 套接字复制连接现在在 `pg_hba.conf` 中以“<ruby> 信任 <rt> trust </rt></ruby>”模式启用（无密码）！因此，如果其他非 DBA 用户也可以访问真实的生产计算机，请确保更改配置。
### 从 DBA 的角度来看我的最爱
* 逻辑复制
这个期待已久的功能在你只想要复制一张单独的表、部分表或者所有表时只需要简单的设置而性能损失最小，这也意味着之后主要版本可以零停机升级！历史上（需要 Postgres 9.4+），这可以通过使用第三方扩展或缓慢的基于触发器的解决方案来实现。对我而言这是 10 最好的功能。
* 声明分区
以前管理分区的方法通过继承并创建触发器来把插入操作重新路由到正确的表中，这一点很烦人，更不用说性能的影响了。目前支持的是 “range” 和 “list” 分区方案。如果有人在某些数据库引擎中缺少 “哈希” 分区，则可以使用带表达式的 “list” 分区来实现相同的功能。
* 可用的哈希索引
哈希索引现在是 WAL 记录的，因此是崩溃安全的，并获得了一些性能改进，对于简单的搜索，它们比在更大的数据上的标准 B 树索引快。也支持更大的索引大小。
* 跨列优化器统计
这样的统计数据需要在一组表的列上手动创建，以指出这些值实际上是以某种方式相互依赖的。这将能够应对计划器认为返回的数据很少（概率的乘积通常会产生非常小的数字）从而导致在大量数据下性能不好的的慢查询问题（例如选择“嵌套循环” join）。
* 副本上的并行快照
现在可以在 pg\_dump 中使用多个进程（`-jobs` 标志）来极大地加快备用服务器上的备份。
* 更好地调整并行处理 worker 的行为
参考 `max_parallel_workers` 和 `min_parallel_table_scan_size`/`min_parallel_index_scan_size` 参数。我建议增加一点后两者的默认值（8MB、512KB）。
* 新的内置监控角色，便于工具使用
新的角色 `pg_monitor`、`pg_read_all_settings`、`pg_read_all_stats` 和 `pg_stat_scan_tables` 能更容易进行各种监控任务 - 以前必须使用超级用户帐户或一些 SECURITY DEFINER 包装函数。
* 用于更安全的副本生成的临时 (每个会话) 复制槽
* 用于检查 B 树索引的有效性的一个新的 Contrib 扩展
这两个智能检查发现结构不一致和页面级校验未覆盖的内容。希望不久的将来能更加深入。
* Psql 查询工具现在支持基本分支（`if`/`elif`/`else`）
例如下面的将启用具有特定版本分支（对 pg\_stat\* 视图等有不同列名）的单个维护/监视脚本，而不是许多版本特定的脚本。
```
SELECT :VERSION_NAME = '10.0' AS is_v10 \gset
\if :is_v10
SELECT 'yippee' AS msg;
\else
SELECT 'time to upgrade!' AS msg;
\endif
```
这次就这样了！当然有很多其他的东西没有列出，所以对于专职 DBA，我一定会建议你更全面地看发布记录。非常感谢那 300 多为这个版本做出贡献的人！
---
via: <http://www.cybertec.at/best-of-postgresql-10-for-the-dba/>
作者：[Kaarel Moppel](http://www.cybertec.at/author/kaarel-moppel/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
记不住 Linux 命令？这三个工具可以帮你
|
Jack Wallen
|
https://www.linux.com/learn/intro-to-linux/2017/10/3-tools-help-you-remember-linux-commands
|
在我的 Elementary OS 系统里，目录 /usr/bin 下有 2029 个可执行文件。尽管我只会用到其中的一小部分，我要怎么才能记住这一部分呢？
|
/data/attachment/album/201711/01/220118efre8ur8lenn2xfy.jpeg.thumb.jpg
|
/data/attachment/album/201711/01/220118efre8ur8lenn2xfy.jpeg
| true
| false
| true
|
zpl1025
| false
|
[
"Linux",
"命令",
"Fish",
"apropos"
] |
技术
|
{
"viewnum": 16510,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 6171,
"displayorder": 0
}
] |
在我的 Elementary OS 系统里，目录 /usr/bin 下有 2029 个可执行文件。尽管我只会用到其中的一小部分，我要怎么才能记住这一部分呢？
| 2017-11-01T22:02:26
| 2017-11-01T22:02:26
| 9,021
|
/article-9021-1.html
|
Linux 桌面从开始的简陋到现在走了很长的路。在我早期使用 Linux 的那段日子里，掌握命令行是最基本的 —— 即使是在桌面版。不过现在变了，很多人可能从没用过命令行。但对于 Linux 系统管理员来说，可不能这样。实际上，对于任何 Linux 管理员（不管是服务器还是桌面），命令行仍是必须的。从管理网络到系统安全，再到应用和系统设定 —— 没有什么工具比命令行更强大。
但是，实际上……你可以在 Linux 系统里找到*非常多*命令。比如只看 `/usr/bin` 目录，你就可以找到很多命令执行文件（你可以运行 `ls/usr/bin/ | wc -l` 看一下你的系统里这个目录下到底有多少命令）。当然，它们并不全是针对用户的执行文件，但是可以让你感受下 Linux 命令数量。在我的 Elementary OS 系统里，目录 `/usr/bin` 下有 2029 个可执行文件。尽管我只会用到其中的一小部分，我要怎么才能记住这一部分呢？
幸运的是，你可以使用一些工具和技巧，这样你就不用每天挣扎着去记忆这些命令了。我想和大家分享几个这样的小技巧，希望能让你们能稍微有效地使用命令行（顺便节省点脑力）。
我们从一个系统内置的工具开始介绍，然后再介绍两个可以安装的非常实用的程序。
### Bash 命令历史
不管你知不知道，Bash（最流行的 Linux shell）会保留你执行过的命令的历史。想实际操作下看看吗？有两种方式。打开终端窗口然后按向上方向键。你应该可以看到会有命令出现，一个接一个。一旦你找到了想用的命令，不用修改的话，可以直接按 Enter 键执行，或者修改后再按 Enter 键。
要重新执行（或修改一下再执行）之前运行过的命令，这是一个很好的方式。我经常用这个功能。它不仅仅让我不用去记忆一个命令的所有细节，而且可以不用一遍遍重复地输入同样的命令。
说到 Bash 的命令历史，如果你执行命令 `history`，你可以列出你过去执行过的命令列表（图 1）。
*图 1: 你能找到我敲的命令里的错误吗？*
你的 Bash 命令历史保存的历史命令的数量可以在 `~/.bashrc` 文件里设置。在这个文件里，你可以找到下面两行：
```
HISTSIZE=1000
HISTFILESIZE=2000
```
`HISTSIZE` 是命令历史列表里记录的命令的最大数量，而 `HISTFILESIZE` 是命令历史文件的最大行数。
显然，默认情况下，Bash 会记录你的 1000 条历史命令。这已经很多了。有时候，这也被认为是一个安全漏洞。如果你在意的话，你可以随意减小这个数值，在安全性和实用性之间平衡。如果你不希望 Bash 记录你的命令历史，可以将 `HISTSIZE` 设置为 `0`。
如果你修改了 `~/.bashrc` 文件，记得要登出后再重新登录（否则改动不会生效）。
### apropos
这是第一个我要介绍的工具，可以帮助你记忆 Linux 命令。apropos （意即“关于”）能够搜索 Linux 帮助文档来帮你找到你想要的命令。比如说，你不记得你用的发行版用的什么防火墙工具了。你可以输入 `apropos “firewall”` ，然后这个工具会返回相关的命令（图 2）。
*图 2: 你用的什么防火墙？*
再假如你需要一个操作目录的命令，但是完全不知道要用哪个呢？输入 `apropos “directory”` 就可以列出在帮助文档里包含了字符 “directory” 的所有命令（图 3）。
*图 3: 可以操作目录的工具有哪些呢？*
apropos 工具在几乎所有 Linux 发行版里都会默认安装。
### Fish
还有另一个能帮助你记忆命令的很好的工具。Fish 是 Linux/Unix/Mac OS 的一个命令行 shell，有一些很好用的功能。
* 自动推荐
* VGA 颜色
* 完美的脚本支持
* 基于网页的配置
* 帮助文档自动补全
* 语法高亮
* 以及更多
自动推荐功能让 fish 非常方便（特别是你想不起来一些命令的时候）。
你可能觉得挺好，但是 fish 没有被默认安装。对于 Ubuntu（以及它的衍生版），你可以用下面的命令安装：
```
sudo apt-add-repository ppa:fish-shell/release-2
sudo apt update
sudo apt install fish
```
对于类 CentOS 系统，可以这样安装 fish。用下面的命令增加仓库：
```
sudo -s
cd /etc/yum.repos.d/
wget http://download.opensuse.org/repositories/shells:fish:release:2/CentOS_7/shells:fish:release:2.repo
```
用下面的命令更新仓库：
```
yum repolist
yum update
```
然后用下面的命令安装 fish：
```
yum install fish
```
fish 用起来可能没你想象的那么直观。记住，fish 是一个 shell，所以在使用命令之前你得先登录进去。在你的终端里，运行命令 fish 然后你就会看到自己已经打开了一个新的 shell（图 4）。
*图 4: fish 的交互式 shell。*
在开始输入命令的时候，fish 会自动补齐命令。如果推荐的命令不是你想要的，按下键盘的 Tab 键可以浏览更多选择。如果正好是你想要的，按下键盘的向右键补齐命令，然后按下 Enter 执行。在用完 fish 后，输入 exit 来退出 shell。
Fish 还可以做更多事情，但是这里只介绍用来帮助你记住命令，自动推荐功能足够了。
### 保持学习
Linux 上有太多的命令了。但你也不用记住所有命令。多亏有 Bash 命令历史以及像 apropos 和 fish 这样的工具，你不用消耗太多记忆来回忆那些帮你完成任务的命令。
---
via: <https://www.linux.com/learn/intro-to-linux/2017/10/3-tools-help-you-remember-linux-commands>
作者：[JACK WALLEN](https://www.linux.com/users/jlwallen) 译者：[zpl1025](https://github.com/zpl1025) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
2017 年 Linux 的五大痛点
|
Jeremy Garcia
|
https://opensource.com/article/17/10/top-5-linux-painpoints
|
到目前为止，糟糕的文档是 Linux 用户最头痛的问题。这里还有一些其他常见的问题。
|
/data/attachment/album/201711/02/111724c408xrhrhsxppxzk.jpg.thumb.jpg
|
/data/attachment/album/201711/02/111724c408xrhrhsxppxzk.jpg
| true
| false
| true
|
geekpi
| false
|
[
"Linux",
"故障"
] |
观点
|
{
"viewnum": 5152,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 8185,
"displayorder": 0
}
] |
到目前为止，糟糕的文档是 Linux 用户最头痛的问题。这里还有一些其他常见的问题。
| 2017-11-02T11:17:00
| 2017-11-02T11:17:00
| 9,022
|
/article-9022-1.html
|
>
> 到目前为止，糟糕的文档是 Linux 用户最头痛的问题。这里还有一些其他常见的问题。
>
>
>
正如我在 [2016 年开源年鉴](https://opensource.com/yearbook/2016)的“[故障排除提示：5 个最常见的 Linux 问题](/article-8185-1.html)”中所讨论的，对大多数用户而言 Linux 能安装并按照预期运行，但有些不可避免地会遇到问题。过去一年在这方面有什么变化？又一次，我将问题提交给 LinuxQuestions.org 和社交媒体，并分析了 LQ 回复情况。以下是更新后的结果。
### 1、 文档
文档及其不足是今年最大的痛点之一。尽管开源的方式产生了优秀的代码，但是制作高质量文档的重要性在最近才走到了前列。随着越来越多的非技术用户采用 Linux 和开源软件，文档的质量和数量将变得至关重要。如果你想为开源项目做出贡献，但不觉得你有足够的技术来提供代码，那么改进文档是参与的好方法。许多项目甚至将文档保存在其仓库中，因此你可以使用你的贡献来适应版本控制的工作流。
### 2、 软件/库版本不兼容
我对此感到惊讶，但软件/库版本不兼容性屡被提及。如果你没有运行某个主流发行版，这个问题似乎更加严重。我个人*许多*年来没有遇到这个问题，但是越来越多的诸如 [AppImage](https://appimage.org/)、[Flatpak](http://flatpak.org/) 和 Snaps 等解决方案的采用让我相信可能确实存在这些情况。我有兴趣听到更多关于这个问题的信息。如果你最近遇到过，请在评论中告诉我。
### 3、 UEFI 和安全启动
尽管随着更多支持的硬件部署，这个问题在继续得到改善，但许多用户表示仍然存在 UEFI 和/或<ruby> 安全启动 <rt> secure boot </rt></ruby>问题。使用开箱即用完全支持 UEFI/安全启动的发行版是最好的解决方案。
### 4、 弃用 32 位
许多用户对他们最喜欢的发行版和软件项目中的 32 位支持感到失望。尽管如果 32 位支持是必须的，你仍然有很多选择，但可能会继续支持市场份额和心理份额不断下降的平台的项目越来越少。幸运的是，我们谈论的是开源，所以只要*有人*关心这个平台，你可能至少有几个选择。
### 5、 X 转发的支持和测试恶化
尽管 Linux 的许多长期和资深的用户经常使用 <ruby> X 转发 <rt> X-forwarding </rt></ruby>，并将其视为关键功能，但随着 Linux 变得越来越主流，它看起来很少得到测试和支持，特别是对较新的应用程序。随着 Wayland 网络透明转发的不断发展，情况可能会进一步恶化。
### 对比去年的遗留和改进
视频（特别是视频加速器、最新的显卡、专有驱动程序、高效的电源管理）、蓝牙支持、特定 WiFi 芯片和打印机以及电源管理以及挂起/恢复，对许多用户来说仍然是麻烦的。更积极的一点的是，安装、HiDPI 和音频问题比一年前显著降低。
Linux 继续取得巨大的进步，而持续的、几乎必然的改进周期将会确保持续数年。然而，与任何复杂的软件一样，总会有问题。
那么说，你在 2017 年发现 Linux 最常见的技术问题是什么？让我在评论中知道它们。
---
via: <https://opensource.com/article/17/10/top-5-linux-painpoints>
作者：[Jeremy Garcia](https://opensource.com/users/jeremy-garcia) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么要在 Docker 中使用 R？ 一位 DevOps 的看法
|
Jeroen Ooms
|
https://www.r-bloggers.com/why-use-docker-with-r-a-devops-perspective/
|
已经有几篇关于为什么要在 Docker 中使用 R 的文章。在这篇文章中，我将尝试加入一个 DevOps 的观点，并解释在 OpenCPU 系统的环境中如何使用容器化 R 来构建和部署 R 服务器。
|
/data/attachment/album/201711/02/143915tq6cdnzpqp1f8ktp.png.thumb.jpg
|
/data/attachment/album/201711/02/143915tq6cdnzpqp1f8ktp.png
| true
| false
| true
|
geekpi
| false
|
[
"Docker",
"OpenCPU"
] |
技术
|
{
"viewnum": 6828,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
已经有几篇关于为什么要在 Docker 中使用 R 的文章。在这篇文章中，我将尝试加入一个 DevOps 的观点，并解释在 OpenCPU 系统的环境中如何使用容器化 R 来构建和部署 R 服务器。
| 2017-11-04T10:38:00
| 2017-11-04T10:38:00
| 9,023
|
/article-9023-1.html
|
[](https://www.opencpu.org/posts/opencpu-with-docker)
>
> R 语言，一种自由软件编程语言与操作环境，主要用于统计分析、绘图、数据挖掘。R 内置多种统计学及数字分析功能。R 的另一强项是绘图功能，制图具有印刷的素质，也可加入数学符号。——引自维基百科。
>
>
>
已经有几篇关于为什么要在 Docker 中使用 R 的文章。在这篇文章中，我将尝试加入一个 DevOps 的观点，并解释在 OpenCPU 系统的环境中如何使用容器化 R 来构建和部署 R 服务器。
>
> 有在 [#rstats](https://twitter.com/hashtag/rstats?src=hash&ref_src=twsrc%5Etfw) 世界的人真正地写过*为什么*他们使用 Docker，而不是*如何*么？
>
>
> — Jenny Bryan (@JennyBryan) [September 29, 2017](https://twitter.com/JennyBryan/status/913785731998289920?ref_src=twsrc%5Etfw)
>
>
>
### 1：轻松开发
OpenCPU 系统的旗舰是 [OpenCPU 服务器](https://www.opencpu.org/download.html)：它是一个成熟且强大的 Linux 栈，用于在系统和应用程序中嵌入 R。因为 OpenCPU 是完全开源的，我们可以在 DockerHub 上构建和发布。可以使用以下命令启动一个可以立即使用的 OpenCPU 和 RStudio 的 Linux 服务器（使用端口 8004 或 80）：
```
docker run -t -p 8004:8004 opencpu/rstudio
```
现在只需在你的浏览器打开 http://localhost:8004/ocpu/ 和 http://localhost:8004/rstudio/ 即可！在 rstudio 中用用户 `opencpu`（密码：`opencpu`）登录来构建或安装应用程序。有关详细信息，请参阅[自述文件](https://hub.docker.com/r/opencpu/rstudio/)。
Docker 让开始使用 OpenCPU 变得简单。容器给你一个充分灵活的 Linux 机器，而无需在系统上安装任何东西。你可以通过 rstudio 服务器安装软件包或应用程序，也可以使用 `docker exec` 进入到正在运行的服务器的 root shell 中：
```
# Lookup the container ID
docker ps
# Drop a shell
docker exec -i -t eec1cdae3228 /bin/bash
```
你可以在服务器的 shell 中安装其他软件，自定义 apache2 的 httpd 配置（auth，代理等），调整 R 选项，通过预加载数据或包等来优化性能。
### 2： 通过 DockerHub 发布和部署
最强大的是，Docker 可以通过 DockerHub 发布和部署。要创建一个完全独立的应用程序容器，只需使用标准的 [opencpu 镜像](https://hub.docker.com/u/opencpu/)并添加你的程序。
出于本文的目的，我通过在每个仓库中添加一个非常简单的 “Dockerfile”，将一些[示例程序](https://www.opencpu.org/apps.html)打包为 docker 容器。例如：[nabel](https://rwebapps.ocpu.io/nabel/www/) 的 [Dockerfile](https://github.com/rwebapps/nabel/blob/master/Dockerfile) 包含以下内容：
```
FROM opencpu/base
RUN R -e 'devtools::install_github("rwebapps/nabel")'
```
它采用标准的 [opencpu/base](https://hub.docker.com/r/opencpu/base/) 镜像，并从 Github [仓库](https://github.com/rwebapps)安装 nabel。最终得到一个完全隔离、独立的程序。任何人可以使用下面这样的命令启动程序：
```
docker run -d 8004:8004 rwebapps/nabel
```
`-d` 代表守护进程监听 8004 端口。很显然，你可以调整 `Dockerfile` 来安装任何其它的软件或设置你需要的程序。
容器化部署展示了 Docker 的真正能力：它可以发布可以开箱即用的独立软件，而无需安装任何软件或依赖付费托管的服务。如果你更喜欢专业的托管，那会有许多公司乐意在可扩展的基础设施上为你托管 docker 程序。
### 3： 跨平台构建
还有 Docker 用于 OpenCPU 的第三种方式。每次发布，我们都构建 6 个操作系统的 `opencpu-server` 安装包，它们在 [https://archive.opencpu.org](https://archive.opencpu.org/) 上公布。这个过程已经使用 DockerHub 完全自动化了。以下镜像从源代码自动构建所有栈：
* [opencpu/ubuntu-16.04](https://hub.docker.com/r/opencpu/ubuntu-16.04/)
* [opencpu/debian-9](https://hub.docker.com/r/opencpu/debian-9/)
* [opencpu/fedora-25](https://hub.docker.com/r/opencpu/fedora-25/)
* [opencpu/fedora-26](https://hub.docker.com/r/opencpu/fedora-26/)
* [opencpu/centos-6](https://hub.docker.com/r/opencpu/centos-6/)
* [opencpu/centos-7](https://hub.docker.com/r/opencpu/centos-7/)
当 GitHub 上发布新版本时，DockerHub 会自动重建此镜像。要做的就是运行一个[脚本](https://github.com/opencpu/archive/blob/gh-pages/update.sh)，它会取回镜像并将 `opencpu-server` 二进制复制到[归档服务器上](https://archive.opencpu.org/)。
---
via: <https://www.r-bloggers.com/why-use-docker-with-r-a-devops-perspective/>
作者：[Jeroen Ooms](https://www.r-bloggers.com/author/jeroen-ooms/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
通过 Slack 监视慢 SQL 查询
|
Azer Koçulu
|
http://azer.bike/journal/monitoring-slow-sql-queries-via-slack/
|
一个获得关于慢查询、意外错误和其它重要日志通知的简单 Go 秘诀。
|
/data/attachment/album/201711/02/162453gvjdc1q41q08dqjp.jpg.thumb.jpg
|
/data/attachment/album/201711/02/162453gvjdc1q41q08dqjp.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"监控",
"Slack"
] |
技术
|
{
"viewnum": 6239,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一个获得关于慢查询、意外错误和其它重要日志通知的简单 Go 秘诀。
| 2017-11-02T16:24:00
| 2017-11-02T16:24:00
| 9,024
|
/article-9024-1.html
|
>
> 一个获得关于慢查询、意外错误和其它重要日志通知的简单 Go 秘诀。
>
>
>
我的 Slack 机器人提示我一个运行了很长时间 SQL 查询。我应该尽快解决它。
**我们不能管理我们无法去测量的东西。**每个后台应用程序都需要我们去监视它在数据库上的性能。如果一个特定的查询随着数据量增长变慢，你必须在它变得太慢之前去优化它。
由于 Slack 已经成为我们工作的中心，它也在改变我们监视系统的方式。 虽然我们已经有非常不错的监视工具，如果在系统中任何东西有正在恶化的趋势，让 Slack 机器人告诉我们，也是非常棒的主意。比如，一个太长时间才完成的 SQL 查询，或者，在一个特定的 Go 包中发生一个致命的错误。
在这篇博客文章中，我们将告诉你，通过使用已经支持这些特性的[一个简单的日志系统](http://azer.bike/journal/monitoring-slow-sql-queries-via-slack/?utm_source=dbweekly&utm_medium=email#logger) 和 [一个已存在的数据库库（database library）](http://azer.bike/journal/monitoring-slow-sql-queries-via-slack/?utm_source=dbweekly&utm_medium=email#crud) 怎么去设置来达到这个目的。
### 使用记录器
[logger](https://github.com/azer/logger) 是一个为 Go 库和应用程序使用设计的小型库。在这个例子中我们使用了它的三个重要的特性：
* 它为测量性能提供了一个简单的定时器。
* 支持复杂的输出过滤器，因此，你可以从指定的包中选择日志。例如，你可以告诉记录器仅从数据库包中输出，并且仅输出超过 500 ms 的定时器日志。
* 它有一个 Slack 钩子，因此，你可以过滤并将日志输入到 Slack。
让我们看一下在这个例子中，怎么去使用定时器，稍后我们也将去使用过滤器：
```
package main
import (
"github.com/azer/logger"
"time"
)
var (
users = logger.New("users")
database = logger.New("database")
)
func main () {
users.Info("Hi!")
timer := database.Timer()
time.Sleep(time.Millisecond * 250) // sleep 250ms
timer.End("Connected to database")
users.Error("Failed to create a new user.", logger.Attrs{
"e-mail": "foo@bar.com",
})
database.Info("Just a random log.")
fmt.Println("Bye.")
}
```
运行这个程序没有输出：
```
$ go run example-01.go
Bye
```
记录器是[缺省静默的](http://www.linfo.org/rule_of_silence.html)，因此，它可以在库的内部使用。我们简单地通过一个环境变量去查看日志：
例如：
```
$ LOG=database@timer go run example-01.go
01:08:54.997 database(250.095587ms): Connected to database.
Bye
```
上面的示例我们使用了 `database@timer` 过滤器去查看 `database` 包中输出的定时器日志。你也可以试一下其它的过滤器，比如：
* `LOG=*`: 所有日志
* `LOG=users@error,database`: 所有来自 `users` 的错误日志，所有来自 `database` 的所有日志
* `LOG=*@timer,database@info`: 来自所有包的定时器日志和错误日志，以及来自 `database` 的所有日志
* `LOG=*,users@mute`: 除了 `users` 之外的所有日志
### 发送日志到 Slack
控制台日志是用于开发环境的，但是我们需要产品提供一个友好的界面。感谢 [slack-hook](https://github.com/azer/logger-slack-hook)， 我们可以很容易地在上面的示例中，使用 Slack 去整合它：
```
import (
"github.com/azer/logger"
"github.com/azer/logger-slack-hook"
)
func init () {
logger.Hook(&slackhook.Writer{
WebHookURL: "https://hooks.slack.com/services/...",
Channel: "slow-queries",
Username: "Query Person",
Filter: func (log *logger.Log) bool {
return log.Package == "database" && log.Level == "TIMER" && log.Elapsed >= 200
}
})
}
```
我们来解释一下，在上面的示例中我们做了什么：
* 行 #5: 设置入站 webhook url。这个 URL [链接在这里](https://my.slack.com/services/new/incoming-webhook/)。
* 行 #6: 选择流日志的入口通道。
* 行 #7: 显示的发送者的用户名。
* 行 #11: 使用流过滤器，仅输出时间超过 200 ms 的定时器日志。
希望这个示例能给你提供一个大概的思路。如果你有更多的问题，去看这个 [记录器](https://github.com/azer/logger)的文档。
### 一个真实的示例： CRUD
[crud](https://github.com/azer/crud) 是一个用于 Go 的数据库的 ORM 式的类库，它有一个隐藏特性是内部日志系统使用 [logger](https://github.com/azer/logger) 。这可以让我们很容易地去监视正在运行的 SQL 查询。
#### 查询
这有一个通过给定的 e-mail 去返回用户名的简单查询：
```
func GetUserNameByEmail (email string) (string, error) {
var name string
if err := DB.Read(&name, "SELECT name FROM user WHERE email=?", email); err != nil {
return "", err
}
return name, nil
}
```
好吧，这个太短了， 感觉好像缺少了什么，让我们增加全部的上下文：
```
import (
"github.com/azer/crud"
_ "github.com/go-sql-driver/mysql"
"os"
)
var db *crud.DB
func main () {
var err error
DB, err = crud.Connect("mysql", os.Getenv("DATABASE_URL"))
if err != nil {
panic(err)
}
username, err := GetUserNameByEmail("foo@bar.com")
if err != nil {
panic(err)
}
fmt.Println("Your username is: ", username)
}
```
因此，我们有一个通过环境变量 `DATABASE_URL` 连接到 MySQL 数据库的 [crud](https://github.com/azer/crud) 实例。如果我们运行这个程序，将看到有一行输出：
```
$ DATABASE_URL=root:123456@/testdb go run example.go
Your username is: azer
```
正如我前面提到的，日志是 [缺省静默的](http://www.linfo.org/rule_of_silence.html)。让我们看一下 crud 的内部日志：
```
$ LOG=crud go run example.go
22:56:29.691 crud(0): SQL Query Executed: SELECT username FROM user WHERE email='foo@bar.com'
Your username is: azer
```
这很简单，并且足够我们去查看在我们的开发环境中查询是怎么执行的。
#### CRUD 和 Slack 整合
记录器是为配置管理应用程序级的“内部日志系统”而设计的。这意味着，你可以通过在你的应用程序级配置记录器，让 crud 的日志流入 Slack ：
```
import (
"github.com/azer/logger"
"github.com/azer/logger-slack-hook"
)
func init () {
logger.Hook(&slackhook.Writer{
WebHookURL: "https://hooks.slack.com/services/...",
Channel: "slow-queries",
Username: "Query Person",
Filter: func (log *logger.Log) bool {
return log.Package == "mysql" && log.Level == "TIMER" && log.Elapsed >= 250
}
})
}
```
在上面的代码中：
* 我们导入了 [logger](https://github.com/azer/logger) 和 [logger-slack-hook](https://github.com/azer/logger-slack-hook) 库。
* 我们配置记录器日志流入 Slack。这个配置覆盖了代码库中 [记录器](https://github.com/azer/logger) 所有的用法， 包括第三方依赖。
* 我们使用了流过滤器，仅输出 MySQL 包中超过 250 ms 的定时器日志。
这种使用方法可以被扩展，而不仅是慢查询报告。我个人使用它去跟踪指定包中的重要错误， 也用于统计一些类似新用户登入或生成支付的日志。
### 在这篇文章中提到的包
* [crud](https://github.com/azer/crud)
* [logger](https://github.com/azer/logger)
* [logger-slack-hook](https://github.com/azer/logger)
[告诉我们](https://twitter.com/afrikaradyo) 如果你有任何的问题或建议。
---
via: <http://azer.bike/journal/monitoring-slow-sql-queries-via-slack/>
作者：[Azer Koçulu](http://azer.bike/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我们的征程是星辰大海，迈向不可知的彼岸
|
老王
|
我们本着传播知识的初心，决定将内容反倾销到那些不可知、不存在的地方。毕竟，我们是要成为海贼王的男人嘛！ :D
|
/data/attachment/album/201711/02/172535ooq15su5zc8106cq.jpg.thumb.jpg
|
/data/attachment/album/201711/02/172535ooq15su5zc8106cq.jpg
| true
| false
| false
| false
|
[
"Linux中国"
] |
新闻
|
{
"viewnum": 4930,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
我们本着传播知识的初心，决定将内容反倾销到那些不可知、不存在的地方。毕竟，我们是要成为海贼王的男人嘛！ :D
| 2017-11-02T17:26:00
| 2017-11-02T17:26:00
| 9,025
|
/article-9025-1.html
|
Linux 中国以推广开源技术，传播开源文化为己任，因此，我们广泛地从互联网世界汲取各种有益的资讯，并组织了 LCTT 翻译了数千篇英文文章分享给中国的读者们。再次，这要感谢我们的志愿者们，几年来，勤勉地贡献了多少个人时间，留下的却是一再传播、令人受益的文章。
大家已经知道，我们除了官方主站（<https://linux.cn/>）之外，我们还有微信公众号、微博认证号、知乎机构号、网易号、今日头条号等等。而据说，互联网世界除了中国国内这些传播渠道之外，居然还有什么脸谱、推她、电报之类平台，因此，我们本着传播知识的初心，决定将内容反倾销到那些不可知、不存在的地方。毕竟，我们是要成为海贼王的男人嘛！ :D
言归正传，下面我来列出一下我们目前所有处于积极维护状态的内容输出平台，<ruby> 请诸君多撷取 <rp> （ </rp> <rt> 说人话：需要粉丝，求关注 </rt> <rp> ） </rp></ruby>：
| | | | | |
| --- | --- | --- | --- | --- |
| 平台 | Web | 客户端 | 地址或名称 | 备注 |
| *官方主站* | *√* | | <https://linux.cn/> | 所有“Linux 中国”发布内容的起源地 |
| *RSS* | | *√* | <https://linux.cn/rss.xml> | 比主站内容更新有延迟 |
| *微博认证号* | *√* | *√* | [Linux中国](https://weibo.com/linuxcn) | 不定时推送主站内容 |
| *微信公众号* | | *√* | Linux中国 | 主号，基本上每日同步更新主站内容 |
| Linux | 精华摘要号，1-2 周更新一次期间的重要文章 |
| Linux开源社区 | 每日一条技术文章 |
| *知乎机构号* | *√* | *√* | [Linux中国](https://www.zhihu.com/org/linuxzhong-guo/) | 不定时推送主站内容 |
| *今日头条号* | *√* | *√* | [Linux技术](http://www.toutiao.com/c/user/3357852467/) | 不定时推送主站内容 |
| [Linux中国](https://www.toutiao.com/c/user/52889878622/) | 不定时推送主站内容 |
| *网易号* | *√* | *√* | [Linux](http://dy.163.com/v2/article/detail/D282EJLD0511CPOJ.html) | 不定时推送主站内容 |
| **Facebook** | **√** | **√** | [Linux中国](https://www.facebook.com/linux.china/) | 同步推送主站内容 |
| **Twitter** | **√** | **√** | [Linux中国](https://twitter.com/linux_cn) | 同步推送主站内容 |
| **Telegram** | | **√** | [Linux中国](https://t.me/linuxdotcn) | 频道， 同步推送主站内容 |
| [Linux中国 粉丝群](https://t.me/linuxcngroup) | 群组， 同步推送主站内容 |
好了，不要问我怎么样到达那些不可知、不可测的地方，谁知道到底存在不存在呢？
|
||||
在 Linux 图形栈上运行 Android
|
Swapnil Bhartiya
|
https://www.linux.com/blog/event/elce/2017/10/running-android-top-linux-graphics-stack
|
你现在可以在常规的 Linux 图形栈之上运行 Android。以前并不能这样，根据 Collabora 的 Linux 图形栈贡献者和软件工程师 Robert Foss 的说法，这是非常强大的功能。
|
/data/attachment/album/201711/02/220630xq0q71hkh17qn1ij.jpg.thumb.jpg
|
/data/attachment/album/201711/02/220630xq0q71hkh17qn1ij.jpg
| true
| false
| true
|
geekpi
| false
|
[
"Android",
"图形"
] |
技术
|
{
"viewnum": 5832,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你现在可以在常规的 Linux 图形栈之上运行 Android。以前并不能这样，根据 Collabora 的 Linux 图形栈贡献者和软件工程师 Robert Foss 的说法，这是非常强大的功能。
| 2017-11-04T10:05:00
| 2017-11-04T10:05:00
| 9,027
|
/article-9027-1.html
|
你现在可以在常规的 Linux 图形栈之上运行 Android。以前并不能这样，根据 Collabora 的 Linux 图形栈贡献者和软件工程师 Robert Foss 的说法，这是非常强大的功能。在即将举行的[欧洲 Linux 嵌入式会议](http://events.linuxfoundation.org/events/embedded-linux-conference-europe)的讲话中，Foss 将会介绍这一领域的最新进展，并讨论这些变化如何让你可以利用内核中的新功能和改进。
在本文中，Foss 解释了更多内容，并提供了他的演讲的预览。
**Linux.com：你能告诉我们一些你谈论的图形栈吗？**
**Foss：** 传统的 Linux 图形系统（如 X11）大都没有使用<ruby> 平面图形 <rt> plane </rt></ruby>。但像 Android 和 Wayland 这样的现代图形系统可以充分利用它。
Android 在 HWComposer 中最成功实现了平面支持，其图形栈与通常的 Linux 桌面图形栈有所不同。在桌面上，典型的合成器只是使用 GPU 进行所有的合成，因为这是桌面上唯一有的东西。
大多数嵌入式和移动芯片都有为 Android 设计的专门的 2D 合成硬件。这是通过将显示的内容分成不同的图层，然后智能地将图层送到经过优化处理图层的硬件。这就可以释放 GPU 来处理你真正关心的事情，同时它让硬件更有效率地做最好一件事。
**Linux.com：当你说到 Android 时，你的意思是 Android 开源项目 （AOSP） 么？**
**Foss：** Android 开源项目（AOSP）是许多 Android 产品建立的基础，AOSP 和 Android 之间没有什么区别。
具体来说，我的工作已经在 AOSP 上完成，但没有什么可以阻止将此项工作加入到已经发货的 Android 产品中。
区别更多在于授权和满足 Google 对 Android 产品的要求，而不是代码。
**Linux.com： 谁想要运行它，为什么？有什么好处？**
**Foss：** AOSP 为你提供了大量免费的东西，例如针对可用性、低功耗和多样化硬件进行优化的软件栈。它比任何一家公司自行开发的更精致、更灵活, 而不需要投入大量资源。
作为制造商，它还为你提供了一个能够立即为你的平台开发的大量开发人员。
**Linux.com：有什么实际使用情况？**
\*\* Foss：\*\* 新的部分是在常规 Linux 图形栈上运行 Android 的能力。可以在主线/上游内核和驱动来做到这一点，让你可以利用内核中的新功能和改进，而不仅仅依赖于来自于你的供应商的大量分支的 BSP。
对于任何有合理标准的 Linux 支持的 GPU，你现在可以在上面运行 Android。以前并不能这样。而且这样做是非常强大的。
同样重要的是，它鼓励 GPU 设计者与上游的驱动一起工作。现在他们有一个简单的方法来提供适用于 Android 和 Linux 的驱动程序，而无需额外的努力。他们的成本将会降低，维护上游 GPU 驱动变得更有吸引力。
例如，我们希望看到主线内核支持高通 SOC，我们希望成为实现这一目标的一部分。
总而言之，这将有助于硬件生态系统获得更好的软件支持，软件生态系统有更多的硬件配合。
* 它改善了 SBC/开发板制造商的经济性：它们可以提供一个经过良好测试的栈，既可以在两者之间工作，而不必提供 “Linux 栈” 和 Android 栈。
* 它简化了驱动程序开发人员的工作，因为只有一个优化和支持目标。
* 它支持 Android 社区，因为在主线内核上运行的 Android 可以让他们分享上游的改进。
* 这有助于上游，因为我们获得了一个产品级质量的栈，这些栈已经在硬件设计师的帮助下进行了测试和开发。
以前，Mesa 被视为二等栈，但现在它是最新的（完全符合 Vulkan 1.0、OpenGL 4.6、OpenGL ES 3.2）另外还有性能和产品质量。
这意味着驱动开发人员可以参与 Mesa，相信他们正在分享他人的辛勤工作，并且还有一个很好的基础。
---
via: <https://www.linux.com/blog/event/elce/2017/10/running-android-top-linux-graphics-stack>
作者：[SWAPNIL BHARTIYA](https://www.linux.com/users/arnieswap) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
3 个简单、优秀的 Linux 网络监视器
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2017/10/3-simple-excellent-linux-network-monitors
|
用 iftop、Nethogs 和 vnstat 了解更多关于你的网络连接。
|
/data/attachment/album/201711/03/161319bf9oqn99gnggeggg.jpeg.thumb.jpg
|
/data/attachment/album/201711/03/161319bf9oqn99gnggeggg.jpeg
| true
| false
| true
|
geekpi
| false
|
[
"iftop",
"nethogs",
"vnstat"
] |
系统运维
|
{
"viewnum": 10115,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
用 iftop、Nethogs 和 vnstat 了解更多关于你的网络连接。
| 2017-11-03T16:14:00
| 2017-11-03T16:14:00
| 9,029
|
/article-9029-1.html
|
*用 iftop、Nethogs 和 vnstat 了解更多关于你的网络连接。*
你可以通过这三个 Linux 网络命令，了解有关你网络连接的大量信息。iftop 通过进程号跟踪网络连接，Nethogs 可以快速显示哪个在占用你的带宽，而 vnstat 作为一个很好的轻量级守护进程运行，可以随时随地记录你的使用情况。
### iftop
[iftop](http://www.ex-parrot.com/pdw/iftop/) 监听你指定的网络接口，并以 `top` 的形式展示连接。
这是一个很好的小工具，用于快速识别占用、测量速度，并保持网络流量的总体运行。看到我们使用了多少带宽是非常令人惊讶的，特别是对于我们这些还记得使用电话线、调制解调器、让人尖叫的 Kbit 速度和真实的实时波特率的老年人来说。我们很久以前就放弃了波特率，转而使用比特率。波特率测量信号变化，有时与比特率相同，但大多数情况下不是。
如果你只有一个网络接口，可以不带选项运行 `iftop`。`iftop` 需要 root 权限：
```
$ sudo iftop
```
当你有多个接口时，指定要监控的接口：
```
$ sudo iftop -i wlan0
```
就像 top 一样，你可以在运行时更改显示选项。
* `h` 切换帮助屏幕。
* `n` 切换名称解析。
* `s` 切换源主机显示，`d` 切换目标主机。
* `s` 切换端口号。
* `N` 切换端口解析。要全看到端口号，请关闭解析。
* `t` 切换文本界面。默认显示需要 ncurses。我认为文本显示更易于阅读和更好的组织（图1）。
* `p` 暂停显示。
* `q` 退出程序。
*图 1：文本显示是可读的和可组织的。*
当你切换显示选项时，`iftop` 会继续测量所有流量。你还可以选择要监控的单个主机。你需要主机的 IP 地址和网络掩码。我很好奇 Pandora 在我那可怜的带宽中占用了多少，所以我先用 `dig` 找到它们的 IP 地址：
```
$ dig A pandora.com
[...]
;; ANSWER SECTION:
pandora.com. 267 IN A 208.85.40.20
pandora.com. 267 IN A 208.85.40.50
```
网络掩码是什么？ [ipcalc](https://www.linux.com/learn/intro-to-linux/2017/8/how-calculate-network-addresses-ipcalc) 告诉我们：
```
$ ipcalc -b 208.85.40.20
Address: 208.85.40.20
Netmask: 255.255.255.0 = 24
Wildcard: 0.0.0.255
=>
Network: 208.85.40.0/24
```
现在将地址和网络掩码提供给 iftop：
```
$ sudo iftop -F 208.85.40.20/24 -i wlan0
```
这不是真的吗？我很惊讶地发现，我珍贵的带宽对于 Pandora 很宽裕，每小时使用大约使用 500Kb。而且，像大多数流媒体服务一样，Pandora 的流量也有峰值，其依赖于缓存来缓解阻塞。
你可以使用 `-G` 选项对 IPv6 地址执行相同操作。请参阅手册页了解 `iftop` 的其他功能，包括使用自定义配置文件定制默认选项，并应用自定义过滤器（请参阅 [PCAP-FILTER](http://www.tcpdump.org/manpages/pcap-filter.7.html) 作为过滤器参考）。
### Nethogs
当你想要快速了解谁占用了你的带宽时，Nethogs 是快速和容易的。以 root 身份运行，并指定要监听的接口。它显示了空闲的应用程序和进程号，以便如果你愿意的话，你可以杀死它：
```
$ sudo nethogs wlan0
NetHogs version 0.8.1
PID USER PROGRAM DEV SENT RECEIVED
7690 carla /usr/lib/firefox wlan0 12.494 556.580 KB/sec
5648 carla .../chromium-browser wlan0 0.052 0.038 KB/sec
TOTAL 12.546 556.618 KB/sec
```
Nethogs 选项很少：在 kb/s、kb、b 和 mb 之间循环；通过接收或发送的数据包进行排序；并调整刷新之间的延迟。请参阅 `man nethogs`，或者运行 `nethogs -h`。
### vnstat
[vnstat](http://humdi.net/vnstat/) 是最容易使用的网络数据收集器。它是轻量级的，不需要 root 权限。它作为守护进程运行，并记录你网络统计信息。`vnstat` 命令显示累计的数据：
```
$ vnstat -i wlan0
Database updated: Tue Oct 17 08:36:38 2017
wlan0 since 10/17/2017
rx: 45.27 MiB tx: 3.77 MiB total: 49.04 MiB
monthly
rx | tx | total | avg. rate
------------------------+-------------+-------------+---------------
Oct '17 45.27 MiB | 3.77 MiB | 49.04 MiB | 0.28 kbit/s
------------------------+-------------+-------------+---------------
estimated 85 MiB | 5 MiB | 90 MiB |
daily
rx | tx | total | avg. rate
------------------------+-------------+-------------+---------------
today 45.27 MiB | 3.77 MiB | 49.04 MiB | 12.96 kbit/s
------------------------+-------------+-------------+---------------
estimated 125 MiB | 8 MiB | 133 MiB |
```
它默认显示所有的网络接口。使用 `-i` 选项选择单个接口。以这种方式合并多个接口的数据：
```
$ vnstat -i wlan0+eth0+eth1
```
你可以通过以下几种方式过滤显示：
* `-h` 以小时显示统计数据。
* `-d` 以天数显示统计数据。
* `-w` 和 `-m` 按周和月显示统计数据。
* 使用 `-l` 选项查看实时更新。
此命令删除 wlan1 的数据库，并停止监控它：
```
$ vnstat -i wlan1 --delete
```
此命令为网络接口创建别名。此例使用 Ubuntu 16.04 中的一个奇怪的接口名称：
```
$ vnstat -u -i enp0s25 --nick eth0
```
默认情况下，vnstat 监视 eth0。你可以在 `/etc/vnstat.conf` 中更改此内容，或在主目录中创建自己的个人配置文件。请参见 `man vnstat` 以获得完整的参考。
你还可以安装 `vnstati` 创建简单的彩色图（图2）：
```
$ vnstati -s -i wlx7cdd90a0a1c2 -o vnstat.png
```
*图 2：你可以使用 vnstati 创建简单的彩色图表。*
有关完整选项，请参见 `man vnstati`。
---
via: <https://www.linux.com/learn/intro-to-linux/2017/10/3-simple-excellent-linux-network-monitors>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
三种 Python 网络内容抓取工具与爬虫
|
Jason Baker
|
https://opensource.com/resources/python/web-scraper-crawler
|
运用这些很棒的 Python 爬虫工具来获取你需要的数据。
|
/data/attachment/album/201711/03/214537at1dsdt1tmoddaf2.png.thumb.jpg
|
/data/attachment/album/201711/03/214537at1dsdt1tmoddaf2.png
| true
| false
| true
|
ZH1122
| false
|
[
"Python",
"爬虫"
] |
软件开发
|
{
"viewnum": 9879,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
运用这些很棒的 Python 爬虫工具来获取你需要的数据。
| 2017-11-03T21:45:33
| 2017-11-03T21:45:33
| 9,030
|
/article-9030-1.html
|
>
> 运用这些很棒的 Python 爬虫工具来获取你需要的数据。
>
>
>
在一个理想的世界里，你需要的所有数据都将以公开而文档完备的格式清晰地展现，你可以轻松地下载并在任何你需要的地方使用。
然而，在真实世界里，数据是凌乱的，极少被打包成你需要的样子，要么经常是过期的。
你所需要的信息经常是潜藏在一个网站里。相比一些清晰地、有调理地呈现数据的网站，更多的网站则不是这样的。<ruby> <a href="https://en.wikipedia.org/wiki/Web_crawler"> 爬取数据 </a> <rt> crawling </rt></ruby>、<ruby> <a href="https://en.wikipedia.org/wiki/Web_scraping"> 挖掘数据 </a> <rt> scraping </rt></ruby>、加工数据、整理数据这些是获取整个网站结构来绘制网站拓扑来收集数据所必须的活动，这些可以是以网站的格式储存的或者是储存在一个专有数据库中。
也许在不久的将来，你需要通过爬取和挖掘来获得一些你需要的数据，当然你几乎肯定需要进行一点点的编程来正确的获取。你要怎么做取决于你自己，但是我发现 Python 社区是一个很好的提供者，它提供了工具、框架以及文档来帮助你从网站上获取数据。
在我们进行之前，这里有一个小小的请求：在你做事情之前请思考，以及请耐心。抓取这件事情并不简单。不要把网站爬下来只是复制一遍，并其它人的工作当成是你自己的东西（当然，没有许可）。要注意版权和许可，以及你所爬行的内容应用哪一个标准。尊重 [robots.txt](http://www.robotstxt.org/) 文件。不要频繁的针对一个网站，这将导致真实的访问者会遇到访问困难的问题。
在知晓这些警告之后，这里有一些很棒的 Python 网站爬虫工具，你可以用来获得你需要的数据。
### Pyspider
让我们先从 [pyspider](https://github.com/binux/pyspider) 开始介绍。这是一个带有 web 界面的网络爬虫，让与使之容易跟踪多个爬虫。其具有扩展性，支持多个后端数据库和消息队列。它还具有一些方便的特性，从优先级到再次访问抓取失败的页面，此外还有通过时间顺序来爬取和其他的一些特性。Pyspider 同时支持 Python 2 和 Python 3。为了实现一个更快的爬取，你可以在分布式的环境下一次使用多个爬虫进行爬取。
Pyspyder 的基本用法都有良好的 [文档说明](http://docs.pyspider.org/en/latest/) ，包括简单的代码片段。你能通过查看一个 [在线的样例](http://demo.pyspider.org/) 来体验用户界面。它在 Apache 2 许可证下开源，Pyspyder 仍然在 GitHub 上积极地开发。
### MechanicalSoup
[MechanicalSoup](https://github.com/hickford/MechanicalSoup) 是一个基于极其流行而异常多能的 HTML 解析库 [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) 建立的爬虫库。如果你的爬虫需要相当的简单，但是又要求检查一些选择框或者输入一些文字，而你又不想为这个任务单独写一个爬虫，那么这会是一个值得考虑的选择。
MechanicalSoup 在 MIT 许可证下开源。查看 GitHub 上该项目的 [example.py](https://github.com/hickford/MechanicalSoup/blob/master/example.py) 样例文件来获得更多的用法。不幸的是，到目前为止，这个项目还没有一个很好的文档。
### Scrapy
[Scrapy](https://scrapy.org/) 是一个有着活跃社区支持的抓取框架，在那里你可以建造自己的抓取工具。除了爬取和解析工具，它还能将它收集的数据以 JSON 或者 CSV 之类的格式轻松输出，并存储在一个你选择的后端数据库。它还有许多内置的任务扩展，例如 cookie 处理、代理欺骗、限制爬取深度等等，同时还可以建立你自己附加的 API。
要了解 Scrapy，你可以查看[网上的文档](https://doc.scrapy.org/en/latest/)或者是访问它诸多的[社区](https://scrapy.org/community/)资源，包括一个 IRC 频道、Reddit 子版块以及关注他们的 StackOverflow 标签。Scrapy 的代码在 3 句版 BSD 许可证下开源，你可以在 [GitHub](https://github.com/scrapy/scrapy) 上找到它们。
如果你完全不熟悉编程，[Portia](https://github.com/scrapinghub/portia) 提供了一个易用的可视化的界面。[scrapinghub.com](https://portia.scrapinghub.com/) 则提供一个托管的版本。
### 其它
* [Cola](https://github.com/chineking/cola) 自称它是个“高级的分布式爬取框架”，如果你在寻找一个 Python 2 的方案，这也许会符合你的需要，但是注意它已经有超过两年没有更新了。
* [Demiurge](https://github.com/matiasb/demiurge) 是另一个可以考虑的潜在候选者，它同时支持 Python 2和 Python 3，虽然这个项目的发展较为缓慢。
* 如果你要解析一些 RSS 和 Atom 数据，[Feedparser](https://github.com/kurtmckee/feedparser) 或许是一个有用的项目。
* [Lassie](https://github.com/michaelhelmick/lassie) 让从网站检索像说明、标题、关键词或者是图片一类的基本内容变得简单。
* [RoboBrowser](https://github.com/jmcarp/robobrowser) 是另一个简单的库，它基于 Python 2 或者 Python 3，它具有按钮点击和表格填充的基本功能。虽然它有一段时间没有更新了，但是它仍然是一个不错的选择。
---
这远不是一个完整的列表，当然，如果你是一个编程专家，你可以选择采取你自己的方法而不是使用这些框架中的一个。或者你发现一个用其他语言编写的替代品。例如 Python 编程者可能更喜欢 [Python 附带的](https://selenium-python.readthedocs.io/) [Selenium](https://github.com/SeleniumHQ/selenium)，它可以在不使用实际浏览器的情况下进行爬取。如果你有喜欢的爬取和挖掘工具，请在下面评论让我们知道。
（题图：[You as a Machine](https://www.flickr.com/photos/youasamachine/8025582590/in/photolist-decd6C-7pkccp-aBfN9m-8NEffu-3JDbWb-aqf5Tx-7Z9MTZ-rnYTRu-3MeuPx-3yYwA9-6bSLvd-irmvxW-5Asr4h-hdkfCA-gkjaSQ-azcgct-gdV5i4-8yWxCA-9G1qDn-5tousu-71V8U2-73D4PA-iWcrTB-dDrya8-7GPuxe-5pNb1C-qmnLwy-oTxwDW-3bFhjL-f5Zn5u-8Fjrua-bxcdE4-ddug5N-d78G4W-gsYrFA-ocrBbw-pbJJ5d-682rVJ-7q8CbF-7n7gDU-pdfgkJ-92QMx2-aAmM2y-9bAGK1-dcakkn-8rfyTz-aKuYvX-hqWSNP-9FKMkg-dyRPkY). Modified by Rikki Endsley. [CC BY-SA 2.0](https://creativecommons.org/licenses/by/2.0/)）
---
via: <https://opensource.com/resources/python/web-scraper-crawler>
作者：[Jason Baker](https://opensource.com/users/jason-baker) 译者：[ZH1122](https://github.com/ZH1122) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Apache Kafka 中通过 KSQL 分析 Twitter 数据
|
Robin Moffatt
|
https://www.confluent.io/blog/using-ksql-to-analyse-query-and-transform-data-in-kafka
|
KSQL 是 Apache Kafka 中的开源的流式 SQL 引擎。它可以让你在 Kafka 主题topic上，使用一个简单的并且是交互式的 SQL 接口，很容易地做一些复杂的流处理。
|
/data/attachment/album/201711/03/230240ei0izdx0ldzlviyl.jpg.thumb.jpg
|
/data/attachment/album/201711/03/230240ei0izdx0ldzlviyl.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"Twitter",
"大数据",
"Kafka"
] |
技术
|
{
"viewnum": 9234,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
KSQL 是 Apache Kafka 中的开源的流式 SQL 引擎。它可以让你在 Kafka 主题topic上，使用一个简单的并且是交互式的 SQL 接口，很容易地做一些复杂的流处理。
| 2017-11-03T23:03:00
| 2017-11-03T23:03:00
| 9,031
|
/article-9031-1.html
|
### 介绍
[KSQL](https://github.com/confluentinc/ksql/) 是 Apache Kafka 中的开源的流式 SQL 引擎。它可以让你在 Kafka <ruby> 主题 <rt> topic </rt></ruby>上，使用一个简单的并且是交互式的 SQL 接口，很容易地做一些复杂的流处理。在这个短文中，我们将看到如何轻松地配置并运行在一个沙箱中去探索它，并使用大家都喜欢的演示数据库源： Twitter。我们将从推文的原始流中获取，通过使用 KSQL 中的条件去过滤它，来构建一个聚合，如统计每个用户每小时的推文数量。
### Confluent
首先， [获取一个 Confluent 平台的副本](https://www.confluent.io/download/)。我使用的是 RPM 包，但是，如果你需要的话，你也可以使用 [tar、 zip 等等](https://docs.confluent.io/current/installation.html?) 。启动 Confluent 系统：
```
$ confluent start
```
（如果你感兴趣，这里有一个 [Confluent 命令行的快速教程](https://www.youtube.com/watch?v=ZKqBptBHZTg)）
我们将使用 Kafka Connect 从 Twitter 上拉取数据。 这个 Twitter 连接器可以在 [GitHub](https://github.com/jcustenborder/kafka-connect-twitter) 上找到。要安装它，像下面这样操作：
```
# Clone the git repo
cd /home/rmoff
git clone https://github.com/jcustenborder/kafka-connect-twitter.git
```
```
# Compile the code
cd kafka-connect-twitter
mvn clean package
```
要让 Kafka Connect 去使用我们构建的[连接器](https://docs.confluent.io/current/connect/userguide.html#connect-installing-plugins)， 你要去修改配置文件。因为我们使用 Confluent 命令行，真实的配置文件是在 `etc/schema-registry/connect-avro-distributed.properties`，因此去修改它并增加如下内容：
```
plugin.path=/home/rmoff/kafka-connect-twitter/target/kafka-connect-twitter-0.2-SNAPSHOT.tar.gz
```
重启动 Kafka Connect：
```
confluent stop connect
confluent start connect
```
一旦你安装好插件，你可以很容易地去配置它。你可以直接使用 Kafka Connect 的 REST API ，或者创建你的配置文件，这就是我要在这里做的。如果你需要全部的方法，请首先访问 Twitter 来获取你的 [API 密钥](https://apps.twitter.com/)。
```
{
"name": "twitter_source_json_01",
"config": {
"connector.class": "com.github.jcustenborder.kafka.connect.twitter.TwitterSourceConnector",
"twitter.oauth.accessToken": "xxxx",
"twitter.oauth.consumerSecret": "xxxxx",
"twitter.oauth.consumerKey": "xxxx",
"twitter.oauth.accessTokenSecret": "xxxxx",
"kafka.delete.topic": "twitter_deletes_json_01",
"value.converter": "org.apache.kafka.connect.json.JsonConverter",
"key.converter": "org.apache.kafka.connect.json.JsonConverter",
"value.converter.schemas.enable": false,
"key.converter.schemas.enable": false,
"kafka.status.topic": "twitter_json_01",
"process.deletes": true,
"filter.keywords": "rickastley,kafka,ksql,rmoff"
}
}
```
假设你写这些到 `/home/rmoff/twitter-source.json`，你可以现在运行：
```
$ confluent load twitter_source -d /home/rmoff/twitter-source.json
```
然后推文就从大家都喜欢的网络明星 [rick] 滚滚而来……
```
$ kafka-console-consumer --bootstrap-server localhost:9092 --from-beginning --topic twitter_json_01|jq '.Text'
{
"string": "RT @rickastley: 30 years ago today I said I was Never Gonna Give You Up. I am a man of my word - Rick x https://t.co/VmbMQA6tQB"
}
{
"string": "RT @mariteg10: @rickastley @Carfestevent Wonderful Rick!!\nDo not forget Chile!!\nWe hope you get back someday!!\nHappy weekend for you!!\n❤…"
}
```
### KSQL
现在我们从 KSQL 开始 ! 马上去下载并构建它：
```
cd /home/rmoff
git clone https://github.com/confluentinc/ksql.git
cd /home/rmoff/ksql
mvn clean compile install -DskipTests
```
构建完成后，让我们来运行它：
```
./bin/ksql-cli local --bootstrap-server localhost:9092
```
```
======================================
= _ __ _____ ____ _ =
= | |/ // ____|/ __ \| | =
= | ' /| (___ | | | | | =
= | < \___ \| | | | | =
= | . \ ____) | |__| | |____ =
= |_|\_\_____/ \___\_\______| =
= =
= Streaming SQL Engine for Kafka =
Copyright 2017 Confluent Inc.
CLI v0.1, Server v0.1 located at http://localhost:9098
Having trouble? Type 'help' (case-insensitive) for a rundown of how things work!
ksql>
```
使用 KSQL， 我们可以让我们的数据保留在 Kafka 主题上并可以查询它。首先，我们需要去告诉 KSQL 主题上的<ruby> 数据模式 <rt> schema </rt></ruby>是什么，一个 twitter 消息实际上是一个非常巨大的 JSON 对象， 但是，为了简洁，我们只选出其中几行：
```
ksql> CREATE STREAM twitter_raw (CreatedAt BIGINT, Id BIGINT, Text VARCHAR) WITH (KAFKA_TOPIC='twitter_json_01', VALUE_FORMAT='JSON');
Message
----------------
Stream created
```
在定义的模式中，我们可以查询这些流。要让 KSQL 从该主题的开始展示数据（而不是默认的当前时间点），运行如下命令：
```
ksql> SET 'auto.offset.reset' = 'earliest';
Successfully changed local property 'auto.offset.reset' from 'null' to 'earliest'
```
现在，让我们看看这些数据，我们将使用 LIMIT 从句仅检索一行：
```
ksql> SELECT text FROM twitter_raw LIMIT 1;
RT @rickastley: 30 years ago today I said I was Never Gonna Give You Up. I am a man of my word - Rick x https://t.co/VmbMQA6tQB
LIMIT reached for the partition.
Query terminated
ksql>
```
现在，让我们使用刚刚定义和可用的推文内容的全部数据重新定义该流：
```
ksql> DROP stream twitter_raw;
Message
--------------------------------
Source TWITTER_RAW was dropped
ksql> CREATE STREAM twitter_raw (CreatedAt bigint,Id bigint, Text VARCHAR, SOURCE VARCHAR, Truncated VARCHAR, InReplyToStatusId VARCHAR, InReplyToUserId VARCHAR, InReplyToScreenName VARCHAR, GeoLocation VARCHAR, Place VARCHAR, Favorited VARCHAR, Retweeted VARCHAR, FavoriteCount VARCHAR, User VARCHAR, Retweet VARCHAR, Contributors VARCHAR, RetweetCount VARCHAR, RetweetedByMe VARCHAR, CurrentUserRetweetId VARCHAR, PossiblySensitive VARCHAR, Lang VARCHAR, WithheldInCountries VARCHAR, HashtagEntities VARCHAR, UserMentionEntities VARCHAR, MediaEntities VARCHAR, SymbolEntities VARCHAR, URLEntities VARCHAR) WITH (KAFKA_TOPIC='twitter_json_01',VALUE_FORMAT='JSON');
Message
----------------
Stream created
ksql>
```
现在，我们可以操作和检查更多的最近的数据，使用一般的 SQL 查询：
```
ksql> SELECT TIMESTAMPTOSTRING(CreatedAt, 'yyyy-MM-dd HH:mm:ss.SSS') AS CreatedAt,\
EXTRACTJSONFIELD(user,'$.ScreenName') as ScreenName,Text \
FROM twitter_raw \
WHERE LCASE(hashtagentities) LIKE '%oow%' OR \
LCASE(hashtagentities) LIKE '%ksql%';
2017-09-29 13:59:58.000 | rmoff | Looking forward to talking all about @apachekafka & @confluentinc’s #KSQL at #OOW17 on Sunday 13:45 https://t.co/XbM4eIuzeG
```
注意这里没有 LIMIT 从句，因此，你将在屏幕上看到 “continuous query” 的结果。不像关系型数据表中返回一个确定数量结果的查询，一个持续查询会运行在无限的流式数据上， 因此，它总是可能返回更多的记录。点击 Ctrl-C 去中断然后返回到 KSQL 提示符。在以上的查询中我们做了一些事情：
* **TIMESTAMPTOSTRING** 将时间戳从 epoch 格式转换到人类可读格式。（LCTT 译注： epoch 指的是一个特定的时间 1970-01-01 00:00:00 UTC）
* **EXTRACTJSONFIELD** 来展示数据源中嵌套的用户域中的一个字段，它看起来像：
```
{
"CreatedAt": 1506570308000,
"Text": "RT @gwenshap: This is the best thing since partitioned bread :) https://t.co/1wbv3KwRM6",
[...]
"User": {
"Id": 82564066,
"Name": "Robin Moffatt \uD83C\uDF7B\uD83C\uDFC3\uD83E\uDD53",
"ScreenName": "rmoff",
[...]
```
* 应用断言去展示内容，对 #（hashtag）使用模式匹配， 使用 LCASE 去强制小写字母。（LCTT 译注：hashtag 是twitter 中用来标注线索主题的标签）
关于支持的函数列表，请查看 [KSQL 文档](https://github.com/confluentinc/ksql/blob/0.1.x/docs/syntax-reference.md)。
我们可以创建一个从这个数据中得到的流：
```
ksql> CREATE STREAM twitter AS \
SELECT TIMESTAMPTOSTRING(CreatedAt, 'yyyy-MM-dd HH:mm:ss.SSS') AS CreatedAt,\
EXTRACTJSONFIELD(user,'$.Name') AS user_Name,\
EXTRACTJSONFIELD(user,'$.ScreenName') AS user_ScreenName,\
EXTRACTJSONFIELD(user,'$.Location') AS user_Location,\
EXTRACTJSONFIELD(user,'$.Description') AS user_Description,\
Text,hashtagentities,lang \
FROM twitter_raw ;
Message
----------------------------
Stream created and running
ksql> DESCRIBE twitter;
Field | Type
------------------------------------
ROWTIME | BIGINT
ROWKEY | VARCHAR(STRING)
CREATEDAT | VARCHAR(STRING)
USER_NAME | VARCHAR(STRING)
USER_SCREENNAME | VARCHAR(STRING)
USER_LOCATION | VARCHAR(STRING)
USER_DESCRIPTION | VARCHAR(STRING)
TEXT | VARCHAR(STRING)
HASHTAGENTITIES | VARCHAR(STRING)
LANG | VARCHAR(STRING)
ksql>
```
并且查询这个得到的流：
```
ksql> SELECT CREATEDAT, USER_NAME, TEXT \
FROM TWITTER \
WHERE TEXT LIKE '%KSQL%';
2017-10-03 23:39:37.000 | Nicola Ferraro | RT @flashdba: Again, I'm really taken with the possibilities opened up by @confluentinc's KSQL engine #Kafka https://t.co/aljnScgvvs
```
### 聚合
在我们结束之前，让我们去看一下怎么去做一些聚合。
```
ksql> SELECT user_screenname, COUNT(*) \
FROM twitter WINDOW TUMBLING (SIZE 1 HOUR) \
GROUP BY user_screenname HAVING COUNT(*) > 1;
oracleace | 2
rojulman | 2
smokeinpublic | 2
ArtFlowMe | 2
[...]
```
你将可能得到满屏幕的结果；这是因为 KSQL 在每次给定的时间窗口更新时实际发出聚合值。因为我们设置 KSQL 去读取在主题上的全部消息（`SET 'auto.offset.reset' = 'earliest';`），它是一次性读取这些所有的消息并计算聚合更新。这里有一个微妙之处值得去深入研究。我们的入站推文流正好就是一个流。但是，现有它不能创建聚合，我们实际上是创建了一个表。一个表是在给定时间点的给定键的值的一个快照。 KSQL 聚合数据基于消息的事件时间，并且如果它更新了，通过简单的相关窗口重申去操作后面到达的数据。困惑了吗？ 我希望没有，但是，让我们看一下，如果我们可以用这个例子去说明。 我们将申明我们的聚合作为一个真实的表：
```
ksql> CREATE TABLE user_tweet_count AS \
SELECT user_screenname, count(*) AS tweet_count \
FROM twitter WINDOW TUMBLING (SIZE 1 HOUR) \
GROUP BY user_screenname ;
Message
---------------------------
Table created and running
```
看表中的列，这里除了我们要求的外，还有两个隐含列：
```
ksql> DESCRIBE user_tweet_count;
Field | Type
-----------------------------------
ROWTIME | BIGINT
ROWKEY | VARCHAR(STRING)
USER_SCREENNAME | VARCHAR(STRING)
TWEET_COUNT | BIGINT
ksql>
```
我们看一下这些是什么：
```
ksql> SELECT TIMESTAMPTOSTRING(ROWTIME, 'yyyy-MM-dd HH:mm:ss.SSS') , \
ROWKEY, USER_SCREENNAME, TWEET_COUNT \
FROM user_tweet_count \
WHERE USER_SCREENNAME= 'rmoff';
2017-09-29 11:00:00.000 | rmoff : Window{start=1506708000000 end=-} | rmoff | 2
2017-09-29 12:00:00.000 | rmoff : Window{start=1506711600000 end=-} | rmoff | 4
2017-09-28 22:00:00.000 | rmoff : Window{start=1506661200000 end=-} | rmoff | 2
2017-09-29 09:00:00.000 | rmoff : Window{start=1506700800000 end=-} | rmoff | 4
2017-09-29 15:00:00.000 | rmoff : Window{start=1506722400000 end=-} | rmoff | 2
2017-09-29 13:00:00.000 | rmoff : Window{start=1506715200000 end=-} | rmoff | 6
```
`ROWTIME` 是窗口开始时间， `ROWKEY` 是 `GROUP BY`（`USER_SCREENNAME`）加上窗口的组合。因此，我们可以通过创建另外一个衍生的表来整理一下：
```
ksql> CREATE TABLE USER_TWEET_COUNT_DISPLAY AS \
SELECT TIMESTAMPTOSTRING(ROWTIME, 'yyyy-MM-dd HH:mm:ss.SSS') AS WINDOW_START ,\
USER_SCREENNAME, TWEET_COUNT \
FROM user_tweet_count;
Message
---------------------------
Table created and running
```
现在它更易于查询和查看我们感兴趣的数据：
```
ksql> SELECT WINDOW_START , USER_SCREENNAME, TWEET_COUNT \
FROM USER_TWEET_COUNT_DISPLAY WHERE TWEET_COUNT> 20;
2017-09-29 12:00:00.000 | VikasAatOracle | 22
2017-09-28 14:00:00.000 | Throne_ie | 50
2017-09-28 14:00:00.000 | pikipiki_net | 22
2017-09-29 09:00:00.000 | johanlouwers | 22
2017-09-28 09:00:00.000 | yvrk1973 | 24
2017-09-28 13:00:00.000 | cmosoares | 22
2017-09-29 11:00:00.000 | ypoirier | 24
2017-09-28 14:00:00.000 | pikisec | 22
2017-09-29 07:00:00.000 | Throne_ie | 22
2017-09-29 09:00:00.000 | ChrisVoyance | 24
2017-09-28 11:00:00.000 | ChrisVoyance | 28
```
### 结论
所以我们有了它！ 我们可以从 Kafka 中取得数据， 并且很容易使用 KSQL 去探索它。 而不仅是去浏览和转换数据，我们可以很容易地使用 KSQL 从流和表中建立流处理。
如果你对 KSQL 能够做什么感兴趣，去查看：
* [KSQL 公告](https://www.confluent.io/blog/ksql-open-source-streaming-sql-for-apache-kafka/)
* [我们最近的 KSQL 在线研讨会](https://www.confluent.io/online-talk/ksql-streaming-sql-for-apache-kafka/) 和 [Kafka 峰会讲演](https://www.confluent.io/kafka-summit-sf17/Databases-and-Stream-Processing-1)
* [clickstream 演示](https://www.youtube.com/watch?v=A45uRzJiv7I)，它是 [KSQL 的 GitHub 仓库](https://github.com/confluentinc/ksql) 的一部分
* [我最近做的演讲](https://speakerdeck.com/rmoff/look-ma-no-code-building-streaming-data-pipelines-with-apache-kafka) 展示了 KSQL 如何去支持基于流的 ETL 平台
记住，KSQL 现在正处于开发者预览阶段。 欢迎在 KSQL 的 GitHub 仓库上提出任何问题， 或者去我们的 [community Slack group](https://slackpass.io/confluentcommunity) 的 #KSQL 频道。
---
via: <https://www.confluent.io/blog/using-ksql-to-analyse-query-and-transform-data-in-kafka>
作者：[Robin Moffatt](https://www.confluent.io/blog/author/robin/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开发者，原来你最讨厌的编程语言和技术是……
|
David Robinson
|
https://stackoverflow.blog/2017/10/31/disliked-programming-languages/
|
原来 Perl、PHP 已经到了这个地步……
|
/data/attachment/album/201711/05/100744xl8tk2bmz811b6z1.png.thumb.jpg
|
/data/attachment/album/201711/05/100744xl8tk2bmz811b6z1.png
| true
| false
| true
|
wxy
| false
|
[
"编程语言",
"开发者"
] |
观点
|
{
"viewnum": 7007,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "101.68.66.194",
"message": "引战贴",
"username": "来自浙江杭州的 Chrome 73.0|Mac 10.14 用户",
"date": "2019-04-30T17:04:40"
}
] |
[] |
原来 Perl、PHP 已经到了这个地步……
| 2017-11-05T10:07:00
| 2017-11-05T10:07:00
| 9,034
|
/article-9034-1.html
|
在 [Stack Overflow Jobs](https://stackoverflow.com/jobs) 上，你可以创建你自己的<ruby> <a href="https://stackoverflow.blog/2016/10/11/bye-bye-bullets-the-stack-overflow-developer-story-is-the-new-technical-resume/"> 开发者故事 </a> <rp> （ </rp> <rt> Developer Story </rt> <rp> ） </rp></ruby>来展示你的成就，表现你的职业生涯进步。在创建开发者故事时，你可以对你使用的技术/编程语言添加喜欢或**不喜欢**的标签，如下图：
这就给了我们一个机会可以观察到这数十万开发者的喜好和厌恶。有许多方法可以评估一个语言的流行程度，举个栗子说，我们经常使用 [Stack Overflow 访问数或问题查看数](/article-8865-1.html)来评估这样的趋势。但是，当技术人员在他们的简历中表达他们**不喜欢**某种技术时，这个数据集就是一个找出技术人群不喜欢某种技术的独有方式。
（我[两年前曾经在我的个人博客](http://varianceexplained.org/r/polarizing-technologies/)上发表过一些这类分析，不过这篇文章使用了更新的数据集，以及有更多可视化结果和说明。）
### 编程语言
作为测量每个编程语言有多流行的指标，我们将看看它出现在某人“不喜欢”标签的时间与其出现在其他人的“喜欢”或“不喜欢”标签的频率相比。那么 50% 就意味着该语言喜欢与不喜欢各占一半，而 1% 则意味着 99 个人喜欢它而剩下 1 个人不喜欢它。（我们使用了[这篇文章](http://varianceexplained.org/r/empirical_bayes_baseball/)中描述的<ruby> 经验贝叶斯 <rp> （ </rp> <rt> empirical Bayes </rt> <rp> ） </rp></ruby>方法来计算平均值，并使用[这个方法](http://varianceexplained.org/r/credible_intervals_baseball/)来计算得到 95% 置信区间）
让我们开始看看选出的语言列表（而不是像 Android 这样的平台或像 jQuery 这样的库），所有这些都曾在开发者故事中至少提及了 2000 次以上。
最不喜欢的语言是 Perl、Delphi 和 VBA ，它们远远把其它语言抛下。接着的第二梯队是 PHP、Objective-C、 Coffeescript 和 Ruby。我们的团队很高兴地看到，R 语言相对于喜欢它的人数来说，对它不喜欢的人数是最少的。
如果你读过我们另外一些关于编程语言增长或萎缩的文章，你也许会注意到那些较少被不喜欢的语言往往是增长较快的。 在 Stack Overflow 上，R、Python、Typescript、Go 和 Rust 全是快速增长的编程语言（我们之前专门对 [Python](/article-8865-1.html) 和 [R](https://stackoverflow.blog/2017/10/10/impressive-growth-r/) 做过分析），而且它们全都属于看法比较<ruby> 分化 <rp> （ </rp> <rt> polarizing </rt> <rp> ） </rp></ruby>的语言。类似的，大量萎缩的语言，比如 Perl、Objective-C 和 Ruby，如我们[之前观察](https://stackoverflow.blog/2017/08/01/flash-dead-technologies-might-next/)到的那样，在我们网站上它处于快速萎缩状况。
我们可以通过将每种语言的规模和增长与不喜欢它的人的百分比进行比较来进行调查，橙色点代表最不喜欢的语言。 为了使我们的分析与前几个帖子保持一致，我们将统计数据限制在高收入国家（如美国，英国，德国和加拿大）。
一般来说，编程语言的增长率和它有多不招人喜欢方面存在相关性。几乎每个在开发者故事中提及不喜欢的比率超过 3% 的语言都在 Stack Overflow 流量上处于萎缩状态（除了十分两极化的 VBA，它仍有轻度增长）。而不喜欢数量较少的语言，如 R、Rust、 Typescript 和 Kotlin，它们全处于快速增长领域（Typescript 和 Kotlin 增长的太快，以至于都跑出了上图范围）。
一个突出的编程语言是函数式编程语言 Clojure；几乎没有人表示过不喜欢它，但是它仍然处于快速萎缩中（根据[问题查看情况](https://insights.stackoverflow.com/trends?tags=clojure)，它在去年才开始萎缩）。另外一个例外是 MATLAB，它处于快速萎缩，但是没有很多人表示过不喜欢它。这可能是由于调查样本的数据所限：任何一个 Web 开发人员都可能对 PHP、C# 或 Ruby 有意见，但是不从事数据分析的人没理由对 MATLAB 不满意。（这也可能是 R 较少被提及“不喜欢”的部分原因）
我们不一定说这里存在因果关系——部分程序员不喜欢就会导致该语言会被抛弃。 另一种可能是，如果人们觉得这种语言已经越来越不流行，那么人们就会觉得很自然地表达他们也不喜欢了。 同样可以想象的是，开发人员经常使用这个字段来记录他们曾经使用的技术，但是不会再使用该技术了。 这将导致那些自然而然地“被替代的”技术就一直停留在“不喜欢”标签里面。
### 最不喜欢的和最喜欢的
上面的分析仅考虑了编程语言，不涉及操作系统、平台或库（框架）。那么就整体而言，最不喜欢的技术是什么？为了专注于我们有足够数据的更主要的技术，我们其限制为至少提及了 1000 次的技术。
最不喜欢的其中有几个是微软的技术，特别是 IE 和 VB，以及 “微软” 标签（“评估” 也出现在这个列表中，但是没那么糟糕）。[有个好消息是](https://stackoverflow.blog/2017/08/01/flash-dead-technologies-might-next/)，大多数人都不喜欢 Flash。此外，较老的语言，比如 COBOL、 Fortran 和 Pascal 也出现在此处。
值得再次强调的是，这不是对技术及其品质或受欢迎程度的批评。 这只是衡量哪些技术激起了强烈的消极情绪，至少在一部分愿意公开分享其感受的开发人员中如此。
我们也集中观察了那些最流行的技术、那些最不可能被不喜欢的技术（这次，由于喜欢标签出现的比较多，我们仅关注那些被提及至少 10000 次的）。
Git 也许是许多开发者的沮丧源头（绝对包括我！），但人们很少在简历中承认这一点，这是因为它是我们的开发者故事中最受欢迎的标签之一。 R 也出现在了这个列表，但它并不是唯一一个没有争议的与数据科学相关的语言。 机器学习被 23000 人所喜欢，而且很少被人不喜欢。 诸如 Python-3.X、CSS3 和 HTML5 等标签可能表明开发者很少指定他们不喜欢技术的特定版本（如果他们会指定的话）。 当然，[jQuery 在 Stack Overflow 上一直是如此受欢迎](http://i.stack.imgur.com/ssRUr.gif)。
### 分化的标签网络
我们可以把所有这些标签组合成一个网络。在最近的一篇文章中，[Julia Silge 展示了我们如何构建一个代表整个软件生态系统的技术网络](https://stackoverflow.blog/2017/10/03/mapping-ecosystems-software-development/)。 如果我们根据每个标签不喜欢的程度对节点进行着色，我们可以了解该生态系统的哪些部分比其它部分更有争议。
通过将开发者故事的标签放置到次生态系统中，该网络揭示了哪些类型的标签趋于两级分化。 在微软（以 C＃ 和 .NET 为中心，左上角），PHP（与 WordPress 和 Drupal 一起，左下角）以及移动开发（特别是 Objective-C，右下角）的子生态系统中都有一些意见分化的标签聚合。 在操作系统聚合中（右下），我们可以看到诸如 OSX 之类的系统，以及特别是 Windows 都有不喜欢的人，但是像 Linux、Ubuntu 和 Unix 这样的标签却没有。
### 竞争
如果某人喜欢某个特定的标签，是否意味着通常他们喜欢或不喜欢另外的标签呢？
我们可以使用出现在特定喜欢标签之间的 [phi 系数](https://en.wikipedia.org/wiki/Phi_coefficient)来衡量它。 （当计算这些相关性时，我们只考虑那些至少有一个不喜欢标签的人。）
这突出显示了软件生态系统的一些“竞争”：Linux 和 OSX vs Windows，Git vs SVN，vim vs emacs 以及（对我来说）R vs SAS。 这些配对中的大多数并不代表“相反”的技术，而是反映了两种解决类似问题的方法。 它们中的许多表明了从以前流行的技术发展到更现代的技术（SVN 由 Git 取代，XML 由 JSON 取代，VB 由 C＃ 取代）。 这对于人们想在简历中列出的内容是有意义的；开发者通常会表明他们不愿意使用他们认为过时的东西。
### 总结
我对“语言战争”没有任何兴趣，我也不会对用户分享的喜欢或不喜欢的任何技术进行裁断。 对微软技术的两级分化的看法通常会鼓励我分享我的个人经验。 我是一个 Mac 和 UNIX 终身拥趸，几乎我所有的大学和研究生的编程学习都围绕着 Python 和 R。尽管如此，我很高兴能够加入一个 .NET 栈的公司，我很高兴我来了 —— 因为我喜欢这个团队、产品和数据。 我不能代表其他人说话，但我很高兴自己可以从事于自己想做的事情，而不是那些不想要做的事情。
如果您有兴趣分享您喜欢和不喜欢的技术，并想找到您职业生涯的下一份工作，那么您可以[创建自己的开发者故事](http://stackoverflow.com/users/story/join)。
想找一份你喜欢的技术的工作？ 在 [Stack Overflow Jobs](https://stackoverflow.com/jobs) 找到你的下一份工作，在那里你可以搜索你喜欢做的技术工作。
|
||
Postgres 索引类型探索之旅
|
Craig Kerstiens
|
https://www.citusdata.com/blog/2017/10/17/tour-of-postgres-index-types/
|
Postgres 有几种索引类型， 并且每个新版本都似乎增加一些新的索引类型。每个索引类型都是有用的，但是具体使用哪种类型取决于（1）数据类型，有时是（2）表中的底层数据和（3）执行的查找类型。
|
/data/attachment/album/201711/07/003224iotte1erl0tsgl3p.jpg.thumb.jpg
|
/data/attachment/album/201711/07/003224iotte1erl0tsgl3p.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"数据库",
"索引",
"Postgres"
] |
技术
|
{
"viewnum": 5310,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Postgres 有几种索引类型， 并且每个新版本都似乎增加一些新的索引类型。每个索引类型都是有用的，但是具体使用哪种类型取决于（1）数据类型，有时是（2）表中的底层数据和（3）执行的查找类型。
| 2017-11-07T00:32:29
| 2017-11-07T00:32:29
| 9,035
|
/article-9035-1.html
|
在 Citus 公司，为让事情做的更好，我们与客户一起在数据建模、优化查询、和增加 [索引](https://www.citusdata.com/blog/2017/10/11/index-all-the-things-in-postgres/)上花费了许多时间。我的目标是为客户的需求提供更好的服务，从而创造成功。我们所做的其中一部分工作是[持续](https://www.citusdata.com/product/cloud)为你的 Citus 集群保持良好的优化和 [高性能](https://www.citusdata.com/blog/2017/09/29/what-performance-can-you-expect-from-postgres/)；另外一部分是帮你了解关于 Postgres 和 Citus 你所需要知道的一切。毕竟，一个健康和高性能的数据库意味着 app 执行的更快，并且谁不愿意这样呢？ 今天，我们简化一些内容，与客户分享一些关于 Postgres 索引的信息。
Postgres 有几种索引类型， 并且每个新版本都似乎增加一些新的索引类型。每个索引类型都是有用的，但是具体使用哪种类型取决于（1）数据类型，有时是（2）表中的底层数据和（3）执行的查找类型。接下来的内容我们将介绍在 Postgres 中你可以使用的索引类型，以及你何时该使用何种索引类型。在开始之前，这里有一个我们将带你亲历的索引类型列表：
* B-Tree
* <ruby> 倒排索引 <rt> Generalized Inverted Index </rt></ruby> (GIN)
* <ruby> 倒排搜索树 <rt> Generalized Inverted Seach Tree </rt></ruby> (GiST)
* <ruby> 空间分区的 <rt> Space partitioned </rt></ruby> GiST (SP-GiST)
* <ruby> 块范围索引 <rt> Block Range Index </rt></ruby> (BRIN)
* Hash
现在开始介绍索引。
### 在 Postgres 中，B-Tree 索引是你使用的最普遍的索引
如果你有一个计算机科学的学位，那么 B-Tree 索引可能是你学会的第一个索引。[B-tree 索引](https://en.wikipedia.org/wiki/B-tree) 会创建一个始终保持自身平衡的一棵树。当它根据索引去查找某个东西时，它会遍历这棵树去找到键，然后返回你要查找的数据。使用索引是大大快于顺序扫描的，因为相对于顺序扫描成千上万的记录，它可以仅需要读几个 [页](https://www.8kdata.com/blog/postgresql-page-layout/) (当你仅返回几个记录时)。
如果你运行一个标准的 `CREATE INDEX` 语句，它将为你创建一个 B-tree 索引。 B-tree 索引在大多数的数据类型上是很有价值的，比如文本、数字和时间戳。如果你刚开始在你的数据库中使用索引，并且不在你的数据库上使用太多的 Postgres 的高级特性，使用标准的 B-Tree 索引可能是你最好的选择。
### GIN 索引，用于多值列
<ruby> 倒排索引 <rt> Generalized Inverted Index </rt></ruby>，一般称为 [GIN](https://www.postgresql.org/docs/10/static/gin.html)，大多适用于当单个列中包含多个值的数据类型。
据 Postgres 文档：
>
> “GIN 设计用于处理被索引的条目是复合值的情况，并且由索引处理的查询需要搜索在复合条目中出现的值。例如，这个条目可能是文档，查询可以搜索文档中包含的指定字符。”
>
>
>
包含在这个范围内的最常见的数据类型有：
* [hStore](https://www.citusdata.com/blog/2016/07/14/choosing-nosql-hstore-json-jsonb/)
* Array
* Range
* [JSONB](https://www.citusdata.com/blog/2016/07/14/choosing-nosql-hstore-json-jsonb/)
关于 GIN 索引中最让人满意的一件事是，它们能够理解存储在复合值中的数据。但是，因为一个 GIN 索引需要有每个被添加的单独类型的数据结构的特定知识，因此，GIN 索引并不是支持所有的数据类型。
### GiST 索引， 用于有重叠值的行
<ruby> 倒排搜索树 <rt> Generalized Inverted Seach Tree </rt></ruby>（GiST）索引多适用于当你的数据与同一列的其它行数据重叠时。GiST 索引最好的用处是：如果你声明一个几何数据类型，并且你希望知道两个多边型是否包含一些点时。在一种情况中一个特定的点可能被包含在一个盒子中，而与此同时，其它的点仅存在于一个多边形中。使用 GiST 索引的常见数据类型有：
* 几何类型
* 需要进行全文搜索的文本类型
GiST 索引在大小上有很多的固定限制，否则，GiST 索引可能会变的特别大。作为其代价，GiST 索引是有损的（不精确的）。
据官方文档：
>
> “GiST 索引是有损的，这意味着索引可能产生虚假匹配，所以需要去检查真实的表行去消除虚假匹配。 (当需要时 PostgreSQL 会自动执行这个动作)”
>
>
>
这并不意味着你会得到一个错误结果，它只是说明了在 Postgres 给你返回数据之前，会做了一个很小的额外工作来过滤这些虚假结果。
特别提示：同一个数据类型上 GIN 和 GiST 索引往往都可以使用。通常一个有很好的性能表现，但会占用很大的磁盘空间，反之亦然。说到 GIN 与 GiST 的比较，并没有某个完美的方案可以适用所有情况，但是，以上规则应用于大部分常见情况。
### SP-GiST 索引，用于更大的数据
空间分区 GiST （SP-GiST）索引采用来自 [Purdue](https://www.cs.purdue.edu/spgist/papers/W87R36P214137510.pdf) 研究的空间分区树。 SP-GiST 索引经常用于当你的数据有一个天然的聚集因素，并且不是一个平衡树的时候。 电话号码是一个非常好的例子 (至少 US 的电话号码是)。 它们有如下的格式：
* 3 位数字的区域号
* 3 位数字的前缀号 (与以前的电话交换机有关)
* 4 位的线路号
这意味着第一组前三位处有一个天然的聚集因素，接着是第二组三位，然后的数字才是一个均匀的分布。但是，在电话号码的一些区域号中，存在一个比其它区域号更高的饱合状态。结果可能导致树非常的不平衡。因为前面有一个天然的聚集因素，并且数据不对等分布，像电话号码一样的数据可能会是 SP-GiST 的一个很好的案例。
### BRIN 索引， 用于更大的数据
块范围索引（BRIN）专注于一些类似 SP-GiST 的情形，它们最好用在当数据有一些自然排序，并且往往数据量很大时。如果有一个以时间为序的 10 亿条的记录，BRIN 也许就能派上用场。如果你正在查询一组很大的有自然分组的数据，如有几个邮编的数据，BRIN 能帮你确保相近的邮编存储在磁盘上相近的地方。
当你有一个非常大的比如以日期或邮编排序的数据库， BRIN 索引可以让你非常快的跳过或排除一些不需要的数据。此外，与整体数据量大小相比，BRIN 索引相对较小，因此，当你有一个大的数据集时，BRIN 索引就可以表现出较好的性能。
### Hash 索引， 总算不怕崩溃了
Hash 索引在 Postgres 中已经存在多年了，但是，在 Postgres 10 发布之前，对它们的使用一直有个巨大的警告，它不是 WAL-logged 的。这意味着如果你的服务器崩溃，并且你无法使用如 [wal-g](https://www.citusdata.com/blog/2017/08/18/introducing-wal-g-faster-restores-for-postgres/) 故障转移到备机或从存档中恢复，那么你将丢失那个索引，直到你重建它。 随着 Postgres 10 发布，它们现在是 WAL-logged 的，因此，你可以再次考虑使用它们 ，但是，真正的问题是，你应该这样做吗?
Hash 索引有时会提供比 B-Tree 索引更快的查找，并且创建也很快。最大的问题是它们被限制仅用于“相等”的比较操作，因此你只能用于精确匹配的查找。这使得 hash 索引的灵活性远不及通常使用的 B-Tree 索引，并且，你不能把它看成是一种替代品，而是一种用于特殊情况的索引。
### 你该使用哪个？
我们刚才介绍了很多，如果你有点被吓到，也很正常。 如果在你知道这些之前， `CREATE INDEX` 将始终为你创建使用 B-Tree 的索引，并且有一个好消息是，对于大多数的数据库， Postgres 的性能都很好或非常好。 :) 如果你考虑使用更多的 Postgres 特性，下面是一个当你使用其它 Postgres 索引类型的备忘清单：
* B-Tree - 适用于大多数的数据类型和查询
* GIN - 适用于 JSONB/hstore/arrays
* GiST - 适用于全文搜索和几何数据类型
* SP-GiST - 适用于有天然的聚集因素但是分布不均匀的大数据集
* BRIN - 适用于有顺序排列的真正的大数据集
* Hash - 适用于相等操作，而且，通常情况下 B-Tree 索引仍然是你所需要的。
如果你有关于这篇文章的任何问题或反馈，欢迎加入我们的 [slack channel](https://slack.citusdata.com/)。
---
via: <https://www.citusdata.com/blog/2017/10/17/tour-of-postgres-index-types/>
作者：[Craig Kerstiens](https://www.citusdata.com/blog/2017/10/17/tour-of-postgres-index-types/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为何 Kubernetes 如此受欢迎？
|
Anurag Gupta
|
https://opensource.com/article/17/10/why-kubernetes-so-popular
|
Google 开发的这个容器管理系统很快成为开源历史上最成功的案例之一。
|
/data/attachment/album/201711/07/013606ont6zxs8znc9x94m.png.thumb.jpg
|
/data/attachment/album/201711/07/013606ont6zxs8znc9x94m.png
| true
| false
| true
|
geekpi
| false
|
[
"Kubernetes",
"容器编排"
] |
观点
|
{
"viewnum": 4008,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Google 开发的这个容器管理系统很快成为开源历史上最成功的案例之一。
| 2017-11-07T01:36:12
| 2017-11-07T01:36:12
| 9,036
|
/article-9036-1.html
|
>
> Google 开发的这个容器管理系统很快成为开源历史上最成功的案例之一。
>
>
>
[Kubernetes](https://kubernetes.io/) 是一个在过去几年中快速蹿升起来的开源的容器管理系统。它被众多行业中最大的企业用于关键任务，已成为开源方面最成功的案例之一。这是怎么发生的？该如何解释 Kubernetes 的广泛应用呢？
### Kubernetes 的背景：起源于 Google 的 Borg 系统
随着计算世界变得更加分布式、更加基于网络、以及更多的云计算，我们看到了大型的<ruby> 独石 <rt> monolithic </rt></ruby>应用慢慢地转化为多个敏捷微服务。这些微服务能让用户单独缩放应用程序的关键功能，以处理数百万客户。除此之外，我们还看到像 Docker 这样的容器等技术出现在企业中，为用户快速构建这些微服务创造了一致的、可移植的、便捷的方式。
随着 Docker 继续蓬勃发展，管理这些微服务器和容器成为最重要的要求。这时已经运行基于容器的基础设施已经多年的 Google 大胆地决定开源一个名为 [Borg](http://queue.acm.org/detail.cfm?id=2898444) 的项目。Borg 系统是运行诸如 Google 搜索和 Gmail 这样的 Google 服务的关键。谷歌决定开源其基础设施为世界上任何一家公司创造了一种像顶尖公司一样运行其基础架构的方式。
### 最大的开源社区之一
在开源之后，Kubernetes 发现自己在与其他容器管理系统竞争，即 Docker Swarm 和 Apache Mesos。Kubernetes 近几个月来超过这些其他系统的原因之一得益于社区和系统背后的支持：它是最大的开源社区之一（GitHub 上超过 27,000 多个星标），有来自上千个组织（1,409 个贡献者）的贡献，并且被集中在一个大型、中立的开源基金会里，即[原生云计算基金会](https://www.cncf.io/)（CNCF）。
CNCF 也是更大的 Linux 基金会的一部分，拥有一些顶级企业成员，其中包括微软、谷歌和亚马逊。此外，CNCF 的企业成员队伍持续增长，SAP 和 Oracle 在过去几个月内加入白金会员。这些加入 CNCF 的公司，其中 Kubernetes 项目是前沿和中心的，这证明了有多少企业投注于社区来实现云计算战略的一部分。
Kubernetes 外围的企业社区也在激增，供应商提供了带有更多的安全性、可管理性和支持的企业版。Red Hat、CoreOS 和 Platform 9 是少数几个使企业级 Kubernetes 成为战略前进的关键因素，并投入巨资以确保开源项目继续得到维护的公司。
### 混合云带来的好处
企业以这样一个飞速的方式采用 Kubernetes 的另一个原因是 Kubernetes 可以在任何云端工作。大多数企业在现有的内部数据中心和公共云之间共享资产，对混合云技术的需求至关重要。
Kubernetes 可以部署在公司先前存在的数据中心内、任意一个公共云环境、甚至可以作为服务运行。由于 Kubernetes 抽象了底层基础架构层，开发人员可以专注于构建应用程序，然后将它们部署到任何这些环境中。这有助于加速公司的 Kubernetes 采用，因为它可以在内部运行 Kubernetes，同时继续构建云战略。
### 现实世界的案例
Kubernetes 继续增长的另一个原因是，大型公司正在利用这项技术来解决业界最大的挑战。Capital One、Pearson Education 和 Ancestry.com 只是少数几家公布了 Kubernetes [使用案例](https://kubernetes.io/case-studies/)的公司。
[Pokemon Go](https://cloudplatform.googleblog.com/2016/09/bringing-Pokemon-GO-to-life-on-Google-Cloud.html) 是最流行的宣传 Kubernetes 能力的使用案例。在它发布之前，人们都觉得在线多人游戏会相当的得到追捧。但当它一旦发布，就像火箭一样起飞，达到了预期流量的 50 倍。通过使用 Kubernetes 作为 Google Cloud 之上的基础设施层，Pokemon Go 可以大规模扩展以满足意想不到的需求。
最初作为来自 Google 的开源项目，背后有 Google 15 年的服务经验和来自 Borg 的继承- Kubernetes 现在是有许多企业成员的大型基金会（CNCF）的一部分。它继续受到欢迎，并被广泛应用于金融、大型多人在线游戏（如 Pokemon Go）以及教育公司和传统企业 IT 的关键任务中。考虑到所有，所有的迹象表明，Kubernetes 将继续更加流行，并仍然是开源中最大的成功案例之一。
---
作者简介：
Anurag Gupta - Anurag Gupta 是推动统一日志层 Fluentd Enterprise 发展的 Treasure Data 的产品经理。 Anurag 致力于大型数据技术，包括 Azure Log Analytics 和如 Microsoft System Center 的企业 IT 服务。
---
via: <https://opensource.com/article/17/10/why-kubernetes-so-popular>
作者：[Anurag Gupta](https://opensource.com/users/anuraggupta) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
2017 年哪个公司对开源贡献最多？让我们用 GitHub 的数据分析下
|
Felipe Hoffa
|
https://medium.freecodecamp.org/the-top-contributors-to-github-2017-be98ab854e87
|
微软排名第一、谷歌排名第二。
|
/data/attachment/album/201711/07/122034hfecf9ehgzm9b8gr.png.thumb.jpg
|
/data/attachment/album/201711/07/122034hfecf9ehgzm9b8gr.png
| true
| false
| true
|
wxy
| false
|
[
"微软",
"开源",
"GitHub"
] |
观点
|
{
"viewnum": 9124,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
微软排名第一、谷歌排名第二。
| 2017-11-07T12:20:00
| 2017-11-07T12:20:00
| 9,037
|
/article-9037-1.html
|
在这篇分析报告中，我们将使用 2017 年度截止至当前时间（2017 年 10 月）为止，GitHub 上所有公开的推送事件的数据。对于每个 GitHub 用户，我们将尽可能地猜测其所属的公司。此外，我们仅查看那些今年得到了至少 20 个星标的仓库。
以下是我的报告结果，你也可以[在我的交互式 Data Studio 报告上进一步加工](https://datastudio.google.com/open/0ByGAKP3QmCjLU1JzUGtJdTlNOG8)。
### 顶级云服务商的比较
2017 年它们在 GitHub 上的表现：
* 微软看起来约有 1300 名员工积极地推送代码到 GitHub 上的 825 个顶级仓库。
* 谷歌显示出约有 900 名员工在 GitHub 上活跃，他们推送代码到大约 1100 个顶级仓库。
* 亚马逊似乎只有 134 名员工活跃在 GitHub 上，他们推送代码到仅仅 158 个顶级项目上。
* 不是所有的项目都一样：在超过 25% 的仓库上谷歌员工要比微软员工贡献的多，而那些仓库得到了更多的星标（53 万对比 26 万）。亚马逊的仓库 2017 年合计才得到了 2.7 万个星标。
### 红帽、IBM、Pivotal、英特尔和 Facebook
如果说亚马逊看起来被微软和谷歌远远抛在了身后，那么这之间还有哪些公司呢？根据这个排名来看，红帽、Pivotal 和英特尔在 GitHub 上做出了巨大贡献：
注意，下表中合并了所有的 IBM 地区域名（各个地区会展示在其后的表格中）。
Facebook 和 IBM（美）在 GitHub 上的活跃用户数同亚马逊差不多，但是它们所贡献的项目得到了更多的星标（特别是 Facebook）：
接下来是阿里巴巴、Uber 和 Wix：
以及 GitHub 自己、Apache 和腾讯：
百度、苹果和 Mozilla：
（LCTT 译注：很高兴看到国内的顶级互联网公司阿里巴巴、腾讯和百度在这里排名前列！）
甲骨文、斯坦福大学、麻省理工、Shopify、MongoDb、伯克利大学、VmWare、Netflix、Salesforce 和 Gsa.gov：
LinkedIn、Broad Institute、Palantir、雅虎、MapBox、Unity3d、Automattic（WordPress 的开发商）、Sandia、Travis-ci 和 Spotify：
Chromium、UMich、Zalando、Esri、IBM (英)、SAP、EPAM、Telerik、UK Cabinet Office 和 Stripe：
Cern、Odoo、Kitware、Suse、Yandex、IBM (加)、Adobe、AirBnB、Chef 和 The Guardian：
Arm、Macports、Docker、Nuxeo、NVidia、Yelp、Elastic、NYU、WSO2、Mesosphere 和 Inria：
Puppet、斯坦福（计算机科学）、DatadogHQ、Epfl、NTT Data 和 Lawrence Livermore Lab：
### 我的分析方法
#### 我是怎样将 GitHub 用户关联到其公司的
在 GitHub 上判定每个用户所属的公司并不容易，但是我们可以使用其推送事件的提交消息中展示的邮件地址域名来判断。
* 同样的邮件地址可以出现在几个用户身上，所以我仅考虑那些对此期间获得了超过 20 个星标的项目进行推送的用户。
* 我仅统计了在此期间推送超过 3 次的 GitHub 用户。
* 用户推送代码到 GitHub 上可以在其推送中显示许多不同的邮件地址，这部分是由 GIt 工作机制决定的。为了判定每个用户的组织，我会查找那些在推送中出现更频繁的邮件地址。
* 不是每个用户都在 GitHub 上使用其组织的邮件。有许多人使用 gmail.com、users.noreply.github.com 和其它邮件托管商的邮件地址。有时候这是为了保持匿名和保护其公司邮箱，但是如果我不能定位其公司域名，这些用户我就不会统计。抱歉。
* 有时候员工会更换所任职的公司。我会将他们分配给其推送最多的公司。
#### 我的查询语句
```
#standardSQL
WITH
period AS (
SELECT *
FROM `githubarchive.month.2017*` a
),
repo_stars AS (
SELECT repo.id, COUNT(DISTINCT actor.login) stars, APPROX_TOP_COUNT(repo.name, 1)[OFFSET(0)].value repo_name
FROM period
WHERE type='WatchEvent'
GROUP BY 1
HAVING stars>20
),
pushers_guess_emails_and_top_projects AS (
SELECT *
# , REGEXP_EXTRACT(email, r'@(.*)') domain
, REGEXP_REPLACE(REGEXP_EXTRACT(email, r'@(.*)'), r'.*.ibm.com', 'ibm.com') domain
FROM (
SELECT actor.id
, APPROX_TOP_COUNT(actor.login,1)[OFFSET(0)].value login
, APPROX_TOP_COUNT(JSON_EXTRACT_SCALAR(payload, '$.commits[0].author.email'),1)[OFFSET(0)].value email
, COUNT(*) c
, ARRAY_AGG(DISTINCT TO_JSON_STRING(STRUCT(b.repo_name,stars))) repos
FROM period a
JOIN repo_stars b
ON a.repo.id=b.id
WHERE type='PushEvent'
GROUP BY 1
HAVING c>3
)
)
SELECT * FROM (
SELECT domain
, githubers
, (SELECT COUNT(DISTINCT repo) FROM UNNEST(repos) repo) repos_contributed_to
, ARRAY(
SELECT AS STRUCT JSON_EXTRACT_SCALAR(repo, '$.repo_name') repo_name
, CAST(JSON_EXTRACT_SCALAR(repo, '$.stars') AS INT64) stars
, COUNT(*) githubers_from_domain FROM UNNEST(repos) repo
GROUP BY 1, 2
HAVING githubers_from_domain>1
ORDER BY stars DESC LIMIT 3
) top
, (SELECT SUM(CAST(JSON_EXTRACT_SCALAR(repo, '$.stars') AS INT64)) FROM (SELECT DISTINCT repo FROM UNNEST(repos) repo)) sum_stars_projects_contributed_to
FROM (
SELECT domain, COUNT(*) githubers, ARRAY_CONCAT_AGG(ARRAY(SELECT * FROM UNNEST(repos) repo)) repos
FROM pushers_guess_emails_and_top_projects
#WHERE domain IN UNNEST(SPLIT('google.com|microsoft.com|amazon.com', '|'))
WHERE domain NOT IN UNNEST(SPLIT('gmail.com|users.noreply.github.com|qq.com|hotmail.com|163.com|me.com|googlemail.com|outlook.com|yahoo.com|web.de|iki.fi|foxmail.com|yandex.ru', '|')) # email hosters
GROUP BY 1
HAVING githubers > 30
)
WHERE (SELECT MAX(githubers_from_domain) FROM (SELECT repo, COUNT(*) githubers_from_domain FROM UNNEST(repos) repo GROUP BY repo))>4 # second filter email hosters
)
ORDER BY githubers DESC
```
### FAQ
#### 有的公司有 1500 个仓库，为什么只统计了 200 个？有的仓库有 7000 个星标，为什么只显示 1500 个？
我进行了过滤。我只统计了 2017 年的星标。举个例子说，Apache 在 GitHub 上有超过 1500 个仓库，但是今年只有 205 个项目得到了超过 20 个星标。
#### 这表明了开源的发展形势么？
注意，这个对 GitHub 的分析没有包括像 Android、Chromium、GNU、Mozilla 等顶级社区，也没有包括 Apache 基金会或 Eclipse 基金会，还有一些[其它](https://developers.google.com/open-source/organizations)项目选择在 GitHub 之外开展起活动。
#### 这对于我的组织不公平
我只能统计我所看到的数据。欢迎对我的统计的前提提出意见，以及对我的统计方法给出改进方法。如果有能用的查询语句就更好了。
举个例子，要看看当我合并了 IBM 的各个地区域名到其顶级域时排名发生了什么变化，可以用一条 SQL 语句解决：
```
SELECT *, REGEXP_REPLACE(REGEXP_EXTRACT(email, r'@(.*)'), r'.*.ibm.com', 'ibm.com') domain
```
当合并了其地区域名后， IBM 的相对位置明显上升了。
#### 回音
* [关于“ GitHub 2017 年顶级贡献者”的一些思考](https://redmonk.com/jgovernor/2017/10/25/some-thoughts-on-the-top-contributors-to-github-2017/)
### 接下来
我以前犯过错误，而且以后也可能再次出错。请查看所有的原始数据，并质疑我的前提假设——看看你能得到什么结论是很有趣的。
* [用一下交互式 Data Studio 报告](https://datastudio.google.com/open/0ByGAKP3QmCjLU1JzUGtJdTlNOG8)
感谢 [Ilya Grigorik](https://medium.com/@igrigorik) 保留的 [GitHub Archive](http://githubarchive.org/) 提供了这么多年的 GitHub 数据！
想要看更多的文章？看看我的 [Medium](http://medium.com/@hoffa/)、[在 twitter 上关注我](http://twitter.com/felipehoffa) 并订阅 [reddit.com/r/bigquery](https://reddit.com/r/bigquery)。[试试 BigQuery](https://www.reddit.com/r/bigquery/comments/3dg9le/analyzing_50_billion_wikipedia_pageviews_in_5/)，每个月可以[免费](https://cloud.google.com/blog/big-data/2017/01/how-to-run-a-terabyte-of-google-bigquery-queries-each-month-without-a-credit-card)分析 1 TB 的数据。
---
via: <https://medium.freecodecamp.org/the-top-contributors-to-github-2017-be98ab854e87>
作者：[Felipe Hoffa](https://medium.freecodecamp.org/@hoffa?source=post_header_lockup) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GitLab：我们正将源码贡献许可证切换到 DCO
|
Jamie Hurewitz
|
https://about.gitlab.com/2017/11/01/gitlab-switches-to-dco-license/
|
我们希望通过取消“贡献者许可协议”（CLA）来支持“开发者原创证书”（DCO），让每个人都能更轻松地做出贡献。
|
/data/attachment/album/201711/07/164800bsco8jooz5cb58kc.jpg.thumb.jpg
|
/data/attachment/album/201711/07/164800bsco8jooz5cb58kc.jpg
| true
| false
| true
|
geekpi
| false
|
[
"DCO",
"SLA"
] |
新闻
|
{
"viewnum": 3321,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
我们希望通过取消“贡献者许可协议”（CLA）来支持“开发者原创证书”（DCO），让每个人都能更轻松地做出贡献。
| 2017-11-07T16:48:00
| 2017-11-07T16:48:00
| 9,038
|
/article-9038-1.html
|
>
> 我们希望通过取消“<ruby> 贡献者许可协议 <rt> Contributor License Agreement </rt></ruby>”（CLA）来支持“<ruby> <a href="https://docs.google.com/a/gitlab.com/document/d/1zpjDzL7yhGBZz3_7jCjWLfRQ1Jryg1mlIVmG8y6B1_Q/edit?usp=sharing"> 开发者原创证书 </a> <rt> Developer's Certificate of Origin </rt></ruby>”（DCO），让每个人都能更轻松地做出贡献。
>
>
>
我们致力于成为[开源的好管家](https://about.gitlab.com/2016/01/11/being-a-good-open-source-steward/)，而这一承诺的一部分意味着我们永远不会停止重新评估我们如何做到这一点。承诺“每个人都可以贡献”就是消除贡献的障碍。对于我们的一些社区，“<ruby> 贡献者许可协议 <rt> Contributor License Agreement </rt></ruby>”（CLA）是对 GitLab 贡献的阻碍，所以我们改为“<ruby> <a href="https://docs.google.com/a/gitlab.com/document/d/1zpjDzL7yhGBZz3_7jCjWLfRQ1Jryg1mlIVmG8y6B1_Q/edit?usp=sharing"> 开发者原创证书 </a> <rt> Developer's Certificate of Origin </rt></ruby>”（DCO）。
许多大型的开源项目都想成为自己命运的主人。拥有基于开源软件运行自己的基础架构的自由，以及修改和审计源代码的能力，而不依赖于供应商，这使开源具有吸引力。我们希望 GitLab 成为每个人的选择。
### 为什么改变？
贡献者许可协议（CLA）是对其它项目进行开源贡献的行业标准，但对于不愿意考虑法律条款的开发人员来说，这是不受欢迎的，并且由于需要审查冗长的合同而潜在地放弃他们的一些权利。贡献者发现协议不必要的限制，并且阻止开源项目的开发者使用 GitLab。我们接触过 Debian 开发人员，他们考虑放弃 CLA，而这就是我们正在做的。
### 改变了什么？
到今天为止，我们正在推出更改，以便 GitLab 源码的贡献者只需要一个项目许可证（所有仓库都是 MIT，除了 Omnibus 是 Apache 许可证）和一个[开发者原创证书](https://developercertificate.org/) （DCO）即可。DCO 为开发人员提供了更大的灵活性和可移植性，这也是 Debian 和 GNOME 计划将其社区和项目迁移到 GitLab 的原因之一。我们希望这一改变能够鼓励更多的开发者为 GitLab 做出贡献。谢谢 Debian，提醒我们做出这个改变。
>
> “我们赞扬 GitLab 放弃他们的 CLA，转而使用对 OSS 更加友好的方式，开源社区诞生于一个汇集在一起并转化为项目的贡献海洋，这一举动肯定了 GitLab 愿意保护个人及其创作过程，最重要的是，把知识产权掌握在创造者手中。”
>
>
> —— GNOME 董事会主席 Carlos Soriano
>
>
>
>
> “我们很高兴看到 GitLab 通过从 CLA 转换到 DCO 来简化和鼓励社区贡献。我们认识到，做这种本质性的改变并不容易，我们赞扬 GitLab 在这里所展示的时间、耐心和深思熟虑的考虑。”
>
>
> —— Debian 项目负责人 Chris Lamb
>
>
>
你可以[阅读这篇关于我们做出这个决定的分析](https://docs.google.com/a/gitlab.com/document/d/1zpjDzL7yhGBZz3_7jCjWLfRQ1Jryg1mlIVmG8y6B1_Q/edit?usp=sharing)。阅读所有关于我们 [GitLab 社区版的管理](https://about.gitlab.com/stewardship/)。
---
via: <https://about.gitlab.com/2017/11/01/gitlab-switches-to-dco-license/>
作者：[Jamie Hurewitz](https://about.gitlab.com/team/#hurewitzjamie) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 是如何成功运作的
|
Matt Asay
|
https://www.datamation.com/open-source/why-linux-works.html
|
简而言之，Linux 的成功运作是因为众多企业都想要控制它但却难以做到，由于其在工业中的重要性，使得开发者和构建人员更愿意作为一名 Linux 开发者 而不是 Red Hat （或 Intel 亦或 Oracle … ）工程师。
|
/data/attachment/album/201711/07/233825v5wswwdztqo2wssz.jpg.thumb.jpg
|
/data/attachment/album/201711/07/233825v5wswwdztqo2wssz.jpg
| true
| false
| true
|
softpaopao
| false
|
[
"Linux",
"社区"
] |
观点
|
{
"viewnum": 6685,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
简而言之，Linux 的成功运作是因为众多企业都想要控制它但却难以做到，由于其在工业中的重要性，使得开发者和构建人员更愿意作为一名 Linux 开发者 而不是 Red Hat （或 Intel 亦或 Oracle … ）工程师。
| 2017-11-07T23:38:00
| 2017-11-07T23:38:00
| 9,039
|
/article-9039-1.html
|
>
> 在大量金钱与围绕 Linux 激烈争夺的公司之间，真正给操作系统带来活力的正是那些开发者。
>
>
>
事实证明上，Linux 社区是可行的，因为它本身无需太过担心社区的正常运作。尽管 Linux 已经在超级计算机、移动设备和云计算等多个领域占据了主导的地位，但 Linux 内核开发人员更多的是关注于代码本身，而不是其所在公司的利益。
这是一个出现在 [Dawn Foster 博士](https://opensource.com/article/17/10/collaboration-linux-kernel)研究 Linux 内核协作开发的博士论文中的重要结论。Foster 是在英特尔公司和<ruby> 木偶实验室 <rt> Puppet Labs </rt></ruby>的前任社区领导人，他写到，“很多人首先把自己看作是 Linux 内核开发者，其次才是作为一名雇员。”
随着大量的“<ruby> 基金洗劫型 <rt> foundation washing </rt></ruby>”公司开始侵蚀各种开源项目，意图在虚构的社区面具之下隐藏企业特权，但 Linux 依然设法保持了自身的纯粹。问题是这是怎么做到的？
### 跟随金钱的脚步
毕竟，如果有任何开源项目会进入到企业贪婪的视线中，那它一定是 Linux。早在 2008 年，[Linux 生态系统的估值已经达到了最高 250 亿美元](http://www.osnews.com/story/20416/Linux_Ecosystem_Worth_25_Billion)。最近 10 年，伴随着数量众多的云服务、移动端，以及大数据基础设施对于 Linux 的依赖，这一数据一定倍增了。甚至在像 Oracle 这样单独一个公司里，Linux 也能提供数十亿美元的价值。
那么就难怪有这样一个通过代码来影响 Linux 发展方向的必争之地。
在 [Linux 基金会的最新报道](https://www.linux.com/publications/linux-kernel-development-how-fast-it-going-who-doing-it-what-they-are-doing-and-who-5)中，让我们看看在过去一年中那些最活跃的 Linux 贡献者，以及他们所在的企业[像](/article-8220-1.html)[“海龟”一样](https://en.wikipedia.org/wiki/Turtles_all_the_way_down)高高叠起。
这些企业花费大量的资金来雇佣开发者去为自由软件做贡献，并且每个企业都从这些投资中得到了回报。由于存在企业对 Linux 过度影响的潜在可能，导致一些人对引领 Linux 开发的 Linux 基金会[表示不满](https://www.datamation.com/open-source/the-linux-foundation-and-the-uneasy-alliance.html)。在像微软这样曾经的开源界宿敌的企业挥舞着钞票进入 Linux 基金会之后，这些批评言论正变得越来越响亮。
但这只是一位虚假的敌人，坦率地说，这是一个以前的敌人。
虽然企业为了利益而给 Linux 基金会投入资金已经是事实，不过这些赞助并不能收买基金会而影响到代码。在这个最伟大的开源社区中，金钱可以帮助招募到开发者，但这些开发者相比关注企业而更专注于代码。就像 Linux 基金会执行董事 [Jim Zemlin 所强调的](https://thenewstack.io/linux-foundation-critics/)：
>
> “我们的项目中技术角色都是独立于企业的。没有人会在其提交的内容上标记他们的企业身份： 在 Linux 基金会的项目当中有关代码的讨论是最大声的。在我们的项目中，开发者可以从一个公司跳槽到另一个公司而不会改变他们在项目中所扮演的角色。之后企业或政府采用了这些代码而创造的价值，反过来又投资到项目上。这样的良性循环有益于所有人，并且也是我们的项目目标。”
>
>
>
任何读过 [Linus Torvalds 的](https://github.com/torvalds) 的邮件列表评论的人都不可能认为他是个代表着这个或那个公司的人。这对于其他的杰出贡献者来说也是一样的。虽然他们几乎都是被大公司所雇佣，但是一般情况下，这些公司为这些开发者支付薪水让他们去做想做的开发，而且事实上，他们正在做他们想做的。
毕竟，很少有公司会有足够的耐心或承受风险来为资助一群新手 Linux 内核开发者，并等上几年，等他们中出现几个人可以贡献出质量足以打动内核团队的代码。所以他们选择雇佣已有的、值得信赖的开发者。正如 [2016 Linux 基金会报告](https://www.linux.com/publications/linux-kernel-development-how-fast-it-going-who-doing-it-what-they-are-doing-and-who-5)所写的，“无薪开发者的数量正在持续地缓慢下降，同时 Linux 内核开发被证明是一种雇主们所需要的日益有价值的技能，这确保了有经验的内核开发者不会长期停留在无薪阶段。”
然而，这样的信任是代码所带来的，并不是通过企业的金钱。因此没有一个 Linux 内核开发者会为眼前的金钱而丢掉他们已经积攒的信任，当出现新的利益冲突时妥协代码质量就很快失去信任。因此不存在这种问题。
### 不是康巴亚，就是权利的游戏，非此即彼
最终，Linux 内核开发就是一种身份认同， Foster 的研究是这样认为的。
为 Google 工作也许很棒，而且也许带有一个体面的头衔以及免费的干洗。然而，作为一个关键的 Linux 内核子系统的维护人员，很难得到任意数量的公司承诺高薪酬的雇佣机会。
Foster 这样写到，“他们甚至享受当前的工作并且觉得他们的雇主不错，许多（Linux 内核开发者）倾向于寻找一些临时的工作关系，那样他们作为内核开发者的身份更被视作固定工作，而且更加重要。”
由于作为一名 Linux 开发者的身份优先，企业职员的身份次之，Linux 内核开发者甚至可以轻松地与其雇主的竞争对手合作。之所以这样，是因为雇主们最终只能有限制地控制开发者的工作，原因如上所述。Foster 深入研究了这一问题：
>
> “尽管企业对其雇员所贡献的领域产生了一些影响，在他们如何去完成工作这点上，雇员还是很自由的。许多人在日常工作中几乎没有接受任何指令，来自雇主的高度信任对工作是非常有帮助的。然而，他们偶尔会被要求做一些特定的零碎工作或者是在一个对公司重要的特定领域投入兴趣。
>
>
> 许多内核开发者也与他们的竞争者展开日常的基础协作，在这里他们仅作为个人相互交流，而不需要关心雇主之间的竞争。这是我在 Intel 工作时经常见到的一幕，因为我们内核开发者几乎都是与我们主要的竞争对手一同工作的。”
>
>
>
那些公司可能会在运行 Linux 的芯片上、或 Linux 发行版，亦或者是被其他健壮的操作系统支持的软件上产生竞争，但开发者们主要专注于一件事情：使 Linux 越来越好。同样，这是因为他们的身份与 Linux 维系在一起，而不是编码时所在防火墙（指公司）。
Foster 通过 USB 子系统的邮件列表（在 2013 年到 2015 年之间）说明了这种相互作用，用深色线条描绘了公司之间更多的电子邮件交互：
在价格讨论中一些公司明显的来往可能会引起反垄断机构的注意，但在 Linux 大陆中，这只是简单的商业行为。结果导致为所有各方在自由市场相互竞争中得到一个更好的操作系统。
### 寻找合适的平衡
这样的“合作”，如 Novell 公司的创始人 Ray Noorda 所说的那样，存在于最佳的开源社区里，但只有在真正的社区里才存在。这很难做到，举个例子，对一个由单一供应商所主导的项目来说，实现正确的合作关系很困难。由 Google 发起的 [Kubernetes](https://kubernetes.io/) 表明这是可能的，但其它像是 Docker 这样的项目却在为同样的目标而挣扎，很大一部分原因是他们一直不愿放弃对自己项目的技术领导。
也许 Kubernetes 能够工作的很好是因为 Google 并不觉得必须占据重要地位，而且事实上，它*希望*其他公司担负起开发领导的职责。凭借出色的代码解决了一个重要的行业需求，像 Kubernetes 这样的项目就能获得成功，只要 Google 既能帮助它，又为它开辟出一条道路，这就鼓励了 Red Hat 及其它公司做出杰出的贡献。
不过，Kubernetes 是个例外，就像 Linux 曾经那样。成功是因为企业的贪婪，有许多要考虑的，并且要在之间获取平衡。如果一个项目仅仅被公司自己的利益所控制，常常会在公司的技术管理上体现出来，而且再怎么开源许可也无法对企业产生影响。
简而言之，Linux 的成功运作是因为众多企业都想要控制它但却难以做到，由于其在工业中的重要性，使得开发者和构建人员更愿意作为一名 Linux 开发者 而不是 Red Hat （或 Intel 亦或 Oracle … ）工程师。
---
via: <https://www.datamation.com/open-source/why-linux-works.html>
作者：[Matt Asay](https://www.datamation.com/author/Matt-Asay-1133910.html) 译者：[softpaopao](https://github.com/softpaopao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
世界上最流行的操作系统不是 Linux 或 Windows，而是 MINIX
|
Wxy
|
你可能不知道，但是在你的英特尔系统里，除了你的主操作系统之外，还有一个操作系统在运行，这就是 MINIX。
|
/data/attachment/album/201711/08/002801dk99olicslr93ql9.jpg.thumb.jpg
|
/data/attachment/album/201711/08/002801dk99olicslr93ql9.jpg
| true
| false
| false
| true
|
[
"CPU",
"MINIX"
] |
新闻
|
{
"viewnum": 30543,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
你可能不知道，但是在你的英特尔系统里，除了你的主操作系统之外，还有一个操作系统在运行，这就是 MINIX。
| 2017-11-08T00:28:00
| 2017-11-08T00:28:00
| 9,040
|
/article-9040-1.html
|
### 运行在“Ring -3” 的 MINIX
你可能不知道，但是在你的英特尔系统里，除了你的主操作系统之外，还有一个操作系统在运行，这就是 MINIX。
早在今年 5月，[EFF 就发布了一篇文章](https://www.eff.org/deeplinks/2017/05/intels-management-engine-security-hazard-and-users-need-way-disable-it)，介绍了自 2008 年以来，这十年间英特尔发布的所有处理器都运行了一个修改版的 MINIX 3，它被称之为“管理引擎（ME）”。这个由计算机科学教授 Andrew Tanenbaum （对，就是那位早期曾经和 Linus Torvalds 论战过的教授）作为一个教育工具开发的类 Unix 操作系统内置于每一款新英特尔处理器内。
MINIX 运行在你的 CPU 的 “Ring -3”（负数 3） 层上，虽然是你的 CPU，但是你无权访问它。你能够实际访问的最低的 “Ring” 是 “Ring 0”，你的操作系统（比如 Linux）内核就运行在这一层，而大多数用户程序则运行在 “Ring 3”（正数 3）上。
这个运行在 “Ring -3” 的 MINIX 包括如下功能：
完整网络堆栈、文件系统、许多驱动程序 (包括 USB、网络等)，以及一个 Web 服务器！
没错，Web 服务器。在你的 CPU 里面有一个秘密的 Web 服务器，您是不允许访问的，而且，显然，英特尔并不希望你知道。我们不知道这个 Web 服务器究竟有什么用途，也许是 CPU 厂商会用它来访问一些数据或者进行一些控制。但是这一切，你都不知道。
据称，Google 正在积极从其内部服务器上移除这个管理引擎，显然 Google 对其安全风险感到忧虑。
这个事情有两个有趣或者说疯狂的地方：
首先，由于英特尔 CPU 的流行，所以，世界上最流行的操作系统恐怕不是 Windows，也不是 Linux，而是这个 MINIX——我们都是 MINIX 用户！
其次，由于你根本没权限访问到“Ring -3”，而这个 MINIX 却能够完全访问你的整个系统——这就是一个巨大的安全风险，运行权限极大，但是从不更新。
### MINIX 作者表态
在过去几天多家媒体[报道](https://www.networkworld.com/article/3236064/servers/minix-the-most-popular-os-in-the-world-thanks-to-intel.html)了这一消息，以至于惊动了 Andrew 本人。他在个人网站上[发表了公开信](http://www.cs.vu.nl/~ast/intel/)，强调自己并没有直接参与这个项目，如果这个系统有后门的话，这与他无关（他对此并没有明说只是暗示）。
Andrew Tanenbaum 称，MINIX 3 在 2000 年决定采用 BSD 授权，原因是企业不喜欢 GPL 许可证，认为 GPL 会让他们花费许多时间精力金钱去修改代码，然后免费提供给竞争对手。他说，英特尔的工程团队在几年前接触了他，询问了 MINIX 3 大量的技术问题，要求他对 MINIX 3 进行大量改变，减少内存占用，选择性的关闭不需要的功能。
在短暂的活跃之后双方进入了静默，直到现在媒体报道英特尔处理器都运行了 MINIX 3 他才知道。他对此感到吃惊，但并不在意，因为该操作系统是 BSD 授权，英特尔不需要付钱给他。他只是希望英特尔在部署了 MINIX 3 之后能通知他一下，这只是礼貌问题。
参考：[solidot](http://www.solidot.org/story?sid=54408)，[networkworld](https://www.networkworld.com/article/3236064/servers/minix-the-most-popular-os-in-the-world-thanks-to-intel.html)
|
||||
不，Linux 桌面版并没有突然流行起来
|
Steven J. Vaughan-nichols
|
http://www.zdnet.com/article/no-the-linux-desktop-hasnt-jumped-in-popularity/
|
有一些传闻说，Linux 桌面版的市场占有率从通常的 1.5% - 3% 翻了一番，达到 5%。真正的解释要简单的多。这似乎只是一个错误。
|
/data/attachment/album/201711/08/215822fxu3iix3uep6xuuq.jpg.thumb.jpg
|
/data/attachment/album/201711/08/215822fxu3iix3uep6xuuq.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"Linux",
"市场份额"
] |
新闻
|
{
"viewnum": 8248,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 4174,
"displayorder": 0
},
{
"raid": 7534,
"displayorder": 1
},
{
"raid": 7538,
"displayorder": 2
},
{
"raid": 7913,
"displayorder": 3
},
{
"raid": 8837,
"displayorder": 4
}
] |
有一些传闻说，Linux 桌面版的市场占有率从通常的 1.5% - 3% 翻了一番，达到 5%。真正的解释要简单的多。这似乎只是一个错误。
| 2017-11-08T21:58:00
| 2017-11-08T21:58:00
| 9,041
|
/article-9041-1.html
|
>
> 最近流传着这样一个传闻，Linux 桌面版已经突然流行起来了，并且使用者超过了 macOS。其实，并不是的。
>
>
>
有一些传闻说，Linux 桌面版的市场占有率从通常的 1.5% - 3% 翻了一番，达到 5%。那些报道是基于 [NetMarketShare](https://www.netmarketshare.com/) 的桌面操作系统分析报告而来的，据其显示，在七月份，Linux 桌面版的市场占有率从 2.5% 飙升，在九月份几乎达到 5%。但对 Linux 爱好者来说，很不幸，它并不是真的。
它也不是因为加入了谷歌推出的 Chrome OS，它在 [NetMarketShare](https://www.netmarketshare.com/) 和 [StatCounter](https://statcounter.com/) 的桌面操作系统的数据中被低估，它被认为是 Linux。但请注意，那是公正的，因为 [Chrome OS 是基于 Linux 的](http://www.zdnet.com/article/the-secret-origins-of-googles-chrome-os/)。
真正的解释要简单的多。这似乎只是一个错误。NetMarketShare 的市场营销高管 Vince Vizzaccaro 告诉我，“Linux 份额是不正确的。我们意识到这个问题，目前正在调查此事”。（LCTT 译注：已经修复该错误）
如果这听起来很奇怪，那是因为你可能认为，NetMarketShare 和 StatCounter 只是计算用户数量。但他们不是这样的。相反，他们都使用自己的秘密的方法去统计这些操作系统的数据。
NetMarketShare 的方法是对 “[从网站访问者的浏览器中收集数据](http://www.netmarketshare.com/faq.aspx#Methodology)到我们专用的请求式 HitsLink 分析网络中和 SharePost 客户端。该网络包括超过 4 万个网站，遍布全球。我们‘计数’访问我们的网络站点的唯一访客，并且一个唯一访客每天每个网络站点只计数一次。”
然后，公司按国家对数据进行加权。“我们将我们的流量与 CIA 互联网流量按国家进行比较，并相应地对我们的数据进行加权。例如，如果我们的全球数据显示巴西占我们网络流量的 2%，而 CIA 的数据显示巴西占全球互联网流量的 4%，那么我们将统计每一个来自巴西的唯一访客两次。”
他们究竟如何 “权衡” 每天访问一个站点的数据？我们不知道。
StatCounter 也有自己的方法。它使用 “[在全球超过 200 万个站点上安装的跟踪代码](http://gs.statcounter.com/faq#methodology)。这些网站涵盖了各种类型和不同的地理位置。每个月，我们都会记录在这些站点上的数十亿页的页面访问。对于每个页面访问，我们分析其使用的浏览器/操作系统/屏幕分辨率（如果页面访问来自移动设备）。 ... 我们统计了所有这些数据以获取我们的全球统计信息。
我们为互联网使用趋势提供独立的、公正的统计数据。我们不与任何其他信息源核对我们的统计数据，也 [没有使用人为加权](http://gs.statcounter.com/faq#no-weighting)。”
他们如何汇总他们的数据？你猜猜看？其它我们也不知道。
因此，无论何时，你看到的他们这些经常被引用的操作系统或浏览器的数字，使用它们要有很大的保留余地。
对于更精确的，以美国为对象的操作系统和浏览器数量，我更喜欢使用联邦政府的 [数字分析计划（DAP）](https://www.digitalgov.gov/services/dap/)。
与其它的不同， DAP 的数字来自在过去的 90 天访问过 [400 个美国政府行政机构域名](https://analytics.usa.gov/data/live/second-level-domains.csv) 的数十亿访问者。那里有 [大概 5000 个网站](https://analytics.usa.gov/data/live/sites.csv)，并且包含每个内阁部门。 DAP 从一个谷歌分析帐户中得到原始数据。 DAP [开源了它在这个网站上显示其数据的代码](https://github.com/GSA/analytics.usa.gov) 以及它的 [数据收集代码](https://github.com/18F/analytics-reporter)。最重要的是，与其它的不同，你可以以 [JSON](http://json.org/) 格式下载它的数据，这样你就可以自己分析原始数据了。
在 [美国分析](https://analytics.usa.gov/) 网站上，它汇总了 DAP 的数据，你可以找到 Linux 桌面版，和往常一样，它仍以 1.5% 列在 “其它” 中。Windows 仍然是高达 45.9%，接下来是 Apple iOS，占 25.5%，Android 占 18.6%，而 macOS 占 8.5%。
对不起，伙计们，我也希望它更高，但是，这就是事实。没有人，即使是 DAP，似乎都无法很好地将基于 Linux 的 Chrome OS 数据单列出来。尽管如此，Linux 桌面版仍然是 Linux 高手、软件开发者、系统管理员和工程师的专利。Linux 爱好者们还只能对其它所有的计算机设备 —— 服务器、云、超级计算机等等的（Linux）操作系统表示自豪。
---
via: <http://www.zdnet.com/article/no-the-linux-desktop-hasnt-jumped-in-popularity/>
作者：[Steven J. Vaughan-Nichols](http://www.zdnet.com/meet-the-team/us/steven-j-vaughan-nichols/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
明确 GPL 版本号，避免许可证混淆
|
Jeffrey Robert Kaufman
|
https://opensource.com/article/17/11/avoiding-gpl-confusion
|
多年以来，我看到很多开源项目表示遵循 GPL 许可证，但却没有明确指出版本号，同时也没有将整个 GPL 许可证（例如，v2 或 v3）副本囊括在程序内。取决于您是许可人还是被许可人等因素，这其中造成的含混不清可能对您有益或有害。
|
/data/attachment/album/201711/08/235505stg54ff5vfumj6vg.png.thumb.jpg
|
/data/attachment/album/201711/08/235505stg54ff5vfumj6vg.png
| true
| false
| true
|
薛亮
| false
|
[
"GPL",
"许可证"
] |
开源智慧
|
{
"viewnum": 5287,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
多年以来，我看到很多开源项目表示遵循 GPL 许可证，但却没有明确指出版本号，同时也没有将整个 GPL 许可证（例如，v2 或 v3）副本囊括在程序内。取决于您是许可人还是被许可人等因素，这其中造成的含混不清可能对您有益或有害。
| 2017-11-08T23:55:01
| 2017-11-08T23:55:01
| 9,042
|
/article-9042-1.html
|
>
> 明确是避免许可歧义的关键所在。
>
>
>
在许可证的过去、当前和未来版本如何适用于软件程序方面，[GPL 系列许可证](https://www.gnu.org/licenses/licenses.html)在开源许可证中可谓独树一帜。如果不能完全理解其中独有的许可证特性，开源软件开发人员可能会无意中造成混淆。
GPL 许可证在其许可证的条款和条件中阐明了许可证版本如何适用于该程序。[GPL v2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html#SEC3)（第 9 条）写到：
>
> “每个版本都有一个独特的版本号，如果该程序指定了其适用的许可证的版本号以及‘任何更新的版本’，则可以选择遵循由<ruby> 自由软件基金会 <rp> （ </rp> <rt> Free Software Foundation </rt> <rp> ） </rp></ruby>发布的该版本或之后任何更新版本的条款和条件。如果该程序未指定许可证的版本号，则可以选择自由软件基金会以前发布的任何版本。”
>
>
>
[GPL v3](https://www.gnu.org/licenses/gpl.html) 第 14 条与 GPL v2 中的上述条款非常相似。
多年以来，我看到很多开源项目表示遵循 GPL 许可证，但却没有明确指出版本号，同时也没有将整个 GPL 许可证（例如，v2 或 v3）副本囊括在程序内。取决于您是许可人还是被许可人等因素，这其中造成的含混不清可能对您有益或有害。
### 许可证的模糊如何产生影响
例如，假设应用程序的许可证声明：“本程序遵循 GPL 许可证”，并且包含整个 GPL v3 许可证的副本。由于该项目没有明确说明适用该许可证的哪个版本号，所以合理的解释是自由软件基金会发布的所有版本 GPL 许可证都适用——v3、v2 甚至 v1！
依据 GPL v3 第 14 条的下述文本可以合乎情理地做出上述理解。
>
> “如果该程序未指定 GNU GPL 的版本号，则可以选择由自由软件基金会发布的任何版本。”
>
>
>
另一方面，将 GPL 特定版本的完整副本（还可能包括许可证标题块中的 GPL 版本号）包含在程序中，可以被解释为在实质上传递了特定版本的许可证。在这个例子中，那就是 GPL v3 版本并且只有 GPL v3 版本，因为 v3 中没有“任何更新的版本”的条款。
### 如何避免许可歧义
为了避免这种许可歧义，您应该写得非常明确。如果您只想适用 GPL v3，应该明确地声明：“本程序仅遵循 GPL v3”，并提供整个 GPL v3 许可证副本。或者，如果您希望适用 GPL v3 或之后更新的版本，请明确声明：“本程序遵循 GPL v3 或其之后更新的版本”。最后，如果您真的想要适用任何版本的 GPL 许可证，您可以提供 GPL v3 许可证，并表示：“本程序遵循由自由软件基金会发布的任何版本的 GPL 许可证”。
无论您选择哪种授权方式，都应该非常明确，让每个人都能理解您的真正意图。
---
作者简介：Jeffrey R. Kaufman是全球领先的开源软件解决方案供应商Red Hat公司的开源知识产权律师，还担任托马斯杰斐逊法学院（Thomas Jefferson School of Law）的兼职教授。在任职Red Hat之前，Jeffrey曾担任高通公司（Qualcomm Incorporated）的专利顾问，为首席科学家办公室（Office of the Chief Scientist）提供开源事务咨询。
译者简介：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
---
via: <https://opensource.com/article/17/11/avoiding-gpl-confusion>
作者：[Jeffrey Robert Kaufman](https://opensource.com/users/jkaufman) 译者：薛亮 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](/article-9041-1.html) 荣誉推出
|
||
GitHub 2017 章鱼猫观察报告
|
Github
|
https://octoverse.github.com/
|
又是一年，GitHub 例行发布了 2017 年度的章鱼猫观察报告。以下我们撷取此报告中一些有趣的结果分享给大家。
|
/data/attachment/album/201711/09/000609ifqg33f4xngtwgr9.jpg.thumb.jpg
|
/data/attachment/album/201711/09/000609ifqg33f4xngtwgr9.jpg
| true
| false
| true
|
wxy
| true
|
[
"GitHub",
"章鱼猫"
] |
观点
|
{
"viewnum": 6588,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 7776,
"displayorder": 0
}
] |
又是一年，GitHub 例行发布了 2017 年度的章鱼猫观察报告。以下我们撷取此报告中一些有趣的结果分享给大家。
| 2017-11-09T10:54:00
| 2017-11-09T10:54:00
| 9,043
|
/article-9043-1.html
|
又是一年，GitHub 例行发布了 [2017 年度的章鱼猫观察报告](https://octoverse.github.com/)。以下我们撷取此报告中一些有趣的结果分享给大家。
数百万的开发人员使用 GitHub 来共享代码和构建业务。在这里你可以完成你的工作、打造新的技术、贡献给开源项目等等。历史已经证明，当好奇的人聚集到一起工作，一些美好的事情就会随之而来：工作进行得更快、新的想法涌现，从根本上改变了我们建立软件的方式。
为了庆祝这贡献和辉煌的一年, 让我们回顾一下 2017 年的项目、人员和团队。
### 十年千万，遍及全球
过去这十年，GitHub 各项数据已经超过了百万级，甚至千万级。在 2017 年，GitHub 社区有 2400 万开发者工作于 6700 万个仓库上，就连这些开发者组成的组织都达到了 150 万个。
而这些开发者遍及全球：亚洲 710 万，北美 590 万，欧洲 530 万，等等。
### 这一年，忙碌的一年
人们在 2500 万个公开仓库上分享代码。从 2016 年 9 月到现在的一年间：
* 公开仓库的提交数达到了 **1 亿个**！
* 活跃仓库有 2530 万个（“活跃”指该仓库有公开的活动，比如提交、星标、讨论等）
* 活跃<ruby> 工单 <rp> （ </rp> <rt> issue </rt> <rp> ） </rp></ruby>有 1250 万个，关闭（解决）了 6880 万个工单，对工单进行了 140 万次讨论
+ 这其中包括 [Kent 的约聊求助工单](https://github.com/kentcdodds/ama/issues/295) :D
* 新 PR （<ruby> 拉取请求 <rp> （ </rp> <rt> pull request </rt> <rp> ） </rp></ruby>）有 130 万个，
+ 这其中包括了 [Linus Torvalds 的第一个 GitHub PR](https://github.com/Subsurface-divelog/subsurface/pull/155) ！
* **第 1 亿个 PR** 被合并，这是一个 [OpenShift 的文档更新](https://github.com/openshift/openshift-docs/pull/4509)
* 对代码进行了 62 万次审查
* 最流行的表情符是：点赞（720 万）
* 新加入 670 万开发者，其有 100 万的开发者来自美国，69 万来自中国
+ 这些新加入的开发者发起了 120 万个 PR，410 万人创建了其第一个仓库，
+ 19 万人没有提交任何代码而只是复刻和星标了仓库
* 创建了 45 万个组织
+ 这其中包括 [Python](https://github.com/python) 的开发也迁移到了 GitHub
### 编程语言，各就其位
通过 PR 所使用的语言，可以发现最流行的语言是——**JavaScript**！而 Python 取代了 Java 成为了第二名。很高兴 Ruby 和 PHP 分别能取得第四、第五名。其余的名次和[去年](/article-7776-1.html)相差不大。
### 项目排名，众望所归
从这些活跃的仓库中，我们找出了 10 大<ruby> 复刻 <rp> （ </rp> <rt> fork </rt> <rp> ） </rp></ruby>数最多的仓库。人工智能方向的 [TensorFlow](https://github.com/tensorflow/tensorflow) 项目夺得桂冠，前端方向的 [BootStrap](https://github.com/twbs/bootstrap) 是第二。尤雨溪的 [vuejs](https://github.com/vuejs/vue) 排名第六，恰恰比排名第七的 Facebook 的 [react](https://github.com/facebook/react) 的复刻数高一点，很难说这与今年 Facebook 对 react 的[许可证问题](/article-8733-1.html)有没有关系。而 Linus 的 [Linux](https://github.com/torvalds/linux) 项目敬陪末座，作为这样庞大的一个项目，已经相当了不起了。
（这里没有包括 MOOC 课程，[一个 Coursera 的 R 语言课程](https://github.com/rdpeng/ProgrammingAssignment2)有数千的复刻数，以此判断，至少有十万学生开始学习该课程了）
而以贡献者来说，微软的 [vscode](https://github.com/Microsoft/vscode) 项目的贡献者最多，几乎是排在第二名的 [react-native](https://github.com/facebook/react-native) 的两倍。这一方面证明了社区对 vscode 的喜爱，另外一方面也证明了微软在开源方面的重注投入。
得到最多代码评议的项目是 Typescript 的一个类型定义库 [DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped)，第二名才是炙手可热的 [Kubernetes](https://github.com/kubernetes/kubernetes)。
当然，已经赢得了容器编排系统之战的 [Kerbernetes](https://github.com/kubernetes/kubernetes) 取得讨论最多的排名一点也不令人意外，它的讨论数量的零头就和第二名 [origin](https://github.com/openshift/origin) 差不多，而这个 OpenShift 下的 Origin 项目，也是一个 Kubernetes 项目——面向开发者的企业版 Kubernetes 发行版。
### 企业版，大公司多用
GitHub 虽然对个人的公开使用提供免费的服务，当然，如果你想放私有仓库，是要交费的。而 GitHub 对于或大或小的企业来说，更适用的是其企业版。
* 美国前一百个最大的公司（按收入）有一半在使用 GitHub 企业版
* 虽然美国是使用 GitHub 企业版最多的国家，但是也有 1/4 的客户来自其它国家
* 不仅仅是软件和互联网行业在使用 GitHub 企业版（占 22%），金融服务、商业服务也占比较高
感谢你，让我们期待 2018 年的章鱼猫报告！
|
||
如何分析博客中最流行的编程语言
|
Serge Mosin
|
https://www.databrawl.com/2017/10/08/blog-analysis/
|
我一直在想，各种各样的博客每天到底都有多少页面浏览量，以及在博客阅读受众中最受欢迎的是什么编程语言。我也很感兴趣的是，它们在谷歌的网站排名是否与它们的受欢迎程度直接相关。
|
/data/attachment/album/201711/09/180208dcnhwgbjbx1c1sc1.jpg.thumb.jpg
|
/data/attachment/album/201711/09/180208dcnhwgbjbx1c1sc1.jpg
| true
| false
| true
|
Chao-zhi
| false
|
[
"博客",
"编程语言"
] |
软件开发
|
{
"viewnum": 5674,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我一直在想，各种各样的博客每天到底都有多少页面浏览量，以及在博客阅读受众中最受欢迎的是什么编程语言。我也很感兴趣的是，它们在谷歌的网站排名是否与它们的受欢迎程度直接相关。
| 2017-11-09T18:02:00
| 2017-11-09T18:02:00
| 9,044
|
/article-9044-1.html
|
>
> 摘要：这篇文章我们将对一些各种各样的博客的流行度相对于他们在谷歌上的排名进行一个分析。所有代码可以在 [github](https://github.com/Databrawl/blog_analysis) 上找到。
>
>
>
### 想法来源
我一直在想，各种各样的博客每天到底都有多少页面浏览量，以及在博客阅读受众中最受欢迎的是什么编程语言。我也很感兴趣的是，它们在谷歌的网站排名是否与它们的受欢迎程度直接相关。
为了回答这些问题，我决定做一个 Scrapy 项目，它将收集一些数据，然后对所获得的信息执行特定的数据分析和数据可视化。
### 第一部分：Scrapy
我们将使用 [Scrapy](https://scrapy.org/) 为我们的工作，因为它为抓取和对该请求处理后的反馈进行管理提供了干净和健壮的框架。我们还将使用 [Splash](https://github.com/scrapinghub/splash) 来解析需要处理的 Javascript 页面。Splash 使用自己的 Web 服务器充当代理，并处理 Javascript 响应，然后再将其重定向到我们的爬虫进程。
>
> 我这里没有描述 Scrapy 的设置，也没有描述 Splash 的集成。你可以在[这里](https://docs.scrapy.org/en/latest/intro/tutorial.html)找到 Scrapy 的示例，而[这里](https://blog.scrapinghub.com/2015/03/02/handling-javascript-in-scrapy-with-splash/)还有 Scrapy+Splash 指南。
>
>
>
#### 获得相关的博客
第一步显然是获取数据。我们需要关于编程博客的谷歌搜索结果。你看，如果我们开始仅仅用谷歌自己来搜索，比如说查询 “Python”，除了博客，我们还会得到很多其它的东西。我们需要的是做一些过滤，只留下特定的博客。幸运的是，有一种叫做 [Google 自定义搜索引擎（CSE）](https://en.wikipedia.org/wiki/Google_Custom_Search)的东西，它能做到这一点。还有一个网站 [www.blogsearchengine.org](http://www.blogsearchengine.org/)，它正好可以满足我们需要，它会将用户请求委托给 CSE，这样我们就可以查看它的查询并重复利用它们。
所以，我们要做的是到 [www.blogsearchengine.org](http://www.blogsearchengine.org/) 网站，搜索 “python”，并在一侧打开 Chrome 开发者工具中的网络标签页。这截图是我们将要看到的：
突出显示的是 blogsearchengine 向谷歌委派的一个搜索请求，所以我们将复制它，并在我们的 scraper 中使用。
这个博客抓取爬行器类会是如下这样的:
```
class BlogsSpider(scrapy.Spider):
name = 'blogs'
allowed_domains = ['cse.google.com']
def __init__(self, queries):
super(BlogsSpider, self).__init__()
self.queries = queries
```
与典型的 Scrapy 爬虫不同，我们的方法覆盖了 `__init__` 方法，它接受额外的参数 `queries`，它指定了我们想要执行的查询列表。
现在，最重要的部分是构建和执行这个实际的查询。这个过程放在 `start_requests` 爬虫的方法里面执行，我们愉快地覆盖它：
```
def start_requests(self):
params_dict = {
'cx': ['partner-pub-9634067433254658:5laonibews6'],
'cof': ['FORID:10'],
'ie': ['ISO-8859-1'],
'q': ['query'],
'sa.x': ['0'],
'sa.y': ['0'],
'sa': ['Search'],
'ad': ['n9'],
'num': ['10'],
'rurl': [
'http://www.blogsearchengine.org/search.html?cx=partner-pub'
'-9634067433254658%3A5laonibews6&cof=FORID%3A10&ie=ISO-8859-1&'
'q=query&sa.x=0&sa.y=0&sa=Search'
],
'siteurl': ['http://www.blogsearchengine.org/']
}
params = urllib.parse.urlencode(params_dict, doseq=True)
url_template = urllib.parse.urlunparse(
['https', self.allowed_domains[0], '/cse',
'', params, 'gsc.tab=0&gsc.q=query&gsc.page=page_num'])
for query in self.queries:
for page_num in range(1, 11):
url = url_template.replace('query', urllib.parse.quote(query))
url = url.replace('page_num', str(page_num))
yield SplashRequest(url, self.parse, endpoint='render.html',
args={'wait': 0.5})
```
在这里你可以看到相当复杂的 `params_dict` 字典，它控制所有我们之前找到的 Google CSE URL 的参数。然后我们准备好 `url_template` 里的一切，除了已经填好的查询和页码。我们对每种编程语言请求 10 页，每一页包含 10 个链接，所以是每种语言有 100 个不同的博客用来分析。
在 `42-43` 行，我使用一个特殊的类 `SplashRequest` 来代替 Scrapy 自带的 Request 类。它封装了 Splash 库内部的重定向逻辑，所以我们无需为此担心。十分整洁。
最后，这是解析程序：
```
def parse(self, response):
urls = response.css('div.gs-title.gsc-table-cell-thumbnail') \
.xpath('./a/@href').extract()
gsc_fragment = urllib.parse.urlparse(response.url).fragment
fragment_dict = urllib.parse.parse_qs(gsc_fragment)
page_num = int(fragment_dict['gsc.page'][0])
query = fragment_dict['gsc.q'][0]
page_size = len(urls)
for i, url in enumerate(urls):
parsed_url = urllib.parse.urlparse(url)
rank = (page_num - 1) * page_size + i
yield {
'rank': rank,
'url': parsed_url.netloc,
'query': query
}
```
所有 Scraper 的核心和灵魂就是解析器逻辑。可以有多种方法来理解响应页面的结构并构建 XPath 查询字符串。您可以使用 [Scrapy shell](https://doc.scrapy.org/en/latest/topics/shell.html) 尝试并随时调整你的 XPath 查询，而不用运行爬虫。不过我更喜欢可视化的方法。它需要再次用到谷歌 Chrome 开发人员控制台。只需右键单击你想要用在你的爬虫里的元素，然后按下 Inspect。它将打开控制台，并定位到你指定位置的 HTML 源代码。在本例中，我们想要得到实际的搜索结果链接。他们的源代码定位是这样的:
在查看这个元素的描述后我们看到所找的 `<div>` 有一个 `.gsc-table-cell-thumbnail` CSS 类，它是 `.gs-title` `<div>` 的子元素，所以我们把它放到响应对象的 `css` 方法（`46` 行）。然后，我们只需要得到博客文章的 URL。它很容易通过`'./a/@href'` XPath 字符串来获得，它能从我们的 `<div>` 直接子元素的 `href` 属性找到。（LCTT 译注：此处图文对不上）
#### 寻找流量数据
下一个任务是估测每个博客每天得到的页面浏览量。得到这样的数据有[各种方式](https://www.labnol.org/internet/find-website-traffic-hits/8008/)，有免费的，也有付费的。在快速搜索之后，我决定基于简单且免费的原因使用网站 [www.statshow.com](http://www.statshow.com/) 来做。爬虫将抓取这个网站，我们在前一步获得的博客的 URL 将作为这个网站的输入参数，获得它们的流量信息。爬虫的初始化是这样的:
```
class TrafficSpider(scrapy.Spider):
name = 'traffic'
allowed_domains = ['www.statshow.com']
def __init__(self, blogs_data):
super(TrafficSpider, self).__init__()
self.blogs_data = blogs_data
```
`blogs_data` 应该是以下格式的词典列表：`{"rank": 70, "url": "www.stat.washington.edu"， "query": "Python"}`。
请求构建函数如下：
```
def start_requests(self):
url_template = urllib.parse.urlunparse(
['http', self.allowed_domains[0], '/www/{path}', '', '', ''])
for blog in self.blogs_data:
url = url_template.format(path=blog['url'])
request = SplashRequest(url, endpoint='render.html',
args={'wait': 0.5}, meta={'blog': blog})
yield request
```
它相当的简单，我们只是把字符串 `/www/web-site-url/` 添加到 `'www.statshow.com'` URL 中。
现在让我们看一下语法解析器是什么样子的：
```
def parse(self, response):
site_data = response.xpath('//div[@id="box_1"]/span/text()').extract()
views_data = list(filter(lambda r: '$' not in r, site_data))
if views_data:
blog_data = response.meta.get('blog')
traffic_data = {
'daily_page_views': int(views_data[0].translate({ord(','): None})),
'daily_visitors': int(views_data[1].translate({ord(','): None}))
}
blog_data.update(traffic_data)
yield blog_data
```
与博客解析程序类似，我们只是通过 StatShow 示例的返回页面，然后找到包含每日页面浏览量和每日访问者的元素。这两个参数都确定了网站的受欢迎程度，对于我们的分析只需要使用页面浏览量即可 。
### 第二部分：分析
这部分是分析我们搜集到的所有数据。然后，我们用名为 [Bokeh](https://bokeh.pydata.org/en/latest/) 的库来可视化准备好的数据集。我在这里没有给出运行器和可视化的代码，但是它可以在 [GitHub repo](https://github.com/Databrawl/blog_analysis) 中找到，包括你在这篇文章中看到的和其他一切东西。
>
> 最初的结果集含有少许偏离过大的数据，（如 google.com、linkedin.com、Oracle.com 等）。它们显然不应该被考虑。即使其中有些有博客，它们也不是针对特定语言的。这就是为什么我们基于这个 [StackOverflow 回答](https://stackoverflow.com/a/16562028/1573766) 中所建议的方法来过滤异常值。
>
>
>
#### 语言流行度比较
首先，让我们对所有的语言进行直接的比较，看看哪一种语言在前 100 个博客中有最多的浏览量。
这是能进行这个任务的函数：
```
def get_languages_popularity(data):
query_sorted_data = sorted(data, key=itemgetter('query'))
result = {'languages': [], 'views': []}
popularity = []
for k, group in groupby(query_sorted_data, key=itemgetter('query')):
group = list(group)
daily_page_views = map(lambda r: int(r['daily_page_views']), group)
total_page_views = sum(daily_page_views)
popularity.append((group[0]['query'], total_page_views))
sorted_popularity = sorted(popularity, key=itemgetter(1), reverse=True)
languages, views = zip(*sorted_popularity)
result['languages'] = languages
result['views'] = views
return result
```
在这里，我们首先按语言（词典中的关键字“query”）来分组我们的数据，然后使用 python 的 `groupby` 函数，这是一个从 SQL 中借来的奇妙函数，从我们的数据列表中生成一组条目，每个条目都表示一些编程语言。然后，在第 `14` 行我们计算每一种语言的总页面浏览量，然后添加 `('Language', rank)` 形式的元组到 `popularity` 列表中。在循环之后，我们根据总浏览量对流行度数据进行排序，并将这些元组展开到两个单独的列表中，然后在 `result` 变量中返回它们。
>
> 最初的数据集有很大的偏差。我检查了到底发生了什么，并意识到如果我在 [blogsearchengine.org](http://blogsearchengine.org/) 上查询“C”，我就会得到很多无关的链接，其中包含了 “C” 的字母。因此，我必须将 C 排除在分析之外。这种情况几乎不会在 “R” 和其他类似 C 的名称中出现：“C++”、“C”。
>
>
>
因此，如果我们将 C 从考虑中移除并查看其他语言，我们可以看到如下图:
评估结论：Java 每天有超过 400 万的浏览量，PHP 和 Go 有超过 200 万，R 和 JavaScript 也突破了百万大关。
#### 每日网页浏览量与谷歌排名
现在让我们来看看每日访问量和谷歌的博客排名之间的联系。从逻辑上来说，不那么受欢迎的博客应该排名靠后，但这并没那么简单，因为其他因素也会影响排名，例如，如果在人气较低的博客上的文章更新一些，那么它很可能会首先出现。
数据准备工作以下列方式进行：
```
def get_languages_popularity(data):
query_sorted_data = sorted(data, key=itemgetter('query'))
result = {'languages': [], 'views': []}
popularity = []
for k, group in groupby(query_sorted_data, key=itemgetter('query')):
group = list(group)
daily_page_views = map(lambda r: int(r['daily_page_views']), group)
total_page_views = sum(daily_page_views)
popularity.append((group[0]['query'], total_page_views))
sorted_popularity = sorted(popularity, key=itemgetter(1), reverse=True)
languages, views = zip(*sorted_popularity)
result['languages'] = languages
result['views'] = views
return result
```
该函数接受爬取到的数据和需要考虑的语言列表。我们对这些数据以语言的流行程度进行排序。后来，在类似的语言分组循环中，我们构建了 `(rank, views_number)` 元组（从 1 开始的排名）被转换为 2 个单独的列表。然后将这一对列表写入到生成的字典中。
前 8 位 GitHub 语言（除了 C）是如下这些：
评估结论：我们看到，所有图的 [PCC （皮尔逊相关系数）](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)都远离 1/-1，这表示每日浏览量与排名之间缺乏相关性。值得注意的是，在大多数图表（8 个中的 7 个）中，相关性是负的，这意味着排名的降低会导致浏览量的减少。
### 结论
因此，根据我们的分析，Java 是目前最流行的编程语言，其次是 PHP、Go、R 和 JavaScript。在日常浏览量和谷歌排名上，排名前 8 的语言都没有很强的相关性，所以即使你刚刚开始写博客，你也可以在搜索结果中获得很高的评价。不过，成为热门博客究竟需要什么，可以留待下次讨论。
>
> 这些结果是相当有偏差的，如果没有更多的分析，就不能过分的考虑这些结果。首先，在较长的一段时间内收集更多的流量信息，然后分析每日浏览量和排名的平均值（中值）值是一个好主意。也许我以后还会再回来讨论这个。
>
>
>
### 引用
1. 抓取：
1. [blog.scrapinghub.com: Handling Javascript In Scrapy With Splash](https://blog.scrapinghub.com/2015/03/02/handling-javascript-in-scrapy-with-splash/)
2. [BlogSearchEngine.org](http://www.blogsearchengine.org/)
3. [twingly.com: Twingly Real-Time Blog Search](https://www.twingly.com/)
4. [searchblogspot.com: finding blogs on blogspot platform](http://www.searchblogspot.com/)
2. 流量评估：
1. [labnol.org: Find Out How Much Traffic a Website Gets](https://www.labnol.org/internet/find-website-traffic-hits/8008/)
2. [quora.com: What are the best free tools that estimate visitor traffic…](https://www.quora.com/What-are-the-best-free-tools-that-estimate-visitor-traffic-for-a-given-page-on-a-particular-website-that-you-do-not-own-or-operate-3rd-party-sites)
3. [StatShow.com: The Stats Maker](http://www.statshow.com/)
---
via: <https://www.databrawl.com/2017/10/08/blog-analysis/>
作者：[Serge Mosin](https://www.databrawl.com/author/svmosingmail-com/) 译者：[Chao-zhi](https://github.com/Chao-zhi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
为什么 Ubuntu 放弃 Unity？创始人如是说
|
Joey Sneddon
|
http://www.omgubuntu.co.uk/2017/10/why-did-ubuntu-drop-unity-mark-shuttleworth-explains
|
答案可能会出乎意料……或许不会，因为答案也在情理之中。简而言之就是他把驱逐 Unity 作为节约成本的一部分，旨在使 Canonical 走上 IPO 的道路。是的，投资者来了。
|
/data/attachment/album/201711/10/101920lvghu2vgh95h4lek.jpg.thumb.jpg
|
/data/attachment/album/201711/10/101920lvghu2vgh95h4lek.jpg
| true
| false
| true
|
Snapcrafter,geekpi
| false
|
[
"Ubuntu",
"Unity"
] |
观点
|
{
"viewnum": 6924,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8413,
"displayorder": 0
},
{
"raid": 8428,
"displayorder": 1
},
{
"raid": 8980,
"displayorder": 2
}
] |
答案可能会出乎意料……或许不会，因为答案也在情理之中。简而言之就是他把驱逐 Unity 作为节约成本的一部分，旨在使 Canonical 走上 IPO 的道路。是的，投资者来了。
| 2017-11-10T10:19:00
| 2017-11-10T10:19:00
| 9,045
|
/article-9045-1.html
|
Mark Shuttleworth 是 Ubuntu 的创始人
Ubuntu 之前[在 4 月份](/article-8428-1.html)宣布决定放弃 Unity 让包括我在内的所有人都大感意外。
现在，Ubuntu 的创始人 [Mark Shuttleworth](https://en.wikipedia.org/wiki/Mark_Shuttleworth) 分享了关于 Ubuntu 为什么会选择放弃 Unity 的更多细节。
答案可能会出乎意料……
或许不会，因为答案也在情理之中。
### 为什么 Ubuntu 放弃 Unity？
上周（10 月 20 日）[Ubuntu 17.10](/article-8980-1.html) 已经发布，这是自 [2011 年引入](http://www.omgubuntu.co.uk/2010/10/ubuntu-11-04-unity-default-desktop) Unity 以来，Ubuntu 第一次没有带 Unity 桌面发布。
当然，主流媒体对 Unity 的未来感到好奇，因此 Mark Shuttleworth [向 eWeek](http://www.eweek.com/enterprise-apps/canonical-on-path-to-ipo-as-ubuntu-unity-linux-desktop-gets-ditched) 详细介绍了他决定在 Ubuntu 路线图中抛弃 Unity 的原因。
简而言之就是他把驱逐 Unity 作为节约成本的一部分，旨在使 Canonical 走上 IPO 的道路。
是的，投资者来了。
但是完整采访提供了更多关于这个决定的更多内容，并且披露了放弃曾经悉心培养的桌面对他而言是多么艰难。
### “Ubuntu 已经进入主流”
Mark Shuttleworth 和 [Sean Michael Kerner](https://twitter.com/TechJournalist) 的谈话，首先提醒了我们 Ubuntu 有多么伟大：
>
> “Ubuntu 的美妙之处在于，我们创造了一个对终端用户免费，并围绕其提供商业服务的平台，在这个梦想中，我们可以用各种不同的方式定义未来。
>
>
> 我们确实已经看到，Ubuntu 在很多领域已经进入了主流。”
>
>
>
但是受欢迎并不意味着盈利，Mark 指出：
>
> “我们现在所做的一些事情很明显在商业上是不可能永远持续的，而另外一些事情无疑商业上是可持续发展的，或者已经在商业上可持续。
>
>
> 只要我们还是一个纯粹的私人公司，我们就有完全的自由裁量权来决定是否支持那些商业上不可持续的事情。”
>
>
>
Shuttleworth 说，他和 Canonical 的其他“领导”通过协商一致认为，他们应该让公司走上成为上市公司的道路。
为了吸引潜在的投资者，公司必须把重点放在盈利领域 —— 而 Unity、Ubuntu 电话、Unity 8 以及<ruby> 融合 <rt> convergence </rt></ruby>不属于这个部分：
>
> “[这个决定]意味着我们不能让我们的名册中拥有那些根本没有商业前景实际上却非常重大的项目。
>
>
> 这并不意味着我们会考虑改变 Ubuntu 的条款，因为它是我们所做的一切的基础。而且实际上，我们也没有必要。”
>
>
>
### “Ubuntu 本身现在完全可持续发展”
钱可能意味着 Unity 的消亡，但会让更广泛的 Ubuntu 项目健康发展。正如 Shuttleworth 解释说的：
>
> “我最为自豪的事情之一就是在过去的 7 年中，Ubuntu 本身变得完全可持续发展。即使明天我被车撞倒，而 Ubuntu 也可以继续发展下去。
>
>
> 这很神奇吧？对吧？这是一个世界级的企业平台，它不仅完全免费，而且是可持续的。
>
>
> 这主要要感谢 Jane Silber。” （LCTT 译注：Canonical 公司的 CEO）
>
>
>
虽然桌面用户都会关注桌面，但比起我们期待的每 6 个月发布的版本，对 Canonical 公司的关注显然要多得多。
失去 Unity 对桌面用户可能是一个沉重打击，但它有助于平衡公司的其他部分：
>
> “除此之外，我们在企业中还有巨大的可能性，比如在真正定义云基础设施是如何构建的方面，云应用程序是如何操作的等等。而且，在物联网中，看看下一波的可能性，那些创新者们正在基于物联网创造的东西。
>
>
> 所有这些都足以让我们在这方面进行 IPO。”
>
>
>
然而，对于 Mark 来说，放弃 Unity 并不容易，
>
> “我们在 Unity 上做了很多工作，我真的很喜欢它。
>
>
> 我认为 Unity 8 工程非常棒，而且如何将这些不同形式的要素结合在一起的深层理念是非常迷人的。”
>
>
> “但是，如果我们要走上 IPO 的道路，我不能再为将它留在 Canonical 来争论了。
>
>
> 在某个阶段你们应该会看到，我想我们很快就会宣布，没有 Unity， 我们实际上已经几乎打破了我们在商业上所做的所有事情。”
>
>
>
在这之后不久，他说公司可能会进行第一轮用于增长的投资，以此作为转变为正式上市公司前的过渡。
但 Mark 并不想让任何人认为投资者会 “毁了派对”：
>
> “我们还没沦落到需要根据风投的指示来行动的地步。我们清楚地看到了我们的客户喜欢什么，我们已经找到了适用于云和物联网的很好的市场着力点和产品。”
>
>
>
Mark 补充到，Canonical 公司的团队对这个决定 “无疑很兴奋”。
>
> “在情感上，我不想再经历这样的过程。我对 Unity 做了一些误判。我曾天真的认为业界会支持一个独立自由平台的想法。
>
>
> 但我也不后悔做过这件事。很多人会抱怨他们的选择，而不去创造其他选择。
>
>
> 事实证明，这需要一点勇气以及相当多的钱去尝试和创造这些选择。”
>
>
>
### OMG! IPO? NO!
在对 Canonical（可能）成为一家上市公司的观念进行争辩之前，我们要记住，**RedHat 已经是一家 20 年之久的上市公司了**。GNOME 桌面和 Fedora 在没有任何 “赚钱” 措施的干预下也都活得很不错。
Canonical 的 IPO 不太可能对 Ubuntu 产生突然的引人注目的的改变，因为就像 Shuttleworth 自己所说的那样，这是其它所有东西得以成立的基础。
Ubuntu 是已被认可的。这是云上的头号操作系统。它是世界上最受欢迎的 Linux 发行版（除了 [Distrowatch 排名](http://distrowatch.com/table.php?distribution=ubuntu)）。并且它似乎在物联网上也有巨大的应用前景。
Mark 说 Ubuntu 现在是完全可持续发展的。
随着一个[迎接 Ubuntu 17.10 到来的热烈招待会](http://www.omgubuntu.co.uk/2017/10/ubuntu-17-10-review-roundup)，以及一个新的 LTS 将要发布，事情看起来相当不错……
---
via: <http://www.omgubuntu.co.uk/2017/10/why-did-ubuntu-drop-unity-mark-shuttleworth-explains>
作者：[JOEY SNEDDON](https://plus.google.com/117485690627814051450/?rel=author) 译者：[Snapcrafter](https://github.com/Snapcrafter)，[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 GitLab 我们是如何扩展数据库的
|
Yorick Peterse
|
https://about.gitlab.com/2017/10/02/scaling-the-gitlab-database/
|
很长时间以来 GitLab.com 使用了一个单个的 PostgreSQL 数据库服务器和一个用于灾难恢复的单个复制。在 GitLab.com 最初的几年，它工作的还是很好的，但是，随着时间的推移，我们看到这种设置的很多问题，在这篇文章中，我们将带你了解我们在帮助解决 GitLab.com 和 GitLab 实例所在的主机时都做了些什么。
|
/data/attachment/album/201711/11/141056bqycq96dnyy9qumh.jpg.thumb.jpg
|
/data/attachment/album/201711/11/141056bqycq96dnyy9qumh.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"数据库",
"PostgreSQL",
"GitLab"
] |
技术
|
{
"viewnum": 6917,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
很长时间以来 GitLab.com 使用了一个单个的 PostgreSQL 数据库服务器和一个用于灾难恢复的单个复制。在 GitLab.com 最初的几年，它工作的还是很好的，但是，随着时间的推移，我们看到这种设置的很多问题，在这篇文章中，我们将带你了解我们在帮助解决 GitLab.com 和 GitLab 实例所在的主机时都做了些什么。
| 2017-11-11T14:10:00
| 2017-11-11T14:10:00
| 9,048
|
/article-9048-1.html
|
>
> 在扩展 GitLab 数据库和我们应用的解决方案，去帮助解决我们的数据库设置中的问题时，我们深入分析了所面临的挑战。
>
>
>
很长时间以来 GitLab.com 使用了一个单个的 PostgreSQL 数据库服务器和一个用于灾难恢复的单个复制。在 GitLab.com 最初的几年，它工作的还是很好的，但是，随着时间的推移，我们看到这种设置的很多问题，在这篇文章中，我们将带你了解我们在帮助解决 GitLab.com 和 GitLab 实例所在的主机时都做了些什么。
例如，数据库长久处于重压之下， CPU 使用率几乎所有时间都处于 70% 左右。并不是因为我们以最好的方式使用了全部的可用资源，而是因为我们使用了太多的（未经优化的）查询去“冲击”服务器。我们意识到需要去优化设置，这样我们就可以平衡负载，使 GitLab.com 能够更灵活地应对可能出现在主数据库服务器上的任何问题。
在我们使用 PostgreSQL 去跟踪这些问题时，使用了以下的四种技术：
1. 优化你的应用程序代码，以使查询更加高效（并且理论上使用了很少的资源）。
2. 使用一个连接池去减少必需的数据库连接数量（及相关的资源）。
3. 跨多个数据库服务器去平衡负载。
4. 分片你的数据库
在过去的两年里，我们一直在积极地优化应用程序代码，但它不是一个完美的解决方案，甚至，如果你改善了性能，当流量也增加时，你还需要去应用其它的几种技术。出于本文的目的，我们将跳过优化应用代码这个特定主题，而专注于其它技术。
### 连接池
在 PostgreSQL 中，一个连接是通过启动一个操作系统进程来处理的，这反过来又需要大量的资源，更多的连接（及这些进程）将使用你的数据库上的更多的资源。 PostgreSQL 也在 [max\_connections](https://www.postgresql.org/docs/9.6/static/runtime-config-connection.html#GUC-MAX-CONNECTIONS) 设置中定义了一个强制的最大连接数量。一旦达到这个限制，PostgreSQL 将拒绝新的连接， 比如，下面的图表示的设置：
这里我们的客户端直接连接到 PostgreSQL，这样每个客户端请求一个连接。
通过连接池，我们可以有多个客户端侧的连接重复使用一个 PostgreSQL 连接。例如，没有连接池时，我们需要 100 个 PostgreSQL 连接去处理 100 个客户端连接；使用连接池后，我们仅需要 10 个，或者依据我们配置的 PostgreSQL 连接。这意味着我们的连接图表将变成下面看到的那样：
这里我们展示了一个示例，四个客户端连接到 pgbouncer，但不是使用了四个 PostgreSQL 连接，而是仅需要两个。
对于 PostgreSQL 有两个最常用的连接池：
* [pgbouncer](https://pgbouncer.github.io/)
* [pgpool-II](http://pgpool.net/mediawiki/index.php/Main_Page)
pgpool 有一点特殊，因为它不仅仅是连接池：它有一个内置的查询缓存机制，可以跨多个数据库负载均衡、管理复制等等。
另一个 pgbouncer 是很简单的：它就是一个连接池。
### 数据库负载均衡
数据库级的负载均衡一般是使用 PostgreSQL 的 “<ruby> <a href="https://www.postgresql.org/docs/9.6/static/hot-standby.html"> 热备机 </a> <rt> hot-standby </rt></ruby>” 特性来实现的。 热备机是允许你去运行只读 SQL 查询的 PostgreSQL 副本，与不允许运行任何 SQL 查询的普通<ruby> 备用机 <rt> standby </rt></ruby>相反。要使用负载均衡，你需要设置一个或多个热备服务器，并且以某些方式去平衡这些跨主机的只读查询，同时将其它操作发送到主服务器上。扩展这样的一个设置是很容易的：（如果需要的话）简单地增加多个热备机以增加只读流量。
这种方法的另一个好处是拥有一个更具弹性的数据库集群。即使主服务器出现问题，仅使用次级服务器也可以继续处理 Web 请求；当然，如果这些请求最终使用主服务器，你可能仍然会遇到错误。
然而，这种方法很难实现。例如，一旦它们包含写操作，事务显然需要在主服务器上运行。此外，在写操作完成之后，我们希望继续使用主服务器一会儿，因为在使用异步复制的时候，热备机服务器上可能还没有这些更改。
### 分片
分片是水平分割你的数据的行为。这意味着数据保存在特定的服务器上并且使用一个分片键检索。例如，你可以按项目分片数据并且使用项目 ID 做为分片键。当你的写负载很高时，分片数据库是很有用的（除了一个多主设置外，均衡写操作没有其它的简单方法），或者当你有*大量*的数据并且你不再使用传统方式保存它也是有用的（比如，你不能把它简单地全部放进一个单个磁盘中）。
不幸的是，设置分片数据库是一个任务量很大的过程，甚至，在我们使用诸如 [Citus](https://www.citusdata.com/) 的软件时也是这样。你不仅需要设置基础设施 （不同的复杂程序取决于是你运行在你自己的数据中心还是托管主机的解决方案），你还得需要调整你的应用程序中很大的一部分去支持分片。
#### 反对分片的案例
在 GitLab.com 上一般情况下写负载是非常低的，同时大多数的查询都是只读查询。在极端情况下，尖峰值达到每秒 1500 元组写入，但是，在大多数情况下不超过每秒 200 元组写入。另一方面，我们可以在任何给定的次级服务器上轻松达到每秒 1000 万元组读取。
存储方面，我们也不使用太多的数据：大约 800 GB。这些数据中的很大一部分是在后台迁移的，这些数据一经迁移后，我们的数据库收缩的相当多。
接下来的工作量就是调整应用程序，以便于所有查询都可以正确地使用分片键。 我们的一些查询包含了一个项目 ID，它是我们使用的分片键，也有许多查询没有包含这个分片键。分片也会影响提交到 GitLab 的改变内容的过程，每个提交者现在必须确保在他们的查询中包含分片键。
最后，是完成这些工作所需要的基础设施。服务器已经完成设置，监视也添加了、工程师们必须培训，以便于他们熟悉上面列出的这些新的设置。虽然托管解决方案可能不需要你自己管理服务器，但它不能解决所有问题。工程师们仍然需要去培训（很可能非常昂贵）并需要为此支付账单。在 GitLab 上，我们也非常乐意提供我们用过的这些工具，这样社区就可以使用它们。这意味着如果我们去分片数据库， 我们将在我们的 Omnibus 包中提供它（或至少是其中的一部分）。确保你提供的服务的唯一方法就是你自己去管理它，这意味着我们不能使用主机托管的解决方案。
最终，我们决定不使用数据库分片，因为它是昂贵的、费时的、复杂的解决方案。
### GitLab 的连接池
对于连接池我们有两个主要的诉求：
1. 它必须工作的很好（很显然这是必需的）。
2. 它必须易于在我们的 Omnibus 包中运用，以便于我们的用户也可以从连接池中得到好处。
用下面两步去评估这两个解决方案（pgpool 和 pgbouncer）：
1. 执行各种技术测试（是否有效，配置是否容易，等等）。
2. 找出使用这个解决方案的其它用户的经验，他们遇到了什么问题？怎么去解决的？等等。
pgpool 是我们考察的第一个解决方案，主要是因为它提供的很多特性看起来很有吸引力。我们其中的一些测试数据可以在 [这里](https://gitlab.com/gitlab-com/infrastructure/issues/259#note_23464570) 找到。
最终，基于多个因素，我们决定不使用 pgpool 。例如， pgpool 不支持<ruby> 粘连接 <rt> sticky connection </rt></ruby>。 当执行一个写入并（尝试）立即显示结果时，它会出现问题。想像一下，创建一个<ruby> 工单 <rt> issue </rt></ruby>并立即重定向到这个页面， 没有想到会出现 HTTP 404，这是因为任何用于只读查询的服务器还没有收到数据。针对这种情况的一种解决办法是使用同步复制，但这会给表带来更多的其它问题，而我们希望避免这些问题。
另一个问题是， pgpool 的负载均衡逻辑与你的应用程序是不相干的，是通过解析 SQL 查询并将它们发送到正确的服务器。因为这发生在你的应用程序之外，你几乎无法控制查询运行在哪里。这实际上对某些人也可能是有好处的， 因为你不需要额外的应用程序逻辑。但是，它也妨碍了你在需要的情况下调整路由逻辑。
由于配置选项非常多，配置 pgpool 也是很困难的。或许促使我们最终决定不使用它的原因是我们从过去使用过它的那些人中得到的反馈。即使是在大多数的案例都不是很详细的情况下，我们收到的反馈对 pgpool 通常都持有负面的观点。虽然出现的报怨大多数都与早期版本的 pgpool 有关，但仍然让我们怀疑使用它是否是个正确的选择。
结合上面描述的问题和反馈，最终我们决定不使用 pgpool 而是使用 pgbouncer 。我们用 pgbouncer 执行了一套类似的测试，并且对它的结果是非常满意的。它非常容易配置（而且一开始不需要很多的配置），运用相对容易，仅专注于连接池（而且它真的很好），而且没有明显的负载开销（如果有的话）。也许我唯一的报怨是，pgbouncer 的网站有点难以导航。
使用 pgbouncer 后，通过使用<ruby> 事务池 <rt> transaction pooling </rt></ruby>我们可以将活动的 PostgreSQL 连接数从几百个降到仅 10 - 20 个。我们选择事务池是因为 Rails 数据库连接是持久的。这个设置中，使用<ruby> 会话池 <rt> session pooling </rt></ruby>不能让我们降低 PostgreSQL 连接数，从而受益（如果有的话）。通过使用事务池，我们可以调低 PostgreSQL 的 `max_connections` 的设置值，从 3000 （这个特定值的原因我们也不清楚) 到 300 。这样配置的 pgbouncer ，即使在尖峰时，我们也仅需要 200 个连接，这为我们提供了一些额外连接的空间，如 `psql` 控制台和维护任务。
对于使用事务池的负面影响方面，你不能使用预处理语句，因为 `PREPARE` 和 `EXECUTE` 命令也许最终在不同的连接中运行，从而产生错误的结果。 幸运的是，当我们禁用了预处理语句时，并没有测量到任何响应时间的增加，但是我们 *确定* 测量到在我们的数据库服务器上内存使用减少了大约 20 GB。
为确保我们的 web 请求和后台作业都有可用连接，我们设置了两个独立的池： 一个有 150 个连接的后台进程连接池，和一个有 50 个连接的 web 请求连接池。对于 web 连接需要的请求，我们很少超过 20 个，但是，对于后台进程，由于在 GitLab.com 上后台运行着大量的进程，我们的尖峰值可以很容易达到 100 个连接。
今天，我们提供 pgbouncer 作为 GitLab EE 高可用包的一部分。对于更多的信息，你可以参考 “[Omnibus GitLab PostgreSQL High Availability](https://docs.gitlab.com/ee/administration/high_availability/alpha_database.html)”。
### GitLab 上的数据库负载均衡
使用 pgpool 和它的负载均衡特性，我们需要一些其它的东西去分发负载到多个热备服务器上。
对于（但不限于） Rails 应用程序，它有一个叫 [Makara](https://github.com/taskrabbit/makara) 的库，它实现了负载均衡的逻辑并包含了一个 ActiveRecord 的缺省实现。然而，Makara 也有一些我们认为是有些遗憾的问题。例如，它支持的粘连接是非常有限的：当你使用一个 cookie 和一个固定的 TTL 去执行一个写操作时，连接将粘到主服务器。这意味着，如果复制极大地滞后于 TTL，最终你可能会发现，你的查询运行在一个没有你需要的数据的主机上。
Makara 也需要你做很多配置，如所有的数据库主机和它们的角色，没有服务发现机制（我们当前的解决方案也不支持它们，即使它是将来计划的）。 Makara 也 [似乎不是线程安全的](https://github.com/taskrabbit/makara/issues/151)，这是有问题的，因为 Sidekiq （我们使用的后台进程）是多线程的。 最终，我们希望尽可能地去控制负载均衡的逻辑。
除了 Makara 之外 ，还有一个 [Octopus](https://github.com/thiagopradi/octopus) ，它也是内置的负载均衡机制。但是 Octopus 是面向分片数据库的，而不仅是均衡只读查询的。因此，最终我们不考虑使用 Octopus。
最终，我们直接在 GitLab EE构建了自己的解决方案。 添加初始实现的<ruby> 合并请求 <rt> merge request </rt></ruby>可以在 [这里](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/1283)找到，尽管一些更改、提升和修复是以后增加的。
我们的解决方案本质上是通过用一个处理查询的路由的代理对象替换 `ActiveRecord::Base.connection` 。这可以让我们均衡负载尽可能多的查询，甚至，包括不是直接来自我们的代码中的查询。这个代理对象基于调用方式去决定将查询转发到哪个主机， 消除了解析 SQL 查询的需要。
#### 粘连接
粘连接是通过在执行写入时，将当前 PostgreSQL WAL 位置存储到一个指针中实现支持的。在请求即将结束时，指针短期保存在 Redis 中。每个用户提供他自己的 key，因此，一个用户的动作不会导致其他的用户受到影响。下次请求时，我们取得指针，并且与所有的次级服务器进行比较。如果所有的次级服务器都有一个超过我们的指针的 WAL 指针，那么我们知道它们是同步的，我们可以为我们的只读查询安全地使用次级服务器。如果一个或多个次级服务器没有同步，我们将继续使用主服务器直到它们同步。如果 30 秒内没有写入操作，并且所有的次级服务器还没有同步，我们将恢复使用次级服务器，这是为了防止有些人的查询永远运行在主服务器上。
检查一个次级服务器是否就绪十分简单，它在如下的 `Gitlab::Database::LoadBalancing::Host#caught_up?` 中实现：
```
def caught_up?(location)
string = connection.quote(location)
query = "SELECT NOT pg_is_in_recovery() OR " \
"pg_xlog_location_diff(pg_last_xlog_replay_location(), #{string}) >= 0 AS result"
row = connection.select_all(query).first
row && row['result'] == 't'
ensure
release_connection
end
```
这里的大部分代码是运行原生查询（raw queries）和获取结果的标准的 Rails 代码，查询的最有趣的部分如下：
```
SELECT NOT pg_is_in_recovery()
OR pg_xlog_location_diff(pg_last_xlog_replay_location(), WAL-POINTER) >= 0 AS result"
```
这里 `WAL-POINTER` 是 WAL 指针，通过 PostgreSQL 函数 `pg_current_xlog_insert_location()` 返回的，它是在主服务器上执行的。在上面的代码片断中，该指针作为一个参数传递，然后它被引用或转义，并传递给查询。
使用函数 `pg_last_xlog_replay_location()` 我们可以取得次级服务器的 WAL 指针，然后，我们可以通过函数 `pg_xlog_location_diff()` 与我们的主服务器上的指针进行比较。如果结果大于 0 ，我们就可以知道次级服务器是同步的。
当一个次级服务器被提升为主服务器，并且我们的 GitLab 进程还不知道这一点的时候，添加检查 `NOT pg_is_in_recovery()` 以确保查询不会失败。在这个案例中，主服务器总是与它自己是同步的，所以它简单返回一个 `true`。
#### 后台进程
我们的后台进程代码 *总是* 使用主服务器，因为在后台执行的大部分工作都是写入。此外，我们不能可靠地使用一个热备机，因为我们无法知道作业是否在主服务器执行，也因为许多作业并没有直接绑定到用户上。
#### 连接错误
要处理连接错误，比如负载均衡器不会使用一个视作离线的次级服务器，会增加主机上（包括主服务器）的连接错误，将会导致负载均衡器多次重试。这是确保，在遇到偶发的小问题或数据库失败事件时，不会立即显示一个错误页面。当我们在负载均衡器级别上处理 [热备机冲突](https://www.postgresql.org/docs/current/static/hot-standby.html#HOT-STANDBY-CONFLICT) 的问题时，我们最终在次级服务器上启用了 `hot_standby_feedback` ，这样就解决了热备机冲突的所有问题，而不会对表膨胀造成任何负面影响。
我们使用的过程很简单：对于次级服务器，我们在它们之间用无延迟试了几次。对于主服务器，我们通过使用越来越快的回退尝试几次。
更多信息你可以查看 GitLab EE 上的源代码：
* <https://gitlab.com/gitlab-org/gitlab-ee/tree/master/lib/gitlab/database/load_balancing.rb>
* <https://gitlab.com/gitlab-org/gitlab-ee/tree/master/lib/gitlab/database/load_balancing>
数据库负载均衡首次引入是在 GitLab 9.0 中，并且 *仅* 支持 PostgreSQL。更多信息可以在 [9.0 release post](https://about.gitlab.com/2017/03/22/gitlab-9-0-released/) 和 [documentation](https://docs.gitlab.com/ee/administration/database_load_balancing.html) 中找到。
### Crunchy Data
我们与 [Crunchy Data](https://www.crunchydata.com/) 一起协同工作来部署连接池和负载均衡。不久之前我还是唯一的 [数据库专家](https://about.gitlab.com/handbook/infrastructure/database/)，它意味着我有很多工作要做。此外，我对 PostgreSQL 的内部细节的和它大量的设置所知有限 (或者至少现在是)，这意味着我能做的也有限。因为这些原因，我们雇用了 Crunchy 去帮我们找出问题、研究慢查询、建议模式优化、优化 PostgreSQL 设置等等。
在合作期间，大部分工作都是在相互信任的基础上完成的，因此，我们共享私人数据，比如日志。在合作结束时，我们从一些资料和公开的内容中删除了敏感数据，主要的资料在 [gitlab-com/infrastructure#1448](https://gitlab.com/gitlab-com/infrastructure/issues/1448)，这又反过来导致产生和解决了许多分立的问题。
这次合作的好处是巨大的，它帮助我们发现并解决了许多的问题，如果必须我们自己来做的话，我们可能需要花上几个月的时间来识别和解决它。
幸运的是，最近我们成功地雇佣了我们的 [第二个数据库专家](https://gitlab.com/_stark) 并且我们希望以后我们的团队能够发展壮大。
### 整合连接池和数据库负载均衡
整合连接池和数据库负载均衡可以让我们去大幅减少运行数据库集群所需要的资源和在分发到热备机上的负载。例如，以前我们的主服务器 CPU 使用率一直徘徊在 70%，现在它一般在 10% 到 20% 之间，而我们的两台热备机服务器则大部分时间在 20% 左右：
在这里， `db3.cluster.gitlab.com` 是我们的主服务器，而其它的两台是我们的次级服务器。
其它的负载相关的因素，如平均负载、磁盘使用、内存使用也大为改善。例如，主服务器现在的平均负载几乎不会超过 10，而不像以前它一直徘徊在 20 左右：
在业务繁忙期间，我们的次级服务器每秒事务数在 12000 左右（大约为每分钟 740000），而主服务器每秒事务数在 6000 左右（大约每分钟 340000）：
可惜的是，在部署 pgbouncer 和我们的数据库负载均衡器之前，我们没有关于事务速率的任何数据。
我们的 PostgreSQL 的最新统计数据的摘要可以在我们的 [public Grafana dashboard](http://monitor.gitlab.net/dashboard/db/postgres-stats?refresh=5m&orgId=1) 上找到。
我们的其中一些 pgbouncer 的设置如下：
| 设置 | 值 |
| --- | --- |
| `default_pool_size` | 100 |
| `reserve_pool_size` | 5 |
| `reserve_pool_timeout` | 3 |
| `max_client_conn` | 2048 |
| `pool_mode` | transaction |
| `server_idle_timeout` | 30 |
除了前面所说的这些外，还有一些工作要作，比如： 部署服务发现（[#2042](https://gitlab.com/gitlab-org/gitlab-ee/issues/2042)）， 持续改善如何检查次级服务器是否可用（[#2866](https://gitlab.com/gitlab-org/gitlab-ee/issues/2866)），和忽略落后于主服务器太多的次级服务器 （[#2197](https://gitlab.com/gitlab-org/gitlab-ee/issues/2197)）。
值得一提的是，到目前为止，我们还没有任何计划将我们的负载均衡解决方案，独立打包成一个你可以在 GitLab 之外使用的库，相反，我们的重点是为 GitLab EE 提供一个可靠的负载均衡解决方案。
如果你对它感兴趣，并喜欢使用数据库、改善应用程序性能、给 GitLab上增加数据库相关的特性（比如： [服务发现](https://gitlab.com/gitlab-org/gitlab-ee/issues/2042)），你一定要去查看一下我们的 [招聘职位](https://about.gitlab.com/jobs/specialist/database/) 和 [数据库专家手册](https://about.gitlab.com/handbook/infrastructure/database/) 去获取更多信息。
---
via: <https://about.gitlab.com/2017/10/02/scaling-the-gitlab-database/>
作者：[Yorick Peterse](https://about.gitlab.com/team/#yorickpeterse) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
由 KRACK 攻击想到的确保网络安全的小贴士
|
Konstantin Ryabitsev
|
https://www.linux.com/blog/2017/10/tips-secure-your-network-wake-krack
|
最近的 KRACK （密钥重装攻击）漏洞攻击的目标是位于你的设备和 Wi-Fi 访问点之间的链路，这个访问点或许是在你家里、办公室中、或你喜欢的咖啡吧中的任何一台路由器。这些提示能帮你提升你的连接的安全性。
|
/data/attachment/album/201711/11/235930sejrxs44dzvej4nm.jpg.thumb.jpg
|
/data/attachment/album/201711/11/235930sejrxs44dzvej4nm.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"安全",
"KRACK",
"无线网",
"WIFI"
] |
技术
|
{
"viewnum": 4533,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "182.160.105.186",
"message": "bdmarket.blogspot.com",
"username": "来自孟加拉的 Chrome 79.0|Windows 10 用户",
"date": "2020-01-21T19:47:12"
}
] |
[] |
最近的 KRACK （密钥重装攻击）漏洞攻击的目标是位于你的设备和 Wi-Fi 访问点之间的链路，这个访问点或许是在你家里、办公室中、或你喜欢的咖啡吧中的任何一台路由器。这些提示能帮你提升你的连接的安全性。
| 2017-11-11T23:59:00
| 2017-11-11T23:59:00
| 9,049
|
/article-9049-1.html
|
>
> 最近的 KRACK （密钥重装攻击，这是一个安全漏洞名称或该漏洞利用攻击行为的名称）漏洞攻击的目标是位于你的设备和 Wi-Fi 访问点之间的链路，这个访问点或许是在你家里、办公室中、或你喜欢的咖啡吧中的任何一台路由器。这些提示能帮你提升你的连接的安全性。
>
>
>
[KRACK 漏洞攻击](https://www.krackattacks.com/) 出现已经一段时间了，并且已经在 [相关技术网站](https://blog.cryptographyengineering.com/2017/10/16/falling-through-the-kracks/) 上有很多详细的讨论，因此，我将不在这里重复攻击的技术细节。攻击方式的总结如下：
* 在 WPA2 无线握手协议中的一个缺陷允许攻击者在你的设备和 wi-fi 访问点之间嗅探或操纵通讯。
* 这个问题在 Linux 和 Android 设备上尤其严重，由于在 WPA2 标准中的措辞含糊不清，也或许是在实现它时的错误理解，事实上，在底层的操作系统打完补丁以前，该漏洞一直可以强制无线流量以无加密方式通讯。
* 还好这个漏洞可以在客户端上修补，因此，天并没有塌下来，而且，WPA2 加密标准并没有像 WEP 标准那样被淘汰（不要通过切换到 WEP 加密的方式去“修复”这个问题）。
* 大多数流行的 Linux 发行版都已经通过升级修复了这个客户端上的漏洞，因此，老老实实地去更新它吧。
* Android 也很快修复了这个漏洞。如果你的设备在接收 Android 安全补丁，你会很快修复这个漏洞。如果你的设备不再接收这些更新，那么，这个特别的漏洞将是你停止使用你的旧设备的一个理由。
即使如此，从我的观点来看， Wi-Fi 是不可信任的基础设施链中的另一个环节，并且，我们应该完全避免将其视为可信任的通信通道。
### Wi-Fi 是不受信任的基础设备
如果从你的笔记本电脑或移动设备中读到这篇文章，那么，你的通信链路看起来应该是这样：
KRACK 攻击目标是在你的设备和 Wi-Fi 访问点之间的链接，访问点或许是在你家里、办公室中、或你喜欢的咖啡吧中的任何一台路由器。
实际上，这个图示应该看起来像这样：
Wi-Fi 仅仅是在我们所不应该信任的信道上的长长的通信链的第一个链路。让我来猜猜，你使用的 Wi-Fi 路由器或许从开始使用的第一天气就没有得到过一个安全更新，并且，更糟糕的是，它或许使用了一个从未被更改过的、缺省的、易猜出的管理凭据（用户名和密码）。除非你自己安装并配置你的路由器，并且你能记得你上次更新的它的固件的时间，否则，你应该假设现在它已经被一些人控制并不能信任的。
在 Wi-Fi 路由器之后，我们的通讯进入一般意义上的常见不信任区域 —— 这要根据你的猜疑水平。这里有上游的 ISP 和接入提供商，其中的很多已经被指认监视、更改、分析和销售我们的流量数据，试图从我们的浏览习惯中挣更多的钱。通常他们的安全补丁计划辜负了我们的期望，最终让我们的流量暴露在一些恶意者眼中。
一般来说，在互联网上，我们还必须担心强大的国家级的参与者能够操纵核心网络协议，以执行大规模的网络监视和状态级的流量过滤。
### HTTPS 协议
值的庆幸的是，我们有一个基于不信任的介质进行安全通讯的解决方案，并且，我们可以每天都能使用它 —— 这就是 HTTPS 协议，它加密你的点对点的互联网通讯，并且确保我们可以信任站点与我们之间的通讯。
Linux 基金会的一些措施，比如像 [Let’s Encrypt](https://letsencrypt.org/) 使世界各地的网站所有者都可以很容易地提供端到端的加密，这有助于确保我们的个人设备与我们试图访问的网站之间的任何有安全隐患的设备不再是个问题。
是的... 基本没关系。
### DNS —— 剩下的一个问题
虽然，我们可以尽量使用 HTTPS 去创建一个可信的通信信道，但是，这里仍然有一个攻击者可以访问我们的路由器或修改我们的 Wi-Fi 流量的机会 —— 在使用 KRACK 的这个案例中 —— 可以欺骗我们的通讯进入一个错误的网站。他们可以利用我们仍然非常依赖 DNS 的这一事实 —— 这是一个未加密的、易受欺骗的 [诞生自上世纪 80 年代的协议](https://en.wikipedia.org/wiki/Domain_Name_System#History)。
DNS 是一个将像 “linux.com” 这样人类友好的域名，转换成计算机可以用于和其它计算机通讯的 IP 地址的一个系统。要转换一个域名到一个 IP 地址，计算机将会查询解析器软件 —— 它通常运行在 Wi-Fi 路由器或一个系统上。解析器软件将查询一个分布式的“根”域名服务器网络，去找到在互联网上哪个系统有 “linux.com” 域名所对应的 IP 地址的“权威”信息。
麻烦就在于，所有发生的这些通讯都是未经认证的、[易于欺骗的](https://en.wikipedia.org/wiki/DNS_spoofing)、明文协议、并且响应可以很容易地被攻击者修改，去返回一个不正确的数据。如果有人去欺骗一个 DNS 查询并且返回错误的 IP 地址，他们可以操纵我们的系统最终发送 HTTP 请求到那里。
幸运的是，HTTPS 有一些内置的保护措施去确保它不会很容易地被其它人诱导至其它假冒站点。恶意服务器上的 TLS 凭据必须与你请求的 DNS 名字匹配 —— 并且它必须由一个你的浏览器认可的信誉良好的 [认证机构（CA）](https://en.wikipedia.org/wiki/Certificate_authority) 所签发。如果不是这种情况，你的浏览器将在你试图去与他们告诉你的地址进行通讯时出现一个很大的警告。如果你看到这样的警告，在选择不理会警告之前，请你格外小心，因为，它有可能会把你的秘密泄露给那些可能会对付你的人。
如果攻击者完全控制了路由器，他们可以在一开始时，通过拦截来自服务器指示你建立一个安全连接的响应，以阻止你使用 HTTPS 连接（这被称为 “[SSL 脱衣攻击](https://en.wikipedia.org/wiki/Moxie_Marlinspike#Notable_research)”）。 为了帮助你防护这种类型的攻击，网站可以增加一个 [特殊响应头（HSTS）](https://en.wikipedia.org/wiki/HTTP_Strict_Transport_Security) 去告诉你的浏览器以后与它通讯时总是使用 HTTPS 协议，但是，这仅仅是在你首次访问之后的事。对于一些非常流行的站点，浏览器现在包含一个 [硬编码的域名列表](https://hstspreload.org/)，即使是首次连接，它也将总是使用 HTTPS 协议访问。
现在已经有了 DNS 欺骗的解决方案，它被称为 [DNSSEC](https://en.wikipedia.org/wiki/Domain_Name_System_Security_Extensions)，由于有重大的障碍 —— 真实和可感知的（LCTT 译注，指的是要求实名认证），它看起来接受程度很慢。在 DNSSEC 被普遍使用之前，我们必须假设，我们接收到的 DNS 信息是不能完全信任的。
### 使用 VPN 去解决“最后一公里”的安全问题
因此，如果你不能信任固件太旧的 Wi-Fi 和/或无线路由器，我们能做些什么来确保发生在你的设备与常说的互联网之间的“最后一公里”通讯的完整性呢？
一个可接受的解决方案是去使用信誉好的 VPN 供应商的服务，它将在你的系统和他们的基础设施之间建立一条安全的通讯链路。这里有一个期望，就是它比你的路由器提供者和你的当前互联网供应商更注重安全，因为，他们处于一个更好的位置去确保你的流量不会受到恶意的攻击或欺骗。在你的工作站和移动设备之间使用 VPN，可以确保免受像 KRACK 这样的漏洞攻击，不安全的路由器不会影响你与外界通讯的完整性。
这有一个很重要的警告是，当你选择一个 VPN 供应商时，你必须确信他们的信用；否则，你将被一拨恶意的人出卖给其它人。远离任何人提供的所谓“免费 VPN”，因为，它们可以通过监视你和向市场营销公司销售你的流量来赚钱。 [这个网站](https://www.vpnmentor.com/bestvpns/overall/) 是一个很好的资源，你可以去比较他们提供的各种 VPN，去看他们是怎么互相竞争的。
注意，你所有的设备都应该在它上面安装 VPN，那些你每天使用的网站，你的私人信息，尤其是任何与你的钱和你的身份（政府、银行网站、社交网络、等等）有关的东西都必须得到保护。VPN 并不是对付所有网络级漏洞的万能药，但是，当你在机场使用无法保证的 Wi-Fi 时，或者下次发现类似 KRACK 的漏洞时，它肯定会保护你。
---
via: <https://www.linux.com/blog/2017/10/tips-secure-your-network-wake-krack>
作者：[KONSTANTIN RYABITSEV](https://www.linux.com/users/mricon) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
瞬间提升命令行的生产力 100%
|
Nikita Sobolev
|
https://dev.to/sobolevn/instant-100-command-line-productivity-boost
|
这里有许多方式提升你的生产力。今天，我共享一些命令行的小技巧，以及让你的人生更轻松的小秘诀。
|
/data/attachment/album/201711/12/010750vk5tkm5ipkxxi59v.png.thumb.jpg
|
/data/attachment/album/201711/12/010750vk5tkm5ipkxxi59v.png
| true
| false
| true
|
qhwdw
| false
|
[
"命令行"
] |
技术
|
{
"viewnum": 7900,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
这里有许多方式提升你的生产力。今天，我共享一些命令行的小技巧，以及让你的人生更轻松的小秘诀。
| 2017-11-13T08:43:00
| 2017-11-13T08:43:00
| 9,050
|
/article-9050-1.html
|
关于生产力的话题总是让人充满兴趣的。
这里有许多方式提升你的生产力。今天，我共享一些命令行的小技巧，以及让你的人生更轻松的小秘诀。
### TL;DR
在本文中讨论的内容的全部设置及更多的信息，可以查看： <https://github.com/sobolevn/dotfiles> 。
### Shell
使用一个好用的，并且稳定的 shell 对你的命令行生产力是非常关键的。这儿有很多选择，我喜欢 `zsh` 和 `oh-my-zsh`。它是非常神奇的，理由如下：
* 自动补完几乎所有的东西
* 大量的插件
* 确实有用且能定制化的“提示符”
你可以通过下列的步骤去安装它：
1. 安装 `zsh`： <https://github.com/robbyrussell/oh-my-zsh/wiki/Installing-ZSH>
2. 安装 `oh-my-zsh`： <http://ohmyz.sh/>
3. 选择对你有用的插件： <https://github.com/robbyrussell/oh-my-zsh/wiki/Plugins>
你也可以调整你的设置以 [关闭自动补完的大小写敏感](https://github.com/sobolevn/dotfiles/blob/master/zshrc#L12) ，或改变你的 [命令行历史的工作方式](https://github.com/sobolevn/dotfiles/blob/master/zshrc#L24)。
就是这样。你将立马获得 +50% 的生产力提升。现在你可以打开足够多的选项卡（tab）了！（LCTT 译注：指多选项卡的命令行窗口）
### 主题
选择主题也很重要，因为你从头到尾都在看它。它必须是有用且漂亮的。我也喜欢简约的主题，因为它不包含一些视觉噪音和没用的信息。
你的主题将为你展示：
* 当前文件夹
* 当前的版本分支
* 当前版本库状态：干净或脏的（LCTT 译注：指是否有未提交版本库的内容）
* 任何的错误返回码（如果有）（LCTT 译注：Linux 命令如果执行错误，会返回错误码）
我也喜欢我的主题可以在新起的一行输入新命令，这样就有足够的空间去阅读和书写命令了。
我个人使用 [`sobole`](https://github.com/sobolevn/sobole-zsh-theme) 主题。它看起来非常棒，它有两种模式。
亮色的：
[](https://res.cloudinary.com/practicaldev/image/fetch/s--Lz_uthoR--/c_limit,f_auto,fl_progressive,q_auto,w_880/https://raw.githubusercontent.com/sobolevn/sobole-zsh-theme/master/showcases/env-and-user.png)
以及暗色的：
[](https://res.cloudinary.com/practicaldev/image/fetch/s--4o6hZwL9--/c_limit,f_auto,fl_progressive,q_auto,w_880/https://raw.githubusercontent.com/sobolevn/sobole-zsh-theme/master/showcases/dark-mode.png)
你得到了另外 +15% 的提升，以及一个看起来很漂亮的主题。
### 语法高亮
对我来说，从我的 shell 中得到足够的可视信息对做出正确的判断是非常重要的。比如 “这个命令有没有拼写错误？” 或者 “这个命令有相应的作用域吗？” 这样的提示。我经常会有拼写错误。
因此， [`zsh-syntax-highlighting`](https://github.com/zsh-users/zsh-syntax-highlighting) 对我是非常有用的。 它有合适的默认值，当然你可以 [改变任何你想要的设置](https://github.com/zsh-users/zsh-syntax-highlighting/blob/master/docs/highlighters.md)。
这个步骤可以带给我们额外的 +5% 的提升。
### 文件处理
我在我的目录中经常遍历许多文件，至少看起来很多。我经常做这些事情：
* 来回导航
* 列出文件和目录
* 显示文件内容
我喜欢去使用 [`z`](https://github.com/rupa/z) 导航到我已经去过的文件夹。这个工具是非常棒的。 它使用“<ruby> 近常 <rt> frecency </rt></ruby>” 方法来把你输入的 `.dot TAB` 转换成 `~/dev/shell/config/.dotfiles`。真的很不错！
当你显示文件时，你通常要了解如下几个内容：
* 文件名
* 权限
* 所有者
* 这个文件的 git 版本状态
* 修改日期
* 人类可读形式的文件大小
你也或许希望缺省展示隐藏文件。因此，我使用 [`exa`](https://github.com/ogham/exa) 来替代标准的 `ls`。为什么呢？因为它缺省启用了很多的东西：
[](https://res.cloudinary.com/practicaldev/image/fetch/s--n_YCO9Hj--/c_limit,f_auto,fl_progressive,q_auto,w_880/https://raw.githubusercontent.com/ogham/exa/master/screenshots.png)
要显示文件内容，我使用标准的 `cat`，或者，如果我希望看到语法高亮，我使用一个定制的别名：
```
# exa:
alias la="exa -abghl --git --color=automatic"
# `cat` with beautiful colors. requires: pip install -U Pygments
alias c='pygmentize -O style=borland -f console256 -g'
```
现在，你已经掌握了导航。它使你的生产力提升 +15% 。
### 搜索
当你在应用程序的源代码中搜索时，你不会想在你的搜索结果中缺省包含像 `node_modules` 或 `bower_components` 这样的文件夹。或者，当你想搜索执行的更快更流畅时。
这里有一个比内置的搜索方式更好的替代： [`the_silver_searcher`](https://github.com/ggreer/the_silver_searcher)。
它是用纯 `C` 写成的，并且使用了很多智能化的逻辑让它工作的更快。
在命令行 `history` 中，使用 `ctrl` + `R` 进行 [反向搜索](https://unix.stackexchange.com/questions/73498/how-to-cycle-through-reverse-i-search-in-bash) 是非常有用的。但是，你有没有发现你自己甚至不能完全记住一个命令呢？如果有一个工具可以模糊搜索而且用户界面更好呢？
这里确实有这样一个工具。它叫做 `fzf`：
它可以被用于任何模糊查询，而不仅是在命令行历史中，但它需要 [一些配置](https://github.com/sobolevn/dotfiles/blob/master/shell/.external#L19)。
你现在有了一个搜索工具，可以额外提升 +15% 的生产力。
### 延伸阅读
更好地使用命令行： <https://dev.to/sobolevn/using-better-clis-6o8>。
### 总结
通过这些简单的步骤，你可以显著提升你的命令行的生产力 +100% 以上（数字是估计的）。
这里还有其它的工具和技巧，我将在下一篇文章中介绍。
你喜欢阅读软件开发方面的最新趋势吗？在这里订阅我们的愽客吧 <https://medium.com/wemake-services>。
---
via: <https://dev.to/sobolevn/instant-100-command-line-productivity-boost>
作者：[Nikita Sobolev](https://dev.to/sobolevn) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开源软件对于商业机构的六个好处
|
Jos Poortvliet Feed
|
https://opensource.com/article/17/10/6-reasons-choose-open-source-software
|
在相同的基础上，开源软件要优于专有软件。想知道为什么？这里有六个商业机构及政府部门可以从开源技术中获得好处的原因。
|
/data/attachment/album/201711/12/130405rp72ztz7p0022qtv.jpeg.thumb.jpg
|
/data/attachment/album/201711/12/130405rp72ztz7p0022qtv.jpeg
| true
| false
| true
|
ZH1122
| false
|
[
"开源",
"商业"
] |
开源智慧
|
{
"viewnum": 5376,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在相同的基础上，开源软件要优于专有软件。想知道为什么？这里有六个商业机构及政府部门可以从开源技术中获得好处的原因。
| 2017-11-12T13:04:24
| 2017-11-12T13:04:24
| 9,051
|
/article-9051-1.html
|
>
> 这就是为什么商业机构应该选择开源模式的原因
>
>
>
在相同的基础上，开源软件要优于专有软件。想知道为什么？这里有六个商业机构及政府部门可以从开源技术中获得好处的原因。
### 1、 让供应商审核更简单
在你投入工程和金融资源将一个产品整合到你的基础设施之前，你需要知道你选择了正确的产品。你想要一个处于积极开发的产品，它有定期的安全更新和漏洞修复，同时在你有需求时，产品能有相应的更新。这最后一点也许比你想的还要重要：没错，解决方案一定是满足你的需求的。但是产品的需求随着市场的成熟以及你商业的发展在变化。如果该产品随之改变，在未来你需要花费很大的代价来进行迁移。
你怎么才能知道你没有正在把你的时间和资金投入到一个正在消亡的产品？在开源的世界里，你可以不选择一个只有卖家有话语权的供应商。你可以通过考虑[发展速度以及社区健康程度](https://nextcloud.com/blog/nextcloud-the-most-active-open-source-file-sync-and-share-project/)来比较供应商。一到两年之后，一个更活跃、多样性和健康的社区将开发出一个更好的产品，这是一个重要的考虑因素。当然，就像这篇 [关于企业开源软件的博文](http://www.redhat-cloudstrategy.com/open-source-for-business-people/) 指出的，供应商必须有能力处理由于项目发展创新带来的不稳定性。寻找一个有长支持周期的供应商来避免混乱的更新。
### 2、 来自独立性的长寿
福布斯杂志指出 [90%的初创公司是失败的](http://www.forbes.com/sites/neilpatel/2015/01/16/90-of-startups-will-fail-heres-what-you-need-to-know-about-the-10/) ，而他们中不到一半的中小型公司能存活超过五年。当你不得不迁移到一个新的供应商时，你花费的代价是昂贵的。所以最好避免一些只有一个供应商支持的产品。
开源使得社区成员能够协同编写软件。例如 OpenStack [是由许多公司以及个人志愿者一起编写的](http://stackalytics.com/)，这给客户提供了一个保证，不管任何一个独立供应商发生问题，也总会有一个供应商能提供支持。随着软件的开源，企业会长期投入开发团队，以实现产品开发。能够使用开源代码可以确保你总是能从贡献者中雇佣到人来保持你的开发活跃。当然，如果没有一个大的、活跃的社区，也就只有少量的贡献者能被雇佣，所以活跃贡献者的数量是重要的。
### 3、 安全性
安全是一件复杂的事情。这就是为什么开源开发是构建安全解决方案的关键因素和先决条件。同时每一天安全都在变得更重要。当开发以开源方式进行，你能直接的校验供应商是否积极的在追求安全，以及看到供应商是如何对待安全问题的。研究代码和执行独立代码审计的能力可以让供应商尽可能早的发现和修复漏洞。一些供应商给社区提供上千的美金的[漏洞奖金](https://hackerone.com/nextcloud)作为额外的奖励来鼓励开发者发现他们产品的安全漏洞，这同时也展示了供应商对于自己产品的信任。
除了代码，开源开发同样意味着开源过程，所以你能检查和看到供应商是否遵循 ISO27001、 [云安全准则](https://www.ncsc.gov.uk/guidance/implementing-cloud-security-principles) 及其他标准所推荐的工业级的开发过程。当然，一个可信组织外部检查提供了额外的保障，就像我们在 Nextcloud 与 [NCC小组](https://nextcloud.com/secure)合作的一样。
### 4、 更多的顾客导向
由于用户和顾客能直接看到和参与到产品的开发中，开源项目比那些只关注于营销团队回应的闭源软件更加的贴合用户的需求。你可以注意到开源软件项目趋向于以“宽松”方式发展。一个商业供应商也许关注在某个特定的事情方面，而一个社区则有许多要做的事情并致力于开发更多的功能，而这些全都是公司或个人贡献者中的某人或某些人所感兴趣的。这导致更少的为了销售而发布的版本，因为各种改进混搭在一起根本就不是一回事。但是它创造了许多对用户更有价值的产品。
### 5、 更好的支持
专有供应商通常是你遇到问题时唯一能给你提供帮助的一方。但如果他们不提供你所需要的服务，或者对调整你的商务需求收取额外昂贵的费用，那真是不好运。对专有软件提供的支持是一个典型的 “[柠檬市场](https://en.wikipedia.org/wiki/The_Market_for_Lemons)”。 随着软件的开源，供应商要么提供更大的支持，要么就有其它人来填补空白——这是自由市场的最佳选择，这可以确保你总是能得到最好的服务支持。
### 6、 更佳的许可
典型的软件许可证[充斥着令人不愉快的条款](http://boingboing.net/2016/11/01/why-are-license-agreements.html)，通常都是强制套利，你甚至不会有机会起诉供应商的不当行为。其中一个问题是你仅仅被授予了软件的使用权，这通常完全由供应商自行决定。如果软件不运行或者停止运行或者如果供应商要求支付更多的费用，你得不到软件的所有权或其他的权利。像 GPL 一类的开源许可证是为保护客户专门设计的，而不是保护供应商，它确保你可以如你所需的使用软件，而没有专制限制，只要你喜欢就行。
由于它们的广泛使用，GPL 的含义及其衍生出来的其他许可证得到了广泛的理解。例如，你能确保该许可允许你现存的基础设施（开源或闭源）通过设定好的 API 去进行连接，其没有时间或者是用户人数上的限制，同时也不会强迫你公开软件架构或者是知识产权（例如公司商标）。
这也让合规变得更加的容易；使用专有软件意味着你面临着苛刻的法规遵从性条款和高额的罚款。更糟糕的是一些<ruby> 开源内核 <rt> open core </rt></ruby>的产品在混合了 GPL 软件和专有软件。这[违反了许可证规定](https://www.gnu.org/licenses/gpl-faq.en.html#GPLPluginsInNF)并将顾客置于风险中。同时 Gartner 指出，开源内核模式意味着你[不能从开源中获利](http://blogs.gartner.com/brian_prentice/2010/03/31/open-core-the-emperors-new-clothes/)。纯净的开源许可的产品避免了所有这些问题。取而代之，你只需要遵从一个规则：如果你对代码做出了修改（不包括配置、商标或其他类似的东西），你必须将这些与你的软件分发随同分享，如果他们要求的话。
显然开源软件是更好的选择。它易于选择正确的供应商（不会被供应商锁定），加之你也可以受益于更安全、对客户更加关注和更好的支持。而最后，你将处于法律上的安全地位。
---
作者简介：
一个善于与人打交道的技术爱好者和开源传播者。Nextcloud 的销售主管，曾是 ownCloud 和 SUSE 的社区经理，同时还是一个有多年经验的 KDE 销售人员。喜欢骑自行车穿越柏林和为家人朋友做饭。[点击这里找到我的博客](http://blog.jospoortvliet.com/)。
---
via: <https://opensource.com/article/17/10/6-reasons-choose-open-source-software>
作者：[Jos Poortvliet Feed](https://opensource.com/users/jospoortvliet) 译者：[ZH1122](https://github.com/ZH1122) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
容器和微服务是如何改变了安全性
|
Wei Lien Dang
|
https://www.infoworld.com/article/3233139/cloud-computing/how-cloud-native-applications-change-security.html
|
由于这种方法从根本上改变了软件的构建、部署和运行方式，它也从根本上改变了软件需要保护的方式。云原生程序和基础架构为安全专业人员带来了若干新的挑战，他们需要建立新的安全计划来支持其组织对云原生技术的使用。
|
/data/attachment/album/201711/13/154225idzjqsdz5v1ld1de.jpeg.thumb.jpg
|
/data/attachment/album/201711/13/154225idzjqsdz5v1ld1de.jpeg
| true
| false
| true
|
geekpi
| false
|
[
"安全",
"容器",
"微服务"
] |
技术
|
{
"viewnum": 4282,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
由于这种方法从根本上改变了软件的构建、部署和运行方式，它也从根本上改变了软件需要保护的方式。云原生程序和基础架构为安全专业人员带来了若干新的挑战，他们需要建立新的安全计划来支持其组织对云原生技术的使用。
| 2017-11-13T15:38:00
| 2017-11-13T15:38:00
| 9,052
|
/article-9052-1.html
|
>
> 云原生程序和基础架构需要完全不同的安全方式。牢记这些最佳实践
>
>
>
如今，大大小小的组织正在探索云原生技术的采用。“<ruby> 云原生 <rt> Cloud-native </rt></ruby>”是指将软件打包到被称为容器的标准化单元中的方法，这些单元组织成微服务，它们必须对接以形成程序，并确保正在运行的应用程序完全自动化以实现更高的速度、灵活性和可伸缩性。
由于这种方法从根本上改变了软件的构建、部署和运行方式，它也从根本上改变了软件需要保护的方式。云原生程序和基础架构为安全专业人员带来了若干新的挑战，他们需要建立新的安全计划来支持其组织对云原生技术的使用。
让我们来看看这些挑战，然后我们将讨论安全团队应该采取的哪些最佳实践来解决这些挑战。首先挑战是：
* **传统的安全基础设施缺乏容器可视性。** 大多数现有的基于主机和网络的安全工具不具备监视或捕获容器活动的能力。这些工具是为了保护单个操作系统或主机之间的流量，而不是其上运行的应用程序，从而导致容器事件、系统交互和容器间流量的可视性缺乏。
* **攻击面可以快速更改。**云原生应用程序由许多较小的组件组成，这些组件称为微服务，它们是高度分布式的，每个都应该分别进行审计和保护。因为这些应用程序的设计是通过编排系统进行配置和调整的，所以其攻击面也在不断变化，而且比传统的独石应用程序要快得多。
* **分布式数据流需要持续监控。**容器和微服务被设计为轻量级的，并且以可编程方式与对方或外部云服务进行互连。这会在整个环境中产生大量的快速移动数据，需要进行持续监控，以便应对攻击和危害指标以及未经授权的数据访问或渗透。
* **检测、预防和响应必须自动化。** 容器生成的事件的速度和容量压倒了当前的安全操作流程。容器的短暂寿命也成为难以捕获、分析和确定事故的根本原因。有效的威胁保护意味着自动化数据收集、过滤、关联和分析，以便能够对新事件作出足够快速的反应。
面对这些新的挑战，安全专业人员将需要建立新的安全计划以支持其组织对云原生技术的使用。自然地，你的安全计划应该解决云原生程序的整个生命周期的问题，这些应用程序可以分为两个不同的阶段：构建和部署阶段以及运行时阶段。每个阶段都有不同的安全考虑因素，必须全部加以解决才能形成一个全面的安全计划。
### 确保容器的构建和部署
构建和部署阶段的安全性侧重于将控制应用于开发人员工作流程和持续集成和部署管道，以降低容器启动后可能出现的安全问题的风险。这些控制可以包含以下准则和最佳实践：
* **保持镜像尽可能小。**容器镜像是一个轻量级的可执行文件，用于打包应用程序代码及其依赖项。将每个镜像限制为软件运行所必需的内容, 从而最小化从镜像启动的每个容器的攻击面。从最小的操作系统基础镜像（如 Alpine Linux）开始，可以减少镜像大小，并使镜像更易于管理。
* **扫描镜像的已知问题。**当镜像构建后，应该检查已知的漏洞披露。可以扫描构成镜像的每个文件系统层，并将结果与定期更新的常见漏洞披露数据库（CVE）进行比较。然后开发和安全团队可以在镜像被用来启动容器之前解决发现的漏洞。
* **数字签名的镜像。**一旦建立镜像，应在部署之前验证它们的完整性。某些镜像格式使用被称为摘要的唯一标识符，可用于检测镜像内容何时发生变化。使用私钥签名镜像提供了加密的保证，以确保每个用于启动容器的镜像都是由可信方创建的。
* **强化并限制对主机操作系统的访问。**由于在主机上运行的容器共享相同的操作系统，因此必须确保它们以适当限制的功能集启动。这可以通过使用内核安全功能和 Seccomp、AppArmor 和 SELinux 等模块来实现。
* **指定应用程序级别的分割策略。**微服务之间的网络流量可以被分割，以限制它们彼此之间的连接。但是，这需要根据应用级属性（如标签和选择器）进行配置，从而消除了处理传统网络详细信息（如 IP 地址）的复杂性。分割带来的挑战是，必须事先定义策略来限制通信，而不会影响容器在环境内部和环境之间进行通信的能力，这是正常活动的一部分。
* **保护容器所使用的秘密信息。**微服务彼此相互之间频繁交换敏感数据，如密码、令牌和密钥，这称之为<ruby> 秘密信息 <rt> secret </rt></ruby>。如果将这些秘密信息存储在镜像或环境变量中，则可能会意外暴露这些。因此，像 Docker 和 Kubernetes 这样的多个编排平台都集成了秘密信息管理，确保只有在需要的时候才将秘密信息分发给使用它们的容器。
来自诸如 Docker、Red Hat 和 CoreOS 等公司的几个领先的容器平台和工具提供了部分或全部这些功能。开始使用这些方法之一是在构建和部署阶段确保强大安全性的最简单方法。
但是，构建和部署阶段控制仍然不足以确保全面的安全计划。提前解决容器开始运行之前的所有安全事件是不可能的，原因如下：首先，漏洞永远不会被完全消除，新的漏洞会一直出现。其次，声明式的容器元数据和网络分段策略不能完全预见高度分布式环境中的所有合法应用程序活动。第三，运行时控制使用起来很复杂，而且往往配置错误，就会使应用程序容易受到威胁。
### 在运行时保护容器
运行时阶段的安全性包括所有功能（可见性、检测、响应和预防），这些功能是发现和阻止容器运行后发生的攻击和策略违规所必需的。安全团队需要对安全事件的根源进行分类、调查和确定，以便对其进行全面补救。以下是成功的运行时阶段安全性的关键方面：
* **检测整个环境以得到持续可见性。**能够检测攻击和违规行为始于能够实时捕获正在运行的容器中的所有活动，以提供可操作的“真相源”。捕获不同类型的容器相关数据有各种检测框架。选择一个能够处理容器的容量和速度的方案至关重要。
* **关联分布式威胁指标。** 容器设计为基于资源可用性以跨计算基础架构而分布。由于应用程序可能由数百或数千个容器组成，因此危害指标可能分布在大量主机上，使得难以确定那些与主动威胁相关的相关指标。需要大规模，快速的相关性来确定哪些指标构成特定攻击的基础。
* **分析容器和微服务行为。**微服务和容器使得应用程序可以分解为执行特定功能的最小组件，并被设计为不可变的。这使得比传统的应用环境更容易理解预期行为的正常模式。偏离这些行为基准可能反映恶意行为，可用于更准确地检测威胁。
* **通过机器学习增强威胁检测。**容器环境中生成的数据量和速度超过了传统的检测技术。自动化和机器学习可以实现更有效的行为建模、模式识别和分类，从而以更高的保真度和更少的误报来检测威胁。注意使用机器学习的解决方案只是为了生成静态白名单，用于警报异常，这可能会导致严重的警报噪音和疲劳。
* **拦截并阻止未经授权的容器引擎命令。**发送到容器引擎（例如 Docker）的命令用于创建、启动和终止容器以及在正在运行的容器中运行命令。这些命令可以反映危害容器的意图，这意味着可以禁止任何未经授权的命令。
* **自动响应和取证。**容器的短暂寿命意味着它们往往只能提供很少的事件信息，以用于事件响应和取证。此外，云原生架构通常将基础设施视为不可变的，自动将受影响的系统替换为新系统，这意味着在调查时的容器可能会消失。自动化可以确保足够快地捕获、分析和升级信息，以减轻攻击和违规的影响。
基于容器技术和微服务架构的云原生软件正在迅速实现应用程序和基础架构的现代化。这种模式转变迫使安全专业人员重新考虑有效保护其组织所需的计划。随着容器的构建、部署和运行，云原生软件的全面安全计划将解决整个应用程序生命周期问题。通过使用上述指导方针实施计划，组织可以为容器基础设施以及运行在上面的应用程序和服务构建安全的基础。
---
作者：WeLien Dang 是 StackRox 的产品副总裁，StackRox 是一家为容器提供自适应威胁保护的安全公司。此前，他曾担任 CoreOS 产品负责人，并在亚马逊、Splunk 和 Bracket Computing 担任安全和云基础架构的高级产品管理职位。
---
via: <https://www.infoworld.com/article/3233139/cloud-computing/how-cloud-native-applications-change-security.html>
作者：[Wei Lien Dang](https://www.infoworld.com/blog/new-tech-forum/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 mlocate 查找文件
|
Chris Binnie
|
https://www.linux.com/blog/learn/intro-to-linux/2017/11/finding-files-mlocate
|
以前你可能已经发现 find 命令非常不听话，让你经常抓耳挠腮。你知道，丢失了一个分号或一个没有正确转义的特殊的字符就会这样。现在让我们离开这个复杂的 find 命令，放松一下，看一下这个聪明的小命令。
|
/data/attachment/album/201711/14/121507ebabmpj9amg733gy.jpg.thumb.jpg
|
/data/attachment/album/201711/14/121507ebabmpj9amg733gy.jpg
| true
| false
| true
|
geekpi
| false
|
[
"locate",
"mlocate",
"find"
] |
技术
|
{
"viewnum": 11941,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
以前你可能已经发现 find 命令非常不听话，让你经常抓耳挠腮。你知道，丢失了一个分号或一个没有正确转义的特殊的字符就会这样。现在让我们离开这个复杂的 find 命令，放松一下，看一下这个聪明的小命令。
| 2017-11-14T12:15:15
| 2017-11-14T12:15:15
| 9,053
|
/article-9053-1.html
|
在这一系列的文章中，我们将来看下 `mlocate`，来看看如何快速、轻松地满足你的需求。
对于一个系统管理员来说，草中寻针一样的查找文件的事情并不少见。在一台拥挤的机器上，文件系统中可能存在数十万个文件。当你需要确定一个特定的配置文件是最新的，但是你不记得它在哪里时怎么办？
如果你使用过一些类 Unix 机器，那么你肯定用过 `find` 命令。毫无疑问，它是非常复杂和功能强大的。以下是一个只搜索目录中的符号链接，而忽略文件的例子：
```
# find . -lname "*"
```
你可以用 `find` 命令做几乎无尽的事情，这是不容否认的。`find` 命令好用的时候是很好且简洁的，但是它也可以很复杂。这不一定是因为 `find` 命令本身的原因，而是它与 `xargs` 结合，你可以传递各种选项来调整你的输出，并删除你找到的那些文件。
### 位置、位置，让人沮丧
然而，通常情况下简单是最好的选择，特别是当一个脾气暴躁的老板搭着你的肩膀，闲聊着时间的重要性时。你还在模糊地猜测这个你从来没有见过的文件的路径，而你的老板却肯定它在拥挤的 /var 分区的某处。
进一步看下 `mlocate`。你也许注意过它的一个近亲：`slocate`，它安全地（注意前缀字母 s 代表安全）记录了相关的文件权限，以防止非特权用户看到特权文件。此外，还有它们所起源的一个更老的，原始 `locate` 命令。
`mlocate` 与其家族的其他成员（至少包括 `slocate`）的不同之处在于，在扫描文件系统时，`mlocate` 不需要持续重新扫描所有的文件系统。相反，它将其发现的文件（注意前面的 m 代表合并）与现有的文件列表合并在一起，使其可以借助系统缓存从而性能更高、更轻量级。
在本系列文章中，我们将更仔细地了解 `mlocate` （由于其流行，所以也简称其为 `locate`），并研究如何快速轻松地将其调整到你心中所想的方式。
### 小巧和 紧凑
除非你经常重复使用复杂的命令，否则就会像我一样，最终会忘记它们而需要在用的时候寻找它们。`locate` 命令的优点是可以快速查询整个文件系统，而不用担心你处于顶层目录、根目录和所在路径，只需要简单地使用 `locate` 命令。
以前你可能已经发现 `find` 命令非常不听话，让你经常抓耳挠腮。你知道，丢失了一个分号或一个没有正确转义的特殊的字符就会这样。现在让我们离开这个复杂的 `find` 命令，放松一下，看一下这个聪明的小命令。
你可能需要首先通过运行以下命令来检查它是否在你的系统上：
对于 Red Hat 家族：
```
# yum install mlocate
```
对于 Debian 家族：
```
# apt-get install mlocate
```
发行版之间不应该有任何区别，但版本之间几乎肯定有细微差别。小心。
接下来，我们将介绍 `locate` 命令的一个关键组件，名为 `updatedb`。正如你可能猜到的那样，这是**更新** `locate` 命令的**数据库**的命令。这名字非常符合直觉。
这个数据库是我之前提到的 `locate` 命令的文件列表。该列表被保存在一个相对简单而高效的数据库中。`updatedb` 通过 cron 任务定期运行，通常在一天中的安静时间运行。在下面的清单 1 中，我们可以看到文件 `/etc/cron.daily/mlocate.cron` 的内部（该文件的路径及其内容可能因发行版不同）。
```
#!/bin/sh
nodevs=$(< /proc/filesystems awk '$1 == "nodev" { print $2 }')
renice +19 -p $$ >/dev/null 2>&1
ionice -c2 -n7 -p $$ >/dev/null 2>&1
/usr/bin/updatedb -f "$nodevs"
```
**清单 1：** 每天如何触发 “updatedb” 命令。
如你所见，`mlocate.cron` 脚本使用了优秀的 `nice` 命令来尽可能少地影响系统性能。我还没有明确指出这个命令每天都在设定的时间运行（但如果我没有记错的话，原始的 `locate` 命令与你在午夜时的计算机减速有关）。这是因为，在一些 “cron” 版本上，延迟现在被引入到隔夜开始时间。
这可能是因为所谓的 “<ruby> 河马之惊群 <rt> Thundering Herd of Hippos </rt></ruby>”问题。想象许多计算机（或饥饿的动物）同时醒来从单一或有限的来源要求资源（或食物）。当所有的“河马”都使用 NTP 设置它们的手表时，这可能会发生（好吧，这个寓言扯多了，但请忍受一下）。想象一下，正好每五分钟（就像一个 “cron 任务”），它们都要求获得食物或其他东西。
如果你不相信我，请看下配置文件 - 清单 2 中名为 `anacron` 的 cron 版本，这是文件 `/etc/anacrontab` 的内容。
```
# /etc/anacrontab: configuration file for anacron
# See anacron(8) and anacrontab(5) for details.
SHELL=/bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
# the maximal random delay added to the base delay of the jobs
RANDOM_DELAY=45
# the jobs will be started during the following hours only
START_HOURS_RANGE=3-22
#period in days delay in minutes job-identifier command
1 5 cron.daily nice run-parts /etc/cron.daily
7 25 cron.weekly nice run-parts /etc/cron.weekly
@monthly 45 cron.monthly nice run-parts /etc/cron.monthly
```
**清单 2：** 运行 “cron” 任务时延迟是怎样被带入的。
从清单 2 可以看到 `RANDOM_DELAY` 和 “delay in minutes” 列。如果你不熟悉 cron 这个方面，那么你可以在这找到更多的东西：
```
# man anacrontab
```
否则，如果你愿意，你可以自己延迟一下。有个[很棒的网页](http://www.moundalexis.com/archives/000076.php)（现在已有十多年的历史）以非常合理的方式讨论了这个问题。本网站讨论如何使用 `sleep` 来引入一个随机性，如清单 3 所示。
```
#!/bin/sh
# Grab a random value between 0-240.
value=$RANDOM
while [ $value -gt 240 ] ; do
value=$RANDOM
done
# Sleep for that time.
sleep $value
# Syncronize.
/usr/bin/rsync -aqzC --delete --delete-after masterhost::master /some/dir/
```
**清单 3：**在触发事件之前引入随机延迟的 shell 脚本，以避免[河马之惊群](http://www.moundalexis.com/archives/000076.php)。
在提到这些（可能令人惊讶的）延迟时，是指 `/etc/crontab` 或 root 用户自己的 crontab 文件。如果你想改变 `locate` 命令运行的时间，特别是由于磁盘访问速度减慢时，那么它不是太棘手。实现它可能会有更优雅的方式，但是你也可以把文件 `/etc/cron.daily/mlocate.cron` 移到别的地方（我使用 `/usr/local/etc` 目录），使用 root 用户添加一条记录到 root 用户的 crontab，粘贴以下内容：
```
# crontab -e
33 3 * * * /usr/local/etc/mlocate.cron
```
使用 anacron，而不是通过 `/var/log/cron` 以及它的旧的、轮转的版本，你可以快速地告诉它上次 cron.daily 任务被触发的时间：
```
# ls -hal /var/spool/anacron
```
下一次，我们会看更多的使用 `locate`、`updatedb` 和其他工具来查找文件的方法。
---
via: <https://www.linux.com/blog/learn/intro-to-linux/2017/11/finding-files-mlocate>
作者：[CHRIS BINNIE](https://www.linux.com/users/chrisbinnie) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
PostgreSQL 的哈希索引现在很酷
|
Robert Haas
|
https://rhaas.blogspot.jp/2017/09/postgresqls-hash-indexes-are-now-cool.html
|
现在似乎是对过去 18 个月左右所做的工作进行简要回顾的好时机。
|
/data/attachment/album/201711/14/174704dbtn0tb2tpbz30jv.png.thumb.jpg
|
/data/attachment/album/201711/14/174704dbtn0tb2tpbz30jv.png
| true
| false
| true
|
polebug
| false
|
[
"PostgreSQL",
"哈希",
"索引"
] |
技术
|
{
"viewnum": 4875,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
现在似乎是对过去 18 个月左右所做的工作进行简要回顾的好时机。
| 2017-11-14T17:47:09
| 2017-11-14T17:47:09
| 9,054
|
/article-9054-1.html
|
由于我刚刚提交了最后一个改进 PostgreSQL 11 哈希索引的补丁，并且大部分哈希索引的改进都致力于预计下周发布的 PostgreSQL 10（LCTT 译注：已发布），因此现在似乎是对过去 18 个月左右所做的工作进行简要回顾的好时机。在版本 10 之前，哈希索引在并发性能方面表现不佳，缺少预写日志记录，因此在宕机或复制时都是不安全的，并且还有其他二等公民。在 PostgreSQL 10 中，这在很大程度上被修复了。
虽然我参与了一些设计，但改进哈希索引的首要功劳来自我的同事 Amit Kapila，[他在这个话题下的博客值得一读](http://amitkapila16.blogspot.jp/2017/03/hash-indexes-are-faster-than-btree.html)。哈希索引的问题不仅在于没有人打算写预写日志记录的代码，还在于代码没有以某种方式进行结构化，使其可以添加实际上正常工作的预写日志记录。要拆分一个桶，系统将锁定已有的桶（使用一种十分低效的锁定机制），将半个元组移动到新的桶中，压缩已有的桶，然后松开锁。即使记录了个别更改，在错误的时刻发生崩溃也会使索引处于损坏状态。因此，Aimt 首先做的是重新设计锁定机制。[新的机制](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=6d46f4783efe457f74816a75173eb23ed8930020)在某种程度上允许扫描和拆分并行进行，并且允许稍后完成那些因报错或崩溃而被中断的拆分。完成了一系列漏洞的修复和一些重构工作，Aimt 就打了另一个补丁，[添加了支持哈希索引的预写日志记录](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=c11453ce0aeaa377cbbcc9a3fc418acb94629330)。
与此同时，我们发现哈希索引已经错过了许多已应用于 B 树索引多年的相当明显的性能改进。因为哈希索引不支持预写日志记录，以及旧的锁定机制十分笨重，所以没有太多的动机去提升其他的性能。而这意味着如果哈希索引会成为一个非常有用的技术，那么需要做的事只是添加预写日志记录而已。PostgreSQL 索引存取方法的抽象层允许索引保留有关其信息的后端专用缓存，避免了重复查询索引本身来获取相关的元数据。B 树和 SQLite 的索引正在使用这种机制，但哈希索引没有，所以我的同事 Mithun Cy 写了一个补丁来[使用此机制缓存哈希索引的元页](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=293e24e507838733aba4748b514536af2d39d7f2)。同样，B 树索引有一个称为“单页回收”的优化，它巧妙地从索引页移除没用的索引指针，从而防止了大量索引膨胀。我的同事 Ashutosh Sharma 打了一个补丁将[这个逻辑移植到哈希索引上](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=6977b8b7f4dfb40896ff5e2175cad7fdbda862eb)，也大大减少了索引的膨胀。最后，B 树索引[自 2006 年以来](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=7c75ef571579a3ad7a1d3ee909f11dba5e0b9440)就有了一个功能，可以避免重复锁定和解锁同一个索引页——所有元组都在页中一次性删除，然后一次返回一个。Ashutosh Sharma 也[将此逻辑移植到了哈希索引中](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=a507b86900f695aacc8d52b7d2cfcb65f58862a2)，但是由于缺少时间，这个优化没有在版本 10 中完成。在这个博客提到的所有内容中，这是唯一一个直到版本 11 才会出现的改进。
关于哈希索引的工作有一个更有趣的地方是，很难确定行为是否真的正确。锁定行为的更改只可能在繁重的并发状态下失败，而预写日志记录中的错误可能仅在崩溃恢复的情况下显示出来。除此之外，在每种情况下，问题可能是微妙的。没有东西崩溃还不够；它们还必须在所有情况下产生正确的答案，并且这似乎很难去验证。为了协助这项工作，我的同事 Kuntal Ghosh 先后跟进了最初由 Heikki Linnakangas 和 Michael Paquier 开始的工作，并且制作了一个 WAL 一致性检查器，它不仅可以作为开发人员测试的专用补丁，还能真正[提交到 PostgreSQL](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=7403561c0f6a8c62b79b6ddf0364ae6c01719068)。在提交之前，我们对哈希索引的预写日志代码使用此工具进行了广泛的测试，并十分成功地查找到了一些漏洞。这个工具并不仅限于哈希索引，相反：它也可用于其他模块的预写日志记录代码，包括堆，当今的所有 AM 索引，以及一些以后开发的其他东西。事实上，它已经成功地[在 BRIN 中找到了一个漏洞](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=08bf6e529587e1e9075d013d859af2649c32a511)。
虽然 WAL 一致性检查是主要的开发者工具——尽管它也适合用户使用，如果怀疑有错误——也可以升级到专为数据库管理人员提供的几种工具。Jesper Pedersen 写了一个补丁来[升级 pageinspect contrib 模块来支持哈希索引](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=e759854a09d49725a9519c48a0d71a32bab05a01)，Ashutosh Sharma 做了进一步的工作，Peter Eisentraut 提供了测试用例（这是一个很好的办法，因为这些测试用例迅速失败，引发了几轮漏洞修复）。多亏了 Ashutosh Sharma 的工作，pgstattuple contrib 模块[也支持哈希索引了](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=ea69a0dead5128c421140dc53fac165ba4af8520)。
一路走来，也有一些其他性能的改进。我一开始没有意识到的是，当一个哈希索引开始新一轮的桶拆分时，磁盘上的大小会突然加倍，这对于 1MB 的索引来说并不是一个问题，但是如果你碰巧有一个 64GB 的索引，那就有些不幸了。Mithun Cy 通过编写一个补丁，把加倍过程[分为四个阶段](https://www.postgresql.org/message-id/20170704105728.mwb72jebfmok2nm2@zip.com.au)在某个程度上解决了这一问题，这意味着我们将从 64GB 到 80GB 到 96GB 到 112GB 到 128GB，而不是一次性从 64GB 到 128GB。这个问题可以进一步改进，但需要对磁盘格式进行更深入的重构，并且需要仔细考虑对查找性能的影响。
七月时，一份[来自于“AP”测试人员](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=ff98a5e1e49de061600feb6b4de5ce0a22d386af)的报告使我们感到需要做进一步的调整。AP 发现，若试图将 20 亿行数据插入到新创建的哈希索引中会导致错误。为了解决这个问题，Amit 修改了拆分桶的代码，[使得在每次拆分之后清理旧的桶](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=ff98a5e1e49de061600feb6b4de5ce0a22d386af)，大大减少了溢出页的累积。为了得以确保，Aimt 和我也[增加了四倍的位图页的最大数量](https://www.postgresql.org/message-id/CA%2BTgmoax6DhnKsuE_gzY5qkvmPEok77JAP1h8wOTbf%2Bdg2Ycrw%40mail.gmail.com)，用于跟踪溢出页分配。
虽然还是有更多的事情要做，但我觉得，我和我的同事们——以及在 PostgreSQL 团队中的其他人的帮助下——已经完成了我们的目标，使哈希索引成为一个一流的功能，而不是被严重忽视的半成品。不过，你或许会问，这个功能可能有哪些应用场景。我在文章开头提到的（以及链接中的）Amit 的博客内容表明，即使是 pgbench 的工作负载，哈希索引页也可能在低级和高级并发方面优于 B 树。然而，从某种意义上说，这确实是最坏的情况。哈希索引的卖点之一是，索引存储的是字段的哈希值，而不是原始值——所以，我希望像 UUID 或者长字符串的宽键将有更大的改进。它们可能会在读取繁重的工作负载时做得更好。我们没有像优化读取那种程度来优化写入，但我鼓励任何对此技术感兴趣的人去尝试并将结果发到邮件列表（或发私人电子邮件），因为对于开发一个功能而言，真正关键的并不是一些开发人员去思考在实验室中会发生什么，而是在实际中发生了什么。
最后，我要感谢 Jeff Janes 和 Jesper Pedersen 为这个项目及其相关所做的宝贵的测试工作。这样一个规模适当的项目并不易得，以及有一群坚持不懈的测试人员，他们勇于打破任何废旧的东西的决心起了莫大的帮助。除了以上提到的人之外，其他人同样在测试，审查以及各种各样的日常帮助方面值得赞扬，其中包括 Andreas Seltenreich，Dilip Kumar，Tushar Ahuja，Alvaro Herrera，Micheal Paquier，Mark Kirkwood，Tom Lane，Kyotaro Horiguchi。谢谢你们，也同样感谢那些本该被提及却被我无意中忽略的所有朋友。
---
via：<https://rhaas.blogspot.jp/2017/09/postgresqls-hash-indexes-are-now-cool.html>
作者：[Robert Haas](http://rhaas.blogspot.jp) 译者：[polebug](https://github.com/polebug) 校对：[wxy](https://github.com/wxy)
本文由[LCTT]（[https://github.com/LCTT/TranslateProject）原创编译，[Linux中国]（https://linux.cn/）荣誉推出](https://github.com/LCTT/TranslateProject%EF%BC%89%E5%8E%9F%E5%88%9B%E7%BC%96%E8%AF%91%EF%BC%8C%5BLinux%E4%B8%AD%E5%9B%BD%5D%EF%BC%88https://linux.cn/%EF%BC%89%E8%8D%A3%E8%AA%89%E6%8E%A8%E5%87%BA)
|
||
怎么在 Fedora 中创建我的第一个 RPM 包？
|
Justin W. Flory
|
https://blog.justinwflory.com/2017/11/first-rpm-package-fedora/
|
在这篇文章中，我将分享以下的内容：创建 RPM SPEC 文件；在 Koji 和 Copr 中构建包；使用调试包处理一个问题；提交这个包到 Fedora 包集合中。
|
/data/attachment/album/201711/14/192342gl900rja78080299.png.thumb.jpg
|
/data/attachment/album/201711/14/192342gl900rja78080299.png
| true
| false
| true
|
qhwdw
| false
|
[
"打包",
"RPM"
] |
技术
|
{
"viewnum": 5568,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我将分享以下的内容：创建 RPM SPEC 文件；在 Koji 和 Copr 中构建包；使用调试包处理一个问题；提交这个包到 Fedora 包集合中。
| 2017-11-14T19:22:00
| 2017-11-14T19:22:00
| 9,055
|
/article-9055-1.html
|
过了这个夏天，我把我的桌面环境迁移到了 i3，这是一个瓦片式窗口管理器。当初，切换到 i3 是一个挑战，因为我必须去处理许多以前 GNOME 帮我处理的事情。其中一件事情就是改变屏幕亮度。 xbacklight 这个在笔记本电脑上改变背光亮度的标准方法，它在我的硬件上不工作了。
最近，我发现一个改变背光亮度的工具 [brightlight](https://github.com/multiplexd/brightlight)。我决定去试一下它，它工作在 root 权限下。但是，我发现 brightligh 在 Fedora 下没有 RPM 包。我决定，是在 Fedora 下尝试创建一个包的时候了，并且可以学习怎么去创建一个 RPM 包。
在这篇文章中，我将分享以下的内容：
* 创建 RPM SPEC 文件
* 在 Koji 和 Copr 中构建包
* 使用调试包处理一个问题
* 提交这个包到 Fedora 包集合中
### 前提条件
在 Fedora 上，我安装了包构建过程中所有步骤涉及到的包。
```
sudo dnf install fedora-packager fedpkg fedrepo_req copr-cli
```
### 创建 RPM SPEC 文件
创建 RPM 包的第一步是去创建 SPEC 文件。这些规范，或者是指令，它告诉 RPM 怎么去构建包。这是告诉 RPM 从包的源代码中创建一个二进制文件。创建 SPEC 文件看上去是整个包处理过程中最难的一部分，并且它的难度取决于项目。
对我而言，幸运的是，brightlight 是一个用 C 写的简单应用程序。维护人员用一个 Makefile 使创建二进制应用程序变得很容易。构建它只是在仓库中简单运行 `make` 的问题。因此，我现在可以用一个简单的项目去学习 RPM 打包。
#### 查找文档
谷歌搜索 “how to create an RPM package” 有很多结果。我开始使用的是 [IBM 的文档](https://www.ibm.com/developerworks/library/l-rpm1/index.html)。然而，我发现它理解起来非常困难，不知所云（虽然十分详细，它可能适用于复杂的 app）。我也在 Fedora 维基上找到了 [创建包](https://fedoraproject.org/wiki/How_to_create_an_RPM_package) 的介绍。这个文档在构建和处理上解释的非常好，但是，我一直困惑于 “怎么去开始呢？”
最终，我找到了 [RPM 打包指南](https://fedoraproject.org/wiki/How_to_create_an_RPM_package)，它是大神 [Adam Miller](https://github.com/maxamillion) 写的。这些介绍非常有帮助，并且包含了三个优秀的示例，它们分别是用 Bash、C 和 Python 编写的程序。这个指南帮我很容易地理解了怎么去构建一个 RPM SPEC，并且，更重要的是，解释了怎么把这些片断拼到一起。
有了这些之后，我可以去写 brightlight 程序的我的 [第一个 SPEC 文件](https://src.fedoraproject.org/rpms/brightlight/blob/master/f/brightlight.spec) 了。因为它是很简单的，SPEC 很短也很容易理解。我有了 SPEC 文件之后，我发现其中有一些错误。处理掉一些错误之后，我创建了源 RPM (SRPM) 和二进制 RPM，然后，我解决了出现的每个问题。
```
rpmlint SPECS/brightlight.spec
rpmbuild -bs SPECS/brightlight.spec
rpmlint SRPMS/brightlight-5-1.fc26.src.rpm
rpmbuild -bb SPECS/brightlight-5-1.fc26.x86_64.rpm
rpmlint RPMS/x86_64/brightlight-5-1.fc26.x86_64.rpm
```
现在，我有了一个可用的 RPM，可以发送到 Fedora 仓库了。
### 在 Copr 和 Koji 中构建
接下来，我读了该 [指南](https://fedoraproject.org/wiki/Join_the_package_collection_maintainers) 中关于怎么成为一个 Fedora 打包者。在提交之前，他们鼓励打包者通过在在 [Koji](https://koji.fedoraproject.org/koji/) 中托管、并在 [Copr](https://copr.fedoraproject.org/) 中构建项目来测试要提交的包。
#### 使用 Copr
首先，我为 brightlight 创建了一个 [Copr 仓库](https://copr.fedorainfracloud.org/coprs/jflory7/brightlight/)，[Copr](https://developer.fedoraproject.org/deployment/copr/about.html) 是在 Fedora 的基础设施中的一个服务，它构建你的包，并且为你任意选择的 Fedora 或 EPEL 版本创建一个定制仓库。它对于快速托管你的 RPM 包，并与其它人去分享是非常方便的。你不需要特别操心如何去托管一个 Copr 仓库。
我从 Web 界面创建了我的 Copr 项目，但是，你也可以使用 `copr-cli` 工具。在 Fedora 开发者网站上有一个 [非常优秀的指南](https://developer.fedoraproject.org/deployment/copr/copr-cli.html)。在该网站上创建了我的仓库之后，我使用这个命令构建了我的包。
```
copr-cli build brightlight SRPMS/brightlight.5-1.fc26.src.rpm
```
我的包在 Corp 上成功构建，并且，我可以很容易地在我的 Fedora 系统上成功安装它。
#### 使用 Koji
任何人都可以使用 [Koji](https://koji.fedoraproject.org/koji/) 在多种架构和 Fedora 或 CentOS/RHEL 版本上测试他们的包。在 Koji 中测试，你必须有一个源 RPM。我希望 brightlight 包在 Fedora 所有的版本中都支持，因此，我运行如下的命令：
```
koji build --scratch f25 SRPMS/brightlight-5-1.fc26.src.rpm
koji build --scratch f26 SRPMS/brightlight-5-1.fc26.src.rpm
koji build --scratch f27 SRPMS/brightlight-5-1.fc26.src.rpm
```
它花费了一些时间，但是，Koji 构建了所有的包。我的包可以很完美地运行在 Fedora 25 和 26 中，但是 Fedora 27 失败了。 Koji 模拟构建可以使我走在正确的路线上，并且确保我的包构建成功。
### 问题：Fedora 27 构建失败！
现在，我已经知道我的 Fedora 27 上的包在 Koji 上构建失败了。但是，为什么呢？我发现在 Fedora 27 上有两个相关的变化。
* [Subpackage and Source Debuginfo](https://fedoraproject.org/wiki/Changes/SubpackageAndSourceDebuginfo)
* [RPM 4.14](https://fedoraproject.org/wiki/Changes/RPM-4.14) (特别是，debuginfo 包重写了)
这些变化意味着 RPM 包必须使用一个 debuginfo 包去构建。这有助于排错或调试一个应用程序。在我的案例中，这并不是关键的或者很必要的，但是，我需要去构建一个。
感谢 Igor Gnatenko，他帮我理解了为什么我在 Fedora 27 上构建包时需要去将这些增加到我的包的 SPEC 中。在 `%make_build` 宏指令之前，我增加了这些行。
```
export CFLAGS="%{optflags}"
export LDFLAGS="%{__global_ldflags}"
```
我构建了一个新的 SRPM 并且提交它到 Koji 去在 Fedora 27 上构建。成功了，它构建成功了！
### 提交这个包
现在，我在 Fedora 25 到 27 上成功校验了我的包，是时候为 Fedora 打包了。第一步是提交这个包，为了请求一个包评估，要在 Red Hat Bugzilla 创建一个新 bug。我为 brightlight [创建了一个工单](https://bugzilla.redhat.com/show_bug.cgi?id=1505026)。因为这是我的第一个包，我明确标注它 “这是我的第一个包”，并且我寻找一个发起人。在工单中，我链接 SPEC 和 SRPM 文件到我的 Git 仓库中。
#### 进入 dist-git
[Igor Gnatenko](https://fedoraproject.org/wiki/User:Ignatenkobrain) 发起我进入 Fedora 打包者群组，并且在我的包上留下反馈。我学习了一些其它的关于 C 应用程序打包的特定的知识。在他响应我之后，我可以在 [dist-git](https://src.fedoraproject.org/) 上申请一个仓库，Fedora 的 RPM 包集合仓库为所有的 Fedora 版本保存了 SPEC 文件。
一个很方便的 Python 工具使得这一部分很容易。`fedrepo-req` 是一个用于创建一个新的 dist-git 仓库的请求的工具。我用这个命令提交我的请求。
```
fedrepo-req brightlight \
--ticket 1505026 \
--description "CLI tool to change screen back light brightness" \
--upstreamurl https://github.com/multiplexd/brightlight
```
它为我在 fedora-scm-requests 仓库创建了一个新的工单。这是一个我是管理员的 [创建的仓库](https://src.fedoraproject.org/rpms/brightlight)。现在，我可以开始干了！
*My first RPM in Fedora dist-git – woohoo!*
#### 与 dist-git 一起工作
接下来，`fedpkg` 是用于和 dist-git 仓库进行交互的工具。我改变当前目录到我的 git 工作目录，然后运行这个命令。
```
fedpkg clone brightlight
```
`fedpkg` 从 dist-git 克隆了我的包的仓库。对于这个仅有的第一个分支，你需要去导入 SRPM。
```
fedpkg import SRPMS/brightlight-5-1.fc26.src.rpm
```
`fedpkg` 导入你的包的 SRPM 到这个仓库中，然后设置源为你的 Git 仓库。这一步对于使用 `fedpkg` 是很重要的，因为它用一个 Fedora 友好的方去帮助规范这个仓库（与手动添加文件相比）。一旦你导入了 SRPM，推送这个改变到 dist-git 仓库。
```
git commit -m "Initial import (#1505026)."
git push
```
#### 构建包
自从你推送第一个包导入到你的 dist-git 仓库中，你已经准备好了为你的项目做一次真实的 Koji 构建。要构建你的项目，运行这个命令。
```
fedpkg build
```
它会在 Koji 中为 Rawhide 构建你的包，这是 Fedora 中的非版本控制的分支。在你为其它分支构建之前，你必须在 Rawhide 分支上构建成功。如果一切构建成功，你现在可以为你的项目的其它分支发送请求了。
```
fedrepo-req brightlight f27 -t 1505026
fedrepo-req brightlight f26 -t 1505026
fedrepo-req brightlight f25 -t 1505026
```
#### 关于构建其它分支的注意事项
一旦你最初导入了 SRPM，如果你选择去创建其它分支，记得合并你的主分支到它们。例如，如果你后面为 Fedora 27 请求一个分支，你将需要去使用这些命令。
```
fedpkg switch-branch f27
git merge master
git push
fedpkg build
```
#### 提交更新到 Bodhi
这个过程的最后一步是，把你的新包作为一个更新包提交到 Bodhi 中。当你初次提交你的更新包时，它将去测试这个仓库。任何人都可以测试你的包并且增加 karma 到该更新中。如果你的更新接收了 3 个以上的投票（或者像 Bodhi 称它为 karma），你的包将自动被推送到稳定仓库。否则，一周之后，推送到测试仓库中。
要提交你的更新到 Bodhi，你仅需要一个命令。
```
fedpkg update
```
它为你的包用一个不同的配置选项打开一个 Vim 窗口。一般情况下，你仅需要去指定一个 类型（比如，`newpackage`）和一个你的包评估的票据 ID。对于更深入的讲解，在 Fedora 维基上有一篇[更新的指南](https://fedoraproject.org/wiki/Package_update_HOWTO)。
在保存和退出这个文件后，`fedpkg` 会把你的包以一个更新包提交到 Bodhi，最后，同步到 Fedora 测试仓库。我也可以用这个命令去安装我的包。
```
sudo dnf install brightlight -y --enablerepo=updates-testing --refresh
```
### 稳定仓库
最近提交了我的包到 [Fedora 26 稳定仓库](https://bodhi.fedoraproject.org/updates/brightlight-5-1.fc26)，并且不久将进入 [Fedora 25](https://bodhi.fedoraproject.org/updates/FEDORA-2017-8071ee299f) 和 [Fedora 27](https://bodhi.fedoraproject.org/updates/FEDORA-2017-f3f085b86e) 稳定仓库。感谢帮助我完成我的第一个包的每个人。我期待有更多的机会为发行版添加包。
---
via: <https://blog.justinwflory.com/2017/11/first-rpm-package-fedora/>
作者：[JUSTIN W. FLORY](https://blog.justinwflory.com/author/jflory7/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
怎么在一台树莓派上安装 Postgres 数据库
|
Ben Nuttall
|
https://opensource.com/article/17/10/set-postgres-database-your-raspberry-pi
|
本教程介绍了怎么在一个树莓派上去安装 Postgres；创建一个表；写简单查询；在树莓派、PC，或者 Mac 上使用 pgAdmin 图形用户界面；从 Python 中与数据库交互。
|
/data/attachment/album/201711/14/231228w1yr2z7zlzn1y0vr.png.thumb.jpg
|
/data/attachment/album/201711/14/231228w1yr2z7zlzn1y0vr.png
| true
| false
| true
|
qhwdw
| false
|
[
"PostgreSQL",
"树莓派"
] |
技术
|
{
"viewnum": 11218,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "113.137.58.77",
"message": "PostgreSQL linux 安装指导:<br />\r\nRPM 软件包安装 <a href=\"https://doc.rockdata.net/zh-cn/installation/redhat/\" target=\"_blank\">https://doc.rockdata.net/zh-cn/installation/redhat/</a><br />\r\nDEB 软件包安装 <a href=\"https://doc.rockdata.net/zh-cn/installation/debian/\" target=\"_blank\">https://doc.rockdata.net/zh-cn/installation/debian/</a><br />\r\n二进制软件包安装 <a href=\"https://doc.rockdata.net/zh-cn/installation/binary/\" target=\"_blank\">https://doc.rockdata.net/zh-cn/installation/binary/</a>",
"username": "来自陕西咸阳的 Chrome 113.0|Windows 10 用户",
"date": "2023-05-06T10:13:09"
}
] |
[] |
本教程介绍了怎么在一个树莓派上去安装 Postgres；创建一个表；写简单查询；在树莓派、PC，或者 Mac 上使用 pgAdmin 图形用户界面；从 Python 中与数据库交互。
| 2017-11-17T10:10:00
| 2017-11-17T10:10:00
| 9,056
|
/article-9056-1.html
|
>
> 在你的下一个树莓派项目上安装和配置流行的开源数据库 Postgres 并去使用它。
>
>
>
保存你的项目或应用程序持续增加的数据，数据库是一种很好的方式。你可以在一个会话中将数据写入到数据库，并且在下次你需要查找的时候找到它。一个设计良好的数据库可以做到在巨大的数据集中高效地找到数据，只要告诉它你想去找什么，而不用去考虑它是如何查找的。为一个基本的 [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) （创建、记录、更新、删除）应用程序安装一个数据库是非常简单的， 它是一个很通用的模式，并且也适用于很多项目。
为什么 [PostgreSQL](https://www.postgresql.org/) 一般被为 Postgres？ 它被认为是功能和性能最好的开源数据库。如果你使用过 MySQL，它们是很相似的。但是，如果你希望使用它更高级的功能，你会发现优化 Postgres 是比较容易的。它便于安装、容易使用、方便安全， 而且在树莓派 3 上运行的非常好。
本教程介绍了怎么在一个树莓派上去安装 Postgres；创建一个表；写简单查询；在树莓派、PC，或者 Mac 上使用 pgAdmin 图形用户界面；从 Python 中与数据库交互。
你掌握了这些基础知识后，你可以让你的应用程序使用复合查询连接多个表，那个时候你需要考虑的是，怎么去使用主键或外键优化及最佳实践等等。
### 安装
一开始，你将需要去安装 Postgres 和一些其它的包。打开一个终端窗口并连接到因特网，然后运行以下命令：
```
sudo apt install postgresql libpq-dev postgresql-client
postgresql-client-common -y
```
当安装完成后，切换到 Postgres 用户去配置数据库：
```
sudo su postgres
```
现在，你可以创建一个数据库用户。如果你创建了一个与你的 Unix 用户帐户相同名字的用户，那个用户将被自动授权访问该数据库。因此在本教程中，为简单起见，我们将假设你使用了默认用户 `pi` 。运行 `createuser` 命令以继续：
```
createuser pi -P --interactive
```
当得到提示时，输入一个密码 （并记住它）， 选择 `n` 使它成为一个非超级用户（LCTT 译注：此处原文有误），接下来两个问题选择 `y`（LCTT 译注：分别允许创建数据库和其它用户）。
现在，使用 Postgres shell 连接到 Postgres 去创建一个测试数据库：
```
$ psql
> create database test;
```
按下 `Ctrl+D` **两次**从 psql shell 和 postgres 用户中退出，再次以 `pi` 用户登入。你创建了一个名为 `pi` 的 Postgres 用户后，你可以从这里无需登录凭据即可访问 Postgres shell：
```
$ psql test
```
你现在已经连接到 "test" 数据库。这个数据库当前是空的，不包含任何表。你可以在 psql shell 里创建一个简单的表：
```
test=> create table people (name text, company text);
```
现在你可插入数据到表中：
```
test=> insert into people values ('Ben Nuttall', 'Raspberry Pi Foundation');
test=> insert into people values ('Rikki Endsley', 'Red Hat');
```
然后尝试进行查询：
```
test=> select * from people;
name | company
---------------+-------------------------
Ben Nuttall | Raspberry Pi Foundation
Rikki Endsley | Red Hat
(2 rows)
```
```
test=> select name from people where company = 'Red Hat';
name | company
---------------+---------
Rikki Endsley | Red Hat
(1 row)
```
### pgAdmin
如果希望使用一个图形工具去访问数据库，你可以使用它。 PgAdmin 是一个全功能的 PostgreSQL GUI，它允许你去创建和管理数据库和用户、创建和修改表、执行查询，和如同在电子表格一样熟悉的视图中浏览结果。psql 命令行工具可以很好地进行简单查询，并且你会发现很多高级用户一直在使用它，因为它的执行速度很快 （并且因为他们不需要借助 GUI），但是，一般用户学习和操作数据库，使用 pgAdmin 是一个更适合的方式。
关于 pgAdmin 可以做的其它事情：你可以用它在树莓派上直接连接数据库，或者用它在其它的电脑上远程连接到树莓派上的数据库。
如果你想去访问树莓派，你可以用 `apt` 去安装它：
```
sudo apt install pgadmin3
```
它是和基于 Debian 的系统如 Ubuntu 是完全相同的；如果你在其它发行版上安装，尝试与你的系统相关的等价的命令。 或者，如果你在 Windows 或 macOS 上，尝试从 [pgAdmin.org](https://www.pgadmin.org/download/) 上下载 pgAdmin。注意，在 `apt` 上的可用版本是 pgAdmin3，而最新的版本 pgAdmin4，在其网站上可以找到。
在同一台树莓派上使用 pgAdmin 连接到你的数据库，从主菜单上简单地打开 pgAdmin3 ，点击 **new connection** 图标，然后完成注册，这时，你将需要一个名字（连接名，比如 test），改变用户为 “pi”，然后剩下的输入框留空 (或者如它们原本不动）。点击 OK，然后你在左侧的侧面版中将发现一个新的连接。
要从另外一台电脑上使用 pgAdmin 连接到你的树莓派数据库上，你首先需要编辑 PostgreSQL 配置允许远程连接：
1、 编辑 PostgreSQL 配置文件 `/etc/postgresql/9.6/main/postgresql.conf` ，取消 `listen_addresses` 行的注释，并把它的值从 `localhost` 改变成 `*`。然后保存并退出。
2、 编辑 pg\_hba 配置文件 `/etc/postgresql/9.6/main/postgresql.conf`，将 `127.0.0.1/32` 改变成 `0.0.0.0/0` （对于IPv4）和将 `::1/128` 改变成 `::/0` （对于 IPv6）。然后保存并退出。
3、 重启 PostgreSQL 服务： `sudo service postgresql restart`。
注意，如果你使用一个旧的 Raspbian 镜像或其它发行版，版本号可能不一样。
做完这些之后，在其它的电脑上打开 pgAdmin 并创建一个新的连接。这时，需要提供一个连接名，输入树莓派的 IP 地址作为主机（这可以在任务栏的 WiFi 图标上悬停鼠标找到，或者在一个终端中输入 `hostname -I` 找到）。
不论你连接的是本地的还是远程的数据库，点击打开 **Server Groups > Servers > test > Schemas > public > Tables**，右键单击 **people** 表，然后选择 **View Data > View top 100 Rows**。你现在将看到你前面输入的数据。
你现在可以创建和修改数据库和表、管理用户，和使用 GUI 去写你自己的查询了。你可能会发现这种可视化方法比命令行更易于管理。
### Python
要从一个 Python 脚本连接到你的数据库，你将需要 [Psycopg2](http://initd.org/psycopg/) 这个 Python 包。你可以用 [pip](https://pypi.python.org/pypi/pip) 来安装它：
```
sudo pip3 install psycopg2
```
现在打开一个 Python 编辑器写一些代码连接到你的数据库：
```
import psycopg2
conn = psycopg2.connect('dbname=test')
cur = conn.cursor()
cur.execute('select * from people')
results = cur.fetchall()
for result in results:
print(result)
```
运行这个代码去看查询结果。注意，如果你连接的是远程数据库，在连接字符串中你将需要提供更多的凭据，比如，增加主机 IP、用户名，和数据库密码：
```
conn = psycopg2.connect('host=192.168.86.31 user=pi
password=raspberry dbname=test')
```
你甚至可以创建一个函数去运行特定的查询：
```
def get_all_people():
query = """
SELECT
*
FROM
people
"""
cur.execute(query)
return cur.fetchall()
```
和一个包含参数的查询：
```
def get_people_by_company(company):
query = """
SELECT
*
FROM
people
WHERE
company = %s
"""
values = (company, )
cur.execute(query, values)
return cur.fetchall()
```
或者甚至是一个增加记录的函数：
```
def add_person(name, company):
query = """
INSERT INTO
people
VALUES
(%s, %s)
"""
values = (name, company)
cur.execute(query, values)
```
注意，这里使用了一个注入字符串到查询中的安全的方法， 你不希望被 [小鲍勃的桌子](https://xkcd.com/327/) 害死！
现在你知道了这些基础知识，如果你想去进一步掌握 Postgres ，查看在 [Full Stack Python](https://www.fullstackpython.com/postgresql.html) 上的文章。
（题图：树莓派基金会）
---
作者简介：
Ben Nuttall - 树莓派社区的管理者。除了它为树莓派基金会所做的工作之外 ，他也投入开源软件、数学、皮艇运动、GitHub、探险活动和 Futurama。在 Twitter [@ben\_nuttall](http://www.twitter.com/ben_nuttall) 上关注他。
---
via: <https://opensource.com/article/17/10/set-postgres-database-your-raspberry-pi>
作者：[Ben Nuttall](https://opensource.com/users/bennuttall) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 中怎么使用 cron 计划任务
|
David Both
|
https://opensource.com/article/17/11/how-use-cron-linux
|
系统管理员（在许多好处中）的挑战之一是在你该睡觉的时候去运行一些任务。例如，一些任务（包括定期循环运行的任务）需要在没有人使用计算机资源的时候去运行，如午夜或周末。在下班后，我没有时间去运行命令或脚本。而且，我也不想在晚上去启动备份或重大更新。
|
/data/attachment/album/201711/15/102515w2lxul2uw2bmlqah.jpeg.thumb.jpg
|
/data/attachment/album/201711/15/102515w2lxul2uw2bmlqah.jpeg
| true
| false
| true
|
qhwdw
| false
|
[
"cron",
"crontab"
] |
系统运维
|
{
"viewnum": 18591,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
系统管理员（在许多好处中）的挑战之一是在你该睡觉的时候去运行一些任务。例如，一些任务（包括定期循环运行的任务）需要在没有人使用计算机资源的时候去运行，如午夜或周末。在下班后，我没有时间去运行命令或脚本。而且，我也不想在晚上去启动备份或重大更新。
| 2017-11-15T10:25:00
| 2017-11-15T10:25:00
| 9,057
|
/article-9057-1.html
|
>
> 没有时间运行命令？使用 cron 的计划任务意味着你不用熬夜程序也可以运行。
>
>
>
系统管理员（在许多好处中）的挑战之一是在你该睡觉的时候去运行一些任务。例如，一些任务（包括定期循环运行的任务）需要在没有人使用计算机资源的时候去运行，如午夜或周末。在下班后，我没有时间去运行命令或脚本。而且，我也不想在晚上去启动备份或重大更新。
取而代之的是，我使用两个服务功能在我预定的时间去运行命令、程序和任务。[cron](https://en.wikipedia.org/wiki/Cron) 和 at 服务允许系统管理员去安排任务运行在未来的某个特定时间。at 服务指定在某个时间去运行一次任务。cron 服务可以安排任务在一个周期上重复，比如天、周、或月。
在这篇文章中，我将介绍 cron 服务和怎么去使用它。
### 常见（和非常见）的 cron 用途
我使用 cron 服务去安排一些常见的事情，比如，每天凌晨 2:00 发生的定期备份，我也使用它去做一些不常见的事情。
* 许多电脑上的系统时钟（比如，操作系统时间）都设置为使用网络时间协议（NTP）。 NTP 设置系统时间后，它不会去设置硬件时钟，它可能会“漂移”。我使用 cron 基于系统时间去设置硬件时钟。
* 我还有一个 Bash 程序，我在每天早晨运行它，去在每台电脑上创建一个新的 “每日信息” （MOTD）。它包含的信息有当前的磁盘使用情况等有用的信息。
* 许多系统进程和服务，像 [Logwatch](https://sourceforge.net/projects/logwatch/files/)、[logrotate](https://github.com/logrotate/logrotate)、和 [Rootkit Hunter](http://rkhunter.sourceforge.net/)，使用 cron 服务去安排任务和每天运行程序。
crond 守护进程是一个完成 cron 功能的后台服务。
cron 服务检查在 `/var/spool/cron` 和 `/etc/cron.d` 目录中的文件，以及 `/etc/anacrontab` 文件。这些文件的内容定义了以不同的时间间隔运行的 cron 作业。个体用户的 cron 文件是位于 `/var/spool/cron`，而系统服务和应用生成的 cron 作业文件放在 `/etc/cron.d` 目录中。`/etc/anacrontab` 是一个特殊的情况，它将在本文中稍后部分介绍。
### 使用 crontab
cron 实用程序运行基于一个 cron 表（`crontab`）中指定的命令。每个用户，包括 root，都有一个 cron 文件。这些文件缺省是不存在的。但可以使用 `crontab -e` 命令创建在 `/var/spool/cron` 目录中，也可以使用该命令去编辑一个 cron 文件（看下面的脚本）。我强烈建议你，*不要*使用标准的编辑器（比如，Vi、Vim、Emacs、Nano、或者任何其它可用的编辑器）。使用 `crontab` 命令不仅允许你去编辑命令，也可以在你保存并退出编辑器时，重启动 crond 守护进程。`crontab` 命令使用 Vi 作为它的底层编辑器，因为 Vi 是预装的（至少在大多数的基本安装中是预装的）。
现在，cron 文件是空的，所以必须从头添加命令。 我增加下面示例中定义的作业到我的 cron 文件中，这是一个快速指南，以便我知道命令中的各个部分的意思是什么，你可以自由拷贝它，供你自己使用。
```
# crontab -e
SHELL=/bin/bash
MAILTO=root@example.com
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin
# For details see man 4 crontabs
# Example of job definition:
# .---------------- minute (0 - 59)
# | .------------- hour (0 - 23)
# | | .---------- day of month (1 - 31)
# | | | .------- month (1 - 12) OR jan,feb,mar,apr ...
# | | | | .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
# | | | | |
# * * * * * user-name command to be executed
# backup using the rsbu program to the internal 4TB HDD and then 4TB external
01 01 * * * /usr/local/bin/rsbu -vbd1 ; /usr/local/bin/rsbu -vbd2
# Set the hardware clock to keep it in sync with the more accurate system clock
03 05 * * * /sbin/hwclock --systohc
# Perform monthly updates on the first of the month
# 25 04 1 * * /usr/bin/dnf -y update
```
*`crontab` 命令用于查看或编辑 cron 文件。*
上面代码中的前三行设置了一个缺省环境。对于给定用户，环境变量必须是设置的，因为，cron 不提供任何方式的环境。`SHELL` 变量指定命令运行使用的 shell。这个示例中，指定为 Bash shell。`MAILTO` 变量设置发送 cron 作业结果的电子邮件地址。这些电子邮件提供了 cron 作业（备份、更新、等等）的状态，和你从命令行中手动运行程序时看到的结果是一样的。第三行为环境设置了 `PATH` 变量。但即使在这里设置了路径，我总是使用每个程序的完全限定路径。
在上面的示例中有几个注释行，它详细说明了定义一个 cron 作业所要求的语法。我将在下面分别讲解这些命令，然后，增加更多的 crontab 文件的高级特性。
```
01 01 * * * /usr/local/bin/rsbu -vbd1 ; /usr/local/bin/rsbu -vbd2
```
*在我的 `/etc/crontab` 中的这一行运行一个脚本，用于为我的系统执行备份。*
这一行运行我自己编写的 Bash shell 脚本 `rsbu`，它对我的系统做完全备份。这个作业每天的凌晨 1:01 (`01 01`) 运行。在这三、四、五位置上的星号（\*），像文件通配符一样代表一个特定的时间，它们代表 “一个月中的每天”、“每个月” 和 “一周中的每天”，这一行会运行我的备份两次，一次备份内部专用的硬盘驱动器，另外一次运行是备份外部的 USB 驱动器，使用它这样我可以很保险。
接下来的行我设置了一个硬件时钟，它使用当前系统时钟作为源去设置硬件时钟。这一行设置为每天凌晨 5：03 分运行。
```
03 05 * * * /sbin/hwclock --systohc
```
*这一行使用系统时间作为源来设置硬件时钟。*
我使用的第三个也是最后一个的 cron 作业是去执行一个 `dnf` 或 `yum` 更新，它在每个月的第一天的凌晨 04:25 运行，但是，我注释掉了它，以后不再运行。
```
# 25 04 1 * * /usr/bin/dnf -y update
```
*这一行用于执行一个每月更新，但是，我也把它注释掉了。*
#### 其它的定时任务技巧
现在，让我们去做一些比基本知识更有趣的事情。假设你希望在每周四下午 3:00 去运行一个特别的作业：
```
00 15 * * Thu /usr/local/bin/mycronjob.sh
```
*这一行会在每周四下午 3:00 运行 `mycronjob.sh` 这个脚本。*
或者，或许你需要在每个季度末去运行一个季度报告。cron 服务没有为 “每个月的最后一天” 设置选项，因此，替代方式是使用下一个月的第一天，像如下所示（这里假设当作业准备运行时，报告所需要的数据已经准备好了）。
```
02 03 1 1,4,7,10 * /usr/local/bin/reports.sh
```
*在季度末的下一个月的第一天运行这个 cron 作业。*
下面展示的这个作业，在每天的上午 9:01 到下午 5:01 之间，每小时运行一次。
```
01 09-17 * * * /usr/local/bin/hourlyreminder.sh
```
*有时，你希望作业在业务期间定时运行。*
我遇到一个情况，需要作业在每二、三或四小时去运行。它需要用期望的间隔去划分小时，比如， `*/3` 为每三个小时，或者 `6-18/3` 为上午 6 点到下午 6 点每三个小时运行一次。其它的时间间隔的划分也是类似的。例如，在分钟位置的表达式 `*/15` 意思是 “每 15 分钟运行一次作业”。
```
*/5 08-18/2 * * * /usr/local/bin/mycronjob.sh
```
*这个 cron 作业在上午 8:00 到下午 18:59 之间，每五分钟运行一次作业。*
需要注意的一件事情是：除法表达式的结果必须是余数为 0（即整除）。换句话说，在这个例子中，这个作业被设置为在上午 8 点到下午 6 点之间的偶数小时每 5 分钟运行一次（08:00、08:05、 08:10、 08:15……18:55 等等），而不运行在奇数小时。另外，这个作业不能运行在下午 7:00 到上午 7:59 之间。（LCTT 译注：此处本文表述有误，根据正确情况修改）
我相信，你可以根据这些例子想到许多其它的可能性。
#### 限制访问 cron
普通用户使用 cron 访问可能会犯错误，例如，可能导致系统资源（比如内存和 CPU 时间）被耗尽。为避免这种可能的问题， 系统管理员可以通过创建一个 `/etc/cron.allow` 文件去限制用户访问，它包含了一个允许去创建 cron 作业的用户列表。（不管是否列在这个列表中，）不能阻止 root 用户使用 cron。
通过阻止非 root 用户创建他们自己的 cron 作业，那也许需要将非 root 用户的 cron 作业添加到 root 的 crontab 中， “但是，等等！” 你说，“不是以 root 去运行这些作业？” 不一定。在这篇文章中的第一个示例中，出现在注释中的用户名字段可以用于去指定一个运行作业的用户 ID。这可以防止特定的非 root 用户的作业以 root 身份去运行。下面的示例展示了一个作业定义，它以 “student” 用户去运行这个作业：
```
04 07 * * * student /usr/local/bin/mycronjob.sh
```
如果没有指定用户，这个作业将以 contab 文件的所有者用户去运行，在这个情况中是 root。
#### cron.d
目录 `/etc/cron.d` 中是一些应用程序，比如 [SpamAssassin](http://spamassassin.apache.org/) 和 [sysstat](https://github.com/sysstat/sysstat) 安装的 cron 文件。因为，这里没有 spamassassin 或者 sysstat 用户，这些程序需要一个位置去放置 cron 文件，因此，它们被放在 `/etc/cron.d` 中。
下面的 `/etc/cron.d/sysstat` 文件包含系统活动报告（SAR）相关的 cron 作业。这些 cron 文件和用户 cron 文件格式相同。
```
# Run system activity accounting tool every 10 minutes
*/10 * * * * root /usr/lib64/sa/sa1 1 1
# Generate a daily summary of process accounting at 23:53
53 23 * * * root /usr/lib64/sa/sa2 -A
```
*sysstat 包安装了 `/etc/cron.d/sysstat` cron 文件来运行程序生成 SAR。*
该 sysstat cron 文件有两行执行任务。第一行每十分钟去运行 `sa1` 程序去收集数据，存储在 `/var/log/sa` 目录中的一个指定的二进制文件中。然后，在每天晚上的 23:53， `sa2` 程序运行来创建一个每日汇总。
#### 计划小贴士
我在 crontab 文件中设置的有些时间看上起似乎是随机的，在某种程度上说，确实是这样的。尝试去安排 cron 作业可能是件很具有挑战性的事， 尤其是作业的数量越来越多时。我通常在我的每个电脑上仅有一些任务，它比起我工作用的那些生产和实验环境中的电脑简单多了。
我管理的一个系统有 12 个每天晚上都运行 cron 作业，另外 3、4 个在周末或月初运行。那真是个挑战，因为，如果有太多作业在同一时间运行，尤其是备份和编译系统，会耗尽内存并且几乎填满交换文件空间，这会导致系统性能下降甚至是超负荷，最终什么事情都完不成。我增加了一些内存并改进了如何计划任务。我还删除了一些写的很糟糕、使用大量内存的任务。
crond 服务假设主机计算机 24 小时运行。那意味着如果在一个计划运行的期间关闭计算机，这些计划的任务将不再运行，直到它们计划的下一次运行时间。如果这里有关键的 cron 作业，这可能导致出现问题。 幸运的是，在定期运行的作业上，还有一个其它的选择： `anacron`。
### anacron
[anacron](https://en.wikipedia.org/wiki/Anacron) 程序执行和 cron 一样的功能，但是它增加了运行被跳过的作业的能力，比如，如果计算机已经关闭或者其它的原因导致无法在一个或多个周期中运行作业。它对笔记本电脑或其它被关闭或进行睡眠模式的电脑来说是非常有用的。
只要电脑一打开并引导成功，anacron 会检查过去是否有计划的作业被错过。如果有，这些作业将立即运行，但是，仅运行一次（而不管它错过了多少次循环运行）。例如，如果一个每周运行的作业在最近三周因为休假而系统关闭都没有运行，它将在你的电脑一启动就立即运行，但是，它仅运行一次，而不是三次。
anacron 程序提供了一些对周期性计划任务很好用的选项。它是安装在你的 `/etc/cron.[hourly|daily|weekly|monthly]` 目录下的脚本。 根据它们需要的频率去运行。
它是怎么工作的呢？接下来的这些要比前面的简单一些。
1、 crond 服务运行在 `/etc/cron.d/0hourly` 中指定的 cron 作业。
```
# Run the hourly jobs
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
01 * * * * root run-parts /etc/cron.hourly
```
*`/etc/cron.d/0hourly` 中的内容使位于 `/etc/cron.hourly` 中的 shell 脚本运行。*
2、 在 `/etc/cron.d/0hourly` 中指定的 cron 作业每小时运行一次 `run-parts` 程序。
3、 `run-parts` 程序运行所有的在 `/etc/cron.hourly` 目录中的脚本。
4、 `/etc/cron.hourly` 目录包含的 `0anacron` 脚本，它使用如下的 `/etdc/anacrontab` 配置文件去运行 anacron 程序。
```
# /etc/anacrontab: configuration file for anacron
# See anacron(8) and anacrontab(5) for details.
SHELL=/bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
# the maximal random delay added to the base delay of the jobs
RANDOM_DELAY=45
# the jobs will be started during the following hours only
START_HOURS_RANGE=3-22
#period in days delay in minutes job-identifier command
1 5 cron.daily nice run-parts /etc/cron.daily
7 25 cron.weekly nice run-parts /etc/cron.weekly
@monthly 45 cron.monthly nice run-parts /etc/cron.monthly
```
*`/etc/anacrontab` 文件中的内容在合适的时间运行在 `cron.[daily|weekly|monthly]` 目录中的可执行文件。*
5、 anacron 程序每日运行一次位于 `/etc/cron.daily` 中的作业。它每周运行一次位于 `/etc/cron.weekly` 中的作业。以及每月运行一次 `cron.monthly` 中的作业。注意，在每一行指定的延迟时间，它可以帮助避免这些作业与其它 cron 作业重叠。
我在 `/usr/local/bin` 目录中放置它们，而不是在 `cron.X` 目录中放置完整的 Bash 程序，这会使我从命令行中运行它们更容易。然后，我在 cron 目录中增加一个符号连接，比如，`/etc/cron.daily`。
anacron 程序不是设计用于在指定时间运行程序的。而是，用于在一个指定的时间开始，以一定的时间间隔去运行程序，比如，从每天的凌晨 3:00（看上面脚本中的 `START_HOURS_RANGE` 行）、从周日（每周第一天）和这个月的第一天。如果任何一个或多个循环错过，anacron 将立即运行这个错过的作业。
### 更多的关于设置限制
我在我的计算机上使用了很多运行计划任务的方法。所有的这些任务都需要一个 root 权限去运行。在我的经验中，很少有普通用户去需要运行 cron 任务，一种情况是开发人员需要一个 cron 作业去启动一个开发实验室的每日编译。
限制非 root 用户去访问 cron 功能是非常重要的。然而，在一些特殊情况下，用户需要去设置一个任务在预先指定时间运行，而 cron 可以允许他们去那样做。许多用户不理解如何正确地配置 cron 去完成任务，并且他们会出错。这些错误可能是无害的，但是，往往不是这样的，它们可能导致问题。通过设置功能策略，使用户与管理员互相配合，可以使个别的 cron 作业尽可能地不干扰其它的用户和系统功能。
可以给为单个用户或组分配的资源设置限制，但是，这是下一篇文章中的内容。
更多信息，在 [cron](http://man7.org/linux/man-pages/man8/cron.8.html)、[crontab](http://man7.org/linux/man-pages/man5/crontab.5.html)、[anacron](http://man7.org/linux/man-pages/man8/anacron.8.html)、[anacrontab](http://man7.org/linux/man-pages/man5/anacrontab.5.html)、和 [run-parts](http://manpages.ubuntu.com/manpages/zesty/man8/run-parts.8.html) 的 man 页面上，所有的这些信息都描述了 cron 系统是如何工作的。
---
作者简介：
David Both - 是一位 Linux 和开源软件的倡导者，居住在 Raleigh，North Carolina。他从事 IT 行业超过四十年，并且在 IBM 教授 OS/2 超过 20 年时间，他在 1981 年 IBM 期间，为最初的 IBM PC 写了第一部培训教程。他为 Red Hat 教授 RHCE 系列课程，并且他也为 MCI Worldcom、 Cisco、和 North Carolina 州工作。他使用 Linux 和开源软件工作差不多 20 年了。
---
via: <https://opensource.com/article/17/11/how-use-cron-linux>
作者：[David Both](https://opensource.com/users/dboth) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
CyberShaolin：培养下一代网络安全专家
|
Swapnil Bhartiya
|
https://www.linuxfoundation.org/blog/cybershaolin-teaching-next-generation-cybersecurity-experts/
|
现年 11 岁的 Reuben Paul 并不是唯一一个玩电子游戏的孩子，但是他对游戏和电脑的痴迷使他走上了一段独特的好奇之旅，引起了他对网络安全教育和宣传的早期兴趣，并创立了 CyberShaolin，一个帮助孩子理解网络攻击的威胁的组织。
|
/data/attachment/album/201711/15/115826un1nfz7720rw1y7w.jpg.thumb.jpg
|
/data/attachment/album/201711/15/115826un1nfz7720rw1y7w.jpg
| true
| false
| true
|
geekpi
| false
|
[
"网络安全"
] |
观点
|
{
"viewnum": 3933,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
现年 11 岁的 Reuben Paul 并不是唯一一个玩电子游戏的孩子，但是他对游戏和电脑的痴迷使他走上了一段独特的好奇之旅，引起了他对网络安全教育和宣传的早期兴趣，并创立了 CyberShaolin，一个帮助孩子理解网络攻击的威胁的组织。
| 2017-11-15T11:54:00
| 2017-11-15T11:54:00
| 9,058
|
/article-9058-1.html
|
>
> CyberShaolin 联合创始人 Reuben Paul 将在布拉格的开源峰会上发表演讲，强调网络安全意识对于孩子们的重要性。
>
>
>
Reuben Paul 并不是唯一一个玩电子游戏的孩子，但是他对游戏和电脑的痴迷使他走上了一段独特的好奇之旅，引起了他对网络安全教育和宣传的早期兴趣，并创立了 CyberShaolin，一个帮助孩子理解网络攻击的威胁的组织。现年 11 岁的 Paul 将在[布拉格开源峰会]（LCTT 译注：已于 10 月 28 举办）上发表主题演讲，分享他的经验，并强调玩具、设备和日常使用的其他技术的不安全性。
*CyberShaolin 联合创始人 Reuben Paul*
我们采访了 Paul 听取了他的故事，并讨论 CyberShaolin 及其教育、赋予孩子（及其父母）的网络安全危险和防御知识。
**Linux.com：你对电脑的迷恋是什么时候开始的？**
Reuben Paul：我对电脑的迷恋始于电子游戏。我喜欢手机游戏以及视频游戏。（我记得是）当我大约 5 岁时，我通过 Gameloft 在手机上玩 “Asphalt” 赛车游戏。这是一个简单而有趣的游戏。我得触摸手机右侧加快速度，触摸手机左侧减慢速度。我问我爸，“游戏怎么知道我触摸了哪里？”
他研究发现，手机屏幕是一个 xy 坐标系统，所以他告诉我，如果 x 值大于手机屏幕宽度的一半，那么它是右侧的触摸。否则，这是左侧接触。为了帮助我更好地理解这是如何工作的，他给了我一个线性的方程，它是 y = mx + b，并问：“你能找每个 x 值 对应的 y 值吗？”大约 30 分钟后，我计算出了所有他给我的 x 对应的 y 值。
当我父亲意识到我能够学习编程的一些基本逻辑时，他给我介绍了 Scratch，并且使用鼠标指针的 x 和 y 值编写了我的第一个游戏 - 名为 “大鱼吃小鱼”。然后，我爱上了电脑。
**Linux.com：你对网络安全感兴趣吗？**
Paul：我的父亲 Mano Paul 曾经在网络安全方面培训他的商业客户。每当他在家里工作，我都会听到他的电话交谈。到了我 6 岁的时候，我就知道互联网、防火墙和云计算等东西。当我的父亲意识到我有兴趣和学习的潜力，他开始教我安全方面，如社会工程技术、克隆网站、中间人攻击技术、hack 移动应用等等。当我第一次从目标测试机器上获得一个 meterpreter shell 时，我的感觉就像 Peter Parker 刚刚发现他的蜘蛛侠的能力一样。
**Linux.com：你是如何以及为什么创建 CyberShaolin 的？**
Paul：当我 8 岁的时候，我首先在 DerbyCon 上做了主题为“来自（8 岁大）孩子之口的安全信息”的演讲。那是在 2014 年 9 月。那次会议之后，我收到了几个邀请函，2014 年底之前，我还在其他三个会议上做了主题演讲。
所以，当孩子们开始听到我在这些不同的会议上发言时，他们开始写信给我，要我教他们。我告诉我的父母，我想教别的孩子，他们问我怎么想。我说：“也许我可以制作一些视频，并在像 YouTube 这样的频道上发布。”他们问我是否要收费，而我说“不”。我希望我的视频可以免费供在世界上任何地方的任何孩子使用。CyberShaolin 就是这样创建的。
**Linux.com：CyberShaolin 的目标是什么？**
Paul：CyberShaolin 是我父母帮助我创立的非营利组织。它的任务是教育、赋予孩子（和他们的父母）掌握网络安全的危险和防范知识，我在学校的空闲时间开发了这些视频和其他训练材料，连同功夫、体操、游泳、曲棍球、钢琴和鼓等。迄今为止，我已经在 [www.CyberShaolin.org](http://www.Cyber%E2%80%8B%E2%80%8BShaolin.org) 网站上发布了大量的视频，并计划开发更多的视频。我也想制作游戏和漫画来支持安全学习。
CyberShaolin 来自两个词：网络和少林。网络这个词当然是来自技术。少林来自功夫武术，我和我的父亲都是黑带 2 段。在功夫方面，我们有显示知识进步的缎带，你可以想像 CyberShaolin 像数码技术方面的功夫，在我们的网站上学习和考试后，孩子们可以成为网络黑带。
**Linux.com：你认为孩子对网络安全的理解有多重要？**
Paul：我们生活在一个技术和设备不仅存在我们家里，还在我们学校和几乎任何你去的地方的时代。世界也正在与物联网联系起来，这些物联网很容易成为威胁网（Internet of Threats）。儿童是这些技术和设备的主要用户之一。不幸的是，这些设备和设备上的应用程序不是很安全，可能会给儿童和家庭带来严重的问题。例如，最近（2017 年 5 月），我演示了如何攻入智能玩具泰迪熊，并将其变成远程侦察设备。孩子也是下一代。如果他们对网络安全没有意识和训练，那么未来（我们的未来）将不会很好。
**Linux.com：该项目如何帮助孩子？**
Paul：正如我之前提到的，CyberShaolin 的使命是教育、赋予孩子（和他们的父母）网络安全的危险和防御知识。
当孩子们受到网络欺凌、中间人、钓鱼、隐私、在线威胁、移动威胁等网络安全危害的教育时，他们将具备知识和技能，从而使他们能够在网络空间做出明智的决定并保持安全。而且，正如我永远不会用我的功夫技能去伤害某个人一样，我希望所有的 CyberShaolin 毕业生都能利用他们的网络功夫技能为人类的利益创造一个安全的未来。
---
作者简介：
Swapnil Bhartiya 是一名记者和作家，专注在 Linux 和 Open Source 上 10 多年。
---
via: <https://www.linuxfoundation.org/blog/cybershaolin-teaching-next-generation-cybersecurity-experts/>
作者：[Swapnil Bhartiya](https://www.linuxfoundation.org/author/sbhartiya/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
AWS 采用自制的 KVM 作为新的管理程序
|
Simon Sharwood
|
https://www.theregister.co.uk/2017/11/07/aws_writes_new_kvm_based_hypervisor_to_make_its_cloud_go_faster/
|
这是爆炸性的新闻，因为 AWS 长期以来一直支持 Xen 管理程序。Xen 项目从最强大的公共云使用其开源软件的这个事实中吸取了力量。Citrix 将其大部分 Xen 服务器运行了 AWS 的管理程序的闭源兄弟。
|
/data/attachment/album/201711/15/132754vcnn44gc4n4j94nw.jpg.thumb.jpg
|
/data/attachment/album/201711/15/132754vcnn44gc4n4j94nw.jpg
| true
| false
| true
|
geekpi
| false
|
[
"AWS",
"KVM"
] |
新闻
|
{
"viewnum": 4604,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 2,
"likes": 0
}
|
[] |
[] |
这是爆炸性的新闻，因为 AWS 长期以来一直支持 Xen 管理程序。Xen 项目从最强大的公共云使用其开源软件的这个事实中吸取了力量。Citrix 将其大部分 Xen 服务器运行了 AWS 的管理程序的闭源兄弟。
| 2017-11-15T13:28:00
| 2017-11-15T13:28:00
| 9,059
|
/article-9059-1.html
|
>
> 摆脱了 Xen，新的 C5 实例和未来的虚拟机将采用“核心 KVM 技术”
>
>
>
AWS 透露说它已经创建了一个基于 KVM 的新的<ruby> 管理程序 <rt> hypervisor </rt></ruby>，而不是多年来依赖的 Xen 管理程序。
新的虚拟机管理程序披露在 EC2 新实例类型的[新闻](https://aws.amazon.com/blogs/aws/now-available-compute-intensive-c5-instances-for-amazon-ec2/)脚注里，新实例类型被称为 “C5”，由英特尔的 Skylake Xeon 提供支持。AWS 关于新实例的 [FAQ](https://aws.amazon.com/ec2/faqs/#compute-optimized) 提及“C5 实例使用新的基于核心 KVM 技术的 EC2 虚拟机管理程序”。
这是爆炸性的新闻，因为 AWS 长期以来一直支持 Xen 管理程序。Xen 项目从最强大的公共云使用其开源软件的这个事实中吸取了力量。Citrix 将其大部分 Xen 服务器运行了 AWS 的管理程序的闭源版本。
更有趣的是，AWS 新闻中说：“未来，我们将使用这个虚拟机管理程序为其他实例类型提供动力。” 这个互联网巨头的文章中计划在“一系列 AWS re:Invent 会议中分享更多的技术细节”。
这听上去和很像 AWS 要放弃 Xen。
新的管理程序还有很长的路要走，这解释了为什么 AWS 是[最后一个运行 Intel 新的 Skylake Xeon CPU 的大型云服务商](https://www.theregister.co.uk/2017/10/24/azure_adds_skylakes_in_fv2_instances/)，因为 AWS 还透露了新的 C5 实例运行在它所描述的“定制处理器上，针对 EC2 进行了优化。”
Intel 和 AWS 都表示这是一款定制的 3.0 GHz Xeon Platinum 8000 系列处理器。Chipzilla 提供了一些该 CPU 的[新闻发布级别的细节](https://newsroom.intel.com/news/intel-xeon-scalable-processors-supercharge-amazon-web-services/)，称它与 AWS 合作开发了“使用最新版本的 Intel 数学核心库优化的 AI/深度学习引擎”，以及“ MXNet 和其他深度学习框架为在 Amazon EC2 C5 实例上运行进行了高度优化。”
Intel 之前定制了 Xeons，将其提供给 [Oracle](https://www.theregister.co.uk/2015/06/04/oracle_intel_team_on_server_with_a_dimmer_switch/) 等等。AWS 大量购买 CPU，所以英特尔再次这样做并不意外。
迁移到 KVM 更令人惊讶，但是 AWS 可以根据需要来调整云服务以获得最佳性能。如果这意味着构建一个虚拟机管理程序，并确保它使用自定义的 Xeon，那就这样吧。
不管它在三周内发布了什么，AWS 现在都在说 C5 实例和它们的新虚拟机管理程序有更高的吞吐量，新的虚拟机在连接到弹性块存储 （EBS） 的网络和带宽都超过了之前的最佳记录。
以下是 AWS 在 FAQ 中的说明：
>
> 随着 C5 实例的推出，Amazon EC2 的新管理程序是一个主要为 C5 实例提供 CPU 和内存隔离的组件。VPC 网络和 EBS 存储资源是由所有当前 EC2 实例家族的一部分的专用硬件组件实现的。
>
>
> 它基于核心的 Linux 内核虚拟机（KVM）技术，但不包括通用的操作系统组件。
>
>
>
换句话说，网络和存储在其他地方完成，而不是集中在隔离 CPU 和内存资源的管理程序上：
>
> 新的 EC2 虚拟机管理程序通过删除主机系统软件组件，为 EC2 虚拟化实例提供一致的性能和增长的计算和内存资源。该硬件使新的虚拟机管理程序非常小，并且对用于网络和存储的数据处理任务没有影响。
>
>
> 最终，所有新实例都将使用新的 EC2 虚拟机管理程序，但是在近期内，根据平台的需求，一些新的实例类型将使用 Xen。
>
>
> 运行在新 EC2 虚拟机管理程序上的实例最多支持 27 个用于 EBS 卷和 VPC ENI 的附加 PCI 设备。每个 EBS 卷或 VPC ENI 使用一个 PCI 设备。例如，如果将 3 个附加网络接口连接到使用新 EC2 虚拟机管理程序的实例，则最多可以为该实例连接 24 个 EBS 卷。
>
>
> 所有面向公众的与运行新的 EC2 管理程序的 EC2 交互 API 都保持不变。例如，DescribeInstances 响应的 “hypervisor” 字段将继续为所有 EC2 实例报告 “xen”，即使是在新的管理程序下运行的实例也是如此。这个字段可能会在未来版本的 EC2 API 中删除。
>
>
>
你应该查看 FAQ 以了解 AWS 转移到其新虚拟机管理程序的全部影响。以下是新的基于 KVM 的 C5 实例的统计数据：
| 实例名 | vCPU | RAM（GiB） | EBS\*带宽 | 网络带宽 |
| --- | --- | --- | --- | --- |
| c5.large | 2 | 4 | 最高 2.25 Gbps | 最高 10 Gbps |
| c5.xlarge | 4 | 8 | 最高 2.25 Gbps | 最高 10 Gbps |
| c5.2xlarge | 8 | 16 | 最高 2.25 Gbps | 最高 10 Gbps |
| c5.4xlarge | 16 | 32 | 2.25 Gbps | 最高 10 Gbps |
| c5.9xlarge | 36 | 72 | 4.5 Gbps | 10 Gbps |
| c5.18xlarge | 72 | 144 | 9 Gbps | 25 Gbps |
每个 vCPU 都是 Amazon 购买的物理 CPU 上的一个线程。
现在，在 AWS 的美国东部、美国西部（俄勒冈州）和欧盟地区，可以使用 C5 实例作为按需或点播服务器。该公司承诺其他地区将尽快提供。
---
via: <https://www.theregister.co.uk/2017/11/07/aws_writes_new_kvm_based_hypervisor_to_make_its_cloud_go_faster/>
作者：[Simon Sharwood](https://www.theregister.co.uk/Author/Simon-Sharwood) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
原生云计算：你所不知道的 Kubernetes 特性和工具
|
Steven J. Vaughan-nichols
|
https://insights.hpe.com/articles/how-to-implement-cloud-native-computing-with-kubernetes-1710.html
|
开放容器计划（OCI）和原生云计算基金会（CNCF）的代表说，Kubernetes 和容器可以在降低程序员和系统管理成本的同时加速部署进程，从被忽视的 Kubernetes 特性（比如命令空间）开始，去利用 Kubernetes 和它的相关工具运行一个原生云架构。
|
/data/attachment/album/201711/16/014700ukj3k7llk71kkjpk.jpg.thumb.jpg
|
/data/attachment/album/201711/16/014700ukj3k7llk71kkjpk.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"Kubernetes",
"OCI"
] |
容器与云
|
{
"viewnum": 3829,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9075,
"displayorder": 0
}
] |
开放容器计划（OCI）和原生云计算基金会（CNCF）的代表说，Kubernetes 和容器可以在降低程序员和系统管理成本的同时加速部署进程，从被忽视的 Kubernetes 特性（比如命令空间）开始，去利用 Kubernetes 和它的相关工具运行一个原生云架构。
| 2017-11-16T01:46:56
| 2017-11-16T01:46:56
| 9,060
|
/article-9060-1.html
|
>
> 开放容器计划（OCI）和原生云计算基金会（CNCF）的代表说，Kubernetes 和容器可以在降低程序员和系统管理成本的同时加速部署进程，从被忽视的 Kubernetes 特性（比如命令空间）开始，去利用 Kubernetes 和它的相关工具运行一个原生云架构。
>
>
>
[Kubernetes](https://kubernetes.io/) 不止是一个云容器管理器。正如 Steve Pousty，他是 [Red Hat](https://www.redhat.com/en) 支持的 [OpenShift](https://www.openshift.com/) 的首席开发者，在 [Linux 基金会](https://www.linuxfoundation.org/)的[开源峰会](http://events.linuxfoundation.org/events/open-source-summit-north-america)上的讲演中解释的那样，Kubernetes 提供了一个 “使用容器进行原生云计算的通用操作平台”。
Pousty 的意思是什么？先让我们复习一下基础知识。
[开源容器计划](https://www.opencontainers.org/)（OCI）和 [原生云计算基金会](https://www.cncf.io/) （CNCF）的执行董事 Chris Aniszczyk 的解释是，“原生云计算使用开源软件栈将应用程序部署为微服务，打包每一个部分到其容器中，并且动态地编排这些容器以优化资源使用”。[Kubernetes 一直在关注着原生云计算的最新要素](https://insights.hpe.com/articles/the-basics-explaining-kubernetes-mesosphere-and-docker-swarm-1702.html)。这将最终将导致 IT 中很大的一部分发生转变，如从服务器到虚拟机，从<ruby> 构建包 <rt> buildpack </rt></ruby>到现在的 [容器](https://insights.hpe.com/articles/when-to-use-containers-and-when-not-to-1705.html)。
会议主持人表示，数据中心的演变将节省相当可观的成本，部分原因是它需要更少的专职员工。例如，据 Aniszczyk 说，通过使用 Kubernetes，谷歌每 10000 台机器仅需要一个网站可靠性工程师（LCTT 译注：即 SRE）。
实际上，系统管理员可以利用新的 Kubernetes 相关的工具的优势，并了解那些被低估的功能。
### 构建一个原生云平台
Pousty 解释说，“对于 Red Hat 来说，Kubernetes 是云 Linux 的内核。它是每个人都可以构建于其上的基础设施”。
例如，假如你在一个容器镜像中有一个应用程序。你怎么知道它是安全的呢？ Red Hat 和其它的公司使用 [OpenSCAP](https://www.open-scap.org/)，它是基于 <ruby> <a href="https://scap.nist.gov/"> 安全内容自动化协议 </a> <rt> Security Content Automation Protocol </rt></ruby>（SCAP）的，是使用标准化的方式表达和操作安全数据的一个规范。OpenSCAP 项目提供了一个开源的强化指南和配置基准。选择一个合适的安全策略，然后，使用 OpenSCAP 认可的安全工具去使某些由 Kubernetes 控制的容器中的程序遵守这些定制的安全标准。
Red Hat 将使用<ruby> <a href="https://developers.redhat.com/blog/2016/05/02/introducing-atomic-scan-container-vulnerability-detection/"> 原子扫描 </a> <rt> Atomic Scan </rt></ruby>来自动处理这个过程；它借助 OpenSCAP <ruby> 提供者 <rt> provider </rt></ruby>来扫描容器镜像中已知的安全漏洞和策略配置问题。原子扫描会以只读方式加载文件系统。这些通过扫描的容器，会在一个可写入的目录存放扫描器的输出。
Pousty 指出，这种方法有几个好处，主要是，“你可以扫描一个容器镜像而不用实际运行它”。因此，如果在容器中有糟糕的代码或有缺陷的安全策略，它不会影响到你的系统。
原子扫描比手动运行 OpenSCAP 快很多。 因为容器从启用到消毁可能就在几分钟或几小时内，原子扫描允许 Kubernetes 用户在（很快的）容器生命期间保持容器安全，而不是在更缓慢的系统管理时间跨度里进行。
### 关于工具
帮助系统管理员和 DevOps 管理大部分 Kubernetes 操作的另一个工具是 [CRI-O](http://cri-o.io/)。这是一个基于 OCI 实现的 [Kubernetes 容器运行时接口](http://blog.kubernetes.io/2016/12/container-runtime-interface-cri-in-kubernetes.html)。CRI-O 是一个守护进程， Kubernetes 可以用于运行存储在 Docker 仓库中的容器镜像，Dan Walsh 解释说，他是 Red Hat 的顾问工程师和 [SELinux](https://wiki.centos.org/HowTos/SELinux) 项目领导者。它允许你直接从 Kubernetes 中启动容器镜像，而不用花费时间和 CPU 处理时间在 [Docker 引擎](https://docs.docker.com/engine/) 上启动。并且它的镜像格式是与容器无关的。
在 Kubernetes 中， [kubelet](https://kubernetes.io/docs/admin/kubelet/) 管理 pod（容器集群）。使用 CRI-O，Kubernetes 及其 kubelet 可以管理容器的整个生命周期。这个工具也不是和 Docker 镜像捆绑在一起的。你也可以使用新的 [OCI 镜像格式](http://www.zdnet.com/article/containers-consolidation-open-container-initiative-1-0-released/) 和 [CoreOS 的 rkt](https://coreos.com/rkt/docs/latest/) 容器镜像。
同时，这些工具正在成为一个 Kubernetes 栈：编排系统、[容器运行时接口](http://blog.kubernetes.io/2016/12/container-runtime-interface-cri-in-kubernetes.html) （CRI）和 CRI-O。Kubernetes 首席工程师 Kelsey Hightower 说，“我们实际上不需要这么多的容器运行时——无论它是 Docker 还是 [rkt](https://coreos.com/rkt/)。只需要给我们一个到内核的 API 就行”，这个结果是这些技术人员的承诺，是推动容器比以往更快发展的强大动力。
Kubernetes 也可以加速构建容器镜像。目前为止，有[三种方法来构建容器](http://chris.collins.is/2017/02/24/three-docker-build-strategies/)。第一种方法是通过一个 Docker 或者 CoreOS 去构建容器。第二种方法是注入定制代码到一个预构建镜像中。最后一种方法是，<ruby> 资产生成管道 <rt> Asset Generation Pipeline </rt></ruby>使用容器去编译那些<ruby> 资产 <rt> asset </rt></ruby>，然后其被包含到使用 Docker 的<ruby> <a href="https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds"> 多阶段构建 </a> <rt> Multi-Stage Build </rt></ruby>所构建的随后镜像中。
现在，还有一个 Kubernetes 原生的方法：Red Hat 的 [Buildah](https://github.com/projectatomic/buildah)， 这是[一个脚本化的 shell 工具](https://www.projectatomic.io/blog/2017/06/introducing-buildah/) 用于快速、高效地构建 OCI 兼容的镜像和容器。Buildah 降低了容器环境的学习曲线，简化了创建、构建和更新镜像的难度。Pousty 说。你可以使用它和 Kubernetes 一起基于应用程序的调用来自动创建和使用容器。Buildah 也更节省系统资源，因为它不需要容器运行时守护进程。
因此，比起真实地引导一个容器和在容器内按步骤操作，Pousty 说，“挂载该文件系统，就如同它是一个常规的文件系统一样做一些正常操作，并且在最后提交”。
这意味着你可以从一个仓库中拉取一个镜像，创建它所匹配的容器，并且优化它。然后，你可以使用 Kubernetes 中的 Buildah 在你需要时去创建一个新的运行镜像。最终结果是，他说，运行 Kubernetes 管理的容器化应用程序比以往速度更快，需要的资源更少。
### 你所不知道的 Kubernetes 拥有的特性
你不需要在其它地方寻找工具。Kubernetes 有几个被低估的特性。
根据谷歌云全球产品经理 Allan Naim 的说法，其中一个是 [Kubernetes 命名空间](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/)。Naim 在开源峰会上谈及 “Kubernetes 最佳实践”，他说，“很少有人使用命名空间，这是一个失误。”
“命名空间是将一个单个的 Kubernetes 集群分成多个虚拟集群的方法”，Naim 说。例如，“你可以认为命名空间就是<ruby> 姓氏 <rt> family name </rt></ruby>”，因此，假如说 “Simth” 用来标识一个家族，如果有个成员 Steve Smith，他的名字就是 “Steve”，但是，家族范围之外的，它就是 “Steve Smith” 或称 “来自 Chicago 的 Steve Smith”。
严格来说，“命名空间是一个逻辑分区技术，它允许一个 Kubernetes 集群被多个用户、用户团队或者一个用户的多个不能混淆的应用程序所使用。Naim 解释说，“每个用户、用户团队、或者应用程序都可以存在于它的命名空间中，与集群中的其他用户是隔离的，并且可以像你是这个集群的唯一用户一样操作它。”
Practically 说，你可以使用命名空间去构建一个企业的多个业务/技术的实体进入 Kubernetes。例如，云架构可以通过映射产品、地点、团队和成本中心为命名空间，从而定义公司的命名空间策略。
Naim 建议的另外的方法是，去使用命名空间将软件开发<ruby> 流程 <rt> pipeline </rt></ruby>划分到分离的命名空间中，如测试、质量保证、<ruby> 预演 <rt> staging </rt></ruby>和成品等常见阶段。或者命名空间也可以用于管理单独的客户。例如，你可以为每个客户、客户项目、或者客户业务单元去创建一个单独的命名空间。它可以更容易地区分项目，避免重用相同名字的资源。
然而，Kubernetes 现在还没有提供一个跨命名空间访问的控制机制。因此，Naim 建议你不要使用这种方法去对外公开程序。还要注意的是，命名空间也不是一个管理的“万能药”。例如，你不能将命名空间嵌套在另一个命名空间中。另外，也没有跨命名空间的强制安全机制。
尽管如此，小心地使用命名空间，还是很有用的。
### 以人为中心的建议
从谈论较深奥的技术换到项目管理。Pousty 建议，在转移到原生云和微服务架构时，在你的团队中要有一个微服务操作人员。“如果你去做微服务，你的团队最终做的就是 Ops-y。并且，不去使用已经知道这种操作的人是愚蠢的行为”，他说。“你需要一个正确的团队核心能力。我不想开发人员重新打造运维的轮子”。
而是，将你的工作流彻底地改造成一个能够使用容器和云的过程，对此，Kubernetes 是很适用的。
### 使用 Kubernetes 的原生云计算：领导者的课程
* 迅速扩大的原生云生态系统。寻找可以扩展你使用容器的方法的工具。
* 探索鲜为人知的 Kubernetes 特性，如命名空间。它们可以改善你的组织和自动化程度。
* 确保部署到容器的开发团队有一个 Ops 人员参与。否则，冲突将不可避免。
---
作者简介：
Steven J. Vaughan-Nichols, Vaughan-Nichols & Associates 的 CEO
Steven J. Vaughan-Nichols，即 sjvn，是一个技术方面的作家，从 CP/M-80 还是前沿技术、PC 操作系统、300bps 是非常快的因特网连接、WordStar 是最先进的文字处理程序的那个时候开始，一直从事于商业技术的写作，而且喜欢它。他的作品已经发布在了从高科技出版物（IEEE Computer、ACM Network、 Byte）到商业出版物（eWEEK、 InformationWeek、ZDNet），从大众科技（Computer Shopper、PC Magazine、PC World）再到主流出版商（Washington Post、San Francisco Chronicle、BusinessWeek) 等媒体之上。
---
via: <https://insights.hpe.com/articles/how-to-implement-cloud-native-computing-with-kubernetes-1710.html>
作者：[Steven J. Vaughan-Nichols](https://insights.hpe.com/contributors/steven-j-vaughan-nichols.html) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 中管理 EXT2、 EXT3 和 EXT4 健康状况的 4 个工具
|
Aaron Kili
|
https://www.tecmint.com/manage-ext2-ext3-and-ext4-health-in-linux/
|
受损的文件系统运行在你的系统上可能导致操作系统中的组件或用户应用程序的运行时错误，它可能会进一步扩大到服务器数据的丢失。为避免文件系统错误或损坏，你需要去持续关注它的健康状况。
|
/data/attachment/album/201711/16/164437f1c3321d0kg3oil0.jpg.thumb.jpg
|
/data/attachment/album/201711/16/164437f1c3321d0kg3oil0.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"fsck",
"ext",
"文件系统"
] |
技术
|
{
"viewnum": 7371,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
受损的文件系统运行在你的系统上可能导致操作系统中的组件或用户应用程序的运行时错误，它可能会进一步扩大到服务器数据的丢失。为避免文件系统错误或损坏，你需要去持续关注它的健康状况。
| 2017-11-16T16:44:45
| 2017-11-16T16:44:45
| 9,061
|
/article-9061-1.html
|
文件系统是一个在计算机上帮你去管理数据怎么去存储和检索的数据结构。文件系统也可以被视作是磁盘上的物理（或扩展）分区。如果它没有很好地被维护或定期监视，它可能在长期运行中出现各种各样的错误或损坏。
这里有几个可能导致文件系统出问题的因素：系统崩溃、硬件或软件故障、 有问题的驱动和程序、不正确的优化、大量的数据过载加上一些小故障。
这其中的任何一个问题都可以导致 Linux 不能顺利地挂载（或卸载）一个文件系统，从而导致系统故障。
扩展阅读：[Linux 中判断文件系统类型（Ext2, Ext3 或 Ext4）的 7 种方法](/article-8289-1.html)
另外，受损的文件系统运行在你的系统上可能导致操作系统中的组件或用户应用程序的运行时错误，它可能会进一步扩大到服务器数据的丢失。为避免文件系统错误或损坏，你需要去持续关注它的健康状况。
在这篇文章中，我们将介绍监视或维护一个 ext2、ext3 和 ext4 文件系统健康状况的工具。在这里描述的所有工具都需要 root 用户权限，因此，需要使用 [sudo 命令](/article-8278-1.html)去运行它们。
### 怎么去查看 EXT2/EXT3/EXT4 文件系统信息
`dumpe2fs` 是一个命令行工具，用于去转储 ext2/ext3/ext4 文件系统信息，这意味着它可以显示设备上文件系统的超级块和块组信息。
在运行 `dumpe2fs` 之前，先去运行 [df -hT](https://www.tecmint.com/how-to-check-disk-space-in-linux/) 命令，确保知道文件系统的设备名。
```
$ sudo dumpe2fs /dev/sda10
```
**示例输出：**
```
dumpe2fs 1.42.13 (17-May-2015)
Filesystem volume name:
Last mounted on: /
Filesystem UUID: bb29dda3-bdaa-4b39-86cf-4a6dc9634a1b
Filesystem magic number: 0xEF53
Filesystem revision #: 1 (dynamic)
Filesystem features: has_journal ext_attr resize_inode dir_index filetype needs_recovery extent flex_bg sparse_super large_file huge_file uninit_bg dir_nlink extra_isize
Filesystem flags: signed_directory_hash
Default mount options: user_xattr acl
Filesystem state: clean
Errors behavior: Continue
Filesystem OS type: Linux
Inode count: 21544960
Block count: 86154752
Reserved block count: 4307737
Free blocks: 22387732
Free inodes: 21026406
First block: 0
Block size: 4096
Fragment size: 4096
Reserved GDT blocks: 1003
Blocks per group: 32768
Fragments per group: 32768
Inodes per group: 8192
Inode blocks per group: 512
Flex block group size: 16
Filesystem created: Sun Jul 31 16:19:36 2016
Last mount time: Mon Nov 6 10:25:28 2017
Last write time: Mon Nov 6 10:25:19 2017
Mount count: 432
Maximum mount count: -1
Last checked: Sun Jul 31 16:19:36 2016
Check interval: 0 ()
Lifetime writes: 2834 GB
Reserved blocks uid: 0 (user root)
Reserved blocks gid: 0 (group root)
First inode: 11
Inode size: 256
Required extra isize: 28
Desired extra isize: 28
Journal inode: 8
First orphan inode: 6947324
Default directory hash: half_md4
Directory Hash Seed: 9da5dafb-bded-494d-ba7f-5c0ff3d9b805
Journal backup: inode blocks
Journal features: journal_incompat_revoke
Journal size: 128M
Journal length: 32768
Journal sequence: 0x00580f0c
Journal start: 12055
```
你可以通过 `-b` 选项来显示文件系统中的任何保留块，比如坏块（无输出说明没有坏块）：
```
$ sudo dumpe2fs -b
```
### 检查 EXT2/EXT3/EXT4 文件系统的错误
`e2fsck` 用于去检查 ext2/ext3/ext4 文件系统的错误。`fsck` 可以检查并且可选地 [修复 Linux 文件系统](https://www.tecmint.com/defragment-linux-system-partitions-and-directories/)；它实际上是底层 Linux 提供的一系列文件系统检查器 （fsck.fstype，例如 fsck.ext3、fsck.sfx 等等） 的前端程序。
记住，在系统引导时，Linux 会为 `/etc/fstab` 配置文件中被标为“检查”的分区自动运行 `e2fsck`/`fsck`。而在一个文件系统没有被干净地卸载时，一般也会运行它。
注意：不要在已挂载的文件系统上运行 e2fsck 或 fsck，在你运行这些工具之前，首先要去卸载分区，如下所示。
```
$ sudo unmount /dev/sda10
$ sudo fsck /dev/sda10
```
此外，可以使用 `-V` 开关去启用详细输出，使用 `-t` 去指定文件系统类型，像这样：
```
$ sudo fsck -Vt ext4 /dev/sda10
```
### 调优 EXT2/EXT3/EXT4 文件系统
我们前面提到过，导致文件系统损坏的其中一个因素就是不正确的调优。你可以使用 `tune2fs` 实用程序去改变 ext2/ext3/ext4 文件系统的可调优参数，像下面讲的那样。
去查看文件系统的超级块，包括参数的当前值，使用 `-l` 选项，如下所示。
```
$ sudo tune2fs -l /dev/sda10
```
**示例输出：**
```
tune2fs 1.42.13 (17-May-2015)
Filesystem volume name:
Last mounted on: /
Filesystem UUID: bb29dda3-bdaa-4b39-86cf-4a6dc9634a1b
Filesystem magic number: 0xEF53
Filesystem revision #: 1 (dynamic)
Filesystem features: has_journal ext_attr resize_inode dir_index filetype needs_recovery extent flex_bg sparse_super large_file huge_file uninit_bg dir_nlink extra_isize
Filesystem flags: signed_directory_hash
Default mount options: user_xattr acl
Filesystem state: clean
Errors behavior: Continue
Filesystem OS type: Linux
Inode count: 21544960
Block count: 86154752
Reserved block count: 4307737
Free blocks: 22387732
Free inodes: 21026406
First block: 0
Block size: 4096
Fragment size: 4096
Reserved GDT blocks: 1003
Blocks per group: 32768
Fragments per group: 32768
Inodes per group: 8192
Inode blocks per group: 512
Flex block group size: 16
Filesystem created: Sun Jul 31 16:19:36 2016
Last mount time: Mon Nov 6 10:25:28 2017
Last write time: Mon Nov 6 10:25:19 2017
Mount count: 432
Maximum mount count: -1
Last checked: Sun Jul 31 16:19:36 2016
Check interval: 0 ()
Lifetime writes: 2834 GB
Reserved blocks uid: 0 (user root)
Reserved blocks gid: 0 (group root)
First inode: 11
Inode size: 256
Required extra isize: 28
Desired extra isize: 28
Journal inode: 8
First orphan inode: 6947324
Default directory hash: half_md4
Directory Hash Seed: 9da5dafb-bded-494d-ba7f-5c0ff3d9b805
Journal backup: inode blocks
```
接下来，使用 `-c` 标识，你可以设置文件系统在挂载多少次后将进行 `e2fsck` 检查。下面这个命令指示系统每挂载 4 次之后，去对 `/dev/sda10` 运行 `e2fsck`。
```
$ sudo tune2fs -c 4 /dev/sda10
tune2fs 1.42.13 (17-May-2015)
Setting maximal mount count to 4
```
你也可以使用 `-i` 选项定义两次文件系统检查的时间间隔。下列的命令在两次文件系统检查之间设置了一个 2 天的时间间隔。
```
$ sudo tune2fs -i 2d /dev/sda10
tune2fs 1.42.13 (17-May-2015)
Setting interval between checks to 172800 seconds
```
现在，如果你运行下面的命令，你可以看到对 `/dev/sda10` 已经设置了文件系统检查的时间间隔。
```
$ sudo tune2fs -l /dev/sda10
```
**示例输出：**
```
Filesystem created: Sun Jul 31 16:19:36 2016
Last mount time: Mon Nov 6 10:25:28 2017
Last write time: Mon Nov 6 13:49:50 2017
Mount count: 432
Maximum mount count: 4
Last checked: Sun Jul 31 16:19:36 2016
Check interval: 172800 (2 days)
Next check after: Tue Aug 2 16:19:36 2016
Lifetime writes: 2834 GB
Reserved blocks uid: 0 (user root)
Reserved blocks gid: 0 (group root)
First inode: 11
Inode size: 256
Required extra isize: 28
Desired extra isize: 28
Journal inode: 8
First orphan inode: 6947324
Default directory hash: half_md4
Directory Hash Seed: 9da5dafb-bded-494d-ba7f-5c0ff3d9b805
Journal backup: inode blocks
```
要改变缺省的日志参数，可以使用 `-J` 选项。这个选项也有子选项： `size=journal-size` （设置日志的大小）、`device=external-journal` （指定日志存储的设备）和 `location=journal-location` （定义日志的位置）。
注意，这里一次仅可以为文件系统设置一个日志大小或设备选项：
```
$ sudo tune2fs -J size=4MB /dev/sda10
```
最后，同样重要的是，可以去使用 `-L` 选项设置文件系统的卷标，如下所示。
```
$ sudo tune2fs -L "ROOT" /dev/sda10
```
### 调试 EXT2/EXT3/EXT4 文件系统
`debugfs` 是一个简单的、交互式的、基于 ext2/ext3/ext4 文件系统的命令行调试器。它允许你去交互式地修改文件系统参数。输入 `?` 查看子命令或请求。
```
$ sudo debugfs /dev/sda10
```
缺省情况下，文件系统将以只读模式打开，使用 `-w` 标识去以读写模式打开它。使用 `-c` 选项以灾难（catastrophic）模式打开它。
**示例输出：**
```
debugfs 1.42.13 (17-May-2015)
debugfs: ?
Available debugfs requests:
show_debugfs_params, params
Show debugfs parameters
open_filesys, open Open a filesystem
close_filesys, close Close the filesystem
freefrag, e2freefrag Report free space fragmentation
feature, features Set/print superblock features
dirty_filesys, dirty Mark the filesystem as dirty
init_filesys Initialize a filesystem (DESTROYS DATA)
show_super_stats, stats Show superblock statistics
ncheck Do inode->name translation
icheck Do block->inode translation
change_root_directory, chroot
....
```
要展示未使用空间的碎片，使用 `freefrag` 请求，像这样：
```
debugfs: freefrag
```
**示例输出：**
```
Device: /dev/sda10
Blocksize: 4096 bytes
Total blocks: 86154752
Free blocks: 22387732 (26.0%)
Min. free extent: 4 KB
Max. free extent: 2064256 KB
Avg. free extent: 2664 KB
Num. free extent: 33625
HISTOGRAM OF FREE EXTENT SIZES:
Extent Size Range : Free extents Free Blocks Percent
4K... 8K- : 4883 4883 0.02%
8K... 16K- : 4029 9357 0.04%
16K... 32K- : 3172 15824 0.07%
32K... 64K- : 2523 27916 0.12%
64K... 128K- : 2041 45142 0.20%
128K... 256K- : 2088 95442 0.43%
256K... 512K- : 2462 218526 0.98%
512K... 1024K- : 3175 571055 2.55%
1M... 2M- : 4551 1609188 7.19%
2M... 4M- : 2870 1942177 8.68%
4M... 8M- : 1065 1448374 6.47%
8M... 16M- : 364 891633 3.98%
16M... 32M- : 194 984448 4.40%
32M... 64M- : 86 873181 3.90%
64M... 128M- : 77 1733629 7.74%
128M... 256M- : 11 490445 2.19%
256M... 512M- : 10 889448 3.97%
512M... 1024M- : 2 343904 1.54%
1G... 2G- : 22 10217801 45.64%
debugfs:
```
通过去简单浏览它所提供的简要描述，你可以试试更多的请求，比如，创建或删除文件或目录，改变当前工作目录等等。要退出 `debugfs`，使用 `q`。
现在就这些！我们收集了不同分类下的相关文章，你可以在里面找到对你有用的内容。
**文件系统使用信息：**
1. [12 Useful “df” Commands to Check Disk Space in Linux](https://www.tecmint.com/how-to-check-disk-space-in-linux/)
2. [Pydf an Alternative “df” Command to Check Disk Usage in Different Colours](https://www.tecmint.com/pyd-command-to-check-disk-usage/)
3. [10 Useful du (Disk Usage) Commands to Find Disk Usage of Files and Directories](https://www.tecmint.com/check-linux-disk-usage-of-files-and-directories/)
**检查磁盘或分区健康状况：**
1. [3 Useful GUI and Terminal Based Linux Disk Scanning Tools](https://www.tecmint.com/linux-disk-scanning-tools/)
2. [How to Check Bad Sectors or Bad Blocks on Hard Disk in Linux](https://www.tecmint.com/check-linux-hard-disk-bad-sectors-bad-blocks/)
3. [How to Repair and Defragment Linux System Partitions and Directories](https://www.tecmint.com/defragment-linux-system-partitions-and-directories/)
维护一个健康的文件系统可以提升你的 Linux 系统的整体性能。如果你有任何问题或更多的想法，可以使用下面的评论去分享。
---
via: <https://www.tecmint.com/manage-ext2-ext3-and-ext4-health-in-linux/>
作者：[Aaron Kili](https://www.tecmint.com/author/aaronkili/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[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
|
本文由高级咨询师薛亮据自由软件基金会（FSF）的英文原文翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
|
/data/attachment/album/201711/16/222341pv2m210nf98st7uf.png.thumb.jpg
|
/data/attachment/album/201711/16/222341pv2m210nf98st7uf.png
| true
| false
| true
|
薛亮
| false
|
[
"GPL",
"许可证"
] |
开源智慧
|
{
"viewnum": 8327,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "42.120.74.94",
"message": "感谢薛亮",
"username": "来自浙江杭州的 Chrome 72.0|Windows 7 用户",
"date": "2019-03-19T17:04:00"
},
{
"postip": "110.53.234.13",
"message": "终于把我的疑问解开了",
"username": "来自湖南长沙的 Firefox 73.0|Windows 10 用户",
"date": "2020-03-01T23:40:45"
}
] |
[
{
"raid": 8834,
"displayorder": 0
},
{
"raid": 9222,
"displayorder": 0
}
] |
本文由高级咨询师薛亮据自由软件基金会（FSF）的英文原文翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
| 2017-11-16T22:23:00
| 2017-11-16T22:23:00
| 9,062
|
/article-9062-1.html
|
本文由高级咨询师薛亮据自由软件基金会（FSF）的[英文原文](https://www.gnu.org/licenses/gpl-faq.html)翻译而成，这篇常见问题解答澄清了在使用 GNU 许可证中遇到许多问题，对于企业和软件开发者在实际应用许可证和解决许可证问题时具有很强的实践指导意义。
1. [关于 GNU 项目、自由软件基金会（FSF）及其许可证的基本问题](/article-8761-1.html)
2. [对于 GNU 许可证的一般了解](/article-8834-1.html)
3. 在您的程序中使用 GNU 许可证
4. 依据 GNU 许可证分发程序
5. 在编写其他程序时采用依据 GNU 许可证发布的程序
6. 将作品与依据 GNU 许可证发布的代码相结合
7. 关于违反 GNU 许可证的问题
### 3、在您的程序中使用 GNU 许可证
#### 3.1 如何从 (L)GPLv2 升级到 (L)GPLv3？
首先，在您的软件包中包含新版本的许可证。如果您在项目中使用 LGPL v3，请确保一同包含了 GPL v3 和 LGPL v3 的副本，因为 LGPL v3 现在被写成在 GPL v3 基础上的一系列附加许可。
其次，将所有现有的 v2 许可证<ruby> 通知 <rp> （ </rp> <rt> notice </rt> <rp> ） </rp></ruby>（通常位于每个文件的顶部）替换为“[如何使用 GNU 许可证](https://www.gnu.org/licenses/gpl-howto.html)”上新的推荐文本。它更加面向未来，因为它不再包括 FSF 的邮政地址。
当然，任何涉及软件包许可证的描述性的文本（如在 README中）也应该被适当更新。
#### 3.2 您能一步一步地指导我如何将GPL应用到我的程序吗？
请参阅 [GPL 说明书页面](https://www.gnu.org/licenses/gpl-howto.html)。
#### 3.3 为什么我要使用 GNU GPL，而不是其他自由软件许可证？（同 1.3）
使用 GNU GPL 将要求所有[发布的改进版本都是自由软件](https://www.gnu.org/philosophy/pragmatic.html)。这意味着您可以避免与您自己作品的专有修改版本进行竞争的风险。不过，在某些特殊情况下，最好使用一个[更宽松的许可证](https://www.gnu.org/licenses/why-not-lgpl.html)。
#### 3.4 为什么 GPL 要求程序的每个副本必须包含 GPL 许可证副本？（同 2.14）
作品包含许可证副本至关重要，因此获得程序副本的每个人都可以知道他们的权利是什么。
包括一个指向许可证的 URL，而不是将许可证本身包含在内，这是一种看起来很诱人的做法。但是您不能确定该 URL 在五年或十年后仍然有效。二十年后，我们今天所知道的 URL 们可能已不复存在。
不管网络将发生什么样的变化，确保拥有该程序副本的人员能够继续看到 GPL 许可证的唯一方法是，将许可证的副本包含在该程序中。
#### 3.5 只需将 GNU GPL 的副本放在我的存储库中就可以了吗？
仅将 GNU GPL 的副本放在存储库中的文件中，并不能明确地声明可以依据 GNU GPL 使用同一存储库中的代码。如果没有这样的声明，并不能完全清楚地表明许可证中的权限真的可以适用于任何特定的源文件。一个明确的声明将消除所有的疑问。
文件仅包含许可证文本，而没有一个声明规定某些其他文件被该许可证覆盖，类似于文件包含一个其他任何地方都不会调用的子例程。但这种相似之处并不完美：律师和法院可能应用常识得出结论，因为您希望以 GPL 方式许可代码，所以您必定要将GNU GPL 的副本放在那里。或许律师和法院不会这样做。但为什么要留下不确定性呢？
每个源文件中都应该包括声明文本。只要能够伴随代码，程序的 README 文件中的清晰声明从法律上来说就足够了，但是它们很容易分离。所以，为什么要[给您的代码许可证带来不确定性](https://www.gnu.org/licenses/gpl-faq.html#NoticeInSourceFile)的风险呢？
这与 GNU GPL 的具体内容无关。对于任何自由许可证来说都是正确的。
#### 3.6 为什么要在每个源文件中放置许可证<ruby> 通知 <rp> （ </rp> <rt> notice </rt> <rp> ） </rp></ruby>？
您应该在每个源文件的起始处放置通知，说明它所携带的许可证，以避免代码与其许可证被断开的风险。如果您存储库的 README 文件声明源文件遵循 GNU GPL，如果有人将该文件复制到另一个程序，会发生什么呢？ 其他上下文可能无法表明该文件的许可证是什么。它似乎有一些其他许可证，或[根本没有许可证](https://www.gnu.org/licenses/license-list.html#NoLicense)（这将使代码变成非自由软件）。
在每个源文件的开始添加版权声明和许可证通知很容易，造成这种混乱的可能性不大。
这与 GNU GPL 的具体内容无关。对于任何自由许可证来说都是正确的。
#### 3.7 如果作品不是很长，那该怎么办？（同 2.15）
如果整个软件包中只有很少的代码——我们使用的基准是不到 300 行，那么您可以使用一个宽松的许可证，而不是像 GNU GPL 这样的左版许可证（除非代码特别重要）。我们[建议这种情况使用 Apache 许可证 2.0]( https://www.gnu.org/licenses/license-recommendations.html#software)。
#### 3.8 为了节省空间，我是否可以省略 GPL 的引言部分，或者省略如何在自己的程序上使用 GPL 的<ruby> 指导 <rp> （ </rp> <rt> instructions </rt> <rp> ） </rp></ruby>部分吗？（同 2.21）
引言和指导是 GNU GPL 的组成部分，不能省略。事实上，GPL 是受版权保护的，其许可证规定只能逐字复制整个 GPL。（您可以使用法律条款制作[另一个许可证](https://www.gnu.org/licenses/gpl-faq.html#ModifyGPL)，但该许可证不再是 GNU GPL。）
引言和指导部分共约 1000 字，不到 GPL 总文字数量的 1/5。除非软件包本身很小，否则引言和指导不会对软件包的大小产生大幅度的改变。在软件包很小的情况下，您可以使用一个简单的<ruby> 全权 <rp> （ </rp> <rt> all-permissive </rt> <rp> ） </rp></ruby>许可证，而不是 GNU GPL。
#### 3.9 如何获得我的程序的版权，以便依据 GPL 发布？
根据<ruby> 《伯尔尼公约》 <rp> （ </rp> <rt> Berne Convention </rt> <rp> ） </rp></ruby>，所有书写成文的内容都将自动受版权保护。所以你没有必要做任何事情来“获得”你所写代码的版权——只要没有其他人声称拥有你的作品。
不过，在美国注册版权是一个很好的主意。这将给你在美国应对侵权者带来更多的影响力。
其他人可能声称拥有版权的情况是，如果您是雇员或学生；那么雇主或学校可能会声称你为他们做了工作，并且版权属于他们。他们是否存在有效的权利主张将取决于你所居住地方的法律，以及你的雇佣合同和你所做的工作。如果有任何疑问，最好咨询律师。
如果您认为雇主或学校可能会提出权利主张，您可以通过获得公司或学校适当授权的官员签署的版权免责声明来明确解决该问题。（您的直接上司或教授通常无权签署此免责声明。）
#### 3.10 如果我的学校想将我自己的程序应用到学校的专有软件产品，我该怎么办？
现在许多大学试图通过限制他们所开发的知识和信息的使用来筹集资金，其实际上与商业业务有所不同。 （参见刊载于 2000 年 3 月<ruby> 《大西洋月刊》 <rp> （ </rp> <rt> Atlantic Monthly </rt> <rp> ） </rp></ruby>的<ruby> 《受缚的大学》 <rp> （ </rp> <rt> The Kept University </rt> <rp> ） </rp></ruby>，该文章对这个问题及其影响进行了一般性的讨论。）
如果您在某种程度上认为您的学校可能拒绝允许您的程序作为自由软件发布，最好尽早提出这个问题。程序越接近于有用的作品，行政部门越有动机从你手里拿回该程序，并在没有你的情况下完成它。在更早的阶段，你有更多的影响力。
所以我们建议你在程序只进行一半的时候接触他们，说：“如果你同意将它作为自由软件发布，我会完成它。”不要以为这是虚张声势。要取得胜利，你必须有勇气说：“我的程序如果不能成为自由软件，我宁愿不把它写出来。”
#### 3.11 我想发布一个我依据 GNU GPL 编写的程序，但是我想在非自由程序中使用相同的代码。
发布一个非自由程序总是有道德上的污点，但从法律上来说没有任何障碍阻止你这样做。如果您是代码的版权所有者，您可以在不同时间以各种不同的非独占许可证发布。
#### 3.12 依据 GPL 分发的程序的开发人员是否可以将其授权给另一方专用？
不可以，因为公众已经有权利使用遵循 GPL 的该程序，这个权利是不能撤销的。
#### 3.13 美国政府可以依据 GNU GPL 发布一个程序吗？
如果这个程序是由美国联邦政府雇员在雇用过程中编写的，那么它是处于公有领域，这意味着它不受版权保护。由于GNU GPL是基于版权的许可证，所以这样的程序不能依据 GNU GPL 发布。（它仍然可以是[自由软件](https://www.gnu.org/philosophy/free-sw.html)，公有领域的程序是自由软件。）
不过，当美国联邦政府机构使用承包商来开发软件时，那就是不同的情况。合同可以要求承包商依据 GNU GPL 进行发布（GNU Ada 是以这种方式开发的）。或者合同可以将版权<ruby> 分配 <rp> （ </rp> <rt> assign </rt> <rp> ） </rp></ruby>给政府机构，然后政府机构可以依据 GNU GPL 发布该软件。
#### 3.14 美国政府可否对遵循 GPL 的程序进行改进并发布？
可以。如果这些改进是由美国政府雇员在雇佣期间编写的，那么这些改进属于公有领域。不过，GNU GPL 仍然涵盖了整体的改进版本。在这种情况下没有问题。
如果美国政府使用承包商来完成这项工作，那么改进本身可以被 GPL 覆盖。
#### 3.15 程序里为什么要说“GPL 的版本 3 或任何更新的版本”？
随着时间的推移，我们会不断更改 GPL——有时要澄清一下，有时允许以前不允许的某些用途，有时会收紧要求。（最后两次更改是在 2007 年和 1991 年。）当我们更新 GPL 时，在每个程序中使用这个“间接指针”可以让我们有可能针对整个 GNU 软件集合更改分发条款。
如果每个程序缺少间接指针，我们将被迫与许多版权持有者进行长时间的讨论，这在事实上是不可能实现的。在实践中，为 GNU 软件制定统一分发条款的机会将为零。
假设一个程序里说“GPL 的版本 3 或任何更新的版本”，并且一个新版本的 GPL 被发布。如果新的 GPL 版本提供了额外的许可，那么该权限将立即提供给程序的所有用户。但是，如果新的 GPL 版本要求更严格，则不会对使用当前版本的程序形成限制，因为该程序仍然可以依据 GPL 版本 3 进行使用。当程序里说“GPL 的版本 3 或任何更新的版本”，用户将被永远允许使用它，甚至可以依据 GPL 版本 3 的条款进行更改，即使在后续版本的 GPL 可用后也是如此。
如果GPL的新版本中更严格的要求不需要被现有软件遵守，那么它还有用吗？一旦 GPL 版本 4 可用，大多数遵循 GPL 的程序的开发人员将发布其程序的后续版本，阐明其采用“GPL 的版本 4 或任何更新的版本”。那么用户将不得不遵循 GPL 版本 4 中更严格的要求，以便使用程序的后续版本。
然而，开发人员没有义务这样做；如果这是他们的偏好，开发人员可以继续被允许使用以前版本的 GPL。
#### 3.16 使用一个声明某个程序只能依据最新版本的 GNU GPL 进行使用的许可证是个好主意吗？
您不应该这样做，原因是它可能会导致未来某一天自动撤回用户以前拥有的一些权限。
假设一个程序是在 2000 年依据“最新的 GPL 版本”进行发布。当时，人们可以依据 GPL 版本 2 使用它。在 2007 年发布 GPL 版本 3 的那一天，每个人都将被迫不得不依据 GPL 版本 3 使用该程序。
有些用户甚至可能不知道 GPL 版本 3——但是他们将被要求使用它。他们可能会无意中违反该程序的许可证，只因为他们没有得到 GPL 版本 3发布的消息。这不是个对待别人的好方法。
除非因为违规，我们认为收回已经授予的权限是错误的做法。如果您的自由可以被撤销，那么这不是真正的自由。因此，如果您获得遵循某个版本许可证的某个版本程序的副本，则应始终具有该版本许可证授予的权限。依据“GPL 的版本 N 或任何更新的版本”进行发布维护了该原则。
#### 3.17 有没有一些方法可以让使用我的程序的人们得到的输出物遵循 GPL？例如，如果我的程序用于开发硬件设计，我可以要求这些设计必须是自由的吗？
一般来说，这在法律上是不可能的；针对人们通过使用您的程序获取数据形成的输出物如何使用，版权法并没有赋予您任何发言权。如果用户使用您的程序输入或转换自己的数据，输出物的版权属于他，而不是您。更一般来说，当程序将其输入物转换成其他形式时，输出物的版权状态将继承其得以生成的输入物的版权状态。
所以您对输出物的使用拥有发言权的唯一方式是输出物的实质部分（或多或少）是从您程序的文本中复制出来。例如，如果我们在这种具体情况下没有例外，那么Bison的一部分输出物（参见问题 5.2）将被 GNU GPL 所涵盖。
所以，即使没有技术原因，您也可以人为制作一个程序，将某些文本复制到其输出物中。但是，如果复制的文本没有实际用途，用户可以简单地从输出物中删除该文本，并且仅使用其余的内容。那么他就不必满足重新分发所复制文本的条件。
#### 3.18 手册为什么不使用 GPL 许可证？（同 1.7）
手册也可以使用 GPL 许可证，但对于手册来说，最好使用 GFDL（自由文本授权，GNU Free Documentation License）许可证。
GPL 是为软件程序设计的，它包含许多复杂的条款，对于程序来说至关重要；但对于图书或手册来说，这将是麻烦和不必要的。例如，任何人如果（以 GPL）出版纸质图书，就要么必须为每份印刷版本配置该图书的机器可读形式“源代码”，或提供书面文件，表明将稍后发送“源代码”。
同时，GFDL 中包含了帮助免费手册的出版商从销售副本中获利的条款，例如，出售封面文字。<ruby> 背书 <rp> （ </rp> <rt> Endorsements </rt> <rp> ） </rp></ruby>部分的特殊规则使得 GFDL 可以作为官方标准。修改版本的手册是被允许的，但该修改版本不能被标记为“该标准”。
使用 GFDL，我们允许对手册中涵盖其技术主题的文本进行修改。能够修改技术部分非常重要，因为修改程序的人理所当然地要去修改对应的文档。人们有这样做的自由，它是一种道德责任。我们的手册还包括阐述我们对自由软件政治立场的部分。我们将它们标记为<ruby> “不变量” <rp> （ </rp> <rt> invariant </rt> <rp> ） </rp></ruby>，使得它们不被更改或删除。 GFDL 中也为这些“不变部分”做出了规定。
#### 3.19 GPL 如何适用于字体？
字体许可是一个复杂的问题，需要认真考虑。以下许可证例外是试验性的，但被批准用于一般用途。我们欢迎关于这个问题的建议——请参阅这个[解释性文章](http://www.fsf.org/blogs/licensing/20050425novalis)，并写邮件到 [licensing@gnu.org](mailto:licensing@gnu.org) 。
要使用此例外，请将该文本添加到软件包中的每个文件的许可证通知中（尽可能），在文本末尾说明该文件依据 GNU GPL 分发：
>
> 作为一个特殊的例外，如果您创建一个使用此字体的文档，并将该字体或该字体未更改的部分嵌入到文档中，则此字体本身不会导致生成的文档被<ruby> GNU 通用公共许可证 <rp> （ </rp> <rt> GNU General Public License </rt> <rp> ） </rp></ruby>覆盖。然而，这个例外不会使文档可能被 GNU 通用公共许可证涵盖的任何其他原因无效。如果您修改此字体，您可以将此例外扩展到您的字体版本，但是您没有义务这样做。如果您不想这样做，请从您的版本中删除此例外声明。
>
>
>
#### 3.20 我正在编写一个网站维护系统（有人称之为“[内容管理系统](https://www.gnu.org/philosophy/words-to-avoid.html#Content)”）或者是其他一些从模板生成网页的应用程序。我应该为这些模板使用什么许可证？
模板很小，不值得使用<ruby> 左版 <rp> （ </rp> <rt> copyleft </rt> <rp> ） </rp></ruby>来保护它们。在小作品上使用左版通常是无害的，但模板是一种特殊情况，因为它们与应用程序用户提供的数据结合使用，并且其组合被分发。因此，我们建议您以简单的许可条款许可您的模板。
一些模板调用 JavaScript 函数。由于 JavaScript 通常是不一般的作品，因此它值得用左版保护。由于模板与用户数据相结合，因此模板 + 用户数据 + JavaScript 可能被版权法看作是一个作品。需要在 JavaScript（受左版保护）和用户代码（通常遵循不兼容的条款）之间划清界限。
以下是执行此操作的 JavaScript 代码的一种例外：
>
> 作为 GPL 的一个特殊例外，仅对此代码进行函数调用并且为此目的通过引用将其包括在内的 HTML 文件，将被视为版权法意义下的单独作品。此外，此代码的版权所有者可以让您将该代码与依据 GNU LGPL 发布的自由软件库相结合。您可以按照此代码所遵循的 GNU GPL 条款以及此库所遵循的 LGPL 条款复制和分发这样一个系统。如果您修改此代码，则可以将此例外扩展到您的代码版本，但是您没有义务这样做。如果您不想这样做，请从您的版本中删除此例外声明。
>
>
>
#### 3.21 我可以发布一个使用非自由工具开发的遵循 GPL 的程序吗？
您使用什么程序来编辑、编译、研究、记录源代码，通常对于该源代码的许可问题没有任何影响。
但是，如果将非自由库与源代码链接，那么它就是一个您需要进行处理的问题。它不阻碍依据GPL发布源代码，但是如果这些库不符合<ruby> “系统库” <rp> （ </rp> <rt> system library </rt> <rp> ） </rp></ruby>例外情况，那么您应该附加一个明确的通知，允许您的程序与它们进行链接。有关使用 [GPL 不兼容库的 FAQ 条目](https://www.gnu.org/licenses/gpl-faq.html#GPLIncompatibleLibs)提供了如何执行此操作的更多信息。
#### 3.22 我使用公钥加密来对我的代码进行签名，以确保其真实性。GPL v3 是否强制要求我发布我的私人签名密钥？
否。只有在您将遵循 GPL 的软件传递给用户产品之中，您才需要发布签名密钥，并且其硬件会在功能启动之前检查该软件来获得有效的密码签名。在这种具体情况下，您将被要求提供密钥给任何拥有该设备的人员，使其按照要求在设备上签名并安装修改后的软件，以便其运行。如果具体每个设备使用不同的密钥，那么您只需要为每个购买者提供相应的密钥。
#### 3.23 GPL v3 是否要求投票人能够修改在投票机中运行的软件？（同 2.41）
不要求。企业分发包含遵循 GPL v3 软件的设备，最多只需要为拥有目标代码副本的人提供软件的源代码和安装信息。使用投票机（如同任何其他信息亭一样）的选民不能拥有它，甚至不能暂时拥有，所以选民也不能拥有二进制软件。
不过，请注意，投票是一个非常特殊的情况。仅仅因为计算机中的软件是自由软件，并不意味着您可以信任计算机，并进行投票。我们认为电脑不值得信任，不能被用作投票。投票应在纸上进行。
#### 3.24 GPL v3 中的担保和免责声明似乎是依据美国法律的。我可以将自己的免责声明添加到我自己的代码中吗？
可以。GPL v3 第 7 节允许您添加自己的免责声明，具体来说是 7（a）。
#### 3.25 我的程序具有非视觉性的交互式用户界面。如何遵守 GPL v3 中的<ruby> 适当法律声明 <rp> （ </rp> <rt> Appropriate Legal Notices </rt> <rp> ） </rp></ruby>要求？
所有您需要做的是确保适当法律声明对于您界面中的用户来说唾手可得。例如，如果您已经编写了一个音频接口，您可以包括一个大声朗读该声明的命令。
|
||
大多数公司对开源社区不得要领，正确的打开方式是什么？
|
Matt Asay
|
https://www.techrepublic.com/article/most-companies-cant-buy-an-open-source-community-clue-heres-how-to-do-it-right/
|
Red Hat 已经学会了跟随开源社区，并将其商业化。你也可以。
|
/data/attachment/album/201711/16/233209sb8z33evyvvn3pc8.png.thumb.jpg
|
/data/attachment/album/201711/16/233209sb8z33evyvvn3pc8.png
| true
| false
| true
|
geekpi
| false
|
[
"开源社区"
] |
观点
|
{
"viewnum": 3432,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Red Hat 已经学会了跟随开源社区，并将其商业化。你也可以。
| 2017-11-18T10:27:00
| 2017-11-18T10:27:00
| 9,063
|
/article-9063-1.html
|
>
> Red Hat 已经学会了跟随开源社区，并将其商业化。你也可以。
>
>
>
开源中最强大但最困难的事情之一就是社区。红帽首席执行官 Jim Whitehurst 在与 Slashdot 的[最近一次采访](https://linux.slashdot.org/story/17/10/30/0237219/interviews-red-hat-ceo-jim-whitehurst-answers-your-questions)中宣称：“有强大社区的存在，开源总是赢得胜利”。但是建设这个社区很难。真的，真的很难。尽管[预测开源社区蓬勃发展的必要组成部分](http://asay.blogspot.com/2005/09/so-you-want-to-build-open-source.html)很简单，但是预测这些部分在何时何地将会组成像 Linux 或 Kubernetes 这样的社区则极其困难。
这就是为什么聪明的资金似乎在随社区而动，而不是试图创建它们。
### 可爱的开源寄生虫
在阅读 Whitehurst 的 Slashdot 采访时，这个想法让我感到震惊。虽然他谈及了从 Linux 桌面到 systemd 的很多内容，但 Whitehurst 关于社区的评论对我来说是最有说服力的：
>
> 建立一个新社区是困难的。我们在红帽开始做一点，但大部分时间我们都在寻找已经拥有强大社区的现有项目。在强大的社区存在的情况下，开源始终是胜利的。
>
>
>
虽然这种方法 —— 加强现有的、不断发展的社区，似乎是一种逃避，它实际上是最明智的做法。早期，开源几乎总是支离破碎的，因为每个项目都试图获得足够的成员。在某些时候，人们开始聚集两到三名获胜者身边（例如 KDE vs. Gnome，或者 Kubernetes vs. Docker Swarm 与 Apache Mesos）。但最终，很难维持不同的社区“标准”，每个人都最终围拢到一个赢家身边（例如 Kubernetes）。
**参见：[混合云和开源：红帽数字化转型的秘诀](http://www.techproresearch.com/article/hybrid-cloud-and-open-source-red-hats-recipe-for-digital-transformation/)（Tech Pro Research）**
这不是投降 —— 这是培养资源和推动标准化的更好方式。例如，Linux 已经成为如此强大的力量的一个原因是，它鼓励在一个地方进行操作系统创新，即使存在不同的分支社区（以及贡献代码的大量的各个公司和个人）不断为它做贡献。红帽的发展很快，部分原因是它在早期就做出了聪明的社区选择，选择了一个赢家（比如 Kubernetes），并帮助它取得更大的成功。
而这反过来又为其商业模式提供动力。
### 从社区混乱中赚钱
对红帽而言一件很好的事是社区越多，项目就越成功。但是，开源的“成功”并不一定意味着企业会接受该项目，这仅仅意味着他们*愿意*这样做。红帽公司早期的直觉和不断地支付分红，就是理解那些枯燥、平庸的企业想要开源的活力，而不要，好吧，还是活力。他们需要把它驯服，变得枯燥而又平庸。Whitehurst 在采访中完美地表达了这一点：
>
> 红帽是成功的，因为我们沉迷于寻找方法来增加我们每个产品的代码价值。我们认为自己是帮助企业客户轻松消费开源创新的。
>
>
> 仅举一例：对于我们所有的产品，我们关注生命周期。开源是一个伟大的开发模式，但其“尽早发布、频繁发布”的风格使其在生产中难以实施。我们在 Linux 中发挥的一个重要价值是，我们在受支持的内核中支持 bug 修复和安全更新十多年，同时从不破坏 API 兼容性。这对于运行长期应用程序的企业具有巨大的价值。我们通过这种类型的流程来应对我们选择进行产品化的所有项目，以确定我们如何增加源代码之外的价值。
>
>
>
对于大多数想要开源的公司来说，挑战在于他们可能认识到社区的价值，但是不知道怎么不去销售代码。毕竟，销售软件几十年来一直是一个非常有利可图的商业模式，并产生了一些地球上最有价值的公司。
**参看[红帽如何使 Kubernetes 乏味并且成功](https://www.techrepublic.com/article/how-red-hat-aims-to-make-kubernetes-boring-and-successful/)**
然而, 正如 Whitehurst 指出的那样，开源需要一种不同的方法。他在采访中断言：“**你不能出售功能**， 因为它是免费的”。相反, 你必须找到其他的价值，比如在很长一段周期内让开源得到支持。这是枯燥的工作，但对红帽而言每年值数十亿美元。
所有这一切都从社区开始。社区更有活力，更好的是它能使开源产品市场化，并能赚钱。为什么？嗯，因为更多的发展的部分等价于更大的价值，随之让自由发展的项目对企业消费而言更加稳定。这是一个成功的公式，并可以发挥所有开源的好处，而不会将它受制于二十世纪的商业模式。
---
via: <https://www.techrepublic.com/article/most-companies-cant-buy-an-open-source-community-clue-heres-how-to-do-it-right/>
作者：[Matt Asay](https://www.techrepublic.com/meet-the-team/us/matt-asay/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux “完全统治” 了超级计算机
|
Steven J. Vaughan-nichols
|
http://www.zdnet.com/article/linux-totally-dominates-supercomputers/
|
Linux 统治了超级计算。自 1998 年以来，这一天终于到来了，那时候 Linux 首次出现在 TOP 500 超级计算机榜单上。如今，全世界最快的 500 台超级计算机全部运行着 Linux！
|
/data/attachment/album/201711/17/233725d025f880lw8220t8.jpg.thumb.jpg
|
/data/attachment/album/201711/17/233725d025f880lw8220t8.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"Linux",
"超算"
] |
新闻
|
{
"viewnum": 7106,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Linux 统治了超级计算。自 1998 年以来，这一天终于到来了，那时候 Linux 首次出现在 TOP 500 超级计算机榜单上。如今，全世界最快的 500 台超级计算机全部运行着 Linux！
| 2017-11-17T23:37:00
| 2017-11-17T23:37:00
| 9,065
|
/article-9065-1.html
|
>
> 它终于发生了。如今，全世界超算 500 强全部都运行着 Linux。
>
>
>
Linux 统治了超级计算。自 1998 年以来，这一天终于到来了，那时候 Linux 首次出现在 [TOP 500 超级计算机榜单](https://www.top500.org/)上。如今，[全世界最快的 500 台超级计算机全部运行着 Linux](https://www.top500.org/statistics/sublist/)！
上以期榜单中最后的两台非 Linux 系统，是来自中国的一对运行着 AIX 的 IBM POWER 计算机，掉出了 [2017 年 11 月超级计算机 500 强榜单](https://www.top500.org/news/china-pulls-ahead-of-us-in-latest-top500-list/)。
总体而言，[现在中国引领着超级计算的竞赛，其拥有的 202 台已经超越美国的 144 台](http://www.zdnet.com/article/now-china-outguns-us-in-top-supercomputer-showdown/)。中国的超级计算机的总体性能上也超越了美国。其超级计算机占据了 TOP500 指数的 35.4%，其后的美国占 29.6%。随着一个反科学政权掌管了政府，美利坚共和国如今只能看着它的技术领袖地位在持续下降。
[在 1993 年 6 月首次编制超级计算机 500 强榜单](http://top500.org/project/introduction)的时候，Linux 只不过是个“玩具”而已。那时的它甚至还没有用“企鹅”作为它的吉祥物。不久之后，Linux 就开始进军超级计算机领域。
在 1993/1994 时，在 NASA 的<ruby> 戈达德太空飞行中心 <rt> Goddard Space Flight Center </rt></ruby>，Donald Becker 和 Thomas Sterling 设计了一个<ruby> 货架产品 <rt> Commodity Off The Shelf </rt></ruby>（COTS）超级计算机：[Beowulf](http://www.beowulf.org/overview/faq.html)。因为他们负担不起一台传统的超级计算机，所以他们构建了一个由 16 个 Intel 486 DX4 处理器的计算机集群，它通过以太网信道聚合互联。这台 [Beowulf 超级计算机](http://www.beowulf.org/overview/history.html) 当时一时成名。
到今天，Beowulf 的设计仍然是一个流行的、廉价的超级计算机设计方法。甚至，在最新的 TOP500 榜单上，全世界最快的 437 台计算机仍然采用受益于 Beowulf 的集群设计。
Linux 首次出现在 TOP500 上是 1998 年。在 Linux 领先之前，Unix 是超级计算机的最佳操作系统。自从 2003 年起，TOP500 中 Linux 已经占据了重要的地位。从 2004 年开始，Linux 已经完全领先于 UNIX 了。
[Linux 基金会](https://www.linux.com/publications/20-years-top500org-supercomputer-data-links-linux-advances-computing-performance)的报告指出，“Linux [成为] 推进研究和技术创新的计算能力突破的驱动力”。换句话说，Linux 在超级计算中占有重要地位，至少是部分重要地位。因为它正帮助研究人员突破计算能力的极限。
有两个原因导致这种情况：首先，全球的大部分顶级超级计算机都是为特定的研究任务去构建的，每台机器都是用于有唯一特性和需求优化的单独项目。为节省成本，不可能为每一个超算系统都去定制一个操作系统。然而，对于 Linux，研究团队可以很容易地修改和优化 Linux 的开源代码为的他们的一次性设计。
例如，最新的 [Linux 4.14](http://www.zdnet.com/article/the-new-long-term-linux-kernel-linux-4-14-has-arrived/) 允许超级计算机去使用 [异构内存管理 (HMM)](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=bffc33ec539699f045a9254144de3d4eace05f07)。这允许 GPU 和 CPU 去访问处理器的共享地址空间。确切地说，TOP500 中的 102 台使用了 GPU 加速/协处理器技术。这全是因 HHM 而使它们运行的更快。
并且，同样重要的是，正如 Linux 基金会指出的那样，“定制的、自我支持的 Linux 发行版的授权成本，无论你是使用 20 个节点，还是使用 2000 万个节点，都是一样的。” 因此，“利用巨大的 Linux 开源社区，项目可以获得免费的支持和开发者资源，以保持开发人员成本与其它操作系统相同或低于它们。”
现在，Linux 已经达到了超级计算之巅，我无法想像它会失去领导地位。即将到来的硬件革命，比如，量子计算，将会动摇 Linux 超级计算的地位。当然，Linux 也许仍然可以保持统治地位，因为，[IBM 开发人员已经准备将 Linux 移植到量子计算机上](http://www.linuxplumbersconf.org/2017/ocw//system/presentations/4704/original/QC-slides.2017.09.13f.pdf)。
---
via: <http://www.zdnet.com/article/linux-totally-dominates-supercomputers/>
作者：[Steven J. Vaughan-Nichols](http://www.zdnet.com/meet-the-team/us/steven-j-vaughan-nichols/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 基金会发布了新的企业开源指南
|
David Ramel
|
https://adtmag.com/articles/2017/11/06/open-source-guides.aspx
|
Linux 基金会在其企业开源指南文集中为开发和使用开源软件增加了三篇新的指南。
|
/data/attachment/album/201711/18/063329xsocsos9w6f1ss1p.jpg.thumb.jpg
|
/data/attachment/album/201711/18/063329xsocsos9w6f1ss1p.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"开源指南"
] |
新闻
|
{
"viewnum": 2807,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
Linux 基金会在其企业开源指南文集中为开发和使用开源软件增加了三篇新的指南。
| 2017-11-18T06:33:26
| 2017-11-18T06:33:26
| 9,066
|
/article-9066-1.html
|
Linux 基金会在其企业开源指南文集中为开发和使用开源软件增加了三篇新的指南。
这个有着 17 年历史的非营利组织的主要任务是支持开源社区，并且，作为该任务的一部分，它在 9 月份发布了六篇 [企业开源指南](https://www.linuxfoundation.org/resources/open-source-guides/)，涉及从招募开发人员到使用开源代码的各个主题。
最近一段时间以来，Linux 基金会与开源专家组 [TODO Group](http://todogroup.org/)（Talk Openly, Develop Openly）合作发布了三篇指南。
这一系列的指南用于在多个层次上帮助企业员工 —— 执行官、开源计划经理、开发者、律师和其他决策者 —— 学习怎么在开源活动中取得更好的收益。
该组织是这样描述这三篇指南的：
* **提升你的开源开发的影响力**， —— 来自 Ibrahim Haddad，三星美国研究院。该指南涵盖了企业可以采用的一些做法，以帮助企业扩大他们在大型开源项目中的影响。
* **启动一个开源项目**，—— 来自 Christine Abernathy，Facebook；Ibrahim Haddad；Guy Martin，Autodesk；John Mertic，Linux 基金会；Jared Smith，第一资本（Capital One）。这个指南帮助已经熟悉开源的企业学习怎么去开始自己的开源项目。
* **开源阅读列表**。一个开源程序管理者必读书清单，由 TODO Group 成员编制完成的。
*企业开源指南的 ‘阅读列表’ 中的一部分产品 （来源：Linux 基金会）*
在九月份发布的六篇指南包括：
* **创建一个开源计划：** 学习怎么去建立一个计划去管理内部开源使用和外部贡献。
* **开源管理工具：** 一系列可用于跟踪和管理开源项目的工具。
* **衡量你的开源计划是否成功：** 了解更多关于顶级组织评估其开源计划和贡献的 ROI 的方法。
* **招聘开发人员：** 学习如何通过创建开源文化和贡献开源项目来招募开发人员或从内部挖掘人才。
* **参与开源社区：** 了解奉献内部开发者资源去参与开源社区的重要性，和怎么去操作的最佳方法。
* **使用开源代码：** 在你的商业产品中集成开源代码时，确保你的组织符合它的法律责任。
更多的指南正在编制中，它们将和这些指南一样发布在 Linux 基金会和 [GitHub](https://github.com/todogroup/guides) 的网站上。
TODO Group 也发布了四个 [案例研究](https://github.com/todogroup/guides/tree/master/casestudies) 的补充材料，详细描述了 Autodesk、Comcast、Facebook 和 Salesforce 在构建他们的开源计划中的经验。以后，还有更多的计划。
---
via: <https://adtmag.com/articles/2017/11/06/open-source-guides.aspx>
作者：[David Ramel](https://adtmag.com/forms/emailtoauthor.aspx?AuthorItem=%7B53762E17-6187-46B4-8C04-9DFA282EBB67%7D&ArticleItem=%7B855B2913-5DCF-4871-8563-6D88DA5A7C3C%7D) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 Kubernetes 和 Docker 部署 Java 应用
|
Daniel Bryant
|
https://www.oreilly.com/ideas/how-to-manage-docker-containers-in-kubernetes-with-java
|
在这篇文章中，我们将使用以前的一个简单的基于 Java 的电子商务商店，我们将它打包进 Docker 容器内，并且在 Kubernetes 上运行它。
|
/data/attachment/album/201711/18/113130tep9pppxn3cejt6e.jpg.thumb.jpg
|
/data/attachment/album/201711/18/113130tep9pppxn3cejt6e.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"Kubernetes",
"容器"
] |
容器与云
|
{
"viewnum": 10566,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我们将使用以前的一个简单的基于 Java 的电子商务商店，我们将它打包进 Docker 容器内，并且在 Kubernetes 上运行它。
| 2017-11-18T11:31:28
| 2017-11-18T11:31:28
| 9,067
|
/article-9067-1.html
|
>
> 大规模容器应用编排起步
>
>
>
通过《[面向 Java 开发者的 Kubernetes](https://www.nginx.com/resources/library/kubernetes-for-java-developers/)》，学习基本的 Kubernetes 概念和自动部署、维护和扩展你的 Java 应用程序的机制。[下载该电子书的免费副本](https://www.nginx.com/resources/library/kubernetes-for-java-developers/)
在 《[Java 的容器化持续交付](https://www.nginx.com/resources/library/containerizing-continuous-delivery-java/)》 中，我们探索了在 Docker 容器内打包和部署 Java 应用程序的基本原理。这只是创建基于容器的生产级系统的第一步。在真实的环境中运行容器还需要一个容器编排和计划的平台，并且，现在已经存在了很多个这样的平台（如，Docker Swarm、Apach Mesos、AWS ECS），而最受欢迎的是 [Kubernetes](https://kubernetes.io/)。Kubernetes 被用于很多组织的产品中，并且，它现在由[原生云计算基金会（CNCF）](https://www.cncf.io/)所管理。在这篇文章中，我们将使用以前的一个简单的基于 Java 的电子商务商店，我们将它打包进 Docker 容器内，并且在 Kubernetes 上运行它。
### “Docker Java Shopfront” 应用程序
我们将打包进容器，并且部署在 Kubernetes 上的 “Docker Java Shopfront” 应用程序的架构，如下面的图所示：
在我们开始去创建一个所需的 Kubernetes 部署配置文件之前，让我们先学习一下关于容器编排平台中的一些核心概念。
### Kubernetes 101
Kubernetes 是一个最初由谷歌开发的开源的部署容器化应用程序的<ruby> 编排器 <rt> orchestrator </rt></ruby>。谷歌已经运行容器化应用程序很多年了，并且，由此产生了 [Borg 容器编排器](https://research.google.com/pubs/pub44843.html)，它是应用于谷歌内部的，是 Kubernetes 创意的来源。如果你对这个技术不熟悉，一些出现的许多核心概念刚开始你会不理解，但是，实际上它们都很强大。首先， Kubernetes 采用了不可变的基础设施的原则。部署到容器中的内容（比如应用程序）是不可变的，不能通过登录到容器中做成改变。而是要以部署新的版本替代。第二，Kubernetes 内的任何东西都是<ruby> 声明式 <rt> declaratively </rt></ruby>配置。开发者或运维指定系统状态是通过部署描述符和配置文件进行的，并且，Kubernetes 是可以响应这些变化的——你不需要去提供命令，一步一步去进行。
不可变基础设施和声明式配置的这些原则有许多好处：它容易防止配置<ruby> 偏移 <rt> drift </rt></ruby>，或者 “<ruby> 雪花 <rt> snowflake </rt></ruby>” 应用程序实例；声明部署配置可以保存在版本控制中，与代码在一起；并且， Kubernetes 大部分都可以自我修复，比如，如果系统经历失败，假如是一个底层的计算节点失败，系统可以重新构建，并且根据在声明配置中指定的状态去重新均衡应用程序。
Kubernetes 提供几个抽象概念和 API，使之可以更容易地去构建这些分布式的应用程序，比如，如下的这些基于微服务架构的：
* [<ruby> 豆荚 <rt> Pod </rt></ruby>](https://kubernetes.io/docs/concepts/workloads/pods/pod/) —— 这是 Kubernetes 中的最小部署单元，并且，它本质上是一组容器。 <ruby> 豆荚 <rt> Pod </rt></ruby>可以让一个微服务应用程序容器与其它“挎斗” 容器，像日志、监视或通讯管理这样的系统服务一起被分组。在一个豆荚中的容器共享同一个文件系统和网络命名空间。注意，一个单个的容器也是可以被部署的，但是，通常的做法是部署在一个豆荚中。
* [服务](https://kubernetes.io/docs/concepts/services-networking/service/) —— Kubernetes 服务提供负载均衡、命名和发现，以将一个微服务与其它隔离。服务是通过[复制控制器](https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/)支持的，它反过来又负责维护在系统内运行期望数量的豆荚实例的相关细节。服务、复制控制器和豆荚在 Kubernetes 中通过使用“[标签](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/)”连接到一起，并通过它进行命名和选择。
现在让我们来为我们的基于 Java 的微服务应用程序创建一个服务。
### 构建 Java 应用程序和容器镜像
在我们开始创建一个容器和相关的 Kubernetes 部署配置之前，我们必须首先确认，我们已经安装了下列必需的组件：
* 适用于 [Mac](https://docs.docker.com/docker-for-mac/install/) / [Windows](https://docs.docker.com/docker-for-windows/install/) / [Linux](https://docs.docker.com/engine/installation/linux/ubuntu/) 的 Docker - 这允许你在本地机器上，在 Kubernetes 之外去构建、运行和测试 Docker 容器。
* [Minikube](https://kubernetes.io/docs/tasks/tools/install-minikube/) - 这是一个工具，它可以通过虚拟机，在你本地部署的机器上很容易地去运行一个单节点的 Kubernetes 测试集群。
* 一个 [GitHub](https://github.com/) 帐户和本地安装的 [Git](https://git-scm.com/) - 示例代码保存在 GitHub 上，并且通过使用本地的 Git，你可以复刻该仓库，并且去提交改变到该应用程序的你自己的副本中。
* [Docker Hub](https://hub.docker.com/) 帐户 - 如果你想跟着这篇教程进行，你将需要一个 Docker Hub 帐户，以便推送和保存你将在后面创建的容器镜像的拷贝。
* [Java 8](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) （或 9） SDK 和 [Maven](https://maven.apache.org/) - 我们将使用 Maven 和附属的工具使用 Java 8 特性去构建代码。
从 GitHub 克隆项目库代码（可选，你可以<ruby> 复刻 <rt> fork </rt></ruby>这个库，并且克隆一个你个人的拷贝），找到 “shopfront” 微服务应用： <https://github.com/danielbryantuk/oreilly-docker-java-shopping/>。
```
$ git clone git@github.com:danielbryantuk/oreilly-docker-java-shopping.git
$ cd oreilly-docker-java-shopping/shopfront
```
请加载 shopfront 代码到你选择的编辑器中，比如，IntelliJ IDE 或 Eclipse，并去研究它。让我们使用 Maven 来构建应用程序。最终生成包含该应用的可运行的 JAR 文件位于 `./target` 的目录中。
```
$ mvn clean install
…
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 17.210 s
[INFO] Finished at: 2017-09-30T11:28:37+01:00
[INFO] Final Memory: 41M/328M
[INFO] ------------------------------------------------------------------------
```
现在，我们将构建 Docker 容器镜像。一个容器镜像的操作系统选择、配置和构建步骤，一般情况下是通过一个 Dockerfile 指定的。我们看一下，我们的示例中位于 shopfront 目录中的 Dockerfile：
```
FROM openjdk:8-jre
ADD target/shopfront-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8010
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
```
第一行指定了，我们的容器镜像将被 “<ruby> 从 <rt> from </rt></ruby>” 这个 openjdk:8-jre 基础镜像中创建。[openjdk:8-jre](https://hub.docker.com/_/openjdk/) 镜像是由 OpenJDK 团队维护的，并且包含了我们在 Docker 容器（就像一个安装和配置了 OpenJDK 8 JDK的操作系统）中运行 Java 8 应用程序所需要的一切东西。第二行是，将我们上面构建的可运行的 JAR “<ruby> 添加 <rt> add </rt></ruby>” 到这个镜像。第三行指定了端口号是 8010，我们的应用程序将在这个端口号上监听，如果外部需要可以访问，必须要 “<ruby> 暴露 <rt> exposed </rt></ruby>” 它，第四行指定 “<ruby> 入口 <rt> entrypoint </rt></ruby>” ，即当容器初始化后去运行的命令。现在，我们来构建我们的容器：
```
$ docker build -t danielbryantuk/djshopfront:1.0 .
Successfully built 87b8c5aa5260
Successfully tagged danielbryantuk/djshopfront:1.0
```
现在，我们推送它到 Docker Hub。如果你没有通过命令行登入到 Docker Hub，现在去登入，输入你的用户名和密码：
```
$ docker login
Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.
Username:
Password:
Login Succeeded
$
$ docker push danielbryantuk/djshopfront:1.0
The push refers to a repository [docker.io/danielbryantuk/djshopfront]
9b19f75e8748: Pushed
...
cf4ecb492384: Pushed
1.0: digest: sha256:8a6b459b0210409e67bee29d25bb512344045bd84a262ede80777edfcff3d9a0 size: 2210
```
### 部署到 Kubernetes 上
现在，让我们在 Kubernetes 中运行这个容器。首先，切换到项目根目录的 `kubernetes` 目录：
```
$ cd ../kubernetes
```
打开 Kubernetes 部署文件 `shopfront-service.yaml`，并查看内容：
```
---
apiVersion: v1
kind: Service
metadata:
name: shopfront
labels:
app: shopfront
spec:
type: NodePort
selector:
app: shopfront
ports:
- protocol: TCP
port: 8010
name: http
---
apiVersion: v1
kind: ReplicationController
metadata:
name: shopfront
spec:
replicas: 1
template:
metadata:
labels:
app: shopfront
spec:
containers:
- name: shopfront
image: danielbryantuk/djshopfront:latest
ports:
- containerPort: 8010
livenessProbe:
httpGet:
path: /health
port: 8010
initialDelaySeconds: 30
timeoutSeconds: 1
```
这个 yaml 文件的第一节创建了一个名为 “shopfront” 的服务，它将到该服务（8010 端口）的 TCP 流量路由到标签为 “app: shopfront” 的豆荚中 。配置文件的第二节创建了一个 `ReplicationController` ，其通知 Kubernetes 去运行我们的 shopfront 容器的一个复制品（实例），它是我们标为 “app: shopfront” 的声明（spec）的一部分。我们也指定了暴露在我们的容器上的 8010 应用程序端口，并且声明了 “livenessProbe” （即健康检查），Kubernetes 可以用于去决定我们的容器应用程序是否正确运行并准备好接受流量。让我们来启动 `minikube` 并部署这个服务（注意，根据你部署的机器上的可用资源，你可能需要去修 `minikube` 中的指定使用的 CPU 和<ruby> 内存 <rt> memory </rt></ruby>）：
```
$ minikube start --cpus 2 --memory 4096
Starting local Kubernetes v1.7.5 cluster...
Starting VM...
Getting VM IP address...
Moving files into cluster...
Setting up certs...
Connecting to cluster...
Setting up kubeconfig...
Starting cluster components...
Kubectl is now configured to use the cluster.
$ kubectl apply -f shopfront-service.yaml
service "shopfront" created
replicationcontroller "shopfront" created
```
你可以通过使用 `kubectl get svc` 命令查看 Kubernetes 中所有的服务。你也可以使用 `kubectl get pods` 命令去查看所有相关的豆荚（注意，你第一次执行 get pods 命令时，容器可能还没有创建完成，并被标记为未准备好）：
```
$ kubectl get svc
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes 10.0.0.1 <none> 443/TCP 18h
shopfront 10.0.0.216 <nodes> 8010:31208/TCP 12s
$ kubectl get pods
NAME READY STATUS RESTARTS AGE
shopfront-0w1js 0/1 ContainerCreating 0 18s
$ kubectl get pods
NAME READY STATUS RESTARTS AGE
shopfront-0w1js 1/1 Running 0 2m
```
我们现在已经成功地在 Kubernetes 中部署完成了我们的第一个服务。
### 是时候进行烟雾测试了
现在，让我们使用 curl 去看一下，我们是否可以从 shopfront 应用程序的健康检查端点中取得数据：
```
$ curl $(minikube service shopfront --url)/health
{"status":"UP"}
```
你可以从 curl 的结果中看到，应用的 health 端点是启用的，并且是运行中的，但是，在应用程序按我们预期那样运行之前，我们需要去部署剩下的微服务应用程序容器。
### 构建剩下的应用程序
现在，我们有一个容器已经运行，让我们来构建剩下的两个微服务应用程序和容器：
```
$ cd ..
$ cd productcatalogue/
$ mvn clean install
…
$ docker build -t danielbryantuk/djproductcatalogue:1.0 .
...
$ docker push danielbryantuk/djproductcatalogue:1.0
...
$ cd ..
$ cd stockmanager/
$ mvn clean install
...
$ docker build -t danielbryantuk/djstockmanager:1.0 .
...
$ docker push danielbryantuk/djstockmanager:1.0
...
```
这个时候， 我们已经构建了所有我们的微服务和相关的 Docker 镜像，也推送镜像到 Docker Hub 上。现在，我们去在 Kubernetes 中部署 `productcatalogue` 和 `stockmanager` 服务。
### 在 Kubernetes 中部署整个 Java 应用程序
与我们上面部署 shopfront 服务时类似的方式去处理它，我们现在可以在 Kubernetes 中部署剩下的两个微服务：
```
$ cd ..
$ cd kubernetes/
$ kubectl apply -f productcatalogue-service.yaml
service "productcatalogue" created
replicationcontroller "productcatalogue" created
$ kubectl apply -f stockmanager-service.yaml
service "stockmanager" created
replicationcontroller "stockmanager" created
$ kubectl get svc
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes 10.0.0.1 <none> 443/TCP 19h
productcatalogue 10.0.0.37 <nodes> 8020:31803/TCP 42s
shopfront 10.0.0.216 <nodes> 8010:31208/TCP 13m
stockmanager 10.0.0.149 <nodes> 8030:30723/TCP 16s
$ kubectl get pods
NAME READY STATUS RESTARTS AGE
productcatalogue-79qn4 1/1 Running 0 55s
shopfront-0w1js 1/1 Running 0 13m
stockmanager-lmgj9 1/1 Running 0 29s
```
取决于你执行 “kubectl get pods” 命令的速度，你或许会看到所有都处于不再运行状态的豆荚。在转到这篇文章的下一节之前，我们要等着这个命令展示出所有豆荚都运行起来（或许，这个时候应该来杯咖啡！）
### 查看完整的应用程序
在所有的微服务部署完成并且所有相关的豆荚都正常运行后，我们现在将去通过 shopfront 服务的 GUI 去访问我们完整的应用程序。我们可以通过执行 `minikube` 命令在默认浏览器中打开这个服务：
```
$ minikube service shopfront
```
如果一切正常，你将在浏览器中看到如下的页面：
### 结论
在这篇文章中，我们已经完成了由三个 Java Spring Boot 和 Dropwizard 微服务组成的应用程序，并且将它部署到 Kubernetes 上。未来，我们需要考虑的事还很多，比如，调试服务（或许是通过工具，像 [Telepresence](https://telepresence.io/) 和 [Sysdig](https://www.sysdig.org/)），通过一个像 [Jenkins](https://wiki.jenkins.io/display/JENKINS/Kubernetes+Plugin) 或 [Spinnaker](https://www.spinnaker.io/) 这样的可持续交付的过程去测试和部署，并且观察我们的系统运行。
---
*本文是与 NGINX 协作创建的。 [查看我们的编辑独立性声明](http://www.oreilly.com/about/editorial_independence.html).*
---
作者简介：
Daniel Bryant 是一名独立技术顾问，他是 SpectoLabs 的 CTO。他目前关注于通过识别价值流、创建构建过程、和实施有效的测试策略，从而在组织内部实现持续交付。Daniel 擅长并关注于“DevOps”工具、云/容器平台和微服务实现。他也贡献了几个开源项目，并定期为 InfoQ、 O’Reilly、和 Voxxed 撰稿...
---
via: <https://www.oreilly.com/ideas/how-to-manage-docker-containers-in-kubernetes-with-java>
作者：[Daniel Bryant](https://www.oreilly.com/people/d3f4d647-482d-4dce-a0e5-a09773b77150) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 Ansible Container 构建和测试应用程序
|
Clement Verna
|
https://fedoramagazine.org/build-test-applications-ansible-container/
|
容器是一个日益流行的开发环境。作为一名开发人员，你可以选择多种工具来管理你的容器。本文将向你介绍 Ansible Container，并展示如何在类似生产环境中运行和测试你的应用程序。
|
/data/attachment/album/201711/19/061202bud9plxpcqeeztlz.jpg.thumb.jpg
|
/data/attachment/album/201711/19/061202bud9plxpcqeeztlz.jpg
| true
| false
| true
|
geekpi
| false
|
[
"Ansible",
"容器"
] |
容器与云
|
{
"viewnum": 6016,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
容器是一个日益流行的开发环境。作为一名开发人员，你可以选择多种工具来管理你的容器。本文将向你介绍 Ansible Container，并展示如何在类似生产环境中运行和测试你的应用程序。
| 2017-11-19T06:11:59
| 2017-11-19T06:11:59
| 9,069
|
/article-9069-1.html
|
容器是一个日益流行的开发环境。作为一名开发人员，你可以选择多种工具来管理你的容器。本文将向你介绍 Ansible Container，并展示如何在类似生产环境中运行和测试你的应用程序。
### 入门
这个例子使用了一个简单的 Flask Hello World 程序。这个程序就像在生产环境中一样由 Apache HTTP 服务器提供服务。首先，安装必要的 `docker` 包：
```
sudo dnf install docker
```
Ansible Container 需要通过本地套接字与 Docker 服务进行通信。以下命令将更改套接字所有者，并将你添加到可访问此套接字的 `docker` 用户组：
```
sudo groupadd docker && sudo gpasswd -a $USER docker
MYGRP=$(id -g) ; newgrp docker ; newgrp $MYGRP
```
运行 `id` 命令以确保 `docker` 组在你的组成员中列出。最后，[使用 sudo](https://fedoramagazine.org/howto-use-sudo/) 启用并启动 docker 服务：
```
sudo systemctl enable docker.service
sudo systemctl start docker.service
```
### 设置 Ansible Container
Ansible Container 使你能够构建容器镜像并使用 Ansible playbook 进行编排。该程序在一个 YAML 文件中描述，而不是使用 Dockerfile，列出组成容器镜像的 Ansible 角色。
不幸的是，Ansible Container 在 Fedora 中没有 RPM 包可用。要安装它，请使用 python3 虚拟环境模块。
```
mkdir ansible-container-flask-example
cd ansible-container-flask-example
python3 -m venv .venv
source .venv/bin/activate
pip install ansible-container[docker]
```
这些命令将安装 Ansible Container 及 Docker 引擎。 Ansible Container 提供三种引擎：Docker、Kubernetes 和 Openshift。
### 设置项目
现在已经安装了 Ansible Container，接着设置这个项目。Ansible Container 提供了一个简单的命令来创建启动所需的所有文件：
```
ansible-container init
```
来看看这个命令在当前目录中创建的文件：
* `ansible.cfg`
* `ansible-requirements.txt`
* `container.yml`
* `meta.yml`
* `requirements.yml`
该项目仅使用 `container.yml` 来描述程序服务。有关其他文件的更多信息，请查看 Ansible Container 的[入门](https://docs.ansible.com/ansible-container/getting_started.html)文档。
### 定义容器
如下更新 `container.yml`：
```
version: "2"
settings:
conductor:
# The Conductor container does the heavy lifting, and provides a portable
# Python runtime for building your target containers. It should be derived
# from the same distribution as you're building your target containers with.
base: fedora:26
# roles_path: # Specify a local path containing Ansible roles
# volumes: # Provide a list of volumes to mount
# environment: # List or mapping of environment variables
# Set the name of the project. Defaults to basename of the project directory.
# For built services, concatenated with service name to form the built image name.
project_name: flask-helloworld
services:
# Add your containers here, specifying the base image you want to build from.
# To use this example, uncomment it and delete the curly braces after services key.
# You may need to run `docker pull ubuntu:trusty` for this to work.
web:
from: "fedora:26"
roles:
- base
ports:
- "5000:80"
command: ["/usr/bin/dumb-init", "httpd", "-DFOREGROUND"]
volumes:
- $PWD/flask-helloworld:/flaskapp:Z
```
`conductor` 部分更新了基本设置以使用 Fedora 26 容器基础镜像。
`services` 部分添加了 `web` 服务。这个服务使用 Fedora 26，后面有一个名为 `base` 的角色。它还设置容器和主机之间的端口映射。Apache HTTP 服务器为容器的端口 80 上的 Flask 程序提供服务，该容器重定向到主机的端口 5000。然后这个文件定义了一个卷，它将 Flask 程序源代码挂载到容器中的 `/flaskapp` 中。
最后，容器启动时运行 `command` 配置。这个例子中使用 [dumb-init](https://github.com/Yelp/dumb-init)，一个简单的进程管理器并初始化系统启动 Apache HTTP 服务器。
### Ansible 角色
现在已经设置完了容器，创建一个 Ansible 角色来安装并配置 Flask 程序所需的依赖关系。首先，创建 `base` 角色。
```
mkdir -p roles/base/tasks
touch roles/base/tasks/main.yml
```
现在编辑 `main.yml` ，它看起来像这样：
```
---
- name: Install dependencies
dnf: pkg={{item}} state=present
with_items:
- python3-flask
- dumb-init
- httpd
- python3-mod_wsgi
- name: copy the apache configuration
copy:
src: flask-helloworld.conf
dest: /etc/httpd/conf.d/flask-helloworld.conf
owner: apache
group: root
mode: 655
```
这个 Ansible 角色是简单的。首先它安装依赖关系。然后，复制 Apache HTTP 服务器配置。如果你对 Ansible 角色不熟悉，请查看[角色文档](http://docs.ansible.com/ansible/latest/playbooks_reuse_roles.html)。
### Apache HTTP 配置
接下来，通过创建 `flask-helloworld.conf` 来配置 Apache HTTP 服务器：
```
$ mkdir -p roles/base/files
$ touch roles/base/files/flask-helloworld.conf
```
最后将以下内容添加到文件中：
```
<VirtualHost *>
ServerName example.com
WSGIDaemonProcess hello_world user=apache group=root
WSGIScriptAlias / /flaskapp/flask-helloworld.wsgi
<Directory /flaskapp>
WSGIProcessGroup hello_world
WSGIApplicationGroup %{GLOBAL}
Require all granted
</Directory>
</VirtualHost>
```
这个文件的重要部分是 `WSGIScriptAlias`。该指令将脚本 `flask-helloworld.wsgi` 映射到 `/`。有关 Apache HTTP 服务器和 mod\_wsgi 的更多详细信息，请阅读 [Flask 文档](http://flask.pocoo.org/docs/0.12/deploying/mod_wsgi/)。
### Flask “hello world”
最后，创建一个简单的 Flask 程序和 `flask-helloworld.wsgi` 脚本。
```
mkdir flask-helloworld
touch flask-helloworld/app.py
touch flask-helloworld/flask-helloworld.wsgi
```
将以下内容添加到 `app.py`：
```
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
return "Hello World!"
```
然后编辑 `flask-helloworld.wsgi` ，添加这个：
```
import sys
sys.path.insert(0, '/flaskapp/')
from app import app as application
```
### 构建并运行
现在是时候使用 `ansible-container build` 和 `ansible-container run` 命令来构建和运行容器。
```
ansible-container build
```
这个命令需要一些时间来完成，所以要耐心等待。
```
ansible-container run
```
你现在可以通过以下 URL 访问你的 flask 程序： http://localhost:5000/
### 结论
你现在已经看到如何使用 Ansible Container 来管理、构建和配置在容器中运行的程序。本例的所有配置文件和源代码在 [Pagure.io](https://pagure.io/ansible-container-flask-example) 上。你可以使用此例作为基础来开始在项目中使用 Ansible Container。
---
via: <https://fedoramagazine.org/build-test-applications-ansible-container/>
作者：[Clement Verna](https://fedoramagazine.org/author/cverna/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
通过构建一个简单的掷骰子游戏去学习怎么用 Python 编程
|
Seth Kenlon
|
https://opensource.com/article/17/10/python-101
|
不论是经验丰富的老程序员，还是没有经验的新手，Python 都是一个非常好的编程语言。
|
/data/attachment/album/201711/20/084125nss5x4ubwbpayyky.jpg.thumb.jpg
|
/data/attachment/album/201711/20/084125nss5x4ubwbpayyky.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"编程",
"Python"
] |
软件开发
|
{
"viewnum": 15111,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "103.218.216.131",
"message": "真的是又臭又长",
"username": "来自亚太地区的 Chrome 73.0|Windows 10 用户",
"date": "2019-04-02T16:39:01"
}
] |
[
{
"raid": 9362,
"displayorder": 0
},
{
"raid": 10850,
"displayorder": 1
}
] |
不论是经验丰富的老程序员，还是没有经验的新手，Python 都是一个非常好的编程语言。
| 2017-11-20T08:41:00
| 2017-11-20T08:41:00
| 9,071
|
/article-9071-1.html
|
>
> 不论是经验丰富的老程序员，还是没有经验的新手，Python 都是一个非常好的编程语言。
>
>
>
[Python](https://www.python.org/) 是一个非常流行的编程语言，它可以用于创建桌面应用程序、3D 图形、视频游戏、甚至是网站。它是非常好的首选编程语言，因为它易于学习，不像一些复杂的语言，比如，C、 C++、 或 Java。 即使如此， Python 依然也是强大且健壮的，足以创建高级的应用程序，并且几乎适用于所有使用电脑的行业。不论是经验丰富的老程序员，还是没有经验的新手，Python 都是一个非常好的编程语言。
### 安装 Python
在学习 Python 之前，你需要先去安装它：
**Linux：** 如果你使用的是 Linux 系统， Python 是已经包含在里面了。但是，你如果确定要使用 Python 3 。应该去检查一下你安装的 Python 版本，打开一个终端窗口并输入：
```
python3 -V
```
如果提示该命令没有找到，你需要从你的包管理器中去安装 Python 3。
**MacOS：** 如果你使用的是一台 Mac，可以看上面 Linux 的介绍来确认是否安装了 Python 3。MacOS 没有内置的包管理器，因此，如果发现没有安装 Python 3，可以从 [python.org/downloads/mac-osx](https://www.python.org/downloads/mac-osx/) 安装它。即使 macOS 已经安装了 Python 2，你还是应该学习 Python 3。
**Windows：** 微软 Windows 当前是没有安装 Python 的。从 [python.org/downloads/windows](https://www.python.org/downloads/windows) 安装它。在安装向导中一定要选择 **Add Python to PATH** 来将 Python 执行程序放到搜索路径。
### 在 IDE 中运行
在 Python 中写程序，你需要准备一个文本编辑器，使用一个集成开发环境（IDE）是非常实用的。IDE 在一个文本编辑器中集成了一些方便而有用的 Python 功能。IDLE 3 和 NINJA-IDE 是你可以考虑的两种选择：
#### IDLE 3
Python 自带的一个基本的 IDE 叫做 IDLE。
它有关键字高亮功能，可以帮助你检测拼写错误，并且有一个“运行”按钮可以很容易地快速测试代码。
要使用它：
* 在 Linux 或 macOS 上，启动一个终端窗口并输入 `idle3`。
* 在 Windows，从开始菜单中启动 Python 3。
+ 如果你在开始菜单中没有看到 Python，在开始菜单中通过输入 `cmd` 启动 Windows 命令提示符，然后输入 `C:\Windows\py.exe`。
+ 如果它没有运行，试着重新安装 Python。并且确认在安装向导中选择了 “Add Python to PATH”。参考 [docs.python.org/3/using/windows.html](https://docs.python.org/3/using/windows.html) 中的详细介绍。
+ 如果仍然不能运行，那就使用 Linux 吧！它是免费的，只要将你的 Python 文件保存到一个 U 盘中，你甚至不需要安装它就可以使用。
#### Ninja-IDE
[Ninja-IDE](http://ninja-ide.org/) 是一个优秀的 Python IDE。它有关键字高亮功能可以帮助你检测拼写错误、引号和括号补全以避免语法错误，行号（在调试时很有帮助）、缩进标记，以及运行按钮可以很容易地进行快速代码测试。
要使用它：
1. 安装 Ninja-IDE。如果你使用的是 Linux，使用包管理器安装是非常简单的；否则， 从 NINJA-IDE 的网站上 [下载](http://ninja-ide.org/downloads/) 合适的安装版本。
2. 启动 Ninja-IDE。
3. 转到 Edit 菜单，并选择 Preferences 设置。
4. 在 Preferences 窗口中，点击 Execution 选项卡。
5. 在 Execution 选项卡上，更改 `python` 为 `python3`。
*Ninja-IDE 中的 Python3*
### 告诉 Python 想做什么
关键字可以告诉 Python 你想要做什么。不论是在 IDLE 还是在 Ninja 中，转到 File 菜单并创建一个新文件。对于 Ninja 用户：不要创建一个新项目，仅创建一个新文件。
在你的新的空文件中，在 IDLE 或 Ninja 中输入以下内容：
```
print("Hello world.")
```
* 如果你使用的是 IDLE，转到 Run 菜单并选择 Run module 选项。
* 如果你使用的是 Ninja，在左侧按钮条中点击 Run File 按钮。
*在 Ninja 中运行文件*
关键字 `print` 告诉 Python 去打印输出在圆括号中引用的文本内容。
虽然，这并不是特别刺激。在其内部， Python 只能访问基本的关键字，像 `print`、 `help`，最基本的数学函数，等等。
可以使用 `import` 关键字加载更多的关键字。在 IDLE 或 Ninja 中开始一个新文件，命名为 `pen.py`。
**警告：**不要命名你的文件名为 `turtle.py`，因为名为 `turtle.py` 的文件是包含在你正在控制的 turtle （海龟）程序中的。命名你的文件名为 `turtle.py` ，将会把 Python 搞糊涂，因为它会认为你将导入你自己的文件。
在你的文件中输入下列的代码，然后运行它：
```
import turtle
```
Turtle 是一个非常有趣的模块，试着这样做：
```
turtle.begin_fill()
turtle.forward(100)
turtle.left(90)
turtle.forward(100)
turtle.left(90)
turtle.forward(100)
turtle.left(90)
turtle.forward(100)
turtle.end_fill()
```
看一看你现在用 turtle 模块画出了一个什么形状。
要擦除你的海龟画图区，使用 `turtle.clear()` 关键字。想想看，使用 `turtle.color("blue")` 关键字会出现什么情况？
尝试更复杂的代码：
```
import turtle as t
import time
t.color("blue")
t.begin_fill()
counter=0
while counter < 4:
t.forward(100)
t.left(90)
counter = counter+1
t.end_fill()
time.sleep(5)
```
运行完你的脚本后，是时候探索更有趣的模块了。
### 通过创建一个游戏来学习 Python
想学习更多的 Python 关键字，和用图形编程的高级特性，让我们来关注于一个游戏逻辑。在这个教程中，我们还将学习一些关于计算机程序是如何构建基于文本的游戏的相关知识，在游戏里面计算机和玩家掷一个虚拟骰子，其中掷的最高的是赢家。
#### 规划你的游戏
在写代码之前，最重要的事情是考虑怎么去写。在他们写代码 *之前*，许多程序员是先 [写简单的文档](https://opensource.com/article/17/8/doc-driven-development)，这样，他们就有一个编程的目标。如果你想给这个程序写个文档的话，这个游戏看起来应该是这样的：
1. 启动掷骰子游戏并按下 Return 或 Enter 去掷骰子
2. 结果打印在你的屏幕上
3. 提示你再次掷骰子或者退出
这是一个简单的游戏，但是，文档会告诉你需要做的事很多。例如，它告诉你写这个游戏需要下列的组件：
* 玩家：你需要一个人去玩这个游戏。
* AI：计算机也必须去掷，否则，就没有什么输或赢了
* 随机数：一个常见的六面骰子表示从 1-6 之间的一个随机数
* 运算：一个简单的数学运算去比较一个数字与另一个数字的大小
* 一个赢或者输的信息
* 一个再次玩或退出的提示
#### 制作掷骰子游戏的 alpha 版
很少有程序，一开始就包含其所有的功能，因此，它们的初始版本仅实现最基本的功能。首先是几个定义：
**变量**是一个经常要改变的值，它在 Python 中使用的非常多。每当你需要你的程序去“记住”一些事情的时候，你就要使用一个变量。事实上，运行于代码中的信息都保存在变量中。例如，在数学方程式 `x + 5 = 20` 中，变量是 `x` ，因为字母 `x` 是一个变量占位符。
**整数**是一个数字， 它可以是正数也可以是负数。例如，`1` 和 `-1` 都是整数，因此，`14`、`21`，甚至 `10947` 都是。
在 Python 中变量创建和使用是非常容易的。这个掷骰子游戏的初始版使用了两个变量： `player` 和 `ai`。
在命名为 `dice_alpha.py` 的新文件中输入下列代码：
```
import random
player = random.randint(1,6)
ai = random.randint(1,6)
if player > ai :
print("You win") # notice indentation
else:
print("You lose")
```
启动你的游戏，确保它能工作。
这个游戏的基本版本已经工作的非常好了。它实现了游戏的基本目标，但是，它看起来不像是一个游戏。玩家不知道他们摇了什么，电脑也不知道摇了什么，并且，即使玩家还想玩但是游戏已经结束了。
这是软件的初始版本（通常称为 alpha 版）。现在你已经确信实现了游戏的主要部分（掷一个骰子），是时候该加入到程序中了。
#### 改善这个游戏
在你的游戏的第二个版本中（称为 beta 版），将做一些改进，让它看起来像一个游戏。
##### 1、 描述结果
不要只告诉玩家他们是赢是输，他们更感兴趣的是他们掷的结果。在你的代码中尝试做如下的改变：
```
player = random.randint(1,6)
print("You rolled " + player)
ai = random.randint(1,6)
print("The computer rolled " + ai)
```
现在，如果你运行这个游戏，它将崩溃，因为 Python 认为你在尝试做数学运算。它认为你试图在 `player` 变量上加字母 `You rolled` ，而保存在其中的是数字。
你必须告诉 Python 处理在 `player` 和 `ai` 变量中的数字，就像它们是一个句子中的单词（一个字符串）而不是一个数学方程式中的一个数字（一个整数）。
在你的代码中做如下的改变：
```
player = random.randint(1,6)
print("You rolled " + str(player) )
ai = random.randint(1,6)
print("The computer rolled " + str(ai) )
```
现在运行你的游戏将看到该结果。
##### 2、 让它慢下来
计算机运行的非常快。人有时可以很快，但是在游戏中，产生悬念往往更好。你可以使用 Python 的 `time` 函数，在这个紧张时刻让你的游戏慢下来。
```
import random
import time
player = random.randint(1,6)
print("You rolled " + str(player) )
ai = random.randint(1,6)
print("The computer rolls...." )
time.sleep(2)
print("The computer has rolled a " + str(player) )
if player > ai :
print("You win") # notice indentation
else:
print("You lose")
```
启动你的游戏去测试变化。
##### 3、 检测关系
如果你多玩几次你的游戏，你就会发现，即使你的游戏看起来运行很正确，它实际上是有一个 bug 在里面：当玩家和电脑摇出相同的数字的时候，它就不知道该怎么办了。
去检查一个值是否与另一个值相等，Python 使用 `==`。那是个“双”等号标记，不是一个。如果你仅使用一个，Python 认为你尝试去创建一个新变量，但是，实际上你是去尝试做数学运算。
当你想有比两个选项（即，赢或输）更多的选择时，你可以使用 Python 的 `elif` 关键字，它的意思是“否则，如果”。这允许你的代码去检查，是否在“许多”结果中有一个是 `true`， 而不是只检查“一个”是 `true`。
像这样修改你的代码：
```
if player > ai :
print("You win") # notice indentation
elif player == ai:
print("Tie game.")
else:
print("You lose")
```
多运行你的游戏几次，去看一下你能否和电脑摇出一个平局。
#### 编写最终版
你的掷骰子游戏的 beta 版的功能和感觉比起 alpha 版更像游戏了，对于最终版，让我们来创建你的第一个 Python **函数**。
函数是可以作为一个独立的单元来调用的一组代码的集合。函数是非常重要的，因为，大多数应用程序里面都有许多代码，但不是所有的代码都只运行一次。函数可以启用应用程序并控制什么时候可以发生什么事情。
将你的代码变成这样：
```
import random
import time
def dice():
player = random.randint(1,6)
print("You rolled " + str(player) )
ai = random.randint(1,6)
print("The computer rolls...." )
time.sleep(2)
print("The computer has rolled a " + str(player) )
if player > ai :
print("You win") # notice indentation
else:
print("You lose")
print("Quit? Y/N")
cont = input()
if cont == "Y" or cont == "y":
exit()
elif cont == "N" or cont == "n":
pass
else:
print("I did not understand that. Playing again.")
```
游戏的这个版本，在他们玩游戏之后会询问玩家是否退出。如果他们用一个 `Y` 或 `y` 去响应， Python 就会调用它的 `exit` 函数去退出游戏。
更重要的是，你将创建一个称为 `dice` 的你自己的函数。这个 `dice` 函数并不会立即运行，事实上，如果在这个阶段你尝试去运行你的游戏，它不会崩溃，但它也不会正式运行。要让 `dice` 函数真正运行起来做一些事情，你必须在你的代码中去**调用它**。
在你的现有代码下面增加这个循环，前两行就是上文中的前两行，不需要再次输入，并且要注意哪些需要缩进哪些不需要。**要注意缩进格式**。
```
else:
print("I did not understand that. Playing again.")
# main loop
while True:
print("Press return to roll your die.")
roll = input()
dice()
```
`while True` 代码块首先运行。因为 `True` 被定义为总是真，这个代码块将一直运行，直到 Python 告诉它退出为止。
`while True` 代码块是一个循环。它首先提示用户去启动这个游戏，然后它调用你的 `dice` 函数。这就是游戏的开始。当 `dice` 函数运行结束，根据玩家的回答，你的循环再次运行或退出它。
使用循环来运行程序是编写应用程序最常用的方法。循环确保应用程序保持长时间的可用，以便计算机用户使用应用程序中的函数。
### 下一步
现在，你已经知道了 Python 编程的基础知识。这个系列的下一篇文章将描述怎么使用 [PyGame](https://www.pygame.org/news) 去编写一个视频游戏，一个比 turtle 模块有更多功能的模块，但它也更复杂一些。
---
作者简介：
Seth Kenlon - 一个独立的多媒体大师，自由文化的倡导者，和 UNIX 极客。他同时从事电影和计算机行业。他是基于 slackwarers 的多媒体制作项目的维护者之一， <http://slackermedia.info>
---
via: <https://opensource.com/article/17/10/python-101>
作者：[Seth Kenlon](https://opensource.com/users/seth) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
ABC 时代 GPL 许可证传染性问题探讨
|
薛亮
|
2017 年 11 月 18 日至 19 日，2017 中国开源年会在上海交大召开，来自集慧智佳的高级咨询师薛亮在开源治理分论坛上发表了题为《ABC 时代 GPL 许可证传染性问题探讨》的演讲，现将演讲的内容进行整理和补充，以飨读者。
|
/data/attachment/album/201711/21/162834cq37o33g05bi380h.jpg.thumb.jpg
|
/data/attachment/album/201711/21/162834cq37o33g05bi380h.jpg
| true
| false
| false
| false
|
[
"GPL",
"MongoDB",
"许可证"
] |
开源智慧
|
{
"viewnum": 8592,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
2017 年 11 月 18 日至 19 日，2017 中国开源年会在上海交大召开，来自集慧智佳的高级咨询师薛亮在开源治理分论坛上发表了题为《ABC 时代 GPL 许可证传染性问题探讨》的演讲，现将演讲的内容进行整理和补充，以飨读者。
| 2017-11-21T16:50:00
| 2017-11-21T16:50:00
| 9,072
|
/article-9072-1.html
|
>
> 2017 年 11 月 18 日至 19 日，2017 中国开源年会在上海交大召开，来自集慧智佳的高级咨询师薛亮在开源治理分论坛上发表了题为《ABC 时代 GPL 许可证传染性问题探讨》的演讲，现将演讲的内容进行整理和补充，以飨读者。
>
>
>
我们目前所处的时代被称为“ABC（AI、Big Data、Cloud）时代”，也是大量采用开源软件的时代。在这个过程中，不可避免地会遇到开源软件合规的问题，而其中最让人感到困惑的，可以说就是 GPL 许可证传染性问题。那么 GPL 软件是不是真的像传说中的避之唯恐不及，其传染性风险令人谈之色变呢？本次演讲和大家简要探讨一下 GPL 传染性问题。
演讲内容主要包括四个部分，第一部分为“从合规到牟利”，简要介绍目前开源软件合规环境的变化情况。第二部分为“ GPL 传染性判断”，介绍从实务角度考虑，GPL 传染性判断的流程、方法和原则。第三部分为“MongoDB 案例”，介绍了采用 AGPL 许可证的 MongoDB 案例。第四部分为“开源智慧专栏”，简单介绍集慧智佳与 Linux 中国合作开办的“[开源智慧专栏](https://linux.cn/talk/ossip/)”。
第一部分题目为“从合规到牟利”，介绍了近些年开源软件合规和诉讼态势发生的变化，已经从单纯的“寻求合规”转变为“追求牟利”，而这种变化使得开源软件用户的合规风险变得越来越严重。
以最为严格的 GPL 许可证来说，自由软件基金会和自由软件管理机构是全球推行 GPL 许可的主要机构，其追求的主要目标之一是实现 GPL 的合规，对于那些在无意中违反 GPL 许可证的行为，本着“惩前毖后，治病救人”的原则，大多数还是以教育和帮助为主，并不会刻意追求罚款、赔偿等。
但是，随着开源软件合规和诉讼生态的发展，涌现了更多类型的新玩家。根据[国外律师的观察](https://www.slideshare.net/blackducksoftware/litigation-and-compliance-in-the-open-source-ecosystem)，除了诸如 SFLC、SFC 等传统的合规机构之外，近年来出现了比较激进的例如 McHardy 这样的<ruby> 版权流氓 <rp> （ </rp> <rt> Copyright Troll </rt> <rp> ） </rp></ruby>，或者说是 GPL 牟利者，其主要目标已经从合规转变为牟利，要求对违规行为颁发禁令或进行赔偿。
根据“开源智慧专栏”发表的翻译文章《[如何应对开源软件的版权牟利者？ 开源律师说这样做！](/article-9005-1.html)》，GPL 牟利者 McHardy 已经骚扰了 50 多个目标，据说有些国内企业也在其中。
面对越来越复杂的开源软件合规态势，作为开源软件用户来说，对于许可证合规问题，需要引起重视，而 GPL 传染性显然是其中最让人头疼的问题。
第二部分我们具体探讨一下“GPL 传染性判断”，主要是根据我们的研究和实务经验，对于如何评估和判断GPL软件的传染性进行梳理和总结。
对于软件企业的技术人员来说，开源代码是否好用，是他们选用开源代码的重要标准之一，而不会过多考虑许可证问题。但对于企业的合规和法律部门来说，自己企业的技术人员使用了哪些开源软件，这些开源软件采用哪些许可证，则是需要进行排查和梳理，做到心中有数。而对于采用 GPL 许可证的软件，为了避免传染性，是不是必须简单地“一刀切”，绝对禁止使用呢？
我们认为，根据 GPL 软件类型和使用场景的不同，其传染性风险也存在不同。**其中一个关键的分界点，在于自用与分发。**
自用的范畴比较广泛，在公司个人、部门使用，甚至在公司内部分发，都可以自由使用。
对于编译器、解释器等工具类软件，其主要作用是对代码进行加工，可以归为自用的范畴，但也要区分 GPL 工具类软件是否将自身代码混进其所加工的代码。例如 GCC 是 GPL 编译器，但使用 GCC 不会感染被编译的源文件。
对于采用 GPL、LGPL 许可证的软件，如果放在服务器/云上以 SaaS 方式对外提供服务，也可以算作自用的范畴。但是，采用 AGPL 许可证的软件除外，AGPL 专门针对 SaaS 方式进行约束。
我们接着再来看分发，对于一些必须分发出去的 GPL 软件，其类型也有多种。对于一些相对独立的软件，需要注意与自有代码是各自独立还是复杂的糅合，是否构成了结合作品。对于诸如 MQTT 等协议实现类的软件，其实现方式有多种，可以选择采用宽松许可证的开源软件。许多开源软件也采用双重授权，如果担心开源版本的风险问题，可以选择花钱购买其商业授权版本。
对于自有代码与 GPL 软件的链接/混合，也分几种情况。例如对于自有模块 A 和 GPL 模块 B，需要根据两者之间的通信亲密程度以及传输数据的复杂程度，判断两者是否构成了结合作品。对于 GPL 插件，需要分析自有代码主程序对其调用的方式，判断是否造成传染。
对于自有代码与 GPL 库的链接，根据 GPL 许可证，无论是采用静态链接或动态链接方式，都会造成自有代码被传染，必须进行公开。而之后发表的 LGPL 许可证，则对 GPL 库的链接稍微放松了限制。由于 LGPL 专门针对库而制定，采用 LGPL 的库相对来说应该已经考虑了对调用程序的影响，更容易避免被“传染”。
我们再来看一下“自用”，GNU 官方问答对于自用的解释非常宽泛，在一个企业集团的总公司、分公司、子公司等使用，都可以算作自用的范畴，不构成分发。
对于采用 GPL、LGPL 许可证的软件，如果放在服务器/云上以 SaaS 方式对外提供服务，不构成分发，但如果将其部署在用户终端上，则构成分发，带来传染性问题。
对于采用 AGPL 许可证的软件，即便是运行在服务器/云上，如果后续用户对其源代码进行了修改，也必须将修改版本发布出来。
需要注意的是，某个GPL软件的使用场景如果发生变化，之前对其传染性风险的判断也有可能变化，需要根据新的使用场景重新评估。
第三部分我们来看一个案例，MongoDB 是一个非常典型的使用 AGPL 许可证的开源软件。国外有文章甚至开玩笑说，正是因为有了 MongoDB，人们对 AGPL 许可证的看法有了明显改变，从 “never use AGPL” 转变成 “[never use AGPL except for Mongo DB](https://blog.blackducksoftware.com/agpl-out-of-the-shadows)”。
具体看一下 MongoDB 的许可政策。MongoDB 的数据库部分采用严格的 AGPL v3.0 许可证，并且是双重许可，用户既可以选择开源版本，也可以选择商业授权版本。MongoDB 的驱动部分则采用宽松的 Apache v2.0 许可证。
通过对数据库和驱动分别适用不同的许可证，MongoDB 在坚守其自由软件本质的同时，也为用户大开方便之门。
其中需要注意，如果用户修改了 MongoDB 核心数据库的源代码，则必须将修改版本发布出来，回馈给社区。
反之，如果用户的程序仅是使用 MongoDB 数据库，没有对数据库源代码进行修改，则不必发布该用户程序。Copyleft 仅适用于 mongod 和 mongos 数据库，而驱动则采用 Apache 许可证，所以用户的程序如果通过 MongoDB 官方推荐的驱动与数据库进行交互，也不被视为 AGPL 范畴下的结合作品，而是单独的程序或作品，无需担心被传染。
从 MongoDB 这个案例可以看出，一些开源软件的著作权人为了保护和推广自己的开源项目，可以说是“煞费苦心”，绞尽脑汁地在许可证方面进行精巧的设计，给出一些“例外声明”，为用户“开后门”，让用户可以相对比较放心地使用，推动了这些开源软件的迅速普及。
“开源智慧专栏”由集慧智佳与国内领先的开源社区 [Linux 中国](https://linux.cn/)合作创办，聚焦开源软件的知识产权问题，旨在传播域外动态，梳理经典判例，翻译重要文本，关注行业热点，分享实务经验。
在第三部分简要介绍了 GPL 传染性判断的方法和原则，其主要依据是自由软件基金会发布的 [GPL 许可证官方问答](https://www.gnu.org/licenses/gpl-faq.html)。我们也对这个问题进行了翻译，陆续发表在本专栏中。此外，对于此前闹得沸沸扬扬的 Facebook 公司 react 许可证事件，我们也进行了实时的跟踪和解读。
以上所列为本专栏从创办至今所发表的文章列表，大家可以登录 Linux 中国的[“开源智慧专栏”](https://linux.cn/talk/ossip/)查看，或者扫描关注微信公众号，接收实时推送的相关文章。
最后，简单介绍一下我本人。我所供职的单位——集慧智佳是中国第一家在新三板挂牌（838286）的知识产权咨询公司，对开源知识产权问题一直进行持续的跟踪和研究，曾承担国家级的开源知识产权研究课题，并为国内知名的互联网软件企业提供开源知识产权风险排查服务。
我在集慧智佳互联网事业部担任高级咨询师，擅长专利检索、专利分析、专利布局、竞争对手跟踪、FTO 调查、开源软件知识产权风险分析；长期为联想、中国移动、海尔、东软等互联网企业、高科技公司提供知识产权咨询服务；担任“开源智慧专栏”主要撰稿人。
* 2017 年 10 月 14 日，在 GNOME 2017 亚洲峰会上发表题为《开源软件的知识产权风险》演讲。
* 2017 年 11 月 18 日，在 2017 中国开源年会上发表题为《ABC 时代 GPL 许可证传染性问题探讨》演讲（[PDF](https://img.linux.net.cn/static/pdf/ABC%E6%97%B6%E4%BB%A3GPL%E8%AE%B8%E5%8F%AF%E8%AF%81%E4%BC%A0%E6%9F%93%E6%80%A7%E9%97%AE%E9%A2%98%E6%8E%A2%E8%AE%A8PPT.%E8%96%9B%E4%BA%AE.20171120.pdf)）。
欢迎大家围绕开源软件知识产权问题与我进行交流！
|
||||
理解多区域配置中的 firewalld
|
Nathan Vance
|
https://www.linuxjournal.com/content/understanding-firewalld-multi-zone-configurations
|
Firewalld 是最新的 netfilter 用户态抽象层。遗憾的是，由于缺乏描述多区域配置的文档，它强大而灵活的功能被低估了。这篇文章提供了一个示例去改变这种情况。
|
/data/attachment/album/201711/21/233944jiz6thts6pk6y6ss.jpg.thumb.jpg
|
/data/attachment/album/201711/21/233944jiz6thts6pk6y6ss.jpg
| true
| false
| true
|
qhwdw
| false
|
[
"firewalld",
"防火墙",
"iptables"
] |
系统运维
|
{
"viewnum": 10047,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Firewalld 是最新的 netfilter 用户态抽象层。遗憾的是，由于缺乏描述多区域配置的文档，它强大而灵活的功能被低估了。这篇文章提供了一个示例去改变这种情况。
| 2017-11-21T23:39:52
| 2017-11-21T23:39:52
| 9,073
|
/article-9073-1.html
|
现在的新闻里充斥着服务器被攻击和数据失窃事件。对于一个阅读过安全公告博客的人来说，通过访问错误配置的服务器，利用最新暴露的安全漏洞或通过窃取的密码来获得系统控制权，并不是件多困难的事情。在一个典型的 Linux 服务器上的任何互联网服务都可能存在漏洞，允许未经授权的系统访问。
因为在应用程序层面上强化系统以防范任何可能的威胁是不可能做到的事情，而防火墙可以通过限制对系统的访问提供了安全保证。防火墙基于源 IP、目标端口和协议来过滤入站包。因为这种方式中，仅有几个 IP/端口/协议的组合与系统交互，而其它的方式做不到过滤。
Linux 防火墙是通过 netfilter 来处理的，它是内核级别的框架。这十几年来，iptables 被作为 netfilter 的用户态抽象层（LCTT 译注： userland，一个基本的 UNIX 系统是由 kernel 和 userland 两部分构成，除 kernel 以外的称为 userland）。iptables 将包通过一系列的规则进行检查，如果包与特定的 IP/端口/协议的组合匹配，规则就会被应用到这个包上，以决定包是被通过、拒绝或丢弃。
Firewalld 是最新的 netfilter 用户态抽象层。遗憾的是，由于缺乏描述多区域配置的文档，它强大而灵活的功能被低估了。这篇文章提供了一个示例去改变这种情况。
### Firewalld 的设计目标
firewalld 的设计者认识到大多数的 iptables 使用案例仅涉及到几个单播源 IP，仅让每个符合白名单的服务通过，而其它的会被拒绝。这种模式的好处是，firewalld 可以通过定义的源 IP 和/或网络接口将入站流量分类到不同<ruby> 区域 <rt> zone </rt></ruby>。每个区域基于指定的准则按自己配置去通过或拒绝包。
另外的改进是基于 iptables 进行语法简化。firewalld 通过使用服务名而不是它的端口和协议去指定服务，使它更易于使用，例如，是使用 samba 而不是使用 UDP 端口 137 和 138 和 TCP 端口 139 和 445。它进一步简化语法，消除了 iptables 中对语句顺序的依赖。
最后，firewalld 允许交互式修改 netfilter，允许防火墙独立于存储在 XML 中的永久配置而进行改变。因此，下面的的临时修改将在下次重新加载时被覆盖：
```
# firewall-cmd <some modification>
```
而，以下的改变在重加载后会永久保存：
```
# firewall-cmd --permanent <some modification>
# firewall-cmd --reload
```
### 区域
在 firewalld 中最上层的组织是区域。如果一个包匹配区域相关联的网络接口或源 IP/掩码 ，它就是区域的一部分。可用的几个预定义区域：
```
# firewall-cmd --get-zones
block dmz drop external home internal public trusted work
```
任何配置了一个**网络接口**和/或一个**源**的区域就是一个<ruby> 活动区域 <rt> active zone </rt></ruby>。列出活动的区域：
```
# firewall-cmd --get-active-zones
public
interfaces: eno1 eno2
```
**Interfaces** （接口）是系统中的硬件和虚拟的网络适配器的名字，正如你在上面的示例中所看到的那样。所有的活动的接口都将被分配到区域，要么是默认的区域，要么是用户指定的一个区域。但是，一个接口不能被分配给多于一个的区域。
在缺省配置中，firewalld 设置所有接口为 public 区域，并且不对任何区域设置源。其结果是，`public` 区域是唯一的活动区域。
**Sources** （源）是入站 IP 地址的范围，它也可以被分配到区域。一个源（或重叠的源）不能被分配到多个区域。这样做的结果是产生一个未定义的行为，因为不清楚应该将哪些规则应用于该源。
因为指定一个源不是必需的，任何包都可以通过接口匹配而归属于一个区域，而不需要通过源匹配来归属一个区域。这表示通过使用优先级方式，优先到达多个指定的源区域，稍后将详细说明这种情况。首先，我们来检查 `public` 区域的配置：
```
# firewall-cmd --zone=public --list-all
public (default, active)
interfaces: eno1 eno2
sources:
services: dhcpv6-client ssh
ports:
masquerade: no
forward-ports:
icmp-blocks:
rich rules:
# firewall-cmd --permanent --zone=public --get-target
default
```
逐行说明如下：
* `public (default, active)` 表示 `public` 区域是默认区域（当接口启动时会自动默认），并且它是活动的，因为，它至少有一个接口或源分配给它。
* `interfaces: eno1 eno2` 列出了这个区域上关联的接口。
* `sources:` 列出了这个区域的源。现在这里什么都没有，但是，如果这里有内容，它们应该是这样的格式 xxx.xxx.xxx.xxx/xx。
* `services: dhcpv6-client ssh` 列出了允许通过这个防火墙的服务。你可以通过运行 `firewall-cmd --get-services` 得到一个防火墙预定义服务的详细列表。
* `ports:` 列出了一个允许通过这个防火墙的目标端口。它是用于你需要去允许一个没有在 firewalld 中定义的服务的情况下。
* `masquerade: no` 表示这个区域是否允许 IP 伪装。如果允许，它将允许 IP 转发，它可以让你的计算机作为一个路由器。
* `forward-ports:` 列出转发的端口。
* `icmp-blocks:` 阻塞的 icmp 流量的黑名单。
* `rich rules:` 在一个区域中优先处理的高级配置。
* `default` 是目标区域，它决定了与该区域匹配而没有由上面设置中显式处理的包的动作。
### 一个简单的单区域配置示例
如果只是简单地锁定你的防火墙。简单地在删除公共区域上当前允许的服务，并重新加载：
```
# firewall-cmd --permanent --zone=public --remove-service=dhcpv6-client
# firewall-cmd --permanent --zone=public --remove-service=ssh
# firewall-cmd --reload
```
在下面的防火墙上这些命令的结果是：
```
# firewall-cmd --zone=public --list-all
public (default, active)
interfaces: eno1 eno2
sources:
services:
ports:
masquerade: no
forward-ports:
icmp-blocks:
rich rules:
# firewall-cmd --permanent --zone=public --get-target
default
```
本着尽可能严格地保证安全的精神，如果发生需要在你的防火墙上临时开放一个服务的情况（假设是 ssh），你可以增加这个服务到当前会话中（省略 `--permanent`），并且指示防火墙在一个指定的时间之后恢复修改：
```
# firewall-cmd --zone=public --add-service=ssh --timeout=5m
```
这个 `timeout` 选项是一个以秒（`s`）、分（`m`）或小时（`h`）为单位的时间值。
### 目标
当一个区域处理它的源或接口上的一个包时，但是，没有处理该包的显式规则时，这时区域的<ruby> 目标 <rt> target </rt></ruby>决定了该行为：
* `ACCEPT`：通过这个包。
* `%%REJECT%%`：拒绝这个包，并返回一个拒绝的回复。
* `DROP`：丢弃这个包，不回复任何信息。
* `default`：不做任何事情。该区域不再管它，把它踢到“楼上”。
在 firewalld 0.3.9 中有一个 bug （已经在 0.3.10 中修复），对于一个目标是除了“default”以外的源区域，不管允许的服务是什么，这的目标都会被应用。例如，一个使用目标 `DROP` 的源区域，将丢弃所有的包，甚至是白名单中的包。遗憾的是，这个版本的 firewalld 被打包到 RHEL7 和它的衍生版中，使它成为一个相当常见的 bug。本文中的示例避免了可能出现这种行为的情况。
### 优先权
活动区域中扮演两个不同的角色。关联接口行为的区域作为接口区域，并且，关联源行为的区域作为源区域（一个区域能够扮演两个角色）。firewalld 按下列顺序处理一个包：
1. 相应的源区域。可以存在零个或一个这样的区域。如果这个包满足一个<ruby> 富规则 <rt> rich rule </rt></ruby>、服务是白名单中的、或者目标没有定义，那么源区域处理这个包，并且在这里结束。否则，向上传递这个包。
2. 相应的接口区域。肯定有一个这样的区域。如果接口处理这个包，那么到这里结束。否则，向上传递这个包。
3. firewalld 默认动作。接受 icmp 包并拒绝其它的一切。
这里的关键信息是，源区域优先于接口区域。因此，对于多区域的 firewalld 配置的一般设计模式是，创建一个优先源区域来允许指定的 IP 对系统服务的提升访问，并在一个限制性接口区域限制其它访问。
### 一个简单的多区域示例
为演示优先权，让我们在 `public` 区域中将 `http` 替换成 `ssh`，并且为我们喜欢的 IP 地址，如 1.1.1.1，设置一个默认的 `internal` 区域。以下的命令完成这个任务：
```
# firewall-cmd --permanent --zone=public --remove-service=ssh
# firewall-cmd --permanent --zone=public --add-service=http
# firewall-cmd --permanent --zone=internal --add-source=1.1.1.1
# firewall-cmd --reload
```
这些命令的结果是生成如下的配置：
```
# firewall-cmd --zone=public --list-all
public (default, active)
interfaces: eno1 eno2
sources:
services: dhcpv6-client http
ports:
masquerade: no
forward-ports:
icmp-blocks:
rich rules:
# firewall-cmd --permanent --zone=public --get-target
default
# firewall-cmd --zone=internal --list-all
internal (active)
interfaces:
sources: 1.1.1.1
services: dhcpv6-client mdns samba-client ssh
ports:
masquerade: no
forward-ports:
icmp-blocks:
rich rules:
# firewall-cmd --permanent --zone=internal --get-target
default
```
在上面的配置中，如果有人尝试从 1.1.1.1 去 `ssh`，这个请求将会成功，因为这个源区域（`internal`）被首先应用，并且它允许 `ssh` 访问。
如果有人尝试从其它的地址，如 2.2.2.2，去访问 `ssh`，它不是这个源区域的，因为和这个源区域不匹配。因此，这个请求被直接转到接口区域（`public`），它没有显式处理 `ssh`，因为，public 的目标是 `default`，这个请求被传递到默认动作，它将被拒绝。
如果 1.1.1.1 尝试进行 `http` 访问会怎样？源区域（`internal`）不允许它，但是，目标是 `default`，因此，请求将传递到接口区域（`public`），它被允许访问。
现在，让我们假设有人从 3.3.3.3 拖你的网站。要限制从那个 IP 的访问，简单地增加它到预定义的 `drop` 区域，正如其名，它将丢弃所有的连接：
```
# firewall-cmd --permanent --zone=drop --add-source=3.3.3.3
# firewall-cmd --reload
```
下一次 3.3.3.3 尝试去访问你的网站，firewalld 将转发请求到源区域（`drop`）。因为目标是 `DROP`，请求将被拒绝，并且它不会被转发到接口区域（`public`）。
### 一个实用的多区域示例
假设你为你的组织的一台服务器配置防火墙。你希望允许全世界使用 `http` 和 `https` 的访问，你的组织（1.1.0.0/16）和工作组（1.1.1.0/8）使用 `ssh` 访问，并且你的工作组可以访问 `samba` 服务。使用 firewalld 中的区域，你可以用一个很直观的方式去实现这个配置。
`public` 这个命名，它的逻辑似乎是把全世界访问指定为公共区域，而 `internal` 区域用于为本地使用。从在 `public` 区域内设置使用 `http` 和 `https` 替换 `dhcpv6-client` 和 `ssh` 服务来开始：
```
# firewall-cmd --permanent --zone=public --remove-service=dhcpv6-client
# firewall-cmd --permanent --zone=public --remove-service=ssh
# firewall-cmd --permanent --zone=public --add-service=http
# firewall-cmd --permanent --zone=public --add-service=https
```
然后，取消 `internal` 区域的 `mdns`、`samba-client` 和 `dhcpv6-client` 服务（仅保留 `ssh`），并增加你的组织为源：
```
# firewall-cmd --permanent --zone=internal --remove-service=mdns
# firewall-cmd --permanent --zone=internal --remove-service=samba-client
# firewall-cmd --permanent --zone=internal --remove-service=dhcpv6-client
# firewall-cmd --permanent --zone=internal --add-source=1.1.0.0/16
```
为容纳你提升的 `samba` 的权限，增加一个富规则：
```
# firewall-cmd --permanent --zone=internal --add-rich-rule='rule family=ipv4 source address="1.1.1.0/8" service name="samba" accept'
```
最后，重新加载，把这些变化拉取到会话中：
```
# firewall-cmd --reload
```
仅剩下少数的细节了。从一个 `internal` 区域以外的 IP 去尝试通过 `ssh` 到你的服务器，结果是回复一个拒绝的消息。它是 firewalld 默认的。更为安全的作法是去显示不活跃的 IP 行为并丢弃该连接。改变 `public` 区域的目标为 `DROP`，而不是 `default` 来实现它：
```
# firewall-cmd --permanent --zone=public --set-target=DROP
# firewall-cmd --reload
```
但是，等等，你不再可以 ping 了，甚至是从内部区域！并且 icmp （ping 使用的协议）并不在 firewalld 可以列入白名单的服务列表中。那是因为，icmp 是第 3 层的 IP 协议，它没有端口的概念，不像那些捆绑了端口的服务。在设置公共区域为 `DROP` 之前，ping 能够通过防火墙是因为你的 `default` 目标通过它到达防火墙的默认动作（default），即允许它通过。但现在它已经被删除了。
为恢复内部网络的 ping，使用一个富规则：
```
# firewall-cmd --permanent --zone=internal --add-rich-rule='rule protocol value="icmp" accept'
# firewall-cmd --reload
```
结果如下，这里是两个活动区域的配置：
```
# firewall-cmd --zone=public --list-all
public (default, active)
interfaces: eno1 eno2
sources:
services: http https
ports:
masquerade: no
forward-ports:
icmp-blocks:
rich rules:
# firewall-cmd --permanent --zone=public --get-target
DROP
# firewall-cmd --zone=internal --list-all
internal (active)
interfaces:
sources: 1.1.0.0/16
services: ssh
ports:
masquerade: no
forward-ports:
icmp-blocks:
rich rules:
rule family=ipv4 source address="1.1.1.0/8" service name="samba" accept
rule protocol value="icmp" accept
# firewall-cmd --permanent --zone=internal --get-target
default
```
这个设置演示了一个三层嵌套的防火墙。最外层，`public`，是一个接口区域，包含全世界的访问。紧接着的一层，`internal`，是一个源区域，包含你的组织，它是 `public` 的一个子集。最后，一个富规则增加到最内层，包含了你的工作组，它是 `internal` 的一个子集。
这里的关键信息是，当在一个场景中可以突破到嵌套层，最外层将使用接口区域，接下来的将使用一个源区域，并且在源区域中额外使用富规则。
### 调试
firewalld 采用直观范式来设计防火墙，但比它的前任 iptables 更容易产生歧义。如果产生无法预料的行为，或者为了更好地理解 firewalld 是怎么工作的，则可以使用 iptables 描述 netfilter 是如何配置操作的。前一个示例的输出如下，为了简单起见，将输出和日志进行了修剪:
```
# iptables -S
-P INPUT ACCEPT
... (forward and output lines) ...
-N INPUT_ZONES
-N INPUT_ZONES_SOURCE
-N INPUT_direct
-N IN_internal
-N IN_internal_allow
-N IN_internal_deny
-N IN_public
-N IN_public_allow
-N IN_public_deny
-A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -j INPUT_ZONES_SOURCE
-A INPUT -j INPUT_ZONES
-A INPUT -p icmp -j ACCEPT
-A INPUT -m conntrack --ctstate INVALID -j DROP
-A INPUT -j REJECT --reject-with icmp-host-prohibited
... (forward and output lines) ...
-A INPUT_ZONES -i eno1 -j IN_public
-A INPUT_ZONES -i eno2 -j IN_public
-A INPUT_ZONES -j IN_public
-A INPUT_ZONES_SOURCE -s 1.1.0.0/16 -g IN_internal
-A IN_internal -j IN_internal_deny
-A IN_internal -j IN_internal_allow
-A IN_internal_allow -p tcp -m tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT
-A IN_internal_allow -s 1.1.1.0/8 -p udp -m udp --dport 137 -m conntrack --ctstate NEW -j ACCEPT
-A IN_internal_allow -s 1.1.1.0/8 -p udp -m udp --dport 138 -m conntrack --ctstate NEW -j ACCEPT
-A IN_internal_allow -s 1.1.1.0/8 -p tcp -m tcp --dport 139 -m conntrack --ctstate NEW -j ACCEPT
-A IN_internal_allow -s 1.1.1.0/8 -p tcp -m tcp --dport 445 -m conntrack --ctstate NEW -j ACCEPT
-A IN_internal_allow -p icmp -m conntrack --ctstate NEW -j ACCEPT
-A IN_public -j IN_public_deny
-A IN_public -j IN_public_allow
-A IN_public -j DROP
-A IN_public_allow -p tcp -m tcp --dport 80 -m conntrack --ctstate NEW -j ACCEPT
-A IN_public_allow -p tcp -m tcp --dport 443 -m conntrack --ctstate NEW -j ACCEPT
```
在上面的 iptables 输出中，新的链（以 `-N` 开始的行）是被首先声明的。剩下的规则是附加到（以 `-A` 开始的行） iptables 中的。已建立的连接和本地流量是允许通过的，并且入站包被转到 `INPUT_ZONES_SOURCE` 链，在那里如果存在相应的区域，IP 将被发送到那个区域。从那之后，流量被转到 `INPUT_ZONES` 链，从那里它被路由到一个接口区域。如果在那里它没有被处理，icmp 是允许通过的，无效的被丢弃，并且其余的都被拒绝。
### 结论
firewalld 是一个文档不足的防火墙配置工具，它的功能远比大多数人认识到的更为强大。以创新的区域范式，firewalld 允许系统管理员去分解流量到每个唯一处理它的分类中，简化了配置过程。因为它直观的设计和语法，它在实践中不但被用于简单的单一区域中也被用于复杂的多区域配置中。
---
via: <https://www.linuxjournal.com/content/understanding-firewalld-multi-zone-configurations>
作者：[Nathan Vance](https://www.linuxjournal.com/users/nathan-vance) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
肯特·贝克：改变人生的代码整理魔法
|
Kent Beck
|
https://www.facebook.com/notes/kent-beck/the-life-changing-magic-of-tidying-up-code/1544047022294823/
|
本周我一直在整理 Facebook 代码，而且我喜欢这个工作。我的职业生涯中已经整理了数千小时的代码，我有一套使这种整理更加安全、有趣和高效的规则。
|
/data/attachment/album/201711/22/152437d7w0kwfb4rw27kc2.jpg.thumb.jpg
|
/data/attachment/album/201711/22/152437d7w0kwfb4rw27kc2.jpg
| true
| false
| true
|
geekpi
| false
|
[
"代码",
"整理",
"编程"
] |
软件开发
|
{
"viewnum": 4774,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本周我一直在整理 Facebook 代码，而且我喜欢这个工作。我的职业生涯中已经整理了数千小时的代码，我有一套使这种整理更加安全、有趣和高效的规则。
| 2017-11-22T15:24:42
| 2017-11-22T15:24:42
| 9,074
|
/article-9074-1.html
|
>
> 本文作者<ruby> 肯特·贝克 <rt> Kent Beck </rt></ruby>，是最早研究软件开发的模式和重构的人之一，是敏捷开发的开创者之一，更是极限编程和测试驱动开发的创始人，同时还是 Smalltalk 和 JUnit 的作者，对当今世界的软件开发影响深远。现在 Facebook 工作。
>
>
>
本周我一直在整理 Facebook 代码，而且我喜欢这个工作。我的职业生涯中已经整理了数千小时的代码，我有一套使这种整理更加安全、有趣和高效的规则。
整理工作是通过一系列短小而安全的步骤进行的。事实上，规则一就是**如果这很难，那就不要去做**。我以前在晚上做填字游戏。如果我卡住那就去睡觉，第二天晚上那些没有发现的线索往往很容易发现。与其想要一心搞个大的，不如在遇到阻力的时候停下来。
整理会陷入这样一种感觉：你错失的要比你从一个个成功中获得的更多（稍后会细说）。第二条规则是**当你充满活力时开始，当你累了时停下来**。起来走走。如果还没有恢复精神，那这一天的工作就算做完了。
只有在仔细追踪其它变化的时候（我把它和最新的差异搞混了），整理工作才可以与开发同步进行。第三条规则是**立即完成每个环节的工作**。与功能开发所不同的是，功能开发只有在完成一大块工作时才有意义，而整理是基于时间一点点完成的。
整理在任何步骤中都只需要付出不多的努力，所以我会在任何步骤遇到麻烦的时候放弃。所以，规则四是**两次失败后恢复**。如果我整理代码，运行测试，并遇到测试失败，那么我会立即修复它。如果我修复失败，我会立即恢复到上次已知最好的状态。
即便没有闪亮的新设计的愿景，整理也是有用的。不过，有时候我想看看事情会如何发展，所以第五条就是**实践**。执行一系列的整理和还原。第二次将更快，你会更加熟悉避免哪些坑。
只有在附带损害的风险较低，审查整理变化的成本也较低的时候整理才有用。规则六是**隔离整理**。如果你错过了在编写代码中途整理的机会，那么接下来可能很困难。要么完成并接着整理，要么还原、整理并进行修改。
试试这些。将临时申明的变量移动到它第一次使用的位置，简化布尔表达式（`return expression == True`？），提取一个 helper，将逻辑或状态的范围缩小到实际使用的位置。
### 规则
* 规则一、 如果这很难，那就不要去做
* 规则二、 当你充满活力时开始，当你累了时停下来
* 规则三、 立即完成每个环节工作
* 规则四、 两次失败后恢复
* 规则五、 实践
* 规则六、 隔离整理
### 尾声
我通过严格地整理改变了架构、提取了框架。这种方式可以安全地做出重大改变。我认为这是因为，虽然每次整理的成本是不变的，但回报是指数级的，但我需要数据和模型来解释这个假说。
---
via: <https://www.facebook.com/notes/kent-beck/the-life-changing-magic-of-tidying-up-code/1544047022294823/>
作者：[KENT BECK](https://www.facebook.com/kentlbeck) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
很遗憾，我也不知道什么是容器！
|
Mike Bursell
|
https://opensource.com/article/17/10/what-are-containers
|
题图抽象的形容了容器和虚拟机是那么的相似，又是那么的不同！
|
/data/attachment/album/201711/22/233347d77ay3h3dy73d3ba.png.thumb.jpg
|
/data/attachment/album/201711/22/233347d77ay3h3dy73d3ba.png
| true
| false
| true
|
jrglinux
| false
|
[
"容器"
] |
容器与云
|
{
"viewnum": 4317,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
题图抽象的形容了容器和虚拟机是那么的相似，又是那么的不同！
| 2017-11-22T23:33:39
| 2017-11-22T23:33:39
| 9,076
|
/article-9076-1.html
|
>
> 题图抽象的形容了容器和虚拟机是那么的相似，又是那么的不同！
>
>
>
在近期的一些会议和学术交流会上，我一直在讲述有关 DevOps 的安全问题（亦称为 DevSecOps）<sup> 注1</sup> 。通常，我首先都会问一个问题：“在座的各位有谁知道什么是容器吗？” 通常并没有很多人举手<sup> 注2</sup> ，所以我都会先简单介绍一下什么是容器<sup> 注3</sup> ，然后再进行深层次的讨论交流。
更准确的说，在运用 DevOps 或者 DevSecOps 的时候，容器并不是必须的。但容器能很好的融于 DevOps 和 DevSecOps 方案中，结果就是，虽然不用容器便可以运用 DevOps ，但我还是假设大部分人依然会使用容器。
### 什么是容器
几个月前的一个会议上，一个同事正在容器上操作演示，因为大家都不是这个方面的专家，所以该同事就很简单的开始了他的演示。他说了诸如“在 Linux 内核源码中没有一处提及到<ruby> 容器 <rt> container </rt></ruby>。“之类的话。事实上，在这样的特殊群体中，这种描述表达是很危险的。就在几秒钟内，我和我的老板（坐在我旁边）下载了最新版本的内核源代码并且查找统计了其中 “container” 单词出现的次数。很显然，这位同事的说法并不准确。更准确来说，我在旧版本内核（4.9.2）代码中发现有 15273 行代码包含 “container” 一词<sup> 注4</sup> 。我和我老板会心一笑，确认同事的说法有误，并在休息时纠正了他这个有误的描述。
后来我们搞清楚同事想表达的意思是 Linux 内核中并没有明确提及容器这个概念。换句话说，容器使用了 Linux 内核中的一些概念、组件、工具以及机制，并没有什么特殊的东西；这些东西也可以用于其他目的<sup> 注</sup> 5 。所以才有会说“从 Linux 内核角度来看，并没有容器这样的东西。”
然后，什么是容器呢？我有着虚拟化（<ruby> 管理器 <rt> hypervisor </rt></ruby>和虚拟机）技术的背景，在我看来， 容器既像虚拟机（VM）又不像虚拟机。我知道这种解释好像没什么用，不过请听我细细道来。
### 容器和虚拟机相似之处有哪些？
容器和虚拟机相似的一个主要方面就是它是一个可执行单元。将文件打包生成镜像文件，然后它就可以运行在合适的主机平台上。和虚拟机一样，它运行于主机上，同样，它的运行也受制于该主机。主机平台为容器的运行提供软件环境和硬件资源（诸如 CPU 资源、网络环境、存储资源等等），除此之外，主机还需要负责以下的任务：
1. 为每一个工作单元（这里指虚拟机和容器）提供保护机制，这样可以保证即使某一个工作单元出现恶意的、有害的以及不能写入的情况时不会影响其他的工作单元。
2. 主机保护自己不会受一些恶意运行或出现故障的工作单元影响。
虚拟机和容器实现这种隔离的原理并不一样，虚拟机的隔离是由管理器对硬件资源划分，而容器的隔离则是通过 Linux 内核提供的软件功能实现的<sup> 注6</sup> 。这种软件控制机制通过不同的“命名空间”保证了每一个容器的文件、用户以及网络连接等互不可见，当然容器和主机之间也互不可见。这种功能也能由 SELinux 之类软件提供，它们提供了进一步隔离容器的功能。
### 容器和虚拟机不同之处又有哪些？
以上描述有个问题，如果你对<ruby> 管理器 <rt> hypervisor </rt></ruby>机制概念比较模糊，也许你会认为容器就是虚拟机，但它确实不是。
首先，最为重要的一点<sup> 注7</sup> ，容器是一种包格式。也许你会惊讶的反问我“什么，你不是说过容器是某种可执行文件么？” 对，容器确实是可执行文件，但容器如此迷人的一个主要原因就是它能很容易的生成比虚拟机小很多的实体化镜像文件。由于这些原因，容器消耗很少的内存，并且能非常快的启动与关闭。你可以在几分钟或者几秒钟（甚至毫秒级别）之内就启动一个容器，而虚拟机则不具备这些特点。
正因为容器是如此轻量级且易于替换，人们使用它们来创建微服务——应用程序拆分而成的最小组件，它们可以和一个或多个其它微服务构成任何你想要的应用。假使你只在一个容器内运行某个特定功能或者任务，你也可以让容器变得很小，这样丢弃旧容器创建新容器将变得很容易。我将在后续的文章中继续跟进这个问题以及它们对安全性的可能影响，当然，也包括 DevSecOps 。
希望这是一次对容器的有用的介绍，并且能带动你有动力去学习 DevSecOps 的知识（如果你不是，假装一下也好）。
---
* 注 1：我觉得 DevSecOps 读起来很奇怪，而 DevOpsSec 往往有多元化的理解，然后所讨论的主题就不一样了。
* 注 2：我应该注意到这不仅仅会被比较保守、不太喜欢被人注意的英国听众所了解，也会被加拿大人和美国人所了解，他们的性格则和英国人不一样。
* 注 3：当然，我只是想讨论 Linux 容器。我知道关于这个问题，是有历史根源的，所以它也值得注意，而不是我故弄玄虚。
* 注 4：如果你感兴趣的话，我使用的是命令 `grep -ir container linux-4.9.2 | wc -l`
* 注 5：公平的说，我们快速浏览一下，一些用途与我们讨论容器的方式无关，我们讨论的是 Linux 容器，它是抽象的，可以用来包含其他元素，因此在逻辑上被称为容器。
* 注 6：也有一些巧妙的方法可以将容器和虚拟机结合起来以发挥它们各自的优势，那个不在我今天的主题范围内。
* 注 7：很明显，除了我们刚才介绍的执行位。
原文来自 [Alice, Eve, and Bob—a security blog](https://aliceevebob.wordpress.com/2017/07/04/but-i-dont-know-what-a-container-is/) ，转载请注明
（题图： opensource.com ）
---
**作者简介**：
原文作者 Mike Bursell 是一名居住在英国、喜欢威士忌的开源爱好者， Red Hat 首席安全架构师。其自从 1997 年接触开源世界以来，生活和工作中一直使用 Linux （尽管不是一直都很容易）。更多信息请参考作者的博客 <https://aliceevebob.com> ，作者会不定期的更新一些有关安全方面的文章。
---
via: <https://opensource.com/article/17/10/what-are-containers>
作者：[Mike Bursell](https://opensource.com/users/mikecamel) 译者：[jrglinux](https://github.com/jrglinux) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 LXD 容器运行 Ubuntu Core
|
Stéphane Graber
|
https://insights.ubuntu.com/2017/02/27/ubuntu-core-in-lxd-containers/
|
Ubuntu Core 是完全基于 snap 包构建，并且完全事务化的 Ubuntu 版本。
|
/data/attachment/album/201711/23/004218pohu77bt0tlrtvz1.jpg.thumb.jpg
|
/data/attachment/album/201711/23/004218pohu77bt0tlrtvz1.jpg
| true
| false
| true
|
aiwhj
| false
|
[
"LXD",
"容器"
] |
容器与云
|
{
"viewnum": 5735,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Ubuntu Core 是完全基于 snap 包构建，并且完全事务化的 Ubuntu 版本。
| 2017-11-23T00:42:53
| 2017-11-23T00:42:53
| 9,077
|
/article-9077-1.html
|
### Ubuntu Core 是什么？
Ubuntu Core 是完全基于 snap 包构建，并且完全事务化的 Ubuntu 版本。
该系统大部分是只读的，所有已安装的应用全部来自 snap 包，完全使用事务化更新。这意味着不管在系统更新还是安装软件的时候遇到问题，整个系统都可以回退到之前的状态并且记录这个错误。
最新版是在 2016 年 11 月发布的 Ubuntu Core 16。
注意，Ubuntu Core 限制只能够安装 snap 包（而非 “传统” 软件包），并且有相当数量的 snap 包在当前环境下不能正常运行，或者需要人工干预（创建用户和用户组等）才能正常运行。随着新版的 snapd 和 “core” snap 包发布，Ubuntu Core 每周都会得到改进。
### 环境需求
就 LXD 而言，Ubuntu Core 仅仅相当于另一个 Linux 发行版。也就是说，snapd 需要挂载无特权的 FUSE 和 AppArmor 命名空间以及软件栈，像下面这样：
* 一个新版的使用 Ubuntu 官方内核的系统
* 一个新版的 LXD
### 创建一个 Ubuntu Core 容器
当前 Ubuntu Core 镜像发布在社区的镜像服务器。你可以像这样启动一个新的容器：
```
stgraber@dakara:~$ lxc launch images:ubuntu-core/16 ubuntu-core
Creating ubuntu-core
Starting ubuntu-core
```
这个容器启动需要一点点时间，它会先执行第一阶段的加载程序，加载程序会确定使用哪一个镜像（镜像是只读的），并且在系统上设置一个可读层，你不要在这一阶段中断容器执行，这个时候什么都没有，所以执行 `lxc exec` 将会出错。
几秒钟之后，执行 `lxc list` 将会展示容器的 IP 地址，这表明已经启动了 Ubuntu Core：
```
stgraber@dakara:~$ lxc list
+-------------+---------+----------------------+----------------------------------------------+------------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+-------------+---------+----------------------+----------------------------------------------+------------+-----------+
| ubuntu-core | RUNNING | 10.90.151.104 (eth0) | 2001:470:b368:b2b5:216:3eff:fee1:296f (eth0) | PERSISTENT | 0 |
+-------------+---------+----------------------+----------------------------------------------+------------+-----------+
```
之后你就可以像使用其他的交互一样和这个容器进行交互：
```
stgraber@dakara:~$ lxc exec ubuntu-core bash
root@ubuntu-core:~# snap list
Name Version Rev Developer Notes
core 16.04.1 394 canonical -
pc 16.04-0.8 9 canonical -
pc-kernel 4.4.0-45-4 37 canonical -
root@ubuntu-core:~#
```
### 更新容器
如果你一直关注着 Ubuntu Core 的开发，你应该知道上面的版本已经很老了。这是因为被用作 Ubuntu LXD 镜像的代码每隔几个月才会更新。Ubuntu Core 系统在重启时会检查更新并进行自动更新（更新失败会回退）。
如果你想现在强制更新，你可以这样做：
```
stgraber@dakara:~$ lxc exec ubuntu-core bash
root@ubuntu-core:~# snap refresh
pc-kernel (stable) 4.4.0-53-1 from 'canonical' upgraded
core (stable) 16.04.1 from 'canonical' upgraded
root@ubuntu-core:~# snap version
snap 2.17
snapd 2.17
series 16
root@ubuntu-core:~#
```
然后重启一下 Ubuntu Core 系统，然后看看 snapd 的版本。
```
root@ubuntu-core:~# reboot
root@ubuntu-core:~#
stgraber@dakara:~$ lxc exec ubuntu-core bash
root@ubuntu-core:~# snap version
snap 2.21
snapd 2.21
series 16
root@ubuntu-core:~#
```
你也可以像下面这样查看所有 snapd 的历史记录：
```
stgraber@dakara:~$ lxc exec ubuntu-core snap changes
ID Status Spawn Ready Summary
1 Done 2017-01-31T05:14:38Z 2017-01-31T05:14:44Z Initialize system state
2 Done 2017-01-31T05:14:40Z 2017-01-31T05:14:45Z Initialize device
3 Done 2017-01-31T05:21:30Z 2017-01-31T05:22:45Z Refresh all snaps in the system
```
### 安装 Snap 软件包
以一个最简单的例子开始，经典的 Hello World：
```
stgraber@dakara:~$ lxc exec ubuntu-core bash
root@ubuntu-core:~# snap install hello-world
hello-world 6.3 from 'canonical' installed
root@ubuntu-core:~# hello-world
Hello World!
```
接下来让我们看一些更有用的：
```
stgraber@dakara:~$ lxc exec ubuntu-core bash
root@ubuntu-core:~# snap install nextcloud
nextcloud 11.0.1snap2 from 'nextcloud' installed
```
之后通过 HTTP 访问你的容器就可以看到刚才部署的 Nextcloud 实例。
如果你想直接通过 git 测试最新版 LXD，你可以这样做：
```
stgraber@dakara:~$ lxc config set ubuntu-core security.nesting true
stgraber@dakara:~$ lxc exec ubuntu-core bash
root@ubuntu-core:~# snap install lxd --edge
lxd (edge) git-c6006fb from 'canonical' installed
root@ubuntu-core:~# lxd init
Name of the storage backend to use (dir or zfs) [default=dir]:
We detected that you are running inside an unprivileged container.
This means that unless you manually configured your host otherwise,
you will not have enough uid and gid to allocate to your containers.
LXD can re-use your container's own allocation to avoid the problem.
Doing so makes your nested containers slightly less safe as they could
in theory attack their parent container and gain more privileges than
they otherwise would.
Would you like to have your containers share their parent's allocation (yes/no) [default=yes]?
Would you like LXD to be available over the network (yes/no) [default=no]?
Would you like stale cached images to be updated automatically (yes/no) [default=yes]?
Would you like to create a new network bridge (yes/no) [default=yes]?
What should the new bridge be called [default=lxdbr0]?
What IPv4 address should be used (CIDR subnet notation, “auto” or “none”) [default=auto]?
What IPv6 address should be used (CIDR subnet notation, “auto” or “none”) [default=auto]?
LXD has been successfully configured.
```
已经设置过的容器不能回退版本，但是可以在 Ubuntu Core 16 中运行另一个 Ubuntu Core 16 容器：
```
root@ubuntu-core:~# lxc launch images:ubuntu-core/16 nested-core
Creating nested-core
Starting nested-core
root@ubuntu-core:~# lxc list
+-------------+---------+---------------------+-----------------------------------------------+------------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+-------------+---------+---------------------+-----------------------------------------------+------------+-----------+
| nested-core | RUNNING | 10.71.135.21 (eth0) | fd42:2861:5aad:3842:216:3eff:feaf:e6bd (eth0) | PERSISTENT | 0 |
+-------------+---------+---------------------+-----------------------------------------------+------------+-----------+
```
### 写在最后
如果你只是想试用一下 Ubuntu Core，这是一个不错的方法。对于 snap 包开发者来说，这也是一个不错的工具来测试你的 snap 包能否在不同的环境下正常运行。
如果你希望你的系统总是最新的，并且整体可复制，Ubuntu Core 是一个很不错的方案，不过这也会带来一些相应的限制，所以可能不太适合你。
最后是一个警告，对于测试来说，这些镜像是足够的，但是当前并没有被正式的支持。在不久的将来，官方的 Ubuntu server 可以完整的支持 Ubuntu Core LXD 镜像。
### 附录
* LXD 主站：<https://linuxcontainers.org/lxd>
* Github：<https://github.com/lxc/lxd>
* 邮件列表：[https://lists.linuxcontainers.org](https://lists.linuxcontainers.org/)
* IRC：#lxcontainers on irc.freenode.net
* 在线试用：<https://linuxcontainers.org/lxd/try-it>
---
来自: <https://insights.ubuntu.com/2017/02/27/ubuntu-core-in-lxd-containers/>
作者：[Stéphane Graber](https://insights.ubuntu.com/author/stgraber/) 译者：[aiwhj](https://github.com/aiwhj) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
借助 minikube 上手 OpenFaaS
|
Alex Ellis
|
https://medium.com/@alexellisuk/getting-started-with-openfaas-on-minikube-634502c7acdf
|
本文将介绍如何借助 minikube 在 Kubernetes 1.8 上搭建 OpenFaaS（让 Serverless Function 变得更简单）。minikube 是一个 Kubernetes 分发版，借助它，你可以在笔记本电脑上运行 Kubernetes 集群，minikube 支持 Mac 和 Linux 操作系统，但是在 MacOS 上使用得更多一些。
|
/data/attachment/album/201711/23/163035naykmjmb00z8ugpo.png.thumb.jpg
|
/data/attachment/album/201711/23/163035naykmjmb00z8ugpo.png
| true
| false
| true
|
mandeler
| false
|
[
"容器",
"OpenFaaS",
"minikube",
"Serverless"
] |
容器与云
|
{
"viewnum": 8283,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文将介绍如何借助 minikube 在 Kubernetes 1.8 上搭建 OpenFaaS（让 Serverless Function 变得更简单）。minikube 是一个 Kubernetes 分发版，借助它，你可以在笔记本电脑上运行 Kubernetes 集群，minikube 支持 Mac 和 Linux 操作系统，但是在 MacOS 上使用得更多一些。
| 2017-11-23T16:31:00
| 2017-11-23T16:31:00
| 9,078
|
/article-9078-1.html
|
本文将介绍如何借助 [minikube](https://kubernetes.io/docs/getting-started-guides/minikube/) 在 Kubernetes 1.8 上搭建 OpenFaaS（让 Serverless Function 变得更简单）。minikube 是一个 [Kubernetes](https://kubernetes.io/) 分发版，借助它，你可以在笔记本电脑上运行 Kubernetes 集群，minikube 支持 Mac 和 Linux 操作系统，但是在 MacOS 上使用得更多一些。
>
> 本文基于我们最新的部署手册 [Kubernetes 官方部署指南](https://github.com/openfaas/faas/blob/master/guide/deployment_k8s.md)
>
>
>
### 安装部署 Minikube
1、 安装 [xhyve driver](https://git.k8s.io/minikube/docs/drivers.md#xhyve-driver) 或 [VirtualBox](https://www.virtualbox.org/wiki/Downloads) ，然后在上面安装 Linux 虚拟机以部署 minikube 。根据我的经验，VirtualBox 更稳定一些。
2、 [参照官方文档](https://kubernetes.io/docs/tasks/tools/install-minikube/) 安装 minikube 。
3、 使用 `brew` 或 `curl -sL cli.openfaas.com | sudo sh` 安装 `faas-cli`。
4、 通过 `brew install kubernetes-helm` 安装 `helm` 命令行。
5、 运行 minikube ：`minikube start`。
>
> Docker 船长小贴士：Mac 和 Windows 版本的 Docker 已经集成了对 Kubernetes 的支持。现在我们使用 Kubernetes 的时候，已经不需要再安装额外的软件了。
>
>
>
### 在 minikube 上面部署 OpenFaaS
1、 为 Helm 的服务器组件 tiller 新建服务账号：
```
kubectl -n kube-system create sa tiller \
&& kubectl create clusterrolebinding tiller \
--clusterrole cluster-admin \
--serviceaccount=kube-system:tiller
```
2、 安装 Helm 的服务端组件 tiller：
```
helm init --skip-refresh --upgrade --service-account tiller
```
3、 克隆 Kubernetes 的 OpenFaaS 驱动程序 faas-netes：
```
git clone https://github.com/openfaas/faas-netes && cd faas-netes
```
4、 Minikube 没有配置 RBAC，这里我们需要把 RBAC 关闭：
```
helm upgrade --install --debug --reset-values --set async=false --set rbac=false openfaas openfaas/
```
（LCTT 译注：RBAC（Role-Based access control）基于角色的访问权限控制，在计算机权限管理中较为常用，详情请参考以下链接：<https://en.wikipedia.org/wiki/Role-based_access_control> ）
现在，你可以看到 OpenFaaS pod 已经在你的 minikube 集群上运行起来了。输入 `kubectl get pods` 以查看 OpenFaaS pod：
```
NAME READY STATUS RESTARTS AGE
alertmanager-6dbdcddfc4-fjmrf 1/1 Running 0 1m
faas-netesd-7b5b7d9d4-h9ftx 1/1 Running 0 1m
gateway-965d6676d-7xcv9 1/1 Running 0 1m
prometheus-64f9844488-t2mvn 1/1 Running 0 1m
```
30,000ft：
该 API 网关包含了一个 [用于测试功能的最小化 UI](https://github.com/openfaas/faas/blob/master/TestDrive.md)，同时开放了用于功能管理的 [RESTful API](https://github.com/openfaas/faas/tree/master/api-docs) 。 faas-netesd 守护进程是一种 Kubernetes 控制器，用来连接 Kubernetes API 服务器来管理服务、部署和密码。
Prometheus 和 AlertManager 进程协同工作，实现 OpenFaaS Function 的弹性缩放，以满足业务需求。通过 Prometheus 指标我们可以查看系统的整体运行状态，还可以用来开发功能强悍的仪表盘。
Prometheus 仪表盘示例：
### 构建/迁移/运行
和很多其他的 FaaS 项目不同，OpenFaaS 使用 Docker 镜像格式来进行 Function 的创建和版本控制，这意味着可以在生产环境中使用 OpenFaaS 实现以下目标：
* 漏洞扫描（LCTT 译注：此处我觉得应该理解为更快地实现漏洞补丁）
* 持续集成/持续开发
* 滚动更新
你也可以在现有的生产环境集群中利用空闲资源部署 OpenFaaS。其核心服务组件内存占用大概在 10-30MB 。
>
> OpenFaaS 一个关键的优势在于，它可以使用容器编排平台的 API ，这样可以和 Kubernetes 以及 Docker Swarm 进行本地集成。同时，由于使用 Docker <ruby> 存储库 <rt> registry </rt></ruby>进行 Function 的版本控制，所以可以按需扩展 Function，而没有按需构建 Function 的框架的额外的延时。
>
>
>
### 新建 Function
```
faas-cli new --lang python hello
```
以上命令创建文件 `hello.yml` 以及文件夹 `handler`，文件夹有两个文件 `handler.py`、`requirements.txt` 可用于你可能需要的 pip 模块。你可以随时编辑这些文件和文件夹，不需要担心如何维护 Dockerfile —— 我们为你通过以下方式维护：
* 分级创建
* 非 root 用户
* 以官方的 Docker Alpine Linux 版本为基础进行镜像构建 (可替换)
### 构建你的 Function
先在本地创建 Function，然后推送到 Docker 存储库。 我们这里使用 Docker Hub，打开文件 `hello.yml` 然后输入你的账号名：
```
provider:
name: faas
gateway: http://localhost:8080
functions:
hello:
lang: python
handler: ./hello
image: alexellis2/hello
```
现在，发起构建。你的本地系统上需要安装 Docker 。
```
faas-cli build -f hello.yml
```
把封装好 Function 的 Docker 镜像版本推送到 Docker Hub。如果还没有登录 Docker hub ，继续前需要先输入命令 `docker login` 。
```
faas-cli push -f hello.yml
```
当系统中有多个 Function 的时候，可以使用 `--parallel=N` 来调用多核并行处理构建或推送任务。该命令也支持这些选项： `--no-cache`、`--squash` 。
### 部署及测试 Function
现在，可以部署、列出、调用 Function 了。每次调用 Function 时，可以通过 Prometheus 收集指标值。
```
$ export gw=http://$(minikube ip):31112
$ faas-cli deploy -f hello.yml --gateway $gw
Deploying: hello.
No existing function to remove
Deployed.
URL: http://192.168.99.100:31112/function/hello
```
上面给到的是部署时调用 Function 的标准方法，你也可以使用下面的命令：
```
$ echo test | faas-cli invoke hello --gateway $gw
```
现在可以通过以下命令列出部署好的 Function，你将看到调用计数器数值增加。
```
$ faas-cli list --gateway $gw
Function Invocations Replicas
hello 1 1
```
*提示：这条命令也可以加上 `--verbose` 选项获得更详细的信息。*
由于我们是在远端集群（Linux 虚拟机）上面运行 OpenFaaS，命令里面加上一条 `--gateway` 用来覆盖环境变量。 这个选项同样适用于云平台上的远程主机。除了加上这条选项以外，还可以通过编辑 .yml 文件里面的 `gateway` 值来达到同样的效果。
### 迁移到 minikube 以外的环境
一旦你在熟悉了在 minikube 上运行 OpenFaaS ，就可以在任意 Linux 主机上搭建 Kubernetes 集群来部署 OpenFaaS 了。
### 继续学习
我们的 Github 上面有很多手册和博文，可以带你轻松“上车”，把我们的页面保存成书签吧：[openfaas/faas](https://github.com/openfaas/faas/tree/master/guide) 。
2017 哥本哈根 Dockercon Moby 峰会上，我做了关于 Serverless 和 OpenFaaS 的概述演讲，这里我把视频放上来，视频不长，大概 15 分钟左右。
最后，别忘了关注 [OpenFaaS on Twitter](https://twitter.com/openfaas) 这里有最潮的新闻、最酷的技术和 Demo 展示。
---
via: <https://medium.com/@alexellisuk/getting-started-with-openfaas-on-minikube-634502c7acdf>
作者：[Alex Ellis](https://medium.com/@alexellisuk?source=post_header_lockup) 译者：[mandeler](https://github.com/mandeler) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 用户的手边工具：Guide to Linux
|
Jack Wallen
|
https://www.linux.com/learn/intro-to-linux/2017/8/guide-linux-app-handy-tool-every-level-linux-user
|
“Guide to Linux” 这个应用并不完美，但它是一个非常好的工具，可以帮助你学习 Linux 命令。
|
/data/attachment/album/201711/23/223543k8vaw6i2rfeafwy4.png.thumb.jpg
|
/data/attachment/album/201711/23/223543k8vaw6i2rfeafwy4.png
| true
| false
| true
|
qhwdw
| false
|
[
"Linux",
"手机应用"
] |
分享
|
{
"viewnum": 7710,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
“Guide to Linux” 这个应用并不完美，但它是一个非常好的工具，可以帮助你学习 Linux 命令。
| 2017-11-23T22:35:39
| 2017-11-23T22:35:39
| 9,079
|
/article-9079-1.html
|
>
> “Guide to Linux” 这个应用并不完美，但它是一个非常好的工具，可以帮助你学习 Linux 命令。
>
>
>
还记得你初次使用 Linux 时的情景吗？对于有些人来说，他的学习曲线可能有些挑战性。比如，在 `/usr/bin` 中能找到许多命令。在我目前使用的 Elementary OS 系统中，命令的数量是 1944 个。当然，这并不全是真实的命令（或者，我会使用到的命令数量），但这个数目是很多的。
正因为如此（并且不同平台不一样），现在，新用户（和一些已经熟悉的用户）需要一些帮助。
对于每个管理员来说，这些技能是必须具备的：
* 熟悉平台
* 理解命令
* 编写 Shell 脚本
当你寻求帮助时，有时，你需要去“阅读那些该死的手册”（Read the Fine/Freaking/Funky Manual，LCTT 译注：一个网络用语，简写为 RTFM），但是当你自己都不知道要找什么的时候，它就没办法帮到你了。在那个时候，你就会为你拥有像 [Guide to Linux](https://play.google.com/store/apps/details?id=com.essence.linuxcommands) 这样的手机应用而感到高兴。
不像你在 Linux.com 上看到的那些大多数的内容，这篇文章只是介绍一个 Android 应用的。为什么呢？因为这个特殊的 应用是用来帮助用户学习 Linux 的。
而且，它做的很好。
关于这个应用我清楚地告诉你 —— 它并不完美。Guide to Linux 里面充斥着很烂的英文，糟糕的标点符号，并且（如果你是一个纯粹主义者），它从来没有提到过 GNU。在这之上，它有一个特别的功能（通常它对用户非常有用）功能不是很有用（LCTT 译注：是指终端模拟器，后面会详细解释）。除此之外，我敢说 Guide to Linux 可能是 Linux 平台上最好的一个移动端的 “口袋指南”。
对于这个应用，你可能会喜欢它的如下特性：
* 离线使用
* Linux 教程
* 基础的和高级的 Linux 命令的详细介绍
* 包含了命令示例和语法
* 专用的 Shell 脚本模块
除此以外，Guide to Linux 是免费提供的（尽管里面有一些广告）。如果你想去除广告，它有一个应用内的购买，（$2.99 USD/年）可以去消除广告。
让我们来安装这个应用，来看一看它的构成。
### 安装
像所有的 Android 应用一样，安装 Guide to Linux 是非常简单的。按照以下简单的几步就可以安装它了：
1. 打开你的 Android 设备上的 Google Play 商店
2. 搜索 Guide to Linux
3. 找到 Essence Infotech 的那个，并轻触进入
4. 轻触 Install
5. 允许安装
安装完成后，你可以在你的<ruby> 应用抽屉 <rt> App Drawer </rt></ruby>或主屏幕上（或者两者都有）上找到它去启动 Guide to Linux 。轻触图标去启动这个应用。
### 使用
让我们看一下 Guide to Linux 的每个功能。我发现某些功能比其它的更有帮助，或许你的体验会不一样。在我们分别讲解之前，我将重点提到其界面。开发者在为这个应用创建一个易于使用的界面方面做的很好。
从主窗口中（图 1），你可以获取四个易于访问的功能。
*图 1： The Guide to Linux 主窗口。[已获授权](https://www.linux.com/licenses/category/used-permission)*
轻触四个图标中的任何一个去启动一个功能，然后，准备去学习。
### 教程
让我们从这个应用教程的最 “新手友好” 的功能开始。打开“Tutorial”功能，然后，将看到该教程的欢迎部分，“Linux 操作系统介绍”（图 2）。
*图 2：教程开始。[已获授权](https://www.linux.com/licenses/category/used-permission)*
如果你轻触 “汉堡包菜单” （左上角的三个横线），显示了内容列表（图 3），因此，你可以在教程中选择任何一个可用部分。
*图 3：教程的内容列表。[已获授权](https://www.linux.com/licenses/category/used-permission)*
如果你现在还没有注意到，Guide to Linux 教程部分是每个主题的一系列短文的集合。短文包含图片和链接（有时候），链接将带你到指定的 web 网站（根据主题的需要）。这里没有交互，仅仅只能阅读。但是，这是一个很好的起点，由于开发者在描述各个部分方面做的很好（虽然有语法问题）。
尽管你可以在窗口的顶部看到一个搜索选项，但是，我还是没有发现这一功能的任何效果 —— 但是，你可以试一下。
对于 Linux 新手来说，如果希望获得 Linux 管理的技能，你需要去阅读整个教程。完成之后，转到下一个主题。
### 命令
命令功能类似于手机上的 man 页面一样，是大量的频繁使用的 Linux 命令。当你首次打开它，欢迎页面将详细解释使用命令的益处。
读完之后，你可以轻触向右的箭头（在屏幕底部）或轻触 “汉堡包菜单” ，然后从侧边栏中选择你想去学习的其它命令。（图 4）
*图 4：命令侧边栏允许你去查看列出的命令。[已获授权](https://www.linux.com/licenses/category/used-permission)*
轻触任意一个命令，你可以阅读这个命令的解释。每个命令解释页面和它的选项都提供了怎么去使用的示例。
### Shell 脚本
在这个时候，你开始熟悉 Linux 了，并对命令已经有一定程序的掌握。现在，是时候去熟悉 shell 脚本了。这个部分的设置方式与教程部分和命令部分相同。
你可以打开内容列表的侧边栏，然后打开包含 shell 脚本教程的任意部分（图 5）。
*图 5：Shell 脚本节看上去很熟悉。[已获授权](https://www.linux.com/licenses/category/used-permission)*
开发者在解释如何最大限度地利用 shell 脚本方面做的很好。对于任何有兴趣学习 shell 脚本细节的人来说，这是个很好的起点。
### 终端
现在我们到了一个新的地方，开发者在这个应用中包含了一个终端模拟器。遗憾的是，当你在一个没有 “root” 权限的 Android 设备上安装这个应用时，你会发现你被限制在一个只读文件系统中，在那里，大部分命令根本无法工作。但是，我在一台 Pixel 2 （通过 Android 应用商店）安装的 Guide to Linux 中，可以使用更多的这个功能（还只是较少的一部分）。在一台 OnePlus 3 （非 root 过的）上，不管我改变到哪个目录，我都是得到相同的错误信息 “permission denied”，甚至是一个简单的命令也如此。
在 Chromebook 上，不管怎么操作，它都是正常的（图 6）。可以说，它可以一直很好地工作在一个只读操作系统中（因此，你不能用它进行真正的工作或创建新文件）。
*图 6： 可以完美地（可以这么说）用一个终端模拟器去工作。[已获授权](https://www.linux.com/licenses/category/used-permission)*
记住，这并不是真实的成熟终端，但却是一个新用户去熟悉终端是怎么工作的一种方法。遗憾的是，大多数用户只会发现自己对这个工具的终端功能感到沮丧，仅仅是因为，它们不能使用他们在其它部分学到的东西。开发者可能将这个终端功能打造成了一个 Linux 文件系统沙箱，因此，用户可以真实地使用它去学习。每次用户打开那个工具，它将恢复到原始状态。这只是我一个想法。
### 写在最后…
尽管终端功能被一个只读文件系统所限制（几乎到了没法使用的程序），Guide to Linux 仍然是一个新手学习 Linux 的好工具。在 guide to Linux 中，你将学习关于 Linux、命令、和 shell 脚本的很多知识，以便在你安装你的第一个发行版之前，让你学习 Linux 有一个好的起点。
---
via: <https://www.linux.com/learn/intro-to-linux/2017/8/guide-linux-app-handy-tool-every-level-linux-user>
作者：[JACK WALLEN](https://www.linux.com/users/jlwallen) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
放弃你的代码，而不是你的时间
|
William Gross
|
http://wgross.net/essays/give-away-your-code-but-never-your-time
|
我们需要的是一种新的行业规范，即项目领导者将总是能获得（其付出的）时间上的补偿。我们还需要抛弃的想法是， 任何提交问题或合并请求的开发人员都自动会得到维护者的注意。
|
/data/attachment/album/201711/24/070812nzvnszsdnnsp7plq.jpg.thumb.jpg
|
/data/attachment/album/201711/24/070812nzvnszsdnnsp7plq.jpg
| true
| false
| true
|
geekpi
| false
|
[
"开源软件"
] |
观点
|
{
"viewnum": 5093,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
我们需要的是一种新的行业规范，即项目领导者将总是能获得（其付出的）时间上的补偿。我们还需要抛弃的想法是， 任何提交问题或合并请求的开发人员都自动会得到维护者的注意。
| 2017-11-24T07:08:00
| 2017-11-24T07:08:00
| 9,080
|
/article-9080-1.html
|
作为软件开发人员，我认为我们可以认同开源代码<sup> 注1</sup> 已经[改变了世界](https://www.wired.com/insights/2013/07/in-a-world-without-open-source/)。它的公共性质去除了壁垒，可以让软件可以变的最好。但问题是，太多有价值的项目由于领导者的精力耗尽而停滞不前：
>
> “我没有时间和精力去投入开源了。我在开源上没有得到任何收入，所以我在那上面花的时间，我可以用在‘生活上的事’，或者写作上……正因为如此，我决定现在结束我所有的开源工作。”
>
>
> —— [Ryan Bigg，几个 Ruby 和 Elixir 项目的前任维护者](http://ryanbigg.com/2015/11/open-source-work)
>
>
>
>
> “这也是一个巨大的机会成本，由于我无法同时学习或者完成很多事情，FubuMVC 占用了我很多的时间，这是它现在必须停下来的主要原因。”
>
>
> —— [前 FubuMVC 项目负责人 Jeremy Miller](https://jeremydmiller.com/2014/04/03/im-throwing-in-the-towel-in-fubumvc/)
>
>
>
>
> “当我们决定要孩子的时候，我可能会放弃开源，我预计最终解决我问题的方案将是：核武器。”
>
>
> —— [Nolan Lawson，PouchDB 的维护者之一](https://nolanlawson.com/2017/03/05/what-it-feels-like-to-be-an-open-source-maintainer/)
>
>
>
我们需要的是一种新的行业规范，即项目领导者将*总是*能获得（其付出的）时间上的补偿。我们还需要抛弃的想法是， 任何提交问题或合并请求的开发人员都自动会得到维护者的注意。
我们先来回顾一下开源代码在市场上的作用。它是一个积木。它是[实用软件](https://martinfowler.com/bliki/UtilityVsStrategicDichotomy.html)，是企业为了在别处获利而必须承担的成本。如果用户能够理解该代码的用途并且发现它比替代方案（闭源专用、定制的内部解决方案等）更有价值，那么围绕该软件的社区就会不断增长。它可以更好，更便宜，或两者兼而有之。
如果一个组织需要改进该代码，他们可以自由地聘请任何他们想要的开发人员。通常情况下[为了他们的利益](https://tessel.io/blog/67472869771/monetizing-open-source)会将改进贡献给社区，因为由于代码合并的复杂性，这是他们能够轻松地从其他用户获得未来改进的唯一方式。这种“引力”倾向于把社区聚集在一起。
但是它也会加重项目维护者的负担，因为他们必须对这些改进做出反应。他们得到了什么回报？最好的情况是，这些社区贡献可能是他们将来可以使用的东西，但现在不是。最坏的情况下，这只不过是一个带着利他主义面具的自私请求罢了。
有一类开源项目避免了这个陷阱。Linux、MySQL、Android、Chromium 和 .NET Core 除了有名，有什么共同点么？他们都对一个或多个大型企业具有*战略性重要意义*，因为它们满足了这些利益。[聪明的公司商品化他们的商品](https://www.joelonsoftware.com/2002/06/12/strategy-letter-v/)，没有什么比开源软件便宜的商品了。红帽需要那些使用 Linux 的公司来销售企业级 Linux，Oracle 使用 MySQL 作为销售 MySQL Enterprise 的引子，谷歌希望世界上每个人都拥有电话和浏览器，而微软则试图将开发者锁定在平台上然后将它们拉入 Azure 云。这些项目全部由各自公司直接资助。
但是那些其他的项目呢，那些不是大玩家核心战略的项目呢？
如果你是其中一个项目的负责人，请向社区成员收取年费。*开放的源码，封闭的社区*。给用户的信息应该是“尽你所愿地使用代码，但如果你想影响项目的未来，请*为我们的时间支付*。”将非付费用户锁定在论坛和问题跟踪之外，并忽略他们的电子邮件。不支付的人应该觉得他们错过了派对。
还要向贡献者收取合并非普通的合并请求的时间花费。如果一个特定的提交不会立即给你带来好处，请为你的时间收取全价。要有原则并[记住 YAGNI](https://martinfowler.com/bliki/Yagni.html)。
这会导致一个极小的社区和更多的分支么？绝对。但是，如果你坚持不懈地构建自己的愿景，并为其他人创造价值，他们会尽快为要做的贡献而支付。*合并贡献的意愿是[稀缺资源](https://hbr.org/2010/11/column-to-win-create-whats-scarce)*。如果没有它，用户必须反复地将它们的变化与你发布的每个新版本进行协调。
如果你想在代码库中保持高水平的[概念完整性](http://wiki.c2.com/?ConceptualIntegrity)，那么限制社区是特别重要的。有[自由贡献政策](https://opensource.com/life/16/5/growing-contributor-base-modern-open-source)的无领导者项目没有必要收费。
为了实现更大的愿景，而不是单独为自己的业务支付成本，而是可能使其他人受益，去[众筹](https://poststatus.com/kickstarter-open-source-project/)吧。有许多成功的故事：
* [Font Awesome 5](https://www.kickstarter.com/projects/232193852/font-awesome-5)
* [Ruby enVironment Management (RVM)](https://www.bountysource.com/teams/rvm/fundraiser)
* [Django REST framework 3](https://www.kickstarter.com/projects/tomchristie/django-rest-framework-3)
[众筹有局限性](http://blog.felixbreuer.net/2013/04/24/crowdfunding-for-open-source.html)。它[不适合](https://www.indiegogo.com/projects/geary-a-beautiful-modern-open-source-email-client#/)[大型项目](http://www.itworld.com/article/2708360/open-source-tools/canonical-misses-smartphone-crowdfunding-goal-by--19-million.html)。但是，开源代码也是实用软件，它不需要雄心勃勃、冒险的破局者。它已经一点点地[渗透到每个行业](http://www.infoworld.com/article/2914643/open-source-software/rise-and-rise-of-open-source.html)。
这些观点代表着一条可持续发展的道路，也可以解决[开源的多样性问题](http://readwrite.com/2013/12/11/open-source-diversity/)，这可能源于其历史上无偿的性质。但最重要的是，我们要记住，[我们一生中只留下那么多的按键次数](http://keysleft.com/)，而且我们总有一天会后悔那些我们浪费的东西。
* 注 1 ：当我说“开源”时，我的意思是代码[许可](https://choosealicense.com/)以某种方式来构建专有的东西。这通常意味着一个宽松许可证（MIT 或 Apache 或 BSD），但并非总是如此。Linux 是当今科技行业的核心，但是是以 GPL 授权的。
感谢 Jason Haley、Don McNamara、Bryan Hogan 和 Nadia Eghbal 阅读了这篇文章的草稿。
---
via: <http://wgross.net/essays/give-away-your-code-but-never-your-time>
作者：[William Gross](http://wgross.net/#about-section) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Let's Encrypt ：2018 年 1 月发布通配证书
|
Josh Aas
|
https://letsencrypt.org/2017/07/06/wildcard-certificates-coming-jan-2018.html
|
通配证书是一个经常需要的功能，并且我们知道在一些情况下它可以使 HTTPS 部署更简单。我们希望提供通配证书有助于加速网络向 100％ HTTPS 进展。
|
/data/attachment/album/201711/24/133411nkhvk4abv5631q0a.jpg.thumb.jpg
|
/data/attachment/album/201711/24/133411nkhvk4abv5631q0a.jpg
| true
| false
| true
|
geekpi
| false
|
[
"HTTPS"
] |
新闻
|
{
"viewnum": 4547,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
通配证书是一个经常需要的功能，并且我们知道在一些情况下它可以使 HTTPS 部署更简单。我们希望提供通配证书有助于加速网络向 100％ HTTPS 进展。
| 2017-11-24T13:34:00
| 2017-11-24T13:34:00
| 9,082
|
/article-9082-1.html
|
Let’s Encrypt 将于 2018 年 1 月开始发放通配证书。通配证书是一个经常需要的功能，并且我们知道在一些情况下它可以使 HTTPS 部署更简单。我们希望提供通配证书有助于加速网络向 100％ HTTPS 进展。
Let’s Encrypt 目前通过我们的全自动 DV 证书颁发和管理 API 保护了 4700 万个域名。自从 Let's Encrypt 的服务于 2015 年 12 月发布以来，它已经将加密网页的数量从 40% 大大地提高到了 58%。如果你对通配证书的可用性以及我们达成 100% 的加密网页的使命感兴趣，我们请求你为我们的[夏季筹款活动](https://letsencrypt.org/donate/)（LCTT 译注：之前的夏季活动，原文发布于今年夏季）做出贡献。
通配符证书可以保护基本域的任何数量的子域名（例如 \*.example.com）。这使得管理员可以为一个域及其所有子域使用单个证书和密钥对，这可以使 HTTPS 部署更加容易。
通配符证书将通过我们[即将发布的 ACME v2 API 终端](https://letsencrypt.org/2017/06/14/acme-v2-api.html)免费提供。我们最初只支持通过 DNS 进行通配符证书的基础域验证，但是随着时间的推移可能会探索更多的验证方式。我们鼓励人们在我们的[社区论坛](https://community.letsencrypt.org/)上提出任何关于通配证书支持的问题。
我们决定在夏季筹款活动中宣布这一令人兴奋的进展，因为我们是一个非营利组织，这要感谢使用我们服务的社区的慷慨支持。如果你想支持一个更安全和保密的网络，[现在捐赠吧](https://letsencrypt.org/donate/)！
我们要感谢我们的[社区](https://letsencrypt.org/getinvolved/)和我们的[赞助者](https://letsencrypt.org/sponsors/)，使我们所做的一切成为可能。如果你的公司或组织能够赞助 Let's Encrypt，请发送电子邮件至 [sponsor@letsencrypt.org](mailto:sponsor@letsencrypt.org)。
---
via: <https://letsencrypt.org/2017/07/06/wildcard-certificates-coming-jan-2018.html>
作者：[Josh Aas](https://letsencrypt.org/2017/07/06/wildcard-certificates-coming-jan-2018.html) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 BorgBackup、Rclone 和 Wasabi 云存储推出自己的家庭备份解决方案
|
Christopher Aedo
|
https://opensource.com/article/17/10/backing-your-machines-borg
|
使用基于开源软件和廉价云存储的自动备份解决方案来保护你的数据。
|
/data/attachment/album/201711/25/082459kouk6k6b172mb4bb.jpeg.thumb.jpg
|
/data/attachment/album/201711/25/082459kouk6k6b172mb4bb.jpeg
| true
| false
| true
|
geekpi
| false
|
[
"备份"
] |
技术
|
{
"viewnum": 8662,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
使用基于开源软件和廉价云存储的自动备份解决方案来保护你的数据。
| 2017-11-25T08:26:06
| 2017-11-25T08:26:06
| 9,083
|
/article-9083-1.html
|
>
> 使用基于开源软件和廉价云存储的自动备份解决方案来保护你的数据。
>
>
>
几年来，我用 CrashPlan 来备份我家的电脑，包括属于我妻子和兄弟姐妹的电脑。CrashPlan 本质上是“永远在线”，不需要为它操心就可以做的规律性的备份，这真是太棒了。此外，能使用时间点恢复的能力多次派上用场。因为我通常是家庭的 IT 人员，所以我对其用户界面非常容易使用感到高兴，家人可以在没有我帮助的情况下恢复他们的数据。
最近 [CrashPlan 宣布](https://www.crashplan.com/en-us/consumer/nextsteps/)，它正在放弃其消费者订阅，专注于其企业客户。我想，这是有道理的，因为它不能从像我这样的人赚到很多钱，而我们的家庭计划在其系统上使用了大量的存储空间。
我决定，我需要一个合适的替代功能，包括：
* 跨平台支持 Linux 和 Mac
* 自动化（所以没有必要记得点击“备份”）
* 时间点恢复（可以关闭），所以如果你不小心删除了一个文件，但直到后来才注意到，它仍然可以恢复
* 低成本
* 备份有多份存储，这样数据存在于多个地方（即，不仅仅是备份到本地 USB 驱动器上）
* 加密以防备份文件落入坏人手中
我四处搜寻，问我的朋友有关类似于 CrashPlan 的服务。我对其中一个 [Arq](https://www.arqbackup.com/) 非常满意，但没有 Linux 支持意味着对我没用。[Carbonite](https://www.carbonite.com/) 与 CrashPlan 类似，但会很昂贵，因为我有多台机器需要备份。[Backblaze](https://www.backblaze.com/) 以优惠的价格（每月 5 美金）提供无限备份，但其备份客户端不支持 Linux。[BackupPC](http://backuppc.sourceforge.net/BackupPCServerStatus.html) 是一个强有力的竞争者，但在我想起它之前，我已经开始测试我的解决方案了。我看到的其它选项都不符合我要的一切。这意味着我必须找出一种方法来复制 CrashPlan 为我和我的家人提供的服务。
我知道在 Linux 系统上备份文件有很多好的选择。事实上，我一直在使用 [rdiff-backup](http://www.nongnu.org/rdiff-backup/) 至少 10 年了，通常用于本地保存远程文件系统的快照。我希望能够找到可以去除备份数据中重复部分的工具，因为我知道有些（如音乐库和照片）会存储在多台计算机上。
我认为我所做的工作非常接近实现我的目标。
### 我的备份解决方案
最终，我的目标落在 [BorgBackup](https://www.borgbackup.org/)、[Rclone](https://rclone.org/) 和 [Wasabi 云存储](https://wasabi.com/)的组合上，我的决定让我感到无比快乐。Borg 符合我所有的标准，并有一个非常健康的[用户和贡献者社区](https://github.com/borgbackup/borg/)。它提供重复数据删除和压缩功能，并且在 PC、Mac 和 Linux 上运行良好。我使用 Rclone 将来自 Borg 主机的备份仓库同步到 Wasabi 上的 S3 兼容存储。任何与 S3 兼容的存储都可以工作，但是我选择了 Wasabi，因为它的价格好，而且它的性能超过了亚马逊的 S3。使用此设置，我可以从本地 Borg 主机或从 Wasabi 恢复文件。
在我的机器上安装 Borg 只要 `sudo apt install borgbackup`。我的备份主机是一台连接有 1.5TB USB 驱动器的 Linux 机器。如果你没有可用的机器，那么备份主机可以像 Raspberry Pi 一样轻巧。只要确保所有的客户端机器都可以通过 SSH 访问这个服务器，那么你就能用了。
在备份主机上，使用以下命令初始化新的备份仓库：
```
$ borg init /mnt/backup/repo1
```
根据你要备份的内容，你可能会选择在每台计算机上创建多个仓库，或者为所有计算机创建一个大型仓库。由于 Borg 有重复数据删除功能，如果在多台计算机上有相同的数据，那么从所有这些计算机向同一个仓库发送备份可能是有意义的。
在 Linux 上安装 Borg 非常简单。在 Mac OS X 上，我需要首先安装 XCode 和 Homebrew。我遵循 [how-to](http://osxdaily.com/2014/02/12/install-command-line-tools-mac-os-x/) 来安装命令行工具，然后使用 `pip3 install borgbackup`。
### 备份
每台机器都有一个 `backup.sh` 脚本（见下文），由 cron 任务定期启动。它每天只做一个备份集，但在同一天尝试几次也没有什么不好的。笔记本电脑每隔两个小时就会尝试备份一次，因为不能保证它们在某个特定的时间开启，但很可能在其中一个时间开启。这可以通过编写一个始终运行的守护进程来改进，并在笔记本电脑唤醒时触发备份尝试。但现在，我对它的运作方式感到满意。
我可以跳过 cron 任务，并为每个用户提供一个相对简单的方法来使用 [BorgWeb](https://github.com/borgbackup/borgweb) 来触发备份，但是我真的不希望任何人必须记得备份。我倾向于忘记点击那个备份按钮，直到我急需修复（这时太迟了！）。
我使用的备份脚本来自 Borg 的[快速入门](https://borgbackup.readthedocs.io/en/stable/quickstart.html)文档，另外我在顶部添加了一些检查，看 Borg 是否已经在运行，如果之前的备份运行仍在进行这个脚本就会退出。这个脚本会创建一个新的备份集，并用主机名和当前日期来标记它。然后用简单的保留计划来整理旧的备份集。
这是我的 `backup.sh` 脚本：
```
#!/bin/sh
REPOSITORY=borg@borgserver:/mnt/backup/repo1
#Bail if borg is already running, maybe previous run didn't finish
if pidof -x borg >/dev/null; then
echo "Backup already running"
exit
fi
# Setting this, so you won't be asked for your repository passphrase:
export BORG_PASSPHRASE='thisisnotreallymypassphrase'
# or this to ask an external program to supply the passphrase:
export BORG_PASSCOMMAND='pass show backup'
# Backup all of /home and /var/www except a few
# excluded directories
borg create -v --stats \
$REPOSITORY::'{hostname}-{now:%Y-%m-%d}' \
/home/doc \
--exclude '/home/doc/.cache' \
--exclude '/home/doc/.minikube' \
--exclude '/home/doc/Downloads' \
--exclude '/home/doc/Videos' \
--exclude '/home/doc/Music' \
# Use the `prune` subcommand to maintain 7 daily, 4 weekly and 6 monthly
# archives of THIS machine. The '{hostname}-' prefix is very important to
# limit prune's operation to this machine's archives and not apply to
# other machine's archives also.
borg prune -v --list $REPOSITORY --prefix '{hostname}-' \
--keep-daily=7 --keep-weekly=4 --keep-monthly=6
```
备份的输出如下所示：
```
------------------------------------------------------------------------------
Archive name: x250-2017-10-05
Archive fingerprint: xxxxxxxxxxxxxxxxxxx
Time (start): Thu, 2017-10-05 03:09:03
Time (end): Thu, 2017-10-05 03:12:11
Duration: 3 minutes 8.12 seconds
Number of files: 171150
------------------------------------------------------------------------------
Original size Compressed size Deduplicated size
This archive: 27.75 GB 27.76 GB 323.76 MB
All archives: 3.08 TB 3.08 TB 262.76 GB
Unique chunks Total chunks
Chunk index: 1682989 24007828
------------------------------------------------------------------------------
[...]
Keeping archive: x250-2017-09-17 Sun, 2017-09-17 03:09:02
Pruning archive: x250-2017-09-28 Thu, 2017-09-28 03:09:02
```
我在将所有的机器备份到主机上后，我遵循[安装预编译的 Rclone 二进制文件指导](https://rclone.org/install/)，并将其设置为访问我的 Wasabi 帐户。
此脚本每天晚上运行以将任何更改同步到备份集：
```
#!/bin/bash
set -e
repos=( repo1 repo2 repo3 )
#Bail if rclone is already running, maybe previous run didn't finish
if pidof -x rclone >/dev/null; then
echo "Process already running"
exit
fi
for i in "${repos[@]}"
do
#Lets see how much space is used by directory to back up
#if directory is gone, or has gotten small, we will exit
space=`du -s /mnt/backup/$i|awk '{print $1}'`
if (( $space < 34500000 )); then
echo "EXITING - not enough space used in $i"
exit
fi
/usr/bin/rclone -v sync /mnt/backup/$i wasabi:$i >> /home/borg/wasabi-sync.log 2>&1
done
```
第一次用 Rclone 同步备份集到 Wasabi 花了好几天，但是我大约有 400GB 的新数据，而且我的出站连接速度不是很快。但是每日的增量是非常小的，能在几分钟内完成。
### 恢复文件
恢复文件并不像 CrashPlan 那样容易，但是相对简单。最快的方法是从存储在 Borg 备份服务器上的备份中恢复。以下是一些用于恢复的示例命令：
```
#List which backup sets are in the repo
$ borg list borg@borgserver:/mnt/backup/repo1
Remote: Authenticated with partial success.
Enter passphrase for key ssh://borg@borgserver/mnt/backup/repo1:
x250-2017-09-17 Sun, 2017-09-17 03:09:02
#List contents of a backup set
$ borg list borg@borgserver:/mnt/backup/repo1::x250-2017-09-17 | less
#Restore one file from the repo
$ borg extract borg@borgserver:/mnt/backup/repo1::x250-2017-09-17 home/doc/somefile.jpg
#Restore a whole directory
$ borg extract borg@borgserver:/mnt/backup/repo1::x250-2017-09-17 home/doc
```
如果本地的 Borg 服务器或拥有所有备份仓库的 USB 驱动器发生问题，我也可以直接从 Wasabi 直接恢复。如果机器安装了 Rclone，使用 [rclone mount](https://rclone.org/commands/rclone_mount/)，我可以将远程存储仓库挂载到本地文件系统：
```
#Mount the S3 store and run in the background
$ rclone mount wasabi:repo1 /mnt/repo1 &
#List archive contents
$ borg list /mnt/repo1
#Extract a file
$ borg extract /mnt/repo1::x250-2017-09-17 home/doc/somefile.jpg
```
### 它工作得怎样
现在我已经使用了这个备份方法几个星期了，我可以说我真的很高兴。设置所有这些并使其运行当然比安装 CrashPlan 要复杂得多，但这就是使用你自己的解决方案和使用服务之间的区别。我将不得不密切关注以确保备份继续运行，数据与 Wasabi 正确同步。
但是，总的来说，以一个非常合理的价格替换 CrashPlan 以提供相似的备份覆盖率，结果比我预期的要容易一些。如果你看到有待改进的空间，请告诉我。
*这最初发表在 [Local Conspiracy](http://localconspiracy.com/2017/10/backup-everything.html)，并被许可转载。*
---
作者简介：
Christopher Aedo - Christopher Aedo 自从大学时开始就一直在用开源软件工作并为之作出贡献。最近他在领导一支非常棒的 IBM 上游开发团队，他们也是开发支持者。当他不在工作或在会议上发言时，他可能在俄勒冈州波特兰市使用 RaspberryPi 酿造和发酵美味的自制啤酒。
---
via: <https://opensource.com/article/17/10/backing-your-machines-borg>
作者：[Christopher Aedo](https://opensource.com/users/docaedo) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何以翻译贡献参与开源社区
|
老王
|
2017 中国开源年会 - COSCon'17 于 11 月 18 - 19 日在上海交大闵行校区圆满收官。在本次大会上，我发表了题为《如何以翻译贡献参与开源社区——LCTT 这几年》的演讲。
|
/data/attachment/album/201711/25/104856gn5jjjtkjs3mj2jf.jpg.thumb.jpg
|
/data/attachment/album/201711/25/104856gn5jjjtkjs3mj2jf.jpg
| true
| false
| false
| true
|
[
"LCTT"
] |
观点
|
{
"viewnum": 7445,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 8670,
"displayorder": 0
}
] |
2017 中国开源年会 - COSCon'17 于 11 月 18 - 19 日在上海交大闵行校区圆满收官。在本次大会上，我发表了题为《如何以翻译贡献参与开源社区——LCTT 这几年》的演讲。
| 2017-11-25T11:44:00
| 2017-11-25T11:44:00
| 9,084
|
/article-9084-1.html
|
[2017 中国开源年会 - COSCon'17](http://www.kaiyuanshe.cn/dynamic/217.html) 于 11 月 18 - 19 日在上海交大闵行校区圆满收官。老王应邀代表 “Linux 中国” 参加了本次盛会。
这次大会总共 1,108 人次到场，在线视频观众总计 2,284 人，参加了接近 60 位大牛讲师的 5 场主题演讲，45 场分会场演讲，6 场动手训练营，5 场嘉宾对谈/观众问答，而来自五湖四海的 50 位可爱的志愿者们，热情地为讲师与观众们服务。
在本次大会上，我发表了题为《[如何以翻译贡献参与开源社区——LCTT 这几年](https://img.linux.net.cn/static/pdf/%E5%A6%82%E4%BD%95%E4%BB%A5%E7%BF%BB%E8%AF%91%E8%B4%A1%E7%8C%AE%E5%8F%82%E4%B8%8E%E5%BC%80%E6%BA%90%E7%A4%BE%E5%8C%BA.pdf)》的演讲，就 Linux 中国旗下的志愿者翻译组 LCTT 情况向大家做了介绍，将这几年来的辛酸苦辣、感恩感怀向开源小伙伴们做了倾诉；并就 LCTT 目前的情况和存在的问题，以及下一步的展望做了分析和计划。在本次演讲中，得到诸多关注志愿者翻译活动的社区积极分子的支持，并与其它翻译组织也有了初步合作的沟通。最后，在本次演讲中，我还宣布了重启 LCTT 的 man 翻译计划！
以下内容，摘录自本次演讲，完整的演讲文稿，可[从此下载](https://img.linux.net.cn/static/pdf/%E5%A6%82%E4%BD%95%E4%BB%A5%E7%BF%BB%E8%AF%91%E8%B4%A1%E7%8C%AE%E5%8F%82%E4%B8%8E%E5%BC%80%E6%BA%90%E7%A4%BE%E5%8C%BA.pdf)（PDF，3.1 Mb），版式与实际演讲稿有所不同。
演讲内容分为两大部分，分别面向贡献者个人的和面向社区组织者。
### 面向贡献者谈翻译贡献
首先，谈及为什么要为开源社区做贡献，这是提升自己的一个有益途径：
而且，翻译活动也适合于初入开源社区的同学了解开源和在开源社区中获得进步：
那么，如何参与开源贡献呢？参与的方式有很多，这里从下向上，由易而难依次列出了几个参与的主要方式——而其中所提到的“翻译”就是我本次演讲的主题。
为什么说“参与翻译”是一个比较适合开源贡献者入门的方式呢？是因为：
而且，参与开源社区的翻译活动，要求并不高：
当然，这也是需要你做出一点努力和学习的。
在谈完开源志愿者以翻译贡献参与开源活动之后，我介绍了 LCTT 这几年的发展情况。
### LCTT 之路
LCTT 缘起于我对糟糕的 man 文档的中文化翻译的不满：
而这四年来，我们已经取得了令人瞩目的成果：
也涌现出了像 [geekpi](https://linux.cn/lctt/geekpi)、[oska874](https://linux.cn/lctt/oska874) 这样卓越的贡献者：
正是这两百多位贡献者，才成就了 LCTT 这几年来成绩。在外出参加社区交流时，我不止一次地听到别人对我表扬 LCTT 翻译的文章不错，这是让我感到最荣耀的事情，是对我们 LCTT 最大的肯定。
然后，我立下了本次演讲中的 flag，我将重启 man 翻译计划。
### 中文 man 翻译计划——我的执念
man 翻译计划殇于我们的经验不足和对困难的认识不够：
对此，我们进行了一些反思总结：
历史上，man 中文翻译活动沉沉浮浮，但是一直没有取得像样的成功。
所以，我觉得，对于这样一件有意义的事情，不应该只是心里的念想，而应该切实做出来。希望大家支持我们，参与我们，让我们将这件利在千秋的事情做好。
立下这个目标之后，那么想参与的同学该怎么进入呢？我介绍了加入 LCTT 的方式：
### 如何加入 LCTT
加入 [LCTT](https://linux.cn/lctt/) 并参与到 LCTT 的贡献活动当中，其实很简单，重要的是，你的意愿。你只需要加入我们的专属 QQ 群： **198889102**，验证信息输入“志愿者”，即可加入 LCTT 大家庭。成为了一个 LCTT 人，你不但可以为开源社区做出贡献，而且你还会有自己的专页来展示你的成就。
我也简单介绍了 LCTT 的贡献流程：
后面还谈及了一些我们总结的翻译技巧，这里就不写了，大家可以看完整演讲稿了解，也可以和 LCTT 成员在群内沟通。
然后，面向开源社区组织者谈了一下我们组织和运营 LCTT 几年来的经验心得，希望可以给其它开源社区一些有益的参考。
### 开源社区如何组织翻译活动
作为志愿者翻译组织，首先要做的就是招募愿意参与的志愿者：
其实，我们这次演讲，也是具有一定的招募意义的。
有了参与者之外，就要拟定和执行一个翻译流程：
并建立激励机制：
以及，到了一定规模之后，就应该考虑建立一个翻译工作平台来规范流程和降低参与难度，这也是我们 LCTT 目前亟待进行的工作：
并且，我们自我反思，在 LCTT 的运营中，也存在一些不足。不怕自曝其丑，这些地方也希望可以给大家一些启示：
最后，结束演讲之前，我还大致谈了谈我的开源社区观，具体内容不在此处赘述，大家可以参考我以前写的一篇文章：《[如何参与和帮助「Linux 中国」开源社区的发展](/article-8670-1.html)》
### 总结
这次参与[开源社](http://www.kaiyuanshe.cn/)主办的 “[2017 中国开源年会 - COSCon'17](http://www.kaiyuanshe.cn/dynamic/217.html)”，我见到了许多朋友，有之前闻名已久的新朋友，也有已经熟悉的老朋友。而且，大家的很多分享，都是干货满满——这一点并不是我为朋友们吹嘘，确实，作为开源社区活动人士，很多演讲都让我很有共鸣，也很有启发。
感谢开源社做出的贡献！
|
||||
5 款最酷的 Linux 终端模拟器
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2017/11/5-coolest-linux-terminal-emulators
|
虽然，我们可以继续使用老旧的 GNOME 终端、Konsole，以及好笑而孱弱的旧式 xterm。 不过，让我们带着尝试某种新东西的心境，回过头来看看 5 款酷炫并且实用的 Linux 终端。
|
/data/attachment/album/201711/26/224140mmrcqn8fgmmzkvgv.jpg.thumb.jpg
|
/data/attachment/album/201711/26/224140mmrcqn8fgmmzkvgv.jpg
| true
| false
| true
|
cnobelw
| false
|
[
"终端"
] |
技术
|
{
"viewnum": 39481,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
虽然，我们可以继续使用老旧的 GNOME 终端、Konsole，以及好笑而孱弱的旧式 xterm。 不过，让我们带着尝试某种新东西的心境，回过头来看看 5 款酷炫并且实用的 Linux 终端。
| 2017-11-26T22:32:00
| 2017-11-26T22:32:00
| 9,085
|
/article-9085-1.html
|
>
> Carla Schroder 正在看着那些她喜欢的终端模拟器， 包括展示在这儿的 Cool Retro Term。
>
>
>
虽然，我们可以继续使用老旧的 GNOME 终端、Konsole，以及好笑而孱弱的旧式 xterm。 不过，让我们带着尝试某种新东西的心境，回过头来看看 5 款酷炫并且实用的 Linux 终端。
### Xiki
首先我要推荐的第一个终端是 [Xiki](http://xiki.org/)。 Xiki 是 Craig Muth 的智慧结晶，他是一个天才程序员，也是一个有趣的人（有趣在此处的意思是幽默，可能还有其它的意思）。 很久以前我在 [遇见 Xiki，Linux 和 Mac OS X 下革命性命令行 Shell](https://www.linux.com/learn/meet-xiki-revolutionary-command-shell-linux-and-mac-os-x) 一文中介绍过 Xiki。 Xiki 不仅仅是又一款终端模拟器；它也是一个扩展命令行用途、加快命令行速度的交互式环境。
Xiki 支持鼠标，并且在绝大多数命令行 Shell 上都支持。 它有大量的屏显帮助，而且可以使用鼠标和键盘快速导航。 它体现在速度上的一个简单例子就是增强了 `ls` 命令。 Xiki 可以快速穿过文件系统上的多层目录，而不用持续的重复输入 `ls` 或者 `cd`， 或者利用那些巧妙的正则表达式。
Xiki 可以与许多文本编辑器相集成， 提供了一个永久的便签， 有一个快速搜索引擎， 同时像他们所说的，还有许许多多的功能。 Xiki 是如此的有特色、如此的不同， 所以学习和了解它的最快的方式可以看 [Craig 的有趣和实用的视频](http://xiki.org/screencasts/)。
### Cool Retro Term
我推荐 [Cool Retro Term](https://github.com/Swordfish90/cool-retro-term) （如题图显示） 主要因为它的外观，以及它的实用性。 它将我们带回了阴极射线管显示器的时代，这不算很久以前，而我也没有怀旧的意思，我死也不会放弃我的 LCD 屏幕。它基于 [Konsole](https://www.linux.com/learn/expert-tips-and-tricks-kate-and-konsole)， 因此有着 Konsole 的优秀功能。可以通过 Cool Retro Term 的配置文件菜单来改变它的外观。配置文件包括 Amber、Green、Pixelated、Apple 和 Transparent Green 等等，而且全都包括一个像真的一样的扫描线。并不是全都是有用的，例如 Vintage 配置文件看起来就像一个闪烁着的老旧的球面屏。
Cool Retro Term 的 GitHub 仓库有着详细的安装指南，且 Ubuntu 用户有 [PPA](https://launchpad.net/%7Ebugs-launchpad-net-falkensweb/+archive/ubuntu/cool-retro-term)。
### Sakura
你要是想要一个优秀的轻量级、易配置的终端，可以尝试下 [Sakura](https://bugs.launchpad.net/sakura)（图 1）。 它依赖少，不像 GNOME 终端 和 Konsole，在 GNOME 和 KDE 中牵扯了很多组件。其大多数选项是可以通过右键菜单配置的，例如选项卡的标签、 颜色、大小、选项卡的默认数量、字体、铃声，以及光标类型。 你可以在你个人的配置文件 `~/.config/sakura/sakura.conf` 里面设置更多的选项，例如绑定快捷键。
*图 1： Sakura 是一个优秀的、轻量级的、可配置的终端。*
命令行选项详见 `man sakura`。可以使用这些来从命令行启动 sakura，或者在你的图形启动器上使用它们。 例如，打开 4 个选项卡并设置窗口标题为 “MyWindowTitle”：
```
$ sakura -t MyWindowTitle -n 4
```
### Terminology
[Terminology](https://www.enlightenment.org/about-terminology) 来自 Enlightenment 图形环境的郁葱可爱的世界，它能够被美化成任何你所想要的样子 (图 2)。 它有许多有用的功能：独立的拆分窗口、打开文件和 URL、文件图标、选项卡，林林总总。 它甚至能运行在没有图形界面的 Linux 控制台上。
*图 2: Terminology 也能够运行在没有图形界面的 Linux 控制台上。*
当你打开多个拆分窗口时，每个窗口都能设置不同的背景，并且背景文件可以是任意媒体文件：图像文件、视频或者音乐文件。它带有一堆便于清晰可读的暗色主题和透明主题，它甚至一个 Nyan 猫主题。它没有滚动条，因此需要使用组合键 `Shift+PageUp` 和 `Shift+PageDown` 进行上下导航。
它有多个控件：一个右键单击菜单，上下文对话框，以及命令行选项。右键单击菜单里包含世界上最小的字体，且 Miniview 可显示一个微观的文件树，但我没有找到可以使它们易于辨读的选项。当你打开多个标签时，可以点击小标签浏览器来打开一个可以上下滚动的选择器。任何东西都是可配置的；通过 `man terminology` 可以查看一系列的命令和选项，包括一批不错的快捷键快捷方式。奇怪的是，帮助里面没有包括以下命令，这是我偶然发现的：
* tyalpha
* tybg
* tycat
* tyls
* typop
* tyq
使用 `tybg [filename]` 命令来设置背景，不带参数的 `tybg` 命令来移除背景。 运行 `typop [filename]` 来打开文件。 `tyls` 命令以图标视图列出文件。 加上 `-h` 选项运行这些命令可以了解它们是干什么的。 即使有可读性的怪癖，Terminology 依然是快速、漂亮和实用的。
### Tilda
已经有几个优秀的下拉式终端模拟器，包括 Guake 和 Yakuake。 [Tilda](https://github.com/lanoxx/tilda) (图 3) 是其中最简单和轻量级的一个。 打开 Tilda 后它会保持打开状态， 你可以通过快捷键来显示和隐藏它。 Tilda 快捷键是默认设置的， 你可以设置自己喜欢的快捷键。 它一直打开着的，随时准备工作，但是直到你需要它的时候才会出现。
*图 3: Tilda 是最简单和轻量级的一个终端模拟器。*
Tilda 选项方面有很好的补充，包括默认的大小、位置、外观、绑定键、搜索条、鼠标动作，以及标签条。 这些都被右键单击菜单控制。
*学习更多关于 Linux 的知识可以通过 Linux 基金会 和 edX 的免费课程 ["Linux 介绍"](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 。*
---
via: <https://www.linux.com/learn/intro-to-linux/2017/11/5-coolest-linux-terminal-emulators>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 译者：[cnobelw](https://github.com/cnobelw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
我们为国内的逆向工程师做了一件事！
|
老王
|
https://detail.youzan.com/show/goods?alias=3nffgxtvcasmt&from=wxd&kdtfrom=wxd&type=share_goods&share=wxd_frd&mtd=sh_frd_wxd
|
对于软件逆向工程这门手艺来说，最难的便是入门。软件逆向不同于软件的编写。基于汇编语言的软件逆向将绝大多数的人拦在了门外。少部分人打开了这扇门，又为门后的贫瘠所震惊 —— 相关资料少且不系统。
|
/data/attachment/album/201711/27/175032a8wjwm5wbvmjoddd.jpg.thumb.jpg
|
/data/attachment/album/201711/27/175032a8wjwm5wbvmjoddd.jpg
| true
| false
| false
| false
|
[
"安全",
"二进制分析"
] |
新闻
|
{
"viewnum": 10129,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "220.181.38.111",
"message": "如果发现书的翻译有问题，可以到异步社区 http://www.epubit.com.cn/book/details/4696 提交勘误",
"username": "sonofelice [Chrome 62.0|Mac 10.13]",
"date": "2017-11-27T19:33:44"
},
{
"postip": "111.204.176.147",
"message": "微信过期了 加作者不回",
"username": "来自北京的 Firefox 66.0|Mac 10.10 用户",
"date": "2019-01-15T12:52:41"
},
{
"postip": "111.204.176.147",
"message": "微信过期了 加作者不回",
"username": "来自北京的 Firefox 66.0|Mac 10.10 用户",
"date": "2019-01-15T12:52:42"
}
] |
[] |
对于软件逆向工程这门手艺来说，最难的便是入门。软件逆向不同于软件的编写。基于汇编语言的软件逆向将绝大多数的人拦在了门外。少部分人打开了这扇门，又为门后的贫瘠所震惊 —— 相关资料少且不系统。
| 2017-11-27T18:23:00
| 2017-11-27T18:23:00
| 9,087
|
/article-9087-1.html
|
>
> 拿到这本《Linux 二进制分析》，我不禁心生感慨。
>
>
>
对于软件逆向工程这门手艺来说，最难的便是入门。软件逆向不同于软件的编写。基于汇编语言的软件逆向将绝大多数的人拦在了门外。少部分人打开了这扇门，又为门后的贫瘠所震惊 —— 相关资料少且不系统。
一直以来， Windows 由于其在桌面端的广泛应用而不断受人关注，相关的书籍也不断出新。但随着移动端设备的逐渐崛起，\*nix 系统占据了市场的主流。但是基于 \*nix 的逆向开发一直都处在荒芜的状态，为少数人所掌握。现在，移动端设备成为新的安全隐患增长点，我们也为此忧心忡忡。于是，我们组织译者，翻译了这本<ruby> <a href="https://detail.youzan.com/show/goods?alias=3nffgxtvcasmt&from=wxd&kdtfrom=wxd&type=share_goods&share=wxd_frd&mtd=sh_frd_wxd"> 《Linux 二进制分析》 </a> <rp> （ </rp> <rt> Learning Linux Binary Analysis </rt> <rp> ） </rp></ruby> 。
### 1、LCTT 的新台阶
《[Linux 二进制分析](https://detail.youzan.com/show/goods?alias=3nffgxtvcasmt&from=wxd&kdtfrom=wxd&type=share_goods&share=wxd_frd&mtd=sh_frd_wxd)》是棣琦的译作，也是我们 Linux 中国审校的第一本书。在我看来，这是 Linux 中国 [LCTT 翻译组](https://linux.cn/lctt/)的一个新的里程碑。
自 2013 年 9 月 LCTT 创立以来，已有 250 余位志愿者参与到我们的翻译组，累计翻译了近三千篇各种 Linux 相关的文章。但是直到这本《[Linux 二进制分析](https://detail.youzan.com/show/goods?alias=3nffgxtvcasmt&from=wxd&kdtfrom=wxd&type=share_goods&share=wxd_frd&mtd=sh_frd_wxd)》的出版，我们 LCTT 第一次真正意义上完成了一本书的翻译、校对、审核的工作。我们的工作上了一个新的台阶。
### 2、作者简介
Ryan O‘Neill，是一名在逆向工程、软件开发、安全防御和取证分析技术方面深有建树的计算机安全专家，曾就职于 Pikewerks、Leviathan 安全集团，最近在 Backtrace 担任软件工程师。
除了这本书以外，他之前还写了大量相关的论文，比如 “Modern day ELF Runtime infection via GlobalOffsetTable poisoning”、“Extending the ELF core file format for forensics snapshots”。丰富的经历和研究，使他在 ELF 二进制研究上有着超出前人的成就，这些成就，最终促成了这本《[Linux 二进制分析](https://detail.youzan.com/show/goods?alias=3nffgxtvcasmt&from=wxd&kdtfrom=wxd&type=share_goods&share=wxd_frd&mtd=sh_frd_wxd)》的出版。
### 3、译者简介
[棣琦](http://www.epubit.com.cn/space/book/41539)，本名张萌萌，是一个集美貌与智慧并存的程序媛。目前是百度研发工程师， 业余时间爱好翻译。当别人周末约会、逛街时，她选择了开启一段艰辛的翻译之旅，焚膏继晷大半年，一字一句的翻译、一行一行的校对。
《[Linux 二进制分析](https://detail.youzan.com/show/goods?alias=3nffgxtvcasmt&from=wxd&kdtfrom=wxd&type=share_goods&share=wxd_frd&mtd=sh_frd_wxd)》不同于其他 Linux 技术书籍，国内和 Linux 二进制分析相关的图书、资 料十分的少，远不如其他方面的资料那般充盈，对于她来说，除了要对文章进行翻译，还要通读国内外的相关文献，以保证译文的翔实和准确。
此外，由于这本书内包含了大量的实战操作内容，她也需要花费大量的时间进行重复操作、验证，以确保书的内容可以被读者重新实践。
### 4、内容分享
这本书的内容详实，可以帮助读者快速建立起 Linux 二进制分析的整体框架，并且使用了大量的篇幅来介绍 ELF 文件格式，为读者打下良好的基础；并通过取自工作中不同场景下二进制分析的实战来帮助读者明晰二进制分析的重要性和效果，一方面可以让读者不至于只能读到枯燥无味的内容解读，另一方面，也让这本书成为安全工程师的“牛津词典”，在工作中遇到问题，可以翻到对应章节，重温操作、理念。
#### 章节介绍
* 第 1 章，Linux 环境和相关工具，简要介绍了会在本书中用到的 Linux 环境和相关的工具。
* 第 2 章，ELF：二进制格式，帮助读者了解 ELF 文件格式
* 第 3 章，Linux 进程追踪，教会读者使用 ptrace 系统调用读写进程内存并注入代码。
* 第 4 章，ELF 病毒技术 - Linux/UNIX 病毒，介绍了 Linux 病毒的历史、病毒的工程化和围绕病毒进行的相关研究。
* 第 5 章，Linux 二进制保护，解释了 ELF 二进制保护的基本原理。
* 第 6 章，Linux 下的 ELF 二进制取证分析，通过解析 ELF 目标文件来研究病毒、后门和可疑的代码注入。
* 第 7 章，进程内存取证分析，将会介绍如何解析进程的地址空间，以研究内存中的恶意软件、后门和可疑的代码注入。
* 第 8 章，ECFS 一一扩展核心文件快照技术，是对 ECFS 这一用于深入进程内存取证分析的新开源产品的介绍。
* 第 9 章，Linux /proc/kcore 分析，介绍了如何使用 /proc/kcore 进行内存分析来检测 Linux 内核中的恶意软件。
### 5、我对书的评价
在过去，安全工程师们想要学习 Linux 二进制分析，只能通过搜索引擎来搜索有限的资料，不管是中文的还是英文的，都颇为琐碎，工程师们不得不在一个又一个网页间不断跳转，以求得知识的完备性，然而互联网上的资料虽多，但真正有价值的内容却不多，大多是一些颇为浅薄的内容。
这本书的出现，填补了 Linux 二进制分析方面的空白，一方面，体系化的内容设计使得安全工程师能够在读完此书后建立起 Linux 二进制分析的完整知识体系。读者在后续需要继续研究时，只需要在此书的基础上，查询其他相关的资料，丰满自己的知识体系即可。另一方面，对于一些开始在工作中使用 ELF 分析的工程师来说， Ryan 的经验也可以真正的帮助他们更好的工作，这才是这本书最难得的。
如果你已经开始了相关的安全工作又或者希望从事软件逆向研究的相关工作，那么你一定不能错过这本书。
### 6、欢迎交流
译者棣琦已经召集了一个专用的微信群来讨论有关本书的话题，欢迎大家加入（限时）：
如果你加入时二维码已经过期，或者群已经超过百人，你也可以加棣琦的微信，让她拉你进群：
### 福利
作为 Linux 中国参与制书流程的第一本书，我们从出版社那里为大家争取到了福利。在异步社区价值 59 的图书，我给你打 7 折，只要 39.99。
扫描下方二维码，即可下单购买这本《[Linux 二进制分析](https://detail.youzan.com/show/goods?alias=3nffgxtvcasmt&from=wxd&kdtfrom=wxd&type=share_goods&share=wxd_frd&mtd=sh_frd_wxd)》，欢迎大家转发此文或转发如下图片：
|
|||
了解用于 Linux 和 Windows 容器的 Docker “容器主机”与“容器操作系统”
|
Floyd Hilton
|
http://floydhilton.com/docker/2017/03/31/Docker-ContainerHost-vs-ContainerOS-Linux-Windows.html
|
让我们来探讨一下“容器主机”和“容器操作系统”之间的关系，以及它们在 Linux 和 Windows 容器之间的区别。
|
/data/attachment/album/201711/27/225657t2mt8222b5ma5c24.png.thumb.jpg
|
/data/attachment/album/201711/27/225657t2mt8222b5ma5c24.png
| true
| false
| true
|
geekpi
| false
|
[
"容器",
"主机",
"Docker"
] |
容器与云
|
{
"viewnum": 8919,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
让我们来探讨一下“容器主机”和“容器操作系统”之间的关系，以及它们在 Linux 和 Windows 容器之间的区别。
| 2017-11-27T22:57:06
| 2017-11-27T22:57:06
| 9,088
|
/article-9088-1.html
|
让我们来探讨一下“容器主机”和“容器操作系统”之间的关系，以及它们在 Linux 和 Windows 容器之间的区别。
### 一些定义
* <ruby> 容器主机 <rt> Container Host </rt></ruby>：也称为<ruby> 主机操作系统 <rt> Host OS </rt></ruby>。主机操作系统是 Docker 客户端和 Docker 守护程序在其上运行的操作系统。在 Linux 和非 Hyper-V 容器的情况下，主机操作系统与运行中的 Docker 容器共享内核。对于 Hyper-V，每个容器都有自己的 Hyper-V 内核。
* <ruby> 容器操作系统 <rt> Container OS </rt></ruby>：也被称为<ruby> 基础操作系统 <rt> Base OS </rt></ruby>。基础操作系统是指包含操作系统如 Ubuntu、CentOS 或 windowsservercore 的镜像。通常情况下，你将在基础操作系统镜像之上构建自己的镜像，以便可以利用该操作系统的部分功能。请注意，Windows 容器需要一个基础操作系统，而 Linux 容器不需要。
* <ruby> 操作系统内核 <rt> Operating System Kernel </rt></ruby>：内核管理诸如内存、文件系统、网络和进程调度等底层功能。
### 如下的一些图
在上面的例子中：
* 主机操作系统是 Ubuntu。
* Docker 客户端和 Docker 守护进程（一起被称为 Docker 引擎）正在主机操作系统上运行。
* 每个容器共享主机操作系统内核。
* CentOS 和 BusyBox 是 Linux 基础操作系统镜像。
* “No OS” 容器表明你不需要基础操作系统以在 Linux 中运行一个容器。你可以创建一个含有 [scratch](https://hub.docker.com/_/scratch/) 基础镜像的 Docker 文件，然后运行直接使用内核的二进制文件。
* 查看[这篇](https://www.brianchristner.io/docker-image-base-os-size-comparison/)文章来比较基础 OS 的大小。
在上面的例子中：
* 主机操作系统是 Windows 10 或 Windows Server。
* 每个容器共享主机操作系统内核。
* 所有 Windows 容器都需要 [nanoserver](https://hub.docker.com/r/microsoft/nanoserver/) 或 [windowsservercore](https://hub.docker.com/r/microsoft/windowsservercore/) 的基础操作系统。
在上面的例子中：
* 主机操作系统是 Windows 10 或 Windows Server。
* 每个容器都托管在自己的轻量级 Hyper-V 虚拟机中。
* 每个容器使用 Hyper-V 虚拟机内的内核，它在容器之间提供额外的分离层。
* 所有 Windows 容器都需要 [nanoserver](https://hub.docker.com/r/microsoft/nanoserver/) 或 [windowsservercore](https://hub.docker.com/r/microsoft/windowsservercore/) 的基础操作系统。
### 几个好的链接
* [关于 Windows 容器](https://docs.microsoft.com/en-us/virtualization/windowscontainers/about/)
* [深入实现 Windows 容器，包括多用户模式和“写时复制”来节省资源](http://blog.xebia.com/deep-dive-into-windows-server-containers-and-docker-part-2-underlying-implementation-of-windows-server-containers/)
* [Linux 容器如何通过使用“写时复制”来节省资源](https://docs.docker.com/engine/userguide/storagedriver/imagesandcontainers/#the-copy-on-write-strategy)
---
via: <http://floydhilton.com/docker/2017/03/31/Docker-ContainerHost-vs-ContainerOS-Linux-Windows.html>
作者：[Floyd Hilton](http://floydhilton.com/about/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 coredumpctl 更好地记录 bug
|
Paul W. Frields
|
https://fedoramagazine.org/file-better-bugs-coredumpctl/
|
通常开发者要求提供 “回溯（backtrace）” 形式的数据，以显示导致崩溃的指令流。开发人员可以使用它来修复 bug 以改进系统。
|
/data/attachment/album/201711/28/230423v9yp293hhfafy0vf.jpg.thumb.jpg
|
/data/attachment/album/201711/28/230423v9yp293hhfafy0vf.jpg
| true
| false
| true
|
geekpi
| false
|
[
"coredump",
"调试"
] |
软件开发
|
{
"viewnum": 7058,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
通常开发者要求提供 “回溯（backtrace）” 形式的数据，以显示导致崩溃的指令流。开发人员可以使用它来修复 bug 以改进系统。
| 2017-11-28T23:04:18
| 2017-11-28T23:04:18
| 9,089
|
/article-9089-1.html
|
一个不幸的事实是，所有的软件都有 bug，一些 bug 会导致系统崩溃。当它出现的时候，它经常会在磁盘上留下一个被称为“<ruby> 核心转储 <rt> core dump </rt></ruby>”的数据文件。该文件包含有关系统崩溃时的相关数据，可能有助于确定发生崩溃的原因。通常开发者要求提供 “<ruby> 回溯 <rt> backtrace </rt></ruby>” 形式的数据，以显示导致崩溃的指令流。开发人员可以使用它来修复 bug 以改进系统。如果系统发生了崩溃，以下是如何轻松生成 <ruby> 回溯 <rt> backtrace </rt></ruby> 的方法。
### 从使用 coredumpctl 开始
大多数 Fedora 系统使用[自动错误报告工具（ABRT）](https://github.com/abrt/abrt)来自动捕获崩溃文件并记录 bug。但是，如果你禁用了此服务或删除了该软件包，则此方法可能会有所帮助。
如果你遇到系统崩溃，请首先确保你运行的是最新的软件。更新通常包含修复程序，这些更新通常含有已经发现的会导致严重错误和崩溃的错误的修复。当你更新后，请尝试重现导致错误的情况。
如果崩溃仍然发生，或者你已经在运行最新的软件，那么可以使用有用的 `coredumpctl` 工具。此程序可帮助查找和处理崩溃。要查看系统上所有核心转储列表，请运行以下命令：
```
coredumpctl list
```
如果你看到比预期长的列表，请不要感到惊讶。有时系统组件在后台默默地崩溃，并自行恢复。快速查找今天的转储的简单方法是使用 `-since` 选项：
```
coredumpctl list --since=today
```
“PID” 列包含用于标识转储的进程 ID。请注意这个数字，因为你会之后再用到它。或者，如果你不想记住它，使用下面的命令将它赋值给一个变量：
```
MYPID=<PID>
```
要查看关于核心转储的信息，请使用此命令（使用 `$MYPID` 变量或替换 PID 编号）：
```
coredumpctl info $MYPID
```
### 安装 debuginfo 包
在核心转储中的数据以及原始代码中的指令之间调试符号转义。这个符号数据可能相当大。与大多数用户运行在 Fedora 系统上的软件包不同，符号以 “debuginfo” 软件包的形式安装。要确定你必须安装哪些 debuginfo 包，请先运行以下命令：
```
coredumpctl gdb $MYPID
```
这可能会在屏幕上显示大量信息。最后一行可能会告诉你使用 `dnf` 安装更多的 debuginfo 软件包。[用 sudo](https://fedoramagazine.org/howto-use-sudo/) 运行该命令以安装：
```
sudo dnf debuginfo-install <packages...>
```
然后再次尝试 `coredumpctl gdb $MYPID` 命令。**你可能需要重复执行此操作**，因为其他符号会在回溯中展开。
### 捕获回溯
在调试器中运行以下命令以记录信息：
```
set logging file mybacktrace.txt
set logging on
```
你可能会发现关闭分页有帮助。对于长的回溯，这可以节省时间。
```
set pagination off
```
现在运行回溯：
```
thread apply all bt full
```
现在你可以输入 `quit` 来退出调试器。`mybacktrace.txt` 包含可附加到 bug 或问题的追踪信息。或者，如果你正在与某人实时合作，则可以将文本上传到 pastebin。无论哪种方式，你现在可以向开发人员提供更多的帮助来解决问题。
---
作者简介：
Paul W. Frields
Paul W. Frields 自 1997 年以来一直是 Linux 用户和爱好者，并于 2003 年在 Fedora 发布不久后加入 Fedora。他是 Fedora 项目委员会的创始成员之一，从事文档、网站发布、宣传、工具链开发和维护软件。他于 2008 年 2 月至 2010 年 7 月加入 Red Hat，担任 Fedora 项目负责人，现任红帽公司工程部经理。他目前和妻子和两个孩子住在弗吉尼亚州。
---
via: <https://fedoramagazine.org/file-better-bugs-coredumpctl/>
作者：[Paul W. Frields](https://fedoramagazine.org/author/pfrields/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
介绍 Moby 项目：推进软件容器化运动的一个新的开源项目
|
Solomon Hykes
|
https://blog.docker.com/2017/04/introducing-the-moby-project/
|
自从 Docker 四年前将软件容器推向大众化以来，整个生态系统都围绕着容器化而发展，在这段这么短的时期内，它经历了两个不同的增长阶段。在这每一个阶段，生产容器系统的模式已经随着项目和不断增长的容器生态系统而演变适应用户群体的规模和需求。
|
/data/attachment/album/201711/29/054157oxcaiq4xxu4x4yz1.png.thumb.jpg
|
/data/attachment/album/201711/29/054157oxcaiq4xxu4x4yz1.png
| true
| false
| true
|
geekpi
| false
|
[
"Docker",
"Moby",
"容器"
] |
容器与云
|
{
"viewnum": 4930,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
自从 Docker 四年前将软件容器推向大众化以来，整个生态系统都围绕着容器化而发展，在这段这么短的时期内，它经历了两个不同的增长阶段。在这每一个阶段，生产容器系统的模式已经随着项目和不断增长的容器生态系统而演变适应用户群体的规模和需求。
| 2017-11-29T05:41:54
| 2017-11-29T05:41:54
| 9,090
|
/article-9090-1.html
|
自从 Docker 四年前将软件容器推向大众化以来，整个生态系统都围绕着容器化而发展，在这段这么短的时期内，它经历了两个不同的增长阶段。在这每一个阶段，生产容器系统的模式已经随着项目和不断增长的容器生态系统而演变适应用户群体的规模和需求。
Moby 是一个新的开源项目，旨在推进软件容器化运动，帮助生态系统将容器作为主流。它提供了一个组件库，一个将它们组装到定制的基于容器的系统的框架，也是所有容器爱好者进行实验和交换想法的地方。
让我们来回顾一下我们如何走到今天。在 2013-2014 年，开拓者开始使用容器，并在一个单一的开源代码库，Docker 和其他一些项目中进行协作，以帮助工具成熟。
然后在 2015-2016 年，云原生应用中大量采用容器用于生产环境。在这个阶段，用户社区已经发展到支持成千上万个部署，由数百个生态系统项目和成千上万的贡献者支持。正是在这个阶段，Docker 将其产品模式演变为基于开放式组件的方法。这样，它使我们能够增加创新和合作的方面。
涌现出来的新独立的 Docker 组件项目帮助促进了合作伙伴生态系统和用户社区的发展。在此期间，我们从 Docker 代码库中提取并快速创新组件，以便系统制造商可以在构建自己的容器系统时独立重用它们：[runc](https://github.com/opencontainers/runc)、[HyperKit](https://github.com/docker/hyperkit)、[VPNKit](https://github.com/docker/vpnkit)、[SwarmKit](https://github.com/docker/swarmkit)、[InfraKit](https://github.com/docker/infrakit)、[containerd](https://github.com/containerd/containerd) 等。
站在容器浪潮的最前沿，我们看到 2017 年出现的一个趋势是容器将成为主流，传播到计算、服务器、数据中心、云、桌面、物联网和移动的各个领域。每个行业和垂直市场，金融、医疗、政府、旅游、制造。以及每一个使用案例，现代网络应用、传统服务器应用、机器学习、工业控制系统、机器人技术。容器生态系统中许多新进入者的共同点是，它们建立专门的系统，针对特定的基础设施、行业或使用案例。
作为一家公司，Docker 使用开源作为我们的创新实验室，而与整个生态系统合作。Docker 的成功取决于容器生态系统的成功：如果生态系统成功，我们就成功了。因此，我们一直在计划下一阶段的容器生态系统增长：什么样的产品模式将帮助我们扩大容器生态系统，以实现容器成为主流的承诺？
去年，我们的客户开始在 Linux 以外的许多平台上要求有 Docker：Mac 和 Windows 桌面、Windows Server、云平台（如亚马逊网络服务（AWS）、Microsoft Azure 或 Google 云平台），并且我们专门为这些平台创建了[许多 Docker 版本](https://blog.docker.com/2017/03/docker-enterprise-edition/)。为了在一个相对较短的时间和更小的团队中，以可扩展的方式构建和发布这些专业版本，而不必重新发明轮子，很明显，我们需要一个新的方式。我们需要我们的团队不仅在组件上进行协作，而且还在组件组合上进行协作，这借用[来自汽车行业的想法](https://en.wikipedia.org/wiki/List_of_Volkswagen_Group_platforms)，其中组件被重用于构建完全不同的汽车。
我们认为将容器生态系统提升到一个新的水平以让容器成为主流的最佳方式是在生态系统层面上进行协作。
为了实现这种新的合作高度，今天（2017 年 4 月 18 日）我们宣布推出软件容器化运动的新开源项目 Moby。它是提供了数十个组件的“乐高组件”，一个将它们组合成定制容器系统的框架，以及所有容器爱好者进行试验和交换意见的场所。可以把 Moby 认为是容器系统的“乐高俱乐部”。
Moby 包括：
1. 容器化后端组件**库**（例如，低层构建器、日志记录设备、卷管理、网络、镜像管理、containerd、SwarmKit 等）
2. 将组件组合到独立容器平台中的**框架**，以及为这些组件构建、测试和部署构件的工具。
3. 一个名为 “Moby Origin” 的引用组件，它是 Docker 容器平台的开放基础，以及使用 Moby 库或其他项目的各种组件的容器系统示例。
Moby 专为系统构建者而设计，他们想要构建自己的基于容器的系统，而不是可以使用 Docker 或其他容器平台的应用程序开发人员。Moby 的参与者可以从源自 Docker 的组件库中进行选择，或者可以选择将“自己的组件”（BYOC）打包为容器，以便在所有组件之间进行混合和匹配以创建定制的容器系统。
Docker 将 Moby 作为一个开放的研发实验室来试验、开发新的组件，并与容器技术的未来生态系统进行协作。我们所有的开源协作都将转向 Moby。Docker 现在并且将来仍然是一个开源产品，可以让你创建、发布和运行容器。从用户的角度来看，它是完全一样的。用户可以继续从 docker.com 下载 Docker。请在 Moby 网站上参阅[有关 Docker 和 Moby 各自角色的更多信息](https://mobyproject.org/#moby-and-docker)。
请加入我们，帮助软件容器成为主流，并通过在组件和组合上进行协作，将我们的生态系统和用户社区发展到下一个高度。
---
via: <https://blog.docker.com/2017/04/introducing-the-moby-project/>
作者：[Solomon Hykes](https://blog.docker.com/author/solomon/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 上的科学图像处理
|
Joey Bernard
|
https://www.linuxjournal.com/content/image-processing-linux
|
在这篇文章中，我将谈到一款叫 ImageJ 的热门图像处理软件。特别的，我会介绍 Fiji，这是一款绑定了一系列用于科学图像处理插件的 ImageJ 软件。
|
/data/attachment/album/201711/29/064214rq07lbllcxquadvl.jpg.thumb.jpg
|
/data/attachment/album/201711/29/064214rq07lbllcxquadvl.jpg
| true
| false
| true
|
XYenChi
| false
|
[
"ImageJ",
"Fiji"
] |
桌面应用
|
{
"viewnum": 7394,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我将谈到一款叫 ImageJ 的热门图像处理软件。特别的，我会介绍 Fiji，这是一款绑定了一系列用于科学图像处理插件的 ImageJ 软件。
| 2017-11-29T06:42:24
| 2017-11-29T06:42:24
| 9,091
|
/article-9091-1.html
|
在显示你的数据和工作方面我发现了几个科学软件，但是我不会涉及太多方面。因此在这篇文章中，我将谈到一款叫 ImageJ 的热门图像处理软件。特别的，我会介绍 [Fiji](https://imagej.net/Fiji)，这是一款绑定了一系列用于科学图像处理插件的 ImageJ 软件。
Fiji 这个名字是一个循环缩略词，很像 GNU 。代表着 “Fiji Is Just ImageJ”。 ImageJ 是科学研究领域进行图像分析的实用工具 —— 例如你可以用它来辨认航拍风景图中树的种类。 ImageJ 能划分物品种类。它以插件架构制成，海量插件可供选择以提升使用灵活度。
首先是安装 ImageJ （或 Fiji）。大多数的 ImageJ 发行版都可有该软件包。你愿意的话，可以以这种方式安装它，然后根据你的研究安装所需的独立插件。另一种选择是安装 Fiji 的同时获取最常用的插件。不幸的是，大多数 Linux 发行版的软件中心不会有可用的 Fiji 安装包。幸而，官网上的简单安装文件是可以使用的。这是一个 zip 文件，包含了运行 Fiji 需要的所有文件目录。第一次启动时，你只会看到一个列出了菜单项的工具栏。（图 1）
*图 1. 第一次打开 Fiji 有一个最小化的界面。*
如果你没有备好图片来练习使用 ImageJ ，Fiji 安装包包含了一些示例图片。点击“File”->“Open Samples”的下拉菜单选项（图 2）。这些示例包含了许多你可能有兴趣做的任务。
*图 2. 案例图片可供学习使用 ImageJ。*
如果你安装了 Fiji，而不是单纯的 ImageJ ，那么大量插件也会被安装。首先要注意的是自动更新器插件。每次打开 ImageJ ，该插件将联网检验 ImageJ 和已安装插件的更新。
所有已安装的插件都在“插件”菜单项中可选。一旦你安装了很多插件，列表会变得冗杂，所以需要精简你选择的插件。你想手动更新的话，点击“Help”->“Update Fiji” 菜单项强制检测并获取可用更新的列表（图 3）。
*图 3. 强制手动检测可用更新。*
那么，现在，用 Fiji/ImageJ 可以做什么呢？举一例，统计图片中的物品数。你可以通过点击“File”->“Open Samples”->“Embryos”来载入示例。
*图 4. 用 ImageJ 算出图中的物品数。*
第一步给图片设定比例，这样你可以告诉 ImageJ 如何判别物品。首先，选择在工具栏选择线条按钮。然后选择“Analyze”->“Set Scale”，然后就会设置比例尺包含的像素点个数(图 5)。你可以设置“known distance ”为 100，单元为“um”。
*图 5. 很多图片分析任务需要对图片设定一个范围。*
接下来的步骤是简化图片内的信息。点击“Image”->“Type”->“8-bit”来减少信息量到 8 比特灰度图片。要分隔独立物体点击“Process”->“Binary”->“Make Binary”以自动设置图片门限。(图 6)。
*图 6. 有些工具可以自动完成像门限一样的任务。*
图片内的物品计数前，你需要移除像比例尺之类的人工操作。可以用矩形选择工具来选中它并点击“Edit”->“Clear”来完成这项操作。现在你可以分析图片看看这里是啥物体。
确保图中没有区域被选中，点击“Analyze”->“Analyze Particles”来弹出窗口来选择最小尺寸，这决定了最后的图片会展示什么（图 7）。
\*图 7. 你可以通过确定最小尺寸生成一个缩减过的图片。 \*
图 8 在总结窗口展示了一个概览。每个最小点也有独立的细节窗口。
*图 8. 包含了已知最小点总览清单的输出结果。*
当你有一个分析程序可以工作于给定图片类型，你通常需要将相同的步骤应用到一系列图片当中。这可能数以千计，你当然不会想对每张图片手动重复操作。这时候，你可以集中必要步骤到宏，这样它们可以被应用多次。点击插件->“Macros”->“Record”，弹出一个新的窗口记录你随后的所有命令。所有步骤完成，你可以将之保存为一个宏文件，并且通过点击“Plugins”->“Macros”->“Run”来在其它图片上重复运行。
如果你有非常特定的工作步骤，你可以简单地打开宏文件并手动编辑它，因为它是一个简单的文本文件。事实上有一套完整的宏语言可供你更加充分地控制图片处理过程。
然而，如果你有真的有非常多的系列图片需要处理，这也将是冗长乏味的工作。这种情况下，前往“Process”->“Batch”->“Macro”，会弹出一个你可以设置批量处理工作的新窗口（图 9）。
*图 9. 对批量输入的图片用单一命令运行宏。*
这个窗口中，你能选择应用哪个宏文件、输入图片所在的源目录和你想写入输出图片的输出目录。也可以设置输出文件格式，及通过文件名筛选输入图片中需要使用的。万事具备之后，点击窗口下方的的“Process”按钮开始批量操作。
若这是会重复多次的工作，你可以点击窗口底部的“Save”按钮保存批量处理到一个文本文件。点击也在窗口底部的“Open”按钮重新加载相同的工作。这个功能可以使得研究中最冗余部分自动化，这样你就可以在重点放在实际的科学研究中。
考虑到单单是 ImageJ 主页就有超过 500 个插件和超过 300 种宏可供使用，简短起见，我只能在这篇短文中提出最基本的话题。幸运的是，还有很多专业领域的教程可供使用，项目主页上还有关于 ImageJ 核心的非常棒的文档。如果你觉得这个工具对研究有用，你研究的专业领域也会有很多信息指引你。
---
作者简介：
Joey Bernard 有物理学和计算机科学的相关背景。这对他在新不伦瑞克大学当计算研究顾问的日常工作大有裨益。他也教计算物理和并行程序规划。
---
via: <https://www.linuxjournal.com/content/image-processing-linux>
作者：[Joey Bernard](https://www.linuxjournal.com/users/joey-bernard) 译者：[XYenChi](https://github.com/XYenChi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何轻松记住 Linux 命令
|
Nick Congleton
|
https://www.maketecheasier.com/remember-linux-commands/
|
Linux 新手往往对命令行心存畏惧。部分原因是因为需要记忆大量的命令，毕竟掌握命令是高效使用命令行的前提。不幸的是，学习这些命令并无捷径，然而在你开始学习命令之初，有些工具还是可以帮到你的。
|
/data/attachment/album/201711/29/152255euutfdffffdzdfyq.jpg.thumb.jpg
|
/data/attachment/album/201711/29/152255euutfdffffdzdfyq.jpg
| true
| false
| true
|
lujun9972
| false
|
[
"命令行",
"apropos",
"history"
] |
技术
|
{
"viewnum": 16816,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux 新手往往对命令行心存畏惧。部分原因是因为需要记忆大量的命令，毕竟掌握命令是高效使用命令行的前提。不幸的是，学习这些命令并无捷径，然而在你开始学习命令之初，有些工具还是可以帮到你的。
| 2017-11-29T15:22:00
| 2017-11-29T15:22:00
| 9,093
|
/article-9093-1.html
|
Linux 新手往往对命令行心存畏惧。部分原因是因为需要记忆大量的命令，毕竟掌握命令是高效使用命令行的前提。
不幸的是，学习这些命令并无捷径，然而在你开始学习命令之初，有些工具还是可以帮到你的。
### history
首先要介绍的是命令行工具 `history`，它能帮你记住那些你曾经用过的命令。包括应用最广泛的 Bash 在内的大多数 [Linux shell](https://www.maketecheasier.com/alternative-linux-shells/)，都会创建一个历史文件来包含那些你输入过的命令。如果你用的是 Bash，这个历史文件就是 `/home/<username>/.bash_history`。
这个历史文件是纯文本格式的，你可以用任意的文本编辑器打开来浏览和搜索。
### apropos
确实存在一个可以帮你找到其他命令的命令。这个命令就是 `apropos`，它能帮你找出合适的命令来完成你的搜索。比如，假设你需要知道哪个命令可以列出目录的内容，你可以运行下面命令:
```
apropos "list directory"
```
这就搜索出结果了，非常直接。给 “directory” 加上复数后再试一下。
```
apropos "list directories"
```
这次没用了。`apropos` 所作的其实就是搜索一系列命令的描述。描述不匹配的命令不会纳入结果中。
还有其他的用法。通过 `-a` 标志，你可以以更灵活的方式来增加搜索关键字。试试这条命令:
```
apropos "match pattern"
```
你会觉得应该会有一些匹配的内容出现，比如 [grep](https://www.maketecheasier.com/what-is-grep-and-uses/) 对吗? 然而，实际上并没有匹配出任何结果。再说一次，apropos 只会根据字面内容进行搜索。
现在让我们试着用 `-a` 标志来把单词分割开来。（LCTT 译注：该选项的意思是“and”，即多个关键字都存在，但是不需要正好是连在一起的字符串。）
```
apropos "match" -a "pattern"
```
这一下，你可以看到很多期望的结果了。
`apropos` 是一个很棒的工具，不过你需要留意它的缺陷。
### ZSH
ZSH 其实并不是用于记忆命令的工具。它其实是一种 shell。你可以用 [ZSH](https://www.maketecheasier.com/understanding-the-different-shell-in-linux-zsh-shell/) 来替代 Bash 作为你的命令行 shell。ZSH 包含了自动纠错机制，能在你输入命令的时候给你予提示。开启该功能后，它会提示你相近的选择。在 ZSH 中你可以像往常一样使用命令行，同时你还能享受到极度安全的网络以及其他一些非常好用的特性。充分利用 ZSH 的最简单方法就是使用 [Oh-My-ZSH](https://github.com/robbyrussell/oh-my-zsh)。
### 速记表
最后，也可能是最间的方法就是使用 [速记表](https://www.maketecheasier.com/premium/cheatsheet/linux-command-line/)。
有很多在线的速记表，比如[这个](https://www.cheatography.com/davechild/cheat-sheets/linux-command-line/) 可以帮助你快速查询命令。
为了快速查询，你可以寻找图片格式的速记表，然后将它设置为你的桌面墙纸。
这并不是记忆命令的最好方法，但是这么做可以帮你节省在线搜索遗忘命令的时间。
在学习时依赖这些方法，最终你会发现你会越来越少地使用这些工具。没有人能够记住所有的事情，因此偶尔遗忘掉某些东西或者遇到某些没有见过的东西也很正常。这也是这些工具以及因特网存在的意义。
---
via: <https://www.maketecheasier.com/remember-linux-commands/>
作者：[Nick Congleton](https://www.maketecheasier.com/author/nickcongleton/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
操作系统何时运行？
|
Gustavo
|
http://duartes.org/gustavo/blog/post/when-does-your-os-run/
|
请各位思考以下问题：在你阅读本文的这段时间内，计算机中的操作系统在运行吗？又或者仅仅是 Web 浏览器在运行？又或者它们也许均处于空闲状态，等待着你的指示？
|
/data/attachment/album/201711/29/222924esf8201bgwoobtg8.jpg.thumb.jpg
|
/data/attachment/album/201711/29/222924esf8201bgwoobtg8.jpg
| true
| false
| true
|
Cwndmiao
| false
|
[
"操作系统",
"CPU"
] |
技术
|
{
"viewnum": 9174,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9303,
"displayorder": 0
}
] |
请各位思考以下问题：在你阅读本文的这段时间内，计算机中的操作系统在运行吗？又或者仅仅是 Web 浏览器在运行？又或者它们也许均处于空闲状态，等待着你的指示？
| 2017-11-29T22:29:00
| 2017-11-29T22:29:00
| 9,095
|
/article-9095-1.html
|
请各位思考以下问题：在你阅读本文的这段时间内，计算机中的操作系统在**运行**吗？又或者仅仅是 Web 浏览器在运行？又或者它们也许均处于空闲状态，等待着你的指示？
这些问题并不复杂，但它们深入涉及到系统软件工作的本质。为了准确回答这些问题，我们需要透彻理解操作系统的行为模型，包括性能、安全和除错等方面。在该系列文章中，我们将以 Linux 为主举例来帮助你建立操作系统的行为模型，OS X 和 Windows 在必要的时候也会有所涉及。对那些深度探索者，我会在适当的时候给出 Linux 内核源码的链接。
这里有一个基本认知，就是，在任意给定时刻，某个 CPU 上仅有一个任务处于活动状态。大多数情形下这个任务是某个用户程序，例如你的 Web 浏览器或音乐播放器，但它也可能是一个操作系统线程。可以确信的是，它是**一个任务**，不是两个或更多，也不是零个，对，**永远**是一个。
这听上去可能会有些问题。比如，你的音乐播放器是否会独占 CPU 而阻止其它任务运行？从而使你不能打开任务管理工具去杀死音乐播放器，甚至让鼠标点击也失效，因为操作系统没有机会去处理这些事件。你可能会愤而喊出，“它究竟在搞什么鬼？”，并引发骚乱。
此时便轮到**中断**大显身手了。中断就好比，一声巨响或一次拍肩后，神经系统通知大脑去感知外部刺激一般。计算机主板上的[芯片组](http://duartes.org/gustavo/blog/post/motherboard-chipsets-memory-map)同样会中断 CPU 运行以传递新的外部事件，例如键盘上的某个键被按下、网络数据包的到达、一次硬盘读取的完成，等等。硬件外设、主板上的中断控制器和 CPU 本身，它们共同协作实现了中断机制。
中断对于记录我们最珍视的资源——时间——也至关重要。计算机[启动过程](http://duartes.org/gustavo/blog/post/kernel-boot-process)中，操作系统内核会设置一个硬件计时器以让其产生周期性**计时中断**，例如每隔 10 毫秒触发一次。每当计时中断到来，内核便会收到通知以更新系统统计信息和盘点如下事项：当前用户程序是否已运行了足够长时间？是否有某个 TCP 定时器超时了？中断给予了内核一个处理这些问题并采取合适措施的机会。这就好像你给自己设置了整天的周期闹铃并把它们用作检查点：我是否应该去做我正在进行的工作？是否存在更紧急的事项？直到你发现 10 年时间已逝去……
这些内核对 CPU 周期性的劫持被称为<ruby> 滴答 <rt> tick </rt></ruby>，也就是说，是中断让你的操作系统滴答了一下。不止如此，中断也被用作处理一些软件事件，如整数溢出和页错误，其中未涉及外部硬件。**中断是进入操作系统内核最频繁也是最重要的入口**。对于学习电子工程的人而言，这些并无古怪，它们是操作系统赖以运行的机制。
说到这里，让我们再来看一些实际情形。下图示意了 Intel Core i5 系统中的一个网卡中断。图片中的部分元素设置了超链，你可以点击它们以获取更为详细的信息，例如每个设备均被链接到了对应的 Linux 驱动源码。
链接如下：
* [network card](https://github.com/torvalds/linux/blob/v3.17/drivers/net/ethernet/intel/e1000e/netdev.c)
* [USB keyboard](https://github.com/torvalds/linux/blob/v3.16/drivers/hid/usbhid/usbkbd.c)
* [I/O APIC](https://github.com/torvalds/linux/blob/v3.16/arch/x86/kernel/apic/io_apic.c)
* [HPET](https://github.com/torvalds/linux/blob/v3.17/arch/x86/kernel/hpet.c)
让我们来仔细研究下。首先，由于系统中存在众多中断源，如果硬件只是通知 CPU “嘿，这里发生了一些事情”然后什么也不做，则不太行得通。这会带来难以忍受的冗长等待。因此，计算机上电时，每个设备都被授予了一根**中断线**，或者称为 IRQ。这些 IRQ 然后被系统中的中断控制器映射成值介于 0 到 255 之间的**中断向量**。等到中断到达 CPU，它便具备了一个完好定义的数值，异于硬件的某些其它诡异行为。
相应地，CPU 中还存有一个由内核维护的指针，指向一个包含 255 个函数指针的数组，其中每个函数被用来处理某个特定的中断向量。后文中，我们将继续深入探讨这个数组，它也被称作**中断描述符表**（IDT）。
每当中断到来，CPU 会用中断向量的值去索引中断描述符表，并执行相应处理函数。这相当于，在当前正在执行任务的上下文中，发生了一个特殊函数调用，从而允许操作系统以较小开销快速对外部事件作出反应。考虑下述场景，Web 服务器在发送数据时，CPU 却间接调用了操作系统函数，这听上去要么很炫酷要么令人惊恐。下图展示了 Vim 编辑器运行过程中一个中断到来的情形。
此处请留意，中断的到来是如何触发 CPU 到 [Ring 0](http://duartes.org/gustavo/blog/post/cpu-rings-privilege-and-protection) 内核模式的切换而未有改变当前活跃的任务。这看上去就像，Vim 编辑器直接面向操作系统内核产生了一次神奇的函数调用，但 Vim 还在那里，它的[地址空间](http://duartes.org/gustavo/blog/post/anatomy-of-a-program-in-memory)原封未动，等待着执行流返回。
这很令人振奋，不是么？不过让我们暂且告一段落吧，我需要合理控制篇幅。我知道还没有回答完这个开放式问题，甚至还实质上翻开了新的问题，但你至少知道了在你读这个句子的同时**滴答**正在发生。我们将在充实了对操作系统动态行为模型的理解之后再回来寻求问题的答案，对 Web 浏览器情形的理解也会变得清晰。如果你仍有问题，尤其是在这篇文章公诸于众后，请尽管提出。我将会在文章或后续评论中回答它们。下篇文章将于明天在 RSS 和 Twitter 上发布。
---
via: <http://duartes.org/gustavo/blog/post/when-does-your-os-run/>
作者：[gustavo](http://duartes.org/gustavo/blog/about/) 译者：[Cwndmiao](https://github.com/Cwndmiao) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
tmate：秒级分享你的终端会话
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/tmate-instantly-share-your-terminal-session-to-anyone-in-seconds/
|
tmate 的意思是 teammates，它是 tmux 的一个分支，并且使用相同的配置信息（例如快捷键配置，配色方案等）。它是一个终端多路复用器，同时具有即时分享终端的能力。它允许在单个屏幕中创建并操控多个终端，同时这些终端还能与其他同事分享。
|
/data/attachment/album/201711/30/122203xut2ngdhontci2vt.jpg.thumb.jpg
|
/data/attachment/album/201711/30/122203xut2ngdhontci2vt.jpg
| true
| false
| true
|
lujun9972
| false
|
[
"终端",
"tmate",
"tmux"
] |
系统运维
|
{
"viewnum": 16427,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
tmate 的意思是 teammates，它是 tmux 的一个分支，并且使用相同的配置信息（例如快捷键配置，配色方案等）。它是一个终端多路复用器，同时具有即时分享终端的能力。它允许在单个屏幕中创建并操控多个终端，同时这些终端还能与其他同事分享。
| 2017-12-01T09:17:00
| 2017-12-01T09:17:00
| 9,096
|
/article-9096-1.html
|
不久前，我们写过一篇关于 [teleconsole](https://www.2daygeek.com/teleconsole-share-terminal-session-instantly-to-anyone-in-seconds/) 的介绍，该工具可用于快速分享终端给任何人（任何你信任的人）。今天我们要聊一聊另一款类似的应用，名叫 `tmate`。
`tmate` 有什么用？它可以让你在需要帮助时向你的朋友们求助。
### 什么是 tmate？
[tmate](https://tmate.io/) 的意思是 `teammates`，它是 tmux 的一个分支，并且使用相同的配置信息（例如快捷键配置，配色方案等）。它是一个终端多路复用器，同时具有即时分享终端的能力。它允许在单个屏幕中创建并操控多个终端，同时这些终端还能与其他同事分享。
你可以分离会话，让作业在后台运行，然后在想要查看状态时重新连接会话。`tmate` 提供了一个即时配对的方案，让你可以与一个或多个队友共享一个终端。
在屏幕的地步有一个状态栏，显示了当前会话的一些诸如 ssh 命令之类的共享信息。
### tmate 是怎么工作的？
* 运行 `tmate` 时，会通过 `libssh` 在后台创建一个连接到 tmate.io （由 tmate 开发者维护的后台服务器）的 ssh 连接。
* tmate.io 服务器的 ssh 密钥通过 DH 交换进行校验。
* 客户端通过本地 ssh 密钥进行认证。
* 连接创建后，本地 tmux 服务器会生成一个 150 位(不可猜测的随机字符)会话令牌。
* 队友能通过用户提供的 SSH 会话 ID 连接到 tmate.io。
### 使用 tmate 的必备条件
由于 `tmate.io` 服务器需要通过本地 ssh 密钥来认证客户机，因此其中一个必备条件就是生成 SSH 密钥 key。 记住，每个系统都要有自己的 SSH 密钥。
```
$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/magi/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/magi/.ssh/id_rsa.
Your public key has been saved in /home/magi/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:3ima5FuwKbWyyyNrlR/DeBucoyRfdOtlUmb5D214NC8 magi@magi-VirtualBox
The key's randomart image is:
+---[RSA 2048]----+
| |
| |
| . |
| . . = o |
| *ooS= . + o |
| . =.@*o.o.+ E .|
| =o==B++o = . |
| o.+*o+.. . |
| ..o+o=. |
+----[SHA256]-----+
```
### 如何安装 tmate
`tmate` 已经包含在某些发行版的官方仓库中，可以通过包管理器来安装。
对于 Debian/Ubuntu，可以使用 [APT-GET 命令](https://www.2daygeek.com/apt-get-apt-cache-command-examples-manage-packages-debian-ubuntu-systems/)或者 [APT 命令](https://www.2daygeek.com/apt-command-examples-manage-packages-debian-ubuntu-systems/)to 来安装。
```
$ sudo apt-get install software-properties-common
$ sudo add-apt-repository ppa:tmate.io/archive
$ sudo apt-get update
$ sudo apt-get install tmate
```
你也可以从官方仓库中安装 tmate。
```
$ sudo apt-get install tmate
```
对于 Fedora，使用 [DNF 命令](https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/) 来安装。
```
$ sudo dnf install tmate
```
对于基于 Arch Linux 的系统，使用 [Yaourt 命令](https://www.2daygeek.com/install-yaourt-aur-helper-on-arch-linux/)或 [Packer 命令](https://www.2daygeek.com/install-packer-aur-helper-on-arch-linux/) 来从 AUR 仓库中安装。
```
$ yaourt -S tmate
```
或
```
$ packer -S tmate
```
对于 openSUSE，使用 [Zypper 命令](https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/) 来安装。
```
$ sudo zypper in tmate
```
### 如何使用 tmate
成功安装后，打开终端然后输入下面命令，就会打开一个新的会话，在屏幕底部，你能看到 SSH 会话的 ID。
```
$ tmate
```
要注意的是，SSH 会话 ID 会在几秒后消失，不过不要紧，你可以通过下面命令获取到这些详细信息。
```
$ tmate show-messages
```
`tmate` 的 `show-messages` 命令会显示 tmate 的日志信息，其中包含了该 ssh 连接内容。
现在，分享你的 SSH 会话 ID 给你的朋友或同事从而允许他们观看终端会话。除了 SSH 会话 ID 以外，你也可以分享 web URL。
另外你还可以选择分享的是只读会话还是可读写会话。
### 如何通过 SSH 连接会话
只需要在终端上运行你从朋友那得到的 SSH 终端 ID 就行了。类似下面这样。
```
$ ssh session: ssh 3KuRj95sEZRHkpPtc2y6jcokP@sg2.tmate.io
```
### 如何通过 Web URL 连接会话
打开浏览器然后访问朋友给你的 URL 就行了。像下面这样。
只需要输入 `exit` 就能退出会话了。
```
[Source System Output]
[exited]
[Remote System Output]
[server exited]
Connection to sg2.tmate.io closed by remote host。
Connection to sg2.tmate.io closed。
```
---
via: <https://www.2daygeek.com/tmate-instantly-share-your-terminal-session-to-anyone-in-seconds/>
作者：[Magesh Maruthamuthu][a] 译者：[lujun9972](https://github.com/lujun9972) 校对：[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.