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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
略谈企业的开源战略
|
老王
|
11 月 24 日，Gdevops 全球敏捷运维峰会的 2017 年度收官之站在广州盛大举行。老王受邀参加了本次大会，本做了本次大会的首场演讲《略谈企业的开源战略》。
|
/data/attachment/album/201711/30/130252jr1kdk8k12xxo2d1.jpg.thumb.jpg
|
/data/attachment/album/201711/30/130252jr1kdk8k12xxo2d1.jpg
| true | false | false | false |
[
"开源",
"企业"
] |
观点
|
{
"viewnum": 4032,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
11 月 24 日，Gdevops 全球敏捷运维峰会的 2017 年度收官之站在广州盛大举行。老王受邀参加了本次大会，本做了本次大会的首场演讲《略谈企业的开源战略》。
| 2017-11-30T16:02:00 | 2017-11-30T16:02:00 | 9,097 |
/article-9097-1.html
|
11 月 24 日，Gdevops 全球敏捷运维峰会的 2017 年度收官之站在广州盛大举行。老王受邀参加了本次大会，本做了本次大会的首场演讲《略谈企业的开源战略》。
说起来，Gdevops 已经举办了两年多，我曾经多次参与和主持过大会，开场的视频所滑过的一幕幕，让我不禁心生感慨，逝者如斯夫啊。
虽然参加了两年的 Gdevops，也曾经以主持人的身份主持过多期，但是这次还是老王第一次以演讲者的身份登上 Gdevops 讲台——结果原本感觉 30 分钟还是比较长的，结果讲 high 了，差点没搂着时间。
以下是整理自本次演讲的内容，分享给大家，大家也可以下载演讲的稿件（[PDF](https://img.linux.net.cn/static/pdf/%E7%95%A5%E8%B0%88%E4%BC%81%E4%B8%9A%E7%9A%84%E5%BC%80%E6%BA%90%E6%88%98%E7%95%A5%20-%20Gdevops%E5%B3%B0%E4%BC%9A.pdf)，2.3Mb）。
演讲的内容主要分成三个部分：
首先追本溯源，简单介绍了开源的历史：
从软件的由来、专有软件的兴起谈到了古典黑客文化的回归：
然后谈到了开源软件的“正确打开方式”：
什么是开源软件（或者自由软件），很多人都有一些理解，不过<ruby> 开源软件 <rp> （ </rp> <rt> Open Source Software </rt> <rp> ） </rp></ruby>其实是有严格的定义的。开源软件推进联盟（OSI）对其有着[完整严密的定义](https://opensource.org/osd-annotated)，不过主要是以下几点：
同样，自由软件也有着严格的定义，这个定义的风格很有 RMS 风格。这就是自由软件的四大自由：
开源软件和自由软件有所不同，但是又联系紧密，通常来说，自由软件属于开源软件的[一部分](https://www.gnu.org/philosophy/open-source-misses-the-point.zh-cn.html%20)，其定义更严格一些。当然，有些场景下，我们会使用更中立的说法：FOSS（自由及开源软件），也有时候用 FLOSS 的写法（L 代表 Libre）。
那么，了解是什么是开源软件之后，开源软件可以赋予你什么权利呢？
开源不等于公共领域，所以开源也是有限制的（许可证），正是因为这些限制，才有开源生态的生生不息的发展：
开源软件的使用也是有一定的规则的：
遵循了这些规则，开源软件能给你带来数之不尽的受益：
一般来说，“打开”开源软件有几个阶段，按照深入程度分别是：
而在这个过程中，开源软件也不单纯是只会带来受益的，也存在一些“打开不当”的风险：
只有以“正确打开”的方式，才能真正受益于开源软件，而不是在拥抱开源的时候，遇到风险：
最后，以企业的视角，来谈谈企业在开源方面的实践操作。基本上，如果不是浅尝辄止，企业在开源方面的实践，应该考虑如下几个方面：
首先是要进行开源计划的规划，而不是随便试试：
并且落实开源方面的组织机构和人员：
如果公司规模比较大，那么不妨从<ruby> 内部开源 <rp> （ </rp> <rt> Inner Source </rt> <rp> ） </rp></ruby>做起来，这有利于公司内部转换思想、流程，也可以比较早的发现问题：
内部开源有了一定程度之后，可以逐步走向外部社区：
最终形成开放平台和开源生态：
这样，企业的开源才算得上走上了正确的道路。
我的本次演讲就到这里。
|
||||
ARMv8 上的 kprobes 事件跟踪
|
David Long
|
http://www.linaro.org/blog/kprobes-event-tracing-armv8/
|
kprobes 是一种内核功能，它允许通过在执行（或模拟）断点指令之前和之后，设置调用开发者提供例程的任意断点来检测内核。
|
/data/attachment/album/201712/01/200415tacytrrorw9t2yb9.jpg.thumb.jpg
|
/data/attachment/album/201712/01/200415tacytrrorw9t2yb9.jpg
| true | false | true |
kimii
| false |
[
"kprobes",
"内核"
] |
技术
|
{
"viewnum": 6928,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
kprobes 是一种内核功能，它允许通过在执行（或模拟）断点指令之前和之后，设置调用开发者提供例程的任意断点来检测内核。
| 2017-12-01T20:04:23 | 2017-12-01T20:04:23 | 9,098 |
/article-9098-1.html
|
### 介绍
kprobes 是一种内核功能，它允许通过在执行（或模拟）断点指令之前和之后，设置调用开发者提供例程的任意断点来检测内核。可参见 kprobes 文档<sup> 注1</sup> 获取更多信息。基本的 kprobes 功能可使用 `CONFIG_KPROBEES` 来选择。在 arm64 的 v4.8 内核发行版中， kprobes 支持被添加到主线。
在这篇文章中，我们将介绍 kprobes 在 arm64 上的使用，通过在命令行中使用 debugfs 事件追踪接口来收集动态追踪事件。这个功能在一些架构（包括 arm32）上可用已经有段时间，现在在 arm64 上也能使用了。这个功能可以无需编写任何代码就能使用 kprobes。
### 探针类型
kprobes 子系统提供了三种不同类型的动态探针，如下所述。
#### kprobes
基本探针是 kprobes 插入的一个软件断点，用以替代你正在探测的指令，当探测点被命中时，它为最终的单步执行（或模拟）保存下原始指令。
#### kretprobes
kretprobes 是 kprobes 的一部分，它允许拦截返回函数，而不必在返回点设置一个探针（或者可能有多个探针）。对于支持的架构（包括 ARMv8），只要选择 kprobes，就可以选择此功能。
#### jprobes
jprobes 允许通过提供一个具有相同<ruby> 调用签名 <rt> call signature </rt></ruby>的中间函数来拦截对一个函数的调用，这里中间函数将被首先调用。jprobes 只是一个编程接口，它不能通过 debugfs 事件追踪子系统来使用。因此，我们将不会在这里进一步讨论 jprobes。如果你想使用 jprobes，请参考 kprobes 文档。
### 调用 kprobes
kprobes 提供一系列能从内核代码中调用的 API 来设置探测点和当探测点被命中时调用的注册函数。在不往内核中添加代码的情况下，kprobes 也是可用的，这是通过写入特定事件追踪的 debugfs 文件来实现的，需要在文件中设置探针地址和信息，以便在探针被命中时记录到追踪日志中。后者是本文将要讨论的重点。最后 kprobes 可以通过 perl 命令来使用。
#### kprobes API
内核开发人员可以在内核中编写函数(通常在专用的调试模块中完成）来设置探测点，并且在探测指令执行前和执行后立即执行任何所需操作。这在 kprobes.txt 中有很好的解释。
#### 事件追踪
事件追踪子系统有自己的自己的文档<sup> 注2</sup> ，对于了解一般追踪事件的背景可能值得一读。事件追踪子系统是<ruby> 追踪点 <rt> tracepoints </rt></ruby>和 kprobes 事件追踪的基础。事件追踪文档重点关注追踪点，所以请在查阅文档时记住这一点。kprobes 与追踪点不同的是没有预定义的追踪点列表，而是采用动态创建的用于触发追踪事件信息收集的任意探测点。事件追踪子系统通过一系列 debugfs 文件来控制和监视。事件追踪（`CONFIG_EVENT_TRACING`）将在被如 kprobe 事件追踪子系统等需要时自动选择。
##### kprobes 事件
使用 kprobes 事件追踪子系统，用户可以在内核任意断点处指定要报告的信息，只需要指定任意现有可探测指令的地址以及格式化信息即可确定。在执行过程中遇到断点时，kprobes 将所请求的信息传递给事件追踪子系统的公共部分，这些部分将数据格式化并追加到追踪日志中，就像追踪点的工作方式一样。kprobes 使用一个类似的但是大部分是独立的 debugfs 文件来控制和显示追踪事件信息。该功能可使用 `CONFIG_KPROBE_EVENT` 来选择。Kprobetrace 文档^ 注3 提供了如何使用 kprobes 事件追踪的基本信息，并且应当被参考用以了解以下介绍示例的详细信息。
#### kprobes 和 perf
perf 工具为 kprobes 提供了另一个命令行接口。特别地，`perf probe` 允许探测点除了由函数名加偏移量和地址指定外，还可由源文件和行号指定。perf 接口实际上是使用 kprobes 的 debugfs 接口的封装器。
### Arm64 kprobes
上述所有 kprobes 的方面现在都在 arm64 上得到实现，然而实际上与其它架构上的有一些不同：
* 注册名称参数当然是依架构而特定的，并且可以在 ARM ARM 中找到。
* 目前不是所有的指令类型都可被探测。当前不可探测的指令包括 mrs/msr（除了 DAIF 读取）、异常生成指令、eret 和 hint（除了 nop 变体）。在这些情况下，只探测一个附近的指令来代替是最简单的。这些指令在探测的黑名单里是因为在 kprobes 单步执行或者指令模拟时它们对处理器状态造成的改变是不安全的，这是由于 kprobes 构造的单步执行上下文和指令所需要的不一致，或者是由于指令不能容忍在 kprobes 中额外的处理时间和异常处理（ldx/stx）。
* 试图识别在 ldx/stx 序列中的指令并且防止探测，但是理论上这种检查可能会失败，导致允许探测到的原子序列永远不会成功。当探测原子代码序列附近时应该小心。
* 注意由于 linux ARM64 调用约定的具体信息，为探测函数可靠地复制栈帧是不可能的，基于此不要试图用 jprobes 这样做，这一点与支持 jprobes 的大多数其它架构不同。这样的原因是被调用者没有足够的信息来确定需要的栈数量。
* 注意当探针被命中时，一个探针记录的栈指针信息将反映出使用中的特定栈指针，它是内核栈指针或者中断栈指针。
* 有一组内核函数是不能被探测的，通常因为它们作为 kprobes 处理的一部分被调用。这组函数的一部分是依架构特定的，并且也包含如异常入口代码等。
### 使用 kprobes 事件追踪
kprobes 的一个常用例子是检测函数入口和/或出口。因为只需要使用函数名来作为探针地址，它安装探针特别简单。kprobes 事件追踪将查看符号名称并且确定地址。ARMv8 调用标准定义了函数参数和返回值的位置，并且这些可以作为 kprobes 事件处理的一部分被打印出来。
#### 例子: 函数入口探测
检测 USB 以太网驱动程序复位功能：
```
$ pwd
/sys/kernel/debug/tracing
$ cat > kprobe_events <<EOF
p ax88772_reset %x0
EOF
$ echo 1 > events/kprobes/enable
```
此时每次该驱动的 `ax8872_reset()` 函数被调用，追踪事件都将会被记录。这个事件将显示指向通过作为此函数的唯一参数的 `X0`（按照 ARMv8 调用标准）传入的 `usbnet` 结构的指针。插入需要以太网驱动程序的 USB 加密狗后，我们看见以下追踪信息：
```
$ cat trace
# tracer: nop
#
# entries-in-buffer/entries-written: 1/1 #P:8
#
# _—–=> irqs-off
# / _—-=> need-resched
# | / _—=> hardirq/softirq
# || / _–=> preempt-depth
# ||| / delay
# TASK-PID CPU# |||| TIMESTAMP FUNCTION
# | | | |||| | |
kworker/0:0-4 [000] d… 10972.102939: p_ax88772_reset_0:
(ax88772_reset+0x0/0x230) arg1=0xffff800064824c80
```
这里我们可以看见传入到我们的探测函数的指针参数的值。由于我们没有使用 kprobes 事件追踪的可选标签功能，我们需要的信息自动被标注为 `arg1`。注意这指向我们需要 kprobes 记录这个探针的一组值的第一个，而不是函数参数的实际位置。在这个例子中它也只是碰巧是我们探测函数的第一个参数。
#### 例子: 函数入口和返回探测
kretprobe 功能专门用于探测函数返回。在函数入口 kprobes 子系统将会被调用并且建立钩子以便在函数返回时调用，钩子将记录需求事件信息。对最常见情况，返回信息通常在 `X0` 寄存器中，这是非常有用的。在 `%x0` 中返回值也可以被称为 `$retval`。以下例子也演示了如何提供一个可读的标签来展示有趣的信息。
使用 kprobes 和 kretprobe 检测内核 `do_fork()` 函数来记录参数和结果的例子：
```
$ cd /sys/kernel/debug/tracing
$ cat > kprobe_events <<EOF
p _do_fork %x0 %x1 %x2 %x3 %x4 %x5
r _do_fork pid=%x0
EOF
$ echo 1 > events/kprobes/enable
```
此时每次对 `_do_fork()` 的调用都会产生两个记录到 trace 文件的 kprobe 事件，一个报告调用参数值，另一个报告返回值。返回值在 trace 文件中将被标记为 `pid`。这里是三次 fork 系统调用执行后的 trace 文件的内容：
```
_$ cat trace
# tracer: nop
#
# entries-in-buffer/entries-written: 6/6 #P:8
#
# _—–=> irqs-off
# / _—-=> need-resched
# | / _—=> hardirq/softirq
# || / _–=> preempt-depth
# ||| / delay
# TASK-PID CPU# |||| TIMESTAMP FUNCTION
# | | | |||| | |
bash-1671 [001] d… 204.946007: p__do_fork_0: (_do_fork+0x0/0x3e4) arg1=0x1200011 arg2=0x0 arg3=0x0 arg4=0x0 arg5=0xffff78b690d0 arg6=0x0
bash-1671 [001] d..1 204.946391: r__do_fork_0: (SyS_clone+0x18/0x20 <- _do_fork) pid=0x724
bash-1671 [001] d… 208.845749: p__do_fork_0: (_do_fork+0x0/0x3e4) arg1=0x1200011 arg2=0x0 arg3=0x0 arg4=0x0 arg5=0xffff78b690d0 arg6=0x0
bash-1671 [001] d..1 208.846127: r__do_fork_0: (SyS_clone+0x18/0x20 <- _do_fork) pid=0x725
bash-1671 [001] d… 214.401604: p__do_fork_0: (_do_fork+0x0/0x3e4) arg1=0x1200011 arg2=0x0 arg3=0x0 arg4=0x0 arg5=0xffff78b690d0 arg6=0x0
bash-1671 [001] d..1 214.401975: r__do_fork_0: (SyS_clone+0x18/0x20 <- _do_fork) pid=0x726_
```
#### 例子： 解引用指针参数
对于指针值，kprobes 事件处理子系统也允许解引用和打印所需的内存内容，适用于各种基本数据类型。为了展示所需字段，手动计算结构的偏移量是必要的。
检测 `_do_wait()` 函数：
```
$ cat > kprobe_events <<EOF
p:wait_p do_wait wo_type=+0(%x0):u32 wo_flags=+4(%x0):u32
r:wait_r do_wait $retval
EOF
$ echo 1 > events/kprobes/enable
```
注意在第一个探针中使用的参数标签是可选的，并且可用于更清晰地识别记录在追踪日志中的信息。带符号的偏移量和括号表明了寄存器参数是指向记录在追踪日志中的内存内容的指针。`:u32` 表明了内存位置包含一个无符号的 4 字节宽的数据（在这个例子中指局部定义的结构中的一个 emum 和一个 int）。
探针标签（冒号后）是可选的，并且将用来识别日志中的探针。对每个探针来说标签必须是独一无二的。如果没有指定，将从附近的符号名称自动生成一个有用的标签，如前面的例子所示。
也要注意 `$retval` 参数可以只是指定为 `%x0`。
这里是两次 fork 系统调用执行后的 trace 文件的内容：
```
$ cat trace
# tracer: nop
#
# entries-in-buffer/entries-written: 4/4 #P:8
#
# _—–=> irqs-off
# / _—-=> need-resched
# | / _—=> hardirq/softirq
# || / _–=> preempt-depth
# ||| / delay
# TASK-PID CPU# |||| TIMESTAMP FUNCTION
# | | | |||| | |
bash-1702 [001] d… 175.342074: wait_p: (do_wait+0x0/0x260) wo_type=0x3 wo_flags=0xe
bash-1702 [002] d..1 175.347236: wait_r: (SyS_wait4+0x74/0xe4 <- do_wait) arg1=0x757
bash-1702 [002] d… 175.347337: wait_p: (do_wait+0x0/0x260) wo_type=0x3 wo_flags=0xf
bash-1702 [002] d..1 175.347349: wait_r: (SyS_wait4+0x74/0xe4 <- do_wait) arg1=0xfffffffffffffff6
```
#### 例子: 探测任意指令地址
在前面的例子中，我们已经为函数的入口和出口插入探针，然而探测一个任意指令（除少数例外）是可能的。如果我们正在 C 函数中放置一个探针，第一步是查看代码的汇编版本以确定我们要放置探针的位置。一种方法是在 vmlinux 文件上使用 gdb,并在要放置探针的函数中展示指令。下面是一个在 `arch/arm64/kernel/modules.c` 中 `module_alloc` 函数执行此操作的示例。在这种情况下，因为 gdb 似乎更喜欢使用弱符号定义，并且它是与这个函数关联的存根代码，所以我们从 System.map 中来获取符号值：
```
$ grep module_alloc System.map
ffff2000080951c4 T module_alloc
ffff200008297770 T kasan_module_alloc
```
在这个例子中我们使用了交叉开发工具，并且在我们的主机系统上调用 gdb 来检查指令包含我们感兴趣函数。
```
$ ${CROSS_COMPILE}gdb vmlinux
(gdb) x/30i 0xffff2000080951c4
0xffff2000080951c4 <module_alloc>: sub sp, sp, #0x30
0xffff2000080951c8 <module_alloc+4>: adrp x3, 0xffff200008d70000
0xffff2000080951cc <module_alloc+8>: add x3, x3, #0x0
0xffff2000080951d0 <module_alloc+12>: mov x5, #0x713 // #1811
0xffff2000080951d4 <module_alloc+16>: mov w4, #0xc0 // #192
0xffff2000080951d8 <module_alloc+20>:
mov x2, #0xfffffffff8000000 // #-134217728
0xffff2000080951dc <module_alloc+24>: stp x29, x30, [sp,#16] 0xffff2000080951e0 <module_alloc+28>: add x29, sp, #0x10
0xffff2000080951e4 <module_alloc+32>: movk x5, #0xc8, lsl #48
0xffff2000080951e8 <module_alloc+36>: movk w4, #0x240, lsl #16
0xffff2000080951ec <module_alloc+40>: str x30, [sp] 0xffff2000080951f0 <module_alloc+44>: mov w7, #0xffffffff // #-1
0xffff2000080951f4 <module_alloc+48>: mov x6, #0x0 // #0
0xffff2000080951f8 <module_alloc+52>: add x2, x3, x2
0xffff2000080951fc <module_alloc+56>: mov x1, #0x8000 // #32768
0xffff200008095200 <module_alloc+60>: stp x19, x20, [sp,#32] 0xffff200008095204 <module_alloc+64>: mov x20, x0
0xffff200008095208 <module_alloc+68>: bl 0xffff2000082737a8 <__vmalloc_node_range>
0xffff20000809520c <module_alloc+72>: mov x19, x0
0xffff200008095210 <module_alloc+76>: cbz x0, 0xffff200008095234 <module_alloc+112>
0xffff200008095214 <module_alloc+80>: mov x1, x20
0xffff200008095218 <module_alloc+84>: bl 0xffff200008297770 <kasan_module_alloc>
0xffff20000809521c <module_alloc+88>: tbnz w0, #31, 0xffff20000809524c <module_alloc+136>
0xffff200008095220 <module_alloc+92>: mov sp, x29
0xffff200008095224 <module_alloc+96>: mov x0, x19
0xffff200008095228 <module_alloc+100>: ldp x19, x20, [sp,#16] 0xffff20000809522c <module_alloc+104>: ldp x29, x30, [sp],#32
0xffff200008095230 <module_alloc+108>: ret
0xffff200008095234 <module_alloc+112>: mov sp, x29
0xffff200008095238 <module_alloc+116>: mov x19, #0x0 // #0
```
在这种情况下，我们将在此函数中显示以下源代码行的结果：
```
p = __vmalloc_node_range(size, MODULE_ALIGN, VMALLOC_START,
VMALLOC_END, GFP_KERNEL, PAGE_KERNEL_EXEC, 0,
NUMA_NO_NODE, __builtin_return_address(0));
```
……以及在此代码行的函数调用的返回值：
```
if (p && (kasan_module_alloc(p, size) < 0)) {
```
我们可以在从调用外部函数的汇编代码中识别这些。为了展示这些值，我们将在目标系统上的 `0xffff20000809520c` 和 `0xffff20000809521c` 处放置探针。
```
$ cat > kprobe_events <<EOF
p 0xffff20000809520c %x0
p 0xffff20000809521c %x0
EOF
$ echo 1 > events/kprobes/enable
```
现在将一个以太网适配器加密狗插入到 USB 端口后，我们看到以下写入追踪日志的内容：
```
$ cat trace
# tracer: nop
#
# entries-in-buffer/entries-written: 12/12 #P:8
#
# _—–=> irqs-off
# / _—-=> need-resched
# | / _—=> hardirq/softirq
# || / _–=> preempt-depth
# ||| / delay
# TASK-PID CPU# |||| TIMESTAMP FUNCTION
# | | | |||| | |
systemd-udevd-2082 [000] d… 77.200991: p_0xffff20000809520c: (module_alloc+0x48/0x98) arg1=0xffff200001188000
systemd-udevd-2082 [000] d… 77.201059: p_0xffff20000809521c: (module_alloc+0x58/0x98) arg1=0x0
systemd-udevd-2082 [000] d… 77.201115: p_0xffff20000809520c: (module_alloc+0x48/0x98) arg1=0xffff200001198000
systemd-udevd-2082 [000] d… 77.201157: p_0xffff20000809521c: (module_alloc+0x58/0x98) arg1=0x0
systemd-udevd-2082 [000] d… 77.227456: p_0xffff20000809520c: (module_alloc+0x48/0x98) arg1=0xffff2000011a0000
systemd-udevd-2082 [000] d… 77.227522: p_0xffff20000809521c: (module_alloc+0x58/0x98) arg1=0x0
systemd-udevd-2082 [000] d… 77.227579: p_0xffff20000809520c: (module_alloc+0x48/0x98) arg1=0xffff2000011b0000
systemd-udevd-2082 [000] d… 77.227635: p_0xffff20000809521c: (module_alloc+0x58/0x98) arg1=0x0
modprobe-2097 [002] d… 78.030643: p_0xffff20000809520c: (module_alloc+0x48/0x98) arg1=0xffff2000011b8000
modprobe-2097 [002] d… 78.030761: p_0xffff20000809521c: (module_alloc+0x58/0x98) arg1=0x0
modprobe-2097 [002] d… 78.031132: p_0xffff20000809520c: (module_alloc+0x48/0x98) arg1=0xffff200001270000
modprobe-2097 [002] d… 78.031187: p_0xffff20000809521c: (module_alloc+0x58/0x98) arg1=0x0
```
kprobes 事件系统的另一个功能是记录统计信息，这可在 `inkprobe_profile` 中找到。在以上追踪后，该文件的内容为：
```
$ cat kprobe_profile
p_0xffff20000809520c 6 0
p_0xffff20000809521c 6 0
```
这表明我们设置的两处断点每个共发生了 8 次命中，这当然与追踪日志数据是一致的。在 kprobetrace 文档中有更多 kprobe\_profile 的功能描述。
也可以进一步过滤 kprobes 事件。用来控制这点的 debugfs 文件在 kprobetrace 文档中被列出，然而它们内容的详细信息大多在 trace events 文档中被描述。
### 总结
现在，Linux ARMv8 对支持 kprobes 功能也和其它架构相当。有人正在做添加 uprobes 和 systemtap 支持的工作。这些功能/工具和其他已经完成的功能（如： perf、 coresight）允许 Linux ARMv8 用户像在其它更老的架构上一样调试和测试性能。
---
参考文献
* 注1： Jim Keniston, Prasanna S. Panchamukhi, Masami Hiramatsu. “Kernel Probes (kprobes).” *GitHub*. GitHub, Inc., 15 Aug. 2016. Web. 13 Dec. 2016.
* 注2： Ts’o, Theodore, Li Zefan, and Tom Zanussi. “Event Tracing.” *GitHub*. GitHub, Inc., 3 Mar. 2016. Web. 13 Dec. 2016.
* 注3： Hiramatsu, Masami. “Kprobe-based Event Tracing.” *GitHub*. GitHub, Inc., 18 Aug. 2016. Web. 13 Dec. 2016.
---
作者简介 ： [David Long](http://www.linaro.org/author/david-long/) 在 Linaro Kernel - Core Development 团队中担任工程师。 在加入 Linaro 之前，他在商业和国防行业工作了数年，既做嵌入式实时工作又为Unix提供软件开发工具。之后，在 Digital（又名 Compaq）公司工作了十几年，负责 Unix 标准，C 编译器和运行时库的工作。之后 David 又去了一系列初创公司做嵌入式 Linux 和安卓系统，嵌入式定制操作系统和 Xen 虚拟化。他拥有 MIPS，Alpha 和 ARM 平台的经验（等等）。他使用过从 1979 年贝尔实验室 V6 开始的大部分Unix操作系统，并且长期以来一直是 Linux 用户和倡导者。他偶尔也因使用烙铁和数字示波器调试设备驱动而知名。
---
via: <http://www.linaro.org/blog/kprobes-event-tracing-armv8/>
作者：[David Long](http://www.linaro.org/author/david-long/) 译者：[kimii](https://github.com/kimii) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
检查 Linux 系统上的网络连接
|
Sandra Henry-stocker
|
https://www.networkworld.com/article/3230519/linux/examining-network-connections-on-linux-systems.html
|
Linux 系统提供了许多有用的命令来检查网络配置和连接。下面来看几个，包括 ifquery、ifup、ifdown 和 ifconfig。
|
/data/attachment/album/201712/01/201507wrds6brsa7aq7sdd.jpeg.thumb.jpg
|
/data/attachment/album/201712/01/201507wrds6brsa7aq7sdd.jpeg
| true | false | true |
geekpi
| false |
[
"网络",
"网卡"
] |
系统运维
|
{
"viewnum": 20116,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Linux 系统提供了许多有用的命令来检查网络配置和连接。下面来看几个，包括 ifquery、ifup、ifdown 和 ifconfig。
| 2017-12-01T20:15:17 | 2017-12-01T20:15:17 | 9,099 |
/article-9099-1.html
|
>
> Linux 系统提供了许多有用的命令来检查网络配置和连接。下面来看几个，包括 `ifquery`、`ifup`、`ifdown` 和 `ifconfig`。
>
>
>
Linux 上有许多可用于查看网络设置和连接的命令。在今天的文章中，我们将会通过一些非常方便的命令来看看它们是如何工作的。
### ifquery 命令
一个非常有用的命令是 `ifquery`。这个命令应该会显示一个网络接口列表。但是，你可能只会看到类似这样的内容 - 仅显示回环接口：
```
$ ifquery --list
lo
```
如果是这种情况，那说明你的 `/etc/network/interfaces` 不包括除了回环接口之外的网络接口信息。在下面的例子中，假设你使用 DHCP 来分配地址，且如果你希望它更有用的话，你可以添加例子最后的两行。
```
# interfaces(5) file used by ifup(8) and ifdown(8)
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet dhcp
```
### ifup 和 ifdown 命令
可以使用相关的 `ifup` 和 `ifdown` 命令来打开网络连接并根据需要将其关闭，只要该文件具有所需的描述性数据即可。请记住，“if” 在这里意思是<ruby> 接口 <rt> interface </rt></ruby>，这与 `ifconfig` 命令中的一样，而不是<ruby> 如果我只有一个大脑 <rt> if I only had a brain </rt></ruby> 中的 “if”。
### ifconfig 命令
另外，`ifconfig` 命令完全不读取 `/etc/network/interfaces`，但是仍然提供了网络接口相当多的有用信息 —— 配置数据以及可以告诉你每个接口有多忙的数据包计数。`ifconfig` 命令也可用于关闭和重新启动网络接口（例如：`ifconfig eth0 down`）。
```
$ ifconfig eth0
eth0 Link encap:Ethernet HWaddr 00:1e:4f:c8:43:fc
inet addr:192.168.0.6 Bcast:192.168.0.255 Mask:255.255.255.0
inet6 addr: fe80::b44b:bdb6:2527:6ae9/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:60474 errors:0 dropped:0 overruns:0 frame:0
TX packets:33463 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:43922053 (43.9 MB) TX bytes:4000460 (4.0 MB)
Interrupt:21 Memory:fe9e0000-fea00000
```
输出中的 RX 和 TX 数据包计数很低。此外，没有报告错误或数据包冲突。或许可以用 `uptime` 命令确认此系统最近才重新启动。
上面显示的广播 （Bcast） 和网络掩码 （Mask） 地址表明系统运行在 C 类等效网络（默认）上，所以本地地址范围从 `192.168.0.1` 到 `192.168.0.254`。
### netstat 命令
`netstat` 命令提供有关路由和网络连接的信息。`netstat -rn` 命令显示系统的路由表。192.168.0.1 是本地网关 （Flags=UG)。
```
$ netstat -rn
Kernel IP routing table
Destination Gateway Genmask Flags MSS Window irtt Iface
0.0.0.0 192.168.0.1 0.0.0.0 UG 0 0 0 eth0
169.254.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0
192.168.0.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0
```
上面输出中的 `169.254.0.0` 条目仅在你正在使用或计划使用本地链路通信时才有必要。如果不是这样的话，你可以在 `/etc/network/if-up.d/avahi-autoipd` 中注释掉相关的行：
```
$ tail -12 /etc/network/if-up.d/avahi-autoipd
#if [ -x /bin/ip ]; then
# # route already present?
# ip route show | grep -q '^169.254.0.0/16[[:space:]]' && exit 0
#
# /bin/ip route add 169.254.0.0/16 dev $IFACE metric 1000 scope link
#elif [ -x /sbin/route ]; then
# # route already present?
# /sbin/route -n | egrep -q "^169.254.0.0[[:space:]]" && exit 0
#
# /sbin/route add -net 169.254.0.0 netmask 255.255.0.0 dev $IFACE metric 1000
#fi
```
### netstat -a 命令
`netstat -a` 命令将显示“所有”网络连接。为了将其限制为显示正在监听和已建立的连接（通常更有用），请改用 `netstat -at` 命令。
```
$ netstat -at
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 *:ssh *:* LISTEN
tcp 0 0 localhost:ipp *:* LISTEN
tcp 0 0 localhost:smtp *:* LISTEN
tcp 0 256 192.168.0.6:ssh 192.168.0.32:53550 ESTABLISHED
tcp6 0 0 [::]:http [::]:* LISTEN
tcp6 0 0 [::]:ssh [::]:* LISTEN
tcp6 0 0 ip6-localhost:ipp [::]:* LISTEN
tcp6 0 0 ip6-localhost:smtp [::]:* LISTEN
```
### host 命令
`host` 命令就像 `nslookup` 一样，用来查询远程系统的 IP 地址，但是还提供系统的邮箱处理地址。
```
$ host world.std.com
world.std.com has address 192.74.137.5
world.std.com mail is handled by 10 smtp.theworld.com.
```
### nslookup 命令
`nslookup` 还提供系统中（本例中是本地系统）提供 DNS 查询服务的信息。
```
$ nslookup world.std.com
Server: 127.0.1.1
Address: 127.0.1.1#53
Non-authoritative answer:
Name: world.std.com
Address: 192.74.137.5
```
### dig 命令
`dig` 命令提供了很多有关连接到远程系统的信息 - 包括与我们通信的名称服务器以及查询需要多长时间进行响应，并经常用于故障排除。
```
$ dig world.std.com
; <<>> DiG 9.10.3-P4-Ubuntu <<>> world.std.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 28679
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;world.std.com. IN A
;; ANSWER SECTION:
world.std.com. 78146 IN A 192.74.137.5
;; Query time: 37 msec
;; SERVER: 127.0.1.1#53(127.0.1.1)
;; WHEN: Mon Oct 09 13:26:46 EDT 2017
;; MSG SIZE rcvd: 58
```
### nmap 命令
`nmap` 经常用于探查远程系统，但是同样也用于报告本地系统提供的服务。在下面的输出中，我们可以看到登录可以使用 ssh、smtp 用于电子邮箱、web 站点也是启用的，并且 ipp 打印服务正在运行。
```
$ nmap localhost
Starting Nmap 7.01 ( https://nmap.org ) at 2017-10-09 15:01 EDT
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00016s latency).
Not shown: 996 closed ports
PORT STATE SERVICE
22/tcp open ssh
25/tcp open smtp
80/tcp open http
631/tcp open ipp
Nmap done: 1 IP address (1 host up) scanned in 0.09 seconds
```
Linux 系统提供了很多有用的命令用于查看网络配置和连接。如果你都探索完了，请记住 `apropos network` 或许会让你了解更多。
---
via: <https://www.networkworld.com/article/3230519/linux/examining-network-connections-on-linux-systems.html>
作者：[Sandra Henry-Stocker](https://www.networkworld.com/author/Sandra-Henry_Stocker/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 下安装安卓文件传输助手
|
Joey Sneddon
|
http://www.omgubuntu.co.uk/2017/11/android-file-transfer-app-linux
|
如果你尝试在 Ubuntu 下连接你的安卓手机，你也许可以试试 Linux 下的安卓文件传输助手。
|
/data/attachment/album/201712/03/104921py9cpjjbmdmvzya2.jpg.thumb.jpg
|
/data/attachment/album/201712/03/104921py9cpjjbmdmvzya2.jpg
| true | false | true |
wenwensnow
| false |
[
"Android"
] |
桌面应用
|
{
"viewnum": 7394,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你尝试在 Ubuntu 下连接你的安卓手机，你也许可以试试 Linux 下的安卓文件传输助手。
| 2017-12-03T10:48:00 | 2017-12-03T10:48:00 | 9,100 |
/article-9100-1.html
|
如果你尝试在 Ubuntu 下连接你的安卓手机，你也许可以试试 Linux 下的安卓文件传输助手。
本质上来说，这个应用是谷歌 macOS 版本的一个克隆。它是用 Qt 编写的，用户界面非常简洁，使得你能轻松在 Ubuntu 和安卓手机之间传输文件和文件夹。
现在，有可能一部分人想知道有什么是这个应用可以做，而 Nautilus（Ubuntu 默认的文件资源管理器）不能做的，答案是没有。
当我将我的 Nexus 5X（记得选择 [媒体传输协议 MTP](https://en.wikipedia.org/wiki/Media_Transfer_Protocol) 选项）连接在 Ubuntu 上时，在 [GVfs](https://en.wikipedia.org/wiki/GVfs)（LCTT 译注： GNOME 桌面下的虚拟文件系统）的帮助下，我可以打开、浏览和管理我的手机，就像它是一个普通的 U 盘一样。
[](http://www.omgubuntu.co.uk/wp-content/uploads/2017/11/browsing-android-mtp-nautilus.jpg)
但是*一些*用户在使用默认的文件管理器时，在 MTP 的某些功能上会出现问题：比如文件夹没有正确加载，创建新文件夹后此文件夹不存在，或者无法在媒体播放器中使用自己的手机。
这就是要为 Linux 系统用户设计一个安卓文件传输助手应用的原因，将这个应用当做将 MTP 设备安装在 Linux 下的另一种选择。如果你使用 Linux 下的默认应用时一切正常，你也许并不需要尝试使用它 (除非你真的很想尝试新鲜事物)。
该 app 特点：
* 简洁直观的用户界面
* 支持文件拖放功能（从 Linux 系统到手机）
* 支持批量下载 (从手机到 Linux系统)
* 显示传输进程对话框
* FUSE 模块支持
* 没有文件大小限制
* 可选命令行工具
### Ubuntu 下安装安卓手机文件助手的步骤
以上就是对这个应用的介绍，下面是如何安装它的具体步骤。
这有一个 [PPA]（个人软件包集）源为 Ubuntu 14.04 LTS、16.04 LTS 和 Ubuntu 17.10 提供可用应用。
为了将这一 PPA 加入你的软件资源列表中，执行这条命令：
```
sudo add-apt-repository ppa:samoilov-lex/aftl-stable
```
接着，为了在 Ubuntu 下安装 Linux版本的安卓文件传输助手，执行：
```
sudo apt-get update && sudo apt install android-file-transfer
```
这样就行了。
你会在你的应用列表中发现这一应用的启动图标。
在你启动这一应用之前，要确保没有其他应用（比如 Nautilus）已经挂载了你的手机。如果其它应用正在使用你的手机，就会显示“无法找到 MTP 设备”。要解决这一问题，将你的手机从 Nautilus（或者任何正在使用你的手机的应用）上移除，然后再重新启动安卓文件传输助手。
---
via: <http://www.omgubuntu.co.uk/2017/11/android-file-transfer-app-linux>
作者：[JOEY SNEDDON](https://plus.google.com/117485690627814051450/?rel=author) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
开源云技能认证：系统管理员的核心竞争力
|
Linux.com
|
https://www.linux.com/blog/open-source-cloud-skills-and-certification-are-key-sysadmins
|
总的来说，今年的报告指出开源领域人才需求最大的有开源云（47%），应用开发（44%），大数据（43%），开发运营和安全（42%）。
|
/data/attachment/album/201712/03/105709hqovjlzrh9rd49jy.jpg.thumb.jpg
|
/data/attachment/album/201712/03/105709hqovjlzrh9rd49jy.jpg
| true | false | true |
wangy325
| false |
[
"开源云",
"系统管理员"
] |
观点
|
{
"viewnum": 4299,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
总的来说，今年的报告指出开源领域人才需求最大的有开源云（47%），应用开发（44%），大数据（43%），开发运营和安全（42%）。
| 2017-12-03T10:57:07 | 2017-12-03T10:57:07 | 9,101 |
/article-9101-1.html
|
>
> [2017年开源工作报告](https://www.linuxfoundation.org/blog/2017-jobs-report-highlights-demand-open-source-skills/)（以下简称“报告”）显示，具有开源云技术认证的系统管理员往往能获得更高的薪酬。
>
>
>
报告调查的受访者中，53% 认为系统管理员是雇主们最期望被填补的职位空缺之一，因此，技术娴熟的系统管理员更受青睐而收获高薪职位，但这一职位，并没想象中那么容易填补。
系统管理员主要负责服务器和其他电脑操作系统的安装、服务支持和维护，及时处理服务中断和预防其他问题的出现。
总的来说，今年的报告指出开源领域人才需求最大的有开源云（47%），应用开发（44%），大数据（43%），开发运营和安全（42%）。
此外，报告对人事经理的调查显示，58% 期望招揽更多的开源人才，67% 认为开源人才的需求增长会比业内其他领域更甚。有些单位视开源人才为招聘最优选则，它们招聘的开源人才较上年增长了 2 个百分点。
同时，89% 的人事经理认为很难找到颇具天赋的开源人才。
### 为什么要获取认证
报告显示，对系统管理员的需求刺激着人事经理为 53% 的组织/机构提供正规的培训和专业技术认证，而这一比例去年为 47%。
对系统管理方面感兴趣的 IT 人才考虑获取 Linux 认证已成为行业规律。随便查看几个知名的招聘网站，你就能发现：[CompTIA Linux+](https://certification.comptia.org/certifications/linux?tracking=getCertified/certifications/linux.aspx) 认证是入门级 Linux 系统管理员的最高认证；如果想胜任高级别的系统管理员职位，获取[红帽认证工程师（RHCE）](https://www.redhat.com/en/services/certification/rhce)和[红帽认证系统管理员（RHCSA）](https://www.redhat.com/en/services/certification/rhcsa)则是不可或缺的。
戴士（Dice）[2017 技术行业薪资调查](http://marketing.dice.com/pdf/Dice_TechSalarySurvey_2017.pdf?aliId=105832232)显示，2016 年系统管理员的薪水为 79,538 美元，较上年下降了 0.8%；系统架构师的薪水为 125,946 美元，同比下降 4.7%。尽管如此，该调查发现“高水平专业人才仍最受欢迎，特别是那些精通支持产业转型发展所需技术的人才”。
在开源技术方面，HBase（一个开源的分布式数据库）技术人才的薪水在戴士 2017 技术行业薪资调查中排第一。在计算机网络和数据库领域，掌握 OpenVMS 操作系统技术也能获得高薪。
### 成为出色的系统管理员
出色的系统管理员须在问题出现时马上处理，这意味着你必须时刻准备应对可能出现的状况。这个职位追求“零责备的、精益的、流程或技术上交互式改进的”思维方式和善于自我完善的人格，成为一个系统管理员意味着“你必将与开源软件如 Linux、BSD 甚至开源 Solaris 等结下不解之缘”，Paul English <sup> 译注1</sup> 在 [opensource.com](https://opensource.com/article/17/7/truth-about-sysadmins) 上发文指出。
Paul English 认为，现在的系统管理员较以前而言，要更多地与软件打交道，而且要能够编写脚本来协助系统管理。
>
> 译注1：Paul English，计算机科学学士，UNIX/Linux 系统管理员，PreOS Security Inc. 公司 CEO，2015-2017 年于为推动系统管理员发展实践的非盈利组织——<ruby> 专业系统管理员联盟 <rt> League of Professional System Administrator </rt></ruby>担任董事会成员。
>
>
>
### 展望 2018
[Robert Half 2018 年技术人才薪资导览](https://www.roberthalf.com/salary-guide/technology)预测 2018 年北美地区许多单位将聘用大量系统管理方面的专业人才，同时个人软实力和领导力水平作为优秀人才的考量因素，越来越受到重视。
该报告指出：“良好的聆听能力和批判性思维能力对于理解和解决用户的问题和担忧至关重要，也是 IT 从业者必须具备的重要技能，特别是从事服务台和桌面支持工作相关的技术人员。”
这与[Linux基金会](https://www.linux.com/learn/10-essential-skills-novice-junior-and-senior-sysadmins%20%20)<sup> 译注2</sup> 提出的不同阶段的系统管理员必备技能相一致，都强调了强大的分析能力和快速处理问题的能力。
>
> 译注2：<ruby> Linux 基金会 <rt> The Linux Foundation </rt></ruby>，成立于 2000 年，致力于围绕开源项目构建可持续发展的生态系统，以加速开源项目的技术开发和商业应用；它是世界上最大的开源非盈利组织，在推广、保护和推进 Linux 发展，协同开发，维护“历史上最大的共享资源”上功勋卓越。
>
>
>
如果想逐渐爬上系统管理员职位的金字塔上层，还应该对系统配置的结构化方法充满兴趣；且拥有解决系统安全问题的经验；用户身份验证管理的经验；与非技术人员进行非技术交流的能力；以及优化系统以满足最新的安全需求的能力。
* [下载](http://bit.ly/2017OSSjobsreport)2017年开源工作报告全文，以获取更多信息。
---
via: <https://www.linux.com/blog/open-source-cloud-skills-and-certification-are-key-sysadmins>
作者：[linux.com](https://www.linux.com/blog/open-source-cloud-skills-and-certification-are-key-sysadmins) 译者：[wangy325](https://github.com/wangy325) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在命令行中使用 DuckDuckGo 搜索
|
Joey Sneddon
|
http://www.omgubuntu.co.uk/2017/11/duck-duck-go-terminal-app
|
像 Googler 一样，ddgr 是一个完全开源而且非官方的工具。没错，它并不属于 DuckDuckGo。所以，如果你发现它返回的结果有些奇怪，请先询问这个工具的开发者，而不是搜索引擎的开发者。
|
/data/attachment/album/201712/03/110113cfcblroim9qorqlq.png.thumb.jpg
|
/data/attachment/album/201712/03/110113cfcblroim9qorqlq.png
| true | false | true |
yixunx
| false |
[
"DuckDuckGo",
"搜索引擎"
] |
桌面应用
|
{
"viewnum": 7222,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
像 Googler 一样，ddgr 是一个完全开源而且非官方的工具。没错，它并不属于 DuckDuckGo。所以，如果你发现它返回的结果有些奇怪，请先询问这个工具的开发者，而不是搜索引擎的开发者。
| 2017-12-03T11:01:12 | 2017-12-03T11:01:12 | 9,102 |
/article-9102-1.html
|
此前我们介绍了[如何在命令行中使用 Google 搜索](http://www.omgubuntu.co.uk/2017/08/search-google-from-the-command-line)。许多读者反馈说他们平时使用 [Duck Duck Go](http://duckduckgo.com/)，这是一个功能强大而且保密性很强的搜索引擎。
正巧，最近出现了一款能够从命令行搜索 DuckDuckGo 的工具。它叫做 ddgr（我把它读作 “dodger”），非常好用。
像 [Googler](https://github.com/jarun/googler) 一样，ddgr 是一个完全开源而且非官方的工具。没错，它并不属于 DuckDuckGo。所以，如果你发现它返回的结果有些奇怪，请先询问这个工具的开发者，而不是搜索引擎的开发者。
### DuckDuckGo 命令行应用
[DuckDuckGo Bangs（DuckDuckGo 快捷搜索）](https://duckduckgo.com/bang) 可以帮助你轻易地在 DuckDuckGo 上找到想要的信息（甚至 *本网站 omgubuntu* 都有快捷搜索）。ddgr 非常忠实地呈现了这个功能。
和网页版不同的是，你可以更改每页返回多少结果。这比起每次查询都要看三十多条结果要方便一些。默认界面经过了精心设计，在不影响可读性的情况下尽量减少了占用空间。
`ddgr` 有许多功能和亮点，包括：
* 更改搜索结果数
* 支持 Bash 自动补全
* 使用 DuckDuckGo Bangs
* 在浏览器中打开链接
* ”手气不错“选项
* 基于时间、地区、文件类型等的筛选功能
* 极少的依赖项
你可以从 Github 的项目页面上下载支持各种系统的 `ddgr`：
* [从 Github 下载 “ddgr”](https://github.com/jarun/ddgr/releases/tag/v1.1)
另外，在 Ubuntu 16.04 LTS 或更新版本中，你可以使用 PPA 安装 ddgr。这个仓库由 ddgr 的开发者维护。如果你想要保持在最新版本的话，推荐使用这种方式安装。
需要提醒的是，在本文创作时，这个 PPA 中的 ddgr *并不是* 最新版本，而是一个稍旧的版本（缺少 -num 选项）。
使用以下命令添加 PPA：
```
sudo add-apt-repository ppa:twodopeshaggy/jarun
sudo apt-get update
```
### 如何使用 ddgr 在命令行中搜索 DuckDuckGo
安装完毕后，你只需打开你的终端模拟器，并运行：
```
ddgr
```
然后输入查询内容：
```
search-term
```
你可以限制搜索结果数：
```
ddgr --num 5 search-term
```
或者自动在浏览器中打开第一条搜索结果：
```
ddgr -j search-term
```
你可以使用参数和选项来提高搜索精确度。使用以下命令来查看所有的参数：
```
ddgr -h
```
---
via: <http://www.omgubuntu.co.uk/2017/11/duck-duck-go-terminal-app>
作者：[JOEY SNEDDON](https://plus.google.com/117485690627814051450/?rel=author) 译者：[yixunx](https://github.com/yixunx) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
回复：块层介绍第一部分 - 块 I/O 层
|
Neilbrown
|
https://lwn.net/Articles/737655/
|
你在这里描述的问题与块层不直接相关。这可能是一个驱动错误、可能是一个 SCSI 层错误，但绝对不是一个块层的问题。
|
/data/attachment/album/201712/03/111453ac1rfngngbnb2fct.png.thumb.jpg
|
/data/attachment/album/201712/03/111453ac1rfngngbnb2fct.png
| true | false | true |
geekpi
| false |
[
"内核"
] |
技术
|
{
"viewnum": 3484,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你在这里描述的问题与块层不直接相关。这可能是一个驱动错误、可能是一个 SCSI 层错误，但绝对不是一个块层的问题。
| 2017-12-03T11:14:00 | 2017-12-03T11:14:00 | 9,103 |
/article-9103-1.html
|
回复：amarao 在[块层介绍第一部分：块 I/O 层](https://lwn.net/Articles/737588/) 中提的问题
先前的文章：[块层介绍第一部分：块 I/O 层](https://lwn.net/Articles/736534/)
嗨，
你在这里描述的问题与块层不直接相关。这可能是一个驱动错误、可能是一个 SCSI 层错误，但绝对不是一个块层的问题。
不幸的是，报告针对 Linux 的错误是一件难事。有些开发者拒绝去看 bugzilla，有些开发者喜欢它，有些（像我这样）只能勉强地使用它。
另一种方法是发送电子邮件。为此，你需要选择正确的邮件列表，还有也许是正确的开发人员，当他们心情愉快，或者不是太忙或者不是假期时找到它们。有些人会努力回复所有，有些是完全不可预知的 - 这对我来说通常会发送一个补丁，包含一些错误报告。如果你只是有一个你自己几乎都不了解的 bug，那么你的预期响应率可能会更低。很遗憾，但这是是真的。
许多 bug 都会得到回应和处理，但很多 bug 都没有。
我不认为说没有人关心是公平的，但是没有人认为它如你想的那样重要是有可能的。如果你想要一个解决方案，那么你需要驱动它。一个驱动它的方法是花钱请顾问或者与经销商签订支持合同。我怀疑你的情况没有上面的可能。另一种方法是了解代码如何工作，并自己找到解决方案。很多人都这么做，但是这对你来说可能不是一种选择。另一种方法是在不同的相关论坛上不断提出问题，直到得到回复。坚持可以见效。你需要做好准备去执行任何你所要求的测试，可能包括建立一个新的内核来测试。
如果你能在最近的内核(4.12 或者更新)上复现这个 bug，我建议你邮件报告给 [linux-kernel@vger.kernel.org](mailto:linux-kernel@vger.kernel.org)、[linux-scsi@vger.kernel.org](mailto:linux-scsi@vger.kernel.org) 和我（[neilb@suse.com](mailto:neilb@suse.com)）（注意你不必订阅这些列表来发送邮件，只需要发送就行）。描述你的硬件以及如何触发问题的。
包含所有进程状态是 “D” 的栈追踪。你可以用 “cat /proc/$PID/stack” 来得到它，这里的 “$PID” 是进程的 pid。
确保避免抱怨或者说这个已经坏了好几年了以及这是多么严重不足。没有人关心这个。我们关心的是 bug 以及如何修复它。因此只要报告相关的事实就行。
尝试在邮件中而不是链接到其他地方的链接中包含所有事实。有时链接是需要的，但是对于你的脚本，它只有 8 行，所以把它包含在邮件中就行（并避免像 “fuckup” 之类的描述。只需称它为<ruby> “坏的” <rp> （ </rp> <rt> broken </rt> <rp> ） </rp></ruby>或者类似的）。同样确保你的邮件发送的不是 HTML 格式。我们喜欢纯文本。HTML 被所有的 @vger.kernel.org 邮件列表拒绝。你或许需要配置你的邮箱程序不发送 HTML。
---
via: <https://lwn.net/Articles/737655/>
作者：[neilbrown](https://lwn.net/Articles/737655/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
容器技术和 K8S 的下一站
|
Kevin Casey
|
https://enterprisersproject.com/article/2017/11/containers-and-kubernetes-whats-next
|
想知道容器编排管理和 K8S 的最新展望么？来看看专家怎么说。
|
/data/attachment/album/201712/03/175452doyee18n18zse88f.png.thumb.jpg
|
/data/attachment/album/201712/03/175452doyee18n18zse88f.png
| true | false | true |
yunfengHe
| false |
[
"容器",
"编排"
] |
观点
|
{
"viewnum": 5268,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
想知道容器编排管理和 K8S 的最新展望么？来看看专家怎么说。
| 2017-12-03T17:54:47 | 2017-12-03T17:54:47 | 9,104 |
/article-9104-1.html
|
>
> 想知道容器编排管理和 K8S 的最新展望么？来看看专家怎么说。
>
>
>
如果你想对容器在未来的发展方向有一个整体把握，那么你一定要跟着钱走，看看钱都投在了哪里。当然了，有很多很多的钱正在投入容器的进一步发展。相关研究预计 2020 年容器技术的投入将占有 [27 亿美元](https://451research.com/images/Marketing/press_releases/Application-container-market-will-reach-2-7bn-in-2020_final_graphic.pdf) 的市场份额。而在 2016 年，容器相关技术投入的总额为 7.62 亿美元，只有 2020 年投入预计的三分之一。巨额投入的背后是一些显而易见的基本因素，包括容器化的迅速增长以及并行化的大趋势。随着容器被大面积推广和使用，容器编排管理也会被理所当然的推广应用起来。
来自 [The new stack](https://thenewstack.io/) 的调研数据表明，容器的推广使用是编排管理被推广的主要的催化剂。根据调研参与者的反馈数据，在已经将容器技术使用到生产环境中的使用者里，有六成使用者正在将 Kubernetes（K8S）编排管理广泛的应用在生产环境中，另外百分之十九的人员则表示他们已经处于部署 K8S 的初级阶段。在容器部署初期的使用者当中，虽然只有百分之五的人员表示已经在使用 K8S ，但是百分之五十八的人员表示他们正在计划和准备使用 K8S。总而言之，容器和 Kubernetes 的关系就好比是鸡和蛋一样，相辅相成紧密关联。众多专家一致认为编排管理工具对容器的[长周期管理](https://enterprisersproject.com/article/2017/10/microservices-and-containers-6-management-tips-long-haul) 以及其在市场中的发展有至关重要的作用。正如 [Cockroach 实验室](https://www.cockroachlabs.com/) 的 Alex Robinson 所说，容器编排管理被更广泛的拓展和应用是一个总体的大趋势。毫无疑问，这是一个正在快速演变的领域，且未来潜力无穷。鉴于此，我们对 Robinson 和其他的一些容器的实际使用和推介者做了采访，来从他们作为容器技术的践行者的视角上展望一下容器编排以及 K8S 的下一步发展。
### 容器编排将被主流接受
像任何重要技术的转型一样，我们就像是处在一个高崖之上一般，在经过了初期步履蹒跚的跋涉之后将要来到一望无际的广袤平原。广大的新天地和平实真切的应用需求将会让这种新技术在主流应用中被迅速推广，尤其是在大企业环境中。正如 Alex Robinson 说的那样，容器技术的淘金阶段已经过去，早期的技术革新创新正在减速，随之而来的则是市场对容器技术的稳定性和可用性的强烈需求。这意味着未来我们将不会再见到大量的新的编排管理系统的涌现，而是会看到容器技术方面更多的安全解决方案，更丰富的管理工具，以及基于目前主流容器编排系统的更多的新特性。
### 更好的易用性
人们将在简化容器的部署方面下大功夫，因为容器部署的初期工作对很多公司和组织来说还是比较复杂的，尤其是容器的[长期管理维护](https://enterprisersproject.com/article/2017/10/microservices-and-containers-6-management-tips-long-haul)更是需要投入大量的精力。正如 [Codemill AB](https://codemill.se/) 公司的 My Karlsson 所说，容器编排技术还是太复杂了，这导致很多使用者难以娴熟驾驭和充分利用容器编排的功能。很多容器技术的新用户都需要花费很多精力，走很多弯路，才能搭建小规模的或单个的以隔离方式运行的容器系统。这种现象在那些没有针对容器技术设计和优化的应用中更为明显。在简化容器编排管理方面有很多优化可以做，这些优化和改造将会使容器技术更加具有可用性。
### 在混合云以及多云技术方面会有更多侧重
随着容器和容器编排技术被越来越多的使用，更多的组织机构会选择扩展他们现有的容器技术的部署，从之前的把非重要系统部署在单一环境的使用情景逐渐过渡到更加[复杂的使用情景](https://www.redhat.com/en/challenges/integration?intcmp=701f2000000tjyaAAA)。对很多公司来说，这意味着他们必须开始学会在 [混合云](https://enterprisersproject.com/hybrid-cloud) 和 [多云](https://enterprisersproject.com/article/2017/7/multi-cloud-vs-hybrid-cloud-whats-difference) 的环境下，全局化的去管理那些容器化的应用和微服务。正如红帽 [Openshift 部门产品战略总监](https://www.redhat.com/en) [Brian Gracely](https://enterprisersproject.com/user/brian-gracely) 所说，“容器和 K8S 技术的使用使得我们成功的实现了混合云以及应用的可移植性。结合 Open Service Broker API 的使用，越来越多的结合私有云和公有云资源的新应用将会涌现出来。” 据 [CloudBees](https://www.cloudbees.com/) 公司的高级工程师 Carlos Sanchez 分析，联合服务（Federation）将会得到极大推动，使一些诸如多地区部署和多云部署等的备受期待的新特性成为可能。
**[ 想知道 CIO 们对混合云和多云的战略构想么? 请参看我们的这条相关资源， [Hybrid Cloud: The IT leader's guide](https://enterprisersproject.com/hybrid-cloud?sc_cid=70160000000h0aXAAQ)。 ]**
### 平台和工具的持续整合及加强
对任何一种科技来说，持续的整合和加强从来都是大势所趋；容器编排管理技术在这方面也不例外。来自 [Sumo Logic](https://www.sumologic.com/) 的首席分析师 Ben Newton 表示，随着容器化渐成主流，软件工程师们正在很少数的一些技术上做持续整合加固的工作，来满足他们的一些微应用的需求。容器和 K8S 将会毫无疑问的成为容器编排管理方面的主流平台，并轻松碾压其它的一些小众平台方案。因为 K8S 提供了一个相当清晰的可以摆脱各种特有云生态的途径，K8S 将被大量公司使用，逐渐形成一个不依赖于某个特定云服务的<ruby> “中立云” <rt> cloud-neutral </rt></ruby>。
### K8S 的下一站
来自 [Alcide](http://alcide.io/) 的 CTO 和联合创始人 Gadi Naor 表示，K8S 将会是一个有长期和远景发展的技术，虽然我们的社区正在大力推广和发展 K8S，K8S 仍有很长的路要走。
专家们对[日益流行的 K8S 平台](https://enterprisersproject.com/article/2017/10/how-explain-kubernetes-plain-english)也作出了以下一些预测：
***来自 Alcide 的 Gadi Naor 表示：*** “运营商会持续演进并趋于成熟，直到在 K8S 上运行的应用可以完全自治。利用 [OpenTracing](http://opentracing.io/) 和诸如 [istio](https://istio.io/) 技术的 service mesh 架构，在 K8S 上部署和监控微应用将会带来很多新的可能性。”
***来自 Red Hat 的 Brian Gracely 表示：*** “K8S 所支持的应用的种类越来越多。今后在 K8S 上，你不仅可以运行传统的应用程序，还可以运行原生的云应用、大数据应用以及 HPC 或者基于 GPU 运算的应用程序，这将为灵活的架构设计带来无限可能。”
***来自 Sumo Logic 的 Ben Newton 表示：*** “随着 K8S 成为一个具有统治地位的平台，我预计更多的操作机制将会被统一化，尤其是 K8S 将和第三方管理和监控平台融合起来。”
***来自 CloudBees 的 Carlos Sanchez 表示：*** “在不久的将来我们就能看到不依赖于 Docker 而使用其它运行时环境的系统，这将会有助于消除任何可能的 lock-in 情景“ [编辑提示：[CRI-O](http://cri-o.io/) 就是一个可以借鉴的例子。]“而且我期待将来会出现更多的针对企业环境的存储服务新特性，包括数据快照以及在线的磁盘容量的扩展。”
***来自 Cockroach Labs 的 Alex Robinson 表示：*** “ K8S 社区正在讨论的一个重大发展议题就是加强对[有状态程序](https://opensource.com/article/17/2/stateful-applications)的管理。目前在 K8S 平台下，实现状态管理仍然非常困难，除非你所使用的云服务商可以提供远程固定磁盘。现阶段也有很多人在多方面试图改善这个状况，包括在 K8S 平台内部以及在外部服务商一端做出的一些改进。”
---
via: <https://enterprisersproject.com/article/2017/11/containers-and-kubernetes-whats-next>
作者：[Kevin Casey](https://enterprisersproject.com/user/kevin-casey) 译者：[yunfengHe](https://github.com/yunfengHe) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用户指南：Linux 文件系统的链接
|
David Both
|
https://opensource.com/article/17/6/linking-linux-filesystem
|
学习如何使用链接，通过从 Linux 文件系统多个位置来访问文件，可以让日常工作变得轻松。
|
/data/attachment/album/201712/03/193119ay3qk3y9e0qq4xex.png.thumb.jpg
|
/data/attachment/album/201712/03/193119ay3qk3y9e0qq4xex.png
| true | false | true |
yongshouzhang
| false |
[
"文件系统",
"链接",
"符号链接"
] |
技术
|
{
"viewnum": 7006,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习如何使用链接，通过从 Linux 文件系统多个位置来访问文件，可以让日常工作变得轻松。
| 2017-12-03T19:31:14 | 2017-12-03T19:31:14 | 9,105 |
/article-9105-1.html
|
>
> 学习如何使用链接，通过从 Linux 文件系统多个位置来访问文件，可以让日常工作变得轻松。
>
>
>
在我为 opensource.com 写过的关于 Linux 文件系统方方面面的文章中，包括 [Linux 的 EXT4 文件系统的历史、特性以及最佳实践](/article-8685-1.html)； [在 Linux 中管理设备](/article-8099-1.html)；[Linux 文件系统概览](/article-8887-1.html) 和 [用户指南：逻辑卷管理](https://opensource.com/business/16/9/linux-users-guide-lvm)，我曾简要的提到过 Linux 文件系统一个有趣的特性，它允许用户从多个位置来访问 Linux 文件目录树中的文件来简化一些任务。
Linux 文件系统中有两种<ruby> 链接 <rt> link </rt></ruby>：<ruby> 硬链接 <rt> hard link </rt></ruby>和<ruby> 软链接 <rt> soft link </rt></ruby>。虽然二者差别显著，但都用来解决相似的问题。它们都提供了对单个文件的多个目录项（引用）的访问，但实现却大为不同。链接的强大功能赋予了 Linux 文件系统灵活性，因为[一切皆是文件](https://opensource.com/life/15/9/everything-is-a-file)。
举个例子，我曾发现一些程序要求特定的版本库方可运行。 当用升级后的库替代旧库后，程序会崩溃，提示旧版本库缺失。通常，库名的唯一变化就是版本号。出于直觉，我仅仅给程序添加了一个新的库链接，并以旧库名称命名。我试着再次启动程序，运行良好。程序就是一个游戏，人人都明白，每个玩家都会尽力使游戏进行下去。
事实上，几乎所有的应用程序链接库都使用通用的命名规则，链接名称中包含了主版本号，链接所指向的文件的文件名中同样包含了小版本号。再比如，程序的一些必需文件为了迎合 Linux 文件系统规范，从一个目录移动到另一个目录中，系统为了向后兼容那些不能获取这些文件新位置的程序在旧的目录中存放了这些文件的链接。如果你对 `/lib64` 目录做一个长清单列表，你会发现很多这样的例子。
```
lrwxrwxrwx. 1 root root 36 Dec 8 2016 cracklib_dict.hwm -> ../../usr/share/cracklib/pw_dict.hwm
lrwxrwxrwx. 1 root root 36 Dec 8 2016 cracklib_dict.pwd -> ../../usr/share/cracklib/pw_dict.pwd
lrwxrwxrwx. 1 root root 36 Dec 8 2016 cracklib_dict.pwi -> ../../usr/share/cracklib/pw_dict.pwi
lrwxrwxrwx. 1 root root 27 Jun 9 2016 libaccountsservice.so.0 -> libaccountsservice.so.0.0.0
-rwxr-xr-x. 1 root root 288456 Jun 9 2016 libaccountsservice.so.0.0.0
lrwxrwxrwx 1 root root 15 May 17 11:47 libacl.so.1 -> libacl.so.1.1.0
-rwxr-xr-x 1 root root 36472 May 17 11:47 libacl.so.1.1.0
lrwxrwxrwx. 1 root root 15 Feb 4 2016 libaio.so.1 -> libaio.so.1.0.1
-rwxr-xr-x. 1 root root 6224 Feb 4 2016 libaio.so.1.0.0
-rwxr-xr-x. 1 root root 6224 Feb 4 2016 libaio.so.1.0.1
lrwxrwxrwx. 1 root root 30 Jan 16 16:39 libakonadi-calendar.so.4 -> libakonadi-calendar.so.4.14.26
-rwxr-xr-x. 1 root root 816160 Jan 16 16:39 libakonadi-calendar.so.4.14.26
lrwxrwxrwx. 1 root root 29 Jan 16 16:39 libakonadi-contact.so.4 -> libakonadi-contact.so.4.14.26
```
`/lib64` 目录下的一些链接
在上面展示的 `/lib64` 目录清单列表中，文件模式第一个字母 `l` （小写字母 l）表示这是一个软链接（又称符号链接）。
### 硬链接
在 [Linux 的 EXT4 文件系统的历史、特性以及最佳实践](/article-8685-1.html)一文中，我曾探讨过这样一个事实，每个文件都有一个包含该文件信息的 inode，包含了该文件的位置信息。上述文章中的[图2](/article-8685-1.html#3_19182)展示了一个指向 inode 的单一目录项。每个文件都至少有一个目录项指向描述该文件信息的 inode ，目录项是一个硬链接，因此每个文件至少都有一个硬链接。
如下图 1 所示，多个目录项指向了同一 inode 。这些目录项都是硬链接。我曾在三个目录项中使用波浪线 (`~`) 的缩写，这是用户目录的惯例表示，因此在该例中波浪线等同于 `/home/user` 。值得注意的是，第四个目录项是一个完全不同的目录，`/home/shared`，可能是该计算机上用户的共享文件目录。
*图 1*
硬链接被限制在一个单一的文件系统中。此处的“文件系统” 是指挂载在特定挂载点上的分区或逻辑卷，此例中是 `/home`。这是因为在每个文件系统中的 inode 号都是唯一的。而在不同的文件系统中，如 `/var` 或 `/opt`，会有和 `/home` 中相同的 inode 号。
因为所有的硬链接都指向了包含文件元信息的单一 inode ，这些属性都是文件的一部分，像所属关系、权限、到该 inode 的硬链接数目，对每个硬链接来说这些特性没有什么不同的。这是一个文件所具有的一组属性。唯一能区分这些文件的是包含在 inode 信息中的文件名。链接到同一目录中的单一文件/ inode 的硬链接必须拥有不同的文件名，这是基于同一目录下不能存在重复的文件名的事实的。
文件的硬链接数目可通过 `ls -l` 来查看，如果你想查看实际节点号，可使用 `ls -li` 命令。
### 符号（软）链接
硬链接和软链接（也称为<ruby> 符号链接 <rt> symlink </rt></ruby>）的区别在于，硬链接直接指向属于该文件的 inode ，而软链接直接指向一个目录项，即指向一个硬链接。因为软链接指向的是一个文件的硬链接而非该文件的 inode ，所以它们并不依赖于 inode 号，这使得它们能跨越不同的文件系统、分区和逻辑卷起作用。
软链接的缺点是，一旦它所指向的硬链接被删除或重命名后，该软链接就失效了。软链接虽然还在，但所指向的硬链接已不存在。所幸的是，`ls` 命令能以红底白字的方式在其列表中高亮显示失效的软链接。
### 实验项目: 链接实验
我认为最容易理解链接用法及其差异的方法是动手搭建一个项目。这个项目应以非超级用户的身份在一个空目录下进行。我创建了 `~/temp` 目录做这个实验，你也可以这么做。这么做可为项目创建一个安全的环境且提供一个新的空目录让程序运作，如此以来这儿仅存放和程序有关的文件。
#### 初始工作
首先，在你要进行实验的目录下为该项目中的任务创建一个临时目录，确保当前工作目录（PWD）是你的主目录，然后键入下列命令。
```
mkdir temp
```
使用这个命令将当前工作目录切换到 `~/temp`。
```
cd temp
```
实验开始，我们需要创建一个能够链接到的文件，下列命令可完成该工作并向其填充内容。
```
du -h > main.file.txt
```
使用 `ls -l` 长列表命名确认文件正确地创建了。运行结果应类似于我的。注意文件大小只有 7 字节，但你的可能会有 1～2 字节的变动。
```
[dboth@david temp]$ ls -l
total 4
-rw-rw-r-- 1 dboth dboth 7 Jun 13 07:34 main.file.txt
```
在列表中，文件模式串后的数字 `1` 代表存在于该文件上的硬链接数。现在应该是 1 ，因为我们还没有为这个测试文件建立任何硬链接。
#### 对硬链接进行实验
硬链接创建一个指向同一 inode 的新目录项，当为文件添加一个硬链接时，你会看到链接数目的增加。确保当前工作目录仍为 `~/temp`。创建一个指向 `main.file.txt` 的硬链接，然后查看该目录下文件列表。
```
[dboth@david temp]$ ln main.file.txt link1.file.txt
[dboth@david temp]$ ls -l
total 8
-rw-rw-r-- 2 dboth dboth 7 Jun 13 07:34 link1.file.txt
-rw-rw-r-- 2 dboth dboth 7 Jun 13 07:34 main.file.txt
```
目录中两个文件都有两个链接且大小相同，时间戳也一样。这就是有一个 inode 和两个硬链接（即该文件的目录项）的一个文件。再建立一个该文件的硬链接，并列出目录清单内容。你可以建立硬链接： `link1.file.txt` 或 `main.file.txt`。
```
[dboth@david temp]$ ln link1.file.txt link2.file.txt ; ls -l
total 16
-rw-rw-r-- 3 dboth dboth 7 Jun 13 07:34 link1.file.txt
-rw-rw-r-- 3 dboth dboth 7 Jun 13 07:34 link2.file.txt
-rw-rw-r-- 3 dboth dboth 7 Jun 13 07:34 main.file.txt
```
注意，该目录下的每个硬链接必须使用不同的名称，因为同一目录下的两个文件不能拥有相同的文件名。试着创建一个和现存链接名称相同的硬链接。
```
[dboth@david temp]$ ln main.file.txt link2.file.txt
ln: failed to create hard link 'link2.file.txt': File exists
```
显然不行，因为 `link2.file.txt` 已经存在。目前为止我们只在同一目录下创建硬链接，接着在临时目录的父目录（你的主目录）中创建一个链接。
```
[dboth@david temp]$ ln main.file.txt ../main.file.txt ; ls -l ../main*
-rw-rw-r-- 4 dboth dboth 7 Jun 13 07:34 main.file.txt
```
上面的 `ls` 命令显示 `main.file.txt` 文件确实存在于主目录中，且与该文件在 `temp` 目录中的名称一致。当然它们不是不同的文件，它们是同一文件的两个链接，指向了同一文件的目录项。为了帮助说明下一点，在 `temp` 目录中添加一个非链接文件。
```
[dboth@david temp]$ touch unlinked.file ; ls -l
total 12
-rw-rw-r-- 4 dboth dboth 7 Jun 13 07:34 link1.file.txt
-rw-rw-r-- 4 dboth dboth 7 Jun 13 07:34 link2.file.txt
-rw-rw-r-- 4 dboth dboth 7 Jun 13 07:34 main.file.txt
-rw-rw-r-- 1 dboth dboth 0 Jun 14 08:18 unlinked.file
```
使用 `ls` 命令的 `i` 选项查看 inode 的硬链接号和新创建文件的硬链接号。
```
[dboth@david temp]$ ls -li
total 12
657024 -rw-rw-r-- 4 dboth dboth 7 Jun 13 07:34 link1.file.txt
657024 -rw-rw-r-- 4 dboth dboth 7 Jun 13 07:34 link2.file.txt
657024 -rw-rw-r-- 4 dboth dboth 7 Jun 13 07:34 main.file.txt
657863 -rw-rw-r-- 1 dboth dboth 0 Jun 14 08:18 unlinked.file
```
注意上面文件模式左边的数字 `657024` ，这是三个硬链接文件所指的同一文件的 inode 号，你也可以使用 `i` 选项查看主目录中所创建的链接的节点号，和该值相同。而那个只有一个链接的 inode 号和其他的不同，在你的系统上看到的 inode 号或许不同于本文中的。
接着改变其中一个硬链接文件的大小。
```
[dboth@david temp]$ df -h > link2.file.txt ; ls -li
total 12
657024 -rw-rw-r-- 4 dboth dboth 1157 Jun 14 14:14 link1.file.txt
657024 -rw-rw-r-- 4 dboth dboth 1157 Jun 14 14:14 link2.file.txt
657024 -rw-rw-r-- 4 dboth dboth 1157 Jun 14 14:14 main.file.txt
657863 -rw-rw-r-- 1 dboth dboth 0 Jun 14 08:18 unlinked.file
```
现在所有的硬链接文件大小都比原来大了，因为多个目录项都链接着同一文件。
下个实验在我的电脑上会出现这样的结果，是因为我的 `/tmp` 目录在一个独立的逻辑卷上。如果你有单独的逻辑卷或文件系统在不同的分区上（如果未使用逻辑卷），确定你是否能访问那个分区或逻辑卷，如果不能，你可以在电脑上挂载一个 U 盘，如果上述方式适合你，你可以进行这个实验。
试着在 `/tmp` 目录中建立一个 `~/temp` 目录下文件的链接（或你的文件系统所在的位置）。
```
[dboth@david temp]$ ln link2.file.txt /tmp/link3.file.txt
ln: failed to create hard link '/tmp/link3.file.txt' => 'link2.file.txt':
Invalid cross-device link
```
为什么会出现这个错误呢？ 原因是每一个单独的可挂载文件系统都有一套自己的 inode 号。简单的通过 inode 号来跨越整个 Linux 文件系统结构引用一个文件会使系统困惑，因为相同的节点号会存在于每个已挂载的文件系统中。
有时你可能会想找到一个 inode 的所有硬链接。你可以使用 `ls -li` 命令。然后使用 `find` 命令找到所有硬链接的节点号。
```
[dboth@david temp]$ find . -inum 657024
./main.file.txt
./link1.file.txt
./link2.file.txt
```
注意 `find` 命令不能找到所属该节点的四个硬链接，因为我们在 `~/temp` 目录中查找。 `find` 命令仅在当前工作目录及其子目录中查找文件。要找到所有的硬链接，我们可以使用下列命令，指定你的主目录作为起始查找条件。
```
[dboth@david temp]$ find ~ -samefile main.file.txt
/home/dboth/temp/main.file.txt
/home/dboth/temp/link1.file.txt
/home/dboth/temp/link2.file.txt
/home/dboth/main.file.txt
```
如果你是非超级用户，没有权限，可能会看到错误信息。这个命令也使用了 `-samefile` 选项而不是指定文件的节点号。这个效果和使用 inode 号一样且更容易，如果你知道其中一个硬链接名称的话。
#### 对软链接进行实验
如你刚才看到的，不能跨越文件系统边界创建硬链接，即在逻辑卷或文件系统中从一个文件系统到另一个文件系统。软链接给出了这个问题的解决方案。虽然它们可以达到相同的目的，但它们是非常不同的，知道这些差异是很重要的。
让我们在 `~/temp` 目录中创建一个符号链接来开始我们的探索。
```
[dboth@david temp]$ ln -s link2.file.txt link3.file.txt ; ls -li
total 12
657024 -rw-rw-r-- 4 dboth dboth 1157 Jun 14 14:14 link1.file.txt
657024 -rw-rw-r-- 4 dboth dboth 1157 Jun 14 14:14 link2.file.txt
658270 lrwxrwxrwx 1 dboth dboth 14 Jun 14 15:21 link3.file.txt ->
link2.file.txt
657024 -rw-rw-r-- 4 dboth dboth 1157 Jun 14 14:14 main.file.txt
657863 -rw-rw-r-- 1 dboth dboth 0 Jun 14 08:18 unlinked.file
```
拥有节点号 `657024` 的那些硬链接没有变化，且硬链接的数目也没有变化。新创建的符号链接有不同的 inode 号 `658270`。 名为 `link3.file.txt` 的软链接指向了 `link2.file.txt` 文件。使用 `cat` 命令查看 `link3.file.txt` 文件的内容。符号链接的 inode 信息以字母 `l` （小写字母 l）开头，意味着这个文件实际是个符号链接。
上例中软链接文件 `link3.file.txt` 的大小只有 14 字节。这是文本内容 `link3.file.txt` 的大小，即该目录项的实际内容。目录项 `link3.file.txt` 并不指向一个 inode ；它指向了另一个目录项，这在跨越文件系统建立链接时很有帮助。现在试着创建一个软链接，之前在 `/tmp` 目录中尝试过的。
```
[dboth@david temp]$ ln -s /home/dboth/temp/link2.file.txt
/tmp/link3.file.txt ; ls -l /tmp/link*
lrwxrwxrwx 1 dboth dboth 31 Jun 14 21:53 /tmp/link3.file.txt ->
/home/dboth/temp/link2.file.txt
```
#### 删除链接
当你删除硬链接或硬链接所指的文件时，需要考虑一些问题。
首先，让我们删除硬链接文件 `main.file.txt`。注意指向 inode 的每个目录项就是一个硬链接。
```
[dboth@david temp]$ rm main.file.txt ; ls -li
total 8
657024 -rw-rw-r-- 3 dboth dboth 1157 Jun 14 14:14 link1.file.txt
657024 -rw-rw-r-- 3 dboth dboth 1157 Jun 14 14:14 link2.file.txt
658270 lrwxrwxrwx 1 dboth dboth 14 Jun 14 15:21 link3.file.txt ->
link2.file.txt
657863 -rw-rw-r-- 1 dboth dboth 0 Jun 14 08:18 unlinked.file
```
`main.file.txt` 是该文件被创建时所创建的第一个硬链接。现在删除它，仍然保留着原始文件和硬盘上的数据以及所有剩余的硬链接。要删除原始文件，你必须删除它的所有硬链接。
现在删除 `link2.file.txt` 硬链接文件。
```
[dboth@david temp]$ rm link2.file.txt ; ls -li
total 8
657024 -rw-rw-r-- 3 dboth dboth 1157 Jun 14 14:14 link1.file.txt
658270 lrwxrwxrwx 1 dboth dboth 14 Jun 14 15:21 link3.file.txt ->
link2.file.txt
657024 -rw-rw-r-- 3 dboth dboth 1157 Jun 14 14:14 main.file.txt
657863 -rw-rw-r-- 1 dboth dboth 0 Jun 14 08:18 unlinked.file
```
注意软链接的变化。删除软链接所指的硬链接会使该软链接失效。在我的系统中，断开的链接用颜色高亮显示，目标的硬链接会闪烁显示。如果需要修复这个损坏的软链接，你需要在同一目录下建立一个和旧链接相同名字的硬链接，只要不是所有硬链接都已删除就行。您还可以重新创建链接本身，链接保持相同的名称，但指向剩余的硬链接中的一个。当然如果软链接不再需要，可以使用 `rm` 命令删除它们。
`unlink` 命令在删除文件和链接时也有用。它非常简单且没有选项，就像 `rm` 命令一样。然而，它更准确地反映了删除的基本过程，因为它删除了目录项与被删除文件的链接。
### 写在最后
我用过这两种类型的链接很长一段时间后，我开始了解它们的能力和特质。我为我所教的 Linux 课程编写了一个实验室项目，以充分理解链接是如何工作的，并且我希望增进你的理解。
（题图： [Paul Lewin](https://www.flickr.com/photos/digypho/7905320090)，Opensource.com 修改。 [CC BY-SA 2.0](https://creativecommons.org/licenses/by/2.0/)）
---
作者简介：
戴维.布斯 - 戴维.布斯是 Linux 和开源倡导者，居住在北卡罗莱纳的罗列 。他在 IT 行业工作了四十年，为 IBM 工作了 20 多年的 OS/2。在 IBM 时，他在 1981 年编写了最初的 IBM PC 的第一个培训课程。他为 RedHat 教授过 RHCE 班，并曾在 MCI Worldcom、思科和北卡罗莱纳州工作。他已经用 Linux 和开源软件工作将近 20 年了。
---
via: <https://opensource.com/article/17/6/linking-linux-filesystem>
作者：[David Both](https://opensource.com/users/dboth) 译者：[yongshouzhang](https://github.com/yongshouzhang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
请允悲，发行了 23 年的《Linux Journal》最终停刊了
|
Carlie Fairchild
|
http://www.linuxjournal.com/content/linux-journal-ceases-publication
|
有着 23 年历史的著名 Linux 和开源期刊《Linux Journal》结束了，其发行人 Carlie Fairchild 在 12 月 1 日撰文称，《Linux Journal》宣布停刊——如果没有奇迹出现的话。
|
/data/attachment/album/201712/03/232739e1gkvzkpv8nmvnhv.jpeg.thumb.jpg
|
/data/attachment/album/201712/03/232739e1gkvzkpv8nmvnhv.jpeg
| true | false | true |
wxy
| false |
[
"期刊",
"Linux"
] |
新闻
|
{
"viewnum": 6750,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "59.67.152.238",
"message": "允悲",
"username": "乔少年 [Chrome 62.0|Windows 10]",
"date": "2017-12-05T21:25:02"
},
{
"postip": "222.223.34.10",
"message": "为LJ默哀，再次证明了，商业化才是生存之道。<br />\r\n昔日闭源急先锋微软，摇身一变成为开源领袖。<br />\r\n商业化可能会毁了一个品牌，但是没有商业化，注定会毁掉一个品牌。<br />\r\n抱歉，有钱真的可以为所欲为。",
"username": "来自河北保定的 Chrome 76.0|Windows 10 用户",
"date": "2019-08-31T10:19:58"
}
] |
[] |
有着 23 年历史的著名 Linux 和开源期刊《Linux Journal》结束了，其发行人 Carlie Fairchild 在 12 月 1 日撰文称，《Linux Journal》宣布停刊——如果没有奇迹出现的话。
| 2017-12-03T23:33:00 | 2017-12-03T23:33:00 | 9,106 |
/article-9106-1.html
|
有着 23 年历史的著名 Linux 和开源期刊《[Linux Journal](http://www.linuxjournal.com/)》结束了，其发行人 Carlie Fairchild 在 12 月 1 日撰文称，《[Linux Journal](http://www.linuxjournal.com/)》[宣布停刊](http://www.linuxjournal.com/content/linux-journal-ceases-publication)——如果没有奇迹出现的话。
看的出来，Fairchild 的告别信充满了悲伤、释然和获得帮助的一线期望。《[Linux Journal](http://www.linuxjournal.com/)》创刊于 1994 年，仅比 Linux 内核发布 0.01 版本的 1991 年晚 3 年，而 1994 年 Linux 内核才刚刚发布了 1.0。其后，2011 年的时候，该杂志停止了纸质杂志的出版，仅发行电子版；而如今，经过 6 年之后，连电子版的发行也难以维系，只能无奈的宣布停刊了。
虽然社区也在讨论是不是可以发起募捐或众筹来帮助它度过难关，但是，问题是我们能帮助它多久？
而另外一方面，《[Linux Journal](http://www.linuxjournal.com/)》的停刊，仅仅是时代变迁带来的变化么？这件事会给我们带来什么思考？
以下是 Fairchild 发布的[告别信](http://www.linuxjournal.com/content/linux-journal-ceases-publication)译文：
---
结束了。
看起来我们走到了尽头。根据计划，虽然我们并不想这样做，11 月这一期的《Linux Journal》是我们最后的一期了。
简单的来说，就是我们没钱了，连同期权也用光了。我们没有一个富有的母公司，也没有一个聚宝盆，从头至尾，我们就不算是一个正常的出版商。很长时间以来，我们一直在勉力挣扎于盈亏线之上，当这个平衡终于翻转时，我们最终坠毁在这个 11 月。
我们所能看到的未来和出版业的过去一样——广告商赞助一个出版物是因为它的品牌和读者——而如今的广告世界更喜欢追逐眼球，喜欢在读者的浏览器中植入信标，在读者看到的每个角度用广告去轰炸他们。但是未来不再，过去已逝。
或许还有一点希望，我们觉得，救世主也许会来；但是那需要接过我们的债务、我们的品牌、归档、域名和订阅者及读者。如果你知道任何人真心愿意接手，一定要让我们知道。否则，来看看 [LinuxJournal.com](http://www.linuxjournal.com/) 吧，希望，至少我们的旧归档（可以追溯到 1994 年 4 月创刊，其时 Linux 刚刚发布 1.0）不会消失，这里有许多极棒的内容，以及许多我们怀念的历史。
我们最大的遗憾是，我们没有足够的钱来返还给那些对我们最有价值的人们：我们的订阅者。对此我们表示深切的、真诚的道歉。我们可以为订阅者做的事情有：
《Linux Pro 杂志》为我们的订阅者提供了六期免费杂志，这是一份我们 《Linux Journal》 一直推崇的出版物。在我们需要的时候，他们是第一个出现的人，我们也非常感谢他们的盛情邀请。我们今天刚刚完成了我们的 2017 归档，包括了我们曾经出版过的从开始到最后的每一期。一般我们按 $25 的价格销售它，但是订阅者们这次会免费得到它。请订阅者注意接收邮件了解详情。
我们也希望能得到一些安慰，要知道我们非常、非常地努力才使《Linux Journal》维持下来，我们已经做了太久了，并且以我们所能做到的，以尽可能低、尽可能少的成本来运营。我们基本上是志愿者群体，我们的一些员工已经几个月没有得到报酬了。并且，我们还欠一些自由职业者的钱。出版商对这些情况能承受多少时间是有限度的，而现在已经到了极限了。
这是一件伟大的事情，兄弟们！向那些为我们的诞生、成功和执着而奉献的人们致敬！我们希望列出他们的名字，但是这个名单太长了，以至于我们无法一一列出。但是我们记得你。再次感谢！
本文作者是：《[Linux Journal](http://www.linuxjournal.com/)》发行人 [Carlie Fairchild](mailto:carlie@linuxjournal.com)。
|
||
Translate Shell ：一款在 Linux 命令行中使用谷歌翻译的工具
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/translate-shell-a-tool-to-use-google-translate-from-command-line-in-linux/
|
我写过很多关于 CLI 应用的文章。 最近我发现了一些谷歌的 CLI 工具，像 “Google Translator”、“Google Calendar” 和 “Google Contacts”。 这里，我想在给大家分享一下。
|
/data/attachment/album/201712/04/213512ugw2stsgg6gf9sya.jpg.thumb.jpg
|
/data/attachment/album/201712/04/213512ugw2stsgg6gf9sya.jpg
| true | false | true |
lujun9972
| false |
[
"命令行",
"翻译"
] |
桌面应用
|
{
"viewnum": 24866,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "60.247.91.50",
"message": "粤语转换不太行啊",
"username": "来自北京的 Chrome 92.0|Windows 10 用户",
"date": "2021-08-20T16:58:03"
},
{
"postip": "171.107.150.47",
"message": "输入trans命令根本久没反应",
"username": "来自广西桂林的 Chrome 113.0|Windows 10 用户",
"date": "2023-05-11T01:07:16"
},
{
"postip": "223.148.140.139",
"message": "要换api，默认Google的，GitHub上说支持bing的api",
"username": "来自湖南的 Chrome Mobile 119.0|Android 13 用户",
"date": "2023-11-21T21:01:13"
}
] |
[] |
我写过很多关于 CLI 应用的文章。 最近我发现了一些谷歌的 CLI 工具，像 “Google Translator”、“Google Calendar” 和 “Google Contacts”。 这里，我想在给大家分享一下。
| 2017-12-04T21:35:00 | 2017-12-04T21:35:00 | 9,107 |
/article-9107-1.html
|
我对 CLI 应用非常感兴趣，因此热衷于使用并分享 CLI 应用。 我之所以更喜欢 CLI 很大原因是因为我在大多数的时候都使用的是字符界面（black screen），已经习惯了使用 CLI 应用而不是 GUI 应用。
我写过很多关于 CLI 应用的文章。 最近我发现了一些谷歌的 CLI 工具，像 “Google Translator”、“Google Calendar” 和 “Google Contacts”。 这里，我想在给大家分享一下。
今天我们要介绍的是 “Google Translator” 工具。 由于我的母语是泰米尔语，我在一天内用了很多次才理解了它的意义。
谷歌翻译为其它语系的人们所广泛使用。
### 什么是 Translate Shell
[Translate Shell](https://github.com/soimort/translate-shell) (之前叫做 Google Translate CLI) 是一款借助谷歌翻译（默认）、必应翻译、Yandex.Translate 以及 Apertium 来翻译的命令行翻译器。它让你可以在终端访问这些翻译引擎。 Translate Shell 在大多数 Linux 发行版中都能使用。
### 如何安装 Translate Shell
有三种方法安装 Translate Shell。
* 下载自包含的可执行文件
* 手工安装
* 通过包管理器安装
#### 方法 1 : 下载自包含的可执行文件
下载自包含的可执行文件放到 `/usr/bin` 目录中。
```
$ wget git.io/trans
$ chmod +x ./trans
$ sudo mv trans /usr/bin/
```
#### 方法 2 : 手工安装
克隆 Translate Shell 的 GitHub 仓库然后手工编译。
```
$ git clone https://github.com/soimort/translate-shell && cd translate-shell
$ make
$ sudo make install
```
#### 方法 3 : 通过包管理器
有些发行版的官方仓库中包含了 Translate Shell，可以通过包管理器来安装。
对于 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/)来安装。
```
$ sudo apt-get install translate-shell
```
对于 Fedora, 使用 [DNF 命令](https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/) 来安装。
```
$ sudo dnf install translate-shell
```
对于基于 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 translate-shell
or
$ packer -S translate-shell
```
### 如何使用 Translate Shell
安装好后，打开终端闭关输入下面命令。 谷歌翻译会自动探测源文本是哪种语言，并且在默认情况下将之翻译成你的 `locale` 所对应的语言。
```
$ trans [Words]
```
下面我将泰米尔语中的单词 “நன்றி” (Nanri) 翻译成英语。 这个单词的意思是感谢别人。
```
$ trans நன்றி
நன்றி
(Naṉṟi)
Thanks
Definitions of நன்றி
[ தமிழ் -> English ]
noun
gratitude
நன்றி
thanks
நன்றி
நன்றி
Thanks
```
使用下面命令也能将英语翻译成泰米尔语。
```
$ trans :ta thanks
thanks
/THaNGks/
நன்றி
(Naṉṟi)
Definitions of thanks
[ English -> தமிழ் ]
noun
நன்றி
gratitude, thanks
thanks
நன்றி
```
要将一个单词翻译到多个语种可以使用下面命令(本例中，我将单词翻译成泰米尔语以及印地语)。
```
$ trans :ta+hi thanks
thanks
/THaNGks/
நன்றி
(Naṉṟi)
Definitions of thanks
[ English -> தமிழ் ]
noun
நன்றி
gratitude, thanks
thanks
நன்றி
thanks
/THaNGks/
धन्यवाद
(dhanyavaad)
Definitions of thanks
[ English -> हिन्दी ]
noun
धन्यवाद
thanks, thank, gratitude, thankfulness, felicitation
thanks
धन्यवाद, शुक्रिया
```
使用下面命令可以将多个单词当成一个参数（句子）来进行翻译。(只需要把句子应用起来作为一个参数就行了)。
```
$ trans :ta "what is going on your life?"
what is going on your life?
உங்கள் வாழ்க்கையில் என்ன நடக்கிறது?
(Uṅkaḷ vāḻkkaiyil eṉṉa naṭakkiṟatu?)
Translations of what is going on your life?
[ English -> தமிழ் ]
what is going on your life?
உங்கள் வாழ்க்கையில் என்ன நடக்கிறது?
```
下面命令单独地翻译各个单词。
```
$ trans :ta curios happy
curios
ஆர்வம்
(Ārvam)
Translations of curios
[ Română -> தமிழ் ]
curios
ஆர்வம், அறிவாளிகள், ஆர்வமுள்ள, அறிய, ஆர்வமாக
happy
/ˈhapē/
சந்தோஷமாக
(Cantōṣamāka)
Definitions of happy
[ English -> தமிழ் ]
மகிழ்ச்சியான
happy, convivial, debonair, gay
திருப்தி உடைய
happy
adjective
இன்பமான
happy
happy
சந்தோஷமாக, மகிழ்ச்சி, இனிய, சந்தோஷமா
```
简洁模式：默认情况下，Translate Shell 尽可能多的显示翻译信息。如果你希望只显示简要信息，只需要加上 `-b`选项。
```
$ trans -b :ta thanks
நன்றி
```
字典模式：加上 `-d` 可以把 Translate Shell 当成字典来用。
```
$ trans -d :en thanks
thanks
/THaNGks/
Synonyms
noun
- gratitude, appreciation, acknowledgment, recognition, credit
exclamation
- thank you, many thanks, thanks very much, thanks a lot, thank you kindly, much obliged, much appreciated, bless you, thanks a million
Examples
- In short, thanks for everything that makes this city great this Thanksgiving.
- many thanks
- There were no thanks in the letter from him, just complaints and accusations.
- It is a joyful celebration in which Bolivians give thanks for their freedom as a nation.
- festivals were held to give thanks for the harvest
- The collection, as usual, received a great response and thanks is extended to all who subscribed.
- It would be easy to dwell on the animals that Tasmania has lost, but I prefer to give thanks for what remains.
- thanks for being so helpful
- It came back on about half an hour earlier than predicted, so I suppose I can give thanks for that.
- Many thanks for the reply but as much as I tried to follow your advice, it's been a bad week.
- To them and to those who have supported the office I extend my grateful thanks .
- We can give thanks and words of appreciation to others for their kind deeds done to us.
- Adam, thanks for taking time out of your very busy schedule to be with us tonight.
- a letter of thanks
- Thank you very much for wanting to go on reading, and thanks for your understanding.
- Gerry has received a letter of thanks from the charity for his part in helping to raise this much needed cash.
- So thanks for your reply to that guy who seemed to have a chip on his shoulder about it.
- Suzanne, thanks for being so supportive with your comments on my blog.
- She has never once acknowledged my thanks , or existence for that matter.
- My grateful thanks go to the funders who made it possible for me to travel.
- festivals were held to give thanks for the harvest
- All you secretaries who made it this far into the article… thanks for your patience.
- So, even though I don't think the photos are that good, thanks for the compliments!
- And thanks for warning us that your secret service requires a motorcade of more than 35 cars.
- Many thanks for your advice, which as you can see, I have passed on to our readers.
- Tom Ryan was given a bottle of wine as a thanks for his active involvement in the twinning project.
- Mr Hill insists he has received no recent complaints and has even been sent a letter of thanks from the forum.
- Hundreds turned out to pay tribute to a beloved former headteacher at a memorial service to give thanks for her life.
- Again, thanks for a well written and much deserved tribute to our good friend George.
- I appreciate your doing so, and thanks also for the compliments about the photos!
See also
Thanks!, thank, many thanks, thanks to, thanks to you, special thanks, give thanks, thousand thanks, Many thanks!, render thanks, heartfelt thanks, thanks to this
```
使用下面格式可以使用 Translate Shell 来翻译文件。
```
$ trans :ta file:///home/magi/gtrans.txt
உங்கள் வாழ்க்கையில் என்ன நடக்கிறது?
```
下面命令可以让 Translate Shell 进入交互模式。 在进入交互模式之前你需要明确指定源语言和目标语言。本例中，我将英文单词翻译成泰米尔语。
```
$ trans -shell en:ta thanks
Translate Shell
(:q to quit)
thanks
/THaNGks/
நன்றி
(Naṉṟi)
Definitions of thanks
[ English -> தமிழ் ]
noun
நன்றி
gratitude, thanks
thanks
நன்றி
```
想知道语言代码，可以执行下面命令。
```
$ trans -R
```
或者
```
$ trans -T
┌───────────────────┬────────────────────┬────────────────────┐
│ Afrikaans - af │ Hindi - hi │ Punjabi - pa │
│ Albanian - sq │ Hmong - hmn │ Querétaro Otomi- otq │
│ Amharic - am │ Hmong Daw - mww │ Romanian - ro │
│ Arabic - ar │ Hungarian - hu │ Russian - ru │
│ Armenian - hy │ Icelandic - is │ Samoan - sm │
│ Azerbaijani - az │ Igbo - ig │ Scots Gaelic - gd │
│ Basque - eu │ Indonesian - id │ Serbian (Cyr...-sr-Cyrl
│ Belarusian - be │ Irish - ga │ Serbian (Latin)-sr-Latn
│ Bengali - bn │ Italian - it │ Sesotho - st │
│ Bosnian - bs │ Japanese - ja │ Shona - sn │
│ Bulgarian - bg │ Javanese - jv │ Sindhi - sd │
│ Cantonese - yue │ Kannada - kn │ Sinhala - si │
│ Catalan - ca │ Kazakh - kk │ Slovak - sk │
│ Cebuano - ceb │ Khmer - km │ Slovenian - sl │
│ Chichewa - ny │ Klingon - tlh │ Somali - so │
│ Chinese Simp...- zh-CN│ Klingon (pIqaD)tlh-Qaak Spanish - es │
│ Chinese Trad...- zh-TW│ Korean - ko │ Sundanese - su │
│ Corsican - co │ Kurdish - ku │ Swahili - sw │
│ Croatian - hr │ Kyrgyz - ky │ Swedish - sv │
│ Czech - cs │ Lao - lo │ Tahitian - ty │
│ Danish - da │ Latin - la │ Tajik - tg │
│ Dutch - nl │ Latvian - lv │ Tamil - ta │
│ English - en │ Lithuanian - lt │ Tatar - tt │
│ Esperanto - eo │ Luxembourgish - lb │ Telugu - te │
│ Estonian - et │ Macedonian - mk │ Thai - th │
│ Fijian - fj │ Malagasy - mg │ Tongan - to │
│ Filipino - tl │ Malay - ms │ Turkish - tr │
│ Finnish - fi │ Malayalam - ml │ Udmurt - udm │
│ French - fr │ Maltese - mt │ Ukrainian - uk │
│ Frisian - fy │ Maori - mi │ Urdu - ur │
│ Galician - gl │ Marathi - mr │ Uzbek - uz │
│ Georgian - ka │ Mongolian - mn │ Vietnamese - vi │
│ German - de │ Myanmar - my │ Welsh - cy │
│ Greek - el │ Nepali - ne │ Xhosa - xh │
│ Gujarati - gu │ Norwegian - no │ Yiddish - yi │
│ Haitian Creole - ht │ Pashto - ps │ Yoruba - yo │
│ Hausa - ha │ Persian - fa │ Yucatec Maya - yua │
│ Hawaiian - haw │ Polish - pl │ Zulu - zu │
│ Hebrew - he │ Portuguese - pt │ │
└───────────────────┴────────────────────┴────────────────────┘
```
想了解更多选项的内容，可以查看其 man 手册。
```
$ man trans
```
---
via: <https://www.2daygeek.com/translate-shell-a-tool-to-use-google-translate-from-command-line-in-linux/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com/author/magesh/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 DNSTrails 自动找出每个域名的拥有者
|
Securitytrails Team
|
https://securitytrails.com/blog/find-every-domain-someone-owns
|
如果你正在调查互联网上任何个人的域名所有权，这意味着即使域名甚至没有指向注册服务商的 IP，如果他们使用相同的电话和邮件地址，我们仍然可以发现其他域名。
|
/data/attachment/album/201712/04/215650blxa4lj6bgsj7n6s.jpg.thumb.jpg
|
/data/attachment/album/201712/04/215650blxa4lj6bgsj7n6s.jpg
| true | false | true |
geekpi
| false |
[
"DNS",
"域名"
] |
分享
|
{
"viewnum": 5715,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你正在调查互联网上任何个人的域名所有权，这意味着即使域名甚至没有指向注册服务商的 IP，如果他们使用相同的电话和邮件地址，我们仍然可以发现其他域名。
| 2017-12-06T10:55:00 | 2017-12-06T10:55:00 | 9,109 |
/article-9109-1.html
|
今天，我们很高兴地宣布我们最近几周做的新功能。它是 Whois 聚合工具，现在可以在 [DNSTrails](https://dnstrails.com/) 上获得。
在过去，查找一个域名的所有者会花费很多时间，因为大部分时间你都需要把域名翻译为一个 IP 地址，以便找到同一个人拥有的其他域名。
使用老的方法，在得到你想要的域名列表之前，你在一个工具和另外一个工具的一日又一日的研究和交叉比较结果中经常会花费数个小时。
感谢这个新工具和我们的智能 [WHOIS 数据库](https://securitytrails.com/forensics)，现在你可以搜索任何域名，并获得组织或个人注册的域名的完整列表，并在几秒钟内获得准确的结果。
### 我如何使用 Whois 聚合功能？
第一步：打开 [DNSTrails.com](https://dnstrails.com/)
第二步：搜索任何域名，比如：godaddy.com
第三步：在得到域名的结果后，如下所见，定位下面的 Whois 信息：
第四步：你会看到那里有有关域名的电话和电子邮箱地址。
第五步：点击右边的链接，你会轻松地找到用相同电话和邮箱注册的域名。
如果你正在调查互联网上任何个人的域名所有权，这意味着即使域名甚至没有指向注册服务商的 IP，如果他们使用相同的电话和邮件地址，我们仍然可以发现其他域名。
想知道一个人拥有的其他域名么？亲自试试 [DNStrails](https://dnstrails.com/) 的 [WHOIS 聚合功能](http://dnstrails.com/#/domain/domain/ueland.com)或者[使用我们的 API 访问](https://securitytrails.com/contact)。
---
via: <https://securitytrails.com/blog/find-every-domain-someone-owns>
作者：[SECURITYTRAILS TEAM](https://securitytrails.com/blog/find-every-domain-someone-owns) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Photon 也许能成为你最喜爱的容器操作系统
|
Jack Wallen
|
https://www.linux.com/learn/intro-to-linux/2017/11/photon-could-be-your-new-favorite-container-os
|
Photon 就是这样的一个发行版。这个特殊的版本是由 VMware 于 2005 年创建的，它包含了 Docker 的守护进程，并可与容器框架（如 Mesos 和 Kubernetes ）一起使用。Photon 经过优化可与 VMware vSphere 协同工作，而且可用于裸机、Microsoft Azure、 Google Compute Engine、 Amazon Elastic Compute Cloud 或者 VirtualBox 等。
|
/data/attachment/album/201712/04/223630pii8gzm6v2hkh3mm.jpg.thumb.jpg
|
/data/attachment/album/201712/04/223630pii8gzm6v2hkh3mm.jpg
| true | false | true |
KeyLD
| false |
[
"Photon",
"容器",
"Docker"
] |
容器与云
|
{
"viewnum": 7866,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Photon 就是这样的一个发行版。这个特殊的版本是由 VMware 于 2005 年创建的，它包含了 Docker 的守护进程，并可与容器框架（如 Mesos 和 Kubernetes ）一起使用。Photon 经过优化可与 VMware vSphere 协同工作，而且可用于裸机、Microsoft Azure、 Google Compute Engine、 Amazon Elastic Compute Cloud 或者 VirtualBox 等。
| 2017-12-04T22:36:28 | 2017-12-04T22:36:28 | 9,110 |
/article-9110-1.html
|
>
> Phonton OS 专注于容器，是一个非常出色的平台。 —— Jack Wallen
>
>
>
容器在当下的火热，并不是没有原因的。正如[之前](https://www.linux.com/learn/intro-to-linux/2017/11/how-install-and-use-docker-linux)讨论的，容器可以使您轻松快捷地将新的服务与应用部署到您的网络上，而且并不耗费太多的系统资源。比起专用硬件和虚拟机，容器都是更加划算的，除此之外，他们更容易更新与重用。
更重要的是，容器喜欢 Linux（反之亦然）。不需要太多时间和麻烦，你就可以启动一台 Linux 服务器，运行[Docker](https://www.docker.com/)，然后部署容器。但是，哪种 Linux 发行版最适合部署容器呢？我们的选择很多。你可以使用标准的 Ubuntu 服务器平台（更容易安装 Docker 并部署容器）或者是更轻量级的发行版 —— 专门用于部署容器。
[Photon](https://vmware.github.io/photon/) 就是这样的一个发行版。这个特殊的版本是由 [VMware](https://www.vmware.com/) 于 2005 年创建的，它包含了 Docker 的守护进程，并可与容器框架（如 Mesos 和 Kubernetes ）一起使用。Photon 经过优化可与 [VMware vSphere](https://www.vmware.com/products/vsphere.html) 协同工作，而且可用于裸机、[Microsoft Azure](https://azure.microsoft.com/)、 [Google Compute Engine](https://cloud.google.com/compute/)、 [Amazon Elastic Compute Cloud](https://aws.amazon.com/ec2/) 或者 [VirtualBox](https://www.virtualbox.org/) 等。
Photon 通过只安装 Docker 守护进程所必需的东西来保持它的轻量。而这样做的结果是，这个发行版的大小大约只有 300MB。但这足以让 Linux 的运行一切正常。除此之外，Photon 的主要特点还有：
* 内核为性能而调整。
* 内核根据[内核自防护项目](https://kernsec.org/wiki/index.php/Kernel_Self_Protection_Project)（KSPP）进行了加固。
* 所有安装的软件包都根据加固的安全标识来构建。
* 操作系统在信任验证后启动。
* Photon 的管理进程可以管理防火墙、网络、软件包，和远程登录在 Photon 机器上的用户。
* 支持持久卷。
* [Project Lightwave](http://vmware.github.io/lightwave/) 整合。
* 及时的安全补丁与更新。
Photon 可以通过 [ISO 镜像](https://github.com/vmware/photon/wiki/Downloading-Photon-OS)、[OVA](https://github.com/vmware/photon/wiki/Downloading-Photon-OS)、[Amazon Machine Image](https://github.com/vmware/photon/wiki/Downloading-Photon-OS)、[Google Compute Engine 镜像](https://github.com/vmware/photon/wiki/Downloading-Photon-OS) 和 [Azure VHD](https://github.com/vmware/photon/wiki/Downloading-Photon-OS) 安装使用。现在我将向您展示如何使用 ISO 镜像在 VirtualBox 上安装 Photon。整个安装过程大概需要五分钟，在最后您将有一台随时可以部署容器的虚拟机。
### 创建虚拟机
在部署第一台容器之前，您必须先创建一台虚拟机并安装 Photon。为此，打开 VirtualBox 并点击“新建”按钮。跟着创建虚拟机向导进行配置（根据您的容器将需要的用途，为 Photon 提供必要的资源）。在创建好虚拟机后，您所需要做的第一件事就是更改配置。选择新建的虚拟机（在 VirtualBox 主窗口的左侧面板中），然后单击“设置”。在弹出的窗口中，点击“网络”（在左侧的导航中）。
在“网络”窗口（图1）中，你需要在“连接”的下拉窗口中选择桥接。这可以确保您的 Photon 服务与您的网络相连。完成更改后，单击确定。
*图 1： 更改 Photon 在 VirtualBox 中的网络设置。[经许可使用](https://www.linux.com/licenses/category/used-permission)*
从左侧的导航选择您的 Photon 虚拟机，点击启动。系统会提示您去加载 ISO 镜像。当您完成之后，Photon 安装程序将会启动并提示您按回车后开始安装。安装过程基于 ncurses（没有 GUI），但它非常简单。
接下来（图2），系统会询问您是要最小化安装，完整安装还是安装 OSTree 服务器。我选择了完整安装。选择您所需要的任意选项，然后按回车继续。
*图 2： 选择您的安装类型。[经许可使用](https://www.linux.com/licenses/category/used-permission)*
在下一个窗口，选择您要安装 Photon 的磁盘。由于我们将其安装在虚拟机，因此只有一块磁盘会被列出（图3）。选择“自动”按下回车。然后安装程序会让您输入（并验证）管理员密码。在这之后镜像开始安装在您的磁盘上并在不到 5 分钟的时间内结束。
*图 3： 选择安装 Photon 的硬盘。[经许可使用](https://www.linux.com/licenses/category/used-permission)*
安装完成后，重启虚拟机并使用安装时创建的用户 root 和它的密码登录。一切就绪，你准备好开始工作了。
在开始使用 Docker 之前，您需要更新一下 Photon。Photon 使用 `yum` 软件包管理器，因此在以 root 用户登录后输入命令 `yum update`。如果有任何可用更新，则会询问您是否确认（图4）。
*图 4： 更新 Photon。[经许可使用](https://www.linux.com/licenses/category/used-permission)*
### 用法
正如我所说的，Photon 提供了部署容器甚至创建 Kubernetes 集群所需要的所有包。但是，在使用之前还要做一些事情。首先要启动 Docker 守护进程。为此，执行以下命令：
```
systemctl start docker
systemctl enable docker
```
现在我们需要创建一个标准用户，以便我们可以不用 root 去运行 `docker` 命令。为此，执行以下命令：
```
useradd -m USERNAME
passwd USERNAME
```
其中 “USERNAME” 是我们新增的用户的名称。
接下来，我们需要将这个新用户添加到 “docker” 组，执行命令：
```
usermod -a -G docker USERNAME
```
其中 “USERNAME” 是刚刚创建的用户的名称。
注销 root 用户并切换为新增的用户。现在，您已经可以不必使用 `sudo` 命令或者切换到 root 用户来使用 `docker` 命令了。从 Docker Hub 中取出一个镜像开始部署容器吧。
### 一个优秀的容器平台
在专注于容器方面，Photon 毫无疑问是一个出色的平台。请注意，Photon 是一个开源项目，因此没有任何付费支持。如果您对 Photon 有任何的问题，请移步 Photon 项目的 GitHub 下的 [Issues](https://github.com/vmware/photon/issues)，那里可以供您阅读相关问题，或者提交您的问题。如果您对 Photon 感兴趣，您也可以在该项目的官方 [GitHub](https://github.com/vmware/photon)中找到源码。
尝试一下 Photon 吧，看看它是否能够使得 Docker 容器和 Kubernetes 集群的部署更加容易。
欲了解 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/photon-could-be-your-new-favorite-container-os>
作者：[JACK WALLEN](https://www.linux.com/users/jlwallen) 译者：[KeyLD](https://github.com/KeyLd) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 系统里用 Scrot 截屏
|
Himanshu Arora
|
https://www.howtoforge.com/tutorial/how-to-take-screenshots-in-linux-with-scrot/
|
如果你想找一个在命令行运行的更好用的截屏工具，你一定要试试 Scrot。这个工具有一些 gnome-screenshot 没有的独特功能。在这篇文章里，我们会通过简单易懂的例子来详细介绍 Scrot。
|
/data/attachment/album/201712/05/112340yiuqlqnnqnv6qqfi.jpg.thumb.jpg
|
/data/attachment/album/201712/05/112340yiuqlqnnqnv6qqfi.jpg
| true | false | true |
zpl1025
| false |
[
"scrot",
"截屏"
] |
桌面应用
|
{
"viewnum": 8112,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你想找一个在命令行运行的更好用的截屏工具，你一定要试试 Scrot。这个工具有一些 gnome-screenshot 没有的独特功能。在这篇文章里，我们会通过简单易懂的例子来详细介绍 Scrot。
| 2017-12-11T08:19:00 | 2017-12-11T08:19:00 | 9,111 |
/article-9111-1.html
|
最近，我们介绍过 [gnome-screenshot](https://www.howtoforge.com/tutorial/taking-screenshots-in-linux-using-gnome-screenshot/) 工具，这是一个很优秀的屏幕抓取工具。但如果你想找一个在命令行运行的更好用的截屏工具，你一定要试试 Scrot。这个工具有一些 gnome-screenshot 没有的独特功能。在这篇文章里，我们会通过简单易懂的例子来详细介绍 Scrot。
请注意一下，这篇文章里的所有例子都在 Ubuntu 16.04 LTS 上测试过，我们用的 scrot 版本是 0.8。
### 关于 Scrot
[Scrot](https://en.wikipedia.org/wiki/Scrot) （**SCR**eensh**OT**） 是一个屏幕抓取工具，使用 imlib2 库来获取和保存图片。由 Tom Gilbert 用 C 语言开发完成，通过 BSD 协议授权。
### 安装 Scrot
scort 工具可能在你的 Ubuntu 系统里预装了，不过如果没有的话，你可以用下面的命令安装：
```
sudo apt-get install scrot
```
安装完成后，你可以通过下面的命令来使用：
```
scrot [options] [filename]
```
**注意**：方括号里的参数是可选的。
### Scrot 的使用和特点
在这个小节里，我们会介绍如何使用 Scrot 工具，以及它的所有功能。
如果不带任何选项执行命令，它会抓取整个屏幕。
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/scrot.png)
默认情况下，抓取的截图会用带时间戳的文件名保存到当前目录下，不过你也可以在运行命令时指定截图文件名。比如：
```
scrot [image-name].png
```
### 获取程序版本
你想的话，可以用 `-v` 选项来查看 scrot 的版本。
```
scrot -v
```
这是例子：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/version.png)
### 抓取当前窗口
这个工具可以限制抓取当前的焦点窗口。这个功能可以通过 `-u` 选项打开。
```
scrot -u
```
例如，这是我在命令行执行上边命令时的桌面：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/desktop.png)
这是另一张用 scrot 抓取的截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/active.png)
### 抓取选定窗口
这个工具还可以让你抓取任意用鼠标点击的窗口。这个功能可以用 `-s` 选项打开。
```
scrot -s
```
例如，在下面的截图里你可以看到，我有两个互相重叠的终端窗口。我在上层的窗口里执行上面的命令。
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/select1.png)
现在假如我想抓取下层的终端窗口。这样我只要在执行命令后点击窗口就可以了 —— 在你用鼠标点击之前，命令的执行不会结束。
这是我点击了下层终端窗口后的截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/select2.png)
**注意**：你可以在上面的截图里看到，下层终端窗口的整个显示区域都被抓去下来了，甚至包括了上层窗口的部分叠加内容。
### 在截屏时包含窗口边框
我们之前介绍的 `-u` 选项在截屏时不会包含窗口边框。不过，需要的话你也可以在截屏时包含窗口边框。这个功能可以通过 `-b` 选项打开（当然要和 `-u` 选项一起）。
```
scrot -ub
```
下面是示例截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/border-new.png)
**注意**：截屏时包含窗口边框同时也会增加一点额外的背景。
### 延时截屏
你可以在开始截屏时增加一点延时。需要在 `--delay` 或 `-d` 选项后设定一个时间值参数。
```
scrot --delay [NUM]
scrot --delay 5
```
例如：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/delay.png)
在这例子里，scrot 会等待 5 秒再截屏。
### 截屏前倒数
这个工具也可以在你使用延时功能后显示一个倒计时。这个功能可以通过 `-c` 选项打开。
```
scrot –delay [NUM] -c
scrot -d 5 -c
```
下面是示例截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/countdown.png)
### 图片质量
你可以使用这个工具来调整截图的图片质量，范围是 1-100 之间。较大的值意味着更大的文件大小以及更低的压缩率。默认值是 75，不过最终效果根据选择的文件类型也会有一些差异。
这个功能可以通过 `--quality` 或 `-q` 选项打开，但是你必须提供一个 1 - 100 之间的数值作为参数。
```
scrot –quality [NUM]
scrot –quality 10
```
下面是示例截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/img-quality.jpg)
你可以看到，`-q` 选项的参数更靠近 1 让图片质量下降了很多。
### 生成缩略图
scort 工具还可以生成截屏的缩略图。这个功能可以通过 `--thumb` 选项打开。这个选项也需要一个 NUM 数值作为参数，基本上是指定原图大小的百分比。
```
scrot --thumb NUM
scrot --thumb 50
```
**注意**：加上 `--thumb` 选项也会同时保存原始截图文件。
例如，下面是我测试的原始截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/orig.png)
下面是保存的缩略图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/thmb.png)
### 拼接多显示器截屏
如果你的电脑接了多个显示设备，你可以用 scort 抓取并拼接这些显示设备的截图。这个功能可以通过 `-m` 选项打开。
```
scrot -m
```
下面是示例截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/multiple.png)
### 在保存截图后执行操作
使用这个工具，你可以在保存截图后执行各种操作 —— 例如，用像 gThumb 这样的图片编辑器打开截图。这个功能可以通过 `-e` 选项打开。下面是例子：
```
scrot abc.png -e 'gthumb abc.png'
```
这个命令里的 gthumb 是一个图片编辑器，上面的命令在执行后会自动打开。
下面是命令的截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/exec1.png)
这个是上面命令执行后的效果：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/exec2.png)
你可以看到 scrot 抓取了屏幕截图，然后再启动了 gThumb 图片编辑器打开刚才保存的截图图片。
如果你截图时没有指定文件名，截图将会用带有时间戳的文件名保存到当前目录 —— 这是 scrot 的默认设定，我们前面已经说过。
下面是一个使用默认名字并且加上 `-e` 选项来截图的例子：
```
scrot -e 'gthumb $n'
```
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/exec3.png)
有个地方要注意的是 `$n` 是一个特殊字符串，用来获取当前截图的文件名。关于特殊字符串的更多细节，请继续看下个小节。
### 特殊字符串
scrot 的 `-e`（或 `--exec`）选项和文件名参数可以使用格式说明符。有两种类型格式。第一种是以 `%` 加字母组成，用来表示日期和时间，第二种以 `$` 开头，scrot 内部使用。
下面介绍几个 `--exec` 和文件名参数接受的说明符。
`$f` – 让你可以使用截图的全路径（包括文件名）。
例如：
```
scrot ashu.jpg -e ‘mv $f ~/Pictures/Scrot/ashish/’
```
下面是示例截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/f.png)
如果你没有指定文件名，scrot 默认会用日期格式的文件名保存截图。这个是 scrot 的默认文件名格式：`%yy-%mm-%dd-%hhmmss_$wx$h_scrot.png`。
`$n` – 提供截图文件名。下面是示例截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/n.png)
`$s` – 获取截图的文件大小。这个功能可以像下面这样使用。
```
scrot abc.jpg -e ‘echo $s’
```
下面是示例截图：
[](https://www.howtoforge.com/images/how-to-take-screenshots-in-linux-with-scrot/big/s.png)
类似的，你也可以使用其他格式字符串 `$p`、`$w`、 `$h`、`$t`、`$$` 以及 `\n` 来分别获取图片像素大小、图像宽度、图像高度、图像格式、输入 `$` 字符、以及换行。你可以像上面介绍的 `$s` 格式那样使用这些字符串。
### 结论
这个应用能轻松地安装在 Ubuntu 系统上，对初学者比较友好。scrot 也提供了一些高级功能，比如支持格式化字符串，方便专业用户用脚本处理。当然，如果你想用起来的话有一点轻微的学习曲线。
---
via: <https://www.howtoforge.com/tutorial/how-to-take-screenshots-in-linux-with-scrot/>
作者：[Himanshu Arora](https://www.howtoforge.com/tutorial/how-to-take-screenshots-in-linux-with-scrot/) 译者：[zpl1025](https://github.com/zpl1025) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
vim 的酷功能：会话！
|
Julia Evans
|
https://jvns.ca/blog/2017/09/10/vim-sessions/
|
昨天我在编写我的vimrc的时候了解到一个很酷的 vim 功能！（主要为了添加 fzf 和 ripgrep 插件）。这是一个内置功能，不需要特别的插件。
|
/data/attachment/album/201712/05/113217zsgadesas32a07bb.jpg.thumb.jpg
|
/data/attachment/album/201712/05/113217zsgadesas32a07bb.jpg
| true | false | true |
geekpi
| false |
[
"vim",
"会话"
] |
技术
|
{
"viewnum": 6414,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
昨天我在编写我的vimrc的时候了解到一个很酷的 vim 功能！（主要为了添加 fzf 和 ripgrep 插件）。这是一个内置功能，不需要特别的插件。
| 2017-12-05T11:32:29 | 2017-12-05T11:32:29 | 9,112 |
/article-9112-1.html
|
昨天我在编写我的 [vimrc](https://github.com/jvns/vimconfig/blob/master/vimrc) 的时候了解到一个很酷的 vim 功能！（主要为了添加 fzf 和 ripgrep 插件）。这是一个内置功能，不需要特别的插件。
所以我画了一个漫画。
基本上你可以用下面的命令保存所有你打开的文件和当前的状态
```
:mksession ~/.vim/sessions/foo.vim
```
接着用 `:source ~/.vim/sessions/foo.vim` 或者 `vim -S ~/.vim/sessions/foo.vim` 还原会话。非常酷！
一些 vim 插件给 vim 会话添加了额外的功能：
* <https://github.com/tpope/vim-obsession>
* <https://github.com/mhinz/vim-startify>
* <https://github.com/xolox/vim-session>
这是漫画：
---
via: <https://jvns.ca/blog/2017/09/10/vim-sessions/>
作者：[Julia Evans](https://jvns.ca/about) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
面向初学者的 Linux 网络硬件：软件思维
|
Carla Schrode
|
https://www.linux.com/learn/intro-to-linux/2017/10/linux-networking-hardware-beginners-think-software
|
没有路由和桥接，我们将会成为孤独的小岛，你将会在这个网络教程中学到更多知识。
|
/data/attachment/album/201712/05/215725lg096gq9m9ue9xom.jpg.thumb.jpg
|
/data/attachment/album/201712/05/215725lg096gq9m9ue9xom.jpg
| true | false | true |
FelixYFZ
| false |
[
"网络"
] |
技术
|
{
"viewnum": 5014,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
没有路由和桥接，我们将会成为孤独的小岛，你将会在这个网络教程中学到更多知识。
| 2017-12-05T21:57:22 | 2017-12-05T21:57:22 | 9,113 |
/article-9113-1.html
|
>
> 没有路由和桥接，我们将会成为孤独的小岛，你将会在这个网络教程中学到更多知识。
>
>
>
上周，我们学习了本地网络硬件知识，本周，我们将学习网络互联技术和在移动网络中的一些很酷的黑客技术。
### 路由器
网络路由器就是计算机网络中的一切，因为路由器连接着网络，没有路由器，我们就会成为孤岛。图一展示了一个简单的有线本地网络和一个无线接入点，所有设备都接入到互联网上，本地局域网的计算机连接到一个连接着防火墙或者路由器的以太网交换机上，防火墙或者路由器连接到网络服务供应商（ISP）提供的电缆箱、调制调节器、卫星上行系统……好像一切都在计算中，就像是一个带着不停闪烁的的小灯的盒子。当你的网络数据包离开你的局域网，进入广阔的互联网，它们穿过一个又一个路由器直到到达自己的目的地。
*图一：一个简单的有线局域网和一个无线接入点。*
路由器可以是各种样式：一个只专注于路由的小巧特殊的小盒子，一个将会提供路由、防火墙、域名服务，以及 VPN 网关功能的大点的盒子，一台重新设计的台式电脑或者笔记本，一个树莓派计算机或者一个 Arduino，体积臃肿矮小的像 PC Engines 这样的单板计算机，除了苛刻的用途以外，普通的商品硬件都能良好的工作运行。高端的路由器使用特殊设计的硬件每秒能够传输最大量的数据包。它们有多路数据总线，多个中央处理器和极快的存储。（可以通过了解 Juniper 和思科的路由器来感受一下高端路由器书什么样子的，而且能看看里面是什么样的构造。）
接入你的局域网的无线接入点要么作为一个以太网网桥，要么作为一个路由器。桥接器扩展了这个网络，所以在这个桥接器上的任意一端口上的主机都连接在同一个网络中。一台路由器连接的是两个不同的网络。
### 网络拓扑
有多种设置你的局域网的方式，你可以把所有主机接入到一个单独的<ruby> 平面网络 <rt> flat network </rt></ruby>，也可以把它们划分为不同的子网。如果你的交换机支持 VLAN 的话，你也可以把它们分配到不同的 VLAN 中。
平面网络是最简单的网络，只需把每一台设备接入到同一个交换机上即可，如果一台交换上的端口不够使用，你可以将更多的交换机连接在一起。有些交换机有特殊的上行端口，有些是没有这种特殊限制的上行端口，你可以连接其中的任意端口，你可能需要使用交叉类型的以太网线，所以你要查阅你的交换机的说明文档来设置。
平面网络是最容易管理的，你不需要路由器也不需要计算子网，但它也有一些缺点。它们的伸缩性不好，所以当网络规模变得越来越大的时候就会被广播网络所阻塞。将你的局域网进行分段将会提升安全保障， 把局域网分成可管理的不同网段将有助于管理更大的网络。图二展示了一个分成两个子网的局域网络：内部的有线和无线主机，和一个托管公开服务的主机。包含面向公共的服务器的子网称作非军事区域 DMZ，（你有没有注意到那些都是主要在电脑上打字的男人们的术语？）因为它被阻挡了所有的内部网络的访问。
*图二：一个分成两个子网的简单局域网。*
即使像图二那样的小型网络也可以有不同的配置方法。你可以将防火墙和路由器放置在一台单独的设备上。你可以为你的非军事区域设置一个专用的网络连接，把它完全从你的内部网络隔离，这将引导我们进入下一个主题：一切基于软件。
### 软件思维
你可能已经注意到在这个简短的系列中我们所讨论的硬件，只有网络接口、交换机，和线缆是特殊用途的硬件。 其它的都是通用的商用硬件，而且都是软件来定义它的用途。Linux 是一个真实的网络操作系统，它支持大量的网络操作：网关、虚拟专用网关、以太网桥、网页、邮箱以及文件等等服务器、负载均衡、代理、服务质量、多种认证、中继、故障转移……你可以在运行着 Linux 系统的标准硬件上运行你的整个网络。你甚至可以使用 Linux 交换应用（LISA）和VDE2 协议来模拟以太网交换机。
有一些用于小型硬件的特殊发行版，如 DD-WRT、OpenWRT，以及树莓派发行版，也不要忘记 BSD 们和它们的特殊衍生用途如 pfSense 防火墙/路由器，和 FreeNAS 网络存储服务器。
你知道有些人坚持认为硬件防火墙和软件防火墙有区别？其实是没有区别的，就像说硬件计算机和软件计算机一样。
### 端口聚合和以太网绑定
聚合和绑定，也称链路聚合，是把两条以太网通道绑定在一起成为一条通道。一些交换机支持端口聚合，就是把两个交换机端口绑定在一起，成为一个是它们原来带宽之和的一条新的连接。对于一台承载很多业务的服务器来说这是一个增加通道带宽的有效的方式。
你也可以在以太网口进行同样的配置，而且绑定汇聚的驱动是内置在 Linux 内核中的，所以不需要任何其他的专门的硬件。
### 随心所欲选择你的移动宽带
我期望移动宽带能够迅速增长来替代 DSL 和有线网络。我居住在一个有 25 万人口的靠近一个城市的地方，但是在城市以外，要想接入互联网就要靠运气了，即使那里有很大的用户上网需求。我居住的小角落离城镇有 20 分钟的距离，但对于网络服务供应商来说他们几乎不会考虑到为这个地方提供网络。 我唯一的选择就是移动宽带；这里没有拨号网络、卫星网络（即使它很糟糕）或者是 DSL、电缆、光纤，但却没有阻止网络供应商把那些我在这个区域从没看到过的 Xfinity 和其它高速网络服务的传单塞进我的邮箱。
我试用了 AT&T、Version 和 T-Mobile。Version 的信号覆盖范围最广，但是 Version 和 AT&T 是最昂贵的。 我居住的地方在 T-Mobile 信号覆盖的边缘，但迄今为止他们给了最大的优惠，为了能够能够有效的使用，我必须购买一个 WeBoost 信号放大器和一台中兴的移动热点设备。当然你也可以使用一部手机作为热点，但是专用的热点设备有着最强的信号。如果你正在考虑购买一台信号放大器，最好的选择就是 WeBoost，因为他们的服务支持最棒，而且他们会尽最大努力去帮助你。在一个小小的 APP [SignalCheck Pro](http://www.bluelinepc.com/signalcheck/) 的协助下设置将会精准的增强你的网络信号，他们有一个功能较少的免费的版本，但你将一点都不会后悔去花两美元使用专业版。
那个小巧的中兴热点设备能够支持 15 台主机，而且还有拥有基本的防火墙功能。 但你如果你使用像 Linksys WRT54GL这样的设备，可以使用 Tomato、OpenWRT，或者 DD-WRT 来替代普通的固件，这样你就能完全控制你的防护墙规则、路由配置，以及任何其它你想要设置的服务。
（题图：Pixabay）
---
via: <https://www.linux.com/learn/intro-to-linux/2017/10/linux-networking-hardware-beginners-think-software>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 译者：[FelixYFZ](https://github.com/FelixYFZ) 校对：[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/12/how-manage-users-groups-linux
|
本教程可以了解如何通过用户组和访问控制表（ACL）来管理用户。
|
/data/attachment/album/201712/05/224222k2uqlslgchuws8uj.jpg.thumb.jpg
|
/data/attachment/album/201712/05/224222k2uqlslgchuws8uj.jpg
| true | false | true |
imquanquan
| false |
[
"用户组",
"ACL",
"权限"
] |
技术
|
{
"viewnum": 7494,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本教程可以了解如何通过用户组和访问控制表（ACL）来管理用户。
| 2017-12-05T22:42:14 | 2017-12-05T22:42:14 | 9,114 |
/article-9114-1.html
|
>
> 本教程可以了解如何通过用户组和访问控制表（ACL）来管理用户。
>
>
>
当你需要管理一台容纳多个用户的 Linux 机器时，比起一些基本的用户管理工具所提供的方法，有时候你需要对这些用户采取更多的用户权限管理方式。特别是当你要管理某些用户的权限时，这个想法尤为重要。比如说，你有一个目录，某个用户组中的用户可以通过读和写的权限访问这个目录，而其他用户组中的用户对这个目录只有读的权限。在 Linux 中，这是完全可以实现的。但前提是你必须先了解如何通过用户组和访问控制表（ACL）来管理用户。
我们将从简单的用户开始，逐渐深入到复杂的访问控制表（ACL）。你可以在你所选择的 Linux 发行版完成你所需要做的一切。本文的重点是用户组，所以不会涉及到关于用户的基础知识。
为了达到演示的目的，我将假设：
你需要用下面两个用户名新建两个用户：
* olivia
* nathan
你需要新建以下两个用户组：
* readers
* editors
olivia 属于 editors 用户组，而 nathan 属于 readers 用户组。reader 用户组对 `/DATA` 目录只有读的权限，而 editors 用户组则对 `/DATA` 目录同时有读和写的权限。当然，这是个非常小的任务，但它会给你基本的信息，你可以扩展这个任务以适应你其他更大的需求。
我将在 Ubuntu 16.04 Server 平台上进行演示。这些命令都是通用的，唯一不同的是，要是在你的发行版中不使用 `sudo` 命令，你必须切换到 root 用户来执行这些命令。
### 创建用户
我们需要做的第一件事是为我们的实验创建两个用户。可以用 `useradd` 命令来创建用户，我们不只是简单地创建一个用户，而需要同时创建用户和属于他们的家目录，然后给他们设置密码。
```
sudo useradd -m olivia
sudo useradd -m nathan
```
我们现在创建了两个用户，如果你看看 `/home` 目录，你可以发现他们的家目录（因为我们用了 `-m` 选项，可以在创建用户的同时创建他们的家目录。
之后，我们可以用以下命令给他们设置密码：
```
sudo passwd olivia
sudo passwd nathan
```
就这样，我们创建了两个用户。
### 创建用户组并添加用户
现在我们将创建 readers 和 editors 用户组，然后给它们添加用户。创建用户组的命令是：
```
addgroup readers
addgroup editors
```
（LCTT 译注：当你使用 CentOS 等一些 Linux 发行版时，可能系统没有 `addgroup` 这个命令，推荐使用 `groupadd` 命令来替换 `addgroup` 命令以达到同样的效果）
*图一：我们可以使用刚创建的新用户组了。*
创建用户组后，我们需要添加我们的用户到这两个用户组。我们用以下命令来将 nathan 用户添加到 readers 用户组：
```
sudo usermod -a -G readers nathan
```
用以下命令将 olivia 添加到 editors 用户组：
```
sudo usermod -a -G editors olivia
```
现在我们可以通过用户组来管理用户了。
### 给用户组授予目录的权限
假设你有个目录 `/READERS` 且允许 readers 用户组的所有成员访问这个目录。首先，我们执行以下命令来更改目录所属用户组：
```
sudo chown -R :readers /READERS
```
接下来，执行以下命令收回目录所属用户组的写入权限：
```
sudo chmod -R g-w /READERS
```
然后我们执行下面的命令来收回其他用户对这个目录的访问权限（以防止任何不在 readers 组中的用户访问这个目录里的文件）：
```
sudo chmod -R o-x /READERS
```
这时候，只有目录的所有者（root）和用户组 reader 中的用户可以访问 `/READES` 中的文件。
假设你有个目录 `/EDITORS` ，你需要给用户组 editors 里的成员这个目录的读和写的权限。为了达到这个目的，执行下面的这些命令是必要的：
```
sudo chown -R :editors /EDITORS
sudo chmod -R g+w /EDITORS
sudo chmod -R o-x /EDITORS
```
此时 editors 用户组的所有成员都可以访问和修改其中的文件。除此之外其他用户（除了 root 之外）无法访问 `/EDITORS` 中的任何文件。
使用这个方法的问题在于，你一次只能操作一个组和一个目录而已。这时候访问控制表（ACL）就可以派得上用场了。
### 使用访问控制表（ACL）
现在，让我们把这个问题变得棘手一点。假设你有一个目录 `/DATA` 并且你想给 readers 用户组的成员读取权限，并同时给 editors 用户组的成员读和写的权限。为此，你必须要用到 `setfacl` 命令。`setfacl` 命令可以为文件或文件夹设置一个访问控制表（ACL）。
这个命令的结构如下：
```
setfacl OPTION X:NAME:Y /DIRECTORY
```
其中 OPTION 是可选选项，X 可以是 `u`（用户）或者是 `g` （用户组），NAME 是用户或者用户组的名字，/DIRECTORY 是要用到的目录。我们将使用 `-m` 选项进行修改。因此，我们给 readers 用户组添加读取权限的命令是：
```
sudo setfacl -m g:readers:rx -R /DATA
```
现在 readers 用户组里面的每一个用户都可以读取 `/DATA` 目录里的文件了，但是他们不能修改里面的内容。
为了给 editors 用户组里面的用户读写权限，我们执行了以下命令：
```
sudo setfacl -m g:editors:rwx -R /DATA
```
上述命令将赋予 editors 用户组中的任何成员读取权限，同时保留 readers 用户组的只读权限。
### 更多的权限控制
使用访问控制表（ACL），你可以实现你所需的权限控制。你可以添加用户到用户组，并且灵活地控制这些用户组对每个目录的权限以达到你的需求。如果想了解上述工具的更多信息，可以执行下列的命令：
* `man usradd`
* `man addgroup`
* `man usermod`
* `man sefacl`
* `man chown`
* `man chmod`
---
via: <https://www.linux.com/learn/intro-to-linux/2017/12/how-manage-users-groups-linux>
作者：[Jack Wallen] 译者：[imquanquan](https://github.com/imquanquan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何自动唤醒和关闭 Linux
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2017/11/wake-and-shut-down-linux-automatically
|
不要成为一个电能浪费者。如果你的电脑不需要开机就请把它们关机。出于方便和计算机宅的考虑，你可以通过配置你的 Linux 计算机实现自动唤醒和关闭。
|
/data/attachment/album/201712/06/100309kocmcg74gmes7zeo.jpg.thumb.jpg
|
/data/attachment/album/201712/06/100309kocmcg74gmes7zeo.jpg
| true | false | true |
HardworkFish
| false |
[
"开机",
"关机",
"电源"
] |
技术
|
{
"viewnum": 17595,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
不要成为一个电能浪费者。如果你的电脑不需要开机就请把它们关机。出于方便和计算机宅的考虑，你可以通过配置你的 Linux 计算机实现自动唤醒和关闭。
| 2017-12-06T10:03:07 | 2017-12-06T10:03:07 | 9,115 |
/article-9115-1.html
|
>
> 了解如何通过配置 Linux 计算机来根据时间自动唤醒和关闭。
>
>
>
不要成为一个电能浪费者。如果你的电脑不需要开机就请把它们关机。出于方便和计算机宅的考虑，你可以通过配置你的 Linux 计算机实现自动唤醒和关闭。
### 宝贵的系统运行时间
有时候有些电脑需要一直处在开机状态，在不超过电脑运行时间的限制下这种情况是被允许的。有些人为他们的计算机可以长时间的正常运行而感到自豪，且现在我们有内核热补丁能够实现只有在硬件发生故障时才需要机器关机。我认为比较实际可行的是，像减少移动部件磨损一样节省电能，且在不需要机器运行的情况下将其关机。比如，你可以在规定的时间内唤醒备份服务器，执行备份，然后关闭它直到它要进行下一次备份。或者，你可以设置你的互联网网关只在特定的时间运行。任何不需要一直运行的东西都可以将其配置成在其需要工作的时候打开，待其完成工作后将其关闭。
### 系统休眠
对于不需要一直运行的电脑，使用 root 的 cron 定时任务（即 `/etc/crontab`）可以可靠地关闭电脑。这个例子创建一个 root 定时任务实现每天晚上 11 点 15 分定时关机。
```
# crontab -e -u root
# m h dom mon dow command
15 23 * * * /sbin/shutdown -h now
```
以下示例仅在周一至周五运行：
```
15 23 * * 1-5 /sbin/shutdown -h now
```
您可以为不同的日期和时间创建多个 cron 作业。 通过命令 `man 5 crontab` 可以了解所有时间和日期的字段。
一个快速、容易的方式是，使用 `/etc/crontab` 文件。但这样你必须指定用户：
```
15 23 * * 1-5 root shutdown -h now
```
### 自动唤醒
实现自动唤醒是一件很酷的事情；我大多数 SUSE （SUSE Linux）的同事都在纽伦堡，因此，因此为了跟同事能有几小时一起工作的时间，我不得不需要在凌晨五点起床。我的计算机早上 5 点半自动开始工作，而我只需要将自己和咖啡拖到我的桌子上就可以开始工作了。按下电源按钮看起来好像并不是什么大事，但是在每天的那个时候每件小事都会变得很大。
唤醒 Linux 计算机可能不如关闭它可靠，因此你可能需要尝试不同的办法。你可以使用远程唤醒（Wake-On-LAN）、RTC 唤醒或者个人电脑的 BIOS 设置预定的唤醒这些方式。这些方式可行的原因是，当你关闭电脑时，这并不是真正关闭了计算机；此时计算机处在极低功耗状态且还可以接受和响应信号。只有在你拔掉电源开关时其才彻底关闭。
### BIOS 唤醒
BIOS 唤醒是最可靠的。我的系统主板 BIOS 有一个易于使用的唤醒调度程序 (图 1)。对你来说也是一样的容易。
*图 1：我的系统 BIOS 有个易用的唤醒定时器。*
### 主机远程唤醒（Wake-On-LAN）
远程唤醒是仅次于 BIOS 唤醒的又一种可靠的唤醒方法。这需要你从第二台计算机发送信号到所要打开的计算机。可以使用 Arduino 或<ruby> 树莓派 <rt> Raspberry Pi </rt></ruby>发送给基于 Linux 的路由器或者任何 Linux 计算机的唤醒信号。首先，查看系统主板 BIOS 是否支持 Wake-On-LAN ，要是支持的话，必须先启动它，因为它被默认为禁用。
然后，需要一个支持 Wake-On-LAN 的网卡；无线网卡并不支持。你需要运行 `ethtool` 命令查看网卡是否支持 Wake-On-LAN ：
```
# ethtool eth0 | grep -i wake-on
Supports Wake-on: pumbg
Wake-on: g
```
这条命令输出的 “Supports Wake-on” 字段会告诉你你的网卡现在开启了哪些功能：
* d -- 禁用
* p -- 物理活动唤醒
* u -- 单播消息唤醒
* m -- 多播（组播）消息唤醒
* b -- 广播消息唤醒
* a -- ARP 唤醒
* g -- <ruby> 特定数据包 <rt> magic packet </rt></ruby>唤醒
* s -- 设有密码的<ruby> 特定数据包 <rt> magic packet </rt></ruby>唤醒
`ethtool` 命令的 man 手册并没说清楚 `p` 选项的作用；这表明任何信号都会导致唤醒。然而，在我的测试中它并没有这么做。想要实现远程唤醒主机，必须支持的功能是 `g` —— <ruby> 特定数据包 <rt> magic packet </rt></ruby>唤醒，而且下面的“Wake-on” 行显示这个功能已经在启用了。如果它没有被启用，你可以通过 `ethtool` 命令来启用它。
```
# ethtool -s eth0 wol g
```
这条命令可能会在重启后失效，所以为了确保万无一失，你可以创建个 root 用户的定时任务（cron）在每次重启的时候来执行这条命令。
```
@reboot /usr/bin/ethtool -s eth0 wol g
```
另一个选择是最近的<ruby> 网络管理器 <rt> Network Manager </rt></ruby>版本有一个很好的小复选框来启用 Wake-On-LAN（图 2）。
*图 2：启用 Wake on LAN*
这里有一个可以用于设置密码的地方，但是如果你的网络接口不支持<ruby> 安全开机 <rt> Secure On </rt></ruby>密码，它就不起作用。
现在你需要配置第二台计算机来发送唤醒信号。你并不需要 root 权限，所以你可以为你的普通用户创建 cron 任务。你需要用到的是想要唤醒的机器的网络接口和MAC地址信息。
```
30 08 * * * /usr/bin/wakeonlan D0:50:99:82:E7:2B
```
### RTC 唤醒
通过使用实时闹钟来唤醒计算机是最不可靠的方法。对于这个方法，可以参看 [Wake Up Linux With an RTC Alarm Clock](https://www.linux.com/learn/wake-linux-rtc-alarm-clock) ；对于现在的大多数发行版来说这种方法已经有点过时了。
下周继续了解更多关于使用 RTC 唤醒的方法。
通过 Linux 基金会和 edX 可以学习更多关于 Linux 的免费 [Linux 入门](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux)教程。
（题图：[The Observatory at Delhi](http://www.columbia.edu/itc/mealac/pritchett/00routesdata/1700_1799/jaipur/delhijantarearly/delhijantarearly.html)）
---
via:<https://www.linux.com/learn/intro-to-linux/2017/11/wake-and-shut-down-linux-automatically>
作者：[Carla Schroder](https://www.linux.com/users/cschroder) 译者：[HardworkFish](https://github.com/HardworkFish) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何判断 Linux 服务器是否被入侵？
|
Elliot Cooper
|
https://bash-prompt.net/guides/server-hacked/
|
大多数被攻破的服务器都是被类似自动攻击程序这样的程序或者类似“脚本小子”这样的廉价攻击者，以及蠢蛋罪犯所入侵的。这类攻击者会在访问服务器的同时滥用服务器资源，并且不怎么会采取措施来隐藏他们正在做的事情。
|
/data/attachment/album/201712/06/153011mrmc4foxd70sowxr.jpg.thumb.jpg
|
/data/attachment/album/201712/06/153011mrmc4foxd70sowxr.jpg
| true | false | true |
lujun9972
| false |
[
"黑客",
"攻击",
"入侵",
"安全"
] |
技术
|
{
"viewnum": 28261,
"commentnum": 0,
"favtimes": 10,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
大多数被攻破的服务器都是被类似自动攻击程序这样的程序或者类似“脚本小子”这样的廉价攻击者，以及蠢蛋罪犯所入侵的。这类攻击者会在访问服务器的同时滥用服务器资源，并且不怎么会采取措施来隐藏他们正在做的事情。
| 2017-12-06T15:30:52 | 2017-12-06T15:30:52 | 9,116 |
/article-9116-1.html
|
本指南中所谓的服务器被入侵或者说被黑了的意思，是指未经授权的人或程序为了自己的目的登录到服务器上去并使用其计算资源，通常会产生不好的影响。
免责声明：若你的服务器被类似 NSA 这样的国家机关或者某个犯罪集团入侵，那么你并不会注意到有任何问题，这些技术也无法发觉他们的存在。
然而，大多数被攻破的服务器都是被类似自动攻击程序这样的程序或者类似“脚本小子”这样的廉价攻击者，以及蠢蛋罪犯所入侵的。
这类攻击者会在访问服务器的同时滥用服务器资源，并且不怎么会采取措施来隐藏他们正在做的事情。
### 被入侵服务器的症状
当服务器被没有经验攻击者或者自动攻击程序入侵了的话，他们往往会消耗 100% 的资源。他们可能消耗 CPU 资源来进行数字货币的采矿或者发送垃圾邮件，也可能消耗带宽来发动 DoS 攻击。
因此出现问题的第一个表现就是服务器 “变慢了”。这可能表现在网站的页面打开的很慢，或者电子邮件要花很长时间才能发送出去。
那么你应该查看那些东西呢?
#### 检查 1 - 当前都有谁在登录?
你首先要查看当前都有谁登录在服务器上。发现攻击者登录到服务器上进行操作并不复杂。
其对应的命令是 `w`。运行 `w` 会输出如下结果：
```
08:32:55 up 98 days, 5:43, 2 users, load average: 0.05, 0.03, 0.00
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
root pts/0 113.174.161.1 08:26 0.00s 0.03s 0.02s ssh root@coopeaa12
root pts/1 78.31.109.1 08:26 0.00s 0.01s 0.00s w
```
第一个 IP 是英国 IP，而第二个 IP 是越南 IP。这个不是个好兆头。
停下来做个深呼吸, 不要恐慌之下只是干掉他们的 SSH 连接。除非你能够防止他们再次进入服务器，否则他们会很快进来并踢掉你，以防你再次回去。
请参阅本文最后的“被入侵之后怎么办”这一章节来看找到了被入侵的证据后应该怎么办。
`whois` 命令可以接一个 IP 地址然后告诉你该 IP 所注册的组织的所有信息，当然就包括所在国家的信息。
#### 检查 2 - 谁曾经登录过?
Linux 服务器会记录下哪些用户，从哪个 IP，在什么时候登录的以及登录了多长时间这些信息。使用 `last` 命令可以查看这些信息。
输出类似这样：
```
root pts/1 78.31.109.1 Thu Nov 30 08:26 still logged in
root pts/0 113.174.161.1 Thu Nov 30 08:26 still logged in
root pts/1 78.31.109.1 Thu Nov 30 08:24 - 08:26 (00:01)
root pts/0 113.174.161.1 Wed Nov 29 12:34 - 12:52 (00:18)
root pts/0 14.176.196.1 Mon Nov 27 13:32 - 13:53 (00:21)
```
这里可以看到英国 IP 和越南 IP 交替出现，而且最上面两个 IP 现在还处于登录状态。如果你看到任何未经授权的 IP，那么请参阅最后章节。
登录后的历史记录会记录到二进制的 `/var/log/wtmp` 文件中（LCTT 译注：这里作者应该写错了，根据实际情况修改），因此很容易被删除。通常攻击者会直接把这个文件删掉，以掩盖他们的攻击行为。 因此, 若你运行了 `last` 命令却只看得见你的当前登录，那么这就是个不妙的信号。
如果没有登录历史的话，请一定小心，继续留意入侵的其他线索。
#### 检查 3 - 回顾命令历史
这个层次的攻击者通常不会注意掩盖命令的历史记录，因此运行 `history` 命令会显示出他们曾经做过的所有事情。 一定留意有没有用 `wget` 或 `curl` 命令来下载类似垃圾邮件机器人或者挖矿程序之类的非常规软件。
命令历史存储在 `~/.bash_history` 文件中，因此有些攻击者会删除该文件以掩盖他们的所作所为。跟登录历史一样，若你运行 `history` 命令却没有输出任何东西那就表示历史文件被删掉了。这也是个不妙的信号，你需要很小心地检查一下服务器了。（LCTT 译注，如果没有命令历史，也有可能是你的配置错误。）
#### 检查 4 - 哪些进程在消耗 CPU？
你常遇到的这类攻击者通常不怎么会去掩盖他们做的事情。他们会运行一些特别消耗 CPU 的进程。这就很容易发现这些进程了。只需要运行 `top` 然后看最前的那几个进程就行了。
这也能显示出那些未登录进来的攻击者。比如，可能有人在用未受保护的邮件脚本来发送垃圾邮件。
如果你最上面的进程对不了解，那么你可以 Google 一下进程名称，或者通过 `losf` 和 `strace` 来看看它做的事情是什么。
使用这些工具，第一步从 `top` 中拷贝出进程的 PID，然后运行：
```
strace -p PID
```
这会显示出该进程调用的所有系统调用。它产生的内容会很多，但这些信息能告诉你这个进程在做什么。
```
lsof -p PID
```
这个程序会列出该进程打开的文件。通过查看它访问的文件可以很好的理解它在做的事情。
#### 检查 5 - 检查所有的系统进程
消耗 CPU 不严重的未授权进程可能不会在 `top` 中显露出来，不过它依然可以通过 `ps` 列出来。命令 `ps auxf` 就能显示足够清晰的信息了。
你需要检查一下每个不认识的进程。经常运行 `ps` （这是个好习惯）能帮助你发现奇怪的进程。
#### 检查 6 - 检查进程的网络使用情况
`iftop` 的功能类似 `top`，它会排列显示收发网络数据的进程以及它们的源地址和目的地址。类似 DoS 攻击或垃圾机器人这样的进程很容易显示在列表的最顶端。
#### 检查 7 - 哪些进程在监听网络连接?
通常攻击者会安装一个后门程序专门监听网络端口接受指令。该进程等待期间是不会消耗 CPU 和带宽的，因此也就不容易通过 `top` 之类的命令发现。
`lsof` 和 `netstat` 命令都会列出所有的联网进程。我通常会让它们带上下面这些参数：
```
lsof -i
```
```
netstat -plunt
```
你需要留意那些处于 `LISTEN` 和 `ESTABLISHED` 状态的进程，这些进程要么正在等待连接（LISTEN），要么已经连接（ESTABLISHED）。如果遇到不认识的进程，使用 `strace` 和 `lsof` 来看看它们在做什么东西。
### 被入侵之后该怎么办呢?
首先，不要紧张，尤其当攻击者正处于登录状态时更不能紧张。**你需要在攻击者警觉到你已经发现他之前夺回机器的控制权。**如果他发现你已经发觉到他了，那么他可能会锁死你不让你登陆服务器，然后开始毁尸灭迹。
如果你技术不太好那么就直接关机吧。你可以在服务器上运行 `shutdown -h now` 或者 `systemctl poweroff` 这两条命令之一。也可以登录主机提供商的控制面板中关闭服务器。关机后，你就可以开始配置防火墙或者咨询一下供应商的意见。
如果你对自己颇有自信，而你的主机提供商也有提供上游防火墙，那么你只需要以此创建并启用下面两条规则就行了：
1. 只允许从你的 IP 地址登录 SSH。
2. 封禁除此之外的任何东西，不仅仅是 SSH，还包括任何端口上的任何协议。
这样会立即关闭攻击者的 SSH 会话，而只留下你可以访问服务器。
如果你无法访问上游防火墙，那么你就需要在服务器本身创建并启用这些防火墙策略，然后在防火墙规则起效后使用 `kill` 命令关闭攻击者的 SSH 会话。（LCTT 译注：本地防火墙规则 有可能不会阻止已经建立的 SSH 会话，所以保险起见，你需要手工杀死该会话。）
最后还有一种方法，如果支持的话，就是通过诸如串行控制台之类的带外连接登录服务器，然后通过 `systemctl stop network.service` 停止网络功能。这会关闭所有服务器上的网络连接，这样你就可以慢慢的配置那些防火墙规则了。
重夺服务器的控制权后，也不要以为就万事大吉了。
不要试着修复这台服务器，然后接着用。你永远不知道攻击者做过什么，因此你也永远无法保证这台服务器还是安全的。
最好的方法就是拷贝出所有的数据，然后重装系统。（LCTT 译注：你的程序这时已经不可信了，但是数据一般来说没问题。）
---
via: <https://bash-prompt.net/guides/server-hacked/>
作者：[Elliot Cooper](https://bash-prompt.net) 译者：[lujun9972](https://github.com/lujun9972) 校对：[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-3-event-driven/
|
另一种常见的实现并发的方法叫做 事件驱动编程，也可以叫做 异步 编程 。这种方法变化万千，因此我们会从最基本的开始，使用一些基本的 API 而非从封装好的高级方法开始。本系列以后的文章会讲高层次抽象，还有各种混合的方法。
|
/data/attachment/album/201712/06/162148e551uz4iyjotimib.jpg.thumb.jpg
|
/data/attachment/album/201712/06/162148e551uz4iyjotimib.jpg
| true | false | true |
BriFuture
| false |
[
"并发"
] |
软件开发
|
{
"viewnum": 6586,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9002,
"displayorder": 0
},
{
"raid": 9397,
"displayorder": 0
}
] |
另一种常见的实现并发的方法叫做 事件驱动编程，也可以叫做 异步 编程 。这种方法变化万千，因此我们会从最基本的开始，使用一些基本的 API 而非从封装好的高级方法开始。本系列以后的文章会讲高层次抽象，还有各种混合的方法。
| 2017-12-08T10:20:00 | 2017-12-08T10:20:00 | 9,117 |
/article-9117-1.html
|
这是并发服务器系列的第三节。[第一节](/article-8993-1.html) 介绍了阻塞式编程，[第二节：线程](/article-9002-1.html) 探讨了多线程，将其作为一种可行的方法来实现服务器并发编程。
另一种常见的实现并发的方法叫做 *事件驱动编程*，也可以叫做 *异步* 编程 <sup> 注1</sup> 。这种方法变化万千，因此我们会从最基本的开始，使用一些基本的 API 而非从封装好的高级方法开始。本系列以后的文章会讲高层次抽象，还有各种混合的方法。
本系列的所有文章：
* [第一节 - 简介](/article-8993-1.html)
* [第二节 - 线程](/article-9002-1.html)
* [第三节 - 事件驱动](http://eli.thegreenplace.net/2017/concurrent-servers-part-3-event-driven/)
### 阻塞式 vs. 非阻塞式 I/O
作为本篇的介绍，我们先讲讲阻塞和非阻塞 I/O 的区别。阻塞式 I/O 更好理解，因为这是我们使用 I/O 相关 API 时的“标准”方式。从套接字接收数据的时候，调用 `recv` 函数会发生 *阻塞*，直到它从端口上接收到了来自另一端套接字的数据。这恰恰是第一部分讲到的顺序服务器的问题。
因此阻塞式 I/O 存在着固有的性能问题。第二节里我们讲过一种解决方法，就是用多线程。哪怕一个线程的 I/O 阻塞了，别的线程仍然可以使用 CPU 资源。实际上，阻塞 I/O 通常在利用资源方面非常高效，因为线程就等待着 —— 操作系统将线程变成休眠状态，只有满足了线程需要的条件才会被唤醒。
*非阻塞式* I/O 是另一种思路。把套接字设成非阻塞模式时，调用 `recv` 时（还有 `send`，但是我们现在只考虑接收），函数返回的会很快，哪怕没有接收到数据。这时，就会返回一个特殊的错误状态 <sup> 注2</sup> 来通知调用者，此时没有数据传进来。调用者可以去做其他的事情，或者尝试再次调用 `recv` 函数。
示范阻塞式和非阻塞式的 `recv` 区别的最好方式就是贴一段示例代码。这里有个监听套接字的小程序，一直在 `recv` 这里阻塞着；当 `recv` 返回了数据，程序就报告接收到了多少个字节 <sup> 注3</sup> ：
```
int main(int argc, const char** argv) {
setvbuf(stdout, NULL, _IONBF, 0);
int portnum = 9988;
if (argc >= 2) {
portnum = atoi(argv[1]);
}
printf("Listening on port %d\n", portnum);
int sockfd = listen_inet_socket(portnum);
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);
while (1) {
uint8_t buf[1024];
printf("Calling recv...\n");
int len = recv(newsockfd, buf, sizeof buf, 0);
if (len < 0) {
perror_die("recv");
} else if (len == 0) {
printf("Peer disconnected; I'm done.\n");
break;
}
printf("recv returned %d bytes\n", len);
}
close(newsockfd);
close(sockfd);
return 0;
}
```
主循环重复调用 `recv` 并且报告它返回的字节数（记住 `recv` 返回 0 时，就是客户端断开连接了）。试着运行它，我们会在一个终端里运行这个程序，然后在另一个终端里用 `nc` 进行连接，发送一些字符，每次发送之间间隔几秒钟：
```
$ nc localhost 9988
hello # wait for 2 seconds after typing this
socket world
^D # to end the connection>
```
监听程序会输出以下内容：
```
$ ./blocking-listener 9988
Listening on port 9988
peer (localhost, 37284) connected
Calling recv...
recv returned 6 bytes
Calling recv...
recv returned 13 bytes
Calling recv...
Peer disconnected; I'm done.
```
现在试试非阻塞的监听程序的版本。这是代码：
```
int main(int argc, const char** argv) {
setvbuf(stdout, NULL, _IONBF, 0);
int portnum = 9988;
if (argc >= 2) {
portnum = atoi(argv[1]);
}
printf("Listening on port %d\n", portnum);
int sockfd = listen_inet_socket(portnum);
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);
// 把套接字设成非阻塞模式
int flags = fcntl(newsockfd, F_GETFL, 0);
if (flags == -1) {
perror_die("fcntl F_GETFL");
}
if (fcntl(newsockfd, F_SETFL, flags | O_NONBLOCK) == -1) {
perror_die("fcntl F_SETFL O_NONBLOCK");
}
while (1) {
uint8_t buf[1024];
printf("Calling recv...\n");
int len = recv(newsockfd, buf, sizeof buf, 0);
if (len < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
usleep(200 * 1000);
continue;
}
perror_die("recv");
} else if (len == 0) {
printf("Peer disconnected; I'm done.\n");
break;
}
printf("recv returned %d bytes\n", len);
}
close(newsockfd);
close(sockfd);
return 0;
}
```
这里与阻塞版本有些差异，值得注意：
1. `accept` 函数返回的 `newsocktfd` 套接字因调用了 `fcntl`， 被设置成非阻塞的模式。
2. 检查 `recv` 的返回状态时，我们对 `errno` 进行了检查，判断它是否被设置成表示没有可供接收的数据的状态。这时，我们仅仅是休眠了 200 毫秒然后进入到下一轮循环。
同样用 `nc` 进行测试，以下是非阻塞监听器的输出：
```
$ ./nonblocking-listener 9988
Listening on port 9988
peer (localhost, 37288) connected
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
recv returned 6 bytes
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
Calling recv...
recv returned 13 bytes
Calling recv...
Calling recv...
Calling recv...
Peer disconnected; I'm done.
```
作为练习，给输出添加一个时间戳，确认调用 `recv` 得到结果之间花费的时间是比输入到 `nc` 中所用的多还是少（每一轮是 200 ms）。
这里就实现了使用非阻塞的 `recv` 让监听者检查套接字变为可能，并且在没有数据的时候重新获得控制权。换句话说，用编程的语言说这就是 <ruby> 轮询 <rt> polling </rt></ruby> —— 主程序周期性的查询套接字以便读取数据。
对于顺序响应的问题，这似乎是个可行的方法。非阻塞的 `recv` 让同时与多个套接字通信变成可能，轮询这些套接字，仅当有新数据到来时才处理。就是这样，这种方式 *可以* 用来写并发服务器；但实际上一般不这么做，因为轮询的方式很难扩展。
首先，我在代码中引入的 200ms 延迟对于演示非常好（监听器在我输入 `nc` 之间只打印几行 “Calling recv...”，但实际上应该有上千行）。但它也增加了多达 200ms 的服务器响应时间，这无意是不必要的。实际的程序中，延迟会低得多，休眠时间越短，进程占用的 CPU 资源就越多。有些时钟周期只是浪费在等待，这并不好，尤其是在移动设备上，这些设备的电量往往有限。
但是当我们实际这样来使用多个套接字的时候，更严重的问题出现了。想像下监听器正在同时处理 1000 个客户端。这意味着每一个循环迭代里面，它都得为 *这 1000 个套接字中的每一个* 执行一遍非阻塞的 `recv`，找到其中准备好了数据的那一个。这非常低效，并且极大的限制了服务器能够并发处理的客户端数。这里有个准则：每次轮询之间等待的间隔越久，服务器响应性越差；而等待的时间越少，CPU 在无用的轮询上耗费的资源越多。
讲真，所有的轮询都像是无用功。当然操作系统应该是知道哪个套接字是准备好了数据的，因此没必要逐个扫描。事实上，就是这样，接下来就会讲一些 API，让我们可以更优雅地处理多个客户端。
### select
`select` 的系统调用是可移植的（POSIX），是标准 Unix API 中常有的部分。它是为上一节最后一部分描述的问题而设计的 —— 允许一个线程可以监视许多文件描述符 <sup> 注4</sup> 的变化，而不用在轮询中执行不必要的代码。我并不打算在这里引入一个关于 `select` 的全面教程，有很多网站和书籍讲这个，但是在涉及到问题的相关内容时，我会介绍一下它的 API，然后再展示一个非常复杂的例子。
`select` 允许 *多路 I/O*，监视多个文件描述符，查看其中任何一个的 I/O 是否可用。
```
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
```
`readfds` 指向文件描述符的缓冲区，这个缓冲区被监视是否有读取事件；`fd_set` 是一个特殊的数据结构，用户使用 `FD_*` 宏进行操作。`writefds` 是针对写事件的。`nfds` 是监视的缓冲中最大的文件描述符数字（文件描述符就是整数）。`timeout` 可以让用户指定 `select` 应该阻塞多久，直到某个文件描述符准备好了（`timeout == NULL` 就是说一直阻塞着）。现在先跳过 `exceptfds`。
`select` 的调用过程如下：
1. 在调用之前，用户先要为所有不同种类的要监视的文件描述符创建 `fd_set` 实例。如果想要同时监视读取和写入事件，`readfds` 和 `writefds` 都要被创建并且引用。
2. 用户可以使用 `FD_SET` 来设置集合中想要监视的特殊描述符。例如，如果想要监视描述符 2、7 和 10 的读取事件，在 `readfds` 这里调用三次 `FD_SET`，分别设置 2、7 和 10。
3. `select` 被调用。
4. 当 `select` 返回时（现在先不管超时），就是说集合中有多少个文件描述符已经就绪了。它也修改 `readfds` 和 `writefds` 集合，来标记这些准备好的描述符。其它所有的描述符都会被清空。
5. 这时用户需要遍历 `readfds` 和 `writefds`，找到哪个描述符就绪了（使用 `FD_ISSET`）。
作为完整的例子，我在并发的服务器程序上使用 `select`，重新实现了我们之前的协议。[完整的代码在这里](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/select-server.c)；接下来的是代码中的重点部分及注释。警告：示例代码非常复杂，因此第一次看的时候，如果没有足够的时间，快速浏览也没有关系。
### 使用 select 的并发服务器
使用 I/O 的多发 API 诸如 `select` 会给我们服务器的设计带来一些限制；这不会马上显现出来，但这值得探讨，因为它们是理解事件驱动编程到底是什么的关键。
最重要的是，要记住这种方法本质上是单线程的 <sup> 注5</sup> 。服务器实际上在 *同一时刻只能做一件事*。因为我们想要同时处理多个客户端请求，我们需要换一种方式重构代码。
首先，让我们谈谈主循环。它看起来是什么样的呢？先让我们想象一下服务器有一堆任务，它应该监视哪些东西呢？两种类型的套接字活动：
1. 新客户端尝试连接。这些客户端应该被 `accept`。
2. 已连接的客户端发送数据。这个数据要用 [第一节](/article-8993-1.html) 中所讲到的协议进行传输，有可能会有一些数据要被回送给客户端。
尽管这两种活动在本质上有所区别，我们还是要把它们放在一个循环里，因为只能有一个主循环。循环会包含 `select` 的调用。这个 `select` 的调用会监视上述的两种活动。
这里是部分代码，设置了文件描述符集合，并在主循环里转到被调用的 `select` 部分。
```
// “master” 集合存活在该循环中，跟踪我们想要监视的读取事件或写入事件的文件描述符（FD）。
fd_set readfds_master;
FD_ZERO(&readfds_master);
fd_set writefds_master;
FD_ZERO(&writefds_master);
// 监听的套接字一直被监视，用于读取数据，并监测到来的新的端点连接。
FD_SET(listener_sockfd, &readfds_master);
// 要想更加高效，fdset_max 追踪当前已知最大的 FD；这使得每次调用时对 FD_SETSIZE 的迭代选择不是那么重要了。
int fdset_max = listener_sockfd;
while (1) {
// select() 会修改传递给它的 fd_sets，因此进行拷贝一下再传值。
fd_set readfds = readfds_master;
fd_set writefds = writefds_master;
int nready = select(fdset_max + 1, &readfds, &writefds, NULL, NULL);
if (nready < 0) {
perror_die("select");
}
...
```
这里的一些要点：
1. 由于每次调用 `select` 都会重写传递给函数的集合，调用器就得维护一个 “master” 集合，在循环迭代中，保持对所监视的所有活跃的套接字的追踪。
2. 注意我们所关心的，最开始的唯一那个套接字是怎么变成 `listener_sockfd` 的，这就是最开始的套接字，服务器借此来接收新客户端的连接。
3. `select` 的返回值，是在作为参数传递的集合中，那些已经就绪的描述符的个数。`select` 修改这个集合，用来标记就绪的描述符。下一步是在这些描述符中进行迭代。
```
...
for (int fd = 0; fd <= fdset_max && nready > 0; fd++) {
// 检查 fd 是否变成可读的
if (FD_ISSET(fd, &readfds)) {
nready--;
if (fd == listener_sockfd) {
// 监听的套接字就绪了；这意味着有个新的客户端连接正在联系
...
} else {
fd_status_t status = on_peer_ready_recv(fd);
if (status.want_read) {
FD_SET(fd, &readfds_master);
} else {
FD_CLR(fd, &readfds_master);
}
if (status.want_write) {
FD_SET(fd, &writefds_master);
} else {
FD_CLR(fd, &writefds_master);
}
if (!status.want_read && !status.want_write) {
printf("socket %d closing\n", fd);
close(fd);
}
}
```
这部分循环检查 *可读的* 描述符。让我们跳过监听器套接字（要浏览所有内容，[看这个代码](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/select-server.c)） 然后看看当其中一个客户端准备好了之后会发生什么。出现了这种情况后，我们调用一个叫做 `on_peer_ready_recv` 的 *回调* 函数，传入相应的文件描述符。这个调用意味着客户端连接到套接字上，发送某些数据，并且对套接字上 `recv` 的调用不会被阻塞 <sup> 注6</sup> 。这个回调函数返回结构体 `fd_status_t`。
```
typedef struct {
bool want_read;
bool want_write;
} fd_status_t;
```
这个结构体告诉主循环，是否应该监视套接字的读取事件、写入事件，或者两者都监视。上述代码展示了 `FD_SET` 和 `FD_CLR` 是怎么在合适的描述符集合中被调用的。对于主循环中某个准备好了写入数据的描述符，代码是类似的，除了它所调用的回调函数，这个回调函数叫做 `on_peer_ready_send`。
现在来花点时间看看这个回调：
```
typedef enum { INITIAL_ACK, WAIT_FOR_MSG, IN_MSG } ProcessingState;
#define SENDBUF_SIZE 1024
typedef struct {
ProcessingState state;
// sendbuf 包含了服务器要返回给客户端的数据。on_peer_ready_recv 句柄填充这个缓冲，
// on_peer_read_send 进行消耗。sendbuf_end 指向缓冲区的最后一个有效字节，
// sendptr 指向下个字节
uint8_t sendbuf[SENDBUF_SIZE];
int sendbuf_end;
int sendptr;
} peer_state_t;
// 每一端都是通过它连接的文件描述符（fd）进行区分。只要客户端连接上了，fd 就是唯一的。
// 当客户端断开连接，另一个客户端连接上就会获得相同的 fd。on_peer_connected 应该
// 进行初始化，以便移除旧客户端在同一个 fd 上留下的东西。
peer_state_t global_state[MAXFDS];
fd_status_t on_peer_ready_recv(int sockfd) {
assert(sockfd < MAXFDs);
peer_state_t* peerstate = &global_state[sockfd];
if (peerstate->state == INITIAL_ACK ||
peerstate->sendptr < peerstate->sendbuf_end) {
// 在初始的 ACK 被送到了客户端，就没有什么要接收的了。
// 等所有待发送的数据都被发送之后接收更多的数据。
return fd_status_W;
}
uint8_t buf[1024];
int nbytes = recv(sockfd, buf, sizeof buf, 0);
if (nbytes == 0) {
// 客户端断开连接
return fd_status_NORW;
} else if (nbytes < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
// 套接字 *实际* 并没有准备好接收，等到它就绪。
return fd_status_R;
} else {
perror_die("recv");
}
}
bool ready_to_send = false;
for (int i = 0; i < nbytes; ++i) {
switch (peerstate->state) {
case INITIAL_ACK:
assert(0 && "can't reach here");
break;
case WAIT_FOR_MSG:
if (buf[i] == '^') {
peerstate->state = IN_MSG;
}
break;
case IN_MSG:
if (buf[i] == '$') {
peerstate->state = WAIT_FOR_MSG;
} else {
assert(peerstate->sendbuf_end < SENDBUF_SIZE);
peerstate->sendbuf[peerstate->sendbuf_end++] = buf[i] + 1;
ready_to_send = true;
}
break;
}
}
// 如果没有数据要发送给客户端，报告读取状态作为最后接收的结果。
return (fd_status_t){.want_read = !ready_to_send,
.want_write = ready_to_send};
}
```
`peer_state_t` 是全状态对象，用来表示在主循环中两次回调函数调用之间的客户端的连接。因为回调函数在客户端发送的某些数据时被调用，不能假设它能够不停地与客户端通信，并且它得运行得很快，不能被阻塞。因为套接字被设置成非阻塞模式，`recv` 会快速的返回。除了调用 `recv`， 这个句柄做的是处理状态，没有其它的调用，从而不会发生阻塞。
举个例子，你知道为什么这个代码需要一个额外的状态吗？这个系列中，我们的服务器目前只用到了两个状态，但是这个服务器程序需要三个状态。
来看看 “套接字准备好发送” 的回调函数：
```
fd_status_t on_peer_ready_send(int sockfd) {
assert(sockfd < MAXFDs);
peer_state_t* peerstate = &global_state[sockfd];
if (peerstate->sendptr >= peerstate->sendbuf_end) {
// 没有要发送的。
return fd_status_RW;
}
int sendlen = peerstate->sendbuf_end - peerstate->sendptr;
int nsent = send(sockfd, peerstate->sendbuf, sendlen, 0);
if (nsent == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
return fd_status_W;
} else {
perror_die("send");
}
}
if (nsent < sendlen) {
peerstate->sendptr += nsent;
return fd_status_W;
} else {
// 所有东西都成功发送；重置发送队列。
peerstate->sendptr = 0;
peerstate->sendbuf_end = 0;
// 如果我们现在是处于特殊的 INITIAL_ACK 状态，就转变到其他状态。
if (peerstate->state == INITIAL_ACK) {
peerstate->state = WAIT_FOR_MSG;
}
return fd_status_R;
}
}
```
这里也一样，回调函数调用了一个非阻塞的 `send`，演示了状态管理。在异步代码中，回调函数执行的很快是受争议的，任何延迟都会阻塞主循环进行处理，因此也阻塞了整个服务器程序去处理其他的客户端。
用脚步再来运行这个服务器，同时连接 3 个客户端。在一个终端中我们运行下面的命令：
```
$ ./select-server
```
在另一个终端中：
```
$ python3.6 simple-client.py -n 3 localhost 9090
INFO:2017-09-26 05:29:15,864:conn1 connected...
INFO:2017-09-26 05:29:15,864:conn2 connected...
INFO:2017-09-26 05:29:15,864:conn0 connected...
INFO:2017-09-26 05:29:15,865:conn1 sending b'^abc$de^abte$f'
INFO:2017-09-26 05:29:15,865:conn2 sending b'^abc$de^abte$f'
INFO:2017-09-26 05:29:15,865:conn0 sending b'^abc$de^abte$f'
INFO:2017-09-26 05:29:15,865:conn1 received b'bcdbcuf'
INFO:2017-09-26 05:29:15,865:conn2 received b'bcdbcuf'
INFO:2017-09-26 05:29:15,865:conn0 received b'bcdbcuf'
INFO:2017-09-26 05:29:16,866:conn1 sending b'xyz^123'
INFO:2017-09-26 05:29:16,867:conn0 sending b'xyz^123'
INFO:2017-09-26 05:29:16,867:conn2 sending b'xyz^123'
INFO:2017-09-26 05:29:16,867:conn1 received b'234'
INFO:2017-09-26 05:29:16,868:conn0 received b'234'
INFO:2017-09-26 05:29:16,868:conn2 received b'234'
INFO:2017-09-26 05:29:17,868:conn1 sending b'25$^ab0000$abab'
INFO:2017-09-26 05:29:17,869:conn1 received b'36bc1111'
INFO:2017-09-26 05:29:17,869:conn0 sending b'25$^ab0000$abab'
INFO:2017-09-26 05:29:17,870:conn0 received b'36bc1111'
INFO:2017-09-26 05:29:17,870:conn2 sending b'25$^ab0000$abab'
INFO:2017-09-26 05:29:17,870:conn2 received b'36bc1111'
INFO:2017-09-26 05:29:18,069:conn1 disconnecting
INFO:2017-09-26 05:29:18,070:conn0 disconnecting
INFO:2017-09-26 05:29:18,070:conn2 disconnecting
```
和线程的情况相似，客户端之间没有延迟，它们被同时处理。而且在 `select-server` 也没有用线程！主循环 *多路* 处理所有的客户端，通过高效使用 `select` 轮询多个套接字。回想下 [第二节中](/article-9002-1.html) 顺序的 vs 多线程的客户端处理过程的图片。对于我们的 `select-server`，三个客户端的处理流程像这样：
所有的客户端在同一个线程中同时被处理，通过乘积，做一点这个客户端的任务，然后切换到另一个，再切换到下一个，最后切换回到最开始的那个客户端。注意，这里没有什么循环调度，客户端在它们发送数据的时候被客户端处理，这实际上是受客户端左右的。
### 同步、异步、事件驱动、回调
`select-server` 示例代码为讨论什么是异步编程、它和事件驱动及基于回调的编程有何联系，提供了一个良好的背景。因为这些词汇在并发服务器的（非常矛盾的）讨论中很常见。
让我们从一段 `select` 的手册页面中引用的一句话开始：
>
> select，pselect，FD\_CLR，FD\_ISSET，FD\_SET，FD\_ZERO - 同步 I/O 处理
>
>
>
因此 `select` 是 *同步* 处理。但我刚刚演示了大量代码的例子，使用 `select` 作为 *异步* 处理服务器的例子。有哪些东西？
答案是：这取决于你的观察角度。同步常用作阻塞处理，并且对 `select` 的调用实际上是阻塞的。和第 1、2 节中讲到的顺序的、多线程的服务器中对 `send` 和 `recv` 是一样的。因此说 `select` 是 *同步的* API 是有道理的。可是，服务器的设计却可以是 *异步的*，或是 *基于回调的*，或是 *事件驱动的*，尽管其中有对 `select` 的使用。注意这里的 `on_peer_*` 函数是回调函数；它们永远不会阻塞，并且只有网络事件触发的时候才会被调用。它们可以获得部分数据，并能够在调用过程中保持稳定的状态。
如果你曾经做过一些 GUI 编程，这些东西对你来说应该很亲切。有个 “事件循环”，常常完全隐藏在框架里，应用的 “业务逻辑” 建立在回调上，这些回调会在各种事件触发后被调用，用户点击鼠标、选择菜单、定时器触发、数据到达套接字等等。曾经最常见的编程模型是客户端的 JavaScript，这里面有一堆回调函数，它们在浏览网页时用户的行为被触发。
### select 的局限
使用 `select` 作为第一个异步服务器的例子对于说明这个概念很有用，而且由于 `select` 是很常见、可移植的 API。但是它也有一些严重的缺陷，在监视的文件描述符非常大的时候就会出现。
1. 有限的文件描述符的集合大小。
2. 糟糕的性能。
从文件描述符的大小开始。`FD_SETSIZE` 是一个编译期常数，在如今的操作系统中，它的值通常是 1024。它被硬编码在 `glibc` 的头文件里，并且不容易修改。它把 `select` 能够监视的文件描述符的数量限制在 1024 以内。曾有些人想要写出能够处理上万个并发访问的客户端请求的服务器，所以这个问题很有现实意义。有一些方法，但是不可移植，也很难用。
糟糕的性能问题就好解决的多，但是依然非常严重。注意当 `select` 返回的时候，它向调用者提供的信息是 “就绪的” 描述符的个数，还有被修改过的描述符集合。描述符集映射着描述符“就绪/未就绪”，但是并没有提供什么有效的方法去遍历所有就绪的描述符。如果只有一个描述符是就绪的，最坏的情况是调用者需要遍历 *整个集合* 来找到那个描述符。这在监视的描述符数量比较少的时候还行，但是如果数量变的很大的时候，这种方法弊端就凸显出了 <sup> 注7</sup> 。
由于这些原因，为了写出高性能的并发服务器， `select` 已经不怎么用了。每一个流行的操作系统有独特的不可移植的 API，允许用户写出非常高效的事件循环；像框架这样的高级结构还有高级语言通常在一个可移植的接口中包含这些 API。
### epoll
举个例子，来看看 `epoll`，Linux 上的关于高容量 I/O 事件通知问题的解决方案。`epoll` 高效的关键之处在于它与内核更好的协作。不是使用文件描述符，`epoll_wait` 用当前准备好的事件填满一个缓冲区。只有准备好的事件添加到了缓冲区，因此没有必要遍历客户端中当前 *所有* 监视的文件描述符。这简化了查找就绪的描述符的过程，把空间复杂度从 `select` 中的 O(N) 变为了 O(1)。
关于 `epoll` API 的完整展示不是这里的目的，网上有很多相关资源。虽然你可能猜到了，我还要写一个不同的并发服务器，这次是用 `epool` 而不是 `select`。完整的示例代码 [在这里](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/epoll-server.c)。实际上，由于大部分代码和 `用 select 的服务器`相同，所以我只会讲要点，在主循环里使用 `epoll`：
```
struct epoll_event accept_event;
accept_event.data.fd = listener_sockfd;
accept_event.events = EPOLLIN;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listener_sockfd, &accept_event) < 0) {
perror_die("epoll_ctl EPOLL_CTL_ADD");
}
struct epoll_event* events = calloc(MAXFDS, sizeof(struct epoll_event));
if (events == NULL) {
die("Unable to allocate memory for epoll_events");
}
while (1) {
int nready = epoll_wait(epollfd, events, MAXFDS, -1);
for (int i = 0; i < nready; i++) {
if (events[i].events & EPOLLERR) {
perror_die("epoll_wait returned EPOLLERR");
}
if (events[i].data.fd == listener_sockfd) {
// 监听的套接字就绪了；意味着新客户端正在连接。
...
} else {
// A peer socket is ready.
if (events[i].events & EPOLLIN) {
// 准备好了读取
...
} else if (events[i].events & EPOLLOUT) {
// 准备好了写入
...
}
}
}
}
```
通过调用 `epoll_ctl` 来配置 `epoll`。这时，配置监听的套接字数量，也就是 `epoll` 监听的描述符的数量。然后分配一个缓冲区，把就绪的事件传给 `epoll` 以供修改。在主循环里对 `epoll_wait` 的调用是魅力所在。它阻塞着，直到某个描述符就绪了（或者超时），返回就绪的描述符数量。但这时，不要盲目地迭代所有监视的集合，我们知道 `epoll_write` 会修改传给它的 `events` 缓冲区，缓冲区中有就绪的事件，从 0 到 `nready-1`，因此我们只需迭代必要的次数。
要在 `select` 里面重新遍历，有明显的差异：如果在监视着 1000 个描述符，只有两个就绪， `epoll_waits` 返回的是 `nready=2`，然后修改 `events` 缓冲区最前面的两个元素，因此我们只需要“遍历”两个描述符。用 `select` 我们就需要遍历 1000 个描述符，找出哪个是就绪的。因此，在繁忙的服务器上，有许多活跃的套接字时 `epoll` 比 `select` 更加容易扩展。
剩下的代码很直观，因为我们已经很熟悉 “select 服务器” 了。实际上，“epoll 服务器” 中的所有“业务逻辑”和 “select 服务器” 是一样的，回调构成相同的代码。
这种相似是通过将事件循环抽象分离到一个库/框架中。我将会详述这些内容，因为很多优秀的程序员曾经也是这样做的。相反，下一篇文章里我们会了解 libuv，一个最近出现的更加受欢迎的时间循环抽象层。像 libuv 这样的库让我们能够写出并发的异步服务器，并且不用考虑系统调用下繁琐的细节。
---
* 注1：我试着在做网络浏览和阅读这两件事的实际差别中突显自己，但经常做得头疼。有很多不同的选项，从“它们是一样的东西”到“一个是另一个的子集”，再到“它们是完全不同的东西”。在面临这样主观的观点时，最好是完全放弃这个问题，专注特殊的例子和用例。
* 注2：POSIX 表示这可以是 `EAGAIN`，也可以是 `EWOULDBLOCK`，可移植应用应该对这两个都进行检查。
* 注3：和这个系列所有的 C 示例类似，代码中用到了某些助手工具来设置监听套接字。这些工具的完整代码在这个 [仓库](https://github.com/eliben/code-for-blog/blob/master/2017/async-socket-server/utils.h) 的 `utils` 模块里。
* 注4：`select` 不是网络/套接字专用的函数，它可以监视任意的文件描述符，有可能是硬盘文件、管道、终端、套接字或者 Unix 系统中用到的任何文件描述符。这篇文章里，我们主要关注它在套接字方面的应用。
* 注5：有多种方式用多线程来实现事件驱动，我会把它放在稍后的文章中进行讨论。
* 注6：由于各种非实验因素，它 *仍然* 可以阻塞，即使是在 `select` 说它就绪了之后。因此服务器上打开的所有套接字都被设置成非阻塞模式，如果对 `recv` 或 `send` 的调用返回了 `EAGAIN` 或者 `EWOULDBLOCK`，回调函数就装作没有事件发生。阅读示例代码的注释可以了解更多细节。
* 注7：注意这比该文章前面所讲的异步轮询的例子要稍好一点。轮询需要 *一直* 发生，而 `select` 实际上会阻塞到有一个或多个套接字准备好读取/写入；`select` 会比一直询问浪费少得多的 CPU 时间。
---
via: <https://eli.thegreenplace.net/2017/concurrent-servers-part-3-event-driven/>
作者：[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/) 荣誉推出
|
||
如何使用 GPG 加解密文件
|
Nick Congleton
|
https://linuxconfig.org/how-to-encrypt-and-decrypt-individual-files-with-gpg
|
加密非常重要。它对于保护敏感信息来说是必不可少的。你的私人文件应该要被加密，而 GPG 提供了很好的解决方案。
|
/data/attachment/album/201712/06/235030pafawqxu58jl6yn6.jpg.thumb.jpg
|
/data/attachment/album/201712/06/235030pafawqxu58jl6yn6.jpg
| true | false | true |
lujun9972
| false |
[
"gpg",
"加密",
"解密"
] |
技术
|
{
"viewnum": 9985,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
加密非常重要。它对于保护敏感信息来说是必不可少的。你的私人文件应该要被加密，而 GPG 提供了很好的解决方案。
| 2017-12-06T23:50:35 | 2017-12-06T23:50:35 | 9,118 |
/article-9118-1.html
|
目标：使用 GPG 加密文件
发行版：适用于任何发行版
要求：安装了 GPG 的 Linux 或者拥有 root 权限来安装它。
难度：简单
约定：
* `#` - 需要使用 root 权限来执行指定命令，可以直接使用 root 用户来执行，也可以使用 `sudo` 命令
* `$` - 可以使用普通用户来执行指定命令
### 介绍
加密非常重要。它对于保护敏感信息来说是必不可少的。你的私人文件应该要被加密，而 GPG 提供了很好的解决方案。
### 安装 GPG
GPG 的使用非常广泛。你在几乎每个发行版的仓库中都能找到它。如果你还没有安装它，那现在就来安装一下吧。
**Debian/Ubuntu**
```
$ sudo apt install gnupg
```
**Fedora**
```
# dnf install gnupg2
```
**Arch**
```
# pacman -S gnupg
```
**Gentoo**
```
# emerge --ask app-crypt/gnupg
```
### 创建密钥
你需要一个密钥对来加解密文件。如果你为 SSH 已经生成过了密钥对，那么你可以直接使用它。如果没有，GPG 包含工具来生成密钥对。
```
$ gpg --full-generate-key
```
GPG 有一个命令行程序可以帮你一步一步的生成密钥。它还有一个简单得多的工具，但是这个工具不能让你设置密钥类型，密钥的长度以及过期时间，因此不推荐使用这个工具。
GPG 首先会询问你密钥的类型。没什么特别的话选择默认值就好。
下一步需要设置密钥长度。`4096` 是一个不错的选择。
之后，可以设置过期的日期。 如果希望密钥永不过期则设置为 `0`。
然后，输入你的名称。
最后，输入电子邮件地址。
如果你需要的话，还能添加一个注释。
所有这些都完成后，GPG 会让你校验一下这些信息。
GPG 还会问你是否需要为密钥设置密码。这一步是可选的， 但是会增加保护的程度。若需要设置密码，则 GPG 会收集你的操作信息来增加密钥的健壮性。 所有这些都完成后， GPG 会显示密钥相关的信息。
### 加密的基本方法
现在你拥有了自己的密钥，加密文件非常简单。 使用下面的命令在 `/tmp` 目录中创建一个空白文本文件。
```
$ touch /tmp/test.txt
```
然后用 GPG 来加密它。这里 `-e` 标志告诉 GPG 你想要加密文件， `-r` 标志指定接收者。
```
$ gpg -e -r "Your Name" /tmp/test.txt
```
GPG 需要知道这个文件的接收者和发送者。由于这个文件给是你的，因此无需指定发送者，而接收者就是你自己。
### 解密的基本方法
你收到加密文件后，就需要对它进行解密。 你无需指定解密用的密钥。 这个信息被编码在文件中。 GPG 会尝试用其中的密钥进行解密。
```
$ gpg -d /tmp/test.txt.gpg
```
### 发送文件
假设你需要发送文件给别人。你需要有接收者的公钥。 具体怎么获得密钥由你自己决定。 你可以让他们直接把公钥发送给你， 也可以通过密钥服务器来获取。
收到对方公钥后，导入公钥到 GPG 中。
```
$ gpg --import yourfriends.key
```
这些公钥与你自己创建的密钥一样，自带了名称和电子邮件地址的信息。 记住，为了让别人能解密你的文件，别人也需要你的公钥。 因此导出公钥并将之发送出去。
```
gpg --export -a "Your Name" > your.key
```
现在可以开始加密要发送的文件了。它跟之前的步骤差不多， 只是需要指定你自己为发送人。
```
$ gpg -e -u "Your Name" -r "Their Name" /tmp/test.txt
```
### 结语
就这样了。GPG 还有一些高级选项， 不过你在 99% 的时间内都不会用到这些高级选项。 GPG 就是这么易于使用。你也可以使用创建的密钥对来发送和接受加密邮件，其步骤跟上面演示的差不多， 不过大多数的电子邮件客户端在拥有密钥的情况下会自动帮你做这个动作。
---
via: <https://linuxconfig.org/how-to-encrypt-and-decrypt-individual-files-with-gpg>
作者：[Nick Congleton](https://linuxconfig.org) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux 中国](https://linux.cn/) 荣誉推出
|
||
Mark McIntyre：与 Fedora 的那些事
|
Charles Profitt
|
https://fedoramagazine.org/mark-mcintyre-fedora/
|
最近我们采访了 Mark McIntyre，谈了他是如何使用 Fedora 系统的。这也是 Fedora 杂志上系列文章的一部分。该系列简要介绍了 Fedora 用户，以及他们是如何用 Fedora 把事情做好的。
|
/data/attachment/album/201712/07/093534f3fs7rbbr5lbu3q5.jpg.thumb.jpg
|
/data/attachment/album/201712/07/093534f3fs7rbbr5lbu3q5.jpg
| true | false | true |
zrszrszrs
| false |
[
"Fedora"
] |
观点
|
{
"viewnum": 3855,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
最近我们采访了 Mark McIntyre，谈了他是如何使用 Fedora 系统的。这也是 Fedora 杂志上系列文章的一部分。该系列简要介绍了 Fedora 用户，以及他们是如何用 Fedora 把事情做好的。
| 2017-12-07T09:35:31 | 2017-12-07T09:35:31 | 9,119 |
/article-9119-1.html
|
最近我们采访了 Mark McIntyre，谈了他是如何使用 Fedora 系统的。这也是 Fedora 杂志上[系列文章的一部分](https://fedoramagazine.org/tag/how-do-you-fedora/)。该系列简要介绍了 Fedora 用户，以及他们是如何用 Fedora 把事情做好的。如果你想成为采访对象，请通过[反馈表](https://fedoramagazine.org/submit-an-idea-or-tip/)与我们联系。
### Mark McIntyre 是谁?
Mark McIntyre 为极客而生，以 Linux 为乐趣。他说：“我在 13 岁开始编程，当时自学 BASIC 语言，我体会到其中的乐趣，并在乐趣的引导下，一步步成为专业的码农。” Mark 和他的侄女都是披萨饼的死忠粉。“去年秋天，我和我的侄女开始了一个任务，去尝试诺克斯维尔的许多披萨饼连锁店。点击[这里](https://knox-pizza-quest.blogspot.com/)可以了解我们的进展情况。”Mark 也是一名业余的摄影爱好者，并且在 Flickr 上 [发布自己的作品](https://www.flickr.com/photos/mockgeek/)。
作为一名开发者，Mark 有着丰富的工作背景。他用过 Visual Basic 编写应用程序，用过 LotusScript、 PL/SQL（Oracle）、 Tcl/TK 编写代码，也用过基于 Python 的 Django 框架。他的强项是 Python。这也是目前他作为系统工程师的工作语言。“我经常使用 Python。由于我的工作变得更像是自动化工程师， Python 用得就更频繁了。”
McIntyre 自称是个书呆子，喜欢科幻电影，但他最喜欢的一部电影却不是科幻片。“尽管我是个书呆子，喜欢看《<ruby> 星际迷航 <rt> Star Trek </rt></ruby>》、《<ruby> 星球大战 <rt> Star Wars </rt></ruby>》之类的影片，但《<ruby> 光荣战役 <rt> Glory </rt></ruby>》或许才是我最喜欢的电影。”他还提到，电影《<ruby> 冲出宁静号 <rt> Serenity </rt></ruby>》是一个著名电视剧的精彩后续（指《萤火虫》）。
Mark 比较看重他人的谦逊、知识与和气。他欣赏能够设身处地为他人着想的人。“如果你决定为另一个人服务，那么你会选择自己愿意亲近的人，而不是让自己备受折磨的人。”
McIntyre 目前在 [Scripps Networks Interactive](http://www.scrippsnetworksinteractive.com/) 工作，这家公司是 HGTV、Food Network、Travel Channel、DIY、GAC 以及其他几个有线电视频道的母公司。“我现在是一名系统工程师，负责非线性视频内容，这是所有媒体要开展线上消费所需要的。”他为一些开发团队提供支持，他们编写应用程序，将线性视频从有线电视发布到线上平台，比如亚马逊、葫芦。这些系统既包含预置系统，也包含云系统。Mark 还开发了一些自动化工具，将这些应用程序主要部署到云基础结构中。
### Fedora 社区
Mark 形容 Fedora 社区是一个富有活力的社区，充满着像 Fedora 用户一样热爱生活的人。“从设计师到封包人，这个团体依然非常活跃，生机勃勃。” 他继续说道：“这使我对该操作系统抱有一种信心。”
2002 年左右，Mark 开始经常使用 IRC 上的 #fedora 频道：“那时候，Wi-Fi 在启用适配器和配置模块功能时，有许多还是靠手工实现的。”为了让他的 Wi-Fi 能够工作，他不得不重新去编译 Fedora 内核。
McIntyre 鼓励他人参与 Fedora 社区。“这里有许多来自不同领域的机会。前端设计、测试部署、开发、应用程序打包以及新技术实现。”他建议选择一个感兴趣的领域，然后向那个团体提出疑问。“这里有许多机会去奉献自己。”
对于帮助他起步的社区成员，Mark 赞道：“Ben Williams 非常乐于助人。在我第一次接触 Fedora 时，他帮我搞定了一些 #fedora 支持频道中的安装补丁。” Ben 也鼓励 Mark 去做 Fedora [大使](https://fedoraproject.org/wiki/Ambassadors)。
### 什么样的硬件和软件?
McIntyre 将 Fedora Linux 系统用在他的笔记本和台式机上。在服务器上他选择了 CentOS，因为它有更长的生命周期支持。他现在的台式机是自己组装的，配有 Intel 酷睿 i5 处理器，32GB 的内存和2TB 的硬盘。“我装了个 4K 的显示屏，有足够大的地方来同时查看所有的应用。”他目前工作用的笔记本是戴尔灵越二合一，配备 13 英寸的屏，16 GB 的内存和 525 GB 的 m.2 固态硬盘。
Mark 现在将 Fedora 26 运行在他过去几个月装配的所有机器中。当一个新版本正式发布的时候，他倾向于避开这个高峰期。“除非在它即将发行的时候，我的工作站中有个正在运行下一代测试版本，通常情况下，一旦它发展成熟，我都会试着去获取最新的版本。”他经常采取就地更新：“这种就地更新方法利用 dnf 系统升级插件，目前表现得非常好。”
为了搞摄影，McIntyre 用上了 [GIMP](https://www.gimp.org/)、[Darktable](http://www.darktable.org/)，以及其他一些照片查看包和快速编辑包。当不用 Web 电子邮件时，Mark 会使用 [Geary](https://wiki.gnome.org/Apps/Geary)，还有[GNOME Calendar](https://wiki.gnome.org/Apps/Calendar)。Mark 选用 HexChat 作为 IRC 客户端，[HexChat](https://hexchat.github.io/) 与在 Fedora 服务器实例上运行的 [ZNC bouncer](https://wiki.znc.in/ZNC) 联机。他的部门通过 Slave 进行沟通交流。
“我从来都不是 IDE 粉，所以大多数的编辑任务都是在 [vim](http://www.vim.org/) 上完成的。”Mark 偶尔也会打开一个简单的文本编辑器，如 [gedit](https://wiki.gnome.org/Apps/Gedit)，或者 [xed](https://github.com/linuxmint/xed)。他用 [GPaste](https://github.com/Keruspe/GPaste) 做复制和粘贴工作。“对于终端的选择，我已经变成 [Tilix](https://fedoramagazine.org/try-tilix-new-terminal-emulator-fedora/) 的忠粉。”McIntyre 通过 [Rhythmbox](https://wiki.gnome.org/Apps/Rhythmbox) 来管理他喜欢的播客，并用 [Epiphany](https://wiki.gnome.org/Apps/Web) 实现快速网络查询。
---
via: <https://fedoramagazine.org/mark-mcintyre-fedora/>
作者：[Charles Profitt](https://fedoramagazine.org/author/cprofitt/) 译者：[zrszrszrs](https://github.com/zrszrszrs) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
2017 年 30 款最好的支持 Linux 的 Steam 游戏
|
Ankush Das
|
https://itsfoss.com/best-linux-games-steam/
|
在几年之前， Steam for Linux 上可玩的游戏并不是很吸引人。但现在情况完全不一样了。Steam 商店里现在有许多支持 Linux 平台的游戏（包括很多主流大作）。我们在本文中将介绍 Steam 上最好的一些 Linux 游戏。
|
/data/attachment/album/201712/07/114916ad8altt8xwwpqozw.jpg.thumb.jpg
|
/data/attachment/album/201712/07/114916ad8altt8xwwpqozw.jpg
| true | false | true |
yixunx
| true |
[
"游戏",
"Steam"
] |
分享
|
{
"viewnum": 35109,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "60.209.105.170",
"message": "现在忙得没有时间玩游戏了。",
"username": "绿色圣光 [Firefox 57.0|GNU/Linux]",
"date": "2017-12-07T14:23:28"
}
] |
[
{
"raid": 1971,
"displayorder": 0
},
{
"raid": 6993,
"displayorder": 0
},
{
"raid": 7316,
"displayorder": 2
},
{
"raid": 8004,
"displayorder": 3
},
{
"raid": 8686,
"displayorder": 4
}
] |
在几年之前， Steam for Linux 上可玩的游戏并不是很吸引人。但现在情况完全不一样了。Steam 商店里现在有许多支持 Linux 平台的游戏（包括很多主流大作）。我们在本文中将介绍 Steam 上最好的一些 Linux 游戏。
| 2017-12-07T12:11:00 | 2017-12-07T12:11:00 | 9,120 |
/article-9120-1.html
|
说到游戏，人们一般都会推荐使用 Windows 系统。Windows 能提供更好的显卡支持和硬件兼容性，所以对于游戏爱好者来说的确是个更好的选择。但你是否想过[在 Linux 系统上玩游戏](/article-7316-1.html)？这的确是可以的，也许你以前还曾经考虑过。但在几年之前， [Steam for Linux](https://itsfoss.com/install-steam-ubuntu-linux/) 上可玩的游戏并不是很吸引人。
但现在情况完全不一样了。Steam 商店里现在有许多支持 Linux 平台的游戏（包括很多主流大作）。我们在本文中将介绍 Steam 上最好的一些 Linux 游戏。
在进入正题之前，先介绍一个省钱小窍门。如果你是个狂热的游戏爱好者，在游戏上花费很多时间和金钱的话，我建议你订阅 [<ruby> Humble 每月包 <rt> Humble Monthly </rt></ruby>](https://www.humblebundle.com/?partner=itsfoss)。这是个每月收费的订阅服务，每月只用 12 美元就能获得价值 100 美元的游戏。
这个游戏包中可能有些游戏不支持 Linux，但除了 Steam 游戏之外，它还会让 [Humble Bundle 网站](https://www.humblebundle.com/store?partner=itsfoss)上所有的游戏和书籍都打九折，所以这依然是个不错的优惠。
更棒的是，你在 Humble Bundle 上所有的消费都会捐出一部分给慈善机构。所以你在享受游戏的同时还在帮助改变世界。
### Steam 上最好的 Linux 游戏
以下排名无先后顺序。
额外提示：虽然在 Steam 上有很多支持 Linux 的游戏，但你在 Linux 上玩游戏时依然可能会遇到各种问题。你可以阅读我们之前的文章：[每个 Linux 游戏玩家都会遇到的烦人问题](https://itsfoss.com/linux-gaming-problems/)。
### Steam 上最佳 Linux 动作类游戏
#### 1、 《<ruby> 反恐精英：全球攻势 <rt> Counter-Strike: Global Offensive </rt></ruby>》（多人）
《CS:GO》毫无疑问是 Steam 上支持 Linux 的最好的 FPS 游戏之一。我觉得这款游戏无需介绍，但如果你没有听说过它，我要告诉你这将会是你玩过的最好玩的多人 FPS 游戏之一。《CS:GO》还是电子竞技中的一个主流项目。想要提升等级的话，你需要在天梯上和其他玩家同台竞技。但你也可以选择更加轻松的休闲模式。
我本想写《彩虹六号：围攻行动》，但它目前还不支持 Linux 或 Steam OS。
* [购买《CS: GO》](http://store.steampowered.com/app/730/CounterStrike_Global_Offensive/)
#### 2、 《<ruby> 求生之路 2 <rt> Left 4 Dead 2 </rt></ruby>》（多人/单机）
这是最受欢迎的僵尸主题多人 FPS 游戏之一。在 Steam 优惠时，价格可以低至 1.3 美元。这是个有趣的游戏，能让你体会到你在僵尸游戏中期待的战栗和刺激。游戏中的环境包括了沼泽、城市、墓地等等，让游戏既有趣又吓人。游戏中的枪械并不是非常先进，但作为一个老游戏来说，它已经提供了足够真实的体验。
* [购买《求生之路 2》](http://store.steampowered.com/app/550/Left_4_Dead_2/)
#### 3、 《<ruby> 无主之地 2 <rt> Borderlands 2 </rt></ruby>》（单机/协作）
《无主之地 2》是个很有意思的 FPS 游戏。它和你以前玩过的游戏完全不同。画风看上去有些诡异和卡通化，如果你正在寻找一个第一视角的射击游戏，我可以保证，游戏体验可一点也不逊色！
如果你在寻找一个好玩而且有很多 DLC 的 Linux 游戏，《无主之地 2》绝对是个不错的选择。
* [购买《无主之地 2》](http://store.steampowered.com/app/49520/?snr=1_5_9__205)
#### 4、 《<ruby> 叛乱 <rt> Insurgency </rt></ruby>》（多人）
《叛乱》是 Steam 上又一款支持 Linux 的优秀的 FPS 游戏。它剑走偏锋，从屏幕上去掉了 HUD 和弹药数量指示。如同许多评论者所说，这是款注重武器和团队战术的纯粹的射击游戏。这也许不是最好的 FPS 游戏，但如果你想玩和《三角洲部队》类似的多人游戏的话，这绝对是最好的游戏之一。
* [购买《叛乱》](http://store.steampowered.com/app/222880/?snr=1_5_9__205)
#### 5、 《<ruby> 生化奇兵：无限 <rt> Bioshock: Infinite </rt></ruby>》(单机)
《生化奇兵：无限》毫无疑问将会作为 PC 平台最好的单机 FPS 游戏之一而载入史册。你可以利用很多强大的能力来杀死你的敌人。同时你的敌人也各个身怀绝技。游戏的剧情也非常丰富。你不容错过！
* [购买《生化奇兵：无限》](http://store.steampowered.com/agecheck/app/8870/)
#### 6、 《<ruby> 杀手（年度版） <rt> HITMAN - Game of the Year Edition </rt></ruby>》（单机）
《杀手》系列无疑是 PC 游戏爱好者们的最爱之一。本系列的最新作开始按章节发布，让很多玩家觉得不满。但现在 Square Enix 撤出了开发，而最新的年度版带着新的内容重返舞台。在游戏中发挥你的想象力暗杀你的目标吧，杀手47！
* [购买（杀手（年度版））](http://store.steampowered.com/app/236870/?snr=1_5_9__205)
#### 7、 《<ruby> 传送门 2 <rt> Portal 2 </rt></ruby>》
《传送门 2》完美地结合了动作与冒险。这是款解谜类游戏，你可以与其他玩家协作，并开发有趣的谜题。协作模式提供了和单机模式截然不同的游戏内容。
* [购买《传送门2》](http://store.steampowered.com/app/620/?snr=1_5_9__205)
#### 8、 《<ruby> 杀出重围：人类分裂 <rt> Deux Ex: Mankind Divided </rt></ruby>》
如果你在寻找隐蔽类的射击游戏，《杀出重围》是个填充你的 Steam 游戏库的完美选择。这是个非常华丽的游戏，有着最先进的武器和超乎寻常的战斗机制。
* [购买《杀出重围：人类分裂》](http://store.steampowered.com/app/337000/?snr=1_5_9__205)
#### 9、 《<ruby> 地铁 2033 重置版 <rt> Metro 2033 Redux </rt></ruby>》 / 《<ruby> 地铁：最后曙光 重置版 <rt> Metro Last Light Redux </rt></ruby>》
《地铁 2033 重置版》和《地铁：最后曙光 重置版》是经典的《地铁 2033》和《地铁：最后曙光》的最终版本。故事发生在世界末日之后。你需要消灭所有的变种人来保证人类的生存。剩下的就交给你自己去探索了！
* [购买《地铁 2033 重置版》](http://store.steampowered.com/app/286690/?snr=1_5_9__205)
* [购买《地铁：最后曙光 重置版》](http://store.steampowered.com/app/287390/?snr=1_5_9__205)
#### 10、 《<ruby> 坦能堡 <rt> Tannenberg </rt></ruby>》（多人）
《坦能堡》是个全新的游戏 - 在本文发表一个月前刚刚发售。游戏背景是第一次世界大战的东线战场（1914-1918）。这款游戏只有多人模式。如果你想要在游戏中体验第一次世界大战，不要错过这款游戏！
* [购买《坦能堡》](http://store.steampowered.com/app/633460/?snr=1_5_9__205)
### Steam 上最佳 Linux 角色扮演类游戏
#### 11、 《<ruby> 中土世界：暗影魔多 <rt> Shadow of Mordor </rt></ruby>》
《中土世界：暗影魔多》 是 Steam 上支持 Linux 的最好的开放式角色扮演类游戏之一。你将扮演一个游侠（塔里昂），和光明领主（凯勒布理鹏）并肩作战击败索隆的军队（并最终和他直接交手）。战斗机制非常出色。这是款不得不玩的游戏！
* [购买《中土世界：暗影魔多》](http://store.steampowered.com/app/241930/?snr=1_5_9__205)
#### 12、 《<ruby> 神界：原罪加强版 <rt> Divinity: Original Sin – Enhanced Edition </rt></ruby>》
《神界：原罪》是一款极其优秀的角色扮演类独立游戏。它非常独特而又引人入胜。这或许是评分最高的带有冒险和策略元素的角色扮演游戏。加强版添加了新的游戏模式，并且完全重做了配音、手柄支持、协作任务等等。
* [购买《神界：原罪加强版》](http://store.steampowered.com/app/373420/?snr=1_5_9__205)
#### 13、 《<ruby> 废土 2：导演剪辑版 <rt> Wasteland 2: Director’s Cut </rt></ruby>》
《废土 2》是一款出色的 CRPG 游戏。如果《辐射 4》被移植成 CRPG 游戏，大概就是这种感觉。导演剪辑版完全重做了画面，并且增加了一百多名新人物。
* [购买《废土 2》](http://store.steampowered.com/app/240760/?snr=1_5_9__205)
#### 14、 《<ruby> 阴暗森林 <rt> Darkwood </rt></ruby>》
一个充满恐怖的俯视角角色扮演类游戏。你将探索世界、搜集材料、制作武器来生存下去。
* [购买《阴暗森林》](http://store.steampowered.com/app/274520/?snr=1_5_9__205)
### 最佳赛车 / 运动 / 模拟类游戏
#### 15、 《<ruby> 火箭联盟 <rt> Rocket League </rt></ruby>》
《火箭联盟》是一款充满刺激的足球游戏。游戏中你将驾驶用火箭助推的战斗赛车。你不仅是要驾车把球带进对方球门，你甚至还可以让你的对手化为灰烬！
这是款超棒的体育动作类游戏，每个游戏爱好者都值得拥有！
* [购买《火箭联盟》](http://store.steampowered.com/app/252950/?snr=1_5_9__205)
#### 16、 《<ruby> 公路救赎 <rt> Road Redemption </rt></ruby>》
想念《暴力摩托》了？作为它精神上的续作，《公路救赎》可以缓解你的饥渴。当然，这并不是真正的《暴力摩托 2》，但它一样有趣。如果你喜欢《暴力摩托》，你也会喜欢这款游戏。
* [购买《公路救赎》](http://store.steampowered.com/app/300380/?snr=1_5_9__205)
#### 17、 《<ruby> 尘埃拉力赛 <rt> Dirt Rally </rt></ruby>》
《尘埃拉力赛》是为想要体验公路和越野赛车的玩家准备的。画面非常有魄力，驾驶手感也近乎完美。
* [购买《尘埃拉力赛》](http://store.steampowered.com/app/310560/?snr=1_5_9__205)
#### 18、 《F1 2017》
《F1 2017》是另一款令人印象深刻的赛车游戏。由《尘埃拉力赛》的开发者 Codemasters & Feral Interactive 制作。游戏中包含了所有标志性的 F1 赛车，值得你去体验。
* [购买《F1 2017》](http://store.steampowered.com/app/515220/?snr=1_5_9__205)
#### 19、 《<ruby> 超级房车赛：汽车运动 <rt> GRID Autosport </rt></ruby>》
《超级房车赛》是最被低估的赛车游戏之一。《超级房车赛：汽车运动》是《超级房车赛》的续作。这款游戏的可玩性令人惊艳。游戏中的赛车也比前作更好。推荐所有的 PC 游戏玩家尝试这款赛车游戏。游戏还支持多人模式，你可以和你的朋友组队参赛。
* [购买《超级房车赛：汽车运动》](http://store.steampowered.com/app/255220/?snr=1_5_9__205)
### 最好的冒险游戏
#### 20、 《<ruby> 方舟：生存进化 <rt> ARK: Survival Evolved </rt></ruby>》
《方舟：生存进化》是一款不错的生存游戏，里面有着激动人心的冒险。你发现自己身处一个未知孤岛（方舟岛），为了生存下去并逃离这个孤岛，你必须去驯服恐龙、与其他玩家合作、猎杀其他人来抢夺资源、以及制作物品。
* [购买《方舟：生存进化》](http://store.steampowered.com/app/346110/?snr=1_5_9__205)
#### 21、 《<ruby> 这是我的战争 <rt> This War of Mine </rt></ruby>》
一款独特的战争游戏。你不是扮演士兵，而是要作为一个平民来面对战争带来的艰难。你需要在身经百战的敌人手下逃生，并帮助其他的幸存者。
* [购买《这是我的战争》](http://store.steampowered.com/app/282070/?snr=1_5_9__205)
#### 22、 《<ruby> 疯狂的麦克斯 <rt> Mad Max </rt></ruby>》
生存和暴力概括了《疯狂的麦克斯》的全部内容。游戏中有性能强大的汽车，开放性的世界，各种武器，以及徒手肉搏。你要不断地探索世界，并注意升级你的汽车来防患于未然。在做决定之前，你要仔细思考并设计好策略。
* [购买《疯狂的麦克斯》](http://store.steampowered.com/app/234140/?snr=1_5_9__205)
### 最佳独立游戏
#### 23、 《<ruby> 泰拉瑞亚 <rt> Terraria </rt></ruby>》
这是款在 Steam 上广受好评的 2D 游戏。你在旅途中需要去挖掘、战斗、探索、建造。游戏地图是自动生成的，而不是固定不变的。也许你刚刚遇到的东西，你的朋友过一会儿才会遇到。你还将体验到富有新意的 2D 动作场景。
* [购买《泰拉瑞亚》](http://store.steampowered.com/app/105600/?snr=1_5_9__205)
#### 24、 《<ruby> 王国与城堡 <rt> Kingdoms and Castles </rt></ruby>》
在《王国与城堡》中，你将建造你自己的王国。在管理你的王国的过程中，你需要收税、保护森林、规划城市，并且发展国防来防止别人入侵你的王国。
这是款比较新的游戏，但在独立游戏中已经相对获得了比较高的人气。
* [购买《王国与城堡》](http://store.steampowered.com/app/569480/?snr=1_5_9__205)
### Steam 上最佳 Linux 策略类游戏
#### 25、 《<ruby> 文明 5 <rt> Sid Meier’s Civilization V </rt></ruby>》
《文明 5》是 PC 上评价最高的策略游戏之一。如果你想的话，你可以去玩《文明 6》。但是依然有许多玩家喜欢《文明 5》，觉得它更有独创性，游戏细节也更富有创造力。
* [购买《文明 5》](http://store.steampowered.com/app/8930/?snr=1_5_9__205)
#### 26、 《<ruby> 全面战争：战锤 <rt> Total War: Warhammer </rt></ruby>》
《全面战争：战锤》是 PC 平台上一款非常出色的回合制策略游戏。可惜的是，新作《战锤 2》依然不支持 Linux。但如果你喜欢使用飞龙和魔法来建造与毁灭帝国的话，2016 年的《战锤》依然是个不错的选择。
* [购买《全面战争：战锤》](http://store.steampowered.com/app/364360/?snr=1_5_9__205)
#### 27、 《<ruby> 轰炸小队 <rt> Bomber Crew </rt></ruby>》
想要一款充满乐趣的策略游戏？《轰炸小队》就是为你准备的。你需要选择合适的队员并且让你的队伍稳定运转来取得最终的胜利。
* [购买《轰炸小队》](http://store.steampowered.com/app/537800/?snr=1_5_9__205)
#### 28、 《<ruby> 奇迹时代 3 <rt> Age of Wonders III </rt></ruby>》
非常流行的策略游戏，包含帝国建造、角色扮演、以及战争元素。这是款精致的回合制策略游戏，请一定要试试！
* [购买《奇迹时代 3》](http://store.steampowered.com/app/226840/?snr=1_5_9__205)
#### 29、 《<ruby> 城市：天际线 <rt> Cities: Skylines </rt></ruby>》
一款非常简洁的策略游戏。你要从零开始建造一座城市，并且管理它的全部运作。你将体验建造和管理城市带来的愉悦与困难。我不觉得每个玩家都会喜欢这款游戏——它的用户群体非常明确。
* [购买《城市：天际线》](http://store.steampowered.com/app/255710/?snr=1_5_9__205)
#### 30、 《<ruby> 幽浮 2 <rt> XCOM 2 </rt></ruby>》
《幽浮 2》是 PC 上最好的回合制策略游戏之一。我在想如果《幽浮 2》能够被制作成 FPS 游戏的话该有多棒。不过它现在已经是一款好评如潮的杰作了。如果你有多余的预算能花在这款游戏上，建议你购买“<ruby> 天选之战 <rt> War of the Chosen </rt></ruby>“ DLC。
* [购买《幽浮 2》](http://store.steampowered.com/app/268500/?snr=1_5_9__205)
### 总结
我们从所有支持 Linux 的游戏中挑选了大部分的主流大作以及一些评价很高的新作。
你觉得我们遗漏了你最喜欢的支持 Linux 的 Steam 游戏么？另外，你还希望哪些 Steam 游戏开始支持 Linux 平台？
请在下面的回复中告诉我们你的想法。
---
via: <https://itsfoss.com/best-linux-games-steam/>
作者：[Ankush Das](https://itsfoss.com/author/ankush/) 译者：[yixunx](https://github.com/yixunx) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 groff 编写 man 手册页
|
Matt Welsh
|
http://www.linuxjournal.com/article/1158
|
groff 是大多数 Unix 系统上所提供的流行的文本格式化工具 nroff/troff 的 GNU 版本。它一般用于编写手册页，即命令、编程接口等的在线文档。在本文中，我们将给你展示如何使用 groff 编写你自己的 man 手册页。
|
/data/attachment/album/201712/08/182910w66et8tekeq8wq6n.jpg.thumb.jpg
|
/data/attachment/album/201712/08/182910w66et8tekeq8wq6n.jpg
| true | false | true |
wxy
| false |
[
"man",
"groff"
] |
技术
|
{
"viewnum": 9139,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
groff 是大多数 Unix 系统上所提供的流行的文本格式化工具 nroff/troff 的 GNU 版本。它一般用于编写手册页，即命令、编程接口等的在线文档。在本文中，我们将给你展示如何使用 groff 编写你自己的 man 手册页。
| 2017-12-08T18:29:29 | 2017-12-08T18:29:29 | 9,122 |
/article-9122-1.html
|
`groff` 是大多数 Unix 系统上所提供的流行的文本格式化工具 nroff/troff 的 GNU 版本。它一般用于编写手册页，即命令、编程接口等的在线文档。在本文中，我们将给你展示如何使用 `groff` 编写你自己的 man 手册页。
在 Unix 系统上最初有两个文本处理系统：troff 和 nroff，它们是由贝尔实验室为初始的 Unix 所开发的（事实上，开发 Unix 系统的部分原因就是为了支持这样的一个文本处理系统）。这个文本处理器的第一个版本被称作 roff（意为 “runoff”——径流）；稍后出现了 troff，在那时用于为特定的<ruby> 排字机 <rt> Typesetter </rt></ruby>生成输出。nroff 是更晚一些的版本，它成为了各种 Unix 系统的标准文本处理器。groff 是 nroff 和 troff 的 GNU 实现，用在 Linux 系统上。它包括了几个扩展功能和一些打印设备的驱动程序。
`groff` 能够生成文档、文章和书籍，很多时候它就像是其它的文本格式化系统（如 TeX）的血管一样。然而，`groff`（以及原来的 nroff）有一个固有的功能是 TeX 及其变体所缺乏的：生成普通 ASCII 输出。其它的系统在生成打印的文档方面做得很好，而 `groff` 却能够生成可以在线浏览的普通 ASCII（甚至可以在最简单的打印机上直接以普通文本打印）。如果要生成在线浏览的文档以及打印的表单，`groff` 也许是你所需要的（虽然也有替代品，如 Texinfo、Lametex 等等）。
`groff` 还有一个好处是它比 TeX 小很多；它所需要的支持文件和可执行程序甚至比最小化的 TeX 版本都少。
`groff` 一个特定的用途是用于格式化 Unix 的 man 手册页。如果你是一个 Unix 程序员，你肯定需要编写和生成各种 man 手册页。在本文中，我们将通过编写一个简短的 man 手册页来介绍 `groff` 的使用。
像 TeX 一样，`groff` 使用特定的文本格式化语言来描述如何处理文本。这种语言比 TeX 之类的系统更加神秘一些，但是更加简洁。此外，`groff` 在基本的格式化器之上提供了几个宏软件包；这些宏软件包是为一些特定类型的文档所定制的。举个例子， mgs 宏对于写作文章或论文很适合，而 man 宏可用于 man 手册页。
### 编写 man 手册页
用 `groff` 编写 man 手册页十分简单。要让你的 man 手册页看起来和其它的一样，你需要从源头上遵循几个惯例，如下所示。在这个例子中，我们将为一个虚构的命令 `coffee` 编写 man 手册页，它用于以各种方式控制你的联网咖啡机。
使用任意文本编辑器，输入如下代码，并保存为 `coffee.man`。不要输入每行的行号，它们仅用于本文中的说明。
```
.TH COFFEE 1 "23 March 94"
.SH NAME
coffee \- Control remote coffee machine
.SH SYNOPSIS
\fBcoffee\fP [ -h | -b ] [ -t \fItype\fP ]
\fIamount\fP
.SH DESCRIPTION
\fBcoffee\fP queues a request to the remote
coffee machine at the device \fB/dev/cf0\fR.
The required \fIamount\fP argument specifies
the number of cups, generally between 0 and
12 on ISO standard coffee machines.
.SS Options
.TP
\fB-h\fP
Brew hot coffee. Cold is the default.
.TP
\fB-b\fP
Burn coffee. Especially useful when executing
\fBcoffee\fP on behalf of your boss.
.TP
\fB-t \fItype\fR
Specify the type of coffee to brew, where
\fItype\fP is one of \fBcolumbian\fP,
\fBregular\fP, or \fBdecaf\fP.
.SH FILES
.TP
\fC/dev/cf0\fR
The remote coffee machine device
.SH "SEE ALSO"
milk(5), sugar(5)
.SH BUGS
May require human intervention if coffee
supply is exhausted.
```
*清单 1：示例 man 手册页源文件*
不要让这些晦涩的代码吓坏了你。字符串序列 `\fB`、`\fI` 和 `\fR` 分别用来改变字体为粗体、斜体和正体（罗马字体）。`\fP` 设置字体为前一个选择的字体。
其它的 `groff` <ruby> 请求 <rt> request </rt></ruby>以点（`.`）开头出现在行首。第 1 行中，我们看到的 `.TH` 请求用于设置该 man 手册页的标题为 `COFFEE`、man 的部分为 `1`、以及该 man 手册页的最新版本的日期。（说明，man 手册的第 1 部分用于用户命令、第 2 部分用于系统调用等等。使用 `man man` 命令了解各个部分）。
在第 2 行，`.SH` 请求用于标记一个<ruby> 节 <rt> section </rt></ruby>的开始，并给该节名称为 `NAME`。注意，大部分的 Unix man 手册页依次使用 `NAME`、 `SYNOPSIS`、`DESCRIPTION`、`FILES`、`SEE ALSO`、`NOTES`、`AUTHOR` 和 `BUGS` 等节，个别情况下也需要一些额外的可选节。这只是编写 man 手册页的惯例，并不强制所有软件都如此。
第 3 行给出命令的名称，并在一个横线（`-`）后给出简短描述。在 `NAME` 节使用这个格式以便你的 man 手册页可以加到 whatis 数据库中——它可以用于 `man -k` 或 `apropos` 命令。
第 4-6 行我们给出了 `coffee` 命令格式的大纲。注意，斜体 `\fI...\fP` 用于表示命令行的参数，可选参数用方括号扩起来。
第 7-12 行给出了该命令的摘要介绍。粗体通常用于表示程序或文件的名称。
在 13 行，使用 `.SS` 开始了一个名为 `Options` 的子节。
接着第 14-25 行是选项列表，会使用参数列表样式表示。参数列表中的每一项以 `.TP` 请求来标记；`.TP` 后的行是参数，再之后是该项的文本。例如，第 14-16 行：
```
.TP
\fB-h\P
Brew hot coffee. Cold is the default.
```
将会显示如下：
```
-h Brew hot coffee. Cold is the default.
```
第 26-29 行创建该 man 手册页的 `FILES` 节，它用于描述该命令可能使用的文件。可以使用 `.TP` 请求来表示文件列表。
第 30-31 行，给出了 `SEE ALSO` 节，它提供了其它可以参考的 man 手册页。注意，第 30 行的 `.SH` 请求中 `"SEE ALSO"` 使用括号扩起来，这是因为 `.SH` 使用第一个空格来分隔该节的标题。任何超过一个单词的标题都需要使用引号扩起来成为一个单一参数。
最后，第 32-34 行，是 `BUGS` 节。
### 格式化和安装 man 手册页
为了在你的屏幕上查看这个手册页格式化的样式，你可以使用如下命令：
```
$ groff -Tascii -man coffee.man | more
```
`-Tascii` 选项告诉 `groff` 生成普通 ASCII 输出；`-man` 告诉 `groff` 使用 man 手册页宏集合。如果一切正常，这个 man 手册页显示应该如下。
```
COFFEE(1) COFFEE(1)
NAME
coffee - Control remote coffee machine
SYNOPSIS
coffee [ -h | -b ] [ -t type ] amount
DESCRIPTION
coffee queues a request to the remote coffee machine at
the device /dev/cf0\. The required amount argument speci-
fies the number of cups, generally between 0 and 12 on ISO
standard coffee machines.
Options
-h Brew hot coffee. Cold is the default.
-b Burn coffee. Especially useful when executing cof-
fee on behalf of your boss.
-t type
Specify the type of coffee to brew, where type is
one of columbian, regular, or decaf.
FILES
/dev/cf0
The remote coffee machine device
SEE ALSO
milk(5), sugar(5)
BUGS
May require human intervention if coffee supply is
exhausted.
```
*格式化的 man 手册页*
如之前提到过的，`groff` 能够生成其它类型的输出。使用 `-Tps` 选项替代 `-Tascii` 将会生成 PostScript 输出，你可以将其保存为文件，用 GhostView 查看，或用一个 PostScript 打印机打印出来。`-Tdvi` 会生成设备无关的 .dvi 输出，类似于 TeX 的输出。
如果你希望让别人在你的系统上也可以查看这个 man 手册页，你需要安装这个 groff 源文件到其它用户的 `%MANPATH` 目录里面。标准的 man 手册页放在 `/usr/man`。第一部分的 man 手册页应该放在 `/usr/man/man1` 下，因此，使用命令：
```
$ cp coffee.man /usr/man/man1/coffee.1
```
这将安装该 man 手册页到 `/usr/man` 中供所有人使用（注意使用 `.1` 扩展名而不是 `.man`）。当接下来执行 `man coffee` 命令时，该 man 手册页会被自动重新格式化，并且可查看的文本会被保存到 `/usr/man/cat1/coffee.1.Z` 中。
如果你不能直接复制 man 手册页的源文件到 `/usr/man`（比如说你不是系统管理员），你可创建你自己的 man 手册页目录树，并将其加入到你的 `%MANPATH`。`%MANPATH` 环境变量的格式同 `%PATH` 一样，举个例子，要添加目录 `/home/mdw/man` 到 `%MANPATH` ，只需要：
```
$ export MANPATH=/home/mdw/man:$MANPATH
```
`groff` 和 man 手册页宏还有许多其它的选项和格式化命令。找到它们的最好办法是查看 `/usr/lib/groff` 中的文件； `tmac` 目录包含了宏文件，自身通常会包含其所提供的命令的文档。要让 `groff` 使用特定的宏集合，只需要使用 `-m macro` （或 `-macro`） 选项。例如，要使用 mgs 宏，使用命令：
```
groff -Tascii -mgs files...
```
`groff` 的 man 手册页对这个选项描述了更多细节。
不幸的是，随同 `groff` 提供的宏集合没有完善的文档。第 7 部分的 man 手册页提供了一些，例如，`man 7 groff_mm` 会给你 mm 宏集合的信息。然而，该文档通常只覆盖了在 `groff` 实现中不同和新功能，而假设你已经了解过原来的 nroff/troff 宏集合（称作 DWB：the Documentor's Work Bench）。最佳的信息来源或许是一本覆盖了那些经典宏集合细节的书。要了解更多的编写 man 手册页的信息，你可以看看 man 手册页源文件（`/usr/man` 中），并通过它们来比较源文件的输出。
这篇文章是《Running Linux》 中的一章，由 Matt Welsh 和 Lar Kaufman 著，奥莱理出版（ISBN 1-56592-100-3）。在本书中，还包括了 Linux 下使用的各种文本格式化系统的教程。这期的《Linux Journal》中的内容及《Running Linux》应该可以给你提供在 Linux 上使用各种文本工具的良好开端。
### 祝好，撰写快乐！
Matt Welsh （[mdw@cs.cornell.edu](mailto:mdw@cs.cornell.edu)）是康奈尔大学的一名学生和系统程序员，在机器人和视觉实验室从事于时时机器视觉研究。
（题图：wikimedia.org）
---
via: <http://www.linuxjournal.com/article/1158>
作者：[Matt Welsh](http://www.linuxjournal.com/user/800006) 译者：[wxy](https://github.com/wxy) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Linux 启动或重启时执行命令与脚本
|
Shusain
|
http://linuxtechlab.com/executing-commands-scripts-at-reboot/
|
有时可能会需要在重启时或者每次系统启动时运行某些命令或者脚本。我们要怎样做呢？本文中我们就对此进行讨论。 我们会用两种方法来描述如何在 CentOS/RHEL 以及 Ubuntu 系统上做到重启或者系统启动时执行命令和脚本。 两种方法都通过了测试。
|
/data/attachment/album/201712/10/091506qvbncn11v37bs06c.jpg.thumb.jpg
|
/data/attachment/album/201712/10/091506qvbncn11v37bs06c.jpg
| true | false | true |
lujun9972
| false |
[
"启动"
] |
技术
|
{
"viewnum": 19288,
"commentnum": 3,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "113.44.113.48",
"message": "您好，按照您的方法完全不管用",
"username": "来自北京的 Chrome 72.0|Mac 10.14 用户",
"date": "2019-03-23T14:27:45"
},
{
"postip": "106.39.50.242",
"message": "那着呢么关闭这个自动重启呢",
"username": "来自北京的 Chrome 78.0|Windows 7 用户",
"date": "2020-06-18T11:11:22"
},
{
"postip": "183.165.130.247",
"message": "哈哈哈哈",
"username": "来自安徽六安的 Chrome 93.0|Windows 10 用户",
"date": "2021-09-21T23:14:55"
}
] |
[] |
有时可能会需要在重启时或者每次系统启动时运行某些命令或者脚本。我们要怎样做呢？本文中我们就对此进行讨论。 我们会用两种方法来描述如何在 CentOS/RHEL 以及 Ubuntu 系统上做到重启或者系统启动时执行命令和脚本。 两种方法都通过了测试。
| 2017-12-10T09:15:10 | 2017-12-10T09:15:10 | 9,123 |
/article-9123-1.html
|
有时可能会需要在重启时或者每次系统启动时运行某些命令或者脚本。我们要怎样做呢？本文中我们就对此进行讨论。 我们会用两种方法来描述如何在 CentOS/RHEL 以及 Ubuntu 系统上做到重启或者系统启动时执行命令和脚本。 两种方法都通过了测试。
### 方法 1 – 使用 rc.local
这种方法会利用 `/etc/` 中的 `rc.local` 文件来在启动时执行脚本与命令。我们在文件中加上一行来执行脚本，这样每次启动系统时，都会执行该脚本。
不过我们首先需要为 `/etc/rc.local` 添加执行权限，
```
$ sudo chmod +x /etc/rc.local
```
然后将要执行的脚本加入其中：
```
$ sudo vi /etc/rc.local
```
在文件最后加上：
```
sh /root/script.sh &
```
然后保存文件并退出。使用 `rc.local` 文件来执行命令也是一样的，但是一定要记得填写命令的完整路径。 想知道命令的完整路径可以运行：
```
$ which command
```
比如：
```
$ which shutter
/usr/bin/shutter
```
如果是 CentOS，我们修改的是文件 `/etc/rc.d/rc.local` 而不是 `/etc/rc.local`。 不过我们也需要先为该文件添加可执行权限。
注意:- 启动时执行的脚本，请一定保证是以 `exit 0` 结尾的。
### 方法 2 – 使用 Crontab
该方法最简单了。我们创建一个 cron 任务，这个任务在系统启动后等待 90 秒，然后执行命令和脚本。
要创建 cron 任务，打开终端并执行
```
$ crontab -e
```
然后输入下行内容，
```
@reboot ( sleep 90 ; sh \location\script.sh )
```
这里 `\location\script.sh` 就是待执行脚本的地址。
我们的文章至此就完了。如有疑问，欢迎留言。
---
via: <http://linuxtechlab.com/executing-commands-scripts-at-reboot/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 上如何禁用 USB 存储
|
Shusain
|
http://linuxtechlab.com/disable-usb-storage-linux/
|
在本教程中，我们将讨论三种不同的方法来禁用 Linux 机器上的 USB 存储设备。所有这三种方法都在 CentOS 6＆7 机器上通过测试。那么让我们一一讨论这三种方法，
|
/data/attachment/album/201712/10/092346thez6zth6lv6tt5z.jpg.thumb.jpg
|
/data/attachment/album/201712/10/092346thez6zth6lv6tt5z.jpg
| true | false | true |
lujun9972
| false |
[
"USB",
"安全"
] |
技术
|
{
"viewnum": 12874,
"commentnum": 1,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "116.236.28.244",
"message": "以上三种方法，都存在一个问题，设置重启后，如果有U盘插在电脑上，重启下电脑，设置就会失效",
"username": "来自上海的 Chrome 86.0|Windows 10 用户",
"date": "2020-11-17T18:59:48"
}
] |
[] |
在本教程中，我们将讨论三种不同的方法来禁用 Linux 机器上的 USB 存储设备。所有这三种方法都在 CentOS 6＆7 机器上通过测试。那么让我们一一讨论这三种方法，
| 2017-12-12T09:21:00 | 2017-12-12T09:21:00 | 9,124 |
/article-9124-1.html
|
为了保护数据不被泄漏，我们使用软件和硬件防火墙来限制外部未经授权的访问，但是数据泄露也可能发生在内部。 为了消除这种可能性，机构会限制和监测访问互联网，同时禁用 USB 存储设备。
在本教程中，我们将讨论三种不同的方法来禁用 Linux 机器上的 USB 存储设备。所有这三种方法都在 CentOS 6＆7 机器上通过测试。那么让我们一一讨论这三种方法。
（另请阅读: [Ultimate guide to securing SSH sessions](http://linuxtechlab.com/ultimate-guide-to-securing-ssh-sessions/)）
### 方法 1 – 伪安装
在本方法中，我们往配置文件中添加一行 `install usb-storage /bin/true`， 这会让安装 usb-storage 模块的操作实际上变成运行 `/bin/true`， 这也是为什么这种方法叫做`伪安装`的原因。 具体来说就是，在文件夹 `/etc/modprobe.d` 中创建并打开一个名为 `block_usb.conf` (也可能叫其他名字) ，
```
$ sudo vim /etc/modprobe.d/block_usb.conf
```
然后将下行内容添加进去：
```
install usb-storage /bin/true
```
最后保存文件并退出。
### 方法 2 – 删除 USB 驱动
这种方法要求我们将 USB 存储的驱动程序（`usb_storage.ko`）删掉或者移走，从而达到无法再访问 USB 存储设备的目的。 执行下面命令可以将驱动从它默认的位置移走：
```
$ sudo mv /lib/modules/$(uname -r)/kernel/drivers/usb/storage/usb-storage.ko /home/user1
```
现在在默认的位置上无法再找到驱动程序了，因此当 USB 存储器连接到系统上时也就无法加载到驱动程序了，从而导致磁盘不可用。 但是这个方法有一个小问题，那就是当系统内核更新的时候，`usb-storage` 模块会再次出现在它的默认位置。
### 方法 3 - 将 USB 存储器纳入黑名单
我们也可以通过 `/etc/modprobe.d/blacklist.conf` 文件将 usb-storage 纳入黑名单。这个文件在 RHEL/CentOS 6 是现成就有的，但在 7 上可能需要自己创建。 要将 USB 存储列入黑名单，请使用 vim 打开/创建上述文件：
```
$ sudo vim /etc/modprobe.d/blacklist.conf
```
并输入以下行将 USB 纳入黑名单：
```
blacklist usb-storage
```
保存文件并退出。`usb-storage` 就在就会被系统阻止加载，但这种方法有一个很大的缺点，即任何特权用户都可以通过执行以下命令来加载 `usb-storage` 模块，
```
$ sudo modprobe usb-storage
```
这个问题使得这个方法不是那么理想，但是对于非特权用户来说，这个方法效果很好。
在更改完成后重新启动系统，以使更改生效。请尝试用这些方法来禁用 USB 存储，如果您遇到任何问题或有什么疑问，请告知我们。
---
via: <http://linuxtechlab.com/disable-usb-storage-linux/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject)原创编译，[Linux 中国](https://linux.cn/)荣誉推出
|
||
如何在 Linux 上安装友好的交互式 shell：Fish
|
Sk
|
https://www.ostechnix.com/install-fish-friendly-interactive-shell-linux/
|
Fish 有着很多重要的功能，比如自动建议、语法高亮、可搜索的历史记录（像在 bash 中 CTRL+r）、智能搜索功能、极好的 VGA 颜色支持、基于 web 的设置方式、完善的手册页和许多开箱即用的功能。
|
/data/attachment/album/201712/10/095452wue3h33xvchfe3yj.jpg.thumb.jpg
|
/data/attachment/album/201712/10/095452wue3h33xvchfe3yj.jpg
| true | false | true |
kimii
| false |
[
"fish",
"shell"
] |
技术
|
{
"viewnum": 7902,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Fish 有着很多重要的功能，比如自动建议、语法高亮、可搜索的历史记录（像在 bash 中 CTRL+r）、智能搜索功能、极好的 VGA 颜色支持、基于 web 的设置方式、完善的手册页和许多开箱即用的功能。
| 2017-12-10T09:54:58 | 2017-12-10T09:54:58 | 9,125 |
/article-9125-1.html
|
Fish，<ruby> 友好的交互式 shell <rt> Friendly Interactive SHell </rt></ruby> 的缩写，它是一个适于装备于类 Unix 系统的智能而用户友好的 shell。Fish 有着很多重要的功能，比如自动建议、语法高亮、可搜索的历史记录（像在 bash 中 `CTRL+r`）、智能搜索功能、极好的 VGA 颜色支持、基于 web 的设置方式、完善的手册页和许多开箱即用的功能。尽管安装并立即使用它吧。无需更多其他配置，你也不需要安装任何额外的附加组件/插件!
在这篇教程中，我们讨论如何在 Linux 中安装和使用 fish shell。
#### 安装 Fish
尽管 fish 是一个非常用户友好的并且功能丰富的 shell，但并没有包括在大多数 Linux 发行版的默认仓库中。它只能在少数 Linux 发行版中的官方仓库中找到，如 Arch Linux，Gentoo，NixOS，和 Ubuntu 等。然而，安装 fish 并不难。
在 Arch Linux 和它的衍生版上，运行以下命令来安装它。
```
sudo pacman -S fish
```
在 CentOS 7 上以 root 运行以下命令：
```
cd /etc/yum.repos.d/
wget https://download.opensuse.org/repositories/shells:fish:release:2/CentOS_7/shells:fish:release:2.repo
yum install fish
```
在 CentOS 6 上以 root 运行以下命令：
```
cd /etc/yum.repos.d/
wget https://download.opensuse.org/repositories/shells:fish:release:2/CentOS_6/shells:fish:release:2.repo
yum install fish
```
在 Debian 9 上以 root 运行以下命令：
```
wget -nv https://download.opensuse.org/repositories/shells:fish:release:2/Debian_9.0/Release.key -O Release.key
apt-key add - < Release.key
echo 'deb http://download.opensuse.org/repositories/shells:/fish:/release:/2/Debian_9.0/ /' > /etc/apt/sources.list.d/fish.list
apt-get update
apt-get install fish
```
在 Debian 8 上以 root 运行以下命令：
```
wget -nv https://download.opensuse.org/repositories/shells:fish:release:2/Debian_8.0/Release.key -O Release.key
apt-key add - < Release.key
echo 'deb http://download.opensuse.org/repositories/shells:/fish:/release:/2/Debian_8.0/ /' > /etc/apt/sources.list.d/fish.list
apt-get update
apt-get install fish
```
在 Fedora 26 上以 root 运行以下命令：
```
dnf config-manager --add-repo https://download.opensuse.org/repositories/shells:fish:release:2/Fedora_26/shells:fish:release:2.repo
dnf install fish
```
在 Fedora 25 上以 root 运行以下命令：
```
dnf config-manager --add-repo https://download.opensuse.org/repositories/shells:fish:release:2/Fedora_25/shells:fish:release:2.repo
dnf install fish
```
在 Fedora 24 上以 root 运行以下命令：
```
dnf config-manager --add-repo https://download.opensuse.org/repositories/shells:fish:release:2/Fedora_24/shells:fish:release:2.repo
dnf install fish
```
在 Fedora 23 上以 root 运行以下命令：
```
dnf config-manager --add-repo https://download.opensuse.org/repositories/shells:fish:release:2/Fedora_23/shells:fish:release:2.repo
dnf install fish
```
在 openSUSE 上以 root 运行以下命令：
```
zypper install fish
```
在 RHEL 7 上以 root 运行以下命令：
```
cd /etc/yum.repos.d/
wget https://download.opensuse.org/repositories/shells:fish:release:2/RHEL_7/shells:fish:release:2.repo
yum install fish
```
在 RHEL-6 上以 root 运行以下命令：
```
cd /etc/yum.repos.d/
wget https://download.opensuse.org/repositories/shells:fish:release:2/RedHat_RHEL-6/shells:fish:release:2.repo
yum install fish
```
在 Ubuntu 和它的衍生版上：
```
sudo apt-get update
sudo apt-get install fish
```
就这样了。是时候探索 fish shell 了。
### 用法
要从你默认的 shell 切换到 fish,请执行以下操作：
```
$ fish
Welcome to fish, the friendly interactive shell
```
你可以在 `~/.config/fish/config.fish` 上找到默认的 fish 配置（类似于 `.bashrc`）。如果它不存在，就创建它吧。
#### 自动建议
当我输入一个命令，它以浅灰色自动建议一个命令。所以，我需要输入一个 Linux 命令的前几个字母，然后按下 `tab` 键来完成这个命令。
[](http://www.ostechnix.com/wp-content/uploads/2017/12/fish-1.png)
如果有更多的可能性，它将会列出它们。你可以使用上/下箭头键从列表中选择列出的命令。在选择你想运行的命令后，只需按下右箭头键，然后按下 `ENTER` 运行它。
[](http://www.ostechnix.com/wp-content/uploads/2017/12/fish-2.png)
无需 `CTRL+r` 了！正如你已知道的，我们通过按 `CTRL+r` 来反向搜索 Bash shell 中的历史命令。但在 fish shell 中是没有必要的。由于它有自动建议功能，只需输入命令的前几个字母，然后从历史记录中选择已经执行的命令。很酷，是吧。
#### 智能搜索
我们也可以使用智能搜索来查找一个特定的命令、文件或者目录。例如，我输入一个命令的一部分，然后按向下箭头键进行智能搜索，再次输入一个字母来从列表中选择所需的命令。
[](http://www.ostechnix.com/wp-content/uploads/2017/12/fish-6.png)
#### 语法高亮
当你输入一个命令时，你将注意到语法高亮。请看下面当我在 Bash shell 和 fish shell 中输入相同的命令时截图的区别。
Bash：
[](http://www.ostechnix.com/wp-content/uploads/2017/12/fish-3.png)
Fish：
[](http://www.ostechnix.com/wp-content/uploads/2017/12/fish-4.png)
正如你所看到的，`sudo` 在 fish shell 中已经被高亮显示。此外，默认情况下它将以红色显示无效命令。
#### 基于 web 的配置方式
这是 fish shell 另一个很酷的功能。我们可以设置我们的颜色、更改 fish 提示符，并从网页上查看所有功能、变量、历史记录、键绑定。
启动 web 配置接口，只需输入：
```
fish_config
```
[](http://www.ostechnix.com/wp-content/uploads/2017/12/fish-5.png)
#### 手册页补完
Bash 和 其它 shells 支持可编程的补完，但只有 fish 可以通过解析已安装的手册来自动生成它们。
为此，请运行：
```
fish_update_completions
```
实例输出将是：
```
Parsing man pages and writing completions to /home/sk/.local/share/fish/generated_completions/
3435 / 3435 : zramctl.8.gz
```
#### 禁用问候语
默认情况下，fish 在启动时问候你（“Welcome to fish, the friendly interactive shell”）。如果你不想要这个问候消息，可以禁用它。为此，编辑 fish 配置文件：
```
vi ~/.config/fish/config.fish
```
添加以下行：
```
set -g -x fish_greeting ''
```
你也可以设置任意自定义的问候语，而不是禁用 fish 问候。
```
set -g -x fish_greeting 'Welcome to OSTechNix'
```
#### 获得帮助
这是另一个吸引我的令人印象深刻的功能。要在终端的默认 web 浏览器中打开 fish 文档页面，只需输入：
```
help
```
官方文档将会在你的默认浏览器中打开。另外，你可以使用手册页来显示任何命令的帮助部分。
```
man fish
```
#### 设置 fish 为默认 shell
非常喜欢它？太好了！设置它作为默认 shell 吧。为此，请使用命令 `chsh`：
```
chsh -s /usr/bin/fish
```
在这里，`/usr/bin/fish` 是 fish shell 的路径。如果你不知道正确的路径，以下命令将会帮助你：
```
which fish
```
注销并且重新登录以使用新的默认 shell。
请记住，为 Bash 编写的许多 shell 脚本可能不完全兼容 fish。
要切换回 Bash，只需运行：
```
bash
```
如果你想 Bash 作为你的永久默认 shell，运行：
```
chsh -s /bin/bash
```
各位，这就是全部了。在这个阶段，你可能会得到一个有关 fish shell 使用的基本概念。 如果你正在寻找一个Bash的替代品，fish 可能是一个不错的选择。
Cheers!
资源:
* [fish shell 官网](https://fishshell.com/)
---
via: <https://www.ostechnix.com/install-fish-friendly-interactive-shell-linux/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[kimii](https://github.com/kimii) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
2017 年末 Linux 中国线下小聚会
|
老王
|
我们决定在 2017 年末举办一场各地线下沙龙聚会。聚会由 Linux 中国核心成员负责组织，分别在北京、上海、广州和成都同步举行。聚会形式采用 AA 方式，地点拟选择咖啡馆或奶茶店。聚会的主要活动内容包括：技术分享、开源文化谈、职场交流等等。
|
/data/attachment/album/201712/10/225035dxxg31hgcotbsx31.jpg.thumb.jpg
|
/data/attachment/album/201712/10/225035dxxg31hgcotbsx31.jpg
| true | false | false | false |
[
"Linux中国",
"聚会"
] |
新闻
|
{
"viewnum": 6480,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "60.209.105.170",
"message": "赞！",
"username": "绿色圣光 [Firefox 57.0|GNU/Linux]",
"date": "2017-12-12T10:46:45"
}
] |
[
{
"raid": 9167,
"displayorder": 0
}
] |
我们决定在 2017 年末举办一场各地线下沙龙聚会。聚会由 Linux 中国核心成员负责组织，分别在北京、上海、广州和成都同步举行。聚会形式采用 AA 方式，地点拟选择咖啡馆或奶茶店。聚会的主要活动内容包括：技术分享、开源文化谈、职场交流等等。
| 2017-12-10T22:52:00 | 2017-12-10T22:52:00 | 9,126 |
/article-9126-1.html
|
又是一年行将结束，老王这段时间到广州、上海和北京都走了走，见了不少小伙伴。平时主要在网上聊天的小伙伴们，这一见面还真是倍觉亲切。
经过和大家的讨论，我们决定在 2017 年末举办一场各地线下沙龙聚会。聚会由 Linux 中国核心成员负责组织，分别在**北京**、**上海**、**广州**和**成都**同步举行。聚会形式采用 AA 方式，个人承担自己的费用。地点拟选择咖啡馆之类，由各地组织者负责确定地点。
由于我们将此次聚会定位为微型沙龙聚会，所以各地聚会规模限制为 20 人以下。因此，如果您的报名已经超过该地区的限制，可能就不会收到短信通知了。
聚会的主要活动内容包括：技术分享、开源文化谈、职场交流等等。我们各个地方的组织者，均是在技术领域和开源领域具有多年积淀的高手，聚会上会和大家分享一些心得和认识。
主要的话题可能会谈到：Linux 运维、容器与 DevOps、网络安全、Python 开发、开源文化等方面。
此外，我们多个地点是同步举行的，因此也会利用视频手段，将多个地点互相连接起来。
最后，Linux 中国官方和人民邮电出版社会提供部分奖品和支持。
---
聚会时间： 2017 年 12 月 23 日下午 14:00
聚会地点：
* 北京：西城区时光咖啡（地铁4号线西四站北300米路东）
* 上海：黄浦区宁波路276号
* 广州：W.coffee（太古汇对面，地铁3号线石牌 B 口）
* 成都：人民公园鹤鸣茶社
聚会报名：（已截止）
（本页信息将不断更新。）
|
||||
如何在 Bash 中抽取子字符串
|
Vivek Gite
|
https://www.cyberciti.biz/faq/how-to-extract-substring-in-bash/
|
所谓“子字符串”就是出现在其它字符串内的字符串。 比如 “3382” 就是 “this is a 3382 test” 的子字符串。 我们有多种方法可以从中把数字或指定部分字符串抽取出来。
|
/data/attachment/album/201712/11/004423sx2nuierggkusmgz.jpg.thumb.jpg
|
/data/attachment/album/201712/11/004423sx2nuierggkusmgz.jpg
| true | false | true |
lujun9972
| false |
[
"Bash",
"字符串"
] |
技术
|
{
"viewnum": 4685,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
所谓“子字符串”就是出现在其它字符串内的字符串。 比如 “3382” 就是 “this is a 3382 test” 的子字符串。 我们有多种方法可以从中把数字或指定部分字符串抽取出来。
| 2017-12-11T00:44:00 | 2017-12-11T00:44:00 | 9,127 |
/article-9127-1.html
|
所谓“子字符串”就是出现在其它字符串内的字符串。 比如 “3382” 就是 “this is a 3382 test” 的子字符串。 我们有多种方法可以从中把数字或指定部分字符串抽取出来。
[](https://www.cyberciti.biz/media/new/faq/2017/12/How-to-Extract-substring-in-Bash-Shell-on-Linux-or-Unix.jpg)
本文会向你展示在 bash shell 中如何获取或者说查找出子字符串。
### 在 Bash 中抽取子字符串
其语法为：
```
## 格式 ##
${parameter:offset:length}
```
子字符串扩展是 bash 的一项功能。它会扩展成 `parameter` 值中以 `offset` 为开始，长为 `length` 个字符的字符串。 假设， `$u` 定义如下:
```
## 定义变量 u ##
u="this is a test"
```
那么下面参数的子字符串扩展会抽取出子字符串:
```
var="${u:10:4}"
echo "${var}"
```
结果为:
```
test
```
其中这些参数分别表示：
* 10 : 偏移位置
* 4 : 长度
### 使用 IFS
根据 bash 的 man 页说明:
>
> [IFS （内部字段分隔符）](https://bash.cyberciti.biz/guide/$IFS)用于在扩展后进行单词分割，并用内建的 read 命令将行分割为词。默认值是。
>
>
>
另一种 <ruby> POSIX 就绪 <rt> POSIX ready </rt></ruby>的方案如下：
```
u="this is a test"
set -- $u
echo "$1"
echo "$2"
echo "$3"
echo "$4"
```
输出为：
```
this
is
a
test
```
下面是一段 bash 代码，用来从 Cloudflare cache 中去除带主页的 url。
```
#！/bin/bash
####################################################
## Author - Vivek Gite {https://www.cyberciti.biz/}
## Purpose - Purge CF cache
## License - Under GPL ver 3.x+
####################################################
## set me first ##
zone_id="YOUR_ZONE_ID_HERE"
api_key="YOUR_API_KEY_HERE"
email_id="YOUR_EMAIL_ID_HERE"
## hold data ##
home_url=""
amp_url=""
urls="$@"
## Show usage
[ "$urls" == "" ] && { echo "Usage: $0 url1 url2 url3"; exit 1; }
## Get home page url as we have various sub dirs on domain
## /tips/
## /faq/
get_home_url(){
local u="$1"
IFS='/'
set -- $u
echo "${1}${IFS}${IFS}${3}${IFS}${4}${IFS}"
}
echo
echo "Purging cache from Cloudflare。.。"
echo
for u in $urls
do
home_url="$(get_home_url $u)"
amp_url="${u}amp/"
curl -X DELETE "https://api.cloudflare.com/client/v4/zones/${zone_id}/purge_cache" \
-H "X-Auth-Email: ${email_id}" \
-H "X-Auth-Key: ${api_key}" \
-H "Content-Type: application/json" \
--data "{\"files\":[\"${u}\"，\"${amp_url}\"，\"${home_url}\"]}"
echo
done
echo
```
它的使用方法为：
```
~/bin/cf.clear.cache https://www.cyberciti.biz/faq/bash-for-loop/ https://www.cyberciti.biz/tips/linux-security.html
```
### 借助 cut 命令
可以使用 `cut` 命令来将文件中每一行或者变量中的一部分删掉。它的语法为：
```
u="this is a test"
echo "$u" | cut -d' ' -f 4
echo "$u" | cut --delimiter=' ' --fields=4
##########################################
## WHERE
## -d' ' : Use a whitespace as delimiter
## -f 4 : Select only 4th field
##########################################
var="$(cut -d' ' -f 4 <<< $u)"
echo "${var}"
```
想了解更多请阅读 bash 的 man 页：
```
man bash
man cut
```
另请参见： [Bash String Comparison: Find Out IF a Variable Contains a Substring](https://www.cyberciti.biz/faq/bash-find-out-if-variable-contains-substring/)
---
via: <https://www.cyberciti.biz/faq/how-to-extract-substring-in-bash/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
通过示例学习使用 netstat
|
Shusain
|
http://linuxtechlab.com/learn-use-netstat-with-examples/
|
netstat 是一个告诉我们系统中所有 tcp/udp/unix socket 连接状态的命令行工具。它会列出所有已经连接或者等待连接状态的连接。 该工具在识别某个应用监听哪个端口时特别有用，我们也能用它来判断某个应用是否正常的在监听某个端口。
|
/data/attachment/album/201712/11/010039me11a4y4doyedw2e.jpg.thumb.jpg
|
/data/attachment/album/201712/11/010039me11a4y4doyedw2e.jpg
| true | false | true |
lujun9972
| false |
[
"netstat",
"网络"
] |
技术
|
{
"viewnum": 5874,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
netstat 是一个告诉我们系统中所有 tcp/udp/unix socket 连接状态的命令行工具。它会列出所有已经连接或者等待连接状态的连接。 该工具在识别某个应用监听哪个端口时特别有用，我们也能用它来判断某个应用是否正常的在监听某个端口。
| 2017-12-11T01:00:52 | 2017-12-11T01:00:52 | 9,128 |
/article-9128-1.html
|
netstat 是一个告诉我们系统中所有 tcp/udp/unix socket 连接状态的命令行工具。它会列出所有已经连接或者等待连接状态的连接。 该工具在识别某个应用监听哪个端口时特别有用，我们也能用它来判断某个应用是否正常的在监听某个端口。
netstat 命令还能显示其它各种各样的网络相关信息，例如路由表， 网卡统计信息， 虚假连接以及多播成员等。
本文中，我们会通过几个例子来学习 netstat。
(推荐阅读: [通过示例学习使用 CURL 命令](http://linuxtechlab.com/learn-use-curl-command-examples/) )
### 1 - 检查所有的连接
使用 `a` 选项可以列出系统中的所有连接，
```
$ netstat -a
```
这会显示系统所有的 tcp、udp 以及 unix 连接。
### 2 - 检查所有的 tcp/udp/unix socket 连接
使用 `t` 选项只列出 tcp 连接，
```
$ netstat -at
```
类似的，使用 `u` 选项只列出 udp 连接，
```
$ netstat -au
```
使用 `x` 选项只列出 Unix socket 连接，
```
$ netstat -ax
```
### 3 - 同时列出进程 ID/进程名称
使用 `p` 选项可以在列出连接的同时也显示 PID 或者进程名称，而且它还能与其他选项连用，
```
$ netstat -ap
```
### 4 - 列出端口号而不是服务名
使用 `n` 选项可以加快输出，它不会执行任何反向查询（LCTT 译注：这里原文有误），而是直接输出数字。 由于无需查询，因此结果输出会快很多。
```
$ netstat -an
```
### 5 - 只输出监听端口
使用 `l` 选项只输出监听端口。它不能与 `a` 选项连用，因为 `a` 会输出所有端口，
```
$ netstat -l
```
### 6 - 输出网络状态
使用 `s` 选项输出每个协议的统计信息，包括接收/发送的包数量，
```
$ netstat -s
```
### 7 - 输出网卡状态
使用 `I` 选项只显示网卡的统计信息，
```
$ netstat -i
```
### 8 - 显示<ruby> 多播组 <rt> multicast group </rt></ruby>信息
使用 `g` 选项输出 IPV4 以及 IPV6 的多播组信息，
```
$ netstat -g
```
### 9 - 显示网络路由信息
使用 `r` 输出网络路由信息，
```
$ netstat -r
```
### 10 - 持续输出
使用 `c` 选项持续输出结果
```
$ netstat -c
```
### 11 - 过滤出某个端口
与 `grep` 连用来过滤出某个端口的连接，
```
$ netstat -anp | grep 3306
```
### 12 - 统计连接个数
通过与 `wc` 和 `grep` 命令连用，可以统计指定端口的连接数量
```
$ netstat -anp | grep 3306 | wc -l
```
这会输出 mysql 服务端口（即 3306）的连接数。
这就是我们简短的案例指南了，希望它带给你的信息量足够。 有任何疑问欢迎提出。
---
via: <http://linuxtechlab.com/learn-use-netstat-with-examples/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
AWS 帮助构建 ONNX 开源 AI 平台
|
David Jones
|
https://www.linuxinsider.com/story/AWS-to-Help-Build-ONNX-Open-Source-AI-Platform-84971.html
|
AWS 最近成为了加入深度学习社区的开放神经网络交换Open Neural Network Exchange（ONNX）协作的技术公司，最近在无障碍和可互操作frictionless and interoperable的环境中推出了高级人工智能。由 Facebook 和微软领头了该协作。
|
/data/attachment/album/201712/11/084155qzqsqbgsv6wzurwe.jpg.thumb.jpg
|
/data/attachment/album/201712/11/084155qzqsqbgsv6wzurwe.jpg
| true | false | true |
geekpi
| false |
[
"AI",
"ONNX",
"深度学习",
"AWS"
] |
新闻
|
{
"viewnum": 4402,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "219.228.146.28",
"message": "现在AWS中国区新用户注册即可免费使用12个月云服务产品啦？",
"username": "来自上海华东师范大学的 Safari 14.1|Mac 10.15 用户",
"date": "2021-09-27T21:38:49"
}
] |
[] |
AWS 最近成为了加入深度学习社区的开放神经网络交换Open Neural Network Exchange（ONNX）协作的技术公司，最近在无障碍和可互操作frictionless and interoperable的环境中推出了高级人工智能。由 Facebook 和微软领头了该协作。
| 2017-12-11T08:41:52 | 2017-12-11T08:41:52 | 9,129 |
/article-9129-1.html
|
AWS 最近成为了加入深度学习社区的<ruby> 开放神经网络交换 <rt> Open Neural Network Exchange </rt></ruby>（ONNX）协作的技术公司，最近在<ruby> 无障碍和可互操作 <rt> frictionless and interoperable </rt></ruby>的环境中推出了高级人工智能。由 Facebook 和微软领头了该协作。
作为该合作的一部分，AWS 开源其深度学习框架 Python 软件包 ONNX-MXNet，该框架提供了跨多种语言的编程接口（API），包括 Python、Scala 和开源统计软件 R。
AWS 深度学习工程经理 Hagay Lupesko 和软件开发人员 Roshani Nagmote 上周在一篇帖子中写道，ONNX 格式将帮助开发人员构建和训练其它框架的模型，包括 PyTorch、Microsoft Cognitive Toolkit 或 Caffe2。它可以让开发人员将这些模型导入 MXNet，并运行它们进行推理。
### 对开发者的帮助
今年夏天，Facebook 和微软推出了 ONNX，以支持共享模式的互操作性，来促进 AI 的发展。微软提交了其 Cognitive Toolkit、Caffe2 和 PyTorch 来支持 ONNX。
微软表示：Cognitive Toolkit 和其他框架使开发人员更容易构建和运行计算图以表达神经网络。
[ONNX 代码和文档](https://github.com/onnx/onnx)的初始版本已经放到了 Github。
AWS 和微软上个月宣布了在 Apache MXNet 上的一个新 Gluon 接口计划，该计划允许开发人员构建和训练深度学习模型。
[Tractica](https://www.tractica.com/) 的研究总监 Aditya Kaul 观察到：“Gluon 是他们试图与 Google 的 Tensorflow 竞争的合作伙伴关系的延伸”。
他告诉 LinuxInsider，“谷歌在这点上的疏忽是非常明显的，但也说明了他们在市场上的主导地位。”
Kaul 说：“甚至 Tensorflow 也是开源的，所以开源在这里并不是什么大事，但这归结到底是其他生态系统联手与谷歌竞争。”
根据 AWS 的说法，本月早些时候，Apache MXNet 社区推出了 MXNet 的 0.12 版本，它扩展了 Gluon 的功能，以便进行新的尖端研究。它的新功能之一是变分 dropout，它允许开发人员使用 dropout 技术来缓解递归神经网络中的过拟合。
AWS 指出：卷积 RNN、LSTM 网络和门控循环单元（GRU）允许使用基于时间的序列和空间维度对数据集进行建模。
### 框架中立方式
[Tirias Research](http://www.tiriasresearch.com/) 的首席分析师 Paul Teich 说：“这看起来像是一个提供推理的好方法，而不管是什么框架生成的模型。”
他告诉 LinuxInsider：“这基本上是一种框架中立的推理方式。”
Teich 指出，像 AWS、微软等云提供商在客户的压力下可以在一个网络上进行训练，同时提供另一个网络，以推进人工智能。
他说：“我认为这是这些供应商检查互操作性的一种基本方式。”
Tractica 的 Kaul 指出：“框架互操作性是一件好事，这会帮助开发人员确保他们建立在 MXNet 或 Caffe 或 CNTK 上的模型可以互操作。”
至于这种互操作性如何适用于现实世界，Teich 指出，诸如自然语言翻译或语音识别等技术将要求将 Alexa 的语音识别技术打包并交付给另一个开发人员的嵌入式环境。
### 感谢开源
[ThinkStrategies](http://www.thinkstrategies.com/) 的总经理 Jeff Kaplan 表示：“尽管存在竞争差异，但这些公司都认识到他们在开源运动所带来的软件开发进步方面所取得的巨大成功。”
他告诉 LinuxInsider：“开放式神经网络交换（ONNX）致力于在人工智能方面产生类似的优势和创新。”
越来越多的大型科技公司已经宣布使用开源技术来加快 AI 协作开发的计划，以便创建更加统一的开发和研究平台。
AT＆T 几周前宣布了与 TechMahindra 和 Linux 基金会合作[推出 Acumos 项目](https://www.linuxinsider.com/story/84926.html)的计划。该平台旨在开拓电信、媒体和技术方面的合作。
---
via: <https://www.linuxinsider.com/story/AWS-to-Help-Build-ONNX-Open-Source-AI-Platform-84971.html>
作者：[David Jones](https://www.linuxinsider.com/story/AWS-to-Help-Build-ONNX-Open-Source-AI-Platform-84971.html#searchbyline) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何归档 GitHub 仓库
|
Mikemcquaid
|
https://github.com/blog/2460-archiving-repositories
|
如果仓库不再活跃开发或者你不想接受额外的贡献，但这并不意味着你想要删除它。现在可以在 Github 上归档仓库让它变成只读。
|
/data/attachment/album/201712/11/173539hzvc3nhf23i8y5qc.jpg.thumb.jpg
|
/data/attachment/album/201712/11/173539hzvc3nhf23i8y5qc.jpg
| true | false | true |
geekpi
| false |
[
"GitHub"
] |
技术
|
{
"viewnum": 8161,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果仓库不再活跃开发或者你不想接受额外的贡献，但这并不意味着你想要删除它。现在可以在 Github 上归档仓库让它变成只读。
| 2017-12-11T17:36:55 | 2017-12-11T17:36:55 | 9,130 |
/article-9130-1.html
|
如果仓库不再活跃开发或者你不想接受额外的贡献，但这并不意味着你想要删除它。现在可以在 Github 上归档仓库让它变成只读。
归档一个仓库会让它对所有人只读（包括仓库拥有者）。这包括对仓库的编辑、<ruby> 问题 <rt> issue </rt></ruby>、<ruby> 合并请求 <rt> pull request </rt></ruby>（PR）、标记、里程碑、项目、维基、发布、提交、标签、分支、反馈和评论。谁都不可以在一个归档的仓库上创建新的问题、合并请求或者评论，但是你仍可以 fork 仓库——以允许归档的仓库在其它地方继续开发。
要归档一个仓库，进入仓库设置页面并点在这个仓库上点击“<ruby> 归档该仓库 <rt> Archive this repository </rt></ruby>”。
在归档你的仓库前，确保你已经更改了它的设置并考虑关闭所有的开放问题和合并请求。你还应该更新你的 README 和描述来让它让访问者了解他不再能够对之贡献。
如果你改变了主意想要解除归档你的仓库，在相同的地方点击“<ruby> 解除归档该仓库 <rt> Unarchive this repository </rt></ruby>”。请注意归档仓库的大多数设置是隐藏的，你需要解除归档才能改变它们。
要了解更多，请查看[这份文档](https://help.github.com/articles/about-archiving-repositories/)中的归档仓库部分。归档快乐！
---
via: <https://github.com/blog/2460-archiving-repositories>
作者：[MikeMcQuaid](https://github.com/MikeMcQuaid) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在执行一个命令或程序之前就了解它会做什么
|
Sk
|
https://www.ostechnix.com/know-command-program-will-exactly-executing/
|
maybe ，一个简单的工具，它允许你运行一条命令并可以查看此命令对你的文件做了什么，而实际上这条命令却并未执行！在查看 maybe 的输出列表后，你可以决定是否真的想要运行这条命令。
|
/data/attachment/album/201712/11/181157veejemmd4qw8ed8m.png.thumb.jpg
|
/data/attachment/album/201712/11/181157veejemmd4qw8ed8m.png
| true | false | true |
imquanquan
| false |
[
"maybe",
"文件操作"
] |
技术
|
{
"viewnum": 3901,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
maybe ，一个简单的工具，它允许你运行一条命令并可以查看此命令对你的文件做了什么，而实际上这条命令却并未执行！在查看 maybe 的输出列表后，你可以决定是否真的想要运行这条命令。
| 2017-12-12T11:09:00 | 2017-12-12T11:09:00 | 9,131 |
/article-9131-1.html
|
有没有想过在执行一个 Unix 命令前就知道它干些什么呢？并不是每个人都会知道一个特定的命令或者程序将会做什么。当然，你可以用 [Explainshell](https://www.ostechnix.com/explainshell-find-part-linux-command/) 来查看它。你可以在 Explainshell 网站中粘贴你的命令，然后它可以让你了解命令的每个部分做了什么。但是，这是没有必要的。现在，我们从终端就可以轻易地在执行一个命令或者程序前就知道它会做什么。 `maybe` ，一个简单的工具，它允许你运行一条命令并可以查看此命令对你的文件做了什么，而实际上这条命令却并未执行！在查看 `maybe` 的输出列表后，你可以决定是否真的想要运行这条命令。
### `maybe` 是如何工作的
根据开发者的介绍：
>
> `maybe` 利用 `python-ptrace` 库在 `ptrace` 控制下运行了一个进程。当它截取到一个即将更改文件系统的系统调用时，它会记录该调用，然后修改 CPU 寄存器，将这个调用重定向到一个无效的系统调用 ID（效果上将其变成一个无效操作（no-op）），并将这个无效操作（no-op）的返回值设置为有效操作的返回值。结果，这个进程认为，它所做的一切都发生了，实际上什么都没有改变。
>
>
>
警告：在生产环境或者任何你所关心的系统里面使用这个工具时都应该小心。它仍然可能造成严重的损失，因为它只能阻止少数系统调用。
#### 安装 `maybe`
确保你已经在你的 Linux 系统中已经安装了 `pip` 。如果没有，可以根据您使用的发行版，按照如下指示进行安装。
在 Arch Linux 及其衍生产品（如 Antergos、Manjaro Linux）上，使用以下命令安装 `pip` ：
```
sudo pacman -S python-pip
```
在 RHEL，CentOS 上：
```
sudo yum install epel-release
sudo yum install python-pip
```
在 Fedora 上：
```
sudo dnf install epel-release
sudo dnf install python-pip
```
在 Debian，Ubuntu，Linux Mint 上：
```
sudo apt-get install python-pip
```
在 SUSE、 openSUSE 上：
```
sudo zypper install python-pip
```
安装 `pip` 后，运行以下命令安装 `maybe` ：
```
sudo pip install maybe
```
### 了解一个命令或程序在执行前会做什么
用法是非常简单的！只要在要执行的命令前加上 `maybe` 即可。
让我给你看一个例子：
```
$ maybe rm -r ostechnix/
```
如你所看到的，我从我的系统中删除一个名为 `ostechnix` 的文件夹。下面是示例输出：
```
maybe has prevented rm -r ostechnix/ from performing 5 file system operations:
delete /home/sk/inboxer-0.4.0-x86_64.AppImage
delete /home/sk/Docker.pdf
delete /home/sk/Idhayathai Oru Nodi.mp3
delete /home/sk/dThmLbB334_1398236878432.jpg
delete /home/sk/ostechnix
Do you want to rerun rm -r ostechnix/ and permit these operations? [y/N] y
```
[](http://www.ostechnix.com/wp-content/uploads/2017/12/maybe-1.png)
`maybe` 执行了 5 个文件系统操作，并向我显示该命令（`rm -r ostechnix/`）究竟会做什么。现在我可以决定是否应该执行这个操作。是不是很酷呢？确实很酷！
这是另一个例子。我要为 Gmail 安装 Inboxer 桌面客户端。这是我得到的输出：
```
$ maybe ./inboxer-0.4.0-x86_64.AppImage
fuse: bad mount point `/tmp/.mount_inboxemDzuGV': No such file or directory
squashfuse 0.1.100 (c) 2012 Dave Vasilevsky
Usage: /home/sk/Downloads/inboxer-0.4.0-x86_64.AppImage [options] ARCHIVE MOUNTPOINT
FUSE options:
-d -o debug enable debug output (implies -f)
-f foreground operation
-s disable multi-threaded operation
open dir error: No such file or directory
maybe has prevented ./inboxer-0.4.0-x86_64.AppImage from performing 1 file system operations:
create directory /tmp/.mount_inboxemDzuGV
Do you want to rerun ./inboxer-0.4.0-x86_64.AppImage and permit these operations? [y/N]
```
如果它没有检测到任何文件系统操作，那么它会只显示如下所示的结果。
例如，我运行下面这条命令来更新我的 Arch Linux。
```
$ maybe sudo pacman -Syu
sudo: effective uid is not 0, is /usr/bin/sudo on a file system with the 'nosuid' option set or an NFS file system without root privileges?
maybe has not detected any file system operations from sudo pacman -Syu.
```
看到没？它没有检测到任何文件系统操作，所以没有任何警告。这非常棒，而且正是我所预料到的结果。从现在开始，我甚至可以在执行之前知道一个命令或一个程序将执行什么操作。我希望这对你也会有帮助。
Cheers!
资源：
* [`maybe` GitHub 主页](https://github.com/p-e-w/maybe)
---
via: <https://www.ostechnix.com/know-command-program-will-exactly-executing/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[imquanquan](https://github.com/imquanquan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在 Ubuntu 16.04 下随机化你的 WiFi MAC 地址
|
Paul M Furley
|
https://www.paulfurley.com/randomize-your-wifi-mac-address-on-ubuntu-1604-xenial/
|
你的设备的 MAC 地址可以在不同的 WiFi 网络中记录你的活动。这些信息能被共享后出售，用于识别特定的个体。但可以用随机生成的伪 MAC 地址来阻止这一行为。
|
/data/attachment/album/201712/11/190224a08seleao084es0b.jpg.thumb.jpg
|
/data/attachment/album/201712/11/190224a08seleao084es0b.jpg
| true | false | true |
wenwensnow
| false |
[
"WiFi",
"MAC"
] |
技术
|
{
"viewnum": 7450,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
你的设备的 MAC 地址可以在不同的 WiFi 网络中记录你的活动。这些信息能被共享后出售，用于识别特定的个体。但可以用随机生成的伪 MAC 地址来阻止这一行为。
| 2017-12-11T18:59:00 | 2017-12-11T18:59:00 | 9,132 |
/article-9132-1.html
|
>
> 你的设备的 MAC 地址可以在不同的 WiFi 网络中记录你的活动。这些信息能被共享后出售，用于识别特定的个体。但可以用随机生成的伪 MAC 地址来阻止这一行为。
>
>
>
每一个诸如 WiFi 或者以太网卡这样的网络设备，都有一个叫做 MAC 地址的唯一标识符，如：`b4:b6:76:31:8c:ff`。这就是你能上网的原因：每当你连上 WiFi，路由器就会用这一地址来向你接受和发送数据，并且用它来区别你和这一网络的其它设备。
这一设计的缺陷在于唯一性，不变的 MAC 地址正好可以用来追踪你。连上了星巴克的 WiFi? 好，注意到了。在伦敦的地铁上? 也记录下来。
如果你曾经在某一个 WiFi 验证页面上输入过你的真实姓名，你就已经把自己和这一 MAC 地址建立了联系。没有仔细阅读许可服务条款、你可以认为，机场的免费 WiFi 正通过出售所谓的 ‘顾客分析数据’（你的个人信息）获利。出售的对象包括酒店，餐饮业，和任何想要了解你的人。
我不想信息被记录，再出售给多家公司，所以我花了几个小时想出了一个解决方案。
### MAC 地址不一定总是不变的
幸运的是，在不断开网络的情况下，是可以随机生成一个伪 MAC 地址的。
我想随机生成我的 MAC 地址，但是有三个要求：
1. MAC 地址在不同网络中是不相同的。这意味着，我在星巴克和在伦敦地铁网络中的 MAC 地址是不相同的，这样在不同的服务提供商中就无法将我的活动系起来。
2. MAC 地址需要经常更换，这样在网络上就没人知道我就是去年在这儿经过了 75 次的那个人。
3. MAC 地址一天之内应该保持不变。当 MAC 地址更改时，大多数网络都会与你断开连接，然后必须得进入验证页面再次登陆 - 这很烦人。
### 操作<ruby> 网络管理器 <rt> NetworkManager </rt></ruby>
我第一次尝试用一个叫做 `macchanger` 的工具，但是失败了。因为<ruby> 网络管理器 <rt> NetworkManager </rt></ruby>会根据它自己的设置恢复默认的 MAC 地址。
我了解到，网络管理器 1.4.1 以上版本可以自动生成随机的 MAC 地址。如果你在使用 Ubuntu 17.04 版本，你可以根据[这一配置文件](https://gist.github.com/paulfurley/978d4e2e0cceb41d67d017a668106c53/)实现这一目的。但这并不能完全符合我的三个要求（你必须在<ruby> 随机 <rt> random </rt></ruby>和<ruby> 稳定 <rt> stable </rt></ruby>这两个选项之中选择一个，但没有一天之内保持不变这一选项）
因为我使用的是 Ubuntu 16.04，网络管理器版本为 1.2，不能直接使用高版本这一新功能。可能网络管理器有一些随机化方法支持，但我没能成功。所以我编了一个脚本来实现这一目标。
幸运的是，网络管理器 1.2 允许模拟 MAC 地址。你在已连接的网络中可以看见 ‘编辑连接’ 这一选项。
网络管理器也支持钩子处理 —— 任何位于 `/etc/NetworkManager/dispatcher.d/pre-up.d/` 的脚本在建立网络连接之前都会被执行。
### 分配随机生成的伪 MAC 地址
我想根据网络 ID 和日期来生成新的随机 MAC 地址。 我们可以使用网络管理器的命令行工具 nmcli 来显示所有可用网络：
```
> nmcli connection
NAME UUID TYPE DEVICE
Gladstone Guest 618545ca-d81a-11e7-a2a4-271245e11a45 802-11-wireless wlp1s0
DoESDinky 6e47c080-d81a-11e7-9921-87bc56777256 802-11-wireless --
PublicWiFi 79282c10-d81a-11e7-87cb-6341829c2a54 802-11-wireless --
virgintrainswifi 7d0c57de-d81a-11e7-9bae-5be89b161d22 802-11-wireless --
```
因为每个网络都有一个唯一标识符（UUID），为了实现我的计划，我将 UUID 和日期拼接在一起，然后使用 MD5 生成 hash 值：
```
# eg 618545ca-d81a-11e7-a2a4-271245e11a45-2017-12-03
> echo -n "${UUID}-$(date +%F)" | md5sum
53594de990e92f9b914a723208f22b3f -
```
生成的结果可以代替 MAC 地址的最后八个字节。
值得注意的是，最开始的字节 `02` 代表这个地址是[自行指定](https://en.wikipedia.org/wiki/MAC_address#Universal_vs._local)的。实际上，真实 MAC 地址的前三个字节是由制造商决定的，例如 `b4:b6:76` 就代表 Intel。
有可能某些路由器会拒绝自己指定的 MAC 地址，但是我还没有遇到过这种情况。
每次连接到一个网络，这一脚本都会用 `nmcli` 来指定一个随机生成的伪 MAC 地址。
最后，我查看了 `ifconfig` 的输出结果，我发现 MAC 地址 `HWaddr` 已经变成了随机生成的地址（模拟 Intel 的），而不是我真实的 MAC 地址。
```
> ifconfig
wlp1s0 Link encap:Ethernet HWaddr b4:b6:76:45:64:4d
inet addr:192.168.0.86 Bcast:192.168.0.255 Mask:255.255.255.0
inet6 addr: fe80::648c:aff2:9a9d:764/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:12107812 errors:0 dropped:2 overruns:0 frame:0
TX packets:18332141 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:11627977017 (11.6 GB) TX bytes:20700627733 (20.7 GB)
```
### 脚本
完整的脚本也可以[在 Github 上查看](https://gist.github.com/paulfurley/46e0547ce5c5ea7eabeaef50dbacef3f)。
```
#!/bin/sh
# /etc/NetworkManager/dispatcher.d/pre-up.d/randomize-mac-addresses
# Configure every saved WiFi connection in NetworkManager with a spoofed MAC
# address, seeded from the UUID of the connection and the date eg:
# 'c31bbcc4-d6ad-11e7-9a5a-e7e1491a7e20-2017-11-20'
# This makes your MAC impossible(?) to track across WiFi providers, and
# for one provider to track across days.
# For craptive portals that authenticate based on MAC, you might want to
# automate logging in :)
# Note that NetworkManager >= 1.4.1 (Ubuntu 17.04+) can do something similar
# automatically.
export PATH=$PATH:/usr/bin:/bin
LOG_FILE=/var/log/randomize-mac-addresses
echo "$(date): $*" > ${LOG_FILE}
WIFI_UUIDS=$(nmcli --fields type,uuid connection show |grep 802-11-wireless |cut '-d ' -f3)
for UUID in ${WIFI_UUIDS}
do
UUID_DAILY_HASH=$(echo "${UUID}-$(date +F)" | md5sum)
RANDOM_MAC="02:$(echo -n ${UUID_DAILY_HASH} | sed 's/^\(..\)\(..\)\(..\)\(..\)\(..\).*$/\1:\2:\3:\4:\5/')"
CMD="nmcli connection modify ${UUID} wifi.cloned-mac-address ${RANDOM_MAC}"
echo "$CMD" >> ${LOG_FILE}
$CMD &
done
wait
```
*更新：[使用自己指定的 MAC 地址](https://gist.github.com/paulfurley/46e0547ce5c5ea7eabeaef50dbacef3f/revisions#diff-824d510864d58c07df01102a8f53faef)可以避免和真正的 intel 地址冲突。感谢 [@\_fink](https://twitter.com/fink_/status/937305600005943296)*
---
via: <https://www.paulfurley.com/randomize-your-wifi-mac-address-on-ubuntu-1604-xenial/>
作者：[Paul M Furley](https://www.paulfurley.com/) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Docker：使用多阶段构建镜像
|
Docker
|
https://docs.docker.com/engine/userguide/eng-image/multistage-build/
|
多阶段构建是 Docker 17.05 及更高版本提供的新功能。这对致力于优化 Dockerfile 的人来说，使得 Dockerfile 易于阅读和维护。
|
/data/attachment/album/201712/11/223241y0thlaabla8ahh7z.jpg.thumb.jpg
|
/data/attachment/album/201712/11/223241y0thlaabla8ahh7z.jpg
| true | false | true |
iron0x
| false |
[
"Docker",
"容器"
] |
容器与云
|
{
"viewnum": 5976,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
多阶段构建是 Docker 17.05 及更高版本提供的新功能。这对致力于优化 Dockerfile 的人来说，使得 Dockerfile 易于阅读和维护。
| 2017-12-11T22:32:57 | 2017-12-11T22:32:57 | 9,133 |
/article-9133-1.html
|
多阶段构建是 Docker 17.05 及更高版本提供的新功能。这对致力于优化 Dockerfile 的人来说，使得 Dockerfile 易于阅读和维护。
>
> 致谢: 特别感谢 [Alex Ellis](https://twitter.com/alexellisuk) 授权使用他的关于 Docker 多阶段构建的博客文章 [Builder pattern vs. Multi-stage builds in Docker](http://blog.alexellis.io/mutli-stage-docker-builds/) 作为以下示例的基础。
>
>
>
### 在多阶段构建之前
关于构建镜像最具挑战性的事情之一是保持镜像体积小巧。 Dockerfile 中的每条指令都会在镜像中增加一层，并且在移动到下一层之前，需要记住清除不需要的构件。要编写一个非常高效的 Dockerfile，你通常需要使用 shell 技巧和其它方式来尽可能地减少层数，并确保每一层都具有上一层所需的构件，而其它任何东西都不需要。
实际上最常见的是，有一个 Dockerfile 用于开发（其中包含构建应用程序所需的所有内容），而另一个裁剪过的用于生产环境，它只包含您的应用程序以及运行它所需的内容。这被称为“构建器模式”。但是维护两个 Dockerfile 并不理想。
下面分别是一个 `Dockerfile.build` 和遵循上面的构建器模式的 `Dockerfile` 的例子：
`Dockerfile.build`：
```
FROM golang:1.7.3
WORKDIR /go/src/github.com/alexellis/href-counter/
RUN go get -d -v golang.org/x/net/html
COPY app.go .
RUN go get -d -v golang.org/x/net/html \
&& CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .
```
注意这个例子还使用 Bash 的 `&&` 运算符人为地将两个 `RUN` 命令压缩在一起，以避免在镜像中创建额外的层。这很容易失败，难以维护。例如，插入另一个命令时，很容易忘记继续使用 `\` 字符。
`Dockerfile`：
```
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY app .
CMD ["./app"]
```
`build.sh`：
```
#!/bin/sh
echo Building alexellis2/href-counter:build
docker build --build-arg https_proxy=$https_proxy --build-arg http_proxy=$http_proxy \
-t alexellis2/href-counter:build . -f Dockerfile.build
docker create --name extract alexellis2/href-counter:build
docker cp extract:/go/src/github.com/alexellis/href-counter/app ./app
docker rm -f extract
echo Building alexellis2/href-counter:latest
docker build --no-cache -t alexellis2/href-counter:latest .
rm ./app
```
当您运行 `build.sh` 脚本时，它会构建第一个镜像，从中创建一个容器，以便将该构件复制出来，然后构建第二个镜像。 这两个镜像会占用您的系统的空间，而你仍然会一个 `app` 构件存放在你的本地磁盘上。
多阶段构建大大简化了这种情况！
### 使用多阶段构建
在多阶段构建中，您需要在 Dockerfile 中多次使用 `FROM` 声明。每次 `FROM` 指令可以使用不同的基础镜像，并且每次 `FROM` 指令都会开始新阶段的构建。您可以选择将构件从一个阶段复制到另一个阶段，在最终镜像中，不会留下您不需要的所有内容。为了演示这是如何工作的，让我们调整前一节中的 Dockerfile 以使用多阶段构建。
`Dockerfile`：
```
FROM golang:1.7.3
WORKDIR /go/src/github.com/alexellis/href-counter/
RUN go get -d -v golang.org/x/net/html
COPY app.go .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=0 /go/src/github.com/alexellis/href-counter/app .
CMD ["./app"]
```
您只需要单一个 Dockerfile。 不需要另外的构建脚本。只需运行 `docker build` 即可。
```
$ docker build -t alexellis2/href-counter:latest .
```
最终的结果是和以前体积一样小的生产镜像，复杂性显著降低。您不需要创建任何中间镜像，也不需要将任何构件提取到本地系统。
它是如何工作的呢？第二条 `FROM` 指令以 `alpine:latest` 镜像作为基础开始新的建造阶段。`COPY --from=0` 这一行将刚才前一个阶段产生的构件复制到这个新阶段。Go SDK 和任何中间构件都被留在那里，而不会保存到最终的镜像中。
### 命名您的构建阶段
默认情况下，这些阶段没有命名，您可以通过它们的整数来引用它们，从第一个 `FROM` 指令的 0 开始。但是，你可以通过在 `FROM` 指令中使用 `as <NAME>` 来为阶段命名。以下示例通过命名阶段并在 `COPY` 指令中使用名称来改进前一个示例。这意味着，即使您的 `Dockerfile` 中的指令稍后重新排序，`COPY` 也不会出问题。
```
FROM golang:1.7.3 as builder
WORKDIR /go/src/github.com/alexellis/href-counter/
RUN go get -d -v golang.org/x/net/html
COPY app.go .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /go/src/github.com/alexellis/href-counter/app .
CMD ["./app"]
```
---
via: <https://docs.docker.com/engine/userguide/eng-image/multistage-build/>
作者：[docker](https://docs.docker.com/engine/userguide/eng-image/multistage-build/) 译者：[iron0x](https://github.com/iron0x) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Eclipse 如何助力 IoT 发展
|
Gordon Haff
|
https://opensource.com/article/17/10/eclipse-and-iot
|
开源组织的模块化开发方式非常适合物联网。
|
/data/attachment/album/201712/11/233019xkql6hj2hsyhadll.png.thumb.jpg
|
/data/attachment/album/201712/11/233019xkql6hj2hsyhadll.png
| true | false | true |
smartgrids
| false |
[
"IoT",
"Eclipse"
] |
观点
|
{
"viewnum": 5343,
"commentnum": 1,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "60.209.105.170",
"message": "新项目正准备用 Eclipse Paho 呢。",
"username": "绿色圣光 [Firefox 57.0|GNU/Linux]",
"date": "2017-12-12T10:44:33"
}
] |
[] |
开源组织的模块化开发方式非常适合物联网。
| 2017-12-11T23:30:10 | 2017-12-11T23:30:10 | 9,134 |
/article-9134-1.html
|
>
> 开源组织的模块化开发方式非常适合物联网。
>
>
>
图片来源： opensource.com
[Eclipse](https://www.eclipse.org/home/) 可能不是第一个去研究物联网的开源组织。但是，远在 IoT 家喻户晓之前，该基金会在 2001 年左右就开始支持开源软件发展商业化。
九月份的 Eclipse 物联网日和 RedMonk 的 [ThingMonk 2017](http://thingmonk.com/) 一块举行，着重强调了 Eclipse 在 [物联网发展](https://iot.eclipse.org/) 中的重要作用。它现在已经包含了 28 个项目，覆盖了大部分物联网项目需求。会议过程中，我和负责 Eclipse 市场化运作的 [Ian Skerritt](https://twitter.com/ianskerrett) 讨论了 Eclipse 的物联网项目以及如何拓展它。
### 物联网的最新进展？
我问 Ian 物联网同传统工业自动化，也就是前几十年通过传感器和相应工具来实现工厂互联的方式有什么不同。 Ian 指出很多工厂是还没有互联的。
另外，他说 “SCADA [<ruby> 监控和数据分析 <rt> supervisory control and data analysis </rt></ruby>] 系统以及工厂底层技术都是非常私有的、独立性的。我们很难去改变它，也很难去适配它们 …… 现在，如果你想运行一套生产系统，你需要设计成百上千的单元。生产线想要的是满足用户需求，使制造过程更灵活，从而可以不断产出。” 这也就是物联网会带给制造业的一个很大的帮助。
### Eclipse 物联网方面的研究
Ian 对于 Eclipse 在物联网的研究是这样描述的：“满足任何物联网解决方案的核心基础技术” ，通过使用开源技术，“每个人都可以使用，从而可以获得更好的适配性。” 他说，Eclipse 将物联网视为包括三层互联的软件栈。从更高的层面上看，这些软件栈（按照大家常见的说法）将物联网描述为跨越三个层面的网络。特定的实现方式可能含有更多的层，但是它们一般都可以映射到这个三层模型的功能上：
* 一种可以装载设备（例如设备、终端、微控制器、传感器）用软件的堆栈。
* 将不同的传感器采集到的数据信息聚合起来并传输到网上的一类网关。这一层也可能会针对传感器数据检测做出实时反应。
* 物联网平台后端的一个软件栈。这个后端云存储数据并能根据采集的数据比如历史趋势、预测分析提供服务。
这三个软件栈在 Eclipse 的白皮书 “[The Three Software Stacks Required for IoT Architectures](https://iot.eclipse.org/resources/white-papers/Eclipse%20IoT%20White%20Paper%20-%20The%20Three%20Software%20Stacks%20Required%20for%20IoT%20Architectures.pdf) ”中有更详细的描述。
Ian 说在这些架构中开发一种解决方案时，“需要开发一些特殊的东西，但是很多底层的技术是可以借用的，像通信协议、网关服务。需要一种模块化的方式来满足不同的需求场合。” Eclipse 关于物联网方面的研究可以概括为：开发模块化开源组件，从而可以被用于开发大量的特定性商业服务和解决方案。
### Eclipse 的物联网项目
在众多已被应用的 Eclipse 物联网应用中， Ian 举了两个和 [MQTT](http://mqtt.org/) 有关联的突出应用，一个设备与设备互联（M2M）的物联网协议。 Ian 把它描述成“一个专为重视电源管理工作的油气传输线监控系统的信息发布/订阅协议。MQTT 已经是众多物联网广泛应用标准中很成功的一个。” [Eclipse Mosquitto](https://projects.eclipse.org/projects/technology.mosquitto) 是 MQTT 的代理，[Eclipse Paho](https://projects.eclipse.org/projects/technology.paho) 是他的客户端。
[Eclipse Kura](https://www.eclipse.org/kura/) 是一个物联网网关，引用 Ian 的话，“它连接了很多不同的协议间的联系”，包括蓝牙、Modbus、CANbus 和 OPC 统一架构协议，以及一直在不断添加的各种协议。他说，一个优势就是，取代了你自己写你自己的协议， Kura 提供了这个功能并将你通过卫星、网络或其他设备连接到网络。”另外它也提供了防火墙配置、网络延时以及其它功能。Ian 也指出“如果网络不通时，它会存储信息直到网络恢复。”
最新的一个项目中，[Eclipse Kapua](https://www.eclipse.org/kapua/) 正尝试通过微服务来为物联网云平台提供不同的服务。比如，它集成了通信、汇聚、管理、存储和分析功能。Ian 说“它正在不断前进，虽然还没被完全开发出来，但是 Eurotech 和 RedHat 在这个项目上非常积极。”
Ian 说 [Eclipse hawkBit](https://eclipse.org/hawkbit/) ，一个软件更新管理的软件，是一项“非常有趣的项目。从安全的角度说，如果你不能更新你的设备，你将会面临巨大的安全漏洞。”很多物联网安全事故都和无法更新的设备有关，他说，“HawkBit 可以基本负责通过物联网系统来完成扩展性更新的后端管理。”
物联网设备软件升级的难度一直被看作是难度最高的安全挑战之一。物联网设备不是一直连接的，而且数目众多，再加上首先设备的更新程序很难完全正常。正因为这个原因，关于 IoT 软件升级的项目一直是被当作重要内容往前推进。
### 为什么物联网这么适合 Eclipse
在物联网发展趋势中的一个方面就是关于构建模块来解决商业问题，而不是跨越行业和公司的大物联网平台。 Eclipse 关于物联网的研究放在一系列模块栈、提供特定和大众化需求功能的项目上，还有就是指定目标所需的可捆绑式中间件、网关和协议组件上。
---
作者简介：
Gordon Haff - Gordon Haff 是红帽公司的云专家，经常在消费者和行业会议上讲话，并且帮助发展红帽全面云化解决方案。他是《计算机前沿：云如何如何打开众多出版社未来之门》的作者。在红帽之前， Gordon 写了成百上千的研究报告，经常被引用到公众刊物上，像纽约时报关于 IT 的议题和产品建议等……
---
via： <https://opensource.com/article/17/10/eclipse-and-iot>
作者：[Gordon Haff](https://opensource.com/users/ghaff) 译者：[smartgrids](https://github.com/smartgrids) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
在红帽企业版 Linux 中将系统服务容器化（一）
|
Matt Micene
|
http://rhelblog.redhat.com/2017/07/19/containing-system-services-in-red-hat-enterprise-linux-part-1/
|
在 2017 年红帽峰会上，有几个人问我“我们通常用完整的虚拟机来隔离如 DNS 和 DHCP 等网络服务，那我们可以用容器来取而代之吗？”答案是可以的，下面是在当前红帽企业版 Linux 7 系统上创建一个系统容器的例子。
|
/data/attachment/album/201712/12/120057wnsg7irlnhr3nhxc.jpg.thumb.jpg
|
/data/attachment/album/201712/12/120057wnsg7irlnhr3nhxc.jpg
| true | false | true |
liuxinyu123
| false |
[
"容器",
"服务",
"bind"
] |
容器与云
|
{
"viewnum": 4395,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 2017 年红帽峰会上，有几个人问我“我们通常用完整的虚拟机来隔离如 DNS 和 DHCP 等网络服务，那我们可以用容器来取而代之吗？”答案是可以的，下面是在当前红帽企业版 Linux 7 系统上创建一个系统容器的例子。
| 2017-12-12T12:01:10 | 2017-12-12T12:01:10 | 9,135 |
/article-9135-1.html
|
在 2017 年红帽峰会上，有几个人问我“我们通常用完整的虚拟机来隔离如 DNS 和 DHCP 等网络服务，那我们可以用容器来取而代之吗？”答案是可以的，下面是在当前红帽企业版 Linux 7 系统上创建一个系统容器的例子。
### 我们的目的
**创建一个可以独立于任何其它系统服务而更新的网络服务，并且可以从主机端容易地管理和更新。**
让我们来探究一下在容器中建立一个运行在 systemd 之下的 BIND 服务器。在这一部分，我们将了解到如何建立自己的容器以及管理 BIND 配置和数据文件。
在本系列的第二部分，我们将看到如何整合主机中的 systemd 和容器中的 systemd。我们将探究如何管理容器中的服务，并且使它作为一种主机中的服务。
### 创建 BIND 容器
为了使 systemd 在一个容器中轻松运行，我们首先需要在主机中增加两个包：`oci-register-machine` 和 `oci-systemd-hook`。`oci-systemd-hook` 这个钩子允许我们在一个容器中运行 systemd，而不需要使用特权容器或者手工配置 tmpfs 和 cgroups。`oci-register-machine` 这个钩子允许我们使用 systemd 工具如 `systemctl` 和 `machinectl` 来跟踪容器。
```
[root@rhel7-host ~]# yum install oci-register-machine oci-systemd-hook
```
回到创建我们的 BIND 容器上。[红帽企业版 Linux 7 基础镜像](https://access.redhat.com/containers)包含了 systemd 作为其初始化系统。我们可以如我们在典型的系统中做的那样安装并激活 BIND。你可以从 [git 仓库中下载这份 Dockerfile](https://github.com/nzwulfin/named-container)。
```
[root@rhel7-host bind]# vi Dockerfile
# Dockerfile for BIND
FROM registry.access.redhat.com/rhel7/rhel
ENV container docker
RUN yum -y install bind && \
yum clean all && \
systemctl enable named
STOPSIGNAL SIGRTMIN+3
EXPOSE 53
EXPOSE 53/udp
CMD [ "/sbin/init" ]
```
因为我们以 PID 1 来启动一个初始化系统，当我们告诉容器停止时，需要改变 docker CLI 发送的信号。从 `kill` 系统调用手册中 （`man 2 kill`）：
>
> 唯一可以发送给 PID 1 进程（即 init 进程）的信号，是那些初始化系统明确安装了<ruby> 信号处理器 <rt> signal handler </rt></ruby>的信号。这是为了避免系统被意外破坏。
>
>
>
对于 systemd 信号处理器，`SIGRTMIN+3` 是对应于 `systemd start halt.target` 的信号。我们也需要为 BIND 暴露 TCP 和 UDP 端口号，因为这两种协议可能都要使用。
### 管理数据
有了一个可以工作的 BIND 服务，我们还需要一种管理配置文件和区域文件的方法。目前这些都放在容器里面，所以我们任何时候都可以进入容器去更新配置或者改变一个区域文件。从管理的角度来说，这并不是很理想。当要更新 BIND 时，我们将需要重建这个容器，所以镜像中的改变将会丢失。任何时候我们需要更新一个文件或者重启服务时，都需要进入这个容器，而这增加了步骤和时间。
相反的，我们将从这个容器中提取出配置文件和数据文件，把它们拷贝到主机上，然后在运行的时候挂载它们。用这种方式我们可以很容易地重启或者重建容器，而不会丢失所做出的更改。我们也可以使用容器外的编辑器来更改配置和区域文件。因为这个容器的数据看起来像“该系统所提供服务的特定站点数据”，让我们遵循 Linux <ruby> 文件系统层次标准 <rt> File System Hierarchy </rt></ruby>，并在当前主机上创建 `/srv/named` 目录来保持管理权分离。
```
[root@rhel7-host ~]# mkdir -p /srv/named/etc
[root@rhel7-host ~]# mkdir -p /srv/named/var/named
```
*提示：如果你正在迁移一个已有的配置文件，你可以跳过下面的步骤并且将它直接拷贝到 `/srv/named` 目录下。你也许仍然要用一个临时容器来检查一下分配给这个容器的 GID。*
让我们建立并运行一个临时容器来检查 BIND。在将 init 进程以 PID 1 运行时，我们不能交互地运行这个容器来获取一个 shell。我们会在容器启动后执行 shell，并且使用 `rpm` 命令来检查重要文件。
```
[root@rhel7-host ~]# docker build -t named .
[root@rhel7-host ~]# docker exec -it $( docker run -d named ) /bin/bash
[root@0e77ce00405e /]# rpm -ql bind
```
对于这个例子来说，我们将需要 `/etc/named.conf` 和 `/var/named/` 目录下的任何文件。我们可以使用 `machinectl` 命令来提取它们。如果注册了一个以上的容器，我们可以在任一机器上使用 `machinectl status` 命令来查看运行的是什么。一旦有了这些配置，我们就可以终止这个临时容器了。
*如果你喜欢，资源库中也有一个[样例 `named.conf` 和针对 `example.com` 的区域文件](https://github.com/nzwulfin/named-container)。*
```
[root@rhel7-host bind]# machinectl list
MACHINE CLASS SERVICE
8824c90294d5a36d396c8ab35167937f container docker
[root@rhel7-host ~]# machinectl copy-from 8824c90294d5a36d396c8ab35167937f /etc/named.conf /srv/named/etc/named.conf
[root@rhel7-host ~]# machinectl copy-from 8824c90294d5a36d396c8ab35167937f /var/named /srv/named/var/named
[root@rhel7-host ~]# docker stop infallible_wescoff
```
### 最终的创建
为了创建和运行最终的容器，添加卷选项以挂载：
* 将文件 `/srv/named/etc/named.conf` 映射为 `/etc/named.conf`
* 将目录 `/srv/named/var/named` 映射为 `/var/named`
因为这是我们最终的容器，我们将提供一个有意义的名字，以供我们以后引用。
```
[root@rhel7-host ~]# docker run -d -p 53:53 -p 53:53/udp -v /srv/named/etc/named.conf:/etc/named.conf:Z -v /srv/named/var/named:/var/named:Z --name named-container named
```
在最终容器运行时，我们可以更改本机配置来改变这个容器中 BIND 的行为。这个 BIND 服务器将需要在这个容器分配的任何 IP 上监听。请确保任何新文件的 GID 与来自这个容器中的其余的 BIND 文件相匹配。
```
[root@rhel7-host bind]# cp named.conf /srv/named/etc/named.conf
[root@rhel7-host ~]# cp example.com.zone /srv/named/var/named/example.com.zone
[root@rhel7-host ~]# cp example.com.rr.zone /srv/named/var/named/example.com.rr.zone
```
>
> 很好奇为什么我不需要在主机目录中改变 SELinux 上下文？<sup> 注1</sup>
>
>
>
我们将运行这个容器提供的 `rndc` 二进制文件重新加载配置。我们可以使用 `journald` 以同样的方式检查 BIND 日志。如果运行出现错误，你可以在主机中编辑该文件，并且重新加载配置。在主机中使用 `host` 或 `dig`，我们可以检查来自该容器化服务的 example.com 的响应。
```
[root@rhel7-host ~]# docker exec -it named-container rndc reload
server reload successful
[root@rhel7-host ~]# docker exec -it named-container journalctl -u named -n
-- Logs begin at Fri 2017-05-12 19:15:18 UTC, end at Fri 2017-05-12 19:29:17 UTC. --
May 12 19:29:17 ac1752c314a7 named[27]: automatic empty zone: 9.E.F.IP6.ARPA
May 12 19:29:17 ac1752c314a7 named[27]: automatic empty zone: A.E.F.IP6.ARPA
May 12 19:29:17 ac1752c314a7 named[27]: automatic empty zone: B.E.F.IP6.ARPA
May 12 19:29:17 ac1752c314a7 named[27]: automatic empty zone: 8.B.D.0.1.0.0.2.IP6.ARPA
May 12 19:29:17 ac1752c314a7 named[27]: reloading configuration succeeded
May 12 19:29:17 ac1752c314a7 named[27]: reloading zones succeeded
May 12 19:29:17 ac1752c314a7 named[27]: zone 1.0.10.in-addr.arpa/IN: loaded serial 2001062601
May 12 19:29:17 ac1752c314a7 named[27]: zone 1.0.10.in-addr.arpa/IN: sending notifies (serial 2001062601)
May 12 19:29:17 ac1752c314a7 named[27]: all zones loaded
May 12 19:29:17 ac1752c314a7 named[27]: running
[root@rhel7-host bind]# host www.example.com localhost
Using domain server:
Name: localhost
Address: ::1#53
Aliases:
www.example.com is an alias for server1.example.com.
server1.example.com is an alias for mail
```
>
> 你的区域文件没有更新吗？可能是因为你的编辑器，而不是序列号。<sup> 注2</sup>
>
>
>
### 终点线
我们已经达成了我们打算完成的目标，从容器中为 DNS 请求和区域文件提供服务。我们已经得到一个持久化的位置来管理更新和配置，并且更新后该配置不变。
在这个系列的第二部分，我们将看到怎样将一个容器看作为主机中的一个普通服务来运行。
---
[关注 RHEL 博客](http://redhatstackblog.wordpress.com/feed/)，通过电子邮件来获得本系列第二部分和其它新文章的更新。
---
### 附加资源
* **所附带文件的 Github 仓库：** <https://github.com/nzwulfin/named-container>
* **注1：** **通过容器访问本地文件的 SELinux 上下文**
你可能已经注意到当我从容器向本地主机拷贝文件时，我没有运行 `chcon` 将主机中的文件类型改变为 `svirt_sandbox_file_t`。为什么它没有出错？将一个文件拷贝到 `/srv` 会将这个文件标记为类型 `var_t`。我 `setenforce 0` （关闭 SELinux）了吗？
当然没有，这将让 [Dan Walsh 大哭](https://stopdisablingselinux.com/)（LCTT 译注：RedHat 的 SELinux 团队负责人，倡议不要禁用 SELinux）。是的，`machinectl` 确实将文件标记类型设置为期望的那样，可以看一下：
启动一个容器之前：
```
[root@rhel7-host ~]# ls -Z /srv/named/etc/named.conf
-rw-r-----. unconfined_u:object_r:var_t:s0 /srv/named/etc/named.conf
```
不过，运行中我使用了一个卷选项可以使 Dan Walsh 先生高兴起来，`:Z`。`-v /srv/named/etc/named.conf:/etc/named.conf:Z` 命令的这部分做了两件事情：首先它表示这需要使用一个私有卷的 SELiunx 标记来重新标记；其次它表明以读写挂载。
启动容器之后：
```
[root@rhel7-host ~]# ls -Z /srv/named/etc/named.conf
-rw-r-----. root 25 system_u:object_r:svirt_sandbox_file_t:s0:c821,c956 /srv/named/etc/named.conf
```
* **注2：** **VIM 备份行为能改变 inode**
如果你在本地主机中使用 `vim` 来编辑配置文件，而你没有看到容器中的改变，你可能不经意的创建了容器感知不到的新文件。在编辑时，有三种 `vim` 设定影响备份副本：`backup`、`writebackup` 和 `backupcopy`。
我摘录了 RHEL 7 中的来自官方 VIM [backup\_table](http://vimdoc.sourceforge.net/htmldoc/editing.html#backup-table) 中的默认配置。
```
backup writebackup
off on backup current file, deleted afterwards (default)
```
所以我们不创建残留下的 `~` 副本，而是创建备份。另外的设定是 `backupcopy`，`auto` 是默认的设置：
```
"yes" make a copy of the file and overwrite the original one
"no" rename the file and write a new one
"auto" one of the previous, what works best
```
这种组合设定意味着当你编辑一个文件时，除非 `vim` 有理由（请查看文档了解其逻辑），你将会得到一个包含你编辑内容的新文件，当你保存时它会重命名为原先的文件。这意味着这个文件获得了新的 inode。对于大多数情况，这不是问题，但是这里容器的<ruby> 绑定挂载 <rt> bind mount </rt></ruby>对 inode 的改变很敏感。为了解决这个问题，你需要改变 `backupcopy` 的行为。
不管是在 `vim` 会话中还是在你的 `.vimrc`中，请添加 `set backupcopy=yes`。这将确保原先的文件被清空并覆写，维持了 inode 不变并且将该改变传递到了容器中。
---
via: <http://rhelblog.redhat.com/2017/07/19/containing-system-services-in-red-hat-enterprise-linux-part-1/>
作者：[Matt Micene](http://rhelblog.redhat.com/2017/07/19/containing-system-services-in-red-hat-enterprise-linux-part-1/) 译者：[liuxinyu123](https://github.com/liuxinyu123) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Suplemon：带有多光标支持的现代 CLI 文本编辑器
|
Ivo Ursino
|
https://linoxide.com/tools/suplemon-cli-text-editor-multi-cursor/
|
Suplemon 是一个 CLI 中的现代文本编辑器，它模拟 Sublime Text 的多光标行为和其它特性。它是轻量级的，非常易于使用，就像 Nano 一样。
|
/data/attachment/album/201712/12/145414by3qq9c0qq6cwq6y.jpg.thumb.jpg
|
/data/attachment/album/201712/12/145414by3qq9c0qq6cwq6y.jpg
| true | false | true |
geekpi
| false |
[
"编辑器",
"suplemon"
] |
分享
|
{
"viewnum": 5319,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Suplemon 是一个 CLI 中的现代文本编辑器，它模拟 Sublime Text 的多光标行为和其它特性。它是轻量级的，非常易于使用，就像 Nano 一样。
| 2017-12-12T14:52:00 | 2017-12-12T14:52:00 | 9,136 |
/article-9136-1.html
|
Suplemon 是一个 CLI 中的现代文本编辑器，它模拟 [Sublime Text](https://linoxide.com/tools/install-sublime-text-editor-linux/) 的多光标行为和其它特性。它是轻量级的，非常易于使用，就像 Nano 一样。
使用 CLI 编辑器的好处之一是，无论你使用的 Linux 发行版是否有 GUI，你都可以使用它。这种文本编辑器也很简单、快速和强大。
你可以在其[官方仓库](https://github.com/richrd/suplemon/)中找到有用的信息和源代码。
### 功能
这些是一些它有趣的功能：
* 多光标支持
* 撤销/重做
* 复制和粘贴，带有多行支持
* 鼠标支持
* 扩展
* 查找、查找所有、查找下一个
* 语法高亮
* 自动完成
* 自定义键盘快捷键
### 安装
首先，确保安装了最新版本的 python3 和 pip3。
然后在终端输入：
```
$ sudo pip3 install suplemon
```
### 使用
#### 在当前目录中创建一个新文件
打开一个终端并输入：
```
$ suplemon
```
你将看到如下：
#### 打开一个或多个文件
打开一个终端并输入：
```
$ suplemon <filename1> <filename2> ... <filenameN>
```
例如：
```
$ suplemon example1.c example2.c
```
### 主要配置
你可以在 `~/.config/suplemon/suplemon-config.json` 找到配置文件。
编辑这个文件很简单，你只需要进入命令模式（进入 suplemon 后）并运行 `config` 命令。你可以通过运行 `config defaults` 来查看默认配置。
#### 键盘映射配置
我会展示 suplemon 的默认键映射。如果你想编辑它们，只需运行 `keymap` 命令。运行 `keymap default` 来查看默认的键盘映射文件。
| 操作 | 快捷键 |
| --- | --- |
| 退出 | `Ctrl + Q` |
| 复制行到缓冲区 | `Ctrl + C` |
| 剪切行缓冲区 | `Ctrl + X` |
| 插入缓冲区 | `Ctrl + V` |
| 复制行 | `Ctrl + K` |
| 跳转 | `Ctrl + G`。 你可以跳转到一行或一个文件（只需键入一个文件名的开头）。 另外，可以输入类似于 `exam:50` 跳转到 `example.c` 第 `50` 行。 |
| 用字符串或正则表达式搜索 | `Ctrl + F` |
| 搜索下一个 | `Ctrl + D` |
| 去除空格 | `Ctrl + T` |
| 在箭头方向添加新的光标 | `Alt + 方向键` |
| 跳转到上一个或下一个单词或行 | `Ctrl + 左/右` |
| 恢复到单光标/取消输入提示 | `Esc` |
| 向上/向下移动行 | `Page Up` / `Page Down` |
| 保存文件 | `Ctrl + S` |
| 用新名称保存文件 | `F1` |
| 重新载入当前文件 | `F2` |
| 打开文件 | `Ctrl + O` |
| 关闭文件 | `Ctrl + W` |
| 切换到下一个/上一个文件 | `Ctrl + Page Up` / `Ctrl + Page Down` |
| 运行一个命令 | `Ctrl + E` |
| 撤消 | `Ctrl + Z` |
| 重做 | `Ctrl + Y` |
| 触发可见的空格 | `F7` |
| 切换鼠标模式 | `F8` |
| 显示行号 | `F9` |
| 显示全屏 | `F11` |
#### 鼠标快捷键
* 将光标置于指针位置：左键单击
* 在指针位置添加一个光标：右键单击
* 垂直滚动：向上/向下滚动滚轮
### 总结
在尝试 Suplemon 一段时间后，我改变了对 CLI 文本编辑器的看法。我以前曾经尝试过 Nano，是的，我喜欢它的简单性，但是它的现代特征的缺乏使它在日常使用中变得不实用。
这个工具有 CLI 和 GUI 世界最好的东西……简单性和功能丰富！所以我建议你试试看，并在评论中写下你的想法 :-)
---
via: <https://linoxide.com/tools/suplemon-cli-text-editor-multi-cursor/>
作者：[Ivo Ursino](https://linoxide.com/author/ursinov/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Glitch：可以让你立即写出有趣的小型网站
|
Julia Evans
|
https://jvns.ca/blog/2017/11/13/glitch--write-small-web-projects-easily/
|
Glitch 是一个简单的构建 Javascript web 程序的方式（javascript 后端、javascript 前端）。
|
/data/attachment/album/201712/12/165925g24w582uc5g553e7.jpg.thumb.jpg
|
/data/attachment/album/201712/12/165925g24w582uc5g553e7.jpg
| true | false | true |
geekpi
| false |
[
"Glitch",
"JavaScript"
] |
分享
|
{
"viewnum": 9201,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Glitch 是一个简单的构建 Javascript web 程序的方式（javascript 后端、javascript 前端）。
| 2017-12-15T16:54:00 | 2017-12-15T16:54:00 | 9,137 |
/article-9137-1.html
|
我刚写了一篇关于 Jupyter Notebooks 的文章，它是一个有趣的交互式写 Python 代码的方式。这让我想起我最近学习了 Glitch，这个我同样喜爱！我构建了一个小的程序来用于[关闭转发 twitter](https://turn-off-retweets.glitch.me/)。因此有了这篇文章！
[Glitch](https://glitch.com/) 是一个简单的构建 Javascript web 程序的方式（javascript 后端、javascript 前端）。
关于 glitch 有趣的地方有：
1. 你在他们的网站输入 Javascript 代码
2. 只要输入了任何代码，它会自动用你的新代码重载你的网站。你甚至不必保存！它会自动保存。
所以这就像 Heroku，但更神奇！像这样的编码（你输入代码，代码立即在公共网络上运行）对我而言感觉很**有趣**。
这有点像用 ssh 登录服务器，编辑服务器上的 PHP/HTML 代码，它立即就可用了，而这也是我所喜爱的方式。虽然现在我们有了“更好的部署实践”，而不是“编辑代码，让它立即出现在互联网上”，但我们并不是在谈论严肃的开发实践，而是在讨论编写微型程序的乐趣。
### Glitch 有很棒的示例应用程序
Glitch 似乎是学习编程的好方式！
比如，这有一个太空侵略者游戏（由 [Mary Rose Cook](https://maryrosecook.com/) 编写）：<https://space-invaders.glitch.me/>。我喜欢的是我只需要点击几下。
1. 点击 “remix this”
2. 开始编辑代码使箱子变成橘色而不是黑色
3. 制作我自己太空侵略者游戏！我的在这：<http://julias-space-invaders.glitch.me/>。（我只做了很小的更改使其变成橘色，没什么神奇的）
他们有大量的示例程序，你可以从中启动 - 例如[机器人](https://glitch.com/handy-bots)、[游戏](https://glitch.com/games)等等。
### 实际有用的非常好的程序：tweetstorms
我学习 Glitch 的方式是从这个程序开始的：<https://tweetstorms.glitch.me/>，它会向你展示给定用户的推特云。
比如，你可以在 <https://tweetstorms.glitch.me/sarahmei> 看到 [@sarahmei](https://twitter.com/sarahmei) 的推特云（她发布了很多好的 tweetstorm！）。
### 我的 Glitch 程序： 关闭转推
当我了解到 Glitch 的时候，我想关闭在 Twitter 上关注的所有人的转推（我知道可以在 Tweetdeck 中做这件事），而且手动做这件事是一件很痛苦的事 - 我一次只能设置一个人。所以我写了一个 Glitch 程序来为我做！
我喜欢我不必设置一个本地开发环境，我可以直接开始输入然后开始！
Glitch 只支持 Javascript，我不是非常了解 Javascript（我之前从没写过一个 Node 程序），所以代码不是很好。但是编写它很愉快 - 能够输入并立即看到我的代码运行是令人愉快的。这是我的项目：<https://turn-off-retweets.glitch.me/>。
### 就是这些！
使用 Glitch 感觉真的很有趣和民主。通常情况下，如果我想 fork 某人的 Web 项目，并做出更改，我不会这样做 - 我必须 fork，找一个托管，设置本地开发环境或者 Heroku 或其他，安装依赖项等。我认为像安装 node.js 依赖关系这样的任务在过去很有趣，就像“我正在学习新东西很酷”，但现在我觉得它们很乏味。
所以我喜欢只需点击 “remix this!” 并立即在互联网上能有我的版本。
---
via: <https://jvns.ca/blog/2017/11/13/glitch--write-small-web-projects-easily/>
作者：[Julia Evans](https://jvns.ca/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
7 个使用 bcc/BPF 的性能分析神器
|
Brendan Gregg
|
https://opensource.com/article/17/11/bccbpf-performance
|
在 Linux 中出现的一种新技术能够为系统管理员和开发者提供大量用于性能分析和故障排除的新工具和仪表盘。它被称为增强的伯克利数据包过滤器（eBPF，或 BPF），虽然这些改进并不是由伯克利开发的，而且它们不仅仅是处理数据包，更多的是过滤。
|
/data/attachment/album/201712/13/145007s235twz5tuib4sty.jpg.thumb.jpg
|
/data/attachment/album/201712/13/145007s235twz5tuib4sty.jpg
| true | false | true |
yongshouzhang
|
wxy
| true |
[
"性能分析",
"BPF",
"eBPF",
"bcc"
] |
技术
|
{
"viewnum": 19021,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在 Linux 中出现的一种新技术能够为系统管理员和开发者提供大量用于性能分析和故障排除的新工具和仪表盘。它被称为增强的伯克利数据包过滤器（eBPF，或 BPF），虽然这些改进并不是由伯克利开发的，而且它们不仅仅是处理数据包，更多的是过滤。
| 2017-12-13T14:51:00 | 2017-12-13T14:51:00 | 9,139 |
/article-9139-1.html
|
>
> 使用<ruby> 伯克利包过滤器 <rt> Berkeley Packet Filter </rt></ruby>（BPF）<ruby> 编译器集合 <rt> Compiler Collection </rt></ruby>（BCC）工具深度探查你的 Linux 代码。
>
>
>
在 Linux 中出现的一种新技术能够为系统管理员和开发者提供大量用于性能分析和故障排除的新工具和仪表盘。它被称为<ruby> 增强的伯克利数据包过滤器 <rt> enhanced Berkeley Packet Filter </rt></ruby>（eBPF，或 BPF），虽然这些改进并不是由伯克利开发的，而且它们不仅仅是处理数据包，更多的是过滤。我将讨论在 Fedora 和 Red Hat Linux 发行版中使用 BPF 的一种方法，并在 Fedora 26 上演示。
BPF 可以在内核中运行由用户定义的沙盒程序，可以立即添加新的自定义功能。这就像按需给 Linux 系统添加超能力一般。 你可以使用它的例子包括如下：
* **高级性能跟踪工具**：对文件系统操作、TCP 事件、用户级事件等的可编程的低开销检测。
* **网络性能**： 尽早丢弃数据包以提高对 DDoS 的恢复能力，或者在内核中重定向数据包以提高性能。
* **安全监控**： 7x24 小时的自定义检测和记录内核空间与用户空间内的可疑事件。
在可能的情况下，BPF 程序必须通过一个内核验证机制来保证它们的安全运行，这比写自定义的内核模块更安全。我在此假设大多数人并不编写自己的 BPF 程序，而是使用别人写好的。在 GitHub 上的 [BPF Compiler Collection (bcc)](https://github.com/iovisor/bcc) 项目中，我已发布许多开源代码。bcc 为 BPF 开发提供了不同的前端支持，包括 Python 和 Lua，并且是目前最活跃的 BPF 工具项目。
### 7 个有用的 bcc/BPF 新工具
为了了解 bcc/BPF 工具和它们的检测内容，我创建了下面的图表并添加到 bcc 项目中。
这些是命令行界面工具，你可以通过 SSH 使用它们。目前大多数分析，包括我的老板，都是用 GUI 和仪表盘进行的。SSH 是最后的手段。但这些命令行工具仍然是预览 BPF 能力的好方法，即使你最终打算通过一个可用的 GUI 使用它。我已着手向一个开源 GUI 添加 BPF 功能，但那是另一篇文章的主题。现在我想向你分享今天就可以使用的 CLI 工具。
#### 1、 execsnoop
从哪儿开始呢？如何查看新的进程。那些会消耗系统资源，但很短暂的进程，它们甚至不会出现在 `top(1)` 命令或其它工具中的显示之中。这些新进程可以使用 [execsnoop](https://github.com/brendangregg/perf-tools/blob/master/execsnoop) 进行检测（或使用行业术语说，可以<ruby> 被追踪 <rt> traced </rt></ruby>）。 在追踪时，我将在另一个窗口中通过 SSH 登录：
```
# /usr/share/bcc/tools/execsnoop
PCOMM PID PPID RET ARGS
sshd 12234 727 0 /usr/sbin/sshd -D -R
unix_chkpwd 12236 12234 0 /usr/sbin/unix_chkpwd root nonull
unix_chkpwd 12237 12234 0 /usr/sbin/unix_chkpwd root chkexpiry
bash 12239 12238 0 /bin/bash
id 12241 12240 0 /usr/bin/id -un
hostname 12243 12242 0 /usr/bin/hostname
pkg-config 12245 12244 0 /usr/bin/pkg-config --variable=completionsdir bash-completion
grepconf.sh 12246 12239 0 /usr/libexec/grepconf.sh -c
grep 12247 12246 0 /usr/bin/grep -qsi ^COLOR.*none /etc/GREP_COLORS
tty 12249 12248 0 /usr/bin/tty -s
tput 12250 12248 0 /usr/bin/tput colors
dircolors 12252 12251 0 /usr/bin/dircolors --sh /etc/DIR_COLORS
grep 12253 12239 0 /usr/bin/grep -qi ^COLOR.*none /etc/DIR_COLORS
grepconf.sh 12254 12239 0 /usr/libexec/grepconf.sh -c
grep 12255 12254 0 /usr/bin/grep -qsi ^COLOR.*none /etc/GREP_COLORS
grepconf.sh 12256 12239 0 /usr/libexec/grepconf.sh -c
grep 12257 12256 0 /usr/bin/grep -qsi ^COLOR.*none /etc/GREP_COLORS
```
哇哦。 那是什么？ 什么是 `grepconf.sh`？ 什么是 `/etc/GREP_COLORS`？ 是 `grep` 在读取它自己的配置文件……由 `grep` 运行的？ 这究竟是怎么工作的？
欢迎来到有趣的系统追踪世界。 你可以学到很多关于系统是如何工作的（或者根本不工作，在有些情况下），并且发现一些简单的优化方法。 `execsnoop` 通过跟踪 `exec()` 系统调用来工作，`exec()` 通常用于在新进程中加载不同的程序代码。
#### 2、 opensnoop
接着上面继续，所以，`grepconf.sh` 可能是一个 shell 脚本，对吧？ 我将运行 `file(1)` 来检查它，并使用[opensnoop](https://github.com/brendangregg/perf-tools/blob/master/opensnoop) bcc 工具来查看打开的文件：
```
# /usr/share/bcc/tools/opensnoop
PID COMM FD ERR PATH
12420 file 3 0 /etc/ld.so.cache
12420 file 3 0 /lib64/libmagic.so.1
12420 file 3 0 /lib64/libz.so.1
12420 file 3 0 /lib64/libc.so.6
12420 file 3 0 /usr/lib/locale/locale-archive
12420 file -1 2 /etc/magic.mgc
12420 file 3 0 /etc/magic
12420 file 3 0 /usr/share/misc/magic.mgc
12420 file 3 0 /usr/lib64/gconv/gconv-modules.cache
12420 file 3 0 /usr/libexec/grepconf.sh
1 systemd 16 0 /proc/565/cgroup
1 systemd 16 0 /proc/536/cgroup
```
像 `execsnoop` 和 `opensnoop` 这样的工具会将每个事件打印一行。上图显示 `file(1)` 命令当前打开（或尝试打开）的文件：返回的文件描述符（“FD” 列）对于 `/etc/magic.mgc` 是 -1，而 “ERR” 列指示它是“文件未找到”。我不知道该文件，也不知道 `file(1)` 正在读取的 `/usr/share/misc/magic.mgc` 文件是什么。我不应该感到惊讶，但是 `file(1)` 在识别文件类型时没有问题：
```
# file /usr/share/misc/magic.mgc /etc/magic
/usr/share/misc/magic.mgc: magic binary file for file(1) cmd (version 14) (little endian)
/etc/magic: magic text file for file(1) cmd, ASCII text
```
`opensnoop` 通过跟踪 `open()` 系统调用来工作。为什么不使用 `strace -feopen file` 命令呢？ 在这种情况下是可以的。然而，`opensnoop` 的一些优点在于它能在系统范围内工作，并且跟踪所有进程的 `open()` 系统调用。注意上例的输出中包括了从 systemd 打开的文件。`opensnoop` 应该系统开销更低：BPF 跟踪已经被优化过，而当前版本的 `strace(1)` 仍然使用较老和较慢的 `ptrace(2)` 接口。
#### 3、 xfsslower
bcc/BPF 不仅仅可以分析系统调用。[xfsslower](https://github.com/iovisor/bcc/blob/master/tools/xfsslower.py) 工具可以跟踪大于 1 毫秒（参数）延迟的常见 XFS 文件系统操作。
```
# /usr/share/bcc/tools/xfsslower 1
Tracing XFS operations slower than 1 ms
TIME COMM PID T BYTES OFF_KB LAT(ms) FILENAME
14:17:34 systemd-journa 530 S 0 0 1.69 system.journal
14:17:35 auditd 651 S 0 0 2.43 audit.log
14:17:42 cksum 4167 R 52976 0 1.04 at
14:17:45 cksum 4168 R 53264 0 1.62 [
14:17:45 cksum 4168 R 65536 0 1.01 certutil
14:17:45 cksum 4168 R 65536 0 1.01 dir
14:17:45 cksum 4168 R 65536 0 1.17 dirmngr-client
14:17:46 cksum 4168 R 65536 0 1.06 grub2-file
14:17:46 cksum 4168 R 65536 128 1.01 grub2-fstest
[...]
```
在上图输出中，我捕获到了多个延迟超过 1 毫秒 的 `cksum(1)` 读取操作（字段 “T” 等于 “R”）。这是在 `xfsslower` 工具运行的时候，通过在 XFS 中动态地检测内核函数实现的，并当它结束的时候解除该检测。这个 bcc 工具也有其它文件系统的版本：`ext4slower`、`btrfsslower`、`zfsslower` 和 `nfsslower`。
这是个有用的工具，也是 BPF 追踪的重要例子。对文件系统性能的传统分析主要集中在块 I/O 统计信息 —— 通常你看到的是由 `iostat(1)` 工具输出，并由许多性能监视 GUI 绘制的图表。这些统计数据显示的是磁盘如何执行，而不是真正的文件系统如何执行。通常比起磁盘来说，你更关心的是文件系统的性能，因为应用程序是在文件系统中发起请求和等待。并且，文件系统的性能可能与磁盘的性能大为不同！文件系统可以完全从内存缓存中读取数据，也可以通过预读算法和回写缓存来填充缓存。`xfsslower` 显示了文件系统的性能 —— 这是应用程序直接体验到的性能。通常这对于排除整个存储子系统的问题是有用的；如果确实没有文件系统延迟，那么性能问题很可能是在别处。
#### 4、 biolatency
虽然文件系统性能对于理解应用程序性能非常重要，但研究磁盘性能也是有好处的。当各种缓存技巧都无法挽救其延迟时，磁盘的低性能终会影响应用程序。 磁盘性能也是容量规划研究的目标。
`iostat(1)` 工具显示了平均磁盘 I/O 延迟，但平均值可能会引起误解。 以直方图的形式研究 I/O 延迟的分布是有用的，这可以通过使用 [biolatency] 来实现[18](https://github.com/iovisor/bcc/blob/master/tools/biolatency.py)：
```
# /usr/share/bcc/tools/biolatency
Tracing block device I/O... Hit Ctrl-C to end.
^C
usecs : count distribution
0 -> 1 : 0 | |
2 -> 3 : 0 | |
4 -> 7 : 0 | |
8 -> 15 : 0 | |
16 -> 31 : 0 | |
32 -> 63 : 1 | |
64 -> 127 : 63 |**** |
128 -> 255 : 121 |********* |
256 -> 511 : 483 |************************************ |
512 -> 1023 : 532 |****************************************|
1024 -> 2047 : 117 |******** |
2048 -> 4095 : 8 | |
```
这是另一个有用的工具和例子；它使用一个名为 maps 的 BPF 特性，它可以用来实现高效的内核摘要统计。从内核层到用户层的数据传输仅仅是“计数”列。 用户级程序生成其余的。
值得注意的是，这种工具大多支持 CLI 选项和参数，如其使用信息所示：
```
# /usr/share/bcc/tools/biolatency -h
usage: biolatency [-h] [-T] [-Q] [-m] [-D] [interval] [count]
Summarize block device I/O latency as a histogram
positional arguments:
interval output interval, in seconds
count number of outputs
optional arguments:
-h, --help show this help message and exit
-T, --timestamp include timestamp on output
-Q, --queued include OS queued time in I/O time
-m, --milliseconds millisecond histogram
-D, --disks print a histogram per disk device
examples:
./biolatency # summarize block I/O latency as a histogram
./biolatency 1 10 # print 1 second summaries, 10 times
./biolatency -mT 1 # 1s summaries, milliseconds, and timestamps
./biolatency -Q # include OS queued time in I/O time
./biolatency -D # show each disk device separately
```
它们的行为就像其它 Unix 工具一样，以利于采用而设计。
#### 5、 tcplife
另一个有用的工具是 [tcplife](https://github.com/iovisor/bcc/blob/master/tools/tcplife.py) ，该例显示 TCP 会话的生命周期和吞吐量统计。
```
# /usr/share/bcc/tools/tcplife
PID COMM LADDR LPORT RADDR RPORT TX_KB RX_KB MS
12759 sshd 192.168.56.101 22 192.168.56.1 60639 2 3 1863.82
12783 sshd 192.168.56.101 22 192.168.56.1 60640 3 3 9174.53
12844 wget 10.0.2.15 34250 54.204.39.132 443 11 1870 5712.26
12851 curl 10.0.2.15 34252 54.204.39.132 443 0 74 505.90
```
在你说 “我不是可以只通过 `tcpdump(8)` 就能输出这个？” 之前请注意，运行 `tcpdump(8)` 或任何数据包嗅探器，在高数据包速率的系统上的开销会很大，即使 `tcpdump(8)` 的用户层和内核层机制已经过多年优化（要不可能更差）。`tcplife` 不会测试每个数据包；它只会有效地监视 TCP 会话状态的变化，并由此得到该会话的持续时间。它还使用已经跟踪了吞吐量的内核计数器，以及进程和命令信息（“PID” 和 “COMM” 列），这些对于 `tcpdump(8)` 等线上嗅探工具是做不到的。
#### 6、 gethostlatency
之前的每个例子都涉及到内核跟踪，所以我至少需要一个用户级跟踪的例子。 这就是 [gethostlatency](https://github.com/iovisor/bcc/blob/master/tools/gethostlatency.py)，它检测用于名称解析的 `gethostbyname(3)` 和相关的库调用：
```
# /usr/share/bcc/tools/gethostlatency
TIME PID COMM LATms HOST
06:43:33 12903 curl 188.98 opensource.com
06:43:36 12905 curl 8.45 opensource.com
06:43:40 12907 curl 6.55 opensource.com
06:43:44 12911 curl 9.67 opensource.com
06:45:02 12948 curl 19.66 opensource.cats
06:45:06 12950 curl 18.37 opensource.cats
06:45:07 12952 curl 13.64 opensource.cats
06:45:19 13139 curl 13.10 opensource.cats
```
是的，总是有 DNS 请求，所以有一个工具来监视系统范围内的 DNS 请求会很方便（这只有在应用程序使用标准系统库时才有效）。看看我如何跟踪多个对 “opensource.com” 的查找？ 第一个是 188.98 毫秒，然后更快，不到 10 毫秒，毫无疑问，这是缓存的作用。它还追踪多个对 “opensource.cats” 的查找，一个不存在的可怜主机名，但我们仍然可以检查第一个和后续查找的延迟。（第二次查找后是否有一些否定缓存的影响？）
#### 7、 trace
好的，再举一个例子。 [trace](https://github.com/iovisor/bcc/blob/master/tools/trace.py) 工具由 Sasha Goldshtein 提供，并提供了一些基本的 `printf(1)` 功能和自定义探针。 例如：
```
# /usr/share/bcc/tools/trace 'pam:pam_start "%s: %s", arg1, arg2'
PID TID COMM FUNC -
13266 13266 sshd pam_start sshd: root
```
在这里，我正在跟踪 `libpam` 及其 `pam_start(3)` 函数，并将其两个参数都打印为字符串。 `libpam` 用于插入式身份验证模块系统，该输出显示 sshd 为 “root” 用户调用了 `pam_start()`（我登录了）。 其使用信息中有更多的例子（`trace -h`），而且所有这些工具在 bcc 版本库中都有手册页和示例文件。 例如 `trace_example.txt` 和 `trace.8`。
### 通过包安装 bcc
安装 bcc 最佳的方法是从 iovisor 仓储库中安装，按照 bcc 的 [INSTALL.md](https://github.com/iovisor/bcc/blob/master/INSTALL.md#fedora---binary) 进行即可。[IO Visor](https://www.iovisor.org/) 是包括了 bcc 的 Linux 基金会项目。4.x 系列 Linux 内核中增加了这些工具所使用的 BPF 增强功能，直到 4.9 添加了全部支持。这意味着拥有 4.8 内核的 Fedora 25 可以运行这些工具中的大部分。 使用 4.11 内核的 Fedora 26 可以全部运行它们（至少在目前是这样）。
如果你使用的是 Fedora 25（或者 Fedora 26，而且这个帖子已经在很多个月前发布了 —— 你好，来自遥远的过去！），那么这个通过包安装的方式是可以工作的。 如果您使用的是 Fedora 26，那么请跳至“通过源代码安装”部分，它避免了一个[已修复的](https://reviews.llvm.org/rL302055)的[已知](https://github.com/iovisor/bcc/issues/1221)错误。 这个错误修复目前还没有进入 Fedora 26 软件包的依赖关系。 我使用的系统是：
```
# uname -a
Linux localhost.localdomain 4.11.8-300.fc26.x86_64 #1 SMP Thu Jun 29 20:09:48 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
# cat /etc/fedora-release
Fedora release 26 (Twenty Six)
```
以下是我所遵循的安装步骤，但请参阅 INSTALL.md 获取更新的版本：
```
# echo -e '[iovisor]\nbaseurl=https://repo.iovisor.org/yum/nightly/f25/$basearch\nenabled=1\ngpgcheck=0' | sudo tee /etc/yum.repos.d/iovisor.repo
# dnf install bcc-tools
[...]
Total download size: 37 M
Installed size: 143 M
Is this ok [y/N]: y
```
安装完成后，您可以在 `/usr/share` 中看到新的工具：
```
# ls /usr/share/bcc/tools/
argdist dcsnoop killsnoop softirqs trace
bashreadline dcstat llcstat solisten ttysnoop
[...]
```
试着运行其中一个：
```
# /usr/share/bcc/tools/opensnoop
chdir(/lib/modules/4.11.8-300.fc26.x86_64/build): No such file or directory
Traceback (most recent call last):
File "/usr/share/bcc/tools/opensnoop", line 126, in
b = BPF(text=bpf_text)
File "/usr/lib/python3.6/site-packages/bcc/__init__.py", line 284, in __init__
raise Exception("Failed to compile BPF module %s" % src_file)
Exception: Failed to compile BPF module
```
运行失败，提示 `/lib/modules/4.11.8-300.fc26.x86_64/build` 丢失。 如果你也遇到这个问题，那只是因为系统缺少内核头文件。 如果你看看这个文件指向什么（这是一个符号链接），然后使用 `dnf whatprovides` 来搜索它，它会告诉你接下来需要安装的包。 对于这个系统，它是：
```
# dnf install kernel-devel-4.11.8-300.fc26.x86_64
[...]
Total download size: 20 M
Installed size: 63 M
Is this ok [y/N]: y
[...]
```
现在：
```
# /usr/share/bcc/tools/opensnoop
PID COMM FD ERR PATH
11792 ls 3 0 /etc/ld.so.cache
11792 ls 3 0 /lib64/libselinux.so.1
11792 ls 3 0 /lib64/libcap.so.2
11792 ls 3 0 /lib64/libc.so.6
[...]
```
运行起来了。 这是捕获自另一个窗口中的 ls 命令活动。 请参阅前面的部分以使用其它有用的命令。
### 通过源码安装
如果您需要从源代码安装，您还可以在 [INSTALL.md](https://github.com/iovisor/bcc/blob/master/INSTALL.md#fedora---source) 中找到文档和更新说明。 我在 Fedora 26 上做了如下的事情：
```
sudo dnf install -y bison cmake ethtool flex git iperf libstdc++-static \
python-netaddr python-pip gcc gcc-c++ make zlib-devel \
elfutils-libelf-devel
sudo dnf install -y luajit luajit-devel # for Lua support
sudo dnf install -y \
http://pkgs.repoforge.org/netperf/netperf-2.6.0-1.el6.rf.x86_64.rpm
sudo pip install pyroute2
sudo dnf install -y clang clang-devel llvm llvm-devel llvm-static ncurses-devel
```
除 `netperf` 外一切妥当，其中有以下错误：
```
Curl error (28): Timeout was reached for http://pkgs.repoforge.org/netperf/netperf-2.6.0-1.el6.rf.x86_64.rpm [Connection timed out after 120002 milliseconds]
```
不必理会，`netperf` 是可选的，它只是用于测试，而 bcc 没有它也会编译成功。
以下是余下的 bcc 编译和安装步骤：
```
git clone https://github.com/iovisor/bcc.git
mkdir bcc/build; cd bcc/build
cmake .. -DCMAKE_INSTALL_PREFIX=/usr
make
sudo make install
```
现在，命令应该可以工作了：
```
# /usr/share/bcc/tools/opensnoop
PID COMM FD ERR PATH
4131 date 3 0 /etc/ld.so.cache
4131 date 3 0 /lib64/libc.so.6
4131 date 3 0 /usr/lib/locale/locale-archive
4131 date 3 0 /etc/localtime
[...]
```
### 写在最后和其他的前端
这是一个可以在 Fedora 和 Red Hat 系列操作系统上使用的新 BPF 性能分析强大功能的快速浏览。我演示了 BPF 的流行前端 [bcc](https://github.com/iovisor/bcc) ，并包括了其在 Fedora 上的安装说明。bcc 附带了 60 多个用于性能分析的新工具，这将帮助您充分利用 Linux 系统。也许你会直接通过 SSH 使用这些工具，或者一旦 GUI 监控程序支持 BPF 的话，你也可以通过它们来使用相同的功能。
此外，bcc 并不是正在开发的唯一前端。[ply](https://github.com/iovisor/ply) 和 [bpftrace](https://github.com/ajor/bpftrace)，旨在为快速编写自定义工具提供更高级的语言支持。此外，[SystemTap](https://sourceware.org/systemtap/) 刚刚发布[版本 3.2](https://sourceware.org/ml/systemtap/2017-q4/msg00096.html)，包括一个早期的实验性 eBPF 后端。 如果这个继续开发，它将为运行多年来开发的许多 SystemTap 脚本和 tapset（库）提供一个安全和高效的生产级引擎。（随同 eBPF 使用 SystemTap 将是另一篇文章的主题。）
如果您需要开发自定义工具，那么也可以使用 bcc 来实现，尽管语言比 SystemTap、ply 或 bpftrace 要冗长得多。我的 bcc 工具可以作为代码示例，另外我还贡献了用 Python 开发 bcc 工具的[教程](https://github.com/iovisor/bcc/blob/master/docs/tutorial_bcc_python_developer.md)。 我建议先学习 bcc 的 multi-tools，因为在需要编写新工具之前，你可能会从里面获得很多经验。 您可以从它们的 bcc 存储库[funccount](https://github.com/iovisor/bcc/blob/master/tools/funccount_example.txt)，[funclatency](https://github.com/iovisor/bcc/blob/master/tools/funclatency_example.txt)，[funcslower](https://github.com/iovisor/bcc/blob/master/tools/funcslower_example.txt)，[stackcount](https://github.com/iovisor/bcc/blob/master/tools/stackcount_example.txt)，[trace](https://github.com/iovisor/bcc/blob/master/tools/trace_example.txt) ，[argdist](https://github.com/iovisor/bcc/blob/master/tools/argdist_example.txt) 的示例文件中研究 bcc。
感谢 [Opensource.com](http://opensource.com/) 进行编辑。
### 关于作者
Brendan Gregg 是 Netflix 的一名高级性能架构师，在那里他进行大规模的计算机性能设计、分析和调优。
---
via:<https://opensource.com/article/17/11/bccbpf-performance>
作者：[Brendan Gregg](https://opensource.com/users/brendang) 译者：[yongshouzhang](https://github.com/yongshouzhang) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|
LibreOffice 上架 Flathub 应用商店
|
Joey Sneddon
|
http://www.omgubuntu.co.uk/2017/11/libreoffice-now-available-flathub-flatpak-app-store
|
它的到来使任何运行现代 Linux 发行版的人都能只点击一两次即可安装 LibreOffice 的最新稳定版本，而无需搜索 PPA，纠缠于 tar 包或等待发行版将其打包。
|
/data/attachment/album/201712/13/153857yzradgfhgdaitvis.jpg.thumb.jpg
|
/data/attachment/album/201712/13/153857yzradgfhgdaitvis.jpg
| true | false | true |
geekpi
| false |
[
"LibreOffice",
"Flatpak"
] |
桌面应用
|
{
"viewnum": 6334,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
它的到来使任何运行现代 Linux 发行版的人都能只点击一两次即可安装 LibreOffice 的最新稳定版本，而无需搜索 PPA，纠缠于 tar 包或等待发行版将其打包。
| 2017-12-13T15:38:54 | 2017-12-13T15:38:54 | 9,140 |
/article-9140-1.html
|
>
> LibreOffice 现在可以从集中化的 Flatpak 应用商店 [Flathub](http://www.flathub.org/) 进行安装。
>
>
>
它的到来使任何运行现代 Linux 发行版的人都能只点击一两次即可安装 LibreOffice 的最新稳定版本，而无需搜索 PPA，纠缠于 tar 包或等待发行版将其打包。
自去年 8 月份 [LibreOffice 5.2](http://www.omgubuntu.co.uk/2016/08/libreoffice-5-2-released-whats-new) 发布以来，[LibreOffice Flatpak](http://www.omgubuntu.co.uk/2016/08/libreoffice-5-2-released-whats-new) 已经可供用户下载和安装。
这里“新”的是指发行方法。<ruby> 文档基金会 <rt> Document Foundation </rt></ruby>选择使用 Flathub 而不是专门的服务器来发布更新。
这对于终端用户来说是一个*很好*的消息，因为这意味着不需要在新安装时担心仓库，但对于 Flatpak 的倡议者来说也是一个好消息：LibreOffice 是开源软件里最流行的生产力套件。它对该格式和应用商店的支持肯定会受到热烈的欢迎。
在撰写本文时，你可以从 Flathub 安装 LibreOffice 5.4.2。新的稳定版本将在发布时添加。
### 在 Ubuntu 上启用 Flathub
要在 Ubuntu 上启动并运行 Flatpak，首先必须安装它：
```
sudo apt install flatpak gnome-software-plugin-flatpak
```
为了能够从 Flathub 安装应用程序，你需要添加 Flathub 远程服务器：
```
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
```
这就行了。只需注销并重新登录（以便 Ubuntu Software 刷新其缓存），之后你应该能够通过 Ubuntu Software 看到 Flathub 上的任何 Flatpak 程序了。
*Fedora、Arch 和 Linux Mint 18.3 用户已经安装了 Flatpak，随时可以开箱即用。Mint 甚至预启用了 Flathub remote。*
在本例中，搜索 “LibreOffice” 并在结果中找到下面有 Flathub 提示的结果。（请记住，Ubuntu 已经调整了客户端，来将 Snap 程序显示在最上面，所以你可能需要向下滚动列表来查看它）。
### 从 Flathub 安装 LibreOffice
* [从 Flathub 安装 LibreOffice](https://flathub.org/repo/appstream/org.libreoffice.LibreOffice.flatpakref)
从 flatpakref 中[安装 Flatpak 程序有一个 bug](https://bugs.launchpad.net/ubuntu/+source/gnome-software/+bug/1716409)，所以如果上面的方法不起作用，你也可以使用命令行从 Flathub 中安装 Flathub 程序。
Flathub 网站列出了安装每个程序所需的命令。切换到“命令行”选项卡来查看它们。
### Flathub 上更多的应用
如果你经常看这个网站，你就会知道我喜欢 Flathub。这是我最喜欢的一些应用（Corebird、Parlatype、GNOME MPV、Peek、Audacity、GIMP 等）的家园。我无需等待就能获得这些应用程序的最新、稳定版本（加上它们需要的所有依赖）。
而且，在我 twiiter 上发布一周左右后，大多数 Flatpak 应用现在看起来有很棒 GTK 主题 - 不再需要[临时方案](http://www.omgubuntu.co.uk/2017/05/flatpak-theme-issue-fix)了！
---
via: <http://www.omgubuntu.co.uk/2017/11/libreoffice-now-available-flathub-flatpak-app-store>
作者：[JOEY SNEDDON](https://plus.google.com/117485690627814051450/?rel=author) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
从实战出发，谈谈 nginx 信号集
|
张超
|
https://tech.upyun.com/article/260/1.html
|
nginx 信号操作在日常运维中是最常见的，也是非常重要的，这个环节如果出现失误则可能造成业务异常，带来损失。所以理清楚 nginx 信号集是非常必要的，能帮助我们更好地处理这些工作。
|
/data/attachment/album/201712/13/210935plsxjv4f4sjs1x44.jpg.thumb.jpg
|
/data/attachment/album/201712/13/210935plsxjv4f4sjs1x44.jpg
| true | false | false | false |
[
"nginx"
] |
技术
|
{
"viewnum": 5069,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
nginx 信号操作在日常运维中是最常见的，也是非常重要的，这个环节如果出现失误则可能造成业务异常，带来损失。所以理清楚 nginx 信号集是非常必要的，能帮助我们更好地处理这些工作。
| 2017-12-13T21:09:41 | 2017-12-13T21:09:41 | 9,141 |
/article-9141-1.html
|
### 前言
之前工作时候，一台引流测试机器的一个 ngx\_lua 服务突然出现了一些 HTTP/500 响应，从错误日志打印的堆栈来看，是不久前新发布的版本里添加的一个 Lua table 不存在，而有代码向其进行索引导致的。这令人百思不得其解，如果是版本回退导致的，那么为什么使用这个 Lua table 的代码没有被回退，偏偏定义这个 table 的代码被回退了呢？
经过排查发现，当时 nginx 刚刚完成热更新操作，旧的 master 进程还存在，因为要准备机器重启，先切掉了引流流量（但有些请求还在），同时系统触发了 `nginx -s stop`，这才导致了这个问题。
### 场景复现
下面我将使用一个原生的 nginx，在我的安装了 fedora26 的虚拟机上复现这个过程，我使用的 nginx 版本是目前最新的 `1.13.4`
首先启动 nginx：
```
alex@Fedora26-64: ~/bin_install/nginx
./sbin/nginx
alex@Fedora26-64: ~/bin_install/nginx
ps auxf | grep nginx
alex 6174 0.0 0.0 28876 428 ? Ss 14:35 0:00 nginx: master process ./sbin/nginx
alex 6175 0.0 0.2 29364 2060 ? S 14:35 0:00 \\_ nginx: worker process
```
可以看到 master 和 worker 都已经在运行。
接着我们向 master 发送一个 `SIGUSR2` 信号，当 nginx 核心收到这个信号后，就会触发热更新。
```
alex@Fedora26-64: ~/bin_install/nginx
kill -USR2 6174
alex@Fedora26-64: ~/bin_install/nginx
ps auxf | grep nginx
alex 6174 0.0 0.1 28876 1996 ? Ss 14:35 0:00 nginx: master process ./sbin/nginx
alex 6175 0.0 0.2 29364 2060 ? S 14:35 0:00 \\_ nginx: worker process
alex 6209 0.0 0.2 28876 2804 ? S 14:37 0:00 \\_ nginx: master process ./sbin/nginx
alex 6213 0.0 0.1 29364 2004 ? S 14:37 0:00 \\_ nginx: worker process
```
可以看到新的 master 和该 master fork 出来的 worker 已经在运行了，此时我们接着向旧 master 发送一个 `SIGWINCH` 信号，旧 master 收到这个信号后，会向它的 worker 发送 `SIGQUIT`，于是旧 master 的 worker 进程就会退出：
```
alex@Fedora26-64: ~/bin_install/nginx
kill -WINCH 6174
alex@Fedora26-64: ~/bin_install/nginx
ps auxf | grep nginx
alex 6174 0.0 0.1 28876 1996 ? Ss 14:35 0:00 nginx: master process ./sbin/nginx
alex 6209 0.0 0.2 28876 2804 ? S 14:37 0:00 \\_ nginx: master process ./sbin/nginx
alex 6213 0.0 0.1 29364 2004 ? S 14:37 0:00 \\_ nginx: worker process
```
此时只剩下旧的 master，新的 master 和新 master 的 worker 在运行，这和当时线上运行的情况类似。
接着我们使用 stop 命令：
```
alex@Fedora26-64: ~/bin_install/nginx
./sbin/nginx -s stop
alex@Fedora26-64: ~/bin_install/nginx
ps auxf | grep nginx
alex 6174 0.0 0.1 28876 1996 ? Ss 14:35 0:00 nginx: master process ./sbin/nginx
alex 6301 0.0 0.2 29364 2124 ? S 14:49 0:00 \\_ nginx: worker process
```
我们会发现，新的 master 和它的 worker 都已经退出，而旧的 master 还在运行，并产生了 worker 出来。这就是当时线上的情况了。
事实上，这个现象和 nginx 自身的设计有关：当旧的 master 准备产生 fork 新的 master 之前，它会把 `nginx.pid` 这个文件重命名为 `nginx.pid.oldbin`，然后再由 fork 出来的新的 master 去创建新的 `nginx.pid`，这个文件将会记录新 master 的 pid。nginx 认为热更新完成之后，旧 master 的使命几乎已经结束，之后它随时会退出，因此之后的操作都应该由新 master 接管。当然，在旧 master 没有退出的情况下通过向新 master 发送 `SIGUSR2` 企图再次热更新是无效的，新 master 只会忽略掉这个信号然后继续它自己的工作。
### 问题分析
更不巧的是，我们上面提到的这个 Lua table，定义它的 Lua 文件早在运行 init\_by\_lua 这个 hook 的时候，就已经被 LuaJIT 加载到内存并编译成字节码了，那么显然旧的 master 必然没有这个 Lua table，因为它加载那部分 Lua 代码是旧版本的。
而索引该 table 的 Lua 代码并没有在 init\_by\_lua 的时候使用到，这些代码都是在 worker 进程里被加载起来的，这时候项目目录里的代码都是最新的，所以 worker 进程加载的都是最新的代码，如果这些 worker 进程处理到相关的请求，就会出现 Lua 运行时错误，外部表现则是对应的 HTTP 500。
吸收了这个教训之后，我们需要更加合理地关闭我们的 nginx 服务。 所以一个更加合理的 nginx 服务启动关闭脚本是必需的，网上流传的一些脚本并没有对这个现象做处理，我们更应该参考 NGINX 官方提供的脚本。
```
stop() {
echo -n $"Stopping $prog: "
killproc $prog -QUIT
retval=$?
echo
[ $retval -eq 0 ] && rm -f $lockfile
return $retval
}
```
这段代码引自 NGINX 官方的 [/etc/init.d/nginx](https://www.nginx.com/resources/wiki/start/topics/examples/redhatnginxinit/) 。
### nginx 信号集
接下来我们来全面梳理下 nginx 信号集，这里不会涉及到源码细节，感兴趣的同学可以自行阅读相关源码。
我们有两种方式来向 master 进程发送信号，一种是通过 `nginx -s signal` 来操作，另一种是通过 kill 命令手动发送。
第一种方式的原理是，产生一个新进程，该进程通过 `nginx.pid` 文件得到 master 进程的 pid，然后把对应的信号发送到 master，之后退出，这种进程被称为 signaller。
第二种方式要求我们了解 `nginx -s signal` 到真实信号的映射。下表是它们的映射关系：
| operation | signal |
| --- | --- |
| reload | SIGHUP |
| reopen | SIGUSR1 |
| stop | SIGTERM |
| quit | SIGQUIT |
| hot update | SIGUSR2 & SIGWINCH & SIGQUIT |
#### stop vs quit
stop 发送 SIGTERM 信号，表示要求强制退出，quit 发送 `SIGQUIT`，表示优雅地退出。 具体区别在于，worker 进程在收到 `SIGQUIT` 消息（注意不是直接发送信号，所以这里用消息替代）后，会关闭监听的套接字，关闭当前空闲的连接（可以被抢占的连接），然后提前处理所有的定时器事件，最后退出。没有特殊情况，都应该使用 quit 而不是 stop。
#### reload
master 进程收到 `SIGHUP` 后，会重新进行配置文件解析、共享内存申请，等一系列其他的工作，然后产生一批新的 worker 进程，最后向旧的 worker 进程发送 `SIGQUIT` 对应的消息，最终无缝实现了重启操作。
#### reopen
master 进程收到 `SIGUSR1` 后，会重新打开所有已经打开的文件（比如日志），然后向每个 worker 进程发送 `SIGUSR1` 信息，worker 进程收到信号后，会执行同样的操作。reopen 可用于日志切割，比如 NGINX 官方就提供了一个方案：
```
$ mv access.log access.log.0
$ kill -USR1 `cat master.nginx.pid`
$ sleep 1
$ gzip access.log.0 # do something with access.log.0
```
这里 `sleep 1` 是必须的，因为在 master 进程向 worker 进程发送 `SIGUSR1` 消息到 worker 进程真正重新打开 `access.log` 之间，有一段时间窗口，此时 worker 进程还是向文件 `access.log.0` 里写入日志的。通过 sleep 1s，保证了 `access.log.0` 日志信息的完整性（如果没有 sleep 而直接进行压缩，很有可能出现日志丢失的情况）。
#### hot update
某些时候我们需要进行二进制热更新，nginx 在设计的时候就包含了这种功能，不过无法通过 nginx 提供的命令行完成，我们需要手动发送信号。
通过上面的问题复现，大家应该已经了解到如何进行热更新了，我们首先需要给当前的 master 进程发送 `SIGUSR2`，之后 master 会重命名 `nginx.pid` 到 `nginx.pid.oldbin`，然后 fork 一个新的进程，新进程会通过 `execve` 这个系统调用，使用新的 nginx ELF 文件替换当前的进程映像，成为新的 master 进程。新 master 进程起来之后，就会进行配置文件解析等操作，然后 fork 出新的 worker 进程开始工作。
接着我们向旧的 master 发送 `SIGWINCH` 信号，然后旧的 master 进程则会向它的 worker 进程发送 `SIGQUIT` 信息，从而使得 worker 进程退出。向 master 进程发送 `SIGWINCH` 和 `SIGQUIT` 都会使得 worker 进程退出，但是前者不会使得 master 进程也退出。
最后，如果我们觉得旧的 master 进程使命完成，就可以向它发送 `SIGQUIT` 信号，让其退出了。
#### worker 进程如何处理来自 master 的信号消息
实际上，master 进程再向 worker 进程通讯，不是使用 kill 函数，而是使用了通过管道实现的 nginx channel，master 进程向管道一端写入信息（比如信号信息），worker 进程则从另外一端收取信息，nginx channel 事件，在 worker 进程刚刚起来的时候，就被加入事件调度器中（比如 epoll，kqueue），所以当有数据从 master 发来时，即可被事件调度器通知到。
nginx 这么设计是有理由的，作为一个优秀的反向代理服务器，nginx 追求的就是极致的高性能，而 signal handler 会中断 worker 进程的运行，使得所有的事件都被暂停一个时间窗口，这对性能是有一定损失的。
很多人可能会认为当 master 进程向 worker 进程发送信息之后，worker 进程立刻会有对应操作回应，然而 worker 进程是非常繁忙的，它不断地处理着网络事件和定时器事件，当调用 nginx channel 事件的 handler 之后，nginx 仅仅只是处理了一些标志位。真正执行这些动作是在一轮事件调度完成之后。所以这之间存在一个时间窗口，尤其是业务复杂且流量巨大的时候，这个窗口就有可能被放大，这也就是为什么 NGINX 官方提供的日志切割方案里要求 sleep 1s 的原因。
当然，我们也可以绕过 master 进程，直接向 worker 进程发送信号，worker 可以处理的信号有
| signal | effect |
| --- | --- |
| SIGINT | 强制退出 |
| SIGTERM | 强制退出 |
| SIGQUIT | 优雅退出 |
| SIGUSR1 | 重新打开文件 |
### 总结
nginx 信号操作在日常运维中是最常见的，也是非常重要的，这个环节如果出现失误则可能造成业务异常，带来损失。所以理清楚 nginx 信号集是非常必要的，能帮助我们更好地处理这些工作。
另外，通过这次的经验教训和对 nginx 信号集的认知，我们认为以下几点是比较重要的：
* 慎用 `nginx -s stop`，尽可能使用 `nginx -s quit`
* 热更新之后，如果确定业务没问题，尽可能让旧的 master 进程退出
* 关键性的信号操作完成后，等待一段时间，避免时间窗口的影响
* 不要直接向 worker 进程发送信号
|
|||
怎么使用 SVG 作为一个图像占位符
|
José M. Pérez
|
https://medium.freecodecamp.org/using-svg-as-placeholders-more-image-loading-techniques-bed1b810ab2c
|
在这篇文章中我们将涉及如下的主题：不同的占位符类型的概述；基于 SVG 的占位符（边缘、形状和轮廓）；自动化处理。
|
/data/attachment/album/201712/13/232720zg4qcuccgx7xcncm.jpg.thumb.jpg
|
/data/attachment/album/201712/13/232720zg4qcuccgx7xcncm.jpg
| true | false | true |
qhwdw
| false |
[
"图像",
"SVG",
"占位符"
] |
软件开发
|
{
"viewnum": 5351,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中我们将涉及如下的主题：不同的占位符类型的概述；基于 SVG 的占位符（边缘、形状和轮廓）；自动化处理。
| 2017-12-13T23:27:00 | 2017-12-13T23:27:00 | 9,142 |
/article-9142-1.html
|
*从图像中生成的 SVG 可以用作占位符。请继续阅读！*
我对怎么去让 web 性能更优化和图像加载的更快充满了热情。在这些感兴趣的领域中的其中一项研究就是占位符：当图像还没有被加载的时候应该去展示些什么？
在前些天，我偶然发现了使用 SVG 的一些加载技术，我将在这篇文章中谈论它。
在这篇文章中我们将涉及如下的主题：
* 不同的占位符类型的概述
* 基于 SVG 的占位符（边缘、形状和轮廓）
* 自动化处理
### 不同的占位符类型的概述
之前 [我写过一篇关于图像占位符和<ruby> 延迟加载 <rt> lazy-loading </rt></ruby>](https://medium.com/@jmperezperez/lazy-loading-images-on-the-web-to-improve-loading-time-and-saving-bandwidth-ec988b710290) 的文章以及 [关于它的讨论](https://www.youtube.com/watch?v=szmVNOnkwoU)。当进行一个图像的延迟加载时，一个很好的办法是提供一个东西作为占位符，因为它可能会很大程度上影响用户的感知体验。之前我提供了几个选择：
在图像被加载之前，有几种办法去填充图像区域：
* 在图像区域保持空白：在一个响应式设计的环境中，这种方式防止了内容的跳跃。从用户体验的角度来看，那些布局的改变是非常差的作法。但是，它是为了性能的考虑，否则，每次为了获取图像尺寸，浏览器就要被迫进行布局重新计算，以便为它留下空间。
* 占位符：在图像那里显示一个用户配置的图像。我们可以在背景上显示一个轮廓。它一直显示直到实际的图像被加载完成，它也被用于当请求失败或者当用户根本没有设置头像图像的情况下。这些图像一般都是矢量图，并且由于尺寸非常小，可以作为内联图片。
* 单一颜色：从图像中获取颜色，并将其作为占位符的背景颜色。这可能是图像的主要颜色、最具活力的颜色 … 这个想法是基于你正在加载的图像，并且它将有助于在没有图像和图像加载完成之间进行平滑过渡。
* 模糊的图像：也被称为模糊技术。你提供一个极小版本的图像，然后再去过渡到完整的图像。最初显示的图像的像素和尺寸是极小的。为去除<ruby> 细节 <rt> artifacts </rt></ruby>，该图像会被放大并模糊化。我在前面写的 [Medium 是怎么做的渐进加载图像](https://medium.com/@jmperezperez/how-medium-does-progressive-image-loading-fd1e4dc1ee3d)、[使用 WebP 去创建极小的预览图像](https://medium.com/@jmperezperez/using-webp-to-create-tiny-preview-images-3e9b924f28d6)、和[渐进加载图像的更多示例](https://medium.com/@jmperezperez/more-examples-of-progressive-image-loading-f258be9f440b) 中讨论过这方面的内容。
此外还有其它的更多的变种，许多聪明的人也开发了其它的创建占位符的技术。
其中一个就是用梯度图代替单一的颜色。梯度图可以创建一个更精确的最终图像的预览，它整体上非常小（提升了有效载荷）。
*使用梯度图作为背景。这是来自 Gradify 的截屏，它现在已经不在线了，代码 [在 GitHub](https://github.com/fraser-hemp/gradify)。*
另外一种技术是使用基于 SVG 的技术，它在最近的实验和研究中取得到了一些进展。
### 基于 SVG 的占位符
我们知道 SVG 是完美的矢量图像。而在大多数情况下我们是希望加载一个位图，所以，问题是怎么去矢量化一个图像。其中一些方法是使用边缘、形状和轮廓。
#### 边缘
在 [前面的文章中](https://medium.com/@jmperezperez/drawing-images-using-edge-detection-and-svg-animation-16a1a3676d3)，我解释了怎么去找出一个图像的边缘并创建一个动画。我最初的目标是去尝试绘制区域，矢量化该图像，但是我并不知道该怎么去做到。我意识到使用边缘也可能是一种创新，我决定去让它们动起来，创建一个 “绘制” 的效果。
* [范例](https://codepen.io/jmperez/embed/oogqdp?default-tabs=html%2Cresult&embed-version=2&height=600&host=https%3A%2F%2Fcodepen.io&referrer=https%3A%2F%2Fmedium.freecodecamp.org%2Fmedia%2F8c5c44a4adf82b09692a34eb4daa3e2e%3FpostId%3Dbed1b810ab2c&slug-hash=oogqdp#result-box)
>
> [使用边缘检测绘制图像和 SVG 动画](https://medium.com/@jmperezperez/drawing-images-using-edge-detection-and-svg-animation-16a1a3676d3)
>
>
> 在以前，很少使用和支持 SVG。一段时间以后，我们开始用它去作为一个某些图标的传统位图的替代品……
>
>
>
#### 形状
SVG 也可以用于根据图像绘制区域而不是边缘/边界。用这种方法，我们可以矢量化一个位图来创建一个占位符。
在以前，我尝试去用三角形做类似的事情。你可以在 [CSSConf](https://jmperezperez.com/cssconfau16/#/45) 和 [Render Conf](https://jmperezperez.com/renderconf17/#/46) 上我的演讲中看到它。
* [范例](https://codepen.io/jmperez/embed/BmaWmQ?default-tabs=html%2Cresult&embed-version=2&height=600&host=https%3A%2F%2Fcodepen.io&referrer=https%3A%2F%2Fmedium.freecodecamp.org%2Fmedia%2F05d1ee44f0537f8257258124d7b94613%3FpostId%3Dbed1b810ab2c&slug-hash=BmaWmQ#result-box)
上面的 codepen 是一个由 245 个三角形组成的基于 SVG 占位符的概念验证。生成的三角形是基于 [Delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation) 的，使用了 [Possan’s polyserver](https://github.com/possan/polyserver)。正如预期的那样，使用更多的三角形，文件尺寸就更大。
#### Primitive 和 SQIP，一个基于 SVG 的 LQIP 技术
Tobias Baldauf 正在致力于另一个使用 SVG 的低质量图像占位符技术，它被称为 [SQIP](https://github.com/technopagan/sqip)。在深入研究 SQIP 之前，我先简单介绍一下 [Primitive](https://github.com/fogleman/primitive)，它是基于 SQIP 的一个库。
Primitive 是非常吸引人的，我强烈建议你去了解一下。它讲解了一个位图怎么变成由重叠形状组成的 SVG。它尺寸比较小，适合于直接内联放置到页面中。当步骤较少时，在初始的 HTML 载荷中作为占位符是非常有意义的。
Primitive 基于三角形、长方形、和圆形等形状生成一个图像。在每一步中它增加一个新形状。很多步之后，图像的结果看起来非常接近原始图像。如果你输出的是 SVG，它意味着输出代码的尺寸将很大。
为了理解 Primitive 是怎么工作的，我通过几个图像来跑一下它。我用 10 个形状和 100 个形状来为这个插画生成 SVG：
| | | |
| --- | --- | --- |
| | | |
| 使用 Primitive 处理 ，使用 [10 个形状](https://jmperezperez.com/assets/images/posts/svg-placeholders/pexels-photo-281184-square-10.svg) 、 [100 形状](https://jmperezperez.com/assets/images/posts/svg-placeholders/pexels-photo-281184-square-100.svg)、 [原图](https://jmperezperez.com/assets/images/posts/svg-placeholders/pexels-photo-281184-square.jpg)。 |
| | | |
| --- | --- | --- |
| | | |
| 使用 Primitive 处理，使用 [10 形状](https://jmperezperez.com/assets/images/posts/svg-placeholders/pexels-photo-618463-square-10.svg) 、 [100 形状](https://jmperezperez.com/assets/images/posts/svg-placeholders/pexels-photo-618463-square-100.svg)、 [原图](https://jmperezperez.com/assets/images/posts/svg-placeholders/pexels-photo-618463-square.jpg) 。 |
当在图像中使用 10 个形状时，我们基本构画出了原始图像。在图像占位符这种使用场景里，我们可以使用这种 SVG 作为潜在的占位符。实际上，使用 10 个形状的 SVG 代码已经很小了，大约是 1030 字节，当通过 SVGO 传输时，它将下降到约 640 字节。
```
<svg xmlns=”http://www.w3.org/2000/svg" width=”1024" height=”1024"><path fill=”#817c70" d=”M0 0h1024v1024H0z”/><g fill-opacity=”.502"><path fill=”#03020f” d=”M178 994l580 92L402–62"/><path fill=”#f2e2ba” d=”M638 894L614 6l472 440"/><path fill=”#fff8be” d=”M-62 854h300L138–62"/><path fill=”#76c2d9" d=”M410–62L154 530–62 38"/><path fill=”#62b4cf” d=”M1086–2L498–30l484 508"/><path fill=”#010412" d=”M430–2l196 52–76 356"/><path fill=”#eb7d3f” d=”M598 594l488–32–308 520"/><path fill=”#080a18" d=”M198 418l32 304 116–448"/><path fill=”#3f201d” d=”M1086 1062l-344–52 248–148"/><path fill=”#ebd29f” d=”M630 658l-60–372 516 320"/></g></svg>
```
正如我们预计的那样，使用 100 个形状生成的图像更大，在 SVGO（之前是 8kB）之后，大小约为 5kB。它们在细节上已经很好了，但是仍然是个很小的载荷。使用多少三角形主要取决于图像类型和细腻程度（如，对比度、颜色数量、复杂度）。
还可以创建一个类似于 [cpeg-dssim](https://github.com/technopagan/cjpeg-dssim) 的脚本，去调整所使用的形状的数量，以满足 [结构相似](https://en.wikipedia.org/wiki/Structural_similarity) 的阈值（或者最差情况中的最大数量）。
这些生成的 SVG 也可以用作背景图像。因为尺寸约束和矢量化，它们在展示<ruby> 超大题图 <rt> hero image </rt></ruby>和大型背景图像时是很好的选择。
#### SQIP
用 [Tobias 自己的话说](https://github.com/technopagan/sqip)：
>
> SQIP 尝试在这两个极端之间找到一种平衡：它使用 [Primitive](https://github.com/fogleman/primitive) 去生成一个 SVG，由几种简单的形状构成，近似于图像中可见的主要特征，使用 [SVGO](https://github.com/svg/svgo) 优化 SVG，并且为它增加高斯模糊滤镜。产生的最终的 SVG 占位符后大小仅为约 800~1000 字节，在屏幕上看起来更为平滑，并提供一个图像内容的视觉提示。
>
>
>
这个结果和使用一个用了模糊技术的极小占位符图像类似。（看看 [Medium](https://medium.com/@jmperezperez/how-medium-does-progressive-image-loading-fd1e4dc1ee3d) 和 [其它站点](https://medium.com/@jmperezperez/more-examples-of-progressive-image-loading-f258be9f440b) 是怎么做的）。区别在于它们使用了一个位图图像，如 JPG 或者 WebP，而这里是使用的占位符是 SVG。
如果我们使用 SQIP 而不是原始图像，我们将得到这样的效果：
| | |
| --- | --- |
| | |
| [第一张图像](https://jmperezperez.com/assets/images/posts/svg-placeholders/pexels-photo-281184-square-sqip.svg) 和 [第二张图像](https://jmperezperez.com/svg-placeholders/%28/assets/images/posts/svg-placeholders/pexels-photo-618463-square-sqip.svg) 使用了 SQIP 后的输出图像。 |
输出的 SVG 约 900 字节，并且通过检查代码，我们可以发现 `feGaussianBlur` 过滤被应用到该组形状上：
```
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 2000 2000"><filter id="b"><feGaussianBlur stdDeviation="12" /></filter><path fill="#817c70" d="M0 0h2000v2000H0z"/><g filter="url(#b)" transform="translate(4 4) scale(7.8125)" fill-opacity=".5"><ellipse fill="#000210" rx="1" ry="1" transform="matrix(50.41098 -3.7951 11.14787 148.07886 107 194.6)"/><ellipse fill="#eee3bb" rx="1" ry="1" transform="matrix(-56.38179 17.684 -24.48514 -78.06584 205 110.1)"/><ellipse fill="#fff4bd" rx="1" ry="1" transform="matrix(35.40604 -5.49219 14.85017 95.73337 16.4 123.6)"/><ellipse fill="#79c7db" cx="21" cy="39" rx="65" ry="65"/><ellipse fill="#0c1320" cx="117" cy="38" rx="34" ry="47"/><ellipse fill="#5cb0cd" rx="1" ry="1" transform="matrix(-39.46201 77.24476 -54.56092 -27.87353 219.2 7.9)"/><path fill="#e57339" d="M271 159l-123–16 43 128z"/><ellipse fill="#47332f" cx="214" cy="237" rx="242" ry="19"/></g></svg>
```
SQIP 也可以输出一个带有 Base64 编码的 SVG 内容的图像标签：
```
<img width="640" height="640" src="example.jpg” alt="Add descriptive alt text" style="background-size: cover; background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAw…<stripped base 64>…PjwvZz48L3N2Zz4=);">
```
#### 轮廓
我们刚才看了使用了边缘和原始形状的 SVG。另外一种矢量化图像的方式是 “描绘” 它们。在几天前 [Mikael Ainalem](https://twitter.com/mikaelainalem) 分享了一个 [codepen](https://codepen.io/ainalem/full/aLKxjm/) 代码，展示了怎么去使用两色轮廓作为一个占位符。结果非常漂亮：
SVG 在这种情况下是手工绘制的，但是，这种技术可以用工具快速生成并自动化处理。
* [Gatsby](https://www.gatsbyjs.org/)，一个用 React 支持的描绘 SVG 的静态网站生成器。它使用 [一个 potrace 算法的 JS 移植](https://www.npmjs.com/package/potrace) 去矢量化图像。
* [Craft 3 CMS](https://craftcms.com/)，它也增加了对轮廓的支持。它使用了 [一个 potrace 算法的 PHP 移植](https://github.com/nystudio107/craft3-imageoptimize/blob/master/src/lib/Potracio.php)。
* [image-trace-loader](https://github.com/EmilTholin/image-trace-loader)，一个使用了 potrace 算法去处理图像的 Webpack 加载器。
如果感兴趣，可以去看一下 Emil 的 webpack 加载器 (基于 potrace) 和 Mikael 的手工绘制 SVG 之间的比较。
这里我假设该输出是使用默认选项的 potrace 生成的。但是可以对它们进行优化。查看 [图像描绘加载器的选项](https://github.com/EmilTholin/image-trace-loader#options)，[传递给 potrace 的选项](https://www.npmjs.com/package/potrace#parameters)非常丰富。
### 总结
我们看到了从图像中生成 SVG 并使用它们作为占位符的各种不同的工具和技术。与 [WebP 是一个用于缩略图的奇妙格式](https://medium.com/@jmperezperez/using-webp-to-create-tiny-preview-images-3e9b924f28d6) 一样，SVG 也是一个用于占位符的有趣格式。我们可以控制细节的级别（和它们的大小），它是高可压缩的，并且很容易用 CSS 和 JS 进行处理。
#### 额外的资源
这篇文章上到了 [Hacker News 热文](https://news.ycombinator.com/item?id=15696596)。对此以及在该页面的评论中分享的其它资源的链接，我表示非常感谢。下面是其中一部分。
* [Geometrize](https://github.com/Tw1ddle/geometrize-haxe) 是用 Haxe 写的 Primitive 的一个移植。也有[一个 JS 实现](https://github.com/Tw1ddle/geometrize-haxe-web)，你可以直接 [在你的浏览器上](http://www.samcodes.co.uk/project/geometrize-haxe-web/)尝试它。
* [Primitive.js](https://github.com/ondras/primitive.js)，它也是 Primitive 在 JS 中的一个移植，[primitive.nextgen](https://github.com/cielito-lindo-productions/primitive.nextgen)，它是使用 Primitive.js 和 Electron 的 Primitive 的桌面版应用的一个移植。
* 这里有两个 Twitter 帐户，里面你可以看到一些用 Primitive 和 Geometrize 生成的图像示例。访问 [@PrimitivePic](https://twitter.com/PrimitivePic) 和 [@Geometrizer](https://twitter.com/Geometrizer)。
* [imagetracerjs](https://github.com/jankovicsandras/imagetracerjs)，它是在 JavaScript 中的光栅图像描绘器和矢量化程序。这里也有为 [Java](https://github.com/jankovicsandras/imagetracerjava) 和 [Android](https://github.com/jankovicsandras/imagetracerandroid) 提供的移植。
---
via: <https://medium.freecodecamp.org/using-svg-as-placeholders-more-image-loading-techniques-bed1b810ab2c>
作者：[José M. Pérez](https://medium.freecodecamp.org/@jmperezperez?source=post_header_lockup) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
什么是僵尸进程，如何找到并杀掉僵尸进程？
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/what-are-zombie-processes-and-how-to-find-kill-zombie-processes
|
如果你经常使用 Linux，你应该遇到这个术语“僵尸进程”。 那么什么是僵尸进程？ 它们是怎么产生的？ 它们是否对系统有害？ 我要怎样杀掉这些进程？ 下面将会回答这些问题。
|
/data/attachment/album/201712/14/223009uhhlhmbcjhwc7umb.jpg.thumb.jpg
|
/data/attachment/album/201712/14/223009uhhlhmbcjhwc7umb.jpg
| true | false | true |
lujun9972
| false |
[
"进程",
"僵尸进程"
] |
技术
|
{
"viewnum": 12638,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
如果你经常使用 Linux，你应该遇到这个术语“僵尸进程”。 那么什么是僵尸进程？ 它们是怎么产生的？ 它们是否对系统有害？ 我要怎样杀掉这些进程？ 下面将会回答这些问题。
| 2017-12-14T22:30:19 | 2017-12-14T22:30:19 | 9,143 |
/article-9143-1.html
|
如果你经常使用 Linux，你应该遇到这个术语“<ruby> 僵尸进程 <rt> Zombie Processes </rt></ruby>”。 那么什么是僵尸进程？ 它们是怎么产生的？ 它们是否对系统有害？ 我要怎样杀掉这些进程？ 下面将会回答这些问题。
### 什么是僵尸进程？
我们都知道进程的工作原理。我们启动一个程序，开始我们的任务，然后等任务结束了，我们就停止这个进程。 进程停止后， 该进程就会从进程表中移除。
你可以通过 `System-Monitor` 查看当前进程。
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/linux-check-zombie-processes_orig.jpg)
但是，有时候有些程序即使执行完了也依然留在进程表中。
那么，这些完成了生命周期但却依然留在进程表中的进程，我们称之为 “僵尸进程”。
### 它们是如何产生的？
当你运行一个程序时，它会产生一个父进程以及很多子进程。 所有这些子进程都会消耗内核分配给它们的内存和 CPU 资源。
这些子进程完成执行后会发送一个 Exit 信号然后死掉。这个 Exit 信号需要被父进程所读取。父进程需要随后调用 `wait` 命令来读取子进程的退出状态，并将子进程从进程表中移除。
若父进程正确第读取了子进程的 Exit 信号，则子进程会从进程表中删掉。
但若父进程未能读取到子进程的 Exit 信号，则这个子进程虽然完成执行处于死亡的状态，但也不会从进程表中删掉。
### 僵尸进程对系统有害吗？
**不会**。由于僵尸进程并不做任何事情， 不会使用任何资源也不会影响其它进程， 因此存在僵尸进程也没什么坏处。 不过由于进程表中的退出状态以及其它一些进程信息也是存储在内存中的，因此存在太多僵尸进程有时也会是一些问题。
**你可以想象成这样：**
“你是一家建筑公司的老板。你每天根据工人们的工作量来支付工资。 有一个工人每天来到施工现场，就坐在那里， 你不用付钱， 他也不做任何工作。 他只是每天都来然后呆坐在那，仅此而已！”
这个工人就是僵尸进程的一个活生生的例子。**但是**， 如果你有很多僵尸工人， 你的建设工地就会很拥堵从而让那些正常的工人难以工作。
### 那么如何找出僵尸进程呢？
打开终端并输入下面命令:
```
ps aux | grep Z
```
会列出进程表中所有僵尸进程的详细内容。
### 如何杀掉僵尸进程？
正常情况下我们可以用 `SIGKILL` 信号来杀死进程，但是僵尸进程已经死了， 你不能杀死已经死掉的东西。 因此你需要输入的命令应该是
```
kill -s SIGCHLD pid
```
将这里的 pid 替换成父进程的进程 id，这样父进程就会删除所有以及完成并死掉的子进程了。
**你可以把它想象成：**
"你在道路中间发现一具尸体，于是你联系了死者的家属，随后他们就会将尸体带离道路了。"
不过许多程序写的不是那么好，无法删掉这些子僵尸（否则你一开始也见不到这些僵尸了）。 因此确保删除子僵尸的唯一方法就是杀掉它们的父进程。
---
via: <http://www.linuxandubuntu.com/home/what-are-zombie-processes-and-how-to-find-kill-zombie-processes>
作者：[linuxandubuntu](http://www.linuxandubuntu.com) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 VirtualBox 创建 Vagrant Boxes 的完全指南
|
Shusain
|
http://linuxtechlab.com/creating-vagrant-virtual-boxes-virtualbox/
|
Vagrant 是一个用来创建和管理虚拟机环境的工具，常用于建设开发环境。 它在 Docker、VirtualBox、Hyper-V、Vmware、AWS 等技术的基础上构建了一个易于使用且易于复制、重建的环境。
|
/data/attachment/album/201712/15/112020pvqkrg6o6v55zyvv.jpg.thumb.jpg
|
/data/attachment/album/201712/15/112020pvqkrg6o6v55zyvv.jpg
| true | false | true |
lujun9972
| false |
[
"Vagrant",
"VirtualBox"
] |
技术
|
{
"viewnum": 6065,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Vagrant 是一个用来创建和管理虚拟机环境的工具，常用于建设开发环境。 它在 Docker、VirtualBox、Hyper-V、Vmware、AWS 等技术的基础上构建了一个易于使用且易于复制、重建的环境。
| 2017-12-15T11:20:23 | 2017-12-15T11:20:23 | 9,144 |
/article-9144-1.html
|
Vagrant 是一个用来创建和管理虚拟机环境的工具，常用于建设开发环境。 它在 Docker、VirtualBox、Hyper-V、Vmware、AWS 等技术的基础上构建了一个易于使用且易于复制、重建的环境。
Vagrant Boxes 简化了软件配置部分的工作，并且完全解决了软件开发项目中经常遇到的“它能在我机器上工作”的问题，从而提高开发效率。
在本文中，我们会在 Linux 机器上学习使用 VirtualBox 来配置 Vagrant Boxes。
### 前置条件
Vagrant 是基于虚拟化环境运行的，这里我们使用 VirtualBox 来提供虚拟化环境。 关于如何安装 VirutalBox 我们在“[在 Linux 上安装 VirtualBox](http://linuxtechlab.com/installing-virtualbox-on-linux-centos-ubuntu/)” 中有详细描述，请阅读该文并安装 VirtualBox。
安装好 VirtualBox 后，下一步就是配置 Vagrant 了。
* 推荐阅读：[创建你的 Docker 容器](http://linuxtechlab.com/create-first-docker-container-beginners-guide/)
### 安装
VirtualBox 准备好后，我们来安装最新的 vagrant 包。 在写本文的时刻， Vagrant 的最新版本为 2.0.0。 使用下面命令下载最新的 rpm 文件：
```
$ wget https://releases.hashicorp.com/vagrant/2.0.0/vagrant_2.0.0_x86_64.rpm
```
然后安装这个包:
```
$ sudo yum install vagrant_2.0.0_x86_64.rpm
```
如果是 Ubuntu，用下面这个命令来下载最新的 vagrant 包：
```
$ wget https://releases.hashicorp.com/vagrant/2.0.0/vagrant_2.0.0_x86_64.deb
```
然后安装它，
```
$ sudo dpkg -i vagrant_2.0.0_x86_64.deb
```
安装结束后，就该进入配置环节了。
### 配置
首先，我们需要创建一个目录给 vagrant 来安装我们需要的操作系统，
```
$ mkdir /home/dan
$ cd /home/dan/vagrant
```
**注意：** 推荐在你的用户主目录下创建 vagrant，否则你可能会遇到本地用户相关的权限问题。
现在执行下面命令来安装操作系统，比如 CentOS：
```
$ sudo vagrant init centos/7
```
如果要安装 Ubuntu 则运行：
```
$ sudo vagrant init ubuntu/trusty64
```
这还会在存放 vagrant OS 的目录中创建一个叫做 `Vagrantfile` 的配置文件。它包含了一些关于操作系统、私有 IP 网络、转发端口、主机名等信息。 若我们需要创建一个新的操作系统， 也可以编辑这个问题。
一旦我们用 vagrant 创建/修改了操作系统，我们可以用下面命令启动它:
```
$ sudo vagrant up
```
这可能要花一些时间，因为这条命令要构建操作系统，它需要从网络上下载所需的文件。 因此根据互联网的速度， 这个过程可能会比较耗时。
这个过程完成后，你就可以使用下面这些命令来管理 vagrant 实例了。
启动 vagrant 服务器：
```
$ sudo vagrant up
```
关闭服务器：
```
$ sudo vagrant halt
```
完全删除服务器：
```
$ sudo vagrant destroy
```
使用 ssh 访问服务器：
```
$ sudo vagrant ssh
```
我们可以从 Vagrant Box 的启动过程中得到 ssh 的详细信息（参见上面的截屏）。
如果想看创建的 vagrant OS，可以打开 VirtualBox，然后你就能在 VirtualBox 创建的虚拟机中找到它了。 如果在 VirtualBox 中没有找到， 使用 `sudo` 权限打开 virtualbox， 然后应该就能看到了。
**注意：** 在 [Vagrant 官方网站](https://app.vagrantup.com/boxes/search)上可以下载预先配置好的 Vagrant OS。
这就是本文的内容了。如有疑问请在下方留言，我们会尽快回复。
---
via: <http://linuxtechlab.com/creating-vagrant-virtual-boxes-virtualbox/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
介绍 GitHub 上的安全警报
|
Mijuhan
|
https://github.com/blog/2470-introducing-security-alerts-on-github
|
在启用依赖关系图后，当我们检测到你的依赖中有漏洞时会通知你，并给出来自 Github 社区中的已知修复。
|
/data/attachment/album/201712/15/113211q1w7w0p4rs7t07ij.jpg.thumb.jpg
|
/data/attachment/album/201712/15/113211q1w7w0p4rs7t07ij.jpg
| true | false | true |
geekpi
| false |
[
"GitHub",
"安全",
"依赖"
] |
技术
|
{
"viewnum": 4737,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在启用依赖关系图后，当我们检测到你的依赖中有漏洞时会通知你，并给出来自 Github 社区中的已知修复。
| 2017-12-15T11:32:20 | 2017-12-15T11:32:20 | 9,145 |
/article-9145-1.html
|
上个月，我们用依赖关系图让你更容易跟踪你代码依赖的的项目，它目前支持 Javascript 和 Ruby。如今，超过 75％ 的 GitHub 项目有依赖，我们正在帮助你做更多的事情，而不只是关注那些重要的项目。在启用依赖关系图后，当我们检测到你的依赖中有漏洞时会通知你，并给出来自 Github 社区中的已知修复。
[](https://user-images.githubusercontent.com/594029/32851987-76c36e4a-c9eb-11e7-98fc-feb39fddaadb.gif)
### 如何开始使用安全警报
无论你的项目时私有还是公有的，安全警报都会为团队中的正确人员提供重要的漏洞信息。
**启用你的依赖图：**
公开仓库将自动启用依赖关系图和安全警报。对于私人仓库，你需要在仓库设置中添加安全警报，或者在 “Insights” 选项卡中允许访问仓库的 “依赖关系图” 部分。
**设置通知选项：**
启用依赖关系图后，管理员将默认收到安全警报。管理员还可以在依赖关系图设置中将团队或个人添加为安全警报的收件人。
**警报响应：**
当我们通知你潜在的漏洞时，我们将突出显示我们建议更新的任何依赖关系。如果存在已知的安全版本，我们将通过机器学习和公开数据选择一个，并将其包含在我们的建议中。
### 漏洞覆盖率
有 [CVE ID](https://cve.mitre.org/)（[国家漏洞数据库](https://nvd.nist.gov/)公开披露的漏洞）的漏洞将包含在安全警报中。但是，并非所有漏洞都有 CVE ID，甚至许多公开披露的漏洞也没有。随着安全数据的增长，我们将继续更好地识别漏洞。如需更多帮助来管理安全问题，请查看我们的 [GitHub Marketplace 中的安全合作伙伴](https://github.com/marketplace/category/security)。
这是使用世界上最大的开源数据集的下一步，可以帮助你保持代码安全并做到最好。依赖关系图和安全警报目前支持 JavaScript 和 Ruby，并将在 2018 年提供 Python 支持。
* [了解更多关于安全警报](https://help.github.com/articles/about-security-alerts-for-vulnerable-dependencies/)
---
via: <https://github.com/blog/2470-introducing-security-alerts-on-github>
作者：[mijuhan](https://github.com/mijuhan) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
更多你所不知道的 Linux 命令
|
Carla Schroder
|
https://www.linux.com/learn/intro-to-linux/2017/4/more-unknown-linux-commands
|
本文是一篇关于一些有趣但鲜为人知的工具 termsaver、pv 和 calendar 的文章。
|
/data/attachment/album/201712/15/115543pk3buly2bie2k4qe.jpg.thumb.jpg
|
/data/attachment/album/201712/15/115543pk3buly2bie2k4qe.jpg
| true | false | true |
ucasFL
| false |
[
"termsaver",
"pv",
"calendar"
] |
技术
|
{
"viewnum": 7073,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文是一篇关于一些有趣但鲜为人知的工具 termsaver、pv 和 calendar 的文章。
| 2017-12-15T11:55:40 | 2017-12-15T11:55:40 | 9,146 |
/article-9146-1.html
|
>
> 在这篇文章中和 Carla Schroder 一起探索 Linux 中的一些鲜为人知的强大工具。
>
>
>
本文是一篇关于一些有趣但鲜为人知的工具 `termsaver`、`pv` 和 `calendar` 的文章。`termsaver` 是一个终端 ASCII 屏保，`pv` 能够测量数据吞吐量并模拟输入。Debian 的 `calendar` 拥有许多不同的日历，并且你还可以制定你自己的日历。
### 终端屏保
难道只有图形桌面能够拥有有趣的屏保吗？现在，你可以通过安装 `termsaver` 来享受 ASCII 屏保，比如 matrix（LCTT 译注：电影《黑客帝国》中出现的黑客屏保）、时钟、星球大战以及两个<ruby> 不太安全 <rt> not-safe-for-work </rt></ruby>（NSFW）的屏保。 NSFW 屏保还有很多。
`termsaver` 可以从 Debian/Ubuntu 的包管理器中直接下载安装，如果你使用别的不包含该软件包的发行版比如 CentOS，那么你可以从 [termsaver.brunobraga.net](http://termsaver.brunobraga.net/) 下载，然后按照安装指导进行安装。
运行 `termsaver -h` 来查看一系列屏保：
```
randtxt displays word in random places on screen
starwars runs the asciimation Star Wars movie
urlfetcher displays url contents with typing animation
quotes4all displays recent quotes from quotes4all.net
rssfeed displays rss feed information
matrix displays a matrix movie alike screensaver
clock displays a digital clock on screen
rfc randomly displays RFC contents
jokes4all displays recent jokes from jokes4all.net (NSFW)
asciiartfarts displays ascii images from asciiartfarts.com (NSFW)
programmer displays source code in typing animation
sysmon displays a graphical system monitor
```
*图片 1： 星球大战屏保。*
你可以通过运行命令 `termsaver [屏保名]` 来使用屏保，比如 `termsaver matrix` ，然后按 `Ctrl+c` 停止。你也可以通过运行 `termsaver [屏保名] -h` 命令来获取关于某一个特定屏保的信息。图片 1 来自 `startwars` 屏保，它运行的是古老但受人喜爱的 [Asciimation Wars](http://www.asciimation.co.nz/) 。
那些不太安全（NSFW）的屏保通过在线获取资源的方式运行，我并不喜欢它们，但好消息是，由于 `termsaver` 是一些 Python 脚本文件，因此，你可以很容易的利用它们连接到任何你想要的 RSS 资源。
### pv
`pv` 命令是一个非常有趣的小工具但却很实用。它的用途是监测数据复制的过程，比如，当你运行 `rsync` 命令或创建一个 `tar` 归档的时候。当你不带任何选项运行 `pv` 命令时，默认参数为：
* -p ：进程
* -t ：时间，到当前总运行时间
* -e ：预计完成时间，这往往是不准确的，因为 `pv` 通常不知道需要移动的数据的大小
* -r ：速率计数器，或吞吐量
* -b ：字节计数器
一次 `rsync` 传输看起来像这样：
```
$ rsync -av /home/carla/ /media/carla/backup/ | pv
sending incremental file list
[...]
103GiB 0:02:48 [ 615MiB/s] [ <=>
```
创建一个 tar 归档，就像下面这个例子：
```
$ tar -czf - /file/path| (pv > backup.tgz)
885MiB 0:00:30 [28.6MiB/s] [ <=>
```
`pv` 能够监测进程，因此也可以监测 Web 浏览器的最大活动，令人惊讶的是，它产生了如此多的活动：
```
$ pv -d 3095
58:/home/carla/.pki/nssdb/key4.db: 0 B 0:00:33
[ 0 B/s] [<=> ]
78:/home/carla/.config/chromium/Default/Visited Links:
256KiB 0:00:33 [ 0 B/s] [<=> ]
]
85:/home/carla/.con...romium/Default/data_reduction_proxy_leveldb/LOG:
298 B 0:00:33 [ 0 B/s] [<=> ]
```
在网上，我偶然发现一个使用 `pv` 最有趣的方式：使用 `pv` 来回显输入的内容：
```
$ echo "typing random stuff to pipe through pv" | pv -qL 8
typing random stuff to pipe through pv
```
普通的 `echo` 命令会瞬间打印一整行内容。通过管道传给 `pv` 之后能够让内容像是重新输入一样的显示出来。我不知道这是否有实际的价值，但是我非常喜欢它。`-L` 选项控制回显的速度，即多少字节每秒。
`pv` 是一个非常古老且非常有趣的命令，这么多年以来，它拥有了许多的选项，包括有趣的格式化选项，多种输出选项，以及传输速度修改器。你可以通过 `man pv` 来查看所有的选项。
### /usr/bin/calendar
通过浏览 `/usr/bin` 目录以及其他命令目录和阅读 man 手册，你能够学到很多东西。在 Debian/Ubuntu 上的 `/usr/bin/calendar` 是 BSD 日历的一个变种，但它漏掉了月亮历和太阳历。它保留了多个日历包括 `calendar.computer, calendar.discordian, calendar.music` 以及 `calendar.lotr`。在我的系统上，man 手册列出了 `/usr/bin/calendar` 里存在的不同日历。下面这个例子展示了指环王日历接下来的 60 天：
```
$ calendar -f /usr/share/calendar/calendar.lotr -A 60
Apr 17 An unexpected party
Apr 23 Crowning of King Ellesar
May 19 Arwen leaves Lorian to wed King Ellesar
Jun 11 Sauron attacks Osgilliath
```
这些日历是纯文本文件，因此，你可以轻松的创建你自己的日历。最简单的方式就是复制已经存在的日历文件的格式。你可以通过 `man calendar` 命令来查看创建个人日历文件的更详细的指导。
又一次很快走到了尽头。你可以花费一些时间来浏览你的文件系统，挖掘更多有趣的命令。
*你可以通过来自 Linux 基金会和 edx 的免费课程 ["Introduction to Linux"](https://training.linuxfoundation.org/linux-courses/system-administration-training/introduction-to-linux) 来学习更过关于 Linux 的知识*。
（题图：[CC Zero](https://www.linux.com/licenses/category/creative-commons-zero) Pixabay）
---
via: <https://www.linux.com/learn/intro-to-linux/2017/4/more-unknown-linux-commands>
作者：[CARLA SCHRODER](https://www.linux.com/users/cschroder) 译者：[ucasFL](https://github.com/ucasFL) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
有人试图挽救 Ubuntu Unity ，将其做为官方分支
|
Marius Nestor
|
http://news.softpedia.com/news/someone-tries-to-bring-back-ubuntu-s-unity-from-the-dead-as-an-unofficial-spin-518778.shtml
|
你会对 Ubuntu Unity Spin 感兴趣么，官方或者非官方？
|
/data/attachment/album/201712/15/141555ytknhx1k3oze1len.jpg.thumb.jpg
|
/data/attachment/album/201712/15/141555ytknhx1k3oze1len.jpg
| true | false | true |
geekpi
| false |
[
"Unity"
] |
新闻
|
{
"viewnum": 4998,
"commentnum": 2,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "101.81.57.144",
"message": "这个桌面环境审美不行",
"username": "mistyos [Firefox 58.0|Windows 10]",
"date": "2017-12-15T15:18:00"
},
{
"postip": "14.104.204.191",
"message": "Ubuntu Unity 界面就是反人类的设计.",
"username": "来自重庆的 Sogou Explorer 2|Windows 7 用户",
"date": "2019-08-10T10:08:28"
}
] |
[] |
你会对 Ubuntu Unity Spin 感兴趣么，官方或者非官方？
| 2017-12-15T14:15:52 | 2017-12-15T14:15:52 | 9,147 |
/article-9147-1.html
|
>
> Ubuntu Unity Remix 将支持九个月。
>
>
>
Canonical 在七年之后突然决定抛弃它的 Unity 用户界面影响了许多 Ubuntu 用户，现在看起来有人试图把它从死亡中带回来，成为官方<ruby> 分支 <rt> spin </rt></ruby>。
长期 [Ubuntu](http://linux.softpedia.com/downloadTag/Ubuntu) 成员 Dale Beaudoin 上周在官方的 Ubuntu 论坛上[进行了一项调查](https://community.ubuntu.com/t/poll-unity-7-distro-9-month-spin-or-lts-for-18-04/2066)来了解社区意向，看看他们是否对随同明年的 Ubuntu 18.04 LTS（Bionic Beaver）一起发布的 Ubuntu Unity Remix 感兴趣，它将支持 9 个月或 5 年。
有 30 人进行了投票，其中 67％ 的人选择了所谓的 Ubuntu Unity Remix 的 LTS（长期支持）版本，33％ 的人投票支持 9 个月的支持版本。看起来这个即将到来的 Ubuntu Unity Spin [看起来会成为官方特色版本](https://community.ubuntu.com/t/unity-maintenance-roadmap/2223)，而这意味着开发它的承诺。
Dale Beaudoin 表示：“最近的一项民意调查显示，2/3 的人支持 Ubuntu Unity 成为 LTS 发行版，我们应该按照它成为 LTS 和官方特色版的更新周期去努力。我们将尝试使用当前默认的 Ubuntu Bionic Beaver 18.04 的每日构建版本作为平台，每周或每 10 天发布一次更新的 ISO。”
### Ubuntu Unity 是否会卷土重来？
正常情况下，最后一个带有 Unity 的 Ubuntu 版本应该是 Ubuntu 17.04（Zesty Zapus），它将在 2018 年 1 月终止支持。当前流行操作系统的稳定版本 Ubuntu 17.10（Artful Artful），是今年早些时候 Canonical CEO [宣布](http://news.softpedia.com/news/canonical-to-stop-developing-unity-8-ubuntu-18-04-lts-ships-with-gnome-desktop-514604.shtml)之后第一个默认使用 GNOME 桌面环境的版本，Unity 将不再开发。
然而，Canonical 仍然在官方软件仓库提供 Unity 桌面环境，所以如果有人想要安装它，只需点击一下即可。但坏消息是，它们支持到 2018 年 4 月发布 Ubuntu 18.04 LTS（Bionic Beaver）之前，所以 Ubuntu Unity Remix 的开发者们将不得不在独立的仓库中继续支持。
另一方面，我们不相信 Canonical 会改变主意，接受这个 Ubuntu Unity Spin 成为官方的特色版，这意味着他们不会继续开发 Unity，现在只有一小部分人可以做这个开发。最有可能的是，如果对 Ubuntu Unity Remix 的兴趣没有很快消失，那么，这可能会是一个由怀旧社区支持的非官方版本。
问题是，你会对 Ubuntu Unity Spin 感兴趣么，官方或者非官方？
---
via: <http://news.softpedia.com/news/someone-tries-to-bring-back-ubuntu-s-unity-from-the-dead-as-an-unofficial-spin-518778.shtml>
作者：[Marius Nestor](http://news.softpedia.com/editors/browse/marius-nestor) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
因为这个我要点名批评 Hacker News
|
Benjamin Pollack
|
https://bitquabit.com/post/one-which-i-call-out-hacker-news/
|
指责开源软件总是离奇难用已经不是一个新论点了；这样的论点之前就被很多比我更为雄辩的人提及过，甚至是出自一些人非常推崇开源软件的人士口中。那么为什么我要在这里老调重弹呢？
|
/data/attachment/album/201712/16/000842naa44ssa740ab65r.jpg.thumb.jpg
|
/data/attachment/album/201712/16/000842naa44ssa740ab65r.jpg
| true | false | true |
hopefully2333,yunfengHe
| false |
[
"开源软件"
] |
观点
|
{
"viewnum": 4560,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
指责开源软件总是离奇难用已经不是一个新论点了；这样的论点之前就被很多比我更为雄辩的人提及过，甚至是出自一些人非常推崇开源软件的人士口中。那么为什么我要在这里老调重弹呢？
| 2017-12-16T00:08:49 | 2017-12-16T00:08:49 | 9,148 |
/article-9148-1.html
|
>
> “实现高速缓存会花费 30 个小时，你有额外的 30 个小时吗？ 不，你没有。我实际上并不知道它会花多少时间，可能它会花五分钟，你有五分钟吗？不，你还是没有。为什么？因为我在撒谎。它会消耗远超五分钟的时间。这一切把问题简单化的假设都只不过是程序员单方面的乐观主义。”
>
>
> — 出自 [Owen Astrachan](http://www.cs.duke.edu/%7Eola/) 教授于 2004 年 2 月 23 日在 [CPS 108](http://www.cs.duke.edu/courses/cps108/spring04/) 上的讲座
>
>
>
[指责开源软件总是离奇难用已经不是一个新论点了](http://blog.bitquabit.com/2009/06/30/one-which-i-say-open-source-software-sucks/)；这样的论点之前就被很多比我更为雄辩的人提及过，甚至是出自一些人非常推崇开源软件的人士口中。那么为什么我要在这里老调重弹呢？
在周一的 Hacker News 期刊上，一段文章把我逗乐了。文章谈到，一些人认为 [编写代码实现和一个跟 StackOverflow 一样的系统可以简单到爆](http://news.ycombinator.com/item?id=678501)，并自信的 [声称他们可以在 7 月 4 号的周末就写出一版和 StackOverflow 原版一模一样的程序](http://news.ycombinator.com/item?id=678704)，以此来证明这一切是多么容易。另一些人则插话说，[现有的](http://code.google.com/p/cnprog/)[那些仿制产品](http://code.google.com/p/soclone/) 就已经是一个很好的例证了。
秉承着自由讨论的精神，我们来假设一个场景。你在思考了一阵之后认为你可以用 ASP.NET MVC 来编写一套你自己的 StackOverflow 。我呢，在被一块儿摇晃着的怀表催眠之后，脑袋又挨了别人一顿棒槌，然后像个二哈一样一页一页的把 StackOverflow 的源码递给你，让你照原样重新拿键盘逐字逐句的在你的环境下把那些代码再敲一遍，做成你的 StackOverflow。假设你可以像我一样打字飞快，一分钟能敲 100 个词 ([也就是大约每秒敲八个字母](http://en.wikipedia.org/wiki/Words_per_minute))，但是却可以牛叉到我无法企及的打字零错误率。从 StackOverflow 的大小共计 2.3MB 的源码来估计（包括 .CS、 .SQL、 .CSS、 .JS 和 .aspx 文件），就单单是照着源代码这么飞速敲一遍而且一气呵成中间一个字母都不错，你也要差不多用掉至少 80 个小时的时间。
或者你打算从零开始编码实现你自己的 StackOverflow，虽然我知道你肯定是不会那样做的。我们假设你从设计程序，到敲代码，再到最终完成调试只需要区区十倍于抄袭 StackOverflow 源代码的时间。即使在这样的假设条件下，你也要耗费几周的时间昼夜不停得狂写代码。不知道你是否愿意，但是至少我可以欣然承认，如果只给我照抄 StackOverflow 源代码用时的十倍时间来让我自己写 StackOverflow，我可是打死也做不到。
*好的*，我知道你在听到这些假设的时候已经开始觉得泄气了。*你在想，如果不是全部实现，而只是实现 StackOverflow **大部分** 的功能呢？这总归会容易很多了吧。*
好的，问题是什么是 “大部分” 功能？如果只去实现提问和回答问题的功能？这个部分应该很简单吧。其实不然，因为实现问和答的功能还要求你必须做出一个对问题及其答案的投票系统，来显示大家对某个答案是赞同还是反对。因为只有这样你才能保证提问者可以得到这个问题的唯一的可信答案。当然，你还不能让人们赞同或者反对他们自己给出的答案，所以你还要去实现这种禁止自投自票的机制。除此之外，你需要去确保用户在一定的时间内不能赞同或反对其他用户太多次，以此来防止有人用机器人程序作弊乱投票。你很可能还需要去实现一个垃圾评论过滤器，即使这个过滤器很基础很简陋，你也要考虑如何去设计它。而且你恐怕还需要去支持用户图标（头像）的功能。并且你将不得不寻找一个自己真正信任的并且与 Markdown 结合很好的干净的 HTML 库（当然，假设你确实想要复用 StackOverflow 的 [那个超棒的编辑器](http://github.com/derobins/wmd/tree/master) ）。你还需要为所有控件购买或者设计一些小图标、小部件，此外你至少需要实现一个基本的管理界面，以便那些喜欢捣鼓的用户可以调整和改动他们的个性化设置。并且你需要实现类似于 Karma 的声望累积系统，以便用户可以随着不断地使用来稳步提升他们的话语权和解锁更多的功能以及可操作性。
但是如果你实现了以上*所有*功能，可以说你*就已经*把要做的都做完了。
除非……除非你还要做全文检索功能。尤其是在“边问边搜”（动态检索）的特性中，支持全文检索是必不可少的。此外，录入和显示用户的基本信息，实现对问题答案的评论功能，以及实现一个显示热点提问的页面，以及热点问题和帖子随着时间推移沉下去的这些功能，都将是不可或缺的。另外你肯定还需要去实现回答奖励系统，并支持每个用户用多个不同的 OpenID 账户去登录，然后将这些相关的登录事件通过邮件发送出去来通知用户，并添加一个标签或徽章系统，接着允许管理员通过一个不错的图形界面来配置这些标签和<ruby> 徽章 <rt> Badge </rt></ruby>。你需要去显示用户的 Karma 历史，以及他们的历史点赞和差评。而且整个页面还需要很流畅的展开和拉伸，因为这个系统的页面随时都可能被 Slashdot、Reddit 或是 StackOverflow 这些动作影响到。
在这之后！你会以为你基本已经大功告成了！
……为了产品的完整性，在上面所述的工作都完成之后，你又奋不顾身的去实现了升级功能，界面语言的国际化，Karma 值上限，以及让网站更专业的 CSS 设计、AJAX，还有那些看起来理所当然做起来却让人吐血的功能和特性。如果你不是真的动手来尝试做一个和 StackOverflow 一模一样的系统，你肯定不会意识到在整个程序设计实施的过程中，你会踩到无数的鬼才会知道的大坑。
那么请你告诉我：如果你要做一个让人满意的类似产品出来，上述的哪一个功能是你可以省略掉的呢？哪些是“大部分”网站都具备的功能，哪些又不是呢？
正因为这些很容易被忽视的问题，开发者才会以为做一个 StackOverflow 的仿制版产品会很简单。也同样是因为这些被忽视了的因素，开源软件才一直让人用起来很痛苦。很多软件开发人员在看到 StackOverflow 的时候，他们并不能察觉到 StackOverflow 产品的全貌。他们会简单的把 Stackoverflow 的实现抽象成下面一段逻辑和代码:
```
create table QUESTION (ID identity primary key,
TITLE varchar(255), --- 为什么我知道你认为是 255
BODY text,
UPVOTES integer not null default 0,
DOWNVOTES integer not null default 0,
USER integer references USER(ID));
create table RESPONSE (ID identity primary key,
BODY text,
UPVOTES integer not null default 0,
DOWNVOTES integer not null default 0,
QUESTION integer references QUESTION(ID))
```
如果你让这些开发者去实现 StackOverflow，进入他脑海中的就是上面的两个 SQL 表和一个用以呈现表格数据的 HTML 文件。他们甚至会忽略数据的格式问题，进而单纯的以为他们可以在一个周末的时间里就把 StackOverflow 做出来。一些稍微老练的开发者可能会意识到他们还要去实现登录和注销功能、评论功能、投票系统，但是仍然会自信的认为这不过也就是利用一个周末就能完成了；因为这些功能也不过意味着在后端多了几张 SQL 表和 HTML 文件。如果借助于 Django 之类的构架和工具，他们甚至可以直接拿来主义地不花一分钱就实现用户登录和评论的功能。
但这种简单的实现却*远远不能*体现出 StackOverflow 的精髓。无论你对 StackOverflow 的感觉如何，大多数使用者似乎都同意 StackOverflow 的用户体验从头到尾都很流畅。使用 StackOverflow 的过程就是在跟一个精心打磨过的产品在愉快地交互。即使我没有深入了解过 StackOverflow ，我也能猜测出这个产品的成功和它的数据库的 Schema 没有多大关系 —— 实际上在有幸研读过 StackOverflow 的源码之后，我得以印证了自己的想法，StackOverflow 的成功确实和它的数据库设计关系甚小。真正让它成为一个极其易用的网站的原因，是它背后*大量的*精雕细琢的设计和实施。多数的开发人员在谈及仿制和克隆一款产品的难度时，真的*很少会去考虑到产品背后的打磨和雕琢工作*，因为他们认为*这些打磨和雕琢都是偶然的，甚至是无足轻重的。*
这就是为什么用开源工具去克隆和山寨 StackOverflow 其实是很容易失败的。即使这些开源开发者只是想去实现 StackOverflow 的主要的“规范和标准特性”，而非全面的高级特性，他们也会在实现的过程中遭遇种种关键和核心的问题，让他们阴沟翻船，半途而废。拿徽章功能来说，如果你要针对普通终端用户来设计徽章， 则要么需要实现一个用户可用来个性化设置徽章的 GUI，要么则取巧的设计出一个比较通用的徽章，供所有的安装版本来使用。而开源设计的实际情况是，开发者会有很多的抱怨和牢骚，认为给徽章这种东西设计一个功能全面的 GUI 是根本不可能的。而且他们会固执地把任何标准徽章的提案踢回去，踢出第一宇宙速度，击穿地壳甩到地球的另一端。最终这些开发者还是会搞出一个类似于 Roundup 的 bug tracker 程序都在使用的流程和方案：即实现一个通用的机制，提供以 Python 或 PHP 为基础的一些系统 API， 以便那些可以自如使用 Python 或 PHP 的人可以轻松的通过这些编程接口来定制化他们自己的徽章。而且老实说，PHP 和 Python 可是比任何可能的 GUI 接口都要好用和强大得多，为什么还要考虑 GUI 的方案呢？（出自开源开发者的想法）
同样的，开源开发者会认为那些系统设置和管理员界面也一样可以省略掉。在他们看来，假如你是一个管理员，有 SQL 服务器的权限，那么你就理所当然的具备那些系统管理员该有的知识和技能。那么你其实可以使用 Djang-admin 或者任何类似的工具来轻松的对 StackOverflow 做很多设置和改造工作。毕竟如果你是一个 mods （懂如何 mod 的人）那么你肯定知道网站是怎么工作的，懂得如何利用专业工具去设置和改造一个网站。对啊！这不就得了！ 毋庸置疑，在开源开发者重做他们自己的 StackOverflow 的时候，他们也不会把任何 StackOverflow 在接口上面的失败设计纠正过来。即使是原版 StackOverflow 里面最愚蠢最失败的那个设计（即要求用户必须拥有一个 OpenID 并知道如何使用它）在某个将来最终被 StackOverflow 删除和修正掉了， 我相信正在复制 StackOverflow 模式的那些开源克隆产品也还是会不假思索的把这个 OpenID 的功能仿制出来。这就好比是 GNOME 和 KDE 多年以来一直在做的事情，他们并没有把精力放在如何在设计之初就避免 Windows 的那些显而易见的毛病和问题，相反的却是在亦步亦趋的重复着 Windows 的设计，想办法用开源的方式做出一个比拟 Windows 功能的系统。
开发者可能不会关心一个应用的上述设计细节，但是终端用户一定会。尤其是当他们在尝试去选择要使用哪个应用的时候，这些终端用户更会重视这些接口设计是否易用。就好像一家好的软件公司希望通过确保其产品在出货之前就有一流的质量，以降低售后维护支持的成本一样，懂行的消费者也会在他们购买这些产品之前就确保产品好用，以防在使用的时候不知所措，然后无奈的打电话给售后来解决问题。开源产品就失败在这里，而且相当之失败。一般来讲，付费软件则在这方面做得好很多。
这不是说开源软件没有自己的立足之地，这个博客就运行在 Apache、[Django](http://www.djangoproject.com/)、[PostgreSQL](http://www.postgresql.org/) 和 Linux 搭建的开源系统之上。但是让我来告诉你吧，配置这些堆栈可不是谁都可以做的。老版本的 PostgreSQL 需要手工配置 Vacuuming 来确保数据库的自动清理，而即使是最新版本的 Ubuntu 和 FreeBSD 也仍然要求用户去手工配置他们的第一个数据库集群。
相比之下，MS SQL (微软的 SQL 数据库) 则不需要你手工配置以上的任何一样东西。至于 Apache …… 我的天，Apache 简直复杂到让我根本来不及去尝试给一个新用户讲解我们如何可以通过一个一次性的安装过程就能把虚拟机、MovableType，几个 Diango apps 和 WordPress 配置在一起并流畅地使用。单单是给那些技术背景还不错但并非软件开发者的用户解释清楚 Apache 的那些针对多进程和多线程的设置参数就已经够我喝一壶的了。相比之下，微软的 IIS 7 或者是使用了 OS X 服务器的那个几乎闭源的 GUI 管理器的 Apache ，在配置的时候就要简单上不止一个数量级了。Django 确实是一个好的开源产品，但它也 *只是* 一个基础构架，而并非是一个可以直接面向终端普通用户的商业产品。而开源真正的强项就 *恰恰在* 这种基础构架的开发和创新上，这也正是驱使开发者为开源做贡献的最本真的动力。
所以我的结论是，如果下次你再看到一个你喜欢的应用程序，请好好细心地揣摩一下这款产品，揣摩一下所有的那些针对用户的体贴入微的设计细节。而不是武断的认为你可以轻轻松松的在一周之内就用开源工具做一个和这个应用一摸一样的产品出来。那些认为制作和实现一个应用程序如此简单的人，十之八九都是因为忽略了软件开发的最终产品是要交给用户去用的。
---
via: <https://bitquabit.com/post/one-which-i-call-out-hacker-news/>
作者：[Benjamin Pollack](https://bitquabit.com/meta/about/) 译者：[hopefully2333](https://github.com/hopefully2333)，[yunfengHe](https://github.com/yunfengHe) 校对：[yunfengHe](https://github.com/yunfengHe)，[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux shell 中找出所有包含指定文本的文件
|
Lubos Rendek
|
https://linuxconfig.org/how-to-find-all-files-with-a-specific-text-using-linux-shell
|
本文提供一些关于如何搜索出指定目录或整个文件系统中那些包含指定单词或字符串的文件。
|
/data/attachment/album/201712/16/002633n0oujua76do30drd.jpg.thumb.jpg
|
/data/attachment/album/201712/16/002633n0oujua76do30drd.jpg
| true | false | true |
lujun9972
| false |
[
"find",
"grep"
] |
技术
|
{
"viewnum": 8443,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本文提供一些关于如何搜索出指定目录或整个文件系统中那些包含指定单词或字符串的文件。
| 2017-12-18T09:23:00 | 2017-12-18T09:23:00 | 9,149 |
/article-9149-1.html
|
**目标：**本文提供一些关于如何搜索出指定目录或整个文件系统中那些包含指定单词或字符串的文件。
**难度：**容易
**约定：**
* `#` - 需要使用 root 权限来执行指定命令，可以直接使用 root 用户来执行也可以使用 `sudo` 命令
* `$` - 可以使用普通用户来执行指定命令
### 案例
#### 非递归搜索包含指定字符串的文件
第一个例子让我们来搜索 `/etc/` 目录下所有包含 `stretch` 字符串的文件，但不去搜索其中的子目录:
```
# grep -s stretch /etc/*
/etc/os-release:PRETTY_NAME="Debian GNU/Linux 9 (stretch)"
/etc/os-release:VERSION="9 (stretch)"
```
`grep` 的 `-s` 选项会在发现不存在或者不能读取的文件时隐藏报错信息。结果显示除了文件名之外，还有包含请求字符串的行也被一起输出了。
#### 递归地搜索包含指定字符串的文件
上面案例中忽略了所有的子目录。所谓递归搜索就是指同时搜索所有的子目录。
下面的命令会在 `/etc/` 及其子目录中搜索包含 `stretch` 字符串的文件：
```
# grep -R stretch /etc/*
/etc/apt/sources.list:# deb cdrom:[Debian GNU/Linux testing _Stretch_ - Official Snapshot amd64 NETINST Binary-1 20170109-05:56]/ stretch main
/etc/apt/sources.list:#deb cdrom:[Debian GNU/Linux testing _Stretch_ - Official Snapshot amd64 NETINST Binary-1 20170109-05:56]/ stretch main
/etc/apt/sources.list:deb http://ftp.au.debian.org/debian/ stretch main
/etc/apt/sources.list:deb-src http://ftp.au.debian.org/debian/ stretch main
/etc/apt/sources.list:deb http://security.debian.org/debian-security stretch/updates main
/etc/apt/sources.list:deb-src http://security.debian.org/debian-security stretch/updates main
/etc/dictionaries-common/words:backstretch
/etc/dictionaries-common/words:backstretch's
/etc/dictionaries-common/words:backstretches
/etc/dictionaries-common/words:homestretch
/etc/dictionaries-common/words:homestretch's
/etc/dictionaries-common/words:homestretches
/etc/dictionaries-common/words:outstretch
/etc/dictionaries-common/words:outstretched
/etc/dictionaries-common/words:outstretches
/etc/dictionaries-common/words:outstretching
/etc/dictionaries-common/words:stretch
/etc/dictionaries-common/words:stretch's
/etc/dictionaries-common/words:stretched
/etc/dictionaries-common/words:stretcher
/etc/dictionaries-common/words:stretcher's
/etc/dictionaries-common/words:stretchers
/etc/dictionaries-common/words:stretches
/etc/dictionaries-common/words:stretchier
/etc/dictionaries-common/words:stretchiest
/etc/dictionaries-common/words:stretching
/etc/dictionaries-common/words:stretchy
/etc/grub.d/00_header:background_image -m stretch `make_system_path_relative_to_its_root "$GRUB_BACKGROUND"`
/etc/os-release:PRETTY_NAME="Debian GNU/Linux 9 (stretch)"
/etc/os-release:VERSION="9 (stretch)"
```
#### 搜索所有包含特定单词的文件
上面 `grep` 命令的案例中列出的是所有包含字符串 `stretch` 的文件。也就是说包含 `stretches` ， `stretched` 等内容的行也会被显示。 使用 `grep` 的 `-w` 选项会只显示包含特定单词的行：
```
# grep -Rw stretch /etc/*
/etc/apt/sources.list:# deb cdrom:[Debian GNU/Linux testing _Stretch_ - Official Snapshot amd64 NETINST Binary-1 20170109-05:56]/ stretch main
/etc/apt/sources.list:#deb cdrom:[Debian GNU/Linux testing _Stretch_ - Official Snapshot amd64 NETINST Binary-1 20170109-05:56]/ stretch main
/etc/apt/sources.list:deb http://ftp.au.debian.org/debian/ stretch main
/etc/apt/sources.list:deb-src http://ftp.au.debian.org/debian/ stretch main
/etc/apt/sources.list:deb http://security.debian.org/debian-security stretch/updates main
/etc/apt/sources.list:deb-src http://security.debian.org/debian-security stretch/updates main
/etc/dictionaries-common/words:stretch
/etc/dictionaries-common/words:stretch's
/etc/grub.d/00_header:background_image -m stretch `make_system_path_relative_to_its_root "$GRUB_BACKGROUND"`
/etc/os-release:PRETTY_NAME="Debian GNU/Linux 9 (stretch)"
/etc/os-release:VERSION="9 (stretch)"
```
#### 显示包含特定文本的文件名
上面的命令都会产生多余的输出。下一个案例则会递归地搜索 `etc` 目录中包含 `stretch` 的文件并只输出文件名：
```
# grep -Rl stretch /etc/*
/etc/apt/sources.list
/etc/dictionaries-common/words
/etc/grub.d/00_header
/etc/os-release
```
#### 大小写不敏感的搜索
默认情况下搜索是大小写敏感的，也就是说当搜索字符串 `stretch` 时只会包含大小写一致内容的文件。
通过使用 `grep` 的 `-i` 选项，`grep` 命令还会列出所有包含 `Stretch` ， `STRETCH` ， `StReTcH` 等内容的文件，也就是说进行的是大小写不敏感的搜索。
```
# grep -Ril stretch /etc/*
/etc/apt/sources.list
/etc/dictionaries-common/default.hash
/etc/dictionaries-common/words
/etc/grub.d/00_header
/etc/os-release
```
#### 搜索时包含/排除指定文件
`grep` 命令也可以只在指定文件中进行搜索。比如，我们可以只在配置文件（扩展名为`.conf`）中搜索指定的文本/字符串。 下面这个例子就会在 `/etc` 目录中搜索带字符串 `bash` 且所有扩展名为 `.conf` 的文件：
```
# grep -Ril bash /etc/*.conf
OR
# grep -Ril --include=\*.conf bash /etc/*
/etc/adduser.conf
```
类似的，也可以使用 `--exclude` 来排除特定的文件：
```
# grep -Ril --exclude=\*.conf bash /etc/*
/etc/alternatives/view
/etc/alternatives/vim
/etc/alternatives/vi
/etc/alternatives/vimdiff
/etc/alternatives/rvim
/etc/alternatives/ex
/etc/alternatives/rview
/etc/bash.bashrc
/etc/bash_completion.d/grub
/etc/cron.daily/apt-compat
/etc/cron.daily/exim4-base
/etc/dictionaries-common/default.hash
/etc/dictionaries-common/words
/etc/inputrc
/etc/passwd
/etc/passwd-
/etc/profile
/etc/shells
/etc/skel/.profile
/etc/skel/.bashrc
/etc/skel/.bash_logout
```
#### 搜索时排除指定目录
跟文件一样，`grep` 也能在搜索时排除指定目录。 使用 `--exclude-dir` 选项就行。
下面这个例子会搜索 `/etc` 目录中搜有包含字符串 `stretch` 的文件，但不包括 `/etc/grub.d` 目录下的文件：
```
# grep --exclude-dir=/etc/grub.d -Rwl stretch /etc/*
/etc/apt/sources.list
/etc/dictionaries-common/words
/etc/os-release
```
#### 显示包含搜索字符串的行号
`-n` 选项还会显示指定字符串所在行的行号:
```
# grep -Rni bash /etc/*.conf
/etc/adduser.conf:6:DSHELL=/bin/bash
```
#### 寻找不包含指定字符串的文件
最后这个例子使用 `-v` 来列出所有**不**包含指定字符串的文件。
例如下面命令会搜索 `/etc` 目录中不包含 `stretch` 的所有文件：
```
# grep -Rlv stretch /etc/*
```
---
via: <https://linuxconfig.org/how-to-find-all-files-with-a-specific-text-using-linux-shell>
作者：[Lubos Rendek](https://linuxconfig.org) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用系统日志了解你的 Linux 系统
|
Chabowski
|
https://www.suse.com/communities/blog/system-logs-understand-linux-system/
|
后台运行的程序（通常被称为守护进程或者服务进程）处理了你 Linux 系统中的大部分任务。当这些守护进程工作时，它们将任务的详细信息记录进日志文件中，作为它们做过什么的“历史”信息。
|
/data/attachment/album/201712/16/010936xkfdg7zk1lpkwwir.jpg.thumb.jpg
|
/data/attachment/album/201712/16/010936xkfdg7zk1lpkwwir.jpg
| true | false | true |
lujun9972
| false |
[
"日志"
] |
技术
|
{
"viewnum": 7972,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
后台运行的程序（通常被称为守护进程或者服务进程）处理了你 Linux 系统中的大部分任务。当这些守护进程工作时，它们将任务的详细信息记录进日志文件中，作为它们做过什么的“历史”信息。
| 2017-12-19T09:04:00 | 2017-12-19T09:04:00 | 9,150 |
/article-9150-1.html
|
本文摘自为 Linux 小白（或者非资深桌面用户）传授技巧的系列文章。该系列文章旨在为 LinuxMagazine 发布的第 30 期特别版 “[Linux 入门](http://www.linux-magazine.com/Resources/Special-Editions/30-Getting-Started-with-Linux)” （基于 [openSUSE Leap](https://en.opensuse.org/Portal:42.3) ）提供补充说明。
本文作者是 Romeo S.，她是一名基于 PDX 的企业 Linux 专家，专注于为创新企业提供富有伸缩性的解决方案。
Linux 系统日志非常重要。后台运行的程序（通常被称为守护进程或者服务进程）处理了你 Linux 系统中的大部分任务。当这些守护进程工作时，它们将任务的详细信息记录进日志文件中，作为它们做过什么的“历史”信息。这些守护进程的工作内容涵盖从使用原子钟同步时钟到管理网络连接。所有这些都被记录进日志文件，这样当有错误发生时，你可以通过查阅特定的日志文件来看出发生了什么。
*Photo by Markus Spiske on Unsplash*
在你的 Linux 计算机上有很多不同的日志。历史上，它们一般以纯文本的格式存储到 `/var/log` 目录中。现在依然有很多日志这样做，你可以很方便的使用 `less` 来查看它们。
在新装的 openSUSE Leap 42.3 以及大多数现代操作系统上，重要的日志由 `systemd` 初始化系统存储。 `systemd`这套系统负责启动守护进程，并在系统启动时让计算机做好被使用的准备。由 `systemd` 记录的日志以二进制格式存储，这使得它们消耗的空间更小，更容易被浏览，也更容易被导出成其他各种格式，不过坏处就是你必须使用特定的工具才能查看。好在这个工具已经预安装在你的系统上了：它的名字叫 `journalctl`，而且默认情况下，它会将每个守护进程的所有日志都记录到一个地方。
只需要运行 `journalctl` 命令就能查看你的 `systemd` 日志了。它会用 `less` 分页器显示各种日志。为了让你有个直观的感受, 下面是 `journalctl` 中摘录的一条日志记录：
```
Jul 06 11:53:47 aaathats3as pulseaudio[2216]: [pulseaudio] alsa-util.c: Disabling timer-based scheduling because running inside a VM.
```
这条独立的日志记录以此包含了记录的日期和时间、计算机名、记录日志的进程名、记录日志的进程 PID，以及日志内容本身。
若系统中某个程序运行出问题了，则可以查看日志文件并搜索（使用 `/` 加上要搜索的关键字）程序名称。有可能导致该程序出问题的错误会记录到系统日志中。 有时，错误信息会足够详细到让你能够修复该问题。其他时候，你需要在 Web 上搜索解决方案。 Google 就很适合来搜索奇怪的 Linux 问题。不过搜索时请注意你只输入了日志的实际内容，行首的那些信息（日期、主机名、进程 ID) 对搜索来说是无意义的，会干扰搜索结果。
解决方法一般在搜索结果的前几个连接中就会有了。当然，你不能只是无脑得运行从互联网上找到的那些命令：请一定先搞清楚你要做的事情是什么，它的效果会是什么。据说，搜索系统日志中的特定条目要比直接描述该故障通用关键字要有用的多。因为程序出错有很多原因，而且同样的故障表现也可能由多种问题引发的。
比如，系统无法发声的原因有很多，可能是播放器没有插好，也可能是声音系统出故障了，还可能是缺少合适的驱动程序。如果你只是泛泛的描述故障表现，你会找到很多无关的解决方法，而你也会浪费大量的时间。而专门搜索日志文件中的实际内容，你也许会查询出其它人也有相同日志内容的结果。
你可以对比一下图 1 和图 2。
图 1 搜索系统的故障表现只会显示泛泛的，不精确的结果。这种搜索通常没什么用。
图 2 搜索特定的日志行会显示出精确的，有用的结果。这种搜索通常很有用。
也有一些系统不用 `journalctl` 来记录日志。在桌面系统中最常见的这类日志包括用于记录 openSUSE 包管理器的行为的 `/var/log/zypper.log`； 记录系统启动时消息的 `/var/log/boot.log` ，开机时这类消息往往滚动的特别快，根本看不过来；`/var/log/ntp` 用来记录 Network Time Protocol （NTP）守护进程同步时间时发生的错误。 另一个存放硬件故障信息的地方是 “Kernel Ring Buffer”（内核环状缓冲区），你可以输入 `demesg -H` 命令来查看（这条命令也会调用 `less` 分页器来查看）。“Kernel Ring Buffer” 存储在内存中，因此会在重启电脑后丢失。不过它包含了 Linux 内核中的重要事件，比如新增了硬件、加载了模块，以及奇怪的网络错误.
希望你已经准备好深入了解你的 Linux 系统了! 祝你玩的开心!
---
via: <https://www.suse.com/communities/blog/system-logs-understand-linux-system/>
作者：[chabowski] 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何为 Linux 无线网卡配置无线唤醒功能
|
Vivek Gite
|
https://www.cyberciti.biz/faq/configure-wireless-wake-on-lan-for-linux-wifi-wowlan-card/
|
无线唤醒（WoWLAN 或 WoW）允许 Linux 系统进入低耗电模式的情况下保持无线网卡处于激活状态，依然与热点连接。这篇教程演示了如何在一台安装无线网卡的 Linux 笔记本或桌面电脑上启用 WoWLAN / WoW 模式。
|
/data/attachment/album/201712/16/223821o6ys03xrysrrs4ae.jpg.thumb.jpg
|
/data/attachment/album/201712/16/223821o6ys03xrysrrs4ae.jpg
| true | false | true |
lujun9972
| false |
[
"无线唤醒",
"WoWLAN",
"WoW"
] |
桌面应用
|
{
"viewnum": 7904,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
无线唤醒（WoWLAN 或 WoW）允许 Linux 系统进入低耗电模式的情况下保持无线网卡处于激活状态，依然与热点连接。这篇教程演示了如何在一台安装无线网卡的 Linux 笔记本或桌面电脑上启用 WoWLAN / WoW 模式。
| 2017-12-18T08:37:00 | 2017-12-18T08:37:00 | 9,151 |
/article-9151-1.html
|
我有一台用于备份我的所有设备的网络存储（NAS）服务器。然而当我备份我的 Linux 笔记本时遇到了困难。当它休眠或挂起时我不能备份它。当我使用基于 Intel 的无线网卡时，我可以配置笔记本上的 WiFi 接受无线唤醒吗？
<ruby> <a href="https://www.cyberciti.biz/tips/linux-send-wake-on-lan-wol-magic-packets.html"> 网络唤醒 </a> <rt> Wake-on-LAN </rt></ruby>（WOL）是一个以太网标准，它允许服务器通过一个网络消息而被打开。你需要发送一个“魔法数据包”到支持网络唤醒的以太网卡和主板，以便打开被唤醒的系统。
[](https://www.cyberciti.biz/media/new/faq/2017/12/linux-configire-wake-on-wireless-lan-wowlan.jpg)
<ruby> 无线唤醒 <rt> wireless wake-on-lan </rt></ruby>（WoWLAN 或 WoW）允许 Linux 系统进入低耗电模式的情况下保持无线网卡处于激活状态，依然与热点连接。这篇教程演示了如何在一台安装无线网卡的 Linux 笔记本或桌面电脑上启用 WoWLAN / WoW 模式。
>
> 请注意，不是所有的无线网卡和 Linux 驱动程序都支持 WoWLAN。
>
>
>
### 语法
在 Linux 系统上，你需要使用 `iw` 命令来查看和操作无线设备及其配置。 其格式为：
```
iw command
iw [options] command
```
### 列出所有的无线设备及其功能
输入下面命令：
```
$ iw list
$ iw list | more
$ iw dev
```
输出为：
```
phy#0
Interface wlp3s0
ifindex 3
wdev 0x1
addr 6c:88:14:ff:36:d0
type managed
channel 149 (5745 MHz)，width： 40 MHz， center1： 5755 MHz
txpower 15.00 dBm
```
请记下这个 `phy0`。
### 查看无线唤醒的当前状态
打开终端并输入下面命令来查看无线网络的状态：
```
$ iw phy0 wowlan show
```
输出为：
```
WoWLAN is disabled
```
### 如何启用无线唤醒
启用的语法为：
`sudo iw phy {phyname} wowlan enable {option}`
其中，
1. `{phyname}` - 使用 `iw dev` 来获取其物理名。
2. `{option}` - 可以是 `any`、`disconnect`、`magic-packet` 等。
比如，我想为 `phy0` 开启无线唤醒：
```
$ sudo iw phy0 wowlan enable any
```
或者：
```
$ sudo iw phy0 wowlan enable magic-packet disconnect
```
检查一下：
```
$ iw phy0 wowlan show
```
结果为：
```
WoWLAN is enabled：
* wake up on disconnect
* wake up on magic packet
```
### 测试一下
将你的笔记本挂起或者进入休眠模式：
```
$ sudo sh -c 'echo mem > /sys/power/state'
```
从 NAS 服务器上使用 [ping 命令](https://www.cyberciti.biz/faq/unix-ping-command-examples/ "See Linux/Unix ping command examples for more info") 发送 ping 请求
```
$ ping your-laptop-ip
```
也可以 [使用 `wakeonlan` 命令发送魔法数据包](https://www.cyberciti.biz/faq/apple-os-x-wake-on-lancommand-line-utility/)：
```
$ wakeonlan laptop-mac-address-here
$ etherwake MAC-Address-Here
```
### 如何禁用无线唤醒？
语法为：
```
$ sudo phy {phyname} wowlan disable
$ sudo phy0 wowlan disable
```
更多信息请阅读 `iw` 命令的 man 页：
```
$ man iw
$ iw --help
```
---
via: <https://www.cyberciti.biz/faq/configure-wireless-wake-on-lan-for-linux-wifi-wowlan-card/>
作者：[Vivek Gite](https://twitter.com/nixcraft) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何使用 Wine 在 Linux 下玩魔兽世界
|
Nick Congleton
|
魔兽世界已经出现差不多有 13 年了，但它依然是最流行的 MMORPG。 不幸的是， 一直以来暴雪从未发布过官方的 Linux 客户端。 不过还好，我们有 Wine。
|
/data/attachment/album/201712/16/233536eaokjqp37y5m83qy.jpg.thumb.jpg
|
/data/attachment/album/201712/16/233536eaokjqp37y5m83qy.jpg
| true | false | true |
lujun9972
| false |
[
"魔兽世界",
"Wine"
] |
桌面应用
|
{
"viewnum": 16586,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
魔兽世界已经出现差不多有 13 年了，但它依然是最流行的 MMORPG。 不幸的是， 一直以来暴雪从未发布过官方的 Linux 客户端。 不过还好，我们有 Wine。
| 2017-12-20T10:30:00 | 2017-12-20T10:30:00 | 9,152 |
/article-9152-1.html
|
**目标：**在 Linux 中运行魔兽世界
**发行版：**适用于几乎所有的 Linux 发行版。
**要求：**具有 root 权限的 Linux 系统，搭配上比较现代化的显卡并安装了最新的图形驱动程序。
**难度：**简单
**约定：**
* `#` - 要求以 root 权限执行命令，可以直接用 root 用户来执行也可以使用 `sudo` 命令
* `$` - 使用普通非特权用户执行
### 简介
魔兽世界已经出现差不多有 13 年了，但它依然是最流行的 MMORPG。 不幸的是， 一直以来暴雪从未发布过官方的 Linux 客户端。 不过还好，我们有 Wine。
### 安装 Wine
你可以试着用一下普通的 Wine，但它在游戏性能方面改进不大。 Wine Staging 以及带 Gallium Nine 补丁的 Wine 几乎在各方面都要更好一点。 如果你使用了闭源的驱动程序， 那么 Wine Staging 是最好的选择。 若使用了 Mesa 驱动程序， 则还需要打上 Gallium Nine 补丁。
根据你使用的发行版，参考 [Wine 安装指南](https://linuxconfig.org/installing-wine) 来安装。
### Winecfg
打开 `winecfg`。确保第一个标签页中的 Windows 版本已经设置成了 `Windows 7`。 暴雪不再对之前的版本提供支持。 然后进入 “Staging” 标签页。 这里根据你用的是 staging 版本的 Wine 还是打了 Gallium 补丁的 Wine 来进行选择。
不管是哪个版本的 Wine，都需要启用 VAAPI 以及 EAX。 至于是否隐藏 Wine 的版本则由你自己决定。
如果你用的是 Staging 补丁，则启用 CSMT。 如果你用的是 Gallium Nine，则启用 Gallium Nine。 但是你不能两个同时启用。
### Winetricks
下一步轮到 Winetricks 了。如果你对它不了解，那我告诉你， Winetricks 一个用来为 Wine 安装各种 Windows 库以及组件以便程序正常运行的脚本。 更多信息可以阅读我们的这篇文章 [Winetricks 指南](https://linuxconfig.org/configuring-wine-with-winetricks)：
要让 WoW 以及<ruby> 战网启动程序 <rt> Battle.net launcher </rt></ruby>工作需要安装一些东西。首先，在 “Fonts” 部分中安装 `corefonts`。 然后下面这一步是可选的， 如果你希望来自互联网上的所有数据都显示在战网启动程序中的话，就还需要安装 DLL 部分中的 ie8。
### Battle.net
现在你配置好了 Wine 了，可以安装 Battle.net 应用了。 Battle.net 应用用来安装和升级 WoW 以及其他暴雪游戏。 它经常在升级后会出现问题。 因此若它突然出现问题，请查看 [WineHQ 页面](https://appdb.winehq.org/objectManager.php?sClass=version&iId=28855&iTestingId=98594)。
毫无疑问，你可以从 [Blizzard 的官网上](http://us.battle.net/en/app/) 下载 Battle.net 应用。
下载完毕后，使用 Wine 打开 `.exe` 文件， 然后按照安装指引一步步走下去，就跟在 Windows 上一样。
应用安装完成后，登录/新建帐号就会进入启动器界面。 你在那可以安装和管理游戏。 然后开始安装 WoW。 这可得好一会儿。
### 运行游戏
在 Battle.net 应用中点击 “Play” 按钮就能启动 WoW 了。你需要等一会儿才能出现登录界面， 这个性能简直堪称垃圾。 之所以这么慢是因为 WoW 默认使用 DX11 来加速。 进入设置窗口中的 “Advanced” 标签页， 设置图像 API 为 DX9。 保存然后退出游戏。 退出成功后再重新打开游戏。
现在游戏应该可以玩了。请注意，游戏的性能严重依赖于你的硬件水平。 WoW 是一个很消耗 CPU 的游戏， 而 Wine 更加加剧了 CPU 的负担。 如果你的 CPU 不够强劲， 你的体验会很差。 不过 WoW 支持低特效，因此你可以调低画质让游戏更流畅。
#### 性能调优
很难说什么样的设置最适合你。WoW 在基本设置中有一个很简单的滑动比例条。 它的配置应该要比在 Windows 上低几个等级，毕竟这里的性能不像 Windows 上那么好。
先调低最可能的罪魁祸首。像<ruby> 抗锯齿 <rt> anti-aliasing </rt></ruby>和<ruby> 粒子 <rt> particles </rt></ruby>就常常会导致低性能。 另外，试试对比一下窗口模式和全屏模式。 有时候这两者之间的差距还是蛮大的。
WoW 对 “Raid and Battleground” 有专门的配置项。这可以在 “Raid and Battleground” 实例中的内容创建更精细的画面。 有时间 WoW 在开放地图中表现不错， 但当很多玩家出现在屏幕中时就变得很垃圾了。
实验然后看看哪些配置最适合你的系统。这完全取决于你的硬件和你的系统配置。
### 最后结语
虽然从未发布过 Linux 版的魔兽世界，但它在 Wine 上已经运行很多年了。 事实上， 它几乎一直都工作的很好。 甚至有传言说暴雪的开发人员会在 Wine 上测试以保证它是有效的。
虽然有这个说法，但后续的更新和补丁还是会影响到这个古老的游戏， 所以请随时做好出问题的准备。 不管怎样， 就算出问题了，也总是早已有了解决方案， 你只需要找到它而已。
---
via: <https://linuxconfig.org/how-to-play-world-of-warcraft-on-linux-with-wine>
作者：[Nick Congleton](https://linuxconfig.org) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
|||
十个不错的 Linux 网络监视工具
|
Linuxandubuntu
|
http://www.linuxandubuntu.com/home/best-network-monitoring-tools-for-linux
|
在这篇文章中，我们将讨论从 Linux 终端中运行的 10 个网络监视工具。它对不使用 GUI 而希望通过 SSH 来保持对网络管理的用户来说是非常理想的。
|
/data/attachment/album/201712/17/180511m1g17mga3g111yz3.jpg.thumb.jpg
|
/data/attachment/album/201712/17/180511m1g17mga3g111yz3.jpg
| true | false | true |
qhwdw
| false |
[
"网络监控"
] |
技术
|
{
"viewnum": 12420,
"commentnum": 0,
"favtimes": 6,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在这篇文章中，我们将讨论从 Linux 终端中运行的 10 个网络监视工具。它对不使用 GUI 而希望通过 SSH 来保持对网络管理的用户来说是非常理想的。
| 2017-12-17T18:05:09 | 2017-12-17T18:05:09 | 9,153 |
/article-9153-1.html
|
保持对我们的网络的管理，防止任何程序过度使用网络、导致整个系统操作变慢，对管理员来说是至关重要的。有几个网络监视工具可以用于不同的操作系统。在这篇文章中，我们将讨论从 Linux 终端中运行的 10 个网络监视工具。它对不使用 GUI 而希望通过 SSH 来保持对网络管理的用户来说是非常理想的。
### iftop
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/iftop_orig.png)
Linux 用户通常都熟悉 `top` —— 这是一个系统监视工具，它允许我们知道在我们的系统中实时运行的进程，并可以很容易地管理它们。`iftop` 与 `top` 应用程序类似，但它是专门监视网络的，通过它可以知道更多的关于网络的详细情况和使用网络的所有进程。
我们可以从 [这个链接](http://www.ex-parrot.com/pdw/iftop/) 获取关于这个工具的更多信息以及下载必要的包。
### vnstat
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/edited/vnstat.png)
`vnstat` 是一个缺省包含在大多数 Linux 发行版中的网络监视工具。它允许我们对一个用户选择的时间周期内发送和接收的流量进行实时控制。
我们可以从 [这个链接](http://humdi.net/vnstat/) 获取关于这个工具的更多信息以及下载必要的包。
### iptraf
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/iptraf_orig.gif)
IPTraf 是一个基于控制台的 Linux 实时网络监视程序。它会收集经过这个网络的各种各样的信息作为一个 IP 流量监视器，包括 TCP 标志信息、ICMP 详细情况、TCP / UDP 流量故障、TCP 连接包和字节计数。它也收集接口上全部的 TCP、UDP、…… IP 协议和非 IP 协议 ICMP 的校验和错误、接口活动等等的详细情况。（LCTT 译注：此处原文有误，径改之）
我们可以从 [这个链接](http://iptraf.seul.org/) 获取这个工具的更多信息以及下载必要的包。
### Monitorix - 系统和网络监视
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/monitorix_orig.png)
Monitorix 是一个轻量级的免费应用程序，它设计用于去监视尽可能多的 Linux / Unix 服务器的系统和网络资源。它里面添加了一个 HTTP web 服务器，可以定期去收集系统和网络信息，并且在一个图表中显示它们。它跟踪平均系统负载、内存分配、磁盘健康状态、系统服务、网络端口、邮件统计信息（Sendmail、Postfix、Dovecot 等等）、MySQL 统计信息以及其它的更多内容。它设计用于去管理系统的整体性能，以及帮助检测故障、瓶颈、异常活动等等。
下载及更多 [信息在这里](http://www.monitorix.org)。
### dstat
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/dstat_orig.png)
这个监视器相比前面的几个知名度低一些，但是，在一些发行版中已经缺省包含了。
我们可以从 [这个链接](http://dag.wiee.rs/home-made/dstat/) 获取这个工具的更多信息以及下载必要的包。
### bwm-ng
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/bwm-ng_orig.png)
这是最简化的工具之一。它允许你去从连接中交互式取得数据，并且，为了便于其它设备使用，在取得数据的同时，能以某些格式导出它们。
我们可以从 [这个链接](http://sourceforge.net/projects/bwmng/) 获取这个工具的更多信息以及下载必要的包。
### ibmonitor
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/ibmonitor_orig.jpg)
与上面的类似，它显示连接接口上过滤后的网络流量，并且，明确地将接收流量和发送流量区分开。
我们可以从 [这个链接](http://ibmonitor.sourceforge.net/) 获取这个工具的更多信息以及下载必要的包。
### Htop - Linux 进程跟踪
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/htop_orig.png)
Htop 是一个更先进的、交互式的、实时的 Linux 进程跟踪工具。它类似于 Linux 的 top 命令，但是有一些更高级的特性，比如，一个更易于使用的进程管理界面、快捷键、水平和垂直的进程视图等更多特性。Htop 是一个第三方工具，它不包含在 Linux 系统中，你必须使用 **YUM** 或者 **APT-GET** 或者其它的包管理工具去安装它。关于安装它的更多信息，读[这篇文章](http://wesharethis.com/knowledgebase/htop-and-atop/)。
我们可以从 [这个链接](http://hisham.hm/htop/) 获取这个工具的更多信息以及下载必要的包。
### arpwatch - 以太网活动监视器
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/arpwatch_orig.png)
arpwatch 是一个设计用于在 Linux 网络中去管理以太网通讯的地址解析程序。它持续监视以太网通讯并记录一个网络中的 IP 地址和 MAC 地址的变化，该变化同时也会记录一个时间戳。它也有一个功能是当一对 IP 和 MAC 地址被添加或者发生变化时，发送一封邮件给系统管理员。在一个网络中发生 ARP 攻击时，这个功能非常有用。
我们可以从 [这个链接](http://linux.softpedia.com/get/System/Monitoring/arpwatch-NG-7612.shtml) 获取这个工具的更多信息以及下载必要的包。
### Wireshark - 网络监视工具
[](http://www.linuxandubuntu.com/uploads/2/1/1/5/21152474/how-to-use-wireshark_1_orig.jpg)
[Wireshark](https://www.wireshark.org/) 是一个自由的应用程序，它允许你去捕获和查看前往你的系统和从你的系统中返回的信息，它可以去深入到数据包中并查看每个包的内容 —— 以分别满足你的不同需求。它一般用于去研究协议问题和去创建和测试程序的特别情况。这个开源分析器是一个被公认的分析器商业标准，它的流行要归功于其久负盛名。
最初它被叫做 Ethereal，Wireshark 有轻量化的、易于理解的界面，它能分类显示来自不同的真实系统上的协议信息。
### 结论
在这篇文章中，我们看了几个开源的网络监视工具。虽然我们从这些工具中挑选出来的认为是“最佳的”，并不意味着它们都是最适合你的需要的。例如，现在有很多的开源监视工具，比如，OpenNMS、Cacti、和 Zennos，并且，你需要去从你的个体情况考虑它们的每个工具的优势。
另外，还有不同的、更适合你的需要的不开源的工具。
你知道的或者使用的在 Linux 终端中的更多网络监视工具还有哪些？
---
via: <http://www.linuxandubuntu.com/home/best-network-monitoring-tools-for-linux>
作者：[LinuxAndUbuntu](http://www.linuxandubuntu.com) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Django ORM 简介
|
Katie Mclaughlin
|
https://opensource.com/article/17/11/django-orm
|
学习怎么去使用 Python 的 web 框架中的对象关系映射与你的数据库交互，就像你使用 SQL 一样。
|
/data/attachment/album/201712/17/185201amly37pj9r33ph5j.png.thumb.jpg
|
/data/attachment/album/201712/17/185201amly37pj9r33ph5j.png
| true | false | true |
qhwdw
| false |
[
"Python",
"Django",
"ORM"
] |
软件开发
|
{
"viewnum": 13318,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习怎么去使用 Python 的 web 框架中的对象关系映射与你的数据库交互，就像你使用 SQL 一样。
| 2017-12-17T18:51:56 | 2017-12-17T18:51:56 | 9,154 |
/article-9154-1.html
|
>
> 学习怎么去使用 Python 的 web 框架中的对象关系映射与你的数据库交互，就像你使用 SQL 一样。
>
>
>
你可能听说过 [Django](https://www.djangoproject.com/)，它是一个被称为“完美主义者的最后期限” 的 Python web 框架。它是一匹 [可爱的小矮马](http://www.djangopony.com/)。
Django 的一个强大的功能是它的<ruby> 对象关系映射 <rt> Object-Relational Mapper </rt></ruby>（ORM），它允许你就像使用 SQL 一样去和你的数据库交互。事实上，Django 的 ORM 就是创建 SQL 去查询和操作数据库的一个 Python 式方式，并且获得 Python 风格的结果。 我说的*是*一种方式，但实际上，它是一种非常聪明的工程方法，它利用了 Python 中一些很复杂的部分，而使得开发者更加轻松。
在我们开始去了解 ORM 是怎么工作之前，我们需要一个可以操作的数据库。和任何一个关系型数据库一样，我们需要去定义一堆表和它们的关系（即，它们相互之间联系起来的方式)。让我们使用我们熟悉的东西。比如说，我们需要去建模一个有博客文章和作者的博客。每个作者有一个名字。一位作者可以有很多的博客文章。一篇博客文章可以有很多的作者、标题、内容和发布日期。
在 Django 村里，这个文章和作者的概念可以被称为博客应用。在这个语境中，一个应用是一个自包含一系列描述我们的博客行为和功能的模型和视图的集合。用正确的方式打包，以便于其它的 Django 项目可以使用我们的博客应用。在我们的项目中，博客正是其中的一个应用。比如，我们也可以有一个论坛应用。但是，我们仍然坚持我们的博客应用的原有范围。
这是为这个教程事先准备的 `models.py`：
```
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
def __str__(self):
return self.name
class Post(models.Model):
title = models.CharField(max_length=100)
content = models.TextField()
published_date = models.DateTimeField(blank=True, null=True)
author = models.ManyToManyField(Author, related_name="posts")
def __str__(self):
return self.title
```
现在，看上去似乎有点令人恐惧，因此，我们把它分解来看。我们有两个模型：作者（`Author`）和文章（`Post`）。它们都有名字（`name`）或者标题（`title`）。文章有个放内容的大的文本字段，以及用于发布时间和日期的 `DateTimeField`。文章也有一个 `ManyToManyField`，它同时链接到文章和作者。
大多数的教程都是从头开始的，但是，在实践中并不会发生这种情况。实际上，你会得到一堆已存在的代码，就像上面的 `model.py` 一样，而你必须去搞清楚它们是做什么的。
因此，现在你的任务是去进入到应用程序中去了解它。做到这一点有几种方法，你可以登入到 [Django admin](https://docs.djangoproject.com/en/1.11/ref/contrib/admin/)，这是一个 Web 后端，它会列出全部的应用和操作它们的方法。我们先退出它，现在我们感兴趣的东西是 ORM。
我们可以在 Django 项目的主目录中运行 `python manage.py shell` 去访问 ORM。
```
/srv/web/django/ $ python manage.py shell
Python 3.6.3 (default, Nov 9 2017, 15:58:30)
[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.38)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>>
```
这将带我们进入到交互式控制台。[`shell` 命令](https://docs.djangoproject.com/en/1.11/ref/django-admin/#shell) 为我们做了很多设置，包括导入我们的设置和配置 Django 环境。虽然我们启动了 shell，但是，在我们导入它之前，我们并不能访问我们的博客模型。
```
>>> from blog.models import *
```
它导入了全部的博客模型，因此，我们可以玩我们的博客了。
首先，我们列出所有的作者：
```
>>> Author.objects.all()
```
我们将从这个命令取得结果，它是一个 `QuerySet`，它列出了我们所有的作者对象。它不会充满我们的整个控制台，因为，如果有很多查询结果，Django 将自动截断输出结果。
```
>>> Author.objects.all()
<QuerySet [<Author: VM (Vicky) Brasseur>, <Author: Rikki Endsley>,
<Author: Jen Wike Huger>, '...(remaining elements truncated)...']
```
我们可以使用 `get` 代替 `all` 去检索单个作者。但是，我们需要一些更多的信息才能 `get` 一个单个记录。在关系型数据库中，表有一个主键，它唯一标识了表中的每个记录，但是，作者名并不唯一。许多人都 [重名](https://2016.katieconf.xyz/)，因此，它不是唯一约束的好选择。解决这个问题的一个方法是使用一个序列（1、2、3 ……）或者一个通用唯一标识符（UUID）作为主键。但是，因为它对人类并不好用，我们可以通过使用 `name` 来操作我们的作者对象。
```
>>> Author.objects.get(name="VM (Vicky) Brasseur")
<Author: VM (Vicky) Brasseur>
```
到现在为止，我们已经有了一个我们可以交互的对象，而不是一个 `QuerySet` 列表。我们现在可以与这个 Python 对象进行交互了，使用任意一个表列做为属性去查看对象。
```
>>> vmb = Author.objects.get(name="VM (Vicky) Brasseur")
>>> vmb.name
u'VM (Vicky) Brasseur'
```
然后，很酷的事件发生了。通常在关系型数据库中，如果我们希望去展示其它表的信息，我们需要去写一个 `LEFT JOIN`，或者其它的表耦合函数，并确保它们之间有匹配的外键。而 Django 可以为我们做到这些。
在我们的模型中，由于作者写了很多的文章，因此，我们的作者对象可以检索他自己的文章。
```
>>> vmb.posts.all()
QuerySet[<Post: "7 tips for nailing your job interview">,
<Post: "5 tips for getting the biggest bang for your cover letter buck">,
<Post: "Quit making these 10 common resume mistakes">,
'...(remaining elements truncated)...']
```
我们可以使用正常的 Python 式的列表操作方式来操作 `QuerySets`。
```
>>> for post in vmb.posts.all():
... print(post.title)
...
7 tips for nailing your job interview
5 tips for getting the biggest bang for your cover letter buck
Quit making these 10 common resume mistakes
```
要实现更复杂的查询，我们可以使用过滤得到我们想要的内容。这有点复杂。在 SQL 中，你可以有一些选项，比如，`like`、`contains` 和其它的过滤对象。在 ORM 中这些事情也可以做到。但是，是通过 *特别的* 方式实现的：是通过使用一个隐式（而不是显式）定义的函数实现的。
如果在我的 Python 脚本中调用了一个函数 `do_thing()`，我会期望在某个地方有一个匹配的 `def do_thing`。这是一个显式的函数定义。然而，在 ORM 中，你可以调用一个 *不显式定义的* 函数。之前，我们使用 `name` 去匹配一个名字。但是，如果我们想做一个子串搜索，我们可以使用 `name__contains`。
```
>>> Author.objects.filter(name__contains="Vic")
QuerySet[<Author: VM (Vicky) Brasseur>, <Author: Victor Hugo">]
```
现在，关于双下划线（`__`）我有一个小小的提示。这些是 Python *特有的*。在 Python 的世界里，你可以看到如 `__main__` 或者 `__repr__`。这些有时被称为 `dunder methods`，是 “<ruby> 双下划线 <rt> double underscore </rt></ruby>” 的缩写。仅有几个非字母数字的字符可以被用于 Python 中的对象名字；下划线是其中的一个。这些在 ORM 中被用于显式分隔<ruby> 过滤关键字 <rt> filter key name </rt></ruby>的各个部分。在底层，字符串用这些下划线分割开，然后这些标记分开处理。`name__contains` 被替换成 `attribute: name, filter: contains`。在其它编程语言中，你可以使用箭头代替，比如，在 PHP 中是 `name->contains`。不要被双下划线吓着你，正好相反，它们是 Python 的好帮手（并且如果你斜着看，你就会发现它看起来像一条小蛇，想去帮你写代码的小蟒蛇）。
ORM 是非常强大并且是 Python 特有的。不过，还记得我在上面提到过的 Django 的管理网站吗？
Django 的其中一个非常精彩的用户可访问特性是它的管理界面，如果你定义你的模型，你将看到一个非常好用的基于 web 的编辑门户，而且它是免费的。
ORM，有多强大？
好吧！给你一些代码去创建最初的模型，Django 就变成了一个基于 web 的门户，它是非常强大的，它可以使用我们前面用过的同样的原生函数。默认情况下，这个管理门户只有基本的东西，但这只是在你的模型中添加一些定义去改变外观的问题。例如，在早期的这些 `__str__` 方法中，我们使用这些去定义作者对象应该有什么？（在这种情况中，比如，作者的名字），做了一些工作后，你可以创建一个界面，让它看起来像一个内容管理系统，以允许你的用户去编辑他们的内容。（例如，为一个标记为 “已发布” 的文章，增加一些输入框和过滤）。
如果你想去了解更多内容，[Django 美女的教程](https://djangogirls.org/) 中关于 [the ORM](https://tutorial.djangogirls.org/en/django_orm/) 的节有详细的介绍。在 [Django project website](https://docs.djangoproject.com/en/1.11/topics/db/) 上也有丰富的文档。
（题图 [Christian Holmér](https://www.flickr.com/people/crsan/)，Opensource.com 修改. [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)）
---
作者简介：
Katie McLaughlin - Katie 在过去的这几年有许多不同的头衔，她以前是使用多种语言的一位软件开发人员，多种操作系统的系统管理员，和多个不同话题的演讲者。当她不改变 “世界” 的时候，她也去享受烹饪、挂毯艺术，和去研究各种应用程序栈怎么去处理 emoji。
---
via: <https://opensource.com/article/17/11/django-orm>
作者：[Katie McLaughlin](https://opensource.com/users/glasnt) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
互联网协议正在发生变化
|
Mark Nottingham
|
https://blog.apnic.net/2017/12/12/internet-protocols-changing/
|
现在，核心互联网协议的重要改变已经开始了。虽然它们意图与互联网大部分兼容（因为，如果不兼容的话，它们不会被采纳），但是它们可能会破坏那些在协议中没有规定的地方，或者根本就假设那些地方不存在变化。
|
/data/attachment/album/201712/17/220929xdziize505c665i0.png.thumb.jpg
|
/data/attachment/album/201712/17/220929xdziize505c665i0.png
| true | false | true |
qhwdw
| false |
[
"互联网",
"Internet"
] |
观点
|
{
"viewnum": 5579,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
现在，核心互联网协议的重要改变已经开始了。虽然它们意图与互联网大部分兼容（因为，如果不兼容的话，它们不会被采纳），但是它们可能会破坏那些在协议中没有规定的地方，或者根本就假设那些地方不存在变化。
| 2017-12-17T22:09:28 | 2017-12-17T22:09:28 | 9,155 |
/article-9155-1.html
|
当上世纪九十年代互联网开始被广泛使用的时候，其大部分的通讯只使用几个协议：IPv4 协议路由这些数据包，TCP 协议转发这些包到连接上，SSL（及后来的 TLS）协议加密连接，DNS 协议命名那些所要连接的主机，而 HTTP 协议是最常用的应用程序协议。
多年以来，这些核心的互联网协议的变化几乎是微乎其微的；HTTP 增加了几个新的报文头和请求方式，TLS 缓慢地进行了一点小修改，TCP 调整了拥塞控制，而 DNS 引入了像 DNSSEC 这样的特性。这些协议看起来很长时间都一成不变（除了已经引起网络运营商们的大量关注的 IPv6）。
因此，希望了解（甚至有时控制）互联网的网络运营商、供应商和决策者对这些协议采用的做法是基于其原有工作方式 —— 无论是打算调试问题，提高服务质量，或施加政策。
现在，核心互联网协议的重要改变已经开始了。虽然它们意图与互联网大部分兼容（因为，如果不兼容的话，它们不会被采纳），但是它们可能会破坏那些在协议中没有规定的地方，或者根本就假设那些地方不存在变化。
### 为什么我们需要去改变互联网
有大量的因素推动这些变化。
首先，核心互联网协议的局限性越来越明显，尤其是考虑到性能的时候。由于在应用和传输协议方面的结构性问题，网络没有得到高效使用，导致终端用户认为性能不能满足要求（特别是，网络延迟）。
这就意味着人们有强烈的动机来演进或者替换这些协议，因为有 [大量的经验表明，即便是很小的性能改善也会产生影响](https://www.smashingmagazine.com/2015/09/why-performance-matters-the-perception-of-time/)。
其次，演进互联网协议的能力 —— 无论在任何层面上 —— 会随着时间的推移变得更加困难，这主要是因为上面所讨论的对网络的非预期使用。例如，尝试去压缩响应的 HTTP 代理服务器使得部署新的压缩技术更困难；中间设备中的 TCP 优化使得部署对 TCP 的改进越来越困难。
最后，[我们正处在一个越来越多地使用加密技术的互联网变化当中](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/46197.pdf)，首次激起这种改变的事件是，2015 年 Edward Snowden 的披露事件（LCTT 译注：指的是美国中情局雇员斯诺登的事件）。那是一个单独讨论的话题，但是与之相关的是，加密技术是最好的工具之一，我们必须确保协议能够进化。
让我们来看一下都发生了什么，接下来会出现什么，它对网络有哪些影响，和它对网络协议的设计有哪些影响。
### HTTP/2
[HTTP/2](https://http2.github.io/)（基于 Google 的 SPDY） 是第一个重大变化 —— 它在 2015 年被标准化。它将多个请求复用到一个 TCP 连接上，从而避免了客户端排队请求，而不会互相阻塞。它现在已经被广泛部署，并且被所有的主流浏览器和 web 服务器支持。
从网络的角度来看，HTTP/2 带来了一些显著变化。首先，这是一个二进制协议，因此，任何假定它是 HTTP/1.1 的设备都会出现问题。
这种破坏性问题是导致 HTTP/2 中另一个重大变化的主要原因之一：它实际上需要加密。这种改变的好处是避免了来自伪装的 HTTP/1.1 的中间人攻击，或者一些更细微的事情，比如 strip headers 或者阻止新的协议扩展 —— 这两种情况都在工程师对协议的开发中出现过，导致了很明显的支持问题。
[当它被加密时，HTTP/2 请求也要求使用 TLS/1.2](http://httpwg.org/specs/rfc7540.html#TLSUsage)，并且将一些已经被证明是不安全的算法套件列入[黑名单](http://httpwg.org/specs/rfc7540.html#BadCipherSuites) —— 其效果只允许使用<ruby> 短暂密钥 <rt> ephemeral keys </rt></ruby>。关于潜在的影响可以去看 TLS 1.3 的相关章节。
最终，HTTP/2 允许多个主机的请求被 [合并到一个连接上](http://httpwg.org/specs/rfc7540.html#reuse)，通过减少页面加载所使用的连接（从而减少拥塞控制的场景）数量来提升性能。
例如，你可以对 www.example.com 建立一个连接，也可以将这个连接用于对 images.example.com 的请求。而[未来的协议扩展也允许将其它的主机添加到连接上](https://tools.ietf.org/html/draft-bishop-httpbis-http2-additional-certs)，即便它们没有被列在最初用于它们的 TLS 证书中。因此，假设连接上的通讯被限制于它初始化时的目的并不适用。
值得注意的是，尽管存在这些变化，HTTP/2 并没有出现明显的互操作性问题或者来自网络的冲突。
### TLS 1.3
[TLS 1.3](https://datatracker.ietf.org/doc/draft-ietf-tls-tls13/) 刚刚通过了标准化的最后流程，并且已经被一些实现所支持。
不要被它只增加了版本号的名字所欺骗；它实际上是一个新的 TLS 版本，全新打造的 “握手”机制允许应用程序数据从头开始流动（经常被称为 ‘0RTT’）。新的设计依赖于短暂密钥交换，从而排除了静态密钥。
这引起了一些网络运营商和供应商的担心 —— 尤其是那些需要清晰地知道那些连接内部发生了什么的人。
例如，假设一个对可视性有监管要求的银行数据中心，通过在网络中嗅探通讯包并且使用他们的服务器上的静态密钥解密它，它们可以记录合法通讯和识别有害通讯，无论是来自外部的攻击，还是员工从内部去泄露数据。
TLS 1.3 并不支持那些窃听通讯的特定技术，因为那也是 [一种针对短暂密钥防范的攻击形式](https://en.wikipedia.org/wiki/Forward_secrecy)。然而，因为他们有使用更现代化的加密协议和监视他们的网络的监管要求，这些使网络运营商处境很尴尬。
关于是否规定要求静态密钥、替代方式是否有效、并且为了相对较少的网络环境而减弱整个互联网的安全是否是一个正确的解决方案有很多的争论。确实，仍然有可能对使用 TLS 1.3 的通讯进行解密，但是，你需要去访问一个短暂密钥才能做到，并且，按照设计，它们不可能长时间存在。
在这一点上，TLS 1.3 看起来不会去改变以适应这些网络，但是，关于去创建另外一种协议有一些传言，这种协议允许第三方去偷窥通讯内容，或者做更多的事情。这件事是否会得到推动还有待观察。
### QUIC
在 HTTP/2 工作中，可以很明显地看到 TCP 有相似的低效率。因为 TCP 是一个按顺序发送的协议，一个数据包的丢失可能阻止其后面缓存区中的数据包被发送到应用程序。对于一个多路复用协议来说，这对性能有很大的影响。
[QUIC](https://quicwg.github.io/) 尝试去解决这种影响而在 UDP 之上重构了 TCP 语义（以及 HTTP/2 流模型的一部分）。像 HTTP/2 一样，它始于 Google 的一项成果，并且现在已经被 IETF 接纳作为一个 HTTP-over-UDP 的初始用例，其目标是在 2018 年底成为一个标准。然而，因为 Google 已经在 Chrome 浏览器及其网站上部署了 QUIC，它已经占有了超过 7% 的互联网通讯份额。
* 阅读 [关于 QUIC 的答疑](https://blog.apnic.net/2016/08/30/questions-answered-quic/)
除了大量的通讯从 TCP 到 UDP 的转变（以及隐含的可能的网络调整）之外，Google QUIC（gQUIC）和 IETF QUIC（iQUIC）都要求全程加密；并没有非加密的 QUIC。
iQUIC 使用 TLS 1.3 来为会话建立密钥，然后使用它去加密每个数据包。然而，由于它是基于 UDP 的，许多 TCP 中公开的会话信息和元数据在 QUIC 中被加密了。
事实上，iQUIC 当前的 [‘短报文头’](https://quicwg.github.io/base-drafts/draft-ietf-quic-transport.html#short-header) 被用于除了握手外的所有包，仅公开一个包编号、一个可选的连接标识符和一个状态字节，像加密密钥轮换计划和包字节（它最终也可能被加密）。
其它的所有东西都被加密 —— 包括 ACK，以提高 [通讯分析](https://www.mjkranch.com/docs/CODASPY17_Kranch_Reed_IdentifyingHTTPSNetflix.pdf) 攻击的门槛。
然而，这意味着通过观察连接来被动估算 RTT 和包丢失率将不再变得可行；因为没有足够多的信息。在一些运营商中，由于缺乏可观测性，导致了大量的担忧，它们认为像这样的被动测量对于他们调试和了解它们的网络是至关重要的。
为满足这一需求，它们有一个提议是 ‘[Spin Bit](https://tools.ietf.org/html/draft-trammell-quic-spin)’ — 这是在报文头中的一个回程翻转的位，因此，可能通过观察它来估算 RTT。因为，它从应用程序的状态中解耦的，它的出现并不会泄露关于终端的任何信息，也无法实现对网络位置的粗略估计。
### DOH
即将发生的变化是 DOH — [DNS over HTTP](https://datatracker.ietf.org/wg/doh/about/)。[大量的研究表明，对网络实施政策干预的一个常用手段是通过 DNS 实现的](https://datatracker.ietf.org/meeting/99/materials/slides-99-maprg-fingerprint-based-detection-of-dns-hijacks-using-ripe-atlas/)（无论是代表网络运营商或者一个更大的权力机构）。
使用加密去规避这种控制已经 [讨论了一段时间了](https://datatracker.ietf.org/wg/dprive/about/)，但是，它有一个不利条件（至少从某些立场来看）— 它可能与其它通讯区别对待；例如，通过它的端口号被阻止访问。
DOH 将 DNS 通讯搭载在已经建立的 HTTP 连接上，因此，消除了任何的鉴别器。希望阻止访问该 DNS 解析器的网络只能通过阻止对该网站的访问来实现。
例如，如果 Google 在 www.google.com 上部署了它的 [基于 DOH 的公共 DNS 服务](https://developers.google.com/speed/public-dns/)，并且一个用户配置了它的浏览器去使用它，一个希望（或被要求的）被停止访问该服务的网络，将必须阻止对 Google 的全部访问（向他们提供的服务致敬！）（LCTT 译注：他们做到了）。
DOH 才刚刚开始，但它已经引起很多人的兴趣，并有了一些部署的传闻。通过使用 DNS 来实施政策影响的网络（和政府机构）如何反应还有待观察。
阅读 [IETF 100, Singapore: DNS over HTTP (DOH!)](https://blog.apnic.net/2017/11/17/ietf-100-singapore-dns-http-doh/)
### 僵化和润滑
让我们返回到协议变化的动机，有一个主题贯穿了这项工作，协议设计者们遇到的越来越多的问题是网络对流量的使用做了假设。
例如，TLS 1.3 有一些临门一脚的问题是中间设备假设它是旧版本的协议。gQUIC 将几个对 UDP 通讯进行限流的网络列入了黑名单，因为，那些网络认为 UDP 通讯是有害的或者是低优先级的。
当一个协议因为已有的部署而 “冻结” 它的可扩展点，从而导致不能再进化，我们称它为 *已经僵化了* 。TCP 协议自身就是一个严重僵化的例子，因此，太多的中间设备在 TCP 协议上做了太多的事情，比如阻止了带有无法识别的 TCP 选项的数据包，或者，“优化”了拥塞控制。
防止僵化是有必要的，确保协议可以进化以满足未来互联网的需要；否则，它将成为一个“公共灾难”，一些个别网络的行为 —— 虽然在那里工作的很好 —— 但将影响整个互联网的健康发展。
有很多的方式去防止僵化；如果被讨论的数据是加密的，它并不能被除了持有密钥的人之外任何一方所访问，阻止了干扰。如果扩展点是未加密的，但是通常以一种可以明显中断应用程序的方法使用（例如，HTTP 报头），它不太可能受到干扰。
协议设计者不能使用加密的扩展点不经常使用的情况下，人为地利用扩展点——我们称之为 *润滑* 它。
例如，QUIC 鼓励终端在 [版本协商](https://quicwg.github.io/base-drafts/draft-ietf-quic-transport.html#rfc.section.3.7) 中使用一系列的诱饵值，来避免假设它的实现永远不变化（就像在 TLS 实现中经常遇到的导致重大问题的情况）。
### 网络和用户
除了避免僵化的愿望外，这些变化也反映出了网络和它们的用户之间关系的进化。很长时间以来，人们总是假设网络总是很仁慈好善的 —— 或者至少是公正的 —— 但这种情况是不存在的，不仅是 [无孔不入的监视](https://tools.ietf.org/html/rfc7258)，也有像 [Firesheep](http://codebutler.com/firesheep) 的攻击。
因此，当那些网络想去访问一些流经它们的网络的用户数据时，互联网用户的整体需求和那些网络之间的关系日益紧张。尤其受影响的是那些希望去对它们的用户实施政策干预的网络；例如，企业网络。
在一些情况中，他们可以通过在它们的用户机器上安装软件（或一个 CA 证书，或者一个浏览器扩展）来达到他们的目的。然而，在网络不拥有或无法访问计算机的情况下，这并不容易；例如，BYOD 已经很常用，并且物联网设备几乎没有合适的控制接口。
因此，在 IETF 中围绕协议开发的许多讨论，触及了企业和其它的 “叶子” 网络有时相互竞争的需求，以及互联网整体的好处。
### 参与
为了让互联网在以后工作的更好，它需要为终端用户提供价值、避免僵化、让网络有序运行。现在正在发生的变化需要满足所有的三个目标，但是，人们需要网络运营商更多的投入。
如果这些变化影响你的网络 —— 或者没有影响 —— 请在下面留下评论。更好地可以通过参加会议、加入邮件列表、或者对草案提供反馈来参与 [IETF](https://www.ietf.org/) 的工作。
感谢 Martin Thomson 和 Brian Trammell 的评论。
*本文作者 Mark Nottingham 是互联网架构委员会的成员和 IETF 的 HTTP 和 QUIC 工作组的联席主席。*
---
via: <https://blog.apnic.net/2017/12/12/internet-protocols-changing/>
作者：[Mark Nottingham](https://blog.apnic.net/author/mark-nottingham/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GNOME Boxes 使得测试 Linux 发行版更加简单
|
Joey Sneddon
|
http://www.omgubuntu.co.uk/2017/12/gnome-boxes-install-linux-distros-directly
|
GNOME Boxes 的下一个主要版本能够直接在应用程序内下载流行的 Linux（和基于 BSD 的）操作系统。
|
/data/attachment/album/201712/18/000416xbz588ylhcrgyooc.jpg.thumb.jpg
|
/data/attachment/album/201712/18/000416xbz588ylhcrgyooc.jpg
| true | false | true |
geekpi
| false |
[
"虚拟机"
] |
分享
|
{
"viewnum": 8410,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
GNOME Boxes 的下一个主要版本能够直接在应用程序内下载流行的 Linux（和基于 BSD 的）操作系统。
| 2017-12-18T07:02:00 | 2017-12-18T07:02:00 | 9,156 |
/article-9156-1.html
|
>
> 在 GNOME 桌面上创建 Linux 虚拟机即将变得更加简单。
>
>
>
[GNOME Boxes](https://en.wikipedia.org/wiki/GNOME_Boxes) 的下一个主要版本能够直接在应用程序内下载流行的 Linux（和基于 BSD 的）操作系统。
Boxes 是自由开源软件。它可以用来访问远程和虚拟系统，因为它是用 [QEMU](https://en.wikipedia.org/wiki/QEMU)、KVM 和 libvirt 虚拟化技术构建的。
对于新的 ISO-toting 的集成，*Boxes* 利用 [libosinfo](https://libosinfo.org/) 这一操作系统的数据库，该数据库还提供了有关任何虚拟化环境要求的详细信息。
在 GNOME 开发者 Felipe Borges 的[这个（起错标题的）视频](https://blogs.gnome.org/felipeborges/boxes-downloadable-oses/)中，你可以看到改进的“源选择”页面，包括为给定的发行版下载特定架构的 ISO 的能力。
尽管它是一个核心 GNOME 程序，我不得不承认，我从来没有使用过 Boxes。（我这么做）并不是说我没有听到有关它的好处，只是我更熟悉在 VirtualBox 中设置和配置虚拟机。
我承认在浏览器中下载一个 ISO 然后将虚拟机指向它（见鬼，这是我们大多数在过去十年来一直做的事）并不是一件很*困难*的事。
但是我内心的偷懒精神会欣赏这种集成。
所以，感谢这个功能，我将在明年 3 月份发布 GNOME 3.28 时，在我的系统上解压 Boxes。我会启动 *Boxes*，闭上眼睛，随意从列表中挑选一个发行版，并立即拓宽我的视野。
---
via: <http://www.omgubuntu.co.uk/2017/12/gnome-boxes-install-linux-distros-directly>
作者：[JOEY SNEDDON](https://plus.google.com/117485690627814051450/?rel=author) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
FreeCAD：Linux 下的 3D 建模和设计软件
|
Martins D. Okoi
|
https://www.fossmint.com/freecad-3d-modeling-and-design-software-for-linux/
|
FreeCAD 是一个基于 OpenCasCade 的跨平台机械工程和产品设计工具。作为参数化 3D 建模工具，它可以与 PLM、CAx、CAE、MCAD 和 CAD 协同工作，并且可以使用大量高级扩展和自定义选项扩展其功能。
|
/data/attachment/album/201712/19/073013pbmhmek4yqzc4zwh.png.thumb.jpg
|
/data/attachment/album/201712/19/073013pbmhmek4yqzc4zwh.png
| true | false | true |
geekpi
| false |
[
"CAD",
"FreeCAD"
] |
分享
|
{
"viewnum": 11703,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
FreeCAD 是一个基于 OpenCasCade 的跨平台机械工程和产品设计工具。作为参数化 3D 建模工具，它可以与 PLM、CAx、CAE、MCAD 和 CAD 协同工作，并且可以使用大量高级扩展和自定义选项扩展其功能。
| 2017-12-19T07:30:11 | 2017-12-19T07:30:11 | 9,157 |
/article-9157-1.html
|
[FreeCAD](http://www.freecadweb.org/) 是一个基于 OpenCasCade 的跨平台机械工程和产品设计工具。作为参数化 3D 建模工具，它可以与 PLM、CAx、CAE、MCAD 和 CAD 协同工作，并且可以使用大量高级扩展和自定义选项扩展其功能。
它有基于 Qt 的简约用户界面，具有可切换的面板、布局、工具栏、大量的 Python API 以及符合 Open Inventor 的 3D 场景表示模型（感谢 Coin 3D 库）。
[](https://www.fossmint.com/wp-content/uploads/2017/12/FreeCAD-3D-Software.png)
*FreeCAD 3D 软件*
正如在网站上所列出的，FreeCAD 有一些使用案例，即：
>
> * 家庭用户/业余爱好者：有一个想要构建，或已经已经构建，或者 3D 打印的项目么？在 FreeCAD 中建模。无需之前具有 CAD 经验。我们的社区将帮助你快速掌握它！
> * 有经验的 CAD 用户：如果你在工作中使用商业 CAD 或 BIM 建模软件，你会在 FreeCAD 的许多工作台中找到类似的工具和工作流程。
> * 程序员：几乎所有的 FreeCAD 功能都可以用 Python 访问。你可以轻松扩展 FreeCAD 的功能，使用脚本将其自动化，创建自己的模块，甚至将 FreeCAD 嵌入到自己的程序中。
> * 教育者：教给你的学生一个免费的软件，不用担心购买许可证。他们可以在家里安装相同的版本，并在离开学校后继续使用它。
>
>
>
### FreeCAD 中的功能
* 免费软件：FreeCAD 免费供所有人下载和使用。
* 开源：在 [GitHub](https://github.com/FreeCAD/FreeCAD) 上开源。
* 跨平台：所有的 Windows、Linux 和 Mac 用户都可以享受 FreeCAD 的功能。
* 全面的[在线文档](https://www.freecadweb.org/wiki/Main_Page)。
* 一个给初学者和专业人士的免费[在线手册](https://www.freecadweb.org/wiki/Manual)。
* 注释支持。例如：文字和尺寸。
* 内置的 Python 控制台。
* 完全可定制和脚本化的用户界面。
* [这里](https://forum.freecadweb.org/viewforum.php?f=24)有展示项目的在线社区。
* 用于建模和设计各种物体的可扩展模块。
FreeCAD 为用户提供的功能比我们在这里列出的多得多，所以请随时在其网站的[功能页面](https://www.freecadweb.org/wiki/Feature_list)上查看其余的功能。
市场上有很多 3D 建模工具，但几乎没有免费的。如果你是建模工程师、建筑师或艺术家，并且正在寻找可以使用的程序，而不必花费现金，那么 FreeCAD 是一个非常漂亮的开源项目，你应该看一下。
尝试一下它，看看你是否不喜欢它。
* [下载 Linux 下的 FreeCAD](https://www.freecadweb.org/wiki/Download)
准备成为 FreeCAD 用户了么？你最喜欢哪个功能？你有没有遇到过与它功能相近的其他软件？
欢迎在下面的评论区留下你的留言、建议和建设性的批评。
---
via: <https://www.fossmint.com/freecad-3d-modeling-and-design-software-for-linux/>
作者：[Martins D. Okoi](https://www.fossmint.com/author/dillivine/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Neo4j 和图数据库起步
|
Ruth Holloway
|
https://opensource.com/article/17/7/neo4j-graph-databases-getting-started
|
我们将安装 Neo4j 并通过网页客户端在图中插入并查询数据。
|
/data/attachment/album/201712/19/231406e6dheghg1wcdaqg6.jpg.thumb.jpg
|
/data/attachment/album/201712/19/231406e6dheghg1wcdaqg6.jpg
| true | false | true |
happygeorge01
| false |
[
"Neo4j",
"图数据库"
] |
软件开发
|
{
"viewnum": 5024,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 8728,
"displayorder": 0
}
] |
我们将安装 Neo4j 并通过网页客户端在图中插入并查询数据。
| 2017-12-19T23:14:00 | 2017-12-19T23:14:00 | 9,158 |
/article-9158-1.html
|
>
> 在这个三篇文章系列中的第二篇中，安装 Neo4j 并通过网页客户端来在图中插入和查询数据。
>
>
>
在本系列的 [第一篇](/article-8728-1.html) 中，我们介绍了图数据库中的一些核心概念。在这篇，我们将安装 [Neo4j](https://neo4j.com/) 并通过网页客户端在图中插入并查询数据。
可通过 [他们的网站](https://neo4j.com/download/community-edition/) 下载社区版的 Neo4j！你可以下载 Windows 或 OSX 版来测试，也有各 Linux 发行版对应的版本，还有 Docker 版。
我会在 Debian 9 (stretch) 上安装软件。你可在 [这里](http://debian.neo4j.org/?_ga=2.172102506.853767004.1499179137-1089522652.1499179137) 查看完整说明。如果你正在使用 Debian 8 (jessie) 或更老的版本，你可以安装当前的版本，但会出现的一点小问题是 jessie 中并没有安装 Neo4j 运行所需要的 Java 8 环境。
```
wget -O - https://debian.neo4j.org/neotechnology.gpg.key | sudo apt-key add - echo 'deb https://debian.neo4j.org/repo stable/' | sudo tee /etc/apt/sources.list.d/neo4j.list sudo apt-get update sudo apt-get install neo4j
```
在我的系统中，出于某些原因，我创建好 `/var/run/neo4j` 之后它就可以很轻松地开始了。Neo4j 给了一个“最大打开文件数”的警告，但因为是测试环境所以我不太需要关心这个问题。Neo4j 默认只会监听本机 localhost 上的连接。如果你的机器是 Debian ，那这很好，但是我的不是。我修改了 `/etc/neo4j/neo4j.conf` ，取消注释了下面这行：
```
dbms.connectors.default_listen_address=0.0.0.0
```
在重启 Neo4j 之后，我可以通过 7474 端口来访问服务器的 Neo4j 服务。默认的用户名和密码是 `Neo4j` 和 `neo4j`； 你需要设置一个新密码，然后会出现初始页面：
让我们在 Neo4j 上创建[上篇文章](/article-8728-1.html)中使用过的图。如下图：
类似 MySQL 和其它的数据库系统，Neo4j 的各类操作也使用一套查询语句。Cypher，就是 Neo4j 使用的查询语句，但有一些语法区别需要去学习和注意。<ruby> 节点 <rt> node </rt></ruby>需要用圆括号表示，而<ruby> 关系 <rt> relationship </rt></ruby> 需要放在方括号中。因为这是系统中唯二的数据类型，所以了解这些就够了。
首先，我们创建所有的节点。你需要将下面内容复制黏贴到浏览器顶部区域中，在那里运行查询语句。
```
CREATE (a:Person { name: 'Jane Doe', favorite_color: 'purple' }) CREATE (b:Person { name: 'John Doe' }) CREATE (c:Person { name: 'Mary Smith', favorite_color: 'red', dob: '1992-11-09' }) CREATE (d:Person { name: 'Robert Roe' }) CREATE (e:Person { name: 'Rhonda Roe' }) CREATE (f:Person { name: 'Ryan Roe' }) CREATE (t:City { name: 'Petaluma, CA' }) CREATE (u:City { name: 'Cypress, TX' }) CREATE (v:City { name: 'Grand Prairie, TX' }) CREATE (w:City { name: 'Houston, TX' })
```
注意，在标签前的字符就是变量。这些信息会在出现在各个地方，但我们在这里并不会用到。但你不能不指定相应信息就盲目创建，所以我们使用它们然后就忽略它们。
在上面一共创建了 10 个节点和 13 个属性。想查看它们？ 通过下面语句来匹配查询所有节点：
```
MATCH (n) RETURN n
```
这条语句会返回一个可视化的图。（在应用内，你可以在返回的图中使用”全屏”按钮来查看大图)。你将会看到类似下面的图像：
添加关系需要一点技巧；你需要连接的节点必须是 “<ruby> 在限定范围内的 <rt> in scope </rt></ruby>”，意思连接的节点是在当前查询语句所限定的范围内的。我们之前使用的查询语句范围太大，所以让我们找到 John 和 Jane 并让他们结婚：
```
MATCH (a:Person),(b:Person) WHERE a.name='Jane Doe' AND b.name='John Doe' CREATE (a)-[r:MARRIAGE {date: '2017-03-04', place: 'Houston, TX'}]->(b)
```
这条语句会创建一个关系并设置两个属性。重新运行该 `MATCH` 语句会显示那个关系。你可以通过鼠标点击任意的节点或关系来查看它们的属性。
我们来添加其它的关系。比起使用一些列的 `MATCH` 语句，我会一次性做完并从中 `CREATE` 创建多个关系。
```
MATCH (a:Person),(b:Person),(c:Person),(d:Person),(e:Person),(f:Person),(t:City),(u:City),(v:City),(w:City) WHERE a.name='Jane Doe' AND b.name='John Doe' AND c.name='Mary Smith' AND d.name='Robert Roe' AND e.name='Rhonda Roe' AND f.name='Ryan Roe' AND t.name='Petaluma, CA' AND u.name='Cypress, TX' AND v.name='Grand Prairie, TX' AND w.name='Houston, TX' CREATE (d)-[m2:MARRIAGE {date: '1990-12-01', place: 'Chicago, IL'}]->(e) CREATE (a)-[n:CHILD]->(c) CREATE (d)-[n2:CHILD]->(f) CREATE (e)-[n3:CHILD]->(f) CREATE (b)-[n4:STEPCHILD]->(c) CREATE (a)-[o:BORN_IN]->(v) CREATE (b)-[o2:BORN_IN]->(t) CREATE (c)-[p:DATING]->(f) CREATE (a)-[q:LIVES_IN]->(u) CREATE (b)-[q1:LIVES_IN]->(u) CREATE (a)-[r:WORKS_IN]->(w) CREATE (a)-[s:FRIEND]->(d) CREATE (a)-[s2:FRIEND]->(e)
```
重新运行该 `MATCH` 语句，你将会看到下面图像：
如果你喜欢，你可以将节点拖拉成像我之前画的图的样子。
在这个例子中，我们唯一使用的 `MATCH` 就是 `MATCH` 所有的东西。下面这个查询会返回两个结婚了的夫妻并显示他们之间的关系：
```
MATCH (a)-[b:MARRIAGE]->(c) RETURN a,b,c
```
在一个更复杂的图中，你可以做更多的细节查询。（LCTT 译注：此例子为 Neo4j 自带例子的）例如，你有关于电影和人的节点，还有像 `ACTED IN`、`DIRECTED`、`WROTE SCREENPLAY` 等属性的关系，你可以运行下面这个查询：
```
MATCH (p:Person { name: 'Mel Gibson' })--(m:Movie) RETURN m.title
```
……上述是查询和 Mel Gibson 相关的所有影片。但如果你想查询他演过的所有电影，下面这条语句会更有用：
```
MATCH (p:Person { name: 'Mel Gibson' })-[r:ACTED_IN]->(m:movie) RETURN m.title,r.role
```
还有更多更炫酷的 Cypher 语句可以使用，但我们就简单介绍这些。更详细完整的 Cypher 语句可以在 Neo4j 的[官网](https://neo4j.com/docs/developer-manual/current/cypher/)上查看, 并且也有很多例子可以练习。
在此系列的下篇文章中，我们会通过写些 Perl 脚本来展示如何在应用中使用图数据库。
---
via: <https://opensource.com/article/17/7/neo4j-graph-databases-getting-started>
作者：[Ruth Holloway](https://opensource.com/users/druthb) 译者：[happygeorge01](https://github.com/happygeorge01) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
将安装了 CentOS/RHEL 6/7 的机器转变成路由器
|
Shusain
|
http://linuxtechlab.com/turning-centosrhel-6-7-machine-router/
|
与其使用专用硬件，不如让我们用 Linux 机器转换成路由器来用。
|
/data/attachment/album/201712/20/000147x3n8s6z8su86zrhz.jpg.thumb.jpg
|
/data/attachment/album/201712/20/000147x3n8s6z8su86zrhz.jpg
| true | false | true |
lujun9972
| false |
[
"路由器",
"NAT"
] |
系统运维
|
{
"viewnum": 8202,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
与其使用专用硬件，不如让我们用 Linux 机器转换成路由器来用。
| 2017-12-20T08:45:00 | 2017-12-20T08:45:00 | 9,159 |
/article-9159-1.html
|
在本文中，我们将学习通过使用 NAT 技术将安装有 RHEL/CentOS 6 & 7 的机器转变成路由器来用。 我们都知道，路由器是一个工作在第三层的网络设备，用于将两个或多个网络连接在一起，即，将局域网连接上广域网上或者局域网直接互联。 路由器非常昂贵，尤其对于小型组织来说更是如此，这可能是我们关注路由器的一个原因。 与其使用专用硬件，不如让我们用 Linux 机器转换成路由器来用。
RHEL/CentOS 6 和 7 上的操作过程我们都会讲。但在开始之前， 让我们先看看需要准备那些东西。
### 前期条件
1、 一台装有 RHEL/CentOS 6 或 7 的机器
2、两块分别配有本地 IP 和外网 IP 的网卡
我们需要为两个网卡都分配 IP 地址，一个本地网络的 IP（由我们的网络管理员提供），另一个是互联网 IP（由 ISP 提供）。 像这样：
```
Ifcfg-en0s3 192.168.1.1 (LAN IP address)
Ifcfg-en0s5 10.1.1.1 (WAN IP address)
```
**注意** 不同 Linux 发行版的网卡名是不一样的。
现在准备工作完成了，可以进行配置了。
### 步骤 1 启用 IP 转发
第一步，我们启用 IP 转发。 这一步在 RHEL/CentOS 6 和 7 上是相同的。 运行
```
$ sysctl -w net.ipv4.ip_forward=1
```
但是这样会在系统重启后恢复。要让重启后依然生效需要打开
```
$ vi /etc/sysctl.conf
```
然后输入下面内容，
```
net.ipv4.ip_forward = 1
```
保存并退出。现在系统就启用 IP 转发了。
### 步骤 2 配置 IPtables/Firewalld 的规则
下一步我们需要启动 IPtables/firewalld 服务并配置 NAT 规则，
```
$ systemctl start firewalld (For Centos/RHEL 7)
$ service iptables start (For Centos/RHEL 6)
```
然后运行下面命令来配置防火墙的 NAT 规则：
```
CentOS/RHEL 6
$ iptables -t nat -A POSTROUTING -o XXXX -j MASQUERADE
$ service iptables restart
CentOS/RHEL 7
$ firewall-cmd -permanent -direct -passthrough ipv4 -t nat -I POSTROUTING -o XXXX -j MASQUERADE -s 192.168.1.0/24
$ systemctl restart firewalld
```
这里，`XXXX` 是配置有外网 IP 的那个网卡名称。 这就将 Linux 机器配置成了路由器了， 下面我们就可以配置客户端然后测试路由器了。
### 步骤 3 配置客户端
要测试路由器，我们需要在客户端的网关设置成内网 IP， 本例中就是 192.168.1.1。 因此不管客户机是 Windows 还是 Linux， 请先确保网关是 192.168.1.1。 完成后， 打开终端或命令行并 `ping` 一个网站来测试客户端是否能访问互联网了：
```
$ ping google.com
```
我们也可以通过网络浏览器访问网站的方式来检查。
---
via: <http://linuxtechlab.com/turning-centosrhel-6-7-machine-router/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
你或许不知道的实用 GNOME Shell 快捷键
|
Ada Ivanova
|
https://www.maketecheasier.com/gnome-shell-keyboard-shortcuts/
|
由于 Ubuntu 在 17.10 发行版本中转移到了 GNOME Shell，许多用户可能对那些实用的快捷键以及创建自己的快捷键感兴趣。这篇文章就是介绍这两方面的。
|
/data/attachment/album/201712/20/222353d9kt00zgiimb0ttz.jpg.thumb.jpg
|
/data/attachment/album/201712/20/222353d9kt00zgiimb0ttz.jpg
| true | false | true |
imquanquan
| false |
[
"GNOME",
"快捷键"
] |
桌面应用
|
{
"viewnum": 7056,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
由于 Ubuntu 在 17.10 发行版本中转移到了 GNOME Shell，许多用户可能对那些实用的快捷键以及创建自己的快捷键感兴趣。这篇文章就是介绍这两方面的。
| 2017-12-20T22:23:50 | 2017-12-20T22:23:50 | 9,160 |
/article-9160-1.html
|
由于 Ubuntu 在 17.10 发行版本中转移到了 GNOME Shell，许多用户可能对那些实用的快捷键以及创建自己的快捷键感兴趣。这篇文章就是介绍这两方面的。
### 已有的便捷的 GNOME Shell 快捷键
如果你希望 GNOME 有成百上千种快捷键，你会失望地发现，情况并非如此。快捷键的列表不会太长，而且并不是全部都对你有用，但仍然会有许多快捷键可以用得上的。
可以通过菜单“设置 -> 设备 -> 键盘”访问快捷方式列表。以下是一些不太流行但实用的快捷方式。
* `Ctrl` + `Alt` + `T` - 这是一个用来启动终端的快捷键组合，你可以在 GNOME 的任何地方使用它。
我个人经常使用的两个快捷键是：
* `Alt` + `F4` - 关闭最顶层端口
* `Alt` + `F8` - 调整窗口大小
大多数人都知道如何用 `Alt` + `Tab` 在打开的应用程序窗口之间，但是你可能不知道可以使用 `Alt` + `Shift` + `Tab` 在应用程序窗口之间进行反方向切换。
在切换窗口界面时，另一个有用的组合键是 `Alt` + `~` （`tab` 键上面的一个键）。
要是你想显示活动概览，你可以用快捷键 `Alt` + `F1`。
有很多跟工作台有关的快捷键。如果你像我那样不经常使用多个工作台的话，这些快捷键对来说是没用的。尽管如此，以下几个快捷键还是值得留意的：
* `Super` + `PageUp` （或者 `PageDown` ）移动到上方或下方的工作台
* `Ctrl` + `Alt` + `Left` （或 `Right` ）移动到左侧或右侧的工作台
如果在这些快捷键中加上 `Shift` ，例如 `Shift` + `Ctrl` + `Alt` + `Left`，则可以把当前窗口移动到其他工作区。
另一个我最喜欢是辅助功能中的调整文字大小的快捷键。你可以用 `Ctrl` + `+` （或 `Ctrl` + `-` ）快速缩放字体大小。在某些情况下，这个快捷键可能默认是禁用的，所以在尝试之前请先检查一下。
上述是一些鲜为人知但是十分实用的键盘快捷键。如果你想知道更多实用的快捷键，可以查看[官方 GNOME Shell 快捷键列表](https://wiki.gnome.org/Projects/GnomeShell/CheatSheet)。
### 如何创建自己的 GNOME Shell 快捷键
如果默认的快捷键不符合您的喜好，可以更改它们或创建新的快捷键。你同样可以通过菜单“设置 -> 设备 -> 键盘“完成这些操作。当你选择想更改的快捷键条目时，下面的对话框就会弹出。
输入你想要的键盘快捷键组合。
如果这个快捷键已经被使用，你会得到一个消息。如果没有，只需点击设置，就完成了。
如果要添加新快捷键而不是更改现有快捷键，请向下滚动，直到看到 “+” 标志，单击它，在出现的对话框中输入新键盘快捷键的名称和快捷键组合。
GNOME 默认情况下并没有提供大量的 shell 快捷键，上面列出的是一些比较实用的快捷键。如果这些快捷键对你来说不够，你可以随时创建自己的快捷键。
---
via: <https://www.maketecheasier.com/gnome-shell-keyboard-shortcuts/>
作者：[Ada Ivanova](https://www.maketecheasier.com/author/adaivanoff/) 译者：[imquanquan](https://github.com/imquanquan) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
LinchPin：一个使用 Ansible 的简化的编配工具
|
Clint Savage
|
https://opensource.com/article/17/6/linchpin
|
2016 年末开始的 LinchPin，现在已经拥有一个 Python API 和一个成长中的社区。
|
/data/attachment/album/201712/21/224543hbqbz5m6xgmmuscm.png.thumb.jpg
|
/data/attachment/album/201712/21/224543hbqbz5m6xgmmuscm.png
| true | false | true |
qhwdw
| false |
[
"编排",
"编配"
] |
容器与云
|
{
"viewnum": 4990,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
2016 年末开始的 LinchPin，现在已经拥有一个 Python API 和一个成长中的社区。
| 2017-12-21T22:46:28 | 2017-12-21T22:46:28 | 9,161 |
/article-9161-1.html
|
>
> 2016 年末开始的 LinchPin，现在已经拥有一个 Python API 和一个成长中的社区。
>
>
>
去年，[我的团队公布了](http://sexysexypenguins.com/posts/introducing-linch-pin/) [LinchPin](http://linch-pin.readthedocs.io/en/develop/)，这是一个使用 Ansible 的混合云<ruby> 编配 <rt> orchestration </rt></ruby>工具。<ruby> 配给 <rt> provision </rt></ruby>云资源从来没有这么容易便捷过。借助 Ansible 强力支持，LinchPin 专注于简化，使云资源让用户可以触手可及。在这篇文章中，我将介绍 LinchPin，并且去看看过去的 10 个月该项目是如何逐渐成熟。
（LCTT 译注：关于 orchestration 应该翻译成惯例的“编排”还是“编配”，有个 @wffger 提出的[建议](https://github.com/LCTT/TranslateProject/issues/6715) ，欢迎大家参与讨论。）
LinchPin 刚出现的时候，使用 `ansible-playbook` 命令去运行 LinchPin ，虽然可以完成，但是还是很复杂的，LinchPin 现在有一个前端命令行用户界面（CLI），它是用 [Click](http://click.pocoo.org/) 写的，而且它使 LinchPin 比以前更简化。
没有止步于 CLI，LinchPin 现在还有一个 [Python](https://opensource.com/resources/python) API，它可以用于管理资源，比如，Amazon EC2 和 OpenStack 实例、网络、存储、安全组等等。这个 API [文档](http://linchpin.readthedocs.io/en/develop/libdocs.html) 可以在你想去尝试 LinchPin 的 Python API 时帮助你。
### Playbook 是一个库
因为 LinchPin 的核心是 [Ansible playbook](http://docs.ansible.com/ansible/playbooks.html)，其角色、模块、过滤器，以及任何被称为 Ansible 模块的东西都被移进 LinchPin 库中，这意味着我们虽然可以直接调用 playbook，但它不是资源管理的首选机制。`linchpin` 可执行文件事实上已经成为该命令行的前端。
### 深入了解命令行
让我们深入了解 `linchpin` 命令行：
```
$ linchpin
Usage: linchpin [OPTIONS] COMMAND [ARGS]...
linchpin: hybrid cloud orchestration
Options:
-c, --config PATH Path to config file
-w, --workspace PATH Use the specified workspace if the familiar Jenkins
$WORKSPACE environment variable is not set
-v, --verbose Enable verbose output
--version Prints the version and exits
--creds-path PATH Use the specified credentials path if WORKSPACE
environment variable is not set
-h, --help Show this message and exit.
Commands:
init Initializes a linchpin project.
up Provisions nodes from the given target(s) in...
destroy Destroys nodes from the given target(s) in...
```
你可以立即看到一个简单的描述，以及命令的选项和参数。这个帮助的最下面的三个命令是本文的重点内容。
#### 配置文件
之前有个名为 `linchpin_config.yml` 的文件。但现在这个文件没有了，替换它的是一个 ini 形式的配置文件，称为 `linchpin.conf`。虽然这个文件可以被修改或放到别的地方，它可以放置在配置文件容易找到的库路径中。在多数情况下，`linchpin.conf` 文件是不需要去修改的。
#### 工作空间
<ruby> 工作空间 <rt> workspace </rt></ruby>是一个定义好的文件系统路径，它是一个逻辑上的资源组。一个工作空间可以认为是一个特定环境、服务组、或其它逻辑组的一个单点。它也可以是一个所有可管理资源的大的存储容器。
工作空间可以在命令行上使用 `--workspace` （`-w`） 选项去指定，随后是工作空间路径。它也可以使用环境变量指定（比如，bash 中的 `$WORKSPACE`）。默认工作空间是当前目录。
#### 初始化 (`linchpin init`)
运行 `linchpin init` 将生成一个需要的目录结构，以及一个 `PinFile`、`topology`、和 `layout` 文件的示例：
```
$ export WORKSPACE=/tmp/workspace
$ linchpin init
PinFile and file structure created at /tmp/workspace
$ cd /tmp/workspace/
$ tree
.
├── credentials
├── hooks
├── inventories
├── layouts
│ └── example-layout.yml
├── PinFile
├── resources
└── topologies
└── example-topology.yml
```
在这个时候，可以执行 `linchpin up` ，然后提供一个 `libvirt` 虚拟机，和一个名为 `linchpin-centos71` 的网络。会生成一个<ruby> 库存 <rt> inventory </rt></ruby>，并放在 `inventories/libvirt.inventory` 目录中。它可以通过读取 `topologies/example-topology.yml` 和 `topology_name` 的值了解它。
#### <ruby> 配给 <rt> provisioning </rt></ruby> (`linchpin up`)
一旦有了一个 PinFile、拓扑、和一个可选的布局，就可以<ruby> 配给 <rt> provisioning </rt></ruby>了。
我们使用 dummy （模拟）工具，因为用它来配给非常简单；它不需要任何额外的东西（认证、网络、等等）。dummy 配给程序会创建一个临时文件，它表示所配给的主机。如果临时文件没有任何数据，说明主机没有被配给，或者它已经被销毁了。
dummy 配给程序的目录树大致如下：
```
$ tree
.
├── hooks
├── inventories
├── layouts
│ └── dummy-layout.yml
├── PinFile
├── resources
└── topologies
└── dummy-cluster.yml
```
PinFile 也很简单；它指定了它的拓扑，并且为 `dummy1` 目标提供一个可选的布局：
```
---
dummy1:
topology: dummy-cluster.yml
layout: dummy-layout.yml
```
`dummy-cluster.yml` 拓扑文件是一个引用，指向到配给的三个 `dummy_node` 类型的资源：
```
---
topology_name: "dummy_cluster" # topology name
resource_groups:
-
resource_group_name: "dummy"
resource_group_type: "dummy"
resource_definitions:
-
name: "web"
type: "dummy_node"
count: 3
```
执行命令 `linchpin up` 将基于上面的 `topology_name`（在这个案例中是 `dummy_cluster`）生成 `resources` 和 `inventory` 文件。
```
$ linchpin up
target: dummy1, action: up
$ ls {resources,inventories}/dummy*
inventories/dummy_cluster.inventory resources/dummy_cluster.output
```
要验证 dummy 集群的资源，可以检查 `/tmp/dummy.hosts`：
```
$ cat /tmp/dummy.hosts
web-0.example.net
web-1.example.net
web-2.example.net
```
Dummy 模块为假定的（或模拟的）配给提供了一个基本工具。关于在 OpenStack、AWS EC2、Google Cloud 上和 LinchPin 的更多详细情况，可以去看[示例](https://github.com/CentOS-PaaS-SIG/linchpin/tree/develop/linchpin/examples/topologies)。
#### <ruby> 库存 <rt> inventory </rt></ruby>生成
作为上面提到的 PinFile 的一部分，可以指定一个 `layout`。如果这个文件被指定，并且放在一个正确的位置上，就会为配给的资源自动生成一个用于 Ansible 的静态<ruby> 库存 <rt> inventory </rt></ruby>文件：
```
---
inventory_layout:
vars:
hostname: __IP__
hosts:
example-node:
count: 3
host_groups:
- example
```
当 `linchpin up` 运行完成，资源文件将提供一个很有用的详细信息。特别是，插入到静态库存的 IP 地址或主机名：
```
[example]
web-2.example.net hostname=web-2.example.net
web-1.example.net hostname=web-1.example.net
web-0.example.net hostname=web-0.example.net
[all]
web-2.example.net hostname=web-2.example.net
web-1.example.net hostname=web-1.example.net
web-0.example.net hostname=web-0.example.net
```
#### 卸载 （`linchpin destroy`）
LinchPin 也可以执行资源卸载。卸载动作一般认为该资源是已经配给好的；然而，因为 Ansible 是<ruby> 幂等的 <rt> idempotent </rt></ruby>，`linchpin destroy` 将仅检查确认该资源是启用的。如果这个资源已经是启用的，它将去卸载它。
命令 `linchpin destroy` 也将使用资源和/或拓扑文件去决定合适的卸载过程。
Ansible `dummy` 角色不使用资源，卸载期间仅有拓扑：
```
$ linchpin destroy
target: dummy1, action: destroy
$ cat /tmp/dummy.hosts
-- EMPTY FILE --
```
针对暂时的资源，卸载功能有一些限制，像网络、存储、等等。网络资源可以被用于多个云实例。在这种情况下，执行一个 `linchpin destroy` 某些资源就不能卸载。这取决于每个供应商的实现。查看每个[供应商](https://github.com/CentOS-PaaS-SIG/linch-pin/tree/develop/linchpin/provision/roles)的具体实现。
### LinchPin 的 Python API
在 `linchpin` 命令行中实现的功能大多数都是用 Python API 写的。这个 API，虽然不完整，但它已经成为 LinchPin 工具的至关重要的组件。
这个 API 由下面的三个包组成：
* `linchpin`
* `linchpin.cli`
* `linchpin.api`
该命令行工具是基于 `linchpin` 包来管理的。它导入了 `linchpin.cli` 模块和类，该类是 `linchpin.api` 的子类。这样做的目的是为了允许使用 `linchpin.api` 来做其它的 LinchPin 实现，比如像计划中的 RESTful API。
更多信息，去查看 [Python API library documentation on Read the Docs](http://linchpin.readthedocs.io/en/develop/libdocs.html)。
### Hook
LinchPin 1.0 的其中一个大的变化是转向 hook。hook 的目标是在 `linchpin` 运行期间的特定状态下，允许配置使用更多外部资源。目前的状态有：
* `preup`: 在配给拓扑资源之前运行
* `postup`: 在配给拓扑资源之后运行，并且生成可选的<ruby> 库存 <rt> inventory </rt></ruby>
* `predestroy`: 卸载拓扑资源之前运行
* `postdestroy`: 卸载拓扑资源之后运行
在每种状态下，这些 hooks 允许运行外部脚本。存在几种类型的 hook，包括一个定制的叫做 *Action Managers*。这是一个内置的 Action Manager 的列表：
* `shell`: 允许任何的<ruby> 内联 <rt> inline </rt></ruby>的 shell 命令，或者一个可运行的 shell 脚本
* `python`: 运行一个 Python 脚本
* `ansible`: 运行一个 Ansible playbook，允许传递一个 `vars_file` 和 `extra_vars` 作为 Python 字典
* `nodejs`: 运行一个 Node.js 脚本
* `ruby`: 运行一个 Ruby 脚本
hook 被绑定到一个特定的目标，并且每个目标使用时必须重新声明。将来，hook 将可能是全局的，然后它们在每个目标的 `hooks` 节下命名会更简单。
#### 使用 hook
hook 描述起来非常简单，但理解它们强大的功能却并不简单。这个特性的存在是为了给用户灵活提供那些 LinchPin 开发者所没有考虑到的功能。这个概念可能会带来 ping 一套系统的简单方式，举个实例，比如在运行另一个 hook 之前。
更仔细地去研究 *工作空间* ，你可能会注意到 `hooks` 目录，让我们看一下这个目录的结构：
```
$ tree hooks/
hooks/
├── ansible
│ ├── ping
│ │ └── dummy_ping.yaml
└── shell
└── database
├── init_db.sh
└── setup_db.sh
```
在任何情况下，hook 都可以用在 `PinFile` 中，展示如下：
```
---
dummy1:
topology: dummy-cluster.yml
layout: dummy-layout.yml
hooks:
postup:
- name: ping
type: ansible
actions:
- dummy_ping.yaml
- name: database
type: shell
actions:
- setup_db.sh
- init_db.sh
```
基本概念是有三个 postup 动作要完成。Hook 是从上到下运行的，因此，Ansible `ping` 任务将首先运行，紧接着是两个 shell 任务， `setup_db.sh` 和 `init_db.sh`。假设 hook 运行成功。将发生一个系统的 ping，然后，一个数据库被安装和初始化。
### 认证的驱动程序
在 LinchPin 的最初设计中，开发者决定在 Ansible playbooks 中管理认证；然而，逐渐有更多的 API 和命令行驱动的工具后，意味着认证将被置于 playbooks 库之外，并且还可以根据需要去传递认证值。
#### 配置
让用户使用驱动程序提供的认证方法去完成这个任务。举个实例，如果对于 OpenStack 调用的拓扑，标准方法是使用一个 yaml 文件，或者类似于 `OS_` 前缀的环境变量。`clouds.yaml` 文件是一个 profile 文件的组成部分，它有一个 `auth` 节：
```
clouds:
default:
auth:
auth_url: http://stack.example.com:5000/v2.0/
project_name: factory2
username: factory-user
password: password-is-not-a-good-password
```
更多详细信息在 [OpenStack documentation](https://docs.openstack.org/developer/python-openstackclient/configuration.html)。
这个 `clouds.yaml` 或者任何其它认证文件位于 `default_credentials_path` （比如，`~/.config/linchpin`）中，并在拓扑中引用：
```
---
topology_name: openstack-test
resource_groups:
-
resource_group_name: linchpin
resource_group_type: openstack
resource_definitions:
- name: resource
type: os_server
flavor: m1.small
image: rhel-7.2-server-x86_64-released
count: 1
keypair: test-key
networks:
- test-net2
fip_pool: 10.0.72.0/24
credentials:
filename: clouds.yaml
profile: default
```
`default_credentials_path` 可以通过修改 `linchpin.conf` 改变。
拓扑在底部包含一个新的 `credentials` 节。使用 `openstack`、`ec2`、和 `gcloud` 模块，也可以去指定类似的凭据。认证驱动程序将查看给定的名为 `clouds.yaml` 的文件，并搜索名为 `default` 的 *配置*。
假设认证被找到并被加载，配给将正常继续。
### 简化
虽然 LinchPin 可以完成复杂的拓扑、库存布局、hooks、和认证管理，但是，终极目标是简化。通过使用一个命令行界面的简化，除了提升已经完成的 1.0 版的开发者体验外，LinchPin 将持续去展示复杂的配置可以很简单地去管理。
### 社区的成长
在过去的一年中，LinchPin 的社区现在已经有了 [邮件列表](https://www.redhat.com/mailman/listinfo/linchpin)和一个 IRC 频道（#linchpin on chat.freenode.net，而且在 [GitHub](https://github.com/CentOS-PaaS-SIG/linch-pin/projects/4) 中我们很努力地管理它。
在过去的一年里，社区成员已经从 2 位核心开发者增加到大约 10 位贡献者。更多的人持续参与到项目中。如果你对 LinchPin 感兴趣，可以给我们写信、在 GitHub 上提问，加入 IRC，或者给我们发邮件。
*这篇文章是基于 Clint Savage 在 OpenWest 上的演讲 [Introducing LinchPin: Hybrid cloud provisioning using Ansible](https://www.openwest.org/custom/description.php?id=166) 整理的。[OpenWest](https://www.openwest.org/) 将在 2017 年 7 月 12-15 日在盐城湖市举行。*
---
作者简介：
Clint Savage - 工作于 Red Hat 是一位负责原子项目（Project Atomic）的高级软件工程师。他的工作是为 Fedora、CentOS、和 Red Hat Enterprise Linux（RHEL）提供自动原子服务器构建。
---
via: <https://opensource.com/article/17/6/linchpin>
作者：[Clint Savage](https://opensource.com/users/herlo) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
ESR：程序语言设计的要诣和真谛
|
Eric Raymond
|
http://esr.ibiblio.org/?p=7745
|
为什么一些语言会成功，另一些语言会失败。
|
/data/attachment/album/201712/21/231200wgzslqeqo2qlgdlm.jpg.thumb.jpg
|
/data/attachment/album/201712/21/231200wgzslqeqo2qlgdlm.jpg
| true | false | true |
Valoniakim,yunfengHe
| false |
[
"编程语言"
] |
观点
|
{
"viewnum": 4376,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
为什么一些语言会成功，另一些语言会失败。
| 2017-12-21T23:12:06 | 2017-12-21T23:12:06 | 9,162 |
/article-9162-1.html
|
当你真正掌握了整体化的工程设计思维时，你就会发现高屋建瓴的工程设计已经远远超越了技术优化的层面。我们的每一件创造都催生于人类活动的大背景下，被这种人类活动赋予了广泛的经济学意义、社会学意义，甚至于具有了奥地利经济学家所称的“<ruby> 人类行为学意义 <rt> praxeology </rt></ruby>”。而这种人类行为学意义则是明确的人类行为所能达到的最高层次。
对我来说这并不只是一种抽象的理论。当我在撰写关于开源项目开发的文章时，文章的内容正是关于人类行为学的 —— 这些文章并不涉及哪个具体的软件技术或者话题，而是在讨论科技所服务的人类行为。从人类行为学角度对科技进行更深入的理解，可以帮助我们重塑科技，并且提升我们的生产力和成就感。这种提升并不总是因为我们有了更新的工具，而更多的是因为我们改变了使用现有工具的思路，提升了我们对这些工具的驾驭能力。
在这个思路之下，我的随笔文章的第三篇中谈到了 C 语言的衰退和正在到来的巨大改变，而我们也确实能够感受到系统级别编程的新时代的到来。在这里，我会把我的统观见解总结成更具体的、更实用的对计算机语言设计的分析。例如总结出为什么一些语言会成功，另一些语言会失败。
在我最近的一篇文章中，我写道：所有计算机语言的设计都是对机器资源和程序员人力成本的相对权衡的结果；是对一种相对价值主张的体现。而这些设计思路都是在硬件算力成本不断下降，程序员人力成本相对稳定且可能不减反增的背景下产生的。我还强调了语言设计在实现了一些原有的权衡方案之后，其未来的转化和演变成本在这种语言的成败中所要扮演的一些额外角色。在文中我也阐述了编程语言设计者是如何为当前和可见的未来寻找新的最优设计方案的。
现在我要集中讲解一下我在上面段落里最后提到的那个概念，即语言设计工程师们其实可以在多个方面来改进和提高现阶段编程语言的设计水准。比如输入系统的优化，GC (垃圾回收机制) 和手动内存分配的权衡，命令导向、函数导向和面向对象导向的混合和权衡。但是站在人类行为学的角度去考量，我认为设计师们一定会做出更简单的设计权衡，即针对近景问题还是针对远景问题来优化一种语言的设计。
所谓的“远”、“近”之分，是指随着硬件成本的逐渐降低，软件复杂程度的上升和由现有语言向其他语言转化的成本的增加，根据这些因素的变化曲线所做出的判断。近景问题是编程人员眼下看到的问题，远景问题则是指可预见的，但未必会很快到来的一系列情况。针对近景问题的解决方案可以被很快部署下去，且能够在短期内非常有效，但随着情况的变化和时间的推移，这种方案可能很快就不适用了。而远景的解决方案可能因为其自身的复杂和超前性而夭折，或是因其代价过高无法被接受和采纳。
在计算机刚刚面世的时候， FORTRAN 就是一个近景设计方案， LISP 语言的设计则是针对远景问题；汇编语言多是近景设计方案，很好的阐明了这类设计很适用于非通用语言，同样的例子还包括 ROFF 标记语言。PHP 和 Javascript 则是我们后来看到的采用了近景设计思维的语言。那么后来的远景设计方案有哪些例子呢？ Oberon、Ocaml、ML、XML-Docbook 都是它的例子。学术研究中设计出的语言多倾向于远景设计，因为在学术研究领域，原创性以及大胆的假设与想法是很重要的。这和学术研究的动机以及其奖励机制很有关系（值得注意的是，在学术研究中，倾向于远景设计的本源动机并非出于技术方面的原因，而是出自于人类行为，即标新立异才能在学术上有成绩）。学术研究中设计出的编程语言是注定会失败的；因为学术研究的产物常常有高昂的转入成本，无人问津的设计。这类语言也因为在社区中不够流行而不能得到主流的采纳，具有孤立性，且常常被搁置成为半成品。（如上所述的问题正是对 LISP 历史的精辟总结，而且我是以一个对 LISP 语言有深入研究，并深深喜爱它的使用者的身份来评价 LISP 的）。
一些近景设计的失败案例则更加惨不忍睹。对这些案例来说，我们能够期待的最好的结果就是这种语言可以消亡的相对体面一些，被一种新的语言设计取而代之。如果这些近景设计导向的语言没有死亡而是一直被沿用下去（通常是因为转化成本过高），那么我们则会看到不断有新的特性和功能在这些语言原来的基础之上堆积起来，以保持它们的可用性和有效性。直到这种堆积把这些语言变得越来越复杂，变的危若累卵且不可理喻。是的，我说的就是 C++ 。当然， 还有 Javascript。Perl 也不例外，尽管它的设计者 Larry Walls 有不错的设计品味，避免了很多问题，让这种语言得以存活了很多年。但也正是因为 Larry Walls 的好品味，让他在最终对 Perl 的固有问题忍无可忍之后发布了全新的 Perl 6。
从这种角度去思考程序语言，我们则可以把语言设计中需要侧重的目标重新归纳为两部分: （1）以时间的远近为轴，在远景设计和近景设计之间选取一个符合预期的最佳平衡点；（2）降低由一种或多种语言转化为这种新语言的转入成本，这样就可以更好地吸纳其它语言的用户群。接下来我会讲讲 C 语言是怎样占领全世界的。
在整个计算机发展史中，没有谁能比 C 语言在选择远景和近景设计的平衡点的时候做的更完美。事实胜于雄辩，作为一种实用的主流语言，C 语言有着很长的寿命，它目睹了无数个竞争者的兴衰，但它的地位仍旧不可取代。从淘汰它的第一个竞争者到现在已经过了 35 年，但看起来 C 语言的终结仍旧不会到来。
当然，你可以把 C 语言的持久存在归功于文化惰性，但那是对“文化惰性”这个词的曲解，C 语言一直得以延续的真正原因是因为目前还没有人能提供另一种足够好的语言，可以抵消取代 C 语言所需要的转化成本！
相反的，C 语言低廉的<ruby> 内向转化成本 <rt> inward transition costs </rt></ruby>（转入成本）并未引起大家应有的重视，C 语言几乎是唯一的一个极其多样和强大的编程工具，以至于从它漫长统治时期的初期开始，它就可以适用于多种语言如 FORTRAN、Pascal、汇编语言和 LISP 的编程习惯。在一九八零年代我就注意到，我常常可以根据一个 C 语言新人的编码风格判断出他之前在使用什么语言，这也从另一方面证明了 C 语言可以轻松的被其它语言的使用者所接受，并吸引他们加入进来。
C++ 语言同样胜在它低廉的转化成本。很快，大部分新兴的语言为了降低自身的转入成本，都纷纷参考了 C 语言的语法。值得注意的是这给未来的语言设计带来了一种影响：即新语言的设计都在尽可能的向 C 的语法靠拢，以便这种新语言可以有很低的内向转化成本（转入成本），使其他语言的使用者可以欣然接受并使用这种新语言。
另一种降低转入成本的方法则是把一种编程语言设计的极其简单并容易入手，让那些即使是没有编程经验的人都可以轻松学会。但做到这一点并非易事。我认为只有一种语言 —— Python —— 成功的做到了这一点，即通过易用的设计来降低内向转化成本。对这种程序语言的设计思路我在这里一带而过，因为我并不认为一种系统级别的语言可以被设计的像 Python 一样傻瓜易用，当然我很希望我的这个论断是错的。
而今我们已经来到 2017 年末尾，你一定猜测我接下来会向那些 Go 语言的鼓吹者一样对 Go 大加赞赏一番，然后激怒那些对 Go 不厌其烦的人群。但其实我的观点恰恰相反，我认为 Go 本身很有可能在许多方面遭遇失败。Go 团队太过固执独断，即使几乎整个用户群体都认为 Go 需要做出某些方面的改变了，Go 团队也无动于衷，这是个大问题。目前，Go 语言的 GC 延迟问题以及用以平衡延迟而牺牲掉的吞吐量，都可能会严重制约这种语言的适用范围。
即便如此，在 Go 的设计中还是蕴含了一个让我颇为认同的远大战略目标。想要理解这个目标，我们需要回想一下如果想要取代 C 语言，要面临的短期问题是什么。正如我之前提到的，这个问题就是，随着软件工程项目和系统的不断扩张，故障率也在持续上升，这其中内存管理方面的故障尤其多，而内存管理故障一直是导致系统崩溃和安全漏洞的主要元凶。
我们现在已经认清，一种语言要想取代 C 语言，它的设计就必须遵循两个十分重要准则：（1）解决内存管理问题；（2）降低由 C 语言向本语言转化时所需的转入成本。从人类行为学的角度来纵观编程语言的历史，我们不难发现，作为 C 语言的准替代者，如果不能有效解决转入成本过高这个问题，那设计者所做的其它部分做得再好都不算数。相反的，如果一种 C 的替代语言把转入成本过高这个问题解决地很好，即使它在其他部分做的不是最好的，人们也不会对这种语言吹毛求疵。
而 Go 正是遵循了上述两点设计思路，虽然这个思路并不是一种完美无瑕的设计理论，也有其局限性。比如，目前 GC 延迟的问题就限制了 Go 的推广。但是 Go 目前选择了照搬 Unix 下 C 语言的传染战略，把其自身设计成一种易于转入，便于传播的语言。这样它的广泛和快速的传播就会使其迅速占领市场，从而打败那些针对远景设计的看起来更好的语言。
没错，我所指的这个远景设计方案就是 Rust。而 Rust 的自身定位也正是一种远景和长期的 C 语言替代方案。我曾经在之前的一些文章中解释过我为什么认为 Rust 还没有做好和 Go 展开竞争的准备。TIBOE 和 PYPL 的语言评价指数榜也很好的证明了我的对于 Rust 的这个观点。在 TIBOE 上 Rust 从来没有进过前 20 名。而在 TIBOE 和 PYPL 两个指数榜上， Rust 都要比 Go 的表现差很多。
五年后的 Rust 会发展的怎样还未可知。但如果 Rust 社区的开发人员对这种语言的设计抱着认真投入的态度，并愿意倾听，那么我建议他们要特别重视转入成本的问题。以我个人经历来说，目前由 C 语言转入 Rust 语言的壁垒很高，使人望而却步。如果 Corrode 之类的 Code-lifting 工具只是把 C 语言映射为不安全的 Rust 语言，那么 Corrode 这类工具也是不能解决这种转入壁垒的。或者如果有更简单的方法能够自动注释代码的所有权或生命周期，那么编译器就能把 C 代码直接映射到 Rust，人们也不再需要 Corrode 这一类工具了。目前我还不知道这个问题要如何解决，但我觉得 Rust 社区最好能够找到一种解决方案来代替 Corrode 和其同类工具。
在最后我想强调一下，Ken Thompson 曾经有过语言设计的辉煌历史。他设计的一些语言虽然看起来只是为了解决近景问题，实际上却具有很高的质量和开放程度，让这些语言同样非常适合远景问题，非常易于被提高和拓展。当然 Unix 也是这样的， 这让我不禁暗自揣测，那些我认为的 Go 语言中乍看上去不利于其远景发展的一些令人担忧烦扰的设计（例如缺乏泛型）也许并没有我想象的那样糟糕。如果确如我所认为的那样，即这些设计会影响 Go 的远景发展，那么恐怕我真的是比 Ken 还要聪明有远见了。但是我并不认为我有那么高明。Go 的前途我们还是只能拭目以待。
---
via: <http://esr.ibiblio.org/?p=7745>
作者：[Eric Raymond](http://esr.ibiblio.org/?author=2) 译者：[Valoniakim](https://github.com/Valoniakim)，[yunfengHe](https://github.com/yunfengHe) 校对：[yunfengHe](https://github.com/yunfengHe)，[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 parallel 利用起你的所有 CPU 资源
|
Elliot Cooper
|
https://bash-prompt.net/guides/parallell-bash/
|
bash 命令通常单线程运行。这意味着所有的处理工作只在单个 CPU 上执行。随着 CPU 规模的扩大以及核心数目的增加，这意味着只有一小部分的 CPU 资源用于处理你的工作。
|
/data/attachment/album/201712/22/223428y77ofxfxvxuufcuv.jpg.thumb.jpg
|
/data/attachment/album/201712/22/223428y77ofxfxvxuufcuv.jpg
| true | false | true |
lujun9972
| false |
[
"parallel",
"CPU"
] |
技术
|
{
"viewnum": 9321,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
bash 命令通常单线程运行。这意味着所有的处理工作只在单个 CPU 上执行。随着 CPU 规模的扩大以及核心数目的增加，这意味着只有一小部分的 CPU 资源用于处理你的工作。
| 2017-12-22T22:34:34 | 2017-12-22T22:34:34 | 9,164 |
/article-9164-1.html
|
bash 命令通常单线程运行。这意味着所有的处理工作只在单个 CPU 上执行。随着 CPU 规模的扩大以及核心数目的增加，这意味着只有一小部分的 CPU 资源用于处理你的工作。
当我们的工作受制于 CPU 处理数据的速度时，这些未使用的 CPU 资源能产生很大的效用。这种情况在进行多媒体转换（比如图片和视频转换）以及数据压缩中经常遇到。
本文中，我们将会使用 [parallel](https://www.gnu.org/software/parallel/) 程序。parallel 会接受一个列表作为输入，然后在所有 CPU 核上并行地执行命令来处理该列表。Parallel 甚至会按顺序将结果输出到标准输出中，因此它可以用在管道中作为其他命令的标准输入。
### 如何使用 parallel
parallel 在标准输入中读取一个列表作为输入，然后创建多个指定命令的进程来处理这个列表，其格式为：
```
list | parallel command
```
这里的 list 可以由任何常见的 bash 命令创建，例如：`cat`、`grep`、`find`。这些命令的结果通过管道从它们的标准输出传递到 parallel 的标准输入，像这样：
```
find . -type f -name "*.log" | parallel
```
跟 `find` 中使用 `-exec` 类似，`parallel` 使用 `{}` 来表示输入列表中的每个元素。下面这个例子中，`parallel` 会使用 `gzip` 压缩所有 `find` 命令输出的文件：
```
find . -type f -name "*.log" | parallel gzip {}
```
下面这些实际的使用 `parallel` 的例子可能会更容易理解一些。
### 使用 parallel 来进行 JPEG 压缩
在这个例子中，我收集了一些比较大的 `.jpg` 文件（大约 10MB 大小），要用 [Mozilla](https://www.mozilla.org/) 出品的 JPEG 图像压缩工具 [MozJPEG](https://github.com/mozilla/mozjpeg) 来进行处理。该工具会在尝试保持图像质量的同时减少 JPEG 图像文件的大小。这对降低网页加载时间很重要。
下面是一个普通的 `find` 命令，用来找出当前目录中的所有 `.jpg` 文件，然后通过 MozJPEG 包中提供的图像压缩工具 （`cjpeg`） 对其进行处理：
```
find . -type f -name "*.jpg" -exec cjpeg -outfile LoRes/{} {} ';'
```
总共耗时 `0m44.114s`。该命令运行时的 `top` 看起来是这样的：
你可以看到，虽然有 8 个核可用，但实际只有单个线程在用单个核。
下面用 `parallel` 来运行相同的命令：
```
find . -type f -name "*.jpg" | parallel cjpeg -outfile LoRes/{} {}
```
这次压缩所有图像的时间缩减到了 `0m10.814s`。从 `top` 显示中可以很清楚地看出不同：
所有 CPU 核都满负荷运行，有 8 个线程对应使用 8 个 CPU 核。
### parallel 与 gzip 连用
如果你需要压缩多个文件而不是一个大文件，那么 `parallel` 就能用来提高处理速度。如果你需要压缩单个文件而同时又想要利用所有的 CPU 核的话，那么你应该 `gzip` 的多线程替代品 [pigz](https://zlib.net/pigz/)。
首先，我用随机数据创建了 100 个大约 1GB 的文件：
```
for i in {1..100}; do dd if=/dev/urandom of=file-$i bs=1MB count=10; done
```
然而我用 `find -exec` 命令来进行压缩：
```
find . -type f -name "file*" -exec gzip {} ';'
```
总共耗时 `0m28.028s`，而且也是只利用了单核。
换成 `parallel` 版本：
```
find . -type f -name "file*" | parallel gzip {}
```
耗时减少到了 `0m5.774s`。
parallel 是一款非常好用的工具，应该加入到你的系统管理工具包中，在合适的场合它能帮你节省大量的时间。
---
via: <https://bash-prompt.net/guides/parallell-bash/>
作者：[Elliot Cooper](https://bash-prompt.net/about) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
学习如何高效地使用 man 页
|
Sk
|
https://www.ostechnix.com/learn-use-man-pages-efficiently/
|
一个标准的 man 页分成很多个部分，每部分都有一个独立的标题。当你想查看特定的标志/选项时，可能需要向下滚动很长时间才能找到。这是个效率低下而且很耗时间的过程。
|
/data/attachment/album/201712/22/231438kpp7dhwcjwudddwe.jpg.thumb.jpg
|
/data/attachment/album/201712/22/231438kpp7dhwcjwudddwe.jpg
| true | false | true |
lujun9972
| false |
[
"man"
] |
技术
|
{
"viewnum": 7503,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
一个标准的 man 页分成很多个部分，每部分都有一个独立的标题。当你想查看特定的标志/选项时，可能需要向下滚动很长时间才能找到。这是个效率低下而且很耗时间的过程。
| 2017-12-22T23:14:59 | 2017-12-22T23:14:59 | 9,165 |
/article-9165-1.html
|
不久前，我们发布了一篇简短的指引描述了如何轻易地[回忆起忘记的 Linux 命令](https://www.ostechnix.com/easily-recall-forgotten-linux-commands/) 。那篇指引对于无法记住命令的人来说真的非常有用。今天，我们就来学习一下如何高效而又迅速地从 man 页中获取你所需要的信息。如你所知，一个标准的 man 页分成很多个部分，每部分都有一个独立的标题。当你想查看特定的标志/选项时，可能需要向下滚动很长时间才能找到。这是个效率低下而且很耗时间的过程。这也是为什么学会高效使用 man 页来精确定位你想要的内容。
在本文中，我会分享一些常用的跟 man 页相关的重要技巧。
### 学习高效地使用 Man 页
#### 基础用法
我们都知道，我们可以使用类似下面的命令来打开关于某个命令（比如 `mkdir`）的 man 页：
```
man mkdir
```
可以使用 `空格`，`d`，`b` 以及上下箭头等来浏览 man 页。要跳转道 man 页的末尾，可以按 `End` 键而想跳转到 man 页的头部则可以按 `Home` 键。在当前打开的 man 页中按下 `h` 键会显示所有有用的键盘快捷键和一般用法。（LCTT 译注：这些快捷键其实是 man 所使用的 less 分页器的快捷键）
按 `q` 可以退出 man 页。
#### 回忆起忘记的命令
对于那些不知道想要哪个命令的家伙，可以去查看一下我第一段中提到的那个链接。使用 man 页我们也能做到这一点。假设说，你想要创建一个目录，而你忘记了使用哪个命令来创建目录。
为了回忆起那个忘记的命令，可以将 man 和 `grep` 命令联用：
```
man -k directory | grep create
```
输出结果为：
```
CURLOPT_NEW_DIRECTORY_PERMS (3) - permissions for remotely created directories
libssh2_sftp_mkdir_ex (3) - create a directory on the remote file system
mkdir (2) - create a directory
mkdirat (2) - create a directory
mkdtemp (3) - create a unique temporary directory
mkdtemp (3p) - create a unique directory or file
mkfontdir (1) - create an index of X font files in a directory
mklost+found (8) - create a lost+found directory on a mounted Linux second extended file。。。
mkstemp (3p) - create a unique directory
mktemp (1) - create a temporary file or directory
pam_mkhomedir (8) - PAM module to create users home directory
```
你只需要阅读一下每个命令的描述然后挑选出合适的命令就行了。啊，现在你记起来了。`mkdir` 正式你想要的，对吧？就是那么简单。
#### 在 man 页中搜索
若你在 man 页中想要查找特定字符串。只需要输入 `/` （前斜线）再加上你想要搜索的字符串，像这样：
```
/<search_string> 或 <pattern>
```
假设你正在查看 `mount` 命令的 man 页，想要寻找关于 `-bind` 选项的相关信息。可以输入：
```
/bind
```
当前 man 页中任何匹配搜索字符串的内容都会被高亮显示。
按下 `n` 和 `SHIFT+n` 来查看下一个/上一个匹配的地方。
`/` 模式（或者说字符串）会向前搜索匹配行。你也可以使用 `?` 模式进行向后搜索。这当你在 man 页的末尾或中间位置时非常有用。
```
?bind
```
若想只显示匹配行，输入：
```
&bind
```
使用这种方法，你无需使用 `n` 和 `SHIFT+n` 来滚动到下一个/上一个匹配的位置。`&` 模式只会显示那些包含搜索内容的行，其他的内容全都被省略掉。
#### 不打开 man 页而进行搜索
也可以在不打开 man 页的前提下搜索指定选项的信息。
比如，你想了解 `mkdir` 命令中的 `-m` 选项的相关信息。可以运行：
```
man mkdir | grep -e '-m'
```
或者，
```
man mkdir | grep -- '-m'
```
这个命令会显示出 `mkdir` 命令 man 页中第一次出现 `-m` 时的内容。从上面命令中我们可以看到 `-m` 表示的是 “MODE”（`chmod`）。
如果你想阅读 `mkdir` 命令的完整 man 页，但是要跳过第一次出现 `-m` 之前的内容，可以使用下面命令：
```
man mkdir | less +/-m
```
这是另一个例子：
```
man mount | less +/--bind
```
按下 `n` 或 `SHIFT+n` 可以浏览下一个/上一个匹配的位置。
参考阅读：[每个 Linux 用户都应该知道的 3 个 man 页替代品](https://www.ostechnix.com/3-good-alternatives-man-pages-every-linux-user-know/)。
#### 将完整的 man 页导出到文本文件中
我们可以将指定命令的完整 man 页导出成文本文件。方法是运行下面命令：
```
man mount > mount.txt
```
该命令会将 `mount` 命令的 man 页导出到当前目录的 `mount.txt` 文件中。
也可以获取一个简化版的 man 页，没有退格和下划线，方法是使用下面命令。
```
man mount | col -b > mount.txt
```
要了解更多关于 man 页的详细信息，运行：
```
man man
```
该命令会显示出关于 man 的 man 页。这些技巧都很基础但很实用。它们会节省你很多的时间而且能免去很多的滚动操作。
今天的内容就到这了。希望对你有帮助。更多好文即将到来。准备好哦！
Cheers！
（题图：Pixabay， CC0）
---
via: <https://www.ostechnix.com/learn-use-man-pages-efficiently/>
作者：[SK](https://www.ostechnix.com/author/sk/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[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/long-term-linux-support-future-clarified/
|
Linux 4.4 长期支持版（LTS）将得到 6 年的使用期，但是这并不意味着其它长期支持版的使用期将持续这么久。
|
/data/attachment/album/201712/23/103032k7z75ff56iv17565.png.thumb.jpg
|
/data/attachment/album/201712/23/103032k7z75ff56iv17565.png
| true | false | true |
liuxinyu123
| false |
[
"内核",
"LTS"
] |
新闻
|
{
"viewnum": 5938,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "222.71.162.162",
"message": "看来linux内核已经足够稳定了",
"username": "mistyos [Firefox 57.0|Ubuntu]",
"date": "2017-12-23T23:24:48"
}
] |
[] |
Linux 4.4 长期支持版（LTS）将得到 6 年的使用期，但是这并不意味着其它长期支持版的使用期将持续这么久。
| 2017-12-23T10:30:00 | 2017-12-23T10:30:00 | 9,166 |
/article-9166-1.html
|
>
> Linux 4.4 长期支持版（LTS）将得到 6 年的使用期，但是这并不意味着其它长期支持版的使用期将持续这么久。
>
>
>
*视频: Torvalds 对内核版本 2.6 的弹性感到惊讶*
在 2017 年 10 月，[Linux 内核小组同意将 Linux 长期支持版（LTS）的下一个版本的生命期从两年延长至六年](http://www.zdnet.com/article/long-term-support-linux-gets-a-longer-lease-on-life/)，而 LTS 的下一个版本正是 [Linux 4.14](http://www.zdnet.com/article/the-new-long-term-linux-kernel-linux-4-14-has-arrived/)。这对于 [Android](https://www.android.com/)，嵌入式 Linux 和 Linux 物联网（IoT）的开发者们是一个利好。但是这个变动并不意味着将来所有的 Linux LTS 版本将有 6 年的使用期。
正如 [Linux 基金会](https://www.linuxfoundation.org/)的 IT 技术设施安全主管 Konstantin Ryabitsev 在 Google+ 上发文解释说，“尽管外面的各种各样的新闻网站可能已经告知你们，但是[内核版本 4.14 的 LTS 并不计划支持 6 年](https://plus.google.com/u/0/+KonstantinRyabitsev/posts/Lq97ZtL8Xw9)。只是因为 Greg Kroah-Hartman 正在为 LTS 4.4 版本做这项工作并不表示从现在开始所有的 LTS 内核会维持那么久。”
所以，简而言之，Linux 4.14 将支持到 2020 年 1月份，而 2016 年 1 月 20 号问世的 Linux 4.4 内核将支持到 2022 年。因此，如果你正在编写一个打算能够长期运行的 Linux 发行版，那你需要基于 [Linux 4.4 版本](http://www.zdnet.com/article/whats-new-and-nifty-in-linux-4-4/)。
[Linux LTS 版本](https://www.kernel.org/releases.html)包含对旧内核树的后向移植漏洞的修复。不是所有漏洞的修复都被导入进来，只有重要漏洞的修复才用于这些内核中。它们不会非常频繁的发布，特别是对那些旧版本的内核树来说。
Linux 其它的版本有<ruby> 尝鲜版 <rt> Prepatch </rt></ruby>或发布候选版（RC）、<ruby> 主线版 <rt> Mainline </rt></ruby>，<ruby> 稳定版 <rt> Stable </rt></ruby>和 LTS 版。
RC 版必须从源代码编译并且通常包含漏洞的修复和新特性。这些都是由 Linux Torvalds 维护和发布的。他也维护主线版本树（这是所有新特性被引入的地方）。新的主线内核每几个月发布一次。当主线版本树发布以便通用时，它被称为“稳定版”。稳定版的内核漏洞修复是从主线版本树后向移植的，并且这些修复是由一个指定的稳定版内核维护者来申请。在下一个主线内核变得可用之前，通常也有一些修复漏洞的内核发布。
对于最新的 LTS 版本，Linux 4.14，Ryabitsev 说，“Greg 已经担负起了 4.14 版本的维护者责任（过去发生过多次），其他人想成为该版本的维护者也是有可能的，但是你最后不要指望。"
Kroah-Hartman 对 Ryabitsev 的帖子回复道：“[他说神马。](https://plus.google.com/u/0/+gregkroahhartman/posts/ZUcSz3Sn1Hc)”
---
via: <http://www.zdnet.com/article/long-term-linux-support-future-clarified/>
作者：[Steven J. Vaughan-Nichols](http://www.zdnet.com/meet-the-team/us/steven-j-vaughan-nichols/) 译者：[liuxinyu123](https://github.com/liuxinyu123) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
胜利的沙龙！Linux 中国 2017 线下联合沙龙闭幕
|
老王
|
让我们期待，一个月以后的沙龙再次举办，也希望下次我们可以有更多的城市共同举办，并且让更多的同学来参与，并讲演自己的知识和见解！
|
/data/attachment/album/201712/23/223643pmfl4lbf0fomff04.jpg.thumb.jpg
|
/data/attachment/album/201712/23/223643pmfl4lbf0fomff04.jpg
| true | false | false | false |
[
"Linux中国",
"沙龙"
] |
新闻
|
{
"viewnum": 6282,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9126,
"displayorder": 0
}
] |
让我们期待，一个月以后的沙龙再次举办，也希望下次我们可以有更多的城市共同举办，并且让更多的同学来参与，并讲演自己的知识和见解！
| 2017-12-23T22:36:00 | 2017-12-23T22:36:00 | 9,167 |
/article-9167-1.html
|
时值年末，我们 Linux 中国在北上广成组织了一次线下沙龙，来自北上广成等多个城市的朋友们欢聚在这四个城市，成功地将友谊从线上连接到了线下。
这次沙龙，是分别在北上广成四个城市分别举办的，并在期间多个城市进行了视频互联。大家俨如多年未见的好友，畅聊了开源、Linux、互联网、区块链、运维、开发、安全等等各种话题。老王我这次参与了北京的沙龙，并全程口若悬河谈了许多话题；据闻上海、广州和成都也都聊得非常尽兴。
这次参与的人员当中，很多人都是 Linux 中国多年的成员，其中不少人是 LCTT 成员。当然，也有许多新朋友。其中据闻有一位最小参与者才上初二！
下面分享一些各地的沙龙精彩照片：
总之，这次沙龙聚会，取得了超乎预期的成功，本次参会的很多小伙伴们也得到由人邮出版社傅主编赞助的书籍（其中有棣琦翻译的《Linux 二进制分析》，北京站更有荣幸得到译者亲自签名！）。
让我们期待，一个月以后的沙龙再次举办，也希望下次我们可以有更多的城市共同举办，并且让更多的同学来参与，并讲演自己的知识和见解！
欢迎希望参与线下沙龙的同学，加微信群助手 “#群主”（微信号：**china\_linux**）好友，并对她说“沙龙”，获得进入微信群的邀请。
|
||||
逻辑卷管理（LVM） Linux 用户指南
|
David Both
|
https://opensource.com/business/16/9/linux-users-guide-lvm
|
我想告诉你的是，当 LVM （逻辑卷管理）首次出现在 Fedora Linux 中时，我是非常抗拒它的。我最初的反应是，我并不需要在我和我的设备之间有这种额外的抽象层。结果是我错了，逻辑卷管理是非常有用的。
|
/data/attachment/album/201712/24/071337ok3v1fvyv8yy7vpv.png.thumb.jpg
|
/data/attachment/album/201712/24/071337ok3v1fvyv8yy7vpv.png
| true | false | true |
qhwdw
| false |
[
"LVM",
"分区",
"磁盘"
] |
技术
|
{
"viewnum": 7913,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我想告诉你的是，当 LVM （逻辑卷管理）首次出现在 Fedora Linux 中时，我是非常抗拒它的。我最初的反应是，我并不需要在我和我的设备之间有这种额外的抽象层。结果是我错了，逻辑卷管理是非常有用的。
| 2017-12-24T07:13:33 | 2017-12-24T07:13:33 | 9,168 |
/article-9168-1.html
|
管理磁盘空间对系统管理员来说是一件重要的日常工作。一旦磁盘空间耗尽就需要进行一系列耗时而又复杂的任务，以提升磁盘分区中可用的磁盘空间。它也需要系统离线才能处理。通常这种任务会涉及到安装一个新的硬盘、引导至恢复模式或者单用户模式、在新硬盘上创建一个分区和一个文件系统、挂载到临时挂载点去从一个太小的文件系统中移动数据到较大的新位置、修改 `/etc/fstab` 文件的内容来反映出新分区的正确设备名、以及重新引导来重新挂载新的文件系统到正确的挂载点。
我想告诉你的是，当 LVM （逻辑卷管理）首次出现在 Fedora Linux 中时，我是非常抗拒它的。我最初的反应是，我并不需要在我和我的设备之间有这种额外的抽象层。结果是我错了，逻辑卷管理是非常有用的。
LVM 让磁盘空间管理非常灵活。它提供的功能诸如在文件系统已挂载和活动时，很可靠地增加磁盘空间到一个逻辑卷和它的文件系统中，并且，它也允许你将多个物理磁盘和分区融合进一个可以分割成逻辑卷（LV）的单个卷组（VG）中。
卷管理也允许你去减少分配给一个逻辑卷的磁盘空间数量，但是，这里有两个要求，第一，卷必须是未挂载的。第二，在卷空间调整之前，文件系统本身的空间大小必须先被减少。
有一个重要的提示是，文件系统本身必须允许重新调整大小的操作。当重新提升文件系统大小的时候，EXT2、3 和 4 文件系统都允许离线（未挂载状态）或者在线（挂载状态）重新调整大小。你应该去认真了解你打算去调整的文件系统的详细情况，去验证它们是否可以完全调整大小，尤其是否可以在线调整大小。
### 即时扩展一个文件系统
在我安装一个新的发行版到我的生产用机器中之前，我总是喜欢在一个 VirtualBox 虚拟机中运行这个新的发行版一段时间，以确保它没有任何的致命的问题存在。在几年前的一个早晨，我在我的主要使用的工作站上的虚拟机中安装了一个新发行的 Fedora 版本。我认为我有足够的磁盘空间分配给安装虚拟机的主文件系统。但是，我错了，大约在安装到三分之一时，我耗尽了我的文件系统的空间。幸运的是，VirtualBox 检测到了磁盘空间不足的状态，并且暂停了虚拟机，然后显示了一个明确指出问题所在的错误信息。
请注意，这个问题并不是虚拟机磁盘太小造成的，而是由于宿主机上空间不足，导致虚拟机上的虚拟磁盘在宿主机上的逻辑卷中没有足够的空间去扩展。
因为许多现在的发行版都缺省使用了逻辑卷管理，并且在我的卷组中有一些可用的空余空间，我可以分配额外的磁盘空间到适当的逻辑卷，然后即时扩展宿主机的文件系统。这意味着我不需要去重新格式化整个硬盘，以及重新安装操作系统或者甚至是重启机器。我不过是分配了一些可用空间到适当的逻辑卷中，并且重新调整了文件系统的大小 —— 所有的这些操作都在文件系统在线并且运行着程序的状态下进行的，虚拟机也一直使用着宿主机文件系统。在调整完逻辑卷和文件系统的大小之后，我恢复了虚拟机的运行，并且继续进行安装过程，就像什么问题都没有发生过一样。
虽然这种问题你可能从来也没有遇到过，但是，许多人都遇到过重要程序在运行过程中发生磁盘空间不足的问题。而且，虽然许多程序，尤其是 Windows 程序，并不像 VirtualBox 一样写的很好，且富有弹性，Linux 逻辑卷管理可以使它在不丢失数据的情况下去恢复，也不需要去进行耗时的安装过程。
### LVM 结构
逻辑卷管理的磁盘环境结构如下面的图 1 所示。逻辑卷管理允许多个单独的硬盘和/或磁盘分区组合成一个单个的卷组（VG）。卷组然后可以再划分为逻辑卷（LV）或者被用于分配成一个大的单一的卷。普通的文件系统，如 EXT3 或者 EXT4，可以创建在一个逻辑卷上。
在图 1 中，两个完整的物理硬盘和一个第三块硬盘的一个分区组合成一个单个的卷组。在这个卷组中创建了两个逻辑卷和文件系统，比如，可以在每个逻辑卷上创建一个 EXT3 或者 EXT4 的文件系统。
*图 1: LVM 允许组合分区和整个硬盘到卷组中*
在一个主机上增加磁盘空间是非常简单的，在我的经历中，这种事情是很少的。下面列出了基本的步骤。你也可以创建一个完整的新卷组或者增加新的空间到一个已存在的逻辑卷中，或者创建一个新的逻辑卷。
### 增加一个新的逻辑卷
有时候需要在主机上增加一个新的逻辑卷。例如，在被提示包含我的 VirtualBox 虚拟机的虚拟磁盘的 `/home` 文件系统被填满时，我决定去创建一个新的逻辑卷，以存储包含虚拟磁盘在内的虚拟机数据。这将在我的 `/home` 文件系统中释放大量的空间，并且也允许我去独立地管理虚拟机的磁盘空间。
增加一个新的逻辑卷的基本步骤如下：
1. 如有需要，安装一个新硬盘。
2. 可选： 在硬盘上创建一个分区。
3. 在硬盘上创建一个完整的物理卷（PV）或者一个分区。
4. 分配新的物理卷到一个已存在的卷组（VG）中，或者创建一个新的卷组。
5. 从卷空间中创建一个新的逻辑卷（LV）。
6. 在新的逻辑卷中创建一个文件系统。
7. 在 `/etc/fstab` 中增加适当的条目以挂载文件系统。
8. 挂载文件系统。
为了更详细的介绍，接下来将使用一个示例作为一个实验去教授关于 Linux 文件系统的知识。
#### 示例
这个示例展示了怎么用命令行去扩展一个已存在的卷组，并给它增加更多的空间，在那个空间上创建一个新的逻辑卷，然后在逻辑卷上创建一个文件系统。这个过程一直在运行着和已挂载的文件系统上执行。
警告：仅 EXT3 和 EXT4 文件系统可以在运行和挂载状态下调整大小。许多其它的文件系统，包括 BTRFS 和 ZFS 是不能这样做的。
##### 安装硬盘
如果在系统中现有硬盘上的卷组中没有足够的空间可以增加，那么可能需要去增加一块新的硬盘，然后创建空间增加到逻辑卷中。首先，安装物理硬盘，然后，接着执行后面的步骤。
##### 从硬盘上创建物理卷
首先需要去创建一个新的物理卷（PV）。使用下面的命令，它假设新硬盘已经分配为 `/dev/hdd`。
```
pvcreate /dev/hdd
```
在新硬盘上创建一个任意分区并不是必需的。创建的物理卷将被逻辑卷管理器识别为一个新安装的未处理的磁盘或者一个类型为 83 的 Linux 分区。如果你想去使用整个硬盘，创建一个分区并没有什么特别的好处，而且元数据所用的磁盘空间也能用做 PV 的一部分使用。
##### 扩展已存在的卷组
在这个示例中，我将扩展一个已存在的卷组，而不是创建一个新的；你可以选择其它的方式。在物理磁盘已经创建之后，扩展已存在的卷组（VG）去包含新 PV 的空间。在这个示例中，已存在的卷组命名为：MyVG01。
```
vgextend /dev/MyVG01 /dev/hdd
```
##### 创建一个逻辑卷
首先，在卷组中从已存在的空余空间中创建逻辑卷。下面的命令创建了一个 50 GB 大小的 LV。这个卷组的名字为 MyVG01，然后，逻辑卷的名字为 Stuff。
```
lvcreate -L +50G --name Stuff MyVG01
```
##### 创建文件系统
创建逻辑卷并不会创建文件系统。这个任务必须被单独执行。下面的命令在新创建的逻辑卷中创建了一个 EXT4 文件系统。
```
mkfs -t ext4 /dev/MyVG01/Stuff
```
##### 增加一个文件系统卷标
增加一个文件系统卷标，更易于在文件系统以后出现问题时识别它。
```
e2label /dev/MyVG01/Stuff Stuff
```
##### 挂载文件系统
在这个时候，你可以创建一个挂载点，并在 `/etc/fstab` 文件系统中添加合适的条目，以挂载文件系统。
你也可以去检查并校验创建的卷是否正确。你可以使用 `df`、`lvs` 和 `vgs` 命令去做这些工作。
### 在 LVM 文件系统中调整逻辑卷大小
从 Unix 的第一个版本开始，对文件系统的扩展需求就一直伴随，Linux 也不例外。随着有了逻辑卷管理（LVM），现在更加容易了。
1. 如有需要，安装一个新硬盘。
2. 可选： 在硬盘上创建一个分区。
3. 在硬盘上创建一个完整的物理卷（PV）或者一个分区。
4. 分配新的物理卷到一个已存在的卷组（VG）中，或者创建一个新的卷组。
5. 从卷空间中创建一个新的逻辑卷（LV），或者用卷组中部分或全部空间扩展已有的逻辑卷。
6. 如果创建了新的逻辑卷，那么在上面创建一个文件系统。如果对已有的逻辑卷增加空间，使用 `resize2fs` 命令来增大文件系统来填满逻辑卷。
7. 在 `/etc/fstab` 中增加适当的条目以挂载文件系统。
8. 挂载文件系统。
#### 示例
这个示例展示了怎么用命令行去扩展一个已存在的卷组。它会给 `/Staff` 文件系统增加大约 50GB 的空间。这将生成一个可用于挂载的文件系统，在 Linux 2.6 内核（及更高）上可即时使用 EXT3 和 EXT4 文件系统。我不推荐你用于任何关键系统，但是这是可行的，我已经成功了好多次；即使是在根（`/`）文件系统上。是否使用自己把握风险。
警告：仅 EXT3 和 EXT4 文件系统可以在运行和挂载状态下调整大小。许多其它的文件系统，包括 BTRFS 和 ZFS 是不能这样做的。
##### 安装硬盘
如果在系统中现有硬盘上的卷组中没有足够的空间可以增加，那么可能需要去增加一块新的硬盘，然后创建空间增加到逻辑卷中。首先，安装物理硬盘，然后，接着执行后面的步骤。
##### 从硬盘上创建物理卷
首先需要去创建一个新的物理卷（PV）。使用下面的命令，它假设新硬盘已经分配为 `/dev/hdd`。
```
pvcreate /dev/hdd
```
在新硬盘上创建一个任意分区并不是必需的。创建的物理卷将被逻辑卷管理器识别为一个新安装的未处理的磁盘或者一个类型为 83 的 Linux 分区。如果你想去使用整个硬盘，创建一个分区并没有什么特别的好处，而且元数据所用的磁盘空间也能用做 PV 的一部分使用。
##### 增加物理卷到已存在的卷组
在这个示例中，我将使用一个新的物理卷来扩展一个已存在的卷组。在物理卷已经创建之后，扩展已存在的卷组（VG）去包含新 PV 的空间。在这个示例中，已存在的卷组命名为：MyVG01。
```
vgextend /dev/MyVG01 /dev/hdd
```
##### 扩展逻辑卷
首先，在卷组中从已存在的空余空间中创建逻辑卷。下面的命令创建了一个 50 GB 大小的 LV。这个卷组的名字为 MyVG01，然后，逻辑卷的名字为 Stuff。
```
lvcreate -L +50G --name Stuff MyVG01
```
##### 扩展文件系统
如果你使用了 `-r` 选项，扩展逻辑卷也将扩展器文件系统。如果你不使用 `-r` 选项，该操作不行单独执行。下面的命令在新调整大小的逻辑卷中调整了文件系统大小。
```
resize2fs /dev/MyVG01/Stuff
```
你也可以去检查并校验调整大小的卷是否正确。你可以使用 `df`、`lvs` 和 `vgs` 命令去做这些工作。
### 提示
过去几年来，我学习了怎么去做让逻辑卷管理更加容易的一些知识，希望这些提示对你有价值。
* 除非你有一个明确的原因去使用其它的文件系统外，推荐使用可扩展的文件系统。除了 EXT2、3、和 4 外，并不是所有的文件系统都支持调整大小。EXT 文件系统不但速度快，而且它很高效。在任何情况下，如果默认的参数不能满足你的需要，它们（指的是文件系统参数）可以通过一位知识丰富的系统管理员来调优它。
* 使用有意义的卷和卷组名字。
* 使用 EXT 文件系统标签
我知道，像我一样，大多数的系统管理员都抗拒逻辑卷管理。我希望这篇文章能够鼓励你至少去尝试一个 LVM。如果你能那样做，我很高兴；因为，自从我使用它之后，我的硬盘管理任务变得如此的简单。
### 关于作者
David Both 是一位 Linux 和开源软件的倡导者，住在 Raleigh, North Carolina。他在 IT 行业工作了 40 多年，在 IBM 工作了 20 多年。在 IBM 期间，他在 1981 年为最初的 IBM PC 编写了第一个培训课程。他曾教授红帽的 RHCE 课程，并在 MCI Worldcom、Cisco和 North Carolina 工作。他已经使用 Linux 和开源软件工作了将近 20 年。
---
via: <https://opensource.com/business/16/9/linux-users-guide-lvm>
作者：[David Both](a) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
动态连接的诀窍：使用 LD_PRELOAD 去欺骗、注入特性和研究程序
|
Rafał Cieślak
|
https://rafalcieslak.wordpress.com/2013/04/02/dynamic-linker-tricks-using-ld_preload-to-cheat-inject-features-and-investigate-programs/
|
我将向你展示一个基本的诀窍，在很大程度上你可以去影响大多数程序的行为，它并不仅是好玩，在有时候也很有用。
|
/data/attachment/album/201712/24/214230mevm8eqvmmqmvvhv.jpg.thumb.jpg
|
/data/attachment/album/201712/24/214230mevm8eqvmmqmvvhv.jpg
| true | false | true |
qhwdw
| false |
[
"分析",
"安全",
"注入"
] |
软件开发
|
{
"viewnum": 5011,
"commentnum": 0,
"favtimes": 4,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我将向你展示一个基本的诀窍，在很大程度上你可以去影响大多数程序的行为，它并不仅是好玩，在有时候也很有用。
| 2017-12-24T21:42:40 | 2017-12-24T21:42:40 | 9,169 |
/article-9169-1.html
|
**本文假设你具备基本的 C 技能**
Linux 完全在你的控制之中。虽然从每个人的角度来看似乎并不总是这样，但是高级用户喜欢去控制它。我将向你展示一个基本的诀窍，在很大程度上你可以去影响大多数程序的行为，它并不仅是好玩，在有时候也很有用。
### 一个让我们产生兴趣的示例
让我们以一个简单的示例开始。先乐趣，后科学。
*random\_num.c：*
```
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(){
srand(time(NULL));
int i = 10;
while(i--) printf("%d\n",rand()%100);
return 0;
}
```
我相信，它足够简单吧。我不使用任何参数来编译它，如下所示：
```
gcc random_num.c -o random_num
```
我希望它输出的结果是明确的：从 0-99 中选择的十个随机数字，希望每次你运行这个程序时它的输出都不相同。
现在，让我们假装真的不知道这个可执行程序的出处。甚至将它的源文件删除，或者把它移动到别的地方 —— 我们已不再需要它了。我们将对这个程序的行为进行重大的修改，而你并不需要接触到它的源代码，也不需要重新编译它。
因此，让我们来创建另外一个简单的 C 文件：
*unrandom.c：*
```
int rand(){
return 42; //the most random number in the universe
}
```
我们将编译它进入一个共享库中。
```
gcc -shared -fPIC unrandom.c -o unrandom.so
```
因此，现在我们已经有了一个可以输出一些随机数的应用程序，和一个定制的库，它使用一个常数值 `42` 实现了一个 `rand()` 函数。现在 …… 就像运行 `random_num` 一样，然后再观察结果：
```
LD_PRELOAD=$PWD/unrandom.so ./random_nums
```
如果你想偷懒或者不想自动亲自动手（或者不知什么原因猜不出发生了什么），我来告诉你 —— 它输出了十次常数 42。
如果先这样执行
```
export LD_PRELOAD=$PWD/unrandom.so
```
然后再以正常方式运行这个程序，这个结果也许会更让你吃惊：一个未被改变过的应用程序在一个正常的运行方式中，看上去受到了我们做的一个极小的库的影响 ……
**等等，什么？刚刚发生了什么？**
是的，你说对了，我们的程序生成随机数失败了，因为它并没有使用 “真正的” `rand()`，而是使用了我们提供的的那个 —— 它每次都返回 `42`。
**但是，我们*告诉过*它去使用真实的那个。我们编程让它去使用真实的那个。另外，在创建那个程序的时候，假冒的 `rand()` 甚至并不存在！**
这句话并不完全正确。我们只能告诉它去使用 `rand()`，但是我们不能去选择哪个 `rand()` 是我们希望我们的程序去使用的。
当我们的程序启动后，（为程序提供所需要的函数的）某些库被加载。我们可以使用 `ldd` 去学习它是怎么工作的：
```
$ ldd random_nums
linux-vdso.so.1 => (0x00007fff4bdfe000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f48c03ec000)
/lib64/ld-linux-x86-64.so.2 (0x00007f48c07e3000)
```
正如你看到的输出那样，它列出了被程序 `random_nums` 所需要的库的列表。这个列表是构建进可执行程序中的，并且它是在编译时决定的。在你的机器上的具体的输出可能与示例有所不同，但是，一个 `libc.so` 肯定是有的 —— 这个文件提供了核心的 C 函数。它包含了 “真正的” `rand()`。
我使用下列的命令可以得到一个全部的函数列表，我们看一看 libc 提供了哪些函数：
```
nm -D /lib/libc.so.6
```
这个 `nm` 命令列出了在一个二进制文件中找到的符号。`-D` 标志告诉它去查找动态符号，因为 `libc.so.6` 是一个动态库。这个输出是很长的，但它确实在列出的很多标准函数中包括了 `rand()`。
现在，在我们设置了环境变量 `LD_PRELOAD` 后发生了什么？这个变量 **为一个程序强制加载一些库**。在我们的案例中，它为 `random_num` 加载了 `unrandom.so`，尽管程序本身并没有这样去要求它。下列的命令可以看得出来：
```
$ LD_PRELOAD=$PWD/unrandom.so ldd random_nums
linux-vdso.so.1 => (0x00007fff369dc000)
/some/path/to/unrandom.so (0x00007f262b439000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f262b044000)
/lib64/ld-linux-x86-64.so.2 (0x00007f262b63d000)
```
注意，它列出了我们当前的库。实际上这就是代码为什么得以运行的原因：`random_num` 调用了 `rand()`，但是，如果 `unrandom.so` 被加载，它调用的是我们所提供的实现了 `rand()` 的库。很清楚吧，不是吗？
### 更清楚地了解
这还不够。我可以用相似的方式注入一些代码到一个应用程序中，并且用这种方式它能够像个正常的函数一样工作。如果我们使用一个简单的 `return 0` 去实现 `open()` 你就明白了。我们看到这个应用程序就像发生了故障一样。这是 **显而易见的**， 真实地去调用原始的 `open()`：
*inspect\_open.c：*
```
int open(const char *pathname, int flags){
/* Some evil injected code goes here. */
return open(pathname,flags); // Here we call the "real" open function, that is provided to us by libc.so
}
```
嗯，不对。这将不会去调用 “原始的” `open(...)`。显然，这是一个无休止的递归调用。
怎么去访问这个 “真正的” `open()` 函数呢？它需要去使用程序接口进行动态链接。它比听起来更简单。我们来看一个完整的示例，然后，我将详细解释到底发生了什么：
*inspect\_open.c：*
```
#define _GNU_SOURCE
#include <dlfcn.h>
typedef int (*orig_open_f_type)(const char *pathname, int flags);
int open(const char *pathname, int flags, ...)
{
/* Some evil injected code goes here. */
orig_open_f_type orig_open;
orig_open = (orig_open_f_type)dlsym(RTLD_NEXT,"open");
return orig_open(pathname,flags);
}
```
`dlfcn.h` 是我们后面用到的 `dlsym` 函数所需要的。那个奇怪的 `#define` 是命令编译器去允许一些非标准的东西，我们需要它来启用 `dlfcn.h` 中的 `RTLD_NEXT`。那个 `typedef` 只是创建了一个函数指针类型的别名，它的参数等同于原始的 `open` —— 它现在的别名是 `orig_open_f_type`，我们将在后面用到它。
我们定制的 `open(...)` 的主体是由一些代码构成。它的最后部分创建了一个新的函数指针 `orig_open`，它指向原始的 `open(...)` 函数。为了得到那个函数的地址，我们请求 `dlsym` 在动态库堆栈上为我们查找下一个 `open()` 函数。最后，我们调用了那个函数（传递了与我们的假冒 `open()` 一样的参数），并且返回它的返回值。
我使用下面的内容作为我的 “邪恶的注入代码”：
*inspect\_open.c (片段)：*
```
printf("The victim used open(...) to access '%s'!!!\n",pathname); //remember to include stdio.h!
```
要编译它，我需要稍微调整一下编译参数：
```
gcc -shared -fPIC inspect_open.c -o inspect_open.so -ldl
```
我增加了 `-ldl`，因此，它将这个共享库链接到 `libdl` —— 它提供了 `dlsym` 函数。（不，我还没有创建一个假冒版的 `dlsym` ，虽然这样更有趣）
因此，结果是什么呢？一个实现了 `open(...)` 函数的共享库，除了它有 *输出* 文件路径的意外作用以外，其它的表现和真正的 `open(...)` 函数 **一模一样**。:-)
如果这个强大的诀窍还没有说服你，是时候去尝试下面的这个示例了：
```
LD_PRELOAD=$PWD/inspect_open.so gnome-calculator
```
我鼓励你去看看自己实验的结果，但是简单来说，它实时列出了这个应用程序可以访问到的每个文件。
我相信它并不难想像为什么这可以用于去调试或者研究未知的应用程序。请注意，这个特定诀窍并不完整，因为 `open()` 并不是唯一一个打开文件的函数 …… 例如，在标准库中也有一个 `open64()`，并且为了完整地研究，你也需要为它去创建一个假冒的。
### 可能的用法
如果你一直跟着我享受上面的过程，让我推荐一个使用这个诀窍能做什么的一大堆创意。记住，你可以在不损害原始应用程序的同时做任何你想做的事情！
1. ~~获得 root 权限~~。你想多了！你不会通过这种方法绕过安全机制的。（一个专业的解释是：如果 ruid != euid，库不会通过这种方法预加载的。）
2. 欺骗游戏：**取消随机化**。这是我演示的第一个示例。对于一个完整的工作案例，你将需要去实现一个定制的 `random()` 、`rand_r()`、`random_r()`，也有一些应用程序是从 `/dev/urandom` 之类的读取，你可以通过使用一个修改过的文件路径来运行原始的 `open()` 来把它们重定向到 `/dev/null`。而且，一些应用程序可能有它们自己的随机数生成算法，这种情况下你似乎是没有办法的（除非，按下面的第 10 点去操作）。但是对于一个新手来说，它看起来很容易上手。
3. 欺骗游戏：**让子弹飞一会** 。实现所有的与时间有关的标准函数，让假冒的时间变慢两倍，或者十倍。如果你为时间测量和与时间相关的 `sleep` 或其它函数正确地计算了新的值，那么受影响的应用程序将认为时间变慢了（你想的话，也可以变快），并且，你可以体验可怕的 “子弹时间” 的动作。或者 **甚至更进一步**，你的共享库也可以成为一个 DBus 客户端，因此你可以使用它进行实时的通讯。绑定一些快捷方式到定制的命令，并且在你的假冒的时间函数上使用一些额外的计算，让你可以有能力按你的意愿去启用和禁用慢进或快进任何时间。
4. 研究应用程序：**列出访问的文件**。它是我演示的第二个示例，但是这也可以进一步去深化，通过记录和监视所有应用程序的文件 I/O。
5. 研究应用程序：**监视因特网访问**。你可以使用 Wireshark 或者类似软件达到这一目的，但是，使用这个诀窍你可以真实地控制基于 web 的应用程序发送了什么，不仅是看看，而是也能影响到交换的数据。这里有很多的可能性，从检测间谍软件到欺骗多用户游戏，或者分析和逆向工程使用闭源协议的应用程序。
6. 研究应用程序：**检查 GTK 结构** 。为什么只局限于标准库？让我们在所有的 GTK 调用中注入一些代码，因此我们就可以知道一个应用程序使用了哪些组件，并且，知道它们的构成。然后这可以渲染出一个图像或者甚至是一个 gtkbuilder 文件！如果你想去学习一些应用程序是怎么管理其界面的，这个方法超级有用！
7. **在沙盒中运行不安全的应用程序**。如果你不信任一些应用程序，并且你可能担心它会做一些如 `rm -rf /` 或者一些其它不希望的文件活动，你可以通过修改传递到文件相关的函数（不仅是 `open` ，也包括删除目录等）的参数，来重定向所有的文件 I/O 操作到诸如 `/tmp` 这样地方。还有更难的诀窍，如 chroot，但是它也给你提供更多的控制。它可以更安全地完全 “封装”，但除非你真的知道你在做什么，不要以这种方式真的运行任何恶意软件。
8. **实现特性** 。[zlibc](http://www.zlibc.linux.lu/index.html) 是明确以这种方法运行的一个真实的库；它可以在访问文件时解压文件，因此，任何应用程序都可以在无需实现解压功能的情况下访问压缩数据。
9. **修复 bug**。另一个现实中的示例是：不久前（我不确定现在是否仍然如此）Skype（它是闭源的软件）从某些网络摄像头中捕获视频有问题。因为 Skype 并不是自由软件，源文件不能被修改，这就可以通过使用预加载一个解决了这个问题的库的方式来修复这个 bug。
10. 手工方式 **访问应用程序拥有的内存**。请注意，你可以通过这种方式去访问所有应用程序的数据。如果你有类似的软件，如 CheatEngine/scanmem/GameConqueror 这可能并不会让人惊讶，但是，它们都要求 root 权限才能工作，而 `LD_PRELOAD` 则不需要。事实上，通过一些巧妙的诀窍，你注入的代码可以访问所有的应用程序内存，从本质上看，是因为它是通过应用程序自身得以运行的。你可以修改这个应用程序能修改的任何东西。你可以想像一下，它允许你做许多的底层的侵入…… ，但是，关于这个主题，我将在某个时候写一篇关于它的文章。
这里仅是一些我想到的创意。我希望你能找到更多，如果你做到了 —— 通过下面的评论区共享出来吧！
---
via: <https://rafalcieslak.wordpress.com/2013/04/02/dynamic-linker-tricks-using-ld_preload-to-cheat-inject-features-and-investigate-programs/>
作者：[Rafał Cieślak](https://rafalcieslak.wordpress.com/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一步步教你如何安装 Arch Linux
|
Ambarish Kumar
|
https://itsfoss.com/install-arch-linux/
|
Arch Linux 是一个 x86-64 通用发行版，它流行于那些喜欢 DIY Linux 系统的用户和 Linux 铁杆粉丝当中。
|
/data/attachment/album/201712/25/102347o3eceaeca1j9x1zl.png.thumb.jpg
|
/data/attachment/album/201712/25/102347o3eceaeca1j9x1zl.png
| true | false | true |
wenwensnow
| false |
[
"Arch",
"Linux",
"安装",
"发行版"
] |
桌面应用
|
{
"viewnum": 47523,
"commentnum": 2,
"favtimes": 7,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "60.209.105.170",
"message": "我最喜爱的Linux发行版之一。",
"username": "绿色圣光 [Firefox 57.0|GNU/Linux]",
"date": "2017-12-28T18:15:36"
},
{
"postip": "61.216.19.203",
"message": "视频是人看的吗？模糊的一逼",
"username": "来自台湾的 Chrome 92.0|Mac 10.15 用户",
"date": "2021-07-27T11:16:54"
}
] |
[] |
Arch Linux 是一个 x86-64 通用发行版，它流行于那些喜欢 DIY Linux 系统的用户和 Linux 铁杆粉丝当中。
| 2017-12-25T10:23:45 | 2017-12-25T10:23:45 | 9,170 |
/article-9170-1.html
|
>
> 简要说明：这一教程会教你如何用简单步骤安装 Arch Linux。
>
>
>
[Arch Linux](https://www.archlinux.org/) 是一个 x86-64 通用发行版，它流行于那些喜欢 [DIY](https://en.wikipedia.org/wiki/Do_it_yourself) Linux 系统的用户和 Linux 铁杆粉丝当中。其默认的安装文件只含有一个最基本的系统，它希望使用者自己配置并使用 Arch 系统。其基于 KISS 原则（<ruby> 使它保持简单、傻瓜 <rt> Keep It Simple, Stupid! </rt></ruby>），Arch Linux 是一个专注于优雅、代码正确，精简而简洁的系统。
Arch 支持滚动发布模式，并且有自己的软件包管理器 —— [pacman](https://wiki.archlinux.org/index.php/pacman)。为了提供一个先锐的操作系统，Arch 绝不会错失任何一个最新的源。实际上，它只提供了一个最小化的基本操作系统，使得你可以在低端硬件上安装 Arch，并且只安装你所必须的软件包。
同时，它也是最流行的从头开始学习 Linux 的操作系统之一。如果你想以 DIY 精神自己体验一番，你应该尝试一下 Arch Linux。 这被许多 Linux 用户视作核心的 Linux 体验。
在这篇文章里，我们会了解到如何安装、配置 Arch 并在其上安装桌面环境。
### 如何安装 Arch Linux
我们在这里讨论的安装方法是从你的电脑上**完全删除已有的操作系统** ，而后在其上安装 Arch Linux。如果你想遵循这一教程安装 Arch，请确保你已经备份了所有文件，否则你就会失去它们。切切。
在你从 USB 上安装 Arch 之前，请确保你已经满足了以下条件：
#### 安装 Arch Linux 的条件：
* 一个兼容 x86\_64（例如 64 位）的机器
* 最小 512M 内存（建议 2GB）
* 最少 1GB 的磁盘空余空间（日常使用推荐 20GB）
* 可以访问互联网
* 至少有 2GB 存储空间的 USB 存储器
* 熟悉 Linux 命令行
一旦你确认满足所有条件，就可以开始安装 Arch Linux 了。
#### 第一步：下载 ISO 文件
你可以从[官网](https://www.archlinux.org/download/)上下载 ISO。安装 Arch Linux 需要一个至少有 512M 内存和 800M 磁盘空间，并兼容 x86\_64 （如 64 位）的机器。不过，建议至少有 2G 内存和 20G 磁盘空间，这样安装桌面环境时就不会遇到麻烦。
#### 第二步：创建一个 Arch Linux 的现场版 USB 存储器
我们需要用你刚刚下载的 ISO 文件创建一个 Arch Linux 的<ruby> 现场版 <rt> live </rt></ruby> USB 存储器。
如果你使用 Linux，你可以用 `dd` 命令来创建现场版 USB 存储器。 记得将下面的例子中的 `/path/to/archlinux.iso` 改成你的 ISO 文件的实际存储位置，`/dev/sdx` 改成你的磁盘设备号（例如 `/dev/sdb`）。你可以通过 [lsblk](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/deployment_guide/s1-sysinfo-filesystems) 命令来了解你的设备信息。
```
dd bs=4M if=/path/to/archlinux.iso of=/dev/sdx status=progress && sync
```
在 Windows 下，有多种方法来创建现场版 USB 存储器。 推荐工具是 Rufus。我们之前已经有[如何使用这一工具创建Antergos 现场版 USB 存储器](https://itsfoss.com/live-usb-antergos/)的教程。因为 Antergos 发行版是基于 Arc h的，所以你可以使用同一教程。
#### 步骤三：从现场版 USB 存储器上启动
一旦你已经创建了 Arch Linux 的现场版 USB 存储器，关闭你的电脑。插上你的 USB 存储器然后启动系统。在开机启动时，持续按 F2、F10 或 F1 之类的按键（根据你的电脑型号而定）进入启动设置。在这里，选择“从 USB 存储器或可移除设备启动”这一项。
一旦你选择了它，你会看到这样一个选项：
选择“Boot Arch Linux (x86\_64)”。经过各种系统检查后，Arch Linux 会启动到 root 用户的命令行界面。
接下来的步骤包括磁盘分区、创建文件系统并挂载它。
#### 第四步：磁盘分区
第一步就是给你的硬盘分区。单根分区是最简单的，就在它上面创建根分区（`/`）分区、交换分区和 `home` 分区。
我有一个 19G 的硬盘，我想在这儿安装 Arch Linux。为了创建分区，输入：
```
fdisk /dev/sda
```
按 `n` 创建新分区。按 `p` 创建主分区，然后选择分区号。
第一个扇区会被自动选择，你只要按回车键。在确定分区的最后一个扇区时，请输入这一分区的大小。
用相同的方法为 `home` 和交换分区创建两个分区，按 `w` 来保存修改并退出。
#### 第四步：创建文件系统
因为我们已经有了三个分区，接下来就是创建文件系统来格式化分区。
我们用 `mkfs` 命令在根分区和 `home` 分区上创建文件系统，用 `mkswap` 创建交换分区。我们用 ext4 文件系统格式化磁盘。
```
mkfs.ext4 /dev/sda1
mkfs.ext4 /dev/sda3
mkswap /dev/sda2
swapon /dev/sda2
```
将这些分区挂载在根分区和 `home` 分区下：
```
mount /dev/sda1 /mnt
mkdir /mnt/home
mount /dev/sda3 /mnt/home
```
#### 第五步：安装
我们已经创建分区并挂载了分区，开始安装最基本的软件包。基本的软件包包括了系统运行所必需的所有软件包。比如有 GNU BASH shell、文件压缩工具、文件系统管理工具、C 语言库、压缩工具、Linux 内核及其模块，类库、系统工具、USB 设备工具、Vi 文本编辑器等等。
```
pacstrap /mnt base base-devel
```
#### 第六步：配置系统
生成一个 `fstab` 文件来规定磁盘分区、块设备，或者远程文件系统是如何挂载进文件系统中的。
```
genfstab -U /mnt >> /mnt/etc/fstab
```
进入 chroot 环境，这样可以为当前进程以及子进程切换当前根目录。
```
arch-chroot /mnt
```
一些需要与数据总线保持连接的 systemd 工具不能在 chroot 环境下使用，所以需要从当前环境退出。想要退出 chroot，就用下面的命令:
```
exit
```
#### 第七步：设定时区
用下面这条命令设定时区：
```
ln -sf /usr/share/<时区信息>/<地区>/<城市> /etc/localtime
```
获取时区列表，输入：
```
ls /usr/share/zoneinfo
```
用 `hwclock` 命令设定硬件时钟：
```
hwclock --systohc --utc
```
#### 第八步：设置地区
文件 `/etc/locale.gen` 在注释里包含了所有地区和系统语言设置。用 Vi 打开它，然后去掉你希望选择语言前面的注释。 我选择了 `en_GB.UTF-8`。
现在用下面的命令在 `/etc` 文件夹里生成 关于地区的配置文件：
```
locale-gen
echo LANG=en_GB.UTF-8 > /etc/locale.conf
export LANG=en_GB.UTF-8
```
#### 第九步 ：安装 bootloader，设置主机名和 root 密码
创建 `/etc/hostname` 文件 然后添加一个对应的主机名：
```
127.0.1.1 myhostname.localdomain myhostname
```
我添加了 `ItsFossArch` 作为我的主机名：
```
echo ItsFossArch > /etc/hostname
```
然后也将它添加到 `/etc/hosts` 中
为了安装 bootloader 使用下面的命令：
```
pacman -S grub
grub-install /dev/sda
grub-mkconfig -o /boot/grub/grub.cfg
```
创建 root 密码，输入：
```
passwd
```
输入你想要的密码。
完成之后，更新你的系统。但很有可能你的系统已经是最新的，因为你下载的是最新的 ISO。
```
pacman -Syu
```
恭喜! 你已经安装了 Arch Linux 的命令行版本。
接下来，我们会了解到如何为 Arch 设置并安装一个桌面环境。我很喜欢 GNOME 桌面环境，所以在这儿也就选择了这个。
#### 第十步：安装桌面（这一例子中是 GNOME）
在你安装桌面之前，你需要先设置网络。
你可以用下面的命令看见你的端口：
```
ip link
```
在我的电脑上，端口名是 `enp0s3`。
将下面这一段加进文件中：
```
vi /etc/systemd/network/enp0s3.network
[Match]
name=en*
[Network]
DHCP=yes
```
保存并退出。重启网络来应用你刚才的改动。
```
systemctl restart systemd-networkd
systemctl enable systemd-networkd
```
将下面这两句话加进 `/etc/resolv.conf` 中
```
nameserver 8.8.8.8
nameserver 8.8.4.4
```
下一步是安装 X 环境。
输入下面的命令安装 Xorg，并将它作为显示服务器。
```
pacman -S xorg xorg-server
```
gnome 包含了基本的 GNOME桌面，gnome-extra 则包含 GNOME 应用、归档管理器、磁盘管理器、文本编辑器和其它的应用。
```
pacman -S gnome gnome-extra
```
最后一步是在 Arch 上开启 GDM 显示管理器。
```
systemctl start gdm.service
systemctl enable gdm.service
```
重启你的系统，你就会看见 GNOME 的登录界面。
### Arch Linux 安装总结
我们在下面的视频中展示了一个由 Foss 读者 Gonzalo Tormo 提供的相似的安装方法（全屏观看，能更好的看清命令）：
你也许意识到安装 Arch 不像[安装 Ubuntu](https://itsfoss.com/install-ubuntu-1404-dual-boot-mode-windows-8-81-uefi/) 一样简单。不过，只要有耐心，你一定可以安装好它，并且向全世界宣布你在用 Arch Linux。
Arch Linux 安装过程本身就是一个学习的机会。一旦安装完毕，我建议你参考它的 Wiki 去尝试其它的桌面环境，从而更深入了解这一操作系统。你可以探索它，发现它的强大之处。
如果你在安装 Arch 的过程中遇到任何问题，请在评论中给我们留言。
---
via: <https://itsfoss.com/install-arch-linux/>
作者：[Ambarish Kumar](https://itsfoss.com/author/ambarish/) 译者：[wenwensnow](https://github.com/wenwensnow) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 Linux 启动时自动启动 LXD 容器
|
Vivek Gite
|
https://www.cyberciti.biz/faq/how-to-auto-start-lxd-containers-at-boot-time-in-linux/
|
当 LXD 在启动时运行，你就可以随时启动容器。你需要将 boot.autostart 设置为 true。
|
/data/attachment/album/201712/25/134247vu4yiw2jpk1akijw.jpg.thumb.jpg
|
/data/attachment/album/201712/25/134247vu4yiw2jpk1akijw.jpg
| true | false | true |
geekpi
| false |
[
"LXD",
"容器"
] |
容器与云
|
{
"viewnum": 4533,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
当 LXD 在启动时运行，你就可以随时启动容器。你需要将 boot.autostart 设置为 true。
| 2017-12-25T13:42:50 | 2017-12-25T13:42:50 | 9,171 |
/article-9171-1.html
|
**Q：我正在使用基于 LXD（“Linux 容器”）的虚拟机。如何在 Linux 系统中启动时自动启动 LXD 容器？**
当 LXD 在启动时运行，你就可以随时启动容器。你需要将 `boot.autostart` 设置为 `true`。你可以使用 `boot.autostart.priority`（默认值为 `0`）选项来定义启动容器的顺序（从最高开始）。你也可以使用 `boot.autostart.delay`（默认值 `0`）选项定义在启动一个容器后等待几秒后启动另一个容器。
### 语法
上面讨论的关键字可以使用 `lxc` 工具用下面的语法来设置：
```
$ lxc config set {vm-name} {key} {value}
$ lxc config set {vm-name} boot.autostart {true|false}
$ lxc config set {vm-name} boot.autostart.priority integer
$ lxc config set {vm-name} boot.autostart.delay integer
```
### 如何在 Ubuntu Linux 16.10 中让 LXD 容器在启动时启动？
输入以下命令：
```
$ lxc config set {vm-name} boot.autostart true
```
设置一个 LXD 容器名称 “nginx-vm” 以在启动时启动
```
$ lxc config set nginx-vm boot.autostart true
```
你可以使用以下语法验证设置：
```
$ lxc config get {vm-name} boot.autostart
$ lxc config get nginx-vm boot.autostart
```
示例输出：
```
true
```
你可以使用下面的语法在启动容器后等待 10 秒钟后启动另一个容器：
```
$ lxc config set nginx-vm boot.autostart.delay 10
```
最后，通过设置最高值来定义启动容器的顺序。确保 db*vm 容器首先启动，然后再启动 nginx*vm。
```
$ lxc config set db_vm boot.autostart.priority 100
$ lxc config set nginx_vm boot.autostart.priority 99
```
使用[下面的 bash 循环在 Linux 上查看所有](https://www.cyberciti.biz/faq/bash-for-loop/)配置值：
```
#!/bin/bash
echo 'The current values of each vm boot parameters:'
for c in db_vm nginx_vm memcache_vm
do
echo "*** VM: $c ***"
for v in boot.autostart boot.autostart.priority boot.autostart.delay
do
echo "Key: $v => $(lxc config get $c $v) "
done
echo ""
done
```
示例输出：
---
via: <https://www.cyberciti.biz/faq/how-to-auto-start-lxd-containers-at-boot-time-in-linux/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
详解如何用源代码安装软件，以及如何卸载它
|
Sylvain Leroux
|
https://itsfoss.com/install-software-from-source-code/
|
对于绝大多数的 Linux 用户来说，第一次从源代码中编译和安装一个软件看上去像是一个入门仪式：它让很多人感到恐惧；但是，如果你能克服困难，你将可能进入一个全新的世界，并且，如果你做到了，那么你将成为社区中享有特权的一部分人。
|
/data/attachment/album/201712/25/215040sjoviquqilz5igl9.jpg.thumb.jpg
|
/data/attachment/album/201712/25/215040sjoviquqilz5igl9.jpg
| true | false | true |
qhwdw
| true |
[
"编译",
"安装",
"源代码"
] |
技术
|
{
"viewnum": 39394,
"commentnum": 1,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "219.239.227.222",
"message": "深度好文！！！！",
"username": "来自北京的 Chrome 75.0|GNU/Linux 用户",
"date": "2019-07-20T09:01:56"
}
] |
[] |
对于绝大多数的 Linux 用户来说，第一次从源代码中编译和安装一个软件看上去像是一个入门仪式：它让很多人感到恐惧；但是，如果你能克服困难，你将可能进入一个全新的世界，并且，如果你做到了，那么你将成为社区中享有特权的一部分人。
| 2017-12-25T21:50:37 | 2017-12-25T21:50:37 | 9,172 |
/article-9172-1.html
|
*简介：这篇文章详细介绍了在 Linux 中怎么用源代码安装程序，以及怎么去卸载用源代码安装的程序。*
Linux 发行版的一个最大的优点就是它的包管理器和相关的软件库。通过它们提供的资源和工具，你才能够以完全自动化的方式在你的计算机上下载和安装软件。
但是，尽管付出了很多的努力，包维护者仍然没法照顾好每种情况，也不可能将所有的可用软件都打包进去。因此，仍然存在需要你自已去编译和安装一个新软件的情形。对于我来说，到目前为止，最主要的原因是，我编译一些软件是我需要去运行一个特定的版本。或者是我想去修改源代码或使用一些想要的编译选项。
如果你也属于后一种情况，那你已经知道你应该怎么做了。但是，对于绝大多数的 Linux 用户来说，第一次从源代码中编译和安装一个软件看上去像是一个入门仪式：它让很多人感到恐惧；但是，如果你能克服困难，你将可能进入一个全新的世界，并且，如果你做到了，那么你将成为社区中享有特权的一部分人。
* [建议阅读：怎样在 Ubuntu 中安装和删除软件（完全指南）](https://itsfoss.com/remove-install-software-ubuntu/)
### A. 在 Linux 中从源代码开始安装软件
这正是我们要做的。因为这篇文章的需要，我要在我的系统上安装 [NodeJS](https://nodejs.org/en/) 8.1.1。它是个完全真实的版本。这个版本在 Debian 仓库中没有：
```
sh$ apt-cache madison nodejs | grep amd64
nodejs | 6.11.1~dfsg-1 | http://deb.debian.org/debian experimental/main amd64 Packages
nodejs | 4.8.2~dfsg-1 | http://ftp.fr.debian.org/debian stretch/main amd64 Packages
nodejs | 4.8.2~dfsg-1~bpo8+1 | http://ftp.fr.debian.org/debian jessie-backports/main amd64 Packages
nodejs | 0.10.29~dfsg-2 | http://ftp.fr.debian.org/debian jessie/main amd64 Packages
nodejs | 0.10.29~dfsg-1~bpo70+1 | http://ftp.fr.debian.org/debian wheezy-backports/main amd64 Packages
```
#### 第 1 步：从 GitHub 上获取源代码
像大多数开源项目一样，NodeJS 的源代码可以在 GitHub：<https://github.com/nodejs/node> 上找到。
所以，我们直接开始吧。
如果你不熟悉 [GitHub](https://en.wikipedia.org/wiki/GitHub)，[git](https://en.wikipedia.org/wiki/Git) 或者提到的其它 [版本管理系统](https://en.wikipedia.org/wiki/Version_control)包含了这个软件的源代码，以及多年来对该软件的所有修改的历史。甚至可以回溯到该软件的最早版本。对于开发者来说，保留它的历史版本有很多好处。如今对我来说，其中一个好处是可以得到任何一个给定时间点的项目源代码。更准确地说，我可以得到我所要的 8.1.1 发布时的源代码。即便从那之后他们有了很多的修改。
在 GitHub 上，你可以使用 “branch” （分支）按钮导航到这个软件的不同版本。[“分支” 和 “标签” 是 Git 中一些相关的概念](https://stackoverflow.com/questions/1457103/how-is-a-tag-different-from-a-branch-which-should-i-use-here)。总的来说，开发者创建 “分支” 和 “标签” 来在项目历史中对重要事件保持跟踪，比如当他们启用一个新特性或者发布一个新版本时。在这里先不详细介绍了，你现在只需要知道我在找被标记为 “v8.1.1” 的版本。
在选择了 “v8.1.1” 标签后，页面被刷新，最显著的变化是标签现在作为 URL 的一部分出现。另外，你可能会注意到文件改变日期也有所不同。你现在看到的源代码树是创建了 v8.1.1 标签时的代码。在某种意义上，你也可以认为像 git 这样的版本管理工具是一个时光穿梭机，允许你在项目历史中来回穿梭。
此时，我们可以下载 NodeJS 8.1.1 的源代码。你不要忘记去点那个建议的大的蓝色按钮来下载一个项目的 ZIP 压缩包。对于我来说，为讲解的目的，我从命令行中下载并解压这个 ZIP 压缩包。但是，如果你更喜欢使用一个 [GUI](https://en.wikipedia.org/wiki/Graphical_user_interface) 工具，不用担心，你可以取代下面的命令方式：
```
wget https://github.com/nodejs/node/archive/v8.1.1.zip
unzip v8.1.1.zip
cd node-8.1.1/
```
下载一个 ZIP 包就可以，但是如果你希望“像个专家一样”，我建议你直接使用 `git` 工具去下载源代码。它一点也不复杂 — 并且如果你是第一次使用该工具，它将是一个很好的开端，你以后将经常用到它：
```
# first ensure git is installed on your system
sh$ sudo apt-get install git
# Make a shallow clone the NodeJS repository at v8.1.1
sh$ git clone --depth 1 \
--branch v8.1.1 \
https://github.com/nodejs/node
sh$ cd node/
```
顺便说一下，如果你有任何问题，这篇文章的第一部分只是做一个总体介绍而已。后面，为了帮你排除常见问题，我们将基于 Debian 和基于 RedHat 的发行版更详细地解释。
不管怎样，在你使用 `git` 或者作为一个 ZIP 压缩包下载了源代码后，在当前目录下就有了同样的源代码文件：
```
sh$ ls
android-configure BUILDING.md common.gypi doc Makefile src
AUTHORS CHANGELOG.md configure GOVERNANCE.md node.gyp test
benchmark CODE_OF_CONDUCT.md CONTRIBUTING.md lib node.gypi tools
BSDmakefile COLLABORATOR_GUIDE.md deps LICENSE README.md vcbuild.bat
```
#### 第 2 步：理解程序的构建系统
构建系统就是我们通常所说的“编译源代码”，其实，编译只是从源代码中生成一个可使用的软件的其中一个阶段。构建系统是一套工具，用于自动处置不同的任务，以便可以仅通过几个命令就能构建整个软件。
虽然概念很简单，实际上编译做了很多事情。因为不同的项目或者编程语言也许有不同的要求，或者因为编程者的好恶，或者因为支持的平台、或者因为历史的原因，等等等等 … 选择或创建另外一个构建系统的原因几乎数不清。这方面有许多种不同的解决方案。
NodeJS 使用一种 [GNU 风格的构建系统](https://en.wikipedia.org/wiki/GNU_Build_System)。这在开源社区中这是一个很流行的选择。由此开始，你将进入一段精彩的旅程。
写出和调优一个构建系统是一个非常复杂的任务。但是，作为 “终端用户” 来说，GNU 风格的构建系统使用两个工具让他们免于此难：`configure` 和 `make`。
`configure` 文件是个项目专用的脚本，它将检查目标系统的配置和可用功能，以确保该项目可以被构建，并最终吻合当前平台的特性。
一个典型的 `configure` 任务的重要部分是去构建 `Makefile`。这个文件包含了有效构建项目所需的指令。
另一方面，[`make` 工具](https://en.wikipedia.org/wiki/Make_%28software)，这是一个可用于任何类 Unix 系统的 POSIX 工具。它将读取项目专用的 `Makefile` 然后执行所需的操作去构建和安装你的程序。
但是，在 Linux 的世界中，你仍然有一些定制你自己专用的构建的理由。
```
./configure --help
```
`configure -help` 命令将展示你可用的所有配置选项。再强调一下，这是非常的项目专用。说实话，有时候，在你完全理解每个配置选项的作用之前，你需要深入到项目中去好好研究。
不过，这里至少有一个标准的 GNU 自动化工具选项是你该知道的，它就是众所周知的 `--prefix` 选项。它与文件系统的层次结构有关，它是你软件要安装的位置。
#### 第 3 步：文件系统层次化标准（FHS）
大部分典型的 Linux 发行版的文件系统层次结构都遵从 [文件系统层次化标准（FHS）](http://www.pathname.com/fhs/)。
这个标准说明了你的系统中各种目录的用途，比如，`/usr`、`/tmp`、`/var` 等等。
当使用 GNU 自动化工具 *和大多数其它的构建系统* 时，它会把新软件默认安装在你的系统的 `/usr/local` 目录中。这是依据 FHS 中 *“`/usr/local` 层级是为系统管理员本地安装软件时使用的，它在系统软件更新覆盖时是安全的。它也可以用于存放在一组主机中共享，但又没有放到 /usr 中的程序和数据”*，因此，它是一个非常好的选择。
`/usr/local` 层级以某种方式复制了根目录，你可以在 `/usr/local/bin` 这里找到可执行程序，在 `/usr/local/lib` 中找到库，在 `/usr/local/share` 中找到架构无关的文件，等等。
使用 `/usr/local` 树作为你定制安装的软件位置的唯一问题是，你的软件的文件将在这里混杂在一起。尤其是你安装了多个软件之后，将很难去准确地跟踪 `/usr/local/bin` 和 `/usr/local/lib` 中的哪个文件到底属于哪个软件。它虽然不会导致系统的问题。毕竟，`/usr/bin` 也是一样混乱的。但是，有一天你想去卸载一个手工安装的软件时它会将成为一个问题。
要解决这个问题，我通常喜欢安装定制的软件到 `/opt` 子目录下。再次引用 FHS：
>
> “`/opt` 是为安装附加的应用程序软件包而保留的。
>
>
> 包安装在 `/opt` 下的软件包必须将它的静态文件放在单独的 `/opt/<package>` 或者 `/opt/<provider>` 目录中，此处 `<package>` 是所说的那个软件名的名字，而 `<provider>` 处是提供者的 LANANA 注册名字。”（LCTT 译注：LANANA 是指 [The Linux Assigned Names And Numbers Authority](http://www.lanana.org/)。 ）
>
>
>
因此，我们将在 `/opt` 下创建一个子目录，用于我们定制的 NodeJS 安装。并且，如果有一天我想去卸载它，我只是很简单地去删除那个目录：
```
sh$ sudo mkdir /opt/node-v8.1.1
sh$ sudo ln -sT node-v8.1.1 /opt/node
# What is the purpose of the symbolic link above?
# Read the article till the end--then try to answer that
# question in the comment section!
sh$ ./configure --prefix=/opt/node-v8.1.1
sh$ make -j9 && echo ok
# -j9 means run up to 9 parallel tasks to build the software.
# As a rule of thumb, use -j(N+1) where N is the number of cores
# of your system. That will maximize the CPU usage (one task per
# CPU thread/core + a provision of one extra task when a process
# is blocked by an I/O operation.
```
在你运行完成 `make` 命令之后，如果有任何的除了 “ok” 以外的信息，将意味着在构建过程中有错误。当我们使用一个 `-j` 选项去运行并行构建时，在构建系统的大量输出过程中，检索错误信息并不是件很容易的事。
在这种情况下，只能是重新开始 `make`，并且不要使用 `-j` 选项。这样错误将会出现在输出信息的最后面：
```
sh$ make
```
最终，编译结束后，你可以运行这个命令去安装你的软件：
```
sh$ sudo make install
```
然后测试它：
```
sh$ /opt/node/bin/node --version
v8.1.1
```
### B. 如果在源代码安装的过程中出现错误怎么办？
我上面介绍的大多是你能在文档完备的项目的“构建指令”页面上看到。但是，本文的目标是让你从源代码开始去编译你的第一个软件，它可能要花一些时间去研究一些常见的问题。因此，我将再次重新开始一遍整个过程，但是，这次是在一个最新的、最小化安装的 Debian 9.0 和 CentOS 7.0 系统上。因此，你可能看到我遇到的错误以及我怎么去解决它。
#### 从 Debian 9.0 中 “Stretch” 开始
```
itsfoss@debian:~$ git clone --depth 1 \
--branch v8.1.1 \
https://github.com/nodejs/node
-bash: git: command not found
```
这个问题非常容易去诊断和解决。去安装这个 `git` 包即可：
```
itsfoss@debian:~$ sudo apt-get install git
```
```
itsfoss@debian:~$ git clone --depth 1 \
--branch v8.1.1 \
https://github.com/nodejs/node && echo ok
[...]
ok
```
```
itsfoss@debian:~/node$ sudo mkdir /opt/node-v8.1.1
itsfoss@debian:~/node$ sudo ln -sT node-v8.1.1 /opt/node
```
现在没有问题了。
```
itsfoss@debian:~/node$ ./configure --prefix=/opt/node-v8.1.1/
WARNING: failed to autodetect C++ compiler version (CXX=g++)
WARNING: failed to autodetect C compiler version (CC=gcc)
Node.js configure error: No acceptable C compiler found!
Please make sure you have a C compiler installed on your system and/or
consider adjusting the CC environment variable if you installed
it in a non-standard prefix.
```
很显然，编译一个项目，你需要一个编译器。NodeJS 是使用 [C++ 语言](https://en.wikipedia.org/wiki/C%2B%2B) 写的，我们需要一个 C++ [编译器](https://en.wikipedia.org/wiki/Compiler)。在这里我将安装 `g++`，它就是为这个目的写的 GNU C++ 编译器：
```
itsfoss@debian:~/node$ sudo apt-get install g++
itsfoss@debian:~/node$ ./configure --prefix=/opt/node-v8.1.1/ && echo ok
[...]
ok
```
```
itsfoss@debian:~/node$ make -j9 && echo ok
-bash: make: command not found
```
还差一个其它工具。同样的症状。同样的解决方案：
```
itsfoss@debian:~/node$ sudo apt-get install make
itsfoss@debian:~/node$ make -j9 && echo ok
[...]
ok
```
```
itsfoss@debian:~/node$ sudo make install
[...]
itsfoss@debian:~/node$ /opt/node/bin/node --version
v8.1.1
```
成功！
请注意：我将一次又一次地安装各种工具去展示怎么去诊断编译问题，以及展示怎么去解决这些问题。但是，如果你搜索关于这个主题的更多文档，或者读其它的教程，你将发现，很多发行版有一个 “meta-packages”，它包罗了安装一些或者全部的用于编译软件的常用工具。在基于 Debian 的系统上，你或许遇到过 [build-essentials](https://packages.debian.org/sid/build-essential) 包，它就是这种用作。在基于 Red Hat 的发行版中，它将是 *“Development Tools”* 组。
#### 在 CentOS 7.0 上
```
[itsfoss@centos ~]$ git clone --depth 1 \
--branch v8.1.1 \
https://github.com/nodejs/node
-bash: git: command not found
```
命令没有找到？可以用 `yum` 包管理器去安装它：
```
[itsfoss@centos ~]$ sudo yum install git
```
```
[itsfoss@centos ~]$ git clone --depth 1 \
--branch v8.1.1 \
https://github.com/nodejs/node && echo ok
[...]
ok
```
```
[itsfoss@centos ~]$ sudo mkdir /opt/node-v8.1.1
[itsfoss@centos ~]$ sudo ln -sT node-v8.1.1 /opt/node
```
```
[itsfoss@centos ~]$ cd node
[itsfoss@centos node]$ ./configure --prefix=/opt/node-v8.1.1/
WARNING: failed to autodetect C++ compiler version (CXX=g++)
WARNING: failed to autodetect C compiler version (CC=gcc)
Node.js configure error: No acceptable C compiler found!
Please make sure you have a C compiler installed on your system and/or
consider adjusting the CC environment variable if you installed
it in a non-standard prefix.
```
你知道的：NodeJS 是使用 C++ 语言写的，但是，我的系统缺少合适的编译器。Yum 可以帮到你。因为，我不是一个合格的 CentOS 用户，我实际上是在互联网上搜索到包含 g++ 编译器的包的确切名字的。这个页面指导了我：<https://superuser.com/questions/590808/yum-install-gcc-g-doesnt-work-anymore-in-centos-6-4> 。
```
[itsfoss@centos node]$ sudo yum install gcc-c++
[itsfoss@centos node]$ ./configure --prefix=/opt/node-v8.1.1/ && echo ok
[...]
ok
```
```
[itsfoss@centos node]$ make -j9 && echo ok
[...]
ok
```
```
[itsfoss@centos node]$ sudo make install && echo ok
[...]
ok
```
```
[itsfoss@centos node]$ /opt/node/bin/node --version
v8.1.1
```
再次成功！
### C. 从源代码中对要安装的软件做一些改变
从源代码中安装一个软件，可能是因为你的分发仓库中没有一个可用的特定版本。或者因为你想去 *修改* 那个程序。也可能是修复一个 bug 或者增加一个特性。毕竟，开源软件这些都可以做到。因此，我将抓住这个机会，让你亲自体验怎么去编译你自己的软件。
在这里，我将在 NodeJS 源代码上做一个微小改变。然后，我们将看到我们的改变将被纳入到软件的编译版本中：
用你喜欢的 [文本编辑器](https://en.wikipedia.org/wiki/List_of_text_editors)（如，vim、nano、gedit、 … ）打开文件 `node/src/node.cc`。然后，尝试找到如下的代码片段：
```
if (debug_options.ParseOption(argv[0], arg)) {
// Done, consumed by DebugOptions::ParseOption().
} else if (strcmp(arg, "--version") == 0 || strcmp(arg, "-v") == 0) {
printf("%s\n", NODE_VERSION);
exit(0);
} else if (strcmp(arg, "--help") == 0 || strcmp(arg, "-h") == 0) {
PrintHelp();
exit(0);
}
```
它在 [文件的 3830 行](https://github.com/nodejs/node/blob/v8.1.1/src/node.cc#L3830) 附近。然后，修改包含 `printf` 的行，将它替换成如下内容：
```
printf("%s (compiled by myself)\n", NODE_VERSION);
```
然后，返回到你的终端。在继续之前，*为了对强大的 Git 支持有更多的了解*，你可以去检查一下，你修改是文件是否正确：
```
diff --git a/src/node.cc b/src/node.cc
index bbce1022..a5618b57 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -3828,7 +3828,7 @@ static void ParseArgs(int* argc,
if (debug_options.ParseOption(argv[0], arg)) {
// Done, consumed by DebugOptions::ParseOption().
} else if (strcmp(arg, "--version") == 0 || strcmp(arg, "-v") == 0) {
- printf("%s\n", NODE_VERSION);
+ printf("%s (compiled by myself)\n", NODE_VERSION);
exit(0);
} else if (strcmp(arg, "--help") == 0 || strcmp(arg, "-h") == 0) {
PrintHelp();
```
在你前面改变的那行之前，你将看到一个 “-” （减号标志）。而在改变之后的行前面有一个 “+” （加号标志）。
现在可以去重新编译并重新安装你的软件了：
```
make -j9 && sudo make install && echo ok
[...]
ok
```
这个时候，可能失败的唯一原因就是你改变代码时的输入错误。如果就是这种情况，在文本编辑器中重新打开 `node/src/node.cc` 文件并修复错误。
一旦你完成了新修改版本的 NodeJS 的编译和安装，就可以去检查你的修改是否包含到软件中：
```
itsfoss@debian:~/node$ /opt/node/bin/node --version
v8.1.1 (compiled by myself)
```
恭喜你！你对开源程序做出了你的第一个改变！
### D. 让 shell 找到我们定制构建的软件
到目前为止，你可能注意到，我通常启动我新编译的 NodeJS 软件是通过指定到该二进制文件的绝对路径。
```
/opt/node/bin/node
```
这是可以正常工作的。但是，这样太麻烦。实际上有两种办法可以去解决这个问题。但是，去理解它们，你必须首先明白，你的 shell 定位可执行文件是通过在[环境变量](https://en.wikipedia.org/wiki/Environment_variable) `PATH` 中指定的目录里面查找的。
```
itsfoss@debian:~/node$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
```
在这个 Debian 系统上，如果你不指定一个精确的目录做为命令名字的一部分，shell 将首先在 `/usr/local/bin` 中查找可执行程序；如果没有找到，然后进入 `/usr/bin` 中查找；如果没有找到，然后进入 `/bin`查找；如果没有找到，然后进入 `/usr/local/games` 查找；如果没有找到，然后进入 `/usr/games` 查找；如果没有找到，那么，shell 将报告一个错误，*“command not found”*。
由此，我们可以知道有两种方法去确保命令可以被 shell 访问到：将它（该二进制程序）增加到已经配置好的 `PATH` 目录中，或者将包含可执行程序的目录添加到 `PATH` 中。
#### 从 /usr/local/bin 中添加一个链接
只是从 `/opt/node/bin` 中 *拷贝* NodeJS 二进制可执行文件到 `/usr/local/bin` 是一个错误的做法。因为，如果这么做，该可执行程序将无法定位到在 `/opt/node/` 中的需要的其它组件。（软件以它自己的位置去定位它所需要的资源文件是常见的做法）
因此，传统的做法是去使用一个符号链接：
```
itsfoss@debian:~/node$ sudo ln -sT /opt/node/bin/node /usr/local/bin/node
itsfoss@debian:~/node$ which -a node || echo not found
/usr/local/bin/node
itsfoss@debian:~/node$ node --version
v8.1.1 (compiled by myself)
```
这一个简单而有效的解决办法，尤其是，如果一个软件包是由好几个众所周知的可执行程序组成的，因为，你将为每个用户调用的命令创建一个符号链接。例如，如果你熟悉 NodeJS，你知道应用的 `npm` 组件，也应该从 `/usr/local/bin` 做个符号链接。我把这个留给你做练习。
#### 修改 PATH
首先，如果你尝试过前面的解决方案，请先移除前面创建的节点符号链接，去从一个干净的状态开始：
```
itsfoss@debian:~/node$ sudo rm /usr/local/bin/node
itsfoss@debian:~/node$ which -a node || echo not found
not found
```
现在，这里有一个改变你的 `PATH` 的魔法命令：
```
itsfoss@debian:~/node$ export PATH="/opt/node/bin:${PATH}"
itsfoss@debian:~/node$ echo $PATH
/opt/node/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
```
简单说就是，我用环境变量 `PATH` 之前的内容前缀了一个 `/opt/node/bin` 替换了其原先的内容。因此，你可以想像一下，shell 将先进入到 `/opt/node/bin` 目录中查找可执行程序。我们也可以使用 `which` 命令去确认一下：
```
itsfoss@debian:~/node$ which -a node || echo not found
/opt/node/bin/node
itsfoss@debian:~/node$ node --version
v8.1.1 (compiled by myself)
```
鉴于 “符号链接” 解决方案是永久的，只要创建到 `/usr/local/bin` 的符号链接就行了，而对 `PATH` 的改变仅影响到当前的 shell。你可以自己做一些研究，如何做到对 `PATH` 的永久改变。给你一个提示，可以将它写到你的 “profile” 中。如果你找到这个解决方案，不要犹豫，通过下面的评论区共享给其它的读者！
### E. 怎么去卸载刚才从源代码中安装的软件
因为我们定制编译的 NodeJS 软件全部在 `/opt/node-v8.1.1` 目录中，卸载它不需要做太多的工作，仅使用 `rm` 命令去删除那个目录即可：
```
sudo rm -rf /opt/node-v8.1.1
```
注意：`sudo` 和 `rm -rf` 是 “非常危险的鸡尾酒”！一定要在按下回车键之前多检查几次你的命令。你不会得到任何的确认信息，并且如果你删除了错误的目录它是不可恢复的 …
然后，如果你修改了你的 `PATH`，你可以去恢复这些改变。它一点也不复杂。
如果你从 `/usr/local/bin` 创建了一个符号链接，你应该去删除它们：
```
itsfoss@debian:~/node$ sudo find /usr/local/bin \
-type l \
-ilname "/opt/node/*" \
-print -delete
/usr/local/bin/node
```
### 等等？ 依赖地狱在哪里？
作为最终的讨论，如果你读过有关的编译定制软件的文档，你可能听到关于 <ruby> <a href="https://en.wikipedia.org/wiki/Dependency_hell"> 依赖地狱 </a> <rt> dependency hell </rt></ruby> 的说法。那是在你能够成功编译一个软件之前，对那种烦人情况的一个别名，你必须首先编译一个前提条件所需要的库，它又可能要求其它的库，而这些库有可能与你的系统上已经安装的其它软件不兼容。
发行版的软件包维护者的部分工作，就是实际去地解决那些依赖地狱，确保你的系统上的各种软件都使用了兼容的库，并且按正确的顺序去安装。
在这篇文章中，我特意选择了 NodeJS 去安装，是因为它几乎没有依赖。我说 “几乎” 是因为，实际上，它 *有* 依赖。但是，这些源代码的依赖已经预置到项目的源仓库中（在 `node/deps` 子目录下），因此，在你动手编译之前，你不用手动去下载和安装它们。
如果你有兴趣了解更多关于那个问题的知识和学习怎么去处理它。请在下面的评论区告诉我，它将是更高级别的文章的好主题！
---
作者简介：
充满激情的工程师，职业是教师，我的目标是：热心分享我所教的内容，并让我的学生自己培养它们的技能。你也可以在我的网站上联系到我。
---
via: <https://itsfoss.com/install-software-from-source-code/>
作者：[Sylvain Leroux](https://itsfoss.com/author/sylvain/) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 molly-guard 保护你的 Linux/Unix 机器不会被错误地关机/重启
|
Vivek Gite
|
https://www.cyberciti.biz/hardware/how-to-protects-linux-and-unix-machines-from-accidental-shutdownsreboots-with-molly-guard/
|
我去！又是这样。 我还以为我登录到家里的服务器呢。 结果 重启的居然是数据库服务器。 另外我也有时会在错误终端内输入 "shutdown -h 0" 命令。 我知道有些人 经常会犯这个错误 。
|
/data/attachment/album/201712/26/095946d1glghlkvz9wgwk1.jpg.thumb.jpg
|
/data/attachment/album/201712/26/095946d1glghlkvz9wgwk1.jpg
| true | false | true |
lujun9972
| false |
[
"重启",
"关机"
] |
技术
|
{
"viewnum": 6049,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我去！又是这样。 我还以为我登录到家里的服务器呢。 结果 重启的居然是数据库服务器。 另外我也有时会在错误终端内输入 "shutdown -h 0" 命令。 我知道有些人 经常会犯这个错误 。
| 2017-12-26T09:59:51 | 2017-12-26T09:59:51 | 9,173 |
/article-9173-1.html
|
我去！又是这样。 我还以为我登录到家里的服务器呢。 结果 [重启的居然是数据库服务器](https://www.cyberciti.biz/faq/howto-reboot-linux/)。 另外我也有时会在错误终端内输入 “[shutdown -h 0](https://www.cyberciti.biz/faq/shutdown-linux-server/)” 命令。 我知道有些人 [经常会犯这个错误](https://www.cyberciti.biz/tips/my-10-unix-command-line-mistakes.html "My 10 UNIX Command Line Mistakes") 。
有办法解决这个问题吗？我真的只能忍受这种随机重启和关机的痛苦吗？ 虽说人总是要犯错的，但总不能一错再错吧。
最新我在 tweet 上发了一通牢骚：
>
> 我总是一遍又一遍地犯下同样的错误 :( 本来应该输入： `sudo virsh reboot d1`
>
>
> 却总是输错重启了自己的电脑 `sudo reboot d1`
>
>
> -- nixCraft (@nixcraft) [February 19，2017](https://twitter.com/nixcraft/status/833320792880320513)
>
>
>
结果收到了一些建议。我们来试一下。
### 向你引荐 molly guard
Molly-Guard **尝试阻止你不小心关闭或重启 Linux 服务器**。它在 Debian/Ubuntu 中的包描述为：
>
> 这个包会安装一个 shell 脚本来屏蔽现有的 `shutdown`/`reboot`/`halt`/`poweroff`/`coldreboot`/`pm-hibernate`/`pm-suspend*` 命令。 `molly-gurad` 会首先运行一系列的脚本，只有在所有的脚本都返回成功的条件下， 才会调用真正的命令。 其中一个脚本会检查是否存在 SSH 会话。 如果是通过 SSH 会话调用的命令， shell 脚本会提示你输入相关闭主机的名称。 这应该足够防止你发生意外的关机或重启了。
>
>
>
貌似 [molly-guard](http://catb.org/%7Eesr/jargon/html/M/molly-guard.html) 还是个<ruby> 专有名词 <rt> Jargon File </rt></ruby>：
>
> 一种用于防止由于笨拙或者不小心触碰道大红开关的屏障。最初指的临时盖在 IBM 4341 的大红按钮上的有机玻璃，因为有一个程序员蹒跚学步的女儿（名叫 Molly）一天之内重启了它两次。 后来这个东西也被用来盖住磁盘和网络设备上的停止/重启按钮。在硬件目录中，你很少会看到 “guarded button” 这样无趣的描述"。
>
>
>
### 如何安装 molly guard
使用 [`apt-get` 命令](//www.cyberciti.biz/tips/linux-debian-package-management-cheat-sheet.html "See Linux/Unix apt-get command examples for more info") 或者 [`apt` 命令](//www.cyberciti.biz/faq/ubuntu-lts-debian-linux-apt-command-examples/ "See Linux/Unix apt command examples for more info") 来搜索并安装 molly-guard：
```
$ apt search molly-guard
$ sudo apt-get install molly-guard
```
结果为：
[](https://www.cyberciti.biz/hardware/how-to-protects-linux-and-unix-machines-from-accidental-shutdownsreboots-with-molly-guard/attachment/install-molly-guard-on-linux/)
### 测试一下
输入 [`reboot` 命令](https://www.cyberciti.biz/faq/linux-reboot-command/ "See Linux/Unix reboot command examples for more info") 和 `shutdown` 命令：
```
$ sudo reboot
# reboot
$ shutdown -h 0
# sudo shutdown -h 0
### running wrong command such as follows instead of
### sudo virsh reboot vm_name_here
$ sudo reboot vm_name_here
```
结果为：
我超级喜欢 molly-guard。因此我将下行内容加入到 `apt-debian-ubuntu-common.yml` 文件中了：
```
- apt：
name： molly-guard
```
是的。我使用 Ansible 在所有的 Debian 和 Ubuntu 服务器上都自动安装上它了。
**相关** ： [我的 10 大 UNIX 命令行错误](https://www.cyberciti.biz/tips/my-10-unix-command-line-mistakes.html)
### 如果我的 Linux 发行版或者 Unix 系统（比如 FreeBSD） 没有 molly-guard 怎么办呢？
不用怕，[设置 shell 别名](https://www.cyberciti.biz/tips/bash-aliases-mac-centos-linux-unix.html) ：
```
## bash shell example ###
alias reboot = "echo 'Are you sure？' If so， run /sbin/reboot"
alias shutdown = "echo 'Are you sure？' If so， run /sbin/shutdown"
```
你也可以 [临时取消别名机制运行真正的命令](https://www.cyberciti.biz/faq/bash-shell-temporarily-disable-an-alias/)。比如要运行 reboot 可以这样：
```
# \reboot
```
或者
```
# /sbin/reboot
```
另外你也可以写一个 [shell/perl/python 脚本来调用这些命令并要求](https://github.com/kjetilho/clumsy_protect) 确认 `reboot`/`halt`/`shutdown` 的选项。
---
via: <https://www.cyberciti.biz/hardware/how-to-protects-linux-and-unix-machines-from-accidental-shutdownsreboots-with-molly-guard/>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Undistract-me：当长时间运行的终端命令完成时获取通知
|
Sk
|
https://www.ostechnix.com/undistract-get-notification-long-running-terminal-commands-complete/
|
想象这个场景。你运行着一个需要一段时间才能完成的命令。与此同时，你查看你的 Facebook，并参与其中。过了一会儿，你记得你几分钟前执行了一个命令。你回到终端，注意到这个命令已经完成了。但是你不知道命令何时完成。你有没有遇到这种情况？
|
/data/attachment/album/201712/26/142149rlcchc8maxwyymfm.png.thumb.jpg
|
/data/attachment/album/201712/26/142149rlcchc8maxwyymfm.png
| true | false | true |
geekpi
| false |
[
"命令",
"运行"
] |
桌面应用
|
{
"viewnum": 7506,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
想象这个场景。你运行着一个需要一段时间才能完成的命令。与此同时，你查看你的 Facebook，并参与其中。过了一会儿，你记得你几分钟前执行了一个命令。你回到终端，注意到这个命令已经完成了。但是你不知道命令何时完成。你有没有遇到这种情况？
| 2017-12-26T14:21:46 | 2017-12-26T14:21:46 | 9,174 |
/article-9174-1.html
|
前一段时间，我们发表了如何[在终端活动完成时获取通知](https://www.ostechnix.com/get-notification-terminal-task-done/)。今天，我发现了一个叫做 “undistract-me” 的类似工具，它可以在长时间运行的终端命令完成时通知你。想象这个场景。你运行着一个需要一段时间才能完成的命令。与此同时，你查看你的 Facebook，并参与其中。过了一会儿，你记得你几分钟前执行了一个命令。你回到终端，注意到这个命令已经完成了。但是你不知道命令何时完成。你有没有遇到这种情况？我敢打赌，你们大多数人遇到过许多次这种情况。这就是 “undistract-me” 能帮助的了。你不需要经常检查终端，查看命令是否完成。长时间运行的命令完成后，undistract-me 会通知你。它能在 Arch Linux、Debian、Ubuntu 和其他 Ubuntu 衍生版上运行。
### 安装 Undistract-me
Undistract-me 可以在 Debian 及其衍生版（如 Ubuntu）的默认仓库中使用。你要做的就是运行下面的命令来安装它。
```
sudo apt-get install undistract-me
```
Arch Linux 用户可以使用任何帮助程序从 AUR 安装它。
使用 [Pacaur](https://www.ostechnix.com/install-pacaur-arch-linux/)：
```
pacaur -S undistract-me-git
```
使用 [Packer](https://www.ostechnix.com/install-packer-arch-linux-2/)：
```
packer -S undistract-me-git
```
使用 [Yaourt](https://www.ostechnix.com/install-yaourt-arch-linux/)：
```
yaourt -S undistract-me-git
```
然后，运行以下命令将 “undistract-me” 添加到 Bash 中。
```
echo 'source /etc/profile.d/undistract-me.sh' >> ~/.bashrc
```
或者，你可以运行此命令将其添加到你的 Bash：
```
echo "source /usr/share/undistract-me/long-running.bash\nnotify_when_long_running_commands_finish_install" >> .bashrc
```
如果你在 Zsh shell 中，请运行以下命令：
```
echo "source /usr/share/undistract-me/long-running.bash\nnotify_when_long_running_commands_finish_install" >> .zshrc
```
最后让更改生效。
对于 Bash：
```
source ~/.bashrc
```
对于 Zsh：
```
source ~/.zshrc
```
### 配置 Undistract-me
默认情况下，Undistract-me 会将任何超过 10 秒的命令视为长时间运行的命令。你可以通过编辑 `/usr/share/undistract-me/long-running.bash` 来更改此时间间隔。
```
sudo nano /usr/share/undistract-me/long-running.bash
```
找到 `LONG_RUNNING_COMMAND_TIMEOUT` 变量并将默认值（`10` 秒）更改为你所选择的其他值。
[](http://www.ostechnix.com/wp-content/uploads/2017/11/undistract-me-1.png)
保存并关闭文件。不要忘记让更改生效：
```
source ~/.bashrc
```
此外，你可以禁用特定命令的通知。为此，找到 `LONG_RUNNING_IGNORE_LIST` 变量并像下面那样用空格分隔命令。
默认情况下，只有当活动窗口不是命令运行的窗口时才会显示通知。也就是说，只有当命令在后台终端窗口中运行时，它才会通知你。如果该命令在活动窗口终端中运行，则不会收到通知。如果你希望无论终端窗口可见还是在后台都发送通知，你可以将 `IGNORE_WINDOW_CHECK` 设置为 `1` 以跳过窗口检查。
Undistract-me 的另一个很酷的功能是当命令完成时，你可以设置音频通知和可视通知。默认情况下，它只会发送一个可视通知。你可以通过在命令行上将变量 `UDM_PLAY_SOUND` 设置为非零整数来更改此行为。但是，你的 Ubuntu 系统应该安装 pulseaudio-utils 和 sound-theme-freedesktop 程序来启用此功能。
请记住，你需要运行以下命令来更新所做的更改。
对于 Bash：
```
source ~/.bashrc
```
对于 Zsh：
```
source ~/.zshrc
```
现在是时候来验证这是否真的有效。
### 在长时间运行的终端命令完成时获取通知
现在，运行任何需要超过 10 秒或者你在 Undistract-me 脚本中定义的时间的命令
我在 Arch Linux 桌面上运行以下命令：
```
sudo pacman -Sy
```
这个命令花了 32 秒完成。上述命令完成后，我收到以下通知。
[](http://www.ostechnix.com/wp-content/uploads/2017/11/undistract-me-2.png)
请记住，只有当给定的命令花了超过 10 秒才能完成时，Undistract-me 脚本才会通知你。如果命令在 10 秒内完成，你将不会收到通知。当然，你可以按照上面的“配置”部分所述更改此时间间隔设置。
我发现这个工具非常有用。在我迷失在其他任务上时，它帮助我回到正事。我希望这个工具也能对你有帮助。
还有更多的工具。保持耐心！
干杯！
资源：
* [Undistract-me GitHub 仓库](https://github.com/jml/undistract-me)
---
via: <https://www.ostechnix.com/undistract-get-notification-long-running-terminal-commands-complete/>
作者：[sk](https://www.ostechnix.com/author/sk/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GitHub 欢迎一切 CI 工具
|
Jonico
|
https://github.com/blog/2463-github-welcomes-all-ci-tools
|
持续集成（CI）工具可以帮助你在每次提交时执行测试，并将报告结果提交到合并请求，从而帮助维持团队的质量标准。结合持续交付（CD）工具，你还可以在多种配置上测试你的代码，运行额外的性能测试，并自动执行每个步骤，直到进入产品阶段。
|
/data/attachment/album/201712/26/143738wtboxug1zthtq55g.png.thumb.jpg
|
/data/attachment/album/201712/26/143738wtboxug1zthtq55g.png
| true | false | true |
geekpi
| false |
[
"GitHub",
"CI",
"CD"
] |
新闻
|
{
"viewnum": 6477,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 1,
"likes": 0
}
|
[] |
[] |
持续集成（CI）工具可以帮助你在每次提交时执行测试，并将报告结果提交到合并请求，从而帮助维持团队的质量标准。结合持续交付（CD）工具，你还可以在多种配置上测试你的代码，运行额外的性能测试，并自动执行每个步骤，直到进入产品阶段。
| 2017-12-26T14:37:00 | 2017-12-26T14:37:00 | 9,175 |
/article-9175-1.html
|
持续集成（[CI](https://en.wikipedia.org/wiki/Continuous_integration)）工具可以帮助你在每次提交时执行测试，并将[报告结果](https://github.com/blog/2051-protected-branches-and-required-status-checks)提交到合并请求，从而帮助维持团队的质量标准。结合持续交付（[CD](https://en.wikipedia.org/wiki/Continuous_delivery)）工具，你还可以在多种配置上测试你的代码，运行额外的性能测试，并自动执行每个步骤，[直到进入产品阶段](https://developer.github.com/changes/2014-01-09-preview-the-new-deployments-api/)。
有几个[与 GitHub 集成](https://github.com/works-with/category/continuous-integration)的 CI 和 CD 工具，其中一些可以在 [GitHub Marketplace](https://github.com/marketplace/category/continuous-integration) 中点击几下安装。有了这么多的选择，你可以选择最好的工具 —— 即使它不是与你的系统预集成的工具。
最适合你的工具取决于许多因素，其中包括：
* 编程语言和程序架构
* 你计划支持的操作系统和浏览器
* 你团队的经验和技能
* 扩展能力和增长计划
* 依赖系统的地理分布和使用的人
* 打包和交付目标
当然，无法为所有这些情况优化你的 CI 工具。构建它们的人需要选择哪些情况下服务更好，何时优先考虑复杂性而不是简单性。例如，如果你想测试针对一个平台的用特定语言编写的小程序，那么你就不需要那些可在数十个平台上测试，有许多编程语言和框架的，用来测试嵌入软件控制器的复杂工具。
如果你需要一些灵感来挑选最好使用哪个 CI 工具，那么看一下 [Github 上的流行项目](https://github.com/explore?trending=repositories#trending)。许多人在他们的 README.md 中将他们的集成的 CI/CD 工具的状态显示为徽章。我们还分析了 GitHub 社区中超过 5000 万个仓库中 CI 工具的使用情况，并发现了很多变化。下图显示了根据我们的拉取请求中使用最多的[提交状态上下文](https://developer.github.com/v3/repos/statuses/)，GitHub.com 使用的前 10 个 CI 工具的相对百分比。
*我们的分析还显示，许多团队在他们的项目中使用多个 CI 工具，使他们能够发挥它们最擅长的。*
[](https://user-images.githubusercontent.com/7321362/32575895-ea563032-c49a-11e7-9581-e05ec882658b.png)
如果你想查看，下面是团队中使用最多的 10 个工具：
* [Travis CI](https://travis-ci.org/)
* [Circle CI](https://circleci.com/)
* [Jenkins](https://jenkins.io/)
* [AppVeyor](https://www.appveyor.com/)
* [CodeShip](https://codeship.com/)
* [Drone](http://try.drone.io/)
* [Semaphore CI](https://semaphoreci.com/)
* [Buildkite](https://buildkite.com/)
* [Wercker](http://www.wercker.com/)
* [TeamCity](https://www.jetbrains.com/teamcity/)
这只是尝试选择默认的、预先集成的工具，而没有花时间根据任务研究和选择最好的工具，但是对于你的特定情况会有很多[很好的选择](https://github.com/works-with/category/continuous-integration)。如果你以后改变主意，没问题。当你为特定情况选择最佳工具时，你可以保证量身定制的性能和不再适合时互换的自由。
准备好了解 CI 工具如何适应你的工作流程了么？
* [浏览 GitHub Marketplace](https://github.com/marketplace/category/continuous-integration)
---
via: <https://github.com/blog/2463-github-welcomes-all-ci-tools>
作者：[jonico](https://github.com/jonico) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
GIT 命令“从初学到专业”完整进阶指南
|
Shusain
|
http://linuxtechlab.com/beginners-to-pro-guide-for-git-commands/
|
本教程，我们将讨论如何使用 git，比如与 git 一起使用的各种命令。所以我们开始吧。
|
/data/attachment/album/201712/26/153323ahv8v9bdotohwdtu.png.thumb.jpg
|
/data/attachment/album/201712/26/153323ahv8v9bdotohwdtu.png
| true | false | true |
liuxinyu123
| false |
[
"git"
] |
软件开发
|
{
"viewnum": 6029,
"commentnum": 0,
"favtimes": 11,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
本教程，我们将讨论如何使用 git，比如与 git 一起使用的各种命令。所以我们开始吧。
| 2017-12-28T10:29:00 | 2017-12-28T10:29:00 | 9,176 |
/article-9176-1.html
|
在[之前的教程](http://linuxtechlab.com/install-git-linux-ubuntu-centos/)中，我们已经学习了在机器上安装 git。本教程，我们将讨论如何使用 git，比如与 git 一起使用的各种命令。所以我们开始吧。
* 推荐阅读：[如何在 Linux 上安装 GIT (Ubuntu 和 CentOS)](http://linuxtechlab.com/install-git-linux-ubuntu-centos/)
### 设置用户信息
这应该是安装完 git 的第一步。我们将添加用户信息 (用户名和邮箱)，所以当我们提交代码时，会产生带有用户信息的提交信息，这使得跟踪提交过程变得更容易。要添加用户信息，命令是 `git config`：
```
$ git config --global user.name "Daniel"
$ git config --global user.email "dan.mike@xyz.com"
```
添加完用户信息之后，通过运行下面命令，我们将检查这些信息是否成功更新。
```
$ git config --list
```
我们应该能够看到输出的用户信息。
### GIT 命令
#### 新建一个仓库
为了建立一个新仓库，运行如下命令：
```
$ git init
```
#### 查找一个仓库
为了查找一个仓库，命令如下：
```
$ git grep "repository"
```
#### 与远程仓库连接
为了与远程仓库连接，运行如下命令：
```
$ git remote add origin remote_server
```
然后检查所有配置的远程服务器，运行如下命令：
```
$ git remote -v
```
#### 克隆一个仓库
为了从本地服务器克隆一个仓库，运行如下代码：
```
$ git clone repository_path
```
如果我们想克隆远程服务器上的一个仓库，那克隆这个仓库的命令是：
```
$ git clone repository_path
```
#### 在仓库中列出分支
为了检查所有可用的和当前工作的分支列表，执行：
```
$ git branch
```
#### 创建新分支
创建并使用一个新分支，命令是：
```
$ git checkout -b 'branchname'
```
#### 删除一个分支
为了删除一个分支，执行：
```
$ git branch -d 'branchname'
```
为了删除远程仓库的一个分支，执行：
```
$ git push origin:'branchname'
```
#### 切换到另一个分支
从当前分支切换到另一个分支，使用
```
$ git checkout 'branchname'
```
#### 添加文件
添加文件到仓库，执行：
```
$ git add filename
```
#### 文件状态
检查文件状态 (那些将要提交或者添加的文件)，执行：
```
$ git status
```
#### 提交变更
在我们添加一个文件或者对一个文件作出变更之后，我们通过运行下面命令来提交代码：
```
$ git commit -a
```
提交变更到 head 但不提交到远程仓库，命令是：
```
$ git commit -m "message"
```
#### 推送变更
推送对该仓库 master 分支所做的变更，运行：
```
$ git push origin master
```
#### 推送分支到仓库
推送对单一分支做出的变更到远程仓库，运行：
```
$ git push origin 'branchname'
```
推送所有分支到远程仓库，运行：
```
$ git push -all origin
```
#### 合并两个分支
合并另一个分支到当前活动分支，使用命令：
```
$ git merge 'branchname'
```
#### 从远端服务器合并到本地服务器
从远端服务器下载/拉取变更到到本地服务器的工作目录，运行：
```
$ git pull
```
#### 检查合并冲突
查看对库文件的合并冲突，运行：
```
$ git diff -base 'filename'
```
查看所有冲突，运行：
```
$ git diff
```
如果我们在合并之前想预览所有变更，运行：
```
$ git diff 'source-branch' 'target-branch'
```
#### 创建标记
创建标记来标志任一重要的变更，运行：
```
$ git tag 'tag number' 'commit id'
```
通过运行以下命令，我们可以查找 commit id ：
```
$ git log
```
#### 推送标记
推送所有创建的标记到远端服务器，运行：
```
$ git push -tags origin
```
#### 恢复做出的变更
如果我们想用 head 中最后一次变更来替换对当前工作树的变更，运行：
```
$ git checkout -'filename'
```
我们也可以从远端服务器获取最新的历史，并且将它指向本地仓库的 master 分支,而不是丢弃掉所有本地所做所有变更。为了这么做，运行：
```
$ git fetch origin
$ git reset -hard master
```
好了，伙计们。这些就是我们使用 git 服务器的命令。我们将会很快为大家带来更有趣的教程。如果你希望我们对某个特定话题写一个教程，请通过下面的评论箱告诉我们。像往常一样， 欢迎您的各种意见和建议。
---
via: <http://linuxtechlab.com/beginners-to-pro-guide-for-git-commands/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[liuxinyu123](https://github.com/liuxinyu123) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
OnionShare：匿名共享文件
|
Anirudh Rayapeddi
|
https://www.theitstuff.com/onionshare-share-files-anonymously-2
|
习惯 Bit Torrent 之后，大小已经不是问题了，但安全性仍旧是。
|
/data/attachment/album/201712/26/182529sfrrddfthxheehhn.jpg.thumb.jpg
|
/data/attachment/album/201712/26/182529sfrrddfthxheehhn.jpg
| true | false | true |
geekpi
| false |
[
"Tor",
"隐私"
] |
分享
|
{
"viewnum": 12150,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
习惯 Bit Torrent 之后，大小已经不是问题了，但安全性仍旧是。
| 2017-12-27T18:23:00 | 2017-12-27T18:23:00 | 9,177 |
/article-9177-1.html
|
在这个数字世界中，我们通过互联网使用 Dropbox、Mega、Google Drive 等不同云存储分享我们的媒体、文档和重要文件。但是每个云存储都有两个主要问题，一个是大小和另一个安全。习惯 Bit Torrent 之后，大小已经不是问题了，但安全性仍旧是。
即使你通过安全的云服务发送文件，该公司也会注意到这些文件，如果这些文件是保密的，政府甚至可以拿到它们。因此，为了克服这些问题，我们使用 OnionShare，如它的名字那样它使用洋葱网络也就是 Tor 来匿名分享文件给任何人。
### 如何使用 **OnionShare**？
首先下载 [OnionShare](https://onionshare.org/) 和 [Tor浏览器](https://www.torproject.org/projects/torbrowser.html.en)。下载后安装它们。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/Icons.png)
现在从开始菜单打开 OnionShare
[](http://www.theitstuff.com/wp-content/uploads/2017/12/Onion-Share.png)
点击添加并添加一个文件/文件夹共享。
点击开始分享。它会产生一个 .onion 网址，你可以与你的收件人分享这个网址。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/With-Link.png)
从 URL 下载文件，复制 URL 并打开 Tor 浏览器并粘贴。打开 URL 并下载文件/文件夹。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/Tor.png)
### OnionShare 的起源
几年前，Glenn Greenwald 发现他从 Edward Snowden 收到的一些 NSA 的文件已经被损坏。但他需要该文件，并决定通过使用 USB 获取那些文件。这并不成功。
在阅读了 Greenwald 写的书后，The Intercept 的安全专家 Micah Lee 发布了 OnionShare —— 一个简单的免费软件，可以匿名和安全地共享文件。他创建了一个程序，通过一个被匿名软件 Tor 加密和保护的直接通道来分享大型数据转储，使窃取者难以获取文件。
### OnionShare 如何工作？
OnionShare 在 127.0.0.1 上启动了一个 Web 服务器，用于在随机端口上共享文件。它从有 6880 个单词的单词列表中选择任意两个单词，称为 slug。它使服务器可以作为 Tor 洋葱服务发送文件。最终的 URL 看起来像这样：
```
http://qx2d7lctsnqwfdxh.onion/subside-durable
```
OnionShare 在下载后关闭。有一个选项允许多次下载文件。这使得该文件在互联网上不能再次得到。
### 使用 OnionShare 好处
其他网站或程序可以访问你的文件：发件人使用 OnionShare 共享的文件不存储在任何服务器上。它直接托管在发件人的系统上。
没有人可以窥探共享文件：由于用户之间的连接是由洋葱服务和 Tor 浏览器加密的。这使得连接安全，很难窃取文件。
用户双方都是匿名的：OnionShare 和 Tor 浏览器使发件人和收件人匿名。
### 结论
在这篇文章中，我已经解释了如何**匿名分享你的文档、文件**。我也解释了它是如何工作的。希望你了解 OnionShare 是如何工作的，如果你对任何事情仍有疑问，只需留言。
---
via: <https://www.theitstuff.com/onionshare-share-files-anonymously-2>
作者：[Anirudh Rayapeddi](https://www.theitstuff.com) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
2018 年开源技术 10 大发展趋势
|
Sreejith Omanakuttan
|
https://opensource.com/article/17/11/10-open-source-technology-trends-2018
|
技术一直在变革，诸如 OpenStack、增强型网页应用（PWA）、Rust、R、认知云、人工智能（AI），物联网等一些新技术正在颠覆我们对世界的固有认知。以下概述了 2018 年最可能成为主流的开源技术。
|
/data/attachment/album/201712/27/085930grj6p6jwpwwpewej.png.thumb.jpg
|
/data/attachment/album/201712/27/085930grj6p6jwpwwpewej.png
| true | false | true |
wangy325
| false |
[
"趋势",
"技术",
"开源"
] |
观点
|
{
"viewnum": 8481,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "211.102.192.66",
"message": "RUST、区块链个人比较看好",
"username": "编程浪子 [Chrome 62.0|Windows 7]",
"date": "2017-12-27T17:11:13"
}
] |
[] |
技术一直在变革，诸如 OpenStack、增强型网页应用（PWA）、Rust、R、认知云、人工智能（AI），物联网等一些新技术正在颠覆我们对世界的固有认知。以下概述了 2018 年最可能成为主流的开源技术。
| 2017-12-27T08:59:24 | 2017-12-27T08:59:24 | 9,178 |
/article-9178-1.html
|
>
> 你是否关注过开源技术的发展趋势？ 这里是 10 个预测。
>
>
>
技术一直在变革，诸如 OpenStack、<ruby> 增强型网页应用 <rt> Progressive Web App </rt></ruby>（PWA）、Rust、R、<ruby> 认知云 <rt> the cognitive cloud </rt></ruby>、人工智能（AI），物联网等一些新技术正在颠覆我们对世界的固有认知。以下概述了 2018 年最可能成为主流的开源技术。
### 1、 OpenStack 认可度持续高涨
[OpenStack](https://www.openstack.org/) 本质上是一个云操作平台（系统），它为管理员提供直观友好的控制面板，以便对大量的计算、存储和网络资源进行配置和监管。
目前，很多企业运用 OpenStack 平台搭建和管理云计算系统。得益于其灵活的生态系统、透明度和运行速度，OpenStack 越来越流行。相比其他替代方案，OpenStack 只需更少的花费便能轻松支持任务关键型应用程序。 但是，其复杂的结构以及其对虚拟化、服务器和大量网络资源的严重依赖使得不少企业对使用 OpenStack 心存顾虑。另外，想要用好 OpenStack，好的硬件支持和高水平的员工二者缺一不可。
OpenStack 基金会一直在致力于完善他们的产品。一些功能创新，无论是已经发布的还是尚处于打造阶段，都将解决许多 OpenStack 潜在的问题。随着其结构复杂性降低，OpenStack 将获取更大认可。加之众多大型的软件开发及托管公司以及成千上万会员的支持， OpenStack 在云计算时代前途光明。
### 2、 PWA 或将大热
PWA，即 <ruby> <a href="https://developers.google.com/web/progressive-web-apps/"> 增强型网页应用 </a> <rt> Progressive Web App </rt></ruby>，是对技术、设计和<ruby> 网络应用程序接口 <rt> Web API </rt></ruby>的整合，它能够在移动浏览器上提供类似应用的体验。
传统的网站有许多与生俱来的缺点。虽然应用（app）提供了比网站更加个性化、用户参与度更高的体验，但是却要占用大量的系统资源；并且要想使用应用，你还必须提前下载安装。PWA 则扬长避短，它可用浏览器访问、可被引擎搜索检索，并可响应式适应外在环境，为用户提供应用级体验。PWA 也能像应用一样自我更新，总是显示最新的实时信息，并且像网站一样，以极其安全的 HTTPS 模式递交信息。PWA 运行于标准容器中，无须安装，任何人只要输入 URL 即可访问。
现在的移动用户看重便利性和参与度，PWAs 的特性完美契合这一需求，所以 PWA 成为主流是必然趋势。
### 3、 Rust 成开发者新宠
大多数的编程语言都需在安全和控制二者之间折衷，但 [Rust](https://www.rust-lang.org/) 是一个例外。Rust 使用广泛的编译时检查进行 100% 的控制而不影响程序安全性。上一次 [Pwn2Own](https://en.wikipedia.org/wiki/Pwn2Own) 竞赛找出了 Firefox C++ 底层实现的许多严重漏洞。如果 Firefox 是用 Rust 编写的，这些漏洞在产品发布之前的编译阶段就会被发现并解决。
Rust 独特的内建单元测试方式使开发者们考虑将其作为首选的开源语言。它是 C 和 Python 等其他编程语言有效的替代方案，Rust 可以在不损失程序可读性的情况下写出安全的代码。总之，Rust 前途光明。
### 4、 R 用户群在壮大
[R](https://en.wikipedia.org/wiki/R_(programming_language)) 编程语言，是一个与统计计算和图像呈现相关的 [GUN 项目](https://en.wikipedia.org/wiki/GNU_Project)。它提供了大量的统计和图形技术，并且可扩展增强。它是 [S](https://en.wikipedia.org/wiki/S_(programming_language)) 语言的延续。S 语言早已成为统计方法学的首选工具，R 为数据操作、计算和图形显示提供了开源选择。R 语言的另一个优势是对细节的把控和对细微差别的关注。
和 Rust 一样，R 语言也处于上升期。
### 5、 广义的 XaaS
XaaS 是 “<ruby> 一切皆服务 <rt> anything as a service </rt></ruby>” 的缩写，是通过网络提供的各种线上服务的总称。XaaS 的外延正在扩大，软件即服务（SaaS）、基础设施即服务（IaaS） 和平台即服务（PaaS）等观念已深入人心，新兴的基于云的服务如网络即服务（NaaS）、存储即服务（SaaS 或 StaaS）、监控即服务（MaaS）以及通信即服务（CaaS）等概念也正在普及。我们正在迈向一个万事万物 “皆为服务” 的世界。
现在，XaaS 的概念已经延伸到实体企业。著名的例子有 Uber 、Lyft 和 Airbnb，前二者利用新科技提供交通服务，后者提供住宿服务。
高速网络和服务器虚拟化使得强大的计算能力成为可能，这加速了 XaaS 的发展，2018 年可能是 “XaaS 年”。XaaS 无与伦比的灵活性、可扩展性将推动 XaaS 进一步发展。
### 6、 容器技术越来越受欢迎
[容器技术](https://www.techopedia.com/2/31967/trends/open-source/container-technology-the-next-big-thing)，是用标准化方法打包代码的技术，它使得代码能够在任意环境中快速地 “接入并运行”。容器技术让企业可以削减经费、降低实施周期。尽管容器技术在 IT 基础结构改革方面的已经初显潜力，但事实上，运用好容器技术仍然比较复杂。
容器技术仍在发展中，技术复杂性随着各方面的进步在下降。最新的技术让容器使用起来像使用智能手机一样简单、直观，更不用说现在的企业需求：速度和灵活性往往能决定业务成败。
### 7、 机器学习和人工智能的更广泛应用
[机器学习和人工智能](https://opensource.com/tags/artificial-intelligence) 指在没有程序员给出明确的编码指令的情况下，机器具备自主学习并且积累经验自我改进的能力。
随着一些开源技术利用机器学习和人工智能实现尖端服务和应用，这两项技术已经深入人心。
[Gartner](https://sdtimes.com/gartners-top-10-technology-trends-2018/) 预测，2018 年机器学习和人工智能的应用会更广。其他一些领域诸如数据准备、集成、算法选择、学习方法选择、模块制造等随着机器学习的加入将会取得很大进步。
全新的智能开源解决方案将改变人们和系统交互的方式，转变由来已久的工作观念。
* 机器交互，像[聊天机器人](https://en.wikipedia.org/wiki/Chatbot)这样的对话平台，提供“问与答”的体验——用户提出问题，对话平台作出回应，成为人机之间默认的交互界面。
* 无人驾驶和无人机现在已经家喻户晓了，2018 年将会更司空见惯。
* 沉浸式体验的应用不再仅仅局限于视频游戏，在真实的生活场景比如设计、培训和可视化过程中都能看到沉浸式体验的身影。
### 8、 区块链将成为主流
自比特币应用区块链技术以来，其已经取得了重大进展，并且已广泛应用在金融系统、保密选举、学历验证等领域中。未来几年，区块链会在医疗、制造业、供应链物流、政府服务等领域中大展拳脚。
区块链分布式存储数据信息，这些数据信息依赖于数百万个共享数据库的节点。区块链不被任意单一所有者控制，并且单个损坏的节点不影响其正常运行，区块链的这两个特性让它异常健壮、透明、不可破坏。同时也规避了有人从中篡改数据的风险。区块链强大的先天优势足够支撑其成为将来主流技术。
### 9、 认知云粉墨登场
认识技术，比如前面所述的机器学习和人工智能，用于为多行业提供简单化和个性化服务。一个典型例子是金融行业的游戏化应用，其为投资者提供了严谨的投资建议，降低投资模块的复杂程度。数字信托平台使得金融机构的身份认证过程较以前精简 80%，提升了合规性，降低了诈骗比率。
认知云技术现在正向云端迁移，借助云，它将更加强大。[IBM Watson](https://en.wikipedia.org/wiki/Watson_(computer)) 是认知云应用最知名的例子。IBM 的 UIMA 架构是开源的，由 Apache 基金会负责维护。DARPA（美国国防高级研究计划局）的 DeepDive 项目借鉴了 Watson 的机器学习能力，通过不断学习人类行为来增强决策能力。另一个开源平台 [OpenCog](https://en.wikipedia.org/wiki/OpenCog) ，为开发者和数据科学家开发人工智能应用程序提供支撑。
考虑到实现先进的、个性化的用户体验风险较高，这些认知云平台来年时机成熟时才会粉墨登场。
### 10、 物联网智联万物
物联网（IoT）的核心在于建立小到嵌入式传感器、大至计算机设备的相互连接，让其（“物”）相互之间可以收发数据。毫无疑问，物联网将会是科技界的下一个 “搅局者”，但物联网本身处于一个不断变化的状态。
物联网最广为人知的产品就是 IBM 和三星合力打造的去中心化 P2P 自动遥测系统（[ADEPT](https://insights.samsung.com/2016/03/17/block-chain-mobile-and-the-internet-of-things/)）。它运用和区块链类似的技术来构建一个去中心化的物联网。没有中央控制设备，“物” 之间通过自主交流来进行升级软件、处理 bug、管理电源等等一系列操作。
### 开源推动技术创新
[数字化颠覆](https://cio-wiki.org/home/loc/home?page=digital-disruption)是当今以科技为中心的时代的常态。在技术领域，开放源代码正在逐渐普及，其在 2018 将年成为大多数技术创新的驱动力。
此榜单对开源技术趋势的预测有遗漏？在评论区告诉我们吧！
（题图：[Mitch Bennett](https://www.flickr.com/photos/mitchell3417/9206373620). [Opensource.com](https://opensource.com/) 修改）
### 关于作者
[**Sreejith Omanakuttan**](https://opensource.com/users/sreejith) - 自 2000 年开始编程，2007年开始从事专业工作。目前在 [Fingent](https://www.fingent.com/) 领导开源团队，工作内容涵盖不同的技术层面，从“无聊的工作”（？）到前沿科技。有一套 “构建—修复—推倒重来” 工作哲学。在领英上关注我： <https://www.linkedin.com/in/futuregeek/>
---
via: <https://opensource.com/article/17/11/10-open-source-technology-trends-2018>
作者：[Sreejith Omanakuttan](https://opensource.com/users/sreejith) 译者：[wangy325](https://github.com/wangy25) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
补丁管理：不要以持续运行时间为自豪
|
Kyle Rankin
|
https://www.linuxjournal.com/content/sysadmin-101-patch-management
|
在补丁管理方面一些 Linux 系统管理员和 Windows 系统管理员没有差别。实话说，在一些方面甚至做的更差（特别是以持续运行时间为自豪）。
|
/data/attachment/album/201712/27/104633u8szjopoawfqsnwp.jpg.thumb.jpg
|
/data/attachment/album/201712/27/104633u8szjopoawfqsnwp.jpg
| true | false | true |
haoqixu
| false |
[
"补丁",
"安全",
"升级"
] |
观点
|
{
"viewnum": 5652,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在补丁管理方面一些 Linux 系统管理员和 Windows 系统管理员没有差别。实话说，在一些方面甚至做的更差（特别是以持续运行时间为自豪）。
| 2017-12-27T10:46:54 | 2017-12-27T10:46:54 | 9,179 |
/article-9179-1.html
|
就在之前几篇文章，我开始了“系统管理 101”系列文章，用来记录现今许多初级系统管理员、DevOps 工程师或者“全栈”开发者可能不曾接触过的一些系统管理方面的基本知识。按照我原本的设想，该系列文章已经是完结了的。然而后来 WannaCry 恶意软件出现，并在补丁管理不善的 Windows 主机网络间爆发。我能想象到那些仍然深陷 2000 年代 Linux 与 Windows 争论的读者听到这个消息可能已经面露优越的微笑。
我之所以这么快就决定再次继续“系统管理 101”文章系列，是因为我意识到在补丁管理方面一些 Linux 系统管理员和 Windows 系统管理员没有差别。实话说，在一些方面甚至做的更差（特别是以持续运行时间为自豪）。所以，这篇文章会涉及 Linux 下补丁管理的基础概念，包括良好的补丁管理该是怎样的，你可能会用到的一些相关工具，以及整个补丁安装过程是如何进行的。
### 什么是补丁管理？
我所说的补丁管理，是指你部署用于升级服务器上软件的系统，不仅仅是把软件更新到最新最好的前沿版本。即使是像 Debian 这样为了“稳定性”持续保持某一特定版本软件的保守派发行版，也会时常发布升级补丁用于修补错误和安全漏洞。
当然，如果你的组织决定自己维护特定软件的版本，要么是因为开发者有最新最好版本的需求，需要派生软件源码并做出修改，要么是因为你喜欢给自己额外的工作量，这时你就会遇到问题。理想情况下，你应该已经配置好你的系统，让它在自动构建和打包定制版本软件时使用其它软件所用的同一套持续集成系统。然而，许多系统管理员仍旧在自己的本地主机上按照维基上的文档（但愿是最新的文档）使用过时的方法打包软件。不论使用哪种方法，你都需要明确你所使用的版本有没有安全缺陷，如果有，那必须确保新补丁安装到你定制版本的软件上了。
### 良好的补丁管理是怎样的
补丁管理首先要做的是检查软件的升级。首先，对于核心软件，你应该订阅相应 Linux 发行版的安全邮件列表，这样才能第一时间得知软件的安全升级情况。如果你使用的软件有些不是来自发行版的仓库，那么你也必须设法跟踪它们的安全更新。一旦接收到新的安全通知，你必须查阅通知细节，以此明确安全漏洞的严重程度，确定你的系统是否受影响，以及安全补丁的紧急性。
一些组织仍在使用手动方式管理补丁。在这种方式下，当出现一个安全补丁，系统管理员就要凭借记忆，登录到各个服务器上进行检查。在确定了哪些服务器需要升级后，再使用服务器内建的包管理工具从发行版仓库升级这些软件。最后以相同的方式升级剩余的所有服务器。
手动管理补丁的方式存在很多问题。首先，这么做会使补丁安装成为一个苦力活，安装补丁越多就需要越多人力成本，系统管理员就越可能推迟甚至完全忽略它。其次，手动管理方式依赖系统管理员凭借记忆去跟踪他或她所负责的服务器的升级情况。这非常容易导致有些服务器被遗漏而未能及时升级。
补丁管理越快速简便，你就越可能把它做好。你应该构建一个系统，用来快速查询哪些服务器运行着特定的软件，以及这些软件的版本号，而且它最好还能够推送各种升级补丁。就个人而言，我倾向于使用 MCollective 这样的编排工具来完成这个任务，但是红帽提供的 Satellite 以及 Canonical 提供的 Landscape 也可以让你在统一的管理界面上查看服务器的软件版本信息，并且安装补丁。
补丁安装还应该具有容错能力。你应该具备在不下线的情况下为服务安装补丁的能力。这同样适用于需要重启系统的内核补丁。我采用的方法是把我的服务器划分为不同的高可用组，lb1、app1、rabbitmq1 和 db1 在一个组，而lb2、app2、rabbitmq2 和 db2 在另一个组。这样，我就能一次升级一个组，而无须下线服务。
所以，多快才能算快呢？对于少数没有附带服务的软件，你的系统最快应该能够在几分钟到一小时内安装好补丁（例如 bash 的 ShellShock 漏洞）。对于像 OpenSSL 这样需要重启服务的软件，以容错的方式安装补丁并重启服务的过程可能会花费稍多的时间，但这就是编排工具派上用场的时候。我在最近的关于 MCollective 的文章中（查看 2016 年 12 月和 2017 年 1 月的工单）给了几个使用 MCollective 实现补丁管理的例子。你最好能够部署一个系统，以具备容错性的自动化方式简化补丁安装和服务重启的过程。
如果补丁要求重启系统，像内核补丁，那它会花费更多的时间。再次强调，自动化和编排工具能够让这个过程比你想象的还要快。我能够在一到两个小时内在生产环境中以容错方式升级并重启服务器，如果重启之间无须等待集群同步备份，这个过程还能更快。
不幸的是，许多系统管理员仍坚信过时的观点，把持续运行时间（uptime）作为一种骄傲的象征——鉴于紧急内核补丁大约每年一次。对于我来说，这只能说明你没有认真对待系统的安全性！
很多组织仍然使用无法暂时下线的单点故障的服务器，也因为这个原因，它无法升级或者重启。如果你想让系统更加安全，你需要去除过时的包袱，搭建一个至少能在深夜维护时段重启的系统。
基本上，快速便捷的补丁管理也是一个成熟专业的系统管理团队所具备的标志。升级软件是所有系统管理员的必要工作之一，花费时间去让这个过程简洁快速，带来的好处远远不止是系统安全性。例如，它能帮助我们找到架构设计中的单点故障。另外，它还帮助鉴定出环境中过时的系统，给我们替换这些部分提供了动机。最后，当补丁管理做得足够好，它会节省系统管理员的时间，让他们把精力放在真正需要专业知识的地方。
---
Kyle Rankin 是高级安全与基础设施架构师，其著作包括： Linux Hardening in Hostile Networks，DevOps Troubleshooting 以及 The Official Ubuntu Server Book。同时，他还是 Linux Journal 的专栏作家。
---
via: <https://www.linuxjournal.com/content/sysadmin-101-patch-management>
作者：[Kyle Rankin](https://www.linuxjournal.com/users/kyle-rankin) 译者：[haoqixu](https://github.com/haoqixu) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
UC 浏览器最大的问题
|
Rishabh Kandari
|
https://www.theitstuff.com/biggest-problems-uc-browser
|
我一开始是 Android 上的 Chrome 用户，但我在朋友的推荐下开始使用 UC。但在过去的一年左右，我看到了一些东西让我重新思考我的选择，现在我感觉我要重新回到 Chrome。
|
/data/attachment/album/201712/27/105427vo5izikyryn44jkm.png.thumb.jpg
|
/data/attachment/album/201712/27/105427vo5izikyryn44jkm.png
| true | false | true |
geekpi
| false |
[
"UC",
"浏览器"
] |
观点
|
{
"viewnum": 31991,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "101.22.10.186",
"message": "4cc6ddb3e87107414dec9b037c876d04不定传说正常吗",
"username": "自己123 [Sogou Explorer 2|Windows 7]",
"date": "2018-01-18T17:59:41"
}
] |
[] |
我一开始是 Android 上的 Chrome 用户，但我在朋友的推荐下开始使用 UC。但在过去的一年左右，我看到了一些东西让我重新思考我的选择，现在我感觉我要重新回到 Chrome。
| 2017-12-29T09:52:00 | 2017-12-29T09:52:00 | 9,180 |
/article-9180-1.html
|
在我们开始谈论缺点之前，我要确定的事实是过去 3 年来，我一直是一个忠实的 UC 浏览器用户。我真的很喜欢它的下载速度，超时尚的用户界面和工具上引人注目的图标。我一开始是 Android 上的 Chrome 用户，但我在朋友的推荐下开始使用 UC。但在过去的一年左右，我看到了一些东西让我重新思考我的选择，现在我感觉我要重新回到 Chrome。
### 不需要的**通知**
我相信我不是唯一一个每几个小时内就收到这些不需要的通知的人。这些欺骗点击的文章真的很糟糕，最糟糕的部分是你每隔几个小时就会收到一次。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/Untitled-design-6.png)
我试图从通知设置里关闭他们，但它们仍然以一个更低频率出现。
### **新闻主页**
另一个不需要的部分是完全无用的。我们完全理解 UC 浏览器是免费下载，可能需要资金，但并不应该这么做。这个主页上的新闻文章是非常让人分心且不需要的。有时当你在一个专业或家庭环境中的一些诱骗点击甚至可能会导致尴尬。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/Untitled-design-1-1.png)
而且他们甚至有这样的设置。将 **UC** **新闻显示打开/关闭**。我也试过，猜猜看发生了什么。在下图中，左侧你可以看到我的尝试，右侧可以看到结果。
[](http://www.theitstuff.com/wp-content/uploads/2017/12/uceffort.png)
而且不止诱骗点击新闻，他们已经开始添加一些不必要的功能。所以我也列出它们。
### UC **音乐**
UC 浏览器在浏览器中集成了一个**音乐播放器**来播放音乐。它只是能用，没什么特别的东西。那为什么还要呢？有什么原因呢？谁需要浏览器中的音乐播放器？
[](http://www.theitstuff.com/wp-content/uploads/2017/10/Untitled-design-3-1.png)
它甚至不是在后台直接播放来自网络的音频。相反，它是一个播放离线音乐的音乐播放器。所以为什么要它？我的意思是，它甚至没有好到可以作为主要音乐播放器。即使它足够好，它也不能独立于 UC 浏览器运行。所以为什么会有人运行将他/她的浏览器只是为了使用你的音乐播放器？
### **快速**访问栏
我已经看到平均有 90% 的用户在通知区域挂着这栏，因为它默认安装，并且它们不知道如何摆脱它。右侧的设置可以摆脱它。
[](http://www.theitstuff.com/wp-content/uploads/2017/10/Untitled-design-4-1.png)
但是我还是想问一下，“为什么它是默认的？”。这让大多数用户很头痛。如果我们需要它，就会去启用它。为什么要强迫用户。
### 总结
UC 浏览器仍然是最大的玩家之一。它提供了一个最好的体验，但是，我不知道 UC 通过在浏览中打包进将越来越多的功能并强迫用户使用它们是要证明什么。
我喜欢 UC 的速度和设计。但最近的体验导致我再次考虑我的主要浏览器。
---
via: <https://www.theitstuff.com/biggest-problems-uc-browser>
作者：[Rishabh Kandari](https://www.theitstuff.com/author/reevkandari) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
修复 Linux / Unix / OS X / BSD 系统控制台上的显示乱码
|
Vivek Gite
|
https://www.cyberciti.biz/tips/bash-fix-the-display.html
|
有时我的探索会在屏幕上输出一些奇怪的东西。比如，有一次我不小心用 cat 命令查看了一下二进制文件的内容 —— cat /sbin/*。这种情况下你将无法再访问终端里的 bash/ksh/zsh 了。
|
/data/attachment/album/201712/27/112303wgjngceelpjjj1gx.png.thumb.jpg
|
/data/attachment/album/201712/27/112303wgjngceelpjjj1gx.png
| true | false | true |
lujun9972
| false |
[
"clear",
"reset",
"终端"
] |
技术
|
{
"viewnum": 5277,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "60.209.105.170",
"message": "受教了。我以前遇到这个问题，都是关闭终端模拟器，重新打开。",
"username": "绿色圣光 [Firefox 57.0|GNU/Linux]",
"date": "2018-01-01T14:39:34"
}
] |
[] |
有时我的探索会在屏幕上输出一些奇怪的东西。比如，有一次我不小心用 cat 命令查看了一下二进制文件的内容 —— cat /sbin/*。这种情况下你将无法再访问终端里的 bash/ksh/zsh 了。
| 2017-12-30T08:21:00 | 2017-12-30T08:21:00 | 9,181 |
/article-9181-1.html
|
有时我的探索会在屏幕上输出一些奇怪的东西。比如，有一次我不小心用 `cat` 命令查看了一下二进制文件的内容 —— `cat /sbin/*`。这种情况下你将无法再访问终端里的 bash/ksh/zsh 了。大量的奇怪字符充斥了你的终端。这些字符会隐藏你输入的内容和要显示的字符，取而代之的是一些奇怪的符号。要清理掉这些屏幕上的垃圾可以使用以下方法。本文就将向你描述在 Linux/ 类 Unix 系统中如何真正清理终端屏幕或者重置终端。
### clear 命令
`clear` 命令会清理掉屏幕内容，连带它的回滚缓存区一起也会被清理掉。（LCTT 译注：这种情况下你输入的字符回显也是乱码，不必担心，正确输入后回车即可生效。）
```
$ clear
```
你也可以按下 `CTRL+L` 来清理屏幕。然而，`clear` 命令并不会清理掉终端屏幕（LCTT 译注：这句话比较难理解，应该是指的运行 `clear` 命令并不是真正的把以前显示的内容删掉，你还是可以通过向上翻页看到之前显示的内容）。使用下面的方法才可以真正地清空终端，使你的终端恢复正常。
### 使用 reset 命令修复显示
要修复正常显示，只需要输入 `reset` 命令。它会为你再初始化一次终端：
```
$ reset
```
或者：
```
$ tput reset
```
如果 `reset` 命令还不行，那么输入下面命令来让绘画回复到正常状态：
```
$ stty sane
```
按下 `CTRL + L` 来清理屏幕（或者输入 `clear` 命令）：
```
$ clear
```
### 使用 ANSI 转义序列来真正地清空 bash 终端
另一种选择是输入下面的 ANSI 转义序列：
```
clear
echo -e "\033c"
```
下面是这两个命令的输出示例：
[](https://www.cyberciti.biz/tips/bash-fix-the-display.html/unix-linux-console-gibberish)
更多信息请阅读 `stty` 和 `reset` 的 man 页： stty(1)，reset(1)，bash(1)。
---
via: <https://www.cyberciti.biz/tips/bash-fix-the-display.html>
作者：[Vivek Gite](https://www.cyberciti.biz) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Bash 脚本：正则表达式基础篇
|
Shusain
|
http://linuxtechlab.com/bash-scripting-learn-use-regex-basics/
|
正则表达式（简写为 regex 或者 regexp）基本上是定义一种搜索模式的字符串，可以被用来执行“搜索”或者“搜索并替换”操作，也可以被用来验证像密码策略等条件。
|
/data/attachment/album/201712/27/151130vskd72f2yzdvskuz.jpg.thumb.jpg
|
/data/attachment/album/201712/27/151130vskd72f2yzdvskuz.jpg
| true | false | true |
kimii
| false |
[
"正则表达式",
"脚本"
] |
技术
|
{
"viewnum": 15851,
"commentnum": 0,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
正则表达式（简写为 regex 或者 regexp）基本上是定义一种搜索模式的字符串，可以被用来执行“搜索”或者“搜索并替换”操作，也可以被用来验证像密码策略等条件。
| 2017-12-27T15:11:35 | 2017-12-27T15:11:35 | 9,182 |
/article-9182-1.html
|
<ruby> 正则表达式 <rt> Regular expressions </rt></ruby>（简写为 regex 或者 regexp）基本上是定义一种搜索模式的字符串，可以被用来执行“搜索”或者“搜索并替换”操作，也可以被用来验证像密码策略等条件。
正则表达式是一个我们可利用的非常强大的工具，并且使用正则表达式的优点是它能在几乎所有计算机语言中被使用。所以如果你使用 Bash 脚本或者创建一个 python 程序时，我们可以使用正则表达式，或者也可以写一个单行搜索查询。
在这篇教程中，我们将会学习一些正则表达式的基本概念，并且学习如何在 Bash 中通过 `grep` 使用它们，但是如果你希望在其他语言如 python 或者 C 中使用它们，你只能使用正则表达式部分。那么让我们通过正则表达式的一个例子开始吧，
正则表达式看起来像 `/t[aeiou]l/` 这个样子。
但这是什么意思呢？它意味着所提到的正则表达式将寻找一个词，它以 `t` 开始，在中间包含字母 `a e i o u` 中任意一个，并且字母 `l` 最为最后一个字符。它可以是 `tel`，`tal` 或者 `til`，可以匹配一个单独的词或者其它单词像 `tilt`，`brutal` 或者 `telephone` 的一部分。
grep 使用正则表达式的语法是 `$ grep "regex_search_term" file_location`
如果不理解，不要担心，这只是一个例子，来展示可以利用正则表达式获取什么，相信我，这是最简单的例子。我们可以从正则表达式中获取更多。现在我们将从正则表达式基础的开始。
* 推荐阅读: [你应该知道的有用的 linux 命令](http://linuxtechlab.com/useful-linux-commands-you-should-know/)
### 基础的正则表示式
现在我们开始学习一些被称为<ruby> 元字符 <rt> MetaCharacters </rt></ruby>的特殊字符。它们可以帮助我们创建更复杂的正则表达式搜索项。下面提到的是基本元字符的列表，
* `.` 点将匹配任意字符
* `[ ]` 将匹配一个字符范围
* `[^ ]` 将匹配除了括号中提到的那个之外的所有字符
* `*` 将匹配零个或多个前面的项
* `+` 将匹配一个或多个前面的项
* `?` 将匹配零个或一个前面的项
* `{n}` 将匹配 n 次前面的项
* `{n,}` 将匹配 n 次或更多前面的项
* `{n,m}` 将匹配在 n 和 m 次之间的项
* `{,m}` 将匹配少于或等于 m 次的项
* `\` 是一个转义字符，当我们需要在我们的搜索中包含一个元字符时使用
现在我们将用例子讨论所有这些元字符。
#### `.` （点）
它用于匹配出现在我们搜索项中的任意字符。举个例子，我们可以使用点如：
```
$ grep "d.g" file1
```
这个正则表达式意味着我们在名为 ‘file1’ 的文件中查找的词以 `d` 开始，以 `g`结尾，中间可以有 1 个字符的字符串。同样，我们可以使用任意数量的点作为我们的搜索模式，如 `T......h`，这个查询项将查找一个词，以 `T` 开始，以 `h` 结尾，并且中间可以有任意 6 个字符。
#### `[ ]`
方括号用于定义字符范围。例如，我们需要搜索一些特别的单词而不是匹配任何字符，
```
$ grep "N[oen]n" file2
```
这里，我们正寻找一个单词，以 `N`开头，以 `n` 结尾，并且中间只能有 `o`、`e` 或者 `n` 中的一个。 在方括号中我们可以提到单个到任意数量的字符。
我们在方括号中也可以定义像 `a-e`或者 `1-18` 作为匹配字符的列表。
#### `[^ ]`
这就像正则表达式的 not 操作。当使用 `[^ ]` 时，它意味着我们的搜索将包括除了方括号内提到的所有字符。例如，
```
$ grep "St[^1-9]d" file3
```
这意味着我们可以拥有所有这样的单词，它们以 `St` 开始，以字母 `d` 结尾，并且不得包含从 `1` 到 `9` 的任何数字。
到现在为止，我们只使用了仅需要在中间查找单个字符的正则表达式的例子，但是如果我们需要更多字符该怎么办呢。假设我们需要找到以一个字符开头和结尾的所有单词，并且在中间可以有任意数量的字符。这就是我们使用乘数元字符如 `+` `*` 与 `?` 的地方。
`{n}`、`{n,m}`、`{n,}` 或者 `{,m}` 也是可以在我们的正则表达式项中使用的其他乘数元字符。
#### `*` (星号)
以下示例匹配字母 `k` 的任意出现次数，包括一次没有：
```
$ grep "lak*" file4
```
它意味着我们可以匹配到 `lake`、`la` 或者 `lakkkk`。
#### `+`
以下模式要求字符串中的字母 `k` 至少被匹配到一次：
```
$ grep "lak+" file5
```
这里 `k` 在我们的搜索中至少需要发生一次，所以我们的结果可以为 `lake` 或者 `lakkkk`，但不能是 `la`。
#### `?`
在以下模式匹配中
```
$ grep "ba?b" file6
```
匹配字符串 `bb` 或 `bab`，使用 `?` 乘数，我们可以有一个或零个字符的出现。
#### 非常重要的提示
当使用乘数时这是非常重要的，假设我们有一个正则表达式
```
$ grep "S.*l" file7
```
我们得到的结果是 `small`、`silly`，并且我们也得到了 `Shane is a little to play ball`。但是为什么我们得到了 `Shane is a little to play ball`？我们只是在搜索中寻找单词，为什么我们得到了整个句子作为我们的输出。
这是因为它满足我们的搜索标准，它以字母 `s` 开头，中间有任意数量的字符并以字母 `l` 结尾。那么，我们可以做些什么来纠正我们的正则表达式来只是得到单词而不是整个句子作为我们的输出。
我们在正则表达式中需要增加 `?` 元字符，
```
$ grep "S.*?l" file7
```
这将会纠正我们正则表达式的行为。
#### `\`
`\` 是当我们需要包含一个元字符或者对正则表达式有特殊含义的字符的时候来使用。例如，我们需要找到所有以点结尾的单词，所以我们可以使用：
```
$ grep "S.*\\." file8
```
这将会查找和匹配所有以一个点字符结尾的词。
通过这篇基本正则表达式教程，我们现在有一些关于正则表达式如何工作的基本概念。在我们的下一篇教程中，我们将学习一些高级的正则表达式的概念。同时尽可能多地练习，创建正则表达式并试着尽可能多的在你的工作中加入它们。如果有任何疑问或问题，您可以在下面的评论区留言。
---
via: <http://linuxtechlab.com/bash-scripting-learn-use-regex-basics/>
作者：[SHUSAIN](http://linuxtechlab.com/author/shsuain/) 译者：[kimii](https://github.com/kimii) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Ubuntu 18.04 新功能、发行日期和更多信息
|
Thishosting.rocks
|
https://thishosting.rocks/ubuntu-18-04-new-features-release-date/
|
我们一直都在翘首以盼 —— 新的 Ubuntu 的 LTS 版本 —— 18.04。了解有关新功能，发行日期以及更多信息。
|
/data/attachment/album/201712/27/173957kiq7us0zazasqsqn.png.thumb.jpg
|
/data/attachment/album/201712/27/173957kiq7us0zazasqsqn.png
| true | false | true |
kimii
| false |
[
"Ubuntu"
] |
新闻
|
{
"viewnum": 22340,
"commentnum": 1,
"favtimes": 0,
"sharetimes": 1,
"likes": 0
}
|
[
{
"postip": "211.102.192.66",
"message": "期待",
"username": "编程浪子 [Chrome 62.0|Windows 7]",
"date": "2018-01-05T11:23:32"
}
] |
[] |
我们一直都在翘首以盼 —— 新的 Ubuntu 的 LTS 版本 —— 18.04。了解有关新功能，发行日期以及更多信息。
| 2017-12-30T08:34:00 | 2017-12-30T08:34:00 | 9,183 |
/article-9183-1.html
|
我们一直都在翘首以盼 —— 新的 Ubuntu 的 LTS 版本 —— 18.04。了解有关新功能，发行日期以及更多信息。
### 关于 Ubuntu 18.04 的基本信息
让我们以一些基本信息开始。
* 这是一个新的 LTS（长期支持）版本。所以对桌面版和服务器版有 5 年的支持。
* 被命名为 “Bionic Beaver”（仿生河狸）。Canonical 的创始人 Mark Shuttleworth 解释了这个名字背后的含义。吉祥物是一个河狸，因为它充满活力，勤劳，并且是一个很棒工程师 —— 这完美地描述了一个典型的 Ubuntu 用户，以及新的 Ubuntu 发行版本身。使用 “Bionic”（仿生）这个形容词是由于在 Ubuntu Core 上运行的机器人数量的增加。
### Ubuntu 18.04 发行日期和日程
如果你是 Ubuntu 的新手，你可能并不熟悉实际的版本号意味着什么。它指的是官方发行的年份和月份。所以 Ubuntu 18.04 正式发布将在 2018 年的第 4 个月。Ubuntu 17.10 于 2017 年发布，也就是今年的第 10 个月。
对进一步的细节，这里是有关 Ubuntu 18.04 LTS 的重要日期和需要知道的：
* 2017 年 11 月 30 日 - 功能定义冻结。
* 2018 年 1 月 4 日 - 第一个 Alpha 版本。所以，如果您选择接收新的 Alpha 版本，那么您将在这天获得 Alpha 1 更新。
* 2018 年 2 月 1 日 - 第二个 Alpha 版本。
* 2018 年 3 月 1 日 - 功能冻结。将不会引入或发布新功能。所以开发团队只会在改进现有功能和修复错误上努力。当然也有例外。如果您不是开发人员或有经验的用户，但仍想尝试新的 Ubuntu ASAP，那么我个人建议从此版本开始。
* 2018 年 3 月 8 日 - 第一个 Bata 版本。如果您选择接收 Bata 版更新，则会在当天得到更新。
* 2018 年 3 月 22 日 - 用户界面冻结。这意味着不会对实际的用户界面做进一步的更改或更新，因此，如果您编写文档，[教程](https://thishosting.rocks/category/knowledgebase/)，并使用屏幕截图，那时开始是可靠的。
* 2018 年 3 月 29 日 - 文档字符串冻结。将不会有任何编辑或新的东西（字符串）添加到文档中，所以翻译者可以开始翻译文档。
* 2018 年 4 月 5 日 - 最终 Beta 版本。这也是开始使用新版本的好日子。
* 2018 年 4 月 19 日 - 最终冻结。现在一切都已经完成了。版本的图像被创建和分发，并且可能不会有任何更改。
* 2018 年 4 月 26 日 - 官方最终版本的 Ubuntu 18.04。每个人都可以从这一天开始使用它，即使在生产服务器上。我们建议从 [Vultr](https://thishosting.rocks/go/vultr/) 获得 Ubuntu 18.04 服务器并测试新功能。[Vultr](https://thishosting.rocks/go/vultr/) 的服务器每月起价为 2.5 美元。（LCTT 译注：这是原文广告！）
### Ubuntu 18.04 的新功能
在 Ubuntu 18.04 LTS 上的所有新功能：
#### 现已支持彩色表情符号
在以前的版本中，Ubuntu 只支持单色（黑和白）表情符号，坦白地说，它看起来不是太好。Ubuntu 18.04 将使用[Noto Color Emoji font](https://www.google.com/get/noto/help/emoji/) 来支持彩色表情符号。随着 18.04，你可以在任何地方轻松查看和添加颜色表情符号。它们是原生支持的 —— 所以你可以使用它们，而不用使用第三方应用程序或安装/配置任何额外的东西。你可以随时通过删除该字体来禁用彩色表情符号。
#### GNOME 桌面环境
[](https://thishosting.rocks/wp-content/uploads/2017/12/ubuntu-17-10-gnome.jpg)
Ubuntu 从 Ubuntu 17.10 开始使用 GNOME 桌面环境，而不是默认的 Unity 环境。Ubuntu 18.04 将继续使用 GNOME。这是 Ubuntu 的一个重要的变化。
#### Ubuntu 18.04 桌面将有一个新的默认主题
Ubuntu 18.04 正在用新的 GTK 主题以告别旧的默认主题 “Ambience”。如果你想帮助新的主题，看看一些截图甚至更多，去[这里](https://community.ubuntu.com/t/call-for-participation-an-ubuntu-default-theme-lead-by-the-community/1545)。
到目前为止，有人猜测 Suru 将成 为 Ubuntu 18.04 的[新默认图标主题](http://www.omgubuntu.co.uk/2017/11/suru-default-icon-theme-ubuntu-18-04-lts)。这里有一个截图：
[](https://thishosting.rocks/wp-content/uploads/2017/12/suru-icon-theme-ubuntu-18-04.jpg)
>
> 值得注意的是：Ubuntu 16.10，17.04 和 17.10 中的所有新功能都将滚动到 Ubuntu 18.04 中，这些更新，如右边的窗口按钮、更好的登录屏幕，改进的蓝牙支持等将推送到 Ubuntu 18.04。对此我们不会特别说明，因为它对 Ubuntu 18.04 本身并不新鲜。如果您想了解更多关于从 16.04 到 18.04 的所有变化，请谷歌搜索它们之间的每个版本。
>
>
>
### 下载 Ubuntu 18.04
首先，如果你已经使用 Ubuntu，你可以升级到 Ubuntu 18.04。
如果你需要下载 Ubuntu 18.04：
在最终发布之后，请进入[官方 Ubuntu 下载页面](https://www.ubuntu.com/download)。
对于每日构建（alpha，beta 和 non-final 版本），请转到[这里](http://cdimage.ubuntu.com/daily-live/current/)。
### 常见问题解答
现在是一些经常被问到的问题（附带答案），这应该能给你关于这一切的更多信息。
#### 什么时候切换到 Ubuntu 18.04 是安全的？
当然是在正式的最终发布日期。但是，如果您等不及，请开始使用 2018 年 3 月 1 日的桌面版本，并在 2018 年 4 月 5 日开始测试服务器版本。但是为了确保安全，您需要等待最终发布，甚至更长时间，使得您正在使用的第三方服务和应用程序经过测试，并在新版本上进行良好运行。
#### 如何将我的服务器升级到 Ubuntu 18.04？
这个过程相当简单，但潜在风险很大。我们可能会在不久的将来发布一个教程，但你基本上需要使用 `do-release-upgrade`。同样，升级你的服务器也有潜在的风险，并且如果在生产服务器上，我会在升级之前再三考虑。特别是如果你在 16.04 上还剩有几年的支持。
#### 我怎样才能帮助 Ubuntu 18.04？
即使您不是一个经验丰富的开发人员和 Ubuntu 用户，您仍然可以通过以下方式提供帮助：
* 宣传它。让人们了解 Ubuntu 18.04。在社交媒体上的一个简单的分享也有点帮助。
* 使用和测试版本。开始使用该版本并进行测试。同样，您不必是一个开发人员。您仍然可以查找和报告错误，或发送反馈。
* 翻译。加入翻译团队，开始翻译文档或应用程序。
* 帮助别人。加入一些在线 Ubuntu 社区，并帮助其他人解决他们对 Ubuntu 18.04 的问题。有时候人们需要帮助，一些简单的事如“我在哪里可以下载 Ubuntu？”
#### Ubuntu 18.04 对其他发行版如 Lubuntu 意味着什么？
所有基于 Ubuntu 的发行版都将具有相似的新功能和类似的发行计划。你需要检查你的发行版的官方网站来获取更多信息。
#### Ubuntu 18.04 是一个 LTS 版本吗?
是的，Ubuntu 18.04 是一个 LTS（长期支持）版本，所以你将得到 5 年的支持。
#### 我能从 Windows/OS X 切换到 Ubuntu 18.04 吗？
当然可以！你很可能也会体验到性能的提升。从不同的操作系统切换到 Ubuntu 相当简单，有相当多的相关教程。你甚至可以设置一个双引导，来使用多个操作系统，所以 Windows 和 Ubuntu 18.04 你都可以使用。
#### 我可以尝试 Ubuntu 18.04 而不安装它吗？
当然。你可以使用像 [VirtualBox](https://www.virtualbox.org/) 这样的东西来创建一个“虚拟桌面” —— 你可以在你的本地机器上安装它，并且使用 Ubuntu 18.04 而不需要真正地安装 Ubuntu。
或者你可以在 [Vultr](https://thishosting.rocks/go/vultr/) 上以每月 2.5 美元的价格尝试 Ubuntu 18.04 服务器。如果你使用一些[免费账户（free credits）](https://thishosting.rocks/vultr-coupons-for-2017-free-credits-and-more/)，那么它本质上是免费的。（LCTT 译注：广告！）
#### 为什么我找不到 Ubuntu 18.04 的 32 位版本？
因为没有 32 位版本。Ubuntu 的 17.10 版本便放弃了 32 位版本。如果你使用的是旧硬件，那么最好使用不同的[轻量级 Linux 发行版](https://thishosting.rocks/best-lightweight-linux-distros/)而不是 Ubuntu 18.04。
#### 还有其他问题吗？
在下面留言！分享您的想法，我们会非常激动，并且一旦有新信息发布，我们就会更新这篇文章。敬请期待，耐心等待！
---
via: <https://thishosting.rocks/ubuntu-18-04-new-features-release-date/>
作者：<thishosting.rocks> 译者：[kimii](https://github.com/kimii) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何改善遗留的代码库
|
Jacques Mattheij
|
https://jacquesmattheij.com/improving-a-legacy-codebase
|
在每一个程序员、项目管理员、团队领导的一生中，这都会至少发生一次。原来的程序员早已离职去度假了，给你留下了一坨几百万行屎一样的、勉强支撑公司运行的代码和（如果有的话）跟代码驴头不对马嘴的文档。
|
/data/attachment/album/201712/28/093339ql5vt7lw1vpssnnl.jpg.thumb.jpg
|
/data/attachment/album/201712/28/093339ql5vt7lw1vpssnnl.jpg
| true | false | true |
aiwhj
| false |
[
"代码",
"重构"
] |
观点
|
{
"viewnum": 4131,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
在每一个程序员、项目管理员、团队领导的一生中，这都会至少发生一次。原来的程序员早已离职去度假了，给你留下了一坨几百万行屎一样的、勉强支撑公司运行的代码和（如果有的话）跟代码驴头不对马嘴的文档。
| 2017-12-28T09:33:45 | 2017-12-28T09:33:45 | 9,184 |
/article-9184-1.html
|
在每一个程序员、项目管理员、团队领导的一生中，这都会至少发生一次。原来的程序员早已离职去度假了，给你留下了一坨几百万行屎一样的、勉强支撑公司运行的代码和（如果有的话）跟代码驴头不对马嘴的文档。
你的任务：带领团队摆脱这个混乱的局面。
当你的第一反应（逃命）过去之后，你开始去熟悉这个项目。公司的管理层都在关注着你，所以项目只能成功；然而，看了一遍代码之后却发现失败几乎是不可避免。那么该怎么办呢？
幸运（不幸）的是我已经遇到好几次这种情况了，我和我的小伙伴发现将这坨热气腾腾的屎变成一个健康可维护的项目是一个有丰厚利润的业务。下面这些是我们的一些经验：
### 备份
在开始做任何事情之前备份与之可能相关的所有文件。这样可以确保不会丢失任何可能会在另外一些地方很重要的信息。一旦修改了其中一些文件，你可能花费一天或者更多天都解决不了这个愚蠢的问题。配置数据通常不受版本控制，所以特别容易受到这方面影响，如果定期备份数据时连带着它一起备份了，还是比较幸运的。所以谨慎总比后悔好，复制所有东西到一个绝对安全的地方并不要轻易碰它，除非这些文件是只读模式。
### 重要的先决条件：必须确保代码能够在生产环境下构建运行并产出
之前我假设环境已经存在，所以完全丢了这一步，但 Hacker News 的众多网友指出了这一点，并且事实证明他们是对的：第一步是确认你知道在生产环境下运行着什么东西，也意味着你需要在你的设备上构建一个跟生产环境上运行的版本每一个字节都一模一样的版本。如果你找不到实现它的办法，一旦你将它投入生产环境，你很可能会遭遇一些预料之外的糟糕事情。确保每一部分都尽力测试，之后在你足够确信它能够很好的运行的时候将它部署生产环境下。无论它运行的怎么样都要做好能够马上切换回旧版本的准备，确保日志记录下了所有情况，以便于接下来不可避免的 “验尸” 。
### 冻结数据库
直到你修改代码结束之前尽可能冻结你的数据库，在你已经非常熟悉代码库和遗留代码之后再去修改数据库。在这之前过早的修改数据库的话，你可能会碰到大问题，你会失去让新旧代码和数据库一起构建稳固的基础的能力。保持数据库完全不变，就能比较新的逻辑代码和旧的逻辑代码运行的结果，比较的结果应该跟预期的没有差别。
### 写测试
在你做任何改变之前，尽可能多的写一些端到端测试和集成测试。确保这些测试能够正确的输出，并测试你对旧的代码运行的各种假设（准备好应对一些意外状况）。这些测试有两个重要的作用：其一，它们能够在早期帮助你抛弃一些错误观念，其二，这些测试在你写新代码替换旧代码的时候也有一定防护作用。
要自动化测试，如果你有 CI 的使用经验可以用它，并确保在你提交代码之后 CI 能够快速的完成所有测试。
### 日志监控
如果旧设备依然可用，那么添加上监控功能。在一个全新的数据库，为每一个你能想到的事件都添加一个简单的计数器，并且根据这些事件的名字添加一个函数增加这些计数器。用一些额外的代码实现一个带有时间戳的事件日志，你就能大概知道发生多少事件会导致另外一些种类的事件。例如：用户打开 APP 、用户关闭 APP 。如果这两个事件导致后端调用的数量维持长时间的不同，这个数量差就是当前打开的 APP 的数量。如果你发现打开 APP 比关闭 APP 多的时候，你就必须要知道是什么原因导致 APP 关闭了（例如崩溃）。你会发现每一个事件都跟其它的一些事件有许多不同种类的联系，通常情况下你应该尽量维持这些固定的联系，除非在系统上有一个明显的错误。你的目标是减少那些错误的事件，尽可能多的在开始的时候通过使用计数器在调用链中降低到指定的级别。（例如：用户支付应该得到相同数量的支付回调）。
这个简单的技巧可以将每一个后端应用变成一个像真实的簿记系统一样，而像一个真正的簿记系统，所有数字必须匹配，如果它们在某个地方对不上就有问题。
随着时间的推移，这个系统在监控健康方面变得非常宝贵，而且它也是使用源码控制修改系统日志的一个好伙伴，你可以使用它确认 BUG 引入到生产环境的时间，以及对多种计数器造成的影响。
我通常保持每 5 分钟（一小时 12 次）记录一次计数器，但如果你的应用生成了更多或者更少的事件，你应该修改这个时间间隔。所有的计数器公用一个数据表，每一个记录都只是简单的一行。
### 一次只修改一处
不要陷入在提高代码或者平台可用性的同时添加新特性或者是修复 BUG 的陷阱。这会让你头大，因为你现在必须在每一步操作想好要出什么样的结果，而且会让你之前建立的一些测试失效。
### 修改平台
如果你决定转移你的应用到另外一个平台，最主要的是跟之前保持一模一样。如果你觉得需要，你可以添加更多的文档和测试，但是不要忘记这一点，所有的业务逻辑和相互依赖要跟从前一样保持不变。
### 修改架构
接下来处理的是改变应用的结构（如果需要）。这一点上，你可以自由的修改高层的代码，通常是降低模块间的横向联系，这样可以降低代码活动期间对终端用户造成的影响范围。如果旧代码很庞杂，那么现在正是让它模块化的时候，将大段代码分解成众多小的部分，不过不要改变量和数据结构的名字。
Hacker News 的 [mannykannot](https://news.ycombinator.com/item?id=14445661) 网友指出，修改高层代码并不总是可行，如果你特别不幸的话，你可能为了改变一些架构必须付出沉重的代价。我赞同这一点也应该在这里加上提示，因此这里有一些补充。我想额外补充的是如果你修改高层代码的时候修改了一点点底层代码，那么试着只修改一个文件或者最坏的情况是只修改一个子系统，尽可能限制修改的范围。否则你可能很难调试刚才所做的更改。
### 底层代码的重构
现在，你应该非常理解每一个模块的作用了，准备做一些真正的工作吧：重构代码以提高其可维护性并且使代码做好添加新功能的准备。这很可能是项目中最消耗时间的部分，记录你所做的任何操作，在你彻底的记录并且理解模块之前不要对它做任何修改。之后你可以自由的修改变量名、函数名以及数据结构以提高代码的清晰度和统一性，然后请做测试（情况允许的话，包括单元测试）。
### 修复 bug
现在准备做一些用户可见的修改，战斗的第一步是修复很多积累了几年的 bug。像往常一样，首先证实 bug 仍然存在，然后编写测试并修复这个 bug，你的 CI 和端对端测试应该能避免一些由于不太熟悉或者一些额外的事情而犯的错误。
### 升级数据库
如果你在一个坚实且可维护的代码库上完成所有工作，你就可以选择更改数据库模式的计划，或者使用不同的完全替换数据库。之前完成的步骤能够帮助你更可靠的修改数据库而不会碰到问题，你可以完全的测试新数据库和新代码，而之前写的所有测试可以确保你顺利的迁移。
### 按着路线图执行
祝贺你脱离的困境并且可以准备添加新功能了。
### 任何时候都不要尝试彻底重写
彻底重写是那种注定会失败的项目。一方面，你在一个未知的领域开始，所以你甚至不知道构建什么，另一方面，你会把所有的问题都推到新系统马上就要上线的前一天。非常不幸的是，这也是你失败的时候。假设业务逻辑被发现存在问题，你会得到异样的眼光，那时您会突然明白为什么旧系统会用某种奇怪的方式来工作，最终也会意识到能将旧系统放在一起工作的人也不都是白痴。在那之后。如果你真的想破坏公司（和你自己的声誉），那就重写吧，但如果你是聪明人，你会知道彻底重写系统根本不是一个可选的选择。
### 所以，替代方法：增量迭代工作
要解开这些线团最快方法是，使用你熟悉的代码中任何的元素（它可能是外部的，也可能是内核模块），试着使用旧的上下文去增量改进。如果旧的构建工具已经不能用了，你将必须使用一些技巧（看下面），但至少当你开始做修改的时候，试着尽力保留已知的工作。那样随着代码库的提升你也对代码的作用更加理解。一个典型的代码提交应该最多两三行。
### 发布！
每一次的修改都发布到生产环境，即使一些修改不是用户可见的。使用最少的步骤也是很重要的，因为当你缺乏对系统的了解时，有时候只有生产环境能够告诉你问题在哪里。如果你只做了一个很小的修改之后出了问题，会有一些好处：
* 很容易弄清楚出了什么问题
* 这是一个改进流程的好位置
* 你应该马上更新文档展示你的新见解
### 使用代理的好处
如果你做 web 开发那就谢天谢地吧，可以在旧系统和用户之间加一个代理。这样你能很容易的控制每一个网址哪些请求定向到旧系统，哪些请求定向到新系统，从而更轻松更精确的控制运行的内容以及谁能够看到运行系统。如果你的代理足够的聪明，你可以使用它针对个别 URL 把一定比例的流量发送到新系统，直到你满意为止。如果你的集成测试也能连接到这个接口那就更好了。
### 是的，但这会花费很多时间！
这就取决于你怎样看待它了。的确，在按照以上步骤优化代码时会有一些重复的工作步骤。但是它确实有效，而这里介绍的任何一个步骤都是假设你对系统的了解比现实要多。我需要保持声誉，也真的不喜欢在工作期间有负面的意外。如果运气好的话，公司系统已经出现问题，或者有可能会严重影响到客户。在这样的情况下，我比较喜欢完全控制整个流程得到好的结果，而不是节省两天或者一星期。如果你更多地是牛仔的做事方式，并且你的老板同意可以接受冒更大的风险，那可能试着冒险一下没有错，但是大多数公司宁愿采取稍微慢一点但更确定的胜利之路。
---
via: <https://jacquesmattheij.com/improving-a-legacy-codebase>
作者：[Jacques Mattheij](https://jacquesmattheij.com/) 译者：[aiwhj](https://github.com/aiwhj) 校对：[JianqinWang](https://github.com/JianqinWang), [wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
一行命令轻松升级 Ubuntu
|
Ambarish Kumar
|
https://itsfoss.com/zzupdate-upgrade-ubuntu/
|
Gianluigi 'Zane' Zanettini 写的 zzupdate 只需一个命令就可以在 Ubuntu 中清理、更新、自动删除、版本升级、该工具的自我更新。
|
/data/attachment/album/201712/28/165550n883wxk9b8853643.jpg.thumb.jpg
|
/data/attachment/album/201712/28/165550n883wxk9b8853643.jpg
| true | false | true |
geekpi
| false |
[
"Ubuntu",
"升级"
] |
技术
|
{
"viewnum": 12333,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Gianluigi 'Zane' Zanettini 写的 zzupdate 只需一个命令就可以在 Ubuntu 中清理、更新、自动删除、版本升级、该工具的自我更新。
| 2017-12-30T09:54:00 | 2017-12-30T09:54:00 | 9,185 |
/article-9185-1.html
|
[zzupdate](https://github.com/TurboLabIt/zzupdate) 是一个开源的命令行程序，通过将几个更新命令组合到一个命令中，使得将 Ubuntu 桌面和服务器版本升级到更新版本的任务变得容易一些。
将 Ubuntu 系统升级到更新的版本并不是一项艰巨的任务。无论是使用 GUI 还是使用几个命令，都可以轻松地将系统升级到最新版本。
另一方面，Gianluigi 'Zane' Zanettini 写的 `zzupdate` 只需一个命令就可以在 Ubuntu 中清理、更新、自动删除、版本升级、该工具的自我更新。
它会清理本地缓存，更新可用的软件包信息，然后执行发行版升级。接着，它会更新该工具并删除未使用的软件包。
该脚本必须以 root 用户身份运行。
### 安装 zzupdate 将 Ubuntu 升级到更新的版本
要安装 `zzupdate`，请在终端中执行以下命令。
```
curl -s https://raw.githubusercontent.com/TurboLabIt/zzupdate/master/setup.sh | sudo sh
```
然后将提供的示例配置文件复制到 `zzupdate.conf` 并设置你的首选项。
```
sudo cp /usr/local/turbolab.it/zzupdate/zzupdate.default.conf /etc/turbolab.it/zzupdate.conf
```
完成后，只要使用下面的命令，它就会开始升级你的 Ubuntu 系统到一个更新的版本（如果有的话）。
```
sudo zzupdate
```
请注意，在普通版本（非 LTS 版本）下，zzupdate 会将系统升级到下一个可用的版本。但是，当你运行 Ubuntu 16.04 LTS 时，它将尝试仅搜索下一个长期支持版本，而不是可用的最新版本。
如果你想退出 LTS 版本并升级到最新版本，你将需要更改一些选项。
对于 Ubuntu 桌面，打开 **软件和更新** 和下面 **更新** 选项卡，并更改通知我新的 Ubuntu 版本选项为 “**对于任何新版本**”。
对于 Ubuntu 服务版，编辑 `release-upgrades` 文件。
```
vi /etc/update-manager/release-upgrades
Prompt=normal
```
### 配置 zzupdate [可选]
`zzupdate` 要配置的选项：
```
REBOOT=1
```
如果值为 1，升级后系统将重启。
```
REBOOT_TIMEOUT=15
```
将重启超时设置为 900 秒，因为某些硬件比其他硬件重启需要更长的时间。
```
VERSION_UPGRADE=1
```
如果升级可用，则执行版本升级。
```
VERSION_UPGRADE_SILENT=0
```
自动显示版本进度。
```
COMPOSER_UPGRADE=1
```
值为 “1” 会自动升级该工具。
```
SWITCH_PROMPT_TO_NORMAL=0
```
此功能将 Ubuntu 版本更新为普通版本，即如果你运行着 LTS 发行版，`zzupdate` 将不会将其升级到 Ubuntu 17.10（如果其设置为 0）。它将仅搜索 LTS 版本。相比之下，无论你运行着 LTS 或者普通版，“1” 都将搜索最新版本。
完成后，你要做的就是在控制台中运行一个完整的 Ubuntu 系统更新。
```
sudo zzupdate
```
### 最后的话
尽管 Ubuntu 的升级过程本身就很简单，但是 zzupdate 将它简化为一个命令。不需要编码知识，这个过程完全是配置文件驱动。我个人发现这是一个很好的更新几个 Ubuntu 系统的工具，而无需单独关心不同的事情。
你愿意试试吗？
---
via: <https://itsfoss.com/zzupdate-upgrade-ubuntu/>
作者：[Ambarish Kumar](https://itsfoss.com) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
用 Ansible Container 去管理 Linux 容器
|
Tomas Tomecek
|
https://opensource.com/article/17/10/dockerfiles-ansible-container
|
Ansible Container 解决了 Dockerfile 的不足，并对容器化项目提供了完整的管理。
|
/data/attachment/album/201712/28/181710auyru6kuhokbhdz3.png.thumb.jpg
|
/data/attachment/album/201712/28/181710auyru6kuhokbhdz3.png
| true | false | true |
qhwdw
| false |
[
"Dockerfile",
"Ansible",
"Docker"
] |
容器与云
|
{
"viewnum": 5007,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
Ansible Container 解决了 Dockerfile 的不足，并对容器化项目提供了完整的管理。
| 2017-12-29T09:14:00 | 2017-12-29T09:14:00 | 9,186 |
/article-9186-1.html
|
>
> Ansible Container 解决了 Dockerfile 的不足，并对容器化项目提供了完整的管理。
>
>
>
Image by : opensource.com
我喜欢容器，并且每天都使用这个技术。即便如此，容器并不完美。不过，在过去几个月里，一系列项目已经解决了我遇到的一些问题。
我刚开始时，用 [Docker](https://opensource.com/tags/docker) 使用容器，这个项目使得这种技术非常流行。除了使用这个容器引擎之外，我学到了怎么去使用 [docker-compose](https://github.com/docker/compose) 以及怎么去用它管理我的项目。使用它使得我的生产力猛增！一个命令就可以运行我的项目，而不管它有多复杂。因此，我太高兴了。
使用一段时间之后，我发现了一些问题。最明显的问题是创建容器镜像的过程。Docker 工具使用一个定制的文件格式作为生成容器镜像的依据：Dockerfile。这个格式易于学习，并且很短的一段时间之后，你就可以自己制作容器镜像了。但是，一旦你希望进一步掌握它或者考虑到复杂场景，问题就会出现。
让我们打断一下，先去了解一个不同的东西：[Ansible](https://opensource.com/tags/ansible) 的世界。你知道它吗？它棒极了，是吗？你不这么认为？好吧，是时候去学习一些新事物了。Ansible 是一个允许你通过写一些任务去管理你的基础设施，并在你选择的环境中运行它们的项目。不需要去安装和设置任何的服务；你可以从你的笔记本电脑中很容易地做任何事情。许多人已经接受 Ansible 了。
想像一下这样的场景：你在 Ansible 中，你写了很多的 Ansible <ruby> 角色 <rt> role </rt></ruby>和<ruby> 剧本 <rt> playbook </rt></ruby>，你可以用它们去管理你的基础设施，并且你想把它们运用到容器中。你应该怎么做？通过 shell 脚本和 Dockerfile 去写容器镜像定义？听起来好像不对。
来自 Ansible 开发团队的一些人问到这个问题，并且他们意识到，人们每天编写和使用的那些同样的 Ansible 角色和剧本也可以用来制作容器镜像。但是 Ansible 能做到的不止这些 —— 它可以被用于去管理容器化项目的完整生命周期。从这些想法中，[Ansible Container](https://www.ansible.com/ansible-container) 项目诞生了。它利用已有的 Ansible 角色转变成容器镜像，甚至还可以被用于生产环境中从构建到部署的完整生命周期。
现在让我们讨论一下，我之前提到过的在 Dockerfile 环境中的最佳实践问题。这里有一个警告：这将是非常具体且技术性的。出现最多的三个问题有：
### 1、 在 Dockerfile 中内嵌的 Shell 脚本
当写 Dockerfile 时，你可以指定会由 `/bin/sh -c` 解释执行的脚本。它类似如下：
```
RUN dnf install -y nginx
```
这里 `RUN` 是一个 Dockerfile 指令，其它的都是参数（它们传递给 shell）。但是，想像一个更复杂的场景：
```
RUN set -eux; \
\
# this "case" statement is generated via "update.sh"
%%ARCH-CASE%%; \
\
url="https://golang.org/dl/go${GOLANG_VERSION}.${goRelArch}.tar.gz"; \
wget -O go.tgz "$url"; \
echo "${goRelSha256} *go.tgz" | sha256sum -c -; \
```
这仅是从 [golang 官方镜像](https://github.com/docker-library/golang/blob/master/Dockerfile-debian.template#L14) 中拿来的一段。它看起来并不好看，是不是？
### 2、 解析 Dockerfile 并不容易
Dockerfile 是一个没有正式规范的新格式。如果你需要在你的基础设施（比如，让构建过程自动化一点）中去处理 Dockerfile 将会很复杂。仅有的规范是 [这个代码](https://github.com/moby/moby/tree/master/builder/dockerfile)，它是 **dockerd** 的一部分。问题是你不能使用它作为一个<ruby> 库 <rt> library </rt></ruby>来使用。最容易的解决方案是你自己写一个解析器，然后祈祷它运行的很好。使用一些众所周知的标记语言不是更好吗？比如，YAML 或者 JSON。
### 3、 管理困难
如果你熟悉容器镜像的内部结构，你可能知道每个镜像是由<ruby> 层 <rt> layer </rt></ruby>构成的。一旦容器被创建，这些层就使用联合文件系统技术堆叠在一起（像煎饼一样）。问题是，你并不能显式地管理这些层 — 你不能说，“这儿开始一个新层”，你被迫使用一种可读性不好的方法去改变你的 Dockerfile。最大的问题是，必须遵循一套最佳实践以去达到最优结果 — 新来的人在这个地方可能很困难。
### Ansible 语言和 Dockerfile 比较
相比 Ansible，Dockerfile 的最大缺点，也是 Ansible 的优点，作为一个语言，Ansible 更强大。例如，Dockerfile 没有直接的变量概念，而 Ansible 有一个完整的模板系统（变量只是它其中的一个特性）。Ansible 包含了很多更易于使用的模块，比如，[wait\_for](http://docs.ansible.com/wait_for_module.html)，它可以被用于服务就绪检查，比如，在处理之前等待服务准备就绪。在 Dockerfile 中，做任何事情都通过一个 shell 脚本。因此，如果你想去找出已准备好的服务，它必须使用 shell（或者独立安装）去做。使用 shell 脚本的其它问题是，它会变得很复杂，维护成为一种负担。很多人已经发现了这个问题，并将这些 shell 脚本转到 Ansible。
### 关于作者
Tomas Tomecek - 工程师、Hacker、演讲者、Tinker、Red Hatter。喜欢容器、linux、开源软件、python 3、rust、zsh、tmux。[More about me](https://opensource.com/users/tomastomecek)
---
via: <https://opensource.com/article/17/10/dockerfiles-ansible-container>
作者：[Tomas Tomecek](https://opensource.com/users/tomastomecek) 译者：[qhwdw](https://github.com/qhwdw) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 pss 提升你的代码搜索能力
|
Clément Verna
|
https://fedoramagazine.org/improve-code-searching-skills-pss/
|
搜索代码库是开发者每天都要做的事情。从修改 bug 到学习新代码，或者查看如何调用某个 API，能快速在代码库中导航的能力都是一大助力。幸运的是，我们有专门的工具来搜索代码。pss 就是其中一个工具，让我们来看看如何安装和使用它吧。
|
/data/attachment/album/201712/28/213536kijg800zzz8rjvrz.jpg.thumb.jpg
|
/data/attachment/album/201712/28/213536kijg800zzz8rjvrz.jpg
| true | false | true |
lujun9972
| false |
[
"pss",
"代码",
"搜索"
] |
分享
|
{
"viewnum": 5821,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
搜索代码库是开发者每天都要做的事情。从修改 bug 到学习新代码，或者查看如何调用某个 API，能快速在代码库中导航的能力都是一大助力。幸运的是，我们有专门的工具来搜索代码。pss 就是其中一个工具，让我们来看看如何安装和使用它吧。
| 2017-12-30T08:34:00 | 2017-12-30T08:34:00 | 9,187 |
/article-9187-1.html
|
搜索代码库是开发者每天都要做的事情。从修改 bug 到学习新代码，或者查看如何调用某个 API，能快速在代码库中导航的能力都是一大助力。幸运的是，我们有专门的工具来搜索代码。[pss](https://github.com/eliben/pss) 就是其中一个工具，让我们来看看如何安装和使用它吧。
### 什么是 pss？
`pss` 是一个帮你在源代码文件中进行搜索的命令行工具。`pss` 递归地在目录树中进行搜索，它能自动根据文件名和后缀判断哪些文件需要搜索，哪些文件不需搜索，并且会自动跳过那些你不会想搜索的目录（比如 `.svn` 和 `.git`），还能用色彩渲染输出以方便人们阅读，以及其他很多功能。
### 安装 pss
使用下面命令在 Fedora 上安装 `pss`：
```
$ dnf install pss
```
安装好后就能在终端调用 `pss` 了：
```
$ pss
```
不带参数调用 `pss` 或者带上 `-h` 标志会输出详细的使用说明。
### 使用案例
现在你安装好 `pss` 了，下面来看一些例子吧。
```
$ pss foo
```
该命令只是简单的搜索 `foo`。你也可以限制 `pss` 让它只在 python 文件中搜索 `foo`：
```
$ pss foo --py
```
还能在非 python 文件中搜索 `bar`：
```
$ pss bar --nopy
```
而且，`pss` 支持大多数常见的源代码文件类型，要获取完整的支持列表，执行：
```
$ pss --help-types
```
你还能指定忽略某些目录不进行搜索。默认情况下，`pss` 会忽略类似 `.git`，`__pycache__`，`.metadata` 等目录。
```
$ pss foo --py --ignore-dir=dist
```
此外，`pss` 还能显示搜索结果的上下文。
```
$ pss -A 5 foo
```
会显示匹配结果的后面 5 行内容。
```
$ pss -B 5 foo
```
会显示匹配结果的前面 5 行内容。
```
$ pss -C 5 foo
```
会显示匹配结果的前后各 5 行内容。
如果你想知道如何使用 `pss` 进行正则表达式搜索以及它的其他选项的话，可以在[这里](https://github.com/eliben/pss/wiki/Usage-samples)看到更多的例子。
---
via: <https://fedoramagazine.org/improve-code-searching-skills-pss/>
作者：[Clément Verna](https://fedoramagazine.org) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
极客漫画：#!S
|
Daniel Stori
|
http://turnoff.us/geek/shebang/
|
#! 是 Unix/Linux 里面用于指示脚本解释器的特定语法，位于脚本中的第一行，以 #! 开头，接着是该脚本的解释器，通常是 /bin/bash、/usr/bin/python 之类。
|
/data/attachment/album/201712/29/000823ywkzget79ocqbpbf.png.thumb.jpg
|
/data/attachment/album/201712/29/000823ywkzget79ocqbpbf.png.large.jpg
| false | false | true |
wxy
| false |
[
"释伴",
"shebang"
] |
极客漫画
|
{
"viewnum": 11958,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 1,
"likes": 0
}
|
[] |
[
{
"raid": 3664,
"displayorder": 0
}
] |
#! 是 Unix/Linux 里面用于指示脚本解释器的特定语法，位于脚本中的第一行，以 #! 开头，接着是该脚本的解释器，通常是 /bin/bash、/usr/bin/python 之类。
| 2017-12-29T00:08:00 | 2017-12-29T00:08:00 | 9,188 |
/article-9188-1.html
|
这是我第一次遇到无法翻译的漫画。
`#!` 是 Unix/Linux 里面用于指示脚本解释器的特定语法，位于脚本中的第一行，以 `#!` 开头，接着是该脚本的解释器，通常是 `/bin/bash`、`/usr/bin/python` 之类。
关于 `#!` 其英文名称为“shebang”，其中的“she” 来源于 “#”的发音 “sharp”，“bang”来源于“!”，故如此命名。
Linux 中国翻译组核心成员 GOLinux 提议将此专有名称翻译为“[释伴](/article-3664-1.html)”。
回到这幅漫画，作者的原意可能是：我！你！他！ ，以此类推，然后是她（she）！ 即 `#!S`。（附注：感谢万能的网友指出我没看懂的部分。）
---
via: <http://turnoff.us/geek/shebang/>
作者：[Daniel Stori](http://turnoff.us/about/) 点评：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何为你的科技书籍找到出版商
|
Brian Macdonald
|
https://opensource.com/article/17/12/how-find-publisher-your-book
|
想去写一本科技书籍是一个好的想法，但你还需要去了解一下出版业的运作过程。
|
/data/attachment/album/201712/29/174228cdzl4iuofcuylilt.png.thumb.jpg
|
/data/attachment/album/201712/29/174228cdzl4iuofcuylilt.png
| true | false | true |
FelixYFZ
| false |
[
"书籍",
"出版"
] |
观点
|
{
"viewnum": 4025,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
想去写一本科技书籍是一个好的想法，但你还需要去了解一下出版业的运作过程。
| 2017-12-29T17:42:00 | 2017-12-29T17:42:00 | 9,189 |
/article-9189-1.html
|
>
> 想去写一本科技书籍是一个好的想法，但你还需要去了解一下出版业的运作过程。
>
>
>
你有一个写本科技书籍的想法，那么祝贺你！就像在阿巴拉契亚山脉徒步旅行，或者是去学做一种蛋奶酥，写书是人们经常讨论的话题之一，但是却都只停留在思考的初级阶段。那是可以理解的，因为失败的几率是很高的。要想实现它，你需要在把自己的想法阐述给出版商，去探讨是否已经做好充分的准备去写成一本书。要去实现这一步是相当困难的，但缺乏关于如何做这件事的信息会使事情变得复杂。
如果你想和一家传统的出版商合作，那么你需要在他们面前推销你的书稿以期望能够得到出版的机会。因为我是 [Pragmatci Bookshelf](https://pragprog.com/) 的总编，所以经常看到很多的选题，也去帮助作者制作出好的作品。这些选题中有些是好的，有些则不然，但我经常会看到许多不符合我们出版社风格的文稿。我会帮助你找到最适合的出版商，来让你的想法得到认可。
### 确定你的目标
你的第一步是要找出最适合你的想法的出版商。首先，想想你经常买书的以及你喜欢的出版商，你的书会被像你自己一样的人喜欢的几率是很高的，所以从你自己最喜欢的出版商开始，列出一个简短的列表将会大大缩小你的搜索范围。如果你自己所买的书籍并不多。那么可以去书店逛逛，或者在亚马逊网站上看看。 列一个你自己喜欢的几家出版商的清单出来。
下一步，筛选出你期望的出版商，尽管大多数技术类出版商看起来没什么差别，但他们通常各有不同的读者群体。有些出版商会选择广受欢迎的话题，如 C++ 或者 Java，那么你以 Elixir 为主题的书稿就可能不适合那个出版商；如果你的书稿是关于教授小孩学习编程的，那么你可能就不想让学术出版商来出版。
一旦确定了一些目标，你就可以在他们的商品目录、网站或者亚马逊上对其进行进一步的调查，去寻找有哪些书籍和你的思想是相符的。如果他们能有一本和你自己的书稿主题一样或很相近的书，那么你将很难说服他们和你签约。但那并不意味着已经可以把这样的出版商从你的列表中划掉，你可以将自己的书稿主题进行适当的修改以将它和已经发行的书区别开来：比如定位于不同的读者群体，或者不同层次的技能水平。也许已发行的那本书已经过时了，你就可以专注于该技术领域里的新方法，确保你的书稿能够弥补现有书的不足，更加完善，而不是单纯的竞争。
如果你锁定的出版商没有出版过类似的书籍，也许这将会是个好迹象，但也许是个坏迹象。有时候一些供应商不会选择去出版一些专业技术方面的书籍，或者是因为他们认为自己的读者不会感兴趣，也可能是因为他们曾经在这块领域遇到过麻烦。新的语言或者类库一直在不停地涌现出来，出版商们不得不去琢磨什么样的书籍内容将会吸引他们的读者群体。他们的评估标准可能和你的是不一样的。他们已经有了最终决定，也可能是还在等待合适的选题。判断究竟是哪一种的唯一方法就是提出文稿并找出答案。
### 建立起你自己的网络
确定一家出版商是第一步；现在你需要与其建立联系。不幸的是，出版需要的仍旧是你认识什么人，而不是你知道什么。你需要认识的那个人是一个去发现新市场、新作者和新选题的策划编辑。如果你认识某个和出版商有关系的人，请他给你介绍一位策划编辑。这些策划编辑往往负责一个专题板块，尤其是在较大的出版商，但你并非一定要找到符合你书稿的专题板块的编辑。各类板块的编辑通常都会很乐意将你介绍给合适的编辑。
有时候你也许能够在一个技术会议上找到一个策划编辑，特别是在出版商同时也是赞助商，而且还有一个展台时。即使当时并没有一个策划编辑在场，展台的其他工作人员也能够帮你和策划编辑建立联系。 如果会议不符合你的主题思想，那就需要你利用自己的社交网络来获得别人的推荐。比如使用 LinkedIn，或者其他非正式的联系方式，去和一个编辑建立联系。
对于小型的出版商，你可能会在公司网站上发现策划编辑的名单，如果你够幸运的话，还可以找到他们的联系信息。如果找不到联系方式的话，可以在推特上搜寻出版商的名字，试试能否找到他们的编辑的信息，在社交媒体上去寻找一位陌生的人，然后把自己的书稿推荐给他，这也许会让你有些紧张，但是你真的不必去担心这些，建立联系也是策划编辑的工作之一。最坏的结果只不过是他们忽视你而已。
一旦建立起联系，策划编辑将会协助你进行下一步。他们可能会立刻对你的书稿给予反馈，或者在他们可能想让你根据他们的指导来修改你的文章，使其变得更加充实。当你经过努力找到了一名策划编辑后，多听从他们的建议，因为他们比你更熟悉出版商的运作流程。
### 如果其他的方法都失败了
如果你无法联系到一名策划编辑，出版商通常会有一个<ruby> 书稿盲投 <rt> proposal alias </rt></ruby>的方式来接受投稿，通常是 `proposals@[publisher].com` 的格式。 查找他们网站的介绍，找到如何去发送书稿；有的出版商是有特殊的要求的。你需要遵循他们的要求，如果不这样做的话，你的书稿将会被丢弃，它不会被任何人阅读。如果你有疑问，或者不确定出版商的意图，那么你需要再尝试着去找一名编辑进一步地沟通，因为书稿并不能回答那些问题。整理他们对你的要求（一篇独立的主题文章），发给他们，然后你要做的就是期望能够得到满意的答复。
### 等待
无论你是如何与一个出版商取得联系的，你也得等待着。如果你已经投递了书稿，也许要过一段时间才有人去处理你的稿件，特别是在一些大公司。即使你已经找了一位策划编辑去处理你的投稿，你可能也只是他同时在处理的潜在目标之一，所以你可能不会很快得到答复。几乎所有的出版商都会在最终确认之前召开一次组委会来决定接受哪个稿件，所以即使你的书稿已经足够的优秀，并且可以出版了，你也仍然需要等待组委会开会讨论。你可能需要等待几周，甚至是一个月的时间。
几周过后，你可以和编辑再联系一下，看看他们是否需要更多的信息。在邮件中你要表现出足够的礼貌；如果他们仍然没有回复，也许是因为他们有太多的投稿需要处理，即使你不停地催促也不会让你的稿件被提前处理。一些出版商有可能永远不会回复你，也不会去发一份退稿的通知给你，但那种情况并不常见。在这种情况下你除了耐心地等待也没有别的办法，如果几个月后也没有人回复你邮件，你完全可以去接触另一个出版商或者干脆考虑自出版。
### 祝好运
如果你觉得这个过程看起来让你感觉有些混乱和不科学，这是很正常的。能够得到出版要在合适的时间地点，与合适的人沟通，而且还要期待他们此时有好的心情。你无法去控制这些不确定的因素，但是更好地了解行业的工作方式，以及出版商的需求，可以帮助你完善它们。
寻找一个出版商只是万里长征的第一步。你需要提炼你的思想，并创建选题，以及其他方面的考虑。在今年的 SeaGLS 上，我对整个过程做了[介绍](https://archive.org/details/SeaGL2017WritingTheNextGreatTechBook)。查看[视频](https://archive.org/details/SeaGL2017WritingTheNextGreatTechBook)可以获取更详细的信息。
### 关于作者
麦克唐纳先生现在是 Pragmatic Bookshelf 的总编。过去 20 年在技术出版领域生涯中，他是一名编辑、一名作者，偶尔还去客串演讲者或者讲师。他现在把大量的时间都用来和新作者探讨如何更好地表达出他们的想法。你可以关注他的推特@bmac\_editor。
>
> **如果这篇文章点燃你写书的热情，但又不知道如何找到合适的途径联系出版商，不如逛逛像[异步社区](epubit.com.cn)这样的网站，按照上文的步骤尝试一下，也许能够发现新的希望。**
>
>
>
---
via: <https://opensource.com/article/17/12/how-find-publisher-your-book>
作者：[Brian MacDonald](https://opensource.com/users/bmacdonald) 译者：[FelixYFZ](https://github.com/FelixYFZ) 校对：[wxy](https://github.com/wxy), 陈聪聪
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
10 个例子教你学会 ncat (nc) 命令
|
Pradeep Kumar
|
https://www.linuxtechi.com/nc-ncat-command-examples-linux-systems/
|
ncat 或者说 nc 是一款功能类似 cat 的工具，但是是用于网络的。它是一款拥有多种功能的 CLI 工具，可以用来在网络上读、写以及重定向数据。
|
/data/attachment/album/201712/30/001853qeiznzihgh3zghqz.jpg.thumb.jpg
|
/data/attachment/album/201712/30/001853qeiznzihgh3zghqz.jpg
| true | false | true |
lujun9972
| false |
[
"nc",
"ncat"
] |
技术
|
{
"viewnum": 25617,
"commentnum": 0,
"favtimes": 5,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
ncat 或者说 nc 是一款功能类似 cat 的工具，但是是用于网络的。它是一款拥有多种功能的 CLI 工具，可以用来在网络上读、写以及重定向数据。
| 2017-12-31T08:01:00 | 2017-12-31T08:01:00 | 9,190 |
/article-9190-1.html
|
`ncat` 或者说 `nc` 是一款功能类似 `cat` 的工具，但是是用于网络的。它是一款拥有多种功能的 CLI 工具，可以用来在网络上读、写以及重定向数据。 它被设计成可以被脚本或其他程序调用的可靠的后端工具。同时由于它能创建任意所需的连接，因此也是一个很好的网络调试工具。
`ncat`/`nc` 既是一个端口扫描工具，也是一款安全工具，还能是一款监测工具，甚至可以做为一个简单的 TCP 代理。 由于有这么多的功能，它被誉为是网络界的瑞士军刀。 这是每个系统管理员都应该知道并且掌握它。
在大多数 Debian 发行版中，`nc` 是默认可用的，它会在安装系统的过程中自动被安装。 但是在 CentOS 7 / RHEL 7 的最小化安装中，`nc` 并不会默认被安装。 你需要用下列命令手工安装。
```
[root@linuxtechi ~]# yum install nmap-ncat -y
```
系统管理员可以用它来审计系统安全，用它来找出开放的端口然后保护这些端口。 管理员还能用它作为客户端来审计 Web 服务器、telnet 服务器、邮件服务器等， 通过 `nc` 我们可以控制发送的每个字符，也可以查看对方的回应。
我们还可以用它捕获客户端发送的数据以此来了解这些客户端是做什么的。
在本文中，我们会通过 10 个例子来学习如何使用 `nc` 命令。
### 例子： 1) 监听入站连接
通过 `-l` 选项，`ncat` 可以进入监听模式，使我们可以在指定端口监听入站连接。 完整的命令是这样的：
```
$ ncat -l port_number
```
比如，
```
$ ncat -l 8080
```
服务器就会开始在 8080 端口监听入站连接。
### 例子： 2) 连接远程系统
使用下面命令可以用 `nc` 来连接远程系统，
```
$ ncat IP_address port_number
```
让我们来看个例子，
```
$ ncat 192.168.1.100 80
```
这会创建一个连接，连接到 IP 为 192.168.1.100 的服务器上的 80 端口，然后我们就可以向服务器发送指令了。 比如我们可以输入下面内容来获取完整的网页内容
```
GET / HTTP/1.1
```
或者获取页面名称，
```
GET / HTTP/1.1
```
或者我们可以通过以下方式获得操作系统指纹标识，
```
HEAD / HTTP/1.1
```
这会告诉我们使用的是什么软件来运行这个 web 服务器的。
### 例子： 3) 连接 UDP 端口
默认情况下，`nc` 创建连接时只会连接 TCP 端口。 不过我们可以使用 `-u` 选项来连接到 UDP 端口，
```
$ ncat -l -u 1234
```
现在我们的系统会开始监听 UDP 的 1234 端口，我们可以使用下面的 `netstat` 命令来验证这一点，
```
$ netstat -tunlp | grep 1234
udp 0 0 0.0.0.0:1234 0.0.0.0:* 17341/nc
udp6 0 0 :::1234 :::* 17341/nc
```
假设我们想发送或者说测试某个远程主机 UDP 端口的连通性，我们可以使用下面命令，
```
$ ncat -v -u {host-ip} {udp-port}
```
比如：
```
[root@localhost ~]# ncat -v -u 192.168.105.150 53
Ncat: Version 6.40 ( http://nmap.org/ncat )
Ncat: Connected to 192.168.105.150:53。
```
### 例子： 4) 将 `nc` 作为聊天工具
`nc` 也可以作为聊天工具来用，我们可以配置服务器监听某个端口，然后从远程主机上连接到服务器的这个端口，就可以开始发送消息了。 在服务器这端运行：
```
$ ncat -l 8080
```
在远程客户端主机上运行：
```
$ ncat 192.168.1.100 8080
```
之后开始发送消息，这些消息会在服务器终端上显示出来。
### 例子： 5) 将 `nc` 作为代理
`nc` 也可以用来做代理。比如下面这个例子，
```
$ ncat -l 8080 | ncat 192.168.1.200 80
```
所有发往我们服务器 8080 端口的连接都会自动转发到 192.168.1.200 上的 80 端口。 不过由于我们使用了管道，数据只能被单向传输。 要同时能够接受返回的数据，我们需要创建一个双向管道。 使用下面命令可以做到这点:
```
$ mkfifo 2way
$ ncat -l 8080 0<2way | ncat 192.168.1.200 80 1>2way
```
现在你可以通过 `nc` 代理来收发数据了。
### 例子： 6) 使用 `nc` 拷贝文件
`nc` 还能用来在系统间拷贝文件，虽然这么做并不推荐，因为绝大多数系统默认都安装了 `ssh`/`scp`。 不过如果你恰好遇见个没有 `ssh`/`scp` 的系统的话， 你可以用 `nc` 来作最后的努力。
在要接受数据的机器上启动 `nc` 并让它进入监听模式：
```
$ ncat -l 8080 > file.txt
```
现在去要被拷贝数据的机器上运行下面命令：
```
$ ncat 192.168.1.100 8080 --send-only < data.txt
```
这里，`data.txt` 是要发送的文件。 `-–send-only` 选项会在文件拷贝完后立即关闭连接。 如果不加该选项， 我们需要手工按下 `ctrl+c` 来关闭连接。
我们也可以用这种方法拷贝整个磁盘分区，不过请一定要小心。
### 例子： 7) 通过 `nc` 创建后门
`nc` 命令还可以用来在系统中创建后门，并且这种技术也确实被黑客大量使用。 为了保护我们的系统，我们需要知道它是怎么做的。 创建后门的命令为：
```
$ ncat -l 10000 -e /bin/bash
```
`-e` 标志将一个 bash 与端口 10000 相连。现在客户端只要连接到服务器上的 10000 端口就能通过 bash 获取我们系统的完整访问权限：
```
$ ncat 192.168.1.100 10000
```
### 例子： 8) 通过 `nc` 进行端口转发
我们通过选项 `-c` 来用 `nc` 进行端口转发，实现端口转发的语法为：
```
$ ncat -u -l 80 -c 'ncat -u -l 8080'
```
这样，所有连接到 80 端口的连接都会转发到 8080 端口。
### 例子： 9) 设置连接超时
`nc` 的监听模式会一直运行，直到手工终止。 不过我们可以通过选项 `-w` 设置超时时间:
```
$ ncat -w 10 192.168.1.100 8080
```
这回导致连接 10 秒后终止，不过这个选项只能用于客户端而不是服务端。
### 例子： 10) 使用 `-k` 选项强制 `nc` 待命
当客户端从服务端断开连接后，过一段时间服务端也会停止监听。 但通过选项 `-k` 我们可以强制服务器保持连接并继续监听端口。 命令如下：
```
$ ncat -l -k 8080
```
现在即使来自客户端的连接断了也依然会处于待命状态。
自此我们的教程就完了，如有疑问，请在下方留言。
---
via: <https://www.linuxtechi.com/nc-ncat-command-examples-linux-systems/>
作者：[Pradeep Kumar](https://www.linuxtechi.com/author/pradeep/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何在 CentOS 7 / RHEL 7 的 KVM 上启用嵌套虚拟化
|
Pradeep Kumar
|
https://www.linuxtechi.com/enable-nested-virtualization-kvm-centos-7-rhel-7/
|
嵌套虚拟化意味着在虚拟机内配置虚拟化环境。换句话说，我们可以说嵌套虚拟化是虚拟机管理程序（hypervisor）的一个特性，它允许我们通过虚拟化管理程序（宿主机）的硬件加速在虚拟服务器内安装和运行虚拟机。
|
/data/attachment/album/201712/31/204014zlw6mk9iiszhcsgm.jpg.thumb.jpg
|
/data/attachment/album/201712/31/204014zlw6mk9iiszhcsgm.jpg
| true | false | true |
zjon
| false |
[
"KVM",
"虚拟化",
"嵌套虚拟化"
] |
容器与云
|
{
"viewnum": 7779,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
嵌套虚拟化意味着在虚拟机内配置虚拟化环境。换句话说，我们可以说嵌套虚拟化是虚拟机管理程序（hypervisor）的一个特性，它允许我们通过虚拟化管理程序（宿主机）的硬件加速在虚拟服务器内安装和运行虚拟机。
| 2017-12-31T20:40:20 | 2017-12-31T20:40:20 | 9,191 |
/article-9191-1.html
|
**嵌套虚拟化**意味着在虚拟机内配置虚拟化环境。换句话说，我们可以说嵌套虚拟化是<ruby> 虚拟机管理程序 <rt> hypervisor </rt></ruby>的一个特性，它允许我们通过**虚拟化管理程序**（宿主机）的硬件加速在虚拟服务器内安装和运行虚拟机。
在这篇文章中，我们将讨论如何在 CentOS 7 / RHEL 7 的 KVM 上启用嵌套虚拟化。我假定您已经配置过 KVM 管理程序。如果您不熟悉如何安装和配置 KVM 管理程序，请参考以下文章。
### 在 CentOS 7.x 和 RHEL 7.x 安装 KVM 管理程序
让我们进入虚拟化管理程序，验证您的 KVM 宿主机是否启用了嵌套虚拟化。
基于 Intel 的处理器运行以下命令：
```
[root@kvm-hypervisor ~]# cat /sys/module/kvm_intel/parameters/nested
N
```
基于 AMD 的处理器运行以下命令：
```
[root@kvm-hypervisor ~]# cat /sys/module/kvm_amd/parameters/nested
N
```
上述命令输出 `N` 表示嵌套虚拟化是禁用的。如果我们得到的输出是 `Y` 则表示在您的宿主机已启用嵌套虚拟化。
现在启用嵌套虚拟化，使用以下内容创建一个文件名为 `/etc/modprobe.d/kvm-nested.conf` 的文件：
```
[root@kvm-hypervisor ~]# vi /etc/modprobe.d/kvm-nested.conf
```
```
options kvm-intel nested=1
options kvm-intel enable_shadow_vmcs=1
options kvm-intel enable_apicv=1
options kvm-intel ept=1
```
保存并退出文件。
现在移除 `kvm_intel` 模块然后通过 `modprobe` 命令添加同样的模块。在移除模块之前，确保虚拟机已关机，否则我们会得到像 “modprobe: FATAL: Module kvm\_intel is in use” 这样的错误信息。
```
[root@kvm-hypervisor ~]# modprobe -r kvm_intel
[root@kvm-hypervisor ~]# modprobe -a kvm_intel
```
现在验证嵌套虚拟化功能是否启用。
```
[root@kvm-hypervisor ~]# cat /sys/module/kvm_intel/parameters/nested
Y
```
### 测试嵌套虚拟化
假设我们在 KVM 管理程序上有一台已经启用了嵌套虚拟化的名为 “director” 的虚拟机。在测试之前，确保 CPU 模式为 “host-modle” 或 “host-passthrough” ，使用 Virt-Manager 或 `virtsh` 编辑命令检查虚拟机的 CPU 模式。
现在登录 director 这台虚拟机并运行 `lscpu` 和 `lsmod` 命令。
```
[root@kvm-hypervisor ~]# ssh 192.168.126.1 -l root
root@192.168.126.1's password:
Last login: Sun Dec 10 07:05:59 2017 from 192.168.126.254
[root@director ~]# lsmod | grep kvm
kvm_intel 170200 0
kvm 566604 1 kvm_intel
irqbypass 13503 1 kvm
```
```
[root@director ~]# lscpu
```
让我们试着在 director 这台虚拟机的虚拟管理器 GUI 或 `virt-install` 命令创建一台虚拟机，在我的情况下我使用 `virt-install` 命令。
```
[root@director ~]# virt-install -n Nested-VM --description "Test Nested VM" --os-type=Linux --os-variant=rhel7 --ram=2048 --vcpus=2 --disk path=/var/lib/libvirt/images/nestedvm.img,bus=virtio,size=10 --graphics none --location /var/lib/libvirt/images/CentOS-7-x86_64-DVD-1511.iso --extra-args console=ttyS0
Starting install...
Retrieving file .treeinfo... | 1.1 kB 00:00:00
Retrieving file vmlinuz... | 4.9 MB 00:00:00
Retrieving file initrd.img... | 37 MB 00:00:00
Allocating 'nestedvm.img' | 10 GB 00:00:00
Connected to domain Nested-VM
Escape character is ^]
[ 0.000000] Initializing cgroup subsys cpuset
[ 0.000000] Initializing cgroup subsys cpu
[ 0.000000] Initializing cgroup subsys cpuacct
[ 0.000000] Linux version 3.10.0-327.el7.x86_64 (builder@kbuilder.dev.centos.org) (gcc version 4.8.3 20140911 (Red Hat 4.8.3-9) (GCC) ) #1 SMP Thu Nov 19 22:10:57 UTC 2015
………………………………………………
```
这证实了嵌套虚拟化已成功启用，因为我们能在虚拟机内创建虚拟机。
这篇文章到此结束，请分享您的反馈和意见。
---
via: <https://www.linuxtechi.com/enable-nested-virtualization-kvm-centos-7-rhel-7/>
作者：[Pradeep Kumar](https://www.linuxtechi.com) 译者：[zjon](https://github.com/zjon) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Linux 下如何修改用户名（同时修改用户组名和家目录）
|
Shusain
|
http://linuxtechlab.com/rename-user-in-linux-rename-home-directory/
|
有时候，由于某些原因，我们可能会需要重命名用户名。我们可以很容易地修改用户名以及对应的家目录和 UID。
|
/data/attachment/album/201712/31/210720ehetzqxltdlulkir.jpg.thumb.jpg
|
/data/attachment/album/201712/31/210720ehetzqxltdlulkir.jpg
| true | false | true |
lujun9972
| false |
[
"用户名"
] |
技术
|
{
"viewnum": 88949,
"commentnum": 9,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "211.68.2.192",
"message": "完美。",
"username": "来自北京北京理工大学的 Chrome 86.0|Mac 10.14 用户",
"date": "2020-10-15T16:12:39"
},
{
"postip": "167.179.94.116",
"message": "wanmeibaolu",
"username": "来自新西兰的 Chrome 86.0|Mac 10.14 用户",
"date": "2020-10-15T16:14:39"
},
{
"postip": "106.19.122.70",
"message": "太棒了",
"username": "来自湖南的 Chrome 88.0|Windows 10 用户",
"date": "2021-02-01T11:02:53"
},
{
"postip": "122.228.131.35",
"message": "只改用户名，其他的地方有要改的吗",
"username": "来自浙江温州的 Chrome 90.0|Windows 10 用户",
"date": "2021-04-23T10:16:48"
},
{
"postip": "123.233.156.246",
"message": "您好，再VM中如何更改呢，管理员权限如何打开",
"username": "来自山东济南的 Chrome 105.0|Windows 10 用户",
"date": "2022-09-09T01:22:44"
},
{
"postip": "123.233.156.246",
"message": "您好，再VM中如何更改呢，管理员权限如何打开",
"username": "来自山东济南的 Chrome 105.0|Windows 10 用户",
"date": "2022-09-09T01:22:46"
},
{
"postip": "123.233.156.246",
"message": "您好，再VM中如何更改呢，管理员权限如何打开",
"username": "来自山东济南的 Chrome 105.0|Windows 10 用户",
"date": "2022-09-09T01:22:47"
},
{
"postip": "123.233.156.246",
"message": "您好，再VM中如何更改呢，管理员权限如何打开",
"username": "来自山东济南的 Chrome 105.0|Windows 10 用户",
"date": "2022-09-09T01:22:47"
},
{
"postip": "223.104.11.77",
"message": "jjjfgghj",
"username": "来自陕西西安的 Chrome Mobile 119.0|Android 10 用户",
"date": "2023-12-05T11:17:41"
}
] |
[] |
有时候，由于某些原因，我们可能会需要重命名用户名。我们可以很容易地修改用户名以及对应的家目录和 UID。
| 2018-01-01T08:56:00 | 2018-01-01T08:56:00 | 9,192 |
/article-9192-1.html
|
有时候，由于某些原因，我们可能会需要重命名用户名。我们可以很容易地修改用户名以及对应的家目录和 UID。
本教程将会讨论这些东西。让我们先从修改用户名开始。
### 修改用户名
我们使用 `usermod` 来修改用户名。其语法为，
```
$ usermod -l new_username old_username
```
举个例子，假设我们有一个名叫 `dan` 的用户想要重命名为 `susan`，那么在终端下执行下面命令：
```
$ sudo usermod -l susan dan
```
这只会更改用户名，而其他的东西，比如用户组，家目录，UID 等都保持不变。
**注意：-** 你需要从要改名的帐号中登出并杀掉该用户的所有进程，要杀掉该用户的所有进程可以执行下面命令，
```
$ sudo pkill -u dan
$ sudo pkill -9 -u dan
```
### 修改家目录
要同时更改家目录，我们需要在执行 `usermod` 命令的同时加上 `-d` 选项，
```
$ sudo usermod -d /home/susan -m susan
```
### 更改用户 UID
执行下面命令修改用户 UID，
```
$ sudo usermod -u 2000 susan
```
这里 `2000` 就是用户的新 UID。
### 修改用户组名
要把用户组名从 `dan` 修改为 `susan`，我们需要使用 `groupmod` 命令。使用下面命令来修改用户组名，
```
$ groupmod -n susan dan
```
做完修改后，可以使用 `id` 命令来检查，
```
$ id susan
```
这篇教导如何修改用户名的指南就此结束了。有任何疑问或建议，欢迎给我们留言。
---
via: <http://linuxtechlab.com/rename-user-in-linux-rename-home-directory/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Cheat ： 一个实用 Linux 命令示例集合
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/cheat-a-collection-of-practical-linux-command-examples/
|
我们中的许多人经常查看 man 页面 来了解命令开关（选项），它会显示有关命令语法、说明、细节和可用的选项，但它没有任何实际的例子。因此，在组合成一个我们需要的完整命令时会遇到一些麻烦。
|
/data/attachment/album/201801/01/231203rvk8wttnt3kvtitt.jpeg.thumb.jpg
|
/data/attachment/album/201801/01/231203rvk8wttnt3kvtitt.jpeg
| true | false | true |
geekpi
| false |
[
"cheat",
"示例",
"命令"
] |
技术
|
{
"viewnum": 7713,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
我们中的许多人经常查看 man 页面 来了解命令开关（选项），它会显示有关命令语法、说明、细节和可用的选项，但它没有任何实际的例子。因此，在组合成一个我们需要的完整命令时会遇到一些麻烦。
| 2018-01-01T23:12:21 | 2018-01-01T23:12:21 | 9,193 |
/article-9193-1.html
|
我们中的许多人经常查看 [man 页面](https://www.2daygeek.com/linux-color-man-pages-configuration-less-most-command/) 来了解命令开关（选项），它会显示有关命令语法、说明、细节和可用的选项，但它没有任何实际的例子。因此，在组合成一个我们需要的完整命令时会遇到一些麻烦。
你确实遇到这个麻烦而想要一个更好的解决方案吗？我会建议你试一下 `cheat`。
### Cheat 是什么
[cheat](https://github.com/chrisallenlane/cheat) 允许你在命令行中创建和查看交互式的<ruby> 速查表 <rt> cheatsheet </rt></ruby>。它旨在帮助提醒 \*nix 系统管理员他们经常使用但还没频繁到会记住的命令的选项。
### 如何安装 Cheat
`cheat` 是使用 python 开发的，所以可以用 `pip` 来在你的系统上安装 `cheat`。
`pip` 是一个与 `setuptools` 捆绑在一起的 Python 模块，它是在 Linux 中安装 Python 包推荐的工具之一。
对于 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/)来安装 `pip`。
```
[对于 Python2]
$ sudo apt install python-pip python-setuptools
[对于 Python3]
$ sudo apt install python3-pip
```
RHEL/CentOS 官方仓库中没有 pip，因此使用 [EPEL 仓库](https://www.2daygeek.com/install-enable-epel-repository-on-rhel-centos-scientific-linux-oracle-linux/)，并使用 [YUM 命令](https://www.2daygeek.com/yum-command-examples-manage-packages-rhel-centos-systems/)安装 `pip`。
```
$ sudo yum install python-pip python-devel python-setuptools
```
对于 Fedora 系统，使用 [dnf 命令](https://www.2daygeek.com/dnf-command-examples-manage-packages-fedora-system/)来安装 `pip`。
```
[对于 Python2]
$ sudo dnf install python-pip
[对于 Python3]
$ sudo dnf install python3
```
对于基于 Arch Linux 的系统，请使用 [Pacman 命令](https://www.2daygeek.com/pacman-command-examples-manage-packages-arch-linux-system/) 来安装 `pip`。
```
[对于 Python2]
$ sudo pacman -S python2-pip python-setuptools
[对于 Python3]
$ sudo pacman -S python-pip python3-setuptools
```
对于 openSUSE 系统，使用 [Zypper 命令](https://www.2daygeek.com/zypper-command-examples-manage-packages-opensuse-system/)来安装 `pip`。
```
[对于 Python2]
$ sudo pacman -S python-pip
[对于 Python3]
$ sudo pacman -S python3-pip
```
用 `pip` 来在你的系统上安装 `cheat`。
```
$ sudo pip install cheat
```
### 如何使用 Cheat
运行 `cheat`，然后按相应的`命令`来查看速查表，作为例子，我们要来看下 `tar` 命令的例子。
```
$ cheat tar
# To extract an uncompressed archive:
tar -xvf /path/to/foo.tar
# To create an uncompressed archive:
tar -cvf /path/to/foo.tar /path/to/foo/
# To extract a .gz archive:
tar -xzvf /path/to/foo.tgz
# To create a .gz archive:
tar -czvf /path/to/foo.tgz /path/to/foo/
# To list the content of an .gz archive:
tar -ztvf /path/to/foo.tgz
# To extract a .bz2 archive:
tar -xjvf /path/to/foo.tgz
# To create a .bz2 archive:
tar -cjvf /path/to/foo.tgz /path/to/foo/
# To extract a .tar in specified Directory:
tar -xvf /path/to/foo.tar -C /path/to/destination/
# To list the content of an .bz2 archive:
tar -jtvf /path/to/foo.tgz
# To create a .gz archive and exclude all jpg,gif,... from the tgz
tar czvf /path/to/foo.tgz --exclude=\*.{jpg,gif,png,wmv,flv,tar.gz,zip} /path/to/foo/
# To use parallel (multi-threaded) implementation of compression algorithms:
tar -z ... -> tar -Ipigz ...
tar -j ... -> tar -Ipbzip2 ...
tar -J ... -> tar -Ipixz ...
```
运行下面的命令查看可用的速查表。
```
$ cheat -l
```
进入帮助页面获取更多详细信息。
```
$ cheat -h
```
---
via: <https://www.2daygeek.com/cheat-a-collection-of-practical-linux-command-examples/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
检查 Linux 文件系统中的错误：通过案例学习 FSCK 命令
|
Shusain
|
http://linuxtechlab.com/linux-filesystem-errors-fsck-command-with-examples/
|
FSCK 是一个很重要的 Linux/Unix 工具，它用于检测并修复文件系统中的错误。它类似于 Windows 操作系统中的 “chkdsk” 工具，但它是为 Linux、MacOS、FreeBSD 操作系统所准备的。
|
/data/attachment/album/201801/01/233426vf4rqkj361qrfqnw.jpg.thumb.jpg
|
/data/attachment/album/201801/01/233426vf4rqkj361qrfqnw.jpg
| true | false | true |
lujun9972
| false |
[
"fsck",
"文件系统"
] |
技术
|
{
"viewnum": 9480,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
FSCK 是一个很重要的 Linux/Unix 工具，它用于检测并修复文件系统中的错误。它类似于 Windows 操作系统中的 “chkdsk” 工具，但它是为 Linux、MacOS、FreeBSD 操作系统所准备的。
| 2018-01-01T23:34:31 | 2018-01-01T23:34:31 | 9,194 |
/article-9194-1.html
|
FSCK 是一个很重要的 Linux/Unix 工具，它用于检测并修复文件系统中的错误。它类似于 Windows 操作系统中的 “chkdsk” 工具，但它是为 Linux、MacOS、FreeBSD 操作系统所准备的。
FSCK 全称为 File System Consistency Check。在大多数时候，它在系统启动时运行，但是如果需要的话，它也能被超级用户手工启动。
它可以进行三种模式的操作，
1. 查错并在发现错误时由用户决定如何处理，
2. 查错并自动修复，
3. 查错但在发现错误时只显示错误而不进行修复。
### FSCK 的语法
手工执行 FSCK 的语法为，
```
$ fsck options drives
```
`fsck` 支持的选项有，
* `-p` 自动修复（不询问）
* `-n` 不对文件系统做出改动
* `-y` 对所有问题都回答 "yes"
* `-c` 检查所有的坏块并将之添加到坏块列表中
* `-f` 即使文件系统标记为 clean 也强制进行检查
* `-v` 输出详细信息
* `-b superblock` 使用替代的超级块
* `-B blocksize` 指定超级块的块大小
* `-j external_journal` 指定外部日志的位置
* `-l bad_blocks_file` 添加到指定的坏块列表（文件）
* `-L bad_blocks_file` 指定坏块列表（文件）
我们可以根据要做的操作任意指定这些选项。下面让我们来看一些例子。
### Fsck 命令的案例
注意： 在开始讨论案例之前，请先读完这段话。我们不应该用 `fsck` 检查已挂载的磁盘，这很可能会对磁盘造成永久性的伤害。因此在开始使用 `fsck` 之前，我们需要使用下面命令来卸载磁盘，
```
$ umount drivename
```
比如像这样，
```
$ umount /dev/sdb1
```
可以通过下面命令来查看分区编号，
```
$ fdisk -l
```
另外，在运行 fsck 时，可能出错并返回一些错误码。下面是一些常见的错误及其意义的列表，
* `0` - 没有错误
* `1` - 修复了一些文件系统错误
* `2` - 系统需要被重启
* `4` - 文件系统错误未被修复
* `8` - 操作错
* `16` - 使用或语法错
* `32` - fsck 被用户取消
* `128` - 共享库出错
现在让我们来看一些 `fsck` 命令的例子，
### 在单个分区上进行错误检查
在终端运行下面过命令来对单个分区进行检查，
```
$ umount /dev/sdb1
$ fsck /dev/sdb1
```
### 检查文件系统错误并自动修复
使用选项 `-a` 进行一致性检查并自动修复这些错误。也可以用 `-y` 替代 `-a` 选项。
```
$ fsck -a /dev/sdb1
```
### 检查文件系统错误但并不进行修复
若我们只想知道文件系统上有哪些错误而不想修复这些错误，那么可以使用选项 `-n`，
```
$ fsck -n /dev/sdb1
```
### 检查所有分区中的错误
`-A` 选项一次性检查所有分区上的文件系统错误，
```
$ fsck -A
```
若要禁止对根文件系统进行检查可以使用选项 `-R`，
```
$ fsck -AR
```
### 只检查指定文件系统类型的分区
使用选项 `-t` 及文件系统类型，可以让 fsck 只检查指定文件系统类型的分区，比如指定文件系统类型为 “ext4”，
```
$ fsck -t ext4 /dev/sdb1
```
或者，
```
$ fsck -t -A ext4
```
### 只在卸载的磁盘上进行一致性检查
要保证 fsck 只在卸载的磁盘上操作，可以使用选项 `-M`，
```
$ fsck -AM
```
这就是我们的案例教程了。有任何疑问欢迎在下面的留言框中留言。
---
via: <http://linuxtechlab.com/linux-filesystem-errors-fsck-command-with-examples/>
作者：[Shusain](http://linuxtechlab.com/author/shsuain/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
Reddit 如何实现大规模的帖子浏览计数
|
Krishnan Chandra
|
https://redditblog.com/2017/05/24/view-counting-at-reddit/
|
对浏览计数有四个主要要求，满足这四项要求比听起来要复杂得多。
|
/data/attachment/album/201801/02/122933k3et5d5z5vk5aykz.png.thumb.jpg
|
/data/attachment/album/201801/02/122933k3et5d5z5vk5aykz.png
| true | false | true |
geekpi
| false |
[
"计数",
"Reddit"
] |
技术
|
{
"viewnum": 4669,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
对浏览计数有四个主要要求，满足这四项要求比听起来要复杂得多。
| 2018-01-02T12:29:29 | 2018-01-02T12:29:29 | 9,195 |
/article-9195-1.html
|
我们希望更好地将 Reddit 的规模传达给我们的用户。到目前为止，投票得分和评论数量是特定的帖子活动的主要指标。然而，Reddit 有许多访问者在没有投票或评论的情况下阅读内容。我们希望建立一个能够捕捉到帖子阅读数量的系统。然后将该数量展示给内容创建者和版主，以便他们更好地了解特定帖子上的活动。
在这篇文章中，我们将讨论我们如何大规模地实现计数。
### 计数方法
对浏览计数有四个主要要求：
* 计数必须是实时的或接近实时的。不是每天或每小时的总量。
* 每个用户在短时间内只能计数一次。
* 显示的数量与实际的误差在百分之几。
* 系统必须能够在生产环境运行，并在事件发生后几秒内处理事件。
满足这四项要求比听起来要复杂得多。为了实时保持准确的计数，我们需要知道某个特定的用户是否曾经访问过这个帖子。要知道这些信息，我们需要存储先前访问过每个帖子的用户组，然后在每次处理对该帖子的新访问时查看该组。这个解决方案的一个原始实现是将这个唯一用户的集合作为散列表存储在内存中，并且以帖子 ID 作为键名。
这种方法适用于浏览量较少的文章，但一旦文章流行，阅读人数迅速增加，这种方法很难扩展。有几个热门的帖子有超过一百万的唯一读者！对于这种帖子，对于内存和 CPU 来说影响都很大，因为要存储所有的 ID，并频繁地查找集合，看看是否有人已经访问过。
由于我们不能提供精确的计数，我们研究了几个不同的[基数估计](https://en.wikipedia.org/wiki/Count-distinct_problem)算法。我们考虑了两个非常符合我们期望的选择：
1. 线性概率计数方法，非常准确，但要计数的集合越大，则线性地需要更多的内存。
2. 基于 [HyperLogLog](http://algo.inria.fr/flajolet/Publications/FlFuGaMe07.pdf)（HLL）的计数方法。HLL 随集合大小<ruby> 次线性 <rt> sub-linearly </rt></ruby>增长，但不能提供与线性计数器相同的准确度。
要了解 HLL 真正节省的空间大小，看一下这篇文章顶部包括的 r/pics 帖子。它有超过 100 万的唯一用户。如果我们存储 100 万个唯一用户 ID，并且每个用户 ID 是 8 个字节长，那么我们需要 8 兆内存来计算单个帖子的唯一用户数！相比之下，使用 HLL 进行计数会占用更少的内存。每个实现的内存量是不一样的，但是对于[这个实现](http://antirez.com/news/75)，我们可以使用仅仅 12 千字节的空间计算超过一百万个 ID，这将是原始空间使用量的 0.15％！
（[这篇关于高可伸缩性的文章](http://highscalability.com/blog/2012/4/5/big-data-counting-how-to-count-a-billion-distinct-objects-us.html)很好地概述了上述两种算法。）
许多 HLL 实现使用了上述两种方法的组合，即对于小集合以线性计数开始，并且一旦大小达到特定点就切换到 HLL。前者通常被称为 “稀疏” HLL 表达，而后者被称为“密集” HLL 表达。混合的方法是非常有利的，因为它可以提供准确的结果，同时保留适度的内存占用量。这个方法在 [Google 的 HyperLogLog++ 论文](https://stefanheule.com/papers/edbt13-hyperloglog.pdf)中有更详细的描述。
虽然 HLL 算法是相当标准的，但在我们的实现中我们考虑使用三种变体。请注意，对于内存中的 HLL 实现，我们只关注 Java 和 Scala 实现，因为我们主要在数据工程团队中使用 Java 和 Scala。
1. Twitter 的 Algebird 库，用 Scala 实现。Algebird 有很好的使用文档，但是稀疏和密集的 HLL 表达的实现细节不容易理解。
2. 在 stream-lib 中的 HyperLogLog++ 的实现，用 Java 实现。stream-lib 中的代码有很好的文档，但是要理解如何正确使用这个库并且调整它以满足我们的需求是有些困难的。
3. Redis 的 HLL 实现（我们选择的）。我们认为，Redis 的 HLL 实施方案有很好的文档并且易于配置，所提供的 HLL 相关的 API 易于集成。作为一个额外的好处，使用 Redis 通过将计数应用程序（HLL 计算）的 CPU 和内存密集型部分移出并将其移至专用服务器上，从而缓解了我们的许多性能问题。
Reddit 的数据管道主要围绕 [Apache Kafka](https://kafka.apache.org/)。当用户查看帖子时，事件被激发并发送到事件收集器服务器，该服务器批量处理事件并将其保存到 Kafka 中。
从这里，浏览计数系统有两个按顺序运行的组件。我们的计数架构的第一部分是一个名为 [Nazar](https://en.wikipedia.org/wiki/Nazar_(amulet)) 的 Kafka 消费者，它将读取来自 Kafka 的每个事件，并通过我们编制的一组规则来确定是否应该计算一个事件。我们给它起了这个名字是因为 Nazar 是一个保护你免受邪恶的眼形护身符，Nazar 系统是一个“眼睛”，它可以保护我们免受不良因素的影响。Nazar 使用 Redis 保持状态，并跟踪不应计算浏览的潜在原因。我们可能无法统计事件的一个原因是，由于同一用户在短时间内重复浏览的结果。Nazar 接着将改变事件，添加一个布尔标志表明是否应该被计数，然后再发回 Kafka 事件。
这是这个项目要说的第二部分。我们有第二个叫做 [Abacus](https://en.wikipedia.org/wiki/Abacus) 的 Kafka 消费者，它实际上对浏览进行计数，并使计数在网站和客户端可见。Abacus 读取 Nazar 输出的 Kafka 事件。接着，根据 Nazar 的决定，它将计算或跳过本次浏览。如果事件被标记为计数，那么 Abacus 首先检查 Redis 中是否存在已经存在与事件对应的帖子的 HLL 计数器。如果计数器已经在 Redis 中，那么 Abacus 向 Redis 发出一个 [PFADD](https://redis.io/commands/pfadd) 的请求。如果计数器还没有在 Redis 中，那么 Abacus 向 Cassandra 集群发出请求，我们用这个集群来持久化 HLL 计数器和原始计数，并向 Redis 发出一个 [SET](https://redis.io/commands/set) 请求来添加过滤器。这种情况通常发生在人们查看已经被 Redis 删除的旧帖的时候。
为了保持对可能从 Redis 删除的旧帖子的维护，Abacus 定期将 Redis 的完整 HLL 过滤器以及每个帖子的计数记录到 Cassandra 集群中。 Cassandra 的写入以 10 秒一组分批写入，以避免超载。下面是一个高层的事件流程图。
### 总结
我们希望浏览量计数器能够更好地帮助内容创作者了解每篇文章的情况，并帮助版主快速确定哪些帖子在其社区拥有大量流量。未来，我们计划利用数据管道的实时潜力向更多的人提供更多有用的反馈。
如果你有兴趣解决这样的问题，[请查看我们的职位页面](https://about.reddit.com/careers/)。
---
via: <https://redditblog.com/2017/05/24/view-counting-at-reddit/>
作者：[Krishnan Chandra](https://redditblog.com/topic/technology/) 译者：[geekpi](https://github.com/geekpi) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
如何解决 Linux 中“磁盘空间不足”的问题
|
Nick Congleton
|
https://www.maketecheasier.com/fix-linux-no-space-left-on-device-error/
|
明明有很多剩余空间，但 Linux 系统依然提示没有空间剩余。为什么会这样呢？Linux 偶尔会有一些令人沮丧的模糊的错误消息出现，而这就是其中一种。不过这种错误通常都是由某几种因素导致的。
|
/data/attachment/album/201801/03/064323bm1b14cv9s4sm61l.jpg.thumb.jpg
|
/data/attachment/album/201801/03/064323bm1b14cv9s4sm61l.jpg
| true | false | true |
lujun9972
| false |
[
"文件系统",
"磁盘空间"
] |
技术
|
{
"viewnum": 32442,
"commentnum": 0,
"favtimes": 2,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
明明有很多剩余空间，但 Linux 系统依然提示没有空间剩余。为什么会这样呢？Linux 偶尔会有一些令人沮丧的模糊的错误消息出现，而这就是其中一种。不过这种错误通常都是由某几种因素导致的。
| 2018-01-03T06:43:00 | 2018-01-03T06:43:00 | 9,196 |
/article-9196-1.html
|
明明有很多剩余空间，但 Linux 系统依然提示没有空间剩余。为什么会这样呢？Linux 偶尔会有一些令人沮丧的模糊的错误消息出现，而这就是其中一种。不过这种错误通常都是由某几种因素导致的。
### 通过 du 和 df 检查磁盘空间
在开始行动前，最好先检查一下是否磁盘上是否确实还有空间剩余。虽然桌面环境的工具也很不错，但命令行上的工具更直接，要好的多。
首先让我们看看 `du` 命令。用它来检查问题磁盘所在的挂载点目录。本文假设出问题的分区挂载点为根目录。
```
sudo du -sh /
```
由于它要遍历磁盘中的所有文件，因此需要花费一点时间。现在再让我们试试 `df`。
```
sudo df -h
```
把根目录和在其中挂载的文件系统加在这条命令的后面。比如，若你的有一个独立的磁盘挂载到 `/home`，那么除了根目录之外，你也需要把它加进来。使用空间的总和应该跟你 `du` 命令得到的结果接近。否则的话，就说明可能有已删除文件的文件被进程占用。
当然，这里主要专注点在于这些命令的结果是否要小于磁盘的大小。如果确实小于磁盘大小，那么很明显有很多地方不对劲。
**相关**：[使用 Agedu 分析硬盘空间使用状况](https://www.maketecheasier.com/agedu-analyze-hard-disk-space-usage-in-linux/ "Use Agedu to Analyze Hard Disk Space Usage in Linux")
### 可能的原因
这里列出了一些产生这种情况的主要原因。若你发现 `du` 和 `df` 的结果之间有差别，那么可以直接检查第一项原因。否则从第二项原因开始检查。
#### 已删除文件被进程所占用
有时，文件可能已经被删掉了，但有进程依然在使用它。在进程运行期间，Linux 不会释放该文件的存储空间。你需要找出这个进程然后重启这个进程。
使用下面命令来定位进程。
```
sudo lsof / | grep deleted
```
这应该会列出出问题的进程了，然后重启该进程。
```
sudo systemctl restart service_name
```
#### i 节点不够了
文件系统中有一些称为 “<ruby> i 节点 <rt> inode </rt></ruby>” 的元数据，其用来保存文件的相关信息。很多文件系统中的 i 节点数量是固定的，因此很可能 i 节点已经耗尽了而文件系统本身还没有用完。你可以使用 `df` 来检查。
```
sudo df -i /
```
比较一下已用的 i 节点和总共的 i 节点数量。如果没有可用的 i 节点了，那么很不幸，你也无法扩充 i 节点。删除一些无用的和过期的文件来释放一些 i 节点吧。
#### 坏块
最后一个很常见的问题就是坏的文件系统块。除非另有标记，否则操作系统很可能会认为这些块都是可用的，这会导致文件系统损坏或者硬盘坏死。最好是使用带 `-cc` 标志的 `fsck` 搜索并标记出这些块。记住，你不能使用正在使用的文件系统（LCTT 译注：即包含坏块的文件系统）中的 `fsck` 命令。你应该会要用到 live CD。
```
sudo fsck -vcck /dev/sda2
```
很明显，这里需要使用你想检查的磁盘路径取代命令中的磁盘位置。另外，要注意，这恐怕会花上很长一段时间。
**相关**：[使用 fsck 检查并修复你的文件系统 [Linux]](https://www.maketecheasier.com/check-repair-filesystem-fsck-linux/ "Check and Repair Your Filesystem With fsck [Linux]")
希望这些方案能解决你的问题。这种问题在任何情况下都不是那么容易诊断的。但是，在运气好的情况下，你可以把文件系统清理干净并让你的硬盘再次正常工作。
---
via: <https://www.maketecheasier.com/fix-linux-no-space-left-on-device-error/>
作者：[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/) 荣誉推出
|
||
Linux 下使用 sudo 进行赋权
|
David Both
|
https://opensource.com/article/17/12/using-sudo-delegate
|
学习怎么在保护 root 密码的安全性的同时，为可信用户赋予所管理的网络功能和特定服务的权限。
|
/data/attachment/album/201801/03/093439rdkdiqqiigcw2wtp.png.thumb.jpg
|
/data/attachment/album/201801/03/093439rdkdiqqiigcw2wtp.png
| true | false | true |
lujun9972
| false |
[
"sudo",
"sudoers",
"root"
] |
技术
|
{
"viewnum": 9835,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
学习怎么在保护 root 密码的安全性的同时，为可信用户赋予所管理的网络功能和特定服务的权限。
| 2018-01-03T09:34:35 | 2018-01-03T09:34:35 | 9,197 |
/article-9197-1.html
|
>
> 学习怎么在保护 root 密码的安全性的同时，为可信用户赋予所管理的网络功能和特定服务的权限。
>
>
>
我最近写了一个简短的 Bash 程序来将 MP3 文件从一台网络主机的 USB 盘中拷贝到另一台网络主机上去。拷贝出来的文件存放在一台志愿者组织所属服务器的特定目录下，在那里，这些文件可以被下载和播放。
我的程序还会做些其他事情，比如为了自动在网页上根据日期排序，在拷贝文件之前会先对这些文件重命名。在验证拷贝完成后，还会删掉 USB 盘中的所有文件。这个小程序还有一些其他选项，比如 `-h` 会显示帮助， `-t` 进入测试模式等等。
我的程序需要以 root 运行才能发挥作用。然而，这个组织中之后很少的人对管理音频和计算机系统有兴趣的，这使得我不得不找那些半吊子的人来，并培训他们登录到用于传输的计算机，运行这个小程序。
倒不是说我不能亲自运行这个程序，但由于外出和疾病等等各种原因， 我不是时常在场的。 即使我在场，作为一名 “懒惰的系统管理员”， 我也希望别人能替我把事情给做了。 因此我写了一些脚本来自动完成这些任务并通过 `sudo` 来指定某些人来运行这些脚本。 很多 Linux 命令都需要用户以 root 身份来运行。 `sudo` 能够保护系统免遭一时糊涂造成的意外损坏以及恶意用户的故意破坏。
### 尽可能的使用 sudo
`sudo` 是一个很方便的工具，它让我一个具有 root 权限的管理员可以分配所有或者部分管理性的任务给其他用户， 而且还无需告诉他们 root 密码， 从而保证主机的高安全性。
假设，我给了普通用户 `ruser` 访问我 Bash 程序 `myprog` 的权限， 而这个程序的部分功能需要 root 权限。 那么该用户可以以 `ruser` 的身份登录，然后通过以下命令运行 `myprog`。
```
sudo myprog
```
`sudo` 程序会检查 `/etc/sudoers` 文件，并确认 `ruser` 是否被许可运行 `myprog`。如被许可，`sudo` 会要求该用户输入其密码——而非 root 密码。在 `ruser` 输入他的密码之后，该程序就运行了。此外，`sudo` 也记录 `myprog` 该程序运行的日期和时间、完整的命令，以及谁在运行它。这个数据会记录在 `/var/log/security` 中。
我发现在培训时记录下每个用 `sudo` 执行的命令会很有帮助。我可以看到谁执行了哪些命令，他们是否输对了。
我委派了权限给自己和另一个人来运行那一个程序；然而，`sudo` 可以做更多的事情。 它允许系统管理员委派所管理的网络功能或特定的服务给某个受信的人或某组人。这可以让你在保护了 root 密码的安全性的同时，也赋予了那些功能。
### 配置 sudoers 文件
作为一名系统管理员，我使用 `/etc/sudoers` 文件来设置某些用户或某些用户组可以访问某个命令，或某组命令，或所有命令。 这种灵活性是使用 `sudo` 进行委派时能兼顾功能与简易性的关键。
我一开始对 `sudoers` 文件感到很困惑，因此下面我会拷贝并分解我所使用主机上的完整 `sudoers` 文件。 希望在分析的过程中不会让你感到困惑。 我意外地发现， 基于 Red Hat 的发行版中默认的配置文件都会很多注释以及例子来指导你如何做出修改，这使得修改配置文件变得简单了很多，也不需要在互联网上搜索那么多东西了。
不要直接用编辑器来修改 `sudoers` 文件，而应该用 `visudo` 命令，因为该命令会在你保存并退出编辑器后就立即生效这些变更。 `visudo` 也可以使用除了 Vi 之外的其他编辑器。
让我们首先来分析一下文件中的各种别名。
#### 主机别名
主机别名这一节用于创建主机分组，授予该组主机可以访问哪些命令或命令别名。 它的基本思想是，该文件由组织中的所有主机共同维护，然后拷贝到每台主机中的 `/etc` 中。 其中有些主机， 例如各种服务器， 可以配置成一个组来赋予用户访问特定命令的权限， 比如可以启停类似 HTTPD、DNS 以及网络服务；可以挂载文件系统等等。
在设置主机别名时也可以用 IP 地址替代主机名。
```
## Host Aliases
## Groups of machines. You may prefer to use hostnames (perhaps using
## wildcards for entire domains) or IP addresses instead.
# Host_Alias FILESERVERS = fs1, fs2
# Host_Alias MAILSERVERS = smtp, smtp2
```
#### 用户别名
用户别名允许 root 将用户整理成别名组中，并按组来分配特定的 root 权限。在这部分内容中我加了一行 `User_Alias AUDIO = dboth, ruser`，定义了一个别名 `AUDIO` 用来指代了两个用户。
正如 `sudoers` 文件中所阐明的，也可以直接使用 `/etc/groups` 中定义的组而不用自己设置别名。 如果你定义好的组（假设组名为 `audio`）已经能满足要求了， 那么在后面分配命令时只需要在组名前加上 `%` 号，像这样: `%audio`。
```
## User Aliases
## These aren't often necessary, as you can use regular groups
## (ie, from files, LDAP, NIS, etc) in this file - just use %groupname
## rather than USERALIAS
# User_Alias ADMINS = jsmith, mikem
User_Alias AUDIO = dboth, ruser
```
#### 命令别名
再后面是命令别名的部分。这些别名表示的是一系列相关的命令， 比如网络相关命令，或者 RPM 包管理命令。 这些别名允许系统管理员方便地为一组命令分配权限。
该部分内容已经设置好了许多别名，这使得分配权限给某类命令变得方便很多。
```
## Command Aliases
## These are groups of related commands...
## Networking
# Cmnd_Alias NETWORKING = /sbin/route, /sbin/ifconfig, /bin/ping, /sbin/dhclient, /usr/bin/net, /sbin/iptables, /usr/bin/rfcomm, /usr/bin/wvdial, /sbin/iwconfig, /sbin/mii-tool
## Installation and management of software
# Cmnd_Alias SOFTWARE = /bin/rpm, /usr/bin/up2date, /usr/bin/yum
## Services
# Cmnd_Alias SERVICES = /sbin/service, /sbin/chkconfig
## Updating the locate database
# Cmnd_Alias LOCATE = /usr/bin/updatedb
## Storage
# Cmnd_Alias STORAGE = /sbin/fdisk, /sbin/sfdisk, /sbin/parted, /sbin/partprobe, /bin/mount, /bin/umount
## Delegating permissions
# Cmnd_Alias DELEGATING = /usr/sbin/visudo, /bin/chown, /bin/chmod, /bin/chgrp
## Processes
# Cmnd_Alias PROCESSES = /bin/nice, /bin/kill, /usr/bin/kill, /usr/bin/killall
## Drivers
# Cmnd_Alias DRIVERS = /sbin/modprobe
```
#### 环境默认值
下面部分内容设置默认的环境变量。这部分最值得关注的是 `!visiblepw` 这一行， 它表示当用户环境设置成显示密码时禁止 `sudo` 的运行。 这个安全措施不应该被修改掉。
```
# Defaults specification
#
# Refuse to run if unable to disable echo on the tty.
#
Defaults !visiblepw
Defaults env_reset
Defaults env_keep = "COLORS DISPLAY HOSTNAME HISTSIZE KDEDIR LS_COLORS"
Defaults env_keep += "MAIL PS1 PS2 QTDIR USERNAME LANG LC_ADDRESS LC_CTYPE"
Defaults env_keep += "LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MESSAGES"
Defaults env_keep += "LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE"
Defaults env_keep += "LC_TIME LC_ALL LANGUAGE LINGUAS _XKB_CHARSET XAUTHORITY"
Defaults secure_path = /sbin:/bin:/usr/sbin:/usr/bin:/usr/local/bin
```
#### 命令部分
命令部分是 `sudoers` 文件的主体。不使用别名并不会影响你完成要实现的效果，别名只是让整个配置工作大幅简化而已。
这部分使用之前定义的别名来告诉 `sudo` 哪些人可以在哪些机器上执行哪些操作。一旦你理解了这部分内容的语法，你会发现这些例子都非常的直观。 下面我们来看看它的语法。
```
ruser ALL=(ALL) ALL
```
*意即 `ruser` 可以在任意主机上以任意用户身份运行任意命令*
这是一条为用户 `ruser` 做出的配置。行中第一个 `ALL` 表示该条规则在所有主机上生效。 第二个 `ALL` 允许 `ruser` 以任意其他用户的身份运行命令。 默认情况下， 命令以 `root` 用户的身份运行， 但 `ruser` 可以在 `sudo` 命令行指定程序以其他用户的身份运行。 最后这个 `ALL` 表示 `ruser` 可以运行所有命令而不受限制。 这让 `ruser` 实际上就变成了 `root`。
注意到下面还有一条针对 `root` 的配置。这允许 `root` 能通过 `sudo` 在任何主机上运行任何命令。
```
root ALL=(ALL) ALL
```
*意即 `root` 可以在任意主机上以任意用户身份运行任意命令*
为了实验一下效果，我注释掉了这行， 然后以 root 的身份试着直接运行 `chown`。 出乎意料的是这样是能成功的。 然后我试了下 `sudo chown`，结果失败了，提示信息 “Root is not in the sudoers file。 This incident will be reported”。 也就是说 root 可以直接运行任何命令， 但当加上 `sudo` 时则不行。 这会阻止 root 像其他用户一样使用 `sudo` 命令来运行其他命令， 但是 root 有太多种方法可以绕过这个约束了。
下面这行是我新增来控制访问 `myprog` 的。它指定了只有上面定义的 `AUDIO` 组中的用户才能在 `guest1` 这台主机上使用 `myprog` 这个命令。
```
AUDIO guest1=/usr/local/bin/myprog
```
*允许 AUDIO 组成员在 guest1 主机上访问 myprog*
注意，上面这一行只指定了允许访问的主机名和程序，而没有说用户可以以其他用户的身份来运行该程序。
#### 省略密码
你也可以通过 `NOPASSWORD` 来让 `AUDIO` 组中的用户无需密码就能运行 `myprog`。像这样：
```
AUDIO guest1=NOPASSWORD : /usr/local/bin/myprog
```
*允许 AUDIO 组成员在 guest1 主机上不用输入密码即可访问 myprog*
我并没有这样做，因为我觉得使用 `sudo` 的用户必须要停下来想清楚他们正在做的事情，这对他们有好处。 我这里只是举个例子。
#### wheel
`sudoers` 文件中命令部分的 `wheel` 说明（如下所示）允许所有在 `wheel` 组中的用户在任何机器上运行任何命令。`wheel` 组在 `/etc/group` 文件中定义， 用户必须加入该组后才能工作。 组名前面的 `%` 符号表示 `sudo` 应该去 `/etc/group` 文件中查找该组。
```
%wheel ALL = (ALL) ALL
```
*运行所有定义在 /etc/group 文件中的 “wheel” 组成员可以在任意主机上运行全部命令*
这种方法很好的实现了为多个用户赋予完全的 root 权限而不用提供 root 密码。只需要把该用户加入 `wheel` 组中就能给他们提供完整的 root 的能力。 它也提供了一种通过 `sudo` 创建的日志来监控他们行为的途径。 有些 Linux 发行版， 比如 Ubuntu， 会自动将用户的 ID 加入 `/etc/group` 中的 `wheel` 组中， 这使得他们能够用 `sudo` 命令运行所有的特权命令。
### 结语
我这里只是小试了一把 `sudo` — 我只是给一到两个用户以 root 权限运行单个命令的权限。完成这些只添加了两行配置（不考虑注释）。 将某项任务的权限委派给其他非 root 用户非常简单，而且可以节省你大量的时间。 同时它还会产生日志来帮你发现问题。
`sudoers` 文件还有许多其他的配置和能力。查看 `sudo` 和 `sudoers` 的 man 手册可以深入了解详细信息。
---
via: <https://opensource.com/article/17/12/using-sudo-delegate>
作者：[David Both](https://opensource.com/users/dboth) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
源代码即是许可证
|
Scott K Peterson
|
https://opensource.com/article/17/12/source-code-license
|
对于开源软件来说，其许可证信息内嵌在源代码中。为了降低复杂性，您可以生成不同的视图。
|
/data/attachment/album/201801/03/144740dsblrzzbzkcaactl.png.thumb.jpg
|
/data/attachment/album/201801/03/144740dsblrzzbzkcaactl.png
| true | false | true |
薛亮
| false |
[
"源代码",
"GPL",
"许可证"
] |
开源智慧
|
{
"viewnum": 5440,
"commentnum": 0,
"favtimes": 0,
"sharetimes": 0,
"likes": 0
}
|
[] |
[] |
对于开源软件来说，其许可证信息内嵌在源代码中。为了降低复杂性，您可以生成不同的视图。
| 2018-01-03T14:47:00 | 2018-01-03T14:47:00 | 9,198 |
/article-9198-1.html
|
>
> 提要：对于开源软件来说，其许可证信息内嵌在源代码中。为了降低复杂性，您可以生成不同的视图。
>
>
>
您可以通过查看源代码找到开源软件的许可证信息。为了满足不同的需求，可以生成关于该许可证信息的不同视图或报告。
尽管直接在源代码中提供许可证信息并不是开源软件的必要条件，但是这样做的实际好处显而易见。由于开源许可证促进了软件的传播，与代码一起传输的许可证信息简化了管理过程，即使代码接收人通过间接方式获得代码，也可以使他随时可以获得权限声明。
### 什么是许可证条款？
在源码树中嵌入许可证信息的价值被低估了。让我们暂停一下，反思一下这种常见做法是多么有用。
什么是许可证条款呢？ 对于许多开源软件来说，有一个简单的答案：一个许可证文本包含整个软件的所有许可证信息。但是开源的力量在于，它推动了其他开发者在这个起点之上进行构建，而这个过程会使许可证信息复杂化。
开源软件可以被扩展、再利用，或者与其他软件结合使用。与机械设备不同，不同群体之间的合作更具挑战性，复杂软件从许多人的工作中受益是切实可行的。开源许可证提供了促进这种开发动态的权限。具有复杂历史的软件也可能具有复杂的许可证信息。
考虑下面的例子：有人写了一个新的程序，在每个源文件中包含一个版权声明，声明该软件根据 Apache 2.0 版许可证进行许可，并且在源码树的根目录中包含 Apache 许可证文本。之后，添加了一个具有不同的版权声明的文件，以及一个 BSD 2 句版许可证副本的文件。然后，添加了一个新的子目录，其中文件具有 Apache 许可证声明，但具有标识不同版权所有者的版权声明。再之后，一个 MIT 许可证的副本添加到了新的子目录中，该子目录包含了版权声明与 MIT 许可证文件中相同的文件，但没有任何其他许可证指示信息。
这个例子表明，嵌入在源码树中的许可证信息可能很复杂而且很详细。根目录和/或各个子目录中都可能有许可证文本。一些源文件可能有许可证通知；其他源文件可能不会有。也许会有版权声明来识别各种版权所有者。但是，在不丢失信息的前提下将法律文本从代码中分离出来似乎是不可能的。因此，源代码即是许可证。
从源码树的角度来看，上面例子中对许可证信息的解释是非常简单的。但是，要在简单、明确的独立声明中获取许可证信息将是一件困难的事情。截取了源代码中所有许可证信息的许可证声明会比源代码更短，但这将是不方便的——谁会希望得到如此高度详细的单独声明？大多数用户可能会更喜欢一个概要，虽然不完整，但其获取的关键点符合自己的特定意图和敏感性要求。
### 用视图来概括许可证信息
对于“许可证条款是什么”这个问题，用整个源码树副本来回答可能没什么用，因为它过于庞杂和分散。大多数人只想要一个概要。但这面临一个挑战：当许可证信息比较复杂时，人们需要不同的概要，因为他们对于什么是重要的有不同的定义。
对于某些人来说，对以下问题回答“是”可能是足够的：该软件 1）是否根据一个或多个开源许可证获得许可，2）其被组装和许可后是否使得其分发和使用与所有这些许可证一致？ 其他人可能需要所有许可证的列表，或者他们可能想要查看哪个软件组件对应于哪个许可证。还有一些人可能想要一个逐个组件的列表来标识任何<ruby> 左版 <rp> （ </rp> <rt> copyleft </rt> <rp> ） </rp></ruby>许可证（也许自己要做深入的左版合规研究）。 有些人可能有兴趣看到所有版权声明和软件组件的相关列表。
单一的概要可能不会满足所有人的利益。简单地将概要具体化可能会减少它对一些人的效用，而对其他人则显得不足。因此，需要将源代码中包含的许可证信息展现为不同的<ruby> “视图” <rp> （ </rp> <rt> views </rt> <rp> ） </rp></ruby>。这里使用的“视图”术语可以视为与在数据库中使用它相似。或者，您也可以将“视图”看作是<ruby> “报告” <rp> （ </rp> <rt> reports </rt> <rp> ） </rp></ruby>。
考虑将源代码作为许可证有一个优势，并且可以从中提取多个不同的视图。
您可能会尝试创建一个“全能”概要，从中可以创建其他较短的概要。但是以中间状态表达许可证信息至少有三个缺点：
1. 时机：主概要的维护人员可能无法按计划进行更新。
2. 版本：主概要可能基于与您使用的软件不同的版本。
3. 质量：您的视图继承了主概要的错误和评判性。
因此，根据需要直接从您使用的源码树版本生成您的首选视图是有价值的。
有工具可以生成视图。按需视图的生成取决于工具。许可证信息展示的清晰（或混乱）程度会促进（或妨碍）该工具的功效。我们不需要许可证信息的特定机器编码，但是我们应该充分利用众多经验来源，以既可以被人读取，也可以被机器提取的方式来表达信息。
Jeff Kaufman 在他的文章《[开源软件许可证合规的经济高效模型](/article-8849-1.html)》中指出：由于源代码包含许可证信息，因此分发源代码是满足某些许可证要求的有效方式。
将所有许可证信息嵌入到源码树中是最佳实践。如果您发现源码树中没有显示许可证信息，请考虑通过提交错误报告来改进该项目，建议将该信息添加到源码树中。
源代码即是许可证。从完整的记录中，可以生成许可证信息的视图。工具可以将许可证信息提取到各种报告中，以满足特定需求或敏感性要求。
为了获得这个愿景的全部好处，我们还有工作要做。您对工具状态以及许可证信息展现有什么看法呢？
---
作者简介：Scott Peterson 是红帽公司法律团队成员。很久以前，一位工程师就一个叫做 GPL 的奇怪文件向 Scott 征询法律建议，这个致命的问题让 Scott 走上了探索包括技术标准和开源软件在内的协同开发法律问题的纠结之路。
译者简介：薛亮，集慧智佳知识产权咨询公司高级咨询师，擅长专利检索、专利分析、竞争对手跟踪、FTO分析、开源软件知识产权风险分析，致力于为互联网企业、高科技公司提供知识产权咨询服务。
|
||
为你的 Linux 应用创建 .desktop 文件
|
Ayo Isaiah
|
https://www.maketecheasier.com/create-desktop-file-linux/
|
在 Linux 中，一个 .desktop 文件就是一个用来运行程序的快捷方式。没有 .desktop 的话，你的应用就不会在应用菜单中显示了，也无法使用像 Synapse 和 Albert 这样的第三方启动起启动了。
|
/data/attachment/album/201801/03/153912ci5u5i0gisbgrkkr.jpg.thumb.jpg
|
/data/attachment/album/201801/03/153912ci5u5i0gisbgrkkr.jpg
| true | false | true |
lujun9972
| false |
[
"桌面",
"应用"
] |
桌面应用
|
{
"viewnum": 34849,
"commentnum": 2,
"favtimes": 3,
"sharetimes": 0,
"likes": 0
}
|
[
{
"postip": "211.102.192.66",
"message": "分享",
"username": "编程浪子 [Chrome 62.0|Windows 7]",
"date": "2018-01-05T11:05:45"
},
{
"postip": "118.167.103.140",
"message": "學到了！",
"username": "来自台湾的 Chrome 76.0|GNU/Linux 用户",
"date": "2019-10-08T15:28:32"
}
] |
[] |
在 Linux 中，一个 .desktop 文件就是一个用来运行程序的快捷方式。没有 .desktop 的话，你的应用就不会在应用菜单中显示了，也无法使用像 Synapse 和 Albert 这样的第三方启动起启动了。
| 2018-01-04T15:38:00 | 2018-01-04T15:38:00 | 9,199 |
/article-9199-1.html
|
在 Linux 中，一个 `.desktop` 文件就是一个用来运行程序的快捷方式。没有 `.desktop` 的话，你的应用就不会在应用菜单中显示了，也无法使用像 Synapse 和 Albert 这样的第三方启动起启动了。
大多数应用在安装后都会自动创建 `.desktop` 文件，并将自己放入应用菜单中以方便访问。然而，如果是你自己从源代码中编译的程序或者自己下载的压缩格式的应用，那就不会做这些事情了，每次你都需要打开终端来执行它的二进制文件。显然这个过程很无聊也很麻烦。
本文将会告诉你如何为应用创建 `.desktop` 文件，从而让你能在应用菜单中启动该应用。
**相关阅读**：[How to Add App Drawers to Unity Launcher in Ubuntu](https://www.maketecheasier.com/add-app-drawer-unity-launcher-ubuntu/ "How to Add App Drawers to Unity Launcher in Ubuntu")
### 如何创建桌面启动器
`.desktop` 文件基本上就是一个包含程序信息的纯文本文件，通常根据是自己可见还是所有用户可见的不同而放在 `~/.local/share/applications` 或者 `/usr/share/applications/` 目录中。你在文件管理器中访问这两个目录，都会看到很多系统中已安装应用对应的 `.desktop` 文件存在。
为了演示，我将会为 Super Tux Kart 创建一个 `.desktop` 文件，这是一个我很喜欢玩的卡丁车竞赛游戏。Ubuntu 仓库中带了这个游戏，但版本一般不新。
要获得最新的版本就需要下载 tar 包，解压并执行其中的游戏启动文件。
你可以仿照这个步骤来为任何程序创建启动器。
**注意**：下面步骤假设程序压缩包放在 “Downloads” 目录下。
1、跳转到存放压缩包的目录，右击然后选择 “Extract here”。
2、解压后，进入新创建的目录然后找到可执行的文件。之后右击文件选择 “Run” 来启动程序，确定程序运行正常。
3、有时候，你在右键菜单中找不到 “Run” 选项。这通常是因为这个可执行文件是一个文本文件。你可以在终端中执行它，如果你使用 GNOME 的话，可以点击上面菜单栏中的 Files 菜单，然后选择 “Preferences”。
4、选择 “Behavior” 标签页然后选择 “Executable Text Files” 下的 “Run them”。现在右击可执行文本文件后也能出现 “Run” 选项了。
5、确认应用运行正常后，就可以退出它了。然后运行你的文本编辑器并将下面内容粘贴到空文本文件中：
```
[Desktop Entry]
Encoding=UTF-8
Version=1.0
Type=Application
Terminal=false
Exec=/path/to/executable
Name=Name of Application
Icon=/path/to/icon
```
你需要更改 “Exec” 域的值为可执行文件的路径，并且将 “Name” 域的值改成应用的名称。大多数的程序都在压缩包中提供了一个图标，不要忘记把它也填上哦。在我们这个例子中，Super Tux Kart 的启动文件看起来是这样的：
6、将文件以 `application-name.desktop` 为名保存到 `~/.local/share/applications` 目录中。`.local` 目录位于你的家目录下，是一个隐藏目录，你需要启用 “Show Hidden Files” 模式才能看到它。如果你希望这个应用所有人都能访问，则在终端中运行下面命令：
```
sudo mv ~/.local/share/applications/<application-name`.desktop`> /usr/share/applications/
```
当然，别忘了把命令中的 `<application-name.desktop>` 改成真实的 `.desktop` 文件名。
7、完成后，打开应用菜单，就能看到应用出现在其中，可以使用了。
这个方法应该适用于所有主流的 Linux 操作系统。下面是另一张 Super Tux Kart 在 elementary OS 的应用启动器 (slingshot) 上的截图
如果你觉得本教程还有点用的话，欢迎留言。
---
via: <https://www.maketecheasier.com/create-desktop-file-linux/>
作者：[Ayo Isaiah](https://www.maketecheasier.com/author/ayoisaiah/) 译者：[lujun9972](https://github.com/lujun9972) 校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||
使用 ACL 设置用户访问指定文件/目录的权限
|
Magesh Maruthamuthu
|
https://www.2daygeek.com/how-to-configure-access-control-lists-acls-setfacl-getfacl-linux/
|
ACL 表示访问控制列表（Access Control List，ACL），它为文件系统提供了附加的、更具有弹性的权限机制。 它被设计来为补充 UNIX 文件权限机制。
|
/data/attachment/album/201801/03/162646rygbaqcx4c0ebycx.jpg.thumb.jpg
|
/data/attachment/album/201801/03/162646rygbaqcx4c0ebycx.jpg
| true | false | true |
lujun9972
| false |
[
"ACL",
"setfacl",
"chmod",
"getfacl"
] |
技术
|
{
"viewnum": 6064,
"commentnum": 0,
"favtimes": 1,
"sharetimes": 0,
"likes": 0
}
|
[] |
[
{
"raid": 9355,
"displayorder": 0
}
] |
ACL 表示访问控制列表（Access Control List，ACL），它为文件系统提供了附加的、更具有弹性的权限机制。 它被设计来为补充 UNIX 文件权限机制。
| 2018-01-05T09:10:00 | 2018-01-05T09:10:00 | 9,200 |
/article-9200-1.html
|
当提到文件和目录的权限时，你的第一反应可能是“属主/群组/其它”权限。 这些权限可以通过 `chmod`、 `chown` 等命令来修改。
文件和目录都有属主 (文件所有者 )、群组 (所属组) 以及其它权限，这些权限构成一个集合。 然而这些权限集合有它的局限性，无法做到为不同的用户设置不同的权限。
Linux 对文件和目录有以下默认权限。
* 文件 -> `644` -> `-rw-r-r-` （所有者有读写权限，组成员有只读权限， 其他人也只有读权限）
* 目录 -> `755` -> `drwxr-xr-x` （所有者有读、写和执行权限，组成员有读和执行的权限，其他人也有读和执行的权限）
比如： 默认情况下，所有者可以访问和编辑他们自己主目录中的文件， 也可以访问相关同组人的文件，但他们不能修改这些文件，因为组成员没有写权限，而且让组成员有写权限也是不明智的。 基于同样的原因，他/她也不能修改其他人的文件。 然而在某些情况下，多个用户想要修改同一个文件， 那该怎么办呢？
假设有个名叫 `magi` 的用户，他想要修改 `httpd.conf` 文件怎么办呢？ 这个文件是归 root 用户所有的，这样如何授权呢？ 为了解决这种情况，<ruby> 访问控制列表 <rt> Access Control List </rt></ruby>（ACL）诞生了。
### 什么是 ACL？
ACL 表示<ruby> 访问控制列表 <rt> Access Control List </rt></ruby>（ACL），它为文件系统提供了附加的、更具有弹性的权限机制。 它被设计来为补充 UNIX 文件权限机制。 ACL 允许你赋予任何某用户/组访问某项资源的权限。 `setfacl` 与 `getfacl` 命令会帮助你管理 ACL 而不会有任何麻烦。
### 什么是 setfacl？
`setfacl` 用于设置文件和目录的 ACL。
### 什么 getfacl？
`getfacl` - 获取文件的 ACL 。对于每个文件， `getfacl` 都会显示文件名、文件所有者、所属组以及ACL。 如果目录有默认 ACL， `getfacl` 也会显示这个默认的 ACL。
### 如何确认是否启用了 ACL？
运行 `tune2fs` 命令来检查是否启用了 ACL。
```
# tune2fs -l /dev/sdb1 | grep options
Default mount options: (none)
```
上面的输出很明显第说明 `/dev/sdb1` 分区没有启用 ACL。
如果结果中没有列出 `acl`，则你需要在挂载选项中加上 `acl`。 为了让它永久生效， 修改 `/etc/fstab` 中 `/app` 这一行成这样：
```
# more /etc/fstab
UUID=f304277d-1063-40a2-b9dc-8bcf30466a03 / ext4 defaults 1 1
/dev/sdb1 /app ext4 defaults，acl 1 1
```
或者，你也可以使用下面命令将其添加道文件系统的超级块中：
```
# tune2fs -o +acl /dev/sdb1
```
现在，通过运行以下命令来动态修改选项：
```
# mount -o remount,acl /app
```
再次运行 `tune2fs` 命令来看选项中是否有 `acl` 了：
```
# tune2fs -l /dev/sdb1 | grep options
Default mount options： acl
```
嗯，现在 `/dev/sdb1` 分区中有 ACL 选项了。
### 如何查看默认的 ACL 值
要查看文件和目录默认的 ACL 值，可以使用 `getfacl` 命令后面加上文件路径或者目录路径。 注意， 当你对非 ACL 文件/目录运行 `getfacl` 命令时， 则不会显示附加的 `user` 和 `mask` 参数值。
```
# getfacl /etc/apache2/apache2.conf
# file： etc/apache2/apache2.conf
# owner： root
# group： root
user::rw-
group::r--
other::r--
```
### 如何为文件设置 ACL
以下面格式运行 `setfacl` 命令可以为指定文件设置 ACL。在下面的例子中，我们会给 `magi` 用户对 `/etc/apache2/apache2.conf` 文件 `rwx` 的权限。
```
# setfacl -m u:magi:rwx /etc/apache2/apache2.conf
```
**仔细分析起来：**
* `setfacl`： 命令
* `-m`： 修改文件的当前 ACL
* `u`： 指明用户
* `magi`： 用户名
* `rwx`： 要设置的权限
* `/etc/apache2/apache2.conf`： 文件名称
再查看一次新的 ACL 值：
```
# getfacl /etc/apache2/apache2.conf
# file： etc/apache2/apache2.conf
# owner： root
# group： root
user::rw-
user:magi:rwx
group::r--
mask::rwx
other::r--
```
注意： 若你发现文件或目录权限后面有一个加号（`+`），就表示设置了 ACL。
```
# ls -lh /etc/apache2/apache2.conf
-rw-rwxr--+ 1 root root 7.1K Sep 19 14:58 /etc/apache2/apache2.conf
```
### 如何为目录设置 ACL
以下面格式运行 `setfacl` 命令可以递归地为指定目录设置 ACL。在下面的例子中，我们会将 `/etc/apache2/sites-available/` 目录中的 `rwx` 权限赋予 `magi` 用户。
```
# setfacl -Rm u:magi:rwx /etc/apache2/sites-available/
```
**其中：**
* `-R`： 递归到子目录中
再次查看一下新的 ACL 值。
```
# getfacl /etc/apache2/sites-available/
# file： etc/apache2/sites-available/
# owner： root
# group： root
user::rwx
user:magi:rwx
group::r-x
mask::rwx
other::r-x
```
现在 `/etc/apache2/sites-available/` 中的文件和目录都设置了 ACL。
```
# ls -lh /etc/apache2/sites-available/
total 20K
-rw-rwxr--+ 1 root root 1.4K Sep 19 14:56 000-default.conf
-rw-rwxr--+ 1 root root 6.2K Sep 19 14:56 default-ssl.conf
-rw-rwxr--+ 1 root root 1.4K Dec 8 02:57 mywebpage.com.conf
-rw-rwxr--+ 1 root root 1.4K Dec 7 19:07 testpage.com.conf
```
### 如何为组设置 ACL
以下面格式为指定文件运行 `setfacl` 命令。在下面的例子中，我们会给 `appdev` 组赋予 `/etc/apache2/apache2.conf` 文件的 `rwx` 权限。
```
# setfacl -m g:appdev:rwx /etc/apache2/apache2.conf
```
**其中：**
* `g`： 指明一个组
对多个用户和组授权，只需要用 `逗号` 区分开，就像下面这样。
```
# setfacl -m u:magi:rwx,g:appdev:rwx /etc/apache2/apache2.conf
```
### 如何删除 ACL
以下面格式运行 `setfacl` 命令会删除文件对指定用户的 ACL。这只会删除用户权限而保留 `mask` 的值为只读。
```
# setfacl -x u:magi /etc/apache2/apache2.conf
```
**其中：**
* `-x`： 从文件的 ACL 中删除
再次查看 ACL 值。在下面的输出中我们可以看到 `mask` 的值是读。
```
# getfacl /etc/apache2/apache2.conf
# file： etc/apache2/apache2.conf
# owner： root
# group： root
user::rw-
group::r--
mask::r--
other::r--
```
使用 `-b` 来删除文件中所有的 ACL。
```
# setfacl -b /etc/apache2/apache2.conf
```
**其中：**
* `-b`： 删除所有的 ACL 条目
再次查看删掉后的 ACl 值就会发现所有的东西都不见了，包括 `mask` 的值也不见了。
```
# getfacl /etc/apache2/apache2.conf
# file： etc/apache2/apache2.conf
# owner： root
# group： root
user::rw-
group::r--
other::r--
```
### 如何备份并还原 ACL
下面命令可以备份和还原 ACL 的值。要制作备份， 需要进入对应的目录然后这样做（假设我们要备份 `sites-available` 目录中的 ACL 值)。
```
# cd /etc/apache2/sites-available/
# getfacl -R * > acl_backup_for_folder
```
还原的话，则运行下面命令：
```
# setfacl --restore=/etc/apache2/sites-available/acl_backup_for_folder
```
---
via: <https://www.2daygeek.com/how-to-configure-access-control-lists-acls-setfacl-getfacl-linux/>
作者：[Magesh Maruthamuthu](https://www.2daygeek.com) 译者：[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.